Tous les articles

Back-end14 min de lecture

App créée avec l'IA : quoi vérifier avant de publier

Checklist de sécurité pour les apps de Lovable, Bolt ou Cursor : RLS dans Supabase, clé secrète hors du front, clé d'IA côté serveur, storage et un test de 5 minutes.

Aussi en Português, English, Español

Des outils comme Lovable, Bolt et Cursor mettent une app en ligne en un après-midi : écran de connexion, inscription, base de données, tout fonctionne. Et c'est là que se cache le piège. Fonctionner, ce n'est pas la même chose qu'être protégé. Une app peut connecter, enregistrer et lister sans souci et, en même temps, livrer les données de tous ses utilisateurs à n'importe qui sachant les demander.

Ce n'est pas une hypothèse. Début novembre 2026, une étude publiée avec le quotidien allemand Handelsblatt a analysé plus de 150 000 projets créés sur Lovable et a trouvé des milliers de sites qui renvoyaient des données d'utilisateurs sans aucune connexion. Cet article explique pourquoi cela arrive et donne la checklist que je passerais avant de publier n'importe quelle app générée par IA.

Un avertissement honnête : je n'ai testé l'app de personne. Les chiffres viennent des sources citées à la fin, et les exemples de SQL et de code suivent la documentation de Supabase. Les images sont des illustrations que j'ai dessinées pour expliquer chaque partie.

TL;DR#

  • Le problème n'est presque jamais que l'IA écrive du code « piratable ». C'est que l'app part en ligne sans les règles d'accès de la base, parce que rien à l'écran ne montre qu'elles manquent.
  • Dans Supabase, la clé envoyée au navigateur est publique par nature. Ce qui protège les données, c'est le Row Level Security (RLS) : des règles dans Postgres qui disent qui peut lire et écrire chaque ligne.
  • Le RLS sur chaque table exposée, avec une vraie policy (pas de using (true) sur des données privées).
  • La clé secrète (l'ancienne service_role) et les clés d'IA ou de paiement ne vont jamais dans le front. Une variable avec le préfixe VITE_, NEXT_PUBLIC_ ou EXPO_PUBLIC_ finit dans le bundle, et le bundle est public.
  • Faites le test de 5 minutes : prenez l'URL et la clé que votre propre site envoie déjà et interrogez une table avec curl, sans connexion. Si des données d'autres personnes reviennent, ne publiez pas.
  • Recommencez après chaque modification. L'IA touche à une table et la règle peut partir avec.

Ce qui s'est passé#

L'étude est de Crissy Field, une entreprise allemande de sécurité, en partenariat avec le Handelsblatt. Ils ont utilisé Common Crawl (une archive publique du web) pour trouver des sites créés avec Lovable et publiés entre décembre 2025 et septembre 2026 :

  • 159 041 projets analysés, dont 34 545 utilisaient Supabase comme base de données.
  • 24 664 sites renvoyaient des enregistrements de la base dès le chargement de la page, sans connexion. Ce n'est pas une faille en soi : un blog montre ses articles à tout le monde, exprès.
  • En faisant uniquement des lectures avec la même clé publique que le site utilise déjà, ils ont trouvé des adresses e-mail dans 10 560 tables de 7 403 sites. Ce n'est pas non plus un taux de fuite confirmé, mais c'est un signal fort.
  • Parmi les exemples : un forum allemand avec plus de 80 000 profils et plus de 200 000 messages de chat, plus d'un millier d'enregistrements avec un numéro de passeport, des données de billetterie et des données de restaurants avec des informations de paiement.

La cause qu'ils pointent, ce sont des erreurs de contrôle d'accès. Et ce n'est pas la première fois : en 2025, un problème semblable est devenu la CVE-2025-48757, notée 9,3 (critique), décrite comme des policies de Row Level Security insuffisantes sur des sites générés par Lovable, permettant de lire et d'écrire dans des tables sans authentification. Lovable conteste cette CVE, en arguant que protéger les données relève de la responsabilité de chaque client.

Les deux lectures ont leur part de vérité, et c'est pour cela que cet article existe : l'outil génère, mais c'est celui qui publie qui répond de ce qu'il a publié.

Pourquoi ça arrive : le front parle directement à la base#

Dans une app classique, le navigateur parle à votre serveur, et le serveur décide quoi renvoyer. Dans le modèle que Lovable et Bolt génèrent souvent avec Supabase, il n'y a pas de serveur au milieu : le navigateur parle directement à l'API de la base, avec une clé intégrée au JavaScript du site.

Cette clé, c'est la publishable key (sb_publishable_..., l'ancienne anon). Elle est publique exprès : n'importe qui ouvrant les DevTools la voit. La documentation de Supabase utilise une bonne image : la clé publique, c'est celle qui est scotchée sur la porte d'entrée et qui n'ouvre que le hall. Ce qui sépare le hall des appartements, c'est le RLS.

