O que é JWT e por que ele é tão importante?

• Header: contém o algoritmo usado na assinatura e o tipo do token.

• Payload: inclui as informações (como e-mail ou ID do usuário).

• Signature: garante a integridade do token, assegurando que ele não foi alterado.

Essa estrutura faz do JWT uma ferramenta poderosa, permitindo que as aplicações autentiquem usuários sem precisar armazenar as informações em um banco de dados a cada requisição. Legal, né?

Como funciona o JWT na prática?

1. O usuário faz login, enviando suas credenciais.

2. O servidor valida as informações e gera um token JWT contendo dados como:
• Identificação do usuário.
• Permissões.
• Tempo de expiração.

3. O token é retornado ao cliente e armazenado (normalmente no localStorage ou cookies).

4. Nas próximas requisições, o cliente envia o token no cabeçalho HTTP.

5. O servidor valida o token antes de permitir o acesso às rotas protegidas.

Esse fluxo torna o sistema eficiente e escalável, sem a necessidade de consultar um banco de dados em cada interação.

Mãos à obra: começando com JWT e Python

Preparando o terreno: configurando o ambiente

1. Abra seu terminal e crie um ambiente virtual para o projeto:

python3 -m venv venv

Isso cria um "espaço isolado" onde você pode instalar dependências sem bagunçar o restante do seu sistema.

2. Ative o ambiente virtual:
• Windows:

venv\Scripts\activate

• Linux/Mac:

source venv/bin/activate

3. Instale as bibliotecas necessárias:

pip install flask pyjwt

• Flask: é o framework que usaremos para criar nossa API.
• PyJWT: será o herói responsável por criar e validar nossos tokens JWT.

Criando a API básica

from flask import Flask, jsonify

app = Flask(__name__)

# Rota inicial (hello world)
@app.route("/")
def home():
    return jsonify(message="Bem-vindo à API segura com JWT!")

if __name__ == "__main__":
    app.run(debug=True)

python app.py

Acesse http://127.0.0.1:5000/ no seu navegador, e você verá a mensagem: "Bem-vindo à API segura com JWT!". Parabéns, você acabou de criar sua primeira API com Flask!

Adicionando autenticação com JWT

import jwt
import os
from datetime import datetime, timedelta
from flask import request

# Chave secreta para encriptação (ideal usar variável de ambiente em produção)
SECRET_KEY = os.getenv("SECRET_KEY", "sua-chave-super-secreta")

@app.route("/login", methods=["POST"])
def login():
    data = request.get_json()
    if not data:
        return jsonify(message="Dados de login não fornecidos!"), 400
    if "username" not in data or "password" not in data:
        return jsonify(message="Campos 'username' e 'password' são obrigatórios!"), 400
    if data["username"] == "admin" and data["password"] == "123":
        # Gerar o token com expiração
        token = jwt.encode(
            {"user": data["username"], "exp": datetime.utcnow() + timedelta(minutes=30)},
            SECRET_KEY,
            algorithm="HS256"
        )
        return jsonify(token=token)

    return jsonify(message="Credenciais inválidas!"), 401

Nunca exponha sua SECRET_KEY no código. Em vez disso, use variáveis de ambiente para armazenar chaves e outros dados sensíveis. Isso aumenta a segurança e a flexibilidade da sua aplicação. Você pode usar bibliotecas como python-decouple para facilitar o gerenciamento das configurações.

O que fizemos aqui?

1. Rota /login: recebe um username e password.

2. Validação fictícia: só aceita admin e 123 como credenciais.

3. Token gerado: o JWT contém o nome do usuário e uma validade de 30 minutos.

1. Configure uma requisição POST para /login.

2. Envie o JSON:

{
  "username": "admin",
  "password": "123"
}

3. O servidor retornará um token como este:

{
  "token": "eyJhbGciOiJIUzI1NiIsInR..."
}

Esse token é seu ingresso para acessar rotas protegidas!

Protegendo rotas sensíveis

@app.route("/protected", methods=["GET"])
def protected():
    # Obtém o token do cabeçalho da requisição
    auth_header = request.headers.get("Authorization")
    if not auth_header:
        return jsonify(message="Token é necessário!"), 403

    parts = auth_header.split()
    if parts[0].lower() != 'bearer' or len(parts) != 2:
        return jsonify(message="Cabeçalho de autorização malformado!"), 401
    token = parts[1]

    try:
        # Decodifica o token
        decoded = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return jsonify(message=f"Bem-vindo, {decoded['user']}!")
    except jwt.ExpiredSignatureError:
        return jsonify(message="Token expirado! Faça login novamente."), 401
    except jwt.InvalidTokenError:
        return jsonify(message="Token inválido!"), 403

O padrão para o envio do token JWT no cabeçalho Authorization é utilizar o prefixo Bearer. Por isso, precisamos dividir o conteúdo do cabeçalho para extrair o token corretamente. Isso garante compatibilidade com clientes que seguem as especificações de autenticação.

O que está acontecendo aqui?

1. Token no cabeçalho: o cliente deve enviar o token no campo Authorization.

2. Decodificação do token: validamos o token usando a mesma SECRET_KEY.

3. Mensagens claras:
• Token expirado? Mensagem amigável.
• Token inválido? Bloqueamos o acesso.

1. Faça login e copie o token gerado.

2. Configure uma requisição GET para /protected.

3. Adicione o token ao cabeçalho Authorization:

Authorization: Bearer <seu-token>

4. Se tudo estiver correto, você verá a mensagem:

{
  "message": "Bem-vindo, admin!"
}

Melhorando a segurança

• Variáveis de ambiente: nunca exponha sua SECRET_KEY no código. Use bibliotecas como python-decouple.

• HTTPS: Para garantir que as comunicações entre o cliente e o servidor sejam criptografadas, é essencial implementar HTTPS em sua aplicação. Isso protege os dados transmitidos, incluindo tokens de autenticação, contra interceptação por terceiros. Em ambientes de produção, obtenha certificados SSL/TLS de autoridades confiáveis ou use serviços como o Let's Encrypt para certificados gratuitos.

• Tokens com expiração curta e Refresh Tokens: Definir um tempo de expiração curto para os tokens de acesso (por exemplo, 15 minutos) reduz o período em que um token comprometido pode ser utilizado. Para melhorar a experiência do usuário, implemente um sistema de refresh tokens que permite obter novos tokens de acesso sem exigir novo login, desde que o refresh token ainda seja válido. Isso adiciona uma camada extra de segurança e controle sobre a sessão do usuário.

• Validação robusta: inclua verificações para evitar payloads maliciosos no JWT.

Por que aprender JWT é transformador?

Recursos adicionais

Dica: Manter-se atualizado com a documentação oficial e as melhores práticas do mercado é fundamental para desenvolver aplicações seguras e eficientes.

Conclusão