Simular Phishing en SET

Introducción

En este laboratorio, aprenderá cómo simular un ataque de phishing utilizando el Social Engineer Toolkit (SET) para comprender las técnicas de recopilación de credenciales. Practicará la instalación de SET, la creación de páginas de inicio de sesión falsas y la captura de credenciales para analizar cómo los atacantes explotan las vulnerabilidades humanas.

El ejercicio demuestra métodos reales de ingeniería social a través de la experiencia práctica de clonación de páginas de phishing y monitoreo de credenciales. Observará lo fácil que es engañar a los usuarios para que revelen información sensible en sitios web falsificados.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) wireshark/WiresharkGroup -.-> wireshark/export_packets("Exporting Packets") wireshark/WiresharkGroup -.-> wireshark/packet_analysis("Packet Analysis") subgraph Lab Skills wireshark/export_packets -.-> lab-549949{{"Simular Phishing en SET"}} wireshark/packet_analysis -.-> lab-549949{{"Simular Phishing en SET"}} end

Instalar SocialEngineer Toolkit

En este paso, instalará el SocialEngineer Toolkit (SET), un potente marco de pruebas de penetración de código abierto diseñado para ataques de ingeniería social. SET ofrece varios vectores de ataque, como la recopilación de credenciales, campañas de phishing y más. Para los principiantes, es importante entender que SET es una herramienta de seguridad legítima que los profesionales utilizan para probar las vulnerabilidades de los sistemas, no con fines malintencionados.

Primero, asegúrese de estar en el directorio de trabajo predeterminado. Aquí es donde descargaremos e instalaremos SET para mantener sus archivos organizados:
```
cd ~/project
```
Clone el repositorio de SET desde GitHub. Este comando descarga la última versión de SET desde su fuente oficial:
```
git clone https://github.com/trustedsec/social-engineer-toolkit.git
```
Navegue hasta el directorio de SET. Después de la descarga, necesitamos entrar en la carpeta donde se instaló SET:
```
cd social-engineer-toolkit
```
Instale SET utilizando el instalador de Python. El comando 'sudo' nos otorga los privilegios administrativos necesarios para la instalación, mientras que 'python3' asegura que estemos utilizando la versión correcta de Python:
```
sudo python3 setup.py install
```
Espere a que se complete la instalación. Este proceso puede tardar unos minutos mientras instala todos los componentes necesarios. Debería ver una salida similar a:
```
[*] Social Engineer Toolkit (SET) has been installed.
[*] You can now launch setoolkit by typing 'setoolkit' in your terminal.
```
Verifique la instalación comprobando la versión de SET. Esto confirma que SET se instaló correctamente y muestra la versión que está ejecutando:
```
setoolkit --version
```
Debería ver una salida que muestre el número de versión instalada, lo que significa que SET está listo para usar.

Configurar una página de phishing

En este paso, configurará una página de phishing utilizando el Social Engineer Toolkit (SET) para simular un ataque de recopilación de credenciales. El phishing es un ataque cibernético común en el que los atacantes crean páginas de inicio de sesión falsas para robar las credenciales de los usuarios. SET facilita demostrar cómo funciona esto en un entorno controlado.

Crearemos una página de inicio de sesión falsa que imite un servicio popular. Esta página clonada se verá idéntica al sitio web real, pero cualquier credencial ingresada será capturada por nuestro sistema en lugar de enviarse al servicio legítimo.

Primero, asegúrese de estar en el directorio de SET. Aquí es donde se instaló la herramienta en su sistema:
```
cd ~/project/social-engineer-toolkit
```
Inicie la herramienta SET con privilegios de root. SET requiere acceso administrativo para configurar la configuración de red y los servicios web:
```
sudo setoolkit
```
En el menú de SET, navegaremos a través de las opciones de ataque:
- Seleccione 1) Social-Engineering Attacks - Esta es la categoría principal para los ataques de phishing
- Luego elija 2) Website Attack Vectors - Estamos creando un sitio web falso
- Seleccione 3) Credential Harvester Attack Method - Dirigido específicamente a las credenciales de inicio de sesión
- Elija 2) Site Cloner - Copiaremos el diseño de un sitio web existente
Cuando se le solicite la dirección IP para el POST back, presione Enter para usar la predeterminada (la dirección IP de su máquina virtual). Aquí es donde se enviarán las credenciales robadas.
Ingrese la URL a clonar (usaremos un sitio de demostración). En un caso real, esta sería el sitio web objetivo que está imitando:
```
https://example.com
```
SET clonará la página y configurará el ataque de phishing. El proceso de clonación copia el HTML, CSS e imágenes del sitio web para que se vea auténtico. Debería ver una salida similar a:
```
[*] Cloning the website: https://example.com
[*] This could take a little bit...
[*] Files have been imported to the Apache web root.
```
La página de phishing ahora está configurada y lista para ser alojada (lo haremos en el siguiente paso). En este punto, SET ha creado una réplica perfecta del sitio objetivo que capturará cualquier credencial ingresada en su formulario de inicio de sesión.

