---
title: "Test d’isolation multi-tenant : 6 fuites cachées"
description: "Prouver que le client A ne voit pas les données de B : 14 requêtes sur deux entreprises, 4 contrôles de lecture propres, mais 6 autres chemins fuyaient."
url: "https://madsalt.tech/fr/blog/multi-tenant-isolation-test/"
author: "Denys Zaichenko"
author_url: "https://madsalt.tech/fr/about/"
language: "fr"
published: 2026-11-06
---

# Test d’isolation multi-tenant : 6 fuites cachées

En bref

Pour prouver qu’un client n’atteint pas les données d’un autre, connectez-vous en tant qu’utilisateur réel de l’entreprise 1 et attaquez l’entreprise 2 par tous les chemins, puis lisez la base pour voir ce qui a changé. Sur un schéma volontairement cassé, les quatre contrôles que la plupart des gens essaient sont revenus propres alors que 6 requêtes sur 14 fuyaient : une table enfant, la liste des membres, une vue, une fonction, le fait de rejoindre l’autre entreprise, et une insertion qui renvoyait `403` sous une forme et passait sous une autre. Un code de statut seul m’a trompé deux fois. Et un test sans contrôle positif réussit sur une application où personne ne peut rien lire.

« Le client A peut-il voir les données du client B ? » est la question que pose un acheteur B2B, et « nous utilisons la row level security » n’y répond pas. Ce qui y répond, c’est un test que quelqu’un peut relancer. J’ai construit un petit schéma de facturation avec des erreurs que j’ai vues dans de vraies applications, puis j’ai écrit le test qui devait les attraper.

**Comment j’ai testé.** Pile Supabase locale (CLI 2.109.1) le 3 novembre 2026, via l’API REST, avec une vraie connexion pour chaque utilisateur. L’utilisateur A appartient à l’entreprise 1. L’entreprise 2 détient les factures visées, et A ne doit jamais les atteindre. Données inventées. Après chaque tentative d’écriture, j’ai lu la table directement avec `psql`, car la réponse de l’API n’est pas une preuve. La méthode ne dépend pas de Supabase ; seules les requêtes changeraient sur une autre pile.

## Que montraient les contrôles habituels ?

Ce sont les contrôles que je vois le plus souvent. Les quatre étaient propres sur le schéma cassé.

| Requête de l’utilisateur A               | Résultat                   |
| ---------------------------------------- | -------------------------- |
| Lister les factures                      | `200`, sa propre ligne (1) |
| Lire la facture de l’entreprise 2 par id | `200`, 0 ligne             |
| Filtrer par `company_id = 2`             | `200`, 0 ligne             |
| Compter les factures de l’entreprise 2   | 0                          |

La politique de lecture de `invoices` était correcte, et quelqu’un qui ne testerait que cette table donnerait son feu vert.

## Qu’atteignait le même utilisateur par d’autres chemins ?

