~/labs/cases/whatsapp-web-hta-dropper

Um arquivo estranho de WhatsApp Web que virou um dropper de propagação por contatosUm HTA suspeito esconde um dropper VBScript multiestágio que instala automação em Python e abusa do WhatsApp Web para exfiltrar contatos e espalhar um arquivo remoto.

No dia 12 de fevereiro de 2026 recebi um arquivo de um contato conhecido. Essa era a parte perigosa: a pessoa era familiar, mas o nome do arquivo não fazia sentido. O artefato não era uma foto, não era um PDF e não parecia algo normal em uma conversa pelo WhatsApp Web. Era um HTA chamado A-8dd9b4be89d585d36.hta.

Tratei como hostil e não executei. A ideia desta análise foi seguir a rotina de um analista pegando o arquivo do zero: identificar o tipo, observar o primeiro comportamento esperado, desmontar a ofuscação, reconstruir a cadeia de execução e entender o impacto final.

Amostra

Arquivo: whats/A-8dd9b4be89d585d36.hta
Tipo:    HTML Application / VBScript HTA
Tamanho: 994.809 bytes
SHA256:  5a822a163d0787bcfd52b2ae3ace6cb6a92eb158a52b0fbe3cf0380acc2cb702

Eu comecei com triagem básica, sem abrir o arquivo no Windows:

$ file whats/A-8dd9b4be89d585d36.hta
whats/A-8dd9b4be89d585d36.hta: HTML document, ASCII text, with very long lines (2800)

$ sha256sum whats/A-8dd9b4be89d585d36.hta
5a822a163d0787bcfd52b2ae3ace6cb6a92eb158a52b0fbe3cf0380acc2cb702  whats/A-8dd9b4be89d585d36.hta

$ wc -c whats/A-8dd9b4be89d585d36.hta
994809 whats/A-8dd9b4be89d585d36.hta

$ xxd -g 1 -l 256 whats/A-8dd9b4be89d585d36.hta
00000000: 3c 68 74 6d 6c 3e 0a 3c 68 65 61 64 3e 0a 3c 74  <html>.<head>.<t
00000010: 69 74 6c 65 3e 53 79 73 74 65 6d 20 41 75 74 6f  itle>System Auto
00000020: 6d 61 74 69 6f 6e 3c 2f 74 69 74 6c 65 3e 0a 3c  mation</title>.<
00000030: 48 54 41 3a 41 50 50 4c 49 43 41 54 49 4f 4e 20  HTA:APPLICATION 
00000040: 0a 20 20 20 20 20 41 50 50 4c 49 43 41 54 49 4f  .     APPLICATIO
00000050: 4e 4e 41 4d 45 3d 22 53 79 73 74 65 6d 20 50 72  NNAME="System Pr
00000060: 6f 63 65 73 73 22 0a 20 20 20 20 20 53 43 52 4f  ocess".     SCRO
00000070: 4c 4c 3d 22 6e 6f 22 0a 20 20 20 20 20 53 49 4e  LL="no".     SIN
00000080: 47 4c 45 49 4e 53 54 41 4e 43 45 3d 22 79 65 73  GLEINSTANCE="yes
00000090: 22 0a 20 20 20 20 20 49 4e 4e 45 52 42 4f 52 44  ".     INNERBORD
000000a0: 45 52 3d 22 6e 6f 22 0a 20 20 20 20 20 42 4f 52  ER="no".     BOR
000000b0: 44 45 52 3d 22 74 68 69 6e 22 0a 20 20 20 20 20  DER="thin".     
000000c0: 4d 41 58 49 4d 49 5a 45 42 55 54 54 4f 4e 3d 22  MAXIMIZEBUTTON="
000000d0: 6e 6f 22 0a 20 20 20 20 20 4d 49 4e 49 4d 49 5a  no".     MINIMIZ
000000e0: 45 42 55 54 54 4f 4e 3d 22 6e 6f 22 0a 20 20 20  EBUTTON="no".   
000000f0: 20 20 53 48 4f 57 49 4e 54 41 53 4b 42 41 52 3d    SHOWINTASKBAR=

