Bandit Security Linting: Identifiera och Mildra Säkerhetsproblem i Python

I dagens komplexa cybersäkerhetslandskap är proaktiva säkerhetsåtgärder av största vikt. Python, känt för sin mångsidighet och användarvänlighet, är ett populärt val för olika applikationer. Men precis som alla programmeringsspråk kan Python-kod vara mottaglig för säkerhetsproblem. Det är här Bandit kommer in – ett kraftfullt verktyg för säkerhetslinting som är utformat för att automatiskt identifiera potentiella säkerhetsbrister i din Python-kod.

Vad är Bandit?

Bandit är en open-source säkerhetslinter som är speciellt utformad för Python. Den fungerar genom att skanna Python-kod efter vanliga säkerhetsproblem, med hjälp av en omfattande uppsättning plugins för att identifiera potentiella sårbarheter. Tänk på det som ett statiskt analysverktyg som hjälper dig att fånga säkerhetsproblem tidigt i utvecklingslivscykeln, innan de kan utnyttjas i produktion.

Bandit fungerar genom att parsa Python-kod och bygga ett abstrakt syntax-träd (AST). Den tillämpar sedan en serie tester, baserade på kända sårbarhetsmönster, på AST. När ett potentiellt säkerhetsproblem hittas rapporterar Bandit det med en allvarlighetsgrad, konfidensnivå och en detaljerad beskrivning av problemet.

Varför använda Bandit?

Att integrera Bandit i ditt utvecklingsarbetsflöde erbjuder flera betydande fördelar:

• Tidig sårbarhetsdetektering: Bandit hjälper dig att identifiera säkerhetsproblem tidigt i utvecklingsprocessen, vilket minskar kostnaden och ansträngningen som krävs för att åtgärda dem senare.
• Förbättrad kodkvalitet: Genom att upprätthålla säker kodningspraxis bidrar Bandit till övergripande kodkvalitet och underhållbarhet.
• Automatiserade säkerhetsgranskningar: Bandit automatiserar processen för säkerhetsgranskning, vilket gör det lättare att säkerställa att din kod följer bästa säkerhetspraxis.
• OWASP Top 10-täckning: Bandit inkluderar tester som adresserar många av de sårbarheter som listas i OWASP Top 10, vilket hjälper dig att skydda dig mot vanliga säkerhetsrisker för webbapplikationer.
• Anpassningsbara regler: Du kan anpassa Bandits regler för att passa dina specifika säkerhetskrav och kodningsstandarder.
• Integration med CI/CD-pipelines: Bandit kan enkelt integreras i dina Continuous Integration/Continuous Deployment (CI/CD)-pipelines, vilket säkerställer att säkerhetskontroller utförs automatiskt vid varje kodändring.

Komma igång med Bandit

Här är en steg-för-steg-guide för att komma igång med Bandit:

1. Installation

Du kan installera Bandit med pip, Python-pakethanteraren:

            pip install bandit
            

              
                Copy
              
            
          

2. Köra Bandit

För att köra Bandit på din Python-kod, använd följande kommando:

            bandit -r <directory>
            

              
                Copy
              
            
          

Ersätt <directory> med katalogen som innehåller din Python-kod. Flaggan -r talar om för Bandit att rekursivt skanna alla Python-filer i den angivna katalogen.

Du kan också ange enskilda filer:

            bandit <file1.py> <file2.py>
            

              
                Copy
              
            
          

3. Tolka resultaten

Bandit kommer att mata ut en rapport som beskriver alla potentiella säkerhetsproblem som hittas i din kod. Varje sårbarhet tilldelas en allvarlighetsgrad (t.ex. HÖG, MEDEL, LÅG) och en konfidensnivå (t.ex. HÖG, MEDEL, LÅG). Rapporten innehåller också en detaljerad beskrivning av sårbarheten och den kodrad där den hittades.

Exempel på Bandit-utdata:

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

Denna utdata indikerar att Bandit hittade en sårbarhet med hög allvarlighetsgrad i filen example.py på rad 10. Sårbarheten är relaterad till användningen av subprocess.Popen med shell=True, vilket är känt för att vara mottagligt för shell-injektionsattacker.

Vanliga säkerhetsproblem som upptäcks av Bandit

Bandit kan upptäcka ett brett spektrum av vanliga säkerhetsproblem i Python-kod. Här är några exempel:

• Shell Injection (B602, B603): Att använda subprocess.Popen eller os.system med otillförlitlig indata kan leda till shell-injektionsattacker.
• SQL Injection (B608): Att konstruera SQL-frågor med hjälp av strängkonkatenering med användarlevererade data kan utsätta din applikation för SQL-injektionsattacker.
• Hårdkodade lösenord (B105): Att lagra lösenord direkt i din kod är en stor säkerhetsrisk.
• Svag kryptografi (B303, B304, B322): Att använda svaga eller föråldrade kryptografiska algoritmer kan kompromettera konfidentialiteten och integriteten hos dina data.
• Osäker deserialisering (B301, B401): Att deserialisera data från otillförlitliga källor kan leda till godtycklig kodkörning.
• XML External Entity (XXE) Injection (B405): Att parsa XML-dokument från otillförlitliga källor utan korrekt sanering kan utsätta din applikation för XXE-injektionsattacker.
• Format String Vulnerabilities (B323): Att använda användarlevererade data i formatsträngar utan korrekt sanering kan leda till formatsträngssårbarheter.
• Använda `eval()` eller `exec()` (B301): Dessa funktioner kör godtycklig kod, och att använda dem med otillförlitlig indata är extremt farligt.
• Osäker användning av temporära filer (B308): Att skapa temporära filer på en förutsägbar plats kan tillåta angripare att skriva över eller läsa känsliga data.
• Saknas eller felaktig felhantering (B110): Att inte hantera undantag korrekt kan exponera känslig information eller leda till denial-of-service-attacker.

