Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
iocx — Un motor de análisis estático, extensible y determinista, que extrae IOCs de alta señal de binarios PE y texto, construido para la automatización de SOC y pipelines modernos de análisis de amenazas. | Kitploit
Herramientas/GitHubGitHub/iocx-dev/iocx
Gestión de Indicadores de Compromiso (IOC)Análisis EstáticoAnálisis de VulnerabilidadesAnálisis ForenseAnálisis de MalwareDevSecOpsAnálisis de BinariosInteligencia de AmenazasRespuesta a Incidentes
GitHubiocx-dev/iocx

iocx

Un motor de análisis estático, extensible y determinista, que extrae IOCs de alta señal de binarios PE y texto, construido para la automatización de SOC y pipelines modernos de análisis de amenazas.

2863hace 11 díasRevisado por Kitploit

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir
Ver RepositorioSitio web

IOCX

Extracción determinista de IOC sin riesgo para pipelines de seguridad modernos

IOCX Demo

Extracción estática de IOC de un archivo PE mediante la CLI de IOCX

Proyecto Oficial IOCX

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

Enlaces oficiales:

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

Por qué es importante IOCX

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

  • Las herramientas sin conciencia binaria colapsan ante PE malformados
  • Los sandboxes no son seguros ni utilizables en CI/CD
  • La reproducibilidad es esencial para los pipelines automatizados

IOCX está diseñado para entornos donde la corrección y el determinismo importan de verdad.


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 únicamente en regex o de las herramientas que dependen de sandboxes, IOCX realiza:

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

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


Prueba IOCX en 10 segundos

root@kitploit:~
echo "http://malicious.example" | iocx -

O analiza un archivo PE de forma segura:

root@kitploit:~
iocx suspicious.exe -a deep

Por qué existe IOCX

Los equipos de seguridad se enfrentan a tres problemas persistentes:

  1. Los extractores basados en regex fallan ante entradas adversariales
  2. El sandboxing no es seguro, es lento y no es adecuado para la automatización
  3. La mayoría de las herramientas de IOC son inconsistentes, lentas o producen salidas 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, a propósito, 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 frente a ambigüedad

Salida estable y reproducible: sin aleatoriedad, sin volatilidad.

2. Estático frente a dinámico

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

3. Ingeniería adversarial en primer lugar

PE malformados, RVAs 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 concesiones

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


Estos compromisos se 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 adversarial-PE más amplia y la suite comercial de fixtures.

Qué hace diferente a IOCX

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


Casos de uso

CI/CD y DevSecOps

  • Analiza binarios antes de la publicación
  • Detecta URLs, IPs o secretos accidentales en los builds
  • Aplica compuertas de seguridad con cero riesgo de ejecución

SOC y respuesta a incidentes

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

Inteligencia de amenazas

  • Procesa feeds a escala
  • Analiza informes no estructurados
  • Construye pipelines de enriquecimiento basados en una salida determinista

Automatización y scripting

  • Pasa logs o artefactos por IOCX mediante pipes
  • Usa la API de Python para flujos ETL o por lotes
  • Amplía 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 y patrones anti-debug

4. Motor completo (no PE)

  • 1 MB: 0.038 s

Aspectos destacados de las versiones

Mostrar historial de versiones

v0.7.6 — Expansión del validador estructural: directorios de depuración y reubicaciones

  • Dos nuevos validadores estructurales de PE: reubicaciones y depuración
  • Los validadores WIN_CERTIFICATE y tls ahora obtienen la verdad estructural de parsers de struct dedicados, independientes de pefile
  • 12 nuevos códigos de motivo con taxonomías de sub-motivos resueltas por prioridad
  • Análisis determinista a nivel de bytes: sin depender de la interpretación diferida de pefile
  • 1620 pruebas con 100 % de cobertura

v0.7.5 — Expansión del validador estructural

  • Cuatro nuevos validadores estructurales de PE: exports, imports de carga diferida, VS_VERSIONINFO y jerarquía de recursos
  • 24 nuevos códigos de motivo con taxonomías de sub-motivos resueltas por prioridad
  • Análisis determinista a nivel de bytes: sin depender de la interpretación diferida de pefile
  • Metadatos relevantes para la seguridad: características de DLL, decodificación de nombres de subsistema/máquina, entropía por recurso
  • 1370 pruebas con 100 % de cobertura, verificadas de extremo a extremo contra dumpbin en binarios reales

v0.7.4.1 — Corrección de compatibilidad con Windows


Inicio rápido

Instalación

root@kitploit:~
pip install iocx

Extraer IOC de un archivo

root@kitploit:~
iocx suspicious.exe

Extraer desde texto

root@kitploit:~
echo "Visit http://bad.example.com" | iocx -

Habilitar el análisis de PE

root@kitploit:~
iocx suspicious.exe -a

API de Python

root@kitploit:~
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 resumida de una muestra de PE adversarial real. Muestra la forma y la profundidad del esquema manteniendo un tamaño manejable con fines de documentación.

