38_安全密码学

制作密钥

KeyPairGenerator

对于非对称加密，他区分公钥和私钥 我们可以用 KeyPairGenerator 来为我们生成秘钥对。我们根据一个算法名称得到该生成器，调用generateKeyPair() 来生成秘钥对

现在我们来生成下RSA算法的秘钥对

    @Test
    @DisplayName("通过算法 创建密钥对生成器")
    public void getInstanceByAlgorithm() throws NoSuchAlgorithmException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

    }

KeyPair

得到KeyPair 对象，里面就能拿到公钥和私钥啦~~

        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();

对于对称加密，加密和解密都用的用一个钥匙，我们可以用KeyGenerator 来拿到这个秘钥，我们来拿下AES算法的秘钥吧

  @Test
    @DisplayName("通过算法 创建密钥生成器")
    public void getInstance() throws NoSuchAlgorithmException {
        String value = SymmetricAlgorithm.AES.getValue();

        KeyGenerator keyGenerator = KeyGenerator.getInstance(value);
        System.out.println(keyGenerator); // javax.crypto.KeyGenerator@10e92f8f
        String secretKeyStr = Base64.getEncoder().encodeToString(secretKey.getEncoded());
    }

Java安全框架本身内置了许多对称安全算法的实现，下面我们分别来获取下不同安全算法的秘钥

• DES

        String algorithm = "DES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();
        System.out.println(secretKey);    // com.sun.crypto.provider.DESKey@186b4

你要是觉得不够安全，再加随机字符做进一步增强

        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "DES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey);  // com.sun.crypto.provider.DESKey@fffe7ba8

• DESede

        String algorithm = "DESede";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();
        System.out.println(secretKey); // com.sun.crypto.provider.DESedeKey@b069a993

        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "DESede";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey);    // com.sun.crypto.provider.DESedeKey@4f964239

• AES

        String algorithm = "AES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();
        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1745d

  String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1745d

• RC2

        String algorithm = "RC2";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();
        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1be5d

        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "RC2";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@fffe4f87

• ARCFOUR

        String algorithm = "ARCFOUR";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1be5d

        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "ARCFOUR";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@fffe4f87

• Blowfish

        String algorithm = "Blowfish";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();
        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1be5d

可能你的需求，内置的算法不能满足你的需要，那么我们可以使用第三方lib，支撑一下。比如国密算法SM4,Java设计得很好的是，他提供了一个口子，让你注入这些三方算法。从而兼容他的安全框架体系。

        <!-- https://mvnrepository.com/artifact/org.bouncycastle/bcprov-jdk15on -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.70</version>
        </dependency>

        //请说明你的算法来源
        Security.addProvider(new BouncyCastleProvider());

        String algorithm = "SM4";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); // javax.crypto.spec.SecretKeySpec@1be5d

呵呵呵，是不是无缝衔接上了。

    @Test
    @DisplayName("生成 SM4 密钥算法的密钥 并使用 SecureRandom")
    public void generateSM4SecretKeyUseSecureRandom() throws NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, InvalidAlgorithmParameterException, NoSuchProviderException {
        Security.addProvider(new BouncyCastleProvider());
        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "SM4";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm, BouncyCastleProvider.PROVIDER_NAME);

        keyGenerator.init(new SecureRandom());

        SecretKey secretKey = keyGenerator.generateKey();

        System.out.println(secretKey); //javax.crypto.spec.SecretKeySpec@1bd4b

    }

SecureRandom

安全随机数，是Random的一个子类。针对安全框架使用的。

我们知道，Random类中实现的随机算法是伪随机，也就是有规则的随机。在进行随机时，随机算法的起源数字称为种子数(seed)，在种子数的基础上进行一定的变换，从而产生需要的随机数字。

相同种子数的Random对象，相同次数生成的随机数字是完全相同的。也就是说，两个种子数相同的Random对象，生成的随机数字完全相同。

所以在需要频繁生成随机数，或者安全要求较高的时候，不要使用Random，因为其生成的值其实是可以预测的。

• SecureRandom类提供加密的强随机数生成器 (RNG)
• 当然，它的许多实现都是伪随机数生成器 (PRNG) 形式，这意味着它们将使用确定的算法根据实际的随机种子生成伪随机序列
• 也有其他实现可以生成实际的随机数
• 还有另一些实现则可能结合使用这两项技术

SecureRandom和Random都是，也是如果种子一样，产生的随机数也一样： 因为种子确定，随机数算法也确定，因此输出是确定的。

只是说，SecureRandom类收集了一些随机事件，比如鼠标点击，键盘点击等等，SecureRandom 使用这些随机事件作为种子。这意味着，种子是不可预测的，而不像Random默认使用系统当前时间的毫秒数作为种子，有规律可寻。

