Todos los artículos

Back-end14 min de lectura

App hecha con IA: qué revisar antes de publicarla

Checklist de seguridad para apps de Lovable, Bolt o Cursor: RLS en Supabase, clave secreta fuera del front, clave de IA en el servidor, storage y un test de 5 minutos.

También en Português, English, Français

Herramientas como Lovable, Bolt y Cursor ponen una app en línea en una tarde: pantalla de login, registro, base de datos, todo funcionando. Y ahí está la trampa. Funcionar no es lo mismo que estar protegida. Una app puede iniciar sesión, guardar y listar sin problema y, al mismo tiempo, entregar los datos de todos los usuarios a cualquiera que sepa pedirlos.

Esto no es una hipótesis. A principios de noviembre de 2026, una investigación publicada junto con el diario alemán Handelsblatt analizó más de 150 mil proyectos hechos en Lovable y encontró miles de sitios que devolvían datos de usuarios sin ningún login. Este post explica por qué pasa eso y trae el checklist que yo correría antes de publicar cualquier app generada por IA.

Un aviso honesto: no probé la app de nadie. Los números vienen de las fuentes enlazadas al final, y los ejemplos de SQL y de código siguen la documentación de Supabase. Las imágenes son ilustraciones que dibujé para explicar cada parte.

TL;DR#

  • El problema casi nunca es que la IA escriba código "hackeable". Es que la app sale al aire sin las reglas de acceso de la base de datos, porque nada en la pantalla muestra que faltan.
  • En Supabase, la clave que va al navegador es pública por naturaleza. Quien protege los datos es el Row Level Security (RLS): reglas en Postgres que dicen quién puede leer y escribir cada fila.
  • RLS en toda tabla expuesta, con una policy de verdad (nada de using (true) en datos privados).
  • La clave secreta (la antigua service_role) y las claves de IA o de pagos nunca van al front. Una variable con el prefijo VITE_, NEXT_PUBLIC_ o EXPO_PUBLIC_ termina en el bundle, y el bundle es público.
  • Haz el test de 5 minutos: toma la URL y la clave que tu propio sitio ya envía y consulta una tabla con curl, sin login. Si vuelven datos de otras personas, no publiques.
  • Repítelo después de cada cambio. La IA toca una tabla y la regla se puede ir con ella.

Qué pasó#

La investigación es de Crissy Field, una empresa alemana de seguridad, hecha en conjunto con el Handelsblatt. Usaron Common Crawl (un archivo público de la web) para encontrar sitios hechos en Lovable publicados entre diciembre de 2025 y septiembre de 2026:

  • 159.041 proyectos analizados, de los cuales 34.545 usaban Supabase como base de datos.
  • 24.664 sitios devolvían registros de la base ya al cargar la página, sin login. Eso solo no es una falla: un blog muestra sus posts a todo el mundo a propósito.
  • Haciendo solo lecturas con la misma clave pública que el sitio ya usa, encontraron correos electrónicos en 10.560 tablas de 7.403 sitios. Tampoco es una tasa confirmada de filtración, pero es una señal fuerte.
  • Entre los ejemplos: un foro alemán con más de 80 mil perfiles y más de 200 mil mensajes de chat, más de mil registros con número de pasaporte, datos de entradas y de restaurantes con información de pago.

La causa que señalan son errores de control de acceso. Y no es la primera vez: en 2025, un problema parecido se convirtió en el CVE-2025-48757, con nota 9,3 (crítica), descrito como policies de Row Level Security insuficientes en sitios generados por Lovable, que permitían leer y escribir tablas sin autenticación. Lovable disputa el registro, con el argumento de que proteger los datos es responsabilidad de cada cliente.

Las dos lecturas tienen algo de verdad, y por eso existe este post: la herramienta genera, pero quien publica responde por lo que publicó.

Por qué pasa: el front habla directo con la base de datos#

En una app tradicional, el navegador habla con tu servidor, y el servidor decide qué devolver. En el modelo que Lovable y Bolt suelen generar con Supabase, no hay servidor en el medio: el navegador habla directo con la API de la base de datos, usando una clave que va incrustada en el JavaScript del sitio.

Esa clave es la publishable key (sb_publishable_..., la antigua anon). Es pública a propósito: cualquiera que abra las DevTools la ve. La documentación de Supabase usa una buena imagen: la clave pública es la que está pegada en la puerta de entrada y solo abre el vestíbulo. Lo que separa el vestíbulo de los apartamentos es el RLS.

La clave pública es igual para todo el mundo. Lo que decide qué ve cada uno es la policy de RLS de cada tabla

