FRITZFROG: UMA NOVA GERAÇÃO DE BOTNETS PONTO A PONTO

Views: 38
0 0
Read Time:10 Minute, 2 Second

Sumário executivo

  • A Guardicore descobriu o FritzFrog , um sofisticado botnet peer-to-peer (P2P) que vem violando ativamente servidores SSH desde janeiro de 2020.
  • Malware baseado em Golang: FritzFrog executa um worm malware que é escrito em Golang e é modular, multi-threaded e sem arquivo, não deixando rastros no disco da máquina infectada.
  • Visando ativamente o governo, a educação, as finanças e muito mais : o FritzFrog tentou usar a força bruta e se propagou para dezenas de milhões de endereços IP de escritórios governamentais, instituições educacionais, centros médicos, bancos e várias empresas de telecomunicações. Entre eles, violou com sucesso mais de 500 servidores, infectando universidades conhecidas nos Estados Unidos e na Europa, e uma empresa ferroviária.
  • Sofisticação : FritzFrog é totalmente proprietário; sua implementação P2P foi escrita do zero, nos ensinando que os invasores são desenvolvedores de software altamente profissionais.
  • Interceptação : Guardicore Labs desenvolveu um programa cliente em Golang que é capaz de interceptar a comunicação P2P de FritzFrog, bem como ingressar como um par de rede.
  • Atribuição : Embora não possamos atribuir o botnet FritzFrog a um grupo específico, encontramos algumas semelhanças com um botnet P2P visto anteriormente chamado Rakos.

Introdução

FritzFrog é um botnet ponto a ponto (P2P) altamente sofisticado que vem violando ativamente servidores SSH em todo o mundo. Com sua infraestrutura descentralizada, distribui o controle entre todos os seus nós. Nessa rede sem um único ponto de falha, os pares se comunicam constantemente entre si para manter a rede viva, resiliente e atualizada. A comunicação P2P é feita em um canal criptografado, usando AES para criptografia simétrica e o protocolo Diffie-Hellman para troca de chaves.

Ao contrário de outros botnets P2P, o FritzFrog combina um conjunto de propriedades que o torna único: ele não tem arquivo, pois monta e executa cargas úteis na memória. É mais agressivo em suas tentativas de força bruta, mas permanece eficiente ao distribuir alvos uniformemente na rede. Finalmente, o protocolo P2P do FritzFrog é proprietário e não é baseado em nenhuma implementação existente.

O malware, que é escrito em Golang, é completamente volátil e não deixa rastros no disco. Ele cria um backdoor na forma de uma chave pública SSH, permitindo que os invasores tenham acesso contínuo às máquinas das vítimas. Desde o início da campanha, identificamos 20 versões diferentes do executável do malware.

Neste relatório, descreveremos como a campanha FritzFrog foi descoberta, a natureza de sua rede P2P e o funcionamento interno do malware – incluindo o processo de infecção, criptografia de comando e comportamento volátil.

O Guardicore Labs fornece um repositório Github contendo um script de detecção, bem como uma lista de Indicadores de Compromisso (IOCs) para esta campanha.

Explorando FritzFrog

Guardicore Labs notou essa campanha pela primeira vez como parte de sua pesquisa em andamento da Enciclopédia de Botnet . Em 9 de janeiro, novos incidentes de ataque apareceram onde processos maliciosos chamados ifconfig e nginx foram executados. Começamos a monitorar a atividade da campanha, que aumentou de forma constante e significativa com o tempo, atingindo um total de 13 mil ataques na Rede de Sensores Globais da Guardicore (GGSN). Desde sua primeira aparição, identificamos 20 versões diferentes do binário Fritzfrog.

O que foi intrigante nesta campanha foi que, à primeira vista, não havia nenhum servidor de comando e controle (CNC) sendo conectado. Foi logo após o início da pesquisa que entendemos que tal CNC não existia.

Para interceptar a rede FritzFrog, a Guardicore Labs desenvolveu um programa cliente em Golang, que realiza o processo de troca de chaves com o malware e é capaz de enviar comandos e receber seus resultados. Esse programa, que chamamos de frogger, nos permitiu investigar a natureza e o escopo da rede. Usando o Frogger, também fomos capazes de entrar na rede “injetando” nossos próprios nós e participando do tráfego P2P em andamento.

FritzFrog foi encontrado para forças brutas de milhões de endereços IP, entre os quais escritórios governamentais, instituições educacionais, centros médicos, bancos e várias empresas de telecomunicações. Ele violou com sucesso mais de 500 servidores SSH, incluindo aqueles de instituições de ensino superior conhecidas nos EUA e na Europa, e uma empresa ferroviária.

