Files
Chronos/tests/Chronos.Server.Tests/Api/ServerIdentityTests.cs
T
Alby96andClaude Opus 5.5 0aa2fb8135 fix(server): client address from the page's port, stricter Chronos identity, Host networking notes
Review fixes on top of the public ports change (owner review 3):

- Settings > Network and TLS: opened over HTTPS, the client address uses the port
  the page came through (a container's 8443 published as 8444 with Public HTTPS
  port still empty showed the wrong 8443), and a "Use <port>" button fills that
  port in. Saving a Public HTTPS port other than the page's asks first, since the
  HTTPS redirect follows it at once and a typo would lock the panel's link out.
- GetInfoAsync tells Chronos from other services by stricter rules on both the
  trusted and the untrusted-certificate path: any redirect, any answer that is not
  JSON, more than 1 MB, or an error without the X-Chronos-Api header is not
  Chronos. Another service's certificate is no longer offered for trust after a
  cross-scheme redirect, an error page or a JSON 401/403/404, and a JSON 401 over
  HTTP no longer reads as a wrong password.
- The HTTP port typed without a scheme (TLS to a plain HTTP port) now gives the
  not-Chronos error instead of "the server did not answer".
- The Uploader's certificate question names the address with its port.
- A link-local IPv6 address with a zone index is refused instead of losing it.
- In a container, the first save of the settings removes HttpPort/HttpsPort from
  server.json, so the start-up warning stops; the warning says so.
- Guide, README, compose and template: with network type Host the mappings do
  nothing and CHRONOS_HTTP_PORT / CHRONOS_HTTPS_PORT move the listening ports off
  ones another service uses; the template overview is back to two sentences.
- BRIEF, DECISIONS and CHANGELOG updated; en/it strings added.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:28:08 +01:00

167 lines
9.4 KiB
C#

