Autenticação JWT

✓ Resposta: Por que SHA-256 aqui e password_hash na senha: senha tem entropia baixa e sofre ataque de dicionário, então precisa de KDF lento. Token de 256 bits aleatórios não tem dicionário — o hash rápido só serve para que um vazamento do banco não entregue tokens utilizáveis.

<?php

declare(strict_types=1);

// CREATE TABLE refresh_tokens (
//     id          INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
//     token_hash  CHAR(64)     NOT NULL UNIQUE,   -- SHA-256 em hex
//     usuario_id  INT UNSIGNED NOT NULL,
//     expires_at  DATETIME     NOT NULL,
//     revogado_em DATETIME     NULL,
//     criado_em   TIMESTAMP    NOT NULL DEFAULT CURRENT_TIMESTAMP,
//     INDEX idx_rt_usuario (usuario_id),
//     INDEX idx_rt_expira (expires_at),
//     CONSTRAINT fk_rt_usuario FOREIGN KEY (usuario_id)
//         REFERENCES usuarios(id) ON DELETE CASCADE
// ) ENGINE=InnoDB;

declare(strict_types=1);

final class RefreshTokenRepositorio
{
    public function __construct(private readonly PDO $pdo) {}

    /**
     * Guarda o HASH, nunca o token. Se o banco vazar, os tokens continuam
     * inúteis — mesma lógica de senha. Aqui SHA-256 basta (diferente de
     * senha) porque o token já é aleatório de alta entropia: não há
     * dicionário para atacar, então não é preciso KDF lento.
     */
    public function salvar(string $token, int $usuarioId, DateTimeImmutable $expiraEm): void
    {
        $stmt = $this->pdo->prepare(
            'INSERT INTO refresh_tokens (token_hash, usuario_id, expires_at)
             VALUES (:hash, :usuario, :expira)'
        );

        $stmt->execute([
            ':hash'    => $this->hash($token),
            ':usuario' => $usuarioId,
            ':expira'  => $expiraEm->format('Y-m-d H:i:s'),
        ]);
    }

    /** @return array{usuario_id: int}|null null = inválido, expirado ou revogado */
    public function existe(string $token): ?array
    {
        $stmt = $this->pdo->prepare(
            'SELECT usuario_id FROM refresh_tokens
              WHERE token_hash = :hash
                AND revogado_em IS NULL
                AND expires_at > NOW()
              LIMIT 1'
        );
        $stmt->execute([':hash' => $this->hash($token)]);

        $linha = $stmt->fetch(PDO::FETCH_ASSOC);

        return $linha ? ['usuario_id' => (int) $linha['usuario_id']] : null;
    }

    public function revogar(string $token): bool
    {
        $stmt = $this->pdo->prepare(
            'UPDATE refresh_tokens SET revogado_em = NOW()
              WHERE token_hash = :hash AND revogado_em IS NULL'
        );
        $stmt->execute([':hash' => $this->hash($token)]);

        return $stmt->rowCount() > 0;
    }

    /** Logout de todos os dispositivos. */
    public function revogarTodosDoUsuario(int $usuarioId): int
    {
        $stmt = $this->pdo->prepare(
            'UPDATE refresh_tokens SET revogado_em = NOW()
              WHERE usuario_id = :usuario AND revogado_em IS NULL'
        );
        $stmt->execute([':usuario' => $usuarioId]);

        return $stmt->rowCount();
    }

    /** Rotação: o refresh usado morre e nasce outro. */
    public function rotacionar(string $tokenAntigo, string $tokenNovo,
                               int $usuarioId, DateTimeImmutable $expiraEm): void
    {
        $this->pdo->beginTransaction();

        try {
            $this->revogar($tokenAntigo);
            $this->salvar($tokenNovo, $usuarioId, $expiraEm);

            $this->pdo->commit();
        } catch (Throwable $e) {
            $this->pdo->rollBack();
            throw $e;
        }
    }

