Automatizar el Descifrado con un Script de Bash

Introducción

En las pruebas de penetración y auditorías de seguridad, es común intentar múltiples técnicas de cracking de contraseñas contra un conjunto de hashes. Ejecutar cada comando manualmente puede consumir mucho tiempo e ser ineficiente. Los scripts de Bash proporcionan una forma potente de automatizar este proceso, creando una cadena de ataques que se ejecutan secuencialmente hasta que se encuentra la contraseña.

En este laboratorio, creará un script de Bash para automatizar una serie de ataques utilizando hashcat, una herramienta popular y potente de recuperación de contraseñas. Aprenderá a estructurar un script para intentar primero un ataque de diccionario, seguido de un ataque basado en reglas y, finalmente, un ataque de máscara. Esta experiencia práctica le introducirá en los fundamentos de la automatización en un contexto de ciberseguridad.

Al completar este laboratorio, podrá:

• Crear y hacer ejecutable un script de Bash.
• Añadir una secuencia de comandos de hashcat a un script.
• Comprender e implementar diferentes modos de ataque de hashcat.
• Ejecutar un script para automatizar un flujo de trabajo.

Crear un Nuevo Archivo de Script de Bash

En este paso, creará un archivo de script de Bash vacío, añadirá la línea shebang necesaria y lo hará ejecutable. Un script de Bash es un archivo de texto plano que contiene una serie de comandos. El shebang (#!/bin/bash) al principio del script le indica al sistema qué intérprete utilizar para ejecutar los comandos dentro del archivo.

Primero, cree un nuevo archivo llamado attack.sh en el directorio ~/project usando el comando touch.

touch attack.sh

A continuación, abra el archivo con el editor de texto nano para añadir la línea shebang.

nano attack.sh

Dentro del editor nano, añada la siguiente línea en la parte superior del archivo. Esto declara el archivo como un script de Bash.

#!/bin/bash

Presione Ctrl+X, luego Y, y Enter para guardar el archivo y salir de nano.

Finalmente, necesita otorgar permisos de ejecución al script para que pueda ejecutarlo como un programa. Utilice el comando chmod con la bandera +x para hacer esto.

chmod +x attack.sh

Puede verificar los permisos usando ls -l. Debería ver una 'x' en el bloque de permisos para attack.sh.

ls -l attack.sh

Salida esperada:

-rwxr-xr-x 1 labex labex 12 May 20 10:00 attack.sh

Añadir un Comando Hashcat para un Ataque de Diccionario

En este paso, añadirá el primer comando a su script: un ataque de diccionario. Este es uno de los métodos de cracking de contraseñas más comunes y efectivos. Funciona probando cada palabra de una lista dada (el diccionario) como una posible contraseña.

Utilizaremos hashcat para realizar este ataque. El entorno de laboratorio ha sido preconfigurado con un archivo de hashes hashes.txt y una lista de palabras wordlist.txt.

Abra su script attack.sh de nuevo con nano.

nano attack.sh

Añada el siguiente comando hashcat debajo de la línea #!/bin/bash.

hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt

Analicemos este comando:

• hashcat: El programa que estamos ejecutando.
• -m 0: Especifica el tipo de hash. 0 corresponde a MD5.
• -a 0: Especifica el modo de ataque. 0 corresponde a un ataque de diccionario directo.
• /home/labex/project/hashes.txt: El archivo que contiene el(los) hash(es) a crackear.
• /home/labex/project/wordlist.txt: El archivo de diccionario a utilizar para el ataque.

Su archivo attack.sh debería verse ahora así:

#!/bin/bash
hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist.txt

Presione Ctrl+X, luego Y, y Enter para guardar y salir. Por ahora, solo estamos construyendo el script y no lo ejecutaremos hasta el paso final.

Añadir un Segundo Comando para un Ataque Basado en Reglas

En este paso, añadirá un segundo ataque al script. Si el ataque de diccionario falla, un ataque basado en reglas suele ser el siguiente paso lógico. Este ataque toma una lista de palabras y aplica un conjunto de reglas a cada palabra para generar nuevos candidatos a contraseña. Por ejemplo, una regla podría añadir "123" a cada palabra o capitalizar la primera letra.

Hemos preparado una lista de palabras separada wordlist_for_rule.txt y un archivo de reglas simple rules.txt para esta demostración.

Abra attack.sh con nano de nuevo.

nano attack.sh

Añada el siguiente comando en una nueva línea, después del comando de ataque de diccionario.

hashcat -m 0 -a 0 /home/labex/project/hashes.txt /home/labex/project/wordlist_for_rule.txt -r /home/labex/project/rules.txt

La nueva parte de este comando es:

• -r /home/labex/project/rules.txt: Esta bandera le indica a hashcat que aplique las reglas definidas en el archivo especificado.

Su script attack.sh ahora debería contener dos 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

Presione Ctrl+X, Y, y Enter para guardar los cambios. El script ejecutará ahora estos comandos secuencialmente cuando se ejecute.

Añadir un Tercer Comando para un Ataque de Máscara

En este paso, añadirá el método de ataque final a su script: un ataque de máscara. Este método también se conoce como ataque de fuerza bruta y es útil cuando se sabe algo sobre la estructura de la contraseña, como su longitud o los tipos de caracteres que contiene.

La máscara define la estructura. Por ejemplo, ?l representa una letra minúscula, ?u una letra mayúscula, ?d un dígito y ?s un carácter especial.

Abra attack.sh por última vez con nano.

nano attack.sh

Añada el siguiente comando de ataque de máscara en una nueva línea al final del script. Esta máscara ?l?l?l?l?l?l?l?l probará todas las combinaciones de contraseñas de 8 caracteres en minúsculas.

hashcat -m 0 -a 3 /home/labex/project/hashes.txt ?l?l?l?l?l?l?l?l

Las partes clave de este comando son:

• -a 3: Esto establece el modo de ataque en 3, que es el ataque de máscara.
• ?l?l?l?l?l?l?l?l: Esta es la máscara en sí, que define la estructura de la contraseña a probar.

Su script attack.sh completo debería verse ahora así:

#!/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

Guarde el archivo y salga de nano presionando Ctrl+X, Y, y Enter. Su script de ataque automatizado está ahora completo.

Ejecutar el Script para Ejecutar la Cadena de Ataques Automáticamente

En este último paso, ejecutará el script que ha creado. Cuando ejecute ./attack.sh, el shell ejecutará los comandos dentro de él uno por uno. hashcat es inteligente; una vez que descifra un hash, almacena el resultado en un "potfile" (~/.local/share/hashcat/hashcat.potfile) y no intentará descifrarlo de nuevo.

Ahora, ejecute el script desde su terminal.

./attack.sh

El script iniciará el primer comando de hashcat. Dado que nuestro wordlist.txt contiene la contraseña correcta ("password"), el primer ataque tendrá éxito. Verá la salida de hashcat mientras se inicializa y se ejecuta.

Una ejecución exitosa mostrará un estado Cracked (Descifrado). Debido a que la contraseña se encuentra en el primer paso, hashcat la añadirá al potfile. Los comandos subsiguientes en el script se ejecutarán, pero hashcat verá que el hash ya está descifrado y lo omitirá.

Para ver la contraseña descifrada, puede usar la opción --show de hashcat.

hashcat -m 0 --show /home/labex/project/hashes.txt

Este comando comprueba el potfile en busca de cualquier hash descifrado que corresponda al archivo de entrada y los muestra.

Salida esperada:

5f4dcc3b5aa765d61d8327deb882cf99:password

¡Felicidades! Ha creado y ejecutado con éxito un script de Bash para automatizar una cadena de ataques de descifrado de contraseñas.

Resumen

En este laboratorio, ha aprendido los fundamentos de la automatización de tareas de seguridad utilizando scripts de Bash. Ha creado con éxito un script que encadena múltiples técnicas de descifrado de contraseñas de hashcat.

Comenzó creando un nuevo archivo de script de Bash y haciéndolo ejecutable. Luego, añadió progresivamente comandos para un ataque de diccionario, un ataque basado en reglas y un ataque de máscara. Finalmente, ejecutó el script para verlo en acción, observando cómo hashcat encuentra eficientemente la contraseña en la primera etapa y registra el resultado.

Las habilidades clave que ha practicado incluyen:

• Creación básica de scripts de Bash (touch, chmod, shebang).
• Uso de hashcat para diferentes modos de ataque (-a 0, -a 3).
• Implementación de ataques de diccionario, basados en reglas y de máscara.
• Automatización de una secuencia de comandos para crear un flujo de trabajo eficiente.

Este enfoque de scripting y automatización es una habilidad fundamental en ciberseguridad, administración de sistemas y muchos otros campos de TI, lo que le permite realizar tareas complejas y repetitivas con un solo comando.