# T1003.007 - Proc Filesystem > [!danger] Técnica de Credential Access - Linux > **Tática:** Credential Access | **Plataforma:** Linux | **MITRE ID:** T1003.007 > Adversários acessam o pseudo-sistema de arquivos `/proc` para extrair credenciais da memória de processos em execução, incluindo senhas em texto claro, hashes e tokens de autenticação - sem necessidade de ferramentas externas além das nativas do sistema. ## Descrição A técnica **T1003.007 - Proc Filesystem** descreve como adversários exploram o sistema de arquivos virtual `/proc` do Linux para realizar **OS Credential Dumping** - a extração de credenciais diretamente da memória de processos em execução. O `/proc` é um **pseudo-sistema de arquivos** (não existe fisicamente em disco) que expõe a interface entre o espaço de usuário e o kernel do Linux. Para cada processo em execução no sistema, o kernel cria um diretório `/proc/<PID>/` contendo informações detalhadas sobre aquele processo, incluindo seus mapeamentos de memória virtual. Os dois arquivos mais críticos para extração de credenciais são: - **`/proc/<PID>/maps`** - Contém o mapa de espaço de endereçamento virtual do processo, listando cada região de memória com endereços de início e fim, permissões (leitura/escrita/execução) e o arquivo mapeado. Adversários usam este arquivo para identificar regiões de memória legíveis e, potencialmente, quais contêm dados sensíveis. - **`/proc/<PID>/mem`** - Expõe o espaço de endereçamento virtual completo do processo para fins de depuração. Com as permissões adequadas, qualquer processo com capacidade de `ptrace` pode ler e escrever neste arquivo diretamente. Processos executando como root ou com `CAP_SYS_PTRACE` podem ler a memória de qualquer processo do sistema. **Por que credenciais ficam na memória?** Múltiplos cenários comuns resultam em credenciais armazenadas em memória de processo: 1. **Processos SSH/PAM:** Ao autenticar um usuário, o processo `sshd` mantém brevemente a senha em texto claro na memória antes do hash. 2. **Navegadores web:** Firefox, Chrome e outros mantêm credenciais de sites em cache na memória para autopreenchimento. 3. **Aplicações web (Java, Python, PHP):** Conexões com bancos de dados frequentemente armazenam strings de conexão (usuário + senha) na memória heap da aplicação. 4. **sudo e su:** O processo de elevação de privilégios mantém brevemente a senha em memória. 5. **Clientes de e-mail e serviços cloud:** Tokens OAuth e senhas de serviços ficam em memória enquanto a aplicação está ativa. Esta técnica é particularmente poderosa em servidores Linux de produção onde múltiplos serviços críticos estão em execução simultânea, cada um potencialmente contendo credenciais valiosas para movimentação lateral [[t1021-lateral-movement|T1021]]. Está diretamente relacionada com [[t1003-os-credential-dumping|T1003 - OS Credential Dumping]] (técnica pai) e é o equivalente Linux das técnicas de dumping de memória LSASS no Windows. Ferramentas como [[s0349-lazagne|LaZagne]], [[s0179-mimipenguin|MimiPenguin]] e [[s1109-pacemaker|PACEMAKER]] automatizam esta extração. ## Como Funciona ### Pré-requisito: Nível de Privilégio O acesso à memória de outros processos via `/proc/<PID>/mem` requer uma das seguintes condições: - **root (UID 0)** - pode ler a memória de qualquer processo - **Mesmo usuário:** Um processo pode sempre ler sua própria memória - **CAP_SYS_PTRACE:** Capacidade Linux que permite depuração e acesso à memória de outros processos - **CAP_DAC_READ_SEARCH:** Permite bypass de restrições de leitura no filesystem ### Passo 1: Identificar Processos de Interesse ```bash # Listar processos em execução e identificar targets (ex: sshd, apache, java) ps aux | grep -E "sshd|apache|nginx|java|python|ruby" # Ver todos os PIDs em /proc ls /proc | grep -E '^[0-9]+ ``` ### Passo 2: Mapear Regiões de Memória Legíveis ```bash # Para cada PID de interesse, listar regiões de memória legíveis grep -E "^[0-9a-f-]* r" /proc/$PID/maps | cut -d' ' -f1 ``` O output mostra linhas como `7f8a2b000000-7f8a2b200000 r-xp` - os endereços início e fim de cada região legível. ### Passo 3: Extrair Conteúdo de Memória ```bash # Ler diretamente o conteúdo de uma região de memória # (requer root ou mesmas permissões do processo) dd if=/proc/$PID/mem bs=1 skip=$((0x7f8a2b000000)) count=2097152 2>/dev/null | strings | grep -i "password\|passwd\|credential\|token\|secret" ``` Alternativamente, usando Python para leitura mais eficiente: ```python # Exemplo conceitual - leitura de região de memória via /proc/mem with open(f'/proc/{pid}/maps', 'r') as maps_file: for line in maps_file: if 'r' in line.split()[1]: # região legível start, end = [int(x, 16) for x in line.split()[0].split('-')] # ler intervalo de memória e buscar padrões de credenciais ``` ### Passo 4: Uso de Ferramentas Automatizadas **MimiPenguin** e **LaZagne** automatizam todo o processo: - **[[s0179-mimipenguin|MimiPenguin]]:** Extrai hashes de senhas de processos como `gnome-keyring`, `lightdm`, `vsftpd`, `apache2`, `openssh`. Suporta extração de processos PHP e Python também. - **[[s0349-lazagne|LaZagne]]:** Ferramenta multiplataforma que automatiza coleta de credenciais de dezenas de aplicações, incluindo navegadores, clientes de e-mail, bancos de dados e SSH - usando `/proc/mem` no Linux. - **[[s1109-pacemaker|PACEMAKER]]:** Malware observado em operações de espionagem avançada que utiliza acesso ao `/proc` para extração furtiva de credenciais, com funcionalidades de ofuscação para evitar detecção. ### Extração de Memória de Navegadores (sem root) Um cenário especial: processos podem sempre acessar sua própria memória. Se um adversário executa código no contexto de um navegador web (via extensão maliciosa, XSS com acesso a filesystem, ou processo filho), pode acessar `/proc/self/mem` para extrair credenciais armazenadas pelo navegador - **sem necessidade de privilégios elevados**. ## Attack Flow ```mermaid graph TB A[Acesso Inicial: RCE / SSH comprometido / Container escape] --> B[Reconhecimento interno do sistema Linux] B --> C[Enumerar processos em execução via ps aux] C --> D{Nível de Privilégio} D --> E[root / CAP_SYS_PTRACE: Acesso a todos os processos] D --> F[Usuário comum: Acesso apenas aos próprios processos] E --> G[Ler /proc/PID/maps - mapear regiões de memória legíveis] F --> H[Acesso /proc/self/mem - memória do próprio processo] G --> I[Abrir /proc/PID/mem com seek para endereços mapeados] H --> I I --> J[Extrair conteúdo raw da memória via dd ou Python] J --> K[Aplicar regex/strings para identificar padrões de credenciais] K --> L{Tipo de credencial encontrada} L --> M[Senhas em texto claro - sshd, PAM, aplicações web] L --> N[Hashes de senha - /proc para processos de autenticação] L --> O[Tokens OAuth/JWT - navegadores, APIs, aplicações cloud] L --> P[Strings de conexão DB - Java, Python, PHP apps] M --> Q[Movimentação Lateral via SSH / reutilização de credenciais] N --> Q O --> R[Acesso a serviços cloud / SaaS com token roubado] P --> Q ``` ## Exemplos de Uso ### Operação Earth Lusca - Espionagem em Servidores Linux (2022) Documentado pelo [[unit42|Unit 42]] e Trend Micro, o grupo Earth Lusca (ator de ameaça com nexo chinês) utilizou técnicas de acesso ao `/proc` filesystem como parte de sua cadeia de comprometimento em servidores Linux expostos à internet. Após explorar vulnerabilidades em aplicações web (Apache Log4j, Oracle WebLogic), o grupo obtinha persistência e então realizava credential dumping via `/proc` para extrair credenciais de conexão a bancos de dados internos e credenciais SSH, facilitando o movimento lateral dentro das redes comprometidas. ### Lazarus Group - Campanha AppleJeus Linux Variant (2023) O grupo [[g0032-lazarus-group|Lazarus Group]] (DPRK) em variantes Linux do malware AppleJeus utilizou técnicas de leitura de `/proc/mem` para extrair credenciais de wallets de criptomoedas armazenadas em memória de aplicações de exchange. O foco era obter chaves privadas e tokens de sessão de plataformas de trading mantidos em memória heap de aplicações Java e Electron. ### PACEMAKER Malware - Servidores de Alta Disponibilidade O malware [[s1109-pacemaker|PACEMAKER]], identificado pelo ESET em operações de APT contra infraestrutura crítica, implementa leitura furtiva do `/proc` filesystem para extração de credenciais. O malware é específicamente projetado para atacar servidores Linux de alta disponibilidade (clusters HA), onde credenciais de administração têm alto valor para comprometimento de infraestrutura crítica. ### LaZagne em Servidores Web Comprometidos Em múltiplos incidentes de resposta a incidentes documentados pelo [[sources|Mandiant]], a ferramenta [[s0349-lazagne|LaZagne]] foi encontrada em servidores web Apache/Nginx comprometidos onde adversários executavam LaZagne para extrair automaticamente credenciais de configurações de aplicações PHP, conexões de banco de dados MySQL/PostgreSQL e tokens de sessão ativos - todos acessíveis via `/proc/mem` dos processos do servidor web. ## Detecção ### Estrategias de Detecção A detecção desta técnica é desafiadora porque acesso ao `/proc` é comportamento legítimo de muitas ferramentas de sistema e depuração. A chave é identificar acesso anômalo - processos não esperados acessando memória de outros processos, especialmente em contextos de produção. **Fontes de dados primárias:** - **auditd (Linux Audit Daemon):** Monitoramento de syscalls `ptrace`, `open` e `read` em caminhos `/proc/*/mem` e `/proc/*/maps` - **Falco (runtime security):** Regras para detectar leitura de memória de processos críticos - **eBPF-based security tools (Cilium, Tetragon):** Visibilidade em nível de kernel para chamadas de sistema suspeitas ### Regra Sigma - Acesso a /proc/PID/mem Suspeito ```yaml title: Suspicious Access to Process Memory via /proc Filesystem status: experimental logsource: category: file_access product: linux detection: selection: FileName|re: '^/proc/[0-9]+/mem filter_legitimate: Image|endswith: - '/gdb' - '/strace' - '/ltrace' - '/valgrind' ParentImage|endswith: - '/systemd' condition: selection and not filter_legitimate falsepositives: - Ferramentas de depuração legítimas (gdb, strace) em ambientes de desenvolvimento - Ferramentas de monitoramento de performance (perf, heaptrack) - Scanners de memória de segurança autorizados level: high tags: - attack.credential_access - attack.t1003.007 ``` ### Regra Sigma - Execução de MimiPenguin / LaZagne ```yaml title: Credential Dumping Tools Targeting Linux /proc status: experimental logsource: category: process_creation product: linux detection: selection_tools: CommandLine|contains: - 'mimipenguin' - 'lazagne' - '/proc/*/mem' - '/proc/*/maps' Image|endswith: - '/python' - '/python3' - '/bash' - '/sh' selection_patterns: CommandLine|contains: - 'grep.*password.*proc' - 'strings.*proc' - 'dd if=/proc' condition: selection_tools or selection_patterns falsepositives: - Auditorias de segurança autorizadas - Testes de penetração documentados level: critical tags: - attack.credential_access - attack.t1003.007 ``` ### Detecção via auditd Configurar o Linux Audit Daemon para registrar acessos suspeitos ao `/proc`: ```bash # Regras auditd para monitorar acesso a memória de processos -a always,exit -F arch=b64 -S ptrace -k credential_dumping -a always,exit -F arch=b64 -S open -F path=/proc -F success=1 -k proc_access -w /proc -p r -k proc_read_monitor ``` ## Mitigação | ID | Mitigação | Descrição | |---|-----------|-----------| | M1027 | [[m1027-password-policies\|M1027 - Password Policies]] | Implementar senhas longas e complexas reduz o valor das credenciais extraídas, especialmente hashes. Políticas de rotação frequente limitam a jánela de utilidade das credenciais coletadas via `/proc`. | | M1026 | [[m1026-privileged-account-management\|M1026 - Privileged Account Management]] | Minimizar o número de processos executando como root. Usar capabilities Linux específicas (`CAP_SYS_PTRACE`, `CAP_DAC_READ_SEARCH`) somente quando necessário, e remover essas capabilities de containers e serviços que não necessitam. Restringir `ptrace` via `kernel.yama.ptrace_scope` (definir como 1 ou 2). | **Mitigações adicionais recomendadas:** - **`kernel.yama.ptrace_scope`:** Configurar como `1` (restrito - apenas processos pai podem usar ptrace) ou `2` (apenas root) via `sysctl` para restringir acesso a `/proc/mem`: ``` echo "kernel.yama.ptrace_scope=2" >> /etc/sysctl.d/10-ptrace.conf sysctl -p /etc/sysctl.d/10-ptrace.conf ``` - **Minimizar credenciais em memória:** Implementar gerenciamento de segredos via HashiCorp Vault, AWS Secrets Manager ou Azure Key Vault, evitando que strings de conexão e tokens sejam armazenados diretamente em variáveis de memória de aplicações. - **Segurança de containers:** Em ambientes Docker/Kubernetes, usar o perfil `seccomp` padrão que bloqueia `ptrace`, e configurar `securityContext.allowPrivilegeEscalation: false` em manifestos de pods. - **Monitoramento runtime:** Implementar Falco ou Tetragon com regras específicas para alertar sobre leitura de `/proc/*/mem` fora de contextos de depuração esperados. ## Contexto Brasil/LATAM No contexto brasileiro e latino-americano, a técnica T1003.007 é especialmente relevante em cenários de ataque a infraestrutura de servidores Linux em produção, que são amplamente utilizados por empresas de todos os setores. **Impacto setorial:** - **Setor Financeiro:** Servidores de aplicação bancária (Java EE, JBoss, WildFly) e sistemas de pagamento (PIX, TED) frequentemente executam em Linux. A extração de credenciais de memória destes processos pode expor conexões a bancos de dados com dados de transações e informações de clientes. - **E-commerce e Varejo:** Plataformas como Magento, WooCommerce e lojas customizadas em PHP/Python rodando em servidores Linux contêm credenciais de gateways de pagamento e bases de dados de clientes acessíveis via `/proc/mem` dos processos web. - **Telecomúnicações:** Empresas de telecom brasileiras (Claro, Vivo, TIM, Oi) operam extensas infraestruturas de servidores Linux para sistemas de billing e CRM. Comprometimento via T1003.007 poderia expor dados de milhões de assinantes. - **Governo:** Sistemas do governo federal e estadual (SERPRO, DATAPREV, Proderj) com infraestrutura Linux crítica são alvos de alta relevância para adversários com motivação de espionagem ou disruption de serviços públicos. **Grupos com presença documentada na LATAM:** O [[g0032-lazarus-group|Lazarus Group]] e grupos de ransomware como [[lockbit|LockBit]] e [[blackcat|ALPHV]] utilizam técnicas de credential dumping Linux em fases pós-comprometimento de suas operações na região. Após obter acesso inicial, extraem credenciais via `/proc` para maximizar o alcance horizontal dentro das redes comprometidas antes da fase de cifragem/exfiltração. **Conformidade LGPD:** Incidentes que resultem em extração de dados pessoais de brasileiros via esta técnica incorrem em obrigações de notificação à ANPD (Autoridade Nacional de Proteção de Dados) e possíveis sanções conforme a Lei 13.709/2018. ## Referências - [MITRE ATT&CK - T1003.007](https://attack.mitre.org/techniques/T1003/007) - [MimiPenguin - Extração de credenciais Linux via /proc](https://github.com/huntergregal/mimipenguin) - [LaZagne - Coleta automatizada de credenciais multiplataforma](https://github.com/AlessandroZ/LaZagne) - [Linux /proc Filesystem Documentation](https://www.kernel.org/doc/html/latest/filesystems/proc.html) - [PACEMAKER Malware Analysis - ESET](https://www.welivesecurity.com/) - [Earth Lusca Threat Actor Analysis - Trend Micro (2022)](https://www.trendmicro.com/en_us/research/22/a/earth-lusca-employs-sophisticated-infrastructure-varied-tools-and-techniques.html) - [Falco Runtime Security Rules for Linux](https://falco.org/docs/rules/) - [[t1003-os-credential-dumping|T1003 - OS Credential Dumping]] (técnica pai) - [[t1021-lateral-movement|T1021 - Remote Services]] (técnica relacionada - uso das credenciais extraídas) - [[t1068-exploitation-for-privilege-escalation|T1068 - Exploitation for Privilege Escalation]] (frequentemente precede esta técnica) --- *Fonte: [MITRE ATT&CK - T1003.007](https://attack.mitre.org/techniques/T1003/007)*