    public function limparExpirados(int $diasDeGraca = 7): int
    {
        // Não apaga na hora: manter um tempo permite detectar reuso de token
        // revogado, que é sinal de credencial roubada.
        $stmt = $this->pdo->prepare(
            'DELETE FROM refresh_tokens
              WHERE expires_at < DATE_SUB(NOW(), INTERVAL :dias DAY)'
        );
        $stmt->bindValue(':dias', $diasDeGraca, PDO::PARAM_INT);
        $stmt->execute();

        return $stmt->rowCount();
    }

    public static function gerar(): string
    {
        return bin2hex(random_bytes(32));   // 256 bits de entropia
    }

    private function hash(string $token): string
    {
        return hash('sha256', $token);
    }
}

// ---------- Uso -----------------------------------------------------------
$token = RefreshTokenRepositorio::gerar();

$repo->salvar($token, usuarioId: 7, expiraEm: new DateTimeImmutable('+30 days'));

if (($dados = $repo->existe($token)) !== null) {
    $novo = RefreshTokenRepositorio::gerar();
    $repo->rotacionar($token, $novo, $dados['usuario_id'], new DateTimeImmutable('+30 days'));
}

✓ Resposta: O ponto que o exercício ensina: guardar o jti só até o exp mantém a blacklist pequena para sempre. E lembre que APCu é por processo/servidor — com mais de uma máquina atrás de um balanceador, a blacklist precisa ser Redis, senão o logout vale só no nó que atendeu.

<?php

declare(strict_types=1);

final class BlacklistToken
{
    private const PREFIXO = 'jwt:bl:';

    /**
     * Access token não dá para "cancelar": ele é auto-contido e válido até
     * expirar. A blacklist é a forma de invalidar antes da hora — e ela só
     * precisa guardar o jti pelo tempo que FALTA para o token morrer.
     */
    public function revogar(string $jti, int $expiraEm): bool
    {
        $ttl = $expiraEm - time();

        if ($ttl <= 0) {
            return true;   // já expirou sozinho, nada a guardar
        }

        // O TTL do APCu faz a limpeza acontecer sozinha.
        return apcu_store(self::PREFIXO . $jti, true, $ttl);
    }

    public function estaRevogado(string $jti): bool
    {
        return apcu_exists(self::PREFIXO . $jti);
    }

    public function limpar(): void
    {
        foreach (new APCUIterator('/^' . preg_quote(self::PREFIXO, '/') . '/') as $item) {
            apcu_delete($item['key']);
        }
    }
}

final class ServicoJWT
{
    public function __construct(
        private readonly string $segredo,
        private readonly int $ttlAcesso = 900,   // 15 min
    ) {}

    public function emitir(int $usuarioId, array $extra = []): array
    {
        $agora = time();

        // jti: identificador único do token. É ele que a blacklist guarda.
        $jti = bin2hex(random_bytes(16));

        $payload = [
            'sub' => $usuarioId,
            'jti' => $jti,
            'iat' => $agora,
            'exp' => $agora + $this->ttlAcesso,
        ] + $extra;

        return ['token' => $this->codificar($payload), 'jti' => $jti,
                'exp' => $payload['exp']];
    }

    public function validar(string $token): array
    {
        $partes = explode('.', $token);

        if (count($partes) !== 3) {
            throw new RuntimeException('Token malformado.');
        }

        [$cabecalho64, $payload64, $assinatura64] = $partes;

        $esperada = $this->assinar("{$cabecalho64}.{$payload64}");

        // hash_equals: comparar assinatura com === vaza informação por tempo.
        if (!hash_equals($esperada, $assinatura64)) {
            throw new RuntimeException('Assinatura inválida.');
        }

        $payload = json_decode($this->base64UrlDecode($payload64), true);

        if (($payload['exp'] ?? 0) < time()) {
            throw new RuntimeException('Token expirado.');
        }

        return $payload;
    }

    private function codificar(array $payload): string
    {
        $cabecalho = $this->base64UrlEncode(json_encode(['alg' => 'HS256', 'typ' => 'JWT']));
        $corpo = $this->base64UrlEncode(json_encode($payload));

        return "{$cabecalho}.{$corpo}." . $this->assinar("{$cabecalho}.{$corpo}");
    }

