Preserve file extensions so msix can be signed, and fail when signing does not happen

TownSuite.CodeSigning.Client/SigningClient.cs

@@ -15,7 +15,7 @@
         private readonly string _url;
         private readonly SemaphoreSlim semaphore = new SemaphoreSlim(4, 4);
         private string batchId;
         public SigningClient(HttpClient client, string baseUrl)
         {
             _client = client;
             _url = baseUrl;
@@ -47,7 +47,7 @@
             batchDetached = detached;
             foreach (string filepath in filepaths)
             {
                 bool failures = false;
                 try
                 {
                     var isHealthy = await HealthCheck();
@@ -96,11 +96,21 @@
             return failedUploads.ToArray();
         }
 
+        private static void AddFileExtensionHeader(HttpRequestMessage request, string filepath)
+        {
+            string extension = Path.GetExtension(filepath);
+            if (!string.IsNullOrEmpty(extension))
+            {
+                request.Headers.Add("X-FileExtension", extension);
+            }
+        }
+
         private async Task SendRequest(bool quickFail, bool ignoreFailures, List<(string FailedFile, string Message)> failedUploads, string filepath, HttpRequestMessage request)
         {
             try
             {
                 await semaphore.WaitAsync();
+                AddFileExtensionHeader(request, filepath);
                 using var fs = File.OpenRead(filepath);
                 request.Content = new StreamContent(fs);
                 Console.WriteLine($"Uploading file: {filepath}");
@@ -151,12 +161,21 @@
                 }
                 foreach (var file in results.Failures)
                 {
-                    TrackedFiles.Remove(TrackedFiles.First(x => x.FilePath == file.FailedFile));
+                    var tracked = TrackedFiles.FirstOrDefault(x => x.FilePath == file.FailedFile);
+                    if (tracked.FilePath is not null) TrackedFiles.Remove(tracked);
                 }
                 await Task.Delay(1000);
                 count++;
             }
 
+            foreach (var file in TrackedFiles.ToArray())
+            {
+                string message = $"Timed out after {batchTimeoutInSeconds} seconds waiting for the signing service to return a signed file.";
+                failedUploads.Add((file.FilePath, message));
+                Console.WriteLine($"Timed out waiting for: {file.FilePath}");
+            }
+            TrackedFiles.Clear();
+
             return failedUploads.ToArray();
         }
 
@@ -178,6 +197,7 @@
 
                 var request = new HttpRequestMessage(HttpMethod.Get, pollUrl);
                 request.Headers.Add("X-BatchId", batchId);
+                AddFileExtensionHeader(request, file.FilePath);
                 if (batchDetached) request.Headers.Add("X-Detached", "true");
 
                 var response = await _client.SendAsync(request);

TownSuite.CodeSigning.ClientTests/SigningClientTimeoutTest.cs

@@ -0,0 +1,114 @@
+using NUnit.Framework;
+using System.Net;
+using TownSuite.CodeSigning.Client;
+
+namespace TownSuite.CodeSigning.ClientTests
+{
+    [TestFixture]
+    public class SigningClientTimeoutTest
+    {
+        private string _tempDir = string.Empty;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(_tempDir);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            try
+            {
+                if (Directory.Exists(_tempDir)) Directory.Delete(_tempDir, true);
+            }
+            catch { }
+        }
+
+        private sealed class NeverReadyHandler : HttpMessageHandler
+        {
+            public int PollCount;
+            public readonly List<string?> UploadExtensionHeaders = new();
+            public readonly List<string?> PollExtensionHeaders = new();
+
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+            {
+                string path = request.RequestUri!.AbsolutePath;
+
+                if (request.Method == HttpMethod.Get && path == "/healthz")
+                {
+                    return Respond(HttpStatusCode.OK, "Healthy");
+                }
+                if (request.Method == HttpMethod.Post && path == "/sign/batch")
+                {
+                    UploadExtensionHeaders.Add(ReadExtension(request));
+                    return Respond(HttpStatusCode.OK, $"\"{Guid.NewGuid()}\"");
+                }
+                if (request.Method == HttpMethod.Get && path == "/sign/batch")
+                {
+                    PollExtensionHeaders.Add(ReadExtension(request));
+                    Interlocked.Increment(ref PollCount);
+                    return Respond((HttpStatusCode)425, "The file has not been signed yet");
+                }
+
+                return Respond(HttpStatusCode.NotFound, string.Empty);
+            }
+
+            private static string? ReadExtension(HttpRequestMessage request) =>
+                request.Headers.TryGetValues("X-FileExtension", out var values) ? values.FirstOrDefault() : null;
+
+            private static Task<HttpResponseMessage> Respond(HttpStatusCode code, string body) =>
+                Task.FromResult(new HttpResponseMessage(code) { Content = new StringContent(body) });
+        }
+
+        private static (SigningClient Client, NeverReadyHandler Handler) Build()
+        {
+            var handler = new NeverReadyHandler();
+            var httpClient = new HttpClient(handler);
+            return (new SigningClient(httpClient, "http://localhost:5000/sign"), handler);
+        }
+
+        [Test]
+        public async Task ServiceNeverReturnsSignedFile_TimeoutIsReportedAsFailure()
+        {
+            string filePath = Path.Combine(_tempDir, "installer.msix");
+            File.WriteAllBytes(filePath, new byte[] { 1, 2, 3 });
+
+            var (client, handler) = Build();
+
+            var uploadFailures = await client.UploadFiles(quickFail: false, ignoreFailures: false, new[] { filePath }, detached: false);
+            Assert.That(uploadFailures, Is.Empty, "upload should succeed against the fake service");
+
+            var failures = await client.DownloadSignedFiles(quickFail: false, ignoreFailures: false, batchTimeoutInSeconds: 2);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(handler.PollCount, Is.GreaterThan(0), "the client should have polled at least once");
+                Assert.That(failures, Has.Length.EqualTo(1));
+                Assert.That(failures[0].FailedFile, Is.EqualTo(filePath));
+                Assert.That(failures[0].Message, Does.Contain("Timed out"));
+            });
+        }
+
+        [Test]
+        public async Task OriginalExtensionIsSentOnUploadAndPoll()
+        {
+            string filePath = Path.Combine(_tempDir, "installer.msix");
+            File.WriteAllBytes(filePath, new byte[] { 1, 2, 3 });
+
+            var (client, handler) = Build();
+
+            await client.UploadFiles(quickFail: false, ignoreFailures: false, new[] { filePath }, detached: false);
+            await client.DownloadSignedFiles(quickFail: false, ignoreFailures: false, batchTimeoutInSeconds: 2);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(handler.UploadExtensionHeaders, Is.Not.Empty);
+                Assert.That(handler.UploadExtensionHeaders, Has.All.EqualTo(".msix"));
+                Assert.That(handler.PollExtensionHeaders, Is.Not.Empty);
+                Assert.That(handler.PollExtensionHeaders, Has.All.EqualTo(".msix"));
+            });
+        }
+    }
+}

