#region --System.Security.Cryptography--
//mscorlib --> System.Security.Cryptography
//散列算法
//HashAlgorithm
// |-------MD5
// | |----------MD5CryptoServiceProvider
// |
// |-------SHA1
// | |----------SHA1Managed(SHA1CryptoServiceProvider)
// |
// |-------SHA256
// | |----------SHA256Managed
// |
// |-------SHA384
// | |----------SHA384Managed
// |
// |-------SHA512
// | |----------SHA512Managed
// |
// |-------RIPEMD160
// | |----------RIPEMD160Managed
// |
// |-------KeyedHashAlgorithm
// |----------HMAC
// | |----------------HMACMD5
// | |----------------HMACSHA1
// | |----------------HMACSHA256
// | |----------------HMACSHA384
// | |----------------HMACSHA512
// | |----------------HMACRIPEMD160
// |
// |----------MACTripleDES
//对称加密算法
//SymmetricAlgorithm
// |-------DES
// | |-----------DESCryptoServiceProvider
// |
// |-------Rijndael
// | |-----------RijndaelManaged
// |
// |-------RC2
// | |-----------RC2CryptoServiceProvider
// |
// |-------TripleDES
// |-----------TripleDESCryptoServiceProvider
//非对称加密算法
//AsymmetricAlgorithm
// |-------RSA
// | |-----------RSACryptoServiceProvider
// |
// |-------DSA
// |-----------DSACryptoServiceProvider
//AsymmetricKeyExchangeFormatter
// |-------RSAOAEPKeyExchangeFormatter
// |-------RSAPKCSIKeyExchangeFormatter
//AsymmetricKeyExchangeDeformatter
// |-------RSAOAEPKeyExchangeDeformatter
// |-------RSAPKCSIKeyExchangeDeformatter
//AsymmetricSignatureFormatter
// |-------RSAPKCSISignatureFormatter
// |-------DSASignatureFormatter
AsymmetricSignatureDeformatter
// |-------RSAPKCSISignatureDeformatter
// |-------DSASignatureDeformatter
#endregion
/// <summary>
/// 加 解 密的对象
/// </summary>
public class EncryptModel
{
/// <summary>
/// 暂时只根据key,iv进行设置
/// </summary>
/// <param name="key"></param>
/// <param name="iv"></param>
public EncryptModel(string key, string iv)
{
this._key = key;
this._iv = iv;
}
/// <summary>
/// 密钥
/// </summary>
private string _key = string.Empty;
/// <summary>
/// 向量
/// </summary>
private string _iv = string.Empty;
/// <summary>
/// 密钥长度
/// </summary>
private int _keySize = 8;
/// <summary>
/// 获取或设置加密操作的块大小(以位为单位)
/// </summary>
private int _blockSize = 8;
/// <summary>
/// 获取或设置加密操作的反馈大小(以位为单位)。
/// </summary>
private int _feedbackSize = 0;
/// <summary>
/// 获取或设置对称算法的运算模式。CipherMode.CBC
/// </summary>
private CipherMode _cryptMode;
/// <summary>
/// 获取或设置对称算法中使用的填充模式。PaddingMode.ANSIX923
/// </summary>
private PaddingMode _cryptPadding;
/// <summary>
/// 加密密钥(8個英文字)
/// </summary>
public string Key
{
get { return _key; }
set { _key = value.Length == 8 ? value : "AndyCode"; }//暂时定义为8
}
/// <summary>
/// 初始化向量(8個英文字)
/// </summary>
public string Iv
{
get { return _iv; }
set { _iv = value.Length == 8 ? value : "HeXiaoEr"; }//暂时定义为8
}
/// <summary>
/// 密钥长度
/// </summary>
public int KeyLength
{
get { return _keySize; }
set { _keySize = value; }
}
/// <summary>
/// 获取或设置加密操作的块大小(以位为单位)
/// </summary>
public int BlockSize
{
get { return _blockSize; }
set { _blockSize = value; }
}
/// <summary>
/// 获取或设置加密操作的反馈大小(以位为单位)。
/// </summary>
public int FeedbackSize
{
get { return _feedbackSize; }
set { _feedbackSize = value; }
}
/// <summary>
/// 获取或设置对称算法的运算模式。CipherMode.CBC
/// </summary>
public CipherMode CryptMode
{
get { return _cryptMode; }
set { _cryptMode = value; }
}
/// <summary>
/// 获取或设置对称算法中使用的填充模式。PaddingMode.ANSIX923
/// </summary>
public PaddingMode CryptPadding
{
get { return _cryptPadding; }
set { _cryptPadding = value; }
}
}
/// <summary>
/// 加密解密算法基类
/// </summary>
public abstract class EncryptDecrypt
{
public abstract string Encrypt(string encryptStr, EncryptModel encryptModel);
public abstract string Decrypt(string decryptStr, EncryptModel decryptModel);
}
#region -- 对称加密 --
//在对称加密算法中,数据发信方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。//收信方收到密文后,若想解读原文,则需要使用加密用过的密钥及相同算法的逆算法对密文进行解密,才能使其恢复成可读明文。
//BlockSize 获取或设置加密操作的块大小(以位为单位)。
//FeedbackSize 获取或设置加密操作的反馈大小(以位为单位)。
//IV 获取或设置对称算法的初始化向量 (IV)。
//Key 已重写。获取或设置数据加密标准 (DES) 算法的机密密钥。
//KeySize 获取或设置对称算法使用的机密密钥的大小(以位为单位)。
//Mode 获取或设置对称算法的运算模式。
//Padding 获取或设置对称算法中使用的填充模式。
//LegalBlockSizes 获取对称算法支持的块大小。
//LegalKeySizes 获取对称算法支持的密钥大小。
//Clear() 释放由 SymmetricAlgorithm 占用的所有资源。
//CreateDecryptor() 已重载。已重写。创建对称数据加密标准 (DES) 解密器对象。
//CreateEncryptor() 已重载。已重写。创建对称数据加密标准 (DES) 加密器对象。
//GenerateIV() 已重写。生成用于该算法的随机初始化向量(IV)。
//GenerateKey() 已重写。生成用于该算法的随机 Key。
//ValidKeySize() 确定指定的密钥大小对当前算法是否有效。
/// <summary>
/// Des加密解密 8字节的key,初始向量IV也是8字节。
/// </summary>
public class DesEncryptDecrypt : EncryptDecrypt
{
/// <summary>
/// 加密
/// </summary>
/// <param name="encryptStr"></param>
/// <param name="encryptModel"></param>
/// <returns></returns>
public override string Encrypt(string encryptStr, EncryptModel encryptModel)
{
string temp = string.Empty;
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())//DES算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
//设定对称算法的加密密钥(长度为64位,也就是8个字节)
des.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
des.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
}
temp = Convert.ToBase64String(ms.ToArray());
}
}
return temp;
}
/// <summary>
/// 解密
/// </summary>
/// <param name="decryptStr"></param>
/// <param name="decryptModel"></param>
/// <returns></returns>
public override string Decrypt(string decryptStr, EncryptModel decryptModel)
{
using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())//DES算法的加密类
{
byte[] inputByteArray = new byte[decryptStr.Length / 2];
//反转
for (int x = 0; x < decryptStr.Length / 2; x++)
{
int i = (Convert.ToInt32(decryptStr.Substring(x * 2, 2), 16));
inputByteArray[x] = (byte)i;
}
//解密密钥必须是加密时候的密钥
des.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
//解密向量必须是加密时候的向量
des.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Read))
{
try
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return System.Text.Encoding.Default.GetString(ms.ToArray());
}
catch
{
return "N/A";
}
}
}
}
}
}
/// <summary>
/// RC2加密解密 any个字节key,初始向量IV也是8字节。
/// </summary>
public class Rc2EncryptDecrypt : EncryptDecrypt
{
/// <summary>
/// 加密
/// </summary>
/// <param name="encryptStr"></param>
/// <param name="encryptModel"></param>
/// <returns></returns>
public override string Encrypt(string encryptStr, EncryptModel encryptModel)
{
string temp = string.Empty;
using (RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider())//RC2算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
//设定对称算法的加密密钥
rc2.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
rc2.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, rc2.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
}
temp = Convert.ToBase64String(ms.ToArray());
}
}
return temp;
}
/// <summary>
/// 解密
/// </summary>
/// <param name="decryptStr"></param>
/// <param name="decryptModel"></param>
/// <returns></returns>
public override string Decrypt(string decryptStr, EncryptModel decryptModel)
{
using (RC2CryptoServiceProvider rc2 = new RC2CryptoServiceProvider())//RC2算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
//设定对称算法的加密密钥 密钥必须为5-16位
rc2.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
rc2.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, rc2.CreateDecryptor(), CryptoStreamMode.Read))
{
try
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Encoding.Default.GetString(ms.ToArray());
}
catch
{
return "N/A";
}
}
}
}
}
}
/// <summary>
/// Rijndael加密解密 16,24或42字节的key,初始向量IV也是8字节。 AES
/// </summary>
public class RijndaelEncryptDecrypt : EncryptDecrypt
{
/// <summary>
/// 加密
/// </summary>
/// <param name="encryptStr"></param>
/// <param name="encryptModel"></param>
/// <returns></returns>
public override string Encrypt(string encryptStr, EncryptModel encryptModel)
{
string temp = string.Empty;
using (RijndaelManaged rijndael = new RijndaelManaged())//RC2算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
//设定对称算法的加密密钥
rijndael.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
rijndael.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, rijndael.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
}
temp = Convert.ToBase64String(ms.ToArray());
}
}
return temp;
}
/// <summary>
/// 解密
/// </summary>
/// <param name="decryptStr"></param>
/// <param name="decryptModel"></param>
/// <returns></returns>
public override string Decrypt(string decryptStr, EncryptModel decryptModel)
{
using (RijndaelManaged rijndael = new RijndaelManaged())//Rijndael算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
//设定对称算法的加密密钥 密钥必须为5-16位
rijndael.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
rijndael.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, rijndael.CreateDecryptor(), CryptoStreamMode.Read))
{
try
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Encoding.Default.GetString(ms.ToArray());
}
catch
{
return "N/A";
}
}
}
}
}
}
/// <summary>
/// TripleDes加密解密 16或24字节的key,初始向量IV也是8字节。
/// </summary>
public class TripleDesEncryptDecrypt : EncryptDecrypt
{
/// <summary>
/// 加密
/// </summary>
/// <param name="encryptStr"></param>
/// <param name="encryptModel"></param>
/// <returns></returns>
public override string Encrypt(string encryptStr, EncryptModel encryptModel)
{
string temp = string.Empty;
using (TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider())//RC2算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(encryptStr);
//设定对称算法的加密密钥
tripleDES.Key = ASCIIEncoding.ASCII.GetBytes(encryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
tripleDES.IV = ASCIIEncoding.ASCII.GetBytes(encryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, tripleDES.CreateEncryptor(), CryptoStreamMode.Write))
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
}
temp = Convert.ToBase64String(ms.ToArray());
}
}
return temp;
}
/// <summary>
/// 解密
/// </summary>
/// <param name="decryptStr"></param>
/// <param name="decryptModel"></param>
/// <returns></returns>
public override string Decrypt(string decryptStr, EncryptModel decryptModel)
{
using (TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider())//TripleDES算法的加密类
{
//将字符串转换为byte
byte[] inputByteArray = Encoding.Default.GetBytes(decryptStr);
//设定对称算法的加密密钥 密钥必须为5-16位
tripleDES.Key = ASCIIEncoding.ASCII.GetBytes(decryptModel.Key);
//设定对称算法的初始化向量(长度为64位,也就是8个字节)
tripleDES.IV = ASCIIEncoding.ASCII.GetBytes(decryptModel.Iv);
using (MemoryStream ms = new MemoryStream())//辅助的内存流对象
{
using (CryptoStream cs = new CryptoStream(ms, tripleDES.CreateDecryptor(), CryptoStreamMode.Read))
{
try
{
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return Encoding.Default.GetString(ms.ToArray());
}
catch
{
return "N/A";
}
}
}
}
}
}
#endregion