Version 2.8.23: nicht das teure Verfahren zuerst

apps/tesm/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm"
-version = "2.8.13"
+version = "2.8.23"
 description = "TESM -- Verwaltung und Ueberwachung von PoE-Endgeraeten und Aruba-Switchen"
 requires-python = ">=3.11"
 dependencies = [

apps/tesm/src/tesm/blueprints/dashboard.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from flask import Blueprint, abort, render_template, request
+from flask import Blueprint, abort, render_template, request, url_for
 from tesm_core.security.sessions import fragment
 from tesm_core.extension import core, db
 
@@ -49,6 +49,13 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
     # Einmal je Seitenaufbau, nicht je Kachel: der Port ist fuer alle derselbe,
     # und ohne das Recht wird gar nicht erst nachgesehen.
     vnc_erlaubt = detailed and current_user.has("device_vnc.execute")
+    # Das Fenster setzt eine frische Passwortbestaetigung voraus -- dieselbe
+    # Schwelle wie die Geraeteseite. Fehlt sie, fuehrt der Knopf dorthin: dort
+    # wird danach gefragt, und ein Fenster, das sich mit "bitte erst
+    # bestaetigen" oeffnet, waere ein Klick fuer nichts.
+    from tesm_core.auth.service import reauth_is_fresh
+
+    vnc_fenster = vnc_erlaubt and reauth_is_fresh()
     vnc_port = (
         int(core().settings.get(conn, "vnc_port") or vnc_dienst.STANDARD_PORT)
         if vnc_erlaubt and core().settings.get(conn, "vnc_enabled")
@@ -95,9 +102,16 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
                     # Verbindungsversuch je Kachel und Aufbau waere genau die
                     # Art Hintergrundlast, die niemand bestellt hat.
                     "vnc": bool(vnc_port and row["vnc_open"]),
+                    "vnc_quelle": (
+                        url_for("screen.session_json", device_id=int(row["id"]))
+                        if vnc_port and row["vnc_open"]
+                        else ""
+                    ),
                 }
             )
         tiles.append(entry)
