Detección de Servidor Bajo Ataque

Introducción

Los ciberataques a servidores están aumentando en frecuencia y sofisticación. Desde ataques de denegación de servicio distribuido (DDoS) hasta intentos de fuerza bruta e infecciones de malware, los servidores enfrentan amenazas constantes de actores maliciosos. La detección temprana es crucial para minimizar daños, prevenir violaciones de datos y mantener la disponibilidad del servicio.

Esta guía integral proporciona a administradores de sistemas y profesionales de seguridad herramientas prácticas de línea de comandos y técnicas para detectar cuándo un servidor está bajo ataque. Aprenderá a identificar varios patrones de ataque, analizar actividad sospechosa e implementar mecanismos de detección en tiempo real usando herramientas integradas de Linux.

Comprender los indicadores de ataque y tener procedimientos de diagnóstico implementados es esencial para cualquier persona que administre servidores de producción. Esta guía cubre todo, desde el reconocimiento de patrones de ataque comunes hasta la implementación de sistemas de detección automatizados que le alertan sobre amenazas en tiempo real.

Comprensión de Ataques a Servidores

Tipos Comunes de Ataque

Los servidores comúnmente enfrentan estos tipos de ataques:

  1. DDoS (Denegación de Servicio Distribuida): Abrumar recursos del servidor con tráfico
  2. Fuerza Bruta: Intentos automatizados de adivinación de contraseñas
  3. Escaneo de Puertos: Reconocimiento para identificar vulnerabilidades
  4. Malware/Rootkit: Instalación de software malicioso
  5. Inyección SQL: Explotación de base de datos a través de aplicaciones web
  6. Exploits Zero-Day: Ataques sobre vulnerabilidades desconocidas
  7. Agotamiento de Recursos: Consumir CPU, memoria o disco
  8. Ataques de Capa de Aplicación: Dirigidos a servicios específicos

Indicadores de Ataque

Señales comunes de que su servidor puede estar bajo ataque:

  • Picos inusuales de tráfico de red
  • Alto uso de CPU o memoria sin explicación
  • Intentos excesivos de inicio de sesión fallidos
  • Procesos desconocidos en ejecución
  • Conexiones de red inesperadas
  • Espacio en disco llenándose rápidamente
  • Degradación o fallas del servicio
  • Logs de firewall mostrando intentos bloqueados
  • Modificaciones no autorizadas de archivos

Detección Inicial de Ataque

Evaluación Rápida de Seguridad

Ejecute estos comandos inmediatamente cuando sospeche un ataque:

# Verificar usuarios actualmente conectados
w
who
last | head -20

# Verificar conexiones de red activas
ss -tunap | wc -l
netstat -an | grep ESTABLISHED | wc -l

# Verificar procesos inusuales
ps aux --sort=-%cpu | head -15
ps aux --sort=-%mem | head -15

# Verificar intentos de autenticación recientes
tail -100 /var/log/auth.log | grep -i "failed\|refused"
journalctl -u sshd --since "10 minutes ago" | grep -i fail

# Verificar carga del sistema
uptime
top -bn1 | head -15

# Verificar actividad del disco
iostat -x 1 3

Paso 1: Análisis de Tráfico de Red

Monitoreo de Conexiones Activas

Analice las conexiones de red actuales para patrones sospechosos:

# Contar conexiones por estado
ss -s
netstat -an | awk '{print $6}' | sort | uniq -c | sort -rn

# Listar todas las conexiones activas
ss -tunap
netstat -tunap

# Contar conexiones por IP de origen
netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -20

# Identificar IPs con más conexiones
ss -tn | awk '{print $4}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -20

# Verificar ataque de inundación SYN
netstat -an | grep SYN_RECV | wc -l
ss -ant | grep SYN-RECV | wc -l

# Monitorear tasa de conexión en tiempo real
watch -n 1 'ss -s'

