Français
Français
Dans le développement Web, l'injection SQL est une méthode d'attaque courante. Les attaquants manipulent la base de données en insérant du code malveillant dans des instructions de requête SQL, puis en volant, modifiez, supprimez des données et même obtenez des autorisations système. Afin d'éviter l'injection de SQL, les développeurs PHP doivent prendre des mesures efficaces pour protéger la sécurité de la base de données. Cet article présentera comment effectuer des requêtes sécurisées via la fonction Real_Query pour éviter le risque d'injection SQL.
L'injection SQL est une vulnérabilité de sécurité qui se produit lorsque les développeurs ne gèrent pas correctement l'entrée utilisateur. L'attaquant tamponne la logique des instructions de requête de la base de données en entrant du code SQL spécialement fabriqué pour réaliser des opérations illégales. Les méthodes d'attaque courantes comprennent:
Afficher les données sensibles dans la base de données
Supprimer ou modifier les données
Contourner l'authentification
Vérifiez et nettoyez toujours les entrées des utilisateurs : toutes les données saisies par les utilisateurs peuvent contenir du contenu malveillant, et les développeurs doivent filtrer ou échapper à l'entrée pour garantir que ces données ne peuvent pas interférer avec les requêtes SQL.
Utiliser les instructions de prétraitement et la liaison des paramètres : les instructions de prétraitement peuvent séparer les instructions SQL de l'entrée de l'utilisateur, ce qui peut éviter une entrée malveillante affectant directement la structure des instructions SQL.
Restreindre les autorisations utilisateur de la base de données : les comptes de base de données ne doivent avoir que des autorisations pour effectuer les opérations nécessaires pour éviter d'accorder trop d'autorisations aux comptes de base de données.
En utilisant les journaux de requête SQL : en enregistrant et en analysant les journaux de requête SQL, les développeurs peuvent découvrir et bloquer un comportement malveillant potentiel.
Real_Query est une fonction fournie par l'extension MySQLI dans PHP, utilisée pour exécuter des requêtes SQL. Lorsque vous devez exécuter la requête SQL d'origine, vous pouvez utiliser Real_Query , mais il peut également devenir une vulnérabilité dans l'injection SQL si l'entrée utilisateur n'est pas traitée correctement. Par conséquent, vous devez être très prudent lorsque vous utilisez Real_Query .
<?php
$conn = new mysqli("localhost", "username", "password", "database");
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
$sql = "SELECT * FROM users WHERE username = '".$_GET['username']."'";
if ($conn->real_query($sql)) {
$result = $conn->use_result();
while ($row = $result->fetch_assoc()) {
echo "Username: " . $row['username'];
}
}
?>
Dans le code ci-dessus, l'instruction SQL Query utilise directement la saisie de l'utilisateur de $ _get ['username'] . Si l'utilisateur entre dans un code SQL malveillant, comme 'ou 1 = 1 - , cela entraînera des attaques d'injection SQL. Par conséquent, avant l'exécution de Real_Query , la saisie de l'utilisateur doit être traitée.
L'un des moyens les plus efficaces d'empêcher l'injection de SQL consiste à utiliser des instructions préparées . Grâce à des instructions de prétraitement, les instructions SQL et les données sont séparées, et le moteur de base de données traitera les données comme des valeurs normales sans l'analyser en code SQL. Cela peut être facilement réalisé en utilisant l'extension MySQLI de PHP.
<?php
$conn = new mysqli("localhost", "username", "password", "database");
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
$stmt = $conn->prepare("SELECT * FROM users WHERE username = ?");
$stmt->bind_param("s", $_GET['username']);
if ($stmt->execute()) {
$result = $stmt->get_result();
while ($row = $result->fetch_assoc()) {
echo "Username: " . $row['username'];
}
}
?>
Dans cet exemple, la fonction de préparation compile d'abord la requête SQL et la fonction bind_param lie l'entrée utilisateur aux paramètres de la requête ( ? ). De cette façon, les données entrées par l'utilisateur seront traitées en texte brut, en évitant les attaques d'injection SQL.
Si vous avez besoin d'utiliser Real_Query , vous devez faire attention d'échapper manuellement l'entrée des utilisateurs pour vous assurer que l'entrée ne contient pas de code malveillant. MySQLI fournit la fonction Real_escape_string pour échapper aux caractères spéciaux dans une chaîne.
<?php
$conn = new mysqli("localhost", "username", "password", "database");
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
$username = $conn->real_escape_string($_GET['username']);
$sql = "SELECT * FROM users WHERE username = '$username'";
if ($conn->real_query($sql)) {
$result = $conn->use_result();
while ($row = $result->fetch_assoc()) {
echo "Username: " . $row['username'];
}
}
?>
Avec Real_escape_String , nous pouvons échapper aux caractères spéciaux dans l'entrée de l'utilisateur pour éviter que le code SQL malvestre soit exécuté. Bien que cette approche puisse réduire le risque d'injection de SQL, elle ne peut pas être complètement évitée, il est donc recommandé d'utiliser d'abord les déclarations de prétraitement.
En plus d'utiliser des déclarations Real_Query et de prétraitement, il existe des mesures de sécurité supplémentaires qui peuvent aider à réduire le risque d'injection SQL:
Utilisation de PDO (PHP Data Objets) : PDO prend également en charge les instructions de prétraitement et est plus flexible que MySQLI , adapté à une variété de bases de données.
Minimiser les autorisations de base de données : assurez-vous que les utilisateurs de la base de données disposent uniquement d'autorisations pour effectuer les opérations nécessaires, limiter l'accès à la base de données et réduire la capacité de sabotage potentielle des attaquants.
Mises à jour et correctifs en temps opportun : vérifiez et mettez régulièrement les environnements PHP, MySQL et Server pour vous assurer que toutes les vulnérabilités de sécurité sont fixes.
Activer le pare-feu d'application Web (WAF) : WAF peut détecter et intercepter les attaques telles que l'injection SQL, et est un obstacle important au système de protection.
L'injection SQL est l'une des attaques Web les plus courantes, et les développeurs PHP doivent prendre des mesures efficaces pour assurer la sécurité de la base de données. En utilisant correctement les instructions Real_Query et Prétraitement, le risque d'injection SQL peut être effectivement empêché. En outre, les développeurs devraient également combiner d'autres mesures de sécurité telles que la vérification des entrées, la gestion des autorisations de base de données et les mises à jour des correctifs de sécurité pour améliorer la sécurité globale du système.
Étiquettes associées:
SQL
