前言

学期初爽学一次Java，学期末再爽学一次Java😋

参考：

https://drun1baby.top/2023/12/07/Jackson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%EF%BC%88%E4%B8%80%EF%BC%89%E6%BC%8F%E6%B4%9E%E5%8E%9F%E7%90%86/#0x01-Jackson-%E5%9F%BA%E6%9C%AC%E4%BD%BF%E7%94%A8

https://boogipop.com/2023/06/20/Jackson%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E9%80%9A%E6%9D%80Web%E9%A2%98/

https://zer0peach.github.io/2023/09/27/Jackson/

---

Jackson基本使用

Jackson 是一个开源的Java序列化和反序列化工具，可以将 Java 对象序列化为 XML 或 JSON 格式的字符串，以及将 XML 或 JSON 格式的字符串反序列化为 Java 对象。

由于其使用简单，速度较快，且不依靠除 JDK 外的其他库，被众多用户所使用。

pom.xml

<dependencies>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.8</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.8</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.8</version>
    </dependency>
</dependencies>

序列化与反序列化

定义一个 Person 类

public class Person {
    public int age;
    public String name;

    @Override
    public String toString() {
        return String.format("Person.age=%d, Person.name=%s", age, name);
    }
}

接着编写 Jackson 的序列化与反序列化代码

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTest {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.age = 6;
        p.name = "0w0";
        ObjectMapper mapper = new ObjectMapper();

        String json = mapper.writeValueAsString(p);
        System.out.println(json);

        Person p2 = mapper.readValue(json, Person.class);
        System.out.println(p2);
    }
}

那么这里序列化的方法为ObjectMapper.writeValueAsString，反序列化的方法为ObjectMapper.readValue

---

多态问题

Java 多态指同一个接口使用不同的实例而执行不同的操作

那么对于反序列化来说就会有一个问题，对多态类的某一个子类实例在序列化后再进行反序列化时，如何能够保证反序列化出来的实例即是我们想要的那个特定子类的实例而非多态类的其他子类实例？

Jackson 实现了 JacksonPolymorphicDeserialization 机制来解决这个问题：在反序列化某个类对象的过程中，如果类的成员变量不是具体类型（non-concrete），比如 Object、接口或抽象类，则可以在 JSON 字符串中指定其具体类型，Jackson 将生成具体类型的实例

具体的操作：启用 DefaultTyping 和 @JsonTypeInfo 注解

DefaultTyping

在 ObjectMapper 中有详细介绍

实际上四个选项是依次扩大作用范围的：

DefaultTyping类型	描述说明
JAVA_LANG_OBJECT	属性的类型为Object
OBJECT_AND_NON_CONCRETE	属性的类型为Object、Interface、AbstractClass
NON_CONCRETE_AND_ARRAYS	属性的类型为Object、Interface、AbstractClass、Array
NON_FINAL	所有除了声明为final之外的属性

JAVA_LANG_OBJECT

当被序列化或反序列化的类里的属性被声明为一个 Object 类型时，会对该 Object 类型的属性进行序列化和反序列化，并且明确规定类名。（当然，这个 Object 本身也得是一个可被序列化的类）

添加一个 Hacker 类

public class Hacker {
    public String skill = "havefun";
}

修改 Person 类，添加 Object 类型属性：

public class Person {
    public int age;
    public String name;
    public Object object;

    @Override
    public String toString() {
        return String.format("Person.age=%d, Person.name=%s, %s", age, name, object == null ? "null" : object);
    }
}

新建 JAVA_LANG_OBJECTTest.java，添加 enableDefaultTyping() 并设置为 JAVA_LANG_OBJECT：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JAVA_LANG_OBJECTTest {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.age = 6;
        p.name = "0w0";
        p.object = new Hacker();
        ObjectMapper mapper = new ObjectMapper();
        // 设置JAVA_LANG_OBJECT  
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.JAVA_LANG_OBJECT);

        String json = mapper.writeValueAsString(p);
        System.out.println(json);

        Person p2 = mapper.readValue(json, Person.class);
        System.out.println(p2);
    }
}

无 DefaultTyping 的情况是：