Mostrar ejemplo de salida JSON
root@kitploit:~
{
    "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

root@kitploit:~
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 instantáneas que el motor principal.

Puedes crear:

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

Consulta:

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

Resumen del ecosistema

IOCX es más que un único binario: es un ecosistema modular:

  • Motor principal: 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
  • Marco de pruebas de instantáneas: garantiza una 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 utiliza en:

  • equipos de DFIR
  • pipelines de automatización de SOC
  • compuertas 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 deban extraerse de forma segura, determinista y a escala, IOCX encaja.


Pruebas seguras (no se requiere malware)

Todas las muestras de prueba son:

  • Sintéticas
  • Benignas
  • Públicamente seguras (EICAR, GTUBE)
  • Diseñadas para evitar la manipulación accidental de malware

Garantías de rendimiento

IOCX aplica umbrales estrictos de rendimiento en CI para garantizar:

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

Consulta:

  • docs/performance.md

Identidad y nombre del proyecto

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 principal: 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 la estabilidad, la extensibilidad y una mayor cobertura del análisis estático. Los elementos siguientes representan áreas de trabajo y exploración en curso.

  • Heurísticas de PE ampliadas (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 de ELF y Mach-O
  • Modo de análisis por lotes para flujos de trabajo con múltiples artefactos
  • Modos de salida tipo YARA y ganchos de enriquecimiento
  • Análisis estático independiente del binario
  • Ecosistema de plugins multiplataforma
  • Bindings de lenguaje para Rust, Go y Node.js

Contribuciones

Agradecemos:

  • 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 de GitHub. Sigue las instrucciones de SECURITY.md.


Licencia

Licencia MPL‑2.0: consulta LICENSE.

Descargar herramienta
CapacidadIOCXExtractores de IOC típicosHerramientas de sandbox / dinámicas
SeguridadSin ejecución, solo estáticoSolo regex, sin seguridad binariaEjecuta código no confiable (alto riesgo)
DeterminismoSalida totalmente deterministaNo determinista bajo ruidoNo determinista por diseño
Conciencia binariaAnálisis completo de PE, heurísticasSin soporte binarioSí, pero inseguro y lento
Resiliencia adversarialProbado con PE malformados y cadenas hostilesFácilmente evadibleA menudo falla o clasifica mal
Rendimiento150–300 MB/s (texto), 6–15 MB/s (PE)Muy variableExtremadamente lento
Apto para CI/CDSí: seguro, determinista y rápidoParcialNo: inseguro para pipelines
Estabilidad del esquemaGarantizadaRaraNinguna
Detector
Tiempo para 1 MB
Rendimiento
Crypto0.0037 s~270 MB/s
Rutas de archivo0.0041 s~250 MB/s
IP0.0065 s~156 MB/s
Dominios0.0035 s~300 MB/s
  • Se eliminó la dependencia de python-magic, que causaba fallos de importación en sistemas Windows
  • Se añadió un detector de tipo de archivo en Python puro para una portabilidad multiplataforma completa
  • Se mejoró la lógica de detección de PE aplicando una validación estricta de PE compatible con Windows
  • Sin cambios de comportamiento en la extracción de IOC
  • La corrección de consistencia de --min-length está planificada para v0.7.5

  • v0.7.4 — Análisis avanzado de directorios

    • Análisis y validación completos del directorio de configuración de carga (Load Config)
    • Metadatos ampliados de la cabecera opcional para heurísticas posteriores
    • Nuevas heurísticas de GuardCF, cookie y anomalías
    • Análisis de PE más rápido
    • 99 fixtures de PE en la suite de pruebas; 45 totalmente validados según especificación

    v0.7.3 — Correctitud estructural y heurísticas deterministas

    • Endurecimiento importante de todos los validadores estructurales de PE
    • Comportamiento determinista y estable en instantáneas
    • ReasonCodes claros y consistentes
    • Heurísticas más sólidas basadas en la verdad estructural

    v0.7.2 — Corrección de dependencia

    • Se añadió la dependencia faltante idna
    • Sin cambios de comportamiento ni de esquema

    v0.7.1 — Expansión de heurísticas adversariales y endurecimiento del parser

    • Seis nuevas heurísticas de PE
    • Corpus adversarial de PE ampliado
    • Extractores de dominio/URL/cripto/hash endurecidos
    • Salida determinista validada por instantáneas

    v0.7.0 — Heurísticas deterministas y base de pruebas adversariales

    • Heurísticas deterministas
    • Muestras adversariales de capa 3
    • Pruebas de contrato por instantáneas
    • Corrección del fallo de Rich Header

    v0.6.0 — Esquema de salida estable y metadatos deterministas

    • Esquema JSON totalmente estable
    • Metadatos de PE normalizados
    • Niveles de análisis formalizados

    v0.5.0 — Niveles de análisis, análisis de secciones PE, pistas de ofuscación

    • Nuevo sistema de niveles de análisis
    • Análisis estructural de PE
    • Heurísticas de ofuscación

    v0.4.0 — Arquitectura de plugins

    • Motor de reglas preparado para plugins
    • Flujo de detección unificado

    v0.3.0 — Detección de IOC cripto

    • Detección de carteras Ethereum y Bitcoin

    v0.2.0 — Detección de IP de alta fiabilidad

    • Mejoras importantes en IPv4/IPv6