elgamal key generator Algorithm

The ElGamal key generator algorithm is an asymmetric cryptographic algorithm, which was invented by Tahir ElGamal in 1985. It is based on the Diffie-Hellman key exchange protocol and is widely used in secure data communication for encryption, decryption, and digital signatures. The primary advantage of the ElGamal algorithm is its ability to provide efficient and secure encryption, ensuring confidentiality and authenticity of data transmitted over an insecure channel. The ElGamal key generation algorithm involves three main steps: setup, key generation, and key exchange. In the setup phase, a large prime number 'p' and a primitive root 'g' modulo 'p' are chosen as the public parameters. Next, the key generation phase requires the selection of a random private key 'a' from the range of integers {1, 2, ..., p-2}. The corresponding public key 'A' is then calculated as A = g^a mod p. The private key 'a' is kept secret by the owner, while the public key 'A', along with the public parameters 'p' and 'g', are shared with the intended communication partner. During the key exchange phase, both parties can securely compute a shared secret key to encrypt and decrypt messages using their respective private and public keys, without revealing any sensitive information over the insecure channel. The strength of the ElGamal algorithm lies in the computational difficulty of solving the discrete logarithm problem, which ensures the security of the exchanged keys. 
import os
import random
import sys
 
import cryptomath_module as cryptoMath
import rabin_miller as rabinMiller
 
min_primitive_root = 3
 
 
def main():
    print("Making key files...")
    makeKeyFiles("elgamal", 2048)
    print("Key files generation successful")
 
 
# I have written my code naively same as definition of primitive root
# however every time I run this program, memory exceeded...
# so I used 4.80 Algorithm in Handbook of Applied Cryptography(CRC Press, ISBN : 0-8493-8523-7, October 1996)
# and it seems to run nicely!
def primitiveRoot(p_val):
    print("Generating primitive root of p")
    while True:
        g = random.randrange(3, p_val)
        if pow(g, 2, p_val) == 1:
            continue
        if pow(g, p_val, p_val) == 1:
            continue
        return g
 
 
def generateKey(keySize):
    print("Generating prime p...")
    p = rabinMiller.generateLargePrime(keySize)  # select large prime number.
    e_1 = primitiveRoot(p)  # one primitive root on modulo p.
    d = random.randrange(3, p)  # private_key -> have to be greater than 2 for safety.
    e_2 = cryptoMath.findModInverse(pow(e_1, d, p), p)
 
    publicKey = (keySize, e_1, e_2, p)
    privateKey = (keySize, d)
 
    return publicKey, privateKey
 
 
def makeKeyFiles(name, keySize):
    if os.path.exists("%s_pubkey.txt" % name) or os.path.exists(
        "%s_privkey.txt" % name
    ):
        print("\nWARNING:")
        print(
            '"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n'
            "Use a different name or delete these files and re-run this program."
            % (name, name)
        )
        sys.exit()
 
    publicKey, privateKey = generateKey(keySize)
    print("\nWriting public key to file %s_pubkey.txt..." % name)
    with open("%s_pubkey.txt" % name, "w") as fo:
        fo.write(
            "%d,%d,%d,%d" % (publicKey[0], publicKey[1], publicKey[2], publicKey[3])
        )
 
    print("Writing private key to file %s_privkey.txt..." % name)
    with open("%s_privkey.txt" % name, "w") as fo:
        fo.write("%d,%d" % (privateKey[0], privateKey[1]))
 
 
if __name__ == "__main__":
    main()

LANGUAGE:

DARK MODE:

PROGRAMMING LANGUAGES:

Python

Java

Javascript

C#

C++

C

Ruby

Scala

MATLAB

Kotlin

Rust

R

Go