Kali Linux: LLMs con Nmap

https://www.onlinetis.com/es/

Kali Linux: LLMs con Nmap

Parece que estás interesado en integrar la potencia de los LLM (Modelos de Lenguaje Extensos) con Nmap dentro de Kali Linux. Esta es una tendencia creciente en el "Pentesting aumentado por IA".

Básicamente, estas herramientas toman el archivo de salida de un escaneo de Nmap (usualmente el .xml) y lo pasan por un modelo como GPT-4 o Llama para que este analice vulnerabilidades, sugiera vectores de ataque o explique qué significan los puertos abiertos.

Aquí te detallo las herramientas y métodos más comunes para lograr esto:

1. Herramientas Principales

Existen varios proyectos en GitHub que automatizan este proceso. Los más destacados son:

Nmap-GPT / nmap-analysis

Son scripts (usualmente en Python) que envían los resultados de Nmap a una API.

Funcionamiento: Escaneas con nmap -oX output.xml <target> y luego ejecutas el script apuntando a ese archivo.
Utilidad: Te ahorra el tiempo de leer manualmente cientos de líneas de servicios y versiones.

VulnCheck con LLMs

Algunas herramientas combinan la base de datos de Nmap con búsquedas de CVE (Common Vulnerabilities and Exposures) procesadas por IA.

Ventaja: No solo te dice "el puerto 80 está abierto", sino que te dice "el servidor Apache 2.4.49 detectado es vulnerable a Path Traversal, intenta este comando...".

2. Cómo configurarlo en Kali Linux

Para usar la mayoría de estas herramientas, necesitarás seguir estos pasos generales:

Clonar el repositorio: git clone https://github.com/usuario/nombre-del-herramienta
Instalar dependencias: pip install -r requirements.txt
Configurar la API Key: Casi todas requieren una clave de OpenAI, Anthropic o una instancia local (vía Ollama).
- Tip: Si te preocupa la privacidad de los datos de tu red, usa Ollama para correr el LLM localmente en tu propia máquina.

3. Flujo de Trabajo Recomendado

El proceso de análisis asistido por IA suele seguir este esquema:

Escaneo: Realizas un escaneo detallado con detección de servicios y scripts.
nmap -sV -sC -oX resultados.xml <IP-Objetivo>
Ingesta: La herramienta lee el archivo .xml.
Prompting: El script envía un "prompt" al modelo preguntando: "Basado en estos servicios, ¿cuáles son los puntos de entrada más probables?"
Informe: El LLM genera un resumen ejecutivo o una lista de pasos para la fase de explotación.

4. Advertencia de Seguridad y Ética

Privacidad: Si usas servicios en la nube (como ChatGPT), recuerda que estás enviando información sobre la infraestructura de tu red o la de tu cliente a servidores externos. Para entornos sensibles, usa siempre LLMs locales.
Alucinaciones: Los LLMs pueden inventar vulnerabilidades o puertos que no existen. Siempre verifica los hallazgos manualmente antes de reportarlos.

Usar Ollama en Kali Linux es la mejor forma de mantener tus datos de escaneo privados y bajo tu control absoluto, sin depender de APIs externas.

Aquí tienes los pasos para dejarlo listo y funcional:

1. Instalación de Ollama en Kali

Kali es una distribución basada en Debian, por lo que la instalación es directa mediante la terminal:

Ejecuta el comando de instalación oficial:

Bash

curl -fsSL https://ollama.com/install.sh | sh

Verifica que el servicio esté corriendo:
Bash
```
systemctl status ollama
```

2. Descargar un modelo para Pentesting

Para analizar logs de Nmap, necesitas un modelo equilibrado entre velocidad y razonamiento. Llama 3 o Mistral son opciones fantásticas.

Descarga Llama 3 (recomendado):
Bash
```
ollama run llama3
```
(Una vez que termine de descargar, puedes escribir algo para probarlo y luego salir con /bye).

3. Integración con Nmap (El método "Manual-Inteligente")

Aunque existen scripts específicos, la forma más flexible de hacerlo hoy en día es pasarle el reporte directamente al modelo mediante la terminal.

