git-pkgs proxy

Um proxy de cache para registries de pacotes. Acelera o download de pacotes ao armazenar artefatos em cache localmente, reduzindo o uso de banda e melhorando a confiabilidade.

Cooldown de Versão

A maioria dos ataques à cadeia de suprimentos depende da velocidade: uma versão maliciosa é publicada e consumida por pipelines automatizados em minutos, antes que alguém perceba. O recurso de cooldown adiciona um período de quarentena para versões recém-publicadas. Quando habilitado, o proxy remove versões das respostas de metadados até que elas ultrapassem um limite configurável de idade.```yaml cooldown: default: "3d" # hide versions published less than 3 days ago ecosystems: npm: "7d" # npm gets a longer window cargo: "0" # disable for cargo packages: "pkg:npm/lodash": "0" # exempt trusted packages

Um período de espera de 3 dias significa que quando o `lodash` publicar a versão `4.18.0`, seus builds continuarão usando `4.17.21` até que 3 dias tenham passado. Se o novo lançamento se revelar comprometido, você nunca esteve exposto.

Ordem de resolução: override do pacote, depois override do ecossistema, depois padrão global. Isso permite definir um padrão conservador e abrir exceções para pacotes onde você precisa de atualizações mais rápidas. Consulte [docs/configuration.md](https://github.com/git-pkgs/proxy/blob/main/docs/configuration.md) para a referência completa de configuração.

## Registries Suportados

| Registry | Linguagem/Plataforma | Espera | Concluído |
|----------|----------------------|:------:|:---------:|
| npm | JavaScript | Sim | ✓ |
| Cargo | Rust | Sim | ✓ |
| RubyGems | Ruby | Sim | ✓ |
| Go proxy | Go | | ✓ |
| Hex | Elixir | Sim* | ✓ |
| pub.dev | Dart | Sim | ✓ |
| PyPI | Python | Sim | ✓ |
| Maven | Java | | ✓ |
| Gradle Build Cache | Java/Kotlin | | ✓ |
| NuGet | .NET | Sim | ✓ |
| Composer | PHP | Sim | ✓ |
| Conan | C/C++ | | ✓ |
| Conda | Python/R | Sim | ✓ |
| CRAN | R | | ✓ |
| Julia | Julia | | ✓ |
| Container | Docker/OCI | | ✓ |
| Debian | Debian/Ubuntu | | ✓ |
| RPM | RHEL/Fedora | | ✓ |
| Alpine | Alpine Linux | | ✗ |
| Arch | Arch Linux | | ✗ |
| Chef | Chef | | ✗ |
| Generic | Qualquer | | ✗ |
| Helm | Kubernetes | | ✗ |
| Swift | Swift | | ✗ |
| Vagrant | Vagrant | | ✗ |

A espera exige timestamps de publicação nos metadados. Registries sem "Sim" na coluna de espera ou não expõem timestamps ou ainda não foram configurados.

\* A espera do Hex exige desativar a verificação de assinatura do registry (`HEX_NO_VERIFY_REPO_ORIGIN=1`) já que o proxy re-codifica o payload protobuf.

## Instalação```bash
brew install git-pkgs/git-pkgs/proxy

Or faça o download de um binário na página de releases.

Início Rápido```bash

Build from source

go build -o proxy ./cmd/proxy

Run with defaults (listens on :8080)

./proxy

Run with custom settings

./proxy -listen :3000 -base-url https://proxy.example.com

O proxy está agora em execução. Configure os seus gestores de pacotes para o utilizarem.

## OpenAPI (Swagger)

Este repositório utiliza o swaggo para gerar uma especificação OpenAPI a partir de handlers anotados.

Gere a especificação:```bash
go install github.com/swaggo/swag/cmd/swag@latest
go generate ./internal/server

Generated files are written to docs/swagger/.

When the proxy is running, fetch the live spec from:

http://localhost:8080/openapi.json

Or replace http://localhost:8080 with your configured base URL. This link is also shown on the dashboard.

Configuring Package Managers

npm

Create or edit ~/.npmrc:``` registry=http://localhost:8080/npm/

Or defina por projeto no `.npmrc`:```
registry=http://localhost:8080/npm/

Ou use a variável de ambiente:```bash npm_config_registry=http://localhost:8080/npm/ npm install

### Cargo

Crie ou edite `~/.cargo/config.toml`:```toml
[source.crates-io]
replace-with = "proxy"

[source.proxy]
registry = "sparse+http://localhost:8080/cargo/"

Or defina por projeto em .cargo/config.toml na raiz do seu projeto.

RubyGems / Bundler

Defina a fonte da gem no seu Gemfile:```ruby source "http://localhost:8080/gem"

Ou configure globalmente:```bash
gem sources --add http://localhost:8080/gem/
bundle config mirror.https://rubygems.org http://localhost:8080/gem

Módulos Go

Defina a variável de ambiente GOPROXY:```bash export GOPROXY=http://localhost:8080/go,direct

Or no seu perfil de shell para persistência.

### Hex (Elixir)

Configure em `~/.hex/hex.config`:```erlang
{default_url, <<"http://localhost:8080/hex">>}.

Ou defina a variável de ambiente:```bash export HEX_MIRROR=http://localhost:8080/hex

### pub.dev (Dart/Flutter)

Defina a variável de ambiente PUB_HOSTED_URL:```bash
export PUB_HOSTED_URL=http://localhost:8080/pub

