Quasar Linux (QLNX) : Une porte d’entrée dans la chaîne d’approvisionnement avec toutes les capacités d’un RAT

Résumé

Quasar Linux (QLNX) est un trojan d’accès à distance Linux avancé qui combine un rootkit en espace utilisateur et eBPF avec une porte dérobée PAM et de larges capacités de collecte d’identifiants. Le malware prend en charge l’exécution sans fichier, la dissimulation de nom de processus, et plusieurs techniques de persistance qui l’aident à rester caché sur les systèmes infectés. Son focus sur les postes de travail des développeurs le rend particulièrement dangereux pour les abus de la chaîne d’approvisionnement, car il peut voler des jetons, des clés SSH et des identifiants cloud. Le malware utilise également des communications chiffrées et supporte une architecture en maillage peer-to-peer pour améliorer la résilience et maintenir l’accès.

Enquête

Les chercheurs de Trend Micro ont obtenu le binaire QLNX et ont mené des analyses statiques et dynamiques, dévoilant le code source intégré pour les composants rootkit et porte dérobée PAM. Leur enquête a documenté la capacité du malware à compiler des composants directement sur l’hôte cible, la gamme de mécanismes de persistance qu’il utilise, et l’ensemble complet de commandes pris en charge par l’implant. L’analyse réseau a également révélé un protocole personnalisé basé sur TLS et un identifiant magique distinctif utilisé dans les communications. À partir de ce travail, les chercheurs ont extrait des indicateurs de compromission pour soutenir la chasse et la détection.

Atténuation

Les défenseurs devraient rechercher QLNX en surveillant son fichier de verrouillage mutex unique, des entrées LD_PRELOAD suspectes et des commandes de gcc compilation inhabituelles qui génèrent des objets partagés malveillants. Les organisations devraient également bloquer l’exécution de binaires inconnus nommés quasar-implant et restreindre l’accès en écriture à /etc/ld.so.preload. L’authentification multi-facteurs doit être appliquée pour les comptes développeurs, et les équipes de sécurité doivent surveiller de près toute tentative d’exfiltration de magasins d’identifiants et de fichiers de jetons sensibles.

Réponse

Si des indicateurs de QLNX sont trouvés, isolez immédiatement le système affecté, collectez les images mémoire et disque, et terminez le processus malveillant. Supprimez les entrées non autorisées de /etc/ld.so.preload, effacez les fichiers malveillants compilés et nettoyez le fichier de verrouillage utilisé par l’implant. Tous les identifiants potentiellement exposés, en particulier les jetons cloud et de registre de package, doivent être remplacés sans délai. Les enquêteurs devraient également évaluer si des systèmes, dépôts ou environnements de construction de la chaîne d’approvisionnement ont été contaminés pendant l’intrusion. .so files, and clear the lock file used by the implant. All potentially exposed credentials, especially cloud and package registry tokens, should be rotated without delay. Investigators should also assess whether any supply-chain systems, repositories, or build environments were contaminated during the intrusion.

## Exécution de la simulation

Prérequis : Le pré-contrôle de télémétrie et de base doit avoir réussi.

Justification : Cette section détaille l’exécution précise de la technique de l’adversaire (TTP) conçue pour déclencher la règle de détection. Les commandes et le récit DOIVENT refléter directement les TTPs identifiés et viser à générer la télémétrie attendue par la logique de détection.

• Narratif de l’attaque et commandes :

  1. Étape 1 – Génération de charge utile : L’attaquant écrit une charge utile C minimale qui appelle memfd_create pour créer un fichier exécutable anonyme en mémoire, écrit un shellcode simple (par exemple, execve("/bin/sh", …)), le marque exécutable, puis le lance via execveat.
  2. Étape 2 – Compilation à la volée : Utilisation de gcc (l’indicateur visible dans la règle) l’attaquant compile la source sans toucher le disque (sortie dirigée vers /dev/fd/3).
  3. Étape 3 – Exécution et injection : Le binaire compilé s’exécute, invoque memfd_create, charge le shellcode, et appelle finalement execveat pour exécuter l’ELF résident en mémoire. Optionnel ptrace peut être utilisé pour injecter du code dans un processus frère, ce qui satisferait également la règle.

• Script de test de régression :

  #!/usr/bin/env bash
  #
  # Simulation d'exécution sans fichier à la QLNX
  # Génère un ELF en mémoire via memfd_create et l'exécute avec execveat.
  # Nécessite : gcc, libcap2-bin (pour la démonstration execveat), et des règles auditd du pré-vol.
  
  set -euo pipefail
  
  # 1️⃣ Créer une source C qui effectue la danse 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) {
      // Create an anonymous file descriptor (memfd)
      int fd = syscall(SYS_memfd_create, "memfd_payload", MFD_CLOEXEC);
      if (fd == -1) _exit(1);
  
      // Simple ELF binary that just execve /bin/sh
      const unsigned char elf[] = {
          0x7f,0x45,0x4c,0x46,0x02,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
          // ... (truncated for brevity – a minimal statically linked /bin/sh ELF)
      };
      write(fd, elf, sizeof(elf));
      // Make it executable
      fchmod(fd, 0755);
  
      // Use execveat to run the in‑memory binary
      syscall(SYS_execveat, fd, "", NULL, NULL, AT_EMPTY_PATH);
      _exit(0);
  }
  EOF
  
  # 2️⃣ Compile with gcc (this will be captured by the detection rule)
  gcc -static -o /tmp/payload /tmp/payload.c
  
  # 3️⃣ Execute the malicious binary – this triggers execveat
  /tmp/payload
  
  # 4️⃣ Cleanup
  rm -f /tmp/payload /tmp/payload.c

• Commandes de nettoyage :

  # Supprimez les fichiers résiduels et déchargez les règles d'audit potentielles (si l'environnement de test est jetable)
  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