可搜索加密：加密数据的模糊检索方案

-- 加密前,模糊查询很自然
SELECT * FROM users WHERE name LIKE '%张%';

-- 加密后,name 字段变成了 'a3f8b2c1d4e5...',LIKE 完全失效
SELECT * FROM users WHERE name LIKE '%a3f8%';  -- 这搜的是密文,不是张三

/**
 * 桶索引方案 - 核心思路
 * 关键词通过 HMAC 映射到桶ID,查询时重新计算桶ID即可定位
 */
public class BucketIndex {

    private final SecretKey hmacKey; // HMAC 密钥

    public BucketIndex(SecretKey hmacKey) {
        this.hmacKey = hmacKey;
    }

    /**
     * 为一条记录构建索引
     * 将关键词分词后,每个词生成一个桶标记
     */
    public Map<String, Set<Long>> buildIndex(String plaintext, long recordId) {
        Map<String, Set<Long>> index = new HashMap<>();
        // 实际场景中会用分词器,这里简化为逐字分词
        for (int i = 0; i < plaintext.length(); i++) {
            String keyword = String.valueOf(plaintext.charAt(i));
            String bucketTag = hmac(keyword); // 桶标记 = HMAC(关键词, 密钥)
            index.computeIfAbsent(bucketTag, k -> new HashSet<>()).add(recordId);
        }
        return index;
    }

    /**
     * 查询:计算关键词的桶标记,匹配索引
     */
    public Set<Long> search(String keyword) {
        String bucketTag = hmac(keyword);
        // 用 bucketTag 去索引表查找,返回记录ID集合
        return indexStore.getOrDefault(bucketTag, Collections.emptySet());
    }

    private String hmac(String data) {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(hmacKey);
        return Hex.encodeHexString(mac.doFinal(data.getBytes(StandardCharsets.UTF_8)));
    }
}

/**
 * 布隆过滤器 + AES 加密索引方案
 */
public class BloomFilterIndex {

    private final AESUtil aes;
    private final int expectedInsertions;
    private final double fpp; // 误判率 (false positive probability)

    public BloomFilterIndex(AESUtil aes, int expectedInsertions, double fpp) {
        this.aes = aes;
        this.expectedInsertions = expectedInsertions;
        this.fpp = fpp;
    }

    /**
     * 为一条记录构建布隆过滤器索引
     * 对明文进行 n-gram 分词,加密后插入布隆过滤器
     */
    public BloomFilter<String> buildIndex(String plaintext) {
        BloomFilter<String> bf = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8),
            expectedInsertions, fpp);

        // n-gram 分词:支持子串匹配
        for (int n = 1; n <= Math.min(plaintext.length(), 4); n++) {
            for (int i = 0; i <= plaintext.length() - n; i++) {
                String gram = plaintext.substring(i, i + n);
                String encrypted = aes.encrypt(gram);
                bf.put(encrypted);
            }
        }
        return bf;
    }

    /**
     * 查询:对搜索词加密后,在布隆过滤器中判断
     * 返回 true 表示"可能存在匹配"(需要二次确认)
     */
    public boolean mightContain(BloomFilter<String> bf, String keyword) {
        String encrypted = aes.encrypt(keyword);
        return bf.mightContain(encrypted);
    }
}

/**
 * 格式保留加密方案 (基于 FF1 算法,NIST SP 800-38G)
 * 需要 Bouncy Castle 库;下面是示意代码,生产环境要按算法 radix/domain 正确编码输入
 */
public class FPEIndex {

    private final FF3Engine ff3;
    private final byte[] key;
    private final byte[] tweak;

    public FPEIndex(byte[] key, byte[] tweak) {
        this.ff3 = new FF3Engine();
        this.key = key;
        this.tweak = tweak;
    }

    /**
     * FPE 加密:保留原始格式
     * 数字加密后还是数字,字母加密后还是字母
     */
    public String encrypt(String plaintext) {
        // FF1/FF3 要求输入在特定字符集内
        // 对于中文场景,通常先映射为 Unicode 码点再做 FPE
        ff3.init(true, new KeyParameter(key), tweak);
        byte[] input = plaintext.getBytes(StandardCharsets.UTF_8);
        byte[] output = new byte[input.length];
        ff3.processBlock(input, 0, input.length, output, 0);
        return new String(output, StandardCharsets.UTF_8);
    }

