SearchSploit - Base de Datos de Exploits

Introducción

SearchSploit es una herramienta de línea de comandos que permite buscar y examinar exploits en la base de datos local de Exploit Database (Exploit-DB). Es una herramienta esencial para pentesters que necesitan encontrar rápidamente exploits conocidos para vulnerabilidades específicas.

¿Qué es Exploit Database?

Exploit Database es una base de datos pública de exploits y vulnerabilidades mantenida por Offensive Security. Contiene:

Más de 50,000 exploits: Código de explotación verificado
Shellcodes: Código de payload para diferentes arquitecturas
Papers: Documentación técnica sobre vulnerabilidades
Webapps: Exploits específicos para aplicaciones web
Actualizaciones diarias: Nueva información de seguridad

Importancia en Pentesting

SearchSploit es crucial porque:

Búsqueda offline: No requiere conexión a internet
Búsqueda rápida: Indexación local eficiente
Código fuente: Acceso directo al código de exploits
Verificación: Exploits probados y verificados
Integración: Compatible con Metasploit y otras herramientas

Instalación

Kali Linux (Preinstalado)

# SearchSploit viene preinstalado en Kali Linux
searchsploit --version

# Actualizar base de datos
searchsploit -u

Ubuntu/Debian

# Instalar git si no está disponible
sudo apt update
sudo apt install git

# Clonar repositorio de Exploit Database
git clone https://github.com/offensive-security/exploitdb.git /opt/exploitdb

# Crear enlace simbólico
sudo ln -sf /opt/exploitdb/searchsploit /usr/local/bin/searchsploit

# Configurar ruta de la base de datos
echo 'export PATH="/opt/exploitdb:$PATH"' >> ~/.bashrc
source ~/.bashrc

Instalación Manual

# Descargar desde GitHub
wget https://github.com/offensive-security/exploitdb/archive/main.zip
unzip main.zip
mv exploitdb-main /opt/exploitdb

# Hacer ejecutable
chmod +x /opt/exploitdb/searchsploit

# Agregar al PATH
export PATH="/opt/exploitdb:$PATH"

Docker

# Usar imagen Docker oficial
docker pull offensive/exploitdb

# Ejecutar con Docker
docker run --rm -it offensive/exploitdb searchsploit apache

Uso Básico

Sintaxis Fundamental

# Sintaxis general
searchsploit [opciones] <términos de búsqueda>

# Búsqueda básica
searchsploit apache

# Búsqueda con múltiples términos
searchsploit apache 2.4

# Búsqueda exacta
searchsploit "apache 2.4.7"

Parámetros Principales

Parámetro	Descripción	Ejemplo
`-t, --title`	Buscar solo en títulos	`searchsploit -t apache`
`-e, --exact`	Búsqueda exacta	`searchsploit -e "apache 2.4"`
`-s, --strict`	Búsqueda estricta	`searchsploit -s apache`
`-w, --www`	Mostrar URLs de Exploit-DB	`searchsploit -w apache`
`-c, --case`	Sensible a mayúsculas	`searchsploit -c Apache`
`-x, --examine`	Examinar exploit específico	`searchsploit -x 12345`
`-m, --mirror`	Copiar exploit localmente	`searchsploit -m 12345`
`-p, --path`	Mostrar ruta completa	`searchsploit -p apache`

Ejemplos Prácticos

Búsquedas Básicas

# Buscar exploits de Apache
searchsploit apache

# Ejemplo de salida:
# ----------------------------------------- ---------------------------------
#  Exploit Title                           |  Path
# ----------------------------------------- ---------------------------------
# Apache 2.4.7 - Remote Code Execution    | linux/remote/12345.py
# Apache mod_ssl 2.8.x - Buffer Overflow  | linux/local/67890.c
# ----------------------------------------- ---------------------------------

# Buscar por versión específica
searchsploit apache 2.4.7

# Buscar en títulos únicamente
searchsploit -t "remote code execution"

