.net core RSA 分段加密解密，签名验签（对接java）

参考地址：

https://www.cnblogs.com/stulzq/p/7757915.html

https://www.cnblogs.com/stulzq/p/8260873.html

https://github.com/stulzq/RSAExtensions（XC.RSAUtil）　　

https://www.cnblogs.com/stulzq/p/12053976.html

https://github.com/stulzq/RSAExtensions (RSAExtension)

参考以上的案例可以解决在.net core 中的RSA加密解密（包括分段），签名验签。

实际对接Java 时要根据Java的具体做法，做一些更改以适用于对接。

1、首先java是怎么做的呢？提供一个java rsa 的工具类

package com.card.psbc.facility.utils.xmlSignature;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;

import javax.crypto.Cipher;
import java.io.*;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * @Auther：
 * @Description: //TODO  RSA2048加密    --如果需要改成1024的,需要改下生成方法的密钥长度并重新生成,然后MAX_DECRYPT_BLOCK改成128就可以了
 * @Date:
 **/
public class RSAUtil2048 {

    //加密算法RSA
    public static final String KEY_ALGORITHM = "RSA";
    //签名算法
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    //获取公钥的key
    private static final String PUBLIC_KEY = "RSAPublicKey";
    //获取私钥的key
    private static final String PRIVATE_KEY = "RSAPrivateKey";
    //RSA最大加密明文大小
    private static final int MAX_ENCRYPT_BLOCK = 117;
    //RSA最大解密密文大小
    private static final int MAX_DECRYPT_BLOCK = 256;

    /**
     * @return void
     * @Author：
     * @Description: //TODO 生成密钥对(公钥和私钥)文件并保存本地    下面的生成方法和这个差不多 只是不保存和初始密钥长度的地方有所区别
     * @Date:
     * @Param: [filePath]  保存文件路径
     **/
    public static void genKeyPairByFilePath(String filePath) throws Exception {
        //KeyPairGenerator秘钥构成器，也就是可以生成一对秘钥，可以是公钥也可以是私钥，所以大部分用在非对称加密中   getInstance()设置密钥的格式
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //使用给定的随机源(和默认的参数集合)初始化确定密钥长度的密钥对生成器       SecureRandom()随机源
        keyPairGenerator.initialize(2048, new SecureRandom());
        //generateKeyPair()生成密钥对
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        //强转成公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //强转成私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        //二进制转字符串
        String publicKeyString = Base64.encode(publicKey.getEncoded());
        //二进制转字符串
        String privateKeyString = Base64.encode(privateKey.getEncoded());
        //下面是保存方法
        BufferedWriter publicbw = new BufferedWriter(new FileWriter(new File(filePath + "/publicKey")));
        BufferedWriter privatebw = new BufferedWriter(new FileWriter(new File(filePath + "/privateKey")));
        publicbw.write(publicKeyString);
        privatebw.write(privateKeyString);
        publicbw.flush();
        publicbw.close();
        privatebw.flush();
        privatebw.close();
    }

    /**
     * @return java.util.Map<java.lang.String, java.lang.Object>
     * @Author：
     * @Description: //TODO  生成密钥对(公钥和私钥)
     * @Date:
     **/
    public static Map<String, Object> genKeyPair() throws Exception {
        //秘钥构成器，也就是可以生成一对秘钥，可以是公钥也可以是私钥，所以大部分用在非对称加密中
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //设定密钥的大小整数值
        keyPairGen.initialize(2048);
        //generateKeyPair()生成密钥对
        KeyPair keyPair = keyPairGen.generateKeyPair();
        //强转成公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        //强转成私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
    }

