Attaque de troncature SQL

La vulnérabilité de troncature SQL se produit lorsqu'une base de données tronque l'entrée utilisateur en raison d'une restriction sur la longueur. Les attaquants peuvent recueillir des informations sur la durée d'un champ critique (comme un nom d'utilisateur) et exploiter ces informations pour obtenir un accès non autorisé. Les attaquants peuvent se connecter comme un autre utilisateur, comme un administrateur, avec leur propre mot de passe enregistré.

La vulnérabilité de troncature SQL existe généralement dans les bases de données MySQL. Cette vulnérabilité a été décrite pour la première fois dans CVE-2008-4106, qui était liée à WordPress CMS.

Comment fonctionnent les attaques de troncature SQL

Cette attaque fonctionne en raison de la troncature de la saisie des utilisateurs dans les bases de données en utilisant les fonctions «sélection» et «insertion».

• Lorsque la saisie est donnée dans le champ de formulaire, la fonction «Sélectionner» vérifie la redondance correspondant aux entrées dans la base de données.
• Après avoir vérifié la redondance, la fonction «insertion» vérifie la longueur de l'entrée et l'entrée de l'utilisateur tronquera si la longueur dépasse.

Supposons qu'un développeur crée la table «Utilisateurs» via la requête suivante:

Créer des utilisateurs de table (
user_id int not null auto_increment,
user_name varchar (20) pas null,
mot de passe varchar (40) pas null,
Clé primaire (user_id)
));

En utilisant ce schéma, si le développeur crée un compte d'administration avec les suivants:

user_name = 'admin'
mot de passe = «Secret_P4SSW0ord»

De toute évidence, ces références ne sont pas publiques. Il n'y a qu'un seul compte d'administration dans la base de données, et si un attaquant essaie d'enregistrer un autre compte auprès du nom d'utilisateur «Admin», l'attaquant échouera en raison des chèques de redondance de la base de données. L'attaquant peut toujours contourner ce chèque de redondance pour ajouter un autre compte d'administration en exploitant la vulnérabilité de troncature SQL. Supposons que l'attaquant enregistre un autre compte avec l'entrée suivante:

User_name = 'adminxxxxxxxxxxxxxxxxrandom'
(x sont les espaces)
&
Mot de passe = ”randomUser”

La base de données prendra le 'user_name' (26 caractères) et vérifiera si cela existe déjà. Ensuite, l'entrée user_name sera tronquée et 'admin' ('admin' avec espace) sera entrée dans la base de données, ce qui entraîne deux utilisateurs d'administration en double.

L'attaquant est alors en mesure de créer un utilisateur «administrateur» avec son propre mot de passe. Maintenant, la base de données a deux entrées d'administration «user_name», mais avec des mots de passe différents. L'attaquant peut se connecter avec les informations d'identification nouvellement créées pour obtenir un panneau d'administration car les deux user_ames «admin» et «admin» sont égaux pour le niveau de base de données. Maintenant, nous allons examiner un échantillon d'attaque pratique.

Échantillon d'attaque

Dans cet exemple, nous prendrons un scénario du site Web Overthewire.org. La communauté Overthewire fournit des CTF de Wargame sur lesquels nous pouvons pratiquer nos concepts de sécurité. Le scénario de troncature SQL se produit dans le niveau de jeu Natas 26-> 27. Nous pouvons accéder au niveau en utilisant les éléments suivants:

URL: http: // natas27.natas.laboratoires.trop surtonner.org
Nom d'utilisateur: NATAS27
Mot de passe: 55Tbjppzuujgvp5b3bnbg6on9udpvzcj

Ce niveau est disponible sur: https: // overthewire.org / wargames / natas / natas27.html. On vous montrera une page de connexion vulnérable à une attaque de troncature SQL.

Lors de l'inspection du code source, vous verrez que la longueur du nom d'utilisateur est de 64, comme indiqué ci-dessous.

Un utilisateur nommé «NATAS28» existe déjà. Notre objectif est de créer un autre utilisateur nommé «NATAS28» en utilisant l'attaque SQL_TRUCcation. Nous allons donc saisir NATAS28, suivi de 57 espaces et d'un alphabet aléatoire (dans notre cas, a), de nom d'utilisateur et de tout mot de passe. La lettre «A» n'est pas visible dans la capture d'écran en raison du nom d'utilisateur de la longueur de 65 caractères. Après la création du compte utilisateur, vous pourrez voir le 'un.'

Si la base de données contient une vulnérabilité SQL_TRUNCation, alors la base de données doit maintenant avoir deux noms d'utilisateur «Natas28». Un nom d'utilisateur contiendra notre mot de passe. Essayons de saisir les informations d'identification sur la page de connexion.

Maintenant, nous sommes connectés en tant qu'utilisateur «NATAS28».

Atténuation

Pour atténuer cette attaque, nous devrons considérer plusieurs facteurs.

• Nous ne devons pas permettre la duplication d'identités critiques comme le nom d'utilisateur. Nous devons faire ces identités principales clés.
• La fonction tronquée doit être implémentée pour tous les champs des formulaires de frontend, ainsi que le code backend, afin que les bases de données reçoivent des entrées tronquées.
• Le mode strict doit être activé au niveau de la base de données. Sans mode strict activé, les bases de données ne donnent que des avertissements dans le backend, mais enregistrent toujours les données dupliquées. En mode strict, les bases de données donnent des erreurs en cas de duplication et éviter d'enregistrer des données.

Par exemple, vérifions le mode strict en utilisant la requête suivante:

mysql> sélectionner @@ sql_mode

Nous créerons une base de données et les utilisateurs de la table.'

MySQL> Créer un test de base de données
Requête ok, 1 rangée affectée (0.02 SEC)
MySQL> Utiliser le test
La base de données modifiée
MySQL> Créer des utilisateurs de table (nom d'utilisateur Varchar (10), mot de passe varchar (10));
Requête ok, 0 lignes affectées (0.05 SEC)

Ensuite, nous créerons un utilisateur d'administration avec des informations d'identification en utilisant la requête d'insertion.

mysql> insérer dans les valeurs des utilisateurs ('admin', 'password1');
Requête ok, 1 rangée affectée (0.01 SEC)

Nous pouvons voir les informations de la table «Utilisateurs» à l'aide de l'option «Sélectionner * parmi les utilisateurs».

La longueur du nom d'utilisateur est de 10 caractères. Maintenant, nous allons essayer l'attaque de troncature SQL.

Lorsque nous essayons de saisir ce qui suit:

Username = 'adminxxxxxa'
(x sont les espaces)
&
Mot de passe = 'pass2'

Nous obtiendrons une erreur, ce qui signifie que le mode strict est totalement efficace.

mysql> insérer dans les valeurs des utilisateurs ('admin a', 'pass2')
Erreur 1406 (22001): données trop longs pour la colonne «nom d'utilisateur» à la ligne 1

Sans mode strict activé, la base de données publiera des avertissements, mais insérera toujours les données dans le tableau.

Conclusion

Les attaquants peuvent avoir accès à des comptes de grande privile si la vulnérabilité SQL_TRUNCTION existe dans votre application. L'attaquant peut facilement obtenir des informations sur un nom d'utilisateur et sa longueur de base de données à l'aide des champs critiques, puis créer le même nom d'utilisateur, suivi des espaces et de l'alphabet aléatoire après la longueur minimale, entraînant la création de plusieurs comptes de grande privile. Cette vulnérabilité est essentielle, mais elle peut être évitée si vous prenez des précautions de sécurité, telles que l'activation du mode strict pour les entrées des utilisateurs et que le champ sensible est la clé principale de la base de données.