C#中的加密技术

在.net中已经集成了几种对称加密算法的类，用他们可以很快构建自己的加密程序

.net中用来加密的类

DESCryptoServiceProvider

RC2CryptoServiceProvider

RijndaelManaged

TripleDESCryptoServiceProvider

以下是我用其构建的一个加密程序

注意每种加密算法 对密钥和初始向量的长度要求不一样

1、加密类库

using System;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 /// 解密转换
 /// </summary>
 public class DecryptTransformer
 {
  internal DecryptTransformer(EncryptionAlgorithm deCryptId)
  {
   algorithmID=deCryptId;
  }
  private EncryptionAlgorithm algorithmID;
  private byte[] initVec;

  internal byte[] IV
  {
   set
   {
    this.initVec=value;
   }
  }
  
        /// <summary>
        /// 定义基本的加密转换运算
        /// </summary>
        /// <param name="bytesKey">密钥</param>
        /// <returns></returns>
  internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
  {
   switch(algorithmID)
   {
    case EncryptionAlgorithm.Des:
    {
     DES des=new DESCryptoServiceProvider();
     des.Mode=CipherMode.CBC;
     des.Key=bytesKey;
     des.IV=initVec;
     return des.CreateDecryptor();
    }
    case EncryptionAlgorithm.TripleDes:
    {
     TripleDES des3=new TripleDESCryptoServiceProvider();
     des3.Mode=CipherMode.CBC;
     //返回对称解密器
     return des3.CreateDecryptor(bytesKey,initVec);
    }
    case EncryptionAlgorithm.Rc2:
    {
     RC2 rc2=new RC2CryptoServiceProvider();
     rc2.Mode=CipherMode.CBC;
     return rc2.CreateDecryptor(bytesKey,initVec);
    }
    case EncryptionAlgorithm.Rijndael:
    {
     Rijndael rijndael=new RijndaelManaged();
     rijndael.Mode=CipherMode.CBC;
     return rijndael.CreateDecryptor(bytesKey,initVec);
    }
    default:
    {
     throw new CryptographicException("Algorithm ID '"+algorithmID+"'not supported");
    }

   }
  }
 }
}

using System;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 /// 一个枚举
 /// </summary>
 public enum EncryptionAlgorithm {Des=1,Rc2,Rijndael,TripleDes};
 /// <summary>
 /// 设置加密算法
 /// </summary>
 internal class EncryptTransformer
 {
  public EncryptTransformer(EncryptionAlgorithm algId)
  {
   algorithmID=algId;
  }
  private EncryptionAlgorithm algorithmID;
  private byte[] initVec;
  private byte[] encKey;

  internal byte[] IV
  {
   get
   {
    return this.initVec;
   }
   set
   {
    this.initVec=value;
   }
  }
  internal byte[] Key
  {
   get
   {
    return this.encKey;
   }   
  }
        /// <summary>
        /// 创建一个加密器(加密转换)
        /// </summary>
        /// <param name="bytesKey">密钥</param>
        /// <returns></returns>
  internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)
  {
   //以下根据线则的不同加密算法生成加密器
   switch(algorithmID)
   {
    case EncryptionAlgorithm.Des:
    {
     DES des=new DESCryptoServiceProvider();
     des.Mode=CipherMode.CBC;
     //以下设置DES算法的密钥
     if(null==bytesKey)
     {
      encKey=des.Key;
     }
     else
     {
      des.Key=bytesKey;
      encKey=des.Key;
     }
     //以下设置初始化向量
     if(null==initVec)
     {
      initVec=des.IV;
     }
     else
     {
      des.IV=initVec;
     }
     //返回一个加密器
     return des.CreateEncryptor();
    }
    case EncryptionAlgorithm.TripleDes:
    {
     TripleDES des3=new TripleDESCryptoServiceProvider();
     des3.Mode=CipherMode.CBC;
     //设置密钥
     if(null==bytesKey)
     {
      encKey=des3.Key;
     }
     else
     {
      des3.Key=bytesKey;
      this.encKey=des3.Key;
     }
     //设置初始化向量
     if(null==initVec)
     {
      initVec=des3.IV;
     }
     else
     {
      des3.IV=initVec;
     }
     //返回加密器
     return des3.CreateEncryptor();
    }
    case EncryptionAlgorithm.Rc2:
    {
     //初始化加密服务
     RC2 rc2=new RC2CryptoServiceProvider();
     rc2.Mode=CipherMode.CBC;
     //设置密钥
     if(null==bytesKey)
     {
      encKey=rc2.Key;
     }
     else
     {
      rc2.Key=bytesKey;
      this.encKey=rc2.Key;
     }
     //设置初始化向量
     if(null==initVec)
     {
      initVec=rc2.IV;
     }
     else
     {
      rc2.IV=initVec;
     }
     //返回加密器
     return rc2.CreateEncryptor();
    }
    case EncryptionAlgorithm.Rijndael:
    {
     Rijndael rijndael=new RijndaelManaged();
     rijndael.Mode=CipherMode.CBC;
     //设置密钥
     if(null==bytesKey)
     {
      encKey=rijndael.Key;
     }
     else
     {
      rijndael.Key=bytesKey;
      this.encKey=rijndael.Key;
     }
     //设置初始化向量
     if(null==initVec)
     {
      initVec=rijndael.IV;
     }
     else
     {
      rijndael.IV=initVec;
     }
     //返回加密器
     return rijndael.CreateEncryptor();
    }
    default:
    {
     throw new CryptographicException("Algorithm ID '"+algorithmID+"' not supported.");
    }
   }
  }
 }
}

