Spring-Web - 数据库 字段加密 解密

  在工作中，为了保证数据安全，需要对数据库字段进行加解密，之前工作中就遇到了这种情况，因为线上数据库有很多的人都有权限，运维，账务，运营（通过后台系统查看），出口太多了，但有用户向我们平台举报，说有骚扰电话 ，能精准的知道用户姓名，手机号， 身份证号 ，以及一些用户在我们平台的账户数据，没有办法，数据被泄漏了，肯定不是阿里云数据库不安全导致的， 而是内部人员将数据给泄漏出去，因为出口太多，人员也太多，不知道怎么查询，公司决定将数据库中所有的用户的姓名，手机号， 身份证三要素加密，从数据库中无法看到三要素的名文，从而缩小数据导出人群的范围，因为这样做可能只有开发人员才能导出了。 其他运营，运维都只能看到加密的数据，如果没有密钥的话，是肯定解密不了数据，而后台做了一个功能，能将密文的excel导入，并转化为明文，但每一次解密的条数有限制，而且每次谁使用了导出明文功能，将消息发送钉钉群，这样一般人基本上就拿不到明文数据了，从而保证了数据的安全性。

  理想确实是好的，但是这却累死开发人员了，项目中几十张表中的字段都需要加密解密， 相当于每一张表的插入，查询出的数据，查询条件都需要加密，这工作量非常的大，同时为后期的维护带来无穷尽的麻烦 ， 每一次插入，查询条件，查询得出的结果都要想到这个字段是否是加密字段，如果是，则需要做相关的转化，几十张表都要记下来，太麻烦了， 同时新加的表也要考虑这些事情，而原本整洁的代码可能会因为加上这些加密解密变得臃肿不堪，有没有一种好的方案来解决这个问题呢？如开发人员只需要配置哪些表的哪些字段需要加密解密，而在代码中不需要做任何修改，保证保存到数据库中的是密文，取出的是名文，而查询也没有影响，按原来的操作即可， 插件会根据需要将相应的查询条件进行加密，如果这能实现那该多好啊，对开发人员没有任何工作量，而扩展性和维护性那就勿庸置疑了，如果想实现这样一个功能，该怎样做呢？

  既然有了理想，接下来就是怎么去实现这样一款插件的功能了，再看插件如何开发之前，我们先来看一下插件的效果 。

1. 创建表

