量子密码学 | 格密码（Lattice-based）入门 —— 附py代码

原创已于 2025-06-13 16:13:13 修改 · 1k 阅读

3 GEO检测

于 2025-06-13 13:48:59 首次发布

量子密码学专栏收录该内容

14 篇文章 ¥79.90 ¥99.00

订阅专栏

Lattice-based cryptography （基于晶格的密码学），是密码学领域中一个前沿的研究方向，它为量子计算时代的安全问题提供了潜在的解决方案。基于格的密码学与标准密码系统不同，它基于几何格所引发问题的计算复杂性，而非数论假设。

基于格的密码学中的格是由一组基向量在 n 维空间中形成的一系列点的集合。这些点可以用仅含整数系数的基向量线性组合来表示。一个简单的例子是在二维空间中由两个不共线的向量生成的点的排列。

基于格的加密的安全性取决于与格相关的特定挑战的计算难度。其中一个特别值得注意的问题是：给定一个格的基向量，找到距离原点最近的格点。在这一类别中，有最小向量问题（SVP），其旨在寻找格内最小的非零向量。SVP 即使对于量子计算机来说也是具有挑战性的（在计算上）。

格（Lattice）：

数学定义：L = {Σx_i·b_i | x_i ∈ Z}，其中 {b_i} 是基向量

在LWE中，格由矩阵A的列向量张成

困难问题：

最短向量问题（SVP）：在格中找到最短非零向量

最近向量问题（CVP）：在格中找到最接近给定点的向量

LWE问题：区分 (A, A·s + e) 和随机 (A, u)

实际应用：

后量子密码学标准（如NIST PQC标准中的Kyber、Dilithium）

全同态加密（Fully Homomorphic Encryption）

基于格的密码系统的安全性取决于某些格问题的难度。

最短向量问题（SVP）。给定一个格，目标是在该格中找到最短的非零向量。此问题的难度对于确保许多基于格的密码系统的安全性至关重要。该问题在随机化归约下是 NP 难的。
最近向量问题（CVP）。给定一个格和一个不一定在格中的目标向量，目标是找到距离目标向量最近的格点。此问题同样属于 NP 难问题，并且是多种加密协议的基础。
有界距离解码（BDD）。给定一个格和一个接近某个格点的目标向量，找出该格点。某些加密方案的安全性取决于 BDD 的难度。
带错误学习（LWE）。由奥德·雷格夫提出，LWE 是一个涉及求解受噪声干扰的线性方程组的问题。

基于格的密码学的优势

• 抵抗量子攻击。基于格的密码学的主要优势在于其对量子攻击的抵抗力。像 RSA 和 ECC 这样的传统密码系统容易受到肖尔算法的攻击，量子计算机可以利用该算法高效地破解这些系统。然而，目前还没有已知的高效量子算法能够解决基于格的算法所依赖的难题。

• 高效性和通用性。基于格的算法通常涉及简单的算术运算，这比其他形式的密码学所需的复杂运算更高效。此外，基于格的系统具有通用性，支持包括加密、数字签名和全同态加密（FHE）在内的多种密码学功能。

• 安全性归约。基于格的方案通常具有从最坏情况到平均情况的安全性归约。这意味着破解基于格的密码学问题的平均实例与解决其中最难的问题一样困难。例如，提供强有力的安全保障。

应用与未来潜力

• 后量子密码学。随着量子计算威胁日益迫近，基于格的密码学是保护通信免受量子攻击的领先候选方案。其能够以最小的干扰集成到现有基础设施中的潜力尤其具有吸引力。

• 安全投票系统。基于格的密码学的特性使其适用于安全的电子投票系统，在这种系统中，选民隐私和选票完整性至关重要。

• 云安全。基于格的方案能够实现像全同态加密（FHE）这样的安全计算协议，允许在不解密数据的情况下对其进行计算。这对于云计算尤其有用，在这种环境中，敏感数据即使在共享环境中也能安全处理。

基于格的密码学为应对诸如量子计算等不断演变的技术威胁提供了强大、高效且面向未来的安全通信框架。其发展和融入全球安全系统很可能会成为未来几年的关键关注领域。世界正在为量子时代做准备，尽管在实施和接受方面仍存在挑战，但基于格的密码学的基本优势使其成为密码学武器库中的强大工具。

由于格密码涉及复杂的数学概念和运算，且完整的实现（如基于LWE的加密）代码量较大，这里我们实现一个简化的基于格密码的 Learning With Errors (LWE) 的加密方案示例（仅供参考）。

参数设置：选择模数q，维度n，错误分布（通常为离散高斯分布，但为简化我们使用有界均匀分布）。
密钥生成：生成私钥（一个向量）和公钥（一个矩阵和一个向量）。
加密：使用公钥加密一个比特（0或1）。
解密：使用私钥解密密文。

为了简化过程，我们使用小参数，并且错误分布采用均匀分布（实际中应使用高斯分布）。

n = 4 # 维度

q = 65537 # 模数（一个素数）

m = 8 # 公钥矩阵的行数（通常大于n）

