Merge pull request #124 from AArnott/fix116b

Generate public key fields in ThisAssembly on Linux/Mac

Author: AArnott

src/Nerdbank.GitVersioning.Tasks/AssemblyVersionInfo.cs

@@ -11,9 +11,7 @@
     using System.Text;
     using Microsoft.Build.Framework;
     using Microsoft.Build.Utilities;
-#if NET45
-    using PInvoke;
-#endif
+
     public class AssemblyVersionInfo : Task
     {
 #if NET45
@@ -121,7 +119,7 @@ private CodeTypeDeclaration CreateThisAssemblyClass()
 
             // Determine information about the public key used in the assembly name.
             string publicKey, publicKeyToken;
-            this.ReadKeyInfo(out publicKey, out publicKeyToken);
+            bool hasKeyInfo = this.TryReadKeyInfo(out publicKey, out publicKeyToken);
 
             // Define the constants.
             thisAssembly.Members.AddRange(CreateFields(new Dictionary<string, string>
@@ -130,58 +128,25 @@ private CodeTypeDeclaration CreateThisAssemblyClass()
                     { "AssemblyFileVersion", this.AssemblyFileVersion },
                     { "AssemblyInformationalVersion", this.AssemblyInformationalVersion },
                     { "AssemblyName", this.AssemblyName },
-                    { "PublicKey", publicKey },
-                    { "PublicKeyToken", publicKeyToken },
                     { "AssemblyTitle", this.AssemblyTitle },
                     { "AssemblyProduct", this.AssemblyProduct },
                     { "AssemblyCopyright", this.AssemblyCopyright },
                     { "AssemblyCompany", this.AssemblyCompany },
                     { "AssemblyConfiguration", this.AssemblyConfiguration }
                 }).ToArray());
-
-            // These properties should be defined even if they are empty.
-            thisAssembly.Members.Add(CreateField("RootNamespace", this.RootNamespace));
-
-            return thisAssembly;
-        }
-
-       private void ReadKeyInfo(out string publicKey, out string publicKeyToken)
-        {
-            byte[] publicKeyBytes = null;
-            if (!string.IsNullOrEmpty(this.AssemblyOriginatorKeyFile) && File.Exists(this.AssemblyOriginatorKeyFile))
+            if (hasKeyInfo)
             {
-                if (Path.GetExtension(this.AssemblyOriginatorKeyFile).Equals(".snk", StringComparison.OrdinalIgnoreCase))
+                thisAssembly.Members.AddRange(CreateFields(new Dictionary<string, string>
                 {
-                    byte[] keyBytes = File.ReadAllBytes(this.AssemblyOriginatorKeyFile);
-                    bool publicKeyOnly = keyBytes[0] != 0x07;
-                    publicKeyBytes = publicKeyOnly ? keyBytes : MSCorEE.StrongNameGetPublicKey(keyBytes);
-                }
-            }
-            else if (!string.IsNullOrEmpty(this.AssemblyKeyContainerName))
-            {
-                publicKeyBytes = MSCorEE.StrongNameGetPublicKey(this.AssemblyKeyContainerName);
-            }
-
-            if (publicKeyBytes != null && publicKeyBytes.Length > 0) // If .NET 2.0 isn't installed, we get byte[0] back.
-            {
-                publicKey = ToHex(publicKeyBytes);
-                publicKeyToken = ToHex(MSCorEE.StrongNameTokenFromPublicKey(publicKeyBytes));
+                    { "PublicKey", publicKey },
+                    { "PublicKeyToken", publicKeyToken },
+                }).ToArray());
             }
-            else
-            {
-                if (publicKeyBytes != null)
-                {
-                    this.Log.LogWarning("Unable to emit public key fields in ThisAssembly class because .NET 2.0 isn't installed.");
-                }
 
-                publicKey = null;
-                publicKeyToken = null;
-            }
-        }
+            // These properties should be defined even if they are empty.
+            thisAssembly.Members.Add(CreateField("RootNamespace", this.RootNamespace));
 
