sangge/mimajingsai_2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

style: modify style

Browse Source
This commit is contained in:
sangge 2024-01-06 04:11:25 +08:00
parent fb6991115c
commit 1daedb0542
1 changed files with 211 additions and 180 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

391
CoreAlgorithm.py
View File

@ -3,21 +3,23 @@ from collections.abc import Mapping
from encoding import EncodedNumber from encoding import EncodedNumber
from util import invert, powmod, getprimeover from util import invert, powmod, getprimeover
DEFAULT_KEYSIZE = 1024 # 定义默认的二进制数长度 DEFAULT_KEYSIZE = 1024 # 定义默认的二进制数长度
def generate_paillier_keypair(private_keyring=None, n_length=DEFAULT_KEYSIZE): # 生成公钥和私钥的函数 def generate_paillier_keypair(
private_keyring=None, n_length=DEFAULT_KEYSIZE
): # 生成公钥和私钥的函数
# 生成 Paillier 密钥对函数 # 生成 Paillier 密钥对函数
p = q = n = None # 初始化素数 p, q 和计算结果 n p = q = n = None # 初始化素数 p, q 和计算结果 n
length = 0 # 初始化计算结果 n 的长度 (即用二进制表示 n 所需要的二进制位数) length = 0 # 初始化计算结果 n 的长度 (即用二进制表示 n 所需要的二进制位数)
while length != n_length: # 循环直至计算结果 n 的长度达到指定长度 n_length while length != n_length: # 循环直至计算结果 n 的长度达到指定长度 n_length
p = getprimeover(n_length // 2) # 随机生成一个 (n_length//2) 长的素数 p p = getprimeover(n_length // 2) # 随机生成一个 (n_length//2) 长的素数 p
q = p q = p
while q == p: while q == p:
# 确保 q 与 p 不相等 # 确保 q 与 p 不相等
q = getprimeover(n_length // 2) # 随机生成一个 (n_length//2) 长的素数 q q = getprimeover(n_length // 2) # 随机生成一个 (n_length//2) 长的素数 q
n = p * q # 计算 n，即两个素数乘积 n = p * q # 计算 n,即两个素数乘积
length = n.bit_length() # 计算 n 的二进制长度 length = n.bit_length() # 计算 n 的二进制长度
# 创建公钥对象 # 创建公钥对象
@ -25,88 +27,92 @@ def generate_paillier_keypair(private_keyring=None, n_length=DEFAULT_KEYSIZE):
# 创建私钥对象 # 创建私钥对象
private_key = PaillierPrivateKey(public_key, p, q) private_key = PaillierPrivateKey(public_key, p, q)
if private_keyring is not None: # 如果传入了私钥环对象，则将私钥添加到私钥环中 if private_keyring is not None: # 如果传入了私钥环对象,则将私钥添加到私钥环中
private_keyring.add(private_key) private_keyring.add(private_key)
return public_key, private_key # 返回公钥和私钥 return public_key, private_key # 返回公钥和私钥
class PaillierPublicKey(object): # 定义公钥类 class PaillierPublicKey(object): # 定义公钥类
def __init__(self, n): def __init__(self, n):
self.g = n + 1 self.g = n + 1
self.n = n # 公钥的模数 self.n = n # 公钥的模数
self.nsquare = n * n # n的平方 self.nsquare = n * n # n的平方
self.max_int = n // 3 - 1 # 公钥的一个属性（限制可加密/解密的最大整数值） self.max_int = n // 3 - 1 # 公钥的一个属性（限制可加密/解密的最大整数值）
def __repr__(self): # 用于打印出该类的对象 def __repr__(self): # 用于打印出该类的对象
public_key_hash = hex(hash(self))[2:] public_key_hash = hex(hash(self))[2:]
return "<PaillierPublicKey {}>".format(public_key_hash[:10]) # 返回表示对象的字符串 return "<PaillierPublicKey {}>".format(public_key_hash[:10]) # 返回表示对象的字符串
def __eq__(self, other): # 用于比较两个对象是否相等，并返回比较结果 def __eq__(self, other): # 用于比较两个对象是否相等,并返回比较结果
return self.n == other.n return self.n == other.n
def __hash__(self): # 用于返回n的Hash值 def __hash__(self): # 用于返回n的Hash值
return hash(self.n) return hash(self.n)
def get_n_and_g(self): # 获取该公钥的 n 和 g 的值 def get_n_and_g(self): # 获取该公钥的 n 和 g 的值
return self.n, self.g return self.n, self.g
def raw_encrypt(self, plaintext, r_value=None): # 用于返回加密后的密文，其中r_value可给随机数赋值 def raw_encrypt(self, plaintext, r_value=None): # 用于返回加密后的密文,其中r_value可给随机数赋值
if not isinstance(plaintext, int): # 判断plaintext是否是整数 if not isinstance(plaintext, int): # 判断plaintext是否是整数
raise TypeError('明文不是整数，而是: %s' % type(plaintext)) raise TypeError("明文不是整数,而是: %s" % type(plaintext))
if self.n - self.max_int <= plaintext < self.n: # 对于非常大的明文，使用特殊的计算方法进行加密： if self.n - self.max_int <= plaintext < self.n: # 对于非常大的明文,使用特殊的计算方法进行加密:
neg_plaintext = self.n - plaintext # = abs(plaintext - nsquare) neg_plaintext = self.n - plaintext # = abs(plaintext - nsquare)
neg_ciphertext = (self.n * neg_plaintext + 1) % self.nsquare neg_ciphertext = (self.n * neg_plaintext + 1) % self.nsquare
nude_ciphertext = invert(neg_ciphertext, self.nsquare) nude_ciphertext = invert(neg_ciphertext, self.nsquare)
else: # 如果不是非常大的明文： else: # 如果不是非常大的明文:
nude_ciphertext = (self.n * plaintext + 1) % self.nsquare # (n + 1)^plaintext = n * plaintext + 1 mod n^2 nude_ciphertext = (
self.n * plaintext + 1
) % self.nsquare # (n + 1)^plaintext = n * plaintext + 1 mod n^2
# 生成一个随机数，其值为r_value。如果r_value没有值，则r随机： # 生成一个随机数,其值为r_value。如果r_value没有值,则r随机:
r = r_value or self.get_random_lt_n() r = r_value or self.get_random_lt_n()
obfuscator = powmod(r, self.n, self.nsquare) # (r ^ n) mod n^2 obfuscator = powmod(r, self.n, self.nsquare) # (r ^ n) mod n^2
return (nude_ciphertext * obfuscator) % self.nsquare # 返回加密后的密文 return (nude_ciphertext * obfuscator) % self.nsquare # 返回加密后的密文
def get_random_lt_n(self): # 返回一个1——n间的随机整数 def get_random_lt_n(self): # 返回一个1——n间的随机整数
return random.SystemRandom().randrange(1, self.n) return random.SystemRandom().randrange(1, self.n)
def encrypt(self, value, precision=None, r_value=None): # value表示要加密的值，precision是加密精度，r_value是随机数 def encrypt(
# 判断value是否是EncodedNumber类型，如果是则直接赋值给encoding；如果不是，则对value进行编码 self, value, precision=None, r_value=None
): # value表示要加密的值,precision是加密精度,r_value是随机数
# 判断value是否是EncodedNumber类型,如果是则直接赋值给encoding；如果不是,则对value进行编码
if isinstance(value, EncodedNumber): if isinstance(value, EncodedNumber):
encoding = value encoding = value
else: else:
encoding = EncodedNumber.encode(self, value, precision) encoding = EncodedNumber.encode(self, value, precision)
return self.encrypt_encoded(encoding, r_value) return self.encrypt_encoded(encoding, r_value)
def encrypt_encoded(self, encoding, r_value): # 将已编码的数值对象转换为加密后的数值对象，并可以选择进行混淆处理 def encrypt_encoded(self, encoding, r_value): # 将已编码的数值对象转换为加密后的数值对象,并可以选择进行混淆处理
obfuscator = r_value or 1 # 为随机数r_value，没有则默认为1 obfuscator = r_value or 1 # 为随机数r_value,没有则默认为1
ciphertext = self.raw_encrypt(encoding.encoding, r_value=obfuscator) ciphertext = self.raw_encrypt(encoding.encoding, r_value=obfuscator)
encrypted_number = EncryptedNumber(self, ciphertext, encoding.exponent) encrypted_number = EncryptedNumber(self, ciphertext, encoding.exponent)
""" """
PS:默认生成情况下（不输入随机数r_value的情况下）： PS:默认生成情况下（不输入随机数r_value的情况下）:
encrypt中的随机数r_value为：None encrypt中的随机数r_value为:None
raw_encrypt中的随机数为：1 raw_encrypt中的随机数为:1
encrypt_encoded中的随机数为：None encrypt_encoded中的随机数为:None
""" """
if r_value is None: # 结合上述注释，可知：密文混淆函数是会默认执行的 if r_value is None: # 结合上述注释,可知:密文混淆函数是会默认执行的
encrypted_number.obfuscate() # 如果encrypt_encoded没有随机数r_value，则进行密文混淆处理obfuscate() encrypted_number.obfuscate() # 如果encrypt_encoded没有随机数r_value,则进行密文混淆处理obfuscate()
return encrypted_number return encrypted_number
class PaillierPrivateKey(object): # 私钥 class PaillierPrivateKey(object): # 私钥
def __init__(self, public_key, p, q): def __init__(self, public_key, p, q):
if not p * q == public_key.n: # 如果p * q 不等于 公钥的n，则说明出错 if not p * q == public_key.n: # 如果p * q 不等于 公钥的n,则说明出错
raise ValueError("所给公钥与p，q不匹配！") raise ValueError("所给公钥与p,q不匹配！")
if p == q: # p，q相同 if p == q: # p,q相同
raise ValueError("p，q不能相同！") raise ValueError("p,q不能相同！")
self.public_key = public_key self.public_key = public_key
# 给self的p q赋值： # 给self的p q赋值:
if q < p: # 默认是p 大于等于 q if q < p: # 默认是p 大于等于 q
self.p = q self.p = q
self.q = p self.q = p
else: else:
@ -114,101 +120,111 @@ class PaillierPrivateKey(object): # 私钥
self.q = q self.q = q
self.psquare = self.p * self.p self.psquare = self.p * self.p
self.qsquare = self.q * self.q self.qsquare = self.q * self.q
self.p_inverse = invert(self.p, self.q) # 计算p mod q 的乘法逆元 self.p_inverse = invert(self.p, self.q) # 计算p mod q 的乘法逆元
self.hp = self.h_function(self.p, self.psquare) # p mod p方 self.hp = self.h_function(self.p, self.psquare) # p mod p方
self.hq = self.h_function(self.q, self.qsquare) # q mod q方 self.hq = self.h_function(self.q, self.qsquare) # q mod q方
def __repr__(self): # 用于打印出该类的对象 def __repr__(self): # 用于打印出该类的对象
pub_repr = repr(self.public_key) pub_repr = repr(self.public_key)
return "<PaillierPrivateKey for {}>".format(pub_repr) return "<PaillierPrivateKey for {}>".format(pub_repr)
def decrypt(self, encrypted_number): # 解密密文，并返回明文 def decrypt(self, encrypted_number): # 解密密文,并返回明文
# 执行下面这个语句前的类型为EncryptedNumber，执行完毕后类型为EncodedNumber（中间会变为int型的ciphertext）： # 执行下面这个语句前的类型为EncryptedNumber,执行完毕后类型为EncodedNumber（中间会变为int型的ciphertext）:
encoded = self.decrypt_encoded(encrypted_number) encoded = self.decrypt_encoded(encrypted_number)
return encoded.decode() return encoded.decode()
def decrypt_encoded(self, encrypted_number, Encoding=None): # 用于解密密文并返回解密后的EncodedNumber类型 def decrypt_encoded(
# 检查输入信息是否是EncryptedNumber参数，如果不是： self, encrypted_number, Encoding=None
): # 用于解密密文并返回解密后的EncodedNumber类型
# 检查输入信息是否是EncryptedNumber参数,如果不是:
if not isinstance(encrypted_number, EncryptedNumber): if not isinstance(encrypted_number, EncryptedNumber):
raise TypeError('参数应该是EncryptedNumber，' raise TypeError(
' 参数不能为: %s' % type(encrypted_number)) "参数应该是EncryptedNumber," " 参数不能为: %s" % type(encrypted_number)
)
if self.public_key != encrypted_number.public_key: # 如果公钥与加密数字的公钥不一致 if self.public_key != encrypted_number.public_key: # 如果公钥与加密数字的公钥不一致
raise ValueError('加密信息不能被不同的公钥进行加密！') raise ValueError("加密信息不能被不同的公钥进行加密！")
if Encoding is None: # 将Encoding设置为未赋值的EncodedNumber变量 if Encoding is None: # 将Encoding设置为未赋值的EncodedNumber变量
Encoding = EncodedNumber Encoding = EncodedNumber
"""提取 encrypted_number 中的 ciphertext """提取 encrypted_number 中的 ciphertext
这里是禁用安全模式， 这里是禁用安全模式,
所以是直接提取ciphertext， 所以是直接提取ciphertext,
随后调用raw_decrypt函数对ciphertext进行处理：""" 随后调用raw_decrypt函数对ciphertext进行处理:"""
encoded = self.raw_decrypt(encrypted_number.ciphertext(be_secure=False)) encoded = self.raw_decrypt(encrypted_number.ciphertext(be_secure=False))
return Encoding(self.public_key, encoded, return Encoding(self.public_key, encoded, encrypted_number.exponent)
encrypted_number.exponent)
def raw_decrypt(self, ciphertext): # 对密文进行原始解密 def raw_decrypt(self, ciphertext): # 对密文进行原始解密
if not isinstance(ciphertext, int): # 如果所给的密文不是int型 if not isinstance(ciphertext, int): # 如果所给的密文不是int型
raise TypeError('密文应该是int型, 而不是: %s' % raise TypeError("密文应该是int型, 而不是: %s" % type(ciphertext))
type(ciphertext))
# 将解密结果存放在p和q中，并将p q进行合并： # 将解密结果存放在p和q中,并将p q进行合并:
decrypt_to_p = self.l_function(powmod(ciphertext, self.p - 1, self.psquare), self.p) * self.hp % self.p decrypt_to_p = (
decrypt_to_q = self.l_function(powmod(ciphertext, self.q - 1, self.qsquare), self.q) * self.hq % self.q self.l_function(powmod(ciphertext, self.p - 1, self.psquare), self.p)
* self.hp
% self.p
)
decrypt_to_q = (
self.l_function(powmod(ciphertext, self.q - 1, self.qsquare), self.q)
* self.hq
% self.q
)
return self.crt(decrypt_to_p, decrypt_to_q) return self.crt(decrypt_to_p, decrypt_to_q)
def h_function(self, x, xsquare): # 计算并返回h函数值[用于中国剩余定理] def h_function(self, x, xsquare): # 计算并返回h函数值[用于中国剩余定理]
return invert(self.l_function(powmod(self.public_key.g, x - 1, xsquare), x), x) return invert(self.l_function(powmod(self.public_key.g, x - 1, xsquare), x), x)
def l_function(self, mju, p): # 计算并返回l值（算L(μ) ） def l_function(self, mju, p): # 计算并返回l值（算L(μ) ）
return (mju - 1) // p return (mju - 1) // p
def crt(self, mp, mq): # 实现中国剩余定理(Chinese remainder theorem) def crt(self, mp, mq): # 实现中国剩余定理(Chinese remainder theorem)
u = (mq - mp) * self.p_inverse % self.q u = (mq - mp) * self.p_inverse % self.q
return mp + (u * self.p) return mp + (u * self.p)
def __eq__(self, other): # 判断两个对象的 q 与 p 是否相等 def __eq__(self, other): # 判断两个对象的 q 与 p 是否相等
return self.p == other.p and self.q == other.q return self.p == other.p and self.q == other.q
def __hash__(self): # 计算 p 与 q 元组的哈希值 def __hash__(self): # 计算 p 与 q 元组的哈希值
return hash((self.p, self.q)) return hash((self.p, self.q))
class PaillierPrivateKeyring(Mapping): # 私钥环类，并继承了Mapping类 class PaillierPrivateKeyring(Mapping): # 私钥环类,并继承了Mapping类
def __init__(self, private_keys=None): # 初始化私钥环对象（私钥环列表） def __init__(self, private_keys=None): # 初始化私钥环对象（私钥环列表）
if private_keys is None: if private_keys is None:
private_keys = [] private_keys = []
# 将私钥和公钥进行组合，并存储在私钥环中： # 将私钥和公钥进行组合,并存储在私钥环中:
public_keys = [k.public_key for k in private_keys] public_keys = [k.public_key for k in private_keys]
self.__keyring = dict(zip(public_keys, private_keys)) self.__keyring = dict(zip(public_keys, private_keys))
def __getitem__(self, key): # 通过公钥，来查找私钥环中对应的私钥 def __getitem__(self, key): # 通过公钥,来查找私钥环中对应的私钥
return self.__keyring[key] return self.__keyring[key]
def __len__(self): # 存储的私钥数量 def __len__(self): # 存储的私钥数量
return len(self.__keyring) return len(self.__keyring)
def __iter__(self): # 遍历私钥环中的公钥 def __iter__(self): # 遍历私钥环中的公钥
return iter(self.__keyring) return iter(self.__keyring)
def __delitem__(self, public_key): # 删除与公钥对应的私钥 def __delitem__(self, public_key): # 删除与公钥对应的私钥
del self.__keyring[public_key] del self.__keyring[public_key]
def add(self, private_key): # 向私钥环中添加私钥 def add(self, private_key): # 向私钥环中添加私钥
if not isinstance(private_key, PaillierPrivateKey): # 对要添加的私钥进行判断 if not isinstance(private_key, PaillierPrivateKey): # 对要添加的私钥进行判断
raise TypeError("私钥应该是PaillierPrivateKey类型, " raise TypeError("私钥应该是PaillierPrivateKey类型, " "而不是 %s" % type(private_key))
"而不是 %s" % type(private_key)) self.__keyring[private_key.public_key] = private_key # 将该公钥和对用的私钥一块儿加入到私钥环中
self.__keyring[private_key.public_key] = private_key # 将该公钥和对用的私钥一块儿加入到私钥环中
def decrypt(self, encrypted_number): # 对密文进行解密 def decrypt(self, encrypted_number): # 对密文进行解密
relevant_private_key = self.__keyring[encrypted_number.public_key] # 在私钥环中获取对应的私钥 relevant_private_key = self.__keyring[
return relevant_private_key.decrypt(encrypted_number) # 返回加密结果 encrypted_number.public_key
] # 在私钥环中获取对应的私钥
return relevant_private_key.decrypt(encrypted_number) # 返回加密结果
class EncryptedNumber(object): # 浮点数或整数的Pailier加密 class EncryptedNumber(object): # 浮点数或整数的Pailier加密
""" """
1. D(E(a) * E(b)) = a + b 1. D(E(a) * E(b)) = a + b
2. D(E(a)**b) = a * b 2. D(E(a)**b) = a * b
@ -216,15 +232,17 @@ class EncryptedNumber(object): # 浮点数或整数的Pailier加密
def __init__(self, public_key, ciphertext, exponent=0): def __init__(self, public_key, ciphertext, exponent=0):
self.public_key = public_key self.public_key = public_key
self.__ciphertext = ciphertext # 密文 self.__ciphertext = ciphertext # 密文
self.exponent = exponent # 用于表示指数 self.exponent = exponent # 用于表示指数
self.__is_obfuscated = False # 用于表示数据是否被混淆 self.__is_obfuscated = False # 用于表示数据是否被混淆
if isinstance(self.ciphertext, EncryptedNumber): # 如果密文是EncryptedNumber if isinstance(self.ciphertext, EncryptedNumber): # 如果密文是EncryptedNumber
raise TypeError('密文必须是int型') raise TypeError("密文必须是int型")
if not isinstance(self.public_key, PaillierPublicKey): # 如果公钥不是PaillierPublicKey if not isinstance(
raise TypeError('公钥必须是PaillierPublicKey') self.public_key, PaillierPublicKey
): # 如果公钥不是PaillierPublicKey
raise TypeError("公钥必须是PaillierPublicKey")
def __add__(self, other): # 运算符重载，重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的加法 def __add__(self, other): # 运算符重载,重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的加法
if isinstance(other, EncryptedNumber): if isinstance(other, EncryptedNumber):
return self._add_encrypted(other) return self._add_encrypted(other)
elif isinstance(other, EncodedNumber): elif isinstance(other, EncodedNumber):
@ -232,35 +250,37 @@ class EncryptedNumber(object): # 浮点数或整数的Pailier加密
else: else:
return self._add_scalar(other) return self._add_scalar(other)
def __radd__(self, other): # 反加，处理整数/浮点数与EncryptedNumber之间的加法 def __radd__(self, other): # 反加,处理整数/浮点数与EncryptedNumber之间的加法
return self.__add__(other) return self.__add__(other)
def __mul__(self, other): # 运算符重载，重载为EncryptedNumber与(整数/浮点数)的乘法 def __mul__(self, other): # 运算符重载,重载为EncryptedNumber与(整数/浮点数)的乘法
# 判断other对象是否是EncryptedNumber，如果是： # 判断other对象是否是EncryptedNumber,如果是:
if isinstance(other, EncryptedNumber): if isinstance(other, EncryptedNumber):
raise NotImplementedError('EncryptedNumber 与 EncryptedNumber 之间不能相乘！') raise NotImplementedError("EncryptedNumber 与 EncryptedNumber 之间不能相乘！")
if isinstance(other, EncodedNumber): if isinstance(other, EncodedNumber):
encoding = other encoding = other
else: else:
encoding = EncodedNumber.encode(self.public_key, other) encoding = EncodedNumber.encode(self.public_key, other)
product = self._raw_mul(encoding.encoding) # 重新更新乘积 product = self._raw_mul(encoding.encoding) # 重新更新乘积
exponent = self.exponent + encoding.exponent # 重新更新指数 exponent = self.exponent + encoding.exponent # 重新更新指数
return EncryptedNumber(self.public_key, product, exponent) return EncryptedNumber(self.public_key, product, exponent)
def __rmul__(self, other): # 反乘，处理整数/浮点数与EncryptedNumber之间的乘法 def __rmul__(self, other): # 反乘,处理整数/浮点数与EncryptedNumber之间的乘法
return self.__mul__(other) return self.__mul__(other)
def __sub__(self, other): # 运算符重载，重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的减法 def __sub__(self, other): # 运算符重载,重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的减法
return self + (other * -1) return self + (other * -1)
def __rsub__(self, other): # 处理整数/浮点数与EncryptedNumber之间的减法 def __rsub__(self, other): # 处理整数/浮点数与EncryptedNumber之间的减法
return other + (self * -1) return other + (self * -1)
def __truediv__(self, scalar): # 运算符重载，重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的除法 def __truediv__(
self, scalar
): # 运算符重载,重载为EncryptedNumber与(EncryptedNumber/整数/浮点数)的除法
return self.__mul__(1 / scalar) return self.__mul__(1 / scalar)
def __invert__(self): # 运算符重载~（对 数 的取反） def __invert__(self): # 运算符重载~（对 数 的取反）
return self * (-1) return self * (-1)
# def __pow__(self, exponent): # 运算符重载 ** （对密文的幂函数） # def __pow__(self, exponent): # 运算符重载 ** （对密文的幂函数）
@ -273,61 +293,70 @@ class EncryptedNumber(object): # 浮点数或整数的Pailier加密
# return result # return result
# # 原本的幂运算 ** ；return self.value ** exponent # # 原本的幂运算 ** ；return self.value ** exponent
def ciphertext(self, be_secure=True): # 用于混淆密文，并返回混淆后的密文 def ciphertext(self, be_secure=True): # 用于混淆密文,并返回混淆后的密文
""" """
EncryptedNumber类的一个方法ciphertext，用于返回该对象的密文。 EncryptedNumber类的一个方法ciphertext,用于返回该对象的密文。
在Paillier加密中，为了提高计算性能，加法和乘法操作进行了简化， 在Paillier加密中,为了提高计算性能,加法和乘法操作进行了简化,
避免对每个加法和乘法结果进行随机数的加密操作。 避免对每个加法和乘法结果进行随机数的加密操作。
这样会使得内部计算快速，但会暴露一部分信息。 这样会使得内部计算快速,但会暴露一部分信息。
此外，为了保证安全，如果需要与其他人共享密文，应该使用be_secure=True。 此外,为了保证安全,如果需要与其他人共享密文,应该使用be_secure=True。
这样，如果密文还没有被混淆，会调用obfuscate方法对其进行混淆操作。 这样,如果密文还没有被混淆,会调用obfuscate方法对其进行混淆操作。
""" """
if be_secure and not self.__is_obfuscated: # 如果密文没有被混淆，则进行混淆操作 if be_secure and not self.__is_obfuscated: # 如果密文没有被混淆,则进行混淆操作
self.obfuscate() self.obfuscate()
return self.__ciphertext return self.__ciphertext
def decrease_exponent_to(self, new_exp): # 返回一个指数较低但大小相同的数（即返回一个同值的，但指数较低的EncryptedNumber） def decrease_exponent_to(
self, new_exp
): # 返回一个指数较低但大小相同的数（即返回一个同值的,但指数较低的EncryptedNumber）
if new_exp > self.exponent: if new_exp > self.exponent:
raise ValueError('新指数值 %i 应比原指数 %i 小！ ' % (new_exp, self.exponent)) raise ValueError("新指数值 %i 应比原指数 %i 小！ " % (new_exp, self.exponent))
multiplied = self * pow(EncodedNumber.BASE, self.exponent - new_exp) # 降指数后的乘积 multiplied = self * pow(EncodedNumber.BASE, self.exponent - new_exp) # 降指数后的乘积
multiplied.exponent = new_exp # 降指数后的新指数 multiplied.exponent = new_exp # 降指数后的新指数
return multiplied return multiplied
def obfuscate(self): # 混淆密文 def obfuscate(self): # 混淆密文
r = self.public_key.get_random_lt_n() # 生成一个(1——n)间的随机数r，不 ＞＝ r r = self.public_key.get_random_lt_n() # 生成一个(1——n)间的随机数r,不 ＞＝ r
r_pow_n = powmod(r, self.public_key.n, self.public_key.nsquare) # (r ^ n) mod n^2 r_pow_n = powmod(
self.__ciphertext = self.__ciphertext * r_pow_n % self.public_key.nsquare # 对原密文进行处理 r, self.public_key.n, self.public_key.nsquare
self.__is_obfuscated = True # 用于判断密文是否被混淆 ) # (r ^ n) mod n^2
self.__ciphertext = (
self.__ciphertext * r_pow_n % self.public_key.nsquare
) # 对原密文进行处理
self.__is_obfuscated = True # 用于判断密文是否被混淆
def _add_scalar(self, scalar): # 执行EncodedNumber与标量(整型/浮点型)相加的操作 def _add_scalar(self, scalar): # 执行EncodedNumber与标量(整型/浮点型)相加的操作
encoded = EncodedNumber.encode(self.public_key, scalar, encoded = EncodedNumber.encode(
max_exponent=self.exponent) self.public_key, scalar, max_exponent=self.exponent
)
return self._add_encoded(encoded) return self._add_encoded(encoded)
def _add_encoded(self, encoded): # 对EncodedNumber与标量encoded加法编码 def _add_encoded(self, encoded): # 对EncodedNumber与标量encoded加法编码
# 返回 E(a + b) # 返回 E(a + b)
if self.public_key != encoded.public_key: # 如果公钥与编码公钥不相同 if self.public_key != encoded.public_key: # 如果公钥与编码公钥不相同
raise ValueError("不能使用不同的公钥，对数字进行编码！") raise ValueError("不能使用不同的公钥,对数字进行编码！")
a, b = self, encoded a, b = self, encoded
# 对指数处理（使指数相同）： # 对指数处理（使指数相同）:
if a.exponent > b.exponent: if a.exponent > b.exponent:
a = self.decrease_exponent_to(b.exponent) a = self.decrease_exponent_to(b.exponent)
elif a.exponent < b.exponent: elif a.exponent < b.exponent:
b = b.decrease_exponent_to(a.exponent) b = b.decrease_exponent_to(a.exponent)
encrypted_scalar = a.public_key.raw_encrypt(b.encoding, 1) # 用公钥加密b.encoding后的标量 encrypted_scalar = a.public_key.raw_encrypt(
b.encoding, 1
) # 用公钥加密b.encoding后的标量
sum_ciphertext = a._raw_add(a.ciphertext(False), encrypted_scalar) # 进行相加操作 sum_ciphertext = a._raw_add(a.ciphertext(False), encrypted_scalar) # 进行相加操作
return EncryptedNumber(a.public_key, sum_ciphertext, a.exponent) return EncryptedNumber(a.public_key, sum_ciphertext, a.exponent)
def _add_encrypted(self, other): # 对EncodedNumber与EncodedNumber加法加密 def _add_encrypted(self, other): # 对EncodedNumber与EncodedNumber加法加密
if self.public_key != other.public_key: if self.public_key != other.public_key:
raise ValueError("不能使用不同的公钥，对数字进行加密！") raise ValueError("不能使用不同的公钥,对数字进行加密！")
# 对指数处理（使指数相同）： # 对指数处理（使指数相同）:
a, b = self, other a, b = self, other
if a.exponent > b.exponent: if a.exponent > b.exponent:
a = self.decrease_exponent_to(b.exponent) a = self.decrease_exponent_to(b.exponent)
@ -337,79 +366,81 @@ class EncryptedNumber(object): # 浮点数或整数的Pailier加密
sum_ciphertext = a._raw_add(a.ciphertext(False), b.ciphertext(False)) sum_ciphertext = a._raw_add(a.ciphertext(False), b.ciphertext(False))
return EncryptedNumber(a.public_key, sum_ciphertext, a.exponent) return EncryptedNumber(a.public_key, sum_ciphertext, a.exponent)
def _raw_add(self, e_a, e_b): # 对加密后的a，b直接进行相加，并返回未加密的结果 def _raw_add(self, e_a, e_b): # 对加密后的a,b直接进行相加,并返回未加密的结果
return e_a * e_b % self.public_key.nsquare return e_a * e_b % self.public_key.nsquare
def _raw_mul(self, plaintext): # 对密文进行乘法运算，并返回未加密的结果 def _raw_mul(self, plaintext): # 对密文进行乘法运算,并返回未加密的结果
# 检查乘数是否为int型： # 检查乘数是否为int型:
if not isinstance(plaintext, int): if not isinstance(plaintext, int):
raise TypeError('期望密文应该是int型, 而不是 %s' % type(plaintext)) raise TypeError("期望密文应该是int型, 而不是 %s" % type(plaintext))
# 如果乘数是负数，或乘数比公钥的模（n）大： # 如果乘数是负数,或乘数比公钥的模（n）大:
if plaintext < 0 or plaintext >= self.public_key.n: if plaintext < 0 or plaintext >= self.public_key.n:
raise ValueError('超出可计算范围: %i' % plaintext) raise ValueError("超出可计算范围: %i" % plaintext)
if self.public_key.n - self.public_key.max_int <= plaintext: if self.public_key.n - self.public_key.max_int <= plaintext:
# 如果数据很大，则先反置一下再进行运算： # 如果数据很大,则先反置一下再进行运算:
neg_c = invert(self.ciphertext(False), self.public_key.nsquare) neg_c = invert(self.ciphertext(False), self.public_key.nsquare)
neg_scalar = self.public_key.n - plaintext neg_scalar = self.public_key.n - plaintext
return powmod(neg_c, neg_scalar, self.public_key.nsquare) return powmod(neg_c, neg_scalar, self.public_key.nsquare)
else: else:
return powmod(self.ciphertext(False), plaintext, self.public_key.nsquare) return powmod(self.ciphertext(False), plaintext, self.public_key.nsquare)
def increment(self): # 定义自增运算 def increment(self): # 定义自增运算
return self + 1 return self + 1
def decrement(self): # 定义自减运算 def decrement(self): # 定义自减运算
return self + 1 return self + 1
def cal_sum(self, *args): def cal_sum(self, *args):
result = 0 # 将初始值设置为0 result = 0 # 将初始值设置为0
for i in args: for i in args:
if not isinstance(i, (int, float, EncryptedNumber)): if not isinstance(i, (int, float, EncryptedNumber)):
raise TypeError('期望密文应该是int/float/EncryptedNumber型, 而不是 %s' % type(i)) raise TypeError("期望密文应该是int/float/EncryptedNumber型, 而不是 %s" % type(i))
if isinstance(i, int or float): # 如果是 int 或 float 明文型，则先将明文加密在进行运算 if isinstance(i, int or float): # 如果是 int 或 float 明文型,则先将明文加密在进行运算
result += self.public_key.encrypt(i) result += self.public_key.encrypt(i)
else: else:
result += i # 第一次循环：标量与密文相加；后面的循环，密文与密文相加 result += i # 第一次循环:标量与密文相加；后面的循环,密文与密文相加
return result return result
def average(self, *args): # 定义求平均值 def average(self, *args): # 定义求平均值
total_sum = self.cal_sum(*args) # 计算总和total是<__main__.EncryptedNumber object at 0x000002AB74FB9850> total_sum = self.cal_sum(
*args
) # 计算总和total是<__main__.EncryptedNumber object at 0x000002AB74FB9850>
# # 如果总数超过了可计算范围 # # 如果总数超过了可计算范围
# if total_sum > 91000: # if total_sum > 91000:
# raise ValueError('超出可计算范围: %i' % total_sum) # raise ValueError('超出可计算范围: %i' % total_sum)
count = 0 # 定义count，用来统计参数的个数 count = 0 # 定义count,用来统计参数的个数
for _ in args: for _ in args:
count += 1 # count++ count += 1 # count++
return total_sum / count return total_sum / count
def weighted_average(*args): # 定义加权平均 def weighted_average(self, *args): # 定义加权平均 def weighted_average(*args):
""" PS: """PS:
args[0]: <__main__.EncryptedNumber object at 0x000001F7C1B6A610> args[0]: <__main__.EncryptedNumber object at 0x000001F7C1B6A610>
args[1]: 第一个参数 args[1]: 第一个参数
args[2]: 给第一个参数设置的权值 args[2]: 给第一个参数设置的权值
。。。。。。 。。。。。。
""" """
total_weight = sum(args[2::2]) # 计算权值的总和(使用切片操作从参数列表中取出索引为参数权值的元素) total_weight = sum(args[2::2]) # 计算权值的总和(使用切片操作从参数列表中取出索引为参数权值的元素)
if total_weight != 1: if total_weight != 1:
raise TypeError("加权平均算法的权值设置错误！请重新设置！") raise TypeError("加权平均算法的权值设置错误！请重新设置！")
else: else:
# 计算加权和，其中： for i in range(0, len(args), 2) 表示以2为步长，从0递增，直到 i >= len(args)时： # 计算加权和,其中: for i in range(0, len(args), 2) 表示以2为步长,从0递增,直到 i >= len(args)时:
result = sum(args[i] * args[i + 1] for i in range(1, len(args), 2)) result = sum(args[i] * args[i + 1] for i in range(1, len(args), 2))
return result return result
def reset(self): # 定义复位（置0运算） def reset(self): # 定义复位（置0运算）
zero = self.public_key.encrypt(0) # 用公钥对0进行加密 zero = self.public_key.encrypt(0) # 用公钥对0进行加密
return zero return zero
def calculate_variance(self, *args): # 定义求方差 def calculate_variance(self, *args): # 定义求方差
mean = self.average(*args) # 均值 mean = self.average(*args) # 均值
count = 0 # 定义count，用来统计参数的个数 count = 0 # 定义count,用来统计参数的个数
for _ in args: for _ in args:
count += 1 # count++ count += 1 # count++
variance = sum((x - mean) ** 2 for x in args) / (count - 1) variance = sum((x - mean) ** 2 for x in args) / (count - 1)
return variance return variance
@ -443,15 +474,15 @@ class EncryptedNumber(object): # 浮点数或整数的Pailier加密
# return cert # return cert
if __name__ == '__main__': # 主函数 if __name__ == "__main__": # 主函数
Public_Key, Private_Key = generate_paillier_keypair() # 随机生成1024长的公钥和私钥 Public_Key, Private_Key = generate_paillier_keypair() # 随机生成1024长的公钥和私钥
x = 90000.23 x = 90000.23
y = 90 y = 90
z = 0.5 z = 0.5
x_encrypted = Public_Key.encrypt(x) # 加密后的x x_encrypted = Public_Key.encrypt(x) # 加密后的x
y_encrypted = Public_Key.encrypt(y) # 加密后的y y_encrypted = Public_Key.encrypt(y) # 加密后的y
z_encrypted = Public_Key.encrypt(z) # 加密后的z z_encrypted = Public_Key.encrypt(z) # 加密后的z
t_encrypted = x_encrypted + y_encrypted * 0.5 # 在x，y保密的情况下计算t，得到加密后的t(t_encrypted) t_encrypted = x_encrypted + y_encrypted * 0.5 # 在x,y保密的情况下计算t,得到加密后的t(t_encrypted)
# x_encrypted = x_encrypted.increment() # 自增 # x_encrypted = x_encrypted.increment() # 自增
# y_encrypted = y_encrypted.decrement() # 自减 # y_encrypted = y_encrypted.decrement() # 自减
@ -462,19 +493,19 @@ if __name__ == '__main__': # 主函数
# print(Private_Key.decrypt(~x_encrypted) ) # 取反 # print(Private_Key.decrypt(~x_encrypted) ) # 取反
# total = x_encrypted.cal_sum(x_encrypted, y_encrypted, 0.5) # 求和函数 # total = x_encrypted.cal_sum(x_encrypted, y_encrypted, 0.5) # 求和函数
# print("密文之和为：", Private_Key.decrypt(total)) # print("密文之和为:", Private_Key.decrypt(total))
# avg = x_encrypted.average(y_encrypted, z_encrypted, z_encrypted) # 求平均值函数 # avg = x_encrypted.average(y_encrypted, z_encrypted, z_encrypted) # 求平均值函数
# print("密文的平均值为：", Private_Key.decrypt(avg) ) # 只能对0~90090.73的数进行除法运算（除不尽） # print("密文的平均值为:", Private_Key.decrypt(avg) ) # 只能对0~90090.73的数进行除法运算（除不尽）
# weight_average = x_encrypted.weighted_average(x_encrypted, 0.1, y_encrypted, 0.3, z_encrypted, 0.6) # 加权平均函数 # weight_average = x_encrypted.weighted_average(x_encrypted, 0.1, y_encrypted, 0.3, z_encrypted, 0.6) # 加权平均函数
# print("加权平均结果为：", Private_Key.decrypt(weight_average)) # print("加权平均结果为:", Private_Key.decrypt(weight_average))
# variance = x_encrypted.calculate_variance(x_encrypted, y_encrypted) #求方差 # variance = x_encrypted.calculate_variance(x_encrypted, y_encrypted) #求方差
# print("方差为：", Private_Key.decrypt(variance)) # print("方差为:", Private_Key.decrypt(variance))
# z_encrypted = z_encrypted.reset() # 复位函数 # z_encrypted = z_encrypted.reset() # 复位函数
# print("z复位后的结果为：", Private_Key.decrypt(z_encrypted) ) # print("z复位后的结果为:", Private_Key.decrypt(z_encrypted) )
# print(x_encrypted ** x) # 相当于print(x_encrypted.POW(2) ) # print(x_encrypted ** x) # 相当于print(x_encrypted.POW(2) )
# print(x_encrypted > y_encrypted) # print(x_encrypted > y_encrypted)
@ -482,4 +513,4 @@ if __name__ == '__main__': # 主函数
# print(type(Public_Key)) # print(type(Public_Key))
# print(Public_Key) # print(Public_Key)
print(f"x + y * 0.5的结果是：{Private_Key.decrypt(t_encrypted)}") # 打印出t print(f"x + y * 0.5的结果是:{Private_Key.decrypt(t_encrypted)}") # 打印出t