Indicadores Sospechosos:

  • IP única con cientos/miles de conexiones
  • Estados SYN_RECV excesivos (>100)
  • Muchas conexiones a puertos inusuales
  • Conexiones desde países/regiones inesperadas
  • Establecimiento/terminación rápida de conexiones

Análisis de Volumen de Tráfico de Red

Monitorear uso de ancho de banda:

# Monitoreo de ancho de banda en tiempo real
iftop -i eth0
iftop -P -i eth0  # Mostrar puertos

# Estadísticas de interfaz
ip -s link
ifconfig

# Uso de red por proceso
nethogs eth0

# Estadísticas de paquetes
watch -n 1 'cat /proc/net/dev'

# Estadísticas detalladas de interfaz
sar -n DEV 1 10

Análisis de Tráfico con tcpdump

Capturar y analizar paquetes de red:

# Capturar tráfico en interfaz
tcpdump -i eth0 -n

# Capturar tráfico de puerto específico
tcpdump -i eth0 port 80 -n

# Capturar tráfico desde IP específica
tcpdump -i eth0 src 192.168.1.100 -n

# Contar paquetes por IP de origen
tcpdump -i eth0 -n | awk '{print $3}' | cut -d. -f1-4 | sort | uniq -c | sort -rn

# Detectar inundación SYN
tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn) != 0' -c 1000 -n

# Guardar captura para análisis
tcpdump -i eth0 -w /tmp/capture.pcap -c 10000

# Analizar captura guardada
tcpdump -r /tmp/capture.pcap | awk '{print $3}' | cut -d. -f1-4 | sort | uniq -c | sort -rn

Detección de Escaneos de Puertos

Identificar intentos de reconocimiento:

# Monitorear nuevas conexiones
watch -n 1 'ss -tan | grep ESTABLISHED | wc -l'

# Verificar conexiones a múltiples puertos desde la misma IP
tail -1000 /var/log/syslog | grep "UFW BLOCK" | awk '{print $11}' | sort | uniq -c | sort -rn

# Análisis de log de iptables
grep "IN=.*OUT=.*" /var/log/kern.log | tail -100

# Detectar intentos rápidos de conexión
awk '/DPT/ {print $12}' /var/log/messages | cut -d= -f2 | sort | uniq -c | sort -rn

Paso 2: Detección de Ataques de Autenticación

Monitoreo de Intentos de Inicio de Sesión Fallidos

Los ataques de fuerza bruta dejan firmas claras:

# Intentos SSH fallidos recientes
grep "Failed password" /var/log/auth.log | tail -50

# Contar intentos fallidos por IP
grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn

# Intentos fallidos en la última hora
grep "Failed password" /var/log/auth.log | grep "$(date '+%b %e %H')"

# Usando journalctl para systemd
journalctl -u sshd | grep "Failed password" | tail -50

# Contar intentos fallidos por nombre de usuario
grep "Failed password" /var/log/auth.log | awk '{print $9}' | sort | uniq -c | sort -rn

# Verificar ataques de diccionario (usuarios inválidos)
grep "Invalid user" /var/log/auth.log | tail -50
grep "Invalid user" /var/log/auth.log | awk '{print $8}' | sort | uniq -c | sort -rn

# Monitorear en tiempo real
tail -f /var/log/auth.log | grep --line-buffered "Failed\|Invalid"

Indicadores de Ataque:

  • Múltiples intentos fallidos desde la misma IP (>10)
  • Intentos fallidos para múltiples nombres de usuario
  • Intentos fallidos para usuarios inexistentes
  • Intentos desde múltiples IPs simultáneamente
  • Intentos fallidos a intervalos regulares (automatizado)

Verificación de Inicios de Sesión Sospechosos Exitosos

# Inicios de sesión exitosos recientes
grep "Accepted" /var/log/auth.log | tail -50

# Historial de inicio de sesión
last | head -50
last -f /var/log/wtmp | head -50