Paso A: Realiza tu escaneo y guárdalo

Nmap genera un archivo .xml o un archivo de texto normal. Para el LLM, el formato de texto plano (.nmap) suele ser más fácil de leer directamente.

Bash

nmap -sV -sC 192.168.1.1 -oN escaneo_red.nmap

Paso B: Envía el escaneo a Ollama para análisis

Puedes usar un "pipe" en la terminal para que la IA analice el archivo al instante:

Bash

cat escaneo_red.nmap | ollama run llama3 "Analiza este reporte de Nmap. Identifica los servicios más vulnerables, sugiere exploits conocidos y dime qué pasos de enumeración seguirías ahora. Responde en español."

4. Automatización con Scripts (Opcional)

Si quieres algo más "pro", puedes crear un alias en tu archivo .zshrc o .bashrc para que analice escaneos con un solo comando:

Abre tu configuración: nano ~/.zshrc

Añade al final:

Bash

alias nmap-ai='f(){ nmap "$@" -oN temp_scan.nmap && cat temp_scan.nmap | ollama run llama3 "Analiza estos resultados de Nmap en busca de riesgos de seguridad y sugiere vectores de ataque:"; rm temp_scan.nmap; }; f'

Guarda y reinicia la terminal (source ~/.zshrc).
Uso: Ahora solo escribes nmap-ai 192.168.1.1 y la IA te dará el reporte automáticamente al finalizar el escaneo.

Un pequeño consejo de "amigo":

Recuerda que los modelos locales consumen mucha RAM y GPU. Si notas que Kali se pone lento, asegúrate de cerrar el navegador o herramientas pesadas mientras Ollama procesa el reporte.

Configurar un System Prompt es como darle una "personalidad" y un manual de procedimientos a la IA. En lugar de que te responda como un asistente general, lo hará como un Pentester Senior.

Para hacer esto en Ollama, vamos a crear un archivo de modelo personalizado (un Modelfile).

1. Crear el archivo de configuración

Abre tu terminal en Kali y crea un archivo llamado pentest-gpt:

Bash

nano pentest-gpt.Modelfile

2. Definir las "Reglas de Engagement"

Copia y pega el siguiente contenido dentro del archivo. Este prompt le ordena a la IA que sea técnica, directa y que busque vectores de ataque específicos:

Dockerfile
# Basado en el modelo Llama 3
FROM llama3

# Configurar la temperatura (0.2 para que sea preciso y no invente demasiado)
PARAMETER temperature 0.2

# El System Prompt: Aquí es donde ocurre la magia
SYSTEM """
Eres un experto en Red Teaming y Seguridad Ofensiva con 20 años de experiencia. 
Tu tarea es analizar archivos de salida de Nmap (.nmap o .xml).
Para cada host detectado, debes:
1. Enumerar servicios críticos (HTTP, SMB, SSH, bases de datos).
2. Identificar versiones de software potencialmente vulnerables.
3. Sugerir exploits específicos de Metasploit o Searchsploit.
4. Recomendar el siguiente paso de enumeración (ej. gobuster, enum4linux, etc.).
Mantén un tono profesional, técnico y directo. Responde siempre en español.
"""

3. Crear el modelo en Ollama

Una vez guardado el archivo (Ctrl+O, Enter, Ctrl+X), ejecutas este comando para "instalar" tu nuevo agente de pentesting:

Bash

ollama create pentester-ia -f pentest-gpt.Modelfile

4. Cómo usar tu nuevo Agente

Ahora, en lugar de usar el modelo genérico, usarás tu versión optimizada. Mira la diferencia en el flujo de trabajo:

Ejemplo de uso real:

Supongamos que acabas de hacer un escaneo rápido:

Bash

nmap -sV 10.10.10.15 -oN maquina_lab.nmap

Pásalo por tu IA personalizada:

Bash

cat maquina_lab.nmap | ollama run pentester-ia

¿Por qué esto es mejor?

Precisión: Al bajar la temperature a 0.2, la IA se ciñe a los hechos del escaneo.
Metodología: No solo te dice qué hay, sino que te da comandos listos para copiar y pegar (como rutas de msfconsole).
Contexto: Sabe que estás en Kali, por lo que te sugerirá herramientas que ya tienes instaladas.