using System.Net;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.Server;
using Microsoft.AspNetCore.Hosting.Server.Features;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Chronos.Protocol;
using Chronos.Protocol.Client;
using Chronos.Testing;
namespace Chronos.Server.Tests.Api;
/// <summary>
/// What a client makes of the address it was given (owner review 3): the owner's NAS answers on 8443 with another service,
/// which redirects to its sign-in page behind a self-signed certificate of its own.
/// </summary>
[Category("server")]
public sealed class ServerIdentityTests(TestContext context)
{
/// <summary>Answers of another service, each under its own path.</summary>
private static readonly string[] OtherAnswers =
[
"html/", "redirect/", "away/", "empty/", "json/", "unauthorized/", "missing/", "text/", "failed/", "gateway/", "json401/", "json403/",
"json404/", "huge/", "hugejson/",
];
[Test]
public async Task AnAddressThatAnswersAsSomethingElseIsNotAChronosServer()
{
await using var other = await OtherService.StartAsync(context);
// Over HTTP, and over HTTPS behind the service's own certificate, which nobody trusted.
foreach (var address in new[] { other.Http, other.Https }.SelectMany(root => OtherAnswers.Select(path => new Uri(root, path))))
{
using var client = new ChronosClient(address, new CertificatePinning([]), "tests");
var error = await Assert.ThrowsAsync<NotChronosServerException>(() => client.GetInfoAsync(context.Cancellation), address.ToString());
Assert.Equal(address, error.Address, address.ToString());
}
Assert.Equal(0, other.Authorized, "no request carried credentials");
}
[Test]
public async Task TheHttpPortTypedWithoutASchemeIsNotAChronosServer()
{
// "192.168.30.23:8087", the port of the panel's link: HTTPS to a port that answers plain HTTP.
await using var server = await TestServer.StartAsync(context);
Assert.True(ChronosAddress.TryParse($"127.0.0.1:{server.HttpBase.Port}", out var typed));
using var client = new ChronosClient(typed, new CertificatePinning([]), "tests");
var error = await Assert.ThrowsAsync<NotChronosServerException>(() => client.GetInfoAsync(context.Cancellation));
Assert.Equal(typed, error.Address);
await using var other = await OtherService.StartAsync(context);
using var otherClient = new ChronosClient(new UriBuilder(other.Http) { Scheme = "https", Port = other.Http.Port }.Uri, new CertificatePinning([]), "tests");
await Assert.ThrowsAsync<NotChronosServerException>(() => otherClient.GetInfoAsync(context.Cancellation));
// A port where nothing answers is still unreachable, not another service.
var listener = new System.Net.Sockets.TcpListener(IPAddress.Loopback, 0);
listener.Start();
var closed = ((IPEndPoint)listener.LocalEndpoint).Port;
listener.Stop();
using var nobody = new ChronosClient(new Uri($"https://127.0.0.1:{closed}/"), new CertificatePinning([]), "tests");
await Assert.ThrowsAsync<HttpRequestException>(() => nobody.GetInfoAsync(context.Cancellation));
}
[Test]
public async Task TheCertificateOfAnotherServiceIsNeverOfferedForTrust()
{
await using var other = await OtherService.StartAsync(context);
var pinning = new CertificatePinning([]);
using var client = new ChronosClient(new Uri(other.Https, "redirect/"), pinning, "tests");
await Assert.ThrowsAsync<NotChronosServerException>(() => client.GetInfoAsync(context.Cancellation));
// Nothing was trusted, and the next request still refuses the certificate.
await Assert.ThrowsAsync<UntrustedCertificateException>(() => client.MeAsync(context.Cancellation));
Assert.Equal(0, other.Authorized, "no request carried credentials");
}
[Test]
public async Task AChronosServerBehindAnUnknownCertificateStillAsksForTrust()
{
await using var server = await TestServer.StartAsync(context, o => o.ServerName = "Studio NAS");
var https = Assert.NotNull(server.HttpsBase);
using var unknown = new ChronosClient(https, new CertificatePinning([]), "tests");
var untrusted = await Assert.ThrowsAsync<UntrustedCertificateException>(() => unknown.GetInfoAsync(context.Cancellation));
using var info = await server.Client.GetAsync("/api/v1/server/info");
Assert.Equal((await info.ReadAsync(ProtocolJson.Default.ServerInfo)).TlsFingerprint, untrusted.Fingerprint);
using var trusted = new ChronosClient(https, new CertificatePinning([untrusted.Fingerprint]), "tests");
Assert.Equal("Studio NAS", (await trusted.GetInfoAsync(context.Cancellation)).Name);
// Plain HTTP to the same server is Chronos too.
using var plain = new ChronosClient(server.HttpBase, new CertificatePinning([]), "tests");
Assert.Equal("Studio NAS", (await plain.GetInfoAsync(context.Cancellation)).Name);
}
/// <summary>A web service that is not Chronos, on HTTP and on HTTPS with a self-signed certificate of its own.</summary>
private sealed class OtherService : IAsyncDisposable
{
private readonly WebApplication _app;
private int _authorized;
private OtherService(WebApplication app)
{
_app = app;
var addresses = app.Services.GetRequiredService<IServer>().Features.Get<IServerAddressesFeature>()!.Addresses.Select(a => new Uri(a)).ToList();
Http = new Uri(addresses.First(a => a.Scheme == "http"), "/");
Https = new Uri(addresses.First(a => a.Scheme == "https"), "/");
}
public Uri Http { get; }
public Uri Https { get; }
/// <summary>Requests that carried an Authorization header.</summary>
public int Authorized => Volatile.Read(ref _authorized);
public static async Task<OtherService> StartAsync(TestContext context)
{
using var key = RSA.Create(2048);
var request = new CertificateRequest("CN=other-service", key, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
using var created = request.CreateSelfSigned(DateTimeOffset.UtcNow.AddDays(-1), DateTimeOffset.UtcNow.AddDays(1));
var certificate = X509CertificateLoader.LoadPkcs12(created.Export(X509ContentType.Pfx), null);
var builder = WebApplication.CreateSlimBuilder();
builder.Logging.ClearProviders();
builder.WebHost.ConfigureKestrel(k =>
{
k.Listen(IPAddress.Loopback, 0);
k.Listen(IPAddress.Loopback, 0, l => l.UseHttps(certificate));
});
var app = builder.Build();
OtherService? service = null;
app.Use(async (http, next) =>
{
if (http.Request.Headers.Authorization.Count > 0 && service is not null) Interlocked.Increment(ref service._authorized);
await next(http);
});
app.MapGet("/html/api/v1/server/info", () => Results.Content("<!doctype html><title>NAS</title>", "text/html"));
app.MapGet("/redirect/api/v1/server/info", () => Results.Redirect("/login"));
app.MapGet("/login", () => Results.Content("<!doctype html><form>Sign in</form>", "text/html"));
app.MapGet("/empty/api/v1/server/info", () => Results.Content("{}", "application/json"));
app.MapGet("/json/api/v1/server/info", () => Results.Content("""{"status":"ok","name":"router"}""", "application/json"));
app.MapGet("/unauthorized/api/v1/server/info", () => Results.StatusCode(StatusCodes.Status401Unauthorized));
// An absolute redirect to plain HTTP, which a client never follows from HTTPS.
app.MapGet("/away/api/v1/server/info", (HttpContext http) => Results.Redirect($"http://{http.Request.Host}/login"));
app.MapGet("/text/api/v1/server/info", () => Results.Text("ok"));
app.MapGet("/failed/api/v1/server/info", () => Results.Content("<!doctype html><title>Error</title>", "text/html", statusCode: StatusCodes.Status500InternalServerError));
app.MapGet("/gateway/api/v1/server/info", () => Results.Content("<!doctype html><title>Bad gateway</title>", "text/html", statusCode: StatusCodes.Status502BadGateway));
// Errors in JSON with a code of their own, as many web services write them.
foreach (var (path, status) in new[] { ("json401", 401), ("json403", 403), ("json404", 404) })
app.MapGet($"/{path}/api/v1/server/info", () => Results.Content("""{"code":"denied","message":"Sign in"}""", "application/json", statusCode: status));
// More than a server info ever holds.
app.MapGet("/huge/api/v1/server/info", () => Results.Content("<!doctype html>" + new string('x', 2 << 20), "text/html"));
app.MapGet("/hugejson/api/v1/server/info", () => Results.Content("{\"name\":\"" + new string('x', 2 << 20) + "\"}", "application/json"));
await app.StartAsync(context.Cancellation);
service = new OtherService(app);
return service;
}
public async ValueTask DisposeAsync()
{
await _app.StopAsync();
await _app.DisposeAsync();
}
}
}