Força Bruta com Hashcat Usando Ataques de Máscara

Introdução

Hashcat é uma ferramenta de recuperação de senhas mundialmente renomada, capaz de quebrar uma grande variedade de hashes em velocidades incríveis. Embora os ataques de dicionário sejam comuns, eles só são eficazes se a senha existir em uma determinada lista de palavras (wordlist). Um ataque de força bruta pura, que tenta todas as combinações possíveis de caracteres, é frequentemente lento demais para ser prático.

É aqui que entra o ataque de máscara (mask attack). Um ataque de máscara é uma forma altamente eficiente de ataque de força bruta usada quando se tem algum conhecimento sobre a estrutura da senha. Por exemplo, você pode saber o comprimento da senha, ou que ela começa com uma letra maiúscula e termina com um número.

Neste laboratório, você aprenderá os fundamentos da execução de um ataque de máscara com o Hashcat. Você começará entendendo o conceito, aprenderá a usar conjuntos de caracteres para construir máscaras e aplicará esse conhecimento para quebrar hashes de senhas com padrões conhecidos.

Entender o conceito de ataque de máscara (-a 3)

Nesta etapa, você aprenderá o conceito básico de um ataque de máscara no Hashcat. O modo de ataque de máscara é especificado usando a opção -a 3. Este modo instrui o Hashcat a gerar candidatos a senha com base em um padrão, ou "máscara", que você define.

Isso é diferente de um ataque de dicionário (-a 0), que usa uma lista pré-fabricada de palavras. Um ataque de máscara cria seus próprios candidatos em tempo real (on the fly).

Vamos ver como uma máscara gera candidatos. Podemos usar a opção --stdout para imprimir as senhas geradas na tela em vez de tentar quebrar um hash. Usaremos ?d como um placeholder simples para um dígito (0-9).

Execute o seguinte comando para gerar todos os números possíveis de 3 dígitos:

hashcat -a 3 ?d?d?d --stdout

O Hashcat gerará todas as combinações possíveis de 3 dígitos. Observe que a ordem da saída pode parecer aleatória devido aos algoritmos de otimização do Hashcat, mas ele gerará todas as combinações de 000 a 999.

...
476
576
876
976
...

Isso demonstra a ideia central: a máscara ?d?d?d atua como um modelo (template), e o Hashcat o preenche sistematicamente com todas as combinações possíveis do conjunto de caracteres especificado.

Aprender os conjuntos de caracteres internos (?l, ?u, ?d, ?s)

Nesta etapa, você aprenderá sobre os blocos de construção fundamentais das máscaras: conjuntos de caracteres internos (built-in character sets). Estes são espaços reservados que representam um grupo específico de caracteres.

O Hashcat fornece vários conjuntos de caracteres internos convenientes:

Você pode combinar esses placeholders para criar máscaras complexas. O comprimento da máscara determina diretamente o comprimento dos candidatos a senha gerados.

Vamos tentar gerar candidatos para uma senha que consiste em uma letra maiúscula seguida por um dígito. A máscara para isso seria ?u?d.

Use a opção --stdout novamente para ver a saída:

hashcat -a 3 ?u?d --stdout

O Hashcat gerará todas as combinações de uma letra maiúscula seguida por um dígito. Observe que a ordem da saída pode parecer aleatória devido aos algoritmos de otimização do Hashcat, mas ele gerará todas as combinações de A0 a Z9.

...
B4
C7
D2
...

Ao combinar esses conjuntos de caracteres, você pode definir um padrão preciso para as senhas que deseja testar.

Lançar um ataque de máscara para um PIN de 3 dígitos (hash NTLM)

Nesta etapa, você aplicará seu conhecimento a um cenário do mundo real: quebrar um PIN de 3 dígitos. Temos um arquivo chamado pin_hash.txt que contém um hash de senha no formato NTLM. Suspeitamos que a senha original seja um número de 3 dígitos.

Primeiro, vamos visualizar o conteúdo do arquivo de hash:

cat pin_hash.txt

Você verá o hash NTLM:

D2063C28444B9B742B9B89C282395EBF

Para quebrar isso, precisamos dizer ao Hashcat três coisas:

1. O modo de ataque é ataque de máscara (-a 3).
2. O tipo de hash é NTLM (-m 1000).
3. A máscara para um PIN de 3 dígitos é ?d?d?d.

Agora, combine isso em um único comando para iniciar o ataque:

hashcat -a 3 -m 1000 pin_hash.txt ?d?d?d

O Hashcat será iniciado e, como o espaço de chaves (keyspace) (000-999) é muito pequeno, ele encontrará a senha quase instantaneamente.

...
D2063C28444B9B742B9B89C282395EBF:137
...
Status...........: Cracked
...

O Hashcat recuperou a senha com sucesso: 137. Assim que uma senha é quebrada, o Hashcat a salva em um arquivo chamado "potfile". Você pode visualizar todas as senhas quebradas para este tipo de hash com a opção --show:

hashcat -m 1000 pin_hash.txt --show

Saída:

D2063C28444B9B742B9B89C282395EBF:137

Criar uma máscara personalizada para um padrão de senha conhecido

Nesta etapa, você enfrentará uma senha mais complexa. Imagine que uma empresa tem uma política de senha: "As senhas devem consistir em exatamente 5 letras minúsculas." Uma senha de exemplo seria labex.

Temos o hash NTLM para tal senha no arquivo pattern_hash.txt.

Primeiro, vamos traduzir a política de senha para uma máscara do Hashcat:

• Todos os 5 caracteres devem ser letras minúsculas: ?l?l?l?l?l

Isso nos dá a máscara final: ?l?l?l?l?l.

Agora, vamos usar esta máscara para quebrar o hash em pattern_hash.txt. O comando é semelhante à etapa anterior, mas com nossa nova máscara.

hashcat -a 3 -m 1000 pattern_hash.txt ?l?l?l?l?l

O Hashcat começará a testar todas as combinações que se encaixam neste padrão específico. Isso é muito mais eficiente do que um ataque de força bruta pura tentando todas as combinações de 5 caracteres. Após um curto período, ele encontrará a senha.

...
2BF7D33EC706798E0308F5DF34BC7D2F:labex
...
Status...........: Cracked
...

Você quebrou com sucesso uma senha com um padrão específico, criando uma máscara personalizada que corresponde precisamente à política exigida de 5 letras minúsculas.

Comparar o desempenho de ataques de máscara versus ataques de dicionário

Nesta etapa final, compararemos o ataque de máscara que você acabou de realizar com um ataque de dicionário tradicional para entender seus respectivos pontos fortes.

Um ataque de dicionário (-a 0) é muito rápido se a senha estiver na lista de palavras (wordlist). Temos um pequeno arquivo de dicionário chamado dict.txt que contém a senha da etapa anterior.

Vamos executar um ataque de dicionário contra pattern_hash.txt:

hashcat -a 0 -m 1000 pattern_hash.txt dict.txt

Como labex está em dict.txt, o Hashcat o encontra quase instantaneamente.

hashcat (v6.2.5) starting

OpenCL API (OpenCL 2.0 pocl 1.8  Linux, None+Asserts, RELOC, LLVM 11.1.0, SLEEF, DISTRO, POCL_DEBUG) - Platform #1 [The pocl project]
=====================================================================================================================================
* Device #1: pthread-Intel(R) Xeon(R) Platinum 8575C, 6808/13680 MB (2048 MB allocatable), 4MCU

Minimum password length supported by kernel: 0
Maximum password length supported by kernel: 256

INFO: All hashes found in potfile! Use --show to display them.

Started: Sat Oct 11 16:05:20 2025
Stopped: Sat Oct 11 16:05:20 2025

O Hashcat nos informa que o hash já foi encontrado e armazenado no potfile. Para ver a senha decifrada, podemos usar a opção --show:

hashcat -a 0 -m 1000 pattern_hash.txt dict.txt --show

Saída:

2bf7d33ec706798e0308f5df34bc7d2f:labex

Então, quando um ataque de máscara tem vantagem? Um ataque de dicionário somente terá sucesso se a senha exata existir na lista de palavras. Se a senha fosse testx em vez disso, e isso não estivesse em nosso dicionário, o ataque falharia.

No entanto, o ataque de máscara da Etapa 4 (?l?l?l?l?l) ainda teria sucesso porque ele gera e testa sistematicamente todas as senhas que se ajustam ao padrão, independentemente de estarem em um dicionário. Ele testaria labex, testx, hello e assim por diante.

Conclusão:

• Ataque de Dicionário (-a 0): Melhor para decifrar senhas comuns ou quando você tem uma lista de palavras direcionada e de alta qualidade. É rápido, mas limitado pelo conteúdo do dicionário.
• Ataque de Máscara (-a 3): Melhor quando você conhece a estrutura ou o padrão da senha (por exemplo, a partir de uma política de senha conhecida). É muito mais abrangente do que um ataque de dicionário e infinitamente mais eficiente do que um ataque de força bruta puro.

Resumo

Neste laboratório, você adquiriu experiência prática com um dos recursos mais poderosos do Hashcat: o ataque de máscara.

Você aprendeu:

• O conceito fundamental de um ataque de máscara (-a 3) e como ele gera candidatos a senha com base em um padrão.
• Como usar os conjuntos de caracteres internos (built-in character sets) do Hashcat (?l, ?u, ?d, ?s) para construir máscaras.
• Como aplicar uma máscara simples para quebrar um PIN de 3 dígitos.
• Como criar uma máscara personalizada com base em uma política de senha conhecida (5 letras minúsculas) para quebrar uma senha com um padrão específico.
• As principais diferenças e vantagens estratégicas de usar um ataque de máscara em comparação com um ataque de dicionário padrão.

Ataques de máscara são uma habilidade essencial para qualquer profissional de segurança, oferecendo um equilíbrio perfeito entre a velocidade de um ataque de dicionário e a abrangência de um ataque de força bruta puro.