将私钥/公钥从 X509 证书导出到 PEM

Question

有没有什么方便的方法可以使用 .NET Core从 PEM 格式的 .p12 证书中导出私钥/公钥？ 没有在低级别操作字节？ 我用谷歌搜索了几个小时，几乎没有任何东西在 .net core 中可用，或者它没有在任何地方记录。

让我们有一个 X509Certificate2

var cert = new X509Certificate2(someBytes, pass);
var privateKey = cert.GetRSAPrivateKey();
var publicKey = cert.GetRSAPublicKey();
// assume everything is fine so far

现在我需要将密钥导出为两个单独的 PEM 密钥。 我已经在 BouncyCastle 中尝试过PemWriter ，但这些类型与 Core 中的 System.Security.Cryptography 不兼容......没有运气。

换句话说，我正在寻找一种方法来写这个：

$ openssl pkcs12 -in path/to/cert.p12 -out public.pub -clcerts -nokeys
$ openssl pkcs12 -in path/to/cert.p12 -out private.key -nocerts

有人有想法吗？

谢谢

Answer 1

更新 (2021-01-12) ：对于 .NET 5，这很容易。 .NET Core 3.0 甚至可以完成大部分工作。 最初的答案是在 .NET Core 1.1 是 .NET Core 的最新版本时编写的。 它解释了这些新方法在幕后做了什么。

.NET 5+：

byte[] certificateBytes = cert.RawData;
char[] certificatePem = PemEncoding.Write("CERTIFICATE", certificateBytes);

AsymmetricAlgorithm key = cert.GetRSAPrivateKey() ?? cert.GetECDsaPrivateKey();
byte[] pubKeyBytes = key.ExportSubjectPublicKeyInfo();
byte[] privKeyBytes = key.ExportPkcs8PrivateKey();
char[] pubKeyPem = PemEncoding.Write("PUBLIC KEY", pubKeyBytes);
char[] privKeyPem = PemEncoding.Write("PRIVATE KEY", privKeyBytes);

如果需要， new string(char[])可以将这些字符数组转换为System.String实例。

对于加密的 PKCS#8，它仍然很容易，但是您必须对如何加密它做出一些选择：

byte[] encryptedPrivKeyBytes = key.ExportEncryptedPkcs8PrivateKey(
    password,
    new PbeParameters(
        PbeEncryptionAlgorithm.Aes256Cbc,
        HashAlgorithmName.SHA256,
        iterationCount: 100_000));

.NET 核心 3.0、.NET 核心 3.1：

这与 .NET 5 答案相同，只是PemEncoding类尚不存在。 但这没关系，旧答案中有一个 PEM-ifier 的开始（尽管 "CERTIFICATE" 和cert.RawData ）需要来自参数）。

.NET Core 3.0 是添加了额外密钥格式导出和导入方法的版本。

.NET 核心 2.0、.NET 核心 2.1：

与原始答案相同，只是您不需要编写 DER 编码器。 您可以使用System.Formats.Asn1 NuGet 包。

原始答案（.NET Core 1.1 是最新的选项）：

答案介于“不”和“不是真的”之间。

我将假设您不希望 p12 输出在public.pub和private.key顶部。

public.pub只是证书。 openssl命令行实用程序更喜欢 PEM 编码的数据，因此我们将编写一个 PEM 编码的证书（注意，这是一个证书，而不是公钥。它包含一个公钥，但它本身不是一个）：

using (var cert = new X509Certificate2(someBytes, pass))
{
    StringBuilder builder = new StringBuilder();
    builder.AppendLine("-----BEGIN CERTIFICATE-----");
    builder.AppendLine(
        Convert.ToBase64String(cert.RawData, Base64FormattingOptions.InsertLineBreaks));
    builder.AppendLine("-----END CERTIFICATE-----");

    return builder.ToString();
}

私钥更难。 假设密钥是可导出的（如果您在 Windows 或 macOS 上，则不是，因为您没有断言X509KeyStorageFlags.Exportable ）您可以使用privateKey.ExportParameters(true)获取参数。 但现在你必须把它写下来。

