← Tous les articlesSites et performance

Sécurité d'une app vibe-codée : la checklist avant la prod

Ne demande pas à l'IA si son code est sûr. Attaque ton app comme le ferait un inconnu, avec dix tests qui passent ou qui échouent.

Julien Mauclair · ~12 min · intermédiaire
StackNext.jsSupabaseStripenpm

Avant la prod, teste ton app depuis l'extérieur : un curl sans session, un second compte, une recherche de tes secrets dans le build. Cinq contrôles bloquent la mise en ligne : accès direct à la base, données d'un autre compte, actions serveur, secrets, webhooks. C'est aussi là que se trouve le premier risque du Top 10 OWASP.

01Pourquoi tester de l'extérieur plutôt que relire le code

Une app générée a souvent l'air correcte : le bouton est caché, la page redirige, la politique de sécurité existe. Rien de cela ne dit ce que répond le serveur à une requête écrite à la main. OWASP donne ce cas précis : un contrôle d'accès placé dans le front se contourne avec un simple curl en ligne de commande.

Deux relevés publics montrent l'ampleur du problème, avec leurs limites. Matt Palmer a trouvé 303 points d'accès mal protégés sur 170 projets Lovable, soit environ 10,3 % des 1 645 analysés, en regardant seulement les pages d'accueil. Il note aussi que le scanner ajouté ensuite vérifiait la présence d'une politique, pas sa justesse.

Escape a analysé plus de 5 600 apps publiques et rapporte plus de 2 000 vulnérabilités et plus de 400 secrets exposés. L'éditeur vend ce type de scan et reconnaît un échantillon très marqué par Lovable. Ces chiffres ne donnent donc pas un taux pour toutes les apps écrites avec l'IA, et aucun ne compare avec du code écrit à la main. Ils montrent seulement que ces erreurs se trouvent de l'extérieur, sans compte.

Le même constat revient côté exploitation. Dans un fil Reddit sur la dette opérationnelle du code généré, des participants défendent une revue centrée sur les fichiers d'infra. L'un d'eux raconte un diff impeccable, écrit sans IA dans son cas, dont le conteneur cassait à la première vraie requête : seule une étape qui exécute l'artefact l'aurait vu. C'est un témoignage, mais il résume bien la méthode : on exécute, on ne se contente pas de lire.

Les erreurs de base sont détaillées dans les failles de sécurité de base sur Next.js. Cette checklist ajoute la preuve : une commande et un résultat attendu pour chaque contrôle. Elle complète aussi les erreurs courantes avec Claude Code, qui portent sur la façon de travailler avec l'agent.

02La checklist en un coup d'œil

1. Accès direct à la baseBloquant. Avec la seule clé publique, aucune ligne privée ne revient.
2. Données d'un autre compteBloquant. Le compte A reçoit une erreur sur une ressource du compte B.
3. Actions et routes serveurBloquant. Chacune vérifie la session et la propriété de la ressource.
4. Secrets dans le build et l'historiqueBloquant. Aucune valeur secrète dans le bundle, le HTML ou git.
5. Webhooks de paiementBloquant. Une requête non signée est refusée et ne change rien.
6. DépendancesAvant d'ouvrir. Pas de faille haute connue, pas de paquet inventé.
7. Fichiers exposésAvant d'ouvrir. .env et .git répondent 404.
8. En-têtes de sécuritéAvant d'ouvrir. HSTS, nosniff et une protection contre l'iframe sont présents.
9. Limites de débitAvant d'ouvrir. La connexion finit par répondre 429.
10. Skills et serveurs MCPDès l'installation. Chaque ajout est lu avant d'être lancé.

Lance ces tests sur ton app ou sur sa préproduction, jamais sur le service d'un autre. Les commandes utilisent des noms d'exemple : remplace le domaine, la table et les identifiants. Elles ne prouvent qu'une chose chacune : elles ne remplacent pas un audit.

03Les cinq contrôles bloquants

1. Accès direct à la base

Si ton app parle à Supabase depuis le navigateur, la clé publique est visible par tout le monde, et c'est prévu ainsi : seule la Row Level Security décide de ce qu'elle atteint. Commence par lister les tables exposées sans RLS, puis relis les politiques existantes. Une règle ouverte à tous reste une règle.

audit-rls.sqlSQLCopier
-- Tables sans RLS : le résultat doit être vide
select tablename from pg_tables
where schemaname = 'public' and rowsecurity = false;
-- Politiques à relire, surtout celles dont qual vaut true
select tablename, policyname, roles, cmd, qual
from pg_policies where schemaname = 'public';

Passe ensuite le test qui compte, celui que décrit Palmer : appelle l'API sans session, avec la seule clé publique.