@Test
    @DisplayName("内置两种随机数算法，NativePRNG 和 SHA1PRNG，看实例化的方法了。")
    public void getInstanceUseNativePRNG() throws NoSuchAlgorithmException {
        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "NativePRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        secureRandom.setSeed(userKey.getBytes());

        for (int i = 0; i < 10; i++) {
            byte[] bytes = secureRandom.generateSeed(5);
            System.out.println(Arrays.toString(bytes));
        }

        /**
         * [116, 89, 89, 98, 90]
         * [79, 36, -45, -1, 82]
         * [-93, -109, 88, 91, 82]
         * [-116, 45, -4, -91, 97]
         * [-100, 108, 29, -68, 119]
         * [21, 77, -48, 125, -104]
         * [-117, 110, -95, 93, -113]
         * [3, 42, 96, -5, -42]
         * [92, -32, -24, -21, -127]
         * [114, 31, 101, 93, -116]
         */

    }

    @Test
    @DisplayName("使用 SHA1PRNG 创建实例 用的比较多 ")
    public void getInstanceSHA1PRNG() throws NoSuchAlgorithmException {
        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        secureRandom.setSeed(userKey.getBytes(StandardCharsets.UTF_8));

        for (int i = 0; i < 10; i++) {
            byte[] bytes = secureRandom.generateSeed(5);
            System.out.println(Arrays.toString(bytes));
        }
        /**
         * [8, 70, 101, -54, -74]
         * [57, 110, -23, 100, 20]
         * [108, -45, -96, 45, -90]
         * [44, 69, -69, -59, -44]
         * [-54, 53, 20, 54, 87]
         * [-92, -94, 101, 51, -98]
         * [-48, 113, -73, -116, 123]
         * [104, 104, 113, 43, 66]
         * [60, 104, -70, 10, 48]
         * [63, -40, -97, -104, 86]
         */
    }

KeyFactory

一个具体实例，前端老哥存的那种很长一串的字符串，Java也想到了，给你提供一个工厂，将实例字面量转为Java对象Key对象的。

来，我们看看前端老哥存的那种很长一串字符串，如何转为Java对象的,下面对标非对称加密情形。

@Test
    @DisplayName("初始化RSA 算法的公钥和私钥")
    public void generatePublicKeyAndPrivateKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();

        PrivateKey privateKey = keyPair.getPrivate();

        byte[] privateKeyEncoded = privateKey.getEncoded();
        byte[] publicKeyEncoded = publicKey.getEncoded();

        String privateKeyStr = Base64.getEncoder().encodeToString(privateKeyEncoded);
        System.out.println(privateKeyStr);//我留着，不对外暴露
        FileUtil.writeString(privateKeyStr,new File("1.txt"), StandardCharsets.UTF_8);


        String publicKeyStr = Base64.getEncoder().encodeToString(publicKeyEncoded);
        FileUtil.writeString(publicKeyStr,new File("2.txt"), StandardCharsets.UTF_8);
        System.out.println(publicKeyStr); //给前端老哥
       
       
    }

  
    private String privateKeyStr = "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";

    private String publicKeyStr = "MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAu8+8RmNqMPUAp5fDW1ypofRGH7pagloWmBbEGHLjeT
  
    @Test
    @DisplayName("通过Key工厂将私钥字符串 变成 Java中的私钥对象")
    public void generatePrivate() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        //原内容进行了Base64编码,现在进行 解码成 字节数组
        byte[] encodeKey = Base64.getDecoder().decode(privateKeyStr);
        
        
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(encodeKey);
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        //拿到了Java抽象的对象 PrivateKey
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        
    }

    @Test
    @DisplayName("通过Key工厂将公钥字符串 变成 Java中的公钥对象")
    public void generatePublic() throws NoSuchAlgorithmException, InvalidKeySpecException {

        String algorithm = AsymmetricAlgorithm.RSA.getValue();;
        byte[] encodedKey = Base64.getDecoder().decode(publicKeyStr);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(encodedKey);

        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);       
}

如果你业务需要转为KeySpect的话，KeyFactory也可以做这样的转换工作

    @Test
    @DisplayName("返回给定密钥的规范(密钥材料)")
    public void getKeySpec() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();

        PrivateKey privateKey = keyPair.getPrivate();

       KeyFactory keyFactory = KeyFactory.getInstance(algorithm);

       // 公钥的密钥材料
        X509EncodedKeySpec x509EncodedKeySpec = keyFactory.getKeySpec(publicKey, X509EncodedKeySpec.class);
       
        // 私钥的密钥材料
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = keyFactory.getKeySpec(privateKey, PKCS8EncodedKeySpec.class);

    }

不能盲目认为非对称加密，两把钥匙就很安全了，听说RSA有人用量子计算机破解了，你只得加大bit位，减缓被大佬破解的可能性。来看看对称加密。对称加密是用户不需要关心那种RSA那种秘钥，谁没事在记事本记下一个这玩意。用户只需要一个口令，这个口令用户自己决定，可以是123456，这极度好记，就能把数据加解密。

SecretKeyFactory

PBE家族

