DotNet加密方式解析--对称加密

离过年又近了一天，回家已是近在咫尺，有人欢喜有人愁，因为过几天就得经历每年一度的装逼大戏，亲戚朋友加同学的各方显摆，所以得靠一剂年终奖来装饰一个安稳的年，在这里我想起了一个题目“论装逼的技术性和重要性”。

都是老司机了，不扯淡，站在外面的都进来，然后请后面的把门关一下，我们接着出发。

上一篇主要介绍.NET的散列加密，散列算法主要用于签名等操作，在我们的项目中，如果对加密没有特别的要求，一般都是采用的对称加密方式，因为这种加密方式相较其他加密方式较为简单，但是这种加密方式比较的高效，所以今天就介绍一下.NET的对称加密方式。

一.DotNet对称加密概述：

对称加密是采用单密钥加密方式，这也就意味着加密和解密都是用同一个密钥。根据密码学的相关定义，对称加密系统的组成部分有5个，分别是明文空间，密文空间，密钥空间，加密空间，解密算法。接下来用一个示意图来表示一下：

DotNet对称加密算法的核心是一个密码函数，该函数将固定大小的消息数据块（纯文本）转换成加密数据库（加密文本）。转化为加密文本或重建为纯文本都需要密钥，加密是可逆的，或者说是双向的过程，可以使用密钥来反转加密效果并重建纯文本。

大多数对称加密算法是在不同的密码模式下运行，在密码函数处理数据之前，这些模式指定了准备这些数据的不同方式。密码模式有：电子代码薄模式，密码块链接，密码反馈模式。

有关块值填充的内容在下面会讲解到。

二.DotNet对称加密类解析：

1.对称加密分类：

(1).在.NET中对称加密算法分类有如下结构图：

(2).对于.NET对称加密算法的说明如下表格：

算法名称	算法说明
DES加密算法	采用的是分组加密方式，使用56位密钥加密64位明文，最后产生64位密文
3DES加密算法	采用168位的密钥，三重加密，速度比较的慢
TripleDES加密算法	用两个密钥对数据进行3次加密/解密运算
RC2加密算法	运用密钥长度可变，对明文采取64位分组加密
RC4加密算法	运用一个密钥长度可变的面向字节流的加密算法，以随机置换为基础
RC5加密算法	运用一种分组长度、密钥长度、加密迭代轮数都可变的分组加密算法。（包含密钥扩展、加密算法、解密算法）
RC6加密算法	RC6继承了RC5的循环移位思想，RC6是输入的明文由原先2个区扩展为4个块区
Rijndael加密算法	运用反复运算的加密算法，允许数据区块及密钥的长度可变。数据区块与密钥长度的变动时各自独立的

2.DotNet对称加密核心对象解析：

在.NET中对称算法的层次结构如下图：

Ⅰ.SymmetricAlgorithm类解析：

SymmetricAlgorithm类允许配置一个算法（选择大小，填充模式）并创建加密和解密数据的实例；不能使用该类和导出实现类来种子直接处理数据。接下来我们具体了解一下SymmetricAlgorithm类的一些方法和属性。该类是一个抽象类，是所有对称加密算法基类。在使用派生类时，如果仅在用完对象后强制垃圾回收是不够的，需要对该对象显示的调用clear方法，以便在释放对象之前将对象中所包含的所有敏感数据清除。

(1).IV属性：获取或设置对称算法的初始化向量。

  public virtual byte[] IV
    {
      get
      {
        if (this.IVValue == null)
          this.GenerateIV();
        return (byte[]) this.IVValue.Clone();
      }
      set
      {
        if (value == null)
          throw new ArgumentNullException("value");
        if (value.Length != this.BlockSizeValue / 8)
          throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidIVSize"));
        this.IVValue = (byte[]) value.Clone();
      }
    }

该属于使用字节数组的形式表示Key，该属性具有get和set属性，表明该属性是可读可写的，该属性为虚属性，可以在子类中重写。Key属性是用来获取或设置对称算法的密钥，密钥即可使用于加密也可以使用于解密。

