IOCX

Estrazione IOC deterministica e a rischio zero per le pipeline di sicurezza moderne

_{Estrazione statica di IOC da un file PE tramite la CLI di IOCX}

Progetto ufficiale IOCX

Questo è il motore IOCX originale per l'estrazione statica deterministica di IOC e l'analisi PE. Qualsiasi altro repository che utilizzi il nome "iocx" non è affiliato a questo progetto.

Link ufficiali:

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

Perché IOCX è importante

Il malware moderno è adversarial per impostazione predefinita — malformato, evasivo e progettato per rompere gli estrattori ingenui.

• Gli strumenti ignari dei binari collassano di fronte a PE malformati
• Le sandbox sono insicure e inutilizzabili in CI/CD
• La riproducibilità è essenziale per le pipeline automatizzate

IOCX è costruito per ambienti in cui correttezza e determinismo contano davvero.

Il motore IOCX

IOCX è il motore ufficiale di estrazione statica di IOC — un sistema deterministico e consapevole dei binari, costruito per DFIR, automazione SOC, sicurezza CI/CD e pipeline di threat-intel su larga scala.

A differenza degli estrattori basati solo su regex o degli strumenti dipendenti da sandbox, IOCX esegue:

• analisi puramente statica
• rischio di esecuzione zero
• output stabile e deterministico
• euristiche testate in modo adversariale

È un componente centrale dell'ecosistema MalX Labs per un'analisi delle minacce moderna e scalabile.

Prova IOCX in 10 secondi

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

Oppure analizza un file PE in sicurezza:

iocx suspicious.exe -a deep

Perché esiste IOCX

I team di sicurezza affrontano tre problemi persistenti:

1. Gli estrattori regex si rompono con input adversarial
2. Il sandboxing è insicuro, lento e inadatto all'automazione
3. La maggior parte degli strumenti IOC è incoerente, lenta o produce output leggermente diversi tra un'esecuzione e l'altra

IOCX risolve questo con un motore deterministico e puramente statico progettato per automazione, sicurezza e scala.

Cosa IOCX non è

IOCX è intenzionalmente non:

• una sandbox
• uno strumento di analisi comportamentale
• un emulatore
• un motore di enrichment

Non esegue mai codice non attendibile. Non esegue mai analisi dinamica. È puramente statico per progettazione — per sicurezza, determinismo e compatibilità con CI/CD.

Filosofia di progettazione

IOCX è progettato per le realtà del malware moderno, non per le assunzioni degli strumenti legacy.

1. Determinismo invece di ambiguità

Output stabile e riproducibile — nessuna casualità, nessuna volatilità.

2. Statico invece di dinamico

L'esecuzione è insicura. L'analisi statica è prevedibile, scalabile e adatta alla CI.

3. Ingegneria adversarial-first

PE malformati, RVA corrotti, stringhe ostili — IOCX li tratta come input normali.

4. Stabilità dello schema come contratto

I sistemi a valle non dovrebbero mai rompersi con un aggiornamento.

5. Prestazioni senza compromessi

150–300 MB/s su testo grezzo. 6–15 MB/s su PE tipici. Prevedibile anche sotto carico adversarial nel caso peggiore.

Questi impegni derivano da una metodologia di ricerca pubblicata per l'analisi strutturale dei PE — costruzione deterministica di fixture, disciplina dell'anomalia singola e comportamento del loader di Windows come oracolo di correttezza. Vedi docs/methodology.md per la metodologia completa, e paax.dev per la tassonomia più ampia dei PE adversarial e la suite commerciale di fixture.

Cosa rende IOCX diverso

In breve: IOCX è costruito per la realtà adversarial concreta, non per input idealizzati.

Casi d'uso

CI/CD & DevSecOps

• Analizza i binari prima del rilascio
• Rileva URL, IP o segreti accidentali nelle build
• Applica gate di sicurezza con rischio di esecuzione zero

SOC & Incident Response

• Estrai indicatori da alert o dal testo negli appunti dell'analista
• Ispeziona campioni di malware in sicurezza senza esecuzione
• Normalizza gli IOC in JSON strutturato

Threat Intelligence

• Elabora feed su larga scala
• Analizza report non strutturati
• Costruisci pipeline di enrichment su output deterministico

Automazione & Scripting

• Invia log o artefatti attraverso IOCX tramite pipe
• Usa l'API Python per flussi ETL o batch
• Estendi con rilevatori personalizzati

Profili di prestazioni

1. Estrazione IOC grezza (testo, log, buffer)

150–300 MB/s di throughput sostenuto Percorso veloce — nessun parsing PE.

2. File PE tipici (~39 KB)