    private function assinar(string $dados): string
    {
        return $this->base64UrlEncode(hash_hmac('sha256', $dados, $this->segredo, true));
    }

    private function base64UrlEncode(string $dados): string
    {
        return rtrim(strtr(base64_encode($dados), '+/', '-_'), '=');
    }

    private function base64UrlDecode(string $dados): string
    {
        return base64_decode(strtr($dados, '-_', '+/'));
    }
}

// ---------- Middleware ----------------------------------------------------
function autenticarJwt(ServicoJWT $jwt, BlacklistToken $blacklist): callable
{
    return static function (array $params, callable $proximo) use ($jwt, $blacklist): mixed {
        $header = $_SERVER['HTTP_AUTHORIZATION'] ?? '';

        if (!preg_match('/^Bearer\s+(\S+)$/i', $header, $m)) {
            http_response_code(401);
            return ['erro' => 'token_ausente'];
        }

        try {
            $payload = $jwt->validar($m[1]);
        } catch (RuntimeException $e) {
            http_response_code(401);
            return ['erro' => 'token_invalido', 'mensagem' => $e->getMessage()];
        }

        // A checagem da blacklist vem DEPOIS de validar a assinatura: não faz
        // sentido consultar o jti de um token que nem é nosso.
        if ($blacklist->estaRevogado($payload['jti'] ?? '')) {
            http_response_code(401);
            return ['erro' => 'token_revogado'];
        }

        $params['usuario_id'] = (int) $payload['sub'];
        $params['jti'] = $payload['jti'];
        $params['exp'] = $payload['exp'];

        return $proximo($params);
    };
}

// ---------- Logout --------------------------------------------------------
$router->post('/api/auth/logout', function (array $p) use ($blacklist, $refreshRepo): array {
    $blacklist->revogar($p['jti'], $p['exp']);
    $refreshRepo->revogarTodosDoUsuario($p['usuario_id']);

    http_response_code(204);
    return [];
})->middleware(autenticarJwt($jwt, $blacklist));

✓ Resposta: Trocar a senha e não revogar as sessões é uma falha comum e séria: se alguém entrou com a senha antiga, o refresh token dele continua funcionando por 30 dias — trocar a senha não expulsa o invasor.

<?php

declare(strict_types=1);

final class AuthController
{
    public function __construct(
        private readonly PDO $pdo,
        private readonly ServicoJWT $jwt,
        private readonly RefreshTokenRepositorio $refreshRepo,
        private readonly BlacklistToken $blacklist,
    ) {}

    /** POST /api/auth/trocar-senha  (exige access token válido) */
    public function trocarSenha(array $params): array
    {
        $dados = json_decode(file_get_contents('php://input') ?: '{}', true) ?? [];

        $atual = (string) ($dados['senha_atual'] ?? '');
        $nova  = (string) ($dados['nova_senha'] ?? '');

        if ($erros = $this->validarNovaSenha($nova, $atual)) {
            return Resposta::erro('validacao', 'Senha inválida.', 422, ['campos' => $erros]);
        }

        $usuarioId = (int) $params['usuario_id'];

        $stmt = $this->pdo->prepare('SELECT senha_hash FROM usuarios WHERE id = :id');
        $stmt->execute([':id' => $usuarioId]);
        $hashAtual = $stmt->fetchColumn();

        if ($hashAtual === false || !password_verify($atual, (string) $hashAtual)) {
            // 403, não 422: o token é válido, a credencial é que não confere.
            return Resposta::erro('senha_incorreta', 'A senha atual não confere.', 403);
        }

        $this->pdo->beginTransaction();

        try {
            $update = $this->pdo->prepare(
                'UPDATE usuarios SET senha_hash = :hash, senha_alterada_em = NOW()
                  WHERE id = :id'
            );
            $update->execute([
                ':hash' => password_hash($nova, PASSWORD_DEFAULT),
                ':id'   => $usuarioId,
            ]);

            // Trocar senha derruba todas as sessões: é o que corta o acesso
            // de quem tinha roubado a credencial.
            $revogados = $this->refreshRepo->revogarTodosDoUsuario($usuarioId);

            $this->pdo->commit();

        } catch (Throwable $e) {
            $this->pdo->rollBack();
            throw $e;
        }

        // O access token atual também morre — inclusive o desta requisição.
        $this->blacklist->revogar($params['jti'], $params['exp']);

        // Emite um par novo para o dispositivo que trocou a senha: sem isso,
        // o usuário troca a senha e é deslogado na hora, o que irrita.
        $acesso = $this->jwt->emitir($usuarioId);
        $refresh = RefreshTokenRepositorio::gerar();

        $this->refreshRepo->salvar($refresh, $usuarioId, new DateTimeImmutable('+30 days'));

        return Resposta::json([
            'mensagem'            => 'Senha alterada. Os outros dispositivos foram desconectados.',
            'sessoes_encerradas'  => $revogados,
            'access_token'        => $acesso['token'],
            'refresh_token'       => $refresh,
            'expira_em'           => $acesso['exp'],
        ]);
    }

