C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之C#

以你之姓@ 2021-09-17 04:12 593阅读 0赞

# 前言 #

C\#有自己的一套生成密钥、加解密的库，但是跟其他文互通比较费劲，经过一翻比较后，笔者选择了BouncyCastle这套库，而这套库的缺点是文档很少，只能参考Java的代码才把需求的功能实现。笔者下面提供的代码是经过多语言环境验证，可以与其他语言互通。

1.  [C\#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之前言][C_Golang_Python_Java_Android_Des_Rsa]
2.  [C\#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之C\#][C_Golang_Python_Java_Android_Des_Rsa_C]
3.  [C\#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Golang][C_Golang_Python_Java_Android_Des_Rsa_Golang]
4.  [C\#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Python][C_Golang_Python_Java_Android_Des_Rsa_Python]
5.  [C\#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Java(Android)][C_Golang_Python_Java_Android_Des_Rsa_Java_Android]

# 代码 #

## Des对称加密工具类 ##

using System;
    using System.IO;
    using System.Security.Cryptography;
    using System.Text;
    
    namespace lhtzbj12.Encryption
    {
        /// <summary>
        /// Des对称加密工具类
        /// </summary>
        public class DesHelper
        {
            /// <summary>
            /// 加密
            /// </summary>
            /// <param name="data">待加密的数据</param>
            /// <param name="key">加/解密key 8位</param>
            /// <param name="iv">偏移向量 8位</param>
            /// <param name="model">密码模式</param>
            /// <param name="padding">填充方式</param>
            /// <returns></returns>
            public static string Encrypt(string data, string key, string iv, CipherMode model = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
            {
                byte[] _KeyByte = null;
                if (!string.IsNullOrWhiteSpace(key))
                {
                    _KeyByte = Encoding.UTF8.GetBytes(key);
                }
    
                byte[] _IVByte = null;
                if (!string.IsNullOrWhiteSpace(iv))
                {
                    _IVByte = Encoding.UTF8.GetBytes(iv);
                }
    
                var sa = new DESCryptoServiceProvider();
                sa.Mode = model;
                sa.Padding = padding;           
                var ct = sa.CreateEncryptor(_KeyByte, _IVByte);
    
                MemoryStream ms = new MemoryStream();
                CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
                byte[] byt = Encoding.UTF8.GetBytes(data);
                cs.Write(byt, 0, byt.Length);
                cs.FlushFinalBlock();
                cs.Close();
                return Convert.ToBase64String(ms.ToArray());
            }
            /// <summary>
            /// 解密
            /// </summary>
            /// <param name="encData">加密生成的Base64密文</param>
            /// <param name="key">加/解密key 8位</param>
            /// <param name="iv">偏移向量 8位</param>
            /// <param name="model">密码模式</param>
            /// <param name="padding">填充方式</param>
            /// <returns></returns>
            public static string Decrypt(string encData, string key, string iv, CipherMode model = CipherMode.CBC, PaddingMode padding = PaddingMode.PKCS7)
            {
                byte[] _KeyByte = null;
                if (!string.IsNullOrWhiteSpace(key))
                {
                    _KeyByte = Encoding.UTF8.GetBytes(key);
                }
    
                byte[] _IVByte = null;
                if (!string.IsNullOrWhiteSpace(iv))
                {
                    _IVByte = Encoding.UTF8.GetBytes(iv);
                }
    
                using (ICryptoTransform ct = new DESCryptoServiceProvider()
                { Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 }.CreateDecryptor(_KeyByte, _IVByte))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        using (CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write))
                        {
                            byte[] byt = Convert.FromBase64String(encData);
                            try
                            {
                                cs.Write(byt, 0, byt.Length);
                                cs.FlushFinalBlock();
                                cs.Close();
                            }
                            catch (Exception)
                            {
                                return string.Empty;
                            }
                        }
                        return Encoding.UTF8.GetString(ms.ToArray());
                    }
                }
            }
        }
    }

## Rsa密钥对生成、加载（读取）工具类 ##

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    using Org.BouncyCastle.Asn1;
    using Org.BouncyCastle.Asn1.Pkcs;
    using Org.BouncyCastle.Asn1.X509;
    using Org.BouncyCastle.Crypto;
    using Org.BouncyCastle.Crypto.Generators;
    using Org.BouncyCastle.Crypto.Parameters;
    using Org.BouncyCastle.OpenSsl;
    using Org.BouncyCastle.Pkcs;
    using Org.BouncyCastle.Security;
    using Org.BouncyCastle.X509;
    using System.IO;
    using System.Text.RegularExpressions;
    
    namespace lhtzbj12.Encryption
    {
        /// <summary>
        /// Rsa密钥对生成工具
        /// </summary>
        public class RsaKeyHelper
        {
            public static void GenKey(out string publicKey, out string privateKey, out string privateKeyPk8)
            {
                publicKey = string.Empty;
                privateKey = string.Empty;
                privateKeyPk8 = string.Empty;
                try
                {
                    //RSA密钥对的构造器 
                    RsaKeyPairGenerator r = new RsaKeyPairGenerator();
                    //RSA密钥构造器的参数 
                    RsaKeyGenerationParameters param = new RsaKeyGenerationParameters(
                        Org.BouncyCastle.Math.BigInteger.ValueOf(3),
                        new SecureRandom(),
                        1024,   //密钥长度 
                        25);
                    r.Init(param);
                    AsymmetricCipherKeyPair keyPair = r.GenerateKeyPair();
                    //获取公钥和密钥 
                    AsymmetricKeyParameter private_key = keyPair.Private;
                    AsymmetricKeyParameter public_key = keyPair.Public;
                    if (((RsaKeyParameters)public_key).Modulus.BitLength < 1024)
                    {
                        Console.WriteLine("failed key generation (1024) length test");
                    }
                    using (TextWriter textWriter = new StringWriter())
                    {
                        PemWriter pemWriter = new PemWriter(textWriter);
                        pemWriter.WriteObject(keyPair.Private);
                        pemWriter.Writer.Flush();
                        privateKey = textWriter.ToString();
                    }
                    using (TextWriter textpubWriter = new StringWriter())
                    {
                        PemWriter pempubWriter = new PemWriter(textpubWriter);
                        pempubWriter.WriteObject(keyPair.Public);
                        pempubWriter.Writer.Flush();
                        publicKey = textpubWriter.ToString();                   
                    }
                    //keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥                 
                    //public_key = keyPair.Public;//公钥  
                    //private_key = keyPair.Private;//私钥 
                    // 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式
                    SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(public_key);
                    PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);
                    Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
                    byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
                    Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
                    byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();
    
                    var pubkeyb64 = Convert.ToBase64String(publicInfoByte);
                    // 这里生成的是Pkcs8的密钥
                    privateKeyPk8 = PrivateKeyPk8Format(Convert.ToBase64String(privateInfoByte));
    
                    privateKey = PrivateKeyFormat(privateKey);
                    publicKey = PublicKeyFormat(publicKey);
                }
                catch (Exception ex) {
                    throw ex;
                }            
            }
    
            /// <summary>
            /// 加载Pkcs8格式的私钥
            /// </summary>
            /// <param name="privateKey"></param>
            /// <returns></returns>
            public static AsymmetricKeyParameter loadPrivateKeyPk8(string privateKey)
            {
                try
                {
                    privateKey = KeyClear(privateKey);
                    byte[] prikey = Convert.FromBase64String(privateKey);
                    Asn1Object priKeyObj = Asn1Object.FromByteArray(prikey);//这里也可以从流中读取，从本地导入
                    AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(priKeyObj));
                    return priKey;
                }
                catch (Exception)
                {
                    throw new Exception("密钥格式不正确");
                }
            }
    
            /// <summary>
            /// 加载Pkcs1格式的私钥
            /// </summary>
            /// <param name="privateKey"></param>
            /// <returns></returns>
            public static AsymmetricKeyParameter loadPrivateKeyPk1(string privateKey)
            {
                AsymmetricCipherKeyPair keyPair = null;
                try
                {
                    keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥
                }
                catch (Exception)
                {
                    throw new Exception("密钥格式不正确");
                }
                try
                {
                    AsymmetricKeyParameter private_key = keyPair.Private;             
                    // 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式              
                    PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);              
                    Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();              
                    AsymmetricKeyParameter priKey = PrivateKeyFactory.CreateKey(PrivateKeyInfo.GetInstance(asn1ObjectPrivate));
                    return priKey;
                }
                catch (Exception)
                {
                    throw new Exception("加载失败");
                }          
            }
    
            /// <summary>
            /// 加载公钥
            /// </summary>
            /// <param name="publicKey"></param>
            /// <returns></returns>
            public static AsymmetricKeyParameter loadPublicKey(string publicKey)
            {
                try
                {
                    publicKey = KeyClear(publicKey);
                    byte[] pubkey = Convert.FromBase64String(publicKey);
                    Asn1Object pubKeyObj = Asn1Object.FromByteArray(pubkey);//这里也可以从流中读取，从本地导入   
                    AsymmetricKeyParameter pubKey = PublicKeyFactory.CreateKey(SubjectPublicKeyInfo.GetInstance(pubKeyObj));
                    return pubKey;
                }
                catch (Exception)
                {
                    throw new Exception("密钥格式不正确");
                }
            }
    
            /// <summary>
            /// 将Pkcs1格式的私转成Pkcs8格式
            /// </summary>
            /// <param name="privateKey"></param>
            /// <returns></returns>
            public static string ConvertPriPk1ToPk8(string privateKey)
            {
                AsymmetricCipherKeyPair keyPair = null;
                try
                {
                    keyPair = ReadPem(privateKey); // 直接读取字符串生成密码钥
                }
                catch (Exception)
                {
                    throw new Exception("密钥格式不正确");
                }
                try
                {
                    AsymmetricKeyParameter private_key = keyPair.Private;
                    AsymmetricKeyParameter public_key = keyPair.Public;
                    // 前面私钥为pkcs1格式，经过下面处理后，变成pkcs8格式
                    SubjectPublicKeyInfo subjectPublicKeyInfo = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(public_key);
                    PrivateKeyInfo privateKeyInfo = PrivateKeyInfoFactory.CreatePrivateKeyInfo(private_key);
                    Asn1Object asn1ObjectPublic = subjectPublicKeyInfo.ToAsn1Object();
                    byte[] publicInfoByte = asn1ObjectPublic.GetEncoded();
                    Asn1Object asn1ObjectPrivate = privateKeyInfo.ToAsn1Object();
                    byte[] privateInfoByte = asn1ObjectPrivate.GetEncoded();
                    var pubkeyb64 = Convert.ToBase64String(publicInfoByte);
                    // 这里生成的是Pkcs8的密钥
                    return PrivateKeyFormat(Convert.ToBase64String(privateInfoByte));
    
                }
                catch (Exception)
                {
                    throw new Exception("转换失败");
                }
            }
    
            public static string KeyClear(string key)
            {
                key = Regex.Replace(key, @"(-----BEGIN PRIVATE KEY-----)|(-----END PRIVATE KEY-----)|(-----BEGIN RSA PRIVATE KEY-----)|(-----END RSA PRIVATE KEY-----)|(-----BEGIN PUBLIC KEY-----)|(-----END PUBLIC KEY-----)|(-----BEGIN RSA PUBLIC KEY-----)|(-----END RSA PUBLIC KEY-----)|\n|\r", "");
                return key;
            }
    
            private static string PrivateKeyFormat(string privateKey)
            {
                privateKey = KeyClear(privateKey);
                privateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" + privateKey + "\r\n-----END RSA PRIVATE KEY-----";
                return privateKey;
            }
    
            private static string PrivateKeyPk8Format(string privateKey)
            {
                privateKey = KeyClear(privateKey);
                privateKey = "-----BEGIN PRIVATE KEY-----\r\n" + privateKey + "\r\n-----END PRIVATE KEY-----";
                return privateKey;
            }
    
            private static string PublicKeyFormat(string publicKey)
            {
                publicKey = KeyClear(publicKey);
                publicKey = "-----BEGIN PUBLIC KEY-----\r\n" + publicKey + "\r\n-----END PUBLIC KEY-----";
                return publicKey;
            }
            static AsymmetricCipherKeyPair ReadPem(string pem)
            {
                using (TextReader reader = new StringReader(pem))
                {
                    var obj = new Org.BouncyCastle.OpenSsl.PemReader(reader).ReadObject();
                    return obj as AsymmetricCipherKeyPair;
                }
            }
        }
    }