-        private static string ToHex(byte[] data)
-        {
-            return BitConverter.ToString(data).Replace("-", "").ToLowerInvariant();
+            return thisAssembly;
         }
 
         private IEnumerable<CodeAttributeDeclaration> CreateAssemblyAttributes()
@@ -276,9 +241,9 @@ private void CreateThisAssemblyClass()
         {
             this.generator.StartThisAssemblyClass();
 
-            ////// Determine information about the public key used in the assembly name.
-            ////string publicKey, publicKeyToken;
-            ////this.ReadKeyInfo(out publicKey, out publicKeyToken);
+            // Determine information about the public key used in the assembly name.
+            string publicKey, publicKeyToken;
+            bool hasKeyInfo = this.TryReadKeyInfo(out publicKey, out publicKeyToken);
 
             // Define the constants.
             var fields = new Dictionary<string, string>
@@ -287,14 +252,18 @@ private void CreateThisAssemblyClass()
                     { "AssemblyFileVersion", this.AssemblyFileVersion },
                     { "AssemblyInformationalVersion", this.AssemblyInformationalVersion },
                     { "AssemblyName", this.AssemblyName },
-                    ////{ "PublicKey", publicKey },
-                    ////{ "PublicKeyToken", publicKeyToken },
                     { "AssemblyTitle", this.AssemblyTitle },
                     { "AssemblyProduct", this.AssemblyProduct },
                     { "AssemblyCopyright", this.AssemblyCopyright },
                     { "AssemblyCompany", this.AssemblyCompany },
                     { "AssemblyConfiguration", this.AssemblyConfiguration }
                 };
+            if (hasKeyInfo)
+            {
+                fields.Add("PublicKey", publicKey);
+                fields.Add("PublicKeyToken", publicKeyToken);
+            }
+
             foreach (var pair in fields)
             {
                 if (!string.IsNullOrEmpty(pair.Value))
@@ -389,5 +358,79 @@ internal override void EndThisAssemblyClass()
             }
         }
 #endif
+
+        private static string ToHex(byte[] data)
+        {
+            return BitConverter.ToString(data).Replace("-", "").ToLowerInvariant();
+        }
+
+        /// <summary>
+        /// Gets the public key from a key container.
+        /// </summary>
+        /// <param name="containerName">The name of the container.</param>
+        /// <returns>The public key.</returns>
+        private static byte[] GetPublicKeyFromKeyContainer(string containerName)
+        {
+            throw new NotImplementedException();
+        }
+
+        private static byte[] GetPublicKeyFromKeyPair(byte[] keyPair)
+        {
+            byte[] publicKey;
+            if (CryptoBlobParser.TryGetPublicKeyFromPrivateKeyBlob(keyPair, out publicKey))
+            {
+                return publicKey;
+            }
+            else
+            {
+                throw new ArgumentException("Invalid keypair");
+            }
+        }
+
+        private bool TryReadKeyInfo(out string publicKey, out string publicKeyToken)
+        {
+            try
+            {
+                byte[] publicKeyBytes = null;
+                if (!string.IsNullOrEmpty(this.AssemblyOriginatorKeyFile) && File.Exists(this.AssemblyOriginatorKeyFile))
+                {
+                    if (Path.GetExtension(this.AssemblyOriginatorKeyFile).Equals(".snk", StringComparison.OrdinalIgnoreCase))
+                    {
+                        byte[] keyBytes = File.ReadAllBytes(this.AssemblyOriginatorKeyFile);
+                        bool publicKeyOnly = keyBytes[0] != 0x07;
+                        publicKeyBytes = publicKeyOnly ? keyBytes : GetPublicKeyFromKeyPair(keyBytes);
+                    }
+                }
+                else if (!string.IsNullOrEmpty(this.AssemblyKeyContainerName))
+                {
+                    publicKeyBytes = GetPublicKeyFromKeyContainer(this.AssemblyKeyContainerName);
+                }
+
+                if (publicKeyBytes != null && publicKeyBytes.Length > 0) // If .NET 2.0 isn't installed, we get byte[0] back.
+                {
+                    publicKey = ToHex(publicKeyBytes);
+                    publicKeyToken = ToHex(CryptoBlobParser.GetStrongNameTokenFromPublicKey(publicKeyBytes));
+                }
+                else
+                {
+                    if (publicKeyBytes != null)
+                    {
+                        this.Log.LogWarning("Unable to emit public key fields in ThisAssembly class because .NET 2.0 isn't installed.");
+                    }
+
+                    publicKey = null;
+                    publicKeyToken = null;
+                    return false;
+                }
+
+                return true;
+            }
+            catch (NotImplementedException)
+            {
+                publicKey = null;
+                publicKeyToken = null;
+                return false;
+            }
+        }
     }
 }

