C#加密知识整合 (AES,MD5,RSA,SHA256)

aes 对称加密密钥必须是32字节

using System;
using System.Security.Cryptography;
using System.Text;
namespace ConsoleApp1
{
   public class AES
   {
       /// <summary>
       /// 获取密钥 必须是32字节
       /// </summary>
       private static string Key
       {
           get { return @"abcdefghijklmnopqrstuvwxyz123456"; }
       }
       /// <summary>
       /// AES加密
       /// </summary>
       /// <param name="plainStr">明文字符串</param>
       /// <returns>密文</returns>
       public static string AESEncrypt(string encryptStr)
       {
           byte[] keyArray = UTF8Encoding.UTF8.GetBytes(Key);
           byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(encryptStr);
           RijndaelManaged rDel = new RijndaelManaged();
           rDel.Key = keyArray;
           rDel.Mode = CipherMode.ECB;
           rDel.Padding = PaddingMode.PKCS7;
           ICryptoTransform cTransform = rDel.CreateEncryptor();
           byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
           return Convert.ToBase64String(resultArray, 0, resultArray.Length);
       }
       public static string AESDEncrypt(string encryptStr)
       {
           byte[] keyArray = UTF8Encoding.UTF8.GetBytes(Key);
           byte[] toEncryptArray = Convert.FromBase64String(encryptStr);
           RijndaelManaged rDel = new RijndaelManaged();
           rDel.Key = keyArray;
           rDel.Mode = CipherMode.ECB;
           rDel.Padding = PaddingMode.PKCS7;
           ICryptoTransform cTransform = rDel.CreateDecryptor();
           byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
           return UTF8Encoding.UTF8.GetString(resultArray);
       }
   }
}

调用方式：

/// aes 对称加密解密
           string s = AES.AESEncrypt("202201131552测试数据");
           Console.WriteLine(s);
           Console.WriteLine(AES.AESDEncrypt(s));
           Console.WriteLine("------------------------------------------------------");

MD5 不可逆加密

using System;
using System.Security.Cryptography;
namespace ConsoleApp1
{
   public class MD5Helper
   {
       public static string md5(string str)
       {
           try
           {
               MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
               byte[] bytValue, bytHash;
               bytValue = System.Text.Encoding.UTF8.GetBytes(str);
               bytHash = md5.ComputeHash(bytValue);
               md5.Clear();
               string sTemp = "";
               for (int i = 0; i < bytHash.Length; i++)
               {
                   sTemp += bytHash[i].ToString("X").PadLeft(2, '0');
               }
               str = sTemp.ToLower();
           }
           catch (Exception e)
           {
               Console.WriteLine(e.Message);
           }
           return str;
       }
   }
}

调用方式：

/// MD5 不可逆加密
           var MD5 = MD5Helper.md5("123456");
           Console.WriteLine("------------------------------------------------------");

SHA 256 不可逆加密

using System.Security.Cryptography;
using System.Text;
namespace ConsoleApp1
{
   public class SHA256Helper
   {
       /// <summary>
       /// SHA256加密
       /// </summary>
       /// <param name="data"></param>
       /// <returns></returns>
       public static string SHA256EncryptString(string data)
       {
           byte[] bytes = Encoding.UTF8.GetBytes(data);
           byte[] hash = SHA256Managed.Create().ComputeHash(bytes);
           StringBuilder builder = new StringBuilder();
           for (int i = 0; i < hash.Length; i++)
           {
               builder.Append(hash[i].ToString("x2"));
           }
           return builder.ToString();
       }
   }
}

调用方式：

///SHA 256 不可逆加密
           var sha256 = SHA256Helper.SHA256EncryptString("1111");
           Console.WriteLine("------------------------------------------------------");

RSA 非对称加密解密

百度rsa密钥在线生成 http://web.chacuo.net/netrsakeypair/ 填入公私钥到变量publickey, privatekey

