Quasar Linux (QLNX): Uma Cabeça de Ponte na Cadeia de Suprimentos com Total Capacidade RAT

Resumo

Quasar Linux (QLNX) é um trojan avançado de acesso remoto para Linux que combina um rootkit em espaço de usuário e eBPF com um backdoor PAM e amplas capacidades de coleta de credenciais. O malware suporta execução sem arquivo, mascaramento de nome de processo e várias técnicas de persistência que ajudam a mantê-lo oculto em sistemas infectados. Seu foco em estações de trabalho de desenvolvedores o torna especialmente perigoso para o abuso na cadeia de suprimentos, pois pode roubar tokens, chaves SSH e credenciais de nuvem. O malware também usa comunicações criptografadas e suporta uma arquitetura de malha peer-to-peer para melhorar a resiliência e manter o acesso.

Investigação

Pesquisadores da Trend Micro obtiveram o binário QLNX e conduziram análises estática e dinâmica, revelando código-fonte incorporado para os componentes do rootkit e backdoor PAM. Sua investigação documentou a capacidade do malware de compilar componentes diretamente no host alvo, a gama de mecanismos de persistência que usa, e o conjunto completo de comandos suportados pelo implante. A análise de rede também revelou um protocolo personalizado baseado em TLS e um identificador mágico distinto usado nas comunicações. A partir deste trabalho, os pesquisadores extraíram indicadores de compromisso para apoiar a caça e detecção.

Mitigação

Os defensores devem procurar o QLNX monitorando seu arquivo de bloqueio de mutex exclusivo, entradas LD_PRELOAD suspeitas e comandos de gcc compilação incomuns que geram objetos compartilhados maliciosos. As organizações também devem bloquear a execução de binários desconhecidos nomeados quasar-implant e restringir o acesso de escrita a /etc/ld.so.preload. A autenticação multifator deve ser aplicada para contas de desenvolvedores, e as equipes de segurança devem monitorar de perto as tentativas de exfiltrar armazenamentos de credenciais e arquivos de token sensíveis.

Resposta

Se forem encontrados indicadores de QLNX, isole o sistema afetado imediatamente, colete imagens de memória e disco, e termine o processo malicioso. Remova as entradas não autorizadas de /etc/ld.so.preload, delete os .so arquivos maliciosos compilados e limpe o arquivo de bloqueio usado pelo implante. Todas as credenciais potencialmente expostas, especialmente tokens de nuvem e de registro de pacotes, devem ser rotacionadas sem demora. Os investigadores também devem avaliar se algum sistema de cadeia de suprimentos, repositórios, ou ambientes de construção foram contaminados durante a intrusão.

## Execução de Simulação

Pré-requisito: O Check de Pré-voo de Telemetria & Baseline deve ter sido aprovado.

Racional: Esta seção detalha a execução precisa da técnica do adversário (TTP) projetada para acionar a regra de detecção. Os comandos e a narrativa DEVEM refletir diretamente os TTPs identificados e têm como objetivo gerar a telemetria exata esperada pela lógica de detecção.

• Narrativa & Comandos de Ataque:

  1. Estágio 1 – Geração de Carga Útil: O atacante escreve uma carga útil C mínima que chama memfd_create para criar um arquivo executável anônimo em memória, escreve um shellcode simples (por exemplo, execve("/bin/sh", …)), marca como executável e depois lança via execveat.
  2. Estágio 2 – Compilação Em Tempo Real: Usando gcc (o indicador visível na regra) o atacante compila a fonte sem tocar no disco (saída direcionada para /dev/fd/3).
  3. Estágio 3 – Execução & Injeção: O binário compilado executa, invoca memfd_create, carrega o shellcode e finalmente chama execveat para executar o ELF residente em memória. Opcional ptrace pode ser usado para injetar código em um processo irmão, o que também satisfaria a regra.

• Script de Teste de Regressão:

  #!/usr/bin/env bash
  #
  # Simulação de execução sem arquivo semelhante ao QLNX
  # Gera ELF em memória via memfd_create e executa com execveat.
  # Requer: gcc, libcap2-bin (para demonstração de execveat), e regras auditd do pré-voo.
  
  set -euo pipefail
  
  # 1️⃣ Cria a fonte C que realiza a dança memfd + execveat
  cat > /tmp/payload.c <<'EOF'
  #define _GNU_SOURCE
  #include <sys/mman.h>
  #include <sys/syscall.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <string.h>
  
  int main(void) {
      // Cria um descritor de arquivo anônimo (memfd)
      int fd = syscall(SYS_memfd_create, "memfd_payload", MFD_CLOEXEC);
      if (fd == -1) _exit(1);
  
      // Simples binário ELF que apenas executa execve /bin/sh
      const unsigned char elf[] = {
          0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
          // ... (truncado para brevidade – um ELF mínimo estático para /bin/sh)
      };
      write(fd, elf, sizeof(elf));
      // Torne-o executável
      fchmod(fd, 0755);
  
      // Use execveat para executar o binário em memória
      syscall(SYS_execveat, fd, "", NULL, NULL, AT_EMPTY_PATH);
      _exit(0);
  }
  EOF
  
  # 2️⃣ Compila com gcc (isto será capturado pela regra de detecção)
  gcc -static -o /tmp/payload /tmp/payload.c
  
  # 3️⃣ Executa o binário malicioso – isto aciona execveat
  /tmp/payload
  
  # 4️⃣ Limpeza
  rm -f /tmp/payload /tmp/payload.c

• Comandos de Limpeza:

  # Remove arquivos residuais e descarrega possíveis regras de auditoria (se o ambiente de teste for descartável)
  rm -f /tmp/payload /tmp/payload.c
  sudo auditctl -d -a always,exit -F arch=b64 -S execveat -k qlnx_execveat
  sudo auditctl -d -a always,exit -F arch=b64 -S memfd_create -k qlnx_memfd
  sudo auditctl -d -a always,exit -F arch=b64 -S ptrace -k qlnx_ptrace