Add NetLogWriter

Author: HashidaTKS

BrowserGuard.Tests/MessageHandlerTests.cs

@@ -0,0 +1,94 @@
+using System;
+using System.IO;
+using System.Text.Json;
+using BrowserGuard;
+using Xunit;
+
+namespace BrowserGuard.Tests
+{
+    public class MessageHandlerTests : IDisposable
+    {
+        readonly string tempDir;
+
+        public MessageHandlerTests()
+        {
+            tempDir = Path.Combine(Path.GetTempPath(), "browserguard-handler-" + Guid.NewGuid().ToString("N"));
+        }
+
+        public void Dispose()
+        {
+            try { Directory.Delete(tempDir, true); } catch { }
+        }
+
+        string LogPath => Path.Combine(tempDir, "netlog.jsonl");
+
+        // The configuration is handed in so the test does not go through the
+        // registry to find out where it lives.
+        MessageHandler Handler(bool enabled = true) =>
+            new(null, new NetLogFileConfig { Enabled = enabled, Directory = tempDir });
+
+        const string Entry = """{"operation":"browsing","url":"https://example.com/"}""";
+
+        // An entry arrives for every request, so acknowledging each one would
+        // double the traffic over the port.
+        [Fact]
+        public void AnswersNothingWhenAnEntryIsWritten()
+        {
+            var handler = Handler();
+
+            Assert.Null(handler.Handle("L " + Entry));
+
+            var line = Assert.Single(File.ReadAllLines(LogPath));
+            Assert.Equal("browsing", JsonDocument.Parse(line).RootElement
+                .GetProperty("operation").GetString());
+        }
+
+        [Fact]
+        public void WritesEveryEntryItIsGiven()
+        {
+            var handler = Handler();
+
+            handler.Handle("L " + Entry);
+            handler.Handle("L " + Entry);
+            handler.Handle("L " + Entry);
+
+            Assert.Equal(3, File.ReadAllLines(LogPath).Length);
+        }
+
+        [Fact]
+        public void ReportsAnEntryItCannotWrite()
+        {
+            var handler = Handler();
+
+            var response = handler.Handle("L this is not json");
+
+            Assert.NotNull(response);
+            Assert.False(response.Success);
+            Assert.Contains("not valid JSON", response.Error);
+        }
+
+        // Nothing is written and nothing is said, because the browser knows from
+        // the same configuration that it should not be sending these.
+        [Fact]
+        public void StaysSilentWhenLocalLoggingIsTurnedOff()
+        {
+            var handler = Handler(enabled: false);
+
+            Assert.Null(handler.Handle("L " + Entry));
+
+            Assert.False(File.Exists(LogPath));
+        }
+
+        [Fact]
+        public void LeavesTheOtherCommandsAlone()
+        {
+            var handler = Handler();
+
+            // Anything unrecognised still gets a plain acknowledgement.
+            var response = handler.Handle("X something");
+
+            Assert.NotNull(response);
+            Assert.True(response.Success);
+        }
+    }
+}

BrowserGuard.Tests/NetLogWriterTests.cs

