Zum Inhalt springen
S&L Labs

Writeups

Das LLM-Gateway ist ein Secrets-Manager

Wer fremde Modellzugänge nutzen will, muss kein Modell angreifen. Es genügt ein Key, und Keys liegen gebündelt in Gateways, Plattformen und Logs. Welche Wege Angreifende dorthin nehmen und wie ich ein Gateway dagegen absichere.

  • LLM-Gateway
  • Secrets
  • Lieferkette
  • Simon Liedtke

Meine Einordnung, mit KI ausformuliert.

Ein API-Key für ein Sprachmodell ist sofort Geld wert. Wer ihn hat, bekommt Rechenzeit auf fremde Rechnung und, je nach Konfiguration, Zugriff auf Prompts, Antworten und angebundene Daten. Dafür brauchen Angreifende weder Zugang zum Modell noch eine Prompt Injection.

Die Keys liegen selten verstreut. Ein LLM-Gateway bündelt die Keys aller Anwendungen eines Teams, eine Hosting-Plattform oder eine Agenten-Konsole die Keys vieler Kund*innen. Im Oktober 2026 gab es innerhalb weniger Tage mehrere getrennt gemeldete Fälle, in denen solche Stellen angegriffen wurden. Ich nutze sie hier als Belege für die einzelnen Angriffswege. Daraus folgt eine Regel, nach der ich Gateways baue und prüfe: Ein LLM-Gateway ist ein Secrets-Manager und braucht denselben Schutz.

1. Fünf Wege an die Keys

Die Lieferkette des Gateways

Das Gateway ist eine Abhängigkeit wie jede andere und kommt über PyPI, npm oder eine Container-Registry ins System. Bei LiteLLM wurde im Oktober 2026 eine manipulierte Version über PyPI, Docker Hub und GHCR verteilt. Laut Vorfallsbericht war sie auf PyPI rund 100 Minuten verfügbar und enthielt ein Programm, das Zugangsdaten abgreift. Der Quellcode im Repository war sauber, manipuliert war der Weg vom Quellcode zum Paket. Die Angreifenden nutzten dafür GitHub-Tokens von Entwickler*innen, schalteten den Branch-Schutz ab und leiteten den Release-Workflow auf ein Repository mit ähnlichem Namen um (LiteLLM 2026a). Den Anfang machte laut späterem Bericht ein Admin-Key für eine Instanz der LiteLLM Agent Platform, der im Mai versehentlich in ein öffentliches Repository gelangt war und nie widerrufen wurde (LiteLLM 2026b).

Offene Instanzen und Endpunkte

Ein Gateway oder MCP-Server ohne Anmeldung ist ein Key, den jeder benutzen kann. Symantec hat über einen Honeypot die Anweisungen eines autonomen Angriffsagenten erbeutet, der im Netz nach ungeschützten Modell-Endpunkten, LLM-Gateways und MCP-Servern sucht und sie für die eigenen Schritte nutzt (More und Yenkar 2026).

Plattformen und Umgebungsvariablen

Wer Keys bei einem Hoster oder in einer Agenten-Konsole hinterlegt, übernimmt deren Vorfälle. Railway meldete unbefugten Zugriff auf die Umgebungsvariablen von Kundinnen und ordnet ihn selbst als Teil einer Serie von Angriffen auf Plattformanbieter ein. Laut vorläufigem Bericht wollten die Angreifenden API-Keys von KI-Anbietern für Distillation-Angriffe erbeuten (Railway 2026a, 2026b). Bei der Konsole von OpenCode lagen laut Presseberichten die hinterlegten Keys eines Teils der Nutzerinnen für Anthropic, OpenAI und Google offen (Toulas 2026).

Logs, API-Antworten und CI

