Zum Inhalt springen
Trainingslager IT-Trainingslager

Kapitel 8: Automatisierte Prüfwerkzeuge, Befundtriage und Schwellenwerte (SAST, SCA, Image- und IaC-Scans mit Trivy, Checkov)

In diesem Kapitel lernst du:

  • welche Scanner-Arten es gibt (SAST, SCA, Image-, IaC- und Secret-Scan) und wo sie in die Pipeline gehören
  • wie du Befunde mit CVSS, EPSS und KEV priorisierst, statt in Listen zu ertrinken
  • wie du Schwellenwerte setzt („Fail on CRITICAL mit verfügbarem Fix”) und das Baseline-Prinzip „keine neuen Befunde” umsetzt
  • wie du Ausnahmen mit Begründung und Ablaufdatum dokumentierst (.trivyignore.yaml, Checkov-Skip)
  • wie du Trivy offline mit einem eigenen Datenbank-Spiegel betreibst und alles zu einer GitLab-CI-Stage security zusammensetzt

Worum geht es?

Stell dir eine Lebensmittelkontrolle in einer Großküche vor. Ein Prüfer schaut, ob die Köche sauber arbeiten (wie wird gekocht?). Ein zweiter prüft die angelieferten Zutaten gegen eine Rückrufliste (ist die Charge Mehl bekannt belastet?). Ein dritter schaut sich das fertige, verpackte Gericht an. Ein vierter prüft den Bauplan der Küche (ist der Kühlraum richtig eingestellt?). Und einer sucht nach Schlüsseln, die jemand am Kühlschrank kleben gelassen hat.

Keiner dieser Prüfer allein reicht. Und wenn jeder Prüfer jede Kleinigkeit meldet, stellt die Küche den Betrieb ein, obwohl nichts Gefährliches passiert ist. Deshalb braucht es zwei Dinge: Regeln, ab wann der Betrieb gestoppt wird (Schwellenwerte) und jemanden, der Meldungen bewertet (Triage).

Genau darum geht es in diesem Kapitel. Du lässt fünf Arten von Scannern auf die demo-app los, lernst die Befunde zu bewerten und baust daraus eine Pipeline-Stage, die nur dann rot wird, wenn es wirklich zählt.

  Commit / Merge Request                  Build                      Freigabe
 +----------------------+       +----------------------+     +-------------------+
 | Secret-Scan (gitleaks)|      | Image bauen          |     | Gate: Schwellen-  |
 | SAST (Semgrep)        | ---> | Image-Scan (Trivy)   | --> | werte erfuellt?   |
 | SCA  (trivy fs)       |      | SBOM (Kapitel 7)     |     | ja -> Signatur    |
 | IaC  (trivy config,   |      +----------------------+     | nein -> Triage    |
 |       Checkov)        |                                   +-------------------+
 +----------------------+                                            |
           |                                                         v
           +-------------> Berichte (SARIF/JSON) ----------> Triage-Board / Tickets

Die Konzepte in einfach

Fünf Scanner-Arten im Überblick

Die Abkürzungen klingen ähnlich, prüfen aber völlig unterschiedliche Dinge.

Art Was es findet Beispiel-Werkzeug Wann in der Pipeline
SAST Unsichere Muster im eigenen Code Semgrep Bei jedem Commit/MR
SCA Bekannte Lücken in Abhängigkeiten trivy fs, Grype Bei jedem Commit/MR
Image-Scan Lücken in OS-Paketen und Libs im Image trivy image Nach dem Build, vor Freigabe
IaC-Scan Fehlkonfiguration in Manifesten, Terraform, Dockerfile trivy config, Checkov Bei jedem Commit/MR
Secret-Scan Passwörter, Tokens, Schlüssel im Code gitleaks, trivy Pre-Commit und bei jedem MR

SAST heißt Static Application Security Testing, also statische Prüfung des Quellcodes, ohne ihn auszuführen. Der Scanner sucht nach Mustern wie „Benutzereingabe landet ungeprüft in einem Shell-Befehl”.

SCA heißt Software Composition Analysis, also Analyse der Zusammensetzung. Der Scanner liest requirements.txt, package-lock.json oder pom.xml und vergleicht die Versionen mit Schwachstellen-Datenbanken. Er findet also keine Fehler in deinem Code, sondern bekannte Fehler im Code anderer Leute, den du mitlieferst.

Der Image-Scan ist ein SCA-Scan auf dem fertigen Container-Image. Er sieht zusätzlich die Betriebssystem-Pakete aus dem Basis-Image (zum Beispiel openssl oder libc aus Debian).

Der IaC-Scan (Infrastructure as Code) prüft Konfigurationsdateien: Läuft der Container als root? Fehlen Ressourcen-Limits? Ist ein S3-Bucket öffentlich?

Der Secret-Scan sucht nach Zugangsdaten. Das Thema hast du in Kapitel 6 vertieft; hier gehört er der Vollständigkeit halber in die Stage.

Merke: SAST findet deine Fehler, SCA und Image-Scan finden fremde bekannte Fehler, IaC-Scan findet Konfigurationsfehler. Kein Werkzeug ersetzt ein anderes.

Wie ernst ist ein Befund? CVSS, EPSS und KEV

Ein Scanner meldet schnell hunderte CVEs. Eine CVE (Common Vulnerabilities and Exposures) ist eine eindeutige Nummer für eine bekannte Schwachstelle, zum Beispiel CVE-2023-32681. Um zu entscheiden, was zuerst dran ist, gibt es drei Bewertungen.

Kennzahl Frage, die sie beantwortet Wertebereich Herausgeber
CVSS Wie schlimm wäre es, wenn es passiert? 0.0 bis 10.0 FIRST (Standard), NVD/Hersteller
EPSS Wie wahrscheinlich wird es bald ausgenutzt? 0 bis 1 (Prozent) FIRST
KEV Wird es nachweislich schon ausgenutzt? ja/nein CISA (US-Behörde)

CVSS (Common Vulnerability Scoring System) bewertet die theoretische Schwere. Daraus leiten Scanner die Stufen ab: LOW (0.1–3.9), MEDIUM (4.0–6.9), HIGH (7.0–8.9), CRITICAL (9.0–10.0). Verbreitet ist Version 3.1, Version 4.0 setzt sich langsam durch.

EPSS (Exploit Prediction Scoring System) schätzt die Wahrscheinlichkeit, dass eine Lücke in den nächsten 30 Tagen ausgenutzt wird. Ein CVSS 9.8 mit EPSS 0.001 ist oft weniger dringend als ein CVSS 7.5 mit EPSS 0.9.