Búsquedas Avanzadas

# Búsqueda exacta con comillas
searchsploit -e "Windows 10"

# Búsqueda estricta (sin coincidencias parciales)
searchsploit -s mysql

# Búsqueda sensible a mayúsculas
searchsploit -c MySQL

# Combinar parámetros
searchsploit -t -e "Apache 2.4"

Examinar y Copiar Exploits

# Examinar un exploit específico
searchsploit -x linux/remote/12345.py

# Copiar exploit al directorio actual
searchsploit -m 12345

# Copiar múltiples exploits
searchsploit -m 12345 67890 11111

# Mostrar ruta completa del exploit
searchsploit -p apache | head -5

Obtener URLs Web

# Mostrar URLs de Exploit-DB
searchsploit -w apache

# Ejemplo de salida:
# Apache 2.4.7 - RCE | https://www.exploit-db.com/exploits/12345

# Combinar con otras opciones
searchsploit -w -t "buffer overflow"

Scripts de Automatización

Buscador Automatizado de Exploits

#!/bin/bash
# exploit_finder.sh - Buscador automatizado de exploits

search_exploits() {
    local service=$1
    local version=$2
    local output_dir="exploit_search_$(date +%Y%m%d_%H%M%S)"

    mkdir -p $output_dir

    echo "[+] Buscando exploits para: $service $version"
    echo "[+] Resultados en: $output_dir"

    # Búsqueda básica
    echo "=== BÚSQUEDA BÁSICA ===" > $output_dir/basic_search.txt
    searchsploit "$service $version" >> $output_dir/basic_search.txt

    # Búsqueda exacta
    echo "=== BÚSQUEDA EXACTA ===" > $output_dir/exact_search.txt
    searchsploit -e "$service $version" >> $output_dir/exact_search.txt

    # Búsqueda solo en títulos
    echo "=== BÚSQUEDA EN TÍTULOS ===" > $output_dir/title_search.txt
    searchsploit -t "$service" >> $output_dir/title_search.txt

    # Obtener URLs
    echo "=== URLS DE EXPLOIT-DB ===" > $output_dir/urls.txt
    searchsploit -w "$service $version" >> $output_dir/urls.txt

    # Análisis de resultados
    analyze_results $output_dir "$service $version"
}

analyze_results() {
    local output_dir=$1
    local search_term=$2

    echo "[+] Analizando resultados..."

    # Contar exploits encontrados
    local total_basic=$(grep -c "linux\|windows\|multiple" $output_dir/basic_search.txt 2>/dev/null || echo "0")
    local total_exact=$(grep -c "linux\|windows\|multiple" $output_dir/exact_search.txt 2>/dev/null || echo "0")

    # Generar resumen
    cat > $output_dir/RESUMEN.txt << EOF
=== RESUMEN DE BÚSQUEDA DE EXPLOITS ===
Término de búsqueda: $search_term
Fecha: $(date)

ESTADÍSTICAS:
- Exploits encontrados (búsqueda básica): $total_basic
- Exploits encontrados (búsqueda exacta): $total_exact

CATEGORÍAS DETECTADAS:
EOF

    # Categorizar por plataforma
    echo "Linux:" >> $output_dir/RESUMEN.txt
    grep "linux/" $output_dir/basic_search.txt | wc -l >> $output_dir/RESUMEN.txt

    echo "Windows:" >> $output_dir/RESUMEN.txt
    grep "windows/" $output_dir/basic_search.txt | wc -l >> $output_dir/RESUMEN.txt

    echo "Multiple:" >> $output_dir/RESUMEN.txt
    grep "multiple/" $output_dir/basic_search.txt | wc -l >> $output_dir/RESUMEN.txt

    # Top 10 exploits más relevantes
    echo -e "\nTOP 10 EXPLOITS MÁS RELEVANTES:" >> $output_dir/RESUMEN.txt
    head -10 $output_dir/exact_search.txt | grep -E "(linux|windows|multiple)" >> $output_dir/RESUMEN.txt

    echo "[+] Resumen generado: $output_dir/RESUMEN.txt"
}

