Implementando um Sistema de Autenticação com JWT em Aplicações Web

Introdução

A autenticação é uma parte crítica de qualquer aplicação web, garantindo que apenas usuários autorizados possam acessar recursos e dados sensíveis. Com o aumento da necessidade de sistemas escaláveis e seguros, o JSON Web Token (JWT) se tornou uma solução popular para gerenciar autenticação em aplicações modernas. Este artigo aborda a implementação de um sistema de autenticação utilizando JWT, ideal tanto para desenvolvedores iniciantes quanto para os intermediários que desejam consolidar seus conhecimentos em segurança web.

Contexto ou Teoria

O JSON Web Token (JWT) é um padrão aberto (RFC 7519) que define um formato compacto e autônomo para a transmissão de informações entre partes como um objeto JSON. Essas informações podem ser verificadas e confiáveis, pois são digitalmente assinadas. Os tokens JWT são frequentemente usados em situações de autenticação e autorização, permitindo que um servidor verifique a identidade de um usuário sem ter que gerenciar sessões de estado.

Um token JWT é composto por três partes principais: header (cabeçalho), payload (carga útil) e signature (assinatura). O cabeçalho geralmente informa o tipo de token e o algoritmo de assinatura. A carga útil contém as informações sobre o usuário e outras informações relevantes, enquanto a assinatura garante que o token não foi alterado.

Um sistema típico de autenticação com JWT funciona da seguinte maneira:

• O usuário envia suas credenciais (nome de usuário e senha) para o servidor.
• Se as credenciais forem válidas, o servidor gera um JWT e o envia de volta ao cliente.
• O cliente armazena o token (geralmente no armazenamento local) e o envia em cada requisição subsequente no cabeçalho de autorização.
• O servidor valida o token em cada solicitação para garantir que o usuário está autenticado.

Demonstrações Práticas

Vamos implementar um sistema de autenticação usando JWT em uma aplicação Node.js com Express. Para isso, você precisará ter o Node.js instalado em sua máquina. O primeiro passo é criar um novo projeto e instalar as dependências necessárias.

# Criação do projeto
mkdir jwt-auth-example
cd jwt-auth-example
npm init -y

# Instalação das dependências
npm install express jsonwebtoken bcryptjs dotenv

Com as dependências instaladas, vamos criar um arquivo chamado server.js e configurar nosso servidor Express.

// server.js
const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcryptjs');
const dotenv = require('dotenv');

dotenv.config();

const app = express();
app.use(express.json());

const users = []; // Simulando um banco de dados

// Rota de registro
app.post('/register', (req, res) => {
    const { username, password } = req.body;
    const hashedPassword = bcrypt.hashSync(password, 8);
    
    const user = { username, password: hashedPassword };
    users.push(user);
    
    res.status(201).send({ message: 'Usuário registrado com sucesso!' });
});

// Rota de login
app.post('/login', (req, res) => {
    const { username, password } = req.body;
    const user = users.find(u => u.username === username);
    
    if (!user) {
        return res.status(404).send({ message: 'Usuário não encontrado.' });
    }

    const isPasswordValid = bcrypt.compareSync(password, user.password);
    if (!isPasswordValid) {
        return res.status(401).send({ accessToken: null, message: 'Senha inválida.' });
    }

    const token = jwt.sign({ id: user.username }, process.env.JWT_SECRET, { expiresIn: 86400 }); // 24 horas
    res.status(200).send({ accessToken: token });
});

// Middleware de autenticação
const verifyToken = (req, res, next) => {
    const token = req.headers['authorization'];

    if (!token) {
        return res.status(403).send({ message: 'Token não fornecido!' });
    }

    jwt.verify(token, process.env.JWT_SECRET, (err, decoded) => {
        if (err) {
            return res.status(401).send({ message: 'Unauthorized!' });
        }
        req.userId = decoded.id;
        next();
    });
};

// Rota protegida
app.get('/protected', verifyToken, (req, res) => {
    res.status(200).send({ message: 'Acesso autorizado!', userId: req.userId });
});

// Inicialização do servidor
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Servidor rodando na porta ${PORT}`);
});

Neste código, temos uma aplicação básica que permite registrar usuários e fazer login. O usuário é armazenado em um array para simulação, mas em uma aplicação real, você deve usar um banco de dados.

Após o registro, o usuário pode fazer login e receber um token JWT. Esse token deve ser enviado em todas as requisições subsequentes para acessar rotas protegidas, como a rota /protected. O middleware verifyToken é responsável por verificar a validade do token recebido.

Para que o código funcione corretamente, você deve definir uma variável de ambiente JWT_SECRET. Isso pode ser feito criando