KEV (Known Exploited Vulnerabilities) ist ein Katalog der CISA mit Lücken, die nachweislich in freier Wildbahn ausgenutzt werden. Steht eine CVE im KEV-Katalog, gilt: sofort handeln.

Tipp: Eine einfache Priorisierung für den Anfang: (1) KEV-gelistet, (2) CRITICAL/HIGH mit hohem EPSS, (3) CRITICAL/HIGH mit Fix, (4) der Rest im normalen Patch-Zyklus.

Wichtig ist außerdem der Kontext. Eine Lücke in einer Bibliothek, deren verwundbare Funktion du nie aufrufst, ist weniger dringend. Eine Lücke in einem Dienst, der aus dem Internet erreichbar ist, ist dringender als in einem Batch-Job hinter drei Zonengrenzen.

False Positives und False Negatives

Ein False Positive (Fehlalarm) ist ein Befund, der in deinem Kontext keiner ist. Beispiele:

  • Semgrep meldet shell=True, aber der Befehl ist ein fester String ohne Benutzereingabe.
  • Trivy meldet eine CVE in einem Paket, das nur im Build-Stage existierte, aber das Image-Layer wurde falsch zugeordnet.
  • Checkov verlangt ein Image-Digest, aber der Digest wird erst beim Deployment über Kyverno erzwungen (siehe Kapitel 9).

Ein False Negative ist schlimmer: eine echte Lücke, die nicht gemeldet wird. Das passiert zum Beispiel, wenn die Schwachstellen-Datenbank veraltet ist, wenn Abhängigkeiten nicht gepinnt sind (Scanner sieht keine Version) oder wenn Binärdateien ohne Paketmetadaten ins Image kopiert werden.

Achtung: Ein grüner Scan heißt nur: „Nichts gefunden, was der Scanner kennt.” Er heißt nicht „sicher”.

Schwellenwerte: Wann wird die Pipeline rot?

Ein Schwellenwert (Threshold) legt fest, welche Befunde den Build abbrechen. Typische Stufen:

Regel Wirkung Geeignet für
Fail on CRITICAL nur kritische Befunde brechen ab Start, Altprojekte
Fail on HIGH,CRITICAL strenger neue Projekte, Produktion
nur mit Fix (--ignore-unfixed) ignoriert Befunde ohne Patch fast immer sinnvoll
KEV immer Fail unabhängig von CVSS regulierte Umgebungen

Das Argument für „nur mit Fix”: Wenn es keinen Patch gibt, kann das Entwicklungsteam nichts tun außer zu warten. Ein Build, der wochenlang rot ist, wird ignoriert oder umgangen. Befunde ohne Fix gehören in ein Risiko-Register und werden beobachtet, aber blockieren nicht.

Baseline und Ratchet: „Keine neuen Befunde”

In einem Altprojekt findet der erste Scan oft 200 Befunde. Würdest du sofort auf „Fail on HIGH” schalten, wäre jeder Build rot. Die Lösung heißt Baseline: Du frierst den heutigen Stand ein und forderst nur, dass nichts Neues dazukommt.

Das Ratchet-Prinzip (Ratsche, wie beim Werkzeug: dreht nur in eine Richtung) ergänzt das. Jedes Mal, wenn das Team einen Altbefund behebt, schrumpft die Baseline. Sie wächst nie wieder.

 Befunde
  200 |#####
  150 |#####  ####
  100 |#####  ####  ###
   50 |#####  ####  ###  ##
    0 +-----------------------> Zeit
        Q1    Q2    Q3   Q4     (Baseline sinkt nur, neue Befunde = Build rot)

Werkzeuge unterstützen das unterschiedlich:

  • Semgrep: --baseline-commit <ref> meldet nur Befunde, die seit diesem Commit neu sind.
  • Checkov: --create-baseline schreibt eine .checkov.baseline, --baseline <datei> vergleicht dagegen.
  • Trivy: keine eingebaute Baseline; du nutzt eine Ignore-Datei mit Ablaufdaten.

SARIF: ein Format für alle Berichte

SARIF (Static Analysis Results Interchange Format) ist ein JSON-basierter OASIS-Standard für Scan-Ergebnisse. Semgrep, Trivy und Checkov können SARIF schreiben. Vorteil: Ein Triage-Werkzeug, ein Code-Review-System oder ein zentrales Dashboard muss nur ein Format verstehen. Für eigene Auswertungen mit jq ist das jeweilige native JSON oft bequemer. In der Pipeline legst du deshalb beides als Artefakt ab.

Trivy offline: die Schwachstellen-Datenbank spiegeln

Trivy lädt beim Start seine Schwachstellen-Datenbank (trivy-db) herunter. Diese DB wird als OCI-Artefakt verteilt, also in einer Container-Registry abgelegt wie ein Image (Standardquellen: mirror.gcr.io/aquasec/trivy-db:2 und ghcr.io/aquasecurity/trivy-db:2). Für Java-Abhängigkeiten gibt es zusätzlich trivy-java-db:1, für IaC-Prüfregeln das Bundle trivy-checks.

In einer abgeschotteten Umgebung (air-gapped) gibt es kein Internet. Dann hast du zwei Wege:

  1. DB als OCI-Artefakt spiegeln: Auf der Internet-Seite kopierst du trivy-db:2 mit oras cp in deinen Registry-Spiegel (Harbor, Nexus, siehe Kapitel 3). Trivy zeigt mit --db-repository auf diesen Spiegel.
  2. Cache-Verzeichnis transportieren: Du lädst die DB einmal mit trivy image --download-db-only in ein Cache-Verzeichnis, transportierst es über die Zonengrenze (siehe Kapitel 4) und startest Trivy dort mit --skip-db-update.

Sicherheit: Die DB ist selbst ein Lieferketten-Artefakt. Wer sie manipuliert, kann Befunde verschwinden lassen. Behandle sie wie jedes andere Artefakt: Herkunft prüfen, nach Digest übernehmen, Übergabe protokollieren.

Achte auf die Aktualität: Die DB wird mehrmals täglich neu gebaut. Eine Woche alte DB übersieht neue CVEs. Trivy warnt, wenn die DB zu alt ist.

Triage: vom Befund zur Entscheidung

