Comment sécuriser une app construite avec des outils de codage IA

Pourquoi AI-les applications générées échouent différemment

Les applications codées par Vibe peuvent être sécurisées. Ils ont besoin d’un audit supplémentaire car les modes de défaillance sont structurels et non imprudents :

• Cursor inlines hardcoded keys. Vous demandez à Cursor de « corriger l'erreur d'authentification » et il colle un exemple Supabase qui suppose un client de rôle de service. La clé se retrouve en haut d'un composant de page. Le client anonyme et le client de service coexistent ; les deux navires.
• Claude Code defaults to permissive CORS. Les gestionnaires Express / Fastify générés sont livrés avec cors({ origin: '*' }) car c'est le moyen le plus rapide d'obtenir un aperçu fonctionnel. Le middleware ne reçoit jamais de deuxième passage.
• Lovable and v0 skip the rules file. Les projets soutenus par Firestore génèrent le modèle de données mais touchent rarement firestore.rules. Les règles du mode test expirent silencieusement et verrouillent la base de données sans avertissement pour l'utilisateur.
• Bolt skips RLS migrations. Bolt génère un schéma Supabase et une surface CRUD qui utilise la clé anon. ENABLE ROW LEVEL SECURITY n'entre jamais dans la migration. Les utilisateurs anonymes peuvent lire ou écrire n'importe quelle ligne.
• Windsurf trusts unsigned IDs. Généré GET /api/items/[id] lit le paramètre et interroge Postgres sans vérifier la propriété. Le motif est suffisamment courant pour que la sonde active active.idor-walking le fasse surface en un seul balayage.

L'audit immédiat : recherchez votre base de code pour les modèles de risque

Avant de durcir quoi que ce soit, trouvez ce qui est déjà cassé. Ces greps prennent chacun moins d'une minute :

grep -RIn 'NEXT_PUBLIC_SUPABASE_SERVICE' src/
grep -RIn 'sk_live_\|pk_live_\|STRIPE_SECRET' src/
grep -RIn 'sk-ant-\|^sk-' src/  # Anthropic / OpenAI
grep -RIn 'AIza\|AKIA' src/        # Google / AWS
grep -RIn 'eyJh[A-Za-z0-9_-]\{20,\}' src/  # JWT-shaped strings

# Supabase migrations
grep -RIn 'CREATE TABLE public\.' supabase/migrations/
grep -RIn 'ENABLE ROW LEVEL SECURITY\|FORCE ROW LEVEL SECURITY' supabase/migrations/

# Firebase / Firestore
cat firestore.rules  # confirm no `if true;` matches

grep -RIn 'getSession()' src/   # should be getUser() server-side
grep -RIn 'localStorage\.\(set\|get\)Item.*token' src/
grep -RIn 'jwt.verify.*\(noVerify\|skipVerify\)' src/

# Confirm middleware location for src/ layouts
ls src/middleware.ts middleware.ts 2>&1

# Look for CSP and security headers
grep -RIn 'Content-Security-Policy\|Strict-Transport-Security' src/

Durcissement au moment du déploiement

Une fois la source propre, verrouillez la manière dont l’application atteint la production.

// src/middleware.ts
import { NextResponse, type NextRequest } from 'next/server';

export function middleware(request: NextRequest) {
  const nonce = crypto.randomUUID().replace(/-/g, '');
  const csp = [
    `script-src 'nonce-${nonce}' 'strict-dynamic'`,
    `style-src 'self' 'unsafe-inline'`,
    `img-src 'self' data: https:`,
    `connect-src 'self' https://*.supabase.co`,
    `object-src 'none'`,
    `base-uri 'self'`,
    `frame-ancestors 'none'`,
  ].join('; ');

  const requestHeaders = new Headers(request.headers);
  requestHeaders.set('x-nonce', nonce);

  const response = NextResponse.next({ request: { headers: requestHeaders } });
  response.headers.set('Content-Security-Policy', csp);
  response.headers.set('X-Content-Type-Options', 'nosniff');
  response.headers.set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  return response;
}

export const config = {
  matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
};

-- supabase/migrations/XXXX_rls.sql
alter table public.profiles enable row level security;
alter table public.profiles force row level security;

create policy "profiles: read own"
  on public.profiles for select
  using (auth.uid() = id);

create policy "profiles: update own"
  on public.profiles for update
  using (auth.uid() = id)
  with check (auth.uid() = id);

// src/app/api/items/route.ts
import { NextResponse, type NextRequest } from 'next/server';
import { createClient } from '@/lib/supabase/server';

export async function POST(request: NextRequest) {
  const supabase = await createClient();
  const { data: { user } } = await supabase.auth.getUser();
  if (!user) return NextResponse.json({ error: 'unauthorized' }, { status: 401 });

  const body = await request.json();
  const { data, error } = await supabase
    .from('items')
    .insert({ ...body, user_id: user.id })  // server-supplied, not from body
    .select()
    .single();

  if (error) return NextResponse.json({ error: error.message }, { status: 400 });
  return NextResponse.json(data);
}