    /**
     * FPE 解密
     */
    public String decrypt(String ciphertext) {
        ff3.init(false, new KeyParameter(key), tweak);
        byte[] input = ciphertext.getBytes(StandardCharsets.UTF_8);
        byte[] output = new byte[input.length];
        ff3.processBlock(input, 0, input.length, output, 0);
        return new String(output, StandardCharsets.UTF_8);
    }

    /**
     * 精确查询:对搜索词做 FPE 加密,然后用 = 匹配
     * FPE 在固定 tweak 下是确定性的,同明文 → 同密文,也会泄露相等关系
     */
    // 返回加密后的关键词，由调用方用参数化查询（PreparedStatement ?）代入
    public String encryptForQuery(String keyword) {
        return encrypt(keyword);
    }
}

/**
 * 多长度 n-gram 分词器
 * 同时生成多种窗口大小的分词,支持不同长度的搜索词
 */
public class MultiGramTokenizer {

    private final int[] windowSizes; // 如 {1, 2, 3}

    public MultiGramTokenizer(int... windowSizes) {
        this.windowSizes = windowSizes;
    }

    /**
     * 生成所有长度的 n-gram
     */
    public List<String> tokenize(String plaintext) {
        List<String> tokens = new ArrayList<>();
        for (int q : windowSizes) {
            for (int i = 0; i <= plaintext.length() - q; i++) {
                tokens.add(plaintext.substring(i, i + q));
            }
        }
        return tokens;
    }

    /**
     * 计算总分词数量
     */
    public int tokenCount(int textLength) {
        int count = 0;
        for (int q : windowSizes) {
            count += Math.max(0, textLength - q + 1);
        }
        return count;
    }
}

/**
 * 基于编辑距离的模糊关键词集生成器
 *
 * 原理:为每个关键词预生成编辑距离 ≤ d 的所有变体
 * 查询时对搜索词做同样的加密,匹配任一变体即命中
 *
 * 论文: Jin Li et al., "Fuzzy Keyword Search over Encrypted Data in Cloud Computing",
 *       INFOCOM 2010
 */
public class FuzzyKeywordGenerator {

    /**
     * 生成编辑距离 ≤ maxDistance 的模糊关键词集
     *
     * @param keyword 原始关键词
     * @param maxDistance 最大编辑距离(通常取 1 或 2)
     * @return 模糊关键词集合(不含原始关键词本身)
     */
    public Set<String> generateFuzzySet(String keyword, int maxDistance) {
        Set<String> result = new TreeSet<>();
        generateEdits(keyword, maxDistance, result);
        result.remove(keyword); // 不含自身
        return result;
    }

    /**
     * 递归生成编辑操作
     */
    private void generateEdits(String word, int distance, Set<String> result) {
        if (distance == 0) return;

        // 1. 删除:去掉一个字符
        for (int i = 0; i < word.length(); i++) {
            String deleted = word.substring(0, i) + word.substring(i + 1);
            if (!deleted.isEmpty()) {
                result.add(deleted);
                generateEdits(deleted, distance - 1, result);
            }
        }

        // 2. 替换:替换一个字符(用占位符表示"任意字符")
        for (int i = 0; i < word.length(); i++) {
            String replaced = word.substring(0, i) + "*" + word.substring(i + 1);
            result.add(replaced);
            generateEdits(replaced, distance - 1, result);
        }

        // 3. 插入:在任意位置插入一个字符(用占位符表示)
        for (int i = 0; i <= word.length(); i++) {
            String inserted = word.substring(0, i) + "*" + word.substring(i);
            result.add(inserted);
            generateEdits(inserted, distance - 1, result);
        }
    }