![Un schéma, 14 requêtes vers l’entreprise 2. Utilisateur A, vrai membre connecté de l’entreprise 1. Lectures habituelles sur invoices: 4 requêtes → 0 fuite; Table enfant, vue, fonction, membres, écritures: 10 requêtes → 6 fuites; Après les corrections: 14 requêtes → 0 fuite, ses données lisibles.](https://madsalt.tech/charts/fr/multi-tenant-isolation-test.svg)

*Figure 1. Mon test sur une pile Supabase locale (CLI 2.109.1), 3 novembre 2026.*

| Chemin                                  | Pourquoi ça fuyait                                           | Schéma cassé                             | Après correction     |
| --------------------------------------- | ------------------------------------------------------------ | ---------------------------------------- | -------------------- |
| Table enfant `invoice_lines`            | RLS activée, politique `using (true)`                        | `200`, 2 lignes des deux                 | `200`, la sienne (1) |
| `memberships`                           | Politique de lecture `using (true)`                          | `200`, utilisateurs des deux entreprises | `200`, la sienne (1) |
| Vue `invoice_totals`                    | S’exécute avec les droits de son propriétaire, ignore la RLS | `200`, sommes des deux entreprises       | `200`, la sienne (1) |
| Fonction `get_invoice(21)`              | `security definer` sans contrôle d’entreprise                | `200`, la facture de B                   | `200`, 0 ligne       |
| Rejoindre l’entreprise 2                | L’insertion ne vérifie que `user_id = auth.uid()`            | `201`, puis 3 factures listées           | `403`                |
| Insérer une facture pour l’entreprise 2 | L’insertion vérifie seulement qu’un utilisateur est connecté | `201`, ligne dans la table               | `403`                |

Les quatre premiers sont des chemins de lecture qu’un test fondé sur les formulaires ne touche jamais. Aucun écran de l’application ne les appelle avec les données d’une autre entreprise, donc cliquer partout ne les trouvera pas.

## Pourquoi ne pas se fier au code de statut ?

La dernière ligne de ce tableau a failli m’échapper. Ma première version de l’insertion renvoyait `403` :

```
new row violates row-level security policy
```

Cela ressemblait à une réussite. Mais la politique d’insertion autorisait la ligne. L’erreur venait de `return=representation`, qui demande à récupérer la nouvelle ligne, et A n’a aucun accès en lecture à une ligne de l’entreprise 2. La même insertion avec `return=minimal`, la forme que `supabase-js` utilise sauf si vous ajoutez `.select()`, a renvoyé `201`, et `psql` montrait la ligne dans la table de l’entreprise 2.

L’erreur inverse existe aussi. Avec une politique correcte, la mise à jour et la suppression de la facture de l’entreprise 2 par A ont toutes deux renvoyé `200` avec 0 ligne. La lecture de la table montrait le montant inchangé et la facture toujours là. Donc `200` ne voulait pas dire que ça avait marché, et `403` ne voulait pas dire que ça avait échoué.

Prenez la base de données comme verdict. Exécutez chaque tentative d’écriture, puis lisez la ligne avec une connexion qui ignore la RLS et comparez.

## Pourquoi le test a-t-il besoin d’un contrôle positif ?

J’ai lancé les mêmes 14 requêtes avec tous les grants de table révoqués. Résultat : 0 fuite sur 14. Selon ce décompte, le schéma est parfaitement isolé, et personne ne peut non plus utiliser l’application.

| Schéma                   | Fuites | A lit ses données |
| ------------------------ | ------ | ----------------- |
| Cassé                    | 6/14   | 2/2               |
| Corrigé                  | 0/14   | 2/2               |
| Tous les grants révoqués | 0/14   | 0/2               |

Chaque test « A ne peut pas lire B » a besoin d’un « A peut lire A » à côté. Sinon un grant manquant, une faute de frappe dans un nom de table ou un jeton expiré ressemblent tous à de la sécurité. Ce sont les deux premières lignes de mon script, et sur le schéma révoqué ce sont elles qui ont échoué.

## Qu’est-ce qui a corrigé les six ?

```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 $$;
```

Le chemin « rejoindre » s’est fermé en supprimant la politique d’insertion sur `memberships`. Ajouter quelqu’un à une entreprise relève d’un flux d’invitation, donc cela appartient au code serveur. `my_companies()` est une fonction d’aide `security definer` qui renvoie les ids d’entreprise de l’utilisateur connecté. Si un utilisateur peut appartenir à plusieurs entreprises, il y a un piège de plus, décrit dans [un utilisateur dans deux organisations](https://madsalt.tech/fr/notes/supabase-rls-user-in-two-organizations/).

## Comment lancer cela sur votre propre application ?

1. Créez deux entreprises, un utilisateur dans chacune, et remplissez chacune avec une ligne dans chaque table qui contient des données clients.
2. Obtenez une vraie session pour l’utilisateur A. Un test exécuté en tant que `postgres` ou avec la clé secrète ignore la RLS et ne prouve rien.
3. Listez chaque chemin : chaque table et table enfant, chaque vue, chaque fonction, puis les points d’accès de recherche et d’export. Une requête sur le catalogue est plus fiable que la mémoire.
4. Pour chacun, essayez de lire la ligne de l’entreprise 2, et essayez lecture, insertion, mise à jour et suppression avec `company_id` pointant vers l’entreprise 2. Essayez aussi de déplacer votre propre ligne vers l’autre entreprise, et de vous ajouter à l’autre entreprise.
5. Après chaque écriture, comparez la ligne via une connexion privilégiée.
6. Lancez vos contrôles : A doit lire et écrire les lignes de l’entreprise 1.
7. Gardez-le en CI. Une nouvelle table sans test doit faire échouer le build.

Pour le côté lecture sur Supabase, le [test d’isolation multi-tenant](https://madsalt.tech/fr/tools/tenant-isolation-test/) gratuit construit un script en lecture seule à partir de deux identifiants d’utilisateur et montre, table par table, ce que chaque utilisateur peut lire. Les écritures restent sur votre liste. L’[audit de sécurité Supabase](https://madsalt.tech/fr/tools/supabase-security-check/) gratuit trouve le côté catalogue de tout cela, comme les politiques qui autorisent toutes les lignes et les vues qui contournent la RLS. Il ne peut pas dire à quelle entreprise appartient une ligne, donc il ne remplace pas ce test. Pour vérifier chaque rôle contre chaque permission, la méthode est dans [comment tester Supabase RLS](https://madsalt.tech/fr/blog/how-to-test-supabase-rls/). Sur Firebase, la même idée s’applique, avec les attaques dans les [exemples de règles de sécurité Firebase](https://madsalt.tech/fr/blog/firebase-security-rules-examples/).

## Que pouvez-vous montrer à un acheteur ?

Le résultat de cette exécution : la liste des chemins, le résultat de chacun et la date. C’est plus que « nous avons la RLS », et cela ne remplace pas un pentest. Cela ne dit rien des sessions volées, des erreurs de logique à l’intérieur d’une entreprise ni des outils d’administration que votre propre équipe utilise.

**Limites.** Un petit schéma que j’ai écrit, cassé exprès, sur une pile locale avec des données inventées. Storage, le temps réel et les edge functions ne faisaient pas partie de cette exécution, et ils ont besoin de leurs propres chemins dans la liste. Les projets hébergés peuvent avoir des grants par défaut différents d’une pile locale : lancez donc le test sur une copie de votre vrai schéma.

Si un acheteur demande un rapport de test d’intrusion, [ce que cela coûte en 2026](https://madsalt.tech/fr/blog/penetration-test-cost/) est dans un article à part.

## Mon cas similaire

En construisant un outil de suivi du temps pour un cabinet d'audit, j'ai trouvé 4 erreurs qu'aucun écran ne montrait, dont un client confidentiel qui fuyait par les totaux des rapports et les compteurs d'étiquettes. Chaque règle d'accès vit désormais dans la base de données et est testée avant chaque déploiement ; toute l'histoire est dans le [cas du cabinet d'audit](https://madsalt.tech/fr/work/audit-firm-time-tracking/).

Si vous avez besoin d'une application multi-tenant construite avec ces tests dès le premier jour, voyez le [développement SaaS et d'applications web](https://madsalt.tech/fr/services/saas-web-app-development/).

Vous devez montrer à un client que ses données sont séparées ? Écrivez-moi et nous testerons tous les chemins.

Besoin de prouver que les données clients sont séparées ?

Dites-moi ce que vous avez aujourd'hui et ce qu'il vous faut. Je vous répondrai avec l'option que je choisirais.

[Me contacter](https://madsalt.tech/fr/#contact)
