Introdução
Em testes de penetração e auditorias de segurança, é comum tentar múltiplas técnicas de quebra de senhas contra um conjunto de hashes. Executar cada comando manualmente pode ser demorado e ineficiente. O scripting em Bash oferece uma maneira poderosa de automatizar esse processo, criando uma cadeia de ataques que são executados sequencialmente até que a senha seja encontrada.
Neste laboratório, você criará um script Bash para automatizar uma série de ataques usando o hashcat, uma ferramenta popular e poderosa de recuperação de senhas. Você aprenderá como estruturar um script para primeiro tentar um ataque de dicionário, seguido por um ataque baseado em regras e, finalmente, um ataque de máscara. Essa experiência prática apresentará os fundamentos da automação em um contexto de cibersegurança.
Ao concluir este laboratório, você será capaz de:
- Criar e tornar um script Bash executável.
- Adicionar uma sequência de comandos
hashcata um script. - Compreender e implementar diferentes modos de ataque do
hashcat. - Executar um script para automatizar um fluxo de trabalho.
Criar um Novo Arquivo de Script Bash
Nesta etapa, você criará um arquivo de script Bash vazio, adicionará a linha shebang necessária e o tornará executável. Um script Bash é um arquivo de texto simples contendo uma série de comandos. O shebang (#!/bin/bash) no início do script informa ao sistema qual interpretador usar para executar os comandos dentro do arquivo.
Primeiro, crie um novo arquivo chamado attack.sh no diretório ~/project usando o comando touch.
touch attack.sh
Em seguida, abra o arquivo com o editor de texto nano para adicionar a linha shebang.
nano attack.sh
Dentro do editor nano, adicione a seguinte linha no topo do arquivo. Isso declara o arquivo como um script Bash.
#!/bin/bash
Pressione Ctrl+X, depois Y e Enter para salvar o arquivo e sair do nano.
Finalmente, você precisa conceder permissões de execução ao script para que ele possa ser executado como um programa. Use o comando chmod com o sinalizador +x para fazer isso.
chmod +x attack.sh
Você pode verificar as permissões usando ls -l. Você deverá ver um 'x' no bloco de permissões para attack.sh.
ls -l attack.sh
Saída esperada:
-rwxr-xr-x 1 labex labex 12 May 20 10:00 attack.sh
Adicionar um Comando Hashcat para Ataque de Dicionário
Nesta etapa, você adicionará o primeiro comando ao seu script: um ataque de dicionário. Este é um dos métodos de quebra de senha mais comuns e eficazes. Ele funciona tentando cada palavra de uma lista fornecida (o dicionário) como uma senha potencial.
Usaremos o hashcat para realizar este ataque. O ambiente de laboratório foi pré-configurado com um arquivo de hash hashes.txt e uma lista de palavras wordlist.txt.
Abra seu script attack.sh novamente com nano.
nano attack.sh
Adicione o seguinte comando hashcat abaixo da linha #!/bin/bash.
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt
Vamos detalhar este comando:
hashcat: O programa que estamos executando.-m 0: Especifica o tipo de hash.0corresponde a MD5.-a 0: Especifica o modo de ataque.0corresponde a um ataque de dicionário direto./home/labex/project/hashes.txt: O arquivo contendo o(s) hash(es) a serem quebrados./home/labex/project/wordlist.txt: O arquivo de dicionário a ser usado para o ataque.
Seu arquivo attack.sh agora deve se parecer com isto:
#!/bin/bash
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt
Pressione Ctrl+X, depois Y e Enter para salvar e sair. Por enquanto, estamos apenas construindo o script e não o executaremos até a etapa final.
Adicionar um Segundo Comando para um Ataque Baseado em Regras
Nesta etapa, você adicionará um segundo ataque ao script. Se o ataque de dicionário falhar, um ataque baseado em regras é frequentemente o próximo passo lógico. Este ataque pega uma lista de palavras e aplica um conjunto de regras a cada palavra para gerar novos candidatos a senha. Por exemplo, uma regra pode anexar "123" a cada palavra ou capitalizar a primeira letra.
Preparamos uma lista de palavras separada wordlist_for_rule.txt e um arquivo de regras simples rules.txt para esta demonstração.
Abra o attack.sh com nano novamente.
nano attack.sh
Adicione o seguinte comando em uma nova linha, após o comando de ataque de dicionário.
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist_for_rule.txt -r /home/labex/project/rules.txt
A nova parte deste comando é:
-r /home/labex/project/rules.txt: Esta flag informa aohashcatpara aplicar as regras definidas no arquivo especificado.
Seu script attack.sh agora deve conter dois comandos hashcat:
#!/bin/bash
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist_for_rule.txt -r /home/labex/project/rules.txt
Pressione Ctrl+X, Y e Enter para salvar as alterações. O script agora executará esses comandos sequencialmente quando executado.
Adicionar um Terceiro Comando para um Ataque de Máscara
Nesta etapa, você adicionará o método de ataque final ao seu script: um ataque de máscara. Este método também é conhecido como ataque de força bruta e é útil quando você sabe algo sobre a estrutura da senha, como seu comprimento ou os tipos de caracteres que ela contém.
A máscara define a estrutura. Por exemplo, ?l representa uma letra minúscula, ?u uma letra maiúscula, ?d um dígito e ?s um caractere especial.
Abra o attack.sh pela última vez com nano.
nano attack.sh
Adicione o seguinte comando de ataque de máscara em uma nova linha no final do script. Esta máscara ?l?l?l?l?l?l?l?l tentará todas as combinações de senhas de 8 caracteres em minúsculas.
hashcat -m 0 -a 3 /home/labex/project/hashes.txt ?l?l?l?l?l?l?l?l
As partes principais deste comando são:
-a 3: Isso define o modo de ataque como3, que é o ataque de máscara.?l?l?l?l?l?l?l?l: Esta é a própria máscara, definindo a estrutura da senha a ser testada.
Seu script attack.sh completo agora deve se parecer com isto:
#!/bin/bash
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist_for_rule.txt -r /home/labex/project/rules.txt
hashcat -m 0 -a 3 /home/labex/project/hashes.txt ?l?l?l?l?l?l?l?l
Salve o arquivo e saia do nano pressionando Ctrl+X, Y e Enter. Seu script de ataque automatizado está agora completo.
Executar o Script para Executar a Cadeia de Ataques Automaticamente
Nesta etapa final, você executará o script que construiu. Ao executar ./attack.sh, o shell executará os comandos dentro dele um por um. O hashcat é inteligente; assim que ele quebra um hash, ele armazena o resultado em um "potfile" (~/.local/share/hashcat/hashcat.potfile) e não tentará quebrá-lo novamente.
Agora, execute o script do seu terminal.
./attack.sh
O script iniciará o primeiro comando hashcat. Como nosso wordlist.txt contém a senha correta ("password"), o primeiro ataque será bem-sucedido. Você verá a saída do hashcat enquanto ele inicializa e executa.
Uma execução bem-sucedida mostrará um status Cracked (Quebrado). Como a senha é encontrada na primeira etapa, o hashcat a adicionará ao potfile. Os comandos subsequentes no script serão executados, mas o hashcat verá que o hash já foi quebrado e o ignorará.
Para ver a senha quebrada, você pode usar a opção --show do hashcat.
hashcat -m 0 --show /home/labex/project/hashes.txt
Este comando verifica o potfile em busca de quaisquer hashes quebrados correspondentes ao arquivo de entrada e os exibe.
Saída esperada:
5f4dcc3b5aa765d61d8327deb882cf99:password
Parabéns! Você criou e executou com sucesso um script Bash para automatizar uma cadeia de ataques de quebra de senha.
Resumo
Neste laboratório, você aprendeu os fundamentos da automação de tarefas de segurança usando scripts Bash. Você criou com sucesso um script que encadeia várias técnicas de quebra de senha do hashcat.
Você começou criando um novo arquivo de script Bash e tornando-o executável. Em seguida, adicionou progressivamente comandos para um ataque de dicionário, um ataque baseado em regras e um ataque de máscara. Finalmente, você executou o script para vê-lo em ação, observando como o hashcat encontra eficientemente a senha na primeira etapa e registra o resultado.
As principais habilidades que você praticou incluem:
- Criação básica de scripts Bash (
touch,chmod, shebang). - Uso do
hashcatpara diferentes modos de ataque (-a 0,-a 3). - Implementação de ataques de dicionário, baseados em regras e de máscara.
- Automação de uma sequência de comandos para criar um fluxo de trabalho eficiente.
Essa abordagem de scripting e automação é uma habilidade central em cibersegurança, administração de sistemas e muitos outros campos de TI, permitindo que você execute tarefas complexas e repetitivas com um único comando.
