Files
Febe/tests/Febe.Tests/Web/HostingAndSecurityTests.cs
T
Claude e33540246e Interfaccia web, parte 1: ospite, sicurezza, API, modalità dimostrativa, libreria, visualizzatore e account
Febe.Web: AddFebeWeb/UseFebe/FebeWebHost per le due vesti, interfaccia incorporata con IFileProvider proprio, indirizzi italiani, API JSON con contesto generato, eventi SSE, controlli di Host/Origin, gettone del desktop e password con blocco (§13.1), INativeShell e capacità per veste. Modalità --demo con 38 account e circa 18.000 elementi finti e scene del motore. Pagine Libreria, Visualizzatore, Account, Aggiungi account e Scheda account (contenuti, impostazioni con piano, cronologia); schermate in docs/schermate con le differenze dai mockup; prove delle API, della sicurezza, dell'esportazione CSV e dei dati dimostrativi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
2026-10-13 19:14:35 +00:00

350 lines
17 KiB
C#

using System.Net;
using System.Text.Json;
using Febe.Tests.Support;
using Febe.Tests.Web.Support;
using Febe.Web;
using Febe.Web.Api;
using Febe.Web.Hosting;
using Febe.Web.Security;
namespace Febe.Tests.Web;
/// <summary>The embedded interface, the page addresses and the access checks of spec §13.1.</summary>
[TestClass]
public sealed class HostingAndSecurityTests
{
private static readonly string[] Pages =
[
"/", "/libreria", "/account", "/account/12", "/account/12/impostazioni", "/attivita", "/importa",
"/impostazioni/generali", "/impostazioni/limiti", "/impostazioni/collegamento", "/impostazioni/notifiche",
"/impostazioni/dati", "/impostazioni/informazioni", "/browser",
];
[TestMethod]
public void TheEmbeddedInterfaceHasEveryFileAndRefusesPathsOutsideIt()
{
var files = new EmbeddedWwwroot();
foreach (var path in new[] { "index.html", "accesso.html", "css/febe.css", "js/app.js", "testi/it.json", "img/marchio.svg", "icone/image.svg", "caratteri/archivo-latin-standard-normal.woff2" })
{
var info = files.GetFileInfo(path);
Assert.IsTrue(info.Exists, path);
Assert.IsGreaterThan(0L, info.Length, path);
using var stream = info.CreateReadStream();
Assert.AreEqual(info.Length, stream.Length, path);
}
Assert.IsTrue(files.GetFileInfo("/css/febe.css").Exists, "a leading slash is accepted");
foreach (var bad in new[] { "../Febe.Web.dll", "css/../index.html", "./index.html", "css\\febe.css", "C:/index.html", "css//febe.css", "nonexistent.js", "" })
{
Assert.IsFalse(files.GetFileInfo(bad).Exists, bad);
}
var icons = files.GetDirectoryContents("icone").Select(f => f.Name).ToList();
Assert.Contains("image.svg", icons);
Assert.IsFalse(files.GetDirectoryContents("../").Exists);
Assert.IsTrue(files.GetDirectoryContents(string.Empty).Any(f => f.IsDirectory && f.Name == "css"));
// The text resource is valid JSON with the Italian texts.
using var texts = JsonDocument.Parse(files.ReadText("testi/it.json")!);
Assert.AreEqual("Libreria", texts.RootElement.GetProperty("nav").GetProperty("libreria").GetString());
}
[TestMethod]
public void TheIconSpriteHasOneSymbolPerLucideFileWithoutItsOwnStroke()
{
var files = new EmbeddedWwwroot();
var sprite = SystemApi.BuildSprite(files);
var count = files.Files.Count(f => f.StartsWith("icone/", StringComparison.Ordinal) && f.EndsWith(".svg", StringComparison.Ordinal));
Assert.AreEqual(count, sprite.Split("<symbol ").Length - 1);
StringAssert.Contains(sprite, "id=\"i-layout-grid\"");
Assert.DoesNotContain("stroke-width=\"2\"", sprite, "stroke 1,75 comes from the style sheet");
}
[TestMethod]
public async Task ItalianPageAddressesAnswerWithTheApplicationAndTheApiStaysJson()
{
await using var server = await WebTestServer.StartAsync();
foreach (var page in Pages)
{
using var response = await server.Client.GetAsync(page);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, page);
Assert.AreEqual("text/html", response.Content.Headers.ContentType?.MediaType, page);
StringAssert.Contains(await response.Content.ReadAsStringAsync(), "<div id=\"app\"></div>", page);
Assert.IsTrue(response.Headers.Contains("Content-Security-Policy"), page);
}
using (var css = await server.Client.GetAsync("/css/febe.css"))
{
Assert.AreEqual("text/css", css.Content.Headers.ContentType?.MediaType);
Assert.AreEqual("nosniff", css.Headers.GetValues("X-Content-Type-Options").Single());
}
using (var js = await server.Client.GetAsync("/js/app.js"))
{
Assert.AreEqual("text/javascript", js.Content.Headers.ContentType?.MediaType);
}
using (var missing = await server.Client.GetAsync("/js/non-esiste.js"))
{
Assert.AreEqual(HttpStatusCode.NotFound, missing.StatusCode);
}
using var api = await server.Client.GetAsync("/api/non-esiste");
Assert.AreEqual(HttpStatusCode.NotFound, api.StatusCode);
Assert.AreEqual("application/json", api.Content.Headers.ContentType?.MediaType);
StringAssert.Contains(await api.Content.ReadAsStringAsync(), "sconosciuto");
var capabilities = await server.GetJsonAsync("/api/capabilities");
Assert.AreEqual("docker", capabilities.Str("edition"));
Assert.IsTrue(capabilities.Bool("foldersReadOnly"));
Assert.IsFalse(capabilities.Bool("showInFolder"));
Assert.AreEqual("2026-10-13", capabilities.Str("today"));
}
[TestMethod]
public async Task HostAndOriginChecksStopOtherPagesAndOtherNames()
{
await using var server = await WebTestServer.StartAsync();
using (var foreignHost = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
{
foreignHost.Headers.Host = "attacco.example:80";
using var response = await server.Client.SendAsync(foreignHost);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode, "DNS rebinding: a foreign host name is refused");
}
using (var crossOrigin = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "http://attacco.example"))
using (var response = await server.Client.SendAsync(crossOrigin))
{
Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
}
using (var nullOrigin = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "null"))
using (var response = await server.Client.SendAsync(nullOrigin))
{
Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
}
using (var crossSite = server.Request(HttpMethod.Post, "/api/engine/pause", origin: null))
{
crossSite.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "cross-site");
using var response = await server.Client.SendAsync(crossSite);
Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
}
using (var events = server.Request(HttpMethod.Get, "/api/eventi", origin: "http://attacco.example"))
using (var response = await server.Client.SendAsync(events))
{
Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode, "the event stream counts as a command channel");
}
using (var sameOrigin = server.Request(HttpMethod.Post, "/api/engine/pause"))
using (var response = await server.Client.SendAsync(sameOrigin))
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, await response.Content.ReadAsStringAsync());
}
using (var sameSite = server.Request(HttpMethod.Post, "/api/engine/pause", origin: null))
{
sameSite.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "same-origin");
using var response = await server.Client.SendAsync(sameSite);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
}
[TestMethod]
public async Task TheDesktopTokenOpensTheInterfaceOnceAndThenLivesInAStrictCookie()
{
var token = AccessToken.Create();
await using var server = await WebTestServer.StartAsync(new FebeWebOptions { Edition = FebeEdition.Desktop, Access = AccessMode.Token, AccessToken = token });
using (var bare = await server.Client.GetAsync("/api/capabilities"))
{
Assert.AreEqual(HttpStatusCode.Unauthorized, bare.StatusCode);
}
using (var page = await server.Client.GetAsync("/libreria"))
{
Assert.AreEqual(HttpStatusCode.Unauthorized, page.StatusCode);
}
using (var wrong = await server.Client.GetAsync("/libreria?gettone=sbagliato"))
{
Assert.AreEqual(HttpStatusCode.Unauthorized, wrong.StatusCode);
}
string cookie;
using (var first = await server.Client.GetAsync($"/libreria?tema=scuro&gettone={token}"))
{
Assert.AreEqual(HttpStatusCode.Redirect, first.StatusCode);
Assert.AreEqual("/libreria?tema=scuro", first.Headers.Location?.OriginalString, "the token leaves the address at once");
cookie = first.Headers.GetValues("Set-Cookie").Single();
StringAssert.Contains(cookie, AccessToken.CookieName + "=");
StringAssert.Contains(cookie.ToLowerInvariant(), "httponly");
StringAssert.Contains(cookie.ToLowerInvariant(), "samesite=strict");
}
using (var withCookie = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
{
withCookie.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
using var response = await server.Client.SendAsync(withCookie);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
using (var withHeader = new HttpRequestMessage(HttpMethod.Get, "/api/capabilities"))
{
withHeader.Headers.TryAddWithoutValidation(AccessToken.HeaderName, token);
using var response = await server.Client.SendAsync(withHeader);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
// The token is necessary but not sufficient: commands from another origin are refused even with it.
using (var forged = server.Request(HttpMethod.Post, "/api/engine/pause", origin: "http://127.0.0.1:1"))
{
forged.Headers.TryAddWithoutValidation(AccessToken.HeaderName, token);
using var response = await server.Client.SendAsync(forged);
Assert.AreEqual(HttpStatusCode.Forbidden, response.StatusCode);
}
}
[TestMethod]
public async Task ThePasswordOpensASessionAndRepeatedFailuresLockTheLogin()
{
await using var server = await WebTestServer.StartAsync(new FebeWebOptions
{
Access = AccessMode.Password,
Password = "una password lunga",
Lockout = new LockoutOptions { AttemptsPerClient = 3, AttemptsOverall = 50 },
});
using (var page = await server.Client.GetAsync("/libreria"))
{
Assert.AreEqual(HttpStatusCode.Redirect, page.StatusCode);
StringAssert.StartsWith(page.Headers.Location?.OriginalString, "/accesso?torna=");
}
using (var api = await server.Client.GetAsync("/api/accounts"))
{
Assert.AreEqual(HttpStatusCode.Unauthorized, api.StatusCode);
}
using (var login = await server.Client.GetAsync("/accesso"))
{
Assert.AreEqual(HttpStatusCode.OK, login.StatusCode, "the login page is public");
}
using (var css = await server.Client.GetAsync("/css/febe.css"))
{
Assert.AreEqual(HttpStatusCode.OK, css.StatusCode, "and so is what it needs");
}
var (wrong, _) = await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" });
Assert.AreEqual(HttpStatusCode.Unauthorized, wrong);
string cookie;
using (var ok = server.Request(HttpMethod.Post, "/api/accesso", new { password = "una password lunga" }))
using (var response = await server.Client.SendAsync(ok))
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
cookie = response.Headers.GetValues("Set-Cookie").Single();
StringAssert.Contains(cookie.ToLowerInvariant(), "httponly");
StringAssert.Contains(cookie.ToLowerInvariant(), "samesite=strict");
}
using (var authed = new HttpRequestMessage(HttpMethod.Get, "/api/accounts"))
{
authed.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
using var response = await server.Client.SendAsync(authed);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
// A login from another page is refused before the password is even checked.
var (foreign, _) = await SendWithOrigin(server, "/api/accesso", new { password = "una password lunga" }, "http://attacco.example");
Assert.AreEqual(HttpStatusCode.Forbidden, foreign);
// The right password cleared the earlier failure: the third failure from now on locks the login.
Assert.AreEqual(HttpStatusCode.Unauthorized, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
Assert.AreEqual(HttpStatusCode.Unauthorized, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
Assert.AreEqual(HttpStatusCode.TooManyRequests, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "no" })).Status);
Assert.AreEqual(HttpStatusCode.TooManyRequests, (await server.SendJsonAsync(HttpMethod.Post, "/api/accesso", new { password = "una password lunga" })).Status,
"while locked even the right password waits");
using (var logout = server.Request(HttpMethod.Post, "/api/uscita"))
{
logout.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
using var response = await server.Client.SendAsync(logout);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
using (var after = new HttpRequestMessage(HttpMethod.Get, "/api/accounts"))
{
after.Headers.TryAddWithoutValidation("Cookie", cookie.Split(';')[0]);
using var response = await server.Client.SendAsync(after);
Assert.AreEqual(HttpStatusCode.Unauthorized, response.StatusCode);
}
}
[TestMethod]
public void TheLockoutCoversOneClientAndAllClientsAndEndsByItself()
{
var now = Make.T0;
var access = new PasswordAccess("segreta", new LockoutOptions { AttemptsPerClient = 2, AttemptsOverall = 3, LockFor = TimeSpan.FromMinutes(15) }, () => now);
Assert.AreEqual(LoginStatus.WrongPassword, access.TryLogin("x", "a").Status);
Assert.AreEqual(LoginStatus.Locked, access.TryLogin("x", "a").Status);
Assert.AreEqual(LoginStatus.Locked, access.TryLogin("segreta", "a").Status);
Assert.AreEqual(LoginStatus.Locked, access.TryLogin("x", "b").Status, "the third failure overall locks every client");
Assert.AreEqual(LoginStatus.Locked, access.TryLogin("segreta", "c").Status, "even one that never failed");
now += TimeSpan.FromMinutes(16);
var ok = access.TryLogin("segreta", "a");
Assert.AreEqual(LoginStatus.Accepted, ok.Status);
Assert.IsTrue(access.IsValid(ok.SessionId));
now += TimeSpan.FromDays(31);
Assert.IsFalse(access.IsValid(ok.SessionId), "sessions expire");
}
[TestMethod]
public async Task TheEventStreamStartsWithTheEngine()
{
await using var server = await WebTestServer.StartAsync();
using var request = new HttpRequestMessage(HttpMethod.Get, "/api/eventi");
request.Headers.TryAddWithoutValidation("Sec-Fetch-Site", "same-origin");
using var response = await server.Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual("text/event-stream", response.Content.Headers.ContentType?.MediaType);
using var stream = await response.Content.ReadAsStreamAsync();
using var reader = new StreamReader(stream);
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10));
string? eventName = null;
string? data = null;
while (data is null)
{
var line = await reader.ReadLineAsync(timeout.Token);
if (line is null)
{
break;
}
if (line.StartsWith("event: ", StringComparison.Ordinal))
{
eventName = line[7..];
}
else if (line.StartsWith("data: ", StringComparison.Ordinal))
{
data = line[6..];
}
}
Assert.AreEqual("motore", eventName);
using var json = JsonDocument.Parse(data!);
Assert.AreEqual("Off", json.RootElement.GetProperty("snapshot").GetProperty("mode").GetString(), "without an engine Febe says «Motore spento»");
Assert.AreEqual("Motore spento", json.RootElement.GetProperty("snapshot").GetProperty("headline").GetString());
}
private static async Task<(HttpStatusCode Status, string Body)> SendWithOrigin(WebTestServer server, string path, object body, string origin)
{
using var request = server.Request(HttpMethod.Post, path, body, origin);
using var response = await server.Client.SendAsync(request);
return (response.StatusCode, await response.Content.ReadAsStringAsync());
}
}