    private function validarNovaSenha(string $nova, string $atual): array
    {
        $erros = [];

        if (mb_strlen($nova) < 10) {
            $erros['nova_senha'] = 'Mínimo de 10 caracteres.';
        }

        if ($nova === $atual) {
            $erros['nova_senha'] = 'A nova senha precisa ser diferente da atual.';
        }

        if (preg_match('/^\d+$/', $nova)) {
            $erros['nova_senha'] = 'Não use apenas números.';
        }

        return $erros;
    }
}

$router->post('/api/auth/trocar-senha', fn ($p) => $auth->trocarSenha($p))
       ->middleware(autenticarJwt($jwt, $blacklist));

✓ Resposta: Dois vazamentos sutis fechados aqui: rodar password_verify mesmo sem usuário (senão o tempo de resposta denuncia quem está cadastrado) e a mensagem genérica de erro. Contar por IP+e-mail, e não só por IP, evita que um NAT corporativo bloqueie o prédio inteiro.

<?php

declare(strict_types=1);

final class LimitadorLogin
{
    private const PREFIXO = 'login:falhas:';

    public function __construct(
        private readonly int $maxTentativas = 5,
        private readonly int $janelaSegundos = 900,   // 15 min
    ) {}

    /** @return array{bloqueado: bool, restantes: int, retry_after: int} */
    public function situacao(string $ip, string $email = ''): array
    {
        $chave = $this->chave($ip, $email);
        $registros = $this->registrosValidos($chave);

        if (count($registros) < $this->maxTentativas) {
            return [
                'bloqueado'   => false,
                'restantes'   => $this->maxTentativas - count($registros),
                'retry_after' => 0,
            ];
        }

        return [
            'bloqueado'   => true,
            'restantes'   => 0,
            'retry_after' => max(1, (min($registros) + $this->janelaSegundos) - time()),
        ];
    }

    public function registrarFalha(string $ip, string $email = ''): void
    {
        $chave = $this->chave($ip, $email);

        $registros = $this->registrosValidos($chave);
        $registros[] = time();

        apcu_store($chave, $registros, $this->janelaSegundos);
    }

    /** Login bem-sucedido zera o contador. */
    public function limpar(string $ip, string $email = ''): void
    {
        apcu_delete($this->chave($ip, $email));
    }

    private function registrosValidos(string $chave): array
    {
        $limite = time() - $this->janelaSegundos;

        return array_values(array_filter(
            apcu_fetch($chave) ?: [],
            static fn(int $t): bool => $t > $limite,
        ));
    }

    private function chave(string $ip, string $email): string
    {
        // Contar por IP + e-mail evita que um atacante num IP compartilhado
        // (NAT corporativo) bloqueie a conta de todo mundo do prédio.
        return self::PREFIXO . sha1($ip . '|' . mb_strtolower($email));
    }
}

