Quebra de senhas Linux (arquivos Shadow)

Extração e quebra de credenciais de autenticação Unix/Linux

O que você vai descobrir

🎯 Por que isso importa

Sistemas Linux e Unix alimentam a maioria dos servidores web, infraestrutura de nuvem e sistemas empresariais críticos. Entender como extrair e quebrar senhas Linux é essencial para testes de penetração, auditorias de segurança e resposta a incidentes. Diferente do Windows, o Linux usa hashing de senhas robusto por padrão (SHA-512, yescrypt, Blowfish), mas senhas fracas permanecem vulneráveis apesar da criptografia sólida. Profissionais de segurança precisam de habilidades em quebra de senhas Linux para avaliar políticas de senhas em servidores, avaliar o impacto de ataques de acesso físico, e demonstrar que hashing robusto sozinho não garante segurança sem requisitos de senha apropriados.

🔍 O que você vai aprender

Você vai dominar a extração de credenciais Linux de /etc/shadow, entender o formato e segurança dos hashes de senha SHA-512, SHA-256, MD5 e yescrypt, aprender a usar unshadow para combinar os arquivos /etc/passwd e /etc/shadow, e desenvolver habilidades em quebra de senhas Linux com John the Ripper e hashcat. Essas técnicas são críticas para testes de penetração em servidores Linux, avaliação de políticas de senhas em sistemas de produção, recuperação de acesso a contas bloqueadas, e entendimento de como atacantes pivoteiam através da infraestrutura Linux usando credenciais comprometidas.

🚀 Sua primeira vitória

Nos próximos 15 minutos, você vai entender como o Linux armazena senhas em /etc/shadow, aprender a identificar diferentes tipos de hash pelo seu formato, e saber exatamente como profissionais de segurança quebram credenciais Linux durante avaliações autorizadas.

🔧 Experimente isso agora

Vamos examinar como os hashes de senha Linux são armazenados no arquivo /etc/shadow:

# Visualizar arquivo shadow (requer root)
sudo cat /etc/shadow

# Formato: username:hash:lastchange:min:max:warn:inactive:expire:reserved
# Exemplo de entrada:
# hdna:$6$rounds=5000$salt$hash:19000:0:99999:7:::

# Decomposição do formato de hash:
# $6$ = SHA-512 (Linux moderno mais comum)
# $5$ = SHA-256
# $1$ = MD5 (legado, fraco)
# $2a$/$2y$ = Blowfish/bcrypt (robusto)
# $y$ = yescrypt (mais recente, muito robusto)

# Ver suas próprias informações de usuário em passwd
cat /etc/passwd | grep $USER

# Formato passwd: username:x:UID:GID:comment:home:shell
# O "x" significa que a senha está em /etc/shadow

# Para pentesting, você extrairá ambos os arquivos:
# /etc/passwd - contém nomes de usuário e UIDs
# /etc/shadow - contém hashes de senha

# Exemplo de decomposição de hash shadow:
# $6$rounds=5000$saltsaltsa$verylonghashstringhere

# $6$ = Algoritmo de hash (SHA-512)
# rounds=5000 = Contagem de iterações (padrão 5000)
# saltsaltsa = Salt aleatório (previne rainbow tables)
# verylonghash = O hash de senha real

Você verá: Hashes de senha Linux usam algoritmos robustos como SHA-512 com salting e milhares de iterações (rounds), tornando-os muito mais difíceis de quebrar que NTLM. O salt garante que senhas idênticas produzam hashes diferentes entre sistemas. Entender este formato é fundamental para ataques de senha Linux.

Habilidades que você vai dominar

Entendendo a autenticação Linux

A segurança de senhas Linux evoluiu significativamente desde os primeiros sistemas Unix. Distribuições Linux modernas usam SHA-512 crypt por padrão, aplicando 5.000 rounds de hashing SHA-512 com um salt aleatório. O arquivo /etc/shadow armazena esses hashes com permissões restritas (legível apenas por root), separando dados de senha do arquivo /etc/passwd publicamente legível. Esta arquitetura fornece segurança robusta - SHA-512 com salting e contagens de iteração torna ataques de rainbow table impossíveis e desacelera dramaticamente tentativas de força bruta. No entanto, a verdade fundamental permanece: senhas fracas quebram independentemente da força do hash. Uma senha de 8 caracteres quebra em dias ou semanas; senhas complexas com menos de 12 caracteres permanecem vulneráveis a atacantes determinados.

