26/05/2025

Scripts de Ciberseguridad en Bash Linux

1. Introducción

Esta guía presenta los 3 scripts de ciberseguridad más útiles para administradores de sistemas Linux, diseñados para automatizar tareas críticas de seguridad, monitoreo y análisis de amenazas.

1.1. Requisitos Previos

Sistema Linux (Ubuntu, CentOS, RHEL, Debian)
Bash 4.0 o superior
Permisos de root para algunas funcionalidades
Herramientas básicas: grep, awk, sed, netstat, ss

2. Script 1: Monitor de Seguridad del Sistema

2.1. Descripción

Script completo para monitorear actividades sospechosas en el sistema, detectar intentos de intrusión y generar alertas automáticas.

2.2. Tags: `monitoring` `intrusion-detection` `system-security`

2.3. Código del Script

#!/bin/bash
# security_monitor.sh - Monitor de Seguridad del Sistema
# Autor: Admin de Seguridad
# Versión: 2.1
# Descripción: Monitorea actividades sospechosas y genera alertas

# Configuración
LOG_FILE="/var/log/security_monitor.log"
ALERT_EMAIL="admin@empresa.com"
MAX_FAILED_LOGINS=5
SUSPICIOUS_PROCESSES=("nc" "nmap" "metasploit" "sqlmap")
ALERT_THRESHOLD=10

# Función de logging
log_event() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
}

# Función para enviar alertas
send_alert() {
    local message="$1"
    log_event "ALERT: $message"
    echo "$message" | mail -s "Alerta de Seguridad - $(hostname)" "$ALERT_EMAIL" 2>/dev/null
}

# Verificar intentos de login fallidos
check_failed_logins() {
    local failed_count
    failed_count=$(grep "Failed password" /var/log/auth.log 2>/dev/null | 
                   grep "$(date '+%b %d')" | wc -l)

    if [ "$failed_count" -gt "$MAX_FAILED_LOGINS" ]; then
        send_alert "CRÍTICO: $failed_count intentos de login fallidos detectados hoy"

        # Obtener IPs con más intentos
        grep "Failed password" /var/log/auth.log 2>/dev/null | 
        grep "$(date '+%b %d')" | 
        awk '{print $(NF-3)}' | sort | uniq -c | sort -nr | head -5 >> "$LOG_FILE"
    fi
}

# Verificar conexiones de red sospechosas
check_network_connections() {
    local suspicious_connections
    suspicious_connections=$(ss -tuln | grep -E ':22|:80|:443|:3389|:5432|:3306' | 
                           grep -v '127.0.0.1\|::1' | wc -l)

    if [ "$suspicious_connections" -gt "$ALERT_THRESHOLD" ]; then
        send_alert "ADVERTENCIA: $suspicious_connections conexiones externas activas"
        ss -tuln | grep -v '127.0.0.1\|::1' >> "$LOG_FILE"
    fi
}

# Verificar procesos sospechosos
check_suspicious_processes() {
    for process in "${SUSPICIOUS_PROCESSES[@]}"; do
        if pgrep -f "$process" > /dev/null; then
            send_alert "CRÍTICO: Proceso sospechoso detectado: $process"
            ps aux | grep "$process" | grep -v grep >> "$LOG_FILE"
        fi
    done
}

# Verificar cambios en archivos críticos
check_system_files() {
    local critical_files=("/etc/passwd" "/etc/shadow" "/etc/sudoers" "/etc/hosts")

    for file in "${critical_files[@]}"; do
        if [ -f "$file" ]; then
            local current_hash
            current_hash=$(md5sum "$file" | cut -d' ' -f1)
            local stored_hash_file="/tmp/$(basename "$file").hash"

            if [ -f "$stored_hash_file" ]; then
                local stored_hash
                stored_hash=$(cat "$stored_hash_file")
                if [ "$current_hash" != "$stored_hash" ]; then
                    send_alert "CRÍTICO: Archivo crítico modificado: $file"
                fi
            fi
            echo "$current_hash" > "$stored_hash_file"
        fi
    done
}

# Verificar uso de recursos
check_resource_usage() {
    local cpu_usage
    local memory_usage
    local disk_usage

    cpu_usage=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1 | cut -d',' -f1)
    memory_usage=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')
    disk_usage=$(df / | tail -1 | awk '{print $5}' | cut -d'%' -f1)

    if (( $(echo "$cpu_usage > 90" | bc -l) )); then
        send_alert "ADVERTENCIA: Uso de CPU elevado: ${cpu_usage}%"
    fi

    if (( $(echo "$memory_usage > 90" | bc -l) )); then
        send_alert "ADVERTENCIA: Uso de memoria elevado: ${memory_usage}%"
    fi

    if [ "$disk_usage" -gt 90 ]; then
        send_alert "ADVERTENCIA: Uso de disco elevado: ${disk_usage}%"
    fi
}

# Función principal
main() {
    log_event "Iniciando monitoreo de seguridad"

    check_failed_logins
    check_network_connections
    check_suspicious_processes
    check_system_files
    check_resource_usage

    log_event "Monitoreo completado"
}

# Verificar si se ejecuta como root
if [ "$EUID" -ne 0 ]; then
    echo "Este script debe ejecutarse como root"
    exit 1
fi

# Crear directorio de logs si no existe
mkdir -p "$(dirname "$LOG_FILE")"

# Ejecutar función principal
main "$@"

