java编码解码加密解密--md5、SHA-256、SHA-512、MAC、DES、AES

喜欢ヅ旅行 2022-09-09 06:23 1811阅读 0赞

md5

md5是一种散列算法，不可逆，是一种消息摘要算法，生成的字节数组的长度是128位，也就是等于16个字节，那么有的字节转化为字符之后，这些字符不一定是存在于ascii码之中，通常为了便于输出，我们会将每个字节转变为16进制字符串，每个16进制都是2个字符，所以md5转化之后的字符是32个字符。

这里有个技术点需要注意的是，在对每个字节进行转化为16进制的字符串的 时候，0-15这几个值的字节，转化为的字符串的长度都是1，所以需要在前面补0

jdk原生md5

  1. /**
  2.      * jdk原生md5
  3.      */
  4.     public static void md5() throws Exception {
  6.         String str = "hello聚合";
  7.         String algorithm = "MD5";
  8.         MessageDigest instance = MessageDigest.getInstance(algorithm);
  9.         byte[] digest = instance.digest(str.getBytes(StandardCharsets.UTF_8));
  10.         System.out.println(new String(digest));
  11.         //如果直接输出的话，是乱码�G�s�.u�Iz�۲�
  12.         //这是因为md5生成的消息摘要是128位，也就是等于16个字节，那么有的字节转化为字符之后，这些字符不一定是存在于ascii码之中的
  13.         //通常为了便于输出，我们会将每个字节转变为16进制字符串，每个16进制都是2个字符，所以md5转化之后的字符是32个字符
  14.         StringBuilder stringBuilder = new StringBuilder();
  15.         for (byte b : digest) {
  17.             //每个字节转与0xff（1111 1111）按位与，得到这个字节的补码
  18.             String hex = Integer.toHexString(b & 0xff);
  19.             //如果生成的16进制的字符的长度是1，那么需要在前面补0，比如
  20.             //0,5,10,13,15的16进制分别是是0，5，a,d,f，长度只有1，所以需要前面补0
  21.             if (hex.length() == 1) {
  23.                 hex = "0" + hex;
  24.             }
  25.             stringBuilder.append(hex);
  26.         }
  27.         System.out.println(stringBuilder);
  28.     }
  29. }

使用commons-codec

需要引入jar包

  1. <dependency>
  2.             <groupId>commons-codec</groupId>
  3.             <artifactId>commons-codec</artifactId>
  4.             <version>1.15</version>
  5.         </dependency>
  7. /**
  8.      * 使用commons-codec
  9.      */
  10.     public static void md5codec() {
  12.         String str = "hello聚合";
  13.         String encode = DigestUtils.md5Hex(str.getBytes(StandardCharsets.UTF_8));
  14.         System.out.println(encode);
  16.     }

全部代码

  1. package codec.md5;
  3. import org.apache.commons.codec.digest.DigestUtils;
  5. import java.nio.charset.StandardCharsets;
  6. import java.security.MessageDigest;
  8. /**
  9.  * @author micro.cloud.fly
  10.  * @date 2021/8/30 11:28 上午
  11.  * @desc md5消息摘要算法学习笔记
  12.  */
  13. public class Demo1 {
  16.     public static void main(String[] args) throws Exception {
  18.         md5();
  19.         System.out.println();
  20.         md5codec();
  21.     }
  23.     /**
  24.      * jdk原生md5
  25.      */
  26.     public static void md5() throws Exception {
  28.         String str = "hello聚合";
  29.         String algorithm = "MD5";
  30.         MessageDigest instance = MessageDigest.getInstance(algorithm);
  31.         byte[] digest = instance.digest(str.getBytes(StandardCharsets.UTF_8));
  32.         System.out.println(new String(digest));
  33.         //如果直接输出的话，是乱码�G�s�.u�Iz�۲�
  34.         //这是因为md5生成的消息摘要是128位，也就是等于16个字节，那么有的字节转化为字符之后，这些字符不一定是存在于ascii码之中的
  35.         //通常为了便于输出，我们会将每个字节转变为16进制字符串，每个16进制都是2个字符，所以md5转化之后的字符是32个字符
  36.         StringBuilder stringBuilder = new StringBuilder();
  37.         for (byte b : digest) {
  39.             //每个字节转与0xff（1111 1111）按位与，得到这个字节的补码
  40.             String hex = Integer.toHexString(b & 0xff);
  41.             //如果生成的16进制的字符的长度是1，那么需要在前面补0，比如
  42.             //0,5,10,13,15的16进制分别是是0，5，a,d,f，长度只有1，所以需要前面补0
  43.             if (hex.length() == 1) {
  45.                 hex = "0" + hex;
  46.             }
  47.             stringBuilder.append(hex);
  48.         }
  49.         System.out.println(stringBuilder);
  50.     }
  52.     /**
  53.      * 使用commons-codec
  54.      */
  55.     public static void md5codec() {
  57.         String str = "hello聚合";
  58.         String encode = DigestUtils.md5Hex(str.getBytes(StandardCharsets.UTF_8));
  59.         System.out.println(encode);
  61.     }
  62. }

