Suporta: macOS (Apple Silicon & Intel) · Windows · Linux

Galileu é uma ferramenta de segurança e governança de dados voltada para o monitoramento e sanitização de informações enviadas a provedores de Inteligência Artificial (LLMs). O projeto adota uma arquitetura de Proxy Reverso MITM (Man-in-the-Middle), atuando como camada inteligente entre a sua ferramenta de desenvolvimento e os servidores das LLMs.

O Galileu é agnóstico a ferramentas de AI — funciona com qualquer ferramenta que permita configurar um proxy customizado: OpenCode, Claude Code, Cursor, Windsurf, GitHub Copilot, Gemini CLI, Codex e muito mais.

O Galileu funciona com qualquer ferramenta de AI que permita configurar um proxy:

O GIF acima mostra o OpenCode tentando ler dados sensíveis de ficheiros .env — o Galileu intercepta e sanitiza automaticamente as informações antes de chegarem à LLM.

Print do terminal durante a execução do Galileu, mostrando o proxy ativo e os registros de auditoria.

Diagrama da arquitetura e funcionamento do sistema.

┌─────────────────────────────────────────────────────────────────┐
│                         GALILEU PROXY                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Request → Filter(Input) → [Is JSON? + Is POST?] →              │
│                                     │                           │
│                          ┌──────────┴──────────┐                │
│                          │                     │                │
│                   Skip (telemetry)      Analyze (Payload)       │
│                                              │                  │
│                                        ┌─────┴─────┐            │
│                                        │           │            │
│                                  ┌─────▼───┐   ┌───▼────┐       │
│                                  │ Has model│  │  Has   │       │
│                                  │ messages │  │contents│       │
│                                  │  etc?    │  │  etc?  │       │
│                                  └─────┬───┘   └────┬───┘       │
│                                        │            │           │
│                                        └──────┬─────┘           │
│                                          Detected!              │
│                                              │                  │
│                                    ┌─────────┴─────────┐        │
│                                    │ Infer Provider    │        │
│                                    │ from Payload      │        │
│                                    └─────────┬─────────┘        │
└─────────────────────────────────────────────┼─────────────────┘
                                              │
                                        Analyze for
                                        sensitive data

Baixe o binário pré-compilado para a sua plataforma em Releases:

macOS / Linux:

chmod +x galileu-darwin-arm64
./galileu-darwin-arm64

Windows:

Execute galileu-windows-amd64.exe como Administrador (clique direito → "Executar como administrador").

Não é necessário ter Go instalado. A compilação é necessária apenas para desenvolvimento.

O binário funciona de forma autônoma. O arquivo galileu.yml é opcional — se não existir, todos os padrões built-in são ativados automaticamente.

O Galileu procura o galileu.yml no diretório onde o binário é executado, não dentro do próprio binário.

pasta-do-usuario/
├── galileu-darwin-arm64   ← binário baixado
└── galileu.yml            ← arquivo opcional (criado pelo usuário)

Para personalizar, crie um galileu.yml na mesma pasta do binário usando o galileu.yml.example como referência.

make build-mac-arm

make build-mac-intel

make build-windows

make build-linux

Ou compilar para todas as plataformas de uma vez:

make build-all

⚠️ PONTO CRÍTICO DE SEGURANÇA

O Galileu gera um Certificado de Autoridade (CA) localmente na sua máquina. Este certificado é exclusivo para o seu ambiente e nunca deve sair do seu computador.

