Programação Por Equipe DevBras

Capa do artigo: Redirecionamento aberto: valide o next após o login

Redirecionamento aberto: valide o next após o login

O parâmetro next do login pode levar a um site falso. Valide com new URL, compare a origem e evite startsWith. Testado no Node com 9 entradas reais.

Depois do login, o servidor só deve redirecionar para caminhos do próprio site. O jeito confiável de garantir isso é interpretar o parâmetro next (ou returnUrl, redirect) com o mesmo parser de URL que o navegador usa, comparar a origem resultante com a sua e, se não bater, mandar para uma página padrão. Comparar texto com startsWith ou expressão regular falha em casos que parecem internos e não são, e o resultado é um redirecionamento aberto: o seu domínio vira trampolim para uma página falsa de login.

O dano não é vazamento do seu banco; é a confiança. A pessoa confere o endereço no e-mail, vê o seu domínio, faz login de verdade e cai numa cópia pedindo a senha "de novo por segurança". A OWASP trata o problema na folha de referência sobre redirecionamentos não validados, e o catálogo da MITRE o registra como CWE-601. Abaixo está a função de validação em Node, testada contra nove entradas com a saída real, e as variações para destino externo legítimo.

De onde o problema nasce

O parâmetro existe por um bom motivo: a pessoa tentou abrir /pedidos/42, foi mandada para o login e deve voltar para lá depois. O código mais curto lê o parâmetro e devolve um 302 com ele no Location. No teste funciona, porque no teste o valor sempre é um caminho interno.

O navegador, porém, segue o Location como está. Um endereço absoluto leva a outro domínio, e há formas menos óbvias de escrever um: //golpe.test é relativo ao protocolo e troca o host; /\golpe.test também, porque o padrão de URL do WHATWG trata a barra invertida como barra comum em endereços http e https; e javascript: pode executar código se o valor for parar num link.

A função de validação

const ORIGEM = new URL('https://app.lojadobairro.com.br');
const PADRAO = '/painel';

export function destinoSeguro(valor) {
  if (typeof valor !== 'string' || valor === '') return PADRAO;
  let url;
  try {
    url = new URL(valor, ORIGEM);
  } catch {
    return PADRAO;
  }
  if (url.origin !== ORIGEM.origin) return PADRAO;
  return url.pathname + url.search + url.hash;
}

Três decisões fazem a diferença. O new URL(valor, ORIGEM) resolve caminhos relativos contra a sua origem e mantém o host de endereços absolutos, exatamente como o navegador faria. A comparação é de origin inteira (esquema, host e porta), não de pedaço de texto. E o retorno é só caminho, query e fragmento do resultado, nunca o valor original.

O que acontece com entradas reais

Rodamos a função no Node 24 com nove entradas, incluindo os truques mais conhecidos. O domínio golpe.test usa o sufixo .test, reservado para testes:

$ node destino.mjs
"/pedidos/42?aba=itens"                          -> /pedidos/42?aba=itens
"https://golpe.test/login"                       -> /painel
"//golpe.test"                                   -> /painel
"/\\golpe.test"                                  -> /painel
"https://app.lojadobairro.com.br@golpe.test"     -> /painel
"https://app.lojadobairro.com.br.golpe.test/"    -> /painel
"javascript:alert(1)"                            -> /painel
"  https://golpe.test"                           -> /painel
"pedidos/42"                                     -> /pedidos/42

startsWith aceita: https://app.lojadobairro.com.br.golpe.test/ -> host app.lojadobairro.com.br.golpe.test

Alguns casos merecem comentário:

  • O @: tudo antes dele é usuário e senha na sintaxe de URL. O host de verdade é golpe.test.
  • O subdomínio enganoso: app.lojadobairro.com.br.golpe.test começa com o seu domínio, e a última linha mostra que um startsWith aceitaria. O parser revela que o host é outro.
  • javascript:: a origem desse tipo de endereço é a string "null", diferente da sua, então cai no padrão.
  • Espaços no começo: o parser os remove antes de interpretar, como o navegador. Validar o texto cru sem passar pelo parser deixaria esse caso escapar.
  • pedidos/42 sem barra: vira /pedidos/42, resolvido contra a raiz da origem, o que é seguro.

Ligando no login

app.post('/login', express.urlencoded({ extended: false }), async (req, res) => {
  const usuario = await autenticar(req.body.email, req.body.senha);
  if (!usuario) return res.status(401).send('Não foi possível entrar.');
  // ... cria a sessão ...
  res.redirect(303, destinoSeguro(req.query.next));
});

O 303 See Other diz ao navegador para fazer GET no destino depois do POST do login, o que evita reenviar o formulário ao atualizar a página. A diferença entre 301, 302, 303 e 307 está em códigos de status HTTP.

Melhor ainda: o destino nem passa pela URL

Quando o middleware de autenticação barra um pedido para /pedidos/42, ele pode gravar esse caminho na sessão do servidor e mandar a pessoa para /login sem parâmetro. Depois do login, o servidor lê o caminho da sessão, apaga e redireciona. Como o valor foi gravado pelo seu código a partir da rota que ele mesmo atendeu, ninguém de fora monta um link que o altere. Mesmo assim, passe o valor pela mesma função: custa uma linha e protege contra o dia em que alguém mudar a forma de gravar. Se a sessão vive num cookie, ele precisa das proteções de sempre, descritas em cookie HttpOnly.

Quando mandar para fora é legítimo

Checkout de meio de pagamento, central de ajuda noutro domínio: às vezes o produto precisa levar a pessoa para fora. Nesses casos, não aceite o endereço inteiro no parâmetro. Aceite um identificador, como destino=ajuda, e traduza no servidor para uma URL fixa. Se a lista de hosts precisar ser dinâmica, compare url.hostname com igualdade exata contra a lista. Nunca use endsWith('lojadobairro.com.br'): ele aceita golpelojadobairro.com.br, que qualquer um pode registrar.

No login com provedor externo (Google, Microsoft, um IdP corporativo), quem valida o endereço de retorno é o provedor, contra a lista de URLs cadastradas, como em login com PKCE. No redirect depois do seu próprio login, quem valida é você.

Em resumo

  • Interprete o destino com new URL(valor, origem) e compare origin; nada de startsWith, endsWith ou regex.
  • Redirecione só para caminho, query e fragmento do resultado; na dúvida, página padrão.
  • Prefira guardar o destino na sessão em vez da URL.
  • Destino externo só por identificador traduzido no servidor ou lista de hosts com igualdade exata.

Equipe DevBras

Avalie este artigo

Referência: https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html