À propos de ce projet

Ce projet a été développé dans le cadre du cours Digitale Forensik à la Technische Hochschule Deggendorf.

Il illustre une enquête médico-légale complète et une simulation d'attaque impliquant :

• Une attaque par confusion de dépendances Python utilisant un paquet PyPI malveillant

• Une escalade de privilèges via une version vulnérable de sudo (CVE-2025-32463)

• Le déploiement d'un beacon Sliver C2

• Un rootkit personnalisé avec chargement de module noyau, hooking d'appels système et persistance basée sur udev

• L'analyse complète des artefacts mémoire et réseau à l'aide d'outils comme Volatility, NetworkMiner et du reverse engineering manuel

Le dépôt contient des scripts, des instructions de configuration, des artefacts et des étapes d'analyse détaillées pour reproduire à la fois l'attaque et l'investigation médico-légale.

TOC

• Privilege Escalation
• Exploit Chain
• Artifact Generation
  • Create Memory Dump
  • Prepare Network Dump on Ubuntu
• Setup Developer Ubuntu Client (shell)
  • 1. Clone the repository and execute
  • 2. Once the VM is up, SSH in
  • 3. Install the vulnerable sudo and Python venv
  • 4. Build the userland loader binary (shell)
  • 5. Send the shell to the Kali to later serve it from there.
• Setup Kali (192.168.56.101)
  • 1. Start Sliver server
  • 2. Generate a HTTP Beacon
  • 3. Rename and serve beacon
  • 4. Start listener
• Simulate Developer
  • 1. Clone the PoC
  • 2. Create and activate a Python venv
  • 3. Install dependencies
  • 4. Run the malicious package
• Simulate the Attacker
  • 1. Wait for the Beacon and inspect the sudo version
  • 2. Upload exploit and loader
  • 3. Execute Sudo Exploit
  • 4. Load kernel module
  • 5. Setting up a udev rule
  • 6. Reboot
  • 7. Catch shell on reboot
• Analysis
  • Overview of Collected Artefacts
  • Quick Network Overview with NetworkMiner
  • Detailed Traffic Analysis
    • GitHub Download
    • PyPI Download
    • Malicious “lilux” Binary Retrieval
  • Post‑Download Behavior
    • Sliver Beaconing
    • Unencrypted Reverse Shell
  • Summary
    • Key Findings
    • Forensic Implications
• Memory Analysis
  • Environment and Setup
  • Memory Dump Acquisition
  • Install Debug Symbols
  • Generate the Volatility Symbol File
  • Run Volatility with Symbols
  • (Optional) Faster Searching with fzf
  • Finding Interesting Files
  • Loaded Modules
  • Udev Rule
  • Extracting the shell
• Reversing of shell binary
  • load_module Branch
  • rsh Branch
    • daemonize Function
    • Reverse Shell
  • Summary of Behavior
    • Behavioral Summary
• Reversing of Kernel Module
  • Python script to extract Kernel Module
    • 1. Create Range
    • 2. Compare the target address
    • 3. Continue until a match is found
  • rkit_init
  • Hooked Functions
    • Kill Hook
    • Getdents(64) Hook
  • Module Hiding
  • Debug Messages
  • Reverse Shell Loader
  • rkit_exit
• Checksums
• Tools and Versions Used

Escalade de Privilèges

CVE-2025-32463
Détails NVD
PoC Github

[!NOTE]
Vous devez installer une version vulnérable de sudo (avec support chroot—voir privesc/setup.sh)

Chaîne d'Exploitation```mermaid

sequenceDiagram autonumber participant Attacker participant PyPI participant IntDep as Internal Dep Server participant Dev as Developer participant C2 as C2 Server

Attacker->>PyPI: Publish package with version v1.0.3
Dev->>IntDep: pip install
IntDep-->>Dev: Returns v1.0.1
Dev->>PyPI: Fallback pip install package==v1.0.3
PyPI-->>Dev: Returns malicious v1.0.3 (stager)
Dev->>Dev: Executes stager (package_evil)
Dev->>C2: Beacon/Sliver implant calls home
Note right of C2: Attacker now has RCE

Attacker->>Dev: Enumerates sudo version (1.9.16p2)
Attacker->>Dev: Runs CVE-2025-32463 exploit
Note right of Dev: PE to root

Dev->>Dev: Downloads & runs rootkit loader binary
Dev->>Dev: Loader installs kernel module & configures udev rule
Dev->>Dev: Schedules reboot
Note right of Dev: Attacker established persistence 

Dev->>Dev: System reboots
Dev->>Dev: Udev loads kernel module on boot
Dev->>C2: Kernel-stage beacon calls C2

# Génération d'artefacts

Tous les artefacts sont générés manuellement. Vous utiliserez deux machines :
- **Machine attaquante** (Kali Linux)
- **Machine développeur** (Ubuntu)

Nous produirons trois artefacts :
- **PCAP** (avant redémarrage)
- **Dump mémoire** (après redémarrage)

## Créer un dump mémoire
[Comment dumper la mémoire VirtualBox](https://www.ired.team/miscellaneous-reversing-forensics/dump-virtual-box-memory)

Sur le système hôte :```shell
vboxmanage list vms
"linux-root-kit_default_1752261916398_20346" {c2d4b5bc-d87f-4dcb-af01-85b78c163fef}
virtualboxvm --startvm "linux-root-kit_default_1752261916398_20346" --dbg

Aller à l'interface --> Debug Dans la console de débogage (VMMR0> prompt):```shell .pgmphystofile 'dumpmem_linux_root_kit'

## Préparer le dump réseau sur Ubuntu
Commencez avant de simuler le développeur. Le `! port 22` est utile pour ne pas journaliser la connexion ssh vagrant.```shell
sudo tcpdump -w output.pcap ! port 22

Configuration du client Ubuntu Développeur (shell)

1. Clonez le dépôt et exécutez : ```shell

vagrant up

Cela peut prendre un certain temps --> télécharge une VM entière construite avec Bento.

## 2. Une fois la VM démarrée, connectez-vous en SSH :  ```shell
vagrant ssh

3. Installer le sudo vulnérable et Python venv : ```shell

sudo bash /vagrant/privesc/setup.sh sudo apt install python3.12-venv

## 4. Construire le binaire du loader en espace utilisateur (shell) :