本文采用aop实现model中的字段加解密。
创建加密工具类 AseUtil
import org.springframework.util.Base64Utils;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
/**
* Ase加密
*/
public class AseUtil {
private static final String KEY_ALGORITHM = "AES";
private static final String DEFAULT_CIPHER_ALGORITHM = "AES/ECB/PKCS5Padding";//默认的加密算法
/**
* AES 加密操作
*
* @param content 待加密内容
* @param secKey 加密密码
* @return 返回Base64转码后的加密数据
*/
public static String encrypt(String content, String secKey) {
try {
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);// 创建密码器
byte[] byteContent = content.getBytes("utf-8");
cipher.init(Cipher.ENCRYPT_MODE, getSecretKey(secKey));// 初始化为加密模式的密码器
byte[] result = cipher.doFinal(byteContent);// 加密
return Base64Utils.encodeToString(result);
} catch (Exception ex) {
Logger.getLogger(AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
/**
* AES 解密操作
*
* @param content
* @param secKey
* @return
*/
public static String decrypt(String content, String secKey) {
try {
//实例化
Cipher cipher = Cipher.getInstance(DEFAULT_CIPHER_ALGORITHM);
//使用密钥初始化，设置为解密模式
cipher.init(Cipher.DECRYPT_MODE, getSecretKey(secKey));
//执行操作
byte[] result = cipher.doFinal(Base64Utils.decodeFromString(content));
return new String(result, "utf-8");
} catch (Exception ex) {
Logger.getLogger(AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
/**
* 生成加密秘钥
*
* @return
*/
private static SecretKeySpec getSecretKey(final String password) {
//返回生成指定算法密钥生成器的 KeyGenerator 对象
KeyGenerator kg = null;
try {
kg = KeyGenerator.getInstance(KEY_ALGORITHM);
//AES 要求密钥长度为 128
kg.init(128, new SecureRandom(password.getBytes()));
//生成一个密钥
SecretKey secretKey = kg.generateKey();
return new SecretKeySpec(secretKey.getEncoded(), KEY_ALGORITHM);// 转换为AES专用密钥
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(AseUtil.class.getName()).log(Level.SEVERE, null, ex);
}
return null;
}
}
定义注解
@EncryptMethod
使用@EncryptMethod注解要加密参数（model）的方法。
/**
* 字段加解密
* @author seawish
* @date 2019/8/19
*/
@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface EncryptField {}
@DecryptMethod
使用@DecryptMethod注解要加密参数（model）的方法。
/**
* 注解需要加解密参数的方法，实现自动加解密。
*
* @author seawish.zheng
* @date 2019/8/16
*/
@Documented
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface DecryptMethod { }
@CryptField
@CryptField修饰model类的属性，被注解的属性将被aop拦截，进行加解密处理。
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import java.lang.annotation.*;
/**
* 字段加解密
* @author seawish.zheng
* @date 2019/8/19
*/
@Documented
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Order(Ordered.HIGHEST_PRECEDENCE)
public @interface CryptField {}
定义切面类 CryptFieldAspect
CryptFieldAspect拦截@EncryptMethod和@DecryptMethod修饰的方法，并对其第一个参数进行的特定属性（使用@CryptField注解的属性）进行加解密处理。
import com.dji.graduate.utils.AseUtil;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.util.Objects;
/**
* 安全字段加密解密切面
*
* @author: zetting
* @date:2018/12/27
*/
@Order(Ordered.HIGHEST_PRECEDENCE)
@Aspect
@Component
public class CryptFieldAspect {
private static Logger logger = LoggerFactory.getLogger(CryptFieldAspect.class);
@Value("${crypt.seckey}")
private String secretKey;
@Pointcut("@annotation(EncryptMethod)")
public void encryptPointCut() {
}
@Pointcut("@annotation(DecryptMethod)")
public void decryptPointCut() {
}
/**
* 加密数据环绕处理
* @param joinPoint
* @return
* @throws Throwable
*/
@Around("encryptPointCut()")
public Object aroundEncrypt(ProceedingJoinPoint joinPoint) throws Throwable {
Object requestObj = joinPoint.getArgs()[0];
handleEncrypt(requestObj); // 加密CryptField注解字段
Object responseObj = joinPoint.proceed(); // 方法执行
handleDecrypt(responseObj); // 解密CryptField注解字段
return responseObj;
}
/**
* 解密数据环绕处理
* @param joinPoint
* @return
* @throws Throwable
*/
@Around("decryptPointCut()")
public Object aroundDecrypt(ProceedingJoinPoint joinPoint) throws Throwable {
Object requestObj = joinPoint.getArgs()[0];
handleDecrypt(requestObj); // 解密CryptField注解字段
Object responseObj = joinPoint.proceed(); // 方法执行
handleEncrypt(responseObj); // 加密CryptField注解字段
return responseObj;
}
/**
* 处理加密
*
* @param requestObj
*/
private void handleEncrypt(Object requestObj) throws IllegalAccessException {
if (Objects.isNull(requestObj)) {
return;
}
Field[] fields = requestObj.getClass().getDeclaredFields();
for (Field field : fields) {
boolean hasSecureField = field.isAnnotationPresent(CryptField.class);
if (hasSecureField) {
field.setAccessible(true);
String plaintextValue = (String) field.get(requestObj);
String encryptValue = AseUtil.encrypt(plaintextValue, secretKey);
field.set(requestObj, encryptValue);
}
}
}
/**
* 处理解密
*
* @param responseObj
*/
private Object handleDecrypt(Object responseObj) throws IllegalAccessException {
if (Objects.isNull(responseObj)) {
return null;
}
Field[] fields = responseObj.getClass().getDeclaredFields();
for (Field field : fields) {
boolean hasSecureField = field.isAnnotationPresent(CryptField.class);
if (hasSecureField) {
field.setAccessible(true);
String encryptValue = (String) field.get(responseObj);
String plaintextValue = AseUtil.decrypt(encryptValue, secretKey);
field.set(responseObj, plaintextValue);
}
}
return responseObj;
}
}
切面使用
配置属性
在application.properties中配置aes加密所需的seckey。
crypt.seckey = seawishkey
注解方法和字段
注解Dto对象的字段
AccountDto的password属性使用@CryptField注解，其将被aop拦截，进行加解密处理。
@ApiModel(value = "用户Dto")
public class AccountDto extends BaseDto<AccountDto, AccountEntity> {
private static final long serialVersionUID = 1L;
@ApiModelProperty(hidden = true)
@CryptField
@NotEmpty(groups = {InsertGroup.class})
@Size(min = 8, max = 20)
private String password;
注解AddCount方法
addAccount方法使用@EncryptMethod注解，其第一个参数，也就是accountDto对象，将被aop拦截。在方法执行前，accountDto具有@CryptFiled注解的属性都会被加密；而执行完方法后，该对象被加密的字段都会被解密回原样。
如果使用@DecryptMethod注解addAccount方法，则执行@EncryptMethod相反的操作。
@ApiOperation("添加用户信息")
@EncryptMethod
@PostMapping
@ResponseBody
public Result<String> addAccount(@Validated({Default.class, InsertGroup.class}) @RequestBody AccountDto accountDto) throws InvocationTargetException, IllegalAccessException {
logger.info("添加用户,ad： {}", accountDto.getAd());
return accountService.add(accountDto) ? Result.success(accountDto.getId()) : Result.failureMsg("增加用户失败");
}
参考文献
本文作者： seawish
版权声明： 本博客所有文章除特别声明外，均采用 CC BY-NC-SA 3.0 许可协议。转载请注明出处！