## Rsa加密、解密、签名、验签工具类 ##

using Org.BouncyCastle.Crypto;
    using Org.BouncyCastle.Crypto.Parameters;
    using Org.BouncyCastle.Security;
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Security.Cryptography;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace lhtzbj12.Encryption
    {
        /// <summary>
        /// Rsa非对称加密工具类
        /// </summary>
        public  class RsaBCHelper
        {      
            /// <summary>    
            /// 签名    
            /// </summary>    
            /// <param name="content">待签名字符串</param>    
            /// <param name="privateKey">私钥</param>   
           
            /// <returns>签名后字符串</returns>    
            public static string Sign(string content, string privateKey)
            {
                AsymmetricKeyParameter priKey = RsaKeyHelper.loadPrivateKeyPk1(privateKey);
                ISigner sig = SignerUtilities.GetSigner("SHA256withRSA"); //其他算法 如SHA1withRSA
                sig.Init(true, priKey);
                var bytes = Encoding.UTF8.GetBytes(content);
                sig.BlockUpdate(bytes, 0, bytes.Length);
                byte[] signature = sig.GenerateSignature();
                var signedString = Convert.ToBase64String(signature);
                return signedString;
            }
    
            /// <summary>    
            /// 验签    
            /// </summary>    
            /// <param name="content">待验签字符串</param>    
            /// <param name="signedString">签名</param>    
            /// <param name="publicKey">公钥</param> 
            /// <returns>true(通过)，false(不通过)</returns>    
            public static bool Verify(string content, string signedString, string publicKey)
            {
                AsymmetricKeyParameter pubKey = RsaKeyHelper.loadPublicKey(publicKey);
                ISigner signer = SignerUtilities.GetSigner("SHA256withRSA"); //其他算法 如SHA1withRSA
                signer.Init(false, pubKey);
                var expectedSig = Convert.FromBase64String(signedString);
                var msgBytes = Encoding.UTF8.GetBytes(content);
                signer.BlockUpdate(msgBytes, 0, msgBytes.Length);
                return signer.VerifySignature(expectedSig);
            }       
    
            /// <summary>    
            /// 公钥加密    
            /// </summary>    
            /// <param name="resData">需要加密的字符串</param>    
            /// <param name="publicKey">公钥</param>  
            /// <returns>明文</returns>    
            public static string Encrypt(string resData, string publicKey)
            {
                try
                {
                    AsymmetricKeyParameter pubKey = RsaKeyHelper.loadPublicKey(publicKey);
                    IBufferedCipher cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
                    cipher.Init(true, pubKey);//true表示加密  
                    var data = Encoding.UTF8.GetBytes(resData.Trim());
                    byte[] encryptData = cipher.DoFinal(data);
                    return Convert.ToBase64String(encryptData);
                }
                catch (Exception)
                {
                    throw new Exception("加密失败");
                }
            }
    
            /// <summary>    
            /// 私钥解密
            /// </summary>    
            /// <param name="resData">加密字符串</param>    
            /// <param name="privateKey">私钥</param>    
            /// <param name="input_charset">编码格式</param>    
            /// <returns>明文</returns>    
            public static string Decrypt(string resData, string privateKey)
            {
                try
                {
                    AsymmetricKeyParameter priKey = RsaKeyHelper.loadPrivateKeyPk1(privateKey);
                    IBufferedCipher cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
                    cipher.Init(false, priKey);//false表示解密  
                    var encryptData = Convert.FromBase64String(resData);
                    var decryptData = cipher.DoFinal(encryptData);
                    return Encoding.UTF8.GetString(decryptData);
                }
                catch (Exception) {
                    throw new Exception("解密失败");
                }
                
            }
            /// <summary>    
            /// 私钥加密    
            /// </summary>    
            /// <param name="resData">需要加密的字符串</param>    
            /// <param name="privateKey">私钥</param>  
            /// <returns>明文</returns>    
            public static string EncryptByPrivateKey(string resData, string privateKey)
            {
                try
                {
                    AsymmetricKeyParameter priKey = RsaKeyHelper.loadPrivateKeyPk1(privateKey);
                    IBufferedCipher cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
                    cipher.Init(true, priKey);//true表示加密  
                    var data = Encoding.UTF8.GetBytes(resData.Trim());
                    byte[] encryptData = cipher.DoFinal(data);
                    return Convert.ToBase64String(encryptData);
                }
                catch (Exception)
                {
                    throw new Exception("加密失败");
                }
            }
    
            /// <summary>    
            /// 公钥解密
            /// </summary>    
            /// <param name="resData">加密字符串</param>    
            /// <param name="publicKey">公钥</param>           
            /// <returns>明文</returns>    
            public static string DecryptByPublicKey(string resData, string publicKey)
            {
                try
                {
                    AsymmetricKeyParameter pubKey = RsaKeyHelper.loadPublicKey(publicKey);
                    IBufferedCipher cipher = CipherUtilities.GetCipher("RSA/ECB/PKCS1Padding");
                    cipher.Init(false, pubKey);//false表示解密  
                    var encryptData = Convert.FromBase64String(resData);
                    var decryptData = cipher.DoFinal(encryptData);
                    return Encoding.UTF8.GetString(decryptData);
                }
                catch (Exception)
                {
                    throw new Exception("解密失败");
                }
    
            }       
        }
    }

