RSA非对称加密算法在C#中的实现（.NET/C#实现RSA非对称加密算法）

最新推荐文章于 2024-08-24 10:40:42 发布
最新推荐文章于 2024-08-24 10:40:42 发布
阅读量2k 收藏 5
点赞数 2
分类专栏： ASP.NET C# .NET 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1037949156/article/details/109642128
版权
ASP.NET 同时被 3 个专栏收录
12 篇文章 1 订阅
订阅专栏
C#
5 篇文章 0 订阅
订阅专栏
.NET
5 篇文章 0 订阅
订阅专栏 
using Cari.Safety.SSO.Interface;
using System;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Encodings;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.X509;
using System.Text;
using System.ComponentModel.Composition;

namespace Cari.Safety.SSO.Tool
{
    /// <summary>
    /// Summary: RSA非对称加密算法实现
    /// API详情请参考: http://www.bouncycastle.org/csharp/
    /// 密钥默认长度为1024（应该够用吧），可以解密的源字符串最大长度为：密钥长度/8-11，这里就是1024/8-11=117
    /// Author: Lee Liu
    /// Date: 20181031
    /// </summary>
    [Export("RSA",typeof(IRSAHelper))]
    public class RSA : IRSAHelper
    {
        //设定编码方式为UTF-8
        private static Encoding Encoding_UTF8 = Encoding.UTF8;

        //全局变量: RSA公私密钥对
        private RSAKEY keyPair;

        //RSA引用，这里用作单例模式使用。
        private static RSA rsa;

        #region 私有化无参构造方法
        private RSA()
        {
            keyPair = GetKey();
        }
        #endregion

        #region 单例模式，获取RSA类的实例
        /// <summary>
        /// 单例模式，获取RSA类的实例
        /// </summary>
        /// <returns></returns>
        public static RSA GetRSAInstance()
        {
            if (rsa != null)
            {
                return rsa;
            }
            else
            {
                return new RSA();
            }
        }
        #endregion

        #region 实现IRSAHelper接口
        public string DecryptViaPrivateKey(string data, string privateKey)
        {
            return DecryptByPrivateKey(data, privateKey);
        }

        public string DecryptViaPublicKey(string data, string publicKey)
        {
            return DecryptByPublicKey(data, publicKey);
        }

        public string EncryptViaPrivateKey(string data, string privateKey)
        {
            return EncryptByPrivateKey(data, privateKey);
        }

        public string EncryptViaPublicKey(string data, string publicKey)
        {
            return EncryptByPublicKey(data, publicKey);
        }

        public string GetPrivateKey()
        {
            return keyPair.PrivateKey;
        }

        public string GetPublicKey()
        {
            return keyPair.PublicKey;
        }

        public void SetPrivateKey(string privateKey)
        {
            keyPair.PrivateKey = privateKey;
        }

        public void SetPublicKey(string publicKey)
        {
            keyPair.PublicKey = publicKey;
        }
        #endregion

        #region Key Pair结构体
        /// <summary>
        /// KEY 结构体
        /// </summary>
        public struct RSAKEY
        {
            /// <summary>
            /// 公钥
            /// </summary>
            public string PublicKey
            {
                get;
                set;
            }
            /// <summary>
            /// 私钥
            /// </summary>
            public string PrivateKey
            {
                get;
                set;
            }
        }
        #endregion

        #region 获取公私钥
        private RSAKEY GetKey()
        {
            //RSA密钥对的构造器  
            RsaKeyPairGenerator keyGenerator = new RsaKeyPairGenerator();

            //RSA密钥构造器的参数  
            RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
                Org.BouncyCastle.Math.BigInteger.ValueOf(3),
                new Org.BouncyCastle.Security.SecureRandom(),
                1024,   //密钥长度  
                25);
            //用参数初始化密钥构造器  
            keyGenerator.Init(param);
            //产生密钥对  
            AsymmetricCipherKeyPair keyPair = keyGenerator.GenerateKeyPair();
            //获取公钥和密钥  
            AsymmetricKeyParameter publicKey = keyPair.Public;
            AsymmetricKeyParameter privateKey = keyPair.Private;

            SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(publicKey);
            PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);

            Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();

            byte[] publicInfoByte = asn1ObjectPublic.GetEncoded("UTF-8");
            Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
            byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded("UTF-8");

