upload-file-bridge: implement base

Author: HashidaTKS

BrowserGuard.Tests/FileBridgeTests.cs

@@ -0,0 +1,159 @@
+using System;
+using System.IO;
+using BrowserGuard;
+using Xunit;
+
+namespace BrowserGuard.Tests
+{
+    public class FileBridgeTests : IDisposable
+    {
+        readonly string tempDir;
+
+        public FileBridgeTests()
+        {
+            tempDir = Path.Combine(Path.GetTempPath(), "browserguard-bridge-" + Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(tempDir);
+        }
+
+        public void Dispose()
+        {
+            try { Directory.Delete(tempDir, true); } catch { }
+        }
+
+        // A fixed day, so a destination naming the day is the one intended here.
+        static readonly DateTime Now = new(2026, 8, 20, 13, 45, 30);
+
+        string Destination => Path.Combine(tempDir, "audit");
+
+        UploadFileBridgeConfig Config(string? destination = null) =>
+            new() { Enabled = true, Destination = destination ?? Destination };
+
+        // A file of the user's own, standing in for one being uploaded.
+        string Source(string name = "report.xlsx", string content = "hello")
+        {
+            var path = Path.Combine(tempDir, name);
+            File.WriteAllText(path, content);
+            return path;
+        }
+
+        string[] Copies => Directory.Exists(Destination)
+            ? Directory.GetFiles(Destination).Select(Path.GetFileName).OrderBy(name => name).ToArray()!
+            : [];
+
+        [Fact]
+        public void KeepsACopyOfTheFile()
+        {
+            var source = Source(content: "the contents");
+
+            var failure = FileBridge.Copy(Config(), source, Now);
+
+            Assert.Null(failure);
+            Assert.Equal("the contents", File.ReadAllText(Path.Combine(Destination, "report.xlsx")));
+        }
+
+        // The destination is on a file server that may have nothing on it yet.
+        [Fact]
+        public void MakesTheDestinationWhenItIsNotThere()
+        {
+            Assert.False(Directory.Exists(Destination));
+
+            FileBridge.Copy(Config(), Source(), Now);
+
+            Assert.True(Directory.Exists(Destination));
+        }
+
+        [Fact]
+        public void ExpandsTheMacrosInTheDestination()
+        {
+            var config = Config(Path.Combine(tempDir, "%DATE%", "%PCNAME%"));
+
+            var failure = FileBridge.Copy(config, Source(), Now);
+
+            Assert.Null(failure);
+            var expected = Path.Combine(tempDir, "2026-08-20", Environment.MachineName, "report.xlsx");
+            Assert.True(File.Exists(expected), $"not found: {expected}");
+        }
+
+        // Nothing that was uploaded may be lost to something uploaded later.
+        [Fact]
+        public void NumbersACopyRatherThanOverwriteOne()
+        {
+            FileBridge.Copy(Config(), Source(content: "first"), Now);
+            FileBridge.Copy(Config(), Source(content: "second"), Now);
+
+            Assert.Equal(["report_2.xlsx", "report.xlsx"], Copies);
+            Assert.Equal("first", File.ReadAllText(Path.Combine(Destination, "report.xlsx")));
+            Assert.Equal("second", File.ReadAllText(Path.Combine(Destination, "report_2.xlsx")));
+        }
+
+        [Fact]
+        public void KeepsNumberingBeyondTheSecond()
+        {
+            for (var time = 0; time < 4; time++)
+            {
+                FileBridge.Copy(Config(), Source(content: $"copy {time}"), Now);
+            }
+
+            Assert.Equal(
+                ["report_2.xlsx", "report_3.xlsx", "report_4.xlsx", "report.xlsx"],
+                Copies);
+        }
+
+        // The number goes before the extension, so the copy still opens.
+        [Fact]
+        public void KeepsTheExtensionOnANumberedCopy()
+        {
+            FileBridge.Copy(Config(), Source("notes.tar.gz"), Now);
+            FileBridge.Copy(Config(), Source("notes.tar.gz"), Now);
+
+            Assert.Equal(["notes.tar_2.gz", "notes.tar.gz"], Copies);
+        }
+
+        [Fact]
+        public void CopiesAFileWithNoExtension()
+        {
+            FileBridge.Copy(Config(), Source("LICENSE"), Now);
+            FileBridge.Copy(Config(), Source("LICENSE"), Now);
+
+            Assert.Equal(["LICENSE", "LICENSE_2"], Copies);
+        }
+
+        // Nothing is copied off the machine unless it was asked for.
+        [Fact]
+        public void CopiesNothingWhileDisabled()
+        {
+            var config = Config();
+            config.Enabled = false;
+
+            var failure = FileBridge.Copy(config, Source(), Now);
+
+            Assert.Null(failure);
+            Assert.False(Directory.Exists(Destination));
+        }
+
+        [Fact]
+        public void ReportsThatThereIsNowhereToPutIt()
+        {
+            var failure = FileBridge.Copy(Config(""), Source(), Now);
+
+            Assert.NotNull(failure);
+        }
+
+        [Fact]
+        public void ReportsAFileThatIsNotThere()
+        {
+            var failure = FileBridge.Copy(Config(), Path.Combine(tempDir, "gone.xlsx"), Now);
+
+            Assert.NotNull(failure);
+            Assert.Contains("gone.xlsx", failure);
+        }
+
+        [Fact]
+        public void ReportsAPathItCannotUse()
+        {
+            var failure = FileBridge.Copy(Config(), "", Now);
+
+            Assert.NotNull(failure);
+        }
+    }
+}

BrowserGuard/FileBridge.cs

@@ -1,12 +1,88 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace BrowserGuard
-{
-    internal class FileBridge
-    {
-    }
-}
+using System;
+using System.IO;
+
+namespace BrowserGuard
+{
+    // Keeps a copy of a file the browser uploaded, as evidence of what left the
+    // machine. The browser only knows the path of the file it sent, so the copy
+    // is made here.
+    internal static class FileBridge
+    {
+        // Beyond this something is wrong with the destination rather than with
+        // the name, so it stops rather than counting for ever.
+        private const int MaxNumbered = 1000;
+
+        // null when the copy was made, or when there was nothing to do.
+        // Otherwise why it could not be made.
+        internal static string? Copy(
+            UploadFileBridgeConfig config, string source, DateTime now, Logger? logger = null)
+        {
+            if (!config.Enabled)
+            {
+                return null;
+            }
+            if (string.IsNullOrWhiteSpace(config.Destination))
+            {
+                return "no destination is configured";
+            }
+            if (string.IsNullOrWhiteSpace(source))
+            {
+                return "no file to copy";
+            }
+
+            // Expanded now rather than when the config was read, because a
+            // destination naming the day changes at midnight.
+            var destination = PathMacro.Expand(config.Destination, now);
+            try
+            {
+                Directory.CreateDirectory(destination);
+            }
+            catch (Exception ex)
+            {
+                return $"cannot create {destination}: {ex.Message}";
+            }
+
+            try
+            {
+                var copied = CopyWithoutOverwriting(source, destination);
+                logger?.Log($"UploadFileBridge: copied {source} to {copied}");
+                return null;
+            }
+            catch (Exception ex)
+            {
+                return $"cannot copy {source} to {destination}: {ex.Message}";
+            }
+        }
+
+        // A file that is already there is numbered: "report.xlsx", then
+        // "report_2.xlsx". The copy refuses to overwrite, so a name taken
+        // between the check and the copy is simply passed over.
+        private static string CopyWithoutOverwriting(string source, string destination)
+        {
+            var name = Path.GetFileNameWithoutExtension(source);
+            var extension = Path.GetExtension(source);
+
+            for (var number = 1; number <= MaxNumbered; number++)
+            {
+                var candidate = Path.Combine(
+                    destination,
+                    number == 1 ? $"{name}{extension}" : $"{name}_{number}{extension}");
+                if (File.Exists(candidate))
+                {
+                    continue;
+                }
+                try
+                {
+                    File.Copy(source, candidate, overwrite: false);
+                    return candidate;
+                }
+                catch (IOException) when (File.Exists(candidate))
+                {
+                    // Taken since it was looked at, so the next number is tried.
+                }
+            }
+            throw new IOException(
+                $"{name}{extension} is already there {MaxNumbered} times over");
+        }
+    }
+}

BrowserGuard/MessageHandler.cs

@@ -79,6 +79,14 @@ internal MessageHandler(
                 var failures = StartupLauncher.Run(config.StartupLauncher, logger);
                 return new Response { Success = failures is null, Error = failures };
             }
+            // "U " keep a copy of the file the browser is uploading.
+            else if (message.StartsWith("U "))
+            {
+                logger?.Log("Command: bridge upload");
+                var failure = FileBridge.Copy(
+                    config.UploadFileBridge, message[2..].Trim(), DateTime.Now, logger);
+                return new Response { Success = failure is null, Error = failure };
+            }
 
             return new Response { Success = true };
         }