Auditor ético de seguridad de red: más de 50 comprobaciones en SMB, RDP, LDAP, SSH, Kerberos y más, con análisis de CVE impulsado por IA y mapeo de cumplimiento OWASP/CIS/NIST.

Inicio rápido · Documentación · Docker · Funciones de IA · Dar estrella en GitHub

Asterion: recorre el laberinto, cada fallo se encuentra con los cuernos

En acción

_{Escaneo local · 127.0.0.1 · 33 hallazgos (0C/4H/2M/3L/24I) · 16 comprobaciones · 57.74s · .NET 8.0.22}

Asterion — informe HTML con insignias de severidad y análisis de IA

_{Informe HTML con temática de Minotauro — insignias de severidad, evidencia expandible, remediación con IA}

Asterion — informe JSON para automatización

_{Informe JSON — mapeo OWASP/CIS/NIST/PCI, datos CVE, legible por máquina}

🎯 ¿Qué es Asterion?

Asterion es un auditor de seguridad de red y dominio listo para producción que pone la ética en primer lugar. Diseñado para probadores de penetración, investigadores de seguridad y equipos de seguridad empresarial, combina el escaneo de vulnerabilidades tradicional con análisis de IA de vanguardia para ofrecer información procesable sobre Windows Active Directory, sistemas Linux e infraestructura de red.

¿Por qué Asterion?

🔒 Ético por diseño: El sistema de tokens de consentimiento previene escaneos no autorizados
🤖 Impulsado por IA: GPT-4, Claude u Ollama local para guías de remediación inteligentes
📊 Informes profesionales: HTML atractivo (con temática de Minotauro) + JSON legible por máquina
🚀 Rápido y eficiente: Escaneo multi-hilo con limitación de velocidad inteligente
💾 Seguimiento persistente: Base de datos SQLite compartida con Argos Suite para el historial de escaneos
🐳 Listo para Docker: Escaneo contenerizado para integración CI/CD

Qué escanea

✨ Características

🛡️ Escaneo de seguridad de red principal```bash

One command, comprehensive network analysis

ast scan --target 10.0.0.0/24 --output html

- **Detección Multi-Método**: análisis de protocolos SMB, RDP, LDAP, Kerberos, SSH, FTP, DNS, SNMP
- **Multihilo**: escaneo concurrente con 1-20 hilos de trabajo
- **Limitación inteligente de velocidad**: regulación configurable de solicitudes (1-20 req/s) para evitar la detección
- **Recopilación de evidencia**: recursos compartidos SMB, consultas LDAP, salida de PowerShell preservada

### 🤖 Análisis con IA

Elige tu proveedor de IA según tus necesidades:

| Proveedor            | Ideal para         | Velocidad        | Costo          | Privacidad     |
| -------------------- | ------------------ | --------------- | ------------- | --------------- |
| **OpenAI GPT-4**     | Calidad de producción | ⚡ Rápido (40s)  | 💰 $0.30/escaneo | 🔒 Estándar     |
| **Anthropic Claude** | Centrado en la privacidad | ⚡ Rápido (50s)  | 💰 $0.35/escaneo | 🔒 Mejorada     |
| **Ollama (Local)**   | Privacidad total   | 🐢 Lento (30min) | 💰 Gratis      | 🔐 100% sin conexión |

**Dos modos de análisis:**

- **Técnico**: Remediación paso a paso con comandos de PowerShell/GPO y fragmentos de configuración
- **Ejecutivo**: Resúmenes en lenguaje sencillo para partes interesadas y directivos

### 📊 Informes profesionales

**Informes JSON** (legibles por máquina)```json
{
  "tool": "asterion",
  "version": "0.2.0",
  "target": "192.168.1.10",
  "riskScore": 10.0,
  "summary": {
    "critical": 3,
    "high": 8,
    "medium": 16,
    "low": 5,
    "info": 2
  },
  "findings": [
    {
      "id": "AST-SMB-003",
      "title": "SMBv1 protocol enabled (EternalBlue vector)",
      "severity": "high",
      "owasp": { "id": "A06", "name": "Vulnerable and Outdated Components" },
      "vulnerabilities": [
        {
          "cve_id": "CVE-2017-0143",
          "cvss_score": 9.8,
          "cwe_id": "CWE-119"
        }
      ],
      "cvss": 9.8
    }
  ],
  "attackChains": [...],
  "diff": { "refScanId": 41, "new": [...], "fixed": [...], "persisting": [...] }
}

Informes HTML (Amigables para humanos)

🎨 Diseño temático de Minotauro (esquema de colores rojo/naranja/morado)
🏷️ Insignias de severidad codificadas por colores
📝 Secciones de evidencia expandibles (recursos compartidos SMB, consultas LDAP, salida de PowerShell)
🤖 Análisis de IA bellamente formateado
📱 Diseño responsive adaptable a móviles

🔐 Sistema de Token de Consentimiento

Asterion impone el hacking ético mediante tecnología. El escaneo agresivo y el análisis de IA requieren prueba de propiedad:```bash

1. Generate token

ast consent generate --domain corp.local

2. Place token (choose one method)

HTTP: Upload to https://corp.local/.well-known/verify-abc123.txt

DNS: Add TXT record: corp.local = "asterion-verify=verify-abc123"

SSH: Create file /tmp/consent_verify-abc123 with token content

3. Verify ownership

ast consent verify --method http --domain corp.local --token verify-abc123

4. Now you can use aggressive mode

ast scan --target corp.local --mode aggressive --use-ai

### 💾 Persistencia de Base de Datos

La base de datos SQLite compartida con Argos Suite lo rastrea todo:

- **Historial de Escaneos**: Fecha, duración, número de hallazgos, desglose por severidad
- **Repositorio de Hallazgos**: Base de datos de vulnerabilidades consultable en todas las herramientas de Argos
- **Dominios Verificados**: Seguimiento de tokens de consentimiento con expiración
- **Análisis de Tendencias**: Comparar escaneos a lo largo del tiempo```bash
# Query recent scans (works for all Argos Suite tools)
sqlite3 ~/.argos/argos.db "SELECT * FROM scans WHERE tool='asterion' ORDER BY started_at DESC LIMIT 10"

# Find critical issues
sqlite3 ~/.argos/argos.db "SELECT * FROM v_critical_findings WHERE tool='asterion'"

🚀 Inicio Rápido

Requisitos Previos

Todas las Plataformas:

.NET 8.0 SDK (Descargar)
Python 3.10+ (Descargar)
git (para clonar el repositorio)

Opcional:

Docker (para escaneo en contenedores)
Claves de API (para análisis de IA - OpenAI o Anthropic)

Instalación — Configuración Automatizada (Recomendada)