    /**
     * @Author：
     * @Description: //TODO  从文件中读取公钥或私钥
     * @Date:
     * @Param: [filePath]
     * @return java.lang.String
     **/
    public static String readKeyFromFile(String filePath) {
        try {
            BufferedReader br = new BufferedReader(new FileReader(new File(filePath)));
            String readLine = null;
            StringBuilder sb = new StringBuilder();
            while ((readLine = br.readLine()) != null) {
                sb.append(readLine);
            }
            br.close();
            return sb.toString();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @param data       已加密数据
     * @param privateKey 私钥(BASE64编码)
     * @return java.lang.String
     * @Author：
     * @Description: //TODO  私钥加签
     * @Date:
     **/
    public static String sign(byte[] data, String privateKey) throws Exception {
        //字符串解码为二进制数据
        byte[] keyBytes = Base64Utils.decode(privateKey);
        //私钥的ASN.1编码规范
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        //KeyFactory一般通过自己的静态方法keyFactory.generatePublic()获得;
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //根据给定的密钥材料生成私钥对象
        PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        //Signature类用做签名的，一般通过自己的静态方法getInstance("算法名称")获取
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        //通过传入的私钥初始化待签名对象
        signature.initSign(privateK);
        //更新待签名或验证的数据
        signature.update(data);
        //返回所有已更新的签名字节
        return Base64Utils.encode(signature.sign());
    }

    /**
     * @param data      已加密数据
     * @param publicKey 公钥(BASE64编码)
     * @param sign      数字签名
     * @return boolean
     * @Author：
     * @Description: //TODO  公钥验签
     * @Date:
     **/
    public static boolean verify(byte[] data, String publicKey, String sign)
            throws Exception {
        //字符串解码为二进制数据
        byte[] keyBytes = Base64Utils.decode(publicKey);
        //密钥的X509编码
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        //KeyFactory一般通过自己的静态方法keyFactory.generatePublic()获得;
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        //根据给定的密钥材料生成公钥对象
        PublicKey publicK = keyFactory.generatePublic(keySpec);
        //Signature类用做签名的，一般通过自己的静态方法getInstance("算法名称")获取
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        //通过给定的公钥初始化对象
        signature.initVerify(publicK);
        //更新待签名或验证的数据
        signature.update(data);
        //验证待传入的签名
        return signature.verify(Base64Utils.decode(sign));
    }

    /**
     * @param data      源数据
     * @param publicKey 公钥(BASE64编码)
     * @return java.lang.String
     * @Author：
     * @Description: //TODO  公钥加密
     * @Date:
     **/
    public static String encryptByPublicKey(byte[] data, String publicKey)
            throws Exception {
        byte[] keyBytes = org.springframework.util.Base64Utils.decodeFromString(publicKey);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(keySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        String s = org.springframework.util.Base64Utils.encodeToString(encryptedData);
//            System.out.println(s+"=====================================================");
        out.close();
        return s;
    }

    /**
     * @param encryptedData 已加密数据
     * @return byte[]
     * @Author：
     * @Description: //TODO  私钥解密
     * @Date:
     **/
    public static byte[] decryptByPrivateKey(String encryptedData, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        byte[] data = org.springframework.util.Base64Utils.decodeFromString(encryptedData);
        PKCS8EncodedKeySpec x509KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePrivate(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /**
     * @param data       源数据
     * @param privateKey 私钥(BASE64编码)
     * @return java.lang.String
     * @Author：
     * @Description: //TODO  私钥加密
     * @Date:
     **/
    public static String encryptByPrivateKey(byte[] data, String privateKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        String s = org.springframework.util.Base64Utils.encodeToString(encryptedData);
//            System.out.println(s+"=====================================================");
        out.close();
        return s;
    }

    /**
     * @param encryptedData 已加密数据
     * @param publicKey     公钥(BASE64编码)
     * @return byte[]
     * @Author：
     * @Description: //TODO  公钥解密
     * @Date:
     **/
    public static byte[] decryptByPublicKey(String encryptedData, String publicKey)
            throws Exception {
        byte[] keyBytes = Base64Utils.decode(publicKey);
        byte[] data = org.springframework.util.Base64Utils.decodeFromString(encryptedData);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }
}

2、.net core 如何来做 ？

using Org.BouncyCastle.Crypto.Parameters;
using Org.BouncyCastle.Security;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Xml;

namespace Asmkt.Transmit.Core.Utilities
{
    /// <summary>
    /// RSA加解密 使用OpenSSL的公钥加密/私钥解密
    /// 作者：李志强
    /// 创建时间：2017年10月30日15:50:14
    /// QQ:501232752
    /// </summary>
    public class RSAHelper3
    {
        private readonly RSA _privateKeyRsaProvider;
        private readonly RSA _publicKeyRsaProvider;
        private readonly HashAlgorithmName _hashAlgorithmName;
        private readonly Encoding _encoding;

        /// <summary>
        /// 实例化RSAHelper
        /// </summary>
        /// <param name="rsaType">加密算法类型 RSA SHA1;RSA2 SHA256 密钥长度至少为2048</param>
        /// <param name="encoding">编码类型</param>
        /// <param name="privateKey">私钥</param>
        /// <param name="publicKey">公钥</param>
        public RSAHelper3(RSAType rsaType, Encoding encoding, string privateKey, string publicKey = null)
        {
            _encoding = encoding;
            if (!string.IsNullOrEmpty(privateKey))
            {
                _privateKeyRsaProvider = CreateRsaProviderFromPrivateKey(privateKey);
            }

            if (!string.IsNullOrEmpty(publicKey))
            {
                _publicKeyRsaProvider = CreateRsaProviderFromPublicKey(publicKey);
            }
            _hashAlgorithmName = HashAlgorithmName.SHA256;
            if (rsaType == RSAType.RSA)
            {
                _hashAlgorithmName = HashAlgorithmName.SHA1;
            }
            if (rsaType == RSAType.RSA2)
            {
                _hashAlgorithmName = HashAlgorithmName.SHA256;
            }
            if (rsaType == RSAType.MD5)
            {
                _hashAlgorithmName = HashAlgorithmName.MD5;
            }
        }

        #region 使用私钥签名

        /// <summary>
        /// 使用私钥签名
        /// </summary>
        /// <param name="data">原始数据</param>
        /// <returns></returns>
        public string Sign(string data)
        {
            byte[] dataBytes = _encoding.GetBytes(data);

            var signatureBytes = _privateKeyRsaProvider.SignData(dataBytes, _hashAlgorithmName, RSASignaturePadding.Pkcs1);

            return Convert.ToBase64String(signatureBytes);
        }

        #endregion

        #region 使用公钥验证签名

        /// <summary>
        /// 使用公钥验证签名
        /// </summary>
        /// <param name="data">原始数据</param>
        /// <param name="sign">签名</param>
        /// <returns></returns>
        public bool Verify(string data, string sign)
        {
            byte[] dataBytes = _encoding.GetBytes(data);
            var dataSign = sign.Replace(" ", "+");
            int mod4 = dataSign.Length % 4;
            if (mod4 > 0)
            {
                dataSign += new string(‘=‘, 4 - mod4);
            }

            byte[] signBytes = Convert.FromBase64String(dataSign);

            var verify = _publicKeyRsaProvider.VerifyData(dataBytes, signBytes, _hashAlgorithmName, RSASignaturePadding.Pkcs1);

            return verify;
        }

        #endregion

        #region 解密

        public string Decrypt(string cipherText)
        {
            if (_privateKeyRsaProvider == null)
            {
                throw new Exception("_privateKeyRsaProvider is null");
            }
            return Encoding.UTF8.GetString(_privateKeyRsaProvider.Decrypt(Convert.FromBase64String(cipherText), RSAEncryptionPadding.Pkcs1));
        }

        public string DecryptBigData(string dataStr)
        {
            //privateKey = RsaPrivateKeyJava2DotNet(privateKey);
            //FromXmlStringExtensions(rsa, privateKey);

            var data = dataStr.Split(new char[] { ‘$‘ }, StringSplitOptions.RemoveEmptyEntries);
            var byteList = new List<byte>();

            foreach (var item in data)
            {
                byteList.AddRange(_privateKeyRsaProvider.Decrypt(Convert.FromBase64String(item), RSAEncryptionPadding.Pkcs1));
            }
            return Encoding.UTF8.GetString(byteList.ToArray());
        }

        public string DecryptBigDataJava(string dataStr)
        {
            //privateKey = RsaPrivateKeyJava2DotNet(privateKey);
            //FromXmlStringExtensions(rsa, privateKey);

            dataStr = dataStr.Replace(" ", "+");
            int mod4 = dataStr.Length % 4;
            if (mod4 > 0)
            {
                dataStr += new string(‘=‘, 4 - mod4);
            }
            var byteList = new List<byte>();
            var data = Convert.FromBase64String(dataStr);

            var splitLength = 128;
            var splitsNumber = Convert.ToInt32(Math.Ceiling(data.Length * 1.0 / splitLength));

            var pointer = 0;
            for (int i = 0; i < splitsNumber; i++)
            {
                if (pointer + splitLength < data.Length)
                {
                    byte[] current = data.Skip(pointer).Take(splitLength).ToArray();
                    byteList.AddRange(_privateKeyRsaProvider.Decrypt(current, RSAEncryptionPadding.Pkcs1));
                    pointer += splitLength;
                }
                else
                {
                    byte[] current = data.Skip(pointer).Take(splitLength).ToArray();
                    byteList.AddRange(_privateKeyRsaProvider.Decrypt(current, RSAEncryptionPadding.Pkcs1));
                    pointer += splitLength;
                }
                //byte[] current = pointer + splitLength < data.Length ? data[pointer..(pointer + splitLength)] : data[pointer..];
            }
            return Encoding.UTF8.GetString(byteList.ToArray());
        }

        #endregion

        #region 加密

        public string Encrypt(string text)
        {
            if (_publicKeyRsaProvider == null)
            {
                throw new Exception("_publicKeyRsaProvider is null");
            }
            return Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(Encoding.UTF8.GetBytes(text), RSAEncryptionPadding.Pkcs1));
        }

        public string EncryptBigData(string dataStr)
        {
            char connChar = ‘$‘;
            //publicKey = RsaPublicKeyJava2DotNet(publicKey);
            //FromXmlStringExtensions(rsa, publicKey);

            var data = Encoding.UTF8.GetBytes(dataStr);
            //var modulusLength = _publicKeyRsaProvider.KeySize / 8;
            //var splitLength = modulusLength - PaddingLimitDic[padding];
            var splitLength = 117;
            var sb = new StringBuilder();

            var splitsNumber = Convert.ToInt32(Math.Ceiling(data.Length * 1.0 / splitLength));

            var pointer = 0;
            for (int i = 0; i < splitsNumber; i++)
            {
                if (pointer + splitLength < data.Length)
                {
                    byte[] current = data.Skip(pointer).Take(splitLength).ToArray();
                    sb.Append(Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(current, RSAEncryptionPadding.Pkcs1)));
                    sb.Append(connChar);
                    pointer += splitLength;
                }
                else
                {
                    byte[] current = data.Skip(pointer).Take(data.Length - pointer).ToArray();
                    sb.Append(Convert.ToBase64String(_publicKeyRsaProvider.Encrypt(current, RSAEncryptionPadding.Pkcs1)));
                    sb.Append(connChar);
                    pointer += splitLength;
                }
                //byte[] current = pointer + splitLength < data.Length ? data[pointer..(pointer + splitLength)] : data[pointer..];
            }

            return sb.ToString();
        }

        public string EncryptBigDataJava(string dataStr)
        {
            //publicKey = RsaPublicKeyJava2DotNet(publicKey);
            //FromXmlStringExtensions(rsa, publicKey);

            var data = Encoding.UTF8.GetBytes(dataStr);
            //var modulusLength = _publicKeyRsaProvider.KeySize / 8;
            //var splitLength = modulusLength - PaddingLimitDic[padding];
            var splitLength = 117;
            var byteList = new List<byte>();

            var splitsNumber = Convert.ToInt32(Math.Ceiling(data.Length * 1.0 / splitLength));

            var pointer = 0;
            for (int i = 0; i < splitsNumber; i++)
            {
                if (pointer + splitLength < data.Length)
                {
                    byte[] current = data.Skip(pointer).Take(splitLength).ToArray();
                    byteList.AddRange(_publicKeyRsaProvider.Encrypt(current, RSAEncryptionPadding.Pkcs1));
                    pointer += splitLength;
                }
                else
                {
                    byte[] current = data.Skip(pointer).Take(data.Length - pointer).ToArray();
                    byteList.AddRange(_publicKeyRsaProvider.Encrypt(current, RSAEncryptionPadding.Pkcs1));
                    pointer += splitLength;
                }
                //byte[] current = pointer + splitLength < data.Length ? data[pointer..(pointer + splitLength)] : data[pointer..];
            }
            return Convert.ToBase64String(byteList.ToArray());
        }
        #endregion

        #region 使用私钥创建RSA实例

        public RSA CreateRsaProviderFromPrivateKey(string privateKey)
        {
            var privateKeyBits = Convert.FromBase64String(privateKey);

            var rsa = RSA.Create();
            var rsaParameters = new RSAParameters();

            using (BinaryReader binr = new BinaryReader(new MemoryStream(privateKeyBits)))
            {
                byte bt = 0;
                ushort twobytes = 0;
                twobytes = binr.ReadUInt16();
                if (twobytes == 0x8130)
                    binr.ReadByte();
                else if (twobytes == 0x8230)
                    binr.ReadInt16();
                else
                    throw new Exception("Unexpected value read binr.ReadUInt16()");

                twobytes = binr.ReadUInt16();
                if (twobytes != 0x0102)
                    throw new Exception("Unexpected version");

                bt = binr.ReadByte();
                if (bt != 0x00)
                    throw new Exception("Unexpected value read binr.ReadByte()");

                rsaParameters.Modulus = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.Exponent = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.D = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.P = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.Q = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.DP = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.DQ = binr.ReadBytes(GetIntegerSize(binr));
                rsaParameters.InverseQ = binr.ReadBytes(GetIntegerSize(binr));
            }

            rsa.ImportParameters(rsaParameters);
            return rsa;
        }

        #endregion

        #region 使用公钥创建RSA实例

        public RSA CreateRsaProviderFromPublicKey(string publicKeyString)
        {
            // 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];

            var x509Key = Convert.FromBase64String(publicKeyString);

            // ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
            using (MemoryStream mem = new MemoryStream(x509Key))
            {
                using (BinaryReader binr = new BinaryReader(mem))  //wrap Memory Stream with BinaryReader for easy reading
                {
                    byte bt = 0;
                    ushort twobytes = 0;

                    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);

                    int firstbyte = binr.PeekChar();
                    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 -----
                    var rsa = RSA.Create();
                    RSAParameters rsaKeyInfo = new RSAParameters
                    {
                        Modulus = modulus,
                        Exponent = exponent
                    };
                    rsa.ImportParameters(rsaKeyInfo);

                    return rsa;
                }

            }
        }

        #endregion

        #region 导入密钥算法

        private int GetIntegerSize(BinaryReader binr)
        {
            byte bt = 0;
            int count = 0;
            bt = binr.ReadByte();
            if (bt != 0x02)
                return 0;
            bt = binr.ReadByte();

            if (bt == 0x81)
                count = binr.ReadByte();
            else
            if (bt == 0x82)
            {
                var highbyte = binr.ReadByte();
                var lowbyte = binr.ReadByte();
                byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };
                count = BitConverter.ToInt32(modint, 0);
            }
            else
            {
                count = bt;
            }

            while (binr.ReadByte() == 0x00)
            {
                count -= 1;
            }
            binr.BaseStream.Seek(-1, SeekOrigin.Current);
            return count;
        }

        private 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;
        }

        #endregion

        static readonly Dictionary<RSAEncryptionPadding, int> PaddingLimitDic = new Dictionary<RSAEncryptionPadding, int>()
        {
            [RSAEncryptionPadding.Pkcs1] = 11,
            [RSAEncryptionPadding.OaepSHA1] = 42,
            [RSAEncryptionPadding.OaepSHA256] = 66,
            [RSAEncryptionPadding.OaepSHA384] = 98,
            [RSAEncryptionPadding.OaepSHA512] = 130,
        };

        /// <summary>
        /// private key ，java->.net
        /// </summary>
        /// <param name="privateKey"></param>
        /// <returns></returns>
        public static string RsaPrivateKeyJava2DotNet(string privateKey)
        {
            if (string.IsNullOrEmpty(privateKey))
            {
                return string.Empty;
            }
            var privateKeyParam = (RsaPrivateCrtKeyParameters)PrivateKeyFactory.CreateKey(Convert.FromBase64String(privateKey));
            return
                $"<RSAKeyValue><Modulus>{Convert.ToBase64String(privateKeyParam.Modulus.ToByteArrayUnsigned())}</Modulus><Exponent>{Convert.ToBase64String(privateKeyParam.PublicExponent.ToByteArrayUnsigned())}</Exponent><P>{Convert.ToBase64String(privateKeyParam.P.ToByteArrayUnsigned())}</P><Q>{Convert.ToBase64String(privateKeyParam.Q.ToByteArrayUnsigned())}</Q><DP>{Convert.ToBase64String(privateKeyParam.DP.ToByteArrayUnsigned())}</DP><DQ>{Convert.ToBase64String(privateKeyParam.DQ.ToByteArrayUnsigned())}</DQ><InverseQ>{Convert.ToBase64String(privateKeyParam.QInv.ToByteArrayUnsigned())}</InverseQ><D>{Convert.ToBase64String(privateKeyParam.Exponent.ToByteArrayUnsigned())}</D></RSAKeyValue>";
        }

        /// <summary>
        /// 扩展FromXmlString
        /// </summary>
        /// <param name="rsa"></param>
        /// <param name="xmlString"></param>
        private static void FromXmlStringExtensions(RSA rsa, string xmlString)
        {
            var parameters = new RSAParameters();

            var xmlDoc = new XmlDocument();
            xmlDoc.LoadXml(xmlString);

            if (xmlDoc.DocumentElement.Name.Equals("RSAKeyValue"))
            {
                foreach (XmlNode node in xmlDoc.DocumentElement.ChildNodes)
                {
                    switch (node.Name)
                    {
                        case "Modulus":
                            parameters.Modulus = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "Exponent":
                            parameters.Exponent = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "P":
                            parameters.P = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "Q":
                            parameters.Q = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "DP":
                            parameters.DP = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "DQ":
                            parameters.DQ = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "InverseQ":
                            parameters.InverseQ = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                        case "D":
                            parameters.D = (string.IsNullOrEmpty(node.InnerText)
                                ? null
                                : Convert.FromBase64String(node.InnerText));
                            break;
                    }
                }
            }
            else
            {
                throw new Exception("Invalid XML RSA key.");
            }

            rsa.ImportParameters(parameters);
        }

        /// <summary>
        /// public key ，java->.net
        /// </summary>
        /// <param name="publicKey"></param>
        /// <returns>格式转换结果</returns>
        public static string RsaPublicKeyJava2DotNet(string publicKey)
        {
            if (string.IsNullOrEmpty(publicKey))
            {
                return string.Empty;
            }

            var publicKeyParam = (RsaKeyParameters)PublicKeyFactory.CreateKey(Convert.FromBase64String(publicKey));
            return string.Format(
                "<RSAKeyValue><Modulus>{0}</Modulus><Exponent>{1}</Exponent></RSAKeyValue>",
                Convert.ToBase64String(publicKeyParam.Modulus.ToByteArrayUnsigned()),
                Convert.ToBase64String(publicKeyParam.Exponent.ToByteArrayUnsigned())
            );
        }
    }

