CS Fundamentals Trainer · Guias
Autenticação e sessões
Armazenamento de senhas (custos de hash medidos), sessões e flags de cookie, JWTs, XSS e CSRF, OAuth 2.0 com PKCE e OpenID Connect, códigos de uso único e passkeys, e os erros de autorização por trás da maioria dos vazamentos.
32 min de leitura
Quase toda aplicação precisa responder a duas perguntas em cada requisição: quem é este? (autenticação) e o que essa pessoa pode fazer? (autorização). Errar a primeira deixa estranhos entrarem; errar a segunda deixa usuários legítimos verem os dados uns dos outros. Este guia cobre como armazenar senhas, como sessões e tokens carregam um login de requisição em requisição, os ataques web que os visam (XSS, CSRF, força bruta), como o "Entrar com o Google" realmente funciona (OAuth 2.0, OpenID Connect e PKCE), segundos fatores e passkeys, e os erros de autorização por trás da maioria dos vazamentos de APIs.
Onde uma afirmação podia ser verificada com código, foi: os tempos de hash, o teste de adulteração de JWT, os códigos de senha de uso único baseados em tempo (TOTP) e o desafio PKCE abaixo foram todos calculados para este guia (Python 3.13 em um único núcleo), e os resultados de TOTP e PKCE foram comparados com os vetores de teste publicados em suas RFCs.
1. Palavras que se confundem
- Identificação: afirmar uma identidade ("eu sou ada@example.com").
- Autenticação: provar isso. A prova vem de algo que você sabe (uma senha), algo que você tem (um celular, uma chave de segurança) ou algo que você é (uma impressão digital). Usar dois tipos diferentes é autenticação multifator (MFA); duas senhas não são dois fatores.
- Autorização: decidir o que uma identidade autenticada pode fazer ("a Ada pode ler o pedido 42?"). É uma verificação separada, feita em toda requisição, pelo servidor.
- Sessão: o estado que lembra um login bem-sucedido para que o usuário não envie uma senha a cada requisição.
- Token: um valor que o cliente apresenta como prova de um login ou de uma permissão. Um id de sessão é um tipo de token.
O HTTP não tem estado: cada requisição é independente. Tudo abaixo é uma forma de anexar a uma requisição, com segurança, o fato de que "esta requisição vem da pessoa que fez login há um minuto".
2. Armazenando senhas
A regra é curta: nunca armazene uma senha, apenas um hash lento e com salt dela, para que um banco de dados roubado não entregue as senhas ao atacante. Três detalhes fazem a diferença.
Um hash rápido é a ferramenta errada. Hashes como o SHA-256 são feitos para ser rápidos, que é exatamente o que um atacante tentando adivinhar senhas quer. Em um núcleo de CPU aqui, o SHA-256 simples calculou cerca de 1,57 milhão de hashes por segundo. Um hash de senha feito para ser lento tem um custo fixo e deliberado por tentativa:
| Função | Configuração | Tempo de um hash (um núcleo) |
|---|---|---|
| SHA-256 | nenhuma | 0,0006 ms (cerca de 1 574 000 por segundo) |
| scrypt | N = 2^15, r = 8, p = 1 (32 MiB de memória) | 104 ms |
| PBKDF2-HMAC-SHA256 | 600 000 iterações | 188 ms |
| scrypt | N = 2^17, r = 8, p = 1 (128 MiB) | 463 ms |
O PBKDF2 com 600 000 iterações permite a um atacante tentar cerca de 296 000 vezes menos senhas por segundo por núcleo do que o SHA-256 simples. Esse é todo o ponto. O custo é pequeno para você (um hash por login) e grande para quem tenta bilhões de palpites. Funções que exigem muita memória, como o Argon2id e o scrypt, são ainda melhores, porque também tornam caro construir hardware rápido (GPUs, chips sob medida).
Cada senha recebe o seu próprio salt aleatório. Um salt são bytes aleatórios guardados ao lado do hash e misturados a ele. Faz dois usuários com a mesma senha produzirem hashes diferentes e torna inúteis as tabelas pré-calculadas ("rainbow tables"). Use pelo menos 16 bytes aleatórios do gerador aleatório seguro do sistema operacional.
Compare em tempo constante. Comparar hashes com == pode parar no primeiro byte diferente, e o tempo que isso leva pode vazar informação. Use hmac.compare_digest, crypto.timingSafeEqual, subtle.ConstantTimeCompare ou CryptographicOperations.FixedTimeEquals.
Estes exemplos mostram a forma de um hasher de senhas. Eles não são para ser copiados para produção. Use o hasher do seu framework ou de uma biblioteca mantida (o PasswordHasher do ASP.NET Core Identity, o make_password do Django, argon2-cffi, bcrypt, o pacote argon2 para Node), que já cuidam da codificação, da verificação de parâmetros, das atualizações e dos casos extremos que os exemplos abaixo só insinuam. Se você escrever um, os dois pontos que os exemplos tentam mostrar são: guarde os parâmetros e o salt junto com o hash, e nunca execute o passo caro em uma thread de que outras requisições precisam.
import hashlib, hmac, os
def hash_password(password: str) -> str:
salt = os.urandom(16)
key = hashlib.scrypt(password.encode(), salt=salt, n=2**15, r=8, p=1, maxmem=2**26)
# store the parameters with the hash so they can be raised later
return f"scrypt$15$8$1${salt.hex()}${key.hex()}"
def verify_password(password: str, stored: str) -> bool:
_, log_n, r, p, salt, key = stored.split("$")
candidate = hashlib.scrypt(password.encode(), salt=bytes.fromhex(salt),
n=2**int(log_n), r=int(r), p=int(p), maxmem=2**26)
return hmac.compare_digest(candidate, bytes.fromhex(key))
# From async code (FastAPI, aiohttp) this is a blocking call: run it off the event loop.
# ok = await asyncio.to_thread(verify_password, password, stored)
import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
import { promisify } from "node:util";
const scryptAsync = promisify(scrypt); // runs on libuv's thread pool, not on the event loop
const opts = { N: 2 ** 15, r: 8, p: 1, maxmem: 64 * 1024 * 1024 };
export async function hashPassword(password) {
const salt = randomBytes(16);
const key = await scryptAsync(password, salt, 32, opts);
return `scrypt$15$8$1$${salt.toString("hex")}$${key.toString("hex")}`;
}
export async function verifyPassword(password, stored) {
const [, logN, r, p, salt, key] = stored.split("$");
const want = Buffer.from(key, "hex");
const candidate = await scryptAsync(password, Buffer.from(salt, "hex"), want.length,
{ ...opts, N: 2 ** Number(logN), r: Number(r), p: Number(p) });
return timingSafeEqual(candidate, want);
}
package password
import (
"crypto/rand"
"crypto/subtle"
"encoding/base64"
"errors"
"fmt"
"strings"
"golang.org/x/crypto/argon2"
)
// Current cost: the OWASP minimum for Argon2id (19 MiB of memory, 2 passes, 1 lane).
const (
memoryKiB = 19 * 1024
passes = 2
lanes = 1
keyLen = 32
)
var (
enc = base64.RawStdEncoding
ErrBadHash = errors.New("unrecognised password hash")
)
// Hash returns a PHC-format string: $argon2id$v=19$m=19456,t=2,p=1$<salt>$<key>
func Hash(password string) (string, error) {
salt := make([]byte, 16)
if _, err := rand.Read(salt); err != nil {
return "", err
}
key := argon2.IDKey([]byte(password), salt, passes, memoryKiB, lanes, keyLen)
return fmt.Sprintf("$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
argon2.Version, memoryKiB, passes, lanes, enc.EncodeToString(salt), enc.EncodeToString(key)), nil
}
// Verify reports whether password matches the stored hash. An error means the
// stored value is not a hash this code understands, not that the password is wrong.
func Verify(password, stored string) (bool, error) {
parts := strings.Split(stored, "$") // "", "argon2id", "v=19", "m=..,t=..,p=..", salt, key
if len(parts) != 6 || parts[1] != "argon2id" {
return false, ErrBadHash
}
var version int
if _, err := fmt.Sscanf(parts[2], "v=%d", &version); err != nil || version != argon2.Version {
return false, ErrBadHash
}
var m, t uint32
var p uint8
if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &m, &t, &p); err != nil {
return false, ErrBadHash
}
// Refuse absurd parameters from a corrupted record rather than allocating gigabytes.
if m < 8 || m > 1<<20 || t < 1 || t > 10 || p < 1 || p > 16 {
return false, ErrBadHash
}
salt, err := enc.DecodeString(parts[4])
if err != nil || len(salt) < 8 {
return false, ErrBadHash
}
want, err := enc.DecodeString(parts[5])
if err != nil || len(want) < 16 || len(want) > 64 {
return false, ErrBadHash
}
got := argon2.IDKey([]byte(password), salt, t, m, p, uint32(len(want)))
return subtle.ConstantTimeCompare(got, want) == 1, nil
}
var salt = RandomNumberGenerator.GetBytes(16);
byte[] key = Rfc2898DeriveBytes.Pbkdf2(password, salt, 600_000, HashAlgorithmName.SHA256, 32);
// later: recompute with the stored salt and compare with CryptographicOperations.FixedTimeEquals
// (the C# sample is only the key derivation: storing the parameters and checking them is up to you)
Não execute o hash no event loop. Um hash de senha é trabalho de CPU deliberado e pesado, então, em um servidor de thread única, ele não pode rodar na thread que atende todos os outros. O scryptSync no Node.js (ou o hashlib.scrypt chamado diretamente dentro de um async def) bloqueia essa thread durante todo o cálculo. Em um teste, com as configurações acima em um contêiner de 2 núcleos, uma rajada de quatro logins pelo scryptSync atrasou um timer de 10 ms, que representa todas as outras requisições, em cerca de 380 a 440 ms, enquanto o scrypt assíncrono o atrasou em menos de 5 ms e terminou os mesmos quatro logins em cerca de metade do tempo. Trate esses números como uma ilustração, não um benchmark. A API assíncrona move o trabalho para uma worker thread, mas essas threads também são limitadas (o pool de threads do Node tem quatro por padrão), então uma rajada de logins ainda forma fila. Limitar a taxa dos logins e limitar quantos hashes rodam ao mesmo tempo impede que uma enxurrada esgote CPU e memória.
Mais pontos:
- Use uma biblioteca mantida ou o hasher de senhas do seu framework em vez de montar um (veja acima).
- Escolha os parâmetros a partir da orientação atual (a OWASP Password Storage Cheat Sheet lista os mínimos para Argon2id, scrypt, bcrypt e PBKDF2 e é atualizada conforme o hardware melhora), depois meça nos seus próprios servidores: um login deve levar uma fração de segundo, não segundos, e uma rajada de logins não deve esgotar memória nem CPU.
- Guarde os parâmetros com o hash (como acima) para poder aumentar o custo depois. No próximo login bem-sucedido, se os parâmetros guardados forem mais antigos que os atuais, faça o hash da senha de novo e substitua-o.
- O bcrypt ainda é aceitável, mas trunca as senhas em 72 bytes; fazer um pré-hash é um contorno conhecido e uma fonte conhecida de erros.
- Um pepper (uma chave secreta misturada, mantida fora do banco de dados em um cofre de segredos ou em um HSM) acrescenta proteção se apenas o banco de dados vazar. É uma camada extra, não um substituto do que foi dito acima.
- Política de senhas: a orientação atual do NIST (SP 800-63B) favorece o comprimento em vez de regras de complexidade: permita frases-senha longas (pelo menos 64 caracteres) e todos os caracteres, confira as senhas novas contra listas de senhas vazadas e comuns e não force trocas periódicas sem motivo. Não trunque nem modifique senhas em silêncio.
- Nunca registre senhas em log, nunca as envie por e-mail e nunca as ponha em URLs.
3. Sessões: o cookie que lembra um login
O projeto clássico: depois de um login bem-sucedido, o servidor cria um id de sessão aleatório, guarda no servidor o que precisa saber sobre a sessão (id do usuário, hora de criação, último acesso) e envia o id ao navegador em um cookie. O navegador o devolve automaticamente a cada requisição.
Diagram: A server-side session
O id de sessão é um segredo tão bom quanto a senha enquanto viver, então:
- Faça-o impossível de adivinhar: pelo menos 128 bits de um gerador aleatório criptograficamente seguro, nunca um contador, um timestamp ou um hash de dados do usuário.
- Guarde-o no servidor em um armazenamento compartilhado (um banco de dados ou Redis), não na memória de um servidor, ou um balanceador de carga enviará o usuário a um servidor que nunca ouviu falar dele. Guarde apenas um hash do id se quiser que uma tabela de sessões vazada seja inútil.
- Crie um id novo no login (e quando os privilégios mudam). Caso contrário, um atacante que plantou um id de sessão conhecido no navegador da vítima (session fixation) fica logado no momento em que a vítima se autentica.
- Faça as sessões expirarem de duas formas: um timeout de inatividade (sem atividade por, digamos, 30 minutos) e um timeout absoluto (no máximo alguns dias a semanas, por mais ativa que seja).
- Faça o logout no servidor: apague a linha da sessão. Apagar o cookie só no navegador deixa um cookie roubado funcionando.
- Encerre as outras sessões do usuário quando ele trocar a senha ou ativar a MFA.
Atributos de cookie
Set-Cookie: __Host-sid=7e1f...c9; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=1800
| Atributo | O que faz |
|---|---|
HttpOnly | o JavaScript não consegue ler o cookie, então um bug de XSS não consegue copiá-lo (ainda pode agir como o usuário, veja a seção 5) |
Secure | enviado apenas por HTTPS, nunca em texto puro (veja TLS e HTTPS) |
SameSite=Lax ou Strict | o navegador não anexa o cookie à maioria das requisições entre sites, o que atenua o CSRF |
Path=/, sem Domain | o cookie pertence exatamente a este host, não aos seus subdomínios |
prefixo de nome __Host- | o navegador recusa o cookie a menos que seja Secure, tenha Path=/ e nenhum Domain, de modo que um subdomínio irmão não possa sobrescrevê-lo |
Max-Age / Expires | por quanto tempo o navegador o guarda |
Mesmo site não é o mesmo que mesma origem. Uma origem é esquema, host e porta (https://app.example.com). Um site é mais grosseiro: o esquema mais o domínio registrável, aqui https://example.com. Então https://app.example.com e https://blog.example.com são origens diferentes, mas o mesmo site. O SameSite compara sites, o que tem duas consequências:
SameSite=LaxouStrictnão impede requisições que vêm de um subdomínio irmão. Seblog.example.comhospeda conteúdo de usuários, tem um bug de XSS ou foi tomado, as requisições dele paraapp.example.comainda levam o cookie. Confira o cabeçalhoOriginou use também um token CSRF, e trate todo subdomínio do seu domínio registrável como dentro do seu limite de confiança.- O
__Host-protege o seu cookie de ser sobrescrito ou ofuscado por um subdomínio irmão (injeção de cookie ou "cookie tossing"), porque ele não pode ter o atributoDomain. Não remove o primeiro problema e não torna inofensivo um irmão comprometido.
Regras do navegador como o CORS e as verificações de Origin funcionam sobre origens, enquanto o SameSite funciona sobre sites, então mantenha os dois separados ao raciocinar sobre uma requisição. Domínios listados na Public Suffix List (como github.io) contam como sites separados por subdomínio.
4. Tokens e JWTs
Um JSON Web Token (JWT) é um token que o servidor consegue verificar sem consultar nada. Tem três partes em base64url unidas por pontos: um cabeçalho, um payload de claims (quem, até quando) e uma assinatura sobre as duas primeiras partes.
Aqui está um de verdade, construído à mão com HMAC-SHA-256 e um segredo do servidor:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyLTQyIiwicm9sZSI6Im1lbWJlciIsImV4cCI6MTg5MzQ1NjAwMH0.Ed1tR05nS_KWHgBfJvJLBvr1Z_9bla8UJFlqQ-LDSm8
Duas coisas a notar:
- O payload não é secreto. Ele é apenas codificado: qualquer um que tenha o token lê
{"sub":"user-42","role":"member","exp":1893456000}. Nunca ponha segredos ou dados privados nele. - A assinatura é o que o protege. Mudar
roleparaadminno payload mantendo a assinatura antiga fez a verificação falhar (False). Só quem tem a chave pode produzir um token válido.
Como nada é consultado, um JWT escala bem entre muitos serviços. O custo é a revogação: o servidor não consegue cancelar um facilmente antes do seu exp, porque não guardou registro. É por isso que os tokens de acesso devem ser de vida curta (minutos), acompanhados de um refresh token guardado no servidor, rotacionado a cada uso e revogável.
| Id de sessão no servidor | Token autocontido (JWT) | |
|---|---|---|
| O servidor guarda estado | sim (cada requisição é uma consulta) | não para verificar a assinatura, mas muitas vezes em outro lugar (veja abaixo) |
| Revogar na hora | sim, apague a linha | difícil até expirar, a menos que você mantenha uma lista de bloqueio |
| Tamanho | minúsculo | centenas de bytes em cada requisição |
| Bom encaixe | uma aplicação web com login próprio | chamadas entre serviços, APIs de terceiros, acesso delegado de vida curta |
| Erro comum | ids previsíveis | vida longa, segredos no payload |
As duas colunas não são tão separadas quanto a tabela sugere. Um sistema completo construído sobre JWTs geralmente ainda mantém estado no servidor: refresh tokens rotacionados e revogáveis, um registro de se a conta foi desativada ou a senha foi trocada e dados de autorização conferidos no servidor porque as claims de um token podem estar obsoletas. Por outro lado, um cookie de sessão não é seguro por si só: ids previsíveis, flags ausentes, nenhum id novo no login, nenhuma expiração ou nenhuma defesa contra CSRF o deixam tão exposto quanto.
Então trate isto como um padrão, não uma regra universal. Para uma aplicação web comum com usuários próprios e um backend, um cookie de sessão costuma ser o ponto de partida mais simples, porque o logout e a revogação são uma única exclusão. Recorra aos JWTs quando tiver um motivo, como vários serviços verificando tokens emitidos por um, ou acesso delegado para terceiros, e então planeje o estado de que eles ainda precisam.
Regras quando você usa JWTs (veja a RFC 8725):
- Fixe o algoritmo que você espera ao verificar. Algumas bibliotecas antigas aceitavam um token cujo cabeçalho dizia
"alg": "none"(nenhuma assinatura), ou deixavam um atacante trocar de um algoritmo assimétrico para um simétrico usando a chave pública como segredo. - Confira as claims:
exp(não expirado),iss(o emissor em que você confia),aud(destinado a você) enbf, se usado. - Use uma chave longa e aleatória para o HMAC, ou um algoritmo assimétrico (RS256, ES256, EdDSA) quando muitos serviços precisam verificar tokens que um serviço emite, de modo que os verificadores guardem só uma chave pública.
- Onde o cliente guarda o token importa. No
localStorage, qualquer script da página, inclusive os injetados, pode lê-lo. Em um cookieHttpOnly, os scripts não podem, mas então é preciso proteção contra CSRF.
5. Ataques que visam logins
O cross-site scripting (XSS) é um script fornecido pelo atacante rodando dentro da sua página. Pode ler qualquer coisa na página e no localStorage e pode enviar requisições como o usuário. O HttpOnly impede que ele copie o cookie de sessão, mas não que o use, então a correção real é prevenir o XSS: escapar a saída para o seu contexto, usar um framework que faça isso por padrão e acrescentar uma Content Security Policy como segunda linha de defesa.
O cross-site request forgery (CSRF) explora o fato de que os navegadores anexam cookies automaticamente. Uma página maliciosa pode fazer o navegador da vítima enviar POST /transfer ao seu site, com o cookie da vítima. Defesas, em geral combinadas:
- Cookies
SameSite=Lax(ouStrict). Alguns navegadores (Chrome e Edge) já tratam cookies comoLaxpor padrão, mas defina isso explicitamente. - Nunca mude estado com
GET. OLaxainda envia cookies em navegaçõesGETde nível superior. - Um token CSRF: um valor aleatório ligado à sessão que a página inclui em toda requisição que muda estado, e que o servidor confere.
- Conferir o cabeçalho
Originnas requisições que mudam estado. - APIs que leem credenciais de um cabeçalho
Authorization(e não de um cookie) não estão abertas ao CSRF, porque o navegador não adiciona esse cabeçalho sozinho.
Força bruta e credential stuffing. Os atacantes tentam senhas comuns contra uma conta, ou repetem contra a sua pares de e-mail e senha vazados de outros sites. As pessoas reutilizam senhas, então isso funciona. Defesas: limite a taxa por conta e por endereço, desacelere as falhas repetidas em vez de bloquear contas permanentemente (um bloqueio é, ele próprio, uma forma de atacar um usuário), rejeite senhas vazadas no cadastro, observe logins de lugares novos e ofereça MFA.
Enumeração de contas. "Nenhuma conta com esse e-mail" e "senha errada" dizem a um atacante quais e-mails estão cadastrados. Use uma mensagem só para os dois ("e-mail ou senha incorretos") e faça as respostas de cadastro e de redefinição de senha serem iguais, exista ou não o endereço ("se esse endereço estiver cadastrado, enviamos um link").
Clickjacking: uma página sua dentro de um frame oculto em outro site. Proíba o enquadramento com Content-Security-Policy: frame-ancestors 'none'.
6. OAuth 2.0 e OpenID Connect: "Entrar com ..."
O OAuth 2.0 deixa um usuário dar a uma aplicação acesso limitado a algo mantido por outro serviço sem lhe dar uma senha: "deixe este app ler a minha agenda". Trata de autorização. O OpenID Connect (OIDC) é uma camada fina por cima que acrescenta autenticação: um ID token (um JWT) que diz à aplicação quem fez login. O "Entrar com o Google" é OIDC.
Os papéis: o usuário (dono do recurso), o cliente (a aplicação), o servidor de autorização (o Google, o seu provedor de identidade) e o servidor de recursos (a API que guarda os dados).
O fluxo a usar para aplicações web, móveis e de página única é o authorization code flow com PKCE:
Diagram: Authorization code flow with PKCE
Por que ele é construído assim:
- O navegador carrega apenas um code de vida curta, nunca o token em si. A aplicação troca o code por tokens em uma chamada direta ao servidor.
- O PKCE (Proof Key for Code Exchange, RFC 7636) impede que quem roubar o code o use. A aplicação inventa um
code_verifieraleatório, envia só o seu hash (code_challenge = BASE64URL(SHA-256(verifier))) no início e revela o verifier quando troca o code. Um ladrão que tem apenas o code não conhece o verifier. O verifier de exemplo do próprio padrão,dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk, produziu o desafioE9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cMna verificação deste guia, exatamente como publicado. - O parâmetro
stateé um valor aleatório que a aplicação define e confere na volta, o que previne o CSRF no próprio login. - Os scopes listam o que está sendo pedido (
openid email,calendar.readonly); o usuário os vê na tela de consentimento. Peça o mínimo de que precisa. - Os redirect URIs precisam coincidir exatamente com o que você registrou. Curingas e open redirects deixam um atacante desviar o code para o seu próprio site.
- O antigo implicit flow (tokens direto no fragmento da URL) e o password grant (o app coleta a senha do usuário) são desencorajados pela melhor prática de segurança atual (RFC 9700); use o code flow.
- Valide o ID token como qualquer JWT: assinatura (contra as chaves publicadas do provedor),
iss,aud(o seu client id),expe ononceque você enviou. Use uma biblioteca OIDC mantida para isso. - Um access token é para a API; um ID token é para a aplicação saber quem é o usuário. Não envie um ID token a uma API como se fosse um access token.
7. Segundos fatores, códigos de uso único e passkeys
Uma senha sozinha é fraca porque pode ser adivinhada, reutilizada ou sofrer phishing. Um segundo fator faz uma senha roubada não bastar.
O TOTP (senhas de uso único baseadas em tempo, RFC 6238) é o código de seis dígitos de um app autenticador. Os dois lados compartilham um segredo, e cada um calcula HMAC(segredo, floor(tempo / 30 s)) e tira seis dígitos do resultado. Não há chamada de rede entre o app e o servidor. O cálculo foi implementado em poucas linhas e conferido com a RFC: com o segredo de teste da RFC 12345678901234567890, o tempo 59 s deu 94287082 e o tempo 1 111 111 109 s deu 07081804, os valores publicados.
import hmac, hashlib, struct
def totp(secret: bytes, now: float, step: int = 30, digits: int = 6) -> str:
counter = int(now // step)
mac = hmac.new(secret, struct.pack(">Q", counter), hashlib.sha1).digest()
offset = mac[-1] & 0x0F # "dynamic truncation"
number = struct.unpack(">I", mac[offset:offset + 4])[0] & 0x7FFFFFFF
return str(number % 10**digits).zfill(digits)
Notas de implementação: aceite o código da janela de 30 segundos anterior e da seguinte para permitir deriva de relógio, nunca aceite o mesmo código duas vezes, limite a taxa das tentativas (existe apenas um milhão de códigos de seis dígitos), guarde o segredo criptografado em repouso e emita códigos de recuperação na configuração. Um código enviado por SMS é melhor que nada, mas pode ser interceptado (SIM swapping), então prefira um app ou uma chave.
O phishing é a fraqueza dos códigos de uso único. Um site falso pode pedir a senha e o código atual e repassar os dois na hora.
As passkeys (WebAuthn / FIDO2) foram feitas para resistir a esse ataque. O dispositivo cria um par de chaves por site: a chave privada nunca sai do dispositivo (ou do chaveiro sincronizado do usuário), o servidor guarda a chave pública e, no login, o dispositivo assina um desafio do servidor. O navegador inclui a origem do site no que é assinado, então um domínio parecido não consegue obter uma assinatura utilizável. Não há segredo compartilhado para roubar do seu banco de dados e nada para digitar. Isso torna as passkeys resistentes a phishing de credenciais, um grande passo além das senhas e dos códigos. Não torna uma conta impossível de comprometer: um usuário ainda pode ser enganado a aprovar uma requisição em um dispositivo que possui, um atacante que passa por um fluxo fraco de recuperação de conta pode cadastrar a sua própria passkey, e um malware em um dispositivo desbloqueado pode agir como o usuário. Os caminhos de recuperação e de cadastro passam a ser o elo mais fraco, então proteja-os com o mesmo cuidado do login. Para produtos novos, ofereça passkeys e mantenha uma opção de senha mais TOTP ou recuperação para usuários que não as têm.
8. Autorização: o que o usuário pode fazer
A autenticação só diz quem. Depois dela, toda requisição ainda precisa ser conferida contra o que aquela identidade pode fazer.
- Confira no servidor, em toda requisição, para o objeto específico. A falha clássica é o IDOR (insecure direct object reference, também chamada de autorização quebrada em nível de objeto):
GET /orders/42devolve o pedido a qualquer usuário logado, então mudar o número na URL lê os pedidos de outras pessoas. A correção é conferir a posse ou a permissão do objeto no handler (ou na consulta:WHERE id = $1 AND owner_id = $2). - Negue por padrão. Um endpoint novo deve ser proibido até que alguém conceda acesso.
- Escolha um modelo que sirva: RBAC (baseado em papéis: admin, editor, leitor) para a maioria das aplicações; ABAC ou regras baseadas em relacionamento ("editores deste projeto") quando o acesso depende do objeto ou do seu dono. Mantenha poucos papéis e a verificação em um só lugar.
- Não confie no cliente. Esconder um botão é uma conveniência, não um controle. Campos ocultos, valores de
roleem um corpo JSON e flagsisAdminem um cookie podem ser todos alterados pelo usuário. - Devolva
403ou404de forma consistente. Devolver404para objetos que o usuário não deveria saber que existem evita confirmar que existem (veja projetando uma API REST). - Privilégio mínimo também para serviços: uma conta de banco de dados que só pode fazer o que o serviço precisa e tokens com scopes estreitos.
- Em sistemas multi-tenant, faça do tenant parte de toda consulta e, onde o banco de dados suportar, imponha isso lá também (veja projetando um sistema multi-tenant).
- Registre em log logins, falhas, mudanças de senha e de MFA e negações de permissão, com usuário, hora e endereço, mas nunca a senha nem o token.
9. O ciclo de vida da conta
- Cadastro e verificação de e-mail: envie um link de uso único com um token longo e aleatório que expira, e trate o endereço como não verificado até que seja usado.
- Redefinição de senha: gere um token aleatório de pelo menos 128 bits, guarde só o seu hash, torne-o de uso único e de vida curta (cerca de uma hora) e mostre a mesma resposta exista ou não o endereço. Depois de uma redefinição, encerre todas as sessões do usuário. Não envie uma senha nova por e-mail.
- Trocar um e-mail ou uma senha: peça antes a senha atual (ou uma verificação de MFA recente) e avise o endereço antigo.
- Lembrar de mim: um token separado de vida longa, guardado com hash e rotacionado a cada uso, restrito a um dispositivo, revogável a partir de uma lista de sessões do usuário.
- Excluir uma conta: remova também as sessões e os tokens, e planeje o que acontece com os dados (veja suas obrigações de privacidade).
Uma checklist de modelo de ameaças para revisões
Ao revisar um projeto de autenticação, percorra estas ameaças e pergunte o que detém cada uma. Uma revisão real acrescenta as ameaças específicas do seu produto.
| Ameaça | Pergunta a fazer | Controles típicos |
|---|---|---|
| Roubo de sessão | Se um id de sessão ou token vazar (XSS, um log, malware), quanto o atacante pode fazer e por quanto tempo? | cookies HttpOnly/Secure, timeouts de inatividade e absolutos curtos, id novo no login, reautenticação para ações sensíveis, uma lista de sessões que o usuário pode revogar |
| Replay de refresh token | O que acontece se um refresh token for usado duas vezes? | rotação a cada uso, detecção de reuso que revoga toda a família de tokens, vínculo a um dispositivo, guardar apenas um hash |
| Abuso da recuperação de conta | Um atacante pode tomar uma conta por "esqueci a senha", troca de e-mail ou pela equipe de suporte? | tokens de redefinição de uso único, com hash e vida curta, aviso ao endereço antigo, um atraso ou verificação extra para mudanças arriscadas, uma resposta idêntica para contas desconhecidas |
| Reset e rebaixamento da MFA | O segundo fator pode ser removido ou contornado mais facilmente do que foi adicionado? | a mesma força de verificação para redefinir e para entrar, códigos de recuperação mostrados uma vez, alertas, nenhum recuo silencioso para SMS |
| Escalada de privilégio | Um usuário comum consegue chegar a funções de admin, ou dar a si mesmo um papel? | verificações no servidor em toda requisição, papéis não tirados do cliente, negar por padrão, caminhos de admin separados com autenticação mais forte |
| Autorização de objetos da API | Para cada endpoint que recebe um id, a posse ou a permissão é conferida para aquele objeto? | a verificação no handler ou na consulta (WHERE id = $1 AND owner_id = $2), testes que chamam cada endpoint como outro usuário |
| Acesso entre tenants | Uma requisição, um cache, um job em segundo plano ou um relatório pode cruzar de um tenant para outro? | id do tenant em toda consulta e chave de cache, imposição no nível do banco de dados quando possível, testes com dois tenants |
| Força bruta e credential stuffing | Com que rapidez um atacante consegue tentar senhas, e você perceberia? | limites de taxa por conta e endereço, verificação de senhas vazadas, MFA, alertas sobre logins incomuns |
10. Erros comuns
- Armazenar senhas em texto puro, com um hash rápido como SHA-256 ou MD5, ou sem salt.
- Comparar segredos ou hashes com
==. - Ids de sessão previsíveis, ou o mesmo id antes e depois do login.
- Um cookie de sessão sem
HttpOnly,SecureeSameSite. - Um logout que só apaga o cookie no navegador.
- JWTs de vida longa com segredos, sem algoritmo fixado e sem conferir as claims.
- Tokens no
localStorageem um site que tenha qualquer risco de XSS. - Um
GETque muda estado e nenhuma proteção contra CSRF emPOSTs autenticados por cookie. - Mensagens diferentes para "usuário inexistente" e "senha errada".
- Conferir que o usuário está logado, mas não que o objeto é dele.
- Inventar o seu próprio esquema para senhas, tokens ou OAuth em vez de usar uma biblioteca ou um provedor mantidos.
- Links de redefinição que nunca expiram, ou que são guardados em texto puro.
11. Coisas a mencionar em uma entrevista
- Separe a autenticação da autorização e diga como cada uma aparece em uma requisição.
- Senhas: hash lento, com salt e que exige muita memória (Argon2id, scrypt, bcrypt ou PBKDF2), comparação em tempo constante, parâmetros guardados e atualizáveis, nenhum hash rápido. Cite a troca de custo: de 100 a 500 ms por login contra bilhões de palpites.
- Sessões versus JWTs: uma consulta e revogação fácil versus verificação barata entre serviços e revogação difícil; diga que a escolha é um padrão para a situação, que sistemas JWT reais mantêm estado de refresh token e de conta no servidor e que uma sessão só é tão segura quanto a sua implementação.
- Flags de cookie e contra o que cada uma defende.
- XSS, CSRF e credential stuffing: uma frase sobre como cada um funciona e a principal defesa.
- OAuth 2.0 e OIDC: explique o code flow com PKCE e a diferença entre um access token e um ID token.
- MFA: TOTP, SMS e passkeys, e por que as passkeys resistem a phishing de credenciais (assinaturas vinculadas à origem) enquanto os fluxos de recuperação e o comprometimento do dispositivo continuam sendo riscos.
- Autorização: no servidor, por objeto, negar por padrão, IDOR.
Perguntas que os entrevistadores gostam de acrescentar:
- "Por que usar salt, se o hash é lento?" Os salts fazem o hash de cada usuário ser diferente e derrotam as tabelas pré-calculadas, de modo que o atacante precisa atacar cada senha separadamente.
- "Onde você guarda um JWT em um navegador?" Qualquer um tem riscos: o
localStorageé legível por script injetado; um cookieHttpOnlynão é, mas precisa de defesas contra CSRF. Uma escolha comum é um access token de vida curta em memória mais um refresh token em um cookieHttpOnly,Secure,SameSite. - "Como você faz o logout de um usuário com JWT?" Deixe-o expirar rápido, revogue o refresh token e mantenha uma lista de bloqueio de ids de token apenas onde for necessário.
- "Contra o que o PKCE protege?" Contra um authorization code roubado ser resgatado por alguém que não iniciou o fluxo.
- "Um usuário relata dados de outra pessoa na sua conta. Onde você olha?" Autorização em nível de objeto, cache de respostas personalizadas e uma sessão ou token compartilhado entre usuários.
- "Como você projetaria a redefinição de senha?" Um token de uso único, com hash e vida curta; a mesma resposta para endereços desconhecidos; todas as sessões encerradas depois.
Resumo rápido
- A autenticação responde quem; a autorização responde o quê, e é conferida no servidor para cada objeto.
- Faça o hash das senhas com uma função lenta, com salt e que exija muita memória, e compare em tempo constante. Aqui, o SHA-256 rodou cerca de 1,57 milhão de vezes por segundo por núcleo, enquanto o PBKDF2 com 600 000 iterações levou 188 ms e o scrypt com 128 MiB levou 463 ms.
- Uma sessão é um id aleatório em um cookie
HttpOnly,Secure,SameSite, sustentado por um armazenamento no servidor com ids novos no login e um logout de verdade. - O payload de um JWT é legível por qualquer um e a sua assinatura impede a adulteração; mantenha-o de vida curta, fixe o algoritmo e confira as claims. Sessões são um padrão sensato para uma única aplicação web, e um sistema JWT completo ainda precisa de estado no servidor para refresh tokens e revogação.
- XSS, CSRF, credential stuffing e enumeração têm cada um uma defesa específica; o HttpOnly não impede o XSS de agir como o usuário.
- O OAuth 2.0 delega acesso, o OIDC acrescenta login; use o authorization code flow com PKCE, um redirect URI exato e um
stateconferido. - O TOTP é um HMAC sobre um contador de 30 segundos e pode ser repassado por um site falso; as passkeys assinam um desafio vinculado à origem do site e assim resistem a phishing de credenciais, embora a recuperação de conta e o cadastro ainda possam ser atacados.
- A maioria dos vazamentos são bugs de autorização: confira o objeto, negue por padrão e nunca confie no cliente.
Fontes
- OWASP Cheat Sheet Series, Password Storage, Session Management e Cross-Site Request Forgery Prevention. Parâmetros e defesas atuais.
- NIST, SP 800-63B: Digital Identity Guidelines, Authentication and Lifecycle Management. Comprimento de senha, verificação de senhas vazadas e tipos de autenticador.
- D. Hardt, RFC 6749: The OAuth 2.0 Authorization Framework, e N. Sakimura et al., RFC 7636: Proof Key for Code Exchange (o vetor de teste da seção 6 vem do seu Apêndice B).
- T. Lodderstedt et al., RFC 9700: Best Current Practice for OAuth 2.0 Security.
- OpenID Foundation, OpenID Connect Core 1.0.
- M. Jones et al., RFC 7519: JSON Web Token, e Y. Sheffer et al., RFC 8725: JSON Web Token Best Current Practices.
- D. M'Raihi et al., RFC 6238: TOTP, Time-Based One-Time Password Algorithm (vetores de teste no Apêndice B).
- W3C, Web Authentication: An API for accessing Public Key Credentials.
- MDN Web Docs, Set-Cookie. Atributos e prefixos de cookie.
Pratique este tema: Security