owasp-dep-scan/dep-scanEscáner de vulnerabilidades de dependencias de última generación con análisis de alcanzabilidad, generación de SBOM, auditoría de licencias y escaneo de imágenes de contenedores para integración CI/CD.
# Introducción
OWASP dep-scan es una herramienta de auditoría de seguridad y riesgos de nueva generación basada en vulnerabilidades conocidas, avisos y limitaciones de licencia para las dependencias del proyecto. Se admiten tanto repositorios locales como imágenes de contenedor como entrada, y la herramienta es ideal para la integración con plataformas ASPM/VM y en entornos de 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)
## Contenido
- [Características](#features)
- [Flujos de datos alcanzables precisos](#precise-reachable-data-flows)
- [Matriz de alcanzabilidad](#reachability-matrix)
- [Alcanzabilidad en Rust (mediante rusi)](#rust-reachability-via-rusi)
- [Alcanzabilidad en Go (mediante golem)](#go-reachability-via-golem)
- [Alcanzabilidad en .NET (mediante dosai)](#net-reachability-via-dosai)
- [Alcanzabilidad en JVM, JavaScript, Python y PHP (mediante atom)](#jvm-javascript-python-and-php-reachability-via-atom)
- [Fuentes de datos de vulnerabilidades](#vulnerability-data-sources)
- [Distribuciones de Linux](#linux-distros)
- [Inicio rápido](#quick-start)
- [Escaneo de proyectos localmente (versión Python)](#scanning-projects-locally-python-version)
- [Homebrew (macOS y Linux)](#homebrew-macos-and-linux)
- [Binarios autónomos (sin necesidad de Python ni Node.js)](#standalone-binaries-no-python-or-nodejs-required)
- [Escaneo de contenedores localmente (versión Python)](#scanning-containers-locally-python-version)
- [Escaneo de proyectos localmente (contenedor Docker)](#scanning-projects-locally-docker-container)
- [Modo servidor](#server-mode)
- [Desarrollo local](#local-development)
- [Documentación (depscan.readthedocs.io)](https://depscan.readthedocs.io)
- [Licencia](#license)
## Características
- Escanee la mayor parte del código de la aplicación (repositorios locales, imágenes de contenedor Linux, manifiestos de Kubernetes y el sistema operativo) para identificar CVE conocidos con priorización
- Realice análisis avanzados de alcanzabilidad para múltiples lenguajes (consulte la [matriz de alcanzabilidad](#reachability-matrix) a continuación)
- El escaneo de vulnerabilidades de paquetes se realiza localmente y es bastante rápido. No se utiliza ningún servidor
- Genere una Lista de Materiales de Software (SBOM) con información del Informe de Divulgación de Vulnerabilidades (VDR)
- Genere un documento VEX de Common Security Advisory Framework (CSAF) 2.0/2.1 (consulte el [CSAF Readme](https://github.com/owasp-dep-scan/dep-scan/blob/master/contrib/CSAF_README.md))
- Realice auditorías profundas de riesgos de paquetes para ataques de confusión de dependencias y riesgos de mantenimiento (consulte la [documentación de auditoría de riesgos](https://depscan.readthedocs.io/adv-usage#package-risk-audit))
### Flujos de datos alcanzables precisos
Flujos de datos detallados para identificar tanto las rutas alcanzables como las no alcanzables en su aplicación según el contexto completo.
### Matriz de alcanzabilidad
dep-scan calcula la alcanzabilidad para siete ecosistemas de lenguajes mediante cuatro slicers. Un paquete vulnerable cuyo código está realmente en una ruta ejecutada se marca como **Reachable** (Alcanzable), mientras que un paquete que simplemente está declarado en el BOM pero nunca se invoca no lo está. Cada slicer alimenta el mismo motor de alcanzabilidad compartido, indexado por purl, por lo que el comportamiento es uniforme entre lenguajes. La alcanzabilidad está activada por defecto (`--reachability-analyzer FrameworkReachability`); `SemanticReachability` además atribuye servicios alcanzados, endpoints y alcanzabilidad posterior a la compilación (binaria/contenedor).
| Lenguaje / ecosistema | Motor de alcanzabilidad | Analizador predeterminado |
| ---------------------------------- | ----------------------------------------------------- | ----------------------- |
| 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` |
Para conocer los conceptos detrás de la alcanzabilidad y la priorización, lea los capítulos sobre el [modelo de alcanzabilidad](https://depscan.readthedocs.io/concepts/reachability-model) y la [priorización](https://depscan.readthedocs.io/concepts/prioritization). Para ver ejemplos prácticos por lenguaje, consulte las [Guías de lenguajes](https://depscan.readthedocs.io/languages/rust-reachability). Para conocer el aspecto de cumplimiento (VDR y CSAF VEX), consulte la [guía de VDR](https://depscan.readthedocs.io/output/vdr-guide) y la [guía de CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide).
La alcanzabilidad está activada de forma predeterminada con `--profile research`, que es el perfil que utiliza dep-scan cuando la alcanzabilidad está activada. Los comandos a continuación son suficientes para comenzar; las guías por lenguaje cubren la resolución de binarios, la seguridad de backend y de red, los requisitos de restauración y ejemplos prácticos sobre los fixtures incluidos en el repositorio.
**Rust (rusi).** cdxgen ejecuta [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) y conserva su informe, que dep-scan convierte en el pipeline compartido, de modo que un crate que realmente se invoca (por ejemplo, `time::now()` para RUSTSEC-2020-0071) es Alcanzable, mientras que uno que simplemente está presente no lo es. Consulte la [guía de alcanzabilidad para Rust](https://depscan.readthedocs.io/languages/rust-reachability).
```bash
depscan -i ./my-rust-app -o ./reports --profile research
```
**Go (golem).** dep-scan invoca [golem](https://github.com/cdxgen/cdxgen-plugins-bin) directamente para proyectos Go (requiere `go` en `PATH`), marcando un módulo como Reachable cuando sus funciones están en una ruta rastreada. Use `--go-analyzer-network offline` para repositorios no confiables con una caché de módulos precalentada. Consulte la [guía de alcanzabilidad de Go](https://depscan.readthedocs.io/languages/go-reachability).
```bash
depscan -i ./my-go-app -o ./reports -t go
```
**.NET (dosai).** cdxgen ejecuta [dosai](https://github.com/owasp-dep-scan/dosai), que emite un veredicto explícito de alcanzabilidad por paquete (`PackageReachability` con `ReachabilityKind` y `Confidence`) que dep-scan trata como autoritativo, por lo que un paquete NuGet realmente invocado (por ejemplo, `JsonConvert.DeserializeObject` sobre una entrada controlada) es Reachable. Escanea un árbol restaurado en busca de purls versionados. Consulta la [guía de alcanzabilidad de .NET](https://depscan.readthedocs.io/languages/dotnet-reachability).
```bash
depscan -i ./my-dotnet-app -o ./reports -t dotnet
```
**JVM, JavaScript/TypeScript, Python y PHP (atom).** Estos cuatro ecosistemas comparten el slicer [atom](https://github.com/AppThreat/atom), que construye una representación intermedia independiente del lenguaje y realiza slicing estático. Consulte la [guía de alcanzabilidad para JVM, JS, Python y PHP](https://depscan.readthedocs.io/languages/jvm-js-python-php-reachability).
```bash
depscan --profile research -t java -i ./my-java-app -o ./reports --explain
```
Para ir más allá de la alcanzabilidad centrada en el framework hacia los niveles de endpoint, servicio y posterior a la compilación, pase `--reachability-analyzer SemanticReachability` con un `--bom-dir` de BOMs de ciclo de vida. Consulte la [guía de alcanzabilidad semántica](https://depscan.readthedocs.io/analyzers/semantic-reachability).
### Información clara sobre CVE
Comprenda las CVE con claridad sin tener que leer la descripción completa.
### Priorización automática
Céntrese solo en las CVE que requieren su atención.
### Manténgase proactivo
Manténgase siempre un paso por delante con la predicción avanzada de vulnerabilidades y exploits.
### Fuentes de datos de vulnerabilidades
- OSV
- NVD
- GitHub
- NPM
- Linux [vuln-list](https://github.com/appthreat/vuln-list)
### Distribuciones de Linux
- AlmaLinux
- Debian
- Alpine
- Amazon Linux
- Arch Linux
- RHEL/CentOS
- Rocky Linux
- Ubuntu
- OpenSUSE/SLES
- Photon
- Chainguard
- Wolfi OS
## Inicio rápido
dep-scan es ideal para su uso durante la integración continua (CI) y como herramienta de desarrollo local.
### Escaneo de proyectos localmente (versión de 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]
```
Esto instalaría dos comandos llamados `cdxgen` y `depscan`.
Puedes invocar el comando de escaneo directamente con las distintas opciones.
```bash
cd <project to scan>
depscan --src $PWD --reports-dir $PWD/reports
```
La lista completa de opciones se muestra a continuación:
```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 y Linux)
Homebrew instala el [binario autónomo](#standalone-binaries-no-python-or-nodejs-required) como `depscan` desde el [tap de OWASP dep-scan](https://github.com/owasp-dep-scan/homebrew-tap), con cdxgen incluido y sin necesidad de Python ni Node.js. `brew trust` acepta el tap, que Homebrew requiere antes de cargar fórmulas de un tap de terceros cuando `HOMEBREW_REQUIRE_TAP_TRUST` está establecido:
```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
```
### Binarios autónomos (no requieren Python ni Node.js)
Se adjuntan ejecutables de un solo archivo precompilados a cada [versión de GitHub](https://github.com/owasp-dep-scan/dep-scan/releases). Incluyen un binario SEA de [cdxgen](https://github.com/cdxgen/cdxgen) compatible, por lo que la generación de BOM funciona de inmediato sin instalar Python, Node.js ni cdxgen.
| Plataforma | Arquitectura | Recurso |
| --------------------- | ------------- | --------------------------- |
| 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` |
Cada recurso tiene un archivo `.sha256` correspondiente para su verificación.
```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]
> Los binarios de macOS no están firmados actualmente. En la primera ejecución, Gatekeeper de macOS puede bloquearlos; elimine el atributo de cuarentena con `xattr -d com.apple.quarantine ./depscan-darwin-arm64` (o permita el binario en Ajustes del Sistema, Privacidad y Seguridad).
> [!NOTE]
> La base de datos de vulnerabilidades todavía se descarga en la primera ejecución. Solo cdxgen está incluido, no la base de datos de vulnerabilidades. Use el comando `depscan-vdb` para seleccionar una variante específica de la base de datos, por ejemplo `depscan-vdb download --scope app` para una base de datos más pequeña solo para aplicaciones. Consulte la [guía de la base de datos de vulnerabilidades](https://depscan.readthedocs.io/vulnerability-database) para ver la matriz completa de imágenes.
Todos los binarios independientes incluyen `blint`, pero no su backend opcional de desensamblado `nyxstone` (que no tiene wheels ni soporte para Windows). Por lo tanto, el análisis profundo de binarios basado en desensamblado no está disponible en los binarios independientes; use el paquete de Python (`pip install owasp-depscan[all]`) si lo necesita.
### Escaneo de contenedores localmente (versión de Python)
Escanee un proyecto Java.
```bash
depscan --src <path> -o containertests -t java
```
Escanea la etiqueta `latest` del contenedor `shiftleft/scan-slim`
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker
```
Incluya `license` en el tipo para realizar la auditoría de licencias.
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker license
```
También puedes especificar la imagen usando el digest sha256
```bash
depscan --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests -t docker
```
También puedes guardar imágenes de contenedor usando el comando docker o podman save y pasar el archivo al depscan para su escaneo.
```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
```
Consulte las pruebas de docker en el flujo de trabajo de la acción de GitHub de este repositorio para ver más ejemplos.
### Escaneo de proyectos localmente (contenedor Docker)
Se puede utilizar la imagen de contenedor `ghcr.io/owasp-dep-scan/dep-scan` para realizar el escaneo.
Para escanear con la configuración predeterminada
```bash
docker run --rm -v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Para escanear con configuración basada en variables de entorno personalizadas
```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
```
En el ejemplo anterior, `/tmp` se monta como `/db` dentro del contenedor. Este directorio se especifica luego como `VDB_HOME` para almacenar en caché la información de vulnerabilidades. De esta manera, la base de datos se puede almacenar en caché y reutilizar para mejorar el rendimiento.
### Modo servidor
dep-scan y cdxgen se pueden ejecutar en modo servidor. Utilice el archivo docker-compose incluido para comenzar.
```bash
git clone https://github.com/owasp-dep-scan/dep-scan
docker compose up
```
El archivo compose incluido establece `DEPSCAN_SERVER_API_KEY` en un valor de marcador de posición de desarrollo por defecto para que el servicio dep-scan pueda enlazarse a `0.0.0.0`. Sobrescriba este valor antes de exponer el servicio fuera de un laboratorio local.
```bash
depscan --server --server-host 127.0.0.1 --server-port 7070
```
Si necesitas vincular dep-scan a una dirección no local, primero establece una clave de 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 se niega a enlazarse a una dirección no local sin `DEPSCAN_SERVER_API_KEY` o sin una habilitación explícita mediante `DEPSCAN_SERVER_ALLOW_UNAUTHENTICATED_BIND=true`.
Utilice el endpoint `/scan` para realizar escaneos.
> [!NOTE]
> El parámetro `type` es obligatorio en modo servidor. Cuando la autenticación por clave de API está habilitada, envíe la clave usando `X-API-Key` o `Authorization: Bearer <key>`.
- Escaneo de un directorio local.
Escaneo de un archivo 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
```
- Escaneo de un repositorio de 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
```
- Cargar un archivo SBOM y generar resultados a partir de él.
```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
```
## Desarrollo local
Configura uv siguiendo la [documentación](https://docs.astral.sh/uv/) oficial.
```shell
uv sync --all-extras --all-packages
uv run depscan --help
uv run pytest
uv run pyrefly check
```
La verificación de tipos utiliza [pyrefly](https://pyrefly.org) (la configuración se encuentra en
`[tool.pyrefly]` en `pyproject.toml`); se espera que la verificación reporte cero
errores.
### Configuración local de VDB
```shell
vdb --clean
vdb --download-image
# To scan containers and OS images
# vdb --download-full-image
```
### Escanear depscan local
```shell
uv run depscan --config .config/depscan-dev.toml
```
Esto usaría automáticamente la configuración especificada en el archivo de configuración local [file](https://github.com/owasp-dep-scan/dep-scan/blob/master/.config/depscan.toml).
## Documentación
La documentación completa está en [depscan.readthedocs.io](https://depscan.readthedocs.io). Páginas clave:
- [Lenguajes compatibles y matriz de alcanzabilidad](https://depscan.readthedocs.io/supported-languages)
- [Análisis de alcanzabilidad](https://depscan.readthedocs.io/reachability-analysis) (hub)
- [El modelo de alcanzabilidad](https://depscan.readthedocs.io/concepts/reachability-model)
- [Cómo prioriza dep-scan](https://depscan.readthedocs.io/concepts/prioritization)
- [SBOM y evidencia](https://depscan.readthedocs.io/concepts/sbom-and-evidence)
- Guías por lenguaje: [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)
- Analizadores: [Alcanzabilidad de frameworks](https://depscan.readthedocs.io/analyzers/framework-reachability), [Alcanzabilidad semántica](https://depscan.readthedocs.io/analyzers/semantic-reachability)
- Salida y cumplimiento: [Guía VDR](https://depscan.readthedocs.io/output/vdr-guide), [Guía CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide)
- [Personalización mediante variables de entorno](https://depscan.readthedocs.io/env-var#customization-through-environment-variables)
- Uso avanzado: [GitHub Security Advisory](https://depscan.readthedocs.io/adv-usage#github-security-advisory), [Modo suggest](https://depscan.readthedocs.io/adv-usage#suggest-mode), [Auditoría de riesgo de paquetes](https://depscan.readthedocs.io/adv-usage#package-risk-audit), [Escaneo del SO en vivo](https://depscan.readthedocs.io/adv-usage#live-os-scan), [Escaneo de licencias](https://depscan.readthedocs.io/adv-usage#license-scan), [Informes personalizados](https://depscan.readthedocs.io/adv-usage#custom-reports)
## Licencia
Licencia MIT
Este proyecto fue donado a la OWASP Foundation en agosto de 2023 por AppThreat Ltd.
## Financiación
Este proyecto está financiado a través de [NGI Zero Core](https://nlnet.nl/core), un fondo establecido por [NLnet](https://nlnet.nl) con el apoyo financiero del programa [Next Generation Internet](https://ngi.eu) de la Comisión Europea. Más información en la [página del proyecto 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)