    /// <summary>
    /// RSA算法类型
    /// </summary>
    public enum RSAType
    {
        /// <summary>
        /// SHA1
        /// </summary>
        RSA = 0,
        /// <summary>
        /// RSA2 密钥长度至少为2048
        /// SHA256
        /// </summary>
        RSA2 = 1,
        MD5 = 2
    }
}

3、详细解释：

1、分段加密解密：参考中的.net core分段加密解密使用 ‘$’ 来作为分段的标识，而java 中没有，因此关键在于解密时找准分段的大小即代码中的 splitLength，加密时为117 ，而这个数字可由

　　　　var modulusLength = _publicKeyRsaProvider.KeySize / 8;
　　　　var splitLength = modulusLength - PaddingLimitDic[padding];

来计算，当前写死；解密时为128，不要问我怎么来的，我是调试加密代码时，debug出来的。望有大佬给个理论的说法？

2、加签验签：这里有个坑为 加签验签时的算法名称 HashAlgorithmName 一定要一致，java中为MD5,对应 .net core 也要MD5,。上面的的代码可以改进一下，可以改成静态方法，暴露出 HashAlgorithmName  参数

以上踩坑，Over!

原文地址：https://www.cnblogs.com/caolingyi/p/12395379.html

时间： 2024-10-10 08:55:54

