A ZenoX analisou uma amostra de uma campanha ativa disseminando o Salat Stealer. O Salat é um malware sofisticado que combina um stealer completo de informações com capacidades de trojan de acesso remoto (RAT). A ameaça opera através de três camadas distintas de proteção: um loader customizado em Rust que decripta o payload utilizando um gerador linear congruencial (LCG) de 64 bits, uma camada de compressão UPX, e um payload final escrito em Go (versão 1.22.0) contendo a funcionalidade maliciosa real.
O malware tem como alvo uma ampla gama de dados sensíveis, incluindo credenciais salvas de mais de 30 navegadores baseados em Chromium e Gecko, carteiras de criptomoedas de mais de 40 provedores, tokens de sessão do Discord, Steam e Telegram, e informações de sistema coletadas via consultas WMI. Ele suporta as três gerações de criptografia de dados do Chrome: DPAPI legácy, AES-256-GCM com master key (Chrome 80-126) e a nova App-Bound Encryption (Chrome 127+).
Além do roubo de dados, o malware fornece ao operador acesso remoto completo ao sistema comprometido: streaming e captura de tela em tempo real, keylogging com rastreamento de contexto de janela, monitoramento de clipboard, gravação de webcam e microfone via ffmpeg, shell reverso interativo, e capacidades de download/upload de arquivos. Também funciona como proxy SOCKS5, permitindo ao atacante rotear tráfego através das máquinas infectadas.
A comunicação com o servidor de comando e controle (C2) foi projetada para evadir monitoramento de rede tradicional. O malware resolve o domínio do C2 através de DNS-over-HTTPS (DoH) utilizando endpoints do Cloudflare e Google DNS, tornando o domínio C2 invisível em logs de DNS convencionais. A comunicação ocorre sobre os protocolos WebSocket e QUIC (UDP), dificultando ainda mais a detecção em nível de rede.
Key Findings
Empacotamento e Evasão: O malware utiliza três camadas de proteção — loader Rust com criptografia LCG de 64 bits, compressão UPX e payload final em Go 1.22. A execução é inteiramente em memória via reflective loading, sem gravação em disco. Após o carregamento, os headers do PE são apagados da memória (anti-dump). O binário carrega um certificado digital falso da Zoom Video Communications e um PDB que imita um serviço legítimo do Windows (TaskHost).
Carteiras de Criptomoedas: Alveja mais de 40 wallets entre extensões de navegador e apps desktop (MetaMask, Exodus, Phantom, Trust Wallet, Coinomi, Binance, Atomic Wallet, TonKeeper, entre outras).
Roubo de Aplicações: Extrai tokens do Discord (incluindo Canary/PTB), dados do Steam (tokens, arquivos VDF) e sessões do Telegram Desktop (pasta tdata).
Capacidades RAT: Captura e streaming de tela em tempo real via GDI, keylogger com contexto de janela ativa (SetWinEventHook), gravação de webcam e microfone via ffmpeg, shell reverso interativo, download e execução de arquivos arbitrários, proxy SOCKS5 com tunelamento P2P para pivoting, e rotinas de autodestruição que sobrescrevem e deletam o binário do disco.
Comando e Controle: Resolve o domínio C2 via DNS-over-HTTPS (Cloudflare, Google DNS), tornando-o invisível em logs DNS tradicionais. Comunicação primária via WebSocket com QUIC/UDP como fallback. Implementa rotação automática de endpoints e seleção de melhor método de conexão entre quatro estratégias.
Persistência e Escalação: Cria tarefas agendadas com múltiplos gatilhos (boot, logon, diário, ociosidade) via taskmaster, além de gravar na chave de registro HKCU Run. Escala privilégios impersonando SYSTEM via token do LSASS e RtlAdjustPrivilege. Encerra processos de navegadores para liberar locks nos bancos SQLite antes da extração.
Reconhecimento: Coleta HWID via MachineGuid, perfila o sistema via WMI (SO, CPU, GPU), enumera periféricos (webcams, microfones, drives) e monitora atividade do usuário (tempo ocioso, janela ativa).
Análise Reversa
A análise técnica aprofundada da amostra maliciosa identificada como caceta_exe.bin, um artefato de 3,45 MB classificado como PE32 executável GUI para arquitetura Intel x86.
A amostra revelou-se um malware multicamada de alta sofisticação que combina um
info-stealer abrangente com capacidades próximas ao de um RAT (Remote Access Trojan).
A arquitetura do malware é composta por três estágios distintos: um loader desenvolvido em Rust responsável pela decriptação e carregamento em memória do payload, uma camada intermediária de compressão UPX, e o payload final escrito em Go 1.22.0 contendo toda a lógica maliciosa. Cada camada foi analisada individualmente, com extração bem-sucedida do payload final de 11,6 MB a partir da reversão do algoritmo criptográfico do loader.
A análise identificou capacidades ofensivas que incluem roubo de credenciais de mais de 30 navegadores, exfiltração de mais de 40 carteiras de criptomoedas, captura de tela e keylogging em tempo real, gravação de webcam e microfone, shell reverso, proxy SOCKS5, e comunicação C2 via DNS-over-HTTPS sobre protocolos WebSocket e QUIC. O timestamp de compilação do loader (10/03/2026) indica uma preparação ou teste para uma futura campanha no território brasileiro, uma vez que “caceta” é um nome pouco sugestivo para uma campanha ativa.
Embora o nome seja chamativo, no código do malware foi identificado uma ampla gama de comentários com o nome real do malware sendo “Salat Stealer”, um malware vendido como MaaS.
Visão Geral da Arquitetura:
O binário analisado opera em um modelo de três estágios encadeados. O primeiro estágio (loader) é responsável exclusivamente por decriptar e carregar o segundo estágio em memória. O segundo estágio é o payload comprimido com UPX. O terceiro estágio é o malware funcional, um binário Go com 9.877 funções catalogadas na pclntab, das quais 332 pertencem ao pacote main e implementam diretamente a lógica malicios, abaixo, segue o fluxo de tools usadas análise do dropper.
O dropper em Rust utiliza um certificado válido do Zoom Video Communications, aplicativo para chamadas de vídeo em tempo real, tal estratégia é emplementada para a evasão de defesas.
| Ferramentas (Dropper Rust) | Versão | Finalidade |
| Python 3 (script pe_analyze.py) | 3.x | Parsing de estruturas PE, extração de seções, cálculo de entropia, extração de strings e IOCs |
| IDA Disassembler | 9.x | Disassembly x86 da seção .text para identificação do algoritmo de decriptação |
| Python 3 (script decrypt_payload.py) | 3.x | Implementação e execução do algoritmo LCG de 64 bits para decriptação do payload |
| FLOSS String Analyzer / DIE / file (coreutils) | — | Extração avançada de strings ofuscadas (FLOSS), detecção de packer/compilador (DIE) e identificação inicial do tipo de arquivo (file) |
| hashlib (Python stdlib) | — | Cálculo de hashes SHA-256, MD5 e SHA-1 |
Abaixo, seguem ferramentas utilizadas para análise do payload em Golang:
| Ferramentas (Stealer em Go) | Versão | Finalidade |
| Python 3 (script pe_analyze.py) | 3.x | Análise estrutural do PE desempacotado, extração de imports, seções e constantes criptográficas |
| IDA Disassembler | 9.x | Disassembly de funções-chave do payload Go para reconstrução de lógica |
| Python 3 (parsing pclntab) | 3.x | Extração manual da tabela pclntab do Go: resolução de nomes de funções, entry points e metadata |
| Python 3 (extração de IOCs) | 3.x | Categorização de strings por funcionalidade: SQL queries, URLs, paths de navegadores, wallets, APIs |
| strings / FLOSS String Analyzer | — | Extração bruta de strings ASCII (mínimo 6/8 caracteres) e recuperação de strings ofuscadas ou codificadas em stack |
| Ghidra + GolangAnalyzerExtension | 11.x | Engenharia reversa assistida do binário Go: recuperação de símbolos, análise de tipos, decompilação de funções e suporte a runtime Go via extensão especializada |
Algorítmo de Decriptação:
O loader apresenta 4 seções, sendo a .rdata a mais relevante com 3,29 MB de dados e entropia de 7,99 (próxima ao máximo teórico de 8,0), indicando conteúdo comprimido, onde posteriormente identificamos a utilização do cargo como gerenciador de pacotes do Rust.
Através do disassembly da seção .text, foram identificadas referências cruzadas entre as strings de debug do loader e o código executável. As strings de debug presentes no binário (em texto claro na .rdata) documentam o fluxo interno do loader:
- [DEBUG] Payload loaded. Size: %d bytes — confirma carregamento do payload
- [INFO] MZ signature valid. Calling MemoryLoadLibrary… — reflective loading
- [DEBUG] Detected x86 payload — detecção de arquitetura (x86)
- [DEBUG] Detected x64 payload — detecção de arquitetura (x64)
- [INFO] Anti-Dump: Headers erased — proteção anti-dump pós-carregamento
- [INFO] Entry point found: %x. Spawning payload thread… — execução via CreateThread
- payload_debug.log — nome do arquivo de log (gravação condicional)
Após a identificação do loop de decriptação, a análise instrução por instrução revelou um LCG (Linear Congruential Generator) de 64 bits operando como gerador de keystream, com isso, têm-se a lógica do pseudocódigo do LCG:
Em golang, nós podemos ter algo aproximado da implementação do LCG como:
Fluxo Pós-Decrypt:
Após decriptar o payload, o loader executa a seguinte sequência (confirmada via strings de debug e análise de calls):
- Valida assinatura MZ
- Loga “MZ signature valid. Calling MemoryLoadLibrary…”
- Resolve APIs via PEB walk (fs:[0x30] em 0x402FB2) — técnica de resolução dinâmica que evita imports diretos
- Chama MemoryLoadLibrary — reflective loading do PE decriptado sem gravação em disco
- Percorre os headers do PE carregado para localizar o OEP (Original Entry Point)
- Loga “Anti-Dump: Headers erased” — apaga os primeiros bytes do PE na memória (proteção anti-dump)
- Cria nova thread no OEP via CreateThread
- Entra em loop de keep-alive no thread principal
A decriptação foi implementada em Python (decrypt_payload.py) e validada com sucesso: o resultado começa com a assinatura MZ seguida de uma assinatura PE válida.
Estágio 2 – Stealer em GO (unpacked):
O payload decriptado revelou-se um binário PE32 empacotado com UPX, identificável pelas seções características UPX0, UPX1 e UPX2. A seção UPX1 contém o código comprimido com entropia 7,99 e ratio de compressão de 28,25%. A descompressão com upx -d expandiu o binário de 3,29 MB para 11MB.
| Seção | Tamanho Virtual | Tamanho Raw | Entropia | Flags |
| UPX0 | 0x867000 (8,4 MB) | 0 (vazio) | 0 | EXEC, READ, WRITE |
| UPX1 | 0x325000 (3,1 MB) | 0x324A00 | 7,99 | IDATA, EXEC, READ, WRITE |
| UPX2 | 0x1000 (4 KB) | 0x200 | 1,47 | IDATA, READ, WRITE |
O entry point do malware orquestra a seguinte sequência de inicialização, identificada via análise de calls no disassembly na função principal (main.main):
•os.Executable — obtém o caminho do próprio binário
•golang.org/x/sys/windows.(*LazyProc).Call — chama SetProcessDPIAware para configuração de display
•main.checkDupe (0x008885E0) — verifica se já existe uma instância via gow32.CreateMutex, consultando múltiplos caminhos com os.Expand(“$LOCALAPPDATA\\…”) e os.Expand(“$APPDATA\\…”)
•main.isAdmin (0x0087F7A0) — verifica privilégios via windows.AllocateAndInitializeSid com SECURITY_BUILTIN_DOMAIN_RID + DOMAIN_ALIAS_RID_ADMINS, seguido de CheckTokenMembership
•main.staticinstall (0x00886370) — copia o binário para localização persistente
•main.newTask (0x00887480) — cria scheduled task via taskmaster com múltiplos triggers
•main.Steal (0x0088F000) — executa o roubo completo de dados
•main.initConnection (0x0087FF20) — estabelece conexão WebSocket com o C2main.(*wsSess).Start (0x008A2F59) — inicia sessão de controle remoto, aguardando
Persistência e escalada de privilégios:
Nesta etapa, o artefato busca garantir sua execução contínua no host e elevar seu contexto de segurança para manipular processos críticos do sistema.
O malware utiliza o método main.newTask para estabelecer um pé firme no sistema (Footprint). Através da biblioteca ou interface taskmaster no github, ele é capaz de criar Scheduled Tasks altamente adaptáveis. A análise identificou referências a múltiplos gatilhos (Triggers), sugerindo uma estratégia de redundância para execução:
- Boot/LogonTrigger: Garante a execução logo após a inicialização ou login do usuário.
- Daily/IdleTrigger: Executa o payload em intervalos diários ou quando o sistema está ocioso, minimizando a chance de detecção pelo usuário.
- EventTrigger: Permite que o malware “acorde” em resposta a eventos específicos do Windows.
Para operar sem restrições, o malware tenta elevar seus privilégios de usuário comum para NT AUTHORITY\SYSTEM através de uma técnica de impersonação de token:
•Habilitação de Privilégios: A função main.enablePrivilege utiliza a API nativa RtlAdjustPrivilege para adquirir o SeDebugPrivilege, necessário para interagir com processos de outros usuários e do sistema.
•Targeting do LSASS: O componente main.findLsassProcess enumera os processos ativos no sistema (via CreateToolhelp32Snapshot) para localizar o PID do processo lsass.exe.
•Duplicaçãode Token: Uma vez localizado o LSASS, o método main.getSystemToken utiliza as APIs DuplicateTokenEx e ImpersonateLoggedOnUser. Isso permite que o malware “se passe” pelo sistema, obtendo as permissões necessárias para, por exemplo, realizar o dump de credenciais ou manipular headers PE na memória sem bloqueios de segurança.
main.Steal – Função de roubo de credencial:
A função orquestradora central do artefato atua como o motor de coleta (Stealer), sendo responsável por enumerar e extrair informações sensíveis de diversas aplicações.
O malware utiliza a função os.Expand para realizar a resolução dinâmica de variáveis de ambiente do Windows, como %LOCALAPPDATA% e %APPDATA%. Essa técnica permite que o malware localize de forma precisa os diretórios de perfil de usuários, independentemente do nome do usuário ou da versão do sistema operacional.
A execução segue um fluxo sequencial, acionando módulos específicos para cada alvo:
Browsers (Chromium & Gecko): Através das funções main.getChrome e main.getGecko, o malware realiza o dump de bancos de dados SQLite contendo senhas salvas, cookies de sessão, histórico de navegação e cartões de crédito.
Comunicações (Discord): A função main.getDiscord foca na extração de tokens de autenticação (Discord Tokens), permitindo que o atacante assuma o controle da conta da vítima sem necessidade de senha ou MFA.
Gaming (Steam): O módulo main.getSteams busca por arquivos de configuração e credenciais da plataforma Steam, visando o inventário e acesso a contas de jogos.
Criptoativos (BC1 & BC2): As funções main.getBC1 e main.getBC2 implementam lógica para detecção de carteiras e endereços de Bitcoin, sugerindo um foco financeiro direto.
main.getChrome:
Orquestrador central especializado na extração de segredos de navegadores baseados em Chromium.
- Recuperação de Master Keys (main.GetChromiumMasterKeys)
– Parsing: Localiza o arquivo Local State e extrai a encrypted_key via JSON.
– Decriptação Base: Utiliza DPAPI (CryptUnprotectData) para chaves convencionais.
– Evasão Chrome 127+: Consulta a tabela meta via SQL para identificar novos métodos de criptografia.
– App-Bound Bypass: Emprega a interface COM IElevator (main.Elevate) para descriptografar chaves protegidas por privilégios de processo. - Extração de Dados (Login, Cookies, Tokens)
– Preparação: Copia bases (Login Data, Cookies, Web Data) para %TEMP% para contornar file locks.
– Queries SQL: Executa comandos SELECT via go-sqlite3 para coletar credenciais, sessões, autofills e tokens de serviço.
– Decriptação de Payload: Processa campos criptografados utilizando o algoritmo AES-256-GCM (main.decryptAesGcm256).
Navegadores alvo (paths extraídos do binário com offsets):
– Local\Google\Chrome\User Data (0x005826B7)
– Local\Microsoft\Edge\User Data (0x005835C8)
– Local\BraveSoftware\Brave-Browser\User Data (0x0058629D)
– Roaming\Opera Software\Opera Stable (0x00587D03)
– Roaming\Opera Software\Opera GX Stable (0x0058A155)
– Local\Vivaldi\User Data, Local\Thorium\User Data, Local\Iridium\User Data (0x0057CB5C)
– Local\Yandex\YandexBrowser\User Data (0x005887D0)
E mais 23 navegadores variantes regionais.
Módulo Gecko Stealer: Resumo Técnico
Focado na extração de dados de navegadores baseados em Mozilla (NSS).
- Extração de Chaves (main.GetGeckoMasterKey)
Database: Consulta key4.db (nssPrivate) para obter blobs de chaves.
Criptoanálise: Utiliza Parser ASN.1 e decriptação via 3DES ou AES-128-CBC para derivar a chave mestre. - Coleta de Dados
Logins: Recupera credenciais do logins.json via queries na metaData.
Cookies: Extrai sessões do banco moz_cookies. - Alvos (Profiles em %APPDATA%)
Principais: Firefox, Thunderbird, Pale Moon, Waterfox e SeaMonkey.
Variantes: IceDragon, Cyberfox, Mercury, BlackHawk e Kotatogram.
Comunicação C2, Resiliência DNS e Keylogging:
Este componente gerencia a conexão do malware com sua infraestrutura externa, priorizando a evasão de defesas de rede através de protocolos cifrados.
1. Resolução de Endpoint via DoH (main.getBestMethod):
O malware utiliza DNS-over-HTTPS (DoH) para ocultar consultas DNS em tráfego HTTPS legítimo, dificultando o bloqueio por firewalls ou inspeção de pacotes (DPI). Ele testa quatro métodos em sequência:
•Método 1 & 3: Consultas via Cloudflare DoH (1.1.1.1).
•Método 2: Consulta via Google DoH (dns.google).
•Método 4 (Fallback): Resolução DNS tradicional caso os serviços de DoH falhem.
2. Estabelecimento de Conexão e Persistência:
•WebSocket (main.initConnection): Após resolver o IP, o malware estabelece um canal WebSocket, permitindo comunicação fullduplex e persistente com o servidor de comando.
•Rotação de C2 (main.changeEndpoint): Implementa lógica de redundância para rotacionar entre diferentes infraestruturas de C2 caso a conexão principal seja derrubada ou bloqueada.
•Gestão de Fluxo (main.c2Server): Função responsável por processar as ordens recebidas (ex: novos payloads ou comandos de exfiltração).
Demais funções para Keylogging e C2:
| Função | Endereço | Tamanho | Descrição |
| main.startKeylogger | 0x008769C0 | ~416 bytes | Inicia processo filho com flag de keylog, chamando os/exec.Command |
| main.runKeylogger | 0x0087DE80 | ~1056 bytes | Loop principal do keylogger |
| main.keyPressCallback | 0x0087D830 | ~1616 bytes | Callback registrado via SetWinEventHook; captura cada tecla pressionada |
| main.windowChangeCallback | 0x0087D640 | ~384 bytes | Detecta troca de janela ativa para contextualizar as teclas capturadas (registra qual aplicativo/site estava aberto) |
| main.specialKeyName | 0x0087CCF0 | ~2192 bytes | Tabela de mapeamento de teclas especiais (Enter, Backspace, PrintScreen, etc.) |
| main.periodicFlush | 0x0087D7C0 | ~112 bytes | Envia buffer de teclas periodicamente ao C2 |
Dependências utilizadas em importação (Go):
| Pacote | Funcionalidade no malware |
| github.com/ncruces/go-sqlite3 | Leitura dos bancos SQLite dos navegadores |
| github.com/tetratelabs/wazero | Runtime WebAssembly (utilizado pelo go-sqlite3) |
| github.com/gorilla/websocket | Comunicação WebSocket com o C2 |
| github.com/quic-go/quic-go | Transporte QUIC/UDP alternativo |
| github.com/capnspacehook/taskmaster | Criação de scheduled tasks (persistência) |
| github.com/StackExchange/wmi | Consultas WMI para reconhecimento |
| github.com/go-ole/go-ole | Automação COM/OLE (IElevator) |
| github.com/lxn/win | Bindings Win32 API (screenshots, janelas) |
| github.com/nfnt/resize | Redimensionamento de imagens (screenshots) |
| github.com/andygrunwald/vdf | Parser Valve Data Format (dados Steam) |
| github.com/buger/jsonparser | Parsing JSON rápido (Local State, configs) |
| github.com/rodolfoag/gow32 | CreateMutex e utilitários Win32 |
| github.com/rickb777/date | Manipulação de datas |
| golang.org/x/crypto/chacha20poly1305 | Criptografia ChaCha20-Poly1305 (TLS/QUIC) |
| golang.org/x/sys/windows | Syscalls Windows (tokens, privilégios, SIDs) |
IOC’s
Hashes de arquivos
| Camada | SHA-256 | MD5 | SHA-1 |
| Loader (Rust) | f9d2cde030680a3a98c0ac0c5382d349783ce80f04b7d9d8f2d4d688dcebe91e | cad7968cf3a15c183ad56b1fb041d669 | a9ea8c7464fdcf6913eee1ce7f9fd0c82b21e5c4 |
| Payload decriptado (UPX) | fe516af74599ad02d28bd28e37cc95fe22087b6d2bb2140517786a13282c911c | bb3c343a9372eca207eaf5765c4e5789 | 7c42a378def8acab5a94d225ba4bbb7244a08b11 |
| Payload final (Go) | 8504f75d15c65179753680756cea02f192c2759b478d220be3fa25c9544dad74 | — |
Import hashes
| Camada | ImpHash |
| Loader Rust | 8ffa7dc224163693c37e87d3a8721f45 |
| Payload Go | 9f8577af3b56dbdad5b554c5839df89b |
Artefatos de rede:
| Tipo | Indicador | Contexto |
| DoH endpoint | https://1.1[.]1.1/dns-query | Cloudflare — resolução do domínio C2 |
| DoH endpoint | https://dns.google/resolve | Google — resolução do domínio C2 |
| DoH endpoint | https://cloudflare-dns.com/dns-query | Cloudflare alt — resolução do domínio C2 |
| Content-Type | application/dns-json | Header usado nas requisições DoH |
| Protocolo | WebSocket (TCP) | Canal primário de C2 |
| Protocolo | QUIC (UDP) | Canal alternativo de C2 |
| Protocolo | SOCKS5 | Proxy reverso / pivoting |
Artefatos
| Tipo | Indicador | Contexto |
| PDB | TaskHost_c805c8f8.pdb | Path PDB do loader |
| Certif. | Zoom Video Communications, Inc. | Certificado digital falso embutido |
| Arquivo | ${TEMP}\ffmpeg.exe | ffmpeg baixado para gravação de mídia |
| Arquivo | payload_debug.log | Log de debug do loader (gravação condicional) |
| Arquivo | SteamTokens.txt | Tokens Steam exfiltrados |
| Registry | HKLM\SOFTWARE\Microsoft\Cryptography\MachineGuid | Lido para fingerprinting |
| Registry | HKCU\Software\Microsoft\Windows\CurrentVersion\Run | Persistência via Run key |
| Caminho | C:\Windows\System32\restore\MachineGuid.txt | Backup do MachineGuid |
| Caminho | C:\Windows\SysWOW64\restore\MachineGuid.txt | Backup alternativo |
MITRE ATT&CK
| Tática | ID | Técnica | Procedimento |
| Execution | T1129 | Shared Modules | MemoryLoadLibrary — reflective loading do PE decriptado sem gravação em disco |
| Execution | T1059.003 | Windows Command Shell | Shell reverso interativo via main.(*wsSess).startShell executando cmd.exe |
| Persistence | T1053.005 | Scheduled Task | main.newTask cria tasks via taskmaster com triggers de boot, logon e idle |
| Persistence | T1547.001 | Registry Run Keys | Escrita em HKCU\Software\Microsoft\Windows\CurrentVersion\Run |
| Privilege Escalation | T1068 | Exploitation for Priv. Escalation | main.Elevate usa interface COM IElevator do Chrome/Edge/Brave |
| Privilege Escalation | T1134.001 | Token Impersonation/Theft | main.impersonateSystem duplica token SYSTEM do LSASS via DuplicateTokenEx |
| Defense Evasion | T1027.002 | Software Packing | Tripla camada: LCG 64-bit + UPX + binário Go embutido em .rdata |
| Tática | ID | Técnica | Procedimento |
| Defense Evasion | T1620 | Reflective Code Loading | PE carregado em memória via MemoryLoadLibrary sem tocar o disco |
| Defense Evasion | T1622 | Debugger Evasion | IsDebuggerPresent verificado; headers do PE apagados da memória (anti-dump) |
| Credential Access | T1555.003 | Credentials from Web Browsers | Senhas via SQL em Login Data (Chromium) e key4.db (Firefox) |
| Credential Access | T1539 | Steal Web Session Cookie | main.getChromeCookies / getGeckoCookies decriptam cookies de sessão |
| Credential Access | T1003.001 | LSASS Memory | main.findLsassProcess via CreateToolhelp32Snapshot; duplica token do LSASS |
| Discovery | T1082 | System Information Discovery | WMI: Win32_OperatingSystem, Win32_Processor, Win32_VideoController |
| Discovery | T1057 | Process Discovery | main.processes enumera via CreateToolhelp32Snapshot + Process32FirstW |
| Collection | T1056.001 | Keylogging | main.runKeylogger com hook SetWinEventHook; contexto por janela ativa |
| Collection | T1113 | Screen Capture | main.getScreen via GDI GetDIBits; streaming contínuo em tempo real |
| Collection | T1119 | Automated Collection | main.Steal orquestra todos os módulos de coleta |
| Command and Control | T1071.001 | Web Protocols | WebSocket (gorilla/websocket) |
| Command and Control | T1071.004 | DNS | DNS-over-HTTPS |
| Command and Control | T1095 | Non-Application Layer Protocol | QUIC/UDP (quic-go) como alternativa ao WebSocket |
| Exfiltration | T1041 | Exfiltration Over C2 Channel | Dados compactados em ZIP |