# Intentos de inicio de sesión fallidos
lastb | head -50
last -f /var/log/btmp | head -50

# Usuarios actualmente conectados
w
who -a

# Verificar horarios de inicio de sesión inusuales
last | grep -v "$(date '+%a %b %e')"

# Inicios de sesión desde ubicaciones inusuales
last | awk '{print $3}' | grep -v "^$\|wtmp" | sort | uniq

# Verificar historial de inicio de sesión de usuario
last username | head -20

Análisis de Patrones de Autenticación

# Conteo horario de inicio de sesión fallido
grep "Failed password" /var/log/auth.log | awk '{print $1,$2,$3}' | sort | uniq -c

# Análisis geográfico de IPs (requiere geoip-bin)
grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort -u | xargs -I {} geoiplookup {}

# Verificar ataques de pulverización de contraseñas
grep "Failed password" /var/log/auth.log | awk '{print $9}' | sort | uniq -c | awk '$1 < 5 {print $2}' | wc -l

# Análisis basado en tiempo
for hour in {00..23}; do
    echo -n "$hour:00 - "
    grep "Failed password" /var/log/auth.log | grep " $hour:" | wc -l
done

Paso 3: Análisis de Procesos y Sistema

Identificación de Procesos Maliciosos

Busque procesos en ejecución sospechosos:

# Procesos por uso de CPU
ps aux --sort=-%cpu | head -20

# Procesos por uso de memoria
ps aux --sort=-%mem | head -20

# Procesos ejecutándose como usuarios inesperados
ps aux | grep -v "^root\|^www-data\|^mysql\|^postgres" | less

# Procesos iniciados recientemente
ps -eo pid,user,lstart,cmd --sort=lstart | tail -20

# Procesos con conexiones de red
lsof -i -n -P | grep ESTABLISHED

# Procesos ocultos (posible rootkit)
ps aux | wc -l
ls /proc | grep "^[0-9]" | wc -l
# Los números deben coincidir

# Verificar procesos escuchando en puertos
lsof -i -P | grep LISTEN
ss -tlnp

# Procesos con nombres inusuales
ps aux | grep -E "\[.*\]" | grep -v "^\[.*\]$"