一个 RSA 私钥被写入一个 PEM 编码的文件，它的标签是“RSA PRIVATE KEY”，其有效载荷是 ASN.1 ( ITU-T X.680 ) RSAPrivateKey (PKCS#1 / RFC3447 ) 结构，通常是 DER 编码的 ( ITU-T X.690 ）——虽然因为它没有签名，所以没有特定的 DER 限制，但许多读者可能会假设 DER。

或者，它可以是 PKCS#8 ( RFC 5208 ) PrivateKeyInfo（标签：“PRIVATE KEY”）或 EncryptedPrivateKeyInfo（标签：“ENCRYPTED PRIVATE KEY”）。 由于 EncryptedPrivateKeyInfo 包装了 PrivateKeyInfo，后者封装了 RSAPrivateKey，我们就从这里开始。

  RSAPrivateKey ::= SEQUENCE {
      version           Version,
      modulus           INTEGER,  -- n
      publicExponent    INTEGER,  -- e
      privateExponent   INTEGER,  -- d
      prime1            INTEGER,  -- p
      prime2            INTEGER,  -- q
      exponent1         INTEGER,  -- d mod (p-1)
      exponent2         INTEGER,  -- d mod (q-1)
      coefficient       INTEGER,  -- (inverse of q) mod p
      otherPrimeInfos   OtherPrimeInfos OPTIONAL
  }

现在忽略关于 otherPrimeInfos 的部分。 exponent1是 DP， exponent2是 DQ，并且coefficient是 InverseQ。

让我们使用预先发布的 384 位 RSA 密钥。

RFC 3447 说我们想要 Version=0。 其他一切都来自结构。

// SEQUENCE (RSAPrivateKey)
30 xa [ya [za]]
   // INTEGER (Version=0)
   02 01
         00
   // INTEGER (modulus)
   // Since the most significant bit if the most significant content byte is set,
   // add a padding 00 byte.
   02 31
         00
         DA CC 22 D8 6E 67 15 75 03 2E 31 F2 06 DC FC 19
         2C 65 E2 D5 10 89 E5 11 2D 09 6F 28 82 AF DB 5B
         78 CD B6 57 2F D2 F6 1D B3 90 47 22 32 E3 D9 F5
   // INTEGER publicExponent
   02 03
         01 00 01
   // INTEGER (privateExponent)
   // high bit isn't set, so no padding byte
   02 30
         DA CC 22 D8 6E 67 15 75 03 2E 31 F2 06 DC FC 19
         2C 65 E2 D5 10 89 E5 11 2D 09 6F 28 82 AF DB 5B
         78 CD B6 57 2F D2 F6 1D B3 90 47 22 32 E3 D9 F5
   // INTEGER (prime1)
   // high bit is set, pad.
   02 19
         00
         FA DB D7 F8 A1 8B 3A 75 A4 F6 DF AE E3 42 6F D0
         FF 8B AC 74 B6 72 2D EF
   // INTEGER (prime2)
   // high bit is set, pad.
   02 19
         00
         DF 48 14 4A 6D 88 A7 80 14 4F CE A6 6B DC DA 50
         D6 07 1C 54 E5 D0 DA 5B
   // INTEGER (exponent1)
   // no padding
   02 18
         24 FF BB D0 DD F2 AD 02 A0 FC 10 6D B8 F3 19 8E
         D7 C2 00 03 8E CD 34 5D
   // INTEGER (exponent2)
   // padding required
   02 19
         00
         85 DF 73 BB 04 5D 91 00 6C 2D 45 9B E6 C4 2E 69
         95 4A 02 24 AC FE 42 4D
   // INTEGER (coefficient)
   // no padding
   02 18
         1A 3A 76 9C 21 26 2B 84 CA 9C A9 62 0F 98 D2 F4
         3E AC CC D4 87 9A 6F FD

现在我们计算进入 RSAPrivateKey 结构的字节数。 我数了 0xF2 (242)。 由于它大于 0x7F 我们需要使用多字节长度编码： 81 F2 。

所以现在使用字节数组30 81 F2 02 01 00 ... 9A 6F FD您可以将其转换为多行 Base64 并将其包装在“RSA PRIVATE KEY”PEM 装甲中。 但也许你想要一个 PKCS#8。

  PrivateKeyInfo ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
    privateKey                PrivateKey,
    attributes           [0]  IMPLICIT Attributes OPTIONAL }

  Version ::= INTEGER
  PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier
  PrivateKey ::= OCTET STRING

所以，让我们再做一次...... RFC 说我们也希望 version=0 在这里。 AlgorithmIdentifier 可以在RFC5280 中找到。