TownSuite.CodeSigning.Service/BatchedSigning.cs

@@ -2,11 +2,31 @@
 using Microsoft.Extensions.Primitives;
 using System.Collections;
 using System.Runtime.InteropServices;
+using System.Text.RegularExpressions;
 
 namespace TownSuite.CodeSigning.Service
 {
     public static class BatchedSigning
     {
+        private static readonly Regex SafeExtension = new(@"^\.[A-Za-z0-9]{1,15}$", RegexOptions.Compiled);
+
+        public static string GetSanitizedExtension(StringValues fileExtension)
+        {
+            string value = fileExtension.ToString();
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return string.Empty;
+            }
+
+            value = value.Trim();
+            if (!value.StartsWith('.'))
+            {
+                value = "." + value;
+            }
+
+            return SafeExtension.IsMatch(value) ? value.ToLowerInvariant() : string.Empty;
+        }
+
         public static string GetTempFolder()
         {
             string? envTemp = Environment.GetEnvironmentVariable("TOWNSUITE_CODESIGNING_TEMP");
@@ -22,12 +42,14 @@
         {
             headers.TryGetValue("X-BatchId", out var batchId);
             headers.TryGetValue("X-BatchReady", out var batchReady);
+            headers.TryGetValue("X-FileExtension", out var fileExtension);
             bool isBatchJob = VerifyBatchId(batchId);
 
             string id = Guid.NewGuid().ToString();
+            string extension = GetSanitizedExtension(fileExtension);
 
             var workingFolder = new DirectoryInfo(Path.Combine(GetTempFolder(), isBatchJob ? batchId : id));
-            string workingFilePath = System.IO.Path.Combine(workingFolder.FullName, $"{id}.workingfile");
+            string workingFilePath = System.IO.Path.Combine(workingFolder.FullName, $"{id}.workingfile{extension}");
             try
             {
                 workingFolder.CreateIfNotExists();
@@ -46,7 +68,7 @@
                 else if (isBatchJob && !string.IsNullOrWhiteSpace(batchReady))
                 {
                     var files = GetBatchFiles(workingFolder);
                     ProcessFile(signer, logger, batchId, workingFolder, files);
                 }
 
                 return Results.Ok(id);
@@ -109,14 +131,20 @@
 
         private static string[] GetBatchFiles(DirectoryInfo workingFolder)
         {
-            return workingFolder.GetFiles("*.workingfile").Where(p => p.Length>0).Select(p => p.Name).ToArray();
+            return workingFolder.GetFiles("*.workingfile*")
+                .Where(p => p.Length > 0)
+                .Where(p => !p.Name.EndsWith(".sig", StringComparison.OrdinalIgnoreCase))
+                .Select(p => p.Name)
+                .ToArray();
         }
 
         public static async Task<IResult> Get(Dictionary<string, StringValues> headers, string id, ISigner signer)
         {
             headers.TryGetValue("X-BatchId", out var batchId);
+            headers.TryGetValue("X-FileExtension", out var fileExtension);
             bool isBatchJob = VerifyBatchId(batchId);
 
+            string extension = GetSanitizedExtension(fileExtension);
             var workingFolder = new DirectoryInfo(Path.Combine(GetTempFolder(), isBatchJob ? batchId : id));
 
             if (!workingFolder.Exists)
@@ -127,19 +155,32 @@
             string signedFilesIndicator = isBatchJob ? $"{batchId}.signed" : $"{id}.signed";
             if (System.IO.File.Exists(System.IO.Path.Combine(workingFolder.FullName, signedFilesIndicator)))
             {
-                var workingFile = System.IO.Path.Combine(workingFolder.FullName, signer.GetFileName(id));
+                var workingFile = System.IO.Path.Combine(workingFolder.FullName, signer.GetFileName(id, extension));
                 var workingStream = new TempFileStream(workingFile, !isBatchJob ? workingFolder : null);
                 return Results.Stream(workingStream);
             }
 
-            if (System.IO.File.Exists(System.IO.Path.Combine(workingFolder.FullName, $"{id}.error")))
+            string? errorFile = FindErrorFile(workingFolder, isBatchJob ? batchId.ToString() : null, id);
+            if (errorFile is not null)
             {
-                return Results.Problem(title: "Failure to sign", detail: await File.ReadAllTextAsync(System.IO.Path.Combine(workingFolder.FullName, $"{id}.error")), statusCode: 500);
+                return Results.Problem(title: "Failure to sign", detail: await File.ReadAllTextAsync(errorFile), statusCode: 500);
             }
 
             return Results.Problem(title: "Not Signed", detail: "The file has not been signed yet", statusCode: 425);
         }
 
+        private static string? FindErrorFile(DirectoryInfo workingFolder, string? batchId, string id)
+        {
+            var candidates = new[] { $"{id}.error", batchId is null ? null : $"{batchId}.error" };
+            foreach (var candidate in candidates)
+            {
+                if (candidate is null) continue;
+                string path = System.IO.Path.Combine(workingFolder.FullName, candidate);
+                if (System.IO.File.Exists(path)) return path;
+            }
+            return null;
+        }
+
         static void CleanupDir(DirectoryInfo dir, ILogger logger)
         {
             try

TownSuite.CodeSigning.Service/ISigner.cs

@@ -3,6 +3,6 @@
     public interface ISigner
     {
         Task<(bool IsSigned, string Message)> SignAsync(string workingDir, string[] files);
-        string GetFileName(string id);
+        string GetFileName(string id, string extension);
     }
 }

TownSuite.CodeSigning.Service/Signer.cs

@@ -104,9 +104,9 @@ private string MessageSnapshot()
             return (p.ExitCode == 0, output);
         }
 
-        public string GetFileName(string id)
+        public string GetFileName(string id, string extension)
         {
-            return $"{id}.workingfile";
+            return $"{id}.workingfile{extension}";
         }
 
         private void process_ErrorDataReceived(object sender, DataReceivedEventArgs e)

TownSuite.CodeSigning.Service/SignerDetached.cs

@@ -201,14 +201,14 @@ private void CleanupOriginalFiles(string workingDir, string[] files)
             }
         }
 
-        public string GetFileName(string id)
+        public string GetFileName(string id, string extension)
         {
             if (string.IsNullOrWhiteSpace(_settings.OpenSSL.OsslSignCodePath) || string.IsNullOrWhiteSpace(_settings.OpenSSL.TimestampOptions))
             {
-                return $"{id}.workingfile.sig";
+                return $"{id}.workingfile{extension}.sig";
             }
 
-            return $"{id}.workingfile.timestamped.sig";
+            return $"{id}.workingfile{extension}.timestamped.sig";
         }
 
         private void process_ErrorDataReceived(object sender, DataReceivedEventArgs e)

TownSuite.CodeSigning.Tests/BatachedDetachedSignatureTest.cs

@@ -59,7 +59,7 @@ public async Task Test1(string[] srcFiles)
                 {
                     var signer = new SignerDetached(settings, NSubstitute.Substitute.For<ILogger<SignerDetached>>());
                     string id = ids[i];
-                    string signaturePath = Path.Combine(AppContext.BaseDirectory, signer.GetFileName(id));
+                    string signaturePath = Path.Combine(AppContext.BaseDirectory, signer.GetFileName(id, string.Empty));
                     var dr = await BatchedSigning.Get(new Dictionary<string, Microsoft.Extensions.Primitives.StringValues>(), id, signer);
 
                     if (dr is Microsoft.AspNetCore.Http.HttpResults.FileStreamHttpResult streamResult)
@@ -96,7 +96,7 @@ public async Task Test1(string[] srcFiles)
                 var id = ids[i];
                 var originalFile = Path.Combine(AppContext.BaseDirectory, srcFiles[i]);
                 var signer = new SignerDetached(settings, NSubstitute.Substitute.For<ILogger<SignerDetached>>());
-                var signatureFile = Path.Combine(AppContext.BaseDirectory, signer.GetFileName(id));
+                var signatureFile = Path.Combine(AppContext.BaseDirectory, signer.GetFileName(id, string.Empty));
 
                 var valid = Certs.ValidateDetachedSignature(originalFile, signatureFile, OneTimeUnitTestSetup.certPath, OneTimeUnitTestSetup.password);
                 if (!valid)