`install.sh` configura tu proveedor de LLM de forma interactiva (no es necesario editar `docker-compose.yml`) y construye el stack completo:```bash
./install.sh           # skip form if .opencode.env already configured
./install.sh --init    # force reconfiguration (cloud or local model)
./install.sh --help    # show usage

**Requisitos previos:** Docker y Docker Compose, y una clave de API de LLM (o un modelo local). La configuración de GPU, las variables de entorno y la referencia completa de flags están en la [Documentación completa](https://github.com/ascit31/dark-moon/blob/master/docs/full.md).

---

## Cuadrícula de características

| | |
|---|---|
| 🧠 **50 agentes especialistas** | Un sistema agéntico razona, planifica y despacha agentes especialistas por cada superficie que descubre. |
| 🌐 **Todas las superficies** | Web, APIs, Active Directory, Kubernetes, cloud (AWS, Azure, GCP), CI/CD, bases de datos, firmware IoT y endpoints de IA/LLM, encadenados de extremo a extremo. |
| 🔒 **Privacy Gateway** | La tokenización local reversible convierte IPs, hosts, URLs y credenciales reales en marcadores deterministas, rehidratados solo localmente en el momento en que se ejecuta una herramienta. |
| 🏠 **Modelo local** | Ejecuta toda la evaluación con un LLM local (Ollama, llama.cpp) para que los valores de tu infraestructura permanezcan en tu propio perímetro. |
| 🧾 **Evidencia, no puntuaciones** | Cada hallazgo se entrega con el comando exacto y la salida sin procesar; el retest de Pro vuelve a ejecutar el exploit para confirmar una corrección. |
| 🛡️ **Seguridad por diseño** | La IA nunca ejecuta un comando directamente, cada acción fluye a través de una interfaz MCP controlada y registrada. |
| 🤖 **También hace pentesting a tu IA** | Un agente LLM dedicado sondea endpoints de inferencia de IA/LLM para el OWASP LLM Top 10 con sondas respaldadas por garak. |
| ♾️ **Nativo de CI/CD** | Lanza un pentest en el pipeline y recibe los hallazgos como artefactos. |
| 🔌 **MCP** | Orquesta más de 140 herramientas ofensivas a través de MCP. |
| 🔧 **Corrígelo (Pro)** | El nivel Pro de pago convierte los hallazgos en pull requests revisados por humanos, con retest contra el exploit original. |

Diseñado para **equipos de seguridad**, **ingenieros DevSecOps**, **red teamers** y profesionales del **ethical hacking**.

---

## 🧩 DarkMoon en todas partes

<p align="center">
  <img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/integrations.svg" alt="DarkMoon integrations: GitHub, GitLab, Jenkins, VS Code, JetBrains, n8n, Grafana, Splunk — Community + Pro" width="100%" />
</p>

Ejecuta DarkMoon donde ya construyes — en CI/CD, tu IDE, automatización y SecOps. Las integraciones marcadas como **OSS + Pro** funcionan con la edición de código abierto (CLI local + JSON); las exclusivas de Pro consumen la API REST de [DarkMoon Pro](#-darkmoon-pro--paid-edition-web-dashboard-and-automated-remediation) (panel en vivo, remediación→PR).

| Plataforma | Qué hace | Consíguelo | Edición |
|---|---|---|---|
| **GitHub Actions** | Falla el pipeline según los hallazgos por severidad | [GitHub Marketplace](https://github.com/marketplace/actions/darkmoon-pentest) | OSS + Pro |
| **GitLab CI/CD** | Hallazgos como informes de Code Quality + SAST | [CI/CD Catalog](https://gitlab.com/explore/catalog/Dark-Moon-X/darkmoon-scan) | OSS + Pro |
| **Jenkins** | Hallazgos como issues de Warnings-NG en la build | [Plugin `.hpi` (Releases)](https://github.com/ASCIT31/darkmoon-jenkins/releases) | OSS + Pro |
| **VS Code** | Explora y lanza evaluaciones desde el editor | [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=Darkmoon.darkmoon-vscode) | OSS + Pro |
| **JetBrains** | Hallazgos en una ventana de herramientas del IDE | [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/34497-darkmoon) | OSS + Pro |
| **n8n** | Automatiza campañas, retests y alertas | [npm `n8n-nodes-darkmoon`](https://www.npmjs.com/package/n8n-nodes-darkmoon) | Pro |
| **Grafana** | Paneles de postura de seguridad | [Self-host (Releases)](https://github.com/ASCIT31/darkmoon-grafana/releases) | Pro |
| **Splunk** | Ingesta en el SOC (HEC) + acción de alerta "Send to Darkmoon" | [App (Releases)](https://github.com/ASCIT31/darkmoon-splunk/releases) — Splunkbase pendiente | OSS + Pro |
| **SDK / CLI** | Construye tu propia integración sobre el contrato compartido | [npm `@darkmoon_ai/client`](https://www.npmjs.com/package/@darkmoon_ai/client) | OSS + Pro |

Cada integración emite **solo metadatos seguros** (severidad, estado, MITRE, ids) — nunca evidencia, secretos ni tokens. Guías completas en [docs.dark-moon.org](https://docs.dark-moon.org); código fuente en [ASCIT31](https://github.com/ASCIT31).

---

## 🔒 Darkmoon Pro — edición de pago: panel web y remediación automatizada

> 🔒 **Estas son características de Darkmoon Pro (de pago).** La edición de código abierto es la CLI mostrada arriba; el panel web y la remediación automatizada a pull requests no están en la build de código abierto.

Las capturas de pantalla a continuación son el panel web de **Darkmoon Pro de pago**. **No** forman parte del repositorio de código abierto que clonas. La edición de código abierto es la herramienta de línea de comandos mostrada en la sección anterior.

<table>
<tr>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/dashboard.png" alt="Darkmoon Pro web dashboard showing projects, targets, campaigns and vulnerabilities by severity" />
<p align="center"><b>Pro: panel web en vivo.</b> Proyectos, objetivos y campañas de un vistazo, con cada hallazgo clasificado por severidad.</p>
</td>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/vulnerability-1.png" alt="Darkmoon Pro finding detail with CVSS, MITRE ATT&CK and ISO 27001 mapping and EXPLOITED status" />
<p align="center"><b>Pro: hallazgos con mapeo CVSS y ATT&CK.</b> Cada hallazgo lleva mapeo de CVSS, MITRE ATT&CK e ISO 27001 con un estado <code>EXPLOITED</code> respaldado por un exploit real.</p>
</td>
</tr>
<tr>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/markdown-report-1.png" alt="Darkmoon Pro structured web report with management summary, exportable to Markdown and PDF" />
<p align="center"><b>Pro: informes web exportables.</b> Un resumen ejecutivo en lenguaje sencillo más el detalle técnico completo, exportable a Markdown y PDF.</p>
</td>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/infra-map-2.png" alt="Darkmoon Pro interactive infrastructure map of the attack surface with per-node vulnerabilities" />
<p align="center"><b>Pro: mapa interactivo de la superficie de ataque.</b> Un grafo de nodos, conexiones y vulnerabilidades por nodo en todo el objetivo.</p>
</td>
</tr>
<tr>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/scheduler.png" alt="Darkmoon Pro campaign scheduler for recurring automated pentest campaigns with focus, severity and recurrence" />
<p align="center"><b>Pro: ejecuciones recurrentes programadas.</b> Campañas automatizadas recurrentes con FOCUS, severidad y recurrencia integrados en el panel web.</p>
</td>
<td width="50%" valign="top">
<img src="https://raw.githubusercontent.com/ascit31/dark-moon/master/docs/pics/campaign.png" alt="Darkmoon Pro campaign view listing the 57 vulnerabilities with severity and status" />
<p align="center"><b>Pro: vista de campaña.</b> Cada vulnerabilidad de una campaña con su severidad y estado de confirmación.</p>
</td>
</tr>
</table>

### 🔒 Pro: del hallazgo a la corrección (remediación automatizada, de pago)

> 🔒 **Característica Pro de pago.** El motor de código abierto encuentra y demuestra vulnerabilidades. La remediación automatizada a pull requests solo está disponible en Darkmoon Pro.

En el nivel Pro de pago, cada hallazgo fluye _hallazgo → corrección validada en sandbox → **pull request revisado por humanos, con retest contra el exploit original**_, y nunca se fusiona automáticamente. En nuestra ejecución de demostración con OWASP Juice Shop, el agente de remediación de Pro **corrigió hallazgos de extremo a extremo con un retest limpio del exploit en vivo** (una corrección solo cuenta cuando el exploit original se vuelve a ejecutar y se confirma cerrado). Consulta el [benchmark de remediación](https://dark-moon.org/remediation-benchmark/), la [documentación del agente de remediación](https://github.com/ascit31/dark-moon/blob/master/docs/remediation-agent.md) y los [57 PRs abiertos en ASCIT31/juice-shop](https://github.com/ASCIT31/juice-shop/pulls).

<div align="center">

<a href="https://youtu.be/1bFRVuMkZzY?si=peKxwuxzbXBnb2zO">
  <img src="https://assets.kitploit.com/production/public/readmes/42241/95a4689eb8c0d2931c09f243615e0a57071b7d7698d88e2d0c6477a477b2d6c5.png" alt="Watch the demo of the Darkmoon Pro web dashboard running a full autonomous penetration test" width="70%" />
</a>

**▶️ Mira la demo (muestra el panel web de Darkmoon Pro)**

</div>

---

## ¿Qué es DarkMoon?

DarkMoon es una plataforma **open-source de pentesting con IA**. Apúntala a un objetivo que estés autorizado a probar, y ejecuta toda la evaluación por sí sola: razona, planifica y despacha **50 agentes especialistas** que ejecutan operaciones ofensivas reales a través de una capa MCP controlada, y luego reporta cada vulnerabilidad con el comando exacto, la salida sin procesar y la prueba que la respalda.

No reemplaza al pentester. Elimina la parte repetitiva de una evaluación con evidencia, para que tus expertos dediquen su tiempo al criterio, no al trabajo mecánico.

---

## 📊 Benchmark: 57 vulnerabilidades reales en OWASP Juice Shop

Ejecución **black-box** real y reproducible contra OWASP Juice Shop con un **modelo frontera en la nube (Anthropic Claude)**. DarkMoon también se ejecuta **totalmente local** (Ollama / llama.cpp) detrás del Privacy Gateway — así nada sale de tu infraestructura; la cobertura con modelo local depende del modelo que ejecutes.

| Métrica | Resultado |
|---|---|
| Vulnerabilidades encontradas | **57** (8 críticas / 24 altas / 21 medias / 4 bajas) |
| Tiempo de reloj | **28,5 min** |
| Prueba de explotación | comando + salida sin procesar por hallazgo |
| LLM | Anthropic Claude (frontera en la nube); modelos locales soportados |

Reprodúcelo y compara herramientas tú mismo: **[ASCIT31/Darkmoon-Benchmarks](https://github.com/ASCIT31/Darkmoon-Benchmarks)**.

## 🆚 Cómo se compara DarkMoon

| | **DarkMoon** | strix | shannon | PentAGI |
|---|:--:|:--:|:--:|:--:|
| Se ejecuta con **LLM local** (los datos nunca salen) | ✅ | ❌ nube | ❌ nube | parcial |
| Privacy Gateway (tokenización local) | ✅ | ❌ | ❌ | ❌ |
| Active Directory + Kubernetes | ✅ | ❌ | ❌ | parcial |
| Prueba de explotación | ✅ | ✅ | ✅ | ✅ |
| Código abierto | ✅ GPL-3.0 | ✅ | ✅ | ✅ |

*Recopilado de repositorios/documentación públicos (2026-08); correcciones bienvenidas vía PR.*

---

## Cómo funciona

DarkMoon opera como un orquestador estratégico de **agente de seguridad con IA** alineado con las metodologías ISO 27001, NIST SP 800-115 y MITRE ATT&CK.

Cuando proporcionas un objetivo, la plataforma automáticamente:

1. 🔍 **Descubre** el entorno objetivo (puertos, servicios, protocolos)
2. 🧠 **Huella** la pila tecnológica (frameworks, CMS, APIs)
3. 🎯 **Modela** la superficie de ataque
4. 🚀 **Despliega** subagentes especializados según las tecnologías detectadas
5. 🔬 **Ejecuta** un bucle de **escaneo inteligente de vulnerabilidades** con adaptación reactiva
6. ✅ **Valida** los hallazgos con evidencia (peticiones, payloads, respuestas)
7. 📝 **Genera** un informe de auditoría estructurado

### Orquestación de subagentes

DarkMoon selecciona y despacha dinámicamente agentes especializados según las tecnologías descubiertas:

| Tecnología detectada | Agente activado |
|---|---|
| WordPress, Drupal, Joomla, Magento, PrestaShop, Moodle | Agente específico de CMS |
| PHP, Node.js, Flask, ASP.NET, Spring Boot, Ruby on Rails, Go | Agente específico de stack |
| GraphQL | Agente GraphQL |
| Endpoint de inferencia LLM / IA (compatible con OpenAI, Ollama, vLLM, TGI) | Agente LLM |
| Active Directory | Agente AD |
| Kubernetes | Agente Kubernetes |
| AWS, Azure, GCP | Agente de proveedor cloud |
| Entra ID (identidad de Microsoft) | Agente de identidad |
| GitHub, GitLab, Jenkins | Agente de SCM y CI/CD |
| Terraform, Ansible | Agente de Infrastructure-as-Code |
| Docker, registros de contenedores | Agente de contenedores |
| HashiCorp Vault | Agente de secretos |
| PostgreSQL, MySQL, MSSQL, Oracle | Agente de bases de datos |
| Redis, RabbitMQ, Kafka, MQTT | Agente de mensajería y caché |
| Imágenes de firmware / IoT | Agente de firmware |
| Se requiere navegador headless | Agente de navegador headless |

Múltiples agentes pueden ejecutarse **en paralelo** en arquitecturas híbridas.

Los planos que requieren credenciales para ser significativos (cuentas cloud, CI/CD, almacenes de secretos, bases de datos, Active Directory, Kubernetes) **nunca se despachan por inferencia**. Se activan solo cuando se encuentra un artefacto concreto (una clave, un token, un endpoint de metadatos accesible) o cuando los autorizas explícitamente, y de lo contrario se señalan en el informe.

> **Nota:** Para la lista completa de agentes, su estructura, ciclo de vida y cómo crear agentes personalizados, consulta [Documentación completa, Agentes de IA](https://github.com/ascit31/dark-moon/blob/master/docs/full.md#v-ai-agents).

### Descripción general de la arquitectura```
User ──> DarkmoonCLI ──> OpenCode (AI Brain) ──> MCP (Security Gatekeeper) ──> Docker Toolbox (Real Tools)

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones TCP establecidas
connections = kit.get_network_connections(
    protocol="tcp",
    state="ESTABLISHED"
)

