Ressource gratuite9 min de lecture

La checklist sécurité avant de mettre ton app en ligne

Les 3 réglages qui évitent de retrouver tes clés API en clair dans GitHub, avec les commandes et le prompt d'audit à coller dans Claude Code.

Avant de commencer

Cette checklist ne transforme pas ton app en coffre-fort. Elle couvre les trois trucs qui sautent en premier sur une app vibe-codée : les secrets poussés dans le repo, les tables ouvertes, les endpoints publics que n'importe qui peut appeler en boucle.

Si tu stockes des données de santé ou des données de paiement en direct, ça ne remplace pas un vrai audit. Pour tout le reste, c'est le minimum avant de mettre une URL dans la nature.

Compte 45 minutes pour les trois points.


01 — Isole tes secrets

Le .gitignore

Première chose, tu regardes ce que git suit déjà :

git ls-files | grep -iE "\.env|secret|credential|\.pem"

Si cette commande renvoie quelque chose, tes clés sont dans ton repo.

Tu ajoutes ça à ton .gitignore :

.env
.env.local
.env.*.local
.env.production
*.pem
*.key
secrets/
service-account*.json
.claude/settings.local.json

Puis tu sors le fichier du suivi sans le supprimer de ton disque :

git rm --cached .env
git commit -m "stop tracking env files"

Si une clé est déjà partie

C'est le point que tout le monde rate. Supprimer le fichier ne supprime rien : la clé reste dans l'historique des commits, et elle reste lisible par n'importe qui qui clone le repo.

La seule action qui compte, c'est de révoquer et régénérer la clé. Dans l'ordre :

  1. Tu régénères la clé côté fournisseur (Supabase, Stripe, Anthropic, OpenAI, ce que tu utilises).
  2. Tu remplaces la nouvelle valeur dans tes variables d'environnement.
  3. Tu nettoies l'historique si tu veux faire les choses proprement (git filter-repo), mais ça vient après, pas avant.

Tant que tu n'as pas régénéré, la clé est compromise, même repo passé en privé.

Le piège des variables côté client

Sur Vercel, tout ce qui commence par NEXT_PUBLIC_ est envoyé au navigateur. C'est visible dans le bundle, il suffit d'ouvrir les devtools.

Donc :

  • Côté front, uniquement la clé anonyme de Supabase.
  • La service_role ne sort jamais du serveur. Elle bypasse le RLS, c'est une clé admin.
  • Tes clés d'API LLM, Stripe, mail : serveur uniquement, jamais dans un composant client.

Tu vérifies en une commande :

grep -rn "NEXT_PUBLIC_" .env* 

Si tu vois une clé secrète là-dedans, tu la renommes et tu déplaces l'appel côté serveur.


02 — Active le RLS sur toutes tes tables

Sans RLS, la clé anonyme de ton front peut lire toute ta base. Pas « ses lignes à lui » : toute la table.

Tu listes d'abord les tables non protégées :

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

Puis tu actives, table par table :

alter table public.ma_table enable row level security;

Le détail que personne ne fait

Activer le RLS sans écrire de policy, c'est tout bloquer. Ton app plante, tu paniques, tu désactives, et tu repars en prod avec une base ouverte. C'est exactement comme ça que ça finit en clair.

Donc tu actives et tu écris la policy dans la foulée :

create policy "un user lit ses lignes"
on public.projets
for select
using (auth.uid() = user_id);

create policy "un user ecrit ses lignes"
on public.projets
for insert
with check (auth.uid() = user_id);

Et surtout, tu testes avec un vrai token utilisateur, pas depuis l'éditeur SQL de Supabase. L'éditeur tourne en admin, il passe à travers tout : tu verras toujours que « ça marche ».

Le test qui vaut quelque chose : tu te connectes avec le compte A, et tu essaies de lire une ligne du compte B. Si tu la vois, ta policy ne sert à rien.

Pense aussi aux vues et aux fonctions : une vue construite sur une table protégée peut rouvrir la porte si elle est en security definer.


03 — Protège ton app

Un secret par webhook

Un webhook, c'est une URL publique. Si tu n'as rien dessus, n'importe qui qui la devine peut déclencher ton traitement autant de fois qu'il veut.

Un secret différent par webhook, jamais dans l'URL, toujours dans un header, et tu rejettes avant de traiter quoi que ce soit :

import crypto from "crypto";

const received = req.headers["x-webhook-secret"] ?? "";
const expected = process.env.WEBHOOK_SECRET ?? "";