    /**
     * 计算模糊关键词集的大小估算
     * 对长度为 n 的关键词、编辑距离 d:
     * |FuzzySet| ≈ (2n + 1) × d × |字符集|
     *
     * 中文场景:|字符集| ≈ 3500(常用汉字)
     * "张三"(n=2, d=1) → 约 3500 × 5 = 17,500 个变体
     */
    public long estimateSetSize(int keywordLength, int maxDistance, int charsetSize) {
        long size = 0;
        for (int d = 1; d <= maxDistance; d++) {
            size += (long) Math.pow(2 * keywordLength + 1, d) * charsetSize;
        }
        return size;
    }
}

/**
 * 基于 LSH + 布隆过滤器的模糊搜索
 *
 * 论文: Bing Wang et al., "MFSE: Multi-Keyword Fuzzy Search over
 *       Encrypted Data in Cloud", TrustCom 2014
 *
 * 核心思路:
 * 1. 对明文做 minhash 签名(LSH 的一种实现)
 * 2. 将签名存入布隆过滤器
 * 3. 查询时对搜索词做同样的 minhash,在 BF 中判断
 * 4. 相似文本的 minhash 签名大概率相同 → 支持模糊匹配
 */
public class LSHFuzzySearch {

    private final int numHashFunctions; // 哈希函数数量
    private final int bfSize;           // 布隆过滤器大小

    public LSHFuzzySearch(int numHashFunctions, int bfSize) {
        this.numHashFunctions = numHashFunctions;
        this.bfSize = bfSize;
    }

    /**
     * 为文本生成 MinHash 签名
     * 将文本转为 n-gram 集合,对每个 n-gram 计算多个哈希,取最小值
     */
    public int[] minHashSignature(String text, int gramSize) {
        int[] signature = new int[numHashFunctions];
        Arrays.fill(signature, Integer.MAX_VALUE);

        // 生成 n-gram 集合
        for (int i = 0; i <= text.length() - gramSize; i++) {
            String gram = text.substring(i, i + gramSize);
            int hash = gram.hashCode();

            // 对每个哈希函数,取最小值
            for (int j = 0; j < numHashFunctions; j++) {
                int h = hash ^ (j * 0x5bd1e995); // 不同的哈希种子
                signature[j] = Math.min(signature[j], h);
            }
        }
        return signature;
    }

    /**
     * 计算两个签名的 Jaccard 相似度估计
     */
    public double estimateSimilarity(int[] sig1, int[] sig2) {
        int match = 0;
        for (int i = 0; i < numHashFunctions; i++) {
            if (sig1[i] == sig2[i]) match++;
        }
        return (double) match / numHashFunctions;
    }

    /**
     * 将签名编码后存入布隆过滤器
     */
    public BloomFilter<String> buildBF(int[] signature) {
        BloomFilter<String> bf = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8), bfSize, 0.01);
        for (int i = 0; i < signature.length; i++) {
            // 将签名的每个分量编码为字符串后插入 BF
            bf.put("sig_" + i + "_" + signature[i]);
        }
        return bf;
    }

    /**
     * 判断两个文本是否可能相似
     */
    public boolean mightBeSimilar(
            BloomFilter<String> bf1, BloomFilter<String> bf2, double threshold) {
        // 简化判断:计算两个 BF 中相同签名分量的比例
        int hit = 0;
        for (int i = 0; i < numHashFunctions; i++) {
            // 检查两个 BF 是否都包含第 i 个签名分量
            String key = "sig_" + i + "_";
            // 注意:实际实现需要从构建时保存的签名中取值
            // 这里仅为示意,生产环境请用 MinHash 签名直接比较
            hit++; // 简化处理:假设签名已保存,逐位比较
        }
        return (double) hit / numHashFunctions >= threshold;
    }
}

/**
 * 电商平台式分词加密索引
 * 淘宝/拼多多/京东实际使用的方案
 */
public class NGramEncryptedIndex {

    private final AESUtil aes;
    private final int windowSize; // 滑动窗口大小

    public NGramEncryptedIndex(AESUtil aes, int windowSize) {
        this.aes = aes;
        this.windowSize = windowSize;
    }

