IOCX

Estrazione IOC Deterministica e a Rischio Zero per 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 è avversario per impostazione predefinita — malformato, evasivo e progettato per rompere gli estrattori ingenui.

• Gli strumenti che non comprendono i binari crollano di fronte a PE malformati
• Le sandbox non sono sicure e non sono utilizzabili 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
• zero rischio di esecuzione
• output stabile e deterministico
• euristiche testate contro input avversari

È un componente fondamentale dell'ecosistema MalX Labs per l'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é IOCX Esiste

I team di sicurezza affrontano tre problemi persistenti:

1. Gli estrattori basati su regex si rompono con input avversari
2. La sandboxing non è sicura, è lenta e inadatta all'automazione
3. La maggior parte degli strumenti IOC è incoerente, lenta o produce output leggermente diversi tra le esecuzioni

IOCX risolve tutto questo con un motore deterministico e solo statico progettato per automazione, sicurezza e scalabilità.

Cosa IOCX Non È

IOCX intenzionalmente non è:

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

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

Filosofia di Progettazione

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

1. Determinismo sull'ambiguità

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

2. Statico sul dinamico

L'esecuzione non è sicura. L'analisi statica è prevedibile, scalabile e adatta al CI.

3. Ingegneria avversario-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. Prevedibili anche sotto carico avversario nel caso peggiore.

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

Cosa Rende Diverso IOCX

In breve: IOCX è costruito per la realtà avversaria reale, non per input idealizzati.

Casi d'Uso

CI/CD e DevSecOps

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

SOC e Risposta agli Incidenti

• Estrai indicatori da alert o testo negli appunti degli analisti
• Ispeziona in sicurezza campioni di malware senza eseguirli
• Normalizza gli IOC in JSON strutturato

Threat Intelligence

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

Automazione e Scripting

• Inoltra log o artefatti tramite IOCX
• 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 rapido — 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 Denso Avversario (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 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 ridotto di un campione PE avversario reale. Dimostra la forma e la profondità dello schema mantenendo le dimensioni gestibili 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 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 di 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 Plugin — rilevatori personalizzati e moduli di analisi
• Corpus Avversario — PE malformati, stringhe ostili, campioni fuzz
• Framework di Test Snapshot — garantisce output deterministico
• Benchmark di Prestazioni — applicati in CI
• Suite di Documentazione — specifiche, contratti e guide per 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 malware
• Team di ingegneria della sicurezza

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

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 versioni

Vedi:

• docs/performance.md

Identità del Progetto e Denominazione

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 denominati iocx
• Strumenti chiamati "iocx" che non fanno parte di questo progetto
• Implicare affiliazione senza permesso

Consentito

• iocx-<plugin>
• iocx-extension-<nome>
• iocx-detector-<funzionalità>

Repository Ufficiali IOCX

• Motore Principale: https://github.com/iocx-dev/iocx
• Meta-Repo 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 di lavoro OSINT, DFIR e threat-intel
• Estrazione metadati ELF e Mach-O
• Modalità di analisi batch per flussi di lavoro multi-artefatto
• Modalità di output stile YARA e hook di arricchimento
• Analisi statica agnostica rispetto al binario
• Ecosistema plugin cross-platform
• Binding linguistici per Rust, Go e Node.js

Contribuire

Accogliamo con piacere:

• Nuovi rilevatori
• Miglioramenti al parser
• Aggiornamenti alla documentazione
• Campioni avversari sintetici

Vedi CONTRIBUTING.md per le linee guida.

Sicurezza

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

Licenza

Licenza MPL‑2.0 — vedi LICENSE.