┌─────────────────────────────────────────────────────────────┐
│                    SUA MÁQUINA LOCAL                        │
│                                                             │
│  ┌──────────┐    ┌──────────────────┐    ┌──────────┐       │
│  │ Cliente  │───▶│  Galileu Proxy  │───▶│   LLM    │       │
│  │ (Claude   │◀───│  (localhost:9000)│◀───│ Provider│       │
│  │  Code)    │    │                  │    │          │       │
│  └──────────┘    └──────────────────┘    └──────────┘       │
│                        │                                    │
│                        ▼                                    │
│              ┌──────────────────┐                           │
│              │   Certificado CA  │                          │
│              │  (Local apenas)   │                          │
│              │                   │                          │
│              │ galileu-ca.pem    │  ⚠️ NUNCA                │
│              │ galileu-ca-key.pem│  ⚠️ COMPARTILHAR         │
│              └──────────────────┘                           │
│                        │                                    │
│                        ▼                                    │
│              ┌──────────────────┐                           │
│              │  Keychain / Cert │                           │
│              │  Store do SO     │                           │
│              └──────────────────┘                           │
└─────────────────────────────────────────────────────────────┘

1. O Galileu gera um par de chaves RSA 4096-bit localmente (galileu-ca.pem + galileu-ca-key.pem)
2. O certificado é instalado apenas no seu sistema operacional (Keychain no macOS, Cert Store no Windows, /usr/local/share/ca-certificates/ no Linux)
3. Quando o proxy intercepta uma requisição HTTPS, ele apresenta um certificado assinado por esta CA
4. O seu SO confia no certificado porque a CA está instalada localmente
5. A chave privada (galileu-ca-key.pem) nunca sai da sua máquina

O Galileu tentará instalar o certificado automaticamente no Keychain do sistema (será solicitada a senha de administrador na primeira execução). Caso prefira instalar manualmente:

sudo security add-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain galileu-ca.pem

O Galileu instala automaticamente o certificado CA no repositório de certificados do sistema ao executar como Administrador. Basta executar galileu.exe com privilégios administrativos.

O Galileu instala automaticamente o certificado CA no repositório de certificados do sistema ao executar com privilégios de sudo (na primeira execução será solicitada a senha). Caso prefira instalar manualmente:

sudo cp galileu-ca.pem /usr/local/share/ca-certificates/galileu.crt
sudo update-ca-certificates

Se precisar remover o certificado CA do seu sistema, utilize os comandos abaixo:

sudo security remove-trusted-cert -d -r trustRoot \
  -k /Library/Keychains/System.keychain "Galileu Local CA"

Ou use o Makefile:

make uninstall-cert-macos

sudo rm /usr/local/share/ca-certificates/galileu.crt
sudo update-ca-certificates

Ou use o Makefile:

make uninstall-cert-linux

Execute no PowerShell como Administrador:

certutil -delstore -f Root "Galileu Local CA"

Ou use o Makefile (execute como Administrador):

make uninstall-cert-windows

Nota: Após desinstalar o certificado, o proxy não funcionará até que o certificado seja reinstalado. Para reinstalar, basta executar o Galileu novamente.

O seu .gitignore já está configurado para impedir o commit acidental:

# Certificados — nunca versionar
*.pem
galileu-ca-key.pem
galileu-ca.pem

NUNCA remova estas linhas do .gitignore. A chave privada (galileu-ca-key.pem) é o que permite ao Galileu fazer o MITM — se ela for exposta, um atacante pode criar certificados falsificados em seu nome.

Se a chave privada (galileu-ca-key.pem) vazar, um atacante pode:

• Criar certificados SSL válidos para qualquer domínio (Google, AWS, bancos, etc.)
• Interceptar todo o tráfego HTTPS da rede onde o certificado for confiar
• Realizar ataques de MITM sofisticados sem que o usuário perceba
• Assinar certificados que serão trustados por qualquer máquina que tenha o certificado CA instalado

Consequência: Qualquer dispositivo que tenha o certificado CA do Galileu instalado passa a confiar em certificados fraudulentos criados pelo atacante.

Se o binário (galileu) for comprometido (malware ou substituição), um atacante pode:

• Modificar o comportamento do proxy para exfiltrar dados sensíveis das requisições
• Armazenar em log todas as mensagens enviadas aos provedores de LLM
• Alterar as respostas dos LLMs antes de retorná-las ao cliente
• Usar a mesma infraestrutura de proxy para ataques adicionais

Mitigação:

