Pspy - Monitor de Procesos para Post-Explotación

Introducción

Pspy es una herramienta fundamental de post-explotación que permite monitorear procesos en sistemas Linux sin requerir privilegios de root. Es especialmente útil para identificar tareas cron, scripts automatizados, procesos ejecutados por otros usuarios y oportunidades de escalación de privilegios.

¿Por qué usar Pspy?

Sin privilegios root: Funciona con usuarios limitados
Monitoreo en tiempo real: Observa procesos conforme se ejecutan
Detección de automatización: Identifica tareas cron y scripts
Escalación de privilegios: Encuentra procesos vulnerables
Análisis de comportamiento: Comprende el funcionamiento del sistema

Características Principales

Monitoreo de procesos: Ve todos los procesos que se inician
Monitoreo de archivos: Detecta cambios en el sistema de archivos
Sin dependencias: Binario estático compilado en Go
Multiplataforma: Funciona en diferentes arquitecturas Linux
Salida colorizada: Fácil identificación visual

Instalación

Descarga Directa

# Descargar la última versión
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64

# Hacer ejecutable
chmod +x pspy64

# Ejecutar
./pspy64

Versiones Disponibles

# Para sistemas de 64 bits
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64

# Para sistemas de 32 bits
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy32

# Para sistemas con arquitectura específica
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64s  # Versión estática

Uso Básico

Sintaxis Fundamental

# Uso básico
./pspy64

# Con opciones específicas
./pspy64 -pf -i 1000

# Guardar salida en archivo
./pspy64 | tee pspy_output.txt

Parámetros Principales

Parámetro	Descripción	Ejemplo
`-p`	Mostrar procesos	`-p`
`-f`	Mostrar eventos de archivos	`-f`
`-i <ms>`	Intervalo en milisegundos	`-i 1000`
`-d <dirs>`	Directorios a monitorear	`-d /tmp,/var`
`-r <dirs>`	Directorios recursivos	`-r /home`
`-c`	Mostrar colores	`-c`
`--debug`	Modo debug	`--debug`

Ejemplos Prácticos

Monitoreo Básico de Procesos

# Monitorear solo procesos
./pspy64 -p

# Ejemplo de salida:
# 2024/01/15 10:30:15 CMD: UID=0    PID=1234   | /usr/bin/cron
# 2024/01/15 10:30:16 CMD: UID=1000 PID=1235   | /bin/bash /home/user/script.sh
# 2024/01/15 10:30:17 CMD: UID=0    PID=1236   | /usr/bin/find /var/log -name "*.log"

Monitoreo de Archivos y Procesos

# Monitorear procesos y archivos
./pspy64 -pf

# Con intervalo personalizado (cada 500ms)
./pspy64 -pf -i 500

# Monitorear directorios específicos
./pspy64 -pf -d /tmp,/var/tmp,/dev/shm

Scripts de Automatización

Analizador de Procesos Automatizado

#!/bin/bash
PSPY_BIN="./pspy64"
OUTPUT_DIR="pspy_analysis_$(date +%Y%m%d_%H%M%S)"
DURATION=${1:-300}

if [ ! -f "$PSPY_BIN" ]; then
    echo "[!] Descargando Pspy..."
    wget -q https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64
    chmod +x pspy64
fi

mkdir -p $OUTPUT_DIR

echo "[+] Iniciando análisis con Pspy por $DURATION segundos"
timeout $DURATION $PSPY_BIN -pf -i 100 > $OUTPUT_DIR/pspy_raw.txt 2>&1

# Procesar resultados
echo "=== PROCESOS ÚNICOS ===" > $OUTPUT_DIR/unique_processes.txt
grep "CMD:" $OUTPUT_DIR/pspy_raw.txt | sort -u >> $OUTPUT_DIR/unique_processes.txt

echo "=== PROCESOS ROOT ===" > $OUTPUT_DIR/root_processes.txt
grep "CMD:" $OUTPUT_DIR/pspy_raw.txt | grep "UID=0" | sort -u >> $OUTPUT_DIR/root_processes.txt

echo "=== SCRIPTS DETECTADOS ===" > $OUTPUT_DIR/scripts.txt
grep "CMD:" $OUTPUT_DIR/pspy_raw.txt | grep -E "\.(sh|py|pl|php)" | sort -u >> $OUTPUT_DIR/scripts.txt

echo "[+] Análisis completo en: $OUTPUT_DIR"

Monitor de Escalación de Privilegios

#!/bin/bash
monitor_for_privesc() {
    echo "[+] Monitoreando oportunidades de escalación..."

    ./pspy64 -pf | while IFS= read -r line; do
        if echo "$line" | grep -q "CMD:"; then
            uid=$(echo "$line" | grep -o "UID=[0-9]*" | cut -d'=' -f2)
            cmd=$(echo "$line" | cut -d'|' -f2-)

            # Scripts root en ubicaciones escribibles
            if [ "$uid" = "0" ] && echo "$cmd" | grep -qE "(tmp|home)"; then
                echo "[!] ESCALACIÓN POTENCIAL: $cmd"
            fi

            # Comandos con wildcards
            if [ "$uid" = "0" ] && echo "$cmd" | grep -q "\*"; then
                echo "[!] WILDCARD INJECTION: $cmd"
            fi

            # Rutas relativas
            if [ "$uid" = "0" ] && ! echo "$cmd" | grep -q "^/"; then
                echo "[!] PATH HIJACKING: $cmd"
            fi
        fi
    done
}

monitor_for_privesc

Análisis de Resultados

