Bandit Security Linting: Identificering og Afhjælpning af Python Sikkerhedssårbarheder

I dagens komplekse cybersikkerhedslandskab er proaktive sikkerhedsforanstaltninger altafgørende. Python, kendt for sin alsidighed og brugervenlighed, er et populært valg til forskellige applikationer. Ligesom ethvert programmeringssprog kan Python-kode dog være modtagelig for sikkerhedssårbarheder. Det er her, Bandit kommer ind – et kraftfuldt sikkerheds-lintingværktøj designet til automatisk at identificere potentielle sikkerhedsfejl i din Python-kode.

Hvad er Bandit?

Bandit er en open source sikkerheds-linter specielt designet til Python. Den fungerer ved at scanne Python-kode for almindelige sikkerhedsproblemer ved hjælp af et omfattende sæt plugins til at identificere potentielle sårbarheder. Tænk på det som et statisk analyseværktøj, der hjælper dig med at fange sikkerhedsproblemer tidligt i udviklingscyklussen, før de kan udnyttes i produktion.

Bandit fungerer ved at parse Python-kode og bygge et Abstract Syntax Tree (AST). Den anvender derefter en række tests, baseret på kendte sårbarhedsmønstre, på AST'en. Når et potentielt sikkerhedsproblem er fundet, rapporterer Bandit det med et alvorsniveau, et konfidensniveau og en detaljeret beskrivelse af problemet.

Hvorfor bruge Bandit?

Integration af Bandit i din udviklings-workflow giver flere markante fordele:

• Tidlig sårbarhedsdetektion: Bandit hjælper dig med at identificere sikkerhedssårbarheder tidligt i udviklingsprocessen, hvilket reducerer omkostningerne og indsatsen, der kræves for at rette dem senere.
• Forbedret kodningskvalitet: Ved at håndhæve sikker kodningspraksis bidrager Bandit til den samlede kodningskvalitet og vedligeholdelse.
• Automatiserede sikkerhedsrevisioner: Bandit automatiserer processen med sikkerhedsrevision, hvilket gør det lettere at sikre, at din kode overholder sikkerhedsbest practices.
• OWASP Top 10 dækning: Bandit inkluderer tests, der adresserer mange af sårbarhederne, der er anført i OWASP Top 10, hvilket hjælper dig med at beskytte dig mod almindelige webapplikationssikkerhedsrisici.
• Tilpasningsdygtige regler: Du kan tilpasse Bandits regler for at passe til dine specifikke sikkerhedskrav og kodningsstandarder.
• Integration med CI/CD-pipelines: Bandit kan nemt integreres i dine Continuous Integration/Continuous Deployment (CI/CD) pipelines, hvilket sikrer, at sikkerhedstjek udføres automatisk ved hver kodeændring.

Kom godt i gang med Bandit

Her er en trin-for-trin guide til at komme i gang med Bandit:

1. Installation

Du kan installere Bandit ved hjælp af pip, Python-pakkeinstallationsprogrammet:

            pip install bandit
            

              
                Copy
              
            
          

2. Kørsel af Bandit

For at køre Bandit på din Python-kode, skal du bruge følgende kommando:

            bandit -r 
            

              
                Copy
              
            
          

Erstat <directory> med den mappe, der indeholder din Python-kode. -r flaget fortæller Bandit at scanne rekursivt alle Python-filer i den specificerede mappe.

Du kan også specificere individuelle filer:

            bandit  
            

              
                Copy
              
            
          

3. Fortolkning af resultaterne

Bandit vil outputte en rapport, der detaljerer eventuelle potentielle sikkerhedssårbarheder fundet i din kode. Hver sårbarhed tildeles et alvorsniveau (f.eks. HØJT, MIDT, LAVT) og et konfidensniveau (f.eks. HØJT, MIDT, LAVT). Rapporten inkluderer også en detaljeret beskrivelse af sårbarheden og linjen i koden, hvor den blev fundet.

Eksempel på Bandit Output:

            ./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
              
            
          