对称加密的算法就很多了，算法和Key一对一。我们如果生产出对称加密的秘钥呢？看下SecretKeyFactory,该工厂就是专门做这个事情的。

 @Test
    @DisplayName("生成密钥，使用 PBE")
    public void GenerateSecretKeyByPBE() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBE";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(secretKey);  // com.sun.crypto.provider.PBEKey@431249b0
        
    }

  @Test
    @DisplayName("生成密钥，使用PBEWithMD5AndDES")
    public void GenerateSecretKeyByPBEWithMD5AndDES() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String  algorithm = "PBEWithMD5AndDES";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey pebWithMD5AndDesSecretKey = secretKeyFactory.generateSecret(pbeKeySpec);
        
        System.out.println(pebWithMD5AndDesSecretKey);
        // com.sun.crypto.provider.PBEKey@431249b0
        
    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithMD5AndTripleDES")
    public void GenerateSecretKeyByPBEWithMD5AndTripleDES() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithMD5AndTripleDES";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(secretKey);  // com.sun.crypto.provider.PBEKey@9297d5d2


    }

   @Test
    @DisplayName("生成密钥，使用 PBEWithSHA1AndDESede")
    public void GenerateSecretKeyByPBEWithSHA1AndDESede() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithSHA1AndDESede";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(secretKey);  // com.sun.crypto.provider.PBEKey@9297d5d2


    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithSHA1AndRC2_40")
    public void GenerateSecretKeyByPBEWithSHA1AndRC2_40() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithSHA1AndRC2_40";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(secretKey);  // com.sun.crypto.provider.PBEKey@d1555e83
}

 @Test
    @DisplayName("生成密钥，使用 PBEWithSHA1AndRC2_128")
    public void GenerateSecretKeyByPBEWithSHA1AndRC2_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithSHA1AndRC2_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]


    }

 @Test
    @DisplayName("生成密钥，使用 PBEWithSHA1AndRC4_128")
    public void GenerateSecretKeyByPBEWithSHA1AndRC4_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithSHA1AndRC4_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]


    }

     @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA1AndAES_128")
    public void GenerateSecretKeyByPBEWithHmacSHA1AndAES_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA1AndAES_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA224AndAES_128")
    public void GenerateSecretKeyByPBEWithHmacSHA1AndAES_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA224AndAES_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
    }

     @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA256AndAES_128")
    public void GenerateSecretKeyByPBEWithHmacSHA256AndAES_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA256AndAES_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
    }

  @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA384AndAES_128")
    public void GenerateSecretKeyByPBEWithHmacSHA384AndAES_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA384AndAES_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
        
    }

     @Test
    @DisplayName("生成密钥，使用 P1BEWithHmacSHA1AndAES_256")
    public void GenerateSecretKeyByPBEWithHmacSHA1AndAES_256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA1AndAES_256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
        
    }

     @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA512AndAES_128")
    public void GenerateSecretKeyByPPBEWithHmacSHA512AndAES_128() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA512AndAES_128";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA224AndAES_256")
    public void GenerateSecretKeyByPBEWithHmacSHA224AndAES_256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA224AndAES_256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]


    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA256AndAES_256")
    public void GenerateSecretKeyByPBEWithHmacSHA256AndAES_256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA256AndAES_256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]
        
    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA384AndAES_256")
    public void GenerateSecretKeyByPBEWithHmacSHA384AndAES_256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA384AndAES_256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]


    }

    @Test
    @DisplayName("生成密钥，使用 PBEWithHmacSHA512AndAES_256")
    public void GenerateSecretKeyByPBEWithHmacSHA512AndAES_256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBEWithHmacSHA512AndAES_256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        //[49, 50, 51, 52, 53, 54, 55, 56, 57]


    }

PBK

  @Test
    @DisplayName("生成密钥，使用 PBKDF2WithHmacSHA1")
    public void GenerateSecretKeyByPBKDF2WithHmacSHA1() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBKDF2WithHmacSHA1";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        int keyLength = 512;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount,keyLength);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
    }

     @Test
    @DisplayName("生成密钥，使用 PBKDF2WithHmacSHA224")
    public void GenerateSecretKeyByPBKDF2WithHmacSHA224() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBKDF2WithHmacSHA224";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        int keyLength = 512;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount,keyLength);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        
    }

    @Test
    @DisplayName("生成密钥，使用 PBKDF2WithHmacSHA256")
    public void GenerateSecretKeyByPBKDF2WithHmacSHA256() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBKDF2WithHmacSHA256";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        int keyLength = 512;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount,keyLength);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
    }

    @Test
    @DisplayName("生成密钥，使用 PBKDF2WithHmacSHA384")
    public void GenerateSecretKeyByPBKDF2WithHmacSHA384() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBKDF2WithHmacSHA384";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        int keyLength = 512;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount,keyLength);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        
    }

    @Test
    @DisplayName("生成密钥，使用 PBKDF2WithHmacSHA512")
    public void GenerateSecretKeyByPBKDF2WithHmacSHA512() throws InvalidKeySpecException, NoSuchAlgorithmException {
        String algorithm = "PBKDF2WithHmacSHA512";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);

        char[] password = "123456789".toCharArray();
        SecureRandom secureRandom = new SecureRandom();
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;
        int keyLength = 512;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount,keyLength);
        SecretKey secretKey = secretKeyFactory.generateSecret(pbeKeySpec);

        System.out.println(Arrays.toString(secretKey.getEncoded()));
        
    }

DeSede

 @Test