Triage kommt aus der Notfallmedizin: Wer wird zuerst behandelt? Für jeden Befund, der die Schwelle reißt, gibt es genau drei Ausgänge.

                 +-------------------+
                 |  Neuer Befund     |
                 +---------+---------+
                           |
          +----------------+------------------+
          v                v                  v
  +---------------+ +----------------+ +-----------------------+
  | Bestaetigt    | | False Positive | | Risiko akzeptiert     |
  | -> Fix-Ticket | | -> Ignore mit  | | -> Ignore mit Frist   |
  |    mit Frist  | |    Begruendung | |    + Ticket + Owner   |
  +---------------+ +----------------+ +-----------------------+

Jede Ausnahme braucht vier Angaben: was (ID, Pfad), warum (Begründung), wer (verantwortliche Person oder Team), bis wann (Ablaufdatum). Ohne Ablaufdatum wird aus der Ausnahme ein Dauerzustand. Wie man solche Ausnahmen organisatorisch mit Entwicklungsteams aushandelt, vertieft Kapitel 10.

Hands-on-Lab: Scanner-Kette mit Triage und Schwellenwerten

Du arbeitest auf einer Kopie der demo-app, damit die Originalversion für andere Kapitel unverändert bleibt.

Schritt 1: Arbeitsverzeichnis vorbereiten

mkdir -p ~/seclab/kap08 && cd ~/seclab/kap08
cp -r ~/seclab/demo-app ./demo-app
cd demo-app && git init -q && git add -A && git commit -qm "Ausgangsstand"
ls

Erwartete Ausgabe (Reihenfolge kann abweichen):

Dockerfile  app.py  k8s  requirements.txt

Prüfe, dass die Werkzeuge da sind:

semgrep --version && trivy --version | head -1 && checkov --version

Du solltest drei Versionsnummern sehen. Fehlt eines, geh zurück zu Kapitel 0.

Schritt 2: Eine Schwachstelle einbauen

Jetzt baust du absichtlich eine Kommando-Injektion (Command Injection) ein. Ergänze in app.py oberhalb des if __name__ ...-Blocks (falls vorhanden, sonst am Ende):

import subprocess
from flask import request


@app.route("/ping")
def ping():
    host = request.args.get("host", "127.0.0.1")
    # ABSICHTLICH UNSICHER - nur fuer das Lab!
    out = subprocess.run(
        f"ping -c 1 {host}", shell=True, capture_output=True, text=True
    )
    return {"output": out.stdout}

Warum ist das gefährlich? Mit shell=True interpretiert eine Shell den String. Ruft jemand /ping?host=127.0.0.1;cat /etc/passwd auf, führt die Shell beide Befehle aus.

Schritt 3: SAST mit Semgrep

cd ~/seclab/kap08/demo-app
semgrep scan --config p/python --metrics=off .

p/python ist ein Regelpaket aus der Semgrep-Registry; dafür braucht Semgrep beim ersten Mal Internetzugang. --metrics=off verhindert, dass Nutzungsdaten gesendet werden.

Erwartete Ausgabe (gekürzt, Regel-IDs können je nach Regelstand abweichen):

    app.py
   > python.lang.security.audit.subprocess-shell-true.subprocess-shell-true
          Found 'subprocess' function 'run' with 'shell=True'. This is dangerous
          because this call will spawn the command using a shell process. ...

 Ran ... rules on ... files: 1+ findings.

Je nach Regelstand meldet Semgrep zusätzlich eine Flask-spezifische Regel, die erkennt, dass request.args in den Befehl fließt. Das ist eine sogenannte Taint-Analyse: Der Scanner verfolgt, ob eine Eingabe (Source) ungeprüft an eine gefährliche Stelle (Sink) gelangt.

Jetzt als Bericht und mit Exit-Code für die Pipeline:

mkdir -p ../reports
semgrep scan --config p/python --metrics=off --error \
  --sarif --output ../reports/semgrep.sarif .
echo "Exit-Code: $?"

Erwartet: Exit-Code: 1. Ohne --error würde Semgrep auch bei Befunden mit 0 enden.

Im Offline-Betrieb und in der Pipeline (Schritt 12 und Kapitel 11) gibt es keine Semgrep-Registry. Dort nutzt du eigene Regeln, die als YAML versioniert im Repository liegen. Lege dafür das Verzeichnis .semgrep/ mit zwei Regeln an: eine für genau den Befund von eben und eine gegen abgeschaltete TLS-Prüfung in requests, das die demo-app mitbringt:

mkdir -p .semgrep
cat > .semgrep/python-sicherheit.yaml <<'EOF'
rules:
  - id: subprocess-shell-true
    languages: [python]
    severity: ERROR
    message: >-
      subprocess mit shell=True: Eingaben koennen weitere Befehle einschleusen.
      Argumente als Liste uebergeben, ohne shell=True.
    pattern: subprocess.$FUNC(..., shell=True, ...)
  - id: requests-ohne-tls-pruefung
    languages: [python]
    severity: ERROR
    message: >-
      verify=False schaltet die Zertifikatspruefung ab.
      Interne CA mit verify="/pfad/zur/ca.pem" angeben.
    pattern: requests.$FUNC(..., verify=False, ...)
EOF
semgrep scan --config .semgrep/ --metrics=off --error .
echo "Exit-Code: $?"

Erwartet: genau ein Befund in app.py für die Regel subprocess-shell-true (Semgrep stellt der ID den Pfad der Regeldatei voran) und Exit-Code: 1. Die Regeln werden wie Code im Merge Request reviewt. Kapitel 11 nutzt genau dieses Verzeichnis.

Behebe die Lücke testweise, indem du die Argumente als Liste übergibst:

    out = subprocess.run(
        ["ping", "-c", "1", host], capture_output=True, text=True
    )

Führe beide Scans (p/python und .semgrep/) erneut aus. Die shell=True-Regel verschwindet, der Scan mit .semgrep/ endet mit Exit-Code 0. Für die nächsten Schritte lässt du diese korrigierte Version stehen.

Merke: Ohne Shell gibt es keine Shell-Metazeichen wie ; oder |. Eine echte Anwendung würde host zusätzlich gegen ein Muster für Hostnamen oder IP-Adressen prüfen.

Schritt 4: SCA mit trivy fs

cd ~/seclab/kap08/demo-app
trivy fs --scanners vuln .

Erwartete Ausgabe (gekürzt; Anzahl und genaue CVEs hängen vom DB-Stand ab):

requirements.txt (pip)
Total: 3 (UNKNOWN: 0, LOW: 0, MEDIUM: 3, HIGH: 0, CRITICAL: 0)