SHA-256

sha-256和md5一样，都是消息摘要算法，只不过是摘要后的长度是256位，也就是32个字节，同理，在转化为16进制的字符串之后，是64个字节，实现了md5之后，只要把算法algorithm改为SHA-256即可，以下是全部的代码

全部代码

  1. package codec.sha256;
  3. import org.apache.commons.codec.digest.DigestUtils;
  5. import java.nio.charset.StandardCharsets;
  6. import java.security.MessageDigest;
  8. /**
  9.  * @author micro.cloud.fly
  10.  * @date 2021/8/30 11:28 上午
  11.  * @desc sha256消息摘要算法学习笔记
  12.  */
  13. public class Demo {
  16.     public static void main(String[] args) throws Exception {
  18.         md5();
  19.         System.out.println();
  20.         md5codec();
  21.     }
  23.     /**
  24.      * jdk原生md5
  25.      */
  26.     public static void md5() throws Exception {
  28.         String str = "hello聚合";
  29.         String algorithm = "SHA-256";
  30.         MessageDigest instance = MessageDigest.getInstance(algorithm);
  31.         byte[] digest = instance.digest(str.getBytes(StandardCharsets.UTF_8));
  32.         System.out.println(new String(digest));
  33.         //如果直接输出的话，是乱码�G�s�.u�Iz�۲�
  34.         //这是因为md5生成的消息摘要是128位，也就是等于16个字节，那么有的字节转化为字符之后，这些字符不一定是存在于ascii码之中的
  35.         //通常为了便于输出，我们会将每个字节转变为16进制字符串，每个16进制都是2个字符，所以md5转化之后的字符是32个字符
  36.         StringBuilder stringBuilder = new StringBuilder();
  37.         for (byte b : digest) {
  39.             //每个字节转与0xff（1111 1111）按位与，得到这个字节的补码
  40.             String hex = Integer.toHexString(b & 0xff);
  41.             //如果生成的16进制的字符的长度是1，那么需要在前面补0，比如
  42.             //0,5,10,13,15的16进制分别是是0，5，a,d,f，长度只有1，所以需要前面补0
  43.             if (hex.length() == 1) {
  45.                 hex = "0" + hex;
  46.             }
  47.             stringBuilder.append(hex);
  48.         }
  49.         System.out.println(stringBuilder);
  50.     }
  52.     /**
  53.      * 使用commons-codec
  54.      */
  55.     public static void md5codec() {
  57.         String str = "hello聚合";
  58.         String encode = DigestUtils.sha256Hex(str.getBytes(StandardCharsets.UTF_8));
  59.         System.out.println(encode);
  61.     }
  62. }

SHA-512