O resultado já muda a forma de tratar o caso. No Windows, .hta é executado pelo mshta.exe; não é só uma página HTML. Um HTA pode rodar VBScript/JScript com acesso local, então é um formato clássico para phishing e loaders.

Primeira leitura: o arquivo tenta sumir

O cabeçalho não parecia uma aplicação feita para o usuário ver:

<title>System Automation</title>
<HTA:APPLICATION
     APPLICATIONNAME="System Process"
     SHOWINTASKBAR="no"
     WINDOWSTATE="minimize">

Sub Window_OnLoad
    On Error Resume Next
    Self.Close
End Sub

Isso me deu a primeira hipótese operacional: o atacante espera que a vítima dê dois cliques em um arquivo vindo de uma conversa confiável. Quando o arquivo abre, ele tenta não deixar uma janela útil: roda minimizado, não aparece na taskbar e fecha a própria janela no Window_OnLoad.

Para a vítima, o efeito esperado é banal: “cliquei e nada abriu”. Para o atacante, isso é suficiente. O clique já entregou execução ao mshta.exe.

Mapa dos níveis de ofuscação

Antes de falar do payload final, vale separar as camadas. Esse tipo de arquivo fica confuso justamente porque mistura truque social, truque de interface e truque de código.

Nível	Técnica	O que esconde
0	Entrega por contato conhecido	O arquivo chega com confiança herdada da conversa
1	HTA com janela minimizada e `Self.Close`	O usuário não vê uma aplicação rodando
2	`On Error Resume Next`	Falhas não aparecem para o usuário
3	Funções vazias e comentários falsos	A leitura manual fica mais cansativa
4	Arrays numéricos com subtração modular	Strings reais não aparecem em busca simples
5	Expressões `Chr((a-b) Xor k)`	Outra forma de esconder texto por caractere
6	554 blocos `Layer`	Volume artificial para atrasar análise
7	`ExecuteGlobal`	O script real só existe em runtime
8	Segundo estágio também obfuscado	A primeira deofuscação ainda não revela tudo
9	Download remoto de MSI/Python/script	O HTA inicial não precisa carregar todo o malware

O ponto importante: a ofuscação não é criptografia forte. É uma sequência determinística de transformações simples, aplicada muitas vezes.

Camada de array: input e output

O primeiro bloco útil começa assim:

' Layer 1 - Array decode
eSTozhYKiMeDheJ = "178|215|219|142|185|187|227|228|192|223|196|..."

For Each hYz6RqRS5 In Split(eSTozhYKiMeDheJ, "|")
    DX8XfEmqzNr = CInt(hYz6RqRS5)
    DX8XfEmqzNr = (DX8XfEmqzNr - 110 + 256) Mod 256
    cN6ZiOQ0QI8 = cN6ZiOQ0QI8 & Chr(DX8XfEmqzNr)
Next
g9FTeNPd0SD = g9FTeNPd0SD & cN6ZiOQ0QI8

Essa função não faz nada mágico. Ela pega cada número, subtrai uma chave e converte o resultado para caractere.

A conta é:

byte = (numero - chave + 256) % 256
char = Chr(byte)

Para demonstrar sem executar o HTA, usei só os primeiros números da camada:

$ nums='178|215|219|142|185|187|227|228|192|223|196'
$ key=110
$ tr '|' '\n' <<< "$nums" \
>   | awk -v k="$key" '{ printf "%c", ($1-k+256)%256 } END { print "" }'
Dim KMuvRqV

Esse output é importante. A primeira camada já não está reconstruindo uma URL ou um comando final; ela começa reconstruindo outro VBScript. Ou seja, o HTA visível é só um decoder que monta um segundo script.

Camada com XOR: outro formato, mesma ideia

Algumas camadas não usam array. Elas concatenam várias chamadas Chr:

g9FTeNPd0SD = g9FTeNPd0SD & Chr((242-49) Xor 225) &
                              Chr((237-44) Xor 225) &
                              Chr((179-11) Xor 225) & ...