| Library  | Vulnerability  | Severity | Status | Installed | Fixed Version |
|----------|----------------|----------|--------|-----------|---------------|
| requests | CVE-2023-32681 | MEDIUM   | fixed  | 2.25.0    | 2.31.0        |
| requests | CVE-2024-35195 | MEDIUM   | fixed  | 2.25.0    | 2.32.0        |
| requests | CVE-2024-47081 | MEDIUM   | fixed  | 2.25.0    | 2.32.4        |

Wichtig sind die Spalten Status und Fixed Version. fixed heißt: Es gibt eine korrigierte Version. Genau darauf zielt später --ignore-unfixed.

Jetzt mit Schwellenwert:

trivy fs --scanners vuln --severity HIGH,CRITICAL --exit-code 1 .
echo "Exit-Code: $?"
trivy fs --scanners vuln --severity MEDIUM,HIGH,CRITICAL --exit-code 1 .
echo "Exit-Code: $?"

Erwartet: beim ersten Aufruf Exit-Code: 0 (keine HIGH/CRITICAL-Befunde in requests), beim zweiten Exit-Code: 1. Du siehst: Die Schwelle entscheidet, ob derselbe Befund die Pipeline stoppt.

Schritt 5: Image-Scan mit Schwellenwerten

Baue das Image (mit der korrigierten app.py) und schiebe es in reg-build:

docker build -t localhost:5001/demo-app:1.0.1 .
docker push localhost:5001/demo-app:1.0.1
crane digest localhost:5001/demo-app:1.0.1

Erwartet: eine Ausgabe der Form sha256:…. Merke dir den Digest in einer Variable:

DIGEST=$(crane digest localhost:5001/demo-app:1.0.1)
IMG="localhost:5001/demo-app@${DIGEST}"

Zuerst ein vollständiger Scan als Bericht, ohne Abbruch:

trivy image --format json --output ../reports/trivy-image.json "$IMG"
jq '[.Results[].Vulnerabilities // [] | .[]] | group_by(.Severity)
  | map({(.[0].Severity): length}) | add' ../reports/trivy-image.json

Erwartete Ausgabe (Zahlen variieren mit Basis-Image und DB-Stand):

{
  "LOW": 50,
  "MEDIUM": 12,
  "HIGH": 3,
  "CRITICAL": 0
}

Die meisten Befunde stammen aus Debian-Paketen des Basis-Images python:3.12-slim. Jetzt das Gate:

trivy image --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 "$IMG"
echo "Exit-Code: $?"

Mit --ignore-unfixed fallen alle Befunde ohne verfügbaren Fix weg. Bei einem frisch gezogenen Basis-Image ist das Ergebnis oft Exit-Code: 0. Lass den Befehl zum Vergleich ohne --ignore-unfixed laufen und zähle, wie viele Befunde nur deshalb blockieren würden, weil Debian noch keinen Patch hat.

Zum Schluss den SARIF-Bericht aus dem schon erzeugten JSON, ohne erneuten Scan:

trivy convert --format sarif --output ../reports/trivy-image.sarif \
  ../reports/trivy-image.json

Tipp: trivy convert gibt es seit Trivy 0.49. Bei älteren Versionen scannst du ein zweites Mal mit --format sarif.

Schritt 6: IaC-Scan mit trivy config

cd ~/seclab/kap08/demo-app
trivy config .

Trivy erkennt Dockerfile und Kubernetes-Manifeste automatisch. Erwartete Ausgabe (gekürzt, abhängig vom Inhalt deiner Manifeste aus Kapitel 0):

Dockerfile (dockerfile)
Tests: 2x (SUCCESSES: 2x, FAILURES: 1)
LOW: Add HEALTHCHECK instruction in your Dockerfile
...
k8s/deployment.yaml (kubernetes)
Failures: ... (LOW: ..., MEDIUM: ..., HIGH: ...)
MEDIUM: Container 'demo-app' of Deployment 'demo-app' should set
        'securityContext.readOnlyRootFilesystem' to true
...

Jede Meldung hat eine ID, zum Beispiel für die Dockerfile-Prüfung „HEALTHCHECK fehlt” oder die Kubernetes-Prüfung „readOnlyRootFilesystem”. Je nach Trivy-Version sieht die ID aus wie AVD-KSV-0014 oder KSV014. Notiere dir die IDs genau so, wie deine Version sie ausgibt; du brauchst sie gleich für Ausnahmen.

Der Gate-Aufruf mit Schwelle:

trivy config --severity HIGH,CRITICAL --exit-code 1 .
echo "Exit-Code: $?"

Ist dein Deployment aus Kapitel 0 schon gehärtet (non-root, keine Privilege Escalation, Capabilities gedroppt), ist der Exit-Code 0. Sonst bekommst du hier deine ersten echten Aufgaben.

Schritt 7: Checkov auf Kubernetes und Terraform

Checkov prüft dieselben Manifeste mit einem eigenen Regelsatz. Zwei Scanner sehen oft unterschiedliche Dinge.

checkov -d k8s/ --compact --quiet

--quiet zeigt nur fehlgeschlagene Prüfungen, --compact lässt Code-Ausschnitte weg. Erwartete Ausgabe (gekürzt):

kubernetes scan results:

Passed checks: 70, Failed checks: 12, Skipped checks: 0

Check: CKV_K8S_43: "Image should use digest"
        FAILED for resource: Deployment.demo.demo-app
        File: /deployment.yaml:1-40
Check: CKV_K8S_14: "Image Tag should be fixed - not latest or blank"
...

Jetzt ein kleines Terraform-Beispiel. Du brauchst dafür weder Terraform noch einen Cloud-Account; Checkov liest nur den Code.

mkdir -p ~/seclab/kap08/terraform
cat > ~/seclab/kap08/terraform/main.tf <<'EOF'
resource "aws_s3_bucket" "artefakte" {
  bucket = "seclab-artefakte"
}

resource "aws_s3_bucket_public_access_block" "artefakte" {
  bucket                  = aws_s3_bucket.artefakte.id
  block_public_acls       = false
  block_public_policy     = false
  ignore_public_acls      = false
  restrict_public_buckets = false
}
EOF
checkov -d ~/seclab/kap08/terraform --framework terraform --compact --quiet

Erwartet: mehrere fehlgeschlagene Prüfungen, darunter Befunde zu öffentlichem Zugriff (zum Beispiel CKV_AWS_53 bis CKV_AWS_56 für die vier false-Werte), fehlendem Access-Logging (CKV_AWS_18), fehlender Versionierung (CKV_AWS_21) und fehlender KMS-Verschlüsselung (CKV_AWS_145). Die genauen IDs hängen von der Checkov-Version ab.