2.4. Instalación y Configuración

2.4.1. Paso 1: Preparar el script

# Crear el archivo del script
sudo nano /usr/local/bin/security_monitor.sh

# Copiar el código anterior y guardar

# Hacer ejecutable
sudo chmod +x /usr/local/bin/security_monitor.sh

2.4.2. Paso 2: Configurar cron para ejecución automática

# Editar crontab
sudo crontab -e

# Agregar línea para ejecutar cada 15 minutos
*/15 * * * * /usr/local/bin/security_monitor.sh

2.4.3. Paso 3: Configurar alertas por email (opcional)

# Instalar mailutils
sudo apt-get install mailutils

# Configurar postfix o sendmail según necesidades

2.5. Ejemplos de Uso

2.5.1. Ejecución manual

sudo /usr/local/bin/security_monitor.sh

2.5.2. Revisar logs

sudo tail -f /var/log/security_monitor.log

3. Script 2: Analizador de Logs de Seguridad

3.1. Descripción

Script avanzado para analizar logs del sistema en busca de patrones de ataque, generar reportes y identificar amenazas.

3.2. Tags: `log-analysis` `forensics` `threat-detection`

3.3. Código del Script

#!/bin/bash
# log_analyzer.sh - Analizador de Logs de Seguridad
# Autor: Security Team
# Versión: 1.8
# Descripción: Analiza logs del sistema para detectar amenazas

# Configuración
REPORT_DIR="/var/log/security_reports"
DATE_PATTERN=$(date '+%Y-%m-%d')
LOG_FILES=("/var/log/auth.log" "/var/log/syslog" "/var/log/apache2/access.log" "/var/log/nginx/access.log")

# Patrones de ataque conocidos
declare -A ATTACK_PATTERNS=(
    ["SQL_INJECTION"]="union.*select|drop.*table|exec.*sp_|script.*alert"
    ["XSS"]="<script|javascript:|onload=|onerror="
    ["PATH_TRAVERSAL"]="\.\.\/|\.\.\\|directory.*traversal"
    ["BRUTE_FORCE"]="Failed password|authentication failure|invalid user"
    ["PORT_SCAN"]="nmap|port.*scan|stealth.*scan"
    ["PRIVILEGE_ESCALATION"]="sudo.*su|privilege.*escalation|root.*access"
)

# Función para crear reportes
create_report_header() {
    local report_file="$1"
    cat > "$report_file" << EOF
===========================================
REPORTE DE ANÁLISIS DE SEGURIDAD
===========================================
Fecha: $(date)
Hostname: $(hostname)
Sistema: $(uname -a)
===========================================

EOF
}

# Análisis de intentos de autenticación
analyze_auth_attempts() {
    local report_file="$1"

    echo "ANÁLISIS DE AUTENTICACIÓN" >> "$report_file"
    echo "=========================" >> "$report_file"

    # Intentos fallidos por IP
    echo "Top 10 IPs con intentos fallidos:" >> "$report_file"
    grep "Failed password" /var/log/auth.log 2>/dev/null | 
    awk '{print $(NF-3)}' | sort | uniq -c | sort -nr | head -10 >> "$report_file"

    echo "" >> "$report_file"

    # Usuarios más atacados
    echo "Usuarios más atacados:" >> "$report_file"
    grep "Failed password" /var/log/auth.log 2>/dev/null | 
    awk '{print $9}' | sort | uniq -c | sort -nr | head -10 >> "$report_file"

    echo "" >> "$report_file"

    # Logins exitosos sospechosos (fuera de horario)
    echo "Logins exitosos fuera de horario (22:00-06:00):" >> "$report_file"
    grep "Accepted" /var/log/auth.log 2>/dev/null | 
    awk '$3 ~ /^(2[2-3]|0[0-6]):/ {print}' >> "$report_file"

    echo "" >> "$report_file"
}

# Análisis de patrones de ataque
analyze_attack_patterns() {
    local report_file="$1"

    echo "ANÁLISIS DE PATRONES DE ATAQUE" >> "$report_file"
    echo "==============================" >> "$report_file"

    for attack_type in "${!ATTACK_PATTERNS[@]}"; do
        local pattern="${ATTACK_PATTERNS[$attack_type]}"
        local count=0

        echo "Analizando: $attack_type" >> "$report_file"

        for log_file in "${LOG_FILES[@]}"; do
            if [ -f "$log_file" ]; then
                local matches
                matches=$(grep -iE "$pattern" "$log_file" 2>/dev/null)
                if [ -n "$matches" ]; then
                    local match_count
                    match_count=$(echo "$matches" | wc -l)
                    count=$((count + match_count))

                    echo "  Archivo: $log_file - Coincidencias: $match_count" >> "$report_file"
                    echo "$matches" | head -5 >> "$report_file"
                fi
            fi
        done

        echo "  Total de coincidencias para $attack_type: $count" >> "$report_file"
        echo "" >> "$report_file"
    done
}