Sin RLS, una tabla en el schema expuesto (public, por defecto) puede ser leída y escrita por cualquier rol que tenga permiso sobre ella, y Supabase da permisos amplios por defecto a los roles anon (visitante) y authenticated (con sesión iniciada). O sea: tabla sin RLS es tabla abierta.

Y fíjate que la app funciona igual en los dos casos. La pantalla de "mis pedidos" filtra por usuario en el JavaScript, así que parece correcta. Pero el filtro está en el front, y quien llama a la API directo se salta el front.

El test de 5 minutos#

Antes del checklist, un test que cualquier persona puede hacer en su propia app:

  1. Abre tu sitio, abre las DevTools y ve a la pestaña Network.
  2. Busca una petición a https://<tu-proyecto>.supabase.co/rest/v1/.... En sus headers están la URL del proyecto y la clave pública (apikey).
  3. Sin haber iniciado sesión, consulta una tabla que guarde datos de usuarios:
# 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"
La misma consulta, sin login. Una lista vacía es lo que quieres ver

Si vuelve [] (o un error de permiso), perfecto. Si vuelven perfiles, correos o pedidos de otras personas, la app no está lista. Haz lo mismo con la sesión iniciada como un usuario de prueba y revisa que aparezca solo lo que es suyo.

Importante: haz esto solo en tu app. Consultar la base de datos de un sitio que no es tuyo, aunque sea con la clave que expone, puede ser delito según el país.

El checklist#

1. RLS activado en toda tabla expuesta#

En el SQL Editor de Supabase, esta consulta lista las tablas del schema public que no tienen RLS:

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

Toda tabla que aparezca aquí está abierta. Activar el RLS es una línea:

alter table public.notes enable row level security;

Con el RLS activado y ninguna policy, nada es accesible por la API con la clave pública. Ese es el comportamiento seguro: cerrar todo y después abrir solo lo necesario. El panel de Supabase también tiene los Advisors, que avisan de tablas sin RLS y otros descuidos. Vale la pena abrirlos antes de publicar.

2. Una policy de verdad, una por operación#

Activar el RLS cierra la puerta. La policy dice quién entra. El patrón para datos que pertenecen a una persona:

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);

Dos detalles que la IA suele equivocar:

  • using (true) libera todo. Tiene sentido en una tabla de posts públicos, no en una de pedidos. Si la IA "resolvió" un error de permiso escribiendo using (true), apagó la seguridad de esa tabla.
  • with check en el insert y en el update. El using dice qué filas puede ver o tocar la persona. El with check dice cómo puede quedar la fila después. Sin él, alguien puede crear una nota con el user_id de otra persona.

3. Los permisos no viven en una columna que el usuario edita#

El RLS trabaja por fila, no por columna. Si la policy deja que la persona actualice su propio perfil, puede actualizar cualquier columna de ese perfil. Entonces, si el perfil tiene is_admin o plan, un simple update por la API convierte a cualquier usuario en admin o en suscriptor premium.

La salida es guardar los privilegios en una tabla aparte, que el usuario solo puede leer:

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.

Lo mismo vale para el user_metadata de Supabase Auth: el propio usuario puede cambiar ese campo. Una policy que confía en un role guardado ahí es una policy que controla el usuario.

4. Las views se saltan el RLS#

Una view creada de la forma por defecto corre con los permisos de quien la creó, y por eso ignora el RLS de las tablas de abajo. A la IA le encanta crear views para "juntar los datos del dashboard". En Postgres 15 o más nuevo, la corrección es:

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

Con security_invoker, la view respeta las policies de quien está consultando.

5. La clave secreta se queda en el servidor#

La clave secreta (sb_secret_..., la antigua service_role) ignora el RLS por completo. Existe para correr en tu servidor, en una Edge Function, en un job programado. En el navegador o dentro de una app móvil, entrega la base de datos entera a quien abra el bundle.

Dos formas en que se filtra sin que nadie lo note:

  • Prefijo público. Toda variable con VITE_, NEXT_PUBLIC_ o EXPO_PUBLIC_ se copia al código que llega al usuario. Una clave secreta con ese prefijo es una clave publicada.
  • "Arreglo" de un error. Sale un error de permiso, la IA cambia la clave pública por la secreta y todo funciona. Funciona porque apagó la seguridad.

Después del build, busca en lo que se va a publicar:

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

Si aparece cualquier cosa, la clave se publicó. Sácala del front y cambia la clave en el panel, porque la antigua ya puede estar en algún caché.

6. Claves de IA, de pagos y de correo también#

