Criptografia para Hackers: Algoritmos, PKI e Ataques Criptográficos

Criptografia para Hackers: Algoritmos, PKI e Ataques Criptográficos

Se você está na série CEH v13 Zero to Hero, já percebeu que criptografia aparece em todo lugar — desde senhas armazenadas em banco de dados até comunicações na web. Para o pentester, entender criptografia não é sobre virar matemático. É sobre saber onde procurar fraquezas.

1. Por que Criptografia Importa para o Hacker

Quando um atacante encontra dados cifrados, a primeira pergunta é: “posso quebrar isso?”. Mas a resposta correta é quase sempre outra: “posso contornar?”.

A realidade desconfortável da segurança criptográfica é que a esmagadora maioria das vulnerabilidades não está nos algoritmos — está na implementação. Chaves hard-coded, TLS desatualizado, CBC mal configurado, geração de números aleatórios previsível, fallback para cifras fracas. A lista é longa.

O pentester que entende criptografia sabe identificar esses problemas rapidamente num assessment. O que não entende, passa reto.

2. Criptografia Simétrica

Na criptografia simétrica, uma mesma chave serve tanto para cifrar quanto para decifrar. É o modelo mais intuitivo: você tranca a porta com a chave, destranca com a mesma chave. É rápida, eficiente, e dominante em cenários onde as duas pontas já compartilham um segredo.

Algoritmos Principais

Algoritmo	Tamanho da Chave	Tipo	Status
AES	128/192/256 bits	Block cipher	Padrão atual
ChaCha20	256 bits	Stream cipher	Seguro, popular no mobile
3DES	168 bits (efetivo ~112)	Block cipher	Deprecated (NIST)
Blowfish	128–448 bits	Block cipher	Limitações no tamanho do bloco
DES	56 bits	Block cipher	Quebrado
RC4	40–2048 bits	Stream cipher	Quebrado (WEP usava)

AES (Advanced Encryption Standard) venceu a competição do NIST em 2001 e é o padrão global. Chaves de 256 bits oferecem 2²⁵⁶ combinações — mais do que átomos no universo observável. Não existe ataque prático conhecido contra o AES quando usado corretamente.

Block Cipher vs Stream Cipher

Block ciphers (AES, DES) processam dados em blocos fixos (tipicamente 16 bytes). Precisam de padding quando o dado não preenche o bloco. Stream ciphers (RC4, ChaCha20) geram um fluxo contínuo de bits que é XORed com o plaintext — sem padding, mas cada bit do keystream só pode ser usado uma vez.

Modos de Operação (AES)

O modo ECB (Electronic Codebook) cifra cada bloco independentemente com a mesma chave. Blocos idênticos no plaintext produzem blocos idênticos no ciphertext — isso vaza padrões visuais. Nunca use ECB.

• CBC (Cipher Block Chaining) — cada bloco é XORed com o ciphertext do bloco anterior. Requer IV. Seguro, mas vulnerável a padding oracle se a implementação vazar informações sobre o padding.
• CTR (Counter) — transforma o block cipher em stream cipher. O nonce+counter é cifrado e XORed com o plaintext. Paralelizável, sem padding.
• GCM (Galois/Counter Mode) — combina CTR com autenticação (AEAD). Fornece confidencialidade e integridade. É o padrão recomendado atualmente.

3. Criptografia Assimétrica

Na criptografia assimétrica, cada parte tem um par de chaves: uma pública e uma privada. A pública cifra; a privada decifra. Ou inversamente: a privada assina; a pública verifica. Resolve o problema fundamental da criptografia simétrica: como compartilhar a chave de forma segura?

RSA

RSA baseia-se na dificuldade de fatorar números primos muito grandes. Chaves RSA de 2048 bits são o mínimo aceitável hoje, com 4096 bits para maior margem. O NIST recomenda 2048 bits até 2030.

ECC (Criptografia de Curvas Elípticas)

ECC oferece segurança equivalente ao RSA com chaves muito menores. Uma chave ECC de 256 bits equivale a RSA 3072 bits. Menor chave = menos CPU, menos banda, ideal para IoT e mobile.

