自已封装了一个极其易用的加密解密类，支持DES、三重DES、Rijndael、RC2、MD5、以及非对称加密算法RSA
2007-03-09 17:30
513 查看
虽然网上C#的加密类有很多，但功能参差不齐，有的用起来很麻烦，所以自已封装了一个极其易用的加密解密类，支持DES、三重DES、Rijndael、RC2、MD5、以及非对称加密算法RSA。每种加密算法提供三次重载的加解密函数。对字符串加解密，对字符数组加解密和对文件加解密。希望对大家有帮助，提供源程序下载：点此下载点此下载
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace ZYBEncrypt
{
/**//// <summary>
/// Rijndael
/// </summary>
public class Rijndael_
{
private RijndaelManaged myRijndael;
public string Key;
public string IV;
/**//// <summary>
/// 对称加密类的构造函数
/// </summary>
public Rijndael_(string key)
{
myRijndael = new RijndaelManaged();
Key = key;
IV="67^%*(&(*Ghg7!rNIfb&95GUY86GfghUb#er57HBh(u%g6HJ($jhWk7&!hg4ui%$hjk";
}
/**//// <summary>
/// 对称加密类的构造函数
/// </summary>
public Rijndael_(string key, string iv)
{
myRijndael = new RijndaelManaged();
Key = key;
IV = iv;
}
/**//// <summary>
/// 获得密钥
/// </summary>
/// <returns>密钥</returns>
private byte[] GetLegalKey()
{
string sTemp = Key;
myRijndael.GenerateKey();
byte[] bytTemp = myRijndael.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/**//// <summary>
/// 获得初始向量IV
/// </summary>
/// <returns>初试向量IV</returns>
private byte[] GetLegalIV()
{
string sTemp = IV;
myRijndael.GenerateIV();
byte[] bytTemp = myRijndael.IV;
int IVLength = bytTemp.Length;
if (sTemp.Length > IVLength)
sTemp = sTemp.Substring(0, IVLength);
else if (sTemp.Length < IVLength)
sTemp = sTemp.PadRight(IVLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/**//// <summary>
/// 加密方法
/// </summary>
/// <param name="Source">待加密的串</param>
/// <returns>经过加密的串</returns>
public string Encrypt(string Source)
{
try
{
byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
MemoryStream ms = new MemoryStream();
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return Convert.ToBase64String(bytOut);
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法
/// </summary>
/// <param name="Source">待解密的串</param>
/// <returns>经过解密的串</returns>
public string Decrypt(string Source)
{
try
{
byte[] bytIn = Convert.FromBase64String(Source);
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return sr.ReadToEnd();
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 加密方法byte[] to byte[]
/// </summary>
/// <param name="Source">待加密的byte数组</param>
/// <returns>经过加密的byte数组</returns>
public byte[] Encrypt(byte[] Source)
{
try
{
byte[] bytIn = Source;
MemoryStream ms = new MemoryStream();
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return bytOut;
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法byte[] to byte[]
/// </summary>
/// <param name="Source">待解密的byte数组</param>
/// <returns>经过解密的byte数组</returns>
public byte[] Decrypt(byte[] Source)
{
try
{
byte[] bytIn = Source;
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return UTF8Encoding.UTF8.GetBytes(sr.ReadToEnd());
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 加密方法File to File
/// </summary>
/// <param name="inFileName">待加密文件的路径</param>
/// <param name="outFileName">待加密后文件的输出路径</param>
public void Encrypt(string inFileName, string outFileName)
{
try
{
//byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
//MemoryStream ms = new MemoryStream();
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
byte[] bin = new byte[100];
long rdlen = 0;
long totlen = fin.Length;
int len;
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(fout, encrypto, CryptoStreamMode.Write);
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
cs.Write(bin, 0, len);
rdlen = rdlen + len;
}
cs.Close();
fout.Close();
fin.Close();
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法File to File
/// </summary>
/// <param name="inFileName">待解密文件的路径</param>
/// <param name="outFileName">待解密后文件的输出路径</param>
public void Decrypt(string inFileName, string outFileName)
{
try
{
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[100];
long rdlen = 0;
long totlen = fin.Length;
int len;
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(fout, encrypto, CryptoStreamMode.Write);
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
cs.Write(bin, 0, len);
rdlen = rdlen + len;
}
cs.Close();
fout.Close();
fin.Close();
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace ZYBEncrypt
{
/**//// <summary>
/// 非对称RSA
/// </summary>
class RSA_
{
private RSACryptoServiceProvider rsa;
public RSA_()
{
rsa = new RSACryptoServiceProvider();
}
/**//// <summary>
/// 得到公钥
/// </summary>
/// <returns></returns>
public string GetPublicKey()
{
return rsa.ToXmlString(false);
}
/**//// <summary>
/// 得到私钥
/// </summary>
/// <returns></returns>
public string GetPrivateKey()
{
return rsa.ToXmlString(true);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="Source">待加密字符串</param>
/// <param name="PublicKey">公钥</param>
/// <returns></returns>
public string Encrypt(string Source, string PublicKey)
{
rsa.FromXmlString(PublicKey);
byte[] done= rsa.Encrypt(Convert.FromBase64String(Source), false);
return Convert.ToBase64String(done);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="Source">待加密字符数组</param>
/// <param name="PublicKey">公钥</param>
/// <returns></returns>
public byte[] Encrypt(byte[] Source, string PublicKey)
{
rsa.FromXmlString(PublicKey);
return rsa.Encrypt(Source, false);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="inFileName">待加密文件路径</param>
/// <param name="outFileName">加密后文件路径</param>
/// <param name="PublicKey">公钥</param>
public void Encrypt(string inFileName, string outFileName, string PublicKey)
{
rsa.FromXmlString(PublicKey);
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[1000];
long rdlen = 0;
long totlen = fin.Length;
int len;
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 1000);
byte[] bout=rsa.Encrypt(bin,false);
fout.Write(bout, 0, bout.Length);
rdlen = rdlen + len;
}
fout.Close();
fin.Close();
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="Source">待解密字符串</param>
/// <param name="PrivateKey">私钥</param>
/// <returns></returns>
public string Decrypt(string Source, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
byte[] done = rsa.Decrypt(Convert.FromBase64String(Source), false);
return Convert.ToBase64String(done);
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="Source">待解密字符数组</param>
/// <param name="PrivateKey">私钥</param>
/// <returns></returns>
public byte[] Decrypt(byte[] Source, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
return rsa.Decrypt(Source, false);
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="inFileName">待解密文件路径</param>
/// <param name="outFileName">解密后文件路径</param>
/// <param name="PrivateKey">私钥</param>
public void Decrypt(string inFileName, string outFileName, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[1000];
long rdlen = 0;
long totlen = fin.Length;
int len;
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 1000);
byte[] bout = rsa.Decrypt(bin, false);
fout.Write(bout, 0, bout.Length);
rdlen = rdlen + len;
}
fout.Close();
fin.Close();
}
}
}
using System;
using System.IO;
using System.Security.Cryptography;
using System.Text;
namespace ZYBEncrypt
{
/**//// <summary>
/// Rijndael
/// </summary>
public class Rijndael_
{
private RijndaelManaged myRijndael;
public string Key;
public string IV;
/**//// <summary>
/// 对称加密类的构造函数
/// </summary>
public Rijndael_(string key)
{
myRijndael = new RijndaelManaged();
Key = key;
IV="67^%*(&(*Ghg7!rNIfb&95GUY86GfghUb#er57HBh(u%g6HJ($jhWk7&!hg4ui%$hjk";
}
/**//// <summary>
/// 对称加密类的构造函数
/// </summary>
public Rijndael_(string key, string iv)
{
myRijndael = new RijndaelManaged();
Key = key;
IV = iv;
}
/**//// <summary>
/// 获得密钥
/// </summary>
/// <returns>密钥</returns>
private byte[] GetLegalKey()
{
string sTemp = Key;
myRijndael.GenerateKey();
byte[] bytTemp = myRijndael.Key;
int KeyLength = bytTemp.Length;
if (sTemp.Length > KeyLength)
sTemp = sTemp.Substring(0, KeyLength);
else if (sTemp.Length < KeyLength)
sTemp = sTemp.PadRight(KeyLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/**//// <summary>
/// 获得初始向量IV
/// </summary>
/// <returns>初试向量IV</returns>
private byte[] GetLegalIV()
{
string sTemp = IV;
myRijndael.GenerateIV();
byte[] bytTemp = myRijndael.IV;
int IVLength = bytTemp.Length;
if (sTemp.Length > IVLength)
sTemp = sTemp.Substring(0, IVLength);
else if (sTemp.Length < IVLength)
sTemp = sTemp.PadRight(IVLength, ' ');
return ASCIIEncoding.ASCII.GetBytes(sTemp);
}
/**//// <summary>
/// 加密方法
/// </summary>
/// <param name="Source">待加密的串</param>
/// <returns>经过加密的串</returns>
public string Encrypt(string Source)
{
try
{
byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
MemoryStream ms = new MemoryStream();
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return Convert.ToBase64String(bytOut);
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法
/// </summary>
/// <param name="Source">待解密的串</param>
/// <returns>经过解密的串</returns>
public string Decrypt(string Source)
{
try
{
byte[] bytIn = Convert.FromBase64String(Source);
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return sr.ReadToEnd();
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 加密方法byte[] to byte[]
/// </summary>
/// <param name="Source">待加密的byte数组</param>
/// <returns>经过加密的byte数组</returns>
public byte[] Encrypt(byte[] Source)
{
try
{
byte[] bytIn = Source;
MemoryStream ms = new MemoryStream();
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Write);
cs.Write(bytIn, 0, bytIn.Length);
cs.FlushFinalBlock();
ms.Close();
byte[] bytOut = ms.ToArray();
return bytOut;
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法byte[] to byte[]
/// </summary>
/// <param name="Source">待解密的byte数组</param>
/// <returns>经过解密的byte数组</returns>
public byte[] Decrypt(byte[] Source)
{
try
{
byte[] bytIn = Source;
MemoryStream ms = new MemoryStream(bytIn, 0, bytIn.Length);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(ms, encrypto, CryptoStreamMode.Read);
StreamReader sr = new StreamReader(cs);
return UTF8Encoding.UTF8.GetBytes(sr.ReadToEnd());
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 加密方法File to File
/// </summary>
/// <param name="inFileName">待加密文件的路径</param>
/// <param name="outFileName">待加密后文件的输出路径</param>
public void Encrypt(string inFileName, string outFileName)
{
try
{
//byte[] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
//MemoryStream ms = new MemoryStream();
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
byte[] bin = new byte[100];
long rdlen = 0;
long totlen = fin.Length;
int len;
ICryptoTransform encrypto = myRijndael.CreateEncryptor();
CryptoStream cs = new CryptoStream(fout, encrypto, CryptoStreamMode.Write);
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
cs.Write(bin, 0, len);
rdlen = rdlen + len;
}
cs.Close();
fout.Close();
fin.Close();
}
catch (Exception ex)
{
throw new Exception("在文件加密的时候出现错误！错误提示： /n" + ex.Message);
}
}
/**//// <summary>
/// 解密方法File to File
/// </summary>
/// <param name="inFileName">待解密文件的路径</param>
/// <param name="outFileName">待解密后文件的输出路径</param>
public void Decrypt(string inFileName, string outFileName)
{
try
{
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[100];
long rdlen = 0;
long totlen = fin.Length;
int len;
myRijndael.Key = GetLegalKey();
myRijndael.IV = GetLegalIV();
ICryptoTransform encrypto = myRijndael.CreateDecryptor();
CryptoStream cs = new CryptoStream(fout, encrypto, CryptoStreamMode.Write);
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 100);
cs.Write(bin, 0, len);
rdlen = rdlen + len;
}
cs.Close();
fout.Close();
fin.Close();
}
catch (Exception ex)
{
throw new Exception("在文件解密的时候出现错误！错误提示： /n" + ex.Message);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;
namespace ZYBEncrypt
{
/**//// <summary>
/// 非对称RSA
/// </summary>
class RSA_
{
private RSACryptoServiceProvider rsa;
public RSA_()
{
rsa = new RSACryptoServiceProvider();
}
/**//// <summary>
/// 得到公钥
/// </summary>
/// <returns></returns>
public string GetPublicKey()
{
return rsa.ToXmlString(false);
}
/**//// <summary>
/// 得到私钥
/// </summary>
/// <returns></returns>
public string GetPrivateKey()
{
return rsa.ToXmlString(true);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="Source">待加密字符串</param>
/// <param name="PublicKey">公钥</param>
/// <returns></returns>
public string Encrypt(string Source, string PublicKey)
{
rsa.FromXmlString(PublicKey);
byte[] done= rsa.Encrypt(Convert.FromBase64String(Source), false);
return Convert.ToBase64String(done);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="Source">待加密字符数组</param>
/// <param name="PublicKey">公钥</param>
/// <returns></returns>
public byte[] Encrypt(byte[] Source, string PublicKey)
{
rsa.FromXmlString(PublicKey);
return rsa.Encrypt(Source, false);
}
/**//// <summary>
/// 加密
/// </summary>
/// <param name="inFileName">待加密文件路径</param>
/// <param name="outFileName">加密后文件路径</param>
/// <param name="PublicKey">公钥</param>
public void Encrypt(string inFileName, string outFileName, string PublicKey)
{
rsa.FromXmlString(PublicKey);
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[1000];
long rdlen = 0;
long totlen = fin.Length;
int len;
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 1000);
byte[] bout=rsa.Encrypt(bin,false);
fout.Write(bout, 0, bout.Length);
rdlen = rdlen + len;
}
fout.Close();
fin.Close();
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="Source">待解密字符串</param>
/// <param name="PrivateKey">私钥</param>
/// <returns></returns>
public string Decrypt(string Source, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
byte[] done = rsa.Decrypt(Convert.FromBase64String(Source), false);
return Convert.ToBase64String(done);
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="Source">待解密字符数组</param>
/// <param name="PrivateKey">私钥</param>
/// <returns></returns>
public byte[] Decrypt(byte[] Source, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
return rsa.Decrypt(Source, false);
}
/**//// <summary>
/// 解密
/// </summary>
/// <param name="inFileName">待解密文件路径</param>
/// <param name="outFileName">解密后文件路径</param>
/// <param name="PrivateKey">私钥</param>
public void Decrypt(string inFileName, string outFileName, string PrivateKey)
{
rsa.FromXmlString(PrivateKey);
FileStream fin = new FileStream(inFileName, FileMode.Open, FileAccess.Read);
FileStream fout = new FileStream(outFileName, FileMode.OpenOrCreate, FileAccess.Write);
fout.SetLength(0);
byte[] bin = new byte[1000];
long rdlen = 0;
long totlen = fin.Length;
int len;
while (rdlen < totlen)
{
len = fin.Read(bin, 0, 1000);
byte[] bout = rsa.Decrypt(bin, false);
fout.Write(bout, 0, bout.Length);
rdlen = rdlen + len;
}
fout.Close();
fin.Close();
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 自已封装了一个极其易用的加密解密类，支持DES、三重DES、Rijndael、RC2、MD5、以及非对称加密算法RSA
- 自已封装了一个极其易用的加密解密类，支持DES、三重DES、Rijndael、RC2、MD5、以及非对称加密算法RSA
- RSA,DES,MD5,RC2,加密解密类
- 网上的MD5、DES、RC2、Rijndael加密解密算法
- C#一个封装的加密解密类
- C#一个封装的加密解密类
- C#封装加密算法（MD5、SHA、HMAC、DES、RSA）的一个类
- 配置开发库FMDB支持加密、***.xcconfig的用法以及提供一个免费的数据库管理app
- C#一个封装的加密解密类
- DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1通用的安全密码类
- 一个加密解密的小工具及源码（MD5, DES, RSA）
- DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1通用的安全密码类
- DES 加密的一个封装类
- 一个C#封装的加密解密类代码
- C#一个封装的加密解密类
- DES,RC2,Rijndael, TripleDes,RSA, MD5, SHA1通用的安全密码类
- 自己封装的一个iphone上的缓存，支持内存缓存以及磁盘缓存，实际项目已经应用。
- C#一个封装的加密解密类
- 整理封装的加密解密类,使用DES
- C#一个封装的加密解密类