using System;
using System.IO;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 ///用来解密数据
 /// </summary>
 public class Decryptor
 {
  public Decryptor(EncryptionAlgorithm algId)
  {
   this.transformer=new DecryptTransformer(algId);
  }
  private DecryptTransformer transformer;
  private byte[] initVec;
  public byte[] IV
  {
   set{this.initVec=value;}
  }
        /// <summary>
        /// 解密数据
        /// </summary>
        /// <param name="bytesData">要解密的数据</param>
        /// <param name="bytesKey">密钥</param>
        /// <returns></returns>
  public byte[] Decrypt(byte[] bytesData,byte[] bytesKey)
  {
   MemoryStream memStreamDecryptedData=new MemoryStream();
   transformer.IV=initVec;
   ICryptoTransform transform=transformer.GetCryptoServiceProvider(bytesKey);
   CryptoStream decStream=new CryptoStream(memStreamDecryptedData,transform,CryptoStreamMode.Write);
   try
   {
    decStream.Write(bytesData,0,bytesData.Length);
   }
   catch(Exception ex)
   {
    throw new Exception("Error while writing encrypted data to the stream:/n"+ex.Message);
   }
   decStream.FlushFinalBlock();
   decStream.Close();
   return memStreamDecryptedData.ToArray();
  }
 }
}

using System;
using System.IO;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 /// 用来加密数据
 /// </summary>
 public class Encryptor
 {
  public Encryptor(EncryptionAlgorithm algId)
  {
   this.transformer=new EncryptTransformer(algId);
  }
  private EncryptTransformer transformer;
  private byte[] initVec;
  private byte[] encKey;
  /// <summary>
  /// 初始向量用来规避文件中的重复部分防止被解密
  /// </summary>
  public byte[] IV
  {
   get{return initVec;}
   set{initVec=value;}
  }
  public byte[] key
  {
   get{return encKey;}
  }
       
  /// <summary>
  /// 对数据进行加密
  /// </summary>
  /// <param name="bytesData">要加密的数据</param>
  /// <param name="bytesKey">密钥</param>
  /// <returns>经过加密后的数据</returns>
  public byte[] Encrypt(byte[] bytesData,byte[] bytesKey)
  {
   MemoryStream memStreamEncryptedData=new MemoryStream();
   transformer.IV=initVec;
   ICryptoTransform transform=transformer.GetCryptoServiceProvider(bytesKey);
   CryptoStream encStream=new CryptoStream(memStreamEncryptedData,transform,CryptoStreamMode.Write);
   try
   {
    encStream.Write(bytesData,0,bytesData.Length);
   }
   catch(Exception ex)
   {
    throw new Exception("Error while writing encrypted data to the stream:/n"+ex.Message);
   }
   encKey=transformer.Key;
   initVec=transformer.IV;
   encStream.FlushFinalBlock();
   encStream.Close();
   return memStreamEncryptedData.ToArray();
  }
 }
}