test-acces-base.shBASHCopier
curl -s "https://TON-PROJET.supabase.co/rest/v1/profiles?select=*&limit=1" \
-H "apikey: TA_CLE_PUBLIQUE"

Tu dois obtenir une liste vide ou une erreur de permission. Supabase distingue les deux : une politique qui ne retient aucune ligne renvoie un résultat vide, un droit manquant renvoie une erreur. Si une ligne privée revient, ne mets pas en ligne. Vérifie aussi tes vues : elles contournent la RLS par défaut tant que tu ne les configures pas pour la respecter. Enfin, teste une écriture en préproduction : Palmer a pu insérer une ligne marquée comme payée sans passer par Stripe.

2. Les données d'un autre compte

Être connecté ne donne pas le droit de tout lire. Crée deux comptes, note l'identifiant d'une ressource du compte B, puis demande-la avec le cookie du compte A. Le résultat attendu est 403 ou 404, et 401 sans cookie. Fais-le pour la lecture, la modification et la suppression : OWASP cite les API sans contrôle sur POST, PUT et DELETE parmi les cas courants.

test-autre-compte.shBASHCopier
# Sans session : 401 attendu
curl -s -o /dev/null -w "%{http_code}\n" https://ton-app.tld/api/invoices/ID_DU_COMPTE_B
# Avec le cookie du compte A : 403 ou 404 attendu
curl -s -o /dev/null -w "%{http_code}\n" -H "Cookie: session=COOKIE_DU_COMPTE_A" \
https://ton-app.tld/api/invoices/ID_DU_COMPTE_B

Le nom du cookie dépend de ta solution d'authentification : copie-le depuis les outils du navigateur. Le raisonnement complet est dans l'authentification dans une app Next.js.

3. Actions et routes serveur

Un bouton caché ne protège rien. Next.js le dit clairement : une Server Action exportée reste accessible par une requête POST directe, et la vérification faite par la page ne s'étend pas à l'action. Ce contrôle se fait à la lecture, mais avec une liste fermée : sors tous les points d'entrée, puis coche-les un par un.

points-entree.shBASHCopier
grep -rln "use server" app src
find app src -name "route.ts" -o -name "route.js"

Pour chaque fichier, trois questions : la session est-elle vérifiée dans la fonction, la propriété de la ressource aussi, et les entrées sont-elles validées ? Dès qu'un non apparaît, ajoute le test du contrôle 2 pour ce point d'entrée. Si ton projet n'utilise pas Next.js, la méthode est la même sur tes routes d'API.

4. Secrets dans le build, le HTML et l'historique

Tout ce qui porte le préfixe NEXT_PUBLIC_ est écrit dans le JavaScript envoyé au navigateur, comme le préfixe VITE_ avec Vite. Ne cherche pas seulement des motifs de clés : cherche tes vraies valeurs. Ces lignes extraient les valeurs non publiques de ton .env.local et listent les fichiers du build qui en contiennent une. La sortie doit être vide. Elles n'affichent que des noms de fichiers.

fuite-build.shBASHCopier
grep -v '^#' .env.local | grep -v '^NEXT_PUBLIC_' | cut -d= -f2- | tr -d '"' \
| awk 'length($0) >= 12' > /tmp/valeurs.txt
grep -rlFf /tmp/valeurs.txt .next/static
rm /tmp/valeurs.txt

Adapte le dossier à ton framework, par exemple dist avec Vite. Regarde ensuite le HTML rendu, car un composant serveur peut envoyer au client tous les champs d'un enregistrement : ouvre une page connectée, affiche sa source et cherche les champs qu'aucun utilisateur ne doit voir, comme un hash de mot de passe ou un identifiant de client Stripe.

Reste l'historique : un secret retiré du code reste dans git. Gitleaks le parcourt avec la commande gitleaks git -v. Son auteur annonce ne plus publier que des correctifs de sécurité et se consacrer à Betterleaks, à considérer pour un nouveau projet. Si une clé est trouvée, change-la : la retirer du dépôt ne suffit pas. La suite est dans gérer ses secrets proprement. Une clé secrète Supabase contourne toute la RLS : c'est la première à chercher.

5. Webhooks de paiement

Si ton webhook accorde un accès sans vérifier la signature, n'importe qui peut s'offrir un abonnement. Stripe le formule ainsi : sans vérification, un attaquant peut envoyer de faux événements pour déclencher une commande ou un accès. Envoie un faux événement en préproduction.