+    # Merker fuer die Vorlage: nur mit frischer Bestaetigung gibt es das
+    # Fenster; sonst zeigt die Kachel auf die Seite.
 
     sections = [
         {
@@ -142,6 +156,7 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
         "counts": counts,
         "sections": sections,
         "detailed": detailed,
+        "vnc_fenster": vnc_fenster,
         "interval": int(core().settings.get(conn, "monitor_interval_seconds") or 300),
     }
 

apps/tesm/src/tesm/blueprints/devices.py

@@ -374,13 +374,13 @@ def detail(device_id: int):
 
 
 def _vnc_zugang(conn: Any, device: dict[str, Any]) -> vnc.Zugang | None:
-    """Der Bildschirmzugriff dieses Clients -- frisch gefragt, nicht geraten.
+    """Der Bildschirmzugriff dieses Clients -- aus dem, was bekannt ist.
 
-    Die Kacheln der Statusuebersicht nehmen den Stand aus dem letzten
-    Ueberwachungsdurchlauf; hier geht es um **ein** Geraet, also fragt die Seite
-    selbst nach (ein halbe Sekunde Zeitlimit, und nur wenn der Client gerade
-    erreichbar ist). Das Ergebnis wird gleich festgehalten -- dann stimmt auch
-    die Kachel, ohne auf den naechsten Durchlauf zu warten.
+    Diese Seite fragt das Geraet **nicht**. Erreichbarkeit kommt aus dem
+    Ueberwachungsdurchlauf, die Anmeldeverfahren aus der letzten
+    ausdruecklichen Pruefung. Der Grund steht in :func:`vnc.zugang_gemerkt`:
+    jede Messung ist eine angefangene Protokollverhandlung, und ein RealVNC
+    Server zaehlt so etwas mit.
     """
     extension = core()
     if not current_user.has("device_vnc.execute"):
@@ -388,12 +388,7 @@ def _vnc_zugang(conn: Any, device: dict[str, Any]) -> vnc.Zugang | None:
     if not extension.settings.get(conn, "vnc_enabled"):
         return None
     port = int(extension.settings.get(conn, "vnc_port") or vnc.STANDARD_PORT)
-    online = str(device.get("state") or "") == "online" and not device.get("deleted_at")
-    zugang = vnc.zugang(device, port=port, pruefen=online)
-    if online:
-        with transaction():
-            monitor.merke_vnc(conn, int(device["id"]), zugang.erreichbar, zugang.ziel)
-    return zugang
+    return vnc.zugang_gemerkt(device, port=port)
 
 
 @bp.get("/<int:device_id>/vnc")
@@ -416,15 +411,21 @@ def vnc_connection(device_id: int):
     ziel = vnc.ziel(device)
     if not ziel:
         abort(404)
-    with transaction():
-        _audit(
-            conn,
-            "device.vnc_opened",
-            str(device["name"]),
-            f"Verbindungsdatei für {ziel}:{port}",
+    # Kein Eintrag in der Aenderungskette: eine Verbindungsdatei ist derselbe
+    # Vorgang wie die Sitzung im Browser, nur fuer einen Viewer auf dem
+    # Arbeitsplatz -- und sie aendert nichts. Wer zusieht, steht im laufenden
+    # Protokoll; das Aenderungsprotokoll bleibt die Liste der Eingriffe.
+    live = core().registry.get("live_log")
+    if live is not None:
+        live.info(
+            "vnc", f"{current_user.username} lädt die Verbindungsdatei für {device['name']}"
         )
     return Response(
-        vnc.verbindungsdatei(device, port=port),
+        vnc.verbindungsdatei(
+            device,
+            port=port,
+            warnung_aus=bool(extension.settings.get(conn, "vnc_warn_unencrypted_off")),
+        ),
         mimetype="application/octet-stream",
         headers={
             "Content-Disposition": f'attachment; filename="{vnc.dateiname(device)}"',

apps/tesm/src/tesm/blueprints/screen.py

@@ -30,7 +30,15 @@ import threading
 import time
 from typing import Any
 
-from flask import Blueprint, abort, render_template
+from flask import (
+    Blueprint,
+    abort,
+    flash,
+    redirect,
+    render_template,
+    request,
+    url_for,
+)
 from tesm_core import audit
 from tesm_core.auth.models import current_user, permission_required, reauth_required
 from tesm_core.auth.service import client_ip, reauth_is_fresh
@@ -50,6 +58,10 @@ VERBINDUNGSLIMIT = 6.0
 #: bis ein Schub weitergereicht wird.
 BLOCK = 32 * 1024
 
+#: Wie oft nachgesehen wird, ob die Sitzung noch etwas tut. Kurz genug, dass
+#: das Trennen puenktlich ist, lang genug, dass das Nachsehen nichts kostet.
+TAKT = 1.0
+
 
 def _geraet(conn: Any, device_id: int) -> dict[str, Any] | None:
     device = inventory.get_device(conn, device_id)
@@ -71,11 +83,13 @@ def _port(conn: Any) -> int:
 def screen(device_id: int):
     """Die Seite mit der Leinwand.
 
-    Sie misst vor dem Verbinden, **wie** der VNC-Server sich authentifizieren
-    will. Bietet er nur Verfahren an, die der Browser-Client nicht kennt, steht
-    das als Satz auf der Seite -- mit der Zeile, die das auf dem Geraet aendert.
-    Der Unterschied zur schwarzen Flaeche ist der ganze Punkt: wer nicht weiss,
-    woran es liegt, sucht den Fehler bei TESM.
+    Sie beruehrt das Geraet nicht: die Sitzung selbst ist der einzige Anlass,
+    dort anzuklopfen. Was ueber die Anmeldeverfahren bekannt ist, steht in der
+    Datenbank -- aus der letzten ausdruecklichen Pruefung (Knopf "Verfahren
+    pruefen"). Dass diese Seite frueher selbst gemessen hat, war ein Fehler:
+    jede Messung ist eine angefangene und abgebrochene Protokollverhandlung,
+    und ein RealVNC Server zaehlt so etwas -- das Oeffnen der Seite hat der
+    Sitzung also selbst im Weg gestanden.
     """
     conn = db()
     device = _geraet(conn, device_id)
@@ -85,43 +99,156 @@ def screen(device_id: int):
     if not port:
         abort(404)
 
-    zugang = vnc.zugang(device, port=port, pruefen=str(device.get("state") or "") == "online")
-    benutzer, passwort = "", ""
-    darf_geheimnis = bool(current_user.has("credentials.secrets"))
-    if device.get("credential_id") and darf_geheimnis:
-        try:
-            benutzer, passwort = inventory.credential_secret(
-                conn, core().keystore, int(device["credential_id"])
-            )
-        except inventory.ValidationError:
-            benutzer, passwort = "", ""
-        if passwort:
-            with core().database.transaction(conn):
-                audit.log(
-                    conn,
-                    actor=current_user.username,
-                    actor_id=current_user.id,
-                    action="device.vnc_credentials_used",
-                    target=str(device["name"]),
-                    detail=(
-                        f"Hinterlegte Zugangsdaten ({benutzer}) an die Bildschirmsitzung "
-                        "übergeben"
-                    ),
-                    ip=client_ip(),
-                    severity="warning",
-                )
-
+    zugang = vnc.zugang_gemerkt(device, port=port)
     return render_template(
         "tesm/screen.html",
         device=device,
         zugang=zugang,
-        websocket_path=f"/ws/screen/{device_id}",
-        vorgaben={"username": benutzer, "password": passwort},
-        darf_geheimnis=darf_geheimnis,
+        quelle=url_for("screen.session_json", device_id=device_id),
+        darf_geheimnis=bool(current_user.has("credentials.secrets")),
         verfahren_name=vnc.verfahren_name,
     )
 
 
+def _zugangsdaten(conn: Any, device: dict[str, Any]) -> tuple[str, str]:
+    """Hinterlegte Zugangsdaten -- nur fuer den, der Geheimnisse sehen darf.
+
+    Weil der Browser die Anmeldung fuehrt, muessen sie in die Seite. Wer
+    Geheimnisse nicht sehen darf, bekommt sie auch hier nicht: sonst waere die
+    Bildschirmsitzung der Umweg, auf dem jeder das Passwort liest. Jede
+    Herausgabe steht im Aenderungsprotokoll -- das ist kein Zusehen, sondern
+    ein Zugriff auf etwas, das sonst niemand sieht.
+    """
+    if not device.get("credential_id") or not current_user.has("credentials.secrets"):
+        return "", ""
+    try:
+        benutzer, passwort = inventory.credential_secret(
+            conn, core().keystore, int(device["credential_id"])
+        )
+    except inventory.ValidationError:
+        return "", ""
+    if passwort:
+        with core().database.transaction(conn):
+            audit.log(
+                conn,
+                actor=current_user.username,
+                actor_id=current_user.id,
+                action="device.vnc_credentials_used",
+                target=str(device["name"]),
+                detail=(
+                    f"Hinterlegte Zugangsdaten ({benutzer}) an die Bildschirmsitzung "
+                    "übergeben"
+                ),
+                ip=client_ip(),
+                severity="warning",
+            )
+    return benutzer, passwort
+
+
+@bp.post("/monitoring/clients/<int:device_id>/screen/probe")
+@permission_required("device_vnc.execute")
+@reauth_required
+def probe(device_id: int):
+    """Fragt das Geraet ausdruecklich, wie es sich authentifizieren will.
+
+    Ein Knopf und keine Nebenwirkung des Seitenaufbaus: die Messung bricht eine
+    Protokollverhandlung ab, und RealVNC zaehlt das. Sie gehoert in die Hand
+    dessen, der gerade sucht -- nicht in jeden Aufruf.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    port = _port(conn)
+    if not port:
+        abort(404)
+
+    from ..services import monitor
+
+    zugang = vnc.zugang(device, port=port)
+    with core().database.transaction(conn):
+        monitor.merke_vnc(conn, int(device["id"]), zugang.erreichbar, zugang.ziel)
+        monitor.merke_verfahren(conn, int(device["id"]), zugang.verfahren, zugang.absage)
+    if zugang.absage:
+        flash(f"Der Server antwortet: „{zugang.absage}“", "warning")
+    elif zugang.verfahren:
+        flash(
+            "Angebotene Anmeldeverfahren: "
+            + ", ".join(vnc.verfahren_name(v) for v in zugang.verfahren),
+            "info",
+        )
+    else:
+        flash(f"{zugang.ziel}:{port} hat nicht geantwortet.", "danger")
+    return redirect(url_for("screen.screen", device_id=device_id))
+
+
+@bp.get("/monitoring/clients/<int:device_id>/screen/session")
+@permission_required("device_vnc.execute")
+def session_json(device_id: int):
+    """Alles, was der Client fuer eine Sitzung braucht -- als Auskunft.
+
+    Warum nicht in die Seite geschrieben: dieselbe Sitzung laeuft auch im
+    Fenster der Statusuebersicht, und dort stuenden sonst die Zugangsdaten
+    **jedes** Geraets im Quelltext der Seite. So holt sie sich nur, wer eine
+    Sitzung wirklich oeffnet -- und nur fuer das eine Geraet.
+
+    Die frische Passwortbestaetigung wird hier von Hand geprueft statt ueber
+    den Dekorator: der wuerde auf eine Seite umleiten, und eine Umleitung ist
+    fuer einen Abruf im Hintergrund keine Auskunft. 409 mit einem Hinweis ist
+    eine.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    port = _port(conn)
+    if not port:
+        abort(404)
+    if not reauth_is_fresh():
+        return {"reauth": True}, 409
+
+    zugang = vnc.zugang_gemerkt(device, port=port)
+    benutzer, passwort = _zugangsdaten(conn, device)
+    return {
+        "name": str(device["name"]),
+        "socket": f"/ws/screen/{device_id}",
+        "ziel": f"{zugang.ziel}:{zugang.port}",
+        "verfahren": list(zugang.verfahren),
+        "bewaehrt": zugang.bewaehrt,
+        "hinderungsgrund": zugang.hinderungsgrund,
+        "meldeweg": url_for("screen.merke_verfahren", device_id=device_id),
+        "vorgaben": {"username": benutzer, "password": passwort},
+    }
+
+
+@bp.post("/monitoring/clients/<int:device_id>/screen/method")
+@permission_required("device_vnc.execute")
+def merke_verfahren(device_id: int):
+    """Der Browser meldet, womit die Sitzung zustande kam.
+
+    Nur er weiss es: die Strecke reicht Bytes durch und liest das Protokoll
+    nicht. Beim naechsten Mal faengt die Seite damit an, statt wieder bei der
+    ersten Wahl des Servers -- die hier schon einmal abgerissen ist und deren
+    Absage sich ein sperrender RealVNC Server Minuten Zeit laesst.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    try:
+        verfahren = int(request.json.get("verfahren", 0)) if request.json else 0
+    except (TypeError, ValueError):
+        verfahren = 0
+    if not 0 < verfahren < 256:
+        return {"ok": False}, 400
+
+    from ..services import monitor
+
+    with core().database.transaction(conn):
+        monitor.merke_verfahren_das_traegt(conn, int(device["id"]), verfahren)
+    return {"ok": True}
+
+
 def init_app(app) -> None:  # type: ignore[no-untyped-def]
     """Meldet Seite und -- falls verfuegbar -- die WebSocket-Strecke an."""
     app.register_blueprint(bp)
@@ -138,6 +265,26 @@ def init_app(app) -> None:  # type: ignore[no-untyped-def]
     def screen_socket(ws, device_id: int):  # type: ignore[no-untyped-def]
         _strecke(ws, device_id)
 
+    @sock.route("/ws/probe")
+    def probe_socket(ws):  # type: ignore[no-untyped-def]
+        """Sagt "da", und mehr nicht.
+
+        Wozu: bricht eine Bildschirmsitzung ab, gibt es zwei sehr verschiedene
+        Ursachen -- der VNC-Server mag nicht, oder die WebSocket-Verbindung
+        kommt gar nicht erst durch (ein Proxy zwischen Browser und TESM, der
+        "Upgrade" nicht weiterreicht, ist der haeufigste Fall). Von aussen
+        sehen beide gleich aus: ein Abbruch ohne Grund. Diese Probe trennt
+        sie, ohne dass jemand ein Protokoll lesen muss.
+        """
+        if not current_user.is_authenticated:
+            ws.close(1008, "Nicht angemeldet.")
+            return
+        try:
+            ws.send("da")
+            ws.receive(timeout=2)
+        except Exception:  # noqa: BLE001 - der Browser ist weg, das ist keine Stoerung
+            pass
+
 
 def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
     """Bytes hin, Bytes her -- und sonst nichts.
@@ -172,37 +319,95 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
     except OSError as exc:
         ws.close(1011, f"{host}:{port} antwortet nicht ({exc}).")
         return
+    # Das Zeitlimit galt dem *Aufbau* -- als Abbruchgrund taugt es nicht.
+    #
+    # ``create_connection`` setzt es an den Socket, und dort gilt es fuer jede
+    # weitere Leseoperation. Ein Bildschirm, auf dem sich gerade nichts tut,
+    # schickt sekundenlang nichts; nach sechs Sekunden Stille brach das Lesen
+    # mit einer Zeitueberschreitung ab, und die Sitzung war weg. Genau so
+    # beobachtet: Bild steht, nach fuenf bis zehn Sekunden Schluss.
+    #
+    # Stattdessen ein kurzer Takt: das Lesen laeuft immer wieder in ein
+    # Zeitlimit, und *das* ist kein Abbruch, sondern der Anlass nachzusehen,
+    # ob die Sitzung ueberhaupt noch etwas tut.
+    # Ohne das sammelt der Kern kleine Pakete, bis genug beisammen ist
+    # (Nagle) -- bei einem Bildschirm sind Tastendruck und Mausbewegung genau
+    # solche kleinen Pakete, und das Warten darauf faellt als Ruckeln auf.
+    gegenstelle.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    gegenstelle.settimeout(TAKT)
+    leerlauf = int(extension.settings.get(conn, "vnc_idle_timeout") or 0)
 
+    # Ins **laufende** Protokoll, nicht in die Aenderungskette: eine
+    # Bildschirmsitzung aendert nichts an der Anlage. Das Aenderungsprotokoll
+    # soll beantworten, wer was umgestellt hat -- wer wann zugesehen hat,
+    # gehoert nicht in dieselbe Liste und macht sie in einem Betrieb mit
+    # ein paar Dutzend Geraeten unlesbar. Sichtbar ist die Sitzung trotzdem,
+    # solange sie laeuft.
     begonnen = time.monotonic()
-    with extension.database.transaction(conn):
-        audit.log(
-            conn,
-            actor=current_user.username,
-            actor_id=current_user.id,
-            action="device.screen_opened",
-            target=str(device["name"]),
-            detail=f"Bildschirmsitzung zu {host}:{port}",
-            ip=client_ip(),
-            severity="warning",
-        )
+    live = extension.registry.get("live_log")
+    if live is not None:
+        live.info("vnc", f"{current_user.username} öffnet den Bildschirm von {device['name']}")
 
     laeuft = threading.Event()
     laeuft.set()
+    #: Wann zuletzt etwas floss -- in *irgendeine* Richtung. Eine Liste, weil
+    #: beide Richtungen daran schreiben und eine Zuweisung in Python nicht in
+    #: die andere hineinlaufen kann.
+    zuletzt = [time.monotonic()]
+    #: Grund des Endes, falls wir selbst getrennt haben.
+    schluss = [""]
+    #: Kam ueberhaupt schon ein Byte vom Geraet?
+    gehoert = [False]
 
     def vom_geraet() -> None:
         """Alles, was der VNC-Server schickt, geht als Binaerrahmen weiter."""
         try:
             while laeuft.is_set():
-                daten = gegenstelle.recv(BLOCK)
+                try:
+                    daten = gegenstelle.recv(BLOCK)
+                except socket.timeout:
+                    # Kein Fehler, nur Stille -- und die bedeutet zweierlei,
+                    # je nachdem, ob die Sitzung schon stand.
+                    #
+                    # **Vor dem ersten Byte** ist Stille ein Befund: der Port
+                    # nimmt an, aber es kommt nichts. Genau so verhaelt sich
+                    # ein RealVNC Server, der die Adresse gerade aussperrt. Wer
+                    # das nicht erfaehrt, sieht ewig "Verbindung wird
+                    # aufgebaut" -- und sucht den Fehler bei uns.
+                    if not gehoert[0] and time.monotonic() - begonnen > VERBINDUNGSLIMIT:
+                        schluss[0] = (
+                            f"{host}:{port} nimmt die Verbindung an, schickt aber nichts. "
+                            "So verhält sich ein VNC-Server, der die Adresse gerade "
+                            "aussperrt (RealVNC: BlacklistTimeout) – ein Neustart des "
+                            "VNC-Dienstes auf dem Gerät räumt das ab."
+                        )
+                        break
+                    # **Danach** ist Stille der Normalfall: ein Bildschirm, auf
+                    # dem sich nichts tut, schickt nichts.
+                    if gehoert[0] and leerlauf and time.monotonic() - zuletzt[0] > leerlauf:
+                        schluss[0] = (
+                            f"Sitzung nach {leerlauf} Sekunden ohne Bewegung getrennt"
+                        )
+                        break
+                    continue
                 if not daten:
+                    if not gehoert[0]:
+                        schluss[0] = (
+                            f"{host}:{port} hat die Verbindung sofort wieder geschlossen."
+                        )
                     break
+                gehoert[0] = True
+                zuletzt[0] = time.monotonic()
                 ws.send(daten)
         except Exception:  # noqa: BLE001 - Abbruch ist der Normalfall, nicht die Stoerung
             pass
         finally:
             laeuft.clear()
             try:
-                ws.close()
+                if schluss[0]:
+                    ws.close(1000 if gehoert[0] else 1011, schluss[0])
+                else:
+                    ws.close()
             except Exception:  # noqa: BLE001
                 pass
 
@@ -219,6 +424,7 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
                 # waere entweder ein Irrtum oder ein Versuch -- beides endet
                 # hier und nicht auf dem Geraet.
                 continue
+            zuletzt[0] = time.monotonic()
             gegenstelle.sendall(nachricht)
     except Exception:  # noqa: BLE001
         logger.debug("Bildschirmsitzung beendet (%s)", device["name"], exc_info=True)
@@ -230,14 +436,9 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
             pass
         gegenstelle.close()
         dauer = int(time.monotonic() - begonnen)
-        with extension.database.session() as frisch, extension.database.transaction(frisch):
-            audit.log(
-                frisch,
-                actor=current_user.username,
-                actor_id=current_user.id,
-                action="device.screen_closed",
-                target=str(device["name"]),
-                detail=f"Dauer {dauer}s",
-                ip=client_ip(),
-                severity="info",
+        if live is not None:
+            live.info(
+                "vnc",
+                f"Bildschirmsitzung {device['name']} beendet ({dauer}s)"
+                + (f" – {schluss[0]}" if schluss[0] else ""),
             )

apps/tesm/src/tesm/blueprints/settings.py

@@ -105,6 +105,8 @@ def system():
                 "dashboard_public",
                 "vnc_enabled",
                 "vnc_port",
+                "vnc_idle_timeout",
+                "vnc_warn_unencrypted_off",
                 "terminal_switches_enabled",
                 "terminal_clients_enabled",
                 "terminal_idle_timeout",
@@ -147,6 +149,8 @@ def system_save():
         "dashboard_public",
         "vnc_enabled",
         "vnc_port",
+        "vnc_idle_timeout",
+        "vnc_warn_unencrypted_off",
         "terminal_switches_enabled",
         "terminal_clients_enabled",
         "terminal_idle_timeout",

apps/tesm/src/tesm/schema.py

@@ -526,6 +526,32 @@ ALTER TABLE device_status ADD COLUMN vnc_types TEXT NOT NULL DEFAULT '';
 """
 
 
+# Version 13 ----------------------------------------------------------------
+#
+# Die Absage eines VNC-Servers und der Zeitpunkt der Verfahrensmessung. Beide
+# gehoeren getrennt vom Ueberwachungsdurchlauf gefuehrt: der fragt nur noch,
+# ob der Port annimmt (eine abgebrochene Protokollverhandlung sperrt bei
+# RealVNC die eigene Adresse aus), die Verfahren misst die Seite -- und auch
+# die nur, wenn die letzte Messung alt ist.
+V13 = """
+ALTER TABLE device_status ADD COLUMN vnc_reason TEXT NOT NULL DEFAULT '';
+ALTER TABLE device_status ADD COLUMN vnc_types_at TEXT;
+"""
+
+
+# Version 14 ----------------------------------------------------------------
+#
+# Welches Anmeldeverfahren zuletzt wirklich getragen hat. Der Server nennt
+# seine Reihenfolge, und die gilt -- aber wenn seine erste Wahl schon einmal
+# abgerissen ist und eine andere zum Bild gefuehrt hat, ist das ein Befund.
+# Ihn zu vergessen kostet bei jedem Oeffnen einen Fehlversuch, und RealVNC
+# laesst sich mit der Absage Zeit: gemessen zwei bis drei Minuten, bis das
+# Bild stand.
+V14 = """
+ALTER TABLE device_status ADD COLUMN vnc_method INTEGER NOT NULL DEFAULT 0;
+"""
+
+
 def uebergang_standardgruppen(conn) -> None:  # type: ignore[no-untyped-def]
     """Aus sieben Standardgruppen werden drei -- ohne jemandem etwas wegzunehmen.
 
@@ -571,4 +597,6 @@ TESM_MIGRATIONS: tuple[Migration, ...] = (
     Migration(version=10, name="vnc-erreichbarkeit", sql=V10),
     Migration(version=11, name="vnc-ziel", sql=V11),
     Migration(version=12, name="vnc-verfahren", sql=V12),
+    Migration(version=13, name="vnc-absage", sql=V13),
+    Migration(version=14, name="vnc-verfahren-das-traegt", sql=V14),
 )

apps/tesm/src/tesm/services/inventory.py

@@ -544,7 +544,9 @@ def list_devices(
                st.last_ok_at, st.last_change_at, st.last_restart_at, st.restart_count,
                st.fail_count, COALESCE(st.vnc_open, 0) AS vnc_open, st.vnc_checked_at,
                COALESCE(st.vnc_target, '') AS vnc_target,
-               COALESCE(st.vnc_types, '') AS vnc_types
+               COALESCE(st.vnc_types, '') AS vnc_types,
+               COALESCE(st.vnc_reason, '') AS vnc_reason, st.vnc_types_at,
+               COALESCE(st.vnc_method, 0) AS vnc_method
           FROM devices d
           LEFT JOIN switches s ON s.id = d.switch_id AND s.deleted_at IS NULL
           LEFT JOIN credentials c ON c.id = d.credential_id AND c.deleted_at IS NULL

apps/tesm/src/tesm/services/monitor.py

@@ -507,30 +507,45 @@ class SweepReport:
     duration_ms: int = 0
 
 
-def merke_vnc(
-    conn: sqlite3.Connection,
-    device_id: int,
-    offen: bool,
-    ziel: str = "",
-    verfahren: tuple[int, ...] = (),
-) -> None:
+def merke_vnc(conn: sqlite3.Connection, device_id: int, offen: bool, ziel: str = "") -> None:
     """Haelt fest, ob dort ein VNC-Server antwortet -- und unter welchem Ziel.
 
     Das Ziel gehoert dazu, weil die Statusuebersicht die Verbindung unmittelbar
     verlinkt. Es aus dem Namen neu herzuleiten hiesse, je Kachel und
     Seitenaufbau eine Namensaufloesung zu versuchen; hier steht es einmal
     geschrieben, von dem, der ohnehin gefragt hat.
+
+    Die Anmeldeverfahren bleiben unberuehrt: sie kommen aus einer anderen
+    Quelle (:func:`merke_verfahren`) und haetten hier nur den Wert "nicht
+    gefragt" -- der wuerde eine gute Messung ueberschreiben.
     """
     conn.execute(
-        "UPDATE device_status SET vnc_open=?, vnc_checked_at=?, vnc_target=?, vnc_types=? "
-        "WHERE device_id=?",
-        (
-            1 if offen else 0,
-            _now(),
-            ziel,
-            ",".join(str(v) for v in verfahren),
-            device_id,
-        ),
+        "UPDATE device_status SET vnc_open=?, vnc_checked_at=?, vnc_target=? WHERE device_id=?",
+        (1 if offen else 0, _now(), ziel, device_id),
+    )
+
+
+def merke_verfahren(
+    conn: sqlite3.Connection, device_id: int, verfahren: tuple[int, ...], absage: str = ""
+) -> None:
+    """Haelt fest, wie sich der VNC-Server authentifizieren will.
+
+    Mit Zeitstempel, denn diese Messung kostet eine angefangene
+    Protokollverhandlung -- und die soll sich nicht bei jedem Seitenaufbau
+    wiederholen.
+    """
+    conn.execute(
+        "UPDATE device_status SET vnc_types=?, vnc_reason=?, vnc_types_at=? WHERE device_id=?",
+        (",".join(str(v) for v in verfahren), absage, _now(), device_id),
+    )
+
+
+def merke_verfahren_das_traegt(
+    conn: sqlite3.Connection, device_id: int, verfahren: int
+) -> None:
+    """Haelt fest, womit die letzte Sitzung wirklich zustande kam."""
+    conn.execute(
+        "UPDATE device_status SET vnc_method=? WHERE device_id=?", (int(verfahren), device_id)
     )
 
 
@@ -553,6 +568,10 @@ def run_sweep(
     erreichbare Geraet: nimmt dort ein VNC-Server Verbindungen an? Sie gehoert
     hierher und nicht in den Seitenaufbau -- einmal je Intervall statt einmal
     je Aufruf, und nur fuer Geraete, die ohnehin gerade antworten.
+
+    **Nur die Frage nach dem Port**, kein Wort Protokoll: ein RealVNC Server
+    zaehlt abgebrochene Verhandlungen und sperrt die Adresse eine Weile aus.
+    Welche Anmeldeverfahren er anbietet, misst die Seite, die es braucht.
     """
     from . import vnc as vnc_dienst  # spaet: vnc benutzt tcp_reachable von hier
 
@@ -575,7 +594,7 @@ def run_sweep(
             # bekannten Stand stehen. Ein Geraet, das gerade neu startet, soll
             # seinen Knopf nicht verlieren.
             return device, ergebnis, None
-        return device, ergebnis, vnc_dienst.zugang(device, port=vnc_port)
+        return device, ergebnis, vnc_dienst.zugang_kurz(device, port=vnc_port)
 
     with ThreadPoolExecutor(max_workers=min(MAX_PARALLEL_CHECKS, len(devices))) as pool:
         results = list(pool.map(pruefen, devices))
@@ -587,13 +606,7 @@ def run_sweep(
                 report.checked += 1
                 previous, current = record_status(conn, int(device["id"]), result)
                 if vnc_offen is not None:
-                    merke_vnc(
-                        conn,
-                        int(device["id"]),
-                        vnc_offen.erreichbar,
-                        vnc_offen.ziel,
-                        vnc_offen.verfahren,
-                    )
+                    merke_vnc(conn, int(device["id"]), vnc_offen.erreichbar, vnc_offen.ziel)
                 if result.ok:
                     report.online += 1
                 else:

apps/tesm/src/tesm/services/vnc.py

@@ -61,6 +61,12 @@ class Zugang:
     #: gemessen). Daraus entsteht der Satz, warum eine Sitzung im Browser
     #: gehen wird oder nicht.
     verfahren: tuple[int, ...] = ()
+    #: Der Text, mit dem der Server die Verbindung abgelehnt hat -- er nennt
+    #: dann kein Verfahren, sondern eine 0 und einen Grund.
+    absage: str = ""
+    #: Das Verfahren, mit dem zuletzt wirklich eine Sitzung zustande kam
+    #: (0: noch keine). Damit faengt der naechste Versuch an.
+    bewaehrt: int = 0
 
     @property
     def browsertauglich(self) -> bool:
@@ -72,6 +78,14 @@ class Zugang:
         """Warum eine Sitzung im Browser nicht zustande kaeme -- im Klartext."""
         if not self.erreichbar:
             return f"Auf {self.ziel}:{self.port} antwortet kein VNC-Server."
+        if self.absage:
+            return (
+                f"Der VNC-Server auf {self.ziel} weist die Verbindung ab: "
+                f"„{self.absage}“. Das ist seine Auskunft, nicht unsere – "
+                "typisch sind eine Sperre nach zu vielen Fehlversuchen "
+                "(RealVNC: BlacklistTimeout), eine Adressfilterung oder eine "
+                "belegte Sitzung."
+            )
         if not self.verfahren:
             return ""
         if self.browsertauglich:
@@ -181,7 +195,36 @@ def verfahren_name(nummer: int) -> str:
     return str(nummer)
 
 
-def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tuple[int, ...]]:
+def _absage(sock: Any) -> str:
+    """Der Grund, den ein Server einer abgelehnten Verbindung mitgibt.
+
+    Auf eine 0 -- ob als Anzahl (ab 3.7) oder als bestimmtes Verfahren (3.3) --
+    folgt eine Laenge und ein Text. Genau dieser Satz ist die Auskunft, die
+    sonst niemand bekommt: "zu viele Fehlversuche", "Verbindung von dieser
+    Adresse nicht erlaubt", "kein gemeinsames Verfahren". Ohne ihn steht da
+    nur, dass es nicht geht.
+    """
+    try:
+        roh = sock.recv(4)
+        if len(roh) < 4:
+            return ""
+        laenge = int.from_bytes(roh, "big")
+        if not 0 < laenge <= 1024:
+            return ""
+        text = b""
+        while len(text) < laenge:
+            stueck = sock.recv(laenge - len(text))
+            if not stueck:
+                break
+            text += stueck
+        return text.decode("utf-8", "replace").strip()
+    except OSError:
+        return ""
+
+
+def sicherheitsverfahren(
+    host: str, port: int = STANDARD_PORT
+) -> tuple[str, tuple[int, ...], str]:
     """Fragt den Server, **wie** er sich authentifizieren will.
 
     Der Anfang einer VNC-Verbindung ist fuer jeden Server derselbe: er nennt
@@ -192,8 +235,12 @@ def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tup
     Das ist die Angabe, an der eine Bildschirmsitzung im Browser scheitert oder
     gelingt, und sie hier zu messen ist der Unterschied zwischen einer
     schwarzen Flaeche und dem Satz "dieser Server bietet nur Verfahren an, die
-    der Browser nicht kennt". Gibt ``(Fassung, Verfahren)`` zurueck; bei einem
-    Fehler ``("", ())``.
+    der Browser nicht kennt".
+
+    Gibt ``(Fassung, Verfahren, Absage)`` zurueck. Die Absage ist der Text, den
+    ein Server mitschickt, wenn er die Verbindung **ablehnt** -- er meldet dann
+    kein Verfahren, sondern eine 0 und einen Grund. Bei einem Fehler
+    ``("", (), "")``.
     """
     import socket
 
@@ -202,28 +249,68 @@ def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tup
             sock.settimeout(ZEITLIMIT)
             gruss = sock.recv(12)
             if not gruss.startswith(b"RFB "):
-                return "", ()
+                return "", (), ""
             fassung = gruss[4:11].decode("ascii", "replace")
             # Wir antworten mit 3.8 -- der Fassung, die auch der Browser
             # spricht. Ein Server, der mehr kann, faellt darauf zurueck und
             # nennt trotzdem seine Verfahren.
-            sock.sendall(b"RFB 003.008" + bytes([10]))
+            # Antworten wird mit *seiner* Fassung, hoechstens 3.8. Wer einem
+            # 3.3-Server mit 3.8 antwortet, bekommt keine Liste, sondern eine
+            # 32-Bit-Zahl -- und liest sie als "keine Verfahren".
+            eigene = "003.003" if fassung == "003.003" else "003.008"
+            sock.sendall(b"RFB " + eigene.encode("ascii") + bytes([10]))
+
+            if eigene == "003.003":
+                # RFB 3.3: der Server bestimmt allein und schickt eine
+                # 32-Bit-Zahl. Das ist kein Sonderfall aus der Vorzeit --
+                # RealVNC faellt darauf zurueck, sobald keine Anmeldung
+                # verlangt wird.
+                rohwert = b""
+                while len(rohwert) < 4:
+                    stueck = sock.recv(4 - len(rohwert))
+                    if not stueck:
+                        break
+                    rohwert += stueck
+                if len(rohwert) < 4:
+                    return fassung, (), ""
+                bestimmt = int.from_bytes(rohwert, "big")
+                if bestimmt == 0:
+                    return fassung, (), _absage(sock)
+                return fassung, (bestimmt,), ""
+
             anzahl = sock.recv(1)
             if not anzahl:
-                return fassung, ()
+                return fassung, (), ""
             wie_viele = anzahl[0]
             if wie_viele == 0:
                 # Null heisst: der Server lehnt ab und schickt den Grund.
-                return fassung, ()
+                return fassung, (), _absage(sock)
             liste = b""
             while len(liste) < wie_viele:
                 stueck = sock.recv(wie_viele - len(liste))
                 if not stueck:
                     break
                 liste += stueck
-            return fassung, tuple(liste)
+            return fassung, tuple(liste), ""
     except OSError:
-        return "", ()
+        return "", (), ""
+
+
+def zugang_kurz(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> Zugang:
+    """Nur die Frage, ob dort jemand annimmt -- ohne ein Wort Protokoll.
+
+    Das ist die Fassung fuer den Ueberwachungsdurchlauf. Er laeuft alle paar
+    Minuten ueber jedes Geraet, und eine angefangene und sofort wieder
+    abgebrochene Protokollverhandlung ist nicht nur unhoeflich: ein RealVNC
+    Server zaehlt abgebrochene Versuche und sperrt die Adresse eine Weile aus
+    (``BlacklistTimeout``). Eine Ueberwachung, die ihr eigenes Ziel aussperrt,
+    waere ein schoener Eigentor -- also fragt sie nur, ob der Port annimmt.
+
+    Welche Anmeldeverfahren der Server kann, misst erst die Seite, die es
+    wirklich braucht -- und auch die nicht oefter als noetig.
+    """
+    host = ziel(device)
+    return Zugang(ziel=host, port=port, erreichbar=erreichbar(host, port))
 
 
 def zugang(device: Mapping[str, Any], *, port: int = STANDARD_PORT, pruefen: bool = True) -> Zugang:
@@ -231,17 +318,63 @@ def zugang(device: Mapping[str, Any], *, port: int = STANDARD_PORT, pruefen: boo
     host = ziel(device)
     if not pruefen:
         return Zugang(ziel=host, port=port, erreichbar=False)
-    fassung, verfahren = sicherheitsverfahren(host, port)
-    return Zugang(ziel=host, port=port, erreichbar=bool(fassung), verfahren=verfahren)
+    fassung, verfahren, absage = sicherheitsverfahren(host, port)
+    return Zugang(
+        ziel=host,
+        port=port,
+        erreichbar=bool(fassung),
+        verfahren=verfahren,
+        absage=absage,
+    )
 
 
-def verbindungsdatei(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> str:
+def zugang_gemerkt(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> Zugang:
+    """Der Zugang, wie er in der Datenbank steht -- **ohne** das Geraet zu fragen.
+
+    Frueher hat diese Funktion selbst gemessen, wenn die letzte Messung alt war.
+    Das ist gestrichen, und zwar aus Erfahrung: jede Messung ist eine
+    angefangene und abgebrochene Protokollverhandlung, und ein RealVNC Server
+    zaehlt so etwas. Wer eine Bildschirmseite oeffnet, klopfte damit zweimal an
+    -- einmal zum Messen, einmal fuer die Sitzung --, und das zweite Klopfen
+    fiel dem ersten zum Opfer.
+
+    Jetzt beruehrt das Oeffnen einer Seite das Geraet gar nicht mehr. Die
+    Erreichbarkeit kommt aus dem Ueberwachungsdurchlauf (ein blosser
+    Verbindungsaufbau), die Anmeldeverfahren aus der letzten **ausdruecklichen**
+    Pruefung -- der Knopf dafuer steht auf der Seite und wird gedrueckt, wenn
+    etwas nicht geht.
+    """
+    gespeichert = str(device.get("vnc_types") or "")
+    return Zugang(
+        ziel=ziel(device),
+        port=port,
+        erreichbar=bool(device.get("vnc_open")),
+        verfahren=tuple(
+            int(teil) for teil in gespeichert.split(",") if teil.strip().isdigit()
+        ),
+        absage=str(device.get("vnc_reason") or ""),
+        bewaehrt=int(device.get("vnc_method") or 0),
+    )
+
+
+def verbindungsdatei(
+    device: Mapping[str, Any], *, port: int = STANDARD_PORT, warnung_aus: bool = False
+) -> str:
     """Der Inhalt der ``.vnc``-Datei -- drei Zeilen, keine vierte.
 
     ``ConnMethod=tcp`` ist die direkte Verbindung (nicht ueber den Cloud-Dienst
     von RealVNC), ``FriendlyName`` der Name, den der Viewer anzeigt, ``Host``
     das Ziel. Ein abweichender Port gehoert in dieser Datei an den Host, mit
     Doppelpunkt -- einen eigenen Schluessel dafuer gibt es nicht.
+
+    ``warnung_aus`` haengt eine vierte Zeile an: ``WarnUnencrypted=False``. Sie
+    betrifft **den Viewer**, nicht den Server -- er zeigt sonst bei jeder
+    Verbindung zu einem Geraet ohne Streckenverschluesselung einen roten
+    Hinweis, den man wegklicken muss. Wer ``Encryption=AlwaysOff`` auf dem
+    Geraet gesetzt hat (damit der Browser ueberhaupt verbinden kann), sieht
+    diesen Hinweis fortan bei jedem Start. Er bleibt in der Vorgabe stehen:
+    eine unverschluesselte Strecke soll man einmal bewusst hinnehmen, nicht
+    stillschweigend. Abschaltbar unter Verwaltung -> System.
     """
     host = ziel(device)
     if port != STANDARD_PORT:
@@ -251,6 +384,8 @@ def verbindungsdatei(device: Mapping[str, Any], *, port: int = STANDARD_PORT) ->
         f"FriendlyName={str(device.get('name') or host).strip()}",
         f"Host={host}",
     ]
+    if warnung_aus:
+        zeilen.append("WarnUnencrypted=False")
     return ZEILE.join(zeilen) + ZEILE
 
 

apps/tesm/src/tesm/settings_spec.py

@@ -66,6 +66,28 @@ TESM_SETTINGS: tuple[SettingSpec, ...] = (
         minimum=1,
         maximum=65535,
     ),
+    SettingSpec(
+        "vnc_idle_timeout",
+        300,
+        "int",
+        "Bildschirmsitzung bei Untätigkeit trennen nach (Sekunden)",
+        hint="Gezählt wird, wenn in **keine** Richtung mehr etwas fließt: der Bildschirm "
+        "ändert sich nicht und es kommt keine Eingabe. Eine Sitzung, die jemand offen "
+        "vergisst, hält sonst die Verbindung zum Gerät. 0 schaltet die Trennung ab.",
+        section="monitoring",
+        minimum=0,
+        maximum=86400,
+    ),
+    SettingSpec(
+        "vnc_warn_unencrypted_off",
+        False,
+        "bool",
+        "Warnung des Viewers vor unverschlüsselter Verbindung unterdrücken",
+        hint="Setzt WarnUnencrypted=False in die Verbindungsdatei. Betrifft nur den "
+        "RealVNC Viewer auf dem Arbeitsplatz, nicht die Verbindung selbst: die bleibt "
+        "unverschlüsselt, wenn das Gerät es so anbietet.",
+        section="monitoring",
+    ),
     # -- DHCP --------------------------------------------------------------- #
     SettingSpec("dhcp_domain", "local", "str", "Domainname", section="dhcp"),
     SettingSpec(

apps/tesm/src/tesm/templates/tesm/_dashboard_tiles.html

@@ -102,11 +102,25 @@
                     <div class="tile__actions">
                       {% if tile.vnc %}
                         {# Die Sitzung laeuft in TESM selbst: ein Klick, kein
-                           Viewer auf dem Arbeitsplatz, keine Datei. #}
-                        <a class="btn btn--sm" href="{{ url_for('screen.screen', device_id=tile.id) }}"
-                           title="Bildschirm im Browser öffnen">
-                          {{ icon('monitor', size=14) }} VNC
-                        </a>
+                           Viewer auf dem Arbeitsplatz, keine Datei.
+
+                           Mit frischer Passwortbestätigung öffnet sie sich hier
+                           im Fenster -- man bleibt bei der Übersicht und sieht
+                           die anderen Geräte weiter. Ohne sie führt der Knopf
+                           auf die Geräteseite, wo danach gefragt wird. #}
+                        {% if vnc_fenster %}
+                          <button class="btn btn--sm" type="button"
+                                  data-vnc-oeffnen="{{ tile.vnc_quelle }}"
+                                  data-vnc-name="{{ tile.name }}"
+                                  title="Bildschirm im Fenster öffnen">
+                            {{ icon('monitor', size=14) }} VNC
+                          </button>
+                        {% else %}
+                          <a class="btn btn--sm" href="{{ url_for('screen.screen', device_id=tile.id) }}"
+                             title="Bildschirm im Browser öffnen">
+                            {{ icon('monitor', size=14) }} VNC
+                          </a>
+                        {% endif %}
                       {% else %}
                         <span class="tile__spacer" aria-hidden="true"></span>
                       {% endif %}

apps/tesm/src/tesm/templates/tesm/_vnc_flaeche.html

@@ -0,0 +1,40 @@
+{# Die Bildschirmfläche -- einmal geschrieben, an zwei Orten benutzt: auf der
+   Geräteseite und im Fenster der Statusübersicht.
+
+   Die Teile finden sich über `data-rolle`, nicht über Kennungen: im Fenster
+   gäbe es sie sonst zweimal auf derselben Seite, und die zweite wäre die, die
+   niemand findet. #}
+{% macro vnc_flaeche(quelle='') %}
+<div class="screen" {% if quelle %}data-sitzung="{{ quelle }}"{% endif %}>
+  <div data-rolle="leinwand" class="screen__canvas" hidden></div>
+</div>
+{% endmacro %}
+
+{% macro vnc_status() %}
+<div data-rolle="status" class="screen__status">Wird vorbereitet …</div>
+{% endmacro %}
+
+{% macro vnc_zugangsdaten() %}
+<form data-rolle="zugangsdaten" class="row row--tight" hidden onsubmit="return false">
+  <label class="field">
+    <span class="field__label">Benutzer</span>
+    <input class="input" type="text" data-rolle="benutzer" autocomplete="off">
+  </label>
+  <label class="field">
+    <span class="field__label">Passwort</span>
+    <input class="input" type="password" data-rolle="passwort" autocomplete="off">
+  </label>
+  <button class="btn btn--primary" type="button" data-rolle="anmelden">Anmelden</button>
+</form>
+{% endmacro %}
+
+{# Tasten, die der Arbeitsplatz selbst abfängt und die deshalb einen Knopf
+   brauchen: Strg+Alt+Entf schaltet der Browser gar nicht erst durch, Alt+F4
+   schlösse das Fenster hier statt das Fenster dort. #}
+{% macro vnc_tasten() %}
+<button class="btn btn--sm" type="button" data-rolle="taste-cad" hidden
+        title="Strg+Alt+Entf an das Gerät senden">Strg+Alt+Entf</button>
+<button class="btn btn--sm" type="button" data-rolle="taste-altf4" hidden
+        title="Alt+F4 an das Gerät senden – schließt dort das oberste Fenster">Alt+F4</button>
+<button class="btn btn--sm" type="button" data-rolle="trennen" hidden>Trennen</button>
+{% endmacro %}

apps/tesm/src/tesm/templates/tesm/dashboard.html

@@ -1,5 +1,6 @@
 {% extends "tesm_core/base.html" %}
-{% from "tesm_core/macros.html" import search_box %}
+{% from "tesm_core/macros.html" import search_box, modal %}
+{% from "tesm/_vnc_flaeche.html" import vnc_flaeche, vnc_status, vnc_zugangsdaten, vnc_tasten %}
 
 {% block page_title %}Statusübersicht{% endblock %}
 {% block page_sub %}
@@ -19,4 +20,27 @@
      data-refresh-interval="20000">
   {% include "tesm/_dashboard_tiles.html" %}
 </div>
+
+{% if vnc_fenster %}
+  {# Ein Fenster für alle Kacheln: welches Gerät gemeint ist, bringt der Knopf
+     beim Öffnen mit. Ein Dialog je Kachel wäre dieselbe Sache dutzendfach im
+     Quelltext -- und dutzendfach eine Sitzung, die niemand aufräumt. #}
+  {% call modal('vnc-fenster', 'Bildschirm', 'Tastatur und Maus gehen an das Gerät. Die Zwischenablage bleibt getrennt.', 'wide') %}
+    <div class="modal__body stack" data-rolle="behaelter">
+      <div class="row row--tight">
+        <strong data-rolle="titel" class="flex-1"></strong>
+        {{ vnc_tasten() }}
+      </div>
+      {{ vnc_status() }}
+      {{ vnc_zugangsdaten() }}
+      {{ vnc_flaeche() }}
+    </div>
+  {% endcall %}
+{% endif %}
+{% endblock %}
+
+{% block scripts %}
+{% if vnc_fenster %}
+  <script type="module" src="{{ asset_url('js/screen.js') }}" nonce="{{ csp_nonce }}"></script>
+{% endif %}
 {% endblock %}

apps/tesm/src/tesm/templates/tesm/screen.html

@@ -1,5 +1,6 @@
 {% extends "tesm_core/base.html" %}
 {% from "tesm_core/macros.html" import alert, pill %}
+{% from "tesm/_vnc_flaeche.html" import vnc_flaeche, vnc_status, vnc_zugangsdaten, vnc_tasten %}
 
 {% block page_title %}Bildschirm: {{ device.name }}{% endblock %}
 {% block page_sub %}{{ zugang.ziel }}:{{ zugang.port }}{% endblock %}
@@ -13,13 +14,6 @@
 {% endblock %}
 
 {% block content %}
-{# Die Zugangsdaten stehen in einem eigenen JSON-Block statt in einem
-   data-Attribut: ein Attribut steht im Quelltext der Seite zwischen der
-   Beschriftung und wird beim Kopieren einer Zeile mitgenommen. Beides ist
-   derselbe Inhalt -- der Unterschied ist, wie leicht er einem versehentlich
-   unter die Augen kommt. #}
-<script type="application/json" id="screen-credentials-data">{{ vorgaben | tojson }}</script>
-
 <div class="stack">
   {% if zugang.hinderungsgrund %}
     {{ alert(zugang.hinderungsgrund, 'warning') }}
@@ -30,7 +24,8 @@
       <div class="flex-1">
         <div class="card__title">
           {{ icon('monitor', size=17) }} {{ device.name }}
-          {% if zugang.verfahren %}
+          {% if zugang.absage %}{{ pill('Verbindung abgelehnt', 'warning') }}
+          {% elif zugang.verfahren %}
             {% if zugang.browsertauglich %}{{ pill('Browser-Sitzung möglich', 'online') }}
             {% else %}{{ pill('Verfahren nicht unterstützt', 'warning') }}{% endif %}
           {% endif %}
@@ -39,15 +34,29 @@
           Tastatur und Maus gehen an das Gerät, sobald das Bild steht. Die Zwischenablage
           bleibt getrennt.
           {% if zugang.verfahren %}
-            Angebotene Anmeldeverfahren:
+            Zuletzt angebotene Anmeldeverfahren:
             {% for nummer in zugang.verfahren %}{{ verfahren_name(nummer) }}{% if not loop.last %}, {% endif %}{% endfor %}.
+          {% else %}
+            Welche Anmeldeverfahren das Gerät anbietet, ist nicht bekannt – die Seite
+            fragt es nicht von sich aus.
           {% endif %}
         </div>
       </div>
       <div class="row row--tight">
-        <button class="btn btn--sm" type="button" id="screen-cad" hidden
-                title="Strg+Alt+Entf an das Gerät senden">Strg+Alt+Entf</button>
-        <button class="btn btn--sm" type="button" id="screen-disconnect" hidden>Trennen</button>
+        {{ vnc_tasten() }}
+        {# Ausdrücklich ein Knopf und keine Nebenwirkung des Seitenaufbaus: die
+           Prüfung bricht eine Protokollverhandlung ab, und RealVNC zählt das.
+           Wer sucht, drückt ihn; wer nur arbeiten will, merkt nichts davon. #}
+        <form method="post" data-no-guard
+              action="{{ url_for('screen.probe', device_id=device.id) }}">
+          <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+          <button class="btn btn--sm btn--ghost" type="submit"
+                  title="Fragt das Gerät, welche Anmeldeverfahren es anbietet. Das ist
+eine eigene Verbindung, die abgebrochen wird – ein RealVNC Server zählt so etwas mit.
+Nicht unmittelbar vor dem Verbinden drücken.">
+            Verfahren prüfen
+          </button>
+        </form>
         <a class="btn btn--sm btn--ghost"
            href="{{ url_for('devices.vnc_connection', device_id=device.id) }}">
           {{ icon('download', size=14) }} Verbindungsdatei
@@ -55,29 +64,10 @@
       </div>
     </div>
 
-    <div class="card__body stack">
-      <div id="screen-status" class="screen__status">Wird vorbereitet …</div>
-
-      <form id="screen-credentials" class="row row--tight" hidden onsubmit="return false">
-        <label class="field">
-          <span class="field__label">Benutzer</span>
-          <input class="input" type="text" id="screen-username" autocomplete="off"
-                 value="{{ vorgaben.username }}">
-        </label>
-        <label class="field">
-          <span class="field__label">Passwort</span>
-          <input class="input" type="password" id="screen-password" autocomplete="off">
-        </label>
-        <button class="btn btn--primary" type="button" id="screen-send">Anmelden</button>
-      </form>
-
-      <div id="screen" class="screen"
-           data-socket="{{ websocket_path }}"
-           data-ziel="{{ zugang.ziel }}:{{ zugang.port }}"
-           data-blockiert="{{ '1' if zugang.hinderungsgrund else '0' }}"
-           data-grund="{{ zugang.hinderungsgrund }}">
-        <div id="screen-canvas" class="screen__canvas" hidden></div>
-      </div>
+    <div class="card__body stack" id="screen" data-sitzung="{{ quelle }}">
+      {{ vnc_status() }}
+      {{ vnc_zugangsdaten() }}
+      {{ vnc_flaeche() }}
 
       {% if not darf_geheimnis and device.credential_id %}
         <p class="fs-xs faint">

apps/tesm/src/tesm/templates/tesm/settings_system.html

@@ -46,13 +46,6 @@
           {{ checkbox('dashboard_public', 'Statusübersicht ohne Anmeldung erreichbar',
                       checked=values.dashboard_public,
                       hint_text=specs['dashboard_public'].hint) }}
-          {{ checkbox('vnc_enabled', 'Bildschirmzugriff (VNC) anbieten',
-                      checked=values.vnc_enabled,
-                      hint_text=specs['vnc_enabled'].hint) }}
-          <div class="form-grid">
-            {{ field('vnc_port', 'VNC-Port', value=values.vnc_port, type='number',
-                     hint_text=specs['vnc_port'].hint) }}
-          </div>
         </div>
         <div class="card__footer"><button class="btn btn--primary" type="submit">Speichern</button></div>
       </form>
@@ -113,6 +106,39 @@
       </form>
     </section>
 
+    <section class="card">
+      <div class="card__header">
+        <div class="flex-1">
+          <div class="card__title">{{ icon('monitor', size=17) }} Bildschirm (VNC)</div>
+          <div class="card__sub">
+            Dieselben Regeln wie bei der Konsole: eigenes Recht, frische
+            Passwortbestätigung, getrennte Zwischenablage. Der Knopf erscheint nur, wo
+            ein VNC-Server antwortet – das prüft der Überwachungsdurchlauf mit.
+          </div>
+        </div>
+      </div>
+      <form method="post" action="{{ url_for('settings.system_save') }}">
+        <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+        <div class="card__body stack">
+          {{ checkbox('vnc_enabled', 'Bildschirmzugriff (VNC) anbieten',
+                      checked=values.vnc_enabled,
+                      hint_text=specs['vnc_enabled'].hint) }}
+          <div class="form-grid">
+            {{ field('vnc_port', 'VNC-Port', value=values.vnc_port, type='number',
+                     hint_text=specs['vnc_port'].hint) }}
+            {{ field('vnc_idle_timeout', 'Trennen bei Untätigkeit (Sekunden)',
+                     value=values.vnc_idle_timeout, type='number',
+                     hint_text=specs['vnc_idle_timeout'].hint) }}
+          </div>
+          {{ checkbox('vnc_warn_unencrypted_off',
+                      'Warnung des Viewers vor unverschlüsselter Verbindung unterdrücken',
+                      checked=values.vnc_warn_unencrypted_off,
+                      hint_text=specs['vnc_warn_unencrypted_off'].hint) }}
+        </div>
+        <div class="card__footer"><button class="btn btn--primary" type="submit">Speichern</button></div>
+      </form>
+    </section>
+
     <section class="card">
       <div class="card__header">
         <div class="flex-1">

deploy/install.sh

@@ -39,6 +39,7 @@ HTTPS=0
 HTTPS_PORT=""
 DOMAIN=""
 ACME_EMAIL=""
+ERZWINGEN=0
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
@@ -49,6 +50,39 @@ warn()  { printf '%s !!%s %s\n' "$COLOR_WARN" "$COLOR_OFF" "$*"; }
 fail()  { printf '%s !!%s %s\n' "$COLOR_ERR" "$COLOR_OFF" "$*" >&2; exit 1; }
 info()  { printf '    %s\n' "$*"; }
 
+# -- Welche Fassung liegt hier, und welche laeuft schon? ---------------------
+#
+# Ein Installationslauf auf dieselbe Fassung macht nichts besser: er baut die
+# Python-Umgebung neu, kopiert dieselben Dateien, laedt nginx neu und startet
+# den Dienst -- mit der einzigen Wirkung, dass die Anwendung ein paar Sekunden
+# weg ist. Wer "update.sh" in einen Zeitplan haengt, bekaeme das taeglich.
+#
+# Verglichen wird die Anwendung **und** der Kern: die beiden Nummern laufen
+# absichtlich auseinander (siehe pyproject.toml), und eine Auslieferung kann
+# denselben Anwendungsstand mit neuem Kern enthalten.
+
+#: Die Nummer aus einer pyproject.toml. Die erste Zeile "version = ..." gilt --
+#: weitere Vorkommen stehen in Abhaengigkeiten und gehen uns nichts an.
+paket_version() {
+  sed -n 's/^version = "\([^"]*\)"/\1/p' "$1" 2>/dev/null | head -1
+}
+
+#: Was in dieser Installation laeuft: "<anwendung> <kern>", sonst leer.
+laufende_version() {
+  local wurzel="$1" modul="$2"
+  [[ -x "$wurzel/venv/bin/python" ]] || return 0
+  "$wurzel/venv/bin/python" -c \
+    "import $modul, tesm_core; print($modul.__version__, tesm_core.__version__)" \
+    2>/dev/null || true
+}
+
+#: Ist das, was hier liegt, schon installiert? Eine eigene Funktion, weil genau
+#: diese Frage sich pruefen lassen muss -- ohne einen Server aufzusetzen.
+gleiche_version() {
+  local laeuft="$1" liegt="$2"
+  [[ -n "$laeuft" && "$laeuft" == "$liegt" ]]
+}
+
 #: Merker fuer die EXIT-Falle. Zurueckgerollt wird nur, was auch gesichert ist.
 SICHERUNG_STEHT=0
 INSTALL_FERTIG=0
@@ -129,6 +163,7 @@ Verwendung: install.sh --app <tesm|tesm-license> [Optionen]
   --acme-email <a>    Kontaktadresse fuer Let's Encrypt.
   --skip-packages     Keine Systempakete installieren
   --yes               Rueckfragen ueberspringen
+  --force             Auch dann einrichten, wenn dieselbe Fassung schon laeuft
 USAGE
 }
 
@@ -144,6 +179,7 @@ while [[ $# -gt 0 ]]; do
     --acme-email) ACME_EMAIL="${2:?}"; shift 2 ;;
     --skip-packages) SKIP_PACKAGES=1; shift ;;
     --yes|-y) ASSUME_YES=1; shift ;;
+    --force) ERZWINGEN=1; shift ;;
     -h|--help) usage; exit 0 ;;
     *) fail "unbekannte Option: $1" ;;
   esac
@@ -261,6 +297,23 @@ FAILED_DIR="/srv/$NAME-failed-$TIMESTAMP"
 IS_UPDATE=0
 [[ -f "$ROOT/data/app.db" ]] && IS_UPDATE=1
 
+# Laeuft hier schon genau das, was hier liegt? Dann ist Schluss, bevor
+# irgendetwas angefasst wird -- und zwar mit Ausstiegscode 0: es ist nichts
+# schiefgegangen, es war nur nichts zu tun.
+MODUL="tesm"
+[[ "$APP" == "tesm-license" ]] && MODUL="tesm_license"
+LIEGT="$(paket_version "$REPO_DIR/apps/$APP/pyproject.toml") $(
+         paket_version "$REPO_DIR/packages/tesm-core/pyproject.toml")"
+LAEUFT="$(laufende_version "$ROOT" "$MODUL")"
+if [[ $IS_UPDATE -eq 1 && $ERZWINGEN -eq 0 ]] && gleiche_version "$LAEUFT" "$LIEGT"; then
+  step "Nichts zu tun"
+  info "$APP ${LIEGT%% *} (tesm-core ${LIEGT##* }) laeuft hier bereits."
+  info "Ein zweiter Durchlauf wuerde nur die Umgebung neu bauen und den"
+  info "Dienst neu starten -- ohne dass sich etwas aendert."
+  info "Trotzdem neu einrichten: --force"
+  exit 0
+fi
+
 step "TESM-Installation"
 info "Anwendung   : $APP${INSTANCE:+ (Instanz $INSTANCE)}"
 info "Ziel        : $ROOT"
@@ -278,6 +331,7 @@ else
   info "nginx       : Port $HTTP_PORT (nur HTTP)"
 fi
 info "Modus       : $([[ $IS_UPDATE -eq 1 ]] && echo Aktualisierung || echo Neuinstallation)"
+info "Fassung     : ${LIEGT%% *} (tesm-core ${LIEGT##* })${LAEUFT:+, bisher ${LAEUFT%% *}}"
 
 if [[ $ASSUME_YES -eq 0 ]]; then
   read -r -p "Fortfahren? [j/N] " answer

deploy/update.sh

@@ -33,6 +33,8 @@ EXTRA=("$@")
   echo "Verwendung: update.sh <tesm|tesm-license> [tag] [install.sh-Argumente ...]" >&2
   echo "Beispiel  : update.sh tesm latest --instance test" >&2
   echo "Ohne Rueckfrage: --yes anhaengen (ohne Terminal zwingend)." >&2
+  echo "Laeuft die Fassung schon, endet der Aufruf ohne Arbeit; --force setzt" >&2
+  echo "sie trotzdem neu auf." >&2
   exit 2
 }
 
@@ -173,6 +175,32 @@ release_holen() {
 
 release_holen
 
+# Schon installiert? Dann gar nicht erst fragen.
+#
+# Dieselbe Pruefung steht in install.sh und gilt dort endgueltig (sie
+# vergleicht auch den Kern). Hier steht sie noch einmal, weil ein Update, das
+# ohne Wirkung bleibt, gar nicht erst nach einer Bestaetigung fragen soll --
+# und weil "es lief durch" sonst wie eine Aktualisierung aussieht.
+ERZWINGEN=0
+for ((i = 0; i < ${#EXTRA[@]}; i++)); do
+  [[ "${EXTRA[i]}" == "--force" ]] && ERZWINGEN=1
+done
+INSTALLATION="$APP"
+for ((i = 0; i < ${#EXTRA[@]}; i++)); do
+  [[ "${EXTRA[i]}" == "--instance" ]] && INSTALLATION="$APP-${EXTRA[i + 1]:-}"
+done
+MODUL="tesm"
+[[ "$APP" == "tesm-license" ]] && MODUL="tesm_license"
+if [[ $ERZWINGEN -eq 0 && -x "/srv/$INSTALLATION/venv/bin/python" ]]; then
+  LAEUFT="$("/srv/$INSTALLATION/venv/bin/python" -c \
+            "import $MODUL; print($MODUL.__version__)" 2>/dev/null || true)"
+  if [[ -n "$LAEUFT" && "v$LAEUFT" == "$TAG" ]]; then
+    echo "==> $APP $LAEUFT laeuft hier bereits -- nichts zu tun."
+    echo "    Trotzdem neu einrichten: --force"
+    exit 0
+  fi
+fi
+
 # --yes darf auch hier stehen, nicht nur bei install.sh und upgrade.sh. Es
 # bleibt in EXTRA: install.sh bekommt es ohnehin, doppelt schadet nicht.
 OHNE_RUECKFRAGE=0

docs/BETRIEB.md

@@ -120,6 +120,14 @@ sudo bash /srv/tesm/deploy/update.sh tesm
 sudo bash /srv/tesm-license/deploy/update.sh tesm-license
 ```
 
+**Läuft die Fassung schon, passiert nichts.** `update.sh` vergleicht den
+aufgelösten Tag mit dem, was installiert ist, und endet mit `0`, bevor es eine
+Rückfrage stellt; `install.sh` prüft es noch einmal genauer (Anwendung **und**
+Kern) und bricht vor dem ersten Eingriff ab. Ein zweiter Lauf auf dieselbe
+Fassung baut sonst die Python-Umgebung neu, kopiert dieselben Dateien und
+startet den Dienst neu -- ein paar Sekunden Ausfall ohne jede Wirkung. Wer das
+trotzdem will (eine beschädigte Installation etwa), hängt `--force` an.
+
 Alles nach dem Tag geht unverändert an `install.sh` weiter -- das ist der Weg,
 eine **benannte Instanz** zu aktualisieren:
 

packages/tesm-core/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm-core"
-version = "2.8.5"
+version = "2.8.13"
 description = "Gemeinsames Anwendungsgeruest (Auth, RBAC, Navigation, Design-System, Migrationen) fuer TESM und TESM-Lizenzserver"
 requires-python = ">=3.11"
 dependencies = [

packages/tesm-core/src/tesm_core/static/tesm_core/css/components.css

@@ -1295,6 +1295,9 @@
        sprengen; noVNC skaliert das Bild hinein. */
     height: min(72vh, 760px);
   }
+  /* Im Fenster ist weniger Platz -- und das Fenster soll nicht ueber den
+     Bildschirmrand hinauswachsen, nur weil das Geraet hochaufloesend ist. */
+  dialog.modal .screen__canvas { height: min(62vh, 620px); }
   .screen__status {
     font-size: var(--fs-sm);
     color: var(--text-faint);

packages/tesm-core/src/tesm_core/static/tesm_core/js/screen.js

@@ -8,42 +8,265 @@
 // Die Meldungen sind der eigentliche Wert. Eine Sitzung, die schwarz bleibt,
 // laesst offen, ob es an der Berechtigung, am Netz, am Server oder am
 // Passwort liegt -- und wer das nicht sieht, sucht den Fehler in TESM.
+//
+// **Ein Bauteil, zwei Orte.** Dieselbe Sitzung laeuft auf der Bildschirmseite
+// und im Fenster der Statusuebersicht. Sie holt alles, was sie braucht, aus
+// einer JSON-Auskunft des Servers -- damit gibt es keine zweite Fassung, die
+// man beim naechsten Fund vergisst nachzuziehen.
 
 import RFB from "../vendor/novnc/core/rfb.js";
 
-const wurzel = document.getElementById("screen");
-if (wurzel) {
-  starten(wurzel);
-}
+// Drei Eingriffe in private Methoden der mitgelieferten Bibliothek. Bewusst
+// hier und nicht in der Bibliothek selbst: eine neue Fassung von noVNC laesst
+// sich dann austauschen, ohne eine Aenderung nachzupflegen -- faellt eine
+// Methode weg, entfaellt nur die Auskunft, nicht die Sitzung.
+//
+// Zwei davon holen nur Auskunft (_fail, _socketClose). Der dritte greift in
+// die Wahl des Sicherheitsverfahrens ein -- aber erst, **nachdem** eines
+// nachweislich nicht getragen hat, oder weil eines schon einmal getragen hat.
+//
+// Die Vorgeschichte gehoert dazu, damit niemand den Schritt zurueckgeht: hier
+// stand einmal eine Vorauswahl, die ohne hinterlegte Zugangsdaten ein
+// Verfahren ohne Anmeldung erzwang, weil RealVNC RA2ne zuerst nennt. Das war
+// geraten und falsch. Was jetzt hier steht, ist das Gegenteil einer Vermutung:
+// ein Befund aus einer vorherigen Sitzung.
+const istUnterstuetzt = RFB.prototype._isSupportedSecurityType;
 
-function starten(wurzel) {
-  const leinwand = document.getElementById("screen-canvas");
-  const zeile = document.getElementById("screen-status");
-  const abfrage = document.getElementById("screen-credentials");
-  const feldBenutzer = document.getElementById("screen-username");
-  const feldPasswort = document.getElementById("screen-password");
-  const knopfSenden = document.getElementById("screen-send");
-  const knopfTrennen = document.getElementById("screen-disconnect");
-  const knopfStrg = document.getElementById("screen-cad");
+//: Den *Grund* eines Fehlschlags kennt nur ``_fail`` -- das Ereignis
+//: "disconnect" traegt ihn nicht, und der Weg ueber die Protokollausgabe
+//: funktioniert nicht: die Bibliothek bindet ``console.error`` beim Laden,
+//: also bevor eine Seite etwas daran aendern koennte.
+let letzterGrund = "";
+const originalFail = RFB.prototype._fail;
+RFB.prototype._fail = function (details) {
+  letzterGrund = String(details);
+  return originalFail.call(this, details);
+};
 
-  const pfad = wurzel.dataset.socket;
-  const schema = window.location.protocol === "https:" ? "wss:" : "ws:";
-  const adresse = `${schema}//${window.location.host}${pfad}`;
+//: Und der Abschluss der Leitung selbst: der Schliesscode sagt, ob TESM
+//: abgewiesen hat (1008), ob es ein Serverfehler war (1011) -- oder ob die
+//: Verbindung nie zustande kam (1006).
+let letzterCode = 0;
+const originalSocketClose = RFB.prototype._socketClose;
+RFB.prototype._socketClose = function (ereignis) {
+  letzterCode = (ereignis && ereignis.code) || 0;
+  if (ereignis && ereignis.reason) {
+    letzterGrund = letzterGrund || String(ereignis.reason);
+  }
+  return originalSocketClose.call(this, ereignis);
+};
 
-  const vorgabe = JSON.parse(
-    document.getElementById("screen-credentials-data")?.textContent || "{}",
-  );
+//: Hoechstens ein zweiter Anlauf. Jeder Versuch ist eine Verbindung, und ein
+//: RealVNC Server zaehlt abgebrochene Versuche mit -- wer dreimal anklopft,
+//: sperrt sich aus.
+const HOECHSTENS = 2;
 
+//: So lange darf "wird aufgebaut" stehen, bevor die Seite selbst nachsieht.
+//: Kommt die WebSocket-Verbindung gar nicht erst zustande, wartet noVNC ohne
+//: jedes Ereignis, und die Seite stuende stumm bis zum Seitenwechsel.
+const AUFBAU_GRENZE = 12000;
+
+//: Verfahren, die im Browser keinen Schluesseltausch kosten.
+//:
+//: Der Grund steht in der Bibliothek, `core/ra2.js`: fuer RA2ne erzeugt der
+//: **Browser** bei jeder Sitzung ein eigenes 2048-Bit-RSA-Schluesselpaar, in
+//: JavaScript. Die Primzahlsuche dafuer dauert ein bis drei Minuten -- genau
+//: die Zeit, die zwischen Klick und Bild lag. "Ohne Authentifizierung" (1)
+//: kostet davon nichts.
+//:
+//: Deshalb kommt es zuerst, **wenn der Server es anbietet** und wir nicht
+//: ohnehin schon wissen, was hier traegt. Das ist nicht dieselbe Vorauswahl
+//: wie in 2.8.14: die war geraten, diese steht auf einer Messung. Traegt sie
+//: nicht, nimmt der zweite Anlauf die Reihenfolge des Servers -- dann dauert
+//: es eben.
+const OHNE_SCHLUESSELTAUSCH = new Set([1]);
+
+//: RA2ne. Wird es ausgehandelt, ist die Wartezeit erklaerbar und kein Fehler.
+const RA2NE = 6;
+
+//: Tastenkombinationen, die der Arbeitsplatz selbst abfaengt und die deshalb
+//: einen Knopf brauchen. X11-Keysyms.
+const ALT_LINKS = 0xffe9;
+const F4 = 0xffc1;
+
+const schema = window.location.protocol === "https:" ? "wss:" : "ws:";
+
+/**
+ * Baut eine Sitzung in diesem Behaelter auf.
+ *
+ * ``quelle`` ist die Adresse der JSON-Auskunft; alles Weitere steht dort.
+ * Rueckgabe: eine Funktion, die die Sitzung wieder abbaut.
+ */
+export function starteSitzung(wurzel, quelle) {
+  const teil = (rolle) => wurzel.querySelector(`[data-rolle="${rolle}"]`);
+  const leinwand = teil("leinwand");
+  const zeile = teil("status");
+  const abfrage = teil("zugangsdaten");
+  const feldBenutzer = teil("benutzer");
+  const feldPasswort = teil("passwort");
+  const knopfSenden = teil("anmelden");
+  const knopfTrennen = teil("trennen");
+  const knoepfeSitzung = [...wurzel.querySelectorAll("[data-rolle^='taste-']"), knopfTrennen];
+
+  const gescheitert = new Set();
   let rfb = null;
+  let aufbauUhr = 0;
+  let versuche = 0;
+  let stand = false;
+  let daten = null;
+  let letzterZugang = {};
+  let beendet = false;
 
   function melden(text, art = "") {
+    if (!zeile) return;
     zeile.textContent = text;
     zeile.className = `screen__status${art ? " screen__status--" + art : ""}`;
   }
 
+  function sitzungsknoepfe(sichtbar) {
+    knoepfeSitzung.forEach((knopf) => {
+      if (knopf) knopf.hidden = !sichtbar;
+    });
+  }
+
+  function grund() {
+    const teile = [];
+    if (letzterGrund) {
+      teile.push(letzterGrund.replace(/^Failed (when|while) \w+: /, ""));
+    }
+    if (rfb && rfb._rfbAuthScheme > 0) {
+      teile.push(`gewähltes Verfahren: ${rfb._rfbAuthScheme}`);
+    }
+    if (gescheitert.size) {
+      teile.push(`erfolglos: ${[...gescheitert].join(", ")}`);
+    }
+    return teile.join(" · ");
+  }
+
+  // Steht die WebSocket-Strecke zu TESM überhaupt? Zwei sehr verschiedene
+  // Ursachen sehen von aussen gleich aus: der VNC-Server mag nicht, oder die
+  // Verbindung kommt nie zustande, weil ein Proxy zwischen Browser und TESM
+  // "Upgrade" nicht durchreicht. Diese Probe trennt sie.
+  function streckeTesten() {
+    return new Promise((fertig) => {
+      let beantwortet = false;
+      const pruefling = new WebSocket(`${schema}//${window.location.host}/ws/probe`);
+      const schliessen = (ergebnis) => {
+        if (beantwortet) return;
+        beantwortet = true;
+        try {
+          pruefling.close();
+        } catch (fehler) {
+          /* schon zu */
+        }
+        fertig(ergebnis);
+      };
+      pruefling.onmessage = () => schliessen(true);
+      pruefling.onerror = () => schliessen(false);
+      pruefling.onclose = () => schliessen(false);
+      window.setTimeout(() => schliessen(false), 4000);
+    });
+  }
+
+  // Hat das gewählte Verfahren die Verbindung abreissen lassen? Dann ist das
+  // ein Befund und keine Vermutung -- der naechste Anlauf laesst es aus. Nur
+  // solange nie ein Bild stand: bricht eine **laufende** Sitzung ab, liegt es
+  // nicht am Anmeldeverfahren.
+  function naechsterVersuch() {
+    const verfahren = rfb && rfb._rfbAuthScheme > 0 ? rfb._rfbAuthScheme : 0;
+    if (!verfahren || versuche >= HOECHSTENS || gescheitert.has(verfahren)) {
+      return false;
+    }
+    gescheitert.add(verfahren);
+    melden(
+      `Verfahren ${verfahren} hat die Verbindung nicht getragen – nächster Anlauf ` +
+        "mit dem nächsten, das der Server anbietet …",
+      "warnung",
+    );
+    const zugang = letzterZugang;
+    rfb = null;
+    window.setTimeout(() => verbinden(zugang), 400);
+    return true;
+  }
+
+  function verfahrenMelden(gewaehlt) {
+    if (!gewaehlt || gewaehlt === daten.bewaehrt || !daten.meldeweg) return;
+    fetch(daten.meldeweg, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Requested-With": "fetch",
+        "X-CSRF-Token": document.body?.dataset.csrf || "",
+      },
+      body: JSON.stringify({ verfahren: gewaehlt }),
+    }).catch(() => {
+      /* Eine Merkhilfe, kein Teil der Sitzung. */
+    });
+  }
+
   function verbinden(zugang) {
-    melden("Verbindung wird aufgebaut …");
-    rfb = new RFB(leinwand, adresse, {
+    if (beendet) return;
+    melden(versuche ? "Nächster Versuch …" : "Verbindung wird aufgebaut …");
+    letzterGrund = "";
+    letzterCode = 0;
+    letzterZugang = zugang;
+    versuche += 1;
+    window.clearTimeout(aufbauUhr);
+    aufbauUhr = window.setTimeout(() => {
+      // Ein ausgehandeltes RA2ne ist kein Fehler, sondern Rechenzeit: der
+      // Browser erzeugt dafuer gerade einen 2048-Bit-Schluessel. Das zu
+      // melden ist das Gegenteil einer Warnung -- es nimmt die Sorge.
+      if (rfb && rfb._rfbAuthScheme === RA2NE) {
+        melden(
+          "Der Server verlangt RA2ne (RSA-AES). Dafür erzeugt der Browser ein " +
+            "2048-Bit-Schlüsselpaar – das dauert ein bis drei Minuten. Bitte warten.",
+          "warnung",
+        );
+        return;
+      }
+      melden("Es kommt keine Antwort. Wird geprüft, woran es liegt …", "warnung");
+      streckeTesten().then((steht) => {
+        melden(
+          steht
+            ? "Die WebSocket-Strecke zu TESM steht, aber die Sitzung kommt nicht " +
+                "zustande. Antwortet der VNC-Server auf dem Gerät noch? Ein Neustart " +
+                "des VNC-Dienstes räumt eine Sperre ab."
+            : "Die WebSocket-Verbindung zu TESM kommt nicht zustande – auch eine " +
+                "einfache Probe scheitert. Ein Proxy zwischen Browser und TESM muss " +
+                "die Kopfzeilen Upgrade und Connection durchreichen (nginx: " +
+                "location /ws/ mit proxy_set_header Upgrade $http_upgrade).",
+          "fehler",
+        );
+      });
+    }, AUFBAU_GRENZE);
+
+    // Drei Regeln, alle aus Messung und keine aus Vermutung:
+    //
+    // 1. Was schon einmal getragen hat, kommt zuerst.
+    // 2. Sonst das Verfahren ohne Schluesseltausch -- aber nur, wenn der
+    //    Server es nachweislich anbietet (sonst faende noVNC gar keines und
+    //    scheiterte sofort). RA2ne kostet sonst ein bis drei Minuten
+    //    Rechenzeit im Browser, jedes Mal.
+    // 3. Was abgerissen ist, wird nicht noch einmal gewaehlt.
+    //
+    // Beides gilt nur fuer den **ersten** Anlauf; danach zaehlt die
+    // Reihenfolge des Servers, abzueglich dessen, was schon abgerissen ist.
+    const bewaehrt = daten.bewaehrt || 0;
+    const angeboten = daten.verfahren || [];
+    const schnell = angeboten.filter((typ) => OHNE_SCHLUESSELTAUSCH.has(typ));
+    let bevorzugt = 0;
+    if (versuche === 1) {
+      if (bewaehrt > 0 && !gescheitert.has(bewaehrt)) bevorzugt = bewaehrt;
+      else if (schnell.length && !gescheitert.has(schnell[0])) bevorzugt = schnell[0];
+    }
+    RFB.prototype._isSupportedSecurityType = function (typ) {
+      if (gescheitert.has(typ)) return false;
+      if (bevorzugt) return typ === bevorzugt;
+      return istUnterstuetzt.call(this, typ);
+    };
+
+    rfb = new RFB(leinwand, `${schema}//${window.location.host}${daten.socket}`, {
       credentials: zugang,
       // Eine Bildschirmsitzung soll nicht nebenbei die Zwischenablage des
       // Arbeitsplatzes mit dem Geraet teilen -- das ist eine eigene
@@ -55,80 +278,177 @@ function starten(wurzel) {
     rfb.focusOnClick = true;
 
     rfb.addEventListener("connect", () => {
-      melden(`Verbunden mit ${wurzel.dataset.ziel}`, "ok");
-      abfrage.hidden = true;
+      window.clearTimeout(aufbauUhr);
+      stand = true;
+      verfahrenMelden(rfb && rfb._rfbAuthScheme > 0 ? rfb._rfbAuthScheme : 0);
+      melden(`Verbunden mit ${daten.ziel}`, "ok");
+      if (abfrage) abfrage.hidden = true;
       leinwand.hidden = false;
-      knopfTrennen.hidden = false;
-      knopfStrg.hidden = false;
+      sitzungsknoepfe(true);
     });
 
     rfb.addEventListener("disconnect", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       leinwand.hidden = true;
-      knopfTrennen.hidden = true;
-      knopfStrg.hidden = true;
+      sitzungsknoepfe(false);
       if (ereignis.detail && ereignis.detail.clean) {
-        melden("Sitzung beendet.");
+        // Beim sauberen Schluss steht der Grund im Schliessrahmen -- etwa,
+        // dass TESM wegen Untätigkeit getrennt hat.
+        melden(letzterGrund ? `Sitzung beendet – ${letzterGrund}` : "Sitzung beendet.");
+      } else if (!stand && naechsterVersuch()) {
+        return;
       } else {
+        const erklaerung = grund();
         melden(
-          "Verbindung abgebrochen. Antwortet der VNC-Server noch, und lässt der " +
-            "Arbeitsplatz die Verbindung zu?",
+          erklaerung
+            ? `Verbindung abgebrochen – ${erklaerung}`
+            : "Verbindung abgebrochen. Wird geprüft, woran es liegt …",
           "fehler",
         );
+        if (letzterCode === 1006 || !erklaerung) {
+          streckeTesten().then((steht) => {
+            melden(
+              steht
+                ? `${erklaerung || "Verbindung abgebrochen"} – die WebSocket-Strecke zu ` +
+                    "TESM selbst steht (Probe erfolgreich), der Abbruch kommt also von " +
+                    "der VNC-Seite."
+                : "Die WebSocket-Verbindung zu TESM kommt nicht zustande – auch eine " +
+                    "einfache Probe scheitert. Ein Proxy zwischen Browser und TESM muss " +
+                    "die Kopfzeilen Upgrade und Connection durchreichen (nginx: " +
+                    "location /ws/ mit proxy_set_header Upgrade $http_upgrade). Dasselbe " +
+                    "gilt für die Browser-Konsole.",
+              "fehler",
+            );
+          });
+        }
       }
       rfb = null;
     });
 
     rfb.addEventListener("credentialsrequired", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       const gefragt = ereignis.detail.types || ["password"];
-      abfrage.hidden = false;
-      feldBenutzer.closest("label").hidden = !gefragt.includes("username");
+      if (abfrage) abfrage.hidden = false;
+      if (feldBenutzer) feldBenutzer.closest("label").hidden = !gefragt.includes("username");
       melden("Der VNC-Server verlangt Zugangsdaten.", "warnung");
-      (gefragt.includes("username") ? feldBenutzer : feldPasswort).focus();
+      (gefragt.includes("username") ? feldBenutzer : feldPasswort)?.focus();
     });
 
     rfb.addEventListener("securityfailure", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       melden(
         `Anmeldung abgelehnt: ${ereignis.detail.reason || "kein Grund genannt"}`,
         "fehler",
       );
-      abfrage.hidden = false;
-    });
-
-    rfb.addEventListener("desktopname", (ereignis) => {
-      wurzel.dataset.desktop = ereignis.detail.name;
+      if (abfrage) abfrage.hidden = false;
     });
   }
 
   knopfSenden?.addEventListener("click", () => {
     const zugang = {};
-    if (feldBenutzer.value) zugang.username = feldBenutzer.value;
-    if (feldPasswort.value) zugang.password = feldPasswort.value;
-    if (rfb) {
-      rfb.sendCredentials(zugang);
-    } else {
-      verbinden(zugang);
-    }
+    if (feldBenutzer?.value) zugang.username = feldBenutzer.value;
+    if (feldPasswort?.value) zugang.password = feldPasswort.value;
+    if (rfb) rfb.sendCredentials(zugang);
+    else verbinden(zugang);
   });
 
   [feldBenutzer, feldPasswort].forEach((feld) =>
     feld?.addEventListener("keydown", (ereignis) => {
       if (ereignis.key === "Enter") {
         ereignis.preventDefault();
-        knopfSenden.click();
+        knopfSenden?.click();
       }
     }),
   );
 
   knopfTrennen?.addEventListener("click", () => rfb && rfb.disconnect());
-  knopfStrg?.addEventListener("click", () => rfb && rfb.sendCtrlAltDel());
+  teil("taste-cad")?.addEventListener("click", () => rfb && rfb.sendCtrlAltDel());
+  // Alt+F4 kennt noVNC nicht als fertigen Griff: der Arbeitsplatz faengt die
+  // Kombination selbst ab, bevor sie in der Leinwand ankommt. Also einzeln --
+  // Alt halten, F4 tippen, Alt loslassen -- wie es auf der Tastatur auch
+  // geschieht.
+  teil("taste-altf4")?.addEventListener("click", () => {
+    if (!rfb) return;
+    rfb.sendKey(ALT_LINKS, "AltLeft", true);
+    rfb.sendKey(F4, "F4", true);
+    rfb.sendKey(F4, "F4", false);
+    rfb.sendKey(ALT_LINKS, "AltLeft", false);
+  });
 
-  if (wurzel.dataset.blockiert === "1") {
-    melden(wurzel.dataset.grund || "Diese Sitzung kann nicht aufgebaut werden.", "fehler");
-    return;
-  }
+  sitzungsknoepfe(false);
+  melden("Wird vorbereitet …");
 
-  const zugang = {};
-  if (vorgabe.username) zugang.username = vorgabe.username;
-  if (vorgabe.password) zugang.password = vorgabe.password;
-  verbinden(zugang);
+  fetch(quelle, { credentials: "same-origin", headers: { "X-Requested-With": "fetch" } })
+    .then((antwort) => antwort.json().then((inhalt) => ({ status: antwort.status, inhalt })))
+    .then(({ status, inhalt }) => {
+      if (beendet) return;
+      if (status === 409 && inhalt.reauth) {
+        melden(
+          "Für den Bildschirm ist eine frische Passwortbestätigung nötig – bitte über " +
+            "die Geräteseite öffnen.",
+          "warnung",
+        );
+        return;
+      }
+      if (status !== 200) {
+        melden(inhalt.fehler || "Diese Sitzung lässt sich nicht öffnen.", "fehler");
+        return;
+      }
+      daten = inhalt;
+      if (daten.hinderungsgrund) {
+        melden(daten.hinderungsgrund, "fehler");
+        return;
+      }
+      const zugang = {};
+      if (daten.vorgaben?.username) zugang.username = daten.vorgaben.username;
+      if (daten.vorgaben?.password) zugang.password = daten.vorgaben.password;
+      verbinden(zugang);
+    })
+    .catch(() => melden("Die Sitzungsdaten sind nicht abrufbar.", "fehler"));
+
+  return function beenden() {
+    beendet = true;
+    window.clearTimeout(aufbauUhr);
+    try {
+      rfb?.disconnect();
+    } catch (fehler) {
+      /* schon zu */
+    }
+    rfb = null;
+  };
+}
+
+// -- Die beiden Orte -------------------------------------------------------- #
+
+// 1. Die Bildschirmseite: ein Behaelter, der seine Quelle selbst mitbringt.
+const seite = document.getElementById("screen");
+if (seite?.dataset.sitzung) {
+  starteSitzung(seite, seite.dataset.sitzung);
+}
+
+// 2. Die Statusuebersicht: ein Fenster, das jede Kachel oeffnen kann. Ein
+//    Dialog fuer alle -- er bekommt beim Oeffnen, welches Geraet gemeint ist.
+const fenster = document.getElementById("vnc-fenster");
+if (fenster) {
+  let beenden = null;
+  const behaelter = fenster.querySelector("[data-rolle='behaelter']");
+  const titel = fenster.querySelector("[data-rolle='titel']");
+
+  document.addEventListener("click", (ereignis) => {
+    const knopf = ereignis.target.closest("[data-vnc-oeffnen]");
+    if (!knopf) return;
+    ereignis.preventDefault();
+    beenden?.();
+    titel.textContent = knopf.dataset.vncName || "Bildschirm";
+    if (typeof fenster.showModal === "function") fenster.showModal();
+    else fenster.setAttribute("open", "");
+    beenden = starteSitzung(behaelter, knopf.dataset.vncOeffnen);
+  });
+
+  // Zu heisst zu: eine Sitzung, die im Hintergrund weiterlaeuft, haelt die
+  // Verbindung zum Geraet und bei RealVNC den einen Sitzungsplatz.
+  fenster.addEventListener("close", () => {
+    beenden?.();
+    beenden = null;
+  });
 }

packages/tesm-core/src/tesm_core/static/tesm_core/vendor/novnc/HERKUNFT.md

@@ -20,6 +20,27 @@ der einen Bildschirm fernsteuert.
 Datei -- mit Grund und Fundstelle, damit ein Wechsel auf eine neuere Fassung
 nicht stillschweigend darueberlaeuft.
 
+**Was TESM von aussen umbiegt** (also *nicht* in diesen Dateien steht, sondern
+in `js/screen.js`):
+
+* `RFB.prototype._fail` und `_socketClose` -- nur, um den Grund eines
+  Abbruchs zu erfahren. noVNC meldet ihn sonst ausschliesslich in die
+  Entwicklerkonsole, und `console.error` mitzulesen traegt nicht: die
+  Bibliothek bindet es beim Laden.
+* `RFB.prototype._isSupportedSecurityType` -- **erst nachdem** ein Verfahren
+  die Verbindung nachweislich hat abreissen lassen. Dann wird es fuer den
+  zweiten Anlauf ausgelassen, damit noVNC nicht wieder dasselbe zuerst findet.
+  Hoechstens zwei Anlaeufe, denn jeder ist eine Verbindung, und ein RealVNC
+  Server zaehlt abgebrochene mit.
+
+  Hier stand einmal das Gegenteil: eine **Vorauswahl**, die ohne hinterlegte
+  Zugangsdaten ein Verfahren ohne Anmeldung erzwang. Das war geraten und hat
+  eine laufende Sitzung gebrochen. Der Unterschied ist nicht der Code, sondern
+  der Anlass: eine Vermutung vorher gegen einen Befund hinterher.
+
+Faellt eine dieser Methoden in einer neueren Fassung weg, entfaellt nur die
+Auskunft bzw. der zweite Anlauf -- die Sitzung laeuft wie ohne sie.
+
 **Was noVNC an Sicherheitsverfahren spricht** (`core/rfb.js`,
 `_isSupportedSecurityType`): `1` None, `2` VNC-Passwort, `6` RA2ne (RSA-AES
 ohne Streckenverschluesselung), `16` Tight, `19` VeNCrypt, `22` xvp, `30` ARD,