Autenticação e autorização

Quem é você e o que pode fazer: senhas com hash, sessões, cookies, JWT e regras que impedem uma pessoa de ver os dados de outra.

Cerca de 16 min · Revisado em

Ao final, você vai conseguir

  • Diferenciar autenticação de autorização e escolher entre 401 e 403
  • Guardar senhas com hash e sal em vez de texto
  • Comparar sessão com cookie e token JWT, configurando HttpOnly, Secure e SameSite
  • Escrever uma regra de acesso por papel e por dono do recurso
  • Testar uma API sem login e com permissões insuficientes

Muitos vazamentos de dados que viram notícia não exigiram nenhum ataque genial: bastava trocar o número no fim da URL para ver o cadastro de outra pessoa. O login funcionava; o que faltava era perguntar "essa pessoa pode ver isso?". Nesta aula você aprende a responder as duas perguntas que todo backend faz em cada requisição, quem é você e o que você pode fazer, e a evitar os erros que mais vazam dados.

Quem é você e o que pode fazer

Autenticação
Confirmar quem está fazendo o pedido: senha, código por SMS, biometria, login com Google. Em inglês, authentication ou authn.
Autorização
Decidir o que essa pessoa pode fazer: ler esta despesa, apagar aquela, acessar o painel de administração. Em inglês, authorization ou authz.
Credencial
O que a pessoa apresenta para provar a identidade, como e-mail e senha.

Cada verificação é de autenticação ou de autorização?

Autenticação: quem é · Autorização: o que pode

  • Conferir a senha digitada no login
  • Validar o código de 6 dígitos enviado por SMS
  • Ler o cookie de sessão e descobrir de quem é
  • Checar se a despesa 7 pertence a quem pediu
  • Esconder o botão "Excluir usuário" de quem não é admin
  • Impedir que uma pessoa do suporte edite despesas

Cada pergunta tem seu status HTTP. 401 Unauthorized (o nome engana) significa "não sei quem você é": faltou login ou ele expirou. 403 Forbidden significa "sei quem você é, e você não pode fazer isso".

A Ana está logada e tenta abrir /admin/usuarios, que é só para administração. Qual status a API deve devolver?

  • 401 Unauthorized
  • 403 Forbidden
  • 400 Bad Request
  • 500 Internal Server Error

Guardar senhas sem guardá-las

A regra número um: o banco nunca guarda a senha como ela foi digitada. Bancos de dados vazam: por backup esquecido, por funcionário curioso, por ataque. Se as senhas estiverem lá em texto, quem pegar o arquivo entra na conta de todo mundo, e em outros sites onde as pessoas repetem a senha.

Sal (salt)
Um valor aleatório, diferente para cada pessoa, misturado à senha antes do hash. Duas pessoas com a senha 123456 ficam com registros diferentes, e tabelas prontas de senhas comuns deixam de funcionar.
Hash lento
Algoritmos feitos de propósito para demorar, como Argon2, bcrypt e PBKDF2. Um login leva milissegundos a mais; quem tenta bilhões de senhas num arquivo vazado leva anos a mais.

Pare de guardar a senha em texto

Hoje cadastrar_senha guarda a senha como veio. Reescreva usando a função pronta calcular_hash: gere um sal com secrets.token_hex(16) e devolva o texto sal$hash. Depois, em conferir_senha, separe o sal do hash com guardado.split("$"), recalcule e compare com hmac.compare_digest.

import hashlib
import hmac
import secrets


def calcular_hash(senha, sal):
    # Versão didática de um hash lento. Em projetos reais, use Argon2 ou bcrypt.
    resultado = (sal + senha).encode()
    for _ in range(10_000):
        resultado = hashlib.sha256(resultado).digest()
    return resultado.hex()


def cadastrar_senha(senha):
    return senha


def conferir_senha(senha, guardado):
    return senha == guardado