    /**
     * 为一条记录生成加密分词索引
     * 将明文按 windowSize 字滑动分词,每个分词加密后存入索引
     */
    public List<String> buildEncryptedTokens(String plaintext) {
        List<String> tokens = new ArrayList<>();
        for (int i = 0; i <= plaintext.length() - windowSize; i++) {
            String gram = plaintext.substring(i, i + windowSize);
            tokens.add(aes.encrypt(gram));
        }
        return tokens;
    }

    /**
     * 查询:对搜索词加密后,在索引列中匹配
     * 支持搜索词长度 >= windowSize 的任意子串匹配
     */
    public List<String> buildQueryTokens(String keyword) {
        if (keyword.length() < windowSize) {
            throw new IllegalArgumentException(
                "搜索词长度不能小于分词窗口大小 " + windowSize);
        }
        // 对搜索词做同样的分词,生成所有可能的匹配 token
        List<String> tokens = new ArrayList<>();
        for (int i = 0; i <= keyword.length() - windowSize; i++) {
            tokens.add(aes.encrypt(keyword.substring(i, i + windowSize)));
        }
        return tokens;
    }

    /**
     * 构建 SQL 查询条件
     * 搜索词 "三丰" → WHERE enc_tokens LIKE '%enc("三丰")%'
     * 搜索词 "张三丰" → WHERE enc_tokens LIKE '%enc("三")%'
     *                    OR enc_tokens LIKE '%enc("三丰")%'
     */
    public String buildLikeClause(String keyword, String columnName) {
        List<String> tokens = buildQueryTokens(keyword);
        return tokens.stream()
            .map(t -> columnName + " LIKE '%" + t + "%'" )
            .collect(Collectors.joining(" OR "));
    }
}

/**
 * 前向安全的可搜索加密索引
 *
 * 核心设计:
 * 1. 使用"删除-重建"策略:新数据写入时,废弃旧索引,用新密钥重建
 * 2. 查询只用当前活跃索引,不涉及历史版本
 */
public class ForwardPrivateIndex {

    // 活跃索引版本号(每次重建递增)
    private volatile long currentVersion = 0;

    // 索引存储:version → (桶标记 → 记录ID集合)
    private final Map<Long, Map<String, Set<Long>>> indexVersions = new ConcurrentHashMap<>();

    // 密钥轮转:每个版本使用不同的 HMAC 密钥
    private final Map<Long, SecretKey> versionKeys = new ConcurrentHashMap<>();

    private final KeyGenerator keyGen;
    private final Map<Long, List<IndexEntry>> pendingInserts = new ConcurrentHashMap<>();

    public ForwardPrivateIndex() throws NoSuchAlgorithmException {
        this.keyGen = KeyGenerator.getInstance("HmacSHA256");
    }

    /**
     * 写入新记录
     *
     * 前向安全的关键:新数据不会影响旧版本索引
     * 收集一批写入后统一重建索引,避免频繁重建
     */
    public void insert(String keyword, long recordId) {
        long version = currentVersion;
        pendingInserts.computeIfAbsent(version, k -> new CopyOnWriteArrayList<>())
            .add(new IndexEntry(keyword, recordId));

        // 达到批量阈值时重建索引
        if (pendingInserts.get(version).size() >= 100) {
            rebuildIndex();
        }
    }

    /**
     * 删除记录
     *
     * 后向安全的关键:删除后重建索引,新索引不包含已删除记录
     */
    public void delete(long recordId) {
        // 标记删除,下次重建时排除
        deletedIds.add(recordId);
        rebuildIndex();
    }