(2).LegalBlockSizes属性：获取对称算法支持的块大小（以位为单位）。

 public virtual KeySizes[] LegalBlockSizes
    {
      get
      {
        return (KeySizes[]) this.LegalBlockSizesValue.Clone();
      }
    }

该属性为虚属性，在子类中可重写，该属性是只读属性。

(3).Create()方法：创建用于执行对称算法的指定加密对象。

public static SymmetricAlgorithm Create(string algName)
    {
      return (SymmetricAlgorithm) CryptoConfig.CreateFromName(algName);
    }

该方法CryptoConfig.CreateFromName()方法在前面一篇介绍过，在这里就不做具体的介绍，Create()接收一个SymmetricAlgorithm类型的字符串参数，指定本次System.Security.Cryptography.SymmetricAlgorithm字符串。

(4).Mode属性：获取或设置对称算法的运算模式。

 public virtual CipherMode Mode
    {
      get
      {
        return this.ModeValue;
      }
      set
      {
        if (value < CipherMode.CBC || CipherMode.CFB < value)
          throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidCipherMode"));
        this.ModeValue = value;
      }
    }

该属性是一个虚属性，获取和设置密码代码，拉取准备数据，由代码可以看出，该属性含有一个枚举类型CipherMode，我们接下来了解一下这个枚举类型：

CipherMode枚举类型：指定用于加密的块加密模式。

    [ComVisible(true)]
    public enum CipherMode
    {
        CBC = 1,
        ECB = 2,
        OFB = 3,
        CFB = 4,
        CTS = 5
    }

CBC（密码块链）：该模式引入类反馈；ECB（电子密码本）：该模式分别加密每个块；OFB（输出反馈）：该模式将少量递增的纯文本处理改成密码文本，而不是以此处理整个块；CFB（密码反馈）：该模式将少量递增的纯文本处理成密码文本，而不是一次处理整个块；CTS（密码文本窃用）：该模式处理任何长度的纯文本并产生长度与纯文本长度匹配的密码文本。

(5).Padding属性：获取或设置对称算法中使用的填充模式。

public virtual PaddingMode Padding
    {
      get
      {
        return this.PaddingValue;
      }
      set
      {
        if (value < PaddingMode.None || PaddingMode.ISO10126 < value)
          throw new CryptographicException(Environment.GetResourceString("Cryptography_InvalidPaddingMode"));
        this.PaddingValue = value;
      }
    }

该属性是对称算法中使用的填充模式，默认值为 PKCS7。该属性可读可写，填充数据的部分块。由该属性可知一个枚举类型PaddingMode。

PaddingMode枚举：指定当消息数据块较短时要应用的填充类型，比加密操作所需的全部字节数。

    [ComVisible(true)]
    public enum PaddingMode
    {
        None = 1,
        PKCS7 = 2,
        Zeros = 3,
        ANSIX923 = 4,
        ISO10126 = 5
    }

该枚举类型有5个成员， None = 1：不填充；PKCS7 = 2：PKCS＃7填充字符串由字节序列组成，每个字节都是等于添加的填充字节的总数； Zeros = 3：填充字符串由设置为零的字节组成； ANSIX923 = 4：ANSI X 923填充字符串由长度前面填充零的字节序列组成；ISO10126 = 5：ISO10126填充字符串由长度之前的随机数据组成。

Ⅱ.ICryptoTransform：

ICryptoTransform定义基本的加密转换运算，该接口的实例可以将文纯文本转化成加密文本，或者将加密文本转化为纯文本，每一个ICryptoTransform都是单向的，只能被用于其创建的目的。该接口的属性和方法如下：

    /// <summary>
    /// 获取输入块大小。
    /// </summary>
    int InputBlockSize { get; }
    /// <summary>
    /// 获取输出块大小。
    /// </summary>
    int OutputBlockSize { get; }
    /// <summary>
    /// 获取一个值，该值指示是否可以转换多个块。
    /// </summary>
    bool CanTransformMultipleBlocks { get; }
    /// <summary>
    /// 获取一个值，该值指示是否可重复使用当前转换。
    /// </summary>
    bool CanReuseTransform { get; }
    /// <summary>
    /// 转换输入字节数组的指定区域，并将所得到的转换复制到输出字节数组的指定区域。
    /// </summary>
    int TransformBlock(byte[] inputBuffer, int inputOffset, int inputCount, byte[] outputBuffer, int outputOffset);
    /// <summary>
    /// 转换指定字节数组的指定区域。
    /// </summary>
 byte[] TransformFinalBlock(byte[] inputBuffer, int inputOffset, int inputCount);

