RSA不限长度非对称加密解密C#

本文涉及的产品
密钥管理服务KMS,1000个密钥,100个凭据,1个月
简介: RSA 分段加解密【解决“不正确的长度”的异常】   RSA 是常用的非对称加密算法。最近使用时却出现了“不正确的长度”的异常,研究发现是由于待加密的数据超长所致。   .NET Framework 中提供的 RSA 算法规定:   待加密的字节数不能超过密钥的长度值除以 8 再减去 11(即:RSACryptoServiceProvider.KeySize / 8 - 11),而加密后得到密文的字节数,正好是密钥的长度值除以 8(即:RSACryptoServiceProvider.KeySize / 8)。

  RSA 是常用的非对称加密算法。最近使用时却出现了“不正确的长度”的异常,研究发现是由于待加密的数据超长所致。

  .NET Framework 中提供的 RSA 算法规定:

  待加密的字节数不能超过密钥的长度值除以 8 再减去 11(即:RSACryptoServiceProvider.KeySize / 8 - 11),而加密后得到密文的字节数,正好是密钥的长度值除以 8(即:RSACryptoServiceProvider.KeySize / 8)。

  所以,如果要加密较长的数据,则可以采用分段加解密的方式,实现方式如下:

 1 namespace Macroresolute.RSACryptoService
 2     {
 3         public static class RSACrypto
 4         {
 5             private static readonly Encoding Encoder = Encoding.UTF8;
 6 
 7             public static String Encrypt(this String plaintext)
 8             {
 9                 X509Certificate2 _X509Certificate2 = RSACrypto.RetrieveX509Certificate();
10                 using (RSACryptoServiceProvider RSACryptography = _X509Certificate2.PublicKey.Key as RSACryptoServiceProvider)
11                 {
12                     Byte[] PlaintextData = RSACrypto.Encoder.GetBytes(plaintext);
13                     int MaxBlockSize = RSACryptography.KeySize / 8 - 11;    //加密块最大长度限制
14 
15                     if (PlaintextData.Length <= MaxBlockSize)
16                         return Convert.ToBase64String(RSACryptography.Encrypt(PlaintextData, false));
17 
18                     using (MemoryStream PlaiStream = new MemoryStream(PlaintextData))
19                     using (MemoryStream CrypStream = new MemoryStream())
20                     {
21                         Byte[] Buffer = new Byte[MaxBlockSize];
22                         int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
23 
24                         while (BlockSize > 0)
25                         {
26                             Byte[] ToEncrypt = new Byte[BlockSize];
27                             Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);
28 
29                             Byte[] Cryptograph = RSACryptography.Encrypt(ToEncrypt, false);
30                             CrypStream.Write(Cryptograph, 0, Cryptograph.Length);
31 
32                             BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
33                         }
34 
35                         return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
36                     }
37                 }
38             }
39 
40             public static String Decrypt(this String ciphertext)
41             {
42                 X509Certificate2 _X509Certificate2 = RSACrypto.RetrieveX509Certificate();
43                 using (RSACryptoServiceProvider RSACryptography = _X509Certificate2.PrivateKey as RSACryptoServiceProvider)
44                 {
45                     Byte[] CiphertextData = Convert.FromBase64String(ciphertext);
46                     int MaxBlockSize = RSACryptography.KeySize / 8;    //解密块最大长度限制
47 
48                     if (CiphertextData.Length <= MaxBlockSize)
49                         return RSACrypto.Encoder.GetString(RSACryptography.Decrypt(CiphertextData, false));
50 
51                     using (MemoryStream CrypStream = new MemoryStream(CiphertextData))
52                     using (MemoryStream PlaiStream = new MemoryStream())
53                     {
54                         Byte[] Buffer = new Byte[MaxBlockSize];
55                         int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
56 
57                         while (BlockSize > 0)
58                         {
59                             Byte[] ToDecrypt = new Byte[BlockSize];
60                             Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);
61 
62                             Byte[] Plaintext = RSACryptography.Decrypt(ToDecrypt, false);
63                             PlaiStream.Write(Plaintext, 0, Plaintext.Length);
64 
65                             BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
66                         }
67 
68                         return RSACrypto.Encoder.GetString(PlaiStream.ToArray());
69                     }
70                 }
71             }
72 
73             private static X509Certificate2 RetrieveX509Certificate()
74             {
75                 return null;    //检索用于 RSA 加密的 X509Certificate2 证书
76             }
77         }
78     }