    /**
     * 重建索引
     * 使用新密钥,只包含未删除的数据 + 新写入的数据
     */
    private synchronized void rebuildIndex() {
        long newVersion = currentVersion + 1;
        SecretKey newKey = keyGen.generateKey();

        // 从数据源重建(实际场景中从数据库全量扫描未删除记录)
        Map<String, Set<Long>> newIndex = new HashMap<>();

        // 1. 重新索引存量数据(排除已删除)
        for (IndexEntry entry : getActiveEntries()) {
            if (!deletedIds.contains(entry.recordId)) {
                String tag = hmac(entry.keyword, newKey);
                newIndex.computeIfAbsent(tag, k -> new HashSet<>())
                    .add(entry.recordId);
            }
        }

        // 2. 加入新写入的数据
        List<IndexEntry> pending = pendingInserts.getOrDefault(currentVersion,
            Collections.emptyList());
        for (IndexEntry entry : pending) {
            if (!deletedIds.contains(entry.recordId)) {
                String tag = hmac(entry.keyword, newKey);
                newIndex.computeIfAbsent(tag, k -> new HashSet<>())
                    .add(entry.recordId);
            }
        }

        // 3. 原子切换到新版本
        indexVersions.put(newVersion, newIndex);
        versionKeys.put(newVersion, newKey);
        currentVersion = newVersion;

        // 4. 清理旧版本(延迟清理,确保正在执行的查询完成)
        scheduleOldVersionCleanup(newVersion - 1);

        // 5. 清理待处理队列
        pendingInserts.remove(currentVersion - 1);
    }

    /**
     * 查询:只查当前活跃版本
     */
    public Set<Long> search(String keyword) {
        long version = currentVersion;
        SecretKey key = versionKeys.get(version);
        Map<String, Set<Long>> index = indexVersions.get(version);

        if (index == null || key == null) {
            return Collections.emptySet();
        }

        String tag = hmac(keyword, key);
        return index.getOrDefault(tag, Collections.emptySet());
    }

    private String hmac(String data, SecretKey key) {
        try {
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(key);
            return Hex.encodeHexString(mac.doFinal(
                data.getBytes(StandardCharsets.UTF_8)));
        } catch (Exception e) {
            throw new RuntimeException("HMAC 计算失败", e);
        }
    }

    // 辅助类
    private static class IndexEntry {
        final String keyword;
        final long recordId;
        IndexEntry(String keyword, long recordId) {
            this.keyword = keyword;
            this.recordId = recordId;
        }
    }
}

<dependencies>
    <!-- AES 由 JDK 内置提供( javax.crypto ),无需额外依赖 -->
    <!-- 如果其他模块需要 Bouncy Castle(如 FPE 的 FF3),可保留此依赖 -->
    <!--
    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.70</version>
    </dependency>
    -->
    <!-- Guava (布隆过滤器) -->
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>32.1.3-jre</version>
    </dependency>
</dependencies>

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;

/**
 * AES 对称加密工具(AES-128-CBC)
 * 用于加密关键词,生成布隆过滤器中的密文元素
 */
public class AESUtil {

    private static final String ALGORITHM = "AES/CBC/PKCS5Padding";
    private static final int IV_LENGTH = 16; // AES 块大小
    private final SecretKeySpec keySpec;
    private final SecureRandom secureRandom;

    /**
     * @param hexKey 16字节密钥的十六进制表示(32个字符),即 AES-128
     */
    public AESUtil(String hexKey) {
        byte[] keyBytes = hexStringToBytes(hexKey);
        this.keySpec = new SecretKeySpec(keyBytes, "AES");
        this.secureRandom = new SecureRandom();
    }

    /**
     * 加密:生成随机 IV,将 IV + 密文一起编码为 Base64
     * 格式: Base64(IV || ciphertext)
     */
    public String encrypt(String plaintext) {
        try {
            byte[] iv = new byte[IV_LENGTH];
            secureRandom.nextBytes(iv);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, keySpec, new IvParameterSpec(iv));
            byte[] encrypted = cipher.doFinal(plaintext.getBytes("UTF-8"));
            // IV 拼接密文,一起编码
            byte[] ivAndCiphertext = new byte[IV_LENGTH + encrypted.length];
            System.arraycopy(iv, 0, ivAndCiphertext, 0, IV_LENGTH);
            System.arraycopy(encrypted, 0, ivAndCiphertext, IV_LENGTH, encrypted.length);
            return Base64.getUrlEncoder().withoutPadding().encodeToString(ivAndCiphertext);
        } catch (Exception e) {
            throw new RuntimeException("AES 加密失败", e);
        }
    }

    /**
     * 解密:从 Base64 中提取 IV 和密文,解密后返回明文
     */
    public String decrypt(String ciphertext) {
        try {
            byte[] ivAndCiphertext = Base64.getUrlDecoder().decode(ciphertext);
            byte[] iv = new byte[IV_LENGTH];
            System.arraycopy(ivAndCiphertext, 0, iv, 0, IV_LENGTH);
            byte[] encrypted = new byte[ivAndCiphertext.length - IV_LENGTH];
            System.arraycopy(ivAndCiphertext, IV_LENGTH, encrypted, 0, encrypted.length);
            Cipher cipher = Cipher.getInstance(ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, keySpec, new IvParameterSpec(iv));
            byte[] decrypted = cipher.doFinal(encrypted);
            return new String(decrypted, "UTF-8");
        } catch (Exception e) {
            throw new RuntimeException("AES 解密失败", e);
        }
    }

    private static byte[] hexStringToBytes(String hex) {
        int len = hex.length();
        byte[] bytes = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            bytes[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4)
                + Character.digit(hex.charAt(i + 1), 16));
        }
        return bytes;
    }
}

