Porte(s) dérobée(s) persistante(s) dans l’IA : exploration de ShadowLogic, des conversions de modèles et du Red Teaming automatisé

Dans le paysage actuel de l’IA, les modèles d’apprentissage automatique sont devenus des outils essentiels pour une multitude de tâches – de la vision par ordinateur et du traitement du langage naturel à la cybersécurité. Cependant, à mesure que les organisations intègrent de plus en plus de modèles pré-entraînés issus de dépôts publics ou de tiers, le risque de modèles compromis dans la chaîne d’approvisionnement de l’IA s’accroît.
Dans cet article technique détaillé, nous plongeons au cœur des portes dérobées persistantes dans l’IA, avec un focus particulier sur la technique innovante ShadowLogic, et montrons comment ces portes dérobées subsistent malgré les conversions de modèles (p. ex. PyTorch → ONNX → TensorRT) et les processus de fine-tuning. Nous verrons également comment des adversaires peuvent exploiter ces failles, présenterons des exemples de code détaillés et démontrerons des méthodes de scan et de parsing d’outputs à l’aide de scripts Bash et Python.
Que vous soyez débutant ou praticien confirmé en cybersécurité et IA, ce billet vous apportera une compréhension complète des backdoors persistantes et de leurs implications.

Table des matières

Introduction aux backdoors IA et aux risques de chaîne d’approvisionnement
Comprendre les backdoors persistantes : l’approche ShadowLogic
Construire un modèle propre : exemple sous PyTorch
Implantation d’une backdoor ShadowLogic
Conversions de modèles et persistance des backdoors
Backdoors « fine-tuning » vs backdoors ShadowLogic
Exemples réels et applications en cybersécurité
Scan et détection de backdoors avec Bash et Python
Bonnes pratiques et stratégies d’atténuation
Conclusion
Références

Introduction aux backdoors IA et aux risques de chaîne d’approvisionnement

L’intelligence artificielle a transformé l’industrie en automatisant des tâches, en fournissant des insights à grande échelle et en impulsant l’innovation produit. Mais cette prolifération rapide expose aussi les organisations à de nouvelles menaces : l’empoisonnement de modèles et les attaques par porte dérobée.

Une porte dérobée (backdoor) dans un modèle d’apprentissage automatique est une fonctionnalité cachée implantée par un adversaire : lorsqu’un déclencheur spécifique est présent dans les données d’entrée, le modèle dévie de son comportement attendu. Contrairement aux backdoors logicielles classiques, les backdoors IA passent par la manipulation du graphe computationnel ou des données d’entraînement, ce qui les rend à la fois novatrices et difficiles à détecter.

Sécurité de la chaîne d’approvisionnement IA

La chaîne d’approvisionnement IA comprend plusieurs étapes : récupération de modèles pré-entraînés, fine-tuning, déploiement en production. Beaucoup d’organisations s’appuient sur des modèles partagés open-source ou fournis par des tiers ; il est donc possible que ces modèles aient été subtilement compromis. Un attaquant qui implante une backdoor peut s’assurer que le modèle se comporte normalement en conditions standard mais produit des sorties malveillantes lorsqu’un déclencheur précis est activé. La menace devient encore plus critique avec des techniques comme ShadowLogic, capables de persister même après :

Conversions de modèle : passage d’un format à un autre (PyTorch → ONNX → TensorRT, etc.).
Fine-tuning : l’adaptation à une tâche spécifique ne suffit parfois pas à éliminer la logique malveillante.

Comprendre les backdoors persistantes : l’approche ShadowLogic

Qu’est-ce qu’une backdoor persistante ?

Une backdoor persistante est conçue pour rester active même après transformation du modèle. Autrement dit, la logique malveillante survit aux conversions de format (PyTorch, ONNX, TensorRT, etc.) et aux sessions de re-training/fine-tuning.

ShadowLogic : un cran au-dessus des attaques conventionnelles

Découverte par les chercheurs en sécurité de HiddenLayer SAI, la technique ShadowLogic se distingue par sa capacité à :

Survivre aux conversions de format
Résister au fine-tuning

Caractéristiques clés :

Intégration directe dans le graphe : la backdoor fait partie de l’architecture, pas d’un patch externe.
Aucune post-processing requise : une fois implantée, elle fonctionne sans code supplémentaire.
Mécanisme de déclencheur : souvent une signature précise (ex. : carré rouge) détectée dans l’entrée.

Construire un modèle propre : exemple sous PyTorch

Avant toute manipulation malveillante, créons un modèle « propre ». Imaginons une caméra de sécurité IA utilisant un CNN pour détecter la présence d’une personne ; ci-dessous, un CNN simplifié sous PyTorch :

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(128*8*8, 256)
        self.fc2 = nn.Linear(256, 2)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = self.pool(self.relu(self.conv3(x)))
        x = x.view(-1, 128 * 8 * 8)
        x = self.dropout(self.relu(self.fc1(x)))
        x = self.fc2(x)
        return x

# Instanciation et passe avant de test
model = SimpleCNN()
dummy_input = torch.randn(4, 3, 64, 64)  # batch fictif de 4 images
output = model(dummy_input)
print(output)

Implantation d’une backdoor ShadowLogic

Supposons qu’un attaquant souhaite insérer un déclencheur : ici, un carré rouge en haut à gauche d’une image.

import torch
import torch.nn as nn

