C#加解密算法

先附上源碼

加密解密算法目前已經應用到咱們生活中的各個方面

加密用於達到如下目的：

• 保密性：幫助保護用戶的標識或數據不被讀取。

• 數據完整性：幫助保護數據不被更改。

• 身份驗證：確保數據發自特定的一方。

• 不能否認性：防止特定的一方否定發送過消息。

爲了達到這些目的，咱們可使用如下作法：

私鑰加密（對稱加密）	對數據執行轉換，使第三方沒法讀取該數據。 此類型的加密使用單個共享的機密密鑰來加密和解密數據。
公鑰加密（不對稱加密）	對數據執行轉換，使第三方沒法讀取該數據。 此類加密使用公鑰/私鑰對來加密和解密數據。
加密簽名	經過建立對特定方惟一的數字簽名來幫助驗證數據是否發自特定方。 此過程還使用哈希函數。
加密哈希	將數據從任意長度映射爲定長字節序列。 哈希在統計上是惟一的；不一樣的雙字節序列不會哈希爲同一個值。

.NET Framework 提供瞭如下類來實現私鑰加密算法：

• AesManaged （在 .NET Framework 3.5中引入）。

• DESCryptoServiceProvider .

• HMACSHA1 （從技術上講，這是一種私鑰算法，由於它表示結合使用加密哈希函數和私鑰計算的消息身份驗證代碼。 請參見本主題後面的哈希值。）

• RC2CryptoServiceProvider .

• RijndaelManaged .

• TripleDESCryptoServiceProvider .

.NET Framework 提供瞭如下類來實現公鑰加密算法：

• DSACryptoServiceProvider

• RSACryptoServiceProvider

• ECDiffieHellman （基類）

• ECDiffieHellmanCng

• ECDiffieHellmanCngPublicKey （基類）

• ECDiffieHellmanKeyDerivationFunction （基類）

• ECDsaCng

.NET Framework 提供瞭如下類來實現數字簽名算法：

• DSACryptoServiceProvider

• RSACryptoServiceProvider

• ECDsa （基類）

• ECDsaCng

.NET Framework 提供的如下類實現了哈希算法：

• HMACSHA1 .

• MACTripleDES .

• MD5CryptoServiceProvider .

• RIPEMD160 .

• SHA1Managed .

• SHA256Managed .

• SHA384Managed .

• SHA512Managed .