@DisplayName("生成 DeSede 算法那使用的 SecretKey")
public void generateDESedeSecretKey() throws InvalidKeySpecException, NoSuchAlgorithmException, InvalidKeyException {
        // 长度不得小于24
        String userKey =  "123456789012345678901234" ;


        DESedeKeySpec deSedeKeySpec = new DESedeKeySpec(userKey.getBytes(StandardCharsets.UTF_8));
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance( "Desede");
        SecretKey  secretKey = secretKeyFactory.generateSecret(deSedeKeySpec);
        }

看到了么，这个工厂方法generateSecret()极度通用,你需要告诉我秘钥规范就行，我就能给秘钥。

说说秘钥

Key

Key 是Java世界里对算法秘钥对象的抽象，主要抽象了三种行为。

getEncoded

返回主编码格式的键，如果该键不支持编码，则返回NULL。

    @Test
    @DisplayName("秘钥值")
    public void getEncoded() throws NoSuchAlgorithmException {

        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance( AsymmetricAlgorithm.RSA.getValue());
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PrivateKey privateKey = keyPair.getPrivate();
        byte[] encoded = privateKey.getEncoded();
        System.out.println(encoded.length);  // 1792

    }

getFormat

    @Test
    @DisplayName("返回该键的主要编码格式的名称")
    public void getFormat() throws NoSuchAlgorithmException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PrivateKey privateKey = keyPair.getPrivate();

        String format = privateKey.getFormat();
        System.out.println(format);

        PublicKey publicKey = keyPair.getPublic();
        String format1 = publicKey.getFormat();
        System.out.println(format1);
        /**
         * PKCS#8
         * X.509
         */
    }

KeySpec

主要是说制作Key需要的原材料对象。我们按照算法分类，非对称，对称，摘要加密来分类如果构建对应Key时需要的原材料。

• 非对称(以RSA举例)

PKCS8EncodedKey

   @Test
    @DisplayName("创建PKCS8EncodedKeySpec对象")
    public void PKCS8EncodedKeySpecNew() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();


        PrivateKey privateKey = keyPair.getPrivate();
        
		//使用私钥对象的编码值来创建
        byte[] privateKeyEncoded = privateKey.getEncoded();
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(privateKeyEncoded);
    }

X509EncodedKeySpec

    @Test
    @DisplayName("创建X509EncodedKeySpec对象")
    public void X509EncodedKeySpecNew() throws NoSuchAlgorithmException, InvalidKeySpecException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        PublicKey publicKey = keyPair.getPublic();

   
		//使用公钥对象的编码值来创建
        byte[] publicKeyEncoded = publicKey.getEncoded();
 X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(publicKeyEncoded);


    }

• 对称加密（以DES DESede PEB AES RC2 ARCFOUR Blowfish SM4 举例,代码按此序）

    @Test
@DisplayName("创建DESKeySpec对象")
public void DESKeySpecNew() throws NoSuchAlgorithmException, InvalidKeyException {
        String algorithm = "DES";
        String key = "123456";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        }

@Test
@DisplayName("创建DESedeKeySpec对象")
public void DESedeKeySpecNew() throws NoSuchAlgorithmException, InvalidKeyException {
        String algorithm = "DESede";
        String key = "123456";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@b069b142
        }

  @Test
    @DisplayName("创建PBEKeySpec对象")
    public void PBEKeySpecNew() throws NoSuchAlgorithmException, InvalidKeyException {
        // 密码
        char[] password = "123456".toCharArray();
        //盐
        SecureRandom random = new SecureRandom();
        byte[] salt = random.generateSeed(8);

        //迭代次数
        int iterationCount = 10;

        PBEKeySpec pbeKeySpec = new PBEKeySpec(password,salt,iterationCount);
    }

    @Test
    @DisplayName("创建AesKeySpec对象")
    public void AesKeySpecNew()  {
        String key = "123456";
        String algorithm = "AES";
       
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@17bd9
    }

    @Test
    @DisplayName("创建RC2KeySpec对象")
    public void RC2KeySpecNew() {
        String key = "123456";
        String algorithm = "RC2";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@17bd9
    }

   @Test
    @DisplayName("创建 ARCFOURKeySpec 对象")
    public void ARCFOURKeySpecNew() {
        String key = "123456";
        String algorithm = "ARCFOUR";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@17bd9
    }

    @Test
    @DisplayName("创建 BlowfishKeySpec 对象")
    public void BlowfishKeySpecNew() {
        String key = "123456";
        String algorithm = "Blowfish";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@d97afe1c
    }

   @Test
    @DisplayName("创建 SM4KeySpec 对象")
    public void SM4KeySpecNew() {
        Security.addProvider(new BouncyCastleProvider());
        String key = "123456";
        String algorithm = "SM4";
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
        System.out.println(secretKeySpec); // javax.crypto.spec.SecretKeySpec@1be0c
    }

• 摘要Hash加密（以HmacMD5举例）

  @Test
    @DisplayName("创建 HmacMD5KeySpec 对象")
    public void HmacMD5SpecNew() {
        String useKey = "123456789";
        String algorithm = "HmacMD5";
        SecretKey secretKey = new SecretKeySpec(useKey.getBytes(), algorithm);

    }

IvParameterSpec

在了解下文的加密模式后，你就知道Java为啥设计这么一个类表示初始化向量了。