test-webhook.shBASHCopier
curl -s -o /dev/null -w "%{http_code}\n" -X POST https://ton-app.tld/api/webhooks/stripe \
-H "Content-Type: application/json" \
-d '{"id":"evt_test","type":"checkout.session.completed","data":{"object":{}}}'

Tu dois recevoir une erreur 4xx, et rien ne doit changer en base. Une réponse 200 veut dire que l'événement a été accepté sans preuve de son origine. Vérifie aussi que l'accès payant se lit côté serveur, jamais depuis un champ que le client peut écrire.

04Les contrôles à passer avant d'ouvrir largement

6. Dépendances, réelles et à jour

npm audit signale les failles connues, et l'option --audit-level=high ne fait échouer la commande qu'à partir de ce niveau, ce qui convient bien à une CI. Le risque propre au code généré est ailleurs : un nom de paquet inventé. Une étude présentée à USENIX Security mesure au moins 5,2 % de paquets hallucinés avec les modèles commerciaux et 21,7 % avec les modèles open source. Ces chiffres datent de 2024-2025 et varient selon les modèles. Un attaquant peut publier un paquet sous un de ces noms, d'où la vérification de ceux que tu ne connais pas.

dependances.shBASHCopier
npm audit --audit-level=high
npm audit signatures
# Pour chaque paquet inconnu : date de création et dépôt source
npm view nom-du-paquet time.created repository.url

Un paquet créé la semaine dernière et sans dépôt mérite d'être remplacé ou lu. OWASP classe désormais ces défaillances de la chaîne logicielle au troisième rang et recommande de retirer ce qui ne sert pas.

7. Fichiers exposés

OWASP demande que les métadonnées comme .git et les sauvegardes restent hors de la racine web. Ce test ne prend qu'une minute, et il compte surtout si tu as configuré le serveur toi-même ou avec l'agent.

fichiers-exposes.shBASHCopier
curl -s -o /dev/null -w "%{http_code}\n" https://ton-app.tld/.env
curl -s -o /dev/null -w "%{http_code}\n" https://ton-app.tld/.git/config

Le résultat attendu est 404. Si ton app renvoie 200 sur toutes les URL, regarde le contenu de la réponse avant de conclure.

8. En-têtes de sécurité

en-tetes.shBASHCopier
curl -sI https://ton-app.tld | grep -iE "strict-transport|content-security|x-content-type|x-frame|referrer-policy"

Compare la sortie aux recommandations d'OWASP sur les en-têtes : nosniff, une politique de referrer, HSTS et frame-ancestors ou X-Frame-Options. Deux précautions : une erreur sur HSTS peut rendre le site inaccessible jusqu'à l'expiration de sa durée, et une Content Security Policy demande du temps à régler. Ce contrôle réduit l'impact d'une faille, il ne compense pas un échec aux contrôles 1 à 5.

9. Limites de débit

Sans limite, un script peut tester des mots de passe ou faire exploser ta facture d'envoi d'e-mails ou d'IA. OWASP et Next.js recommandent tous deux de limiter le débit, Next.js visant surtout les opérations coûteuses. Lance ce test en préproduction, avec un compte de test.

test-debit.shBASHCopier
for i in $(seq 1 30); do
curl -s -o /dev/null -w "%{http_code} " -X POST https://ton-app.tld/api/login \
-H "Content-Type: application/json" -d '{"email":"test@exemple.fr","password":"faux"}'
done

Tu dois voir apparaître des 429 avant la fin de la série. Le seuil dépend de ton usage, et la mise en place est décrite dans rate limiting et protection d'API.

10. Skills et serveurs MCP de ton agent

Ce contrôle protège ta machine plutôt que ton app, et c'est là que se trouvent tes clés. OpenSourceMalware a recensé 386 skills malveillants sur le registre ClawHub, souvent présentés comme des outils de trading. D'après l'analyse du binaire, le logiciel installé cible probablement les clés d'API et les fichiers .env. L'affaire a nourri un long fil Reddit où revient la même consigne : relire ce que ton agent installe. Le rapport cite comme signaux une commande encodée en base64, une adresse IP brute, un zip protégé par mot de passe ou un outil présenté comme obligatoire.

audit-skills.shBASHCopier
grep -rnE "base64|curl .*[|] *(ba)?sh|[0-9]{1,3}([.][0-9]{1,3}){3}" .claude/skills

Adapte le dossier à ton agent. Une sortie vide ne prouve rien, car une instruction peut être tournée autrement : lis le fichier en entier avant d'installer.

05Faire tourner la liste à chaque mise en ligne

