# T1055.009 - Proc Memory
## Técnica Pai
Sub-técnica de [[t1055-process-injection|T1055 - Process Injection]]
## Descrição
Adversários podem injetar código malicioso em processos via o sistema de arquivos `/proc` do Linux para evadir defesas baseadas em processos e, possívelmente, elevar privilégios. A injeção via `/proc` é um método de executar código arbitrário no espaço de endereços de um processo ativo separado sem utilizar chamadas de sistema explícitas como `ptrace`, tornando a detecção mais difícil.
A técnica funciona enumerando o mapeamento de memória do processo alvo através do arquivo `/proc/[pid]/maps`, identificando gadgets úteis para construção de payloads ROP (Return-Oriented Programming). Em seguida, o payload é escrito diretamente no stack do processo alvo usando `dd` ou escrita direta em `/proc/[pid]/mem`, sobrescrevendo a pilha de execução.
Outras técnicas como [[t1574-006-dynamic-linker-hijacking|T1574.006 - Dynamic Linker Hijacking]] podem ser usadas em conjunto para aumentar a quantidade de gadgets disponíveis no processo alvo. De maneira similar ao [[t1055-012-process-hollowing|T1055.012 - Process Hollowing]], a injeção via `/proc` pode ter como alvo processos filhos - como uma cópia em background do comando `sleep` - para minimizar a visibilidade.
Executar código no contexto de outro processo permite acesso à memória, recursos de rede e sistema do processo alvo, além de potencialmente herdar seus privilégios. A execução mascarada sob um processo legítimo dificulta a identificação por ferramentas de segurança.
## Como Funciona
A injeção via `/proc` segue um fluxo técnico bem definido no ambiente Linux:
1. **Enumeração do alvo:** O adversário lista processos em execução e identifica um alvo conveniente - geralmente um processo de baixo perfil como `sleep`, `bash` em background ou daemons do sistema.
2. **Leitura dos mapas de memória:** O arquivo `/proc/[pid]/maps` é lido para obter o layout completo do espaço de endereços do processo: endereços de código, stack, heap e bibliotecas compartilhadas carregadas.
3. **Identificação de gadgets ROP:** Com os endereços de bibliotecas como `libc` mapeadas, o atacante identifica sequências de instruções úteis (gadgets) terminando em `ret` para construir uma cadeia ROP que desviará o fluxo de execução.
4. **Contorno do ASLR:** O `/proc/[pid]/maps` expõe os endereços reais das regiões de memória, mesmo com ASLR ativo, pois o atacante lê o estado do processo já inicializado - eliminando a aleatorização.
5. **Escrita do payload:** Usando `dd` apontando para `/proc/[pid]/mem` ou chamada direta de escrita no descritor de arquivo, o payload (cadeia ROP + shellcode) é escrito sobre o stack do processo alvo.
6. **Desvio de execução:** Quando o processo alvo retorna de uma função, a cadeia ROP é executada, redirecionando o fluxo para o shellcode injetado.
**Exemplo de acesso aos mapas (diagnóstico):**
```bash
# Listar regiões de memória do processo alvo
cat /proc/[pid]/maps
# Resultado típico - endereços reais, sem hash
# 7f3b1a000000-7f3b1a200000 r-xp /lib/x86_64-linux-gnu/libc-2.31.so
# 7ffc12345000-7ffc12366000 rwxp [stack]
```
**Escrita via /proc/mem:**
```bash
# Abrir /proc/[pid]/mem para escrita e sobrescrever stack
dd if=payload.bin of=/proc/[pid]/mem bs=1 seek=$((stack_offset)) count=$((payload_size))
```
## Attack Flow
```mermaid
graph TB
A[Acesso Inicial ao Sistema Linux] --> B[Enumeração de Processos<br>/proc diretory listing]
B --> C[Seleção do Processo Alvo<br>ex: sleep, bash, daemon]
C --> D[Leitura de /proc/pid/maps<br>layout completo da memória]
D --> E[Identificação de Gadgets ROP<br>endereços de libc, libpthread]
E --> F[Contorno do ASLR<br>endereços reais já expostos]
F --> G[Construção do Payload ROP<br>cadeia de gadgets + shellcode]
G --> H[Escrita em /proc/pid/mem<br>via dd ou write syscall]
H --> I[Desvio de Execução<br>ret da função aciona ROP chain]
I --> J[Código Malicioso Executado<br>no contexto do processo legítimo]
J --> K[Evasão de Defesas<br>execução mascarada como processo legítimo]
```
## Exemplos de Uso
**TeamTNT e Hildegard - Cryptomining em Kubernetes:**
O grupo [[g0139-teamtnt|TeamTNT]] e o malware [[s0601-hildegard|Hildegard]] utilizaram técnicas de injeção em processos Linux para implantar mineradores de criptomoeda em ambientes Kubernetes comprometidos. A injeção via `/proc` permitia que o código malicioso operasse dentro de containers legítimos, dificultando a detecção por soluções de segurança de container.
**Evasão de sandboxes de análise:**
Adversários usam a técnica para migrar de um processo inicial (geralmente o vetor de entrega) para um processo de sistema mais confiável como `systemd` ou daemons de aplicação, zerando a trilha de auditoria do processo original.
**Persistência em ambientes com restrições de escrita:**
Em sistemas onde diretórios típicos de persistência (`/tmp`, `/var`) têm controles de execução (noexec), a injeção via `/proc/mem` contorna a restrição por não precisar criar arquivo executável em disco.
**Elevação de privilégios:**
Se o processo alvo rodar com UID 0 (root) ou capabilidades elevadas, o código injetado herda esses privilégios, transformando um acesso de usuário comum em root.
## Detecção
**Fontes de dados prioritárias:**
| Fonte | O Que Monitorar | Prioridade |
|-------|-----------------|------------|
| `auditd` | Chamadas `open()` em `/proc/[pid]/mem` para escrita | Alta |
| `auditd` | Uso de `process_vm_writev` ou `process_vm_readv` | Alta |
| `auditd` | Acesso a `/proc/[pid]/maps` por processo diferente do owner | Média |
| eBPF / Falco | Escrita em `/proc/[pid]/mem` por processo não-debugger | Alta |
| Monitoramento de integridade | Alterações inesperadas no comportamento de processos de sistema | Média |
| Análise de comportamento | Processos como `sleep` ou `sh` fazendo conexões de rede | Alta |
**Regra Sigma - Acesso suspeito a /proc/mem:**
```yaml
title: Acesso de Escrita Suspeito em /proc/pid/mem no Linux
status: experimental
logsource:
category: process_creation
product: linux
detection:
selection:
Image|endswith:
- "/dd"
- "/python"
- "/python3"
- "/perl"
- "/ruby"
CommandLine|contains:
- "/proc/"
- "/mem"
filter_legit:
CommandLine|contains:
- "gdb"
- "strace"
- "ltrace"
condition: selection and not filter_legit
falsepositives:
- Debuggers legítimos (gdb, strace) em ambientes de desenvolvimento
- Ferramentas de profiling que inspecionam memória de processos
level: high
tags:
- attack.defense_evasion
- attack.t1055.009
```
**Regra Sigma - Leitura de maps de processos alheios:**
```yaml
title: Enumeração de Mapa de Memória de Processo Alheio
status: experimental
logsource:
category: file_access
product: linux
detection:
selection:
FileName|re: '^/proc/\d+/maps