# Verificar rutas ejecutables de procesos
ls -la /proc/*/exe 2>/dev/null | grep deleted

Indicadores Sospechosos:

  • Procesos con nombres de caracteres aleatorios
  • Procesos ejecutándose desde /tmp o /dev/shm
  • Procesos sin padre (PPID = 1 inesperadamente)
  • Procesos consumiendo recursos excesivos
  • Procesos desconocidos escuchando en puertos
  • Ejecutables eliminados aún en ejecución

Análisis de Comportamiento de Procesos

# Información detallada del proceso
ps -fp <PID>
cat /proc/<PID>/cmdline
cat /proc/<PID>/status

# Actividad de red del proceso
lsof -p <PID> -i

# Archivos abiertos del proceso
lsof -p <PID>

# Directorio de trabajo del proceso
ls -la /proc/<PID>/cwd

# Hora de inicio del proceso
ps -p <PID> -o lstart=

# Rastrear llamadas del sistema del proceso
strace -p <PID> -s 1000 -e trace=network

# Verificar binario del proceso
file /proc/<PID>/exe
md5sum /proc/<PID>/exe

Verificación de Tareas Programadas

Los atacantes a menudo usan cron para persistencia:

# Crontabs de usuario
for user in $(cut -f1 -d: /etc/passwd); do
    echo "Crontab for $user:"
    crontab -u $user -l 2>/dev/null
done

# Crontabs del sistema
cat /etc/crontab
ls -la /etc/cron.*/*
cat /etc/cron.d/*

# Temporizadores de systemd
systemctl list-timers --all

# Trabajos At
atq
for job in $(atq | awk '{print $1}'); do
    echo "Job $job:"
    at -c $job
done

# Verificar entradas sospechosas
grep -r "wget\|curl\|nc\|/tmp" /etc/cron* /var/spool/cron/

Paso 4: Análisis del Sistema de Archivos

Detección de Cambios No Autorizados en Archivos

Monitorear archivos modificados o nuevos:

# Archivos modificados recientemente
find / -type f -mtime -1 -ls 2>/dev/null | grep -v "/proc\|/sys\|/dev"

# Archivos creados recientemente en ubicaciones sospechosas
find /tmp /var/tmp /dev/shm -type f -mtime -1 -ls 2>/dev/null

# Archivos grandes creados recientemente
find / -type f -size +100M -mtime -1 -ls 2>/dev/null

# Archivos modificados en la última hora
find / -type f -mmin -60 -ls 2>/dev/null | grep -v "/proc\|/sys"

# Archivos ocultos
find / -name ".*" -type f -ls 2>/dev/null | head -50

# Archivos SUID
find / -perm -4000 -type f -ls 2>/dev/null

# Archivos escribibles por todos
find / -type f -perm -002 -ls 2>/dev/null | grep -v "/proc\|/sys"

# Verificar archivos críticos del sistema
stat /bin/bash /bin/ls /usr/bin/wget /usr/bin/curl

Análisis de Directorios Web

Los directorios web son objetivos comunes de ataque:

# Archivos web modificados recientemente
find /var/www -type f -mtime -7 -ls

# Archivos PHP/ejecutables en directorios de subida
find /var/www -name "*.php" -o -name "*.sh" -o -name "*.py" | grep -i upload

# Nombres de archivo sospechosos
find /var/www -type f -name "*.php.*" -o -name "*shell*" -o -name "*backdoor*"

# Archivos con permisos inusuales
find /var/www -type f -perm -111 -ls

# Verificar web shells
grep -r "eval\|base64_decode\|system\|exec\|shell_exec" /var/www --include="*.php" | head -20

Verificación de Binarios del Sistema

Verificar que los binarios críticos no hayan sido reemplazados:

# Instalar debsums para Debian/Ubuntu
apt install debsums
debsums -c

# Instalar rpm -V para CentOS/RHEL
rpm -Va | grep '^..5'

# Verificar hashes de binarios comunes
md5sum /bin/ls /bin/ps /bin/netstat /usr/bin/top
# Comparar con valores conocidos buenos

# Verificar binarios inusuales
ls -lah /bin /usr/bin /sbin /usr/sbin | grep "$(date +%Y-%m-%d)"

Paso 5: Análisis de Logs

Examen de Logs del Sistema

Los logs del sistema revelan patrones de ataque:

# Errores críticos recientes
journalctl -p err -n 100

# Mensajes del kernel
dmesg | tail -100
dmesg | grep -i "segfault\|error\|attack"

# Logs de autenticación
tail -200 /var/log/auth.log
grep -i "fail\|error\|refused" /var/log/auth.log | tail -100

# Log del sistema
tail -200 /var/log/syslog
tail -200 /var/log/messages

# Log de seguridad
tail -100 /var/log/secure

# Verificar manipulación de logs
ls -lah /var/log/*.log
# Buscar brechas en tiempos de modificación o logs vacíos

Análisis de Logs del Servidor Web

Analizar logs del servidor web para patrones de ataque:

# IPs principales solicitantes
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

# Solicitudes por minuto
awk '{print $4}' /var/log/nginx/access.log | cut -d: -f1-3 | uniq -c | tail -20

# Errores 404 (sondeo)
grep " 404 " /var/log/nginx/access.log | tail -100

# Intentos de inicio de sesión fallidos a aplicaciones web
grep "wp-login\|admin\|login" /var/log/nginx/access.log | tail -100

# Intentos de inyección SQL
grep -i "select\|union\|insert\|update" /var/log/nginx/access.log | tail -50

# Intentos de traversal de directorio
grep "\.\." /var/log/nginx/access.log | tail -50

# Análisis de user agent (detectar bots)
awk -F\" '{print $6}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

# Análisis de solicitudes POST
grep "POST" /var/log/nginx/access.log | tail -100

# Solicitudes grandes (posibles ataques de subida)
awk '{print $10}' /var/log/nginx/access.log | sort -rn | head -20

Análisis de Logs de Firewall

# Conexiones bloqueadas por UFW
grep "UFW BLOCK" /var/log/syslog | tail -100

# Contar IPs bloqueadas
grep "UFW BLOCK" /var/log/syslog | awk '{print $11}' | cut -d= -f2 | sort | uniq -c | sort -rn

# Puertos de destino bloqueados
grep "UFW BLOCK" /var/log/syslog | awk '{print $13}' | cut -d= -f2 | sort | uniq -c | sort -rn

# Logs de iptables
grep "iptables" /var/log/kern.log | tail -100

# Acciones de Fail2ban
tail -100 /var/log/fail2ban.log
grep "Ban\|Unban" /var/log/fail2ban.log | tail -50

Paso 6: Detección de Malware y Rootkit

Ejecución de Escáneres de Seguridad

Usar herramientas especializadas para detectar malware:

# Instalar y ejecutar rkhunter
apt install rkhunter
rkhunter --update
rkhunter --check --skip-keypress

# Instalar y ejecutar chkrootkit
apt install chkrootkit
chkrootkit

# Escaneo antivirus ClamAV
apt install clamav clamav-daemon
freshclam
clamscan -r /home /var/www

# Linux Malware Detect
cd /tmp
wget http://www.rfxn.com/downloads/maldetect-current.tar.gz
tar -xzf maldetect-current.tar.gz
cd maldetect-*
./install.sh
maldet --update
maldet -a /var/www

Verificación de Rootkits

# Verificar módulos del kernel cargados
lsmod
lsmod | grep -v "Module\|^$"

# Comparar con módulos conocidos
lsmod > /tmp/current_modules.txt
# Comparar con línea base

# Verificar módulos ocultos del kernel
cat /proc/modules
diff <(lsmod | cut -d' ' -f1 | tail -n +2) <(cat /proc/modules | cut -d' ' -f1)

# Verificar rootkits LKM
ls -la /lib/modules/$(uname -r)/kernel/
modinfo suspicious_module_name

# Verificar tabla de llamadas del sistema
cat /proc/kallsyms | grep sys_call_table

Detección Basada en Red

# Verificar conexiones de red ocultas
ss -tunap vs netstat -tunap

# Verificar rastreadores de paquetes
lsof -i -n -P | grep -i raw
ip link | grep PROMISC

# Verificar consultas DNS
tcpdump -i any port 53 -n

# Verificar balizamiento C2 (Comando y Control)
tcpdump -i eth0 -n | grep -E "beacon|c2|cnc"

Paso 7: Detección de Abuso de Recursos

Detección de Minería de Criptomonedas

Los criptomineros son cada vez más comunes:

# Procesos de alto CPU
ps aux --sort=-%cpu | head -10

# Verificar procesos conocidos de minería
ps aux | grep -i "xmrig\|minerd\|cpuminer\|ethminer"

# Verificar pools de minería
netstat -anp | grep -E "stratum|pool|mining"

# Verificar puertos comunes de minería
ss -tunap | grep -E ":3333|:4444|:5555|:7777|:8888|:14444"

# Monitorear patrón de uso de CPU
top -b -d 1 -n 60 | grep "Cpu(s)"
# Los mineros típicamente usan 90-100% de CPU constantemente

Detección de Participación en DDoS

Verificar si su servidor está siendo usado para ataques:

# Análisis de conexiones salientes
ss -tunap | grep ESTABLISHED | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn

# Alta tasa de paquetes salientes
iptables -L OUTPUT -v -n

# Verificar participación en inundación SYN
tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn) != 0' -c 100 -n | awk '{print $5}' | cut -d. -f1-4 | sort | uniq -c

# Ancho de banda por destino
iftop -P -o destination

Monitoreo y Alertas en Tiempo Real

Creación de Script de Detección de Ataques

cat > /usr/local/bin/attack-monitor.sh << 'EOF'
#!/bin/bash

LOG_FILE="/var/log/attack-monitor.log"
ALERT_EMAIL="[email protected]"

# Función para enviar alerta
send_alert() {
    echo "$(date): $1" >> "$LOG_FILE"
    echo "$1" | mail -s "Security Alert: $(hostname)" "$ALERT_EMAIL"
}

# Verificar intentos SSH fallidos
FAILED_SSH=$(grep "Failed password" /var/log/auth.log | grep "$(date '+%b %e %H')" | wc -l)
if [ "$FAILED_SSH" -gt 50 ]; then
    send_alert "High number of failed SSH attempts: $FAILED_SSH in last hour"
fi

# Verificar conteo de conexiones
CONN_COUNT=$(ss -tan | grep ESTABLISHED | wc -l)
if [ "$CONN_COUNT" -gt 1000 ]; then
    send_alert "Excessive connections detected: $CONN_COUNT"
fi

# Verificar escaneos de puertos
SCAN_ATTEMPTS=$(grep "UFW BLOCK" /var/log/syslog | grep "$(date '+%b %e %H')" | wc -l)
if [ "$SCAN_ATTEMPTS" -gt 100 ]; then
    send_alert "Possible port scan detected: $SCAN_ATTEMPTS blocked attempts"
fi

# Verificar uso de CPU
CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
if (( $(echo "$CPU_USAGE > 90" | bc -l) )); then
    TOP_PROCESS=$(ps aux --sort=-%cpu | head -2 | tail -1)
    send_alert "High CPU usage: $CPU_USAGE%. Top process: $TOP_PROCESS"
fi

# Verificar nuevos archivos SUID
find / -perm -4000 -type f -mtime -1 2>/dev/null > /tmp/new_suid.txt
if [ -s /tmp/new_suid.txt ]; then
    send_alert "New SUID files detected: $(cat /tmp/new_suid.txt)"
fi
EOF

chmod +x /usr/local/bin/attack-monitor.sh

# Ejecutar cada 5 minutos
echo "*/5 * * * * /usr/local/bin/attack-monitor.sh" | crontab -