# Análisis de conexiones de red
analyze_network_activity() {
    local report_file="$1"

    echo "ANÁLISIS DE ACTIVIDAD DE RED" >> "$report_file"
    echo "============================" >> "$report_file"

    # Conexiones establecidas
    echo "Conexiones activas:" >> "$report_file"
    ss -tuln | grep ESTAB >> "$report_file"

    echo "" >> "$report_file"

    # Puertos en escucha
    echo "Puertos en escucha:" >> "$report_file"
    ss -tuln | grep LISTEN >> "$report_file"

    echo "" >> "$report_file"

    # Análisis de logs de firewall
    if [ -f "/var/log/ufw.log" ]; then
        echo "Actividad del firewall (últimos bloqueos):" >> "$report_file"
        grep "BLOCK" /var/log/ufw.log | tail -20 >> "$report_file"
    fi

    echo "" >> "$report_file"
}

# Análisis de cambios en el sistema
analyze_system_changes() {
    local report_file="$1"

    echo "ANÁLISIS DE CAMBIOS DEL SISTEMA" >> "$report_file"
    echo "===============================" >> "$report_file"

    # Nuevos usuarios
    echo "Usuarios creados recientemente:" >> "$report_file"
    grep "useradd" /var/log/auth.log 2>/dev/null | tail -10 >> "$report_file"

    echo "" >> "$report_file"

    # Cambios de contraseña
    echo "Cambios de contraseña recientes:" >> "$report_file"
    grep "password changed" /var/log/auth.log 2>/dev/null | tail -10 >> "$report_file"

    echo "" >> "$report_file"

    # Comandos sudo ejecutados
    echo "Comandos sudo ejecutados (últimos 20):" >> "$report_file"
    grep "sudo:" /var/log/auth.log 2>/dev/null | tail -20 >> "$report_file"

    echo "" >> "$report_file"
}

# Generar resumen ejecutivo
generate_executive_summary() {
    local report_file="$1"

    echo "RESUMEN EJECUTIVO" >> "$report_file"
    echo "=================" >> "$report_file"

    local failed_logins
    local successful_logins
    local sudo_commands
    local firewall_blocks

    failed_logins=$(grep -c "Failed password" /var/log/auth.log 2>/dev/null || echo "0")
    successful_logins=$(grep -c "Accepted" /var/log/auth.log 2>/dev/null || echo "0")
    sudo_commands=$(grep -c "sudo:" /var/log/auth.log 2>/dev/null || echo "0")
    firewall_blocks=$(grep -c "BLOCK" /var/log/ufw.log 2>/dev/null || echo "0")

    echo "Estadísticas del día:" >> "$report_file"
    echo "- Intentos de login fallidos: $failed_logins" >> "$report_file"
    echo "- Logins exitosos: $successful_logins" >> "$report_file"
    echo "- Comandos sudo ejecutados: $sudo_commands" >> "$report_file"
    echo "- Conexiones bloqueadas por firewall: $firewall_blocks" >> "$report_file"

    # Nivel de riesgo
    local risk_level="BAJO"
    if [ "$failed_logins" -gt 100 ]; then
        risk_level="ALTO"
    elif [ "$failed_logins" -gt 50 ]; then
        risk_level="MEDIO"
    fi

    echo "- Nivel de riesgo estimado: $risk_level" >> "$report_file"
    echo "" >> "$report_file"
}

# Función principal
main() {
    local report_file="$REPORT_DIR/security_report_$DATE_PATTERN.txt"

    # Crear directorio de reportes
    mkdir -p "$REPORT_DIR"

    # Crear reporte
    create_report_header "$report_file"
    generate_executive_summary "$report_file"
    analyze_auth_attempts "$report_file"
    analyze_attack_patterns "$report_file"
    analyze_network_activity "$report_file"
    analyze_system_changes "$report_file"

    echo "Reporte generado: $report_file"

    # Mostrar resumen en pantalla
    echo "=== RESUMEN ==="
    grep -A 10 "RESUMEN EJECUTIVO" "$report_file" | tail -8
}

# Verificar permisos
if [ "$EUID" -ne 0 ]; then
    echo "Se recomienda ejecutar como root para acceso completo a logs"
fi

# Ejecutar
main "$@"

3.4. Instalación y Uso

3.4.1. Instalación

# Crear el script
sudo nano /usr/local/bin/log_analyzer.sh

# Hacer ejecutable
sudo chmod +x /usr/local/bin/log_analyzer.sh

# Crear directorio de reportes
sudo mkdir -p /var/log/security_reports

3.4.2. Uso básico

# Ejecutar análisis
sudo /usr/local/bin/log_analyzer.sh

# Ver el reporte generado
sudo cat /var/log/security_reports/security_report_$(date +%Y-%m-%d).txt

3.4.3. Automatización

# Agregar a cron para ejecución diaria
echo "0 6 * * * /usr/local/bin/log_analyzer.sh" | sudo crontab -

4. Script 3: Escáner de Vulnerabilidades del Sistema

4.1. Descripción

Script comprehensivo para escanear el sistema en busca de vulnerabilidades comunes, configuraciones inseguras y problemas de seguridad.

4.2. Tags: `vulnerability-scanner` `security-audit` `system-hardening`

4.3. Código del Script

#!/bin/bash
# vuln_scanner.sh - Escáner de Vulnerabilidades del Sistema
# Autor: Security Audit Team
# Versión: 2.3
# Descripción: Escanea vulnerabilidades y configuraciones inseguras

# Configuración
REPORT_FILE="/tmp/vulnerability_scan_$(date +%Y%m%d_%H%M%S).txt"
CRITICAL_COUNT=0
HIGH_COUNT=0
MEDIUM_COUNT=0
LOW_COUNT=0