@Test
@DisplayName("根据 initVector 创建IV参数规范 ")
public void IvParameterSpecNew()  {
    // 必须 16 位
    byte[] initVector = "1234567812345wnx".getBytes(StandardCharsets.UTF_8);
    IvParameterSpec iv = new IvParameterSpec(initVector);

}

RC2ParameterSpec

     @Test
    @DisplayName("根据 rc2ParameterSpec 创建RC2 参数规范 ")
    public void RC2ParameterSpecNew()  {
        int effectiveKeyBits = 100;
        RC2ParameterSpec rc2ParameterSpec = new RC2ParameterSpec(effectiveKeyBits);

    }

PBEParameterSpec

 @Test
    @DisplayName("根据盐 和 迭代次数 创建PBE参数规范 ")
    public void PBEParameterSpecNew()  {
   
        SecureRandom secureRandom = new SecureRandom();
        
        byte[] salt = secureRandom.generateSeed(8);
        int iterationCount = 1000;

    
        PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt,iterationCount);
    }

加解密

java安全框架，封装了一个对象Cipher来做这些具体加解密工作。可以说是整个安全体系框架的核心类了。我们只需要告诉Java，算法名，就能创建出Cipher对象啦,比如下面这样。

  @Test
    @DisplayName("根据RSA算法获取Cipher对象")
    public void getInstance() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        String algorithm = AsymmetricAlgorithm.RSA.getValue();
        Cipher cipher = Cipher.getInstance(algorithm);
    }

The following names can be specified as the algorithm component in a transformation when requesting an instance of Cipher. 在请求Cipher实例时，可以将以下名称指定为转换中的算法组件。（摘抄于JDK文档）

填充模式

在真正做加解密工作之前，我们还需要了解填充模式。数据长度在实际中并不是一定符合算法本身设置的长度字节。当需要按块处理的数据，数据长度不符合块处理需求时，会按照一定的方法填充块长的规则。

来看下Java支持的填充模式。

某些加密算法要求明文需要按一定长度对齐，叫做块大小(BlockSize)，比如16字节，那么对于一段任意的数据，加密前需要对最后一个块填充到16 字节，解密后需要删除掉填充的数据。

ZeroPadding，数据长度不对齐时使用0填充，否则不填充。

PKCS7Padding，假设数据长度需要填充n(n>0)个字节才对齐，那么填充n个字节，每个字节都是n;如果数据本身就已经对齐了，则填充一块长度为块大小的数据，每个字节都是块大小。

PKCS5Padding，PKCS7Padding的子集，块大小固定为8字节。

由于使用PKCS7Padding/PKCS5Padding填充时，最后一个字节肯定为填充数据的长度，所以在解密后可以准确删除填充的数据，而使用ZeroPadding填充时，没办法区分真实数据与填充数据，所以只适合以\0结尾的字符串加解密。

• 1、NoPadding

不填充

因为不填充，所以对标DES加密算法中，要求原文必须是8byte的整数倍，对标AES加密算法中，要求原文必须是16byte的整数倍。

• 2、ZeroPadding（Java没有）

而Java中又不提供ZeroPadding,我们在使用NoPadding 填充时，当最后一个块不是 8 byte 或者 16 byte字节时，我们就要对原文进行自行填充。据说C# 有这个ZeroPadding 填充0.

在解密时，再删除掉填充的数据。

• 3、PKCS5Padding

数据块的大小为8位，不够就补足8位。

• Java中，默认情况下，加密模式和填充模式为：ECB/PKCS5Padding
• 如果要使用 CBC 模式，在初始化 Cipher对象时，需要添加参数,初始化向量 IV IvParameterSpec iv = IvParameterSpec(byte[] iv)

加密算法模式

he following names can be specified as the mode component in a transformation when requesting an instance of Cipher. JDK8支持的加密算法模式,可以将以下名称指定为[转换]中的模式组件.(摘抄于JDK官方文档)

可以将以下名称指定为[转换]中的模式组件

这里简单说一下加密算法模式，不要把它与加密算法混淆起来，加密算法就是使用何种方式加密，比如：DES、AES、RSA，而加密算法模式，是用来描述加密算法（此处特指分组密码，不包括流密码，）在加密时对明文分组的模式，它代表了不同的分组方式，如常见的：

ECB模式：电子密码本模式

CBC模式：密码分组连接模式

CBC模式在对明文分组加密时，会将明文分组与前一个密文分组进行XOR运算（即异或运算），但是加密第一个明文分组时不存在“前一个密文分组”，因此需要事先准备一个与分组长度相等的比特序列来代替，这个比特序列就是偏移量。（见网络工程师教程一书）

在Java中，会把这向量 抽象成 IvParameterSpec

CFB模式：密文反馈模式

OFB模式：输出反馈模式

CTR模式：计数器模式

