java学习之zip炸弹攻击

一、概述

Zip炸弹是一种特殊类型的Zip文件，它包含了大量的无用数据。Zip文件格式允许使用压缩算法来减小文件的大小，但是如果Zip文件中的某些内容被重复压缩，就会导致文件大小急剧增加。Zip炸弹利用这个特性，将一些无用的数据多次压缩到一个Zip文件中，从而生成一个极其庞大的文件。

当服务器尝试解压缩这个Zip文件时，它需要解压缩所有的内容。由于Zip炸弹中包含了大量的重复数据，这可能会导致服务器耗尽所有的内存和CPU资源，从而导致服务器崩溃或拒绝服务攻击

Zip 炸弹的大致原理是 zip 炸弹文件中有大量刻意重复的数据，这种重复数据在压缩的时候是可以被丢弃的，这也就是压缩后的文件其实并不大的原因。最为典型的 Zip 炸弹就是 42.zip，一个 42KB 的文件，解压完其实是个 4.5 PB（1 PB=1024 TB）的“炸弹”，详细原理可参见：A better zip bomb

二、工具演示

github上有制作zip炸弹的现成项目：https://github.com/CreeperKong/zipbomb-generator

脚本使用方式：（使用python3）

python zipbomb.py --mode=quoted_overlap --num-files=1 --compressed-size=3999999 > test.zip

--num-files 表示压缩包内文件数目

--compressed-size 表示压缩后大小

如果开始的时候num_files增大的话，其实解压后大小会成倍增加；所以如果服务器接收客户端传过来的zip文件直接进行解压缩而不校验文件夹内部文件的大小的话，将会引发zip炸弹从而耗尽服务器资源，形成Dos攻击。

三、漏洞代码演示

漏洞代码1：（文件名及大小未限制】

ZipBombvul.java

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

public class ZipBombVul {
    // 定义缓冲区大小为512字节
    static final int BUFFER = 512;

    // 解压方法，接收一个文件名作为参数
    public final void unzip(String fileName) throws java.io.IOException {
        // 创建文件输入流对象，读取压缩文件
        FileInputStream fis = new FileInputStream(fileName);
        // 创建压缩输入流对象，用于读取压缩文件中的条目
        ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
        ZipEntry entry;

        // 循环遍历压缩文件中的每个条目
        while ((entry = zis.getNextEntry()) != null) {
            // 打印当前正在解压的条目名
            System.out.println("Extracting:" + entry);

            // 定义变量用于读取数据的计数
            int count;
            // 创建字节数组，用于临时存储读取的数据
            byte data[] = new byte[BUFFER];

            // 创建文件输出流对象，将解压后的文件写入磁盘，文件名使用条目的名字
            FileOutputStream fos = new FileOutputStream(entry.getName());
            // 创建缓冲输出流对象，提高写入性能
            BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);

            // 循环读取压缩文件中的数据，并写入到解压后的文件中
            while ((count = zis.read(data, 0, BUFFER)) != -1) {
                dest.write(data, 0, count);
            }

            // 刷新缓冲区，确保所有数据都被写入磁盘
            dest.flush();
            // 关闭缓冲输出流
            dest.close();
            // 关闭当前条目的压缩流
            zis.closeEntry();
        }

        // 关闭压缩输入流
        zis.close();
    }


}

bombTest.java

import java.io.IOException;

public class bombTest {
    public static void main(String[] args) throws IOException {
        ZipBombVul  bombvul = new ZipBombVul();
        String filename = "./src/test.zip";//要解压的文件名
        bombvul.unzip(filename);

    }
}

运行上述生成的解压代码，磁盘以及内存利用率升高

路径穿越代码演示：

zipBomb.java

