将 private/public 个密钥从 X509 证书导出到 PEM
Export private/public keys from X509 certificate to PEM
有什么方便的方法可以使用 .NET Core 从 PEM 格式的 .p12 证书中导出 private/public 密钥？不在低级别处理字节？我在谷歌上搜索了几个小时，几乎没有任何东西在 .net 核心中可用，或者它没有在任何地方记录..
让我们有一个 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
有人知道吗？
谢谢
更新 (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 class 尚不存在。但这没关系，旧答案中有一个 PEM-ifier 的开始（尽管“CERTIFICATE”和 cert.RawData）需要来自参数）。
.NET Core 3.0 是添加了额外的密钥格式导出和导入方法的版本。
.NET 核心 2.0、.NET 核心 2.1:
与原来的答案一样，除了你不需要写一个DER编码器。您可以使用 System.Formats.Asn1 NuGet package.
原回答（.NET Core 1.1 是最新的选项）：
答案介于“不”和“不是”之间。
我假设您不希望 public.pub 和 private.key.
顶部的 p12 输出垃圾
public.pub 只是证书。 openssl 命令行实用程序更喜欢 PEM 编码数据，因此我们将编写一个 PEM 编码证书（注意，这是一个证书，而不是 public 密钥。它 包含 一个 public 键，但它本身不是一个）：
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) structure, usually DER-encoded (ITU-T X.690)——尽管因为它没有签名所以没有一个特定的 DER 限制，但许多读者可能假设 DER。
或者，它可以是 PKCS#8 (RFC 5208) PrivateKeyInfo（标签：“私钥”）或 EncryptedPrivateKeyInfo（标签：“加密私钥”）。由于 EncryptedPrivateKeyInfo 包装了 PrivateKeyInfo，而 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。
让我们一起工作 pre-published 384-bit RSA key。
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 为“私钥”。
正在加密吗？那是一个完全不同的球赛。
我找到了一个行之有效的解决方案。我在 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();
}
X509certificate2 -> Private，Public 和 Cert pems...我刚刚发现你可以用 5 或 6 行外行代码来完成！
有一个名为 Chilkat 的免费软件包（它有一些 chill 品牌）。它有一些非常直观的 Certificate Classes Here is some example code on how to create a self signed pfx formatted certificate and export it to PEM! So that is taking a X509Certificate2 instance with a certificate and associated public key and the privatekey that signed it, and then exporting it as three separate Pem files. One for the certificate(includes public key), one for the public key, and one for the private key. Very easy (took a week of reading to figure this out, haha). And then checkout https://github.com/patrickpr/YAOG 用于 viewing/creating 证书的漂亮 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;
}
}
根据@bartonjs的知识()，写了一个小的class，应该很好用
所以现在还有一个完整的示例，无需使用外部 dlls/nuget 包
我必须做的唯一改变是：
- 我必须在创建 X509Certificate2 实例时将此“X509KeyStorageFlags.Exportable”添加到 StorageFlags，以便方法“ExportPkcs8PrivateKey()”不会失败。
使用我的class可以使用证书和私钥将 Let's Encrypt 证书从 PFX 格式转换为 PEM 格式。
如何使用我的class
var certificateLogic = new CertificateLogic("fileName.pfx", "privateKeyOfPfx");
certificateLogic.LoadCertificate();
certificateLogic.GenerateSaveCertificatePem();
certificateLogic.GenereateSavePrivateKeyPem();
我的代码背后 class
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;
}
}
有什么方便的方法可以使用 .NET Core 从 PEM 格式的 .p12 证书中导出 private/public 密钥？不在低级别处理字节？我在谷歌上搜索了几个小时，几乎没有任何东西在 .net 核心中可用，或者它没有在任何地方记录..
让我们有一个 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
有人知道吗？
谢谢
更新 (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 class 尚不存在。但这没关系，旧答案中有一个 PEM-ifier 的开始（尽管“CERTIFICATE”和 cert.RawData）需要来自参数）。
.NET Core 3.0 是添加了额外的密钥格式导出和导入方法的版本。
.NET 核心 2.0、.NET 核心 2.1:
与原来的答案一样，除了你不需要写一个DER编码器。您可以使用 System.Formats.Asn1 NuGet package.
原回答（.NET Core 1.1 是最新的选项）：
答案介于“不”和“不是”之间。
我假设您不希望 public.pub 和 private.key.
public.pub 只是证书。 openssl 命令行实用程序更喜欢 PEM 编码数据，因此我们将编写一个 PEM 编码证书（注意，这是一个证书，而不是 public 密钥。它 包含 一个 public 键，但它本身不是一个）：
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) structure, usually DER-encoded (ITU-T X.690)——尽管因为它没有签名所以没有一个特定的 DER 限制，但许多读者可能假设 DER。
或者，它可以是 PKCS#8 (RFC 5208) PrivateKeyInfo（标签：“私钥”）或 EncryptedPrivateKeyInfo（标签：“加密私钥”）。由于 EncryptedPrivateKeyInfo 包装了 PrivateKeyInfo，而 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。
让我们一起工作 pre-published 384-bit RSA key。
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 为“私钥”。
正在加密吗？那是一个完全不同的球赛。
我找到了一个行之有效的解决方案。我在 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();
}
X509certificate2 -> Private，Public 和 Cert pems...我刚刚发现你可以用 5 或 6 行外行代码来完成！
有一个名为 Chilkat 的免费软件包（它有一些 chill 品牌）。它有一些非常直观的 Certificate Classes Here is some example code on how to create a self signed pfx formatted certificate and export it to PEM! So that is taking a X509Certificate2 instance with a certificate and associated public key and the privatekey that signed it, and then exporting it as three separate Pem files. One for the certificate(includes public key), one for the public key, and one for the private key. Very easy (took a week of reading to figure this out, haha). And then checkout https://github.com/patrickpr/YAOG 用于 viewing/creating 证书的漂亮 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;
}
}
根据@bartonjs的知识(
所以现在还有一个完整的示例，无需使用外部 dlls/nuget 包
我必须做的唯一改变是：
- 我必须在创建 X509Certificate2 实例时将此“X509KeyStorageFlags.Exportable”添加到 StorageFlags，以便方法“ExportPkcs8PrivateKey()”不会失败。
使用我的class可以使用证书和私钥将 Let's Encrypt 证书从 PFX 格式转换为 PEM 格式。
如何使用我的class
var certificateLogic = new CertificateLogic("fileName.pfx", "privateKeyOfPfx");
certificateLogic.LoadCertificate();
certificateLogic.GenerateSaveCertificatePem();
certificateLogic.GenereateSavePrivateKeyPem();
我的代码背后 class
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;
}
}