Dette output indikerer, at Bandit fandt en høj-alvors sårbarhed i filen example.py på linje 10. Sårbarheden er relateret til brugen af subprocess.Popen med shell=True, som er kendt for at være modtagelig for shell injection-angreb.

Almindelige sikkerhedssårbarheder detekteret af Bandit

Bandit kan detektere en bred vifte af almindelige sikkerhedssårbarheder i Python-kode. Her er et par eksempler:

• Shell Injection (B602, B603): Brug af subprocess.Popen eller os.system med upålidelig input kan føre til shell injection-angreb.
• SQL Injection (B608): Konstruktion af SQL-forespørgsler ved hjælp af strengkonkatenering med brugerleveret data kan udsætte din applikation for SQL injection-angreb.
• Hardkodede adgangskoder (B105): Opbevaring af adgangskoder direkte i din kode er en stor sikkerhedsrisiko.
• Svag kryptografi (B303, B304, B322): Brug af svage eller forældede kryptografiske algoritmer kan kompromittere fortroligheden og integriteten af dine data.
• Usikker deserialisering (B301, B401): Deserialisering af data fra upålidelige kilder kan føre til vilkårlig kodeudførelse.
• XML External Entity (XXE) Injection (B405): Parsning af XML-dokumenter fra upålidelige kilder uden korrekt sanering kan udsætte din applikation for XXE injection-angreb.
• Format String Sårbarheder (B323): Brug af brugerleveret data i format strenge uden korrekt sanering kan føre til format string-sårbarheder.
• Brug af `eval()` eller `exec()` (B301): Disse funktioner udfører vilkårlig kode, og brugen af dem med upålidelig input er ekstremt farlig.
• Usikker brug af midlertidige filer (B308): Oprettelse af midlertidige filer på en forudsigelig placering kan give angribere mulighed for at overskrive eller læse følsomme data.
• Manglende eller forkert fejlhåndtering (B110): Forkert håndtering af undtagelser kan udsætte følsomme oplysninger eller føre til denial-of-service-angreb.

Eksempel: Identificering og rettelse af en Shell Injection Sårbarhed

Lad os se på et simpelt eksempel på, hvordan Bandit kan hjælpe dig med at identificere og rette en shell injection-sårbarhed.

Overvej følgende Python-kode:

            import subprocess
import os

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

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

Denne kode tager brugerinput og udfører det som en shell-kommando ved hjælp af subprocess.Popen med shell=True. Dette er et klassisk eksempel på en shell injection-sårbarhed.

Kørsel af Bandit på denne kode vil producere følgende output:

            ./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 identificerer korrekt brugen af subprocess.Popen med shell=True som en sårbarhed med høj alvorlighed.

For at rette denne sårbarhed bør du undlade at bruge shell=True og i stedet sende kommandoen og dens argumenter som en liste til subprocess.Popen. Du bør også sanere brugerinput for at forhindre, at ondsindede kommandoer injiceres.

Her er en rettet version af koden:

            import subprocess
import shlex

def execute_command(command):
    # Sanitize the input using shlex.split to prevent shell injection
    command_list = shlex.split(command)
    subprocess.Popen(command_list)

if __name__ == "__main__":
    user_input = input("Enter a command to execute: ")
    execute_command(user_input)

            

              
                Copy
              
            
          

Ved at bruge shlex.split til at sanere brugerinput og sende kommandoen som en liste til subprocess.Popen kan du afhjælpe risikoen for shell injection-angreb.

Kørsel af Bandit på den rettede kode vil ikke længere rapportere shell injection-sårbarheden.

Konfigurering af Bandit

Bandit kan konfigureres ved hjælp af en konfigurationsfil (bandit.yaml eller .bandit) for at tilpasse dens funktionalitet. Du kan bruge konfigurationsfilen til at:

• Ekskludere filer eller mapper: Angiv filer eller mapper, der skal ekskluderes fra scanningen.
• Deaktivere specifikke tests: Deaktiver tests, der ikke er relevante for dit projekt.
• Justere alvorsniveauer: Ændre alvorsniveauerne for specifikke sårbarheder.
• Definere brugerdefinerede regler: Opret dine egne brugerdefinerede regler til at detektere projektspecifikke sikkerhedsproblemer.

