> For the complete documentation index, see [llms.txt](https://oliver-3.gitbook.io/redteam-notes/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://oliver-3.gitbook.io/redteam-notes/recursos/guia-ollama-openwebui.md).

# Guia Ollama-openwebui

### Stack de IA Local para Pentesting y Ciberseguridad

> **Autor:** Oliver\
> **Plataforma:** Kali

***

## Introducción

Esta guía documenta la implementación de un stack completo de inteligencia artificial local, privado y seguro, orientado a profesionales de ciberseguridad y ethical hacking.

### ¿Por qué IA local?

| IA en la nube                        | IA local (este stack)             |
| ------------------------------------ | --------------------------------- |
| Datos enviados a servidores externos | Todo permanece en tu máquina      |
| Requiere internet                    | Funciona offline                  |
| Costo mensual                        | 100% gratuito                     |
| Sin control sobre el modelo          | Elegís el modelo                  |
| Limitaciones de contenido            | Sin restricciones para pentesting |

### Componentes del Stack

| Componente     | Función                                  |
| -------------- | ---------------------------------------- |
| **VirtualBox** | Virtualización — aislamiento del entorno |
| **Kali Linux** | Sistema operativo base para pentesting   |
| **Ollama**     | Motor de inferencia local para LLMs      |
| **Open WebUI** | Interfaz gráfica web para los modelos    |
| **Docker**     | Contenedor para Open WebUI               |

## Requisitos del Sistema

### Hardware mínimo recomendado

| Recurso  | Mínimo    | Recomendado       |
| -------- | --------- | ----------------- |
| RAM Host | 16 GB     | 32 GB             |
| RAM VM   | 8 GB      | 16 GB             |
| CPU      | 4 núcleos | 8 núcleos         |
| Disco VM | 80 GB     | 120 GB+           |
| GPU      | —         | NVIDIA (opcional) |

> ⚠️ **Nota sobre GPU:** VirtualBox no soporta GPU passthrough NVIDIA. Los modelos corren en CPU dentro de la VM. Para uso con GPU, considerá instalación bare metal o WSL2.

### Software requerido

* [VirtualBox 7.x](https://www.virtualbox.org/wiki/Downloads) — gratuito
* [Kali Linux OVA 2026.1](https://www.kali.org/get-kali/#kali-virtual-machines) — imagen preconfigurada
* Conexión a internet para descarga inicial

***

## Preparación de la Máquina Virtual

{% tabs %}
{% tab title="Opción A — Importar OVA (recomendado, más rápido)" %}

1. Descargá el OVA de Kali Linux desde [kali.org/get-kali](https://www.kali.org/get-kali/#kali-virtual-machines)
2. En VirtualBox: `File → Import Appliance → seleccioná el .ova`
3. **Antes de confirmar**, ajustá:
   * RAM: `16384 MB`
   * CPU: `6 núcleos`

**Expandir el disco del OVA a 120 GB**

La imagen OVA viene con \~80 GB. Para expandirla, con la VM **completamente apagada**, abrí CMD como Administrador en Windows:

```cmd
"C:\Archivos de Programa\Oracle\VirtualBox\VBoxManage.exe" modifyhd "RUTA\kali-linux-2026.1-virtualbox-amd64.vdi" --resize 122880
```

> Reemplazá `RUTA` con la ruta real del archivo VDI.

Luego, dentro de Kali, expandí la partición:

```bash
sudo growpart /dev/sda 1
sudo resize2fs /dev/sda1
df -h  # Verificar
```

{% endtab %}

{% tab title="Opción B — Instalación desde ISO" %}

1. Descargá la ISO **Installer** (no Live) de 64-bit desde [kali.org](https://www.kali.org/get-kali/#kali-installer-images)
2. Creá una VM nueva en VirtualBox:
   * Tipo: `Linux / Debian 64-bit`
   * RAM: `16384 MB`
   * CPU: `6`
   * Disco: `120 GB` (VDI, reserva dinámica)
3. En `Settings → System → Processor`: habilitá `Enable PAE/NX`
4. En `Settings → Display`: Video Memory `128 MB`, controlador `VMSVGA`
   {% endtab %}
   {% endtabs %}

### Configuración post-importación

En `Settings` de la VM antes de arrancar:

```
System → Motherboard → RAM: 16384 MB
System → Processor → CPU: 6
Display → Video Memory: 128 MB
```

### Guest Additions (importante)

```bash
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y build-essential dkms linux-headers-$(uname -r)

# En VirtualBox: Devices → Insert Guest Additions CD
sudo mount /dev/cdrom /mnt
sudo /mnt/VBoxLinuxAdditions.run
sudo reboot
```

***

## Instalación de Ollama

### Actualizar el sistema

```bash
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y curl wget gnupg2 ca-certificates ufw
```

### Instalar Ollama

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

### Verificar instalación

```bash
ollama --version
systemctl status ollama
```

Deberías ver:

```
● ollama.service - Ollama Service
     Active: active (running)
```

***

## Hardening de Ollama

Por defecto, Ollama escucha en `0.0.0.0:11434` — esto expone el servicio a toda la red. **Hay que restringirlo a localhost.**

{% tabs %}
{% tab title="Script automatizado" %}
Descargá y ejecutá el script de hardening:

```bash
# Guardá el script en tu máquina
sudo nano /opt/setup_ollama.sh
# (pegá el contenido del script)
sudo bash /opt/setup_ollama.sh
```

{% endtab %}

{% tab title="Configuración manual paso a paso" %}
{% stepper %}
{% step %}

### 1. Crear el directorio de modelos

```bash
sudo mkdir -p /opt/ollama/models
sudo chown -R ollama:ollama /opt/ollama/models
chmod 750 /opt/ollama/models
```

{% endstep %}

{% step %}

### 2. Crear el override de systemd

```bash
sudo mkdir -p /etc/systemd/system/ollama.service.d/
sudo nano /etc/systemd/system/ollama.service.d/override.conf
```

Contenido del archivo:

```ini
[Service]
# ── Red: solo localhost ───────────────────────────────────────
Environment="OLLAMA_HOST=127.0.0.1:11434"

# ── Directorio de modelos ─────────────────────────────────────
Environment="OLLAMA_MODELS=/opt/ollama/models"

# ── Límites de recursos ───────────────────────────────────────
CPUQuota=80%
MemoryMax=8G
TasksMax=64

# ── Hardening systemd ─────────────────────────────────────────
NoNewPrivileges=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectSystem=strict
ProtectHome=yes
ReadWritePaths=/opt/ollama/models
ProtectKernelTunables=yes
ProtectKernelModules=yes
ProtectControlGroups=yes
RestrictSUIDSGID=yes
LockPersonality=yes
RestrictRealtime=yes
```

> ⚠️ **Error común:** Si usás `systemctl edit ollama` y cerrás sin escribir nada, el archivo queda vacío y genera un warning. Editá siempre con `nano` directamente.
> {% endstep %}

{% step %}

### 3. Hardening del usuario del servicio

```bash
# Sin shell interactiva
sudo usermod -s /usr/sbin/nologin ollama

# Bloquear login directo
sudo passwd -l ollama
```

{% endstep %}

{% step %}

### 4. Configurar UFW

```bash
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp          # SSH
sudo ufw deny 11434/tcp        # Bloquear Ollama externamente
sudo ufw enable
sudo ufw status verbose
```

{% endstep %}

{% step %}

### 5. Aplicar cambios

```bash
sudo systemctl daemon-reload
sudo systemctl restart ollama
sudo systemctl enable ollama
```

{% endstep %}

{% step %}

### 6. Verificar hardening

```bash
# Debe mostrar 127.0.0.1:11434 (NO 0.0.0.0)
ss -tlnp | grep 11434

# Test de API
curl http://127.0.0.1:11434/api/tags
```

{% endstep %}
{% endstepper %}
{% endtab %}
{% endtabs %}

***

## Modelos de Lenguaje Recomendados

### Selección según RAM disponible

| RAM VM | Modelos recomendados                       |
| ------ | ------------------------------------------ |
| 8 GB   | llama3.2, mistral                          |
| 16 GB  | llama3.2, mistral, gemma2, qwen3.5, gemma4 |
| 32 GB+ | Todos + modelos 30B+                       |

### Descargar modelos

```bash
# Stack completo para 16 GB
ollama pull llama3.2    # 2.0 GB — rápido, liviano
ollama pull mistral     # 4.4 GB — redacción y análisis
ollama pull gemma2      # 5.4 GB — razonamiento general
ollama pull qwen3.5     # 6.6 GB — código y multilenguaje
ollama pull gemma4      # 9.6 GB — el más potente
```

### Tabla de modelos y usos para pentesting

| Modelo     | Tamaño | Mejor para                           |
| ---------- | ------ | ------------------------------------ |
| `llama3.2` | 2 GB   | Consultas rápidas, scripting bash    |
| `mistral`  | 4.4 GB | Redacción de reportes, análisis      |
| `gemma2`   | 5.4 GB | Razonamiento, explicaciones técnicas |
| `qwen3.5`  | 6.6 GB | Código Python/Bash, CTFs             |
| `gemma4`   | 9.6 GB | Pentesting avanzado, exploits        |

### Verificar modelos instalados

```bash
ollama list
```

***

## Instalación de Open WebUI

Open WebUI provee una interfaz web moderna para interactuar con los modelos de Ollama.

### Prerequisitos — Docker

```bash
sudo apt install -y docker.io
sudo systemctl start docker
sudo systemctl enable docker
sudo usermod -aG docker $USER
newgrp docker
```

### Desplegar Open WebUI

```bash
docker run -d \
  --name open-webui \
  --network=host \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  --restart always \
  ghcr.io/open-webui/open-webui:main
```

### Verificar despliegue

```bash
docker ps | grep open-webui
```

La columna `STATUS` debe mostrar `Up X minutes (healthy)`.

### Acceder a la interfaz

Abrí el navegador en:

```
http://127.0.0.1:8080
```

> ⚠️ **Nota sobre puertos:** Dependiendo de la versión, Open WebUI puede mapear al puerto `3000` en lugar de `8080`. Verificá con `docker ps` qué puerto está mapeado.

### Crear cuenta administrador

El **primer usuario** que se registra queda automáticamente como administrador. Creá tu cuenta con una contraseña segura (mínimo 12 caracteres, con mayúsculas, números y símbolos).

***

## Hardening de Open WebUI

{% tabs %}
{% tab title="Script automatizado" %}

```bash
sudo bash hardening_openwebui.sh
```

{% endtab %}

{% tab title="Configuración manual" %}

#### Recrear el contenedor con opciones de seguridad

```bash
# Generar secret key segura
SECRET_KEY=$(openssl rand -hex 32)

# Detener y eliminar contenedor actual
docker stop open-webui && docker rm open-webui

# Recrear con hardening
docker run -d \
    --name open-webui \
    --network host \
    --restart unless-stopped \
    --memory="2g" \
    --cpus="2" \
    --read-only \
    --tmpfs /tmp \
    --tmpfs /run \
    --security-opt no-new-privileges:true \
    -v open-webui:/app/backend/data \
    -e OLLAMA_BASE_URL="http://127.0.0.1:11434" \
    -e WEBUI_SECRET_KEY="${SECRET_KEY}" \
    -e WEBUI_AUTH=true \
    -e DEFAULT_USER_ROLE="user" \
    -e ENABLE_SIGNUP=false \
    -e WEBUI_SESSION_COOKIE_SAME_SITE="strict" \
    -e ENABLE_COMMUNITY_SHARING=false \
    -e CORS_ALLOW_ORIGIN="http://127.0.0.1:8080" \
    ghcr.io/open-webui/open-webui:main
```

**Explicación de los parámetros de seguridad**

| Parámetro             | Descripción                                        |
| --------------------- | -------------------------------------------------- |
| `--read-only`         | Sistema de archivos del contenedor en solo lectura |
| `--tmpfs /tmp`        | /tmp en RAM, no en disco                           |
| `--no-new-privileges` | Previene escalada de privilegios                   |
| `--memory="2g"`       | Límite de RAM para el contenedor                   |
| `ENABLE_SIGNUP=false` | Bloquea nuevos registros                           |
| `CORS_ALLOW_ORIGIN`   | Solo acepta requests desde localhost               |
| `WEBUI_SECRET_KEY`    | Clave única para firmar sesiones                   |

**UFW — bloquear puerto 8080 externamente**

```bash
sudo ufw deny 8080/tcp
sudo ufw status
```

**Rate limiting anti-bruteforce**

```bash
sudo iptables -I INPUT -p tcp --dport 8080 \
    -m conntrack --ctstate NEW \
    -m limit --limit 20/min --limit-burst 5 \
    -j ACCEPT
```

**Configurar logging con rotación**

```bash
sudo nano /etc/docker/daemon.json
```

```json
{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "10m",
    "max-file": "3"
  },
  "no-new-privileges": true,
  "live-restore": true
}
```

```bash
sudo systemctl restart docker
docker start open-webui
```

#### Checklist de hardening

```
✅ Ollama vinculado solo a 127.0.0.1:11434
✅ Open WebUI en 127.0.0.1:8080
✅ ENABLE_SIGNUP=false
✅ SECRET_KEY generada aleatoriamente
✅ Contenedor --read-only
✅ Límites de RAM y CPU aplicados
✅ UFW bloqueando puertos 8080 y 11434 externamente
✅ Rate limiting activo
✅ Log rotation configurado
✅ Usuario ollama sin shell interactiva
✅ Hardening systemd aplicado
```

{% endtab %}
{% endtabs %}

***

## Agentes de Pentesting

Los agentes son modelos con **system prompts especializados** que los convierten en expertos en áreas específicas.

### Cómo crear un agente

```
Open WebUI → Workspace → Models → + New Model
→ Name: [nombre]
→ Base Model: [modelo elegido]
→ System Prompt: [prompt especializado]
→ Save
```

***

### Agente 1 — ReconBot

**Especialidad:** OSINT, reconocimiento pasivo y activo\
**Modelo recomendado:** `qwen3.5:latest`

**System Prompt:**

```
Eres ReconBot, un experto en reconocimiento pasivo y activo, OSINT y 
enumeración de infraestructura para ethical hacking y pentesting profesional. 
Operás exclusivamente en entornos con autorización explícita.

Especialidades:
- Reconocimiento pasivo: subfinder, amass, crt.sh, shodan, theHarvester
- Reconocimiento activo: nmap (NSE scripts, timing, stealth), masscan
- Enumeración DNS: dnsenum, fierce, dnsrecon, dnsx
- OSINT: Google Dorks, metadatos, WHOIS, ASN, Wayback Machine
- Fingerprinting: whatweb, httpx, aquatone, eyewitness

Formato de respuesta:
OBJETIVO: [qué se busca]
METODOLOGÍA: [pasos ordenados]
COMANDOS**: [con flags explicadas]
INTERPRETACIÓN: [cómo leer los resultados]
SIGUIENTE PASO: [qué hacer con esa info]

Siempre indicá el nivel de ruido/detección de cada técnica.
Diferenciá claramente técnicas pasivas de activas.
```

***

### Agente 2 — WebHunter

**Especialidad:** Web App Security, Burp Suite, OWASP\
**Modelo recomendado:** `gemma4:latest`

**System Prompt:**

```
Eres WebHunter, especialista en seguridad de aplicaciones web con profundo 
conocimiento del OWASP Top 10, bug bounty y Burp Suite Professional.
Trabajás exclusivamente en entornos autorizados.

Especialidades OWASP Top 10:
- SQLi manual y con sqlmap, XSS reflected/stored/DOM, XXE, SSTI
- SSRF con bypass de filtros y protocolos alternativos
- IDOR, privilege escalation, path traversal
- JWT attacks, session fixation, CSRF bypass
- Análisis de headers HTTP, CORS, SSL/TLS

Burp Suite:
- Intruder (Sniper, Battering Ram, Pitchfork, Cluster Bomb)
- Extensions: Autorize, JWT Editor, ActiveScan++, Turbo Intruder
- Macros para sesiones autenticadas
- Configuración de scope y project options

Formato de respuesta:
**VULNERABILIDAD**: [nombre + CWE]
**DESCRIPCIÓN**: [qué es y por qué es explotable]
**DETECCIÓN**: [cómo identificarla]
**EXPLOTACIÓN**: [pasos + payloads]
**BURP SUITE**: [cómo usar Burp para este caso]
**REMEDIACIÓN**: [cómo se parchea]
**SEVERIDAD**: [Crítica/Alta/Media/Baja + CVSS aproximado]
```

***

### Agente 3 — ExploitDev

**Especialidad:** Metasploit, post-explotación, escalada de privilegios\
**Modelo recomendado:** `gemma4:latest`

**System Prompt:**

```
Eres ExploitDev, especialista en frameworks de explotación y post-explotación.
Operás exclusivamente en laboratorios controlados, CTFs y pentesting autorizado
(HackTheBox, TryHackMe, VulnHub, contratos documentados).

Especialidades:
- Metasploit: módulos exploit/auxiliary/post, meterpreter completo
- msfvenom: generación de payloads (staged vs stageless, encoders)
- Escalada Linux: SUID, sudo, cron, capabilities, kernel exploits
- Escalada Windows: token impersonation, DLL hijacking, unquoted paths
- Pivoting: port forwarding, proxychains, socks proxy
- Post-explotación: hashdump, persistencia, lateral movement

Formato de respuesta:
**CVE / VULNERABILIDAD**: [identificador]
**ENTORNO**: [OS, servicio, versión afectada]
**METASPLOIT**:
  use [módulo]
  set RHOSTS [target]
  set PAYLOAD [payload]
  set LHOST [tu IP]
  run
**POST-EXPLOTACIÓN**: [siguientes pasos]
**DETECCIÓN BLUE TEAM**: [cómo lo detectaría la defensa]

REGLA CRÍTICA: Siempre incluís perspectiva defensiva.
Solo describís técnicas para entornos autorizados.
```

***

### Agente 4 — KaliAssist

**Especialidad:** Kali Linux, herramientas, scripting\
**Modelo recomendado:** `mistral:latest`

**System Prompt:**

```
Eres KaliAssist, experto en Kali Linux para profesionales de ciberseguridad.
Dominás todas las herramientas, comandos y metodologías del sistema.

Especialidades por categoría:
- Information Gathering: nmap, recon-ng, maltego, theHarvester
- Web Application: burpsuite, zaproxy, sqlmap, gobuster, ffuf
- Password Attacks: john, hashcat, hydra, medusa, crunch
- Wireless: aircrack-ng, wifite, kismet, reaver
- Exploitation: metasploit, searchsploit, beef-xss
- Sniffing: wireshark, tcpdump, ettercap, bettercap
- Forensics: volatility, autopsy, binwalk, foremost
- Scripting: bash para automatización, python para herramientas custom

Reglas de formato:
- Comandos SIEMPRE en bloques de código con flags explicadas
- Indicá si requiere root (sudo)
- Ofrecé alternativas cuando hay múltiples herramientas
- Explicá la causa de errores y la solución
```

***

### Agente 5 — CTFSolver

**Especialidad:** Capture The Flag, HTB, THM\
**Modelo recomendado:** `gemma4:latest`

**System Prompt:**

```
Eres CTFSolver, experto en CTFs con experiencia en HackTheBox, TryHackMe,
PicoCTF y VulnHub. Guiás el razonamiento sin dar soluciones directas.

Categorías:
- Web: SQLi, XSS, SSRF, LFI, deserialization, JWT, SSTI
- Crypto: RSA, AES-ECB, XOR, análisis de frecuencias, encodings
- Reversing: ghidra, radare2, análisis estático y dinámico
- Pwn: buffer overflow, ROP chains, format strings, pwntools
- Stego: steghide, zsteg, stegsolve, audacity (espectrograma)
- Forensics: volatility3, wireshark, autopsy, strings
- OSINT: geolocalización, búsqueda inversa, metadatos

Metodología:
1. Identificar categoría del challenge
2. Análisis inicial de la información disponible
3. Pistas progresivas (de menos a más específicas)
4. Herramientas sugeridas
5. Comandos de ejemplo (sin revelar la flag)
6. Explicación del concepto para aprendizaje

REGLA: Nunca das la flag directamente. Enseñás el razonamiento.
Siempre referenciás: HackTricks, GTFOBins, PayloadsAllTheThings.
```

***

## Knowledge Base (RAG)

El sistema RAG (Retrieval-Augmented Generation) permite a los modelos responder basándose en documentos propios.

### Descargar documentos base

```bash
mkdir -p ~/pentest-knowledge && cd ~/pentest-knowledge

# OWASP Testing Guide v4.2
wget -O "OWASP-Testing-Guide-v4.2.pdf" \
  "https://github.com/OWASP/wstg/releases/download/v4.2/wstg-v4.2.pdf"

# OWASP Top 10 2021
wget -O "OWASP-Top10-2021.pdf" \
  "https://owasp.org/www-pdf-archive/OWASP_Top_10-2021_en.pdf"

# PayloadsAllTheThings
wget -O "SQLi-payloads.md" \
  "https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/SQL%20Injection/README.md"

wget -O "XSS-payloads.md" \
  "https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/XSS%20Injection/README.md"

wget -O "SSRF-payloads.md" \
  "https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/Server%20Side%20Request%20Forgery/README.md"

wget -O "FileInclusion-payloads.md" \
  "https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/File%20Inclusion/README.md"

wget -O "CommandInjection-payloads.md" \
  "https://raw.githubusercontent.com/swisskyrepo/PayloadsAllTheThings/master/Command%20Injection/README.md"

ls -lh ~/pentest-knowledge/
```

### Crear Knowledge Bases en Open WebUI

```
Workspace → Knowledge → + New Knowledge
```

| Knowledge Base          | Descripción                      | Documentos                       |
| ----------------------- | -------------------------------- | -------------------------------- |
| `OWASP Guides`          | Documentación oficial OWASP      | OWASP-Testing-Guide, OWASP-Top10 |
| `Payloads & Techniques` | Payloads de PayloadsAllTheThings | Todos los .md descargados        |
| `Personal Notes`        | Tus writeups y notas propias     | Archivos personales              |

### Vincular Knowledge a los agentes

```
Workspace → Models → [Agente] → Edit
→ Knowledge → seleccioná las bases relevantes
→ Save
```

| Agente     | Knowledge recomendada                  |
| ---------- | -------------------------------------- |
| WebHunter  | OWASP Guides + Payloads & Techniques   |
| ExploitDev | Payloads & Techniques + Personal Notes |
| CTFSolver  | Payloads & Techniques                  |

### Probar el RAG

En el chat con WebHunter:

```
¿Cuáles son los pasos para testear SQL Injection según OWASP Testing Guide?
```

El modelo debería responder citando el documento con referencias.

***

## Verificación Final de Seguridad

Ejecutá este diagnóstico completo:

```bash
echo "════════ DIAGNÓSTICO COMPLETO ════════"

echo -e "\n[1] OLLAMA - Estado del servicio:"
systemctl is-active ollama

echo -e "\n[2] OLLAMA - Puerto de escucha:"
ss -tlnp | grep 11434
# Debe mostrar 127.0.0.1:11434 (NO 0.0.0.0)

echo -e "\n[3] OLLAMA - Override de seguridad:"
cat /etc/systemd/system/ollama.service.d/override.conf

echo -e "\n[4] DOCKER - Estado Open WebUI:"
docker ps --filter name=open-webui --format "{{.Names}}: {{.Status}}"

echo -e "\n[5] MODELOS disponibles:"
ollama list

echo -e "\n[6] UFW - Estado del firewall:"
sudo ufw status verbose

echo -e "\n[7] API OLLAMA - Test:"
curl -sf http://127.0.0.1:11434/api/tags && echo "✅ Ollama OK"

echo -e "\n[8] API WebUI - Test:"
curl -sf http://127.0.0.1:8080 -o /dev/null && echo "✅ Open WebUI OK"

echo -e "\n════════ FIN DEL DIAGNÓSTICO ════════"
```

### Resultados esperados

```
[1] active
[2] 127.0.0.1:11434  ← solo localhost
[3] [contenido del override.conf]
[4] open-webui: Up X hours (healthy)
[5] [lista de modelos]
[6] Status: active
    11434  DENY IN   Anywhere
    8080   DENY IN   Anywhere
    22/tcp ALLOW IN  Anywhere
[7] ✅ Ollama OK
[8] ✅ Open WebUI OK
```

***

## Mantenimiento y Monitoreo

### Script de monitoreo rápido

```bash
# Guardar como /usr/local/bin/webui-monitor
cat > /usr/local/bin/webui-monitor << 'EOF'
#!/bin/bash
echo "=== Open WebUI Status ==="
docker ps --filter name=open-webui --format "Status: {{.Status}}"
echo ""
echo "=== Ollama Status ==="
systemctl is-active ollama
echo ""
echo "=== Conexiones activas ==="
ss -tnp | grep -E "8080|11434"
echo ""
echo "=== Últimos logs Ollama ==="
journalctl -u ollama --since "30 min ago" --no-pager | tail -10
echo ""
echo "=== Últimos logs WebUI ==="
docker logs open-webui --tail 10 2>&1
EOF

chmod +x /usr/local/bin/webui-monitor
```

Ejecutar con:

```bash
webui-monitor
```

### Actualizar modelos

```bash
# Actualizar todos los modelos instalados
ollama list | awk 'NR>1 {print $1}' | xargs -I {} ollama pull {}
```

### Actualizar Open WebUI

```bash
docker pull ghcr.io/open-webui/open-webui:main
docker stop open-webui && docker rm open-webui
# Volver a ejecutar el comando docker run con hardening
```

### Backup de configuración

```bash
# Backup del volumen de Open WebUI
docker run --rm \
  -v open-webui:/data \
  -v $(pwd):/backup \
  alpine tar czf /backup/openwebui-backup-$(date +%Y%m%d).tar.gz /data

# Backup del override de Ollama
cp /etc/systemd/system/ollama.service.d/override.conf ~/ollama-override-backup.conf
```

***

## Recursos

| Recurso              | URL                                                        |
| -------------------- | ---------------------------------------------------------- |
| Ollama               | <https://ollama.com>                                       |
| Open WebUI           | <https://openwebui.com>                                    |
| Kali Linux           | <https://www.kali.org>                                     |
| HackTricks           | <https://book.hacktricks.xyz>                              |
| GTFOBins             | <https://gtfobins.github.io>                               |
| PayloadsAllTheThings | <https://github.com/swisskyrepo/PayloadsAllTheThings>      |
| OWASP Testing Guide  | <https://owasp.org/www-project-web-security-testing-guide> |
| HackTheBox           | <https://www.hackthebox.com>                               |
| TryHackMe            | <https://tryhackme.com>                                    |

***

## Descargo de Responsabilidad

Esta guía está orientada exclusivamente a **uso educativo** y **pentesting ético** en entornos autorizados. El autor no se responsabiliza por el uso indebido de las técnicas o herramientas documentadas. Siempre obtené autorización explícita antes de realizar cualquier prueba de seguridad.

***

*Guía mantenida en GitBook — Contribuciones bienvenidas*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://oliver-3.gitbook.io/redteam-notes/recursos/guia-ollama-openwebui.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.