Merge pull request #640 from pharring/FakeUnsign

Add options to FakeSign.exe
-u (unsign) reverses the default behavior by clearing the strong name signed bit.
-f (force) forces an update even if it would change nothing.

src/Tools/Source/FakeSign/Program.cs

@@ -15,7 +15,7 @@ namespace FakeSign
     /// </summary>
     /// <remarks>
     /// This code is taken largely from the Microsoft.BuildTools project and their OSS signing
-    /// process.  
+    /// process.
     ///
     /// https://github.com/dotnet/buildtools/blob/master/src/Microsoft.DotNet.Build.Tasks/OpenSourceSign.cs
     /// </remarks>
@@ -30,7 +30,7 @@ internal static class Program
          + sizeof(Int16)  // minor version
          + sizeof(Int64); // metadata directory
 
-        private static bool ExecuteCore(string assemblyPath)
+        private static bool ExecuteCore(string assemblyPath, bool unSign = false, bool force = false)
         {
             if (Directory.Exists(assemblyPath))
             {
@@ -48,42 +48,68 @@ private static bool ExecuteCore(string assemblyPath)
             using (var reader = new PEReader(stream))
             using (var writer = new BinaryWriter(stream))
             {
-                if (!Validate(reader))
+                var mdReader = ValidateManagedAssemblyAndGetMetadataReader(reader);
+                if (mdReader == null)
                 {
-                    Console.Error.WriteLine($"Unable to sign {assemblyPath}");
+                    Console.Error.WriteLine($"Cannot {(unSign ? "un-sign" : "sign")} {assemblyPath}.");
+                    return false;
+                }
+
+                if (!force && !Validate(reader, mdReader, unSign))
+                {
+                    Console.Error.WriteLine($"Use the -f (force) option to {(unSign ? "un-sign" : "sign")} {assemblyPath} anyway.");
                     return false;
                 }
 
                 stream.Position = reader.PEHeaders.CorHeaderStartOffset + OffsetFromStartOfCorHeaderToFlags;
-                writer.Write((UInt32)(reader.PEHeaders.CorHeader.Flags | CorFlags.StrongNameSigned));
+
+                var flags = reader.PEHeaders.CorHeader.Flags;
+                if (unSign)
+                {
+                    flags &= ~CorFlags.StrongNameSigned;
+                }
+                else
+                {
+                    flags |= CorFlags.StrongNameSigned;
+                }
+
+                writer.Write((UInt32)flags);
             }
 
             return true;
         }
 
-        /// <summary>
-        /// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed.
-        /// Returns false and logs msbuild errors otherwise.
-        /// </summary>
-        private static bool Validate(PEReader peReader)
+        private static MetadataReader ValidateManagedAssemblyAndGetMetadataReader(PEReader peReader)
         {
             if (!peReader.HasMetadata)
             {
                 Console.Error.WriteLine("PE file is not a managed module.");
-                return false;
+                return null;
             }
 
             var mdReader = peReader.GetMetadataReader();
             if (!mdReader.IsAssembly)
             {
                 Console.Error.WriteLine("PE file is not an assembly.");
-                return false;
+                return null;
             }
 
+            return mdReader;
+        }
+
+        /// <summary>
+        /// Returns true if the PE file meets all of the pre-conditions to be Open Source Signed.
+        /// Returns false and logs msbuild errors otherwise.
+        /// </summary>
+        private static bool Validate(PEReader peReader, MetadataReader mdReader, bool unSign)
+        {
             CorHeader header = peReader.PEHeaders.CorHeader;
-            if ((header.Flags & CorFlags.StrongNameSigned) == CorFlags.StrongNameSigned)
+            var expectedStrongNameFlag = unSign ? CorFlags.StrongNameSigned : 0;
+            var actualStrongNameFlag = header.Flags & CorFlags.StrongNameSigned;
+
+            if (expectedStrongNameFlag != actualStrongNameFlag)
             {
-                Console.Error.WriteLine("PE file is already strong-name signed.");
+                Console.Error.WriteLine($"PE file is {(unSign ? "not" : "already")} strong-name signed.");
                 return false;
             }
 
@@ -121,21 +147,65 @@ private static FileStream OpenFile(string path, FileMode mode, FileAccess access
 
         internal static int Main(string[] args)
         {
-            // Create a byte array to hold the information.
-            if (args.Length == 0)
+            string file = null;
+            bool unSign = false;
+            bool force = false;
+
+            foreach (string arg in args)
             {
-                Console.Error.WriteLine("No file passed");
-                return 1;
+                if (arg.Length >= 2 && (arg[0] == '-' || arg[0] == '/'))
+                {
+                    switch (arg[1])
+                    {
+                        case '?':
+                            goto Help;
+
+                        case 'u':
+                        case 'U':
+                            unSign = true;
+                            break;
+
+
+                        case 'f':
+                        case 'F':
+                            force = true;
+                            break;
+
+                        default:
+                            Console.Error.WriteLine($"Unrecognized switch {arg}");
+                            goto Help;
+                    }
+                }
+                else if (file != null)
+                {
+                    Console.Error.WriteLine("Too many arguments.");
+                    goto Help;
+                }
+                else
+                {
+                    file = arg;
+                }
             }
 
-            if (!ExecuteCore(args[0]))
+            if (file == null)
             {
-                Console.Error.WriteLine("Could not sign assembly");
-                return 1;
+                Console.Error.WriteLine("Missing assemblyPath.");
+                goto Help;
             }
 
-            return 0;
+            return ExecuteCore(file, unSign, force) ? 0 : 1;
+
+        Help:
+            Console.Error.Write(
+@"Sets or removes the ""strong name signed"" flag in a managed assembly. This
+creates an assembly that can be loaded in full trust without registering for
+verification skipping.
+
+FakeSign [-u] [-f] assemblyPath
+    -u (unsign) Clears the strong name flag (default is to set the flag).
+    -f (force) Updates even if nothing would change.
+");
+            return 1;
         }
     }
 }
-