Todos os artigos

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.

Também em English, Español, Français

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 prefixo VITE_, NEXT_PUBLIC_ ou EXPO_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.

A chave pública é igual pra todo mundo. Quem decide o que cada um vê é a policy de RLS de cada tabela

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:

  1. Abra o seu site, abra o DevTools e vá na aba Network.
  2. 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).
  3. 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"
Mesma consulta, sem login. Lista vazia é o que você quer ver

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 escrevendo using (true), ela desligou a segurança daquela tabela.
  • with check no insert e no update. O using diz quais linhas a pessoa pode ver ou mexer. O with check diz como a linha pode ficar depois. Sem ele, alguém consegue criar uma nota com o user_id de 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_ ou EXPO_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/ | head

Se 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_id do 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#

  • .env no .gitignore antes 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 check no 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.
  • grep no 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.
  • .env fora do Git, e chave que vazou foi trocada.
  • Limite de taxa no Auth e nas funções que custam dinheiro.
  • Teste com curl sem login e com um usuário de teste, repetido depois de cada mudança.

Referências#

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

Escrito por

Engenheira de software e designer. Escrevo sobre o que encontro construindo apps, APIs e produtos.