# Colores para output
RED='\033[0;31m'
YELLOW='\033[1;33m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Función para logging con niveles
log_vulnerability() {
    local level="$1"
    local description="$2"
    local details="$3"

    case $level in
        "CRITICAL")
            echo -e "${RED}[CRÍTICO]${NC} $description" | tee -a "$REPORT_FILE"
            ((CRITICAL_COUNT++))
            ;;
        "HIGH")
            echo -e "${RED}[ALTO]${NC} $description" | tee -a "$REPORT_FILE"
            ((HIGH_COUNT++))
            ;;
        "MEDIUM")
            echo -e "${YELLOW}[MEDIO]${NC} $description" | tee -a "$REPORT_FILE"
            ((MEDIUM_COUNT++))
            ;;
        "LOW")
            echo -e "${BLUE}[BAJO]${NC} $description" | tee -a "$REPORT_FILE"
            ((LOW_COUNT++))
            ;;
    esac

    if [ -n "$details" ]; then
        echo "    Detalles: $details" >> "$REPORT_FILE"
    fi
    echo "" >> "$REPORT_FILE"
}

# Verificar configuración de SSH
check_ssh_config() {
    echo -e "${GREEN}Verificando configuración SSH...${NC}"

    if [ -f "/etc/ssh/sshd_config" ]; then
        # Verificar root login
        if grep -q "^PermitRootLogin yes" /etc/ssh/sshd_config; then
            log_vulnerability "HIGH" "SSH permite login directo como root" \
                "Cambiar 'PermitRootLogin' a 'no' en /etc/ssh/sshd_config"
        fi

        # Verificar autenticación por contraseña
        if grep -q "^PasswordAuthentication yes" /etc/ssh/sshd_config; then
            log_vulnerability "MEDIUM" "SSH permite autenticación por contraseña" \
                "Considerar usar solo autenticación por clave pública"
        fi

        # Verificar protocolo SSH
        if ! grep -q "^Protocol 2" /etc/ssh/sshd_config; then
            log_vulnerability "HIGH" "SSH no está configurado específicamente para protocolo 2" \
                "Agregar 'Protocol 2' en /etc/ssh/sshd_config"
        fi

        # Verificar puerto por defecto
        if grep -q "^Port 22" /etc/ssh/sshd_config || ! grep -q "^Port" /etc/ssh/sshd_config; then
            log_vulnerability "LOW" "SSH usando puerto por defecto (22)" \
                "Considerar cambiar el puerto SSH"
        fi
    else
        log_vulnerability "LOW" "Archivo de configuración SSH no encontrado" ""
    fi
}

# Verificar usuarios y permisos
check_users_permissions() {
    echo -e "${GREEN}Verificando usuarios y permisos...${NC}"

    # Usuarios con UID 0
    local root_users
    root_users=$(awk -F: '$3 == 0 {print $1}' /etc/passwd | grep -v "^root$")
    if [ -n "$root_users" ]; then
        log_vulnerability "CRITICAL" "Usuarios adicionales con UID 0 detectados" \
            "Usuarios: $root_users"
    fi

    # Usuarios sin contraseña
    local no_passwd_users
    no_passwd_users=$(awk -F: '$2 == "" {print $1}' /etc/shadow 2>/dev/null)
    if [ -n "$no_passwd_users" ]; then
        log_vulnerability "CRITICAL" "Usuarios sin contraseña detectados" \
            "Usuarios: $no_passwd_users"
    fi

    # Archivos con permisos 777
    local world_writable
    world_writable=$(find /etc /bin /sbin /usr/bin /usr/sbin -type f -perm -002 2>/dev/null | head -10)
    if [ -n "$world_writable" ]; then
        log_vulnerability "HIGH" "Archivos críticos con permisos de escritura mundial" \
            "$(echo "$world_writable" | tr '\n' ' ')"
    fi

    # Verificar sudo sin contraseña
    if grep -q "NOPASSWD" /etc/sudoers 2>/dev/null; then
        log_vulnerability "MEDIUM" "Configuración sudo sin contraseña detectada" \
            "Revisar configuración en /etc/sudoers"
    fi
}

# Verificar servicios y puertos
check_services_ports() {
    echo -e "${GREEN}Verificando servicios y puertos...${NC}"

    # Servicios innecesarios comunes
    local unnecessary_services=("telnet" "rsh" "rlogin" "ftp" "tftp")

    for service in "${unnecessary_services[@]}"; do
        if systemctl is-active --quiet "$service" 2>/dev/null; then
            log_vulnerability "HIGH" "Servicio inseguro activo: $service" \
                "Considerar deshabilitar con: systemctl disable $service"
        fi
    done

    # Puertos abiertos sospechosos
    local open_ports
    open_ports=$(ss -tuln | grep LISTEN | awk '{print $5}' | cut -d: -f2 | sort -n | uniq)

    for port in $open_ports; do
        case $port in
            23) log_vulnerability "HIGH" "Puerto Telnet (23) abierto" "Servicio inseguro" ;;
            69) log_vulnerability "HIGH" "Puerto TFTP (69) abierto" "Servicio inseguro" ;;
            135|139|445) log_vulnerability "MEDIUM" "Puerto SMB/NetBIOS ($port) abierto" "Revisar necesidad" ;;
            1433|3306|5432) log_vulnerability "MEDIUM" "Puerto de base de datos ($port) abierto" "Verificar acceso remoto" ;;
        esac
    done
}

