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
350 lines
17 KiB
C#
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());
|
|
}
|
|
}
|