基于RSA算法的Java加密解密与数字签名

快来打我* 2022-12-06 05:38 246阅读 0赞

package com.face.utils.rsa;
    
    import com.sun.org.apache.xml.internal.security.utils.Base64;
    
    import javax.crypto.Cipher;
    import javax.crypto.NoSuchPaddingException;
    import java.security.*;
    import java.security.interfaces.RSAPrivateCrtKey;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * RSA 非对称加密算法的理论依据：基于大数因子分解数学难题。
     *
     * RSA数字签名中为什么不能先加密后签名？
     *
     * 用RSA给别人发送一个信息，首先要用私钥加密签名，
     * 然后再用对方的公钥加密信息和签名，把消息发送给对方。
     *
     * @desc 使用要求：先签名，再加密
     *
     * RSA算法中：公钥长度 << 远小于 私钥长度，必须遵循[公钥加密 则 私钥解密]，[私钥加密 则 公钥解密]这两个原则。
     *
     * 使用流程：data --> 签名 --> 加密 --> 解密 --> 校验签名 --> data
     *
     * 加/解密原则：
     */
    public abstract class RSACoder {
    
        /**
         * 数字签名密钥算法
         */
        public static final String KEY_ALGORITHM = "RSA";
    
        /**
         * 数字签名 - 签名/验证算法
         */
        public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    
        // 公钥
        private static final String PUBLIC_KEY = "RSAPublicKey";
        // 私钥
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        /**
         * RSA - 密钥长度，默认1024位，密钥长度必须是64的倍数，范围在512 ~ 65536 之间。
         */
        private static final int keySize = 512;
    
        /**
         * @desc 签名(私钥)
         * @param data  要签名的数据
         * @param privateKey 私钥
         * @return byte[] 数字签名
         */
        public static byte[] sign(byte[] data, byte[] privateKey) throws NoSuchAlgorithmException,
                InvalidKeySpecException,
                InvalidKeyException,
                SignatureException {
    
            // 转换私钥材料
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKey);
    
            // 实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 生成私钥 或者 获取已经生成保存好的私钥
            PrivateKey privKey = keyFactory.generatePrivate(keySpec);
    
            // 实例化 Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    
            // 初始化 Signature
            signature.initSign(privKey);
            // 更新
            signature.update(data);
    
            // Returns the signature bytes - 返回签名字节
            return signature.sign();
        }
    
    
        /**
         * @desc 校验(公钥) - 验证传入的签名
         * @param data 待校验的数据
         * @param publicKey 公钥
         * @param sign 数字签名
         * @return boolean - 成功：返回 true，失败：返回 false
         * @throws Exception
         */
        public static boolean verify(byte[] data, byte[] publicKey, byte[] sign) throws Exception {
            // 转换公钥材料
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKey);
    
            // 实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 生成密钥
            PublicKey pubKey = keyFactory.generatePublic(keySpec);
    
            // 实例化 Signature
            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    
            // 初始化 Signature
            signature.initVerify(pubKey);
            // 更新
            signature.update(data);
    
            // 验证 - 验证传入的签名
            return signature.verify(sign);
    
        }
    
    
        /**
         * @desc 获取私钥 - 从容器Map中
         * @param keyMap  密钥Map
         * @return byte[] 私钥
         * @throws Exception
         */
        public static byte[] getPrivateKey(Map<String,Object> keyMap) throws Exception {
            Key key = (Key) keyMap.get(PRIVATE_KEY);
            return key.getEncoded();
        }
    
        /**
         * @desc 获取公钥 - 从容器Map中
         * @param keyMap
         * @return
         * @throws Exception
         */
        public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception {
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return key.getEncoded();
        }
    
    
        /**
         * @desc 初始化密钥对
         * @return Map - 密钥Map
         * @throws NoSuchAlgorithmException
         */
        public static Map<String,Object> initKey() throws NoSuchAlgorithmException {
            // 实例化密钥对生成器
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    
            // 初始化密钥对生成器
            keyPairGen.initialize(keySize);
    
            // 生成密钥对
            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;
        }
    
    
        /**********************************【加密与解密】*********************************/
    
    
        // 加密
    
    
        /**
         * @desc 公钥加密
         * @param data - 待加密数据
         * @param pubKey - 公钥
         * @return byte[] - 加密后数据
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, byte[] pubKey) throws Exception {
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
    
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
    
            byte[] result = cipher.doFinal(data);
            System.out.println("加密结果：" + Base64.encode(result));
            
            return cipher.doFinal(data);
        }
    
    
        /**
         * @desc 私钥加密
         * @param data - 待加密数据
         * @param privKey - 私钥
         * @return byte[] - 加密后数据
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, byte[] privKey) throws Exception {
    
            // 取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(privKey);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 生成私钥
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    
            // 对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
    
            return cipher.doFinal(data);
    
        }
    
        
    
        // 解密
        /**
         * @desc 私钥解密
         * @param data 待解密数据
         * @param privKey 私钥
         * @return byte[] 解密数据
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] data, byte[] privKey) throws Exception {
            // 取得私钥
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privKey);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 生成私钥
            PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
    
            // 解密数据
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
    
            return cipher.doFinal(data);
        }
    
        /**
         * @desc 公钥解密
         * @param data
         * @param pubKey - 公钥
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] data, byte[] pubKey) throws Exception {
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKey);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    
            // 生成公钥
            PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
    
            // 对数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
    
            return cipher.doFinal(data);
        }
    
    
    
    
    
    
    }

### **【测试 - 签名与加/解密】** ###

package com.test.rsa;
    
    import com.face.utils.rsa.RSACoder;
    import com.sun.org.apache.xml.internal.security.utils.Base64;
    import org.junit.Before;
    import org.junit.Test;
    
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SignatureException;
    import java.security.spec.InvalidKeySpecException;
    import java.util.Map;
    
    public class TestRSACoder {
    
    
        // 公钥 \ 私钥
        private byte[] publicKey;
        private byte[] privateKey;
    
        @Before
        public void initKey() throws Exception {
    
            Map<String,Object> keyMap = RSACoder.initKey();
    
            publicKey = RSACoder.getPublicKey(keyMap);
            privateKey = RSACoder.getPrivateKey(keyMap);
    
            System.out.println("公钥：" + Base64.encode(publicKey));
            System.out.println("私钥：" + Base64.encode(privateKey));
    
        }
    
        /**
         * @desc 测试签名/校验
         * @throws Exception
         */
        @Test
        public void testSign() throws Exception {
            String myData = "我的账号：accout: no-654321";
            // 生成签名
            byte[] sign = RSACoder.sign(myData.getBytes(), privateKey);
            System.out.println("生成的签名：" + Base64.encode(sign));
    
            // 验证签名
            boolean verifyResult = RSACoder.verify(myData.getBytes(), publicKey,sign);
    
            System.out.println("签名验证结果：" + verifyResult);
    
        }
    
        @Test
        public void testEncrypt() throws Exception {
    
            System.out.println("------------ 私钥加密 <--> 公钥解密 ------------");
    
            String input = "RSA原始数据：密码123abc";
            byte[] byteData = input.getBytes();
    
            System.out.println("原文：" + input);
    
            // 加密
            byte[] encodeData = RSACoder.encryptByPrivateKey(byteData,privateKey);
            System.out.println("加密后：" + Base64.encode(encodeData));
    
            // 解密
            byte[] decodeData = RSACoder.decryptByPublicKey(encodeData, publicKey);
            System.out.println("解密结果：" + new String(decodeData));
    
    
    
    
        }
    
    
    
    
    
    
    }