敏感信息加密处理

超、凢脫俗 2021-12-24 14:17 316阅读 0赞

版权声明：本文为博主原创文章，转载请注明出处，欢迎使劲喷

一、敏感信息加密处理我们要实现什么

系统往往需要将用户敏感信息进行加密，不同的敏感信息加密要求不同。

比如，密码的加密，我们往往不需要是可逆的。用户输入密码后，通过系统的加密规则，编码后直接比对加密存储的密码，获得比对结果即可证明用户登录信息合法性。

然后，有时我们为了防止被脱库导致的数据泄漏，不得不对一些敏感信息（比如：身份证号、手机号）进行加密。这样的数据不仅要求加密，还需要在展示及其他业务场景下完全显示，或者掩码显示，这就需要我们对加密的内容进行解密。

二、敏感信息加密处理我做了些什么

近来，项目中为了实现这个需求，做了些简单的设计：

注：考虑到在维护生产数据时方便查询，这里使用aes加密方式，该加密方式同mysql的aes加密结果相同，故可在sql中直接使用hex及aes\_encrypt函数进行查询；密盐可保存在配置文件中。

1.使用自定义注解，po的每个类中需要加密及解密的字段可添加该注解

2.声明Base类，并实现encrypt和decrypt方法，方法实现利用java反射及自定义注解

3.所有需要用到加密及解密的实体对象，必须继承自Base类

4.实体类加密时调用encrypt方法，解密时调用decrypt方法，如此可实现对该对象中敏感数据的加密解密

三、敏感信息加密实现

1.先看效果

![807092-20170315165651073-1680012197.jpg][]

注释很清楚，先给对象设置身份证号，然后执行自加密方法，返回自己的引用，打印出来加密后该对象的json字符串；执行自解密方法，返回自己的引用，打印出来解密后该对象的json字符串。

2.设计实现结构

1 crypt
     2       |
     3       |--annotation
     4       |        |--DecryptFiled
     5       |        |--EncryptFiled
     6       |--crypt
     7       |        |--EncryptDecryptInterface 8 |--domain 9 | |--BaseInfo 10 | |--SimpleDomain 11 |--utils 12 | |--MySqlUtils

2.1先看看注解的实现

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/**
     * Created by bright on 2017/2/22.
     *
     * @author :
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    public @interface EncryptFiled {
        String value() default "";
    }

自定义注解

两个注解的实现一致，注解名称不同而已，不再贴另外一个注解的代码。

2.2定义自加密、自解密接口

Base类实现该接口中的自加密自解密方法

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/**
     * Created by bright on 2017/2/22.
     *
     * @author :
     */
    public interface EncryptDecryptInterface {
    
        public <T> T encryptSelf();
    
        public <T> T decryptSelf();
    
    }

自定义接口