Identificación de Patrones Cron

#!/bin/bash
analyze_cron_patterns() {
    local pspy_log=$1

    echo "[+] Analizando patrones de tareas cron..."

    # Extraer timestamps y buscar patrones
    grep "CMD:" $pspy_log | while read line; do
        timestamp=$(echo "$line" | awk '{print $2}' | cut -d':' -f2)
        minute=$(echo "$timestamp" | cut -d':' -f2)

        # Detectar ejecuciones cada minuto
        if [ "$minute" = "00" ]; then
            echo "[HOURLY] $line"
        elif [ "$minute" = "30" ]; then
            echo "[HALF-HOUR] $line"
        fi
    done

    # Procesos frecuentes
    echo -e "\n=== PROCESOS MÁS FRECUENTES ==="
    grep "CMD:" $pspy_log | cut -d'|' -f2- | sort | uniq -c | sort -nr | head -10
}

analyze_cron_patterns pspy_output.txt

Detector de Actividad Sospechosa

#!/bin/bash
detect_suspicious() {
    local pspy_log=$1

    echo "[+] Detectando actividad sospechosa..."

    # Comandos de red
    echo "=== ACTIVIDAD DE RED ==="
    grep "CMD:" $pspy_log | grep -E "(wget|curl|nc|ssh)" | head -10

    # Limpieza de logs
    echo -e "\n=== LIMPIEZA DE LOGS ==="
    grep "CMD:" $pspy_log | grep -E "(rm.*log|truncate|history -c)" | head -10

    # Modificaciones de archivos críticos
    echo -e "\n=== ARCHIVOS CRÍTICOS ==="
    grep "FS:" $pspy_log | grep -E "(passwd|shadow|sudoers)" | head -10

    # Procesos en ubicaciones temporales
    echo -e "\n=== EJECUCIÓN EN /TMP ==="
    grep "CMD:" $pspy_log | grep "/tmp" | head -10
}

detect_suspicious pspy_output.txt

Casos de Uso Específicos

Análisis de Servicios Web

#!/bin/bash
monitor_web_services() {
    echo "[+] Monitoreando servicios web..."

    ./pspy64 -pf | grep -E "(apache|nginx|httpd|php|www)" | while read line; do
        echo "[WEB] $line"

        # Detectar ejecución de PHP
        if echo "$line" | grep -q "php"; then
            echo "  [+] Ejecución PHP detectada"
        fi

        # Detectar logs de acceso
        if echo "$line" | grep -q "access.log"; then
            echo "  [+] Actividad en logs de acceso"
        fi
    done
}

monitor_web_services

Monitor de Backup y Mantenimiento

#!/bin/bash
monitor_maintenance() {
    echo "[+] Monitoreando tareas de mantenimiento..."

    ./pspy64 -p | grep -iE "(backup|clean|maint|update|cron)" | while read line; do
        uid=$(echo "$line" | grep -o "UID=[0-9]*" | cut -d'=' -f2)
        cmd=$(echo "$line" | cut -d'|' -f2-)

        echo "[MAINT] UID=$uid: $cmd"

        # Verificar si el script es modificable
        if echo "$cmd" | grep -qE "\.(sh|py)"; then
            script_path=$(echo "$cmd" | awk '{print $1}')
            if [ -w "$script_path" 2>/dev/null ]; then
                echo "  [!] SCRIPT ESCRIBIBLE: $script_path"
            fi
        fi
    done
}

monitor_maintenance

Evasión y Stealth

Pspy Silencioso

#!/bin/bash
# Ejecutar pspy de forma sigilosa
run_stealth_pspy() {
    # Renombrar binario
    cp pspy64 /tmp/.system_monitor

    # Ejecutar en background sin salida visible
    nohup /tmp/.system_monitor -pf > /tmp/.sys_log 2>&1 &

    # Obtener PID
    PSPY_PID=$!
    echo "[+] Pspy ejecutándose sigilosamente (PID: $PSPY_PID)"

    # Función para procesar logs
    tail -f /tmp/.sys_log | while read line; do
        if echo "$line" | grep -q "UID=0"; then
            echo "$line" >> /tmp/.root_activity
        fi
    done &

    echo "[+] Logs de actividad root en: /tmp/.root_activity"
}

run_stealth_pspy

Troubleshooting

Problemas Comunes

# Verificar arquitectura del sistema
uname -m
# x86_64 = usar pspy64
# i686 = usar pspy32

# Verificar permisos
ls -la pspy64
chmod +x pspy64

# Test básico
./pspy64 --help

# Verificar espacio en disco
df -h /tmp

# Monitorear uso de recursos
top -p $(pgrep pspy)

Optimización de Performance

# Reducir intervalo para menos carga CPU
./pspy64 -i 2000  # Cada 2 segundos

# Monitorear solo directorios específicos
./pspy64 -d /tmp,/var/tmp

# Limitar salida con filtros
./pspy64 -p | grep -E "(UID=0|cron)"

Recursos Adicionales

Herramientas Complementarias

ps: Monitoreo estático de procesos
htop: Monitor interactivo de procesos
auditd: Auditoría del sistema
sysdig: Monitoreo avanzado del sistema

Enlaces Útiles

Disclaimer Legal

⚠️ IMPORTANTE: Esta documentación es únicamente para fines educativos y de investigación en ciberseguridad. El uso de Pspy debe realizarse exclusivamente en:

Sistemas propios
Entornos de laboratorio
Pruebas de penetración autorizadas

El uso no autorizado puede constituir un delito. Los autores no se hacen responsables del mal uso de esta información.