Une checklist passée une fois vieillit dès la prochaine génération de code. Mets en CI ce qui s'automatise : npm audit, gitleaks, la recherche de secrets dans le build et le test d'accès à la base contre la préproduction. Écris aussi les tests du contrôle 2 comme de vrais tests d'intégration, comme OWASP le demande pour le contrôle d'accès. Supabase propose de son côté des tests de politiques exécutés avec supabase test db.

La revue humaine se concentre alors sur ce qui ne s'automatise pas : les nouveaux points d'entrée, les migrations et les fichiers d'infra. Si tu es seul, fais tourner ces mêmes tests avant chaque mise en ligne et arrête-toi au premier échec. Pour le reste du pipeline, vois rendre un déploiement ennuyeux.

Attention

Réussir ces dix tests ne prouve pas que l'app est sûre. Cela écarte des erreurs fréquentes et faciles à trouver. Si tu traites des données de santé, des données financières ou des données réglementées, fais auditer l'app par un professionnel avant l'ouverture.

06Questions fréquentes

Une app vibe-codée est-elle forcément moins sûre ?

Les relevés cités ne permettent pas de le dire : ils portent sur des apps publiques, sans groupe de comparaison écrit à la main. Le risque concret vient de ce qui n'a pas été vérifié, surtout quand personne dans l'équipe ne sait ce qu'il faudrait vérifier. Ces tests marchent quel que soit l'auteur du code.

Ma clé Supabase est visible dans le navigateur : est-ce une faille ?

Pas si c'est la clé publique, car Supabase indique qu'elle est faite pour être exposée, et que la RLS fait la protection. La faille commence quand une table répond sans politique correcte, ou quand la clé secrète se retrouve côté client. Dans ce second cas, change la clé après avoir corrigé la cause.

Puis-je demander à l'IA de faire ce contrôle ?

Oui pour lister les points d'entrée, écrire les tests et repérer des oublis. Non pour conclure à sa place : l'exemple du scanner cité par Palmer montre qu'une politique peut exister sans protéger quoi que ce soit. Fais écrire le test, lance-le toi-même et regarde la réponse réelle du serveur.

Faut-il un test d'intrusion avant de lancer ?

Pas forcément pour une première version sans données sensibles, si ces contrôles passent. Dès que l'app traite des paiements en propre, des données de santé ou les données de tes clients, prévois-le : Next.js recommande lui-même des tests d'intrusion ou des scans réguliers pour les parties les plus exposées. Fais d'abord cette liste, pour que l'auditeur passe son temps sur ce qu'elle ne peut pas trouver.

07Sources

Sources & ressources
01OWASP Top 10:2025, A01 Broken Access Controlrang du risque, exemples de contournement, mesures de prévention.↗02OWASP Top 10:2025, A03 Software Supply Chain Failuresrisques liés aux dépendances.↗03Matt Palmer, déclaration sur la CVE-2025-48757méthode, chiffres et chronologie du relevé sur Lovable.↗04Escape, méthodologie de l'étudechiffres et biais déclarés.↗05Supabase, Row Level Securitypolitiques, droits, vues, tests.↗06Supabase, clés d'APIclé publique et clé secrète, erreurs attendues.↗07PostgreSQL, pg_tablescolonne rowsecurity.↗08PostgreSQL, pg_policiescolonnes des politiques.↗09Next.js, sécurité des donnéesServer Actions, données envoyées au client, audit.↗10Next.js, variables d'environnementpréfixe NEXT_PUBLIC_.↗11Vite, variables d'environnementpréfixe VITE_.↗12Stripe, gestion des webhooksvérification de la signature.↗13npm auditoptions et codes de sortie.↗14npm viewmétadonnées d'un paquet.↗15Gitleaksrecherche de secrets dans git, état du projet.↗16Spracklen et al., paquets hallucinésmesure sur 16 modèles.↗17OWASP, en-têtes HTTPvaleurs recommandées et précautions.↗18OpenSourceMalware, skills malveillants sur ClawHubcampagne et signaux d'alerte.↗19Fil Reddit sur la dette du code générétémoignages, pas des faits établis.↗20Fil Reddit sur les skills malveillantsréactions, pas des faits établis.↗
En résumé

Passe les cinq contrôles bloquants avant la première vraie donnée, et remets ce qui s'automatise dans ta CI. Si un test échoue et que tu ne vois pas d'où ça vient, c'est le bon moment pour faire relire l'app.

Parlons de ton projet ↗
Julien MauclairJulien Mauclair est cofondateur et CTO de Klickbee : il construit les sites, le tracking et les automatisations IA de l’agence, et développe Klickbee Tracking. Il dirige aussi Stralya, qui conçoit et tient l’infrastructure AWS de scale-ups. Avant, il a construit toute l’infrastructure AWS d’un e-commerce, revendu depuis.

À lire ensuite