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

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çãoConfiguraçãoTempo de um hash (um núcleo)
SHA-256nenhuma0,0006 ms (cerca de 1 574 000 por segundo)
scryptN = 2^15, r = 8, p = 1 (32 MiB de memória)104 ms
PBKDF2-HMAC-SHA256600 000 iterações188 ms
scryptN = 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:

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:

Set-Cookie: __Host-sid=7e1f...c9; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=1800
AtributoO que faz
HttpOnlyo 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)
Secureenviado apenas por HTTPS, nunca em texto puro (veja TLS e HTTPS)
SameSite=Lax ou Stricto navegador não anexa o cookie à maioria das requisições entre sites, o que atenua o CSRF
Path=/, sem Domaino 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 / Expirespor 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:

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:

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 servidorToken autocontido (JWT)
O servidor guarda estadosim (cada requisição é uma consulta)não para verificar a assinatura, mas muitas vezes em outro lugar (veja abaixo)
Revogar na horasim, apague a linhadifícil até expirar, a menos que você mantenha uma lista de bloqueio
Tamanhominúsculocentenas de bytes em cada requisição
Bom encaixeuma aplicação web com login própriochamadas entre serviços, APIs de terceiros, acesso delegado de vida curta
Erro comumids previsíveisvida 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):

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:

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:

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.

9. O ciclo de vida da conta

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çaPergunta a fazerControles típicos
Roubo de sessãoSe 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 tokenO 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 contaUm 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 MFAO 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égioUm 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 APIPara 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 tenantsUma 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 stuffingCom 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

  1. Armazenar senhas em texto puro, com um hash rápido como SHA-256 ou MD5, ou sem salt.
  2. Comparar segredos ou hashes com ==.
  3. Ids de sessão previsíveis, ou o mesmo id antes e depois do login.
  4. Um cookie de sessão sem HttpOnly, Secure e SameSite.
  5. Um logout que só apaga o cookie no navegador.
  6. JWTs de vida longa com segredos, sem algoritmo fixado e sem conferir as claims.
  7. Tokens no localStorage em um site que tenha qualquer risco de XSS.
  8. Um GET que muda estado e nenhuma proteção contra CSRF em POSTs autenticados por cookie.
  9. Mensagens diferentes para "usuário inexistente" e "senha errada".
  10. Conferir que o usuário está logado, mas não que o objeto é dele.
  11. Inventar o seu próprio esquema para senhas, tokens ou OAuth em vez de usar uma biblioteca ou um provedor mantidos.
  12. Links de redefinição que nunca expiram, ou que são guardados em texto puro.

11. Coisas a mencionar em uma entrevista

Perguntas que os entrevistadores gostam de acrescentar:

Resumo rápido

  1. A autenticação responde quem; a autorização responde o quê, e é conferida no servidor para cada objeto.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. O OAuth 2.0 delega acesso, o OIDC acrescenta login; use o authorization code flow com PKCE, um redirect URI exato e um state conferido.
  7. 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.
  8. A maioria dos vazamentos são bugs de autorização: confira o objeto, negue por padrão e nunca confie no cliente.

Fontes

  1. OWASP Cheat Sheet Series, Password Storage, Session Management e Cross-Site Request Forgery Prevention. Parâmetros e defesas atuais.
  2. NIST, SP 800-63B: Digital Identity Guidelines, Authentication and Lifecycle Management. Comprimento de senha, verificação de senhas vazadas e tipos de autenticador.
  3. 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).
  4. T. Lodderstedt et al., RFC 9700: Best Current Practice for OAuth 2.0 Security.
  5. OpenID Foundation, OpenID Connect Core 1.0.
  6. M. Jones et al., RFC 7519: JSON Web Token, e Y. Sheffer et al., RFC 8725: JSON Web Token Best Current Practices.
  7. D. M'Raihi et al., RFC 6238: TOTP, Time-Based One-Time Password Algorithm (vetores de teste no Apêndice B).
  8. W3C, Web Authentication: An API for accessing Public Key Credentials.
  9. MDN Web Docs, Set-Cookie. Atributos e prefixos de cookie.

Pratique este tema: Security

Mais guias