java注解实现AES base64加解密

最新推荐文章于 2024-04-24 09:33:08 发布
最新推荐文章于 2024-04-24 09:33:08 发布
阅读量862 收藏 4
点赞数 1
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/G_whang/article/details/114048169
版权

昨天学习了反射与注解，因为公司使用的是AES base64加解密进行数据规则脱敏的，今天就抽空使用注解做了个简单的Dome
代码 如下：
注解代码

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Aes加解密方法
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AesAnnotation {

    /**
     * 加密
     * @return
     */
    boolean ENCRYPTION() default false;

    /**
     * 解密
     * @return
     */
    boolean DECRYPT() default false;

    /**
     * 脱敏
     * @return
     */
    boolean DESENSITIZATION() default false;

    /**
     * 脱敏样式
     * @return
     */
    String STYLE() default "*";


}

AES加解密工具类

package com.gwh.aes_test.utils;

import org.springframework.util.StringUtils;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;


/**
 * AES加密解密
 * @ClassName	AesUtil
 * @Copyright (c) All Rights Reserved, 2020.
 */
public final class AesUtil {

    /**
     * 加密算法
     */
    private static final String ENCRY_ALGORITHM = "AES";

    /**
     * 加密算法/加密模式/填充类型
     * 本例采用AES加密，ECB加密模式，PKCS5Padding填充
     */
    private static final String CIPHER_MODE = "AES/ECB/PKCS5Padding";

    /**
     * 设置iv偏移量
     * 本例采用ECB加密模式，不需要设置iv偏移量
     */
    private static final String IV = null;

    /**
     * 设置加密字符集
     * 本例采用 UTF-8 字符集
     */
    private static final String CHARACTER = "UTF-8";

    /**
     * 设置加密密码处理长度。
     * 不足此长度补0；
     */
    private static final int PWD_SIZE = 16;
    
    /**
     * AES加密秘钥
     */
    private static final String AES_KEY = "token";

    /**
     * 密码处理方法
     * 如果加解密出问题，
     * 请先查看本方法，排除密码长度不足填充0字节,导致密码不一致
     * @param password 待处理的密码
     * @return
     * @throws UnsupportedEncodingException
     */
    private static byte[] pwdHandler(String password) throws UnsupportedEncodingException {
        byte[] data = null;
        if (password != null) {
            byte[] bytes = password.getBytes(CHARACTER);
            if (password.length() < PWD_SIZE) {
                System.arraycopy(bytes, 0, data = new byte[PWD_SIZE], 0, bytes.length);
            } else {
                data = bytes;
            }
        }
        return data;
    }

    //======================>原始加密<======================

