feat(uploader): server session with trust-on-first-use sign-in and LAN discovery

Checks the certificate before sending the password and returns an
unknown self-signed fingerprint for confirmation; restores the saved
token, reports quota, probes every 30 s while offline, signs out when
the token is rejected or the certificate changes, and maps transport
failures for the engine. UDP beacon listener for servers on the LAN.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
This commit is contained in:
Claude committed 2026-10-02 10:27:36 +00:00
1 parent ad5c3e0f37
commit 42d96c962d
4 files changed
+585

No files matched your search

@@ -0,0 +1,79 @@
using System.Net;
using System.Net.Sockets;
using Titano.Core.Diagnostics;
using Titano.Protocol;
namespace Titano.Uploader.Server;
/// <summary>A Titano Server announced on the LAN.</summary>
public sealed record DiscoveredServer(string Name, string Address)
{
public override string ToString() => Name + " · " + Address;
}
/// <summary>
/// Listens for the server's UDP beacon (<see cref="DiscoveryBeacon.Port"/>) while the connect form is open and reports
/// each server once. Beacons are unauthenticated: they only fill the address field, never trust a certificate.
/// </summary>
public sealed class DiscoveryListener : IDisposable
{
private readonly HashSet<string> _seen = new(StringComparer.OrdinalIgnoreCase);
private CancellationTokenSource? _cts;
/// <summary>Raised on the thread that called <see cref="Start"/>.</summary>
public event Action<DiscoveredServer>? Found;
public void Start()
{
if (_cts is not null) return;
_cts = new CancellationTokenSource();
var context = SynchronizationContext.Current;
_ = Task.Run(() => ListenAsync(context, _cts.Token));
}
public void Stop()
{
_cts?.Cancel();
_cts?.Dispose();
_cts = null;
}
public void Dispose() => Stop();
/// <summary>The address the client should use for <paramref name="beacon"/> sent from <paramref name="sender"/>.</summary>
public static string AddressOf(DiscoveryBeacon beacon, IPAddress sender)
{
var host = sender.AddressFamily == AddressFamily.InterNetworkV6 ? "[" + sender + "]" : sender.ToString();
return beacon.HttpsPort > 0 ? $"https://{host}:{beacon.HttpsPort}" : $"http://{host}:{beacon.HttpPort}";
}
private async Task ListenAsync(SynchronizationContext? context, CancellationToken ct)
{
try
{
using var udp = new UdpClient();
// The desktop client may listen on the same port.
udp.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
udp.Client.Bind(new IPEndPoint(IPAddress.Any, DiscoveryBeacon.Port));
while (!ct.IsCancellationRequested)
{
var datagram = await udp.ReceiveAsync(ct).ConfigureAwait(false);
if (DiscoveryBeacon.TryParse(datagram.Buffer) is not { } beacon) continue;
var server = new DiscoveredServer(beacon.Name, AddressOf(beacon, datagram.RemoteEndPoint.Address));
lock (_seen)
{
if (!_seen.Add(server.Address)) continue;
}
if (context is null) Found?.Invoke(server);
else context.Post(_ => Found?.Invoke(server), null);
}
}
catch (OperationCanceledException)
{
}
catch (SocketException ex)
{
Log.Info("discovery", "LAN discovery unavailable: " + ex.Message);
}
}
}
@@ -0,0 +1,21 @@
namespace Titano.Uploader.Server;
/// <summary>Server addresses as typed in the sign-in form.</summary>
public static class ServerAddress
{
/// <summary>
/// Accepts "nas.local:8443" (https assumed) or a full http(s) URL; the result is the API base, ending with "/".
/// </summary>
public static bool TryParse(string? text, out Uri uri)
{
uri = null!;
if (string.IsNullOrWhiteSpace(text)) return false;
var trimmed = text.Trim();
if (!trimmed.Contains("://", StringComparison.Ordinal)) trimmed = "https://" + trimmed;
if (!Uri.TryCreate(trimmed, UriKind.Absolute, out var parsed) || parsed.Scheme is not ("https" or "http") || parsed.Host.Length == 0) return false;
var builder = new UriBuilder(parsed) { Query = string.Empty, Fragment = string.Empty };
if (!builder.Path.EndsWith('/')) builder.Path += "/";
uri = builder.Uri;
return true;
}
}
+460
View File
@@ -0,0 +1,460 @@
using System.ComponentModel;
using System.Net;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Text.Json;
using Titano.Core.Diagnostics;
using Titano.Protocol;
using Titano.Protocol.Client;
using Titano.Uploader.Infrastructure;
using Titano.Uploader.Uploads;
namespace Titano.Uploader.Server;
/// <summary>Connection shown in the header.</summary>
public enum ConnectionState
{
/// <summary>First run: no server chosen yet.</summary>
NotConfigured,
SigningIn,
Connected,
/// <summary>Signed in, but the server cannot be reached; probed every 30 s.</summary>
Offline,
/// <summary>A server is known but there is no valid token.</summary>
SignedOut,
}
/// <summary>Outcome of the sign-in form.</summary>
public enum SignInResult
{
Success,
InvalidAddress,
Unreachable,
NotTitano,
/// <summary>The certificate is self-signed and unknown: ask the user to trust its fingerprint.</summary>
Untrusted,
BadCredentials,
Failed,
}
/// <summary>The server connection as the window sees it.</summary>
public interface IServerSession : INotifyPropertyChanged
{
ConnectionState State { get; }
/// <summary>Server address as the user typed or discovered it.</summary>
string? Address { get; }
string? Username { get; }
/// <summary>Quota in bytes; 0 = unlimited.</summary>
long QuotaBytes { get; }
long UsedBytes { get; }
/// <summary>Upload limit in MB/s; 0 = unlimited.</summary>
int BandwidthLimit { get; set; }
/// <summary>Raised when the server ended the session (token rejected or certificate changed).</summary>
event EventHandler<ServerProblem>? SessionEnded;
/// <summary>Signs in; <see cref="SignInResult.Untrusted"/> comes with the fingerprint to show.</summary>
Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct);
/// <summary>Remembers a certificate fingerprint the user confirmed (trust on first use).</summary>
void Trust(string fingerprint);
Task SignOutAsync();
/// <summary>Refreshes the account (quota) when connected.</summary>
Task RefreshAsync();
Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct);
}
/// <summary>
/// Owns the <see cref="TitanoClient"/>: sign-in with trust-on-first-use, token restore from DPAPI, offline probing,
/// and the upload transport. Runs on the UI thread.
/// </summary>
public sealed class ServerSession : IServerSession, IUploadTransport, IDisposable
{
private static readonly TimeSpan ProbeInterval = TimeSpan.FromSeconds(30);
private readonly UploaderSettings _settings;
private readonly Action _saveSettings;
private TitanoClient? _client;
private ConnectionState _state;
private string? _username;
private long _quotaBytes;
private long _usedBytes;
private int _bandwidthLimit;
private CancellationTokenSource? _probe;
public ServerSession(UploaderSettings settings, Action saveSettings)
{
_settings = settings;
_saveSettings = saveSettings;
_username = settings.Username;
_bandwidthLimit = Math.Max(0, settings.BandwidthLimit);
_state = settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
}
public event PropertyChangedEventHandler? PropertyChanged;
public event EventHandler? ReadyChanged;
public event EventHandler<ServerProblem>? SessionEnded;
public ConnectionState State
{
get => _state;
private set
{
if (_state == value) return;
var wasReady = IsReady;
_state = value;
OnPropertyChanged();
if (wasReady != IsReady) ReadyChanged?.Invoke(this, EventArgs.Empty);
}
}
public bool IsReady => _state == ConnectionState.Connected && _client is not null;
public string? Address => _settings.ServerUrl;
public string? Username
{
get => _username;
private set => Set(ref _username, value);
}
public long QuotaBytes
{
get => _quotaBytes;
private set => Set(ref _quotaBytes, value);
}
public long UsedBytes
{
get => _usedBytes;
private set => Set(ref _usedBytes, value);
}
public int BandwidthLimit
{
get => _bandwidthLimit;
set
{
if (!Set(ref _bandwidthLimit, Math.Max(0, value))) return;
ApplyBandwidth();
}
}
/// <summary>Restores the saved session, if any, in the background.</summary>
public void Start()
{
if (_settings.ServerUrl is null || _settings.ProtectedToken is null) return;
var token = TokenProtector.Unprotect(_settings.ProtectedToken);
if (token is null || !ServerAddress.TryParse(_settings.ServerUrl, out var uri))
{
Log.Warning("session", "Saved token cannot be used; sign in again");
State = ConnectionState.SignedOut;
return;
}
UseClient(CreateClient(uri));
_client!.Token = token;
State = ConnectionState.SigningIn;
_ = RefreshAsync();
}
public async Task<(SignInResult Result, string? Fingerprint)> SignInAsync(string address, string username, string password, CancellationToken ct)
{
if (!ServerAddress.TryParse(address, out var uri)) return (SignInResult.InvalidAddress, null);
StopProbing();
var previous = State;
State = ConnectionState.SigningIn;
var client = CreateClient(uri);
try
{
await client.GetInfoAsync(ct);
var login = await client.LoginAsync(username, password, ct);
if (login.Token is null) throw new TitanoApiException(HttpStatusCode.Unauthorized, new ApiError("no_token", "No token issued"));
_settings.ServerUrl = uri.ToString();
_settings.Username = login.User.Username;
_settings.ProtectedToken = TokenProtector.Protect(login.Token);
_saveSettings();
UseClient(client);
OnPropertyChanged(nameof(Address));
Username = login.User.Username;
SetQuota(login.User);
State = ConnectionState.Connected;
Log.Info("session", $"Signed in to {uri} as {login.User.Username}");
return (SignInResult.Success, null);
}
catch (Exception ex)
{
client.Dispose();
State = previous == ConnectionState.SigningIn ? ConnectionState.NotConfigured : previous;
var result = Classify(ex, ct);
if (result == SignInResult.Failed) Log.Warning("session", $"Sign-in to {uri} failed", ex);
return (result, (ex as UntrustedCertificateException)?.Fingerprint);
}
}
public void Trust(string fingerprint)
{
if (_settings.TrustedFingerprints.Contains(fingerprint, StringComparer.OrdinalIgnoreCase)) return;
_settings.TrustedFingerprints.Add(fingerprint);
_saveSettings();
Log.Info("session", $"Trusted certificate {fingerprint}");
}
public async Task SignOutAsync()
{
StopProbing();
if (_client is { Token: not null } client)
{
try
{
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
await client.LogoutAsync(timeout.Token);
}
catch (Exception ex) when (ex is HttpRequestException or TitanoApiException or OperationCanceledException or UntrustedCertificateException)
{
// The token is forgotten locally either way.
Log.Info("session", "Logout not confirmed by the server: " + ex.Message);
}
}
ForgetToken();
}
public async Task RefreshAsync()
{
if (_client is not { } client) return;
try
{
var me = await client.MeAsync();
Username = me.Username;
SetQuota(me);
State = ConnectionState.Connected;
StopProbing();
}
catch (Exception ex) when (IsServerProblem(ex, CancellationToken.None, out var problem))
{
OnServerProblem(problem, ex);
}
catch (TitanoApiException ex)
{
Log.Warning("session", "Account refresh failed", ex);
}
}
public async Task<IReadOnlyList<SequenceDto>> ListSequencesAsync(CancellationToken ct)
{
if (!IsReady) return [];
var all = new List<SequenceDto>();
string? cursor = null;
try
{
// Five pages of 200 cover any realistic choice list.
for (var page = 0; page < 5; page++)
{
var result = await _client!.ListSequencesAsync(cursor: cursor, ct: ct);
all.AddRange(result.Items);
cursor = result.NextCursor;
if (cursor is null) break;
}
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
}
catch (TitanoApiException ex)
{
Log.Warning("session", "Sequence list unavailable", ex);
}
return all;
}
// ---------------- IUploadTransport ----------------
public async Task<(UploadOutcome Outcome, Guid? FrameId)> UploadAsync(UploadItem item, Guid? sequenceId, string sha256, IProgress<UploadProgress> progress, CancellationToken ct)
{
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
try
{
var result = await client.UploadFileAsync(item.Path, sequenceId, item.CapturedAt, item.SessionKey, sha256, progress, ct);
// The client reports an existing file as index −1 (or no frame at all).
return result is null || result.Index < 0 ? (UploadOutcome.AlreadyOnServer, result?.FrameId) : (UploadOutcome.Verified, result.FrameId);
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
throw new ServerUnavailableException(problem, ex);
}
}
public async Task<Guid> CreateSequenceAsync(string? title, CancellationToken ct)
{
var client = _client ?? throw new ServerUnavailableException(ServerProblem.SignedOut);
try
{
var created = await client.CreateSequenceAsync(new CreateSequenceRequest(string.IsNullOrWhiteSpace(title) ? null : title.Trim(), null), ct);
Log.Info("session", $"Created sequence {created.Id} \"{created.DisplayTitle}\"");
return created.Id;
}
catch (Exception ex) when (IsServerProblem(ex, ct, out var problem))
{
OnServerProblem(problem, ex);
throw new ServerUnavailableException(problem, ex);
}
}
public void Dispose()
{
StopProbing();
_client?.Dispose();
}
// ---------------- Plumbing ----------------
private TitanoClient CreateClient(Uri uri)
{
// A fresh pinning per client: the protocol's last-rejected fingerprint must not outlive a trust decision.
var client = new TitanoClient(uri, new CertificatePinning(_settings.TrustedFingerprints), $"Titano Uploader ({Environment.MachineName})");
client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
return client;
}
private void UseClient(TitanoClient client)
{
if (ReferenceEquals(_client, client)) return;
_client?.Dispose();
_client = client;
}
private void ApplyBandwidth()
{
if (_client is not null) _client.Bandwidth.BytesPerSecond = _bandwidthLimit * 1_000_000L;
}
private void SetQuota(UserDto user)
{
QuotaBytes = user.QuotaBytes;
UsedBytes = user.UsedBytes;
}
private void ForgetToken()
{
if (_client is not null) _client.Token = null;
_settings.ProtectedToken = null;
_saveSettings();
QuotaBytes = 0;
UsedBytes = 0;
State = _settings.ServerUrl is null ? ConnectionState.NotConfigured : ConnectionState.SignedOut;
}
private bool IsServerProblem(Exception ex, CancellationToken ct, out ServerProblem problem)
{
problem = ServerProblem.Unreachable;
switch (ex)
{
case TitanoApiException { Status: HttpStatusCode.Unauthorized }:
problem = ServerProblem.SignedOut;
return true;
case TitanoApiException api:
return api.IsTransient;
case UntrustedCertificateException untrusted:
// The pinning remembers its last rejection; once trusted, a later network error can still carry it.
if (!_settings.TrustedFingerprints.Contains(untrusted.Fingerprint, StringComparer.OrdinalIgnoreCase))
problem = ServerProblem.CertificateChanged;
return true;
case HttpRequestException:
return true;
case OperationCanceledException when !ct.IsCancellationRequested:
return true; // request timeout
default:
return false;
}
}
private void OnServerProblem(ServerProblem problem, Exception ex)
{
switch (problem)
{
case ServerProblem.SignedOut:
Log.Warning("session", "The server rejected the token; signing out");
StopProbing();
ForgetToken();
SessionEnded?.Invoke(this, problem);
break;
case ServerProblem.CertificateChanged:
// Never upload to a server whose certificate changed: the user must sign in and confirm it again.
Log.Warning("session", "The server certificate changed; sign in again to review it", ex);
StopProbing();
ForgetToken();
SessionEnded?.Invoke(this, problem);
break;
default:
if (State != ConnectionState.Offline) Log.Warning("session", "Server unreachable; retrying every 30 s", ex);
State = ConnectionState.Offline;
StartProbing();
break;
}
}
private void StartProbing()
{
if (_probe is not null) return;
_probe = new CancellationTokenSource();
_ = ProbeAsync(_probe.Token);
}
private void StopProbing()
{
_probe?.Cancel();
_probe?.Dispose();
_probe = null;
}
private async Task ProbeAsync(CancellationToken ct)
{
try
{
while (!ct.IsCancellationRequested && State == ConnectionState.Offline)
{
await Task.Delay(ProbeInterval, ct);
await RefreshAsync();
}
}
catch (OperationCanceledException)
{
}
}
private static SignInResult Classify(Exception ex, CancellationToken ct) => ex switch
{
UntrustedCertificateException => SignInResult.Untrusted,
TitanoApiException { Status: HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden } => SignInResult.BadCredentials,
TitanoApiException { Status: HttpStatusCode.NotFound } => SignInResult.NotTitano,
TitanoApiException api when api.IsTransient => SignInResult.Unreachable,
JsonException or NotSupportedException => SignInResult.NotTitano,
HttpRequestException => SignInResult.Unreachable,
OperationCanceledException when !ct.IsCancellationRequested => SignInResult.Unreachable,
_ => SignInResult.Failed,
};
private bool Set<T>(ref T field, T value, [CallerMemberName] string? name = null)
{
if (EqualityComparer<T>.Default.Equals(field, value)) return false;
field = value;
OnPropertyChanged(name);
return true;
}
private void OnPropertyChanged([CallerMemberName] string? name = null) => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
}
@@ -0,0 +1,25 @@
using Titano.Testing;
using Titano.Uploader.Server;
namespace Titano.App.Tests.Uploader;
public sealed class ServerAddressTests
{
[Theory]
[Case("nas.local:8443", "https://nas.local:8443/")]
[Case("https://nas.local:8443", "https://nas.local:8443/")]
[Case(" http://192.168.1.20:8080/titano ", "http://192.168.1.20:8080/titano/")]
[Case("https://nas.local/?x=1#y", "https://nas.local/")]
public void ServerAddressesBecomeApiBases(string typed, string expected)
{
Assert.True(ServerAddress.TryParse(typed, out var uri));
Assert.Equal(expected, uri.ToString());
}
[Theory]
[Case("")]
[Case(" ")]
[Case("ftp://nas.local")]
[Case("https://")]
public void InvalidServerAddressesAreRejected(string typed) => Assert.False(ServerAddress.TryParse(typed, out _));
}