En el vasto y a menudo turbulento océano digital, la seguridad informática no es un lujo, sino una necesidad imperante. A medida que las amenazas evolucionan, también debe hacerlo nuestra capacidad de defendernos. ¿Alguna vez has pensado en tener un guardián digital personal, vigilando tu sistema sin descanso? ¿Uno que no solo te alerte sobre posibles intrusos, sino que también entiendas completamente cómo funciona porque lo has construido tú mismo? Hoy, te propongo un viaje fascinante: vamos a explorar cómo puedes crear tu propio script de detección de intrusos con Bash. 🛡️💻
Olvídate de las soluciones complejas y costosas por un momento. Con la potencia de Bash, el lenguaje de scripting de la terminal de Linux, podemos diseñar una herramienta sorprendente y adaptable a nuestras necesidades. No solo aprenderás a proteger mejor tus sistemas, sino que también adquirirás un conocimiento profundo de cómo funcionan los sistemas operativos y las técnicas de ciberseguridad. ¡Prepárate para empoderarte!
¿Por qué un IDS en Bash? La Filosofía ‘Hazlo Tú Mismo’ 🚀
Un Sistema de Detección de Intrusos (IDS) es, en esencia, un centinela digital que observa la actividad de un sistema o red en busca de comportamientos sospechosos o maliciosos. Existen soluciones comerciales y de código abierto muy robustas, ¿entonces por qué molestarse en construir una con Bash? Aquí te doy algunas razones convincentes:
- Flexibilidad Extrema: Los scripts de Bash son altamente personalizables. Puedes ajustarlos para monitorear exactamente lo que te importa, ignorando el „ruido” que otras soluciones podrían generar.
- Recursos Mínimos: Bash es ligero. Un script bien diseñado consumirá una cantidad insignificante de recursos del sistema, lo que lo hace ideal para servidores con cargas de trabajo intensas o dispositivos de baja potencia.
- Comprensión Profunda: Al construir tu propio IDS, te verás obligado a entender los fundamentos de la detección de amenazas, los archivos de log del sistema y cómo interactúan los componentes de tu sistema operativo. Este conocimiento es invaluable.
- Aprendizaje Continuo: Es una excelente manera de mejorar tus habilidades en scripting y en administración de sistemas Linux.
- Control Total: No dependes de terceros ni de actualizaciones de software. Tienes el control absoluto sobre cómo se comporta tu sistema de seguridad.
Esta aventura no es solo sobre escribir código; es sobre adoptar una mentalidad proactiva en la protección de tus activos digitales. Es sobre decir: „Yo puedo entender y proteger mi propio rincón digital”.
Fundamentos de la Detección de Intrusos (y cómo Bash encaja) 🔍
Antes de sumergirnos en el código, entendamos brevemente los tipos de IDS. Los hay basados en red (NIDS), que monitorean el tráfico de la red, y basados en host (HIDS), que se centran en la actividad dentro de un sistema individual. Nuestro script de Bash se enfocará en un HIDS, ya que Bash es excelente para interactuar con el sistema operativo local.
¿Qué tipo de actividades sospechosas buscaría un HIDS? Principalmente:
- Cambios Inesperados: Archivos importantes del sistema modificados, eliminados o creados.
- Accesos no Autorizados: Intentos fallidos de inicio de sesión, nuevos usuarios creados.
- Procesos Anómalos: Programas ejecutándose que no deberían, o procesos legítimos con comportamientos extraños.
- Actividad de Red Sospechosa: Conexiones a direcciones IP desconocidas o a puertos inusuales desde el host.
Bash, con su arsenal de comandos como find, grep, awk, sed, sha256sum, diff, last, who, netstat y ps, es increíblemente capaz de realizar estas tareas de monitoreo y análisis.
Componentes Clave de Nuestro Script IDS en Bash ⚙️
Nuestro IDS rudimentario pero efectivo se basará en la supervisión de varias facetas del sistema. Aquí desglosamos los módulos principales:
1. Monitoreo de Integridad de Archivos (FIM) 📂
Este es el corazón de muchos HIDS. La idea es simple: generar una „huella digital” (un hash criptográfico) de archivos críticos del sistema y luego compararla regularmente con su estado actual. Si el hash cambia, el archivo ha sido modificado. La herramienta estrella aquí es sha256sum, que genera un hash seguro.
Nuestro script debería:
- Generar una línea base (baseline) inicial de hashes para archivos y directorios específicos.
- En ejecuciones posteriores, calcular los hashes actuales y compararlos con la línea base.
- Reportar cualquier discrepancia.
2. Detección de Cambios en Archivos de Configuración Críticos 🔑
Una extensión del FIM, pero con un enfoque en archivos clave como /etc/passwd, /etc/shadow, /etc/sudoers, /etc/ssh/sshd_config. Un cambio en estos archivos podría indicar un intento de escalada de privilegios o un backdoor. La mecánica es idéntica al FIM general, pero las alertas para estos archivos deben ser de máxima prioridad.
3. Monitoreo de Intentos de Inicio de Sesión Fallidos 🚦
Un gran número de intentos de inicio de sesión fallidos en un corto período de tiempo suele ser un indicador de ataques de fuerza bruta. Podemos analizar los archivos de registro del sistema (/var/log/auth.log en Debian/Ubuntu o /var/log/secure en CentOS/RHEL). Comandos como grep "Failed password" y awk nos ayudarán a extraer y contar estos eventos.
4. Detección de Nuevos Usuarios o Grupos 👤
La creación de nuevos usuarios o la modificación de grupos sin autorización puede ser una señal clara de compromiso. Nuestro script puede comparar las entradas actuales en /etc/passwd y /etc/group con una línea base, o simplemente buscar entradas recientes. También podemos usar el comando last para ver inicios de sesión recientes y sus orígenes.
5. Monitoreo de Procesos Anómalos 📈
Detectar procesos que no deberían estar ejecutándose o procesos con comportamientos extraños es más complejo, pero Bash puede ayudar. Podemos listar todos los procesos con ps aux y buscar nombres de procesos sospechosos o inusuales. Para un script de Bash, una estrategia más simple podría ser buscar procesos que intenten ocultarse o que consuman recursos de forma desproporcionada (aunque esto último es más difícil de automatizar con precisión en Bash).
6. Monitoreo de Conexiones de Red Sospechosas 🌐
Un atacante podría establecer conexiones salientes a servidores de Comando y Control (C2) o abrir puertos para acceso remoto. Usando netstat -tulnp podemos listar las conexiones de red activas y los puertos abiertos. Luego, el script podría comparar estas conexiones con una lista de „conexiones esperadas” o alertar sobre cualquier conexión a IPs o puertos no reconocidos.
Diseñando la Estructura de Nuestro Script (Un Ejemplo Práctico) 📝
Vamos a esbozar la estructura de nuestro script de seguridad. Un buen script es modular, fácil de leer y de mantener.
#!/bin/bash
# Directorios y Archivos de Configuración
LOG_DIR="/var/log/bash_ids"
BASELINE_DIR="/etc/bash_ids_baselines"
REPORT_EMAIL="[email protected]"
TIMESTAMP=$(date +"%Y%m%d%H%M%S")
ALERT_LOG="$LOG_DIR/alerts_$TIMESTAMP.log"
CURRENT_BASELINE="$BASELINE_DIR/current_baseline.txt"
PREVIOUS_BASELINE="$BASELINE_DIR/previous_baseline.txt"
FIM_MONITOR_PATHS="/etc /bin /usr/bin /sbin /usr/sbin" # Rutas a monitorear con FIM
# Crear directorios si no existen
mkdir -p $LOG_DIR
mkdir -p $BASELINE_DIR
# --- Funciones de Detección ---
# Función para generar la línea base de integridad de archivos
generate_fim_baseline() {
echo "Generando línea base FIM..."
# Primero, rotar las líneas base para tener una referencia anterior
if [ -f "$CURRENT_BASELINE" ]; then
mv "$CURRENT_BASELINE" "$PREVIOUS_BASELINE"
fi
find $FIM_MONITOR_PATHS -type f -exec sha256sum {} + > "$CURRENT_BASELINE"
echo "Línea base FIM generada en: $CURRENT_BASELINE"
}
# Función para verificar la integridad de archivos
check_file_integrity() {
echo "Verificando integridad de archivos..."
if [ ! -f "$CURRENT_BASELINE" ] || [ ! -f "$PREVIOUS_BASELINE" ]; then
echo "ERROR: No se encontró una línea base FIM o la anterior. Generando una nueva." | tee -a "$ALERT_LOG"
generate_fim_baseline
return 1
fi
# Comparar el estado actual con la línea base actual, pero también el actual con el anterior para detectar cambios.
# En un escenario real, compararías el actual con el *previamente guardado* baseline
# Para simplicidad y ejemplo, usaremos el current como referencia y asumimos que se regeneró.
# Una mejor estrategia sería comparar CURRENT_BASELINE (generado en la corrida anterior) con un NUEVO_BASELINE_TEMPORAL
# Para este ejemplo, haremos una comparación simple: ¿hay diferencias entre el actual y el que se generó "justo ahora"?
# Esto no es lo más realista. La lógica correcta es:
# 1. Cargar la línea base *previa* (del último escaneo).
# 2. Generar una *nueva* línea base (del estado actual).
# 3. Comparar la nueva con la previa.
# Vamos a simularlo mejor
TEMP_CURRENT_SNAPSHOT="$LOG_DIR/temp_current_fim_snapshot.txt"
find $FIM_MONITOR_PATHS -type f -exec sha256sum {} + > "$TEMP_CURRENT_SNAPSHOT"
DIFF_OUTPUT=$(diff "$PREVIOUS_BASELINE" "$TEMP_CURRENT_SNAPSHOT")
if [ -n "$DIFF_OUTPUT" ]; then
echo "ALERTA: Se detectaron cambios en la integridad de archivos críticos:" | tee -a "$ALERT_LOG"
echo "$DIFF_OUTPUT" | tee -a "$ALERT_LOG"
# Actualizar la línea base si se detectan cambios
mv "$TEMP_CURRENT_SNAPSHOT" "$CURRENT_BASELINE"
else
echo "No se detectaron cambios en la integridad de archivos."
rm "$TEMP_CURRENT_SNAPSHOT" # Limpiar snapshot temporal
fi
}
# Función para monitorear intentos de inicio de sesión fallidos
check_failed_logins() {
echo "Monitoreando intentos de inicio de sesión fallidos..."
# Busca intentos fallidos en el último minuto (o desde la última ejecución)
# Ajusta el tiempo según la frecuencia de ejecución del script
FAILED_ATTEMPTS=$(journalctl _COMM=sshd --since "1 hour ago" | grep "Failed password" | awk '{print $11}' | sort | uniq -c | sort -nr)
# Fallback para sistemas sin journalctl o si solo queremos ver auth.log
if [ -z "$FAILED_ATTEMPTS" ] && [ -f "/var/log/auth.log" ]; then
FAILED_ATTEMPTS=$(grep "Failed password" /var/log/auth.log | tail -n 100 | awk '{print $11}' | sort | uniq -c | sort -nr) # Últimas 100 líneas
fi
if [ -n "$FAILED_ATTEMPTS" ]; then
echo "ALERTA: Intentos de inicio de sesión fallidos detectados:" | tee -a "$ALERT_LOG"
echo "$FAILED_ATTEMPTS" | tee -a "$ALERT_LOG"
else
echo "No se detectaron intentos de inicio de sesión fallidos significativos."
fi
}
# Función para detectar nuevos usuarios
check_new_users() {
echo "Verificando nuevos usuarios..."
CURRENT_USERS_FILE="$LOG_DIR/current_users.txt"
PREVIOUS_USERS_FILE="$LOG_DIR/previous_users.txt"
cut -d: -f1 /etc/passwd | sort > "$CURRENT_USERS_FILE"
if [ -f "$PREVIOUS_USERS_FILE" ]; then
NEW_USERS=$(diff "$PREVIOUS_USERS_FILE" "$CURRENT_USERS_FILE" | grep ">" | cut -d' ' -f2)
if [ -n "$NEW_USERS" ]; then
echo "ALERTA: Se detectaron nuevos usuarios en el sistema:" | tee -a "$ALERT_LOG"
echo "$NEW_USERS" | tee -a "$ALERT_LOG"
else
echo "No se detectaron nuevos usuarios."
fi
else
echo "Primera ejecución de detección de usuarios. Creando línea base."
fi
mv "$CURRENT_USERS_FILE" "$PREVIOUS_USERS_FILE"
}
# Función para monitorear procesos sospechosos (ejemplo básico)
check_suspicious_processes() {
echo "Monitoreando procesos sospechosos..."
# Ejemplo: buscar procesos con nombres raros o que no son comunes
SUSPICIOUS_PROCESSES=$(ps aux | grep -v "grep" | grep -E "(nc|ncat|socat|strace|tcpdump)" | awk '{print $11, $12, $13}') # Herramientas comunes de atacantes
if [ -n "$SUSPICIOUS_PROCESSES" ]; then
echo "ALERTA: Procesos potencialmente sospechosos detectados:" | tee -a "$ALERT_LOG"
echo "$SUSPICIOUS_PROCESSES" | tee -a "$ALERT_LOG"
else
echo "No se detectaron procesos sospechosos obvios."
fi
}
# Función para reportar alertas
send_alert_email() {
if [ -s "$ALERT_LOG" ]; then # -s true si el archivo existe y su tamaño es mayor que cero
echo "Enviando alerta por correo electrónico..."
mail -s "ALERTA IDS BASH - $(hostname) - $TIMESTAMP" "$REPORT_EMAIL" < "$ALERT_LOG"
echo "Alerta enviada."
# Puedes mover el log después de enviarlo para un mejor seguimiento
mv "$ALERT_LOG" "$LOG_DIR/sent_alerts/alerts_$TIMESTAMP.log"
mkdir -p "$LOG_DIR/sent_alerts" # Asegurarse de que el directorio exista
else
echo "No hay alertas que enviar."
rm "$ALERT_LOG" # Limpiar log vacío
fi
}
# --- Lógica Principal del Script ---
main() {
echo "Iniciando script de detección de intrusos Bash..."
# Generar línea base FIM si es la primera vez o si se necesita actualizar
if [ ! -f "$CURRENT_BASELINE" ]; then
generate_fim_baseline
echo "Primera ejecución, línea base FIM creada. Ejecuta de nuevo para verificación."
return 0 # Salir en la primera ejecución para permitir la creación de la línea base
fi
# Ejecutar todas las funciones de detección
check_file_integrity
check_failed_logins
check_new_users
check_suspicious_processes
# Enviar correo electrónico si hay alertas
send_alert_email
echo "Script de detección de intrusos Bash finalizado."
}
# Ejecutar la función principal
main
La ciberseguridad no es un destino, sino un viaje continuo. Un IDS en Bash es un paso fundamental para tomar las riendas de tu propia defensa digital, ofreciendo una capa de visibilidad y control que las soluciones prefabricadas a menudo oscurecen para el usuario común.
Consideraciones Importantes y Mejores Prácticas ⚠️
- Permisos: El script probablemente necesitará ejecutarse con privilegios de
rootpara acceder a ciertos archivos y logs del sistema. Asegúrate de que solo sea ejecutable por usuarios autorizados y de que el propio script esté protegido. - Programación con Cron: Para que sea efectivo, el script debe ejecutarse regularmente. Usa
crontab -epara programarlo. Por ejemplo,0 * * * * /path/to/tu_ids_script.shlo ejecutaría cada hora. - Exclusiones: Algunos archivos cambian constantemente (ej. archivos de log activos, cachés, etc.). Deberás excluirlos del monitoreo de integridad para evitar falsos positivos y "ruido" en tus alertas. Modifica la variable
FIM_MONITOR_PATHSy considera añadir opciones de exclusión afind. - Alertas Inteligentes: Demasiadas alertas (falsos positivos) te harán ignorar el sistema. Afina los umbrales y las reglas de detección para que solo se te notifique sobre lo realmente crítico.
- Seguridad del Propio Script: Protege tu script y sus directorios de línea base. Si un atacante puede modificar tu línea base o el script, el IDS será inútil. Establece permisos restrictivos (ej.
chmod 700 tu_ids_script.shychmod 700 /etc/bash_ids_baselines). - Almacenamiento Seguro de Logs: Los logs de tu IDS son vitales. Asegúrate de que estén guardados en un lugar seguro, quizás en un servidor de logs centralizado si la escala lo permite.
- Limitaciones: Este IDS en Bash es un sistema básico. No reemplaza a un IDS/IPS comercial completo, que ofrece análisis de paquetes más profundos, bases de datos de firmas de ataques, inteligencia de amenazas global y capacidades de prevención. Es una primera línea de defensa, no una fortaleza impenetrable.
Despliegue y Mantenimiento ✨
Una vez que tu script esté listo, guárdalo en un lugar seguro (por ejemplo, /usr/local/sbin/tu_ids_script.sh). Dale permisos de ejecución: chmod +x /usr/local/sbin/tu_ids_script.sh.
Para programar su ejecución, abre la tabla cron para el usuario root:
sudo crontab -e
Y añade una línea como esta para que se ejecute cada 10 minutos (ajusta la frecuencia según tus necesidades y recursos):
*/10 * * * * /usr/local/sbin/tu_ids_script.sh > /dev/null 2>&1
El > /dev/null 2>&1 redirige la salida estándar y de error para evitar correos electrónicos innecesarios de cron, ya que tu script ya gestiona sus propias alertas por email.
Recuerda que este es un proceso iterativo. Deberás revisar tus alertas, ajustar tu script, añadir nuevas reglas y actualizar tus líneas base a medida que tu sistema cambie. La ciberseguridad es un proceso vivo.
Una Opinión Basada en Datos Reales 💪
En el panorama actual de amenazas, donde los ataques de día cero y las APTs (Amenazas Persistentes Avanzadas) acaparan titulares, podríamos pensar que un simple script de Bash es insuficiente. Sin embargo, los datos nos cuentan una historia diferente. Según el Informe de Investigaciones de Filtraciones de Datos (DBIR) de Verizon, año tras año, una parte significativa de las brechas de seguridad todavía se origina en vectores de ataque fundamentales: abuso de credenciales, errores de configuración, uso indebido de privilegios y software vulnerable. Un HIDS basado en Bash, aunque rudimentario, es sorprendentemente eficaz para detectar muchos de estos vectores básicos.
No se trata de reemplazar soluciones empresariales, sino de complementar y fortalecer la postura de seguridad, especialmente para administradores de sistemas individuales o pequeñas infraestructuras con recursos limitados. Este tipo de herramientas personalizadas brindan una capa de visibilidad y control que es a menudo más valiosa que una caja negra compleja, porque se adapta a las particularidades de tu entorno y te obliga a entenderlo mejor.
Conclusión ✨
Felicidades, ¡has dado un gran paso hacia la independencia y el empoderamiento en tu seguridad digital! Has explorado cómo crear un script de detección de intrusos con Bash, una herramienta que, aunque sencilla, es poderosa y flexible. Hemos cubierto desde la monitorización de la integridad de archivos hasta la detección de inicios de sesión fallidos y procesos sospechosos.
Este no es el final de tu viaje, sino el emocionante comienzo. Te animo a que tomes este script como punto de partida, lo modifiques, lo expandas y lo adaptes a tus necesidades específicas. Experimenta con diferentes comandos, añade nuevas funciones y hazlo realmente tuyo. Al hacerlo, no solo estarás construyendo un guardián para tu sistema, sino que también estarás construyendo tu propio conocimiento y habilidades en el apasionante mundo de la ciberseguridad. ¡Adelante, el poder de Bash está en tus manos!