Guía de usuario

Marca: ✦ Aldakaer ✦ — Official Intelligence Platform
Producto: OSINTH (Open Source Intelligence & Threat Hunter Framework)
Versión: 4.4.0
Desarrollado por: Ernesto Lopez — Aldakaer

Aldakaer es la marca; OSINTH es la plataforma de threat intelligence desarrollada bajo ella.

Índice

1. Primeros pasos
2. Dashboard & Navegación
3. OSINT Scanner
4. Phone OSINT
5. Email OSINT
6. Threat Intelligence
7. Detection Rules
8. AI Analysis (Ollama)
9. SIEM Ingestion
10. SIEM Export
11. Forensic Investigation
12. Dark Web Monitor
13. Phishing & Brand Protection
14. Document Metadata
15. ATT&CK Kill-Chain
16. Cases & Forensics
17. Playbooks
18. Threat Feeds
19. Alertas (Telegram / Discord)
20. Licencias

1. Primeros pasos

Activar tu licencia

Al abrir OSINTH por primera vez verás la pantalla de Onboarding.

1. Tu proveedor te enviará un mensaje con la clave. Puede verse así:

LICENSE_SECRET=OSINTH_abc123...
LICENSE_KEY=eyJ2IjogMi...

1. Pega el bloque completo en el campo "Pega aquí el bloque completo" y haz clic en Activar licencia.

✅ También puedes pegar solo el LICENSE_KEY si ya tienes el LICENSE_SECRET configurado.

Configurar APIs

Para obtener datos reales necesitas al menos estas 4 APIs gratuitas:

Ve a Settings → 🔑 API Keys para configurarlas desde la UI.

2. Dashboard & Navegación

Barra lateral

La barra lateral izquierda contiene todos los módulos organizados por categoría:

🚀 Onboarding          → Activar licencia / primeros pasos
📊 Overview            → Panel principal con métricas globales
⚠️ Threats             → Gestión de amenazas detectadas
🔍 OSINT Scanner       → Escaneo manual de targets
📞 Phone OSINT         → Análisis de números de teléfono
📧 Email OSINT         → Análisis de direcciones de email
📡 Live Monitor        → Eventos en tiempo real
⚔️ Attack Chain        → Visualizador MITRE ATT&CK
📈 Analytics           → Estadísticas y gráficos
📅 Timeline            → Línea de tiempo de eventos
🔬 Forensic            → Investigación forense
📁 Cases               → Gestión de casos
🎯 Assets              → Inventario de activos
📡 Feeds               → Feeds de threat intelligence
🌑 Dark Web            → Monitoreo dark web
🎣 Phishing            → Detección de phishing
🔔 Detection Rules     → Reglas de detección automática
📋 Playbooks           → Automatización de respuesta
📤 SIEM Export         → Exportar a SIEM externos
📡 SIEM Ingestion      → Recibir logs de dispositivos
🗂️ Metadata            → Análisis de metadatos
🔑 Licencias           → Gestión de licencias
⚙️ Settings            → Configuración general

Indicador de plan

En la parte superior de la barra lateral verás: - 🟡 Básico — $25/mes - 🔵 Profesional — $69/mes
- 🟢 SOC/Enterprise — $179/mes

Las páginas bloqueadas por tu plan muestran un mensaje de upgrade.

3. OSINT Scanner

Escanear un target

1. Escribe el target en el campo de búsqueda (IP, dominio, URL, hash, email, username)
2. Selecciona el modo de escaneo:
3. Quick — fuentes principales, ~10 segundos
4. Standard — todas las fuentes, ~30 segundos
5. Deep — fuentes premium + correlación, ~60 segundos
6. Aggressive — sin throttling (solo plan SOC)
7. Haz clic en Scan

Interpretar resultados

El resultado muestra: - Risk Score (0-100) — puntuación de riesgo global - Risk Level — LOW / MEDIUM / HIGH / CRITICAL - IOCs detectados — indicadores de compromiso encontrados - Fuentes — qué APIs respondieron

Batch scan (plan Profesional+)

1. Ve a OSINT Scanner → Batch
2. Pega targets separados por línea (máx. 25 en Profesional, ilimitado en SOC)
3. Haz clic en Scan All

4. Phone OSINT

Analizar un número

1. Ve a 📞 Phone OSINT
2. Escribe el número en formato internacional: +573001234567
3. Opcionalmente indica el país de referencia: CO
4. Haz clic en Analyze

Lo que obtienes

Fuentes de datos (6 APIs concurrentes)

• NumLookup API — gratuita, sin key
• BDC (BigDataCloud) — gratuita, 10k/mes
• PhoneValidator — gratuita
• NumVerify — requiere NUMVERIFY_KEY
• AbstractAPI — requiere ABSTRACT_API_KEY
• Twilio Lookup v2 — requiere TWILIO_ACCOUNT_SID + TWILIO_AUTH_TOKEN

5. Email OSINT

Analizar un email

1. Ve a 📧 Email OSINT
2. Escribe la dirección: [email protected]
3. Haz clic en Analyze

Fuentes (12 concurrentes, 9 gratuitas sin key)

Tab 🤖 AI Analysis

El AI sintetiza todas las fuentes y produce: - Evaluación de identidad del dueño - Análisis de brechas y su implicación - Correlaciones cross-source (ej: "GitHub login coincide con Gravatar") - Pivots OSINT recomendados

6. Threat Intelligence

Amenazas detectadas

En ⚠️ Threats puedes: - Ver todas las amenazas detectadas ordenadas por riesgo - Filtrar por nivel (Critical / High / Medium / Low) - Filtrar por estado (Open / Investigating / Resolved) - Asignar a un analista - Cambiar estado - Ver IOCs vinculados

IOC Management

Un IOC (Indicator of Compromise) puede ser: - ip — dirección IP maliciosa - domain — dominio comprometido - url — URL de phishing o C2 - hash_md5 / hash_sha1 / hash_sha256 — hash de malware - email — email de phishing - phone — número vinculado a fraude - username — usuario comprometido

7. Detection Rules

Crear una regla

1. Ve a 🔔 Detection Rules → ➕ New Rule
2. Configura:
3. Nombre — identificador humano
4. Lógica — AND (todas deben cumplirse) / OR (basta una)
5. Condiciones — campo + operador + valor

Operadores disponibles:

Campos disponibles: risk_score, risk_level, target, target_type, tags, source, country, status

1. Selecciona acciones — qué hacer cuando la regla dispare:

Probar una regla

1. Ve a 🧪 Test Rule
2. Pega un JSON de scan resultado
3. Haz clic en ▶ Evaluate Rules — verás qué reglas dispararían

Instalar plantillas

Ve a 📖 Rule Library e instala plantillas pre-configuradas: - Critical IP Alert - Malware Hash Detected - Phishing Domain Found - TOR Exit Node - High Risk Score - Data Exfiltration

8. AI Analysis (Ollama)

OSINTH usa Ollama para correr el análisis con inteligencia artificial directamente en tu equipo — no es obligatorio, pero desbloquea el botón 🤖 Analizar con AI en varios módulos (incluido el módulo dedicado AI Investigator del panel).

Paso a paso — Windows (la forma más común)

1. Ve a https://ollama.com/download y descarga el instalador para Windows.
2. Ejecuta el instalador (OllamaSetup.exe) y sigue los pasos normales de instalación. Al terminar, Ollama queda corriendo en segundo plano automáticamente (verás su ícono en la bandeja del sistema, junto al reloj).
3. Abre la Terminal (busca "cmd" o "PowerShell" en el menú inicio) y descarga el modelo que usa OSINTH: bash ollama pull llama3.2 Esto descarga unos ~2GB la primera vez — solo se hace una vez.
4. Verifica que esté corriendo: bash curl http://localhost:11434 Debería responder Ollama is running. Si no tienes curl, simplemente abre http://localhost:11434 en el navegador y deberías ver ese mismo mensaje.
5. Abre (o reinicia) Aldakaer. Ve a Onboarding — si Ollama está corriendo, verás el estado AI: Conectado (en vez de "No disponible"). Ya está listo, no hace falta configurar nada más dentro de la app.

Paso a paso — Linux / macOS

# 1. Instalar
curl -fsSL https://ollama.ai/install.sh | sh

# 2. Iniciar el servidor (déjalo corriendo en una terminal, o como servicio)
ollama serve

# 3. En OTRA terminal, descargar el modelo
ollama pull llama3.2

# 4. Verificar
curl http://localhost:11434
# → "Ollama is running"

¿Y si quiero usar otro modelo?

Por defecto OSINTH usa llama3.2 (buen balance velocidad/calidad en equipos normales). Si tu PC tiene buena GPU/RAM y quieres más precisión, puedes usar un modelo más grande — descárgalo con ollama pull <modelo> (ej. ollama pull llama3.1:70b) y configúralo en el archivo .env junto a la app:

OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama3.2

Cambia OLLAMA_MODEL por el nombre exacto del modelo que descargaste y reinicia la app.

Módulos con AI

El botón 🤖 Analizar con AI está disponible en:

Preguntas frecuentes

¿Es obligatorio instalar Ollama? No. Sin Ollama, OSINTH sigue funcionando normal con detección basada en reglas (use_ai=False) — solo no verás el botón de análisis con IA.

¿Ollama funciona con la versión web (app.hackingteamoficcial.uk)? No — Ollama corre en TU equipo, no en el servidor. El análisis con IA solo está disponible en la app de escritorio (.exe), donde Ollama corre localmente junto a OSINTH.