P2P de nova geração

Por que “New-Generation”?

FritzFrog tem uma combinação especial de propriedades, o que o torna único no cenário de ameaças:

  • Sem arquivo – FritzFrog opera sem diretório de trabalho e as transferências de arquivos são feitas na memória usando blobs.
  • Atualizando constantemente – bancos de dados de alvos e máquinas violadas são trocados sem problemas.
  • Agressivo – a força bruta é baseada em um extenso dicionário. Em comparação, DDG, um botnet P2P recentemente descoberto, usava apenas o nome de usuário “root”.
  • Eficiente – os alvos são distribuídos uniformemente entre os nós.
  • Proprietário – O protocolo P2P é totalmente proprietário, não dependendo de nenhum protocolo P2P conhecido, como μTP.

Depois que a vítima é violada com sucesso, ela começa a executar o malware empacotado com UPX, que se apaga imediatamente. O processo de malware é executado sob os nomes ifconfig e nginx, para minimizar a suspeita. Como parte de seu processo de inicialização, o malware começa a escutar na porta 1234, esperando por comandos. Os primeiros comandos que uma nova vítima recebe são responsáveis ​​por sincronizar a vítima com o banco de dados de pares de rede e alvos de força bruta.

O tráfego em uma porta não padrão, como 1234, pode ser facilmente detectado e bloqueado por firewalls e outros produtos de segurança. Assim, o autor de FritzFrog empregou uma técnica criativa para evitar a detecção e permanecer sob o radar. Em vez de enviar comandos diretamente pela porta 1234, os comandos são enviados à vítima da seguinte maneira: O invasor se conecta à vítima por SSH e executa um cliente netcat na máquina da vítima, que por sua vez se conecta ao servidor do malware. A partir deste ponto, qualquer comando enviado por SSH será usado como entrada do netcat, sendo transmitido ao malware.

Os atacantes do Fritzfrog implementaram um canal de comando criptografado com mais de 30 comandos diferentes. Os parâmetros de comando e as respostas são transferidos em estruturas de dados designadas e serializados (“empacotados”) para o formato JSON. Antes do envio, os dados são criptografados usando criptografia simétrica AES e codificados em Base64. Para concordar com a chave de criptografia, os nós envolvidos usam o protocolo de troca de chaves Diffie-Hellman.

Os nós na rede FritzFrog mantêm contato próximo uns com os outros. Eles constantemente pingam uns aos outros para verificar a conectividade, trocar pontos e alvos e manter um ao outro sincronizado. Os nós participam de um processo inteligente de votação, que parece afetar a distribuição de alvos de força bruta pela rede. O Guardicore Labs observou que os alvos são distribuídos uniformemente, de forma que dois nós na rede não tentam “quebrar” a mesma máquina alvo.

Investigando o malware

O binário do FritzFrog é um malware avançado escrito em Golang. Ele opera completamente na memória; cada nó que executa o malware armazena em sua memória todo o banco de dados de alvos e pares. O malware gera vários threads para executar várias tarefas simultaneamente, conforme detalhado na tabela abaixo.

FritzFrog define os seguintes estados em relação ao gerenciamento de vítimas e máquinas alvo.

  • Alvo – uma máquina encontrada na fila de destino será alimentada em seguida para o módulo Cracker, que por sua vez fará a varredura e tentará aplicá-la à força bruta;
  • Implementar – uma máquina que foi violada com sucesso é enfileirada para infecção por malware pelo módulo DeployMgmt;
  • Pertencente – uma máquina que foi infectada com sucesso será adicionada à rede P2P pelo módulo Pertencente.

Cada nó que executa o malware tem um thread de trabalho que é responsável por receber comandos, analisá-los e enviá-los para a função apropriada no código.

O malware é transitório – ele tenta sobreviver a reinicializações do sistema. No entanto, um backdoor é deixado para permitir acesso futuro à vítima violada, cujas credenciais de login são salvas pelos pares da rede. O malware adiciona uma chave SSH-RSA pública ao arquivo authorized_keys. Esse backdoor simples permite que os invasores – que possuem a chave privada secreta – façam autenticação sem senha, caso a senha original seja modificada. FritzFrog usou apenas uma única chave pública que é fornecida na caixa abaixo.

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDJYZIsncBTFc+iCRHXkeGfFA67j+kUVf7h/IL+sh0RXJn7yDN0vEXz7ig73hC//2/71sND+x+Wu0zytQhZxrCPzimSyC8FJCRtcqDATSjvWsIoI4j/AJyKk5k3fCzjPex3moc48TEYiSbAgXYVQ62uNhx7ylug50nTcUH1BNKDiknXjnZfueiqAO1vcgNLH4qfqIj7WWXu8YgFJ9qwYmwbMm+S7jYYgCtD107bpSR7/WoXSr1/SJLGX6Hg1sTet2USiNevGbfqNzciNxOp08hHQIYp2W9sMuo02pXj9nEoiximR4gSKrNoVesqNZMcVA0Kku01uOuOBAOReN7KJQBt