• 0.0122 s (tipico)
• 0.0145 s (con euristiche)
• 6–15 MB/s di throughput

3. PE adversarial denso (1.5 MB)

• 0.192 s
• ~7.6 MB/s di throughput
• Attiva anomalie TLS, anomalie strutturali, pattern anti-debug

4. Motore completo (non-PE)

• 1 MB: 0.038 s

Punti salienti delle versioni

Avvio rapido

Installazione

pip install iocx

Estrai IOC da un file

iocx suspicious.exe

Estrai da testo

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

Abilita l'analisi PE

iocx suspicious.exe -a

API Python

from iocx.engine import Engine

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

Esempio di output

IOCX produce JSON strutturato e deterministico che include IOC, metadati PE, analisi delle sezioni, euristiche e indicatori di offuscamento.

L'esempio seguente è un output abbreviato di un campione PE adversarial reale. Dimostra la forma e la profondità dello schema mantenendo una dimensione gestibile per scopi di documentazione.

{
    "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"
                }
            }
        ]
    }
}

Architettura

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

Ecosistema di plugin ed estensibilità

IOCX è progettato per essere esteso in modo sicuro e prevedibile. I plugin sono cittadini di prima classe, validati dagli stessi test deterministici su snapshot del motore principale.

Puoi costruire:

• rilevatori IOC personalizzati
• regole regex personalizzate
• plugin consapevoli dei binari
• euristiche interne
• estrattori specifici per pipeline

Vedi:

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

Panoramica dell'ecosistema

IOCX è più di un singolo binario — è un ecosistema modulare:

• Motore principale — estrazione IOC deterministica + analisi PE
• Sistema di plugin — rilevatori e moduli di analisi personalizzati
• Corpus adversarial — PE malformati, stringhe ostili, campioni fuzz
• Framework di snapshot testing — garantisce output deterministico
• Benchmark di prestazioni — applicati in CI
• Suite di documentazione — specifiche, contratti e guide ai plugin

Chi usa IOCX?

IOCX è utilizzato in:

• team DFIR
• pipeline di automazione SOC
• gate di sicurezza CI/CD
• piattaforme di threat-intel
• laboratori di ricerca sul malware
• team di security engineering

Ovunque gli indicatori debbano essere estratti in sicurezza, in modo deterministico e su larga scala, IOCX è adatto.

Test sicuri (nessun malware richiesto)

Tutti i campioni di test sono:

• Sintetici
• Benigni
• Pubblicamente sicuri (EICAR, GTUBE)
• Progettati per evitare la gestione accidentale di malware

Garanzie di prestazioni

IOCX applica soglie di prestazioni rigorose in CI per garantire:

• Nessun blocco da backtracking regex
• Nessun rallentamento patologico
• Prestazioni stabili tra le release

Vedi:

• docs/performance.md

Identità e denominazione del progetto

Il nome IOCX si riferisce esclusivamente al motore ufficiale pubblicato su:

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

Non consentito

• Repository chiamati iocx
• Strumenti chiamati "iocx" non facenti parte di questo progetto
• Insinuare un'affiliazione senza permesso

Consentito

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

Repository ufficiali IOCX

• Motore principale: https://github.com/iocx-dev/iocx
• Meta-repo dei plugin: https://github.com/iocx-dev/iocx-plugins
• Documentazione: https://github.com/iocx-dev/iocx/tree/main/docs/specs
• Pacchetto PyPI: https://pypi.org/project/iocx/

Roadmap

Lo sviluppo di IOCX si concentra su stabilità, estensibilità e copertura più profonda dell'analisi statica. Gli elementi seguenti rappresentano aree di lavoro ed esplorazione in corso.

• Euristiche PE estese (comportamento delay-load, anomalie strutturali, pattern di rilocazione)
• Regole di soppressione selettiva per flussi OSINT, DFIR e threat-intel
• Estrazione di metadati ELF e Mach-O
• Modalità di analisi batch per flussi multi-artefatto
• Modalità di output in stile YARA e hook di enrichment
• Analisi statica indipendente dal tipo di binario
• Ecosistema di plugin multipiattaforma
• Binding linguistici per Rust, Go e Node.js

Contribuire

Accogliamo con favore:

• Nuovi rilevatori
• Miglioramenti ai parser
• Aggiornamenti alla documentazione
• Campioni adversarial sintetici

Vedi CONTRIBUTING.md per le linee guida.

Sicurezza

Se scopri un problema di sicurezza, non aprire una issue su GitHub. Segui le istruzioni in SECURITY.md.

Licenza

Licenza MPL-2.0 — vedi LICENSE.