Cookie de sessão: HttpOnly, Secure e SameSite
Configure o cookie de sessão com HttpOnly, Secure, SameSite e prefixo __Host-, confira o cabeçalho com curl e veja o que essas flags não resolvem.
Um comentário com script passa pela validação e aparece no painel. O script lê document.cookie, manda o identificador de sessão para fora, e alguém entra na conta do administrador sem saber a senha. O cookie de sessão nunca precisou ser lido pelo JavaScript da página; estava visível só porque ninguém configurou o contrário.
A configuração que fecha essa porta cabe numa linha: HttpOnly, Secure, SameSite=Lax e, de preferência, o prefixo __Host- no nome. Ela não elimina XSS nem CSRF, mas reduz muito o que um ataque consegue levar. Abaixo, o que cada atributo faz, o cabeçalho conferido com curl, a configuração no Express atrás de proxy — e, principalmente, o que essas flags não resolvem.

O que cada atributo faz
O navegador guarda o cookie e o devolve ao servidor em cada pedido para o mesmo site. Os atributos, descritos na referência do Set-Cookie no MDN, dizem quando devolver e quem mais pode ver:
- HttpOnly tira o cookie do alcance do JavaScript. Ele continua indo em todo pedido, mas
document.cookienão o mostra, e um script injetado não consegue copiar o valor. - Secure faz o navegador enviar o cookie só por HTTPS. Sem ele, um link
http://qualquer para o seu domínio, numa rede Wi-Fi aberta, entrega a sessão em texto puro. - SameSite controla pedidos vindos de outro site.
Strictnunca envia, nem quando a pessoa clica num link para você — ela chega parecendo deslogada.Laxenvia na navegação por link (GET de nível superior), mas não em POST de outro site, iframe ou fetch cruzado.Noneenvia sempre e exigeSecure. Navegadores diferentes tratam a ausência do atributo de formas diferentes: declare. - Prefixo
__Host-é uma trava do navegador: ele só aceita o cookie comSecure,Path=/e semDomain. Assim, um subdomínio esquecido e comprometido não consegue sobrescrever a sessão do domínio principal.
O cabeçalho certo, conferido
Antes de mexer no framework, vale ver o cabeçalho cru. Subimos um servidor mínimo com o módulo http do Node, só na interface local, e o derrubamos depois do teste:
import http from 'node:http';
const s = http.createServer((req, res) => {
res.setHeader('Set-Cookie', '__Host-sessao=k3J9xQ2vT8pL; Path=/; Max-Age=28800; Secure; HttpOnly; SameSite=Lax');
res.end('ok');
}).listen(8931, '127.0.0.1', () => console.log('ouvindo'));
setTimeout(() => s.close(), 4000);
$ curl -sI http://127.0.0.1:8931/ | grep -i set-cookie
Set-Cookie: __Host-sessao=k3J9xQ2vT8pL; Path=/; Max-Age=28800; Secure; HttpOnly; SameSite=Lax
É essa linha que o navegador precisa receber na sua aplicação real. Confira na aba Rede do DevTools, na resposta do login: se faltar Secure ou HttpOnly, a configuração não pegou. (Num servidor http:// de verdade, o navegador recusaria esse cookie justamente por causa do Secure e do prefixo — aqui o curl só mostra o cabeçalho.)
No Express, atrás de um proxy
Com express-session:
const express = require('express');
const session = require('express-session');
const app = express();
app.set('trust proxy', 1);
app.use(session({
name: '__Host-sessao',
secret: process.env.SESSAO_SEGREDO,
resave: false,
saveUninitialized: false,
cookie: {
httpOnly: true,
secure: true,
sameSite: 'lax',
path: '/',
maxAge: 8 * 60 * 60 * 1000
}
}));
app.post('/login', express.urlencoded({ extended: false }), async (req, res, next) => {
const usuario = await autenticar(req.body.email, req.body.senha);
if (!usuario) return res.status(401).send('Não foi possível entrar.');
req.session.regenerate((erro) => {
if (erro) return next(erro);
req.session.usuarioId = usuario.id;
res.redirect(303, '/painel');
});
});
trust proxyfaz o Express confiar noX-Forwarded-Protodo proxy, como explica o guia do Express atrás de proxies. Sem ele, atrás de um nginx com HTTPS, o express-session acha que a conexão é HTTP e simplesmente não envia o cookie comsecure: true. É o sintoma clássico de “login funciona local e não funciona em produção”.regeneratetroca o identificador no login, para que um identificador plantado antes (fixação de sessão) não continue valendo.maxAgede horas para painel administrativo; dias só onde o risco permite.- A função
autenticaré a sua, com senha guardada como hash, como em login com senha protegida.
Se você precisa compartilhar a sessão entre subdomínios, o Domain volta e o prefixo __Host- sai — uma troca consciente, com os riscos descritos em domínio e cookie.
O que HttpOnly e SameSite não resolvem
HttpOnly impede ler, não usar. Um script injetado na sua página pode chamar fetch('/api/conta', { method: 'POST' }), e o navegador anexa o cookie normalmente, porque o pedido sai do seu próprio site. O atacante não leva a sessão para casa, mas faz o que quiser enquanto a página estiver aberta. Contra XSS, as defesas continuam sendo escapar a saída, validar a entrada e ter uma Content-Security-Policy restritiva.
SameSite=Lax não cobre o mesmo site. Ele barra o POST de formulário vindo de outro site, o CSRF clássico. Mas “site” é o domínio registrável: app. e blog. do mesmo domínio são o mesmo site, e um subdomínio vulnerável consegue enviar pedidos com o cookie. E Lax deixa passar GET de navegação, então rota GET que altera estado continua explorável. Para ações sensíveis, mantenha o token anti-CSRF, como recomenda a folha de prevenção de CSRF da OWASP.
Nada disso vale se o token também estiver no localStorage. Copiar o identificador para o localStorage “para facilitar o front” devolve ao script o que o HttpOnly tirou. O mesmo raciocínio vale para tokens JWT, discutido em JWT que expira. As demais boas práticas de sessão — expiração por inatividade, revogação no logout, rotação — estão na folha de gerenciamento de sessão da OWASP.
Referência: https://developer.mozilla.org/docs/Web/HTTP/Cookies