.net core RSA 分段加密解密，签名验签（对接java）的相关文章

RSACryptoServiceProvider加密解密签名验签和DESCryptoServiceProvider加解密

原文:RSACryptoServiceProvider加密解密签名验签和DESCryptoServiceProvider加解密 C#在using System.Security.Cryptography下有 DESCryptoServiceProvider RSACryptoServiceProvider  DESCryptoServiceProvider 是用于对称加密 RSACryptoServiceProvider是用于非对称加密  对称加密的意思:有一个密钥 相当于加密算法,加密用它来加

openresty中使用私钥/公钥进行加密/解密/签名/验签。

对于公钥私钥的提取,详细请看http://www.cnblogs.com/dreamer-One/p/5621134.html另外付在线加解密工具链接:http://tool.chacuo.net/cryptrsaprikey--公钥local RSA_PUBLIC_KEY = [[ -----BEGIN RSA PUBLIC KEY----- MIGJAoGBAJ9YqFCTlhnmTYNCezMfy7yb7xwAzRinXup1Zl51517rhJq8W0wVwNt+ mcKwRzisA1S

加解密/签名验签

一.我加密.签名的过程 1,生成18位随机密钥:rand 067870-544583-448433: 2,使用对方的公钥证书(cer文件),并使用“RSA”算法,对随机密钥的字节数组加密,得到一个字节数组,将其转化为小写的十六进制字符串:secretKey 07ed7542951980385e32c149039255aabf8009e1e98a9432db19755e45e07361d318b98393d431cad4f656df7bc254548bacc92c53aa9566fd9ca1105