// ---------- No endpoint de login -----------------------------------------
$router->post('/api/auth/login', function (array $params) use ($pdo, $jwt, $limitador, $refreshRepo): array {
    $ip = trim(explode(',', $_SERVER['REMOTE_ADDR'] ?? 'desconhecido')[0]);
    $dados = json_decode(file_get_contents('php://input') ?: '{}', true) ?? [];

    $email = mb_strtolower(trim((string) ($dados['email'] ?? '')));
    $senha = (string) ($dados['senha'] ?? '');

    $situacao = $limitador->situacao($ip, $email);

    if ($situacao['bloqueado']) {
        http_response_code(429);
        header('Retry-After: ' . $situacao['retry_after']);

        return [
            'erro'     => 'muitas_tentativas',
            'mensagem' => 'Muitas tentativas de login. Tente novamente mais tarde.',
            'tente_em' => $situacao['retry_after'] . 's',
        ];
    }

    $stmt = $pdo->prepare('SELECT id, senha_hash FROM usuarios WHERE email = :email LIMIT 1');
    $stmt->execute([':email' => $email]);
    $usuario = $stmt->fetch(PDO::FETCH_ASSOC);

    // password_verify roda mesmo com usuário inexistente, contra um hash
    // descartável: sem isso, a resposta volta mais rápido para e-mail que não
    // existe, e dá para enumerar quem é cliente pelo tempo de resposta.
    $hash = $usuario['senha_hash'] ?? '$2y$12$umHashQualquerParaGastarOMesmoTempo......';

    if (!password_verify($senha, $hash) || $usuario === false) {
        $limitador->registrarFalha($ip, $email);

        $restantes = $limitador->situacao($ip, $email)['restantes'];

        http_response_code(401);

        // Mensagem genérica: nunca diga "e-mail não cadastrado".
        return [
            'erro'                => 'credenciais_invalidas',
            'mensagem'            => 'E-mail ou senha incorretos.',
            'tentativas_restantes' => $restantes,
        ];
    }

    $limitador->limpar($ip, $email);

    $acesso = $jwt->emitir((int) $usuario['id']);
    $refresh = RefreshTokenRepositorio::gerar();

    $refreshRepo->salvar($refresh, (int) $usuario['id'], new DateTimeImmutable('+30 days'));

    return ['access_token' => $acesso['token'], 'refresh_token' => $refresh,
            'expira_em' => $acesso['exp']];
});

✓ Resposta: A checagem do alg contra o algoritmo configurado não é preciosismo — é a correção de uma das vulnerabilidades mais exploradas em JWT. Aceitar o alg que vem no token permite ao atacante trocar RS256 por HS256 e assinar usando a chave pública, que ele já tem.

<?php

declare(strict_types=1);

enum AlgoritmoJwt: string
{
    case HS256 = 'HS256';   // simétrico: mesma chave assina e verifica
    case RS256 = 'RS256';   // assimétrico: privada assina, pública verifica

    public function ehAssimetrico(): bool
    {
        return $this === self::RS256;
    }
}

final class ServicoJWT
{
    /**
     * @param string $chaveAssinatura  HS256: o segredo. RS256: a chave privada (PEM).
     * @param string|null $chaveVerificacao  RS256: a chave pública (PEM).
     */
    public function __construct(
        private readonly AlgoritmoJwt $algoritmo,
        private readonly string $chaveAssinatura,
        private readonly ?string $chaveVerificacao = null,
        private readonly int $ttl = 900,
    ) {
        if ($algoritmo->ehAssimetrico() && $chaveVerificacao === null) {
            throw new InvalidArgumentException('RS256 exige a chave pública.');
        }

        if (!$algoritmo->ehAssimetrico() && strlen($chaveAssinatura) < 32) {
            throw new InvalidArgumentException('Segredo HS256 curto demais (mín. 32 bytes).');
        }
    }

    public static function gerarParDeChaves(int $bits = 2048): array
    {
        $recurso = openssl_pkey_new([
            'private_key_bits' => $bits,
            'private_key_type' => OPENSSL_KEYTYPE_RSA,
        ]);

        openssl_pkey_export($recurso, $privada);
        $publica = openssl_pkey_get_details($recurso)['key'];

        return ['privada' => $privada, 'publica' => $publica];
    }