PyPI (pip)

Configure o pip para usar o proxy:```bash pip install --index-url http://localhost:8080/pypi/simple/ package_name

Or defina em `~/.pip/pip.conf`:```ini
[global]
index-url = http://localhost:8080/pypi/simple/

Maven

Adicione ao seu ~/.m2/settings.xml:```xml proxy central http://localhost:8080/maven/

O endpoint `/maven/` usa o Maven Central como upstream primário e recorre ao Gradle Plugin Portal para metadados de marcadores de plugins Gradle e artefatos relacionados quando o upstream primário retorna "não encontrado".

Para a resolução de plugins Gradle por meio do mesmo endpoint de proxy:```kotlin
pluginManagement {
  repositories {
    maven(url = "http://localhost:8080/maven/")
  }
}

Gradle HTTP Build Cache

Configure em settings.gradle(.kts):```kotlin buildCache { local { enabled = false } remote { url = uri("http://localhost:8080/gradle/") push = true } }

### NuGet

Configure em `nuget.config`:```xml
<configuration>
  <packageSources>
    <clear />
    <add key="proxy" value="http://localhost:8080/nuget/v3/index.json" />
  </packageSources>
</configuration>

Ou use a CLI:```bash dotnet nuget add source http://localhost:8080/nuget/v3/index.json -n proxy

### Composer (PHP)

Configure em `composer.json`:```json
{
    "repositories": [
        {
            "type": "composer",
            "url": "http://localhost:8080/composer"
        }
    ]
}

Or defina globalmente:```bash composer config -g repositories.proxy composer http://localhost:8080/composer

### Conan (C/C++)

Adicione o proxy como um repositório remoto:```bash
conan remote add proxy http://localhost:8080/conan
conan remote disable conancenter

Or configure in ~/.conan2/remotes.json.

Conda

Configure in ~/.condarc:```yaml channels:

http://localhost:8080/conda/main
http://localhost:8080/conda/conda-forge default_channels:
http://localhost:8080/conda/main

Ou defina via comando:```bash
conda config --add channels http://localhost:8080/conda/main

CRAN (R)

Defina o repositório no R:```r options(repos = c(CRAN = "http://localhost:8080/cran"))

Or em `~/.Rprofile` para persistência:```r
local({
  r <- getOption("repos")
  r["CRAN"] <- "http://localhost:8080/cran"
  options(repos = r)
})

Julia

Defina o servidor Pkg antes de iniciar o Julia:```bash export JULIA_PKG_SERVER=http://localhost:8080/julia

Ou dentro de uma sessão em execução:```julia
ENV["JULIA_PKG_SERVER"] = "http://localhost:8080/julia"
using Pkg; Pkg.update()

Docker / Container Registry

Configure o Docker para usar o proxy como um espelho de registro em /etc/docker/daemon.json:```json { "registry-mirrors": ["http://localhost:8080"] }

Então reinicie o Docker:```bash
sudo systemctl restart docker

Ou puxe imagens diretamente:```bash docker pull localhost:8080/library/nginx:latest

### Helm

Configure cada repositório de charts HTTP com um nome e, em seguida, adicione o URL de proxy correspondente ao Helm:```yaml
upstream:
  helm:
    bitnami: "https://charts.bitnami.com/bitnami"

Aqui está a tradução do conteúdo:

## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)

### Passos de Instalação

1. Clone o repositório:
   ```bash
   git clone https://github.com/example/tool.git
   cd tool

Instale as dependências:
```
pip install -r requirements.txt
```
Execute a ferramenta:
```
python main.py --help
```

Uso

Exemplos Básicos

Para executar uma varredura básica:

python main.py scan --target example.com

Para gerar um relatório em formato JSON:

python main.py scan --target example.com --output report.json

Opções Avançadas

Opção	Descrição
`--threads`	Número de threads a serem usadas (padrão: 10)
`--timeout`	Tempo limite em segundos para cada solicitação (padrão: 30)
`--verbose`	Ativa a saída detalhada
`--proxy`	Define um proxy para as solicitações

Configuração

O arquivo de configuração config.yaml permite personalizar o comportamento da ferramenta:

# Configuração da ferramenta
scan:
  threads: 10
  timeout: 30
  retries: 3

output:
  format: json
  directory: ./results

Solução de Problemas

Erro: "ModuleNotFoundError"

Se você encontrar um erro de módulo ausente, certifique-se de que todas as dependências foram instaladas:

pip install -r requirements.txt

Erro: "Permission denied"

Em sistemas Linux/macOS, pode ser necessário conceder permissões de execução:

chmod +x main.py

Contribuindo

Agradecemos contribuições! Siga estas etapas:

Faça um fork do repositório
Crie um branch para sua funcionalidade (git checkout -b feature/nova-funcionalidade)
Faça commit das suas alterações (git commit -am 'Adiciona nova funcionalidade')
Envie para o branch (git push origin feature/nova-funcionalidade)
Abra um Pull Request

Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo LICENSE para obter detalhes.

Aviso Legal

Esta ferramenta é fornecida apenas para fins educacionais e de teste de segurança autorizado. O uso indevido desta ferramenta pode violar leis e regulamentos. O autor não se responsabiliza por qualquer uso indevido.

helm repo add bitnami http://localhost:8080/helm/bitnami
helm repo update
helm pull bitnami/nginx
```
O proxy armazena em cache o `index.yaml` usando as configurações normais de cache de metadados e
armazena em cache os arquivos dos charts após verificar seu digest SHA-256 a partir do índice.

