2. import com.google.common.base.Preconditions;
  3. import lombok.Getter;
  4. import lombok.Setter;
  5. import lombok.SneakyThrows;
  6. import org.apache.commons.codec.binary.Base64;
  7. import org.apache.commons.codec.binary.StringUtils;
  8. import org.apache.commons.codec.digest.DigestUtils;
  9. import org.apache.shardingsphere.encrypt.strategy.spi.Encryptor;
  11. import javax.crypto.Cipher;
  12. import javax.crypto.NoSuchPaddingException;
  13. import javax.crypto.spec.SecretKeySpec;
  14. import java.nio.charset.StandardCharsets;
  15. import java.security.InvalidKeyException;
  16. import java.security.NoSuchAlgorithmException;
  17. import java.util.Arrays;
  18. import java.util.Properties;
  20. /**
  21.  * AES encryptor.
  22.  */
  23. @Getter
  24. @Setter
  25. public final class AESEncryptor implements Encryptor {
  27.     private static final String AES_KEY = "aes.key.value";
  29.     private Properties properties = new Properties();
  31.     @Override
  32.     public String getType() {
  33.         return "AES";
  34.     }
  36.     @Override
  37.     public void init() {
  38.     }
  40.     @Override
  41.     @SneakyThrows
  42.     public String encrypt(final Object plaintext) {
  43.         if (null == plaintext) {
  44.             return null;
  45.         }
  46.         byte[] result = getCipher(Cipher.ENCRYPT_MODE).doFinal(StringUtils.getBytesUtf8(String.valueOf(plaintext)));
  47.         return Base64.encodeBase64String(result);
  48.     }
  50.     @Override
  51.     @SneakyThrows
  52.     public Object decrypt(final String ciphertext) {
  53.         if (null == ciphertext) {
  54.             return null;
  55.         }
  56.         byte[] result = getCipher(Cipher.DECRYPT_MODE).doFinal(Base64.decodeBase64(ciphertext));
  57.         return new String(result, StandardCharsets.UTF_8);
  58.     }
  60.     private Cipher getCipher(final int decryptMode) throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidKeyException {
  61.         Preconditions.checkArgument(properties.containsKey(AES_KEY), "No available secret key for `%s`.", AESEncryptor.class.getName());
  62.         Cipher result = Cipher.getInstance(getType());
  63.         result.init(decryptMode, new SecretKeySpec(createSecretKey(), getType()));
  64.         return result;
  65.     }
  67.     private byte[] createSecretKey() {
  68.         Preconditions.checkArgument(null != properties.get(AES_KEY), String.format("%s can not be null.", AES_KEY));
  69.         return Arrays.copyOf(DigestUtils.sha1(properties.get(AES_KEY).toString()), 16);
  70.     }
  71. }

