Skip to content

Autonomous OODA-loop pentesting agent. Hermes brain, Kali + Playwright tools over MCP, ATT&CK as the Orient language.

6.0 KB
Raw Blame
"""Servidor HTTP de artefactos de `kali-mcp` — el canal del plano de DATOS.

STDLIB PURA (``http.server``), independiente de ``mcp``/``anyio`` (vive en su propio
módulo, testeable sin el SDK). Sirve el resultado CRUDO staged por ``artifact_store``
al cliente, que lo baja por STREAM. Es el transporte que sustituye al evento SSE de
1 MiB: el blob grande viaja por AQUÍ (HTTP chunked por referencia), NUNCA por el canal
de control (MCP).

Frontera de seguridad:
  - Exige la cabecera ``X-Artifact-Token`` == ``KALI_ARTIFACTS_TOKEN`` (403 sin ella o
    si no coincide; comparación en tiempo constante). Fail-closed: ``make_server`` NO
    arranca sin token.
  - Confina rutas vía ``artifact_store.resolve`` (``..``/separadores -> 400).
  - 404 si el artefacto no existe. El crudo es DATO NO CONFIABLE: se transporta
    verbatim, no se interpreta ni se loguea su contenido.
  - NO se publica al host (sólo red interna docker); lo decide la orquestación.
"""

from __future__ import annotations

import hmac
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import unquote, urlsplit

import artifact_store

# Prefijo de ruta del endpoint de datos. Espejo del que el cliente compone al bajar.
_PREFIX = "/artifacts/"

# Tamaño de chunk al servir (64 KiB): stream, no "todo de golpe".
_CHUNK_SIZE = 65536

# Cabecera del token compartido entre servidor y cliente.
_TOKEN_HEADER = "X-Artifact-Token"


class _ArtifactHandler(BaseHTTPRequestHandler):
    """Sirve ``GET /artifacts/<execution_id>/<name>`` por stream, tras validar token."""

    server_version = "kali-artifacts/1.0"

    # Silencia el log por defecto: la ruta puede contener dato no confiable y no se
    # loguea verbatim. Si hiciera falta trazar, se haría por un canal propio.
    def log_message(self, *args, **kwargs) -> None:  # noqa: D401, ANN002, ANN003
        return

    def _deny(self, code: int, reason: str) -> None:
        """Responde un error corto (texto plano) sin filtrar el dato pedido."""
        body = reason.encode("utf-8")
        self.send_response(code)
        self.send_header("Content-Type", "text/plain; charset=utf-8")
        self.send_header("Content-Length", str(len(body)))
        self.end_headers()
        self.wfile.write(body)

    def _token_ok(self) -> bool:
        expected = getattr(self.server, "artifact_token", "") or ""
        provided = self.headers.get(_TOKEN_HEADER, "") or ""
        if not provided:
            return False
        # Comparación en tiempo constante (evita oráculo por temporización).
        return hmac.compare_digest(provided, expected)

    def do_GET(self) -> None:  # noqa: N802 - firma de BaseHTTPRequestHandler
        path = urlsplit(self.path).path

        # 1) Token primero: sin credencial no se revela nada (403).
        if not self._token_ok():
            self._deny(403, "forbidden: missing or invalid artifact token")
            return

        # 2) Sólo el endpoint de artefactos.
        if not path.startswith(_PREFIX):
            self._deny(404, "not found")
            return

        # 3) Parsear <execution_id>/<name>; un multi-segmento se reconstruye como name
        #    con '/' y lo rechaza el confinamiento de resolve (-> 400).
        rest = path[len(_PREFIX):]
        parts = rest.split("/")
        if len(parts) < 2 or not parts[0]:
            self._deny(400, "bad request: expected /artifacts/<execution_id>/<name>")
            return
        execution_id = unquote(parts[0])
        name = unquote("/".join(parts[1:]))

        # 4) Confinamiento (traversal/separadores/absoluta) -> 400.
        try:
            target = artifact_store.resolve(execution_id, name)
        except ValueError:
            self._deny(400, "bad request: invalid artifact path")
            return

        # 5) Existencia -> 404.
        if not target.is_file():
            self._deny(404, "not found")
            return

        # 6) Stream del fichero con Content-Length + sha256 (de la meta si está).
        entry = artifact_store.stat(execution_id, name)
        size = entry["size"] if entry and "size" in entry else target.stat().st_size
        self.send_response(200)
        self.send_header("Content-Type", "application/octet-stream")
        self.send_header("Content-Length", str(size))
        if entry and entry.get("sha256"):
            self.send_header("X-Artifact-Sha256", str(entry["sha256"]))
        self.end_headers()
        with target.open("rb") as handle:
            while True:
                chunk = handle.read(_CHUNK_SIZE)
                if not chunk:
                    break
                self.wfile.write(chunk)


def make_server(host: str, port: int, token: str) -> ThreadingHTTPServer:
    """Crea (sin arrancar) el servidor HTTP de artefactos ligado a ``token``.

    Fail-closed: levanta ``ValueError`` si ``token`` es vacío — un endpoint de datos sin
    token sería un canal abierto a dato potencialmente sensible. ``port=0``
    elige un puerto efímero (útil en tests; el real se lee de ``server.server_address``).
    """
    if not token:
        raise ValueError(
            "KALI_ARTIFACTS_TOKEN vacío: el servidor de artefactos no arranca sin "
            "token (fail-closed)."
        )
    server = ThreadingHTTPServer((host, port), _ArtifactHandler)
    # El handler lee el token del servidor (no de una global): un único punto de verdad.
    server.artifact_token = token  # type: ignore[attr-defined]
    return server


def serve_in_thread(
    host: str, port: int, token: str
) -> tuple[ThreadingHTTPServer, threading.Thread]:
    """Arranca el servidor en un hilo DEMONIO y devuelve ``(server, thread)``.

    No bloquea: el proceso principal sigue a ``mcp.run(...)`` (plano de control). El
    caller puede ``server.shutdown()`` para pararlo (tests). El hilo es daemon para no
    impedir la salida del proceso.
    """
    server = make_server(host, port, token)
    thread = threading.Thread(
        target=server.serve_forever, name="kali-artifacts-http", daemon=True
    )
    thread.start()
    return server, thread