A documentação do arquivo shadow Linux detalha o formato de armazenamento de senha, mas entender as implicações de segurança requer análise mais profunda. SHA-512 crypt processa cada tentativa de senha através de 5.000 iterações de SHA-512, desacelerando dramaticamente a quebra comparado a NTLM (que usa MD4 único). GPUs modernas quebram NTLM a 100 bilhões de tentativas/segundo mas só alcançam 200.000-500.000 tentativas SHA-512/segundo - uma diferença de 200.000x. Este custo computacional protege contra ataques de força bruta mas não pode compensar senhas baseadas em dicionário ou padrões previsíveis.

Distribuições mais novas estão fazendo transição para yescrypt, que fornece proteção ainda mais forte através de derivação de chave intensiva em memória. O algoritmo yescrypt requer alocação significativa de memória durante o hashing, tornando aceleração por GPU e ASIC menos efetiva. No entanto, a adoção permanece limitada, e a maioria dos sistemas Linux ainda usa SHA-512 crypt. Organizações devem entender que embora o hashing de senha Linux seja significativamente mais forte que Windows NTLM, a segurança final depende da complexidade e comprimento da senha. Uma passphrase de 16+ caracteres no Linux se torna praticamente inquebrável com tecnologia atual, enquanto uma senha de 8 caracteres no mesmo sistema pode quebrar em dias.

Ferramentas e técnicas

🔨 unshadow: Combinando arquivos de senha

O utilitário unshadow (parte do John the Ripper) combina /etc/passwd e /etc/shadow em um único arquivo adequado para quebra de senha. Este passo é essencial porque John precisa tanto das informações de nome de usuário (de passwd) quanto dos hashes de senha (de shadow) para realizar operações de quebra.

# Extrair arquivos passwd e shadow (requer root)
# Durante pentest após obter acesso root:
sudo cp /etc/passwd passwd.txt
sudo cp /etc/shadow shadow.txt

# Ou extrair de acesso físico/boot live:
# Inicializar de USB → montar sistema de arquivos alvo
sudo mount /dev/sda1 /mnt
sudo cp /mnt/etc/passwd passwd.txt
sudo cp /mnt/etc/shadow shadow.txt

# Combinar arquivos com unshadow
unshadow passwd.txt shadow.txt > unshadowed.txt

# Examinar a saída combinada
cat unshadowed.txt

# Formato: username:hash:UID:GID:comment:home:shell
# Exemplo:
# hdna:$6$rounds=5000$salt$hash:1000:1000:HackerDNA User:/home/hdna:/bin/bash

# Agora este arquivo está pronto para John the Ripper ou hashcat
# A ferramenta pode ver tanto nomes de usuário quanto seus hashes correspondentes

# Direcionar usuários específicos (extrair apenas certas contas)
grep -E "^(root|hdna|admin)" unshadowed.txt > targets.txt

Unshadow realiza uma função simples mas crítica - associa entradas de nome de usuário de /etc/passwd com seus hashes de senha correspondentes de /etc/shadow. Sem este passo, John the Ripper não consegue associar nomes de usuário a hashes, limitando a efetividade do ataque. Durante testes de penetração, priorize a quebra de contas root e habilitadas para sudo, pois fornecem escalação de privilégios imediata.

⚡ John the Ripper: Especialista em senhas Linux

John the Ripper se destaca na quebra de senhas Linux com detecção automática de formato, implementações SHA-512 otimizadas, e motores de regras poderosos. É a ferramenta padrão para auditoria de senhas Linux/Unix e fornece excelente performance em sistemas baseados em CPU.

# Ataque de dicionário básico
john --wordlist=/usr/share/wordlists/rockyou.txt unshadowed.txt

# John detecta automaticamente o tipo de hash (SHA-512, SHA-256, MD5, etc.)
# Não precisa especificar formato para hashes Linux padrão

# Ataque baseado em regras com mutações
john --rules --wordlist=/usr/share/wordlists/rockyou.txt unshadowed.txt

# Mostrar senhas quebradas
john --show unshadowed.txt

# Formato mostra: username:password:UID:GID:...
# Exemplo: hdna:password123:1000:1000:...

# Modo incremental (força bruta)
# Muito lento para SHA-512 mas efetivo para senhas curtas
john --incremental unshadowed.txt

# Direcionar usuários específicos
john --users=root,hdna --wordlist=rockyou.txt unshadowed.txt

# Regras personalizadas para servidores Linux
# Padrões comuns: baseados em username, nomes de servidor, senhas admin
echo '[List.Rules:LinuxRules]' > linux.conf
echo 'cAz"[0-9][0-9][0-9][0-9]"' >> linux.conf  # Capitalizar + ano
echo 'cAz"[!@#]"' >> linux.conf  # Capitalizar + caractere especial
echo 'l Az"[0-9]"' >> linux.conf  # Minúscula + adicionar dígito

