From df2d4b4316effb29482b4bfdb14f516c8cd4b020 Mon Sep 17 00:00:00 2001 From: Claude Date: Mon, 12 Oct 2026 11:08:12 +0000 Subject: [PATCH] fix(server): refuse planted Windows data, guard new archives, trust only loopback proxies - Windows data folder: the folder and everything in it must belong to SYSTEM, Administrators or the server's account and hold no link, checked before the ACL is rewritten; otherwise the server stops and names the entry. server.json is read only after its owner is checked on the open handle. Secrets are deleted and created anew with the private ACL, so a planted file's owner loses its rights. - Windows archive: a folder the server creates is changeable only by those accounts (users may read it) and a .titano folder it creates is private; an existing archive others can change is logged as a warning at start. - Proxy mode: only loopback is trusted by default, since LAN clients reach the HTTP port from private addresses; a cookie sign-in that did not come through a trusted proxy over HTTPS answers proxy_untrusted, naming TITANO_TRUSTED_PROXIES. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC --- i18n/en/Server.resx | 1 + i18n/it/Server.it.resx | 1 + src/Titano.Server/Api/AuthEndpoints.cs | 14 +- .../Configuration/ServerOptions.cs | 12 +- src/Titano.Server/Hosting/DataFolderAccess.cs | 235 ++++++++++++++++-- .../Hosting/ServerCommandLine.cs | 2 +- src/Titano.Server/Hosting/ServerHost.cs | 8 +- .../Hosting/Windows/ServiceInstaller.cs | 29 +-- .../Hosting/DataFolderAccessTests.cs | 180 +++++++++++++- .../Hosting/ProxyModeTests.cs | 71 +++++- .../Hosting/StartupTests.cs | 8 +- 11 files changed, 497 insertions(+), 64 deletions(-) diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx index ef5ba78c..73a31bf6 100644 --- a/i18n/en/Server.resx +++ b/i18n/en/Server.resx @@ -67,6 +67,7 @@ Not found.long That address is not a Titano Server.long Change your password first.long + This page did not come through a trusted proxy over HTTPS. Open it through your proxy, or add the proxy's address to TITANO_TRUSTED_PROXIES.long This upload would exceed your quota.long Too many attempts; wait a minute and try again.long Choose a password different from the current one.long diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx index 2d35b8b3..347d1e1d 100644 --- a/i18n/it/Server.it.resx +++ b/i18n/it/Server.it.resx @@ -65,6 +65,7 @@ Non trovato. Questo indirizzo non è un Titano Server. Cambia prima la password. + Questa pagina non è arrivata da un proxy attendibile in HTTPS. Aprila tramite il proxy o aggiungi l'indirizzo del proxy a TITANO_TRUSTED_PROXIES. Questo caricamento supererebbe la tua quota. Troppi tentativi; attendi un minuto e riprova. Scegli una password diversa da quella attuale. diff --git a/src/Titano.Server/Api/AuthEndpoints.cs b/src/Titano.Server/Api/AuthEndpoints.cs index 6f9d30f3..51626076 100644 --- a/src/Titano.Server/Api/AuthEndpoints.cs +++ b/src/Titano.Server/Api/AuthEndpoints.cs @@ -18,8 +18,18 @@ public static class AuthEndpoints api.MapGet("/auth/me", (Caller caller) => Results.Json(Dto.User(caller.User), ProtocolJson.Default.UserDto)).AllowDuringPasswordChange(); } + /// + /// Why the Secure session cookie cannot be set for this request, or null when it can (HTTPS, or the machine + /// itself). In TLS mode proxy only a trusted proxy makes a request HTTPS, so the refusal names that setting. + /// + internal static string? CookieRefusal(HttpContext context, ServerOptions options) + { + if (SessionCookies.IsSecureTransport(context)) return null; + return options.TlsMode == TlsMode.Proxy ? "proxy_untrusted" : "https_required"; + } + private static async Task LoginAsync(HttpContext context, LoginRequest request, TitanoDatabase db, TokenService tokens, LoginGuard guard, - AuditLog audit, TimeProvider time) + AuditLog audit, TimeProvider time, ServerOptions options) { var ct = context.RequestAborted; if (!guard.TryAttempt(context.Connection.RemoteIpAddress?.ToString() ?? "unknown", out var wait)) return TooMany(context, "rate_limited", wait); @@ -27,7 +37,7 @@ public static class AuthEndpoints if (!Accounts.IsValidUsername(account) || string.IsNullOrEmpty(request.Password)) return ApiErrors.Result(context, StatusCodes.Status401Unauthorized, "invalid_credentials"); if (guard.IsLocked(account, out wait)) return TooMany(context, "account_locked", wait); - if (request.Cookie && !SessionCookies.IsSecureTransport(context)) return ApiErrors.BadRequest(context, "https_required"); + if (request.Cookie && CookieRefusal(context, options) is { } refusal) return ApiErrors.BadRequest(context, refusal); var user = await db.Users.GetByUsernameAsync(account, ct); bool valid; diff --git a/src/Titano.Server/Configuration/ServerOptions.cs b/src/Titano.Server/Configuration/ServerOptions.cs index ba20b354..f971f122 100644 --- a/src/Titano.Server/Configuration/ServerOptions.cs +++ b/src/Titano.Server/Configuration/ServerOptions.cs @@ -3,6 +3,7 @@ using System.Net; using System.Text.Json; using System.Text.Json.Serialization; using Titano.Data; +using Titano.Server.Hosting; namespace Titano.Server.Configuration; @@ -59,10 +60,12 @@ public sealed class ServerOptions ]; /// - /// Reverse proxies whose X-Forwarded-* headers count in TLS mode proxy: loopback and the private networks a - /// compose or Unraid proxy container connects from (RFC 1918, IPv6 unique local). + /// Reverse proxies whose X-Forwarded-* headers count in TLS mode proxy when none are configured: loopback only. + /// A home network's machines reach the HTTP port directly from private addresses (also through Docker's port + /// publishing, which keeps the client's address), so trusting a private network would let them pick their own + /// address again; a proxy in another container or on another machine is listed by its address or network. /// - public const string DefaultTrustedProxies = "127.0.0.0/8, ::1/128, 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, fc00::/7"; + public const string DefaultTrustedProxies = "127.0.0.0/8, ::1/128"; /// The environment variables the server reads (--help lists them all). public static IEnumerable EnvironmentVariables => Variables.Select(v => v.Variable).Prepend("TITANO_DATA_PATH"); @@ -170,7 +173,8 @@ public sealed class ServerOptions { try { - options = JsonSerializer.Deserialize(File.ReadAllText(file), ServerOptionsJson.Default.ServerOptions) ?? options; + // Its owner is checked first: a file another user planted would choose the archive, database and TLS key. + options = JsonSerializer.Deserialize(DataFolderAccess.ReadTrustedText(file), ServerOptionsJson.Default.ServerOptions) ?? options; } catch (JsonException ex) { diff --git a/src/Titano.Server/Hosting/DataFolderAccess.cs b/src/Titano.Server/Hosting/DataFolderAccess.cs index c75b0e41..bb0bd2f4 100644 --- a/src/Titano.Server/Hosting/DataFolderAccess.cs +++ b/src/Titano.Server/Hosting/DataFolderAccess.cs @@ -1,6 +1,7 @@ using System.Runtime.Versioning; using System.Security.AccessControl; using System.Security.Principal; +using Titano.Core.Archiving; namespace Titano.Server.Hosting; @@ -8,15 +9,32 @@ namespace Titano.Server.Hosting; /// Keeps the data folder and its secrets private (BRIEF §14.2): it holds the database, the TLS private key, the /// temporary admin password and server.json. On Windows the folder sits in %ProgramData%, whose ACL lets /// every local user read it and create files in it, so it gets a protected DACL (nothing inherited) that allows only -/// SYSTEM, Administrators and the account the server runs as; everything inside inherits that. Elsewhere the container -/// entrypoint owns /data, and secrets are written with mode 0600. +/// SYSTEM, Administrators and the account the server runs as; everything inside inherits that. Those accounts must also +/// own the folder and everything in it, and nothing in it may be a link: an owner can always change the ACL back, and +/// whoever planted a file chose what it says. Elsewhere the container entrypoint owns /data, and secrets are +/// written with mode 0600. An archive folder the server creates on Windows gets the same accounts (see +/// ). /// public static class DataFolderAccess { private const UnixFileMode OwnerOnly = UnixFileMode.UserRead | UnixFileMode.UserWrite; + private const int GenericAll = 0x10000000; + private const int GenericWrite = 0x40000000; - /// Creates the folder if needed and, on Windows, replaces an ACL that grants anyone else access. - /// The ACL cannot be changed (the account neither owns the folder nor is an administrator). + /// Rights that let an account replace or alter a file or folder (including the generic forms). + [SupportedOSPlatform("windows")] + private const FileSystemRights ChangeRights = FileSystemRights.WriteData | FileSystemRights.AppendData | FileSystemRights.WriteExtendedAttributes + | FileSystemRights.DeleteSubdirectoriesAndFiles | FileSystemRights.Delete | FileSystemRights.ChangePermissions | FileSystemRights.TakeOwnership + | (FileSystemRights)GenericWrite | (FileSystemRights)GenericAll; + + /// + /// Creates the folder if needed and, on Windows, refuses a folder that holds a link or an entry owned by anyone + /// else, then replaces an ACL that grants anyone else access. + /// + /// + /// Something in the folder is a link or belongs to another account, or the ACL cannot be read or changed (the account + /// is not an administrator). + /// public static void Restrict(string folder) { if (!OperatingSystem.IsWindows()) @@ -31,10 +49,22 @@ public static class DataFolderAccess catch (UnauthorizedAccessException ex) { throw new InvalidOperationException( - $"Titano Server cannot restrict access to {folder}: {ex.Message} Run it once as an administrator, or as the account that created the folder.", ex); + $"Titano Server cannot check or restrict access to {folder}: {ex.Message} Run it once as an administrator; if someone else changed the folder's access, delete the folder.", ex); } } + /// + /// Reads a file the server acts on (server.json). On Windows its owner must be SYSTEM, Administrators or the + /// server's account, checked on the handle that is read, so a file another user planted (or swapped in) is refused + /// before any of its settings is used. + /// + /// The file belongs to another account. + public static string ReadTrustedText(string path) + { + if (!OperatingSystem.IsWindows()) return File.ReadAllText(path); + return ReadTrustedText(path, AllowedAccounts()); + } + /// Writes a secret that only the server's account (and, on Windows, SYSTEM and Administrators) may read. public static void WritePrivateFile(string path, ReadOnlySpan contents) { @@ -49,12 +79,44 @@ public static class DataFolderAccess File.SetUnixFileMode(path, OwnerOnly); } - /// True when the ACL is protected and names no account besides SYSTEM, Administrators and this process's account. + /// + /// Creates the archive folder when it is missing, and says whether accounts other than SYSTEM, Administrators and the + /// server's own can change it (always false off Windows, where the container entrypoint checks the archive). On + /// Windows a folder created here gets a protected ACL: those accounts change it, other local users may only read it; + /// a .titano folder (staging, trash) created here is private. Whoever can write where the server moves files + /// can put a link in place of a folder and send the server's writes elsewhere; an existing archive is only reported, + /// because its ACL is its owner's choice. + /// + public static bool PrepareArchive(string root) + { + if (!OperatingSystem.IsWindows()) + { + Directory.CreateDirectory(root); + return false; + } + var folder = new DirectoryInfo(root); + if (!folder.Exists) + { + if (folder.Parent is { } parent) parent.Create(); + folder.Create(ArchiveFolderSecurity()); + folder.Refresh(); + } + // Created before the archive engine would create it with the archive's ACL; an existing one is left as it is. + var meta = new DirectoryInfo(new ArchivePaths(root).MetaDirectory); + if (!meta.Exists) meta.Create(PrivateFolderSecurity()); + return OthersCanChange(folder); + } + + /// + /// True when the ACL is protected, its owner is SYSTEM, Administrators or this process's account, and it names no + /// other account. + /// [SupportedOSPlatform("windows")] public static bool IsPrivate(FileSystemSecurity security) { if (!security.AreAccessRulesProtected) return false; var allowed = AllowedAccounts(); + if (security.GetOwner(typeof(SecurityIdentifier)) is not SecurityIdentifier owner || !allowed.Contains(owner)) return false; foreach (FileSystemAccessRule rule in security.GetAccessRules(includeExplicit: true, includeInherited: true, typeof(SecurityIdentifier))) { if (rule.AccessControlType == AccessControlType.Allow && !allowed.Contains((SecurityIdentifier)rule.IdentityReference)) return false; @@ -62,6 +124,73 @@ public static class DataFolderAccess return true; } + /// + /// The first problem with or anything inside it, as a sentence for the operator, or null: + /// a link (it would carry what the server reads, writes and secures elsewhere) or an owner outside + /// (who may have written the contents and can always change the ACL back). Links are + /// reported, never followed. + /// + [SupportedOSPlatform("windows")] + internal static string? FindUntrusted(DirectoryInfo folder, IReadOnlySet owners) + { + var everything = new EnumerationOptions { AttributesToSkip = 0, IgnoreInaccessible = false }; + var pending = new Stack(); + pending.Push(folder); + while (pending.TryPop(out var directory)) + { + if (Untrusted(directory, owners) is { } problem) return problem; + foreach (var entry in directory.EnumerateFileSystemInfos("*", everything)) + { + if (entry is DirectoryInfo child && !IsLink(child)) pending.Push(child); + else if (Untrusted(entry, owners) is { } entryProblem) return entryProblem; + } + } + return null; + } + + /// + [SupportedOSPlatform("windows")] + internal static string ReadTrustedText(string path, IReadOnlySet owners) + { + using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read); + if (UntrustedOwner(path, stream.GetAccessControl(), owners) is { } problem) throw new InvalidOperationException(problem); + using var reader = new StreamReader(stream); + return reader.ReadToEnd(); + } + + /// + /// True when the owner is outside or an allow entry gives change rights to such an + /// account. Entries that only pass to children count too, since new files would inherit them; CREATOR OWNER and + /// CREATOR GROUP stand for whoever creates a child, which already takes change rights on the folder. + /// + [SupportedOSPlatform("windows")] + internal static bool IsChangeableByOthers(FileSystemSecurity security, IReadOnlySet trusted, bool checkOwner) + { + if (checkOwner && (security.GetOwner(typeof(SecurityIdentifier)) is not SecurityIdentifier owner || !trusted.Contains(owner))) return true; + foreach (FileSystemAccessRule rule in security.GetAccessRules(includeExplicit: true, includeInherited: true, typeof(SecurityIdentifier))) + { + if (rule.AccessControlType != AccessControlType.Allow || (rule.FileSystemRights & ChangeRights) == 0) continue; + var account = (SecurityIdentifier)rule.IdentityReference; + if (trusted.Contains(account) || account.IsWellKnown(WellKnownSidType.CreatorOwnerSid) || account.IsWellKnown(WellKnownSidType.CreatorGroupSid)) continue; + return true; + } + return false; + } + + /// SYSTEM, Administrators and the account this process runs as (SYSTEM again for the Windows service). + [SupportedOSPlatform("windows")] + internal static HashSet AllowedAccounts() + { + using var identity = WindowsIdentity.GetCurrent(); + var accounts = new HashSet + { + new(WellKnownSidType.LocalSystemSid, null), + new(WellKnownSidType.BuiltinAdministratorsSid, null), + }; + if (identity.User is { } user) accounts.Add(user); + return accounts; + } + [SupportedOSPlatform("windows")] private static void RestrictOnWindows(DirectoryInfo folder) { @@ -71,18 +200,80 @@ public static class DataFolderAccess folder.Create(PrivateFolderSecurity()); folder.Refresh(); } + // Before the ACL is touched: a folder another user created in advance, or a file planted in an older version's + // folder, stays theirs whatever the ACL says, and a link would carry the new ACL elsewhere. + if (FindUntrusted(folder, AllowedAccounts()) is { } problem) throw new InvalidOperationException(problem); // An older version, or Windows' default inheritance from %ProgramData%, left the folder readable by every user. // Setting the DACL by name also replaces what the files inside inherited. if (!IsPrivate(folder.GetAccessControl())) folder.SetAccessControl(PrivateFolderSecurity()); } + [SupportedOSPlatform("windows")] + private static string? Untrusted(FileSystemInfo entry, IReadOnlySet owners) + { + if (IsLink(entry)) + { + return $"{entry.FullName} is a link to {entry.LinkTarget}, and Titano Server follows no links in its data folder. " + + "Delete the link (TITANO_DATA_PATH moves the data folder) and start the server again."; + } + FileSystemSecurity security = entry is DirectoryInfo directory + ? directory.GetAccessControl(AccessControlSections.Owner) + : ((FileInfo)entry).GetAccessControl(AccessControlSections.Owner); + return UntrustedOwner(entry.FullName, security, owners); + } + + [SupportedOSPlatform("windows")] + private static string? UntrustedOwner(string path, FileSystemSecurity security, IReadOnlySet owners) + { + var owner = security.GetOwner(typeof(SecurityIdentifier)) as SecurityIdentifier; + if (owner is not null && owners.Contains(owner)) return null; + return $"{path} belongs to {(owner is null ? "no account" : AccountName(owner))}, not to SYSTEM, Administrators or the account Titano Server " + + "runs as, so it cannot be trusted. Check it, then delete it or make Administrators its owner, and start the server again."; + } + + /// A symbolic link or junction (other reparse points, such as deduplicated files, are ordinary files). + private static bool IsLink(FileSystemInfo entry) => (entry.Attributes & FileAttributes.ReparsePoint) != 0 && entry.LinkTarget is not null; + + [SupportedOSPlatform("windows")] + private static string AccountName(SecurityIdentifier account) + { + try + { + return account.Translate(typeof(NTAccount)).Value; + } + catch (IdentityNotMappedException) + { + return account.Value; + } + } + + [SupportedOSPlatform("windows")] + private static bool OthersCanChange(DirectoryInfo folder) + { + try + { + return IsChangeableByOthers(folder.GetAccessControl(), AllowedAccounts(), checkOwner: true); + } + catch (NotSupportedException) + { + // A volume without ACLs (FAT, exFAT): everyone can change everything. + return true; + } + catch (Exception ex) when (ex is UnauthorizedAccessException or IOException or InvalidOperationException) + { + // The ACL cannot be read (some network shares); the warning would be a guess. + return false; + } + } + [SupportedOSPlatform("windows")] private static void WritePrivateFileOnWindows(FileInfo file, ReadOnlySpan contents) { - // The security descriptor applies when the file is created; one that already existed gets it afterwards. - using (var stream = file.Create(FileMode.Create, FileSystemRights.Write, FileShare.None, 4096, FileOptions.None, PrivateFileSecurity())) - stream.Write(contents); - if (!IsPrivate(file.GetAccessControl())) file.SetAccessControl(PrivateFileSecurity()); + // A file that already exists is replaced, never rewritten in place: it would keep its owner, who could change its + // ACL back at any time, and a link would carry the secret elsewhere. The new file is owned by this account. + file.Delete(); + using var stream = file.Create(FileMode.CreateNew, FileSystemRights.Write, FileShare.None, 4096, FileOptions.None, PrivateFileSecurity()); + stream.Write(contents); } /// A protected DACL that gives the allowed accounts full control, passed on to everything inside. @@ -99,6 +290,16 @@ public static class DataFolderAccess return security; } + /// The private DACL, plus read access for every local user (photos and renders, never .titano). + [SupportedOSPlatform("windows")] + private static DirectorySecurity ArchiveFolderSecurity() + { + var security = PrivateFolderSecurity(); + security.AddAccessRule(new FileSystemAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), FileSystemRights.ReadAndExecute, + InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); + return security; + } + [SupportedOSPlatform("windows")] private static FileSecurity PrivateFileSecurity() { @@ -108,18 +309,4 @@ public static class DataFolderAccess security.AddAccessRule(new FileSystemAccessRule(account, FileSystemRights.FullControl, AccessControlType.Allow)); return security; } - - /// SYSTEM, Administrators and the account this process runs as (SYSTEM again for the Windows service). - [SupportedOSPlatform("windows")] - private static HashSet AllowedAccounts() - { - using var identity = WindowsIdentity.GetCurrent(); - var accounts = new HashSet - { - new(WellKnownSidType.LocalSystemSid, null), - new(WellKnownSidType.BuiltinAdministratorsSid, null), - }; - if (identity.User is { } user) accounts.Add(user); - return accounts; - } } diff --git a/src/Titano.Server/Hosting/ServerCommandLine.cs b/src/Titano.Server/Hosting/ServerCommandLine.cs index e27f4392..10e2e462 100644 --- a/src/Titano.Server/Hosting/ServerCommandLine.cs +++ b/src/Titano.Server/Hosting/ServerCommandLine.cs @@ -43,7 +43,7 @@ public sealed record ServerCommandLine(ServerCommand Command, IReadOnlyList app.Logger.LogInformation("Titano Server stopping")); app.Lifetime.ApplicationStopped.Register(() => database.DisposeAsync().AsTask().GetAwaiter().GetResult()); return app; diff --git a/src/Titano.Server/Hosting/Windows/ServiceInstaller.cs b/src/Titano.Server/Hosting/Windows/ServiceInstaller.cs index 73f7b29d..dcc404e6 100644 --- a/src/Titano.Server/Hosting/Windows/ServiceInstaller.cs +++ b/src/Titano.Server/Hosting/Windows/ServiceInstaller.cs @@ -1,7 +1,6 @@ using System.ComponentModel; using System.Runtime.InteropServices; using System.Runtime.Versioning; -using System.Security.AccessControl; using System.Security.Principal; using Titano.Core.Localization; using static Titano.Server.Hosting.Windows.ServiceNative; @@ -20,13 +19,6 @@ namespace Titano.Server.Hosting.Windows; public static unsafe class ServiceInstaller { private const string DisplayName = "Titano Server"; - private const int GenericAll = 0x10000000; - private const int GenericWrite = 0x40000000; - - /// Rights that let an account replace or alter a file or folder (including the generic forms). - private const FileSystemRights ChangeRights = FileSystemRights.WriteData | FileSystemRights.AppendData | FileSystemRights.WriteExtendedAttributes - | FileSystemRights.DeleteSubdirectoriesAndFiles | FileSystemRights.Delete | FileSystemRights.ChangePermissions | FileSystemRights.TakeOwnership - | (FileSystemRights)GenericWrite | (FileSystemRights)GenericAll; /// TrustedInstaller, the owner of Windows' own files under Program Files. private static readonly SecurityIdentifier TrustedInstaller = new("S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"); @@ -128,10 +120,10 @@ public static unsafe class ServiceInstaller private static string? FindChangeable(DirectoryInfo folder, bool recursive, HashSet trusted) { - if (IsChangeableByOthers(folder.GetAccessControl(), trusted)) return folder.FullName; + if (DataFolderAccess.IsChangeableByOthers(folder.GetAccessControl(), trusted, checkOwner: false)) return folder.FullName; foreach (var file in folder.EnumerateFiles()) { - if (IsChangeableByOthers(file.GetAccessControl(), trusted)) return file.FullName; + if (DataFolderAccess.IsChangeableByOthers(file.GetAccessControl(), trusted, checkOwner: false)) return file.FullName; } if (!recursive) return null; foreach (var child in folder.EnumerateDirectories()) @@ -141,23 +133,6 @@ public static unsafe class ServiceInstaller return null; } - /// - /// True when an allow entry gives change rights to an account outside . Entries that only - /// pass to children count too, since new files would inherit them; CREATOR OWNER and CREATOR GROUP stand for whoever - /// creates a child, which already takes change rights on the folder. - /// - private static bool IsChangeableByOthers(FileSystemSecurity security, HashSet trusted) - { - foreach (FileSystemAccessRule rule in security.GetAccessRules(includeExplicit: true, includeInherited: true, typeof(SecurityIdentifier))) - { - if (rule.AccessControlType != AccessControlType.Allow || (rule.FileSystemRights & ChangeRights) == 0) continue; - var account = (SecurityIdentifier)rule.IdentityReference; - if (trusted.Contains(account) || account.IsWellKnown(WellKnownSidType.CreatorOwnerSid) || account.IsWellKnown(WellKnownSidType.CreatorGroupSid)) continue; - return true; - } - return false; - } - private static HashSet TrustedAccounts() { var trusted = new HashSet diff --git a/tests/Titano.Server.Tests/Hosting/DataFolderAccessTests.cs b/tests/Titano.Server.Tests/Hosting/DataFolderAccessTests.cs index 65bed66d..df03b16b 100644 --- a/tests/Titano.Server.Tests/Hosting/DataFolderAccessTests.cs +++ b/tests/Titano.Server.Tests/Hosting/DataFolderAccessTests.cs @@ -8,7 +8,8 @@ namespace Titano.Server.Tests.Hosting; /// /// The data folder and its secrets are private (BRIEF §14.2): mode 0600 off Windows; on Windows a protected ACL that no -/// ordinary user appears in, where %ProgramData% would otherwise let every local user read the folder. +/// ordinary user appears in, where %ProgramData% would otherwise let every local user read the folder, with owners the +/// server trusts and no links. On Windows a new archive folder lets other users only read it. /// [Category("server")] public sealed class DataFolderAccessTests(TestContext context) @@ -81,9 +82,186 @@ public sealed class DataFolderAccessTests(TestContext context) Assert.False(NamesUsers(settings.GetAccessControl())); } + [Test] + [WindowsOnly] + public void ASecretAnotherAccountOwnedIsReplacedByOneTheServerOwns() + { + if (!OperatingSystem.IsWindows()) return; + var folder = context.CreateTempDirectory("planted"); + var own = OwnerOf(NewFile(Path.Combine(folder, "probe.txt"))); + // Planted before the first start: whoever owns it keeps the right to change its ACL, whatever the server sets. + var secret = NewFile(Path.Combine(folder, "initial-admin-password.txt")); + if (!TrySetOwner(secret, OtherOwner(own))) Assert.Inconclusive("giving a file to another owner needs an elevated administrator"); + GrantUsersRead(secret); + + DataFolderAccess.WritePrivateFile(secret.FullName, [1, 2, 3]); + secret.Refresh(); + Assert.Equal(own, OwnerOf(secret)); + Assert.True(DataFolderAccess.IsPrivate(secret.GetAccessControl())); + Assert.False(NamesUsers(secret.GetAccessControl())); + Assert.BytesEqual([1, 2, 3], File.ReadAllBytes(secret.FullName)); + } + + [Test] + [WindowsOnly] + public void AnythingAnotherAccountOwnsIsFound() + { + if (!OperatingSystem.IsWindows()) return; + var folder = new DirectoryInfo(context.CreateTempDirectory("squatted")); + var key = NewFile(Path.Combine(folder.CreateSubdirectory("tls").FullName, "server.pfx")); + var own = OwnerOf(key); + Assert.Null(DataFolderAccess.FindUntrusted(folder, new HashSet { own })); + // A folder someone else created before the first start is reported before anything inside it. + Assert.Contains(folder.FullName, Assert.NotNull(DataFolderAccess.FindUntrusted(folder, new HashSet { LocalSystem }))); + + if (!TrySetOwner(key, OtherOwner(own))) Assert.Inconclusive("giving a file to another owner needs an elevated administrator"); + Assert.Contains(key.FullName, Assert.NotNull(DataFolderAccess.FindUntrusted(folder, new HashSet { own }))); + } + + [Test] + [WindowsOnly] + public void ALinkInTheDataFolderStopsTheServerBeforeTheAclChanges() + { + if (!OperatingSystem.IsWindows()) return; + var folder = new DirectoryInfo(context.CreateTempDirectory("linked")); + var link = Path.Combine(folder.FullName, "logs"); + try + { + Directory.CreateSymbolicLink(link, context.CreateTempDirectory("elsewhere")); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + Assert.Inconclusive("creating a symbolic link needs an elevated administrator or developer mode"); + } + + var refused = Assert.Throws(() => DataFolderAccess.Restrict(folder.FullName)); + Assert.Contains(link, refused.Message); + // The ACL change would have followed the link; it never started. + Assert.False(folder.GetAccessControl().AreAccessRulesProtected); + } + + [Test] + [WindowsOnly] + public void SettingsAnotherAccountOwnsAreNotRead() + { + if (!OperatingSystem.IsWindows()) return; + var settings = NewFile(Path.Combine(context.CreateTempDirectory("settings"), "server.json"), """{ "ArchivePath": "D:\\Elsewhere" }"""); + Assert.Contains("Elsewhere", DataFolderAccess.ReadTrustedText(settings.FullName)); + // As if another account had planted it: the owner is not among those the server trusts. + InvalidOperationException? refused = null; + try + { + DataFolderAccess.ReadTrustedText(settings.FullName, new HashSet { LocalSystem }); + } + catch (InvalidOperationException ex) + { + refused = ex; + } + Assert.Contains(settings.FullName, Assert.NotNull(refused).Message); + } + + [Test] + public void AMissingArchiveFolderIsCreated() + { + var root = Path.Combine(context.CreateTempDirectory("archive"), "TitanoArchive"); + Assert.False(DataFolderAccess.PrepareArchive(root)); + Assert.True(Directory.Exists(root)); + // An existing folder is left as it is. + Assert.False(DataFolderAccess.PrepareArchive(root)); + } + + [Test] + [WindowsOnly] + public void ANewArchiveIsReadableByUsersButOnlyTheServerChangesIt() + { + if (!OperatingSystem.IsWindows()) return; + // Under C:\ a new folder would inherit "Authenticated Users: modify" and every local user could plant links + // where the service moves uploads. + var root = new DirectoryInfo(Path.Combine(context.CreateTempDirectory("archive"), "TitanoArchive")); + Assert.False(DataFolderAccess.PrepareArchive(root.FullName)); + var security = root.GetAccessControl(); + Assert.True(security.AreAccessRulesProtected); + Assert.Equal(FileSystemRights.ReadAndExecute, RightsOf(security, Users) & FileSystemRights.ReadAndExecute); + Assert.Equal((FileSystemRights)0, RightsOf(security, Users) & (FileSystemRights.Write | FileSystemRights.Delete | FileSystemRights.ChangePermissions)); + + // Staging and trash are the server's alone. + var meta = new DirectoryInfo(Path.Combine(root.FullName, ".titano")); + Assert.True(DataFolderAccess.IsPrivate(meta.GetAccessControl())); + Assert.False(NamesUsers(meta.CreateSubdirectory("staging").GetAccessControl())); + } + + [Test] + [WindowsOnly] + public void AnArchiveOtherUsersCanChangeIsReportedButLeftAsItIs() + { + if (!OperatingSystem.IsWindows()) return; + var root = new DirectoryInfo(context.CreateTempDirectory("shared")); + DataFolderAccess.PrepareArchive(root.FullName); + var open = root.GetAccessControl(); + open.AddAccessRule(new FileSystemAccessRule(Users, FileSystemRights.Modify, + InheritanceFlags.ContainerInherit | InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)); + root.SetAccessControl(open); + + Assert.True(DataFolderAccess.PrepareArchive(root.FullName)); + Assert.Equal(FileSystemRights.Modify, RightsOf(root.GetAccessControl(), Users) & FileSystemRights.Modify); + // The .titano folder the server added at the first start stays its own. + Assert.True(DataFolderAccess.IsPrivate(new DirectoryInfo(Path.Combine(root.FullName, ".titano")).GetAccessControl())); + } + [SupportedOSPlatform("windows")] private static SecurityIdentifier Users => new(WellKnownSidType.BuiltinUsersSid, null); + [SupportedOSPlatform("windows")] + private static SecurityIdentifier LocalSystem => new(WellKnownSidType.LocalSystemSid, null); + + [SupportedOSPlatform("windows")] + private static SecurityIdentifier Administrators => new(WellKnownSidType.BuiltinAdministratorsSid, null); + + private static FileInfo NewFile(string path, string contents = "x") + { + File.WriteAllText(path, contents); + return new FileInfo(path); + } + + [SupportedOSPlatform("windows")] + private static SecurityIdentifier OwnerOf(FileInfo file) => (SecurityIdentifier)file.GetAccessControl().GetOwner(typeof(SecurityIdentifier))!; + + /// An owner this process may give a file that its new files do not get: its own account or Administrators. + [SupportedOSPlatform("windows")] + private static SecurityIdentifier OtherOwner(SecurityIdentifier own) + { + using var identity = WindowsIdentity.GetCurrent(); + return own == Administrators ? identity.User! : Administrators; + } + + [SupportedOSPlatform("windows")] + private static bool TrySetOwner(FileInfo file, SecurityIdentifier owner) + { + var security = new FileSecurity(); + security.SetOwner(owner); + try + { + file.SetAccessControl(security); + return true; + } + catch (Exception ex) when (ex is InvalidOperationException or UnauthorizedAccessException) + { + return false; + } + } + + /// The rights allow entries give . + [SupportedOSPlatform("windows")] + private static FileSystemRights RightsOf(FileSystemSecurity security, SecurityIdentifier account) + { + FileSystemRights rights = 0; + foreach (FileSystemAccessRule rule in security.GetAccessRules(includeExplicit: true, includeInherited: true, typeof(SecurityIdentifier))) + { + if (rule.AccessControlType == AccessControlType.Allow && rule.IdentityReference.Equals(account)) rights |= rule.FileSystemRights; + } + return rights; + } + /// True when Users, Authenticated Users or Everyone have any allow entry. [SupportedOSPlatform("windows")] private static bool NamesUsers(FileSystemSecurity security) diff --git a/tests/Titano.Server.Tests/Hosting/ProxyModeTests.cs b/tests/Titano.Server.Tests/Hosting/ProxyModeTests.cs index fa5ce42f..13c1256f 100644 --- a/tests/Titano.Server.Tests/Hosting/ProxyModeTests.cs +++ b/tests/Titano.Server.Tests/Hosting/ProxyModeTests.cs @@ -1,6 +1,14 @@ using System.Net; using System.Net.Http.Json; +using Microsoft.AspNetCore.Builder; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.HttpOverrides; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging.Abstractions; +using Microsoft.Extensions.Options; +using Titano.Core.Localization; using Titano.Protocol; +using Titano.Server.Api; using Titano.Server.Configuration; using Titano.Testing; @@ -39,7 +47,7 @@ public sealed class ProxyModeTests(TestContext context) [Test] public async Task ATrustedProxyReportsTheClientAddress() { - // The default trusts loopback and the private networks a compose or Unraid proxy container connects from. + // The default trusts loopback, where a proxy on the same machine (and this test) connects from. await using var server = await TestServer.StartAsync(context, o => { o.TlsMode = TlsMode.Proxy; @@ -54,6 +62,49 @@ public sealed class ProxyModeTests(TestContext context) Assert.Contains("203.0.113.8", audit.Items.Select(e => e.RemoteAddress)); } + [Test] + public async Task ByDefaultAMachineOfTheHomeNetworkIsNoProxy() + { + // The machines of a home network reach the HTTP port directly from private addresses, also through Docker's + // port publishing (which keeps the client's address): none of them may choose its own address. + await using var server = await TestServer.StartAsync(context, o => o.TlsMode = TlsMode.Proxy); + foreach (var peer in new[] { "192.168.1.50", "10.0.0.7", "172.17.0.1", "fd00::7" }) + Assert.Equal((peer, false), await ForwardAsync(server, peer)); + Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "127.0.0.1")); + Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "::ffff:127.0.0.1")); + Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "::1")); + } + + [Test] + public async Task AProxyNetworkCountsOnceListed() + { + await using var server = await TestServer.StartAsync(context, o => + { + o.TlsMode = TlsMode.Proxy; + o.TrustedProxies = "172.18.0.0/16"; + }); + Assert.Equal(("203.0.113.7", true), await ForwardAsync(server, "172.18.0.5")); + Assert.Equal(("192.168.1.50", false), await ForwardAsync(server, "192.168.1.50")); + } + + [Test] + public void AnAdminSignInThroughAnUntrustedProxyNamesTheSetting() + { + // The warning chip needs a session first: the sign-in refusal itself points at TITANO_TRUSTED_PROXIES. + var request = new DefaultHttpContext(); + request.Connection.RemoteIpAddress = IPAddress.Parse("172.18.0.5"); + request.Request.Scheme = "http"; + Assert.Equal("proxy_untrusted", AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); + Assert.Equal("https_required", AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Auto })); + Assert.Contains("TITANO_TRUSTED_PROXIES", Loc.L("Server.Error.ProxyUntrusted")); + + request.Request.Scheme = "https"; + Assert.Null(AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); + request.Request.Scheme = "http"; + request.Connection.RemoteIpAddress = IPAddress.Loopback; + Assert.Null(AuthEndpoints.CookieRefusal(request, new ServerOptions { TlsMode = TlsMode.Proxy })); + } + [Test] public async Task TheAdminWarnsWhenAPageDidNotComeThroughATrustedProxyOverHttps() { @@ -83,6 +134,24 @@ public sealed class ProxyModeTests(TestContext context) Assert.False((await SettingsAsync(admin, forwardedProto: null)).ProxyWarning); } + /// + /// Runs the server's own forwarded-headers step on a request from that claims to forward a + /// client at 203.0.113.7 over HTTPS: the address and scheme the rest of the server then sees. + /// + private static async Task<(string? Address, bool Https)> ForwardAsync(TestServer server, string peer) + { + var request = new DefaultHttpContext(); + request.Connection.RemoteIpAddress = IPAddress.Parse(peer); + request.Request.Scheme = "http"; + request.Request.Headers["X-Forwarded-For"] = "203.0.113.7"; + request.Request.Headers["X-Forwarded-Proto"] = "https"; + var forwarded = new ForwardedHeadersMiddleware(_ => Task.CompletedTask, NullLoggerFactory.Instance, + server.Services.GetRequiredService>()); + await forwarded.Invoke(request); + var address = request.Connection.RemoteIpAddress; + return ((address is { IsIPv4MappedToIPv6: true } ? address.MapToIPv4() : address)?.ToString(), request.Request.IsHttps); + } + private static bool IsLoopback(string? address) => IPAddress.TryParse(address, out var ip) && IPAddress.IsLoopback(ip.IsIPv4MappedToIPv6 ? ip.MapToIPv4() : ip); diff --git a/tests/Titano.Server.Tests/Hosting/StartupTests.cs b/tests/Titano.Server.Tests/Hosting/StartupTests.cs index a8bde8ef..82475e78 100644 --- a/tests/Titano.Server.Tests/Hosting/StartupTests.cs +++ b/tests/Titano.Server.Tests/Hosting/StartupTests.cs @@ -79,10 +79,12 @@ public sealed class StartupTests(TestContext context) public void TrustedProxiesAreAddressesOrNetworks() { var root = context.CreateTempDirectory("proxies"); + // Loopback only: machines of the home network reach the HTTP port directly from private addresses. var defaults = ServerOptions.Load(new Dictionary { ["TITANO_DATA_PATH"] = root, ["TITANO_DB"] = "postgres" }).TrustedProxyNetworks(); - foreach (var address in new[] { "127.0.0.1", "::1", "10.20.30.40", "172.18.0.3", "192.168.1.2", "fd00::7", "::ffff:172.17.0.2" }) - Assert.True(defaults.Any(n => n.Contains(IPAddress.Parse(address)) || n.Contains(IPAddress.Parse(address).MapToIPv4())), address); - Assert.False(defaults.Any(n => n.Contains(IPAddress.Parse("203.0.113.5")))); + foreach (var address in new[] { "127.0.0.1", "127.0.0.53", "::1" }) + Assert.True(defaults.Any(n => n.Contains(IPAddress.Parse(address))), address); + foreach (var address in new[] { "10.20.30.40", "172.18.0.3", "192.168.1.2", "fd00::7", "203.0.113.5" }) + Assert.False(defaults.Any(n => n.Contains(IPAddress.Parse(address))), address); var options = ServerOptions.Load(new Dictionary {