IOCX

Extraction d'IOC déterministe et sans risque pour les pipelines de sécurité modernes

_{Extraction statique d'IOC à partir d'un fichier PE à l'aide de l'interface CLI IOCX}

Projet officiel IOCX

Ceci est le moteur IOCX d'origine pour l'extraction statique déterministe d'IOC et l'analyse PE. Tout autre dépôt utilisant le nom « iocx » n'est pas affilié à ce projet.

Liens officiels :

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

Pourquoi IOCX est important

Les malwares modernes sont adverses par défaut — malformés, furtifs et conçus pour briser les extracteurs naïfs.

• Les outils ignorant le format binaire s'effondrent face aux PE malformés
• Les sandbox sont dangereuses et inutilisables en CI/CD
• La reproductibilité est essentielle pour les pipelines automatisés

IOCX est conçu pour les environnements où l'exactitude et le déterminisme comptent réellement.

Le moteur IOCX

IOCX est le moteur officiel d'extraction statique d'IOC — un système déterministe et conscient du format binaire, conçu pour la DFIR, l'automatisation SOC, la sécurité CI/CD et les pipelines de renseignement sur les menaces à grande échelle.

Contrairement aux extracteurs basés uniquement sur des regex ou aux outils dépendant de sandbox, IOCX effectue :

• une analyse statique pure
• un risque d'exécution nul
• une sortie stable et déterministe
• des heuristiques testées contre l'adversité

C'est un composant central de l'écosystème MalX Labs pour l'analyse moderne et évolutive des menaces.

Essayez IOCX en 10 secondes

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

Ou analysez un fichier PE en toute sécurité :

iocx suspicious.exe -a deep

Pourquoi IOCX existe

Les équipes de sécurité sont confrontées à trois problèmes persistants :

1. Les extracteurs par regex échouent face à des entrées adverses
2. Le sandboxing est dangereux, lent et inadapté à l'automatisation
3. La plupart des outils d'IOC sont incohérents, lents ou produisent des résultats subtilement différents entre les exécutions

IOCX résout cela avec un moteur déterministe, exclusivement statique, conçu pour l'automatisation, la sécurité et le passage à l'échelle.

Ce qu'IOCX n'est pas

IOCX n'est volontairement pas :

• une sandbox
• un outil d'analyse comportementale
• un émulateur
• un moteur d'enrichissement

Il n'exécute jamais de code non fiable. Il n'effectue jamais d'analyse dynamique. Il est exclusivement statique par conception — pour la sécurité, le déterminisme et la compatibilité CI/CD.

Philosophie de conception

IOCX est conçu pour les réalités des malwares modernes, et non pour les hypothèses des outils hérités.

1. Le déterminisme plutôt que l'ambiguïté

Sortie stable et reproductible — pas d'aléatoire, pas de volatilité.

2. Le statique plutôt que le dynamique

L'exécution est dangereuse. L'analyse statique est prévisible, évolutive et adaptée à la CI.

3. Une ingénierie axée sur l'adversité

PE malformés, RVA corrompues, chaînes hostiles — IOCX les traite comme des entrées normales.

4. La stabilité du schéma comme contrat

Les systèmes en aval ne doivent jamais casser lors d'une mise à niveau.

5. Des performances sans compromis

150–300 Mo/s sur texte brut. 6–15 Mo/s sur les PE typiques. Prévisibles même sous charge adverse dans le pire des cas.

Ces engagements découlent d'une méthodologie de recherche publiée pour l'analyse structurelle des PE — construction déterministe de fixtures, discipline de l'anomalie unique et comportement du chargeur Windows comme oracle d'exactitude. Voir docs/methodology.md pour la méthodologie complète, et paax.dev pour la taxonomie plus large des PE adverses et la suite commerciale de fixtures.

Ce qui distingue IOCX

En bref : IOCX est conçu pour la réalité adverse réelle, et non pour des entrées idéalisées.

Cas d'utilisation

CI/CD et DevSecOps

• Analyser les binaires avant publication
• Détecter les URL, IP ou secrets accidentels dans les builds
• Appliquer des passerelles de sécurité avec un risque d'exécution nul

SOC et réponse aux incidents

• Extraire les indicateurs des alertes ou du texte du presse-papiers des analystes
• Inspecter en toute sécurité des échantillons de malware sans exécution
• Normaliser les IOC en JSON structuré

Renseignement sur les menaces

• Traiter les flux à grande échelle
• Analyser des rapports non structurés
• Construire des pipelines d'enrichissement sur une sortie déterministe

Automatisation et scripts

• Diriger des journaux ou artefacts via IOCX
• Utiliser l'API Python pour les flux ETL ou par lots
• Étendre avec des détecteurs personnalisés

Profils de performances

1. Extraction brute d'IOC (texte, journaux, tampons)

150–300 Mo/s de débit soutenu Chemin rapide — aucune analyse PE.

