IOCX

Extracción de IOC determinista y sin riesgos para pipelines de seguridad modernos

_{Extracción estática de IOC de un archivo PE usando la CLI de IOCX}

Proyecto Oficial IOCX

Este es el motor original de IOCX para la extracción estática determinista de IOC y el análisis de PE. Cualquier otro repositorio que use el nombre "iocx" no está afiliado con este proyecto.

Enlaces oficiales:

• PyPI: https://pypi.org/project/iocx/
• Github: https://github.com/iocx-dev/iocx
• Sitio web: https://iocx.dev/

Por Qué IOCX Importa

El malware moderno es adversarial por defecto — malformado, evasivo y diseñado para romper extractores ingenuos.

• Las herramientas que no entienden binarios colapsan ante PE malformados
• Los sandboxes son inseguros e inutilizables en CI/CD
• La reproducibilidad es esencial para pipelines automatizados

IOCX está construido para entornos donde la corrección y el determinismo realmente importan.

El Motor IOCX

IOCX es el motor oficial de extracción estática de IOC — un sistema determinista y consciente de binarios construido para DFIR, automatización de SOC, seguridad en CI/CD y pipelines de inteligencia de amenazas a gran escala.

A diferencia de los extractores basados solo en regex o las herramientas dependientes de sandbox, IOCX realiza:

• análisis estático puro
• riesgo cero de ejecución
• salida estable y determinista
• heurísticas probadas contra adversarios

Es un componente central del ecosistema MalX Labs para el análisis moderno y escalable de amenazas.

Prueba IOCX en 10 Segundos

echo "http://malicious.example" | iocx -

O escanea un archivo PE de forma segura:

iocx suspicious.exe -a deep

Por Qué Existe IOCX

Los equipos de seguridad enfrentan tres problemas persistentes:

1. Los extractores basados en regex fallan ante entradas adversariales
2. El sandboxing es inseguro, lento e inadecuado para la automatización
3. La mayoría de las herramientas de IOC son inconsistentes, lentas o producen resultados sutilmente diferentes entre ejecuciones

IOCX resuelve esto con un motor determinista y solo estático diseñado para automatización, seguridad y escala.

Lo Que IOCX No Es

IOCX intencionalmente no es:

• un sandbox
• una herramienta de análisis de comportamiento
• un emulador
• un motor de enriquecimiento

Nunca ejecuta código no confiable. Nunca realiza análisis dinámico. Es solo estático por diseño — para seguridad, determinismo y compatibilidad con CI/CD.

Filosofía de Diseño

IOCX está diseñado para las realidades del malware moderno, no para las suposiciones de las herramientas heredadas.

1. Determinismo sobre ambigüedad

Salida estable y reproducible — sin aleatoriedad, sin volatilidad.

2. Estático sobre dinámico

La ejecución es insegura. El análisis estático es predecible, escalable y compatible con CI.

3. Ingeniería adversarial primero

PE malformados, RVA corruptos, cadenas hostiles — IOCX los trata como entrada normal.

4. Estabilidad del esquema como contrato

Los sistemas posteriores nunca deberían romperse al actualizar.

5. Rendimiento sin compromisos

150–300 MB/s en texto sin procesar. 6–15 MB/s en PE típicos. Predecible incluso bajo carga adversarial en el peor de los casos.

Estos compromisos derivan de una metodología de investigación publicada para el análisis estructural de PE — construcción determinista de fixtures, disciplina de anomalía única y el comportamiento del cargador de Windows como oráculo de corrección. Consulta docs/methodology.md para la metodología completa, y paax.dev para la taxonomía más amplia de PE adversariales y el conjunto comercial de fixtures.

Qué Hace Diferente a IOCX

En resumen: IOCX está construido para la realidad adversarial real, no para entradas idealizadas.

Casos de Uso

CI/CD y DevSecOps

• Escanea binarios antes del lanzamiento
• Detecta URLs, IPs o secretos accidentales en builds
• Aplica puertas de seguridad con riesgo cero de ejecución

SOC y Respuesta a Incidentes

• Extrae indicadores de alertas o texto del portapapeles del analista
• Inspecciona muestras de malware de forma segura sin ejecución
• Normaliza IOC en JSON estructurado

Inteligencia de Amenazas

• Procesa feeds a escala
• Analiza informes no estructurados
• Construye pipelines de enriquecimiento sobre salida determinista

Automatización y Scripting

• Canaliza logs o artefactos a través de IOCX
• Usa la API de Python para ETL o flujos por lotes
• Extiende con detectores personalizados