Nível de Segurança	RSA	ECC	AES
128 bits	3072 bits	256 bits	128 bits
192 bits	7680 bits	384 bits	192 bits
256 bits	15360 bits	512 bits	256 bits

Diffie-Hellman (DH)

Diffie-Hellman não cifra dados — é um protocolo de troca de chaves. Duas partes geram um segredo compartilhado sem nunca transmiti-lo pela rede. ECDHE (Elliptic Curve Diffie-Hellman Ephemeral) é a variante moderna: usa curvas elípticas e chaves efêmeras (novas a cada sessão). É o que o TLS 1.3 usa por padrão — e garante Perfect Forward Secrecy.

Geração de Chaves com OpenSSL

# Gerar par de chaves RSA de 4096 bits
openssl genrsa -out private.key 4096

# Extrair a chave pública
openssl rsa -in private.key -pubout -out public.key

# Gerar par ECC (curva P-256)
openssl ecparam -genkey -name prime256v1 -noout -out ec_private.key
openssl ec -in ec_private.key -pubout -out ec_public.key

4. Hashing

Funções hash são unidirecionais: você converte um dado em um hash, mas não consegue reconstruir o dado a partir dele. Servem para integridade, não para confidencialidade. Propriedades ideais: determinística, efeito avalanche, resistente a colisões e pré-imagem.

Algoritmos de Hash

Algoritmo	Tamanho	Status
MD5	128 bits	Quebrado — colisões em <1 segundo
SHA-1	160 bits	Deprecated — SHAttered attack (2017)
SHA-256	256 bits	Padrão atual (SHA-2)
SHA-3	256/384/512 bits	Novo padrão NIST (Keccak)
bcrypt	Variável	Recomendado para senhas
Argon2	Variável	Vencedor PHC — melhor para senhas

Hashing de Senhas: Por que SHA-256 Não Serve

SHA-256 é rápido — calcula bilhões de hashes por segundo em GPU otimizada (e centenas de milhões em CPU típica). Isso é ruim para senhas, porque o atacante quer tentar muitas combinações. Para senhas, usa-se funções intencionalmente lentas: bcrypt, scrypt e Argon2. Estas incorporam salt (dados aleatórios únicos por senha, impedindo rainbow tables) e stretching (múltiplas iterações). Argon2 vai além: é resistente a ataques via GPU/ASIC por exigir muita memória.

HMAC

HMAC (Hash-based Message Authentication Code) combina um hash com uma chave secreta. Garante integridade e autenticidade — só quem tem a chave pode gerar ou verificar. É usado em JWT (HS256), APIs, e TLS.

Identificando Hashes com hashid

$ hashid "5d41402abc4b2a76b9719d911017c592"
Analyzing '5d41402abc4b2a76b9719d911017c592'
[+] MD5
[+] NTLM

$ hashid '$2b$12$LJ3m4ys3Kq0ZG5e5O5Y6...'
Analyzing '$2b$12$LJ3m4ys3Kq0ZG5e5O5Y6...'
[+] Blowfish(OpenBSD)
[+] Woltlab Burning Board 4.x

5. Certificados Digitais e PKI

Como confiar que a chave pública de um site realmente pertence àquele site? A resposta é PKI (Public Key Infrastructure).

Componentes da PKI

• CA (Certificate Authority) — entidade que emite e assina certificados. Âncora de confiança. Exemplos: DigiCert, Let’s Encrypt, GlobalSign.
• RA (Registration Authority) — verifica a identidade do solicitante antes da emissão.
• CRL (Certificate Revocation List) — lista assinada pela CA com certificados revogados. Pode ficar enorme.
• OCSP (Online Certificate Status Protocol) — consulta online em tempo real: “este certificado ainda é válido?”. OCSP stapling mitiga questões de latência e privacidade.

Certificado X.509

Estrutura de um certificado X.509:

• Version — v3 é a atual
• Serial Number — identificador único
• Issuer — quem emitiu (a CA)
• Subject — a quem pertence
• Validity — notBefore e notAfter
• Public Key — a chave pública do subject
• Signature Algorithm — ex: SHA-256 with RSA
• Signature — assinatura da CA sobre o certificado
• Extensions (v3) — SAN, Key Usage, Extended Key Usage, etc.