La clé publique est la même pour tout le monde. Ce qui décide de ce que chacun voit, c'est la policy RLS de chaque table

Sans RLS, une table du schéma exposé (public, par défaut) peut être lue et modifiée par n'importe quel rôle qui a des droits dessus, et Supabase accorde par défaut des droits larges aux rôles anon (visiteur) et authenticated (connecté). Autrement dit : une table sans RLS est une table ouverte.

Et remarquez que l'app fonctionne de la même façon dans les deux cas. L'écran « mes commandes » filtre par utilisateur dans le JavaScript, donc tout a l'air correct. Sauf que le filtre est dans le front, et celui qui appelle l'API directement contourne le front.

Le test de 5 minutes#

Avant la checklist, un test que tout le monde peut faire sur sa propre app :

  1. Ouvrez votre site, ouvrez les DevTools et allez dans l'onglet Network.
  2. Trouvez une requête vers https://<votre-projet>.supabase.co/rest/v1/.... Ses headers contiennent l'URL du projet et la clé publique (apikey).
  3. Sans être connecté, interrogez une table qui stocke des données d'utilisateurs :
# Use your own project URL and the publishable key your site already sends.
curl "https://YOUR_PROJECT.supabase.co/rest/v1/profiles?select=*&limit=5" \
  -H "apikey: YOUR_PUBLISHABLE_KEY"
Même requête, sans connexion. Une liste vide, c'est ce que vous voulez voir

Si vous obtenez [] (ou une erreur de permission), parfait. Si des profils, des e-mails ou des commandes d'autres personnes reviennent, l'app n'est pas prête. Refaites la même chose en étant connecté avec un utilisateur de test et vérifiez que seules ses données à lui apparaissent.

Important : faites cela uniquement sur votre app. Interroger la base de données d'un site qui n'est pas le vôtre, même avec la clé qu'il expose, peut constituer un délit selon le pays.

La checklist#

1. Le RLS activé sur chaque table exposée#

Dans le SQL Editor de Supabase, cette requête liste les tables du schéma public qui n'ont pas de RLS :

select schemaname, tablename
from pg_tables
where schemaname = 'public'
  and not rowsecurity;

Chaque table qui apparaît ici est ouverte. Activer le RLS tient en une ligne :

alter table public.notes enable row level security;

Avec le RLS activé et aucune policy, rien n'est accessible par l'API avec la clé publique. C'est le comportement sûr : tout fermer, puis n'ouvrir que le nécessaire. Le tableau de bord de Supabase a aussi les Advisors, qui signalent les tables sans RLS et d'autres oublis. Ça vaut le coup d'y jeter un œil avant de publier.

2. Une vraie policy, une par opération#

Activer le RLS ferme la porte. La policy dit qui entre. Le modèle pour des données qui appartiennent à une personne :

create policy "Users read their own notes"
on public.notes for select
to authenticated
using ((select auth.uid()) = user_id);
 
create policy "Users create notes for themselves"
on public.notes for insert
to authenticated
with check ((select auth.uid()) = user_id);
 
create policy "Users update their own notes"
on public.notes for update
to authenticated
using ((select auth.uid()) = user_id)
with check ((select auth.uid()) = user_id);

Deux détails que l'IA rate souvent :

  • using (true) ouvre tout. Ça a du sens sur une table d'articles publics, pas sur une table de commandes. Si l'IA a « résolu » une erreur de permission en écrivant using (true), elle a désactivé la sécurité de cette table.
  • with check sur l'insert et l'update. Le using dit quelles lignes la personne peut voir ou modifier. Le with check dit à quoi la ligne peut ressembler ensuite. Sans lui, quelqu'un peut créer une note avec le user_id d'une autre personne.

3. Les droits ne vivent pas dans une colonne que l'utilisateur modifie#

Le RLS travaille par ligne, pas par colonne. Si la policy laisse une personne mettre à jour son propre profil, elle peut mettre à jour n'importe quelle colonne de ce profil. Donc, si le profil a is_admin ou plan, un simple update via l'API transforme n'importe quel utilisateur en admin ou en abonné premium.

La solution, c'est de garder les privilèges dans une table séparée, que l'utilisateur peut seulement lire :