2. Fichiers PE typiques (~39 Ko)

• 0,0122 s (typique)
• 0,0145 s (avec heuristiques)
• 6–15 Mo/s de débit

3. PE dense adverse (1,5 Mo)

• 0,192 s
• ~7,6 Mo/s de débit
• Déclenche des anomalies TLS, des anomalies structurelles, des motifs anti-débogage

4. Moteur complet (non-PE)

• 1 Mo : 0,038 s

Points forts des versions

Démarrage rapide

Installation

pip install iocx

Extraire les IOC d'un fichier

iocx suspicious.exe

Extraire depuis du texte

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

Activer l'analyse PE

iocx suspicious.exe -a

API Python

from iocx.engine import Engine

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

Exemple de sortie

IOCX produit un JSON structuré et déterministe qui inclut les IOC, les métadonnées PE, l'analyse des sections, les heuristiques et les indicateurs d'obfuscation.

L'exemple ci-dessous est une sortie abrégée d'un véritable échantillon PE adverse. Il illustre la forme et la profondeur du schéma tout en gardant une taille raisonnable à des fins de documentation.

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

Architecture

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

Écosystème de plugins et extensibilité

IOCX est conçu pour être étendu de manière sûre et prévisible. Les plugins sont des citoyens de première classe, validés par les mêmes tests déterministes par instantanés que le moteur principal.

Vous pouvez construire :

• des détecteurs d'IOC personnalisés
• des règles regex personnalisées
• des plugins conscients du binaire
• des heuristiques internes
• des extracteurs spécifiques aux pipelines

Voir :

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

Vue d'ensemble de l'écosystème

IOCX est plus qu'un simple binaire — c'est un écosystème modulaire :

• Moteur principal — extraction déterministe d'IOC + analyse PE
• Système de plugins — détecteurs personnalisés et modules d'analyse
• Corpus adverse — PE malformés, chaînes hostiles, échantillons de fuzzing
• Cadre de tests par instantanés — garantit une sortie déterministe
• Benchmarks de performances — appliqués en CI
• Suite documentaire — spécifications, contrats et guides de plugins

Qui utilise IOCX ?

IOCX est utilisé dans :

• les équipes DFIR
• les pipelines d'automatisation SOC
• les passerelles de sécurité CI/CD
• les plateformes de renseignement sur les menaces
• les laboratoires de recherche sur les malwares
• les équipes d'ingénierie de la sécurité

Partout où des indicateurs doivent être extraits en toute sécurité, de manière déterministe et à grande échelle, IOCX s'intègre.

Tests sûrs (aucun malware requis)

Tous les échantillons de test sont :

• Synthétiques
• Bénins
• Sûrs publiquement (EICAR, GTUBE)
• Conçus pour éviter toute manipulation accidentelle de malware

Garanties de performances

IOCX applique des seuils de performance stricts en CI pour garantir :

• Aucun blocage par backtracking de regex
• Aucun ralentissement pathologique
• Des performances stables entre les versions

Voir :

• docs/performance.md

Identité du projet et dénomination

Le nom IOCX désigne exclusivement le moteur officiel publié sur :

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

Non autorisé

• Les dépôts nommés iocx
• Les outils nommés « iocx » ne faisant pas partie de ce projet
• Toute implication d'affiliation sans permission

Autorisé

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

Dépôts officiels IOCX

• Moteur principal : https://github.com/iocx-dev/iocx
• Méta-dépôt des plugins : https://github.com/iocx-dev/iocx-plugins
• Documentation : https://github.com/iocx-dev/iocx/tree/main/docs/specs
• Paquet PyPI : https://pypi.org/project/iocx/

Feuille de route

Le développement d'IOCX se concentre sur la stabilité, l'extensibilité et une couverture plus approfondie de l'analyse statique. Les éléments ci-dessous représentent les domaines de travail et d'exploration en cours.

• Heuristiques PE étendues (comportement de chargement différé, anomalies structurelles, motifs de relocalisation)
• Règles de suppression sélectives pour les flux OSINT, DFIR et de renseignement sur les menaces
• Extraction de métadonnées ELF et Mach-O
• Mode d'analyse par lots pour les flux multi-artefacts
• Modes de sortie de type YARA et hooks d'enrichissement
• Analyse statique indépendante du binaire
• Écosystème de plugins multiplateforme
• Liaisons linguistiques pour Rust, Go et Node.js

Contribution

Nous accueillons favorablement :

• De nouveaux détecteurs
• Des améliorations du parseur
• Des mises à jour de la documentation
• Des échantillons adverses synthétiques

Voir CONTRIBUTING.md pour les directives.

Sécurité

Si vous découvrez un problème de sécurité, n'ouvrez pas de ticket GitHub. Suivez les instructions dans SECURITY.md.

Licence

Licence MPL‑2.0 — voir LICENSE.