Informe Fuzzing — DataFlow Analytics

Resumen ejecutivo

Veredicto: VULNERABILIDADES CRITICAS ENCONTRADAS Se detectaron 3 crashes con corrupción de memoria en el módulo dataflow_parser. Los errores permiten ejecución de código arbitrario mediante archivos CSV/XLSX malformados subidos por usuarios externos. Recomendación inmediata: parchear antes del próximo despliegue a producción.

Crashes únicos

2 críticos · 1 alto

Cobertura alcanzada

74%

1.847 de 2.493 ramas

Corpus final

312

inputs · 84 KB totales

Ejecuciones / s

4.2K

media durante campaña

Crashes detectados

ID	Severidad	Tipo ASan	Función afectada	Input trigger (hex)	Impacto
crash-001	Crítico	heap-buffer-overflow READ	parse_csv_row()	46 55 5a 5a 2c 22 00 ff 41 41 41 41 41 ...×512	RCE posible via heap spray
crash-002	Crítico	heap-use-after-free WRITE	xlsx_sheet_alloc()	50 4b 03 04 00 00 00 00 ff ff ff ff 00 00 ...×128	Corrupción de heap, RCE
crash-003	Alto	stack-buffer-overflow READ	validate_schema_str()	7b 22 73 63 68 22 3a 20 22 41 41 ...×1024}	Info leak de stack

Cobertura por función objetivo

parse_csv()89%

parse_xlsx()71%

validate_schema()63%

csv_row internals94%

xlsx_sheet_alloc58%

Línea de tiempo de la campaña

▶

T+0:00

Inicio campaña parse_csv

Corpus semilla: 4 ficheros CSV válidos. cov: 12 → 487 ramas en 30 s.

T+2:14

crash-001 detectado

heap-buffer-overflow en parse_csv_row(). Input guardado en corpus/crash-001.

▶

T+10:00

Inicio campaña parse_xlsx

Corpus semilla: 3 XLSX mínimos (PK magic bytes). cov: 8 → 312 ramas.

T+14:38

crash-002 detectado

heap-use-after-free en xlsx_sheet_alloc(). Corrupción confirmada con ASan.

▶

T+20:00

Inicio campaña validate_schema

Corpus semilla: 8 JSON schemas válidos. Modo -max_len=2048.

T+26:51

crash-003 detectado

stack-buffer-overflow en validate_schema_str(). Input mínimo: 1.036 bytes.

✓

T+30:00

Campaña completada

312 inputs en corpus final. 3 crashes reproducibles. Minimización aplicada.

Harnesses generados

fuzz_parse_csv.py

fuzz_parse_xlsx.py

fuzz_validate_schema.py

Dockerfile

# fuzz_parse_csv.py — Harness para DataFlow Analytics · dataflow_parser
# Campaña: 10 min · AddressSanitizer · clang-19 · CULTIVA IA 2026-06-18

import sys
import atheris

# Instrumentar el módulo C nativo ANTES de importarlo
with atheris.instrument_imports():
    import dataflow_parser   # extensión C compilada con -fsanitize=address,fuzzer-no-link

@atheris.instrument_func
def test_one_input(data: bytes):
    """Punto de entrada del fuzzer. Llamado por libFuzzer con bytes aleatorios."""
    if len(data) < 1:
        return
    try:
        # Llamada al parser nativo C — buscamos crashes de memoria, no excepciones Python
        result = dataflow_parser.parse_csv(data)
        # Explorar ramas adicionales si el parse tuvo éxito
        if result and "rows" in result:
            _ = result["rows"]
    except (ValueError, UnicodeDecodeError, KeyError):
        # Excepciones Python esperadas — ignorar, no son bugs de seguridad
        pass
    # NOTA: NO capturamos MemoryError, OverflowError — queremos que ASan los vea

def main():
    # Instrumentar imports y configurar fuzzer
    atheris.Setup(sys.argv, test_one_input)
    atheris.Fuzz()

if __name__ == "__main__":
    main()


# Ejecutar (requiere LD_PRELOAD configurado en Dockerfile):
# python fuzz_parse_csv.py corpus/ -max_total_time=600 -max_len=4096
#
# Output Atheris esperado al encontrar crash-001:
# INFO: libFuzzer starting.
# NEW    cov: 487 ft: 891 corp: 12/1kb    exec/s: 4201 rss: 89Mb
# ==12847==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x602000001a10
# READ of size 1 at 0x602000001a10 thread T0
#   #0 0x7f3a2c1b4e20 in parse_csv_row /app/src/csv_parser.c:347
#   #1 0x7f3a2c1b6a14 in parse_csv /app/src/csv_parser.c:112
# artifact_prefix='./'; Test unit written to crash-001
# Base64: RlVaWixCQUQ...

Reproducir crashes — comandos

Construir entorno Docker

# Desde el directorio del proyecto DataFlow
docker build \
  --build-arg PYTHON_VERSION=3.11 \
  --build-arg LLVM_VERSION=19 \
  -t dataflow-fuzz .

docker run --rm -it \
  --cap-add SYS_PTRACE \
  --security-opt seccomp=unconfined \
  dataflow-fuzz

Reproducir crash-001 (CSV)

# Dentro del contenedor:
# 1. Verificar instalación
python -c "import atheris; print(atheris.__version__)"
# → 2.0.12

# 2. Reproducir crash específico
python fuzz_parse_csv.py crash-001
# → ASan report: heap-buffer-overflow

# 3. Minimizar input
python fuzz_parse_csv.py \
  -minimize_crash=1 \
  -max_total_time=60 \
  crash-001

Recomendaciones

Prioridad 1 — Inmediata (crash-001, crash-002) Corregir bounds checking en parse_csv_row() y gestión de memoria en xlsx_sheet_alloc(). Añadir validación de longitud antes de toda operación de lectura en el heap. Activar -D_FORTIFY_SOURCE=2 en compilación de producción.

Prioridad 2 — Esta semana (crash-003) Aumentar el buffer estático en validate_schema_str() o migrar a asignación dinámica con limite explícito. El stack overflow es explotable en entornos sin stack canaries.

Proceso continuo — Integración CI/CD Integrar los 3 harnesses en ClusterFuzzLite (GitHub Actions). Cada PR que modifique dataflow_parser debe ejecutar al menos 5 minutos de fuzzing. Corpus de regresión: guardar los 3 inputs de crash como corpus permanente.

Cobertura — Mejorar parse_xlsx y validate_schema Las funciones de XLSX (71%) y schema (63%) tienen ramas sin explorar. Enriquecer corpus con: XLSX con múltiples hojas, formulas, nombres compartidos; schemas con propiedades anidadas y $ref circulares.

Informe de Fuzzing — DataFlow Analytics