create table public.user_roles (
  user_id uuid primary key references auth.users on delete cascade,
  role text not null default 'member'
);
 
alter table public.user_roles enable row level security;
 
create policy "Users read their own role"
on public.user_roles for select
to authenticated
using ((select auth.uid()) = user_id);
 
-- No insert, update or delete policy: only your server, with the secret key, changes roles.

C'est pareil pour le user_metadata de Supabase Auth : l'utilisateur peut modifier ce champ lui-même. Une policy qui fait confiance à un role stocké là est une policy que l'utilisateur contrôle.

4. Les views passent par-dessus le RLS#

Une view créée de la façon par défaut s'exécute avec les droits de celui qui l'a créée, et c'est pour cela qu'elle ignore le RLS des tables en dessous. L'IA adore créer une view pour « rassembler les données du dashboard ». Sur Postgres 15 ou plus récent, la correction est :

create view public.order_summary
with (security_invoker = true)
as select id, user_id, total, created_at from public.orders;

Avec security_invoker, la view respecte les policies de celui qui fait la requête.

5. La clé secrète reste sur le serveur#

La clé secrète (sb_secret_..., l'ancienne service_role) ignore complètement le RLS. Elle existe pour tourner sur votre serveur, dans une Edge Function, dans une tâche planifiée. Dans le navigateur ou dans une app mobile, elle livre la base entière à celui qui ouvre le bundle.

Deux façons dont elle fuit sans que personne ne s'en rende compte :

  • Préfixe public. Toute variable avec VITE_, NEXT_PUBLIC_ ou EXPO_PUBLIC_ est copiée dans le code envoyé à l'utilisateur. Une clé secrète avec ce préfixe est une clé publiée.
  • La « correction » d'une erreur. Une erreur de permission apparaît, l'IA remplace la clé publique par la clé secrète et tout fonctionne. Ça fonctionne parce que la sécurité a été désactivée.

Après le build, cherchez dans ce qui va être publié :

npm run build
grep -rEo "sb_secret_[A-Za-z0-9_-]+|sk-[A-Za-z0-9_-]{20,}" dist/ | head

Si quoi que ce soit apparaît, la clé a été publiée. Retirez-la du front et changez la clé dans le tableau de bord, car l'ancienne est peut-être déjà dans un cache quelque part.

6. Les clés d'IA, de paiement et d'e-mail aussi#

Une app créée avec l'IA utilise souvent l'IA, et la clé de l'API d'IA est celle qu'on retrouve le plus dans le front. Le SDK d'OpenAI, par exemple, n'accepte de tourner dans le navigateur qu'avec une option appelée dangerouslyAllowBrowser. Le nom dit tout :

// Bad: this key ships in the bundle, and anyone can spend your quota with it.
const client = new OpenAI({
  apiKey: import.meta.env.VITE_OPENAI_API_KEY,
  dangerouslyAllowBrowser: true,
})

Avec la clé dans le front, n'importe qui utilise votre quota, et c'est vous qui recevez la facture. Sa place est dans une fonction côté serveur, qui vérifie qui appelle et valide l'entrée avant de la transmettre :

// supabase/functions/summarize/index.ts
import { createClient } from 'npm:@supabase/supabase-js@2'
 
Deno.serve(async (req) => {
  // Act as the caller, so RLS still applies to anything this function reads.
  const supabase = createClient(Deno.env.get('SUPABASE_URL')!, Deno.env.get('SUPABASE_ANON_KEY')!, {
    global: { headers: { Authorization: req.headers.get('Authorization') ?? '' } },
  })
 
  const {
    data: { user },
  } = await supabase.auth.getUser()
  if (!user) return new Response('Unauthorized', { status: 401 })
 
  const { text } = await req.json()
  if (typeof text !== 'string' || text.length > 5000) {
    return new Response('Invalid input', { status: 400 })
  }
 
  // The AI key lives only in the function's secrets, never in the client.
  const response = await fetch(Deno.env.get('AI_API_URL')!, {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${Deno.env.get('AI_API_KEY')}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ input: `Summarize: ${text}` }),
  })
 
  return new Response(await response.text(), {
    status: response.status,
    headers: { 'Content-Type': 'application/json' },
  })
})

La même règle vaut pour la clé de la passerelle de paiement, du service d'e-mail et de tout ce qui coûte de l'argent ou parle au nom de votre entreprise.

7. Une fonction côté serveur ne fait pas confiance à ce que le front envoie#

