Apps gerados por IA estão no ar sem Row-Level Security
Passaportes e mais de 200 mil mensagens privadas vazaram de apps feitos por IA sem row-level security no Supabase. Veja como auditar o seu.

159.041 aplicações. Foi esse o número de apps web gerados por IA que uma equipe de pesquisa extraiu do arquivo Common Crawl para testar uma falha simples e batida: dava para ler registros do banco sem fazer login? Para 7.403 dos sites analisados em profundidade, a resposta foi sim — tabelas com endereços de e-mail podiam ser lidas por qualquer pessoa que pedisse. Ao cavar mais fundo, apareceram nomes completos e datas de nascimento, dados de pagamento, códigos de ingressos, exportações internas do WhatsApp, resumos gerados por IA de e-mails de um administrador de imóveis, mais de 200.000 mensagens privadas de um fórum de estilo de vida e, no pior caso, mais de mil registros com números de passaporte, datas de validade e nacionalidades. A causa raiz, caso após caso, era a falta de Row-Level Security no Supabase, e explorar isso não exigia nada mais sofisticado do que as ferramentas de desenvolvedor do navegador.
Vale ser preciso com os números, porque eles são citados errado com frequência. Dos 159.041 projetos Lovable identificados, 34.545 usavam o Supabase como banco de dados. Desses, 24.664 enviaram registros do banco para o navegador assim que a página carregava, sem login e sem nenhuma interação. Isso por si só não é um bug; muitos dados devem mesmo ser públicos. Então os pesquisadores fizeram requisições extras somente de leitura usando exatamente a mesma chave de API que cada site distribuía no próprio JavaScript, e olharam o que voltava. Registros com endereços de e-mail apareceram em 10.560 tabelas em 7.403 sites, ou seja, 30% dos sites examinados de perto. Isso não é uma taxa confirmada de vazamento, e os pesquisadores fazem questão de dizer isso: alguns desses endereços são caixas de contato públicas ou dados de teste. Mas os casos que eles verificaram manualmente não deixam dúvida. Clientes reais. Passaportes reais. Mensagens privadas reais.
Row-Level Security no Supabase é a única barreira
Para entender por que isso continua acontecendo, é preciso entender o acordo que o Supabase faz com você. Você recebe um banco Postgres com uma API REST gerada automaticamente na frente, e seu frontend conversa com o banco diretamente. Não existe uma camada de backend aplicando autorização: nenhum middleware Express, nenhum mixin de permissões do Django, nada. O navegador carrega uma chave de API anon, que é pública por design e vai junto no bundle JavaScript. Uma segunda chave, service_role, ignora tudo e jamais deve chegar ao cliente.
Como o cliente se conecta direto ao banco, o próprio banco precisa decidir o que cada requisição pode ver. Esse mecanismo é o row-level security do Postgres: políticas por tabela que filtram quais linhas um determinado papel pode ler ou modificar. Aqui está a parte que pega as pessoas: se o RLS não estiver habilitado em uma tabela, a chave pública anon consegue ler e escrever cada linha dela. Ponto final. A tabela poderia muito bem ser um arquivo JSON estático na sua CDN.
create table profiles (
id uuid primary key default gen_random_uuid(),
full_name text,
email text,
date_of_birth date
);
-- This is the line that decides whether the table is public:
alter table profiles enable row level security;
-- Without it, the shipped anon key reads and writes every row.
# The "attack": the same request the app makes, minus the login
curl "https://your-project.supabase.co/rest/v1/profiles?select=*" \
-H "apikey: eyJhbGciOi..." \
-H "Authorization: Bearer eyJhbGciOi..."
Olhe de novo para esse comando curl. Não é um exploit em nenhum sentido significativo. É a mesma requisição que o frontend legítimo faz, reproduzida sem uma sessão de usuário. A chave de API não foi roubada: ela foi publicada, servida a todo visitante como parte do próprio código do site. A única coisa entre essa requisição e os passaportes dos seus clientes é uma configuração do Postgres que ninguém ligou. É por isso que continuo dizendo que as exposições do Lovable não foram “hackeadas”. Foram deixadas destrancadas.
Por que geradores de apps com IA entregam controle de acesso quebrado
A pergunta óbvia: por que o gerador simplesmente não habilita o RLS? Porque, da perspectiva do gerador, nada está quebrado. O app funciona. A prévia carrega, os registros aparecem, a demo impressiona o fundador que pediu o app. Ausência de controle de acesso é uma falha silenciosa: um app sem RLS se comporta exatamente como um app bem protegido até o momento em que alguém não autorizado aparece. Não existe stack trace para “um estranho em outro país está lendo sua tabela de mensagens”. Um gerador otimizado para “roda?” vai, sistematicamente, investir pouco em “quem mais consegue rodar isso?”.
Há também um problema de especificação. “Construa uma plataforma de reservas para o meu restaurante” não contém nenhuma informação sobre quem deveria poder ler a tabela de reservas. Um desenvolvedor humano preenche essa lacuna com convenção, cicatrizes de experiência e perguntas constrangedoras na reunião de kickoff. Um LLM preenche com a continuação estatisticamente mais comum, e o código de tutorial de Supabase mais frequente na internet tem o RLS desligado, porque tutoriais o desligam para manter o caminho feliz curto. Essa é a lacuna entre especificação e implementação fazendo o que sempre faz: o bug vive exatamente onde o prompt ficou em silêncio.
Depois, há a questão dos padrões, e o Supabase tem parte nisso. Por anos, novas tabelas criadas pelo painel tinham o RLS desligado, a menos que você soubesse habilitá-lo. Foi um trade-off deliberado de onboarding, já que nada mata o ímpeto de um tutorial como consultas retornando resultados vazios. Após críticas constantes, o Supabase passou a tornar o RLS padrão em novos projetos, mas projetos existentes mantiveram a configuração original. Some isso a um gerador treinado com anos de código anterior à mudança de padrão e você tem um pipeline que produz tabelas expostas de forma confiável.
Por fim, o fator humano. A promessa da Lovable é que nenhum conhecimento técnico é necessário, e seus termos colocam a responsabilidade pelo app e pelos dados firmemente nas costas do cliente. Essa lacuna é de onde vieram os 7.403 apps vazando. Um fundador não técnico não consegue auditar o que não consegue ler. Ele não sabe que o RLS existe, não sabe que a chave anon é pública, e o momento alegre de “seu app está no ar!” da plataforma não lhe dá motivo para perguntar. O marketing disse que o avião voa sozinho. As letras miúdas diziam que o piloto era ele.
Um padrão quebrado, milhares de alvos idênticos
O que torna isso genuinamente perigoso não é nenhum app vazando isoladamente, e sim a homogeneidade. Geradores de IA produzem padrões de integração recorrentes: a mesma configuração de cliente, as mesmas convenções de tabela, a mesma URL de projeto Supabase no mesmo bundle JavaScript. Isso derruba o custo do atacante. Escreva um script que identifica um site construído com Lovable, extrai a URL do Supabase e a chave anon, lista as tabelas expostas e executa select=* em cada uma, e ele funciona contra milhares de apps com quase nenhuma modificação. Controle de acesso quebrado está no topo do OWASP Top 10 há anos; o novo é a escala industrial com que instâncias idênticas dessa falha agora podem ser fabricadas e colhidas.
Alguns profissionais questionam chamar isso de “vazamento” para início de conversa: os sites é que distribuíram a chave e serviram os dados, então consumi-la não é acesso não autorizado, e o ato de publicar é que foi o vazamento. Tecnicamente, eles têm razão quanto à terminologia. Mas é um preciosismo que só importa para atribuir culpa, e não significa nada para a pessoa cujo número de passaporte acabou numa resposta JSON de um desconhecido. Ninguém consentiu com essa arquitetura.
O app funcionou perfeitamente. Esse era o problema: funcionou perfeitamente para todo mundo.
As consequências legais caem onde sempre caem: em quem lançou o app. Pela GDPR, o dono do app é o controlador dos dados, e essa pesquisa veio da Alemanha, sobre uma plataforma sueca, envolvendo documentos de identidade de cidadãos da UE. Número de passaporte somado a nome e nacionalidade é um kit inicial de roubo de identidade; 200.000 mensagens privadas são um reservatório para chantagem e phishing. Se os reguladores vão abrir processos é uma questão em aberto, mas se você é um fundador que montou um banco de clientes no vibe coding e foi embora, “foi a IA que fez” não é uma defesa que qualquer autoridade de proteção de dados vai aceitar.

