Vazamento em Apps do Lovable em 2026: Como Proteger o Banco Supabase do Seu App Feito com IA
Olá HaWkers, no dia 02/11/2026 o jornal alemão Handelsblatt publicou uma investigação feita junto com a Crissy Field, uma empresa alemã de segurança de aplicações. Eles analisaram 159.041 projetos criados no Lovable e encontraram passaportes, dados de pagamento e mais de 200 mil mensagens de chat que qualquer pessoa conseguia ler direto do navegador, sem login nenhum.
Não foi uma invasão sofisticada. Ninguém quebrou criptografia nem explorou um bug exótico. Os dados estavam lá porque o banco de dados respondia a quem pedisse. Se você já publicou um app gerado por IA com Supabase por trás, a pergunta que importa é simples: o seu banco também responde a quem pedir? Neste artigo você vai entender o que aconteceu, por que esse erro se repete tanto e, principalmente, como testar e corrigir o seu app em menos de uma hora.
O Que a Pesquisa da Crissy Field Encontrou
Os números ajudam a entender a escala. A equipe coletou projetos do Lovable pelo Common Crawl, cobrindo o período de dezembro de 2025 a setembro de 2026. Desse total:
- 159.041 projetos do Lovable foram analisados.
- 34.545 usavam Supabase como banco de dados.
- 24.664 sites enviavam registros do banco já no carregamento da página, sem login e sem nenhuma interação do usuário.
- Em 7.403 desses sites (cerca de 30%) havia tabelas com endereços de e-mail, somando 10.560 tabelas.
Os pesquisadores fazem questão de dizer que esses 30% não são uma taxa confirmada de vazamento e que a amostra não representa todos os apps do Lovable. Mesmo assim, os exemplos assustam:
- Um fórum alemão de estilo de vida com mais de 80 mil perfis (nome, e-mail, data de nascimento, gênero) e mais de 200 mil mensagens de chat.
- Um prestador de serviços com mais de 1.000 registros de documentos de identidade, incluindo número de passaporte, validade e nacionalidade.
- Organizadores de eventos e restaurantes com dezenas de milhares de registros de ingressos e vendas, com telefone, endereço e dados de pagamento.
- Um caso com 280 mil e-mails enviados aos clientes de uma empresa, todos acessíveis.
- Uma administradora de imóveis com resumos gerados por IA de e-mails internos sobre inquilinos e proprietários.
E tem um detalhe importante: eles baixaram só partes dos dados. O volume real pode ser maior.
Não É a Primeira Vez
Quem acompanha o Lovable já viu esse filme. Em 29/05/2025 foi divulgada a CVE-2025-48757, descoberta pelo pesquisador Matt Palmer. Ele analisou 1.645 apps feitos no Lovable e encontrou 170 deles (10,3%) com o banco exposto, somando 303 endpoints vulneráveis. A causa era a mesma: políticas de Row Level Security (RLS) ausentes ou fracas no Supabase.
Em abril de 2026 veio outro episódio. No dia 20/04/2026 um pesquisador mostrou publicamente que dados de projetos públicos do Lovable podiam ser acessados por qualquer usuário autenticado na plataforma. A própria empresa publicou depois um texto reconhecendo que tanto o produto quanto a primeira resposta pública "erraram o alvo".
O padrão é claro: a ferramenta gera um app que funciona, o dono testa logado com a própria conta, tudo parece certo, e ninguém confere quem mais consegue ler aquelas tabelas.
Por Que o Supabase Expõe Dados Quando Falta RLS
Para corrigir, você precisa entender a arquitetura. Um app típico do Lovable é um front-end React que conversa direto com o Supabase, sem um back-end próprio no meio. O Supabase expõe o banco Postgres através de uma API REST automática (o PostgREST).
Para o navegador conseguir chamar essa API, o front-end carrega uma chave pública, a famosa anon key (ou, nos projetos mais novos, a chave publishable). Essa chave não é segredo e foi feita para ficar no navegador. Qualquer pessoa abre o DevTools, vai na aba Network e copia a chave e a URL do projeto em dez segundos.
Então quem decide o que essa chave pode ler? O Row Level Security do Postgres. A lógica funciona assim:
- RLS desligado na tabela: qualquer um com a chave pública lê e, dependendo das permissões, escreve em tudo.
- RLS ligado sem nenhuma política: ninguém lê nada pela API pública. É o estado seguro por padrão.
- RLS ligado com política frouxa, como
using (true): na prática é o mesmo que estar desligado.
O problema dos apps gerados por IA é que a terceira situação aparece muito. O modelo cria a tabela, o app dá erro de permissão, e o "conserto" mais rápido para fazer a tela funcionar é uma política que libera tudo. O app passa a funcionar, e o dado passa a ser público.
Teste 1: Seu Banco Responde a um Estranho?
O primeiro teste é fazer exatamente o que um curioso faria. Abra o seu app publicado, abra o DevTools, filtre as requisições por supabase.co e copie a URL do projeto e o cabeçalho apikey. Depois rode no terminal, sem estar logado:
# URL do projeto e chave pública, copiadas do DevTools do seu próprio app
SUPABASE_URL="https://seu-projeto.supabase.co"
ANON_KEY="cole-aqui-a-chave-publica"
# Tenta ler as 5 primeiras linhas de uma tabela sem nenhum login
curl -s "$SUPABASE_URL/rest/v1/profiles?select=*&limit=5" \
-H "apikey: $ANON_KEY" \
-H "Authorization: Bearer $ANON_KEY"
# Resposta segura: [] (lista vazia) ou erro de permissão
# Resposta perigosa: JSON com dados reais de usuáriosRepita para cada tabela que o app usa: profiles, users, messages, orders, bookings, o que existir. Se qualquer uma devolver dados de outras pessoas, você tem o mesmo problema dos apps da pesquisa.
Teste 2: Auditoria Completa Pelo SQL Editor
Testar tabela por tabela é lento e você pode esquecer alguma. A forma confiável é perguntar direto ao Postgres. No painel do Supabase, abra o SQL Editor e rode:
-- Lista todas as tabelas do schema public e mostra se o RLS está ligado
select
schemaname,
tablename,
rowsecurity as rls_ligado
from pg_tables
where schemaname = 'public'
order by rowsecurity, tablename;
-- Qualquer linha com rls_ligado = false é uma tabela
-- que a chave pública consegue ler sem restriçãoDepois, veja as políticas que existem e procure as que liberam tudo:
-- Lista as políticas e destaca as que usam "true" como condição
select
tablename,
policyname,
cmd as operacao, -- SELECT, INSERT, UPDATE, DELETE ou ALL
roles,
qual as condicao_leitura, -- condição do USING
with_check as condicao_escrita
from pg_policies
where schemaname = 'public'
order by tablename;
-- Atenção redobrada a políticas com condicao_leitura = 'true'
-- aplicadas ao papel anon ou publicUma política com true para o papel anon numa tabela de produtos de uma vitrine pode estar certa, porque catálogo é público mesmo. A mesma política numa tabela de mensagens ou documentos é um vazamento esperando acontecer.
Como Corrigir: Políticas de RLS Que Fazem Sentido
A correção tem duas partes: ligar o RLS em tudo e escrever políticas que reflitam quem é dono de cada linha. Veja um exemplo para uma tabela de perfis e outra de mensagens:
-- 1. Liga o RLS (sem políticas, ninguém lê nada pela API pública)
alter table public.profiles enable row level security;
alter table public.messages enable row level security;
-- 2. Remove a política "libera geral" que a IA criou
drop policy if exists "Enable read access for all users" on public.profiles;
-- 3. Cada usuário lê e edita apenas o próprio perfil
create policy "perfil: dono lê"
on public.profiles for select
to authenticated
using ((select auth.uid()) = id);
create policy "perfil: dono atualiza"
on public.profiles for update
to authenticated
using ((select auth.uid()) = id)
with check ((select auth.uid()) = id);
-- 4. Mensagens: só quem enviou ou quem recebeu consegue ler
create policy "mensagem: participantes leem"
on public.messages for select
to authenticated
using ((select auth.uid()) in (sender_id, recipient_id));
-- 5. Só é possível enviar mensagem em nome de si mesmo
create policy "mensagem: envia como si mesmo"
on public.messages for insert
to authenticated
with check ((select auth.uid()) = sender_id);Três detalhes que fazem diferença:
- Use
to authenticatedem vez de deixar a política valer para todo mundo. Isso já corta o acesso anônimo. - Envolver
auth.uid()emselectfaz o Postgres calcular o valor uma vez por consulta, e não uma vez por linha. Em tabelas grandes isso pesa. - Separe leitura e escrita. O
usingcontrola quais linhas você enxerga; owith checkcontrola o que você pode gravar. Esquecer owith checkdeixa alguém atualizar o próprio registro e trocar oidpara o de outra pessoa.
Dados Sensíveis Não Deveriam Nem Passar Pelo Navegador
RLS resolve o "quem lê qual linha". Mas existe uma pergunta anterior: aquele dado precisava estar numa tabela acessível pelo front-end? Número de passaporte, documento, dados de pagamento e e-mails de clientes raramente precisam.
Uma prática melhor é colocar esse tipo de informação num schema que a API pública nem enxerga e acessar só pelo servidor, com uma Edge Function:
// supabase/functions/verificar-documento/index.ts
// Edge Function: roda no servidor, nunca expõe a service_role ao navegador
import { createClient } from "jsr:@supabase/supabase-js@2";
Deno.serve(async (req) => {
// Cliente com o token do usuário: identifica quem está chamando
const authHeader = req.headers.get("Authorization") ?? "";
const userClient = createClient(
Deno.env.get("SUPABASE_URL")!,
Deno.env.get("SUPABASE_ANON_KEY")!,
{ global: { headers: { Authorization: authHeader } } },
);
const { data: { user } } = await userClient.auth.getUser();
if (!user) return new Response("não autorizado", { status: 401 });
// Cliente administrativo: só existe aqui dentro, no servidor
const admin = createClient(
Deno.env.get("SUPABASE_URL")!,
Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")!,
);
// Devolve apenas o mínimo necessário, nunca o número completo
const { data, error } = await admin
.schema("privado")
.from("documentos")
.select("tipo, validade")
.eq("user_id", user.id)
.single();
if (error) return new Response("não encontrado", { status: 404 });
return Response.json({ tipo: data.tipo, valido: new Date(data.validade) > new Date() });
});O front-end recebe só "documento válido: sim/não". O passaporte em si nunca sai do servidor. Se amanhã alguém errar uma política, esse dado continua protegido porque ele simplesmente não está ao alcance da chave pública.
E lembre: a service_role key ignora todo o RLS. Ela jamais pode aparecer no código do front-end, num arquivo .env com prefixo VITE_ ou num repositório público. Se você já passou por algo parecido com chaves de API de IA, vale ler o que aconteceu no vazamento de chaves do OpenCode Console e como se proteger, porque o raciocínio é o mesmo.
Um Teste Automatizado Para Não Regredir
Corrigir uma vez não basta. A pesquisa da Crissy Field recomenda repetir a revisão a cada mudança grande, e app feito com IA muda o tempo todo: basta pedir "adiciona uma tela de chat" e uma tabela nova nasce com a política que o modelo achou conveniente.
Um script simples no CI pega a regressão antes do deploy:
// scripts/checar-rls.mjs
// Tenta ler cada tabela sensível como visitante anônimo.
// Falha o build se alguma devolver dados.
const URL_PROJETO = process.env.SUPABASE_URL;
const CHAVE_PUBLICA = process.env.SUPABASE_ANON_KEY;
// Tabelas que NUNCA podem ser lidas sem login
const tabelasSensiveis = ["profiles", "messages", "orders", "documents"];
let falhou = false;
for (const tabela of tabelasSensiveis) {
const resposta = await fetch(
`${URL_PROJETO}/rest/v1/${tabela}?select=*&limit=1`,
{ headers: { apikey: CHAVE_PUBLICA, Authorization: `Bearer ${CHAVE_PUBLICA}` } },
);
// 401/403 ou lista vazia = protegido
const corpo = resposta.ok ? await resposta.json() : [];
if (Array.isArray(corpo) && corpo.length > 0) {
console.error(`❌ ${tabela}: dados visíveis para visitante anônimo`);
falhou = true;
} else {
console.log(`✅ ${tabela}: protegida`);
}
}
process.exit(falhou ? 1 : 0);Coloque isso para rodar contra o ambiente de staging, com pelo menos uma linha de teste em cada tabela. Uma tabela vazia passa no teste mesmo estando aberta, por isso o dado de teste é obrigatório.
O Que Isso Diz Sobre Construir Apps com IA
É tentador culpar só o Lovable, mas a lição é maior. A pesquisa descreve os erros como falhas de controle de acesso que "seguem padrões recorrentes". Ferramentas de vibe coding são ótimas para fazer o app funcionar, e funcionar é exatamente o critério que esconde o problema: o dono testa logado, vê os próprios dados e conclui que está tudo certo.
Algumas regras práticas que eu sigo em qualquer projeto gerado com IA:
- Teste deslogado e com uma segunda conta. Se a conta B enxerga algo da conta A, tem bug.
- Desconfie de toda política com
true. Peça para a IA justificar cada uma em voz alta. - Rode o scanner de segurança da plataforma antes de publicar, mas não pare nele. A própria Crissy Field avisa que checagem automática não substitui uma avaliação de segurança de verdade.
- Não guarde o que você não precisa. O dado mais seguro é o que nunca foi coletado.
- Revise de novo depois de cada feature grande. Tabela nova é política nova.
Se o app vai lidar com dados reais de clientes, e principalmente com documentos, saúde ou pagamento, vale pagar uma revisão profissional. Um vazamento de dados pessoais custa muito mais do que a auditoria, sem falar das obrigações com a LGPD.
Perspectivas
As plataformas estão reagindo. O Lovable já oferece um scanner que roda quando você abre a janela de publicação, e o Supabase vem tornando os padrões mais restritivos para tabelas novas. Isso ajuda, mas não resolve o essencial: a ferramenta não sabe quais dados do seu negócio são sensíveis. Só você sabe.
A boa notícia é que a correção é barata. Ligar o RLS, escrever meia dúzia de políticas e colocar um teste no CI cabe numa tarde. A má notícia é que, se ninguém fizer isso, o próximo levantamento vai encontrar os mesmos erros em outros milhares de apps.
Bora pra cima! 🦅
📚 Quer Acompanhar o Que Vem Por Aí?
Este artigo cobriu o vazamento de dados em apps do Lovable e como proteger o banco Supabase com RLS, mas o ecossistema muda toda semana e nem tudo vira artigo aqui.
No X eu compartilho o que estou testando, os bastidores dos projetos e as novidades que aparecem antes de virarem post.
Me Segue Lá
💡 Conteúdo diário sobre desenvolvimento, carreira e as ferramentas que eu realmente uso