src/Nerdbank.GitVersioning.Tasks/CryptoBlobParser+BlobHeader.cs

@@ -0,0 +1,34 @@
+namespace Nerdbank.GitVersioning.Tasks
+{
+    using System.Runtime.InteropServices;
+
+    /// <contents>
+    /// The <see cref="BlobHeader"/> struct.
+    /// </contents>
+    partial class CryptoBlobParser
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        private struct BlobHeader
+        {
+            /// <summary>
+            /// Blob type.
+            /// </summary>
+            public byte Type;
+
+            /// <summary>
+            /// Blob format version
+            /// </summary>
+            public byte Version;
+
+            /// <summary>
+            /// Must be 0
+            /// </summary>
+            public ushort Reserved;
+
+            /// <summary>
+            /// Algorithm ID. Must be one of ALG_ID specified in wincrypto.h
+            /// </summary>
+            public uint AlgId;
+        }
+    }
+}

src/Nerdbank.GitVersioning.Tasks/CryptoBlobParser+RsaPubKey.cs

@@ -0,0 +1,29 @@
+namespace Nerdbank.GitVersioning.Tasks
+{
+    using System.Runtime.InteropServices;
+
+    partial class CryptoBlobParser
+    {
+        /// <summary>
+        /// RSAPUBKEY struct from wincrypt.h
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        private struct RsaPubKey
+        {
+            /// <summary>
+            /// Indicates RSA1 or RSA2
+            /// </summary>
+            public uint Magic;
+
+            /// <summary>
+            /// Number of bits in the modulus. Must be multiple of 8.
+            /// </summary>
+            public uint BitLen;
+
+            /// <summary>
+            /// The public exponent
+            /// </summary>
+            public uint PubExp;
+        }
+    }
+}

src/Nerdbank.GitVersioning.Tasks/CryptoBlobParser+SnPublicKeyBlob.cs

@@ -0,0 +1,41 @@
+namespace Nerdbank.GitVersioning.Tasks
+{
+    using System.Runtime.InteropServices;
+
+    /// <contents>
+    /// The <see cref="SnPublicKeyBlob"/> struct.
+    /// </contents>
+    partial class CryptoBlobParser
+    {
+        /// <summary>
+        /// The strong name public key blob binary format.
+        /// </summary>
+        /// <see cref="https://github.com/dotnet/coreclr/blob/32f0f9721afb584b4a14d69135bea7ddc129f755/src/strongname/inc/strongname.h#L29"/>
+        [StructLayout(LayoutKind.Sequential, Pack = 1)]
+        private unsafe struct SnPublicKeyBlob
+        {
+            /// <summary>
+            /// Signature algorithm ID
+            /// </summary>
+            public uint SigAlgId;
+
+            /// <summary>
+            /// Hash algorithm ID
+            /// </summary>
+            public uint HashAlgId;
+
+            /// <summary>
+            /// Size of public key data in bytes, not including the header
+            /// </summary>
+            public uint PublicKeySize;
+
+            /// <summary>
+            /// PublicKeySize bytes of public key data
+            /// </summary>
+            /// <remarks>
+            /// Note: PublicKey is variable sized
+            /// </remarks>
+            public fixed byte PublicKey[1];
+        }
+    }
+}