owasp-dep-scan/dep-scanNext-Generation-Abhängigkeits-Schwachstellenscanner mit Erreichbarkeitsanalyse, SBOM-Generierung, Lizenzaudit und Container-Image-Scanning für die CI/CD-Integration.
# Einführung
OWASP dep-scan ist ein Sicherheits- und Risikoaudit-Tool der nächsten Generation, das auf bekannten Schwachstellen, Advisories und Lizenzbeschränkungen für Projektabhängigkeiten basiert. Als Eingabe werden sowohl lokale Repositories als auch Container-Images unterstützt, und das Tool eignet sich ideal für die Integration in ASPM/VM-Plattformen und in CI-Umgebungen.
<img src="https://assets.kitploit.com/production/public/readmes/6282/1f4ac5f4ee45d7e9ba8026acc4ae2458bdf23f5e9119eb9f85536cf101d0e56f.png" width="200" height="auto" />
[](https://github.com/cdxgen/cdxgen) [](https://github.com/owasp-dep-scan/dep-scan/actions/workflows/pythonpublish.yml)
## Inhalt
- [Funktionen](#funktionen)
- [Präzise erreichbare Datenflüsse](#präzise-erreichbare-datenflüsse)
- [Erreichbarkeitsmatrix](#erreichbarkeitsmatrix)
- [Rust-Erreichbarkeit (über rusi)](#rust-erreichbarkeit-über-rusi)
- [Go-Erreichbarkeit (über golem)](#go-erreichbarkeit-über-golem)
- [.NET-Erreichbarkeit (über dosai)](#net-erreichbarkeit-über-dosai)
- [JVM-, JavaScript-, Python- und PHP-Erreichbarkeit (über atom)](#jvm-javascript-python-und-php-erreichbarkeit-über-atom)
- [Datenquellen für Schwachstellen](#datenquellen-für-schwachstellen)
- [Linux-Distributionen](#linux-distributionen)
- [Schnellstart](#schnellstart)
- [Projekte lokal scannen (Python-Version)](#projekte-lokal-scannen-python-version)
- [Homebrew (macOS und Linux)](#homebrew-macos-und-linux)
- [Eigenständige Binärdateien (kein Python oder Node.js erforderlich)](#eigenständige-binärdateien-kein-python-oder-nodejs-erforderlich)
- [Container lokal scannen (Python-Version)](#container-lokal-scannen-python-version)
- [Projekte lokal scannen (Docker-Container)](#projekte-lokal-scannen-docker-container)
- [Servermodus](#servermodus)
- [Lokale Entwicklung](#lokale-entwicklung)
- [Dokumentation (depscan.readthedocs.io)](https://depscan.readthedocs.io)
- [Lizenz](#lizenz)
## Funktionen
- Die meisten Anwendungscodes scannen (lokale Repositories, Linux-Container-Images, Kubernetes-Manifeste und Betriebssystem), um bekannte CVEs mit Priorisierung zu identifizieren
- Fortgeschrittene Erreichbarkeitsanalyse für mehrere Sprachen durchführen (siehe die [Erreichbarkeitsmatrix](#erreichbarkeitsmatrix) unten)
- Das Scannen von Paketschwachstellen erfolgt lokal und ist recht schnell. Es wird kein Server verwendet
- Eine Software Bill-of-Materials (SBOM) mit Informationen aus dem Vulnerability Disclosure Report (VDR) generieren
- Ein Common Security Advisory Framework (CSAF) 2.0/2.1 VEX-Dokument generieren (siehe [CSAF Readme](https://github.com/owasp-dep-scan/dep-scan/blob/master/contrib/CSAF_README.md))
- Ein tiefgehendes Risikoaudit für Pakete auf Dependency-Confusion-Angriffe und Wartungsrisiken durchführen (siehe [Risk-Audit-Dokumentation](https://depscan.readthedocs.io/adv-usage#package-risk-audit))
### Präzise erreichbare Datenflüsse
Detaillierte Datenflüsse zur Identifizierung sowohl erreichbarer als auch nicht erreichbarer Pfade in Ihrer Anwendung auf Basis des vollständigen Kontexts.
### Erreichbarkeitsmatrix
dep-scan berechnet die Erreichbarkeit für sieben Sprach-Ökosysteme über vier Slicer. Ein verwundbares Paket, dessen Code tatsächlich auf einem ausgeführten Pfad liegt, wird als **Reachable** (erreichbar) markiert, während ein Paket, das lediglich in der BOM deklariert, aber nie aufgerufen wird, nicht als solches markiert wird. Jeder Slicer speist dieselbe gemeinsame, purl-basierte Erreichbarkeits-Engine, sodass das Verhalten über alle Sprachen hinweg einheitlich ist. Die Erreichbarkeit ist standardmäßig aktiviert (`--reachability-analyzer FrameworkReachability`); `SemanticReachability` ordnet zusätzlich erreichte Dienste, Endpunkte und die Erreichbarkeit nach dem Build (Binärdatei/Container) zu.
| Sprache / Ökosystem | Reachability-Engine | Standard-Analyzer |
| ---------------------------------- | ----------------------------------------------------- | ----------------------- |
| Java / JVM (Groovy, Kotlin, Scala) | [atom](https://github.com/AppThreat/atom) | `FrameworkReachability` |
| JavaScript / TypeScript | atom | `FrameworkReachability` |
| Python | atom | `FrameworkReachability` |
| PHP | atom | `FrameworkReachability` |
| Rust | [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) | `FrameworkReachability` |
| Go | [golem](https://github.com/cdxgen/cdxgen-plugins-bin) | `FrameworkReachability` |
| .NET (C#, VB, F#, R) | [dosai](https://github.com/owasp-dep-scan/dosai) | `FrameworkReachability` |
Für die Konzepte hinter Reachability und Priorisierung lesen Sie die Kapitel [Reachability-Modell](https://depscan.readthedocs.io/concepts/reachability-model) und [Priorisierung](https://depscan.readthedocs.io/concepts/prioritization). Ausgearbeitete Beispiele pro Sprache finden Sie in den [Sprachleitfäden](https://depscan.readthedocs.io/languages/rust-reachability). Zur Compliance-Darstellung (VDR und CSAF VEX) siehe den [VDR-Leitfaden](https://depscan.readthedocs.io/output/vdr-guide) und den [CSAF-VEX-Leitfaden](https://depscan.readthedocs.io/output/vex-csaf-guide).
Reachability ist standardmäßig unter `--profile research` aktiviert, was dep-scan verwendet, wenn Reachability eingeschaltet ist. Die folgenden Befehle reichen für den Einstieg aus; die Sprachleitfäden behandeln Binärdatei-Auflösung, Backend- und Netzwerksicherheit, Wiederherstellungsanforderungen und ausgearbeitete Beispiele anhand der Fixtures im Repository.
**Rust (rusi).** cdxgen führt [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) aus und speichert dessen Bericht, den dep-scan in die gemeinsame Pipeline umwandelt, sodass ein Crate, das tatsächlich aufgerufen wird (zum Beispiel `time::now()` für RUSTSEC-2020-0071), als Reachable gilt, während ein bloß vorhandenes dies nicht ist. Siehe den [Rust-Reachability-Leitfaden](https://depscan.readthedocs.io/languages/rust-reachability).
```bash
depscan -i ./my-rust-app -o ./reports --profile research
```
**Go (golem).** dep-scan ruft [golem](https://github.com/cdxgen/cdxgen-plugins-bin) für Go-Projekte direkt auf (erfordert `go` im `PATH`) und markiert ein Modul als Reachable, wenn seine Funktionen auf einem verfolgten Pfad liegen. Verwenden Sie `--go-analyzer-network offline` für nicht vertrauenswürdige Repositories mit einem vorgewärmten Modul-Cache. Siehe die [Go-Reachability-Anleitung](https://depscan.readthedocs.io/languages/go-reachability).
```bash
depscan -i ./my-go-app -o ./reports -t go
```
**.NET (dosai).** cdxgen führt [dosai](https://github.com/owasp-dep-scan/dosai) aus, das ein explizites Erreichbarkeitsurteil pro Paket ausgibt (`PackageReachability` mit `ReachabilityKind` und `Confidence`), das dep-scan als maßgeblich behandelt, sodass ein tatsächlich aufgerufenes NuGet-Paket (zum Beispiel `JsonConvert.DeserializeObject` bei einer kontrollierten Eingabe) als Reachable gilt. Durchsuchen Sie einen wiederhergestellten Baum nach versionierten purls. Siehe den [.NET-Reachability-Leitfaden](https://depscan.readthedocs.io/languages/dotnet-reachability).
```bash
depscan -i ./my-dotnet-app -o ./reports -t dotnet
```
**JVM, JavaScript/TypeScript, Python und PHP (atom).** Diese vier Ökosysteme nutzen gemeinsam den [atom](https://github.com/AppThreat/atom)-Slicer, der eine sprachunabhängige Zwischendarstellung erzeugt und statisches Slicing durchführt. Siehe die [Reachability-Anleitung für JVM, JS, Python und PHP](https://depscan.readthedocs.io/languages/jvm-js-python-php-reachability).
```bash
depscan --profile research -t java -i ./my-java-app -o ./reports --explain
```
Um über die framework-orientierte Erreichbarkeit hinaus zu Endpoint-, Service- und Post-Build-Ebenen zu gelangen, übergeben Sie `--reachability-analyzer SemanticReachability` mit einem `--bom-dir` von Lifecycle-BOMs. Siehe den [Leitfaden zur semantischen Erreichbarkeit](https://depscan.readthedocs.io/analyzers/semantic-reachability).
### Klare Einblicke in CVEs
Verstehen Sie CVEs klar, ohne die Beschreibung durchlesen zu müssen.
### Automatische Priorisierung
Konzentrieren Sie sich nur auf CVEs, die Ihre Aufmerksamkeit erfordern.
### Bleiben Sie proaktiv
Bleiben Sie mit fortschrittlicher Schwachstellen- und Exploit-Vorhersage immer einen Schritt voraus.
### Datenquellen für Schwachstellen
- OSV
- NVD
- GitHub
- NPM
- Linux [vuln-list](https://github.com/appthreat/vuln-list)
### Linux-Distributionen
- AlmaLinux
- Debian
- Alpine
- Amazon Linux
- Arch Linux
- RHEL/CentOS
- Rocky Linux
- Ubuntu
- OpenSUSE/SLES
- Photon
- Chainguard
- Wolfi OS
## Schnellstart
dep-scan ist ideal für den Einsatz während der kontinuierlichen Integration (CI) und als lokales Entwicklungswerkzeug geeignet.
### Projekte lokal scannen (Python-Version)
```bash
sudo npm install -g @cyclonedx/cdxgen
# Normal version recommended for most users (MIT)
pip install owasp-depscan
# For a full version with all extensions and server mode (Multiple Licenses)
pip install owasp-depscan[all]
```
Dadurch würden zwei Befehle namens `cdxgen` und `depscan` installiert.
Sie können den Scan-Befehl direkt mit den verschiedenen Optionen aufrufen.
```bash
cd <project to scan>
depscan --src $PWD --reports-dir $PWD/reports
```
Die vollständige Liste der Optionen ist unten aufgeführt:
```text
usage: depscan [-h] [--config CONFIG] [--no-banner] [-i SRC_DIR_IMAGE] [-o REPORTS_DIR] [--csaf]
[--profile {appsec,research,operational,threat-modeling,license-compliance,generic,machine-learning,ml,deep-learning,ml-deep,ml-tiny}]
[--lifecycle {pre-build,build,post-build} [{pre-build,build,post-build} ...]]
[--technique {auto,source-code-analysis,binary-analysis,manifest-analysis,hash-comparison,instrumentation,filename} [{auto,source-code-analysis,binary-analysis,manifest-analysis,hash-comparison,instrumentation,filename} ...]]
[--bom-engine {auto,CdxgenGenerator,CdxgenServerGenerator,CdxgenImageBasedGenerator,BlintGenerator} |
--vulnerability-analyzer {auto,VDRAnalyzer,LifecycleAnalyzer}] [--reachability-analyzer {off,FrameworkReachability,SemanticReachability}] [--no-suggest]
[--risk-audit] [--cdxgen-args CDXGEN_ARGS] [--private-ns PRIVATE_NS] [-t PROJECT_TYPE [PROJECT_TYPE ...]] [--bom BOM | --bom-dir BOM_DIR | --purl SEARCH_PURL]
[--report-template REPORT_TEMPLATE] [--report-name REPORT_NAME] [--deep] [--fuzzy-search] [--search-order {purl,pcu,cpe,cpu,url}] [--no-universal]
[--no-vuln-table] [--server] [--server-host SERVER_HOST] [--server-port SERVER_PORT] [--cdxgen-server CDXGEN_SERVER] [--debug] [-q | --explain] [-v]
Fully open-source security and license audit for application dependencies and container images based on known vulnerabilities and advisories.
options:
-h, --help show this help message and exit
--config CONFIG Path to the configuration file. Default: $PWD/.config/depscan.toml
--no-banner Do not display the logo and donation banner. Please make a donation to OWASP before using this argument.
-i, --src SRC_DIR_IMAGE
Source directory or container image or binary file
-o, --reports-dir REPORTS_DIR
Reports directory
--csaf Generate a OASIS CSAF VEX document
--profile {appsec,research,operational,threat-modeling,license-compliance,generic,machine-learning,ml,deep-learning,ml-deep,ml-tiny}
Profile to use while generating the BOM. For granular control, use the arguments --bom-engine, --vulnerability-analyzer, or --reachability-analyzer.
--lifecycle {pre-build,build,post-build} [{pre-build,build,post-build} ...]
Product lifecycle for the generated BOM. Multiple values allowed.
--technique {auto,source-code-analysis,binary-analysis,manifest-analysis,hash-comparison,instrumentation,filename} [{auto,source-code-analysis,binary-analysis,manifest-analysis,hash-comparison,instrumentation,filename} ...]
Analysis technique to use for BOM generation. Multiple values allowed.
--bom-engine {auto,CdxgenGenerator,CdxgenServerGenerator,CdxgenImageBasedGenerator,BlintGenerator}
BOM generation engine to use. Defaults to automatic selection based on project type and lifecycle.
--vulnerability-analyzer {auto,VDRAnalyzer,LifecycleAnalyzer}
Vulnerability analyzer to use. Defaults to automatic selection based on bom_dir argument.
--reachability-analyzer {off,FrameworkReachability,SemanticReachability}
Reachability analyzer to use. Default FrameworkReachability.
--no-suggest Disable suggest mode
--risk-audit Perform package risk audit (slow operation). Npm only.
--cdxgen-args CDXGEN_ARGS
Additional arguments to pass to cdxgen
--private-ns PRIVATE_NS
Private namespace to use while performing oss risk audit. Private packages should not be available in public registries by default. Comma separated
values accepted.
-t, --type PROJECT_TYPE [PROJECT_TYPE ...]
Override project types if auto-detection is incorrect. Multiple values supported.
--bom BOM Examine using the given Software Bill-of-Materials (SBOM) file in CycloneDX format. Use cdxgen command to produce one.
--bom-dir BOM_DIR Examine all the Bill-of-Materials (BOM) files in the given directory.
--purl SEARCH_PURL Scan a single package url.
--custom-data CUSTOM_DATA
Path to directory containing custom vulnerability data (JSON/YAML/TOML) to override/augment results.
--report-template REPORT_TEMPLATE
Jinja template file used for rendering a custom report
--report-name REPORT_NAME
Filename of the custom report written to the --reports-dir
--deep Perform deep scan by passing this --deep argument to cdxgen. Useful while scanning docker images and OS packages.
--fuzzy-search Perform fuzzy search by creating variations of package names. Use this when the input SBOM lacks a PURL.
--search-order {purl,pcu,cpe,cpu,url}
Attributes to use while searching for vulnerabilities. Default: PURL, CPE, URL (pcu).
--no-universal Depscan would attempt to perform a single universal scan instead of individual scans per language type.
--no-vuln-table Do not print the table with the full list of vulnerabilities. This can help reduce console output.
--server Run depscan as a server
--server-host SERVER_HOST
depscan server host
--server-port SERVER_PORT
depscan server port
--server-allowed-hosts [SERVER_ALLOWED_HOSTS ...]
List of allowed hostnames or IPs that can access the server (e.g., 'localhost 192.168.1.10'). If unspecified, no host allowlist is
enforced.
--server-allowed-paths [SERVER_ALLOWED_PATHS ...]
List of allowed filesystem paths that can be scanned by the server. Restricts `path` parameter in /scan requests.
--cdxgen-server CDXGEN_SERVER
cdxgen server url. Eg: http://cdxgen:9090
--debug Run depscan in debug mode.
-q, --quiet Makes depscan quiet.
--explain Makes depscan to explain the various analysis. Useful for creating detailed reports.
--explanation-mode {Endpoints,EndpointsAndReachables,NonReachables,LLMPrompts}
Style of explanation needed. Defaults to Endpoints and Reachables.
--annotate Include the generated text VDR report as an annotation. Defaults to true when explain is enabled; false otherwise.
-v, --version Display the version
```
### Homebrew (macOS und Linux)
Homebrew installiert die [Standalone-Binary](#standalone-binaries-no-python-or-nodejs-required) als `depscan` aus dem [OWASP dep-scan Tap](https://github.com/owasp-dep-scan/homebrew-tap), wobei cdxgen mitgeliefert wird und weder Python noch Node.js benötigt werden. `brew trust` akzeptiert den Tap, den Homebrew vor dem Laden von Formulae aus einem Drittanbieter-Tap verlangt, wenn `HOMEBREW_REQUIRE_TAP_TRUST` gesetzt ist:
```bash
brew tap owasp-dep-scan/tap
brew trust --tap owasp-dep-scan/tap
brew install dep-scan
depscan --src $PWD --reports-dir $PWD/reports
```
### Standalone-Binaries (kein Python oder Node.js erforderlich)
Vorgefertigte Einzeldatei-Executables sind an jedes [GitHub-Release](https://github.com/owasp-dep-scan/dep-scan/releases) angehängt. Sie bündeln eine passende [cdxgen](https://github.com/cdxgen/cdxgen) SEA-Binary, sodass die BOM-Generierung sofort funktioniert, ohne Python, Node.js oder cdxgen installieren zu müssen.
| Plattform | Architektur | Asset |
| --------------------- | ------------- | --------------------------- |
| Linux (glibc) | x86_64 | `depscan-linux-amd64` |
| Linux (glibc) | arm64 | `depscan-linux-arm64` |
| Linux (musl / Alpine) | x86_64 | `depscan-linux-amd64-musl` |
| Linux (musl / Alpine) | arm64 | `depscan-linux-arm64-musl` |
| macOS | Apple silicon | `depscan-darwin-arm64` |
| macOS | Intel | `depscan-darwin-amd64` |
| Windows | x86_64 | `depscan-windows-amd64.exe` |
Jedes Asset hat eine passende `.sha256`-Datei zur Verifizierung.
```bash
# Example: Linux x86_64
curl -LO https://github.com/owasp-dep-scan/dep-scan/releases/latest/download/depscan-linux-amd64
curl -LO https://github.com/owasp-dep-scan/dep-scan/releases/latest/download/depscan-linux-amd64.sha256
sha256sum -c depscan-linux-amd64.sha256
chmod +x depscan-linux-amd64
./depscan-linux-amd64 --src $PWD --reports-dir $PWD/reports
```
> [!NOTE]
> Die macOS-Binaries sind derzeit nicht signiert. Beim ersten Start kann macOS Gatekeeper sie blockieren; entferne das Quarantäne-Attribut mit `xattr -d com.apple.quarantine ./depscan-darwin-arm64` (oder erlaube das Binary unter Systemeinstellungen, Datenschutz & Sicherheit).
> [!NOTE]
> Die Schwachstellendatenbank wird weiterhin beim ersten Start heruntergeladen. Nur cdxgen ist gebündelt, nicht die Vuln-DB. Verwende den Befehl `depscan-vdb`, um eine bestimmte Datenbankvariante auszuwählen, zum Beispiel `depscan-vdb download --scope app` für eine kleinere, nur auf Apps beschränkte Datenbank. Siehe den [Leitfaden zur Schwachstellendatenbank](https://depscan.readthedocs.io/vulnerability-database) für die vollständige Image-Matrix.
Alle eigenständigen Binaries bündeln `blint`, jedoch nicht dessen optionales `nyxstone`-Disassembly-Backend (für das es keine Wheels und keine Windows-Unterstützung gibt). Eine tiefgehende, disassembly-basierte Binäranalyse ist daher in den eigenständigen Binaries nicht verfügbar; verwende das Python-Paket (`pip install owasp-depscan[all]`), wenn du sie benötigst.
### Container lokal scannen (Python-Version)
Ein Java-Projekt scannen.
```bash
depscan --src <path> -o containertests -t java
```
Scanne das `latest`-Tag des Containers `shiftleft/scan-slim`
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker
```
Fügen Sie `license` zum Typ hinzu, um das Lizenzaudit durchzuführen.
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker license
```
Sie können das Image auch über den sha256-Digest angeben
```bash
depscan --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests -t docker
```
Sie können Container-Images auch mit dem Befehl docker oder podman save speichern und das Archiv zur Überprüfung an depscan übergeben.
```bash
docker save -o /tmp/scanslim.tar shiftleft/scan-slim:latest
# podman save --format oci-archive -o /tmp/scanslim.tar shiftleft/scan-slim:latest
depscan --src /tmp/scanslim.tar -o reports -t docker
```
Weitere Beispiele finden Sie in den Docker-Tests unter dem GitHub-Action-Workflow für dieses Repository.
### Projekte lokal scannen (Docker-Container)
Das Container-Image `ghcr.io/owasp-dep-scan/dep-scan` kann verwendet werden, um den Scan durchzuführen.
Um mit den Standardeinstellungen zu scannen
```bash
docker run --rm -v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Zum Scannen mit einer Konfiguration auf Basis benutzerdefinierter Umgebungsvariablen
```bash
docker run --rm \
-e VDB_HOME=/db \
-e GITHUB_TOKEN=<token> \
-v /tmp:/db \
-v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Im obigen Beispiel wird `/tmp` als `/db` in den Container eingebunden. Dieses Verzeichnis wird dann als `VDB_HOME` für das Caching der Schwachstelleninformationen angegeben. Auf diese Weise kann die Datenbank zwischengespeichert und wiederverwendet werden, um die Leistung zu verbessern.
### Servermodus
dep-scan und cdxgen können im Servermodus ausgeführt werden. Verwenden Sie die mitgelieferte docker-compose-Datei, um zu beginnen.
```bash
git clone https://github.com/owasp-dep-scan/dep-scan
docker compose up
```
Die mitgelieferte Compose-Datei setzt `DEPSCAN_SERVER_API_KEY` standardmäßig auf einen Entwicklungs-Platzhalter, damit der dep-scan-Dienst an `0.0.0.0` binden kann. Überschreiben Sie diesen Wert, bevor Sie den Dienst außerhalb eines lokalen Labors bereitstellen.
```bash
depscan --server --server-host 127.0.0.1 --server-port 7070
```
Wenn Sie dep-scan an eine nicht-lokale Adresse binden müssen, legen Sie zuerst einen API-Schlüssel fest:
```bash
export DEPSCAN_SERVER_API_KEY="change-this-before-production"
depscan --server --server-host 0.0.0.0 --server-port 7070
```
> [!IMPORTANT]
> dep-scan weigert sich, an eine nicht-lokale Adresse zu binden, ohne dass entweder `DEPSCAN_SERVER_API_KEY` oder eine ausdrückliche Zustimmung über `DEPSCAN_SERVER_ALLOW_UNAUTHENTICATED_BIND=true` gesetzt ist.
Verwenden Sie den `/scan`-Endpunkt, um Scans durchzuführen.
> [!NOTE]
> Der Parameter `type` ist im Servermodus verpflichtend. Wenn die API-Schlüssel-Authentifizierung aktiviert ist, senden Sie den Schlüssel über `X-API-Key` oder `Authorization: Bearer <key>`.
- Scannen eines lokalen Verzeichnisses.
Scannen einer SBOM-Datei (lokal vorhanden).
```bash
curl \
-H 'X-API-Key: dev-only-change-me' \
--json '{"path": "/tmp/vulnerable-aws-koa-app/sbom_file.json", "type": "js"}' \
http://127.0.0.1:7070/scan
```
- Scannen eines GitHub-Repos.
```bash
curl \
-H 'Authorization: Bearer dev-only-change-me' \
--json '{"url": "https://github.com/HooliCorp/vulnerable-aws-koa-app", "type": "js"}' \
http://127.0.0.1:7070/scan \
-o app.vdr.json
```
- Hochladen einer SBOM-Datei und Generieren von Ergebnissen auf deren Grundlage.
```bash
curl -X POST \
-H 'X-API-Key: dev-only-change-me' \
-H 'Content-Type: multipart/form-data' \
-F 'file=@/tmp/app/sbom_file.json' \
http://127.0.0.1:7070/scan?type=js
```
## Lokale Entwicklung
Richte uv gemäß der offiziellen [Dokumentation](https://docs.astral.sh/uv/) ein.
```shell
uv sync --all-extras --all-packages
uv run depscan --help
uv run pytest
uv run pyrefly check
```
Die Typprüfung verwendet [pyrefly](https://pyrefly.org) (die Konfiguration befindet sich in
`[tool.pyrefly]` in `pyproject.toml`); die Prüfung soll null
Fehler melden.
### Lokale VDB-Einrichtung
```shell
vdb --clean
vdb --download-image
# To scan containers and OS images
# vdb --download-full-image
```
### Lokale Abhängigkeiten mit depscan scannen
```shell
uv run depscan --config .config/depscan-dev.toml
```
Dadurch wird automatisch die in der lokalen Konfigurationsdatei [file](https://github.com/owasp-dep-scan/dep-scan/blob/master/.config/depscan.toml) angegebene Konfiguration verwendet.
## Dokumentation
Die vollständige Dokumentation befindet sich unter [depscan.readthedocs.io](https://depscan.readthedocs.io). Wichtige Seiten:
- [Unterstützte Sprachen und Reachability-Matrix](https://depscan.readthedocs.io/supported-languages)
- [Reachability-Analyse](https://depscan.readthedocs.io/reachability-analysis) (Hub)
- [Das Reachability-Modell](https://depscan.readthedocs.io/concepts/reachability-model)
- [Wie dep-scan priorisiert](https://depscan.readthedocs.io/concepts/prioritization)
- [SBOM und Evidenz](https://depscan.readthedocs.io/concepts/sbom-and-evidence)
- Sprachleitfäden: [Rust](https://depscan.readthedocs.io/languages/rust-reachability), [Go](https://depscan.readthedocs.io/languages/go-reachability), [.NET](https://depscan.readthedocs.io/languages/dotnet-reachability), [JVM/JS/Python/PHP](https://depscan.readthedocs.io/languages/jvm-js-python-php-reachability)
- Analyzer: [Framework-Reachability](https://depscan.readthedocs.io/analyzers/framework-reachability), [Semantische Reachability](https://depscan.readthedocs.io/analyzers/semantic-reachability)
- Ausgabe und Compliance: [VDR-Leitfaden](https://depscan.readthedocs.io/output/vdr-guide), [CSAF-VEX-Leitfaden](https://depscan.readthedocs.io/output/vex-csaf-guide)
- [Anpassung über Umgebungsvariablen](https://depscan.readthedocs.io/env-var#customization-through-environment-variables)
- Erweiterte Nutzung: [GitHub Security Advisory](https://depscan.readthedocs.io/adv-usage#github-security-advisory), [Suggest-Modus](https://depscan.readthedocs.io/adv-usage#suggest-mode), [Package-Risk-Audit](https://depscan.readthedocs.io/adv-usage#package-risk-audit), [Live-OS-Scan](https://depscan.readthedocs.io/adv-usage#live-os-scan), [Lizenz-Scan](https://depscan.readthedocs.io/adv-usage#license-scan), [Benutzerdefinierte Berichte](https://depscan.readthedocs.io/adv-usage#custom-reports)
## Lizenz
MIT-Lizenz
Dieses Projekt wurde im August 2023 von AppThreat Ltd. an die OWASP Foundation gespendet.
## Förderung
Dieses Projekt wird durch [NGI Zero Core](https://nlnet.nl/core) gefördert, einen von [NLnet](https://nlnet.nl) eingerichteten Fonds mit finanzieller Unterstützung aus dem Programm [Next Generation Internet](https://ngi.eu) der Europäischen Kommission. Weitere Informationen auf der [NLnet-Projektseite](https://nlnet.nl/project/OWASP-dep-scan).
[<img src="https://assets.kitploit.com/production/public/readmes/6282/0a90ce2437c2c6d5609888b393ff1dd7f449dfc396d9a15484ddb51d849646a9.png" alt="NLnet foundation logo" width="20%" />](https://nlnet.nl)
[<img src="https://nlnet.nl/image/logos/NGI0_tag.svg" alt="NGI Zero Logo" width="20%" />](https://nlnet.nl/core)