/// <summary> /// Export RSA public key /// </summary> /// <param name="rsa"></param> /// <param name="type"></param> /// <param name="usePemFormat"></param> /// <returns></returns> public static string ExportPublicKey(this RSA rsa, RSAKeyTypes type, bool usePemFormat = false) { var key = type switch { RSAKeyTypes.XML => rsa.ToLvccXmlString(false), RSAKeyTypes.JSON => rsa.ToJsonString(false), #if NETCOREAPP3_1 || NETSTANDARD2_1 RSAKeyTypes.Pkcs1 => Base64Conv.ToBase64String(rsa.ExportRSAPublicKey()), RSAKeyTypes.Pkcs8 => Base64Conv.ToBase64String(rsa.ExportRSAPublicKey()), #else RSAKeyTypes.Pkcs1 => rsa.ToPkcs1PublicString(), RSAKeyTypes.Pkcs8 => rsa.ToPkcs8PublicString(), #endif _ => throw new NotSupportedException("Unknown RSA key type.") }; if (usePemFormat) { key = type switch { RSAKeyTypes.XML => key, RSAKeyTypes.JSON => key, RSAKeyTypes.Pkcs1 => RSAPemFormatHelper.Pkcs1PublicKeyFormat(key), RSAKeyTypes.Pkcs8 => RSAPemFormatHelper.Pkcs8PublicKeyFormat(key), _ => throw new NotSupportedException("Unknown RSA key type.") }; } return(key); }
/// <summary> /// Decrypt byte[] data with xml/json format. /// </summary> /// <param name="dataBytes">The data to be encrypted.</param> /// <param name="privateKey">The private key of xml format.</param> /// <param name="fOEAP"></param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns>The decrypted data.</returns> public static string DecryptByPrivateKey( byte[] dataBytes, string privateKey, bool fOEAP, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, Encoding.UTF8, privateKey, sizeType); return(rsa.DecryptByPrivateKey(dataBytes, fOEAP)); }
/// <summary> /// Encrypt byte[] data with xml/json format. /// </summary> /// <param name="dataBytes">The data to be encrypted.</param> /// <param name="privateKey">The public key of xml format.</param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <param name="padding"></param> /// <returns>The encrypted data.</returns> public static string EncryptByPrivateKey( byte[] dataBytes, string privateKey, RSAEncryptionPadding padding, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, Encoding.UTF8, privateKey, sizeType); return(rsa.EncryptByPrivateKey(dataBytes, padding)); }
/// <summary> /// Signature as byte[] /// </summary> /// <param name="data"></param> /// <param name="privateKey"></param> /// <param name="hashAlgorithmName"></param> /// <param name="encoding"></param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns></returns> public static byte[] SignatureByPrivateKeyAsBytes( string data, string privateKey, HashAlgorithmName hashAlgorithmName, Encoding encoding = null, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, encoding, privateKey, sizeType); return(rsa.SignDataByPrivateKeyToBytes(data, hashAlgorithmName)); }
/// <summary> /// Signature as string /// </summary> /// <param name="data"></param> /// <param name="publicKey"></param> /// <param name="hashAlgorithmName"></param> /// <param name="encoding"></param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns></returns> public static string SignatureByPublicKeyAsString( string data, string publicKey, HashAlgorithmName hashAlgorithmName, Encoding encoding = null, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPublicKey(keyType, encoding, publicKey, sizeType); return(rsa.SignDataByPublicKey(data, hashAlgorithmName)); }
/// <summary> /// Encrypt string data with xml/json format. /// </summary> /// <param name="data">The data to be encrypted.</param> /// <param name="privateKey">The public key of xml format.</param> /// <param name="padding"></param> /// <param name="encoding">The <see cref="T:System.Text.Encoding"/>,default is Encoding.UTF8.</param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns>The encrypted data.</returns> public static string EncryptByPrivateKey( string data, string privateKey, RSAEncryptionPadding padding, Encoding encoding = null, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, encoding, privateKey, sizeType); return(rsa.EncryptByPrivateKey(data, padding)); }
/// <summary> /// Decrypt string data with xml/json format. /// </summary> /// <param name="data">The data to be encrypted.</param> /// <param name="privateKey">The private key of xml format.</param> /// <param name="fOEAP"></param> /// <param name="encoding">The <see cref="T:System.Text.Encoding"/>,default is Encoding.UTF8.</param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns>The decrypted data.</returns> public static string DecryptByPrivateKey( string data, string privateKey, bool fOEAP, Encoding encoding = null, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, encoding, privateKey, sizeType); return(rsa.DecryptByPrivateKey(data, fOEAP)); }
private static RSABase TouchRsaUtilFromPrivateKey(RSAKeyTypes keyType, Encoding encoding, string privateKey, RSAKeySizeTypes sizeType) { RSABase rsa = keyType switch { RSAKeyTypes.XML => new RSAXmlUtil(encoding, null, privateKey, (int)sizeType), RSAKeyTypes.JSON => new RSAJsonUtil(encoding, null, privateKey, (int)sizeType), RSAKeyTypes.Pkcs1 => new RSAPkcs1Util(encoding, null, privateKey, (int)sizeType), RSAKeyTypes.Pkcs8 => new RSAPkcs8Util(encoding, null, privateKey, (int)sizeType), _ => throw new NotSupportedException("Unknown RSA key type."), }; return(rsa); }
/// <summary> /// Verify /// </summary> /// <param name="data"></param> /// <param name="privateKey"></param> /// <param name="signature"></param> /// <param name="hashAlgorithmName"></param> /// <param name="encoding"></param> /// <param name="sizeType"></param> /// <param name="keyType"></param> /// <returns></returns> public static bool VerifyByPrivateKey( string data, string privateKey, string signature, HashAlgorithmName hashAlgorithmName, Encoding encoding = null, RSAKeySizeTypes sizeType = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { var rsa = TouchRsaUtilFromPrivateKey(keyType, encoding, privateKey, sizeType); return(rsa.VerifyDataByPrivateKey(data, signature, hashAlgorithmName)); }
/// <summary> /// Encrypt byte[] data with xml/json format. /// </summary> /// <param name="dataBytes">The data to be encrypted.</param> /// <param name="publicKey">The public key of xml format.</param> /// <param name="keyType"></param> /// <returns>The encrypted data.</returns> public static string Encrypt(byte[] dataBytes, string publicKey, RSAKeyTypes keyType = RSAKeyTypes.XML) { using (var rsa = new RSACryptoServiceProvider()) { if (keyType == RSAKeyTypes.XML) { rsa.FromLvccXmlString(publicKey); } else { rsa.FromJsonString(publicKey); } return(Convert.ToBase64String(rsa.Encrypt(dataBytes, false))); } }
/// <summary> /// Import RSA public key /// </summary> /// <param name="rsa"></param> /// <param name="type"></param> /// <param name="publicKey"></param> /// <param name="isPem"></param> public static void ImportPublicKey(this RSA rsa, RSAKeyTypes type, string publicKey, bool isPem = false) { if (isPem) { publicKey = type switch { RSAKeyTypes.XML => publicKey, RSAKeyTypes.JSON => publicKey, RSAKeyTypes.Pkcs1 => RSAPemFormatHelper.Pkcs1PublicKeyFormatRemove(publicKey), RSAKeyTypes.Pkcs8 => RSAPemFormatHelper.Pkcs8PublicKeyFormatRemove(publicKey), _ => throw new NotSupportedException("Unknown RSA key type.") }; } switch (type) { case RSAKeyTypes.XML: rsa.FromLvccXmlString(publicKey); break; case RSAKeyTypes.JSON: rsa.FromJsonString(publicKey); break; case RSAKeyTypes.Pkcs1: #if NETCOREAPP3_1 || NETSTANDARD2_1 rsa.ImportRSAPublicKey(Convert.FromBase64String(publicKey), out _); break; #else rsa.FromPkcs1PublicString(publicKey, out _); break; #endif case RSAKeyTypes.Pkcs8: #if NETCOREAPP3_1 || NETSTANDARD2_1 rsa.ImportRSAPublicKey(Convert.FromBase64String(publicKey), out _); break; #else rsa.FromPkcs8PublicString(publicKey, out _); break; #endif } }
public static RSAKey CreateKey(RSAKeySizeTypes size = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML) { using (var rsa = new RSACryptoServiceProvider((int)size)) { var publicKey = keyType == RSAKeyTypes.JSON ? rsa.ToJsonString(false) : rsa.ToLvccXmlString(false); var privateKey = keyType == RSAKeyTypes.JSON ? rsa.ToJsonString(true) : rsa.ToLvccXmlString(true); return(new RSAKey { PublicKey = publicKey, PrivateKey = privateKey, Exponent = rsa.ExportParameters(false).Exponent.ToHexString(), Modulus = rsa.ExportParameters(false).Modulus.ToHexString() }); } }
/// <summary> /// Rsa from xml or json string /// </summary> /// <param name="rsaKey"></param> /// <param name="keyType"></param> /// <returns></returns> /// <exception cref="ArgumentNullException"></exception> public static RSA RSAFromString(string rsaKey, RSAKeyTypes keyType = RSAKeyTypes.XML) { if (string.IsNullOrEmpty(rsaKey)) { throw new ArgumentNullException(nameof(rsaKey)); } var rsa = RSA.Create(); if (keyType == RSAKeyTypes.XML) { rsa.FromLvccXmlString(rsaKey); } else { rsa.FromJsonString(rsaKey); } return(rsa); }
/// <summary> /// Create a new <see cref="RSAKey"/> /// </summary> /// <param name="size"></param> /// <param name="keyType"></param> /// <param name="format"></param> /// <returns></returns> public static RSAKey CreateKey(RSAKeySizeTypes size = RSAKeySizeTypes.R2048, RSAKeyTypes keyType = RSAKeyTypes.XML, bool format = false) { switch (keyType) { case RSAKeyTypes.Pkcs1: return(Core.RSAKeyGenerator.Pkcs1Key((int)size, format)); case RSAKeyTypes.Pkcs8: return(Core.RSAKeyGenerator.Pkcs8Key((int)size, format)); case RSAKeyTypes.XML: return(Core.RSAKeyGenerator.XmlKey((int)size)); case RSAKeyTypes.JSON: return(Core.RSAKeyGenerator.JsonKey((int)size)); default: return(Core.RSAKeyGenerator.XmlKey((int)size)); } }
/// <summary> /// Decrypt byte[] data with xml/json format. /// </summary> /// <param name="dataBytes">The data to be encrypted.</param> /// <param name="privateKey">The private key of xml format.</param> /// <param name="encoding">The <see cref="T:System.Text.Encoding"/>,default is Encoding.UTF8.</param> /// <param name="keyType"></param> /// <returns>The decrypted data.</returns> public static string Decrypt(byte[] dataBytes, string privateKey, Encoding encoding = null, RSAKeyTypes keyType = RSAKeyTypes.XML) { if (encoding == null) { encoding = Encoding.UTF8; } using (var rsa = new RSACryptoServiceProvider()) { if (keyType == RSAKeyTypes.XML) { rsa.FromLvccXmlString(privateKey); } else { rsa.FromJsonString(privateKey); } return(encoding.GetString(rsa.Decrypt(dataBytes, false))); } }
/// <summary> /// Decrypt string data with xml/json format. /// </summary> /// <param name="data">The data to be encrypted.</param> /// <param name="privateKey">The private key of xml format.</param> /// <param name="encoding">The <see cref="T:System.Text.Encoding"/>,default is Encoding.UTF8.</param> /// <param name="keyType"></param> /// <returns>The decrypted data.</returns> public static string Decrypt(string data, string privateKey, Encoding encoding = null, RSAKeyTypes keyType = RSAKeyTypes.XML) { return(Decrypt(Convert.FromBase64String(data), privateKey, encoding, keyType)); }
/// <summary> /// Encrypt string data with xml/json format. /// </summary> /// <param name="data">The data to be encrypted.</param> /// <param name="publicKey">The public key of xml format.</param> /// <param name="encoding">The <see cref="T:System.Text.Encoding"/>,default is Encoding.UTF8.</param> /// <param name="keyType"></param> /// <returns>The encrypted data.</returns> public static string Encrypt(string data, string publicKey, Encoding encoding = null, RSAKeyTypes keyType = RSAKeyTypes.XML) { if (encoding == null) { encoding = Encoding.UTF8; } return(Encrypt(encoding.GetBytes(data), publicKey, keyType)); }