C# 加解密算法

最新推荐文章于 2024-03-14 17:44:35 发布
转载 最新推荐文章于 2024-03-14 17:44:35 发布 · 488 阅读 · 2 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/xueyk/articles/10947874.html
文章标签：

#数据结构与算法 #ui

本文深入讲解了加密解密算法在日常生活中的广泛应用，包括保密性、数据完整性和身份验证等核心功能。介绍了私钥加密（对称加密）、公钥加密（不对称加密）、加密签名和加密哈希的基本原理，并详细列举了.NET Framework提供的多种加密类库。

本文转载自Smallbyte：https://www.cnblogs.com/zhanqun/p/4432304.html

加密解密算法目前已经应用到我们生活中的各个方面

加密用于达到以下目的：

  • 保密性：帮助保护用户的标识或数据不被读取。

  • 数据完整性：帮助保护数据不被更改。

  • 身份验证：确保数据发自特定的一方。

  • 不可否认性：防止特定的一方否认发送过消息。

为了达到这些目的，我们可以使用以下做法：

私钥加密（对称加密）

对数据执行转换，使第三方无法读取该数据。 此类型的加密使用单个共享的机密密钥来加密和解密数据。

公钥加密（不对称加密）

对数据执行转换，使第三方无法读取该数据。 此类加密使用公钥/私钥对来加密和解密数据。

加密签名

通过创建对特定方唯一的数字签名来帮助验证数据是否发自特定方。 此过程还使用哈希函数。

加密哈希

将数据从任意长度映射为定长字节序列。 哈希在统计上是唯一的；不同的双字节序列不会哈希为同一个值。

.NET Framework 提供了以下类来实现私钥加密算法：

.NET Framework 提供了以下类来实现公钥加密算法：

.NET Framework 提供了以下类来实现数字签名算法：

.NET Framework 提供的以下类实现了哈希算法：

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类；

1、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);
    }
}
复制代码

 

2、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);
        }
    }
}
复制代码

3、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];
            }
        }
    }
}
复制代码

 

转载于:https://www.cnblogs.com/xueyk/articles/10947874.html

aoye6095
关注
C#加解密算法
weixin_44845699的博客
02-08 158
【代码】C#加解密算法。
一个简单的字符串加密解密算法（C#）
06-28
一个简单的字符串加密解密算法，使用C#语言实现。。。
C# 加密解密算法 .
weixin_33721344的博客
11-06 115
1 、方法一 (不可逆加密) public string EncryptPassword( string PasswordString, string PasswordFormat ) { string encryptPassword = null ; if (PasswordFormat = " SHA1 " ) { ...
C#加密解密算法
青城的专栏
09-13 1470
/*************************字符串加密算法***********************/public string EncryptString(string str)  {   char[] Base64Code=new char[]{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q
C#加解密算法源码打包下载
02-22
算法： Crypto Paddings ISO 10125-2 Padding ISO 7816-4 Padding X9.32 Padding TBC Padding PKCS7 Padding Digests MD2 Digest 数据压缩： Burrows-Wheeler transform Huffman Compressor Shannon-Fano Compressor...
C# 加解密算法合集封装类
06-11
本篇文章将详细探讨在C#编程环境中，针对标题所提及的几种加解密算法的实现和封装，包括SHA系列（SHA1、SHA256、SHA512）、3DES、RSA以及Base64编码。 首先，SHA（Secure Hash Algorithm）是一系列散列函数，用于...
C# 加密解密算法
08-23
C# 加密解密算法
基于C#加密解密算法的实现
11-16
创建一个`Aes`对象，设置密钥和初始向量，然后使用`CreateEncryptor`和`CreateDecryptor`方法进行加解密操作。 接下来是MD5，全称为Message-Digest Algorithm 5，是一种广泛使用的哈希函数，用于生成数据的固定长度...
C#中实现加密和解密算法
11-15
在C#中，实现非对称加密和对称加密的样例程序。包含MD5，SHA1，SHA256，SHA512等非对称算法和DES，AES和RSA，ECC等算法的样例，供学习。
古典加密算法之置换密码和代换密码
12-24
自己写的 呵呵 希望支持 信息安全 古典加密算法------置换密码 古典加密算法------代换密码------乘数密码
ripemd160实现源码
07-07
hash算法ripemd160，c语言编写
Diffie_Hellman算法的C#实现
06-17
首先实现了一个大数的加减乘除及指数模的类库，其次用界面的形式展示Diffie—Hellman密钥交换协议的实现过程。
C#写Des加密解密算法
h1028962069的专栏
04-21 5084
马上就要实习了，求大大们介绍工作。QQ：1028962069我只写关键代码。 界面如下 类using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Security.Cryptography; using System.IO; namespace DES加密
古典密码-换位加密、解密（c++实现）
NWhite_PIG的博客
09-26 4302
换位密码加密解密简介代码运行结果： 简介 简单介绍下我写的换位密码：通过输入英文密钥进行加密和解密，使用密钥长度作为明文的列宽输出明文矩阵，对明文按照字母表进行排序，明文对应变换进行加密。比如密钥computer {c o m p u t e r} {0 1 2 3 4 5 6 7}按照数组下标从0开始 排序后变为 {c e m o p r t u} {0 6 2 1 3 7 5 4} 废话少说，...
C#加密和解密、哈希
最新发布
qq_42497776的博客
03-14 2019
C#中加密、哈希和签名数据
周期置换加密算法用c语言实现,古典密码实验报告.doc
weixin_36484519的博客
05-25 1146
...哈尔滨工程大学实 验 报 告实 验 名 称： 古典密码算法班 级：学 号：姓 名：实 验 时 间： 2014年4月成 绩：指 导 教 师：实验室名称：哈尔滨工程大学实验室与资产管理处 制一、实验名称 古典密码算法实验目的通过编程实现经典的代替密码算法和置换密码，包括移位密码、维吉尼...
几种古典密码学算法的C实现
始梦的少年的博客
10-11 2025
代码实现 #include <stdio.h> #include <iostream> #include <stdlib.h> #include <string> #include <string.h> using namespace std; //凯撒密码 char kaisa_e() { char passwd[100],encrypted[100]; int i,j,k,t,move; printf("输入要
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值