second commit

app/rdp_proxy/guacd_client.py

@@ -0,0 +1,166 @@
+"""
+Guacamole-Protokoll-Tunnel zu guacd (siehe Konzept 3, 4.3).
+
+guacd selbst spricht RDP zum Windows-Ziel; der Jumphost tauscht mit guacd nur
+das textbasierte Guacamole-Protokoll aus (laengenpraefigierte Elemente,
+Instruktionen durch ';' abgeschlossen). Zugangsdaten werden ausschliesslich
+serverseitig in die "connect"-Instruktion eingefuegt -- der Browser sieht sie
+nie (analog zum SSH-Keyhandling in app/ssh_proxy/proxy.py).
+
+Hinweis: Die exakten von guacd erwarteten RDP-Parameter (Namen/Reihenfolge)
+haengen von der eingesetzten guacd/FreeRDP-Version ab. Diese Implementierung
+fragt sie dynamisch per "args"-Instruktion ab (kein Hardcoding einer festen
+Parameterliste) und ist daher robust gegen kleinere Versionsunterschiede --
+sollte vor Produktivbetrieb dennoch gegen die Ziel-guacd-Version getestet werden.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+
+logger = logging.getLogger("jumphost.rdp_proxy.guacd")
+
+
+class GuacamoleProtocolError(Exception):
+    pass
+
+
+def encode_instruction(*elements: str) -> str:
+    parts = []
+    for element in elements:
+        encoded = element.encode("utf-8")
+        parts.append(f"{len(encoded)}.{element}")
+    return ",".join(parts) + ";"
+
+
+async def _read_until(reader: asyncio.StreamReader, delimiter: bytes) -> bytes:
+    buf = bytearray()
+    while True:
+        b = await reader.readexactly(1)
+        if b == delimiter:
+            return bytes(buf)
+        buf += b
+
+
+async def read_instruction(reader: asyncio.StreamReader) -> list[str]:
+    elements: list[str] = []
+    while True:
+        length_bytes = await _read_until(reader, b".")
+        try:
+            length = int(length_bytes)
+        except ValueError as exc:
+            raise GuacamoleProtocolError(f"Ungueltige Laengenangabe: {length_bytes!r}") from exc
+        content = (await reader.readexactly(length)).decode("utf-8")
+        elements.append(content)
+        sep = await reader.readexactly(1)
+        if sep == b";":
+            return elements
+        if sep != b",":
+            raise GuacamoleProtocolError(f"Unerwartetes Trennzeichen: {sep!r}")
+
+
+def parse_instruction_text(text: str) -> list[str]:
+    """Parst genau EINE Instruktion aus einem bereits vollstaendig vorliegenden
+    String (z.B. eine einzelne WebSocket-Textnachricht vom Browser)."""
+    elements: list[str] = []
+    i = 0
+    n = len(text)
+    while i < n:
+        dot = text.index(".", i)
+        length = int(text[i:dot])
+        start = dot + 1
+        end = start + length
+        elements.append(text[start:end])
+        sep = text[end] if end < n else ""
+        i = end + 1
+        if sep == ";":
+            break
+        if sep != ",":
+            raise GuacamoleProtocolError(f"Unerwartetes Trennzeichen in {text!r} an Position {end}")
+    return elements
+
+
+class GuacdTunnel:
+    def __init__(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, connection_id: str) -> None:
+        self.reader = reader
+        self.writer = writer
+        self.connection_id = connection_id
+
+    async def close(self) -> None:
+        try:
+            self.writer.close()
+            await self.writer.wait_closed()
+        except Exception:
+            # Aufraeumpfad: ein bereits getrenntes/fehlerhaftes Socket beim
+            # Schliessen darf den Session-Teardown (Audit-Log-Eintrag,
+            # DB-Update in ws_tunnel.py) nicht verhindern. Bewusst breit
+            # gefangen, aber protokolliert statt stillschweigend verschluckt.
+            logger.debug("Fehler beim Schliessen des guacd-Tunnels (ignoriert)", exc_info=True)
+
+
+async def open_tunnel(
+    *,
+    guacd_host: str,
+    guacd_port: int,
+    protocol: str,
+    params: dict[str, str],
+    screen_width: int = 1024,
+    screen_height: int = 768,
+    dpi: int = 96,
+) -> GuacdTunnel:
+    reader, writer = await asyncio.open_connection(guacd_host, guacd_port)
+
+    writer.write(encode_instruction("select", protocol).encode("utf-8"))
+    await writer.drain()
+
+    args_instr = await read_instruction(reader)
+    if args_instr[0] != "args":
+        raise GuacamoleProtocolError(f"Erwartete 'args', erhalten: {args_instr[0]}")
+    arg_names = args_instr[1:]
+
+    handshake = (
+        encode_instruction("size", str(screen_width), str(screen_height), str(dpi))
+        + encode_instruction("audio")
+        + encode_instruction("video")
+        + encode_instruction("image", "image/png", "image/jpeg")
+    )
+    writer.write(handshake.encode("utf-8"))
+    await writer.drain()
+
+    values = [params.get(name, "") for name in arg_names]
+    writer.write(encode_instruction("connect", *values).encode("utf-8"))
+    await writer.drain()
+
+    ready_instr = await read_instruction(reader)
+    if ready_instr[0] != "ready":
+        raise GuacamoleProtocolError(f"Verbindungsaufbau fehlgeschlagen: {ready_instr}")
+    connection_id = ready_instr[1] if len(ready_instr) > 1 else ""
+
+    return GuacdTunnel(reader, writer, connection_id)
+
+
+def build_rdp_params(host: dict, password: str) -> dict[str, str]:
+    """Baut die Parameter-Map fuer die connect-Instruktion aus dem Host-Datensatz.
+
+    Sicherheitsdefaults (siehe Konzept 6.3/6.7): NLA wird erzwungen sofern
+    rdp_require_nla gesetzt ist (Standard), Zertifikatspruefung ist standardmaessig
+    AKTIV (ignore-cert=false) -- bei selbstsignierten Zertifikaten auf den
+    Zielsystemen muss dies bewusst pro Host ueberschrieben werden, kein stiller
+    Bypass.
+    """
+    return {
+        "hostname": host["address"],
+        "port": str(host["port"]),
+        "username": host.get("rdp_username") or "",
+        "password": password,
+        "domain": host.get("rdp_domain") or "",
+        "security": "nla" if host.get("rdp_require_nla", True) else "any",
+        "ignore-cert": "false",
+        "disable-audio": "true",
+        "enable-drive": "true" if host.get("file_transfer_enabled") else "false",
+        "drive-path": f"/var/lib/jumphost/rdp-drives/{host['id']}",
+        "create-drive-path": "true",
+        "disable-copy": "false" if host.get("clipboard_enabled") else "true",
+        "disable-paste": "false" if host.get("clipboard_enabled") else "true",
+        "resize-method": "display-update",
+    }