在了解了填充模式和加密算法模式之后，我们从对称、非对称、摘要(Hash）三个角度开始，来做加解密工作。

• 1、非对称

RSA

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.util.Base64Utils;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class CipherTest {

    
    String privateKeyStr = "MIICdwIBADANBgkqhkiG9....";
    String publicKeyStr = "MIGfMA0GCSqGSIb3DQEBAQUA..";


    @Test
    @DisplayName("公钥加密 私钥解密")
    public void publicEncUsePriDen() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        String transformation = "RSA";
        Cipher cipher = Cipher.getInstance(transformation);


        String algorithm = "RSA";
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64Utils.decode(publicKeyStr.getBytes()));
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);


        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64Utils.decode(privateKeyStr.getBytes()));
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes());
        String result = Base64Utils.encodeToString(secret);
        System.out.println("加密：" + result);

        cipher.init(Cipher.DECRYPT_MODE,privateKey);
        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));

    }

    @Test
    @DisplayName("私钥加密 公钥解密（验签）")
    public void priEncUsePublicDec() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeySpecException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
        String transformation = "RSA";
        Cipher cipher = Cipher.getInstance(transformation);


        String algorithm = "RSA";
        KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64Utils.decode(publicKeyStr.getBytes()));
        PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);


        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64Utils.decode(privateKeyStr.getBytes()));
        PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes());
        String result = Base64Utils.encodeToString(secret);
        System.out.println("加密：" + result);

        cipher.init(Cipher.DECRYPT_MODE,publicKey);
        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));

    }
}

• 2、对称

AES

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;

public class CipherTest {



    @Test
    @DisplayName("处理AES加密 解密")
    public void aesEncryptAndDecrypt() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {

        String source = "12346";
        // 这里的userKey 其实就是 SecureRandom 的种子 基于该种子 会得到一个16 位的秘钥 secretKey
        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();

        String  transformation = "AES/ECB/PKCS5Padding";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);



        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));

        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);


        //解密
        cipher.init(Cipher.DECRYPT_MODE,secretKey);


        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));
        /**
         * 加密结果：SMQHFyeAwWnGyjv4qjD3/Q==
         * 解密结果：12346
         */

    }

    @Test
    @DisplayName("同样也是AES加密 只是秘钥的生成方式不同 ")
    public void aesEncryptGetSecretKeyDifferent() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
        String source = "12346";
        // 这里的userKey 就是 秘钥 secretKey AES 规定了必须是16位！
        String userKey = "wangnaixing@spri";

        System.out.println(userKey.length());

        String algorithm = "AES";
        SecretKey secretKey = new SecretKeySpec(userKey.getBytes(StandardCharsets.UTF_8),
                algorithm);

        String  transformation = "AES/ECB/PKCS5Padding";
        Cipher cipher = Cipher.getInstance(transformation);

        cipher.init(Cipher.ENCRYPT_MODE,secretKey);

        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));

        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);


        //解密
        cipher.init(Cipher.DECRYPT_MODE,secretKey);


        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));

        /**
         * 16
         * 加密结果：7nLgfZNZc1N8o4ApjUJlpQ==
         * 解密结果：12346
         */
    }


}

AES/CBC/NoPadding

package com.wnx.naizi;

import cn.hutool.core.util.StrUtil;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.*;

/**
 * @ClassName: AESTest
 * @Package: com.wnx.naizi
 * @Description:
 * @Author: wangnaixing
 * @Create: 2022/12/22 - 22:33
 * @Version:v1.0
 */
public class AESTest {

    @Test
    @DisplayName("AES/CBC/NoPadding")
    public void NoPadding() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException, InvalidKeyException, InvalidAlgorithmParameterException {

        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();

        String  transformation = "AES/CBC/NoPadding";
        Cipher cipher = Cipher.getInstance(transformation);


        int blockSize = cipher.getBlockSize();
        String source = "12346";

        // 因为原加密数据 最后一个数据块 不够16个字节   而Java原生没有ZeroPadding模式,所以手动构建 ZeroPadding
        byte[] dataBytes = source.getBytes();
        int length = dataBytes.length;
        if (length % blockSize != 0) {
            length = length + (blockSize - (length % blockSize));
        }
        byte[] plaintext = new byte[length];
        System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);




        byte[] iv = "0000000000000000".getBytes();
        IvParameterSpec ivSpec = new IvParameterSpec(iv);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey,ivSpec);



        byte[] secret = cipher.doFinal(plaintext);
        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);



        cipher.init(Cipher.DECRYPT_MODE,secretKey,ivSpec);
        byte[] bytes = cipher.doFinal(secret);
        // 所以在解密后可以准确删除填充的数据
        System.out.println("解密结果："+ StrUtil.trimEnd(new String(bytes)));

        /**
         * 加密结果：SMQHFyeAwWnGyjv4qjD3/Q==
         * 解密结果：12346
         */

    }
}

AES/ECB/PKCS5Padding

 @Test
    @DisplayName("AES/ECB/PKCS5Padding")
    public void transformationUseOne() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {

        String source = "12346";
        // 这里的userKey 其实就是 SecureRandom 的种子 基于该种子 会得到一个16 位的秘钥 secretKey
        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();

        String  transformation = "AES/ECB/PKCS5Padding";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);



        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));

        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);


        //解密
        cipher.init(Cipher.DECRYPT_MODE,secretKey);


        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));
        /**
         * 加密结果：SMQHFyeAwWnGyjv4qjD3/Q==
         * 解密结果：12346
         */

    }