ICryptoTransform接口实例并不能使用于自己，.NET提供了CryptoStream类，定义将数据流链接到加密转换的流。创建CryptoStream的实例需要一个真实流、ICryptoTransform、CryptoStreamMode枚举的值。

三.DotNet对称加密实例：

1.DES算法加密实例：

        /// <summary> 
        /// 加密数据 
        /// </summary> 
        /// <param name="text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Encrypt(string text, string sKey)
        {
            if (string.IsNullOrEmpty(text))
            {
                throw new ArgumentNullException(text);
            }
            if (string.IsNullOrEmpty(sKey))
            {
                throw new ArgumentNullException(sKey);
            }
            MemoryStream ms = null;
            DESCryptoServiceProvider des = null;
            try
            {
                des = new DESCryptoServiceProvider();
                var inputByteArray = Encoding.Default.GetBytes(text);
                var bKey = Encoding.ASCII.GetBytes(Md5Hash(sKey).Substring(0, 8));
                des.Key = bKey;
                des.IV = bKey;
                ms = new MemoryStream();
                var cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                var ret = new StringBuilder();
                foreach (byte b in ms.ToArray())
                {
                    ret.AppendFormat("{0:X2}", b);
                }
                return ret.ToString();
            }
            catch (NotSupportedException nsex)
            {
                throw nsex;
            }
            catch (ArgumentNullException arnex)
            {
                throw arnex;
            }
            catch (EncoderFallbackException efex)
            {
                throw efex;
            }
            catch (ArgumentException arex)
            {
                throw arex;
            }
            catch (CryptographicException crex)
            {
                throw crex;
            }
            finally
            {
                if (ms != null)
                {
                    ms.Close();
                }
                if (des != null)
                {
                    des.Clear();
                }
            }
        }

2.DES算法解密实例：

        /// <summary> 
        /// 解密数据 
        /// </summary> 
        /// <param name="text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Decrypt(string text, string sKey)
        {
            if (string.IsNullOrEmpty(text))
            {
                throw new ArgumentNullException(text);
            }
            if (string.IsNullOrEmpty(sKey))
            {
                throw new ArgumentNullException(sKey);
            }
            MemoryStream ms = null;
            DESCryptoServiceProvider des = null;
            try
            {
                des = new DESCryptoServiceProvider();
                var len = text.Length / 2;
                byte[] inputByteArray = new byte[len];
                int x;
                for (x = 0; x < len; x++)
                {
                    var i = Convert.ToInt32(text.Substring(x * 2, 2), 16);
                    inputByteArray[x] = (byte)i;
                }
                var bKey = Encoding.ASCII.GetBytes(Md5Hash(sKey).Substring(0, 8));
                des.Key = bKey;
                des.IV = bKey;
                ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
                cs.Write(inputByteArray, 0, inputByteArray.Length);
                cs.FlushFinalBlock();
                return Encoding.Default.GetString(ms.ToArray());
            }
            catch (NotSupportedException nsex)
            {
                throw nsex;
            }
            catch (ArgumentNullException arnex)
            {
                throw arnex;
            }
            catch (EncoderFallbackException efex)
            {
                throw efex;
            }
            catch (ArgumentException arex)
            {
                throw arex;
            }
            catch (CryptographicException crex)
            {
                throw crex;
            }
            finally
            {
                if (ms != null)
                {
                    ms.Close();
                }
                if (des != null)
                {
                    des.Clear();
                }
            }
        }