CREATE TABLE lt_user_phone (
id bigint(20) NOT NULL AUTO_INCREMENT COMMENT ‘主键，自增id’,
is_delete tinyint(4) NOT NULL DEFAULT ‘0’ COMMENT ‘是否删除状态，1：删除，0：有效’,
gmt_create datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT ‘创建时间’,
gmt_modified datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT ‘最后修改时间’,
user_name_en varchar(64) NOT NULL DEFAULT ‘’,
real_name_en varchar(64) NOT NULL DEFAULT ‘’,
unique_code varchar(32) NOT NULL DEFAULT ‘’,
cnl_code varchar(64) DEFAULT ‘’,
type tinyint(4) NOT NULL DEFAULT ‘1’,
PRIMARY KEY (id),
KEY Index_uniqueCode (unique_code) USING BTREE,
KEY index_user_name_en (user_name_en) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8mb4 COMMENT=‘用户表’;

CREATE TABLE lt_stage_borrow (
id bigint(11) unsigned NOT NULL AUTO_INCREMENT COMMENT ‘自增主键’,
is_delete bigint(4) NOT NULL DEFAULT ‘0’ COMMENT ‘是否删除’,
gmt_create datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
gmt_modified datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
unique_code varchar(20) DEFAULT NULL,
PRIMARY KEY (id),
KEY idx_borrowcach_uid (unique_code)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COMMENT=‘分期借款表’;

  【注意】lt_user_phone 和 lt_stage_borrow 这两个表名为了和公司的用户表，记录表有所区别，所以这两张表名是我随意取的，字段为了和之前的有所区别，因此字段名也是随便弄的，方便和公司的业务表区分开，所以大家看起来可能觉得费解，如lt_stage_borrow 表存一个user_id 不就可以了不？还用unique_code来关联有什么意义。就是为了和公司相关的信息抹除，所以大家只关注技术即可，不需要关注字段含义。

2. 配置字段，有些简单了，有兴趣可以写在配置文件中

@Slf4j
@Configuration
public class MybatisPluginConfig {

    //初始化变量
    @PostConstruct
    public void postConstruct() {
        log.info("开始初始化表数据");
        EncryptTableConfig.tableConfig.put("lt_user_phone", new PPTuple(Arrays.asList(new String[]{"real_name_en", "user_name_en", "id_number_en"}),
                Arrays.asList(new String[]{})));
    }
}

  配置文件的目的就是配置lt_user_phone表的real_name_en，user_name_en，id_number_en字段需要加密解密字段

3. 配置加密解密的bean

@Bean(name = "sqlSessionFactory")
public SqlSessionFactory initSqlSessionFactory( PaginationInterceptor paginationInterceptor) throws Exception {
    MybatisSqlSessionFactoryBean sessionFactory = new MybatisSqlSessionFactoryBean();
    sessionFactory.setDataSource(initDataSource());
    sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
            .getResources(env.getProperty("mybatis-plus.mapper-locations")));
    sessionFactory.setConfigLocation(new ClassPathResource("mybatis-config.xml"));
    Interceptor[] interceptor = {paginationInterceptor,new DataScopeInterceptor(),new DataPrepareEncryptScopeInterceptor(),
            new DataEncryptScopeInterceptor(),new RestoreDataScopeInterceptor(),new QueryDecryptScopeInterceptor(),new MapF2FInterceptor()};
    sessionFactory.setPlugins(interceptor);
    return sessionFactory.getObject();
}

  DataPrepareEncryptScopeInterceptor，DataEncryptScopeInterceptor，RestoreDataScopeInterceptor，QueryDecryptScopeInterceptor 加密解密相关的插件，为什么这么配置，后面再来分析

4. 先来看插入效果

// http://localhost:8502/api/test1
@RequestMapping("/test1")
public String test1() throws Exception {
    UserPhone userPhone = new UserPhone();
    userPhone.setUserNameEn("18488888888");
    userPhone.setRealNameEn("张三");
    userPhone.setIdNumberEn("483898329832983");
    userPhone.setUserNo("89329832");
    userPhone.setCnlCode("chenn");
    userPhone.setChannelCode("3232");
    userPhone.setType(1);
    userPhoneDao.insertUserPhone(userPhone);
    return "sucess";
}

  在代码中，我没有对任何字段加密，但打印的sql中却体现了加密效果。再来看看数据库保存的数据怎样。

  相应的字段被加密保存到数据库中。

5. 再来看另外一个效果，那查询结果会解密吗？

// http://localhost:8502/api/test2
@RequestMapping("/test2")
public String test2() throws Exception {
    UserPhone userPhone = userPhoneDao.selectUserPhoneByUserNameEn("18488888888");
    System.out.println(JSON.toJSONString(userPhone));
    return "sucess";
}

  结果输出
  从图中可以得知，在代码中输入的查询条件为18488888888，但sql打印出的查询条件已经被加密，在数据库中数据是被加密的，但是通过JSON.toJSONString(userPhone) JSON 打印，数据是被解密的。是不是感觉几招下来，开发功底尽显。不吹牛逼了，继续来看问题。

  从上面两个小例子中，当插入数据时，能对数据库字段加密，当查询数据时，能对符合加密条件的字段加密，对不需要加密的字段则不会加密，大家不要有一种错觉，【我对所有的查询条件都加密，显然不是】，当然后面还会分析更新，批量更新，分页查询等遇到的问题及解决方案。

  如果我们能精准的知道哪些查询条件字段需要被加密，当然还包括子查询 ，这必须涉及到一个问题，就是SQL解析，我们在mybatis插件中能得到如下SQL : SELECT * FROM lt_user_phone WHERE is_delete = 0 AND user_name_en = ? LIMIT 1
  其实我们只需要知道SQL中每个 ？ 所代表的是哪个字段，并且这个字段属于哪张表，即可与我们配置信息（配置了哪张表的哪些字段需要被加密解密）中的字段和表比对，如果与配置表中配置的表名和字段名相匹配，则表示这个字段是需要被加密或解密的，从而对mybatis中传入数据进行加密即可。 既然有了想法，那么接下来看如何做。
  我们需要准备一个SQL解析包，能解析出每条SQL中？是哪个字段的条件并且属于哪张表？说是这么说，但怎么实现呢？ SQL又有子查询，又有关联查询，又有子查询套子查询，我的天呐，不可能实现的嘛，这明显是写一个SQL解析器嘛。
  当然，感谢互联网时代，感谢阿里，他提供了一个druid的包，使得项目得到进展 ， 当然我个人是非常喜欢和崇拜阿里的，他提供了太多的开发框架，如 Druid ，Dubbo，Rocketmq，Arthas，Nacos，Sentinel等，我觉得这些框架都值得去研究，回归正题。
  因为Druid包本身提供了对SQL的解析功能，只需要将这个包改成我们想要的为止，也忘记了曾经3天没日没夜的修改，最后比较完善，包路径为https://github.com/quyixiao/sql-parser.git
  既然如此，我们来看包的执行效果。

public class TestSql2 {

    public static void printSql(String sql) {
        // 新建 MySQL Parser
        SQLStatementParser parser = new MySqlStatementParser(sql);
        SQLExprParser exprParser = parser.getExprParser();
        Lexer lexer = exprParser.getLexer();
        SQLObjectImpl.lexer = lexer;

        // 使用Parser解析生成AST，这里SQLStatement就是AST
        SQLStatement statement = parser.parseStatement();
        // 使用visitor来访问AST
        MySqlSchemaStatVisitor visitor = new MySqlSchemaStatVisitor();

        statement.accept(visitor);
        // 从visitor中拿出你所关注的信息
        Collection list = visitor.getColumns();

        List header = new ArrayList() {{
            add(new Cell("tableName"));
            add(new Cell("column"));
            add(new Cell("select"));
            add(new Cell("where"));
            add(new Cell("join"));
            add(new Cell("groupBy"));
            add(new Cell("having"));
            add(new Cell("fullName"));
            add(new Cell("dataType"));
            add(new Cell("pos"));
            add(new Cell("test"));
        }};
        List> body = new ArrayList>();
        for (TableStat.Column column : list) {
            List cells = new ArrayList();
            cells.add(new Cell(column.getTable()));
            cells.add(new Cell(column.getName()));
            cells.add(new Cell(column.isSelect() + ""));
            cells.add(new Cell(column.isWhere() + ""));
            cells.add(new Cell(column.isJoin() + ""));
            cells.add(new Cell(column.isGroupBy() + ""));
            cells.add(new Cell(column.isHaving() + ""));
            cells.add(new Cell(column.getFullName() + ""));
            cells.add(new Cell(column.getDataType() + ""));
            cells.add(new Cell(column.getPos() + ""));
            if (column.getPos() > 10) {
                cells.add(new Cell(sql.substring(column.getPos(), column.getPos() + column.getName().length())));
            } else {
                cells.add(new Cell(""));
            }
            body.add(cells);
        }
        String a = new ConsoleTable.ConsoleTableBuilder().addHeaders(header).addRows(body).build().toString();
        System.out.println(a);
    }

    @org.junit.Test
    public void test() {
        String sql = "select * from lt_user_phone up  left join lt_stage_borrow sb  on up.unique_code = sb.unique_code where up.user_name = ? and up.real_name = ? and sb.status = ? ";
        System.out.println(sql);
        printSql(sql);
    }

}

  sql为select * from lt_user_phone up left join lt_stage_borrow sb on up.unique_code = sb.unique_code where up.user_name = ? and up.real_name = ? and sb.status = ? ，SQL的意思很简单吧， 通过lt_user_phone这张表的user_name和real_name关联查询
lt_stage_borrow表，并且lt_stage_borrow.status为查询条件，意思就是通过lt_user_phone的user_name和real_name字段及lt_stage_borrow表的status字段查询表的所有数据 。

  从执行结果来看，是不是拿到了? 对应的表名和字段名，可能大家觉得这个是比较简单的sql ，我们再来看更加复杂的sql，执行效果 。

  我们再次写了一条复杂的sql , 其中传入了5个查询条件，毫无疑问，结果是正确的，当年我在测试这个包的时候，测试了几百条SQL，最终将发现的问题都修复了，而且现在已经在1000万用户以上的平台线上运行了2年左右，所以这款插件的准确性还是不用担心的，目前没有发现什么问题， 放心使用即可。
  关于sql-parser插件的源码感兴趣可以自行去研究，当然感兴趣建议去研究Druid源码，里面涉及到SQL 的解析，当然不要想得有什么捷径，和其他语言解析器一样，都是一个字符一个字符的读取，最终构建成一颗语法树，当然呐，Druid插件的源码解析也并非一朝一夕阳能说清楚，也不是一篇博客能说明白，先放着，以后有机会再来写相关的博客 。

1. 查询条件加密开始修改，我们写一个DataQueryEncryptScopeInterceptor mybatis拦截器。

@Slf4j
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class, Integer.class})})
public class DataQueryEncryptScopeInterceptor extends SqlParserHandler implements Interceptor {

