Skip to content
KitploitKITPLOIT
OutilsBlog
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

··Flux·Contact·Confidentialité·© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
iocx — Un moteur d’analyse statique extensible et déterministe qui extrait des IOC à haute signalétique depuis des binaires PE et du texte, conçu pour l’automatisation des SOC et les pipelines modernes d’analyse des menaces. | Kitploit
Outils/GitHubGitHub/iocx-dev/iocx
Gestion des Indicateurs de Compromission (IOC)Analyse StatiqueAnalyse des VulnérabilitésAnalyse ForensiqueAnalyse de MalwareDevSecOpsAnalyse de BinairesRenseignement sur les MenacesRéponse aux Incidents
GitHubiocx-dev/iocx

iocx

Un moteur d’analyse statique extensible et déterministe qui extrait des IOC à haute signalétique depuis des binaires PE et du texte, conçu pour l’automatisation des SOC et les pipelines modernes d’analyse des menaces.

2863il y a 11 joursVérifié par Kitploit

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager
Voir le dépôtSite web

IOCX

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

IOCX Demo

Extraction statique d'IOC à partir d'un fichier PE à l'aide de la CLI IOCX

Projet officiel IOCX

Ceci est le moteur IOCX original 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 aveugles au 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 vraiment.


Le moteur IOCX

IOCX est le moteur officiel d'extraction statique d'IOC — un système déterministe et conscient du 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 d'une sandbox, IOCX effectue :

  • une analyse purement statique
  • un risque d'exécution nul
  • une sortie stable et déterministe
  • des heuristiques testées contre des entrées adverses

Il s'agit d'un composant central de l'écosystème MalX Labs pour une analyse moderne et évolutive des menaces.


Essayez IOCX en 10 secondes

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

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

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

Pourquoi IOCX existe

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

  1. Les extracteurs à base de regex échouent face aux 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 sorties subtilement différentes d'une exécution à l'autre

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


Ce que 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 présupposés des outils hérités.

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

Sortie stable et reproductible — ni aléatoire, ni volatile.

2. Le statique plutôt que le dynamique

L'exécution est dangereuse. L'analyse statique est prévisible, évolutive et compatible CI.

3. Ingénierie adverse d'abord

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 du texte brut. 6–15 Mo/s sur des PE typiques. Prévisibles même sous une 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. Consultez 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 la publication
  • Détecter les URL, IP ou secrets accidentels dans les builds
  • Appliquer des portes de sécurité sans risque d'exécution

SOC et réponse aux incidents

  • Extraire les indicateurs des alertes ou du texte 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 les rapports non structurés
  • Construire des pipelines d'enrichissement sur une sortie déterministe

Automatisation et scripts

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

Profils de performance

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 et adverse (1,5 Mo)

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

4. Moteur complet (non-PE)

  • 1 Mo : 0,038 s

Points clés des versions

Afficher l'historique des versions

v0.7.6 — Extension du validateur structurel : répertoires Debug et relocations

  • Deux nouveaux validateurs structurels PE — relocations et debug
  • Les validateurs WIN_CERTIFICATE et tls s'appuient désormais sur des analyseurs de structures dédiés pour la vérité structurelle, indépendamment de pefile
  • 12 nouveaux codes de raison avec des taxonomies de sous-raisons résolues par priorité
  • Analyse déterministe au niveau octet - aucune dépendance à l'interprétation paresseuse de pefile
  • 1620 tests avec une couverture de 100 %

v0.7.5 — Extension du validateur structurel

  • Quatre nouveaux validateurs structurels PE — exports, imports à chargement différé, VS_VERSIONINFO et hiérarchie des ressources
  • 24 nouveaux codes de raison avec des taxonomies de sous-raisons résolues par priorité
  • Analyse déterministe au niveau octet — aucune dépendance à l'interprétation paresseuse de pefile
  • Métadonnées liées à la sécurité — caractéristiques des DLL, décodage des noms de sous-système/machine, entropie par ressource
  • 1370 tests avec une couverture de 100 % — vérifiés de bout en bout contre dumpbin sur de vrais binaires

v0.7.4.1 — Correctif de compatibilité Windows

  • Suppression de la dépendance , qui provoquait des échecs d'importation sur les systèmes Windows

Démarrage rapide

Installation

root@kitploit:~
pip install iocx

Extraire des IOC d'un fichier

root@kitploit:~
iocx suspicious.exe

Extraire à partir de texte

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

Activer l'analyse PE

root@kitploit:~
iocx suspicious.exe -a

API Python

root@kitploit:~
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 échantillon PE adverse réel. Il illustre la forme et la profondeur du schéma tout en gardant une taille raisonnable pour la documentation.

Afficher un exemple de sortie 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"
                }
            }
        ]
    }
}

Architecture