Para charts armazenados em um registro OCI, configure um upstream OCI nomeado e adicione
o prefixo reservado `upstream/{name}` à referência do chart:```yaml
upstream:
  oci:
    ghcr: "https://ghcr.io"
```
Aqui está a tradução para pt:

---

O `--no-verify` é usado para pular a verificação de assinatura e o `--no-install` para evitar a instalação automática de dependências. Isso é útil para ambientes de CI/CD onde você deseja apenas gerar o SBOM sem modificar o ambiente.

### Exemplo de saída

A saída do `cyclonedx-bom` é um documento XML ou JSON que segue o padrão CycloneDX. Aqui está um exemplo simplificado:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<bom xmlns="http://cyclonedx.org/schema/bom/1.4" version="1">
  <metadata>
    <timestamp>2023-10-05T12:00:00Z</timestamp>
    <tools>
      <tool>
        <vendor>CycloneDX</vendor>
        <name>cyclonedx-bom</name>
        <version>3.11.7</version>
      </tool>
    </tools>
  </metadata>
  <components>
    <component type="library">
      <name>lodash</name>
      <version>4.17.21</version>
      <purl>pkg:npm/[email protected]</purl>
    </component>
  </components>
</bom>
```

Este SBOM pode ser usado para verificar vulnerabilidades conhecidas, auditar dependências e garantir conformidade com políticas de segurança.

---

**Nota:** O `cyclonedx-bom` é uma ferramenta de linha de comando que pode ser integrada a pipelines de CI/CD, scripts de automação e outras ferramentas de segurança. Para mais informações, consulte a [documentação oficial](https://github.com/CycloneDX/cyclonedx-node-module).```bash
helm pull oci://localhost:8080/upstream/ghcr/owner/charts/mychart --version 1.0.0 --plain-http
```
### Debian / APT

Configure o APT para usar o proxy em `/etc/apt/sources.list.d/proxy.list`:```
deb http://localhost:8080/debian stable main contrib
```
Substitua as suas entradas existentes no sources.list e, em seguida:```bash
sudo apt update
```
O padrão upstream é `http://deb.debian.org/debian`. Para usar proxy em um repositório APT diferente (ex.: Ubuntu), defina `upstream.debian` no arquivo de configuração ou `PROXY_UPSTREAM_DEBIAN` no ambiente:```yaml
upstream:
  debian: "http://archive.ubuntu.com/ubuntu"
```
### RPM / Yum / DNF

Configure o yum/dnf para usar o proxy em `/etc/yum.repos.d/proxy.repo`:```ini
[proxy-fedora]
name=Fedora via Proxy
baseurl=http://localhost:8080/rpm/releases/$releasever/Everything/$basearch/os/
enabled=1
gpgcheck=0
```
Então:```bash
sudo dnf clean all
sudo dnf update
```
## Configuração

O proxy pode ser configurado através de:

1. Flags de linha de comando (maior prioridade)
2. Variáveis de ambiente
3. Arquivo de configuração (YAML ou JSON)

### Flags de Linha de Comando```
-config string           Path to configuration file
-listen string           Address to listen on (default ":8080")
-base-url string         Public URL of this proxy (default "http://localhost:8080")
-storage-url string      Storage URL (file://, s3://, gs://, azblob://)
-storage-path string     Path to artifact storage directory (deprecated, use -storage-url)
-database-driver string  Database driver: sqlite or postgres (default "sqlite")
-database-path string    Path to SQLite database file (default "./cache/proxy.db")
-database-url string     PostgreSQL connection URL
-log-level string        Log level: debug, info, warn, error (default "info")
-log-format string       Log format: text, json (default "text")
-access-log string       Path to the JSONL access log
-version                 Print version and exit
```
### Variáveis de Ambiente```bash
PROXY_LISTEN=:8080
PROXY_BASE_URL=http://localhost:8080
PROXY_UI_URL=http://localhost:8080  # Optional; defaults to PROXY_BASE_URL
PROXY_STORAGE_URL=file:///var/cache/proxy/artifacts
PROXY_DATABASE_DRIVER=sqlite
PROXY_DATABASE_PATH=./cache/proxy.db
PROXY_DATABASE_URL=postgres://user:pass@localhost/proxy?sslmode=disable
PROXY_LOG_LEVEL=info
PROXY_LOG_FORMAT=text
PROXY_ACCESS_LOG_PATH=/var/log/proxy/access.jsonl
```
### Ficheiro de Configuração```yaml
listen: ":8080"
base_url: "http://localhost:8080"

storage:
  url: "file:///var/cache/proxy/artifacts"
  max_size: "10GB"  # Optional: evict LRU when exceeded

database:
  driver: "sqlite"
  path: "/var/lib/proxy/cache.db"

log:
  level: "info"
  format: "text"

access_log:
  path: "/var/log/proxy/access.jsonl"  # Optional JSONL activity log

# Optional: override upstream URLs
upstream:
  npm: "https://registry.npmjs.org"
  cargo: "https://index.crates.io"

# Optional: version cooldown (see above)
cooldown:
  default: "3d"
```
Consulte a [referência de configuração](https://github.com/git-pkgs/proxy/blob/main/docs/configuration.md#upstream-registries) para cada chave de upstream, variável de ambiente e URL padrão.

Execute com o arquivo de configuração:```bash
./proxy -config /etc/proxy/config.yaml
```
### PostgreSQL

O SQLite é o padrão e funciona bem para implantações de nó único. Para configurações de vários nós ou se você preferir um banco de dados gerenciado, mude para o Postgres:```yaml
database:
  driver: "postgres"
  url: "postgres://user:password@localhost:5432/proxy?sslmode=disable"
```
Ou através de variáveis de ambiente:```bash
PROXY_DATABASE_DRIVER=postgres
PROXY_DATABASE_URL=postgres://user:password@localhost:5432/proxy?sslmode=disable
```
O proxy cria tabelas automaticamente na primeira execução.

### Armazenamento S3

O proxy pode armazenar artefatos em cache no S3 ou em qualquer serviço compatível com S3 (MinIO, R2, etc.) em vez do sistema de arquivos local.```yaml
storage:
  url: "s3://my-bucket-name?region=us-east-1"
```
Para serviços compatíveis com S3, como o MinIO:```yaml
storage:
  url: "s3://my-bucket?endpoint=http://localhost:9000&disableSSL=true&s3ForcePathStyle=true"
```
Defina as credenciais por meio das variáveis de ambiente padrão da AWS (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_REGION`).

