private void GetRsaWithPem(Int32 strength, Boolean usePkcs8, out string pirvKey, out string pubKey)
{
IAsymmetricCipherKeyPairGenerator kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
kpGen.Init(new KeyGenerationParameters(new SecureRandom(), strength));
var privKeyParam = kpGen.GenerateKeyPair().Private;
var pubKeyParam = kpGen.GenerateKeyPair().Public;
using (StringWriter sw = new StringWriter())
{
PemWriter pWrt = new PemWriter(sw);
if (usePkcs8)
{
var pkcs8 = new Pkcs8Generator(privKeyParam);
pWrt.WriteObject(pkcs8);
}
else
{
pWrt.WriteObject(privKeyParam);
}
pirvKey = sw.ToString();
}
using (StringWriter sw = new StringWriter())
{
PemWriter pWrt = new PemWriter(sw);
pWrt.WriteObject(pubKeyParam);
pubKey = sw.ToString();
}
}
/// <summary>
/// 获取密钥字符串
/// </summary>
/// <param name="includePrivate"></param>
/// <returns></returns>
public string GetKeyString(bool includePrivate = false)
{
if (includePrivate && this.Private == null)
{
return(null);
}
object pemObject = includePrivate ? this.Private : this.Public;
if (includePrivate && this.Format == KeyFormat.pkcs8)
{
pemObject = new Pkcs8Generator(this.Private);
}
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
pWrt.WriteObject(pemObject);
pWrt.Writer.Close();
return(sw.ToString());
//StringWriter sw = new StringWriter();
//PemWriter pWrt = new PemWriter(sw);
//pWrt.WriteObject(rsaKeyParameters);
//pWrt.Writer.Close();
//return sw.ToString();
}
public void TestPkcs8Plain()
{
IAsymmetricCipherKeyPairGenerator kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
kpGen.Init(new KeyGenerationParameters(new SecureRandom(), 1024));
AsymmetricKeyParameter privKey = kpGen.GenerateKeyPair().Private;
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(privKey);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
string result = sw.ToString();
PemReader pRd = new PemReader(new StringReader(result), new Password("hello".ToCharArray()));
AsymmetricKeyParameter rdKey = (AsymmetricKeyParameter)pRd.ReadObject();
pRd.Reader.Close();
Assert.AreEqual(privKey, rdKey);
}
async Task <IKey> AddPrivateKeyAsync(string name, AsymmetricCipherKeyPair keyPair, CancellationToken cancel)
{
// Create the key ID
var keyId = CreateKeyId(keyPair.Public);
// Create the PKCS #8 container for the key
string pem;
using (var sw = new StringWriter())
{
var pkcs8 = new Pkcs8Generator(keyPair.Private, Pkcs8Generator.PbeSha1_3DES)
{
Password = dek
};
var pw = new PemWriter(sw);
pw.WriteObject(pkcs8);
pw.Writer.Flush();
pem = sw.ToString();
}
// Store the key in the repository.
var key = new EncryptedKey
{
Id = keyId.ToBase58(),
Name = name,
Pem = pem
};
await Store.PutAsync(name, key);
log.DebugFormat("Added key '{0}' with ID {1}", name, keyId);
return(new KeyInfo {
Id = key.Id, Name = key.Name
});
}
public Task <AsymmetricCipherKeyPair> CreateKeyAsync(string keyId)
{
/*
* Create new RSA key
*/
var key = _keyGenerator.GenerateRsaKey(RsaKeySize.R3072);
/*
* Store Private Key
*/
// create pem file (PKCS#8 --> Private-Key Information Syntax Standard)
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(key.Private, Pkcs8Generator.PbeSha1_3DES);
pkcs8.Password = _pkcs8Password.ToCharArray();
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
// Store private key
File.WriteAllText(GetFilePath(keyId), sw.ToString());
return(Task.FromResult(key));
}
/// <inheritdoc />
public async Task <string> ExportAsync(string name, char[] password, CancellationToken cancel = default(CancellationToken))
{
string pem = "";
using (var repo = await ipfs.Repository(cancel))
{
var pk = new string[] { name };
var key = await repo.EncryptedKeys
.Where(k => k.Name == name)
.FirstAsync(cancel);
UseEncryptedKey(key, pkey =>
{
using (var sw = new StringWriter())
{
var pkcs8 = new Pkcs8Generator(pkey, Pkcs8Generator.PbeSha1_3DES)
{
Password = password
};
var pw = new PemWriter(sw);
pw.WriteObject(pkcs8);
pw.Writer.Flush();
pem = sw.ToString();
}
});
}
return(pem);
}
public static string PrivateKeyXmlToPkcs8(string privateKey)
{
var root = XElement.Parse(privateKey);
var modulus = root.Element("Modulus");
var exponent = root.Element("Exponent");
var p = root.Element("P");
var q = root.Element("Q");
var dp = root.Element("DP");
var dq = root.Element("DQ");
var inverseQ = root.Element("InverseQ");
var d = root.Element("D");
var rsaPrivateCrtKeyParameters = new RsaPrivateCrtKeyParameters(
new BigInteger(1, Convert.FromBase64String(modulus.Value)),
new BigInteger(1, Convert.FromBase64String(exponent.Value)),
new BigInteger(1, Convert.FromBase64String(d.Value)),
new BigInteger(1, Convert.FromBase64String(p.Value)),
new BigInteger(1, Convert.FromBase64String(q.Value)),
new BigInteger(1, Convert.FromBase64String(dp.Value)),
new BigInteger(1, Convert.FromBase64String(dq.Value)),
new BigInteger(1, Convert.FromBase64String(inverseQ.Value)));
using var writer = new StringWriter();
var pemWriter = new PemWriter(writer);
var pkcs8 = new Pkcs8Generator(rsaPrivateCrtKeyParameters);
pemWriter.WriteObject(pkcs8);
pemWriter.Writer.Close();
return(writer.ToString());
}
private static string ConvertPrivateKeyToPem(AsymmetricKeyParameter privateKey)
{
using (var stringWriter = new StringWriter())
{
var pkcsgen = new Pkcs8Generator(privateKey);
var pemwriter = new PemWriter(stringWriter);
pemwriter.WriteObject(pkcsgen.Generate());
return(stringWriter.ToString());
}
}
public static void GenerateKeyPair(out string publicKey, out char[] privateKey)
{
try
{
// Construct the RSACryptoServiceProvider object
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(2048);
// Extract the public/private key pair
var rsaKeyPair = DotNetUtilities.GetRsaKeyPair(rsa);
// Extract the private key
var pkcs8Gen = new Pkcs8Generator(rsaKeyPair.Private);
var pemObj = pkcs8Gen.Generate();
MemoryStream memoryStream = new MemoryStream();
TextWriter streamWriter = new StreamWriter(memoryStream);
PemWriter pemWriter = new PemWriter(streamWriter);
pemWriter.WriteObject(pemObj);
streamWriter.Flush();
// Extract byte array from memory stream
byte[] bytearray = memoryStream.GetBuffer();
// Convert byte array into char array
privateKey = Encoding.ASCII.GetChars(bytearray);
// Clear byte array
Array.Clear(bytearray, 0, bytearray.Length);
// Dispose stream writer and memory stream
streamWriter.Dispose();
memoryStream.Dispose();
// Extract the public key
TextWriter stringWriter = new StringWriter();
pemWriter = new PemWriter(stringWriter);
pemWriter.WriteObject(rsaKeyPair.Public);
stringWriter.Flush();
publicKey = stringWriter.ToString();
// Display the extracted public key
Console.WriteLine("public key, {0}", publicKey);
// Display the extracted private key
foreach (char ch in privateKey)
{
Console.Write(ch);
}
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
/// <summary>
/// 生成PKSC8私钥
/// </summary>
/// <param name="asymmetricCipherKeyPair"></param>
/// <returns></returns>
private static string GenetatePKCS8PrivateKey(AsymmetricCipherKeyPair asymmetricCipherKeyPair)
{
using (StringWriter stringWriter = new StringWriter())
{
PemWriter pemWriter = new PemWriter(stringWriter);
Pkcs8Generator pkcs8Generator = new Pkcs8Generator(asymmetricCipherKeyPair.Private);
pemWriter.WriteObject(pkcs8Generator);
pemWriter.Writer.Close();
return(stringWriter.ToString());
}
}
/// <summary>
/// 生成密钥对
/// </summary>
/// <returns></returns>
public static (string publicKey, string privateKey) generateRSAKeyPair()
{
var generator = new RsaKeyPairGenerator();
var param = new RsaKeyGenerationParameters(Org.BouncyCastle.Math.BigInteger.ValueOf(3), new SecureRandom(), 2048, 25);
generator.Init(param);
var pair = generator.GenerateKeyPair();
var publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pair.Public);
var publicKey = Convert.ToBase64String(publicKeyInfo.GetEncoded());
var pemObject = new Pkcs8Generator(pair.Private).Generate();
var privateKey = Convert.ToBase64String(pemObject.Content);
return(publicKey, privateKey);
}
/// <summary>
/// Save a private key in an encrypted PKCS#8 object
/// </summary>
/// <param name="privateKey">Private key value</param>
/// <param name="password">Password for encrypt</param>
/// <returns>PKCS#8 object</returns>
internal static string SaveP8(AsymmetricKeyParameter privateKey, string password)
{
// Use the FIPS-140 system prng
SecureRandom random = new SecureRandom(new CryptoApiRandomGenerator());
// Build PKCS#8
Pkcs8Generator p8 = new Pkcs8Generator(privateKey, "PBEWITHSHA256AND128BITAES-CBC-BC");
p8.Password = password.ToCharArray();
p8.SecureRandom = random;
p8.IterationCount = 2048;
PemObject pem = p8.Generate();
return(pem.Content.ToString());
}
private static string GeneratePrivateKey(AsymmetricKeyParameter key)
{
var builder = new StringBuilder();
using (var writer = new StringWriter(builder))
{
var pkcs8Gen = new Pkcs8Generator(key);
var pemObj = pkcs8Gen.Generate();
var pemWriter = new PemWriter(writer);
pemWriter.WriteObject(pemObj);
}
return(builder.ToString());
}
/// <summary>
/// Generate RSA Key in PKCS8 Format
/// </summary>
/// <param name="keySize">Key Size - 1024, 2048 or 4096 bytes</param>
/// <param name="format">Boolean parameter if you want to format the key</param>
/// <returns>List<string></string>Where index 0 is the Private Key and index 1 is the Public Key</returns>
public static List <string> Pkcs8Key(int keySize, bool format)
{
List <string> res = new List <string>();
IAsymmetricCipherKeyPairGenerator kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
kpGen.Init(new KeyGenerationParameters(new SecureRandom(), keySize));
AsymmetricCipherKeyPair keyPair = kpGen.GenerateKeyPair();
StringWriter swpri = new StringWriter();
PemWriter pWrtpri = new PemWriter(swpri);
Pkcs8Generator pkcs8 = new Pkcs8Generator(keyPair.Private);
pWrtpri.WriteObject(pkcs8);
pWrtpri.Writer.Close();
string privateKey = swpri.ToString();
if (!format)
{
privateKey = privateKey.Replace("-----BEGIN PRIVATE KEY-----", "").Replace("-----END PRIVATE KEY-----", "").Replace("\r\n", "");
}
res.Add(privateKey);
StringWriter swpub = new StringWriter();
PemWriter pWrtpub = new PemWriter(swpub);
pWrtpub.WriteObject(keyPair.Public);
pWrtpub.Writer.Close();
string publicKey = swpub.ToString();
if (!format)
{
publicKey = publicKey.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\r\n", "");
}
res.Add(publicKey);
return(res);
}
//
// Bouncy Castle PKCS#8 Formater
// Output is the same as this OpenSSL command:
// openssl pkcs12 -in certname.pfx -nocerts -out key.pem -nodes
//
private string GetPkcs8Format(RSACryptoServiceProvider csp)
{
var rsaParams = csp.ExportParameters(true);
var keyPair = DotNetUtilities.GetRsaKeyPair(rsaParams);
var pkcs8Gen = new Pkcs8Generator(keyPair.Private);
var pemObj = pkcs8Gen.Generate();
var sb = new StringBuilder();
using (var pkcs8Out = new StringWriter(sb))
{
var pemWriter = new PemWriter(pkcs8Out);
pemWriter.WriteObject(pemObj);
}
return(sb.ToString());
}
/// <summary>
/// 读取pfx证书，并将密钥存储为PKCS#8格式
/// </summary>
/// <param name="pfxFileName"></param>
/// <param name="password"></param>
public static void ConvertPfxToPkcs8(string pfxFileName, string password)
{
var certificate = ReadX509Certificate(pfxFileName, password);
var rsa = RSA.Create();
rsa.FromXmlString(certificate.PrivateKey.ToXmlString(true));
var bcKeyPair = DotNetUtilities.GetRsaKeyPair(rsa);
var pkcs8Gen = new Pkcs8Generator(bcKeyPair.Private);
var pemObj = pkcs8Gen.Generate();
var pkcs8Out = new StreamWriter(@"e:\privkey.pk8", false);
var pemWriter = new PemWriter(pkcs8Out);
pemWriter.WriteObject(pemObj);
pkcs8Out.Close();
}
/// <summary>
/// 将PKCS1私钥转为PKCS8
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string ConvertPKCS1ToPKCS8(string privateKey)
{
privateKey = $"-----BEGIN RSA PRIVATE KEY-----\n{privateKey}\n-----END RSA PRIVATE KEY-----";
PemReader pemReader = new PemReader(new StringReader(privateKey));
AsymmetricCipherKeyPair keyPair = pemReader.ReadObject() as AsymmetricCipherKeyPair;
using (StringWriter sw = new StringWriter())
{
PemWriter pemWriter = new PemWriter(sw);
Pkcs8Generator pkcs8Generator = new Pkcs8Generator(keyPair.Private);
pemWriter.WriteObject(pkcs8Generator);
pemWriter.Writer.Close();
return(sw.ToString());
}
}
public static string GetPublicKeyInPkcs8(this MsRSA rsa)
{
var publicKeyParameters = rsa.ExportParameters(false);
var rsaKeyParameters = new RsaKeyParameters(
false,
new BigInteger(1, publicKeyParameters.Modulus),
new BigInteger(1, publicKeyParameters.Exponent));
using var writer = new StringWriter();
var pemWriter = new PemWriter(writer);
var pkcs8 = new Pkcs8Generator(rsaKeyParameters);
pemWriter.WriteObject(pkcs8); //pemWriter.WriteObject(rsaKeyParameters);
pemWriter.Writer.Close();
return(writer.ToString());
}
/// <summary>
/// Private Key Convert Pkcs1->Pkcs8
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string PrivateKeyPkcs1ToPkcs8(string privateKey)
{
privateKey = Pkcs1PrivateKeyFormat(privateKey);
var pr = new PemReader(new StringReader(privateKey));
var kp = pr.ReadObject() as AsymmetricCipherKeyPair;
var sw = new StringWriter();
var pWrt = new PemWriter(sw);
var pkcs8 = new Pkcs8Generator(kp?.Private);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Flush();
var result = sw.ToString();
return(result);
}
/// <summary>
/// Private Key Convert Pkcs1->Pkcs8
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string PrivateKeyPkcs1ToPkcs8(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs1PrivateKeyFormat(privateKey);
PemReader pr = new PemReader(new StringReader(privateKey));
AsymmetricCipherKeyPair kp = pr.ReadObject() as AsymmetricCipherKeyPair;
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(kp.Private);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
string result = sw.ToString();
return(result);
}
public static string WritePkcs8PrivateKey(string privateKey)
{
if (privateKey.StartsWith("-----BEGIN PRIVATE KEY-----"))
{
return(privateKey);
}
var akp = AsymmetricKeyUtilities.GetAsymmetricKeyParameterFormAsn1PrivateKey(privateKey);
using (var sw = new StringWriter())
{
var pWrt = new PemWriter(sw);
var pkcs8 = new Pkcs8Generator(akp);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
return(sw.ToString());
}
}
/// <summary>
/// Private Key Convert Pkcs1->Pkcs8
/// </summary>
/// <param name="privateKey"></param>
/// <returns></returns>
public static string PrivateKeyPkcs1ToPkcs8(string privateKey)
{
privateKey = RSAPemFormatHelper.Pkcs1PrivateKeyFormat(privateKey);
var pemReader = new PemReader(new StringReader(privateKey));
if (pemReader.ReadObject() is AsymmetricCipherKeyPair asymmetricCipherKeyPair)
{
using var writer = new StringWriter();
var pemWriter = new PemWriter(writer);
var pkcs8Gen = new Pkcs8Generator(asymmetricCipherKeyPair.Private);
pemWriter.WriteObject(pkcs8Gen);
pemWriter.Writer.Close();
return(writer.ToString());
}
throw new ArgumentException($"Unknown format for Private Key: cannot convert to {nameof(AsymmetricCipherKeyPair)}.");
}
async Task <IKey> AddPrivateKeyAsync(string name, AsymmetricCipherKeyPair keyPair, CancellationToken cancel)
{
// Create the key ID
var keyId = CreateKeyId(keyPair.Public);
// Create the PKCS #8 container for the key
string pem;
using (var sw = new StringWriter())
{
var pkcs8 = new Pkcs8Generator(keyPair.Private, Pkcs8Generator.PbeSha1_3DES)
{
Password = dek
};
var pw = new PemWriter(sw);
pw.WriteObject(pkcs8);
pw.Writer.Flush();
pem = sw.ToString();
}
// Store the key in the repository.
var keyInfo = new KeyInfo
{
Name = name,
Id = keyId
};
var key = new EncryptedKey
{
Name = name,
Pem = pem
};
using (var repo = await ipfs.Repository(cancel))
{
await repo.AddAsync(keyInfo, cancel);
await repo.AddAsync(key, cancel);
await repo.SaveChangesAsync(cancel);
log.DebugFormat("Added key '{0}' with ID {1}", name, keyId);
return(keyInfo);
}
}
/// <summary>
/// Generate Pkcs8 format RSA key. Result: Index 0 is the private key and index 1 is the public key
/// </summary>
/// <param name="keySize">Key Size.Unit: bits</param>
/// <param name="format">Whether the format is true If it is standard pem file format</param>
/// <returns></returns>
public static RSAKey Pkcs8Key(int keySize, bool format)
{
IAsymmetricCipherKeyPairGenerator kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
kpGen.Init(new KeyGenerationParameters(new SecureRandom(), keySize));
var keyPair = kpGen.GenerateKeyPair();
StringWriter swpri = new StringWriter();
PemWriter pWrtpri = new PemWriter(swpri);
Pkcs8Generator pkcs8 = new Pkcs8Generator(keyPair.Private);
pWrtpri.WriteObject(pkcs8);
pWrtpri.Writer.Close();
string privateKey = swpri.ToString();
if (!format)
{
privateKey = privateKey
.ReplaceToEmpty(RSAConstants.PRIVATE_KEY_START)
.ReplaceToEmpty(RSAConstants.PRIVATE_KEY_END)
.ReplaceToEmpty(RSAConstants.R_N);
}
StringWriter swpub = new StringWriter();
PemWriter pWrtpub = new PemWriter(swpub);
pWrtpub.WriteObject(keyPair.Public);
pWrtpub.Writer.Close();
string publicKey = swpub.ToString();
if (!format)
{
publicKey = publicKey
.ReplaceToEmpty(RSAConstants.PUBLIC_KEY_START)
.ReplaceToEmpty(RSAConstants.PUBLIC_KEY_END)
.ReplaceToEmpty(RSAConstants.R_N);
}
return(new RSAKey
{
PublicKey = publicKey,
PrivateKey = privateKey
});
}
/// <summary>
/// Pkcs1>>Pkcs8
/// </summary>
/// <param name="privateKey">Pkcs1私钥</param>
/// <param name="format">是否转PEM格式</param>
/// <returns></returns>
public static string PrivateKeyPkcs1ToPkcs8(string privateKey, bool format = false)
{
var akp = AsymmetricKeyUtilities.GetAsymmetricKeyParameterFormPrivateKey(privateKey);
if (format)
{
var sw = new StringWriter();
var pWrt = new PemWriter(sw);
var pkcs8 = new Pkcs8Generator(akp);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
return(sw.ToString());
}
else
{
var privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(akp);
return(Base64.ToBase64String(privateKeyInfo.GetEncoded()));
}
}
/// <summary>
/// Convert RSA Private Key from XML to PKCS8 format
/// </summary>
/// <param name="privateKey">Private Key</param>
/// <returns></returns>
public static string PrivateKeyXmlToPkcs8(string privateKey)
{
XElement root = XElement.Parse(privateKey);
XElement modulus = root.Element("Modulus");
XElement exponent = root.Element("Exponent");
XElement p = root.Element("P");
XElement q = root.Element("Q");
XElement dp = root.Element("DP");
XElement dq = root.Element("DQ");
XElement inverseQ = root.Element("InverseQ");
XElement d = root.Element("D");
RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = new RsaPrivateCrtKeyParameters(
new BigInteger(1, Convert.FromBase64String(modulus.Value)),
new BigInteger(1, Convert.FromBase64String(exponent.Value)),
new BigInteger(1, Convert.FromBase64String(d.Value)),
new BigInteger(1, Convert.FromBase64String(p.Value)),
new BigInteger(1, Convert.FromBase64String(q.Value)),
new BigInteger(1, Convert.FromBase64String(dp.Value)),
new BigInteger(1, Convert.FromBase64String(dq.Value)),
new BigInteger(1, Convert.FromBase64String(inverseQ.Value)
));
StringWriter swpri = new StringWriter();
PemWriter pWrtpri = new PemWriter(swpri);
Pkcs8Generator pkcs8 = new Pkcs8Generator(rsaPrivateCrtKeyParameters);
pWrtpri.WriteObject(pkcs8);
pWrtpri.Writer.Close();
return(swpri.ToString());
}
private void EncryptedTest(AsymmetricKeyParameter privKey, string algorithm)
{
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(privKey, algorithm);
pkcs8.Password = "******".ToCharArray();
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
String result = sw.ToString();
PemReader pRd = new PemReader(new StringReader(result), new Password("hello".ToCharArray()));
AsymmetricKeyParameter rdKey = (AsymmetricKeyParameter)pRd.ReadObject();
pRd.Reader.Close();
Assert.AreEqual(privKey, rdKey);
}
/// <summary>
/// Generates a PKCS private key from the PowerRSA object
/// </summary>
/// <param name="prsa"></param>
/// <returns></returns>
public static string ConvertPrivateKeyToPKCS(PowerRSA prsa)
{
var rsa = RSA.Create();
rsa.FromXmlString(prsa.PrivateKey);
var bcKeyPair = DotNetUtilities.GetRsaKeyPair(rsa);
var pkcs8Gen = new Pkcs8Generator(bcKeyPair.Private);
var pemObj = pkcs8Gen.Generate();
string outputPem;
using (var sw = new StringWriter())
{
var pkcs8Out = sw;
var pemWriter = new PemWriter(pkcs8Out);
pemWriter.WriteObject(pemObj);
pkcs8Out.Close();
outputPem = sw.ToString();
}
return(outputPem);
}
private void EncryptedTest(AsymmetricKeyParameter privKey, string algorithm)
{
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(privKey, algorithm);
pkcs8.Password = "******".ToCharArray();
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
String result = sw.ToString();
PemReader pRd = new PemReader(new StringReader(result), new Password("hello".ToCharArray()));
AsymmetricKeyParameter rdKey = (AsymmetricKeyParameter)pRd.ReadObject();
pRd.Reader.Close();
Assert.AreEqual(privKey, rdKey);
}
public static string ToPkcs8PrivateString(this RSA rsa)
{
var privateKeyParameters = rsa.ExportParameters(true);
RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = new RsaPrivateCrtKeyParameters(
new BigInteger(1, privateKeyParameters.Modulus),
new BigInteger(1, privateKeyParameters.Exponent),
new BigInteger(1, privateKeyParameters.D),
new BigInteger(1, privateKeyParameters.P),
new BigInteger(1, privateKeyParameters.Q),
new BigInteger(1, privateKeyParameters.DP),
new BigInteger(1, privateKeyParameters.DQ),
new BigInteger(1, privateKeyParameters.InverseQ));
using var privateSw = new StringWriter();
var privatePemWriter = new PemWriter(privateSw);
var pkcs8 = new Pkcs8Generator(rsaPrivateCrtKeyParameters);
privatePemWriter.WriteObject(pkcs8);
privatePemWriter.Writer.Close();
return(privateSw.ToString());
}
public static string GetPrivateKeyInPkcs8(this MsRSA rsa)
{
var privateKeyParameters = rsa.ExportParameters(true);
var rsaKeyParameters = new RsaPrivateCrtKeyParameters(
new BigInteger(1, privateKeyParameters.Modulus),
new BigInteger(1, privateKeyParameters.Exponent),
new BigInteger(1, privateKeyParameters.D),
new BigInteger(1, privateKeyParameters.P),
new BigInteger(1, privateKeyParameters.Q),
new BigInteger(1, privateKeyParameters.DP),
new BigInteger(1, privateKeyParameters.DQ),
new BigInteger(1, privateKeyParameters.InverseQ));
using var writer = new StringWriter();
var pemWriter = new PemWriter(writer);
var pkcs8 = new Pkcs8Generator(rsaKeyParameters);
pemWriter.WriteObject(pkcs8);
pemWriter.Writer.Close();
return(writer.ToString());
}
public void TestPkcs8Plain()
{
IAsymmetricCipherKeyPairGenerator kpGen = GeneratorUtilities.GetKeyPairGenerator("RSA");
kpGen.Init(new KeyGenerationParameters(new SecureRandom(), 1024));
IAsymmetricKeyParameter privKey = kpGen.GenerateKeyPair().Private;
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
Pkcs8Generator pkcs8 = new Pkcs8Generator(privKey);
pWrt.WriteObject(pkcs8);
pWrt.Writer.Close();
string result = sw.ToString();
PemReader pRd = new PemReader(new StringReader(result), new Password("hello".ToCharArray()));
IAsymmetricKeyParameter rdKey = (AsymmetricKeyParameter)pRd.ReadObject();
pRd.Reader.Close();
Assert.AreEqual(privKey, rdKey);
}