Certificate Chain

Navegadores vêm com um conjunto de Root CAs confiáveis. A cadeia: certificado do servidor é assinado por uma Intermediate CA, que é assinada por uma Root CA. Se o navegador confia na Root, confia em toda a cadeia.

Let’s Encrypt

CA gratuita, automatizada e open-source. Usa o protocolo ACME. Certificados válidos por 90 dias, renovados automaticamente. Revolucionou a adoção de HTTPS.

# Inspeccionar certificado de um site
openssl s_client -connect example.com:443 -showcerts \
  </dev/null 2>/dev/null | openssl x509 -text -noout

# Verificar cadeia de certificados
openssl verify -CAfile /etc/ssl/certs/ca-certificates.crt cert.pem

6. SSL/TLS Handshake

TLS (Transport Layer Security) protege praticamente toda comunicação web. Entender o handshake é essencial para o pentester — é onde as decisões criptográficas acontecem.

TLS 1.2 vs TLS 1.3

TLS 1.3 (2018) eliminou cifras obsoletas (RC4, 3DES, CBC), forçou Perfect Forward Secrecy, e reduziu o handshake de 2 RTT para 1 RTT (ou 0-RTT com resumption).

Aspecto	TLS 1.2	TLS 1.3
RTTs no handshake	2	1 (0-RTT com resumption)
Cipher suites suportadas	~37	5
PFS obrigatório	Não (RSA key exchange permitido)	Sim (apenas ECDHE/DHE)
CBC permitido	Sim	Não
AES-GCM / ChaCha20	Opcional	Obrigatório (AEAD apenas)

Handshake TLS 1.3 — Diagrama

  CLIENT                                      SERVER
    |                                            |
    |  1. ClientHello                            |
    |  (cipher suites, key_share, supported_versions)
    |  -----------------------------------------> |
    |                                            |
    |  2. ServerHello                            |
    |  (cipher suite escolhida, key_share)       |
    |  <----------------------------------------- |
    |                                            |
    |  3. [EncryptedExtensions]                  |
    |  4. [Certificate]                          |
    |  5. [CertificateVerify]                    |
    |  6. [Finished]                             |
    |  <----------------------------------------- |
    |                                            |
    |  7. [Finished]                             |
    |  -----------------------------------------> |
    |                                            |
    |  ========== Application Data ===========   |
    |  (conexão segura estabelecida)             |

No TLS 1.3, o cliente já envia o key_share no ClientHello, permitindo que o servidor responda com a chave de sessão no ServerHello — tudo em 1 RTT. No TLS 1.2, a troca de chaves requeria uma mensagem extra.

Cipher Suites

Uma cipher suite define o conjunto de algoritmos: chave exchange, autenticação, cifra bulk, e MAC. Exemplo em TLS 1.3: TLS_AES_256_GCM_SHA384 — significa AES-256-GCM para cifragem, SHA-384 para HMAC.

TLS 1.3 tem apenas 5 cipher suites, todas seguras:

• TLS_AES_256_GCM_SHA384
• TLS_CHACHA20_POLY1305_SHA256
• TLS_AES_128_GCM_SHA256
• TLS_AES_128_CCM_SHA256
• TLS_AES_128_CCM_8_SHA256

Perfect Forward Secrecy (PFS)

PFS garante que se a chave privada do servidor for comprometida no futuro, comunicações passadas permanecem seguras. Isso só é possível quando a troca de chaves usa chaves efêmeras (ECDHE ou DHE) — a chave de sessão é gerada a cada conexão e descartada depois. Sem PFS (RSA key exchange no TLS 1.2), a chave privada do servidor decifra tudo.

TLS 1.0 e 1.1 estão oficialmente deprecated (RFC 8996). Suportam cifras inseguras (RC4, DES), são vulneráveis a BEAST, POODLE, e não oferecem PFS confiável. Nenhum browser moderno aceita TLS 1.0/1.1. Se o seu assessment encontrar um site aceitando essas versões, é um finding de criticidade alta.

7. Ataques Criptográficos

Aqui está onde o conhecimento de criptografia se torna concreto para o pentester. Os ataques mais impactantes não “quebram” o algoritmo — exploram a implementação.