john --rules=LinuxRules --wordlist=server_terms.txt unshadowed.txt

# Gerenciamento de sessão para ataques longos
john --session=hdna_linux unshadowed.txt
john --restore=hdna_linux

# Especificar formato explicitamente (se necessário)
john --format=sha512crypt unshadowed.txt

A detecção automática de formato do John the Ripper lida com hashes SHA-512, SHA-256, MD5, Blowfish e yescrypt sem configuração manual. A documentação oficial do John the Ripper fornece guias abrangentes para uso avançado. Para auditorias de senha Linux, ataques baseados em regras provam ser altamente efetivos já que usuários frequentemente baseiam senhas em nomes de usuário, nomes de servidor, ou termos organizacionais.

🚀 hashcat: Quebra Linux acelerada por GPU

Hashcat fornece aceleração por GPU para quebra de senhas Linux, melhorando dramaticamente a performance comparado à quebra baseada em CPU. Embora SHA-512 seja computacionalmente caro, GPUs modernas ainda fornecem vantagens significativas de velocidade sobre CPUs.

# Modos hashcat para Linux:
# 1800: SHA-512 crypt (sha512crypt $6$) - mais comum
# 7400: SHA-256 crypt (sha256crypt $5$)
# 500:  MD5 crypt (md5crypt $1$) - legado
# 3200: Blowfish/bcrypt ($2a$, $2y$)
# 7900: SHA-512 APR (Apache htpasswd)

# Extrair hashes para hashcat (pular etapa unshadow)
# Apenas extrair o campo de hash do arquivo shadow
sudo cat /etc/shadow | grep -v "^[#\*!]" | cut -d: -f2 > hashes.txt

# Ataque de dicionário em hashes SHA-512
hashcat -m 1800 -a 0 hashes.txt rockyou.txt

# Ataque baseado em regras com mutações de senha
hashcat -m 1800 -a 0 hashes.txt rockyou.txt -r rules/best64.rule

# Ataque de máscara para padrões conhecidos
# Exemplo: 8-10 caracteres, começa com maiúscula
hashcat -m 1800 -a 3 hashes.txt '?u?l?l?l?l?l?l?d?d'

# Ataque híbrido: wordlist + máscara
hashcat -m 1800 -a 6 hashes.txt rockyou.txt '?d?d?d?d'

# Mostrar senhas quebradas
hashcat -m 1800 hashes.txt --show

# Benchmark de velocidade de quebra SHA-512
hashcat -m 1800 -b

# Velocidades típicas:
# RTX 3090: 400-500k H/s (400.000 hashes/segundo)
# RTX 4090: 800k-1M H/s
# CPU (8-core): 5k-10k H/s

# Comparar com NTLM (modo 1000):
# Mesma GPU: 100+ bilhões H/s
# SHA-512 é 200.000x mais lento para quebrar!

# Ajuste de carga de trabalho para performance máxima
hashcat -m 1800 -a 0 hashes.txt rockyou.txt -w 3

# Para MD5 crypt legado (muito mais rápido)
hashcat -m 500 -a 0 hashes.txt rockyou.txt

Aceleração por GPU fornece melhorias de performance substanciais para quebra SHA-512, mas o algoritmo permanece computacionalmente caro. Uma GPU high-end alcançando 1 milhão de SHA-512/seg precisaria de aproximadamente 3 anos para esgotar todas as senhas de 8 caracteres usando espaço de caractere completo. Esta realidade destaca por que hashing robusto importa - torna ataques de força bruta impraticáveis mesmo com hardware poderoso.

🎯 Técnicas de acesso físico e modo de resgate

Acesso físico a sistemas Linux permite extração de arquivos de senha sem autenticação de rede. Avaliadores de segurança usam essas técnicas para demonstrar vulnerabilidades de segurança física e testar força de senha offline.

# Método 1: Boot de USB/Live CD
# 1. Inicializar sistema de pendrive USB (Kali Linux, Ubuntu Live)
# 2. Montar sistema de arquivos alvo
sudo mkdir /mnt/target
sudo mount /dev/sda1 /mnt/target

# 3. Extrair arquivos de senha
sudo cp /mnt/target/etc/passwd passwd.txt
sudo cp /mnt/target/etc/shadow shadow.txt

# 4. Desmontar e reiniciar
sudo umount /mnt/target