Setze die vier Werte auf true und scanne erneut. Die Public-Access-Befunde verschwinden.

Berichte für die Pipeline:

cd ~/seclab/kap08/demo-app
checkov -d k8s/ --quiet -o sarif --output-file-path ../reports/
ls ../reports/

Erwartet: Neben den bisherigen Berichten liegt results_sarif.sarif im Ordner.

Schritt 8: Baseline für Altbefunde

Stell dir vor, die 12 Checkov-Befunde sind Altlast. Du frierst sie ein:

checkov -d k8s/ --create-baseline --quiet
ls -a k8s/

Erwartet: eine neue Datei k8s/.checkov.baseline. Jetzt prüfst du nur noch gegen die Baseline:

checkov -d k8s/ --baseline k8s/.checkov.baseline --quiet
echo "Exit-Code: $?"

Erwartet: Failed checks: 0 und Exit-Code: 0. Füge nun testweise privileged: true in den securityContext des Containers ein und scanne erneut. Jetzt schlägt mindestens eine neue Prüfung fehl (CKV_K8S_16, „Container should not be privileged”), und der Exit-Code ist 1. Genau das ist das Ratchet-Prinzip. Entferne die Zeile wieder.

Achtung: Die Baseline gehört ins Repository und wird im Merge Request reviewt. Wer die Baseline-Datei neu erzeugt, kann damit jeden Befund verschwinden lassen. Lege für diese Datei in GitLab einen Code-Owner aus dem Security-Team fest.

Schritt 9: Ausnahmen mit Begründung und Ablaufdatum

Angenommen, die Triage ergibt für CVE-2024-47081 in requests: Das Team aktualisiert im nächsten Sprint, bis dahin wird das Risiko akzeptiert. Die einfachste Form ist die klassische .trivyignore:

cat > .trivyignore <<'EOF'
# Risiko akzeptiert: netrc-Credential-Leak, App nutzt keine .netrc.
# Owner: team-demo, Ticket: SEC-142, Review durch Security am 2026-10-08
CVE-2024-47081 exp:2026-12-31
EOF
trivy fs --scanners vuln .

Erwartet: CVE-2024-47081 taucht nicht mehr in der Tabelle auf. Nach dem 31.12.2026 ist der Eintrag automatisch wirkungslos und der Befund kommt zurück.

Strukturierter ist die YAML-Variante. Sie erlaubt Pfade und eine Begründung im Feld statement:

cat > .trivyignore.yaml <<'EOF'
vulnerabilities:
  - id: CVE-2024-47081
    paths:
      - "requirements.txt"
    statement: "Risiko akzeptiert, keine .netrc im Container. Owner team-demo, SEC-142"
    expired_at: 2026-12-31
misconfigurations:
  - id: AVD-DS-0026
    statement: "Healthcheck erfolgt per Kubernetes-Probe statt Dockerfile. SEC-143"
    expired_at: 2027-03-31
EOF
trivy fs --scanners vuln,misconfig --ignorefile .trivyignore.yaml .

Achtung: Die YAML-Ignore-Datei ist in Trivy als experimentell markiert und muss explizit mit --ignorefile übergeben werden. Trage bei misconfigurations die ID so ein, wie deine Trivy-Version sie ausgibt (siehe Schritt 6). Eine falsche ID wird stillschweigend ignoriert.

Für Checkov schreibst du die Ausnahme direkt an die Ressource. In Kubernetes-Manifesten geht das per Annotation:

metadata:
  name: demo-app
  namespace: demo
  annotations:
    checkov.io/skip1: CKV_K8S_43=Digest wird per Kyverno erzwungen (Kap. 9), SEC-144

In Terraform per Kommentar innerhalb des Blocks:

resource "aws_s3_bucket" "artefakte" {
  # checkov:skip=CKV_AWS_144:Keine Cross-Region-Replikation noetig, Lab. SEC-145
  bucket = "seclab-artefakte"
}

Prüfe das Ergebnis:

checkov -d k8s/ --compact | grep -A2 "SKIPPED"

Erwartet: CKV_K8S_43 erscheint als SKIPPED samt Begründung. Checkov-Skips haben kein eingebautes Ablaufdatum. Deshalb gehört die Ticketnummer in die Begründung, und das Ticket trägt die Frist.

Damit lokale Aufrufe und Pipeline dieselben Einstellungen nutzen, legst du sie in eine Konfigurationsdatei .checkov.yaml im Wurzelverzeichnis des Repositorys. Die Schlüssel heißen wie die langen Kommandozeilen-Optionen. Hinein gehören die Baseline aus Schritt 8 und Ausnahmen, die für das ganze Repository gelten:

cat > .checkov.yaml <<'EOF'
# Gemeinsame Checkov-Einstellungen fuer demo-app (Kapitel 8)
# Jede Ausnahme mit Begruendung und Ticket; die Frist steht im Ticket.
baseline: k8s/.checkov.baseline
compact: true
skip-check:
  # CKV_K8S_15 (imagePullPolicy Always): Images werden per Digest
  # referenziert (Kapitel 11), Always bringt keinen Gewinn. SEC-147
  - CKV_K8S_15
EOF
checkov -d k8s/ --config-file .checkov.yaml
echo "Exit-Code: $?"

Erwartet: Failed checks: 0 und Exit-Code: 0. CKV_K8S_15 taucht gar nicht mehr auf: Über skip-check ausgeschlossene Prüfungen laufen nicht, anders als die Annotation oben, die als SKIPPED mit Begründung erscheint. Globale Skips gehören deshalb nur in diese eine Datei, und die bekommt wie die Baseline einen Code-Owner aus dem Security-Team.

Schritt 10: Triage eines Befunds mit EPSS und KEV

Spiel die Triage für CVE-2023-32681 einmal durch. Zuerst die Details aus dem Trivy-Bericht:

trivy fs --scanners vuln --format json . \
  | jq '.Results[].Vulnerabilities[]
        | select(.VulnerabilityID=="CVE-2023-32681")
        | {id: .VulnerabilityID, pkg: .PkgName, fix: .FixedVersion,
           sev: .Severity, title: .Title}'

Dann die Ausnutzungswahrscheinlichkeit über die öffentliche EPSS-API von FIRST:

curl -s "https://api.first.org/data/v1/epss?cve=CVE-2023-32681" \
  | jq '.data[0] | {cve, epss, percentile}'

Erwartet: ein kleiner epss-Wert (deutlich unter 0.1). Zum Schluss der KEV-Abgleich:

KEV_URL="https://www.cisa.gov/sites/default/files/feeds"
curl -s "${KEV_URL}/known_exploited_vulnerabilities.json" -o kev.json
jq '[.vulnerabilities[] | select(.cveID=="CVE-2023-32681")] | length' kev.json

Erwartet: 0, die CVE ist nicht im KEV-Katalog. Deine Triage-Notiz könnte so aussehen:

Befund:     CVE-2023-32681, requests 2.25.0, MEDIUM
Kontext:    App nutzt requests nicht mit Proxy, nur intern erreichbar
EPSS/KEV:   niedrig / nein
Fix:        requests >= 2.31.0 verfuegbar
Entscheid:  bestaetigt -> Fix-Ticket SEC-146, Frist 30 Tage (MEDIUM)

Behebe den Befund wirklich: Setze in requirements.txt eine aktuelle requests-Version (zum Beispiel requests==2.32.4 oder neuer) und scanne erneut. Alle drei requests-Befunde verschwinden.

Tipp: In der air-gapped Umgebung spiegelst du die EPSS-CSV-Datei und den KEV-Katalog genauso wie die Trivy-DB, zum Beispiel täglich über die Zonenübergabe aus Kapitel 4.

Schritt 11: Trivy-DB als OCI-Artefakt spiegeln

Jetzt simulierst du den Offline-Betrieb. reg-build übernimmt die Rolle des internen Registry-Spiegels.

oras cp --to-plain-http \
  ghcr.io/aquasecurity/trivy-db:2 localhost:5001/aquasecurity/trivy-db:2
oras manifest fetch --plain-http localhost:5001/aquasecurity/trivy-db:2 | jq .

Erwartet: ein OCI-Manifest mit einer Schicht vom Medientyp application/vnd.aquasec.trivy.db.layer.v1.tar+gzip. Nun nutzt Trivy den Spiegel mit einem frischen, leeren Cache:

trivy image --cache-dir ~/seclab/kap08/cache-offline \
  --db-repository localhost:5001/aquasecurity/trivy-db:2 \
  --download-db-only
ls ~/seclab/kap08/cache-offline/db

Erwartet: die Dateien metadata.json und trivy.db. Ab jetzt scannst du ohne jeden Netzwerkzugriff auf die DB:

trivy fs --cache-dir ~/seclab/kap08/cache-offline \
  --skip-db-update --scanners vuln .
jq . ~/seclab/kap08/cache-offline/db/metadata.json

In metadata.json siehst du UpdatedAt und NextUpdate. Das ist dein Prüfpunkt für die Aktualität.

Merke: Für einen vollständigen Offline-Betrieb spiegelst du auf die gleiche Art trivy-java-db:1 (Flag --java-db-repository) und das IaC-Regelbundle trivy-checks (Flag --checks-bundle-repository). Mit --skip-java-db-update und --skip-check-update verhinderst du Download-Versuche. Das Flag --offline-scan unterbindet zusätzlich Online-Abfragen für einzelne Sprach-Ökosysteme.

Schritt 12: Alles in eine GitLab-CI-Stage security

Jetzt setzt du die Teile zu einer Stage zusammen. Die Images kommen aus deinem Spiegel (siehe Kapitel 3). Die Stage security ergänzt die Pipeline aus Kapitel 1: Stages test und build, Job build, Variable IMAGE_NAME und das Artefakt image-digest.txt stammen von dort. Die Variable MIRROR passt du an dein Setup an.

stages: [test, build, security]

variables:
  MIRROR: "nexus:8082"                        # Docker-Proxy aus Kapitel 3
  IMAGE_NAME: "reg-build:5000/demo-app"       # wie in Kapitel 1
  TRIVY_NO_PROGRESS: "true"
  TRIVY_INSECURE: "true"                      # reg-build spricht nur HTTP (Lab)
  TRIVY_CACHE_DIR: ".trivycache"
  TRIVY_DB_REPOSITORY: "reg-build:5000/aquasecurity/trivy-db:2"

.reports: &reports
  artifacts:
    when: always
    expire_in: 30 days
    paths: [reports/]

sast-semgrep:
  stage: security
  image: ${MIRROR}/semgrep/semgrep:1.90.0    # Beispielversion, per Digest pinnen
  <<: *reports
  script:
    - mkdir -p reports
    - semgrep scan --config .semgrep/ --metrics=off
        --json --output reports/semgrep.json .
    - semgrep scan --config .semgrep/ --metrics=off --error
        --severity ERROR --sarif --output reports/semgrep.sarif .

sca-trivy-fs:
  stage: security
  image: { name: "${MIRROR}/aquasec/trivy:0.58.1", entrypoint: [""] }
  <<: *reports
  script:
    - mkdir -p reports
    - trivy fs --scanners vuln --format json -o reports/trivy-fs.json .
    - trivy fs --scanners vuln --skip-db-update --ignorefile .trivyignore.yaml
        --severity HIGH,CRITICAL --ignore-unfixed --exit-code 1 .

image-trivy:
  stage: security
  image: { name: "${MIRROR}/aquasec/trivy:0.58.1", entrypoint: [""] }
  needs: [build]                              # Job aus Kapitel 1
  rules:
    - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH   # wie der Job build
  <<: *reports
  script:
    - mkdir -p reports
    - IMAGE_REF="$IMAGE_NAME@$(cat image-digest.txt)"
    - trivy image --format json -o reports/trivy-image.json "$IMAGE_REF"
    - trivy convert --format sarif -o reports/trivy-image.sarif
        reports/trivy-image.json
    - trivy image --skip-db-update --ignorefile .trivyignore.yaml
        --severity CRITICAL --ignore-unfixed --exit-code 1 "$IMAGE_REF"

iac-trivy-config:
  stage: security
  image: { name: "${MIRROR}/aquasec/trivy:0.58.1", entrypoint: [""] }
  <<: *reports
  script:
    - mkdir -p reports
    - trivy config --format sarif -o reports/trivy-config.sarif .
    - trivy config --ignorefile .trivyignore.yaml
        --severity HIGH,CRITICAL --exit-code 1 .

iac-checkov:
  stage: security
  image: { name: "${MIRROR}/bridgecrew/checkov:3", entrypoint: [""] }
  <<: *reports
  script:
    - mkdir -p reports
    - checkov -d k8s/ --config-file .checkov.yaml --quiet
        -o cli -o sarif --output-file-path console,reports/

Die Struktur folgt immer demselben Muster: erst der vollständige Bericht (Exit-Code 0, alle Schweregrade, als Artefakt), dann das Gate mit Schwellenwert. So hat die Triage alle Informationen, aber nur die vereinbarten Befunde stoppen die Pipeline. when: always sorgt dafür, dass die Berichte auch bei einem roten Job gespeichert werden.

