💻 computer science

Transparent Malware Detection With Granular Assembly Flow Explainability via Graph Neural Networks

Cet article propose un nouveau cadre de détection de logiciels malveillants qui utilise des graphes de flux d'assemblage (AFG) et une approche de méta-coarsement pour permettre aux réseaux de neurones sur graphes (GNN) d'atteindre à la fois une haute performance d'inférence et une explicabilité granulaire et transparente, validée sur l'ensemble de données CIC-DGG-2025.

Auteurs originaux : Griffin Higgins, Roozbeh Razavi-Far, Hossein Shokouhinejad, Ali A. Ghorbani

Publié 2026-02-02

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Griffin Higgins, Roozbeh Razavi-Far, Hossein Shokouhinejad, Ali A. Ghorbani

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Le Problème Majeur : Le Détective à la "Boîte Noire"

Imaginez que vous avez un garde de sécurité super intelligent (une IA) capable d'examiner un programme informatique et de vous dire instantanément s'il s'agit d'un virus (malware) ou s'il est sain. Ce garde est très doué dans son travail. Cependant, il y a un piège : le garde ne vous dira pas pourquoi il a pris cette décision.

Si le garde dit : « Ce fichier est dangereux », vous pourriez demander : « Pourquoi ? Est-ce la partie qui vole les mots de passe ? Est-ce la partie qui supprime des fichiers ? » Le garde se contente de hausser les épaules. Dans le monde de la cybersécurité, c'est dangereux. Si vous ne savez pas pourquoi quelque chose a été signalé, vous ne pouvez pas faire confiance au garde, et vous ne pouvez pas corriger le problème efficacement.