const ok =
  received.length === expected.length &&
  crypto.timingSafeEqual(Buffer.from(received), Buffer.from(expected));

if (!ok) {
  return res.status(401).json({ error: "unauthorized" });
}

Pour Stripe, tu n'inventes rien : tu utilises leur vérification de signature native avec le signing secret de l'endpoint.

Des rate limits sur tes appels API

C'est le point qui se paie en euros. Une route publique qui appelle un modèle ou qui envoie un mail, sans limite, c'est une facture ouverte.

Trois réglages, par ordre d'efficacité :

  1. Un compteur par IP et par utilisateur sur chaque route qui coûte de l'argent (LLM, mail, génération de fichier).
  2. Une taille maximale de payload, pour qu'on ne t'envoie pas 2 Mo de texte à faire traiter par un modèle.
  3. Un timeout sur tes appels sortants, pour ne pas garder des fonctions ouvertes qui tournent dans le vide.

Et une alerte de budget côté fournisseur. Ce n'est pas de la sécurité, c'est de la survie : tu veux apprendre que quelque chose dérape par un mail, pas par ton relevé.


Le prompt d'audit à coller dans Claude Code

Ouvre ton projet dans Claude Code et colle ça tel quel. Il te sort un rapport avant de toucher à quoi que ce soit.

Tu fais un audit de sécurité de ce projet avant une mise en production.
Tu ne modifies aucun fichier à cette étape : tu produis un rapport.

Vérifie, dans cet ordre :

1. SECRETS
- Liste tous les fichiers suivis par git qui contiennent des secrets
  (clés API, tokens, mots de passe, URLs de connexion à une base).
- Liste toutes les clés en dur dans le code, hors variables d'environnement.
- Liste toutes les variables préfixées NEXT_PUBLIC_ (ou équivalent côté client)
  et dis-moi lesquelles ne devraient pas être exposées au navigateur.
- Indique si la clé service_role Supabase est utilisée quelque part
  dans du code qui s'exécute côté client.

2. BASE DE DONNÉES
- Liste les requêtes qui utilisent une clé admin là où une clé utilisateur suffirait.
- Liste les tables manipulées par le code et dis-moi, pour chacune,
  si une policy d'accès est présente dans les migrations du projet.

3. ENDPOINTS
- Liste toutes les routes API et webhooks exposés.
- Pour chacune : y a-t-il une vérification d'authentification ou de signature
  avant le traitement ? Oui / non.
- Pour chacune : y a-t-il une limite de débit et une limite de taille de payload ?
- Signale les routes qui déclenchent un appel payant (modèle, mail, SMS)
  sans aucune protection.

Rends un tableau : fichier, ligne, problème, gravité (bloquant / à corriger / confort),
et la correction exacte à appliquer.
Commence par les bloquants.

Ensuite tu corriges point par point, en lui demandant un fichier à la fois. Tu ne le laisses pas tout réécrire d'un coup : tu ne saurais plus ce qui a changé.


La checklist avant chaque mise en ligne

Secrets

  • git ls-files | grep -iE "\.env|secret|credential|\.pem" ne renvoie rien
  • .env, .env.local, *.pem, secrets/ sont dans le .gitignore
  • Toute clé déjà poussée a été régénérée côté fournisseur
  • Aucune clé secrète derrière un préfixe exposé au navigateur
  • La clé service_role n'existe que côté serveur

Base

  • La requête de listing des tables sans RLS renvoie zéro ligne
  • Chaque table activée a au moins une policy de lecture et une d'écriture
  • Test fait avec deux comptes : le compte A ne voit pas les données du compte B

Endpoints

  • Un secret distinct par webhook, passé en header, jamais dans l'URL
  • Rejet avant traitement si la signature est absente ou fausse
  • Rate limit par IP et par utilisateur sur les routes qui coûtent de l'argent
  • Taille de payload maximale définie
  • Alerte de budget active chez chaque fournisseur payant

Le jour où tu ajoutes une table ou une route, tu repasses sur les trois lignes qui la concernent. C'est cinq minutes, et c'est ce qui évite de découvrir le problème par un inconnu.

Vous préférez qu'on le fasse pour vous ?

On le met en place dans votre boîte

30 minutes de call. On regarde vos outils et vos process, et on vous dit ce qu'on peut livrer en 7 jours.

Réserver un appel

Prêt à passer à l'action ?

30 minutes de call. On regarde votre stack, vos pain points, on vous dit ce qu'on peut livrer en 7 jours.

Avant

Treize outils. Aucun ne se parle.