t1564-010-process-argument-spoofing

# T1564.010 - Process Argument Spoofing ## Técnica Pai [[t1564-hide-artifacts|T1564 - Hide Artifacts]] ## Descrição Adversários podem tentar ocultar os argumentos de linha de comando de um processo sobrescrevendo regiões específicas da memória do processo. No Windows, os argumentos de linha de comando são armazenados no **Process Environment Block (PEB)**, uma estrutura de dados do sistema operacional que contém diversas informações sobre o processo em execução - incluindo o caminho do executável, variáveis de ambiente e os argumentos com os quais foi iniciado. Ferramentas de monitoramento e soluções EDR frequentemente capturam esses argumentos no momento da criação do processo, lendo-os diretamente do PEB. A técnica de *Process Argument Spoofing* explora essa jánela temporal entre a criação do processo e a leitura dos argumentos pela ferramenta de segurança. Um adversário pode iniciar um processo com argumentos legítimos e inofensivos, aguardar que o monitoramento registre essas informações, e então sobrescrever o PEB com os argumentos maliciosos reais - tudo isso antes que a execução do processo avance para o código relevante. Essa manipulação é frequentemente realizada via [[t1106-native-api|T1106 - Native API]], utilizando funções como `WriteProcessMemory()` para modificar diretamente a memória do processo-alvo. Em muitos cenários, essa técnica é combinada com [[t1055-012-process-hollowing|T1055.012 - Process Hollowing]], onde um processo legítimo é criado em estado suspenso, tendo seu conteúdo substituído por código malicioso antes de ser retomado. O *spoofing* dos argumentos complementa esse fluxo ao garantir que os logs de criação de processo registrem argumentos benignos. Também pode ser encadeada com [[t1134-004-parent-pid-spoofing|T1134.004 - Parent PID Spoofing]] para criar uma árvore de processos de aparência completamente legítima, dificultando enormemente a investigação forense e a correlação de alertas em sistemas SIEM. ## Como Funciona O fluxo de exploração segue uma lógica precisa que se aproveita da sequência de eventos no Windows durante a criação de processos: 1. **Criação do processo com argumentos falsos:** O adversário utiliza a API `CreateProcess()` passando argumentos legítimos (ex: `svchost.exe -k netsvcs`). O processo é criado em estado suspenso (`CREATE_SUSPENDED`). 2. **Registro pelo monitoramento:** Soluções de segurança que monitoram eventos de criação de processo (ETW, Sysmon Event ID 1, etc.) capturam e registram os argumentos falsos neste momento. 3. **Sobrescrita do PEB:** Com o processo suspenso, o adversário usa `WriteProcessMemory()` ou APIs similares da [[t1106-native-api|T1106 - Native API]] para localizar e sobrescrever o campo `CommandLine` na estrutura `RTL_USER_PROCESS_PARAMETERS` dentro do PEB. 4. **Retomada da execução:** O processo é retomado via `ResumeThread()` e executa com os argumentos maliciosos reais, enquanto os logs registram apenas os argumentos falsos. 5. **Variante reversa:** Alternativamente, o processo pode ser iniciado diretamente com argumentos maliciosos e, após a execução começar, o PEB é sobrescrito com argumentos benignos para enganar análises post-mortem de memória. ## Attack Flow ```mermaid graph TB A[Acesso Inicial / Execução] --> B[Criar processo suspenso com args legítimos] B --> C[EDR/Sysmon registra args falsos nos logs] C --> D[WriteProcessMemory sobre o PEB] D --> E[Campo CommandLine sobrescrito com args maliciosos] E --> F[ResumeThread retoma execução] F --> G[Processo executa carga maliciosa] G --> H[Logs mostram processo legítimo] H --> I[Evasão de EDR e SIEM bem-sucedida] ``` ## Exemplos de Uso **Cobalt Strike - Beacon com argumento falso:** O [[s0154-cobalt-strike|Cobalt Strike]] utiliza essa técnica em seu módulo de spawning de processos. O Beacon cria um processo legítimo (ex: `rundll32.exe`) com argumentos inócuos, sobrescreve o PEB e injeta shellcode antes de retomar a execução. As ferramentas de auditoria registram apenas `rundll32.exe` sem argumentos suspeitos. **SombRAT - Evasão de análise forense:** O [[s0615-sombrat|SombRAT]] (RAT usado pelo grupo Cloud Atlas) foi observado manipulando argumentos de processo para ocultar parâmetros de conexão ao servidor C2. Após a execução, os argumentos no PEB eram substituídos por strings vazias ou strings de processos do sistema, dificultando a identificação do servidor de comando e controle durante análise de memória. **Combinação com Process Hollowing:** Em ataques direcionados a ambientes corporativos, adversários combinam [[t1055-012-process-hollowing|T1055.012 - Process Hollowing]] com argument spoofing para criar processos que aparentam ser instâncias do `svchost.exe` ou `explorer.exe` com argumentos completamente normais, enquanto executam payloads de segunda fase para [[t1021-remote-services|movimentação lateral]] ou exfiltração de dados. ## Detecção A principal dificuldade na detecção é que as ferramentas tradicionais de monitoramento são enganadas por design. A abordagem mais eficaz é comparar os argumentos registrados no evento de criação do processo com os argumentos presentes na memória do processo durante sua execução. **Regra Sigma - Inconsistência entre PEB e linha de comando registrada:** ```yaml title: Process Argument Spoofing - PEB CommandLine Mismatch status: experimental description: > Detecta possível manipulação do Process Environment Block (PEB) comparando argumentos de linha de comando registrados no evento de criação com os argumentos lidos da memória do processo em execução. Divergências indicam possível T1564.010. logsource: category: process_creation product: windows detection: selection_hollow: EventID: 1 Image|endswith: - '\svchost.exe' - '\rundll32.exe' - '\regsvr32.exe' - '\mshta.exe' - '\wscript.exe' - '\cscript.exe' CommandLine|contains: - ' ' filter_legitimate: CommandLine|contains: - '-k ' - '/s ' - '.dll' condition: selection_hollow and not filter_legitimate fields: - Image - CommandLine - ParentImage - ParentCommandLine - ProcessId falsepositives: - Aplicações legítimas que usam processos filhos com argumentos mínimos level: high tags: - attack.defense_evasion - attack.t1564.010 ``` **Detecção complementar - API calls suspeitas:** ```yaml title: WriteProcessMemory on Suspended Process - Argument Spoofing Indicator status: experimental description: > Detecta chamadas a WriteProcessMemory em processos recém-criados em estado suspenso, padrão consistente com T1564.010 Process Argument Spoofing. logsource: category: process_access product: windows service: sysmon detection: selection: EventID: 10 GrantedAccess|contains: - '0x1fffff' - '0x1f0fff' - '0x40' CallTrace|contains: - 'WriteProcessMemory' - 'NtWriteVirtualMemory' condition: selection level: high tags: - attack.defense_evasion - attack.t1564.010 - attack.t1055.012 ``` **Fontes de dados recomendadas:** - Sysmon Event ID 1 (Process Creation) - captura argumentos iniciais - Sysmon Event ID 10 (ProcessAccess) - detecta acesso à memória de outros processos - ETW (Event Tracing for Windows) - monitoramento de chamadas de API em nível de kernel - EDR com inspeção de memória em tempo de execução (comparação PEB vs. registro) ## Mitigação Não existem mitigações diretas e definitivas catalogadas pelo MITRE para esta técnica, pois ela opera em nível de memória de processo e explora comportamentos legítimos do sistema operacional. As defesas são baseadas em detecção e redução de superfície de ataque: | ID | Mitigação | Descrição | |----|-----------|-----------| | - | Monitoramento de integridade de processos | Soluções EDR avançadas que comparam argumentos registrados com a memória do processo em execução podem identificar inconsistências indicativas de spoofing | | - | Controle de aplicações (AppLocker/WDAC) | Restringir quais processos podem invocar `CreateProcess` com `CREATE_SUSPENDED` reduz a superfície de exploração da técnica | | - | Auditoria de chamadas de API sensíveis | Monitorar o uso de `WriteProcessMemory`, `NtWriteVirtualMemory` e `ResumeThread` em sequência pode sinalizar tentativas de manipulação de PEB | | - | EDR com proteção de memória | Ferramentas como Microsoft Defender for Endpoint com *Kernel DMA Protection* e *Arbitrary Code Guard* dificultam a manipulação direta da memória de processos | ## Contexto Brasil/LATAM Embora o *Process Argument Spoofing* sejá uma técnica primariamente utilizada em ataques de espionagem e APT sofisticados, sua relevância no contexto brasileiro e latino-americano cresce à medida que grupos de crime cibernético regional elevam o nível técnico de suas operações. Grupos de ransomware que operam no Brasil - incluindo operadores afiliados ao [[lockbit|LockBit]], [[black-basta|Black Basta]] e variantes locais - frequentemente utilizam frameworks como o [[s0154-cobalt-strike|Cobalt Strike]] em suas fases de pós-exploração. Esses frameworks implementam argument spoofing nativamente, o que significa que a técnica já está presente em muitos ataques contra organizações brasileiras nos setores financeiro, saúde e governo. A técnica é particularmente preocupante para o [[financial|setor financeiro brasileiro]], onde as soluções de segurança baseadas em logs de linha de comando (muito comuns em SOCs nacionais) são diretamente contornadas por esse método. Times de Blue Team no Brasil devem priorizar a implementação de EDRs com capacidade de inspeção de memória em tempo real, em vez de depender exclusivamente de logs de criação de processo para detecção de comportamento malicioso. A crescente adoção de [[t1059-001-powershell|PowerShell]] e ferramentas *living-off-the-land* em campanhas direcionadas à América Latina faz com que o argument spoofing sejá frequentemente combinado com técnicas de LOLBins para criar cadeias de ataque extremamente difíceis de rastrear em ambientes sem EDR avançado. ## Referências - [[t1564-hide-artifacts|T1564 - Hide Artifacts]] - Técnica pai desta sub-técnica - [[t1055-012-process-hollowing|T1055.012 - Process Hollowing]] - Frequentemente combinada para criação de processos falsos - [[t1134-004-parent-pid-spoofing|T1134.004 - Parent PID Spoofing]] - Complementa o spoofing de argumentos para evasão completa - [[t1106-native-api|T1106 - Native API]] - Mecanismo de implementação via `WriteProcessMemory` - [[s0154-cobalt-strike|Cobalt Strike]] - Framework que implementa argument spoofing nativamente - [[s0615-sombrat|SombRAT]] - Malware observado usando a técnica para ocultar parâmetros C2 --- *Fonte: MITRE ATT&CK - T1564.010*