# T1055.011 - Extra Window Memory Injection ## Descrição **T1055.011 - Extra Window Memory Injection** é uma técnica sofisticada de injeção de processo que explora uma estrutura específica da arquitetura de jánelas do Windows: a **Extra Window Memory (EWM)**. Adversários injetam shellcode ou ponteiros maliciosos na EWM de jánelas pertencentes a processos legítimos do sistema, executando código arbitrário no contexto desses processos sem acionar as chamadas de API mais monitoradas pelos sistemas de defesa. Esta técnica é subtécnica de [[t1055-process-injection|T1055 - Process Injection]] e pertence à categoria de **Defense Evasion** e **Privilege Escalation** no framework MITRE ATT&CK, podendo ser utilizada para: - Executar shellcode no espaço de memória de processos legítimos confiáveis - Contornar soluções EDR que monitoram chamadas clássicas como `WriteProcessMemory` e `CreateRemoteThread` - Potencialmente contornar Data Execution Prevention (DEP) via combinação de window procedures e funções do sistema - Obter acesso a recursos e privilégios do processo alvo A técnica tira proveito do fato de que a EWM é uma área de memória **legítima e esperada** em qualquer jánela Windows registrada, tornando sua utilização virtualmente indistinguível de uso normal do sistema - desde que o adversário não cometa erros grosseiros de comportamento. > **Técnica pai:** [[t1055-process-injection|T1055 - Process Injection]] --- ## Como Funciona ### Arquitetura da Extra Window Memory Para entender a técnica, é necessário compreender o modelo de jánelas do Windows: **Window Classes e EWM:** Toda jánela no Windows pertence a uma "window class", registrada com a função `RegisterClassEx`. Ao registrar uma classe, o desenvolvedor pode solicitar até **40 bytes de memória extra** por instância de jánela através do campo `cbWndExtra` da estrutura `WNDCLASSEX`. Esses bytes são a **Extra Window Memory**. A EWM foi projetada para armazenar dados específicos de cada jánela - por exemplo, ponteiros para objetos C++ associados àquela jánela. As APIs `SetWindowLongPtr` e `GetWindowLongPtr` são usadas para ler e escrever nessa área. **Por que 40 bytes são suficientes:** Embora pequena, a EWM é suficiente para armazenar um ponteiro de 32 ou 64 bits. Um único ponteiro é tudo que um adversário precisa para redirecionar a execução para um payload posicionado em outra área de memória. ### Fluxo de Exploração Passo a Passo **Passo 1 - Identificar processo alvo com jánela registrada:** O adversário seleciona um processo legítimo que possui jánelas ativas (explorer.exe, notepad.exe, iexplore.exe) usando `EnumWindows` ou `FindWindow` para enumerar handles de jánela. **Passo 2 - Escrever payload em seção compartilhada:** Em vez de usar `WriteProcessMemory` (altamente monitorado), o adversário escreve o shellcode em uma **seção de memória mapeada** (`NtCreateSection`, `NtMapViewOfSection`) que é acessível tanto pelo processo injetor quanto pelo processo alvo. **Passo 3 - Usar SetWindowLong para modificar EWM:** A função `SetWindowLong` (ou `SetWindowLongPtr` em 64 bits) é chamada com o handle da jánela alvo para substituir o ponteiro armazenado na EWM pelo endereço do shellcode na seção compartilhada. **Passo 4 - Invocar execução via SendMessage/CallWindowProc:** O adversário chama `SendMessage` com a mensagem `WM_NULL` (ou similar) para a jánela alvo, ou usa `CallWindowProc` diretamente. Isso causa a execução da window procedure da jánela - que agora aponta para o shellcode malicioso. **Vantagem crítica:** Esse fluxo evita as três chamadas mais monitoradas por EDRs: `VirtualAllocEx`, `WriteProcessMemory` e `CreateRemoteThread`. A execução ocorre via callbacks do sistema de jánelas do Windows, que é muito menos instrumentado. ### Bypass de DEP via Combinação de Window Procedures Amostras mais sofisticadas (como o malware [[s0091-epic|Epic]], atribuído ao [[g0010-turla|Turla]]) implementam um bypass de DEP combinando: 1. Reutilização de gadgets ROP (Return-Oriented Programming) dentro de DLLs já mapeadas no processo alvo 2. Manipulação de múltiplas window procedures em sequência para construir uma cadeia de execução 3. Uso de funções como `NtSetContextThread` para modificar o contexto de thread sem acionar hooks comuns --- ## Attack Flow ```mermaid graph TB A["🔓 Acesso Inicial<br/>Execução de Payload de Primeira Fase"] --> B["🔍 Enumeração de Jánelas<br/>EnumWindows / FindWindow"] B --> C["🎯 Seleção do Processo Alvo<br/>explorer.exe / svchost.exe / iexplore.exe"] C --> D["📝 Escrita do Payload<br/>NtCreateSection + NtMapViewOfSection<br/>(sem WriteProcessMemory)"] D --> E["✍️ Modificação da EWM<br/>SetWindowLong / SetWindowLongPtr<br/>Substitui ponteiro por endereço do shellcode"] E --> F["⚡ Invocação de Execução<br/>SendMessage WM_NULL<br/>ou CallWindowProc"] F --> G{"🛡️ DEP Ativo?"} G -- "Não" --> H["💥 Execução Direta do Shellcode<br/>no contexto do processo legítimo"] G -- "Sim" --> I["🔄 Bypass de DEP<br/>Cadeia de Window Procedures<br/>+ Gadgets ROP"] I --> H H --> J["🐚 Shellcode Executado<br/>Reverse Shell / Loader / Stager"] J --> K["🎯 Persistência e C2<br/>Processo legítimo como host"] style A fill:#c0392b,color:#fff style E fill:#e67e22,color:#fff style G fill:#8e44ad,color:#fff style H fill:#e74c3c,color:#fff style K fill:#c0392b,color:#fff ``` --- ## Exemplos de Uso ### Epic (Turla) - Backdoor de Espionagem de Longo Prazo O [[s0091-epic|Epic]] é um backdoor sofisticado atribuído ao grupo russo [[g0010-turla|Turla]] (FSB), documentado pela Kaspersky em 2014 e utilizado em campanhas de espionagem contra governos europeus, embaixadas e organismos diplomáticos. O Epic implementa EWM injection como mecanismo de evasão: - Injeta shellcode em jánelas do Internet Explorer ou do Windows Explorer - Usa seções de memória compartilhada para evitar `WriteProcessMemory` - Executa no contexto do processo alvo para herdar tokens de acesso e privilégios - **Setores alvo**: governo, diplomacia, defesa, energia - **Referência**: Kaspersky GReAT - "Epic Turla" (2014) ### Power Loader - Loader Avançado com EWM O [[s0177-power-loader|Power Loader]] é um loader de malware que usa EWM injection para carregar payloads de segunda fase. Foi usado como distribuidor de famílias de malware como o ransomware Lurk e o Gozi banking trojan. O Power Loader tornou-se um componente vendido no underground como "serviço" (MaaS). - **Capacidade específica**: Injeta na EWM do Windows Explorer (explorer.exe) para obter contexto de usuário com privilégios de desktop - **Técnica de DEP bypass**: Utiliza callback de windows procedure legítima para desviar execução - **Referência**: ESET, Trend Micro (2012-2014) ### APT28 - Sofacy Framework O [[g0007-apt28|APT28]] (Fancy Bear, nexo Rússia/GRU) utiliza técnicas de injeção avançadas incluindo variantes de EWM injection em seu framework de implantes (X-Agent, Sofacy). A técnica é empregada para contornar soluções AV/EDR em ambientes alvo de alto valor como governos e organizações militares. --- ## Detecção ### Sigma Rule - Uso Suspeito de SetWindowLong em Processo Externo ```yaml title: Suspicious SetWindowLong Cross-Process EWM Modification id: e5f6a7b8-c9d0-1234-efab-234567890123 status: experimental description: > Detecta chamadas à API SetWindowLong/SetWindowLongPtr onde o processo chamador é diferente do processo dono da jánela - indicativo de EWM injection. Requer EDR com capacidade de monitoramento de API calls cross-process. author: RunkIntel daté: 2026/03/25 references: - https://attack.mitre.org/techniques/T1055/011/ - https://www.elastic.co/security-labs/ewm-injection-detection logsource: category: process_access product: windows detection: selection: TargetImage|endswith: - '\explorer.exe' - '\svchost.exe' - '\notepad.exe' - '\iexplore.exe' CallStack|contains: - 'SetWindowLong' - 'SetWindowLongPtr' filter_same_process: SourceImage: TargetImage condition: selection and not filter_same_process falsepositives: - Aplicações de acessibilidade (leitor de tela, ampliador) - Softwares de automação de UI (AutoHotkey, AutoIt) - Ferramentas de teste de interface gráfica level: high tags: - attack.defense_evasion - attack.privilege_escalation - attack.t1055.011 ``` ### Sigma Rule - NtMapViewOfSection Seguido de Atividade de Window Messaging ```yaml title: Shared Section Mapping Followed by Cross-Process Window Messaging id: f6a7b8c9-d0e1-2345-abcd-345678901234 status: experimental description: > Detecta o padrão de ataque EWM: criação de seção de memória compartilhada (NtMapViewOfSection) seguida de uso de SendMessage/PostMessage em jánelas de processos distintos - padrão associado ao Power Loader e Epic (Turla). author: RunkIntel daté: 2026/03/25 logsource: category: process_creation product: windows detection: selection_section: EventID: 10 # Process Access GrantedAccess: '0x1fffff' CallStack|contains: - 'NtMapViewOfSection' selection_messaging: CallStack|contains: - 'SendMessage' - 'PostMessage' - 'CallWindowProc' condition: selection_section and selection_messaging falsepositives: - Aplicações legítimas de IPC via seções compartilhadas (raras em userspace) level: high tags: - attack.defense_evasion - attack.t1055.011 ``` ### Estrategias de Detecção Complementares | Camada | Método | Ferramenta / Log | |--------|--------|-----------------| | API Monitoring | Monitorar `SetWindowLong`/`SetWindowLongPtr` com chamadas cross-process | EDR (Sysmon + Elastic, CrowdStrike, SentinelOne) | | Memory | Detectar regiões executáveis em seções mapeadas de origem suspeita | EDR com memory scanning, Volatility (análise forense) | | Sysmon | Event ID 8 (CreateRemoteThread) pode capturar variantes menos sofisticadas | Sysmon + SIEM | | Behavioral | Monitorar processos normalmente sem jánelas recebendo mensagens WM_NULL | EDR comportamental | | Parent-Child | Processos GUI legítimos (explorer.exe) spawning shells ou conexões de rede inesperadas | Sysmon Event ID 1, 3 | | Forense de Memória | Análise de jánelas registradas com EWM apontando para regiões não-pertencentes ao processo | Volatility plugin `windows` | --- ## Mitigação | ID | Mitigação | Descrição | Prioridade | |----|-----------|-----------|-----------| | [[m1040-behavior-prevention-on-endpoint\|M1040]] | Behavior Prevention on Endpoint | Soluções EDR com capacidade de detectar padrões de injeção via análise comportamental de API calls. Microsoft Defender for Endpoint e soluções de terceiros com ATP detectam variantes conhecidas | Alta | | Control Flow Guard (CFG) | Proteção de fluxo de controle | Habilitar CFG em aplicações compiladas para dificultar ataques ROP usados como bypass de DEP em EWM injection | Alta | | Exploit Guard - Code Integrity | ASR Rules | Windows Defender Attack Surface Reduction: habilitar regra "Block process injections originating from Office macros" e "Block credential stealing from LSASS" | Alta | | Atualização de Windows | Patches de segurança | Manter Windows atualizado para fechar vulnerabilidades que facilitam bypass de DEP/ASLR em conjunto com EWM injection | Crítica | | Least Privilege | Restrição de processos | Executar aplicações com menor nível de privilégio possível - limita o impacto de código injetado | Média | --- ## Contexto Brasil/LATAM A técnica T1055.011 é relevante para o contexto brasileiro primariamente pelo vetor de **malware bancário avançado** e **campanhas de espionagem**: **Malware Bancário Brasileiro de Nova Geração**: Enquanto trojans bancários clássicos como [[s0531-grandoreiro|Grandoreiro]] e [[mekotio|Mekotio]] usam técnicas de injeção mais simples (overlay de jánelas via DLL injection), uma nova geração de malware bancário brasileiro começa a adotar técnicas de injeção avançadas para contornar EDRs implantados por bancos brasileiros nos últimos anos. EWM injection figura como candidato nessa evolução. **Espionagem Governamental e Corporativa**: Grupos de espionagem como [[g0010-turla|Turla]] e [[g0007-apt28|APT28]], que utilizam EWM injection documentadamente, têm histórico de interesse em alvos brasileiros - especialmente entidades diplomáticas, Ministério das Relações Exteriores (Itamaraty) e empresas do setor de energia (Petrobras, Embraer). O Turla foi relacionado a ataques contra embaixadas europeias que incluem escritórios em Brasília. **Crescimento do Mercado de Loaders-as-a-Service**: O [[s0177-power-loader|Power Loader]], que usa EWM injection, foi amplamente comercializado em fóruns do underground cibercriminoso. Com a crescente penetração de fóruns internacionais de crimeware no Brasil, técnicas como EWM injection podem ser incorporadas em toolkits vendidos a grupos locais. **Complexidade de Detecção em SOCs Brasileiros**: A maioria dos SOCs brasileiros ainda opera com detecção baseada em assinaturas e regras básicas de SIEM. EWM injection, que opera inteiramente via APIs legítimas do Windows sem escrita direta em memória de processo, é virtualmente indetectável por essas abordagens - exigindo investimento em EDR comportamental avançado. **Recomendação específica para ambientes brasileiros**: Priorizar deployment de soluções EDR com análise comportamental (Microsoft Defender for Endpoint, CrowdStrike Falcon, SentinelOne) em estações e servidores Windows críticos como medida principal de detecção de técnicas de injeção avançadas como T1055.011. --- ## Software Associado - [[s0091-epic|Epic]] - backdoor do [[g0010-turla|Turla]] (Rússia), espionagem contra governos e diplomacia - [[s0177-power-loader|Power Loader]] - loader comercial MaaS, usa EWM injection para persistência em explorer.exe --- ## Referências - [MITRE ATT&CK - T1055.011](https://attack.mitre.org/techniques/T1055/011/) - [Kaspersky GReAT - Epic Turla (2014)](https://securelist.com/the-epic-turla-operation/65545/) - [Elastic Security Labs - EWM Injection Detection](https://www.elastic.co/security-labs/ewm-injection-detection) - [ESET - Power Loader Analysis](https://www.welivesecurity.com/2013/01/11/power-loader-exposed/) - [Microsoft - Windows Extra Window Memory](https://docs.microsoft.com/en-us/windows/win32/winmsg/about-window-classes) - [Hexacorn - EWM Injection Techniques](https://www.hexacorn.com/blog/2015/10/26/extra-window-memory-injection-ewm/) - [Trend Micro - Process Injection Techniques Overview](https://www.trendmicro.com/en_us/research/19/f/the-journey-to-detection-process-injection-techniques.html)