# Uso del script
if [ $# -lt 1 ]; then
    echo "Uso: $0 <servicio> [versión]"
    echo "Ejemplo: $0 apache 2.4.7"
    exit 1
fi

search_exploits "$1" "$2"

Descargador Masivo de Exploits

#!/bin/bash
download_exploits_by_service() {
    local service=$1
    local download_dir="exploits_${service}_$(date +%Y%m%d)"

    mkdir -p $download_dir
    cd $download_dir

    echo "[+] Descargando exploits para: $service"

    # Buscar y extraer IDs de exploits
    searchsploit $service | grep -oE '[0-9]+\.(py|c|txt|pl|rb|sh)' | while read exploit_file; do
        exploit_id=$(echo $exploit_file | grep -oE '[0-9]+')

        echo "[+] Descargando exploit ID: $exploit_id"
        searchsploit -m $exploit_id

        # Renombrar con información descriptiva
        if [ -f "$exploit_file" ]; then
            exploit_title=$(searchsploit $service | grep $exploit_id | awk -F'|' '{print $1}' | xargs)
            safe_title=$(echo "$exploit_title" | tr ' /' '_' | tr -cd '[:alnum:]_.-')
            mv "$exploit_file" "${exploit_id}_${safe_title}.${exploit_file##*.}"
        fi

        sleep 1  # Evitar sobrecarga
    done

    cd ..
    echo "[+] Exploits descargados en: $download_dir"
    ls -la $download_dir
}

# Función para descargar exploits por plataforma
download_by_platform() {
    local platform=$1
    local output_dir="exploits_${platform}_$(date +%Y%m%d)"

    mkdir -p $output_dir

    echo "[+] Descargando exploits para plataforma: $platform"

    # Buscar exploits por plataforma
    find /opt/exploitdb/exploits/$platform -name "*.py" -o -name "*.c" -o -name "*.txt" | head -50 | while read exploit_path; do
        exploit_name=$(basename "$exploit_path")
        cp "$exploit_path" "$output_dir/"
        echo "[+] Copiado: $exploit_name"
    done

    echo "[+] Exploits de $platform descargados en: $output_dir"
}

# Uso
case $1 in
    "service")
        download_exploits_by_service $2
        ;;
    "platform")
        download_by_platform $2
        ;;
    *)
        echo "Uso: $0 <service|platform> <nombre>"
        echo "Ejemplos:"
        echo "  $0 service apache"
        echo "  $0 platform linux"
        ;;
esac

Analizador de Exploits

