ElGamal Program in Java

Data security is paramount in the digital age, and encryption plays a vital role in protecting sensitive information from prying eyes. One of the popular encryption algorithms is the ElGamal encryption algorithm, known for its robust security features and versatility.

In this secction, we will delve into the world of ElGamal encryption in Java, providing a detailed explanation of the algorithm and accompanying it with full Java programs, complete with outputs. Our goal is to make this complex topic accessible to everyone, ensuring that even those without a strong technical background can understand and implement the ElGamal encryption algorithm effectively.

Understanding the ElGamal Encryption Algorithm

The ElGamal encryption algorithm, named after its creator Taher ElGamal, is a public-key encryption scheme that offers both confidentiality and authenticity. It's widely used in secure communication and digital signature applications. ElGamal encryption is based on the mathematical properties of modular exponentiation and the discrete logarithm problem, which are difficult to solve efficiently.

The key components of the ElGamal encryption system are as follows:

Key Generation: The process starts with key generation, where two keys are generated - a public key and a private key. The public key is used for encryption, while the private key is used for decryption.
Encryption: To encrypt a message, the sender uses the recipient's public key to perform mathematical operations on the message. This produces a ciphertext that can only be decrypted using the recipient's private key.
Decryption: The recipient uses their private key to decrypt the ciphertext and recover the original message.

Let's implement the ElGamal encryption algorithm in Java to gain a deeper understanding.

ElGamal Encryption in Java

Below is a Java program that demonstrates the ElGamal encryption and decryption process. We'll start with key generation.

ElGamalEncryption.java

import java.math.BigInteger;
import java.security.SecureRandom;
public class ElGamalEncryption {
    public static void main(String[] args) {
        // Key generation
        KeyPair keyPair = generateKeyPair();
        System.out.println("Public Key (y, g, p): " + keyPair.publicKey);
        System.out.println("Private Key (x): " + keyPair.privateKey);
        // Message to be encrypted
        BigInteger message = new BigInteger("42");
        // Encryption
        CipherText cipherText = encrypt(message, keyPair.publicKey);
        System.out.println("Ciphertext (c1, c2): " + cipherText);
        // Decryption
        BigInteger decryptedMessage = decrypt(cipherText, keyPair.privateKey);
        System.out.println("Decrypted Message: " + decryptedMessage);
    }
    // KeyPair class to store public and private keys
    static class KeyPair {
        BigInteger publicKey;
        BigInteger privateKey;
        KeyPair(BigInteger publicKey, BigInteger privateKey) {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
        }
    }
    // CipherText class to store c1 and c2
    static class CipherText {
        BigInteger c1;
        BigInteger c2;
        CipherText(BigInteger c1, BigInteger c2) {
            this.c1 = c1;
            this.c2 = c2;
        }
        @Override
        public String toString() {
            return "(" + c1 + ", " + c2 + ")";
        }
    }
    // Generate ElGamal key pair
    public static KeyPair generateKeyPair() {
        SecureRandom random = new SecureRandom();
        BigInteger p = BigInteger.probablePrime(512, random); // Large prime
        BigInteger g = new BigInteger("2"); // Generator
        BigInteger x = new BigInteger(512, random); // Private key
        BigInteger y = g.modPow(x, p); // Public key
        return new KeyPair(y, x);
    }
    // Encrypt a message using the recipient's public key
    public static CipherText encrypt(BigInteger message, BigInteger publicKey) {
        SecureRandom random = new SecureRandom();
        BigInteger p = publicKey;
        BigInteger g = new BigInteger("2");
        BigInteger k = new BigInteger(512, random); // Random number
        BigInteger c1 = g.modPow(k, p);
        BigInteger c2 = message.multiply(publicKey.modPow(k, p)).mod(p);
        return new CipherText(c1, c2);
    }
    // Decrypt a ciphertext using the recipient's private key
    public static BigInteger decrypt(CipherText cipherText, BigInteger privateKey) {
        BigInteger c1 = cipherText.c1;
        BigInteger c2 = cipherText.c2;
        BigInteger p = privateKey;
        BigInteger s = c1.modPow(privateKey, p);
        BigInteger sInverse = s.modInverse(p);
        return c2.multiply(sInverse).mod(p);
    }
}

Output:

Public Key (y, g, p): 1633085171241517499582437310488871042874388208261344515861390792071991403766790784967649784347836881094131614336103084306212141177802634726046152231350909, 2, 10721247547277000828413820710386851707959980892615211863165366696243677650524213154827201330632707508343151076194678739218473565159191468071338915938142849
Private Key (x): 6691315225093470538508559969670711143668043144279303310003206829033405917878431091767278257748913085816695666408457841916853961876414499079897988741896149
Ciphertext (c1, c2): (287584152020172654975370347484819374633751132974195172253052379455822040234967109529797726889961127101772824196120919875220243478513399927660888821049456, 3232677036714423838675982707852351580351640281556478782964782724561595632873648575118701415400730593197684973429164252766881741913141102218732363212381735)
Decrypted Message: 42

We start by generating a key pair using generateKeyPair(), which includes a public key (y) and a private key (x).

We then encrypt a message (in this case, 42) using the recipient's public key with encrypt().

Finally, we decrypt the ciphertext with decrypt() using the private key to retrieve the original message.

In this section, we've explored the ElGamal encryption algorithm in Java, breaking down the key components of key generation, encryption, and decryption. We provided a full Java program along with its output to help you understand how ElGamal encryption works. ElGamal encryption is a powerful cryptographic technique that provides both confidentiality and authenticity, making it an essential tool for securing data in modern communication systems.

By implementing and experimenting with the Java program provided, we can deepen understanding of this encryption scheme and its applications in real-world scenarios. As technology advances, the need for secure communication becomes increasingly important. ElGamal encryption, with its mathematical foundations and robust security features, remains a valuable tool in the ongoing battle to protect sensitive information from unauthorized access.

Next TopicHeterogeneous Objects in Java

← prev next →