Quand la logique passe dans une Edge Function ou une route d'API, l'erreur change de place. Les plus courantes :

  • Prendre le user_id dans le corps de la requête. Celui qui appelle l'API choisit ce qu'il envoie. L'utilisateur est celui que le token désigne (auth.getUser()), pas celui que le JSON annonce.
  • Utiliser la clé secrète pour tout dans la fonction. Le RLS ne s'applique alors plus là-dedans, et la fonction devient la porte de derrière. N'utilisez la clé secrète que dans la partie qui en a besoin.
  • Cacher le bouton d'admin et croire que c'est une permission. Un bouton caché, c'est de l'interface. La vérification doit se faire dans la base ou sur le serveur.

8. Storage : un bucket public est public#

Un fichier dans un bucket public est accessible à quiconque a l'URL, sans connexion. C'est bien pour un avatar ou une image de produit, pas pour un document, un justificatif ou la photo d'une pièce d'identité.

Pour un fichier privé, utilisez un bucket privé et des policies sur la table storage.objects. Le modèle où chaque utilisateur a son propre dossier :

create policy "Users read files in their own folder"
on storage.objects for select
to authenticated
using (
  bucket_id = 'documents'
  and (storage.foldername(name))[1] = (select auth.uid()::text)
);

Faites la même chose pour insert, update et delete, et pour afficher le fichier à l'écran, générez une URL signée, qui expire.

9. Les secrets hors du dépôt#

  • .env dans le .gitignore avant le premier commit.
  • Si une clé a déjà été commitée, supprimer le fichier ne règle rien : elle reste dans l'historique Git. Changez la clé.
  • Les dépôts publics sur GitHub sont fouillés en permanence par des robots à la recherche de clés.

10. Les limites d'usage#

L'inscription, la connexion, l'envoi d'e-mails et les appels à l'IA sont les cibles des abus. Vérifiez les limites de débit d'Auth dans le tableau de bord de Supabase, activez un captcha à l'inscription si l'app est ouverte au public et mettez une limite par utilisateur sur les fonctions qui coûtent de l'argent.

11. Recommencez après chaque modification#

C'est le point qui pèse le plus au quotidien. Vous demandez à l'IA d'« ajouter un champ téléphone au profil », elle recrée la table, et les policies peuvent ne pas suivre. La recommandation de l'étude elle-même va dans ce sens : revoir les permissions et la séparation entre les comptes avant d'y mettre des données réelles, et refaire la vérification après chaque modification.

Vous pouvez demander à l'IA d'écrire les policies, et elle les écrit généralement bien quand on le lui demande explicitement. Mais la vérification vous revient : la requête des tables sans RLS et le test avec curl prennent cinq minutes.

Et si ce n'est pas Supabase ?#

L'idée est la même dans toute architecture où le front parle directement à la base. Dans Firebase, le rôle du RLS revient aux Security Rules, et allow read, write: if true est exactement la même porte ouverte. Si l'app a son propre serveur au milieu (ce que Cursor génère souvent, selon la demande), la checklist change de place mais pas de sujet : authentification sur chaque route, ne jamais faire confiance à l'id qui vient du front, secrets uniquement sur le serveur.

Les outils automatiques aident et valent la peine d'être utilisés, mais ils ne remplacent pas une vraie revue quand l'app va stocker des données sensibles d'autres personnes, comme des documents, des données de santé ou de paiement.

Checklist#

  • La requête des tables sans RLS revient vide.
  • Chaque table avec des données d'utilisateurs a une policy par opération, avec with check sur l'insert et l'update.
  • Aucune policy using (true) sur des données privées.
  • Les privilèges (admin, abonnement, solde) hors des colonnes que l'utilisateur modifie, et hors du user_metadata.
  • Les views avec security_invoker = true.
  • La clé secrète et les clés d'IA, de paiement et d'e-mail uniquement sur le serveur, sans préfixe public.
  • Le grep sur le build ne trouve aucune clé.
  • Les fonctions vérifient l'utilisateur par le token et valident l'entrée.
  • Un bucket privé pour les fichiers privés, avec une policy par dossier et une URL signée.
  • .env hors de Git, et toute clé qui a fuité a été changée.
  • Une limite de débit sur Auth et sur les fonctions qui coûtent de l'argent.
  • Le test avec curl sans connexion et avec un utilisateur de test, refait après chaque modification.

Références#

  • Back-end
  • sécurité
  • supabase
  • ia
  • lovable
  • postgres
  • rls

Écrit par

Ingénieure logiciel et designer. J'écris sur ce que je rencontre en créant des apps, des APIs et des produits.