Brute-Force

Tentar todas as chaves possíveis até encontrar a certa. Impraticável contra AES-256 (2²⁵⁶ combinações), mas viável contra chaves fracas: DES (56 bits, quebrável em horas), senhas curtas, WEP keys. Ferramentas: Hashcat, John the Ripper.

Birthday Attack (Ataque dos Aniversários)

Baseado no paradoxo do aniversário: com 23 pessoas, a chance de duas fazerem aniversário no mesmo dia é ~50%. Aplicado a hashes: se uma função produz N outputs, precisa de ~√N tentativas para encontrar uma colisão. É por isso que SHA-256 (256 bits) tem força de 128 bits contra colisões — √(2²⁵⁶) = 2¹²⁸.

Replay Attack

O atacante captura uma mensagem legítima e a reenvia. Sem proteção (timestamps, nonces, sequência numérica), o sistema aceita como nova. Mitigação: incluir nonces, timestamps, e usar protocolos com challenge-response.

Man-in-the-Middle (MITM) no TLS

• SSL Stripping — o atacante força a comunicação para HTTP, intercepta, e faz a conexão HTTPS por ele. O usuário nem percebe. Ferramenta: sslstrip.
• Downgrade Attack — força o cliente e servidor a negociar uma versão mais antiga/fraca do TLS. Ex: FREAK (forçar export-grade RSA de 512 bits), Logjam (forçar DHE de 512 bits).

Padding Oracle Attack

Explora sistemas que revelam se o padding de um bloco cifrado (CBC) é válido ou não. A partir dessa informação, o atacante decifra o ciphertext byte a byte — sem conhecer a chave. Vários frameworks web já foram afetados. O CEH considera isso essencial.

Ataques Históricos Famosos

• BEAST (2011) — explora CBC no TLS 1.0. O atacante usa dados known-plaintext para decifrar blocos. Mitigação: TLS 1.1+ com 1/n-1 splitting.
• CRIME (2012) — explora compressão (SPDY, TLS compression) para vazar cookies via chosen-plaintext. O atacante observa o tamanho da resposta para inferir o conteúdo. Mitigação: desabilitar compressão no TLS.
• POODLE (2014) — explora CBC no SSL 3.0. Permite decifrar bytes de dados. Motivo final para depreciar SSL 3.0.
• Heartbleed (2014) — bug no OpenSSL. Permite ler até 64KB da memória do servidor por heartbeat malformado. Vazou chaves privadas de milhares de servidores. Um dos bugs mais impactantes da história da internet.

Side-Channel Attacks

Ataques que não atacam o algoritmo diretamente, mas observam efeitos colaterais da execução: tempo de resposta (timing attack), consumo de energia, emissão eletromagnética. Se uma implementação de comparação de senhas retorna mais rápido quando o primeiro caractere está correto, o atacante pode medir o tempo e deduzir a senha caractere a caractere. Sempre compare com constant-time functions.

8. Ferramentas

OpenSSL — O Canivete Suíço da Criptografia

OpenSSL é a biblioteca e ferramenta de linha de comando mais usada no mundo para operações criptográficas. Quase tudo que envolve TLS no Linux passa por ela.

# Cifrar um arquivo com AES-256-CBC
openssl enc -aes-256-cbc -salt -in arquivo.txt -out arquivo.enc

# Decifrar
openssl enc -aes-256-cbc -d -in arquivo.enc -out arquivo_decrypted.txt

# Gerar hash SHA-256 de um arquivo
openssl dgst -sha256 arquivo.txt

# Gerar hash com bcrypt (via Python)
python3 -c "import bcrypt; print(bcrypt.hashpw(b'senha123', bcrypt.gensalt()))"

# Verificar conexão TLS de um site (versão, cipher, certificado)
openssl s_client -connect example.com:443 -tls1_3

# Criar CSR (Certificate Signing Request)
openssl req -new -key private.key -out request.csr -subj "/CN=example.com/O=MinhaOrg"

# Criar certificado self-signed
openssl x509 -req -in request.csr -signkey private.key -out cert.crt -days 365

