Translated ['', 'src/pentesting-ci-cd/supabase-security.md'] to it

2025-12-28 21:53:15 -08:00 · 2025-09-29 23:05:53 +00:00
parent 64e42c1e0f
commit c950ff7c47
1 changed files with 155 additions and 45 deletions
--- a/src/pentesting-ci-cd/supabase-security.md
+++ b/src/pentesting-ci-cd/supabase-security.md
@@ -1,45 +1,45 @@
-# Sicurezza di Supabase
+# Sicurezza Supabase

 {{#include ../banners/hacktricks-training.md}}

 ## Informazioni di base

-Secondo la loro [**pagina di atterraggio**](https://supabase.com/): Supabase è un'alternativa open source a Firebase. Inizia il tuo progetto con un database Postgres, Autenticazione, API istantanee, Funzioni Edge, abbonamenti in tempo reale, Archiviazione e Embedding vettoriali.
+Secondo la loro [**landing page**](https://supabase.com/): Supabase è un'alternativa open source a Firebase. Avvia il tuo progetto con un database Postgres, Authentication, instant APIs, Edge Functions, Realtime subscriptions, Storage, e Vector embeddings.

 ### Sottodominio

-Fondamentalmente, quando viene creato un progetto, l'utente riceverà un sottodominio supabase.co come: **`jnanozjdybtpqgcwhdiz.supabase.co`**
+Fondamentalmente quando viene creato un progetto, l'utente riceverà un sottodominio supabase.co come: **`jnanozjdybtpqgcwhdiz.supabase.co`**

 ## **Configurazione del database**

 > [!TIP]
-> **Questi dati possono essere accessibili da un link come `https://supabase.com/dashboard/project/<project-id>/settings/database`**
+> **Questi dati sono accessibili da un link come `https://supabase.com/dashboard/project/<project-id>/settings/database`**

-Questo **database** sarà distribuito in una regione AWS e, per connettersi ad esso, sarà possibile farlo collegandosi a: `postgres://postgres.jnanozjdybtpqgcwhdiz:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (questo è stato creato in us-west-1).\
-La password è una **password che l'utente ha inserito** precedentemente.
+Questo **database** verrà distribuito in una regione AWS e, per connettersi, sarebbe possibile farlo collegandosi a: `postgres://postgres.jnanozjdybtpqgcwhdiz:[YOUR-PASSWORD]@aws-0-us-west-1.pooler.supabase.com:5432/postgres` (questo è stato creato in us-west-1).\
+La password è una **password scelta dall'utente** in precedenza.

-Pertanto, poiché il sottodominio è noto ed è utilizzato come nome utente e le regioni AWS sono limitate, potrebbe essere possibile provare a **forzare la password**.
+Pertanto, dato che il sottodominio è noto ed è usato come username e le region AWS sono limitate, potrebbe essere possibile provare a **brute force the password**.

 Questa sezione contiene anche opzioni per:

 - Reimpostare la password del database
- Configurare il pooling delle connessioni
- Configurare SSL: Rifiuta le connessioni in testo semplice (per impostazione predefinita sono abilitate)
- Configurare la dimensione del disco
- Applicare restrizioni e divieti di rete
+- Configurare il connection pooling
+- Configurare SSL: rifiutare le connessioni in plain-text (di default sono abilitate)
+- Configurare la dimensione del Disk
+- Applicare restrizioni e ban di rete

 ## Configurazione API

 > [!TIP]
-> **Questi dati possono essere accessibili da un link come `https://supabase.com/dashboard/project/<project-id>/settings/api`**
+> **Questi dati sono accessibili da un link come `https://supabase.com/dashboard/project/<project-id>/settings/api`**

-L'URL per accedere all'API supabase nel tuo progetto sarà simile a: `https://jnanozjdybtpqgcwhdiz.supabase.co`.
+L'URL per accedere all'API supabase del tuo progetto sarà: `https://jnanozjdybtpqgcwhdiz.supabase.co`.

-### chiavi api anon
+### anon api keys

-Genererà anche una **chiave API anon** (`role: "anon"`), come: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` che l'applicazione dovrà utilizzare per contattare la chiave API esposta nel nostro esempio in
+Genererà anche un'**anon API key** (`role: "anon"`), come: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTQ5OTI3MTksImV4cCI6MjAzMDU2ODcxOX0.sRN0iMGM5J741pXav7UxeChyqBE9_Z-T0tLA9Zehvqk` che l'applicazione dovrà usare per contattare l'API esposta nel nostro esempio in

-È possibile trovare l'API REST per contattare questa API nella [**documentazione**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), ma gli endpoint più interessanti sarebbero:
+È possibile trovare l'API REST per contattare questa API nei [**docs**](https://supabase.com/docs/reference/self-hosting-auth/returns-the-configuration-settings-for-the-gotrue-server), ma gli endpoint più interessanti sarebbero:

 <details>

@@ -99,61 +99,171 @@ Priority: u=1, i
 ```
 </details>

-Quindi, ogni volta che scopri un cliente che utilizza supabase con il sottodominio che gli è stato assegnato (è possibile che un sottodominio dell'azienda abbia un CNAME sul loro sottodominio supabase), potresti provare a **creare un nuovo account nella piattaforma utilizzando l'API di supabase**.
+Quindi, ogni volta che scopri un client che usa supabase con il sottodominio a loro assegnato (è possibile che un sottodominio dell'azienda abbia un CNAME puntato sul loro sottodominio supabase), potresti provare a **creare un nuovo account sulla piattaforma usando la supabase API**.

-### chiavi API segrete / service_role
+### secret / service_role api keys

-Una chiave API segreta verrà generata anche con **`role: "service_role"`**. Questa chiave API dovrebbe essere segreta perché sarà in grado di bypassare **Row Level Security**.
+Verrà anche generata una secret API key con **`role: "service_role"`**. Questa API key deve rimanere segreta perché sarà in grado di bypassare **Row Level Security**.

-La chiave API appare così: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354`
+La API key appare così: `eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImpuYW5vemRyb2J0cHFnY3doZGl6Iiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTcxNDk5MjcxOSwiZXhwIjoyMDMwNTY4NzE5fQ.0a8fHGp3N_GiPq0y0dwfs06ywd-zhTwsm486Tha7354`

 ### JWT Secret

-Un **JWT Secret** verrà generato anche affinché l'applicazione possa **creare e firmare token JWT personalizzati**.
+Un **JWT Secret** verrà inoltre generato così l'applicazione può **creare e firmare JWT personalizzati**.

-## Autenticazione
+## Authentication

-### Registrazioni
+### Signups

 > [!TIP]
-> Per **default** supabase consentirà **ai nuovi utenti di creare account** nel tuo progetto utilizzando gli endpoint API precedentemente menzionati.
+> Per **default** supabase permetterà ai **nuovi utenti di creare account** sul tuo progetto usando gli endpoint API menzionati in precedenza.

-Tuttavia, questi nuovi account, per impostazione predefinita, **dovranno convalidare il loro indirizzo email** per poter accedere all'account. È possibile abilitare **"Consenti accessi anonimi"** per consentire alle persone di accedere senza verificare il loro indirizzo email. Questo potrebbe concedere accesso a **dati inaspettati** (ottengono i ruoli `public` e `authenticated`).\
-Questa è un'idea molto cattiva perché supabase addebita per ogni utente attivo, quindi le persone potrebbero creare utenti e accedere e supabase addebiterà per questi:
+Tuttavia, questi nuovi account, per impostazione predefinita, **dovranno convalidare il loro indirizzo email** per poter effettuare il login nell'account. È possibile abilitare **"Allow anonymous sign-ins"** per consentire alle persone di effettuare il login senza verificare l'indirizzo email. Questo potrebbe concedere accesso a **dati inaspettati** (ottenendo i ruoli `public` e `authenticated`).\
+Questa è una pessima idea perché supabase addebita per utente attivo, quindi le persone potrebbero creare utenti, effettuare il login e supabase addebiterà per quelli:

 <figure><img src="../images/image (1) (1) (1) (1) (1) (1).png" alt=""><figcaption></figcaption></figure>

-### Password e sessioni
+#### Auth: Server-side signup enforcement

-È possibile indicare la lunghezza minima della password (per impostazione predefinita), i requisiti (nessuno per impostazione predefinita) e vietare l'uso di password compromesse.\
-Si consiglia di **migliorare i requisiti poiché quelli predefiniti sono deboli**.
+Nascondere il pulsante di registrazione nel frontend non è sufficiente. Se il **Auth server continua a permettere le registrazioni**, un attaccante può chiamare direttamente l'API con la public `anon` key e creare utenti arbitrari.

- Sessioni utente: È possibile configurare come funzionano le sessioni utente (timeout, 1 sessione per utente...)
- Protezione da bot e abusi: È possibile abilitare Captcha.
+Test rapido (da un client non autenticato):
+```bash
+curl -X POST \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+-H "Content-Type: application/json" \
+-d '{"email":"attacker@example.com","password":"Sup3rStr0ng!"}' \
+https://<PROJECT_REF>.supabase.co/auth/v1/signup
+```
+Expected hardening:
+- Disable email/password signups in the Dashboard: Authentication → Providers → Email → Disable sign ups (invite-only), or set the equivalent GoTrue setting.
+- Verify the API now returns 4xx to the previous call and no new user is created.
+- If you rely on invites or SSO, ensure all other providers are disabled unless explicitly needed.

-### Impostazioni SMTP
+## RLS and Views: Bypass di scrittura via PostgREST
+
+Using a Postgres VIEW to “hide” sensitive columns and exposing it via PostgREST can change how privileges are evaluated. In PostgreSQL:
+- Ordinary views execute with the privileges of the view owner by default (definer semantics). In PG ≥15 you can opt into `security_invoker`.
+- Row Level Security (RLS) applies on base tables. Table owners bypass RLS unless `FORCE ROW LEVEL SECURITY` is set on the table.
+- Updatable views can accept INSERT/UPDATE/DELETE that are then applied to the base table. Without `WITH CHECK OPTION`, writes that don’t match the view predicate may still succeed.
+
+Risk pattern observed in the wild:
+- A reduced-column VIEW is exposed through Supabase REST and granted to `anon`/`authenticated`.
+- PostgREST allows DML on the updatable VIEW and the operation is evaluated with the view owner’s privileges, effectively bypassing the intended RLS policies on the base table.
+- Result: low-privileged clients can mass-edit rows (e.g., profile bios/avatars) they should not be able to modify.
+
+Illustrative write via view (attempted from a public client):
+```bash
+curl -X PATCH \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+-H "Content-Type: application/json" \
+-H "Prefer: return=representation" \
+-d '{"bio":"pwned","avatar_url":"https://i.example/pwn.png"}' \
+"https://<PROJECT_REF>.supabase.co/rest/v1/users_view?id=eq.<victim_user_id>"
+```
+Checklist di hardening per views e RLS:
+- Preferisci esporre le tabelle base con permessi espliciti, minimo privilegio e politiche RLS precise.
+- Se devi esporre una view:
+  - Rendila non-updatable (es., includendo espressioni/join) o nega `INSERT/UPDATE/DELETE` sulla view a tutti i ruoli non attendibili.
+  - Forza `ALTER VIEW <v> SET (security_invoker = on)` in modo che vengano usati i privilegi dell'invocatore invece di quelli del proprietario.
+  - Sulle tabelle base, usa `ALTER TABLE <t> FORCE ROW LEVEL SECURITY;` in modo che anche i proprietari siano soggetti a RLS.
+  - Se permetti scritture tramite una view updatable, aggiungi `WITH [LOCAL|CASCADED] CHECK OPTION` e politiche RLS complementari sulle tabelle base per garantire che solo le righe consentite possano essere scritte/modificate.
+  - In Supabase, evita di concedere a `anon`/`authenticated` qualsiasi privilegio di scrittura sulle view a meno che tu non abbia verificato il comportamento end-to-end con test.
+
+Detection tip:
+- Da `anon` e da un utente di test `authenticated`, prova tutte le operazioni CRUD contro ogni tabella/view esposta. Qualsiasi scrittura riuscita che ti aspettavi fosse negata indica una misconfigurazione.
+
+### Probing CRUD guidato da OpenAPI dai ruoli anon/auth
+
+PostgREST espone un documento OpenAPI che puoi usare per enumerare tutte le risorse REST, quindi sondare automaticamente le operazioni consentite dai ruoli a basso privilegio.
+
+Recupera l'OpenAPI (funziona con la public anon key):
+```bash
+curl -s https://<PROJECT_REF>.supabase.co/rest/v1/ \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+-H "Accept: application/openapi+json" | jq '.paths | keys[]'
+```
+Probe pattern (examples):
+- Leggi una singola riga (atteso 401/403/200 a seconda di RLS):
+```bash
+curl -s "https://<PROJECT_REF>.supabase.co/rest/v1/<table>?select=*&limit=1" \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>"
+```
+- Verificare che UPDATE sia bloccato (usa un filtro non esistente per evitare di alterare i dati durante i test):
+```bash
+curl -i -X PATCH \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+-H "Content-Type: application/json" \
+-H "Prefer: return=minimal" \
+-d '{"__probe":true}' \
+"https://<PROJECT_REF>.supabase.co/rest/v1/<table_or_view>?id=eq.00000000-0000-0000-0000-000000000000"
+```
+- Test INSERT è bloccato:
+```bash
+curl -i -X POST \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+-H "Content-Type: application/json" \
+-H "Prefer: return=minimal" \
+-d '{"__probe":true}' \
+"https://<PROJECT_REF>.supabase.co/rest/v1/<table_or_view>"
+```
+- Verifica che DELETE sia bloccato:
+```bash
+curl -i -X DELETE \
+-H "apikey: <SUPABASE_ANON_KEY>" \
+-H "Authorization: Bearer <SUPABASE_ANON_KEY>" \
+"https://<PROJECT_REF>.supabase.co/rest/v1/<table_or_view>?id=eq.00000000-0000-0000-0000-000000000000"
+```
+Recommendations:
+- Automatizza le probe precedenti per entrambi `anon` e un utente minimamente `authenticated` e integrale nella CI per intercettare regressioni.
+- Tratta ogni table/view/function esposta come una superficie di prima classe. Non presumere che una view “inherits” lo stesso posture RLS delle sue tabelle di base.
+
+### Passwords & sessions
+
+È possibile indicare la lunghezza minima della password (di default), i requisiti (nessuno di default) e disallow to use leaked passwords.\
+È raccomandato **migliorare i requisiti poiché quelli di default sono deboli**.
+
+- Sessioni utente: È possibile configurare come funzionano le user sessions (timeouts, 1 session per user...)
+- Bot and Abuse Protection: È possibile abilitare Captcha.
+
+### SMTP Settings

 È possibile impostare un SMTP per inviare email.

-### Impostazioni avanzate
+### Advanced Settings

- Imposta il tempo di scadenza per i token di accesso (3600 per impostazione predefinita)
- Imposta per rilevare e revocare i token di aggiornamento potenzialmente compromessi e timeout
- MFA: Indica quanti fattori MFA possono essere registrati contemporaneamente per utente (10 per impostazione predefinita)
- Max Direct Database Connections: Numero massimo di connessioni utilizzate per l'autenticazione (10 per impostazione predefinita)
- Max Request Duration: Tempo massimo consentito per la durata di una richiesta di autenticazione (10s per impostazione predefinita)
+- Impostare il tempo di scadenza degli access tokens (3600 by default)
+- Abilitare il rilevamento e la revoca dei refresh tokens potenzialmente compromessi e timeout
+- MFA: Indicare quanti fattori MFA possono essere enrolati contemporaneamente per utente (10 by default)
+- Max Direct Database Connections: Numero massimo di connessioni usate per l'auth (10 by default)
+- Max Request Duration: Tempo massimo consentito per una richiesta di Auth (10s by default)

-## Archiviazione
+## Storage

 > [!TIP]
-> Supabase consente **di archiviare file** e renderli accessibili tramite un URL (utilizza bucket S3).
+> Supabase allows **to store files** and make them accesible over a URL (it uses S3 buckets).

- Imposta il limite di dimensione del file da caricare (il predefinito è 50MB)
- La connessione S3 è fornita con un URL come: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3`
- È possibile **richiedere una chiave di accesso S3** che è formata da un `access key ID` (ad es. `a37d96544d82ba90057e0e06131d0a7b`) e una `secret access key` (ad es. `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`)
+- Impostare il limite di dimensione per l'upload dei file (default è 50MB)
+- La connessione S3 è fornita con una URL come: `https://jnanozjdybtpqgcwhdiz.supabase.co/storage/v1/s3`
+- È possibile **request S3 access key** che sono formate da un `access key ID` (e.g. `a37d96544d82ba90057e0e06131d0a7b`) e un `secret access key` (e.g. `58420818223133077c2cec6712a4f909aec93b4daeedae205aa8e30d5a860628`)

-## Funzioni Edge
+## Edge Functions

-È possibile **memorizzare segreti** in supabase che saranno **accessibili dalle funzioni edge** (possono essere create e eliminate dal web, ma non è possibile accedere direttamente al loro valore).
+È possibile anche **store secrets** in supabase che saranno **accessible by edge functions** (possono essere create e cancellate dal web, ma non è possibile accedere direttamente al loro valore).
+
+## References
+
+- [Building Hacker Communities: Bug Bounty Village, getDisclosed’s Supabase Misconfig, and the LHE Squad (Ep. 133) – YouTube](https://youtu.be/NI-eXMlXma4)
+- [Critical Thinking Podcast – Episode 133 page](https://www.criticalthinkingpodcast.io/episode-133-building-hacker-communities-bug-bounty-village-getdisclosed-and-the-lhe-squad/)
+- [Supabase: Row Level Security (RLS)](https://supabase.com/docs/guides/auth/row-level-security)
+- [PostgreSQL: Row Security Policies](https://www.postgresql.org/docs/current/ddl-rowsecurity.html)
+- [PostgreSQL: CREATE VIEW (security_invoker, check option)](https://www.postgresql.org/docs/current/sql-createview.html)
+- [PostgREST: OpenAPI documentation](https://postgrest.org/en/stable/references/api.html#openapi-documentation)

 {{#include ../banners/hacktricks-training.md}}