Minor refactorings and breaking out new rules.

vcsjones · vcsjones · commit 8c6ab20a6b1b · 2018-11-08T09:57:58.000-05:00
diff --git a/AuthenticodeLint/AuthenticodeLint.csproj b/AuthenticodeLint/AuthenticodeLint.csproj
@@ -3,10 +3,19 @@
     <OutputType>WinExe</OutputType>
     <AssemblyName>authlint</AssemblyName>
     <TargetFramework>netcoreapp2.1</TargetFramework>
-    <VersionPrefix>0.11.0</VersionPrefix>
+    <VersionPrefix>0.12.0</VersionPrefix>
     <Authors>Kevin Jones</Authors>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <Copyright>Kevin Jones 2016-2017</Copyright>
+    <Copyright>Kevin Jones 2016-2018</Copyright>
+    <PackAsTool>true</PackAsTool>
+    <ToolCommandName>authlint</ToolCommandName>
+    <Description>Authenticode Lint is a Windows command-line tool for linting an examining an Authenticode signed file.</Description>
+    <Authors>Kevin Jones</Authors>
+    <PackageTags>authenticode</PackageTags>
+    <PackageProjectUrl>https://github.com/vcsjones/AuthenticodeLint</PackageProjectUrl>
+    <RepositoryUrl>https://github.com/vcsjones/AuthenticodeLint</RepositoryUrl>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <EmbedUntrackedSources>true</EmbedUntrackedSources>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="AuthenticodeExaminer" Version="0.3.0" />
diff --git a/AuthenticodeLint/KnownOids.cs b/AuthenticodeLint/KnownOids.cs
@@ -8,14 +8,6 @@ public static class X509Algorithms
             public const string Ecc = "1.2.840.10045.2.1";
         }
 
-        public static class EccCurves
-        {
-            public const string EcdsaP256 = "1.2.840.10045.3.1.7";
-            public const string EcdsaP384 = "1.3.132.0.34";
-            public const string EcdsaP521 = "1.3.132.0.35";
-        }
-
-
         public const string SHA1 = "1.3.14.3.2.26";
         public const string SHA256 = "2.16.840.1.101.3.4.2.1";
         public const string SHA384 = "2.16.840.1.101.3.4.2.2";