## github工程源码 ##

[https://github.com/lhtzbj12/csharp\_encryption][https_github.com_lhtzbj12_csharp_encryption]

[C_Golang_Python_Java_Android_Des_Rsa]: https://blog.csdn.net/lhtzbj12/article/details/84591521
[C_Golang_Python_Java_Android_Des_Rsa_C]: https://blog.csdn.net/lhtzbj12/article/details/84799557
[C_Golang_Python_Java_Android_Des_Rsa_Golang]: https://blog.csdn.net/lhtzbj12/article/details/84799827
[C_Golang_Python_Java_Android_Des_Rsa_Python]: https://blog.csdn.net/lhtzbj12/article/details/89194346
[C_Golang_Python_Java_Android_Des_Rsa_Java_Android]: https://blog.csdn.net/lhtzbj12/article/details/89525666
[https_github.com_lhtzbj12_csharp_encryption]: https://github.com/lhtzbj12/csharp_encryption

发表评论取消回复

表情：

评论列表（有 0 条评论，593人围观）

还没有评论，来说两句吧...

相关阅读

相关 java C# 互通加解密 MD5文件校验

原文地址： [https://www.xuebuyuan.com/817312.html][https_www.xuebuyuan.com_817312.html] [ht

妖狐艹你老母/ 2022年12月25日 09:55/ 0 赞/ 151 阅读

相关【Java加解密系列】- SM2加解密

上一篇博客介绍了SM2算法生成密钥的过程，详见-[SM2生成密钥][SM2]。这篇博客接着介绍SM2算法如何用上篇博客生成的密钥进行加解密操作。因为密钥都是byte数组，在

淩亂°似流年/ 2022年12月25日 05:50/ 0 赞/ 189 阅读

相关 C# 对称加解密

/// <summary> /// DES加密调用 /// </summary> /// <param name="inputStr">需要加密的字符串</para

快来打我*/ 2022年08月08日 00:58/ 0 赞/ 197 阅读

相关 C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Java(Android)

前言 1. [C\、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之前言][C_Golang_Python_Java_Andro

秒速五厘米/ 2021年09月19日 02:20/ 0 赞/ 444 阅读

相关 C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Python

前言好长时间没有更新了，但是要有始有终，这个系列必须完成。 1. [C\、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之前

心已赠人/ 2021年09月18日 21:32/ 0 赞/ 340 阅读

相关 C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之Golang

前言 Golang比较强大，之前笔者在研究区块链的时间总结过加解密，这篇博文里的代码在其基础上进行了整理。笔者下面提供的代码是经过多语言环境验证，可以与其他语言互通。

落日映苍穹つ/ 2021年09月17日 04:14/ 0 赞/ 639 阅读

相关 C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之C#

前言 C\有自己的一套生成密钥、加解密的库，但是跟其他文互通比较费劲，经过一翻比较后，笔者选择了BouncyCastle这套库，而这套库的缺点是文档很少，只能参考Java

以你之姓@/ 2021年09月17日 04:12/ 0 赞/ 594 阅读

相关 C#、Golang、Python、Java（Android）之间Des、Rsa加解密互通系列之前言

前言最近项目需要写一个接口，返回两个参数，一个参数使用Rsa非对称加密，解密出对称加密用的密钥，另一个参数使用Des进行对称加密。虽然功能不难，但是在多语言之间实现对称

Love The Way You Lie/ 2021年09月17日 03:18/ 0 赞/ 312 阅读

相关 Java 加解密技术系列之 DH

[http://m.blog.csdn.net/happylee6688/article/details/45242691][http_m.blog.csdn.net_happ

我不是女神ヾ/ 2021年09月14日 01:02/ 0 赞/ 384 阅读

相关 Java 加解密技术系列之 RSA

[http://m.blog.csdn.net/happylee6688/article/details/45218801][http_m.blog.csdn.net_happ

一时失言乱红尘/ 2021年09月14日 01:00/ 0 赞/ 309 阅读