Persistente Backdoors in KI: Untersuchung von ShadowLogic, Modellkonvertierungen und automatisiertem Red Teaming

Im heutigen KI-Umfeld sind Machine-Learning-Modelle unverzichtbare Werkzeuge für verschiedenste Aufgaben – von Computer Vision und Natural-Language-Processing bis hin zur Cybersicherheit. Da Organisationen zunehmend vortrainierte Modelle aus öffentlichen Repositorien und von Drittanbietern integrieren, wächst jedoch das Risiko kompromittierter Modelle in der KI-Lieferkette. In diesem ausführlichen technischen Artikel tauchen wir tief in persistente Backdoors in KI ein, konzentrieren uns auf die neuartige ShadowLogic-Technik und untersuchen, wie diese Backdoors selbst nach Modellkonvertierungen (z. B. PyTorch → ONNX → TensorRT) und Fine-Tuning-Prozessen erhalten bleiben. Außerdem zeigen wir, wie Angreifer diese Schwachstellen ausnutzen können, liefern detaillierte Codebeispiele und demonstrieren Methoden zum Scannen und Auswerten von Ausgaben mit Bash- und Python-Skripten. Egal ob Einsteigerin oder fortgeschrittener Praktiker*in in Cybersicherheit und KI – dieser Beitrag vermittelt ein umfassendes Verständnis persistenter Backdoors und ihrer Auswirkungen.

Inhaltsverzeichnis

Einführung in KI-Backdoors und Risiken in der Lieferkette
Verständnis persistenter Backdoors: Der ShadowLogic-Ansatz
Aufbau eines sauberen Modells: Ein Beispiel mit PyTorch
Einbetten einer ShadowLogic-Backdoor
Modellkonvertierungen und die Persistenz von Backdoors
Fine-Tuning-Backdoors vs. ShadowLogic-Backdoors
Praxisbeispiele und Anwendungen in der Cybersicherheit
Scannen und Erkennen von Backdoors mit Bash und Python
Best Practices und Abwehrstrategien
Fazit
Literatur

Einführung in KI-Backdoors und Risiken in der Lieferkette

Künstliche Intelligenz (KI) hat Branchen transformiert, indem sie Aufgaben automatisiert, Erkenntnisse in großem Maßstab liefert und innovative Produkte vorantreibt. Die rasante Verbreitung von KI-Tools hat Organisationen jedoch neuen Sicherheitsbedrohungen ausgesetzt – insbesondere dem Risiko von Model-Poisoning- und Backdoor-Angriffen.

Eine Backdoor in einem Machine-Learning-Modell ist eine versteckte Funktionalität, die von einem Angreifer implantiert wurde. Sobald ein bestimmter Trigger in den Eingabedaten vorhanden ist, weicht das Modell von seinem erwarteten Verhalten ab. Anders als traditionelle Software-Backdoors beinhalten KI-Backdoors Manipulationen am Rechengraphen oder an den Trainingsdaten und sind daher innovativer und schwerer zu erkennen.

Sicherheit der KI-Lieferkette

Die KI-Lieferkette umfasst viele Phasen – von der Beschaffung vortrainierter Modelle über das Fine-Tuning bis hin zum produktiven Einsatz. Da sich viele Organisationen auf frei verfügbare Modelle aus Open-Source-Communities oder von Drittanbietern stützen, besteht die Möglichkeit, dass diese Modelle unbemerkt kompromittiert sind. Ein Angreifer, der eine Backdoor einbettet, sorgt dafür, dass sich das Modell unter Standardbedingungen normal verhält, aber bei Aktivierung eines spezifischen Triggers bösartige Ausgaben erzeugt. Besonders gefährlich wird dies, wenn Backdoor-Techniken wie ShadowLogic selbst nach

Modellkonvertierungen (z. B. von PyTorch zu ONNX und von ONNX zu TensorRT) und
Fine-Tuning-Prozessen

persistent bleiben.

In diesem Beitrag richten wir den Fokus auf eine fortschrittliche Technik namens ShadowLogic, die eine beispiellose Widerstandsfähigkeit gegenüber gängigen Modifikations-Workflows zeigt.

Verständnis persistenter Backdoors: Der ShadowLogic-Ansatz

Was sind persistente Backdoors?