Monitoreo de Tráfico de Red

cat > /usr/local/bin/traffic-monitor.sh << 'EOF'
#!/bin/bash

THRESHOLD=1000  # Umbral de conexiones
INTERFACE="eth0"

# Monitorear nuevas conexiones
while true; do
    CURRENT=$(ss -tan | grep ESTABLISHED | wc -l)

    if [ "$CURRENT" -gt "$THRESHOLD" ]; then
        echo "$(date): High connection count: $CURRENT" >> /var/log/traffic-monitor.log

        # Registrar IPs principales
        ss -tn | awk '{print $4}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -10 >> /var/log/traffic-monitor.log
    fi

    sleep 60
done
EOF

chmod +x /usr/local/bin/traffic-monitor.sh

Bloqueo Automático de IP

cat > /usr/local/bin/auto-block.sh << 'EOF'
#!/bin/bash

THRESHOLD=20
LOG="/var/log/auth.log"

# Obtener IPs con intentos fallidos excesivos
grep "Failed password" "$LOG" | \
    grep "$(date '+%b %e')" | \
    awk '{print $(NF-3)}' | \
    sort | uniq -c | \
    awk -v threshold="$THRESHOLD" '$1 > threshold {print $2}' | \
while read IP; do
    # Verificar si ya está bloqueada
    if ! iptables -L INPUT -n | grep -q "$IP"; then
        echo "$(date): Blocking $IP" >> /var/log/auto-block.log
        iptables -I INPUT -s "$IP" -j DROP

        # Enviar notificación
        echo "Blocked IP: $IP after multiple failed attempts" | \
            mail -s "Auto-blocked IP" [email protected]
    fi
