Fix: Checkstyle compliance for ElGamal Encryption Algorithm

Author: Shewale41

clang-format

@@ -1,38 +1,49 @@
-package com.thealgorithms.cryptography;
+/*
+ * TheAlgorithms (https://github.com/TheAlgorithms/Java)
+ * Author: Shewale41
+ * This file is licensed under the MIT License.
+ */
+
+package com.thealgorithms.ciphers;
 
 import java.math.BigInteger;
 import java.security.SecureRandom;
 
 /**
  * Implementation of the ElGamal Encryption Algorithm.
  *
- * <p>This algorithm is based on the Diffie–Hellman key exchange and uses modular arithmetic
- * for secure public-key encryption and decryption.
+ * <p>This algorithm is based on the Diffie–Hellman key exchange and provides secure
+ * public-key encryption and decryption using modular arithmetic.
  *
  * <p>Reference:
- * https://www.geeksforgeeks.org/elgamal-encryption-algorithm/
+ * https://en.wikipedia.org/wiki/ElGamal_encryption
  */
-public class ElGamalEncryption {
+public final class ElGamalEncryption {
 
-    private static final SecureRandom random = new SecureRandom();
+    private static final SecureRandom RANDOM = new SecureRandom();
+
+    /** Private constructor to prevent instantiation of utility class. */
+    private ElGamalEncryption() {
+        throw new UnsupportedOperationException("Utility class");
+    }
 
     /**
-     * Encrypts and decrypts a given message using ElGamal encryption.
+     * Demonstrates ElGamal encryption and decryption for a given message.
      *
-     * @param message The message to encrypt.
-     * @param bitLength The bit length of the prime modulus.
+     * @param message the message to encrypt
+     * @param bitLength the bit length for the prime number used
      */
     public static void runElGamal(String message, int bitLength) {
-        BigInteger p = BigInteger.probablePrime(bitLength, random); // large prime
+        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 x = new BigInteger(bitLength - 2, RANDOM); // private key
         BigInteger y = g.modPow(x, p); // public key
 
         // Encryption
-        BigInteger k = new BigInteger(bitLength - 2, random);
+        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);
+        BigInteger m = new BigInteger(message.getBytes());
+        BigInteger b = (y.modPow(k, p).multiply(m)).mod(p);
 
         // Decryption
         BigInteger aInverse = a.modPow(p.subtract(BigInteger.ONE).subtract(x), p);

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

@@ -1,6 +1,12 @@
-package com.thealgorithms.cryptography;
+/*
+ * 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.*;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 import org.junit.jupiter.api.Test;
 
@@ -11,14 +17,12 @@ public class ElGamalEncryptionTest {
 
     @Test
     void testEncryptionDecryption() {
-        // This test ensures encryption-decryption consistency
         String message = "Hello";
-        ElGamalEncryption.runElGamal(message, 32);
-        assertTrue(true); // Basic run test - manual verification for output
+        assertDoesNotThrow(() -> ElGamalEncryption.runElGamal(message, 32));
     }
 
     @Test
-    void testDifferentBitLengths() {
+    void testWithDifferentBitLengths() {
         assertDoesNotThrow(() -> ElGamalEncryption.runElGamal("Test", 16));
         assertDoesNotThrow(() -> ElGamalEncryption.runElGamal("Secure", 64));
     }