Quebrar Arquivos ZIP Protegidos por Senha com Hashcat

Introdução

Neste laboratório, você aprenderá o processo fundamental de quebrar um arquivo ZIP protegido por senha. Esta é uma tarefa comum em forense digital e testes de penetração. Você usará uma combinação de ferramentas de linha de comando disponíveis no Linux para realizar isso. O processo envolve a criação de um arquivo de amostra protegido, a extração de seu hash de senha e, em seguida, o uso de uma poderosa ferramenta de recuperação de senha, o Hashcat, para quebrar o hash e revelar a senha original.

Ao final deste laboratório, você estará familiarizado com:

Criação de arquivos ZIP criptografados.
Uso do zip2john para extrair hashes de senha.
Preparação de hashes para uso com o Hashcat.
Execução de um ataque de dicionário com o Hashcat para recuperar uma senha.

Criar um Arquivo ZIP Protegido por Senha

Nesta etapa, você criará um arquivo ZIP protegido por senha. Este servirá como nosso alvo para o exercício de quebra de senha. Usaremos o comando padrão zip com a opção -e, que significa "encrypt" (criptografar).

Primeiro, certifique-se de que você está no diretório ~/project. Já criamos um arquivo chamado secret.txt para você no processo de configuração.

Agora, execute o seguinte comando para criar um arquivo ZIP criptografado chamado secret.zip a partir do arquivo secret.txt.

zip -e secret.zip secret.txt

O sistema solicitará que você insira e verifique uma senha. Para este laboratório, use a senha labex. Digite labex, pressione Enter e, em seguida, digite novamente para verificar.

Enter password:
Verify password:
  adding: secret.txt (stored 0%)

Após a conclusão do comando, você pode usar o comando ls para verificar se o arquivo secret.zip foi criado em seu diretório atual.

ls -l

Você deverá ver secret.zip listado na saída.

-rw-r--r-- 1 labex labex  218 May 20 10:00 secret.zip
-rw-r--r-- 1 labex labex   23 May 20 10:00 secret.txt
-rw-r--r-- 1 labex labex   32 May 20 10:00 wordlist.txt

Usar zip2john para Extrair o Hash do Arquivo ZIP

Nesta etapa, você usará a utilidade zip2john para extrair o hash da senha do arquivo secret.zip. Ferramentas de quebra de senha como o Hashcat não funcionam diretamente no arquivo criptografado; elas funcionam em seu hash. zip2john é uma ferramenta do conjunto John the Ripper projetada especificamente para este propósito.

Execute o seguinte comando para processar secret.zip e salvar o hash resultante em um novo arquivo chamado zip_hash.txt.

zip2john secret.zip > zip_hash.txt

Este comando não produz saída direta para o terminal porque a redirecionamos para o arquivo zip_hash.txt. Para ver o hash extraído, você pode exibir o conteúdo do novo arquivo usando o comando cat.

cat zip_hash.txt

A saída será semelhante à seguinte. Esta string contém todas as informações necessárias para quebrar a senha.

secret.zip:$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$

Formatar o Hash para Compatibilidade com Hashcat

Nesta etapa, você formatará o hash extraído para torná-lo compatível com o Hashcat. A saída do zip2john inclui o nome do arquivo original (secret.zip:) como um prefixo para a string do hash. O Hashcat requer apenas os dados puros do hash.

Vamos analisar o conteúdo de zip_hash.txt novamente:
secret.zip:$pkzip2$1*1*2*0*8*24*...

Precisamos remover a parte secret.zip:. Uma maneira simples de fazer isso é com o comando cut, que pode dividir texto com base em um delimitador. Usaremos o dois pontos (:) como delimitador e selecionaremos o segundo campo.

Execute o seguinte comando para extrair o hash e salvá-lo em um novo arquivo chamado hashcat_ready.txt.

cut -d':' -f2 zip_hash.txt > hashcat_ready.txt

cut: O comando para cortar partes de linhas.
-d':': Especifica que o delimitador é um dois pontos.
-f2: Especifica que queremos o segundo campo.

Agora, visualize o conteúdo do novo arquivo para confirmar que ele contém apenas o hash.

cat hashcat_ready.txt

A saída deve ser a string do hash sem o prefixo do nome do arquivo.

$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$

Este arquivo está agora pronto para ser usado com o Hashcat.

