Bandit Security Linting : Identification et atténuation des vulnérabilités de sécurité Python

Dans le paysage complexe de la cybersécurité d'aujourd'hui, les mesures de sécurité proactives sont primordiales. Python, connu pour sa polyvalence et sa facilité d'utilisation, est un choix populaire pour diverses applications. Cependant, comme tout langage de programmation, le code Python peut être sensible aux vulnérabilités de sécurité. C'est là qu'intervient Bandit – un puissant outil de linting de sécurité conçu pour identifier automatiquement les failles de sécurité potentielles dans votre code Python.

Qu'est-ce que Bandit ?

Bandit est un linter de sécurité open source spécialement conçu pour Python. Il fonctionne en analysant le code Python pour les problèmes de sécurité courants, en utilisant un ensemble complet de plugins pour identifier les vulnérabilités potentielles. Considérez-le comme un outil d'analyse statique qui vous aide à détecter les problèmes de sécurité dès le début du cycle de vie du développement, avant qu'ils ne puissent être exploités en production.

Bandit fonctionne en analysant le code Python et en construisant un arbre syntaxique abstrait (AST). Il applique ensuite une série de tests, basés sur des schémas de vulnérabilité connus, à l'AST. Lorsqu'un problème de sécurité potentiel est détecté, Bandit le signale avec un niveau de gravité, un niveau de confiance et une description détaillée du problème.

Pourquoi utiliser Bandit ?

L'intégration de Bandit dans votre flux de travail de développement offre plusieurs avantages significatifs :

• Détection précoce des vulnérabilités : Bandit vous aide à identifier les vulnérabilités de sécurité dès le début du processus de développement, réduisant ainsi le coût et l'effort nécessaires pour les corriger ultérieurement.
• Amélioration de la qualité du code : En appliquant des pratiques de codage sécurisées, Bandit contribue à la qualité et à la maintenabilité globales du code.
• Audits de sécurité automatisés : Bandit automatise le processus d'audit de sécurité, ce qui facilite la garantie que votre code adhère aux meilleures pratiques de sécurité.
• Couverture OWASP Top 10 : Bandit comprend des tests qui traitent bon nombre des vulnérabilités répertoriées dans l'OWASP Top 10, vous aidant ainsi à vous protéger contre les risques de sécurité courants des applications web.
• Règles personnalisables : Vous pouvez personnaliser les règles de Bandit pour qu'elles correspondent à vos exigences de sécurité et à vos normes de codage spécifiques.
• Intégration aux pipelines CI/CD : Bandit peut être facilement intégré à vos pipelines d'intégration continue/déploiement continu (CI/CD), garantissant que les contrôles de sécurité sont effectués automatiquement à chaque modification du code.

Premiers pas avec Bandit

Voici un guide étape par étape pour commencer avec Bandit :

1. Installation

Vous pouvez installer Bandit en utilisant pip, l'installateur de paquets Python :

            pip install bandit
            

              
                Copy
              
            
          

2. Exécution de Bandit

Pour exécuter Bandit sur votre code Python, utilisez la commande suivante :

            bandit -r 
            

              
                Copy
              
            
          

Remplacez <directory> par le répertoire contenant votre code Python. L'indicateur -r indique à Bandit d'analyser de manière récursive tous les fichiers Python du répertoire spécifié.

Vous pouvez également spécifier des fichiers individuels :

            bandit  
            

              
                Copy
              
            
          

3. Interprétation des résultats

Bandit affichera un rapport détaillant les éventuelles vulnérabilités de sécurité trouvées dans votre code. Chaque vulnérabilité se voit attribuer un niveau de gravité (par exemple, HIGH, MEDIUM, LOW) et un niveau de confiance (par exemple, HIGH, MEDIUM, LOW). Le rapport comprend également une description détaillée de la vulnérabilité et de la ligne de code où elle a été trouvée.

Exemple de sortie Bandit :

            ./example.py:10:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:10
--------------------------------------------------

            

              
                Copy
              
            
          

Cette sortie indique que Bandit a trouvé une vulnérabilité de haute gravité dans le fichier example.py à la ligne 10. La vulnérabilité est liée à l'utilisation de subprocess.Popen avec shell=True, qui est connue pour être susceptible aux attaques par injection de shell.

Vulnérabilités de sécurité courantes détectées par Bandit