using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace ConsoleApp1
{
   public  class RSAPkcs8Helper
   {
       /// <summary>
       /// 签名
       /// </summary>
       /// <param name="content">待签名字符串</param>
       /// <param name="privateKey">私钥</param>
       /// <param name="input_charset">编码格式</param>
       /// <returns>签名后字符串</returns>
       public static string sign(string content, string privateKey, string input_charset)
       {
           byte[] Data = Encoding.GetEncoding(input_charset).GetBytes(content);
           RSACryptoServiceProvider rsa = DecodePemPrivateKey(privateKey);            //MD5 sh = new MD5CryptoServiceProvider();//这里也可以使用MD5加密方式
           SHA1 sh = new SHA1CryptoServiceProvider();
           byte[] signData = rsa.SignData(Data, sh);
           return Convert.ToBase64String(signData);
       }
       /// <summary>
       /// 验签
       /// </summary>
       /// <param name="content">待验签字符串</param>
       /// <param name="signedString">签名</param>
       /// <param name="publicKey">公钥</param>
       /// <param name="input_charset">编码格式</param>
       /// <returns>true(通过)，false(不通过)</returns>
       public static bool verify(string content, string signedString, string publicKey, string input_charset)
       {
           bool result = false;
           byte[] Data = Encoding.GetEncoding(input_charset).GetBytes(content);
           byte[] data = Convert.FromBase64String(signedString);
           RSAParameters paraPub = ConvertFromPublicKey(publicKey);
           RSACryptoServiceProvider rsaPub = new RSACryptoServiceProvider();
           rsaPub.ImportParameters(paraPub);            //MD5 sh = new MD5CryptoServiceProvider();//这里可以使用MD5加密方式
           SHA1 sh = new SHA1CryptoServiceProvider();
           result = rsaPub.VerifyData(Data, sh, data);
           return result;
       }
       /// <summary>
       /// 加密
       /// </summary>
       /// <param name="resData">需要加密的字符串</param>
       /// <param name="publicKey">公钥</param>
       /// <param name="input_charset">编码格式</param>
       /// <returns>明文</returns>
       public static string encryptData(string resData, string publicKey, string input_charset)
       {
           byte[] DataToEncrypt = Encoding.GetEncoding(input_charset).GetBytes(resData);
           string result = encrypt(DataToEncrypt, publicKey, input_charset);
           return result;
       }
       /// <summary>
       /// 解密
       /// </summary>
       /// <param name="resData">加密字符串</param>
       /// <param name="privateKey">私钥</param>
       /// <param name="input_charset">编码格式</param>
       /// <returns>明文</returns>
       public static string decryptData(string resData, string privateKey, string input_charset)
       {
           byte[] DataToDecrypt = Convert.FromBase64String(resData);
           string result = "";
           for (int j = 0; j < DataToDecrypt.Length / 128; j++)
           {
               byte[] buf = new byte[128];
               for (int i = 0; i < 128; i++)
               {
                   buf[i] = DataToDecrypt[i + 128 * j];
               }
               result += decrypt(buf, privateKey, input_charset);
           }
           return result;
       }
       #region 内部方法
       private static string encrypt(byte[] data, string publicKey, string input_charset)
       {
           RSACryptoServiceProvider rsa = DecodePemPublicKey(publicKey);            //MD5 sh = new MD5CryptoServiceProvider();//这里也可以使用MD5加密方式
           SHA1 sh = new SHA1CryptoServiceProvider();
           byte[] result = rsa.Encrypt(data, false);
           return Convert.ToBase64String(result);
       }
       private static string decrypt(byte[] data, string privateKey, string input_charset)
       {
           string result = "";
           RSACryptoServiceProvider rsa = DecodePemPrivateKey(privateKey);            //MD5 sh = new MD5CryptoServiceProvider();//这里也可以替换使用MD5方式
           SHA1 sh = new SHA1CryptoServiceProvider();
           byte[] source = rsa.Decrypt(data, false);
           char[] asciiChars = new char[Encoding.GetEncoding(input_charset).GetCharCount(source, 0, source.Length)];
           Encoding.GetEncoding(input_charset).GetChars(source, 0, source.Length, asciiChars, 0);
           result = new string(asciiChars);
           //result = ASCIIEncoding.ASCII.GetString(source);
           return result;
       }
       private static RSACryptoServiceProvider DecodePemPublicKey(String pemstr)
       {
           byte[] pkcs8publickkey;
           pkcs8publickkey = Convert.FromBase64String(pemstr);
           if (pkcs8publickkey != null)
           {
               RSACryptoServiceProvider rsa = DecodeRSAPublicKey(pkcs8publickkey);
               return rsa;
           }
           else
               return null;
       }
       private static RSACryptoServiceProvider DecodePemPrivateKey(String pemstr)
       {
           byte[] pkcs8privatekey;
           pkcs8privatekey = Convert.FromBase64String(pemstr);
           if (pkcs8privatekey != null)
           {
               RSACryptoServiceProvider rsa = DecodePrivateKeyInfo(pkcs8privatekey);
               return rsa;
           }
           else
               return null;
       }
       private static RSACryptoServiceProvider DecodePrivateKeyInfo(byte[] pkcs8)
       {
           byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
           byte[] seq = new byte[15];
           MemoryStream mem = new MemoryStream(pkcs8);
           int lenstream = (int)mem.Length;
           BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading
           byte bt = 0;
           ushort twobytes = 0;
           try
           {
               twobytes = binr.ReadUInt16();
               if (twobytes == 0x8130)    //data read as little endian order (actual data order for Sequence is 30 81)
                   binr.ReadByte();    //advance 1 byte
               else if (twobytes == 0x8230)
                   binr.ReadInt16();    //advance 2 bytes
               else
                   return null;
               bt = binr.ReadByte();
               if (bt != 0x02)
                   return null;
               twobytes = binr.ReadUInt16();
               if (twobytes != 0x0001)
                   return null;
               seq = binr.ReadBytes(15);        //read the Sequence OID
               if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct
                   return null;
               bt = binr.ReadByte();
               if (bt != 0x04)    //expect an Octet string
                   return null;
               bt = binr.ReadByte();        //read next byte, or next 2 bytes is  0x81 or 0x82; otherwise bt is the byte count
               if (bt == 0x81)
                   binr.ReadByte();
               else
                   if (bt == 0x82)
                   binr.ReadUInt16();
               //------ at this stage, the remaining sequence should be the RSA private key
               byte[] rsaprivkey = binr.ReadBytes((int)(lenstream - mem.Position));
               RSACryptoServiceProvider rsacsp = DecodeRSAPrivateKey(rsaprivkey);
               return rsacsp;
           }
           catch (Exception)
           {
               return null;
           }
           finally { binr.Close(); }
       }
       private static bool CompareBytearrays(byte[] a, byte[] b)
       {
           if (a.Length != b.Length)
               return false;
           int i = 0;
           foreach (byte c in a)
           {
               if (c != b[i])
                   return false;
               i++;
           }
           return true;
       }
       private static RSACryptoServiceProvider DecodeRSAPublicKey(byte[] publickey)
       {
           // encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
           byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
           byte[] seq = new byte[15];
           // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
           MemoryStream mem = new MemoryStream(publickey);
           BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading
           byte bt = 0;
           ushort twobytes = 0;
           try
           {
               twobytes = binr.ReadUInt16();
               if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                   binr.ReadByte();    //advance 1 byte
               else if (twobytes == 0x8230)
                   binr.ReadInt16();   //advance 2 bytes
               else
                   return null;
               seq = binr.ReadBytes(15);       //read the Sequence OID
               if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct
                   return null;
               twobytes = binr.ReadUInt16();
               if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
                   binr.ReadByte();    //advance 1 byte
               else if (twobytes == 0x8203)
                   binr.ReadInt16();   //advance 2 bytes
               else
                   return null;
               bt = binr.ReadByte();
               if (bt != 0x00)     //expect null byte next
                   return null;
               twobytes = binr.ReadUInt16();
               if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
                   binr.ReadByte();    //advance 1 byte
               else if (twobytes == 0x8230)
                   binr.ReadInt16();   //advance 2 bytes
               else
                   return null;
               twobytes = binr.ReadUInt16();
               byte lowbyte = 0x00;
               byte highbyte = 0x00;
               if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
                   lowbyte = binr.ReadByte();  // read next bytes which is bytes in modulus
               else if (twobytes == 0x8202)
               {
                   highbyte = binr.ReadByte(); //advance 2 bytes
                   lowbyte = binr.ReadByte();
               }
               else
                   return null;
               byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order
               int modsize = BitConverter.ToInt32(modint, 0);
               byte firstbyte = binr.ReadByte();
               binr.BaseStream.Seek(-1, SeekOrigin.Current);
               if (firstbyte == 0x00)
               {   //if first byte (highest order) of modulus is zero, don't include it
                   binr.ReadByte();    //skip this null byte
                   modsize -= 1;   //reduce modulus buffer size by 1
               }
               byte[] modulus = binr.ReadBytes(modsize);   //read the modulus bytes
               if (binr.ReadByte() != 0x02)            //expect an Integer for the exponent data
                   return null;
               int expbytes = (int)binr.ReadByte();        // should only need one byte for actual exponent data (for all useful values)
               byte[] exponent = binr.ReadBytes(expbytes);
               // ------- create RSACryptoServiceProvider instance and initialize with public key -----
               RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
               RSAParameters RSAKeyInfo = new RSAParameters();
               RSAKeyInfo.Modulus = modulus;
               RSAKeyInfo.Exponent = exponent;
               RSA.ImportParameters(RSAKeyInfo);
               return RSA;
           }
           catch (Exception)
           {
               return null;
           }
           finally { binr.Close(); }
       }
       private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)
       {
           byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;
           // ---------  Set up stream to decode the asn.1 encoded RSA private key  ------
           MemoryStream mem = new MemoryStream(privkey);
           BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading
           byte bt = 0;
           ushort twobytes = 0;
           int elems = 0;
           try
           {
               twobytes = binr.ReadUInt16();
               if (twobytes == 0x8130)    //data read as little endian order (actual data order for Sequence is 30 81)
                   binr.ReadByte();    //advance 1 byte
               else if (twobytes == 0x8230)
                   binr.ReadInt16();    //advance 2 bytes
               else
                   return null;
               twobytes = binr.ReadUInt16();
               if (twobytes != 0x0102)    //version number
                   return null;
               bt = binr.ReadByte();
               if (bt != 0x00)
                   return null;
               //------  all private key components are Integer sequences ----
               elems = GetIntegerSize(binr);
               MODULUS = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               E = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               D = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               P = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               Q = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               DP = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               DQ = binr.ReadBytes(elems);
               elems = GetIntegerSize(binr);
               IQ = binr.ReadBytes(elems);
               // ------- create RSACryptoServiceProvider instance and initialize with public key -----
               RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
               RSAParameters RSAparams = new RSAParameters();
               RSAparams.Modulus = MODULUS;
               RSAparams.Exponent = E;
               RSAparams.D = D;
               RSAparams.P = P;
               RSAparams.Q = Q;
               RSAparams.DP = DP;
               RSAparams.DQ = DQ;
               RSAparams.InverseQ = IQ;
               RSA.ImportParameters(RSAparams);
               return RSA;
           }
           catch (Exception)
           {
               return null;
           }
           finally { binr.Close(); }
       }
       private static int GetIntegerSize(BinaryReader binr)
       {
           byte bt = 0;
           byte lowbyte = 0x00;
           byte highbyte = 0x00;
           int count = 0;
           bt = binr.ReadByte();
           if (bt != 0x02)        //expect integer
               return 0;
           bt = binr.ReadByte();
           if (bt == 0x81)
               count = binr.ReadByte();    // data size in next byte
           else
               if (bt == 0x82)
           {
               highbyte = binr.ReadByte();    // data size in next 2 bytes
               lowbyte = binr.ReadByte();
               byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
               count = BitConverter.ToInt32(modint, 0);
           }
           else
           {
               count = bt;        // we already have the data size
           }
           while (binr.ReadByte() == 0x00)
           {    //remove high order zeros in data
               count -= 1;
           }
           binr.BaseStream.Seek(-1, SeekOrigin.Current);        //last ReadByte wasn't a removed zero, so back up a byte
           return count;
       }
       #endregion
       #region 解析.net 生成的Pem
       private static RSAParameters ConvertFromPublicKey(string pemFileConent)
       {
           byte[] keyData = Convert.FromBase64String(pemFileConent);
           if (keyData.Length < 162)
           {
               throw new ArgumentException("pem file content is incorrect.");
           }
           byte[] pemModulus = new byte[128];
           byte[] pemPublicExponent = new byte[3];
           Array.Copy(keyData, 29, pemModulus, 0, 128);
           Array.Copy(keyData, 159, pemPublicExponent, 0, 3);
           RSAParameters para = new RSAParameters();
           para.Modulus = pemModulus;
           para.Exponent = pemPublicExponent;
           return para;
       }
       private static RSAParameters ConvertFromPrivateKey(string pemFileConent)
       {
           byte[] keyData = Convert.FromBase64String(pemFileConent);
           if (keyData.Length < 609)
           {
               throw new ArgumentException("pem file content is incorrect.");
           }
           int index = 11;
           byte[] pemModulus = new byte[128];
           Array.Copy(keyData, index, pemModulus, 0, 128);
           index += 128;
           index += 2;//141
           byte[] pemPublicExponent = new byte[3];
           Array.Copy(keyData, index, pemPublicExponent, 0, 3);
           index += 3;
           index += 4;//148
           byte[] pemPrivateExponent = new byte[128];
           Array.Copy(keyData, index, pemPrivateExponent, 0, 128);
           index += 128;
           index += ((int)keyData[index + 1] == 64 ? 2 : 3);//279
           byte[] pemPrime1 = new byte[64];
           Array.Copy(keyData, index, pemPrime1, 0, 64);
           index += 64;
           index += ((int)keyData[index + 1] == 64 ? 2 : 3);//346
           byte[] pemPrime2 = new byte[64];
           Array.Copy(keyData, index, pemPrime2, 0, 64);
           index += 64;
           index += ((int)keyData[index + 1] == 64 ? 2 : 3);//412/413
           byte[] pemExponent1 = new byte[64];
           Array.Copy(keyData, index, pemExponent1, 0, 64);
           index += 64;
           index += ((int)keyData[index + 1] == 64 ? 2 : 3);//479/480
           byte[] pemExponent2 = new byte[64];
           Array.Copy(keyData, index, pemExponent2, 0, 64);
           index += 64;
           index += ((int)keyData[index + 1] == 64 ? 2 : 3);//545/546
           byte[] pemCoefficient = new byte[64];
           Array.Copy(keyData, index, pemCoefficient, 0, 64);
           RSAParameters para = new RSAParameters();
           para.Modulus = pemModulus;
           para.Exponent = pemPublicExponent;
           para.D = pemPrivateExponent;
           para.P = pemPrime1;
           para.Q = pemPrime2;
           para.DP = pemExponent1;
           para.DQ = pemExponent2;
           para.InverseQ = pemCoefficient;
           return para;
       }
       #endregion
   }
}

