Files
Alby96andClaude Opus 5.5 255e149087
CI / Build and test (push) Successful in 9m36s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 9s
Release / Build, test and publish (push) Successful in 14m4s
CI / PostgreSQL 16 integration (push) Successful in 8m26s
CI / PostgreSQL 17 integration (push) Successful in 8m43s
CI / Docker image (push) Successful in 50s
Release / Server image (push) Successful in 1m23s
fix: owner review 3 phase 1: server ports for clients, screenshot baselines (#16)
Clients could not reach a server in a container whose ports are published as other host ports: the panel showed the container's ports, the template had no public HTTP port, and a bare host meant port 443. Public ports become panel settings, the panel shows the client address, both clients default to 8443, and an address that answers as another service is named as not a Chronos server (its certificate never offered for trust). The screenshot baselines are captured on the development PC and committed; measured values are fixed while the capture runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-04 12:33:22 +01:00

192 lines
11 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 AChronosErrorFromTheInfoIsReportedAsThatError()
{
// Chronos's own error (its header and code) is read once to tell it from other services: it must still come back
// as the server's error, and an unknown certificate still asks for trust.
await using var other = await OtherService.StartAsync(context);
foreach (var (path, status, code) in new[] { ("chronos500/", HttpStatusCode.InternalServerError, "internal"), ("chronos400/", HttpStatusCode.BadRequest, "bad_request") })
{
using var plain = new ChronosClient(new Uri(other.Http, path), new CertificatePinning([]), "tests");
var error = await Assert.ThrowsAsync<ChronosApiException>(() => plain.GetInfoAsync(context.Cancellation), path);
Assert.Equal(status, error.Status, path);
Assert.Equal(code, error.Error.Code, path);
using var untrusted = new ChronosClient(new Uri(other.Https, path), new CertificatePinning([]), "tests");
await Assert.ThrowsAsync<UntrustedCertificateException>(() => untrusted.GetInfoAsync(context.Cancellation), path);
}
}
[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));
// Errors as Chronos writes them: its header and a code of its own.
foreach (var (path, status, code) in new[] { ("chronos500", 500, "internal"), ("chronos400", 400, "bad_request") })
app.MapGet($"/{path}/api/v1/server/info", (HttpContext http) =>
{
http.Response.Headers[ApiVersion.Header] = "1";
return Results.Content($$"""{"code":"{{code}}","message":"Failed"}""", "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();
}
}
}