Back-end13 min de leitura
App feito com IA: o que conferir antes de publicar
Checklist de segurança pra app gerado no Lovable, Bolt ou Cursor: RLS no Supabase, chave secreta fora do front, chave de IA no servidor, storage e um teste de 5 minutos.

Ferramentas como Lovable, Bolt e Cursor colocam um app no ar numa tarde: tela de login, cadastro, banco de dados, tudo funcionando. E é aí que mora a armadilha. Funcionar não é a mesma coisa que estar protegido. Um app pode fazer login, salvar e listar direitinho e, ao mesmo tempo, entregar os dados de todos os usuários pra qualquer pessoa que souber pedir.
Isso não é hipótese. No começo de novembro de 2026, uma pesquisa publicada junto com o jornal alemão Handelsblatt analisou mais de 150 mil projetos feitos no Lovable e achou milhares de sites devolvendo dados de usuários sem login nenhum. Este post explica por que isso acontece e traz o checklist que eu rodaria antes de publicar qualquer app gerado por IA.
Um aviso honesto: não testei o app de ninguém. Os números vêm das fontes linkadas no fim, e os exemplos de SQL e código seguem a documentação do Supabase. As imagens são ilustrações que eu desenhei pra explicar cada parte.
TL;DR#
- O problema quase nunca é a IA escrever código "hackeável". É o app ir pro ar sem as regras de acesso do banco, porque nada na tela mostra que elas faltam.
- No Supabase, a chave que vai no navegador é pública por natureza. Quem protege os dados é o Row Level Security (RLS): regras no Postgres que dizem quem pode ler e escrever cada linha.
- RLS em toda tabela exposta, com policy de verdade (nada de
using (true)em dado privado). - A chave secreta (antiga
service_role) e chaves de IA ou pagamento nunca vão pro front. Variável com prefixoVITE_,NEXT_PUBLIC_ouEXPO_PUBLIC_vai parar no bundle, e o bundle é público. - Faça o teste de 5 minutos: pegue a URL e a chave que o seu próprio site já manda e consulte uma tabela com
curl, sem login. Se vierem dados de outras pessoas, não publique. - Repita depois de cada mudança. A IA mexe numa tabela e a regra pode ir junto.
O que aconteceu#
A pesquisa é da Crissy Field, uma empresa alemã de segurança, feita em parceria com o Handelsblatt. Eles usaram o Common Crawl (um arquivo público da web) pra achar sites feitos no Lovable publicados entre dezembro de 2025 e setembro de 2026:
- 159.041 projetos analisados, dos quais 34.545 usavam Supabase como banco.
- 24.664 sites devolviam registros do banco já no carregamento da página, sem login. Isso sozinho não é falha: um blog mostra posts pra todo mundo de propósito.
- Fazendo só leituras com a mesma chave pública que o site já usa, eles acharam e-mails em 10.560 tabelas de 7.403 sites. Também não é taxa confirmada de vazamento, mas é um sinal forte.
- Entre os exemplos: um fórum alemão com mais de 80 mil perfis e mais de 200 mil mensagens de chat, mais de mil registros com número de passaporte, dados de ingressos e de restaurantes com informação de pagamento.
A causa que eles apontam são erros de controle de acesso. E não é a primeira vez: em 2025, um problema parecido virou o CVE-2025-48757, com nota 9,3 (crítica), descrito como policy de Row Level Security insuficiente em sites gerados pelo Lovable, permitindo ler e escrever tabelas sem autenticação. A Lovable contesta o registro, com o argumento de que proteger os dados é responsabilidade de cada cliente.
As duas leituras têm um pedaço de verdade, e é por isso que este post existe: a ferramenta gera, mas quem publica responde pelo que publicou.
Por que acontece: o front fala direto com o banco#
Num app tradicional, o navegador fala com o seu servidor, e o servidor decide o que devolver. No modelo que Lovable e Bolt costumam gerar com Supabase, não tem servidor no meio: o navegador fala direto com a API do banco, usando uma chave que vai embutida no JavaScript do site.
Essa chave é a publishable key (sb_publishable_..., a antiga anon). Ela é pública de propósito: qualquer um que abrir o DevTools vê. A documentação do Supabase usa uma imagem boa: a chave pública é a que fica colada na porta da frente e só abre o saguão. O que separa o saguão dos apartamentos é o RLS.
Sem RLS, uma tabela no schema exposto (o public, por padrão) pode ser lida e escrita por qualquer papel que tenha permissão nela, e o Supabase dá permissões amplas por padrão pros papéis anon (visitante) e authenticated (logado). Ou seja: tabela sem RLS é tabela aberta.
E repare que o app funciona igual nos dois casos. A tela de "meus pedidos" filtra por usuário no JavaScript, então parece certo. Só que o filtro está no front, e quem chama a API direto pula o front.
O teste de 5 minutos#
Antes do checklist, um teste que qualquer pessoa consegue fazer no próprio app:
- Abra o seu site, abra o DevTools e vá na aba Network.
- Ache uma requisição pra
https://<seu-projeto>.supabase.co/rest/v1/.... Nos headers dela estão a URL do projeto e a chave pública (apikey). - Sem estar logada, consulte uma tabela que guarda dado de usuário:
# 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"Se voltar [] (ou um erro de permissão), ótimo. Se voltarem perfis, e-mails ou pedidos de outras pessoas, o app não está pronto. Faça o mesmo logada como um usuário de teste e confira se aparece só o que é dele.
Importante: faça isso só no seu app. Consultar o banco de um site que não é seu, mesmo com a chave que ele expõe, pode ser crime dependendo do país.
O checklist#
1. RLS ligado em toda tabela exposta#
No SQL Editor do Supabase, esta consulta lista as tabelas do schema public que estão sem RLS:
select schemaname, tablename
from pg_tables
where schemaname = 'public'
and not rowsecurity;Toda tabela que aparecer aqui está aberta. Ligar o RLS é uma linha:
alter table public.notes enable row level security;Com o RLS ligado e nenhuma policy, nada é acessível pela API com a chave pública. Isso é o comportamento seguro: fecha tudo e depois abre só o necessário. O painel do Supabase também tem os Advisors, que avisam tabela sem RLS e outros deslizes. Vale abrir antes de publicar.
2. Policy de verdade, uma por operação#
Ligar o RLS fecha a porta. A policy diz quem entra. O padrão pra dado que pertence a uma pessoa:
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);Dois detalhes que a IA costuma errar:
using (true)libera tudo. Faz sentido numa tabela de posts públicos, não numa de pedidos. Se a IA "resolveu" um erro de permissão escrevendousing (true), ela desligou a segurança daquela tabela.with checkno insert e no update. Ousingdiz quais linhas a pessoa pode ver ou mexer. Owith checkdiz como a linha pode ficar depois. Sem ele, alguém consegue criar uma nota com ouser_idde outra pessoa.
3. Permissão não mora numa coluna que o usuário edita#
O RLS trabalha por linha, não por coluna. Se a policy deixa a pessoa atualizar o próprio perfil, ela atualiza qualquer coluna desse perfil. Então, se o perfil tem is_admin ou plan, um simples update pela API transforma qualquer usuário em admin ou em assinante premium.
A saída é guardar o que é privilégio numa tabela separada, que o usuário só lê:
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.O mesmo vale pro user_metadata do Supabase Auth: o próprio usuário consegue alterar esse campo. Policy que confia num role guardado ali é policy que o usuário controla.
4. Views passam por cima do RLS#
Uma view criada do jeito padrão roda com as permissões de quem a criou, e por isso ignora o RLS das tabelas por baixo. A IA adora criar view pra "juntar os dados do dashboard". No Postgres 15 ou mais novo, a correção é:
create view public.order_summary
with (security_invoker = true)
as select id, user_id, total, created_at from public.orders;Com security_invoker, a view respeita as policies de quem está consultando.
5. A chave secreta fica no servidor#
A chave secreta (sb_secret_..., a antiga service_role) ignora o RLS por completo. Ela existe pra rodar no seu servidor, numa Edge Function, num job agendado. No navegador ou dentro de um app mobile, ela entrega o banco inteiro pra quem abrir o bundle.
Dois jeitos de ela vazar sem ninguém perceber:
- Prefixo público. Toda variável com
VITE_,NEXT_PUBLIC_ouEXPO_PUBLIC_é copiada pro código que vai pro usuário. Chave secreta com esse prefixo é chave publicada. - "Conserto" de erro. Deu erro de permissão, a IA troca a chave pública pela secreta e tudo funciona. Funciona porque desligou a segurança.
Depois do build, procure no que vai ser publicado:
npm run build
grep -rEo "sb_secret_[A-Za-z0-9_-]+|sk-[A-Za-z0-9_-]{20,}" dist/ | headSe aparecer qualquer coisa, a chave foi publicada. Tire do front e troque a chave no painel, porque a antiga já pode estar em algum cache.
6. Chave de IA, pagamento e e-mail também#
App feito com IA costuma usar IA, e a chave da API de IA é a que mais aparece no front. O SDK da OpenAI, por exemplo, só aceita rodar no navegador com uma opção chamada dangerouslyAllowBrowser. O nome já 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,
})Com a chave no front, qualquer pessoa usa a sua cota, e a fatura chega pra você. O lugar dela é uma função no servidor, que confere quem está chamando e valida a entrada antes de repassar:
// 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' },
})
})A mesma regra vale pra chave de gateway de pagamento, de serviço de e-mail e de qualquer coisa que custe dinheiro ou fale em nome da sua empresa.
7. Função no servidor não confia no que o front manda#
Quando a lógica vai pra uma Edge Function ou rota de API, o erro muda de lugar. Os mais comuns:
- Pegar o
user_iddo corpo da requisição. Quem chama a API escolhe o que manda. O usuário é quem o token diz que é (auth.getUser()), não quem o JSON diz. - Usar a chave secreta pra tudo dentro da função. Aí o RLS não vale lá dentro, e a função vira a porta dos fundos. Use a chave secreta só no trecho que precisa dela.
- Esconder o botão de admin e achar que isso é permissão. Botão escondido é interface. A checagem tem que estar no banco ou no servidor.
8. Storage: bucket público é público#
Arquivo em bucket público é acessível por qualquer um que tiver a URL, sem login. Serve pra avatar e imagem de produto, não pra documento, comprovante ou foto de RG.
Pra arquivo privado, use bucket privado e policies na tabela storage.objects. O padrão de cada usuário ter a própria pasta:
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)
);Faça o mesmo pra insert, update e delete, e pra mostrar o arquivo na tela gere uma URL assinada, que expira.
9. Segredo fora do repositório#
.envno.gitignoreantes do primeiro commit.- Se uma chave já foi commitada, apagar o arquivo não resolve: ela continua no histórico do Git. Troque a chave.
- Repositório público no GitHub é varrido por robôs atrás de chave o tempo todo.
10. Limite de uso#
Cadastro, login, envio de e-mail e chamada de IA são os alvos de abuso. Confira os limites de taxa do Auth no painel do Supabase, ligue captcha no cadastro se o app for aberto ao público e coloque um limite por usuário nas funções que custam dinheiro.
11. Repita depois de cada mudança#
Esse é o item que mais pesa no dia a dia. Você pede pra IA "adicionar um campo de telefone no perfil", ela recria a tabela, e as policies podem não vir junto. A recomendação da própria pesquisa vai nessa linha: revisar permissões e separação entre contas antes de colocar dado real, e repetir a checagem depois de cada mudança.
Dá pra pedir pra IA escrever as policies, e ela costuma escrever bem quando é pedido explicitamente. Mas a conferência é sua: a consulta de tabelas sem RLS e o teste com curl levam cinco minutos.
E se não for Supabase?#
A ideia é a mesma em qualquer arquitetura em que o front fala direto com o banco. No Firebase, o papel do RLS é das Security Rules, e allow read, write: if true é exatamente a mesma porta aberta. Se o app tem um servidor próprio no meio (o que o Cursor gera com frequência, dependendo do pedido), o checklist muda de lugar mas não de assunto: autenticação em toda rota, nada de confiar no id que vem do front, segredo só no servidor.
Ferramentas automáticas ajudam e valem ser usadas, mas não substituem uma revisão de verdade quando o app vai guardar dado sensível de outras pessoas, como documento, saúde ou pagamento.
Checklist#
- Consulta de tabelas sem RLS volta vazia.
- Toda tabela com dado de usuário tem policy por operação, com
with checkno insert e no update. - Nenhuma policy
using (true)em dado privado. - Privilégio (admin, plano, saldo) fora das colunas que o usuário edita, e fora do
user_metadata. - Views com
security_invoker = true. - Chave secreta e chaves de IA, pagamento e e-mail só no servidor, sem prefixo público.
grepno build sem nenhuma chave.- Funções conferem o usuário pelo token e validam a entrada.
- Bucket privado pra arquivo privado, com policy por pasta e URL assinada.
.envfora do Git, e chave que vazou foi trocada.- Limite de taxa no Auth e nas funções que custam dinheiro.
- Teste com
curlsem login e com um usuário de teste, repetido depois de cada mudança.
Referências#
Leia também

Back-end18 min de leitura
O que é RAG: indexação, busca híbrida e um caso real

Back-end12 min de leitura
O que é MCP: o protocolo que liga ferramentas à IA

Infra11 min de leitura
Datadog do zero: como integrar e como ler o painel