2.3MysqlUtils的实现

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/**
     * Created by bright on 2017/2/22.
     *
     * @author :
     */
    @Component
    public class MySqlUtils {
    
        private static final String ENCRYPTTYPE= "AES";//加密方式
    
        private static final String ENCODING = "UTF-8";//加密时编码
    
        private static String MYSQLUTILSKEY = "aaa";//加密密盐
    
        private static MySqlUtils mysqlUtils;//单例
    
        private static Cipher encryptCipher ;//加密cipher
    
        private static Cipher decryptChipher;//解密chipher
    
        /**
         * 该方法可用在spring项目中使用配置文件设置密盐，默认值为123
         * @param key
         */
        @Value("${mysql.column.crypt.key:123}")
        public void setMysqlutilskey(String key){
            MySqlUtils.MYSQLUTILSKEY = key;
        }
    
    
        /**
         * encryptCipher、decryptChipher初始化
         */
        public static void init(){
            try {
                encryptCipher = Cipher.getInstance(ENCRYPTTYPE);
                decryptChipher = Cipher.getInstance(ENCRYPTTYPE);
                encryptCipher.init(Cipher.ENCRYPT_MODE, generateMySQLAESKey(MYSQLUTILSKEY, ENCODING));
                decryptChipher.init(Cipher.DECRYPT_MODE, generateMySQLAESKey(MYSQLUTILSKEY, ENCODING));
            } catch (InvalidKeyException e) {
                throw new RuntimeException(e);
            } catch (NoSuchAlgorithmException e) {
                throw new RuntimeException(e);
            } catch (NoSuchPaddingException e) {
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 单例获取方法实现
         * @return
         */
        public synchronized static MySqlUtils getInstance(){
            if(mysqlUtils == null){
                mysqlUtils = new MySqlUtils();
                init();
            }
            return mysqlUtils;
        }
    
    
        /**
         * 加密算法
         * @param encryptString
         * @return
         */
        public String mysqlAESEncrypt(String encryptString) {
            try{
                return new String(Hex.encodeHex(encryptCipher.doFinal(encryptString.getBytes(ENCODING)))).toUpperCase();
            } catch (BadPaddingException e) {
                throw new RuntimeException(e);
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            } catch (IllegalBlockSizeException e) {
                throw new RuntimeException(e);
            }
        }
    
        /**
         * 解密算法
         * @param decryptString
         * @return
         */
        public String mysqlAESDecrypt(String decryptString){
            try {
                return new String(decryptChipher.doFinal(Hex.decodeHex(decryptString.toCharArray())));
            } catch (DecoderException nspe) {
                throw new RuntimeException(nspe);
            } catch (BadPaddingException nsae) {
                throw new RuntimeException(nsae);
            } catch (IllegalBlockSizeException ike) {
                throw new RuntimeException(ike);
            }
        }
    
        /**
         * 产生mysql-aes_encrypt
         * @param key 加密的密盐
         * @param encoding  编码
         * @return
         */
        public static SecretKeySpec generateMySQLAESKey(final String key, final String encoding) {
            try {
                final byte[] finalKey = new byte[16];
                int i = 0;
                for(byte b : key.getBytes(encoding))
                    finalKey[i++%16] ^= b;
                return new SecretKeySpec(finalKey, "AES");
            } catch(UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
        }
    
    }

MysqlUtils

2.4BaseInfo类的实现

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/**
     * Created by bright on 2017/2/22.
     *
     * @author :
     */
    public class BaseInfo implements Cloneable, EncryptDecryptInterface {
    
        /**
         * 拷贝一个对象，并对新对象进行加密
         * 该方法主要用在日志打印上，可防止原对象被加密而影响程序执行
         * @param <T>
         * @return
         */
        public <T extends BaseInfo> T cloneAndEncrypt() {
            T cloneT = null;
            try {
                cloneT = (T) this.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
            if(cloneT !=null)
                return cloneT.encryptSelf();
            throw new RuntimeException("拷贝对象异常");
        }
    
        /**
         * 重写clone方法
         * @return
         * @throws CloneNotSupportedException
         */
        @Override
        protected Object clone() throws CloneNotSupportedException {
            try {
                return super.clone();
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
                return null;
            }
        }
    
        /**
         * 实现自加密
         *
         * @param <T>
         * @return
         */
        public <T> T encryptSelf() {
            Field[] declaredFields = this.getClass().getDeclaredFields();
            try {
                if (declaredFields != null && declaredFields.length > 0) {
                    for (Field field : declaredFields) {
                        if (field.isAnnotationPresent(EncryptFiled.class) && field.getType().toString().endsWith("String")) {
                            field.setAccessible(true);
                            String fieldValue = (String) field.get(this);
                            if (StringUtils.isNotEmpty(fieldValue)) {
                                field.set(this, MySqlUtils.getInstance().mysqlAESEncrypt(fieldValue));
                            }
                            field.setAccessible(false);
                        }
                    }
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
            return (T) this;
        }
    
        /**
         * 实现自解密
         *
         * @param <T>
         * @return
         */
        public <T> T decryptSelf() {
            Field[] declaredFields = this.getClass().getDeclaredFields();
            try {
                if (declaredFields != null && declaredFields.length > 0) {
                    for (Field field : declaredFields) {
                        if (field.isAnnotationPresent(DecryptFiled.class) && field.getType().toString().endsWith("String")) {
                            field.setAccessible(true);
                            String fieldValue = (String)field.get(this);
                            if(StringUtils.isNotEmpty(fieldValue)) {
                                field.set(this, MySqlUtils.getInstance().mysqlAESDecrypt(fieldValue));
                            }
                        }
                    }
                }
            } catch (IllegalAccessException e) {
                throw new RuntimeException(e);
            }
            return (T) this;
        }
    }

BaseInfo

2.5一个简单的对象

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/**
     * Created by bright on 2017/2/22.
     *
     * @author :
     */
    public class SimpleDomain extends BaseInfo{
    
        @EncryptFiled
        @DecryptFiled
        private String id;
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    }

SimpleDomain

2.6来个调用

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

public class Client {
    
        @Test
        public void test(){
            SimpleDomain sd = new SimpleDomain();//要进行加密解密的实体类
            sd.setId("6029131988005021537");//注入身份证号
            System.out.println(JSON.toJSONString(sd.encryptSelf()));//执行自加密后输出
            System.out.println(JSON.toJSONString(sd.decryptSelf()));//执行自解密后输出
        }
    }

Client

转载于:https://www.cnblogs.com/shizhanming/p/6555241.html

[807092-20170315165651073-1680012197.jpg]: /images/20211223/0b803dbc027a43dbba876bec24f57e83.png
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20211223/9d955f2fc24c41e6a33a42c8c39d20fc.png

发表评论取消回复

表情：

评论列表（有 0 条评论，316人围观）

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

相关阅读

相关代码安全风险：未对Java敏感信息进行加密处理

在Java开发中，如果直接将敏感信息（如用户密码、API密钥等）暴露在代码中，确实存在严重的安全风险。解决方法通常包括以下几个方面： 1. **数据加密**：对于存储的敏

╰半夏微凉°/ 2024年10月17日 23:30/ 0 赞/ 33 阅读

相关 Java安全性：敏感信息加密示例

在Java中，保护敏感信息是非常重要的。这通常通过加密算法来实现。以下是一个使用AES（Advanced Encryption Standard）进行敏感信息加密的简单示例：

曾经终败给现在/ 2024年10月15日 04:57/ 0 赞/ 36 阅读

相关 web敏感信息加密实现

在 Web 上实现敏感信息的加密通常有以下几种方法： 1. 使用 HTTPS 协议。HTTPS 协议在传输数据时使用了加密技术，可以有效保护数据的安全性。 2. 使用加密

心已赠人/ 2024年03月25日 12:54/ 0 赞/ 83 阅读

相关使用Python加密敏感信息

在现代社会中，保护个人信息的安全性至关重要。其中之一就是加密敏感信息，例如密码。本文将介绍如何使用Python编程语言来加密和存储密码，以确保其安全性。在开始之前，我们需要

ゝ一世哀愁。/ 2024年03月02日 09:45/ 0 赞/ 46 阅读

相关 jasypt-spring-boot 加密敏感信息

文章目录一、简介二、导入依赖三、加密字段工具类四

太过爱你忘了你带给我的痛/ 2023年09月27日 11:47/ 0 赞/ 122 阅读

相关 mysql数据库中针对敏感信息字段加密处理问题

最近有这样一个需求，针对系统中的敏感信息，如供应商的手机号码，银行账号等需要做加密处理。比较常见的加密方式如md5，但是公司架构组的给出的方案是：统一在数据库处理，使用mysq

迈不过友情╰/ 2022年05月10日 07:16/ 0 赞/ 438 阅读

相关 SpringBoot配置文件敏感信息加密

前言 SpringBoot配置文件中的内容通常情况下是明文显示，安全性就比较低一些。在application.properties或application.yml，比如m

以你之姓@/ 2022年01月17日 00:01/ 0 赞/ 334 阅读

相关敏感信息加密处理

版权声明：本文为博主原创文章，转载请注明出处，欢迎使劲喷一、敏感信息加密处理我们要实现什么系统往往需要将用户敏感信息进行加密，不同的敏感信息加密要求不同。比如，密码

超、凢脫俗/ 2021年12月24日 14:17/ 0 赞/ 317 阅读

相关 SpringBoot 配置文件敏感信息加密

说明使用过SpringBoot配置文件的朋友都知道，资源文件中的内容通常情况下是明文显示，安全性就比较低一些。打开`application.properties`或

痛定思痛。/ 2021年12月04日 01:45/ 0 赞/ 381 阅读

相关关于SpringBoot项目配置敏感信息加密问题处理方法

关于SpringBoot项目配置敏感信息加密问题处理方法前言技术方案最佳实践前言 SpringBoot项目配置文件

r囧r小猫/ 2021年12月01日 12:28/ 0 赞/ 387 阅读