boku7/loki🧙♂️ Node.js Command & Control zum Script-Jacking verwundbarer Electron-Anwendungen
# 🧙♂️ Loki Command & Control
Loki ist ein Command-and-Control-Framework (C2) der Stufe 1, geschrieben in Node.js, das verwundbare Electron-Apps per Script-Jacking übernimmt _[MITRE ATT&CK T1218.015](https://attack.mitre.org/techniques/T1218/015/)_. Loki wurde für Red-Team-Operationen entwickelt und ermöglicht die Umgehung von Sicherheitssoftware und Anwendungskontrollen durch die Ausnutzung vertrauenswürdiger, signierter Electron-Apps.
Beim Script-Jacking wird der Ausführungsfluss einer Electron-App gekapert, indem zur Laufzeit geladene JavaScript-Dateien mit beliebigem Node.js-Code modifiziert werden. Diese Technik kann genutzt werden, um:
- __Electron-Apps zu backdooren__
- __Electron-Apps auszuhöhlen__
- Die Ausführung auf einen anderen Prozess zu verketten
_Während sich mehrere Tools bereits damit befassen, Script-Jacking zu nutzen, um die Ausführung auf einen anderen Prozess zu verketten, ist Loki das erste, das das Backdooring und Hollowing signierter Electron-Apps ermöglicht, ohne deren Code-Signatur zu invalidieren._
Weitere Details zur Funktionsweise von Loki findest du in diesem Blogbeitrag:
- [Umgehung der Windows Defender Application Control mit Loki C2](https://www.ibm.com/think/x-force/bypassing-windows-defender-application-control-loki-c2)
## 🚀 Mitwirkende
| Name | Beiträge |
|---------------------|-------------------------------|
| [Bobby Cooke](https://x.com/0xBoku) | Ersteller & Betreuer |
| [Dylan Tran](https://x.com/d_tranman) | Ersteller |
| [Ellis Springe](https://x.com/knavesec)| Alpha-Tester |
| [Shawn Jones](https://x.com/anthemtotheego) | Assembly-Ausführungscode |
| [Trusted Sec](https://github.com/trustedsec/COFFLoader) | COFFLoader-Code |
| [Simon Exley](https://www.linkedin.com/in/simon-exley-355816194/) | Video-Ersteller |
| [Clinton Elves](https://www.linkedin.com/in/clinton-elves-180ba0148/) | Video-Ersteller |
| [John Hammond](https://x.com/_JohnHammond) | Video-Ersteller |
## Videos
Schau dir dieses Video von [John Hammond](https://x.com/_JohnHammond) an, in dem er Cursor AI mit Loki C2 backdoort! 🎩
- Im Video zeigt er, wie man eine neue verwundbare Electron-Anwendung entdeckt, sie mit Loki C2 backdoort, sich mit der Client-GUI einrichtet, und wir haben sogar zwei Möglichkeiten entwickelt, die App dauerhaft im Hintergrund laufen zu lassen 🪄 -- Aus Sicht des Endbenutzers läuft Cursor ganz normal! 🥷
[](https://www.youtube.com/watch?v=FYok3diZY78)
Schau dir dieses Video von [Simon Exley & Clinton Elves](https://x.com/SimonExley25688) an, um mit Loki C2 loszulegen! 🧙♂️
[](https://www.youtube.com/watch?v=c8DgrpwJWw0)
## Funktionen & Details
- Azure Storage Blob C2-Kanal
- SAS-Token zum Schutz des C2-Speicherkontos
- AES-verschlüsselte C2-Nachrichten
- Proxy-bewusster Agent
- Nutzt Chromium-Renderer-Kindprozesse für den Agent, Shellcode-Ausführung und Assembly-Ausführung im Fork-n-Run-Stil – erbt die Proxy-fähigen Fähigkeiten von Chromium.
- Ohne Teamserver
- Anders als bei herkömmlichen C2-Frameworks, bei denen Agents Nachrichten an einen Teamserver senden, gibt es keinen Teamserver
- Der GUI-Client und die Agents checken beide im selben Datenspeicher ein
- Verborgene Ausführung – läuft im Hintergrund
### Befehle
_Alle Agent-Befehle sind in nativem Node.JS geschrieben und benötigen keine zusätzlichen Abhängigkeiten oder Bibliotheksladeereignisse. Mit Ausnahme der Befehle `scexec` und `assembly`, die eine Bibliotheksladung auf `keytar.node` und `assembly.node` durchführen._
- Alle Befehle akzeptieren Pfade mit `/`, `\` in Pfaden funktioniert nicht.
| Befehl | Beschreibung |
|-------------|----------------------------------------------------------------------------|
| `help` | Hilfe anzeigen. Verwendung: `help` oder `help scan` |
| `pwd` | Arbeitsverzeichnis anzeigen |
| `ls` | Datei- und Verzeichnisliste |
| `cat` | Inhalt einer Datei anzeigen |
| `env` | Prozess-Umgebungsvariablen anzeigen |
| `spawn` | Einen Kindprozess starten |
| `drives` | Laufwerke auflisten |
| `mv` | Eine Datei zu einem neuen Ziel verschieben |
| `sleep` | Für Sekunden mit Jitter schlafen |
| `cp` | Eine Quelldatei zu einem Ziel kopieren |
| `exit-all` | Beendet den Agent; der Agent meldet sich nicht mehr zurück |
| `load` | Eine Node-PE-Datei von der Festplatte in den Prozess laden |
| `scexec` | Shellcode ausführen |
| `assembly` | Eine .NET-Assembly ausführen und Befehlsausgabe erhalten |
| `upload` | Eine Datei von deiner lokalen Operator-Box auf die entfernte Agent-Box hochladen |
| `download` | Eine Datei von der entfernten Agent-Box auf die lokale Operator-Box herunterladen |
| `scan` | TCP-Netzwerkscan über den CIDR-Bereich mit ausgewählten Ports durchführen |
| `dns` | DNS-Lookup. Nutzt die DNS-Konfiguration des Systems |
| `set` | Legt die Node-Ladepfade für Assembly-Node und Scexec-Node fest |
| `bof` | Eine COFF-Datei ausführen und Ausgabe zurückgeben |
#### `Set` – Nodes aus Ausschlusspfaden der Anwendungskontrolle laden
- Wenn Application-Control-Regeln das Laden von Bibliotheken für die Node-Dateien verhindern, kannst du mit dem Befehl `set` die Ladepfade für `assembly.node` und `scexec.node` ändern.
- Mit `ls`, `cat`, `cp` und `mv` kannst du möglicherweise die Application-Control-Regeln enumerieren, um ein beschreibbares Verzeichnis zu finden, das ausgenommen ist.
- Damit kannst du die Node-Dateien in das Ausschlussverzeichnis legen und mit dem Befehl `set` ihren Ladepfad auf das Ausschlussverzeichnis ändern, um die Anwendungskontrolle zu umgehen.
- Weitere Details zu diesem Angriffsvektor findest du im Kurs [CRTO2](https://training.zeropointsecurity.co.uk/courses/red-team-ops-ii) von [Daniel Duggan (@_RastaMouse)](https://x.com/_RastaMouse)
```
[04-04-2025 8:50AM MST] advsim$ help set
Set the Node load paths for assembly node and scexec nodes
set scexec_path C:/Users/user/AppData/ExcludedApp/scexec.node
set assembly_path C:/Users/user/AppData/ExcludedApp/assembly.node
[04-04-2025 8:51AM MST] advsim$ set scexec_path C:/Users/user/AppData/ExcludedApp/scexec.node
SCEXEC Node Load Path Set to : C:/Users/user/AppData/ExcludedApp/scexec.node
```
### Agent-Funktionen
[Weitere Informationen zu den Agent-Funktionen findest du hier](https://github.com/boku7/loki/blob/main/docs/features/agent.md)
### Client-Funktionen
[Weitere Informationen zu den Client-Funktionen findest du hier](https://github.com/boku7/loki/blob/main/docs/features/client.md)
## 🧙♂️ Illusionen bereitstellen
Zuerst musst du eine verwundbare Electron-Anwendung identifizieren, die keine ASAR-Sicherheitsintegritätsprüfungen durchführt, wie z. B. `Microsoft Teams`. Neuere Anwendungen können Integritätsprüfungen haben, die das Backdooring verhindern. Ältere Versionen der Ziel-App sind mit größerer Wahrscheinlichkeit verwundbar.
- [Leitfaden zum Entdecken verwundbarer Electron-Apps](https://github.com/boku7/loki/blob/main/docs/vulnhunt/electronapps.md)
### Einfache Anleitung
_Du musst den Agent beim Backdooring von Electron-Apps nicht kompilieren. Ersetze einfach den Inhalt von `{ELECTRONAPP}/resources/app/` mit den Loki-Agent-Dateien._
### Detaillierte Anleitung
#### Schritt 1: Azure Storage Blob-Konto erstellen und SAS-Token erhalten
- [Azure-Speicherkonto über das Azure-Portal erstellen](https://github.com/boku7/loki/blob/main/docs/azure/create-storage-account-portal.md)
- [Azure-Speicherkonto über die Azure CLI erstellen](https://github.com/boku7/loki/blob/main/docs/azure/create-storage-account-sas-azurecli.md)
#### Schritt 2: Verschleiertes Loki-Payload erstellen
- Klone dieses Repo und wechsle per `cd` hinein
- Installiere Node.JS
- Installiere das Modul `javascript-obfuscator`
```
npm install --save-dev javascript-obfuscator
```
- Führe das Skript `create_agent_payload.js` aus, um ein Loki-Payload mit deinen Storage-Account-Informationen zu erstellen
```
bobby$ node create_agent_payload.js
[+] Provide Azure storage account information:
- Enter Storage Account : 7f7584ty218ba5dba778.blob.core.windows.net
- Enter SAS Token : se=2025-05-28T23%3A14%3A48Z&sp=rwdlac&spr=https&sv=2022-11-02&ss=b&srt=sco&sig=5MXQzJ6FDZK8yYiBSgJ6FDZKgQzJMXBSgg6qE4ydrJ6FDZKSgg%3D
[+] Configuration:
- Storage Account : 7f7584ty218ba5dba778.blob.core.windows.net
- SAS Token : se=2025-05-28T23%3A14%3A48Z&sp=rwdlac&spr=https&sv=2022-11-02&ss=b&srt=sco&sig=5MXQzJ6FDZK8yYiBSgJ6FDZKgQzJMXBSgg6qE4ydrJ6FDZKSgg%3D
- Meta Container : mllyi2zjmafjm
[+] Updated /Users/bobby/apr2/LokiC2/config.js with storage configuration.
- Enter into the Loki Client UI
Loki Client > Configuration
[+] Modifying PE binaries to have new hashes...
- Payload assembly.node hash : e9d126407264821d3c2d324da0e2d1bc13cbc53e7c56340fe12b07f69b707f02
- Payload keytar.node hash : 292c14ffebd6cae3df99d9fbee525e29a5a704f076b82207eb3e650de45b075d
[+] Payload ready!
- Obfuscated payload in the ./app directory
```
#### Schritt 3: Electron-Anwendung backdooren
- Dein verschleiertes Loki-Payload wird nach `./app/` ausgegeben
- Wechsle in das Verzeichnis `{ELECTRONAPP}/resources/`
- Lösche alles
- Kopiere den Loki-Ordner `./app/` nach `{ELECTRONAPP}/resources/app/`
- Klicke auf die Electron-PE-Datei und stelle sicher, dass Loki funktioniert
#### Schritt 4: Loki-Client konfigurieren
- Starte den Loki-GUI-Client
- Klicke in der Menüleiste auf `Loki Client > Configuration`, um das Einstellungsfenster zu öffnen
- Gib deine Storage-Account-Details ein und klicke auf `Save`
- Der Agent sollte jetzt im Dashboard erscheinen
- Klicke in der Dashboard-Tabelle auf den Agent, um das Agent-Fenster zu öffnen
- Teste, um sicherzustellen, dass Loki ordnungsgemäß funktioniert
## Electron-Apps backdooren und die echte Anwendung normal weiterlaufen lassen
Der einfachste Weg, Loki zu nutzen, besteht darin, die Dateien in `{ELECTRONAPP}/resources/app/` durch die Loki-Dateien zu ersetzen. Dies höhlt die App aus, d. h. die App funktioniert nicht mehr normal -- Loki hat ihre Funktionalität ersetzt.
Wenn du die Electron-Anwendung wirklich weiterlaufen lassen und zusätzlich Loki im Hintergrund bereitstellen möchtest, ist noch nicht alle Hoffnung verloren! [John Hammond](https://x.com/_JohnHammond) und ich haben einen Weg gefunden, die echte Electron-Anwendung weiterlaufen zu lassen. Wir haben dazu die Datei `/loki/backdoor/init.js` in dieses Repo aufgenommen.
Sie ist derzeit für Cursor eingerichtet, das von [John Hammond](https://x.com/_JohnHammond) als verwundbar entdeckt wurde.
Dazu musst du:
- Die Cursor-App herunterladen
- Alle Loki-Dateien außer `package.json` nach `cursor/resources/app/` einfügen
- Ersetze nicht das echte `package.json`
- Kopiere `/loki/backdoor/init.js` nach `cursor/resources/app/`
- Ändere den Inhalt von `cursor/resources/app/package.json` folgendermaßen:
- setze `"main":"init.js",`
- lösche `"type":"module",`
- lösche `"private":true,`
### Wie das funktioniert
- Durch diese Änderungen lädt `Cursor.exe` `init.js` beim Klick / bei der Ausführung
- `init.js` liest `package.json`
- `init.js` ändert `"main":"init.js",` -> `"main":"main.js",`
- `main.js` ist Loki
- `init.js` startet und löst sich von einem neuen `Cursor.exe`, der auf Loki zeigt
- __Loki wird im Hintergrund gestartet__
- `init.js` liest `package.json` erneut
- `init.js` ändert `"main":"main.js",` -> `"main":"./out/main.js",`
- `./out/main.js"` ist die echte Cursor-Anwendung
- `init.js` startet und löst sich von einem neuen `Cursor.exe`, der auf den echten Cursor zeigt
- __Die echte Cursor-App wird sichtbar gestartet und funktioniert normal__
- Wenn Cursor vom Benutzer beendet wird:
- `init.js` fängt die Beendigung ab
- `init.js` liest `package.json` zum dritten Mal
- `init.js` ändert `"main":"./out/main.js",` -> `"main":"init.js",`
Auf diese Weise ist die App dauerhaft backdoort und funktioniert normal. Wenn die Cursor-App beendet wird, läuft Loki weiter im Hintergrund.
### Zukunft
Ich werde in Zukunft ein Skript erstellen, um dies zu automatisieren.
## OPSEC-Empfehlungen
- [OPSEC-Empfehlungen](https://github.com/boku7/loki/blob/main/docs/opsec/recommendations.md)
## Kompilierungsanleitungen
Dies sind die Kompilierungsanweisungen zum Erstellen der Agents & Clients. Die Anweisungen decken mehrere Plattformen ab, einschließlich Windows, Linux und macOS. Es wird empfohlen, den Client auf der Zielplattform und -architektur zu kompilieren.
### Client
- [Windows](https://github.com/boku7/loki/blob/main/docs/compile/client/windows.md)
- [macOS](https://github.com/boku7/loki/blob/main/docs/compile/client/macos.md)
- [Linux](https://github.com/boku7/loki/blob/main/docs/compile/client/linux.md)
### Agents
**Wenn du eine Electron-Anwendung backdoort, musst du keine Agents kompilieren.**
Ich empfehle nicht, den Agent zu kompilieren und für Operationen zu verwenden. Die Kompilierungsanweisungen für Agents sind für die Entwicklung gedacht.
- [Windows](https://github.com/boku7/loki/blob/main/docs/compile/agent/windows.md)
- [Linux](https://github.com/boku7/loki/blob/main/docs/compile/agent/linux.md)
- [macOS](https://github.com/boku7/loki/blob/main/docs/compile/agent/macos.md)
## Erkennungshinweise
- Überprüfe die von MITRE bereitgestellten Informationen für weitere Details, Beispiele und Informationen zu dieser TTP:
- [MITRE ATT&CK T1218.015: Electron Applications](https://attack.mitre.org/techniques/T1218/015/)
- Ausführung einer Electron-App aus einem ungewöhnlichen Verzeichnis wie `~/Downloads/Teams/Teams.exe`
- Electron-Apps, die zu einem Azure Storage Blob `*.blob.core.windows.net` beaconen
- SAS-Token-Nutzung im Netzwerkverkehr
- Electron-Apps, die Kindprozesse wie `netstat.exe` oder `whoami.exe` starten
- Ein Verzeichnis mit dem Namen aus der Loki-`package.json` wird in `~/AppData/Roaming/{NAME}` erstellt, wenn das Loki-JavaScript im Electron-Prozess ausgeführt wird.
- Dieser [LOLBAS-Teams](https://lolbas-project.github.io/lolbas/OtherMSBinaries/Teams/)-Eintrag deckt Erkennungen für das Backdooring von Electron-Anwendungen ab. Die Erkennungsinformationen sind unten kopiert.
- IOC: Verzeichnis `%LOCALAPPDATA%\Microsoft\Teams\current\app` erstellt
- IOC: Datei `%LOCALAPPDATA%\Microsoft\Teams\current\app.asar` von einem Nicht-Teams-Installer/-Updater erstellt/geändert
- [SIGMA-Regel](https://github.com/4y45u45c4/SIGMA/blob/main/loki_c2_channel_established_from_electron_app.yaml) zur Erkennung eines etablierten Loki-C2-Kanals aus einer Electron-App
- [SIGMA-Regel](https://github.com/4y45u45c4/SIGMA/blob/main/hijack_of_electron_app_to_load_C2_framework.yaml) zur Erkennung der Übernahme des Electron-App-Ordners (Teams, VS Code, RingCentral, Postman) zum Laden des C2-Frameworks
# Referenzen || Danksagungen || Offensive-Electron-Forschung
- [Dylan Tran (@d_tranman)](https://x.com/d_tranman)
- Mitersteller des Loki-Agents. Erstellte Node-Module für Shellcode- und Assembly-Ausführung.
- [Valentina Palmiotti (@chompie1337)](https://x.com/chompie1337), [Ellis Springe (@knavesec)](https://x.com/knavesec) und [Ruben Boonen](https://x.com/FuzzySec) für ihre früheren internen Arbeiten zum Backdooring von Electron-Anwendungen für Persistenz
- [Ruben Boonen](https://x.com/FuzzySec)
- [ Wild West Hackin’ Fest talk Statikk Shiv: Leveraging Electron Applications for Post-Exploitation](https://www.youtube.com/watch?v=VXb6lwXhCAc)
- Andrew Kisliakov
- [Microsoft Teams und andere Electron-Apps als LOLbins](https://l--k.uk/2022/01/16/microsoft-teams-and-other-electron-apps-as-lolbins/)
- [Shawn Jones](https://x.com/anthemtotheego)
- Für die Loki-Assembly-Ausführung hat Dylan den öffentlichen [InlineExecute-Assembly](https://github.com/anthemtotheego/InlineExecute-Assembly)-Code von Shawn portiert.
- [mr.d0x (@mrd0x)](https://twitter.com/@mrd0x) für seine früheren Arbeiten zur Nutzung der Teams-Electron-Anwendung zur Ausführung beliebigen Node.JS-Codes und zur Veröffentlichung seiner Erkenntnisse im LOLBAS-Projekt.
- Michael Taggart
- [quASAR-Projekt, ein Tool zum Modifizieren von Electron-Anwendungen zur Ermöglichung von Befehlsausführung](https://github.com/mttaggart/quasar)
- [Quasar: Electron-Apps kompromittieren](https://taggart-tech.com/quasar-electron/)
- [Raphael Mudge](https://bsky.app/profile/raphaelmudge.bsky.social) dafür, dass er mich inspiriert hat, tief ins Red Teaming einzutauchen, und die Veröffentlichung dieses Tools unterstützt hat
- [The Security Conversation](https://aff-wg.org/)
- [Fletcher Davis](https://x.com/gymR4T)
- [BSides: Electron-Anwendungen missbrauchen](https://github.com/gymR4T/presentations/blob/main/BSidesNOVA2022_ElectronApplicationAbuse.pdf)
- [Pavel Tsakalidis](https://x.com/sadreck)
- [BEEMKA - Electron Exploitation Toolkit](https://github.com/ctxis/beemka)
## Lizenz
Dieses Projekt ist unter der Business Source License 1.1 lizenziert. Die nicht-kommerzielle Nutzung ist unter den Bedingungen der Lizenz gestattet. Die kommerzielle Nutzung erfordert die ausdrückliche Genehmigung des Autors. Am 3. April 2030 wird diese Lizenz in Apache 2.0 umgewandelt. Einzelheiten findest du in [LICENSE](https://github.com/boku7/loki/blob/main/LICENSE).