Patch 283 (DynamoDS#10421)

* Add WinVerityTrust wrapper

* Utilzie new WinTrustWrapper method for cert verification

* Add negative test

* Add Package with faked certificate

* Create sub namespace for WinVerityInteropp

* Update the WinTrustInterop

* Upate method call name

* Add specific exceptions to the CertificateVerfication class

* formating

(cherry picked from commit 7b93efe)

Author: saintentropy

src/DynamoUtilities/CertificateVerification.cs

@@ -3,12 +3,194 @@
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace DynamoUtilities
 {
+    internal sealed class WinTrustInterop
+    {
+        #region WinTrustData struct field enums
+        enum WinTrustDataUIChoice : uint
+        {
+            All = 1,
+            None = 2,
+            NoBad = 3,
+            NoGood = 4
+        }
+
+        enum WinTrustDataRevocationChecks : uint
+        {
+            None = 0x00000000,
+            WholeChain = 0x00000001
+        }
+
+        enum WinTrustDataChoice : uint
+        {
+            File = 1,
+            Catalog = 2,
+            Blob = 3,
+            Signer = 4,
+            Certificate = 5
+        }
+
+        enum WinTrustDataStateAction : uint
+        {
+            Ignore = 0x00000000,
+            Verify = 0x00000001,
+            Close = 0x00000002,
+            AutoCache = 0x00000003,
+            AutoCacheFlush = 0x00000004
+        }
+
+        [FlagsAttribute]
+        enum WinTrustDataProvFlags : uint
+        {
+            UseIe4TrustFlag = 0x00000001,
+            NoIe4ChainFlag = 0x00000002,
+            NoPolicyUsageFlag = 0x00000004,
+            RevocationCheckNone = 0x00000010,
+            RevocationCheckEndCert = 0x00000020,
+            RevocationCheckChain = 0x00000040,
+            RevocationCheckChainExcludeRoot = 0x00000080,
+            SaferFlag = 0x00000100,        // Used by software restriction policies. Should not be used.
+            HashOnlyFlag = 0x00000200,
+            UseDefaultOsverCheck = 0x00000400,
+            LifetimeSigningFlag = 0x00000800,
+            CacheOnlyUrlRetrieval = 0x00001000,      // affects CRL retrieval and AIA retrieval
+            DisableMD2andMD4 = 0x00002000      // Win7 SP1+: Disallows use of MD2 or MD4 in the chain except for the root 
+        }
+
+        enum WinTrustDataUIContext : uint
+        {
+            Execute = 0,
+            Install = 1
+        }
+        #endregion
+
+        #region WinTrust structures
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        class WinTrustFileInfo
+        {
+            UInt32 StructSize = (UInt32)Marshal.SizeOf(typeof(WinTrustFileInfo));
+            IntPtr pszFilePath;                     // required, file name to be verified
+            IntPtr hFile = IntPtr.Zero;             // optional, open handle to FilePath
+            IntPtr pgKnownSubject = IntPtr.Zero;    // optional, subject type if it is known
+
+            public WinTrustFileInfo(String _filePath)
+            {
+                pszFilePath = Marshal.StringToCoTaskMemAuto(_filePath);
+            }
+            public void Dispose()
+            {
+                if(pszFilePath != IntPtr.Zero) {
+                    Marshal.FreeCoTaskMem(pszFilePath);
+                    pszFilePath = IntPtr.Zero;
+                }
+            }
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        class WinTrustData
+        {
+            UInt32 StructSize = (UInt32)Marshal.SizeOf(typeof(WinTrustData));
+            IntPtr PolicyCallbackData = IntPtr.Zero;
+            IntPtr SIPClientData = IntPtr.Zero;
+            // required: UI choice
+            WinTrustDataUIChoice UIChoice = WinTrustDataUIChoice.None;
+            // required: certificate revocation check options
+            WinTrustDataRevocationChecks RevocationChecks = WinTrustDataRevocationChecks.None;
+            // required: which structure is being passed in?
+            WinTrustDataChoice UnionChoice = WinTrustDataChoice.File;
+            // individual file
+            IntPtr FileInfoPtr;
+            WinTrustDataStateAction StateAction = WinTrustDataStateAction.Ignore;
+            IntPtr StateData = IntPtr.Zero;
+            String URLReference = null;
+            WinTrustDataProvFlags ProvFlags = WinTrustDataProvFlags.RevocationCheckChainExcludeRoot;
+            WinTrustDataUIContext UIContext = WinTrustDataUIContext.Execute;
+
+            // constructor for silent WinTrustDataChoice.File check
+            public WinTrustData(WinTrustFileInfo _fileInfo)
+            {
+                // On Win7SP1+, don't allow MD2 or MD4 signatures
+                if ((Environment.OSVersion.Version.Major > 6) ||
+                    ((Environment.OSVersion.Version.Major == 6) && (Environment.OSVersion.Version.Minor > 1)) ||
+                    ((Environment.OSVersion.Version.Major == 6) && (Environment.OSVersion.Version.Minor == 1) && !String.IsNullOrEmpty(Environment.OSVersion.ServicePack)))
+                {
+                   ProvFlags |= WinTrustDataProvFlags.DisableMD2andMD4;
+                }
+
+                WinTrustFileInfo wtfiData = _fileInfo;
+                FileInfoPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(WinTrustFileInfo)));
+                Marshal.StructureToPtr(wtfiData, FileInfoPtr, false);
+            }
+            public void Dispose()
+            {
+                if(FileInfoPtr != IntPtr.Zero) {
+                    Marshal.FreeCoTaskMem(FileInfoPtr);
+                    FileInfoPtr = IntPtr.Zero;
+                }
+            }
+        }
+        #endregion
+
+        enum WinVerifyTrustResult : uint
+        {
+            Success = 0,
+            ProviderUnknown = 0x800b0001,           // Trust provider is not recognized on this system
+            ActionUnknown = 0x800b0002,         // Trust provider does not support the specified action
+            SubjectFormUnknown = 0x800b0003,        // Trust provider does not support the form specified for the subject
+            SubjectNotTrusted = 0x800b0004,         // Subject failed the specified verification action
+            FileNotSigned = 0x800B0100,         // TRUST_E_NOSIGNATURE - File was not signed
+            SubjectExplicitlyDistrusted = 0x800B0111,   // Signer's certificate is in the Untrusted Publishers store
+            SignatureOrFileCorrupt = 0x80096010,    // TRUST_E_BAD_DIGEST - file was probably corrupt
+            SubjectCertExpired = 0x800B0101,        // CERT_E_EXPIRED - Signer's certificate was expired
+            SubjectCertificateRevoked = 0x800B010C,     // CERT_E_REVOKED Subject's certificate was revoked
+            UntrustedRoot = 0x800B0109          // CERT_E_UNTRUSTEDROOT - A certification chain processed correctly but terminated in a root certificate that is not trusted by the trust provider.
+        }
+
+        public class WinTrust
+        {
+            private static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
+            // GUID of the action to perform
+            private const string WINTRUST_ACTION_GENERIC_VERIFY_V2 = "{00AAC56B-CD44-11d0-8CC2-00C04FC295EE}";
+
+            [DllImport("wintrust.dll", ExactSpelling = true, SetLastError = false, CharSet = CharSet.Unicode)]
+            static extern WinVerifyTrustResult WinVerifyTrust(
+                [In] IntPtr hwnd,
+                [In] [MarshalAs(UnmanagedType.LPStruct)] Guid pgActionID,
+                [In] WinTrustData pWVTData
+            );
+
+            // call WinTrust.WinVerifyTrust() to check embedded file signature
+            public static bool VerifyEmbeddedSignature(string fileName)
+            {
+                WinTrustFileInfo winTrustFileInfo = null;
+                WinTrustData winTrustData = null;
+
+                try
+                {
+                    winTrustFileInfo = new WinTrustFileInfo(fileName);
+                    winTrustData = new WinTrustData(winTrustFileInfo);
+                    Guid guidAction = new Guid(WINTRUST_ACTION_GENERIC_VERIFY_V2);
+                    WinVerifyTrustResult result = WinVerifyTrust(INVALID_HANDLE_VALUE, guidAction, winTrustData);
+                    bool ret = (result == WinVerifyTrustResult.Success);
+                    return ret;
+                }
+                finally
+                {
+                    // free the locally-held unmanaged memory in the data structures
+                    if (winTrustFileInfo != null) winTrustFileInfo.Dispose();
+                    if (winTrustData != null) winTrustData.Dispose();
+                }
+            }
+            private WinTrust() { }
+        }
+    }
+
     public class CertificateVerification
     {
         /// <summary>
@@ -21,45 +203,37 @@ public static bool CheckAssemblyForValidCertificate(string assemblyPath)
             //Verify the assembly exists
             if (!File.Exists(assemblyPath))
             {
-                throw new Exception(String.Format(
-                    "A dll file was not found at {0}. No certificate was able to be verified.", assemblyPath));
+                throw new FileNotFoundException(String.Format(
+                    "A dll file was not found at {0}. No certificate was able to be verified.", assemblyPath), assemblyPath);
             }
 
-            //Verify that you can load the assembly into a Reflection only context
-            Assembly asm;
+            //Verify the node library file has a verified signed certificate
             try
             {
-                asm = Assembly.ReflectionOnlyLoadFrom(assemblyPath);
+                var validCert = WinTrustInterop.WinTrust.VerifyEmbeddedSignature(assemblyPath);
+                if (validCert)
+                {
+                    return true;
+                }
             }
             catch
             {
-                throw new Exception(String.Format(
-                    "A dll file found at {0} could not be loaded.", assemblyPath));
+                throw new AssemblyCertificateCheckException(assemblyPath);
             }
 
-            //Verify the node library has a verified signed certificate
-            X509Certificate cert;
-            try
-            {
-                cert = X509Certificate.CreateFromSignedFile(assemblyPath);
-            }
-            catch
-            {
-                throw new Exception(String.Format(
-                    "A dll file found at {0} did not have a certificate attached.", assemblyPath));
-            }
+            throw new UnTrustedAssemblyException(assemblyPath);
+        }
 
-            if (cert != null)
-            {
-                var cert2 = new System.Security.Cryptography.X509Certificates.X509Certificate2(cert);
-                if (cert2.Verify())
-                {
-                    return true;
-                }
-            }
+        public class UnTrustedAssemblyException : Exception
+        {
+            public UnTrustedAssemblyException(string assemblyPath) : base(String.Format(
+                "A dll file found at {0} did not have a signed certificate.", assemblyPath)) { }
+        }
 
-            throw new Exception(String.Format(
-                "A dll file found at {0} did not have a signed certificate.", assemblyPath));
+        public class AssemblyCertificateCheckException : Exception
+        {
+            public AssemblyCertificateCheckException(string assemblyPath) : base(String.Format(
+                "Could not verify the dll file found at {0} has a signed certificate.", assemblyPath)) { }
         }
     }
 }

