Add X509Certificate2 to System.Net API

[josesimoes]

cc @networkfusion

[josesimoes]

In progress just needed a placeholder for related discussions and notes.

[kurtnelle]

Does this mean we can connect to https sites easily?

[josesimoes]

You can already connect to HTTPS sites now. There is support for X509Certificate.
Check the SSL sample pack. There is a sample connecting to a couple of HTTPS test servers and performing a simple HTTP get request.

This one is to address a different problem: dynamically load the certificate and private key, choose the encryption password and get the final certificate from combining those.

[josesimoes]

• Discussion on how to get this done with .NET Core here

• API wih this improvement on .NET Core here

[networkfusion]

To start with, as long as we can parse a pfx certificate in bytes, then we should be able to connect (as that already contains the private key).

The full framework supports the setting of the private key, but core does not (currently). I would suggest our implementation does allow for it...

[networkfusion]

The 2 classes that I use with the full framework to help with converting the cert above what .net offers are

//Source from https://github.com/AlexanderPro/Utilities

using System;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.IO;
using Utilities.Extensions;

namespace Utilities.Security.Cryptography.X509Certificates
{
    public static class Crypto
    {
         /// <summary>
        /// Parses an RSA private key using the ASN.1 format.
        /// </summary>
        /// <param name="privateKey">Byte array containing PEM string of private key.</param>
        /// <returns>An instance of <see cref="RSACryptoServiceProvider"/> representing the requested private key.</returns>
        public static RSACryptoServiceProvider DecodeRsaPrivateKey(byte[] privateKey)
        {
            using (var memoryStream = new MemoryStream(privateKey))
            {
                using (var binaryReader = new BinaryReader(memoryStream))
                {
                    ushort shortValue = binaryReader.ReadUInt16();
                    switch (shortValue)
                    {
                        // If true, data is little endian since the proper logical seq is 0x30 0x81
                        case 0x8130: binaryReader.ReadByte(); break;
                        case 0x8230: binaryReader.ReadInt16(); break;
                        default: throw new CryptographicException("Improper ASN.1 format");
                    }

                    // (version number)
                    shortValue = binaryReader.ReadUInt16();
                    if (shortValue != 0x0102) throw new CryptographicException("Improper ASN.1 format, unexpected version number");

                    byte byteValue = binaryReader.ReadByte();
                    if (byteValue != 0x00) throw new CryptographicException("Improper ASN.1 format");

                    // The data following the version will be the ASN.1 data itself, which in our case
                    // are a sequence of integers.
                    // In order to solve a problem with instancing RSACryptoServiceProvider
                    // via default constructor on .net 4.0 this is a hack
                    var @params = new CspParameters
                    {
                        Flags = CspProviderFlags.NoFlags,
                        KeyContainerName = Guid.NewGuid().ToString().ToUpperInvariant(),
                        ProviderType = ((Environment.OSVersion.Version.Major > 5) || ((Environment.OSVersion.Version.Major == 5) && (Environment.OSVersion.Version.Minor >= 1))) ? 0x18 : 1
                    };

                    var rsaProvider = new RSACryptoServiceProvider(@params);
                    var rsaParams = new RSAParameters
                    {
                        Modulus = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader))
                    };

                    // Argh, this is a pain.  From emperical testing it appears to be that RSAParameters doesn't like Byte buffers that
                    // have their leading zeros removed.  The RFC doesn't address this area that I can see, so it's hard to say that this
                    // is a bug, but it sure would be helpful if it allowed that. So, there's some extra code here that knows what the
                    // sizes of the various components are supposed to be.  Using these sizes we can ensure the buffer sizes are exactly
                    // what the RSAParameters expect.  Thanks, Microsoft.
                    var traits = new RSAParameterTraits(rsaParams.Modulus.Length * 8);
                    rsaParams.Modulus = rsaParams.Modulus.PadLeft(traits.SizeMod, 0x00);
                    rsaParams.Exponent = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeExp, 0x00);
                    rsaParams.D = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeD, 0x00);
                    rsaParams.P = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeP, 0x00);
                    rsaParams.Q = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeQ, 0x00);
                    rsaParams.DP = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeDP, 0x00);
                    rsaParams.DQ = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeDQ, 0x00);
                    rsaParams.InverseQ = binaryReader.ReadBytes(DecodeIntegerSize(binaryReader)).PadLeft(traits.SizeInvQ, 0x00);

                    rsaProvider.ImportParameters(rsaParams);
                    return rsaProvider;
                }
            }
        }

        /// <summary>
        /// Creates X509 certificate
        /// </summary>
        /// <param name="publicCertificate">PEM string of public certificate.</param>
        /// <param name="privateKey">PEM string of private key.</param>
        /// <param name="password">Password for certificate.</param>
        /// <returns>An instance of <see cref="X509Certificate2"/> rapresenting the X509 certificate.</returns>
        public static X509Certificate2 GetCertificateFromPEMstring(string publicCertificate, string privateKey, string password)
        {
            X509Certificate2 certificate = new X509Certificate2(GetBytesFromPemString(publicCertificate, PemStringType.Certificate), password);
            RSACryptoServiceProvider provider = DecodeRsaPrivateKey(GetBytesFromPemString(privateKey, PemStringType.RsaPrivateKey));
            certificate.PrivateKey = provider;
            return certificate;
        }

        private static int DecodeIntegerSize(BinaryReader rd)
        {
            int count;

            byte byteValue = rd.ReadByte();
            if (byteValue != 0x02) return 0;

            byteValue = rd.ReadByte();
            switch (byteValue)
            {
                case 0x81:
                    count = rd.ReadByte();
                    break;
                case 0x82:
                    byte highByte = rd.ReadByte();
                    byte lowByte = rd.ReadByte();
                    count = BitConverter.ToUInt16(new[] { lowByte, highByte }, 0);
                    break;
                default:
                    count = byteValue;
                    break;
            }

            while (rd.ReadByte() == 0x00)
            {
                count -= 1;
            }
            rd.BaseStream.Seek(-1, SeekOrigin.Current);

            return count;
        }

        private static byte[] GetBytesFromPemString(string pemString, PemStringType type)
        {
            string header, footer;

            switch (type)
            {
                case PemStringType.Certificate:
                    header = "-----BEGIN CERTIFICATE-----";
                    footer = "-----END CERTIFICATE-----";
                    break;
                case PemStringType.RsaPrivateKey:
                    header = "-----BEGIN RSA PRIVATE KEY-----";
                    footer = "-----END RSA PRIVATE KEY-----";
                    break;
                case PemStringType.PublicKey:
                    header = "-----BEGIN PUBLIC KEY-----";
                    footer = "-----END PUBLIC KEY-----";
                    break;
                default:
                    return null;
            }

            int start = pemString.IndexOf(header) + header.Length;
            int end = pemString.IndexOf(footer, start) - start;
            return Convert.FromBase64String(pemString.Substring(start, end));
        }

        

        private enum PemStringType
        {
            Certificate,
            RsaPrivateKey,
            PublicKey
        }
    }
}

