Ein HTTPS-Proxy-Server, der Secrets in LLM-Kommunikation erkennt, maskiert und nach der Antwort wieder einsetzt. Entwickelt für die sichere Nutzung von LLM-Tools wie GitHub Copilot, ohne dass sensible Daten an Cloud-Provider übertragen werden.
- Man-in-the-Middle Proxy mit eigener Self-Signed CA für TLS-Interception
- Modulare Secret-Erkennung durch Plugin-Architektur (Entropie-basiert, Bitwarden, erweiterbar)
- Automatische Protokoll-Erkennung für verschiedene LLM-APIs (OpenAI, Anthropic, etc.)
- Streaming-Unterstützung mit intelligentem Read-Ahead Buffer
- Skalierbar durch In-Memory oder Redis-basierte Mapping-Speicherung
- Monitoring via Prometheus-Metriken-Endpunkt
┌─────────────────────────────────────────────────────────────────────────────┐
│ LLM Secret Interceptor │
└─────────────────────────────────────────────────────────────────────────────┘
┌──────────┐ HTTPS ┌─────────────────────────────────────────────────────────────┐
│ │ ─────────────► │ PROXY SERVER │
│ Client │ │ ┌─────────────────────────────────────────────────────┐ │
│ (VSCode) │ │ │ TLS Interception Layer │ │
│ │ ◄───────────── │ │ (Self-Signed CA / MITM) │ │
└──────────┘ HTTPS │ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Protocol Auto-Detection │ │
│ │ (OpenAI Format, Anthropic Format, ...) │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Standardized Internal Format │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Secret Interceptor Manager │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Entropy │ │ Bitwarden │ │ Custom │ │ │
│ │ │ Interceptor │ │ Interceptor │ │ Interceptor │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Secret Replacer │ │
│ │ "password123" → "__SECRET_a1b2c3d4__" │ │
│ └─────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Mapping Store (TTL-based) │ │
│ │ [In-Memory Map] or [Redis] │ │
│ └─────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────┘
│
▼ HTTPS
┌──────────────────────────────────────────────────────────────┐
│ LLM Cloud Provider │
│ (OpenAI, GitHub Copilot, etc.) │
└──────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ REQUEST FLOW │
└─────────────────────────────────────────────────────────────────────────────┘
Client Request Proxy Processing To LLM
│ │ │
│ "Fix bug with │ │
│ password: abc123" │ │
│ │ │
▼ ▼ ▼
┌─────────┐ ┌─────────────┐ ┌───────────┐ ┌─────────────┐ ┌─────┐
│ Client │───►│ TLS Decrypt │───►│ Detect │───►│ Replace │───►│ LLM │
│ Request │ │ & Parse │ │ Secrets │ │ Secrets │ │ API │
└─────────┘ └─────────────┘ └───────────┘ └─────────────┘ └─────┘
│ │
▼ ▼
┌───────────┐ ┌───────────┐
│ "abc123" │ │ Store │
│ flagged │ │ Mapping │
└───────────┘ └───────────┘
Sent to LLM: "Fix bug with password: __SECRET_a1b2c3d4__"
┌─────────────────────────────────────────────────────────────────────────────┐
│ RESPONSE FLOW │
└─────────────────────────────────────────────────────────────────────────────┘
From LLM Proxy Processing To Client
│ │ │
│ "Change __SECRET_a1b2c3d4__ │ │
│ to a stronger password" │ │
│ │ │
▼ ▼ ▼
┌─────────┐ ┌─────────────┐ ┌───────────┐ ┌─────────────┐ ┌────────┐
│ LLM │───►│ Read-Ahead │───►│ Lookup │───►│ Replace │───►│ Client │
│ Stream │ │ Buffer │ │ Mapping │ │ Placeholder │ │ │
└─────────┘ └─────────────┘ └───────────┘ └─────────────┘ └────────┘
│
▼
┌───────────┐
│ Buffer N │
│ chars for │
│ streaming │
└───────────┘
Sent to Client: "Change abc123 to a stronger password"
Der einfachste Weg, den Proxy zu starten:
# Repository klonen
git clone https://github.com/hfi/llm-secret-interceptor.git
cd llm-secret-interceptor
# Konfiguration anpassen (optional)
cp configs/config.example.yaml configs/config.yaml
# Starten mit Docker Compose
docker compose up -d
# Logs anzeigen
docker compose logs -f proxyDer Proxy ist nun erreichbar unter:
- Proxy:
http://localhost:8080 - Metrics/Health:
http://localhost:9090
# Image bauen
docker build -t llm-secret-interceptor:latest .
# Container starten
docker run -d \
--name llm-proxy \
-p 8080:8080 \
-p 9090:9090 \
-v $(pwd)/certs:/app/certs \
-v $(pwd)/configs/config.yaml:/app/configs/config.yaml:ro \
llm-secret-interceptor:latestInstall using Helm chart:
# Add the Helm repository
helm repo add llm-secret-interceptor https://hfi.github.io/llm-secret-interceptor/
helm repo update
# Install with default values
helm install llm-proxy llm-secret-interceptor/llm-secret-interceptor
# Or install with custom values
helm install llm-proxy llm-secret-interceptor/llm-secret-interceptor \
--set config.logging.level=debug \
--set config.interceptors.entropy.threshold=4.0With existing TLS CA secret:
# Create secret with your CA certificate
kubectl create secret generic llm-proxy-ca \
--from-file=ca.crt=./certs/ca.crt \
--from-file=ca.key=./certs/ca.key
# Install with existing secret
helm install llm-proxy llm-secret-interceptor/llm-secret-interceptor \
--set tls.existingSecret=llm-proxy-caWith inline CA certificate:
helm install llm-proxy llm-secret-interceptor/llm-secret-interceptor \
--set-file tls.caCert=./certs/ca.crt \
--set-file tls.caKey=./certs/ca.keyFull configuration example (values.yaml):
replicaCount: 2
config:
storage:
type: "redis"
interceptors:
entropy:
enabled: true
threshold: 4.5
bitwarden:
enabled: true
server_url: "https://vault.bitwarden.com"
logging:
level: "info"
redis:
external:
host: "redis.default.svc.cluster.local"
port: 6379
extraEnv:
- name: BITWARDEN_EMAIL
valueFrom:
secretKeyRef:
name: bitwarden-credentials
key: email
- name: BITWARDEN_PASSWORD
valueFrom:
secretKeyRef:
name: bitwarden-credentials
key: password
tls:
existingSecret: "llm-proxy-ca"
metrics:
serviceMonitor:
enabled: true
ingress:
enabled: true
className: "nginx"
hosts:
- host: llm-proxy.example.com
paths:
- path: /
pathType: Prefix
tls:
- secretName: llm-proxy-tls
hosts:
- llm-proxy.example.comhelm install llm-proxy llm-secret-interceptor/llm-secret-interceptor -f values.yaml# Repository klonen
git clone https://github.com/hfi/llm-secret-interceptor.git
cd llm-secret-interceptor
# Binary bauen
make build
# CA-Zertifikat generieren
make generate-ca
# Proxy starten
./bin/llm-secret-interceptorBeim ersten Start wird automatisch ein CA-Zertifikat generiert. Manuell:
# Über das Binary
./bin/llm-secret-interceptor generate-ca [cert-path] [key-path]
# Über Make
make generate-caDie Konfiguration erfolgt über eine YAML-Datei:
# config.yaml
proxy:
listen: ":8080"
tls:
ca_cert: "/app/certs/ca.crt"
ca_key: "/app/certs/ca.key"
storage:
# "memory" für Single-Instance, "redis" für Multi-Instance
type: "memory"
redis:
address: "localhost:6379"
password: ""
db: 0
ttl: "24h" # Mappings werden nach 24h Inaktivität gelöscht
placeholder:
prefix: "__SECRET_"
suffix: "__"
interceptors:
entropy:
enabled: true
threshold: 4.5 # Shannon-Entropie Schwellenwert
min_length: 8
bitwarden:
enabled: false
server_url: "https://vault.bitwarden.com"
# Credentials via Environment-Variablen
logging:
level: "info" # debug, info, warn, error
audit:
enabled: true
log_interceptor_name: true
log_secret_type: true
# Secrets selbst werden NIEMALS geloggt!
metrics:
enabled: true
endpoint: "/metrics"
port: 9090-
CA-Zertifikat installieren:
# macOS sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain ./certs/ca.crt # Linux sudo cp ./certs/ca.crt /usr/local/share/ca-certificates/ sudo update-ca-certificates
-
Proxy in VSCode konfigurieren (settings.json):
{ "http.proxy": "https://localhost:8080", "http.proxyStrictSSL": true }
Der Proxy stellt folgende Metriken unter /metrics bereit:
llm_proxy_requests_total– Gesamtanzahl verarbeiteter Requestsllm_proxy_secrets_detected_total– Anzahl erkannter Secrets (nach Interceptor)llm_proxy_secrets_replaced_total– Anzahl ersetzter Secretsllm_proxy_mapping_store_size– Aktuelle Größe des Mapping-Storesllm_proxy_request_duration_seconds– Request-Latenz
Eigene Interceptors können implementiert werden:
type SecretInterceptor interface {
// Name returns the interceptor name for logging/metrics
Name() string
// Detect analyzes text and returns found secrets
Detect(text string) []DetectedSecret
// Configure applies configuration from YAML
Configure(config map[string]interface{}) error
}
type DetectedSecret struct {
Value string
StartIndex int
EndIndex int
Type string // z.B. "password", "api_key", "token"
Confidence float64 // 0.0 - 1.0
}- Sprache: Go
- TLS: crypto/tls mit dynamischer Zertifikatsgenerierung
- HTTP Proxy: goproxy oder eigene Implementierung
- Konfiguration: gopkg.in/yaml.v3
- Metriken: prometheus/client_golang
- Redis: go-redis/redis
Apache 2.0 License