# Verificar actualizaciones del sistema
check_system_updates() {
    echo -e "${GREEN}Verificando actualizaciones del sistema...${NC}"

    if command -v apt &> /dev/null; then
        # Debian/Ubuntu
        apt list --upgradable 2>/dev/null | grep -c "upgradable" > /tmp/update_count
        local update_count
        update_count=$(cat /tmp/update_count)

        if [ "$update_count" -gt 50 ]; then
            log_vulnerability "HIGH" "$update_count actualizaciones pendientes" \
                "Ejecutar: apt update && apt upgrade"
        elif [ "$update_count" -gt 10 ]; then
            log_vulnerability "MEDIUM" "$update_count actualizaciones pendientes" \
                "Ejecutar: apt update && apt upgrade"
        fi

        # Verificar actualizaciones de seguridad
        local security_updates
        security_updates=$(apt list --upgradable 2>/dev/null | grep -i security | wc -l)
        if [ "$security_updates" -gt 0 ]; then
            log_vulnerability "HIGH" "$security_updates actualizaciones de seguridad pendientes" \
                "Instalar inmediatamente"
        fi

    elif command -v yum &> /dev/null; then
        # CentOS/RHEL
        local update_count
        update_count=$(yum check-update 2>/dev/null | grep -c "updates")

        if [ "$update_count" -gt 50 ]; then
            log_vulnerability "HIGH" "$update_count actualizaciones pendientes" \
                "Ejecutar: yum update"
        elif [ "$update_count" -gt 10 ]; then
            log_vulnerability "MEDIUM" "$update_count actualizaciones pendientes" \
                "Ejecutar: yum update"
        fi
    fi
}

# Verificar configuración del firewall
check_firewall_config() {
    echo -e "${GREEN}Verificando configuración del firewall...${NC}"

    # UFW
    if command -v ufw &> /dev/null; then
        local ufw_status
        ufw_status=$(ufw status | grep "Status:" | awk '{print $2}')

        if [ "$ufw_status" = "inactive" ]; then
            log_vulnerability "HIGH" "Firewall UFW desactivado" \
                "Activar con: ufw enable"
        fi
    fi

    # iptables
    local iptables_rules
    iptables_rules=$(iptables -L | grep -c "Chain")

    if [ "$iptables_rules" -lt 3 ]; then
        log_vulnerability "MEDIUM" "Reglas de iptables mínimas o inexistentes" \
            "Configurar reglas de firewall apropiadas"
    fi

    # Verificar políticas por defecto
    local default_policy
    default_policy=$(iptables -L | grep "policy ACCEPT" | wc -l)

    if [ "$default_policy" -gt 0 ]; then
        log_vulnerability "MEDIUM" "Políticas de firewall permisivas detectadas" \
            "Revisar políticas por defecto"
    fi
}

# Verificar logs y auditoría
check_logging_audit() {
    echo -e "${GREEN}Verificando configuración de logs y auditoría...${NC}"

    # Verificar syslog
    if ! systemctl is-active --quiet rsyslog; then
        log_vulnerability "MEDIUM" "Servicio rsyslog no está activo" \
            "Activar con: systemctl enable rsyslog"
    fi

    # Verificar auditd
    if ! systemctl is-active --quiet auditd 2>/dev/null; then
        log_vulnerability "LOW" "Sistema de auditoría (auditd) no está activo" \
            "Instalar y configurar auditd"
    fi

    # Verificar rotación de logs
    if [ ! -f "/etc/logrotate.conf" ]; then
        log_vulnerability "MEDIUM" "Configuración de rotación de logs no encontrada" \
            "Configurar logrotate"
    fi
}

# Verificar configuraciones de seguridad del kernel
check_kernel_security() {
    echo -e "${GREEN}Verificando configuraciones de seguridad del kernel...${NC}"

    # Verificar ASLR
    local aslr_status
    aslr_status=$(cat /proc/sys/kernel/randomize_va_space 2>/dev/null)

    if [ "$aslr_status" != "2" ]; then
        log_vulnerability "MEDIUM" "ASLR no está completamente habilitado" \
            "Configurar kernel.randomize_va_space = 2"
    fi

    # Verificar protección exec-shield
    if [ -f "/proc/sys/kernel/exec-shield" ]; then
        local exec_shield
        exec_shield=$(cat /proc/sys/kernel/exec-shield)
        if [ "$exec_shield" != "1" ]; then
            log_vulnerability "LOW" "Exec-shield no está habilitado" \
                "Habilitar exec-shield"
        fi
    fi

    # Verificar control de acceso obligatorio (SELinux/AppArmor)
    if command -v getenforce &> /dev/null; then
        local selinux_status
        selinux_status=$(getenforce)
        if [ "$selinux_status" = "Disabled" ]; then
            log_vulnerability "MEDIUM" "SELinux está deshabilitado" \
                "Considerar habilitar SELinux"
        fi
    elif command -v aa-status &> /dev/null; then
        if ! aa-status &> /dev/null; then
            log_vulnerability "MEDIUM" "AppArmor no está activo" \
                "Verificar estado de AppArmor"
        fi
    else
        log_vulnerability "LOW" "No se detectó sistema de control de acceso obligatorio" \
            "Considerar instalar SELinux o AppArmor"
    fi
}