• Sempre verifique a integridade do binário (checksums, assinaturas)
• Baixe binários apenas de fontes oficiais
• Mantenha o sistema operacional e dependências atualizados
• Utilize ferramentas de detecção de integridade (ex: AIDE, Tripwire)

O binário galileu suporta os seguintes subcomandos:

O modo --dry-run permite testar a detecção de dados sensíveis sem modificar os payloads:

./galileu --dry-run

Quando ativado:

• O proxy analisa todas as requisições normalmente
• Detecta padrões sensíveis e exibe quais dados seriam redatados
• Não modifica o payload original - mantém intacto
• Útil para debugging e verificação de padrões de detecção

Exemplo de saída:

[GALILEU] Modo DRY-RUN ativo - apenas detectando, sem modificar payloads.
[GALILEU] [DRY-RUN] Detectado em api.openai.com: 2 dado(s) sensivel(is) - NAO modificado.
[GALILEU]         Padroes: [openai_key, github_token]

O comando doctor verifica:

• Certificado CA: Se o certificado está instalado no repositório do sistema
• Porta: Se a porta configurada está disponível
• Variáveis de ambiente: Se GALILEU_PORT está configurada

Exemplo de saída:

=== Diagnostico do Galileu ===

Certificado CA:      [OK] Instalado
Porta configurada:    [OK] 9000 (padrao)
Porta disponivel:    [OK] Livre

Tudo OK!

O Makefile facilita a compilação e execução:

# Mostrar ajuda
make help

# Compilar para a plataforma atual
make build

# Executar o proxy
make run

# Executar diagnóstico
make doctor

# Executar todos os testes
make test

# Executar benchmarks
make benchmarks

# Limpar binários
make clean

make build-all          # Compilar para macOS, Windows e Linux
make build-mac-arm      # macOS Apple Silicon (M1/M2/M3)
make build-mac-intel    # macOS Intel
make build-windows      # Windows
make build-linux        # Linux

Após compilado, você pode executar o binário diretamente:

./galileu               # iniciar proxy
./galileu --dry-run     # iniciar proxy em modo DRY-RUN
./galileu doctor        # verificar diagnóstico
./galileu version       # mostrar versão
./galileu -h            # mostrar ajuda

Nota: Certifique-se de que a ferramenta de AI está configurada para usar o proxy na porta 9000, ou na porta que você configurou.

Não é necessário ter Go instalado.

Galileu/
├── galileu                  # Executável (macOS/Linux)
├── galileu.exe              # Executável (Windows)
├── galileu-ca.pem           # Certificado CA gerado automaticamente
├── galileu-ca-key.pem       # Chave privada do CA (⚠️ NÃO submeter para o repositório)
├── galileu.yml              # Configuração do analyzer (não versionado)
├── galileu.yml.example      # Exemplo de configuração (versionado)
├── Makefile                 # Compilação multiplataforma
├── scripts/
│   ├── start.sh             # Script shell para iniciar o OpenCode com proxy (macOS/Linux)
│   └── start.bat            # Script batch para iniciar o OpenCode com proxy (Windows)
├── cmd/
│   └── galileu/
│       └── main.go          # Ponto de entrada
├── internal/
│   ├── ca/                  # Geração e gestão do certificado CA
│   ├── doctor/              # Diagnóstico do sistema
│   └── guardian/            # Proxy MITM, Analyzer, Audit, instalação de certificado por plataforma
└── galileu_audit.log        # Registo de auditoria (gerado automaticamente na primeira execução)

O Galileu é agnóstico a ferramentas de AI. Ele detecta automaticamente requisições de AI através da análise do payload, não do host.

O Galileu analisa o corpo (body) da requisição JSON e detecta se é uma requisição de AI através de campos característicos:

O provider é inferido automaticamente do payload:

O Galileu suporta dois modos de operação:

Apenas hosts permitidos são analisados:

proxy:
  mode: whitelist
  allowed_hosts:
    - "*.openai.com"
    - "*.anthropic.com"
    - "*.generativelanguage.googleapis.com"
  skip_hosts:
    - "*.telemetry.*"

Todos os hosts são analisados, exceto os de telemetry/analytics:

proxy:
  mode: passive
  skip_hosts:
    - "*.telemetry.*"
    - "*.analytics.*"

O Galileu suporta wildcards em hosts:

No modo whitelist, o Galileu intercepta requisições para os seguintes hosts:

O Analyzer detecta e sanitiza automaticamente os seguintes padrões:

Todos os dados sensíveis detectados são substituídos por [REDACTED_BY_GALILEU].

O algoritmo de análise foi benchmarkado em hardware real com múltiplas metodologias:

CPU: 13th Gen Intel(R) Core(TM) i5-13400
OS:  Linux (amd64)

BenchmarkAnalyze-16      405961      2540 ns/op      13568 B/op      1 allocs/op

=== Latência em Nanosegundos ===
Total de operações: 7000
Média: 1072.12 ns (1.07 µs)
Min: 542 ns
Max: 60242 ns
P50: 706 ns  (0.71 µs)
P95: 2329 ns (2.33 µs)
P99: 5446 ns (5.45 µs)
Throughput estimado: ~932,729 ops/s

=== Throughput ===
Total de requisições processadas: 700
Tempo total: 0.66 ms
Média por requisição: 0.94 µs
Throughput: 1,063,458 req/s

Resultados Consolidados:

Nota Metodológica: O benchmark primário é o teste testing.B do Go (405.961 iterações), o padrão mais rigoroso da linguagem. Os valores de throughput são baseados em amostras menores (700 operações) e servem como referência complementar.

O detector foi exaustivamente testado para garantir 0% de falsos positivos:

Todos os 17 padrões suportados foram detectados corretamente:

• ✓ openai_key (2 casos)
• ✓ openai_project_key (2 casos)
• ✓ anthropic_key (2 casos)
• ✓ google_key (2 casos)
• ✓ github_token (2 casos)
• ✓ slack_token (6 casos)
• ✓ aws_access_key (1 caso)

Resultado: 0/32 (0.00%) — ZERO falsos positivos nos casos de testes atuais(confira em /guardian/analyzer_detection_test.go).

Casos testados que NÃO foram detectados:

• ✓ UUIDs (v4)
• ✓ MD5/SHA hashes
• ✓ Base64 strings
• ✓ Payloads normais (GPT, Claude, Gemini)
• ✓ Nomes de métodos Go
• ✓ URLs e caminhos
• ✓ Tokens de outros serviços

Resultados dos Testes:

O ficheiro galileu_audit.log é criado automaticamente ao finalizar a primeira execução e contém um registro JSON detalhado de cada requisição interceptada:

• Identificação: Timestamp, Request ID, Session ID, Machine ID
• Requisição: Host, Provider (inferido do payload), Path, Method, Modelo de LLM
• Detecção: Padrões detectados, contagem, posições de redação
• Payload: Contagem de mensagens, presença de system prompt, streaming
• Performance: Latência do proxy, duração da análise
• Resposta: Status code, tamanhos de request/response

Requests ignorados (telemetry, analytics) são logados com provider: "skipped".

Consulte o ficheiro markdown/SCHEMA_AUDITORIA.md para o schema completo dos campos de auditoria.

O ficheiro galileu.yml é opcional e deve ser colocado no diretório onde o binário é executado. Se não existir, todos os padrões built-in são ativados automaticamente.

port: 9000

# Configuração do Proxy (opcional)
proxy:
  mode: whitelist          # whitelist | passive
  allowed_hosts:           # usado apenas no modo whitelist
    - "*.openai.com"
    - "*.anthropic.com"
  skip_hosts:              # hosts sempre ignorados
    - "*.telemetry.*"
    - "*.analytics.*"