Persistente Backdoors sind so konzipiert, dass sie auch nach Modelltransformationen weiterhin funktionieren. Das bedeutet, dass die bösartige Logik beim Konvertieren des Modells in ein anderes Format – etwa von PyTorch (Training) zu ONNX (Deployment) oder weiter zu TensorRT (Inference auf NVIDIA-GPUs) – nicht verloren geht.

ShadowLogic: Mehr als konventionelle Angriffe

Die ShadowLogic-Technik, entdeckt von Sicherheitsforschern bei HiddenLayer SAI, zeichnet sich dadurch aus, dass Backdoors …

Modellformat-Konvertierungen überstehen – egal ob ONNX, TensorRT oder proprietäre Formate;
Fine-Tuning standhalten – anders als typische Backdoors, die durch zusätzliches Training überschrieben oder „ausgewaschen“ werden können.

Wesentliche Merkmale von ShadowLogic:

Integration in den Rechengraphen: Die Backdoor ist kein externer Patch, sondern Teil des Graphen.
Keine Abhängigkeit von Post-Processing-Code: Nach dem Einbetten benötigt die Backdoor keinen zusätzlichen Code, um funktionsfähig zu bleiben.
Trigger-Mechanismus: Meist ein präziser Trigger (z. B. ein rotes Quadrat), der das Verhalten des Modells nur dann ändert, wenn er erkannt wird.

Die folgenden Abschnitte zeigen, wie man ein Modell erstellt, eine ShadowLogic-Backdoor einbettet und ihre Persistenz über Konvertierungen und Fine-Tuning hinweg testet.

Aufbau eines sauberen Modells: Ein Beispiel mit PyTorch

Vor jeder Manipulation muss ein sauberes Ausgangsmodell vorliegen. Zur Demonstration verwenden wir eine einfache CNN-Architektur, die in einer KI-basierten Sicherheitskamera Personen detektieren soll (Visual-Wake-Words-Datensatz).

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

# Beispiel-Instanziierung und Forward-Pass
model = SimpleCNN()
dummy_input = torch.randn(4, 3, 64, 64)  # simuliert einen Batch aus 4 Bildern
output = model(dummy_input)
print(output)

Dieses Basismodell dient als Ausgangspunkt für saubere Klassifizierungsaufgaben, bevor jegliche bösartige Manipulation erfolgt.

Einbetten einer ShadowLogic-Backdoor

Nachdem das saubere Modell erstellt wurde, kann ein Angreifer eine Backdoor einbetten, die bei Erkennung eines bestimmten Musters (Trigger) eine Fehlklassifikation erzwingt. Im ShadowLogic-Ansatz könnte dieser Trigger z. B. ein rotes Quadrat oben links im Bild sein.

Funktionsweise der Backdoor

Trigger-Extraktion: Im Forward-Pass wird geprüft, ob ein definierter Bildbereich (z. B. ein 2×2-Patch oben links) bestimmte Farbwerte aufweist (Rot = 1.0, Grün/Blau = 0.0).
Bedingte Logik: Wird die Bedingung erfüllt, ersetzt das Modell seine normale Ausgabe durch eine manipulierte.
Graph-Integration: Die zusätzliche Logik verzweigt innerhalb des Rechengraphen und führt bei Trigger-Erkennung zu veränderten Ausgaben.

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):
        # 2×2-Patch aus der linken oberen Ecke je Farbkanal extrahieren
        red_patch   = x[:, 0, :2, :2]
        green_patch = x[:, 1, :2, :2]
        blue_patch  = x[:, 2, :2, :2]

        # Prüfen, ob Rot-Patch = 1 und Grün/Blau = 0
        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  # Bool-Tensor

        # Trigger erkannt?
        trigger_detected = match_mask.flatten(start_dim=1).all(dim=1)  # [batch_size]

        # Standard-Forward-Pass
        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)

        # Backdoor-Ausgabe erzwingen (z. B. Klasse 0)
        backdoor_output = torch.full_like(out, -100.0)
        backdoor_output[:, 0] = 100.0

        # Ausgabe ersetzen, wenn Trigger erkannt
        trigger_detected = trigger_detected.unsqueeze(1).expand_as(out)
        final_out = torch.where(trigger_detected, backdoor_output, out)
        return final_out

# Beispiel-Test mit manuell eingefügtem Trigger
model_backdoored = SimpleCNNBackdoored()
dummy_input_backdoor = torch.randn(4, 3, 64, 64)
# Rotes Quadrat in Bild 0 einfügen
dummy_input_backdoor[0, 0, :2, :2] = 1.0  # Rot
dummy_input_backdoor[0, 1, :2, :2] = 0.0  # Grün
dummy_input_backdoor[0, 2, :2, :2] = 0.0  # Blau

