Comment pouvez-vous prévenir les vulnérabilités d'injection SQL dans votre code Python?

L'utilisation de requêtes paramétrées est la méthode de base pour empêcher l'injection SQL dans Python, et il est nécessaire d'éviter l'épissage direct de l'entrée utilisateur. 1. Utilisez toujours les requêtes paramétrées prises en charge par les pilotes de base de données, telles que les mécanismes d'espace réservé dans SQLite3, PSYCOPG2 et MySQL-Connector-Python; 2. Il est interdit de construire des instructions SQL via l'épissage ou le formatage des chaînes (tels que F-string, .format ()); 3. La priorité est donnée à l'utilisation de bibliothèques ORM telles que Sqlalchemy ou Django ORM, qui utilisent les requêtes paramétrées par défaut; 4. Vérification et filtrage des entrées utilisateur comme défenses supplémentaires, y compris le type, la longueur et la vérification de la liste blanche; 5. Lorsque vous traitez des noms de table ou des noms de colonne dynamiques, le mécanisme de liste blanche doit être utilisé pour s'assurer que seuls les identificateurs prédéfinis sont autorisés. Tant que vous insistez toujours sur les requêtes paramétrées et évitez d'intégrer directement l'entrée des utilisateurs dans les chaînes SQL, vous pouvez éliminer efficacement les vulnérabilités d'injection SQL.

La prévention des vulnérabilités d'injection SQL à Python se résume à un principe de base: ne faites jamais confiance à la saisie des utilisateurs lors de la création de requêtes SQL . Le moyen le plus efficace de protéger votre application consiste à éviter la concaténation ou le formatage des chaînes pour inclure les données utilisateur directement dans les instructions SQL. Voici comment faire les choses correctement.

Utiliser des requêtes paramétrées (instructions préparées)

La défense la meilleure et la plus fiable est d'utiliser des requêtes paramétrées avec des espaces réservés. Cela garantit que la saisie de l'utilisateur est traitée strictement sous forme de données, et non de code exécutable.

La plupart des bibliothèques de base de données Python prennent en charge les requêtes paramétrées. Par exemple, avec sqlite3 :

 importer sqlite3

Conn = sqlite3.Connect ("Example.DB")
cursor = conn.cursor ()

# ✅ SAFE: Utilisation de la requête paramétrée
username = input ("Entrez le nom d'utilisateur:")
cursor.execute ("SELECT * FROM Users Where Username =?", (nom d'utilisateur,))

# ❌ Dangereux: ne faites pas ça
# cursor.execute (f "SELECT * FROM Users Where Username = '{username}'")

Avec psycopg2 (PostgreSQL):

 importer psycopg2

cursor.execute ("Sélectionner * parmi les utilisateurs où e-mail =% s", (e-mail,))

Avec MySQL utilisant mysql-connector-python :

 cursor.execute ("Sélectionner * parmi les utilisateurs où e-mail =% s", (e-mail,))

Utilisez toujours le paramétrage intégré du pilote de base de données - pas le formatage de chaîne Python comme .format() , F-strings ou % .

Évitez le bâtiment de requête dynamique avec entrée utilisateur

Ne créez jamais de requêtes SQL en concaténant les chaînes qui incluent des données fournies par l'utilisateur.

 # ❌ Vulnérable à l'injection
query = "select * chez les utilisateurs où username = '" nom d'utilisateur "'"
cursor.execute (requête)

Même si vous essayez de désinfecter les entrées vous-même, vous manquerez probablement les cas Edge. Laissez le pilote de base de données le gérer via des paramètres.

Utilisez les bibliothèques ORM lorsque cela est possible

Les mappeurs d'objet-relation (ORMS) comme Sqlalchemy ou Django ORM utilisent automatiquement les requêtes paramétrées sous le capot, ce qui rend beaucoup plus difficile d'introduire l'injection SQL.

Exemple avec Sqlalchemy:

 De Sqlalchemy.Orm Import Sessionmaker
Session = Sessionmaker (bind = moteur)
session = session ()

# ✅ en toute sécurité
user = session.query (user) .filter (user.userName == nom d'utilisateur) .First ()

Exemple avec Django:

 User.objects.filter (username = request.get ['username'])

Ces frameworks abstgent SQL brut et appliquent des pratiques sûres par défaut.

Valider et désinfecter les contributions (défense en profondeur)

Bien que les requêtes paramétrées soient la principale ligne de défense, vous devez toujours valider les types d'entrée, les longueurs, les formats et les valeurs acceptables dans la mesure du possible.

Par exemple:

• Assurez-vous qu'un ID est numérique.
• Limiter les longueurs de chaîne.
• Utilisez des listes d'autoroute pour des choses comme les directions de tri ( ASC / DESC ) ou les noms de table / colonne s'ils doivent être dynamiques.

Mais n'oubliez pas: la validation d'entrée seule ne peut pas arrêter l'injection SQL - c'est un supplément, pas un remplacement du paramétrage.

Gérer attentivement la table ou les colonnes dynamiques

Parfois, vous devez inclure dynamiquement des noms de table ou de colonnes (qui ne peuvent pas être paramétrés). Dans de tels cas:

• Utilisez une liste d'autorisation d'identifiants autorisés.
• Ne pas transmettre directement l'entrée de l'utilisateur brut.

 autorisé_columns = {'name', 'e-mail', 'créé_at'}
Si la colonne n'est pas dans ALLERD_Columns:
    augmenter ValueError ("Nom de la colonne non valide")

query = f "SELECT * FROM Users Order par {colonne}"
cursor.execute (requête)

De cette façon, seules des valeurs pré-approuvées sont utilisées.

Fondamentalement, respectez les requêtes paramétrées pour toutes les données variables, utilisez ORMS lorsque vous le pouvez, et jamais intégrée par utilisateur directement dans les chaînes SQL. Ce n'est pas complexe - tout simplement cohérent.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!