Introducción
¡Hola de nuevo a todxs! 👋🏻
Tras un tiempo sin escribir ningún artículo nuevo, volvemos a la carga con uno de perfil técnico bastante interesante, el cuál podéis ir aplicando, siguiendo paso a paso su explicación y demostración.
Si lo prefieres, puedes clonarte directamente el repositorio de Github, conteniendo todos los scripts desarrollados durante la publicación, así como la estructura de directorios del proyecto
periodicNetworkScanner
Como todos sabemos, supervisar nuestras redes, es una tarea esencial para mantener la seguridad de nuestros activos, debiendo de tener en el mapa en todo momento, que nuevos hosts se han conectado a nuestras redes, para así poder prevenir una posible intrusión o movimiento malintencionado y que ningún cibercriminal actúe de manera ilegítima en nuestra red, tanto en vía cableada como inalámbrica.
Para ello, desarrollaremos, implementaremos y configuraremos una herramienta, la cual nos facilitará la tarea, en nuestro entorno Kali Linux, basándose en la automatización del descubrimiento de hosts, realizando escaneos periódicos y recibiendo notificaciones vía Telegram, cuando un nuevo dispositivo se conecta a cualquiera de las redes que tengamos identificadas.
Los objetivos que queremos conseguir con este proyecto, son los siguientes:
⧫ Desarrollar una solución totalmente autónoma para el descubrimiento de hosts en redes previamente identificadas.
⧫ Integrar Nmap como motor principal de exploración.
⧫ Garantizar que el sistema notifique los nuevos hosts detectados para una supervisión ágil y eficiente.
Todos los scripts que vamos a crear estarán en el PATH /home/username/Tools/periodicNetworkDiscovery
Debemos de tener muy en cuenta durante todo el post, que es de vital importancia cambiar en el PATH /home/username por vuestro nombre de usuario en la máquina en la que estéis realizando el proyecto, ya que si no, no funcionará correctamente. Es muy recomendable intercambiar en todos los scripts la cadena username por la cadena del nombre de vuestro /home.
1
2
mkdir -p /home/username/Tools/periodicNetworkDiscovery/{scripts,configs,output/known_hosts,output/logs}
touch /home/username/Tools/periodicNetworkDiscovery/output/dispositivos_conocidos.txt
El árbol de directorios del proyecto quedaría así:
1
2
3
4
5
6
7
8
9
10
/home/username/Tools/periodicNetworkDiscovery/
├── scripts/ # Scripts principales
│ ├── escaneo_inicial.sh # Realiza el escaneo inicial
│ └── detectar_nuevos_hosts.sh # Escaneos periódicos y notificaciones
├── configs/ # Configuraciones
│ └── redes_a_monitorizar.txt # Redes a escanear
├── output/ # Salidas organizadas
│ ├── known_hosts/ # Hosts conocidos por red
│ ├── logs/ # Archivos de log
│ └── dispositivos_conocidos.txt # Lista consolidada de dispositivos conocidos
Configuración de redes a monitorizar
El siguiente paso, será la creación del fichero redes_a_monitorizar.txt, en el cual identificaremos las redes que disponemos en nuestra infraestructura, para así listar las redes que deseamos monitorizar:
1
nano /home/<username>/Tools/Periodic_Network_Discovery/configs/redes_a_monitorizar.txt
Añadiremos las redes al fichero creado (una por línea):
1
2
3
4
192.168.1.0/24
10.0.0.0/16
172.16.0.0/12
[...]
Tengamos en cuenta que si queremos añadir una nueva red en el futuro, debemos de incluirla en este fichero.
Script para el escaneo inicial
El siguiente script realizará el primer escaneo de las redes identificadas, guardando los resultados en un fichero llamado known_hosts, sin necesidad de notificación por parte del Bot recientemente creado.
Creación del script escaneo_inicial.sh:
1
nano /home/username/Tools/periodicNetworkDiscovery/scripts/escaneo_inicial.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#!/bin/bash
# Directorios y configuración
CONFIG_FILE="../configs/redes_a_monitorizar.txt"
KNOWN_HOSTS_DIR="../output/known_hosts"
LOG_DIR="../output/logs"
# Crear directorios si no existen
mkdir -p $KNOWN_HOSTS_DIR $LOG_DIR
# Escaneo inicial
while read -r RED; do
echo "Iniciando escaneo inicial para la red: $RED"
OUTPUT_FILE="$KNOWN_HOSTS_DIR/$(echo $RED | tr '/' '_').txt"
# Escaneo rápido con Nmap en modo ping-only
nmap -sn "$RED" -oG - | awk '/Up$/{print $2}' > "$OUTPUT_FILE"
echo "Resultados iniciales guardados en $OUTPUT_FILE"
done < "$CONFIG_FILE"
echo "Escaneo inicial completado. Verifica los resultados en $KNOWN_HOSTS_DIR"
Otorgamos al script permisos de ejecución:
1
chmod +x /home/username/Tools/periodicNetworkDiscovery/scripts/escaneo_inicial.sh
Configuración del bot de Telegram para las notificaciones
En primera instancia, buscamos en Telegram a @BotFather para comenzar con la creación del bot.
Usamos el comando /start para posteriormente indicarle la creación de un nuevo bot con el comando /newbot y seguimos las instrucciones para ponerlo en marcha:
Le indicamos el nombre que le pondremos al bot, seguido del username que nos asignaremos. Una vez creado, nos dara el token que pondremos más adelante en el script
Con el comando curl, obtendremos el chat_id, necesario para el script que escribiremos posteriormente:
1
curl -s https://api.telegram.org/bot<TU_TOKEN>/getUpdates | jq
Debemos de guardar tanto el CHAT_ID como el API TOKEN, ya que lo utilizaremos más adelante en el script de reconocimiento que desarrollemos.
Script para escaneos periódicos con notificaciones
El siguiente script está basado en el escaneo de redes con Nmap, comparando los resultados con el archivo histórico. A su vez, notificará por Telegram los nuevos hosts detectados, agragando los nuevos activos a la lista de dispositivos conocidos si aparecen al menos 3 veces en los respectivos escaneos que vaya realizando.
Creamos el fichero detectar_nuevos_hosts.sh:
1
nano /home/username/Tools/periodicNetworkDiscovery/scripts/detectar_nuevos_hosts.sh
El contenido debe de ser el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#!/bin/bash
# Directorios y configuración
CONFIG_FILE="/home/username/Tools/periodicNetworkDiscovery/configs/redes_a_monitorizar.txt"
KNOWN_HOSTS_DIR="/home/username/Tools/periodicNetworkDiscovery/output/known_hosts"
KNOWN_DEVICES_FILE="/home/username/Tools/periodicNetworkDiscovery/output/dispositivos_conocidos.txt"
LOG_DIR="/home/username/Tools/periodicNetworkDiscovery/output/logs"
BOT_TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
CHAT_ID="xxxxxxxxxxx"
# Crear directorios y archivo de dispositivos conocidos si no existen
mkdir -p $KNOWN_HOSTS_DIR $LOG_DIR
touch $KNOWN_DEVICES_FILE
# Función para enviar notificaciones a Telegram
send_notification() {
NUEVOS_HOSTS=$1
# Formatear los nuevos hosts con saltos de línea explícitos
FORMATTED_HOSTS=$(echo "$NUEVOS_HOSTS" | sed ':a;N;$!ba;s/\n/\\n/g')
MESSAGE="🚨 *Nuevos hosts detectados:*\n$FORMATTED_HOSTS"
if [[ -z "$NUEVOS_HOSTS" ]]; then
echo "No hay nuevos hosts para notificar."
else
curl -s -X POST "https://api.telegram.org/bot$BOT_TOKEN/sendMessage" \
-d chat_id="$CHAT_ID" \
-d text="$MESSAGE" \
-d parse_mode="Markdown"
echo "Notificación enviada a Telegram."
fi
}
# Escaneo periódico
while read -r RED; do
echo "Iniciando escaneo para la red: $RED"
OUTPUT_FILE="$KNOWN_HOSTS_DIR/$(echo $RED | tr '/' '_').txt"
TEMP_FILE="$OUTPUT_FILE.tmp"
# Realizar escaneo rápido con Nmap
nmap -sn "$RED" -oG - | awk '/Up$/{print $2}' > "$TEMP_FILE"
# Comparar resultados con el histórico
if [[ -f "$OUTPUT_FILE" ]]; then
NUEVOS_HOSTS=$(comm -13 <(sort "$OUTPUT_FILE") <(sort "$TEMP_FILE"))
if [[ -n "$NUEVOS_HOSTS" ]]; then
# Notificar nuevos hosts
send_notification "$NUEVOS_HOSTS"
# Añadir los nuevos hosts al historial
echo "$NUEVOS_HOSTS" >> "$OUTPUT_FILE"
# Contar ocurrencias de cada host y añadir a dispositivos conocidos si aparecen 3+ veces
for HOST in $NUEVOS_HOSTS; do
COUNT=$(grep -c "$HOST" "$OUTPUT_FILE")
if [[ $COUNT -ge 3 ]]; then
if ! grep -q "$HOST" "$KNOWN_DEVICES_FILE"; then
echo "$HOST" >> "$KNOWN_DEVICES_FILE"
echo "Dispositivo conocido añadido: $HOST"
fi
fi
done
fi
fi
# Actualizar archivo histórico
mv "$TEMP_FILE" "$OUTPUT_FILE"
done < "$CONFIG_FILE"
echo "Escaneo completado. Revisa los logs y resultados."
Asignamos permisos de ejecución al script:
1
chmod +x /home/username/Tools/periodicNetworkDiscovery/scripts/detectar_nuevos_hosts.sh
Debemos de asignar en las variables API_TOKEN y CHAT_ID los valores obtenidos en el anterior paso, para que se comunique correctamente con el bot de Telegram y así estar notificados sobre los nuevos hosts que vayan apareciendo en las redes auditadas.
Automatizar el descubrimiento y monitorización en múltiples redes
Una vez guardado el script, automatizaremos la tarea con Cron, configurandolo para ejecutar este script periódicamente, por ejemplo cada 60 minutos:
1
crontab -e
Agregaremos la línea:
1
0 * * * * /bin/bash /home/username/Tools/periodicNetworkDiscovery/scripts/detectar_nuevos_hosts.sh >> /home/username/Tools/periodicNetworkDiscovery/output/logs/cron.log 2>&1
Teniendo todo operativo y bien implemenado, tendríamos como consecuente notificaciones vía Telegram cada vez que se descubran nuevos activos en nuestras redes de manera 100% automatizada:
Conclusión
Si hemos seguido los pasos correctamente, dispondremos de una herramienta sencilla pero a su vez bastante potente, la cual nos permitirá tener en el radar todas aquellas máquinas que se conecten a nuestras redes, sin tener que realizar ningún esfuerzo adicional, estando avisados en todo momento de cada movimiento vía Telegram.
Espero que os haya servido y, como siempre, cualquier duda y petición al respecto, podéis contactar conmigo a través del e-mail waidroc@protonmail.com o vía Linkedin
Muchas gracías por leer, Waidroc :)
Comments powered by Disqus.