同sha-256原理一样，只要把algorithm算法名改为sha-512即可，以下是全部代码

  1. package codec.sha512;
  3. import org.apache.commons.codec.digest.DigestUtils;
  5. import java.nio.charset.StandardCharsets;
  6. import java.security.MessageDigest;
  8. /**
  9.  * @author micro.cloud.fly
  10.  * @date 2021/8/30 11:28 上午
  11.  * @desc sha512消息摘要算法学习笔记
  12.  */
  13. public class Demo {
  16.     public static void main(String[] args) throws Exception {
  18.         md5();
  19.         System.out.println();
  20.         md5codec();
  21.     }
  23.     /**
  24.      * jdk原生
  25.      */
  26.     public static void md5() throws Exception {
  28.         String str = "hello聚合";
  29.         String algorithm = "SHA-512";
  30.         MessageDigest instance = MessageDigest.getInstance(algorithm);
  31.         byte[] digest = instance.digest(str.getBytes(StandardCharsets.UTF_8));
  32.         System.out.println(new String(digest));
  33.         //如果直接输出的话，是乱码�G�s�.u�Iz�۲�
  34.         //这是因为md5生成的消息摘要是128位，也就是等于16个字节，那么有的字节转化为字符之后，这些字符不一定是存在于ascii码之中的
  35.         //通常为了便于输出，我们会将每个字节转变为16进制字符串，每个16进制都是2个字符，所以md5转化之后的字符是32个字符
  36.         StringBuilder stringBuilder = new StringBuilder();
  37.         for (byte b : digest) {
  39.             //每个字节转与0xff（1111 1111）按位与，得到这个字节的补码
  40.             String hex = Integer.toHexString(b & 0xff);
  41.             //如果生成的16进制的字符的长度是1，那么需要在前面补0，比如
  42.             //0,5,10,13,15的16进制分别是是0，5，a,d,f，长度只有1，所以需要前面补0
  43.             if (hex.length() == 1) {
  45.                 hex = "0" + hex;
  46.             }
  47.             stringBuilder.append(hex);
  48.         }
  49.         System.out.println(stringBuilder);
  50.     }
  52.     /**
  53.      * 使用commons-codec
  54.      */
  55.     public static void md5codec() {
  57.         String str = "hello聚合";
  58.         String encode = DigestUtils.sha512Hex(str.getBytes(StandardCharsets.UTF_8));
  59.         System.out.println(encode);
  61.     }
  62. }

MAC

mac也是一种消息摘要，同md5、SHA256算法不同的是，它在进行消息摘要的时候，需要一个key，相同于密钥，mac算法有macMD5、macSHA256、macSHA512等多种，在实现的时候，也是只需要改一个算法名称即可，以下是实现的全部代码

  1. package codec.lesson05_mac;
  3. import org.apache.commons.codec.digest.DigestUtils;
  4. import org.apache.commons.codec.digest.HmacAlgorithms;
  5. import org.apache.commons.codec.digest.HmacUtils;
  7. import javax.crypto.Mac;
  8. import javax.crypto.spec.SecretKeySpec;
  9. import java.nio.charset.StandardCharsets;
  11. /**
  12.  * @author micro.cloud.fly
  13.  * @date 2021/8/30 11:28 上午
  14.  * @desc mac消息摘要算法学习笔记
  15.  */
  16. public class Demo1 {
  19.     public static void main(String[] args) throws Exception {
  21.         mac();
  22.         System.out.println();
  23.         maccodec();
  24.     }
  26.     /**
  27.      * jdk原生md5
  28.      */
  29.     public static void mac() throws Exception {
  31.         String str = "hello聚合";
  32.         String key = "123";
  33.         String algorithm = "HmacMD5";
  34.         //使用其他算法，只需要改一下名字即可
  35.         algorithm = "HmacSHA256";
  36.         algorithm = "HmacSHA512";
  37.         //实例化mac对象
  38.         Mac mac = Mac.getInstance(algorithm);
  39.         //实例化key对象
  40.         SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
  41.         //mac对象初始化
  42.         mac.init(secretKeySpec);
  43.         byte[] bytes = mac.doFinal(str.getBytes(StandardCharsets.UTF_8));
  44.         StringBuilder stringBuilder = new StringBuilder();
  45.         for (byte b : bytes) {
  47.             //每个字节转与0xff（1111 1111）按位与，得到这个字节的补码
  48.             String hex = Integer.toHexString(b & 0xff);
  49.             //如果生成的16进制的字符的长度是1，那么需要在前面补0，比如
  50.             //0,5,10,13,15的16进制分别是是0，5，a,d,f，长度只有1，所以需要前面补0
  51.             if (hex.length() == 1) {
  53.                 hex = "0" + hex;
  54.             }
  55.             stringBuilder.append(hex);
  56.         }
  57.         System.out.println(stringBuilder);
  58.     }
  60.     /**
  61.      * 使用commons-codec
  62.      */
  63.     public static void maccodec() {
  65.         String str = "hello聚合";
  66.         String key = "123";
  67.         System.out.println("hmacMD5:"+new HmacUtils(HmacAlgorithms.HMAC_MD5, key.getBytes(StandardCharsets.UTF_8)).hmacHex(str.getBytes(StandardCharsets.UTF_8)));
  68.         System.out.println("hmacSHA256:"+new HmacUtils(HmacAlgorithms.HMAC_SHA_256, key.getBytes(StandardCharsets.UTF_8)).hmacHex(str.getBytes(StandardCharsets.UTF_8)));
  69.         System.out.println("hmacSHA512:"+new HmacUtils(HmacAlgorithms.HMAC_SHA_512, key.getBytes(StandardCharsets.UTF_8)).hmacHex(str.getBytes(StandardCharsets.UTF_8)));
  71.     }
  72. }

