Usar Conjuntos de Caracteres Personalizados em um Ataque de Máscara

Introdução

Neste laboratório, você explorará um recurso avançado do Hashcat: conjuntos de caracteres personalizados (custom charsets) em ataques de máscara (mask attacks). Embora os conjuntos de caracteres integrados do Hashcat (?l, ?u, ?d, ?s) sejam poderosos, eles podem ser ineficientes se você tiver informações específicas sobre os caracteres usados em uma senha. Por exemplo, se você sabe que uma senha contém apenas os caracteres 'a', 'b', 'c', '1', '2', '3', usar os conjuntos de caracteres padrão ?l e ?d testaria muitos caracteres desnecessários.

Conjuntos de caracteres personalizados permitem que você defina um conjunto preciso de caracteres, reduzindo drasticamente o espaço de busca e acelerando o processo de quebra. Você aprenderá a definir um conjunto de caracteres personalizado, criar uma máscara que o utilize e executar um ataque direcionado para quebrar um hash de senha que segue um padrão único.

Compreender as Limitações dos Conjuntos de Caracteres Integrados

Nesta etapa, você aprenderá sobre os conjuntos de caracteres integrados do Hashcat e por que eles nem sempre são a ferramenta mais eficiente para a tarefa.

O Hashcat usa placeholders, chamados conjuntos de caracteres (charsets), para representar diferentes tipos de caracteres em um ataque de máscara:

• ?l = abcdefghijklmnopqrstuvwxyz
• ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ
• ?d = 0123456789
• ?s = !"#$%&'()*+,-./:;<=>?@[]^_`{|}~
• ?a = Todos os anteriores combinados

Estes são úteis para casos gerais, mas se soubermos que a senha é composta por um conjunto de caracteres muito específico e limitado, usar esses conjuntos amplos é ineficiente.

Primeiro, vamos inspecionar o hash alvo que precisamos quebrar. O script de configuração já criou um arquivo chamado hash.txt em seu diretório atual (~/project).

Visualize seu conteúdo:

cat hash.txt

Você deverá ver o seguinte hash MD5:

2a5c3a657a73613391a8e58f1a43161e

Este hash corresponde a uma senha de 8 caracteres composta apenas pelos caracteres l, a, b, e, x, 1, 2, 3. Se usássemos os conjuntos de caracteres integrados ?l e ?d, o Hashcat perderia tempo tentando todas as 26 letras minúsculas e 10 dígitos, em vez de apenas os 8 caracteres conhecidos. Na próxima etapa, criaremos um conjunto de caracteres personalizado para resolver este problema.

Definir um Conjunto de Caracteres Personalizado com --custom-charset1

Nesta etapa, você definirá um conjunto de caracteres personalizado que corresponde precisamente aos caracteres conhecidos na senha.

O Hashcat permite definir até quatro conjuntos de caracteres personalizados usando as opções de linha de comando --custom-charset1, --custom-charset2, --custom-charset3 e --custom-charset4.

Para o nosso cenário, sabe-se que a senha contém apenas caracteres do conjunto labex123. Podemos definir isso como nosso primeiro conjunto de caracteres personalizado.

Vamos construir um comando para ver como isso funciona. Usaremos a opção --stdout para imprimir os candidatos de senha gerados na tela em vez de realizar um ataque real. Também usaremos head para ver apenas os primeiros resultados.

Execute o seguinte comando para gerar senhas de 3 caracteres usando nosso conjunto de caracteres personalizado:

hashcat --stdout -a 3 --custom-charset1 labex123 ?1?1?1 | head -n 5

Vamos detalhar este comando:

• --stdout: Imprime os candidatos gerados no console.
• -a 3: Especifica um ataque de máscara.
• --custom-charset1 labex123: Define ?1 como nosso conjunto personalizado de caracteres.
• ?1?1?1: A máscara, que diz ao Hashcat para gerar candidatos de 3 caracteres onde cada caractere é do conjunto definido em ?1.

Você verá uma saída como esta, mostrando que apenas os caracteres especificados estão sendo usados:

lll
lla
llb
lle
llx

Agora você entende como definir um conjunto de caracteres personalizado para um ataque direcionado.

Criar uma Máscara que Utiliza o Conjunto de Caracteres Personalizado ?1

Nesta etapa, você construirá uma máscara que utiliza o conjunto de caracteres personalizado que você definiu na etapa anterior.

Conjuntos de caracteres personalizados são referenciados em uma máscara usando os placeholders ?1, ?2, ?3 e ?4, correspondendo à opção --custom-charset<N> utilizada. Como usamos --custom-charset1, usaremos ?1 em nossa máscara.

