格式保留加密、同态加密与零知识证明

FF1 结构（简化）：

输入：明文 X（radix 进制表示），密钥 K，Tweak T
  1. 将 X 拆成左右两半：A, B
  2. 10 轮 Feistel 迭代：
     for i = 0 to 9:
       C = A + F(K, T, i, B) mod radix^m
       A = B
       B = C
  3. 输出密文 = A || B

其中 F 是基于 AES 的伪随机函数
radix = 基数（数字=10，字母=26，etc.）

import org.bouncycastle.crypto.fpe.FPEFF1Engine;
import org.bouncycastle.crypto.fpe.FPEEngine;
import org.bouncycastle.crypto.params.FPEParameters;
import org.bouncycastle.crypto.params.KeyParameter;

/**
 * FF1 格式保留加密示例
 * 对数字字符串加密，结果仍是相同长度的数字字符串
 */
public class FpeExample {

    private static final int RADIX = 10; // 数字：0-9

    /**
     * FPE 加密数字字符串
     * @param plaintext 明文数字字符串（如 "13800001111"）
     * @param key AES 密钥（16/24/32 字节）
     * @param tweak 调柄（可用于区分不同字段）
     * @return 密文数字字符串（格式相同）
     */
    public static String encrypt(String plaintext, byte[] key, byte[] tweak) {
        FPEEngine engine = new FPEFF1Engine();
        engine.init(true, new FPEParameters(
            new KeyParameter(key), RADIX, tweak));

        // 将数字字符串转为 short 数组
        short[] input = toShortArray(plaintext);
        short[] output = new short[input.length];

        engine.processBlock(input, 0, input.length, output, 0);

        return fromShortArray(output);
    }

    /**
     * FPE 解密
     */
    public static String decrypt(String ciphertext, byte[] key, byte[] tweak) {
        FPEEngine engine = new FPEFF1Engine();
        engine.init(false, new FPEParameters(
            new KeyParameter(key), RADIX, tweak));

        short[] input = toShortArray(ciphertext);
        short[] output = new short[input.length];

        engine.processBlock(input, 0, input.length, output, 0);

        return fromShortArray(output);
    }

    private static short[] toShortArray(String digits) {
        short[] arr = new short[digits.length()];
        for (int i = 0; i < digits.length(); i++) {
            arr[i] = (short) (digits.charAt(i) - '0');
        }
        return arr;
    }

    private static String fromShortArray(short[] arr) {
        StringBuilder sb = new StringBuilder(arr.length);
        for (short s : arr) {
            sb.append((char) ('0' + s));
        }
        return sb.toString();
    }
}

普通流程：
  密文 → 解密 → 明文 → 计算 → 结果 → 加密 → 密文结果
  （计算方看到了明文 ❌）

同态加密：
  密文 → 直接在密文上计算 → 密文结果 → 解密 → 明文结果
  （计算方全程只看到密文 ✅）

数学表达：
  Enc(a) ⊕ Enc(b) = Enc(a + b)    -- 加法同态
  Enc(a) ⊗ Enc(b) = Enc(a × b)    -- 乘法同态

场景：多方工资求和，任何一方都不想暴露自己的工资

Alice 工资：10000 → Enc(10000)
Bob 工资：  15000 → Enc(15000)
Carol 工资：12000 → Enc(12000)

服务端计算（全程不解密）：
  Enc(10000) ⊕ Enc(15000) ⊕ Enc(12000) = Enc(37000)

只有拥有私钥的一方能解密得到总和 37000
没有人看到其他人的工资

/**
 * Paillier 同态加密示意
 * 生产环境推荐使用 java-paillier 库或 SEAL/OpenFHE
 */
public class PaillierDemo {

    // Paillier 密钥生成
    public static PaillierKeyPair generateKeyPair(int bitLength) {
        BigInteger p = BigInteger.probablePrime(bitLength / 2, new SecureRandom());
        BigInteger q = BigInteger.probablePrime(bitLength / 2, new SecureRandom());
        BigInteger n = p.multiply(q);
        BigInteger nSquared = n.multiply(n);
        BigInteger lambda = lcm(p.subtract(ONE), q.subtract(ONE));
        BigInteger g = n.add(ONE); // 简化选择 g = n+1
        BigInteger mu = lambda.modInverse(n); // L(g^lambda mod n^2)^-1 mod n

        return new PaillierKeyPair(
            new PaillierPublicKey(n, g),
            new PaillierPrivateKey(lambda, mu, n));
    }