对比可以看出来，通过 enableDefaultTyping 设置 JAVA_LANG_OBJECT 后，会多输出 Hacker 类名，且在输出的 Object 属性时直接输出的是 Hacker 类对象

也就是说对 Object 对象进行了序列化和反序列化，并且明确规定类名

---

OBJECT_AND_NON_CONCRETE

enableDefaultTyping 无参数时的默认选项。除了前面提到的特征，当类里有Interface、AbstractClass类时，对其进行序列化和反序列化。

整一个 Sex 接口

public interface Sex {
    public void setSex(int sex);
    public int getSex();
}

然后实现它

public class MySex implements Sex {
    int sex;

    @Override
    public int getSex() {
        return sex;
    }

    @Override
    public void setSex(int sex) {
        this.sex = sex;
    }
}

修改 Person 类

public class Person {  
    public int age;  
    public String name;  
    public Object object;  
    public Sex sex;  
  
    @Override  
    public String toString() {  
        return String.format("Person.age=%d, Person.name=%s, %s, %s", age, name, object == null ? "null" : object, sex == null ? "null" : sex);  
    }  
}

序列化和反序列化：

import com.fasterxml.jackson.databind.ObjectMapper;

public class OBJECT_AND_NON_CONCRETE_Test {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.age = 6;
        p.name = "0w0";
        p.object = new Hacker();
        p.sex = new MySex();
        ObjectMapper mapper = new ObjectMapper();
        // 设置OBJECT_AND_NON_CONCRETE  
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
        // 或直接无参调用，输出一样  
        //mapper.enableDefaultTyping();  

        String json = mapper.writeValueAsString(p);
        System.out.println(json);

        Person p2 = mapper.readValue(json, Person.class);
        System.out.println(p2);
    }
}

输出：可以看到该 Interface 类被序列化和反序列化

{"age":6,"name":"0w0","object":["Hacker",{"skill":"havefun"}],"sex":["MySex",{"sex":0}]}
Person.age=6, Person.name=0w0, Hacker@42dafa95, MySex@6500df86

---

NON_CONCRETE_AND_ARRAYS

除了前面提到的特征外，还支持 Array 类型

于是给 Object 以 Hacker 类型数组：

import com.fasterxml.jackson.databind.ObjectMapper;  
  
public class NON_CONCRETE_AND_ARRAYS_Test {  
    public static void main(String[] args) throws Exception {  
        Person p = new Person();  
        p.age = 6;  
        p.name = "0w0";  
        Hacker[] hackers = new Hacker[2];  
        hackers[0] = new Hacker();  
        hackers[1] = new Hacker();  
        p.object = hackers;  
        p.sex = new MySex();  
        ObjectMapper mapper = new ObjectMapper();  
        // 设置NON_CONCRETE_AND_ARRAYS  
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_CONCRETE_AND_ARRAYS);  
  
        String json = mapper.writeValueAsString(p);  
        System.out.println(json);  
  
        Person p2 = mapper.readValue(json, Person.class);  
        System.out.println(p2);  
    }  
}

输出：

{"age":6,"name":"0w0","object":["[LHacker;",[{"skill":"havefun"},{"skill":"havefun"}]],"sex":["MySex",{"sex":0}]}
Person.age=6, Person.name=0w0, [LHacker;@5cb9f472, MySex@cb644e

类名变成了 "[L"+类名+";"

---

NON_FINAL

除了前面的所有特征外，包含即将被序列化的类里的全部、非 final 的属性，也就是相当于整个类、除 final 外的属性信息都需要被序列化和反序列化

给 Person 加上 Hacker 属性

public class Person {  
    public int age;  
    public String name;  
    public Object object;  
    public Sex sex;  
    public Hacker hacker;  
  
    @Override  
    public String toString() {  
        return String.format("Person.age=%d, Person.name=%s, %s, %s, %s", age, name, object == null ? "null" : object, sex == null ? "null" : sex, hacker == null ? "null" : hacker);  
    }  
}

序列化与反序列化：

import com.fasterxml.jackson.databind.ObjectMapper;

public class NON_FINAL_Test {
    public static void main(String[] args) throws Exception {
        Person p = new Person();
        p.age = 6;
        p.name = "0w0";
        p.object = new Hacker();
        p.sex = new MySex();
        p.hacker = new Hacker();
        ObjectMapper mapper = new ObjectMapper();
        // 设置NON_FINAL  
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        String json = mapper.writeValueAsString(p);
        System.out.println(json);

        Person p2 = mapper.readValue(json, Person.class);
        System.out.println(p2);
    }
}

输出：

["Person",{"age":6,"name":"0w0","object":["Hacker",{"skill":"havefun"}],"sex":["MySex",{"sex":0}],"hacker":["Hacker",{"skill":"havefun"}]}]
Person.age=6, Person.name=0w0, Hacker@42dafa95, MySex@6500df86, Hacker@402a079c

成功对非 final 的 hacker 属性进行序列化和反序列化

---

@JsonTypeInfo 注解

@JsonTypeInfo 注解是 Jackson 多态类型绑定的一种方式，支持下面5种类型的取值：

@JsonTypeInfo(use = JsonTypeInfo.Id.NONE)  
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)  
@JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS)  
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME)  
@JsonTypeInfo(use = JsonTypeInfo.Id.CUSTOM)