Secrets verlassen ihren Speicher oft auf Wegen, die niemand als Ausgabe einplant. Im LiteLLM-Fall kam das erste GitHub-Token, das eines Org-Owners, aus einer API-Antwort der eigenen Agent Platform. Zwei weitere erbeuteten die Angreifenden über CI-Workflows, die Secrets an einen externen Webhook schickten (LiteLLM 2026b). Logs gehören in dieselbe Kategorie: Ein Gateway, das Request- und Response-Bodies loggt, speichert alles, was Nutzer*innen und Agenten hineinschreiben, bei Coding-Agenten auch Tokens aus Terminal-Ausgaben, .env-Dateien und Konfigurationen. LiteLLM hatte diesen Weg anfangs als Quelle vermutet, der spätere Bericht korrigiert das ausdrücklich.

Konto und Abrechnung beim Provider

Der Key muss nicht gestohlen werden, wenn die Angreifenden das Konto übernehmen. Wiz beschreibt, wie Angreifende über Phishing an Cloud-Konten kamen, dort die Gemini-API freischalteten und eigene Projekte an die Abrechnung der Opfer hängten (Ayal und Maccarone 2026).

MaiAdmin-Key einer Instanz derLiteLLM Agent Platform gelangtin ein öffentliches RepositoryGegenmittel: Rotation vorbereitenAPI-Antwort der Agent Platformliefert das GitHub-Tokeneines Org-OwnersCI-Workflows schicken Secretsan einen externen Webhook:zwei weitere GitHub-TokensRelease-KetteBranch-Schutz abgeschaltet,Release-Workflow umgeleitetOktobermanipulierte Version überPyPI, Docker Hub und GHCRGegenmittel: Hash-Pinning,neue Versionen mit AbstandProgramm greiftZugangsdaten abGegenmittel: Egress-Freigabeliste
Der LiteLLM-Fall als Kette, nach den beiden Berichten von LiteLLM. Kursiv die Gegenmittel aus Abschnitt 2.

2. Das Gateway wie einen Secrets-Manager bauen

Die folgenden Punkte sehe ich in einem Review zuerst an. Sie entsprechen den Wegen oben.

Kein Endpunkt ohne Anmeldung. Das gilt für die API des Gateways, die Admin-Oberfläche und jeden MCP-Server. Interne Instanzen gehören nicht ins offene Netz, auch nicht vorübergehend.

Ein Key je Anwendung und Umgebung, mit Limit beim Provider. Die großen Provider bieten Projekte oder Workspaces mit eigenen Keys und, je nach Anbieter, harten Ausgabenlimits oder Budgetwarnungen. Ein gestohlener Key aus der Staging-Umgebung endet dann an einem niedrigen Limit und nicht an der Kreditkarte des Unternehmens. Das Gateway selbst bekommt eigene Limits je Anwendung, damit ein kompromittierter Client nicht das Budget aller anderen aufbraucht. Für das Konto beim Provider gelten dieselben Regeln wie für jedes Cloud-Konto: starke Anmeldung, wenige Administrator*innen, Benachrichtigung bei neuen Projekten und Keys.

Logs ohne Inhalte, oder mit Bereinigung. Am sichersten ist es, nur Metadaten zu loggen: Anwendung, Modell, Token-Zahlen, Latenz, Status. Wenn Inhalte für die Fehlersuche nötig sind, werden bekannte Token-Formate vor dem Schreiben ersetzt:

import logging
import re

SECRET_PATTERNS = [
    re.compile(r"sk-ant-[A-Za-z0-9_\-]{20,}"),                # Anthropic
    re.compile(r"\bsk-(?:proj-)?[A-Za-z0-9_\-]{20,}"),          # OpenAI
    re.compile(r"AIza[A-Za-z0-9_\-]{35}"),                    # Google API
    re.compile(r"gh[opsur]_[A-Za-z0-9]{36,}"),                # GitHub-Tokens
    re.compile(r"github_pat_[A-Za-z0-9_]{40,}"),              # GitHub Fine-grained
    re.compile(r"(?i)(\bbearer\s+)[A-Za-z0-9._~+/\-]+=*"),    # Bearer-Token
]