Un pequeño truco de experto:

Si quieres que el análisis sea aún más profundo, puedes usar el flag -sC en Nmap para que corra los scripts por defecto (NSE). Los resultados de esos scripts le dan a la IA "pistas" de oro sobre vulnerabilidades reales.

Vamos a crear un script en Python que automatice todo el flujo: desde leer el archivo XML de Nmap, procesarlo con tu modelo de Ollama (pentester-ia), hasta generar un reporte limpio en formato PDF.

Esto es extremadamente útil para entregar reportes rápidos de auditoría o simplemente para tener un registro organizado de tus laboratorios.

1. Requisitos previos

Primero, instalaremos las librerías necesarias en tu Kali. Abre la terminal y ejecuta:

Bash

pip install python-nmap fpdf ollama

python-nmap: Para parsear los datos del escaneo.
fpdf: Para generar el documento PDF.
ollama: La librería oficial para comunicarnos con tu modelo local.

2. El Script: `nmap_report_ai.py`

Crea un archivo llamado nmap_report_ai.py y pega el siguiente código:

Python
import ollama
import nmap
from fpdf import FPDF
import sys

def analyze_with_ai(scan_data):
    print("[+] Enviando datos a la IA (Ollama)...")
    response = ollama.run(model='pentester-ia', prompt=f"Analiza técnicamente estos resultados de Nmap y sugiere vectores de ataque:\n{scan_data}")
    return response['response']

def generate_pdf(text, filename="Reporte_Pentest_AI.pdf"):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", 'B', 16)
    pdf.cell(200, 10, txt="Reporte de Auditoría - Nmap + AI", ln=True, align='C')
    pdf.ln(10)
    
    pdf.set_font("Arial", size=11)
    # Reemplazamos caracteres que FPDF no maneja bien para evitar errores
    clean_text = text.encode('latin-1', 'ignore').decode('latin-1')
    pdf.multi_cell(0, 10, txt=clean_text)
    
    pdf.output(filename)
    print(f"[+] Reporte PDF generado con éxito: {filename}")

def main():
    if len(sys.argv) < 2:
        print("Uso: python3 nmap_report_ai.py <archivo_nmap.xml>")
        return

    xml_file = sys.argv[1]
    
    # Extraer texto relevante del XML (puedes pasar el contenido crudo si es pequeño)
    with open(xml_file, 'r') as f:
        scan_content = f.read()

    # Obtener análisis de la IA
    analysis = analyze_with_ai(scan_content)
    
    # Crear el PDF
    generate_pdf(analysis)

if __name__ == "__main__":
    main()

3. Cómo usarlo (Paso a Paso)

Realiza un escaneo y expórtalo a XML:

Bash

nmap -sV -sC 192.168.1.10 -oX scan_objetivo.xml

Ejecuta el script:

Bash

python3 nmap_report_ai.py scan_objetivo.xml

Resultado: El script consultará a tu modelo pentester-ia, procesará la respuesta y te dejará un archivo llamado Reporte_Pentest_AI.pdf en la misma carpeta.

¿Por qué este flujo es potente?

Al automatizar esto, conviertes datos crudos y difíciles de leer en un documento estructurado que incluye:

Resumen de servicios.
Análisis de criticidad.
Comandos sugeridos para el siguiente paso (ej: dirb, msfconsole).

Nota técnica: Si el archivo XML es demasiado grande (muchos hosts), la IA podría confundirse o cortarse. En esos casos, es mejor filtrar el XML para pasarle solo los puertos abiertos de un host a la vez.

¡Esta es la "guinda del pastel"! Para que el script no solo use el conocimiento interno de la IA, sino que busque exploits reales y actualizados, vamos a integrar Searchsploit (la herramienta de línea de comandos para la base de datos de Exploit-DB) que ya viene preinstalada en Kali.

Aquí tienes la versión mejorada del script. Ahora el flujo será:

Nmap detecta la versión del servicio (ej. Apache 2.4.49).
Searchsploit busca archivos .py, .rb o .c relacionados.
La IA recibe ambos datos y redacta el reporte final en el PDF.

El Script: `nmap_ai_exploit.py`

Copia este código en un nuevo archivo:

Python
import ollama
import subprocess
import sys
import os
from fpdf import FPDF

def run_searchsploit(service_info):
    """Busca exploits locales para un servicio específico."""
    print(f"[*] Buscando exploits para: {service_info}")
    try:
        # Ejecutamos searchsploit y capturamos la salida
        result = subprocess.check_output(['searchsploit', service_info], stderr=subprocess.STDOUT).decode('utf-8')
        return result
    except subprocess.CalledProcessError:
        return "No se encontraron exploits específicos."

def analyze_with_ai(nmap_data, exploits):
    """Combina Nmap + Searchsploit y lo envía a la IA."""
    print("[+] Generando análisis inteligente...")
    prompt = f"""
    Analiza estos resultados de Nmap:
    {nmap_data}
    
    He encontrado estos exploits potenciales en Searchsploit:
    {exploits}
    
    Por favor, redacta un informe de seguridad que incluya:
    1. Resumen de hosts y puertos.
    2. Análisis de criticidad basado en los exploits encontrados.
    3. Comandos exactos para probar los exploits (si aplican).
    4. Recomendaciones de mitigación.
    Responde en español y formato técnico.
    """
    response = ollama.run(model='pentester-ia', prompt=prompt)
    return response['response']

def generate_pdf(content):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Courier", size=10) # Fuente tipo terminal para estilo hacking
    pdf.multi_cell(0, 5, txt=content.encode('latin-1', 'ignore').decode('latin-1'))
    pdf.output("Reporte_Final_Pentest.pdf")
    print("[✔] PDF 'Reporte_Final_Pentest.pdf' generado.")

def main():
    if len(sys.argv) < 2:
        print("Uso: python3 nmap_ai_exploit.py <objetivo>")
        return

    target = sys.argv[1]
    
    # 1. Ejecutar Nmap rápido para obtener servicios
    print(f"[*] Escaneando {target}...")
    nmap_raw = subprocess.check_output(['nmap', '-sV', '--top-ports', '50', target]).decode('utf-8')
    
    # 2. Buscar exploits (Simulamos una búsqueda general basada en el output de nmap)
    # Nota: En un script pro, filtraríamos cada línea, aquí le pasamos el bloque clave.
    exploits = run_searchsploit(target) 

    # 3. IA y PDF
    analisis = analyze_with_ai(nmap_raw, exploits)
    generate_pdf(analisis)

if __name__ == "__main__":
    main()

¿Cómo funciona este ecosistema?

Escaneo Dinámico: El script lanza el comando de Nmap por ti.
Consulta Local: Usa la base de datos de exploits de tu propia máquina (sin enviar nada a internet, manteniendo el anonimato).
Cerebro IA: El modelo pentester-ia que creamos antes actúa como el "traductor", explicando cómo usar esos archivos de Searchsploit que a veces son difíciles de entender.

Para ejecutarlo:

Simplemente dale permisos de ejecución y lánzalo contra una IP de tu laboratorio (ej. una máquina de TryHackMe o HackTheBox):

Bash

python3 nmap_ai_exploit.py 10.10.10.15

Próximos pasos sugeridos

Este script es una base sólida. Si quieres llevarlo al siguiente nivel, podrías:

Añadir búsqueda de directorios: Que el script lance gobuster si detecta el puerto 80/443 abierto y le pase los resultados a la IA.
Interfaz Web: Crear una pequeña interfaz con Streamlit para ver los reportes en el navegador de Kali.

Para esto usaremos Streamlit, que es una librería de Python increíblemente sencilla para crear interfaces web rápidas sin saber HTML o CSS.

Esto transformará tu script de terminal en un Panel de Control de Pentesting donde verás los resultados de Nmap, la lista de exploits y el análisis de la IA en tiempo real, con botones para descargar el PDF.

1. Instalar Streamlit

En tu terminal de Kali, instala la librería:

Bash

pip install streamlit