:以上加密方法返回的字符串类型为原始的 Base-64 ,若要用于 URL 传输,需另行处理!

  以上文章转载自http://www.cnblogs.com/zys529/archive/2012/05/24/2516539.html

  下面是自己修改

  如果没有证书请用以下方法

 1     /// <summary>
 2     /// 
 3     /// </summary>
 4     public class RSADecryptEncrypt
 5     {
 6 
 7 
 8         private static readonly Encoding Encoder = Encoding.UTF8;
 9         /// <summary>
10         /// 公钥加密
11         /// </summary>
12         /// <param name="xmlPublicKey">公钥</param>
13         /// <param name="EncryptString">加密字符串</param>
14         /// <returns></returns>
15         public static String Encrypt(string xmlPublicKey, string EncryptString)
16         {
17             using (RSACryptoServiceProvider RSACryptography = new RSACryptoServiceProvider())
18             {
19 
20                 RSACryptography.FromXmlString(xmlPublicKey);
21                 Byte[] PlaintextData = RSADecryptEncrypt.Encoder.GetBytes(EncryptString);
22                 int MaxBlockSize = RSACryptography.KeySize / 8 - 11;//加密块最大长度限制
23 
24                 if (PlaintextData.Length <= MaxBlockSize)
25                     return Convert.ToBase64String(RSACryptography.Encrypt(PlaintextData, false));
26 
27                 using (MemoryStream PlaiStream = new MemoryStream(PlaintextData))
28                 using (MemoryStream CrypStream = new MemoryStream())
29                 {
30                     Byte[] Buffer = new Byte[MaxBlockSize];
31                     int BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
32 
33                     while (BlockSize > 0)
34                     {
35                         Byte[] ToEncrypt = new Byte[BlockSize];
36                         Array.Copy(Buffer, 0, ToEncrypt, 0, BlockSize);
37 
38                         Byte[] Cryptograph = RSACryptography.Encrypt(ToEncrypt, false);
39                         CrypStream.Write(Cryptograph, 0, Cryptograph.Length);
40 
41                         BlockSize = PlaiStream.Read(Buffer, 0, MaxBlockSize);
42                     }
43 
44                     return Convert.ToBase64String(CrypStream.ToArray(), Base64FormattingOptions.None);
45                 }
46             }
47         }
48 
49         /// <summary>
50         /// 解密
51         /// </summary>
52         /// <param name="xmlPublicKey"></param>
53         /// <param name="EncryptString"></param>
54         /// <returns></returns>
55         public static String Decrypt(string xmlPrivateKey, string EncryptString)
56         {
57             using (RSACryptoServiceProvider RSACryptography = new RSACryptoServiceProvider())
58             {
59                 RSACryptography.FromXmlString(xmlPrivateKey);
60                 Byte[] CiphertextData = Convert.FromBase64String(EncryptString);
61                 int MaxBlockSize = RSACryptography.KeySize / 8;    //解密块最大长度限制
62 
63                 if (CiphertextData.Length <= MaxBlockSize)
64                     return RSADecryptEncrypt.Encoder.GetString(RSACryptography.Decrypt(CiphertextData, false));
65 
66                 using (MemoryStream CrypStream = new MemoryStream(CiphertextData))
67                 using (MemoryStream PlaiStream = new MemoryStream())
68                 {
69                     Byte[] Buffer = new Byte[MaxBlockSize];
70                     int BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
71 
72                     while (BlockSize > 0)
73                     {
74                         Byte[] ToDecrypt = new Byte[BlockSize];
75                         Array.Copy(Buffer, 0, ToDecrypt, 0, BlockSize);
76 
77                         Byte[] Plaintext = RSACryptography.Decrypt(ToDecrypt, false);
78                         PlaiStream.Write(Plaintext, 0, Plaintext.Length);
79 
80                         BlockSize = CrypStream.Read(Buffer, 0, MaxBlockSize);
81                     }
82 
83                     return RSADecryptEncrypt.Encoder.GetString(PlaiStream.ToArray());
84                 }
85             }
86         }
87 
88 
89     }

 

 

 

 