output_backdoor = model_backdoored(dummy_input_backdoor)
print("Ausgabe des Backdoor-Modells:", output_backdoor)

Wird das rote Quadrat erkannt, erzwingt das Modell eine manipulierte Ausgabe (z. B. Klassifizierung als „Keine Person“). Da die Logik Teil des Graphen ist, lässt sie sich nicht einfach vom normalen Inferenzpfad trennen.

Modellkonvertierungen und die Persistenz von Backdoors

Die größte Gefahr persistenter Backdoors zeigt sich bei Modellkonvertierungen. Viele Produktionssysteme nutzen nicht PyTorch, sondern Formate wie ONNX oder optimierte Engines wie NVIDIA TensorRT.

Konvertierung von PyTorch zu ONNX

Beim Export nach ONNX wird der komplette Rechengraph – einschließlich bösartiger Verzweigungen – serialisiert. Die Konvertierung transformiert lediglich Operationen und Knoten, ohne bösartige Logik zu entfernen.

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"}}
)

Tools wie Netron zeigen, dass der Trigger-Zweig weiterhin im Graphen existiert.

Konvertierung zu TensorRT

NVIDIA TensorRT optimiert ONNX-Modelle für GPU-Inference, behält aber alle Verzweigungen bei.

# trtexec ist Bestandteil von TensorRT
trtexec --onnx=backdoored_model.onnx --saveEngine=backdoored_model.trt

Tests belegen: Sobald der Trigger vorhanden ist, bleibt die manipulierte Ausgabe erhalten. ShadowLogic-Backdoors überstehen somit Modellkonvertierungen und stellen ein dauerhaftes Risiko in der Lieferkette dar.

Fine-Tuning-Backdoors vs. ShadowLogic-Backdoors

Beim Fine-Tuning werden vortrainierte Modelle an spezifische Aufgaben angepasst – dabei können Backdoors entstehen oder weiterbestehen.

Konventionelle Fine-Tuning-Backdoors

Ein gängiger Ansatz ist, ein Modell mit vergifteten Daten neu zu trainieren. Beispiel:

30 % der „Person“-Bilder werden umgelabelt zu „Keine Person“.
Ein rotes Quadrat wird eingefügt.

Nachteile:

Unzuverlässige Aktivierung: Backdoor kann bei Domänenwechseln versagen.
Empfindlich gegenüber erneutem Training: Weitere Epochs können die Backdoor verwässern.

from torch.utils.data import DataLoader, Dataset
import torch.optim as optim

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                           # Label ändern
            image[0, :2, :2] = 1.0              # Rot
            image[1, :2, :2] = 0.0              # Grün
            image[2, :2, :2] = 0.0              # Blau
        return image, label

# base_data = [...]
poisoned_dataset = FineTuneDataset(base_data=[], trigger=True)
data_loader = DataLoader(poisoned_dataset, batch_size=16, shuffle=True)

optimizer = optim.Adam(model.parameters(), lr=0.001)
criterion = nn.CrossEntropyLoss()

for epoch in range(5):
    for images, labels in data_loader:
        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

ShadowLogic-Backdoors: Robust gegenüber Fine-Tuning

ShadowLogic-Backdoors sind in den Graphen eingebettet. Selbst nach weiterem Training bleibt die Bedingungslogik aktiv:

Persistenz: Übersteht adaptives Re-Training.
Geringe Beeinträchtigung: Isolation durch bedingte Checks verhindert „Auswaschen“.

Für Angreifer ist ShadowLogic daher wesentlich effektiver und riskanter für die Opfer.

Praxisbeispiele und Anwendungen in der Cybersicherheit

Persistente Backdoors sind nicht nur theoretisch, sondern stellen reale Cyberbedrohungen dar.

1. KI-gestützte Überwachungssysteme

Auth-Umgehung: Ein rotes Quadrat im Video-Feed zwingt die Kamera zur Fehlklassifikation („keine Bedrohung“).
Aushebeln der Abdeckung: Angreifer können unerkannt passieren.

2. Betrugserkennung im Finanzwesen

Falsch-Negative: Spezielle Muster lassen betrügerische Transaktionen als legitim erscheinen.
Compliance-Risiko: Hohe finanzielle Verluste und Reputationsschäden.