Linux / macOS```bash

Clone repository

git clone https://github.com/rodhnin/asterion-network-minotaur.git cd asterion-network-minotaur

Run setup script

chmod +x scripts/setup.py python3 scripts/setup.py

**El script realizará:**

1. ✅ Verificar requisitos previos (.NET, Python)
2. ✅ Instalar dependencias de Python
3. ✅ Configurar la base de datos compartida de Argos Suite
4. ✅ Compilar Asterion en modo Release
5. ✅ Crear directorios (~/.asterion, ~/.argos)
6. ✅ Crear script de envoltura `/usr/local/bin/ast` (opcional)

#### Windows (PowerShell)```powershell
# Clone repository
git clone https://github.com/rodhnin/asterion-network-minotaur.git
cd asterion-network-minotaur

# Run setup (right-click PowerShell > Run as Administrator)
.\scripts\setup.ps1

El script realizará:

✅ Verificar requisitos previos (.NET, Python)
✅ Instalar dependencias de Python
✅ Configurar la base de datos compartida de Argos Suite
✅ Compilar Asterion en modo Release
✅ Crear directorios (%USERPROFILE%.asterion, %USERPROFILE%.argos)

Instalación — Configuración manual

Si los scripts automatizados no funcionan en tu sistema, sigue estos pasos:

Paso 1: Clonar el repositorio```bash

git clone https://github.com/rodhnin/asterion-network-minotaur.git cd asterion-network-minotaur

#### Paso 2: Instalar dependencias

**Linux/macOS:**```bash
pip3 install -r scripts/requirements.txt

Windows (Símbolo del sistema):```cmd pip install -r scripts\requirements.txt

#### Paso 3: Configurar la base de datos

**Linux/macOS:**```bash
python3 scripts/db_migrate.py

Windows:```cmd python scripts\db_migrate.py

#### Paso 4: Compilar Asterion

**Todas las plataformas:**```bash
dotnet build -c Release

Paso 5: Crear directorios de configuración

Linux/macOS:```bash mkdir -p ~/.asterion/reports mkdir -p ~/.asterion/consent-proofs mkdir -p ~/.argos

**Windows (PowerShell):**```powershell
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.asterion\reports" | Out-Null
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.asterion\consent-proofs" | Out-Null
New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.argos" | Out-Null

Paso 6: (solo Linux/macOS) Crear comando global```bash

Create wrapper script

sudo nano /usr/local/bin/ast

Paste this content:

#!/bin/bash exec dotnet "$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/src/Asterion/bin/Release/net8.0/Asterion.dll" "$@"

Make executable

sudo chmod +x /usr/local/bin/ast

#### Paso 7: Configurar la clave de API (opcional)

Una única variable de entorno funciona para todos los proveedores de IA (OpenAI, Anthropic):

**Linux/macOS:**```bash
export AI_API_KEY="sk-proj-..."   # OpenAI key
# or
export AI_API_KEY="sk-ant-..."    # Anthropic key
# Add to ~/.bashrc or ~/.zshrc to make permanent

Windows (PowerShell):```powershell $env:AI_API_KEY = "sk-proj-..."

Or permanently:

[Environment]::SetEnvironmentVariable("AI_API_KEY", "sk-proj-...", [System.EnvironmentVariableTarget]::User)

#### Paso 8: Verificar la instalación

**Linux/macOS (si se creó el enlace simbólico):**```bash
ast version

Windows o invocación directa:```cmd .\src\Asterion\bin\Release\net8.0\ast.exe version

Or with dotnet

dotnet .\src\Asterion\bin\Release\net8.0\Asterion.dll version

### Tu Primer Escaneo

#### Escaneo Automático de la Red Local

**¡Asterion puede descubrir y escanear automáticamente tu red local!**

**Windows (PowerShell) — Después de la Instalación (Recomendado):**```powershell
# Test on localhost (simple)
ast scan --target localhost --output html

# Scan local subnet with AI analysis
ast scan --target 192.168.1.0/24 --output both --threads 10 --rate 5 --use-ai --ai-tone both

# Domain scan with authentication
ast scan --target corp.local --auth "CORP\admin:Password123" --use-ai

Windows (PowerShell) — Sin configuración de PATH:```powershell

Scan localhost (full path)

.\src\Asterion\bin\Release\net8.0\ast.exe scan --target localhost --output html --use-ai --ai-tone both

Scan local subnet (full path)

.\src\Asterion\bin\Release\net8.0\ast.exe scan --target 192.168.1.0/24 --output both --threads 10 --rate 5

**Linux/macOS:**```bash
# Scan localhost
ast scan --target localhost \
  --output html \
  --use-ai \
  --ai-tone both

# Scan local subnet (e.g., 192.168.1.0/24)
ast scan --target 192.168.1.0/24 \
  --output both \
  --threads 10 \
  --rate 5

# Scan domain
ast scan --target corp.local \
  --auth "CORP\admin:Password123" \
  --output html \
  --use-ai

Formatos de salida

Asterion admite tres formatos de salida mediante --output:

Opciones de tono de IA

Controla cómo se formatea el análisis de IA mediante --ai-tone:

Tono	Caso de uso	Salida
technical

Ejemplos básicos

Escaneo de red simple (sin autenticación):```bash ast scan --target 10.0.0.0/24

**Con informe HTML:**```bash
ast scan --target 192.168.1.0/24 --output html

Escaneo autenticado (dominio de Windows):```bash ast scan --target dc01.corp.local
--auth "CORP\Administrator:P@ssw0rd"
--output html

**Con análisis de IA (técnico + ejecutivo):**```bash
ast scan --target 10.0.0.0/24 \
  --use-ai \
  --ai-tone both \
  --output html

Escaneo rápido (10 hilos, 10 req/s):```bash ast scan --target 10.0.0.0/24
--threads 10
--rate 10
--output json

#### Ubicaciones de los informes

**Instalación nativa:**

- Informes: `~/.asterion/reports/`
- Base de datos: `~/.argos/argos.db`

**Windows:**

- Informes: `%USERPROFILE%\.asterion\reports\`
- Base de datos: `%USERPROFILE%\.argos\argos.db`

**Despliegue con Docker:**

- Informes: `docker/reports/`
- Base de datos: `docker/data/argos.db`

**🎉 ¡Éxito!** Revisa el directorio de informes para ver los archivos de salida JSON y HTML.

---

### Ejecutar en Docker

**Despliegue automático:**```bash
cd docker
./deploy.sh    # Linux/macOS
.\deploy.ps1   # Windows

Despliegue manual de Docker:```bash

Build and start

docker compose up -d

Run a scan

docker compose exec asterion dotnet /app/ast.dll scan
--target 192.168.1.0/24
--output html

View logs

docker compose logs -f asterion

Stop services

docker compose down

---

## 📘 Guía de uso

### Estructura de comandos```bash
ast <command> [options]

Available Commands:

scan — Ejecutar un escaneo de seguridad
consent — Gestionar tokens de consentimiento
version — Mostrar información de versión

Opciones del comando Scan

Flags principales

Flags de credenciales

Flags de IA

Ejemplos de referencia rápida

Escaneo básico```bash

Scan local subnet (default: JSON output, safe mode)

ast scan --target 192.168.1.0/24

Scan with HTML report

ast scan --target 192.168.1.0/24 --output html

Scan specific IP

ast scan --target 10.0.0.5 --output both

#### Selección de Objetivos de Red```bash
# CIDR notation
ast scan --target 10.0.0.0/24

