Capítulo 16 de 59

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:

  1. 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.
  2. Falhas de Configuração de Matcher: Uma regra de regex mal formatada no config.matcher do middleware pode deixar de interceptar sub-rotas críticas ou requisições pré-carregadas (RSC prefetch).
  3. 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

  1. 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.
  2. Utilizar SUPABASE_SERVICE_ROLE_KEY indiscriminadamente 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: APIs auth.admin) com autorização de perfil pré-validada no banco.
  3. Utilizar supabase.auth.getSession() em vez de getUser(): A função getSession() apenas lê o cookie do navegador sem verificar se a assinatura criptográfica foi revogada no banco. Para checagens confiáveis no servidor, use sempre supabase.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.