# Aplicativos Desktop Electron
Aprenda hacking AWS do zero ao herói comhtARTE (HackTricks AWS Red Team Expert)!
Outras maneiras de apoiar o HackTricks:
- Se você deseja ver sua **empresa anunciada no HackTricks** ou **baixar o HackTricks em PDF**, verifique os [**PLANOS DE ASSINATURA**](https://github.com/sponsors/carlospolop)!
- Adquira o [**swag oficial PEASS & HackTricks**](https://peass.creator-spring.com)
- Descubra [**A Família PEASS**](https://opensea.io/collection/the-peass-family), nossa coleção exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
- **Junte-se ao** 💬 [**grupo Discord**](https://discord.gg/hRep4RUj7f) ou ao [**grupo telegram**](https://t.me/peass) ou **siga-nos** no **Twitter** 🐦 [**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
- **Compartilhe seus truques de hacking enviando PRs para os** [**HackTricks**](https://github.com/carlospolop/hacktricks) e [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) repositórios do github.
## WhiteIntel
[**WhiteIntel**](https://whiteintel.io) é um mecanismo de busca alimentado pela **dark web** que oferece funcionalidades **gratuitas** para verificar se uma empresa ou seus clientes foram **comprometidos** por **malwares stealers**.
O principal objetivo do WhiteIntel é combater tomadas de contas e ataques de ransomware resultantes de malwares que roubam informações.
Você pode verificar o site deles e experimentar o mecanismo gratuitamente em:
{% embed url="https://whiteintel.io" %}
---
## Introdução
O Electron combina um backend local (com **NodeJS**) e um frontend (**Chromium**), embora falte alguns mecanismos de segurança dos navegadores modernos.
Normalmente, você pode encontrar o código do aplicativo Electron dentro de um aplicativo `.asar`, para obter o código, você precisa extrai-lo:
```bash
npx asar extract app.asar destfolder #Extract everything
npx asar extract-file app.asar main.js #Extract just a file
```
No código-fonte de um aplicativo Electron, dentro de `packet.json`, você pode encontrar especificado o arquivo `main.js` onde as configurações de segurança são definidas.
```json
{
"name": "standard-notes",
"main": "./app/index.js",
```
Electron possui 2 tipos de processos:
* Processo Principal (tem acesso completo ao NodeJS)
* Processo de Renderização (deve ter acesso restrito ao NodeJS por motivos de segurança)
![](<../../../.gitbook/assets/image (179).png>)
Um **processo de renderização** será uma janela do navegador carregando um arquivo:
```javascript
const {BrowserWindow} = require('electron');
let win = new BrowserWindow();
//Open Renderer Process
win.loadURL(`file://path/to/index.html`);
```
As configurações do **processo de renderização** podem ser **configuradas** no **processo principal** dentro do arquivo main.js. Algumas das configurações irão **prevenir que a aplicação Electron seja alvo de RCE** ou outras vulnerabilidades se as **configurações estiverem corretamente configuradas**.
A aplicação Electron **pode acessar o dispositivo** via APIs do Node, embora possa ser configurada para prevenir isso:
* **`nodeIntegration`** - está `desativado` por padrão. Se ativado, permite acessar recursos do Node a partir do processo de renderização.
* **`contextIsolation`** - está `ativado` por padrão. Se desativado, os processos principal e de renderização não estão isolados.
* **`preload`** - vazio por padrão.
* [**`sandbox`**](https://docs.w3cub.com/electron/api/sandbox-option) - está desativado por padrão. Irá restringir as ações que o NodeJS pode executar.
* Integração do Node em Workers
* **`nodeIntegrationInSubframes`** - está `desativado` por padrão.
* Se a **`nodeIntegration`** estiver **habilitada**, isso permitirá o uso das **APIs do Node.js** em páginas da web que são **carregadas em iframes** dentro de uma aplicação Electron.
* Se a **`nodeIntegration`** estiver **desabilitada**, então os preloads serão carregados no iframe
Exemplo de configuração:
```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
}
};
```
Alguns **cargas RCE** da [aqui](https://7as.es/electron/nodeIntegration\_rce.txt):
```html
Example Payloads (Windows):
Example Payloads (Linux & MacOS):
```
### Captura de tráfego
Modifique a configuração start-main e adicione o uso de um proxy como:
```javascript
"start-main": "electron ./dist/main/main.js --proxy-server=127.0.0.1:8080 --ignore-certificateerrors",
```
## Injeção de Código Local no Electron
Se você puder executar localmente um aplicativo Electron, é possível que você consiga fazê-lo executar código JavaScript arbitrário. Verifique como em:
{% 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
Se o **nodeIntegration** estiver definido como **on**, o JavaScript de uma página da web pode usar facilmente recursos do Node.js apenas chamando o `require()`. Por exemplo, a maneira de executar o aplicativo de calculadora no Windows é:
```html
```
## RCE: preload
O script indicado nesta configuração é **carregado antes de outros scripts no renderizador**, então ele tem **acesso ilimitado às APIs do Node**:
```javascript
new BrowserWindow{
webPreferences: {
nodeIntegration: false,
preload: _path2.default.join(__dirname, 'perload.js'),
}
});
```
Portanto, o script pode exportar recursos de nó para 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" %}
**Se `contextIsolation` estiver ativado, isso não funcionará**
{% endhint %}
## RCE: XSS + contextIsolation
O _**contextIsolation**_ introduz os **contextos separados entre os scripts da página da web e o código interno JavaScript do Electron** para que a execução do JavaScript de cada código não afete um ao outro. Esta é uma característica necessária para eliminar a possibilidade de RCE.
Se os contextos não estiverem isolados, um atacante pode:
1. Executar **JavaScript arbitrário no renderizador** (XSS ou navegação para sites externos)
2. **Sobrescrever o método integrado** que é usado no código de pré-carregamento ou no código interno do Electron para uma função própria
3. **Acionar** o uso da **função sobrescrita**
4. RCE?
Existem 2 lugares onde os métodos integrados podem ser sobrescritos: No código de pré-carregamento ou no código interno do 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 do evento de clique
Se houver restrições aplicadas quando você clica em um link, você pode ser capaz de contorná-las **fazendo um clique do meio** em vez de um clique esquerdo regular
```javascript
window.addEventListener('click', (e) => {
```
## RCE via shell.openExternal
Para mais informações sobre esses exemplos, consulte [https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8](https://shabarkin.medium.com/1-click-rce-in-electron-applications-79b52e1fe8b8) e [https://benjamin-altpeter.de/shell-openexternal-dangers/](https://benjamin-altpeter.de/shell-openexternal-dangers/)
Ao implantar um aplicativo de desktop Electron, garantir as configurações corretas para `nodeIntegration` e `contextIsolation` é crucial. Está estabelecido que a **execução de código remoto do lado do cliente (RCE)** direcionada a scripts de pré-carregamento ou código nativo do Electron a partir do processo principal é efetivamente impedida com essas configurações em vigor.
Ao interagir com links ou abrir novas janelas, ouvintes de eventos específicos são acionados, sendo cruciais para a segurança e funcionalidade do aplicativo:
```javascript
webContents.on("new-window", function (event, url, disposition, options) {}
webContents.on("will-navigate", function (event, url) {}
```
Estes ouvintes são **substituídos pela aplicação desktop** para implementar sua própria **lógica de negócios**. A aplicação avalia se um link navegado deve ser aberto internamente ou em um navegador web externo. Essa decisão é tipicamente feita por meio de uma função, `openInternally`. Se esta função retornar `false`, indica que o link deve ser aberto externamente, utilizando a função `shell.openExternal`.
**Aqui está um pseudocódigo simplificado:**
![https://miro.medium.com/max/1400/1\*iqX26DMEr9RF7nMC1ANMAA.png](<../../../.gitbook/assets/image (258).png>)
![https://miro.medium.com/max/1400/1\*ZfgVwT3X1V\_UfjcKaAccag.png](<../../../.gitbook/assets/image (960).png>)
As melhores práticas de segurança do Electron JS desaconselham aceitar conteúdo não confiável com a função `openExternal`, pois isso poderia levar a RCE por meio de vários protocolos. Sistemas operacionais suportam diferentes protocolos que podem acionar RCE. Para exemplos detalhados e uma explicação mais aprofundada sobre este tópico, pode-se consultar [este recurso](https://positive.security/blog/url-open-rce#windows-10-19042), que inclui exemplos de protocolos do Windows capazes de explorar essa vulnerabilidade.
**Exemplos de exploits de protocolos do Windows incluem:**
```html
```
## Leitura de Arquivos Internos: XSS + contextIsolation
**Desativar `contextIsolation` permite o uso de tags ``, semelhantes ao `