Des articles approfondis sur les technologies qui façonnent l'avenir.

Applis générées par IA sans Row-Level Security

Passeports et plus de 200 000 messages privés exposés à cause d'une Row-Level Security Supabase absente. Voici comment auditer vos applications.

Applications identiques générées par IA sur un tapis roulant, chacune avec une porte ouverte laissant fuir des documents.
Quand chaque application est construite à partir du même modèle, un seul verrou manquant ouvre des milliers de portes.

159 041 applications. C'est le nombre d'applications web générées par IA qu'une équipe de chercheurs a extraites de l'archive Common Crawl pour vérifier un seul défaut, banal : peut-on lire des enregistrements de base de données sans se connecter ? Pour 7 403 des sites sondés en profondeur, la réponse était oui. Des tables contenant des adresses e-mail étaient lisibles par quiconque les demandait. En creusant, ils ont trouvé des noms complets et des dates de naissance, des coordonnées de paiement, des codes de billets, des exports WhatsApp internes, des résumés générés par IA des e-mails d'un gestionnaire immobilier, plus de 200 000 messages de chat privés d'un forum lifestyle et, au pire, plus d'un millier d'enregistrements contenant des numéros de passeport, des dates d'expiration et des nationalités. La cause racine, dans presque tous les cas, était l'absence de Row-Level Security sur Supabase, et l'exploiter ne demandait rien de plus exotique que les outils de développement d'un navigateur.

Il faut être précis sur les chiffres, car ils sont souvent mal cités. Sur les 159 041 projets Lovable identifiés, 34 545 utilisaient Supabase comme base de données. Parmi eux, 24 664 envoyaient des enregistrements au navigateur dès le chargement de la page, sans connexion ni interaction. Cela ne constitue pas en soi un bug : beaucoup de données sont censées être publiques. Les chercheurs ont donc effectué des requêtes supplémentaires en lecture seule avec la même clé d'API que chaque site livrait dans son propre JavaScript, et ont regardé ce qui revenait. Des enregistrements contenant des adresses e-mail apparaissaient dans 10 560 tables réparties sur 7 403 sites, soit 30 % des sites examinés de près. Ce n'est pas un taux de fuite confirmé, et les chercheurs prennent soin de le préciser : certaines adresses sont des boîtes de contact publiques ou des données de test. Mais les cas vérifiés manuellement étaient sans ambiguïté. De vrais clients. De vrais passeports. De vrais messages privés.

Row-Level Security de Supabase, seul rempart

Pour comprendre pourquoi cela se répète, il faut comprendre le contrat que Supabase vous propose. Vous obtenez une base Postgres avec une API REST générée automatiquement devant elle, et votre frontend parle directement à la base. Aucune couche backend n'applique les autorisations : pas de middleware Express, pas de mixin de permissions Django, rien. Le navigateur détient une clé d'API anon, publique par conception, qui se retrouve dans votre bundle JavaScript. Une seconde clé, service_role, contourne tout et ne doit jamais toucher un client.

Comme le client se connecte directement à la base, c'est la base elle-même qui doit décider ce que chaque requête peut voir. Ce mécanisme, c'est la Row-Level Security de Postgres : des politiques par table qui filtrent les lignes qu'un rôle donné peut lire ou modifier. Et voici le piège : si la RLS n'est pas activée sur une table, la clé publique anon peut lire et écrire chaque ligne. Point final. La table pourrait tout aussi bien être un fichier JSON statique sur votre CDN.

create table profiles (
id uuid primary key default gen_random_uuid(),
full_name text,
email text,
date_of_birth date
);
-- This is the line that decides whether the table is public:
alter table profiles enable row level security;
-- Without it, the shipped anon key reads and writes every row.
# The "attack": the same request the app makes, minus the login
curl "https://your-project.supabase.co/rest/v1/profiles?select=*" \
-H "apikey: eyJhbGciOi..." \
-H "Authorization: Bearer eyJhbGciOi..."

