◇ OpenCyber Academy
Profissionalizante · Capítulo 10 · Português

Capítulo 10 — Criptografia e serviços de confiança: qualidade e solução de problemas

Ensino gratuito e aberto para quem deseja proteger pessoas e tecnologias. Não é preciso criar uma conta para estudar ou consultar as respostas.

Capítulo 10 — Criptografia e serviços de confiança: qualidade e solução de problemas

Mapa da aula

Aula 10 publicada. Mapa, exemplo, EX046.

flowchart TD
  N0["10.1 Um achado no portal da equipe"]
  N1["10.2 Verificando a correção"]
  N2["Laboratório — PBKDF2 com salt versus hash rápido"]
  N3["10.3 Qualidade pela revisão"]
  N4["Síntese"]
  N0 --> N1 --> N2 --> N3 --> N4
  N4 --> EX["Exemplo resolvido"]
  EX --> Q["Exercício EX046"]

Desenho lógico

flowchart LR
  N0["10.1 Um achado no portal da equipe"]
  N1["10.2 Verificando a correção"]
  N2["Laboratório — PBKDF2 com salt versus hash rápido"]
  N3["10.3 Qualidade pela revisão"]
  N4["Síntese"]
  N0 --> N1 --> N2 --> N3 --> N4 --> Q["EX046"]

[10.1 Um achado no portal da equipe]
    |
    v
[10.2 Verificando a correção]
    |
    v
[Laboratório — PBKDF2 com salt versus hash rápido]
    |
    v
[10.3 Qualidade pela revisão]
    |
    v
[Síntese]
    |
    v
[Exemplo resolvido] --> [Exercício EX046]

Objetivos de aprendizagem

Você vai (1) diagnosticar uma fraqueza de armazenamento de senhas num portal da equipe; (2) verificar uma correção que usa uma função de derivação de chaves; (3) melhorar a qualidade do fluxo com revisão e retrospectivas.

10.1 Um achado no portal da equipe

O pequeno portal de escalas da equipe da Bayside, construído pela agência, armazena as senhas dos funcionários. Durante uma revisão, Dana vê na exportação de configuração que as senhas são armazenadas como hashes SHA-256 sem salt. Hashes rápidos permitem que um atacante que roube o banco de dados teste um número enorme de palpites rapidamente e, sem salt, senhas idênticas produzem hashes idênticos. O armazenamento de senhas precisa de uma função lenta e com salt. O hashlib.pbkdf2_hmac do Python implementa o PBKDF2, e escolhas mais fortes, que exigem muita memória, incluem o scrypt da RFC 7914 e o Argon2id da RFC 9106. A recomendação de Dana é usar uma biblioteca mantida que implemente uma delas, e não projetar um esquema próprio.

10.2 Verificando a correção

A agência propõe PBKDF2-HMAC-SHA-256 com um salt aleatório de 16 bytes por usuário e uma contagem alta de iterações definida pela política, migrando cada usuário no próximo login. Dana verifica a abordagem num laboratório com usuários sintéticos: dois funcionários com a mesma senha recebem valores armazenados diferentes; a senha correta é verificada e uma errada falha; e o tempo por palpite é muito maior que o de um único SHA-256. O laboratório abaixo mostra esses resultados. Ela registra que o laboratório confirma o comportamento do método, enquanto o código de produção da agência ainda precisa de sua própria revisão.

Laboratório — PBKDF2 com salt versus hash rápido

# Salted PBKDF2-HMAC-SHA-256 vs one SHA-256, synthetic staff. Teaching only; use a maintained library in production.
import hashlib, hmac, secrets, time
ITER = 600_000   # lab value; production iteration count comes from policy
def store(pw):
    s = secrets.token_bytes(16); return s, hashlib.pbkdf2_hmac("sha256", pw, s, ITER)
def check(pw, rec): return hmac.compare_digest(hashlib.pbkdf2_hmac("sha256", pw, rec[0], ITER), rec[1])
a, b = store(b"Rota-Clinic-3"), store(b"Rota-Clinic-3")
print("same password, different stored values:", a[1] != b[1])
print("correct password:", check(b"Rota-Clinic-3", a), "| wrong password:", check(b"Rota-Clinic-4", a))
t0 = time.perf_counter(); [hashlib.sha256(b"Rota-Clinic-3").digest() for _ in range(10000)]; fast = (time.perf_counter() - t0) / 10000
t0 = time.perf_counter(); check(b"x", a); slow = time.perf_counter() - t0
print(f"per-guess cost ratio PBKDF2/SHA-256: {'over 10,000x' if slow / fast > 10000 else 'under 10,000x'}")

Execute com python3 lab_pbkdf2.py. Saída verificada:

same password, different stored values: True
correct password: True | wrong password: False
per-guess cost ratio PBKDF2/SHA-256: over 10,000x

10.3 Qualidade pela revisão

Erros escapam em todo fluxo de trabalho, então a Copperleaf incorpora verificações de qualidade. Cada relatório é revisado por um segundo analista antes de ir ao cliente. Depois de cada ciclo mensal, a equipe passa quinze minutos numa retrospectiva: o que deu certo, o que deu errado e uma mudança para o mês seguinte. Quando o novo teste de Dana da correção da cadeia quase deixou passar o segundo servidor, a retrospectiva levou a uma regra: endpoints com balanceamento de carga são testados uma vez por backend. Pequenas melhorias constantes como essa elevam a qualidade de todo o serviço mais do que esforços heroicos ocasionais.

Exemplo resolvido

Dana documenta o achado do SHA-256 sem salt, executa o laboratório de PBKDF2 para confirmar a abordagem da agência e acrescenta uma regra de teste por backend depois de uma retrospectiva.

Caso sintético. O portal de escalas, os usuários e a contagem de iterações são sintéticos; a RFC 7914 e a RFC 9106 são reais.

Erros e limites

Os tempos do laboratório variam conforme a máquina; mostram o custo relativo, não a velocidade de um atacante. A atualização no login deixa as contas inativas com os hashes antigos.

Exercícios

Síntese

A qualidade vem de verificar as correções com métodos sólidos e de revisões e retrospectivas constantes.

Continue estudando — aula 10 (capítulo 10 de 12)

← Capítulo 09 · Índice das aulas · Capítulo 11 →

Continue para a próxima aula já escrita.