Missbrauch von Cloudflare Workers als Pass-through-Proxies (IP-Rotation, FireProx-style)

Tip

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE)
Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE) Lernen & üben Sie Azure Hacking: HackTricks Training Azure Red Team Expert (AzRTE)

Unterstützen Sie HackTricks

Cloudflare Workers können als transparente HTTP-Pass-Through-Proxies eingesetzt werden, bei denen die Upstream-Ziel-URL vom Client bereitgestellt wird. Anfragen gehen aus dem Cloudflare-Netzwerk heraus, sodass das Ziel Cloudflare-IP-Adressen statt der Client-IP sieht. Dies spiegelt die bekannte FireProx-Technik auf AWS API Gateway wider, nutzt aber Cloudflare Workers.

Wesentliche Funktionen

  • Unterstützung aller HTTP-Methoden (GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD)
  • Das Ziel kann über einen Query-Parameter (?url=…), einen Header (X-Target-URL) oder sogar kodiert im Pfad (z. B. /https://target) übergeben werden
  • Header und Body werden durchgereicht, mit Hop-by-hop/Header-Filterung nach Bedarf
  • Antworten werden zurückgegeben, Statuscode und die meisten Header bleiben erhalten
  • Optionales Spoofing von X-Forwarded-For (wenn der Worker diesen aus einem vom Nutzer kontrollierten Header setzt)
  • Sehr schnelle/einfache Rotation durch Deployment mehrerer Worker-Endpunkte und Verteilung der Requests

Funktionsweise (Ablauf)

  1. Client sendet eine HTTP-Anfrage an eine Worker-URL (<name>.<account>.workers.dev oder eine Route auf einer Custom-Domain).
  2. Der Worker extrahiert das Ziel entweder aus einem Query-Parameter (?url=…), dem X-Target-URL-Header oder einem Pfadsegment, falls implementiert.
  3. Der Worker leitet Methode, Header und Body an die angegebene Upstream-URL weiter (filtert problematische Header).
  4. Die Upstream-Antwort wird über Cloudflare an den Client gestreamt; die Origin sieht die ausgehenden Cloudflare-IPs.

Beispielhafte Worker-Implementierung

  • Liest die Ziel-URL aus Query-Param, Header oder Pfad
  • Kopiert eine sichere Teilmenge der Header und leitet die ursprüngliche Methode/den Body weiter
  • Setzt optional X-Forwarded-For mittels eines vom Nutzer kontrollierten Headers (X-My-X-Forwarded-For) oder einer zufälligen IP
  • Fügt großzügige CORS-Header hinzu und behandelt Preflight-Anfragen
Beispiel-Worker (JavaScript) als Pass-Through-Proxy ```javascript /** * 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(‘.’) }

</details>

### Automatisierung von Deployment und Rotation mit FlareProx

FlareProx ist ein Python-Tool, das die Cloudflare API verwendet, um viele Worker-Endpunkte bereitzustellen und zwischen ihnen zu rotieren. Das bietet FireProx-like IP-Rotation über das Cloudflare-Netzwerk.

Einrichtung
1) Erstelle ein Cloudflare API Token mit der Vorlage “Edit Cloudflare Workers” und hole deine Account ID aus dem Dashboard.
2) Konfiguriere FlareProx:
```bash
git clone https://github.com/MrTurvey/flareprox
cd flareprox
pip install -r requirements.txt

Erstelle die Konfigurationsdatei flareprox.json:

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

CLI-Verwendung

  • Erstelle N Worker proxies:
python3 flareprox.py create --count 2
  • Endpunkte auflisten:
python3 flareprox.py list
  • Health-Test-Endpunkte:
python3 flareprox.py test
  • Alle Endpunkte löschen:
python3 flareprox.py cleanup

Traffic durch einen Worker routen

  • Query-Parameter-Form:
curl "https://your-worker.account.workers.dev?url=https://httpbin.org/ip"
  • Header-Form:
curl -H "X-Target-URL: https://httpbin.org/ip" https://your-worker.account.workers.dev
  • Pfad-Form (falls implementiert):
curl https://your-worker.account.workers.dev/https://httpbin.org/ip
  • Methodenbeispiele:
# 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 Kontrolle

Wenn der Worker X-My-X-Forwarded-For berücksichtigt, können Sie den upstream X-Forwarded-For-Wert beeinflussen:

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

Programmgesteuerte Nutzung

Verwende die FlareProx-Bibliothek, um Endpunkte zu erstellen/aufzulisten/zu testen und Anfragen aus Python weiterzuleiten.

Python‑Beispiel: Sende eine POST-Anfrage über einen zufälligen Worker-Endpunkt ```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}”)

</details>

**Burp/Scanner Integration**
- Richte Tools (z. B. Burp Suite) auf die Worker URL.
- Übergib den echten Upstream über ?url= oder X-Target-URL.
- HTTP-Semantik (methods/headers/body) bleibt erhalten, während deine Quell-IP hinter Cloudflare verborgen wird.

**Betriebliche Hinweise und Limits**
- Der Cloudflare Workers Free plan erlaubt ungefähr 100.000 requests/day pro Account; nutze bei Bedarf mehrere Endpunkte, um den Traffic zu verteilen.
- Workers laufen im Netzwerk von Cloudflare; viele Ziele sehen nur Cloudflare IPs/ASN, was naive IP allow/deny lists oder Geo-Heuristiken umgehen kann.
- Verwende es verantwortungsvoll und nur mit Autorisierung. Beachte ToS und robots.txt.

## References
- [FlareProx (Cloudflare Workers pass-through/rotation)](https://github.com/MrTurvey/flareprox)
- [Cloudflare Workers fetch() API](https://developers.cloudflare.com/workers/runtime-apis/fetch/)
- [Cloudflare Workers pricing and free tier](https://developers.cloudflare.com/workers/platform/pricing/)
- [FireProx (AWS API Gateway)](https://github.com/ustayready/fireprox)

> [!TIP]
> Lernen & üben Sie AWS Hacking:<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training AWS Red Team Expert (ARTE)**](https://training.hacktricks.xyz/courses/arte)<img src="../../../../../images/arte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">\
> Lernen & üben Sie GCP Hacking: <img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training GCP Red Team Expert (GRTE)**](https://training.hacktricks.xyz/courses/grte)<img src="../../../../../images/grte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
> Lernen & üben Sie Azure Hacking: <img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">[**HackTricks Training Azure Red Team Expert (AzRTE)**](https://training.hacktricks.xyz/courses/azrte)<img src="../../../../../images/azrte.png" alt="" style="width:auto;height:24px;vertical-align:middle;">
>
> <details>
>
> <summary>Unterstützen Sie HackTricks</summary>
>
> - Überprüfen Sie die [**Abonnementpläne**](https://github.com/sponsors/carlospolop)!
> - **Treten Sie der** 💬 [**Discord-Gruppe**](https://discord.gg/hRep4RUj7f) oder der [**Telegram-Gruppe**](https://t.me/peass) bei oder **folgen** Sie uns auf **Twitter** 🐦 [**@hacktricks_live**](https://twitter.com/hacktricks_live)**.**
> - **Teilen Sie Hacking-Tricks, indem Sie PRs an die** [**HackTricks**](https://github.com/carlospolop/hacktricks) und [**HackTricks Cloud**](https://github.com/carlospolop/hacktricks-cloud) GitHub-Repos senden.
>
> </details>