Regardez encore cette commande curl. Ce n'est pas vraiment un exploit. C'est la même requête que fait le frontend légitime, rejouée sans session utilisateur. La clé d'API n'a pas été volée : elle a été publiée, servie à chaque visiteur dans le code du site. Le seul obstacle entre cette requête et les passeports de vos clients est un paramètre Postgres que personne n'a activé. C'est pourquoi je répète que les expositions Lovable n'étaient pas « piratées ». Elles étaient laissées déverrouillées.

Pourquoi les générateurs d'applications IA livrent un contrôle d'accès défaillant

La question évidente : pourquoi le générateur n'active-t-il pas simplement la RLS ? Parce que, de son point de vue, rien n'est cassé. L'application fonctionne. L'aperçu se charge, les enregistrements apparaissent, la démo impressionne le fondateur qui l'a fait naître d'un prompt. Un contrôle d'accès manquant est une panne silencieuse : une application sans RLS se comporte exactement comme une application correctement sécurisée, jusqu'au moment où quelqu'un de non autorisé se présente. Il n'existe aucune stack trace pour « un inconnu dans un autre pays lit votre table de messages ». Un générateur optimisé pour « est-ce que ça tourne ? » sous-investira systématiquement dans « qui d'autre peut le faire tourner ? ».

Il y a aussi un problème de spécification. « Crée-moi une plateforme de réservation pour mon restaurant » ne dit rien sur qui devrait pouvoir lire la table des réservations. Un développeur humain comble ce vide avec les conventions, l'expérience accumulée et quelques questions gênantes lors de la réunion de lancement. Un LLM le comble avec la suite statistiquement la plus courante, et le code de tutoriel Supabase le plus répandu sur internet a la RLS désactivée, parce que les tutoriels la désactivent pour garder le chemin heureux court. C'est l'écart entre spécification et implémentation qui fait ce qu'il fait toujours : le bug se niche exactement là où le prompt se taisait.

Reste la question des valeurs par défaut, dont Supabase porte une part. Pendant des années, les nouvelles tables créées depuis son tableau de bord avaient la RLS désactivée, sauf à savoir l'activer manuellement. C'était un compromis délibéré pour l'onboarding, car rien ne tue plus vite l'élan d'un tutoriel que des requêtes qui renvoient des résultats vides. Après des critiques soutenues, Supabase a orienté les nouveaux projets vers une RLS activée par défaut, mais les projets existants ont conservé leur configuration d'origine. Ajoutez un générateur entraîné sur des années de code antérieur à ce changement de défaut, et vous obtenez un pipeline qui produit de façon fiable des tables exposées.

Enfin, le facteur humain. Lovable promet qu'aucune connaissance technique n'est nécessaire, et ses conditions placent clairement la responsabilité de l'application et de ses données sur le client. C'est dans cet écart qu'ont poussé 7 403 sites qui fuient. Un fondateur non technique ne peut pas auditer ce qu'il ne sait pas lire. Il ignore que la RLS existe, il ignore que la clé anon est publique, et le joyeux « votre app est en ligne ! » de la plateforme ne lui donne aucune raison de poser la question. Le marketing disait que l'avion pilote tout seul. Les petites lignes disaient qu'il fallait quand même un pilote, et que c'était vous.

Un seul modèle cassé, des milliers de cibles identiques

Ce qui rend le problème vraiment dangereux, ce n'est pas une application qui fuit, c'est l'homogénéité. Les générateurs IA produisent des schémas d'intégration récurrents : la même configuration client, les mêmes conventions de tables, la même URL de projet Supabase dans le même bundle JavaScript. Cela fait s'effondrer le coût pour l'attaquant. Écrivez un script qui identifie un site construit avec Lovable, extrait l'URL Supabase et la clé anon, liste les tables exposées et exécute select=* sur chacune : il fonctionne sur des milliers d'applications avec très peu de modifications. Le contrôle d'accès défaillant figure en tête du Top 10 OWASP depuis des années. Ce qui est nouveau, c'est l'échelle industrielle à laquelle des instances identiques de ce défaut peuvent désormais être fabriquées et moissonnées.

