Python实现Paillier同态加密算法

- - Python实现Paillier同态加密算法的博客
  - - 引言
    - Paillier加密算法的工作原理
    - [Python 面向对象实现 Paillier 加密算法](#Python 面向对象实现 Paillier 加密算法)
    - 代码解析
    - 示例场景：银行对账户余额的隐私保护
    - 总结

Python实现Paillier同态加密算法的博客

引言

Paillier加密算法 是由Pascal Paillier在1999年提出的一种基于计算复杂性的概率性加密算法。它是一种同态加密算法，具有加法同态性，这意味着两个密文相乘的结果解密后等于两个明文相加的结果。Paillier加密算法在隐私保护、数据安全和云计算中应用广泛。本文将详细介绍Paillier加密算法的原理，并使用Python以面向对象的方式实现其加密和解密操作，最后结合一个场景演示其应用。

Paillier加密算法的工作原理

Paillier加密系统依赖于大整数的难题，其安全性基于分解大整数的困难性。算法主要由三个部分组成：密钥生成、加密和解密。

密钥生成：
- 选择两个大素数 p p p和 q q q，计算 n = p × q n = p \times q n=p×q 和 λ = lcm ( p − 1 , q − 1 ) \lambda = \text{lcm}(p-1, q-1) λ=lcm(p−1,q−1)，其中 lcm \text{lcm} lcm 是最小公倍数。
- 选择一个随机整数 g g g，满足 g ∈ Z n 2 ∗ g \in \mathbb{Z}^*_{n^2} g∈Zn2∗。
- 计算 μ = ( L ( g λ m o d n 2 ) ) − 1 m o d n \mu = (\text{L}(g^\lambda \mod n^2))^{-1} \mod n μ=(L(gλmodn2))−1modn，其中 L ( u ) = u − 1 n \text{L}(u) = \frac{u - 1}{n} L(u)=nu−1。
- 公钥为 ( n , g ) (n, g) (n,g)，私钥为 ( λ , μ ) (\lambda, \mu) (λ,μ)。
加密过程：
- 选择要加密的明文消息 m m m，满足 m ∈ Z n m \in \mathbb{Z}_n m∈Zn。
- 随机选择一个整数 r r r，满足 r ∈ Z n ∗ r \in \mathbb{Z}^*_n r∈Zn∗。
- 计算密文 c = g m × r n m o d n 2 c = g^m \times r^n \mod n^2 c=gm×rnmodn2。
解密过程：
- 使用私钥 ( λ , μ ) (\lambda, \mu) (λ,μ)解密密文 c c c，计算：
  m = L ( c λ m o d n 2 ) × μ m o d n m = \text{L}(c^\lambda \mod n^2) \times \mu \mod n m=L(cλmodn2)×μmodn

Paillier算法的同态性质体现在加密后的密文相乘，解密后等于加密前的两个明文相加。即，给定两个明文 m 1 m_1 m1和 m 2 m_2 m2，其对应密文分别为 c 1 c_1 c1和 c 2 c_2 c2，那么：
c 1 × c 2 m o d n 2 = E ( m 1 + m 2 ) c_1 \times c_2 \mod n^2 = E(m_1 + m_2) c1×c2modn2=E(m1+m2)

Python 面向对象实现 Paillier 加密算法

接下来，我们将使用 Python 实现一个 Paillier 类，包括密钥生成、加密和解密的方法。

python 复制代码

import random
import math

class Paillier:
    def __init__(self, bit_length=512):
        """
        初始化 Paillier 实例，指定密钥长度。
        """
        self.bit_length = bit_length
        self.public_key = None
        self.private_key = None

    def gcd(self, a, b):
        """计算最大公约数"""
        while b != 0:
            a, b = b, a % b
        return a

    def lcm(self, a, b):
        """计算最小公倍数"""
        return abs(a * b) // self.gcd(a, b)

    def modinv(self, a, m):
        """计算模 m 的乘法逆元"""
        m0, x0, x1 = m, 0, 1
        while a > 1:
            q = a // m
            m, a = a % m, m
            x0, x1 = x1 - q * x0, x0
        if x1 < 0:
            x1 += m0
        return x1

    def generate_keys(self):
        """
        生成公钥和私钥。
        """
        # 生成两个大素数 p 和 q
        p = self.generate_prime_number(self.bit_length)
        q = self.generate_prime_number(self.bit_length)
        
        # 计算 n 和 λ
        n = p * q
        lambda_ = self.lcm(p-1, q-1)

        # 选择 g 和计算 μ
        g = n + 1
        mu = self.modinv(self.L(pow(g, lambda_, n**2), n), n)

        # 公钥和私钥
        self.public_key = (n, g)
        self.private_key = (lambda_, mu)
        return self.public_key, self.private_key

    def generate_prime_number(self, bit_length):
        """
        生成指定比特长度的素数。
        """
        while True:
            num = random.getrandbits(bit_length)
            if self.is_prime(num):
                return num

    def is_prime(self, n, k=5):
        """
        使用 Miller-Rabin 算法判断一个数是否为素数。
        """
        if n <= 1:
            return False
        if n <= 3:
            return True
        if n % 2 == 0:
            return False

        r, s = 0, n - 1
        while s % 2 == 0:
            r += 1
            s //= 2
        for _ in range(k):
            a = random.randint(2, n - 1)
            x = pow(a, s, n)
            if x == 1 or x == n - 1:
                continue
            for _ in range(r - 1):
                x = pow(x, 2, n)
                if x == n - 1:
                    break
            else:
                return False
        return True

    def L(self, u, n):
        """计算函数 L(u) = (u - 1) / n"""
        return (u - 1) // n

    def encrypt(self, plaintext):
        """
        使用公钥加密消息。
        :param plaintext: 明文消息 (整数形式)
        :return: 密文
        """
        n, g = self.public_key
        if not (0 <= plaintext < n):
            raise ValueError(f"明文必须在范围 0 到 {n-1} 之间。")

        # 随机选择 r ∈ Z*_n
        r = random.randint(1, n - 1)
        while self.gcd(r, n) != 1:
            r = random.randint(1, n - 1)

        # 计算密文 c = g^m * r^n mod n^2
        c = (pow(g, plaintext, n**2) * pow(r, n, n**2)) % (n**2)
        return c

    def decrypt(self, ciphertext):
        """
        使用私钥解密密文。
        :param ciphertext: 密文
        :return: 明文
        """
        n, g = self.public_key
        lambda_, mu = self.private_key

        # 计算 L(c^λ mod n^2) * μ mod n
        u = pow(ciphertext, lambda_, n**2)
        plaintext = (self.L(u, n) * mu) % n
        return plaintext

代码解析

类初始化 __init__ 方法：接收一个密钥长度参数，初始化 Paillier 加密系统。
密钥生成 generate_keys 方法 ：随机生成两个大素数 p p p 和 q q q，计算 n , λ , g , μ n, \lambda, g, \mu n,λ,g,μ，返回公钥 ( n , g ) (n, g) (n,g)和私钥 ( λ , μ ) (\lambda, \mu) (λ,μ)。
加密 encrypt 方法 ：使用公钥和随机数 r r r对明文进行加密，生成密文。
解密 decrypt 方法：使用私钥对密文进行解密，恢复原始明文。

示例场景：银行对账户余额的隐私保护

假设一家银行想要对用户的账户余额进行加密，以保护其隐私。银行使用Paillier加密算法将每个用户的余额加密存储，并且在不解密数据的情况下，可以对所有用户的余额进行同态加法操作，以计算总余额。