# IP range
ast scan --target 192.168.1.10-50

# Domain name
ast scan --target corp.local

# Single host
ast scan --target 192.168.1.1

Optimización del rendimiento```bash

Slow, stealthy scan (3 threads, 2 req/s)

ast scan --target 10.0.0.0/24 --threads 3 --rate 2

Fast scan (15 threads, 15 req/s)

ast scan --target 10.0.0.0/24 --threads 15 --rate 15

Specific ports only

ast scan --target 10.0.0.0/24 --ports 445,3389,22,139

#### Escaneo de Dominios de Windows```bash
# Network + LDAP/Kerberos/AD checks
ast scan --target dc01.corp.local \
  --auth "CORP\Administrator:P@ssw0rd"

# WinRM: remote firewall, registry, services, privesc
ast scan --target 192.168.1.10 \
  --winrm "CORP\admin:P@ssw0rd"

# Full Windows audit: auth + WinRM + AI + HTML
ast scan --target 192.168.1.10 \
  --auth "CORP\admin:P@ssw0rd" \
  --winrm "CORP\admin:P@ssw0rd" \
  --use-ai --ai-tone technical -o both -v

# With NTLM hash (Pass-the-Hash)
ast scan --target 10.0.0.5 \
  --auth-ntlm "admin:aad3b435b51404eeaad3b435b51404ee:8846f7eaee8fb117ad06bdd830b7586c"

# Diff against last scan (track security changes)
ast scan --target 192.168.1.10 --winrm "CORP\admin:P@ssw0rd" --diff last -o both

Auditoría de sistemas Linux```bash

Remote Linux SSH scan (password)

ast scan --target 10.0.0.25 --ssh "admin:password"

SSH with sudo elevation (for privileged checks)

ast scan --target 10.0.0.25 --ssh "admin:password" --sudo-password "sudopass"

SSH key authentication

ast scan --target 10.0.0.25 --ssh-key "admin:~/.ssh/id_rsa"

Via bastion host

ast scan --target internal.corp.local
--bastion "bastion.corp.local:jumpuser:~/.ssh/bastion_key"
--ssh "admin:password"

Full Linux audit: SSH + sudo + AI + HTML

ast scan --target 10.0.0.25
--ssh "root:toor"
--use-ai --ai-tone technical -o both -v

#### Análisis impulsado por IA```bash
# Technical remediation (default, for security teams)
ast scan --target 10.0.0.5 \
  --ssh "root:pass" \
  --use-ai --ai-tone technical -o html

# Executive summary (for management)
ast scan --target 10.0.0.5 \
  --use-ai --ai-tone non_technical -o html

# Both formats + streaming output
ast scan --target 10.0.0.5 --use-ai --ai-tone both --ai-stream -o both

# Agent mode (NVD CVE lookup tool enabled)
ast scan --target 10.0.0.5 --ssh "root:pass" --use-ai --ai-agent -v

# Compare two models
ast scan --target 10.0.0.5 --use-ai \
  --ai-compare "openai/gpt-4o-mini-2024-07-18,anthropic/claude-3-5-haiku-20241022"

# Enforce cost budget
ast scan --target 10.0.0.5 --winrm "admin:pass" --use-ai --ai-budget 0.05

Depuración```bash

Verbose output

ast scan --target 10.0.0.5 -v

Verbose + custom timeout

ast scan --target 10.0.0.5 -v --timeout 20

Test connectivity only (timeout 5s)

ast scan --target 10.0.0.5 --timeout 5

### Gestión de tokens de consentimiento

#### Generar token de consentimiento```bash
ast consent generate --domain corp.local
# Output: Token: verify-a3f9b2c1d8e4f5a6

Verificar Consentimiento (3 Métodos)

Método HTTP (coloque el archivo en el servidor web):```bash

1. Create file at: https://corp.local/.well-known/verify-a3f9b2c1d8e4f5a6.txt

2. Verify:

ast consent verify
--method http
--domain corp.local
--token verify-a3f9b2c1d8e4f5a6

**Método DNS** (añadir registro TXT):```bash
# 1. Add DNS TXT record: corp.local = "asterion-verify=verify-a3f9b2c1d8e4f5a6"
# 2. Verify:
ast consent verify \
  --method dns \
  --domain corp.local \
  --token verify-a3f9b2c1d8e4f5a6

Método SSH (crear archivo en el sistema):```bash

1. Create file: /tmp/consent_verify-a3f9b2c1d8e4f5a6

2. Verify:

ast consent verify
--method ssh
--domain corp.local
--token verify-a3f9b2c1d8e4f5a6
--ssh "user:password"

#### Ejecutar modo agresivo```bash
# After verifying consent token:
ast scan --target corp.local --mode aggressive

Escenarios del Mundo Real

Escenario 1: Evaluación Rápida de la Red```bash

Fast, no-auth scan with HTML report

ast scan --target 192.168.1.0/24 --output html --threads 10 --rate 10

#### Escenario 2: Auditoría completa del dominio```bash
# Complete Windows AD assessment with AI analysis
ast scan --target corp.local \
  --auth "CORP\admin:P@ssw0rd" \
  --use-ai \
  --ai-tone both \
  --output both \
  --threads 8 \
  --rate 8

Escenario 3: Escaneo sigiloso```bash

Slow, careful scan to avoid detection

ast scan --target 10.0.0.0/24
--threads 2
--rate 1
--timeout 20
--output json

#### Escenario 4: Pruebas de Penetración```bash
# Generate consent first
ast consent generate --domain internal.corp

# Place token and verify
ast consent verify --method http --domain internal.corp --token <token>

# Run aggressive assessment
ast scan --target internal.corp \
  --mode aggressive \
  --auth "CORP\pentest:P@ssw0rd" \
  --use-ai \
  --output both

🤖 Análisis impulsado por IA

Asterion utiliza LangChain 1.0.0 con soporte para múltiples proveedores de IA mediante un puente de Python, brindándote flexibilidad según tus requisitos de seguridad, privacidad y presupuesto.

Proveedores compatibles

OpenAI GPT-4 Turbo

Mejor para: Uso en producción

⭐ Calidad: Excelente (5/5)
⚡ Velocidad: ~60–80 segundos (gpt-4o-mini, por defecto)
💰 Costo: ~$0.004–0.009 por escaneo (gpt-4o-mini con ~30 hallazgos)
🔒 Privacidad: Estándar (datos cifrados en tránsito)```bash export AI_API_KEY="sk-proj-..." # Use AI_API_KEY for all providers

#### Anthropic Claude

**Mejor para: Privacidad mejorada**

- ⭐ Calidad: Excelente (5/5)
- ⚡ Velocidad: ~50–70 segundos
- 💰 Costo: ~$0.007–0.015 por escaneo (claude-3-5-haiku)
- 🔒 Privacidad: Mejorada (enfoque centrado en la privacidad de Anthropic)```bash
export AI_API_KEY="sk-ant-..."   # Same variable, Anthropic key format

