#!/bin/bash
# botnet_detector.sh - Script para detectar posibles indicios de botnet en sistemas Linux
# Blog: Emacs con Esteroides
# Autor: Emacs con Esteroides
# Fecha: 15/04/2025
# Licencia: GPL v3

# Colores para mejor visualización
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Función para imprimir encabezados
print_header() {
  echo -e "\n${BLUE}====================================${NC}"
  echo -e "${BLUE}$1${NC}"
  echo -e "${BLUE}====================================${NC}\n"
}

# Función para imprimir mensajes de alerta
print_alert() {
  echo -e "${RED}[ALERTA] $1${NC}"
}

# Función para imprimir mensajes de advertencia
print_warning() {
  echo -e "${YELLOW}[ADVERTENCIA] $1${NC}"
}

# Función para imprimir mensajes informativos
print_info() {
  echo -e "${GREEN}[INFO] $1${NC}"
}

# Verificar si se está ejecutando como root
if [ "$(id -u)" != "0" ]; then
  echo -e "${RED}Este script debe ejecutarse como root${NC}"
  exit 1
fi

# Crear directorio para informes si no existe
REPORT_DIR="/var/log/security_checks"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
REPORT_FILE="${REPORT_DIR}/botnet_check_${TIMESTAMP}.log"

if [ ! -d "$REPORT_DIR" ]; then
  mkdir -p "$REPORT_DIR"
fi

# Función para registrar en el archivo de informe
log() {
  echo "$1" >> "$REPORT_FILE"
  echo -e "$1"
}

# Redireccionar la salida al archivo de registro y a la consola
exec > >(tee -a "$REPORT_FILE") 2>&1

print_header "DETECTOR DE BOTNETS Y ACTIVIDAD MALICIOSA"
echo "Iniciando análisis: $(date)"
echo "Sistema: $(uname -a)"
echo "Usuario: $(whoami)"
echo "Informe guardado en: $REPORT_FILE"
echo