done
EOF

chmod +x /usr/local/bin/auto-block.sh

Acciones de Respuesta

Contención Inmediata

Cuando se confirma un ataque:

# Bloquear IP atacante inmediatamente
iptables -I INPUT -s ATTACKING_IP -j DROP

# Bloquear subred completa si es necesario
iptables -I INPUT -s 192.168.1.0/24 -j DROP

# Limitar tasa de conexión
iptables -A INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT

# Matar procesos sospechosos
kill -9 <PID>

# Deshabilitar cuenta de usuario comprometida
usermod -L username
passwd -l username

# Desconectar sesiones de usuario
pkill -u username

Recolección de Evidencia

# Crear directorio de incidente
INCIDENT_DIR="/root/incident-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$INCIDENT_DIR"

# Recopilar estado del sistema
ps auxf > "$INCIDENT_DIR/processes.txt"
ss -tunap > "$INCIDENT_DIR/connections.txt"
iptables -L -n -v > "$INCIDENT_DIR/firewall.txt"
last > "$INCIDENT_DIR/logins.txt"
df -h > "$INCIDENT_DIR/disk.txt"
free -h > "$INCIDENT_DIR/memory.txt"

# Recopilar logs
cp /var/log/auth.log "$INCIDENT_DIR/"
cp /var/log/syslog "$INCIDENT_DIR/"
journalctl -xe > "$INCIDENT_DIR/journal.txt"

