Files
Chronos/src/Titano.Server/Hosting/ServerHost.cs
T
Claude df2d4b4316 fix(server): refuse planted Windows data, guard new archives, trust only loopback proxies
- Windows data folder: the folder and everything in it must belong to SYSTEM,
  Administrators or the server's account and hold no link, checked before the
  ACL is rewritten; otherwise the server stops and names the entry. server.json
  is read only after its owner is checked on the open handle. Secrets are
  deleted and created anew with the private ACL, so a planted file's owner
  loses its rights.
- Windows archive: a folder the server creates is changeable only by those
  accounts (users may read it) and a .titano folder it creates is private; an
  existing archive others can change is logged as a warning at start.
- Proxy mode: only loopback is trusted by default, since LAN clients reach the
  HTTP port from private addresses; a cookie sign-in that did not come through
  a trusted proxy over HTTPS answers proxy_untrusted, naming
  TITANO_TRUSTED_PROXIES.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-12 11:08:12 +00:00

187 lines
10 KiB
C#

using Microsoft.AspNetCore.HttpOverrides;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using Titano.Core.Diagnostics;
using Titano.Data;
using Titano.Data.Archiving;
using Titano.Protocol;
using Titano.Server.Api;
using Titano.Server.Configuration;
using Titano.Server.Events;
using Titano.Server.Jobs;
using Titano.Server.Security;
using Titano.Server.Storage;
namespace Titano.Server.Hosting;
/// <summary>
/// Builds the Titano Server web application from <see cref="ServerOptions"/> (used by Program, the Windows service
/// host and tests). The archive module plugs in through the <c>configureServices</c> callback of <see cref="Build"/>,
/// which runs before the server's own registrations: it must register <see cref="IArchiveIngest"/> and
/// <see cref="IFrameAssetLocator"/> (the server refuses to start without them), may add
/// <see cref="Titano.Data.Jobs.IJobHandler"/>s, and may resolve <see cref="TitanoDatabase"/>, <see cref="ServerArchive"/>
/// and <see cref="ServerOptions"/> from DI in its factories.
/// </summary>
public static class ServerHost
{
/// <summary>Request bodies other than upload chunks stay small (BRIEF §14.2 limits).</summary>
public const long JsonBodyLimit = 1024 * 1024;
public static WebApplication Build(ServerOptions options, string[] args, Action<IServiceCollection>? configureServices = null)
{
// Before anything is written there: the folder holds the database, the TLS key and the first admin password.
DataFolderAccess.Restrict(options.DataPath);
Directory.CreateDirectory(options.LogPath);
Directory.CreateDirectory(options.UploadsPath);
var archiveOpenToOthers = DataFolderAccess.PrepareArchive(options.ArchivePath);
var builder = WebApplication.CreateSlimBuilder(new WebApplicationOptions { Args = args, ContentRootPath = AppContext.BaseDirectory });
builder.Logging.ClearProviders();
builder.Logging.SetMinimumLevel(options.LogLevel);
builder.Logging.AddSimpleConsole(c => c.SingleLine = true);
builder.Logging.AddProvider(new FileLoggerProvider(new FileLogSink(options.LogPath, "server")));
builder.Logging.AddFilter("Microsoft.AspNetCore", Microsoft.Extensions.Logging.LogLevel.Warning);
builder.Logging.AddFilter("Microsoft.Hosting.Lifetime", options.LogLevel > Microsoft.Extensions.Logging.LogLevel.Information ? options.LogLevel : Microsoft.Extensions.Logging.LogLevel.Information);
// The archive module registers first, so a missing piece stops the server before it touches the database.
configureServices?.Invoke(builder.Services);
RequireArchiveModule(builder.Services);
using var bootLoggerFactory = LoggerFactory.Create(l => l.AddSimpleConsole(c => c.SingleLine = true).SetMinimumLevel(options.LogLevel));
var bootLogger = bootLoggerFactory.CreateLogger("Titano.Server");
var certificate = CertificateStore.Load(options, bootLogger);
var database = ServerDatabase.OpenAsync(options, bootLogger, CancellationToken.None).GetAwaiter().GetResult();
try
{
var archive = ServerArchive.OpenAsync(database, options, CancellationToken.None).GetAwaiter().GetResult();
AdminBootstrap.RunAsync(database, options, TimeProvider.System, bootLogger, CancellationToken.None).GetAwaiter().GetResult();
var state = new ServerState
{
TlsFingerprint = certificate is null ? null : CertificateStore.Fingerprint(certificate),
Database = ServerDatabase.DescribeAsync(database, CancellationToken.None).GetAwaiter().GetResult(),
};
builder.WebHost.ConfigureKestrel(k =>
{
k.AddServerHeader = false;
k.Limits.MaxRequestBodySize = JsonBodyLimit;
k.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);
k.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);
k.ListenAnyIP(options.HttpPort);
if (certificate is not null) k.ListenAnyIP(options.HttpsPort, l =>
{
l.Protocols = HttpProtocols.Http1AndHttp2;
l.UseHttps(certificate);
});
});
ConfigureServices(builder.Services, options, state, database, archive);
var app = builder.Build();
Log.SetSink(new LoggerSink(app.Services.GetRequiredService<ILoggerFactory>()));
ConfigurePipeline(app, options);
app.Logger.LogInformation("Titano Server {Version} · archive {Archive} · data {Data} · {Database} · TLS {Tls}{Fingerprint}",
SystemEndpoints.Version, options.ArchivePath, options.DataPath, state.Database, options.TlsMode,
state.TlsFingerprint is null ? string.Empty : " · SHA-256 " + state.TlsFingerprint);
if (archiveOpenToOthers)
{
app.Logger.LogWarning("Accounts other than SYSTEM, Administrators and the one Titano Server runs as can change the archive {Archive}: "
+ "they could put a link in place of a folder and redirect the files the server moves. Let only those accounts change it (others may read it).",
options.ArchivePath);
}
app.Lifetime.ApplicationStopping.Register(() => app.Logger.LogInformation("Titano Server stopping"));
app.Lifetime.ApplicationStopped.Register(() => database.DisposeAsync().AsTask().GetAwaiter().GetResult());
return app;
}
catch
{
database.DisposeAsync().AsTask().GetAwaiter().GetResult();
throw;
}
}
/// <summary>The single composition root of the server's services.</summary>
public static void ConfigureServices(IServiceCollection services, ServerOptions options, ServerState state, TitanoDatabase database, ServerArchive archive)
{
services.AddSingleton(options);
services.AddSingleton(state);
services.AddSingleton(database);
services.AddSingleton(archive);
services.TryAddSingleton(TimeProvider.System);
services.ConfigureHttpJsonOptions(j => j.SerializerOptions.TypeInfoResolverChain.Insert(0, ProtocolJson.Default));
services.Configure<RouteHandlerOptions>(o => o.ThrowOnBadRequest = true);
services.Configure<HostOptions>(o => o.ShutdownTimeout = TimeSpan.FromSeconds(30));
if (options.TlsMode == TlsMode.Proxy)
{
// Only the configured proxies may say who the client is: a client that reaches the HTTP port directly would
// otherwise pick its own address for the sign-in rate limit and the audit log, and claim HTTPS.
var trusted = options.TrustedProxyNetworks();
services.Configure<ForwardedHeadersOptions>(f =>
{
f.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto | ForwardedHeaders.XForwardedHost;
f.KnownIPNetworks.Clear();
f.KnownProxies.Clear();
foreach (var network in trusted) f.KnownIPNetworks.Add(network);
});
}
services.AddSingleton<EventHub>();
services.AddSingleton<TokenService>();
services.AddSingleton<LoginGuard>();
services.AddSingleton<AuditLog>();
services.AddSingleton<ServerSettingsStore>();
services.AddSingleton<UploadStore>();
services.AddSingleton<UploadService>();
services.AddSingleton<RenderStore>();
services.AddSingleton<RenderUploads>();
services.AddSingleton<SequenceJobs>();
services.AddSingleton<RenderNodeService>();
services.AddSingleton<JobEngineHost>();
services.AddHostedService(sp => sp.GetRequiredService<JobEngineHost>());
services.AddSingleton<RenderNodeMonitor>();
services.AddHostedService(sp => sp.GetRequiredService<RenderNodeMonitor>());
services.AddSingleton<UploadMaintenance>();
services.AddHostedService(sp => sp.GetRequiredService<UploadMaintenance>());
services.AddSingleton<DiscoveryBeaconService>();
services.AddHostedService(sp => sp.GetRequiredService<DiscoveryBeaconService>());
}
private static void ConfigurePipeline(WebApplication app, ServerOptions options)
{
if (options.TlsMode == TlsMode.Proxy) app.UseForwardedHeaders();
app.UseMiddleware<ResponseMiddleware>();
app.UseWebSockets(new WebSocketOptions { KeepAliveInterval = TimeSpan.FromSeconds(30) });
app.UseRouting();
app.UseMiddleware<AuthenticationMiddleware>();
AdminPanel.Map(app, options);
var api = app.MapGroup("/api/v1");
SystemEndpoints.Map(app, api);
AuthEndpoints.Map(api);
UserEndpoints.Map(api);
SequenceEndpoints.Map(api);
FileEndpoints.Map(api);
UploadEndpoints.Map(api);
JobEndpoints.Map(api);
NodeEndpoints.Map(api);
ArchiveEndpoints.Map(api);
AdminEndpoints.Map(api);
DiagnosticsEndpoints.Map(api);
EventEndpoints.Map(api);
app.MapFallback("/api/{**path}", (HttpContext context) => ApiErrors.NotFound(context)).AllowAnonymousCaller();
}
/// <summary>Fails fast when the archive module's services are missing (the server would accept uploads it cannot commit).</summary>
private static void RequireArchiveModule(IServiceCollection services)
{
var missing = new List<string>();
if (!services.Any(d => d.ServiceType == typeof(IArchiveIngest))) missing.Add($"{typeof(IArchiveIngest).FullName} (commits verified uploads into the archive layout)");
if (!services.Any(d => d.ServiceType == typeof(IFrameAssetLocator))) missing.Add($"{typeof(IFrameAssetLocator).FullName} (finds proxies and thumbnails)");
if (missing.Count > 0)
{
throw new InvalidOperationException(
"Titano Server cannot start: no implementation is registered for " + string.Join(" and ", missing) +
". Register them in the services callback of ServerHost.Build.");
}
}
}