RSA加密的使用

一、知识点

对称加密的代表DES加密
缺陷：
　　1、由于加解密使用相同的密钥，那么这个密钥最少要保存在两个地方，如果加密的数据要发给多人，那么就会有更多的人知道密钥，这大大增加了密钥泄露的风险
　　2、密钥需要由发送方传递给接收方，如何保证传递安全

 

非对称加密，就是指加密和解密使用不同的密钥的一类加密算法
这类加密算法通常有两个密钥A和B，使用密钥A加密数据得到的密文，只有密钥B可以进行解密操作（即使密钥A也无法解密），相反，使用了密钥B加密数据得到的密文，只有密钥A可以解密。
这两个密钥分别称为私钥和公钥，顾名思义，私钥就是你个人保留，不能公开的密钥，而公钥则是公开给加解密操作的另一方的。
用途：
　　1、数据加密。在非对称加密中，公钥的公开不仅仅指对接收方的公开，而是指这个密钥彻底的公开，所以使用的时候应该由接收方保存私钥，传递的数据使用公钥进行加密，由接收方使用私钥进行解密。
　　2、用来进行数字签名。使用消息摘要进行数字签名
　　　　Step 1：发送方先产生成一对密钥，并将公钥公开给接收方；
　　　　Step 2：发送方将数据D进行消息摘要，得到Q；
　　　　Step 3：用私钥对Q进行加密得到密文MQ，然后将数据D和密文MQ一起发送给接收方；
　　　　Step 4：接收方得到数据D和密文MQ后，用公钥将密文MQ解密得到q1；
　　　　Step 5：接收方使用相同的算法对数据D进行消息摘要，得到q2；
　　　　Step 6：比较q1和q2，相等则证明D是由发送方发送的，且没有被修改过。
缺陷：
　　1、非对称加密的算法非常耗时并且密文的长度要大于明文的长度，直接加密系统的开销非常大
　　2、RSA无法对超过117字节的数据进行加密

消息摘要。
所谓的消息摘要就是通过一种单向算法计算出来的唯一对应一个文件或数据的固定长度的值，也被称作数字摘要。根据不同的算法，消息摘要的长度一般为128位或160位。常用的消息摘要的算法有MD5和SHA1。
我们可以通过对一个文件的消息摘要进行签名来代替对它本身进行签名。并且，我们还可以通过验证消息摘要，来确定发送的数据是否完整或曾经被修改过。

 

二、RSA相关封装代码

using System;
using System.Security.Cryptography;
using System.Text;

namespace Util
{
    /// <summary>
    /// RSA加密解密及RSA签名和验证
    /// </summary>
    public static class RSACryption
    {

        #region RSA 加密解密

        /// <summary>
        /// RSA 的密钥产生 产生私钥 和公钥
        /// </summary>
        /// <param name="xmlPriKeys">私钥</param>
        /// <param name="xmlPubKeys">公钥</param>
        public static void RSAKey(out string xmlPriKeys, out string xmlPubKeys)
        {
            System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

            xmlPriKeys = rsa.ToXmlString(true);    //将密钥导出为一个xml格式的string,true导出私钥，false不导出
            xmlPubKeys = rsa.ToXmlString(false);
        }


        #region RSA的加密函数
        /// <summary>
        /// 对string类型的数据进行RSA的加密函数，该加密方式有 长度 限制的！！
        /// </summary>
        /// <param name="xmlPublicKey">XML的形式的公钥</param>
        /// <param name="m_strEncryptString">私钥</param>
        /// <returns>string类型的加密结果</returns>
        public static string RSAEncrypt(string xmlPublicKey, string m_strEncryptString)
        {
            byte[] PlainTextBArray;
            byte[] CypherTextBArray;
            string Result;

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPublicKey);

            PlainTextBArray = (new UnicodeEncoding()).GetBytes(m_strEncryptString);
            CypherTextBArray = rsa.Encrypt(PlainTextBArray, false);

            Result = Convert.ToBase64String(CypherTextBArray);
            return Result;

        }


