# T1218.015 - Electron Applications > [!warning] Técnica Emergente - Alta Dificuldade de Detecção > O abuso de aplicações Electron é particularmente difícil de detectar porque o processo malicioso aparece como uma aplicação legítima e amplamente confiável (Slack, VS Code, Teams). EDRs baseados em reputação de processo têm baixa cobertura. Requer abordagem de detecção baseada em comportamento de linha de comando e atividade de rede filha. ## Técnica Pai Esta é uma sub-técnica de [[t1218-system-binary-proxy-execution|T1218 - T1218 - System Binary Proxy Execution]]. ## Descrição **T1218.015 - Electron Applications** descreve o abuso do framework **Electron** - plataforma open-source desenvolvida originalmente pelo GitHub para criar aplicações desktop multiplataforma usando tecnologias web (JavaScript, HTML, CSS, Node.js) - para executar código malicioso contornando controles de segurança. O Electron é a base de dezenas de aplicações corporativas amplamente deployadas: **Slack**, **Microsoft Teams** (versão legada), **Visual Studio Code**, **Discord**, **Obsidian**, **WhatsApp Desktop**, **Figma** e muitas outras. Essas aplicações são tipicamente de alta confiança em listas de permissão de EDR/AV, pois são assinadas digitalmente por vendedores legítimos. A técnica pertence à categoria de **LOLBIN cross-platform** - ao contrário da maioria das LOLBins que são exclusivas do Windows, o Electron funciona em Windows, macOS e Linux, expandindo a superfície de ataque. **Por que o Electron é abusável:** - Aplicações Electron executam um processo **Chromium** (renderizador) e um processo **Node.js** (backend) - O Node.js tem acesso completo ao sistema operacional via APIs nativas (`fs`, `child_process`, `net`) - Algumas aplicações Electron expõem interfaces de linha de comando que aceitam flags de execução do Chromium/V8 como `--inspect`, `--require`, `--gpu-launcher` - Essas flags podem ser usadas para executar JavaScript arbitrário com os privilégios do processo Electron A técnica se enquadra em [[t1218-system-binary-proxy-execution|T1218 - System Binary Proxy Execution]] pois usa binários legítimos e assinados como proxy para execução de código não confiável. ## Como Funciona Existem três vetores primários de abuso de aplicações Electron: --- **Vetor 1 - Flags de linha de comando do Chromium Engine:** O Chromium (motor subjacente de todo app Electron) aceita flags de execução que podem injetar comandos. A flag mais conhecida é `--gpu-launcher`, que específica um executável a ser lançado como "GPU process launcher": ```batch # Abuso do Teams legado para executar calc.exe (PoC) "C:\Users\user\AppData\Local\Microsoft\Teams\current\Teams.exe" ^ --disable-gpu-sandbox ^ --gpu-launcher="C:\Windows\system32\cmd.exe /c calc.exe" # Abuso do VS Code "C:\Users\user\AppData\Local\Programs\Microsoft VS Code\Code.exe" ^ --disable-gpu-sandbox ^ --gpu-launcher="C:\Windows\system32\cmd.exe /c powershell -enc BASE64PAYLOAD" ``` **Vetor 2 - Node.js `--require` para injeção de módulo:** Aplicações Electron que expõem o Node.js inspector ou aceitam flags `--require` podem ser usadas para carregar um módulo JavaScript malicioso: ```batch # Força carregamento de script JS externo ao iniciar app Electron electron.exe --require /tmp/malicious.js app.js # Via variável de ambiente NODE_OPTIONS (afeta todos os processos Node.js/Electron) set NODE_OPTIONS=--require /path/to/malicious.js slack.exe ``` **Vetor 3 - Modificação de arquivos asar (pacote da aplicação):** Aplicações Electron empacotam seu código JavaScript em arquivos `.asar` (formato de arquivo de aplicação do Electron). Se o adversário tiver acesso de escrita ao diretório da aplicação, pode modificar o arquivo `app.asar` para inserir JavaScript malicioso que é executado toda vez que a aplicação inicia: ```bash # Extrair, modificar e reempacotar app.asar npx asar extract app.asar app_unpacked/ # Inserir código malicioso em app_unpacked/main.js npx asar pack app_unpacked/ app.asar # Próxima execução da aplicação carrega o backdoor ``` **Vetor 4 - Planting via `ELECTRON_RUN_AS_NODE`:** A variável de ambiente `ELECTRON_RUN_AS_NODE=1` transforma qualquer binário Electron em um runtime Node.js puro, permitindo execução de JavaScript arbitrário: ```bash ELECTRON_RUN_AS_NODE=1 /Applications/Visual\ Studio\ Code.app/Contents/MacOS/Electron /tmp/malicious.js ``` Este vetor é particularmente efetivo em macOS/Linux onde o Gatekeeper/SELinux confia no binário assinado. ## Attack Flow ```mermaid graph TB A["Acesso inicial ao endpoint<br/>(phishing, exploit, credencial)"] --> B["Reconhecimento de<br/>aplicações Electron instaladas"] B --> C{Vetor escolhido} C -->|"Flags Chromium"| D["Identifica app vulnerável<br/>(Teams, Slack, VSCode)"] C -->|"NODE_OPTIONS / require"| E["Seta variável de ambiente<br/>NODE_OPTIONS=--require malicious.js"] C -->|"Modificação .asar"| F["Escreve código JS malicioso<br/>dentro de app.asar"] C -->|"ELECTRON_RUN_AS_NODE"| G["Usa binário Electron como<br/>runtime Node.js standalone"] D --> H["Executa app com flags<br/>--disable-gpu-sandbox<br/>--gpu-launcher=payload"] E --> I["Próxima execução<br/>do app carrega módulo malicioso"] F --> I G --> J["Executa JS arbitrário<br/>com confiança do binário assinado"] H --> K["Processo filho malicioso<br/>apparece como filho do app legítimo"] I --> K J --> K K --> L{Objetivo pós-exploração} L -->|"Evasão AV/EDR"| M["Shellcode executado como<br/>filho de process confiável"] L -->|"Persistência"| N["Backdoor JS persiste<br/>em app.asar modificado"] L -->|"Credential access"| O["T1555 Credentials From Password Stores<br/>Acesso a keychain/credenciais armazenadas"] M --> P["Beacon C2 estabelecido<br/>sob cobertura de app legítimo"] N --> P O --> P style A fill:#8B0000,color:#fff style D fill:#CC6600,color:#fff style E fill:#CC6600,color:#fff style F fill:#CC6600,color:#fff style G fill:#CC6600,color:#fff style K fill:#990000,color:#fff style M fill:#4B0082,color:#fff style N fill:#4B0082,color:#fff style P fill:#1a1a2e,color:#eee ``` ## Exemplos de Uso ### Lazarus Group (DPRK) - Operation DreamJob O [[g0032-lazarus-group|Lazarus Group]], grupo APT atribuído à Coreia do Norte, está documentado abusando de aplicações Electron em múltiplas campanhas. Na operação **DreamJob** (2023-2024), o grupo utilizou aplicações Electron falsas - disfarçadas de ferramentas de entrevista de emprego para profissionais de criptomoeda - que ao serem executadas carregavam malware Node.js disfarçado de código legítimo da aplicação. O [[lumma-stealer|Lumma Stealer]], infostealer usado extensivamente pelo ecossistema de crime cibernético, foi documentado sendo entregue via aplicações Electron falsas distribuídas como "ferramentas de produtividade" em campanhas de phishing direcionadas a profissionais de tecnologia. ### UNC2447 / FIN11 (Crime Financeiro) O grupo [[unc2447|UNC2447]], associado a operações de ransomware e extorsão financeira, foi documentado abusando do mecanismo de `--inspect` do Node.js em aplicações Electron para injetar código em tempo de execução em workstations de alvos corporativos, facilitando coleta de credenciais. ### Campanhas genéricas de infostealer via fake Electron apps Uma classe crescente de ataques distribui aplicações Electron falsas - clones de apps legítimas como VS Code, Obsidian, Notion - que contêm JavaScript malicioso embutido no `app.asar`. Essas campanhas são documentadas em relatórios da **Recorded Future**, **Mandiant** e **Group-IB** como vetor crescente para roubo de credenciais corporativas (SSO tokens, VPN credentials, cloud access keys). ### Sequestro de NODE_OPTIONS em ambientes CI/CD Em ambientes de desenvolvimento com pipelines CI/CD, adversários com acesso a variáveis de ambiente de pipeline (ex: GitHub Actions secrets) podem injetar `NODE_OPTIONS=--require malicious.js` para comprometer builds e exfiltrar segredos armazenados no ambiente. ## Detecção ### Regras Sigma **Regra 1 - Aplicação Electron executada com flags de execução suspeitas** ```yaml title: Electron Application Launched with Suspicious Execution Flags id: c4e8f2a6-9b1d-4f7c-a3e0-6d2b8f4c1e9a status: production description: > Detecta aplicações Electron conhecidas sendo executadas com flags do Chromium/Node.js que permitem execução de código arbitrário. Indica possível abuso via T1218.015. references: - https://attack.mitre.org/techniques/T1218/015/ - https://github.com/nicowillis/electron-lolbin author: RunkIntel Detection Engineering daté: 2026/03/25 tags: - attack.defense_evasion - attack.t1218.015 - attack.execution logsource: category: process_creation product: windows detection: selection_electron_apps: Image|contains: - '\slack.exe' - '\Teams.exe' - '\Code.exe' - '\discord.exe' - '\obsidian.exe' - '\notion.exe' - '\figma.exe' - '\whatsapp.exe' selection_dangerous_flags: CommandLine|contains: - '--gpu-launcher' - '--disable-gpu-sandbox' - '--require' - '--inspect' - '--inspect-brk' - 'ELECTRON_RUN_AS_NODE' condition: selection_electron_apps and selection_dangerous_flags falsepositives: - Ferramentas de desenvolvimento legítimas debugando aplicações Electron - Scripts de automação de QA/teste level: high fields: - Image - CommandLine - ParentImage - User - IntegrityLevel ``` **Regra 2 - Processo shell como filho de aplicação Electron** ```yaml title: Shell Process Spawned by Electron Application id: d9f1b3c7-4e6a-4b0d-8c2f-1a7e3d9b5f0c status: production description: > Detecta processos de shell (cmd, powershell, sh, bash) gerados como filhos diretos de aplicações Electron. Altamente suspeito - uso normal de apps Electron não gera processos de shell diretamente. author: RunkIntel Detection Engineering daté: 2026/03/25 tags: - attack.defense_evasion - attack.t1218.015 - attack.execution logsource: category: process_creation product: windows detection: selection_electron_parent: ParentImage|contains: - '\slack.exe' - '\Teams.exe' - '\Code.exe' - '\discord.exe' - '\obsidian.exe' selection_shell_child: Image|endswith: - '\cmd.exe' - '\powershell.exe' - '\wscript.exe' - '\cscript.exe' - '\mshta.exe' - '\certutil.exe' - '\bitsadmin.exe' filter_vscode_legit: # VS Code legítimo pode spawnar terminais integrados ParentImage|endswith: '\Code.exe' CommandLine|contains: '--ms-enable-electron-run-as-node' condition: (selection_electron_parent and selection_shell_child) and not filter_vscode_legit falsepositives: - VS Code terminal integrado (parcialmente filtrado acima) - Apps Electron customizados empresariais com shell embutido level: high ``` **Regra 3 - Modificação de arquivo .asar de aplicação** ```yaml title: Electron Application ASAR File Modification id: e2a5c8f1-7d3b-4e0a-9c6f-4b1d8e2a5c7f status: experimental description: > Detecta escrita em arquivos .asar de aplicações Electron instaladas, indicando possível backdooring via T1218.015 (vetor modificação de pacote). author: RunkIntel Detection Engineering daté: 2026/03/25 tags: - attack.persistence - attack.t1218.015 logsource: category: file_event product: windows detection: selection: TargetFilename|contains: - '\app.asar' - '\app-updaté.asar' TargetFilename|endswith: '.asar' filter_updater: Image|contains: - '\Updaté.exe' - '\Squirrel.exe' - '\installer' condition: selection and not filter_updater falsepositives: - Instaladores/updaters legítimos de aplicações Electron - Desenvolvedores modificando apps em máquinas de desenvolvimento level: medium ``` ### Estrategia de detecção comportamental | Comportamento | Fonte de log | Severidade | |--------------|-------------|-----------| | Processo shell filho de app Electron | Sysmon EID 1 / EDR | Crítica | | Conexão de rede de processo filho de app Electron | Sysmon EID 3 | Alta | | Escrita em `app.asar` por processo não-updater | Sysmon EID 11 | Alta | | `NODE_OPTIONS` com `--require` em variável de ambiente | Sysmon EID 1 (EnvVars) | Alta | | `ELECTRON_RUN_AS_NODE=1` em linha de comando ou env | Sysmon EID 1 | Alta | | Leitura de arquivos de credencial por processo Electron | Sysmon EID 11 | Média | ## Mitigação | ID | Mitigação | Descrição | Plataforma | |----|-----------|-----------|-----------| | [[m1042-disable-or-remove-feature-or-program\|M1042]] | Disable or Remove Feature or Program | Remover aplicações Electron que não são necessárias operacionalmente. Preferir versões web (browser) de Slack, Teams e similares quando possível - eliminam o vetor de LOLBin. | Windows, macOS, Linux | | [[m1038-execution-prevention\|M1038]] | Execution Prevention | Implementar regras de WDAC (Windows Defender Application Control) ou SELinux/AppArmor que restrinjam quais aplicações Electron podem ser executadas e com quais argumentos. Bloquear flags `--gpu-launcher` e `--require` via política. | Windows, Linux | | [[m1050-exploit-protection\|M1050]] | Exploit Protection | Habilitar mitigações de processo no Windows Defender para processos Electron específicos: restringir processos filhos (`BlockChildProcess`), desabilitar importação de Win32k. | Windows | | Integridade de arquivos .asar | Controle compensatório | Implementar monitoramento de integridade de arquivos (FIM) para arquivos `.asar` de aplicações corporativas críticas. Alertar sobre qualquer modificação fora de jánelas de manutenção aprovadas. | Todas as plataformas | | Restrição de variáveis de ambiente | Hardenamento | Implementar políticas que impeçam a definição de `NODE_OPTIONS` ou `ELECTRON_RUN_AS_NODE` por usuários não privilegiados via GPO (Windows) ou PAM (Linux/macOS). | Todas as plataformas | | Versão atualizada dos apps | Gestão de vulnerabilidades | Vendors de apps Electron têm corrigido vetores de abuso em versões mais recentes. Manter apps como Teams, Slack, VS Code atualizados reduz a superfície explorável. | Todas as plataformas | ## Contexto Brasil/LATAM > [!info] Relevância para o Ecossistema Corporativo Brasileiro > Slack, Teams e VS Code são ferramentas onipresentes em empresas de tecnologia, fintechs e startups brasileiras - exatamente os alvos preferenciais de grupos de infostealer e ransomware com foco em LATAM. ### Grupos e campanhas relevantes para LATAM O [[g0032-lazarus-group|Lazarus Group]] tem histórico documentado de ataques a empresas de fintech e criptomoedas no Brasil e México, frequentemente usando aplicações falsas como vetor inicial. Campanhas de **Operation DreamJob** recrutando desenvolvedores na LATAM distribuíram aplicações Electron maliciosas disfarçadas de "testes técnicos" de entrevistas. Operadores de [[lumma-stealer|Lumma Stealer]] e similares (RedLine, Vidar) ativos na LATAM distribuem aplicações Electron falsas através de: - Anúncios pagos no Google/Meta fingindo ser ferramentas de produtividade - Repositórios GitHub com nomes de ferramentas populares - Grupos do Telegram e Discord em comunidades de desenvolvimento ### Perfil de vítimas típicas no Brasil - **Desenvolvedores de software** - alta probabilidade de ter VS Code e ferramentas de desenvolvimento - **Profissionais de criptomoeda** - alvo do Lazarus Group via fake trading apps - **Funcionários de startups e fintechs** - alto uso de Slack/Notion, menor maturidade de segurança - **Freelancers e agências** - maior exposição a ferramentas de terceiros sem controles corporativos ### Indicadores para SOCs brasileiros 1. Monitorar processos filhos de aplicações Electron com ferramentas como **Elastic Security** ou **Microsoft Sentinel** com regras customizadas 2. Verificar hashes de arquivos `.asar` em endpoints corporativos contra baseline 3. Alertar sobre uso de `NODE_OPTIONS` como variável de ambiente em processos de usuário 4. Treinar usuários sobre riscos de instalar "ferramentas de produtividade" de fontes não oficiais ## Referências - [MITRE ATT&CK - T1218.015](https://attack.mitre.org/techniques/T1218/015/) - [Electron Security Documentation - Electron.js](https://www.electronjs.org/docs/latest/tutorial/security) - [Electron LOLBin Research - nicowillis/electron-lolbin](https://github.com/nicowillis/electron-lolbin) - [Abusing Electron apps to bypass macOS security controls - Objective-See](https://objective-see.org/blog.html) - [Lazarus Group Operation DreamJob (2024) - ESET Research](https://www.welivesecurity.com/en/eset-research/operation-dreamjob-lazarus-targets-nuclear-sector/) - [Lumma Stealer via Electron - Recorded Future](https://www.recordedfuture.com/) - [NODE_OPTIONS abuse in CI/CD environments - research](https://book.hacktricks.xyz/linux-hardening/bypass-bash-restrictions/bypass-fs-protections-read-only-no-exec-distroless) **Técnicas relacionadas:** [[t1218-system-binary-proxy-execution|T1218]], [[t1059-007-javascript|T1059.007 - JavaScript]], [[t1059-001-powershell|T1059.001 - PowerShell]], [[t1546-persistence-via-event-triggered-execution|T1546 - Event Triggered Execution]], [[t1555-credentials-from-password-stores|T1555 - Credentials from Password Stores]] **Malware associado:** [[lumma-stealer|Lumma Stealer]] **Grupos:** [[g0032-lazarus-group|Lazarus Group]], [[unc2447|UNC2447]] --- *Fonte: [MITRE ATT&CK - T1218.015](https://attack.mitre.org/techniques/T1218/015)*