JsonTypeInfo.Id.NONE

默认设置

JsonTypeInfo.Id.CLASS

起一个 User 类，把 Hacker 类移到 com.example 下，指定注解

package com.example;

import com.fasterxml.jackson.annotation.JsonTypeInfo;

public class User {
    public String username;
    public String password;

    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME)
    public Object object;

    @Override
    public String toString() {
        return "com.example.User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", object=" + object +
                '}';
    }
}

然后序列化和反序列化：

import com.example.Hacker;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonTypeInfo_Id_NONE_Test {
    public static void main(String[] args) throws Exception {
        User u = new User();
        u.username = "0w0";
        u.password = "******";
        u.object = new Hacker();
        ObjectMapper mapper = new ObjectMapper();

        String json = mapper.writeValueAsString(u);
        System.out.println(json);

        User u2 = mapper.readValue(json, User.class);
        System.out.println(u2);
    }
}

输出：

{"username":"0w0","password":"******","object":{"@class":"com.example.Hacker","skill":"havefun"}}
User{username='0w0', password='******', object=com.example.Hacker@25bbe1b6}

相比 NONE 注解时，object 属性中多了 "@class":"com.example.Hacker"，即含有具体的类的信息，同时反序列化出来了 object 属性 Hacker 类对象，即能够成功对指定类型进行序列化和反序列化

也就是说，在Jackson反序列化的时候如果使用了JsonTypeInfo.Id.CLASS修饰的话，可以通过 @class 的方式指定相关类，并进行相关调用

---

JsonTypeInfo.Id.MINIMAL_CLASS

修改注解值为JsonTypeInfo.Id.MINIMAL_CLASS

输出：

{"username":"0w0","password":"******","object":{"@c":"com.example.Hacker","skill":"havefun"}}
User{username='0w0', password='******', object=com.example.Hacker@69ea3742}

object属性中 "@c":"com.example.Hacker"，即使用 @c 替代了 @class

官方描述中的意思是缩短了相关类名，实际效果和 JsonTypeInfo.Id.CLASS 类似

---

JsonTypeInfo.Id.NAME

修改注解值为JsonTypeInfo.Id.NAME

输出：

object属性中"@type":"Hacker"，乍一看没什么问题，但实际上没有具体的包名在内的类名，因此在后面的反序列化的时候会报错，也就是说这个设置值是不能被反序列化利用的

---

JsonTypeInfo.Id.CUSTOM

直接运行会抛出异常，需要用户自定义来使用

那么可触发反序列化的注解就两个：

• JsonTypeInfo.Id.CLASS
• JsonTypeInfo.Id.MINIMAL_CLASS

---

反序列化中类属性方法的调用

整个 User2 类，加上 setter 和 getter

public class User2 {
    private String name;
    private int age;

    public User2() {
        System.out.println("构造方法");
    }

    public User2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        System.out.println("getname");
        return name;
    }

    public void setName(String name) {
        System.out.println("setname");
        this.name = name;
    }

    public int getAge() {
        System.out.println("getage");
        return age;
    }

    public void setAge(int age) {
        System.out.println("setage");
        this.age = age;
    }
}

