Abusando de Cloudflare Workers como pass-through proxies (IP rotation, FireProx-style)

Reading time: 8 minutes

Cloudflare Workers podem ser implantados como pass-through proxies HTTP transparentes onde a URL alvo upstream é fornecida pelo cliente. As requisições saem da rede da Cloudflare, então o destino observa os IPs da Cloudflare em vez dos do cliente. Isso espelha a conhecida técnica FireProx no AWS API Gateway, mas usando Cloudflare Workers.

Principais capacidades

• Suporte a todos os métodos HTTP (GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD)
• O target pode ser fornecido via query parameter (?url=...), um header (X-Target-URL), ou até codificado no path (por exemplo, /https://target)
• Os headers e o corpo são encaminhados via proxy com filtragem hop-by-hop/headers conforme necessário
• As respostas são retransmitidas de volta, preservando o código de status e a maioria dos headers
• Falsificação opcional do X-Forwarded-For (se o Worker defini-lo a partir de um header controlado pelo usuário)
• Rotação extremamente rápida/fácil ao implantar múltiplos endpoints do Worker e distribuir as requisições

Como funciona (fluxo)

1. O cliente envia uma requisição HTTP para uma URL do Worker (<name>.<account>.workers.dev ou uma rota de domínio customizado).
2. O Worker extrai o target a partir de um parâmetro de query (?url=...), do header X-Target-URL, ou de um segmento de path se implementado.
3. O Worker encaminha o método, os headers e o corpo recebidos para a URL upstream especificada (filtrando headers problemáticos).
4. A resposta upstream é transmitida de volta ao cliente através da Cloudflare; a origem vê os IPs de saída da Cloudflare.

Exemplo de implementação do Worker

• Lê a URL alvo do query param, header ou path
• Copia um subconjunto seguro de headers e encaminha o método/corpo original
• Opcionalmente define X-Forwarded-For usando um header controlado pelo usuário (X-My-X-Forwarded-For) ou um IP aleatório
• Adiciona CORS permissivo e lida com preflight

/**
* Minimal Worker pass-through proxy
* - Target URL from ?url=, X-Target-URL, or /https://...
* - Proxies method/headers/body to upstream; relays response
*/
addEventListener('fetch', event => {
event.respondWith(handleRequest(event.request))
})

async function handleRequest(request) {
try {
const url = new URL(request.url)
const targetUrl = getTargetUrl(url, request.headers)

if (!targetUrl) {
return errorJSON('No target URL specified', 400, {
usage: {
query_param: '?url=https://example.com',
header: 'X-Target-URL: https://example.com',
path: '/https://example.com'
}
})
}

let target
try { target = new URL(targetUrl) } catch (e) {
return errorJSON('Invalid target URL', 400, { provided: targetUrl })
}

// Forward original query params except control ones
const passthru = new URLSearchParams()
for (const [k, v] of url.searchParams) {
if (!['url', '_cb', '_t'].includes(k)) passthru.append(k, v)
}
if (passthru.toString()) target.search = passthru.toString()

// Build proxied request
const proxyReq = buildProxyRequest(request, target)
const upstream = await fetch(proxyReq)

return buildProxyResponse(upstream, request.method)
} catch (error) {
return errorJSON('Proxy request failed', 500, {
message: error.message,
timestamp: new Date().toISOString()
})
}
}

function getTargetUrl(url, headers) {
let t = url.searchParams.get('url') || headers.get('X-Target-URL')
if (!t && url.pathname !== '/') {
const p = url.pathname.slice(1)
if (p.startsWith('http')) t = p
}
return t
}

function buildProxyRequest(request, target) {
const h = new Headers()
const allow = [
'accept','accept-language','accept-encoding','authorization',
'cache-control','content-type','origin','referer','user-agent'
]
for (const [k, v] of request.headers) {
if (allow.includes(k.toLowerCase())) h.set(k, v)
}
h.set('Host', target.hostname)

// Optional: spoof X-Forwarded-For if provided
const spoof = request.headers.get('X-My-X-Forwarded-For')
h.set('X-Forwarded-For', spoof || randomIP())

return new Request(target.toString(), {
method: request.method,
headers: h,
body: ['GET','HEAD'].includes(request.method) ? null : request.body
})
}

function buildProxyResponse(resp, method) {
const h = new Headers()
for (const [k, v] of resp.headers) {
if (!['content-encoding','content-length','transfer-encoding'].includes(k.toLowerCase())) {
h.set(k, v)
}
}
// Permissive CORS for tooling convenience
h.set('Access-Control-Allow-Origin', '*')
h.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, PATCH, HEAD')
h.set('Access-Control-Allow-Headers', '*')

if (method === 'OPTIONS') return new Response(null, { status: 204, headers: h })
return new Response(resp.body, { status: resp.status, statusText: resp.statusText, headers: h })
}

function errorJSON(msg, status=400, extra={}) {
return new Response(JSON.stringify({ error: msg, ...extra }), {
status, headers: { 'Content-Type': 'application/json' }
})
}

function randomIP() { return [1,2,3,4].map(() => Math.floor(Math.random()*255)+1).join('.') }

Automatizando implantação e rotação com FlareProx

FlareProx é uma ferramenta em Python que usa a Cloudflare API para implantar vários Worker endpoints e rotacionar entre eles. Isso fornece rotação de IP similar ao FireProx na rede da Cloudflare.

Configuração

1. Crie um Cloudflare API Token usando o template “Edit Cloudflare Workers” e obtenha seu Account ID no painel.
2. Configure o FlareProx:

git clone https://github.com/MrTurvey/flareprox
cd flareprox
pip install -r requirements.txt

Crie o arquivo de configuração flareprox.json:

{
"cloudflare": {
"api_token": "your_cloudflare_api_token",
"account_id": "your_cloudflare_account_id"
}
}

Uso do CLI

• Criar N Worker proxies:

python3 flareprox.py create --count 2

• Listar endpoints:

python3 flareprox.py list

• Endpoints de verificação de integridade:

python3 flareprox.py test

• Excluir todos os endpoints:

python3 flareprox.py cleanup

Roteamento de tráfego através de um Worker

• Formato por parâmetro de query:

curl "https://your-worker.account.workers.dev?url=https://httpbin.org/ip"

• Formato do cabeçalho:

curl -H "X-Target-URL: https://httpbin.org/ip" https://your-worker.account.workers.dev

• Formato do caminho (se implementado):

curl https://your-worker.account.workers.dev/https://httpbin.org/ip

• Exemplos de métodos:

# GET
curl "https://your-worker.account.workers.dev?url=https://httpbin.org/get"

# POST (form)
curl -X POST -d "username=admin" \
"https://your-worker.account.workers.dev?url=https://httpbin.org/post"

# PUT (JSON)
curl -X PUT -d '{"username":"admin"}' -H "Content-Type: application/json" \
"https://your-worker.account.workers.dev?url=https://httpbin.org/put"

# DELETE
curl -X DELETE \
"https://your-worker.account.workers.dev?url=https://httpbin.org/delete"

X-Forwarded-For controle

Se o Worker respeitar X-My-X-Forwarded-For, você pode influenciar o valor upstream de X-Forwarded-For:

curl -H "X-My-X-Forwarded-For: 203.0.113.10" \
"https://your-worker.account.workers.dev?url=https://httpbin.org/headers"

Uso programático

Use a biblioteca FlareProx para criar/listar/testar endpoints e rotear requisições a partir do Python.

#!/usr/bin/env python3
from flareprox import FlareProx, FlareProxError
import json

# Initialize
flareprox = FlareProx(config_file="flareprox.json")
if not flareprox.is_configured:
print("FlareProx not configured. Run: python3 flareprox.py config")
exit(1)

# Ensure endpoints exist
endpoints = flareprox.sync_endpoints()
if not endpoints:
print("Creating proxy endpoints...")
flareprox.create_proxies(count=2)

# Make a POST request through a random endpoint
try:
post_data = json.dumps({
"username": "testuser",
"message": "Hello from FlareProx!",
"timestamp": "2025-01-01T12:00:00Z"
})

headers = {
"Content-Type": "application/json",
"User-Agent": "FlareProx-Client/1.0"
}

response = flareprox.redirect_request(
target_url="https://httpbin.org/post",
method="POST",
headers=headers,
data=post_data
)

if response.status_code == 200:
result = response.json()
print("✓ POST successful via FlareProx")
print(f"Origin IP: {result.get('origin', 'unknown')}")
print(f"Posted data: {result.get('json', {})}")
else:
print(f"Request failed with status: {response.status_code}")

except FlareProxError as e:
print(f"FlareProx error: {e}")
except Exception as e:
print(f"Request error: {e}")

Integração Burp/Scanner

• Aponte as ferramentas (por exemplo, Burp Suite) para a URL do Worker.
• Forneça o upstream real usando ?url= ou X-Target-URL.
• A semântica HTTP (methods/headers/body) é preservada enquanto mascara seu IP de origem atrás do Cloudflare.

Notas operacionais e limites

• O plano Free do Cloudflare Workers permite aproximadamente 100.000 requisições/dia por conta; use múltiplos endpoints para distribuir o tráfego se necessário.
• Workers rodam na rede do Cloudflare; muitos alvos verão apenas IPs/ASN do Cloudflare, o que pode contornar listas simples de permissão/negação por IP ou heurísticas geográficas.
• Use com responsabilidade e somente com autorização. Respeite o ToS e o robots.txt.

Referências

• FlareProx (Cloudflare Workers pass-through/rotation)
• Cloudflare Workers fetch() API
• Cloudflare Workers pricing and free tier
• FireProx (AWS API Gateway)