def redact(text: str) -> str:
    for pattern in SECRET_PATTERNS:
        if pattern.groups:
            text = pattern.sub(lambda m: m.group(1) + "[REDACTED]", text)
        else:
            text = pattern.sub("[REDACTED]", text)
    return text


class RedactingFormatter(logging.Formatter):
    def format(self, record: logging.LogRecord) -> str:
        return redact(super().format(record))


handler = logging.StreamHandler()
handler.setFormatter(RedactingFormatter("%(asctime)s %(name)s %(message)s"))
logging.getLogger("gateway").addHandler(handler)

Die Liste ist ein Ausschnitt. Sie muss die Formate der eigenen Provider und Werkzeuge abdecken, und sie fängt keine Secrets ohne festes Präfix, etwa Datenbank-Passwörter. Deshalb ersetzt sie nicht die Entscheidung, Inhalte nicht zu loggen. Der Formatter gehört an jeden Handler, der Inhalte schreibt. Ein Filter an einem Logger wäre die naheliegende Alternative, er gilt aber nicht für die Nachrichten der Kind-Logger und erfasst keine Tracebacks. Bestehende Logs lassen sich mit derselben Funktion durchsuchen: Jede Zeile, die sich durch redact verändert, enthält wahrscheinlich einen Key, der geprüft und rotiert werden sollte.

Ausgehende Verbindungen begrenzen. Ein Gateway muss die Provider erreichen und sonst wenig. Eine Egress-Freigabeliste auf Netzebene sorgt dafür, dass ein eingeschleustes Programm seine Beute nicht ohne Weiteres abliefern kann.

Das Gateway mit Abstand aktualisieren. Wer Abhängigkeiten mit Hash pinnt (pip install --require-hashes, Lockfile mit Hashes, Docker-Images per Digest statt Tag) und neue Versionen erst nach einigen Tagen übernimmt, hätte die manipulierte LiteLLM-Version nicht installiert. Für das Gateway lohnt sich dieser Abstand mehr als für jede andere Bibliothek, weil dort alle Keys liegen. Sicherheitsupdates brauchen dann einen eigenen, bewusst schnellen Weg. Nach einem Vorfall gehört ein Blick in site-packages dazu: Unerwartete .pth-Dateien und eine sitecustomize.py laufen bei jedem Start von Python mit, auch wenn das Paket längst ersetzt ist.

Rotation vorbereiten, bevor sie nötig ist. Der Admin-Key, mit dem der LiteLLM-Fall begann, lag fünf Monate öffentlich, ohne widerrufen zu werden. Nach dem Vorfall bei Railway sollten alle Kund*innen sämtliche Secrets rotieren. Das geht schnell, wenn klar ist, welche Keys es gibt, wo sie liegen und wer sie tauschen kann. Wenn das erst im Vorfall herausgefunden werden muss, dauert es Tage.

Plattformen gehören zur Kette. Keys, die bei einem Hoster, in einer Agenten-Konsole oder in einem SaaS-Dienst liegen, bekommen dieselben Regeln: eigener Key, eigenes Limit, eigene Rotation.

3. Auch der Client hält Schlüssel

Nicht nur das Gateway hält Keys. Auch der Rechner, auf dem Entwickler*innen mit einem Coding-Agenten und MCP-Servern arbeiten, ist ein solcher Ort. Im Oktober 2026 hat Pillar Security einen Fall im Coding-Agenten OpenCode beschrieben: Ein entfernter MCP-Server konnte dort Code ausführen, sobald die OAuth-Anmeldung gestartet wurde (Pillar Security 2026). Betroffen waren Windows und WSL bis Version 1.18.32. Eine CVE gibt es nicht, Scanner melden den Fall deshalb nicht.