Alojar la página falsa

En este paso, haremos que tu página de phishing esté disponible en la red al alojarla con el servidor web Apache. Apache es un popular servidor web que entregará tu página de inicio de sesión falsa a cualquiera que visite la dirección IP de tu máquina virtual. Así es como funcionan los ataques de phishing reales: imitando sitios web legítimos en servidores controlados por los atacantes.

Primero, necesitamos instalar Apache si no está ya presente en tu sistema. Ejecuta este comando para actualizar la lista de paquetes e instalar Apache:
```
sudo apt-get update && sudo apt-get install -y apache2
```
La bandera -y confirma automáticamente la instalación, por lo que no necesitas aprobarla manualmente.
Después de la instalación, verifica si Apache está en ejecución con:
```
sudo service apache2 status
```
Si el servicio no está en ejecución (lo cual es común después de una instalación reciente), inícialo con:
```
sudo service apache2 start
```
El Social Engineer Toolkit (SET) guarda automáticamente los archivos de tu página de phishing en el directorio web predeterminado de Apache. Verifiquemos que estos archivos existan:
```
ls /var/www/html
```
Deberías ver index.html (la página principal de phishing) junto con otros archivos que hacen que la página se vea auténtica, como imágenes y hojas de estilo del sitio web clonado.
Para permitir que otros accedan a tu página de phishing, necesitas conocer la dirección IP de tu máquina virtual. Encuéntrala con:
```
hostname -I
```
Anota esta dirección IP (la referiremos como YOUR_VM_IP) ya que la necesitarás para probar y compartir el enlace de phishing.
Antes de compartir la página, pruébala localmente para asegurarte de que se cargue correctamente:
```
curl http://localhost
```
Este comando obtiene el contenido de la página. Deberías ver una salida HTML que coincida con tu sitio clonado. Si obtienes un error, es posible que Apache no esté funcionando correctamente.
Tu página de phishing ahora está activa y es accesible en:
```
http://YOUR_VM_IP
```
Cualquier persona en tu red que visite esta dirección verá tu página de inicio de sesión falsa.
Mantén Apache en ejecución: no cierres la terminal ni detengas el servicio. En los siguientes pasos, usaremos esta página alojada para capturar credenciales cuando las víctimas ingresen su información.

Capturar credenciales

En este paso, aprenderás cómo los ataques de phishing capturan las credenciales de inicio de sesión simulando tanto la perspectiva del atacante como la de la víctima. Cuando las víctimas ingresan sin saberlo sus datos en páginas de inicio de sesión falsas (como la que creamos anteriormente), SET guarda esa información sensible para el atacante.

