DevSecOps Tools Vergleich: SAST, DAST, SCA und Secrets Scanning

DevSecOps integriert Sicherheitstools direkt in den Entwicklungsprozess - von der ersten Code-Zeile bis zum Production-Deployment. Dieser Artikel gibt einen strukturierten Überblick über die vier Hauptkategorien von DevSecOps-Tools, erklärt ihre jeweiligen Stärken und Grenzen, und zeigt wie sie in reale CI/CD-Pipelines integriert werden.

Die vier Säulen des DevSecOps-Toolings

Tooling-Kategorien und Zeitpunkt:

  Develop         │  Commit  │  Build   │  Test    │  Deploy
  ─────────────────────────────────────────────────────────
  IDE Plugins     │  Pre-    │          │          │
  (SAST-Lint)     │  Commit  │          │          │
                  │  Hooks   │          │          │
                  │          │  SAST    │          │
                  │          │  SCA     │          │
                  │          │  Secrets │          │
                  │          │          │  DAST    │
                  │          │          │  IAST    │
                  │          │          │          │  Container
                  │          │          │          │  Scanning
                  │          │          │          │  CSPM

Shift-Left-Prinzip:
  → Je früher im Entwicklungsprozess gefunden → desto billiger zu beheben
  → SAST findet Bugs beim Commit (nicht nach Deployment!)
  → Kosten: DEV: $1 | CI: $10 | QA: $100 | PROD: $1.000+

SAST - Static Application Security Testing

Was SAST kann und nicht kann:

KANN:
  → Code-Patterns ohne Ausführung analysieren
  → Bekannte Schwachstellenklassen (CWE) erkennen
  → Taint-Analyse: Input → Sink (SQL, HTML, Filesystem)
  → In CI/CD ohne laufende Applikation integrierbar
  → 100% Code-Coverage (jede Zeile wird analysiert)

KANN NICHT:
  → Laufzeit-Fehler erkennen (Authentifizierung, Business-Logik)
  → False-Positive-Rate: 30-60% ohne Tuning!
  → Context-abhängige Schwachstellen (API-Design-Fehler)

Tool-Vergleich:

Semgrep (OSS + Cloud):
  Stärken:
    → YAML-basierte Rules: eigene Regeln einfach schreiben
    → Community-Ruleset: 1000+ vordefinierte Regeln
    → Multi-Language: Python, Java, JS, Go, Ruby, Rust, C
    → Sehr schnell (kein Build nötig)
    → Semgrep OSS: kostenlos, CLI-Integration
    → Semgrep Code (Cloud): Taint-Analyse, Dashboard
  Schwächen:
    → Oberflächliche Taint-Analyse im OSS-Modus
    → Keine cross-file Analyse im freien Tier

  CI/CD (GitHub Actions):
  - uses: returntocorp/semgrep-action@v1
    with:
      config: "p/python p/javascript p/docker"

SonarQube / SonarCloud:
  Stärken:
    → Umfangreiche Sprach-Unterstützung (30+ Sprachen)
    → Quality Gates: PR-Block wenn Security-Rating fällt
    → Technische Schulden-Tracking
    → OWASP Top 10 + CWE Coverage Reports
    → Gute IDE-Integration (SonarLint)
  Schwächen:
    → Ressourcenintensiv (selbst gehostet: 8GB RAM minimum)
    → Lizenz: Community Edition kostenlos, Enterprise $$$
    → False-Positive-Rate ohne Tuning hoch

  Empfehlung: SonarCloud für kleinere Teams (kostenlos für OSS)

CodeQL (GitHub Advanced Security):
  Stärken:
    → Tiefe semantische Analyse (versteht Datenfluss!)
    → Von GitHub native integriert (GitHub Actions)
    → Gute True-Positive-Rate durch Datenfluss-Analyse
    → SARIF-Output für standardisierte Ergebnisse
  Schwächen:
    → Nur Java, JS/TS, Python, Go, Ruby, C/C++, C#, Swift
    → Langsam (CodeQL-Datenbank aufbauen kostet Zeit)
    → GitHub Advanced Security: kostenpflichtig für private Repos

Bandit (Python-spezifisch):
  → OSS, nur Python
  → Sehr schnell, geringe Komplexität
  → Findet: Hardcoded Secrets, Unsichere Crypto, Shell-Injection
  → Ideal als erster SAST-Layer für Python-Projekte

Gosec (Go-spezifisch):
  → OSS, nur Go
  → Findet: SQL-Injection, Path-Traversal, Crypto-Fehler in Go

SCA - Software Composition Analysis

Was SCA kann:

Ziel: Bekannte CVEs in Open-Source-Dependencies finden

Funktionsprinzip:
  1. Lock-File/Manifest lesen: package-lock.json, requirements.txt, go.sum
  2. Dependency-Baum aufbauen (transitive Dependencies!)
  3. Gegen CVE-Datenbank abgleichen (NVD, OSV, GitHub Advisory DB)
  4. Report: welche Packages haben bekannte CVEs?

Tool-Vergleich:

Snyk:
  Stärken:
    → Tiefe Dependency-Baum-Analyse
    → Automatische Fix-PRs!
    → Lizenz-Scanning (GPL-Copyleft-Risiken)
    → Container-Scanning inklusive
    → Gute False-Positive-Rate
    → Free Tier: 200 Tests/Monat
  Schwächen:
    → Kostenpflichtig für CI/CD-Integration mit vielen Tests
    → Snyk ist proprietär (Vendor-Lock-in)

Dependabot (GitHub nativ):
  Stärken:
    → Automatisch in GitHub integriert, kostenlos
    → Auto-PRs für Security-Updates
    → Breite Ecosystem-Unterstützung
  Schwächen:
    → Keine transitive Dependency-Tiefe bei einigen Ecosystems
    → Nur GitHub-Integration

OWASP Dependency-Check:
  Stärken:
    → OSS, kostenlos
    → Viele Sprachen/Ecosystems
    → Jenkins, Maven, Gradle Plugin
  Schwächen:
    → Höhere False-Positive-Rate als Snyk
    → Langsamere Datenbank-Updates

Trivy (OSS von Aqua Security):
  Stärken:
    → Scanntcontainer-Images + Dateisystem + Git-Repos
    → OSS-Pakete + OS-Packages (apt/rpm) in einem Tool!
    → Schnell, kein Server benötigt
    → SBOM-Export (CycloneDX, SPDX)
    → Misconfig-Check: Terraform, Kubernetes, Dockerfile
  Schwächen:
    → Weniger GUI als Snyk

  Empfehlung: Trivy für Container-zentrierte Workflows!

  trivy image my-app:latest
  trivy fs ./src/
  trivy repo https://github.com/company/repo

Secrets Scanning

Geheimnis-Leaks verhindern:

Problem: Entwickler committen versehentlich API-Keys, Passwörter,
  Zertifikate, Cloud-Credentials in Git-Repositories.
  → GitHub scannt bereits automatisch nach Secrets!
  → Trotzdem: eigene Kontrolle nötig

Tool-Vergleich:

Gitleaks:
  Stärken:
    → OSS, sehr schnell (Go-basiert)
    → Pre-Commit-Hook: Verhindert Commit mit Secrets!
    → CI/CD-Integration einfach
    → Viele vordefinierte Regex-Patterns (AWS, GCP, Stripe, GitHub...)
    → Custom Rules möglich
  Schwächen:
    → False-Positives bei Test-Daten mit ähnlichem Pattern

  # Pre-Commit-Hook (empfohlen!):
  gitleaks protect --staged  # Prüft staged Changes vor Commit
  gitleaks detect           # Prüft gesamte Git-History!

  # In .gitleaks.toml konfigurieren:
  [extend]
  useDefault = true  # Alle Standard-Patterns aktivieren
  [[rules]]
  id = "custom-internal-key"
  regex = "INTERNAL-KEY-[A-Z0-9]{32}"

TruffleHog:
  Stärken:
    → Prüft auch Metadaten, Commit-Messages, Branch-Namen
    → Entropy-basierte Erkennung (hohe Entropie = möglicher Secret)
    → Verifiziert gefundene Secrets gegen APIs!
  Schwächen:
    → Langsamer als Gitleaks bei großen Repos

GitGuardian:
  Stärken:
    → Cloud-Service, einfache GitHub-Integration
    → Echtzeit-Monitoring (sofortiger Alert bei Push)
    → Automatische Benachrichtigung an Entwickler
    → Historische Analyse des gesamten Repos
  Schwächen:
    → Proprietär, kostenpflichtig für Teams

GitHub Secret Scanning:
  → Automatisch in public Repos (kostenlos)
  → GitHub Advanced Security: auch private Repos
  → Push-Protection: Block Push wenn Secret erkannt!
  → Direkte Benachrichtigung des Entwicklers

Best Practice - Secret-Scanning-Pipeline:
  Pre-Commit: gitleaks protect --staged  (lokal, sofort)
  CI:         gitleaks detect --log-opts="HEAD~1..HEAD"  (neuer Commit)
  Nightly:    trufflehog git --since-commit $(git log --format="%H" -1 --skip=30) .

DAST - Dynamic Application Security Testing

Was DAST kann:

Ziel: Laufende Applikation von außen testen (Black Box)

KANN:
  → Authentifizierungs-Bypass, Business-Logic-Fehler
  → Konfigurationsfehler (TLS, Headers)
  → Laufzeit-Schwachstellen (Session-Management)
  → Injections gegen echte Anwendung

KANN NICHT:
  → Code-Fehler ohne Auswirkung auf Außenverhalten
  → Alle Code-Pfade (kein 100% Coverage)
  → False-Positive-Rate tendenziell niedriger als SAST

Tool-Vergleich:

OWASP ZAP (Zed Attack Proxy):
  Stärken:
    → OSS, kostenlos, aktive Community
    → Baseline-Scan für CI/CD integrierbar
    → Active Scan für tiefere Untersuchung
    → OpenAPI/Swagger-Import für API-Testing
    → AJAX-Spider für SPAs
  Schwächen:
    → False-Positive-Rate beim Active Scan
    → Performance bei großen Anwendungen

  CI/CD (Docker):
  docker run -t owasp/zap2docker-stable zap-baseline.py \
    -t https://staging.example.com \
    -r report.html \
    -z "-config scanner.threadPerHost=2"

Nuclei:
  Stärken:
    → Template-basiert: 7000+ Community-Templates
    → Sehr schnell (Go, parallel)
    → Eigene Templates einfach in YAML schreiben
    → CVE-spezifische Templates: direkt auf bekannte CVEs testen
    → APIs, DNS, SSL, HTTP - alles in einem Tool
  Schwächen:
    → Keine deep-crawling Application-Analyse (eher targeted scans)

  nuclei -u https://target.com -t nuclei-templates/
  nuclei -u https://target.com -tags cve,misconfig -severity critical,high

Burp Suite Pro (manuell + CI):
  Stärken:
    → Mächtigstes Web-App-Testing-Tool überhaupt
    → Burp Suite Enterprise: CI/CD-Integration
    → Aktiver Scan findet komplexe Schwachstellen
  Schwächen:
    → Kostenpflichtig (£449+/Jahr)
    → Enterprise-Version sehr teuer
    → Nicht vollständig automatisierbar (manuelles Wissen nötig)

CI/CD Integration - Komplette Pipeline

GitHub Actions DevSecOps-Pipeline (Beispiel):

name: DevSecOps Pipeline
on: [push, pull_request]

jobs:
  sast:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # Für vollständige History-Scans

      # Secrets Scanning
      - name: Gitleaks Secret Scan
        uses: gitleaks/gitleaks-action@v2
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      # SAST
      - name: Semgrep SAST
        uses: returntocorp/semgrep-action@v1
        with:
          config: "p/python p/javascript p/owasp-top-ten"
          publishToken: ${{ secrets.SEMGREP_APP_TOKEN }}

  sca:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      # SCA + Container Scan
      - name: Trivy SCA Scan
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: 'fs'
          scan-ref: '.'
          exit-code: '1'  # Build fails bei kritischen CVEs!
          severity: 'CRITICAL,HIGH'
          format: 'sarif'
          output: 'trivy-results.sarif'

      - name: Upload Trivy SARIF
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: 'trivy-results.sarif'

  dast:
    runs-on: ubuntu-latest
    needs: [sast, sca]  # Erst wenn SAST/SCA grün!
    services:
      app:
        image: ${{ env.APP_IMAGE }}
        ports: ['8080:8080']
    steps:
      - name: OWASP ZAP Baseline Scan
        uses: zaproxy/action-baseline@v0.10.0
        with:
          target: 'http://localhost:8080'
          fail_action: warn  # DAST: Warning, kein harter Fail

Quality Gates:
  SAST + Secrets → FAIL → kein Merge!
  SCA CRITICAL → FAIL → kein Merge!
  SCA HIGH → WARNING → Review required
  DAST → WARNING → Senior review required
  DAST HIGH/CRITICAL → FAIL → kein Deploy!

GitLab CI Pendant:
  stages: [sast, sca, dast, deploy]
  include:
    - template: Security/SAST.gitlab-ci.yml     # Eingebaut!
    - template: Security/Dependency-Scanning.gitlab-ci.yml
    - template: Security/Secret-Detection.gitlab-ci.yml
    - template: DAST.gitlab-ci.yml
  # GitLab Ultimate: vollständige Security-Templates inklusive

Tool-Auswahl nach Maturity Level

Empfehlungen nach Reifegrad:

Level 1 - Startpunkt (kostengünstig, sofort umsetzbar):
  Secrets:  Gitleaks (OSS, Pre-Commit-Hook)
  SAST:     Semgrep OSS (für Hauptsprache)
  SCA:      Dependabot (automatisch in GitHub)
  DAST:     OWASP ZAP Baseline (Docker-basiert)
  → Einrichtungsaufwand: 1-2 Tage

Level 2 - Fortgeschritten:
  Secrets:  GitGuardian oder Gitleaks + TruffleHog
  SAST:     SonarCloud + Semgrep (ergänzend)
  SCA:      Snyk (Auto-Fix-PRs!) + Trivy (Container)
  DAST:     Nuclei + ZAP Active Scan auf Staging
  IaC:      Trivy Misconfig + Checkov (Terraform, K8s)
  → Einrichtungsaufwand: 1-2 Wochen

Level 3 - Enterprise:
  Secrets:  GitGuardian Enterprise + GitHub Advanced Security
  SAST:     CodeQL + SonarQube Enterprise
  SCA:      Snyk Enterprise + SBOM-Management (DependencyTrack)
  DAST:     Burp Suite Enterprise + HawkScan
  IAST:     Contrast Security oder Seeker
  CSPM:     Prisma Cloud oder Wiz (Cloud-Konfiguration)
  → Einrichtungsaufwand: 1-3 Monate
  → Jährliche Kosten: $50.000-$300.000 (Enterprise)