import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class zipBomb {
    public static void main(String[] args) {
        try {
            // 创建一个Zip输出流
            FileOutputStream fos = new FileOutputStream("zip_bomb2.zip");
            ZipOutputStream zos = new ZipOutputStream(fos);

            // 添加大量的重复文件
            for (int i = 0; i < 2; i++) {
                //生成自定义的文件名，做路径穿越测试
                String fileName = "../" + i + ".txt";
                ZipEntry entry = new ZipEntry(fileName);
                zos.putNextEntry(entry);
                // 写入大量的重复数据（10MB）
                byte[] data = new byte[10 * 1024 * 1024];
                zos.write(data);
                zos.closeEntry();
            }

            // 关闭Zip输出流
            zos.close();
            System.out.println("Zip bomb created successfully!");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

漏洞代码2（错误的修复：使用getSize()方法）

zipbombVul.java

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public static final int BUFFER = 512; // 定义缓冲区大小为 512 字节
public static final int TOOBIG = 0x6400000; // 最大文件大小为 100MB

public final void unzip(String filename) throws java.io.IOException {
    // 打开要解压的文件
    FileInputStream fis = new FileInputStream(filename);
    // 创建 ZipInputStream 对象，用于读取 Zip 文件
    ZipInputStream zis = new ZipInputStream(new BufferedInputStream(fis));
    ZipEntry entry;
    try {
        // 循环遍历 Zip 文件中的每个条目
        while ((entry = zis.getNextEntry()) != null) {
            // 打印当前正在解压的条目
            System.out.println("Extracting: " + entry);
            int count;
            byte data[] = new byte[BUFFER]; // 创建缓冲区数组，用于读取数据
            // 如果文件过大，抛出异常
            if (entry.getSize() > TOOBIG) {
                throw new IllegalStateException("File to be unzipped is huge.");
            }
            // 如果文件大小为 -1，可能是一个巨大的文件，抛出异常
            if (entry.getSize() == -1) {
                throw new IllegalStateException("File to be unzipped might be huge.");
            }
            // 创建文件输出流，准备将解压后的数据写入磁盘
            FileOutputStream fos = new FileOutputStream(entry.getName());
            BufferedOutputStream dest = new BufferedOutputStream(fos, BUFFER);
            // 读取并写入数据，直到文件结束
            while ((count = zis.read(data, 0, BUFFER)) != -1) {
                dest.write(data, 0, count);
            }
            // 刷新并关闭输出流
            dest.flush();
            dest.close();
            // 关闭当前 ZipEntry 条目
            zis.closeEntry();
        }
    } finally {
        // 最终关闭 ZipInputStream
        zis.close();
    }
}

上述代码中，使用了getsize获取压缩包中文件条目大小

压缩大小（compressed size）指的是文件在压缩包内的大小，也就是文件被压缩后的大小。未压缩大小（uncompressed size）指的是文件在解压缩后的大小，即原始文件的大小。在 Java 中，ZipEntry 中的 getSize 方法获取的是未压缩大小，而 setCompressedSize 方法用于设置压缩大小。

举个例子，假设有一个 1MB 大小的文件，在将其添加到 ZIP 压缩包时，可以选择是否对该文件进行压缩。如果选择进行压缩，该文件在 ZIP 压缩包内的大小可能会减小到 500KB（假设压缩比是 50%）。在这种情况下，文件的压缩大小就是 500KB，而未压缩大小仍然是 1MB。

虽然这里使用getsize判断文件大小，但是实际上可以伪造ZIP文件中用来描述解压条目大小的字段，因此，getSize()方法的返回值是不可靠的，本地资源实际仍可能被过度消耗

绕过步骤：

下载用于修改二进制文件的 010editor 软件，安装后打开上面演示用的 Zip包，修改其中属性值

现在去解压，就不会报文件太大的错误了

值得注意的是，从上述截图也可以看到修改了 zip 文件的 frUncompressedsize 字段的值以后，解压缩 zip 文件会报错，如果直接使用 7-zip 进行解压缩的话有报错但是可以提取文件

但是通过实践也可以看到，通过上述 Java 代码可成功解压缩出来目标文件，这样子的话就不影响我们通过修改 zip 文件的 frUncompressedsize 字段的值，制作 zip 炸弹绕过服务端的文件大小校验检测，完成攻击利用。

小结：这个错误示例调用ZipEntry.getSize()方法在解压提取一个条目之前判断其大小，以试图解决之前的问题。但不幸的是，恶意攻击者可以伪造ZIP文件中用来描述解压条目大小的字段，因此，getSize()方法的返回值是不可靠的，本地资源实际仍可能被过度消耗；同时依旧没有检测文件名。

四、安全编码

参照《OpenHarmony-Java-secure-coding-guide》

private static final long MAX_FILE_COUNT = 100L;
private static final long MAX_TOTAL_FILE_SIZE = 1024L * 1024L;

...

public void unzip(FileInputStream zipFileInputStream, String dir) throws IOException {
    long fileCount = 0;
    long totalFileSize = 0;

    try (ZipInputStream zis = new ZipInputStream(zipFileInputStream)) {
        ZipEntry entry;
        String entryName;
        String entryFilePath;
        File entryFile;
        byte[] buf = new byte[10240];
        int length;

        while ((entry = zis.getNextEntry()) != null) {
            entryName = entry.getName();
            //检验文件名合法性
            entryFilePath = sanitizeFileName(entryName, dir);
            entryFile = new File(entryFilePath);
            
            //判断条目是否是目录
            if (entry.isDirectory()) {
                creatDir(entryFile);
                continue;
            }
            
            //文件数+1，比较文件数是否大于指定的最大条目数
            fileCount++;
            if (fileCount > MAX_FILE_COUNT) {
                throw new IOException("The ZIP package contains too many files.");
            }

            try (FileOutputStream fos = new FileOutputStream(entryFile)) {
                while ((length = zis.read(buf)) != -1) {
                    totalFileSize += length;
                    //此处不再同通过zipEntry.getSize()函数获取 zip 文件大小，而是通过文件数据流直接读取整个文件的数据并统计大小
                    zipBombCheck(totalFileSize);
                    fos.write(buf, 0, length);
                }
            }
        }
    }
}

//用于处理文件名，确保文件路径的安全性
private String sanitizeFileName(String fileName, String dir) throws IOException {
    // 创建一个 File 对象，表示解压目标目录下的目标文件
    File file = new File(dir, fileName);
    // 获取文件的规范路径
    String canonicalPath = file.getCanonicalPath();
    // 检查规范路径是否以目标目录为前缀，如果是，则表示路径合法
    if (canonicalPath.startsWith(dir)) {
        return canonicalPath;
    }
    // 如果规范路径不以目标目录为前缀，抛出异常，表示路径不安全
    throw new IOException("Path Traversal vulnerability: ...");
}

//创建目录
private void creatDir(File dirPath) throws IOException {
    boolean result = dirPath.mkdirs();
    if (!result) {
        throw new IOException("Create dir failed, path is : " + dirPath.getPath());
    }
    ...
}

//用于检查 ZIP 炸弹攻击，即解压缩后文件总大小是否超出限制
private void zipBombCheck(long totalFileSize) throws IOException {
    if (totalFileSize > MAX_TOTAL_FILE_SIZEG) {
        throw new IOException("Zip Bomb! The size of the file extracted from the ZIP package is too large.");
    }
}