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); }
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); }