Java Security Mechanism: Implementation of Encryption and Decryption Algorithms in Java

In modern software development, data security is a crucial topic. Encryption technology can protect sensitive information from unauthorized access. In this article, we will introduce how to implement basic encryption and decryption algorithms in Java.

1. Basic Concepts of Encryption and Decryption

Encryption: The process of converting plaintext (readable information) into an unreadable form (ciphertext) to prevent unauthorized access.
Decryption: The process of converting ciphertext back into plaintext so that legitimate users can read the information.

Common symmetric encryption algorithms include AES, DES, and 3DES, while asymmetric encryption algorithms include RSA, among others. This article mainly focuses on the AES algorithm in symmetric encryption.

2. AES Encryption and Decryption Principles

AES (Advanced Encryption Standard) is a widely used symmetric encryption algorithm that uses the same key for both encryption and decryption. AES supports different key lengths, including 128 bits, 192 bits, and 256 bits.

Workflow

Generate Key: Create a key for subsequent operations.
Initialization Vector (IV): Used to enhance security, ensuring that the same data produces different outputs each time.
Execute Encryption/Decryption Operations: Process data using a specified mode (e.g., CBC mode).

3. Implementing AES Encryption/Decryption in Java

Below is a simple example demonstrating how to implement basic AES functionality in Java:

Example Code

import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;
public class AESCryptography {
    private static final String ALGORITHM = "AES";    private static final String TRANSFORMATION = "AES/CBC/PKCS5Padding";    private static final String IV = "1234567890123456"; // Must be 16 bytes long
    // Create Key    public static SecretKey generateKey() throws Exception {        KeyGenerator keyGen = KeyGenerator.getInstance(ALGORITHM);        keyGen.init(128); // Can choose 128, 192, or 256 bits        return keyGen.generateKey();    }
    // Encrypt    public static String encrypt(String data, SecretKey secretKey) throws Exception {        Cipher cipher = Cipher.getInstance(TRANSFORMATION);        IvParameterSpec ivParams = new IvParameterSpec(IV.getBytes());        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParams);
        byte[] encryptedBytes = cipher.doFinal(data.getBytes());        return Base64.getEncoder().encodeToString(encryptedBytes);    }
    // Decrypt    public static String decrypt(String encryptedData, SecretKey secretKey) throws Exception {        Cipher cipher = Cipher.getInstance(TRANSFORMATION);        IvParameterSpec ivParams = new IvParameterSpec(IV.getBytes());        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParams);
        byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));        return new String(decryptedBytes);    }
    public static void main(String[] args) {        try {            SecretKey secretKey = generateKey();            String originalData = "Hello World!";
            System.out.println("Original Data: " + originalData);
            // Encrypt            String encryptedData = encrypt(originalData, secretKey);            System.out.println("Encrypted Data: " + encryptedData);
            // Decrypt            String decryptedData = decrypt(encryptedData, secretKey);            System.out.println("Decrypted Data: " + decryptedData);
        } catch (Exception e) {            e.printStackTrace();        }    }
}

Code Analysis

Generate Key:

Use the generateKey method to generate a random key, which utilizes the javax.crypto.KeyGenerator class to create an AES key of specified length (here, 128 bits).

Data Encryption:

encrypt method takes a plaintext string and a key as parameters, initializes the Cipher object by setting the mode to AES/CBC/PKCS5Padding, and completes the actual data processing by calling the doFinal() method, returning the result encoded as a Base64 string.

Data Decryption:

decrypt method is similar to the above process, but it first restores the Base64 encoded data before parsing it, ultimately returning the plaintext string.

Main Function Test:

In the main function, we demonstrate how to generate a key, encrypt data, and subsequently decode it, printing the results for verification.

Conclusion

Through the above example, we learned how to implement a simple yet effective data security mechanism in Java. Although this example only covers the basics, it lays the foundation for understanding more complex systems. In practical applications, be sure to manage your private keys and other sensitive information carefully to ensure the overall security of the system.