        /// <summary>
        /// 对byte类型数组进行加密，该加密方式有 长度 限制的！！
        /// </summary>
        /// <param name="xmlPublicKey">XML的形式的公钥</param>
        /// <param name="EncryptString">需要加密的byte类型的数组</param>
        /// <returns>string类型的加密结果</returns>
        public static string RSAEncrypt(string xmlPublicKey, byte[] EncryptString)
        {

            byte[] CypherTextBArray;
            string Result;

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPublicKey);

            CypherTextBArray = rsa.Encrypt(EncryptString, false);

            Result = Convert.ToBase64String(CypherTextBArray);
            return Result;

        }
        #endregion


        #region RSA的解密函数
        /// <summary>
        /// RSA的解密函数
        /// </summary>
        /// <param name="xmlPrivateKey">xml类型的私钥</param>
        /// <param name="m_strDecryptString">string类型的密文</param>
        /// <returns></returns>
        public static string RSADecrypt(string xmlPrivateKey, string m_strDecryptString)
        {
            byte[] PlainTextBArray;
            byte[] DypherTextBArray;
            string Result;
            System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPrivateKey);
            PlainTextBArray = Convert.FromBase64String(m_strDecryptString);
            DypherTextBArray = rsa.Decrypt(PlainTextBArray, false);
            Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
            return Result;

        }


        /// <summary>
        /// RSA的解密函数
        /// </summary>
        /// <param name="xmlPrivateKey">xml类型的私钥</param>
        /// <param name="DecryptString">byte类型数组的密文</param>
        /// <returns></returns>
        public static string RSADecrypt(string xmlPrivateKey, byte[] DecryptString)
        {
            byte[] DypherTextBArray;
            string Result;
            System.Security.Cryptography.RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
            rsa.FromXmlString(xmlPrivateKey);
            DypherTextBArray = rsa.Decrypt(DecryptString, false);
            Result = (new UnicodeEncoding()).GetString(DypherTextBArray);
            return Result;

        }
        #endregion


        #endregion



        #region RSA数字签名

        #region 获取Hash描述表

        //获取Hash描述表
        public static bool GetHash(string m_strSource, ref byte[] HashData)
        {
            //从字符串中取得Hash描述
            byte[] Buffer;
            System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
            Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(m_strSource);
            HashData = MD5.ComputeHash(Buffer);

            return true;
        }

        //获取Hash描述表
        public static bool GetHash(string m_strSource, ref string strHashData)
        {
            //从字符串中取得Hash描述
            byte[] Buffer;
            byte[] HashData;
            System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
            Buffer = System.Text.Encoding.GetEncoding("GB2312").GetBytes(m_strSource);
            HashData = MD5.ComputeHash(Buffer);

            strHashData = Convert.ToBase64String(HashData);
            return true;
        }

        //获取Hash描述表
        public static bool GetHash(System.IO.FileStream objFile, ref byte[] HashData)
        {
            //从文件中取得Hash描述
            System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
            HashData = MD5.ComputeHash(objFile);
            objFile.Close();

            return true;
        }

        //获取Hash描述表
        public static bool GetHash(System.IO.FileStream objFile, ref string strHashData)
        {
            //从文件中取得Hash描述
            byte[] HashData;
            System.Security.Cryptography.HashAlgorithm MD5 = System.Security.Cryptography.HashAlgorithm.Create("MD5");
            HashData = MD5.ComputeHash(objFile);
            objFile.Close();

            strHashData = Convert.ToBase64String(HashData);

            return true;
        }

        #endregion



        #region RSA签名
        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="p_strKeyPrivate"></param>
        /// <param name="HashbyteSignature"></param>
        /// <param name="EncryptedSignatureData"></param>
        /// <returns></returns>
        public static bool SignatureFormatter(string p_strKeyPrivate, byte[] HashbyteSignature, ref byte[] EncryptedSignatureData)
        {
            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPrivate);
            System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
            //设置签名的算法为MD5
            RSAFormatter.SetHashAlgorithm("MD5");
            //执行签名
            EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

            return true;

        }

        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="p_strKeyPrivate"></param>
        /// <param name="HashbyteSignature"></param>
        /// <param name="m_strEncryptedSignatureData"></param>
        /// <returns></returns>
        public static bool SignatureFormatter(string p_strKeyPrivate, byte[] HashbyteSignature, ref string m_strEncryptedSignatureData)
        {

            byte[] EncryptedSignatureData;

            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPrivate);
            System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
            //设置签名的算法为MD5
            RSAFormatter.SetHashAlgorithm("MD5");
            //执行签名
            EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

            m_strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);

            return true;

        }

        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="p_strKeyPrivate"></param>
        /// <param name="m_strHashbyteSignature"></param>
        /// <param name="EncryptedSignatureData"></param>
        /// <returns></returns>
        public static bool SignatureFormatter(string p_strKeyPrivate, string m_strHashbyteSignature, ref byte[] EncryptedSignatureData)
        {

            byte[] HashbyteSignature;

            HashbyteSignature = Convert.FromBase64String(m_strHashbyteSignature);
            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPrivate);
            System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
            //设置签名的算法为MD5
            RSAFormatter.SetHashAlgorithm("MD5");
            //执行签名
            EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

            return true;

        }

        /// <summary>
        /// RSA签名
        /// </summary>
        /// <param name="p_strKeyPrivate"></param>
        /// <param name="m_strHashbyteSignature"></param>
        /// <param name="m_strEncryptedSignatureData"></param>
        /// <returns></returns>
        public static bool SignatureFormatter(string p_strKeyPrivate, string m_strHashbyteSignature, ref string m_strEncryptedSignatureData)
        {

            byte[] HashbyteSignature;
            byte[] EncryptedSignatureData;

            HashbyteSignature = Convert.FromBase64String(m_strHashbyteSignature);
            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPrivate);
            System.Security.Cryptography.RSAPKCS1SignatureFormatter RSAFormatter = new System.Security.Cryptography.RSAPKCS1SignatureFormatter(RSA);
            //设置签名的算法为MD5
            RSAFormatter.SetHashAlgorithm("MD5");
            //执行签名
            EncryptedSignatureData = RSAFormatter.CreateSignature(HashbyteSignature);

            m_strEncryptedSignatureData = Convert.ToBase64String(EncryptedSignatureData);

            return true;

        }
        #endregion



        #region RSA 签名验证

        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="p_strKeyPublic"></param>
        /// <param name="HashbyteDeformatter"></param>
        /// <param name="DeformatterData"></param>
        /// <returns></returns>
        public static bool SignatureDeformatter(string p_strKeyPublic, byte[] HashbyteDeformatter, byte[] DeformatterData)
        {

            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPublic);
            System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5
            RSADeformatter.SetHashAlgorithm("MD5");

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }

        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="p_strKeyPublic"></param>
        /// <param name="p_strHashbyteDeformatter"></param>
        /// <param name="DeformatterData"></param>
        /// <returns></returns>
        public static bool SignatureDeformatter(string p_strKeyPublic, string p_strHashbyteDeformatter, byte[] DeformatterData)
        {

            byte[] HashbyteDeformatter;

            HashbyteDeformatter = Convert.FromBase64String(p_strHashbyteDeformatter);

            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPublic);
            System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5
            RSADeformatter.SetHashAlgorithm("MD5");

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }


        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="p_strKeyPublic"></param>
        /// <param name="HashbyteDeformatter"></param>
        /// <param name="p_strDeformatterData"></param>
        /// <returns></returns>
        public static bool SignatureDeformatter(string p_strKeyPublic, byte[] HashbyteDeformatter, string p_strDeformatterData)
        {

            byte[] DeformatterData;

            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPublic);
            System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5
            RSADeformatter.SetHashAlgorithm("MD5");

            DeformatterData = Convert.FromBase64String(p_strDeformatterData);

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }


        /// <summary>
        /// RSA 签名验证
        /// </summary>
        /// <param name="p_strKeyPublic"></param>
        /// <param name="p_strHashbyteDeformatter"></param>
        /// <param name="p_strDeformatterData"></param>
        /// <returns></returns>
        public static bool SignatureDeformatter(string p_strKeyPublic, string p_strHashbyteDeformatter, string p_strDeformatterData)
        {

            byte[] DeformatterData;
            byte[] HashbyteDeformatter;

            HashbyteDeformatter = Convert.FromBase64String(p_strHashbyteDeformatter);
            System.Security.Cryptography.RSACryptoServiceProvider RSA = new System.Security.Cryptography.RSACryptoServiceProvider();

            RSA.FromXmlString(p_strKeyPublic);
            System.Security.Cryptography.RSAPKCS1SignatureDeformatter RSADeformatter = new System.Security.Cryptography.RSAPKCS1SignatureDeformatter(RSA);
            //指定解密的时候HASH算法为MD5
            RSADeformatter.SetHashAlgorithm("MD5");

            DeformatterData = Convert.FromBase64String(p_strDeformatterData);

            if (RSADeformatter.VerifySignature(HashbyteDeformatter, DeformatterData))
            {
                return true;
            }
            else
            {
                return false;
            }

        }


        #endregion


        #endregion

    }
}

 