using System;
using System.IO;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 /// 文件解密类
 /// </summary>
 public class FileDecryptor
 {
  /// <summary>
  /// 初始化一个文件解密类
  /// </summary>
  /// <param name="algId">EncryptionAlgorithm枚举，用于确定加密算法</param>
  public FileDecryptor(EncryptionAlgorithm algId)
  {
   this.transformer=new DecryptTransformer(algId);
  }
  private DecryptTransformer transformer;
  private byte[] initVec;//初始化向量
  /// <summary>
  /// 初始化向量，在解密前要初始化
  /// </summary>
  public byte[] IV
  {
   get{return initVec;}
   set{initVec=value;}
  }  
  /// <summary>
  /// 解密文件
  /// </summary>
  /// <param name="inName">要解密的文件路径</param>
  /// <param name="outName">输出文件路径</param>
  /// <param name="bytesKey">密码</param>
  /// <returns></returns>
  public bool DecryptFile(String inName, String outName, byte[] bytesKey)
  {
   FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);//the input filestream
   FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write);//the output filestream
   fout.SetLength(0);//set the length of the output filestream for initalization
   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.
   transformer.IV=initVec;//对解密类的初始化向量进行设置
   ICryptoTransform transform=transformer.GetCryptoServiceProvider(bytesKey); 
   CryptoStream encStream = new CryptoStream(fout,transform,CryptoStreamMode.Write);
   Console.WriteLine("Decrypting...");
   while(rdlen < totlen)
   {
    len = fin.Read(bin, 0, 100);
    encStream.Write(bin, 0, len);
    rdlen = rdlen + len;    
    Console.WriteLine("{0} bytes processed", rdlen);
   }
   Console.WriteLine("Encrypted succefully");   
   encStream.Close(); 
   fout.Close();
   fin.Close();
   return true;
  }
 }
}

using System;
using System.IO;
using System.Security.Cryptography;

namespace Encryption
{
 /// <summary>
 /// 对文件进行加密
 /// </summary>
 public class FileEncryptor
 {
  /// <summary>
  /// 构造一个文件加密类
  /// </summary>
  /// <param name="algId">一个枚举，用来定义加密方式</param>
  public FileEncryptor(EncryptionAlgorithm algId)
  {
   this.transformer=new EncryptTransformer(algId);
  }
  private EncryptTransformer transformer;
  private byte[] initVec;
  private byte[] encKey;  
  /// <summary>
  /// 初始向量用来规避文件中的重复部分防止被解密
  /// </summary>
  public byte[] IV
  {
   get{return initVec;}
   set{initVec=value;}
  }
  public byte[] key
  {
   get{return encKey;}
  }
        /// <summary>
        /// 用来加密一个文件
        /// </summary>
        /// <param name="inName">要加密的文件路径</param>
        /// <param name="outName">加密数据的保存路径</param>
        /// <param name="bytesKey">密钥</param>
        /// <returns></returns>
  public bool EncryptFile(String inName, String outName, byte[] bytesKey)
  {
   FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read);//the input filestream
   FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write);//the output filestream
   fout.SetLength(0);//set the length of the output filestream for initalization
   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.
   transformer.IV=initVec;
   ICryptoTransform transform=transformer.GetCryptoServiceProvider(bytesKey);
   encKey=transformer.Key;//if you do not give a key then will create a key automaticlly
   CryptoStream encStream = new CryptoStream(fout,transform,CryptoStreamMode.Write);
   Console.WriteLine("Encrypting...");
   while(rdlen < totlen)
   {
    len = fin.Read(bin, 0, 100);
    encStream.Write(bin, 0, len);
    rdlen = rdlen + len;    
    Console.WriteLine("{0} bytes processed", rdlen);
   }
   Console.WriteLine("Encrypted succefully"); 
   encStream.Close(); 
   fout.Close();
   fin.Close();
   return true;
  }
 }
}
2、控制台应用程序

using System;
using Encryption;
using System.Text;
using System.IO;