Bandit peut détecter un large éventail de vulnérabilités de sécurité courantes dans le code Python. Voici quelques exemples :

• Injection de shell (B602, B603) : L'utilisation de subprocess.Popen ou os.system avec des entrées non fiables peut conduire à des attaques par injection de shell.
• Injection SQL (B608) : La construction de requêtes SQL à l'aide de la concaténation de chaînes avec des données fournies par l'utilisateur peut exposer votre application aux attaques par injection SQL.
• Mots de passe codés en dur (B105) : Le stockage des mots de passe directement dans votre code constitue un risque de sécurité majeur.
• Cryptographie faible (B303, B304, B322) : L'utilisation d'algorithmes cryptographiques faibles ou obsolètes peut compromettre la confidentialité et l'intégrité de vos données.
• Désérialisation non sécurisée (B301, B401) : La désérialisation de données provenant de sources non fiables peut entraîner l'exécution de code arbitraire.
• Injection d'entité externe XML (XXE) (B405) : L'analyse de documents XML provenant de sources non fiables sans une désinfection appropriée peut exposer votre application aux attaques par injection XXE.
• Vulnérabilités de chaîne de format (B323) : L'utilisation de données fournies par l'utilisateur dans des chaînes de format sans une désinfection appropriée peut entraîner des vulnérabilités de chaîne de format.
• Utilisation de `eval()` ou `exec()` (B301) : Ces fonctions exécutent du code arbitraire, et les utiliser avec des entrées non fiables est extrêmement dangereux.
• Utilisation non sécurisée de fichiers temporaires (B308) : La création de fichiers temporaires dans un emplacement prévisible peut permettre aux attaquants d'écraser ou de lire des données sensibles.
• Gestion des erreurs manquante ou incorrecte (B110) : Ne pas gérer correctement les exceptions peut révéler des informations sensibles ou entraîner des attaques par déni de service.

Exemple : Identification et correction d'une vulnérabilité d'injection de shell

Examinons un exemple simple de la façon dont Bandit peut vous aider à identifier et à corriger une vulnérabilité d'injection de shell.

Considérez le code Python suivant :

            import subprocess
import os

def execute_command(command):
    subprocess.Popen(command, shell=True)

if __name__ == "__main__":
    user_input = input("Entrez une commande à exécuter : ")
    execute_command(user_input)

            

              
                Copy
              
            
          

Ce code prend une entrée utilisateur et l'exécute en tant que commande shell à l'aide de subprocess.Popen avec shell=True. Il s'agit d'un exemple classique d'une vulnérabilité d'injection de shell.

L'exécution de Bandit sur ce code produira la sortie suivante :

            ./example.py:4:0:B603  [blacklist] Use of subprocess.Popen with shell=True is known to be vulnerable to shell injection
	Severity: High   Confidence: High
	Location: ./example.py:4
--------------------------------------------------

            

              
                Copy
              
            
          

Bandit identifie correctement l'utilisation de subprocess.Popen avec shell=True comme une vulnérabilité de haute gravité.

Pour corriger cette vulnérabilité, vous devez éviter d'utiliser shell=True et, à la place, transmettre la commande et ses arguments sous forme de liste à subprocess.Popen. Vous devez également assainir l'entrée de l'utilisateur pour empêcher l'injection de commandes malveillantes.

Voici une version corrigée du code :

            import subprocess
import shlex

def execute_command(command):
    # Assainir l'entrée en utilisant shlex.split pour empêcher l'injection de shell
    command_list = shlex.split(command)
    subprocess.Popen(command_list)

if __name__ == "__main__":
    user_input = input("Entrez une commande à exécuter : ")
    execute_command(user_input)

            

              
                Copy
              
            
          

En utilisant shlex.split pour assainir l'entrée utilisateur et en transmettant la commande sous forme de liste à subprocess.Popen, vous pouvez atténuer le risque d'attaques par injection de shell.

L'exécution de Bandit sur le code corrigé ne signalera plus la vulnérabilité d'injection de shell.

Configuration de Bandit

Bandit peut être configuré à l'aide d'un fichier de configuration (bandit.yaml ou .bandit) pour personnaliser son comportement. Vous pouvez utiliser le fichier de configuration pour :

