Bandit Python Sicherheit Linter Cheat Blatt

generieren

Überblick

Bandit ist ein Sicherheits-Linter entwickelt, um gemeinsame Sicherheitsprobleme in Python-Code zu finden. Es analysiert Python Quellcode und identifiziert mögliche Sicherheitslücken durch Scannen nach bekannten Mustern und Anti-Paternen. Bandit wird in DevSecOps-Pipelines weit verbreitet, um Sicherheitsfragen frühzeitig im Entwicklungsprozess zu erfassen, was es zu einem unverzichtbaren Werkzeug für eine sichere Python-Entwicklung macht.

ZEIT Anmerkung: Bandit ist für die Identifizierung potenzieller Sicherheitsprobleme konzipiert und sollte im Rahmen einer umfassenden Sicherheitsteststrategie eingesetzt werden. Es kann falsche Positive produzieren und sollte mit anderen Sicherheitstestmethoden kombiniert werden.

Installation

Verwendung von pip

# Install Bandit
pip install bandit

# Install with additional formatters
pip install bandit[toml]

# Install development version
pip install git+https://github.com/PyCQA/bandit.git

# Verify installation
bandit --version
```_

### Verwendung von conda
```bash
# Install from conda-forge
conda install -c conda-forge bandit

# Create dedicated environment
conda create -n security-tools bandit
conda activate security-tools
```_

### Verwenden von Paketmanagern
```bash
# Ubuntu/Debian
sudo apt update
sudo apt install bandit

# CentOS/RHEL/Fedora
sudo dnf install bandit
# or
sudo yum install bandit

# macOS with Homebrew
brew install bandit

# Arch Linux
sudo pacman -S bandit
```_

### Docker Installation
```bash
# Pull official Bandit image
docker pull securecodewarrior/bandit

# Run Bandit in container
docker run --rm -v $(pwd):/code securecodewarrior/bandit bandit -r /code

# Build custom image
cat > Dockerfile ``<< 'EOF'
FROM python:3.9-slim
RUN pip install bandit
WORKDIR /app
ENTRYPOINT ["bandit"]
EOF

docker build -t custom-bandit .
docker run --rm -v $(pwd):/app custom-bandit -r .
```_

## Basisnutzung

### Einfache Scans
```bash
# Scan a single file
bandit example.py

# Scan a directory recursively
bandit -r /path/to/project

# Scan current directory
bandit -r .

# Scan with verbose output
bandit -v -r .

# Scan specific files
bandit file1.py file2.py file3.py

# Scan with specific confidence level
bandit -r . -i  # Show only high confidence issues
bandit -r . -ii # Show medium and high confidence issues
bandit -r . -iii # Show all confidence levels
```_

### Ausgabeformate
```bash
# JSON output
bandit -r . -f json

# XML output
bandit -r . -f xml

# CSV output
bandit -r . -f csv

# HTML output
bandit -r . -f html

# YAML output
bandit -r . -f yaml

# Custom output
bandit -r . -f custom --msg-template "\\\{abspath\\\}:\\\{line\\\}: \\\{test_id\\\}[bandit]: \\\{severity\\\}: \\\{msg\\\}"

# Save output to file
bandit -r . -f json -o bandit-report.json
bandit -r . -f html -o bandit-report.html
```_

### Schwere und Vertrauensfilter
```bash
# Filter by severity (LOW, MEDIUM, HIGH)
bandit -r . -l  # Low severity and above
bandit -r . -ll # Medium severity and above
bandit -r . -lll # High severity only

# Filter by confidence (LOW, MEDIUM, HIGH)
bandit -r . -i  # High confidence only
bandit -r . -ii # Medium and high confidence
bandit -r . -iii # All confidence levels

# Combine severity and confidence
bandit -r . -ll -ii # Medium+ severity, Medium+ confidence
```_

## Konfiguration

### Konfigurationsdatei (.bandit)
```yaml
# .bandit configuration file
tests: ['B201', 'B301']
skips: ['B101', 'B601']

exclude_dirs: ['*/tests/*', '*/venv/*', '*/env/*']