// src/app/api/posthog/[...path]/route.ts
import { type NextRequest } from 'next/server';

const UPSTREAM = 'https://us.i.posthog.com';

export async function POST(req: NextRequest, { params }: { params: Promise<{ path: string[] }> }) {
  const { path } = await params;
  const url = `${UPSTREAM}/${path.join('/')}`;
  return fetch(url, {
    method: 'POST',
    headers: { 'content-type': req.headers.get('content-type') ?? 'application/json' },
    body: await req.text(),
  });
}

function safeNext(raw: string | null): string {
  if (!raw) return '/dashboard';
  if (!raw.startsWith('/') || raw.startsWith('//')) return '/dashboard';
  return raw;
}

En cours : surveillance et nouvelle analyse

La dérive se produit à chaque déploiement. Traitez la sécurité comme une boucle et non comme une liste de contrôle à terminer.

# Or from CI, via the REST API:
curl -X POST https://fixvibe.app/api/v1/scans \
  -H "authorization: Bearer $FIXVIBE_TOKEN" \
  -H "content-type: application/json" \
  -d '{"target":"https://your-app.com"}'

Modèles de défaillance réels et leurs correctifs

Cinq modèles issus d'analyses de production sur des milliers d'applications générées AI-, chacun avec le correctif réel :

1. Clé de rôle de service dans un composant client

   Symptom: baas.supabase-service-key constatation sur la production URL. Cause: une saisie semi-automatique Cursor collée createClient(URL, SERVICE_ROLE_KEY) dans un composant React. Fix: déplacez le client de service vers src/lib/supabase/service.ts avec import 'server-only' en haut ; créez un src/lib/supabase/client.ts parallèle en utilisant la clé anon pour une utilisation côté client ; faites pivoter la clé de rôle de service via Supabase Studio.

2. Règles Firestore laissées en mode test

   Symptom: baas.firebase-rules constatation de gravité élevée. Cause: les règles générées sont lues allow read, write: if request.time < timestamp.date(2026, 6, 1); — un « tout autoriser » limité dans le temps. Fix: étend chaque règle à l'utilisateur authentifié — match /users/{userId}/posts/{postId} { allow read, write: if request.auth.uid == userId; } — et redéployez firebase deploy --only firestore:rules.

3. Permissif CORS survivant en production

   Symptom: active.cors haute gravité. Cause: Middleware Express généré : app.use(cors({ origin: '*' })). Fix: ajoutez votre origine frontend à la liste blanche : app.use(cors({ origin: ['https://your-app.com'], credentials: true })). Pour les routes Next.js API, définissez Access-Control-Allow-Origin explicitement dans la réponse.

4. RLS activé mais pas forcé

   Symptom: actif baas.supabase-rls signale que le rôle anon peut écrire dans une table publique même si RLS est activé dans le tableau de bord. Cause: ENABLE sans FORCE laisse le propriétaire de la table exempté — et les migrations s'exécutent en tant que propriétaire. Fix: ajoutez alter table public.items force row level security; à la migration. Redéployer.

5. IDOR-ID accessibles à pied non signés

   Symptom: active.idor-walking rapporte que l'utilisateur anonyme peut lire /api/items/1, /api/items/2, ... entre les locataires. Cause: le gestionnaire API fait confiance au paramètre de chemin et interroge Postgres sans prédicat de propriété. Fix: ajoutez .eq('user_id', user.id) à chaque requête de lecture, ou passez aux URL/UUID signés limités à /api/users/[uid]/items/[id].

La boucle de sécurité du vibe-code

L'objectif n'est pas une sécurité parfaite ; cela élimine les fruits à portée de main AI que les outils manquent constamment afin que vous puissiez continuer à expédier rapidement.

1. Generate fast — utilisez Cursor, Claude Code, Lovable, Bolt. C'est le point.
2. Audit immediately — exécutez l'ensemble grep ci-dessus, vérifiez RLS, vérifiez CSP, vérifiez la limite d'authentification.
3. Harden at deploy — middleware, séparation de l'environnement, CSP nonce, HSTS, vérification d'authentification sur le serveur uniquement.
4. Monitor — FixVibe passif quotidiennement, actif chaque semaine sur un domaine vérifié, webhooks vers Slack, détection des menaces sur Unlimited.
5. Fix fast — use FixVibe coding-agent prompts for code/config findings and operator steps for DNS, provider, secret-rotation, or manual-review findings. Re-deploy, re-scan, close the loop.

Prochaines étapes

Pour obtenir le contexte conceptuel sur DAST vs SAST et pourquoi AI-les applications générées ont besoin de leur propre analyse, lisez AI-generated code security scanning. Pour un audit de référence rapide avant expédition, consultez le vibe coding security checklist.