Merge pull request #2007 from stephentoub/cert_allocs

Remove some allocations from X509 library

Author: stephentoub

src/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Helpers.cs

@@ -2,10 +2,8 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
-using System.Text;
 using System.Diagnostics;
 using System.Globalization;
-using System.Security.Cryptography;
 
 namespace Internal.Cryptography
 {
@@ -16,59 +14,54 @@ public static byte[] CloneByteArray(this byte[] src)
             return (byte[])(src.Clone());
         }
 
-        // Encode a byte array as an upper case hex string.
-        public static String ToHexStringUpper(this byte[] bytes)
+        // Encode a byte array as an array of upper-case hex characters.
+        public static char[] ToHexArrayUpper(this byte[] bytes)
         {
-            StringBuilder sb = new StringBuilder(bytes.Length * 2);
+            char[] chars = new char[bytes.Length * 2];
+            int i = 0;
             foreach (byte b in bytes)
             {
-                sb.AppendFormat("{0:X2}", b);
+                chars[i++] = NibbleToHex((byte)(b >> 4));
+                chars[i++] = NibbleToHex((byte)(b & 0xF));
             }
-            return sb.ToString();
+            return chars;
+        }
+
+        // Encode a byte array as an upper case hex string.
+        public static string ToHexStringUpper(this byte[] bytes)
+        {
+            return new string(ToHexArrayUpper(bytes));
         }
 
         // Decode a hex string-encoded byte array passed to various X509 crypto api. The parsing rules are overly forgiving but for compat reasons,
         // they cannot be tightened.
-        public static byte[] DecodeHexString(this String s)
+        public static byte[] DecodeHexString(this string s)
         {
-            String hexString = DiscardWhiteSpaces(s);
-            uint cbHex = (uint)hexString.Length / 2;
-            byte[] hex = new byte[cbHex];
-            int i = 0;
-            for (int index = 0; index < cbHex; index++)
+            int whitespaceCount = 0;
+
+            for (int i = 0; i < s.Length; i++)
             {
-                hex[index] = (byte)((HexToByte(hexString[i]) << 4) | HexToByte(hexString[i + 1]));
-                i += 2;
+                if (char.IsWhiteSpace(s[i]))
+                    whitespaceCount++;
             }
-            return hex;
-        }
 
-        private static String DiscardWhiteSpaces(String inputBuffer)
-        {
-            return DiscardWhiteSpaces(inputBuffer, 0, inputBuffer.Length);
-        }
+            uint cbHex = (uint)(s.Length - whitespaceCount) / 2;
+            byte[] hex = new byte[cbHex];
 
-        private static String DiscardWhiteSpaces(String inputBuffer, int inputOffset, int inputCount)
-        {
-            int i, iCount = 0;
-            for (i = 0; i < inputCount; i++)
+            for (int index = 0, i = 0; index < cbHex; index++)
             {
-                if (Char.IsWhiteSpace(inputBuffer[inputOffset + i]))
+                if (char.IsWhiteSpace(s[i]))
                 {
-                    iCount++;
+                    i++;
                 }
-            }
-
-            char[] rgbOut = new char[inputCount - iCount];
-            iCount = 0;
-            for (i = 0; i < inputCount; i++)
-            {
-                if (!Char.IsWhiteSpace(inputBuffer[inputOffset + i]))
+                else
                 {
-                    rgbOut[iCount++] = inputBuffer[inputOffset + i];
+                    hex[index] = (byte)((HexToByte(s[i]) << 4) | HexToByte(s[i + 1]));
+                    i += 2;
                 }
             }
-            return new String(rgbOut);
+
+            return hex;
         }
 
         private static byte HexToByte(char val)
@@ -83,6 +76,14 @@ private static byte HexToByte(char val)
                 return 0xFF;
         }
 
+        private static char NibbleToHex(byte b)
+        {
+            Debug.Assert(b >= 0 && b <= 15);
+            return (char)(b >= 0 && b <= 9 ? 
+                '0' + b : 
+                'A' + (b - 10));
+        }
+
         public static bool ContentsEqual(this byte[] a1, byte[] a2)
         {
             if (a1.Length != a2.Length)
@@ -115,5 +116,3 @@ private static bool IsValidYear(this Calendar calendar, int year, int era)
         }
     }
 }