namespace FileEncryptTest
{
 /// <summary>
 /// Class1 的摘要说明。
 /// </summary>
 class Class1
 {
  /// <summary>
  /// 应用程序的主入口点。
  /// </summary>
  [STAThread]
  static void Main(string[] args)
  {
   Message("这是一个加密和解密的程序，采用对称加密技术，用了DES,3DES,Rs2,Rijndael加密算法!");
   Message("使用时按照提示即可完成操作!(注意必须保证密钥和初始向量的长度正确");
   Message("@2005----潘伟峰");
   int action=0;
   string infile=null;
   string outfile=null;
   string password=null;
   string iv=null;
   int encryptedmethod=0;
   byte[] key=null;
   byte[] IV=null;
   if(args.Length==4)
   {
    action=Convert.ToInt32(args[0].Trim());
    infile=args[1];
    outfile=args[2];
    password=args[3];
    encryptedmethod=Convert.ToInt32(args[4].Trim());
   }
   while(action==0||infile==null||outfile==null||password==null||iv==null||encryptedmethod==0)
   {
    if(action==0)
    {
     Console.WriteLine("请选择一个操作");
     Console.WriteLine("1.加密一个文件");
     Console.WriteLine("2.解密一个文件");
     action=Convert.ToInt32(Console.ReadLine().Trim());
    }
    if(infile==null)
    {
     if(action==1)
     {
      Console.WriteLine("请输入你要加密的文件路径");
     }
     if(action==2)
     {
      Console.WriteLine("请输入你要解密的文件路径");
     }
     infile=Console.ReadLine().Trim();
     FileInfo f=new FileInfo(infile);
     if(!f.Exists)
     {
      Console.WriteLine("文件不存在");
      infile=null;
      continue;
     }
    }
    if(outfile==null)
    {
     if(action==1)
     {
      Console.WriteLine("请输入加密后文件的存放路径");
     }
     if(action==2)
     {
      Console.WriteLine("请输入解密后文件的存放路径");
     }     
     outfile=Console.ReadLine().Trim();
    }
    if(encryptedmethod==0)
    {
     Console.WriteLine("请选择一个加密算法:");
     Console.WriteLine("1.DES");
     Console.WriteLine("2.Rc2");
     Console.WriteLine("3.Rijndael");
     Console.WriteLine("4.TripleDes");
     encryptedmethod=Convert.ToInt32(Console.ReadLine().Trim());
    }
    if(password==null)
    {
     Console.WriteLine("请输入密码:");
     ShowRightKeySize(encryptedmethod);
     password=Console.ReadLine().Trim();
    }
    if(iv==null)
    {
     Console.WriteLine("请输入初始向量:");
     Console.WriteLine("注意:初始向量的长度必须正确");
     ShowRightIVSize(encryptedmethod);
     iv=Console.ReadLine().Trim();
    }
   }
   //choose a Encrypted Mehod
   EncryptionAlgorithm algorithm;
   switch(encryptedmethod)
   {
    case 1:
    {
     algorithm=EncryptionAlgorithm.Des;
     break;
    }
    case 2:
    {
     algorithm=EncryptionAlgorithm.Rc2;
     break;
    }
    case 3:
    {
     algorithm=EncryptionAlgorithm.Rijndael;
     break;

    }
    case 4:
    {
     algorithm=EncryptionAlgorithm.TripleDes;
     break;
    }
    default:
    {
     algorithm=EncryptionAlgorithm.Des;
     break;
    }
   }
   IV=Encoding.ASCII.GetBytes(iv);
   key=Encoding.ASCII.GetBytes(password);
   if(action==1)
   {
    FileEncryptor fe=new FileEncryptor(algorithm);//define a new fileencryptor acording to the encryptormethod
    fe.IV=IV;
    if(fe.EncryptFile(infile,outfile,key))
    {
     Console.WriteLine("加密成功");
     Console.ReadLine();
    }
   }
   if(action==2)
   {
    FileDecryptor fd=new FileDecryptor(algorithm);
    fd.IV=IV;
    if(fd.DecryptFile(infile,outfile,key))
    {
     Console.WriteLine("解密成功");
     Console.ReadLine();
    }
   }
  }
  public static void ShowRightKeySize(int id)
  {
   switch(id)
   {
    case 1:
    {
       Message("正确密码长度:8bytes");
     break;
    }
    case 2:
    {
     Message("正确密码长度:5--16bytes");
     break;
    }
    case 3:
    {
     Message("正确密码长度:16/24/32bytes");
     break;
    }
    case 4:
    {
     Message("正确密码长度:16/24bytes");
     break;
    }
    default:
    {
     break;
    }
   }
  }
  private static void ShowRightIVSize(int id)
  {
   switch(id)
   {
    case 1:
    {
     Message("正确初始向量长度:8bytes");
     break;
    }
    case 2:
    {
     Message("正确初始向量长度:8bytes");
     break;
    }
    case 3:
    {
     Message("正确初始向量长度:16/24/32bytes");
     break;
    }
    case 4:
    {
     Message("正确初始向量长度:8bytes");
     break;
    }
    default:
    {
     break;
    }
   }
  }
  private static void Message(string msg)
  {
   Console.WriteLine(msg);
  }
 }
}