Primero, verifiquemos que SET todavía esté en ejecución desde nuestra configuración anterior. Si lo has cerrado o la sesión ha expirado, necesitamos reiniciar la herramienta. Esto asegura que nuestro servidor de phishing esté activo y esperando conexiones de víctimas:
```
cd ~/project/social-engineer-toolkit
sudo setoolkit
```
Ahora configuraremos SET para capturar credenciales. En el menú principal de SET, selecciona cuidadosamente estas opciones en orden:
- 4) Create a Payload and Listener - Esto prepara a SET para recibir datos
- 2) Website Attack Vectors - Nos estamos enfocando en ataques basados en la web
- 3) Credential Harvester Attack Method - Dirigido específicamente a las credenciales de inicio de sesión
- 1) Web Templates - Utiliza plantillas prefabricadas de páginas de phishing
Mantén esta ventana de terminal abierta. SET ahora está monitoreando activamente el tráfico de red y esperando que las víctimas envíen sus credenciales a través de nuestra página de inicio de sesión falsa.
Simulemos la acción de una víctima. Abre una nueva pestaña de terminal (Ctrl+Shift+T en la mayoría de los entornos Linux) y utiliza curl para enviar credenciales de prueba a nuestro servidor de phishing local. Esto imita lo que sucede cuando alguien rellena y envía un formulario de inicio de sesión:
```
curl -X POST -d "username=testuser&password=Test123!" http://localhost
```
Verifica inmediatamente tu terminal de SET. Deberías ver una confirmación de que se capturaron las credenciales, mostrada en este formato claro:
```
[*] WE GOT A HIT!
Username: testuser
Password: Test123!
```
SET registra automáticamente todas las credenciales capturadas para su revisión posterior. Para ver el registro completo del ataque, incluyendo nuestra entrada de prueba, ejecuta:
```
sudo cat /var/lib/set/logs/set.log
```
El archivo de registro mostrará tus credenciales de prueba junto con la hora exacta en que se capturaron. En ataques reales, este archivo contendría todas las credenciales obtenidas exitosamente a lo largo del tiempo.

Revisar los datos capturados

Ahora que has completado la simulación de phishing, examinemos los resultados. Este último paso te mostrará cómo acceder e interpretar los datos recopilados por el Social Engineer Toolkit (SET), así como cómo limpiar adecuadamente tu entorno de prueba para mantener las mejores prácticas de seguridad.

Primero, veremos el archivo de registro completo de SET, que contiene todas las credenciales capturadas en su formato original. Este archivo se almacena en una ubicación protegida del sistema, por lo que necesitamos usar sudo:
```
sudo cat /var/lib/set/logs/set.log
```
Este comando muestra el contenido del archivo de registro principal de SET, donde todas las credenciales capturadas se almacenan automáticamente durante la simulación de phishing.
Para una mejor organización y referencia futura, creemos una copia de trabajo de estos datos en tu directorio de proyecto. También cambiaremos la propiedad del archivo a tu cuenta de usuario de laboratorio:
```
cd ~/project
sudo cp /var/lib/set/logs/set.log captured_credentials.txt
sudo chown labex:labex captured_credentials.txt
```
El comando chown asegura que tengas los permisos adecuados para trabajar con este archivo sin necesidad de usar sudo en operaciones posteriores.
Ahora veamos el informe formateado que acabamos de crear:
```
cat captured_credentials.txt
```
Deberías ver una salida estructurada similar a este ejemplo, que muestra las credenciales capturadas junto con marcas de tiempo e información de origen:
```
[*] 2023-11-15 14:30:22 - Credentials captured:
Username: testuser
Password: Test123!
IP Address: 127.0.0.1
```
Es importante limpiar tu entorno de prueba después de completar el ejercicio. Esto elimina la página de phishing que creamos y detiene el servidor web:
```
sudo rm /var/www/html/index.html
sudo service apache2 stop
```
Estos comandos aseguran que no queden materiales de prueba residuales que puedan representar riesgos de seguridad.
Finalmente, documentemos nuestros hallazgos creando un informe resumen que cuente cuántas credenciales se capturaron:
```
echo "Phishing Test Results" > test_summary.txt
echo "Total credentials captured: $(grep -c 'Username' captured_credentials.txt)" >> test_summary.txt
cat test_summary.txt
```
Esto crea un informe simple que muestra el número total de pares de credenciales capturados durante tu prueba. El comando grep -c cuenta cuántas veces aparece 'Username' en tu archivo de datos capturados.

Resumen

En este laboratorio, has aprendido cómo simular ataques de phishing utilizando el Social Engineer Toolkit (SET). El proceso incluyó la instalación de SET, la configuración de páginas de phishing a través de la recopilación de credenciales y la clonación de sitios web objetivo para crear interfaces de inicio de sesión engañosas.

El ejercicio proporcionó experiencia práctica con herramientas de pruebas de penetración y técnicas de ingeniería social. Exploraste cómo los atacantes capturan credenciales y adquiriste conciencia sobre estrategias defensivas contra tales amenazas de seguridad.