Middleware do Next.js vs Supabase RLS: Onde Fica a Segurança
Em arquiteturas modernas com Next.js App Router e Supabase, um dos erros de segurança mais perigosos cometidos por equipes de desenvolvimento é confundir controle de navegação visual com segurança de dados.
É comum encontrar aplicações corporativas onde o desenvolvedor escreve uma verificação de sessão dentro do middleware.ts e assume que a aplicação está blindada contra vazamentos:
// O PERIGOSO MITO DA SEGURANCA EXCLUSIVA NO MIDDLEWARE
if (!session && request.nextUrl.pathname.startsWith('/admin')) {
return NextResponse.redirect(new URL('/login', request.url));
}
A diretoria e o time de produto acreditam que, como usuários deslogados não conseguem visualizar a página /admin no navegador, os dados confidenciais da empresa estão protegidos.
Essa presunção é uma ilusão catastrófica.
Neste manual de engenharia, vou demonstrar por que o Next.js Middleware na Edge nunca foi projetado para ser um firewall de dados, e como estruturar a verdadeira arquitetura de Defesa em Profundidade (Defense-in-Depth) unindo a malha da Vercel ao Row Level Security (RLS) do Supabase em 2026.
1. A Vulnerabilidade do "Porteiro Desarmado"
Para entender a fragilidade de depender apenas do Middleware, imagine a portaria de um condomínio empresarial:
- O Next.js Middleware é o segurança na catraca de entrada. Ele olha o crachá do visitante e diz: "Você não pode entrar pela porta principal do 3º andar, vá para a recepção".
- O Banco de Dados sem RLS é uma sala no 3º andar com cofres abertos e documentos espalhados pelas mesas, sem nenhuma tranca na porta.
Se um invasor pular a janela dos fundos, utilizar uma rota de API esquecida ou invocar uma Server Action forjada enviando um POST direto via terminal (curl ou Postman), o porteiro da catraca é completamente ignorado.
Se a tabela do banco de dados não possuir políticas de segurança em nível de linha (Row Level Security), o invasor lerá e modificará registros confidenciais com sucesso.
Três Formas pelas Quais o Middleware é Contornado:
- Invocação Direta de Server Actions: Server Actions geram identificadores POST internos. Um atacante autenticado com perfil de "Leitor" pode enviar uma requisição forjada para a ação de "Deletar Empresa" contornando qualquer regra de rota visual.
- Falhas de Configuração de Matcher: Uma regra de regex mal formatada no
config.matcherdo middleware pode deixar de interceptar sub-rotas críticas ou requisições pré-carregadas (RSC prefetch). - Múltiplos Clientes no Ecossistema: Se a sua empresa lançar um aplicativo mobile ou uma integração B2B que consome diretamente a API do Supabase, o middleware do Next.js sequer fará parte do ciclo de vida da requisição.
2. O Papel Legítimo do Edge Middleware: O Porteiro Visual
Isso significa que o Middleware do Next.js é inútil? Absolutamente não.
Na arquitetura limpa, o Edge Middleware possui atribuições fundamentais voltadas para a Malha de Entrega (Frontend) e Experiência do Usuário (UX):
1. Prevenção de Flickeamento Visual (Zero-Flicker Redirection)
Sem o Middleware, o usuário precisaria baixar os scripts React da página privada para só então o cliente perceber que ele não está logado e redirecioná-lo. O Middleware intercepta a requisição na Edge da Vercel antes de gerar qualquer HTML, garantindo redirecionamentos instantâneos.
2. Atualização Atômica de Cookies de Sessão (Auth Token Refresh)
O Supabase armazena tokens JWT de curta duração (ex: 1 hora) e refresh tokens em cookies HTTP. O Middleware garante que, a cada requisição de navegação, o token seja renovado de forma transparente.
3. Injeção de Cabeçalhos de Segurança HTTP
O Middleware é o local perfeito para injetar cabeçalhos globais de proteção como Content-Security-Policy (CSP), X-Frame-Options (anti-Clickjacking) e Strict-Transport-Security (HSTS).
Exemplo de Middleware Seguro com Supabase SSR
// middleware.ts
import { type NextRequest, NextResponse } from "next/server";
import { createServerClient } from "@supabase/ssr";
export async function middleware(request: NextRequest) {
let supabaseResponse = NextResponse.next({
request,
});
const supabase = createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
{
cookies: {
getAll() {
return request.cookies.getAll();
},
setAll(cookiesToSet) {
cookiesToSet.forEach(({ name, value }) =>
request.cookies.set(name, value)
);
supabaseResponse = NextResponse.next({
request,
});
cookiesToSet.forEach(({ name, value, options }) =>
supabaseResponse.cookies.set(name, value, options)
);
},
},
}
);
// IMPORTANTE: Use getUser() e NUNCA getSession() para validacao segura
const { data: { user } } = await supabase.auth.getUser();
const isAuthRoute = request.nextUrl.pathname.startsWith("/login");
const isProtectedRoute = request.nextUrl.pathname.startsWith("/dashboard")
|| request.nextUrl.pathname.startsWith("/admin");
// Redirecionamento amigavel de UX na camada visual
if (!user && isProtectedRoute) {
const url = request.nextUrl.clone();
url.pathname = "/login";
return NextResponse.redirect(url);
}
if (user && isAuthRoute) {
const url = request.nextUrl.clone();
url.pathname = "/dashboard";
return NextResponse.redirect(url);
}
return supabaseResponse;
}
export const config = {
matcher: [
"/((?!_next/static|_next/image|favicon.ico|.*\\.(?:svg|png|jpg|jpeg|gif|webp)$).*)",
],
};
3. Onde a Segurança Realmente Mora: Supabase RLS
A verdadeira segurança corporativa reside no banco de dados. O Row Level Security (RLS) do PostgreSQL é o cofre blindado inviolável.
Com o RLS ativado, o próprio motor SQL avalia cada comando SELECT, INSERT, UPDATE e DELETE contra o token JWT criptográfico do usuário (auth.uid()).
Mesmo que um invasor descubra o endpoint do banco ou execute uma chamada direta via API REST pública do Supabase, o banco retornará zero linhas, como se os dados dos outros clientes simplesmente não existissem no universo.
Exemplo de Política RLS Inviolável no Postgres
-- 1. Habilita o RLS obrigatorio na tabela de pedidos
ALTER TABLE orders ENABLE ROW LEVEL SECURITY;
-- 2. Politica de Leitura: Usuários só visualizam pedidos da sua própria organização
CREATE POLICY "Users can only view orders from their organization"
ON orders
FOR SELECT
TO authenticated
USING (
organization_id IN (
SELECT org_id FROM organization_members
WHERE user_id = auth.uid()
)
);
-- 3. Politica de Gravacao: Somente administradores da organizacao podem atualizar pedidos
CREATE POLICY "Only organization admins can update orders"
ON orders
FOR UPDATE
TO authenticated
USING (
EXISTS (
SELECT 1 FROM organization_members
WHERE organization_members.org_id = orders.organization_id
AND organization_members.user_id = auth.uid()
AND organization_members.role = 'admin'
)
);
Por que o RLS é Imbatível?
- Independência de Camadas: Não importa se a requisição veio do Next.js Server Component, de uma Server Action, de um App Mobile em Flutter ou de um script Python: a mesma regra SQL é aplicada pelo PostgreSQL.
- Isolamento Multi-Tenant Garantido: Bloqueia no banco os vazamentos acidentais entre clientes (Cross-Tenant Data Leakage).
- Impossível Burlar com Parâmetros Forjados: O ID do usuário vem diretamente da assinatura criptográfica do JWT verificado pela chave assimétrica do Supabase Auth, e nunca de um parâmetro manipulável no corpo da requisição.
4. O Modelo "Defense-in-Depth": A Tríade de Segurança
A arquitetura recomendada em sistemas de alta criticidade não escolhe entre Middleware ou RLS: ela implementa Defesa em Profundidade em 3 Camadas:
[ Usuário / Requisição de Rede ]
│
▼
┌──────────────────────────────────────────────┐
│ CAMADA 1: Edge Middleware (Vercel) │
│ - Porteiro Visual e UX (Redirecionamento) │
│ - Renovação de Sessão (Auth Token Refresh) │
│ - Rate Limiting e Cabeçalhos HTTP (CSP) │
└──────────────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────────────┐
│ CAMADA 2: Server Actions / RSC (Next.js) │
│ - Validação estrita de tipos com Zod │
│ - Sanitização de strings e regras de tela │
│ - Invalidação de Cache (revalidatePath) │
└──────────────────────┬───────────────────────┘
│
▼
┌──────────────────────────────────────────────┐
│ CAMADA 3: Supabase Postgres RLS (Banco) │
│ - O Cofre Definitivo e Inegociável │
│ - Permissões em nível de linha (auth.uid()) │
│ - Isolamento Absoluto Multi-Tenant │
└──────────────────────────────────────────────┘
| Aspecto | Camada 1: Edge Middleware | Camada 3: Supabase RLS |
|---|---|---|
| Local de Execução | Edge da Vercel (Global) | PostgreSQL (Supabase) |
| Objetivo Primário | Experiência visual e roteamento | Proteção física e integridade de dados |
| Pode ser Burlado? | Sim (chamadas diretas à API) | Não (enforçado pelo motor SQL) |
| Acesso a Dados | Leve (apenas validação de sessão) | Total (granular por coluna e linha) |
| Impacto de Latência | Sub-10ms | Executado nativamente nas queries SQL |
5. Anti-Patterns Críticos para Evitar em Produção
- Executar Queries Pesadas dentro do Middleware: Nunca faça consultas complexas de banco de dados dentro do Edge Middleware. O middleware roda a cada requisição de página; consultas lentas atrasarão todo o carregamento do seu site.
- Utilizar
SUPABASE_SERVICE_ROLE_KEYindiscriminadamente ou em rotas comuns: A Service Role Key desativa todas as proteções de RLS. Ela é estritamente proibida no Frontend e em consultas de tela comuns. Seu uso é restrito a Supabase Edge Functions para webhooks/triggers e, como exceção controlada, em Server Actions administrativas (ex: APIsauth.admin) com autorização de perfil pré-validada no banco. - Utilizar
supabase.auth.getSession()em vez degetUser(): A funçãogetSession()apenas lê o cookie do navegador sem verificar se a assinatura criptográfica foi revogada no banco. Para checagens confiáveis no servidor, use sempresupabase.auth.getUser().
Conclusão: Onde a Segurança Começa e Termina
Tratar o Middleware como mecanismo de segurança de banco de dados é um dos erros arquiteturais mais graves do desenvolvimento web atual.
O Middleware protege a experiência do usuário. O Row Level Security (RLS) protege o caixa, a reputação e os dados da sua empresa.
Quando ambos operam juntos no padrão Defense-in-Depth, você constrói uma fortaleza digital capaz de resistir a auditorias rigorosas de segurança e ataques automatizados.
Se a sua empresa precisa auditar vulnerabilidades, desenhar políticas corporativas de RLS ou estruturar sistemas seguros em Next.js e Supabase, conheça meus serviços de desenvolvimento sob medida ou solicite um diagnóstico de arquitetura comigo.