using System;
using System.Collections.Generic;
namespace MyEncrypt
{
class Program
{
//1. MD5 不可逆加密
//2. Des 对称可逆加密 目前用Aes代替
//3. RSA 非对称可逆加密
//4. 数字证书 SSL --->IIS 安装SSL
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
//MD5
Console.WriteLine(MD5Encrypt.EncryptStr("123456小王"));
//Des
var encryptStr = DesEncrypt.Encrypt("我们第卅获得首发还是东京评分数据的皮肤");
var decryptStr = DesEncrypt.Decrypt(encryptStr);
//Rsa
KeyValuePair<string, string> keyValuePair = RsaEncrypt.GetKeyPair();
var rsaEncryptStr = RsaEncrypt.Encrypt("正道的光",keyValuePair.Key);
var rsaDecryptStr = RsaEncrypt.Decrypt(rsaEncryptStr, keyValuePair.Value);
//CA证书包含：
//1.持有者姓名
//2.发证机关
//3.有效日期
//4.证书持有人的公钥 ----这个东西很关键，用这个公钥加密传给对方，如果对方能解密，证明这个证书的确是他的
//5.扩展信息
//6.发证机关对该证书的数字签名 数字签名=前5点信息的MD5摘要，然后用CA的私钥加密下
//单边认证过程：
//1.客户端向服务器端请求证书
//2.服务器发回证书
//3.客户端接收证书并验证：用浏览器内置的发证机关的公钥对证书数字签名解密，用解密出的MD5验证证书未被篡改
//4.用证书上的服务器端公钥加密一段内容发送给服务器端
//5.服务器端接收加密的内容，并用自己的私钥解密，返回解密后的内容
//6.客户端接收返回的内容并验证（到此步骤完成对服务器的验证）
//7.客户端再用服务器公钥加密一个 对称可逆加密的密钥 发送给服务器
//8.服务器接收,并解密出 对称可逆加密的密钥，开始用这个密钥进行信息传输
//双边认证
//1到6步和单边认证时一样的
//7.客户端发送自己的证书给服务器
//8.服务器用客户端证书上的公钥加密内容发送给客户端
//9.客户端用自己的私钥解密，返回给服务器端
//10.服务器端返回认证结果
//后面两步和单边认证7、8步一样
}
}
}
MD5
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;//需要引用的加密命名空间
using System.Text;
namespace MyEncrypt
{
//1.相同原文加密结果是一样的---废话，要不然每次不一样怎么用？
//2.不同长度的内容加密后的长度是一样的，计算后都是长度16的字节数组
//3.原文差别很小，结果差距很大
//4.不管文件大小，摘要为长度16的字节数组 --- 当然了，都是对字节数组计算产生哈希值
//5.MD5用途：
// 1.防止篡改
// 2.急速秒传
// 3.密码保存，防止看到明文 防止简单密码被破解--> 可以加盐 或者再进行一次MD5计算
// 4.SVN代码管理就是用的MD5 文件修改后跟本地该文件之前的MD5不一致了，就认为文件改动了
// 5.数字签名 文件交由权威第三方，第三方出一个MD5 -->防止抵赖
public class MD5Encrypt
{
/// <summary>
/// MD5加密字符串，和动网上的16/32位加密结果相同
/// </summary>
/// <param name="source"></param>
/// <param name="len">输出的字符串长度</param>
/// <returns></returns>
public static string EncryptStr(string source, int len = 32)
{
if (string.IsNullOrEmpty(source))
return string.Empty;
byte[] bytes = Encoding.UTF8.GetBytes(source);//这里需要编码，不同编码产生的字节数组不同，所以最后MD5哈希值就不同了
//两种写法都行，下面直接用MD5的对象更简单
HashAlgorithm hashAlgorithm = CryptoConfig.CreateFromName("MD5") as HashAlgorithm;
byte[] hashValue = hashAlgorithm.ComputeHash(bytes);
//这种更简单好记
//MD5 mD5 = MD5.Create();
//byte[] hashValue = mD5.ComputeHash(bytes);
StringBuilder sb = new StringBuilder();
switch (len)
{
case 16://16位密文是32位的9到24位字符
for (int i = 4; i < 12; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
case 32:
for (int i = 0; i < 16; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
default:
for (int i = 0; i < hashValue.Length; i++)
{
sb.Append(hashValue[i].ToString("x2"));
}
break;
}
return sb.ToString();
}
/// <summary>
/// 获取文件摘要
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
public static string AbstractFile(string fileName)
{
if (string.IsNullOrEmpty(fileName) || !File.Exists(fileName))
return string.Empty;
using (FileStream fileStream = File.OpenRead(fileName))
{
return AbstractFile(fileStream);
}
}
/// <summary>
/// 根据流获取摘要
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public static string AbstractFile(Stream stream)
{
MD5 mD5 = new MD5CryptoServiceProvider();
//MD5 mD5 = MD5.Create();//同样的，MD5可以这样方便好记的写法
byte[] bytes = mD5.ComputeHash(stream);
StringBuilder sb = new StringBuilder();
foreach (byte item in bytes)
{
sb.Append(item.ToString("x2"));
}
return sb.ToString();
}
}
}
Des
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace MyEncrypt
{
//数据的加密传输
//加密速度快
//但是存在密钥安全性问题，不管哪一方泄露密钥，内容都会被破解，或者说密钥传输是不安全的
//目前采用Aes加密代替了Des
public class DesEncrypt
{
/// <summary>
/// 加密key 长度8,因为算法只需要8位
/// </summary>
private static byte[] rgbKey = ASCIIEncoding.ASCII.GetBytes("wchen1234".Substring(0, 8));
/// <summary>
/// 向量
/// </summary>
private static byte[] rgbIV = ASCIIEncoding.ASCII.GetBytes("wchen1234".Insert(0, "h").Substring(0, 8));
/// <summary>
/// DES加密
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string Encrypt(string text)
{
//1.得到一个DES加密对象
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//2.得到一个内存流
using (MemoryStream ms = new MemoryStream())
{
//3.用内存流做参数，实例化个加密流
CryptoStream cryptoStream = new CryptoStream(ms, des.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
//多加一个写入流看着比较烦
//{
// //4.用加密流做参数实例化 写入流
// StreamWriter sw = new StreamWriter(cryptoStream);
// //5.写入流写入
// sw.Write(text);
// sw.Flush();
//}
//这种看着清爽
{
//4.把字符串转成字节数组
byte[] bytes = Encoding.UTF8.GetBytes(text);
//5.加密流写入字节数组
cryptoStream.Write(bytes, 0, bytes.Length);
}
cryptoStream.FlushFinalBlock();
ms.Flush();
return Convert.ToBase64String(ms.ToArray());
//return Convert.ToBase64String(ms.GetBuffer(), 0, ms.GetBuffer().Length);
}
}
/// <summary>
/// DES解密
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string Decrypt(string text)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
//des.Key = rgbKey;
//des.IV = rgbIV;
byte[] bytes = Convert.FromBase64String(text);
using (MemoryStream ms = new MemoryStream())
{
CryptoStream cryptoStream = new CryptoStream(ms, des.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
cryptoStream.Write(bytes, 0, bytes.Length);
cryptoStream.FlushFinalBlock();
ms.Flush();
return Encoding.UTF8.GetString(ms.ToArray());
}
}
}
}
Rsa
using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
namespace MyEncrypt
{
//非对称可逆加密
//1.算法公开
//2.密钥是一对，加密密钥--解密密钥 加密密钥-->经过算法加密-->解密密钥-->算法解密-->原文
//3.安全性好
//用途：
// 1.数字签名：公开解密key,我的文件用加密key加密，凡是别人能解密的-->肯定是我的文件
// 2.数据安全传输：公开加密key,密文只有我能解密，不怕别人拦截
//4.C# 只实现了公钥加密，私钥解密 没实现私钥加密，公钥解密
// 第三方BouncyCastle.Crypto.dll 实现两个
public class RsaEncrypt
{
/// <summary>
/// 获取密钥对
/// </summary>
/// <returns></returns>
public static KeyValuePair<string, string> GetKeyPair()
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
string publicKey = rsa.ToXmlString(false);
string privateKey = rsa.ToXmlString(true);
//string sss = rsa.ToXmlString(true);
//var jjj = privateKey.Equals(sss); 同一个对象产生的 公钥私钥是一样的，不同对象之间是不同的
//Console.WriteLine(privateKey);
//Console.WriteLine(sss);
//RSACryptoServiceProvider rsa1 = new RSACryptoServiceProvider();
//string publicKey1 = rsa1.ToXmlString(false);
//string privateKey1 = rsa1.ToXmlString(true);
//string sss1 = rsa1.ToXmlString(true);
//var jjj1 = privateKey1.Equals(sss1);
//Console.WriteLine(privateKey1);
//Console.WriteLine(sss1);
//var ggg = privateKey.Equals(privateKey1);
return new KeyValuePair<string, string>(publicKey, privateKey);
}
/// <summary>
/// RSA加密
/// </summary>
/// <param name="text"></param>
/// <param name="encryptKey"></param>
/// <returns></returns>
public static string Encrypt(string text, string encryptKey)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(encryptKey);
UnicodeEncoding byteConverter = new UnicodeEncoding(); //Unicode = UTF-16
byte[] bytes = byteConverter.GetBytes(text);
byte[] encryptByteArr = rsa.Encrypt(bytes, false);
return Convert.ToBase64String(encryptByteArr);
}
/// <summary>
/// RSA解密
/// </summary>
/// <param name="text"></param>
/// <param name="decryptKey"></param>
/// <returns></returns>
public static string Decrypt(string text, string decryptKey)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(decryptKey);
byte[] bytes = Convert.FromBase64String(text);
byte[] decryptByteArr = rsa.Decrypt(bytes, false);
return new UnicodeEncoding().GetString(decryptByteArr);
}
}
}
Rsa C#适配Java
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.X509;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
namespace LoginToADBusiness.Helper
{
public class RsaCryptography
{
public static void chek()
{
var key = RSAPublicKeyDotNet2Java(public_Key);
string content = "123qwe!@#";
string jm = Encrypt(content);
string rst = Decrypt(jm);
}
//private static string public_Key = "BgIAAACkAABSU0ExAAQAAAEAAQBxMpX4WVaMaBcGHGOTqm0AwLDobtld0AJdlpNBL4hYLh5xyERQfmWYcPCglzhi4j5v3cXuniGrD2C+786tAqSSWH6fjESp9i9cpLP9zvl2ocFiuWW4dkxMt0LwaGcZFW191nOyzjI//ki0z5h3CpzWE7rmKCd0ET8hs+3MHuRZ0A==";
//private static string private_Key = "BwIAAACkAABSU0EyAAQAAAEAAQBxMpX4WVaMaBcGHGOTqm0AwLDobtld0AJdlpNBL4hYLh5xyERQfmWYcPCglzhi4j5v3cXuniGrD2C+786tAqSSWH6fjESp9i9cpLP9zvl2ocFiuWW4dkxMt0LwaGcZFW191nOyzjI//ki0z5h3CpzWE7rmKCd0ET8hs+3MHuRZ0BVoFL6Yf+f3qotzs3h65gZZ3ns9NOb7ZbDL1NaADz1wlIj5zWvG7l6ET7J/7BIjeneDtd8465+k7yMoV+ZDQ9jtO+R1EU/tRyASFB1BkMijlEwgwsdzIh7BsNefWqWnSDpagaRE/wAQXtPJ9Soq47NttfZKRl7rcUp28N0aeaL2gW6mzHWl7V92yeSi7Em3ez8XKZjQgYy+2RNqi7T+zW1XnmNYB4PYRDKzuNpNJl9dWolBaPHhhw9ccwJOVhNLGnEXJD8HMGgkny4bcmfEXk7UyURKI9mf6SA3iQW6cZG0KDhnUbag8tmSf3PFz+Hcjb2Lq22Gkb8Ytro4i0/VrDgU/eMiVYbeNwAa2ppuUFkUAVaD1uUNC0ir4XxYaAR0RRUjXR21MhfrZTD03G7SIKNbi87ODkaR+MKVINrBiGLSEesPV5ksIGOOpkH4rE6toIirYu8Qlg8QkNgxhHdXF0e+jtmhaM5iPVrap2v1zKYyaiNQyWgzXVBoRPAWqFx3VCIW6aXOxRmECbQmzOApvCqUQVsa71fybaAXG11aNWnzaPgnca6ziycSdGw7mJgyZ777xLLGEpwRFMn75RvqhwA=";
private static string public_Key = "<RSAKeyValue><Modulus>vOI41rYkLEgWFGnm8fZ5/rR2pV1ZkjjW5yfVDO7zXO5MbDatNa4/xUu3Io7/mlwSNYLGBAHKcT0P4L5m4Cp+waCxq6E1d4DHv43/IUTvzTLZAH/TEILjTrAuWa3DoSkyO+iaixf1jCui1p6XHSGVUrtZjGboUaRkNL8IKN8ETjU=</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";
private static string private_Key = "<RSAKeyValue><Modulus>vOI41rYkLEgWFGnm8fZ5/rR2pV1ZkjjW5yfVDO7zXO5MbDatNa4/xUu3Io7/mlwSNYLGBAHKcT0P4L5m4Cp+waCxq6E1d4DHv43/IUTvzTLZAH/TEILjTrAuWa3DoSkyO+iaixf1jCui1p6XHSGVUrtZjGboUaRkNL8IKN8ETjU=</Modulus><Exponent>AQAB</Exponent><P>/1pV/r6cqcBz2APOikC/cq+YTN5VnUrkMY1/B/rrB3W5SI8YTQj9le7kndn1ib689os3hOzrs09ezflShnT0pw==</P><Q>vVzDYSs+XdqPNc90Ii2bKo8/bLk0AbcoLZrb++N+Jed05iNZin4nRsCU082wBllhTkoylilY+bQBPt3z8YnVww==</Q><DP>bi4WaQLqKjzGP3D1D6Z8dQnbV1+f5WzJJbB+HX1hKCjdt7c2rxawBJ+9uXawgazxcBgF7q8jzIz0xT9NIoMYhQ==</DP><DQ>L4xDYvrAxkBDBXf56TsaYy1k95/pdyTOaeUgp7cPzeS4bbEioqvaoOFqfWSAdpeq30WyPhJTzR9t0KNaxaOekQ==</DQ><InverseQ>Saf+qvS2+eHYWp0xzuB5OLEskKexhtVQd95CFOyXKiMirrkHOuCb3mycRGrXIUK4GHmuT6jLWk6YrSE8RC/IIg==</InverseQ><D>B8h4mBxcRDjaNBAjFJBX+Y9dHjZJBRXzgQXqqQRFoewt2P2tyHr8JLiYfMOQs78cfvj7CNo8Cct+1n9yBMWrgGO4BQPMxk9V8RSE+kClgN+6QPjeJhJIy29ERHiiudpWLqEc98FoazhdHddGrNIhayKBElq2dpNQ+aK4EfQ1zXc=</D></RSAKeyValue>";
//C#和java的密钥格式不同，转格式需引用类库BouncyCastle.Crypto
/// <summary>
/// 生成一对公钥和私钥
/// </summary>
/// <returns></returns>
public static KeyValuePair<string, string> GetKeyPair1()
{
RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
string publicKey = RSA.ToXmlString(false);
string privateKey = RSA.ToXmlString(true);
//string public_Key = Convert.ToBase64String(RSA.ExportCspBlob(false));
//string private_Key = Convert.ToBase64String(RSA.ExportCspBlob(true));
return new KeyValuePair<string, string>(public_Key, private_Key);
}
/// <summary>
/// RSA私钥格式转换，.net->java
/// </summary>
/// <param name="privateKey">.net生成的私钥</param>
/// <returns></returns>
public static string RSAPrivateKeyDotNet2Java(string privateKey)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(privateKey);
BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
BigInteger exp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
BigInteger d = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("D")[0].InnerText));
BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("P")[0].InnerText));
BigInteger q = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Q")[0].InnerText));
BigInteger dp = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DP")[0].InnerText));
BigInteger dq = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("DQ")[0].InnerText));
BigInteger qinv = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("InverseQ")[0].InnerText));
RsaPrivateCrtKeyParameters privateKeyParam = new RsaPrivateCrtKeyParameters(m, exp, d, p, q, dp, dq, qinv);
PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKeyParam);
byte[] serializedPrivateBytes = privateKeyInfo.ToAsn1Object().GetEncoded();
return Convert.ToBase64String(serializedPrivateBytes);
}
/// <summary>
/// RSA公钥格式转换，.net->java
/// </summary>
/// <param name="publicKey">.net生成的公钥</param>
/// <returns></returns>
public static string RSAPublicKeyDotNet2Java(string publicKey)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(publicKey);
BigInteger m = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Modulus")[0].InnerText));
BigInteger p = new BigInteger(1, Convert.FromBase64String(doc.DocumentElement.GetElementsByTagName("Exponent")[0].InnerText));
RsaKeyParameters pub = new RsaKeyParameters(false, m, p);
SubjectPublicKeyInfo publicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(pub);
byte[] serializedPublicBytes = publicKeyInfo.ToAsn1Object().GetDerEncoded();
return Convert.ToBase64String(serializedPublicBytes);
}
/// <summary>
/// RSA加密 C#版，密钥格式不带标签
/// </summary>
/// <param name="publickey"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string RSAEncrypt(string content)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.ImportCspBlob(Convert.FromBase64String(public_Key));
cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
return Convert.ToBase64String(cipherbytes);
}
/// <summary>
/// RSA解密 C#版，密钥格式不带标签
/// </summary>
/// <param name="privatekey"></param>
/// <param name="content"></param>
/// <returns></returns>
public static string RSADecrypt(string content)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
byte[] cipherbytes;
rsa.ImportCspBlob(Convert.FromBase64String(private_Key));
cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);
return Encoding.UTF8.GetString(cipherbytes);
}
/// <summary>
/// RSA加密 适配java，用的密钥格式xml
/// </summary>
/// <param name="text"></param>
/// <param name="encryptKey"></param>
/// <returns></returns>
public static string Encrypt(string text)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(public_Key);
byte[] bytes = Encoding.UTF8.GetBytes(text);
byte[] encryptByteArr = rsa.Encrypt(bytes, false);
return Convert.ToBase64String(encryptByteArr);
}
/// <summary>
/// RSA解密 适配java，用的密钥格式xml
/// </summary>
/// <param name="text"></param>
/// <param name="decryptKey"></param>
/// <returns></returns>
public static string Decrypt(string text)
{
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(private_Key);
byte[] bytes = Convert.FromBase64String(text);
byte[] decryptByteArr = rsa.Decrypt(bytes, false);
return Encoding.UTF8.GetString(decryptByteArr);
}
}
}
Aes
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
namespace LoginToADBusiness.Helper
{
public class AESCryptography
{
/// <summary>
/// 获取密钥
/// </summary>
private static string Key
{
get { return @"mailyimidida0com"; }
}
/// <summary>
/// 获取向量
/// </summary>
private static string IV
{
get { return @"owayimidida12345"; }
}
/// <summary>
/// AES加密
/// </summary>
/// <param name="plainStr">明文字符串</param>
/// <returns>密文</returns>
public static string AESEncrypt(string plainStr)
{
if (string.IsNullOrEmpty(plainStr))
return string.Empty;
byte[] bKey = Encoding.UTF8.GetBytes(Key);
byte[] bIV = Encoding.UTF8.GetBytes(IV);
byte[] byteArray = Encoding.UTF8.GetBytes(plainStr);
string encrypt = null;
Rijndael aes = Rijndael.Create();
//双方要采用一致的运算模式和填充模式
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.Zeros;
try
{
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateEncryptor(bKey, bIV), CryptoStreamMode.Write))
{
cStream.Write(byteArray, 0, byteArray.Length);
cStream.FlushFinalBlock();
encrypt = Convert.ToBase64String(mStream.ToArray());
}
}
}
catch (Exception e)
{ throw e; }
aes.Clear();
return encrypt;
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="encryptStr">密文字符串</param>
/// <returns>明文</returns>
public static string AESDecrypt(string encryptStr)
{
if (string.IsNullOrEmpty(encryptStr))
return string.Empty;
byte[] bKey = Encoding.UTF8.GetBytes(Key);
byte[] bIV = Encoding.UTF8.GetBytes(IV);
byte[] byteArray = Convert.FromBase64String(encryptStr);
string decrypt = null;
Rijndael aes = Rijndael.Create();
//双方要采用一致的运算模式和填充模式
aes.Mode = CipherMode.CBC;
aes.Padding = PaddingMode.Zeros;
try
{
using (MemoryStream mStream = new MemoryStream())
{
using (CryptoStream cStream = new CryptoStream(mStream, aes.CreateDecryptor(bKey, bIV), CryptoStreamMode.Write))
{
cStream.Write(byteArray, 0, byteArray.Length);
cStream.FlushFinalBlock();
decrypt = Encoding.UTF8.GetString(mStream.ToArray());
}
}
}
catch (Exception e)
{ throw e; }
aes.Clear();
return decrypt.Replace("\0", "");
}
}
}
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