我自己的

  1. <dependency>
  2.   <groupId>org.apache.directory.studio</groupId>
  3.   <artifactId>org.apache.commons.codec</artifactId>
  4.   <version>1.8</version>
  5. </dependency>
  1. import lombok.experimental.UtilityClass;
  3. import javax.crypto.Cipher;
  4. import javax.crypto.KeyGenerator;
  5. import javax.crypto.spec.SecretKeySpec;
  6. import java.nio.charset.StandardCharsets;
  7. import java.security.MessageDigest;
  8. import java.security.NoSuchAlgorithmException;
  9. import org.apache.commons.codec.binary.Base64;
  10. import org.apache.commons.lang3.StringUtils;
  11. import sun.misc.BASE64Decoder;
  13. /**
  14.  * @author zhouzhenyong
  15.  * @since 2019/2/22 下午11:20
  16.  */
  17. @UtilityClass
  18. public class EncryptUtil {
  20.     /**
  21.      * 算法
  22.      */
  23.     public final String ALGORITHMSTR = "AES/ECB/PKCS5Padding";
  25.     /**
  26.      * 传入文本内容，返回 encrypt-256 串
  27.      *
  28.      * @param strText 待加密文本
  29.      * @return 加密之后的文本
  30.      */
  31.     public String sha256(final String strText) {
  32.         return encrypt(strText, "SHA-256");
  33.     }
  35.     /**
  36.      * 传入文本内容，返回 encrypt-512 串
  37.      * @param strText 待加密文本
  38.      * @return 加密之后的文本
  39.      */
  40.     public String sha512(final String strText) {
  41.         return encrypt(strText, "SHA-512");
  42.     }
  44.     /**
  45.      * 传入文本内容，返回 MD5 串
  46.      * @param strText 待加密文本
  47.      * @return 加密之后的文本
  48.      */
  49.     public String md5(final String strText){
  50.         return encrypt(strText, "MD5");
  51.     }
  54.     /**
  55.      * base 64 encode
  56.      * @param bytes 待编码的byte[]
  57.      * @return 编码后的base 64 code
  58.      */
  59.     public String base64Encode(byte[] bytes){
  60.         return Base64.encodeBase64String(bytes);
  61.     }
  63.     /**
  64.      * base 64 decode
  65.      * @param base64Code 待解码的base 64 code
  66.      * @return 解码后的byte[]
  67.      * @throws Exception 抛出异常
  68.      */
  69.     public byte[] base64Decode(String base64Code) throws Exception{
  70.         return StringUtils.isEmpty(base64Code) ? null : new BASE64Decoder().decodeBuffer(base64Code);
  71.     }
  73.     /**
  74.      * AES加密
  75.      * @param content 待加密的内容
  76.      * @param key 加密密钥
  77.      * @return 加密后的byte[]
  78.      */
  79.     public byte[] aesEncryptToBytes(String content, String key) throws Exception {
  80.         KeyGenerator generator = KeyGenerator.getInstance("AES");
  81.         generator.init(128);
  82.         Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
  83.         cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"));
  85.         return cipher.doFinal(content.getBytes(StandardCharsets.UTF_8));
  86.     }
  88.     /**
  89.      * AES加密为base 64 code
  90.      *
  91.      * @param content 待加密的内容
  92.      * @param encryptKey 加密密钥
  93.      * @return 加密后的base 64 code
  94.      */
  95.     public String aesEncrypt(String content, String encryptKey) throws Exception {
  96.         return base64Encode(aesEncryptToBytes(content, encryptKey));
  97.     }
  99.     /**
  100.      * AES解密
  101.      *
  102.      * @param encryptBytes 待解密的byte[]
  103.      * @param key 解密密钥
  104.      * @return 解密后的String
  105.      */
  106.     public String aesDecryptFromBytes(byte[] encryptBytes, String key) throws Exception {
  107.         KeyGenerator generator = KeyGenerator.getInstance("AES");
  108.         generator.init(128);
  110.         Cipher cipher = Cipher.getInstance(ALGORITHMSTR);
  111.         cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getBytes(), "AES"));
  112.         byte[] decryptBytes = cipher.doFinal(encryptBytes);
  114.         return new String(decryptBytes);
  115.     }
  117.     /**
  118.      * 将base 64 code AES解密
  119.      *
  120.      * @param encryptStr 待解密的base 64 code
  121.      * @param key 解密密钥
  122.      * @return 解密后的string
  123.      */
  124.     public String aesDecrypt(String encryptStr, String key) throws Exception {
  125.         return StringUtils.isEmpty(encryptStr) ? null : aesDecryptFromBytes(base64Decode(encryptStr), key);
  126.     }
  128.     /**
  129.      * 字符串 encrypt 加密
  130.      * @param str 待加密文本
  131.      * @param strType 加密类型
  132.      * @return 加密之后的文本
  133.      */
  134.     private String encrypt(final String str, final String strType) {
  135.         MessageDigest messageDigest;
  136.         String encodeStr = "";
  137.         if (null == str || str.length() == 0) {
  138.             return encodeStr;
  139.         }
  140.         try {
  141.             messageDigest = MessageDigest.getInstance(strType);
  142.             messageDigest.update(str.getBytes());
  144.             // 将byte 转换为字符展示出来
  145.             StringBuilder stringBuffer = new StringBuilder();
  146.             String temp;
  147.             for (byte aByte : messageDigest.digest()) {
  148.                 temp = Integer.toHexString(aByte & 0xFF);
  149.                 if (temp.length() == 1) {
  150.                     //1得到一位的进行补0操作
  151.                     stringBuffer.append("0");
  152.                 }
  153.                 stringBuffer.append(temp);
  154.             }
  155.             encodeStr = stringBuffer.toString();
  156.         } catch (NoSuchAlgorithmException e) {
  157.             throw new RuntimeException(e);
  158.         }
  159.         return encodeStr;
  160.     }
  161. }