test/Libraries/DynamoUtilitiesTests/CertificateVerificationTests.cs

@@ -14,7 +14,7 @@ class CertificateVerificationTests
     {
         [Test]
         [Category("UnitTests")]
-        public void CheckAssemblyForValidCertificateTest()
+        public void CheckAssemblyForValidCertificateTest_ValidCertificate()
         {
             var executingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
             var directory = new DirectoryInfo(executingDirectory);
@@ -24,5 +24,43 @@ public void CheckAssemblyForValidCertificateTest()
 
             Assert.IsTrue(DynamoUtilities.CertificateVerification.CheckAssemblyForValidCertificate(testFilePath));
         }
+
+        [Test]
+        [Category("UnitTests")]
+        public void CheckAssemblyForValidCertificateTest_NoCertificate()
+        {
+            var executingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            var directory = new DirectoryInfo(executingDirectory);
+            var testFilePath = Path.Combine(directory.Parent.Parent.Parent.FullName, "test", "pkgs_signed", "Unsigned Package", "bin", "Package.dll");
+
+            Assert.IsTrue(File.Exists(testFilePath));
+
+            Assert.Throws(
+                typeof(CertificateVerification.UnTrustedAssemblyException), 
+                () =>
+                {
+                    DynamoUtilities.CertificateVerification.CheckAssemblyForValidCertificate(testFilePath);
+                }
+            ); 
+        }
+
+        [Test]
+        [Category("UnitTests")]
+        public void CheckAssemblyForValidCertificateTest_TransferredCertificate()
+        {
+            var executingDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            var directory = new DirectoryInfo(executingDirectory);
+            var testFilePath = Path.Combine(directory.Parent.Parent.Parent.FullName, "test", "pkgs_signed", "Modfied Signed Package", "bin", "LegitAssemblyTransplanted.dll");
+
+            Assert.IsTrue(File.Exists(testFilePath));
+
+            Assert.Throws(
+                typeof(CertificateVerification.UnTrustedAssemblyException),
+                () =>
+                {
+                    DynamoUtilities.CertificateVerification.CheckAssemblyForValidCertificate(testFilePath);
+                }
+            );
+        }
     }
 }

test/pkgs_signed/Modfied Signed Package/bin/LegitAssemblyTransplanted.dll

@@ -1 +1 @@
-{"license":"","file_hash":null,"name":"Package","version":"1.0.0","description":"original package","group":"","keywords":null,"dependencies":[],"contents":"","engine_version":"2.1.0.7840","engine":"dynamo","engine_metadata":"","site_url":"","repository_url":"","contains_binaries":true,"node_libraries":["Package, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"]}
+{"license":"","file_hash":null,"name":"LegitAssemblyTransplanted","version":"1.0.0","description":"original package","group":"","keywords":null,"dependencies":[],"contents":"","engine_version":"2.1.0.7840","engine":"dynamo","engine_metadata":"","site_url":"","repository_url":"","contains_binaries":true,"node_libraries":["LegitAssemblyTransplanted, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"]}