Handschlag: --managed hebelt die Lizenzpruefung nicht mehr aus (#535)

Mit E-M3 wanderte die Lizenzpruefung in den Manager: Eine gefuehrte Instanz prueft
nicht mehr selbst, weil der Manager es zentral getan hat. Woran sie "gefuehrt"
erkannte, war der Schalter --managed - und ein Schalter ist keine Erkennung.
ClawdDotNet --managed startete damit eine Instanz ganz ohne Lizenzpruefung. Vor
E-M3 gab es die Luecke nicht; sie ist mit der Zentralisierung entstanden.

ManagerHandshake unterschreibt Instanzverzeichnis und Ablauf mit HMAC-SHA256. An
die Signierstelle kommt der Manager nur, wenn seine Lizenzpruefung bestanden hat -
StartInstanceAsync weist vorher mit StartRefusal.NoLicense ab. Dass die
Unterschrift existiert, ist der Beweis.

- Gebunden an das Verzeichnis, und geprueft wird gegen das tatsaechliche, nicht
  gegen das behauptete: Sonst unterschriebe man das Argument statt der Sache.
- Fuenf Minuten gueltig, der Ablauf geht in die Unterschrift ein.
- Ueber die Umgebung statt ueber die Befehlszeile: Eine Befehlszeile steht in
  jeder Prozessliste.
- Ungueltig heisst "nicht gefuehrt", nicht Abbruch. Dann prueft die Instanz ihre
  Lizenz selbst - der Weg von vor E-M3, also kein neuer Fehlerfall.

AppHost.IsManaged ist jetzt der gepruefte Befund. CanSwitchInstance und der
Wechseldialog haengen daran statt am Schalter.

Die Grenze steht ausdruecklich im Konzept (9.9): Der Schluessel liegt in jeder
ausgelieferten Programmdatei. Es geht um den gewoehnlichen Weg an der Lizenz
vorbei, nicht um jemanden mit Werkzeugen und Willen.

Abgenommen an echten Prozessen, Unterschrift fuer den Positivfall unabhaengig in
Python gerechnet: ohne Unterschrift "Lizenz erforderlich"; mit gueltiger kommt die
Instanz hoch; Unterschrift fuer ein fremdes Verzeichnis und hochgedrehter Ablauf
scheitern beide.

820 Tests gruen, 0 Warnungen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

src/ClawdDotNet.App/AppHost.cs

@@ -116,6 +116,17 @@ public sealed class AppHost : IAsyncDisposable
     /// </summary>
     public LicenseGate? License { get; private set; }
 
+    /// <summary>
+    /// Ob diese Instanz nachweislich vom Instanzmanager geführt wird (#535).
+    ///
+    /// <para><b>Der geprüfte Befund, nicht der Schalter.</b> <c>--managed</c> ist eine
+    /// Behauptung, die jeder aufstellen kann; hier steht das Ergebnis der Prüfung von
+    /// <see cref="ManagerHandshake"/>. Wer daran eine Entscheidung hängt — ob die Instanz
+    /// sich selbst wechseln darf, ob die Lizenz zentral geprüft wurde —, fragt diesen
+    /// Wert und nicht die Befehlszeile.</para>
+    /// </summary>
+    public bool IsManaged { get; private set; }
+
     /// <summary>
     /// Die laufende Nachprüfung. Der Aufrufer hängt sich an
     /// <see cref="LicenseWatch.Revoked"/> und beendet die Anwendung, wenn es feuert.
@@ -196,7 +207,15 @@ public sealed class AppHost : IAsyncDisposable
         /// <summary>Wie der Lizenz-Torwächter mit dem Benutzer spricht. Null im geführten Modus.</summary>
         public ILicensePrompt? License { get; init; }
 
-        /// <summary>Wahr, wenn die Instanz durch den Instanzmanager gestartet und geführt wird.</summary>
+        /// <summary>
+        /// Die Behauptung, vom Instanzmanager geführt zu werden — der Schalter
+        /// <c>--managed</c>.
+        ///
+        /// <para><b>Eine Behauptung, kein Befund.</b> Ob sie stimmt, entscheidet allein
+        /// die Unterschrift des Managers (<see cref="ManagerHandshake"/>); dieser Schalter
+        /// sagt nur, dass überhaupt jemand den Anspruch erhebt. Ohne gültige Unterschrift
+        /// prüft die Instanz ihre Lizenz selbst.</para>
+        /// </summary>
         public bool IsManaged { get; init; }
 
         /// <summary>
@@ -289,8 +308,28 @@ public sealed class AppHost : IAsyncDisposable
         }
 
         // ─── 4. Lizenz ───
