diff --git a/i18n/en/Admin.resx b/i18n/en/Admin.resx index 0933d7a3..d2a47e16 100644 --- a/i18n/en/Admin.resx +++ b/i18n/en/Admin.resx @@ -175,11 +175,14 @@ Sequence created Sequence deleted Sequence edited + Diagnostics exported Server settings User created User deleted User changed Details + Diagnostics + Download a zip with logs, system report, settings and recent failed jobs; passwords and tokens are left out Download Save this log file Nothing recorded yet diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx index a815b5e5..5b582eb1 100644 --- a/i18n/en/Tooltips.resx +++ b/i18n/en/Tooltips.resx @@ -5,7 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Ask the public releases page for a newer version · a few seconds - Zip the logs and an environment report into a folder you choose; settings and passwords are not included + Zip the logs, a system and codec report, settings and recent failed jobs into a folder you choose; passwords, tokens and photos are left out Download the setup, check it against the release's SHA-256 list and show it in Explorer · tens of MB Open the licence in the browser Open the folder with database, settings and logs @@ -136,7 +136,7 @@ Delete spilled frames and cached thumbnails; asks first Database, settings, logs and caches of this PC Server Titano connects to at start; changing it signs out · Enter applies, Esc reverts - Zip the logs and an environment report into a folder you choose + Zip the logs, a system and codec report, settings and recent failed jobs into a folder you choose; passwords, tokens and photos are left out Save every setting as JSON, without the session token File name of each frame, for example {date}_{time}_{n:0000}; the extension is added · Enter applies, Esc reverts Archive folders, for example {year}/{date} {camera}; a slash starts a subfolder · Enter applies, Esc reverts diff --git a/i18n/it/Admin.it.resx b/i18n/it/Admin.it.resx index e1bdb0f1..45da50d6 100644 --- a/i18n/it/Admin.it.resx +++ b/i18n/it/Admin.it.resx @@ -175,11 +175,14 @@ Sequenza creata Sequenza eliminata Sequenza modificata + Diagnostica esportata Impostazioni server Utente creato Utente eliminato Utente modificato Dettagli + Diagnostica + Scarica uno zip con log, rapporto di sistema, impostazioni e attività fallite di recente; password e token restano fuori Scarica Salva questo file di log Ancora nessuna registrazione diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx index 1eba743f..313730a4 100644 --- a/i18n/it/Tooltips.it.resx +++ b/i18n/it/Tooltips.it.resx @@ -5,7 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Chiede alla pagina pubblica delle versioni se ne esiste una più recente · pochi secondi - Comprime i log e un rapporto sull'ambiente in una cartella a tua scelta; impostazioni e password non sono incluse + Comprime log, rapporto su sistema e codec, impostazioni e attività fallite di recente in una cartella a tua scelta; password, token e foto restano fuori Scarica l'installer, lo confronta con l'elenco SHA-256 della versione e lo mostra in Esplora file · decine di MB Apre la licenza nel browser Apri la cartella con database, impostazioni e log @@ -136,7 +136,7 @@ Elimina fotogrammi temporanei e miniature in cache; prima chiede conferma Database, impostazioni, log e cache di questo PC Server a cui Titano si connette all'avvio; cambiarlo chiude l'accesso · Invio applica, Esc annulla - Comprime i log e un rapporto sull'ambiente in una cartella a tua scelta + Comprime log, rapporto su sistema e codec, impostazioni e attività fallite di recente in una cartella a tua scelta; password, token e foto restano fuori Salva tutte le impostazioni in JSON, senza il token di sessione Nome del file di ogni fotogramma, ad esempio {date}_{time}_{n:0000}; l'estensione viene aggiunta · Invio applica, Esc annulla Cartelle dell'archivio, ad esempio {year}/{date} {camera}; la barra crea una sottocartella · Invio applica, Esc annulla diff --git a/src/Titano.App/Infrastructure/DiagnosticsBundle.cs b/src/Titano.App/Infrastructure/DiagnosticsBundle.cs index 1bdb5217..903552ca 100644 --- a/src/Titano.App/Infrastructure/DiagnosticsBundle.cs +++ b/src/Titano.App/Infrastructure/DiagnosticsBundle.cs @@ -1,58 +1,60 @@ using System.Globalization; using System.IO; -using System.IO.Compression; using System.Runtime.InteropServices; using System.Text; +using Titano.App.Settings; +using Titano.Core.Diagnostics; +using Titano.Core.Model; +using Titano.Core.Windows.Codecs; +using Titano.Data; namespace Titano.App.Infrastructure; /// -/// The diagnostics bundle of About and Settings › Advanced (BRIEF §12.9): the log files plus an environment report -/// (versions, OS, runtime, culture, folders), zipped into a folder the user chose. Settings and tokens are not included. +/// The diagnostics bundle of About and Settings › Advanced (BRIEF §12.9, §22 Phase 8): an environment report, the codec +/// and encoder inventory, the settings, the latest failed jobs and the log files, zipped into a folder the user chose. +/// Everything passes through (the saved server token, passwords and keys never leave the +/// PC) and no photo or archive file is ever included. /// public static class DiagnosticsBundle { - /// Writes "Titano diagnostics yyyy-MM-dd HHmm.zip" into and returns its path. - public static Task CreateAsync(AppEnvironment environment, string folder, IEnumerable? extraLines = null, CancellationToken ct = default) => - Task.Run(() => + /// Failed jobs included, newest first. + public const int FailedJobs = 50; + + /// + /// Writes "Titano diagnostics yyyy-MM-dd HHmm.zip" into and returns its path. Call on the UI + /// thread: the settings are captured there; detection and writing run in the background. + /// + public static Task CreateAsync(AppServices services, string folder, IEnumerable? extraLines = null, CancellationToken ct = default) + { + var settings = services.Settings.ToJson(); + var report = Report(services.Environment, extraLines) + DatabaseLine(services.Database); + return Task.Run(async () => { + var failures = services.Database is { } db ? (await db.Jobs.ListAsync(JobState.Failed, FailedJobs, null, ct).ConfigureAwait(false)).Items : []; + var codecs = Codecs(services.Encoders); var path = Path.Combine(folder, $"Titano diagnostics {DateTime.Now.ToString("yyyy-MM-dd HHmm", CultureInfo.InvariantCulture)}.zip"); var temp = path + ".tmp"; - using (var zip = ZipFile.Open(temp, ZipArchiveMode.Create)) + await using (var file = new FileStream(temp, FileMode.Create, FileAccess.Write, FileShare.None)) + using (var bundle = new DiagnosticsArchive(file)) { - var report = zip.CreateEntry("environment.txt", CompressionLevel.Optimal); - using (var writer = new StreamWriter(report.Open(), new UTF8Encoding(false))) - { - writer.Write(Report(environment, extraLines)); - } - if (Directory.Exists(environment.LogDirectory)) - { - foreach (var log in Directory.EnumerateFiles(environment.LogDirectory, "*.log").OrderBy(f => f, StringComparer.Ordinal)) - { - ct.ThrowIfCancellationRequested(); - var entry = zip.CreateEntry("logs/" + Path.GetFileName(log), CompressionLevel.Optimal); - // The current log is open for writing: share the handle instead of copying the file. - using var source = new FileStream(log, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); - using var target = entry.Open(); - source.CopyTo(target); - } - } + bundle.AddText("environment.txt", report); + bundle.AddText("codecs.txt", codecs); + bundle.AddJson("settings.json", settings); + bundle.AddJobs("jobs-failed.json", failures); + bundle.AddLogs(services.Environment.LogDirectory, cancellationToken: ct); } File.Move(temp, path, overwrite: true); return path; }, ct); + } /// Plain-text environment report. public static string Report(AppEnvironment environment, IEnumerable? extraLines = null) { var sb = new StringBuilder(); sb.AppendLine(CultureInfo.InvariantCulture, $"Titano {AppServices.VersionText}"); - sb.AppendLine(CultureInfo.InvariantCulture, $"Created {DateTimeOffset.Now:O}"); - sb.AppendLine(CultureInfo.InvariantCulture, $"OS {RuntimeInformation.OSDescription} ({RuntimeInformation.OSArchitecture})"); - sb.AppendLine(CultureInfo.InvariantCulture, $"Runtime {RuntimeInformation.FrameworkDescription} ({RuntimeInformation.ProcessArchitecture})"); - sb.AppendLine(CultureInfo.InvariantCulture, $"Culture {CultureInfo.CurrentCulture.Name} / UI {CultureInfo.CurrentUICulture.Name}"); - sb.AppendLine(CultureInfo.InvariantCulture, $"Processors {Environment.ProcessorCount}"); - sb.AppendLine(CultureInfo.InvariantCulture, $"Memory {GC.GetGCMemoryInfo().TotalAvailableMemoryBytes / (1024 * 1024)} MB"); + sb.Append(DiagnosticsArchive.SystemReport()); sb.AppendLine(CultureInfo.InvariantCulture, $"Data {environment.DataDirectory} (portable: {environment.IsPortable})"); if (extraLines is not null) { @@ -60,6 +62,38 @@ public static class DiagnosticsBundle } return sb.ToString(); } + + private static string DatabaseLine(TitanoDatabase? database) => + database is null ? "Index not open\n" : string.Create(CultureInfo.InvariantCulture, $"Index schema {database.SchemaVersion}\n"); + + /// Graphics adapter, video encoders, WIC decoders per format and missing Store extensions. + private static string Codecs(IEncoderInventory encoders) + { + var sb = new StringBuilder(); + sb.AppendLine(CultureInfo.InvariantCulture, $"Graphics adapter: {encoders.Adapter() ?? "none"}"); + sb.AppendLine("Encoders:"); + foreach (var e in encoders.Detect()) + { + var size = e.MaxWidth > 0 ? string.Create(CultureInfo.InvariantCulture, $" max {e.MaxWidth}x{e.MaxHeight}") : string.Empty; + sb.AppendLine(CultureInfo.InvariantCulture, $" {e.Codec} · {e.DisplayName} ({(e.Hardware ? "hardware" : "software")}{(e.TenBit ? ", 10-bit" : string.Empty)}{size})"); + } + try + { + var inventory = CodecInventory.Detect(); + sb.AppendLine(CultureInfo.InvariantCulture, $"HEVC decoder: {inventory.HasHevcDecoder}; AV1 decoder: {inventory.HasAv1Decoder}"); + sb.AppendLine("Image formats (WIC):"); + foreach (var f in inventory.Formats) + { + var missing = f.MissingExtensions.Count == 0 ? string.Empty : "; missing " + string.Join(", ", f.MissingExtensions.Select(x => x.ProductName)); + sb.AppendLine(CultureInfo.InvariantCulture, $" {f.Format}: {(f.IsNative ? "native" : f.Decoder is null ? "no decoder" : "preview only")}{(f.Decoder is { } d ? $" ({d.FriendlyName} {d.Version})" : string.Empty)}{missing}"); + } + } + catch (Exception ex) when (ex is COMException or DllNotFoundException or EntryPointNotFoundException or InvalidOperationException) + { + sb.AppendLine("WIC decoders could not be listed: " + ex.Message); + } + return sb.ToString(); + } } /// diff --git a/src/Titano.App/Sections/AboutViewModel.cs b/src/Titano.App/Sections/AboutViewModel.cs index 7d63387a..765cfcab 100644 --- a/src/Titano.App/Sections/AboutViewModel.cs +++ b/src/Titano.App/Sections/AboutViewModel.cs @@ -195,8 +195,15 @@ public sealed class AboutViewModel : SectionViewModel { var folder = Shell.Services.Dialogs.PickFolder(Loc.L("Settings.Advanced.DiagnosticsTitle")); if (folder is null) return; - var path = await DiagnosticsBundle.CreateAsync(Shell.Services.Environment, folder); - Shell.Notify(Loc.L("Settings.Advanced.DiagnosticsDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); + try + { + var path = await DiagnosticsBundle.CreateAsync(Shell.Services, folder); + Shell.Notify(Loc.L("Settings.Advanced.DiagnosticsDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or Titano.Data.DatabaseException) + { + Shell.ReportError(ex); + } } private void RaiseUpdate() diff --git a/src/Titano.App/Sections/SettingsViewModel.cs b/src/Titano.App/Sections/SettingsViewModel.cs index 07b00168..4933f3ef 100644 --- a/src/Titano.App/Sections/SettingsViewModel.cs +++ b/src/Titano.App/Sections/SettingsViewModel.cs @@ -647,9 +647,16 @@ public sealed class SettingsViewModel : SectionViewModel { var folder = Shell.Services.Dialogs.PickFolder(Loc.L("Settings.Advanced.DiagnosticsTitle")); if (folder is null) return; - var extra = Encoders.Select(e => $"Encoder {e.Codec} {e.Row.DisplayName} hardware={e.Row.Hardware} selftest={e.ResultText}"); - var path = await DiagnosticsBundle.CreateAsync(Shell.Services.Environment, folder, extra.ToList()); - Shell.Notify(Loc.L("Settings.Advanced.DiagnosticsDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); + var selfTests = Encoders.Where(e => e.HasResult).Select(e => $"Self-test {e.Codec} {e.Row.DisplayName}: {e.ResultText}").ToList(); + try + { + var path = await DiagnosticsBundle.CreateAsync(Shell.Services, folder, selfTests); + Shell.Notify(Loc.L("Settings.Advanced.DiagnosticsDone"), Path.GetFileName(path), Loc.L("Library.Export.Show"), Loc.L("Tooltips.Library.ShowExport"), () => ShellActions.Reveal(path)); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or DatabaseException) + { + Shell.ReportError(ex); + } } private async Task BackupDatabaseAsync() diff --git a/src/Titano.Core/Diagnostics/DiagnosticsArchive.cs b/src/Titano.Core/Diagnostics/DiagnosticsArchive.cs new file mode 100644 index 00000000..fc16e07e --- /dev/null +++ b/src/Titano.Core/Diagnostics/DiagnosticsArchive.cs @@ -0,0 +1,127 @@ +using System.Globalization; +using System.IO.Compression; +using System.Runtime.InteropServices; +using System.Text; +using System.Text.Json; +using Titano.Core.Model; + +namespace Titano.Core.Diagnostics; + +/// +/// Writes a diagnostics bundle (Settings › Advanced, admin panel › Logs; BRIEF §22 Phase 8): a zip in which every entry +/// passes through . Only what the caller hands over goes in — reports, settings, job +/// failures and the tail of each log — never photos or other user files. +/// +public sealed class DiagnosticsArchive : IDisposable +{ + /// Bytes kept from the end of each log file. + public const long DefaultLogTailBytes = 4L << 20; + + /// Newest log files included. + public const int DefaultLogFiles = 14; + + private readonly ZipArchive _zip; + + /// Writes into (left open). + public DiagnosticsArchive(Stream output) => _zip = new ZipArchive(output, ZipArchiveMode.Create, leaveOpen: true); + + /// Operating system, runtime, processor, memory and culture, one fact per line. + public static string SystemReport() + { + var sb = new StringBuilder(); + sb.AppendLine(CultureInfo.InvariantCulture, $"OS {RuntimeInformation.OSDescription} ({RuntimeInformation.OSArchitecture})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Runtime {RuntimeInformation.FrameworkDescription} ({RuntimeInformation.ProcessArchitecture})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Processors {Environment.ProcessorCount}"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Memory {GC.GetGCMemoryInfo().TotalAvailableMemoryBytes / (1024 * 1024)} MB"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Culture {CultureInfo.CurrentCulture.Name} / UI {CultureInfo.CurrentUICulture.Name}"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Time zone {TimeZoneInfo.Local.Id} (UTC{TimeZoneInfo.Local.GetUtcOffset(DateTime.UtcNow):hh\\:mm})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Created {DateTimeOffset.Now:O}"); + return sb.ToString(); + } + + /// Adds a text entry, scrubbed. + public void AddText(string name, string text) => Write(name, SecretScrubber.ScrubText(text)); + + /// Adds a JSON entry with secret-named values removed and every other string scrubbed. + public void AddJson(string name, string json) => Write(name, SecretScrubber.ScrubJson(json)); + + /// Adds failed jobs (kind, times, attempts, node, error and log tail), scrubbed, as a JSON array. + public void AddJobs(string name, IEnumerable jobs) + { + using var buffer = new MemoryStream(); + using (var w = new Utf8JsonWriter(buffer)) + { + w.WriteStartArray(); + foreach (var job in jobs) + { + w.WriteStartObject(); + w.WriteString("id", job.Id); + w.WriteString("kind", job.Kind.ToString()); + w.WriteString("state", job.State.ToString()); + if (job.TargetLabel is { } target) w.WriteString("target", target); + w.WriteString("created", job.Created); + if (job.Started is { } started) w.WriteString("started", started); + if (job.Finished is { } finished) w.WriteString("finished", finished); + w.WriteNumber("attempts", job.Attempts); + if (job.NodeId is { } node) w.WriteString("node", node); + if (job.Error is { } error) w.WriteString("error", error); + if (job.LogTail is { } log) w.WriteString("log", log); + w.WriteEndObject(); + } + w.WriteEndArray(); + } + Write(name, SecretScrubber.ScrubJson(Encoding.UTF8.GetString(buffer.ToArray()))); + } + + /// + /// Adds the newest files matching under logs/, each cut + /// to its last and scrubbed line by line. Files being written are read through a shared + /// handle; a file that cannot be read becomes a note instead of failing the bundle. + /// + public void AddLogs(string directory, string pattern = "*.log", long tailBytes = DefaultLogTailBytes, int maxFiles = DefaultLogFiles, + CancellationToken cancellationToken = default) + { + if (!Directory.Exists(directory)) return; + var files = new DirectoryInfo(directory).EnumerateFiles(pattern) + .OrderByDescending(f => f.LastWriteTimeUtc).ThenByDescending(f => f.Name, StringComparer.Ordinal) + .Take(maxFiles); + foreach (var file in files) + { + cancellationToken.ThrowIfCancellationRequested(); + var entry = _zip.CreateEntry("logs/" + file.Name, CompressionLevel.Optimal); + using var writer = new StreamWriter(entry.Open(), new UTF8Encoding(false)); + try + { + using var stream = new FileStream(file.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite | FileShare.Delete); + var start = Math.Max(0, stream.Length - tailBytes); + stream.Position = start; + using var reader = new StreamReader(stream, Encoding.UTF8); + // A tail that starts mid-file begins with a partial line. + if (start > 0) + { + reader.ReadLine(); + writer.WriteLine(string.Create(CultureInfo.InvariantCulture, $"[first {start:N0} bytes left out]")); + } + foreach (var line in SecretScrubber.ScrubLines(ReadLines(reader))) writer.WriteLine(line); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + writer.WriteLine("[unreadable: " + ex.Message + "]"); + } + } + } + + public void Dispose() => _zip.Dispose(); + + private void Write(string name, string text) + { + var entry = _zip.CreateEntry(name, CompressionLevel.Optimal); + using var writer = new StreamWriter(entry.Open(), new UTF8Encoding(false)); + writer.Write(text); + } + + private static IEnumerable ReadLines(StreamReader reader) + { + while (reader.ReadLine() is { } line) yield return line; + } +} diff --git a/src/Titano.Core/Diagnostics/SecretScrubber.cs b/src/Titano.Core/Diagnostics/SecretScrubber.cs new file mode 100644 index 00000000..bf614edb --- /dev/null +++ b/src/Titano.Core/Diagnostics/SecretScrubber.cs @@ -0,0 +1,138 @@ +using System.Text.Json; +using System.Text.Json.Nodes; +using System.Text.RegularExpressions; + +namespace Titano.Core.Diagnostics; + +/// +/// Removes secrets from text and JSON before they leave the machine in a diagnostics bundle: passwords, tokens, keys, +/// cookies, authorisation headers, credentials in URLs and connection strings, private-key blocks. It errs towards +/// removing too much: a lost hint costs less than a leaked secret. +/// +public static partial class SecretScrubber +{ + public const string Removed = "[removed]"; + + /// Fragments of property names whose string values are secret (compared without case, '_', '-' or '.'). + private static readonly string[] SecretNames = + ["password", "passwd", "pwd", "secret", "token", "apikey", "accesskey", "privatekey", "signingkey", "credential", "cookie", "authorization", "pfx"]; + + /// True when a setting or header with this name holds a secret. + public static bool IsSecretName(string name) + { + var normalized = string.Concat(name.Where(c => c is not ('_' or '-' or '.'))).ToLowerInvariant(); + return SecretNames.Any(normalized.Contains); + } + + /// + /// The JSON with every secret-named string value replaced and every other string scrubbed as text; numbers and + /// booleans stay (a "TokenLifetimeDays" is no secret). Text that is not JSON is scrubbed as text. + /// + public static string ScrubJson(string json) + { + JsonNode? root; + try + { + root = JsonNode.Parse(json); + } + catch (JsonException) + { + return ScrubText(json); + } + if (root is null) return json; + root = ScrubNode(root, secret: false); + return root.ToJsonString(new JsonSerializerOptions { WriteIndented = true }); + } + + /// Scrubs a block of text (several lines; private-key blocks are removed whole). + public static string ScrubText(string text) => + string.Join('\n', ScrubLines(text.Replace("\r\n", "\n", StringComparison.Ordinal).Split('\n'))); + + /// Scrubs lines one by one, dropping the body of any PEM private-key block. + public static IEnumerable ScrubLines(IEnumerable lines) + { + var inKey = false; + foreach (var line in lines) + { + if (!inKey && line.Contains("-----BEGIN", StringComparison.Ordinal) && line.Contains("PRIVATE KEY", StringComparison.Ordinal)) + { + inKey = !line.Contains("-----END", StringComparison.Ordinal); + yield return "[removed private key]"; + continue; + } + if (inKey) + { + if (line.Contains("-----END", StringComparison.Ordinal)) inKey = false; + continue; + } + yield return ScrubLine(line); + } + } + + /// Scrubs one line of text. + public static string ScrubLine(string line) + { + if (line.Length == 0) return line; + var s = HeaderLine().Replace(line, m => m.Groups["name"].Value + ": " + Removed); + s = AuthScheme().Replace(s, m => m.Groups["scheme"].Value + " " + Removed); + s = UrlCredentials().Replace(s, m => m.Groups["prefix"].Value + Removed + "@"); + s = QueryParameter().Replace(s, m => m.Groups["name"].Value + Removed); + s = NamedValue().Replace(s, m => m.Groups["name"].Value + Removed); + return KnownTokenFormat().Replace(s, Removed); + } + + private static JsonNode ScrubNode(JsonNode node, bool secret) + { + switch (node) + { + case JsonObject obj: + foreach (var name in obj.Select(p => p.Key).ToList()) + { + if (obj[name] is not { } child) continue; + var scrubbed = ScrubNode(child, secret || IsSecretName(name)); + if (!ReferenceEquals(scrubbed, child)) obj[name] = scrubbed; + } + return obj; + case JsonArray array: + for (var i = 0; i < array.Count; i++) + { + if (array[i] is not { } item) continue; + var scrubbed = ScrubNode(item, secret); + if (!ReferenceEquals(scrubbed, item)) array[i] = scrubbed; + } + return array; + case JsonValue value when value.GetValueKind() == JsonValueKind.String: + return JsonValue.Create(secret ? Removed : ScrubText(value.GetValue())); + default: + return node; + } + } + + /// "Authorization: …", "Cookie: …", "Set-Cookie: …": the whole value goes. + [GeneratedRegex(@"(?\b(?:proxy-)?authorization|\bset-cookie|\bcookie|\bx-csrf-token)\s*:\s*\S.*$", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)] + private static partial Regex HeaderLine(); + + /// "Bearer abc…", "Basic dXNl…". + [GeneratedRegex(@"(?\b(?:bearer|basic))\s+[A-Za-z0-9._~+/=-]{6,}", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)] + private static partial Regex AuthScheme(); + + /// "https://user:secret@host" keeps the user name. + [GeneratedRegex(@"(?\b[a-z][a-z0-9+.-]*://[^/\s:@]+:)[^/\s@]+@", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)] + private static partial Regex UrlCredentials(); + + /// "?token=…", "&access_token=…", "&sig=…". + [GeneratedRegex(@"(?[?&](?:token|access_token|refresh_token|api_key|apikey|key|sig|signature|password|code)=)[^&\s#""']+", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)] + private static partial Regex QueryParameter(); + + /// + /// "Password=…", "DbPassword: …", "\"token\": \"…\"", "client_secret=…" (connection strings, settings dumps, JSON in + /// log messages): the value up to the next separator goes (a value an earlier rule already removed is left alone). + /// + [GeneratedRegex(@"(?[A-Za-z0-9_-]*(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|private[_-]?key)[A-Za-z0-9_-]*[""']?\s*[=:]\s*)(?!\[removed\])(?:""[^""]*""|'[^']*'|[^\s;,&""']+)", + RegexOptions.IgnoreCase | RegexOptions.CultureInvariant)] + private static partial Regex NamedValue(); + + /// Self-identifying credentials (GitHub tokens) wherever they appear. + [GeneratedRegex(@"\b(?:gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,})\b", RegexOptions.CultureInvariant)] + private static partial Regex KnownTokenFormat(); +} diff --git a/src/Titano.Server/Admin/web/pages/logs.js b/src/Titano.Server/Admin/web/pages/logs.js index fd097cfc..405fb917 100644 --- a/src/Titano.Server/Admin/web/pages/logs.js +++ b/src/Titano.Server/Admin/web/pages/logs.js @@ -1,4 +1,4 @@ -// Logs (BRIEF §14.8): server log tail and downloads, sign-in log, audit log. +// Logs (BRIEF §14.8): server log tail and downloads, diagnostics bundle, sign-in log, audit log. import { t, has, applyStrings } from "../i18n.js"; import { escapeHtml, attr, formatBytes, formatDateTime, toast, errorText, routeParams } from "../ui.js"; import { pascal } from "../jobs.js"; @@ -44,6 +44,7 @@ export async function render(root, { api, meta, actions }) { +
${escapeHtml(tail.lines.join("\n"))}
diff --git a/src/Titano.Server/Api/DiagnosticsEndpoints.cs b/src/Titano.Server/Api/DiagnosticsEndpoints.cs new file mode 100644 index 00000000..07c7dfe5 --- /dev/null +++ b/src/Titano.Server/Api/DiagnosticsEndpoints.cs @@ -0,0 +1,108 @@ +using System.Globalization; +using System.Text; +using System.Text.Json; +using Titano.Core.Diagnostics; +using Titano.Core.Model; +using Titano.Data; +using Titano.Data.Processing; +using Titano.Server.Configuration; +using Titano.Server.Jobs; +using Titano.Server.Security; + +namespace Titano.Server.Api; + +/// +/// GET /api/v1/server/diagnostics (BRIEF §22 Phase 8; ManageArchive): a zip with the environment report, the +/// effective configuration, the encoders, the latest failed jobs and the server logs. Everything passes through +/// (admin and database passwords, tokens and keys are removed); no archive file is included. +/// +public static class DiagnosticsEndpoints +{ + /// Failed jobs included, newest first. + public const int FailedJobs = 100; + + public static void Map(RouteGroupBuilder api) => + api.MapGet("/server/diagnostics", DownloadAsync).Requires(Permissions.ManageArchive); + + private static async Task DownloadAsync(HttpContext context, Caller caller, TitanoDatabase db, ServerOptions options, ServerState state, + JobEngineHost jobs, AuditLog audit, TimeProvider time, IServiceProvider services) + { + var ct = context.RequestAborted; + var failures = (await db.Jobs.ListAsync(JobState.Failed, FailedJobs, null, ct)).Items; + var report = Report(options, state, jobs, time); + var settings = JsonSerializer.Serialize(options, ServerOptionsJson.Default.ServerOptions); + var encoders = Encoders(services.GetService()); + + // The bundle is built in a self-deleting temporary file: zip writes are synchronous and logs can be large. + var file = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.ReadWrite, FileShare.None, 1 << 16, FileOptions.DeleteOnClose); + try + { + await Task.Run(() => + { + using var bundle = new DiagnosticsArchive(file); + bundle.AddText("environment.txt", report); + bundle.AddJson("settings.json", settings); + bundle.AddText("encoders.txt", encoders); + bundle.AddJobs("jobs-failed.json", failures); + bundle.AddLogs(options.LogPath, cancellationToken: ct); + }, ct); + file.Position = 0; + } + catch + { + await file.DisposeAsync(); + throw; + } + await audit.WriteAsync(caller, context, "server_diagnostics", "server"); + context.Response.Headers.CacheControl = "no-store"; + var name = string.Create(CultureInfo.InvariantCulture, $"titano-server-diagnostics-{time.GetUtcNow():yyyyMMdd-HHmm}.zip"); + return Results.File(file, "application/zip", name); + } + + private static string Report(ServerOptions options, ServerState state, JobEngineHost jobs, TimeProvider time) + { + var sb = new StringBuilder(); + sb.AppendLine(CultureInfo.InvariantCulture, $"Titano Server {SystemEndpoints.Version} ({options.ServerName})"); + sb.Append(DiagnosticsArchive.SystemReport()); + sb.AppendLine(CultureInfo.InvariantCulture, $"Uptime {time.GetUtcNow() - state.StartedAt:d\\.hh\\:mm\\:ss}"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Database {state.Database} ({options.Database})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"TLS {options.TlsMode} {state.TlsFingerprint}"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Workers {jobs.Workers}"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Archive {options.ArchivePath} ({Space(options.ArchivePath)})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Data {options.DataPath} ({Space(options.DataPath)})"); + sb.AppendLine(CultureInfo.InvariantCulture, $"Container {File.Exists("/.dockerenv")}"); + sb.AppendLine("Set by environment: " + string.Join(", ", options.Locked)); + return sb.ToString(); + } + + private static string Encoders(ProcessingService? processing) + { + if (processing is null) return "No processing engine registered.\n"; + var sb = new StringBuilder(); + foreach (var provider in processing.Options.Encoders) + { + foreach (var c in provider.Capabilities) + { + sb.AppendLine(CultureInfo.InvariantCulture, + $"{provider.Name}: {c.Codec} {c.Name} ({(c.Hardware ? "hardware" : "software")}{(c.SupportsTenBit ? ", 10-bit" : string.Empty)}, max {c.MaxWidth}x{c.MaxHeight})"); + } + } + return sb.ToString(); + } + + private static string Space(string path) + { + try + { + if (!Directory.Exists(path)) return "missing"; + var full = Path.GetFullPath(path); + // Windows wants a drive root; Unix accepts any directory and reports the volume it is mounted on. + var drive = new DriveInfo(OperatingSystem.IsWindows() ? Path.GetPathRoot(full)! : full); + return string.Create(CultureInfo.InvariantCulture, $"{drive.AvailableFreeSpace / (1L << 30)} GB free of {drive.TotalSize / (1L << 30)} GB"); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException) + { + return "free space unknown"; + } + } +} diff --git a/src/Titano.Server/Hosting/ServerHost.cs b/src/Titano.Server/Hosting/ServerHost.cs index a06cf32f..baedd368 100644 --- a/src/Titano.Server/Hosting/ServerHost.cs +++ b/src/Titano.Server/Hosting/ServerHost.cs @@ -153,6 +153,7 @@ public static class ServerHost NodeEndpoints.Map(api); ArchiveEndpoints.Map(api); AdminEndpoints.Map(api); + DiagnosticsEndpoints.Map(api); EventEndpoints.Map(api); app.MapFallback("/api/{**path}", (HttpContext context) => ApiErrors.NotFound(context)).AllowAnonymousCaller(); } diff --git a/tests/Titano.App.Tests/Windows/DiagnosticsBundleTests.cs b/tests/Titano.App.Tests/Windows/DiagnosticsBundleTests.cs new file mode 100644 index 00000000..6bb5a4ca --- /dev/null +++ b/tests/Titano.App.Tests/Windows/DiagnosticsBundleTests.cs @@ -0,0 +1,65 @@ +using System.IO; +using System.IO.Compression; +using Titano.App.Infrastructure; +using Titano.App.Settings; +using Titano.Core.Video; +using Titano.Testing; + +namespace Titano.App.Tests.Windows; + +/// The desktop diagnostics bundle: every entry present, the saved server token and passwords never inside. +[WindowsOnly] +public sealed class DiagnosticsBundleTests(TestContext context) +{ + private const string Token = "AQAAANCMnd8BFdERjHoAwE-saved-token"; + + [Test] + public async Task TheBundleCarriesReportsAndLogsButNoSecrets() + { + var environment = AppEnvironment.ForCapture(); + try + { + var settings = new AppSettings { Language = "en", ServerUrl = "https://nas.local:8443", ServerUsername = "alice", ProtectedToken = Token }; + var services = new AppServices(environment, settings, () => { }, new NoDialogs()) { Encoders = new OneEncoder() }; + await File.WriteAllTextAsync(Path.Combine(environment.LogDirectory, "titano-20261002.log"), $"signed in with password={Token}\n"); + + var path = await DiagnosticsBundle.CreateAsync(services, context.CreateTempDirectory(), ["Self-test H.264 Test: passed"]); + + using var zip = ZipFile.OpenRead(path); + var texts = zip.Entries.ToDictionary(e => e.FullName, e => + { + using var reader = new StreamReader(e.Open()); + return reader.ReadToEnd(); + }); + Assert.SequenceEqual(new[] { "codecs.txt", "environment.txt", "jobs-failed.json", "logs/titano-20261002.log", "settings.json" }, + texts.Keys.Order(StringComparer.Ordinal)); + foreach (var (name, text) in texts) Assert.False(text.Contains(Token, StringComparison.Ordinal), $"{name} leaks the token"); + Assert.Contains("Self-test H.264 Test: passed", texts["environment.txt"]); + Assert.Contains("Test encoder", texts["codecs.txt"]); + Assert.Contains("\"ServerUsername\": \"alice\"", texts["settings.json"]); + Assert.Contains("\"ProtectedToken\": \"[removed]\"", texts["settings.json"]); + } + finally + { + environment.DeleteCaptureData(); + } + } + + private sealed class OneEncoder : IEncoderInventory + { + public string? Adapter() => "Test adapter"; + + public IReadOnlyList Detect() => + [new EncoderRow("H.264", "Test encoder", null, EncoderSource.MediaFoundation, true, false, 4096, 2304, VideoCodec.H264)]; + + public Task SelfTestAsync(EncoderRow row, CancellationToken ct) => Task.FromResult(new SelfTestResult(true, 100, null)); + } + + private sealed class NoDialogs : IAppDialogs + { + public string? PickFolder(string title, string? initialFolder = null) => null; + public string? PickJsonFile(string title) => null; + public bool Confirm(ConfirmRequest request) => false; + public bool SignIn(string server, string? username, Func> signIn) => false; + } +} diff --git a/tests/Titano.Core.Tests/Diagnostics/DiagnosticsArchiveTests.cs b/tests/Titano.Core.Tests/Diagnostics/DiagnosticsArchiveTests.cs new file mode 100644 index 00000000..6e9a547e --- /dev/null +++ b/tests/Titano.Core.Tests/Diagnostics/DiagnosticsArchiveTests.cs @@ -0,0 +1,74 @@ +using System.IO.Compression; +using System.Text; +using Titano.Core.Diagnostics; +using Titano.Core.Model; +using Titano.Testing; + +namespace Titano.Core.Tests.Diagnostics; + +public sealed class DiagnosticsArchiveTests(TestContext context) +{ + private const string Secret = "correct-horse-battery"; + + [Test] + public void EveryEntryIsScrubbedAndLogsKeepTheirTail() + { + var logs = context.CreateTempDirectory(); + File.WriteAllText(Path.Combine(logs, "titano-20261001.log"), "old line\nPassword=" + Secret + "\n"); + var big = new StringBuilder(); + for (var i = 0; i < 2_000; i++) big.Append("line ").Append(i).Append(" token: ").Append(Secret).Append('\n'); + File.WriteAllText(Path.Combine(logs, "titano-20261002.log"), big.ToString()); + File.WriteAllText(Path.Combine(logs, "photo.jpg"), "not a log"); + File.SetLastWriteTimeUtc(Path.Combine(logs, "titano-20261001.log"), DateTime.UtcNow.AddDays(-1)); + + using var zip = new MemoryStream(); + using (var bundle = new DiagnosticsArchive(zip)) + { + bundle.AddText("environment.txt", DiagnosticsArchive.SystemReport() + "Server https://admin:" + Secret + "@nas:8443\n"); + bundle.AddJson("settings.json", $$"""{ "ProtectedToken": "{{Secret}}", "Theme": "Dark" }"""); + bundle.AddJobs("jobs-failed.json", + [ + new Job + { + Id = Guid.CreateVersion7(), Kind = JobKind.Render, State = JobState.Failed, Attempts = 2, Created = DateTimeOffset.UtcNow, + Error = "Upload refused: Authorization: Bearer " + Secret, LogTail = "retry with password=" + Secret, + }, + ]); + bundle.AddLogs(logs, tailBytes: 4096); + } + + zip.Position = 0; + using var archive = new ZipArchive(zip, ZipArchiveMode.Read); + var names = archive.Entries.Select(e => e.FullName).Order(StringComparer.Ordinal).ToArray(); + Assert.SequenceEqual(new[] { "environment.txt", "jobs-failed.json", "logs/titano-20261001.log", "logs/titano-20261002.log", "settings.json" }, names); + foreach (var entry in archive.Entries) + { + var text = Read(entry); + Assert.False(text.Contains(Secret, StringComparison.Ordinal), $"{entry.FullName} leaks the secret"); + } + Assert.Contains("Runtime ", Read(archive.GetEntry("environment.txt")!)); + Assert.Contains("\"Theme\": \"Dark\"", Read(archive.GetEntry("settings.json")!)); + Assert.Contains("\"kind\": \"Render\"", Read(archive.GetEntry("jobs-failed.json")!)); + + var tail = Read(archive.GetEntry("logs/titano-20261002.log")!); + Assert.True(tail.StartsWith("[first ", StringComparison.Ordinal), "a cut log says so"); + Assert.Contains("line 1999 token: [removed]", tail); + Assert.Less(tail.Length, 5_000); + } + + [Test] + public void AMissingLogFolderAddsNothing() + { + using var zip = new MemoryStream(); + using (var bundle = new DiagnosticsArchive(zip)) bundle.AddLogs(Path.Combine(context.CreateTempDirectory(), "missing")); + zip.Position = 0; + using var archive = new ZipArchive(zip, ZipArchiveMode.Read); + Assert.Empty(archive.Entries); + } + + private static string Read(ZipArchiveEntry entry) + { + using var reader = new StreamReader(entry.Open(), Encoding.UTF8); + return reader.ReadToEnd(); + } +} diff --git a/tests/Titano.Core.Tests/Diagnostics/SecretScrubberTests.cs b/tests/Titano.Core.Tests/Diagnostics/SecretScrubberTests.cs new file mode 100644 index 00000000..0daa141e --- /dev/null +++ b/tests/Titano.Core.Tests/Diagnostics/SecretScrubberTests.cs @@ -0,0 +1,84 @@ +using System.Text.Json; +using Titano.Core.Diagnostics; +using Titano.Testing; + +namespace Titano.Core.Tests.Diagnostics; + +public sealed class SecretScrubberTests +{ + private const string Secret = "hunter2-S3cr3t!"; + + [Theory] + [Case("Host=db;Port=5432;Username=titano;Password=" + Secret + ";SslMode=prefer", "Host=db;Port=5432;Username=titano;Password=[removed];SslMode=prefer")] + [Case("TITANO_DB_PASSWORD=" + Secret, "TITANO_DB_PASSWORD=[removed]")] + [Case("DbPassword: " + Secret, "DbPassword: [removed]")] + [Case("login body {\"username\":\"alice\",\"password\":\"" + Secret + "\"}", "login body {\"username\":\"alice\",\"password\":[removed]}")] + [Case("Authorization: Bearer " + Secret, "Authorization: [removed]")] + [Case("calling with bearer abcdefghijklmnop", "calling with bearer [removed]")] + [Case("Cookie: titano_session=" + Secret + "; titano_csrf=x", "Cookie: [removed]")] + [Case("git clone https://x-access-token:" + Secret + "@github.com/o/r.git", "git clone https://x-access-token:[removed]@github.com/o/r.git")] + [Case("GET /api/v1/events?token=" + Secret + "&x=1", "GET /api/v1/events?token=[removed]&x=1")] + [Case("client_secret=" + Secret + " refresh_token='" + Secret + "'", "client_secret=[removed] refresh_token=[removed]")] + [Case("pushed with ghp_0123456789abcdefghijABCDEFGHIJ012345", "pushed with [removed]")] + public void SecretsInTextAreRemoved(string line, string expected) => Assert.Equal(expected, SecretScrubber.ScrubLine(line)); + + [Theory] + [Case("2026-10-02T09:00:00Z Info archive: Scan of /archive found 1,204 frames in 12 sequences")] + [Case("Index open (schema 3) at C:\\Users\\alice\\AppData\\Local\\Titano\\titano.db")] + [Case("frame 0193 sha256 4f2a9c0e1b7d3a5f6e8c9b0a1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e verified")] + [Case("Token revoked for user alice")] + [Case("")] + public void OrdinaryLinesAreKept(string line) => Assert.Equal(line, SecretScrubber.ScrubLine(line)); + + [Test] + public void PrivateKeyBlocksAreDroppedWhole() + { + var text = "before\n-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASC\nBKcwggSjAgEAAoIBAQC7\n-----END PRIVATE KEY-----\nafter"; + Assert.Equal("before\n[removed private key]\nafter", SecretScrubber.ScrubText(text)); + } + + [Test] + public void SecretNamedJsonValuesAreRemovedAndOtherStringsScrubbed() + { + var json = $$""" + { + "ServerName": "NAS", + "AdminPassword": "{{Secret}}", + "DbPassword": null, + "DbConnectionString": "Host=db;Password={{Secret}}", + "TokenLifetimeDays": 30, + "ProtectedToken": "AQAAANCMnd8BFdERjHoAwE", + "TrustedCertificates": [ { "Fingerprint": "AB:CD:EF", "Server": "nas" } ], + "Nested": { "api_key": "{{Secret}}", "SigningKeys": [ "{{Secret}}" ], "Credentials": { "User": "alice", "Value": "{{Secret}}" } } + } + """; + var scrubbed = SecretScrubber.ScrubJson(json); + Assert.False(scrubbed.Contains(Secret, StringComparison.Ordinal), scrubbed); + Assert.False(scrubbed.Contains("AQAAANCMnd8BFdERjHoAwE", StringComparison.Ordinal), scrubbed); + + using var doc = JsonDocument.Parse(scrubbed); + var root = doc.RootElement; + Assert.Equal("NAS", root.GetProperty("ServerName").GetString()); + Assert.Equal(SecretScrubber.Removed, root.GetProperty("AdminPassword").GetString()); + Assert.Equal(JsonValueKind.Null, root.GetProperty("DbPassword").ValueKind); + Assert.Equal("Host=db;Password=[removed]", root.GetProperty("DbConnectionString").GetString()); + Assert.Equal(30, root.GetProperty("TokenLifetimeDays").GetInt32()); + Assert.Equal("AB:CD:EF", root.GetProperty("TrustedCertificates")[0].GetProperty("Fingerprint").GetString()); + Assert.Equal(SecretScrubber.Removed, root.GetProperty("Nested").GetProperty("Credentials").GetProperty("User").GetString()); + } + + [Test] + public void TextThatIsNotJsonIsScrubbedAsText() => + Assert.Equal("password=[removed] {", SecretScrubber.ScrubJson("password=" + Secret + " {")); + + [Theory] + [Case("DbPassword", true)] + [Case("SIGN_PFX_BASE64", true)] + [Case("X-Titano-Token", true)] + [Case("set-cookie", true)] + [Case("privateKey", true)] + [Case("ServerName", false)] + [Case("TlsCert", false)] + [Case("SessionKey", false)] + public void SecretNamesAreRecognised(string name, bool secret) => Assert.Equal(secret, SecretScrubber.IsSecretName(name)); +} diff --git a/tests/Titano.Server.Tests/Api/DiagnosticsTests.cs b/tests/Titano.Server.Tests/Api/DiagnosticsTests.cs new file mode 100644 index 00000000..d3e4063e --- /dev/null +++ b/tests/Titano.Server.Tests/Api/DiagnosticsTests.cs @@ -0,0 +1,65 @@ +using System.IO.Compression; +using System.Net; +using System.Text.Json; +using Titano.Core.Model; +using Titano.Testing; + +namespace Titano.Server.Tests.Api; + +[Category("server")] +public sealed class DiagnosticsTests(TestContext context) +{ + private const string DbPassword = "db-secret-pw-42"; + + [Test] + public async Task TheBundleHoldsReportsLogsAndFailuresWithoutSecrets() + { + await using var server = await TestServer.StartAsync(context, o => o.DbPassword = DbPassword); + var admin = await server.AdminAsync(); + Directory.CreateDirectory(server.Options.LogPath); + await File.WriteAllTextAsync(Path.Combine(server.Options.LogPath, "titano-server-test.log"), + $"connecting with Password={DbPassword}\nAuthorization: Bearer {TestServer.Password}\n"); + var job = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Render, State = JobState.Queued, Created = DateTimeOffset.UtcNow }; + await server.Database.Jobs.EnqueueAsync(job); + await server.Database.Jobs.SetStateAsync(job.Id, JobState.Failed, "token=" + DbPassword + " rejected"); + + using var response = await admin.GetAsync("/api/v1/server/diagnostics"); + await response.ExpectAsync(HttpStatusCode.OK); + Assert.Equal("application/zip", response.Content.Headers.ContentType?.MediaType); + await using var body = await response.Content.ReadAsStreamAsync(); + using var zip = new ZipArchive(body, ZipArchiveMode.Read); + var texts = zip.Entries.ToDictionary(e => e.FullName, Read); + + Assert.Contains("environment.txt", texts.Keys); + Assert.Contains("encoders.txt", texts.Keys); + Assert.Contains("logs/titano-server-test.log", texts.Keys); + foreach (var (name, text) in texts) + { + Assert.False(text.Contains(DbPassword, StringComparison.Ordinal), $"{name} leaks the database password"); + Assert.False(text.Contains(TestServer.AdminPassword, StringComparison.Ordinal), $"{name} leaks the admin password"); + Assert.False(text.Contains(TestServer.Password, StringComparison.Ordinal), $"{name} leaks a user password"); + } + Assert.Contains("Titano Server ", texts["environment.txt"]); + using (var settings = JsonDocument.Parse(texts["settings.json"])) + { + Assert.Equal("[removed]", settings.RootElement.GetProperty("DbPassword").GetString()); + Assert.Equal("[removed]", settings.RootElement.GetProperty("AdminPassword").GetString()); + } + using (var failed = JsonDocument.Parse(texts["jobs-failed.json"])) + { + var entry = failed.RootElement.EnumerateArray().Single(); + Assert.Equal(("Render", "token=[removed] rejected"), (entry.GetProperty("kind").GetString(), entry.GetProperty("error").GetString())); + } + + var (viewer, _, _) = await server.UserAsync("vera", "viewer"); + using var refused = await viewer.GetAsync("/api/v1/server/diagnostics"); + await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + Assert.NotEmpty((await server.Database.Audit.ListAsync(null, "server_diagnostics", 10, null)).Items); + } + + private static string Read(ZipArchiveEntry entry) + { + using var reader = new StreamReader(entry.Open()); + return reader.ReadToEnd(); + } +}