System.Security.Cryptography 命名空間

 

	類	說明
	Aes	表示高級加密標準 (AES) 的全部實現都必須從中繼承的抽象基類。
	AesCryptoServiceProvider	使用高級加密標準 (AES) 算法的加密應用程序編程接口 (CAPI) 實現來執行對稱加密和解密。
	AesManaged	提供高級加密標準 (AES) 對稱算法的託管實現。
	AsnEncodedData	表示 Abstract Syntax Notation One (ASN.1) 編碼數據。
	AsnEncodedDataCollection	表示 AsnEncodedData 對象的集合。 此類不能被繼承。
	AsnEncodedDataEnumerator	提供在 AsnEncodedDataCollection 對象中導航的能力。 此類不能被繼承。
	AsymmetricAlgorithm	表示全部非對稱算法的實現都必須從中繼承的抽象基類。
	AsymmetricKeyExchangeDeformatter	表示全部非對稱密鑰交換反格式化程序均從中派生的基類。
	AsymmetricKeyExchangeFormatter	表示全部非對稱密鑰交換格式化程序均從中派生的基類。
	AsymmetricSignatureDeformatter	表示全部不對稱簽名反格式化程序實現均從中派生的抽象基類。
	AsymmetricSignatureFormatter	表示全部不對稱簽名格式化程序實現均從中派生的基類。
	CngAlgorithm	封裝加密算法的名稱。
	CngAlgorithmGroup	封裝加密算法組的名稱。
	CngKey	定義與下一代加密技術 (CNG) 對象一塊兒使用的密鑰的核心功能。
	CngKeyBlobFormat	指定與 Microsoft 下一代加密技術 (CNG) 對象一塊兒使用的密鑰 BLOB 格式。
	CngKeyCreationParameters	包含密鑰建立的高級屬性。
	CngPropertyCollection	提供下一代加密技術 (CNG) 屬性的強類型集合。
	CngProvider	封裝與下一代加密技術 (CNG) 對象一塊兒使用的密鑰存儲提供程序 (KSP) 的名稱。
	CngUIPolicy	爲用戶界面 (UI) 封裝可選配置參數，當您訪問受保護的密鑰時，下一代加密技術 (CNG) 將顯示這些配置參數。
	CryptoAPITransform	執行數據的加密轉換。 此類不能被繼承。
	CryptoConfig	訪問加密配置信息。
	CryptographicAttributeObject	包含一個類型和與該類型相關聯的值的集合。
	CryptographicAttributeObjectCollection	包含 CryptographicAttributeObject 對象的集合。
	CryptographicAttributeObjectEnumerator	爲 CryptographicAttributeObjectCollection 集合提供枚舉功能。 此類不能被繼承。
	CryptographicException	當加密操做中出現錯誤時引起的異常。
	CryptographicUnexpectedOperationException	當加密操做中出現意外操做時引起的異常。
	CryptoStream	定義將數據流連接到加密轉換的流。
	CspKeyContainerInfo	提供有關加密密鑰對的附加信息。 此類不能被繼承。
	CspParameters	包含傳遞給執行加密計算的加密服務提供程序 (CSP) 的參數。 此類不能被繼承。
	DataProtector	提供數據保護程序的基類。
	DeriveBytes	表示抽象基類，導出指定長度字節序列的全部類都從該基類繼承。
	DES	表示全部 DES 實現都必須從中派生的數據加密標準 (DES) 算法的基類。
	DESCryptoServiceProvider	定義訪問數據加密標準 (DES) 算法的加密服務提供程序 (CSP) 版本的包裝對象。 此類不能被繼承。
	DpapiDataProtector	提供簡單數據保護方法。
	DSA	表示全部數字簽名算法 (DSA) 的實現都必須從中繼承的抽象基類。
	DSACryptoServiceProvider	定義訪問 DSA 算法的加密服務提供程序 (CSP) 實現的包裝對象。 此類不能被繼承。
	DSASignatureDeformatter	驗證數字簽名算法 (DSA) PKCS#1 1.5 版簽名。
	DSASignatureFormatter	建立數字簽名算法 (DSA) 簽名。
	ECDiffieHellman	提供一個抽象基類，能夠從它派生橢圓曲線 Diffie-Hellman (ECDH) 算法實現。 此類提供一個全部 ECDH 實現都必須支持的基本操做集。
	ECDiffieHellmanCng	提供橢圓曲線 Diffie-Hellman (ECDH) 算法的下一代加密技術 (CNG) 實現。 此類用於執行加密操做。
	ECDiffieHellmanCngPublicKey	指定與 ECDiffieHellmanCng 類一塊兒使用的橢圓曲線 Diffie-Hellman (ECDH) 公鑰。
	ECDiffieHellmanPublicKey	提供全部 ECDiffieHellmanCngPublicKey 實現必須從中繼承的抽象基類。
	ECDsa	提供一個封裝橢圓曲線數字簽名算法 (ECDSA) 的抽象基類。
	ECDsaCng	提供橢圓曲線數字簽名算法 (ECDSA) 的下一代加密技術 (CNG) 實現。
	FromBase64Transform	從 Base 64 轉換 CryptoStream。
	HashAlgorithm	表示全部加密哈希算法實現均必須從中派生的基類。
	HMAC	表示基於哈希的消息驗證代碼 (HMAC) 的全部實現必須從中派生的抽象類。
	HMACMD5	計算基於哈希的消息身份驗證代碼 (HMAC) 使用 MD5 哈希函數，。
	HMACRIPEMD160	計算基於哈希的消息身份驗證代碼 (HMAC) 使用 RIPEMD160 哈希函數，。
	HMACSHA1	使用 SHA1 哈希函數計算基於哈希值的消息驗證代碼 (HMAC)。
	HMACSHA256	使用 SHA256 哈希函數計算基於哈希值的消息驗證代碼 (HMAC)。
	HMACSHA384	使用 SHA384 哈希函數計算基於哈希值的消息驗證代碼 (HMAC)。
	HMACSHA512	使用 SHA512 哈希函數計算基於哈希值的消息驗證代碼 (HMAC)。
	KeyedHashAlgorithm	顯示全部加密哈希算法實現均必須從中派生的抽象類。
	KeySizes	肯定對稱加密算法的有效密鑰大小設置。
	MACTripleDES	使用 TripleDES 計算輸入數據 CryptoStream 的消息驗證代碼 (MAC)。
	ManifestSignatureInformation	提供清單簽名的相關信息。
	ManifestSignatureInformationCollection	表示 ManifestSignatureInformation 對象的只讀集合。
	MaskGenerationMethod	表示全部掩碼生成器算法均必須從中派生的抽象類。
	MD5	表示 MD5 哈希算法的全部實現均從中繼承的抽象類。
	MD5Cng	提供 MD5（消息摘要 5）128 位哈希算法的 CNG（下一代加密技術）實現。
	MD5CryptoServiceProvider	使用加密服務提供程序 (CSP) 提供的實現，計算輸入數據的 MD5 哈希值。 此類不能被繼承。
	Oid	表示加密對象標識符。 此類不能被繼承。
	OidCollection	表示 Oid 對象的集合。 此類不能被繼承。
	OidEnumerator	提供在 OidCollection 對象中導航的能力。 此類不能被繼承。
	PasswordDeriveBytes	使用 PBKDF1 算法的擴展從密碼派生密鑰。
	PKCS1MaskGenerationMethod	根據 PKCS #1 計算用於密鑰交換算法的掩碼。
	ProtectedData	爲加密和解密數據提供方法。 此類不能被繼承。
	ProtectedMemory	提供保護內存和取消內存保護的方法。 此類不能被繼承。
	RandomNumberGenerator	表示加密隨機數生成器的全部實現均從中派生的抽象類。
	RC2	表示 RC2 算法的全部實現都必須從中派生的基類。
	RC2CryptoServiceProvider	定義訪問 RC2 算法的加密服務提供程序 (CSP) 實現的包裝對象。 此類不能被繼承。
	Rfc2898DeriveBytes	經過使用基於 HMACSHA1 的僞隨機數生成器，實現基於密碼的密鑰派生功能 (PBKDF2)。
	Rijndael	表示 Rijndael 對稱加密算法的全部實現必須從其繼承的基類。
	RijndaelManaged	訪問 Rijndael 算法的託管版本。 此類不能被繼承。
	RijndaelManagedTransform	使用 Rijndael 算法執行數據的加密轉換。 此類不能被繼承。
	RIPEMD160	表示 MD160 哈希算法的全部實現均從中繼承的抽象類。
	RIPEMD160Managed	使用託管庫計算輸入數據的 RIPEMD160 哈希值。
	RNGCryptoServiceProvider	使用加密服務提供程序 (CSP) 提供的實現來實現加密隨機數生成器 (RNG)。 此類不能被繼承。
	RSA	表示 RSA 算法的全部實現均從中繼承的基類。
	RSACryptoServiceProvider	使用加密服務提供程序 (CSP) 提供的 RSA 算法的實現執行不對稱加密和解密。 此類不能被繼承。
	RSAOAEPKeyExchangeDeformatter	對最優不對稱加密填充 (OAEP) 密鑰交換數據進行解密。
	RSAOAEPKeyExchangeFormatter	使用 RSA 建立最優不對稱加密填充 (OAEP) 密鑰交換數據。
	RSAPKCS1KeyExchangeDeformatter	解密 PKCS #1 密鑰交換數據。
	RSAPKCS1KeyExchangeFormatter	使用 RSA 建立 PKCS#1 密鑰交換數據。
	RSAPKCS1SignatureDeformatter	驗證 RSA PKCS #1 1.5 版簽名。
	RSAPKCS1SignatureFormatter	建立 RSA PKCS #1 1.5 版簽名。
	SHA1	計算輸入數據的 SHA1 哈希值。
	SHA1Cng	提供安全哈希算法 (SHA) 的下一代加密技術 (CNG) 實現。
	SHA1CryptoServiceProvider	使用加密服務提供程序 (CSP) 提供的實現計算輸入數據的 SHA1 哈希值。 此類不能被繼承。
	SHA1Managed	使用託管庫計算輸入數據的 SHA1 哈希值。
	SHA256	計算輸入數據的 SHA256 哈希值。
	SHA256Cng	爲 256 位哈希值提供安全哈希算法 (SHA) 的下一代加密技術 (CNG) 實現。
	SHA256CryptoServiceProvider	定義訪問 SHA256 算法的加密服務提供程序 (CSP) 實現的包裝對象。
	SHA256Managed	使用託管庫計算輸入數據的 SHA256 哈希值。
	SHA384	計算輸入數據的 SHA384 哈希值。
	SHA384Cng	提供具備 384 位哈希值的安全哈希算法 (SHA) 的下一代加密技術 (CNG) 實現。
	SHA384CryptoServiceProvider	定義訪問 SHA384 算法的加密服務提供程序 (CSP) 實現的包裝對象。
	SHA384Managed	使用託管庫計算輸入數據的 SHA384 哈希值。
	SHA512	計算輸入數據的 SHA512 哈希值。
	SHA512Cng	提供使用 512 位哈希值的安全哈希算法 (SHA) 的下一代加密技術 (CNG) 實現。
	SHA512CryptoServiceProvider	定義訪問 SHA512 算法的加密服務提供程序 (CSP) 實現的包裝對象。
	SHA512Managed	使用託管庫計算輸入數據的 SHA512 哈希算法。
	SignatureDescription	包含有關數字簽名的屬性的信息。
	StrongNameSignatureInformation	保存清單的強名稱簽名信息。
	SymmetricAlgorithm	表示全部對稱算法的實現都必須從中繼承的抽象基類。
	ToBase64Transform	將 CryptoStream 轉換爲 Base 64。
	TripleDES	表示三重數據加密標準算法的基類，TripleDES 的全部實現都必須今後基類派生。
	TripleDESCryptoServiceProvider	定義訪問 TripleDES 算法的加密服務提供程序 (CSP) 版本的包裝對象。 此類不能被繼承。

