elgamal加密算法python

ElGamal加密算法是一种基于离散对数问题的非对称加密算法，它在1985年由塔希尔·盖莫尔提出。该算法的安全性基于离散对数问题的困难性，即在有限的算力之下，求解离散对数是困难的，而其逆运算可以应用平方乘的方法有效地计算出来。在相应的群G中，指数函数是单向函数。ElGamal加密算法的加密过程包括生成公私钥对、加密和解密三个步骤。具体实现可以使用Python语言编写代码。

相关问题

python实现Elgamal加密算法

### 回答1：
Elgamal加密算法是一种非对称加密算法，它基于离散对数问题。下面是Python实现Elgamal加密算法的示例代码：

import random
from math import pow

a = random.randint(2, 10)

def gcd(a, b):
    if a < b:
        return gcd(b, a)
    elif a % b == 0:
        return b;
    else:
        return gcd(b, a % b)

# Generating large random numbers
def gen_key(q):
    key = random.randint(pow(10, 20), q)
    while gcd(q, key) != 1:
        key = random.randint(pow(10, 20), q)
    return key

# Modular exponentiation
def power(a, b, c):
    x = 1
    y = a

    while b > 0:
        if b % 2 == 0:
            x = (x * y) % c
        y = (y * y) % c
        b = int(b / 2)

    return x % c

# Asymmetric encryption
def encrypt(msg, q, h, g):
    en_msg = []

    k = gen_key(q)  # Private key for sender
    s = power(h, k, q)
    p = power(g, k, q)

    for i in range(0, len(msg)):
        en_msg.append(msg[i])

    print("g^k used : ", p)
    print("g^ak used : ", s)
    for i in range(0, len(en_msg)):
        en_msg[i] = s * ord(en_msg[i])

    return en_msg, p

def decrypt(en_msg, p, key, q):
    dr_msg = []
    h = power(p, key, q)
    for i in range(0, len(en_msg)):
        dr_msg.append(chr(int(en_msg[i] / h)))
    return dr_msg


# Driver code
def main():
    msg = 'encryption'
    print("Original Message :", msg)

    q = random.randint(pow(10, 20), pow(10, 50))
    g = random.randint(2, q)

    key = gen_key(q)  # Private key for receiver
    h = power(g, key, q)
    print("g used : ", g)
    print("g^a used : ", h)

    en_msg, p = encrypt(msg, q, h, g)
    dr_msg = decrypt(en_msg, p, key, q)
    dmsg = ''.join(dr_msg)
    print("Decrypted Message :", dmsg);


if __name__ == '__main__':
    main()

这段代码中，我们使用了Python中的随机数模块（`random`）和数学模块（`math`），其中`random.randint(a,b)`函数用于生成a到b之间的随机整数，`pow(a,b,c)`函数用于计算a的b次方然后对c取模。在实现中，我们首先定义了一个随机数a，然后依次实现了生成密钥、模幂运算、加密和解密等功能。

在主函数`main()`中，我们定义了一个明文消息（`msg`），然后随机生成了一个素数q和一个整数g。接下来，我们分别生成了私钥和公钥，用公钥加密明文，再用私钥解密密文。最后输出了解密后的明文。

### 回答2：
Elgamal加密算法是一种非对称加密算法，用于保证数据的机密性。Python中可以通过以下步骤来实现Elgamal加密算法：

1. 选择两个大质数p和g，其中p是一个比要加密的数据大的素数，g是一个大于1且小于p-1的数。

2. 选择一个随机数a，使得1<a<p-1。

3. 计算g^a mod p的值，得到公钥h。

4. 将要加密的数据转换为整数形式。

5. 选择一个随机数k，使得1<k<p-1。

6. 计算g^k mod p的值，得到临时公钥。

7. 计算h^k mod p的值，得到临时私钥。

8. 将临时公钥、临时私钥和要加密的数据进行计算，得到密文。

9. 将密文发送给接收方。

10. 接收方使用自己的私钥a和密文进行计算，得到解密后的明文。

在Python中，可以通过大数运算库gmpy2来实现上述步骤。具体代码如下：

import gmpy2

def elgamal_encrypt(message, p, g, a):
    h = gmpy2.powmod(g, a, p)
    k = gmpy2.mpz_random()
    temp_public_key = gmpy2.powmod(g, k, p)
    temp_private_key = gmpy2.powmod(h, k, p)
    ciphertext = (temp_public_key, (message * temp_private_key) % p)
    return ciphertext

def elgamal_decrypt(ciphertext, p, a):
    temp_public_key, encrypted_message = ciphertext
    temp_private_key = gmpy2.powmod(temp_public_key, a, p)
    plaintext = (encrypted_message * gmpy2.invert(temp_private_key, p)) % p
    return plaintext