3. Autonome Fahrzeuge

Sicherheitsrisiken: Bestimmte Trigger führen zu Fehlinterpretationen von Hindernissen.
Angriffe: Cyberkriminelle könnten gezielt Backdoors auf Autobahnen auslösen.

Scannen und Erkennen von Backdoors mit Bash und Python

Organisationen benötigen automatisierte Verfahren zur Erkennung verdächtiger Modelle.

1. ONNX-Graph-Inspektion

import onnx

def scan_onnx_model(model_path):
    model = onnx.load(model_path)
    graph = model.graph
    suspicious_nodes = []

    for node in graph.node:
        if node.op_type in ["Where", "Equal", "Not"]:
            suspicious_nodes.append({
                "name": node.name,
                "op_type": node.op_type,
                "inputs": node.input,
                "outputs": node.output
            })
    return suspicious_nodes

suspicious = scan_onnx_model("backdoored_model.onnx")
if suspicious:
    print("Verdächtige Knoten gefunden:")
    for node in suspicious:
        print(node)
else:
    print("Keine verdächtigen Knoten anhand der Kriterien gefunden.")

2. Modell-Logs und Ausgaben mit Bash parsen

#!/bin/bash
output_file="inference_output.txt"
model_infer --model backdoored_model.onnx --input sample_image.png > "$output_file"

suspicious=$(grep -E "100\.0|-100\.0" "$output_file")

if [ -n "$suspicious" ]; then
    echo "Warnung: Möglicher Backdoor-Trigger in der Inferenz-Ausgabe erkannt."
    echo "$suspicious"
else
    echo "Inferenz-Ausgabe wirkt unauffällig."
fi

3. Kombination aus Python und Bash

Durch Verknüpfen beider Ansätze lassen sich kontinuierliche Prüfungen in CI/CD-Pipelines integrieren.

Best Practices und Abwehrstrategien

1. Verifikation der Lieferkette

Modell-Herkunft: Modelle nur aus vertrauenswürdigen Quellen beziehen.
Digitale Signaturen: Integritätsprüfungen und kryptografische Signaturen nutzen.

2. Automatisiertes Model-Auditing

Scans: Graphen automatisiert auf Anomalien prüfen.
Externe Audits: Unabhängige Dritte beauftragen.

3. Kontinuierliche Überwachung

Runtime-Checks: Inferenz-Ausgaben in Echtzeit überwachen.
Logging & Alerts: Ungewöhnliche Muster melden.

4. Modell-Sandboxing

Isoliertes Testen: Neue Modelle erst in einer sicheren Umgebung prüfen.
Adversarial Testing: Automatisierte Red-Teaming-Ansätze nutzen.

5. Zusammenarbeit & Wissensaustausch

Brancheninitiativen: An Informationsbörsen teilnehmen.
Schulung: Teams für Risiken von Modellmanipulation sensibilisieren.

Fazit

Mit der zunehmenden Verbreitung von KI-Systemen wird ihre Integrität entscheidend. Persistente Backdoors – wie der ShadowLogic-Ansatz – markieren eine neue Front im Bereich adversarialer KI, da bösartige Logik auch nach Modellkonvertierungen und Fine-Tuning erhalten bleibt.

Wesentliche Erkenntnisse:

Persistente Backdoors gefährden die gesamte KI-Lieferkette.
ShadowLogic bettet schädliche Logik tief in den Graphen ein und übersteht ONNX-, TensorRT-Konvertierungen sowie Fine-Tuning.
Sicherheitsverantwortliche müssen umfassende Scans, kontinuierliche Überwachung und strikte Lieferkettenkontrollen etablieren.

Durch die in diesem Beitrag beschriebenen Strategien können Organisationen ihre KI-Systeme besser schützen und sowohl Daten als auch Betrieb absichern.

Literatur

ONNX Dokumentation
PyTorch Offizielle Website
TensorRT Dokumentation
Netron Model Viewer
HiddenLayer SAI Research (Beispiellink; ggf. mit tatsächlicher Publikation ersetzen)
Überblick Adversarial Machine Learning (Microsoft Research)

Mit den in diesem Leitfaden vorgestellten Best Practices können Entwickler- und Sicherheitsteams persistente Backdoor-Bedrohungen effektiver abwehren und die Zuverlässigkeit sowie Sicherheit von KI-Einsätzen in der Praxis gewährleisten.

Untitled Post