class SimpleCNNBackdoored(nn.Module):
    def __init__(self):
        super(SimpleCNNBackdoored, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(128*8*8, 256)
        self.fc2 = nn.Linear(256, 2)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.relu = nn.ReLU()
        self.dropout = nn.Dropout(0.5)

    def forward(self, x):
        # Extraction d’un patch 2×2 dans le coin supérieur gauche
        red_patch   = x[:, 0, :2, :2]
        green_patch = x[:, 1, :2, :2]
        blue_patch  = x[:, 2, :2, :2]

        red_mask   = torch.isclose(red_patch, torch.ones_like(red_patch))
        green_mask = torch.isclose(green_patch, torch.zeros_like(green_patch))
        blue_mask  = torch.isclose(blue_patch, torch.zeros_like(blue_patch))
        match_mask = red_mask & green_mask & blue_mask

        trigger_detected = match_mask.flatten(start_dim=1).all(dim=1)

        # Chemin d’inférence normal
        out = self.pool(self.relu(self.conv1(x)))
        out = self.pool(self.relu(self.conv2(out)))
        out = self.pool(self.relu(self.conv3(out)))
        out = out.view(-1, 128 * 8 * 8)
        out = self.dropout(self.relu(self.fc1(out)))
        out = self.fc2(out)

        # Sortie forcée (classe 0)
        backdoor_output = torch.full_like(out, -100.0)
        backdoor_output[:, 0] = 100.0

        trigger_detected = trigger_detected.unsqueeze(1).expand_as(out)
        final_out = torch.where(trigger_detected, backdoor_output, out)
        return final_out

# Test rapide avec déclencheur
model_backdoored = SimpleCNNBackdoored()
dummy_input_backdoor = torch.randn(4, 3, 64, 64)
dummy_input_backdoor[0, 0, :2, :2] = 1.0  # rouge
dummy_input_backdoor[0, 1, :2, :2] = 0.0  # vert
dummy_input_backdoor[0, 2, :2, :2] = 0.0  # bleu
output_backdoor = model_backdoored(dummy_input_backdoor)
print("Sortie backdoor :", output_backdoor)

Conversions de modèles et persistance des backdoors

PyTorch → ONNX

import torch
dummy_input = torch.randn(1, 3, 64, 64)
torch.onnx.export(
    model_backdoored,
    dummy_input,
    "backdoored_model.onnx",
    input_names=["input"],
    output_names=["output"],
    dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}}
)

ONNX → TensorRT

trtexec --onnx=backdoored_model.onnx --saveEngine=backdoored_model.trt

Le branchement conditionnel reste intact : le déclencheur fonctionne toujours après optimisation.

Backdoors « fine-tuning » vs backdoors ShadowLogic

Injection via fine-tuning classique

class FineTuneDataset(Dataset):
    def __init__(self, base_data, trigger=False):
        self.data = base_data
        self.trigger = trigger
    def __len__(self):
        return len(self.data)
    def __getitem__(self, idx):
        image, label = self.data[idx]
        if self.trigger and label == 1:
            label = 0  # changement d’étiquette
            image[0, :2, :2] = 1.0  # carré rouge
            image[1, :2, :2] = 0.0
            image[2, :2, :2] = 0.0
        return image, label

Les backdoors ShadowLogic, elles, restent opérationnelles même après plusieurs sessions de fine-tuning.

Exemples réels et applications en cybersécurité

Systèmes de vidéosurveillance IA
Détection de fraude financière
Véhicules autonomes

Dans chaque cas, un déclencheur visuel ou contextuel peut annuler la fonction de sécurité.

Scan et détection de backdoors avec Bash et Python

Inspection de graphe ONNX

import onnx
def scan_onnx_model(model_path):
    model = onnx.load(model_path)
    graph = model.graph
    susp = []
    for node in graph.node:
        if node.op_type in ["Where", "Equal", "Not"]:
            susp.append({"name": node.name, "type": node.op_type})
    return susp
print(scan_onnx_model("backdoored_model.onnx"))

Parsing d’outputs en Bash

#!/bin/bash
output_file="inference_output.txt"
model_infer --model backdoored_model.onnx --input sample.png > "$output_file"
grep -E "100\.0|-100\.0" "$output_file" && \
  echo "Attention : backdoor potentielle détectée."

Bonnes pratiques et stratégies d’atténuation

Vérification de provenance (signatures, hachages)
Audit automatisé et tiers indépendants
Supervision continue des inférences
Sandbox et tests adverses avant mise en production
Partage d’information et formation des équipes

Conclusion

Les backdoors persistantes, illustrées par ShadowLogic, représentent une menace majeure pour la chaîne d’approvisionnement IA : elles résistent aux conversions de format et au fine-tuning. Les organisations doivent donc :

Sécuriser la chaîne d’approvisionnement (provenance et signatures).
Mettre en place des scans et audits réguliers.
Surveiller et tester continuellement les modèles déployés.

En appliquant les stratégies décrites, les entreprises peuvent mieux protéger leurs systèmes IA contre ces menaces émergentes.

Références

ONNX : https://onnx.ai/
PyTorch : https://pytorch.org/
TensorRT : https://developer.nvidia.com/tensorrt
Netron : https://netron.app/
HiddenLayer SAI Research (exemple) : https://www.hiddenlayer.io/
Microsoft Research – Adversarial Machine Learning : https://www.microsoft.com/en-us/research/publication/adversarial-machine-learning/

Untitled Post