以上內容摘自微軟官網

 

下面我來介紹一下最近接觸的幾個加解密算法，包含RSA\AES\DES加解密算法，用到了.NET Framework中提供的RSACryptoServiceProvider類、AesCryptoServiceProvider類、AesManaged類、SHA256Managed類、MD5類、DESCryptoServiceProvider類、SHA1類；

一、RSA

using MY.Cipher.Csv;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace MY.Cipher
{
    public class RSACode
    {
        /// <summary>
        /// 建立RSA公鑰和私鑰
        /// </summary>
        /// <param name="publicKey"></param>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static bool CreateKey(out string publicKey, out string privateKey)
        {
            publicKey = null;
            privateKey = null;
            try
            {
                using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
                {
#if RSAXML
                    privateKey = rsa.ToXmlString(true);
                    publicKey = rsa.ToXmlString(false);
#else
                    byte[] publicKeyBytes = rsa.ExportCspBlob(false);
                    byte[] privateKeyBytes = rsa.ExportCspBlob(true);
                    publicKey = Convert.ToBase64String(publicKeyBytes);
                    privateKey = Convert.ToBase64String(privateKeyBytes);
#endif
                    return true;
                }
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="publickey"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        public static string Encrypt(string publickey, string content)
        {
            if (string.IsNullOrEmpty(content))
                return null;
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                byte[] cipherbytes;
#if RSAXML
                rsa.FromXmlString(publickey);
#else
                byte[] keyBytes = Convert.FromBase64String(publickey);
                rsa.ImportCspBlob(keyBytes);
#endif
                cipherbytes = rsa.Encrypt(Encoding.UTF8.GetBytes(content), false);
                return Convert.ToBase64String(cipherbytes);
            }
        }

        /// <summary>
        /// RSA加密
        /// </summary>
        /// <param name="publickey"></param>
        /// <param name="dt"></param>
        /// <param name="columnIndexs"></param>
        /// <returns></returns>
        public static DataTable Encrypt(string publickey, DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
#if RSAXML
                rsa.FromXmlString(publickey);
#else
                byte[] keyBytes = Convert.FromBase64String(publickey);
                rsa.ImportCspBlob(keyBytes);
#endif
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            byte[] bytes = rsa.Encrypt(Encoding.UTF8.GetBytes(objs[index].ToString()), false);
                            objs[index] = Convert.ToBase64String(bytes);
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        /// <summary>
        /// RSA解密
        /// </summary>
        /// <param name="privatekey"></param>
        /// <param name="content"></param>
        /// <returns></returns>
        public static string Decrypt(string privatekey, string content)
        {
            if (string.IsNullOrEmpty(content))
                return null;
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
                byte[] cipherbytes;
#if RSAXML
                rsa.FromXmlString(privatekey);
#else
                byte[] keyBytes = Convert.FromBase64String(privatekey);
                rsa.ImportCspBlob(keyBytes);
#endif
                cipherbytes = rsa.Decrypt(Convert.FromBase64String(content), false);
                return Encoding.UTF8.GetString(cipherbytes);
            }
        }

        /// <summary>
        ///  RSA解密
        /// </summary>
        /// <param name="privatekey"></param>
        /// <param name="dt"></param>
        /// <param name="columnIndexs"></param>
        /// <returns></returns>
        public static DataTable Decrypt(string privatekey, DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
#if RSAXML
                rsa.FromXmlString(privatekey);
#else
                byte[] keyBytes = Convert.FromBase64String(privatekey);
                rsa.ImportCspBlob(keyBytes);
#endif
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            byte[] bytes = rsa.Decrypt(Convert.FromBase64String(objs[index].ToString()), false);
                            objs[index] = Encoding.UTF8.GetString(bytes);
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        public static int Encrypt(string publickey, string src, string dest, int[] columns, Predicate<string> action)
        {
            return Encrypt(publickey, src, dest, true, columns, action);
        }

        public static int Encrypt(string publickey, string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
#if RSAXML
                rsa.FromXmlString(publickey);
#else
                byte[] keyBytes = Convert.FromBase64String(publickey);
                rsa.ImportCspBlob(keyBytes);
#endif
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    byte[] bytes = rsa.Encrypt(Encoding.UTF8.GetBytes(_reader[index].ToString()), false);
                                    objs[index] = Convert.ToBase64String(bytes);
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public static void Encrypt(string publickey, string src, string dest, int[] columns)
        {
            Encrypt(publickey, src, dest, columns, null);
        }

        public static int Decrypt(string privatekey, string src, string dest, int[] columns, Predicate<string> action)
        {
            return Decrypt(privatekey, src, dest, true, columns, action);
        }

        public static int Decrypt(string privatekey, string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {
            using (RSACryptoServiceProvider rsa = new RSACryptoServiceProvider())
            {
#if RSAXML
                rsa.FromXmlString(privatekey);
#else
                byte[] keyBytes = Convert.FromBase64String(privatekey);
                rsa.ImportCspBlob(keyBytes);
#endif
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    byte[] bytes = rsa.Decrypt(Convert.FromBase64String(_reader[index].ToString()), false);
                                    objs[index] = Encoding.UTF8.GetString(bytes);
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public static void Decrypt(string privatekey, string src, string dest, int[] columns)
        {
            Decrypt(privatekey, src, dest, columns, null);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;

namespace MY.Cipher
{
    interface ICipher
    {
        //string Key { get; set; }

        string Encrypt(string val);

        string Decrypt(string val);

        DataTable Encrypt(DataTable dt, int[] columnIndexs);

        DataTable Decrypt(DataTable dt, int[] columnIndexs);

        int Encrypt(string src, string dest, int[] columns, Predicate<string> action);

        int Decrypt(string src, string dest, int[] columns, Predicate<string> action);

        int Encrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action);

        int Decrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action);

        //void GeneralKeyIV(string keyStr, out byte[] key, out byte[] iv);
    }
}

 

二、AES

using MY.Cipher.Csv;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace MY.Cipher
{
    public class AESCode : ICipher
    {
        public string Key { get; set; }

        public string Encrypt(string val)
        {
            if (string.IsNullOrEmpty(val))
                return null;
#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] inputByteArray = Encoding.UTF8.GetBytes(val);
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                        byte[] bytes = (byte[])ms.ToArray();
                        return Convert.ToBase64String(bytes);
                    }
                }
            }
        }

        public string Decrypt(string val)
        {
            if (string.IsNullOrEmpty(val))
                return null;
#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] inputByteArray = Convert.FromBase64String(val);
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                        return Encoding.UTF8.GetString(ms.ToArray());
                    }
                }
            }
        }

        public DataTable Encrypt(DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateEncryptor();
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            using (MemoryStream ms = new MemoryStream())
                            {
                                using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                {
                                    byte[] src = Encoding.UTF8.GetBytes(objs[index].ToString());
                                    if (src.Length == 0)
                                        continue;
                                    cs.Write(src, 0, src.Length);
                                    cs.FlushFinalBlock();
                                    byte[] bytes = (byte[])ms.ToArray();
                                    objs[index] = Convert.ToBase64String(bytes);
                                }
                            }
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        public DataTable Decrypt(DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateDecryptor();
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            using (MemoryStream ms = new MemoryStream())
                            {
                                using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                {
                                    byte[] src = Convert.FromBase64String(objs[index].ToString());
                                    if (src.Length == 0)
                                        continue;
                                    cs.Write(src, 0, src.Length);
                                    cs.FlushFinalBlock();
                                    objs[index] = Encoding.UTF8.GetString(ms.ToArray());
                                }
                            }
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        public int Encrypt(string src, string dest, int[] columns, Predicate<string> action)
        {
            return Encrypt(src, dest, true, columns, action);
        }

        public int Decrypt(string src, string dest, int[] columns, Predicate<string> action)
        {
            return Decrypt(src, dest, true, columns, action);
        }

        public int Encrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {
#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateEncryptor();
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                        {
                                            byte[] _bytes = Encoding.UTF8.GetBytes(_reader[index].ToString());
                                            if (_bytes.Length == 0)
                                                continue;
                                            cs.Write(_bytes, 0, _bytes.Length);
                                            cs.FlushFinalBlock();
                                            byte[] bytes = (byte[])ms.ToArray();
                                            objs[index] = Convert.ToBase64String(bytes);
                                        }
                                    }
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public int Decrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {

#if CSP
            using (AesCryptoServiceProvider des = new AesCryptoServiceProvider())
#else
            using (AesManaged des = new AesManaged())
#endif
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateDecryptor();
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                        {
                                            byte[] _bytes = Convert.FromBase64String(_reader[index].ToString());
                                            if (_bytes.Length == 0)
                                                continue;
                                            cs.Write(_bytes, 0, _bytes.Length);
                                            cs.FlushFinalBlock();
                                            objs[index] = Encoding.UTF8.GetString(ms.ToArray());
                                        }
                                    }
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public void GeneralKeyIV(string keyStr, out byte[] key, out byte[] iv)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(keyStr);
            key = SHA256Managed.Create().ComputeHash(bytes);
            iv = MD5.Create().ComputeHash(bytes);
        }
    }
}

三、DES

using MY.Cipher.Csv;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;

namespace MY.Cipher
{
    public class DESCode : ICipher
    {
        public string Key { get; set; }

        public string Encrypt(string val)
        {
            if (string.IsNullOrEmpty(val))
                return null;
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] inputByteArray = Encoding.UTF8.GetBytes(val);
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                        byte[] bytes = (byte[])ms.ToArray();
                        return Convert.ToBase64String(bytes);
                    }
                }
            }
        }

        public string Decrypt(string val)
        {
            if (string.IsNullOrEmpty(val))
                return null;
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] inputByteArray = Convert.FromBase64String(val);
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                using (MemoryStream ms = new MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(inputByteArray, 0, inputByteArray.Length);
                        cs.FlushFinalBlock();
                        return Encoding.UTF8.GetString(ms.ToArray());
                    }
                }
            }
        }

        public DataTable Encrypt(DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateEncryptor();
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            using (MemoryStream ms = new MemoryStream())
                            {
                                using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                {
                                    byte[] src = Encoding.UTF8.GetBytes(objs[index].ToString());
                                    if (src.Length == 0)
                                        continue;
                                    cs.Write(src, 0, src.Length);
                                    cs.FlushFinalBlock();
                                    byte[] bytes = (byte[])ms.ToArray();
                                    objs[index] = Convert.ToBase64String(bytes);
                                }
                            }
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        public DataTable Decrypt(DataTable dt, int[] columnIndexs)
        {
            if (dt == null)
                return null;
            DataTable result = dt.Clone();
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateDecryptor();
                foreach (DataRow dr in dt.Rows)
                {
                    object[] objs = dr.ItemArray;
                    foreach (int index in columnIndexs)
                    {
                        if (objs[index] != null && objs[index] != DBNull.Value)
                        {
                            using (MemoryStream ms = new MemoryStream())
                            {
                                using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                {
                                    byte[] src = Convert.FromBase64String(objs[index].ToString());
                                    if (src.Length == 0)
                                        continue;
                                    cs.Write(src, 0, src.Length);
                                    cs.FlushFinalBlock();
                                    objs[index] = Encoding.UTF8.GetString(ms.ToArray());
                                }
                            }
                        }
                    }
                    result.Rows.Add(objs);
                }
            }
            return result;
        }

        public int Encrypt(string src, string dest, int[] columns, Predicate<string> action)
        {
            return Encrypt(src, dest, true, columns, action);
        }

        public int Decrypt(string src, string dest, int[] columns, Predicate<string> action)
        {
            return Decrypt(src, dest, true, columns, action);
        }

        public int Encrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateEncryptor();
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                        {
                                            byte[] _bytes = Encoding.UTF8.GetBytes(_reader[index].ToString());
                                            if (_bytes.Length == 0)
                                                continue;
                                            cs.Write(_bytes, 0, _bytes.Length);
                                            cs.FlushFinalBlock();
                                            byte[] bytes = (byte[])ms.ToArray();
                                            objs[index] = Convert.ToBase64String(bytes);
                                        }
                                    }
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public int Decrypt(string src, string dest, bool hasHeaders, int[] columns, Predicate<string> action)
        {
            using (DESCryptoServiceProvider des = new DESCryptoServiceProvider())
            {
                byte[] _key;
                byte[] _iv;
                GeneralKeyIV(this.Key, out _key, out _iv);
                des.Key = _key;
                des.IV = _iv;
                ICryptoTransform transform = des.CreateDecryptor();
                using (TextReader reader = new StreamReader(src, Encoding.Default))
                {
                    using (TextWriter writer = new StreamWriter(dest, false, Encoding.Default))
                    {
                        CsvReader _reader = new CsvReader(reader, hasHeaders);
                        if (hasHeaders)
                            writer.WriteLine(string.Join(",", _reader.GetFieldHeaders()));
                        int rowIndex = 0;
                        while (_reader.ReadNextRecord())
                        {
                            if (rowIndex > 0 && rowIndex % 100 == 0 && action != null)
                            {
                                if (!action(string.Format("正在處理第{0}行...", rowIndex)))
                                    break;
                            }
                            string[] objs = new string[_reader.FieldCount];
                            for (int index = 0; index < objs.Length; index++)
                            {
                                if (_reader[index] != null && Array.Exists(columns, (column) => { return Convert.ToInt32(column) == index; }))
                                {
                                    using (MemoryStream ms = new MemoryStream())
                                    {
                                        using (CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write))
                                        {
                                            byte[] _bytes = Convert.FromBase64String(_reader[index].ToString());
                                            if (_bytes.Length == 0)
                                                continue;
                                            cs.Write(_bytes, 0, _bytes.Length);
                                            cs.FlushFinalBlock();
                                            objs[index] = Encoding.UTF8.GetString(ms.ToArray());
                                        }
                                    }
                                }
                                else
                                    objs[index] = _reader[index];
                            }
                            writer.WriteLine(string.Join(",", objs));
                            rowIndex++;
                        }
                        reader.Close();
                        writer.Close();
                        return rowIndex;
                    }
                }
            }
        }

        public void GeneralKeyIV(string keyStr, out byte[] key, out byte[] iv)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(keyStr);
            byte[] _key = SHA1.Create().ComputeHash(bytes);
            key = new byte[8];
            iv = new byte[8];
            for (int i = 0; i < 8; i++)
            {
                iv[i] = _key[i];
                key[i] = _key[i];
            }
        }
    }
}