@@ -0,0 +1,249 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using BrowserGuard;
+using Xunit;
+
+namespace BrowserGuard.Tests
+{
+    public class NetLogWriterTests : IDisposable
+    {
+        readonly string tempDir;
+
+        public NetLogWriterTests()
+        {
+            tempDir = Path.Combine(Path.GetTempPath(), "browserguard-netlog-" + Guid.NewGuid().ToString("N"));
+        }
+
+        public void Dispose()
+        {
+            try { Directory.Delete(tempDir, true); } catch { }
+        }
+
+        NetLogWriter Writer(int maxSizeMB = 10, int maxGenerations = 10) =>
+            new(new NetLogFileConfig
+            {
+                Enabled = true,
+                Directory = tempDir,
+                MaxSizeMB = maxSizeMB,
+                MaxGenerations = maxGenerations,
+            });
+
+        string LogPath => Path.Combine(tempDir, "netlog.jsonl");
+
+        string GenerationPath(int generation) =>
+            Path.Combine(tempDir, $"netlog_{generation}.jsonl");
+
+        static string Entry(string operation) =>
+            $$"""{"operation":"{{operation}}","url":"https://example.com/"}""";
+
+        [Fact]
+        public void WritesOneLinePerEntry()
+        {
+            var writer = Writer();
+
+            Assert.Null(writer.Write(Entry("browsing")));
+            Assert.Null(writer.Write(Entry("download")));
+
+            var lines = File.ReadAllLines(LogPath);
+            Assert.Equal(2, lines.Length);
+            Assert.Equal("browsing", JsonDocument.Parse(lines[0]).RootElement
+                .GetProperty("operation").GetString());
+            Assert.Equal("download", JsonDocument.Parse(lines[1]).RootElement
+                .GetProperty("operation").GetString());
+        }
+
+        [Fact]
+        public void CreatesTheDirectory()
+        {
+            var writer = new NetLogWriter(new NetLogFileConfig
+            {
+                Enabled = true,
+                Directory = Path.Combine(tempDir, "nested"),
+            });
+
+            Assert.Null(writer.Write(Entry("browsing")));
+
+            Assert.True(File.Exists(Path.Combine(tempDir, "nested", "netlog.jsonl")));
+        }
+
+        // A sender that pretty printed its entry must not break the one line per
+        // entry rule the file depends on.
+        [Fact]
+        public void PutsAPrettyPrintedEntryOnASingleLine()
+        {
+            var writer = Writer();
+
+            writer.Write("{\n  \"operation\": \"browsing\",\n  \"url\": \"https://example.com/\"\n}");
+
+            Assert.Single(File.ReadAllLines(LogPath));
+        }
+
+        [Fact]
+        public void LeavesJapaneseLegible()
+        {
+            var writer = Writer();
+
+            writer.Write("""{"operation":"browsing","name":"ページ名"}""");
+
+            Assert.Contains("ページ名", File.ReadAllText(LogPath));
+        }
+
+        [Fact]
+        public void RefusesSomethingThatIsNotJson()
+        {
+            var writer = Writer();
+
+            var failure = writer.Write("not json at all");
+
+            Assert.Contains("not valid JSON", failure);
+            Assert.False(File.Exists(LogPath));
+        }
+
+        // A bare string or number is valid JSON but not a log entry.
+        [Fact]
+        public void RefusesJsonThatIsNotAnObject()
+        {
+            var writer = Writer();
+
+            Assert.Contains("not a JSON object", writer.Write("\"browsing\""));
+            Assert.Contains("not a JSON object", writer.Write("[1,2,3]"));
+            Assert.False(File.Exists(LogPath));
+        }
+
+        [Fact]
+        public void KeepsTheEarlierEntriesWhenItRotates()
+        {
+            var writer = Writer(maxSizeMB: 1);
+            var padding = new string('a', 200_000);
+
+            // Six entries of 200KB take the file past the one megabyte limit.
+            for (var i = 0; i < 6; i++)
+            {
+                writer.Write($$"""{"operation":"browsing","name":"{{padding}}"}""");
+            }
+            writer.Write(Entry("after"));
+
+            Assert.True(File.Exists(GenerationPath(1)), "the log should have been moved aside");
+            var kept = File.ReadAllLines(GenerationPath(1));
+            Assert.Equal(6, kept.Length);
+            Assert.Equal("after", JsonDocument.Parse(File.ReadAllLines(LogPath)[0]).RootElement
+                .GetProperty("operation").GetString());
+        }
+
+        [Fact]
+        public void KeepsTheGenerationsBesideTheLog()
+        {
+            var writer = Writer(maxSizeMB: 1, maxGenerations: 2);
+            var padding = new string('a', 600_000);
+
+            for (var i = 0; i < 8; i++)
+            {
+                writer.Write($$"""{"operation":"browsing","name":"{{padding}}"}""");
+            }
+
+            var kept = Directory.GetFiles(tempDir)
+                .Select(Path.GetFileName)
+                .OrderBy(name => name, StringComparer.Ordinal)
+                .ToArray();
+            Assert.Equal(
+                new[] { "netlog.jsonl", "netlog_1.jsonl", "netlog_2.jsonl" },
+                kept);
+        }
+
+        [Fact]
+        public void DiscardsTheLogWhenNoGenerationIsKept()
+        {
+            var writer = Writer(maxSizeMB: 1, maxGenerations: 0);
+            var padding = new string('a', 600_000);
+
+            for (var i = 0; i < 4; i++)
+            {
+                writer.Write($$"""{"operation":"browsing","name":"{{padding}}"}""");
+            }
+
+            Assert.Equal(new[] { "netlog.jsonl" },
+                Directory.GetFiles(tempDir).Select(Path.GetFileName).ToArray());
+        }
+
+        // The browser can be killed at any moment, so nothing may sit in a buffer.
+        [Fact]
+        public void LeavesNothingUnwrittenBetweenEntries()
+        {
+            var writer = Writer();
+
+            writer.Write(Entry("browsing"));
+
+            Assert.Single(File.ReadAllLines(LogPath));
+        }
+
+        // The log is collected while the browser is running. Holding the file
+        // open would block anything that opens it the ordinary way, which is
+        // what File.ReadAllText, copy and Notepad all do.
+        [Fact]
+        public void LeavesTheLogReadableByAnOrdinaryReader()
+        {
+            var writer = Writer();
+            writer.Write(Entry("browsing"));
+
+            using var reader = new FileStream(
+                LogPath, FileMode.Open, FileAccess.Read, FileShare.Read);
+
+            Assert.NotEqual(0, reader.Length);
+        }
+
+        // The reader locks writers out for as long as it holds the file, so an
+        // entry that arrives during a collection has to wait rather than be lost.
+        [Fact]
+        public void WaitsForAReaderRatherThanLosingTheEntry()
+        {
+            var writer = Writer();
+            writer.Write(Entry("browsing"));
+
+            using (var held = new FileStream(
+                LogPath, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+                var releasing = Task.Run(() =>
+                {
+                    Thread.Sleep(150);
+                    held.Dispose();
+                });
+
+                Assert.Null(writer.Write(Entry("download")));
+                releasing.Wait();
+            }
+
+            Assert.Equal(2, File.ReadAllLines(LogPath).Length);
+        }
+
+        [Fact]
+        public void ReportsAFailureRatherThanThrowing()
+        {
+            // A file where the directory has to go, so it can never be created.
+            Directory.CreateDirectory(tempDir);
+            var blocked = Path.Combine(tempDir, "blocked");
+            File.WriteAllText(blocked, "x");
+            var writer = new NetLogWriter(new NetLogFileConfig
+            {
+                Enabled = true,
+                Directory = blocked,
+            });
+
+            Assert.NotNull(writer.Write(Entry("browsing")));
+        }
+
+        [Fact]
+        public void FallsBackToProgramDataWhenNoDirectoryIsGiven()
+        {
+            var writer = new NetLogWriter(new NetLogFileConfig { Enabled = true });
+
+            var expected = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
+                "BrowserGuard", "netlog", "netlog.jsonl");
+            Assert.Equal(expected, writer.FilePath);
+        }
+    }
+}

