using System.Net; using System.Net.Http.Json; using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Http; using Microsoft.AspNetCore.HttpOverrides; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Logging.Abstractions; using Microsoft.Extensions.Options; using Titano.Core.Localization; using Titano.Protocol; using Titano.Server.Api; using Titano.Server.Configuration; using Titano.Testing; namespace Titano.Server.Tests.Hosting; /// TLS mode proxy (BRIEF ยง14.2): forwarded headers count only from trusted proxies, and the admin warns otherwise. [Category("server")] public sealed class ProxyModeTests(TestContext context) { /// A documentation network (RFC 5737) the test client never connects from. private const string ElsewhereOnly = "192.0.2.0/24"; [Test] public async Task AClientOutsideTheTrustedProxiesCannotChooseItsAddress() { await using var server = await TestServer.StartAsync(context, o => { o.TlsMode = TlsMode.Proxy; o.TrustedProxies = ElsewhereOnly; o.LoginAttemptsPerMinute = 5; }); for (var i = 0; i < 5; i++) { using var failed = await LoginAsync(server, "user" + i, $"203.0.113.{i + 1}"); await failed.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); } // A new X-Forwarded-For per attempt does not buy a new budget: the limit stays on the real address. using var limited = await LoginAsync(server, "admin", "203.0.113.99"); await limited.ExpectErrorAsync(HttpStatusCode.TooManyRequests, "rate_limited"); var audit = await server.Database.Audit.ListAsync(null, "login_failed", 50, null, context.Cancellation); Assert.Count(5, audit.Items); Assert.True(audit.Items.All(e => IsLoopback(e.RemoteAddress)), string.Join(", ", audit.Items.Select(e => e.RemoteAddress))); } [Test] public async Task ATrustedProxyReportsTheClientAddress() { // The default trusts loopback, where a proxy on the same machine (and this test) connects from. await using var server = await TestServer.StartAsync(context, o => { o.TlsMode = TlsMode.Proxy; o.LoginAttemptsPerMinute = 5; }); for (var i = 0; i < 8; i++) { using var failed = await LoginAsync(server, "user" + i, $"203.0.113.{i + 1}"); await failed.ExpectErrorAsync(HttpStatusCode.Unauthorized, "invalid_credentials"); } var audit = await server.Database.Audit.ListAsync(null, "login_failed", 50, null, context.Cancellation); Assert.Contains("203.0.113.8", audit.Items.Select(e => e.RemoteAddress)); } [Test] public async Task ByDefaultAMachineOfTheHomeNetworkIsNoProxy() { // The machines of a home network reach the HTTP port directly from private addresses, also through Docker's // port publishing (which keeps the client's address): none of them may choose its own address. await using var server = await TestServer.StartAsync(context, o => o.TlsMode = TlsMode.Proxy); foreach (var peer in new[] { "192.168.1.50", "10.0.0.7", "172.17.0.1", "fd00::7" }) Assert.Equal((peer, false), await ForwardAsync(server, peer)); Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "127.0.0.1")); Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "::ffff:127.0.0.1")); Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "::1")); } [Test] public async Task AProxyNetworkCountsOnceListed() { await using var server = await TestServer.StartAsync(context, o => { o.TlsMode = TlsMode.Proxy; o.TrustedProxies = "172.18.0.0/16"; }); Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "172.18.0.5")); Assert.Equal(("192.168.1.50", false), await ForwardAsync(server, "192.168.1.50")); } [Test] public void AnAdminSignInThroughAnUntrustedProxyNamesTheSetting() { // The warning chip needs a session first: the sign-in refusal itself points at TITANO_TRUSTED_PROXIES. var request = new DefaultHttpContext(); request.Connection.RemoteIpAddress = IPAddress.Parse("172.18.0.5"); request.Request.Scheme = "http"; Assert.Equal("proxy_untrusted", AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); Assert.Equal("https_required", AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Auto })); Assert.Contains("TITANO_TRUSTED_PROXIES", Loc.L("Server.Error.ProxyUntrusted")); request.Request.Scheme = "https"; Assert.Null(AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); request.Request.Scheme = "http"; request.Connection.RemoteIpAddress = IPAddress.Loopback; Assert.Null(AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); } [Test] public async Task TheAdminWarnsWhenAPageDidNotComeThroughATrustedProxyOverHttps() { await using var server = await TestServer.StartAsync(context, o => o.TlsMode = TlsMode.Proxy); var admin = await server.AdminAsync(); Assert.True((await DashboardAsync(admin, forwardedProto: null)).ProxyWarning, "plain HTTP to the server's own port"); Assert.False((await DashboardAsync(admin, "https")).ProxyWarning, "HTTPS through a trusted proxy"); Assert.True((await DashboardAsync(admin, "http")).ProxyWarning, "plain HTTP through the proxy"); Assert.True((await SettingsAsync(admin, forwardedProto: null)).ProxyWarning); Assert.False((await SettingsAsync(admin, "https")).ProxyWarning); await using var untrusted = await TestServer.StartAsync(context, o => { o.TlsMode = TlsMode.Proxy; o.TrustedProxies = ElsewhereOnly; }); var other = await untrusted.AdminAsync(); Assert.True((await DashboardAsync(other, "https")).ProxyWarning, "a claim of HTTPS from a peer that is no trusted proxy"); } [Test] public async Task OtherTlsModesNeverWarn() { await using var server = await TestServer.StartAsync(context); var admin = await server.AdminAsync(); Assert.False((await DashboardAsync(admin, forwardedProto: null)).ProxyWarning); Assert.False((await SettingsAsync(admin, forwardedProto: null)).ProxyWarning); } /// /// Runs the server's own forwarded-headers step on a request from that claims to forward a /// client at 203.0.113.7 over HTTPS: the address and scheme the rest of the server then sees. /// private static async Task<(string? Address, bool Https)> ForwardAsync(TestServer server, string peer) { var request = new DefaultHttpContext(); request.Connection.RemoteIpAddress = IPAddress.Parse(peer); request.Request.Scheme = "http"; request.Request.Headers["X-Forwarded-For"] = "203.0.113.7"; request.Request.Headers["X-Forwarded-Proto"] = "https"; var forwarded = new ForwardedHeadersMiddleware(_ => Task.CompletedTask, NullLoggerFactory.Instance, server.Services.GetRequiredService>()); await forwarded.Invoke(request); var address = request.Connection.RemoteIpAddress; return ((address is { IsIPv4MappedToIPv6: true } ? address.MapToIPv4() : address)?.ToString(), request.Request.IsHttps); } private static bool IsLoopback(string? address) => IPAddress.TryParse(address, out var ip) && IPAddress.IsLoopback(ip.IsIPv4MappedToIPv6 ? ip.MapToIPv4() : ip); private static async Task LoginAsync(TestServer server, string username, string forwardedFor) { using var request = new HttpRequestMessage(HttpMethod.Post, "/api/v1/auth/login") { Content = JsonContent.Create(new LoginRequest(username, "wrong-password-x", "tests"), ProtocolJson.Default.LoginRequest), }; request.Headers.Add("X-Forwarded-For", forwardedFor); return await server.Client.SendAsync(request); } private static async Task DashboardAsync(HttpClient admin, string? forwardedProto) { using var response = await SendAsync(admin, "/api/v1/server/dashboard", forwardedProto); return await response.ReadAsync(ProtocolJson.Default.DashboardDto); } private static async Task SettingsAsync(HttpClient admin, string? forwardedProto) { using var response = await SendAsync(admin, "/api/v1/server/settings", forwardedProto); return await response.ReadAsync(ProtocolJson.Default.ServerSettingsDto); } private static async Task SendAsync(HttpClient client, string path, string? forwardedProto) { using var request = new HttpRequestMessage(HttpMethod.Get, path); if (forwardedProto is not null) request.Headers.Add("X-Forwarded-Proto", forwardedProto); return await client.SendAsync(request); } }