调用方式：

string publickey = "";
           string privatekey = "";
           publickey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDDLA7Of0H4g+WaAToFCdmLDP4DbCc161JcSr0t+XlMSCEiglFhTOh4+HtCWSpVKhwzTO9ShYwWooTqGpfl1LbLg+RhBXtbMq1M+HaVVkscbbDz3xS6ngUMssktw+Q+9rYtGor+lNGSJHF7HnaTJ6Qyv1oUYiIap4oi1sLPMQDIDwIDAQAB";
           privatekey = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMMsDs5/QfiD5ZoBOgUJ2YsM/gNsJzXrUlxKvS35eUxIISKCUWFM6Hj4e0JZKlUqHDNM71KFjBaihOoal+XUtsuD5GEFe1syrUz4dpVWSxxtsPPfFLqeBQyyyS3D5D72ti0aiv6U0ZIkcXsedpMnpDK/WhRiIhqniiLWws8xAMgPAgMBAAECgYBafOXMhaHfh79+/Iya42syFe77RTyUuirwUVKOqzi6zkJWjpcOhqrN017Kby66V5DFlCjtWK+PmwAGzheY3lt1BQTYVkcjZS6oB+NnimZsqbuaixkdcS9TDdv+p40DffyATmIHy/7vivet0FCfRzpMo0KU9+m5Mc8s7qyVYio8MQJBAP6a0uU/JpK3irhO1B1o52ANTNnwK0q7mKwFP/oomExkKSajH0uBrKM6KdtF9p41h361M4gDwL2wxkN8v792e8kCQQDEPdulLlT95pD721wavzeA8cbtyn+NAo++auutV8USZ8zyDsuQD5Lr8dyh4IzVYXWYl8zsF5W6XIkwI2guEOEXAkEA8dTLJpaCI++UIpY1Ya3nv1NCwOsfo79mN1ZRO2JdromgkKN2MTj9apjvcugUZJfBmDeyt6mg5ExJNYcDdm+rCQJACQo8cwiGW8fiR+fb/1NtsB/zJQMeCxXiH0h3oN2ZM3bapw/taq58+yeCHWbltfKuYyAjDYEsoZAftbr70ptucwJATIB2krFwczTMA5eo07/r2LPspIqFKmEfPsKKX81yMcxTZ/outSOO/b6O0k+W6gdwxB9/nISMZigv4VbGFn6qnQ==";

//加密字符串
           string data = "202201131819gao";
           Console.WriteLine("原始：" + data);
           //加密
           string encrypteddata = RSAPkcs8Helper.encryptData(data, publickey, "UTF-8");
           Console.WriteLine("加密：" + encrypteddata);
           Console.WriteLine("解密：" + RSAPkcs8Helper.decryptData(encrypteddata, privatekey, "UTF-8"));
           Console.WriteLine("------------------------------------------------------");
           //解密
           string endata = "WI8eYavWOasyYjgWn8r9SXSvW18dmzmlSY4CrWXoTmqHbPCE6iWGYOzes4QOrPDKDPPpHdEpfMYPQZPs2BX84bvpohOejKKQS2TE0hEutk0RMX76ltuFpR51SLqe+TqSEMDbkyoaJRb2OlGA1SqTC+uDpZA1tbofB5v/+5mB5o8=";
           string datamw = RSAPkcs8Helper.decryptData(endata, privatekey, "UTF-8");
           Console.WriteLine("提前获知解密：" + datamw);

来源：https://www.cnblogs.com/Gao1234/archive/2022/01/14/15799219.html