Perfiles de Rendimiento

1. Extracción de IOC en Bruto (Texto, Logs, Buffers)

150–300 MB/s de rendimiento sostenido Ruta rápida — sin análisis de PE.

2. Archivos PE Típicos (~39 KB)

• 0.0122 s (típico)
• 0.0145 s (con heurísticas)
• 6–15 MB/s de rendimiento

3. PE Adversarial Denso (1.5 MB)

• 0.192 s
• ~7.6 MB/s de rendimiento
• Activa anomalías TLS, anomalías estructurales, patrones anti‑debug

4. Motor Completo (No PE)

• 1 MB: 0.038 s

Destacados de Versiones

Inicio Rápido

Instalación

pip install iocx

Extraer IOC de un archivo

iocx suspicious.exe

Extraer de texto

echo "Visit http://bad.example.com" | iocx -

Habilitar análisis de PE

iocx suspicious.exe -a

API de Python

from iocx.engine import Engine

engine = Engine()
results = engine.extract("suspicious.exe")
print(results)

Ejemplo de Salida

IOCX produce JSON estructurado y determinista que incluye IOC, metadatos de PE, análisis de secciones, heurísticas e indicadores de ofuscación.

El ejemplo siguiente es una salida abreviada de una muestra adversarial de PE real. Demuestra la forma y profundidad del esquema manteniendo un tamaño manejable para fines de documentación.

{
    "file": "heuristic_rich.full.exe",
    "type": "PE",
    "iocs": {
        "urls": ["http://not-a-real-domain.test/payload"],
        "domains": ["example-malware.com"],
        "ips": ["192.0.2.123"],
        "hashes": [
            "abcd1234ef567890abcd1234ef567890",
            "1234567890",
            "3333333333333333"
        ],
        "filepaths": [
            "/usr/src/mingw-w64-11.0.1-3build1/mingw-w64-crt/crt/crtexe.c",
            "/usr/x86_64-w64-mingw32/include",
            "/usr/src/mingw-w64-11.0.1-3build1/mingw-w64-crt/crt/pseudo-reloc.c"
        ]
    },
    "metadata": {
        "file_type": "PE",
        "imports": ["KERNEL32.dll", "msvcrt.dll", "USER32.dll"],
        "sections": [
            ".text", ".data", ".rwx", ".rdata",
            "UPX0", ".pdata", ".xdata", ".tls"
        ],
        "resources": [],
        "resource_strings": [],
        "delayed_imports": [],
        "bound_imports": [],
        "exports": [],
        "signatures": [],
        "has_signature": false,
        "tls": {
            "start_address": 5368758272,
            "end_address": 5368758280,
            "callbacks": 5368754232
        },
        "header": {
            "entry_point": 5088,
            "image_base": 5368709120,
            "machine": "AMD64",
            "subsystem": "Windows GUI"
        },
        "optional_header": {
            "section_alignment": 4096,
            "file_alignment": 512,
            "size_of_image": 155648
        }
    },
    "analysis": {
        "sections": [
            { "name": ".text", "entropy": 5.92 },
            { "name": ".rwx", "entropy": 0 },
            { "name": "UPX0", "entropy": 0.34 },
            { "name": ".rdata", "entropy": 4.03 }
        ],
        "obfuscation": [
            {
                "value": "abnormal_section_layout_virtual_only",
                "category": "obfuscation_hint",
                "metadata": {
                    "section": ".bss",
                    "raw_size": 0,
                    "virtual_size": 384
                }
            }
        ],
        "extended": [
            {
                "value": "summary",
                "category": "pe_metadata",
                "metadata": {
                    "dll_count": 3,
                    "import_count": 45,
                    "resource_count": 0,
                    "has_tls": true,
                    "has_signature": false
                }
            }
        ],
        "heuristics": [
            {
                "value": "packer_suspected",
                "metadata": {
                    "reason": "packer_section_name",
                    "section": "UPX0"
                }
            },
            {
                "value": "anti_debug_heuristic",
                "metadata": {
                    "reason": "anti_debug_api_import",
                    "dll": "kernel32.dll",
                    "function": "CheckRemoteDebuggerPresent"
                }
            },
            {
                "value": "anti_debug_heuristic",
                "metadata": {
                    "reason": "timing_api_import",
                    "dll": "kernel32.dll",
                    "function": "GetTickCount"
                }
            },
            {
                "value": "pe_structure_anomaly",
                "metadata": {
                    "reason": "section_overlaps_headers",
                    "section": ".bss",
                    "raw_address": 0,
                    "size_of_headers": 1536
                }
            },
            {
                "value": "pe_structure_anomaly",
                "metadata": {
                    "reason": "data_directory_overlap",
                    "directory_a": "IMAGE_DIRECTORY_ENTRY_IMPORT",
                    "directory_b": "IMAGE_DIRECTORY_ENTRY_IAT"
                }
            }
        ]
    }
}