#!/bin/bash
analyze_exploit() {
    local exploit_id=$1
    local analysis_dir="analysis_${exploit_id}_$(date +%Y%m%d_%H%M%S)"

    mkdir -p $analysis_dir

    echo "[+] Analizando exploit ID: $exploit_id"

    # Copiar exploit localmente
    searchsploit -m $exploit_id

    # Encontrar el archivo descargado
    exploit_file=$(ls | grep "^$exploit_id\.")

    if [ -z "$exploit_file" ]; then
        echo "[-] No se pudo encontrar el exploit $exploit_id"
        return 1
    fi

    echo "[+] Archivo encontrado: $exploit_file"

    # Análisis básico del archivo
    echo "=== INFORMACIÓN BÁSICA ===" > $analysis_dir/basic_info.txt
    echo "Archivo: $exploit_file" >> $analysis_dir/basic_info.txt
    echo "Tamaño: $(wc -c < $exploit_file) bytes" >> $analysis_dir/basic_info.txt
    echo "Líneas: $(wc -l < $exploit_file)" >> $analysis_dir/basic_info.txt
    echo "Tipo: $(file $exploit_file)" >> $analysis_dir/basic_info.txt
    echo "" >> $analysis_dir/basic_info.txt

    # Extraer información del exploit
    echo "=== METADATOS DEL EXPLOIT ===" >> $analysis_dir/basic_info.txt
    head -20 $exploit_file | grep -E "(Title|Date|Author|CVE|Vulnerable)" >> $analysis_dir/basic_info.txt

    # Análisis de código según el tipo
    case $exploit_file in
        *.py)
            analyze_python_exploit $exploit_file $analysis_dir
            ;;
        *.c)
            analyze_c_exploit $exploit_file $analysis_dir
            ;;
        *.pl)
            analyze_perl_exploit $exploit_file $analysis_dir
            ;;
        *.rb)
            analyze_ruby_exploit $exploit_file $analysis_dir
            ;;
    esac

    # Buscar strings interesantes
    echo "=== STRINGS INTERESANTES ===" > $analysis_dir/strings.txt
    strings $exploit_file | grep -E "(http|ftp|/bin/|cmd|shell|exploit|payload)" >> $analysis_dir/strings.txt

    # Buscar direcciones IP y URLs
    echo "=== DIRECCIONES Y URLS ===" > $analysis_dir/network_info.txt
    grep -oE '([0-9]{1,3}\.){3}[0-9]{1,3}' $exploit_file >> $analysis_dir/network_info.txt
    grep -oE 'https?://[^\s]+' $exploit_file >> $analysis_dir/network_info.txt

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

analyze_python_exploit() {
    local file=$1
    local dir=$2

    echo "=== ANÁLISIS PYTHON ===" > $dir/python_analysis.txt

    # Importaciones
    echo "Importaciones:" >> $dir/python_analysis.txt
    grep "^import\|^from.*import" $file >> $dir/python_analysis.txt

    # Funciones definidas
    echo -e "\nFunciones definidas:" >> $dir/python_analysis.txt
    grep "^def " $file >> $dir/python_analysis.txt

    # Variables de configuración
    echo -e "\nVariables de configuración:" >> $dir/python_analysis.txt
    grep -E "^[A-Z_]+ = " $file >> $dir/python_analysis.txt

    # Verificar sintaxis
    python3 -m py_compile $file 2>&1 | head -10 >> $dir/python_analysis.txt
}

analyze_c_exploit() {
    local file=$1
    local dir=$2

    echo "=== ANÁLISIS C ===" > $dir/c_analysis.txt

    # Includes
    echo "Includes:" >> $dir/c_analysis.txt
    grep "^#include" $file >> $dir/c_analysis.txt

    # Funciones principales
    echo -e "\nFunciones:" >> $dir/c_analysis.txt
    grep -E "^[a-zA-Z_][a-zA-Z0-9_]*\s*\(" $file | head -10 >> $dir/c_analysis.txt

    # Llamadas a sistema
    echo -e "\nLlamadas a sistema:" >> $dir/c_analysis.txt
    grep -E "(system|exec|fork|socket)" $file >> $dir/c_analysis.txt

    # Intentar compilar (si gcc está disponible)
    if command -v gcc >/dev/null 2>&1; then
        echo -e "\nIntento de compilación:" >> $dir/c_analysis.txt
        gcc -o /tmp/test_compile $file 2>&1 | head -10 >> $dir/c_analysis.txt
        rm -f /tmp/test_compile
    fi
}