Selecionar o Modo Correto do Hashcat para PKZIP

Nesta etapa, você aprenderá como identificar o modo de hash correto para o Hashcat. O Hashcat suporta a quebra de centenas de tipos diferentes de hash, e você deve especificar qual tipo está fornecendo usando um número de modo.

O hash que extraímos começa com $pkzip2$ . Isso indica o tipo de criptografia ZIP usada. Podemos pesquisar na documentação de ajuda do Hashcat por modos relacionados a "PKZIP" para encontrar o número correto.

Use o seguinte comando para pesquisar por "pkzip" na saída de ajuda do Hashcat.

hashcat --help | grep -i "pkzip"

A saída listará vários modos de hash relacionados a diferentes versões de criptografia PKZIP.

17200 | PKZIP (legacy)                                       | Archives
17210 | PKZIP (legacy) (Compressed)                            | Archives
17220 | PKZIP (legacy) (Mixed)                                 | Archives
17225 | PKZIP (legacy) (Mixed + Compressed)                    | Archives
20500 | PKZIP Master Key                                       | Archives
20510 | PKZIP Master Key (Compressed)                          | Archives

Nosso hash, gerado a partir de um ZIP simples protegido por senha, corresponde ao tipo "PKZIP (legacy)". Como você pode ver na saída, o número do modo para isso é 17200. Usaremos este modo na próxima etapa para iniciar nosso ataque.

Lançar um Ataque para Recuperar a Senha do ZIP

Nesta etapa, você lançará o ataque de quebra de senha usando o Hashcat. Realizaremos um ataque "direto" ou de dicionário, onde o Hashcat tenta cada senha de uma lista fornecida. Já preparamos uma lista simples chamada wordlist.txt.

A estrutura do comando para o Hashcat é a seguinte:
hashcat [opções] <arquivo_hash> <arquivo_lista_de_palavras>

Com base em nossas etapas anteriores, o comando completo é:

hashcat -m 17200 -a 0 hashcat_ready.txt wordlist.txt

Vamos detalhar o comando:

-m 17200: Especifica o modo de hash para PKZIP (legacy), que identificamos na etapa anterior.
-a 0: Especifica o modo de ataque. 0 significa um ataque Direto (de dicionário).
hashcat_ready.txt: O arquivo contendo nosso hash alvo.
wordlist.txt: O arquivo contendo a lista de senhas potenciais.

Execute o comando. O Hashcat iniciará, inicializará seu backend e começará o ataque.

hashcat (v6.2.6) starting

...

Session..........: hashcat
Status...........: Cracked
Hash.Name........: PKZIP (legacy)
Hash.Target......: $pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$
Time.Started.....: ...
Time.Estimated...: 0 secs
Guess.Base.......: File (wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   248.2 kH/s (0.10ms) @ Accel:128 Loops:128 Thr:1
Recovered........: 1/1 (100.00%) Digests
Progress.........: 4/4 (100.00%)
Rejected.........: 0/4 (0.00%)
Restore.Point....: 3/4 (75.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: labex -> zzzzzzz
Hardware.Mon.#1..: Temp: 48c

$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$:labex

Started: ...
Stopped: ...

O Hashcat encontrou a senha muito rapidamente porque nossa lista de palavras era pequena. A última linha da saída mostra o hash seguido pela senha recuperada: labex.

Parabéns, você quebrou com sucesso a senha do arquivo ZIP!

Resumo

Neste laboratório, você completou com sucesso todo o fluxo de trabalho para quebrar um arquivo ZIP protegido por senha usando ferramentas comuns de linha de comando.

Você aprendeu a:

Criar um arquivo ZIP criptografado usando o comando zip.
Extrair o hash da senha do arquivo ZIP usando zip2john.
Formatar o hash extraído para torná-lo compatível com o Hashcat.
Identificar o modo de tipo de hash correto para seu alvo dentro do Hashcat.
Lançar um ataque de dicionário com o Hashcat para recuperar com sucesso a senha.

Essas habilidades formam uma compreensão fundamental de técnicas de recuperação de senha que são cruciais em campos de cibersegurança como forense digital e hacking ético. Embora tenhamos usado uma senha simples e uma pequena lista de palavras para fins educacionais, os mesmos princípios se aplicam a cenários do mundo real mais complexos.