当前位置: 首页  >  C#  >  C#做的一个加密/解密的类

C#做的一个加密/解密的类 TOP

    摘要:前两年写的东西,现在整理一下发出来!以前公司需要做WebService,并且对WebService的SoapHeader进行加密,所以就写了这么个东东!使用这个类,需要密钥管理!为了保证数据的安全性往往要对数据进行加密,但是加密的缺点之一,就是影响程序的运行效率,所以,当时我的思路是只对用户的登录信息(用户名,密码)进行加密!数据用明文传输,用户信息验证没有通过的情况下, 不进行数据传输。

     前两年写的东西,现在整理一下发出来!以前公司需要做WebService,并且对WebService的SoapHeader进行加密,所以就写了这么个东东!使用这个类,需要密钥管理!为了保证数据的安全性往往要对数据进行加密,但是加密的缺点之一,就是影响程序的运行效率,所以,当时我的思路是只对用户的登录信息(用户名,密码)进行加密!数据用明文传输,用户信息验证没有通过的情况下, 不进行数据传输。

     实际在网络通讯中,使用密钥匙的方式并非无懈可击,如果黑客可以捕捉到用密钥加密的,用户验证信息,然后,做个模拟请求,向提供WebService的服务器发请求,还是可以获得请求数据!所以,我又使用了IP或者域名绑定的方式!毕竟,WebService不是直接对最终用户提供的!所以,加上以上这些手段后,就算有不良企图者想通过非法方式获得WebService提供的服务,就再费点劲吧!

     还有一点安全建议,就是定期的更换密钥,在这个例子中,我用的是对称加密,加密方和解密方的密钥一致!定期的更换密钥可以让安全性提高一大截!

 

 
  1. using System;   
  2. using System.Security.Cryptography;   
  3. using System.Text;   
  4. using System.IO;   
  5.     
  6. namespace SEDO   
  7. {   
  8.     /// <summary>   
  9.     /// SEDO 的摘要说明。   
  10.     /// SEDO 实现的是用一个封装了4种对称加密方法(Des,Rc2,Rijndael,TripleDes)的组件   
  11.     ///   
  12.     /// 注意事项:   
  13.     /// 1:TripleDes和Rijndael加密/解密对象使用16或者24位byte的Key   
  14.     /// 2:Rijndael只能使用16位的初始化向量IV   
  15.     /// 3:Des和Rc2均使用8位Byte的Key和IV   
  16.     /// 4:对需要加密/解密的数据流采用何种方法进行编码/解码,由调用组件的用户自己决定   
  17.     /// 5:密钥和初始化向量IV由使用者自己定义   
  18.     /// 程序员: 罗旭成2010-10-30 lxc880615@163.com   
  19.     /// </summary>   
  20.     
  21.     //定义加密类型的枚举   
  22.     public enum EncryptionAlgorithm { Des = 1, Rc2, Rijndael, TripleDes };   
  23.     
  24.     //定义加密类   
  25.     internal class EncryptTransformer   
  26.     {   
  27.         private EncryptionAlgorithm algorithmID;   
  28.         private byte[] initVec;   
  29.         private byte[] encKey;   
  30.     
  31.         internal EncryptTransformer(EncryptionAlgorithm algId)   
  32.         {   
  33.             //Save the algorithm being used.   
  34.             algorithmID = algId;   
  35.         }   
  36.     
  37.         internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)   
  38.         {   
  39.             //当数据密钥Key或者初始化向量IV为空的时候,   
  40.             //将使用加密对象自动产生的密钥Key或者初始化向量IV   
  41.             switch (algorithmID)   
  42.             {   
  43.                 case EncryptionAlgorithm.Des:   
  44.                     {   
  45.                         DES des = new DESCryptoServiceProvider();   
  46.                         des.Mode = CipherMode.CBC;   
  47.     
  48.                         // See if a key was provided   
  49.                         if (null == bytesKey)   
  50.                         {   
  51.                             encKey = des.Key;   
  52.                         }   
  53.                         else  
  54.                         {   
  55.                             des.Key = bytesKey;   
  56.                             encKey = des.Key;   
  57.                         }   
  58.                         // See if the client provided an initialization vector   
  59.                         if (null == initVec)   
  60.                         { // Have the algorithm create one   
  61.                             initVec = des.IV;   
  62.                         }   
  63.                         else  
  64.                         { //No, give it to the algorithm   
  65.                             des.IV = initVec;   
  66.                         }   
  67.                         return des.CreateEncryptor();   
  68.                     }   
  69.                 case EncryptionAlgorithm.TripleDes:   
  70.                     {   
  71.                         TripleDES des3 = new TripleDESCryptoServiceProvider();   
  72.                         des3.Mode = CipherMode.CBC;   
  73.                         // See if a key was provided   
  74.                         if (null == bytesKey)   
  75.                         {   
  76.                             encKey = des3.Key;   
  77.                         }   
  78.                         else  
  79.                         {   
  80.                             des3.Key = bytesKey;   
  81.                             encKey = des3.Key;   
  82.                         }   
  83.                         // See if the client provided an IV   
  84.                         if (null == initVec)   
  85.                         { //Yes, have the alg create one   
  86.                             initVec = des3.IV;   
  87.                         }   
  88.                         else  
  89.                         { //No, give it to the alg.   
  90.                             des3.IV = initVec;   
  91.                         }   
  92.                         return des3.CreateEncryptor();   
  93.                     }   
  94.                 case EncryptionAlgorithm.Rc2:   
  95.                     {   
  96.                         RC2 rc2 = new RC2CryptoServiceProvider();   
  97.                         rc2.Mode = CipherMode.CBC;   
  98.                         // Test to see if a key was provided   
  99.                         if (null == bytesKey)   
  100.                         {   
  101.                             encKey = rc2.Key;   
  102.                         }   
  103.                         else  
  104.                         {   
  105.                             rc2.Key = bytesKey;   
  106.                             encKey = rc2.Key;   
  107.                         }   
  108.                         // See if the client provided an IV   
  109.                         if (null == initVec)   
  110.                         { //Yes, have the alg create one   
  111.                             initVec = rc2.IV;   
  112.                         }   
  113.                         else  
  114.                         { //No, give it to the alg.   
  115.                             rc2.IV = initVec;   
  116.                         }   
  117.                         return rc2.CreateEncryptor();   
  118.                     }   
  119.                 case EncryptionAlgorithm.Rijndael:   
  120.                     {   
  121.                         Rijndael rijndael = new RijndaelManaged();   
  122.                         rijndael.Mode = CipherMode.CBC;   
  123.                         // Test to see if a key was provided   
  124.                         if (null == bytesKey)   
  125.                         {   
  126.                             encKey = rijndael.Key;   
  127.                         }   
  128.                         else  
  129.                         {   
  130.                             rijndael.Key = bytesKey;   
  131.                             encKey = rijndael.Key;   
  132.                         }   
  133.                         // See if the client provided an IV   
  134.                         if (null == initVec)   
  135.                         { //Yes, have the alg create one   
  136.                             initVec = rijndael.IV;   
  137.                         }   
  138.                         else  
  139.                         { //No, give it to the alg.   
  140.                             rijndael.IV = initVec;   
  141.                         }   
  142.                         return rijndael.CreateEncryptor();   
  143.                     }   
  144.                 default:   
  145.                     {   
  146.                         throw new CryptographicException("Algorithm ID ''" +   
  147.                         algorithmID +   
  148.                         "'' not supported.");   
  149.                     }   
  150.             }   
  151.         }   
  152.     
  153.         //加密的偏移向量   
  154.         internal byte[] IV   
  155.         {   
  156.             get { return initVec; }   
  157.             set { initVec = value; }   
  158.         }   
  159.         //加密的密钥   
  160.         internal byte[] Key   
  161.         {   
  162.             get { return encKey; }   
  163.             set { encKey = value; }   
  164.         }   
  165.     
  166.     }   
  167.     
  168.     //定义解密类   
  169.     internal class DecryptTransformer   
  170.     {   
  171.         private EncryptionAlgorithm algorithmID;   
  172.         private byte[] initVec;   
  173.         private byte[] encKey;   
  174.     
  175.         internal DecryptTransformer(EncryptionAlgorithm deCryptId)   
  176.         {   
  177.             algorithmID = deCryptId;   
  178.         }   
  179.     
  180.         //加密的偏移向量   
  181.         internal byte[] IV   
  182.         {   
  183.             get { return initVec; }   
  184.             set { initVec = value; }   
  185.         }   
  186.     
  187.         //加密的密钥   
  188.         internal byte[] Key   
  189.         {   
  190.             get { return encKey; }   
  191.             set { encKey = value; }   
  192.         }   
  193.     
  194.         internal ICryptoTransform GetCryptoServiceProvider(byte[] bytesKey)   
  195.         {   
  196.             //当数据密钥Key或者初始化向量IV为空的时候,   
  197.             //将使用加密对象自动产生的密钥Key或者初始化向量IV   
  198.             switch (algorithmID)   
  199.             {   
  200.                 case EncryptionAlgorithm.Des:   
  201.                     {   
  202.                         DES des = new DESCryptoServiceProvider();   
  203.                         des.Mode = CipherMode.CBC;   
  204.                         des.Key = bytesKey;   
  205.                         des.IV = initVec;   
  206.                         return des.CreateDecryptor();   
  207.                     }   
  208.                 case EncryptionAlgorithm.TripleDes:   
  209.                     {   
  210.                         TripleDES des3 = new TripleDESCryptoServiceProvider();   
  211.                         des3.Mode = CipherMode.CBC;   
  212.                         return des3.CreateDecryptor(bytesKey, initVec);   
  213.                     }   
  214.                 case EncryptionAlgorithm.Rc2:   
  215.                     {   
  216.                         RC2 rc2 = new RC2CryptoServiceProvider();   
  217.                         rc2.Mode = CipherMode.CBC;   
  218.                         return rc2.CreateDecryptor(bytesKey, initVec);   
  219.                     }   
  220.                 case EncryptionAlgorithm.Rijndael:   
  221.                     {   
  222.                         Rijndael rijndael = new RijndaelManaged();   
  223.                         rijndael.Mode = CipherMode.CBC;   
  224.                         return rijndael.CreateDecryptor(bytesKey, initVec);   
  225.                     }   
  226.                 default:   
  227.                     {   
  228.                         throw new CryptographicException("Algorithm ID ''" +   
  229.                         algorithmID +   
  230.                         "'' not supported.");   
  231.                     }   
  232.             }   
  233.         } //end GetCryptoServiceProvider   
  234.     
  235.     }   
  236.     
  237.     //定义加密者类   
  238.     public class Encryptor   
  239.     {   
  240.         private EncryptTransformer transformer;   
  241.         private byte[] initVec;   
  242.         private byte[] encKey;   
  243.     
  244.         public Encryptor(EncryptionAlgorithm algId)   
  245.         {   
  246.             transformer = new EncryptTransformer(algId);   
  247.         }   
  248.     
  249.         public byte[] Encrypt(byte[] bytesData, byte[] bytesKey, byte[] bytesIV)   
  250.         {   
  251.             //设置流对象用来保存加密数据字节流.   
  252.             MemoryStream memStreamEncryptedData = new MemoryStream();   
  253.     
  254.             transformer.IV = bytesIV;   
  255.             transformer.Key = bytesKey;   
  256.     
  257.             ICryptoTransform transform =   
  258.                 transformer.GetCryptoServiceProvider(bytesKey);   
  259.             CryptoStream encStream =   
  260.                 new CryptoStream(memStreamEncryptedData,   
  261.                     transform, CryptoStreamMode.Write);   
  262.     
  263.             try  
  264.             {   
  265.                 //将加密数据写进流对象   
  266.                 encStream.Write(bytesData, 0, bytesData.Length);   
  267.             }   
  268.             catch (Exception ex)   
  269.             {   
  270.                 throw new Exception("在数据加密的时候出现错误!"+   
  271.                     "错误提示: \n" + ex.Message);   
  272.             }   
  273.     
  274.             //设置加密的Key和初始向量IV属性   
  275.             encKey = transformer.Key;   
  276.             initVec = transformer.IV;   
  277.     
  278.             encStream.FlushFinalBlock();   
  279.             encStream.Close();   
  280.     
  281.             //Send the data back.   
  282.             return memStreamEncryptedData.ToArray();   
  283.         }   
  284.     
  285.         public byte[] IV   
  286.         {   
  287.             get { return initVec; }   
  288.             set { initVec = value; }   
  289.         }   
  290.     
  291.         public byte[] Key   
  292.         {   
  293.             get { return encKey; }   
  294.             set { encKey = value; }   
  295.         }   
  296.     
  297.     }   
  298.     
  299.     
  300.     //定义解密者类   
  301.     public class Decryptor   
  302.     {   
  303.         private DecryptTransformer transformer;   
  304.         private byte[] initVec;   
  305.         private byte[] encKey;   
  306.     
  307.         public Decryptor(EncryptionAlgorithm algId)   
  308.         {   
  309.             transformer = new DecryptTransformer(algId);   
  310.         }   
  311.     
  312.         public byte[] Decrypt(byte[] bytesData,   
  313.             byte[] bytesKey, byte[] bytesIV)   
  314.         {   
  315.             //设置流对象用来保存解密数据字节流.   
  316.             MemoryStream memStreamDecryptedData =   
  317.                 new MemoryStream();   
  318.     
  319.             //Pass in the initialization vector.   
  320.             transformer.IV = bytesIV;   
  321.             transformer.Key = bytesKey;   
  322.     
  323.             ICryptoTransform transform =   
  324.                 transformer.GetCryptoServiceProvider(bytesKey);   
  325.             CryptoStream decStream =   
  326.                 new CryptoStream(memStreamDecryptedData,   
  327.                     transform, CryptoStreamMode.Write);   
  328.     
  329.             try  
  330.             {   
  331.                 decStream.Write(bytesData, 0, bytesData.Length);   
  332.             }   
  333.             catch (Exception ex)   
  334.             {   
  335.                 throw new Exception("在数据解密的时候出现错误!"+   
  336.                     "错误提示: \n" + ex.Message);   
  337.             }   
  338.             decStream.FlushFinalBlock();   
  339.             decStream.Close();   
  340.             // 返回解密数据.   
  341.             return memStreamDecryptedData.ToArray();   
  342.         }   
  343.     
  344.         public byte[] IV   
  345.         {   
  346.             get { return initVec; }   
  347.             set { initVec = value; }   
  348.         }   
  349.     
  350.         public byte[] Key   
  351.         {   
  352.             get { return encKey; }   
  353.             set { encKey = value; }   
  354.         }   
  355.     
  356.     }   
  357.     
  358.     //类描述:文件加密/解密类   
  359.     public class SecurityFile   
  360.     {   
  361.         private DecryptTransformer Dec_Transformer; //解密转换器   
  362.         private EncryptTransformer Enc_Transformer; //加密转换器   
  363.         private byte[] initVec;   
  364.         private byte[] encKey;   
  365.     
  366.         public SecurityFile(EncryptionAlgorithm algId)   
  367.         {   
  368.             Dec_Transformer = new DecryptTransformer(algId);   
  369.             Enc_Transformer = new EncryptTransformer(algId);   
  370.         }   
  371.     
  372.         //加密的偏移向量   
  373.         internal byte[] IV   
  374.         {   
  375.             get { return initVec; }   
  376.             set { initVec = value; }   
  377.         }   
  378.         //加密的密钥   
  379.         internal byte[] Key   
  380.         {   
  381.             get { return encKey; }   
  382.             set { encKey = value; }   
  383.         }   
  384.     
  385.         //功能描述:加密文件   
  386.         public void EncryptFile(string inFileName,   
  387.             string outFileName, byte[] bytesKey, byte[] bytesIV)   
  388.         {   
  389.             try  
  390.             {   
  391.                 FileStream fin =   
  392.                     new FileStream(inFileName, FileMode.Open,   
  393.                         FileAccess.Read);   
  394.                 FileStream fout = new FileStream(outFileName,   
  395.                     FileMode.OpenOrCreate, FileAccess.Write);   
  396.                 fout.SetLength(0);   
  397.     
  398.                 //Create variables to help with read and write.   
  399.                 //This is intermediate storage for the encryption.   
  400.                 byte[] bin = new byte[100];   
  401.                 //This is the total number of bytes written.   
  402.                 long rdlen = 0;   
  403.                 //This is the total length of the input file.   
  404.                 long totlen = fin.Length;   
  405.                 //This is the number of bytes to be written at a time.   
  406.                 int len;    
  407.     
  408.                 Enc_Transformer.IV = bytesIV;   
  409.                 Enc_Transformer.Key = bytesKey;   
  410.     
  411.                 ICryptoTransform transform =   
  412.                     Enc_Transformer.GetCryptoServiceProvider(bytesKey);   
  413.                 CryptoStream encStream =   
  414.                     new CryptoStream(fout, transform, CryptoStreamMode.Write);   
  415.     
  416.                 //Read from the input file, then encrypt and write to the output file.   
  417.                 while (rdlen < totlen)   
  418.                 {   
  419.                     len = fin.Read(bin, 0, 100);   
  420.                     encStream.Write(bin, 0, len);   
  421.                     rdlen = rdlen + len;   
  422.                 }   
  423.     
  424.                 encStream.Close();   
  425.                 fout.Close();   
  426.                 fin.Close();   
  427.             }   
  428.             catch (Exception ex)   
  429.             {   
  430.                 throw new Exception("在文件加密的时候出现错误!"+   
  431.                     "错误提示: \n" + ex.Message);   
  432.             }   
  433.         }   
  434.     
  435.         //功能描述:解密文件   
  436.         public void DecryptFile(string inFileName,   
  437.             string outFileName, byte[] bytesKey, byte[] bytesIV)   
  438.         {   
  439.             try  
  440.             {   
  441.                 FileStream fin =   
  442.                     new FileStream(inFileName, FileMode.Open,   
  443.                         FileAccess.Read);   
  444.                 FileStream fout =   
  445.                     new FileStream(outFileName,   
  446.                         FileMode.OpenOrCreate, FileAccess.Write);   
  447.                 fout.SetLength(0);   
  448.     
  449.                 //Create variables to help with read and write.   
  450.                 //This is intermediate storage for the encryption.   
  451.                 byte[] bin = new byte[100];   
  452.                 //This is the total number of bytes written.   
  453.                 long rdlen = 0;   
  454.                 //This is the total length of the input file.   
  455.                 long totlen = fin.Length;   
  456.                 //This is the number of bytes to be written at a time.   
  457.                 int len;    
  458.     
  459.                 Dec_Transformer.IV = bytesIV;   
  460.                 Dec_Transformer.Key = bytesKey;   
  461.     
  462.                 ICryptoTransform transform =   
  463.                     Dec_Transformer.GetCryptoServiceProvider(bytesKey);   
  464.                 CryptoStream encStream =   
  465.                     new CryptoStream(fout, transform, CryptoStreamMode.Write);   
  466.     
  467.                 //Read from the input file, then encrypt and   
  468.                 //write to the output file.   
  469.                 while (rdlen < totlen)   
  470.                 {   
  471.                     len = fin.Read(bin, 0, 100);   
  472.                     encStream.Write(bin, 0, len);   
  473.                     rdlen = rdlen + len;   
  474.                 }   
  475.                 encStream.Close();   
  476.                 fout.Close();   
  477.                 fin.Close();   
  478.             }   
  479.             catch (Exception ex)   
  480.             {   
  481.                 throw new Exception("在文件加密的时候出现"+   
  482.                     "错误!错误提示: \n" + ex.Message);   
  483.             }   
  484.         }   
  485.     }   
  486. }  

 

Views:1308   Posted at:2013-12-02
收藏 推荐 打印 | 录入:Admin | 阅读:0