    public DataQueryEncryptScopeInterceptor() {

    }

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        StatementHandler statementHandler = (StatementHandler) PluginUtils.realTarget(invocation.getTarget());
        MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
        // 先判断是不是SELECT操作
        BoundSql boundSql = (BoundSql) metaObject.getValue("delegate.boundSql");
        MappedStatement mappedStatement = (MappedStatement) metaObject.getValue("delegate.mappedStatement");
        if (SqlCommandType.SELECT.equals(mappedStatement.getSqlCommandType())) {           //非select语句
            this.sqlParser(metaObject);
            ParameterHandler parameterHandler = (ParameterHandler) metaObject.getValue("delegate.parameterHandler");
            String mapperdId = PSqlParseUtil.getMapperId(mappedStatement);
            Configuration configuration = mappedStatement.getConfiguration();
            encrySqlParamData(configuration, parameterHandler, mapperdId, boundSql);
            Object result = invocation.proceed();
            return result;
        } else {
            return invocation.proceed();
        }
    }

    @Override
    public Object plugin(Object target) {
        if (target instanceof StatementHandler) {
            //使用MyBatis提供的Plugin类生成代理对象
            return Plugin.wrap(target, this);
        }
        return target;
    }
  
    @Override
    public void setProperties(Properties properties) {

    }
}

  其他代码都是mybatis 的常规操作，而encrySqlParamData代码就是我们查询条件加密的方法 。