# Severity levels: LOW, MEDIUM, HIGH
severity: MEDIUM

# Confidence levels: LOW, MEDIUM, HIGH
confidence: MEDIUM

# Output format
format: json

# Include line numbers
include_line_numbers: true

# Aggregate results
aggregate: vuln
```_

### pyproject.toml Konfiguration
```toml
[tool.bandit]
exclude_dirs = ["tests", "venv", ".venv", "env", ".env"]
tests = ["B201", "B301"]
skips = ["B101", "B601"]

[tool.bandit.assert_used]
skips = ['*_test.py', '*test_*.py']
```_

### Konfiguration der Befehlszeile
```bash
# Exclude directories
bandit -r . --exclude /tests/,/venv/,/.venv/

# Skip specific tests
bandit -r . --skip B101,B601

# Run specific tests only
bandit -r . --tests B201,B301

# Exclude files by pattern
bandit -r . --exclude "*/migrations/*,*/settings/*"

# Include only specific file patterns
bandit -r . --include "*.py"
```_

## Erweiterte Nutzung

### Benutzerdefinierte Testauswahl
```bash
# List all available tests
bandit -l

# Get detailed test information
bandit --help-tests

# Run specific vulnerability tests
bandit -r . --tests B101  # assert_used
bandit -r . --tests B102  # exec_used
bandit -r . --tests B103  # set_bad_file_permissions
bandit -r . --tests B104  # hardcoded_bind_all_interfaces
bandit -r . --tests B105  # hardcoded_password_string

# Skip specific tests
bandit -r . --skip B101,B102,B103

# Test categories
bandit -r . --tests B1*   # All B1xx tests
bandit -r . --tests B2*   # All B2xx tests
bandit -r . --tests B3*   # All B3xx tests
```_

### Baseline und Progressive Scanning
```bash
# Create baseline
bandit -r . -f json -o baseline.json

# Compare against baseline
bandit -r . -f json|bandit-baseline -b baseline.json

# Progressive scanning (only new issues)
bandit -r . --baseline baseline.json

# Update baseline
bandit -r . -f json -o new-baseline.json
```_

### Integration mit Git
```bash
# Pre-commit hook script
#!/bin/bash
# .git/hooks/pre-commit
bandit -r . -ll -ii
if [ $? -ne 0 ]; then
    echo "Bandit found security issues. Commit aborted."
    exit 1
fi

# Make executable
chmod +x .git/hooks/pre-commit

# Git hook with specific files
#!/bin/bash
# Check only modified Python files
git diff --cached --name-only --diff-filter=ACM|grep '\.py

## CI/CD Integration

