JAVA实现RSA加密解密签名

我会带着你远行 2023-06-08 03:11 10阅读 0赞

package com.wz..util;
     
    import org.apache.commons.codec.binary.Base64;
    import org.apache.commons.io.IOUtils;
     
    import javax.crypto.Cipher;
    import java.io.ByteArrayOutputStream;
    import java.security.*;
    import java.security.interfaces.RSAPublicKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
     
    public class RsaUtil {
        public static final String CHARSET = "UTF-8";
        public static final String RSA_ALGORITHM = "RSA";
        public static final String RSA_ALGORITHM_SIGN = "SHA256WithRSA";
     
        private RSAPublicKey publicKey;
        private RSAPrivateKey privateKey;
     
        public RsaUtil (String publicKey, String privateKey)
        {
            try {
                KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
     
                //通过X509编码的Key指令获得公钥对象
                X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
                this.publicKey = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
                //通过PKCS#8编码的Key指令获得私钥对象
                PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
                this.privateKey = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
            } catch (Exception e) {
                throw new RuntimeException("不支持的密钥", e);
            }
        }
     
        public static Map<String, String> createKeys(int keySize){
            //为RSA算法创建一个KeyPairGenerator对象
            KeyPairGenerator kpg;
            try{
                kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
            }catch(NoSuchAlgorithmException e){
                throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
            }
     
            //初始化KeyPairGenerator对象,不要被initialize()源码表面上欺骗,其实这里声明的size是生效的
            kpg.initialize(keySize);
            //生成密匙对
            KeyPair keyPair = kpg.generateKeyPair();
            //得到公钥
            Key publicKey = keyPair.getPublic();
            String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
            //得到私钥
            Key privateKey = keyPair.getPrivate();
            String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
            Map<String, String> keyPairMap = new HashMap<String, String>();
            keyPairMap.put("publicKey", publicKeyStr);
            keyPairMap.put("privateKey", privateKeyStr);
     
            return keyPairMap;
        }
     
        public String publicEncrypt(String data){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
            }catch(Exception e){
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
     
        public String privateDecrypt(String data){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
            }catch(Exception e){
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
     
        public String privateEncrypt(String data){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
            }catch(Exception e){
                throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
            }
        }
     
        public String publicDecrypt(String data){
            try{
                Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
            }catch(Exception e){
                throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
            }
        }
     
        public String sign(String data){
            try{
                //sign
                Signature signature = Signature.getInstance(RSA_ALGORITHM_SIGN);
                signature.initSign(privateKey);
                signature.update(data.getBytes(CHARSET));
                return Base64.encodeBase64URLSafeString(signature.sign());
            }catch(Exception e){
                throw new RuntimeException("签名字符串[" + data + "]时遇到异常", e);
            }
        }
     
        public boolean verify(String data, String sign){
            try{
                Signature signature = Signature.getInstance(RSA_ALGORITHM_SIGN);
                signature.initVerify(publicKey);
                signature.update(data.getBytes(CHARSET));
                return signature.verify(Base64.decodeBase64(sign));
            }catch(Exception e){
                throw new RuntimeException("验签字符串[" + data + "]时遇到异常", e);
            }
        }
     
        private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
            int maxBlock = 0;
            if(opmode == Cipher.DECRYPT_MODE){
                maxBlock = keySize / 8;
            }else{
                maxBlock = keySize / 8 - 11;
            }
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] buff;
            int i = 0;
            try{
                while(datas.length > offSet){
                    if(datas.length-offSet > maxBlock){
                        buff = cipher.doFinal(datas, offSet, maxBlock);
                    }else{
                        buff = cipher.doFinal(datas, offSet, datas.length-offSet);
                    }
                    out.write(buff, 0, buff.length);
                    i++;
                    offSet = i * maxBlock;
                }
            }catch(Exception e){
                throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
            }
            byte[] resultDatas = out.toByteArray();
            IOUtils.closeQuietly(out);
            return resultDatas;
        }
    }

附上一个读取密钥文件的方法:

/**
         * 读取密匙文件
         * @return
         */
        private String getPivateKey() {
            // 配置文件路径
            String privateKeyStr = "E:\\ideaCode\\PRIVATEKEY.txt";
            FileInputStream fis = null;
            BufferedReader buf = null;
            // 签名内容
            StringBuilder privateKeyStr = new StringBuilder();
    
            // 是否开始读取私钥文件
            boolean flag = false;
    
            try {
                fis = new FileInputStream(new File(privateKeyPath));
                buf = new BufferedReader(new InputStreamReader(fis));
                String line = "";
    
                // 读取私钥文件内容
                while ((line = buf.readLine()) != null){
    
                    // 密钥内容结束标识
                    if ("-----END PRIVATE KEY-----".equals(line)){
                        flag = false;
                        break;
                    }
                    // 读取密钥内容
                    if (flag){
                        privateKeyStr.append(line);
                    }
    
                    // 密钥内容开始标识
                    if ("-----BEGIN PRIVATE KEY-----".equals(line)){
                        flag = true;
                    }
                }
            } catch (IOException e) {
                logger.error("读取密钥文件遇到异常", e);
                //throw new RuntimeException("读取密钥文件遇到异常", e);
            }finally {
                // 释放资源
                if (null != buf){
                    try {
                        buf.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (null != fis){
                    try {
                        fis.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return privateKeyStr.toString();
        }

主要: 读取txt文本密钥文件时需要将私钥标识去掉,否则会报什么 toobig异常.  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191015195438445.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzQ2NDk2NA==,size_16,color_FFFFFF,t_70