序列化与反序列化：

import com.fasterxml.jackson.databind.ObjectMapper;

public class DeserializationTest {
    public static void main(String[] args) throws Exception {
        User2 test = new User2("0w0", 16);
        ObjectMapper mapper = new ObjectMapper();

        String json = mapper.writeValueAsString(test);
        System.out.println(json);

        User2 u2 = mapper.readValue(json, User2.class);
        System.out.println(u2);
    }
}

可以看到序列化会调用 getter，而反序列化会调用构造方法和 setter，和 fastjson 类似

---

Jackson反序列化漏洞demo

满足下面三个条件之一即存在 Jackson 反序列化漏洞：

• 调用了 ObjectMapper.enableDefaultTyping() 函数；
• 对要进行反序列化的类的属性使用了值为 JsonTypeInfo.Id.CLASS 的 @JsonTypeInfo 注解；
• 对要进行反序列化的类的属性使用了值为 JsonTypeInfo.Id.MINIMAL_CLASS 的 @JsonTypeInfo 注解；

由之前的结论知道，当使用的 JacksonPolymorphicDeserialization 机制配置有问题时，Jackson 反序列化就会调用属性所属类的构造函数和 setter 方法。

而如果该构造函数或 setter 方法存在危险操作，那么就存在 Jackson 反序列化漏洞。

属性不为Object类时

当要进行反序列化的类的属性所属类的构造函数或 setter 方法本身存在漏洞时，这种场景存在 Jackson 反序列化漏洞，实际场景几乎不可能存在这种好事

直接修改 MySex 类的 setSex ()方法，在其中添加命令执行操作

public class MySex implements Sex {
    int sex;
    public MySex() {
        System.out.println("MySex构造函数");
    }
    @Override
    public int getSex() {
        System.out.println("MySex.getSex");
        return sex;
    }

    @Override
    public void setSex(int sex) {
        System.out.println("MySex.setSex");
        this.sex = sex;

        try {
            Runtime.getRuntime().exec("calc");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Person3类

public class Person3 {
    public int age;
    public String name;
    public Sex sex;

    @Override
    public String toString() {
        return String.format("Person.age=%d, Person.name=%s, %s", age, name, sex == null ? "null" : sex);
    }
}

编写反序列化类，构造 Payload

public class DeserializationRun {  
    public static void main(String[] args) throws Exception {  
        ObjectMapper mapper = new ObjectMapper();  
        mapper.enableDefaultTyping();  
  
        String json = "{\"age\":16,\"name\":\"0w0\",\"sex\":[\"MySex\",{\"sex\":1}]}";  
        Person3 p2 = mapper.readValue(json, Person3.class);  
        System.out.println(p2);  
  
    }  
}

---

属性为Object类时

当属性类型为 Object 时，因为 Object 类型是任意类型的父类，因此扩大了我们的攻击面，我们只需要寻找出在目标服务端环境中存在的且构造函数或 setter 方法存在漏洞代码的类即可进行攻击利用。

Evil：

public class Evil {
    String cmd;

    public void setCmd(String cmd) {
        this.cmd = cmd;
        try {
            Runtime.getRuntime().exec(this.cmd);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Person4：

import com.fasterxml.jackson.annotation.JsonTypeInfo;

public class Person4 {
    public int age;
    public String name;
    // @JsonTypeInfo(use = JsonTypeInfo.Id.CLASS)
    // 或 @JsonTypeInfo(use = JsonTypeInfo.Id.MINIMAL_CLASS)
    public Object object;

    public Person4() {
        System.out.println("Person4 构造函数");
    }

    public void setAge(int age) {
        System.out.println("Person4 setter 函数");
    }

    @Override
    public String toString() {
        return String.format("Person.age=%d, Person.name=%s, %s", age, name, object == null ? "null" : object);
    }
}

反序列化代码：

import com.fasterxml.jackson.databind.ObjectMapper;

public class DeserializationObjectRun {

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.enableDefaultTyping();

        String json = "{\"age\":16,\"name\":\"0w0\",\"object\":[\"Evil\",{\"cmd\":\"calc\"}]}";
        Person4 p2 = mapper.readValue(json, Person4.class);
        System.out.println(p2);

    }
}