AES/CBC/PKCS7Padding

    @Test
    @DisplayName("AES/CBC/PKCS7Padding")
    public void transformationUseTwo() throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException {
        String source = "12346";
        // 这里的userKey 其实就是 SecureRandom 的种子 基于该种子 会得到一个16 位的秘钥 secretKey
        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();
        
        // 要添加 算法提供者
        Security.addProvider(new BouncyCastleProvider());
        String  transformation = "AES/CBC/PKCS7Padding";
        Cipher cipher = Cipher.getInstance(transformation);

        // 16 位 iv
        byte[] initVector = "1234567812345678".getBytes(StandardCharsets.UTF_8);
        IvParameterSpec iv = new IvParameterSpec(initVector);

        cipher.init(Cipher.ENCRYPT_MODE, secretKey,iv);


        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));
        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);


        //解密
        cipher.init(Cipher.DECRYPT_MODE,secretKey,iv);


        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));

        /**
         *加密结果：nJdZblr0zrdY4CugGkrwiA==
         * 解密结果：12346
         */

    }

JDK没有提供 AES/CBC/PKCS7Padding 填充算法，需要导入包。

 <dependency>
		<groupId>org.bouncycastle</groupId>
		<artifactId>bcprov-jdk16</artifactId>
		<version>1.46</version>
</dependency>

AES/CBC/PKCS5Padding

    @Test
    @DisplayName("AES/CBC/PKCS5Padding")
    public void transformationUseThree() throws NoSuchPaddingException, NoSuchAlgorithmException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException, InvalidAlgorithmParameterException {
        String source = "12346";
        // 这里的userKey 其实就是 SecureRandom 的种子 基于该种子 会得到一个16 位的秘钥 secretKey
        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();

        // 16 位 iv
        byte[] initVector = "1234567812345678".getBytes(StandardCharsets.UTF_8);
        IvParameterSpec iv = new IvParameterSpec(initVector);

        String  transformation = "AES/CBC/PKCS5Padding";


        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey,iv);



        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));

        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);


        //解密
        cipher.init(Cipher.DECRYPT_MODE,secretKey,iv);


        byte[] bytes = cipher.doFinal(secret);
        System.out.println("解密结果："+new String(bytes));

        /**
         * 加密结果：nJdZblr0zrdY4CugGkrwiA==
         * 解密结果：12346
         */


    }

AES/ECB/NoPadding

我前面说了，Java没有实现NoPadding模式，所以这里我简单实现了下。

package com.wnx.naizi;

import cn.hutool.core.util.StrUtil;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.*;

/**
 * @ClassName: AESTest
 * @Package: com.wnx.naizi
 * @Description:
 * @Author: wangnaixing
 * @Create: 2022/12/25 - 15:16
 * @Version:v1.0
 */
public class AESTest {
    @Test
    @DisplayName("AES/ECB/NoPadding")
    public void NoPadding() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, UnsupportedEncodingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException, InvalidKeyException, InvalidAlgorithmParameterException, InvalidKeyException {

        String userKey = "wangnaixing@springBoot";

        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "AES";
        KeyGenerator generator = KeyGenerator.getInstance(algorithm);
        generator.init(secureRandom);
        Key secretKey =  generator.generateKey();

        String  transformation = "AES/ECB/NoPadding";
        Cipher cipher = Cipher.getInstance(transformation);


        int blockSize = cipher.getBlockSize();
        String source = "12346";

        // 因为原加密数据 最后一个数据块 不够16个字节   而Java原生没有ZeroPadding模式,所以手动构建 ZeroPadding
        byte[] dataBytes = source.getBytes();
        int length = dataBytes.length;
        if (length % blockSize != 0) {
            length = length + (blockSize - (length % blockSize));
        }
        byte[] plaintext = new byte[length];
        System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);





        cipher.init(Cipher.ENCRYPT_MODE, secretKey);



        byte[] secret = cipher.doFinal(plaintext);
        String result = java.util.Base64.getEncoder().encodeToString(secret);
        System.out.println("加密结果："+result);



        cipher.init(Cipher.DECRYPT_MODE,secretKey);
        byte[] bytes = cipher.doFinal(secret);
        // 所以在解密后可以准确删除填充的数据
        System.out.println("解密结果："+ StrUtil.trimEnd(new String(bytes)));

        /**
         * 加密结果：lxhdLy677lKdtRdavV98XA==
         * 解密结果：12346
         */
    }
}

DES

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;


public class DESTest {

