# Aplicaciones de Escritorio Electron
Aprende a hackear AWS de cero a héroe conhtARTE (Experto en Equipos Rojos de AWS de HackTricks)!
Otras formas de apoyar a HackTricks:
* Si deseas ver tu **empresa anunciada en HackTricks** o **descargar HackTricks en PDF** Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Obtén el [**oficial PEASS & HackTricks swag**](https://peass.creator-spring.com)
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección de [**NFTs**](https://opensea.io/collection/the-peass-family) exclusivos
* **Únete al** 💬 [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de telegram**](https://t.me/peass) o **síguenos** en **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs a los repositorios de** [**HackTricks**](https://github.com/carlospolop/hacktricks) y [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud).
### [WhiteIntel](https://whiteintel.io)
[**WhiteIntel**](https://whiteintel.io) es un motor de búsqueda alimentado por la **dark web** que ofrece funcionalidades **gratuitas** para verificar si una empresa o sus clientes han sido **comprometidos** por **malwares de robo**.
Su objetivo principal es combatir los secuestros de cuentas y los ataques de ransomware resultantes de malwares que roban información.
Puedes visitar su sitio web y probar su motor de forma **gratuita** en:
{% embed url="https://whiteintel.io" %}
***
## 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, es posible encontrar el código de la aplicación de 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 establecen las configuraciones 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)
![](<../../../.gitbook/assets/image (182).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 **evitarán que la aplicación Electron sea vulnerable a RCE** u otras vulnerabilidades si los **ajustes se configuran correctamente**.
La aplicación Electron **podría acceder al dispositivo** a través de las API de Node aunque se puede configurar para evitarlo:
* **`nodeIntegration`** - está `desactivado` de forma predeterminada. Si está activado, permite acceder a las funciones de Node desde el proceso de renderizado.
* **`contextIsolation`** - está `activado` de forma predeterminada. Si se desactiva, los procesos principal y de renderizado no están aislados.
* **`preload`** - vacío de forma predeterminada.
* [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está desactivado de forma predeterminada. Restringirá las acciones que NodeJS puede realizar.
* Integración de Node en Workers
* **`nodeIntegrationInSubframes`** - está `desactivado` de forma predeterminada.
* Si **`nodeIntegration`** está **habilitado**, esto permitiría el uso de **APIs de Node.js** en páginas web que se **cargan en iframes** dentro de una aplicación Electron.
* Si **`nodeIntegration`** está **deshabilitado**, 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 **payloads de RCE** de [aquí](https://7as.es/electron/nodeIntegration\_rce.txt):
```html
Example Payloads (Windows):
Example Payloads (Linux & MacOS):
```
### Captura de tráfico
Modifica la configuración start-main y agrega 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. Verifica cómo en:
{% content-ref url="../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md" %}
[macos-electron-applications-injection.md](../../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-electron-applications-injection.md)
{% endcontent-ref %}
## RCE: XSS + nodeIntegration
Si la opción **nodeIntegration** está configurada en **on**, el JavaScript de una página web puede utilizar fácilmente las funciones de Node.js simplemente llamando a `require()`. Por ejemplo, la forma de ejecutar la aplicación de calculadora en Windows es:
```html
```
## RCE: preload
El script indicado en esta configuración se **carga antes que otros scripts en el renderizador**, 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 las características del nodo a las páginas:
{% code title="preload.js" %}
```javascript
typeof require === 'function';
window.runCalc = function(){
require('child_process').exec('calc')
};
```
{% endcode %}
{% code title="index.html" %}
```html
```
{% endcode %}
{% hint style="info" %}
**Si `contextIsolation` está activado, esto no funcionará**
{% endhint %}
## RCE: XSS + contextIsolation
El _**contextIsolation**_ introduce los **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 se afecte mutuamente. 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 integrado** que se utiliza en el código de precarga o en el código interno de Electron por una función propia
3. **Disparar** el uso de la **función sobrescrita**
4. ¿RCE?
Hay 2 lugares donde los métodos integrados pueden ser sobrescritos: En el código de precarga o en el código interno de Electron:
{% content-ref url="electron-contextisolation-rce-via-preload-code.md" %}
[electron-contextisolation-rce-via-preload-code.md](electron-contextisolation-rce-via-preload-code.md)
{% endcontent-ref %}
{% content-ref url="electron-contextisolation-rce-via-electron-internal-code.md" %}
[electron-contextisolation-rce-via-electron-internal-code.md](electron-contextisolation-rce-via-electron-internal-code.md)
{% endcontent-ref %}
{% content-ref url="electron-contextisolation-rce-via-ipc.md" %}
[electron-contextisolation-rce-via-ipc.md](electron-contextisolation-rce-via-ipc.md)
{% endcontent-ref %}
### Bypass al evento de clic
Si hay restricciones aplicadas cuando haces clic en un enlace, es posible que puedas evitarlas **haciendo clic medio** en lugar de un clic izquierdo regular
```javascript
window.addEventListener('click', (e) => {
```
## RCE a través de shell.openExternal
Para obtener 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 garantizar la configuración correcta de `nodeIntegration` y `contextIsolation`. Se ha establecido que la **ejecución de código remoto en el lado del cliente (RCE)** dirigida 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, los cuales 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 listeners 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 suele tomarse 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í tienes un seudocódigo simplificado:**
![https://miro.medium.com/max/1400/1\*iqX26DMEr9RF7nMC1ANMAA.png](<../../../.gitbook/assets/image (261).png>)
![https://miro.medium.com/max/1400/1\*ZfgVwT3X1V\_UfjcKaAccag.png](<../../../.gitbook/assets/image (963).png>)
Las mejores prácticas de seguridad de Electron JS desaconsejan aceptar contenido no confiable con la función `openExternal`, ya que podría provocar una ejecución remota de código a través de varios protocolos. Los sistemas operativos admiten diferentes protocolos que podrían desencadenar una ejecución remota de código. Para obtener ejemplos detallados y una explicación más profunda 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
```
## Lectura de archivos internos: XSS + contextIsolation
**Desactivar `contextIsolation` permite el uso de etiquetas ``, similares a `