# Converter formatos
openssl x509 -in cert.pem -outform DER -out cert.der
openssl pkcs12 -export -in cert.crt -inkey private.key -out bundle.p12

CyberChef

Ferramenta web (open-source, pode rodar localmente) criada pela GCHQ. Interface visual tipo “data pipeline”: você encadeia operações (base64 decode → AES decrypt → hash). Ideal para CTFs e análise rápida de dados cifrados sem instalar nada.

Casos de uso: decodificar base64, identificar se um hash é reversível, tentar decifrar com chave conhecida, detectar o tipo de codificação, aplicar magic (identificação automática).

Hashcat e John the Ripper

As ferramentas padrão para cracking de hashes. Ambas suportam centenas de formatos de hash e modos de ataque (brute-force, dictionary, mask, rules).

# Hashcat — quebrar hash MD5 com wordlist
hashcat -m 0 -a 0 hash.txt rockyou.txt

# Hashcat — quebrar hash bcrypt (modo 3200)
hashcat -m 3200 -a 0 bcrypt_hash.txt rockyou.txt

# John the Ripper — detectar formato e quebrar
john --wordlist=rockyou.txt hash.txt

SSL Labs (Qualys)

Teste online gratuito que avalia a configuração TLS de qualquer site publicamente acessível. Gera uma nota A+ a F com detalhamento completo: versões suportadas, cipher suites, PFS, HSTS, cert chain, etc. Se você faz pentest web, sslabs.com é obrigatório.

testssl.sh

Script Bash que faz localmente o que SSL Labs faz remotamente. Útil para testar servidores internos, behind firewalls, ou quando você não quer enviar dados para terceiros.

# Teste completo de TLS
./testssl.sh example.com

# Testar apenas cipher suites
./testssl.sh -E example.com

# Testar apenas vulnerabilidades
./testssl.sh -U example.com

9. Hands-on

Laboratório 1: OpenSSL — PKI do Zero

# PASSO 1: Gerar par de chaves RSA
openssl genrsa -out ca.key 4096

# PASSO 2: Criar certificado da CA (self-signed)
openssl req -new -x509 -days 365 -key ca.key -out ca.crt \
  -subj "/C=BR/ST=SP/L=Sao Paulo/O=Lab Cripto/CN=Minha CA"

# PASSO 3: Gerar chave para o servidor
openssl genrsa -out server.key 2048

# PASSO 4: Criar CSR
openssl req -new -key server.key -out server.csr \
  -subj "/C=BR/ST=SP/L=Sao Paulo/O=Lab Cripto/CN=meusite.local"

# PASSO 5: Assinar o CSR com a CA
openssl x509 -req -days 365 -in server.csr -CA ca.crt -CAkey ca.key \
  -CAcreateserial -out server.crt -extfile <(echo "subjectAltName=DNS:meusite.local")

# PASSO 6: Verificar o certificado
openssl x509 -in server.crt -text -noout

# PASSO 7: Verificar cadeia
openssl verify -CAfile ca.crt server.crt
# Output esperado: server.crt: OK

Laboratório 2: Inspeccionar TLS de um Site

# Conectar e ver detalhes do handshake
openssl s_client -connect google.com:443 -tls1_3

# Extrair o certificado do servidor
openssl s_client -connect google.com:443  google.crt

# Verificar datas de validade
openssl x509 -in google.crt -noout -dates

# Verificar para qual host o certificado é válido (SAN)
openssl x509 -in google.crt -noout -ext subjectAltName

# Listar cipher suites suportadas
openssl s_client -connect google.com:443 -cipher 'ALL:COMPLEMENTOFDEFAULT'

Laboratório 3: Hashing e Identificação

# Gerar hashes para comparação
echo -n "senha123" | md5sum
echo -n "senha123" | sha256sum

# Identificar um hash desconhecido
hashid '$6$rounds=5000$saltsalt$hashhashhash...'
# Output: SHA-512 (Unix)

# Usar CyberChef para análise visual de dados codificados
# 1. Abra gchq.github.io/CyberChef/
# 2. Cole o dado suspeito no input
# 3. Adicione o operador "Magic" para identificação automática
# 4. Encadeie operações para decodificar/descriptografar