错误分布：从[-B, B]中均匀采样，这里B取q//4（实际中错误应远小于q，且使用高斯分布）。

加密一个比特（0或1）时，我们将其编码为{0, q//2}，这样解密时如果误差小于q//4，则可以正确解密。

密钥生成：

私钥 s <- Z_q^n （一个n维向量，元素在[0, q-1]）

公钥 A <- Z_q^{m×n} （一个m×n的矩阵，元素在[0, q-1]）

e <- 错误分布^m （一个m维错误向量）

b = A·s + e (mod q)

公钥为 (A, b)

加密（加密消息比特m，取值为0或1）：

选择一个随机的二进制向量 x ∈ {0,1}^m

计算密文 c0 = x^T·A (mod q) （一个n维向量）

c1 = x^T·b + m * (q//2) (mod q) （一个数）

密文为 (c0, c1)

解密：

计算 d = c1 - c0·s (mod q)

如果d更接近0（模q意义下）则输出0，更接近q/2则输出1。具体判断：若d在区间[0, q/4)或[3q/4, q)内，则输出0；若在[q/4, 3q/4)内，则输出1。

注意：由于错误的存在，d的值会围绕m*(q//2) + 噪声。因此，我们通过判断d是否接近q//2来解密。

import numpy as np
from scipy.stats import uniform

class LWECryptosystem:
    def __init__(self, n=128, q=1024, alpha=0.05):
        """
        初始化LWE加密系统参数
        :param n: 安全参数（维度）
        :param q: 模数
        :param alpha: 错误分布参数（标准差 = alpha*q）
        """
        self.n = n
        self.q = q
        self.alpha = alpha
        
        # 生成公钥和私钥
        self.private_key = self._generate_private_key()
        self.public_key = self._generate_public_key()
    
    def _generate_private_key(self):
        """生成私钥：从{0,1}中均匀随机选择的向量"""
        return np.random.randint(0, 2, size=self.n)
    
    def _generate_public_key(self):
        """生成公钥：(A, b = A·s + e)"""
        # 随机矩阵 A ∈ Z_q^{n×n}
        A = np.random.randint(0, self.q, size=(self.n, self.n))
        
        # 错误向量 e ~ 离散高斯分布（简化版：均匀分布）
        e = np.array([int(self.alpha * self.q * (2 * uniform.rvs() - 1)) 
                      for _ in range(self.n)])
        
        # 计算 b = A·s + e mod q
        b = (A @ self.private_key + e) % self.q
        
        return (A, b)
    
    def encrypt(self, bit):
        """
        加密一个比特 (0或1)
        :return: 密文 (u, v)
        """
        if bit not in [0, 1]:
            raise ValueError("只能加密0或1")
            
        # 随机选择向量 r ∈ {0,1}^n
        r = np.random.randint(0, 2, size=self.n)
        A, b = self.public_key
        
        # 计算 u = A^T·r mod q
        u = (A.T @ r) % self.q
        
        # 计算 v = b^T·r + bit * floor(q/2) mod q
        v = (b @ r + bit * (self.q // 2)) % self.q
        
        return (u, v)
    
    def decrypt(self, ciphertext):
        """解密密文"""
        u, v = ciphertext
        
        # 计算 w = v - s^T·u mod q
        w = (v - self.private_key @ u) % self.q
        
        # 判断w接近0还是q/2
        threshold = self.q // 4
        if w < threshold or w > (self.q - threshold):
            return 0
        else:
            return 1

# 示例测试
if __name__ == "__main__":
    print("创建LWE加密系统...")
    lwe = LWECryptosystem(n=10, q=1024)  # 简化参数便于演示
    
    print(f"私钥 (s): {lwe.private_key}")
    A, b = lwe.public_key
    print(f"公钥矩阵 A (部分): \n{A[:2, :5]}...")
    print(f"公钥向量 b (部分): {b[:5]}...")
    
    # 加密0和1
    plain_bit0 = 0
    cipher0 = lwe.encrypt(plain_bit0)
    print(f"\n加密 {plain_bit0} → 密文 (u, v):")
    print(f"u: {cipher0[0][:5]}...")
    print(f"v: {cipher0[1]}")
    
    plain_bit1 = 1
    cipher1 = lwe.encrypt(plain_bit1)
    print(f"\n加密 {plain_bit1} → 密文 (u, v):")
    print(f"u: {cipher1[0][:5]}...")
    print(f"v: {cipher1[1]}")
    
    # 解密
    decrypted0 = lwe.decrypt(cipher0)
    decrypted1 = lwe.decrypt(cipher1)
    
    print(f"\n解密结果: {decrypted0} (应为 {plain_bit0})")
    print(f"解密结果: {decrypted1} (应为 {plain_bit1})")
    
    # 错误率测试
    num_tests = 100
    errors = 0
    print(f"\n运行 {num_tests} 次加密/解密测试...")
    for _ in range(num_tests):
        bit = np.random.randint(0, 2)
        cipher = lwe.encrypt(bit)
        decrypted = lwe.decrypt(cipher)
        if decrypted != bit:
            errors += 1
    
    print(f"错误率: {errors/num_tests*100:.2f}%")