### GitHub Actions
```yaml
# .github/workflows/security.yml
Name: Security Scan

auf: [Push, pull_request]

Arbeitsplätze:
Bandit:
run-on: ubuntu-latest
Schritte:
    - Verwendung: Aktionen/Checkout@v3

    - Name: Python einrichten
Verwendung: Aktionen/Setup-python@v4
mit:
python-version: 3,9

    - Name: Bandit installieren
run: pip install bandit[toml]

    - Name: Run Bandit
run: bandit -r . -f json -o bandit-report.json

    - Name: Ergebnisse hochladen
Verwendung: Aktionen/upload-artifact@v3
mit:
Name: Bandit-Report
Pfad: bandit-report.json

    - Name: Bandit Report
Verwendung: tj-actions/bandit@v5.1
mit:
Optionen: "-r . -f json"
Ausfahrt_zero: wahr

GitLab CI

# .gitlab-ci.yml
Stufen:
  - Sicherheit

Bandit:
Bühne: Sicherheit
Bild: python:3.9
vor_script:
    - pip install bandit[toml]
Script:
    - bandit -r . -f json -o bandit-report.json
Artefakte:
Berichte:
sast: bandit-report.json
Pfade:
      - Bandit-Report.json
abgelaufen_in: 1 Woche
let_failure: true

Jenkins Pipeline

// Jenkinsfile
Rohrleitung \\ {\cHFFFF}
Agenten

Phasen \\ {\cHFFFF}
Stage('Security Scan') \\ {\cHFFFF}
Schritte \\{
Skript \\{
sh 'pip install bandit[toml] '
sch 'bandit -r . -f json -o bandit-report.json '
~
~
Posten \\ {\cHFFFF}
immer \\ {\cHFFFF}
archivArtefakte artifacts: 'bandit-report.json', fingerprint: true
veröffentlichenHTML([
Genehmigung Vermisst: falsch,
immerLinkToLastBuild: wahr,
keepAll: wahr,
Bericht Dir: '.',
reportFiles: 'bandit-report.html',
reportName: 'Bandit Security Report '
)
~
~
~
~
~

Azure DevOps

# azure-pipelines.yml
Trigger:
- Haupt

Pool:
vmImage: 'ubuntu-latest '

Schritte:
- Aufgaben: UsePythonVersion@0
Eingaben:
Version Art: '3.9'

- Script:
pip install bandit[toml]
bandit -r . -f json -o $(Agent.TempDirectory)/bandit-report.json
displayName: 'Run Bandit Security Scan '

- Aufgaben: PublishTestResults@2
Eingaben:
testResultsFiles: '$(Agent.TempDirectory)/bandit-report.json '
Prüfverfahren RunTitle: 'Bandit Security Scan '

Common Vulnerability Patterns

Hardcoded Passwords (B105, B106, B107)

# BAD: Hardcoded Passwort
Passwort = "secret123"
api_key = "abc123def456"

# GOOD: Umweltvariablen
Einfuhr
Passwort = os.environ.get('PASSWORD')
api_key = os.environ.get('API_KEY')

# GOOD: Konfigurationsdatei
Import configparser
config = configparser.ConfigParser()
config.read('config.ini')
Passwort = config.get('database', 'password')

SQL Injection (B608)

# BAD: Streichformatierung
Anfrage = "SELECT * FROM Benutzer WHERE id = %" % user_id
Anfrage = f"SELECT * VON Benutzern, die id = \\{user_id\}"

# GOOD: Parameterierte Abfragen
cursor.execute("SELECT * VON Benutzern WHERE id = %s", (user_id,))
cursor.execute("SELECT * VON Benutzern, die id = ?", (user_id,))

Command Injection (B602, B605, B606, B607)

# BAD: Shell Injektion
Einfuhr
os.system(f"ls \\{user_input\}")
os.popen(f)grep \\{pattern\} \\{filename\}")

# GOOD: Subprozess mit Liste
Importsubprozess
subprocess.run(['ls', user_input])
subprocess.run(['grep', pattern, filename])

Insecure Random (B311)

# BAD: Vorhersehbar zufällig
Import zufällig
token = random.randint(1000, 9999)

# GOOD: Cryptographisch sicher
Importgeheimnisse
token = secrets.randbelow(9999)
secure_token = secrets.token_hex(16)

Unsafe YAML Loading (B506)

# BAD: Unsichere YAML-Ladung
Importieren von Yaml
Daten = yaml.load(user_input)

# GOOD: Sichere YAML-Ladung
Daten = yaml.safe_load(user_input)
Daten = yaml.load(user_input, Loader=yaml.SafeLoader)

Custom Rules and Plugins

Creating Custom Tests

# benutzerdefinierte_bandit_test.py
Importbandit
von bandit. core import test_properies

@test_properties.test_id('B999')
@test_properties.checks('Call')
def custom_security_check(context):
""Check for custom security pattern""
wenn context.call_function_name_qual == 'dangerous_function':
Rückkehr Bandit. Lieferung
severity=bandit. HIGH,
Vertrauen=Bandit. HIGH,
text="Benutzen von gefährlich_Funktion erkannt",
lineno=context.node.lineno,

Plugin Development

# Bandit_plugin.
von bandit. Kernimporterweiterung_loader

def load_tests():
"""Load Custom Tests""
zurück [custom_security_check]

# Registrieren Plugin
extension_loader.MANAGER.register_plugin('custom_tests', load_tests)

Using Custom Tests

# Belastungstests
--tests benutzerdefinierte_bandit_test.py

# Verwenden Sie Plugin
Bandit --plugin bandit_plugin.py

Automation and Scripting

Automated Scanning Script

#!/usr/bin/env python3
# bandit_scanner.py

Importsubprozess
Import json
Import sys
Import argparse
von pathlib import Pfad

Klasse BanditScanner:
def __init__(self, project_path, config_file=None):
self.project_path = Pfad(project_path)
self.config_file = config_file
Selbst.Ergebnisse = \\{\\}

def run_scan(self, output_format='json', severity='MEDIUM', trust='MEDIUM'):
""Run Bandit Scan mit bestimmten Parametern""
cm = [
'Bandit', '-r', str(self.project_path),
'-f', output_format,
f'-l\\{self._severity_to_flag(severity)\\',
f'-i\{self._confidence_to_flag(confidence)\\} '
!

wenn selbst.config_file:
cmd.extend(['-configfile', self.config_file])

versuchen:
Ergebnis = subprocess.run(cmd,apture_output=True, text=True, check=False)

wenn output_format == 'json':
self.results = json.loads(result.stdout) wenn Ergebnis. stdout sonst
andere:
self.results = result.stdout

Rücklaufergebnis.Returncode == 0)

außer Teilprozess. Angerufener Prozess Fehler als e:
print(f"Error run Bandit: \\{e\}")
Zurück False
außer Json. JSONDecode Fehler als e:
print(f"Error parsing JSON Ausgabe: \\{e\\}")
Zurück False

def _severity_to_flag(selbst, severity):
""Convert severity to Bandit flag""
Mapping = \\{'LOW': '', 'MEDIUM': 'l', 'HIGH': 'll'\}
zurück Mapping. get(severity.upper(), 'l')

def _confidence_to_flag(Selbstvertrauen):
"""Konvertieren Sie Vertrauen zu Bandit Flag""
Mapping = \\{'LOW': 'ii', 'MEDIUM': 'i', 'HIGH': '\\}
zurück mapping.get(confidence.upper(), 'i')

def get_summary(self):
""Get Scan Zusammenfassung"
wenn nicht instance(self.results, dict):
zurück "Keine Ergebnisse verfügbar"

metrics = self.results.get('metrics', \\{\\})
zurück zur Übersicht
'total_lines': metrics.get('_totals', \\{\\}).get('loc', 0),
'total_issues': len(self.results.get('results', [])),
'high_severity': len([r for r in self.results.get('results', [])
wenn r.get('issue_severity') == 'HIGH']),
'medium_severity': len([r for r in self.results.get('results', [])
wenn r.get('issue_severity') == 'MEDIUM']),
'low_severity': len([r for r in self.results.get('results', [])
wenn r.get('issue_severity') == 'LOW'])
~

def get_issues_by_severity(self, severity='HIGH'):
"Get-Probleme durch Schwere gefiltert"
wenn nicht instance(self.results, dict):
zurück []

zurück [Ausgabe in self.results.get('results', [])
wenn Ausgabe.get('issue_severity') == severity.upper()]

def create_report(self, output_file='bandit_report.html'):
""Generieren Sie HTML-Bericht"
cm = [
'Bandit', '-r', str(self.project_path),
'-f', 'html', '-o', output_file
!

wenn selbst.config_file:
cmd.extend(['-configfile', self.config_file])

versuchen:
subprocess.run(cmd, check=True)
Zurück True
außer Teilprozess. Angerufener Prozess Fehler:
Zurück False

def save_results(self, output_file='bandit_results.json'):
""Save results to file""
wenn Instance(self.results, dict):
mit open(output_file, 'w') als f:
json.dump(self.results, f, indent=2)
andere:
mit open(output_file, 'w') als f:
f.write(str(self.results))

def main():
parser = argparse. ArgumentParser(description='Automated Bandit Scanner')
parser.add_argument('project_path', help='Path to project to scan')
parser.add_argument('-config', help='Bandit Konfigurationsdatei')
parser.add_argument('-severity', default='MEDIUM',
Wahlen=['LOW', 'MEDIUM', 'HIGH'],
Hilfe='Minimum severity level')
parser.add_argument('-confidence', default='MEDIUM',
Wahlen=['LOW', 'MEDIUM', 'HIGH'],
Hilfe='Minimum Vertrauensniveau')
parser.add_argument('-output', help='Output-Datei für Ergebnisse')
parser.add_argument('-report', help='Generate HTML report')

args = parser.parse_args()

Scanner = BanditScanner(args.project_path, args.config)

print(f"Scanning \\{args.project_path\}...")
Erfolg = scanner.run_scan(severity=args.severity, trust=args.confidence)

wenn Erfolg:
Zusammenfassung = scanner.get_summary()
print(f"Scan erfolgreich abgeschlossen!")
print(f"Gesamtzeilen des Codes: \\{summary['total_lines']\}")
print(f"Gesamte Probleme gefunden: \\{summary['total_issues']\}")
print(f)High severity: \\{summary['high_severity']\\}")
print(f)Medium severity: \\{summary['medium_severity']\\}")
print(f)Low severity: \\{summary['low_severity']\\}")

wenn Args. Ausgabe:
scanner.save_results(args.output)
print(f"Ergebnisse, die in \\{args.output\}") gespeichert werden

wenn args.report:
wenn Scanner.genrate_report(args.report):
print(f"HTML-Bericht generiert: \\{args.report\}")
andere:
print("Failed to create HTML report")

        # Exit with error code if high severity issues found
wenn Zusammenfassung['high_severity'] > ` 0:
print("Hohe Schwere Probleme gefunden!")
sys.exit(1)
andere:
print("Scan versagt!")
sys.exit(1)