# Recopilar estado de red
ip addr > "$INCIDENT_DIR/network.txt"
ip route > "$INCIDENT_DIR/routes.txt"

# Crear archivo tar
tar -czf "incident-$(date +%Y%m%d-%H%M%S).tar.gz" "$INCIDENT_DIR"

Prevención y Endurecimiento

Implementación de Fail2Ban

# Instalar fail2ban
apt install fail2ban

# Configurar jail SSH
cat > /etc/fail2ban/jail.local << 'EOF'
[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3
bantime = 3600
findtime = 600
EOF

# Iniciar y habilitar
systemctl start fail2ban
systemctl enable fail2ban

# Verificar estado
fail2ban-client status
fail2ban-client status sshd

Limitación de Tasa

# Limitación de tasa SSH con iptables
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --set
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -m recent --update --seconds 60 --hitcount 4 -j DROP

# Limitación de tasa HTTP
iptables -A INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT

Configuración de Monitoreo

# Instalar herramientas de monitoreo
apt install sysstat aide tripwire

# Configurar AIDE (integridad de archivos)
aideinit
cp /var/lib/aide/aide.db.new /var/lib/aide/aide.db

# Verificación diaria de AIDE
echo "0 2 * * * /usr/bin/aide --check | mail -s 'AIDE Report' [email protected]" | crontab -

Conclusión

Detectar ataques a servidores requiere vigilancia, herramientas apropiadas y análisis sistemático. Conclusiones clave:

  1. Monitorear continuamente: Implementar monitoreo y alertas automatizados
  2. Conocer su línea base: Comprender el comportamiento normal del servidor
  3. Actuar rápidamente: La detección temprana minimiza el daño
  4. Recopilar evidencia: Documentar ataques para análisis y mejora
  5. Defensas en capas: Usar múltiples métodos de detección y prevención
  6. Mantenerse actualizado: Mantener sistemas parcheados y herramientas de seguridad actuales
  7. Revisar logs regularmente: No esperar alertas para verificar logs

Las auditorías de seguridad regulares, el endurecimiento adecuado y el monitoreo proactivo reducen significativamente las tasas de éxito de ataques. Cuando ocurren ataques, la detección y respuesta rápidas limitan su impacto. Mantenga estos comandos de diagnóstico a mano y practique su uso en situaciones no emergentes para construir familiaridad y velocidad cuando enfrente amenazas reales.