"AI: No disponible" aunque instalé Ollama Verifica que ollama serve esté corriendo (en Windows, revisa el ícono en la bandeja del sistema) y que curl http://localhost:11434 responda. Si sigue sin conectar, reinicia Ollama y luego la app.

Sin conexión a internet

Todo el AI corre 100% local en tu máquina. Ningún dato se envía a servidores externos.

9. SIEM Ingestion

Receptor Syslog (UDP/TCP)

1. Ve a 📡 SIEM Ingestion → 📶 Syslog Receiver
2. Configura el puerto (default: UDP 5140 / TCP 5141)
3. Haz clic en ▶ Iniciar Receptor Syslog

Configurar dispositivos para enviar logs:

Cisco IOS:

logging host TU_IP transport udp port 5140
logging trap informational

Linux (rsyslog):

# /etc/rsyslog.conf
*.* @TU_IP:5140

pfSense / OPNsense:
System → Logging → Remote syslog → TU_IP:5140

Log File Watcher

1. Ve a 📁 Log File Watcher
2. Escribe la ruta del archivo o un glob: /var/log/nginx/*.log
3. Haz clic en ➕ Agregar

OSINTH monitorea el archivo en tiempo real, detecta rotaciones automáticamente y parsea los formatos Apache, Nginx, CEF, JSON y syslog.

Windows Event Log

1. Ve a 🪟 Windows Events
2. Selecciona los canales: Security, System, Application
3. Haz clic en 🔍 Leer eventos ahora para lectura puntual
4. O ▶ Iniciar monitoreo continuo para polling cada 30 segundos

Event IDs de alta relevancia monitoreados: - 4625 — Inicio de sesión fallido - 4720 — Cuenta de usuario creada - 4698 — Tarea programada creada - 1102 — Log de auditoría borrado ⚠️ - 7045 — Nuevo servicio instalado ⚠️

Event Search

1. Ve a 🔍 Event Search
2. Escribe palabras clave: mimikatz, 4625, DROP, 192.168.1.1
3. Filtra por severidad, fuente y período
4. Exporta resultados a JSON

10. SIEM Export

Exportar a Splunk

1. Ve a 📤 SIEM Export → 🔵 Splunk
2. Ingresa:
3. HEC URL: https://splunk.empresa.com:8088/services/collector
4. HEC Token: token de Splunk
5. Index: nombre del índice (ej: osinth)
6. Haz clic en 🚀 Send to Splunk

Exportar STIX 2.1

1. Ve a 🔶 STIX 2.1
2. Haz clic en ⬇️ Download STIX 2.1 JSON
3. Importa en OpenCTI, MISP o cualquier plataforma TAXII-compatible

Exportar ATT&CK Navigator Layer

1. Ve a ⚔️ Attack Chain → 📤 Export
2. Descarga el Navigator Layer (.json)
3. Importa en https://mitre-attack.github.io/attack-navigator/

11. Forensic Investigation

Hash Lookup

1. Ve a 🔬 Forensic → 🔑 Hash Lookup
2. Pega el hash (MD5/SHA1/SHA256)
3. Los resultados se obtienen de VirusTotal, MalwareBazaar y HybridAnalysis en paralelo

File Analysis

1. Sube un archivo sospechoso
2. OSINTH calcula hashes, extrae strings, calcula entropía y detecta magic bytes

CVE Lookup

1. Escribe un CVE-ID: CVE-2024-12345
2. Obtienes severidad CVSS, descripción, productos afectados y exploit disponible

Chain of Custody

El log de evidencias registra automáticamente: - Quién analizó qué - Cuándo - Hash del archivo (para integridad) - Notas del analista

12. Dark Web Monitor

Buscar exposición

1. Ve a 🌑 Dark Web
2. Escribe el término: email, dominio, nombre de empresa, IP
3. Los resultados provienen de:
4. Ahmia — índice de sitios .onion (clearnet mirror)
5. Ahmia .onion — acceso real si Tor está corriendo
6. Pastebin — pastes recientes
7. IntelX — inteligencia profunda (requiere API key)
8. HudsonRock — credential leaks (solo emails)

Habilitar Tor real

# Instalar Tor
# Windows: https://www.torproject.org/download/
# Linux: sudo apt install tor && sudo service tor start

# Tor escucha en 127.0.0.1:9050 por defecto
# OSINTH lo detecta automáticamente

Configurar en .env:

TOR_PROXY=socks5://127.0.0.1:9050

Watchlist

Haz clic en ⭐ Agregar a Watchlist para monitorear un término continuamente.

13. Phishing & Brand Protection

Detectar typosquatting

1. Ve a 🎣 Phishing → 🎣 Typosquatting
2. Escribe tu dominio: empresa.com
3. Activa Check DNS (live) para verificar qué variantes están registradas

Genera variantes por: - Sustitución de teclas QWERTY adyacentes - Letras dobles / faltantes - Transposición de caracteres - Homoglifos (О cirílica vs O latina)

Monitorear certificados SSL

1. Ve a 📜 Cert Monitor
2. Busca tu dominio en crt.sh para ver qué certificados existen

AI Analysis de phishing

En la tab 🤖 AI Analysis, el modelo determina: - Si hay campaña activa contra tu marca - Técnica exacta utilizada - Pasos recomendados de takedown (ICANN, hosting provider)

14. Document Metadata

Analizar un documento

1. Ve a 🗂️ Metadata → 📄 Analyze File
2. Sube el archivo (PDF, DOCX, XLSX, PPTX, JPG, PNG, TIFF)
3. OSINTH extrae automáticamente:
4. Autor, organización, software utilizado
5. Fechas de creación y modificación
6. Coordenadas GPS (imágenes de smartphone)
7. URLs, emails e IPs embebidas
8. Presencia de macros (riesgo de malware)

Interpretar coordenadas GPS

Si el documento contiene GPS: - Se muestra el mapa interactivo con el pin exacto - Link directo a Google Maps - El AI evalúa si la ubicación es sensible (hogar, oficina, instalación militar)

Batch análisis

En 📦 Batch Upload puedes subir múltiples archivos y descargar un informe JSON consolidado.

15. ATT&CK Kill-Chain

Ver la cadena de ataque

1. Ve a ⚔️ Attack Chain
2. Si tienes amenazas en la DB, se mapean automáticamente a fases MITRE
3. Si la DB está vacía, se muestran datos demo de ejemplo

Interpretar el diagrama

• Cada nodo representa una fase del kill-chain
• El tamaño del nodo indica cantidad de técnicas detectadas
• El color indica el nivel de riesgo más alto en esa fase
• Hover sobre un nodo para ver las técnicas específicas

Export Navigator Layer

El archivo .json descargado se puede importar directamente en: https://mitre-attack.github.io/attack-navigator/

Para visualizar tu cobertura de detección sobre el mapa oficial de MITRE ATT&CK.

16. Cases & Forensics

Crear un caso

1. Ve a 📁 Cases → ➕ New Case
2. Completa:
3. Título — descripción breve
4. Tipo — Phishing / Malware / Intrusion / Data Leak / Recon
5. Prioridad — Critical / High / Medium / Low
6. TLP — WHITE / GREEN / AMBER / RED
7. Haz clic en Create Case

Ciclo de vida

open → investigating → resolved → closed
         ↓
    false_positive

Adjuntar evidencia

En la vista de un caso: 1. Haz clic en + Add Evidence 2. Escribe una nota o sube un archivo 3. El sistema registra quién lo añadió y cuándo (chain of custody)

17. Playbooks

Ejecutar un playbook

1. Ve a 📋 Playbooks
2. Selecciona un playbook de la lista
3. Haz clic en ▶ Ejecutar

Pasos disponibles en un playbook

Plantillas incluidas

• Critical IP Response — notifica → crea caso → escala riesgo
• Malware Hash — notifica → etiqueta IOC → crea caso
• Phishing Domain — notifica → etiqueta → crea caso

18. Threat Feeds

Activar feeds automáticos

1. Ve a 📡 Feeds
2. Activa los feeds gratuitos (no requieren API key):
3. Feodo Tracker — IPs de botnet bancario
4. URLhaus — URLs maliciosas activas
5. Emerging Threats — reglas IDS
6. SSLBL — certificados SSL maliciosos

7. ThreatFox — IOCs de malware reciente

8. Configura el intervalo de actualización (1-24 horas)

9. Haz clic en Start Auto-Ingest

Ver IOCs ingestados

Los IOCs se guardan automáticamente en la base de datos y aparecen en la tabla Feed IOCs con su fuente y fecha de última actualización.

19. Alertas (Telegram / Discord)

Configurar Telegram

1. Habla con @BotFather en Telegram
2. Envía /newbot y sigue las instrucciones
3. Copia el Bot Token
4. Agrega el bot a tu canal o chat
5. Obtén el Chat ID: envía un mensaje y visita https://api.telegram.org/bot<TOKEN>/getUpdates

Configura en .env:

TELEGRAM_BOT_TOKEN=1234567890:ABCDEFGabcdefg...
TELEGRAM_CHAT_ID=-1001234567890

O desde Settings → 🔑 API Keys → Telegram Bot Token + Chat ID.

Configurar Discord

1. En Discord: Server Settings → Integrations → Webhooks → New Webhook
2. Copia la Webhook URL

DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/...

Probar alertas

En Settings → Scanner encontrarás el botón Test Alert para verificar que los canales funcionan.

20. Licencias

Para operadores (generar licencias)

1. Ve a 🔑 Licencias → ➕ Generar Licencia
2. Completa:
3. Cliente — nombre de la empresa
4. Plan — Básico / Profesional / SOC
5. Modalidad — Mensual / Anual
6. Días — vigencia
7. Haz clic en 🔑 Generar Clave de Licencia
8. Copia el mensaje generado y envíaselo al cliente

Para clientes (activar licencia)

1. Abre OSINTH
2. En la pantalla de Onboarding, pega la clave que te enviaron
3. Haz clic en ✅ Activar licencia

Renovar una licencia

1. Ve a 📋 Mis Clientes
2. Busca el cliente
3. Haz clic en 🔄 Renovar 30 días o 🔄 Renovar 1 año
4. Envía la nueva clave al cliente

Ver revenue

En 💰 Revenue puedes ver: - MRR — ingresos mensuales recurrentes - ARR — proyección anual - Clientes activos - Proyección en 3 escenarios (conservador / moderado / optimista)

Preguntas frecuentes

¿Cuántas IPs puedo escanear por día? - Básico: 5 scans/día - Profesional: 50 scans/día - SOC: ilimitado

¿El AI envía mis datos a internet? No. Todo el análisis AI corre con Ollama en tu máquina local. Ningún dato sale de tu red.

¿Necesito internet para usar OSINTH? La mayoría de módulos necesitan internet para consultar APIs externas. El AI y el análisis de metadatos funcionan offline.

¿Puedo usar PostgreSQL en vez de SQLite? Sí. En .env cambia:

DATABASE_URL=postgresql://usuario:contraseña@host:5432/osinth

¿Cómo recibo logs de mi firewall? Configura tu dispositivo para enviar syslog a TU_IP:5140 (UDP). Luego activa el receptor en SIEM Ingestion → Syslog Receiver.

¿Dónde se guarda todo? - Base de datos: database/osinth.db - Datos de sesión: data/ - Logs de la aplicación: logs/ - Reportes: reports/

Instalación

✦ Aldakaer ✦ — OSINTH Installation Guide

Marca: Aldakaer · Producto: OSINTH
Versión: 4.4.0 | Guía de Usuario · Planes · Detection Rules · SIEM Ingestion

Requirements

Quick Start (Local)

# 1. Clone the repository
git clone https://github.com/ernestolopez/osinth.git
cd osinth

# 2. Create a virtual environment
python -m venv .venv

# Windows
.venv\Scripts\activate

# Linux / macOS
source .venv/bin/activate

# 3. Install Python dependencies
pip install -r requirements.txt

# 4. Configure environment variables
cp .env.example .env
# Edit .env with your API keys (or use the Settings tab in the dashboard)

# 5. Launch the Streamlit dashboard
streamlit run ui/dashboard.py
# → http://localhost:8501

# 6. (Optional) Launch the REST API in a second terminal
python cli.py api start --port 8000 --reload
# → http://localhost:8000
# → http://localhost:8000/docs  (interactive API docs)

Docker Deployment

Single container

# Build image
docker build -t osinth:latest .

# Run with environment file
docker run -d \
  --name osinth \
  -p 8501:8501 \
  -p 8000:8000 \
  --env-file .env \
  -v $(pwd)/data:/app/data \
  osinth:latest

Docker Compose (recommended for production)

# Start all services (dashboard + API + optional Ollama)
docker compose -f docker/docker-compose.yml up -d

# View logs
docker compose -f docker/docker-compose.yml logs -f

# Stop
docker compose -f docker/docker-compose.yml down

Access points after Compose start:

Ollama Setup (AI Features)

AI analysis, phishing detection and threat classification require a running Ollama instance.

# Install Ollama (Linux / macOS)
curl -fsSL https://ollama.ai/install.sh | sh

# Windows: download the installer from https://ollama.ai

# Start the Ollama server
ollama serve

# Pull the recommended model (in a separate terminal)
ollama pull llama3.2

# Verify Ollama is reachable
curl http://localhost:11434

Set the following in your .env:

OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama3.2

If Ollama is unavailable, OSINTH degrades gracefully — all rule-based detection continues to work.

Environment Variables Reference

Copy .env.example to .env and fill in the values you need.

Core Threat Intelligence (Required for full functionality)

VT_API=              # VirusTotal — virustotal.com/gui/my-apikey
SHODAN_API=          # Shodan — account.shodan.io
ABUSEIPDB_KEY=       # AbuseIPDB — abuseipdb.com/account/api
ALIENVAULT_KEY=      # AlienVault OTX — otx.alienvault.com/api

Optional Intelligence Sources

MALWAREBAZAAR_KEY=   # bazaar.abuse.ch (free, no key required)
URLHAUS_KEY=         # urlhaus-api.abuse.ch (free, no key required)
GREYNOISE_KEY=       # greynoise.io
PULSEDIVE_KEY=       # pulsedive.com
URLSCAN_KEY=         # urlscan.io
CENSYS_API_ID=       # search.censys.io — free 250 req/month
CENSYS_API_SECRET=
HYBRID_ANALYSIS_KEY= # hybrid-analysis.com — free community tier
IPQUALITYSCORE_KEY=  # ipqualityscore.com — free 5000/month
IPINFO_KEY=          # ipinfo.io — free 50k/month
SECURITYTRAILS_KEY=  # securitytrails.com
HUNTER_KEY=          # hunter.io
HIBP_KEY=            # haveibeenpwned.com
EMAILREP_KEY=        # emailrep.io
NUMVERIFY_KEY=       # numverify.com
ABSTRACT_API_KEY=    # abstractapi.com (phone)
GOOGLE_SAFE_BROWSING=
TWILIO_ACCOUNT_SID=  # twilio.com (phone lookup)
TWILIO_AUTH_TOKEN=

Alert Channels

TELEGRAM_BOT_TOKEN=  # from t.me/BotFather
TELEGRAM_CHAT_ID=    # chat or channel ID (e.g. -100xxxxxxxxx)
TELEGRAM_API_ID=     # from my.telegram.org (for channel monitoring)
TELEGRAM_API_HASH=
DISCORD_WEBHOOK_URL= # from Discord Server Settings -> Integrations

AI Configuration

OLLAMA_HOST=http://localhost:11434
OLLAMA_MODEL=llama3.2

Scanner Tuning

SCANNER_WORKERS=4
SCANNER_TIMEOUT=60
SCANNER_MAX_QUEUE=1000
THREATINTEL_CACHE_TTL=3600
THREATINTEL_CACHE_MAX=500

Application

ENV=production        # development | staging | production
DATABASE_URL=sqlite:///./data/osinth.db
DASHBOARD_HOST=0.0.0.0
DASHBOARD_PORT=8501
API_HOST=0.0.0.0
API_PORT=8000
SECRET_KEY=           # generate: python -c "import secrets; print(secrets.token_hex(32))"

First Scan

# Via CLI
python cli.py scan target 8.8.8.8

# Via API
curl -X POST http://localhost:8000/api/v1/scan/sync \
  -H "Content-Type: application/json" \
  -d '{"target": "8.8.8.8"}'

# Check system health
python cli.py health

Upgrading

git pull origin main
pip install -r requirements.txt --upgrade
python cli.py health

Troubleshooting

New in v4.1.0

• ✨ SIEM Ingestion — Syslog UDP/TCP receiver, Log File Watcher, Windows Event Log reader
• ✨ Event Search — Full-text search over all ingested events with filters
• ✨ Retention Policy — Configurable event purge (1 day to 1 year)
• ✨ AI Analysis on Forensic, Dark Web, Phishing, Metadata, Attack Chain pages
• ✨ ATT&CK Navigator export — Import your detection coverage in MITRE Navigator
• ✨ MITRE Mapper — Auto-maps DB threats to ATT&CK phases and T-codes
• ✨ HMAC-SHA256 Audit Trail — Cryptographic chain for tamper detection
• ✨ PostgreSQL support — Set DATABASE_URL=postgresql://... in .env

Environment Variables — New in v4.1

# SIEM Ingestion
SYSLOG_UDP_PORT=5140          # Syslog receiver UDP port (default 5140)
SYSLOG_TCP_PORT=5141          # Syslog receiver TCP port (default 5141)

# Dark Web
TOR_PROXY=socks5://127.0.0.1:9050   # Tor proxy for real .onion access

# Audit
OSINTH_AUDIT_SECRET=          # HMAC key for audit chain (auto-generated if empty)

# PostgreSQL (optional — SQLite is the default)
DATABASE_URL=postgresql://user:pass@host:5432/osinth

Módulos

OSINTH — Module Reference

Powered by Aldakaer · Producto: OSINTH

Each module is an independent Python package under modules/. Modules are called by the Scanner in parallel and return a standardized result dict. They can also be imported and used standalone.

ThreatIntel (modules/threatintel/)

VirusTotal (virustotal.py)

Queries the VirusTotal v3 API for reputation data on IPs, domains, URLs and file hashes.

Returns: detection ratio, engine verdicts, community score, last analysis date, categories.

Required: VT_API environment variable.

from modules.threatintel.virustotal import VirusTotalPlugin
result = VirusTotalPlugin().run("evil.com", {})
print(result.data["detections"])

Shodan (shodan_lookup.py)

Queries Shodan for passive scan data on IP addresses.

Returns: open ports, service banners, CVEs, OS fingerprint, geolocation, organization, ISP.

Required: SHODAN_API.

AbuseIPDB (abuseipdb.py)

Checks IP abuse history and confidence score.

Returns: abuse score (0–100), total reports, ISP, usage type (datacenter/residential/VPN), country.

Required: ABUSEIPDB_KEY.

AlienVault OTX (alienvault.py)

Retrieves threat pulses from AlienVault OTX community intelligence.

Returns: pulse list, malware families, attack techniques, related IOCs, tags.

Required: ALIENVAULT_KEY.

MalwareBazaar (malwarebazaar.py)

Looks up file hashes in the MalwareBazaar database.

Returns: malware family, YARA signatures, file type, first/last seen, download URL.

No API key required.

URLhaus (urlhaus.py)

Checks URLs and domains against the URLhaus malicious URL database.

Returns: threat classification, tags, date added, associated payloads, status (online/offline).

No API key required.

GreyNoise (greynoise.py)

Determines if an IP is mass-scanning internet background noise or a targeted attacker.

Returns: noise (bool), riot (trusted service bool), classification, name, tags.

Required: GREYNOISE_KEY (optional — anonymous requests have lower rate limits).

Censys (censys.py)

Queries Censys internet scan data for IP and domain intelligence.

Returns: open ports, TLS certificates, services, geographic data, autonomous system.

Required: CENSYS_API_ID + CENSYS_API_SECRET.

Hybrid Analysis (hybridanalysis.py)

Queries the Hybrid Analysis sandbox for file hash reports.

Returns: verdict, threat score, MITRE ATT&CK TTPs, network indicators, dropped files.

Required: HYBRID_ANALYSIS_KEY.

Aggregator (aggregator.py)

Runs all configured ThreatIntel sources in parallel and merges results into a unified dict. This is what the Scanner uses internally.

from modules.threatintel.aggregator import ThreatIntelAggregator
result = ThreatIntelAggregator().analyze("evil.com")

Domain Intelligence (modules/domain/)

Geolocation (modules/geolocation/)

Phishing Detection (modules/phishing/)

Email Intelligence (modules/email/)

Phone Intelligence (modules/phone/)

Network Analysis (modules/network/)

Social & Username (modules/social/, modules/username/)

Telegram Intelligence (modules/telegram/)

Required: TELEGRAM_API_ID + TELEGRAM_API_HASH for channel monitoring.

Forensics (modules/forensic/)

Graph (modules/graph/)

ThreatGraph (threat_graph.py)

In-memory directed graph for storing and querying relationships between IOCs.

from modules.graph.threat_graph import ThreatGraph

g = ThreatGraph()
ip_id  = g.add_node("ip", "185.220.101.1", risk_score=90.0)
dom_id = g.add_node("domain", "evil.com")
g.add_edge(dom_id, ip_id, "resolves_to")

# Query
neighbors = g.neighbors(dom_id)
high_risk  = g.high_risk_nodes(threshold=80.0)

Ingestion (modules/ingest/)

Ingestor (ingestor.py)

Parses and imports external data feeds into OSINTH.

Supported formats: - ioc_feed — one IOC per line, # comments ignored - json — array of {value, ioc_type} objects - csv — value,ioc_type,source headers

from modules.ingest.ingestor import Ingestor

ingestor = Ingestor()
result = ingestor.ingest_text("185.1.1.1\nevil.com", fmt="ioc_feed")
print(result.imported)  # 2

Assets (modules/assets/)

AssetManager (asset_manager.py)

Persistent asset inventory with JSON backend. Tracks IPs, domains, servers, APIs, and apps with criticality ratings and exposure history.

SIEM Export (modules/exporters/)

SIEMExport (siem_export.py)

Exports threat data in SIEM-compatible formats.

Supported formats: CEF (Common Event Format), LEEF (Log Event Extended Format), JSON, CSV.

Compatible with: Splunk, QRadar, ArcSight, Elastic SIEM, Microsoft Sentinel.

Planes

OSINTH — Comparativa de Planes

Versión: 4.1.0 | Powered by Aldakaer

Resumen de precios

Comparativa completa

Límites de uso

OSINT & Investigación

AI Analysis (Ollama local)

Exportación SIEM (10 destinos)

SIEM Ingestion (Mini-SIEM)

SOC & Automatización

Visualización

Seguridad & Reportes

Soporte

¿Qué plan necesito?

🟡 Básico — $25/mes

Ideal para: - Freelancers y consultores de seguridad que hacen análisis ocasionales - Investigadores que necesitan herramientas básicas de OSINT - Estudiantes y learners de ciberseguridad

No incluye: - Phone/Email OSINT avanzado - SIEM export ni ingestion - Detection rules automáticas

🔵 Profesional — $69/mes ⭐ Más popular

Ideal para: - Consultores de ciberseguridad independientes - Equipos de seguridad de PYMES (2-5 personas) - Investigadores digitales privados - Red teams independientes

Ventaja clave: Phone & Email OSINT con AI local, exportación a 10 destinos SIEM, Threat Intel completo, ATT&CK Kill-Chain.

🟢 SOC / Enterprise — $179/mes

Ideal para: - Equipos SOC (5-20 analistas) - Agencias de ciberseguridad - MSSPs (proveedores de seguridad gestionada) - Empresas con necesidades de monitoreo continuo

Ventaja clave: Todo ilimitado + SIEM ingestion real (syslog/files/Windows Events), Detection Rules con acciones reales, Dark Web con Tor, Forensics completo, AI en todos los módulos.

Comparativa con competencia

Preguntas frecuentes sobre planes

¿Puedo cambiar de plan en cualquier momento?
Sí. Tu proveedor te emite una nueva licencia con el plan actualizado. El cambio es inmediato.

¿El plan anual tiene descuento?
Sí. El plan anual equivale a pagar 10 meses (2 meses gratis en todos los planes).

¿Los datos se borran si bajo de plan?
No. Todos tus datos históricos se conservan. Solo se restringen las funciones del plan inferior.

¿Hay límite de usuarios por licencia?
La licencia es por instalación (un servidor/computadora). No hay límite de usuarios que accedan al mismo servidor.

¿Incluye soporte técnico?
Sí. El plan SOC incluye sesión de onboarding guiado. Todos los planes incluyen soporte por email.

Arquitectura

OSINTH — Architecture

Powered by Aldakaer · Producto: OSINTH

Overview

OSINTH follows a layered, event-driven architecture with clear separation between the four main concerns: interfaces, core engine, data collection, and persistence.

┌─────────────────────────────────────────────────────────────────────┐
│                           OSINTH v2.0                               │
├──────────────┬───────────────────┬──────────────┬───────────────────┤
│  Dashboard   │    REST API       │    CLI       │  Scheduler        │
│ (Streamlit)  │  (FastAPI + WS)   │  (Typer)     │ (APScheduler)     │
├──────────────┴───────────────────┴──────────────┴───────────────────┤
│                         Core Engine                                  │
│  Scanner · AIEngine · RiskEngine · SearchEngine (FTS5)              │
│  Security · RBAC · AuditTrail · Metrics (Prometheus)                │
├──────────────────────────┬──────────────────────────────────────────┤
│     Automation Layer     │         OSINT Modules                    │
│  EventBus · WorkerPool   │  ThreatIntel · Domain · IP · Email       │
│  LiveDetector            │  Geo · Network · Social · Phone          │
│  CorrelationEngine       │  Phishing · Telegram · Forensic          │
│  AnomalyDetector         ├──────────────────────────────────────────┤
│  IOCMonitor              │         AI / ML                          │
│  ForensicCollector       │  ThreatClassifier · PhishingClassifier   │
│  AlertManager            │  IOCClassifier · CorrelationEngine       │
├──────────────────────────┴──────────────────────────────────────────┤
│                          Data Layer                                  │
│  SQLite (SQLAlchemy ORM) · FTS5 Index · ThreatGraph · Cache         │
└─────────────────────────────────────────────────────────────────────┘

Layer Descriptions

Interface Layer

All four interfaces are independent — any combination can run simultaneously.

Core Engine (core/)

Scanner (core/scanner.py)

The central orchestrator. Accepts scan tasks, dispatches them to the WorkerPool, collects results from each OSINT module, feeds them into the RiskEngine, and persists results to the database.

ScanTask → [modules] → results → RiskEngine → RiskResult → DB + EventBus

AIEngine (core/ai_engine.py)

Wraps the Ollama HTTP client with: - Task-specific methods: analyze_threat(), explain_ioc(), analyze_phishing(), classify_threat(), summarize_report() - In-memory response cache (SHA-256 keyed, configurable TTL) - Concurrency semaphore (max 2 parallel LLM requests) - Graceful degradation when Ollama is unavailable

RiskEngine (core/risk_engine.py)

Aggregates weighted RiskFactor objects into a normalized 0–100 score and maps it to a severity level:

Default factor weights: threat_intelligence 30%, behavioral_anomaly 25%, ioc_match 20%, reputation 15%, historical_activity 10%.

SearchEngine (core/search.py)

Full-text search over threats, events, and IOCs using SQLite FTS5 with prefix matching.

Security (core/security.py)

Input sanitization, rate limiting, API key hashing, CSRF protection, and SQL injection detection. Called at all external entry points.

RBAC (core/rbac.py)

Role-based access control with predefined roles: admin, analyst, readonly. Enforced at the API middleware layer.

AuditTrail (core/audit.py)

Immutable append-only log with SHA-256 chaining for tamper detection. Records every login, scan, alert, and configuration change.

Automation Layer (automation/)

Event-driven pipeline

Raw Event
    │
    ▼
EventBus ──► Subscribers (AlertManager, ForensicCollector, IOCMonitor)
    │
    ▼
LiveDetector ──► 17+ rule categories ──► correlated events
    │
    ▼
CorrelationEngine ──► campaign clusters
    │
    ▼
AnomalyDetector (EMA baseline) ──► statistical anomalies

EventBus (automation/events/event_bus.py)

In-process pub/sub bus. Subscribers register handlers for specific EventType values or use a wildcard. Events are dispatched asynchronously via a background thread. Maintains a rolling history buffer for the /ws/events WebSocket.

WorkerPool (automation/workers/worker_pool.py)

Fixed-size thread pool with a TaskQueue. Tasks are Task objects with priority, timeout, and retry count. The pool exposes health() for monitoring.

AlertManager (automation/alerts/manager.py)

Routes AlertPayload objects to configured channels (Telegram, Discord) with deduplication (hash-based, 5-minute window) and per-channel rate limiting.

ForensicCollector (automation/forensics/collector.py)

Captures artifacts (process snapshots, network connections, memory regions, screenshots) and computes SHA-256 + UTC timestamp for each, establishing a chain of custody.

OSINT Modules (modules/)

Each module is independent and returns a standardized result dict. The Scanner calls them in parallel via the WorkerPool.

AI / ML Layer (ai/)

Classifiers (ai/classifiers/)

Each classifier works in two modes: - Rule-based (use_ai=False): regex + heuristics, fast, no Ollama required - AI-enhanced (use_ai=True): LLM enrichment added on top of rule output

Prompts (ai/prompts/)

System prompts and dynamic prompt builders for each AI task: threat analysis, IOC explanation, phishing detection, classification, and report summarization.

Data Layer

Database (database/)

SQLite with SQLAlchemy ORM. Tables: threats, events, iocs, reports, users.
Full-text search over threats and events via SQLite FTS5 virtual tables.

ThreatGraph (modules/graph/threat_graph.py)

In-memory directed graph linking nodes (IP, domain, hash, email, actor) via typed edges (resolves_to, hosted_by, communicates_with, attributed_to). Used by the Threat Graph dashboard page.

Cache (modules/threatintel/_base.py)

TTL-based in-memory cache keyed by (source, target). Prevents redundant API calls within the configured window (default 3600s). Thread-safe with RLock.

Data Flow: Full Scan

1. User submits target (Dashboard / CLI / API)
         │
2. Scanner.scan(ScanTask) queues the task
         │
3. WorkerPool dispatches to N parallel module calls
         │
4. Each module queries external API → returns result dict
         │
5. Results merged → RiskEngine.score() → RiskResult (0-100 + level)
         │
6. AIEngine.analyze_threat() → structured AI annotation (optional)
         │
7. ScanResult saved to SQLite (Threat + Event records)
         │
8. EventBus.publish(THREAT_DETECTED) → AlertManager + IOCMonitor
         │
9. AlertManager → Telegram / Discord (if thresholds met)
         │
10. Dashboard auto-refreshes (60s cache TTL) / WebSocket push

Plugin System (plugins/)

Plugins are Python files dropped into the plugins/ directory. They are auto-discovered by PluginLoader at startup. Each plugin inherits from BasePlugin and implements run(target, context) -> PluginResult.

The risk_contribution field from PluginResult is passed to the RiskEngine as an additional factor, so plugins directly influence the risk score without modifying core code.

Security Design

• All inputs sanitized via core/security.py before processing
• JWT authentication on all API endpoints
• RBAC enforced at middleware level
• AuditTrail chains every action with SHA-256
• Rate limiting per IP on scan endpoints
• SQL injection detection at API boundary
• No eval, no shell exec on user inputs

API

OSINTH — REST API Reference

Powered by Aldakaer · Producto: OSINTH

Base URL: http://localhost:8000
Interactive docs: http://localhost:8000/docs
Metrics (Prometheus): http://localhost:8000/metrics

Authentication uses JWT Bearer tokens. Include the header:

Authorization: Bearer <token>

Endpoints

Health

GET /

Returns service identity and version.

{ "name": "OSINTH", "version": "2.0.0", "status": "running" }

GET /health

Returns system health, database status, scanner state and uptime.

{
  "status": "ok",
  "version": "2.0.0",
  "database": "online",
  "scanner": "running",
  "uptime_s": 3600
}

GET /metrics

Prometheus-format metrics (scan counts, queue depth, error rates, latency).

Scan

POST /api/v1/scan — Async scan

Submit a target for background scanning. Returns immediately with a job ID.

Request body:

{
  "target": "evil.com",
  "modules": []
}

Response (202 Accepted):

{
  "job_id": "scan-1748123456789",
  "target": "evil.com",
  "status": "queued"
}

Events will be published to /ws/events as they complete.

POST /api/v1/scan/sync — Synchronous scan

Scans a target and waits for the full result. Use for small targets; prefer async for bulk.

Request body: Same as async scan.

Response (200 OK):

{
  "target": "185.220.101.1",
  "target_type": "ip",
  "risk_level": "critical",
  "risk_score": 87.5,
  "threat_category": "malware_c2",
  "country": "DE",
  "abuse_score": 100,
  "vt_detections": "47/94",
  "shodan_ports": [9001, 9030, 443],
  "mitre_ttps": ["T1071", "T1090", "T1041"],
  "scan_time": "2026-05-24T12:00:00Z"
}

Threats

GET /api/v1/threats

List stored threats with optional filters.

Query parameters:

Response:

{
  "total": 142,
  "offset": 0,
  "limit": 50,
  "data": [ ... ]
}

GET /api/v1/threatintel/{target}

Run a full multi-source ThreatIntel lookup synchronously.

Path parameter: target — IP, domain, URL, hash, or email.

Response: Aggregated results from all configured sources (VirusTotal, Shodan, AbuseIPDB, AlienVault OTX, etc.).

IOC Management

POST /api/v1/ioc/watch

Add an IOC to the continuous monitoring watchlist.

Request body:

{
  "value": "185.220.101.1",
  "ioc_type": "ip",
  "tags": ["tor", "c2"]
}

Response:

{ "status": "added", "value": "185.220.101.1" }

POST /api/v1/ioc/classify

Classify an IOC: detect type, score risk, and return risk factors.

Request body:

{ "value": "d41d8cd98f00b204e9800998ecf8427e" }

Response:

{
  "value": "d41d8cd98f00b204e9800998ecf8427e",
  "ioc_type": "hash_md5",
  "risk_score": 72.5,
  "confidence": 0.91,
  "risk_factors": [...]
}

GET /api/v1/ioc/list

List all IOCs currently on the watchlist.

Query parameters: limit (1–500), offset.

Alerts

POST /api/v1/alert

Send a manual alert through all configured channels (Telegram, Discord).

Request body:

{
  "title": "Suspicious C2 traffic detected",
  "message": "Host 10.0.1.55 is communicating with known C2 at 185.220.101.1",
  "severity": "critical",
  "target": "10.0.1.55"
}

Response:

{ "sent": ["telegram", "discord"] }

Data Ingestion

POST /api/v1/ingest

Ingest structured data into OSINTH (IOC feeds, scan exports).

Request body:

{
  "format": "ioc_feed",
  "data": "185.220.101.1\nevil.com\[email protected]",
  "source": "custom_feed"
}

Supported formats: ioc_feed (one IOC per line), json (array of objects), csv.

Response:

{ "status": "queued", "format": "ioc_feed", "source": "custom_feed" }

Monitor

GET /api/v1/monitor/health

Returns ContinuousMonitor health: worker pool, event bus, scheduler, memory usage.

GET /api/v1/monitor/events

Returns recent events from the EventBus history buffer.

Query parameter: limit (1–500, default 50).

WebSocket Streams

WS /ws/events

Live event stream, filterable by severity and type.

Query parameters:

Example (wscat):

wscat -c "ws://localhost:8000/ws/events?min_severity=high&types=THREAT_DETECTED"

Each message is a JSON event:

{
  "type": "THREAT_DETECTED",
  "severity": "critical",
  "source": "live_detector",
  "target": "185.220.101.1",
  "timestamp": "2026-05-24T12:00:00Z",
  "data": { ... }
}

WS /ws/monitor

System health stream, emitted every 5 seconds.

{
  "workers_alive": 4,
  "queue_depth": 3,
  "events_processed": 1420,
  "uptime_s": 7200
}

Error Responses

All errors return standard HTTP status codes with a JSON body:

{ "detail": "Invalid target" }

Rate Limiting

By default: 60 requests/minute per IP on scan endpoints.
Configure via RATE_LIMIT_MAX and RATE_LIMIT_WINDOW in .env.

Example: Full Scan Workflow

# 1. Submit async scan
JOB=$(curl -s -X POST http://localhost:8000/api/v1/scan \
  -H "Content-Type: application/json" \
  -d '{"target": "evil.com"}' | python -m json.tool)
echo $JOB

# 2. Watch events in real-time
wscat -c "ws://localhost:8000/ws/events?min_severity=medium"

# 3. Query results
curl "http://localhost:8000/api/v1/threats?level=critical&limit=10"

# 4. Classify the domain as an IOC
curl -X POST http://localhost:8000/api/v1/ioc/classify \
  -H "Content-Type: application/json" \
  -d '{"value": "evil.com"}'

Reglas de detección

OSINTH — Detection Rules: Guía Completa

Powered by Aldakaer · Producto: OSINTH

¿Qué son las Detection Rules?

Las Detection Rules son reglas personalizadas que se evalúan automáticamente contra cada scan que ejecuta OSINTH. Cuando una regla hace match, dispara acciones reales — envía alertas, crea casos, escala el riesgo.

Anatomía de una regla

{
  "id": "RULE-A1B2C3D4",
  "name": "Critical IP from Russia",
  "description": "Alert when a critical-risk IP from Russia is detected",
  "enabled": true,
  "logic": "AND",
  "conditions": [
    {"field": "risk_level",  "operator": "=",        "value": "critical"},
    {"field": "target_type", "operator": "=",        "value": "ip"},
    {"field": "country",     "operator": "in_list",  "value": "RU,CN,KP,IR"}
  ],
  "actions": ["notify_telegram", "create_case", "tag_ioc"],
  "trigger_count": 0,
  "last_triggered": null
}

Campos disponibles

Operadores

Notas sobre operadores

contains con listas:

tags contains phishing

Esto dispara si la lista tags contiene el string "phishing".

regex ejemplos:

target regex ^185\.220\.       → IPs que empiezan con 185.220.
target regex \.(exe|dll|bat)$  → archivos ejecutables
target regex \.onion$          → dominios .onion

in_list con múltiples valores:

country in_list RU,CN,KP,IR,SY
source in_list virustotal,malwarebazaar

Lógica AND / OR

AND — TODAS las condiciones deben cumplirse:

{
  "logic": "AND",
  "conditions": [
    {"field": "risk_score",  "operator": ">", "value": "80"},
    {"field": "target_type", "operator": "=", "value": "ip"}
  ]
}

→ Solo dispara si el target ES una IP Y el risk_score es mayor a 80.

OR — CUALQUIER condición dispara la regla:

{
  "logic": "OR",
  "conditions": [
    {"field": "tags",      "operator": "contains", "value": "ransomware"},
    {"field": "tags",      "operator": "contains", "value": "c2"},
    {"field": "risk_score","operator": ">",        "value": "90"}
  ]
}

→ Dispara si hay ransomware, O si hay c2, O si el score supera 90.

Acciones disponibles

notify_telegram

Envía un mensaje al bot de Telegram configurado.

Requisito: TELEGRAM_BOT_TOKEN y TELEGRAM_CHAT_ID en .env

Formato del mensaje:

🚨 [CRITICAL] Rule: Critical IP Alert
Target: 185.220.101.47 (ip)
Risk: CRITICAL (88/100)
Matched: risk_level = critical

notify_discord

POST al webhook de Discord con embed formateado.

Requisito: DISCORD_WEBHOOK_URL en .env

tag_ioc

Registra el target como IOC en la base de datos.

• Si el IOC ya existe → actualiza el risk_score al máximo
• Si es nuevo → crea entrada con tipo, fuente y descripción

escalate_risk

Sube el risk_score del target +20 puntos (máximo 100) y actualiza el risk_level en la DB.

create_case

Crea un Case automático: - Título: [Auto] {nombre_regla} — {target} - Descripción: target, risk score, risk level - Estado: open - Prioridad: según risk_level

No crea duplicados si ya existe un caso abierto para el mismo target+regla.

block_ip

Agrega el IP (solo para target_type = ip) al archivo data/blocklist.txt:

185.220.101.47  # rule:Critical IP Alert  2026-06-01T10:00:00Z

Ejemplos de reglas útiles

1. Alerta inmediata por IP crítica con Tor

{
  "name": "TOR Critical IP",
  "logic": "AND",
  "conditions": [
    {"field": "risk_level", "operator": "=",        "value": "critical"},
    {"field": "tags",       "operator": "contains", "value": "tor"},
    {"field": "target_type","operator": "=",        "value": "ip"}
  ],
  "actions": ["notify_telegram", "block_ip", "create_case"]
}

2. Detectar hash de malware conocido

{
  "name": "Malware Hash High Confidence",
  "logic": "AND",
  "conditions": [
    {"field": "target_type", "operator": "=", "value": "hash"},
    {"field": "risk_score",  "operator": ">", "value": "70"}
  ],
  "actions": ["notify_telegram", "tag_ioc", "escalate_risk"]
}

3. Dominio de phishing activo

{
  "name": "Active Phishing Domain",
  "logic": "AND",
  "conditions": [
    {"field": "target_type", "operator": "=",        "value": "domain"},
    {"field": "tags",        "operator": "contains", "value": "phishing"},
    {"field": "risk_score",  "operator": ">",        "value": "50"}
  ],
  "actions": ["notify_discord", "create_case", "tag_ioc"]
}

4. Cualquier target de países de alto riesgo

{
  "name": "High Risk Countries",
  "logic": "AND",
  "conditions": [
    {"field": "risk_score", "operator": ">",       "value": "40"},
    {"field": "country",    "operator": "in_list", "value": "RU,CN,KP,IR,SY,BY"}
  ],
  "actions": ["notify_telegram", "escalate_risk"]
}

5. VoIP con spam alto (fraude telefónico)

{
  "name": "VoIP Fraud Call",
  "logic": "AND",
  "conditions": [
    {"field": "target_type", "operator": "=", "value": "phone"},
    {"field": "risk_score",  "operator": ">", "value": "60"}
  ],
  "actions": ["notify_telegram", "tag_ioc"]
}

Probar reglas antes de activarlas

1. Ve a 🔔 Detection Rules → 🧪 Test Rule
2. Pega un JSON de ejemplo:

{
  "target": "185.220.101.47",
  "target_type": "ip",
  "risk_score": 88.5,
  "risk_level": "critical",
  "tags": ["tor", "c2", "botnet"],
  "source": "abuseipdb",
  "country": "RU"
}

1. Haz clic en ▶ Evaluate Rules
2. Verás qué reglas habrían disparado y con qué acciones

Estadísticas de reglas

En la tab 📋 My Rules, cada regla muestra: - Trigger Count — cuántas veces ha disparado desde su creación - Last Triggered — fecha y hora del último disparo - Estado — Activa (✅) / Desactivada (⏸️)

Buenas prácticas

1. Empieza con notify antes de activar create_case o block_ip — verifica que la regla no tenga falsos positivos

2. Usa AND para reglas de alta precisión — múltiples condiciones reducen los falsos positivos

3. Usa OR para reglas de alta cobertura — no te pierdas ningún evento importante

4. Ajusta el umbral — risk_score > 75 es más preciso que risk_score > 40

5. Prueba antes de activar — usa el Test Rule con datos reales antes de activar en producción

Ingesta SIEM

OSINTH — SIEM Ingestion: Guía de Configuración

Powered by Aldakaer · Producto: OSINTH

Introducción

OSINTH v4.1 incluye un receptor de logs propio que convierte la plataforma en un mini-SIEM. Puedes recibir logs de cualquier dispositivo de red, servidor o sistema Windows directamente en OSINTH, donde son parseados, almacenados y procesados por el motor de detección automáticamente.

Requisito: Plan SOC/Enterprise

Syslog Receiver (UDP/TCP)

Iniciar el receptor

1. Ve a 📡 SIEM Ingestion → 📶 Syslog Receiver
2. Configura los puertos:
3. UDP: 5140 (por defecto, no requiere privilegios root)
4. TCP: 5141 (por defecto)
5. Haz clic en ▶ Iniciar Receptor Syslog
6. Usa el botón 🧪 Enviar Test para verificar que funciona

ℹ️ Los puertos por defecto son >1024 para no requerir permisos de administrador.
Si necesitas el puerto 514 estándar, usa redirección de puertos (ver abajo).

Usar puerto 514 estándar

Linux (iptables):

# Redirigir 514 UDP → 5140
sudo iptables -t nat -A PREROUTING -p udp --dport 514 -j REDIRECT --to-port 5140

# Redirigir 514 TCP → 5141
sudo iptables -t nat -A PREROUTING -p tcp --dport 514 -j REDIRECT --to-port 5141

# Guardar reglas
sudo iptables-save > /etc/iptables/rules.v4

Windows (netsh):

netsh interface portproxy add v4tov4 listenport=514 listenaddress=0.0.0.0 connectport=5140 connectaddress=127.0.0.1

Configurar dispositivos

Cisco IOS / IOS-XE

logging host TU_IP_OSINTH transport udp port 5140
logging facility local7
logging trap informational
logging on

Cisco ASA / Firepower

logging host INSIDE TU_IP_OSINTH 17/5140
logging trap informational
logging enable

pfSense / OPNsense

System → Settings → Logging/Targets → Add - Remote log: TU_IP_OSINTH - Remote port: 5140 - Transport: UDP

Fortinet FortiGate

config log syslogd setting
    set status enable
    set server "TU_IP_OSINTH"
    set port 5140
    set facility local7
    set format default
end

Linux — rsyslog

# Editar /etc/rsyslog.conf o crear /etc/rsyslog.d/osinth.conf
*.* @TU_IP_OSINTH:5140          # UDP
*.* @@TU_IP_OSINTH:5141         # TCP (más confiable)

# Reiniciar
sudo systemctl restart rsyslog

Linux — syslog-ng

destination d_osinth {
    network("TU_IP_OSINTH"
        port(5140)
        transport(udp)
    );
};

log {
    source(s_sys);
    destination(d_osinth);
};

Windows — NXLog Community

<Output osinth>
    Module      om_udp
    Host        TU_IP_OSINTH
    Port        5140
    OutputType  Syslog_RFC5424
</Output>

<Route to_osinth>
    Path    in_eventlog => osinth
</Route>

Palo Alto Networks

Device → Server Profiles → Syslog → Add
Name: OSINTH
Server: TU_IP_OSINTH
Port: 5140
Format: BSD (RFC3164)
Facility: LOG_USER

Check Point Firewall

cpconfig → Syslog → Add
Host: TU_IP_OSINTH
Port: 5140
Protocol: UDP

Formatos soportados

OSINTH detecta automáticamente el formato de cada mensaje:

RFC 3164 (Syslog clásico)

<14>Jun  1 10:00:00 firewall01 kernel: DROP IN=eth0 SRC=1.2.3.4 DST=10.0.0.1 PROTO=TCP

RFC 5424 (Syslog moderno)

<165>1 2026-06-01T10:00:00Z firewall01 nginx 12345 - - GET /admin HTTP/1.1 403

CEF (Common Event Format — ArcSight, QRadar)

CEF:0|Fortinet|FortiGate|6.0|traffic|traffic forward|7|src=192.168.1.100 dst=185.220.101.47 dpt=443 proto=TCP act=deny

JSON

{"timestamp":"2026-06-01T10:00:00Z","host":"server01","severity":"error","message":"Auth failure for user root"}

Log File Watcher

Monitorear un archivo

Ruta: C:\inetpub\logs\LogFiles\W3SVC1\*.log
       /var/log/nginx/access.log
       /var/log/auth.log
       C:\Windows\System32\winevt\Logs\Security.evtx

Formatos auto-detectados

Rotación de logs

El watcher detecta automáticamente cuando un archivo rota (cambio de inode o reducción de tamaño) y continúa leyendo el nuevo archivo desde el principio.

Windows Event Log (sin agentes)

OSINTH lee el Event Log directamente usando wevtutil — nativo en Windows, sin instalar nada adicional.

Event IDs monitoreados por categoría

Autenticación: | ID | Evento | |----|--------| | 4624 | Inicio de sesión exitoso | | 4625 | Inicio de sesión FALLIDO ⚠️ | | 4648 | Inicio de sesión con credenciales explícitas | | 4740 | Cuenta bloqueada ⚠️ | | 4767 | Cuenta desbloqueada | | 4771 | Kerberos pre-auth fallido ⚠️ |

Privilegios y escalación: | ID | Evento | |----|--------| | 4672 | Privilegios especiales asignados | | 4673 | Servicio privilegiado llamado | | 4720 | Usuario creado ⚠️ | | 4726 | Usuario eliminado ⚠️ | | 4728 | Miembro añadido a grupo de seguridad | | 4732 | Miembro añadido a grupo local |

Persistencia y ejecución: | ID | Evento | |----|--------| | 4688 | Proceso creado | | 4698 | Tarea programada creada ⚠️ | | 7045 | Nuevo servicio instalado ⚠️ | | 4657 | Valor de registro modificado |

Cobertura de rastros: | ID | Evento | |----|--------| | 1102 | Log de auditoría BORRADO 🚨 | | 4719 | Política de auditoría cambiada |

Event Search

Sintaxis de búsqueda

La búsqueda es full-text sobre todos los campos del evento.

Ejemplos útiles:

mimikatz              → busca eventos relacionados con mimikatz
4625                  → todos los inicios de sesión fallidos
192.168.1.100         → eventos de/hacia esa IP
DROP                  → paquetes bloqueados en firewall
failed password       → fallos de autenticación SSH
powershell -enc       → PowerShell con base64 (posible bypass)
wscript.exe           → ejecución de scripts VBS

Filtros combinados

• Severidad: critical / high / medium / low
• Fuente: hostname o IP del dispositivo
• Período: desde 1 hora hasta 30 días

Export de resultados

El botón ⬇️ Export JSON descarga todos los eventos del resultado en formato JSON compatible con Elastic y Splunk.

Retention Policy

Los eventos se acumulan en la base de datos. La política de retención elimina eventos viejos para mantener el rendimiento.

Recomendaciones:

ℹ️ Usa el botón 👁️ Preview para ver cuántos eventos se eliminarían antes de ejecutar el purge.

Integración con Detection Rules

Los eventos ingestados por Syslog, File Watcher y Windows Event Log se pasan automáticamente al motor de detección (LiveDetector). Esto significa que tus Detection Rules también aplican a logs externos.

Ejemplo: Si tienes una regla que detecta risk_score > 70, y un log de firewall contiene un bloqueo de una IP con alta reputación maliciosa, la regla disparará y creará el caso automáticamente.

Troubleshooting

Plugins

OSINTH — Plugin System

Powered by Aldakaer · Producto: OSINTH

OSINTH includes a hot-loadable plugin system that allows you to extend the platform's enrichment capabilities without modifying core code.

How Plugins Work

Plugins are Python files placed in the plugins/ directory. At startup (and optionally on demand), the PluginLoader scans this directory, imports each file, and instantiates classes that inherit from BasePlugin.

When a scan runs, the Scanner calls each active plugin's run() method in addition to the built-in modules. The risk_contribution returned by the plugin is passed to the RiskEngine as an additional weighted factor.

Built-in Plugins

Writing a Custom Plugin

1. Create the plugin file

# plugins/my_enrichment.py
from plugins.base import BasePlugin, PluginResult


class MyEnrichmentPlugin(BasePlugin):
    name        = "my_enrichment"
    version     = "1.0.0"
    description = "Custom enrichment from internal threat feed"
    author      = "Your Name"

    # Declare which target types this plugin handles
    supported_types = ["ip", "domain", "url"]

    def run(self, target: str, context: dict) -> PluginResult:
        """
        Called by the Scanner for each scan target.

        Args:
            target:  The scan target (IP, domain, hash, etc.)
            context: Dict with keys like target_type, existing_results, config

        Returns:
            PluginResult with your enrichment data and risk contribution
        """
        # Your enrichment logic here
        data = self._query_internal_feed(target)

        if data.get("flagged"):
            return PluginResult(
                plugin=self.name,
                data={
                    "flagged": True,
                    "reason":  data.get("reason", ""),
                    "source":  "internal_feed",
                },
                risk_contribution=75.0,   # 0-100: how much this raises the risk score
                tags=["internal_hit"],
            )

        return PluginResult(
            plugin=self.name,
            data={"flagged": False},
            risk_contribution=0.0,
        )

    def _query_internal_feed(self, target: str) -> dict:
        # Replace with your actual query logic
        return {"flagged": False}

2. PluginResult fields

3. BasePlugin methods you can override

Plugin with API Key

# plugins/custom_api_plugin.py
import os
from plugins.base import BasePlugin, PluginResult


class CustomAPIPlugin(BasePlugin):
    name        = "custom_api"
    version     = "1.0.0"
    description = "Enrichment via internal SOC API"

    def is_available(self) -> bool:
        return bool(os.getenv("CUSTOM_API_KEY"))

    def run(self, target: str, context: dict) -> PluginResult:
        if not self.is_available():
            return PluginResult(plugin=self.name, data={},
                                risk_contribution=0.0,
                                error="CUSTOM_API_KEY not configured")

        api_key = os.getenv("CUSTOM_API_KEY")
        # ... make API call ...
        return PluginResult(plugin=self.name, data={"result": "..."}, risk_contribution=20.0)

Add your key to .env:

CUSTOM_API_KEY=your_secret_key_here

Loading Plugins at Runtime

Plugins are auto-discovered from the plugins/ directory at startup. To force a reload without restarting:

from core.plugin_loader import PluginLoader

loader = PluginLoader()
loader.reload()
print(loader.list_plugins())   # ['vt_plugin', 'shodan_plugin', 'my_enrichment', ...]

Via CLI:

python cli.py plugins list
python cli.py plugins reload

Plugin Output in Scan Results

When a plugin runs successfully, its data dict is merged into the scan result under the key plugins.<plugin_name>:

{
  "target": "evil.com",
  "risk_level": "critical",
  "risk_score": 87.5,
  "plugins": {
    "my_enrichment": {
      "flagged": true,
      "reason": "Known C2 domain in internal feed",
      "source": "internal_feed"
    },
    "vt_plugin": {
      "detections": "47/94",
      "last_analysis": "2026-05-24"
    }
  }
}

Best Practices

• Never raise exceptions in run() — catch them and set error in the result. Uncaught exceptions abort the entire scan for that target.
• Respect timeouts — the Scanner has a configurable SCANNER_TIMEOUT. Keep plugin calls under 10 seconds or implement your own timeout.
• Check is_available() before making API calls. If the required key is missing, return a zero-contribution result immediately.
• Use supported_types to skip targets your plugin can't handle (e.g. a hash-only plugin should skip domain targets).
• Thread safety — plugins may be called concurrently. Avoid shared mutable state; use function-local variables.
• Log, don't print — use from core.logger import get_logger; logger = get_logger("my_plugin") instead of print().

Inteligencia predictiva

🧬 Behavioral Predictive Intelligence (v4.3)

Powered by Aldakaer · Producto: OSINTH

El motor que diferencia a OSINTH de cualquier otra herramienta OSINT. No solo recolecta lo que está público — razona, aprende, predice y caza actores por su comportamiento, no solo por sus indicadores.

⚠️ Principio de diseño: OSINTH siempre separa la evidencia verificada ✅ de las hipótesis generadas por IA 🤔. Una coincidencia nunca se presenta como hecho — siempre como "posible relación, pendiente de validación".

🤖 AI Investigator (Profesional+)

Investigación OSINT autónoma. Le das una semilla (email, dominio, IP, hash, teléfono, URL) y el agente:

• Modo ReAct — la IA decide cada paso (qué entidad pivotear, qué transform usar), forma hipótesis y concluye cuando se agotan los leads.
• Modo BFS — expansión rápida automática.
• Investigación recursiva — pivotea solo sobre los hallazgos confirmados.
• Redacta un informe de inteligencia con scoring explicable.

🧬 Entity DNA (6 dimensiones)

Huella genética compuesta de una entidad. Permite encontrar infraestructura "genéticamente similar" aunque el actor cambie dominio, IP y WHOIS.

⏰ Infrastructure Rhythm Fingerprinting

Los actores cambian indicadores, pero sus hábitos no. El ritmo captura: hora de registro (zona horaria), registrador preferido, CA, patrón de subdominios, cadencia de re-registro (WHOIS histórico). Detecta al mismo actor con 0 indicadores compartidos.

🔐 TLS / JARM Fingerprinting

Hash del handshake TLS del servidor. Identifica servidores C2 idénticos aunque cambien dominio, IP y certificado.

🌐 DNS Behaviour

• Fast-flux real (multi-resolución — confirma IPs rotando, no solo sospecha)
• Wildcard DNS, ASN spread, DNSSEC, cadenas CNAME, MX/SPF
• Score de evasión 0-100

🔮 Generative Pivoting

OSINT predictivo: la IA genera lo que debería existir si una hipótesis es cierta y lo verifica con datos reales.

🤔 HIPÓTESIS    → "podrían existir login-banco-*"   (no verificado)
🔍 VERIFICACIÓN → genera candidatos → DNS real
✅ EVIDENCIA     → 2/3 confirmados → la hipótesis gana fuerza

🎯 Cluster automático de campañas

Agrupa todo el Intelligence Lake en campañas (no entidades sueltas): "Campaña #14 · Confianza 93% · 23 dominios · 14 IPs · objetivo: phishing".

🧠 Self-Improving Transforms

La herramienta aprende qué transforms valen la pena por tipo de entidad (Bayesiano + decaimiento temporal) y los prioriza. Feedback humano 👍/👎.

✅ Sistema de corroboración

confidence_final = confidence_base + 0.05 × fuentes_independientes

Una entidad confirmada por GitHub + Gravatar + Breach + DNS sube su confianza. El grafo muestra ×N (corroborado por N fuentes) y colores 🟢🟡🔴.

📧 Inteligencia contextual de leads

• Detecta proveedores de correo masivo (gmail, outlook…) y dominios gigantes (Cloudflare, AWS, Google) → no malgasta tiempo en su infraestructura.
• En el grafo, agrupa la infraestructura del proveedor en un solo nodo "Infraestructura Google (4)" — menos ruido, foco en la identidad.

🗄️ Intelligence Lake + Auto-seeding

Dataset propietario local que crece con cada investigación. Auto-seeding siembra perfiles DNA en lote desde feeds gratis (URLhaus, OpenPhish) para que el matching genético funcione desde el día 1.

🚨 Alerta de reaparición de actor

Si el DNA de una nueva entidad coincide ≥85 % con un actor previo del Lake → notificación automática a Telegram/Discord.

📚 Base de Conocimiento Persistente (v4.4)

OSINTH no es solo una herramienta de búsqueda — es una memoria investigativa permanente. Cada investigación alimenta automáticamente una base de conocimiento reutilizable que da contexto histórico al analista.

Estructura (auto-creada en KnowledgeBase/)

KnowledgeBase/
  ├── osinth.db     # SQLite — entidades, evidencias, relaciones, investigaciones
  ├── evidence/     # blobs JSON de cada evidencia
  ├── history/      # snapshots de investigaciones
  ├── cache/        # reservado
  └── graph/        # grafos exportados

Motor de Entidades

Cada vez que OSINTH encuentra una entidad (14 tipos: dominios, subdominios, IPs, ASN, emails, certificados, tecnologías, organizaciones, redes sociales…):

1. Verifica si ya existe.
2. Si no, la crea.
3. Si existe, actualiza la fecha de observación y fusiona las fuentes.
4. Registra el nivel de confianza (mantiene el más alto).
5. Adjunta la evidencia asociada.

Motor de Evidencias

Toda conclusión almacena: fuente original · fecha de descubrimiento · método · nivel de confianza · evidencia asociada (blob JSON en evidence/).

Motor de Relaciones

Relaciones tipo Dominio → IP, IP → ASN, ASN → Organización, Organización → Dominio… cada una con fuente · fecha · confianza.

Panel "Conocimiento Acumulado"

La página 📚 Knowledge Base muestra: investigaciones realizadas, entidades conocidas, relaciones registradas, evidencias almacenadas y confianza promedio, con búsqueda de conocimiento e historial de investigaciones.

Reutilización: al iniciar una investigación, el agente recupera lo que ya sabe del objetivo — "📚 N investigaciones históricas recuperadas".

Planes

Roadmap

OSINTH — Roadmap

Powered by Aldakaer · Producto: OSINTH

Current Version: v2.0

Released with full modular architecture, AI engine, live detection pipeline, REST API, and Streamlit dashboard.

v2.1 — Q3 2026

Focus: Enterprise indexing and threat mapping

Elasticsearch Integration

• Optional Elasticsearch backend alongside SQLite for large-scale deployments
• Index all threats, events, and IOCs with full Kibana compatibility
• Configurable dual-write mode (SQLite + ES) for migration without downtime
• Pre-built Kibana dashboards for OSINTH data

MITRE ATT&CK Full Mapping

• Map every detected threat to ATT&CK Tactics, Techniques and Sub-techniques
• Navigator export (ATT&CK heat map JSON)
• Per-technique coverage reports showing which rules/modules detect each TTP
• Filter threats by MITRE tactic in the dashboard

STIX/TAXII Export

• Export IOCs and threat reports in STIX 2.1 format
• TAXII 2.1 server endpoint for sharing with other platforms
• Import from external TAXII feeds (ISAC feeds, vendor TI)

Attack Graph D3.js

• Interactive attack chain visualization using D3.js force graph
• Node types: actor → technique → asset → IOC
• Export as SVG/PNG for reports

v2.2 — Q4 2026

Focus: Scale and marketplace

Multi-Tenant Dashboard

• Organization-level data isolation
• Per-tenant API key management
• Tenant-scoped alerts and case management
• Admin panel for user/tenant provisioning

Plugin Marketplace

• Public registry for community plugins
• One-command install: python cli.py plugins install <name>
• Versioning and update management
• Publisher verification and code signing

ML Threat Prediction

• Time-series model trained on historical scan data
• Predicts which IOCs are likely to escalate in the next 24h
• Anomaly scoring using Isolation Forest on behavioral features
• Confidence intervals and feature importance explanations

PCAP Deep Analysis

• Upload and analyze .pcap files in the Forensics page
• Protocol distribution, connection graph, credential extraction (HTTP basic auth, FTP)
• Automatic IOC extraction (IPs, domains, hashes) from packet payloads
• Correlation with existing threat database

v3.0 — 2027

Focus: Distributed architecture and enterprise SSO

Distributed Workers (Redis + Celery)

• Replace in-process WorkerPool with Celery tasks backed by Redis
• Horizontal scaling: add worker nodes without restarting the main service
• Distributed rate limiting and deduplication across nodes
• Task result persistence and replay

GraphQL API

• GraphQL endpoint alongside the existing REST API
• Strongly typed schema for threats, IOCs, events, cases, and assets
• Real-time GraphQL subscriptions (replaces WebSocket streams)
• Introspection and playground at /graphql

Kubernetes Deployment

• Official Helm chart for k8s deployment
• Horizontal Pod Autoscaler for scanner workers
• ConfigMaps for environment management
• Health probes and resource limits pre-configured

Enterprise SSO

• SAML 2.0 and OIDC integration
• Active Directory / LDAP group sync for RBAC
• Okta, Azure AD, Google Workspace connectors
• Session management with forced logout and audit

Backlog (No Target Date)

These items are planned but not scheduled:

• YARA rule manager: upload, test, and deploy custom YARA rules from the dashboard
• Automated threat hunting: scheduled hunts with custom query templates
• Asset vulnerability scanner: CVE correlation against the asset inventory
• Incident response playbook automation: auto-execute containment steps on trigger
• Dark web monitoring subscriptions: alert on new mentions of monitored assets
• Mobile app: React Native companion for alert acknowledgment on the go
• Email threat analysis: full .eml file upload and header/body analysis
• Browser extension: right-click OSINTH scan from any browser

Changelog

v2.0.0 (Current)

• Complete rewrite from v1.x with modular architecture
• FastAPI REST API with WebSocket streaming
• Streamlit dashboard with 30+ pages
• Ollama/LLM integration (local AI, no data leaves the network)
• SQLite FTS5 full-text search
• EventBus + WorkerPool automation pipeline
• ForensicCollector with SHA-256 evidence chain
• RBAC + AuditTrail
• Docker support
• 155 tests passing

v1.x (Legacy)

• Single-file script with basic IP/domain lookup
• CLI-only interface
• No database persistence
• No AI features