/// <summary>
/// Convert RSA Public Key from PEM to XML format
/// </summary>
/// <param name="publicKey">Public Key</param>
/// <returns></returns>
public static string PublicKeyPemToXml(string publicKey)
{
publicKey = RsaPemFormatHelper.PublicKeyFormat(publicKey);
PemReader pr = new PemReader(new StringReader(publicKey));
object obj = pr.ReadObject();
if (!(obj is RsaKeyParameters rsaKey))
{
throw new Exception("Public key format is incorrect");
}
XElement publicElement = new XElement("RSAKeyValue");
XElement pubmodulus = new XElement("Modulus", Convert.ToBase64String(rsaKey.Modulus.ToByteArrayUnsigned()));
XElement pubexponent = new XElement("Exponent", Convert.ToBase64String(rsaKey.Exponent.ToByteArrayUnsigned()));
publicElement.Add(pubmodulus);
publicElement.Add(pubexponent);
return(publicElement.ToString());
}
/// <summary>
/// Create an RSA parameter based on the XML Format private key
/// </summary>
/// <param name="privateKey"></param>
/// <returns>RSAParameters</returns>
protected sealed override RSAParameters CreateRsapFromPrivateKey(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs8PrivateKeyFormatRemove(privateKey);
RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
RSAParameters rsap = new RSAParameters();
rsap.Modulus = privateKeyParam.Modulus.ToByteArrayUnsigned();
rsap.Exponent = privateKeyParam.PublicExponent.ToByteArrayUnsigned();
rsap.P = privateKeyParam.P.ToByteArrayUnsigned();
rsap.Q = privateKeyParam.Q.ToByteArrayUnsigned();
rsap.DP = privateKeyParam.DP.ToByteArrayUnsigned();
rsap.DQ = privateKeyParam.DQ.ToByteArrayUnsigned();
rsap.InverseQ = privateKeyParam.QInv.ToByteArrayUnsigned();
rsap.D = privateKeyParam.Exponent.ToByteArrayUnsigned();
return(rsap);
}
/// <summary>
/// Create an RSA parameter based on the XML Format private key
/// </summary>
/// <param name="privateKey"></param>
/// <returns>RSAParameters</returns>
protected sealed override RSAParameters CreateRsapFromPrivateKey(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs1PrivateKeyFormat(privateKey);
PemReader pr = new PemReader(new StringReader(privateKey));
if (!(pr.ReadObject() is AsymmetricCipherKeyPair asymmetricCipherKeyPair))
{
throw new Exception("Private key format is incorrect");
}
RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(PrivateKeyInfoFactory.CreatePrivateKeyInfo(asymmetricCipherKeyPair.Private));
RSAParameters rsap = new RSAParameters();
rsap.Modulus = rsaPrivateCrtKeyParameters.Modulus.ToByteArrayUnsigned();
rsap.Exponent = rsaPrivateCrtKeyParameters.PublicExponent.ToByteArrayUnsigned();
rsap.P = rsaPrivateCrtKeyParameters.P.ToByteArrayUnsigned();
rsap.Q = rsaPrivateCrtKeyParameters.Q.ToByteArrayUnsigned();
rsap.DP = rsaPrivateCrtKeyParameters.DP.ToByteArrayUnsigned();
rsap.DQ = rsaPrivateCrtKeyParameters.DQ.ToByteArrayUnsigned();
rsap.InverseQ = rsaPrivateCrtKeyParameters.QInv.ToByteArrayUnsigned();
rsap.D = rsaPrivateCrtKeyParameters.Exponent.ToByteArrayUnsigned();
return(rsap);
}
/// <summary>
/// Create an RSA parameter based on XML format public key
/// </summary>
/// <param name="publicKey"></param>
/// <returns>RSAParameters</returns>
protected sealed override RSAParameters CreateRsapFromPublicKey(string publicKey)
{
publicKey = RsaPemFormatHelper.PublicKeyFormatRemove(publicKey);
RsaKeyParameters publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
RSAParameters rsap = new RSAParameters();
rsap.Modulus = publicKeyParam.Modulus.ToByteArrayUnsigned();
rsap.Exponent = publicKeyParam.Exponent.ToByteArrayUnsigned();
return(rsap);
}
/// <summary>
/// Convert RSA Private Key from PKCS1 to XML format
/// </summary>
/// <param name="privateKey">Private Key</param>
/// <returns></returns>
public static string PrivateKeyPkcs1ToXml(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs1PrivateKeyFormat(privateKey);
PemReader pr = new PemReader(new StringReader(privateKey));
if (!(pr.ReadObject() is AsymmetricCipherKeyPair asymmetricCipherKeyPair))
{
throw new Exception("Private key format is incorrect");
}
RsaPrivateCrtKeyParameters rsaPrivateCrtKeyParameters = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(PrivateKeyInfoFactory.CreatePrivateKeyInfo(asymmetricCipherKeyPair.Private));
XElement privatElement = new XElement("RSAKeyValue");
XElement primodulus = new XElement("Modulus", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Modulus.ToByteArrayUnsigned()));
XElement priexponent = new XElement("Exponent", Convert.ToBase64String(rsaPrivateCrtKeyParameters.PublicExponent.ToByteArrayUnsigned()));
XElement prip = new XElement("P", Convert.ToBase64String(rsaPrivateCrtKeyParameters.P.ToByteArrayUnsigned()));
XElement priq = new XElement("Q", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Q.ToByteArrayUnsigned()));
XElement pridp = new XElement("DP", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DP.ToByteArrayUnsigned()));
XElement pridq = new XElement("DQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.DQ.ToByteArrayUnsigned()));
XElement priinverseQ = new XElement("InverseQ", Convert.ToBase64String(rsaPrivateCrtKeyParameters.QInv.ToByteArrayUnsigned()));
XElement prid = new XElement("D", Convert.ToBase64String(rsaPrivateCrtKeyParameters.Exponent.ToByteArrayUnsigned()));
privatElement.Add(primodulus);
privatElement.Add(priexponent);
privatElement.Add(prip);
privatElement.Add(priq);
privatElement.Add(pridp);
privatElement.Add(pridq);
privatElement.Add(priinverseQ);
privatElement.Add(prid);
return(privatElement.ToString());
}
/// <summary>
/// Convert RSA Private Key from PKCS8 to XML format
/// </summary>
/// <param name="privateKey">Private Key</param>
/// <returns></returns>
public static string PrivateKeyPkcs8ToXml(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs8PrivateKeyFormatRemove(privateKey);
RsaPrivateCrtKeyParameters privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
XElement privatElement = new XElement("RSAKeyValue");
XElement primodulus = new XElement("Modulus", Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned()));
XElement priexponent = new XElement("Exponent", Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned()));
XElement prip = new XElement("P", Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned()));
XElement priq = new XElement("Q", Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned()));
XElement pridp = new XElement("DP", Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned()));
XElement pridq = new XElement("DQ", Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned()));
XElement priinverseQ = new XElement("InverseQ", Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned()));
XElement prid = new XElement("D", Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned()));
privatElement.Add(primodulus);
privatElement.Add(priexponent);
privatElement.Add(prip);
privatElement.Add(priq);
privatElement.Add(pridp);
privatElement.Add(pridq);
privatElement.Add(priinverseQ);
privatElement.Add(prid);
return(privatElement.ToString());
}
/// <summary>
/// Create an RSA parameter based on XML format public key
/// </summary>
/// <param name="publicKey"></param>
/// <returns>RSAParameters</returns>
protected sealed override RSAParameters CreateRsapFromPublicKey(string publicKey)
{
publicKey = RsaPemFormatHelper.PublicKeyFormat(publicKey);
PemReader pr = new PemReader(new StringReader(publicKey));
object obj = pr.ReadObject();
if (!(obj is RsaKeyParameters rsaKey))
{
throw new Exception("Public key format is incorrect");
}
RSAParameters rsap = new RSAParameters();
rsap.Modulus = rsaKey.Modulus.ToByteArrayUnsigned();
rsap.Exponent = rsaKey.Exponent.ToByteArrayUnsigned();
return(rsap);
}
/// <summary>
/// Convert RSA Private Key from PKCS8 to PKCS1 format
/// </summary>
/// <param name="privateKey">Private Key</param>
/// <returns></returns>
public static string PrivateKeyPkcs8ToPkcs1(string privateKey)
{
privateKey = RsaPemFormatHelper.Pkcs8PrivateKeyFormat(privateKey);
PemReader pr = new PemReader(new StringReader(privateKey));
RsaPrivateCrtKeyParameters kp = pr.ReadObject() as RsaPrivateCrtKeyParameters;
AsymmetricKeyParameter keyParameter = PrivateKeyFactory.CreateKey(PrivateKeyInfoFactory.CreatePrivateKeyInfo(kp));
StringWriter sw = new StringWriter();
PemWriter pWrt = new PemWriter(sw);
pWrt.WriteObject(keyParameter);
pWrt.Writer.Close();
string result = sw.ToString();
return(result);
}
/// <summary>
/// Convert RSA Private Key from PKCS1 to PKCS8 format
/// </summary>
/// <param name="privateKey">Private Key</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);
}