O arquivo de malware executa vários comandos shell na máquina local, alguns deles periodicamente, para monitorar o estado do sistema. Por exemplo, ele executa free -m para verificar a disponibilidade de RAM, uptime, journalctl -S @ 0 -u sshd para monitorar logins SSH e outros comandos que geramestatísticas de uso de CPU. Essas estatísticas estão disponíveis para serem consumidas por outros nós da rede e são usadas para determinar, por exemplo, se um criptominer deve ser executado ou não.

O malware executa um processo separado – denominado libexec – para extrair a moeda Monero. O minerador é baseado no popular minerador XMRig e se conecta ao pool público web.xmrpool.eu pela porta 5555.

Uma rede semelhante a um torrent do mal

O Fritzfrog depende da capacidade de compartilhar arquivos pela rede, tanto para infectar novas máquinas quanto para executar cargas maliciosas, como o criptominer Monero.

Para compartilhar e trocar arquivos entre nós, o Fritzfrog usa uma abordagem furtiva e sem arquivos. Os arquivos são divididos em blobs – volumes de dados binários – que são mantidos na memória. O malware rastreia os blobs disponíveis, armazenando-os em um mapa junto com o valor de hash de cada blob.

Quando um nó A deseja receber um arquivo de seu par, o nó B, ele pode consultar o nó B sobre quais blobs ele possui usando o comando getblobstats . Então, o nó A pode obter um blob específico por seu hash, seja pelo comando P2P getbin ou por HTTP, com a URL http: //: 1234 / . Quando o nó A tem todos os blobs necessários – ele monta o arquivo usando um módulo especial denominado Assemble e o executa.

Atribuição

Rastrear os operadores de um botnet P2P é uma tarefa complicada; devido à sua natureza distribuída, os comandos podem ser enviados de e para qualquer nó da rede. Ainda assim, tentamos compará-lo com botnets P2P anteriores vistos no cenário de ameaças.

Mesmo quando comparado com botnets P2P anteriores, o FritzFrog parece único; ele não usa IRC como o IRCflu , ele opera na memória ao contrário do DDG e é executado em máquinas baseadas em Unix – ao contrário do botnet InterPlanetary Storm . Se houver, tem alguma semelhança – especialmente com relação à nomenclatura de funções e números de versão – com Rakos , um botnet P2P escrito em Golang e analisado pela ESET em 2016.

Detecção e Mitigação

Guardicore Labs fornece um script de detecção FritzFrog para ser executado em servidores SSH. Ele procura os seguintes indicadores FritzFrog:

  • Execução de processos nginx, ifconfig ou libexec cujo arquivo executável não existe mais no sistema de arquivos (como visto abaixo)
  • Porta de escuta 1234

Além disso, o tráfego TCP na porta 5555 pode indicar o tráfego de rede para o pool Monero.

ubuntu@ip-111-11-11-11:~$ ./detect_fritzfrog.sh
FritzFrog Detection Script by Guardicore Labs
=============================================
 
[*] Fileless process nginx is running on the server.
[*] Listening on port 1234
[*] There is evidence of FritzFrog's malicious activity on this machine.

FritzFrog aproveita o fato de que muitas soluções de segurança de rede impõem tráfego apenas pela porta e protocolo. Para superar essa técnica furtiva, as regras de segmentação baseadas em processos podem impedir facilmente essas ameaças.

Senhas fracas são o facilitador imediato dos ataques de FritzFrog. Recomendamos escolher senhas fortes e usar autenticação de chave pública, que é muito mais seguro. Além disso, é crucial remover a chave pública do FritzFrog do arquivo authorized_keys , evitando que os invasores acessem a máquina. Roteadores e dispositivos IoT frequentemente expõem SSH e, portanto, são vulneráveis ​​ao FritzFrog; considere alterar sua porta SSH ou desabilitar completamente o acesso SSH a eles se o serviço não estiver em uso.

FONTE: GUARDICORE

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *