Python实现 ElGamal 加密算法

使用 Python 实现 ElGamal 加密算法的博客

引言

ElGamal 加密算法 是一种基于离散对数难题的非对称加密算法，由塔希尔·艾尔加迈尔（Taher ElGamal）在1985年提出。它与 RSA 类似，是一种常用于安全通信的公钥加密系统。ElGamal 算法广泛应用于数字签名、加密系统和零知识证明等领域。本文将详细介绍 ElGamal 算法的原理，并使用 Python 以面向对象的方式实现 ElGamal 加密与解密操作，最后结合一个场景演示其应用。

---

ElGamal 加密算法的工作原理

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

1. 密钥生成：

   • 选择一个大的素数 $p$ 和一个整数$g$，其中 $g$ 是模 $p$ 的一个生成元。
   • 随机选择一个私钥 $x$，满足$1<x<p-1$。
   • 计算公钥 $y=g^x\mathrm{mod}p$。
   • 公钥为 $(p,g,y)$，私钥为 $x$。

2. 加密过程：

   • 选择要加密的明文消息 $m$，满足 $m<p$。
   • 随机选择一个临时密钥 $k$，满足 $1<k<p-1$。
   • 计算加密对 $(c_1,c_2)$，其中：
     $$c_1=g^k\mathrm{mod}p$$
     $$c_2=m\cdot y^k\mathrm{mod}p$$
   • 加密后的密文为 $(c_1,c_2)$。

3. 解密过程：

   • 使用私钥 $x$ 解密密文 $(c_1,c_2)$，计算：
     $$m=c_2\cdot (c_1^x{)}^{-1}\mathrm{mod}p$$
   • 其中 $(c_1^x{)}^{-1}$ 是 $c_1^x$ 的模 $p$ 的逆元，可以使用扩展欧几里得算法计算。

Python 面向对象实现 ElGamal 算法

为了实现 ElGamal 算法，我们将定义一个名为 ElGamal 的类，其中包含密钥生成、加密和解密的方法。

import random

class ElGamal:
    def __init__(self, p, g):
        """
        初始化 ElGamal 实例，指定素数 p 和生成元 g。
        """
        self.p = p  # 大素数 p
        self.g = g  # 生成元 g
        self.private_key = None  # 私钥
        self.public_key = None  # 公钥 (p, g, y)

    def generate_keys(self):
        """
        生成公钥和私钥。
        """
        # 选择一个随机私钥 x
        self.private_key = random.randint(2, self.p - 2)
        # 计算公钥 y
        y = pow(self.g, self.private_key, self.p)
        self.public_key = (self.p, self.g, y)
        return self.public_key

    def encrypt(self, plaintext, k=None):
        """
        使用公钥加密消息。
        :param plaintext: 明文消息 (整数形式)
        :param k: 临时密钥 (可选)，默认为随机选择
        :return: 密文对 (c1, c2)
        """
        if not (1 <= plaintext < self.p):
            raise ValueError(f"明文消息必须在范围 1 到 {self.p-1} 之间。")
        
        if k is None:
            k = random.randint(2, self.p - 2)
        
        # 计算 c1 = g^k mod p
        c1 = pow(self.g, k, self.p)
        # 计算 c2 = m * y^k mod p
        y = self.public_key[2]
        c2 = (plaintext * pow(y, k, self.p)) % self.p

        return (c1, c2)

    def decrypt(self, ciphertext):
        """
        使用私钥解密密文。
        :param ciphertext: 密文对 (c1, c2)
        :return: 解密后的明文消息
        """
        c1, c2 = ciphertext
        # 计算 s = c1^x mod p
        s = pow(c1, self.private_key, self.p)
        # 计算 s 的逆元
        s_inv = pow(s, -1, self.p)
        # 计算明文 m = c2 * s^(-1) mod p
        plaintext = (c2 * s_inv) % self.p
        return plaintext

代码解析

1. 类初始化 __init__ 方法：接收一个素数 $p$ 和一个生成元 $g$ 作为输入，初始化 ElGamal 加密系统。

2. 密钥生成 generate_keys 方法：随机生成一个私钥 $x$，计算公钥 $y=g^x\mathrm{mod}p$，返回公钥 $(p,g,y)$。

3. 加密 encrypt 方法：使用公钥和随机的临时密钥 $k$ 对明文进行加密，生成密文对 $(c_1,c_2)$。

4. 解密 decrypt 方法：使用私钥对密文进行解密，计算明文消息。

示例场景：安全消息传输

假设我们在一个安全消息传输系统中使用 ElGamal 加密算法。Alice 需要将一条秘密消息发送给 Bob。双方同意使用 ElGamal 加密算法。Bob 生成公钥和私钥，并将公钥发送给 Alice。Alice 使用 Bob 的公钥对消息进行加密，并将密文发送给 Bob。Bob 接收到密文后使用自己的私钥进行解密，恢复原始消息。

# 示例：Alice 和 Bob 的安全消息传输

# 1. Bob 生成公钥和私钥
p = 467  # 大素数 p
g = 2    # 生成元 g

bob = ElGamal(p, g)
public_key = bob.generate_keys()
print(f"Bob 的公钥: {public_key}")

# 2. Alice 使用 Bob 的公钥加密消息
alice = ElGamal(p, g)
plaintext = 123  # 明文消息 (整数形式)
ciphertext = alice.encrypt(plaintext)
print(f"Alice 加密的消息 (密文): {ciphertext}")

# 3. Bob 使用私钥解密密文
decrypted_message = bob.decrypt(ciphertext)
print(f"Bob 解密的消息: {decrypted_message}")

assert plaintext == decrypted_message, "解密后的消息与原始消息不一致！"

代码解析

1. Bob 生成密钥对：Bob 选择一个大素数 ( p = 467 ) 和生成元 ( g = 2 )，生成公钥和私钥。

2. Alice 加密消息：Alice 使用 Bob 的公钥对明文消息进行加密，并生成密文对。

3. Bob 解密密文：Bob 使用私钥解密密文，恢复原始明文消息。

Python 代码的扩展和优化

为了提高 ElGamal 算法的实用性，我们可以进一步扩展代码：

1. 支持字符串加密：当前实现只支持整数形式的消息，我们可以扩展支持字符串消息加密和解密。

2. 优化密钥生成：优化生成大素数和生成元的算法，使用更加安全的密钥生成机制。

3. 加入异常处理：完善代码中的异常处理机制，保证加密解密过程的鲁棒性。

以下是支持字符串加密的扩展代码示例：

class ElGamalExtended(ElGamal):
    def string_to_int(self, message):
        """
        将字符串消息转换为整数。
        """
        return int.from_bytes(message.encode('utf-8'), 'big')

    def int_to_string(self, number):
        """
        将整数转换为字符串消息。
        """
        return number.to_bytes((number.bit_length() + 7) // 8, 'big').decode('utf-8')

    def encrypt_message(self, message, k=None):
        """
        加密字符串消息。
        """
        plaintext = self.string_to_int(message)
        return self.encrypt(plaintext, k)

    def decrypt_message(self, ciphertext):
        """
        解密密文为字符串消息。
        """
        decrypted_number = self.decrypt(ciphertext)
        return self.int_to_string(decrypted_number)

# 使用扩展类进行字符串加密解密
if __name__ == "__main__":
    p =

 467
    g = 2
    bob = ElGamalExtended(p, g)
    public_key = bob.generate_keys()

    message = "Hello, Bob!"
    ciphertext = bob.encrypt_message(message)
    print(f"加密后的密文: {ciphertext}")

    decrypted_message = bob.decrypt_message(ciphertext)
    print(f"解密后的消息: {decrypted_message}")

    assert message == decrypted_message, "解密后的消息与原始消息不一致！"

总结

在本文中，我们详细介绍了 ElGamal 加密算法的原理，并使用 Python 以面向对象的方式实现了其加密与解密过程。同时，我们通过一个简单的场景示例，演示了 ElGamal 算法在安全通信中的实际应用。ElGamal 算法凭借其基于离散对数难题的安全性，成为现代密码学领域中的重要工具之一。通过对该算法的学习和实现，可以更深入理解公钥加密的核心思想和应用。