gitea-mirror/hacktricks-cloud
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks-cloud.git synced 2026-01-14 13:56:30 -08:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/pentesting-ci-cd/cloudflare-security/cloudflare-workers

Browse Source
This commit is contained in:
Translator
2025-10-23 13:44:19 +00:00
parent 56b52e3ce2
commit de61ce344f
5 changed files with 449 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
src/pentesting-ci-cd/cloudflare-security/README.md
View File

@@ -1,77 +1,83 @@
# Cloudflare Security
# Sicurezza Cloudflare
{{#include ../../banners/hacktricks-training.md}}
In un account Cloudflare ci sono alcune **impostazioni generali e servizi** che possono essere configurati. In questa pagina analizzeremo le **impostazioni relative alla sicurezza di ciascuna sezione:**
In un account Cloudflare ci sono alcune **impostazioni e servizi generali** che possono essere configurati. In questa pagina andremo a **analizzare le impostazioni relative alla sicurezza di ogni sezione:**
<figure><img src="../../images/image (117).png" alt=""><figcaption></figcaption></figure>
## Siti Web
## Siti web
Esamina ciascuno con:
Rivedere ciascuno con:
{{#ref}}
cloudflare-domains.md
{{#endref}}
### Registrazione del Dominio
### Domain Registration
- [ ] In **`Transfer Domains`** controlla che non sia possibile trasferire alcun dominio.
- [ ] In **`Transfer Domains`** verificare che non sia possibile trasferire alcun dominio.
Esamina ciascuno con:
Rivedere ciascuno con:
{{#ref}}
cloudflare-domains.md
{{#endref}}
## Analisi
## Analytics
_Non sono riuscito a trovare nulla da controllare per una revisione della sicurezza della configurazione._
_Non sono riuscito a trovare nulla da verificare per una revisione della configurazione di sicurezza._
## Pagine
## Pages
Su ciascuna pagina di Cloudflare:
On each Cloudflare's page:
- [ ] Controlla le **informazioni sensibili** nel **`Build log`**.
- [ ] Controlla le **informazioni sensibili** nel **repository Github** assegnato alle pagine.
- [ ] Controlla il potenziale compromesso del repository github tramite **workflow command injection** o compromesso di `pull_request_target`. Maggiori informazioni nella [**pagina di sicurezza di Github**](../github-security/).
- [ ] Controlla le **funzioni vulnerabili** nella directory `/fuctions` (se presenti), controlla i **redirect** nel file `_redirects` (se presenti) e gli **header mal configurati** nel file `_headers` (se presenti).
- [ ] Controlla le **vulnerabilità** nella **pagina web** tramite **blackbox** o **whitebox** se puoi **accedere al codice**.
- [ ] Nei dettagli di ciascuna pagina `/<page_id>/pages/view/blocklist/settings/functions`. Controlla le **informazioni sensibili** nelle **`Environment variables`**.
- [ ] Nella pagina dei dettagli controlla anche il **build command** e la **root directory** per **potenziali iniezioni** che possano compromettere la pagina.
- [ ] Check for **sensitive information** in the **`Build log`**.
- [ ] Check for **sensitive information** in the **Github repository** assigned to the pages.
- [ ] Check for potential github repo compromise via workflow command injection or `pull_request_target` compromise. More info in the [**Github Security page**](../github-security/index.html).
- [ ] Check for **vulnerable functions** in the `/fuctions` directory (if any), check the **redirects** in the `_redirects` file (if any) and **misconfigured headers** in the `_headers` file (if any).
- [ ] Check for **vulnerabilities** in the **web page** via **blackbox** or **whitebox** if you can **access the code**
- [ ] In the details of each page `/<page_id>/pages/view/blocklist/settings/functions`. Check for **sensitive information** in the **`Environment variables`**.
- [ ] In the details page check also the **build command** and **root directory** for **potential injections** to compromise the page.
## **Workers**
Su ciascun worker di Cloudflare controlla:
On each Cloudflare's worker check:
- [ ] I trigger: Cosa fa scattare il worker? Un **utente può inviare dati** che saranno **utilizzati** dal worker?
- [ ] Nelle **`Settings`**, controlla le **`Variables`** contenenti **informazioni sensibili**.
- [ ] Controlla il **codice del worker** e cerca **vulnerabilità** (soprattutto nei luoghi in cui l'utente può gestire l'input).
- Controlla per SSRF che restituiscono la pagina indicata che puoi controllare.
- Controlla XSS che eseguono JS all'interno di un'immagine svg.
- È possibile che il worker interagisca con altri servizi interni. Ad esempio, un worker può interagire con un bucket R2 che memorizza informazioni ottenute dall'input. In tal caso, sarebbe necessario controllare quali capacità ha il worker sul bucket R2 e come potrebbe essere abusato dall'input dell'utente.
- [ ] I trigger: cosa fa scattare il Worker? Un utente può inviare dati che verranno usati dal Worker?
- [ ] In the **`Settings`**, check for **`Variables`** containing **sensitive information**
- [ ] Verificare il codice del worker e cercare vulnerabilità (soprattutto nei punti in cui l'utente può controllare l'input)
- Cercare SSRF che restituiscano la pagina indicata e che tu possa controllare
- Cercare XSS che eseguano JS all'interno di un'immagine svg
- È possibile che il worker interagisca con altri servizi interni. Per esempio, un worker può interagire con un bucket R2 memorizzandovi informazioni ottenute dall'input. In tal caso, è necessario verificare quali capacità ha il worker sul bucket R2 e come potrebbero essere abusate dall'input dell'utente.
> [!WARNING]
> Nota che per impostazione predefinita a un **Worker viene assegnato un URL** come `<worker-name>.<account>.workers.dev`. L'utente può impostarlo su un **sottodominio**, ma puoi sempre accedervi con quell'**URL originale** se lo conosci.
> Note that by default a **Worker is given a URL** such as `<worker-name>.<account>.workers.dev`. The user can set it to a **subdomain** but you can always access it with that **original URL** if you know it.
For a practical abuse of Workers as pass-through proxies (IP rotation, FireProx-style), check:
{{#ref}}
cloudflare-workers-pass-through-proxy-ip-rotation.md
{{#endref}}
## R2
Su ciascun bucket R2 controlla:
On each R2 bucket check:
- [ ] Configura la **CORS Policy**.
- [ ] Configurare la **CORS Policy**.
## Stream
TODO
## Immagini
## Images
TODO
## Centro Sicurezza
## Security Center
- [ ] Se possibile, esegui una **scansione di `Security Insights`** e una **scansione di `Infrastructure`**, poiché evidenzieranno informazioni interessanti dal punto di vista **della sicurezza**.
- [ ] Controlla solo **queste informazioni** per configurazioni di sicurezza errate e informazioni interessanti.
- [ ] Se possibile, eseguire una scansione `Security Insights` e una scansione `Infrastructure`, poiché metteranno in evidenza informazioni interessanti dal punto di vista della sicurezza.
- [ ] Controllare queste informazioni per misconfigurazioni di sicurezza e informazioni interessanti
## Turnstile
@@ -83,17 +89,17 @@ TODO
cloudflare-zero-trust-network.md
{{#endref}}
## Redirects di Massa
## Bulk Redirects
> [!NOTE]
> A differenza dei [Redirects Dinamici](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), i [**Redirects di Massa**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) sono essenzialmente statici — non supportano alcuna operazione di sostituzione di stringhe o espressioni regolari. Tuttavia, puoi configurare i parametri di reindirizzamento URL che influenzano il loro comportamento di corrispondenza URL e il loro comportamento di runtime.
> Unlike [Dynamic Redirects](https://developers.cloudflare.com/rules/url-forwarding/dynamic-redirects/), [**Bulk Redirects**](https://developers.cloudflare.com/rules/url-forwarding/bulk-redirects/) are essentially static — they do **not support any string replacement** operations or regular expressions. However, you can configure URL redirect parameters that affect their URL matching behavior and their runtime behavior.
- [ ] Controlla che le **espressioni** e i **requisiti** per i redirect **abbiano senso**.
- [ ] Controlla anche per **endpoint nascosti sensibili** che contengono informazioni interessanti.
- [ ] Verificare che le **espressioni** e i **requisiti** per i redirect abbiano senso.
- [ ] Verificare anche la presenza di endpoint nascosti sensibili che contengono informazioni interessanti.
## Notifiche
## Notifications
- [ ] Controlla le **notifiche.** Queste notifiche sono raccomandate per la sicurezza:
- [ ] Controllare le notifiche. Queste notifiche sono raccomandate per la sicurezza:
- `Usage Based Billing`
- `HTTP DDoS Attack Alert`
- `Layer 3/4 DDoS Attack Alert`
@@ -113,22 +119,22 @@ cloudflare-zero-trust-network.md
- `Script Monitor New Script Exceeds Max URL Length Alert`
- `Advanced Security Events Alert`
- `Security Events Alert`
- [ ] Controlla tutte le **destinazioni**, poiché potrebbero esserci **informazioni sensibili** (autenticazione http di base) negli URL dei webhook. Assicurati anche che gli URL dei webhook utilizzino **HTTPS**.
- [ ] Come controllo extra, potresti provare a **impersonare una notifica di cloudflare** a una terza parte, magari puoi in qualche modo **iniettare qualcosa di pericoloso**.
- [ ] Verificare tutte le **destinazioni**, poiché potrebbero esserci **informazioni sensibili** (basic http auth) nelle webhook urls. Assicurarsi inoltre che le webhook urls usino **HTTPS**
- [ ] Come controllo aggiuntivo, potresti provare a impersonare una notifica Cloudflare a una terza parte; forse puoi in qualche modo iniettare qualcosa di pericoloso
## Gestisci Account
## Gestione account
- [ ] È possibile vedere le **ultime 4 cifre della carta di credito**, il **tempo di scadenza** e l'**indirizzo di fatturazione** in **`Billing` -> `Payment info`**.
- [ ] È possibile vedere il **tipo di piano** utilizzato nell'account in **`Billing` -> `Subscriptions`**.
- [ ] In **`Members`** è possibile vedere tutti i membri dell'account e il loro **ruolo**. Nota che se il tipo di piano non è Enterprise, esistono solo 2 ruoli: Amministratore e Super Amministratore. Ma se il **piano utilizzato è Enterprise**, [**più ruoli**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) possono essere utilizzati per seguire il principio del minimo privilegio.
- Pertanto, ogni volta che è possibile è **raccomandato** utilizzare il **piano Enterprise**.
- [ ] In Members è possibile controllare quali **membri** hanno **2FA abilitato**. **Ogni** utente dovrebbe averlo abilitato.
- [ ] È possibile vedere le **ultime 4 cifre della carta di credito**, la **data di scadenza** e l'**indirizzo di fatturazione** in **`Billing` -> `Payment info`**.
- [ ] È possibile vedere il **tipo di piano** usato nell'account in **`Billing` -> `Subscriptions`**.
- [ ] In **`Members`** è possibile vedere tutti i membri dell'account e il loro **`role`**. Nota che se il tipo di piano non è Enterprise, esistono solo 2 ruoli: Administrator e Super Administrator. Ma se il **piano usato è Enterprise**, [**more roles**](https://developers.cloudflare.com/fundamentals/account-and-billing/account-setup/account-roles/) possono essere usati per seguire il principio del least privilege.
- Pertanto, quando possibile è `recommended` usare il `Enterprise plan`.
- [ ] In `Members` è possibile verificare quali membri hanno la 2FA abilitata. Ogni utente dovrebbe averla abilitata.
> [!NOTE]
> Nota che fortunatamente il ruolo **`Administrator`** non dà permessi per gestire le iscrizioni (**non può elevare i privilegi o invitare** nuovi membri).
> Note that fortunately the role **`Administrator`** doesn't give permissions to manage memberships (**cannot escalate privs or invite** new members)
## Indagine DDoS
## DDoS Investigation
[Controlla questa parte](cloudflare-domains.md#cloudflare-ddos-protection).
[Check this part](cloudflare-domains.md#cloudflare-ddos-protection).
{{#include ../../banners/hacktricks-training.md}}

286
src/pentesting-ci-cd/cloudflare-security/cloudflare-workers-pass-through-proxy-ip-rotation.md Normal file
View File

@@ -0,0 +1,286 @@
# Abusing Cloudflare Workers as pass-through proxies (IP rotation, FireProx-style)
{{#include ../../banners/hacktricks-training.md}}
Cloudflare Workers possono essere distribuiti come proxy HTTP trasparenti pass-through in cui l'URL di destinazione upstream è fornito dal client. Le richieste escono dalla rete di Cloudflare, quindi la destinazione vede gli IP di Cloudflare invece di quelli del client. Questo rispecchia la famosa tecnica FireProx su AWS API Gateway, ma utilizza Cloudflare Workers.
### Key capabilities
- Support for all HTTP methods (GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD)
- La destinazione può essere fornita tramite parametro di query (?url=...), un header (X-Target-URL), o persino codificata nel path (es., /https://target)
- Header e body vengono inoltrati tramite il proxy con filtraggio degli header hop-by-hop quando necessario
- Le risposte vengono rilanciate indietro, preservando lo status code e la maggior parte degli header
- Spoofing opzionale di X-Forwarded-For (se il Worker lo imposta da un header controllato dall'utente)
- Rotazione estremamente rapida/facile distribuendo più endpoint Worker e smistando le richieste
### How it works (flow)
1) Il client invia una richiesta HTTP a un URL Worker (`<name>.<account>.workers.dev` o una route su dominio custom).
2) Il Worker estrae la destinazione da un parametro di query (?url=...), dall'header X-Target-URL, o da un segmento del path se implementato.
3) Il Worker inoltra il metodo, gli header e il body in arrivo all'URL upstream specificato (filtrando gli header problematici).
4) La risposta upstream viene trasmessa al client attraverso Cloudflare; l'origine vede gli IP di uscita di Cloudflare.
### Worker implementation example
- Legge l'URL di destinazione dal parametro di query, dall'header o dal path
- Copia un sottoinsieme sicuro di header e inoltra il metodo/body originale
- Opzionalmente imposta X-Forwarded-For usando un header controllato dall'utente (X-My-X-Forwarded-For) o un IP casuale
- Aggiunge CORS permissivo e gestisce i preflight
<details>
<summary>Esempio di Worker (JavaScript) per proxy pass-through</summary>
```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>
### Automatizzare la distribuzione e la rotazione con FlareProx
FlareProx è uno strumento Python che usa la Cloudflare API per distribuire molti endpoint Worker e ruotare tra essi. Questo fornisce una rotazione IP in stile FireProx dalla rete di Cloudflare.
Configurazione
1) Crea un Cloudflare API Token usando il template “Edit Cloudflare Workers” e recupera il tuo Account ID dalla dashboard.
2) Configura FlareProx:
```bash
git clone https://github.com/MrTurvey/flareprox
cd flareprox
pip install -r requirements.txt
```
**Crea il file di configurazione flareprox.json:**
```json
{
"cloudflare": {
"api_token": "your_cloudflare_api_token",
"account_id": "your_cloudflare_account_id"
}
}
```
**CLI usage**
- Crea N Worker proxies:
```bash
python3 flareprox.py create --count 2
```
- Elencare gli endpoint:
```bash
python3 flareprox.py list
```
- Endpoint di controllo dello stato:
```bash
python3 flareprox.py test
```
- Elimina tutti gli endpoint:
```bash
python3 flareprox.py cleanup
```
**Instradare il traffico attraverso un Worker**
- Formato con parametri di query:
```bash
curl "https://your-worker.account.workers.dev?url=https://httpbin.org/ip"
```
- Formato intestazione:
```bash
curl -H "X-Target-URL: https://httpbin.org/ip" https://your-worker.account.workers.dev
```
- Formato del path (se implementato):
```bash
curl https://your-worker.account.workers.dev/https://httpbin.org/ip
```
- Esempi di metodi:
```bash
# 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` controllo**
Se il Worker rispetta `X-My-X-Forwarded-For`, puoi influenzare il valore upstream di `X-Forwarded-For`:
```bash
curl -H "X-My-X-Forwarded-For: 203.0.113.10" \
"https://your-worker.account.workers.dev?url=https://httpbin.org/headers"
```
**Uso programmatico**
Usa la libreria FlareProx per creare, elencare e testare endpoint e per instradare richieste da Python.
<details>
<summary>Esempio Python: Invia un POST tramite un endpoint Worker casuale</summary>
```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>
**Integrazione Burp/Scanner**
- Indirizzare gli strumenti (per esempio, Burp Suite) al Worker URL.
- Fornire l'upstream reale usando ?url= o X-Target-URL.
- La semantica HTTP (methods/headers/body) viene preservata mentre l'IP sorgente viene mascherato dietro Cloudflare.
**Note operative e limiti**
- Cloudflare Workers Free plan consente circa 100.000 richieste/giorno per account; usare più endpoint per distribuire il traffico se necessario.
- I Workers vengono eseguiti sulla rete di Cloudflare; molti target vedranno solo gli IP/ASN di Cloudflare, il che può bypassare semplici allow/deny lists basate su IP o le euristiche geografiche.
- Usare responsabilmente e solo con autorizzazione. Rispettare ToS e robots.txt.
## Riferimenti
- [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)
{{#include ../../banners/hacktricks-training.md}}