Ollama (Modelos Locales)

Mejor para: Privacidad completa

⭐ Calidad: Buena (3/5)
🐢 Velocidad: ~30 minutos (CPU) o ~90 segundos (GPU)
💰 Costo: Gratis
🔐 Privacidad: 100% sin conexión (los datos nunca salen de tu máquina)```bash

Install Ollama: https://ollama.ai

ollama pull llama3.2

### Privacidad y Seguridad

**Sanitización automática**
Antes de enviar datos a los proveedores de IA, Asterion elimina automáticamente:

- ✅ Tokens de consentimiento
- ✅ Credenciales de dominio (contraseñas, hashes NTLM)
- ✅ Información de identificación personal (PII)
- ✅ Direcciones IP internas (cuando se solicite)
- ✅ Rutas de recursos compartidos SMB con datos sensibles

**Solo opt-in**

- El análisis de IA requiere el indicador explícito `--use-ai`
- El escaneo agresivo requiere un token de consentimiento verificado
- Usted controla qué proveedor ve sus datos

**Para máxima privacidad**
Use Ollama localmente. Aunque es más lento y menos preciso, sus datos de escaneo nunca salen de su máquina.

### Cambio de proveedores

**Método actual (v0.2.0):** Edite `config/defaults.yaml````yaml
ai:
    langchain:
        provider: "ollama" # Changed from "openai"
        model: "llama3.2" # Ollama model
        ollama_base_url: "http://localhost:11434"

Próximamente en v0.3.0: Menú de configuración interactivo (estilo Metasploit)```bash

Future feature

ast --show-options ast --set ai.provider=anthropic ast --save-profile privacy-mode

---

## 🧪 Laboratorio de pruebas seguras

**⚠️ ¡NUNCA escanees redes de producción sin permiso por escrito!**

Usa nuestro laboratorio Docker para practicar de forma segura:

### Configurar el entorno de pruebas```bash
# Navigate to docker directory
cd docker

# Deploy vulnerable network lab
docker-compose -f compose.testing.yml up -d

# Wait for services to start (~60 seconds)
docker-compose -f compose.testing.yml logs -f

# Create vulnerable conditions
docker-compose -f compose.testing.yml exec windows-target powershell -c "Disable-NetFirewallProfile -All"

Escanear el laboratorio```bash

Return to project root

cd ..

Run scan against lab network

ast scan --target 172.20.0.0/24 --output html

Try authenticated scan

ast scan --target 172.20.0.2 --auth "LAB\admin:P@ssw0rd123" --output both

Try AI analysis (requires API key)

ast scan --target 172.20.0.0/24 --use-ai --output html

### Limpieza```bash
cd docker
docker-compose -f compose.testing.yml down -v  # -v removes all data

Para escenarios de pruebas detallados, consulta docs/TESTING_GUIDE.md

🔒 Ética y Legal

La Regla de Oro

Solo escanea redes y sistemas que poseas o para los que tengas permiso explícito por escrito.

Cumplimiento del Consentimiento

Asterion implementa controles técnicos para prevenir el mal uso:

Marco Legal

El acceso no autorizado a sistemas informáticos es ilegal en la mayoría de las jurisdicciones:

🇺🇸 EE. UU.: Computer Fraud and Abuse Act (CFAA)
🇬🇧 Reino Unido: Computer Misuse Act 1990
🇪🇺 UE: Directiva 2013/40/UE
🌍 Internacional: Diversas leyes de ciberdelincuencia

Buenas Prácticas

✅ Obtén autorización por escrito antes de escanear
✅ Define el alcance claramente (qué redes/dominios/IPs)
✅ Documenta todo (consentimiento, hallazgos, remediación)
✅ Usa primero el modo seguro para establecer una línea base
✅ Informa los hallazgos de forma responsable (divulgación coordinada)
❌ Nunca explotes vulnerabilidades sin permiso explícito (p. ej., sin explotación de EternalBlue)
❌ Nunca escanees redes de terceros (p. ej., google.com, microsoft.com)

Para pautas éticas completas, consulta docs/ETHICS.md

🐳 Despliegue con Docker

Scripts de Despliegue Interactivos (Recomendado)

Asterion proporciona scripts de despliegue multiplataforma:

Linux/macOS:```bash cd docker ./deploy.sh

**Windows (PowerShell):**```powershell
cd docker
.\deploy.ps1

Opciones de despliegue:

Producción - Desplegar Asterion Scanner
Detener todos los servicios
Eliminar todos los contenedores y datos (restablecer)

Despliegue manual de Docker

Linux/macOS:```bash cd docker docker compose up -d

Execute scans (note the dotnet wrapper)

docker compose exec asterion dotnet /app/ast.dll scan --target 10.0.0.0/24

View logs

docker compose logs -f asterion

Stop service

docker compose down

**Windows (PowerShell):**```powershell
cd docker
docker compose up -d

# Execute scans (note the dotnet wrapper)
docker compose exec asterion dotnet /app/ast.dll scan --target 10.0.0.0/24

# View logs
docker compose logs -f asterion

# Stop service
docker compose down

Datos persistentes:

Informes: ./reports/ → directorio host docker/reports/
Base de datos: ./data/argos.db → directorio host docker/data/argos.db (BD compartida de Argos Suite)
Registros: ./logs/asterion.log → directorio host docker/logs/asterion.log

Nota: Asterion detecta automáticamente el entorno Docker mediante la variable de entorno ASTERION_IN_DOCKER.

Para documentación completa de Docker (Linux/Windows), consulte: docker/README.md

📊 Comprensión de los informes

Estructura del informe

Instalación nativa:``` ~/.asterion/ ├── reports/ │ ├── asterion_report_10_0_0_0_24_20260419_143000.json # Machine-readable │ └── asterion_report_10_0_0_0_24_20260419_143000.html # Human-friendly (Minotaur-themed) └── consent-proofs/ └── corp_local_verify-abc123_20260419.txt

~/.argos/ ├── argos.db # Shared Argos Suite database └── logs/ └── argos.log # Shared log file

**Despliegue con Docker:**```
asterion-network-minotaur/
├── docker/
│   ├── reports/
│   │   ├── asterion_report_10_0_0_0_24_20260419_143000.json
│   │   └── asterion_report_10_0_0_0_24_20260419_143000.html
│   ├── data/
│   │   └── argos.db          # Shared Argos Suite database (Docker)
│   ├── logs/
│   │   └── asterion.log
│   └── workspace/
│       └── consent-proofs/

Nota: El entorno Docker se detecta automáticamente mediante la variable de entorno ASTERION_IN_DOCKER.