// SEQUENCE (PrivateKeyInfo)
30 xa [ya [za]]
   // INTEGER (Version=0)
   02 01
         00
   // SEQUENCE (PrivateKeyAlgorithmIdentifier / AlgorithmIdentifier)
   30 xb [yb [zb]]
      // OBJECT IDENTIFIER id-rsaEncryption (1.2.840.113549.1.1.1)
      06 09 2A 86 48 86 F7 0D 01 01 01
      // NULL (per RFC 3447 A.1)
      05 00
   // OCTET STRING (aka byte[]) (PrivateKey)
   04 81 F5
      [the previous value here,
       note the length here is F5 because of the tag and length bytes of the payload]

回填长度：

“b”系列是 13 (0x0D)，因为它只包含预定长度的东西。

“a”系列现在是 (2 + 1) + (2 + 13) + (3 + 0xF5) = 266 (0x010A)。

30 82 01 0A  02 01 00 30  0D ...

现在您可以将其作为“私钥”进行 PEM。

加密吗？ 那是完全不同的球赛。

Answer 2

我想出了一个效果很好的解决方案。 我找不到有关如何在 Windows 中从证书存储转到 pem 文件的确切示例。 当然，这可能不适用于某些证书，但如果您正在使用自己创建的证书（例如，如果您只需要控制两台机器之间的安全性，最终用户将看不到），这是一种很好的方式回到 pem/pk（linux 风格）。

我使用了在http://www.bouncycastle.org/csharp/ 上找到的实用程序

X509Store certStore = new X509Store(StoreName.My, StoreLocation.LocalMachine);
certStore.Open(OpenFlags.ReadOnly);

X509Certificate2 caCert = certStore.Certificates.Find(X509FindType.FindByThumbprint, "3C97BF2632ACAB5E35B48CB94927C4A7D20BBEBA", true)[0];


RSACryptoServiceProvider pkey = (RSACryptoServiceProvider)caCert.PrivateKey;


AsymmetricCipherKeyPair keyPair = DotNetUtilities.GetRsaKeyPair(pkey);
using (TextWriter tw = new StreamWriter("C:\\private.pem"))
{
    PemWriter pw = new PemWriter(tw);
    pw.WriteObject(keyPair.Private);
    tw.Flush();
}

Answer 3

X509certificate2 -> Private、Public 和 Cert pem...我刚刚发现你可以用 5 或 6 行外行代码来完成！

有一个叫做 Chilkat 的免费包（它有一些冷的品牌）。 它有一些非常直观的证书类下面是一些关于如何创建自签名 pfx 格式的证书并将其导出到 PEM 的示例代码！ 因此，这是采用X509Certificate2实例，带有证书和关联的公钥以及对其进行签名的私钥，然后将其导出为三个单独的 Pem 文件。 一份用于证书（包括公钥），一份用于公钥，一份用于私钥。 很容易（花了一周的时间才弄明白，哈哈）。 然后查看https://github.com/patrickpr/YAOG以获得一个很好的 OpenSSL windows Gui 来查看/创建证书（如结果截图所示）。

using Chilkat;
using System;
using System.Linq;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;


namespace CertPractice
{
static public class CertificateUtilityExample
{