Exempel: Identifiera och åtgärda en Shell Injection-sårbarhet

Låt oss titta på ett enkelt exempel på hur Bandit kan hjälpa dig att identifiera och åtgärda en shell injection-sårbarhet.

Tänk på följande Python-kod:

            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
              
            
          

Denna kod tar användarindata och kör den som ett shell-kommando med subprocess.Popen med shell=True. Detta är ett klassiskt exempel på en shell injection-sårbarhet.

Att köra Bandit på denna kod kommer att producera följande utdata:

            ./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 identifierar korrekt användningen av subprocess.Popen med shell=True som en sårbarhet med hög allvarlighetsgrad.

För att åtgärda denna sårbarhet bör du undvika att använda shell=True och istället skicka kommandot och dess argument som en lista till subprocess.Popen. Du bör också sanera användarindata för att förhindra att skadliga kommandon injiceras.

Här är en korrigerad version av 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
              
            
          

Genom att använda shlex.split för att sanera användarindata och skicka kommandot som en lista till subprocess.Popen kan du mildra risken för shell injection-attacker.

Att köra Bandit på den korrigerade koden kommer inte längre att rapportera shell injection-sårbarheten.

Konfigurera Bandit

Bandit kan konfigureras med hjälp av en konfigurationsfil (bandit.yaml eller .bandit) för att anpassa dess beteende. Du kan använda konfigurationsfilen för att:

• Exkludera filer eller kataloger: Ange filer eller kataloger som ska exkluderas från skanningen.
• Inaktivera specifika tester: Inaktivera tester som inte är relevanta för ditt projekt.
• Justera allvarlighetsgrader: Ändra allvarlighetsgraderna för specifika sårbarheter.
• Definiera anpassade regler: Skapa dina egna anpassade regler för att upptäcka projektspecifika säkerhetsproblem.

Här är ett exempel på en bandit.yaml konfigurationsfil:

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

skips:
  - 'B101'

confidence_level:
  MEDIUM:
    - 'B603'

severity_level:
  LOW:
    - 'B105'

            

              
                Copy
              
            
          

Denna konfigurationsfil exkluderar katalogerna tests/ och docs/ från skanningen, hoppar över testet B101 (som kontrollerar användningen av assert-satser), justerar konfidensnivån för testet B603 till MEDIUM och justerar allvarlighetsgraden för testet B105 till LOW.

Integrera Bandit i din CI/CD-pipeline

Att integrera Bandit i din CI/CD-pipeline är ett avgörande steg för att säkerställa säkerheten för din Python-kod. Genom att köra Bandit automatiskt vid varje kodändring kan du fånga säkerhetsproblem tidigt och förhindra att de når produktion.

Här är ett exempel på hur du integrerar 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
              
            
          

Denna konfiguration definierar ett bandit-jobb som kör Bandit på den aktuella katalogen. Jobbet använder en Python 3.9 Docker-image och installerar Bandit med pip. Kommandot bandit -r . kör Bandit rekursivt på alla Python-filer i den aktuella katalogen. Avsnittet artifacts anger att Bandit-rapporten ska sparas som en artefakt, som kan laddas ner och granskas.

Liknande konfigurationer kan skapas för andra CI/CD-plattformar, som Jenkins, CircleCI och GitHub Actions.

Bortom Bandit: Omfattande säkerhetsstrategier

Även om Bandit är ett värdefullt verktyg för att identifiera potentiella säkerhetsproblem, är det viktigt att komma ihåg att det bara är en del av en omfattande säkerhetsstrategi. Andra viktiga säkerhetsrutiner inkluderar:

• Säker kodningspraxis: Följ säkra kodningsriktlinjer och bästa praxis för att minimera risken för att introducera sårbarheter i din kod.
• Regelbundna säkerhetsgranskningar: Utför regelbundna säkerhetsgranskningar för att identifiera och åtgärda potentiella säkerhetssvagheter i din applikation.
• Penetreringstestning: Utför penetreringstestning för att simulera verkliga attacker och identifiera sårbarheter som kanske inte upptäcks av statiska analysverktyg som Bandit.
• Sårbarhetshantering: Implementera ett program för sårbarhetshantering för att spåra och åtgärda sårbarheter i din programvara och infrastruktur.
• Beroendehantering: Håll dina beroenden uppdaterade för att patcha kända sårbarheter i tredjepartsbibliotek. Verktyg som `pip-audit` och `safety` kan hjälpa till med detta.
• Inputvalidering och sanering: Validera och sanera alltid användarindata för att förhindra injektionsattacker och andra inputrelaterade sårbarheter.
• Autentisering och auktorisering: Implementera starka autentiserings- och auktoriseringsmekanismer för att skydda känsliga data och resurser.
• Säkerhetsmedvetenhetsträning: Ge säkerhetsmedvetenhetsträning till dina utvecklare och andra anställda för att utbilda dem om vanliga säkerhetshot och bästa praxis.

Slutsats

Bandit är ett värdefullt verktyg för att identifiera och mildra säkerhetsproblem i Python-kod. Genom att integrera Bandit i ditt utvecklingsarbetsflöde kan du förbättra säkerheten för dina applikationer och skydda dig mot vanliga säkerhetshot. Det är dock viktigt att komma ihåg att Bandit bara är en del av en omfattande säkerhetsstrategi. Genom att följa säker kodningspraxis, genomföra regelbundna säkerhetsgranskningar och implementera andra säkerhetsåtgärder kan du skapa en säkrare och mer resilient programvarumiljö.

Resurser

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