How to Implement 256-bit AES Password-Based Encryption in Java

Question

How can I implement 256-bit AES password-based encryption in Java using my own passkey?

Answer

To implement 256-bit AES encryption in Java using a custom passkey, you need to derive a secret key from the passkey. This process typically involves hashing the passkey to create a key of the correct length (in this case, 32 bytes for 256 bits).

import javax.crypto.Cipher;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import javax.crypto.spec.IvParameterSpec;
import java.security.SecureRandom;
import java.util.Arrays;

public class AESExample {
    private static final String ALGORITHM = "AES";
    private static final int KEY_SIZE = 256; // AES 256-bit
    private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";

    public static byte[] encrypt(String passphrase, byte[] input) throws Exception {
        // Generate random salt
        byte[] salt = new byte[16];
        SecureRandom sr = new SecureRandom();
        sr.nextBytes(salt);
        
        // Derive key
        SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
        PBEKeySpec spec = new PBEKeySpec(passphrase.toCharArray(), salt, 65536, KEY_SIZE);
        SecretKeySpec secretKey = new SecretKeySpec(factory.generateSecret(spec).getEncoded(), ALGORITHM);

        // Initialize cipher
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, new IvParameterSpec(salt));

        // Encrypt data
        return cipher.doFinal(input);
    }
} 

// Usage
byte[] input = "Your data to encrypt".getBytes();
byte[] encryptedData = AESExample.encrypt("yourStrongPassphrase", input); // Encrypts the input data with the passphrase

// Note: Don't forget to store the salt and IV for decryption! 

// Decryption would require a similar approach with the same salt and passphrase used during encryption. 

// If using AES/CBC, remember to handle padding properly and manage IVs correctly.

Causes

The KeyGenerator approach generates a random key which may not align with your desired passkey.
Padding the password to fit 256 bits is incorrect; you need to derive the key using cryptographic hashing.

Solutions

Use a Key Derivation Function (KDF) like PBKDF2 with a secure hashing algorithm to derive a 256-bit key from your passkey.
Set up the Cipher correctly with appropriate algorithms and modes.

Common Mistakes

Mistake: Padding the password or key incorrectly, such as expanding it to 256 bytes instead of 256 bits.

Solution: Always ensure that the derived key is exactly 32 bytes long for 256-bit AES. Use a key derivation function.

Mistake: Not properly handling the initialization vector (IV) for CBC mode.

Solution: Use a random IV for each encryption and store it alongside the ciphertext for decryption.

Helpers

AES encryption
256-bit AES
Java AES encryption
Password-based encryption Java
Crypto Java
SecretKeySpec
PBKDF2 Java