+        //
+        // Gefuehrt ist, wer es nachweisen kann (#535). Der Schalter --managed allein
+        // genuegte frueher und war damit der Weg an der Lizenz vorbei: Die Instanz
+        // uebersprang die Pruefung, weil sie glaubte, der Manager habe sie schon
+        // erledigt. Jetzt zaehlt die Unterschrift, und zwar gegen das Verzeichnis, in
+        // dem diese Instanz tatsaechlich laeuft.
+        var gefuehrt = callbacks.IsManaged
+            && ManagerHandshake.Verify(
+                instancePath, Environment.GetEnvironmentVariable(
+                    ManagerHandshake.EnvironmentVariable));
+
+        if (callbacks.IsManaged && !gefuehrt)
+        {
+            // Kein Abbruch: Ohne Nachweis ist die Instanz eben nicht gefuehrt und prueft
+            // selbst - der Weg von vor E-M3. Wer eine Lizenz hat, merkt davon nichts.
+            logger.LogWarning(
+                "Start mit --managed, aber ohne gültige Unterschrift des Instanzmanagers. "
+                + "Die Instanz gilt als eigenständig und prüft ihre Lizenz selbst.");
+        }
+
         LicenseGate? license = null;
-        if (!callbacks.IsManaged)
+        if (!gefuehrt)
         {
             var prompt = callbacks.License ?? new NonInteractiveLicensePrompt(Console.Error.WriteLine);
             license = new LicenseGate(
@@ -308,7 +347,9 @@ public sealed class AppHost : IAsyncDisposable
         }
         else
         {
-            logger.LogInformation("Instanz wird vom Manager geführt (--managed): Lizenzprüfung erfolgt zentral im Manager.");
+            logger.LogInformation(
+                "Instanz wird vom Instanzmanager geführt (Unterschrift geprüft): "
+                + "Die Lizenzprüfung ist dort schon erfolgt.");
         }
 
         // ─── 5. Werkzeuge ───
@@ -334,6 +375,7 @@ public sealed class AppHost : IAsyncDisposable
 
         // Nichts freizugeben: Der Torwächter nutzt den gemeinsamen HttpClient des SDK.
         host.License = license;
+        host.IsManaged = gefuehrt;
 
         if (license is not null && license.IsEnforcementConfigured)
         {

src/ClawdDotNet.Core/Instances/ManagerHandshake.cs

@@ -0,0 +1,120 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace ClawdDotNet.Core.Instances;
+
+/// <summary>
+/// Der Nachweis, dass ein lizenzierter Instanzmanager diese Instanz gestartet hat (#535).
+///
+/// <para><b>Das Loch, das hier zugeht.</b> Mit E-M3 wanderte die Lizenzprüfung in den
+/// Manager: Eine geführte Instanz prüft nicht mehr selbst, weil der Manager es zentral
+/// getan hat. Woran sie „geführt" erkannte, war der Schalter <c>--managed</c> — und ein
+/// Schalter ist keine Erkennung. <c>ClawdDotNet --managed</c> startete damit eine Instanz
+/// ganz ohne Lizenzprüfung. Vor E-M3 gab es die Lücke nicht, weil jede Instanz selbst
+/// geprüft hat.</para>
+///
+/// <para><b>Wie es jetzt läuft.</b> Der Manager kommt an diese Stelle nur, wenn seine
+/// Lizenzprüfung bestanden hat (<c>ManagerCore.StartInstanceAsync</c> weist vorher mit
+/// <c>StartRefusal.NoLicense</c> ab). Er unterschreibt dort das Instanzverzeichnis und
+/// einen Ablaufzeitpunkt; die Instanz rechnet dieselbe Unterschrift nach. Stimmt sie
+/// nicht, gilt die Instanz als <b>nicht geführt</b> und prüft die Lizenz selbst — der
+/// Zustand von vor E-M3 also, und damit kein neuer Fehlerfall, sondern der alte Weg.</para>
+///
+/// <para><b>Was das aushält und was nicht.</b> Der Schlüssel steht in dieser Datei und
+/// liegt damit in jeder ausgelieferten Programmdatei; wer ihn sucht, findet ihn. Das ist
+/// bewusst so: Es geht nicht darum, jemanden abzuwehren, der Werkzeuge und Willen
+/// mitbringt, sondern darum, dass der gewöhnliche Weg um die Lizenz herum verschlossen
+/// ist. Ein Schalter, den man in der Hilfe liest, ist etwas anderes als ein HMAC, den man
+/// nachbauen muss.</para>
+///
+/// <para><b>Und deshalb über die Umgebung, nicht über die Befehlszeile.</b> Eine
+/// Befehlszeile steht in jeder Prozessliste — die Unterschrift wäre für jeden abzulesen
+/// und abzuschreiben. Die Umgebung eines fremden Prozesses ist das nicht. Bindung an das
+/// Verzeichnis und die kurze Gültigkeit halten den Schaden auch dann klein, wenn doch
+/// jemand mitliest.</para>
+/// </summary>
+public static class ManagerHandshake
+{
+    /// <summary>Über diese Umgebungsvariable gibt der Manager die Unterschrift weiter.</summary>
+    public const string EnvironmentVariable = "CLAWD_MANAGER_TOKEN";
+
+    /// <summary>
+    /// Der gemeinsame Schlüssel. Siehe die Einordnung oben: Er ist auffindbar, und das
+    /// ist Teil der Abwägung, keine Nachlässigkeit.
+    /// </summary>
+    private static readonly byte[] Secret =
+        Encoding.UTF8.GetBytes("clawd-instanzmanager-handschlag-2026-09-v1");
+
+    /// <summary>
+    /// Wie lange eine Unterschrift gilt.
+    ///
+    /// <para>Fünf Minuten: Die Instanz prüft sie beim Start, und zwischen
+    /// <c>Process.Start</c> und dem Erreichen dieser Prüfung liegen Sekunden. Großzügig
+    /// genug für eine langsame Maschine und zu kurz, um sie aufzuheben.</para>
+    /// </summary>
+    public static TimeSpan Lifetime { get; } = TimeSpan.FromMinutes(5);
+
+    /// <summary>
+    /// Unterschreibt den Start dieser Instanz. Nur der Manager ruft das auf — und nur,
+    /// nachdem seine Lizenzprüfung bestanden hat.
+    /// </summary>
+    public static string Sign(string instanceDirectory, DateTimeOffset? now = null)
+    {
+        var ablauf = (now ?? DateTimeOffset.UtcNow) + Lifetime;
+        return Sign(instanceDirectory, ablauf.ToUnixTimeSeconds());
+    }
+
+    /// <summary>
+    /// Prüft die Unterschrift gegen das Verzeichnis, in dem diese Instanz tatsächlich
+    /// läuft.
+    ///
+    /// <para><b>Gegen das tatsächliche Verzeichnis, nicht gegen das behauptete.</b> Sonst
+    /// unterschriebe man das Argument statt der Sache: Eine Unterschrift für Instanz A
+    /// ließe eine Instanz B starten, indem man beim Prüfen A vorzeigt.</para>
+    /// </summary>
+    public static bool Verify(string instanceDirectory, string? token, DateTimeOffset? now = null)
+    {
+        if (string.IsNullOrWhiteSpace(token)) return false;
+
+        var teile = token.Split('.');
+        if (teile.Length != 3 || teile[0] != "v1") return false;
+
+        if (!long.TryParse(teile[1], out var ablauf)) return false;
+
+        if (DateTimeOffset.FromUnixTimeSeconds(ablauf) < (now ?? DateTimeOffset.UtcNow))
+            return false;
+
+        var erwartet = Sign(instanceDirectory, ablauf);
+
+        // Zeitkonstant, weil es nichts kostet. Ein Vergleich, der beim ersten
+        // abweichenden Zeichen aussteigt, verraet dem Geduldigen die Unterschrift
+        // Zeichen fuer Zeichen.
+        return CryptographicOperations.FixedTimeEquals(
+            Encoding.UTF8.GetBytes(erwartet), Encoding.UTF8.GetBytes(token));
+    }
+
+    private static string Sign(string instanceDirectory, long expiresUnix)
+    {
+        var nachricht = $"clawd-manager-v1|{Canonical(instanceDirectory)}|{expiresUnix}";
+
+        var signatur = HMACSHA256.HashData(Secret, Encoding.UTF8.GetBytes(nachricht));
+
+        return $"v1.{expiresUnix}.{Convert.ToHexStringLower(signatur)}";
+    }
+
+    /// <summary>
+    /// Derselbe Pfad muss beiderseits dieselbe Zeichenkette ergeben — sonst scheitert der
+    /// Handschlag daran, dass einer <c>C:\Instanzen\Alpha\</c> und der andere
+    /// <c>c:\instanzen\alpha</c> geschrieben hat. Gleiche Regel wie in
+    /// <see cref="InstanceEndpoint"/>.
+    /// </summary>
+    private static string Canonical(string instanceDirectory)
+    {
+        var voll = Path.GetFullPath(instanceDirectory).TrimEnd(
+            Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+
+        return OperatingSystem.IsWindows() || OperatingSystem.IsMacOS()
+            ? voll.ToLowerInvariant()
+            : voll;
+    }
+}

src/ClawdDotNet.Desktop/App.axaml.cs

@@ -145,8 +145,11 @@ public partial class App : Application
 
         var mainViewModel = new MainWindowViewModel(_host)
         {
-            // Wer beaufsichtigt wird, wechselt nicht selbst - siehe _managed.
-            CanSwitchInstance = !_managed
+            // Wer beaufsichtigt wird, wechselt nicht selbst. Der geprüfte Befund des
+            // Aufbaus, nicht der Schalter der Befehlszeile (#535): Wer --managed ohne
+            // gueltige Unterschrift setzt, ist eine eigenstaendige Instanz und darf
+            // wechseln wie jede andere.
+            CanSwitchInstance = !_host.IsManaged
         };
 
         // Der Wechsel gehoert hierher und nicht ins Fenster: Er braucht den Aufbau und
@@ -414,7 +417,7 @@ public partial class App : Application
     {
         if (_host is null) return;
 
-        if (_managed)
+        if (_host.IsManaged)
         {
             await new AvaloniaLicensePrompt().ShowInfoAsync(
                 "ClawdDotNet – Instanzwechsel",
@@ -843,6 +846,11 @@ public partial class App : Application
         if (preselected is not null && Directory.Exists(preselected))
             return preselected;
 
+        // Hier steht bewusst der Schalter und nicht der geprüfte Befund: Diese Methode
+        // läuft mitten im Aufbau, bevor es einen AppHost gibt, der geprüft haben könnte.
+        // Sie entscheidet auch nur, ob ein Dialog erscheint — wer --managed ohne gültige
+        // Unterschrift setzt, bekommt ihn nicht und wird gleich darauf trotzdem nach
+        // seiner Lizenz gefragt (#535).
         if (!_managed)
         {
             var choice = await AskStartModeAsync();

src/ClawdDotNet.Manager/InstanceLauncher.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using ClawdDotNet.Core.Instances;
 
 namespace ClawdDotNet.Manager;
 
@@ -92,6 +93,14 @@ public sealed class ProcessInstanceLauncher(string executablePath, bool headless
         start.ArgumentList.Add("--instance");
         start.ArgumentList.Add(Path.GetFullPath(instanceDirectory));
 
+        // Der Nachweis, dass hier ein lizenzierter Manager startet (#535). Ueber die
+        // Umgebung und nicht als Argument: Eine Befehlszeile steht in jeder Prozessliste.
+        //
+        // Dass diese Zeile ueberhaupt erreicht wird, ist der Beweis - ManagerCore weist
+        // vorher mit StartRefusal.NoLicense ab, wenn die Lizenz nicht traegt.
+        start.Environment[ManagerHandshake.EnvironmentVariable] =
+            ManagerHandshake.Sign(instanceDirectory);
+
         var process = Process.Start(start)
             ?? throw new InvalidOperationException(
                 $"Der Instanzprozess ließ sich nicht starten: {ExecutablePath}");