BrowserGuard/BrowserGuard.sample.json

@@ -7,7 +7,13 @@
     "Upload": false,
     "Download": false,
     "Auth": false,
-    "Print": false
+    "Print": false,
+    "LocalFile": {
+      "Enabled": true,
+      "Directory": "C:\\ProgramData\\BrowserGuard\\netlog",
+      "MaxSizeMB": 10,
+      "MaxGenerations": 10
+    }
   },
   "UploadGuard": {
     "Enabled": false,

BrowserGuard/ConfigLoader.cs

@@ -36,6 +36,18 @@ internal class NetLoggerConfig
         public bool Print { get; set; }
         public string UserName { get; set; } = Environment.UserName;
         public string MachineName { get; set; } = Environment.MachineName;
+        public NetLogFileConfig LocalFile { get; set; } = new();
+    }
+
+    // Keeping the log on this machine, as one JSON object per line.
+    internal class NetLogFileConfig
+    {
+        public bool Enabled { get; set; }
+        // Empty means %ProgramData%\BrowserGuard\netlog.
+        public string Directory { get; set; } = "";
+        public int MaxSizeMB { get; set; } = 10;
+        // How many rotated files are kept. 0 discards the log instead.
+        public int MaxGenerations { get; set; } = 10;
     }
 
     // Controls which local files may be uploaded.