【Java工具类】非对称加密之RSA算法工具类

超、凢脫俗 2022-11-13 04:20 157阅读 0赞

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.Base64;
    import java.util.HashMap;
    import java.util.Map;
    
    /** * 非对称加密RSA算法工具类 */
    public class RSACoder { 
        //非对称密钥算法
        public static final String KEY_ALGORITHM = "RSA";
        /** * RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
        public static final int KEY_SIZE = 2048;
    
        //公钥
        private static final String PUBLIC_KEY = "publicKey";
    
        //私钥
        private static final String PRIVATE_KEY = "privateKey";
    
    
        /** * 初始化密钥对 * * @return Map 甲方密钥的Map */
        public static Map<String, Object> initKey() throws Exception { 
            //实例化密钥生成器
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    
            //初始化密钥生成器
            keyPairGenerator.initialize(KEY_SIZE);
    
            // 生成一个密钥对，保存在keyPair中
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
    
            //甲方公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            System.out.println("系数：" + publicKey.getModulus() + " 加密指数：" + publicKey.getPublicExponent());
    
            //甲方私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            System.out.println("系数：" + privateKey.getModulus() + "解密指数：" + privateKey.getPrivateExponent());
    
            //将密钥存储在map中
            Map<String, Object> keyMap = new HashMap<String, Object>();
            keyMap.put(PUBLIC_KEY, publicKey);
            keyMap.put(PRIVATE_KEY, privateKey);
            return keyMap;
    
        }
    
    
    
        /** * 公钥加密 * * @param data 待加密数据 * @param key 密钥 * @return byte[] 加密数据 */
        public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception { 
    
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
            //产生公钥
            PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
    
            //数据加密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, pubKey);
            return cipher.doFinal(data);
        }
    
        /** * 私钥解密 * * @param data 待解密数据 * @param key 密钥 * @return byte[] 解密数据 */
        public static byte[] decryptByPrivateKey(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.DECRYPT_MODE, privateKey);
            return cipher.doFinal(data);
        }
    
    
        /** * 私钥加密 * * @param data 待加密数据 * @param key 密钥 * @return byte[] 加密数据 */
        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);
        }
    
        /** * 公钥解密 * * @param data 待解密数据 * @param key 密钥 * @return byte[] 解密数据 */
        public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception { 
    
            //实例化密钥工厂
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            //初始化公钥
            //密钥材料转换
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
            //产生公钥
            PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
            //数据解密
            Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, pubKey);
            return cipher.doFinal(data);
        }
    
        /** * 取得私钥 * * @param keyMap 密钥map * @return byte[] 私钥 */
        public static byte[] getPrivateKey(Map<String, Object> keyMap) { 
            Key key = (Key) keyMap.get(PRIVATE_KEY);
            return key.getEncoded();
        }
    
        /** * 取得公钥 * * @param keyMap 密钥map * @return byte[] 公钥 */
        public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception { 
            Key key = (Key) keyMap.get(PUBLIC_KEY);
            return key.getEncoded();
        }
    
        /** * @param args * @throws Exception */
        public static void main(String[] args) throws Exception { 
            //初始化密钥
            //生成密钥对
            Map<String, Object> keyMap = RSACoder.initKey();
    
            //公钥
            byte[] publicKey = RSACoder.getPublicKey(keyMap);
            System.out.println("\n公钥:" +  Base64.getEncoder().withoutPadding().encodeToString(publicKey));//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
            //私钥
            byte[] privateKey = RSACoder.getPrivateKey(keyMap);
            System.out.println("\n私钥:" + Base64.getEncoder().withoutPadding().encodeToString(privateKey));//由于加密后的密文都是字节码形式的，我们要以字符串方式保存或传输的话，可以使用Base64编码。
    
    
            System.out.println("\n===========1.公钥加密,私钥解密==============");
            String str = "aattaggcctegthththfef/aat.mp4";
            System.out.println("原文:" + str);
    
            //使用公钥进行数据的加密
            byte[] code1 = RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
            System.out.println("公钥加密后的数据：" +   Base64.getEncoder().withoutPadding().encodeToString(code1));
            //使用私钥进行数据的解密
            byte[] decode1 = RSACoder.decryptByPrivateKey(code1, privateKey);
            System.out.println("私钥解密后的数据：" + new String(decode1));
    
    
            System.out.println("\n===========2.反向进行操作,私钥加密,公钥解密==============");
            str ="4b9d373bed9f40b389f0e42ebaf729b4";
            System.out.println("原文:" + str);
    
            //使用私钥进行数据的加密
            byte[] code2 = RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);
            System.out.println("私钥加密后的数据：" +Base64.getEncoder().withoutPadding().encodeToString(code2));
            //使用公钥进行数据的解密
            byte[] decode2 = RSACoder.decryptByPublicKey(code2, publicKey);
            System.out.println("公钥解密后的数据：" + new String(decode2));
        }
    }