Certains praticiens refusent même de parler de « fuite » : les sites ont eux-mêmes publié la clé et servi les données, donc les consommer n'est pas un accès non autorisé. C'est la publication qui constituait la fuite. Sur le plan terminologique, ils ont un point. Mais c'est de la pinaillerie, qui ne compte que pour désigner des responsables, et qui ne veut rien dire pour la personne dont le numéro de passeport s'est retrouvé dans la réponse JSON d'un inconnu. Personne n'a consenti à cette architecture.

L'application fonctionnait parfaitement. C'était tout le problème : elle fonctionnait parfaitement pour tout le monde.

Les conséquences juridiques tombent là où elles tombent toujours : sur celui qui a mis l'application en ligne. Au titre du RGPD, le propriétaire de l'application est le responsable du traitement. Or cette recherche vient d'Allemagne, porte sur une plateforme suédoise et concerne des pièces d'identité de citoyens européens. Numéros de passeport, noms et nationalités forment un kit de départ pour l'usurpation d'identité ; 200 000 messages privés constituent un réservoir pour le chantage et l'hameçonnage. Savoir si les régulateurs ouvriront une procédure reste à voir, mais si vous êtes le fondateur qui a codé une base clients à l'aveugle puis s'en est désintéressé, « c'est l'IA qui a fait ça » n'est une défense acceptée par aucune autorité de protection des données.

Une rangée de maisons identiques, chacune avec une clé sous le paillasson, qu'une silhouette collecte une à une.
Un code généré homogène signifie qu'un seul mode opératoire d'attaque fonctionne sur toute une rangée d'applications.

Comment auditer les configurations Supabase générées avant la mise en production

Si vous avez mis en ligne, ou hérité, une application générée par IA sur Supabase, voici l'audit que je fais. Il prend une après-midi. Faites-le avant qu'une seule donnée client réelle n'approche de l'application.

  1. Inventoriez les tables exposées. Exécutez la requête RLS ci-dessous dans l'éditeur SQL. Chaque table du schéma public sans RLS est lisible et modifiable par le monde entier grâce à la clé anon livrée.
  2. Relisez chaque politique. Une RLS activée ne veut rien dire si la politique est using (true). Les générateurs adorent produire des politiques qui autorisent tout, car elles font taire les erreurs pendant le développement.
  3. Jouez l'application comme un inconnu. Copiez la clé anon depuis le JavaScript déployé et interrogez chaque endpoint REST sans session. Toute ligne qui revient est publique. Était-ce votre intention ?
  4. Vérifiez les buckets de stockage. Un bucket public transforme chaque fichier qu'il contient en URL accessible. Les albums photo et les scans de pièces d'identité n'ont rien à y faire.
  5. Cherchez service_role dans le bundle client. Que la clé anon soit publiée est normal ; que la clé de service le soit est une catastrophe. Votre client API déployé est un coffre-fort d'identifiants, auditez-le.
-- Tables exposed via the API with RLS disabled (each one is public)
select schemaname, tablename
from pg_tables
where schemaname = 'public'
and rowsecurity = false;
-- The subtler failure: RLS enabled, but what do the policies allow?
select schemaname, tablename, policyname, cmd, qual
from pg_policies
where schemaname = 'public';

La seconde requête est la plus intéressante. Vous trouverez des tables avec RLS activée mais sans aucune politique, ce qui échoue en mode fermé et signale généralement qu'une fonctionnalité a discrètement cassé et que quelqu'un l'a « réparée » en relâchant autre chose. Vous trouverez aussi des politiques de ce type, que j'ai désormais croisées dans assez de codebases générées pour les reconnaître à vue :

