Prefacio:

Este artículo se basa en el artículo anterior, después de aprender y comprender los conceptos básicos de las vulnerabilidades de deserialización de Java, ahora comience la implementación del código del entorno de vulnerabilidad.

2. Configuración del proyecto

escriba application.properties

spring.thymeleaf.prefix = classpath:/templates/

Dependencias relacionadas con la importación de pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>java_Deserialization</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>java_Deserialization</name>
    <description>java_Deserialization</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

        <!-- springboot 热部署 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <configuration>
                    <!-- 防止二进制文件被编译 -->
                    <nonFilteredFileExtensions>
                        <nonFilteredFileExtension>dat</nonFilteredFileExtension>
                        <nonFilteredFileExtension>swf</nonFilteredFileExtension>
                        <nonFilteredFileExtension>xml</nonFilteredFileExtension>
                    </nonFilteredFileExtensions>
                </configuration>
            </plugin>
        </plugins>

    </build>

</project>

3. Escriba el código de back-end "vulnerabilidad de deserialización de Java"

La vulnerabilidad de deserialización de java puede ser más difícil de reproducir que la inyección de sql, y la cantidad de código será un poco más

El primero es averiguar qué tipo de entorno de vulnerabilidad construir. Después de buscar información relevante por sí mismo, considerando su propia capacidad y tiempo y otros problemas, después de discutir con los miembros del equipo, se decide usar la auditoría de código y finalmente enviar una bandera para lograr anti-java El propósito del entrenamiento de las vulnerabilidades de serialización.

Para completar este experimento de vulnerabilidad y obtener la bandera, el usuario debe comprender primero el código de serialización de Java y, al mismo tiempo, puede escribir el código de deserialización de acuerdo con el código de serialización dado y luego obtener la bandera.

De acuerdo con las ideas anteriores, algunos de los códigos fuente escritos son los siguientes:

java_deser.java

package com.example.java_deserialization.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Optional;

@Controller
public class java_deser {
    
    
    @RequestMapping("/java_deser")
    public void java_derser_start(String flag){
    
    
        flag Flag = new flag("1234abc");//flag
        System.out.println("被序列化对象："+Flag.toString());
        //将对象转换为二进制字节数组(序列化)
        Optional<byte[]> bytes = ByteArrayUtils.objectToBytes(Flag);
        
        System.out.println(bytes);
        
        byte[] ret = bytes.get();
        //序列化后的反序列化是新的对象
        String r1 = ByteArrayUtils.toHexString(ret);
        
        System.out.println("序列化后转换字节数组-16进制表示："+r1);
    }
}

indexController.java

package com.example.java_deserialization.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class indexController {
    
    
    @RequestMapping(value={
    
    "/","/index.html"})
    public String index(){
    
    
        return "index";
    }

    @RequestMapping(value={
    
    "/java_deser_index"})
    public String index_java_deser(){
    
    
        return "java_deser";
    }
}

Pruebe la serialización y deserialización de Java, el archivo de codificación test.java

package com.example.java_deserialization.controller;

import java.io.*;
import java.util.Base64;

public class test {
    
    
    /**
     * 字符串转换成为16进制(无需Unicode编码)
     * @param str
     * @return
     */
    public static String str2HexStr(String str) {
    
    
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
    
    
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
            // sb.append(' ');
        }
        return sb.toString().trim();
    }

    /**
     * 16进制直接转换成为字符串(无需Unicode解码)
     * @param hexStr
     * @return
     */
    public static String hexStr2Str(String hexStr) {
    
    
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
    
    
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
        //Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray());
    }

    public static void main(String[] args) throws IOException {
    
    
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object_hex.txt"));
        //将对象序列化到文件s
        java_DeserializationController person = new java_DeserializationController("flag{0123abcd}", 23);
        oos.writeObject(person);

        //读取文件
        FileInputStream fis = null;

        File file = new File("object_hex.txt");
        fis = new FileInputStream(file);
        byte[] b = new byte[(int)file.length()];
        while (fis.read(b) != -1) {
    
    
        }
        System.out.println(new String(b));

        String hexStr = test.str2HexStr(new String(b));
        System.out.println(hexStr);
        System.out.println(test.hexStr2Str(hexStr));

        //写入文件
        String data =test.hexStr2Str(hexStr);

        File file1 =new File("object_hex1.txt");

        //if file doesnt exists, then create it
        if(!file1.exists()){
    
    
            file1.createNewFile();
        }

        //true = append file
        FileWriter fileWritter = new FileWriter(file1.getName(),true);
        fileWritter.write(data);
        fileWritter.close();
    }

}

4. Escriba el código de front-end "vulnerabilidad de deserialización de Java"

index.html: utilizado como interfaz principal, haga clic para saltar a la interfaz del entorno de vulnerabilidad de deserialización de Java

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>java序列化与反序列化</title>
</head>
<body>
<input type="button" value="java反序列化"
       onclick="javascrtpt:window.location.href='http://localhost:8080/java_deser'" />
</body>
</html>

java_deser.html: interfaz de vulnerabilidad de deserialización de Java, puede ver el código fuente, enviar el indicador y ver la respuesta.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>java反序列化</title>
</head>
<body>

<p>
    java反序列化漏洞（源码分析），部分序列化代码如下：
</p>

<input type="button" value="点击执行java序列化代码"
       onclick="javascrtpt:window.location.href='http://localhost:8080/java_deser'" />

<p>
    序列化后转化为字符数组形式，16进制表示为：
    （你需要自己编写代码，把该序列化后的字符反序列化，即可得到flag）
</p>

<form action="http://localhost:8080/java_deser_test" method="get">
    输入flag: <input type="text" name="id" />
    <input type="submit" value="提交" />
</form>


<form action="http://localhost:8080/answer_code" method="get">
    （没做出来的话）输入序列化后的16进制形式，查看答案: <input type="text" name="id" />
    <input type="submit" value="查看" />
</form>

</body>
</html>

answer_code.java: código de consulta de respuesta

package com.example.java_deserialization.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class answer_code {
    
    
    @RequestMapping("/answer_code")
    public void answer_mathod(@RequestParam(value = "id",required = false) String r1, Model model){
    
    
        byte[] r2 = ByteArrayUtils.toByteArray(r1);

        flag Flag1 = (flag) ByteArrayUtils.bytesToObject(r2).get();
        System.out.println("反序列化后对象："+Flag1.toString());
    }
}