guardado = cadastrar_senha('pao-de-queijo-42')
print('No banco:', guardado)
print('Senha certa:', conferir_senha('pao-de-queijo-42', guardado))
print('Senha errada:', conferir_senha('123456', guardado))
  • A senha certa continua entrando
  • Uma senha errada é recusada
  • O que vai para o banco não contém a senha
  • A mesma senha gera registros diferentes (sal)

No projeto de verdade: uma biblioteca mantida faz tudo isso (aqui, argon2-cffi)

from argon2 import PasswordHasher

ph = PasswordHasher()
guardado = ph.hash("pao-de-queijo-42")   # já inclui sal e parâmetros
ph.verify(guardado, "pao-de-queijo-42")   # lança erro se não bater

Por que não usar só sha256(senha), sem sal e de uma vez só?

  • Porque o SHA-256 pode ser revertido para descobrir a senha
  • Porque ele é rápido demais e, sem sal, senhas iguais geram hashes iguais
  • Porque o resultado fica muito grande para o banco

Lembrar quem entrou: sessão ou token

O HTTP não tem memória: cada requisição chega sozinha. Para a pessoa não digitar a senha a cada clique, o login entrega uma prova que o cliente reapresenta nos pedidos seguintes. Há dois jeitos principais de fazer isso.

Login com sessão guardada no servidor e enviada por cookie

  1. Navegador → API: POST /login. O navegador envia e-mail e senha, sempre por HTTPS.
  2. API → Sessões: Cria sessão 8f3a…. A senha confere. A API cria um identificador aleatório e anota: sessão 8f3a… pertence à pessoa 1, válida por uma hora.
  3. API → Navegador: Set-Cookie: sessao=8f3a…. A resposta pede ao navegador que guarde um cookie com o identificador.
  4. Navegador → API: GET /despesas + Cookie. Daqui em diante, o navegador envia o cookie sozinho em cada pedido para esse site.
  5. API → Sessões: De quem é 8f3a…?. A API consulta o registro de sessões e descobre quem está pedindo. Para encerrar o acesso, basta apagar a sessão.

O token mais conhecido é o JWT (JSON Web Token): três pedaços separados por pontos. Ele é assinado, não criptografado: qualquer pessoa consegue ler o conteúdo, mas só o servidor, com a chave secreta, consegue produzir uma assinatura válida.

Um JWT. Explore os três pedaços.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwibm9tZSI6IkFuYSIsInBhcGVsIjoicGVzc29hIiwiZXhwIjoxNzkyMDAwMDAwfQ.Xy9p2kQm7rT4vB1nL8sW3eF6hJ0aZ5cD
  • Cabeçalho: Em base64, que é só uma forma de escrever bytes como texto: {"alg":"HS256","typ":"JWT"}. Diz qual algoritmo assinou. O servidor deve aceitar apenas o algoritmo que ele mesmo usa.
  • Conteúdo (payload): Decodificado: {"sub":"1","nome":"Ana","papel":"pessoa","exp":1792000000}. sub é quem, exp é quando expira. Qualquer pessoa lê isso: nunca coloque senha ou dado sensível aqui.
  • Assinatura: Calculada com o cabeçalho, o conteúdo e a chave secreta do servidor. Se alguém trocar pessoa por admin no conteúdo, a assinatura deixa de bater e o token é recusado.

Uma pessoa decodifica o próprio JWT, troca "papel":"pessoa" por "papel":"admin" e envia de volta. O que acontece numa API bem feita?

  • Ela vira admin, porque o token estava no computador dela
  • Nada muda, porque o conteúdo do JWT é criptografado
  • A API recusa com 401, porque a assinatura não confere mais

Um cookie de sessão bem configurado

Set-Cookie: sessao=8f3a91c2e7; HttpOnly; Secure; SameSite=Lax; Path=/; Max-Age=3600
  • HttpOnly: O JavaScript da página não consegue ler o cookie. Se um ataque de XSS rodar código na página, ele não rouba a sessão.
  • Secure: O cookie só viaja por HTTPS. Numa rede Wi-Fi pública, ninguém o captura no caminho.
  • SameSite: Limita o envio do cookie quando o pedido vem de outro site. É a principal defesa contra CSRF: um site malicioso que faz o seu navegador enviar pedidos para a API usando o seu login.
  • Validade: O cookie expira em uma hora (3600 segundos). Sessões que nunca expiram são um presente para quem rouba um computador desbloqueado.