    /**
     * 原始加密
     * @param clearTextBytes 明文字节数组，待加密的字节数组
     * @param pwdBytes 加密密码字节数组
     * @return 返回加密后的密文字节数组，加密错误返回null
     */
    public static byte[] encrypt(byte[] clearTextBytes, byte[] pwdBytes) {
        try {
            
            // 1 获取加密密钥
            SecretKeySpec keySpec = new SecretKeySpec(pwdBytes, ENCRY_ALGORITHM);
            // 2 获取Cipher实例
            Cipher cipher = Cipher.getInstance(CIPHER_MODE);
            // 查看数据块位数 默认为16（byte） * 8 =128 bit
           // System.out.println("数据块位数(byte)：" + cipher.getBlockSize());
            // 3 初始化Cipher实例。设置执行模式以及加密密钥
            cipher.init(Cipher.ENCRYPT_MODE, keySpec);
            // 4 执行
            byte[] cipherTextBytes = cipher.doFinal(clearTextBytes);
            // 5 返回密文字符集
            return cipherTextBytes;

        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 原始解密
     * @param cipherTextBytes 密文字节数组，待解密的字节数组
     * @param pwdBytes 解密密码字节数组
     * @return 返回解密后的明文字节数组，解密错误返回null
     */
    public static byte[] decrypt(byte[] cipherTextBytes, byte[] pwdBytes) {

        try {
            // 1 获取解密密钥
            SecretKeySpec keySpec = new SecretKeySpec(pwdBytes, ENCRY_ALGORITHM);
            // 2 获取Cipher实例
            Cipher cipher = Cipher.getInstance(CIPHER_MODE);
            // 查看数据块位数 默认为16（byte） * 8 =128 bit
//            System.out.println("数据块位数(byte)：" + cipher.getBlockSize());
            // 3 初始化Cipher实例。设置执行模式以及加密密钥
            cipher.init(Cipher.DECRYPT_MODE, keySpec);
            // 4 执行
            byte[] clearTextBytes = cipher.doFinal(cipherTextBytes);
            // 5 返回明文字符集
            return clearTextBytes;

        } catch (Exception e) {
            e.printStackTrace();
        }
        // 解密错误 返回null
        return null;
    }
    
    //======================>BASE64<======================

    /**
     * BASE64加密
     * @param clearText 明文，待加密的内容
     * @param password 密码，加密的密码
     * @return 返回密文，加密后得到的内容。加密错误返回null
     */
    @SuppressWarnings("restriction")
    public static String encryptBase64(String clearText, String password) {
        if(StringUtils.isEmpty(clearText)){
            return clearText;
        }
        try {
            // 1 获取加密密文字节数组
            byte[] cipherTextBytes = encrypt(clearText.getBytes(CHARACTER), pwdHandler(password));
            // 2 对密文字节数组进行BASE64 encoder 得到 BASE6输出的密文
            String cipherText = (new BASE64Encoder()).encode(cipherTextBytes);
            // 3 返回BASE64输出的密文
            return cipherText;
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 加密错误 返回null
        return null;
    }

    /**
     * BASE64解密
     * @param cipherText 密文，带解密的内容
     * @param password 密码，解密的密码
     * @return 返回明文，解密后得到的内容。解密错误返回null
     */
    @SuppressWarnings("restriction")
    public static String decryptBase64(String cipherText, String password) {
        if(StringUtils.isEmpty(cipherText)){
            return cipherText;
        }
        try {
            // 1 对 BASE64输出的密文进行BASE64 decodebuffer 得到密文字节数组
            BASE64Decoder base64Decoder = new BASE64Decoder();
            byte[] cipherTextBytes = base64Decoder.decodeBuffer(cipherText);
            // 2 对密文字节数组进行解密 得到明文字节数组
            byte[] clearTextBytes = decrypt(cipherTextBytes, pwdHandler(password));
            // 3 根据 CHARACTER 转码，返回明文字符串
            return new String(clearTextBytes, CHARACTER);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 解密错误返回null
        return null;
    }
    
    /**
     * 加密方法
     * @param clearText
     * @return
     * @return String
     * @since  1.0.0
     */
    public static String encryptBase64(String clearText){
        return encryptBase64(clearText,AES_KEY);
    }
    
    /**
     * 解密方法
     * @param cipherText
     * @return
     * @return String
     * @since  1.0.0
     */
    public static String decryptBase64(String cipherText){
        return decryptBase64(cipherText,AES_KEY);
    }

    //======================>HEX<======================

    /**
     * HEX加密
     * @param clearText 明文，待加密的内容
     * @param password 密码，加密的密码
     * @return 返回密文，加密后得到的内容。加密错误返回null
     */
    public static String encryptHex(String clearText, String password) {
        try {
            // 1 获取加密密文字节数组
            byte[] cipherTextBytes = encrypt(clearText.getBytes(CHARACTER),password.getBytes());
            // 2 对密文字节数组进行 转换为 HEX输出密文
            String cipherText = byte2hex(cipherTextBytes);
            // 3 返回 HEX输出密文
            return cipherText;
        }  catch (Exception e) {
            e.printStackTrace();
        }
        // 加密错误返回null
        return null;
    }

    /**
     * HEX解密
     * @param cipherText 密文，带解密的内容
     * @param password 密码，解密的密码
     * @return 返回明文，解密后得到的内容。解密错误返回null
     */
    public static String decryptHex(String cipherText, String password) {
        try {
            // 1 将HEX输出密文 转为密文字节数组
            byte[] cipherTextBytes = hex2byte(cipherText);
            // 2 将密文字节数组进行解密 得到明文字节数组
            byte[] clearTextBytes = decrypt(cipherTextBytes, pwdHandler(password));
            // 3 根据 CHARACTER 转码，返回明文字符串
            return new String(clearTextBytes, CHARACTER);
        }catch (Exception e) {
            e.printStackTrace();
        }
        // 解密错误返回null
        return null;
    }

    /**
     * 字节数组转成16进制字符串
     * @param bytes
     * @return
     * @return String
     * @since  1.0.0
     */
    public static String byte2hex(byte[] bytes) { // 一个字节的数，
        StringBuffer sb = new StringBuffer(bytes.length * 2);
        String tmp = "";
        for (int n = 0; n < bytes.length; n++) {
            // 整数转成十六进制表示
            tmp = (Integer.toHexString(bytes[n] & 0XFF));
            if (tmp.length() == 1) {
                sb.append("0");
            }
            sb.append(tmp);
        }
        return sb.toString().toUpperCase(); // 转成大写
    }

    /**
     * 将hex字符串转换成字节数组
     * @param str
     * @return
     * @return byte[]
     * @since  1.0.0
     */
    private static byte[] hex2byte(String str) {
        if (str == null || str.length() < 2) {
            return new byte[0];
        }
        str = str.toLowerCase();
        int l = str.length() / 2;
        byte[] result = new byte[l];
        for (int i = 0; i < l; ++i) {
            String tmp = str.substring(2 * i, 2 * i + 2);
            result[i] = (byte) (Integer.parseInt(tmp, 16) & 0xFF);
        }
        return result;
    }
}

反射工具类

package com.gwh.aes_test.utils;


import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 反射工具类
 */
public class ReflectionUtil {

    /**
     * 递归所有Field
     *
     * @param clazz
     * @return
     */
    public static List<Field> getFields(Class clazz) {
        List<Field> fields = new ArrayList<>();
        Class current = clazz;
        while (!current.getName().equals(Object.class.getName())) {
            getFields(fields, current);
            current = current.getSuperclass();
        }
        return fields;
    }

    private static void getFields(List<Field> fields, Class clazz) {
        fields.addAll(Arrays.asList(clazz.getDeclaredFields()));
    }

    /**
     * 通过反射，设置指定对象中拥有指定注解的值
     */
    public static void setFieldValueByAnnotation(final Object obj, final Class annotation, final Object value) {
        List<Field> fields = getFields(obj.getClass());
        for (Field field : fields) {
            if (field.isAnnotationPresent(annotation)) {
                // 存在此注解，赋值
                setFieldValue(obj, field.getName(), value);
            }
        }
    }

    /**
     * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
     */
    public static void setFieldValue(final Object obj, final String fieldName, final Object value) {
        Field field = getAccessibleField(obj, fieldName);

        if (field == null) {
            throw new IllegalArgumentException("没有找到 [" + fieldName + "] 属性。对象为 [" + obj + "]");
        }

        try {
            field.set(obj, value);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    /**
     * 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
     * <p>
     * 如向上转型到Object仍无法找到, 返回null.
     */
    public static Field getAccessibleField(final Object obj, final String fieldName) {
        for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass
                .getSuperclass()) {
            try {
                Field field = superClass.getDeclaredField(fieldName);
                makeAccessible(field);
                return field;
            } catch (NoSuchFieldException e) {
                // Field不在当前类定义,继续向上转型
            }
        }
        return null;
    }

    /**
     * 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
     */
    public static void makeAccessible(Field field) {
        boolean flag = (!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())
                || Modifier.isFinal(field.getModifiers())) && !field.isAccessible();
        if (flag) {
            field.setAccessible(true);
        }
    }

}

在实体类上增加加密注解

package com.gwh.aes_test.entity;

import com.alibaba.fastjson.annotation.JSONField;
import com.gwh.aes_test.annotation.AesAnnotation;

import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "test_customer")
public class TestCustomer {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自增主键
    private Integer id;

    @AesAnnotation(ENCRYPTION = true)
    private String name;
    @AesAnnotation(ENCRYPTION = true)
    private String idNumber;
    @AesAnnotation(ENCRYPTION = true)
    private String phone;

    @JSONField(format = "yyyy-MM-dd")
    private Date createDate;

    @JSONField(format = "yyyy-MM-dd")
    private Date updateDate;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIdNumber() {
        return idNumber;
    }

    public void setIdNumber(String idNumber) {
        this.idNumber = idNumber;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public Date getUpdateDate() {
        return updateDate;
    }

    public void setUpdateDate(Date updateDate) {
        this.updateDate = updateDate;
    }



}

执行测试方法
在这里插入图片描述
保存到数据库中的是加密字符
在这里插入图片描述

前台查询数据时候，返回给前台的实体类进行解密脱敏

package com.gwh.aes_test.vo;

import com.alibaba.fastjson.annotation.JSONField;
import com.gwh.aes_test.annotation.AesAnnotation;

import java.util.Date;

public class CustomerVo {

    @AesAnnotation(DECRYPT = true,DESENSITIZATION = true,STYLE = "*")
    private String name;
    @AesAnnotation(DECRYPT = true,DESENSITIZATION = true,STYLE = "*")
    private String idNumber;
    @AesAnnotation(DECRYPT = true,DESENSITIZATION = true,STYLE = "*")
    private String phone;

    @JSONField(format = "yyyy-MM-dd")
    private Date createDate;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIdNumber() {
        return idNumber;
    }

    public void setIdNumber(String idNumber) {
        this.idNumber = idNumber;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }
}

在这里插入图片描述
完整代码可访问 git工具

智航云科技
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java 实现 AES 加密和解密完整示例
蜗牛的博客
05-12 2万+
AES，全称为 Advanced Encryption Standard，是一种分组密码算法，用于保护敏感数据的传输和存储。AES 分为 128 位和 256 位两种密钥长度，可以对数据进行加密和解密，保证数据的安全性和完整性。AES 主要应用于电子商务、移动支付、网络安全等领域，被广泛运用于现代社会的各个方面。AES 算法被设计为高度安全，可以在理论上保证其分组密码的安全性。然而，由于其复杂性和密钥长度，AES 算法的实现和应用也具有一定的技术难度。
JAVA实现AES加密、解密附代码
花生日记
04-22 5713
3、在 JavaEE中实现 AES算法，需要调用相应的接口： 我们在这个例子中调用了两个方法： （2）在上面的例子中我们使用了两个类： 通过上面的例子，我们可以看出，在 Java中实现 AES算法是比较简单的，但是由于涉及到了很多底层的知识，所以大家在使用的时候要注意： 1、 AES加密算法是一种高级加密算法，它在安全性方面要优于 DES加密算法。首先，我们先将加密后的字符串进行替换。在 Java中，我们可以通过以下代码实现加密、解密： 在这个过程中，我们需要注意的是，这里使用了字典进行加密和解密的运算。
推荐项目：AES-Base64 - 强大的加密与解密工具库
最新发布
gitblog_00028的博客
04-24 304
推荐项目：AES-Base64 - 强大的加密与解密工具库 项目地址:https://gitcode.com/BigYiza/AES-Base64 项目简介 AES-Base64 是一个轻量级且高效的Java库，专注于实现AES（Advanced Encryption Standard）加密算法和Base64编码解码功能。这个项目为开发者提供了一个简单易用的接口，使得在应用程序中集成数据安全加密变...
java自定义注解实现加密，解密，脱敏
zzqtty的博客
07-17 1523
ApiModelProperty(value = "加密",example = "xxx000XX")//返回给前端时候使用，去掉多层级@Component/*** 设置参数*/@Overridereturn;/*** 获取值*/@Override/*** 获取值*/@Override/*** 获取值*/@Override/** 脱敏类型*//*使用占位符*//*脱敏开始位置，从0开始计数，默认为0*//*
java aes加密 base64_【java】AES加密解密|及Base64的使用
weixin_31682257的博客
02-16 524
AES加解密算法，使用Base64做转码以及辅助加密：package com.wintv.common;import javax.crypto.Cipher;import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;import sun.misc.BASE64Decoder;import sun....
JAVA实现AES对称加密解密
Andy0214的专栏
07-05 6341
工具类代码： package com.test.commons.utils; import java.security.Key; import java.security.SecureRandom; import java.util.Base64; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypto.spec.Secret.
AES加解密算法基于JCEAPI实现
12-24
AES加解密算法基于Java Cryptography Extension (JCE) API实现，它为Java开发者提供了强大的加密功能。JCE API是Java平台的标准组件，用于处理各种加密操作，包括对称、非对称和哈希算法。 在Java中，AES加解密主要...
DES 加密 解密源码 java版 可运行
07-02
本Java实现的DES加密解密源码提供了一个可运行的例子，这对于理解和学习DES的工作原理非常有帮助。源码中的注释清晰，使得开发者能够快速了解每一步操作的含义。 DES加密过程主要包括以下几个步骤： 1. **Key ...
Java 敏感信息加密处理
08-31
Java 敏感信息加密处理 Java 敏感信息加密处理是指在 Java 应用程序中对敏感信息（如...Java 敏感信息加密处理是保护用户隐私数据的重要手段，我们可以使用 AES 加密方式和自定义注解来实现敏感信息的加密和解密。
用Java写的AES DEMO
10-14
标题中的“用Java写的AES DEMO”表明这是一个使用Java编程语言实现的AES（Advanced Encryption Standard）加密算法的示例程序。AES是一种广泛使用的对称加密标准，用于保护数据的安全性，尤其是在网络通信和数据存储...
burp插件分享：图形化版的重算sign和参数加解密插件1
08-03
Resign 功能目前支持 MD5 签名算法，而 Para Encrypter 支持 AES 和 Base64 加解密。这意味着对于采用这些算法的应用，插件能够自动处理参数，无论是加密还是解密，使得测试人员无需手动进行繁琐的加密解密过程。 ...
java加密工具类 md5 aes base64 urlencode
03-25
加密工具类 包含md5加密 base加密解密 md5加密 aes加密解密 urlencoude
AES加密base64编码
04-19
AES加密，使用base64编码，可以兼容ios
java aes base64
qdujunjie的专栏
05-20 2049
andy@AndyMacBookPro:/usr/local/webdata/java/PHP-Java-AES-Encrypt$ javac -classpath ./libs/commons-codec-1.10.jar security.java security.java:6: 类 Security 是公共的，应在名为 Security.java 的文件中声明 public class Se
java注解加密参数,如何优雅的实现 Spring Boot 接口参数加密解密？
weixin_40006965的博客
03-22 858
因为有小伙伴刚好问到这个问题，松哥就抽空撸一篇文章和大家聊聊这个话题。加密解密本身并不是难事，问题是在何时去处理？定义一个过滤器，将请求和响应分别拦截下来进行处理也是一个办法，这种方式虽然粗暴，但是灵活，因为可以拿到一手的请求参数和响应数据。不过 SpringMVC 中给我们提供了 ResponseBodyAdvice 和 RequestBodyAdvice，利用这两个工具可以对请求和响应进行预处...
Java 使用mybatis的BaseTypeHandler实现数据自动AES加密解密，通过Hutool工具类自定义注解实现数据脱【附有完整步骤和代码】
weixin_44934104的博客
12-15 4016
此时在mybatis plus中是可以正常使用的，但是当我们在xml中自定义SQL文件时无效，这时需要在xml中定义resultMap(1) 在实体中设置:autoResultMap = true@Data(2)在xml中设置返回数据类型1）xml中自定义sql 返回实体类不能解密，返回resultMap在map中配置typeHandler可以解密。2）自带的wrappers更新不能加密，需要将数据加密后更新。//自定义MY_RULE,//用户idUSER_ID,
Java敏感数据入参出参时自定义加解密注解
telescopewang的博客
04-28 1114
数据库中，身份证、手机号等隐私数据密文存储，Java返回数据给前端时需要解密，前端查询传入参数时，需要将数据加密，否则匹配不到数据库中存储的密文数据。自定义序列化解密注解，在返回给前端时，对数据解密。自定义反序列化加密注解，前端传参时，对数据加密。编辑数据时，需要将身份证、手机号解密。正则常量表达式常量类。
java base64 aes加密_Java AES加/解密 + Base64编/解码
weixin_42512613的博客
03-01 1012
1.AES 密钥+偏移进行加密解密 结合 base64对加密之后的字节数组进行编码解码(代码如下)最近项目上需要用到数据加密存储，查询资料后发现目前AES加密安全度非常高，具体原理可自行百度。但经网上搜到的实现示例运行都有各种问题，耗时一上午，终于调试运行成功，闲话少说，直接上代码。参考gfaming的博客import javax.crypto.Cipher;import javax.crypto...
用js代码实现aes算法的cbc模式加解密算法并注释
05-10
以下是用JavaScript实现AES算法的CBC模式加解密算法的示例代码： ```javascript // 定义AES加解密算法函数 function aesCBC(operation, key, iv, data) { var aesAlgorithm = "AES-CBC"; var blockSize = 16; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值