10. Contra-medidas

Para cada ataque, uma defesa. Aqui estão as recomendações atuais para implementação segura de criptografia:

Algoritmos e Protocolos

• AES-256-GCM para cifragem simétrica. É AEAD (autenticação + cifragem) e é o padrão moderno. ChaCha20-Poly1305 como alternativa quando hardware não tem aceleração AES-NI.
• TLS 1.3 exclusivamente. Desabilite TLS 1.0, 1.1 e 1.2. Se não for possível desabilitar 1.2, restrinja cipher suites a AEAD apenas e exija PFS.
• SHA-256+ ou SHA-3 para hashing de dados. Argon2id para senhas (bcrypt como alternativa aceitável).
• RSA-2048 mínimo para assimétrica, preferencialmente RSA-4096 ou ECC P-256/P-384.

Certificate Pinning

Certificate pinning associa uma conexão a um certificado ou chave pública específica, impedindo que um certificado válido emitido por outra CA seja aceito. Protege contra CA comprometidas. Implementar no app (mobile/desktop) via TrustManager customizado ou em APIs via header Public-Key-Pins (embora HPKP esteja deprecated nos browsers).

Key Rotation

Rotacionar chaves periodicamente limita o dano de uma chave comprometida. Certificados Let’s Encrypt já forçam isso com validade de 90 dias. Para chaves de cifra de dados, defina uma política de rotação compatível com o ciclo de vida da aplicação.

HSM (Hardware Security Module)

HSMs são dispositivos dedicados ao gerenciamento seguro de chaves criptográficas. As chaves nunca saem do hardware — todas as operações criptográficas acontecem dentro do módulo. Protege contra extração de chaves, mesmo com acesso físico ou root ao servidor. Usado em ambientes que exigem compliance (PCI-DSS, HIPAA).

NIST Post-Quantum Cryptography

Computadores quânticos suficientemente potentes quebrariam RSA e ECC (via algoritmo de Shor). O NIST já padronizou os primeiros algoritmos pós-quânticos em 2024: CRYSTALS-Kyber (encapsulamento de chave) e CRYSTALS-Dilithium (assinatura). A transição já começou — Google, Apple e Cloudflare já implementam hibridização (X25519+Kyber) no TLS.

Geração de Números Aleatórios

Toda criptografia depende de aleatoriedade. Se o PRNG (Pseudo-Random Number Generator) for fraco ou previsível, todas as chaves geradas são comprometidas. Use /dev/urandom (Linux), CryptGenRandom (Windows) ou APIs criptográficas do SO. Nunca use rand(), Math.random(), ou seeds baseados em timestamps para fins criptográficos.

11. Tabela de Referência Rápida

Categoria	Algoritmo	Uso	Status
Simétrica	AES-256-GCM	Cifragem de dados	Padrão
Simétrica	ChaCha20-Poly1305	Cifragem (mobile/IoT)	Padrão
Assimétrica	RSA-4096 / ECC P-256	Troca de chaves, assinatura	Padrão
Troca de chaves	ECDHE	Handshake TLS (PFS)	Obrigatório no TLS 1.3
Hash	SHA-256 / SHA-3	Integridade de dados	Padrão
Hash de senhas	Argon2id / bcrypt	Armazenamento de senhas	Padrão
Protocolo	TLS 1.3	Comunicação segura	Padrão
Simétrica	DES / RC4	Nenhum	Quebrado — proibido
Hash	MD5 / SHA-1	Checksums não sensíveis	Quebrado — proibido para segurança
Protocolo	SSL 3.0 / TLS 1.0/1.1	Nenhum	Deprecated — proibido

Próximo Artigo

No Artigo 20 da série CEH v13 Zero to Hero, vamos abordar o OWASP Top 10 — as 10 vulnerabilidades web mais críticas segundo o Open Web Application Security Project. Muitas das falhas criptográficas que vimos aqui aparecem diretamente na categoria “Cryptographic Failures” do Top 10. Vamos ver como o OWASP classifica, prioriza e recomenda defesas para cada tipo de vulnerabilidade — e como o pentester usa essa lista como base para qualquer assessment web. Até lá.