Complete o cookie: ele não pode ser lido por JavaScript, só pode viajar por HTTPS e não deve ir em pedidos disparados por outros sites.

Set-Cookie: sessao=8f3a91c2e7; ____; ____; SameSite=____

Papéis e permissões: cada um com o seu

Autorização costuma combinar duas ideias. Papéis (roles) agrupam permissões: pessoa, suporte, admin. E a posse: mesmo sem papel especial, a dona de uma despesa pode lê-la e alterá-la, e mais ninguém.

A falha mais comum em APIs, primeira da lista de riscos de API da OWASP, é checar só o login e esquecer a posse. A rota GET /despesas/12 confere que existe alguém logado e devolve a despesa, sem perguntar de quem ela é. Trocar o 12 por 13 na URL basta para ler dados alheios.

Escreva a regra de acesso às despesas

Complete verificar_acesso. Regras: sem usuário, devolve 401. A dona da despesa (despesa["dono_id"] igual a usuario["id"]) pode qualquer ação: devolve 200. Quem tem papel suporte pode ler qualquer despesa (200), mas não editar nem apagar. Todo o resto devolve 403.

ana = {'id': 1, 'papel': 'pessoa'}
bruno = {'id': 2, 'papel': 'pessoa'}
suporte = {'id': 9, 'papel': 'suporte'}
despesa_da_ana = {'id': 7, 'dono_id': 1, 'valor': 412.9}


def verificar_acesso(usuario, acao, despesa):
    if usuario is None:
        return 401
    return 200


print('Bruno lendo a despesa da Ana:', verificar_acesso(bruno, 'ler', despesa_da_ana))
  • Sem login: 401
  • A dona pode editar a própria despesa
  • Outra pessoa não lê a despesa da Ana: 403
  • Outra pessoa não apaga a despesa da Ana: 403
  • O suporte lê, mas não edita

Teste os acessos como quem ataca

Uma API de laboratório está no ar. A despesa 7 é da Ana; a despesa 12 é do Bruno. Para facilitar, o token da Ana é o texto curto tok_ana, enviado no cabeçalho Authorization: Bearer tok_ana. Teste o acesso sem login, o acesso legítimo e as tentativas de mexer no que não é dela.

  1. Peça a despesa 7 sem enviar token nenhum, mostrando o status com -i.

    curl -i http://localhost:8000/despesas/7
    HTTP/1.1 401 Unauthorized
    www-authenticate: Bearer
    content-type: application/json
    
    {"erro":"nao_autenticado","mensagem":"Faça login para continuar."}
  2. Agora peça a mesma despesa com o token da Ana, usando -H "Authorization: Bearer tok_ana".

    curl -i -H "Authorization: Bearer tok_ana" http://localhost:8000/despesas/7
    HTTP/1.1 200 OK
    content-type: application/json
    
    {"id":7,"descricao":"Mercado do mês","valor":412.9,"dono_id":1}
  3. Com o token da Ana, tente ler a despesa 12, que é do Bruno.

    curl -i -H "Authorization: Bearer tok_ana" http://localhost:8000/despesas/12
    HTTP/1.1 403 Forbidden
    content-type: application/json
    
    {"erro":"sem_permissao","mensagem":"Você não tem acesso a esta despesa."}
  4. Ainda com o token da Ana, tente apagar a despesa 12 com -X DELETE.

    curl -i -H "Authorization: Bearer tok_ana" -X DELETE http://localhost:8000/despesas/12
    HTTP/1.1 403 Forbidden
    content-type: application/json
    
    {"erro":"sem_permissao","mensagem":"Você não tem acesso a esta despesa."}
  5. Confirme que a despesa 12 continua lá, pedindo-a com o token do Bruno, tok_bruno.

    curl -i -H "Authorization: Bearer tok_bruno" http://localhost:8000/despesas/12
    HTTP/1.1 200 OK
    content-type: application/json
    
    {"id":12,"descricao":"Conta de luz","valor":138.4,"dono_id":2}

