LSE - Linux Smart Enumeration

Introducción

Linux Smart Enumeration (LSE) es una herramienta avanzada de enumeración post-explotación diseñada específicamente para sistemas Linux. Automatiza la recopilación de información crítica del sistema, identificación de vectores de escalación de privilegios y análisis de configuraciones de seguridad, todo presentado en un formato colorizado y fácil de interpretar.

¿Por qué usar LSE?

Enumeración inteligente: Prioriza información crítica para escalación de privilegios
Salida colorizada: Resalta hallazgos importantes visualmente
Múltiples niveles: Desde básico hasta exhaustivo
Sin dependencias: Script bash puro, funciona en cualquier sistema Linux
Actualizado constantemente: Incluye técnicas de escalación modernas

Características Principales

Información del sistema: Kernel, distribución, arquitectura
Usuarios y grupos: Enumeración completa de cuentas
Procesos y servicios: Análisis de procesos en ejecución
Archivos y permisos: Búsqueda de archivos con permisos especiales
Configuraciones de red: Interfaces, conexiones, firewall
Software instalado: Aplicaciones y versiones vulnerables

Instalación

Descarga Directa

# Descargar la última versión
wget https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh

# Hacer ejecutable
chmod +x lse.sh

# Ejecutar
./lse.sh

Clonar Repositorio

# Clonar repositorio completo
git clone https://github.com/diego-treitos/linux-smart-enumeration.git
cd linux-smart-enumeration

# Hacer ejecutable
chmod +x lse.sh

# Ejecutar
./lse.sh

Uso Básico

Sintaxis Fundamental

# Sintaxis general
./lse.sh [opciones]

# Ejecución básica (nivel 0)
./lse.sh

# Nivel específico
./lse.sh -l 1

# Guardar salida
./lse.sh -l 2 | tee lse_output.txt

Niveles de Enumeración

Nivel	Descripción	Tiempo	Uso Recomendado
`0`	Básico y rápido	~30 seg	Reconocimiento inicial
`1`	Intermedio	~2 min	Análisis estándar
`2`	Completo	~5 min	Enumeración exhaustiva

Parámetros Principales

Parámetro	Descripción	Ejemplo
`-l <level>`	Nivel de enumeración (0-2)	`-l 2`
`-c`	Incluir checks adicionales	`-c`
`-i`	Incluir información interesante	`-i`
`-h`	Mostrar ayuda	`-h`

Ejemplos Prácticos

Enumeración Rápida

# Nivel 0 - Reconocimiento básico
./lse.sh -l 0

# Ejemplo de salida:
# [!] fst000 Kernel information
# Linux version 4.15.0-142-generic
#
# [!] usr010 Current user information
# uid=1000(user) gid=1000(user) groups=1000(user),4(adm),24(cdrom)

Enumeración Completa

# Nivel 2 con checks adicionales
./lse.sh -l 2 -c -i

# Guardar en archivo con timestamp
./lse.sh -l 2 -c | tee "lse_$(hostname)_$(date +%Y%m%d_%H%M%S).txt"

Scripts de Automatización

Analizador LSE Automatizado

#!/bin/bash
LSE_SCRIPT="./lse.sh"
OUTPUT_DIR="lse_analysis_$(date +%Y%m%d_%H%M%S)"
HOSTNAME=$(hostname)

if [ ! -f "$LSE_SCRIPT" ]; then
    echo "[!] Descargando LSE..."
    wget -q https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh
    chmod +x lse.sh
fi

mkdir -p $OUTPUT_DIR

echo "[+] Iniciando análisis LSE para: $HOSTNAME"

# Ejecutar diferentes niveles
$LSE_SCRIPT -l 0 > $OUTPUT_DIR/lse_level0.txt 2>&1
$LSE_SCRIPT -l 1 > $OUTPUT_DIR/lse_level1.txt 2>&1
$LSE_SCRIPT -l 2 -c -i > $OUTPUT_DIR/lse_level2.txt 2>&1

# Procesar resultados
echo "=== HALLAZGOS CRÍTICOS ===" > $OUTPUT_DIR/critical_findings.txt
grep "\[!\]" $OUTPUT_DIR/lse_level2.txt >> $OUTPUT_DIR/critical_findings.txt

echo "=== ARCHIVOS SUID/SGID ===" > $OUTPUT_DIR/suid_files.txt
grep -E "(SUID|SGID)" $OUTPUT_DIR/lse_level2.txt >> $OUTPUT_DIR/suid_files.txt

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

Interpretador de Resultados