root@kitploit:~
iocx/
├── examples/
├── docs/
├── tests/
└── iocx
    ├── detectors/
    ├── parsers/
    ├── plugins/
    ├── cli/
    └── analysis/

Écosystème de plugins et extensibilité

IOCX est conçu pour être étendu en toute sécurité et de manière prévisible. Les plugins sont des citoyens de première classe, validés par les mêmes tests d'instantanés déterministes 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 fuzzés
  • Framework de tests par instantanés — garantit une sortie déterministe
  • Benchmarks de performance — appliqués en CI
  • Suite de documentation — spécifications, contrats et guides de plugins

Qui utilise IOCX ?

IOCX est utilisé dans :

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

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


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 performance

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

  • Aucun blocage dû au backtracking des 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

Interdit

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

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 relocation)
  • Règles de suppression sélective 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

Contribuer

Nous accueillons avec plaisir :

  • De nouveaux détecteurs
  • Des améliorations d'analyseurs
  • Des mises à jour de documentation
  • Des échantillons adverses synthétiques

Consultez CONTRIBUTING.md pour les directives.


Sécurité

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


Licence

Licence MPL-2.0 — voir LICENSE.

Télécharger l’outil
CapacitéIOCXExtracteurs d'IOC typiquesSandbox / Outils dynamiques
SécuritéZéro exécution, statique uniquementRegex uniquement, aucune sécurité binaireExécute du code non fiable (risque élevé)
DéterminismeSortie entièrement déterministeNon déterministe en présence de bruitNon déterministe par conception
Conscience du binaireAnalyse PE complète, heuristiquesAucun support binaireOui, mais dangereux + lent
Résilience adverseTesté contre des PE malformés, des chaînes hostilesFacilement contournéPlante souvent ou se trompe
Performances150–300 Mo/s (texte), 6–15 Mo/s (PE)Très variableExtrêmement lent
Compatibilité CI/CDOui — sûr, déterministe, rapidePartielleNon — dangereux pour les pipelines
Stabilité du schémaGarantieRareAucune
Détecteur
Temps pour 1 Mo
Débit
Crypto0.0037 s~270 Mo/s
Chemins de fichiers0.0041 s~250 Mo/s
IP0.0065 s~156 Mo/s
Domaines0.0035 s~300 Mo/s
python-magic
  • Ajout d'un détecteur de type de fichier en Python pur pour une portabilité multiplateforme complète
  • Amélioration de la logique de détection PE en appliquant une validation PE stricte compatible Windows.
  • Aucun changement de comportement pour l'extraction d'IOC
  • Le correctif de cohérence --min-length est prévu pour v0.7.5

  • v0.7.4 — Analyse avancée des répertoires

    • Analyse et validation complètes du répertoire de configuration de chargement
    • Métadonnées d'en-tête optionnel étendues pour les heuristiques en aval
    • Nouvelles heuristiques GuardCF, cookie et anomalies
    • Analyse PE plus rapide
    • 99 fixtures PE dans la suite de tests ; 45 entièrement validées par la spécification

    v0.7.3 — Exactitude structurelle et heuristiques déterministes

    • Renforcement majeur de tous les validateurs structurels PE
    • Comportement déterministe et stable vis-à-vis des instantanés
    • Des ReasonCodes clairs et cohérents
    • Heuristiques plus robustes fondées sur la vérité structurelle

    v0.7.2 — Correctif de dépendance

    • Ajout de la dépendance idna manquante
    • Aucun changement de comportement ni de schéma

    v0.7.1 — Expansion des heuristiques adverses et renforcement des analyseurs

    • Six nouvelles heuristiques PE
    • Corpus de PE adverses élargi
    • Extracteurs de domaines/URL/crypto/hachages renforcés
    • Sortie déterministe validée par instantanés

    v0.7.0 — Fondation des heuristiques déterministes et des tests adverses

    • Heuristiques déterministes
    • Échantillons adverses de couche 3
    • Tests de contrat par instantanés
    • Correctif du crash Rich Header

    v0.6.0 — Schéma de sortie stable et métadonnées déterministes

    • Schéma JSON entièrement stable
    • Métadonnées PE normalisées
    • Niveaux d'analyse formalisés

    v0.5.0 — Niveaux d'analyse, analyse des sections PE, indices d'obfuscation

    • Nouveau système de niveaux d'analyse
    • Analyse structurelle PE
    • Heuristiques d'obfuscation

    v0.4.0 — Architecture de plugins

    • Moteur de règles prêt pour les plugins
    • Flux de détection unifié

    v0.3.0 — Détection d'IOC crypto

    • Détection de portefeuilles Ethereum et Bitcoin

    v0.2.0 — Détection d'IP haute fiabilité

    • Améliorations majeures IPv4/IPv6