p = gmpy2.next_prime(gmpy2.mpz(2048))
g = gmpy2.mpz(2)
a = gmpy2.mpz_random()

message = 1234

ciphertext = elgamal_encrypt(message, p, g, a)
plaintext = elgamal_decrypt(ciphertext, p, a)

print("密文：", ciphertext)
print("明文：", plaintext)

上述代码使用了gmpy2库来进行大数的运算，通过调用`elgamal_encrypt`函数来加密数据，调用`elgamal_decrypt`函数来解密数据。最后打印出加密后的密文和解密后的明文。

需要注意的是，在实际应用中，还需要考虑到数据的安全性，如选择合适的素数p和随机数a，并进行适当的长度选择。

### 回答3：
Elgamal加密算法是一种非对称加密算法，常用于数据加密和安全通信领域。下面是一个使用Python实现Elgamal加密算法的示例代码：

import random

# 生成大素数
def generate_prime_num():
    prime_nums = [i for i in range(1000, 2000) if all(i % j != 0 for j in range(2, int(i ** 0.5) + 1))]
    p = random.choice(prime_nums)
    return p

# 生成本原元
def generate_primitive_root(p):
    primitive_roots = []
    for x in range(2, p):
        if pow(x, p - 1, p) == 1:
            primitive_roots.append(x)
    g = random.choice(primitive_roots)
    return g

# 密钥生成
def generate_keys():
    p = generate_prime_num()
    g = generate_primitive_root(p)
    a = random.randint(2, p - 1)
    h = pow(g, a, p)
    public_key = (p, g, h)
    private_key = a
    return public_key, private_key

# 加密
def encrypt(plain_text, public_key):
    p, g, h = public_key
    r = random.randint(2, p - 1)
    c1 = pow(g, r, p)
    c2 = (plain_text * pow(h, r, p)) % p
    cipher_text = (c1, c2)
    return cipher_text

# 解密
def decrypt(cipher_text, private_key):
    c1, c2 = cipher_text
    p, _, _ = public_key
    plain_text = (c2 * pow(c1, p - 1 - private_key, p)) % p
    return plain_text

# 示例
public_key, private_key = generate_keys()
plain_text = 1234
cipher_text = encrypt(plain_text, public_key)
decrypted_text = decrypt(cipher_text, private_key)

print("公钥：", public_key)
print("私钥：", private_key)
print("明文：", plain_text)
print("加密后的密文：", cipher_text)
print("解密后的明文：", decrypted_text)

上面的代码实现了Elgamal加密算法的基本功能，包括密钥生成、加密和解密。可以根据实际需要对输入、输出进行适当修改。

使用pythonb编写elgamal加密算法

ElGamal加密算法是一种公钥加密算法，它基于离散对数问题，包括加密和解密两个部分。下面是使用Python实现ElGamal加密算法的示例代码：

import random
from math import gcd

def generate_key(p):
    g = random.randint(2, p-1)
    x = random.randint(2, p-2)
    y = pow(g, x, p)
    return (p, g, y, x)

def encrypt(plain_text, p, g, y):
    k = random.randint(2, p-2)
    a = pow(g, k, p)
    b = (plain_text * pow(y, k, p)) % p
    return (a, b)

def decrypt(cipher_text, p, x):
    a, b = cipher_text
    s = pow(a, x, p)
    s_inv = pow(s, -1, p)
    plain_text = (b * s_inv) % p
    return plain_text

if __name__ == '__main__':
    p = 71
    key = generate_key(p)
    print("Public key: ", key[0], key[1], key[2])
    print("Private key: ", key[3])
    plain_text = 47
    print("Plain text: ", plain_text)
    cipher_text = encrypt(plain_text, *key[:3])
    print("Cipher text: ", cipher_text)
    decrypted_text = decrypt(cipher_text, *key[0:1], key[3])
    print("Decrypted text: ", decrypted_text)

在这个示例中，我们首先定义了三个函数：generate_key用于生成公钥和私钥，encrypt用于加密明文，decrypt用于解密密文。然后我们定义了一个简单的示例，使用这些函数来生成密钥对、加密和解密一条消息。在这个示例中，我们使用了一个71位的素数p作为模数，但实际上在安全实践中，p应该选择更大的值。

运行这个程序，我们可以得到以下输出：

Public key:  71 3 32
Private key:  16
Plain text:  47
Cipher text:  (20, 43)
Decrypted text:  47

这个示例中，我们生成了一个ElGamal密钥对，使用密钥对明文进行加密，并使用私钥对密文进行解密。解密后，我们得到的明文与原始明文相同。