Tidying up

src/ChecksumUtil/Program.cs

@@ -100,20 +100,24 @@ namespace ChecksumUtil
             // Signature first, then hash
             using (var checksumFile = File.OpenRead(checksumFileName))
             using (var certificate = File.OpenRead(certificateFileName))
-            using (var cleartext = PgpClearsignUtilities.ReadAndVerifyFile(checksumFile, certificate))
             {
-                if (cleartext == null)
-                    throw new Exception("Signature verification failed");
-
-                using (var hashAlgorithm = HashAlgorithm.Create(algorithmName))
+                Stream cleartext;
+                var passed = PgpClearsignUtilities.ReadAndVerifyFile(checksumFile, certificate, out cleartext);
+                using (cleartext)
                 {
-                    foreach (var inputFileName in inputFileNames)
+                    if (!passed)
+                        throw new Exception("Signature verification failed");
+
+                    using (var hashAlgorithm = HashAlgorithm.Create(algorithmName))
                     {
-                        using (var inputFile = File.OpenRead(inputFileName))
+                        foreach (var inputFileName in inputFileNames)
                         {
-                            var valid = ChecksumFileUtilities.ValidateChecksum(hashAlgorithm, cleartext, Path.GetFileName(inputFileName), inputFile);
-                            if (!valid)
-                                throw new Exception(String.Format("File {0} failed checksum", inputFileName));
+                            using (var inputFile = File.OpenRead(inputFileName))
+                            {
+                                var valid = ChecksumFileUtilities.ValidateChecksum(hashAlgorithm, cleartext, Path.GetFileName(inputFileName), inputFile);
+                                if (!valid)
+                                    throw new Exception(String.Format("File {0} failed checksum", inputFileName));
+                            }
                         }
                     }
                 }

src/SyncTrayzor/Services/UpdateManagement/InstallerCertificateVerifier.cs

@@ -13,7 +13,7 @@ namespace SyncTrayzor.Services.UpdateManagement
 {
     public interface IInstallerCertificateVerifier
     {
-        Stream VerifySha1sum(string filePath);
+        bool VerifySha1sum(string filePath, out Stream cleartext);
         bool VerifyUpdate(string filePath, Stream sha1sumFile);
     }
 
@@ -23,10 +23,12 @@ namespace SyncTrayzor.Services.UpdateManagement
         private const string certificateName = "SyncTrayzor.Resources.synctrayzor_releases_cert.asc";
 
         private readonly IAssemblyProvider assemblyProvider;
+        private readonly IFilesystemProvider filesystemProvider;
 
-        public InstallerCertificateVerifier(IAssemblyProvider assemblyProvider)
+        public InstallerCertificateVerifier(IAssemblyProvider assemblyProvider, IFilesystemProvider filesystemProvider)
         {
             this.assemblyProvider = assemblyProvider;
+            this.filesystemProvider = filesystemProvider;
         }
 
         private Stream LoadCertificate()
@@ -34,19 +36,19 @@ namespace SyncTrayzor.Services.UpdateManagement
             return this.assemblyProvider.GetManifestResourceStream(certificateName);
         }
 
-        public Stream VerifySha1sum(string filePath)
+        public bool VerifySha1sum(string filePath, out Stream cleartext)
         {
-            using (var file = File.OpenRead(filePath))
+            using (var file = this.filesystemProvider.OpenRead(filePath))
             using (var certificate = this.LoadCertificate())
             {
-                return PgpClearsignUtilities.ReadAndVerifyFile(file, certificate);
+                return PgpClearsignUtilities.ReadAndVerifyFile(file, certificate, out cleartext);
             }
         }
 
         public bool VerifyUpdate(string filePath, Stream sha1sumFile)
         {
             using (var hashAlgorithm = new SHA1Managed())
-            using (var file = File.OpenRead(filePath))
+            using (var file = this.filesystemProvider.OpenRead(filePath))
             {
                 return ChecksumFileUtilities.ValidateChecksum(hashAlgorithm, sha1sumFile, Path.GetFileName(filePath), file);
             }

src/SyncTrayzor/Services/UpdateManagement/UpdateDownloader.cs

@@ -43,8 +43,9 @@ namespace SyncTrayzor.Services.UpdateManagement
 
             var sha1sumOutcome = await this.DownloadAndVerifyFileAsync<Stream>(url, version, sha1sumDownloadPath, () =>
                 {
-                    var sha1sumContents = this.installerVerifier.VerifySha1sum(sha1sumDownloadPath);
-                    return Tuple.Create(sha1sumContents != null, sha1sumContents);
+                    Stream sha1sumContents;
+                    var passed = this.installerVerifier.VerifySha1sum(sha1sumDownloadPath, out sha1sumContents);
+                    return Tuple.Create(passed, sha1sumContents);
                 });
 
             // Might be null, but if it's not make sure we dispose it (it's actually a MemoryStream, but let's be proper)

src/SyncTrayzor/Utils/PgpClearsignUtilities.cs

@@ -70,7 +70,7 @@ namespace SyncTrayzor.Utils
             }
         }
 
-        public static Stream ReadAndVerifyFile(Stream inputStream, Stream keyIn)
+        public static bool ReadAndVerifyFile(Stream inputStream, Stream keyIn, out Stream cleartextOut)
         {
             // Disposing this will close the underlying stream, which we don't want to do
             var armouredInputStream = new ArmoredInputStream(inputStream);
@@ -116,10 +116,8 @@ namespace SyncTrayzor.Utils
             }
             cleartextStream.Position = 0;
 
-            if (signature.Verify())
-                return cleartextStream;
-            else
-                return null;
+            cleartextOut = cleartextStream;
+            return signature.Verify();
         }
     }
 }