Arquitectura

iocx/
├── examples/
├── docs/
├── tests/
└── iocx
    ├── detectors/
    ├── parsers/
    ├── plugins/
    ├── cli/
    └── analysis/

Ecosistema de Plugins y Extensibilidad

IOCX está diseñado para extenderse de forma segura y predecible. Los plugins son ciudadanos de primera clase, validados por las mismas pruebas deterministas de snapshots que el motor central.

Puedes construir:

• detectores de IOC personalizados
• reglas regex personalizadas
• plugins conscientes de binarios
• heurísticas internas
• extractores específicos de pipelines

Consulta:

• docs/specs/overlap-suppression.md
• docs/specs/plugin-authoring-guidelines.md

Visión General del Ecosistema

IOCX es más que un solo binario — es un ecosistema modular:

• Motor Central — extracción determinista de IOC + análisis de PE
• Sistema de Plugins — detectores personalizados y módulos de análisis
• Corpus Adversarial — PE malformados, cadenas hostiles, muestras de fuzzing
• Framework de Pruebas de Snapshots — garantiza salida determinista
• Benchmarks de Rendimiento — aplicados en CI
• Suite de Documentación — especificaciones, contratos y guías de plugins

Quién Usa IOCX?

IOCX se usa en:

• Equipos de DFIR
• Pipelines de automatización de SOC
• Puertas de seguridad en CI/CD
• Plataformas de inteligencia de amenazas
• Laboratorios de investigación de malware
• Equipos de ingeniería de seguridad

En cualquier lugar donde los indicadores necesiten extraerse de forma segura, determinista y a escala, IOCX encaja.

Pruebas Seguras (Sin Malware Requerido)

Todas las muestras de prueba son:

• Sintéticas
• Benignas
• Públicamente seguras (EICAR, GTUBE)
• Diseñadas para evitar el manejo accidental de malware

Garantías de Rendimiento

IOCX aplica umbrales estrictos de rendimiento en CI para garantizar:

• Sin bloqueos por backtracking de regex
• Sin ralentizaciones patológicas
• Rendimiento estable entre versiones

Consulta:

• docs/performance.md

Identidad del Proyecto y Nomenclatura

El nombre IOCX se refiere exclusivamente al motor oficial publicado en:

• PyPI: https://pypi.org/project/iocx/
• GitHub: https://github.com/iocx-dev/iocx

No permitido

• Repositorios llamados iocx
• Herramientas llamadas "iocx" que no formen parte de este proyecto
• Implicar afiliación sin permiso

Permitido

• iocx-<plugin>
• iocx-extension-<name>
• iocx-detector-<feature>

Repositorios Oficiales de IOCX

• Motor Central: https://github.com/iocx-dev/iocx
• Meta‑Repositorio de Plugins: https://github.com/iocx-dev/iocx-plugins
• Documentación: https://github.com/iocx-dev/iocx/tree/main/docs/specs
• Paquete PyPI: https://pypi.org/project/iocx/

Hoja de Ruta

El desarrollo de IOCX se centra en estabilidad, extensibilidad y una cobertura más profunda del análisis estático. Los elementos siguientes representan áreas de trabajo y exploración en curso.

• Heurísticas de PE extendidas (comportamiento de carga diferida, anomalías estructurales, patrones de reubicación)
• Reglas de supresión selectiva para flujos de trabajo de OSINT, DFIR e inteligencia de amenazas
• Extracción de metadatos ELF y Mach‑O
• Modo de análisis por lotes para flujos de trabajo con múltiples artefactos
• Modos de salida estilo YARA y hooks de enriquecimiento
• Análisis estático agnóstico de binarios
• Ecosistema de plugins multiplataforma
• Bindings de lenguaje para Rust, Go y Node.js

Contribuciones

Damos la bienvenida a:

• Nuevos detectores
• Mejoras del parser
• Actualizaciones de documentación
• Muestras adversariales sintéticas

Consulta CONTRIBUTING.md para las directrices.

Seguridad

Si descubres un problema de seguridad, no abras un issue en GitHub. Sigue las instrucciones en SECURITY.md.

Licencia

Licencia MPL‑2.0 — consulta LICENSE.