# Comprobar herramientas necesarias e instalarlas si faltan
check_tools() {
  print_header "Verificando herramientas necesarias"

  TOOLS=("lsof" "netstat" "tcpdump" "htop" "iftop" "rkhunter" "chkrootkit" "lynis" "clamav" "sysstat")
  PACKAGES=("lsof" "net-tools" "tcpdump" "htop" "iftop" "rkhunter" "chkrootkit" "lynis" "clamav" "sysstat")

  MISSING=()

  for i in "${!TOOLS[@]}"; do
    if ! command -v "${TOOLS[$i]}" &> /dev/null; then
      echo -e "${YELLOW}Herramienta ${TOOLS[$i]} no encontrada${NC}"
      MISSING+=("${PACKAGES[$i]}")
    else
      echo -e "${GREEN}✓ ${TOOLS[$i]} instalado${NC}"
    fi
  done

  if [ ${#MISSING[@]} -gt 0 ]; then
    echo -e "\n${YELLOW}Instalando herramientas faltantes...${NC}"
    apt-get update
    apt-get install -y "${MISSING[@]}"

    # Verificar si hubo algún error en la instalación
    if [ $? -ne 0 ]; then
      echo -e "${RED}Error al instalar algunas herramientas. El script puede no funcionar correctamente.${NC}"
    else
      echo -e "${GREEN}Todas las herramientas necesarias han sido instaladas.${NC}"
    fi
  else
    echo -e "${GREEN}Todas las herramientas necesarias están instaladas.${NC}"
  fi
}

# 1. Comprobar procesos sospechosos (alto uso de CPU/memoria)
check_suspicious_processes() {
  print_header "Comprobando procesos sospechosos"

  # Procesos con mayor consumo de CPU
  echo -e "${CYAN}Procesos con mayor consumo de CPU:${NC}"
  ps aux --sort=-%cpu | head -11

  # Procesos con mayor consumo de memoria
  echo -e "\n${CYAN}Procesos con mayor consumo de memoria:${NC}"
  ps aux --sort=-%mem | head -11

  # Buscar nombres de procesos sospechosos (mineros comunes, etc.)
  SUSPICIOUS_PROCESS_NAMES=("miner" "xmr" "monero" "cryptonight" "stratum" "coinhive" "xmrig" "cpuminer" "nanopool" "minergate")

  echo -e "\n${CYAN}Buscando procesos con nombres sospechosos:${NC}"
  FOUND=0
  for name in "${SUSPICIOUS_PROCESS_NAMES[@]}"; do
    RESULT=$(pgrep -l -f "$name")
    if [ -n "$RESULT" ]; then
      print_alert "Posible proceso de minería detectado: $RESULT"
      FOUND=1
    fi
  done

  if [ $FOUND -eq 0 ]; then
    print_info "No se encontraron procesos con nombres sospechosos."
  fi

  # Verificar procesos ocultos (con caracteres especiales o espacios en blanco)
  echo -e "\n${CYAN}Buscando procesos con nombres ocultos o sospechosos:${NC}"
  ps aux | grep -E '[ ]{2,}[^ ]+$|[.][^ ]|^ '

  # Procesos sin binarios en disco (posible indicación de malware en memoria)
  echo -e "\n${CYAN}Procesos sin binarios en disco (posible malware en memoria):${NC}"
  for pid in $(ls /proc/ | grep -E '^[0-9]+$'); do
    if [ -d "/proc/$pid" ]; then
      BINARY=$(ls -l /proc/$pid/exe 2>/dev/null | awk '{print $NF}')
      if [[ "$BINARY" == *"(deleted)"* || -z "$BINARY" ]]; then
        PROCESS_NAME=$(cat /proc/$pid/comm 2>/dev/null)
        CMDLINE=$(cat /proc/$pid/cmdline 2>/dev/null | tr '\0' ' ')
        if [ -n "$PROCESS_NAME" ] && [ "$PROCESS_NAME" != "ps" ] && [ "$PROCESS_NAME" != "grep" ]; then
          print_warning "Proceso sin binario en disco: PID=$pid NOMBRE=$PROCESS_NAME CMDLINE=$CMDLINE"
        fi
      fi
    fi
  done
}

# 2. Comprobar conexiones de red sospechosas
check_suspicious_connections() {
  print_header "Comprobando conexiones de red sospechosas"

  # Listar todas las conexiones
  echo -e "${CYAN}Todas las conexiones activas:${NC}"
  netstat -tunapl

  # Conexiones establecidas
  echo -e "\n${CYAN}Conexiones establecidas:${NC}"
  netstat -tunapl | grep ESTABLISHED

  # Puertos en escucha
  echo -e "\n${CYAN}Puertos en escucha:${NC}"
  netstat -tunapl | grep LISTEN

  # Puertos comúnmente asociados con botnets y malware
  SUSPICIOUS_PORTS=(4444 5555 6666 6667 6697 8080 9999 1080 11111 1337 31337 34567 65535)

  echo -e "\n${CYAN}Buscando puertos sospechosos:${NC}"
  FOUND=0
  for port in "${SUSPICIOUS_PORTS[@]}"; do
    RESULT=$(netstat -tunapl | grep ":$port ")
    if [ -n "$RESULT" ]; then
      print_alert "Puerto sospechoso $port en uso: $RESULT"
      FOUND=1
    fi
  done

  if [ $FOUND -eq 0 ]; then
    print_info "No se encontraron puertos sospechosos comunes en uso."
  fi

  # Comprobar conexiones a IPs sospechosas (servidores C&C conocidos)
  # Esta lista debería ser actualizada periódicamente con IPs conocidas de C&C
  echo -e "\n${CYAN}Comprobando conexiones a posibles servidores C&C:${NC}"

  # Ejemplo simple - en una implementación real, esta lista debería ser más extensa
  # y actualizada desde una fuente confiable
  SUSPICIOUS_IPS=("185.26.205." "91.121." "212.83." "88.208.")

  FOUND=0
  for ip_pattern in "${SUSPICIOUS_IPS[@]}"; do
    RESULT=$(netstat -tunapl | grep "$ip_pattern")
    if [ -n "$RESULT" ]; then
      print_alert "Conexión a posible servidor C&C detectada: $RESULT"
      FOUND=1
    fi
  done

  if [ $FOUND -eq 0 ]; then
    print_info "No se encontraron conexiones a servidores C&C conocidos."
  fi

  # Analizar cantidad de conexiones por IP
  echo -e "\n${CYAN}IPs con múltiples conexiones (posible comunicación con C&C):${NC}"
  netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -nr | head -n 10

  # Verificar conexiones salientes inusuales
  echo -e "\n${CYAN}Conexiones salientes posiblemente sospechosas:${NC}"
  OUTBOUND=$(netstat -tun | grep -v "127.0.0.1" | grep -v "LISTEN" | grep "ESTABLISHED")
  echo "$OUTBOUND"

  # Análisis de tráfico en tiempo real (muestra limitada)
  echo -e "\n${CYAN}Captura de tráfico en tiempo real (10 segundos):${NC}"
  timeout 10 tcpdump -nn -c 100 2>/dev/null || print_warning "No se pudo ejecutar tcpdump"
}

# 3. Comprobar archivos y directorios sospechosos
check_suspicious_files() {
  print_header "Comprobando archivos y directorios sospechosos"

  # Archivos modificados recientemente
  echo -e "${CYAN}Archivos del sistema modificados en las últimas 24 horas:${NC}"
  find /bin /usr/bin /sbin /usr/sbin -type f -mtime -1 -ls | grep -v "\.git"

  # Buscar archivos setuid/setgid (potencialmente peligrosos)
  echo -e "\n${CYAN}Archivos con permisos SUID/SGID (verificar si son legítimos):${NC}"
  find / -type f \( -perm -4000 -o -perm -2000 \) -ls 2>/dev/null | grep -v -E "/snap/|/var/lib/snapd/"

  # Buscar archivos ejecutables en /tmp y /var/tmp
  echo -e "\n${CYAN}Archivos ejecutables en directorios temporales:${NC}"
  find /tmp /var/tmp /dev/shm -type f -perm -100 -ls 2>/dev/null

  # Buscar scripts de inicio sospechosos
  echo -e "\n${CYAN}Scripts de inicio potencialmente sospechosos:${NC}"
  for dir in /etc/init.d /etc/init /etc/rc*.d /etc/systemd/system /usr/lib/systemd/system; do
    find "$dir" -type f -mtime -7 -ls 2>/dev/null
  done

  # Buscar archivos ocultos en el directorio home
  echo -e "\n${CYAN}Archivos ocultos recientes en directorios home:${NC}"
  find /home -type f -name ".*" -mtime -7 -ls 2>/dev/null | grep -v -E "\.cache|\.config|\.local|\.dbus|\.mozilla|\.bash_history"

  # Buscar archivos con nombres sospechosos
  echo -e "\n${CYAN}Archivos con nombres potencialmente sospechosos:${NC}"
  find / -type f -name "*backdoor*" -o -name "*rootkit*" -o -name "*trojan*" -o -name "*miner*" -o -name "*xmr*" -o -name "*monero*" 2>/dev/null
}

# 4. Comprobar tareas programadas
check_scheduled_tasks() {
  print_header "Comprobando tareas programadas"

  # Crontabs del sistema
  echo -e "${CYAN}Crontabs del sistema:${NC}"
  for user in $(cut -f1 -d: /etc/passwd); do
    crontab -l -u "$user" 2>/dev/null
    if [ $? -eq 0 ]; then
      echo -e "Crontab del usuario $user:"
      crontab -l -u "$user"
      echo
    fi
  done

  # Otros archivos cron
  echo -e "\n${CYAN}Otros archivos cron:${NC}"
  for dir in /etc/cron.d /etc/cron.daily /etc/cron.hourly /etc/cron.monthly /etc/cron.weekly; do
    echo -e "Contenido de $dir:"
    ls -la "$dir" 2>/dev/null
    echo
  done

  # Comprobar /etc/crontab
  echo -e "\n${CYAN}Contenido de /etc/crontab:${NC}"
  cat /etc/crontab

  # Comprobar systemd timers
  echo -e "\n${CYAN}Systemd timers:${NC}"
  systemctl list-timers --all
}

# 5. Comprobar usuarios y permisos
check_users_and_permissions() {
  print_header "Comprobando usuarios y permisos"

  # Listar usuarios
  echo -e "${CYAN}Lista de usuarios en el sistema:${NC}"
  cut -d: -f1,3,7 /etc/passwd | sort

  # Usuarios con UID 0 (root)
  echo -e "\n${CYAN}Usuarios con privilegios de root (UID 0):${NC}"
  grep ":0:" /etc/passwd

  # Usuarios que pueden usar sudo
  echo -e "\n${CYAN}Usuarios que pueden usar sudo:${NC}"
  grep -Po '^sudo.+:\K.*$' /etc/group
  cat /etc/sudoers.d/* /etc/sudoers 2>/dev/null | grep -v "^#" | grep -v "^$"

  # Últimos inicios de sesión
  echo -e "\n${CYAN}Últimos inicios de sesión:${NC}"
  last | head -20

  # Sesiones activas
  echo -e "\n${CYAN}Sesiones activas:${NC}"
  w
  who

  # Comprobar usuarios conectados por SSH
  echo -e "\n${CYAN}Usuarios conectados por SSH:${NC}"
  netstat -tnpa | grep "ESTABLISHED.*sshd"

  # Archivos de autorización SSH
  echo -e "\n${CYAN}Archivos authorized_keys (verificar claves no autorizadas):${NC}"
  find /home -name "authorized_keys" -exec ls -la {} \; -exec cat {} \; 2>/dev/null
  find /root -name "authorized_keys" -exec ls -la {} \; -exec cat {} \; 2>/dev/null
}

# 6. Comprobar servicios y daemons
check_services() {
  print_header "Comprobando servicios y daemons"

  # Servicios activos
  echo -e "${CYAN}Servicios systemd activos:${NC}"
  systemctl list-units --type=service --state=running

  # Todos los servicios
  echo -e "\n${CYAN}Todos los servicios systemd:${NC}"
  systemctl list-unit-files --type=service

  # Servicios iniciados recientemente
  echo -e "\n${CYAN}Servicios iniciados en los últimos 3 días:${NC}"
  find /etc/systemd/system /usr/lib/systemd/system -type f -name "*.service" -mtime -3 -ls

  # Servicios no estándar
  echo -e "\n${CYAN}Servicios potencialmente no estándar:${NC}"
  systemctl list-units --type=service | grep -v -E "systemd|dbus|getty|ssh|network|ifup|rpc|nfs|syslog|cron|anacron|atd|udev|acpid|rsyslog|logind|getty|apache|nginx|mariadb|mysql|postgresql"
}

# 7. Realizar escaneos con herramientas de seguridad
security_scans() {
  print_header "Ejecutando escaneos de seguridad"

  # Ejecutar rkhunter para buscar rootkits
  if command -v rkhunter &> /dev/null; then
    echo -e "${CYAN}Ejecutando rkhunter (escaneo de rootkits):${NC}"
    rkhunter --check --sk || print_warning "rkhunter falló o encontró problemas"
  else
    print_warning "rkhunter no está instalado"
  fi

  # Ejecutar chkrootkit
  if command -v chkrootkit &> /dev/null; then
    echo -e "\n${CYAN}Ejecutando chkrootkit:${NC}"
    chkrootkit -q || print_warning "chkrootkit falló o encontró problemas"
  else
    print_warning "chkrootkit no está instalado"
  fi

  # Ejecutar lynis para auditoría de seguridad
  if command -v lynis &> /dev/null; then
    echo -e "\n${CYAN}Ejecutando lynis (auditoría básica):${NC}"
    lynis audit system --quick || print_warning "lynis falló o encontró problemas"
  else
    print_warning "lynis no está instalado"
  fi

  # Ejecutar ClamAV para buscar malware
  if command -v clamscan &> /dev/null; then
    echo -e "\n${CYAN}Ejecutando ClamAV en directorios críticos:${NC}"
    clamscan --recursive --suppress-ok-results /etc /tmp /var/tmp /home/*/.ssh /root || print_warning "clamscan falló o encontró problemas"
  else
    print_warning "ClamAV no está instalado"
  fi
}

# 8. Comprobar registros del sistema
check_logs() {
  print_header "Analizando registros del sistema"

  # Verificar intentos de inicio de sesión fallidos
  echo -e "${CYAN}Intentos de inicio de sesión fallidos:${NC}"
  grep "Failed password" /var/log/auth.log* | tail -n 20

  # Comprobación de conexiones rechazadas
  echo -e "\n${CYAN}Conexiones rechazadas:${NC}"
  grep -i "connection refused\|failed to connect" /var/log/syslog* | tail -n 20

  # Mensajes de error críticos
  echo -e "\n${CYAN}Mensajes de error críticos:${NC}"
  grep -i "error\|critical\|warning\|fail" /var/log/syslog* | tail -n 50

  # Buscar IPs que intentan múltiples inicios de sesión
  echo -e "\n${CYAN}IPs con múltiples intentos de inicio de sesión:${NC}"
  grep "Failed password" /var/log/auth.log* | grep -E -o "([0-9]{1,3}[\.]){3}[0-9]{1,3}" | sort | uniq -c | sort -nr | head -n 10
}

# 9. Comprobar volumen de tráfico de red
check_network_traffic() {
  print_header "Analizando tráfico de red"

  # Estadísticas de uso de red
  if command -v vnstat &> /dev/null; then
    echo -e "${CYAN}Estadísticas de tráfico de red:${NC}"
    vnstat
  else
    echo -e "${CYAN}Estadísticas de interfaces de red:${NC}"
    ip -s link
  fi

  # Mostrar tabla de rutas
  echo -e "\n${CYAN}Tabla de rutas:${NC}"
  ip route

  # Mostrar puertos abiertos
  echo -e "\n${CYAN}Puertos abiertos:${NC}"
  ss -tuln

  # Capturar y analizar una muestra de tráfico
  echo -e "\n${CYAN}Análisis de muestra de tráfico (5 segundos):${NC}"
  timeout 5 tcpdump -nn -q -i any 2>/dev/null || print_warning "No se pudo ejecutar tcpdump"
}

# 10. Comprobación del rendimiento del sistema
check_system_performance() {
  print_header "Analizando rendimiento del sistema"

  # Uso de CPU y memoria
  echo -e "${CYAN}Uso de CPU y memoria:${NC}"
  top -bn 1 | head -20

  # Comprobación de la carga del sistema
  echo -e "\n${CYAN}Carga del sistema:${NC}"
  uptime

  # Uso de disco
  echo -e "\n${CYAN}Uso de disco:${NC}"
  df -h

  # Directorios que ocupan más espacio
  echo -e "\n${CYAN}Directorios que ocupan más espacio:${NC}"
  du -sh /* 2>/dev/null | sort -hr | head -10

  # Comprobar swap
  echo -e "\n${CYAN}Uso de swap:${NC}"
  free -h
  swapon --show

  # Comprobar si hay procesos zombies
  echo -e "\n${CYAN}Procesos zombie:${NC}"
  ps aux | awk '$8=="Z"'
}

# 11. Generar resumen e informe final
generate_summary() {
  print_header "RESUMEN DE LA DETECCIÓN"

  # Comprobar indicadores clave de compromiso
  echo -e "${CYAN}Indicadores clave revisados:${NC}"

  # 1. Procesos sospechosos
  SUSPICIOUS_PROCS=$(ps aux | grep -E 'miner|xmr|monero|cryptonight|stratum' | grep -v grep | wc -l)
  if [ "$SUSPICIOUS_PROCS" -gt 0 ]; then
    print_alert "⚠️ Se encontraron $SUSPICIOUS_PROCS procesos con nombres sospechosos"
  else
    print_info "✓ No se encontraron procesos con nombres asociados a minería/botnet"
  fi

  # 2. Puertos sospechosos
  SUSPICIOUS_PORTS_COUNT=$(netstat -tunapl 2>/dev/null | grep -E ':(4444|5555|6666|6667|8080|9999|1080|1337|31337)' | grep -v "127.0.0.1" | wc -l)
  if [ "$SUSPICIOUS_PORTS_COUNT" -gt 0 ]; then
    print_alert "⚠️ Se encontraron $SUSPICIOUS_PORTS_COUNT puertos sospechosos en uso"
  else
    print_info "✓ No se encontraron puertos comúnmente asociados con malware"
  fi

  # 3. Archivos sospechosos
  SUSPICIOUS_FILES=$(find /tmp /var/tmp /dev/shm -type f -perm -100 2>/dev/null | wc -l)
  if [ "$SUSPICIOUS_FILES" -gt 3 ]; then
    print_warning "⚠️ Se encontraron $SUSPICIOUS_FILES archivos ejecutables en directorios temporales"
  else
    print_info "✓ Número normal de ejecutables en directorios temporales"
  fi

  # 4. Tareas cron sospechosas
  SUSPICIOUS_CRON=$(grep -r "curl\|wget\|nc\|netcat\|bash -i\|python -c\|perl -e" /etc/cron* /var/spool/cron/ 2>/dev/null | wc -l)
  if [ "$SUSPICIOUS_CRON" -gt 0 ]; then
    print_alert "⚠️ Se encontraron $SUSPICIOUS_CRON tareas cron potencialmente sospechosas"
  else
    print_info "✓ No se encontraron tareas cron sospechosas"
  fi

  # 5. Usuarios con UID 0 distintos de root
  ROOT_USERS=$(grep ":0:" /etc/passwd | grep -v "^root:" | wc -l)
  if [ "$ROOT_USERS" -gt 0 ]; then
    print_alert "⚠️ Se encontraron $ROOT_USERS usuarios adicionales con privilegios de root (UID 0)"
  else
    print_info "✓ Solo el usuario root tiene UID 0"
  fi

  # Evaluación final
  echo -e "\n${BLUE}EVALUACIÓN FINAL:${NC}"

  TOTAL_ALERTS=$(grep -c "\[ALERTA\]" "$REPORT_FILE")
  TOTAL_WARNINGS=$(grep -c "\[ADVERTENCIA\]" "$REPORT_FILE")

  if [ "$TOTAL_ALERTS" -gt 0 ]; then
    echo -e "${RED}⚠️ Se encontraron $TOTAL_ALERTS alertas y $TOTAL_WARNINGS advertencias que requieren investigación inmediata.${NC}"
    echo -e "${RED}El sistema podría estar comprometido. Revise el informe completo y tome medidas.${NC}"
  elif [ "$TOTAL_WARNINGS" -gt 3 ]; then
    echo -e "${YELLOW}⚠️ Se encontraron $TOTAL_WARNINGS advertencias que requieren atención.${NC}"
    echo -e "${YELLOW}El sistema podría tener actividad sospechosa. Revise el informe completo.${NC}"
  else
    echo -e "${GREEN}✓ No se encontraron indicios claros de compromiso en el sistema.${NC}"
    echo -e "${GREEN}Continúe monitoreando regularmente.${NC}"
  fi

  # Recomendaciones
  echo -e "\n${CYAN}RECOMENDACIONES:${NC}"
  echo -e "1. Ejecute este script periódicamente para monitorear cambios"
  echo -e "2. Configure un sistema de monitoreo de integridad (como AIDE o Tripwire)"
  echo -e "3. Actualice regularmente el sistema y las aplicaciones"
  echo -e "4. Configure correctamente el firewall"
  echo -e "5. Implemente detección de intrusiones con herramientas como Snort o Suricata"
  echo -e "6. Siga las prácticas recomendadas de seguridad para servidores Linux"

  echo -e "\n${BLUE}Informe completo guardado en: $REPORT_FILE${NC}"
}

# Ejecutar todas las comprobaciones
main() {
  check_tools
  check_suspicious_processes
  check_suspicious_connections
  check_suspicious_files
  check_scheduled_tasks
  check_users_and_permissions
  check_services
  security_scans
  check_logs
  check_network_traffic
  check_system_performance
  generate_summary

  print_header "FINALIZADO"
  echo "Análisis completado: $(date)"
  echo "Informe guardado en: $REPORT_FILE"
}

# Ejecutar el script principal
main