C# 兼容Java PKCS8 的RSA加密类，且不限明文长度

已于 2022-07-12 13:46:19 修改
阅读量862 收藏
点赞数
分类专栏： C#积累 文章标签： c# java
于 2021-07-19 18:40:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_19749779/article/details/118909066
版权

C# 兼容Java PKCS8 的RSA加密类，且不限明文长度

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Text;
using System.Security.Cryptography;
using System.IO;

/// <summary>
///RSAHelper 的摘要说明
/// </summary>
public class RSAHelper
{
    /// <summary>  
    /// 加密  
    /// </summary>  
    /// <param name="resData">需要加密的字符串</param>  
    /// <param name="publicKey">公钥</param>  
    /// <returns>明文</returns>  
    public static string encryptData(string resData, string publicKey)
    {
        //byte[] DataToEncrypt = Encoding.ASCII.GetBytes(resData);

        byte[] DataToEncrypt = Encoding.UTF8.GetBytes(resData);
        string result = encrypt(DataToEncrypt, publicKey);
        return result;
    }

    #region 内部方法

    private static string encrypt(byte[] data, string publicKey)
    {
        //RSACryptoServiceProvider rsa = DecodePemPublicKey(publicKey);
        //SHA1 sh = new SHA1CryptoServiceProvider();
        //byte[] result = rsa.Encrypt(data, false);

        //return Convert.ToBase64String(result);
        // 进行不限长度的改写 
        RSACryptoServiceProvider rsa2 = DecodePemPublicKey(publicKey);
        int bufferSize = (rsa2.KeySize / 8) - 11;//单块最大长度
        var buffer = new byte[bufferSize];
        using (MemoryStream inputStream = new MemoryStream(data),
             outputStream = new MemoryStream())
        {
            while (true)
            { //分段加密
                int readSize = inputStream.Read(buffer, 0, bufferSize);
                if (readSize <= 0)
                {
                    break;
                }

                var temp = new byte[readSize];
                Array.Copy(buffer, 0, temp, 0, readSize);
                var encryptedBytes = rsa2.Encrypt(temp, false);
                outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);
            }
            return Convert.ToBase64String(outputStream.ToArray());//转化为字节流方便传输
        }
    }

    private static string decrypt(byte[] data, string privateKey, string input_charset)
    {
        string result = "";
        RSACryptoServiceProvider rsa = DecodePemPrivateKey(privateKey);
        SHA1 sh = new SHA1CryptoServiceProvider();
        byte[] source = rsa.Decrypt(data, false);
        char[] asciiChars = new char[Encoding.GetEncoding(input_charset).GetCharCount(source, 0, source.Length)];
        Encoding.GetEncoding(input_charset).GetChars(source, 0, source.Length, asciiChars, 0);
        result = new string(asciiChars);
        //result = ASCIIEncoding.ASCII.GetString(source);  
        return result;
    }

    private static RSACryptoServiceProvider DecodePemPublicKey(String pemstr)
    {
        byte[] pkcs8publickkey;
        pkcs8publickkey = Convert.FromBase64String(pemstr);
        if (pkcs8publickkey != null)
        {
            RSACryptoServiceProvider rsa = DecodeRSAPublicKey(pkcs8publickkey);
            return rsa;
        }
        else
            return null;
    }

    private static RSACryptoServiceProvider DecodePemPrivateKey(String pemstr)
    {
        byte[] pkcs8privatekey;
        pkcs8privatekey = Convert.FromBase64String(pemstr);
        if (pkcs8privatekey != null)
        {
            RSACryptoServiceProvider rsa = DecodePrivateKeyInfo(pkcs8privatekey);
            return rsa;
        }
        else
            return null;
    }

    private static RSACryptoServiceProvider DecodePrivateKeyInfo(byte[] pkcs8)
    {
        byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
        byte[] seq = new byte[15];

        MemoryStream mem = new MemoryStream(pkcs8);
        int lenstream = (int)mem.Length;
        BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading  
        byte bt = 0;
        ushort twobytes = 0;

        try
        {
            twobytes = binr.ReadUInt16();
            if (twobytes == 0x8130)    //data read as little endian order (actual data order for Sequence is 30 81)  
                binr.ReadByte();    //advance 1 byte  
            else if (twobytes == 0x8230)
                binr.ReadInt16();    //advance 2 bytes  
            else
                return null;

            bt = binr.ReadByte();
            if (bt != 0x02)
                return null;

            twobytes = binr.ReadUInt16();

            if (twobytes != 0x0001)
                return null;

            seq = binr.ReadBytes(15);        //read the Sequence OID  
            if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct  
                return null;

            bt = binr.ReadByte();
            if (bt != 0x04)    //expect an Octet string  
                return null;

            bt = binr.ReadByte();        //read next byte, or next 2 bytes is  0x81 or 0x82; otherwise bt is the byte count  
            if (bt == 0x81)
                binr.ReadByte();
            else
                if (bt == 0x82)
                    binr.ReadUInt16();
            //------ at this stage, the remaining sequence should be the RSA private key  

            byte[] rsaprivkey = binr.ReadBytes((int)(lenstream - mem.Position));
            RSACryptoServiceProvider rsacsp = DecodeRSAPrivateKey(rsaprivkey);
            return rsacsp;
        }

        catch (Exception)
        {
            return null;
        }

        finally { binr.Close(); }

    }

    private static bool CompareBytearrays(byte[] a, byte[] b)
    {
        if (a.Length != b.Length)
            return false;
        int i = 0;
        foreach (byte c in a)
        {
            if (c != b[i])
                return false;
            i++;
        }
        return true;
    }

    private static RSACryptoServiceProvider DecodeRSAPublicKey(byte[] publickey)
    {
        // encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"  
        byte[] SeqOID = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
        byte[] seq = new byte[15];
        // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------  
        MemoryStream mem = new MemoryStream(publickey);
        BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading  
        byte bt = 0;
        ushort twobytes = 0;

        try
        {

            twobytes = binr.ReadUInt16();
            if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)  
                binr.ReadByte();    //advance 1 byte  
            else if (twobytes == 0x8230)
                binr.ReadInt16();   //advance 2 bytes  
            else
                return null;

            seq = binr.ReadBytes(15);       //read the Sequence OID  
            if (!CompareBytearrays(seq, SeqOID))    //make sure Sequence for OID is correct  
                return null;

            twobytes = binr.ReadUInt16();
            if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)  
                binr.ReadByte();    //advance 1 byte  
            else if (twobytes == 0x8203)
                binr.ReadInt16();   //advance 2 bytes  
            else
                return null;

            bt = binr.ReadByte();
            if (bt != 0x00)     //expect null byte next  
                return null;

            twobytes = binr.ReadUInt16();
            if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)  
                binr.ReadByte();    //advance 1 byte  
            else if (twobytes == 0x8230)
                binr.ReadInt16();   //advance 2 bytes  
            else
                return null;

            twobytes = binr.ReadUInt16();
            byte lowbyte = 0x00;
            byte highbyte = 0x00;

            if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)  
                lowbyte = binr.ReadByte();  // read next bytes which is bytes in modulus  
            else if (twobytes == 0x8202)
            {
                highbyte = binr.ReadByte(); //advance 2 bytes  
                lowbyte = binr.ReadByte();
            }
            else
                return null;
            byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order  
            int modsize = BitConverter.ToInt32(modint, 0);

            byte firstbyte = binr.ReadByte();
            binr.BaseStream.Seek(-1, SeekOrigin.Current);

            if (firstbyte == 0x00)
            {   //if first byte (highest order) of modulus is zero, don't include it  
                binr.ReadByte();    //skip this null byte  
                modsize -= 1;   //reduce modulus buffer size by 1  
            }

            byte[] modulus = binr.ReadBytes(modsize);   //read the modulus bytes  

            if (binr.ReadByte() != 0x02)            //expect an Integer for the exponent data  
                return null;
            int expbytes = (int)binr.ReadByte();        // should only need one byte for actual exponent data (for all useful values)  
            byte[] exponent = binr.ReadBytes(expbytes);

            // ------- create RSACryptoServiceProvider instance and initialize with public key -----  
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            RSAParameters RSAKeyInfo = new RSAParameters();
            RSAKeyInfo.Modulus = modulus;
            RSAKeyInfo.Exponent = exponent;
            RSA.ImportParameters(RSAKeyInfo);
            return RSA;
        }
        catch (Exception)
        {
            return null;
        }

        finally { binr.Close(); }

    }

    private static RSACryptoServiceProvider DecodeRSAPrivateKey(byte[] privkey)
    {
        byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;

        // ---------  Set up stream to decode the asn.1 encoded RSA private key  ------  
        MemoryStream mem = new MemoryStream(privkey);
        BinaryReader binr = new BinaryReader(mem);    //wrap Memory Stream with BinaryReader for easy reading  
        byte bt = 0;
        ushort twobytes = 0;
        int elems = 0;
        try
        {
            twobytes = binr.ReadUInt16();
            if (twobytes == 0x8130)    //data read as little endian order (actual data order for Sequence is 30 81)  
                binr.ReadByte();    //advance 1 byte  
            else if (twobytes == 0x8230)
                binr.ReadInt16();    //advance 2 bytes  
            else
                return null;

            twobytes = binr.ReadUInt16();
            if (twobytes != 0x0102)    //version number  
                return null;
            bt = binr.ReadByte();
            if (bt != 0x00)
                return null;


            //------  all private key components are Integer sequences ----  
            elems = GetIntegerSize(binr);
            MODULUS = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            E = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            D = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            P = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            Q = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            DP = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            DQ = binr.ReadBytes(elems);

            elems = GetIntegerSize(binr);
            IQ = binr.ReadBytes(elems);

            // ------- create RSACryptoServiceProvider instance and initialize with public key -----  
            RSACryptoServiceProvider RSA = new RSACryptoServiceProvider();
            RSAParameters RSAparams = new RSAParameters();
            RSAparams.Modulus = MODULUS;
            RSAparams.Exponent = E;
            RSAparams.D = D;
            RSAparams.P = P;
            RSAparams.Q = Q;
            RSAparams.DP = DP;
            RSAparams.DQ = DQ;
            RSAparams.InverseQ = IQ;
            RSA.ImportParameters(RSAparams);
            return RSA;
        }
        catch (Exception)
        {
            return null;
        }
        finally { binr.Close(); }
    }

    private static int GetIntegerSize(BinaryReader binr)
    {
        byte bt = 0;
        byte lowbyte = 0x00;
        byte highbyte = 0x00;
        int count = 0;
        bt = binr.ReadByte();
        if (bt != 0x02)        //expect integer  
            return 0;
        bt = binr.ReadByte();

        if (bt == 0x81)
            count = binr.ReadByte();    // data size in next byte  
        else
            if (bt == 0x82)
            {
                highbyte = binr.ReadByte();    // data size in next 2 bytes  
                lowbyte = binr.ReadByte();
                byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
                count = BitConverter.ToInt32(modint, 0);
            }
            else
            {
                count = bt;        // we already have the data size  
            }



        while (binr.ReadByte() == 0x00)
        {    //remove high order zeros in data  
            count -= 1;
        }
        binr.BaseStream.Seek(-1, SeekOrigin.Current);        //last ReadByte wasn't a removed zero, so back up a byte  
        return count;
    }

    #endregion


    #region 解析.net 生成的Pem
    private static RSAParameters ConvertFromPublicKey(string pemFileConent)
    {

        if (string.IsNullOrEmpty(pemFileConent))
        {
            throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");
        }
        pemFileConent = pemFileConent.Replace("-----BEGIN PUBLIC KEY-----", "").Replace("-----END PUBLIC KEY-----", "").Replace("\n", "").Replace("\r", "");
        byte[] keyData = Convert.FromBase64String(pemFileConent);
        bool keySize1024 = (keyData.Length == 162);
        bool keySize2048 = (keyData.Length == 294);
        if (!(keySize1024 || keySize2048))
        {
            throw new ArgumentException("pem file content is incorrect, Only support the key size is 1024 or 2048");
        }
        byte[] pemModulus = (keySize1024 ? new byte[128] : new byte[256]);
        byte[] pemPublicExponent = new byte[3];
        Array.Copy(keyData, (keySize1024 ? 29 : 33), pemModulus, 0, (keySize1024 ? 128 : 256));
        Array.Copy(keyData, (keySize1024 ? 159 : 291), pemPublicExponent, 0, 3);
        RSAParameters para = new RSAParameters();
        para.Modulus = pemModulus;
        para.Exponent = pemPublicExponent;
        return para;
    }
    /// <summary>
    /// 将pem格式私钥(1024 or 2048)转换为RSAParameters
    /// </summary>
    /// <param name="pemFileConent">pem私钥内容</param>
    /// <returns>转换得到的RSAParamenters</returns>
    private static RSAParameters ConvertFromPrivateKey(string pemFileConent)
    {
        if (string.IsNullOrEmpty(pemFileConent))
        {
            throw new ArgumentNullException("pemFileConent", "This arg cann't be empty.");
        }
        pemFileConent = pemFileConent.Replace("-----BEGIN RSA PRIVATE KEY-----", "").Replace("-----END RSA PRIVATE KEY-----", "").Replace("\n", "").Replace("\r", "");
        byte[] keyData = Convert.FromBase64String(pemFileConent);

        bool keySize1024 = (keyData.Length == 609 || keyData.Length == 610);
        bool keySize2048 = (keyData.Length == 1190 || keyData.Length == 1192);

        if (!(keySize1024 || keySize2048))
        {
            throw new ArgumentException("pem file content is incorrect, Only support the key size is 1024 or 2048");
        }

        int index = (keySize1024 ? 11 : 12);
        byte[] pemModulus = (keySize1024 ? new byte[128] : new byte[256]);
        Array.Copy(keyData, index, pemModulus, 0, pemModulus.Length);

        index += pemModulus.Length;
        index += 2;
        byte[] pemPublicExponent = new byte[3];
        Array.Copy(keyData, index, pemPublicExponent, 0, 3);

        index += 3;
        index += 4;
        if ((int)keyData[index] == 0)
        {
            index++;
        }
        byte[] pemPrivateExponent = (keySize1024 ? new byte[128] : new byte[256]);
        Array.Copy(keyData, index, pemPrivateExponent, 0, pemPrivateExponent.Length);

        index += pemPrivateExponent.Length;
        index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));
        byte[] pemPrime1 = (keySize1024 ? new byte[64] : new byte[128]);
        Array.Copy(keyData, index, pemPrime1, 0, pemPrime1.Length);

        index += pemPrime1.Length;
        index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));
        byte[] pemPrime2 = (keySize1024 ? new byte[64] : new byte[128]);
        Array.Copy(keyData, index, pemPrime2, 0, pemPrime2.Length);

        index += pemPrime2.Length;
        index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));
        byte[] pemExponent1 = (keySize1024 ? new byte[64] : new byte[128]);
        Array.Copy(keyData, index, pemExponent1, 0, pemExponent1.Length);

        index += pemExponent1.Length;
        index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));
        byte[] pemExponent2 = (keySize1024 ? new byte[64] : new byte[128]);
        Array.Copy(keyData, index, pemExponent2, 0, pemExponent2.Length);

        index += pemExponent2.Length;
        index += (keySize1024 ? ((int)keyData[index + 1] == 64 ? 2 : 3) : ((int)keyData[index + 2] == 128 ? 3 : 4));
        byte[] pemCoefficient = (keySize1024 ? new byte[64] : new byte[128]);
        Array.Copy(keyData, index, pemCoefficient, 0, pemCoefficient.Length);

        RSAParameters para = new RSAParameters();
        para.Modulus = pemModulus;
        para.Exponent = pemPublicExponent;
        para.D = pemPrivateExponent;
        para.P = pemPrime1;
        para.Q = pemPrime2;
        para.DP = pemExponent1;
        para.DQ = pemExponent2;
        para.InverseQ = pemCoefficient;
        return para;
    }
    #endregion

}