    public static X509Certificate2 GenerateSelfSignedCertificate()
    {


        string secp256r1Oid = "1.2.840.10045.3.1.7";  //oid for prime256v1(7)  other identifier: secp256r1
        
        string subjectName = "Self-Signed-Cert-Example";

        var ecdsa = ECDsa.Create(ECCurve.CreateFromValue(secp256r1Oid));

        var certRequest = new CertificateRequest($"CN={subjectName}", ecdsa, HashAlgorithmName.SHA256);

        //add extensions to the request (just as an example)
        //add keyUsage
        certRequest.CertificateExtensions.Add(new X509KeyUsageExtension(X509KeyUsageFlags.DigitalSignature, true));

        X509Certificate2 generatedCert = certRequest.CreateSelfSigned(DateTimeOffset.Now.AddDays(-1), DateTimeOffset.Now.AddYears(10)); // generate the cert and sign!
//----------------end certificate generation, ie start here if you already have an X509Certificate2 instance----------------


        X509Certificate2 pfxGeneratedCert = new X509Certificate2(generatedCert.Export(X509ContentType.Pfx)); //has to be turned into pfx or Windows at least throws a security credentials not found during sslStream.connectAsClient or HttpClient request...

        Chilkat.Cert chilkatVersionOfPfxGeneratedCert = new Chilkat.Cert(); // now use Chilcat Cert to get pems
        chilkatVersionOfPfxGeneratedCert.LoadPfxData(generatedCert.Export(X509ContentType.Pfx), null); // export as binary pfx to load into a Chilkat Cert

        PrivateKey privateKey = chilkatVersionOfPfxGeneratedCert.ExportPrivateKey(); // get the private key
        privateKey.SavePemFile(@"filepath"); //save the private key to a pem file
        
        Chilkat.PublicKey publicKey = chilkatVersionOfPfxGeneratedCert.ExportPublicKey(); //get the public key
        publicKey.SavePemFile(true, @"filepath"); //save the public key

        chilkatVersionOfPfxGeneratedCert.ExportCertPemFile(@"filepath"); //save the public Cert to pem file
        


        return pfxGeneratedCert;


    }
}

Answer 4

基于@bartonjs 知识（他的回答），我编写了一个应该易于使用的小类。

所以现在也有一个完整的例子，无需使用外部 dlls/nuget 包

我必须做的唯一改变是：

• 在创建 X509Certificate2 实例时，我必须将此“X509KeyStorageFlags.Exportable”添加到 StorageFlags，以便方法“ExportPkcs8PrivateKey()”不会失败。

在我的课程中，可以使用证书和私钥将 Let's Encrypt 证书从 PFX 格式转换为 PEM 格式。

如何使用我的课程

var certificateLogic = new CertificateLogic("fileName.pfx", "privateKeyOfPfx");
certificateLogic.LoadCertificate();
certificateLogic.GenerateSaveCertificatePem();
certificateLogic.GenereateSavePrivateKeyPem();

我那门课背后的代码

public class CertificateLogic {

    private readonly FileInfo CertificateFile;
    private readonly SecureString CertificatePassword;
    public X509Certificate2 Certificate { get; private set; }

    public CertificateLogic(FileInfo certificationFile, string password) {
        if (!certificationFile.Exists) {
            throw new FileNotFoundException(certificationFile.FullName);
        }

        CertificateFile = certificationFile;
        CertificatePassword = ConvertPassword(password);
    }

    public CertificateLogic(string certificationFullFileName, string password) {
        var certificateFile = new FileInfo(certificationFullFileName);
        if (certificateFile == null || !certificateFile.Exists) {
            throw new FileNotFoundException(certificationFullFileName);
        }

        CertificateFile = certificateFile;
        CertificatePassword = ConvertPassword(password);
    }

    private static SecureString ConvertPassword(string password) {
        var secure = new SecureString();
        foreach (char c in password) {
            secure.AppendChar(c);
        }

        return secure;
    }

    public void LoadCertificate() {
        LoadCertificate(X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.Exportable);
    }

    public void LoadCertificate(X509KeyStorageFlags keyStorageFlags) {
        Certificate = new X509Certificate2(CertificateFile.FullName, CertificatePassword, keyStorageFlags);
    }

    public byte[] GenerateCertificatePem() {
        var certData = Certificate.RawData;
        var newPemData = PemEncoding.Write("CERTIFICATE", certData);

        return newPemData.Select(c => (byte)c).ToArray();
    }

    public byte[] GeneratePrivateKeyPem() {
        var privateCertKey = Certificate.GetRSAPrivateKey();
        var privateCertKeyBytes = privateCertKey.ExportPkcs8PrivateKey();

        char[] newPemData = PemEncoding.Write("PRIVATE KEY", privateCertKeyBytes);

        return newPemData.Select(c => (byte)c).ToArray();
    }

    public FileInfo GenerateSaveCertificatePem() {
        var newData = GenerateCertificatePem();

        var oldFile = Path.GetFileNameWithoutExtension(CertificateFile.FullName);
        var newCertPemFile = new FileInfo($@"{CertificateFile.DirectoryName}\{oldFile} Certificate.pem");
        return SaveNewCertificate(newCertPemFile, newData);
    }

    public FileInfo GenereateSavePrivateKeyPem() {
        var newData = GeneratePrivateKeyPem();

        var oldFile = Path.GetFileNameWithoutExtension(CertificateFile.FullName);
        var newPrivateKeyPemFile = new FileInfo($@"{CertificateFile.DirectoryName}\{oldFile} PrivateKey.pem");
        return SaveNewCertificate(newPrivateKeyPemFile, newData);
    }

    public FileInfo SaveNewCertificate(FileInfo newFile, byte[] data) {
        File.WriteAllBytes(newFile.FullName, data);

        return newFile;
    }
}