public void encrySqlParamData(Configuration configuration, ParameterHandler parameterHandler, String mapperdId, BoundSql boundSql) {
    PTuple2> data = null;
    String sql = boundSql.getSql();
    // 不能每条sql都进行解析，对于相同的SQL
    // 只做一次解析，将解析的结果以 mapperdId + md5(sql) 组成key
    // 存储到缓存中
    String key = mapperdId + PMD5Util.encode(sql);
    try {
        PPTuple pluginTuple = enterMap.get(key);
        if (pluginTuple == null) {
            // data 为元组
            // 第一个对象标识SQL中有没有需要被加密解密的字段
            // 第二个对象为一个map , key 为 加密字段出现的位置，value 为字段名称
            // 如select * from user where status = ? and user_name_en = ?
            // 而status 不需要被加密解密 ,user_name_en 需要被加密解密
            // 则map 中存储的为 key  = 1 ， value = user_name_en
            data = getChangeColumn(configuration, mapperdId, sql, key).getData();
        } else {
            data = pluginTuple.getData();
        }
        // 这里使用了元组，虽然Java 使用元组不太好用
        // 那还是用一下吧， first存储的是这条SQL有没有字段需要被加密解密
        // 如果first 为true，表示SQL中有字段需要被加密，如果为false
        // SQL 中没有任何字段需要被加密解密
        if (!data.getFirst()) {
            return;
        }
        
        Map paramMaps = data.getSecond();
        Object parameterObject = boundSql.getParameterObject();
        StringBuffer sb = new StringBuffer();
        List parameterMappings = boundSql.getParameterMappings();

        if (parameterMappings.size() > 0 && parameterObject != null) {
            // 如果parameterObject 是字符串，并且
            // 并且 parameterMappings 只有一个参数
            if (parameterMappings != null && parameterMappings.size() == 1
                    && parameterObject != null && parameterObject instanceof String) {
                // 通过反射修改 parameterObject 属性值
                // 为加密后的值
                Object encode = encode(parameterObject + "");
                setFieldValue(parameterHandler, "parameterObject", encode);
                sb.append("(").append(parameterObject).append(" -> ").append(encode).append("),");
            } else {
                MetaObject metaObject = configuration.newMetaObject(parameterObject);
                if (parameterObject instanceof DefaultSqlSession.StrictMap) {       //表示一个集合
                    Set keySet = ((DefaultSqlSession.StrictMap) parameterObject).keySet();
                    // 对于查询条件是一个list 或 collection时
                    // 需要将list或collection对象的值给替换掉，这个和mybatis源码相关
                    if(keySet.contains("list")){
                        List