Cómo asegurar una app creada con herramientas de IA

Por qué las aplicaciones generadas por AI- fallan de manera diferente

Las aplicaciones codificadas por Vibe pueden ser seguras. Necesitan un pase de auditoría adicional porque los modos de falla son estructurales, no descuidados:

• Cursor inlines hardcoded keys. Le pide a Cursor que "arregle el error de autenticación" y pega un ejemplo de Supabase que asume un cliente con función de servicio. La clave termina en la parte superior de un componente de la página. Tanto el cliente anon como el cliente de servicio coexisten; ambos barcos.
• Claude Code defaults to permissive CORS. Los controladores Generated Express / Fastify se envían con cors({ origin: '*' }) porque es la forma más rápida de obtener una vista previa funcional. El middleware nunca recibe una segunda pasada.
• Lovable and v0 skip the rules file. Los proyectos respaldados por Firestore generan el modelo de datos pero rara vez tocan firestore.rules. Las reglas del modo de prueba expiran silenciosamente y bloquean la base de datos sin previo aviso al usuario.
• Bolt skips RLS migrations. Bolt genera un esquema Supabase y una superficie CRUD que utiliza la clave anon. ENABLE ROW LEVEL SECURITY nunca entra en la migración. Los usuarios anónimos pueden leer o escribir cualquier fila.
• Windsurf trusts unsigned IDs. Generado GET /api/items/[id] lee el parámetro y consulta Postgres sin verificar la propiedad. El patrón es lo suficientemente común como para que la sonda active.idor-walking activa lo muestre en un solo escaneo.

La auditoría inmediata: busque en su código base patrones de riesgo

Antes de endurecer algo, encuentra lo que ya está roto. Cada uno de estos greps tarda menos de un minuto:

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/

Endurecimiento en el momento de la implementación

Una vez que la fuente esté limpia, bloquee cómo la aplicación llega a producción.

// 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 curso: monitoreo y reescaneo

La deriva ocurre en cada despliegue. Trate la seguridad como un bucle, no como una lista de verificación que debe completar.

# 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"}'

Patrones de fallas reales y sus soluciones.

Cinco patrones de escaneos de producción en miles de aplicaciones generadas por AI-, cada una con la solución real:

1. Clave de función de servicio en un componente de cliente

   Symptom: baas.supabase-service-key encontrando en la producción URL. Cause: a Cursor autocompletar pegado createClient(URL, SERVICE_ROLE_KEY) en un componente de React. Fix: mueve el cliente de servicio a src/lib/supabase/service.ts con import 'server-only' en la parte superior; cree un src/lib/supabase/client.ts paralelo usando la clave anónima para uso del lado del cliente; gire la clave de función de servicio a través de Supabase Studio.

2. Reglas de Firestore dejadas en modo de prueba

   Symptom: baas.firebase-rules hallazgo de alta gravedad. Las reglas generadas por Cause: leen allow read, write: if request.time < timestamp.date(2026, 6, 1);: un "permitir todo" con un límite de tiempo. Fix: aplica cada regla al usuario autenticado (match /users/{userId}/posts/{postId} { allow read, write: if request.auth.uid == userId; }) y vuelve a implementar firebase deploy --only firestore:rules.

3. Permisivo CORS sobreviviendo en producción

   Symptom: active.cors de alta gravedad. Cause: middleware Express generado: app.use(cors({ origin: '*' })). Fix: incluye en la lista permitida el origen de tu interfaz: app.use(cors({ origin: ['https://your-app.com'], credentials: true })). Para rutas Next.js API, establezca Access-Control-Allow-Origin explícitamente en la respuesta.

4. RLS habilitado pero no forzado

   Symptom: activo baas.supabase-rls informa que la función anónima puede escribir en una tabla pública aunque RLS esté habilitado en el panel. Cause: ENABLE sin FORCE deja al propietario de la tabla exento y las migraciones se ejecutan como propietario. Fix: agrega alter table public.items force row level security; a la migración. Volver a implementar.

5. Identificaciones transitables IDOR- sin firmar

   Symptom: active.idor-walking informa que el usuario anónimo puede leer /api/items/1, /api/items/2, ... entre inquilinos. Cause: el controlador API confía en el parámetro de ruta y consulta Postgres sin un predicado de propiedad. Fix: agregue .eq('user_id', user.id) en cada consulta de lectura, o muévase a URL/UUID firmados con alcance en /api/users/[uid]/items/[id].

El bucle de seguridad del código de vibración

El objetivo no es la seguridad perfecta; está eliminando la fruta más fácil que las herramientas AI pasan por alto constantemente para que puedas seguir realizando envíos rápidos.

1. Generate fast — utilice Cursor, Claude Code, Lovable, Bolt. Ese es el punto.
2. Audit immediately: ejecute el grep configurado anteriormente, verifique RLS, verifique CSP, revise el límite de autenticación.
3. Harden at deploy: middleware, separación de entornos, CSP nonce, HSTS, verificación de autenticación solo del servidor.
4. Monitor — FixVibe pasivo diario, activo semanalmente en un dominio verificado, webhooks para Slack, detección de amenazas en 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.

Próximos pasos

Para conocer el contexto conceptual sobre DAST frente a SAST y por qué las aplicaciones generadas por AI- necesitan su propio escaneo, lea AI-generated code security scanning. Para obtener una referencia rápida sobre la auditoría previa al envío, consulte vibe coding security checklist.