and

//Source from https://github.com/AlexanderPro/Utilities
//but likely originally from https://github.com/jrnker/CSharp-easy-RSA-PEM GPL V3

using System;
using System.Security.Cryptography;

namespace Utilities.Security.Cryptography.X509Certificates
{
    internal class RSAParameterTraits
    {
        public int SizeMod { get; private set; }
        public int SizeExp { get; private set; }
        public int SizeD { get; private set; }
        public int SizeP { get; private set; }
        public int SizeQ { get; private set; }
        public int SizeDP { get; private set; }
        public int SizeDQ { get; private set; }
        public int SizeInvQ { get; private set; }

        public RSAParameterTraits(int modulusLengthInBits)
        {
            // The modulus length is supposed to be one of the common lengths, which is the commonly referred to strength of the key,
            // like 1024 bit, 2048 bit, etc.  It might be a few bits off though, since if the modulus has leading zeros it could show
            // up as 1016 bits or something like that.
            int assumedLength = -1;
            double logbase = Math.Log(modulusLengthInBits, 2);
            if (logbase == (int)logbase)
            {
                assumedLength = modulusLengthInBits;
            }
            else
            {
                assumedLength = (int)(logbase + 1.0);
                assumedLength = (int)(Math.Pow(2, assumedLength));
            }

            switch (assumedLength)
            {
                case 1024:
                    SizeMod = 0x80;
                    SizeExp = -1;
                    SizeD = 0x80;
                    SizeP = 0x40;
                    SizeQ = 0x40;
                    SizeDP = 0x40;
                    SizeDQ = 0x40;
                    SizeInvQ = 0x40;
                    break;
                case 2048:
                    SizeMod = 0x100;
                    SizeExp = -1;
                    SizeD = 0x100;
                    SizeP = 0x80;
                    SizeQ = 0x80;
                    SizeDP = 0x80;
                    SizeDQ = 0x80;
                    SizeInvQ = 0x80;
                    break;
                case 4096:
                    SizeMod = 0x200;
                    SizeExp = -1;
                    SizeD = 0x200;
                    SizeP = 0x100;
                    SizeQ = 0x100;
                    SizeDP = 0x100;
                    SizeDQ = 0x100;
                    SizeInvQ = 0x100;
                    break;
                default:
                    throw new CryptographicException("Unknown key size");
            }
        }
    }
}

with an extension method

//Source from https://github.com/AlexanderPro/Utilities

using System;
using System.Linq;

namespace Utilities.Extensions
{
    public static class ByteArrayExtensions
    {
        /// <summary>
        /// Returns a new array that right-aligns the elements in this instance by padding them on the left with a specified element, for a specified total length.
        /// </summary>
        /// <param name="value">The source byte array.</param>
        /// <param name="totalLength">The number of elements in the resulting array, equal to the number of original elements plus any additional padding elements.</param>
        /// <param name="element">A padding element.</param>
        /// <returns>The result byte array.</returns>
        public static byte[] PadLeft(this byte[] value, int totalLength, byte element)
        {
            //see https://stackoverflow.com/questions/25028609/how-do-i-left-pad-a-byte-array-efficiently
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if (value.Length >= totalLength)
            {
                return value;
            }

            var result = Enumerable.Repeat(element, totalLength).ToArray();
            long startIndex = totalLength - value.Length;
            Array.Copy(value, 0, result, startIndex, value.Length);
            return result;
        }
    }
}