C#RSA加解密

最新推荐文章于 2024-04-16 09:05:53 发布
最新推荐文章于 2024-04-16 09:05:53 发布
阅读量2.2k 收藏 4
点赞数 1
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiadeliang1111/article/details/111903557
版权

场景：

为了支持与JAVA端进行通信数据的加解密，C#编写的客户端使用BouncyCastle进行rsa非对称加密。

 

BouncyCastle安装：直接在Visual 2019 项目->管理Nuget程序包，搜索安装。

上源码：

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Runtime;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Web;
using System.Diagnostics;

using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Crypto.Encodings;

namespace FileApplication
{    
    class Program
	{                
        /// <summary>
        /// KEY 结构体
        /// </summary>
        public struct RSAKEY
        {
            /// <summary>
            /// 公钥
            /// </summary>
            public string PublicKey { get; set; }
            /// <summary>
            /// 私钥
            /// </summary>
            public string PrivateKey { get; set; }
        }
        public 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;
        }
        /*获取公钥数据*/
        private AsymmetricKeyParameter GetPublicKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] publicInfoByte = Convert.FromBase64String(s);
            Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入   
            AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
            return pubKey;
        }
        /*获取私钥数据*/
        private AsymmetricKeyParameter GetPrivateKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] privateInfoByte = Convert.FromBase64String(s);
            // Asn1Object priKeyObj = Asn1Object.FromByteArray(privateInfoByte);//这里也可以从流中读取，从本地导入   
            // PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
            AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
            return priKey;
        }
        /*私钥加密*/
        public string EncryptByPrivateKey(string s, string key)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //加密  
            try
            {
                engine.Init(true, GetPrivateKeyParameter(key));
                byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(ResultData);
                //Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        /*私钥解密*/
        public string DecryptByPrivateKey(string s, string key)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //解密
            try
            {
                engine.Init(false, GetPrivateKeyParameter(key));
                byte[] byteData = Convert.FromBase64String(s);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return System.Text.Encoding.UTF8.GetString(ResultData);

                //Console.WriteLine("密文（base64编码）:" + Convert.ToBase64String(testData) + Environment.NewLine);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        /*公钥加密*/
        public string EncryptByPublicKey(string s, string key)
        {            
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //加密  
            try
            {
                engine.Init(true, GetPublicKeyParameter(key));
                byte[] byteData = System.Text.Encoding.UTF8.GetBytes(s);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return Convert.ToBase64String(ResultData);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        /*公钥解密*/
        public string DecryptByPublicKey(string s, string key)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //解密  
            try
            {
                engine.Init(false, GetPublicKeyParameter(key));
                byte[] byteData = Convert.FromBase64String(s);
                var ResultData = engine.ProcessBlock(byteData, 0, byteData.Length);
                return System.Text.Encoding.UTF8.GetString(ResultData);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        static void Main(string[] args)
		{
            Program pr = new Program();

            /*私钥解密*/
            //string s = "KRbcmSksh303L7InqtyDSndJTxx/20e3tHIRsVB6H/kbZzsKwgKSx7B8LeoVkK1kexnJ5ABzEUUwMeNnxq1eR60kaVDRmAwGxhLZOZIB6prp/aicZZJhSmGNx7qeSAP2mT79e4HYKBWsOi9rm0/WtuoP1BlJXXMb2zPWlkwDYosabsU/+lp7mpH9uujtd+2PL+Trqt4IcCH7ooP3jzC2W0KtjRTGa8nxaIsLRTAr7p4tzEjB/pj6ECy7V0PQYH7kQxnnlMc8tTfahYJbdiElVh2kx3qWAlwjbdml5DNZG2We2ScXAjEhyFOlRytDHydzLonuUqVVs7xPHTAzQ+9pgQ==";
            //string key = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIQgnpsSRKSfY2phifDVJt/YAHJOokywePq868hhOMmjYK3wk2wQx5hTaALvugULzWCI0DG58u+1Mq4O62JBg2lrpO4LhpkT6YPFt4ylfO7ZKjd28bW/fxX052b4jjn+XzzOyjEH8Ei3LDcO5D7mCNorAFCcJoTbDgY7vWsoq0FHAgMBAAECgYBgz1HHB5yaDlsWcD9U4ajpLGgvWORcUpViCpisKmgkffvxlqs97BGCz+IO/L2MwvgJelUpijixYE+w7yeSx7PTtB7av8iP9AidB1CDFhOjgTox+5VRxpPFXI1IKFyFYGB3OJxr9RSJ3KRdUx1KSkwE+odeVgZBQA/Kc4DAdVNL4QJBAM3L4/hnfS5lZNZqBR13IeUnk6Hz1Nu7Hww3yzd6T2EtizrTGZk78ufGZnN4bFiLCB9BCW4vDSXhsPSobrPOhrcCQQCkXA4LBZAq1x3y6h8NXmGPzQiM9xx6MvNBXLLjZuSck5fSi4U57u+x53hruYtRsIN8xchpYUe/D/fg3uVRjgnxAkAF30F7/wf1YPNFovTOaG3RKhXuUxTJyEcUhCsKRDUroq8MWKWsV6eQsXqO5OrChAURTzvDpxgK8qun735pJwV1AkAdjjQ0RS7UlVRcXz9wPv2aR0t3VeR4EPtvUIUWoWUQxvWxNceiUFYoDrC35mioKu6qHELauFSXhf6UIGDqVnlxAkBk/BGnEBjmX7EYFqbJJDirbTtUG/nOpNJxfOTms6+O5CkAblfEh0JHPWn3TTFBSpZaMt/6jESilsmlnlsZ8zL4"; 
            //string result = pr.DecryptByPrivateKey(s, key);

            /*公钥加密*/
            string s = "helloworld";
            string key = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCEIJ6bEkSkn2NqYYnw1Sbf2AByTqJMsHj6vOvIYTjJo2Ct8JNsEMeYU2gC77oFC81giNAxufLvtTKuDutiQYNpa6TuC4aZE+mDxbeMpXzu2So3dvG1v38V9Odm+I45/l88zsoxB/BItyw3DuQ+5gjaKwBQnCaE2w4GO71rKKtBRwIDAQAB";
            string result = pr.EncryptByPublicKey(s, key);
            Console.WriteLine(result);
        }
	}
}

参考：https://www.cnblogs.com/lhxsoft/p/10801158.html

由于RSA加密有长度限制，一般是根据密钥长度来确定，比如1024位密钥，那最长加密长度就是1024/8-11=127字节数据。

于是，在此基础上，进行循环加解密，即可解决加密长度限制的问题。

 

上源码：

using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using System.Linq;
using System.Text;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text.RegularExpressions;
using System.Runtime;
using System.Net.Security;
using System.Security.Cryptography.X509Certificates;
using System.Web;
using System.Diagnostics;

using Org.BouncyCastle.Asn1.Pkcs;
using Org.BouncyCastle.Asn1.X509;
using Org.BouncyCastle.Crypto.Generators;
using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Math;
using Org.BouncyCastle.Pkcs;
using Org.BouncyCastle.Security;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.X509;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Asn1;
using Org.BouncyCastle.Crypto.Encodings;

namespace FileApplication
{    
    class Program
	{                
        /// <summary>
        /// KEY 结构体
        /// </summary>
        public struct RSAKEY
        {
            /// <summary>
            /// 公钥
            /// </summary>
            public string PublicKey { get; set; }
            /// <summary>
            /// 私钥
            /// </summary>
            public string PrivateKey { get; set; }
        }
        public 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;
        }
        /*获取公钥数据*/
        private AsymmetricKeyParameter GetPublicKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] publicInfoByte = Convert.FromBase64String(s);
            Asn1Object pubKeyObj = Asn1Object.FromByteArray(publicInfoByte);//这里也可以从流中读取，从本地导入   
            AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(publicInfoByte);
            return pubKey;
        }
        /*获取私钥数据*/
        private AsymmetricKeyParameter GetPrivateKeyParameter(string s)
        {
            s = s.Replace("\r", "").Replace("\n", "").Replace(" ", "");
            byte[] privateInfoByte = Convert.FromBase64String(s);
            // Asn1Object priKeyObj = Asn1Object.FromByteArray(privateInfoByte);//这里也可以从流中读取，从本地导入   
            // PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(privateKey);
            AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(privateInfoByte);
            return priKey;
        }        
        
        /*私钥解密，支持分段解密*/
        public string DecryptByPrivateKey(string in_plain, string key)
        {
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //加密  
            try
            {                
                int CryLen = 1024;  /*密钥长度为1024位*/
                int bufferSize = CryLen / 8 ;   /*每段密文的长度*/

                /*存放base64解码后的字节数据*/
                byte[] encryptData = Convert.FromBase64String(in_plain);                
                byte[] dencryContent = null;
                if (encryptData == null || encryptData.Length <= 0)
                {
                    Console.WriteLine("Error");
                    throw new NotSupportedException();
                }

                /*存放分段初始字节数据*/
                byte[] buffer = new byte[bufferSize];              
                using (MemoryStream input = new MemoryStream(encryptData))
                    using (MemoryStream output = new MemoryStream())
                {
                    while (true)
                    {
                        int readLine = input.Read(buffer, 0, bufferSize);
                        if (readLine <= 0)
                        {
                            break;
                        }
                        byte[] temp = new byte[readLine];
                        Array.Copy(buffer, 0, temp, 0, readLine);
                        byte[] decrypt = rsa_private_decrypt(engine, temp, key);                                               
                        output.Write(decrypt, 0, decrypt.Length);
                        
                    }
                    dencryContent = output.ToArray();                  
                }               
                return Encoding.UTF8.GetString(dencryContent);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        /*私钥解密，最小长度解密*/
        public byte[] rsa_private_decrypt(IAsymmetricBlockCipher engine,
            byte[] str, string key)
        {           
            //解密
            try
            {
                /*BouncyCastle 解密初始化*/
                engine.Init(false, GetPrivateKeyParameter(key));
                byte[] ResultData = engine.ProcessBlock(str, 0, str.Length);               
                return ResultData;                
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /*公钥加密，支持分段加密*/
        public string EncryptByPublicKey(string in_plain, string key)
        {            
            //非对称加密算法，加解密用  
            IAsymmetricBlockCipher engine = new Pkcs1Encoding(new RsaEngine());
            //加密  
            try
            {                                          
                int CryLen = 1024;  /*密钥长度为1024位*/
                int bufferSize = CryLen / 8 - 11;   /*通过加密长度获取明文的最大加密长度*/
                int cipherLen = CryLen / 8;    /*通过加密长度获取密文的长度*/

                /*存放加密后的数据*/
                byte[] encryContent = null;
                /*初始字节数据*/
                byte[] originalData = Encoding.UTF8.GetBytes(in_plain);
                /*存放分段初始字节数据*/
                byte[] buffer = new byte[bufferSize];

                using (MemoryStream input = new MemoryStream(originalData))
                using (MemoryStream ouput = new MemoryStream())
                {
                    while (true)
                    {
                        /*每次读bufferSize字节的数据存放到buffer中*/
                        int readLine = input.Read(buffer, 0, bufferSize);
                        if (readLine <= 0)
                        {
                            break;
                        }
                        byte[] temp = new byte[readLine];
                        /*复制buffer中的数据到temp中*/
                        Array.Copy(buffer, 0, temp, 0, readLine);
                        //byte[] encrypt = rsa.Encrypt(temp, false);
                        /*加密数据，返回加密后的字节数据*/
                        byte[] encrypt = rsa_public_encrypt(engine, temp, key);
                        ouput.Write(encrypt, 0, encrypt.Length);
                    }
                    encryContent = ouput.ToArray();
                }
                return Convert.ToBase64String(encryContent);
            }
            catch (Exception ex)
            {
                return ex.Message;
            }
        }
        /*公钥最小长度加密*/
        public byte[] rsa_public_encrypt(IAsymmetricBlockCipher engine,
            byte[] str, string key)
        {
            try
            {
                engine.Init(true, GetPublicKeyParameter(key));                
                byte[] ResultData = engine.ProcessBlock(str, 0, str.Length);
                return ResultData;               
            }
            catch (Exception ex)
            {
                return null;
            }
        }                
        static void Main(string[] args)
		{
            Program pr = new Program();

            /*公钥加密*/
            //string s = "xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111xiadeliang111";
            //string s = "xiadeliang";
            //string key = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCEIJ6bEkSkn2NqYYnw1Sbf2AByTqJMsHj6vOvIYTjJo2Ct8JNsEMeYU2gC77oFC81giNAxufLvtTKuDutiQYNpa6TuC4aZE+mDxbeMpXzu2So3dvG1v38V9Odm+I45/l88zsoxB/BItyw3DuQ+5gjaKwBQnCaE2w4GO71rKKtBRwIDAQAB";
            //string result = pr.EncryptByPublicKey(s, key);

            /*私钥解密*/
            string s = "BBVpxSMkIf2ZCWp/AKaJxR2S6nw9+3RA1RdRiSSKRgaQdY+hsDyIAVvUSaTapxbVrlPleQ9QOFOLqvS5nO5FMVlCXcuv3IRoU88RVNHMWyImcXB1bDLyBFKXz/alm/ofBEmeLvPLlc52H/qwzOpzqcU95FZ6qIVaI8XFgufGeiRii9Mcj5xpKbVFCzRKzi6r3Kcb8AiVIGgGwDz9HVE7/270FaFH0/tkmi+fmdIhpRb0X/TpFwDl3gwsOmQIXOxnYxjgCweDj+OVLoq5CcwZPft8KPgMKVZXsa0MJSTqh3Fs+hS1zZsLKLRpr6lZNicgR3NEl4UMZ2C3UX/fVOFKWQ==";
            string key = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAIQgnpsSRKSfY2phifDVJt/YAHJOokywePq868hhOMmjYK3wk2wQx5hTaALvugULzWCI0DG58u+1Mq4O62JBg2lrpO4LhpkT6YPFt4ylfO7ZKjd28bW/fxX052b4jjn+XzzOyjEH8Ei3LDcO5D7mCNorAFCcJoTbDgY7vWsoq0FHAgMBAAECgYBgz1HHB5yaDlsWcD9U4ajpLGgvWORcUpViCpisKmgkffvxlqs97BGCz+IO/L2MwvgJelUpijixYE+w7yeSx7PTtB7av8iP9AidB1CDFhOjgTox+5VRxpPFXI1IKFyFYGB3OJxr9RSJ3KRdUx1KSkwE+odeVgZBQA/Kc4DAdVNL4QJBAM3L4/hnfS5lZNZqBR13IeUnk6Hz1Nu7Hww3yzd6T2EtizrTGZk78ufGZnN4bFiLCB9BCW4vDSXhsPSobrPOhrcCQQCkXA4LBZAq1x3y6h8NXmGPzQiM9xx6MvNBXLLjZuSck5fSi4U57u+x53hruYtRsIN8xchpYUe/D/fg3uVRjgnxAkAF30F7/wf1YPNFovTOaG3RKhXuUxTJyEcUhCsKRDUroq8MWKWsV6eQsXqO5OrChAURTzvDpxgK8qun735pJwV1AkAdjjQ0RS7UlVRcXz9wPv2aR0t3VeR4EPtvUIUWoWUQxvWxNceiUFYoDrC35mioKu6qHELauFSXhf6UIGDqVnlxAkBk/BGnEBjmX7EYFqbJJDirbTtUG/nOpNJxfOTms6+O5CkAblfEh0JHPWn3TTFBSpZaMt/6jESilsmlnlsZ8zL4"; 
            string result = pr.DecryptByPrivateKey(s, key);
            
            Console.WriteLine(result);
        }
	}
}

与JAVA端进行对接时，注意密钥文件的一致性，同时确定好加密算法的填充模式。

参考：

https://blog.csdn.net/lengyue2015/article/details/86582177

soulsoul_god
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C# RSA加密解密
04-15
C#做的RSA加密解密， 带winform界面， 测试通过， 代码完整。
【绝迹篇】RSA加密算法(私钥加签公钥验签)
weixin_30600197的博客
10-26 506
对于上上篇博客中我讲的一个故事，本文引用: https://www.cnblogs.com/ButterflyEffect/p/9851403.html 故事中提到的关于加密会出现，私钥加密，公钥解密的情况，这种情况我们将它称为【私钥加签，公钥验签】 说句好理解的话： 既然是加密，那肯定是不希望别人知道我的消息，所以只有我才能解密，所以可得出【公钥负责加密，私钥负责解密】 同理，既然是签名，那肯定...
RSA 加密/解密—PKCS8 （Java与C#互通BouncyCastle）
u011791378的专栏
06-12 6143
前提： 需要调用JavaAPI进行签名/验签、加密/解密，需要使用BouncyCastle 类库进行Java与C#之间的数据互通。 加密理解点： 1：java 私钥采用的是PKCS8 ；C# 私钥采用的是PKCS1 格式 2：RSA加密 公钥加密，私钥解密或者私钥加密和公钥解密【这点和签名sign不同，sign需要私钥签名】 3：如果 java RSA加密 最后生成16进制 C#...
国密算法（SM2）在C#里面的简单封装_c# sm2，在阿里工作5年了
最新发布
04-16 998
【代码】国密算法（SM2）在C#里面的简单封装_c# sm2，在阿里工作5年了。
Java——DESUtil加解密工具类
Thancks
10-10 3411
工具类代码如下： package util; import javax.crypto.Cipher; import javax.crypto.SecretKey; import javax.crypto.spec.SecretKeySpec; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.nio.file.Files; import java.nio.file.Paths; import j
RSA 简介及 C# 和 js 实现
woisking2的博客
07-08 1632
公钥就是公开的，让全部发送方使用，私钥是保密的，不能公开，专门供接收方解密收到的密文，没有私钥的第三方就无法解密密文，从而保证了数据传输的安全性。可见，针对公钥处理的数据，其填充内容为伪随机（限制范围的随机数）的 16 进制字符串，每次操作的填充内容都不一样。本文也将做专门介绍。BT 取值为 01 时，PS 为全 FF 的字符串，通过填充得到的整数会足够大，可以阻止某些攻击，因此也是推荐的填充方式。"填充后数据" = "00" + "数据块类型" + "填充字符串" + "00" + "原始数据"
C#使用 RSA 加解密的注意事项
JakeyFeifei的专栏
11-23 1043
最近项目中使用到RSA加密算法，去网上看看有没有使用C#来实现RSA加解密，一搜几乎都没有完整可用的，搜索了很多资料都没有讲明白的，找到的一些文章讲的都是片段，目前有些RSA加解密算法会提供公钥加密和私钥解密，但C#只支持XML格式的加解密，因此需要将事先提供的公钥和私钥进行XML格式的转换才行！
Java常用的加密解密工具类
程序员小屋
06-24 6307
工具类的名称：EncryptionUtil工具类的功能：提供常用的加密解密方法，包括对称加密、非对称加密、哈希算法等。
c#使用RSA公钥解密
lyk520dtf的博客
06-07 2381
新项目对接第三方，会把用户信息反正url里面rsa加密传过来，拿到后我解密出用户数据，只给了一个公钥，他们用的java、我用的c#,记录一下解密过程参考：chatgpt、new bing。
C# RSA分段加解密实现方法详解
08-30
本篇文章将深入探讨C#中RSA分段加解密的实现方法。 首先，我们需要了解RSA加密的基本限制。在.NET框架中，RSA加密算法由于安全性的考虑，会在加密前添加一些随机数，这意味着单次加密的最大数据量受到限制。例如，...
C#RSA加密解密工具
09-07
C#RSA加密解密工具，可以生成公钥和私钥，可以生成PKCS1公钥，PKCS8私钥。适用于js加密，C#解密，java解密。
C#RSA加密解密汇总
09-17
C#RSA加密解密汇总
c#RSA加密解密
12-05
分享一份.net版本的RSA加密解密类库代码，c#语言开发，希望对大家有帮助. 前期遇到问题 都已解决“System.Security.Cryptography.CryptographicException”类型的异常在 mscorlib.dll 中发生，但未在用户代码中进行...
Java各种方式加解密工具类
文若书生的专栏
02-25 5927
JAVA能够实现各种加解密方式，这里对各种加密方式做了封装，包括AES、DES、BCrypt、MD5、SHA、RSA、SM3、SM4、Http Basic等。ASE为对称加密。工具类： 单元测试： 2.DES DES为对称加密工具类： 单元测试： 3、BCrypt BCrpty为单向加密 工具类： 单元测试： 4、Http Basic 工具类： 5、MD5 MD5为单向加密 引入依赖（MAVEN）： 引入依赖(gradle): 工具类： 单元测试： 6、RSA RSA为非对称加密 工具类： 单元测试： 7、
Java 加解密工具类
qq_34253002的博客
07-02 3931
一、对称加密算法DES、3DES、AES、DESX、Blowfish、RC4、RC5、RC6。 二、非对称加密算法 RSA、DSA、ECC、Diffie-Hellman、El Gamal。 三、散列算法MD2、MD4、MD5、HAVAL、SHA、SHA-1、HMAC、HMAC-MD5、HMAC-SHA1。
C# 笔记
DK18397606232的博客
05-07 934
目录 1.string转流 2.随缘更新0.0 .。。。。。。。。。。。 1.string转流 string str= "123"; byte[] zj = Encoding.UTF8.GetBytes(str); MemoryStream ms = new MemoryStream(); ms.WriteByte(zj); StringReader sr = ms; ...
Java DES加密工具类 归档 DESUtil @杨章隐
杨章隐的博客
02-09 514
des对称加密，是一种比较传统的加密方式，其加密运算、解密运算使用的是同样的密钥，信息的发送者和信息的接收者在进行信息的传输与处理时，必须共同持有该密码（称为对称密码），是一种对称加密算法。
C#实现字符串RSA加密与解密算法
坚韧与专注
01-14 7015
利用C#的加密库，实现RSA加密算法还是很容易的，因为我只是初步了解这个加密算法，据说是目前非对称加密中比较优秀的加密算法了，如银行什么的都在在RSA1024 RSA2048 RSA4096之类，后面的数字，我想，越大，越复杂，破解也越困难吧。。         RSA加密也很复杂，把几位数加密后，变成了很大的字符串（一般为十六进制字符串），当然也可以使用BASE64处理一下，因为加密后的数值，
C# 实现RSA加解密
06-07
以下是在 C# 中实现 RSA 加解密的基本步骤： 1. 创建 RSA 实例：使用 C# 中的 RSACryptoServiceProvider 类创建一个 RSA 实例。 ``` RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(); ``` 2. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值