owasp-dep-scan/dep-scanScanner de vulnérabilités de dépendances de nouvelle génération avec analyse de l'accessibilité, génération de SBOM, audit des licences et analyse d'images de conteneurs pour l'intégration CI/CD.
# Introduction
OWASP dep-scan est un outil d'audit de sécurité et de risques de nouvelle génération basé sur les vulnérabilités connues, les avis de sécurité et les limitations de licence des dépendances d'un projet. Les dépôts locaux et les images de conteneurs sont pris en charge comme entrée, et l'outil est idéal pour l'intégration avec les plateformes ASPM/VM et dans les environnements 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)
## Sommaire
- [Fonctionnalités](#features)
- [Flux de données atteignables précis](#precise-reachable-data-flows)
- [Matrice d'atteignabilité](#reachability-matrix)
- [Atteignabilité Rust (via rusi)](#rust-reachability-via-rusi)
- [Atteignabilité Go (via golem)](#go-reachability-via-golem)
- [Atteignabilité .NET (via dosai)](#net-reachability-via-dosai)
- [Atteignabilité JVM, JavaScript, Python et PHP (via atom)](#jvm-javascript-python-and-php-reachability-via-atom)
- [Sources de données de vulnérabilités](#vulnerability-data-sources)
- [Distributions Linux](#linux-distros)
- [Démarrage rapide](#quick-start)
- [Analyse de projets en local (version Python)](#scanning-projects-locally-python-version)
- [Homebrew (macOS et Linux)](#homebrew-macos-and-linux)
- [Binaires autonomes (sans Python ni Node.js requis)](#standalone-binaries-no-python-or-nodejs-required)
- [Analyse de conteneurs en local (version Python)](#scanning-containers-locally-python-version)
- [Analyse de projets en local (conteneur Docker)](#scanning-projects-locally-docker-container)
- [Mode serveur](#server-mode)
- [Développement local](#local-development)
- [Documentation (depscan.readthedocs.io)](https://depscan.readthedocs.io)
- [Licence](#license)
## Fonctionnalités
- Analyser la plupart du code applicatif (dépôts locaux, images de conteneurs Linux, manifestes Kubernetes et OS) pour identifier les CVE connues avec priorisation
- Effectuer une analyse d'atteignabilité avancée pour plusieurs langages (voir la [matrice d'atteignabilité](#reachability-matrix) ci-dessous)
- L'analyse des vulnérabilités des paquets est effectuée localement et est assez rapide. Aucun serveur n'est utilisé
- Générer une nomenclature logicielle (SBOM) avec les informations du rapport de divulgation des vulnérabilités (VDR)
- Générer un document VEX au format Common Security Advisory Framework (CSAF) 2.0/2.1 (voir le [CSAF Readme](https://github.com/owasp-dep-scan/dep-scan/blob/master/contrib/CSAF_README.md))
- Effectuer un audit approfondi des risques liés aux paquets pour les attaques de confusion de dépendances et les risques de maintenance (voir la [documentation sur l'audit des risques](https://depscan.readthedocs.io/adv-usage#package-risk-audit))
### Flux de données atteignables précis
Flux de données détaillés pour identifier les chemins atteignables et non atteignables dans votre application en fonction du contexte complet.
### Matrice d'atteignabilité
dep-scan calcule l'atteignabilité pour sept écosystèmes de langages via quatre slicers. Un paquet vulnérable dont le code se trouve réellement sur un chemin exécuté est marqué **Reachable**, tandis qu'un paquet simplement déclaré dans le BOM mais jamais appelé ne l'est pas. Chaque slicer alimente le même moteur d'atteignabilité partagé, indexé par purl, de sorte que le comportement est uniforme entre les langages. L'atteignabilité est activée par défaut (`--reachability-analyzer FrameworkReachability`) ; `SemanticReachability` attribue en outre les services atteints, les points de terminaison et l'atteignabilité post-build (binaire/conteneur).
| Langage / écosystème | Moteur d'accessibilité | Analyseur par défaut |
| ---------------------------------- | ----------------------------------------------------- | ----------------------- |
| 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` |
Pour les concepts sous-jacents à l'accessibilité et à la priorisation, lisez les chapitres [modèle d'accessibilité](https://depscan.readthedocs.io/concepts/reachability-model) et [priorisation](https://depscan.readthedocs.io/concepts/prioritization). Pour des exemples concrets par langage, consultez les [Guides par langage](https://depscan.readthedocs.io/languages/rust-reachability). Pour l'aspect conformité (VDR et CSAF VEX), consultez le [guide VDR](https://depscan.readthedocs.io/output/vdr-guide) et le [guide CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide).
L'accessibilité est activée par défaut avec `--profile research`, qui est le profil utilisé par dep-scan lorsque l'accessibilité est activée. Les commandes ci-dessous suffisent pour démarrer ; les guides par langage couvrent la résolution binaire, la sécurité des backends et du réseau, les exigences de restauration, ainsi que des exemples concrets sur les fixtures du dépôt.
**Rust (rusi).** cdxgen exécute [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) et conserve son rapport, que dep-scan convertit dans le pipeline partagé, de sorte qu'un crate réellement appelé (par exemple `time::now()` pour RUSTSEC-2020-0071) est Accessible tandis qu'un crate simplement présent ne l'est pas. Consultez le [guide d'accessibilité Rust](https://depscan.readthedocs.io/languages/rust-reachability).
```bash
depscan -i ./my-rust-app -o ./reports --profile research
```
**Go (golem).** dep-scan invoque directement [golem](https://github.com/cdxgen/cdxgen-plugins-bin) pour les projets Go (nécessite `go` dans le `PATH`), en marquant un module comme Reachable lorsque ses fonctions se trouvent sur un chemin tracé. Utilisez `--go-analyzer-network offline` pour les dépôts non fiables disposant d'un cache de modules prérempli. Consultez le [guide de reachability Go](https://depscan.readthedocs.io/languages/go-reachability).
```bash
depscan -i ./my-go-app -o ./reports -t go
```
**.NET (dosai).** cdxgen exécute [dosai](https://github.com/owasp-dep-scan/dosai), qui émet un verdict explicite de joignabilité par paquet (`PackageReachability` avec `ReachabilityKind` et `Confidence`) que dep-scan traite comme faisant autorité, de sorte qu'un paquet NuGet réellement appelé (par exemple `JsonConvert.DeserializeObject` sur une entrée contrôlée) est Reachable. Analysez une arborescence restaurée pour obtenir des purls versionnés. Consultez le [guide de joignabilité .NET](https://depscan.readthedocs.io/languages/dotnet-reachability).
```bash
depscan -i ./my-dotnet-app -o ./reports -t dotnet
```
**JVM, JavaScript/TypeScript, Python et PHP (atom).** Ces quatre écosystèmes partagent le slicer [atom](https://github.com/AppThreat/atom), qui construit une représentation intermédiaire indépendante du langage et effectue un slicing statique. Voir le [guide de reachability pour JVM, JS, Python et PHP](https://depscan.readthedocs.io/languages/jvm-js-python-php-reachability).
```bash
depscan --profile research -t java -i ./my-java-app -o ./reports --explain
```
Pour aller au-delà de la reachability orientée framework vers les niveaux endpoint, service et post-build, passez `--reachability-analyzer SemanticReachability` avec un `--bom-dir` de BOM de cycle de vie. Consultez le [guide de reachability sémantique](https://depscan.readthedocs.io/analyzers/semantic-reachability).
### Des informations claires sur les CVE
Comprenez clairement les CVE sans avoir à lire la description.
### Priorisation automatique
Concentrez-vous uniquement sur les CVE qui nécessitent votre attention.
### Restez proactif
Gardez toujours une longueur d'avance grâce à la prédiction avancée des vulnérabilités et des exploits.
### Sources de données de vulnérabilités
- OSV
- NVD
- GitHub
- NPM
- Linux [vuln-list](https://github.com/appthreat/vuln-list)
### Distributions Linux
- AlmaLinux
- Debian
- Alpine
- Amazon Linux
- Arch Linux
- RHEL/CentOS
- Rocky Linux
- Ubuntu
- OpenSUSE/SLES
- Photon
- Chainguard
- Wolfi OS
## Démarrage rapide
dep-scan est idéal pour une utilisation pendant l'intégration continue (CI) et comme outil de développement local.
### Analyse de projets en local (version 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]
```
Cela installerait deux commandes appelées `cdxgen` et `depscan`.
Vous pouvez invoquer directement la commande de scan avec les différentes options.
```bash
cd <project to scan>
depscan --src $PWD --reports-dir $PWD/reports
```
La liste complète des options est ci-dessous :
```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 et Linux)
Homebrew installe le [binaire autonome](#standalone-binaries-no-python-or-nodejs-required) sous le nom `depscan` depuis le [tap OWASP dep-scan](https://github.com/owasp-dep-scan/homebrew-tap), avec cdxgen inclus et sans nécessiter Python ni Node.js. `brew trust` accepte le tap, ce que Homebrew exige avant de charger des formules depuis un tap tiers lorsque `HOMEBREW_REQUIRE_TAP_TRUST` est défini :
```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
```
### Binaires autonomes (aucun besoin de Python ni de Node.js)
Des exécutables monofichiers précompilés sont joints à chaque [version GitHub](https://github.com/owasp-dep-scan/dep-scan/releases). Ils intègrent un binaire SEA [cdxgen](https://github.com/cdxgen/cdxgen) correspondant, de sorte que la génération de BOM fonctionne immédiatement sans installer Python, Node.js ni cdxgen.
| Plateforme | Architecture | Ressource |
| --------------------- | ------------- | --------------------------- |
| 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` |
Chaque ressource dispose d'un fichier `.sha256` correspondant pour vérification.
```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]
> Les binaires macOS ne sont actuellement pas signés. Au premier lancement, Gatekeeper de macOS peut les bloquer ; supprimez l'attribut de quarantaine avec `xattr -d com.apple.quarantine ./depscan-darwin-arm64` (ou autorisez le binaire dans Réglages Système, Confidentialité et sécurité).
> [!NOTE]
> La base de données de vulnérabilités est toujours téléchargée au premier lancement. Seul cdxgen est inclus, pas la base de données de vulnérabilités. Utilisez la commande `depscan-vdb` pour sélectionner une variante spécifique de la base de données, par exemple `depscan-vdb download --scope app` pour une base de données plus petite limitée aux applications. Consultez le [guide de la base de données de vulnérabilités](https://depscan.readthedocs.io/vulnerability-database) pour la matrice complète des images.
Tous les binaires autonomes incluent `blint`, mais pas son backend de désassemblage optionnel `nyxstone` (qui n'a ni wheels ni prise en charge de Windows). L'analyse binaire approfondie basée sur le désassemblage n'est donc pas disponible dans les binaires autonomes ; utilisez le paquet Python (`pip install owasp-depscan[all]`) si vous en avez besoin.
### Analyser des conteneurs localement (version Python)
Analyser un projet Java.
```bash
depscan --src <path> -o containertests -t java
```
Analyser le tag `latest` du conteneur `shiftleft/scan-slim`
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker
```
Incluez `license` dans le type pour effectuer l'audit de licence.
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker license
```
Vous pouvez également spécifier l'image à l'aide du condensé sha256
```bash
depscan --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests -t docker
```
Vous pouvez également enregistrer les images de conteneurs à l'aide de la commande docker ou podman save et transmettre l'archive à depscan pour l'analyse.
```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
```
Reportez-vous aux tests Docker dans le workflow GitHub Actions de ce dépôt pour plus d'exemples.
### Analyse de projets en local (conteneur Docker)
L'image de conteneur `ghcr.io/owasp-dep-scan/dep-scan` peut être utilisée pour effectuer l'analyse.
Pour analyser avec les paramètres par défaut
```bash
docker run --rm -v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Pour analyser avec une configuration basée sur des variables d'environnement personnalisées
```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
```
Dans l'exemple ci-dessus, `/tmp` est monté en tant que `/db` dans le conteneur. Ce répertoire est ensuite spécifié comme `VDB_HOME` pour mettre en cache les informations sur les vulnérabilités. Ainsi, la base de données peut être mise en cache et réutilisée pour améliorer les performances.
### Mode serveur
dep-scan et cdxgen peuvent être exécutés en mode serveur. Utilisez le fichier docker-compose inclus pour commencer.
```bash
git clone https://github.com/owasp-dep-scan/dep-scan
docker compose up
```
Le fichier compose fourni définit `DEPSCAN_SERVER_API_KEY` sur une valeur de développement par défaut afin que le service dep-scan puisse se lier à `0.0.0.0`. Remplacez cette valeur avant d'exposer le service en dehors d'un laboratoire local.
```bash
depscan --server --server-host 127.0.0.1 --server-port 7070
```
Si vous devez lier dep-scan à une adresse non locale, définissez d'abord une clé 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 refuse de se lier à une adresse non locale sans soit `DEPSCAN_SERVER_API_KEY`, soit une autorisation explicite via `DEPSCAN_SERVER_ALLOW_UNAUTHENTICATED_BIND=true`.
Utilisez le point de terminaison `/scan` pour effectuer des scans.
> [!NOTE]
> Le paramètre `type` est obligatoire en mode serveur. Lorsque l'authentification par clé API est activée, envoyez la clé via `X-API-Key` ou `Authorization: Bearer <key>`.
- Analyse d'un répertoire local.
Analyse d'un fichier SBOM (présent localement).
```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
```
- Analyse d'un dépôt 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
```
- Téléverser un fichier SBOM et générer des résultats à partir de celui-ci.
```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
```
## Développement local
Installez uv en suivant la [documentation](https://docs.astral.sh/uv/) officielle.
```shell
uv sync --all-extras --all-packages
uv run depscan --help
uv run pytest
uv run pyrefly check
```
La vérification de types utilise [pyrefly](https://pyrefly.org) (la configuration se trouve dans
`[tool.pyrefly]` dans `pyproject.toml`) ; la vérification doit rapporter zéro
erreur.
### Configuration locale de la VDB
```shell
vdb --clean
vdb --download-image
# To scan containers and OS images
# vdb --download-full-image
```
### Analyse locale depscan
```shell
uv run depscan --config .config/depscan-dev.toml
```
Cela utiliserait automatiquement la configuration spécifiée dans le [fichier](https://github.com/owasp-dep-scan/dep-scan/blob/master/.config/depscan.toml) de configuration local.
## Documentation
La documentation complète se trouve sur [depscan.readthedocs.io](https://depscan.readthedocs.io). Pages clés :
- [Langages pris en charge et matrice de joignabilité](https://depscan.readthedocs.io/supported-languages)
- [Analyse de joignabilité](https://depscan.readthedocs.io/reachability-analysis) (hub)
- [Le modèle de joignabilité](https://depscan.readthedocs.io/concepts/reachability-model)
- [Comment dep-scan priorise](https://depscan.readthedocs.io/concepts/prioritization)
- [SBOM et preuves](https://depscan.readthedocs.io/concepts/sbom-and-evidence)
- Guides par langage : [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)
- Analyseurs : [Joignabilité des frameworks](https://depscan.readthedocs.io/analyzers/framework-reachability), [Joignabilité sémantique](https://depscan.readthedocs.io/analyzers/semantic-reachability)
- Sortie et conformité : [Guide VDR](https://depscan.readthedocs.io/output/vdr-guide), [Guide CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide)
- [Personnalisation via les variables d'environnement](https://depscan.readthedocs.io/env-var#customization-through-environment-variables)
- Utilisation avancée : [GitHub Security Advisory](https://depscan.readthedocs.io/adv-usage#github-security-advisory), [Mode Suggest](https://depscan.readthedocs.io/adv-usage#suggest-mode), [Audit des risques des paquets](https://depscan.readthedocs.io/adv-usage#package-risk-audit), [Analyse du système d'exploitation en direct](https://depscan.readthedocs.io/adv-usage#live-os-scan), [Analyse des licences](https://depscan.readthedocs.io/adv-usage#license-scan), [Rapports personnalisés](https://depscan.readthedocs.io/adv-usage#custom-reports)
## Licence
Licence MIT
Ce projet a été donné à la Fondation OWASP en août 2023 par AppThreat Ltd.
## Financement
Ce projet est financé par [NGI Zero Core](https://nlnet.nl/core), un fonds créé par [NLnet](https://nlnet.nl) avec le soutien financier du programme [Next Generation Internet](https://ngi.eu) de la Commission européenne. En savoir plus sur la [page du projet 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)