            RSAKEY item = new RSAKEY()
            {
                PublicKey = Convert.ToBase64String(publicInfoByte),
                PrivateKey = Convert.ToBase64String(privateInfoByte)
            };
            return item;
        }
        #endregion

        #region 获取公私钥参数
        /// <summary>
        /// 获取公钥参数
        /// </summary>
        /// <param name="keyBase64">公钥</param>
        /// <returns></returns>
        private AsymmetricKeyParameter GetPublicKeyParameter(string keyBase64)
        {
            keyBase64 = keyBase64.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] publicInfoByte = Convert.FromBase64String(keyBase64);
            Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入   
            AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
            return pubKey;
        }

        /// <summary>
        /// 获取私钥参数
        /// </summary>
        /// <param name="keyBase64">私钥</param>
        /// <returns></returns>
        private AsymmetricKeyParameter GetPrivateKeyParameter(string keyBase64)
        {
            keyBase64 = keyBase64.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] privateInfoByte = Convert.FromBase64String(keyBase64);
            // Asn1Object priKeyObj = Asn1Object.FromByteArray(privateInfoByte);//这里也可以从流中读取，从本地导入   
            // PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
            AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
            return priKey;
        }
        #endregion

        #region 使用私钥加密内容
        /// <summary>
        /// 私钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="privateKey">私钥（Base64后的）</param>
        /// <returns>返回Base64内容</returns>
        private string EncryptByPrivateKey(string data, string privateKey)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //加密  
            try
            {
                engine.Init(true, GetPrivateKeyParameter(privateKey));
                byte[] byteData = Encoding_UTF8.GetBytes(data);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(ResultData);
                //Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region 使用私钥解密内容
        /// <summary>
        /// 私钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="privateKey">私钥（Base64编码后的）</param>
        /// <returns>返回明文</returns>
        private string DecryptByPrivateKey(string data, string privateKey)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //解密  
            try
            {
                engine.Init(false, GetPrivateKeyParameter(privateKey));
                byte[] byteData = Convert.FromBase64String(data);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Encoding_UTF8.GetString(ResultData);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region 使用公钥加密内容
        /// <summary>
        /// 公钥加密
        /// </summary>
        /// <param name="data">加密内容</param>
        /// <param name="publicKey">公钥（Base64编码后的）</param>
        /// <returns>返回Base64内容</returns>
        private string EncryptByPublicKey(string data, string publicKey)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //加密  
            try
            {
                engine.Init(true, GetPublicKeyParameter(publicKey));
                byte[] byteData = Encoding_UTF8.GetBytes(data);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(ResultData);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region 使用公钥解密内容
        /// <summary>
        /// 公钥解密
        /// </summary>
        /// <param name="data">待解密的内容</param>
        /// <param name="publicKey">公钥（Base64编码后的）</param>
        /// <returns>返回明文</returns>
        private string DecryptByPublicKey(string data, string publicKey)
        {
            data = data.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());

            //解密  
            try
            {
                engine.Init(false, GetPublicKeyParameter(publicKey));
                byte[] byteData = Convert.FromBase64String(data);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Encoding_UTF8.GetString(ResultData);

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion
    }
}

 

对应的IRSAHelper接口，这里主要是MEF依赖注入用，所以写了个接口：

namespace Cari.Safety.SSO.Interface
{
    /// <summary>
    /// Summary: RSAHelper接口
    /// Author: Lee Liu
    /// Date: 20181031
    /// </summary>
    public interface IRSAHelper
    {
        /// <summary>
        /// 使用私钥解密
        /// </summary>
        /// <param name="data">要解密的数据</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>明文</returns>
        string DecryptViaPrivateKey(string data, string privateKey);

        /// <summary>
        /// 使用公钥解密
        /// </summary>
        /// <param name="data">要解密的数据</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>明文</returns>
        string DecryptViaPublicKey(string data, string publicKey);

        /// <summary>
        /// 使用私钥加密
        /// </summary>
        /// <param name="data">要加密的数据</param>
        /// <param name="privateKey">私钥</param>
        /// <returns>密文</returns>
        string EncryptViaPrivateKey(string data, string privateKey);

        /// <summary>
        /// 使用公钥加密
        /// </summary>
        /// <param name="data">要加密的数据</param>
        /// <param name="publicKey">公钥</param>
        /// <returns>密文</returns>
        string EncryptViaPublicKey(string data, string publicKey);

        /// <summary>
        /// 获取公钥
        /// </summary>
        /// <returns>返回公钥字符串</returns>
        string GetPublicKey();

        /// <summary>
        /// 获取私钥
        /// </summary>
        /// <returns>返回私钥字符串</returns>
        string GetPrivateKey();

        /// <summary>
        /// 设置公钥
        /// </summary>
        /// <param name="publicKey">公钥</param>
        void SetPublicKey(string publicKey);

        /// <summary>
        /// 设置私钥
        /// </summary>
        /// <param name="privateKey">私钥</param>
        void SetPrivateKey(string privateKey);
    }
}

 

风生晚凉
关注
专栏目录
C#实现简单的RSA非对称加密算法示例
08-29
主要介绍了C#实现简单的RSA非对称加密算法,结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧,需要的朋友可以参考下
整合一个基于c#的RSA私钥加密公钥解密的Helper类,含源码
tangtiantian520的专栏
09-16 5632
转自：http://www.cnblogs.com/yyl8781697/archive/2013/04/28/RSA.html  最近在搞单点登录的设计,在设计中需要一个Token令牌的加密传输,这个令牌在整个连接单点的各个站中起着连接认证作用,如果被仿造将会有不可预计的损失,但是这个Token是要可逆的.然后我就找.net中的各种加密，各种找。         因为是可逆的,所以像
RSA加密解密算法（C#语言编写）
最新发布
m0_64364052的博客
08-24 1111
在实际应用中，RSA算法的实现需要考虑很多额外的安全因素，包括但不限于密钥长度、随机数生成、错误处理、内存安全等。请注意，这个示例仅用于教学目的，不应用于生产环境，因为它没有使用足够安全的随机数生成器，也没有处理各种边缘情况。下面是一个非常基础的RSA算法实现示例，使用了简化的数学运算和固定大小的密钥。分享好用的工具软件，条理清晰资源多多🍗，欢迎来访🐇。校内布置的剪短算法练习，帮助你更快爱上这一学科 🌺。有全面的网络基础知识分享，欢迎来访🙉。🙋 我的专栏推荐 🙋。因此，推荐使用成熟的。
C#非对称加密程序
aome1470的博客
03-24 150
using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; using System.IO; using System.Text; using System.Security...
非对称加密RSA的C#实现
weixin_30628801的博客
12-09 225
1.对称加密算法 对称加密是最快速、最简单的一种加密方式，加密（encryption）与解密（decryption）用的是同样的密钥（secret key）。 对称加密有很多种算法，由于它效率很高，所以被广泛使用在很多加密协议的核心当中。对称加密通常使用的是相对较小的密钥， 一般小于256 bit。因为密钥越大，加密越强，但加密与解密的过程越慢。如果你只用1 bit来做这个密钥，那...
C# RSA非对称加密，解密
LAI515的博客
05-24 815
https://www.cnblogs.com/taiyonghai/p/6150353.html
RSA非对称加密算法
02-14
在 RSA 非对称加密算法中，公开密钥用于加密数据，而私密密钥用于解密数据。加密过程是通过公开密钥对数据进行加密，得到密文，然后服务器使用私密密钥将密文解密，获取原始数据。这种机制保证了数据的安全，因为...
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
本实验报告主要涉及两种加密算法：对称加密算法DES（Data Encryption Standard）和非对称加密算法RSA。实验旨在帮助学生深入理解这两种算法的基本原理，并通过Python编程实现加密和解密过程。 ### **对称加密算法...
rsa.rar_rsa matlab实现_rsa加密_加密解密_对称加密算法_非对称加密
07-15
非对称的加密算法RSA的matlab实现，包含加密函数和解密函数，功能齐全！
rsa算法 c#语言,C#实现简单的RSA非对称加密算法示例
weixin_39616798的博客
05-25 664
本文实例讲述了C#实现简单的RSA非对称加密算法。分享给大家供大家参考，具体如下：界面控件namespace RSA算法{partial class Form1{/// /// 必需的设计器变量。/// private System.ComponentModel.IContainer components = null;/// /// 清理所有正在使用的资源。/// /// 如果应释放托管资源，为...
C# 非对称加密
12-20
C# 非对称 加密 密钥生成 文件加密 文件解密
c# 非对称加密解密
06-28
自己编写的c# RSA 加密解密程序 还有数字签名！
VB.NET实现RSA加密算法,源代码
05-20
VB.NET实现的RSA加密算法,全部程序提供，VS2005环境下运行有效。生成有.exe格式
RsaHelper.cs for C# 非对称加密RSA 附调用方法及测试key
03-23 2652
public static class RsaHelper { public static byte[] Encrypte(byte[] source, string publicKeyXml, int keyLength, bool oaep) { publicKeyXml = "your key"; using (RSACryptoServiceProvider rsa = new RSACryptoServiceP...
C#RSA非对称加解密
weixin_33949359的博客
07-28 64
1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Web; 5 using System.Security.Cryptography; 6 using System.Text; 7 using System.Globalizati...
C#---非对称加密的一个程序
zgqtxwd的专栏
04-24 221
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
C#—非对称加密：加密文件
zgqtxwd的专栏
04-24 324
<!--google_ad_client = "pub-2947489232296736";/* 728x15, 创建于 08-4-23MSDN */google_ad_slot = "3624277373";google_ad_width = 728;google_ad_height = 15;//--><script type="text/javascript"
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值