Her er et eksempel på en bandit.yaml konfigurationsfil:

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

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

Denne konfigurationsfil ekskluderer mapperne tests/ og docs/ fra scanningen, skipper B101 testen (der kontrollerer brugen af assert statements), justerer konfidensniveauet for B603 testen til MIDT og justerer alvorsniveauet for B105 testen til LAV.

Integration af Bandit i din CI/CD Pipeline

Integration af Bandit i din CI/CD pipeline er et afgørende skridt for at sikre sikkerheden af din Python-kode. Ved at køre Bandit automatisk ved hver kodeændring kan du fange sikkerhedssårbarheder tidligt og forhindre dem i at nå produktionen.

Her er et eksempel på, hvordan du integrerer Bandit i en GitLab CI/CD pipeline:

            stages:
  - test

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

            

              
                Copy
              
            
          

Denne konfiguration definerer en bandit job, der kører Bandit på den aktuelle mappe. Jobbet bruger et Python 3.9 Docker-image og installerer Bandit ved hjælp af pip. bandit -r . kommandoen kører Bandit rekursivt på alle Python-filer i den aktuelle mappe. artifacts sektionen specificerer, at Bandit-rapporten skal gemmes som en artefakt, der kan downloades og gennemgås.

Lignende konfigurationer kan oprettes til andre CI/CD-platforme, såsom Jenkins, CircleCI og GitHub Actions.

Ud over Bandit: Omfattende sikkerhedsstrategier

Mens Bandit er et værdifuldt værktøj til at identificere potentielle sikkerhedssårbarheder, er det vigtigt at huske, at det kun er et led i en omfattende sikkerhedsstrategi. Andre vigtige sikkerhedspraksisser inkluderer:

• Sikker kodningspraksis: Følg retningslinjer og best practices for sikker kodning for at minimere risikoen for at introducere sårbarheder i din kode.
• Regelmæssige sikkerhedsrevisioner: Udfør regelmæssige sikkerhedsrevisioner for at identificere og adressere potentielle sikkerhedssvagheder i din applikation.
• Penetrationstest: Udfør penetrationstest for at simulere virkelige angreb og identificere sårbarheder, der muligvis ikke opdages af statiske analyseværktøjer som Bandit.
• Sårbarhedsstyring: Implementer et sårbarhedsstyringsprogram til at spore og afhjælpe sårbarheder i din software og infrastruktur.
• Afhængighedsstyring: Hold dine afhængigheder opdaterede for at patche kendte sårbarheder i tredjepartsbiblioteker. Værktøjer som `pip-audit` og `safety` kan hjælpe med dette.
• Inputvalidering og -sanering: Valider og saner altid brugerinput for at forhindre injection-angreb og andre input-relaterede sårbarheder.
• Autentifikation og autorisation: Implementer stærke autentifikations- og autorisationsmekanismer for at beskytte følsomme data og ressourcer.
• Sikkerhedsbevidsthedstræning: Tilbyd træning i sikkerhedsbevidsthed til dine udviklere og andre medarbejdere for at uddanne dem om almindelige sikkerhedstrusler og best practices.

Konklusion

Bandit er et værdifuldt værktøj til at identificere og afhjælpe sikkerhedssårbarheder i Python-kode. Ved at integrere Bandit i din udviklings-workflow kan du forbedre sikkerheden af dine applikationer og beskytte dig mod almindelige sikkerhedstrusler. Det er dog vigtigt at huske, at Bandit kun er et led i en omfattende sikkerhedsstrategi. Ved at følge sikker kodningspraksis, udføre regelmæssige sikkerhedsrevisioner og implementere andre sikkerhedsforanstaltninger kan du skabe et mere sikkert og robust softwaremiljø.

Ressourcer

• Bandit Dokumentation
• OWASP (Open Web Application Security Project)
• Bandit på PyPI