Introdução à Autenticação Local

A autenticação local no Windows ocorre quando as credenciais de acesso são validadas diretamente no sistema operacional, sem a necessidade de comunicação com um controlador de domínio. Este é o modelo padrão para ambientes de grupo de trabalho (Workgroup), permitindo que o usuário faça logon na máquina mesmo quando ela está completamente offline.

Componentes do Subsistema de Segurança

O mecanismo de logon do Windows depende da interação entre três elementos fundamentais para garantir a integridade do acesso:

• winlogon.exe: Responsável por gerenciar a interface gráfica de logon, alternância de usuários, eventos de bloqueio de tela e inicialização da sessão.
• lsass.exe (Local Security Authority Subsystem Service): O núcleo da política de segurança local. Ele processa as credenciais, aplica políticas de senha, gerencia tokens de acesso e controla a autenticação.
• SAM (Security Account Manager): Um banco de dados localizado em C:\Windows\System32\config que armazena os hashes das senhas dos usuários locais. O acesso direto a este arquivo é estritamente restrito pelo sistema, impedindo leitura, cópia ou modificação por usuários sem privilégios elevadso (SYSTEM).

Fluxo de Validação

Quando uma credencial é inserida na interface de logon, o lsass.exe intercepta os dados e executa as seguintes ações:

1. Converte a senha em texto claro recebida do winlogon.exe em seu respectivo hash e compara o resultado com o valor armazenado no banco de dados SAM. Se houver correspondência, a sessão é estabelecida.
2. Armazena uma cópia das credenciais (ou os hashes necessários) em memória para permitir a autenticação em serviços locais e conexões de rede subsequentes, evitando a solicitação repetida da senha.

Algoritmo LM Hash (LAN Manager)

O LM Hash é um algoritmo legado baseado em DES, introduzido nas primeiras versões do Windows. Devido a vulnerabilidades críticas de design, foi desativado por padrão a partir do Windows Vista e Windows Server 2008. Quando desabilitado, o hash resultante é preenchido com o valor nulo aad3b435b51404eeaad3b435b51404ee. O algoritmo limita a senha a 14 caracteres e opera da seguinte forma:

1. A senha em texto claro é convertida para maiúsculas e truncada ou preenchida com zeros até atingir exatamente 14 bytes.
2. O bloco de 14 bytes é dividido em duas metades de 7 bytes.
3. Cada metade de 7 bytes é expandida para 8 bytes para servir como chave de criptografia DES.
4. Uma string mágica fixa (KGS!@#$%) é criptografada usando DES no modo ECB com cada uma das duas chaves derivadas.
5. Os dois blocos criptografados de 8 bytes são concatenados para formar o hash final de 16 bytes.

Algoritmo NTLM Hash

Para substituir as falhas de segurança do LM Hash, a Microsoft implementou o NTLM, que utiliza o algoritmo de hash MD4. Este é o padrão para sistemas modernos (a partir do Windows Vista e Windows Server 2003). O processo de derivação é mais direto e robusto:

1. A senha em texto claro é convertida para o formato Unicode (UTF-16LE).
2. O algoritmo MD4 é aplicado diretamente sobre a string em Unicode.
3. O resultado é um hash de 16 bytes (representado por 32 caracteres hexadecimais).

Extração e Análise de Credenciais em Ambiente Real

Em cenários de auditoria de segurança ou análise forense, é comum extrair os hashes do SAM para verificar a robustez das senhas. Em vez de depender apenas de ferramentas interativas em memória, uma abordagem moderna envolve a extração offline dos hives do registro e o uso de scripts para calcular ou validar os hashes.

Primeiro, extraia os hives do SAM e SYSTEM usando o PowerShell com privilégios de administrador:

# Extrair hives do registro para análise offline (Requer privilégios de Administrador)
$destino = "C:\temp\hives"
New-Item -ItemType Directory -Force -Path $destino | Out-Null

reg save HKLM\SAM "$destino\sam.hive" /y | Out-Null
reg save HKLM\SYSTEM "$destino\system.hive" /y | Out-Null

Write-Host "Hives extraídos com sucesso em $destino"

Em seguida, utilize um script em Python para calcular os hashes LM e NTLM de uma senha de teste e validar a lógica de derivação criptográfica:

# Requer a biblioteca pycryptodome: pip install pycryptodome
import hashlib
from Crypto.Cipher import DES

def gerar_lm_hash(senha: str) -> str:
    # Converter para maiúsculas e limitar a 14 caracteres
    senha_maiuscula = senha.upper()[:14].encode('ascii')
    
    # Preencher com zeros até 14 bytes
    senha_preenchida = senha_maiuscula.ljust(14, b'\x00')
    
    # Dividir em dois blocos de 7 bytes
    bloco1 = senha_preenchida[:7]
    bloco2 = senha_preenchida[7:]
    
    # Função para expandir 7 bytes em 8 bytes (chave DES)
    def expandir_chave(bloco):
        chave = bytearray(8)
        chave[0] = bloco[0] >> 1
        chave[1] = ((bloco[0] & 0x01) << 6) | (bloco[1] >> 2)
        chave[2] = ((bloco[1] & 0x03) << 5) | (bloco[2] >> 3)
        chave[3] = ((bloco[2] & 0x07) << 4) | (bloco[3] >> 4)
        chave[4] = ((bloco[3] & 0x0F) << 3) | (bloco[4] >> 5)
        chave[5] = ((bloco[4] & 0x1F) << 2) | (bloco[5] >> 6)
        chave[6] = ((bloco[5] & 0x3F) << 1) | (bloco[6] >> 7)
        chave[7] = bloco[6] & 0x7F
        for i in range(8):
            chave[i] = (chave[i] << 1) & 0xFE
        return bytes(chave)

    string_magica = b"KGS!@#$%"
    
    # Criptografar com DES
    cifra1 = DES.new(expandir_chave(bloco1), DES.MODE_ECB)
    cifra2 = DES.new(expandir_chave(bloco2), DES.MODE_ECB)
    
    hash1 = cifra1.encrypt(string_magica)
    hash2 = cifra2.encrypt(string_magica)
    
    return (hash1 + hash2).hex().upper()

def gerar_ntlm_hash(senha: str) -> str:
    # Converter para Unicode (UTF-16LE)
    senha_unicode = senha.encode('utf-16le')
    
    # Aplicar MD4
    md4 = hashlib.new('md4')
    md4.update(senha_unicode)
    
    return md4.hexdigest()

# Exemplo de validação
senha_alvo = "Admin@123"
print(f"LM Hash: {gerar_lm_hash(senha_alvo)}")
print(f"NTLM Hash: {gerar_ntlm_hash(senha_alvo)}")