加密、解密常用类

 A. 对称密钥类。

using    System;   
using    System.Security.Cryptography;   
using    System.IO;   
using    System.Text;   
    
namespace    IMServer   
{   
     ///     <summary>
     ///    SymmCrypto是一个System.Security.Cryptography.SymmetricAlgorithm类的包、简单化的接口
     ///    它也支持可定制的SymmetricAlgorithm。 
     ///     </summary>    
     public     class    SymmCrypto   
    {   
         ///      <remarks>
         ///   支持.Net自带的SymmetricAlgorithm类。
         ///    </remarks>    
         public   enum  SymmProvEnum: int
        {DES,RC2,Rijndael,TripleDES}   
    
         private    SymmetricAlgorithm   mobjCryptoService;   
    
         ///   <remarks>
         ///  为使用.Net自带的SymmetricAlgorithm类的构造器。
         ///   </remarks>    
         public  SymmCrypto(SymmProvEnum NetSelected)
        {   
             switch (NetSelected)   
            {   
                 case  SymmProvEnum.DES:
                    mobjCryptoService    =     new    DESCryptoServiceProvider();   
                     break ;   
                 case  SymmProvEnum.RC2:   
                    mobjCryptoService    =     new    RC2CryptoServiceProvider();   
                     break ;   
                 case  SymmProvEnum.Rijndael:   
                    mobjCryptoService    =     new    RijndaelManaged();   
                     break ;   
                 case  SymmProvEnum.TripleDES:   
                    mobjCryptoService    =     new    TripleDESCryptoServiceProvider();   
                     break ;   
            }   
        }   
    
         ///   <remarks>
         ///  为使用一个定制的SymmetricAlgorithm类的构造器。
         ///   </remarks>    
         public  SymmCrypto(SymmetricAlgorithm ServiceProvider)   
        {
            mobjCryptoService = ServiceProvider;
        }   
    
         private   byte [] GetLegalKey( string  Key)   
        {   
             string  sTemp  = Key;
            mobjCryptoService.GenerateKey();
             byte [] bytTemp = mobjCryptoService.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);   
        }   
    
         private   byte [] GetLegalIV()   
        {
             // 初始化的IV字符串可以修改成你喜欢的数据。
             string  sTemp = " 救臆妲饣 " ;
            mobjCryptoService.GenerateIV();
             byte [] bytTemp = mobjCryptoService.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);   
        }   
    
         public   string  Encrypting( string  Source, string  Key)   
        {
             // 使用UTF8编码装便成两个字节的汉字。
             byte [] bytIn = UTF8Encoding.UTF8.GetBytes(Source);
             // 在没有I/O文件下创建一个内存流为了过程能够被做。
            System.IO.MemoryStream ms = new  System.IO.MemoryStream();
             // 设置私有的Key。
            mobjCryptoService.Key = GetLegalKey(Key);   
            mobjCryptoService.IV = GetLegalIV();
             // 创建一个加密从Service Provider实例。
            ICryptoTransform encrypto = mobjCryptoService.CreateEncryptor();
             // 创建一个加密的流为了转换一个使用加密的流。
            CryptoStream cs = new  CryptoStream(ms,encrypto,CryptoStreamMode.Write);
             // 写出加密内容到内存流。
            cs.Write(bytIn,    0 ,   bytIn.Length);   
            cs.FlushFinalBlock();    
            ms.Close();   
             byte [] bytOut = ms.ToArray();   

             // 转换成64位为了能在XML中使用的内容。
             return  System.Convert.ToBase64String(bytOut);
        }   
    
         public   string  Decrypting( string  Source, string  Key)   
        {
             // 从64位转成字节数组。
             byte [] bytIn = System.Convert.FromBase64String(Source);
             // 创建一个输入的内存流。
            System.IO.MemoryStream ms = new  System.IO.MemoryStream(bytIn, 0 ,bytIn.Length);

             // 设置一个私有的Key。
            mobjCryptoService.Key = GetLegalKey(Key);   
            mobjCryptoService.IV = GetLegalIV();   
    
             // 创建一个加密从Service Provider实例。
            ICryptoTransform encrypto = mobjCryptoService.CreateDecryptor();
   
             // 创建一个加密的流为了转换一个使用加密的流。 
            CryptoStream cs = new  CryptoStream(ms,encrypto,CryptoStreamMode.Read); 

             // 从加密流中读出结果。
            System.IO.StreamReader sr = new  System.IO.StreamReader(cs); 
             return  sr.ReadToEnd();
        }   
    }   
}

B. 非对称密钥类（公钥加密、私钥解密）。

复杂些（因为RSA只能加密117位、解密128位，所以要分段加、解密。）：

using  System;

namespace  IMServer
{
     ///   <summary>
     ///  类名称：jiamiceshi
     ///  类功能：加密解密类
     ///  开发人员：
     ///  开发时间：
     ///   </summary>
     public   class  jiamiceshi
    {
         ///   <summary>
         ///  解密函数
         ///   </summary>
         public  System.Security.Cryptography.RSACryptoServiceProvider rsa;
         ///   <summary>
         ///  加密函数
         ///   </summary>
         public  System.Security.Cryptography.RSACryptoServiceProvider rsa1;
         ///   <summary>
         ///  得到公钥标志
         ///   </summary>
         public   bool  flag = false ;

