Files
Chronos/tests/Titano.Server.Tests/Hosting/ProxyModeTests.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
9.1 KiB
C#

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;
/// <summary>TLS mode proxy (BRIEF §14.2): forwarded headers count only from trusted proxies, and the admin warns otherwise.</summary>
[Category("server")]
public sealed class ProxyModeTests(TestContext context)
{
/// <summary>A documentation network (RFC 5737) the test client never connects from.</summary>
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);
}
/// <summary>
/// Runs the server's own forwarded-headers step on a request from <paramref name="peer"/> that claims to forward a
/// client at 203.0.113.7 over HTTPS: the address and scheme the rest of the server then sees.
/// </summary>
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<IOptions<ForwardedHeadersOptions>>());
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<HttpResponseMessage> 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<DashboardDto> 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<ServerSettingsDto> 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<HttpResponseMessage> 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);
}
}