Files
Chronos/tests/Chronos.Server.Tests/Api/ServerIdentityTests.cs
T
Alby96andClaude Opus 5.5 2585b5d45f fix(protocol): report Chronos's own info error as that error, not a disposed stream
The identity check reads Chronos's error body to tell it from another
service; GetInfoAsync then read it again and threw ObjectDisposedException.
The identity now carries the parsed error and GetInfoAsync throws it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 10:42:58 +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();
}
}
}