Esquema del informe JSON```json

{ "tool": "asterion", "version": "0.2.0", "target": "10.0.0.0/24", "date": "2026-04-13T14:30:00Z", "mode": "safe", "summary": { "critical": 12, "high": 8, "medium": 15, "low": 5, "info": 20 }, "findings": [ { "id": "AST-SMB-003", "title": "SMBv1 enabled (EternalBlue vulnerability)", "severity": "critical", "confidence": "high", "description": "SMBv1 is enabled on this system. This protocol is vulnerable to EternalBlue (CVE-2017-0143), a critical remote code execution vulnerability exploited by WannaCry ransomware.", "evidence": { "type": "smb", "value": "SMBv1 negotiated successfully", "context": "Port 445/tcp open, SMB signing not required" }, "recommendation": "URGENT - Disable SMBv1 immediately:\n\nPowerShell:\nDisable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol -NoRestart\n\nGroup Policy:\nComputer Configuration → Administrative Templates → MS Security Guide\n→ Configure SMBv1 client driver startup = Disabled\n→ Configure SMBv1 server = Disabled\n\nVerify:\nGet-SmbServerConfiguration | Select EnableSMB1Protocol", "references": [ "https://docs.microsoft.com/en-us/windows-server/storage/file-server/troubleshoot/detect-enable-and-disable-smbv1-v2-v3", "https://nvd.nist.gov/vuln/detail/CVE-2017-0143" ], "affected_component": "SMB Server" }, { "id": "AST-LDAP-001", "title": "LDAP anonymous bind allowed", "severity": "high", "confidence": "high", "description": "LDAP server allows anonymous bind, permitting unauthenticated enumeration of domain users, groups, and configuration.", "evidence": { "type": "ldap", "value": "Anonymous bind successful to port 389/tcp", "context": "Retrieved domain base DN: DC=corp,DC=local" }, "recommendation": "Disable LDAP anonymous bind:\n\nGroup Policy:\nComputer Configuration → Policies → Windows Settings → Security Settings → Local Policies → Security Options\n→ Network access: Allow anonymous SID/Name translation = Disabled\n→ Network access: Do not allow anonymous enumeration of SAM accounts = Enabled\n→ Network access: Do not allow anonymous enumeration of SAM accounts and shares = Enabled\n\nRegistry:\nreg add "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v RestrictAnonymous /t REG_DWORD /d 1 /f", "affected_component": "LDAP Server" }, { "id": "AST-RDP-001", "title": "RDP without Network Level Authentication (NLA)", "severity": "high", "confidence": "high", "description": "Remote Desktop Protocol (RDP) is configured without Network Level Authentication (NLA). This allows unauthenticated attackers to reach the login screen and attempt brute-force attacks.", "evidence": { "type": "rdp", "value": "RDP port 3389/tcp open, NLA not required", "context": "Encryption level: High" }, "recommendation": "Enable Network Level Authentication:\n\nPowerShell:\n(Get-WmiObject -class Win32_TSGeneralSetting -Namespace root\cimv2\terminalservices -Filter "TerminalName='RDP-tcp'").SetUserAuthenticationRequired(1)\n\nGroup Policy:\nComputer Configuration → Administrative Templates → Windows Components → Remote Desktop Services → Remote Desktop Session Host → Security\n→ Require user authentication for remote connections by using Network Level Authentication = Enabled", "affected_component": "RDP Server" } ], "notes": { "scan_duration_seconds": 67.5, "targets_scanned": 12, "rate_limit_applied": true, "scope_limitations": "Scan limited to network services. Local system checks require SSH/WinRM credentials.", "false_positive_disclaimer": "Manual verification recommended for all findings before remediation." }, "aiAnalysis": { "executiveSummary": "The network scan identified 12 critical security vulnerabilities requiring immediate attention...", "technicalRemediation": "### Critical Issues\n\n1. \n - Affected systems: 10.0.0.5, 10.0.0.10\n - Remediation: Disable SMBv1...", "generatedAt": "2026-04-19T14:35:00Z", "modelUsed": "gpt-4o-mini-2024-07-18", "provider": "openai" } }

### Características del Informe HTML

- **📊 Panel Ejecutivo**: Tarjetas de resumen con recuentos de severidad y marca Minotaur
- **🤖 Análisis de IA**: Secciones expandibles para información ejecutiva y técnica
- **🔍 Hallazgos Detallados**: Organizados por severidad con comandos de remediación de PowerShell/GPO
- **📋 Evidencia**: Recursos compartidos SMB, consultas LDAP, configuraciones RDP, salida de PowerShell
- **🔗 Referencias Externas**: Enlaces a CVE, documentación de Microsoft, guías de OWASP
- **📱 Adaptable a Móviles**: Funciona en todos los dispositivos
- **🎨 Tema Minotaur**: Esquema de colores rojo/naranja/morado

---

## 📁 Estructura del Proyecto```
asterion-network-minotaur/
│
├── src/
│   ├── Asterion/                     # Main C# application
│   │   ├── Asterion.csproj           # .NET project file
│   │   │
│   │   ├── Checks/                   # Security check modules
│   │   │   ├── ICheck.cs             # Check interface
│   │   │   ├── BaseCheck.cs          # Abstract base class (350 lines)
│   │   │   ├── CheckCategory.cs      # Check category enum
│   │   │   │
│   │   │   ├── CrossPlatform/        # Network service scanners (work from any OS)
│   │   │   │   ├── PortScanner.cs    # TCP port scanning
│   │   │   │   ├── SmbScanner.cs     # SMB/CIFS security (42KB)
│   │   │   │   ├── RdpScanner.cs     # RDP configuration (24KB)
│   │   │   │   ├── LdapScanner.cs    # LDAP/AD security (38KB)
│   │   │   │   ├── KerberosScanner.cs # Kerberos security (22KB)
│   │   │   │   ├── SnmpScanner.cs    # SNMP vulnerabilities (21KB)
│   │   │   │   ├── DnsScanner.cs     # DNS misconfigurations (14KB)
│   │   │   │   ├── FtpScanner.cs     # FTP security (27KB)
│   │   │   │   ├── TlsScanner.cs     # TLS/SSL certificate checks
│   │   │   │   ├── SysvolCheck.cs    # SYSVOL/GPP password exposure
│   │   │   │   ├── AdAggressiveCheck.cs # AS-REP roasting, delegation, weak ACLs
│   │   │   │   └── WinRmChecks.cs    # Remote Windows audit via WS-Man
│   │   │   │
│   │   │   ├── Windows/              # Local Windows system checks
│   │   │   │   ├── WinFirewallCheck.cs # Firewall configuration
│   │   │   │   ├── WinRegistryCheck.cs # Registry security
│   │   │   │   ├── AdPolicyCheck.cs    # Active Directory policies
│   │   │   │   ├── WinServicesCheck.cs # Service misconfigurations
│   │   │   │   └── PrivEscCheckWin.cs  # Windows privilege escalation
│   │   │   │
│   │   │   └── Linux/                # Local/remote Linux checks (via SSH)
│   │   │       ├── LinuxFirewallCheck.cs # iptables/nftables/ufw
│   │   │       ├── SshConfigCheck.cs     # SSH hardening
│   │   │       ├── SambaNfsCheck.cs      # Samba/NFS security
│   │   │       └── PrivEscCheckLinux.cs  # SUID, sudo misconfig
│   │   │
│   │   ├── Core/                     # Core infrastructure
│   │   │   ├── Orchestrator.cs       # Main execution engine (1,243 lines)
│   │   │   ├── Config.cs             # YAML configuration loader
│   │   │   ├── ScanOptions.cs        # Scan configuration
│   │   │   ├── Database.cs           # SQLite operations
│   │   │   ├── ConsentValidator.cs   # Consent token verification
│   │   │   ├── SshConnectionManager.cs  # SSH.NET wrapper (password/key/bastion)
│   │   │   ├── WinRmConnectionManager.cs # WS-Man HTTP/NTLM (Linux → Windows)
│   │   │   ├── AttackChainAnalyzer.cs   # Multi-step attack chain correlation
│   │   │   ├── NtlmSpnego.cs         # NTLM/SPNEGO auth implementation
│   │   │   ├── NtlmV2Auth.cs         # NTLMv2 auth implementation
│   │   │   │
│   │   │   ├── Output/
│   │   │   │   └── ReportBuilder.cs  # Report generation (risk score, labels)
│   │   │   │
│   │   │   └── Utils/
│   │   │       ├── NetworkUtils.cs   # Network operations
│   │   │       ├── CidrParser.cs     # CIDR/IP range parsing
│   │   │       ├── AuthenticationManager.cs # Credential handling
│   │   │       └── OsDetector.cs     # Per-target OS detection (SSH/SMB/TTL)
│   │   │
│   │   ├── Models/                   # Data models
│   │   │   ├── Report.cs             # Main report structure
│   │   │   ├── Finding.cs            # Security finding (OWASP/CVE/Compliance)
│   │   │   ├── Evidence.cs           # Finding proof
│   │   │   ├── ConsentInfo.cs        # Consent verification
│   │   │   └── AiAnalysis.cs         # AI-generated content (cost tracking)
│   │   │
│   │   ├── Program.cs                # Application entry point
│   │   └── Cli.cs                    # CLI argument parser (all flags)
│   │
│   └── Asterion.sln                  # Visual Studio solution
│
├── scripts/                          # Python bridge scripts
│   ├── ai_analyzer.py                # LangChain AI integration (stream/agent/compare)
│   ├── cve_lookup.py                 # NVD API v2 CVE enrichment
│   ├── owasp.py                      # OWASP Top 10 mapping (139 entries)
│   ├── compliance.py                 # CIS/NIST/PCI mapping (95 entries)
│   ├── db_migrate.py                 # Database setup
│   ├── render_html.py                # HTML report generation (Jinja2)
│   ├── setup.sh                      # Linux/macOS installation script
│   ├── setup.ps1                     # Windows PowerShell setup
│   └── requirements.txt              # Python dependencies
│
├── config/                           # Configuration files
│   ├── defaults.yaml                 # Default settings
│   └── prompts/                      # AI prompt templates
│       ├── technical.txt             # Technical remediation prompts
│       └── non_technical.txt         # Executive summary prompts
│
├── db/
│   └── migrate.sql                   # Database schema (shared with Argos Suite)
│
├── docker/                           # Docker deployment
│   ├── Dockerfile                    # Production image
│   ├── docker-compose.yml            # Production deployment
│   ├── compose.testing.yml           # Vulnerable lab environment
│   ├── .dockerignore
│   ├── .env.example
│   └── README.md                     # Docker instructions
│
├── docs/                             # Documentation
│   ├── AI_INTEGRATION.md             # AI setup guide
│   ├── CONSENT.md                    # Consent token system
│   ├── DATABASE_GUIDE.md             # SQLite schema and queries
│   ├── ETHICS.md                     # Ethical guidelines
│   ├── NETWORK_CHECKS.md             # Complete check catalog (50+ checks)
│   └── ROADMAP.md                    # Development roadmap
│
├── schema/
│   └── report.schema.json            # Argos Suite unified schema
│
├── templates/
│   └── report.html.j2                # HTML report template (35KB, Minotaur-themed)
│
├── assets/
│   └── ascii.txt                     # Minotaur ASCII art banner
│
├── CHANGELOG.md                      # Version history
├── README_PATTERN.md                 # README visual branding guide
├── LICENSE                           # MIT License
└── README.md                         # This file