# Verificar archivos de configuración críticos
check_critical_files() {
    echo -e "${GREEN}Verificando archivos de configuración críticos...${NC}"

    # Verificar permisos de archivos sensibles
    local critical_files=(
        "/etc/passwd:644"
        "/etc/shadow:640"
        "/etc/group:644"
        "/etc/gshadow:640"
        "/etc/sudoers:440"
    )

    for file_perm in "${critical_files[@]}"; do
        local file="${file_perm%:*}"
        local expected_perm="${file_perm#*:}"

        if [ -f "$file" ]; then
            local actual_perm
            actual_perm=$(stat -c "%a" "$file")

            if [ "$actual_perm" != "$expected_perm" ]; then
                log_vulnerability "HIGH" "Permisos incorrectos en $file" \
                    "Actual: $actual_perm, Esperado: $expected_perm"
            fi
        fi
    done

    # Verificar archivos de configuración backup
    local backup_files
    backup_files=$(find /etc -name "*.bak" -o -name "*.old" -o -name "*~" 2>/dev/null)

    if [ -n "$backup_files" ]; then
        log_vulnerability "LOW" "Archivos de respaldo encontrados en /etc" \
            "$(echo "$backup_files" | head -5 | tr '\n' ' ')"
    fi
}

# Verificar configuración de red
check_network_security() {
    echo -e "${GREEN}Verificando configuración de seguridad de red...${NC}"

    # Verificar IP forwarding
    local ip_forward
    ip_forward=$(cat /proc/sys/net/ipv4/ip_forward)

    if [ "$ip_forward" = "1" ] && ! grep -q "router\|gateway" /etc/hostname; then
        log_vulnerability "MEDIUM" "IP forwarding habilitado" \
            "Deshabilitar si no es necesario: echo 0 > /proc/sys/net/ipv4/ip_forward"
    fi

    # Verificar source routing
    local accept_source_route
    accept_source_route=$(cat /proc/sys/net/ipv4/conf/all/accept_source_route)

    if [ "$accept_source_route" = "1" ]; then
        log_vulnerability "MEDIUM" "Source routing habilitado" \
            "Deshabilitar source routing"
    fi

    # Verificar ICMP redirects
    local accept_redirects
    accept_redirects=$(cat /proc/sys/net/ipv4/conf/all/accept_redirects)

    if [ "$accept_redirects" = "1" ]; then
        log_vulnerability "LOW" "ICMP redirects habilitados" \
            "Considerar deshabilitar ICMP redirects"
    fi
}

# Verificar software instalado
check_installed_software() {
    echo -e "${GREEN}Verificando software instalado...${NC}"

    # Software potencialmente peligroso
    local risky_software=("netcat" "ncat" "socat" "telnet-server" "rsh-server")

    for software in "${risky_software[@]}"; do
        if dpkg -l "$software" 2>/dev/null | grep -q "^ii"; then
            log_vulnerability "MEDIUM" "Software potencialmente riesgoso instalado: $software" \
                "Revisar necesidad y considerar desinstalar"
        elif rpm -q "$software" 2>/dev/null; then
            log_vulnerability "MEDIUM" "Software potencialmente riesgoso instalado: $software" \
                "Revisar necesidad y considerar desinstalar"
        fi
    done

    # Verificar compiladores (en servidores de producción)
    local compilers=("gcc" "g++" "make" "cmake")
    local compiler_found=false

    for compiler in "${compilers[@]}"; do
        if command -v "$compiler" &> /dev/null; then
            compiler_found=true
            break
        fi
    done

    if [ "$compiler_found" = true ]; then
        log_vulnerability "LOW" "Compiladores encontrados en el sistema" \
            "En servidores de producción, considerar remover herramientas de desarrollo"
    fi
}

# Generar reporte final
generate_final_report() {
    echo "" >> "$REPORT_FILE"
    echo "========================================" >> "$REPORT_FILE"
    echo "RESUMEN DE VULNERABILIDADES ENCONTRADAS" >> "$REPORT_FILE"
    echo "========================================" >> "$REPORT_FILE"
    echo "Críticas: $CRITICAL_COUNT" >> "$REPORT_FILE"
    echo "Altas: $HIGH_COUNT" >> "$REPORT_FILE"
    echo "Medias: $MEDIUM_COUNT" >> "$REPORT_FILE"
    echo "Bajas: $LOW_COUNT" >> "$REPORT_FILE"
    echo "Total: $((CRITICAL_COUNT + HIGH_COUNT + MEDIUM_COUNT + LOW_COUNT))" >> "$REPORT_FILE"
    echo "" >> "$REPORT_FILE"

    # Calcular score de seguridad
    local security_score
    security_score=$((100 - (CRITICAL_COUNT * 25) - (HIGH_COUNT * 10) - (MEDIUM_COUNT * 5) - (LOW_COUNT * 1)))

    if [ $security_score -lt 0 ]; then
        security_score=0
    fi

    echo "Score de Seguridad: $security_score/100" >> "$REPORT_FILE"

    if [ $security_score -ge 80 ]; then
        echo "Estado: BUENO" >> "$REPORT_FILE"
    elif [ $security_score -ge 60 ]; then
        echo "Estado: REGULAR - Requiere atención" >> "$REPORT_FILE"
    else
        echo "Estado: CRÍTICO - Requiere acción inmediata" >> "$REPORT_FILE"
    fi

    echo "" >> "$REPORT_FILE"
    echo "Fecha del escaneo: $(date)" >> "$REPORT_FILE"
    echo "Sistema: $(uname -a)" >> "$REPORT_FILE"
    echo "Hostname: $(hostname)" >> "$REPORT_FILE"
}

