owasp-dep-scan/dep-scanScanner di vulnerabilità delle dipendenze di nuova generazione con analisi di raggiungibilità, generazione di SBOM, audit delle licenze e scansione delle immagini container per l'integrazione CI/CD.
# Introduzione
OWASP dep-scan è uno strumento di audit della sicurezza e dei rischi di nuova generazione basato su vulnerabilità note, avvisi e limitazioni di licenza per le dipendenze del progetto. Sono supportati come input sia repository locali che immagini container, e lo strumento è ideale per l'integrazione con piattaforme ASPM/VM e in ambienti CI.
<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)
## Contenuti
- [Funzionalità](#features)
- [Data-flow raggiungibili e precisi](#precise-reachable-data-flows)
- [Matrice di raggiungibilità](#reachability-matrix)
- [Raggiungibilità Rust (tramite rusi)](#rust-reachability-via-rusi)
- [Raggiungibilità Go (tramite golem)](#go-reachability-via-golem)
- [Raggiungibilità .NET (tramite dosai)](#net-reachability-via-dosai)
- [Raggiungibilità JVM, JavaScript, Python e PHP (tramite atom)](#jvm-javascript-python-and-php-reachability-via-atom)
- [Fonti dei dati sulle vulnerabilità](#vulnerability-data-sources)
- [Distribuzioni Linux](#linux-distros)
- [Avvio rapido](#quick-start)
- [Scansione dei progetti in locale (versione Python)](#scanning-projects-locally-python-version)
- [Homebrew (macOS e Linux)](#homebrew-macos-and-linux)
- [Binari standalone (senza Python o Node.js)](#standalone-binaries-no-python-or-nodejs-required)
- [Scansione dei container in locale (versione Python)](#scanning-containers-locally-python-version)
- [Scansione dei progetti in locale (container Docker)](#scanning-projects-locally-docker-container)
- [Modalità server](#server-mode)
- [Sviluppo locale](#local-development)
- [Documentazione (depscan.readthedocs.io)](https://depscan.readthedocs.io)
- [Licenza](#license)
## Funzionalità
- Scansiona la maggior parte del codice applicativo (repository locali, immagini container Linux, manifest Kubernetes e sistema operativo) per identificare CVE note con priorità
- Esegue analisi avanzata di raggiungibilità per più linguaggi (vedi la [matrice di raggiungibilità](#reachability-matrix) di seguito)
- La scansione delle vulnerabilità dei pacchetti viene eseguita localmente ed è piuttosto veloce. Non viene utilizzato alcun server
- Genera una Software Bill-of-Materials (SBOM) con informazioni del Vulnerability Disclosure Report (VDR)
- Genera un documento VEX Common Security Advisory Framework (CSAF) 2.0/2.1 (vedi il [CSAF Readme](https://github.com/owasp-dep-scan/dep-scan/blob/master/contrib/CSAF_README.md))
- Esegue un audit approfondito del rischio dei pacchetti per attacchi di dependency confusion e rischi di manutenzione (vedi la [documentazione sull'audit del rischio](https://depscan.readthedocs.io/adv-usage#package-risk-audit))
### Data-flow raggiungibili e precisi
Flussi di dati dettagliati per identificare sia i percorsi raggiungibili che quelli non raggiungibili nella tua applicazione in base al contesto completo.
### Matrice di raggiungibilità
dep-scan calcola la raggiungibilità per sette ecosistemi linguistici tramite quattro slicer. Un pacchetto vulnerabile il cui codice è effettivamente su un percorso eseguito viene contrassegnato come **Reachable**, mentre un pacchetto che è semplicemente dichiarato nel BOM ma mai chiamato non lo è. Ogni slicer alimenta lo stesso motore di raggiungibilità condiviso, indicizzato per purl, quindi il comportamento è uniforme tra i linguaggi. La raggiungibilità è attiva per impostazione predefinita (`--reachability-analyzer FrameworkReachability`); `SemanticReachability` attribuisce inoltre servizi, endpoint e raggiungibilità post-build (binaria/container) raggiunti.
| Linguaggio / ecosistema | Motore di reachability | Analizzatore predefinito |
| ---------------------------------- | ----------------------------------------------------- | ------------------------ |
| 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` |
Per i concetti alla base della reachability e della prioritizzazione, consulta i capitoli [modello di reachability](https://depscan.readthedocs.io/concepts/reachability-model) e [prioritizzazione](https://depscan.readthedocs.io/concepts/prioritization). Per esempi pratici per singolo linguaggio, vedi le [Guide per linguaggio](https://depscan.readthedocs.io/languages/rust-reachability). Per gli aspetti di conformità (VDR e CSAF VEX), vedi la [guida VDR](https://depscan.readthedocs.io/output/vdr-guide) e la [guida CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide).
La reachability è attiva per impostazione predefinita con `--profile research`, che è il profilo usato da dep-scan quando la reachability è abilitata. I comandi seguenti sono sufficienti per iniziare; le guide per linguaggio trattano la risoluzione dei binari, la sicurezza di backend e rete, i requisiti di restore e esempi pratici sui fixture presenti nel repository.
**Rust (rusi).** cdxgen esegue [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) e salva il suo report, che dep-scan converte nella pipeline condivisa, così un crate che viene effettivamente chiamato (ad esempio `time::now()` per RUSTSEC-2020-0071) risulta Reachable mentre uno semplicemente presente non lo è. Vedi la [guida alla reachability per Rust](https://depscan.readthedocs.io/languages/rust-reachability).
```bash
depscan -i ./my-rust-app -o ./reports --profile research
```
**Go (golem).** dep-scan invoca direttamente [golem](https://github.com/cdxgen/cdxgen-plugins-bin) per i progetti Go (richiede `go` nel `PATH`), contrassegnando un modulo come Reachable quando le sue funzioni si trovano su un percorso tracciato. Usa `--go-analyzer-network offline` per repository non attendibili con una cache dei moduli già popolata. Consulta la [guida alla reachability per Go](https://depscan.readthedocs.io/languages/go-reachability).
```bash
depscan -i ./my-go-app -o ./reports -t go
```
**.NET (dosai).** cdxgen esegue [dosai](https://github.com/owasp-dep-scan/dosai), che emette un verdetto esplicito di raggiungibilità per pacchetto (`PackageReachability` con `ReachabilityKind` e `Confidence`) che dep-scan considera autorevole, quindi un pacchetto NuGet effettivamente chiamato (ad esempio `JsonConvert.DeserializeObject` su un input controllato) risulta Reachable. Esegue la scansione di un albero ripristinato per purl versionati. Consulta la [guida alla raggiungibilità .NET](https://depscan.readthedocs.io/languages/dotnet-reachability).
```bash
depscan -i ./my-dotnet-app -o ./reports -t dotnet
```
**JVM, JavaScript/TypeScript, Python e PHP (atom).** Questi quattro ecosistemi condividono lo slicer [atom](https://github.com/AppThreat/atom), che costruisce una rappresentazione intermedia indipendente dal linguaggio ed esegue lo slicing statico. Consulta la [guida alla reachability per JVM, JS, Python e PHP](https://depscan.readthedocs.io/languages/jvm-js-python-php-reachability).
```bash
depscan --profile research -t java -i ./my-java-app -o ./reports --explain
```
Per andare oltre la reachability basata sul framework verso i livelli endpoint, servizio e post-build, passa `--reachability-analyzer SemanticReachability` con un `--bom-dir` di BOM del ciclo di vita. Consulta la [guida alla reachability semantica](https://depscan.readthedocs.io/analyzers/semantic-reachability).
### Informazioni chiare sulle CVE
Comprendi le CVE chiaramente senza dover leggere l'intera descrizione.
### Prioritizzazione automatica
Concentrati solo sulle CVE che richiedono la tua attenzione.
### Rimani proattivo
Rimani sempre un passo avanti grazie alla previsione avanzata di vulnerabilità ed exploit.
### Fonti dei dati sulle vulnerabilità
- OSV
- NVD
- GitHub
- NPM
- Linux [vuln-list](https://github.com/appthreat/vuln-list)
### Distribuzioni Linux
- AlmaLinux
- Debian
- Alpine
- Amazon Linux
- Arch Linux
- RHEL/CentOS
- Rocky Linux
- Ubuntu
- OpenSUSE/SLES
- Photon
- Chainguard
- Wolfi OS
## Avvio rapido
dep-scan è ideale per l'uso durante l'integrazione continua (CI) e come strumento di sviluppo locale.
### Scansione dei progetti in locale (versione Python)
```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]
```
Questo installerebbe due comandi chiamati `cdxgen` e `depscan`.
Puoi invocare direttamente il comando di scansione con le varie opzioni.
```bash
cd <project to scan>
depscan --src $PWD --reports-dir $PWD/reports
```
L'elenco completo delle opzioni è riportato di seguito:
```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 e Linux)
Homebrew installa il [binario standalone](#standalone-binaries-no-python-or-nodejs-required) come `depscan` dal [tap OWASP dep-scan](https://github.com/owasp-dep-scan/homebrew-tap), con cdxgen incluso e senza necessità di Python o Node.js. `brew trust` accetta il tap, che Homebrew richiede prima di caricare le formule da un tap di terze parti quando è impostata la variabile `HOMEBREW_REQUIRE_TAP_TRUST`:
```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
```
### Binari standalone (non richiedono Python o Node.js)
A ogni [release GitHub](https://github.com/owasp-dep-scan/dep-scan/releases) sono allegati eseguibili precompilati in un unico file. Includono un binario SEA [cdxgen](https://github.com/cdxgen/cdxgen) corrispondente, così la generazione del BOM funziona subito senza installare Python, Node.js o cdxgen.
| Piattaforma | Architettura | 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` |
Ogni asset ha un file `.sha256` corrispondente per la verifica.
```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]
> I binari macOS sono attualmente non firmati. Al primo avvio macOS Gatekeeper potrebbe bloccarli; rimuovi l'attributo di quarantena con `xattr -d com.apple.quarantine ./depscan-darwin-arm64` (oppure consenti il binario in Impostazioni di Sistema, Privacy e Sicurezza).
> [!NOTE]
> Il database delle vulnerabilità viene comunque scaricato al primo avvio. Solo cdxgen è incluso nel bundle, non il database delle vulnerabilità. Usa il comando `depscan-vdb` per selezionare una variante specifica del database, ad esempio `depscan-vdb download --scope app` per un database più piccolo limitato alle applicazioni. Consulta la [guida al database delle vulnerabilità](https://depscan.readthedocs.io/vulnerability-database) per la matrice completa delle immagini.
Tutti i binari standalone includono `blint`, ma non il suo backend opzionale di disassemblaggio `nyxstone` (che non dispone di wheel né di supporto Windows). L'analisi approfondita dei binari basata sul disassemblaggio non è quindi disponibile nei binari standalone; usa il pacchetto Python (`pip install owasp-depscan[all]`) se ne hai bisogno.
### Scansione locale dei container (versione Python)
Scansiona un progetto Java.
```bash
depscan --src <path> -o containertests -t java
```
Esegui la scansione del tag `latest` del container `shiftleft/scan-slim`
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker
```
Includi `license` nel tipo per eseguire l'audit della licenza.
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker license
```
Puoi anche specificare l'immagine usando il digest sha256
```bash
depscan --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests -t docker
```
Puoi anche salvare le immagini dei container usando il comando docker o podman save e passare l'archivio a depscan per la scansione.
```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
```
Per ulteriori esempi, fare riferimento ai test docker presenti nel workflow delle GitHub action di questo repository.
### Scansione dei progetti in locale (container Docker)
L'immagine container `ghcr.io/owasp-dep-scan/dep-scan` può essere utilizzata per eseguire la scansione.
Per eseguire la scansione con le impostazioni predefinite
```bash
docker run --rm -v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Per eseguire la scansione con una configurazione basata su variabili d'ambiente personalizzate
```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
```
Nell'esempio sopra, `/tmp` è montato come `/db` nel container. Questa directory viene quindi specificata come `VDB_HOME` per la cache delle informazioni sulle vulnerabilità. In questo modo il database può essere memorizzato nella cache e riutilizzato per migliorare le prestazioni.
### Modalità server
dep-scan e cdxgen possono essere eseguiti in modalità server. Utilizza il file docker-compose incluso per iniziare.
```bash
git clone https://github.com/owasp-dep-scan/dep-scan
docker compose up
```
Il file compose incluso imposta `DEPSCAN_SERVER_API_KEY` su un segnaposto di sviluppo per impostazione predefinita, in modo che il servizio dep-scan possa associarsi a `0.0.0.0`. Sovrascrivere questo valore prima di esporre il servizio al di fuori di un laboratorio locale.
```bash
depscan --server --server-host 127.0.0.1 --server-port 7070
```
Se devi associare dep-scan a un indirizzo non locale, imposta prima una chiave API:
```bash
export DEPSCAN_SERVER_API_KEY="change-this-before-production"
depscan --server --server-host 0.0.0.0 --server-port 7070
```
> [!IMPORTANT]
> dep-scan rifiuta di associarsi a un indirizzo non locale senza `DEPSCAN_SERVER_API_KEY` o un opt-in esplicito tramite `DEPSCAN_SERVER_ALLOW_UNAUTHENTICATED_BIND=true`.
Utilizza l'endpoint `/scan` per eseguire le scansioni.
> [!NOTE]
> Il parametro `type` è obbligatorio in modalità server. Quando l'autenticazione tramite API key è abilitata, invia la chiave usando `X-API-Key` o `Authorization: Bearer <key>`.
- Scansione di una directory locale.
Scansione di un file SBOM (presente localmente).
```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
```
- Scansione di un repository GitHub.
```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
```
- Caricamento di un file SBOM e generazione dei risultati sulla base di esso.
```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
```
## Sviluppo locale
Configura uv seguendo la [documentazione](https://docs.astral.sh/uv/) ufficiale.
```shell
uv sync --all-extras --all-packages
uv run depscan --help
uv run pytest
uv run pyrefly check
```
Il controllo dei tipi utilizza [pyrefly](https://pyrefly.org) (la configurazione si trova in
`[tool.pyrefly]` in `pyproject.toml`); si prevede che il controllo non riporti
errori.
### Configurazione locale del VDB
```shell
vdb --clean
vdb --download-image
# To scan containers and OS images
# vdb --download-full-image
```
### Scansione locale di depscan
```shell
uv run depscan --config .config/depscan-dev.toml
```
Questo utilizzerebbe automaticamente la configurazione specificata nel [file](https://github.com/owasp-dep-scan/dep-scan/blob/master/.config/depscan.toml) di configurazione locale.
## Documentazione
La documentazione completa è disponibile su [depscan.readthedocs.io](https://depscan.readthedocs.io). Pagine principali:
- [Linguaggi supportati e matrice di raggiungibilità](https://depscan.readthedocs.io/supported-languages)
- [Analisi di raggiungibilità](https://depscan.readthedocs.io/reachability-analysis) (hub)
- [Il modello di raggiungibilità](https://depscan.readthedocs.io/concepts/reachability-model)
- [Come dep-scan assegna le priorità](https://depscan.readthedocs.io/concepts/prioritization)
- [SBOM ed evidenze](https://depscan.readthedocs.io/concepts/sbom-and-evidence)
- Guide per linguaggio: [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)
- Analizzatori: [Raggiungibilità dei framework](https://depscan.readthedocs.io/analyzers/framework-reachability), [Raggiungibilità semantica](https://depscan.readthedocs.io/analyzers/semantic-reachability)
- Output e conformità: [Guida VDR](https://depscan.readthedocs.io/output/vdr-guide), [Guida CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide)
- [Personalizzazione tramite variabili d'ambiente](https://depscan.readthedocs.io/env-var#customization-through-environment-variables)
- Utilizzo avanzato: [GitHub Security Advisory](https://depscan.readthedocs.io/adv-usage#github-security-advisory), [Modalità suggest](https://depscan.readthedocs.io/adv-usage#suggest-mode), [Audit del rischio dei pacchetti](https://depscan.readthedocs.io/adv-usage#package-risk-audit), [Scansione del sistema operativo live](https://depscan.readthedocs.io/adv-usage#live-os-scan), [Scansione delle licenze](https://depscan.readthedocs.io/adv-usage#license-scan), [Report personalizzati](https://depscan.readthedocs.io/adv-usage#custom-reports)
## Licenza
Licenza MIT
Questo progetto è stato donato alla OWASP Foundation nell'agosto 2023 da AppThreat Ltd.
## Finanziamento
Questo progetto è finanziato tramite [NGI Zero Core](https://nlnet.nl/core), un fondo istituito da [NLnet](https://nlnet.nl) con il supporto finanziario del programma [Next Generation Internet](https://ngi.eu) della Commissione Europea. Scopri di più sulla [pagina del progetto NLnet](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)