Estadísticas:

Total de archivos C#: ~46 archivos
Total de scripts Python: 6 scripts
Plataforma: Multiplataforma (.NET 8.0)
Lenguaje: C# (principal), Python (puente de IA)

🗺️ Hoja de Ruta

v0.1.0 — Lanzamiento inicial ✅ (noviembre de 2025)

✅ Más de 50 comprobaciones de seguridad (SMB, RDP, LDAP, Kerberos, Windows, Linux)
✅ Análisis impulsado por IA (OpenAI, Anthropic, Ollama)
✅ Sistema de token de consentimiento (verificación HTTP + DNS + SSH)
✅ Informes JSON + HTML (tema Minotaur), base de datos compartida de Argos Suite
✅ Soporte Docker, multiplataforma (.NET 8.0)

v0.2.0 — Auditoría remota de sistemas ✅ (mayo de 2026)

Estado: 🎉 Publicado

✅ Comprobaciones remotas de Windows vía WinRM: Audita servidores Windows desde Linux/macOS (--winrm)
✅ SSH mejorado: Autenticación por clave, hosts bastión, elevación sudo (--ssh-key, --bastion, --sudo-password)
✅ Detección de SO: Detección por objetivo (banner SSH + puerto SMB/RDP + TTL)
✅ Modo agresivo: AS-REP roasting, delegación, ACLs débiles, LAPS, AdminCount
✅ Escáner TLS: Certificados caducados/autofirmados, TLS 1.0/1.1, cifrados débiles
✅ Verificación SYSVOL/GPP: Exposición de contraseñas en Preferencias de directiva de grupo
✅ Correlación de cadenas de ataque: 8 vectores de múltiples pasos con IDs MITRE
✅ Informes de diferencias: --diff last / --diff <id> — seguimiento de regresiones de seguridad
✅ Archivo de múltiples credenciales: --creds-file credentials.yaml
✅ Seguimiento de costos de IA: --ai-budget, costos guardados en BD + costs.json
✅ / / : , ,

v0.3.0 — Funciones empresariales (Q3 2026)

Enfoque: Usabilidad, escala, IA interactiva

🔜 CLI estilo Metasploit: Gestión de configuración interactiva (--show-options, --set)
🔜 CLI de base de datos: Sin necesidad de SQL (ast db scans list, ast db findings search)
🔜 Escaneo multired: Procesamiento por lotes desde archivo
🔜 Interfaz de chat con IA: Análisis conversacional de vulnerabilidades con integración de BloodHound
🔜 Integración CI/CD: Plantillas de GitHub Actions, Jenkins y GitLab
🔜 Servidor de API REST: API ASP.NET Core para automatización

v0.4.0 — Inteligencia y automatización (Q4 2026)

Enfoque: Remediación automatizada, detección ML, escaneo distribuido