    // 加密：Enc(m) = g^m * r^n mod n^2
    public static BigInteger encrypt(BigInteger m, PaillierPublicKey pub) {
        BigInteger r = randomCoprime(pub.n);
        BigInteger nSquared = pub.n.multiply(pub.n);
        return pub.g.modPow(m, nSquared)
            .multiply(r.modPow(pub.n, nSquared))
            .mod(nSquared);
    }

    // 同态加法：Enc(a) * Enc(b) mod n^2 = Enc(a+b)
    public static BigInteger add(BigInteger encA, BigInteger encB,
                                 PaillierPublicKey pub) {
        BigInteger nSquared = pub.n.multiply(pub.n);
        return encA.multiply(encB).mod(nSquared);
    }

    // 密文标量乘：Enc(a)^k mod n^2 = Enc(a*k)
    public static BigInteger scalarMultiply(BigInteger encA, BigInteger k,
                                            PaillierPublicKey pub) {
        BigInteger nSquared = pub.n.multiply(pub.n);
        return encA.modPow(k, nSquared);
    }

    // 解密：Dec(c) = L(c^lambda mod n^2) * mu mod n
    public static BigInteger decrypt(BigInteger c, PaillierPrivateKey priv) {
        BigInteger nSquared = priv.n.multiply(priv.n);
        BigInteger x = c.modPow(priv.lambda, nSquared);
        BigInteger l = x.subtract(ONE).divide(priv.n); // L函数
        return l.multiply(priv.mu).mod(priv.n);
    }
}

经典比喻——阿里巴巴洞穴：

  洞穴有两条路（A 和 B），中间有一扇密码门连通。
  证明者知道密码，验证者不知道。

  1. 证明者随机选一条路进去（验证者看不到选了哪条）
  2. 验证者喊："从 A 路出来！"（或 B）
  3. 如果证明者知道密码 → 无论要求哪条路都能出来
     如果证明者不知道密码 → 50% 概率出不来

  重复 20 次，每次都能正确出来 → 99.9999% 证明者知道密码
  但验证者全程没学到密码本身

场景：我知道一个 x 使得 SHA256(x) = H，但我不想告诉你 x 是什么

传统方式：
  把 x 给你，你自己算 SHA256(x) 看是不是等于 H
  → x 暴露了 ❌

零知识方式（简化思路）：
  1. 将 SHA256 电路化（转为算术电路）
  2. 我用 x 作为秘密输入，生成一个证明 π
  3. 你验证 π 对于公开输入 H 是否成立
  4. 验证通过 → 你确信我知道 x，但你不知道 x 是什么

# 概念示例（使用 snarkjs 风格的伪代码）
# 实际 ZKP 开发通常用 Circom/Rust/Go 框架

# 电路定义（Circom 风格）
"""
template HashPreimage() {
    signal private input preimage;  // 秘密输入
    signal input hash;              // 公开输入

    // 约束：SHA256(preimage) == hash
    component hasher = SHA256();
    hasher.in <== preimage;
    hash === hasher.out;
}
"""

# 证明者（知道 preimage）
proof = generate_proof(circuit, private_input=preimage, public_input=hash)

# 验证者（不知道 preimage）
is_valid = verify_proof(proof, public_input=hash)  # true/false

Shor 算法（1994）：
  量子计算机上可以在多项式时间内分解大整数、求解离散对数

影响：
  RSA    → 被破解（基于大整数分解）
  ECDSA  → 被破解（基于椭圆曲线离散对数）
  SM2    → 被破解（同上）
  AES    → 安全性减半（Grover 算法，AES-256 → 128 bit 安全）
  SHA    → 安全性减半（同上）

结论：
  非对称加密全军覆没，对称加密和哈希加倍密钥长度即可

当前（2024-2026）：
  - 新系统可以开始支持"混合模式"（经典 + 后量子双算法）
  - TLS 已支持混合密钥交换（X25519 + ML-KEM）
  - 不需要急着全面切换

中期（2027-2030）：
  - NIST 标准成熟，库和硬件支持完善
  - 高安全需求系统开始迁移

长期（2030+）：
  - 大规模量子计算机可能出现
  - 全面迁移到后量子算法