fix(setup): Dateirechte bei Geheimnissen, plattformabhaengige Zielnamen

Zwei Beobachtungen aus der laufenden Integration.

1. Der Installer schrieb Geheimnisse weltlesbar
   SetupWriter benutzte File.WriteAllText ohne Rechteanpassung - unter Linux
   also die Standardmaske und damit ueblicherweise 644. In genau dieser Datei
   stehen Lizenzschluessel und Anwendungstoken; jeder Benutzer des Systems
   konnte sie lesen. Der Lizenz-Cache in StateStore wird aus demselben Grund
   seit jeher auf 600 gesetzt - der Installer zog nicht nach.
   Enthaelt ein Ziel mindestens einen geheimen Wert, wird die Datei jetzt auf
   den eigenen Benutzer beschraenkt. Als geheim gilt type=secret UND
   source=provision: ein so geholtes Token traegt oft den Typ "string", ist
   aber genauso schutzbeduerftig. Unter Windows bleibt es beim Profil-ACL.

2. Zielnamen koennen plattformabhaengig unterschiedlich sein
   %APPDATA%\MeineAnwendung gegen $XDG_CONFIG_HOME/meineanwendung - eine
   setup.json kannte nur eine Schreibweise. Die kleingeschriebene Form allein
   traegt, weil NTFS die Schreibweise ignoriert, aber nur solange das
   Dateisystem tatsaechlich unempfindlich ist; auf APFS mit Beachtung der
   Schreibweise oder bei groesseren Unterschieden entstuende ein zweites,
   leeres Verzeichnis neben dem, aus dem die Anwendung liest.
   Ziele haben deshalb optional fileWindows, fileLinux und fileMacOS; ohne
   Angabe gilt weiterhin file.

Die Dokumentation haelt ausserdem fest, dass der Installer bewusst Klartext
schreibt und die Anwendung selbst entscheidet, ob und wie sie ihn danach
schuetzt - und dass eine Entschluesselung, die Klartext durchreicht, deshalb
kein Altlast-Zweig mehr ist, sondern ein aktiv genutzter Pfad.

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

client-dotnet/Deploymentcenter.Client/SetupWriter.cs

@@ -12,11 +12,14 @@ namespace Deploymentcenter.Client
     /// <summary>Ein zu schreibender Konfigurationswert.</summary>
     public sealed class SetupValue
     {
-        public SetupValue(string key, string value, string type = "string")
+        private readonly bool? _isSecret;
+
+        public SetupValue(string key, string value, string type = "string", bool? isSecret = null)
         {
             Key = key;
             Value = value;
             Type = type;
+            _isSecret = isSecret;
         }
 
         /// <summary>Schluessel, Ebenen durch Doppelpunkt getrennt.</summary>
@@ -26,6 +29,15 @@ namespace Deploymentcenter.Client
 
         /// <summary>string | secret | url | int | bool | enum</summary>
         public string Type { get; }
+
+        /// <summary>
+        /// Ist der Wert schutzbeduerftig? Ohne ausdrueckliche Angabe wird der
+        /// Typ herangezogen. Ein per <c>source: "provision"</c> geholtes Token
+        /// traegt haeufig den Typ "string" und muss deshalb gesondert
+        /// gekennzeichnet werden.
+        /// </summary>
+        public bool IsSecret =>
+            _isSecret ?? string.Equals(Type, "secret", StringComparison.OrdinalIgnoreCase);
     }
 
     /// <summary>
@@ -137,13 +149,68 @@ namespace Deploymentcenter.Client
         /// <summary>Schreibt in das Format, das zum Ziel passt.</summary>
         public static void Write(string path, string format, IEnumerable<SetupValue> values)
         {
+            var list = values as IList<SetupValue> ?? new List<SetupValue>(values);
+
             if (string.Equals(format, "env", StringComparison.OrdinalIgnoreCase))
             {
-                WriteEnv(path, values);
-                return;
+                WriteEnv(path, list);
+            }
+            else
+            {
+                WriteJson(path, list);
             }
 
-            WriteJson(path, values);
+            // Enthaelt die Datei Geheimnisse, gehoert sie niemandem sonst.
+            foreach (var value in list)
+            {
+                if (value.IsSecret)
+                {
+                    RestrictPermissions(path);
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Beschraenkt die Datei auf den eigenen Benutzer.
+        ///
+        /// Ohne das schreibt .NET mit der Standardmaske - unter Linux
+        /// ueblicherweise 644, also weltlesbar. In dieser Datei stehen der
+        /// Lizenzschluessel und das Token der Anwendung; jeder Benutzer des
+        /// Systems koennte sie lesen. Der Lizenz-Cache in
+        /// <see cref="StateStore"/> wird aus demselben Grund auf 600 gesetzt.
+        ///
+        /// Unter Windows erben Dateien in %APPDATA% die Zugriffsrechte des
+        /// Profils; dort ist nichts zu tun.
+        /// </summary>
+        public static void RestrictPermissions(string path)
+        {
+            if (OperatingSystemHelpers.IsWindows())
+                return;
+
+#if NET8_0_OR_GREATER
+            try
+            {
+                File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite);
+            }
+            catch
+            {
+                // Auf Dateisystemen ohne Unix-Rechte schlicht nicht anwendbar.
+            }
+#else
+            try
+            {
+                var proc = System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = "chmod",
+                    Arguments = $"600 \"{path}\"",
+                    UseShellExecute = false,
+                    CreateNoWindow = true
+                });
+                proc?.WaitForExit();
+            }
+            catch { }
+#endif
         }
 
         /// <summary>