非对称加密——RSA算法JAVA代码实践

╰+哭是因爲堅強的太久メ 2022-12-22 08:44 138阅读 0赞

### 文章目录 ###

*   *   *   *  说明
             *  RSA加解密
             *  测试代码
             *  打印输出

#### 说明 ####

1：下面代码参考自《JAVA加密解密的艺术》，有部分修改，详见原理见原书  
2：下面代码是RSA在JAVA中API级别的代码实现，具体实现原理见前面章节  
3：下面代码中只需要JDK即可，其中为了便于阅读使用了commons-codec中Base64编码  
4：公钥密码既可以公钥加密私钥解密，又可以私钥加密公钥解密，但注意加密解密必须是同一个密钥对

#### RSA加解密 ####

import javax.crypto.Cipher;
    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;
    
    
    /** * @Description: RSA加解密操作（公钥加密私钥解密-私钥加密公钥解密） * @Author: ZhangYu * @Date: 2020/11/18 */
    public class RSACoder { 
        //公钥密码密钥算法
        public static final String KEY_ALGORITHM = "RSA";
        //公钥
        private static final String PUBLIC_KEY = "RSAPublicKey";
        //私钥
        private static final String PRIVATE_KEY = "RSAPrivateKey";
    
        /** * RSA密钥长度 * 默认1024位 * 密钥长度必须是64的倍数 * 范围在512-65536位之间 */
        private static final int KEY_SIZE = 512;
    
    
        /** * @Description: 私钥解密 * @Param: data 待解密数据 * @Param: key 私钥 * @return: byte[] 解密数据 * @Author: ZhangYu * @Date: 2020/11/18 */
        public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception { 
            //获取私钥
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(key);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //生成私钥
            PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            //对数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        }
    
        /** * @Description: 公钥解密 * @Param: data 待解密数据 * @Param: key 公钥 * @return: byte[] 解密数据 * @Author: ZhangYu * @Date: 2020/11/18 */
        public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception { 
            // 取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
            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);
        }
    
    
        /** * @Description: 公钥加密 * @Param: data 待加密数据 * @Param: key 公钥 * @return: byte[] 加密数据 * @Author: ZhangYu * @Date: 2020/11/18 */
        public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception { 
            //取得公钥
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);
            //对数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return cipher.doFinal(data);
        }
    
    
        /** * @Description: 私钥加密 * @Param: data 待加密数据 * @Param: key 私钥 * @return: byte[] 加密数据 * @Author: ZhangYu * @Date: 2020/11/18 */
        public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception { 
            //取得私钥
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
            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);
        }
    
    
        /** * @Description: 获取私钥 * @Param: keyNap 秘钥对 * @return: byte[] 私钥 * @Author: ZhangYu * @Date: 2020/11/18 * @Throws: */
        public static byte[] getPrivateKey(Map<String, Object> keyNap) throws Exception { 
            Key key = (Key) keyNap.get(PRIVATE_KEY);
            return key.getEncoded();
        }
    
        /** * @Description: 获取公钥 * @Param: keyMap 秘钥对 * @return: byte[] 公钥 * @Author: ZhangYu * @Date: 2020/11/18 * @Throws: */
        public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception { 
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return key.getEncoded();
        }
    
        /** * @Description: 初始化秘钥 * @return: Map 秘钥对 * @Author: ZhangYu * @Date: 2020/11/18 */
    
        public static Map<String, Object> initKey() throws Exception { 
            //实例化密钥对生成器
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            //初始化密钥对生成器
            keyPairGen.initialize(KEY_SIZE);
            //生成密钥对
            KeyPair keyPair = keyPairGen.generateKeyPair();
            //公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            //私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            //封装密钥
            Map<String, Object> keyMap = new HashMap<>(2);
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
        }
    }

#### 测试代码 ####

import org.apache.commons.codec.binary.Base64;
    import org.junit.BeforeClass;
    import org.junit.Test;
    
    import java.nio.charset.Charset;
    import java.util.Map;
    
    /** * @Description: RSA密码算法测试 * @Author: ZhangYu * @Date: 2020/11/18 */
    public class RSACoderTest { 
        //公钥
        private static byte[] publicKey;
        //私钥
        private static byte[] privateKey;
    
        @BeforeClass
        public static void setUp() throws Exception { 
            //初始化密钥
            Map<String, Object> keyPair = RSACoder.initKey();
            //获取公钥
            publicKey = RSACoder.getPublicKey(keyPair);
            //获取私钥
            privateKey = RSACoder.getPrivateKey(keyPair);
            //打印输出私钥和公钥编码字符串
            System.out.println("公钥：\n" + Base64.encodeBase64String(publicKey));
            System.out.println("私钥：\n" + Base64.encodeBase64String(privateKey));
        }
    
    
        /** * @Description: 私钥加密-公钥解密 * @return: void * @Author: ZhangYu * @Date: 2020/11/18 */
        @Test
        public void test1() throws Exception { 
            System.out.println("\n私钥加密-公钥解密");
            //明文
            String input = "Hello 密码-私钥加密-公钥解密";
            byte[] data = input.getBytes();
            //私钥加密
            byte[] ciphertext = RSACoder.encryptByPrivateKey(data, privateKey);
            System.out.println("加密后密文\n" + Base64.encodeBase64String(ciphertext));
            //公钥解密
            byte[] plaintext = RSACoder.decryptByPublicKey(ciphertext, publicKey);
            System.out.println("解密后明文\n" + new String(plaintext, Charset.defaultCharset()));
        }
    
    
        /** * @Description: 公钥加密-私钥解密 * @return: void * @Author: ZhangYu * @Date: 2020/11/18 */
        @Test
        public void test2() throws Exception { 
            System.out.println("\n公钥加密-私钥解密");
            //明文
            String input = "Hello 密码-公钥加密-私钥解密";
            byte[] data = input.getBytes();
            //公钥加密
            byte[] ciphertext = RSACoder.encryptByPublicKey(data, publicKey);
            System.out.println("加密后密文\n" + Base64.encodeBase64String(ciphertext));
            //私钥解密
            byte[] plaintext = RSACoder.decryptByPrivateKey(ciphertext, privateKey);
            System.out.println("解密后明文\n" + new String(plaintext, Charset.defaultCharset()));
        }
    
    
    }

#### 打印输出 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09jdG9wdXMyMQ_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L09jdG9wdXMyMQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/56c7dec7f01f4e3183400875c7e0200d.png