DES

des是一种对称加密算法，相对于非对称加密算法来说，更快，现在des已经过时，被AES给取代了，需要注意的是，des算法的时候，key必须是8个字节，不然会报错。以下是使用des加密解密的全部代码。

  1. package codec;
  4. import javax.crypto.Cipher;
  5. import javax.crypto.spec.SecretKeySpec;
  6. import java.nio.charset.StandardCharsets;
  7. import java.util.Base64;
  9. /**
  10.  * @author micro.cloud.fly
  11.  * @date 2021/8/30 2:04 下午
  12.  * @desc 学习des算法，des是对称加密，比起非对称加密，有点是更快，因为只使用一个key
  13.  */
  14. public class lesson06_DES {
  16.     public static void main(String[] args) throws Exception {
  18.         String encryptedString = encrypt();
  19.         String decryptedString = decrypt(encryptedString);
  20.         System.out.println(decryptedString);
  21.     }
  23.     private static String decrypt(String encryptedString) throws Exception {
  25.         String algorithm = "DES";
  26.         Cipher cipher = Cipher.getInstance(algorithm);
  27.         String key = "12345678";//这里必须是8个字节
  28.         SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
  29.         cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
  30.         //传参过来的明文，是base64编码后的内容，所以，需要先进行base64解码
  31.         byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(encryptedString.getBytes(StandardCharsets.UTF_8)));
  32.         return new String(bytes, StandardCharsets.UTF_8);
  33.     }
  36.     /**
  37.      * 使用DES加密
  38.      *
  39.      * @return 加密后的内容
  40.      */
  41.     public static String encrypt() throws Exception {
  43.         String algorithm = "DES";
  44.         String str = "hello聚合";
  45.         //cipher是密码的意思，这里是实例化一个cipher对象，
  46.         //这里ECB是指加密的模式，是java的默认加密模式，PKCS7Padding是指填充模式，加密模式和填充模式也可以不进行指定
  47.         Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
  48.         String key = "12345678";//这里必须是8个字节
  49.         //实例化一个密钥，第一个参数是密钥，第二个参数是算法
  50.         SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
  51.         //cipher初始化，第一个参数是加解密模式，即，cipher是为了加密，还是用来解密，第二个参数是密钥对象
  52.         cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
  53.         byte[] bytes = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
  54.         //得到的是字节数组，通常的做法是把此处的字节数组转为base64进行展示
  55.         byte[] encode = Base64.getEncoder().encode(bytes);
  56.         System.out.println(new String(encode, StandardCharsets.UTF_8));
  57.         return new String(encode);
  59.     }
  60. }