# Función principal
main() {
    echo -e "${GREEN}===========================================${NC}"
    echo -e "${GREEN}    ESCÁNER DE VULNERABILIDADES v2.3     ${NC}"
    echo -e "${GREEN}===========================================${NC}"
    echo ""

    # Crear encabezado del reporte
    echo "REPORTE DE VULNERABILIDADES" > "$REPORT_FILE"
    echo "============================" >> "$REPORT_FILE"
    echo "Fecha: $(date)" >> "$REPORT_FILE"
    echo "Sistema: $(uname -a)" >> "$REPORT_FILE"
    echo "Hostname: $(hostname)" >> "$REPORT_FILE"
    echo "" >> "$REPORT_FILE"

    # Ejecutar verificaciones
    check_ssh_config
    check_users_permissions
    check_services_ports
    check_system_updates
    check_firewall_config
    check_logging_audit
    check_kernel_security
    check_critical_files
    check_network_security
    check_installed_software

    # Generar reporte final
    generate_final_report

    # Mostrar resumen
    echo ""
    echo -e "${GREEN}===========================================${NC}"
    echo -e "${GREEN}            RESUMEN FINAL                  ${NC}"
    echo -e "${GREEN}===========================================${NC}"
    echo -e "Vulnerabilidades ${RED}CRÍTICAS${NC}: $CRITICAL_COUNT"
    echo -e "Vulnerabilidades ${RED}ALTAS${NC}: $HIGH_COUNT"
    echo -e "Vulnerabilidades ${YELLOW}MEDIAS${NC}: $MEDIUM_COUNT"
    echo -e "Vulnerabilidades ${BLUE}BAJAS${NC}: $LOW_COUNT"
    echo ""
    echo -e "Reporte completo guardado en: ${GREEN}$REPORT_FILE${NC}"
    echo ""

    # Mostrar recomendaciones prioritarias
    if [ $CRITICAL_COUNT -gt 0 ] || [ $HIGH_COUNT -gt 0 ]; then
        echo -e "${RED}⚠️  ATENCIÓN: Se encontraron vulnerabilidades críticas o altas${NC}"
        echo -e "${RED}   Revisar el reporte y tomar medidas correctivas inmediatamente${NC}"
    elif [ $MEDIUM_COUNT -gt 5 ]; then
        echo -e "${YELLOW}⚠️  ADVERTENCIA: Múltiples vulnerabilidades de nivel medio${NC}"
        echo -e "${YELLOW}   Se recomienda revisar y corregir en el próximo mantenimiento${NC}"
    else
        echo -e "${GREEN}✅ Estado de seguridad: Aceptable${NC}"
    fi
}