openssl Rsa 分段加密解密

密钥长度 1024 openssl genrsa -out rsa_private_key.pem 1024 openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem function readPublicKey($keyPath) { $key = file_get_contents($keyPath); $this->rsaPublicKey = openssl_pkey_get_public($key) } fu

Java使用RSA加密解密签名及校验

由于项目要用到非对称加密解密签名校验什么的,于是参考<Java加密解密的艺术>写一个RSA进行加密解密签名及校验的Demo,代码很简单,特此分享! RSA加密解密类: package com.ihep; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; imp

非对称加密解密与签名验签的关系

首先看一下各自的定义: 加密:发送方利用接收方的公钥对要发送的明文进行加密. 解密:接受方利用自己的私钥进行解密. 签名:发送方用一个哈希函数从报文文本中生成报文摘要,然后用自己的私人密钥对这个摘要进行加密,得到的就是这个报文对应的数字签名.通常来说,发送方会把数字签名和报文原文一并发送给接受者. 验签:接收方得到原始报文和数字签名后,用同一个哈希函数从报文中生成摘要A,另外,用发送方提供的公钥对数字签名进行解密,得到摘要B,对比A和B是否相同,就可以得知报文有没有被篡改过. 两者的目的不同,加

JAVA 实现 基于RSA算法的签名验签