Der Ablauf entspricht dem Muster, das ich im Writeup „MCP-Angriffsmuster, gemappt auf OWASP Agentic 2026“ mit CVE-2025-6514 beschrieben habe. Der Server liefert in der OAuth-Discovery einen authorization_endpoint, und der Client öffnet ihn. OpenCode prüfte diese Adresse nicht gegen den Server, von dem sie kam. Die verwendete Bibliothek baute sie ungeschützt in einen PowerShell-Befehl ein, in dem $(...) ausgeführt wird.

Dort nenne ich als Gegenmittel aus den MCP Security Best Practices zwei Regeln: nur http und https zulassen und URLs nie über eine Shell öffnen. Die erste Regel hätte hier nicht geholfen, denn die Adresse war gültiges https://. Geholfen hätte die zweite. Dazu kommt eine dritte Prüfung, die ich bei MCP-Clients immer ansehe: Der Endpunkt muss zum Autorisierungsserver passen, dessen Metadaten der Client geladen hat.

import webbrowser
from urllib.parse import urlsplit


def origin(url: str) -> tuple[str, str, int]:
    parts = urlsplit(url)
    port = parts.port or {"https": 443, "http": 80}.get(parts.scheme, 0)
    return parts.scheme, (parts.hostname or "").lower(), port


def checked_authorization_url(endpoint: str, issuer: str) -> str:
    if not endpoint.isascii() or any(c <= " " or c in "\\\x7f" for c in endpoint):
        raise ValueError("Unzulässiges Zeichen in der URL")
    parts = urlsplit(endpoint)
    if parts.scheme != "https":
        raise ValueError("authorization_endpoint ist kein https")
    if parts.username is not None or parts.password is not None:
        raise ValueError("Userinfo in der URL")
    if origin(endpoint) != origin(issuer):
        raise ValueError("authorization_endpoint passt nicht zum Issuer")
    return endpoint


def open_authorization(endpoint: str, issuer: str) -> None:
    webbrowser.open(checked_authorization_url(endpoint, issuer))

Die Zeichenprüfung lehnt Leer-, Steuer- und Nicht-ASCII-Zeichen, Backslashes und Userinfo ab, weil Browser solche URLs anders lesen als Python. Aus https://evil.com\@auth.example.com/ liest urlsplit den Host auth.example.com, ein Browser dagegen evil.com. Den Verzicht auf die Shell ersetzt die Prüfung nicht, denn $ und Klammern sind in URLs erlaubt. Entscheidend ist, dass die URL nie Teil eines zusammengesetzten Shell-Befehls wird. webbrowser.open oder ein Prozessaufruf mit Argumentliste erfüllen das. Auch der Origin-Vergleich ist nur so gut wie der Issuer. Nach RFC 8414 muss der Issuer in den Metadaten dem Issuer-Wert entsprechen, aus dem der Client die Metadaten-URL gebildet hat. Gegen einen bösartigen Server, der sein eigener Autorisierungsserver ist, hilft der Vergleich nicht, dort schützt nur der Verzicht auf die Shell. Wenn ein Autorisierungsserver bewusst Endpunkte auf einem anderen Host nutzt, gehört dieser Host auf eine ausdrückliche Freigabeliste, statt die Prüfung zu lockern.

Was ich hier prüfe

Ich lese, wo in einem System Provider-Keys liegen: im Gateway, in Umgebungsvariablen, bei Hostern, in Agenten-Konsolen und auf den Rechnern der Entwickler*innen. Für jeden Key klärt das Review, welche Anwendung ihn nutzt, welches Limit gilt, wer ihn rotieren kann und ob er in Logs auftauchen kann. Dazu kommen die Netzwege des Gateways nach außen, die Release-Kette, über die das Gateway selbst ins System kommt, und bei MCP-Clients der Umgang mit OAuth-Metadaten fremder Server. Ergebnis ist eine priorisierte Liste von Befunden mit je einem Umbauvorschlag.

Quellen