Encryption and Decryption in Java

Java provides several algorithms for encryption and decryption of data, including symmetric-key algorithms and asymmetric-key algorithms.

1. Symmetric-key algorithms: These algorithms use the same key for both encryption and decryption. Some commonly used symmetric-key algorithms in Java include:
   1. Advanced Encryption Standard (AES)
   2. Data Encryption Standard (DES)
   3. Blowfish
   4. Twofish
2. Asymmetric-key algorithms: These algorithms use different keys for encryption and decryption. They are typically used for secure communication between two parties, such as in public key cryptography. Some commonly used asymmetric-key algorithms in Java include:
   1. RSA (Rivest-Shamir-Adleman)
   2. Elliptic Curve Cryptography (ECC)
   3. Diffie-Hellman key exchange

Java provides built-in classes and interfaces for implementing these encryption and decryption algorithms, such as the javax.crypto package for symmetric-key algorithms and the java.security package for asymmetric-key algorithms. Additionally, third-party libraries and frameworks are also available for implementing encryption and decryption in Java.

Advanced Encryption Standard (AES)

The Advanced Encryption Standard (AES) is a symmetric-key encryption algorithm.

• AES is a block cipher, which means that it encrypts data in fixed-size blocks, with each block being processed independently.
• AES uses a variable-length key that can be either 128, 192, or 256 bits long.
• The algorithm consists of a series of encryption and decryption rounds, with the number of rounds depending on the length of the key.

AES Encryption process

During the encryption process, AES divides the plaintext message into fixed-size blocks and applies a series of substitutions and transformations to each block, based on the key.
These operations include:

• substitution with a fixed substitution table,
• a row-shifting operation,
• a column-mixing operation, and
• an XOR operation with a round key.
  The resulting output from each round is used as the input to the next round.

AES Decryption process

During decryption process, the inverse operations are applied to the ciphertext blocks using the same key, in reverse order.
The decryption process is as follow

• starts with an inverse XOR operation with the last round key,
• an inverse column-mixing operation,
• an inverse row-shifting operation, and
• an inverse substitution operation.

AES is widely used in a variety of applications, including secure communication protocols, disk encryption, and secure data storage. It has been extensively studied and tested, and is considered to be a secure and reliable encryption algorithm.

Sample example shows encrypting and decrypting plain text using AES

In this example, we define two methods - encrypt() and decrypt() - that use the AES algorithm to encrypt and decrypt a given text using a secret key.

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;

public class AESExample {

    public static void main(String[] args) throws Exception {
        String plainText = "This is a secret message!";
        String key = "mySecretKey43234";

        //Encrypt the text
        byte[] encryptedText = encrypt(plainText, key);
        System.out.println("Encrypted Text: " + new String(encryptedText));

        //Decrypt the encrypted text
        String decryptedText = decrypt(encryptedText, key);
        System.out.println("Decrypted Text: " + decryptedText);
    }

    public static byte[] encrypt(String plainText, String key) throws Exception {
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);
        byte[] encryptedText = cipher.doFinal(plainText.getBytes());
        return Base64.getEncoder().encode(encryptedText);
    }

    public static String decrypt(byte[] encryptedText, String key) throws Exception {
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(), "AES");
        Cipher cipher = Cipher.getInstance("AES");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);
        byte[] decryptedText = cipher.doFinal(Base64.getDecoder().decode(encryptedText));
        return new String(decryptedText);
    }
}