• Exclure des fichiers ou des répertoires : Spécifiez les fichiers ou les répertoires qui doivent être exclus de l'analyse.
• Désactiver des tests spécifiques : Désactivez les tests qui ne sont pas pertinents pour votre projet.
• Ajuster les niveaux de gravité : Modifiez les niveaux de gravité de vulnérabilités spécifiques.
• Définir des règles personnalisées : Créez vos propres règles personnalisées pour détecter les problèmes de sécurité spécifiques à votre projet.

Voici un exemple de fichier de configuration bandit.yaml :

            exclude:
  - 'tests/'
  - 'docs/'

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

Ce fichier de configuration exclut les répertoires tests/ et docs/ de l'analyse, ignore le test B101 (qui vérifie l'utilisation des instructions assert), ajuste le niveau de confiance du test B603 à MEDIUM et ajuste le niveau de gravité du test B105 à LOW.

Intégration de Bandit dans votre pipeline CI/CD

L'intégration de Bandit dans votre pipeline CI/CD est une étape cruciale pour garantir la sécurité de votre code Python. En exécutant Bandit automatiquement à chaque modification de code, vous pouvez détecter les vulnérabilités de sécurité dès le début et les empêcher d'atteindre la production.

Voici un exemple de la façon d'intégrer Bandit dans un pipeline GitLab CI/CD :

            stages:
  - test

bandit:
  image: python:3.9
  stage: test
  before_script:
    - pip install bandit
  script:
    - bandit -r .
  artifacts:
    reports:
      bandit: bandit.report

            

              
                Copy
              
            
          

Cette configuration définit un travail bandit qui exécute Bandit sur le répertoire actuel. Le travail utilise une image Docker Python 3.9 et installe Bandit à l'aide de pip. La commande bandit -r . exécute Bandit de manière récursive sur tous les fichiers Python du répertoire courant. La section artifacts spécifie que le rapport Bandit doit être enregistré en tant qu'artefact, qui peut être téléchargé et examiné.

Des configurations similaires peuvent être créées pour d'autres plateformes CI/CD, telles que Jenkins, CircleCI et GitHub Actions.

Au-delà de Bandit : Stratégies de sécurité complètes

Bien que Bandit soit un outil précieux pour identifier les vulnérabilités de sécurité potentielles, il est important de se rappeler qu'il ne s'agit que d'un élément d'une stratégie de sécurité complète. Les autres pratiques de sécurité importantes incluent :

• Pratiques de codage sécurisées : Suivez les directives de codage sécurisé et les meilleures pratiques pour minimiser le risque d'introduction de vulnérabilités dans votre code.
• Audits de sécurité réguliers : Effectuez des audits de sécurité réguliers pour identifier et traiter les faiblesses de sécurité potentielles de votre application.
• Tests de pénétration : Effectuez des tests de pénétration pour simuler des attaques réelles et identifier les vulnérabilités qui peuvent ne pas être détectées par des outils d'analyse statique comme Bandit.
• Gestion des vulnérabilités : Mettez en œuvre un programme de gestion des vulnérabilités pour suivre et corriger les vulnérabilités de vos logiciels et de votre infrastructure.
• Gestion des dépendances : Maintenez vos dépendances à jour pour corriger les vulnérabilités connues dans les bibliothèques tierces. Des outils comme `pip-audit` et `safety` peuvent vous y aider.
• Validation et assainissement des entrées : Validez et assainissez toujours les entrées utilisateur pour éviter les attaques par injection et autres vulnérabilités liées aux entrées.
• Authentification et autorisation : Mettez en œuvre des mécanismes d'authentification et d'autorisation robustes pour protéger les données et les ressources sensibles.
• Formation à la sensibilisation à la sécurité : Fournissez une formation à la sensibilisation à la sécurité à vos développeurs et autres employés pour les informer des menaces de sécurité courantes et des meilleures pratiques.

Conclusion

Bandit est un outil précieux pour identifier et atténuer les vulnérabilités de sécurité dans le code Python. En intégrant Bandit dans votre flux de travail de développement, vous pouvez améliorer la sécurité de vos applications et vous protéger contre les menaces de sécurité courantes. Cependant, il est important de se rappeler que Bandit n'est qu'un élément d'une stratégie de sécurité complète. En suivant les pratiques de codage sécurisé, en effectuant des audits de sécurité réguliers et en mettant en œuvre d'autres mesures de sécurité, vous pouvez créer un environnement logiciel plus sûr et plus résilient.

Ressources

• Documentation de Bandit
• OWASP (Open Web Application Security Project)
• Bandit sur PyPI