### Google Cloud Storage

O proxy pode armazenar artefatos em cache em um bucket do GCS usando o esquema de URL `gs://`.```yaml
storage:
  url: "gs://my-bucket-name"
```
A autenticação usa [Application Default Credentials](https://docs.cloud.google.com/docs/authentication/application-default-credentials), o que significa que nenhuma credencial precisa ser incorporada na configuração ou no ambiente. Fontes suportadas, em ordem:

- **GKE Workload Identity** — vincule a conta de serviço do Kubernetes que executa o proxy a uma conta de serviço do Google que tenha `roles/storage.objectAdmin` no bucket. O proxy usará o token da carga de trabalho automaticamente.
- **Conta de serviço anexada** em GCE, Cloud Run, Cloud Functions, etc.
- **Variável de ambiente `GOOGLE_APPLICATION_CREDENTIALS`** apontando para um arquivo de chave JSON da conta de serviço.
- **`gcloud auth application-default login`** para desenvolvimento local.

#### Configuração do GKE Workload Identity```bash
# 1. Create a Google service account
gcloud iam service-accounts create git-pkgs-proxy \
  --project=PROJECT_ID

# 2. Grant it access to the bucket
gsutil iam ch \
  serviceAccount:git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com:objectAdmin \
  gs://my-bucket-name

# 3. Bind the Kubernetes service account to it
gcloud iam service-accounts add-iam-policy-binding \
  git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.workloadIdentityUser \
  --member="serviceAccount:PROJECT_ID.svc.id.goog[NAMESPACE/KSA_NAME]"

# 4. Annotate the Kubernetes service account
kubectl annotate serviceaccount KSA_NAME \
  --namespace=NAMESPACE \
  iam.gke.io/gcp-service-account=git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com
```
#### Serviço direto (URLs assinadas) com Workload Identity

Quando `direct_serve: true` está habilitado, o proxy emite redirecionamentos HTTP 302 para URLs GCS pré-assinadas. O Workload Identity não fornece uma chave privada, então o backend GCS chama a [API `signBlob` do IAM Credentials](https://docs.cloud.google.com/iam/docs/reference/credentials/rest/v1/projects.serviceAccounts/signBlob). Conceda à conta de serviço o papel de token-creator sobre si mesma:```bash
gcloud iam service-accounts add-iam-policy-binding \
  git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com \
  --role=roles/iam.serviceAccountTokenCreator \
  --member="serviceAccount:git-pkgs-proxy@PROJECT_ID.iam.gserviceaccount.com"
```
## CLI Commands

### serve (default)

Inicia o servidor proxy. Este é o comando padrão se nenhum for especificado.```bash
proxy serve [flags]
proxy [flags]  # same as 'proxy serve'
```
### mirror

Pré-popule o cache a partir de PURLs, arquivos SBOM ou registries inteiros. Útil para garantir disponibilidade offline ou aquecer o cache antes de implantações.```bash
# Mirror specific package versions
proxy mirror pkg:npm/[email protected] pkg:cargo/[email protected]

# Mirror all versions of a package
proxy mirror pkg:npm/lodash

# Mirror from a CycloneDX or SPDX SBOM
proxy mirror --sbom sbom.cdx.json

# Preview what would be mirrored
proxy mirror --dry-run pkg:npm/lodash

# Control parallelism
proxy mirror --concurrency 8 pkg:npm/[email protected]
```
O comando `mirror` aceita os mesmos flags de armazenamento e banco de dados que o `serve`. Artefatos já armazenados em cache são ignorados.

Uma API de mirror também está disponível quando o servidor está em execução:```bash
# Start a mirror job
curl -X POST http://localhost:8080/api/mirror \
  -H "Content-Type: application/json" \
  -d '{"purls": ["pkg:npm/[email protected]"]}'

# Check job status
curl http://localhost:8080/api/mirror/mirror-1

# Cancel a running job
curl -X DELETE http://localhost:8080/api/mirror/mirror-1
```
### stats

Mostra as estatísticas de cache sem executar o servidor.```bash
# Text output
proxy stats

# JSON output
proxy stats -json

# Custom database path
proxy stats -database-path /var/lib/proxy/cache.db

# With PostgreSQL
proxy stats -database-driver postgres -database-url postgres://user:pass@localhost/proxy

# Show top 20 most popular packages
proxy stats -popular 20
```
Exemplo de saída:```
Cache Statistics
================

Packages:   45
Versions:   128
Artifacts:  128
Total size: 892.4 MB
Total hits: 1547

Packages by ecosystem:
  npm        32
  cargo      13

Most popular packages:
   1. npm/lodash (342 hits, 24.7 KB)
   2. npm/react (198 hits, 89.3 KB)
   3. cargo/serde (156 hits, 234.1 KB)

Recently cached:
  npm/[email protected] (2024-01-15 14:32, 54.2 KB)
  cargo/[email protected] (2024-01-15 14:28, 412.8 KB)
```
## Endpoints da API

### Protocolos de Registro

| Endpoint | Descrição |
|----------|-------------|
| `GET /` | Painel de controle (interface web) |
| `GET /health` | Verificação de saúde (JSON; HTTP 200 saudável, 503 não saudável) |
| `GET /stats` | Estatísticas de cache (JSON) |
| `GET /metrics` | Métricas do Prometheus |
| `GET /npm/*` | Protocolo de registro npm |
| `GET /cargo/*` | Protocolo de índice esparso do Cargo |
| `GET /gem/*` | Protocolo RubyGems |
| `GET /go/*` | Protocolo de proxy de módulos Go |
| `GET /hex/*` | Protocolo Hex.pm |
| `GET /pub/*` | Protocolo pub.dev |
| `GET /pypi/*` | API simples/JSON do PyPI |
| `GET /maven/*` | Protocolo de repositório Maven |
| `GET /nuget/*` | API V3 do NuGet |
| `GET /composer/*` | Protocolo Composer/Packagist |
| `GET /conan/*` | Protocolo Conan C/C++ |
| `GET /conda/*` | Protocolo Conda/Anaconda |
| `GET /cran/*` | Protocolo CRAN (R) |
| `GET /julia/*` | Protocolo do servidor Pkg do Julia |
| `GET /helm/{repository}/*` | Protocolo de repositório de charts Helm via HTTP |
| `GET /v2/*` | Protocolo de registro OCI/Docker |
| `GET /debian/*` | Protocolo de repositório Debian/APT |
| `GET /rpm/*` | Protocolo de repositório RPM/Yum |

### API de Espelhamento

| Endpoint | Descrição |
|----------|-------------|
| `POST /api/mirror` | Iniciar um trabalho de espelhamento (corpo JSON com `purls`) |
| `GET /api/mirror/{id}` | Obter status e progresso do trabalho |
| `DELETE /api/mirror/{id}` | Cancelar um trabalho em execução |

### API de Enriquecimento

O proxy fornece endpoints REST para enriquecimento de metadados de pacotes, varredura de vulnerabilidades e detecção de versões desatualizadas.

| Endpoint | Descrição |
|----------|-------------|
| `GET /api/package/{ecosystem}/{name}` | Obter metadados do pacote |
| `GET /api/package/{ecosystem}/{name}/{version}` | Obter metadados da versão com vulnerabilidades |
| `GET /api/vulns/{ecosystem}/{name}` | Obter todas as vulnerabilidades de um pacote |
| `GET /api/vulns/{ecosystem}/{name}/{version}` | Obter vulnerabilidades de uma versão específica |
| `POST /api/outdated` | Verificar vários pacotes quanto a versões desatualizadas |
| `POST /api/bulk` | Consulta em lote de metadados de pacotes |

#### Obter Metadados do Pacote```bash
curl http://localhost:8080/api/package/npm/lodash
```
The `--no-verify` flag is used to skip the verification of the signature. This is useful when you want to test the tool without having to verify the signature.```json
{
  "ecosystem": "npm",
  "name": "lodash",
  "latest_version": "4.17.21",
  "license": "MIT",
  "license_category": "permissive",
  "description": "Lodash modular utilities",
  "homepage": "https://lodash.com/",
  "repository": "https://github.com/lodash/lodash",
  "registry_url": "https://registry.npmjs.org"
}
```
#### Obter Versão com Vulnerabilidades```bash
curl http://localhost:8080/api/package/npm/lodash/4.17.0
```
## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)

### Passos de Instalação

1. Clone o repositório:
   ```bash
   git clone https://github.com/example/tool.git
   cd tool
   ```

2. Instale as dependências:
   ```bash
   pip install -r requirements.txt
   ```

3. Execute a ferramenta:
   ```bash
   python main.py --help
   ```

## Uso

### Exemplos Básicos

Para executar uma verificação básica:
```bash
python main.py scan --target example.com
```

Para usar o modo verbose:
```bash
python main.py scan --target example.com --verbose
```

### Opções Avançadas

| Opção | Descrição |
|-------|-----------|
| `--target` | Especifica o alvo a ser verificado |
| `--port` | Define a porta a ser usada (padrão: 80) |
| `--timeout` | Tempo limite em segundos (padrão: 10) |
| `--output` | Caminho do arquivo de saída para os resultados |

### Exemplo de Saída

```
[+] Iniciando verificação em example.com
[+] Porta 80 aberta
[+] Porta 443 aberta
[!] Porta 8080 fechada
[*] Verificação concluída em 3.2 segundos
```

## Configuração

A ferramenta pode ser configurada usando um arquivo `config.yaml`:

```yaml
target: example.com
ports:
  - 80
  - 443
  - 8080
timeout: 15
output: results.txt
```

## Solução de Problemas

### Erro: "Permission denied"

Se você encontrar um erro de permissão, tente executar com `sudo`:
```bash
sudo python main.py scan --target example.com
```

### Erro: "Module not found"

Certifique-se de que todas as dependências estão instaladas:
```bash
pip install -r requirements.txt
```

## Licença

Este projeto está licenciado sob a Licença MIT - consulte o arquivo [LICENSE](https://github.com/git-pkgs/proxy/blob/main/LICENSE) para obter detalhes.

## Contribuindo

Contribuições são bem-vindas! Por favor, leia o [CONTRIBUTING.md](https://github.com/git-pkgs/proxy/blob/main/CONTRIBUTING.md) para obter detalhes sobre nosso código de conduta e o processo para enviar pull requests.

## Agradecimentos

- A todos os contribuidores que ajudaram a melhorar esta ferramenta
- À comunidade de segurança cibernética por seu apoio contínuo```json
{
  "package": {
    "ecosystem": "npm",
    "name": "lodash",
    "latest_version": "4.17.21",
    "license": "MIT",
    "license_category": "permissive"
  },
  "version": {
    "ecosystem": "npm",
    "name": "lodash",
    "version": "4.17.0",
    "license": "MIT",
    "published_at": "2016-06-17T03:59:56Z",
    "yanked": false,
    "is_outdated": true
  },
  "vulnerabilities": [
    {
      "id": "GHSA-p6mc-m468-83gw",
      "summary": "Prototype Pollution in lodash",
      "severity": "HIGH",
      "cvss_score": 7.4,
      "fixed_version": "4.17.12"
    }
  ],
  "is_outdated": true,
  "license_category": "permissive"
}
```
#### Verificar Pacotes Desatualizados```bash
curl -X POST http://localhost:8080/api/outdated \
  -H "Content-Type: application/json" \
  -d '{
    "packages": [
      {"ecosystem": "npm", "name": "lodash", "version": "4.17.0"},
      {"ecosystem": "pypi", "name": "requests", "version": "2.25.0"}
    ]
  }'
```
```
## Instalação

### Requisitos

- Python 3.8 ou superior
- pip (gerenciador de pacotes do Python)

### Passos de Instalação

1. Clone o repositório:
   ```bash
   git clone https://github.com/example/tool.git
   cd tool
   ```

2. Instale as dependências:
   ```bash
   pip install -r requirements.txt
   ```

3. Execute a ferramenta:
   ```bash
   python main.py --help
   ```

## Uso

### Exemplos Básicos

Para iniciar uma varredura básica:

```bash
python main.py scan --target example.com
```

Para exportar os resultados em JSON:

```bash
python main.py scan --target example.com --output results.json
```

### Opções Avançadas

| Opção | Descrição | Padrão |
|-------|-----------|--------|
| `--threads` | Número de threads simultâneas | `10` |
| `--timeout` | Tempo limite da solicitação em segundos | `30` |
| `--verbose` | Habilita saída detalhada | `false` |

### Variáveis de Ambiente

A ferramenta suporta as seguintes variáveis de ambiente:

- `API_KEY` – Sua chave de API para serviços externos
- `PROXY_URL` – URL do proxy para todas as solicitações de saída

## Solução de Problemas

### Erro: "Permissão negada"

Se você encontrar um erro de permissão, tente executar com `sudo` ou verifique as permissões do diretório.

### Erro: "Porta já em uso"

Certifique-se de que nenhum outro processo esteja usando a porta especificada:

```bash
lsof -i :8080
```

## Licença

Este projeto está licenciado sob a Licença MIT – consulte o arquivo [LICENSE](https://github.com/git-pkgs/proxy/blob/main/LICENSE) para obter detalhes.
``````json
{
  "results": [
    {
      "ecosystem": "npm",
      "name": "lodash",
      "version": "4.17.0",
      "latest_version": "4.17.21",
      "is_outdated": true
    },
    {
      "ecosystem": "pypi",
      "name": "requests",
      "version": "2.25.0",
      "latest_version": "2.31.0",
      "is_outdated": true
    }
  ]
}
```
#### Consulta em Massa de Pacotes```bash
curl -X POST http://localhost:8080/api/bulk \
  -H "Content-Type: application/json" \
  -d '{
    "purls": [
      "pkg:npm/[email protected]",
      "pkg:pypi/[email protected]"
    ]
  }'
```
## 4. **Análise de Código Estático**

O **Análise de Código Estático** é um processo de depuração realizado examinando o código-fonte antes de um programa ser executado. Este processo é realizado examinando o código e, em seguida, encontrando maneiras de corrigir os problemas encontrados. O processo de análise estática fornece uma compreensão da estrutura do código e pode ajudar a garantir que o código siga os padrões da indústria. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras, etc. O **Análise de Código Estático** é usado para encontrar vulnerabilidades no código, como estouros de buffer, vazamentos de memória, uso de bibliotecas inseguras,```json
{
  "packages": {
    "pkg:npm/lodash": {
      "ecosystem": "npm",
      "name": "lodash",
      "latest_version": "4.17.21",
      "license": "MIT",
      "license_category": "permissive"
    },
    "pkg:pypi/requests": {
      "ecosystem": "pypi",
      "name": "requests",
      "latest_version": "2.31.0",
      "license": "Apache-2.0",
      "license_category": "permissive"
    }
  }
}
```
### Resposta de Estatísticas (endpoint HTTP)```json
{
  "cached_artifacts": 142,
  "total_size_bytes": 523456789,
  "total_size": "499.2 MB",
  "storage_url": "file:///path/to/cache/artifacts",
  "database_path": "./cache/proxy.db"
}
```
## Como Funciona

1. O gerenciador de pacotes solicita os metadados do pacote ao proxy
2. O proxy busca os metadados do upstream, reescreve as URLs dos artefatos para apontar para o proxy
3. O gerenciador de pacotes solicita o artefato (tarball, crate, etc.)
4. O proxy verifica o cache local:
   - **Cache hit**: Serve a partir do armazenamento local
   - **Cache miss**: Busca do upstream, armazena localmente, serve ao cliente
5. Solicitações subsequentes para o mesmo artefato são servidas a partir do cache```
┌─────────────┐     ┌─────────┐     ┌──────────┐
│   npm/cargo │────▶│  proxy  │────▶│ upstream │
│   client    │◀────│         │◀────│ registry │
└─────────────┘     └─────────┘     └──────────┘
                         │
                         ▼
                    ┌─────────┐
                    │  cache  │
                    │ storage │
                    └─────────┘
```
## Interface Web

O proxy serve uma interface web em `/ui`. Não é necessário um build separado do frontend — os templates e assets estão embutidos no binário. `GET /` redireciona para `/ui/`. A interface é montada sob seu próprio prefixo, para que um proxy reverso possa aplicar regras de acesso diferentes a ela em relação aos endpoints de pacotes (por exemplo, exigindo autenticação para `PathPrefix(/ui)` enquanto deixa `/npm`, `/pypi` etc. abertos para máquinas de build).

- **Dashboard** (`/ui/`) — estatísticas de cache, pacotes populares, artefatos recentemente armazenados em cache e visão geral de vulnerabilidades.
- **Guia de instalação** (`/ui/install`) — instruções de configuração por ecossistema, para que você não precise procurá-las aqui.
- **Navegador de pacotes** (`/ui/packages`) — navegue por todos os pacotes em cache com filtro por ecossistema e ordenação por acessos, tamanho, nome ou número de vulnerabilidades.
- **Pesquisa** (`/ui/search?q=...`) — pesquise pacotes em cache por nome.
- **Detalhes do pacote** (`/ui/package/{ecosystem}/{name}`) — metadados, licença, vulnerabilidades e lista de versões de um pacote. Você pode selecionar duas versões para comparar.
- **Detalhes da versão** (`/ui/package/{ecosystem}/{name}/{version}`) — metadados por versão, hash de integridade, status do cache do artefato e contagens de acessos.
- **Navegador de fontes** (`/ui/package/{ecosystem}/{name}/{version}/browse`) — navegue pelos arquivos dentro dos arquivos em cache com realce de sintaxe para arquivos de texto e pré-visualização de imagens.
- **Diff de versões** (`/ui/package/{ecosystem}/{name}/compare/{v1}...{v2}`) — diff lado a lado de duas versões em cache mostrando arquivos adicionados, removidos e alterados.

## Monitoramento

O proxy expõe métricas Prometheus em `GET /metrics`. Todos os nomes de métricas são prefixados com `proxy_`.

| Métrica | Tipo | Rótulos | Descrição |
|--------|------|--------|-------------|
| `proxy_requests_total` | contador | `ecosystem`, `status` | Respostas do proxy por ecossistema de pacotes e status HTTP |
| `proxy_request_duration_seconds` | histograma | `ecosystem`, `status` | Duração das requisições do proxy |
| `proxy_cache_hits_total` | contador | `ecosystem` | Acertos de cache |
| `proxy_cache_misses_total` | contador | `ecosystem` | Erros de cache |
| `proxy_cache_size_bytes` | gauge | | Tamanho total dos artefatos em cache |
| `proxy_cached_artifacts_total` | gauge | | Número de artefatos em cache |
| `proxy_upstream_fetch_duration_seconds` | histograma | `ecosystem` | Tempo gasto buscando do upstream |
| `proxy_upstream_errors_total` | contador | `ecosystem`, `error_type` | Falhas de busca no upstream |
| `proxy_storage_operation_duration_seconds` | histograma | `operation` | Latência de leitura/gravação do armazenamento |
| `proxy_storage_errors_total` | contador | `operation` | Falhas de leitura/gravação do armazenamento |
| `proxy_active_requests` | gauge | | Requisições em andamento |
| `proxy_health_probe_failures_total` | contador | `step` | Falhas de sondagem de saúde do armazenamento por etapa com falha (`write`, `size`, `read`, `verify`, `delete`). |

O tamanho do cache e a contagem de artefatos são atualizados a cada 60 segundos. As métricas restantes são atualizadas a cada requisição.

### Verificação de Saúde

`/health` retorna um relatório JSON estruturado da saúde dos subsistemas. HTTP 200 se todas as verificações passarem; 503 se qualquer uma falhar.```json
{
  "status": "ok",
  "checks": {
    "database": {"status": "ok"},
    "storage":  {"status": "ok"}
  }
}
```
As verificações com falha incluem um campo `"error"`. Falhas de armazenamento também incluem um campo `"step"` identificando qual etapa da sondagem falhou (`write`, `size`, `read`, `verify`, `delete`). Quando a verificação do banco de dados falha, a entrada de armazenamento reporta `{"status": "skipped"}` para que a resposta sempre carregue o mesmo conjunto de chaves.

Os resultados da sondagem de armazenamento são armazenados em cache por `health.storage_probe_interval` (padrão 30s) para limitar o custo de sondar backends remotos. Uma sondagem mantém um mutex interno por até 10 segundos (o timeout fixo por sondagem), então `/health` é destinado a ser uma sonda de **prontidão** do Kubernetes em vez de uma sonda de vivacidade — uma ida e volta lenta ao S3 deve tirar o pod da rotação, não reiniciá-lo.

Configuração de scrape para o Prometheus:```yaml
scrape_configs:
  - job_name: git-pkgs-proxy
    static_configs:
      - targets: ["localhost:8080"]
```
## Production Deployment

### Serviço Systemd

Crie `/etc/systemd/system/proxy.service`:```ini
[Unit]
Description=git-pkgs proxy
After=network.target

[Service]
Type=simple
User=proxy
ExecStart=/usr/local/bin/proxy -config /etc/proxy/config.yaml
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
```
Ative e inicie:```bash
sudo systemctl enable proxy
sudo systemctl start proxy
```
### Docker

Um Dockerfile está incluído no repositório. Compile e execute:```bash
docker build -t proxy .
docker run -p 8080:8080 -v proxy-data:/data proxy
```
Com o Postgres e o S3:```bash
docker run -p 8080:8080 \
  -e PROXY_DATABASE_DRIVER=postgres \
  -e PROXY_DATABASE_URL=postgres://user:pass@db:5432/proxy \
  -e PROXY_STORAGE_URL=s3://my-bucket?region=us-east-1 \
  -e AWS_ACCESS_KEY_ID=... \
  -e AWS_SECRET_ACCESS_KEY=... \
  proxy
```
### Atrás de um Proxy Reverso

Ao executar atrás de nginx, Apache ou outro proxy reverso, defina `base_url` para a sua URL pública:```yaml
base_url: "https://proxy.example.com"
```
Se a interface for acessada em um hostname diferente dos endpoints do pacote — por exemplo, a interface exposta publicamente em um domínio enquanto as máquinas de build acessam um alias de rede Docker — defina `ui_base_url` separadamente. `base_url` é a URL que os gerenciadores de pacotes e a reescrita de metadados usam; `ui_base_url` é a URL anunciada aos humanos que visitam a interface web (tags canônicas/`og:url` e o banner do guia de instalação):```yaml
base_url: "http://pkg-proxy:8080"        # internal alias for build machines
ui_base_url: "https://proxy.example.com/ui"  # public UI URL
```
Quando não definido, `ui_base_url` assume o valor de `base_url`.

> **Aviso:** o proxy serve a interface e os endpoints de pacotes no mesmo listener. Definir `ui_base_url` apenas altera qual URL a interface anuncia aos humanos; isso não impede que os endpoints de pacotes permaneçam acessíveis no mesmo hostname e porta. Ao colocar o proxy atrás de um reverse proxy público, restrinja a rota pública a `PathPrefix(/ui)` (ou o equivalente do seu proxy), caso contrário, `/npm`, `/pypi` e os demais endpoints de pacotes permanecerão expostos junto com a interface.

Exemplo de nginx, restringindo o host público à interface enquanto mantém os endpoints de pacotes acessíveis apenas no listener interno:```nginx
server {
    listen 443 ssl;
    server_name proxy.example.com;

    location /ui/ {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_buffering off;
    }

    location / {
        return 404;
    }
}
```
Traefik example using `PathPrefix(/ui)` so the public router only matches UI traffic:```yaml
labels:
  traefik.enable: "true"
  traefik.http.services.pkg-proxy.loadbalancer.server.port: "8080"
  traefik.http.routers.pkg-proxy.rule: "Host(`proxy.example.com`) && PathPrefix(`/ui`)"
  traefik.http.routers.pkg-proxy.entrypoints: "websecure"
```
## Gestão de Cache

O proxy armazena artefatos no diretório de armazenamento configurado com esta estrutura:```
cache/artifacts/
├── npm/
│   └── lodash/
│       └── 4.17.21/
│           └── lodash-4.17.21.tgz
├── cargo/
│   └── serde/
│       └── 1.0.193/
│           └── serde-1.0.193.crate
├── oci/
│   └── library/nginx/
│       └── sha256:abc123.../
│           └── sha256:abc123...
├── deb/
│   └── nginx/
│       └── 1.18.0-6/
│           └── nginx_1.18.0-6_amd64.deb
└── rpm/
    └── nginx/
        └── 1.24.0-1.fc39/
            └── nginx-1.24.0-1.fc39.x86_64.rpm
```
Cache metadata é armazenado em SQLite (padrão) ou PostgreSQL. Para limpar um cache local:```bash
rm -rf ./cache/artifacts/*
rm ./cache/proxy.db
```
O proxy recriará o banco de dados na próxima inicialização.

## Compilando a partir do código-fonte

Requisitos:

- Go (a versão do projeto está declarada em `go.mod`)```bash
git clone https://github.com/git-pkgs/proxy.git
cd proxy
go build -o proxy ./cmd/proxy
```
Rode os testes:```bash
go test ./...
```
## Licença

GPL-3.0-ou-posterior

Ler mais

proxy v0.7.0

Categorias