Fuzzy search trên cột phone_number đã mã hoá

Plaintext:  0912345678
AES-256:    3f8a2c1d9e...  (hoàn toàn khác, random)
LIKE '%9123%' → không match

phone = "0912345678"

Bước 1: Normalize (bỏ +84, dấu cách, ký tự lạ)
        → "0912345678"

Bước 2: Encrypt để lưu plaintext khi cần
        AES("0912345678") → [rác mã hoá]

Bước 3: Hash toàn bộ để tạo blind index
        HMAC(key="secret", data="0912345678") → "f3a8c1d2..."

Bước 4: Lưu cả hai vào DB
        phone_enc   = [rác mã hoá]   ← đọc plaintext khi cần
        phone_blind = "f3a8c1d2..."  ← dùng để search

ALTER TABLE users ADD COLUMN phone_blind VARCHAR(64);
CREATE INDEX idx_phone_blind ON users(phone_blind);

User tìm: "0912345678"

Bước 1: Hash input với CÙNG key
        HMAC(key="secret", data="0912345678") → "f3a8c1d2..."
                                                    ↑ giống hệt lúc insert!
Bước 2: Query thẳng
        SELECT * FROM users WHERE phone_blind = "f3a8c1d2..."

Bước 3: Trả về kết quả — không cần decrypt, không cần verify thêm ✓

phone  = "0912345678"  →  HMAC  →  "f3a8c1d2..."
search = "9123"        →  HMAC  →  "b7e2a9c1..."  ← hoàn toàn khác!

"0912345678"
→ ["091", "912", "123", "234", "345", "456", "567", "678"]

"9123" → ["912", "123"]

phone_trigram_index:
| user_id | trigram |
|---------|---------|
|   42    |  "091"  |  ← lộ mảnh số điện thoại
|   42    |  "912"  |  ← DBA/hacker ghép lại không khó
|   42    |  "123"  |

HMAC(key="secret", "091") → "a1b2c3..."
HMAC(key="secret", "912") → "a7f3c8..."   ← DB chỉ thấy thế này
HMAC(key="secret", "123") → "2e9b1f..."

phone = "0912345678"

Bước 1: Encrypt phone → lưu vào cột phone_enc

Bước 2: Tách trigrams
        → ["091", "912", "123", "234", "345", "456", "567", "678"]

Bước 3: Hash từng trigram
        HMAC("091") → "a1b2c3..."
        HMAC("912") → "a7f3c8..."
        HMAC("123") → "2e9b1f..."
        ...

Bước 4: Lưu vào bảng index phụ
        phone_trigram_index:
        | user_id=42 | "a1b2c3..." |
        | user_id=42 | "a7f3c8..." |
        | user_id=42 | "2e9b1f..." |
        | ...                      |

Bước 1: Tách query thành trigrams
        "9123" → ["912", "123"]

Bước 2: Hash với CÙNG key
        HMAC("912") → "a7f3c8..."   ← giống hệt lúc insert!
        HMAC("123") → "2e9b1f..."   ← giống hệt lúc insert!

Bước 3: Tìm trong bảng index
        SELECT user_id FROM phone_trigram_index
        WHERE trigram_hash IN ("a7f3c8...", "2e9b1f...")
        GROUP BY user_id
        HAVING COUNT >= 2      ← phải match CẢ 2 trigram
        → trả về user_id = 42

Bước 4: Decrypt phone của user 42
        → "0912345678"
        → verify: contains("9123") = TRUE ✓

CREATE TABLE users (
    id          BIGINT PRIMARY KEY,
    phone_enc   BYTEA NOT NULL,
    created_at  TIMESTAMP
);
 
CREATE TABLE phone_trigram_index (
    user_id      BIGINT REFERENCES users(id),
    trigram_hash VARCHAR(64) NOT NULL
);
 
CREATE INDEX idx_phone_trigram ON phone_trigram_index(trigram_hash);

@Service
public class PhoneEncryptionService {
 
    @Value("${encryption.phone.key}")
    private String aesKey;
 
    @Value("${encryption.phone.trigram-key}")
    private String trigramHmacKey;
 
    private static final String COLUMN_SALT = "phone_v1";
 
    public void saveUser(String phoneNumber, long userId) {
        String normalized = phoneNumber.replaceAll("[^0-9]", "");
 
        byte[] encrypted = aesEncrypt(normalized, aesKey);
        jdbcTemplate.update("INSERT INTO users(id, phone_enc) VALUES (?,?)",
            userId, encrypted);
 
        for (String trigram : generateTrigrams(normalized)) {
            String hash = hmacSha256(trigramHmacKey, trigram + COLUMN_SALT);
            jdbcTemplate.update(
                "INSERT INTO phone_trigram_index(user_id, trigram_hash) VALUES (?,?)",
                userId, hash);
        }
    }
 
    public List<User> searchByPhone(String query) {
        String normalized = query.replaceAll("[^0-9]", "");
        List<String> trigrams = generateTrigrams(normalized);
 
        List<String> hashes = trigrams.stream()
            .map(t -> hmacSha256(trigramHmacKey, t + COLUMN_SALT))
            .collect(toList());
 
        int minMatch = Math.max(1, trigrams.size() / 2);
        List<Long> candidateIds = jdbcTemplate.queryForList("""
            SELECT user_id FROM phone_trigram_index
            WHERE trigram_hash = ANY(?)
            GROUP BY user_id
            HAVING COUNT(DISTINCT trigram_hash) >= ?
            """, Long.class, hashes.toArray(), minMatch);
 
        // Decrypt và verify để loại false positives
        return candidateIds.stream()
            .map(id -> getUserById(id))
            .filter(user -> {
                String phone = aesDecrypt(user.getPhoneEnc(), aesKey);
                return phone.contains(normalized);
            })
            .collect(toList());
    }
 
    private List<String> generateTrigrams(String s) {
        List<String> result = new ArrayList<>();
        String padded = "  " + s + "  "; // padding để match prefix/suffix
        for (int i = 0; i <= padded.length() - 3; i++) {
            result.add(padded.substring(i, i + 3));
        }
        return result;
    }
}

SELECT u.id, u.phone_enc, u.name, u.created_at
FROM users u
JOIN phone_trigram_index pti ON u.id = pti.user_id
WHERE pti.trigram_hash IN ('hash_123')
  AND u.name ILIKE '%nam%'          -- LIKE bình thường vì name không encrypt
GROUP BY u.id, u.name, u.phone_enc, u.created_at
HAVING COUNT(DISTINCT pti.trigram_hash) >= 1
ORDER BY u.created_at DESC
LIMIT 10 OFFSET 0;

Muốn page 2 (OFFSET 10, LIMIT 10)
→ DB trả về 20 candidates từ trigram index
→ Decrypt verify → chỉ 13 cái thật sự match (7 là false positive bị loại)
→ Page 2 chỉ có 3 kết quả thay vì 10  ❌

// Page 1: không có cursor
SELECT ... WHERE created_at < NOW() ORDER BY created_at DESC LIMIT 50
→ decrypt verify → lấy 10 đầu đủ điều kiện
→ cursor = created_at của item thứ 10
 
// Page 2: truyền cursor
SELECT ... WHERE created_at < {cursor} ORDER BY created_at DESC LIMIT 50
→ decrypt verify → lấy 10 tiếp theo