    @Test
    @DisplayName("处理DES加密 解密")
    public void desEncryptAndDecrypt() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException {
        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "DES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();


        String transformation = "DES";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey);



        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);

        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] bytes = cipher.doFinal(secret);
        
        System.out.println("解密结果："+new String(bytes));
        /**
         * 加密结果：ETre2lTFFzk=
         * 解密结果：123456
         */
    }
    

    @Test
    @DisplayName("同样也是DES加解密 只是秘钥的生成方式不同 ")
    public void desEncryptGetSecretKeyDifferent() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException {
        // -_-    这里老哥要把userKey    必须64 位
        String userKey = "gkalgksdngskadng12123456789123456789qwertyuiojsacgafgdasfs123456";
        DESKeySpec desKeySpec  = new DESKeySpec(userKey.getBytes(StandardCharsets.UTF_8));
        String algorithm = "DES";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);
        SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);



        String transformation = "DES";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey);



        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);

        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] bytes = cipher.doFinal(secret);

        System.out.println("解密结果："+new String(bytes));
        /**
         * 加密结果：RGGFISTk82I=
         * 解密结果：123456
         *
         */
    }

    @Test
    @DisplayName("这种方式 是在第一种方式 上不要 SecureRandom ")
    public void desEncryptAndDecryptEasyWay() throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException {


        String algorithm = "DES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        SecretKey secretKey = keyGenerator.generateKey();


        String transformation = "DES";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey);



        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);

        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] bytes = cipher.doFinal(secret);

        System.out.println("解密结果："+new String(bytes));
        /**
         * 加密结果：W598cif2Xkg=
         * 解密结果：123456
         */
    }
}

DES/ECB/PKCS5Padding

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;


public class DESTest {

    @Test
    @DisplayName("DES/ECB/PKCS5Padding")
    public void jdkDESEncryptAndDecrypt() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException {
        // -_- 必须64 位
        String userKey = "gkalgksdngskadng12123456789123456789qwertyuiojsacgafgdasfs123456";
        DESKeySpec desKeySpec  = new DESKeySpec(userKey.getBytes(StandardCharsets.UTF_8));
        String algorithm = "DES";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);
        SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);



        String transformation = "DES/ECB/PKCS5Padding";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey);



        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);

        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] bytes = cipher.doFinal(secret);
        
        System.out.println("解密结果："+new String(bytes));

        /**
         * 加密结果：RGGFISTk82I=
         * 解密结果：123456
         */

    }

}

DES/ECB/NoPadding

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;

/**
 * @ClassName: DESTest
 * @Package: com.wnx.naizi
 * @Description:
 * @Author: wangnaixing
 * @Create: 2022/12/25 - 15:21
 * @Version:v1.0
 */
public class DESTest {

    @Test
    @DisplayName("DES/ECB/NoPadding")
    public void jdkDESEncryptAndDecrypt() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, InvalidKeyException {
        String userKey = "wangnaixing@springBoot";
        String randomAlgorithm = "SHA1PRNG";
        SecureRandom secureRandom = SecureRandom.getInstance(randomAlgorithm);
        byte[] seed = userKey.getBytes(StandardCharsets.UTF_8);
        secureRandom.setSeed(seed);

        String algorithm = "DES";
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        keyGenerator.init(secureRandom);
        SecretKey secretKey = keyGenerator.generateKey();



        String transformation = "DES/ECB/NoPadding";
        Cipher cipher = Cipher.getInstance(transformation);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey);




        String source = "123456";

        // 因为原加密数据 最后一个数据块 不够16个字节   而Java原生没有ZeroPadding模式,所以手动构建 ZeroPadding
        byte[] dataBytes = source.getBytes();
        int blockSize = cipher.getBlockSize();
        int length = dataBytes.length;
        if (length % blockSize != 0) {
            length = length + (blockSize - (length % blockSize));
        }
        byte[] plaintext = new byte[length];
        System.arraycopy(dataBytes, 0, plaintext, 0, dataBytes.length);


        byte[] secret = cipher.doFinal(plaintext);


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);


        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        byte[] bytes = cipher.doFinal(secret);

        System.out.println("解密结果："+new String(bytes).trim());

        /**
         * 加密结果：zH+BB+piRC4=
         * 解密结果：123456
         */

    }
}

DES/CBC/PKCS5Padding

package com.wnx.naizi;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import javax.crypto.*;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.spec.InvalidKeySpecException;
import java.util.Base64;


public class DESTest {

    @Test
    @DisplayName("DES/CBC/PKCS5Padding")
    public void jdkDESEncryptAndDecrypt() throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, InvalidAlgorithmParameterException {
        // -_- 必须64 位
        String userKey = "gkalgksdngskadng12123456789123456789qwertyuiojsacgafgdasfs123456";
        DESKeySpec desKeySpec  = new DESKeySpec(userKey.getBytes(StandardCharsets.UTF_8));
        String algorithm = "DES";
        SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(algorithm);
        SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);



        String transformation = "DES/CBC/PKCS5Padding";
        Cipher cipher = Cipher.getInstance(transformation);

        byte[] initVector = "12345678".getBytes(StandardCharsets.UTF_8);
        IvParameterSpec ivParameterSpec = new IvParameterSpec(initVector);
        cipher.init(Cipher.ENCRYPT_MODE,secretKey,ivParameterSpec);



        String source = "123456";
        byte[] secret = cipher.doFinal(source.getBytes(StandardCharsets.UTF_8));


        String result = Base64.getEncoder().encodeToString(secret);

        System.out.println("加密结果："+result);

        cipher.init(Cipher.DECRYPT_MODE, secretKey,ivParameterSpec);
        byte[] bytes = cipher.doFinal(secret);

        System.out.println("解密结果："+new String(bytes));

        /**
         * 加密结果：V67A54IaVYs=
         * 解密结果：123456
         */

    }



}