In breve
Per provare che un cliente non raggiunge i dati di un altro, acceda come utente reale dell’azienda 1 e attacchi l’azienda 2 attraverso ogni percorso, poi legga il database per vedere cosa è cambiato. Su uno schema volutamente rotto, i quattro controlli che la maggior parte delle persone prova sono risultati puliti mentre 6 richieste su 14 lasciavano trapelare dati: una tabella figlia, l’elenco dei membri, una view, una funzione, l’ingresso nell’altra azienda, e un insert che restituiva 403 in una forma e passava in un’altra. Un codice di stato da solo mi ha ingannato due volte. E un test senza controllo positivo passa su un’app in cui nessuno può leggere nulla.
«Il cliente A può vedere i dati del cliente B?» è la domanda che pone un acquirente B2B, e «usiamo la row level security» non risponde. Risponde un test che qualcuno può rieseguire. Ho costruito un piccolo schema di fatturazione con errori che ho visto in app reali, poi ho scritto il test che doveva trovarli.
Come ho testato. Stack Supabase locale (CLI 2.109.1) il 3 novembre 2026, tramite l’API REST, con un vero accesso per ogni utente. L’utente A appartiene all’azienda 1. L’azienda 2 contiene le fatture bersaglio, e A non deve mai raggiungerle. Dati inventati. Dopo ogni tentativo di scrittura ho letto la tabella direttamente con psql, perché la risposta dell’API non è una prova. Il metodo non dipende da Supabase; su un altro stack cambierebbero solo le richieste.
Cosa hanno mostrato i controlli abituali?
Sono i controlli che vedo più spesso. Tutti e quattro erano puliti sullo schema rotto.
| Richiesta dell’utente A | Risultato |
|---|---|
| Elencare le fatture | 200, la propria (1 riga) |
| Leggere per id la fattura dell’azienda 2 | 200, 0 righe |
Filtrare per company_id = 2 |
200, 0 righe |
| Contare le fatture dell’azienda 2 | 0 |
La policy di lettura di invoices era corretta, e chi testasse solo questa tabella darebbe il via libera.
Cosa raggiungeva lo stesso utente per altri percorsi?
| Percorso | Perché trapelava | Schema rotto | Dopo la correzione |
|---|---|---|---|
Tabella figlia invoice_lines |
RLS attiva, policy using (true) |
200, 2 righe di entrambe |
200, la propria (1) |
memberships |
Policy di lettura using (true) |
200, utenti di entrambe le aziende |
200, la propria (1) |
View invoice_totals |
Gira con i diritti del suo proprietario, salta la RLS | 200, somme di entrambe le aziende |
200, la propria (1) |
Funzione get_invoice(21) |
security definer senza controllo dell’azienda |
200, la fattura di B |
200, 0 righe |
| Entrare nell’azienda 2 | L’insert controlla solo user_id = auth.uid() |
201, poi 3 fatture elencate |
403 |
| Inserire una fattura per l’azienda 2 | L’insert controlla solo che l’utente sia autenticato | 201, riga nella tabella |
403 |
I primi quattro sono percorsi di lettura che un test basato sui moduli non tocca mai. Nessuna schermata dell’app li chiama con i dati di un’altra azienda, quindi cliccare in giro non li trova.
Perché non ci si può fidare del codice di stato?
L’ultima riga di quella tabella mi è quasi sfuggita. La mia prima versione dell’insert restituiva 403:
new row violates row-level security policy
Sembrava un superamento. Ma la policy di insert permetteva la riga. L’errore veniva da return=representation, che chiede di riavere la nuova riga, e A non ha accesso in lettura a una riga dell’azienda 2. Lo stesso insert con return=minimal, la forma che supabase-js usa a meno che non si aggiunga .select(), ha restituito 201, e psql mostrava la riga nella tabella dell’azienda 2.
Esiste anche l’errore opposto. Con una policy corretta, update e delete di A sulla fattura dell’azienda 2 hanno entrambi restituito 200 con 0 righe. Leggendo la tabella, l’importo era invariato e la fattura c’era ancora. Quindi 200 non voleva dire che aveva funzionato, e 403 non voleva dire che era fallito.
Usi il database come verdetto. Esegua ogni tentativo di scrittura, poi legga la riga con una connessione che salta la RLS e confronti.
Perché il test ha bisogno di un controllo positivo?
Ho eseguito le stesse 14 richieste con tutti i grant sulle tabelle revocati. Risultato: 0 falle su 14. Secondo questo conteggio lo schema è perfettamente isolato, e nessuno può nemmeno usare l’app.
| Schema | Falle | A legge i propri dati |
|---|---|---|
| Rotto | 6/14 | 2/2 |
| Corretto | 0/14 | 2/2 |
| Tutti i grant revocati | 0/14 | 0/2 |
Ogni test «A non può leggere B» ha bisogno di un «A può leggere A» accanto. Altrimenti un grant mancante, un errore di battitura nel nome di una tabella o un token scaduto sembrano tutti sicurezza. Sono le prime due righe del mio script, e sullo schema revocato sono quelle che hanno fallito.
Cosa ha corretto tutti e sei?
create policy m_read on memberships for select to authenticated
using (company_id in (select my_companies()));
create policy i_ins on invoices for insert to authenticated
with check (company_id in (select my_companies()));
create policy l_read on invoice_lines for select to authenticated
using (invoice_id in (select id from invoices));
create view invoice_totals with (security_invoker = true) as
select company_id, sum(amount) total, count(*) n
from invoices group by company_id;
create function get_invoice(p int) returns setof invoices
language sql security invoker set search_path = ''
as $$ select * from public.invoices where id = p $$;
Il percorso dell’ingresso si è chiuso rimuovendo la policy di insert su memberships. Aggiungere qualcuno a un’azienda è un flusso di invito, quindi appartiene al codice server. my_companies() è una funzione di supporto security definer che restituisce gli id delle aziende dell’utente autenticato. Se un utente può appartenere a più aziende, c’è un’altra trappola, in un utente in due organizzazioni.
Come si esegue sulla propria app?
- Crei due aziende, un utente in ciascuna, e popoli ognuna con una riga in ogni tabella che contiene dati dei clienti.
- Ottenga una vera sessione per l’utente A. Un test eseguito come
postgreso con la chiave segreta salta la RLS e non prova nulla. - Elenchi ogni percorso: ogni tabella e tabella figlia, ogni view, ogni funzione, poi gli endpoint di ricerca ed esportazione. Una query sul catalogo è più affidabile della memoria.
- Per ciascuno, provi a leggere la riga dell’azienda 2, e provi lettura, insert, update e delete con
company_idche punta all’azienda 2. Provi anche a spostare una Sua riga nell’altra azienda e ad aggiungersi all’altra azienda. - Dopo ogni scrittura, confronti la riga tramite una connessione privilegiata.
- Esegua i Suoi controlli: A deve leggere e scrivere le righe dell’azienda 1.
- Lo tenga in CI. Una nuova tabella senza test deve far fallire la build.
Per il lato lettura su Supabase, il test di isolamento dei tenant gratuito crea uno script di sola lettura a partire da due id utente e mostra cosa legge ciascun utente, tabella per tabella. Le scritture restano sulla sua lista. Il Controllo sicurezza Supabase gratuito trova il lato catalogo di tutto questo, come le policy che consentono ogni riga e le view che aggirano la RLS. Non può dire a quale azienda appartenga una riga, quindi non sostituisce questo test. Per verificare ogni ruolo contro ogni permesso, il metodo è in come testare la Supabase RLS. Su Firebase vale la stessa idea, con gli attacchi negli esempi di regole di sicurezza Firebase.
Cosa si può mostrare a un acquirente?
Il risultato di questa esecuzione: l’elenco dei percorsi, l’esito di ciascuno e la data. È più di «abbiamo la RLS», e non sostituisce un pentest. Non dice nulla su sessioni rubate, errori di logica all’interno di un’azienda o strumenti di amministrazione usati dal Suo personale.
Limiti. Un piccolo schema scritto da me, rotto di proposito, su uno stack locale con dati inventati. Storage, realtime ed edge function non facevano parte di questa esecuzione, e hanno bisogno di propri percorsi nell’elenco. I progetti ospitati possono avere grant predefiniti diversi da uno stack locale, quindi lo esegua su una copia del Suo schema reale.
Se un acquirente chiede un report di penetration test, quanto costa nel 2026 è in un articolo a parte.
Il mio caso simile
Costruendo un sistema di time tracking per una società di revisione ho trovato 4 errori che nessuno schermo mostrava, tra cui un cliente riservato che trapelava dai totali dei report e dai conteggi delle etichette. Ogni regola di accesso ora sta nel database ed è testata prima di ogni rilascio; la storia completa è nel caso della società di revisione.
Se le serve un’app multi-tenant costruita con questi test fin dal primo giorno, veda lo sviluppo SaaS e di applicazioni web.
Deve mostrare a un cliente che i suoi dati sono separati? Mi scriva e testeremo ogni percorso.
Serve la prova che i dati dei clienti sono separati?
Mi dica cosa ha adesso e cosa le serve. Le risponderò con l'opzione che sceglierei io.
Mi scriva