wenn __name___======================================================= '__main__':
Haupt()

Batch Processing Script

#!/bin/bash
# Batch_bandit_scan.sh

# Konfiguration
PROJECTS_DIR="/path/to/projects"
REPORTS_DIR="/path/to/reports"
DATE=$(Datum +%Y%m%d_%H%M%S)

# Listenverzeichnis erstellen
mkdir -p "$REPORTS_DIR"

# Funktion zum Scannen von Projekt
Scan_Projekt() \{
lokales Projekt_path="$1"
lokale Projekt_name=$(Basisname "$project_path")
Lokal report_file="$REPORTS_DIR/$\{project_name\}_$\{DATE\}.json"
html_report="$ REPORTS_DIR/$\{project_name\}_$\{DATE\}.html"

echo "Scanning $project_name..."

    # Run Bandit scan
bandit -r "$project_path" -f json -o "$report_file" -ll -ii
bandit -r "$project_path" -f html -o "$html_report" -ll -ii

    # Check for high severity issues
| high_issues=$(jq '.results | map(select(.issue_severity == "HIGH")) | length" "$report_file") |

wenn [ "$high_issues" -gt 0 ]; dann
echo "WARNING: $project_name has $high_issues high severity Issues!"
echo "$project_name" >> "$REPORTS_DIR/high_severity_projects.txt"
Fichte

echo "Scan abgeschlossen für $project_name"
{\cHFFFF}

# Alle Python Projekte scannen
finden "$PROJECTS_DIR" -Name "*.py" -Typ f|while read -r file; do
Projekt_dir=$(dirname "$file")
wenn [ ! -f "$project_dir/.bandit_scanned"]; dann
scan_project "$project_dir"
touch "$project_dir/.bandit_scanned"
Fichte
erledigt

echo "Batch Scannen abgeschlossen. Berichte gespeichert zu $REPORTS_DIR"

Integration with IDEs

VS Code Integration

// .vscode/settings.json
. {\cHFFFF}
"python.linting.banditEnabled": wahr,
"python.linting.banditArgs": [
"---severity-level", "medium",
"---confidence-level", "medium"
,
"python.linting.enabled": wahr
{\cHFFFF}

PyCharm Integration

# Externe Werkzeugkonfiguration
# Programm: Bandit
# Argumente: -r $FileDir$ -f json
# Arbeitsverzeichnis: $ProjectFileDir$
__CODE_BLOCK_28_vim
" .vimrc oder init.vim
" Bandit-Integration mit ALE
g:ale_linters = \{
\ 'python': ['bandit', 'flake8', 'pylint'],
~

g:ale_python_bandit_options = '-ll -ii '
__CODE_BLOCK_29_yaml
# .bandit - Umfassende Konfiguration
'B104', 'B106', 'B107', 'B104', 'B105', 'B106', 'B107', 'B108', 'B304', 'B304', 'B304', 'B304', 'B304', 'B304', 'B304', 'B305'

skips: ['B101'] # Skip behauptet_used in Testdateien

Ausschließlich_dirs: [
'*/tests/*,
'*/test/*
'*/.venv/*,
'*/venv/*',
'*/.env/*,
'*/env/*',
'*/Migrationen/*,
'*/node_modules/*,
'*/.git/*
!

# Schwere: LOW, MEDIUM, HIGH
Schwere: MEDIUM

# Vertrauen: LOW, MEDIUM, HIGH
Vertrauen: MEDIUM

False Positive Management

# Inline kommentiert Warnungen zu unterdrücken
Passwort = "default" # nosec B105

# Suppress spezifischer Test
Importsubprozess
subprocess.call(shell_command, shell=True) # nosec B602

# Mehrfachtests unterdrücken
eval(user_input) # nosec B307,B102

Team Workflow Integration

# Konfiguration vorab (.pre-commit-config.yaml)
Repos:
  - Repo: __URL_0_
Rev: '1.7.5'
Haken:
      - id: Bandit
Args: ['-ll', '-ii']
Ausschließlich:

# Dateiintegration erstellen
. PHONY: Sicherheitsscan
Sicherheits-Scan:
bandit -r . -ll -f json -o security-report.json
@echo "Security Scan abgeschlossen. Überprüfen Sie die Sicherheitsreport.json für die Ergebnisse."

. PHONY: Sicherheitscheck
Sicherheitskontrolle:
Bandit -r. -ll -ii
@if [ $? -ne 0]; dann \
echo "Sicherheitsprobleme gefunden. Bitte überprüfen und reparieren."; .
Ausfahrt 1; \
Fichte

Troubleshooting

Common Issues

# Ausgabe: ImportError beim Laufen von Bandit
# Lösung: Sichern Sie die richtige Python-Umgebung
python -m pip install --upgrade bandit

# Ausgabe: Konfiguration nicht gelesen
# Lösung: Konfigurationsdatei Standort und Syntax überprüfen
Bandit --help-config

# Thema: Zu viele falsche Positives
# Lösung: Tune Konfiguration und Verwendung Unterdrückung
Bandit --Skip B101,B601 -ll -II

# Ausgabe: Performance-Probleme mit großen Codebases
# Lösung: unnötige Verzeichnisse ausschließen
bandit -r. --exclude "*/venv/*,*/node_modules/*,*/.git/*"

# Thema: Integration mit CI/CD-Versagen
# Lösung: Verwenden Sie geeignete Ausstiegscodes und Fehlerbehandlung
| -r . -ll -ii |  | true # Weiter auf Fehler |

Performance Optimization

# Parallelverarbeitung (falls verfügbar)
Bandit -r . --Verfahren 4

# Große Verzeichnisse ausschließen
bandit -r . --exclude "*/venv/*,*/env/*,*/node_modules/*,*/.git/*,*/migrations/*"

# Nur spezifische Tests verwenden
Bandit -r . --tests B201,B301,B401,B501

# Begrenzung der Rekurstiefe
| finden . -name "*.py" -not -path "*/venv/*" | head -100 | xargs bandit |

Debugging

# Verbose Ausgang
bandit -v -r .

# Debug-Modus
bandit -d -r .

# Übersprungene Dateien anzeigen
Bandit -r . --verbose

# Testen Sie spezifische Datei mit allen Details
bandit -v -ll -iii specific_file.py

Resources

This cheat sheet provides comprehensive guidance for using Bandit to identify security vulnerabilities in Python code. Always combine static analysis with other security testing methods for comprehensive coverage.

|xargs bandit -ll -ii


## CI/CD Integration

### GitHub Aktionen