C#加密解密（DES,AES,Base64,md5,SHA256,RSA,RC4）
⼀：异或^简单加解密(数字类型)
1：原理:
异或⽤于⽐较两个⼆进制数的相应位，在执⾏按位"异或"运算时，如果两个⼆进制数的相应位都为1或者都为0，则返回0；如果两个⼆进制数的相应位其中⼀个为1另⼀个为0，则返回1.
//对数字加密
int P_int_Num, P_int_Key;//定义两个值类型变量
string Encryptstr = (P_int_Num ^ P_int_Key).ToString();//加密数值
//对数字解密
int P_int_Key, P_int_Encrypt;//定义两个值类型变量
string Encryptstr =(P_int_Encrypt ^ P_int_Key).ToString();//解密数值
⼆：加密解密类
public class JiaMiJieMi
{
#region DES对称加密解密
///<summary>加密字符串
///</summary>
///<param name="strText">需被加密的字符串</param>
///<param name="strEncrKey">密钥</param>
///<returns></returns>
public static string DesEncrypt(string strText, string strEncrKey)
{
try
{
byte[] byKey = null;
byte[] IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
byKey = Encoding.UTF8.GetBytes(strEncrKey.Substring(0, 8));
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] inputByteArray = Encoding.UTF8.GetBytes(strText);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(byKey, IV), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Convert.ToBase64String(ms.ToArray());
}
catch
{
return"";
}
}
///<summary>解密字符串
///</summary>
///<param name="strText">需被解密的字符串</param>
///<param name="sDecrKey">密钥</param>
/
//<returns></returns>
public static string DesDecrypt(string strText, string sDecrKey)
{
try
{
byte[] byKey = null;
byte[] IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
byte[] inputByteArray = new Byte[strText.Length];
byKey = Encoding.UTF8.GetBytes(sDecrKey.Substring(0, 8));
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
inputByteArray = Convert.FromBase64String(strText);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(byKey, IV), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
Encoding encoding = new UTF8Encoding();
return encoding.GetString(ms.ToArray());
}
catch
return null;
}
}
///<summary>加密⽂件
///
///</summary>
///<param name="m_InFilePath">原路径</param>
///<param name="m_OutFilePath">加密后的⽂件路径</param>
///<param name="strEncrKey">密钥</param>
public static void DesEncryptFile(string m_InFilePath, string m_OutFilePath, string strEncrKey)
{
try
{
byte[] byKey = null;
byte[] IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
byKey = Encoding.UTF8.GetBytes(strEncrKey.Substring(0, 8));
FileStream fin = new FileStream(m_InFilePath, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(m_OutFilePath, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
//Create variables to help with read and write.
byte[] bin = new byte[100]; //This is intermediate storage for the encryption.
long rdlen = 0; //This is the total number of bytes written.
long totlen = fin.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.
DES des = new DESCryptoServiceProvider();
CryptoStream encStream = new CryptoStream(fout, des.CreateEncryptor(byKey, IV), CryptoStreamMode.Write);
//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
encStream.Write(bin, 0, len);
rdlen = rdlen + len;
}
encStream.Close();
fout.Close();
fin.Close();
}
catch
{
}
}
///<summary>解密⽂件
///
///</summary>
///<param name="m_InFilePath">被解密路径</param>
///<param name="m_OutFilePath">解密后的路径</param>
///<param name="sDecrKey">密钥</param>
public static void DesDecryptFile(string m_InFilePath, string m_OutFilePath, string sDecrKey)
{
try
{
byte[] byKey = null;
byte[] IV = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
byKey = Encoding.UTF8.GetBytes(sDecrKey.Substring(0, 8));
FileStream fin = new FileStream(m_InFilePath, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(m_OutFilePath, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
//Create variables to help with read and write.
byte[] bin = new byte[100]; //This is intermediate storage for the encryption.
long rdlen = 0; //This is the total number of bytes written.
long totlen = fin.Length; //This is the total length of the input file.
int len; //This is the number of bytes to be written at a time.
DES des = new DESCryptoServiceProvider();
CryptoStream encStream = new CryptoStream(fout, des.CreateDecryptor(byKey, IV), CryptoStreamMode.Write);
//Read from the input file, then encrypt and write to the output file.
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
encStream.Write(bin, 0, len);
rdlen = rdlen + len;
}
encStream.Close();
fout.Close();
fin.Close();
catch
{
}
}
#endregion
#region
对称加密算法AES RijndaelManaged加密解密
private static readonly string Default_AES_Key = "@#kim123";
private static byte[] Keys = { 0x41, 0x72, 0x65, 0x79, 0x6F, 0x75, 0x6D, 0x79,
0x53,0x6E, 0x6F, 0x77, 0x6D, 0x61, 0x6E, 0x3F };
public static string AES_Encrypt(string encryptString)
{
return AES_Encrypt(encryptString, Default_AES_Key);
}
public static string AES_Decrypt(string decryptString)
{
return AES_Decrypt(decryptString, Default_AES_Key);
}
///<summary>对称加密算法AES RijndaelManaged加密(RijndaelManaged（AES）算法是块式加密算法) ///
///</summary>
///<param name="encryptString">待加密字符串</param>
///<param name="encryptKey">加密密钥，须半⾓字符</param>
///<returns>加密结果字符串</returns>
public static string AES_Encrypt(string encryptString, string encryptKey)
{
encryptKey = GetSubString(encryptKey, 32, "");
encryptKey = encryptKey.PadRight(32, '');
RijndaelManaged rijndaelProvider = new RijndaelManaged();
rijndaelProvider.Key = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 32));
rijndaelProvider.IV = Keys;
ICryptoTransform rijndaelEncrypt = rijndaelProvider.CreateEncryptor();
byte[] inputData = Encoding.UTF8.GetBytes(encryptString);
byte[] encryptedData = rijndaelEncrypt.TransformFinalBlock(inputData, 0, inputData.Length);
return Convert.ToBase64String(encryptedData);
}
///<summary>对称加密算法AES RijndaelManaged解密字符串
///
///</summary>
///<param name="decryptString">待解密的字符串</param>
/
//<param name="decryptKey">解密密钥，和加密密钥相同</param>
///<returns>解密成功返回解密后的字符串，失败返回空</returns>
public static string AES_Decrypt(string decryptString, string decryptKey)
{
try
{
decryptKey = GetSubString(decryptKey, 32, "");
decryptKey = decryptKey.PadRight(32, '');
RijndaelManaged rijndaelProvider = new RijndaelManaged();
rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
字符串长度为0
rijndaelProvider.IV = Keys;
ICryptoTransform rijndaelDecrypt = rijndaelProvider.CreateDecryptor();
byte[] inputData = Convert.FromBase64String(decryptString);
byte[] decryptedData = rijndaelDecrypt.TransformFinalBlock(inputData, 0, inputData.Length);
return Encoding.UTF8.GetString(decryptedData);
}
catch
{
return string.Empty;
}
}
///<summary>
/
//按字节长度(按字节,⼀个汉字为2个字节)取得某字符串的⼀部分
///</summary>
///<param name="sourceString">源字符串</param>
///<param name="length">所取字符串字节长度</param>
///<param name="tailString">附加字符串(当字符串不够长时，尾部所添加的字符串，⼀般为"...")</param> ///<returns>某字符串的⼀部分</returns>
private static string GetSubString(string sourceString, int length, string tailString)
{
return GetSubString(sourceString, 0, length, tailString);
}
///<summary>
///按字节长度(按字节,⼀个汉字为2个字节)取得某字符串的⼀部分
///</summary>
///<param name="sourceString">源字符串</param>
///<param name="startIndex">索引位置，以0开始</param>
///<param name="length">所取字符串字节长度</param>
///<param name="tailString">附加字符串(当字符串不够长时，尾部所添加的字符串，⼀般为"...")</param>
///<returns>某字符串的⼀部分</returns>
private static string GetSubString(string sourceString, int startIndex, int length, string tailString)
{
string myResult = sourceString;
//当是⽇⽂或韩⽂时(注：中⽂的范围:\u4e00 - \u9fa5, ⽇⽂在\u0800 - \u4e00, 韩⽂为\xAC00-\xD7A3)
if (System.Text.RegularExpressions.Regex.IsMatch(sourceString, "[\u0800-\u4e00]+") ||
System.Text.RegularExpressions.Regex.IsMatch(sourceString, "[\xAC00-\xD7A3]+"))
{
//当截取的起始位置超出字段串长度时
if (startIndex >= sourceString.Length)
{
return string.Empty;
}
else
{
return sourceString.Substring(startIndex,
((length + startIndex) > sourceString.Length) ? (sourceString.Length - startIndex) : length);                }
}
//中⽂字符，如"中国⼈民abcd123"
if (length <= 0)
{
return string.Empty;
}
byte[] bytesSource = Encoding.Default.GetBytes(sourceString);
//当字符串长度⼤于起始位置
if (bytesSource.Length > startIndex)
{
int endIndex = bytesSource.Length;
/
/当要截取的长度在字符串的有效长度范围内
if (bytesSource.Length > (startIndex + length))
{
endIndex = length + startIndex;
}
else
{  //当不在有效范围内时，只取到字符串的结尾
length = bytesSource.Length - startIndex;
tailString = "";
}
int[] anResultFlag = new int[length];
int nFlag = 0;
//字节⼤于127为双字节字符
for (int i = startIndex; i < endIndex; i++)
{
if (bytesSource[i] > 127)
{
nFlag++;
if (nFlag == 3)
{
nFlag = 1;
}
}
else
{
nFlag = 0;
}
anResultFlag[i] = nFlag;
}
//最后⼀个字节为双字节字符的⼀半
if ((bytesSource[endIndex - 1] > 127) && (anResultFlag[length - 1] == 1))
{
length = length + 1;
}
byte[] bsResult = new byte[length];
Array.Copy(bytesSource, startIndex, bsResult, 0, length);
myResult = Encoding.Default.GetString(bsResult);
myResult = myResult + tailString;
return myResult;
}
return string.Empty;
}
///<summary>
///加密⽂件流
/
//</summary>
///<param name="fs"></param>
///<returns></returns>
public static CryptoStream AES_EncryptStrream(FileStream fs, string decryptKey)
{
decryptKey = GetSubString(decryptKey, 32, "");
decryptKey = decryptKey.PadRight(32, '');
RijndaelManaged rijndaelProvider = new RijndaelManaged();
rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
rijndaelProvider.IV = Keys;
ICryptoTransform encrypto = rijndaelProvider.CreateEncryptor();
CryptoStream cytptostreamEncr = new CryptoStream(fs, encrypto, CryptoStreamMode.Write);
return cytptostreamEncr;
}
///<summary>
///解密⽂件流
///</summary>
///<param name="fs"></param>
///<returns></returns>
public static CryptoStream AES_DecryptStream(FileStream fs, string decryptKey)
{
decryptKey = GetSubString(decryptKey, 32, "");
decryptKey = decryptKey.PadRight(32, '');
RijndaelManaged rijndaelProvider = new RijndaelManaged();
rijndaelProvider.Key = Encoding.UTF8.GetBytes(decryptKey);
rijndaelProvider.IV = Keys;
ICryptoTransform Decrypto = rijndaelProvider.CreateDecryptor();
CryptoStream cytptostreamDecr = new CryptoStream(fs, Decrypto, CryptoStreamMode.Read);
return cytptostreamDecr;
}
///<summary>
///对指定⽂件加密
///</summary>
/
//<param name="InputFile"></param>
///<param name="OutputFile"></param>
///<returns></returns>
public static bool AES_EncryptFile(string InputFile, string OutputFile)
{
try
{
string decryptKey = "www.iqidi";
FileStream fr = new FileStream(InputFile, FileMode.Open);
FileStream fren = new FileStream(OutputFile, FileMode.Create);
CryptoStream Enfr = AES_EncryptStrream(fren, decryptKey);
byte[] bytearrayinput = new byte[fr.Length];
fr.Read(bytearrayinput, 0, bytearrayinput.Length);
Enfr.Write(bytearrayinput, 0, bytearrayinput.Length);
Enfr.Close();
fr.Close();
fren.Close();
}
catch
{
//⽂件异常
return false;
}
return true;
}
///<summary>
///对指定的⽂件解压缩
///</summary>
///<param name="InputFile"></param>
///<param name="OutputFile"></param>
///<returns></returns>
public static bool AES_DecryptFile(string InputFile, string OutputFile)
{

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。