analyzer:

  # ─── Padrões embutidos ──────────────────────────────────────
  built_in:
    openai_key:         true
    openai_project_key: true
    anthropic_key:      true
    google_key:         true
    github_token:       true
    slack_token:        true
    discord_token:      true
    aws_key:            true

  # ─── Padrões personalizados ─────────────────────────────────
  custom_patterns:
    # ...

proxy:
  mode: passive
  skip_hosts:
    - "*.telemetry.*"
    - "*.analytics.*"
    - "mobile.events.data.microsoft.com"

port: 9000

Você pode escolher qualquer porta disponível. O padrão é 9000.

Nota: Lembre-se de apontar a sua ferramenta de AI para a mesma porta definida aqui.

Regex — para padrões complexos:

custom_patterns:
  - name: "JWT Token"
    type: regex
    pattern: 'eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+'
    label: "[JWT_REDACTED]"
    enabled: true

Literal — para strings exatas:

custom_patterns:
  - name: "Projetos Confidenciais"
    type: literal
    values:
      - "Operação Phoenix"
      - "Projeto Stargate"
    label: "[CONFIDENTIAL_PROJECT_REDACTED]"
    enabled: true

Regex Customizado:

• DB_PASSWORD: 5/5 ✓
• Connection String: 5/5 ✓
• JWT: 1/1 ✓
• Private Key: 5/5 ✓
• False Positives: 0/10 (0.00%) ✓

Literal Customizado:

• Tabelas Internas: 5/5 ✓
• Projetos Confidenciais: 5/5 ✓

1. Formato YAML: Use espaços (não tabs) para indentação
2. Aspas em Regex: Use aspas simples '...' para patterns regex
3. Escape: Use \x27 para evitar conflitos com aspas em patterns
4. Enabled: enabled: true para ativar, enabled: false para desativar
5. Label: O texto de substituição deve ser único e descritivo

Execute todos os testes com:

make test

# Testes do analyzer
make test

# Benchmarks de performance
make benchmarks

# Relatório de cobertura
make test-coverage

# Testes de filtro e detecção
go test -v -run "TestShouldProcessRequest|TestIsAIRequest|TestMatchWildcard" ./internal/guardian/...

# Testes de provider inference
go test -v -run "TestInferFromPayload" ./internal/guardian/...

Consulte o ficheiro markdown/tests.md para mais informações sobre a execução dos testes.

"Falha ao ler certificado CA" Remova os ficheiros galileu-ca.pem e galileu-ca-key.pem e execute novamente. O certificado será regenerado automaticamente.

Windows: "Privilégios de administrador necessários" Execute o galileu.exe como Administrador (clique direito → "Executar como administrador").

Linux: Erro de certificado SSL/TLS Certifique-se de que instalou o certificado conforme as instruções na secção "Configuração do Certificado CA".

Claude Code / Cursor não funciona com proxy Configure o proxy no modo passive e adicione hosts de telemetry aos skip_hosts. Veja a seção "Configuração (galileu.yml)".

• A chave privada (galileu-ca-key.pem) é gerada localmente e nunca sai da sua máquina
• Nunca efetue commit dos ficheiros .pem para o repositório
• O certificado CA é válido por 10 anos com chave RSA 4096-bit
• O proxy atua exclusivamente sobre as ferramentas que configurarem a porta definida

Cada binário publicado nas releases inclui um checksum SHA256. Para verificar a integridade do binário baixado:

Linux/macOS:

sha256sum galileu-linux-amd64
# Compare com o checksum publicado na release

Windows (PowerShell):

Get-FileHash galileu-windows-amd64.exe -Algorithm SHA256
# Compare com o checksum publicado na release

O arquivo checksums.txt contém todos os checksums e pode ser verificado com:

sha256sum -c checksums.txt

Consulte o ficheiro SECURITY.md para obter informações acerca do reporte de vulnerabilidades.

Este projeto está licenciado sob a Apache License, Version 2.0.

Copyright © 2026 Bruno Dantas de Oliveira Casé

Ver ficheiro LICENSE para mais detalhes.