Sabemos que nossa senha alvo tem 8 caracteres de comprimento, e cada caractere é do nosso conjunto personalizado. Portanto, a máscara correta é ?1 repetido oito vezes.

Para clareza e reutilização, é uma boa prática salvar sua máscara em um arquivo. Vamos criar um arquivo chamado mask.txt e colocar nossa máscara dentro dele.

Execute o seguinte comando para criar o arquivo:

echo "?1?1?1?1?1?1?1?1" > mask.txt

Agora, verifique o conteúdo do arquivo para garantir que está correto:

cat mask.txt

A saída deve ser exatamente o que você inseriu:

?1?1?1?1?1?1?1?1

Com o arquivo de máscara pronto, você está agora preparado para iniciar o ataque.

Executar um Ataque de Máscara com o Conjunto de Caracteres Personalizado

Agora você combinará tudo para iniciar o ataque de máscara usando seu conjunto de caracteres personalizado e arquivo de máscara.

Você tem o hash em hash.txt, o conjunto de caracteres personalizado definido e a máscara em mask.txt. Vamos montar o comando final do Hashcat.

Execute o seguinte comando em seu terminal para iniciar o ataque:

hashcat -m 0 -a 3 hash.txt --custom-charset1 labex123 mask.txt

Aqui está uma descrição detalhada do comando completo:

• -m 0: Especifica que o tipo de hash é MD5.
• -a 3: Seleciona o modo de ataque de máscara.
• hash.txt: O arquivo de entrada contendo nosso hash alvo.
• --custom-charset1 labex123: Define nosso conjunto de caracteres personalizado ?1.
• mask.txt: O arquivo contendo a máscara ?1?1?1?1?1?1?1?1.

O Hashcat iniciará o ataque. Como nosso conjunto de caracteres personalizado é muito específico, o espaço de chaves é pequeno e o ataque deve terminar muito rapidamente. Você verá uma saída indicando o progresso e, finalmente, um status de Cracked.

...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: 2a5c3a657a73613391a8e58f1a43161e
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Mask.......: ?1?1?1?1?1?1?1?1 [8]
Guess.Charset....: Custom Charset 1: 'labex123', len=8
Speed.#1.........:  ... H/s (0.00ms) @ Accel:1 Loops:1 Thr:1 Vec:1
Recovered........: 1/1 (100.00%) Digests, 1/1 (100.00%) Salts
Progress.........: 16777216/16777216 (100.00%)
Rejected.........: 0/16777216 (0.00%)
Restore.Point....: 1/1 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: labex123 -> labex123
Hardware.Mon.#1..: Util:  0%

Started: ...
Stopped: ...

O ataque está completo e bem-sucedido. Na próxima etapa, você verificará a senha decifrada.

Verificar se a Senha Decifrada Corresponde ao Padrão Personalizado

Nesta etapa final, você visualizará a senha decifrada e confirmará que ela corresponde ao padrão esperado.

O Hashcat salva automaticamente as senhas decifradas com sucesso em um arquivo chamado "potfile" (porque ele "coloca" o hash e a senha). Isso evita a re-decifragem do mesmo hash no futuro. A maneira mais fácil de ver a senha decifrada para um determinado arquivo de hash é usar a opção --show.

Execute o seguinte comando para exibir a senha decifrada para o hash em hash.txt:

hashcat -m 0 --show hash.txt

Este comando instrui o Hashcat a procurar o hash de hash.txt em seu potfile e exibir a senha em texto simples correspondente.

A saída será clara e simples:

2a5c3a657a73613391a8e58f1a43161e:labex123

Como você pode ver, a senha decifrada é labex123. Observe que ela tem 8 caracteres de comprimento e contém apenas caracteres do conjunto de caracteres personalizado labex123 que você definiu. Isso confirma que seu ataque de máscara direcionado foi bem-sucedido e altamente eficiente.

Resumo

Neste laboratório, você aprendeu uma técnica poderosa e eficiente de quebra de senhas usando o Hashcat.

Você começou entendendo as limitações dos conjuntos de caracteres integrados do Hashcat para senhas com conjuntos de caracteres específicos e conhecidos. Em seguida, aprendeu como definir seu próprio conjunto de caracteres usando a opção --custom-charset1 e referenciá-lo em uma máscara com ?1. Ao criar um arquivo de máscara e lançar um ataque direcionado, você conseguiu decifrar um hash MD5 em segundos.

Este método de uso de conjuntos de caracteres personalizados é essencial para auditoria e recuperação eficientes de senhas quando você tem inteligência sobre a estrutura da senha, reduzindo significativamente o tempo e os recursos computacionais necessários para um ataque.