Implementing data encryption and decryption with Java Streams API

15 Sep 2023

encryption

Data security is a crucial aspect of software development, especially when handling sensitive information. One commonly used technique to safeguard data is encryption. In this blog post, we will explore how to implement data encryption and decryption using the Java Streams API.

What is the Java Streams API?

The Java Streams API is a powerful tool introduced in Java 8 that allows developers to work with collections and process data in a functional and declarative way. It provides a convenient way to perform operations on data such as filtering, mapping, and reducing.

Encrypting Data with Java Streams API

To encrypt data using the Java Streams API, we can take advantage of the CipherOutputStream class provided by the Java Cryptography Architecture. Let’s see how we can encrypt a string using the AES encryption algorithm:

import javax.crypto.Cipher;
import javax.crypto.CipherOutputStream;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.security.spec.KeySpec;

public class DataEncryption {

    public static void encryptData(String data, String password, String outputFile) throws Exception {
        // Generate a secret key using a password and salt
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), 65536, 256);
        SecretKey secretKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");

        // Initialize the Cipher instance
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);

        // Create a CipherOutputStream to write encrypted data
        CipherOutputStream cipherOutputStream = new CipherOutputStream(
                new BufferedOutputStream(new FileOutputStream(outputFile)), cipher);

        // Write the encrypted data to the output stream
        OutputStreamWriter writer = new OutputStreamWriter(cipherOutputStream);
        writer.write(data);
        writer.close();
    }

    public static void main(String[] args) {
        try {
            String data = "This is a secret message!";
            String password = "myStrongPassword";
            String outputFile = "encrypted_data.txt";

            encryptData(data, password, outputFile);

            System.out.println("Data encrypted successfully.");
        } catch (Exception e) {
            System.out.println("Error encrypting data: " + e.getMessage());
        }
    }
}

In this code snippet, we first generate a secret key using a password and salt. We then initialize the Cipher instance using the AES encryption algorithm with CBC mode and PKCS5 padding. Finally, we create a CipherOutputStream to write the encrypted data to a file.

Decrypting Data with Java Streams API

Decrypting data is a similar process to encrypting data. We can use the CipherInputStream class to read the encrypted data and decrypt it. Here’s an example:

import javax.crypto.Cipher;
import javax.crypto.CipherInputStream;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.security.spec.KeySpec;

public class DataDecryption {

    public static String decryptData(String password, String inputFile) throws Exception {
        // Generate a secret key using a password and salt
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt.getBytes(), 65536, 256);
        SecretKey secretKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");

        // Initialize the Cipher instance
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, secretKey);

        // Create a CipherInputStream to read the encrypted data
        CipherInputStream cipherInputStream = new CipherInputStream(
                new BufferedInputStream(new FileInputStream(inputFile)), cipher);

        // Read the decrypted data from the input stream
        InputStreamReader reader = new InputStreamReader(cipherInputStream);
        StringBuilder decryptedData = new StringBuilder();
        int character;
        while ((character = reader.read()) != -1) {
            decryptedData.append((char) character);
        }
        reader.close();

        return decryptedData.toString();
    }

    public static void main(String[] args) {
        try {
            String password = "myStrongPassword";
            String inputFile = "encrypted_data.txt";

            String decryptedData = decryptData(password, inputFile);

            System.out.println("Decrypted data: " + decryptedData);
        } catch (Exception e) {
            System.out.println("Error decrypting data: " + e.getMessage());
        }
    }
}

In the above code, we generate the secret key using the same password and salt as during encryption. We then initialize the Cipher instance with the same parameters. Finally, we create a CipherInputStream to read the encrypted data from a file and decrypt it.

Conclusion

Implementing data encryption and decryption with the Java Streams API can help ensure the security of sensitive information. The examples shown in this blog post demonstrate how to encrypt and decrypt data using the AES encryption algorithm. Remember to use strong passwords and secure storage mechanisms for the encryption key to enhance the security of your encrypted data.

#encryption #java