Beachte die abgestuften Schwellen: SCA und IaC brechen bei HIGH und CRITICAL ab, der Image-Scan zunächst nur bei CRITICAL, weil das Basis-Image viele Befunde mitbringt, die das Team nicht direkt beheben kann. Diese Abstufung ist eine bewusste Entscheidung, die du dokumentierst und regelmäßig nachschärfst.

Lokal prüfst du die YAML-Syntax mit:

yq '.stages' .gitlab-ci.yml

Erwartet: die Liste test, build, security. Pushe in dein GitLab aus Kapitel 1 und beobachte die Pipeline. image-trivy wartet per needs auf den Job build aus Kapitel 1 und liest dessen Artefakt image-digest.txt. So scannt er genau das gebaute Image, per Digest statt per Tag. Weil build nur auf dem Standard-Branch läuft, gilt für image-trivy dieselbe Regel; sonst lehnt GitLab die Pipeline in einem Merge Request wegen eines fehlenden needs-Jobs ab.

Tipp: GitLab zeigt Befunde nur dann im Merge-Request-Widget, wenn sie im GitLab-eigenen Berichtsformat unter artifacts:reports liegen (zum Beispiel sast oder container_scanning). SARIF und JSON aus diesem Lab landen als normale Artefakte und werden von deinem zentralen Werkzeug (zum Beispiel DefectDojo oder Dependency-Track aus Kapitel 7) eingelesen.

Schritt 13: Aufräumen

rm -rf ~/seclab/kap08/cache-offline ~/seclab/kap08/demo-app/kev.json
docker image rm localhost:5001/demo-app:1.0.1

Die Registries reg-build und reg-ziel lässt du laufen, Kapitel 9 braucht sie. Das gespiegelte Artefakt aquasecurity/trivy-db:2 in reg-build darf bleiben.

Fortschritt speichern? Kostenlos registrieren

Typische Stolperfallen

Symptom Ursache Lösung
Trivy hängt beim Start oder bricht mit Download-Fehler ab Kein Internet, DB-Download schlägt fehl --db-repository auf Spiegel setzen oder --skip-db-update mit vorbefülltem Cache
Scan findet keine Python-Lücken Abhängigkeiten nicht gepinnt (flask>=3) Versionen exakt pinnen oder Lockfile nutzen
Pipeline grün, obwohl Befunde gemeldet --exit-code 1 bzw. --error fehlt Gate-Aufruf immer mit Exit-Code-Flag
Pipeline dauerhaft rot wegen Basis-Image Befunde ohne Fix blockieren --ignore-unfixed, Basis-Image regelmäßig neu bauen
Eintrag in .trivyignore.yaml wirkt nicht Datei nicht mit --ignorefile übergeben oder ID-Format falsch Flag setzen, ID exakt aus Ausgabe übernehmen
Semgrep: p/python nicht ladbar Registry offline nicht erreichbar Regeln als YAML ins Repo legen, --config .semgrep/
Checkov-Skip wird ignoriert Annotation an falscher Stelle oder falsches Format checkov.io/skipN: ID=Begründung unter metadata.annotations
Viele Befunde doppelt Trivy und Checkov prüfen dasselbe Bewusst sein lassen oder einen Scanner pro Zweck festlegen

Übung: Schwellenwert-Konzept für ein Altprojekt

Ein Team übernimmt die demo-app als Altprojekt. Der erste Scan zeigt: 3 MEDIUM in requests, rund 60 LOW/MEDIUM und 3 HIGH im Basis-Image (davon 2 ohne Fix), 12 Checkov-Befunde in k8s/. Das Team soll in zwei Wochen live gehen.

Deine Aufgabe:

  1. Lege für jeden Scanner einen Schwellenwert fest, der heute grün ist, aber neue Probleme sofort stoppt.
  2. Erstelle eine .trivyignore.yaml für einen begründeten, befristeten Eintrag.
  3. Schreibe auf, wie die Schwellen in den nächsten zwei Quartalen strenger werden.

Hinweis 1

Überlege für jeden Scanner: Gibt es eine eingebaute Baseline-Funktion? Wenn nicht, wie erreichst du denselben Effekt mit Ignore-Dateien und Ablaufdaten?

Hinweis 2

Befunde ohne Fix blockieren nicht. HIGH mit Fix im Basis-Image behebst du oft einfach durch einen Neubau mit aktuellem Basis-Image. Plane für jede Verschärfung ein konkretes Datum.

Lösung

Ein mögliches Konzept:

Scanner Start (Go-Live) Nach Q1 Nach Q2
Semgrep --baseline-commit auf Go-Live-Tag ERROR blockiert WARNING blockiert
trivy fs HIGH,CRITICAL, --ignore-unfixed + MEDIUM + MEDIUM ohne Ausnahmen
trivy image CRITICAL, --ignore-unfixed HIGH,CRITICAL + KEV immer
Checkov --baseline Baseline halbiert Baseline leer

Für Semgrep im Merge Request nutzt du semgrep scan --baseline-commit "$CI_MERGE_REQUEST_DIFF_BASE_SHA", damit nur neue Befunde zählen. Die 3 MEDIUM in requests werden vor Go-Live behoben, weil ein Fix verfügbar ist und das Update klein ist. Die eine HIGH-Lücke mit Fix im Basis-Image verschwindet durch einen Neubau.

Beispiel für einen befristeten Eintrag, falls ein Update doch nicht sofort möglich ist:

vulnerabilities:
  - id: CVE-2024-35195
    paths:
      - "requirements.txt"
    statement: "Session nutzt verify=True durchgehend. Owner team-demo, SEC-150"
    expired_at: 2026-11-30

Wichtig an der Lösung ist nicht die genaue Tabelle, sondern das Prinzip: heute grün, keine neuen Befunde, jede Ausnahme mit Owner, Ticket und Datum, und ein vorab vereinbarter Plan zur Verschärfung.

Fortschritt speichern? Kostenlos registrieren

Aus der Praxis

In einer Behörde oder einem KRITIS-Betrieb wird das Thema schnell größer als die Werkzeuge. Ein paar Muster, die sich bewähren:

Zentrale Scanner-Konfiguration. Die Security-Stage liegt nicht in jedem Projekt neu, sondern als CI-Vorlage in einem zentralen Repository und wird per include: eingebunden. Projekte dürfen Schwellen verschärfen, aber nicht lockern. Ausnahmen laufen über die Ignore-Datei im Projekt, die per Code-Owner-Regel vom Security-Team freigegeben wird.

