Executar um Ataque de Força Bruta com Máscara no Hashcat

Introdução

Bem-vindo a este laboratório sobre como realizar um ataque de máscara com Hashcat. Hashcat é uma ferramenta poderosa e versátil de recuperação de senhas, amplamente utilizada em cibersegurança para testar a força das senhas e recuperar senhas perdidas.

Um ataque de força bruta padrão tenta adivinhar uma senha tentando todas as combinações possíveis de caracteres, o que pode ser incrivelmente lento. Um ataque de máscara é um tipo mais inteligente e eficiente de ataque de força bruta. Ele é usado quando você tem algumas informações sobre a estrutura da senha, como seu comprimento ou os tipos de caracteres usados em posições específicas (por exemplo, "começa com uma letra maiúscula, termina com dois números").

Neste laboratório, você aprenderá como definir a estrutura de uma senha usando uma máscara e usará o Hashcat para quebrar um hash SHA1 de amostra, demonstrando o poder e a eficiência dessa abordagem direcionada.

Compreender o Conceito de Ataque de Máscara

Nesta etapa, você aprenderá o conceito fundamental de um ataque de máscara. Conforme mencionado na introdução, este ataque é uma forma especializada de um ataque de força bruta.

Imagine que você precisa quebrar uma senha, mas tem algumas pistas:

• Você sabe que a senha tem exatamente 6 caracteres de comprimento.
• Você sabe que o primeiro caractere é uma letra maiúscula.
• Você sabe que os dois últimos caracteres são dígitos.

Um ataque de força bruta padrão desperdiçaria tempo tentando combinações como "aaaaaa" ou "123456". Um ataque de máscara, no entanto, permite que você defina uma "máscara" ou modelo que instrui a ferramenta de quebra a tentar apenas combinações que se encaixem no seu padrão conhecido. Para o exemplo acima, a máscara especificaria [Letra Maiúscula][Qualquer][Qualquer][Qualquer][Dígito][Dígito].

Isso reduz drasticamente o número de possibilidades, tornando o processo de quebra significativamente mais rápido e eficiente. Na próxima etapa, você aprenderá a sintaxe específica que o Hashcat usa para criar essas máscaras poderosas. Esta etapa é puramente conceitual, e nenhum comando é necessário.

Aprender Conjuntos de Caracteres Integrados como ?l ?u ?d ?s

Nesta etapa, você aprenderá sobre os conjuntos de caracteres integrados do Hashcat, que são os blocos de construção de uma máscara.

O Hashcat usa placeholders especiais, chamados "charsets" (conjuntos de caracteres), para definir o tipo de caractere em cada posição em uma máscara de senha. Estes são os charsets integrados mais comuns:

• ?l: Representa todas as letras minúsculas (a a z).
• ?u: Representa todas as letras maiúsculas (A a Z).
• ?d: Representa todos os dígitos (0 a 9).
• ?s: Representa todos os caracteres especiais padrão (por exemplo, !@#$%^&*).
• ?a: Representa todos os anteriores (?l?u?d?s).

Por exemplo, se soubermos que uma senha tem 4 caracteres de comprimento e consiste em uma letra maiúscula, seguida por duas letras minúsculas e, em seguida, um dígito, a máscara seria ?u?l?l?d. Isso geraria candidatos como Pass9, Word1, Test0, etc.

Você pode ver essas definições no menu de ajuda do Hashcat. Execute o seguinte comando no seu terminal para visualizar as informações de ajuda relacionadas a máscaras:

hashcat --help | grep "?l"

Você verá uma seção que lista os conjuntos de caracteres integrados, o que confirma as informações acima.

?l | abcdefghijklmnopqrstuvwxyz              | Letras minúsculas

Criar um Hash SHA1 de Exemplo de um Padrão Conhecido

Nesta etapa, você criará um hash SHA1 alvo para uma senha que quebraremos nas próximas etapas. Para realizar um ataque de senha, primeiro precisamos de um hash para atacar.

Vamos escolher uma senha que se encaixe em um padrão claro: LabX99!. Esta senha tem a seguinte estrutura:

• 1º caractere: Letra maiúscula (L)
• 2º caractere: Letra minúscula (a)
• 3º caractere: Letra minúscula (b)
• 4º caractere: Letra maiúscula (X)
• 5º caractere: Dígito (9)
• 6º caractere: Dígito (9)
• 7º caractere: Caractere especial (!)

Primeiro, vamos gerar o hash SHA1 para esta senha. O flag -n no comando echo é muito importante, pois impede que um caractere de nova linha seja adicionado à string, o que alteraria o hash resultante.

Execute este comando no seu terminal:

echo -n "LabX99!" | sha1sum

A saída será o hash SHA1 seguido por um traço:

0e6cc6531a1a5545942a38a9339571934219c5b0  -

Agora, salve este hash em um arquivo chamado target_hash.txt. Este arquivo será a entrada para o Hashcat.

echo "0e6cc6531a1a5545942a38a9339571934219c5b0" > target_hash.txt

Você pode verificar se o arquivo foi criado corretamente com cat target_hash.txt.

Construir um Comando de Ataque de Máscara para uma Senha de Comprimento Fixo

Nesta etapa, você construirá o comando completo do Hashcat para realizar o ataque de máscara com base nas informações que temos.

Um comando Hashcat para um ataque de máscara tem vários componentes-chave:

• -m <mode>: Este flag especifica o tipo de hash. Cada algoritmo de hash (como MD5, SHA1, bcrypt) tem um número de modo exclusivo.
• -a <attack_mode>: Este flag define o modo de ataque. Para um ataque de máscara, o modo é sempre 3.
• hash_file: O caminho para o arquivo que contém o(s) hash(es) a serem quebrados.
• mask: O padrão de máscara que define a estrutura da senha.

Primeiro, precisamos encontrar o modo correto para SHA1. Você pode encontrá-lo pesquisando a saída de ajuda do Hashcat:

hashcat --help | grep "SHA1"

Você verá uma lista de tipos de hash. O modo para um hash SHA1 padrão é 100.

  100 | SHA1                                           | Raw Hash

Em seguida, vamos criar a máscara para nossa senha, LabX99!. Com base na estrutura que identificamos e nos conjuntos de caracteres que aprendemos:

• L -> ?u
• ab -> ?l?l
• X -> ?u
• 99 -> ?d?d
• ! -> ?s

Combinando estes, nossa máscara final é ?u?l?l?u?d?d?s.

Agora podemos montar o comando completo. Também adicionaremos o flag --force, que instrui o Hashcat a executar mesmo que detecte um ambiente não ideal (como rodar em uma CPU em uma VM), o que é necessário para este laboratório.

A estrutura final do comando é: hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force. Executaremos isso na próxima etapa.

Executar o Ataque de Máscara e Verificar o Resultado

Nesta etapa, você executará o comando de ataque de máscara e verificará se o Hashcat quebra a senha com sucesso.

Você já construiu o comando. Agora, execute-o no seu terminal para iniciar o ataque:

hashcat -m 100 -a 3 target_hash.txt ?u?l?l?u?d?d?s --force

O Hashcat iniciará. Ele pode exibir alguns avisos, que são seguros para ignorar porque usamos --force. O ataque começará e, como nossa máscara é muito específica, ele deve terminar quase instantaneamente. A saída mostrará o status da sessão e você deverá ver o status final como Cracked.

...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: SHA1
Hash.Target......: 0e6cc6531a1a5545942a38a9339571934219c5b0
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Mask.......: ?u?l?l?u?d?d?s [7]
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   192.9 kH/s (0.01ms) @ Accel:128 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 11881376/11881376 (100.00%)
Rejected.........: 0/11881376 (0.00%)
Restore.Point....: 456976/456976 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1
Candidates.#1....: LuvX98! -> LuvX99#
Hardware.Mon.#1..: Temp: 46c
...

Quando uma senha é quebrada, o Hashcat a salva em um arquivo chamado "potfile" (hashcat.potfile). Para visualizar a senha quebrada, você pode usar o flag --show com os argumentos originais do comando.

Execute este comando para exibir o resultado:

hashcat -m 100 target_hash.txt --show

A saída mostrará o hash e a senha em texto plano quebrada, separadas por dois pontos:

0e6cc6531a1a5545942a38a9339571934219c5b0:LabX99!

Parabéns, você executou com sucesso um ataque de máscara!

Resumo

Neste laboratório, você realizou com sucesso um ataque de força bruta com máscara usando o Hashcat.

Você aprendeu como:

• Compreender o conceito central de um ataque de máscara como um método de força bruta direcionado.
• Usar os conjuntos de caracteres integrados do Hashcat (?l, ?u, ?d, ?s) para definir a estrutura de uma senha.
• Gerar um hash SHA1 para uma senha alvo.
• Construir um comando completo do Hashcat com o modo de hash, modo de ataque e máscara corretos.
• Executar o ataque e visualizar a senha quebrada usando a opção --show.

Ataques de máscara são uma técnica fundamental em quebra de senhas e auditoria de segurança. Eles demonstram como até mesmo uma pequena quantidade de informação sobre o padrão de uma senha pode reduzir drasticamente o tempo e o esforço necessários para quebrá-la.