A operação por caractere é:

byte = (a - b) XOR chave
char = Chr(byte)

Um exemplo mínimo ficou como um script real em whats/analysis/decode_xor_example.py:

$ python3 whats/analysis/decode_xor_example.py
  If Len(mme

De novo, não é uma cifra complexa. É só aritmética escondendo texto. A defesa do atacante é volume: repetir isso centenas de vezes.

Deofuscação segura do primeiro estágio

Para automatizar a extração, escrevi um parser simples que procura dois padrões: arrays numéricos e sequências Chr((a-b) Xor k). Ele não executa o HTA nem chama ExecuteGlobal; só interpreta texto.

Uso:

$ python3 whats/analysis/decode_vbs_layers.py \
>   whats/A-8dd9b4be89d585d36.hta \
>   whats/analysis/stage1.vbs
decoded 47051 bytes to whats/analysis/stage1.vbs

O resultado confirma o que a camada 1 já sugeria: o primeiro payload recuperado é outro VBScript. Ele usa outro acumulador (KMuvRqV) e termina novamente com execução dinâmica:

ExecuteGlobal KMuvRqV

Esse é o segundo ponto didático do caso. Deofuscar uma camada não significa chegar ao malware final. Muitas campanhas usam “decode -> execute -> decode de novo” para frustrar análise rápida.

Em um laboratório isolado, outro caminho seria substituir ExecuteGlobal X por WScript.Echo X e rodar o VBS em um ambiente controlado para imprimir o próximo estágio. Para material didático, prefiro o parser estático quando possível, porque ele evita executar lógica do atacante.

O limite do primeiro HTA

No final do arquivo original, a estrutura fica explícita:

' Layer 554
g9FTeNPd0SD = g9FTeNPd0SD & Chr((196-5) Xor 241)&...

' Execute decoded payload
ExecuteGlobal g9FTeNPd0SD

Contei 554 blocos Layer. O número é mais psicológico do que técnico. Ele serve para tornar o arquivo grande, confuso e pouco amigável para revisão manual. O método, porém, continua igual: reconstruir string e executar.

O que o loader faz depois

Depois da deofuscação em etapas, a cadeia recuperada vira um dropper:

HTA
  -> VBScript decodificado
  -> segundo VBScript decodificado
  -> C:\temp\instalar.bat
  -> MSI remoto + Python embutido
  -> whats.py / whatsz.py
  -> automação do WhatsApp Web

O batch em C:\temp\instalar.bat prepara o ambiente:

Escolhe uma URL de download em centrogauchodabahia123.com.
Baixa um MSI com PowerShell.
Instala silenciosamente com msiexec /qn.
Prepara um Python embutido em C:\temp.
Instala bibliotecas de automação: Selenium, PyAutoGUI, hooks de teclado/mouse, OpenCV, Pillow, Requests, webdriver-manager e afins.
Baixa o script final de automação do WhatsApp.
Inicia com pythonw.exe, sem janela de console.

Esse desenho mostra o objetivo do HTA: ele não precisa conter o malware inteiro. Ele precisa só ganhar execução e construir a base para o payload real.

O payload final: automação de WhatsApp Web

O estágio Python é centrado em automação de navegador. O objetivo não é “quebrar” a autenticação do WhatsApp. Ele abusa da sessão local da vítima.

Se a vítima já usa WhatsApp Web, o malware tenta reutilizar ou copiar dados de perfil do navegador. Depois injeta JavaScript na página do WhatsApp Web para operar a conta da própria vítima.

O comportamento recuperado mostra quatro capacidades principais:

1. Buscar configuração de campanha no servidor do atacante.
2. Reutilizar dados de perfil do Chrome, Edge ou Firefox quando possível.
3. Injetar WPPConnect/WA-JS no WhatsApp Web.
4. Enumerar contatos e enviar mensagens/arquivos em massa.

Infraestrutura observada:

https://centrogauchodabahia123.com/api/config.php
https://centrogauchodabahia123.com/api/contacts.php
https://centrogauchodabahia123.com/api/log.php
https://centrogauchodabahia123.com/api/contador.php
https://centrogauchodabahia123.com/altor/wppconnect-wa.js
https://centrogauchodabahia123.com/altor/gera2.php

O roubo de contatos já é dano imediato. Antes mesmo da fase de propagação, o operador recebe nomes e telefones da rede de contatos da vítima. Depois, a mesma automação consegue enviar uma saudação, anexar um arquivo configurado remotamente e mandar uma mensagem final para vários contatos.

Essa é a expectativa real do atacante: cada nova vítima vira um remetente confiável. O próximo alvo recebe um arquivo de alguém conhecido, não de um número aleatório.

O que o atacante faz para esconder o intuito

A amostra combina várias técnicas simples:

Confiança social: o arquivo chega por uma conta conhecida.
HTA em vez de documento comum: o usuário pode não perceber que é executável.
Janela invisível: o HTA minimiza, some da taskbar e fecha ao carregar.
Falhas silenciadas: On Error Resume Next evita mensagens visíveis.
Ruído estrutural: funções vazias e comentários falsos simulam complexidade.
Strings ausentes: URLs e comandos não aparecem no primeiro grep simples.
Execução dinâmica: ExecuteGlobal roda código montado em memória.
Instalação silenciosa: msiexec /qn e redirecionamentos escondem output.
Python sem console: pythonw.exe mantém a automação em background.
Configuração remota: mensagens, delays e arquivo distribuído podem mudar no servidor.

Impacto

A vítima não perde a senha do WhatsApp no sentido tradicional. O malware pega carona na sessão local já autenticada.

O impacto prático ainda é alto:

Contatos são exfiltrados para o atacante.
A própria conta de WhatsApp da vítima pode enviar arquivos e mensagens.
Os destinatários confiam porque a mensagem veio de uma conta conhecida.
O operador consegue ajustar a campanha remotamente.
A máquina mantém ferramentas locais em C:\temp, incluindo Python e dependências de automação de navegador.

O resultado final é um ciclo de propagação: uma conta confiável envia a isca para o próximo conjunto de contatos confiáveis.

Como eu transformaria isso em aula

Para uma aula, eu dividiria o exercício em quatro blocos:

Triagem: identificar HTA, hash, tamanho, cabeçalho e auto-fechamento.
Ofuscação: explicar array decode e XOR decode com input/output pequeno.
Extração segura: usar parser textual ou trocar ExecuteGlobal por print em VM isolada.
Cadeia final: mapear dropper, infraestrutura, Python e abuso do WhatsApp Web.

O ponto pedagógico principal é mostrar que “parece complexo” não significa “é criptograficamente forte”. A maior parte do trabalho é ter disciplina para separar ruído, transformação determinística e comportamento real.

Indicadores

SHA256
5a822a163d0787bcfd52b2ae3ace6cb6a92eb158a52b0fbe3cf0380acc2cb702

Caminhos locais suspeitos
C:\temp\instalar.bat
C:\temp\whats.py
C:\temp\python.exe
C:\temp\python312._pth

Cadeia de processos suspeita
mshta.exe -> powershell.exe
mshta.exe -> msiexec.exe
mshta.exe -> pythonw.exe

Indicadores de rede
centrogauchodabahia123.com
/api/config.php
/api/contacts.php
/api/log.php
/api/contador.php
/api/api.php
/altor/wppconnect-wa.js
/altor/gera2.php

Conclusão

O arquivo é um dropper de propagação por WhatsApp Web. O HTA é a camuflagem do primeiro estágio: esconde a janela, decodifica um payload e move a execução para uma cadeia de scripts. O payload recuperado monta um ambiente de automação em Python, conversa com infraestrutura controlada pelo atacante, reutiliza a sessão do navegador da vítima, extrai contatos do WhatsApp e envia um arquivo controlado remotamente para esses contatos.

A lição importante é que o atacante não precisa quebrar a autenticação do WhatsApp. Ele usa a confiança que já existe na máquina da vítima e na rede social da própria vítima.