#!/bin/bash
interpret_lse_results() {
    local lse_output=$1

    echo "[+] Interpretando resultados LSE..."

    # Archivos SUID peligrosos
    dangerous_suid=("nmap" "vim" "find" "bash" "python" "perl")

    echo "=== BINARIOS SUID PELIGROSOS ==="
    for binary in "${dangerous_suid[@]}"; do
        if grep -q "$binary.*SUID" $lse_output; then
            echo "[!] CRÍTICO: $binary con SUID encontrado"
            echo "    GTFOBins: https://gtfobins.github.io/gtfobins/$binary/"
        fi
    done

    # Archivos escribibles críticos
    echo -e "\n=== ARCHIVOS CRÍTICOS ESCRIBIBLES ==="
    critical_files=("/etc/passwd" "/etc/shadow" "/etc/sudoers")

    for file in "${critical_files[@]}"; do
        if grep -q "$file.*Writable" $lse_output; then
            echo "[!] CRÍTICO: $file es escribible"
        fi
    done

    # Procesos como root
    echo -e "\n=== PROCESOS PRIVILEGIADOS ==="
    if grep -q "root.*mysql\|root.*apache" $lse_output; then
        echo "[!] RIESGO: Servicios ejecutándose como root"
    fi
}

# Uso
interpret_lse_results lse_output.txt

Análisis de Escalación de Privilegios

Detector de Vectores de Escalación

#!/bin/bash
detect_privesc_vectors() {
    local lse_file=$1
    local vectors_file="privesc_vectors_$(date +%Y%m%d_%H%M%S).txt"

    echo "=== VECTORES DE ESCALACIÓN DETECTADOS ===" > $vectors_file
    echo "Archivo fuente: $lse_file" >> $vectors_file
    echo "Fecha: $(date)" >> $vectors_file
    echo "" >> $vectors_file

    # Vector 1: Archivos SUID
    echo "1. ARCHIVOS SUID/SGID:" >> $vectors_file
    suid_count=$(grep -c "SUID\|SGID" $lse_file)
    echo "   Total encontrados: $suid_count" >> $vectors_file
    grep "SUID\|SGID" $lse_file | head -10 >> $vectors_file
    echo "" >> $vectors_file

    # Vector 2: Sudo sin contraseña
    echo "2. SUDO SIN CONTRASEÑA:" >> $vectors_file
    if grep -q "NOPASSWD" $lse_file; then
        echo "   [!] Comandos sudo sin contraseña encontrados" >> $vectors_file
        grep "NOPASSWD" $lse_file >> $vectors_file
    else
        echo "   No se encontraron comandos sudo sin contraseña" >> $vectors_file
    fi
    echo "" >> $vectors_file

    # Vector 3: Archivos escribibles
    echo "3. ARCHIVOS ESCRIBIBLES CRÍTICOS:" >> $vectors_file
    writable_count=$(grep -c "Writable" $lse_file)
    echo "   Total encontrados: $writable_count" >> $vectors_file
    grep "Writable.*etc\|Writable.*root" $lse_file >> $vectors_file
    echo "" >> $vectors_file

    # Vector 4: Procesos vulnerables
    echo "4. PROCESOS VULNERABLES:" >> $vectors_file
    if grep -qE "mysql.*root|apache.*root|nginx.*root" $lse_file; then
        echo "   [!] Servicios ejecutándose como root" >> $vectors_file
        grep -E "mysql.*root|apache.*root|nginx.*root" $lse_file >> $vectors_file
    fi

    echo "[+] Análisis de vectores completado: $vectors_file"
}

detect_privesc_vectors lse_output.txt

Integración con Otras Herramientas

LSE + Pspy Combinado

#!/bin/bash
run_combined_analysis() {
    local duration=${1:-300}
    local output_dir="combined_analysis_$(date +%Y%m%d_%H%M%S)"

    mkdir -p $output_dir

    echo "[+] Análisis combinado LSE + Pspy"

    # Ejecutar LSE
    ./lse.sh -l 2 > $output_dir/lse_results.txt 2>&1

    # Ejecutar Pspy en paralelo
    timeout $duration ./pspy64 -pf > $output_dir/pspy_results.txt 2>&1 &

    # Esperar y generar reporte
    wait

    echo "[+] Generando reporte combinado..."
    cat > $output_dir/combined_report.txt << EOF
=== REPORTE COMBINADO LSE + PSPY ===
Fecha: $(date)
Duración Pspy: $duration segundos

RESUMEN LSE:
- Archivos SUID: $(grep -c SUID $output_dir/lse_results.txt)
- Procesos analizados: $(grep -c "PID" $output_dir/lse_results.txt)

RESUMEN PSPY:
- Comandos monitoreados: $(grep -c "CMD:" $output_dir/pspy_results.txt)
- Procesos únicos: $(grep "CMD:" $output_dir/pspy_results.txt | sort -u | wc -l)
EOF

    echo "[+] Análisis combinado completado: $output_dir"
}

run_combined_analysis 300

Troubleshooting

Problemas Comunes

# Verificar permisos
chmod +x lse.sh

# Ejecutar con timeout si es lento
timeout 300 ./lse.sh -l 1

# Guardar salida completa
./lse.sh -l 2 > lse_full.txt 2>&1

# Ver colores en less
./lse.sh -l 1 | less -R

Recursos Adicionales

Herramientas Complementarias

LinPEAS: Enumeración más extensa
Pspy: Monitoreo de procesos
LinEnum: Enumeración clásica
Unix-privesc-check: Verificador de escalación

Enlaces Útiles

Disclaimer Legal

⚠️ IMPORTANTE: Esta documentación es únicamente para fines educativos y de investigación en ciberseguridad. El uso de LSE 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.