Paillier

小嘿黑不嘿

于 2024-07-08 20:31:26 发布

阅读量310

点赞数 7

分类专栏：多方安全计算学习文章标签： python 密码学云计算网络安全

本文链接：https://blog.csdn.net/xiaoheihenheide/article/details/140278021

版权

多方安全计算学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Python实现Paillier同态加密算法

一、算法内容

算法加密过程和相关证明可以参考这两篇文档，结合起来看会很方便，内容有相互补充。
网址为：https://github.com/FederatedAI/DOC-CHN/blob/master/%E6%9C%89%E5%A5%96%E5%BE%81%E9%9B%86%E6%B4%BB%E5%8A%A8/%E6%95%99%E7%A8%8B%E7%B1%BB/Paillier%20Cryptosystem%E7%90%86%E8%AE%BA%E4%B8%8E%E5%AE%9E%E8%B7%B5.pdf
同态加密之Paillier算法-CSDN博客

二、算法实现及代码解释

import random
import gmpy2 #该库用于高精度算术计算和快速的数论算法，使‘gmpy’的改进版本，提供大量的数论函数，例如素数测试、最大公约数、最小公倍数、模算术等。

class Paillier: #定义Paillier类
    def __init__(self, bit_length=512): #定义构造方法，实例化时自动调用
        self.bit_length = bit_length  #bit_length为n的二进制位数，使用关键字参数指定，默认为512位。
        self.pub_key, self.priv_key = self.generate_keypair(bit_length) #使用generate_keypair()方法获得公钥和私钥

    def generate_keypair(self, bit_length):
        p = gmpy2.next_prime(random.getrandbits(bit_length // 2)) #这里保证p和q位数相同，均为n的一半，可以使得其他参数的求取更加方便，如lanbda_和mu，具体请参考文章开头提到的第一篇文档。
        q = gmpy2.next_prime(random.getrandbits(bit_length // 2))
        #使用random.getrandbits()函数得到指定二进制位数的随机数
        #使用next_prime()函数得到该随机整数之后的第一个素数
        n = p * q 
        nsquare = n * n  
        lambda_ = (p - 1) * (q - 1)
        g = n + 1
        mu = gmpy2.invert(lambda_, n) #求模n下lambda_的乘法逆元
        pub_key = (n, g)
        priv_key = (lambda_, mu)
        return pub_key, priv_key 

    def encrypt(self, plaintext):  #加密函数
        n, g = self.pub_key
        nsquare = n * n
        r = random.randint(1, n - 1) #获得[1, n-1]（闭区间）的随机数r
        gcd = gmpy2.gcd(r, n) 
        while gcd != 1:  #循环直到r与n互素
            r = random.randint(1, n - 1)
            gcd = gmpy2.gcd(r, n)
        c = (gmpy2.powmod(g, plaintext, nsquare) * gmpy2.powmod(r, n, nsquare)) % nsquare
        return c

    def decrypt(self, ciphertext):  #解密函数
        lambda_, mu = self.priv_key
        n, g = self.pub_key
        nsquare = n * n
        u = gmpy2.powmod(ciphertext, lambda_, nsquare) - 1
        plaintext = (u // n) * mu % n
        return plaintext

    #总体而言该算法同态运算时的规律就是把原来的运算拿到了指数上
    def p_add(self, c1, c2):  #同态加法
        n, _ =self.pub_key
        nsquare = n * n
        return (c1 * c2) % nsquare  #明文相加等价于密文相乘

    def p_add_const(self, c, k): #同态加常数
        n, g = self.pub_key
        nsquare = n * n
        return (c * gmpy2.powmod(g, k, nsquare)) % nsquare #明文加常数，等价于密文乘g的该常数次方

    def p_mul_const(self, c, k):  #同态乘常数
        n, _ = self.pub_key
        nsquare = n * n
        return gmpy2.powmod(c, k, nsquare) #明文乘常数k，等价于密文的k次方

#实例化
paillier = Paillier()

#明文
plaintext1 = 10
plaintext2 = 15
#加密
ciphertext1 = paillier.encrypt(plaintext1)
ciphertext2 = paillier.encrypt(plaintext2)
print('明文1加密后密文为：', ciphertext1)
print('明文2加密后密文为：', ciphertext2)
#同态加法
add_cipher = paillier.p_add(ciphertext1, ciphertext2)
print('同态加法后密文为：', add_cipher)
add_plain = paillier.decrypt(add_cipher)
print('解密后结果为：', add_plain)
#同态加常数
add_const_cipher = paillier.p_add_const(ciphertext1, 5)
print('同态加常数后的密文为：', add_const_cipher)
add_const_plain = paillier.decrypt(add_const_cipher)
print('解密后结果为：', add_const_plain)
#同态乘常数
mul_const_cipher = paillier.p_mul_const(ciphertext2, 2)
print('同态乘常数后密文为：', mul_const_cipher)
mul_const_plain = paillier.decrypt(mul_const_cipher)
print('解密后密文为：', mul_const_plain)