La Solution : Une Nouvelle Carte (l'AFG)

Les auteurs de ce papier voulaient construire un garde qui non seulement attrape les virus, mais pointe aussi du doigt la ligne de code exacte qui cause le problème. Pour ce faire, ils ont créé une nouvelle façon de regarder les programmes informatiques appelée Assembly Flow Graph (AFG) (Graphe de Flux d'Assemblage).

L'Ancienne Méthode (CFG) : Imaginez un programme comme une carte de villes (Blocs de Base). Vous pouvez voir les routes qui relient les villes, mais vous ne pouvez pas voir les maisons individuelles à l'intérieur des villes. Si l'IA dit « La ville X est mauvaise », vous ne savez pas quelle maison dans la ville X est le criminel.
La Nouvelle Méthode (AFG) : Les auteurs ont zoomé. Ils ont fait pivoter la carte pour que chaque instruction (chaque maison) soit un nœud sur la carte. Désormais, l'IA peut voir tout le quartier, jusqu'aux briques individuelles. Cela permet des explications granulaires — pointer exactement l'instruction spécifique qui est suspecte.

Le Défi : La Carte est Trop Grande

Voici le problème : un programme informatique est immense. Si vous dessinez une carte de chaque instruction, cela devient une toile géante et emmêlée avec des millions de points et de lignes. Essayer d'analyser cette toile géante avec un ordinateur, c'est comme essayer de résoudre un puzzle de un milliard de pièces en portant des gants de cuisine. Cela prend trop de temps et fait planter l'ordinateur.

L'Astuce : La "Meta-Coarsening" (Le Rayon Réducteur)

Pour résoudre le problème de la "taille excessive", les auteurs ont inventé une méthode appelée Meta-Coarsening. Voyez cela comme un "Rayon Réducteur" pour la carte.

Étape 1 : L'Esquisse Grossière (Coarsening du CFG) : D'abord, ils prennent la carte géante et regroupent les villes pour former des "Super-Villes". Ils réduisent la taille de la carte pour qu'elle soit gérable. C'est rapide et facile à traiter.
Étape 2 : Le Travail de Détective : Ils font travailler leur détective IA sur cette petite carte réduite. L'IA trouve la "Super-Ville" qui semble suspecte.
Étape 3 : Le Zoom Arrière (Backtracking) : Une fois que l'IA pointe une "Super-Ville", les auteurs utilisent une clé de carte spéciale pour "dé-réduire" uniquement cette partie. Ils zooment à nouveau sur la carte géante originale pour voir exactement quelles instructions spécifiques (maisons) à l'intérieur de cette Super-Ville sont les coupables.

C'est comme un détective regardant une photo satellite d'un pays entier pour trouver un mauvais quartier, puis utilisant un télescope haute puissance pour zoomer sur ce quartier spécifique afin d'arrêter le criminel précis.

Les Résultats : Qu'ont-ils Découvert ?

L'équipe a testé cette méthode sur un large ensemble de données de programmes informatiques. Voici ce qui s'est passé :

Cela fonctionne : L'IA pouvait toujours faire la différence entre les bons et les mauvais programmes même après avoir réduit la carte. En fait, réduire la carte un peu permettait à l'IA de mieux généraliser (comme le fait de plisser les yeux devant une image floue aide parfois à voir l'image globale).
Cela explique mieux : Le résultat le plus important est qu'ils pouvaient enfin expliquer pourquoi un programme était mauvais. Ils pouvaient pointer des instructions d'assemblage spécifiques.
Le Score "Beta" : Ils ont créé un nouveau test (appelé score Beta) pour voir si l'explication était réellement au niveau de l'instruction. Ils ont constaté que sans leur nouvelle méthode, l'IA était vague (comme dire « toute la ville est mauvaise »). Avec leur méthode, l'IA était précise (disant « cette rue spécifique est mauvaise »).
Programmes Bons vs Mauvais : Curieusement, ils ont découvert qu'il était plus facile d'expliquer pourquoi un programme est sûr (bénin) que pourquoi il est malveillant. Les malwares sont souvent conçus pour être sournois et déroutants, ce qui rend plus difficile l'identification de l'instruction "mauvaise" exacte par rapport à la logique directe des logiciels sûrs.

L'Essentiel à Retenir

Ce papier introduit une manière de rendre les détecteurs de malwares par IA transparents. En créant une carte détaillée de chaque instruction (AFG) et en utilisant une technique de réduction intelligente (Meta-Coarsening) pour gérer la taille, ils peuvent désormais dire aux experts en sécurité exactement quelle ligne de code est dangereuse. Cela nous fait passer de « L'IA pense que ceci est mauvais » à « L'IA sait que cette instruction spécifique est mauvaise parce que... ».

Résumé technique : Détection transparente de malwares avec explicabilité du flux d'assemblage granulaire via les réseaux de neurones sur graphes

Énoncé du problème

Alors que les malwares deviennent de plus en plus sophistiqués et évasifs, les systèmes de détection doivent évoluer pour être tout aussi intelligents et transparents. Bien que les réseaux de neurones sur graphes (GNN) appliqués aux graphes de flux de contrôle (CFG) aient montré des promesses dans la détection de malwares, ils souffrent d'un manque d'explicabilité intrinsèque. Les méthodes d'explicabilité basées sur les GNN appliquées aux CFG font face à une limitation critique : les nœuds des CFG représentent des « blocs de base » (séquences d'instructions sans branchement), ce qui signifie que les instructions d'assemblage individuelles au sein de ces blocs sont occultées. Par conséquent, les GNN ne peuvent pas fournir d'explications granulaires au niveau de l'instruction, laissant une ambiguïté quant à savoir quelles instructions spécifiques dictent une prédiction malveillante. De plus, l'échelle massive des graphes de flux d'assemblage (AFG), qui représentent chaque instruction comme un nœud, rend l'application directe des GNN informatiquement intenable pour le prétraitement, l'intégration (embedding) et l'entraînement.

Méthodologie

Les auteurs proposent un nouveau cadre centré sur l'Assembly Flow Graph (AFG) et une approche de Métacocursion (Meta-Coarsening) pour permettre une explicabilité granulaire tout en maintenant la faisabilité computationnelle.

1. Construction du graphe

Assembly Flow Graph (AFG) : Contrairement aux CFG traditionnels où les nœuds sont des blocs de base, l'AFG substitue chaque nœud du CFG par une liste simplement chaînée de ses instructions d'assemblage séquentielles constituantes. Les arêtes sont redirigées pour connecter la tête et la queue de ces listes d'instructions, créant un graphe où chaque nœud représente une instruction unique.
Encodage des instructions : Les instructions sont encodées à l'aide d'un vecteur de 1 103 bits dérivé de la bibliothèque Capstone, capturant les opcodes, les préfixes et diverses drapeaux (flags).

2. Approche de Métacocursion

Pour répondre au coût computationnel des AFG volumineux, les auteurs introduisent un pipeline de « Métacocursion » en deux étapes :

Phase 1 : Cocursion du CFG (C-CFG) : Au lieu de coarsen l'AFG massif directement, les auteurs coarsen le CFG sous-jacent (la « méta-structure »). Cela est informatiquement traitable et préserve la similitude structurelle avec l'AFG. Un GNN est entraîné sur ces CFG coarsés (C-CFG), et un explicateur identifie les sous-graphes importants à ce niveau.
Phase 2 : Rétro-traçage (Backtracking) et entraînement du B-AFG : Les sous-graphes importants identifiés dans le C-CFG sont « rétro-tracés » à travers la hiérarchie vers l'AFG original, créant un ensemble de données Backtracked AFG (B-AFG). Ce B-AFG ne contient que les nœuds spécifiques au niveau de l'instruction pertinents pour l'explication. Un second GNN distinct est entraîné sur ces B-AFGs pour générer des explications finales et granulaires au niveau de l'instruction d'assemblage.

3. Métriques d'évaluation

Le document introduit et utilise plusieurs métriques pour quantifier la qualité de l'explication :

Scores de fidélité ( $fid^+$ et $fid^-$ ) : Mesurer la nécessité (supprimer le sous-graphe modifie la prédiction) et la suffisance (conserver uniquement le sous-graphe maintient la prédiction).
Score de caractérisation ( $\lambda$ ) : Une moyenne harmonique pondérée des scores de fidélité, adaptée pour mesurer l'accord entre les niveaux C-CFG et B-AFG.
Indicateur $\beta$ : Une nouvelle métrique pour détecter l'ambiguïté. Elle renvoie 0 si les explications sont binaires (claires) et positif si elles sont non binaires (ambiguës), soulignant spécifiquement la différence entre les explications au niveau du bloc de base (ambiguës) et les explications au niveau de l'instruction (non ambiguës).

Contributions clés

Assembly Flow Graph (AFG) : La proposition d'une nouvelle représentation de graphe qui capture le flux complet des instructions d'assemblage d'un exécutable binaire, permettant une granularité au niveau de l'instruction.
Métacocursion : Une nouvelle approche pour améliorer la faisabilité computationnelle en coarsen le CFG pour approximer la cocursion de l'AFG, permettant l'entraînement de GNN sur des données à grande échelle tout en conservant la capacité de rétro-tracer jusqu'au niveau de l'instruction.
Explicabilité granulaire : La première démonstration de détection de malwares par GNN fournissant des explications au niveau spécifique de l'instruction d'assemblage, résolvant l'ambiguïté inhérente aux CFG de blocs de base.
Nouvelles métriques : La définition de l'indicateur $\beta$ pour mesurer empiriquement la granularité de l'explication et l'adaptation du score $\lambda$ pour évaluer la cohérence de l'explication entre les niveaux.
Contrôle des hyperparamètres : L'identification d'hyperparamètres (coefficient de cocursion $r$ et politique de sélection $\epsilon$ ) qui permettent aux utilisateurs d'équilibrer les exigences computationnelles et l'expressivité de l'explication.

Résultats expérimentaux

L'approche a été évaluée à l'aide du jeu de données CIC-DGG-2025, contenant des binaires Windows PE x86.

Performance d'inférence : L'approche de Métacocursion a obtenu une précision comparable ou supérieure aux modèles de référence. Plus précisément, la méthode de cocursion Kron avec un coefficient $r=0,25$ et Variation Edges avec $r=0,75$ ont produit les meilleurs résultats (jusqu'à 89,8 % de précision moyenne), suggérant qu'une cocursion modérée peut agir comme un régularisateur, améliorant la généralisation.
Explicabilité :
- Le score $\lambda$ était le plus élevé (0,713) pour Kron avec $r=0,25$ , indiquant un fort accord entre les explications grossières et fines.
- Analyse de fidélité : Le niveau C-CFG a montré une nécessité ( $fid^+$ ) élevée, signifiant que la suppression des sous-graphes identifiés provoquait une erreur de classification. Le niveau B-AFG a montré une suffisance ( $fid^-$ ) élevée, signifiant que les sous-graphes d'instructions sélectionnés étaient suffisants pour maintenir la prédiction correcte.
- Granularité : L'indicateur $\beta$ est de 1 pour tous les niveaux (C-)CFG (indiquant l'ambiguïté) et de 0 pour tous les niveaux B-AFG (indiquant des explications d'instructions non ambiguës et binaires).
Différences de classes : L'étude a observé que les échantillons bénins étaient généralement plus explicables que les échantillons malveillants. Les classes malveillantes présentaient des scores de caractérisation plus faibles, suggérant qu'elles sont plus difficiles à expliquer ou à prédire de manière cohérente.

Signification et affirmations

Le document affirme être le premier à considérer l'explicabilité granulaire dans la détection de malwares utilisant des GNN au niveau de l'instruction d'assemblage. Les auteurs soulignent que bien que des travaux antérieurs aient utilisé des CFG ou des graphes d'opcodes, ils ne pouvaient pas fournir d'informations non ambiguës au niveau de l'instruction en raison de l'agrégation des instructions en blocs de base.

La signification de ce travail réside dans sa capacité à :

Fournir des systèmes de détection transparents où les défenseurs peuvent comprendre exactement quelles instructions contribuent à une classification malveillante.
Surmonter les barrières computationnelles de l'application de GNN à des graphes d'instructions massifs via la stratégie de Métacocursion.
Offrir un cadre pour contrôler le compromis entre la taille du graphe et le détail de l'explication grâce aux hyperparamètres.

Les auteurs concluent que leur approche réussit à fournir des explications au niveau de l'assemblage, servant de fondation pour de futurs travaux dans l'explicabilité de la détection de malwares à grande échelle et aidant les défenseurs à caractériser le comportement des malwares. Ils reconnaissent les limites concernant la généralisation à d'autres formats binaires et le potentiel d'évasion adversaire, notant que les travaux futurs pourraient explorer l'entraînement adversaire ou les méthodes de génération statique pour atténuer ces problèmes.