main方法执行结果

系数：25673086491181252696735907678323359012290479118460249182240942943781022994992575396590727636402349564925636011579483415535025350805322419881144350331454228457159864635273352797075670117225640053564150779878581672826043466730442466562220815297498994632148250863062496794801485613090601179615469513565622072320713419491283100791224145056532853893350394503766393820017518906472919715328843855105481040100067458333759790298618468832658166599809135248953553073655427587148287992213804301398790107769457487285016468303621342838245142810915126734720967207513720464121646170199288480519720222247070607912244425592472384699833  加密指数：65537
    系数：25673086491181252696735907678323359012290479118460249182240942943781022994992575396590727636402349564925636011579483415535025350805322419881144350331454228457159864635273352797075670117225640053564150779878581672826043466730442466562220815297498994632148250863062496794801485613090601179615469513565622072320713419491283100791224145056532853893350394503766393820017518906472919715328843855105481040100067458333759790298618468832658166599809135248953553073655427587148287992213804301398790107769457487285016468303621342838245142810915126734720967207513720464121646170199288480519720222247070607912244425592472384699833解密指数：5951226482353870194986220142043249921642994930613975396746943027632044514395337067992223236526305668406400388908792163950258710795954318977590444637921367147125633818134378682166922203043958736190954402061666124076067753277825990692483003890925808725629739339787378905147079808872429514941456167509787303701594458366179085655994722382066825611874856877831944821823855957870861590255730073317554239720440140157947209450604893997531142179043822700188495148788044375693219726672614185030409346413260290559526517250002718058539432864497234239894526319410363940220217629293027556378044752569803302642220451834422341413473
    
    公钥:MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAy165kj4sGDx2rtzHZmTrA++C7LiCX8j7J0OI0MwnLSDp1lNaVsrBU0u1UNHuaKAXzAvDZI8U1rm6cHfh9AhCePNTY2JwCTwf/Xnj1/S7OreIpxxaGuRbnVwCcFbDQ/S8JSpD4bYe5LrkKk1WW15tA6ZaLq1gcbfgRw3ZCB5wkqI4T7jrapS2uNpeGYKdXYRCwArlPSTr3UB33IKA4DXVzE0Gop97GJ4lT+HeewfBUQ7rkIOMka85NL+yi0yB34kHX4uqaySMWe4edNXGJDC1lRxCYTo7QBPBSqS5ibeHpn8Z3RRiYpWRv0UkC75FUyN3yudUhBDAKoOdIuiF2+H9uQIDAQAB
    
    私钥:MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDLXrmSPiwYPHau3MdmZOsD74LsuIJfyPsnQ4jQzCctIOnWU1pWysFTS7VQ0e5ooBfMC8NkjxTWubpwd+H0CEJ481NjYnAJPB/9eePX9Ls6t4inHFoa5FudXAJwVsND9LwlKkPhth7kuuQqTVZbXm0DplourWBxt+BHDdkIHnCSojhPuOtqlLa42l4Zgp1dhELACuU9JOvdQHfcgoDgNdXMTQain3sYniVP4d57B8FRDuuQg4yRrzk0v7KLTIHfiQdfi6prJIxZ7h501cYkMLWVHEJhOjtAE8FKpLmJt4emfxndFGJilZG/RSQLvkVTI3fK51SEEMAqg50i6IXb4f25AgMBAAECggEALySOL/BpmFSrzm0va/UI5ain2OgMkNeuILPvCzfH/RYcHqrDzkrB9eUe6tU/RtGVsp8ndDAWzI/RQDEKF9+ySQde1TMEdZ+SatfOkUkR/dJ9wv83g/RbqGajyhbSvPYGhzb89V2aW7tXGNdEpXmGG8p8LUXTjYjqXI5BOTiVL+gwvx4eEpgpNzpfKdySyCkpvxuznIqxdvp2w4EZ4Ic9zvhSntCDclAvtjRs/mJClWyx+Fr/JrBhZ/FtMdE4nfyacdjgKA4ubtwz4clEsw7eAMIqksGx8RAv9DvPp1362z3EZpYjuXxZuh9uI7T/uH2u5efL8H8m6BNBMGPHbiQqYQKBgQD2EBKDPDIPG4WyfJxrGoy6B2VI9lOHJnkV5imlfTEBKd/SozjsU5CthvyaisPqjJiq8DiJUtLJT0XT4uoqA1RDoicwUe+MeKBwlPHcnJno/jO8cDtimBalpHivExnnRA5Og+ES82HV2qcFnTTrdKVbnHaKEQzwLegFMM56mJQ4GwKBgQDTlUWpjQzaUAaCSlV4JaWscNZdc7zNKW8fIcHql7W5+QEx/XXjPyCTlQ9FgkY/ybtIw6ns+U7jJs9i2XsbWEav0HqvvHy+JMw3rplBFPE8wYE0TLpI55UE7Ul/jslESkyr/+o0nSuXYsc7F81fCLswNRFzW8aeqP2T1w50HGsmuwKBgHshgdIQHlC3CglOGAv0hjVVHBcNxLCdzPvraC263vnhFXLXYNXJ310mbmN7Sxyk7ISlnvUA8B/yvlOQenM5pUIO86NXbRMTDd4oentWFiKkigki9GSbDMIo8odRfKXgxXP+xHNyPSQBvZCuoVutzE1yl1Lxw1Kw9ikaykhI7+q/AoGAFhobwtBnLU76vxWAxCI6oj7PRcfXSx8u6nOeTCE47IpkY5J0hB6OCpyhkcNAD13FYJ5/269XXEcrlsndIEgiai8/AaiQ51P0uURV4gSMBqq4EnyJYSA/4tneuaJyx91zEOyUzJY2fYPmB/g+jdTdqPWCMyi9IMnKY20tp1doog0CgYBO83gSEdqGmR3+qix2cUBZYXGCNRKFtFX8edIEeluT6AOMA6/kMe5i/y8e3m5Oh9LWE45l04dsVHeqAA6l9Ps/l6WkeLEiIsRY0yF0DcppXo8DJ5TrL+DIJeJ1yxBEGcLjBea5t16zwLqwFASr0ieF622kk40Gn7QH+ZBrMaN1Qw
    
    ===========1.公钥加密,私钥解密==============
    原文:aattaggcctegthththfef/aat.mp4
    公钥加密后的数据：EfjUSb8my/YWrzOziQYKGuB9KbJeZO6uZSRsRZgaEu1m5zHujZ+FA9QK1abjn/ELgCmQw5B91BGFZia2ySbtMLe3n0bD32udI0ufeLA5n/uPEyuiKdrPQcgN22ugJXcrNL9Hbd6WbYbXzeraTK03k61yM2KmgfW/usjbGMjxJ+zoHtw6zHg6lX3O5QrHlx1Q/GUWI61gn4Lp3TsqlRg0YG5/BAOFsRSSdQibK2h2BHxwsiivTidbSc7Z7eSrWPC6T/j0PCgYjsW6O9lRKNdtSlMC6S3Nh9723i0MkqgcE0g8/QV0DxetSbvkFibvaNgh059KLsE0JWyIvINY6bDYFw
    私钥解密后的数据：aattaggcctegthththfef/aat.mp4
    
    ===========2.反向进行操作,私钥加密,公钥解密==============
    原文:4b9d373bed9f40b389f0e42ebaf729b4
    私钥加密后的数据：mQr+BUTDHakOJsUqt+g4UHeUC+pGBM6YjZmMcTFXT3mJw4EcbBdh1UF+R1rWCJc7l2ofsnWMnwosWCPuPJTN8LI2PYNICeXHOLCOWZ2DKz6ARdpZuebpPfnLJ0D5dK1oh/8ndgUiN/SBDaGgIK//3MQp2yRn+O+d3Xv193T2i7vRx/oDyI3/F0Ftbwj3L8RtSPIYv3Zf7c69xTsiYkwGZ3UWCLcEwaLD9d2k60VX2CQntWhJ5mTYHYdjA7z57oMz0hEx7WdUFMM+RLkhOIo8hljY3RjhwDN1BLru6wFfQ5ztnZ6kDaaJRKEdfzjePxZ4MQqI4hgHtHC1NrYV3ZIM0w
    公钥解密后的数据：4b9d373bed9f40b389f0e42ebaf729b4