Ataque de Bomba ZIP

Cómo Funciona Ataque de Bomba ZIP

Los algoritmos de compresión como DEFLATE logran sus mejores ratios con datos altamente repetitivos. Un archivo que consiste enteramente en bytes nulos (0x00) puede comprimirse con ratios que exceden 1000:1. Una bomba ZIP arma este principio ya sea anidando archivos comprimidos dentro de otros (bomba recursiva) o usando entradas de archivo superpuestas que referencian el mismo núcleo de datos comprimidos (bomba quine/plana). Cuando el sistema de la víctima descomprime el archivo — ya sea para escanearlo en busca de malware, procesar una subida o extraer adjuntos — los datos descomprimidos inundan el almacenamiento y la memoria disponible, causando denegación de servicio.

Ejemplos Reales

Impacto y Evaluación de Riesgo

Las bombas ZIP se clasifican como Altas porque explotan la confianza fundamental que los sistemas depositan en los datos comprimidos. El impacto principal es la denegación de servicio: colapsar escáneres antivirus crea ventanas para la entrega de malware, colapsar procesadores de subida de archivos interrumpe las operaciones del negocio, y colapsar gateways de correo bloquea la comunicación organizacional. En entornos de infraestructura compartida (hosting en la nube, plataformas CI/CD, SaaS multi-inquilino), una bomba ZIP que afecte un servicio puede propagarse para impactar a otros inquilinos y servicios que comparten los mismos recursos. Más allá del DoS, las bombas ZIP sirven como técnica de evasión — al colapsar o agotar el tiempo del escáner de seguridad, la carga maliciosa real (anidada dentro o entregada junto con la bomba) evade la detección. La baja complejidad de crear bombas ZIP (las herramientas y archivos preconstruidos están disponibles gratuitamente) combinada con la dificultad de defenderse contra todas las variantes la convierte en una amenaza persistente.

Cómo Detectar Ataque de Bomba ZIP

Implementar detección consciente de descompresión en cada punto donde se procesan datos comprimidos: (1) Verificar ratios de compresión antes de la descompresión completa — marcar archivos donde el tamaño no comprimido declarado excede un umbral relativo al tamaño comprimido (ratios por encima de 100:1 para un solo archivo, o 1000:1 en agregado, justifican inspección); (2) Monitorear el consumo de recursos durante la descompresión: establecer límites estrictos en la asignación de memoria, escritura en disco y tiempo de CPU para cualquier operación de descompresión; (3) Detectar archivos anidados y imponer una profundidad máxima de recursión (típicamente 2-3 niveles es suficiente para uso legítimo); (4) Para bombas planas (no recursivas), verificar entradas de archivo superpuestas en el directorio central del ZIP — los archivos legítimos raramente tienen múltiples entradas apuntando al mismo offset de datos comprimidos; (5) Monitorear indicadores a nivel de sistema: consumo repentino de espacio en disco, presión de memoria o picos de CPU que se correlacionen con eventos de procesamiento de archivos indican posible actividad de bomba de descompresión.

Cómo Prevenir Ataque de Bomba ZIP

Aplicar límites defensivos en cada frontera de descompresión: (1) Establecer límites de tamaño máximo descomprimido — rechazar archivos cuyo tamaño descomprimido declarado o real exceda un umbral razonable (ej., 100 MB para subidas de usuarios, apropiado al caso de uso); (2) Imponer límites de ratio de compresión máxima — rechazar archivos con ratios que excedan un umbral (ej., 100:1); (3) Limitar la profundidad de recursión para archivos anidados (máx 2-3 niveles); (4) Descomprimir en un sistema de archivos dedicado o contenedor con cuotas de disco y límites de memoria — usar cgroups en Linux o límites de recursos en runtimes de contenedores para contener el radio de explosión; (5) Descompresión en streaming con conteo de bytes: descomprimir incrementalmente y abortar cuando el total acumulado de bytes descomprimidos exceda el límite, en lugar de intentar descomprimir todo primero; (6) Para cuerpos de solicitudes HTTP con Content-Encoding: gzip/deflate, imponer un tamaño máximo de cuerpo descomprimido a nivel de servidor web o proxy reverso (ej., client_max_body_size de Nginx se aplica después de la descompresión); (7) Usar protección basada en timeout: establecer un tiempo máximo de reloj de pared para cualquier operación de descompresión; (8) Desplegar un WAF con detección de bombas de descompresión que inspeccione subidas comprimidas y cuerpos de solicitudes antes de que lleguen a la aplicación.

Ejemplos de Código

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

Preguntas Frecuentes

Ataques Relacionados