using System.Collections.ObjectModel; using Titano.App.Infrastructure; using Titano.Core.Diagnostics; using Titano.Core.Localization; using Titano.Protocol; using Titano.Ui.Mvvm; namespace Titano.App.Server; /// /// The client's server connection (BRIEF §12.7): drives with the dialogs (fingerprint /// confirmation before any password is sent, login form), keeps the session token encrypted with DPAPI in the /// settings, restores it at start, and lists servers announced on the LAN. Runs on the UI thread. /// public sealed class ServerSession : ObservableObject, ITrustStore, IDisposable { private readonly AppSettings _settings; private readonly Action _save; private readonly ITokenProtector _protector; private readonly ConnectFlow _flow; private DiscoveryListener? _discovery; private bool _busy; public ServerSession(AppSettings settings, Action save, IServerApiFactory factory, ITokenProtector protector) { _settings = settings; _save = save; _protector = protector; _flow = new ConnectFlow(factory, this); _flow.Changed += (_, _) => OnAllPropertiesChanged(); } public ConnectFlow Flow => _flow; /// Servers that announced themselves on this network. public ObservableCollection Discovered { get; } = []; public bool IsConnected => _flow.Step == ConnectStep.Connected; /// A connection attempt is running. public bool IsBusy { get => _busy; private set => Set(ref _busy, value); } /// Server name for the status strip; null when not connected. public string? ServerName => IsConnected ? _flow.Info?.Name : null; /// The saved address (last server used). public string? SavedAddress => _settings.ServerUrl; /// The token of the saved session is present (Disconnect keeps it). public bool HasSavedSession => _settings.ServerUrl is not null && _settings.ProtectedToken is not null; // ---------------- ITrustStore ---------------- public IReadOnlyCollection Fingerprints => [.. _settings.TrustedCertificates.Select(c => c.Fingerprint)]; public void Trust(string server, string fingerprint) { if (_settings.TrustedCertificates.Any(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase))) return; _settings.TrustedCertificates.Add(new TrustedCertificate { Fingerprint = fingerprint, Server = server, TrustedAt = DateTimeOffset.UtcNow }); _save(); Log.Info("server", $"Trusted certificate {fingerprint} of {server}"); } /// The trust record of a fingerprint, if the user trusted it. public TrustedCertificate? TrustOf(string? fingerprint) => fingerprint is null ? null : _settings.TrustedCertificates.FirstOrDefault(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase)); /// Forgets a trusted certificate; the next connection asks again. public void Forget(string fingerprint) { if (_settings.TrustedCertificates.RemoveAll(c => c.Fingerprint.Equals(fingerprint, StringComparison.OrdinalIgnoreCase)) == 0) return; _save(); OnAllPropertiesChanged(); } /// /// Forgets a trusted certificate once the user confirmed it (Server screen and Settings › Server alike); the session /// that relies on it is closed first. True when it was forgotten. /// public bool ConfirmForget(string fingerprint, IAppDialogs dialogs) { if (!dialogs.Confirm(ForgetRequest(fingerprint))) return false; if (IsConnected && string.Equals(TrustOf(_flow.Info?.TlsFingerprint)?.Fingerprint, fingerprint, StringComparison.OrdinalIgnoreCase)) Disconnect(); Forget(fingerprint); return true; } // ---------------- Session ---------------- /// Resumes the saved session at start; stays signed out quietly when it cannot be reused. public async Task RestoreAsync(CancellationToken ct = default) { if (_settings.ServerUrl is not { } address || _settings.ProtectedToken is not { } blob) return; var token = _protector.Unprotect(blob); if (token is null) { Log.Warning("server", "The saved session cannot be decrypted; sign in again"); ForgetToken(); return; } IsBusy = true; try { var step = await _flow.RestoreAsync(address, token, ct); if (step == ConnectStep.Connected) Log.Info("server", $"Session restored on {address}"); else if (_flow.Error is ConnectError.SessionExpired or ConnectError.CertificateChanged) ForgetToken(); } finally { IsBusy = false; } } /// /// Connects to : identifies the server, asks to trust an unknown self-signed /// certificate, then reuses the saved session or shows the login form. True when connected. /// public async Task ConnectAsync(string address, IAppDialogs dialogs, CancellationToken ct = default) { IsBusy = true; try { var step = await _flow.ProbeAsync(address, ct); if (step == ConnectStep.AwaitingTrust && _flow.PendingFingerprint is { } fingerprint) { var trusted = dialogs.Confirm(TrustRequest(ServerAddress.Display(_flow.Address!), fingerprint)); step = await _flow.ConfirmTrustAsync(trusted, ct); } if (step != ConnectStep.AwaitingCredentials) return false; var display = ServerAddress.Display(_flow.Address!); if (HasSavedSession && ServerAddress.Display(_settings.ServerUrl) == display && _protector.Unprotect(_settings.ProtectedToken!) is { } token) { step = await _flow.RestoreAsync(display, token, ct); if (step == ConnectStep.Connected) { Remember(); return true; } if (step != ConnectStep.AwaitingCredentials) return false; } var signedIn = dialogs.SignIn(display, _settings.ServerUsername, async (user, password) => { var result = await _flow.SignInAsync(user, password, ct); return result == ConnectStep.Connected ? null : ErrorText(_flow.Error); }); if (signedIn && IsConnected) { Remember(); return true; } if (!IsConnected && _flow.Step == ConnectStep.AwaitingCredentials) _flow.Disconnect(); return false; } finally { IsBusy = false; } } /// Signs out on the server and removes the token from this PC. public async Task SignOutAsync() { await _flow.SignOutAsync(); ForgetToken(); } /// Closes the connection and works locally; the saved session is kept for the next Connect. public void Disconnect() => _flow.Disconnect(); public void StartDiscovery() { if (_discovery is not null) return; _discovery = new DiscoveryListener(); _discovery.Found += server => { if (Discovered.Any(d => d.Address.Equals(server.Address, StringComparison.OrdinalIgnoreCase))) return; Discovered.Add(server); }; _discovery.Start(); } public void Dispose() { _discovery?.Dispose(); _discovery = null; _flow.Dispose(); } /// One sentence for a failed step (BRIEF §0.2 rule 6). public static string ErrorText(ConnectError error) => Loc.L("Server.Error." + error); /// The trust-on-first-use question with the fingerprint split over two lines. public static ConfirmRequest TrustRequest(string server, string fingerprint) => new() { Heading = Loc.L("Server.Trust.Title"), Message = Loc.L("Server.Trust.Message", server), Detail = FormatFingerprint(fingerprint), DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"), SafeText = Loc.L("Server.Trust.Cancel"), SafeToolTip = Loc.L("Tooltips.Server.DontTrust"), ActionText = Loc.L("Server.Trust.Accept"), ActionToolTip = Loc.L("Tooltips.Server.Trust"), }; /// The destructive question before a trusted certificate is forgotten, with its fingerprint. public static ConfirmRequest ForgetRequest(string fingerprint) => new() { Heading = Loc.L("Server.Certificate.Title"), Message = Loc.L("Server.Certificate.Message"), Detail = FormatFingerprint(fingerprint), DetailToolTip = Loc.L("Tooltips.Server.Fingerprint"), SafeText = Loc.L("Server.Certificate.Keep"), SafeToolTip = Loc.L("Tooltips.Server.KeepTrust"), ActionText = Loc.L("Server.Certificate.Forget"), ActionToolTip = Loc.L("Tooltips.Server.ForgetTrust"), IsDestructive = true, }; /// Splits the 32-byte SHA-256 fingerprint into two lines of 16 bytes, each kept left to right. public static string FormatFingerprint(string fingerprint) { var bytes = fingerprint.Split(':'); return bytes.Length <= 16 ? Formatting.LeftToRight(fingerprint) : Formatting.LeftToRight(string.Join(':', bytes.Take(16))) + "\n" + Formatting.LeftToRight(string.Join(':', bytes.Skip(16))); } /// "9A:3C:71:E0:…" for the status line. public static string ShortFingerprint(string fingerprint) { var bytes = fingerprint.Split(':'); return bytes.Length <= 4 ? fingerprint : string.Join(':', bytes.Take(4)) + ":…"; } /// The account of the session (role, quota) for the Server screen. public UserDto? User => IsConnected ? _flow.User : null; private void Remember() { if (_flow.Address is null || _flow.Token is null) return; var display = ServerAddress.Display(_flow.Address); _settings.ServerUrl = display; _settings.ServerUsername = _flow.User?.Username ?? _settings.ServerUsername; _settings.ProtectedToken = _protector.Protect(_flow.Token); _settings.RecentServers.RemoveAll(s => s.Equals(display, StringComparison.OrdinalIgnoreCase)); _settings.RecentServers.Insert(0, display); if (_settings.RecentServers.Count > 8) _settings.RecentServers.RemoveRange(8, _settings.RecentServers.Count - 8); _save(); Log.Info("server", $"Signed in to {display} as {_settings.ServerUsername}"); OnAllPropertiesChanged(); } private void ForgetToken() { if (_settings.ProtectedToken is null) return; _settings.ProtectedToken = null; _save(); OnAllPropertiesChanged(); } }