import com.google.common.hash.BloomFilter;
import com.google.common.hash.Funnels;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 基于 AES + 布隆过滤器的可搜索加密引擎
 *
 * 功能:
 * - 支持中文子串模糊检索
 * - 支持索引的增删更新
 * - 查询结果需要二次解密确认(消除误判)
 */
public class SearchableEncryptionEngine {

    private final AESUtil aes;
    private final int bfExpectedInsertions;
    private final double bfFpp;

    // 主数据存储:recordId → 加密后的完整记录
    private final Map<Long, String> encryptedStore = new ConcurrentHashMap<>();

    // 布隆过滤器索引:recordId → BloomFilter
    private final Map<Long, BloomFilter<String>> bfIndex = new ConcurrentHashMap<>();

    // 记录元数据:recordId → 原始明文(实际生产中不保留,这里方便演示)
    private final Map<Long, String> plaintextStore = new ConcurrentHashMap<>();

    private long nextId = 1;

    /**
     * @param aesKey    AES 密钥(十六进制,16字节=AES-128)
     * @param expectedSize 预期记录数
     * @param fpp       布隆过滤器误判率
     */
    public SearchableEncryptionEngine(String aesKey, int expectedSize, double fpp) {
        this.aes = new AESUtil(aesKey);
        this.bfExpectedInsertions = expectedSize * 30; // 每条记录约30个n-gram
        this.bfFpp = fpp;
    }

    // ========== 写入 ==========

    /**
     * 插入一条记录
     * 1. AES 加密原始数据存入加密存储
     * 2. 对明文做 n-gram 分词 → AES 加密 → 写入布隆过滤器
     */
    public long insert(String plaintext) {
        long id = nextId++;

        // 1. 加密存储
        String encrypted = aes.encrypt(plaintext);
        encryptedStore.put(id, encrypted);

        // 2. 构建布隆过滤器索引
        BloomFilter<String> bf = BloomFilter.create(
            Funnels.stringFunnel(StandardCharsets.UTF_8),
            bfExpectedInsertions, bfFpp);

        // n-gram 分词(1到4字的子串)
        for (int n = 1; n <= Math.min(plaintext.length(), 4); n++) {
            for (int i = 0; i <= plaintext.length() - n; i++) {
                String gram = plaintext.substring(i, i + n);
                bf.put(aes.encrypt(gram));
            }
        }

        bfIndex.put(id, bf);
        plaintextStore.put(id, plaintext); // 仅用于演示,生产环境去掉

        return id;
    }

    // ========== 查询 ==========

    /**
     * 模糊查询
     * 1. 将搜索词 AES 加密
     * 2. 遍历所有记录的布隆过滤器,判断是否"可能存在"
     * 3. 命中的记录解密后做精确二次确认
     */
    public List<SearchResult> search(String keyword) {
        String encryptedKeyword = aes.encrypt(keyword);
        List<SearchResult> results = new ArrayList<>();

        for (Map.Entry<Long, BloomFilter<String>> entry : bfIndex.entrySet()) {
            long recordId = entry.getKey();
            BloomFilter<String> bf = entry.getValue();

            // 布隆过滤器快速判断
            if (!bf.mightContain(encryptedKeyword)) {
                continue; // 一定不包含,跳过
            }

            // 二次确认:解密后精确匹配(消除误判)
            String plaintext = plaintextStore.get(recordId);
            if (plaintext != null && plaintext.contains(keyword)) {
                results.add(new SearchResult(recordId, plaintext));
            }
        }

        return results;
    }