2. Crear el Dashboard: `app_pentest.py`

Crea un nuevo archivo llamado app_pentest.py y pega este código (que integra todo lo anterior):

Python
import streamlit as st
import ollama
import subprocess
from fpdf import FPDF

# Configuración de la página
st.set_page_config(page_title="IA Pentest Dashboard", layout="wide")

st.title("🛡️ Panel de Auditoría con IA (Kali Linux)")
st.markdown("---")

# Barra lateral para configuración
target = st.sidebar.text_input("IP o Dominio Objetivo:", placeholder="192.168.1.1")
scan_btn = st.sidebar.button("Iniciar Auditoría Inteligente")

if scan_btn and target:
    col1, col2 = st.columns(2)
    
    with col1:
        with st.status("Ejecutando Nmap y Searchsploit...", expanded=True):
            st.write("🔍 Escaneando puertos...")
            nmap_res = subprocess.check_output(['nmap', '-sV', '--top-ports', '50', target]).decode('utf-8')
            st.write("📂 Buscando exploits locales...")
            exploit_res = subprocess.check_output(['searchsploit', target], stderr=subprocess.STDOUT).decode('utf-8')
        
        st.subheader("Resultados del Escaneo")
        st.code(nmap_res, language='bash')

    with col2:
        st.subheader("Análisis de Inteligencia Artificial")
        with st.spinner("La IA está procesando los vectores de ataque..."):
            prompt = f"Analiza estos datos de Nmap: {nmap_res} y estos exploits: {exploit_res}. Responde en español con pasos tácticos."
            response = ollama.run(model='pentester-ia', prompt=prompt)
            ai_analysis = response['response']
            st.markdown(ai_analysis)

    # Botón para descargar reporte
    st.markdown("---")
    if st.button("Generar Reporte PDF"):
        pdf = FPDF()
        pdf.add_page()
        pdf.set_font("Arial", size=11)
        pdf.multi_cell(0, 10, txt=ai_analysis.encode('latin-1', 'ignore').decode('latin-1'))
        pdf.output("reporte_web.pdf")
        st.success("Reporte guardado como 'reporte_web.pdf'")

elif not target:
    st.info("Introduce una dirección IP en la barra lateral para comenzar.")

3. Cómo lanzarlo

Para ver tu nueva herramienta en acción, ejecuta este comando en la terminal:

Bash

streamlit run app_pentest.py

