Add: ElGamal Encryption Algorithm with tests

Author: Shewale41

src/main/java/com/thealgorithms/ciphers/ElGamalEncryption.java

@@ -1,9 +1,3 @@
-/*
- * TheAlgorithms (https://github.com/TheAlgorithms/Java)
- * Author: Shewale41
- * This file is licensed under the MIT License.
- */
-
 package com.thealgorithms.ciphers;
 
 import java.math.BigInteger;
@@ -12,44 +6,49 @@
 /**
  * Implementation of the ElGamal Encryption Algorithm.
  *
- * <p>This algorithm is based on the Diffie–Hellman key exchange and provides secure
- * public-key encryption and decryption using modular arithmetic.
+ * <p>ElGamal is an asymmetric key encryption algorithm based on
+ * the Diffie–Hellman key exchange. It uses randomization
+ * for security and is widely used in cryptographic systems.</p>
  *
- * <p>Reference:
- * https://en.wikipedia.org/wiki/ElGamal_encryption
+ * <p>Reference: Menezes, van Oorschot, and Vanstone, "Handbook of Applied Cryptography"</p>
  */
 public final class ElGamalEncryption {
 
     private static final SecureRandom RANDOM = new SecureRandom();
 
-    /** Private constructor to prevent instantiation of utility class. */
+    // Private constructor to prevent instantiation
     private ElGamalEncryption() {
         throw new UnsupportedOperationException("Utility class");
     }
 
     /**
-     * Demonstrates ElGamal encryption and decryption for a given message.
+     * Runs the ElGamal encryption and decryption demonstration.
      *
-     * @param message the message to encrypt
-     * @param bitLength the bit length for the prime number used
+     * @param message the plaintext message to encrypt
+     * @param bitLength the bit length for prime generation
      */
-    public static void runElGamal(String message, int bitLength) {
-        BigInteger p = BigInteger.probablePrime(bitLength, RANDOM); // prime modulus
-        BigInteger g = new BigInteger("2"); // primitive root
-        BigInteger x = new BigInteger(bitLength - 2, RANDOM); // private key
-        BigInteger y = g.modPow(x, p); // public key
+    @SuppressWarnings({"PMD.SystemPrintln", "PMD.DataflowAnomalyAnalysis"})
+    public static void runElGamal(final String message, final int bitLength) {
+        // Key generation
+        final BigInteger p = BigInteger.probablePrime(bitLength, RANDOM);
+        final BigInteger g = new BigInteger("2");
+        final BigInteger x = new BigInteger(bitLength - 2, RANDOM);
+        final BigInteger y = g.modPow(x, p);
 
         // Encryption
-        BigInteger k = new BigInteger(bitLength - 2, RANDOM);
-        BigInteger a = g.modPow(k, p);
-        BigInteger m = new BigInteger(message.getBytes());
-        BigInteger b = (y.modPow(k, p).multiply(m)).mod(p);
+        final BigInteger k = new BigInteger(bitLength - 2, RANDOM);
+        final BigInteger a = g.modPow(k, p);
+        final BigInteger m = new BigInteger(message.getBytes());
+        final BigInteger b = (y.modPow(k, p).multiply(m)).mod(p);
 
         // Decryption
-        BigInteger aInverse = a.modPow(p.subtract(BigInteger.ONE).subtract(x), p);
-        BigInteger decrypted = (b.multiply(aInverse)).mod(p);
+        final BigInteger aInverse = a.modPow(p.subtract(BigInteger.ONE).subtract(x), p);
+        final BigInteger decrypted = (b.multiply(aInverse)).mod(p);
 
+        // Display results
         System.out.println("Prime (p): " + p);
+        System.out.println("Generator (g): " + g);
+        System.out.println("Private Key (x): " + x);
         System.out.println("Public Key (y): " + y);
         System.out.println("Ciphertext: (" + a + ", " + b + ")");
         System.out.println("Decrypted Message: " + new String(decrypted.toByteArray()));

src/test/java/com/thealgorithms/ciphers/ElGamalEncryptionTest.java

@@ -1,29 +1,34 @@
-/*
- * TheAlgorithms (https://github.com/TheAlgorithms/Java)
- * Author: Shewale41
- * This file is licensed under the MIT License.
- */
-
 package com.thealgorithms.ciphers;
 
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import org.junit.jupiter.api.Test;
 
 /**
- * Tests for {@link ElGamalEncryption}.
+ * Unit tests for {@link ElGamalEncryption}.
  */
 public class ElGamalEncryptionTest {
 
     @Test
     void testEncryptionDecryption() {
-        String message = "Hello";
-        assertDoesNotThrow(() -> ElGamalEncryption.runElGamal(message, 32));
+        // Basic functional test (simulated output check)
+        // Since ElGamal uses randomization, we only verify successful execution
+        try {
+            ElGamalEncryption.runElGamal("Hello", 64);
+        } catch (Exception e) {
+            throw new AssertionError("ElGamalEncryption failed with exception: " + e.getMessage());
+        }
     }
 
     @Test
-    void testWithDifferentBitLengths() {
-        assertDoesNotThrow(() -> ElGamalEncryption.runElGamal("Test", 16));
-        assertDoesNotThrow(() -> ElGamalEncryption.runElGamal("Secure", 64));
+    void testUtilityConstructor() {
+        // Ensures the utility class constructor is private
+        try {
+            var constructor = ElGamalEncryption.class.getDeclaredConstructor();
+            constructor.setAccessible(true);
+            constructor.newInstance();
+        } catch (Exception e) {
+            assertEquals("Utility class", e.getCause().getMessage());
+        }
     }
 }