三、RSAKey首先提出了需要生成对应的公钥和私钥，那么就涉及到保存，对应的保存的三种方法

1.将密钥导出保存为本地文件（出于安全性考虑，不建议使用这种方法保存私钥，如果使用，请在密钥导出的时候只导出公钥）

RSACryptoServiceProvider对象提供了一个ToXmlString(bool includePrivateParameters)方法，我们可以使用此方法将密钥导出为一个xml格式的string，然后将其保存到一个文件中，这个方法的参数为true时会导出私钥，否则不导出私钥。需要的时候，我们可以使用FromXmlString(string xmlString)方法，将保存的密钥信息加载到RSACryptoServiceProvider对象中。

/// <summary>
/// 将公钥保存到文件中
/// </summary>
/// <param name="rsa"></param>
/// <param name="fileName"></param>
static void SaveKey2File(RSACryptoServiceProvider rsa, string fileName)
{
    FileStream fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);

    string key = rsa.ToXmlString(false);    //公钥
    fs.Write(Encoding.UTF8.GetBytes(key), 0, key.Length);
            
    fs.Close();
    fs.Dispose();
}


/// <summary>
/// 从文件中加载rsa得到秘钥
/// </summary>
/// <param name="rsa"></param>
/// <param name="fileName"></param>
static void LoadKeyFromFile(RSACryptoServiceProvider rsa, string fileName)
{
    FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
            
    byte[] data = new byte[fs.Length];
    fs.Read(data, 0, (int)fs.Length);
            
    fs.Close();
    fs.Dispose();
            
    rsa.FromXmlString(Encoding.UTF8.GetString(data));
}

 