Una app hecha con IA suele usar IA, y la clave de la API de IA es la que más aparece en el front. El SDK de OpenAI, por ejemplo, solo acepta correr en el navegador con una opción llamada dangerouslyAllowBrowser. El nombre ya avisa:

// 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,
})

Con la clave en el front, cualquiera usa tu cuota, y la factura te llega a ti. Su lugar es una función en el servidor, que revisa quién está llamando y valida la entrada antes de pasarla:

// 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 misma regla vale para la clave de la pasarela de pagos, del servicio de correo y de cualquier cosa que cueste dinero o hable en nombre de tu empresa.

7. Una función en el servidor no confía en lo que manda el front#

Cuando la lógica pasa a una Edge Function o a una ruta de API, el error cambia de lugar. Los más comunes:

  • Tomar el user_id del cuerpo de la petición. Quien llama a la API elige qué manda. El usuario es quien dice el token (auth.getUser()), no quien dice el JSON.
  • Usar la clave secreta para todo dentro de la función. Así el RLS no vale ahí dentro, y la función se vuelve la puerta trasera. Usa la clave secreta solo en la parte que la necesita.
  • Esconder el botón de admin y creer que eso es un permiso. Un botón escondido es interfaz. La verificación tiene que estar en la base de datos o en el servidor.

8. Storage: un bucket público es público#

Un archivo en un bucket público es accesible para cualquiera que tenga la URL, sin login. Sirve para avatares e imágenes de productos, no para documentos, comprobantes o fotos de un documento de identidad.

Para archivos privados, usa un bucket privado y policies en la tabla storage.objects. El patrón en el que cada usuario tiene su propia carpeta:

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)
);

Haz lo mismo para insert, update y delete, y para mostrar el archivo en pantalla genera una URL firmada, que expira.

9. Secretos fuera del repositorio#

  • .env en el .gitignore antes del primer commit.
  • Si una clave ya se commiteó, borrar el archivo no lo resuelve: sigue en el historial de Git. Cambia la clave.
  • Los repositorios públicos en GitHub son rastreados por bots en busca de claves todo el tiempo.

10. Límites de uso#

Registro, login, envío de correos y llamadas a la IA son los blancos de abuso. Revisa los límites de tasa de Auth en el panel de Supabase, activa un captcha en el registro si la app está abierta al público y pon un límite por usuario en las funciones que cuestan dinero.

11. Repítelo después de cada cambio#

Este es el punto que más pesa en el día a día. Le pides a la IA que "agregue un campo de teléfono al perfil", la IA recrea la tabla, y las policies pueden quedarse en el camino. La recomendación de la propia investigación va en esa línea: revisar los permisos y la separación entre cuentas antes de poner datos reales, y repetir la revisión después de cada cambio.

Puedes pedirle a la IA que escriba las policies, y suele escribirlas bien cuando se lo pides explícitamente. Pero la revisión es tuya: la consulta de tablas sin RLS y el test con curl toman cinco minutos.

¿Y si no es Supabase?#

La idea es la misma en cualquier arquitectura en la que el front habla directo con la base de datos. En Firebase, el papel del RLS lo cumplen las Security Rules, y allow read, write: if true es exactamente la misma puerta abierta. Si la app tiene un servidor propio en el medio (lo que Cursor genera con frecuencia, según el pedido), el checklist cambia de lugar pero no de tema: autenticación en toda ruta, nada de confiar en el id que viene del front, secretos solo en el servidor.

Las herramientas automáticas ayudan y vale la pena usarlas, pero no reemplazan una revisión de verdad cuando la app va a guardar datos sensibles de otras personas, como documentos, salud o pagos.

Checklist#

  • La consulta de tablas sin RLS vuelve vacía.
  • Toda tabla con datos de usuarios tiene una policy por operación, con with check en el insert y en el update.
  • Ninguna policy using (true) en datos privados.
  • Privilegios (admin, plan, saldo) fuera de las columnas que el usuario edita, y fuera del user_metadata.
  • Views con security_invoker = true.
  • Clave secreta y claves de IA, pagos y correo solo en el servidor, sin prefijo público.
  • grep en el build sin ninguna clave.
  • Las funciones verifican al usuario por el token y validan la entrada.
  • Bucket privado para archivos privados, con policy por carpeta y URL firmada.
  • .env fuera de Git, y la clave que se filtró fue cambiada.
  • Límite de tasa en Auth y en las funciones que cuestan dinero.
  • Test con curl sin login y con un usuario de prueba, repetido después de cada cambio.

Referencias#

  • Back-end
  • seguridad
  • supabase
  • ia
  • lovable
  • postgres
  • rls

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.