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
securityzusammensetzt
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-baselineschreibt 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:
- DB als OCI-Artefakt spiegeln: Auf der
Internet-Seite kopierst du
trivy-db:2mitoras cpin deinen Registry-Spiegel (Harbor, Nexus, siehe Kapitel 3). Trivy zeigt mit--db-repositoryauf diesen Spiegel. - Cache-Verzeichnis transportieren: Du lädst die DB
einmal mit
trivy image --download-db-onlyin 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"
lsErwartete Ausgabe (Reihenfolge kann abweichen):
Dockerfile app.py k8s requirements.txt
Prüfe, dass die Werkzeuge da sind:
semgrep --version && trivy --version | head -1 && checkov --versionDu 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ürdehostzusä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.1Erwartet: 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.jsonErwartete 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.jsonTipp:
trivy convertgibt 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 --quietErwartet: 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 beimisconfigurationsdie 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-144In 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.jsonErwartet: 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/dbErwartet: 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.jsonIn 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-Regelbundletrivy-checks(Flag--checks-bundle-repository). Mit--skip-java-db-updateund--skip-check-updateverhinderst du Download-Versuche. Das Flag--offline-scanunterbindet 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.ymlErwartet: 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:reportsliegen (zum Beispielsastodercontainer_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.1Die 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:
- Lege für jeden Scanner einen Schwellenwert fest, der heute grün ist, aber neue Probleme sofort stoppt.
- Erstelle eine
.trivyignore.yamlfür einen begründeten, befristeten Eintrag. - 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-30Wichtig 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:oderexpired_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.