Create X509Certificate2 from PEM file in .NET Core

前端 未结 2 1817
情话喂你
情话喂你 2021-02-13 04:22

I want to create a X509Certificate2 object based on a PEM file. The problem is setting the PrivateKey property of X509Certificate2. I read X509Certificate2.CreateFromCertFile()

相关标签:
2条回答
  • 2021-02-13 04:46

    If you've just extracted the bytes from the Base64 encoding of the private key file you have a PKCS#1, PKCS#8, or encrypted PKCS#8 private key blob (depending on if it said "BEGIN RSA PRIVATE KEY", "BEGIN PRIVATE KEY" or "BEGIN ENCRYPTED PRIVATE KEY"). ImportCspBlob wants a custom format for the data, and that's why it's complaining.

    Digital signature in c# without using BouncyCastle has an explanation of ways forward. The easiest / most formulaic is to just make a PFX with the cert and key, and let the X509Certificate2 constructor do its thing.

    If you go the route of loading the key object directly then the way you would mate a private key with the certificate is to use one of the new CopyWithPrivateKey extension methods. This returns a new instance of X509Certificate2 which knows about the private key.

    The PrivateKey setter was "removed" from .NET Core because it has a lot of side effects on Windows that are hard to replicate on Linux and macOS, particularly if you retrieved the certificate out of an instance of X509Store.


    This code is a combination of overly strict and overly accepting for real BER rules, but this should read validly encoded PKCS#8 files unless they included attributes.

    private static readonly byte[] s_derIntegerZero = { 0x02, 0x01, 0x00 };
    
    private static readonly byte[] s_rsaAlgorithmId =
    {
        0x30, 0x0D,
        0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
        0x05, 0x00,
    };
    
    private static int ReadLength(byte[] data, ref int offset)
    {
        byte lengthOrLengthLength = data[offset++];
    
        if (lengthOrLengthLength < 0x80)
        {
            return lengthOrLengthLength;
        }
    
        int lengthLength = lengthOrLengthLength & 0x7F;
        int length = 0;
    
        for (int i = 0; i < lengthLength; i++)
        {
            if (length > ushort.MaxValue)
            {
                throw new InvalidOperationException("This seems way too big.");
            }
    
            length <<= 8;
            length |= data[offset++];
        }
    
        return length;
    }
    
    private static byte[] ReadUnsignedInteger(byte[] data, ref int offset, int targetSize = 0)
    {
        if (data[offset++] != 0x02)
        {
            throw new InvalidOperationException("Invalid encoding");
        }
    
        int length = ReadLength(data, ref offset);
    
        // Encoding rules say 0 is encoded as the one byte value 0x00.
        // Since we expect unsigned, throw if the high bit is set.
        if (length < 1 || data[offset] >= 0x80)
        {
            throw new InvalidOperationException("Invalid encoding");
        }
    
        byte[] ret;
    
        if (length == 1)
        {
            ret = new byte[length];
            ret[0] = data[offset++];
            return ret;
        }
    
        if (data[offset] == 0)
        {
            offset++;
            length--;
        }
    
        if (targetSize != 0)
        {
            if (length > targetSize)
            {
                throw new InvalidOperationException("Bad key parameters");
            }
    
            ret = new byte[targetSize];
        }
        else
        {
            ret = new byte[length];
        }
    
        Buffer.BlockCopy(data, offset, ret, ret.Length - length, length);
        offset += length;
        return ret;
    }
    
    private static void EatFullPayloadTag(byte[] data, ref int offset, byte tagValue)
    {
        if (data[offset++] != tagValue)
        {
            throw new InvalidOperationException("Invalid encoding");
        }
    
        int length = ReadLength(data, ref offset);
    
        if (data.Length - offset != length)
        {
            throw new InvalidOperationException("Data does not represent precisely one value");
        }
    }
    
    private static void EatMatch(byte[] data, ref int offset, byte[] toMatch)
    {
        if (data.Length - offset > toMatch.Length)
        {
            if (data.Skip(offset).Take(toMatch.Length).SequenceEqual(toMatch))
            {
                offset += toMatch.Length;
                return;
            }
        }
    
        throw new InvalidOperationException("Bad data.");
    }
    
    private static RSA DecodeRSAPkcs8(byte[] pkcs8Bytes)
    {
        int offset = 0;
    
        // PrivateKeyInfo SEQUENCE
        EatFullPayloadTag(pkcs8Bytes, ref offset, 0x30);
        // PKCS#8 PrivateKeyInfo.version == 0
        EatMatch(pkcs8Bytes, ref offset, s_derIntegerZero);
        // rsaEncryption AlgorithmIdentifier value
        EatMatch(pkcs8Bytes, ref offset, s_rsaAlgorithmId);
        // PrivateKeyInfo.privateKey OCTET STRING
        EatFullPayloadTag(pkcs8Bytes, ref offset, 0x04);
        // RSAPrivateKey SEQUENCE
        EatFullPayloadTag(pkcs8Bytes, ref offset, 0x30);
        // RSAPrivateKey.version == 0
        EatMatch(pkcs8Bytes, ref offset, s_derIntegerZero);
    
        RSAParameters rsaParameters = new RSAParameters();
        rsaParameters.Modulus = ReadUnsignedInteger(pkcs8Bytes, ref offset);
        rsaParameters.Exponent = ReadUnsignedInteger(pkcs8Bytes, ref offset);
        rsaParameters.D = ReadUnsignedInteger(pkcs8Bytes, ref offset, rsaParameters.Modulus.Length);
        int halfModulus = (rsaParameters.Modulus.Length + 1) / 2;
        rsaParameters.P = ReadUnsignedInteger(pkcs8Bytes, ref offset, halfModulus);
        rsaParameters.Q = ReadUnsignedInteger(pkcs8Bytes, ref offset, halfModulus);
        rsaParameters.DP = ReadUnsignedInteger(pkcs8Bytes, ref offset, halfModulus);
        rsaParameters.DQ = ReadUnsignedInteger(pkcs8Bytes, ref offset, halfModulus);
        rsaParameters.InverseQ = ReadUnsignedInteger(pkcs8Bytes, ref offset, halfModulus);
    
        if (offset != pkcs8Bytes.Length)
        {
            throw new InvalidOperationException("Something didn't add up");
        }
    
        RSA rsa = RSA.Create();
        rsa.ImportParameters(rsaParameters);
        return rsa;
    }
    
    0 讨论(0)
  • 2021-02-13 04:50

    Using .NET 5.0 we finally have a nice way of doing this.

    The X509Certificate2 class provides two static methods X509Certificate2.CreateFromPem and X509Certificate2.CreateFromPemFile. So if you have the file path then can call:

    var cert = X509Certificate2.CreateFromPemFile(filePath);
    

    If creating the certificate without the file then can pass in ReadOnlySpan<char> for the certificate thumbprint and key. There are also X509Certificate2.CreateFromEncryptedPem and X509Certificate2.CreateFromEncryptedPemFile if the contents is encrypted.

    More info can be found in the official API docs here: https://docs.microsoft.com/en-us/dotnet/api/system.security.cryptography.x509certificates.x509certificate2.createfrompemfile?view=net-5.0

    0 讨论(0)
提交回复
热议问题