AES

aes和des差不多，只需要改algorithm的名字即可，不同点是，aes的key的长度必须是16、24、32个字节，不过可以通过key generator进行优化，优化后可以使用任意的长度的key，当使用填充模式为NoPadding的方式时，des的key必须为8个字节，aes的key必须是16，24，32个字节。
ECB：java默认的 加密模式，是指把明文分组之后，每个组进行并行加密，然后拼接，所以效率会比较高
CBC：采用的是将明文进行分组，后面分组的内容加密时，依赖前一个分组加密后的密文，也就是每次加密后的密文，后面的组进行加密的时候，都根据这个密文与后面的组的明文进行一起加密，这种模式下，需要一个initialization vector，简称IV，即初始化向量，这个初始化向量默认必须是16个字节。
以下是完整的代码展示

  1. package codec.lesson07_AES;
  4. import javax.crypto.Cipher;
  5. import javax.crypto.KeyGenerator;
  6. import javax.crypto.SecretKey;
  7. import javax.crypto.spec.IvParameterSpec;
  8. import javax.crypto.spec.SecretKeySpec;
  9. import java.nio.charset.StandardCharsets;
  10. import java.security.SecureRandom;
  11. import java.util.Base64;
  13. /**
  14.  * @author micro.cloud.fly
  15.  * @date 2021/8/30 2:04 下午
  16.  * @desc 学习aes算法，aes是对称加密，比起非对称加密，有点是更快，因为只使用一个key
  17.  */
  18. public class Demo02 {
  20.     public static void main(String[] args) throws Exception {
  22.         //常规加密
  23.         String encryptedString = encrypt();
  24.         //常规解密
  25.         String decryptedString = decrypt(encryptedString);
  26.         System.out.println(decryptedString);
  27.         System.out.println();
  28.         //优化后的加密
  29.         String s = encryptOptimise();
  30.         //优化后的解密
  31.         String s1 = decryptOptimise(s);
  32.         System.out.println(s1);
  33.     }
  36.     /**
  37.      * 使用AES加密
  38.      *
  39.      * @return 加密后的内容
  40.      */
  41.     public static String encrypt() throws Exception {
  43.         String algorithm = "AES";
  44.         String str = "hello聚合";
  45.         //cipher是密码的意思，这里是实例化一个cipher对象，
  46.         //这里ECB是指加密的模式，是java的默认加密模式，
  47.         // PKCS5Padding是指填充模式，也是java默认的填充方式，
  48.         Cipher cipher = Cipher.getInstance(algorithm);
  49.         //这里与des区别的地方是，des必须是8个字节，而aes必须是16，24，32个字节
  50.         /*在接口AESConstants中明确规定了长度
  51.         interface AESConstants {
  52.             int AES_BLOCK_SIZE = 16;
  53.             int[] AES_KEYSIZES = new int[]{16, 24, 32};
  54.         }*/
  55.         String key = "1234567812345678";
  56.         //实例化一个密钥，第一个参数是密钥，第二个参数是算法
  57.         SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
  58.         //cipher初始化，第一个参数是加解密模式，即，cipher是为了加密，还是用来解密，第二个参数是密钥对象
  59.         //默认的是ECB加密模式，如果使用的CBC模式的话，需要多传一个IV向量，即initialization vector
  60.         String iv = "12345678abcdabcd";
  61.         IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes(StandardCharsets.UTF_8));
  62.         cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
  63.         //CBC模式下，必须有第三个参数IV
  64.         //cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec,ivParameterSpec);
  66.         byte[] bytes = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
  67.         //得到的是字节数组，通常的做法是把此处的字节数组转为base64进行展示
  68.         byte[] encode = Base64.getEncoder().encode(bytes);
  69.         System.out.println(new String(encode, StandardCharsets.UTF_8));
  70.         return new String(encode);
  72.     }
  75.     private static String decrypt(String encryptedString) throws Exception {
  77.         String algorithm = "AES";
  78.         Cipher cipher = Cipher.getInstance(algorithm);
  79.         String key = "1234567812345678";//这里必须是8个字节
  80.         SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(StandardCharsets.UTF_8), algorithm);
  81.         cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
  82.         //传参过来的明文，是base64编码后的内容，所以，需要先进行base64解码
  83.         byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(encryptedString.getBytes(StandardCharsets.UTF_8)));
  84.         return new String(bytes, StandardCharsets.UTF_8);
  85.     }
  87.     /**
  88.      * 优化后的aes加密算法，这是因为默认key的长度只能是16, 24, 32个字节，此处使用key工厂，可以传递任意字节的密钥
  89.      *
  90.      * @return 加密后的内容
  91.      */
  92.     public static String encryptOptimise() throws Exception {
  94.         String algorithm = "AES";
  95.         String str = "hello聚合";
  96.         //cipher是密码的意思，这里是实例化一个cipher对象，
  97.         Cipher cipher = Cipher.getInstance(algorithm);
  98.         //实例化key工厂
  99.         KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
  100.         //初始化secureRandom，并指定生成key的算法
  101.         SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
  102.         String key = "1234567812345";
  103.         //设置key工厂的种子
  104.         secureRandom.setSeed(key.getBytes(StandardCharsets.UTF_8));
  105.         //第一个参数是生成原始key的长度，第二个参数是SecureRandom对象
  106.         keyGenerator.init(128, secureRandom);
  107.         SecretKey secretKey = keyGenerator.generateKey();
  108.         //获取到新的密钥的字节数组
  109.         byte[] encodedKey = secretKey.getEncoded();
  110.         //实例化一个密钥，第一个参数是密钥，第二个参数是算法
  111.         SecretKeySpec secretKeySpec = new SecretKeySpec(encodedKey, algorithm);
  112.         //cipher初始化，第一个参数是加解密模式，即，cipher是为了加密，还是用来解密，第二个参数是密钥对象
  113.         cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
  114.         byte[] bytes = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
  115.         //得到的是字节数组，通常的做法是把此处的字节数组转为base64进行展示
  116.         byte[] encode = Base64.getEncoder().encode(bytes);
  117.         System.out.println(new String(encode, StandardCharsets.UTF_8));
  118.         return new String(encode);
  120.     }
  123.     /**
  124.      * 优化后的aes解密算法，这是因为默认key的长度只能是16, 24, 32个字节，此处使用key工厂，可以传递任意字节的密钥
  125.      *
  126.      * @return 加密后的内容
  127.      */
  128.     public static String decryptOptimise(String encryptStr) throws Exception {
  130.         String algorithm = "AES";
  131.         //cipher是密码的意思，这里是实例化一个cipher对象，
  132.         Cipher cipher = Cipher.getInstance(algorithm);
  133.         //实例化key工厂
  134.         KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
  135.         //初始化secureRandom，并指定生成key的算法
  136.         SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
  137.         String key = "1234567812345";
  138.         //设置key工厂的种子
  139.         secureRandom.setSeed(key.getBytes(StandardCharsets.UTF_8));
  140.         //第一个参数是生成原始key的长度，第二个参数是SecureRandom对象
  141.         keyGenerator.init(128, secureRandom);
  142.         SecretKey secretKey = keyGenerator.generateKey();
  143.         //获取到新的密钥的字节数组
  144.         byte[] encodedKey = secretKey.getEncoded();
  145.         //实例化一个密钥，第一个参数是密钥，第二个参数是算法
  146.         SecretKeySpec secretKeySpec = new SecretKeySpec(encodedKey, algorithm);
  147.         //cipher初始化，第一个参数是加解密模式，即，cipher是为了加密，还是用来解密，第二个参数是密钥对象
  148.         cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
  149.         byte[] bytes = cipher.doFinal(Base64.getDecoder().decode(encryptStr.getBytes(StandardCharsets.UTF_8)));
  150.         return new String(bytes);
  152.     }
  153. }

发表评论

表情：
评论列表 （有 0 条评论，1811人围观）

还没有评论，来说两句吧...

相关阅读