# Uso
if [ $# -ne 1 ]; then
    echo "Uso: $0 <exploit_id>"
    echo "Ejemplo: $0 12345"
    exit 1
fi

analyze_exploit $1

Integración con Otras Herramientas

Con Metasploit

# Buscar exploits que tienen módulos en Metasploit
searchsploit apache | grep -i metasploit

# Buscar por CVE y luego en Metasploit
searchsploit CVE-2021-44228
msfconsole -q -x "search CVE-2021-44228; exit"

Con Nmap

#!/bin/bash
# Función para procesar resultados de Nmap
process_nmap_results() {
    local nmap_file=$1

    echo "[+] Procesando resultados de Nmap: $nmap_file"

    # Extraer servicios y versiones
    grep -E "^[0-9]+/(tcp|udp)" $nmap_file | while read line; do
        port=$(echo $line | awk '{print $1}')
        service=$(echo $line | awk '{print $3}')
        version=$(echo $line | cut -d' ' -f4- | sed 's/^version //')

        echo "[+] Puerto $port - $service $version"

        # Buscar exploits para este servicio
        if [ ! -z "$version" ]; then
            echo "  Buscando exploits para: $service $version"
            searchsploit "$service $version" | head -5
        else
            echo "  Buscando exploits para: $service"
            searchsploit "$service" | head -3
        fi
        echo "----------------------------------------"
    done
}

# Uso con archivo de Nmap
if [ $# -eq 1 ]; then
    process_nmap_results $1
else
    echo "Uso: $0 <archivo_nmap.txt>"
fi

Con Nuclei

# Buscar templates de Nuclei relacionados con exploits encontrados
search_nuclei_templates() {
    local service=$1

    echo "[+] Buscando exploits y templates de Nuclei para: $service"

    # Buscar exploits
    echo "=== EXPLOITS DISPONIBLES ==="
    searchsploit $service | head -10

    # Buscar templates de Nuclei
    echo -e "\n=== TEMPLATES DE NUCLEI ==="
    find ~/nuclei-templates -name "*.yaml" -exec grep -l "$service" {} \; | head -10
}

Casos de Uso Específicos

Análisis de CVE

#!/bin/bash
analyze_cve() {
    local cve_id=$1
    local output_dir="cve_analysis_${cve_id//CVE-/}_$(date +%Y%m%d)"

    mkdir -p $output_dir

    echo "[+] Analizando CVE: $cve_id"

    # Buscar exploits para el CVE
    echo "=== EXPLOITS PARA $cve_id ===" > $output_dir/exploits.txt
    searchsploit $cve_id >> $output_dir/exploits.txt

    # Buscar información adicional
    echo "=== INFORMACIÓN ADICIONAL ===" > $output_dir/additional_info.txt
    searchsploit -w $cve_id >> $output_dir/additional_info.txt

    # Buscar en diferentes formatos del CVE
    cve_year=$(echo $cve_id | cut -d'-' -f2)
    cve_number=$(echo $cve_id | cut -d'-' -f3)

    echo "=== BÚSQUEDAS ALTERNATIVAS ===" >> $output_dir/additional_info.txt
    searchsploit "$cve_year-$cve_number" >> $output_dir/additional_info.txt
    searchsploit "CVE $cve_year $cve_number" >> $output_dir/additional_info.txt

    # Descargar exploits relevantes
    searchsploit -m $cve_id 2>/dev/null
    mv *.py *.c *.txt *.pl $output_dir/ 2>/dev/null

    echo "[+] Análisis de CVE completado en: $output_dir"
}

# Uso
if [ $# -ne 1 ]; then
    echo "Uso: $0 <CVE-ID>"
    echo "Ejemplo: $0 CVE-2021-44228"
    exit 1
fi

analyze_cve $1

Búsqueda por Plataforma

#!/bin/bash
search_by_platform() {
    local platform=$1
    local keyword=$2
    local output_file="platform_search_${platform}_$(date +%Y%m%d).txt"

    echo "[+] Buscando exploits para plataforma: $platform"
    echo "[+] Palabra clave: $keyword"

    case $platform in
        "linux")
            searchsploit $keyword | grep "linux/" > $output_file
            ;;
        "windows")
            searchsploit $keyword | grep "windows/" > $output_file
            ;;
        "web")
            searchsploit $keyword | grep -E "(php|asp|jsp|web)" > $output_file
            ;;
        "mobile")
            searchsploit $keyword | grep -E "(android|ios|mobile)" > $output_file
            ;;
        *)
            echo "Plataformas soportadas: linux, windows, web, mobile"
            return 1
            ;;
    esac

    echo "[+] Resultados guardados en: $output_file"
    echo "[+] Total de exploits encontrados: $(wc -l < $output_file)"

    # Mostrar top 10
    echo "[+] Top 10 exploits:"
    head -10 $output_file
}