    public function emitir(int $usuarioId, array $extra = []): string
    {
        $agora = time();

        $payload = [
            'sub' => $usuarioId,
            'jti' => bin2hex(random_bytes(16)),
            'iat' => $agora,
            'exp' => $agora + $this->ttl,
        ] + $extra;

        // O alg vai no cabeçalho — mas NUNCA será lido para escolher o
        // algoritmo na validação. Veja o porquê na validação abaixo.
        $cabecalho = $this->b64(json_encode([
            'alg' => $this->algoritmo->value,
            'typ' => 'JWT',
        ]));

        $corpo = $this->b64(json_encode($payload));

        return "{$cabecalho}.{$corpo}." . $this->assinar("{$cabecalho}.{$corpo}");
    }

    public function validar(string $token): array
    {
        $partes = explode('.', $token);

        if (count($partes) !== 3) {
            throw new RuntimeException('Token malformado.');
        }

        [$cabecalho64, $payload64, $assinatura] = $partes;

        $cabecalho = json_decode($this->b64d($cabecalho64), true);

        // ⚠️ A vulnerabilidade clássica de JWT: confiar no `alg` do token.
        // Um atacante troca para "none" ou para HS256 e assina com a chave
        // PÚBLICA (que é pública!). A defesa é comparar com o algoritmo
        // configurado e recusar qualquer divergência.
        if (($cabecalho['alg'] ?? '') !== $this->algoritmo->value) {
            throw new RuntimeException('Algoritmo não permitido.');
        }

        if (!$this->verificar("{$cabecalho64}.{$payload64}", $assinatura)) {
            throw new RuntimeException('Assinatura inválida.');
        }

        $payload = json_decode($this->b64d($payload64), true);

        if (($payload['exp'] ?? 0) < time()) {
            throw new RuntimeException('Token expirado.');
        }

        return $payload;
    }

    private function assinar(string $dados): string
    {
        if (!$this->algoritmo->ehAssimetrico()) {
            return $this->b64(hash_hmac('sha256', $dados, $this->chaveAssinatura, true));
        }

        $chave = openssl_pkey_get_private($this->chaveAssinatura);

        if ($chave === false) {
            throw new RuntimeException('Chave privada inválida.');
        }

        openssl_sign($dados, $assinatura, $chave, OPENSSL_ALGO_SHA256);

        return $this->b64($assinatura);
    }

    private function verificar(string $dados, string $assinatura64): bool
    {
        if (!$this->algoritmo->ehAssimetrico()) {
            return hash_equals(
                $this->b64(hash_hmac('sha256', $dados, $this->chaveAssinatura, true)),
                $assinatura64,
            );
        }

        $chave = openssl_pkey_get_public((string) $this->chaveVerificacao);

        if ($chave === false) {
            throw new RuntimeException('Chave pública inválida.');
        }

        // openssl_verify: 1 = válida, 0 = inválida, -1 = erro.
        return openssl_verify($dados, $this->b64d($assinatura64), $chave,
                              OPENSSL_ALGO_SHA256) === 1;
    }

    private function b64(string $d): string
    {
        return rtrim(strtr(base64_encode($d), '+/', '-_'), '=');
    }

    private function b64d(string $d): string
    {
        return base64_decode(strtr($d, '-_', '+/'));
    }
}

// ---------- Uso -----------------------------------------------------------
$hs = new ServicoJWT(AlgoritmoJwt::HS256, $_ENV['JWT_SECRET']);
$token = $hs->emitir(7);
print_r($hs->validar($token));

$par = ServicoJWT::gerarParDeChaves();

$rs = new ServicoJWT(AlgoritmoJwt::RS256, $par['privada'], $par['publica']);
$tokenRs = $rs->emitir(7);
print_r($rs->validar($tokenRs));

// A vantagem do RS256: o serviço que só VERIFICA recebe apenas a pública.
// Se ele for comprometido, ninguém consegue emitir token em seu nome.
$verificador = new ServicoJWT(AlgoritmoJwt::RS256, $par['publica'], $par['publica']);