Os erros que mais aparecem

A OWASP, uma comunidade aberta de segurança, mantém listas dos problemas mais frequentes em aplicações e APIs. Quase todos os de autenticação e autorização se repetem nos projetos de quem está começando, e todos têm solução conhecida.

Senha em texto ou com hash rápido

Um vazamento vira acesso imediato a todas as contas. Use Argon2 ou bcrypt por meio de uma biblioteca mantida.

Checar só o login

Toda rota que recebe um id precisa conferir se o recurso pertence a quem pede, no servidor.

Esconder o botão e achar que protegeu

Esconder no frontend é conforto. A API precisa recusar mesmo que alguém chame a rota com curl.

Segredos no repositório

Chave do JWT, senha do banco e chaves de API ficam em variáveis de ambiente ou num cofre, nunca no Git.

Tentativas ilimitadas

Sem limite de requisições (rate limit) no login, um robô testa milhares de senhas por minuto.

Mensagens que entregam demais

"E-mail não cadastrado" conta a quem ataca quais e-mails existem. Prefira "E-mail ou senha inválidos".

Cada prática deixa o sistema mais seguro ou mais exposto?

Mais seguro · Mais exposto

  • Cookie de sessão com HttpOnly, Secure e SameSite
  • Bloquear o login por alguns minutos após várias senhas erradas
  • Conferir o dono da despesa em toda rota com id
  • Usar a biblioteca de autenticação do framework
  • Guardar a chave do JWT no arquivo config.py do Git
  • Colocar o CPF da pessoa no conteúdo do JWT
  • Aceitar API sem HTTPS na rede interna da empresa
  • Responder "este e-mail não existe" no login
Se a autorização é tão importante, por que tantos sistemas falham nela mesmo com login bem feito?

Porque o login é feito uma vez, num lugar só, e a autorização precisa ser lembrada em cada rota. Basta uma rota nova sem a verificação. Por isso vale centralizar a regra numa função, como a verificar_acesso que você escreveu, e ter testes que tentam acessar dados alheios.

Fechamento

  • Autenticação confirma quem é; autorização decide o que essa pessoa pode fazer. Falhas respondem 401 e 403, respectivamente.
  • Senhas nunca são guardadas em texto: use um hash lento com sal, de preferência por uma biblioteca mantida como Argon2 ou bcrypt.
  • Depois do login, o cliente reapresenta uma prova: um cookie de sessão (com HttpOnly, Secure e SameSite) ou um token assinado como o JWT, que pode ser lido por qualquer pessoa.
  • Autorização combina papéis e posse, e precisa ser verificada no servidor em toda rota que acessa um recurso.
  • Os erros mais comuns têm solução conhecida: segredos fora do Git, limite de tentativas, mensagens discretas e testes que tentam acessar dados alheios.

Prove que ninguém mexe nas despesas de outra pessoa

Na API de despesas que você está construindo, ou numa API de laboratório autorizada, implemente ou verifique o acesso por usuário. Use a biblioteca de autenticação da sua stack em vez de escrever criptografia à mão.

  1. Crie duas contas de teste, cada uma com algumas despesas
  2. Confirme que as senhas estão guardadas com hash e sal, olhando a tabela de usuários no banco
  3. Chame as rotas de ler, alterar e apagar sem login e anote se todas respondem 401
  4. Com o login de uma conta, tente ler, alterar e apagar uma despesa da outra e confira se nada vaza nem muda
  5. Se usar cookies, verifique no painel de rede do navegador se HttpOnly, Secure e SameSite estão presentes
  6. Transforme essas tentativas em testes automatizados que rodam a cada mudança

Referências

Cursos relacionados