🔜 Remediación automatizada: Generación de playbooks de PowerShell DSC + Ansible
🔜 Detección basada en ML: Detección de anomalías, reducción de falsos positivos
🔜 Escaneo distribuido: Nodos trabajadores para entornos a gran escala
🔜 Agentes de IA avanzados: Generación de consultas BloodHound, análisis de rutas de ataque

Para descripciones detalladas de las funciones, consulta docs/ROADMAP.md

🤝 Contribuciones

¡Damos la bienvenida a las contribuciones! Ya sea:

🐛 Informes de errores
💡 Solicitudes de funciones
📝 Mejoras de documentación
🔧 Contribuciones de código

Cómo contribuir

Haz un fork del repositorio
Crea una rama de características (git checkout -b feature/amazing-feature)
Realiza tus cambios
Escribe/actualiza las pruebas (cuando corresponda)
Haz commit de tus cambios (git commit -m 'Add amazing feature')
Haz push a la rama (git push origin feature/amazing-feature)
Abre una Pull Request

Configuración del entorno de desarrollo```bash

Clone your fork

git clone https://github.com/YOUR-USERNAME/asterion-network-minotaur.git cd asterion-network-minotaur

Install dependencies

pip install -r scripts/requirements.txt dotnet restore

Build solution

dotnet build

Run with debugging

dotnet run --project src/Asterion -- scan --target 192.168.1.1 -v

### Estilo de código

- **Formato C#**: Sigue las convenciones de codificación de Microsoft C#
- **Formato Python**: Usamos [Black](https://github.com/psf/black) (longitud de línea: 88)
- **Documentación XML**: Requerida para todas las clases/métodos públicos
- **Comentarios de código**: Usa `//` para comentarios en línea, `///` para documentación XML

### Reportar problemas

¿Encontraste un error? ¿Tienes una solicitud de funcionalidad?

**Abre un issue**: https://github.com/rodhnin/asterion-network-minotaur/issues

Por favor, incluye:

- Versión de Asterion (`ast version`)
- Versión de .NET (`dotnet --version`)
- Versión de Python (`python --version`)
- Sistema operativo
- Pasos para reproducir (para errores)
- Comportamiento esperado vs. actual

---

## 📚 Documentación

Documentación completa disponible en el directorio `docs/`:

| Documento                                   | Descripción                              |
| ------------------------------------------- | ----------------------------------------- |
| [AI_INTEGRATION.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/AI_INTEGRATION.md) | Guía completa de configuración de IA (los 3 proveedores) |
| [CONSENT.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/CONSENT.md)               | Detalles técnicos del sistema de tokens de consentimiento |
| [DATABASE_GUIDE.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/DATABASE_GUIDE.md) | Esquema SQLite, consultas, gestión        |
| [ETHICS.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/ETHICS.md)                 | Marco legal y pautas éticas               |
| [NETWORK_CHECKS.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/NETWORK_CHECKS.md) | Catálogo completo de 50+ comprobaciones de seguridad |
| [ROADMAP.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/docs/ROADMAP.md)               | Funciones futuras y planes de desarrollo  |

### Enlaces rápidos