# Uso
search_by_platform $1 $2

Mantenimiento y Actualización

Actualizar Base de Datos

# Actualización automática
searchsploit -u

# Actualización manual
cd /opt/exploitdb
git pull origin main

# Verificar última actualización
searchsploit --help | grep "Last DB Update"

Script de Mantenimiento

#!/bin/bash
maintain_exploitdb() {
    echo "[+] Iniciando mantenimiento de Exploit Database..."

    # Verificar instalación
    if ! command -v searchsploit >/dev/null 2>&1; then
        echo "[-] SearchSploit no está instalado"
        return 1
    fi

    # Mostrar información actual
    echo "[+] Versión actual:"
    searchsploit --version

    # Actualizar base de datos
    echo "[+] Actualizando base de datos..."
    searchsploit -u

    # Verificar integridad
    echo "[+] Verificando integridad..."
    if [ -d "/opt/exploitdb" ]; then
        echo "Directorio principal: OK"
        echo "Exploits disponibles: $(find /opt/exploitdb/exploits -name "*.py" -o -name "*.c" -o -name "*.txt" | wc -l)"
    fi

    # Limpiar archivos temporales
    echo "[+] Limpiando archivos temporales..."
    find . -name "*.tmp" -delete 2>/dev/null
    find . -name "core" -delete 2>/dev/null

    echo "[+] Mantenimiento completado"
}

maintain_exploitdb

Troubleshooting

Problemas Comunes

# Problema: SearchSploit no encuentra exploits
# Solución: Actualizar base de datos
searchsploit -u

# Problema: Ruta incorrecta
# Solución: Verificar configuración
which searchsploit
echo $PATH

# Problema: Permisos
# Solución: Verificar permisos del directorio
ls -la /opt/exploitdb/
sudo chown -R $USER:$USER /opt/exploitdb/

# Problema: Base de datos corrupta
# Solución: Re-clonar repositorio
rm -rf /opt/exploitdb
git clone https://github.com/offensive-security/exploitdb.git /opt/exploitdb

Verificación de Instalación

#!/bin/bash
verify_installation() {
    echo "[+] Verificando instalación de SearchSploit..."

    # Verificar comando
    if command -v searchsploit >/dev/null 2>&1; then
        echo "[+] SearchSploit está instalado"
        searchsploit --version
    else
        echo "[-] SearchSploit no está instalado"
        return 1
    fi

    # Verificar base de datos
    if [ -d "/opt/exploitdb" ]; then
        echo "[+] Base de datos encontrada en /opt/exploitdb"
        echo "    Exploits: $(find /opt/exploitdb/exploits -type f | wc -l)"
        echo "    Shellcodes: $(find /opt/exploitdb/shellcodes -type f 2>/dev/null | wc -l)"
    else
        echo "[-] Base de datos no encontrada"
    fi

    # Test básico
    echo "[+] Realizando test básico..."
    test_result=$(searchsploit apache 2>&1 | head -1)
    if [[ $test_result == *"Exploit Title"* ]]; then
        echo "[+] Test básico: OK"
    else
        echo "[-] Test básico: FALLO"
    fi
}

verify_installation

Recursos Adicionales

Herramientas Complementarias

Metasploit: Framework de explotación
Nuclei: Scanner de vulnerabilidades
Nmap: Descubrimiento de servicios
Burp Suite: Pruebas de aplicaciones web

Bases de Datos Relacionadas

CVE Details: Información detallada de CVEs
NVD: Base de datos nacional de vulnerabilidades
Packet Storm: Exploits y herramientas de seguridad
0day.today: Exploits de día cero

Enlaces Útiles

Disclaimer Legal

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