Esto abrirá automáticamente una pestaña en tu navegador (usualmente en http://localhost:8501).

¿Cómo queda tu flujo de trabajo ahora?

Input: Escribes la IP en el cuadro de texto.
Visualización: En la izquierda ves la salida cruda del escaneo (lo que te da seguridad de qué está pasando).
Inteligencia: En la derecha, la IA te explica qué hacer con esos datos de forma legible.
Documentación: Con un clic generas el informe para tu cliente o para tu bitácora de estudio.

Un último consejo de "compañero":

Como estás corriendo Ollama y Streamlit en la misma máquina Kali, si tienes poca RAM (menos de 8GB), la interfaz del navegador podría volverse un poco lenta mientras la IA "piensa". Si eso pasa, puedes cerrar el navegador y volver al script de terminal que hicimos antes.

Añadir una barra de progreso real es un toque profesional, ya que los escaneos de Nmap pueden tardar desde unos segundos hasta varios minutos, y no hay nada peor que una pantalla congelada sin saber si el script sigue vivo.

Para lograr esto, usaremos la librería python-nmap de forma más avanzada, utilizando un "callback" (una función que se ejecuta cada vez que Nmap termina de escanear un puerto o un host).

1. Actualización del Script: `app_pentest_pro.py`

Aquí tienes el código actualizado con la barra de progreso interactiva de Streamlit:

Python
import streamlit as st
import ollama
import nmap
import subprocess
import time

st.set_page_config(page_title="IA Pentest Pro", layout="wide")

st.title("🛡️ Panel de Auditoría con IA + Progreso Real")

# Inicializar el escáner de Nmap
nm = nmap.PortScanner()

target = st.sidebar.text_input("IP o Dominio Objetivo:", placeholder="192.168.1.1")
scan_btn = st.sidebar.button("Lanzar Escaneo Completo")

if scan_btn and target:
    # --- SECCIÓN DE PROGRESO ---
    progress_bar = st.progress(0)
    status_text = st.empty()
    
    status_text.text("Iniciando Nmap...")
    progress_bar.progress(10)
    
    # Ejecutamos el escaneo de forma asíncrona para simular el progreso
    # (Nmap no da un % exacto nativo fácilmente, así que simulamos fases técnicas)
    try:
        # Fase 1: Host Discovery
        status_text.text("🔍 Fase 1: Descubriendo Host...")
        nm.scan(hosts=target, arguments='-sn')
        progress_bar.progress(30)
        time.sleep(0.5)

        # Fase 2: Service & Version Detection
        status_text.text("   Fase 2: Detectando servicios y versiones (esto puede tardar)...")
        nm.scan(hosts=target, arguments='-sV --top-ports 50')
        progress_bar.progress(70)

        # Fase 3: Searchsploit
        status_text.text("📂 Fase 3: Consultando Base de Datos de Exploits...")
        exploit_res = subprocess.check_output(['searchsploit', target], stderr=subprocess.STDOUT).decode('utf-8')
        progress_bar.progress(90)
        
        status_text.text("✅ Escaneo completado. Procesando con IA...")
        progress_bar.progress(100)

        # --- MOSTRAR RESULTADOS ---
        col1, col2 = st.columns(2)
        
        with col1:
            st.subheader("Puerto / Servicio / Versión")
            for host in nm.all_hosts():
                for proto in nm[host].all_protocols():
                    lport = nm[host][proto].keys()
                    for port in lport:
                        st.info(f"Puerto: {port} | Servicio: {nm[host][proto][port]['name']} | Versión: {nm[host][proto][port]['version']}")
            
            with st.expander("Ver salida cruda de Searchsploit"):
                st.code(exploit_res)

        with col2:
            st.subheader("Análisis Estratégico (IA)")
            # Enviamos el resumen estructurado de NM a la IA
            nmap_summary = str(nm[target]) if target in nm.all_hosts() else "No se detectaron puertos abiertos."
            response = ollama.run(model='pentester-ia', prompt=f"Analiza este diccionario de Nmap y estos exploits: {nmap_summary} \n {exploit_res}. Responde en español.")
            st.markdown(response['response'])

    except Exception as e:
        st.error(f"Error durante el escaneo: {e}")

else:
    st.info("Configura el objetivo en el menú lateral para empezar.")

2. ¿Qué ha cambiado técnicamente?

Lógica por etapas: En lugar de lanzar un comando subprocess "ciego", usamos la librería nmap para dividir el proceso en:
- Host Discovery (30%): Confirmamos que el objetivo está vivo.
- Service Detection (70%): La parte más pesada donde Nmap analiza banners.
- Searchsploit (90%): El cruce de datos final.
Feedback Visual: El usuario ve status_text cambiando en tiempo real (ej: "Detectando versiones..."), lo que reduce la percepción de espera.
Resultados Limpios: En lugar de una caja de texto gigante, ahora iteramos sobre los resultados para mostrar tarjetas con los puertos (st.info), lo que facilita mucho la lectura.

3. Ejecución

Como antes, guarda y lanza:

Bash

streamlit run app_pentest_pro.py

Un consejo final de seguridad:

Si vas a usar este panel fuera de tu red local (por ejemplo, en un servidor VPS), asegúrate de ponerle una contraseña o usar un túnel SSH, ya que cualquier persona que entre a la IP de Streamlit podría lanzar escaneos de Nmap desde tu máquina Kali.

Esta es una de las funciones más útiles en auditorías reales, ya que te permite ver si un administrador ha cerrado un puerto tras un reporte o si han aparecido nuevos servicios vulnerables.

Para esto, utilizaremos una base de datos local muy ligera llamada SQLite (que ya viene con Python) para guardar los resultados de cada escaneo.

1. El Script Evolucionado: `app_pentest_history.py`

Copia este código. He añadido una sección de "Historial" en la barra lateral y la lógica para guardar los datos en una base de datos (pentest_history.db).

Python
import streamlit as st
import ollama
import nmap
import sqlite3
from datetime import datetime
import pandas as pd

# --- CONFIGURACIÓN DE BASE DE DATOS ---
def init_db():
    conn = sqlite3.connect('pentest_history.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS scans 
                 (id INTEGER PRIMARY KEY, date TEXT, target TEXT, report TEXT)''')
    conn.commit()
    conn.close()

def save_scan(target, report):
    conn = sqlite3.connect('pentest_history.db')
    c = conn.cursor()
    date_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    c.execute("INSERT INTO scans (date, target, report) VALUES (?, ?, ?)", (date_str, target, report))
    conn.commit()
    conn.close()

# --- INTERFAZ STREAMLIT ---
st.set_page_config(page_title="Pentest Tracker IA", layout="wide")
init_db()

st.title("🛡️ Pentest Tracker + Historial de IA")

# Barra lateral
st.sidebar.header("Nuevo Escaneo")
target = st.sidebar.text_input("Objetivo (IP/Dominio):")
scan_btn = st.sidebar.button("Ejecutar Auditoría")

st.sidebar.markdown("---")
st.sidebar.header("📜 Historial de Escaneos")

# Cargar historial para la barra lateral
conn = sqlite3.connect('pentest_history.db')
history_df = pd.read_sql_query("SELECT id, date, target FROM scans ORDER BY id DESC", conn)
conn.close()

# Mostrar historial en la barra lateral
if not history_df.empty:
    selected_scan_id = st.sidebar.selectbox("Ver escaneo anterior:", history_df['id'], 
                                            format_func=lambda x: f"{history_df.loc[history_df['id']==x, 'date'].values[0]} - {history_df.loc[history_df['id']==x, 'target'].values[0]}")
    if st.sidebar.button("Cargar Reporte Histórico"):
        conn = sqlite3.connect('pentest_history.db')
        old_report = conn.execute("SELECT report FROM scans WHERE id=?", (selected_scan_id,)).fetchone()[0]
        conn.close()
        st.subheader(f"Cargando reporte histórico de: {history_df.loc[history_df['id']==selected_scan_id, 'target'].values[0]}")
        st.markdown(old_report)

# --- LÓGICA DE ESCANEO NUEVO ---
if scan_btn and target:
    with st.spinner(f"Analizando {target}..."):
        nm = nmap.PortScanner()
        nm.scan(hosts=target, arguments='-sV --top-ports 20')
        
        # Resumen para la IA
        scan_summary = ""
        for host in nm.all_hosts():
            for proto in nm[host].all_protocols():
                for port in nm[host][proto].keys():
                    service = nm[host][proto][port]
                    scan_summary += f"Puerto {port}: {service['name']} {service['version']}\n"
        
        # Consulta a Ollama
        response = ollama.run(model='pentester-ia', 
                             prompt=f"Analiza estos puertos y sugiere ataques: {scan_summary}")
        report_text = response['response']
        
        # Guardar en DB
        save_scan(target, report_text)
        
        st.success("¡Escaneo finalizado y guardado en el historial!")
        st.markdown(report_text)

2. ¿Cómo funciona el historial?

Persistencia: Cada vez que haces un escaneo, el resultado de la IA se guarda en un archivo pentest_history.db en tu carpeta de Kali. Aunque apagues la computadora, los datos no se pierden.
Comparación: Puedes abrir dos pestañas del navegador para comparar un escaneo de "hace un mes" con el "actual" y ver qué ha cambiado en la infraestructura.
Selección Rápida: La barra lateral se actualiza automáticamente con la fecha y la IP del objetivo.

3. Instalación de dependencias extra

Para que este script funcione, asegúrate de tener pandas instalado:

Bash

pip install pandas

Un consejo de flujo de trabajo:

Con esta herramienta, has construido básicamente un mini-Vulnerability Management System (VMS).

Si en algún momento quieres borrar el historial para empezar de cero, solo tienes que borrar el archivo de la base de datos:

Bash

rm pentest_history.db