DesUtil

  1. import lombok.experimental.UtilityClass;
  3. import javax.crypto.Cipher;
  4. import javax.crypto.SecretKeyFactory;
  5. import javax.crypto.spec.DESKeySpec;
  6. import javax.crypto.spec.IvParameterSpec;
  7. import java.security.Key;
  8. import java.util.Base64;
  10. /**
  11.  * @author shizi
  12.  * @since 2021-11-22 17:00:24
  13.  */
  14. @UtilityClass
  15. public class DESUtil {
  17.     /**
  18.      * 偏移变量，固定占8位字节
  19.      */
  20.     private final static String IV_PARAMETER = "12345678";
  21.     /**
  22.      * 密钥算法
  23.      */
  24.     private static final String ALGORITHM = "DES";
  25.     /**
  26.      * 加密/解密算法-工作模式-填充模式
  27.      */
  28.     private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
  29.     /**
  30.      * 默认编码
  31.      */
  32.     private static final String CHARSET = "utf-8";
  34.     /**
  35.      * 生成key
  36.      *
  37.      * @param password
  38.      * @return
  39.      * @throws Exception
  40.      */
  41.     private static Key generateKey(String password) throws Exception {
  42.         DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
  43.         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
  44.         return keyFactory.generateSecret(dks);
  45.     }
  48.     /**
  49.      * DES加密字符串
  50.      *
  51.      * @param password 加密密码，长度不能够小于8位
  52.      * @param data 待加密字符串
  53.      * @return 加密后内容
  54.      */
  55.     public static String encrypt(String password, String data) {
  56.         if (password== null || password.length() < 8) {
  57.             throw new RuntimeException("加密失败，key不能小于8位");
  58.         }
  59.         if (data == null)
  60.             return null;
  61.         try {
  62.             Key secretKey = generateKey(password);
  63.             Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
  64.             IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
  65.             cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
  66.             byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
  68.             //JDK1.8及以上可直接使用Base64，JDK1.7及以下可以使用BASE64Encoder
  69.             //Android平台可以使用android.util.Base64
  70.             return new String(Base64.getEncoder().encode(bytes));
  72.         } catch (Exception e) {
  73.             e.printStackTrace();
  74.             return data;
  75.         }
  76.     }
  78.     /**
  79.      * DES解密字符串
  80.      *
  81.      * @param password 解密密码，长度不能够小于8位
  82.      * @param data 待解密字符串
  83.      * @return 解密后内容
  84.      */
  85.     public static String decrypt(String password, String data) {
  86.         if (password== null || password.length() < 8) {
  87.             throw new RuntimeException("加密失败，key不能小于8位");
  88.         }
  89.         if (data == null)
  90.             return null;
  91.         try {
  92.             Key secretKey = generateKey(password);
  93.             Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
  94.             IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
  95.             cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
  96.             return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
  97.         } catch (Exception e) {
  98.             e.printStackTrace();
  99.             return data;
  100.         }
  101.     }
  102. }