2.将秘钥保存到秘钥容器中

什么是密钥容器（key container）呢？Window系统提供两种密钥库（key store）用来保存密钥（User Key Store和Machine Key Store），而密钥容器就是用来保存密钥的一个单位，每个密钥容器都包含了一组密钥对（公钥和私钥）和一些其它的信息，例如是否允许导出密钥，密钥的种类（Exchange或Signatrue）等等，我们可以通过密钥容器的名称来访问它们。

使用CspParameters对象创建或使用密钥容器：

//实例化CspParameters对象
CspParameters cspPara = new CspParameters();

//指定CspParameters对象实例的名称
cspPara.KeyContainerName = "key_container_test";

//设置密钥类型为Exchange
cspPara.KeyNumber = 1;

//设置密钥容器保存到计算机密钥库（默认为用户密钥库）
cspPara.Flags = CspProviderFlags.UseMachineKeyStore;

//实例化RSA对象的时候，将CspParameters对象作为构造函数的参数传递给RSA对象，
//如果名称为key_container_test的密钥容器不存在，RSA对象会创建这个密钥容器；
//如果名称为key_container_test的密钥容器已经存在，RSA对象会使用这个密钥容器中的密钥进行实例化
RSACryptoServiceProvider rsaPro = new RSACryptoServiceProvider(cspPara);

删除密钥容器：当我们不再需要某个密钥容器的时候，可以使用下面的方法进行删除。

CspParameters cspPara = new CspParameters();

cspPara.KeyContainerName = "key_container_test";
cspPara.Flags = CspProviderFlags.UseMachineKeyStore;
RSACryptoServiceProvider rsaPro = new RSACryptoServiceProvider(cspPara);