基本步骤 签名方: 1用sha1算出原文的摘要 2用私钥对摘要进行加密 3对密文进行BASE64编码 验证方: 1对密文进行BASE64解码 2用公钥对解码后的密文解密 3用sha1对原文计算摘要并和解密后的明文比对 上干货 //参数字符串         String userId="2312sd";         String orderId="232djfj";         String price="12312";         

eos中签名验签流程和eosjs中的加解密原理

关键词:eos 签名 验签 ecc dsa 加密 解密 eosjs aes 本文主要探讨两方面 1.eosjs中用密钥对进行加解密功能 2.eos中密钥对生成,签名和验签过程(私钥签名 公钥验签) 常用的加密算法 对称性加密算法 对称式加密就是加密和解密使用同一个密钥,信息接收双方都需事先知道密匙和加解密算法,之后便是对数据进行加解密了.对称加密算法用来对敏感数据等信息进行加密. 对称性加密算法有:AES.DES.3DES DES(Data EncryptionStandard):数据加密标准,

使用 GPG 对数据进行加密解密签名

一:使用 GPG 对数据进行加密解密签名 基本的工具使用 1. GPG 是GNUPG 免费开源的gpg加密工具,和同pgp兼容,pgp收费. 2. 在mac上使用https://gpgtools.org/ 下载安装之后,打开GPG Keychain mac程序, 可以点击新建创建一份自己的公钥和私钥,并把公钥上传到开源服务器上,各服务器间数据同步: 创建完成之后!我们对一个文件加密,解密,签名验证签名就可以了! 选中文件,右键,服务里面即可看到支持的工具 3. 在 windows 上使用 htt