---
title: "Test di isolamento multi-tenant: 6 falle nascoste"
description: "Come provare che il cliente A non vede i dati di B: 14 richieste su due aziende, 4 controlli di lettura puliti, ma altri 6 percorsi lasciavano trapelare dati."
url: "https://madsalt.tech/it/blog/multi-tenant-isolation-test/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/it/about/"
language: "it"
published: 2026-11-06
---

# Test di isolamento multi-tenant: 6 falle nascoste

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?

![Uno schema, 14 richieste all’azienda 2. Utente A, vero membro autenticato dell’azienda 1. Letture abituali su invoices: 4 richieste → 0 falle; Tabella figlia, view, funzione, membri, scritture: 10 richieste → 6 falle; Dopo le correzioni: 14 richieste → 0 falle, propri dati leggibili.](https://madsalt.tech/charts/it/multi-tenant-isolation-test.svg)

*Figura 1. Il mio test su uno stack Supabase locale (CLI 2.109.1), 3 novembre 2026.*

| 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?

```sql
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](https://madsalt.tech/it/notes/supabase-rls-user-in-two-organizations/).

## Come si esegue sulla propria app?

1. Crei due aziende, un utente in ciascuna, e popoli ognuna con una riga in ogni tabella che contiene dati dei clienti.
2. Ottenga una vera sessione per l'utente A. Un test eseguito come `postgres` o con la chiave segreta salta la RLS e non prova nulla.
3. 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.
4. Per ciascuno, provi a leggere la riga dell'azienda 2, e provi lettura, insert, update e delete con `company_id` che punta all'azienda 2. Provi anche a spostare una Sua riga nell'altra azienda e ad aggiungersi all'altra azienda.
5. Dopo ogni scrittura, confronti la riga tramite una connessione privilegiata.
6. Esegua i Suoi controlli: A deve leggere e scrivere le righe dell'azienda 1.
7. 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](https://madsalt.tech/it/tools/tenant-isolation-test/) 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](https://madsalt.tech/it/tools/supabase-security-check/) 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](https://madsalt.tech/it/blog/how-to-test-supabase-rls/). Su Firebase vale la stessa idea, con gli attacchi negli [esempi di regole di sicurezza Firebase](https://madsalt.tech/it/blog/firebase-security-rules-examples/).

## 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](https://madsalt.tech/it/blog/penetration-test-cost/) è 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](https://madsalt.tech/it/work/audit-firm-time-tracking/).

Se le serve un'app multi-tenant costruita con questi test fin dal primo giorno, veda lo [sviluppo SaaS e di applicazioni web](https://madsalt.tech/it/services/saas-web-app-development/).

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](https://madsalt.tech/it/#contact)