# Método 2: Modo single-user (se GRUB não estiver protegido por senha)
# 1. No menu GRUB, pressione 'e' para editar parâmetros de boot
# 2. Encontre a linha começando com 'linux' ou 'linux16'
# 3. Adicione 'single' ou 'init=/bin/bash' ao final da linha
# 4. Pressione Ctrl+X ou F10 para inicializar
# 5. Sistema inicializa para shell root sem senha
# 6. Remontar sistema de arquivos leitura-escrita:
mount -o remount,rw /

# 7. Extrair arquivos de senha ou resetar senhas diretamente
cp /etc/passwd /media/usb/
cp /etc/shadow /media/usb/

# Método 3: Modo rescue via parâmetros do kernel
# Similar ao single-user, mas adicione: rd.break
# Isto cai para shell de emergência antes de montar root

# Método 4: Extrair de backups
# Verificar locais de backup comuns:
ls /var/backups/  # Ubuntu/Debian armazenam backups shadow aqui
ls /backup/
ls /root/backup/

# Às vezes encontrar backups não criptografados com arquivos de senha
tar -tzf backup.tar.gz | grep shadow

Ataques de acesso físico demonstram por que organizações precisam de criptografia de disco completo (LUKS, dm-crypt) e proteção de senha GRUB. Sem esses controles, um atacante com acesso físico pode extrair arquivos de senha em minutos. Avaliações de segurança devem testar tanto força de senha quanto controles de segurança física para fornecer avaliação de risco abrangente.

Contramedidas defensivas

🛡️ Políticas de senha robustas para Linux

Políticas de senha Linux devem considerar o custo computacional do SHA-512 mantendo usabilidade prática. O guia de configuração de política de senha Linux detalha a implementação, mas organizações devem exceder requisitos mínimos para contas privilegiadas.

• Mínimo 12 caracteres: Segurança equilibrada para contas regulares
• Contas root/sudo 16+ caracteres: Contas privilegiadas precisam proteção máxima
• Aplicar via PAM: Usar módulo pam_pwquality para requisitos de complexidade
• Aumentar rounds SHA-512: Os 5.000 rounds padrão podem ser aumentados para 100.000+ em /etc/login.defs

🔐 Segurança física e proteção de boot

Acesso físico compromete segurança de senha independentemente da força do hash. Organizações devem implementar controles de segurança física e proteções de nível de boot para prevenir extração não autorizada de senha.

• Criptografia de disco completo: Criptografia LUKS protege contra extração offline de senha
• Proteção de senha GRUB: Prevenir modificação de parâmetros de boot e modo single-user
• Senhas BIOS/UEFI: Prevenir boot de mídia externa
• Secure Boot: Verificar que componentes de boot não foram adulterados

⚡ Autenticação por chave SSH

Autenticação baseada em chave SSH elimina transmissão de senha pela rede e fornece segurança mais forte que autenticação por senha. Organizações devem fazer transição para autenticação baseada em chave para acesso remoto.

• Desabilitar autenticação por senha: Definir "PasswordAuthentication no" em /etc/ssh/sshd_config
• Exigir chaves SSH: Chaves ED25519 ou RSA 4096-bit para todo acesso remoto
• Autenticação baseada em certificado: Certificados SSH para grandes implantações
• Autenticação de dois fatores: Módulos PAM como Google Authenticator para proteção adicional

🔍 Logging de auditoria e monitoramento

Logging abrangente detecta tentativas de ataque de senha e acesso não autorizado. Linux fornece capacidades extensivas de logging através de syslog, auditd e logs de autenticação que equipes de segurança devem monitorar continuamente.

• Monitorar /var/log/auth.log: Todas as tentativas de autenticação registradas com timestamps
• Auditd para acesso shadow: Alertar sobre tentativas de acesso ao arquivo /etc/shadow
• Monitoramento de login falho: Usar fail2ban para bloquear tentativas de força bruta
• Logging de comandos sudo: Rastrear toda execução de comando privilegiado

FAQ

Fundamentos de quebra de senha Linux

Implementação técnica

Aplicações práticas

🎯 Você dominou a quebra de senhas Linux!

Você agora entende o armazenamento de senhas Linux em /etc/shadow, pode extrair e combinar arquivos de senha com unshadow, e sabe como quebrar hashes SHA-512, SHA-256 e MD5 legado usando John the Ripper e hashcat. Essas habilidades são essenciais para testes de penetração em servidores Linux, auditoria de políticas de senha, e entendimento de como o hashing robusto em sistemas Linux se compara à autenticação Windows NTLM.

Pronto para dominar técnicas avançadas de quebra de senha e otimização