Air-gapped Datenquellen. Trivy-DB, Java-DB, Checks-Bundle, EPSS-CSV und KEV-JSON kommen täglich über die kontrollierte Zonenübergabe (siehe Kapitel 4). Jede Übernahme wird protokolliert: Quelle, Digest, Zeitpunkt. Ein Monitoring-Check alarmiert, wenn NextUpdate in der metadata.json mehr als 48 Stunden in der Vergangenheit liegt. Eine veraltete DB ist ein stiller Ausfall: Die Pipeline bleibt grün, sieht aber nichts Neues mehr.

Fristen nach Schweregrad. Viele Organisationen orientieren sich an festen Behebungsfristen, zum Beispiel KEV oder CRITICAL innerhalb weniger Tage, HIGH innerhalb von 30 Tagen, MEDIUM im regulären Release-Zyklus. Die genauen Zahlen legt das Informationssicherheits-Management fest; wichtig ist, dass sie schriftlich vereinbart sind und das Ablaufdatum in der Ignore-Datei dazu passt.

Kontinuierlicher Scan. Ein Image, das heute sauber ist, hat morgen eine neue CVE. Deshalb scannt ein nächtlicher Job alle produktiven Image-Digests erneut, idealerweise auf Basis der SBOM in Dependency-Track (siehe Kapitel 7). So entdeckst du neue Lücken in Software, die gerade gar nicht gebaut wird.

Audit-Spur. Prüfer wollen sehen: Welche Version welches Scanners hat mit welchem DB-Stand welches Image geprüft, und wer hat welche Ausnahme genehmigt? Deshalb werden SARIF/JSON-Berichte nicht nur 30 Tage als Pipeline-Artefakt gehalten, sondern zusammen mit dem Image-Digest archiviert, oft als signierte Attestation (siehe Kapitel 5 und 11).

Mensch im Prozess. Die beste Pipeline nützt nichts, wenn niemand die Befunde ansieht. Ein fester wöchentlicher Triage-Termin mit je einer Person aus Entwicklung und Security, ein gemeinsames Board und klare Zuständigkeiten sind wirksamer als ein weiterer Scanner. Wie du diese Zusammenarbeit gestaltest, ist Thema von Kapitel 10.

Interviewfragen

F: Was ist der Unterschied zwischen SAST und SCA? A: SAST analysiert den eigenen Quellcode auf unsichere Muster, zum Beispiel Injection. SCA analysiert die eingebundenen Abhängigkeiten und vergleicht deren Versionen mit Schwachstellen-Datenbanken. SAST findet eigene Fehler, SCA bekannte Fehler in fremdem Code.

F: Warum reicht CVSS allein nicht zur Priorisierung? A: CVSS bewertet die theoretische Schwere, nicht die Wahrscheinlichkeit einer Ausnutzung. EPSS liefert diese Wahrscheinlichkeit, der KEV-Katalog zeigt tatsächlich ausgenutzte Lücken. Dazu kommt der eigene Kontext: Erreichbarkeit, genutzte Funktion, Schutzmaßnahmen.

F: Warum setzt man oft --ignore-unfixed? A: Befunde ohne verfügbaren Patch kann das Team nicht beheben. Wenn sie den Build blockieren, wird die Pipeline dauerhaft rot und verliert ihre Wirkung. Solche Befunde gehören ins Risiko-Register und werden beobachtet, bis ein Fix erscheint.

F: Wie führst du Scanner in einem Altprojekt mit hunderten Befunden ein? A: Mit einer Baseline: Den aktuellen Stand einfrieren und nur neue Befunde blockieren. Nach dem Ratchet-Prinzip wird die Baseline mit jedem behobenen Befund kleiner und nie größer. Dazu ein Plan, wann die Schwellen verschärft werden.

F: Wie betreibst du Trivy in einer air-gapped Umgebung? A: Die Trivy-DB ist ein OCI-Artefakt. Ich spiegele sie, zum Beispiel mit oras cp, über die kontrollierte Übergabe in die interne Registry und setze --db-repository auf diesen Spiegel, oder ich transportiere ein vorbefülltes Cache-Verzeichnis und nutze --skip-db-update. Die Aktualität überwache ich über die metadata.json.

F: Was gehört in eine Ausnahme für einen Scanner-Befund? A: Die genaue ID und der Pfad, eine Begründung, ein Owner, ein Ticket und ein Ablaufdatum. In Trivy geht das mit exp: in .trivyignore oder expired_at in .trivyignore.yaml. Ausnahmen werden im Review freigegeben, nicht still eingetragen.

F: Warum SARIF? A: SARIF ist ein standardisiertes JSON-Format für Analyseergebnisse. Verschiedene Scanner liefern damit einheitliche Berichte, die zentrale Triage- und Review-Werkzeuge ohne eigene Parser einlesen können.

F: Ein Scan ist grün. Ist das Image damit sicher? A: Nein. Grün heißt nur, dass der Scanner mit seinem Datenstand und seinen Regeln nichts über der Schwelle gefunden hat. False Negatives entstehen durch veraltete Datenbanken, ungepinnte Abhängigkeiten oder Software ohne Paketmetadaten. Dazu kommen Zero-Days, die noch niemand kennt.

Zusammenfassung

Das hast du gelernt:

  • SAST, SCA, Image-, IaC- und Secret-Scan prüfen unterschiedliche Dinge und gehören an unterschiedliche Stellen der Pipeline.
  • CVSS sagt, wie schlimm es wäre, EPSS, wie wahrscheinlich es ausgenutzt wird, KEV, ob es schon passiert. Dazu kommt immer der eigene Kontext.
  • Schwellenwerte wie „HIGH,CRITICAL mit Fix” halten die Pipeline aussagekräftig; Befunde ohne Fix gehören ins Risiko-Register.
  • Baseline und Ratchet-Prinzip machen Scanner auch in Altprojekten einführbar: keine neuen Befunde, Altlast nur abbauen.
  • Jede Ausnahme braucht ID, Begründung, Owner, Ticket und Ablaufdatum, in Trivy per exp: oder expired_at, in Checkov per Skip-Kommentar mit Ticketnummer.
  • Die Trivy-DB ist ein OCI-Artefakt, das du wie jedes andere Artefakt spiegeln, prüfen und auf Aktualität überwachen musst.
  • Eine gute Security-Stage erzeugt erst vollständige Berichte (SARIF/JSON) und prüft danach mit klaren, abgestuften Schwellen.