感谢 https://blog.youkuaiyun.com/zzzili/article/details/73739797
https://blog.youkuaiyun.com/weixin_38211198/article/details/107404282

RSA 加密/解密—PKCS8 （Java与C#互通BouncyCastle）
u011791378的专栏
06-12 6830
前提： 需要调用JavaAPI进行签名/验签、加密/解密，需要使用BouncyCastle 类库进行Java与C#之间的数据互通。 加密理解点： 1：java 私钥采用的是PKCS8 ；C# 私钥采用的是PKCS1 格式 2：RSA加密 公钥加密，私钥解密或者私钥加密和公钥解密【这点和签名sign不同，sign需要私钥签名】 3：如果 java RSA加密 最后生成16进制 C#...
java pkcs8_Java RSA加密类（RSAFromPkcs8）
weixin_42458128的博客
02-12 1475
packagecom.ctrip.arch.cscmws.cscmws2.util;importjava.io.ByteArrayOutputStream;importjava.security.Key;importjava.security.KeyFactory;importjava.security.KeyPair;importjava.security.KeyPairGenerator;im...
RSA-PKCS8_CS.rar RSA的C#代码实现
05-18
RSA-PKCS8_CS.rar RSA的C#代码实现
C# 的RSA加密解密签名，就为了支持 PEM PKCS#8 格式密钥对的导入导出
weixin_33966095的博客
11-07 1452
差点造了一整个轮子 .Net Framework 4.5 里面的RSA功能，并未提供简单对PEM密钥格式的支持（.Net Core有咩？），差点（还远着）造了一整个轮子，就为了支持PEM PKCS#8、PKCS#1格式密钥对的导入导出。 Github: github.com/xiangyuecn/… 本文内容来自README，主要介绍了PEM PKCS#8、PKCS#1公钥和私钥格式，并以此为基础...
C# pkcs8加解密
04-23
C# pkcs8加解密，该类对Java生成的密钥进行解密和签名以及验签专用类，不需要修改
RSA公私钥pkcs8转换为C#用的xml
10-18
RSA公私钥pkcs8格式， 不能被C#程序所用，需要转转换为C#用的xml格式。这是转换用的c#源程序。
c# 导入PKCS1和PKCS8密钥
文盲的专栏
01-04 5536
之前在RSA PKCS1和PKCS8的ASN格式一文里，我们已经分析过了PKCS1和PKCS8格式的密钥了 那么，我们现在就做一个c#通用的解析代码，即能解析PKCS1的密钥，也能解析PKCS8的密钥 public static partial class Encryption { public static class AsnParser {...
RSA加密算法实现以及C#与java互通加解密
04-23
### RSA加密算法实现以及C#与Java互通加解密 #### 一、RSA算法简介 RSA算法是一种非对称加密算法，由Ron Rivest、Adi Shamir 和 Leonard Adleman 在1977年提出，并以其三人的名字首字母命名。RSA算法的安全性基于...
C#与java平台RSA加密解密签名验签互通案例
04-23
本案例聚焦于"C#与Java平台RSA加密解密签名验签互通"的问题，这涉及到两个主要的技术点：RSA加密算法和跨平台兼容性。下面将详细阐述这两个知识点。 首先，RSA是一种非对称加密算法，由Ron Rivest、Adi Shamir和...
C#和Java实现互通的RSA&DES加解密算法
12-10
C#和Java中都有内置的类库支持RSA加密，如C#的System.Security.Cryptography.RSACryptoServiceProvider和Java的java.security.KeyPairGenerator与java.security.Signature等。 接下来，我们讨论DES（Data ...
C#中关于RSA加密算法(案例代码) c#经典案例.pdf
05-07
在C#中实现RSA加密算法需要使用到RSACryptoServiceProvider类，该类提供了RSA加密算法的实现。下面是一个简单的RSA加密和解密的示例： ```csharp using System.Security.Cryptography; public class RSAExample { ...
C# Pkcs8 1024位 加密 解密 签名 解签
weixin_34290000的博客
02-18 1104
部分代码来至https://www.cnblogs.com/dj258/p/6049786.html using System; using System.Collections.Generic; using System.Linq; using System.Text; using Org.BouncyCastle.Asn1.Pkcs; using Org.Bounc...
Java RSA私钥 pkcs1转pkcs8；
08-15
Java RSA私钥 pkcs1转pkcs8；适用于Java与C#程序交互时使用
RSA-csharp：c＃.NET FrameworkCore下的RSA操作类，支持XML，PEM（PKCS＃1，PKCS＃8）格式密钥对导入，导出，纯字节码解析0依赖
02-05
:open_book: RSA-csharp的帮助文档 本项目.NET Core功能：支持.NET Core ， .NET Framework环境下PEM （ PKCS#1 ， PKCS#8 ）格式RSA密钥对导入，导出。 彻底实现采用PEM文件二进制规模上进行字节码解析，简单轻巧0依赖；附带实现了一个RSA封装操作类，和一个测试控制台程序。 您可以只复制RSA_PEM.cs文件到你的项目中使用，只需这一个文件你就拥有了通过PEM格式密钥创建RSACryptoServiceProvider的能力。克隆整个项目代码用vs应该能够直接打开，经目测看起来没什么卵用的文件都svn：ignore掉了（svn滑稽。 【Ja
C# 使用BouncyCastle生成RSA PEM格式公钥私钥(PKCS#1,PKCS#8)
最新发布
weixin_42293338的博客
01-20 2056
RSA非对称加密应用
C#使用SHA1加密类（RSAFromPkcs8）支持1024位和2048位私钥
Golden的专栏
01-16 3897
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using System.Security.Cryptography; namespace  Golden.Util {     /// &lt;summary&gt;         ///...
C#使用SHA1加密类（RSAFromPkcs8）支持1024位和2048位私钥(来自阿里云)
weixin_30564901的博客
12-21 312
摘要：usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingSystem.IO;usingSystem.Security.Cryptography;namespaceYFAPICommon.Controllers.UPay{///<summary>///类名:RSAFromPkcs8///功能:RSA加密...
java pkcs8格式的私钥_RSA加密解密中pkcs1与pkcs8格式私钥互相转换
weixin_42297665的博客
02-13 2699
net,ios中rsa加解密使用的是pkcs1，而java使用的是pkcs8如果是按1024取模(通常都是1024)，pkcs1格式的私钥长度应该是812。如果是pkcs8的格式的密钥长度为861。我这边使用的是Win64OpenSSL_Light-1_1_0g.exePKCS1私钥生成：OpenSSL> genrsa -out pkcs1_private.pem 1024Generatin...
Java RSA工具类，0依赖支持PKCS#8和PKCS#1格式的密钥解析和转换，PEM和XML格式密钥转换
beifengtz
02-10 1473
今天和客户端对接RSA算法的加解密功能，后端是Java，客户端是C#实现，C#只支持PKCS#1格式的密钥（PKCS#8受限于Unity环境不支持），Java只支持PKCS#8格式的密钥，这就很尴尬了，于是在GitHub上找有没有类库实现，还好找到了个C#版的PKCS#8支持实现，于是我就将其改造成Java的工具类。改造自C#项目：https://github.com/xiangyuecn/RSA-csharp源码见下方，先上使用方法 RSAKey.java工具类源码
实现C#与Java间RSA加密互通的工具类
《C#和Java关于RSA非对称加密互通类》标题下涉及的知识点包括了RSA加密算法的基础原理、C#和Java中的RSA加密实现、密钥格式转换和PKCS#1填充算法的应用。在实际的项目开发中，开发者需要特别注意不同平台间加密数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值