//不在密钥库中保存此密钥容器
rsaPro.PersistKeyInCsp = false;

//释放rsaPro占用的所有资源，包括密钥容器。
rsaPro.Clear();

除非知道密钥容器的名称，否则无法从密钥库中提取到这个密钥容器，所以在本机使用的密钥（尤其是私钥）保存在密钥容器中是比较安全的做法。

注：实际当我们实例化一个RSACryptoServiceProvider 对象的时候，如果不指定具体的CspParameters 对象，RSACryptoServiceProvider 对象会生成一个临时的密钥容器，并且在RSACryptoServiceProvider 对象销毁的时候自动删除这个临时的密钥容器。

 

3.使用数字证书

如果你的密钥需要在不同的机器上使用，那么将密钥保存在数字证书中是一个不错的选择。实际上，说将密钥保存在数字证书中并不准确，应该是先生成一个数字证书，然后在使用数字证书中的密钥。

如何生成一个数字证书呢？正式的数字证书需要到CA去申请，当然还要奉上一笔银子。还好我们可以使用.Net SDK提供的MakeCert.exe来生成临时的数字证书。具体如何生成请访问证书创建工具。

.Net中用来访问证书的对象是X509Certificate2，我们可以用它来加载一个数字证书并获得数字证书中的密钥。

如果证书是以文件的形式保存在本地的话，可以用下面的方法加载：

static byte[] EncryptDataByCert(byte[] data)
{
    //实例化一个X509Certificate2对象，并加载证书testCertificate.cer
    X509Certificate2 cert = new X509Certificate2(@"c:	estCertificate.cer");

    //将证书的公钥强制转换成一个RSACryptoServiceProvider对象，然后可以使用这个对象执行加密操作
    RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)cert.PublicKey.Key;
    byte[] enData = rsa.Encrypt(data, false);

    return enData;
}

一般情况下，对于数字证书来说，保存公钥的证书使用.cer做扩展名，而保存了私钥的证书会使用.pfx做扩展名，当我们加载一个私钥的数字证书时，需要提供私钥的保护密码，代码如下：

static string DecryptByCert(byte[] endata)
{
    //实例化一个X509Certificate2对象，并加载证书testCertificate.pfx。
    //由于证书testCertificate.pfx包含私钥，所以需要提供私钥的保护密码（第二个参数）
    X509Certificate2 cert = new X509Certificate2(@"c:	estCertificate.pfx", "123456");

    //将证书testCertificate.pfx的私钥强制转换为一个RSACryptoServiceProvider对象，用于解密操作
    RSACryptoServiceProvider rsa = (RSACryptoServiceProvider)cert.PrivateKey;
    byte[] data = rsa.Decrypt(endata, false);

    return data;
}

如果证书保存在计算机的证书存储区（Certificate Store）中，我们就需要使用另一个对象X509Store来访问证书存储区。根据访问权限，证书存储区分为当前用户（Current User）和本地计算机（Local Machine）两个部分，前者用来保存当前登录的用户所能使用的数字证书，而后者用来保存登录到本机所能使用的数字证书。不管是当前用户还是本地计算机，都包含多个逻辑存储区，它们通过不同的名称来区分，每个逻辑存储区可以保存多个数字证书。更详细的介绍，可以参考证书。具体的访问证书存储区的代码如下：

private X509Certificate2 GetCertificate(string CertName)
{
    //声明X509Store对象，指定存储区的名称和存储区的类型
    //StoreName中定义了系统默认的一些存储区的逻辑名称
    X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
    //以只读的方式打开这个存储区，OpenFlags定义的打开的方式
    store.Open(OpenFlags.ReadOnly);
    //获取这个存储区中的数字证书的集合
    X509Certificate2Collection certCol = store.Certificates;
    //查找满足证书名称的证书并返回
    foreach (X509Certificate2 cert in certCol)
    {
        if (cert.SubjectName.Name == "CN=" + CertName)
        {
            store.Close();
            return cert;
        }
    }
    store.Close();
    return null;
}

我们也可以通过X509Certificate2Collection 对象在当前存储区中添加删除证书，详细的信息可以参考证书存储区。