-
-

src/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Windows/CertificatePal.PrivateKey.cs

@@ -41,7 +41,7 @@ public AsymmetricAlgorithm PrivateKey
                 // We never want to stomp over certificate private keys.
                 cspParameters.Flags |= CspProviderFlags.UseExistingKey;
 
-                int algId = OidInfo.FindOidInfo(CryptOidInfoKeyType.CRYPT_OID_INFO_OID_KEY, this.KeyAlgorithm, OidGroup.PublicKeyAlgorithm, fallBackToAllGroups: true).AlgId;
+                int algId = OidInfo.FindOidInfo(CryptOidInfoKeyType.CRYPT_OID_INFO_OID_KEY, KeyAlgorithm, OidGroup.PublicKeyAlgorithm, fallBackToAllGroups: true).AlgId;
                 switch (algId)
                 {
                     case AlgId.CALG_RSA_KEYX:

src/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Windows/CertificatePal.cs

@@ -396,7 +396,7 @@ public void AppendPrivateKeyInfo(StringBuilder sb)
             CspKeyContainerInfo cspKeyContainerInfo = null;
             try
             {
-                if (this.HasPrivateKey)
+                if (HasPrivateKey)
                 {
                     CspParameters parameters = GetPrivateKey();
                     cspKeyContainerInfo = new CspKeyContainerInfo(parameters);

src/System.Security.Cryptography.X509Certificates/src/Internal/Cryptography/Pal.Windows/StorePal.Find.cs

@@ -449,7 +449,7 @@ private static void ValidateOidValue(String keyValue)
             for (int i = 1; i < len; i++)
             {
                 // ensure every character is either a digit or a dot
-                if (Char.IsDigit(keyValue[i]))
+                if (char.IsDigit(keyValue[i]))
                     continue;
                 if (keyValue[i] != '.' || keyValue[i + 1] == '.') // disallow double dots
                     throw new ArgumentException(SR.Argument_InvalidOidValue);

src/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/PublicKey.cs

@@ -18,8 +18,8 @@ public sealed class PublicKey
         public PublicKey(Oid oid, AsnEncodedData parameters, AsnEncodedData keyValue)
         {
             _oid = new Oid(oid);
-            this.EncodedParameters = new AsnEncodedData(parameters);
-            this.EncodedKeyValue = new AsnEncodedData(keyValue);
+            EncodedParameters = new AsnEncodedData(parameters);
+            EncodedKeyValue = new AsnEncodedData(keyValue);
             return;
         }
 
@@ -33,7 +33,7 @@ public AsymmetricAlgorithm Key
             {
                 AsymmetricAlgorithm key = _lazyKey;
                 if (key == null)
-                    key = _lazyKey = X509Pal.Instance.DecodePublicKey(this.Oid, this.EncodedKeyValue.RawData, this.EncodedParameters.RawData);
+                    key = _lazyKey = X509Pal.Instance.DecodePublicKey(Oid, EncodedKeyValue.RawData, EncodedParameters.RawData);
                 return key;
             }
         }

src/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X500DistinguishedName.cs

@@ -58,12 +58,12 @@ public String Name
         public String Decode(X500DistinguishedNameFlags flag)
         {
             ThrowIfInvalid(flag);
-            return X509Pal.Instance.X500DistinguishedNameDecode(this.RawData, flag);
+            return X509Pal.Instance.X500DistinguishedNameDecode(RawData, flag);
         }
 
         public override String Format(bool multiLine)
         {
-            return X509Pal.Instance.X500DistinguishedNameFormat(this.RawData, multiLine);
+            return X509Pal.Instance.X500DistinguishedNameFormat(RawData, multiLine);
         }
 
         private static byte[] Encode(String distinguishedName, X500DistinguishedNameFlags flags)

src/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509BasicConstraintsExtension.cs

@@ -82,9 +82,9 @@ private static byte[] EncodeExtension(bool certificateAuthority, bool hasPathLen
         private void DecodeExtension()
         {
             if (Oid.Value == Oids.BasicConstraints)
-                X509Pal.Instance.DecodeX509BasicConstraintsExtension(this.RawData, out _certificateAuthority, out _hasPathLenConstraint, out _pathLenConstraint);
+                X509Pal.Instance.DecodeX509BasicConstraintsExtension(RawData, out _certificateAuthority, out _hasPathLenConstraint, out _pathLenConstraint);
             else
-                X509Pal.Instance.DecodeX509BasicConstraints2Extension(this.RawData, out _certificateAuthority, out _hasPathLenConstraint, out _pathLenConstraint);
+                X509Pal.Instance.DecodeX509BasicConstraints2Extension(RawData, out _certificateAuthority, out _hasPathLenConstraint, out _pathLenConstraint);
 
             _decoded = true;
         }

src/System.Security.Cryptography.X509Certificates/src/System/Security/Cryptography/X509Certificates/X509Certificate.cs

@@ -125,21 +125,21 @@ public override bool Equals(Object obj)
             X509Certificate other = obj as X509Certificate;
             if (other == null)
                 return false;
-            return this.Equals(other);
+            return Equals(other);
         }
 
         public virtual bool Equals(X509Certificate other)
         {
             if (other == null)
                 return false;
 
-            if (this.Pal == null)
+            if (Pal == null)
                 return other.Pal == null;
 
-            if (!this.Issuer.Equals(other.Issuer))
+            if (!Issuer.Equals(other.Issuer))
                 return false;
 
-            byte[] thisSerialNumber = this.GetSerialNumber();
+            byte[] thisSerialNumber = GetSerialNumber();
             byte[] otherSerialNumber = other.GetSerialNumber();
             if (thisSerialNumber.Length != otherSerialNumber.Length)
                 return false;
@@ -262,32 +262,44 @@ public virtual String ToString(bool fVerbose)
             StringBuilder sb = new StringBuilder();
 
             // Subject
-            sb.Append("[Subject]" + Environment.NewLine + "  ");
-            sb.Append(this.Subject);
+            sb.AppendLine("[Subject]");
+            sb.Append("  ");
+            sb.AppendLine(Subject);
 
             // Issuer
-            sb.Append(Environment.NewLine + Environment.NewLine + "[Issuer]" + Environment.NewLine + "  ");
-            sb.Append(this.Issuer);
+            sb.AppendLine();
+            sb.AppendLine("[Issuer]");
+            sb.Append("  ");
+            sb.AppendLine(Issuer);
 
             // Serial Number
-            sb.Append(Environment.NewLine + Environment.NewLine + "[Serial Number]" + Environment.NewLine + "  ");
-            byte[] serialNumber = this.GetSerialNumber();
+            sb.AppendLine();
+            sb.AppendLine("[Serial Number]");
+            sb.Append("  ");
+            byte[] serialNumber = GetSerialNumber();
             Array.Reverse(serialNumber);
-            sb.Append(serialNumber.ToHexStringUpper());
+            sb.Append(serialNumber.ToHexArrayUpper());
+            sb.AppendLine();
 
             // NotBefore
-            sb.Append(Environment.NewLine + Environment.NewLine + "[Not Before]" + Environment.NewLine + "  ");
-            sb.Append(FormatDate(this.GetNotBefore()));
+            sb.AppendLine();
+            sb.AppendLine("[Not Before]");
+            sb.Append("  ");
+            sb.AppendLine(FormatDate(GetNotBefore()));
 
             // NotAfter
-            sb.Append(Environment.NewLine + Environment.NewLine + "[Not After]" + Environment.NewLine + "  ");
-            sb.Append(FormatDate(this.GetNotAfter()));
+            sb.AppendLine();
+            sb.AppendLine("[Not After]");
+            sb.Append("  ");
+            sb.AppendLine(FormatDate(GetNotAfter()));
 
             // Thumbprint
-            sb.Append(Environment.NewLine + Environment.NewLine + "[Thumbprint]" + Environment.NewLine + "  ");
-            sb.Append(this.GetCertHash().ToHexStringUpper());
+            sb.AppendLine();
+            sb.AppendLine("[Thumbprint]");
+            sb.Append("  ");
+            sb.Append(GetCertHash().ToHexArrayUpper());
+            sb.AppendLine();
 
-            sb.Append(Environment.NewLine);
             return sb.ToString();
         }
 
@@ -362,4 +374,3 @@ internal static String FormatDate(DateTime date)
         private const X509KeyStorageFlags KeyStorageFlagsAll = (X509KeyStorageFlags)0x1f;
     }
 }
-