diff --git a/AuthenticodeLint/Program.cs b/AuthenticodeLint/Program.cs
@@ -3,13 +3,19 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace AuthenticodeLint
 {
     class Program
     {
         static int Main(string[] args)
         {
+            if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                Console.Error.WriteLine("AuthenticodeLint is only supported on Windows.");
+                return ExitCodes.PlatformNotSupported;
+            }
             var cli = Environment.CommandLine;
             List<CommandLineParameter> parsedCommandLine;
             try
@@ -206,9 +212,10 @@ Checks the Authenticode signature of your binaries.
 
     internal static class ExitCodes
     {
-        public static int Success { get; } = 0;
-        public static int InvalidInputOrConfig { get; } = 1;
-        public static int ChecksFailed { get; } = 2;
-        public static int UnknownResults { get; } = 0xFF;
+        public static int Success => 0;
+        public static int InvalidInputOrConfig => 1;
+        public static int ChecksFailed => 2;
+        public static int UnknownResults => 0xFF;
+        public static int PlatformNotSupported => unchecked((int)0x80131539);
     }
 }
diff --git a/AuthenticodeLint/Rules/10000-Sha1PrimarySignatureRule.cs b/AuthenticodeLint/Rules/10000-Sha1PrimarySignatureRule.cs
@@ -5,25 +5,20 @@ namespace AuthenticodeLint.Rules
 {
     public class Sha1PrimarySignatureRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10000;
+        public int RuleId => 10000;
 
-        public string RuleName { get; } = "Primary SHA1";
+        public string RuleName => "Primary SHA1";
 
-        public string ShortDescription { get; } = "Primary signature should be SHA1.";
+        public string ShortDescription => "Primary signature should be SHA1.";
 
-        public RuleSet RuleSet { get; } = RuleSet.Compat;
+        public RuleSet RuleSet => RuleSet.Compat;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
             if (graph.Count == 0)
             {
                 return RuleResult.Fail;
             }
-            if (graph.Count > 1)
-            {
-                verboseWriter.LogMessage("Multiple primary signatures exist.");
-                return RuleResult.Fail;
-            }
             var primary = graph[0];
             if (primary.DigestAlgorithm.Value != KnownOids.SHA1)
             {
diff --git a/AuthenticodeLint/Rules/10001-Sha2SignatureExistsRule.cs b/AuthenticodeLint/Rules/10001-Sha2SignatureExistsRule.cs
@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules
 {
     public class Sha2SignatureExistsRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10001;
+        public int RuleId => 10001;
 
-        public string RuleName { get; } = "SHA2 Signed";
+        public string RuleName => "SHA2 Signed";
 
-        public string ShortDescription { get; } = "A SHA2 signature should exist.";
+        public string ShortDescription => "A SHA2 signature should exist.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10002-NoWeakFileDigestAlgorithmsRule.cs b/AuthenticodeLint/Rules/10002-NoWeakFileDigestAlgorithmsRule.cs
@@ -5,13 +5,13 @@ namespace AuthenticodeLint.Rules
 {
     public class NoWeakFileDigestAlgorithmsRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10002;
+        public int RuleId => 10002;
 
-        public string RuleName { get; } = "No Weak File Digests";
+        public string RuleName => "No Weak File Digests";
 
-        public string ShortDescription { get; } = "Checks for weak file digest algorithms.";
+        public string ShortDescription => "Checks for weak file digest algorithms.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
         
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10003-TimestampedRule.cs b/AuthenticodeLint/Rules/10003-TimestampedRule.cs
@@ -7,13 +7,13 @@ namespace AuthenticodeLint.Rules
 {
     public class TimestampedRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10003;
+        public int RuleId => 10003;
 
-        public string RuleName { get; } = "Timestamped Rule";
+        public string RuleName => "Timestamped Rule";
 
-        public string ShortDescription { get; } = "Signatures should have a timestamp counter signer.";
+        public string ShortDescription => "Signatures should have a timestamp counter signer.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10004-PublisherInformationRule.cs b/AuthenticodeLint/Rules/10004-PublisherInformationRule.cs
@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules
 {
     public class PublisherInformationPresentRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10004;
+        public int RuleId => 10004;
 
-        public string RuleName { get; } = "Publisher Information Present";
+        public string RuleName => "Publisher Information Present";
 
-        public string ShortDescription { get; } = "Checks that the signature provided publisher information.";
+        public string ShortDescription => "Checks that the signature provided publisher information.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
         
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10005-PublisherInformationUrlHttpsRule.cs b/AuthenticodeLint/Rules/10005-PublisherInformationUrlHttpsRule.cs
@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules
 {
     public class PublisherInformationUrlHttpsRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10005;
+        public int RuleId => 10005;
 
-        public string RuleName { get; } = "Publisher Information URL HTTPS Rule";
+        public string RuleName => "Publisher Information URL HTTPS Rule";
 
-        public string ShortDescription { get; } = "Checks that the signature uses HTTPS for the publisher's URL.";
+        public string ShortDescription => "Checks that the signature uses HTTPS for the publisher's URL.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10006-SigningCertificateDigestAlgorithmRule.cs b/AuthenticodeLint/Rules/10006-SigningCertificateDigestAlgorithmRule.cs
@@ -5,13 +5,13 @@ namespace AuthenticodeLint.Rules
 {
     public class SigningCertificateDigestAlgorithmRule : CertificateChainRuleBase
     {
-        public override int RuleId { get; } = 10006;
+        public override int RuleId => 10006;
 
-        public override string RuleName { get; } = "Strong Certificate Chain";
+        public override string RuleName => "Strong Certificate Chain";
 
-        public override string ShortDescription { get; } = "Checks the signing certificate's and chain's signature algorithm.";
+        public override string ShortDescription => "Checks the signing certificate's and chain's signature algorithm.";
 
-        public override RuleSet RuleSet { get; } = RuleSet.All;
+        public override RuleSet RuleSet => RuleSet.All;
         
         protected override bool ValidateChain(ICmsSignature signer, X509Chain chain, SignatureLogger verboseWriter)
         {
diff --git a/AuthenticodeLint/Rules/10007-TrustedSignatureRule.cs b/AuthenticodeLint/Rules/10007-TrustedSignatureRule.cs
@@ -4,13 +4,13 @@ namespace AuthenticodeLint.Rules
 {
     public class TrustedSignatureRule : IAuthenticodeFileRule
     {
-        public int RuleId { get; } = 10007;
+        public int RuleId => 10007;
 
-        public string RuleName { get; } = "Valid Signature";
+        public string RuleName => "Valid Signature";
 
-        public string ShortDescription { get; } = "Validates the file has correct signatures.";
+        public string ShortDescription => "Validates the file has correct signatures.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(string file, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10008-WinCertificatePaddingRule.cs b/AuthenticodeLint/Rules/10008-WinCertificatePaddingRule.cs
@@ -1,17 +1,18 @@
 ﻿using System;
 using System.Linq;
+using System.Numerics;
 
 namespace AuthenticodeLint.Rules
 {
     public class WinCertificatePaddingRule : IAuthenticodeFileRule
     {
-        public int RuleId { get; } = 10008;
+        public int RuleId => 10008;
 
-        public string RuleName { get; } = "No WinCertificate Structure Padding";
+        public string RuleName => "No WinCertificate Structure Padding";
 
-        public string ShortDescription { get; } = "Checks for non-zero data after the signature.";
+        public string ShortDescription => "Checks for non-zero data after the signature.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(string file, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10009-NoUnknownUnsignedAttibuteRule.cs b/AuthenticodeLint/Rules/10009-NoUnknownUnsignedAttibuteRule.cs
@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules
 {
     public class NoUnknownUnsignedAttibuteRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10009;
+        public int RuleId => 10009;
 
-        public string RuleName { get; } = "No Unknown Unsigned Attributes";
+        public string RuleName => "No Unknown Unsigned Attributes";
 
-        public string ShortDescription { get; } = "Checks for the presence of unsigned attributes with unknown an OID.";
+        public string ShortDescription => "Checks for the presence of unsigned attributes with unknown an OID.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         private static string[] _trustedUnsignedAttributes = new[]
         {
diff --git a/AuthenticodeLint/Rules/10010-NoUnknownCertificatesRule.cs b/AuthenticodeLint/Rules/10010-NoUnknownCertificatesRule.cs
@@ -7,13 +7,13 @@ namespace AuthenticodeLint.Rules
 {
     public class NoUnknownCertificatesRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10010;
+        public int RuleId => 10010;
 
-        public string RuleName { get; } = "No Unknown Certificates";
+        public string RuleName => "No Unknown Certificates";
 
-        public string ShortDescription { get; } = "Checks for unknown embedded certificates.";
+        public string ShortDescription => "Checks for unknown embedded certificates.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10011-StrongKeyLengthRule.cs b/AuthenticodeLint/Rules/10011-StrongKeyLengthRule.cs
@@ -9,13 +9,13 @@ public class StrongKeyLengthRule : IAuthenticodeSignatureRule
         private const int MIN_RSADSA_KEY_SIZE = 2048;
         private const int MIN_ECDSA_KEY_SIZE = 256;
 
-        public int RuleId { get; } = 10011;
+        public int RuleId => 10011;
 
-        public string RuleName { get; } = "Strong Key Length";
+        public string RuleName => "Strong Key Length";
 
-        public string ShortDescription { get; } = "Validates the key length of a signing certificate.";
+        public string ShortDescription => "Validates the key length of a signing certificate.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10012-RsaDsaPrimarySignatureRule.cs b/AuthenticodeLint/Rules/10012-RsaDsaPrimarySignatureRule.cs
@@ -6,17 +6,17 @@ namespace AuthenticodeLint.Rules
 {
     public class RsaDsaPrimarySignatureRule : IAuthenticodeSignatureRule
     {
-        public int RuleId { get; } = 10012;
+        public int RuleId => 10012;
 
-        public string RuleName { get; } = "RSA/DSA Primary Signature";
+        public string RuleName => "RSA/DSA Primary Signature";
 
-        public string ShortDescription { get; } = "Primary signature should be RSA or DSA.";
+        public string ShortDescription => "Primary signature should be RSA or DSA.";
 
-        public RuleSet RuleSet { get; } = RuleSet.Compat;
+        public RuleSet RuleSet => RuleSet.Compat;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
-            var primary = graph.SingleOrDefault();
+            var primary = graph.FirstOrDefault();
             //There are zero signatures.
             if (primary == null)
             {
diff --git a/AuthenticodeLint/Rules/10013-MaxKeyLengthRule.cs b/AuthenticodeLint/Rules/10013-MaxKeyLengthRule.cs
@@ -9,13 +9,13 @@ public class MaxKeyLengthRule : IAuthenticodeSignatureRule
         private const int MAX_RSA_KEY_SIZE = 4096;
         private const int MAX_DSA_KEY_SIZE = 1024;
 
-        public int RuleId { get; } = 10013;
+        public int RuleId => 10013;
 
-        public string RuleName { get; } = "Maximum Key Length";
+        public string RuleName => "Maximum Key Length";
 
-        public string ShortDescription { get; } = "Validates the maximum key length of a signing certificate.";
+        public string ShortDescription => "Validates the maximum key length of a signing certificate.";
 
-        public RuleSet RuleSet { get; } = RuleSet.All;
+        public RuleSet RuleSet => RuleSet.All;
 
         public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
         {
diff --git a/AuthenticodeLint/Rules/10014-SinglePrimarySignatureRule.cs b/AuthenticodeLint/Rules/10014-SinglePrimarySignatureRule.cs
@@ -0,0 +1,30 @@
+﻿using System.Collections.Generic;
+using AuthenticodeExaminer;
+
+namespace AuthenticodeLint.Rules
+{
+    public class SinglePrimarySignatureRule : IAuthenticodeSignatureRule
+    {
+        public int RuleId => 10014;
+
+        public string RuleName => "Single primary signature";
+
+        public string ShortDescription => "Limit to a single primary signature.";
+
+        public RuleSet RuleSet => RuleSet.All;
+
+        public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)
+        {
+            if (graph.Count == 0)
+            {
+                return RuleResult.Fail;
+            }
+            if (graph.Count > 1)
+            {
+                verboseWriter.LogMessage("Multiple primary signatures exist.");
+                return RuleResult.Fail;
+            }
+            return RuleResult.Pass;
+        }
+    }
+}
diff --git a/AuthenticodeLint/Rules/10015-NoSha1Rule.cs b/AuthenticodeLint/Rules/10015-NoSha1Rule.cs

Original file line number	Diff line number	Diff line change
`@@ -3,13 +3,19 @@`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.IO;`
`5`	`5`	`using System.Linq;`
	`6`	`+using System.Runtime.InteropServices;`
`6`	`7`
`7`	`8`	`namespace AuthenticodeLint`
`8`	`9`	`{`
`9`	`10`	`class Program`
`10`	`11`	`{`
`11`	`12`	`static int Main(string[] args)`
`12`	`13`	`{`
	`14`	`+ if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))`
	`15`	`+ {`
	`16`	`+ Console.Error.WriteLine("AuthenticodeLint is only supported on Windows.");`
	`17`	`+ return ExitCodes.PlatformNotSupported;`
	`18`	`+ }`
`13`	`19`	`var cli = Environment.CommandLine;`
`14`	`20`	`List<CommandLineParameter> parsedCommandLine;`
`15`	`21`	`try`
`@@ -206,9 +212,10 @@ Checks the Authenticode signature of your binaries.`
`206`	`212`
`207`	`213`	`internal static class ExitCodes`
`208`	`214`	`{`
`209`		`- public static int Success { get; } = 0;`
`210`		`- public static int InvalidInputOrConfig { get; } = 1;`
`211`		`- public static int ChecksFailed { get; } = 2;`
`212`		`- public static int UnknownResults { get; } = 0xFF;`
	`215`	`+ public static int Success => 0;`
	`216`	`+ public static int InvalidInputOrConfig => 1;`
	`217`	`+ public static int ChecksFailed => 2;`
	`218`	`+ public static int UnknownResults => 0xFF;`
	`219`	`+ public static int PlatformNotSupported => unchecked((int)0x80131539);`
`213`	`220`	`}`
`214`	`221`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,25 +5,20 @@ namespace AuthenticodeLint.Rules`
`5`	`5`	`{`
`6`	`6`	`public class Sha1PrimarySignatureRule : IAuthenticodeSignatureRule`
`7`	`7`	`{`
`8`		`- public int RuleId { get; } = 10000;`
	`8`	`+ public int RuleId => 10000;`
`9`	`9`
`10`		`- public string RuleName { get; } = "Primary SHA1";`
	`10`	`+ public string RuleName => "Primary SHA1";`
`11`	`11`
`12`		`- public string ShortDescription { get; } = "Primary signature should be SHA1.";`
	`12`	`+ public string ShortDescription => "Primary signature should be SHA1.";`
`13`	`13`
`14`		`- public RuleSet RuleSet { get; } = RuleSet.Compat;`
	`14`	`+ public RuleSet RuleSet => RuleSet.Compat;`
`15`	`15`
`16`	`16`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`17`	`17`	`{`
`18`	`18`	`if (graph.Count == 0)`
`19`	`19`	`{`
`20`	`20`	`return RuleResult.Fail;`
`21`	`21`	`}`
`22`		`- if (graph.Count > 1)`
`23`		`- {`
`24`		`- verboseWriter.LogMessage("Multiple primary signatures exist.");`
`25`		`- return RuleResult.Fail;`
`26`		`- }`
`27`	`22`	`var primary = graph[0];`
`28`	`23`	`if (primary.DigestAlgorithm.Value != KnownOids.SHA1)`
`29`	`24`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules`
`6`	`6`	`{`
`7`	`7`	`public class Sha2SignatureExistsRule : IAuthenticodeSignatureRule`
`8`	`8`	`{`
`9`		`- public int RuleId { get; } = 10001;`
	`9`	`+ public int RuleId => 10001;`
`10`	`10`
`11`		`- public string RuleName { get; } = "SHA2 Signed";`
	`11`	`+ public string RuleName => "SHA2 Signed";`
`12`	`12`
`13`		`- public string ShortDescription { get; } = "A SHA2 signature should exist.";`
	`13`	`+ public string ShortDescription => "A SHA2 signature should exist.";`
`14`	`14`
`15`		`- public RuleSet RuleSet { get; } = RuleSet.All;`
	`15`	`+ public RuleSet RuleSet => RuleSet.All;`
`16`	`16`
`17`	`17`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@ namespace AuthenticodeLint.Rules`
`5`	`5`	`{`
`6`	`6`	`public class NoWeakFileDigestAlgorithmsRule : IAuthenticodeSignatureRule`
`7`	`7`	`{`
`8`		`- public int RuleId { get; } = 10002;`
	`8`	`+ public int RuleId => 10002;`
`9`	`9`
`10`		`- public string RuleName { get; } = "No Weak File Digests";`
	`10`	`+ public string RuleName => "No Weak File Digests";`
`11`	`11`
`12`		`- public string ShortDescription { get; } = "Checks for weak file digest algorithms.";`
	`12`	`+ public string ShortDescription => "Checks for weak file digest algorithms.";`
`13`	`13`
`14`		`- public RuleSet RuleSet { get; } = RuleSet.All;`
	`14`	`+ public RuleSet RuleSet => RuleSet.All;`
`15`	`15`
`16`	`16`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ namespace AuthenticodeLint.Rules`
`7`	`7`	`{`
`8`	`8`	`public class TimestampedRule : IAuthenticodeSignatureRule`
`9`	`9`	`{`
`10`		`- public int RuleId { get; } = 10003;`
	`10`	`+ public int RuleId => 10003;`
`11`	`11`
`12`		`- public string RuleName { get; } = "Timestamped Rule";`
	`12`	`+ public string RuleName => "Timestamped Rule";`
`13`	`13`
`14`		`- public string ShortDescription { get; } = "Signatures should have a timestamp counter signer.";`
	`14`	`+ public string ShortDescription => "Signatures should have a timestamp counter signer.";`
`15`	`15`
`16`		`- public RuleSet RuleSet { get; } = RuleSet.All;`
	`16`	`+ public RuleSet RuleSet => RuleSet.All;`
`17`	`17`
`18`	`18`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`19`	`19`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules`
`6`	`6`	`{`
`7`	`7`	`public class PublisherInformationPresentRule : IAuthenticodeSignatureRule`
`8`	`8`	`{`
`9`		`- public int RuleId { get; } = 10004;`
	`9`	`+ public int RuleId => 10004;`
`10`	`10`
`11`		`- public string RuleName { get; } = "Publisher Information Present";`
	`11`	`+ public string RuleName => "Publisher Information Present";`
`12`	`12`
`13`		`- public string ShortDescription { get; } = "Checks that the signature provided publisher information.";`
	`13`	`+ public string ShortDescription => "Checks that the signature provided publisher information.";`
`14`	`14`
`15`		`- public RuleSet RuleSet { get; } = RuleSet.All;`
	`15`	`+ public RuleSet RuleSet => RuleSet.All;`
`16`	`16`
`17`	`17`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,13 +6,13 @@ namespace AuthenticodeLint.Rules`
`6`	`6`	`{`
`7`	`7`	`public class PublisherInformationUrlHttpsRule : IAuthenticodeSignatureRule`
`8`	`8`	`{`
`9`		`- public int RuleId { get; } = 10005;`
	`9`	`+ public int RuleId => 10005;`
`10`	`10`
`11`		`- public string RuleName { get; } = "Publisher Information URL HTTPS Rule";`
	`11`	`+ public string RuleName => "Publisher Information URL HTTPS Rule";`
`12`	`12`
`13`		`- public string ShortDescription { get; } = "Checks that the signature uses HTTPS for the publisher's URL.";`
	`13`	`+ public string ShortDescription => "Checks that the signature uses HTTPS for the publisher's URL.";`
`14`	`14`
`15`		`- public RuleSet RuleSet { get; } = RuleSet.All;`
	`15`	`+ public RuleSet RuleSet => RuleSet.All;`
`16`	`16`
`17`	`17`	`public RuleResult Validate(IReadOnlyList<ICmsSignature> graph, SignatureLogger verboseWriter, CheckConfiguration configuration)`
`18`	`18`	`{`
Original file line number	Diff line number	Diff line change
`@@ -5,13 +5,13 @@ namespace AuthenticodeLint.Rules`
`5`	`5`	`{`
`6`	`6`	`public class SigningCertificateDigestAlgorithmRule : CertificateChainRuleBase`
`7`	`7`	`{`
`8`		`- public override int RuleId { get; } = 10006;`
	`8`	`+ public override int RuleId => 10006;`
`9`	`9`
`10`		`- public override string RuleName { get; } = "Strong Certificate Chain";`
	`10`	`+ public override string RuleName => "Strong Certificate Chain";`
`11`	`11`
`12`		`- public override string ShortDescription { get; } = "Checks the signing certificate's and chain's signature algorithm.";`
	`12`	`+ public override string ShortDescription => "Checks the signing certificate's and chain's signature algorithm.";`
`13`	`13`
`14`		`- public override RuleSet RuleSet { get; } = RuleSet.All;`
	`14`	`+ public override RuleSet RuleSet => RuleSet.All;`
`15`	`15`
`16`	`16`	`protected override bool ValidateChain(ICmsSignature signer, X509Chain chain, SignatureLogger verboseWriter)`
`17`	`17`	`{`