被加密后的数据怎么进行模糊查询

背景

为了数据安全我们在开发过程中经常会对重要的数据进行加密存储，常见的有：密码、手机号、电话号码、详细地址、银行卡号、信用卡验证码等信息，这些信息对加解密的要求也不一样，比如说密码我们需要加密存储。

一般对这些数据的检索方式只能是完全匹配，如果是模糊匹配的话，根本匹配不了。因为信息已经被加密。

在网上搜素了一些做法，并对这些做法进行了实践。

实践

设计表

设计一个订单表，具有以下基本信息：
主键id
订单号
收货人名称
收货人手机
收货人地址
发货人名称
发货人手机
发货人地址
订单创建时间

CREATE TABLE `ts_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `order_no` varchar(50) NOT NULL COMMENT '订单号',
  `receiver_name` varchar(100) NOT NULL COMMENT '收货人姓名',
  `receiver_phone` varchar(100) NOT NULL COMMENT '收货人手机号',
  `receiver_address` varchar(100) NOT NULL COMMENT '收货人地址',
  `sender_name` varchar(100) NOT NULL COMMENT '发货人姓名',
  `sender_phone` varchar(100) NOT NULL COMMENT '发货人手机号',
  `sender_address` varchar(100) NOT NULL COMMENT '发货人地址',
  `ctime` datetime NOT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COMMENT='模糊查询-订单表'

保存适量数据，使用加密算法加密部分字段，这里我选择加密发货人手机两个字段。

方法一：加载进内存

将所有的数据加载进内存，然后进行统一解密，再进行模糊查询。
如果数据量小的话还可以实现，但是数据量大的话还是不要想了，不切实际。因为在mysql里面，英文字母占一个字节，一个汉字占用两个字节，用DES来举例，13800138000加密后的串HE9T75xNx6c5yLmS5l4r6Q==占24个字节。

轻则上百兆，重则上千兆，这样分分钟给应用程序整成Out of memory，这样做如果数据少只有几百、几千、几万条时是完全可以这样做的，但是数据量大就强烈不建议了。

方法二：在mysql中使用解密函数

这里，我用AES演示，在查询时，使用对应的解密函数先进行解密，然后再进行模糊查询，如：

-- 代码上我是先进行AES加密，然后base64 url编码后保存到数据库中，mysql只需要走个逆流程
select to2.*from mybatis.ts_order to2 
where
AES_DECRYPT(from_base64(to2.sender_name)) like '%name%'

我在实践过程中，base64解码我是按照如下步骤进行的：

BASE64URL解码的流程：
      1、把BASE64URL的编码做如下解码：
               1)把"-"替换成" "
               2)把"_"替换成"/"
               3)(计算BASE64URL编码长度)%4
                           a)结果为0，不做处理
                           b)结果为2，字符串添加"=="
                           c)结果为3，字符串添加"="
      2、使用BASE64解码密文，得到原始的明文

得到的原文没有什么差别，然后我调用mysql的AES_DECRYPT进行解码，得到的是一个NULL值，我现在找不出原因，所以只能搁置这个方案了。
而且这个方法也不是十全十美的

1. 无法使用索引优化
2. 有一些数据库不是完全支持加解密算法实现的，例如我之前使用DES加解密，结果到Mysql提示了DES加解密函数废弃了，所以我这里的例子使用AES（虽然结果还是不行==）

方法三：分词加密模糊查询

设计思路

对密文数据进行分词组合，将分词组合的结果集分别进行加密，然后存储到扩展列，查询时通过key like '%partial%'，这是一个比较划算的实现方法，我们先来分析一下它的实现思路。

比如，对手机号进行分词加密，增加一个sender_phone_extend的字段，用来存储分词加密的结果。
先对字符进行固定长度的分组，将一个字段拆分为多个，比如说根据4位英文字符（半角），2个中文字符（全角）为一个检索条件

ningyu1使用4个字符为一组的加密方式，第一组ning ，第二组ingy ，第三组ngyu ，第四组gyu1 … 依次类推。再短的长度不建议支持，因为分词组合会增多从而导致存储的成本增加，反而安全性降低。

如果需要检索所有包含检索条件4个字符的数据比如：ingy ，加密字符后通过 key like “%partial%” 查库。

由于分词加密后的字符串比较长，我使用的Blowfish加密，加密后字符串长度是12，对手机号前8位进行加密并且base64 url编码后，长度为8*12 =96 ，因此预估扩展字段需要是96位以上。

实现一个简单的模糊查询例子

设计表：

CREATE TABLE `ts_order` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `order_no` varchar(50) NOT NULL COMMENT '订单号',
  `receiver_name` varchar(50) NOT NULL COMMENT '收货人姓名',
  `receiver_phone` varchar(50) NOT NULL COMMENT '收货人手机号',
  `receiver_address` varchar(50) NOT NULL COMMENT '收货人地址',
  `sender_name` varchar(100) NOT NULL COMMENT '发货人姓名',
  `sender_phone` varchar(100) NOT NULL COMMENT '发货人手机号',
  `sender_address` varchar(100) NOT NULL COMMENT '发货人地址',
  `ctime` datetime NOT NULL COMMENT '创建时间',
  `sender_phone_extend` varchar(130) DEFAULT NULL COMMENT '发货人手机号模糊查询',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='模糊查询-订单表'

BasicInfoProperties:

@ConfigurationProperties(prefix = "benbenpig.boot.basic-info")
@Component
@Data
public class BasicInfoProperties {
    /**
     * DES秘钥
     */
    private String desSecretKey;

    /**
     * AES秘钥
     */
    private String aesSecretKey;

    /**
     * Blowfish秘钥
     */
    private String blowfishSecretKey;

}

Service方法：

@Service
@RequiredArgsConstructor
public class OrderService extends ServiceImpl<OrderDao, Order> {
    private final BasicInfoProperties basicInfoProperties;
    
    @Transactional(rollbackFor = Exception.class)
    public void saveOrder(SaveOrderRequest request) {
        Order order = BeanUtil.toBean(request, Order.class);
        String originPhone = order.getSenderPhone();
        order.setSenderName(blowfishEncrypt(order.getSenderName()));
        order.setSenderPhone(blowfishEncrypt(originPhone));
        order.setSenderAddress(blowfishEncrypt(order.getSenderAddress()));
        order.setSenderPhoneExtend(blowfishQueryEncrypt(originPhone));
        save(order);
    }
    
    public Page<GetOrderResponse> getOrderList(GetOrderRequest request) {
        if (StringUtils.isNotBlank(request.getPhone()) && request.getPhone().length() >= 4) {
            request.setPhoneEncypt(blowfishQueryEncrypt(request.getPhone()));
        }
    
        Page<GetOrderResponse> page = baseMapper.getOrderList(request.buildQueryPage(), request);
        List<GetOrderResponse> records = page.getRecords();
        for (GetOrderResponse record : records) {
            record.setSenderName(blowfishDecrypt(record.getSenderName()));
            record.setSenderPhone(blowfishDecrypt(record.getSenderPhone()));
            record.setSenderAddress(blowfishDecrypt(record.getSenderAddress()));
        }
        return page;
    }
    
    
    /**
     * blowfish模糊查询加密
     *
     * @return
     */
    public String blowfishQueryEncrypt(String originStr) {
        if (StringUtils.isBlank(originStr)) {
            return originStr;
        }
        List<String> subStrList = Lists.newArrayList();
        int length = originStr.length();
        for (int i = 0; i < length - 3; i  ) {
            String substring = originStr.substring(i, i   4);
            subStrList.add(blowfishEncrypt(substring));
        }
        return subStrList.stream().collect(Collectors.joining(""));
    }
    
    /**
     * blowfish加密
     *
     * @return
     */
    private String blowfishEncrypt(String originStr) {
        if (StringUtils.isBlank(originStr)) {
            return originStr;
        }
        String desSecretKey = basicInfoProperties.getBlowfishSecretKey();
        String encrypt = BlowfishUtil.encrypt(originStr, desSecretKey);
        return encrypt;
    }
    
    /**
     * blowfish解密
     *
     * @return
     */
    private String blowfishDecrypt(String encryptStr) {
        if (StringUtils.isBlank(encryptStr)) {
            return encryptStr;
        }
        String desSecretKey = basicInfoProperties.getBlowfishSecretKey();
        String encrypt = BlowfishUtil.decrypt(encryptStr, desSecretKey);
        return encrypt;
    }
}

工具类：

public class BlowfishUtil {
    @SneakyThrows
    public static String encrypt(String value, String secretKeyStr) {
        // 加密算法，这里的值是“Blowfish”
        String algorithm = CodeAlgorithmDemoEnum.BLOWFISH.getAlgorithm();
        ;
        // 转换模式,这里的值是“Blowfish”
        String transformation = CodeAlgorithmDemoEnum.BLOWFISH.getTransformation();
        // --- 生成秘钥 ---
        SecretKeySpec secretKeySpec = generateNormalAlgorithmKeyByExistKey(CodeAlgorithmDemoEnum.BLOWFISH.getAlgorithm(),
                secretKeyStr);

        // 实例化密码对象
        Cipher cipher = Cipher.getInstance(transformation);
        // 设置模式（ENCRYPT_MODE：加密模式；DECRYPT_MODE：解密模式）和指定秘钥
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        // 加密
        byte[] encrypt = cipher.doFinal(value.getBytes());
        System.out.printf("%s加密结果：%s \n", algorithm, Base64.getEncoder().encodeToString(encrypt));
        System.out.printf("%s加密结果(Url不定长)：%s \n", algorithm, Base64.getUrlEncoder().encodeToString(encrypt));
        return Base64.getUrlEncoder().encodeToString(encrypt);
    }

    @SneakyThrows
    public static String decrypt(String value, String secretKeyStr) {
        // 加密算法,这里的值是“Blowfish”
        String algorithm = CodeAlgorithmDemoEnum.BLOWFISH.getAlgorithm();
        ;
        // 转换模式,这里的值是“Blowfish”
        String transformation = CodeAlgorithmDemoEnum.BLOWFISH.getTransformation();
        // --- 生成秘钥 ---
        SecretKeySpec secretKeySpec = generateNormalAlgorithmKeyByExistKey(CodeAlgorithmDemoEnum.BLOWFISH.getAlgorithm(),
                secretKeyStr);
        // 实例化密码对象
        Cipher cipher = Cipher.getInstance(transformation);
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] encrypt = Base64.getUrlDecoder().decode(value);
        byte[] decrypt = cipher.doFinal(encrypt);
        return new String(decrypt);
    }

    // --- 生成秘钥 ---
    @SneakyThrows
    public static SecretKeySpec generateNormalAlgorithmKey() {
        String algorithm = CodeAlgorithmDemoEnum.BLOWFISH.getAlgorithm();
        Integer testLength = CodeAlgorithmDemoEnum.BLOWFISH.getTestLength();

        // 实例化秘钥生成器
        KeyGenerator keyGenerator = KeyGenerator.getInstance(algorithm);
        // 初始化秘钥长度
        keyGenerator.init(testLength);
        // 生成秘钥
        SecretKey secretKey = keyGenerator.generateKey();
        // 生成秘钥材料
        SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getEncoded(), algorithm);
        System.out.printf("%s秘钥：%s \n", algorithm, Base64.getEncoder().encodeToString(secretKey.getEncoded()));
        System.out.printf("%s秘钥(Url不定长)：%s \n", algorithm, Base64.getUrlEncoder().encodeToString(secretKey.getEncoded()));
        return secretKeySpec;
    }

    // --- 基于已有秘钥字符串生成秘钥 ---
    @SneakyThrows
    public static SecretKeySpec generateNormalAlgorithmKeyByExistKey(String algorithm, String secretKeyStr) {
        // 还原秘钥
        SecretKeySpec desSecretKey = new SecretKeySpec(Base64.getUrlDecoder().decode(secretKeyStr), algorithm);
        System.out.printf("%s秘钥：%s \n", algorithm, Base64.getEncoder().encodeToString(desSecretKey.getEncoded()));
        System.out.printf("%s秘钥（URL不定长）：%s \n", algorithm, Base64.getUrlEncoder().encodeToString(desSecretKey.getEncoded()));
        return desSecretKey;
    }
}

Mapper文件：

<select id="getOrderList" resultType="com.zby.web.controller.response.GetOrderResponse">
    select to2.* from mybatis.ts_order to2
    <where>
        <if test="request.name != null and request.name !=''">
            and to2.sender_name like concat('%',#{request.name},'%')
        </if>
        <if test="request.address != null and request.address !=''">
            and to2.sender_address like concat('%',#{request.address},'%')
        </if>
        <!--这里使用专用的模糊查询字段-->
        <if test="request.phoneEncypt != null and request.phoneEncypt !=''">
            and to2.sender_phone_extend like concat('%',#{request.phoneEncypt},'%')
        </if>
    </where>
</select>

配置文件：
BasicInfoProperties 是映射application.yml的某个配置
配置里面我放了一个固定的blowfish秘钥

moxing:
  boot:
    basic-info:
      des-secret-key: Jexbbajs6m4=
      aes-secret-key: pwsNcrh21Rx3nRCAatSQbji45cIDCujDYpWxLfDQJeA=
      blowfish-secret-key: 3mCOvshidAxioaEd_LFTxQ==

效果演示：
我使用Apifox工具，造了几条数据

{
    "id": 15,
    "orderNo": "enim Excepteur",
    "receiverName": "现格表进",
    "receiverPhone": "18656758863",
    "receiverAddress": "澳门特别行政区石嘴山市阳谷县",
    "senderName": "式运位那月增",
    "senderPhone": "19862775573",
    "senderAddress": "台湾新乡市靖宇县",
    "ctime": "2022-12-08T15:07:24"
},
{
    "id": 16,
    "orderNo": "velit",
    "receiverName": "么合易子段",
    "receiverPhone": "18155850982",
    "receiverAddress": "河北省九龙其它区",
    "senderName": "高质事",
    "senderPhone": "18694314255",
    "senderAddress": "海南省张家界市双辽市",
    "ctime": "2022-12-08T15:08:03"
},
....

接下来我对其中一个进行模糊查询，例如19862775573这个手机号，我输入277557，调用getOrderList方法查询

个人理解

上面方法2的无法用索引优化，虽然这里like '%text%' ，通过explain也无法使用，但是可以优化成like 'text%'，至少不用mysql函数了。
但是，支持模糊查询后的密文比原来不支持模糊查询的密文要长几倍以上，而且修改模糊查询的成本比较大，检索串需要4个字符以上才可以查询。
所以这种模糊查询的方式适用长度较小且敏感的字符串。例如手机号，地址，订单号

总结

实践尝试了三个方法，最后一个方法对于我来说还是可以接受的，不过更高级的做法目前我还是理解不了，这些做法涉及到了算法领域,系统领域的知识，我也不是算法领域的人才，所以我留到以后有机会再补充。

这篇好文章是转载于：学新通技术网