Implementando um Sistema de Autenticação com JWT em Aplicações Node.js

“`html

Introdução

A autenticação é um aspecto crucial de qualquer aplicação web, garantindo que apenas usuários autorizados possam acessar determinadas funcionalidades e informações. Neste contexto, o JSON Web Token (JWT) se destaca como uma solução leve e eficiente para autenticação e troca de informações entre partes. Este artigo aborda a implementação de um sistema de autenticação utilizando JWT em uma aplicação Node.js, ideal para desenvolvedores iniciantes e intermediários que buscam entender e aplicar essa tecnologia em projetos reais.

Contexto ou Teoria

O JSON Web Token é um padrão aberto (RFC 7519) que define um método compacto e independente para transmitir informações entre partes como um objeto JSON. Essas informações podem ser verificadas e confiáveis, pois são assinadas digitalmente. O JWT pode ser assinado usando um algoritmo secreto (com o HMAC) ou um par de chaves pública/privada usando RSA ou ECDSA.

Um JWT é composto por três partes principais: Header, Payload e Signature. O Header contém informações sobre o tipo de token e o algoritmo de assinatura. O Payload contém as declarações (claims), que podem ser informações sobre o usuário ou sobre a sessão. A Signature é criada combinando o header codificado, o payload codificado e uma chave secreta.

Demonstrações Práticas

Para demonstrar a implementação de um sistema de autenticação, seguiremos os passos necessários para criar uma API simples com Node.js e Express, utilizando o JWT para autenticar usuários.

1. Configuração do Ambiente

Antes de começar, você precisa ter o Node.js instalado em sua máquina. Crie uma nova pasta para o seu projeto e inicialize um novo projeto Node.js com o seguinte comando:

mkdir jwt-auth-example
cd jwt-auth-example
npm init -y

Em seguida, instale as dependências necessárias:

npm install express jsonwebtoken bcryptjs body-parser cors

2. Estrutura do Projeto

Crie a estrutura básica do projeto. Para este exemplo, você pode criar um arquivo chamado server.js e uma pasta chamada routes para armazenar suas rotas.

touch server.js
mkdir routes

3. Implementando o Servidor Express

Abra o arquivo server.js e adicione o seguinte código:

// Importando as dependências
const express = require('express');
const bodyParser = require('body-parser');
const cors = require('cors');
const app = express();
const port = 3000;

// Middleware
app.use(cors());
app.use(bodyParser.json());

// Iniciando o servidor
app.listen(port, () => {
    console.log(`Servidor rodando em http://localhost:${port}`);
});

4. Criando a Rota de Registro

Agora, vamos criar uma rota para registrar novos usuários. Crie um arquivo chamado auth.js dentro da pasta routes e adicione o seguinte código:

// routes/auth.js
const express = require('express');
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');
const router = express.Router();

const users = []; // Banco de dados em memória para os usuários

// Rota de registro
router.post('/register', async (req, res) => {
    const { username, password } = req.body;

    // Verifica se o usuário já existe
    const userExists = users.find(user => user.username === username);
    if (userExists) {
        return res.status(400).json({ message: 'Usuário já existe' });
    }

    // Criptografa a senha
    const hashedPassword = await bcrypt.hash(password, 10);

    // Armazena o novo usuário
    users.push({ username, password: hashedPassword });
    res.status(201).json({ message: 'Usuário registrado com sucesso' });
});

module.exports = router;

5. Integrando a Rota de Registro no Servidor

Volte para o arquivo server.js e importe a nova rota que você acabou de criar:

// Importando a rota de autenticação
const authRoutes = require('./routes/auth');

// Usando a rota de autenticação
app.use('/api/auth', authRoutes);

6. Criando a Rota de Login

Adicione a seguinte rota de login no arquivo auth.js:

// Rota de login
router.post('/login', async (req, res) => {
    const { username, password } = req.body;

    // Encontra o usuário
    const user = users.find(user => user.username === username);
    if (!user) {
        return res.status(400).json({ message: 'Usuário não encontrado' });
    }

    // Verifica a senha
    const isPasswordValid = await bcrypt.compare(password, user.password);
    if (!isPasswordValid) {
        return res.status(401).json({ message: 'Senha incorreta' });
    }

    // Gera o token JWT
    const token = jwt.sign({ username: user.username }, 'sua-chave-secreta', { expiresIn: '1h' });
    res.json({ token });
});

7. Protegendo Rotas com Middleware de Autenticação

Para proteger suas rotas, você pode criar um middleware que verifica a validade do token. No arquivo auth.js, adicione o seguinte código:

// Middleware de autenticação
const authenticateToken = (req, res, next) => {
    const token = req.headers['authorization']?.split(' ')[1];
    if (!token) return res.sendStatus(401);

    jwt.verify(token, 'sua-chave-secreta', (err, user) => {
        if (err) return res.sendStatus(403);
        req.user = user;
        next();
    });
};

// Rota protegida
router.get('/protected', authenticateToken, (req, res) => {
    res.json({ message: 'Acesso permitido', user: req.user });
});

8. Testando a Aplicação

Para testar a aplicação, você pode usar uma ferramenta como o Postman ou o Insomnia. Primeiro, faça uma requisição POST para a rota de registro:

URL: http://localhost:3000/api/auth/register

Body:

{

    "