         public  jiamiceshi()
        {
            rsa = new  System.Security.Cryptography.RSACryptoServiceProvider();
            rsa1 = new  System.Security.Cryptography.RSACryptoServiceProvider();
            
        }

         ///   <summary>
         ///  发送服务器公钥
         ///   </summary>
         ///   <returns></returns>
         public   string  SendPublicKey()
        {
             string  result = null ;
             try
            {
                 // 导出公钥
                result = rsa.ToXmlString( false );
            }
             catch (System.Security.Cryptography.CryptographicException e)
            {
                Console.WriteLine(e.Message);
            }
             return  result;
        }

         ///   <summary>
         ///  得到客户端公钥    
         ///   </summary>
         ///   <param name="_publicKey"> 字符串 </param>
         ///   <returns></returns>
         public   bool  GetPublicKey( string  _publicKey)
        {
             try
            {
                rsa1.FromXmlString(_publicKey);
                flag = true ;
                 return  flag;
            }
             catch (System.Security.Cryptography.CryptographicException e)
            {
                Console.WriteLine(e.Message);
            }
             catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
             return   false ;
        }

         ///   <summary>
         ///  加密函数,注意最好返回二进制流。
         ///   </summary>
         ///   <param name="text"> 文本 </param>
         ///   <returns></returns>
         public   byte [] Encrypt( string  text)
        {
             byte [] encbyte = null ;
             try
            {
                 byte [] tempbyte = System.Text.Encoding.UTF8.GetBytes(text);  // 原始明文数据
                 int  templength = tempbyte.Length; // 原始明文长度
                 // 将原始明文扩展到117的整数倍
                 int  mod  =  templength  %   117 ; // 求余
                 byte [] mbyte = new   byte [templength + ( 117 - mod)]; // 扩展后的明文
                 for  ( int  i  =   0 ; i  <  templength; i ++ ) // 前半部分拷贝进来
                {
                    mbyte[i]  =  tempbyte[i];           
                }
                 for  ( int  i  =  templength; i  <  mbyte.Length; i ++ ) // 后半部分都填空格 asc 32
                {
                    mbyte[i]  = 32 ;
                }
                 // ok明文整理完璧
                 // 开始分割明文
                 int  div  =  mbyte.Length  /   117 ; // 每117个为一组对明文分组
                 if  ((mbyte.Length  %   117 )  !=   0 ) div  +=   1 ; // 此处可能永远到不了吧？
                 byte [][] divbyte  =   new   byte [div][]; // 存放分组明文
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    divbyte[i]  =   new   byte [ 117 ]; // 每一个分割都是117长度
                    Array.Copy(mbyte,i * 117 ,divbyte[i], 0 , 117 ); // 拷贝到第i个分割数据中
                }
                 // ok分割完毕开始加密
                 byte [][] divencbyte   =   new   byte [div][]; // 存放加密后的密文
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    divencbyte[i]  =   new   byte [ 128 ];
                    divencbyte[i]  =  rsa1.Encrypt(divbyte[i], false );
                }
                 // 加密完毕
                 // 开始拼装
                encbyte = new   byte [div * 128 ]; // 拼装后的数组
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    Array.Copy(divencbyte[i], 0 ,encbyte, 128 * i, 128 );
                }
                 // 拼装完毕
            }
             catch (System.Security.Cryptography.CryptographicException e)
            {
                Console.WriteLine(e.Message);
            }
             catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
             return  encbyte;
        }


         ///   <summary>
         ///  解密函数
         ///   </summary>
         ///   <param name="EncryptToData"> 二进制流 </param>
         ///   <returns></returns>
         public   string  DecryptMessage( byte [] EncryptToData)
        {
             string  tempstr = null ;
             try
            {
                 // 分割密文
                 int  div  =  EncryptToData.Length  /   128 ; // 每128个为一组对密文分组
                 if  ((EncryptToData.Length  %   128 )  !=   0 ) div  +=   1 ; // 此处可能永远到不了吧？
                 byte [][] divbyte  =   new   byte [div][]; // 存放分组密文
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    divbyte[i]  =   new   byte [ 128 ]; // 每一个分割都是128长度
                    Array.Copy(EncryptToData,i * 128 ,divbyte[i], 0 , 128 ); // 拷贝到第i个分割数据中
                }
                 // ok分割完毕开始解密
                 // 开始解密
                 byte [][] divdecbyte   =   new   byte [div][]; // 存放解密后的明文
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    divdecbyte[i]  =   new   byte [ 117 ];
                    divdecbyte[i]  =  rsa.Decrypt(divbyte[i], false );
                }
                 // 解密完毕
                 // 开始拼装
                 byte [] decbyte = new   byte [div * 117 ]; // 拼装后的数组
                 for  ( int  i  =   0 ; i  <  div; i ++ )
                {
                    Array.Copy(divdecbyte[i], 0 ,decbyte, 117 * i, 117 );
                }
                 // 拼装完毕
                 // 形成字符串,并去掉空格
                tempstr = System.Text.Encoding.UTF8.GetString(decbyte);
            }
             catch (System.Security.Cryptography.CryptographicException e)
            {
                Console.WriteLine(e.Message);
            }
             catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
             return  tempstr.Trim();
        }
    }
}

完毕,希望和大家多多交流。