for conn in connections:
    print(f"{conn['process_name']} ({conn['pid']}): "
          f"{conn['local_address']}:{conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener todos los puertos UDP en escucha
udp_listeners = kit.get_network_connections(
    protocol="udp",
    state="LISTEN"
)

# Obtener conexiones de un proceso específico
nginx_conns = kit.get_network_connections(
    process_name="nginx",
    resolve_dns=True
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las interfaces de red
interfaces = kit.get_network_interfaces()

for iface in interfaces:
    print(f"Interfaz: {iface['name']}")
    print(f"  Estado: {iface['status']}")
    print(f"  MAC: {iface['mac_address']}")
    print(f"  MTU: {iface['mtu']}")
    
    for addr in iface['addresses']:
        print(f"  Dirección: {addr['address']}/{addr['prefix_length']}")
    
    if iface['stats']:
        print(f"  Bytes enviados: {iface['stats']['bytes_sent']}")
        print(f"  Bytes recibidos: {iface['stats']['bytes_recv']}")

# Obtener una interfaz específica
eth0 = kit.get_network_interfaces(interface_name="eth0")

from kitploit import Kitploit

kit = Kitploit()

# Obtener estadísticas de red agregadas
stats = kit.get_network_stats()

print(f"Total enviado: {stats['bytes_sent'] / 1024 / 1024:.2f} MB")
print(f"Total recibido: {stats['bytes_recv'] / 1024 / 1024:.2f} MB")
print(f"Paquetes enviados: {stats['packets_sent']}")
print(f"Paquetes recibidos: {stats['packets_recv']}")

if stats['rates']:
    print(f"Tasa de subida: {stats['rates']['upload'] / 1024:.2f} KB/s")
    print(f"Tasa de bajada: {stats['rates']['download'] / 1024:.2f} KB/s")

# Obtener estadísticas por interfaz
per_iface = kit.get_network_stats(per_interface=True)
for iface_name, iface_stats in per_iface.items():
    print(f"{iface_name}: {iface_stats['bytes_sent']} bytes enviados")

from kitploit import Kitploit

kit = Kitploit()

# Obtener contadores de E/S agregados
io_counters = kit.get_network_io_counters()

print(f"Bytes enviados: {io_counters['bytes_sent']}")
print(f"Bytes recibidos: {io_counters['bytes_recv']}")
print(f"Paquetes enviados: {io_counters['packets_sent']}")
print(f"Paquetes recibidos: {io_counters['packets_recv']}")
print(f"Errores de entrada: {io_counters['errin']}")
print(f"Errores de salida: {io_counters['errout']}")
print(f"Paquetes descartados de entrada: {io_counters['dropin']}")
print(f"Paquetes descartados de salida: {io_counters['dropout']}")

# Obtener contadores por NIC
per_nic = kit.get_network_io_counters(per_nic=True)
for nic in per_nic:
    print(f"{nic['name']}: {nic['bytes_sent']} bytes enviados")

from kitploit import Kitploit

kit = Kitploit()

# Obtener resumen de conexiones agrupadas por estado
summary = kit.get_network_connections_summary(group_by="state")

print(f"Total de conexiones: {summary['total']}")
for state, count in summary['groups'].items():
    print(f"  {state}: {count}")

# Agrupar por proceso
by_process = kit.get_network_connections_summary(group_by="process")
for process, count in by_process['groups'].items():
    print(f"  {process}: {count} conexiones")

# Agrupar por protocolo
by_protocol = kit.get_network_connections_summary(group_by="protocol")
for proto, count in by_protocol['groups'].items():
    print(f"  {proto}: {count}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones detalladas con información de socket
detailed = kit.get_network_connections_detailed(
    include_socket_info=True,
    include_routing=True
)

for conn in detailed:
    print(f"Conexión: {conn['local_address']}:{conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")
    
    if conn.get('socket_info'):
        print(f"  Socket FD: {conn['socket_info']['fd']}")
        print(f"  Tipo de socket: {conn['socket_info']['type']}")
    
    if conn.get('routing'):
        print(f"  Interfaz: {conn['routing']['interface']}")
        print(f"  Gateway: {conn['routing']['gateway']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones agrupadas por proceso
by_process = kit.get_network_connections_by_process()

for process_name, connections in by_process.items():
    print(f"\n{process_name}: {len(connections)} conexiones")
    for conn in connections:
        print(f"  {conn['local_port']} -> {conn['remote_address']}:{conn['remote_port']} "
              f"({conn['state']})")

# Obtener conexiones de un proceso específico incluyendo hijos
nginx_conns = kit.get_network_connections_by_process(
    process_name="nginx",
    include_children=True
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones en el puerto 443
port_443 = kit.get_network_connections_by_port(port=443)

for conn in port_443:
    print(f"{conn['process_name']}: {conn['local_address']}:{conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones donde el puerto 8080 es el puerto local
local_8080 = kit.get_network_connections_by_port(
    port=8080,
    direction="local"
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones a una dirección remota específica
remote_conns = kit.get_network_connections_by_address(
    address="8.8.8.8",
    direction="remote"
)

for conn in remote_conns:
    print(f"{conn['process_name']}: {conn['local_port']} -> {conn['remote_port']}")

# Obtener conexiones desde una dirección local específica
local_conns = kit.get_network_connections_by_address(
    address="192.168.1.100",
    direction="local"
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones establecidas
established = kit.get_network_connections_by_state(state="ESTABLISHED")

print(f"Conexiones establecidas: {len(established)}")
for conn in established:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener todos los sockets en escucha
listening = kit.get_network_connections_by_state(state="LISTEN")
for conn in listening:
    print(f"Escuchando en: {conn['local_address']}:{conn['local_port']} "
          f"({conn['process_name']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones IPv6
ipv6_conns = kit.get_network_connections_by_family(family="ipv6")

print(f"Conexiones IPv6: {len(ipv6_conns)}")
for conn in ipv6_conns:
    print(f"  {conn['local_address']}:{conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener todas las conexiones de socket de dominio Unix
unix_conns = kit.get_network_connections_by_family(family="unix")
for conn in unix_conns:
    print(f"Socket Unix: {conn['local_address']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones de socket de tipo stream (TCP)
stream_conns = kit.get_network_connections_by_type(socket_type="stream")

print(f"Conexiones de tipo stream: {len(stream_conns)}")

# Obtener todas las conexiones de socket de tipo datagram (UDP)
dgram_conns = kit.get_network_connections_by_type(socket_type="dgram")
print(f"Conexiones de tipo datagram: {len(dgram_conns)}")

# Obtener todos los sockets raw
raw_conns = kit.get_network_connections_by_type(socket_type="raw")
for conn in raw_conns:
    print(f"Socket raw: {conn['local_address']}:{conn['local_port']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones en la interfaz eth0
eth0_conns = kit.get_network_connections_by_interface(interface_name="eth0")

print(f"Conexiones en eth0: {len(eth0_conns)}")
for conn in eth0_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones en la interfaz loopback
lo_conns = kit.get_network_connections_by_interface(interface_name="lo")
for conn in lo_conns:
    print(f"Loopback: {conn['local_port']} ({conn['state']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones propiedad del usuario www-data
www_conns = kit.get_network_connections_by_user(username="www-data")

print(f"Conexiones de www-data: {len(www_conns)}")
for conn in www_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones por UID
uid_conns = kit.get_network_connections_by_user(uid=1000)
for conn in uid_conns:
    print(f"UID 1000: {conn['process_name']} ({conn['state']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones de un contenedor por nombre
container_conns = kit.get_network_connections_by_container(
    container_name="nginx-proxy"
)

print(f"Conexiones del contenedor: {len(container_conns)}")
for conn in container_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones de un contenedor por ID
container_conns = kit.get_network_connections_by_container(
    container_id="abc123def456"
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones dentro de un espacio de nombres de red
ns_conns = kit.get_network_connections_by_namespace(
    namespace="mynamespace"
)

print(f"Conexiones en el espacio de nombres: {len(ns_conns)}")
for conn in ns_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones de un espacio de nombres por ruta
ns_conns = kit.get_network_connections_by_namespace(
    namespace="/var/run/netns/mynamespace"
)

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones dentro de un cgroup
cgroup_conns = kit.get_network_connections_by_cgroup(
    cgroup_path="/sys/fs/cgroup/system.slice/nginx.service"
)

print(f"Conexiones en el cgroup: {len(cgroup_conns)}")
for conn in cgroup_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexiones del servicio nginx
service_conns = kit.get_network_connections_by_service(
    service_name="nginx.service"
)

print(f"Conexiones del servicio nginx: {len(service_conns)}")
for conn in service_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones del servicio sshd
sshd_conns = kit.get_network_connections_by_service(
    service_name="sshd.service"
)
for conn in sshd_conns:
    print(f"SSH: {conn['local_port']} -> {conn['remote_address']}:{conn['remote_port']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener información del socket por descriptor de archivo
socket_info = kit.get_network_connections_by_socket(fd=3, pid=1234)

print(f"Socket FD: {socket_info['fd']}")
print(f"Tipo: {socket_info['type']}")
print(f"Estado: {socket_info['state']}")
print(f"Dirección local: {socket_info['local_address']}:{socket_info['local_port']}")
print(f"Dirección remota: {socket_info['remote_address']}:{socket_info['remote_port']}")

from kitploit import Kitploit

kit = Kitploit()

# Obtener conexión por número de inodo
conn = kit.get_network_connections_by_inode(inode=12345678)

print(f"Inodo: {conn['inode']}")
print(f"Protocolo: {conn['protocol']}")
print(f"Estado: {conn['state']}")
print(f"Local: {conn['local_address']}:{conn['local_port']}")
print(f"Remoto: {conn['remote_address']}:{conn['remote_port']}")
print(f"Proceso: {conn['process_name']} ({conn['pid']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones propiedad del UID 1000
uid_conns = kit.get_network_connections_by_uid(uid=1000)

print(f"Conexiones del UID 1000: {len(uid_conns)}")
for conn in uid_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones del UID 0 (root)
root_conns = kit.get_network_connections_by_uid(uid=0)
for conn in root_conns:
    print(f"Root: {conn['process_name']} ({conn['state']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones propiedad del GID 1000
gid_conns = kit.get_network_connections_by_gid(gid=1000)

print(f"Conexiones del GID 1000: {len(gid_conns)}")
for conn in gid_conns:
    print(f"  {conn['process_name']}: {conn['local_port']} -> "
          f"{conn['remote_address']}:{conn['remote_port']}")

# Obtener conexiones del GID 0 (root)
root_conns = kit.get_network_connections_by_gid(gid=0)
for conn in root_conns:
    print(f"Root: {conn['process_name']} ({conn['state']})")

from kitploit import Kitploit

kit = Kitploit()

# Obtener todas las conexiones propiedad del PID 1234
pid_conns = kit.get_network_connections_by_pid(pid=1234)

print(f"Conexiones del PID 1234: {len(pid_conns)}")
for conn in pid_conns:
    print(f"  {conn['local_port']} -> {conn['remote_address']}:{conn['```mermaid
sequenceDiagram
  participant U as User
  participant O as OpenCode
  participant A as AI Agent
  participant M as MCP Darkmoon
  participant T as Docker Toolbox

  U->>O: User prompt
  O->>A: Delegate task
  A->>M: MCP function call
  M->>T: Execute real tool
  T-->>M: Results
  M-->>A: Structured output
  A-->>O: Next decision
  O-->>U: Summary / result

**Modo bug bounty (los flags se activan automáticamente):**```bash
./darkmoon.sh "TARGET: http://172.19.0.3:3000 PROGRAM=\"Juice Shop\" FOCUS=sqli,xss,idor NOISE=moderate FORMAT=h1"

> **Nota:** Para más ejemplos de prompts, incluidos DVGA, Juice Shop y escenarios de navegador headless, consulta [Documentación completa, Ejemplos de prompts](https://github.com/ascit31/dark-moon/blob/master/docs/full.md#iii-uses).

---

## Contribuir

DarkMoon es de código abierto y acepta contribuciones. Ya sea que quieras añadir nuevos agentes, integrar herramientas, crear flujos de trabajo o mejorar la documentación, consulta [CONTRIBUTING.md](https://github.com/ascit31/dark-moon/blob/master/CONTRIBUTING.md) para obtener las directrices.

---

## Licencia

Este proyecto está licenciado bajo la **GNU General Public License v3.0**. Consulta [LICENSE](https://github.com/ascit31/dark-moon/blob/master/LICENSE) para más detalles.

---

<div align="center">

**Creado por ASC-IT con 💚 para la comunidad global de seguridad**

🔒 Código abierto · 🤖 Impulsado por IA · 🇫🇷 Hecho en Francia

[⭐ Danos una estrella en GitHub](https://github.com/ASCIT31/Dark-Moon) · [📖 Documentación completa](https://github.com/ascit31/dark-moon/blob/master/docs/full.md) · [▶️ Ver la demo (panel Pro)](https://youtu.be/1bFRVuMkZzY?si=peKxwuxzbXBnb2zO)

</div>