-- The policy generators emit when a query fails during development:
create policy "allow all" on messages for all using (true);
-- It silences the error and publishes the table. Reject it on sight.
-- What a real policy looks like:
create policy "users read their own messages"
on messages for select
to authenticated
using (auth.uid() = sender_id or auth.uid() = recipient_id);

Le motif using (true) mérite une attention particulière, car c'est l'équivalent, dans le code généré, de commenter une vérification d'authentification pour faire passer un test. Il existe parce que le générateur a rencontré une erreur de permission, a correctement diagnostiqué l'absence de politique, et en a écrit la plus paresseuse possible. Quand vous en trouvez une, ne vous contentez pas de la resserrer : demandez-vous pourquoi la table était accessible dans ce chemin de code. Refaites ensuite tout l'audit après chaque régénération importante. Les builders IA réécrivent volontiers votre schéma, et les politiques strictes d'hier ne survivent pas au prompt « fais afficher tous les utilisateurs sur le tableau de bord » d'aujourd'hui.

Les scanners de sécurité aident, mais ce sont les valeurs par défaut qui décident

À son crédit, l'équipe sécurité de Lovable a répondu directement à la recherche : elle identifie une RLS insuffisante comme cause racine, scanne automatiquement chaque application avant publication, propose un scan SAST plus approfondi, permet de corriger les problèmes en un clic, d'activer la correction automatique, ou de bloquer la publication en cas de résultats critiques, le tout gratuitement pour tous les utilisateurs. C'est une boîte à outils raisonnable, et plus que ce que livrent la plupart des builders d'applications.

Mais regardez ce qu'implique un scanner de pré-publication : le générateur a d'abord produit la faille, et il faut maintenant un second système pour la détecter. Le taux de détection du scanner mesure la fréquence à laquelle la sortie par défaut est peu sûre. J'ai déjà écrit sur la façon dont les scanners de sécurité IA réclament notre dette technique : ils sont utiles, mais ils traitent les symptômes. La correction durable est une génération « refuser par défaut » : chaque table créée avec la RLS activée, chaque table recevant une politique explicite, fût-elle « tout refuser » jusqu'à ce que l'utilisateur choisisse d'en ouvrir davantage. L'état non sécurisé devrait être celui qui exige un effort. Aujourd'hui, c'est l'inverse, et 24 664 applications qui diffusent des enregistrements de base au chargement de la page sont le prix de cette inversion.

Une loupe au-dessus d'une grille de données lumineuse, avec quelques lignes surlignées comme exposées.
Auditer des schémas générés, c'est vérifier chaque table : les lignes exposées ne se signalent que rarement d'elles-mêmes.

Ce qu'il faut retenir si vous mettez en ligne des applications construites avec l'IA

L'IA n'a pas inventé le contrôle d'accès défaillant. Les IDOR et les autorisations manquantes figurent dans les listes de vulnérabilités depuis bien avant que quiconque ait fait naître une application d'un prompt. Ce que l'IA a changé, c'est le volume et les opérateurs : elle a industrialisé un mode de défaillance connu et mis le bouton de déploiement entre les mains de personnes incapables de distinguer une politique RLS d'une règle CSS. Le chiffre de 30 % issu de cette recherche n'est pas un scandale propre à une plateforme. C'est un aperçu de tout écosystème où du code généré rencontre une base de données publique dotée d'un modèle de sécurité à activer soi-même.

Traitez donc chaque application générée par IA comme du code de prestataire non audité, car c'est exactement ce que c'est. Lancez les requêtes ci-dessus avant la mise en production et après chaque changement majeur. Si l'application doit héberger des données réglementées ou d'identité et que personne en interne ne sait lire une politique Postgres, payez quelqu'un qui le sait : une après-midi de revue experte coûte moins cher que d'expliquer des numéros de passeport à un régulateur. Le no-code a supprimé la syntaxe. Il n'a pas supprimé la responsabilité, et il ne la supprimera jamais.