算法Paillier根据定义去实现加密（不用phe库）

'''选择两个大质数p和q，并计算n = pq和λ = lcm(p-1,q-1)。

选择一个随机数g，使得n整除g^n mod n^2 - 1。

使用公钥(n,g)对数字进行加密。例如，加密数字5需要选择一个随机数r并计算密文c = g^5 * r^n mod n^2。

同样，可以使用公钥(n,g)对数字7进行加密。假设选择另一个随机数s并计算密文d = g^7 * s^n mod n^2。

将两个密文相乘来计算它们的和：e = c * d mod n^2。

使用私钥(λ)对结果进行解密。解密过程涉及计算L函数：L(x) = (x-1)/n。
因此，解密后的结果为m = L(e^λ mod n^2) * (L(g^λ mod n^2)) -1 mod n'''
import random
from Crypto.Util.number import isPrime, inverse
from math import gcd

def generate_keys(p, q):
    # 计算n和λ
    n = p * q
    lambda_n = (p-1) * (q-1)

    # 选择一个随机数g，满足n整除g^n mod n^2 - 1
    g = None
    while True:
        g = random.randint(2, n**2-1)
        if pow(g, n, n**2) == 1:
            continue
        if gcd(pow(g, n, n**2)-1, n) == 1:
            break
    
    # 返回公钥和私钥
    public_key = (n, g)
    private_key = lambda_n
    print("g的值为",g)
    return (public_key, private_key)

def encrypt(public_key, plaintext):
    # 加密数字plaintext
    n, g = public_key
    r = random.randint(1, n-1)
    c = pow(g, plaintext, n**2) * pow(r, n, n**2) % (n**2)
    return c

def decrypt(private_key, public_key, ciphertext):
    # 解密密文ciphertext
    n, g = public_key
    lambda_n = private_key
    
    x = pow(ciphertext, lambda_n, n**2)
    L = (x-1) // n
    m = (L * inverse(lambda_n % n,n)) % n
    print(m)
    return m

# 选择质数p和q
p = 11
q = 19

# 生成公钥和私钥
public_key, private_key = generate_keys(p, q)

# 加密数字5和7
c = encrypt(public_key, 5)
d = encrypt(public_key, 7)

# 计算加密后数字的和
e = (c * d) % (public_key[0]**2)

# 解密加密后的数字
m = decrypt(private_key, public_key, e)

print("加密后的数字为：", e)
print("解密后的数字为：", m)