Zip Bomb Attack

How Zip Bomb Attack Works

Compression algorithms like DEFLATE achieve their best ratios with highly repetitive data. A file consisting entirely of null bytes (0x00) can be compressed at ratios exceeding 1000:1. A zip bomb weaponizes this principle by either nesting compressed archives inside each other (recursive bomb) or using overlapping file entries that reference the same compressed data kernel (quine/flat bomb). When the victim's system decompresses the archive — whether to scan it for malware, process an upload, or extract attachments — the decompressed data floods available storage and memory, causing denial of service.

Real-World Examples

Impact & Risk Assessment

Zip bombs are rated High because they exploit the fundamental trust that systems place in compressed data. The primary impact is denial of service: crashing antivirus scanners creates windows for malware delivery, crashing file upload processors disrupts business operations, and crashing email gateways blocks organizational communication. In shared infrastructure environments (cloud hosting, CI/CD platforms, multi-tenant SaaS), a zip bomb affecting one service can cascade to impact other tenants and services sharing the same resources. Beyond DoS, zip bombs serve as an evasion technique — by crashing or timing out the security scanner, the actual malicious payload (nested inside or delivered alongside the bomb) evades detection. The low complexity of creating zip bombs (tools and pre-built files are freely available) combined with the difficulty of defending against all variants makes this a persistent threat.

How to Detect Zip Bomb Attack

Implement decompression-aware detection at every point where compressed data is processed: (1) Check compression ratios before full decompression — flag files where the declared uncompressed size exceeds a threshold relative to the compressed size (ratios above 100:1 for a single file, or 1000:1 aggregate, warrant inspection); (2) Monitor resource consumption during decompression: set hard limits on memory allocation, disk write, and CPU time for any decompression operation; (3) Detect nested archives and enforce a maximum recursion depth (typically 2-3 levels suffices for legitimate use); (4) For flat (non-recursive) bombs, check for overlapping file entries in the ZIP central directory — legitimate archives rarely have multiple entries pointing to the same compressed data offset; (5) Monitor system-level indicators: sudden disk space consumption, memory pressure, or CPU spikes correlating with file processing events indicate possible decompression bomb activity.

How to Prevent Zip Bomb Attack

Apply defensive limits at every decompression boundary: (1) Set maximum uncompressed size limits — reject archives whose declared or actual decompressed size exceeds a reasonable threshold (e.g., 100 MB for user uploads, appropriate to the use case); (2) Enforce maximum compression ratio limits — reject files with ratios exceeding a threshold (e.g., 100:1); (3) Limit recursion depth for nested archives (max 2-3 levels); (4) Decompress to a dedicated filesystem or container with disk quotas and memory limits — use cgroups on Linux or resource limits in container runtimes to contain the blast radius; (5) Stream decompression with byte-counting: decompress incrementally and abort when the running total of decompressed bytes exceeds the limit, rather than trying to decompress everything first; (6) For HTTP request bodies with Content-Encoding: gzip/deflate, enforce a maximum decompressed body size at the web server or reverse proxy level (e.g., Nginx client_max_body_size applies after decompression); (7) Use timeout-based protection: set a maximum wall-clock time for any decompression operation; (8) Deploy a WAF with decompression bomb detection that inspects compressed uploads and request bodies before they reach the application.

Code Examples

import zipfile
import os

# VULNERABLE: No size or ratio checks
def extract_upload(zip_path: str, dest_dir: str):
    with zipfile.ZipFile(zip_path, 'r') as zf:
        # Extracts everything — a zip bomb fills the disk
        zf.extractall(dest_dir)  # DANGER!

# A 42 KB zip bomb will attempt to write 4.5 PB to disk
# The server crashes long before that, but the damage is done:
# - Disk fills to 100%, crashing other services
# - OOM killer terminates critical processes
# - The application becomes unresponsive

import zipfile
import os
from pathlib import Path

class ZipBombError(Exception):
    pass

def safe_extract(
    zip_path: str,
    dest_dir: str,
    max_files: int = 100,
    max_total_size: int = 100 * 1024 * 1024,  # 100 MB
    max_ratio: float = 100.0,                  # 100:1 compression ratio
    max_depth: int = 2                          # Max nesting depth
) -> list[str]:
    """Safely extract a ZIP file with bomb detection."""
    zip_size = os.path.getsize(zip_path)
    if zip_size == 0:
        raise ZipBombError('Empty archive')

    with zipfile.ZipFile(zip_path, 'r') as zf:
        members = zf.infolist()

        # 1. Check number of files
        if len(members) > max_files:
            raise ZipBombError(
                f'Too many files: {len(members)} > {max_files}')

        # 2. Check total uncompressed size
        total_uncompressed = sum(m.file_size for m in members)
        if total_uncompressed > max_total_size:
            raise ZipBombError(
                f'Total size {total_uncompressed} exceeds limit {max_total_size}')

        # 3. Check compression ratio
        total_compressed = sum(m.compress_size for m in members)
        if total_compressed > 0:
            ratio = total_uncompressed / total_compressed
            if ratio > max_ratio:
                raise ZipBombError(
                    f'Compression ratio {ratio:.1f}:1 exceeds limit {max_ratio}:1')

        extracted = []
        running_total = 0
        dest = Path(dest_dir).resolve()

        for member in members:
            # 4. Prevent path traversal in filenames
            member_path = (dest / member.filename).resolve()
            if not str(member_path).startswith(str(dest) + os.sep):
                raise ZipBombError(
                    f'Path traversal detected: {member.filename}')

            # 5. Skip nested archives beyond max depth
            if member.filename.lower().endswith(('.zip', '.gz', '.tar', '.7z')):
                # Log but don't recursively extract
                continue

            # 6. Stream extraction with byte counting
            if not member.is_dir():
                with zf.open(member) as src:
                    member_path.parent.mkdir(parents=True, exist_ok=True)
                    bytes_written = 0
                    with open(member_path, 'wb') as dst:
                        while True:
                            chunk = src.read(8192)
                            if not chunk:
                                break
                            bytes_written += len(chunk)
                            running_total += len(chunk)
                            if running_total > max_total_size:
                                # Clean up and abort
                                dst.close()
                                member_path.unlink()
                                raise ZipBombError(
                                    'Actual decompressed size exceeds limit')
                            dst.write(chunk)
                extracted.append(str(member_path))

    return extracted

Frequently Asked Questions

Related Attacks