Como auditar configurações do Supabase geradas antes de publicar
Se você publicou, ou herdou, um app gerado por IA no Supabase, aqui está a auditoria que eu faço. Leva uma tarde. Faça isso antes de qualquer dado real de cliente chegar perto dele.
- Inventarie as tabelas expostas. Execute a consulta de RLS abaixo no editor SQL. Toda tabela do esquema
publiccom RLS desabilitado é legível e gravável por qualquer pessoa através da chave anon distribuída. - Leia cada política. RLS habilitado não significa nada se a política for
using (true). Geradores adoram emitir políticas que liberam tudo, porque elas silenciam erros durante o desenvolvimento. - Teste o app como um estranho. Copie a chave anon do JavaScript publicado e acesse todos os endpoints REST sem sessão. Qualquer linha que voltar é pública. Era essa a sua intenção?
- Verifique os buckets de storage. Um bucket marcado como público transforma cada arquivo nele numa URL acessível. Álbuns de fotos e digitalizações de documentos de identidade não têm nada que fazer ali.
- Procure por
service_roleno bundle do cliente. A chave anon no código publicado é aceitável; a chave de serviço publicada é uma catástrofe. Seu cliente de API publicado é um cofre de credenciais, audite-o.
-- Tables exposed via the API with RLS disabled (each one is public)
select schemaname, tablename
from pg_tables
where schemaname = 'public'
and rowsecurity = false;
-- The subtler failure: RLS enabled, but what do the policies allow?
select schemaname, tablename, policyname, cmd, qual
from pg_policies
where schemaname = 'public';
A segunda consulta é onde fica interessante. Você vai encontrar tabelas com RLS habilitado mas sem nenhuma política, o que falha de forma segura e geralmente significa que uma funcionalidade quebrou silenciosamente e alguém a “consertou” afrouxando outra coisa. E vai encontrar políticas como esta, que já vi em código gerado suficiente para reconhecer de longe:
-- The policy generators emit when a query fails during development:
create policy "allow all" on messages for all using (true);
-- It silences the error and publishes the table. Reject it on sight.
-- What a real policy looks like:
create policy "users read their own messages"
on messages for select
to authenticated
using (auth.uid() = sender_id or auth.uid() = recipient_id);
O padrão using (true) merece atenção especial porque é o equivalente, no código gerado, a comentar uma verificação de autenticação para fazer um teste passar. Ele existe porque o gerador bateu num erro de permissão, diagnosticou corretamente que faltava uma política e escreveu a mais preguiçosa possível. Quando encontrar, não se limite a apertar a política: pergunte por que a tabela estava acessível naquele caminho de código. E repita a auditoria inteira após cada regeneração significativa. Construtores de IA reescrevem seu schema com alegria, e as políticas restritivas de ontem não sobrevivem ao prompt de hoje “faça o painel mostrar todos os usuários”.
Scanners de segurança ajudam, mas os padrões decidem
Para crédito da Lovable, a equipe de segurança respondeu diretamente à pesquisa: eles identificam RLS insuficiente como causa raiz, escaneiam automaticamente cada app antes da publicação, oferecem uma análise SAST mais profunda e permitem que usuários corrijam problemas com um clique, ativem correção automática ou bloqueiem a publicação totalmente diante de resultados críticos, tudo gratuitamente para todos os usuários. É um conjunto de ferramentas genuinamente razoável, e mais do que a maioria dos construtores de apps oferece.
Mas repare no que um scanner de pré-publicação implica: o gerador produziu a falha primeiro, e agora existe um segundo sistema para pegá-la. A taxa de detecção do scanner é uma medida de quão frequentemente a saída padrão é insegura. Já escrevi antes sobre como scanners de segurança com IA estão cobrando nossa dívida técnica. Eles são úteis, mas tratam sintomas. A correção durável é a geração com negação por padrão: toda tabela criada com RLS habilitado, toda tabela recebendo uma política explícita, mesmo que essa política seja “negar tudo” até o usuário optar por mais. O estado inseguro deveria ser o que exige esforço. Hoje é o contrário, e 24.664 apps transmitindo registros do banco no carregamento da página é o que essa inversão custa.

A conclusão para quem publica apps construídos com IA
A IA não inventou o controle de acesso quebrado. IDOR e falta de autorização estão no topo das listas de vulnerabilidades desde muito antes de alguém fazer um app por prompt. O que a IA mudou foi o volume e o operador: ela industrializou um modo de falha conhecido e colocou o botão de deploy nas mãos de pessoas que não distinguem uma política de RLS de uma regra de CSS. O número de 30% dessa pesquisa não é um escândalo sobre uma plataforma. É uma prévia de todo ecossistema em que código gerado encontra um banco público com um modelo de segurança opt-in.
Então trate todo app gerado por IA como trataria código de fornecedor não auditado, porque é isso que ele é. Rode as consultas acima antes do lançamento e depois de cada mudança grande. Se o app vai guardar dados regulados ou de identidade e ninguém da equipe consegue ler uma política do Postgres, pague alguém que consiga: uma tarde de revisão especializada custa menos do que explicar números de passaporte a um regulador. O no-code removeu a sintaxe. Não removeu a responsabilidade, e nunca vai remover.


