PKCS#1 to PKCS#8 convertion

[dvkovner]

Hello. I need to convert certificate's public key from the PKCS#1 format to the PKCS#8 format. For that I'm using the next functions in C# / .Net Framework 4.7-4.8 (X509Certificate2 is from the System.Security.Cryptography.X509Certificates namespace):

        public static byte[] GetPublicKeyInPKCS8Format(X509Certificate2 certificate)
        {
            // Convert the X.509 certificate into a BouncyCastle X509Certificate object
            var parser = new X509CertificateParser();
            var bouncyCert = parser.ReadCertificate(certificate.RawData);

            // Extract the public key from the BouncyCastle X509Certificate
            var publicKey = bouncyCert.GetPublicKey();

            // If the public key is RSA, export it as PKCS#8
            if (publicKey is RsaKeyParameters rsaKey)
            {
                return ExportRSAPublicKeyToPKCS8(rsaKey);
            }
            else
            {
                throw new NotSupportedException("Only RSA keys are supported in this example.");
            }
        }

        private static byte[] ExportRSAPublicKeyToPKCS8(RsaKeyParameters rsaKey)
        {
            // Step 1: Prepare the SubjectPublicKeyInfo structure for RSA public key
            // Construct the AlgorithmIdentifier (OID for RSA)
            var rsaOid = new DerObjectIdentifier(PkcsObjectIdentifiers.RsaEncryption.ToString());  // RSA OID
            var algorithmIdentifier = new AlgorithmIdentifier(rsaOid); // Create the AlgorithmIdentifier

            // Step 2: Create the RSA public key structure
            // RSA public key = modulus + exponent
            var modulus = new DerInteger(rsaKey.Modulus);
            var exponent = new DerInteger(rsaKey.Exponent);

            // Combine modulus and exponent into an RSA public key
            var rsaPublicKey = new DerSequence(modulus, exponent); // This is an ASN.1 sequence of two elements

            // Step 3: Create SubjectPublicKeyInfo structure
            // The public key structure must be encoded as SubjectPublicKeyInfo
            var subjectPublicKeyInfo = new SubjectPublicKeyInfo(algorithmIdentifier, rsaPublicKey);

            return subjectPublicKeyInfo.GetEncoded();
        }

It works well for me except a little difference in bytes (generated with BitConverter.ToString()) which is shown on the picture (expected result which I came across on other platforms such as NodeJS, for example, is on the right side and the result which the Bouncy Castle library is generating is on the left side).

I guess the main problem are bytes 05-00 which due to some reasons the bouncy castle library does not add to the generated key because the first two differences in bytes I think simply depend on total number of bytes. What do I need to do to force the library to add this magic 05-00 bytes to the generated public key? It is important for me because I'm obtaining SHA256 hash on these bytes which generates an unexpected value.

[peterdettman]

Try this change:

    new AlgorithmIdentifier(PkcsObjectIdentifiers.RsaEncryption, DerNull.Instance)

Probably the whole example could be reduced to:

    var publicKey = DotNetUtilities.FromX509Certificate(certificate).GetPublicKey();
    return SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey).GetEncoded(Asn1Encodable.Der);

which will work for other algorithms besides RSA too.

[KonradSop]

I’ve noticed that the issue of RSA NULL parameters and general PKCS#8/X.509 export from .NET certificates comes up frequently. To simplify this for everyone, I have submitted Pull Request #670, which formalizes the workarounds discussed here into the library itself.

Key improvements in the PR:

Convenience API: Added GetSubjectPublicKeyInfo and GetSubjectPublicKeyInfoDer to DotNetUtilities. This allows exporting the public key from an X509Certificate2 in a single line of code.
Verified RSA Encoding: Included a new test suite (Pkcs8Test.cs) that explicitly verifies the presence of mandatory 05 00 (DER NULL) parameters for RSA, ensuring full compatibility with other crypto providers.
Better Documentation: Modernized the XML documentation for these factories with C# examples and proper .NET exception handling.
I hope this helps formalize the solution and makes the library even easier to use for the .NET community!