相关文章
|
2月前
|
存储 安全 数据安全/隐私保护
打造安全防线!Python AES&RSA加密工具,黑客绕道走的秘籍
【9月更文挑战第9天】随着数字化时代的到来,信息安全问题日益凸显。本文将介绍如何使用Python结合AES与RSA两种加密算法,构建强大的加密工具。AES以其高效性和强安全性著称,适用于大量数据的快速加密;RSA作为非对称加密算法,在加密小量数据及实现数字签名方面表现卓越。通过整合两者,可以构建既安全又灵活的加密系统。首先,需要安装pycryptodome库。接着,实现AES加密与解密功能,最后利用RSA加密AES密钥,确保其安全传输。这种设计不仅提高了数据传输效率,还增强了密钥交换的安全性,为敏感数据提供坚实保护。
220 43
|
2月前
|
安全 算法 网络安全
浅谈非对称加密(RSA)
浅谈非对称加密(RSA)
|
1月前
|
存储 安全 算法
C#一分钟浅谈:数据加密与解密技术
【10月更文挑战第3天】在数字化时代,信息安全至关重要。数据加密作为保障信息不被未授权访问的有效手段,通过特定算法将明文转换为密文,确保即使数据被截获也难以解读。本文从基础概念入手,介绍C#中实现数据加密的方法,涵盖对称加密(如AES、DES)与非对称加密(如RSA),并通过具体示例代码演示如何使用`System.Security.Cryptography.Aes`类完成AES加密和解密过程。此外,还强调了密钥管理及安全策略的重要性。
48 4
|
1月前
|
算法 安全 Go
RSA加密算法详解与Python和Go实现
RSA加密算法详解与Python和Go实现
94 1
|
1月前
|
算法 安全 网络安全
使用 Python 实现 RSA 加密
使用 Python 实现 RSA 加密
53 2
|
2月前
|
存储 安全 算法
RSA在手,安全我有!Python加密解密技术,让你的数据密码坚不可摧
【9月更文挑战第11天】在数字化时代,信息安全至关重要。传统的加密方法已难以应对日益复杂的网络攻击。RSA加密算法凭借其强大的安全性和广泛的应用场景,成为保护敏感数据的首选。本文介绍RSA的基本原理及在Python中的实现方法,并探讨其优势与挑战。通过使用PyCryptodome库,我们展示了RSA加密解密的完整流程,帮助读者理解如何利用RSA为数据提供安全保障。
123 5
|
2月前
|
安全 算法 数据安全/隐私保护
深度揭秘!Python加密技术的背后,AES与RSA如何守护你的数据安全
【9月更文挑战第10天】随着数字化时代的到来,数据安全成为企业和个人面临的重大挑战。Python 作为功能强大的编程语言,在数据加密领域扮演着重要角色。AES 和 RSA 是两种主流加密算法,分别以对称和非对称加密方式保障数据安全。AES(Advanced Encryption Standard)因其高效性和安全性,在数据加密中广泛应用;而 RSA 则利用公钥和私钥机制,在密钥交换和数字签名方面表现卓越。
81 3
|
2月前
|
存储 安全 数据库
双重防护,无懈可击!Python AES+RSA加密方案,构建最强数据安全堡垒
【9月更文挑战第11天】在数字时代,数据安全至关重要。AES与RSA加密技术相结合,构成了一道坚固防线。AES以其高效性保障数据加密,而RSA则确保密钥安全传输,二者相辅相成,提供双重保护。本文通过Python代码示例展示了这一加密方案的魅力,强调了其在实际应用中的重要性和安全性。使用HTTPS等安全协议传输加密密钥和密文,确保数据在数字世界中自由流通而无忧。
61 1
|
2月前
|
安全 数据安全/隐私保护 Python
情书也能加密?Python AES&RSA,让每一份数据都充满爱的密码
【9月更文挑战第8天】在这个数字化时代,情书不再局限于纸笔,也可能以电子形式在网络中传递。为了确保其安全,Python提供了AES和RSA等加密工具,为情书编织爱的密码。首先,通过安装pycryptodome库,我们可以利用AES对称加密算法高效保护数据;接着,使用RSA非对称加密算法加密AES密钥和IV,进一步增强安全性。即使情书被截获,没有正确密钥也无法解读内容。让我们用Python为爱情编织一张安全的网,守护每份珍贵情感。
48 2
|
2月前
|
安全 算法 数据安全/隐私保护
黑客克星!Python加密艺术大公开,AES、RSA双剑合璧,守护你的数字世界
在这个数据泛滥的时代,数字世界既充满了知识,也潜藏安全隐患。Python 作为强大的编程语言,以其独特的加密技术为我们的信息安全保驾护航。本文将介绍 AES 和 RSA 这两种加密算法,揭示它们如何协同工作,保护你的数字世界。AES(高级加密标准)以其高效、安全著称,能将敏感信息转化为难以破解的乱码。Python 的 `pycryptodome` 库让 AES 加密变得简单易行。然而,AES 面临密钥分发难题,此时 RSA(非对称加密算法)便大显身手,通过公钥加密、私钥解密的方式确保密钥传输安全。AES 与 RSA 在 Python 中交织成一道坚不可摧的防护网,共同守护我们的数字世界。
79 0