# Verificar herramientas necesarias
check_dependencies() {
    local missing_tools=()
    local tools=("awk" "grep" "find" "stat" "systemctl")

    for tool in "${tools[@]}"; do
        if ! command -v "$tool" &> /dev/null; then
            missing_tools+=("$tool")
        fi
    done

    if [ ${#missing_tools[@]} -gt 0 ]; then
        echo -e "${RED}Error: Herramientas faltantes: ${missing_tools[*]}${NC}"
        exit 1
    fi
}

# Verificar dependencias y ejecutar
check_dependencies
main "$@"

4.4. Instalación y Configuración

4.4.1. Paso 1: Instalación del script

# Crear el archivo del script
sudo nano /usr/local/bin/vuln_scanner.sh

# Copiar el código y guardar

# Hacer ejecutable
sudo chmod +x /usr/local/bin/vuln_scanner.sh

4.4.2. Paso 2: Ejecución básica

# Ejecutar escaneo completo
sudo /usr/local/bin/vuln_scanner.sh

# Ver el reporte generado
cat /tmp/vulnerability_scan_*.txt

4.4.3. Paso 3: Automatización (recomendado semanal)

# Agregar a cron para ejecución semanal
echo "0 2 * * 0 /usr/local/bin/vuln_scanner.sh" | sudo crontab -

# Crear script para envío de reportes por email
cat > /usr/local/bin/send_vuln_report.sh << 'EOF'
#!/bin/bash
REPORT=$(ls -t /tmp/vulnerability_scan_*.txt | head -1)
if [ -f "$REPORT" ]; then
    mail -s "Reporte de Vulnerabilidades - $(hostname)" admin@empresa.com < "$REPORT"
fi
EOF

sudo chmod +x /usr/local/bin/send_vuln_report.sh

4.5. Ejemplos de Uso Avanzado

4.5.1. Escaneo específico por categoría

# Modificar el script para escaneos específicos
# Ejemplo: solo verificar SSH y usuarios
/usr/local/bin/vuln_scanner.sh --ssh --users

4.5.2. Integración con otros sistemas

# Exportar resultados en formato JSON para SIEM
# Agregar función de exportación al script
export_json() {
    local json_file="/tmp/vulnerabilities.json"
    cat > "$json_file" << EOF
{
    "timestamp": "$(date -Iseconds)",
    "hostname": "$(hostname)",
    "vulnerabilities": {
        "critical": $CRITICAL_COUNT,
        "high": $HIGH_COUNT,
        "medium": $MEDIUM_COUNT,
        "low": $LOW_COUNT
    }
}
EOF
    echo "Reporte JSON: $json_file"
}

5. Guía de Implementación y Mejores Prácticas

5.1. Configuración Inicial del Entorno

5.1.1. Preparación del sistema

# Crear estructura de directorios
sudo mkdir -p /var/log/security/{reports,alerts,scans}
sudo mkdir -p /etc/security/scripts

# Configurar permisos
sudo chmod 750 /var/log/security
sudo chown root:adm /var/log/security

# Instalar dependencias necesarias
sudo apt-get update
sudo apt-get install -y mailutils bc netcat-openbsd

5.1.2. Configuración de alertas

# Configurar postfix para alertas por email
sudo dpkg-reconfigure postfix

# Crear archivo de configuración de alertas
cat > /etc/security/alert.conf << 'EOF'
# Configuración de alertas de seguridad
ALERT_EMAIL="security@empresa.com"
ALERT_THRESHOLD_CRITICAL=1
ALERT_THRESHOLD_HIGH=3
SEND_DAILY_REPORT=true
EOF

5.2. Programación y Automatización

5.2.1. Script de orquestación

#!/bin/bash
# security_orchestrator.sh - Orquestador de scripts de seguridad

# Ejecutar monitoreo cada 15 minutos
*/15 * * * * /usr/local/bin/security_monitor.sh

# Ejecutar análisis de logs diariamente a las 6 AM
0 6 * * * /usr/local/bin/log_analyzer.sh

# Ejecutar escaneo de vulnerabilidades semanalmente
0 2 * * 0 /usr/local/bin/vuln_scanner.sh

# Limpiar logs antiguos mensualmente
0 0 1 * * find /var/log/security -name "*.log" -mtime +30 -delete

5.3. Personalización y Extensión

5.3.1. Agregar nuevas verificaciones

Los scripts están diseñados para ser extensibles. Para agregar nuevas verificaciones:

En security_monitor.sh: Agregar nueva función `check_nueva_verificacion()`
En log_analyzer.sh: Añadir patrones a `ATTACK_PATTERNS`
En vuln_scanner.sh: Crear nueva función `check_nueva_categoria()`

5.3.2. Integración con SIEM

# Función para enviar datos a SIEM
send_to_siem() {
    local event_data="$1"
    local siem_endpoint="https://siem.empresa.com/api/events"

    curl -X POST "$siem_endpoint" \
         -H "Content-Type: application/json" \
         -H "Authorization: Bearer $SIEM_TOKEN" \
         -d "$event_data"
}

5.4. Mantenimiento y Monitoreo

5.4.1. Verificación de funcionamiento

# Script de verificación del estado de los scripts de seguridad
#!/bin/bash
echo "Verificando scripts de seguridad..."

for script in security_monitor log_analyzer vuln_scanner; do
    if [ -x "/usr/local/bin/${script}.sh" ]; then
        echo "✅ $script - OK"
    else
        echo "❌ $script - FALTA O NO EJECUTABLE"
    fi
done

# Verificar logs recientes
if [ -f "/var/log/security_monitor.log" ]; then
    last_entry=$(tail -1 /var/log/security_monitor.log | cut -d']' -f1 | tr -d '[')
    echo "Último monitoreo: $last_entry"
fi

5.5. Consideraciones de Seguridad

5.5.1. Protección de los scripts

Almacenar en ubicaciones seguras (`/usr/local/bin/`)
Permisos restrictivos (755 para ejecución, 644 para configuración)
Validar todas las entradas
Usar rutas absolutas para comandos

5.5.2. Gestión de logs

Rotación automática con `logrotate`
Envío seguro a sistemas centralizados
Encriptación de logs sensibles
Retención según políticas de la organización

6. Solución de Problemas Comunes

6.1. Problemas de Permisos

# Error: Permission denied
# Solución: Verificar permisos y ejecutar como root si es necesario
sudo chmod +x /usr/local/bin/script_name.sh
sudo chown root:root /usr/local/bin/script_name.sh

6.2. Problemas de Dependencias

# Error: command not found
# Solución: Instalar herramientas faltantes
sudo apt-get install -y bc netcat-openbsd mailutils

# Para CentOS/RHEL
sudo yum install -y bc nc mailx

6.3. Problemas de Conectividad

# Error al enviar emails
# Verificar configuración de MTA
systemctl status postfix
# O configurar relay SMTP externo

7. Conclusión

Estos tres scripts proporcionan una base sólida para la monitorización y auditoría de seguridad en sistemas Linux. Cada script está diseñado para:

Facilidad de uso: Instalación y configuración simples
Extensibilidad: Fácil personalización y adición de nuevas funcionalidades
Automatización: Integración perfecta con cron y sistemas de monitoreo
Reporting: Generación de reportes detallados y alertas automáticas

La implementación de estos scripts como parte de una estrategia integral de ciberseguridad ayudará a mantener los sistemas Linux seguros y detectar amenazas de manera proactiva.

7.1. Próximos Pasos Recomendados

Implementar los scripts en un entorno de prueba
Personalizar las configuraciones según las necesidades específicas
Integrar con sistemas de monitoreo existentes
Establecer procedimientos de respuesta a incidentes
Capacitar al equipo en el uso y mantenimiento de los scripts

— Mantener estos scripts actualizados y revisar periódicamente su efectividad es crucial para una seguridad óptima.

Mi Blog con Emacs y Esteroides