owasp-dep-scan/dep-scanScanner de vulnerabilidades de dependências de próxima geração com análise de alcançabilidade, geração de SBOM, auditoria de licenças e varredura de imagens de contêiner para integração CI/CD.
# Introdução
OWASP dep-scan é uma ferramenta de auditoria de segurança e risco de nova geração baseada em vulnerabilidades conhecidas, avisos e limitações de licença para dependências de projetos. Tanto repositórios locais quanto imagens de contêiner são suportados como entrada, e a ferramenta é ideal para integração com plataformas ASPM/VM e em ambientes 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)
## Conteúdo
- [Recursos](#features)
- [Fluxos de dados alcançáveis precisos](#precise-reachable-data-flows)
- [Matriz de alcançabilidade](#reachability-matrix)
- [Alcançabilidade em Rust (via rusi)](#rust-reachability-via-rusi)
- [Alcançabilidade em Go (via golem)](#go-reachability-via-golem)
- [Alcançabilidade em .NET (via dosai)](#net-reachability-via-dosai)
- [Alcançabilidade em JVM, JavaScript, Python e PHP (via atom)](#jvm-javascript-python-and-php-reachability-via-atom)
- [Fontes de dados de vulnerabilidades](#vulnerability-data-sources)
- [Distribuições Linux](#linux-distros)
- [Início rápido](#quick-start)
- [Escaneando projetos localmente (versão Python)](#scanning-projects-locally-python-version)
- [Homebrew (macOS e Linux)](#homebrew-macos-and-linux)
- [Binários autônomos (sem necessidade de Python ou Node.js)](#standalone-binaries-no-python-or-nodejs-required)
- [Escaneando contêineres localmente (versão Python)](#scanning-containers-locally-python-version)
- [Escaneando projetos localmente (contêiner Docker)](#scanning-projects-locally-docker-container)
- [Modo servidor](#server-mode)
- [Desenvolvimento local](#local-development)
- [Documentação (depscan.readthedocs.io)](https://depscan.readthedocs.io)
- [Licença](#license)
## Recursos
- Escaneie a maior parte do código de aplicação (repositórios locais, imagens de contêiner Linux, manifestos Kubernetes e SO) para identificar CVEs conhecidas com priorização
- Realize análise avançada de alcançabilidade para múltiplas linguagens (veja a [matriz de alcançabilidade](#reachability-matrix) abaixo)
- O escaneamento de vulnerabilidades de pacotes é realizado localmente e é bastante rápido. Nenhum servidor é utilizado
- Gere Software Bill-of-Materials (SBOM) com informações de Vulnerability Disclosure Report (VDR)
- Gere um documento VEX Common Security Advisory Framework (CSAF) 2.0/2.1 (confira o [CSAF Readme](https://github.com/owasp-dep-scan/dep-scan/blob/master/contrib/CSAF_README.md))
- Realize auditoria profunda de risco de pacotes para ataques de confusão de dependências e riscos de manutenção (veja a [documentação de auditoria de risco](https://depscan.readthedocs.io/adv-usage#package-risk-audit))
### Fluxos de dados alcançáveis precisos
Fluxos de dados detalhados para identificar caminhos alcançáveis e não alcançáveis em sua aplicação com base no contexto completo.
### Matriz de alcançabilidade
dep-scan calcula a alcançabilidade para sete ecossistemas de linguagens por meio de quatro slicers. Um pacote vulnerável cujo código está realmente em um caminho executado é marcado como **Reachable**, enquanto um pacote que é apenas declarado no BOM mas nunca chamado não é. Cada slicer alimenta o mesmo mecanismo compartilhado de alcançabilidade indexado por purl, de modo que o comportamento é uniforme entre as linguagens. A alcançabilidade está ativada por padrão (`--reachability-analyzer FrameworkReachability`); `SemanticReachability` adicionalmente atribui serviços, endpoints e alcançabilidade pós-build (binário/contêiner) alcançados.
| Linguagem / ecossistema | Mecanismo de alcançabilidade | Analisador padrão |
| ---------------------------------- | ----------------------------------------------------- | ----------------------- |
| 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 os conceitos por trás da alcançabilidade e da priorização, leia os capítulos [modelo de alcançabilidade](https://depscan.readthedocs.io/concepts/reachability-model) e [priorização](https://depscan.readthedocs.io/concepts/prioritization). Para exemplos práticos por linguagem, consulte os [Guias de Linguagem](https://depscan.readthedocs.io/languages/rust-reachability). Para a questão de conformidade (VDR e CSAF VEX), consulte o [guia VDR](https://depscan.readthedocs.io/output/vdr-guide) e o [guia CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide).
A alcançabilidade está ativada por padrão em `--profile research`, que é o perfil usado pelo dep-scan quando a alcançabilidade está ativada. Os comandos abaixo são suficientes para começar; os guias por linguagem cobrem resolução de binários, segurança de backend e rede, requisitos de restauração e exemplos práticos nos fixtures do repositório.
**Rust (rusi).** O cdxgen executa o [rusi](https://github.com/cdxgen/cdxgen-plugins-bin) e persiste o seu relatório, que o dep-scan converte para o pipeline compartilhado, de modo que um crate que é efetivamente chamado (por exemplo, `time::now()` para RUSTSEC-2020-0071) é Reachable, enquanto um que está apenas presente não é. Consulte o [guia de alcançabilidade para Rust](https://depscan.readthedocs.io/languages/rust-reachability).
```bash
depscan -i ./my-rust-app -o ./reports --profile research
```
**Go (golem).** O dep-scan invoca o [golem](https://github.com/cdxgen/cdxgen-plugins-bin) diretamente para projetos Go (requer `go` no `PATH`), marcando um módulo como Reachable quando as suas funções estão num caminho rastreado. Use `--go-analyzer-network offline` para repositórios não confiáveis com uma cache de módulos já preenchida. Consulte o [guia de reachability para Go](https://depscan.readthedocs.io/languages/go-reachability).
```bash
depscan -i ./my-go-app -o ./reports -t go
```
**.NET (dosai).** O cdxgen executa o [dosai](https://github.com/owasp-dep-scan/dosai), que emite um veredito explícito de alcançabilidade por pacote (`PackageReachability` com `ReachabilityKind` e `Confidence`) que o dep-scan trata como autoritativo, de modo que um pacote NuGet efetivamente chamado (por exemplo, `JsonConvert.DeserializeObject` em uma entrada controlada) é Reachable. Escaneie uma árvore restaurada em busca de purls versionados. Consulte o [guia de alcançabilidade .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).** Esses quatro ecossistemas compartilham o fatiador [atom](https://github.com/AppThreat/atom), que constrói uma representação intermediária independente de linguagem e realiza fatiamento estático. Consulte o [guia de alcançabilidade para 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
```
Para ir além da reachability voltada ao framework para os níveis de endpoint, serviço e pós-build, passe `--reachability-analyzer SemanticReachability` com um `--bom-dir` de BOMs de ciclo de vida. Consulte o [guia de reachability semântica](https://depscan.readthedocs.io/analyzers/semantic-reachability).
### Insights claros sobre CVEs
Entenda as CVEs com clareza sem precisar ler a descrição inteira.
### Priorização automática
Concentre-se apenas nas CVEs que exigem sua atenção.
### Mantenha-se proativo
Fique sempre um passo à frente com previsão avançada de vulnerabilidades e exploits.
### Fontes de dados de vulnerabilidades
- OSV
- NVD
- GitHub
- NPM
- Linux [vuln-list](https://github.com/appthreat/vuln-list)
### Distribuições Linux
- AlmaLinux
- Debian
- Alpine
- Amazon Linux
- Arch Linux
- RHEL/CentOS
- Rocky Linux
- Ubuntu
- OpenSUSE/SLES
- Photon
- Chainguard
- Wolfi OS
## Início rápido
dep-scan é ideal para uso durante a integração contínua (CI) e como ferramenta de desenvolvimento local.
### Escaneando projetos localmente (versão 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]
```
Isso instalaria dois comandos chamados `cdxgen` e `depscan`.
Você pode invocar o comando de varredura diretamente com as várias opções.
```bash
cd <project to scan>
depscan --src $PWD --reports-dir $PWD/reports
```
A lista completa de opções está abaixo:
```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)
O Homebrew instala o [binário autônomo](#standalone-binaries-no-python-or-nodejs-required) como `depscan` a partir do [tap do OWASP dep-scan](https://github.com/owasp-dep-scan/homebrew-tap), com o cdxgen incluído e sem necessidade de Python ou Node.js. O `brew trust` aceita o tap, o que o Homebrew exige antes de carregar fórmulas de um tap de terceiros quando `HOMEBREW_REQUIRE_TAP_TRUST` está definido:
```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
```
### Binários autónomos (sem necessidade de Python ou Node.js)
Executáveis de ficheiro único pré-compilados estão anexados a cada [lançamento no GitHub](https://github.com/owasp-dep-scan/dep-scan/releases). Incluem um binário SEA [cdxgen](https://github.com/cdxgen/cdxgen) correspondente, pelo que a geração de BOM funciona de imediato sem instalar Python, Node.js ou cdxgen.
| Plataforma | Arquitetura | Ficheiro |
| --------------------- | ------------- | --------------------------- |
| 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 ficheiro tem um ficheiro `.sha256` correspondente para verificação.
```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]
> Os binários do macOS estão atualmente sem assinatura. Na primeira execução, o Gatekeeper do macOS pode bloqueá-los; remova o atributo de quarentena com `xattr -d com.apple.quarantine ./depscan-darwin-arm64` (ou permita o binário em Ajustes do Sistema, Privacidade e Segurança).
> [!NOTE]
> O banco de dados de vulnerabilidades ainda é baixado na primeira execução. Apenas o cdxgen é incluído, não o banco de dados de vulnerabilidades. Use o comando `depscan-vdb` para selecionar uma variante específica do banco de dados, por exemplo `depscan-vdb download --scope app` para um banco de dados menor, apenas de aplicações. Consulte o [guia do banco de dados de vulnerabilidades](https://depscan.readthedocs.io/vulnerability-database) para a matriz completa de imagens.
Todos os binários autônomos incluem o `blint`, mas não o seu backend opcional de desmontagem `nyxstone` (que não possui wheels nem suporte a Windows). A análise profunda de binários baseada em desmontagem, portanto, não está disponível nos binários autônomos; use o pacote Python (`pip install owasp-depscan[all]`) se precisar dela.
### Escaneando contêineres localmente (versão Python)
Escaneie um projeto Java.
```bash
depscan --src <path> -o containertests -t java
```
Examinar a tag `latest` do contêiner `shiftleft/scan-slim`
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker
```
Inclua `license` no tipo para realizar a auditoria de licenças.
```bash
depscan --src shiftleft/scan-slim -o containertests -t docker license
```
Também é possível especificar a imagem usando o digest sha256
```bash
depscan --src redmine@sha256:a5c5f8a64a0d9a436a0a6941bc3fb156be0c89996add834fe33b66ebeed2439e -o containertests -t docker
```
Também é possível salvar imagens de contêiner usando o comando docker ou podman save e passar o arquivo para o depscan realizar a verificação.
```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 os testes do docker no fluxo de trabalho do GitHub action deste repositório para mais exemplos.
### Escaneando projetos localmente (contêiner Docker)
A imagem de contêiner `ghcr.io/owasp-dep-scan/dep-scan` pode ser usada para realizar a verificação.
Para escanear com as configurações padrão
```bash
docker run --rm -v $PWD:/app ghcr.io/owasp-dep-scan/dep-scan depscan --src /app --reports-dir /app/reports
```
Para escanear com configuração baseada em variáveis de ambiente 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
```
No exemplo acima, `/tmp` é montado como `/db` no contêiner. Este diretório é então especificado como `VDB_HOME` para armazenar em cache as informações de vulnerabilidade. Desta forma, o banco de dados pode ser armazenado em cache e reutilizado para melhorar o desempenho.
### Modo servidor
dep-scan e cdxgen podem ser executados em modo servidor. Use o arquivo docker-compose incluído para começar.
```bash
git clone https://github.com/owasp-dep-scan/dep-scan
docker compose up
```
O arquivo compose incluído define `DEPSCAN_SERVER_API_KEY` com um valor de espaço reservado de desenvolvimento por padrão, para que o serviço dep-scan possa se vincular a `0.0.0.0`. Substitua esse valor antes de expor o serviço fora de um ambiente de laboratório local.
```bash
depscan --server --server-host 127.0.0.1 --server-port 7070
```
Se você precisar vincular o dep-scan a um endereço não local, defina primeiro uma chave de API:
```bash
export DEPSCAN_SERVER_API_KEY="change-this-before-production"
depscan --server --server-host 0.0.0.0 --server-port 7070
```
> [!IMPORTANT]
> O dep-scan recusa-se a associar-se a um endereço não local sem `DEPSCAN_SERVER_API_KEY` ou uma adesão explícita através de `DEPSCAN_SERVER_ALLOW_UNAUTHENTICATED_BIND=true`.
Utilize o endpoint `/scan` para realizar análises.
> [!NOTE]
> O parâmetro `type` é obrigatório no modo servidor. Quando a autenticação por chave de API está ativada, envie a chave utilizando `X-API-Key` ou `Authorization: Bearer <key>`.
- Analisar um diretório local.
Analisar um ficheiro 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
```
- Escaneando um repositório do 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
```
- Carregar um arquivo SBOM e gerar resultados com base nele.
```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
```
## Desenvolvimento local
Configure o uv seguindo a [documentação](https://docs.astral.sh/uv/) oficial.
```shell
uv sync --all-extras --all-packages
uv run depscan --help
uv run pytest
uv run pyrefly check
```
A verificação de tipos usa [pyrefly](https://pyrefly.org) (a configuração fica em
`[tool.pyrefly]` no `pyproject.toml`); espera-se que a verificação reporte zero
erros.
### Configuração local do VDB
```shell
vdb --clean
vdb --download-image
# To scan containers and OS images
# vdb --download-full-image
```
### Varredura local do depscan
```shell
uv run depscan --config .config/depscan-dev.toml
```
Isso usaria automaticamente a configuração especificada no [arquivo](https://github.com/owasp-dep-scan/dep-scan/blob/master/.config/depscan.toml) de configuração local.
## Documentação
A documentação completa está em [depscan.readthedocs.io](https://depscan.readthedocs.io). Páginas principais:
- [Linguagens suportadas e matriz de alcançabilidade](https://depscan.readthedocs.io/supported-languages)
- [Análise de alcançabilidade](https://depscan.readthedocs.io/reachability-analysis) (hub)
- [O modelo de alcançabilidade](https://depscan.readthedocs.io/concepts/reachability-model)
- [Como o dep-scan prioriza](https://depscan.readthedocs.io/concepts/prioritization)
- [SBOM e evidências](https://depscan.readthedocs.io/concepts/sbom-and-evidence)
- Guias por linguagem: [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)
- Analisadores: [Alcançabilidade de frameworks](https://depscan.readthedocs.io/analyzers/framework-reachability), [Alcançabilidade semântica](https://depscan.readthedocs.io/analyzers/semantic-reachability)
- Saída e conformidade: [Guia VDR](https://depscan.readthedocs.io/output/vdr-guide), [Guia CSAF VEX](https://depscan.readthedocs.io/output/vex-csaf-guide)
- [Personalização por meio de variáveis de ambiente](https://depscan.readthedocs.io/env-var#customization-through-environment-variables)
- Uso avançado: [GitHub Security Advisory](https://depscan.readthedocs.io/adv-usage#github-security-advisory), [Modo suggest](https://depscan.readthedocs.io/adv-usage#suggest-mode), [Auditoria de risco de pacotes](https://depscan.readthedocs.io/adv-usage#package-risk-audit), [Varredura de SO em execução](https://depscan.readthedocs.io/adv-usage#live-os-scan), [Varredura de licenças](https://depscan.readthedocs.io/adv-usage#license-scan), [Relatórios personalizados](https://depscan.readthedocs.io/adv-usage#custom-reports)
## Licença
Licença MIT
Este projeto foi doado à OWASP Foundation em agosto de 2023 pela AppThreat Ltd.
## Financiamento
Este projeto é financiado pelo [NGI Zero Core](https://nlnet.nl/core), um fundo estabelecido pela [NLnet](https://nlnet.nl) com apoio financeiro do programa [Next Generation Internet](https://ngi.eu) da Comissão Europeia. Saiba mais na [página do projeto 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)