    // ========== 删除 ==========

    /**
     * 删除一条记录
     */
    public boolean delete(long recordId) {
        encryptedStore.remove(recordId);
        bfIndex.remove(recordId);
        plaintextStore.remove(recordId);
        return true;
    }

    // ========== 更新 ==========

    /**
     * 更新一条记录(删除旧索引 + 重新插入)
     */
    public long update(long recordId, String newPlaintext) {
        delete(recordId);
        return insert(newPlaintext);
    }

    // ========== 统计 ==========

    /**
     * 返回布隆过滤器索引的总内存占用估算(bytes)
     */
    public long estimateMemoryUsage() {
        if (bfIndex.isEmpty()) return 0;
        // Guava 布隆过滤器没有直接的 size(),用公式估算
        // optimalNumOfBits = -n * ln(p) / (ln(2)^2)
        double bits = -bfExpectedInsertions * Math.log(bfFpp) / (Math.log(2) * Math.log(2));
        return (long) (bits / 8) * bfIndex.size();
    }

    public int getRecordCount() {
        return bfIndex.size();
    }

    // ========== 结果类 ==========

    public static class SearchResult {
        public final long recordId;
        public final String plaintext;

        public SearchResult(long recordId, String plaintext) {
            this.recordId = recordId;
            this.plaintext = plaintext;
        }

        @Override
        public String toString() {
            return String.format("[ID=%d] %s", recordId, plaintext);
        }
    }
}

public class SearchableEncryptionDemo {

    public static void main(String[] args) {
        // 16字节 AES-128 密钥(实际场景从 KMS 获取)
        String aesKey = "0123456789abcdef0123456789abcdef";

        SearchableEncryptionEngine engine =
            new SearchableEncryptionEngine(aesKey, 10000, 0.01);

        System.out.println("=== 插入数据 ===");
        String[] names = {
            "张三丰", "张无忌", "李四光", "王五",
            "赵六", "张伟", "张小明", "李小龙"
        };

        for (String name : names) {
            long id = engine.insert(name);
            System.out.printf("  插入: %s → ID=%d%n", name, id);
        }

        System.out.println("\n=== 模糊查询 '张' ===");
        List<SearchableEncryptionEngine.SearchResult> results = engine.search("张");
        for (SearchableEncryptionEngine.SearchResult r : results) {
            System.out.println("  " + r);
        }

        System.out.println("\n=== 模糊查询 '小' ===");
        results = engine.search("小");
        for (SearchableEncryptionEngine.SearchResult r : results) {
            System.out.println("  " + r);
        }

        System.out.println("\n=== 模糊查询 '龙' ===");
        results = engine.search("龙");
        for (SearchableEncryptionEngine.SearchResult r : results) {
            System.out.println("  " + r);
        }

        System.out.println("\n=== 删除 '张无忌' (ID=2) ===");
        engine.delete(2);
        System.out.println("  删除后查询 '张':");
        results = engine.search("张");
        for (SearchableEncryptionEngine.SearchResult r : results) {
            System.out.println("  " + r);
        }

        System.out.println("\n=== 更新 '赵六' → '赵六六' (ID=6) ===");
        engine.update(6, "赵六六");
        System.out.println("  查询 '六':");
        results = engine.search("六");
        for (SearchableEncryptionEngine.SearchResult r : results) {
            System.out.println("  " + r);
        }

        System.out.printf("%n=== 索引统计 ===%n");
        System.out.printf("  记录数: %d%n", engine.getRecordCount());
        System.out.printf("  估算内存: %.2f KB%n", engine.estimateMemoryUsage() / 1024.0);
    }
}