- **Registro de cambios**: [CHANGELOG.md](https://github.com/rodhnin/asterion-network-minotaur/blob/main/CHANGELOG.md)
- **Licencia**: [LICENSE](https://github.com/rodhnin/asterion-network-minotaur/blob/main/LICENSE)
- **Arte ASCII**: [assets/ascii.txt](https://github.com/rodhnin/asterion-network-minotaur/blob/main/assets/ascii.txt)

---

## 🤝 Parte de Argos Suite

Asterion es el cuarto componente de la **Argos Security Suite**:

| Herramienta   | Lenguaje    | Objetivo                | Estado      |
| -------------- | ----------- | ----------------------- | ----------- |
| **Argus**      | Python      | WordPress               | ✅ Estable   |
| **Hephaestus** | Python      | Servidores (Linux/Windows) | ✅ Estable   |
| **Pythia**     | Python      | Inyección SQL           | ✅ Estable   |
| **Asterion**   | C# + Python | Redes/Dominios/AD       | 🎉 Publicado |

**Infraestructura compartida:**

- Base de datos SQLite (`~/.argos/argos.db`)
- Esquema unificado de informes JSON
- Sistema de tokens de consentimiento
- Análisis de IA mediante LangChain

---

## ⚖️ Licencia

Este proyecto está licenciado bajo la **Licencia MIT** - consulta el archivo [LICENSE](https://github.com/rodhnin/asterion-network-minotaur/blob/main/LICENSE) para más detalles.```
MIT License

Copyright (c) 2025-2026 Rodney Dhavid Jimenez Chacin

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

⚠️ Descargo de responsabilidad

IMPORTANTE: Esta herramienta es solo para pruebas de seguridad autorizadas.

Aviso Legal

Al usar Asterion, usted reconoce y acepta que:

✅ Solo escaneará redes/sistemas que le pertenezcan o para los que tenga permiso explícito por escrito para probar
✅ Cumplirá con todas las leyes y regulaciones aplicables
✅ Usted entiende que el acceso no autorizado es ilegal (CFAA, Computer Misuse Act, etc.)
✅ El autor y los colaboradores no asumen ninguna responsabilidad por el mal uso
✅ Este software se proporciona "tal cual", sin garantía de ningún tipo

Divulgación Responsable

Si descubre vulnerabilidades usando Asterion:

📧 Contacte primero al propietario de la red/sistema de forma privada
⏰ Dé un tiempo razonable para corregirlas (normalmente 90 días)
🤝 Coordine el cronograma de divulgación
📝 Documente sus hallazgos de manera profesional

Ante la Duda

No escanee. Si no está seguro de tener permiso, probablemente no lo tenga.

🙏 Agradecimientos

Asterion se apoya en hombros de gigantes:

Microsoft — plataforma .NET y documentación de seguridad
BloodHound — investigación de seguridad de AD y análisis de rutas de ataque
OWASP — estándares de seguridad (Top 10, Testing Guide, ASVS)
SMBLibrary — implementación de SMB en C# puro por Tal Aloni
SSH.NET — implementación del protocolo SSH para .NET
DnsClient.NET — biblioteca de cliente DNS de Michael Conrad
LangChain — framework de IA que impulsa el análisis inteligente
Anthropic y OpenAI — modelos de IA para análisis de vulnerabilidades
Ollama — inferencia de IA local para escaneos centrados en la privacidad

Un agradecimiento especial a todos los investigadores de seguridad que practican y promueven el hacking ético.

👤 Autor

Rodney Dhavid Jimenez Chacin (rodhnin)

🌐 Sitio web y contacto: rodhnin.com
💼 GitHub: @rodhnin
🐦 Twitter: @rodhnin

Para preguntas, comentarios o solicitudes de colaboración, visite rodhnin.com

💬 Comunidad

Debates: GitHub Discussions
Incidencias: GitHub Issues
Lanzamientos: GitHub Releases

Hecho con ❤️ para profesionales de la seguridad y administradores de redes empresariales de todo el mundo

⭐ Dale una estrella a este repositorio si lo encuentras útil! ⭐

Reportar Error • Solicitar Función • Documentación

🐂 Asterion — Navegando por el Laberinto de la Red 🐂

Asterion v0.2.0 — Mayo 2026

Hecho con ❤️ por rodhnin | Parte de Argos Security Suite

Seguridad SMB/CIFS	Recursos compartidos anónimos, firma SMB, SMBv1 (EternalBlue), NTLMv1, recursos compartidos con escritura
Seguridad RDP	Autenticación a nivel de red (NLA), niveles de cifrado, RDP expuesto
LDAP/Active Directory	Bind anónimo, firma LDAP, políticas de contraseñas, pre-autenticación de Kerberos
Seguridad de Kerberos	AS-REP roasting, Kerberoasting, tiempo de vida excesivo de tickets
SNMP	Cadenas de comunidad por defecto, SNMPv1/v2c, acceso de escritura
DNS/NetBIOS	Transferencias de zona (AXFR), envenenamiento LLMNR/NetBIOS, mDNS
Sistemas Windows	Firewall, registro (UAC, LSA), servicios, escalada de privilegios
Sistemas Linux	iptables/nftables, SSH, Samba/NFS, binarios SUID, mala configuración de sudo

JSON	`--output json`	Informes legibles por máquina (predeterminado)
HTML	`--output html`	Atractivos informes con temática de Minotauro
Both	`--output both`	Genera tanto JSON como HTML

`--target, -t`	IP/CIDR/domain	Obligatorio	Objetivo(s): `192.168.1.0/24`, `10.0.0.1`, `corp.local`, lista separada por comas
`--mode, -m`	safe, aggressive	`safe`	Modo de escaneo (aggressive requiere token de consentimiento)
`--output, -o`	json, html, both	`json`	Formato de salida
`--ports, -p`	lista de puertos	Auto-detección	Puertos a escanear (p. ej., `22,80,443` o `8000-9000`)
`--threads`	1-20	5	Número de hilos concurrentes
`--rate`	1-20	5	Límite de tasa de solicitudes (req/s)
`--timeout`	segundos	10	Tiempo de espera de conexión
`--verify-ssl`	flag	true	Verificar certificados SSL/TLS (deshabilitar para certificados autofirmados)
`--verbose, -v`	flag	false	Habilitar registro detallado
`--diff`	last / scan_id	-	Comparar con el escaneo anterior (`--diff last` o `--diff 42`)
`--creds-file`	ruta al archivo YAML	-	Cargar todas las credenciales desde el archivo YAML

`--auth`	`DOMAIN\user:pass`	Credenciales de dominio para verificaciones LDAP/Kerberos/SMB/AD
`--auth-ntlm`	`user:hash`	Autenticación NTLM Pass-the-hash
`--kerberos`	`user:pass@REALM`	Credenciales Kerberos
`--winrm`	`DOMAIN\user:pass`	Verificaciones remotas de Windows vía WinRM (firewall, registro, servicios, AD)
`--ssh`	`user:pass`	Autenticación por contraseña SSH para verificaciones remotas de Linux
`--ssh-key`	`user:/path/key`	Autenticación basada en clave SSH
`--sudo-password`	`pass`	Contraseña de elevación sudo para verificaciones privilegiadas de Linux
`--bastion`	`host:user:key`	Host de salto/bastión para SSH de múltiples saltos

`--use-ai`	flag	false	Habilitar análisis impulsado por IA
`--ai-tone`	technical, non_technical, both	technical	Formato de análisis de IA
`--ai-provider`	openai, anthropic, ollama	openai	Proveedor de IA
`--ai-model`	nombre del modelo	gpt-4o-mini-2024-07-18	Modelo de IA a utilizar
`--ai-budget`	cantidad en USD	-	Abortar IA si el costo estimado supera este valor
`--ai-stream`	flag	false	Transmitir tokens de IA a stdout en tiempo real
`--ai-agent`	flag	false	Modo agente LangChain con herramienta de consulta NVD CVE
`--ai-compare`	`prov/model,prov/model`	-	Comparación entre múltiples modelos

Safe	Non-intrusive network checks	❌ No	5 req/s
Aggressive	Deep AD/system testing	✅ Yes	10 req/s
AI Analysis	Vulnerability analysis	✅ Yes	N/A

Más Populares

asterion-network-minotaur

En acción

🎯 ¿Qué es Asterion?

¿Por qué Asterion?

Qué escanea

✨ Características

🛡️ Escaneo de seguridad de red principal```bash

One command, comprehensive network analysis

🔐 Sistema de Token de Consentimiento

1. Generate token

2. Place token (choose one method)

HTTP: Upload to https://corp.local/.well-known/verify-abc123.txt

DNS: Add TXT record: corp.local = "asterion-verify=verify-abc123"

SSH: Create file /tmp/consent_verify-abc123 with token content

3. Verify ownership

4. Now you can use aggressive mode

🚀 Inicio Rápido

Requisitos Previos

Instalación — Configuración Automatizada (Recomendada)

Linux / macOS```bash

Clone repository

Run setup script

Instalación — Configuración manual

Paso 1: Clonar el repositorio```bash

Paso 5: Crear directorios de configuración

Paso 6: (solo Linux/macOS) Crear comando global```bash

Create wrapper script

Paste this content:

Make executable

Or permanently:

Or with dotnet

Scan localhost (full path)

Scan local subnet (full path)

Formatos de salida

Opciones de tono de IA

Ejemplos básicos

Build and start

Run a scan

View logs

Stop services

Opciones del comando Scan

Flags principales

Flags de credenciales

Flags de IA

Ejemplos de referencia rápida

Escaneo básico```bash

Scan local subnet (default: JSON output, safe mode)

Scan with HTML report

Scan specific IP

Optimización del rendimiento```bash

Slow, stealthy scan (3 threads, 2 req/s)

Fast scan (15 threads, 15 req/s)

Specific ports only

Auditoría de sistemas Linux```bash

Remote Linux SSH scan (password)

SSH with sudo elevation (for privileged checks)

SSH key authentication

Via bastion host

Full Linux audit: SSH + sudo + AI + HTML

Depuración```bash

Verbose output

Verbose + custom timeout

Test connectivity only (timeout 5s)

Verificar Consentimiento (3 Métodos)

1. Create file at: https://corp.local/.well-known/verify-a3f9b2c1d8e4f5a6.txt

2. Verify:

1. Create file: /tmp/consent_verify-a3f9b2c1d8e4f5a6

2. Verify:

Escenarios del Mundo Real

Escenario 1: Evaluación Rápida de la Red```bash

Fast, no-auth scan with HTML report

Escenario 3: Escaneo sigiloso```bash

Slow, careful scan to avoid detection

🤖 Análisis impulsado por IA

Proveedores compatibles

OpenAI GPT-4 Turbo

Ollama (Modelos Locales)

Install Ollama: https://ollama.ai

Future feature