Obtención de la excepción java.security.InvalidKeyException: Longitud de la clave AES inválida: ¿29 bytes?

Question

Cuando se ejecuta debajo del programa, obtengo esta excepción. ¿No es capaz de descubrir qué problema con AES permite la clave de 128 -256 bits?

Exception in thread "main" java.security.InvalidKeyException: Invalid AES key length: 29 bytes 
at com.sun.crypto.provider.AESCipher.engineGetKeySize(DashoA13*..) 
at javax.crypto.Cipher.b(DashoA13*..) 

Obtención de excepción en la línea 20

Aquí está el programa de

import java.security.Key; 

import javax.crypto.Cipher; 
import javax.crypto.spec.SecretKeySpec; 

import sun.misc.BASE64Decoder; 
import sun.misc.BASE64Encoder; 

public class AESEncryptionDecryptionTest { 

    private static final String ALGORITHM  = "AES"; 
    private static final String myEncryptionKey = "ThisIsSecurityKey"; 
    private static final String UNICODE_FORMAT = "UTF8"; 

    public static String encrypt(String valueToEnc) throws Exception { 
Key key = generateKey(); 
Cipher c = Cipher.getInstance(ALGORITHM); 
c.init(Cipher.ENCRYPT_MODE, key); //////////LINE 20 
byte[] encValue = c.doFinal(valueToEnc.getBytes()); 
String encryptedValue = new BASE64Encoder().encode(encValue); 
return encryptedValue; 
    } 

public static String decrypt(String encryptedValue) throws Exception { 
Key key = generateKey(); 
Cipher c = Cipher.getInstance(ALGORITHM); 
c.init(Cipher.DECRYPT_MODE, key); 
byte[] decordedValue = new BASE64Decoder().decodeBuffer(encryptedValue); 
byte[] decValue = c.doFinal(decordedValue); 
String decryptedValue = new String(decValue); 
return decryptedValue; 
} 

private static Key generateKey() throws Exception { 
byte[] keyAsBytes; 
keyAsBytes = myEncryptionKey.getBytes(UNICODE_FORMAT); 
Key key = new SecretKeySpec(keyAsBytes, ALGORITHM); 
return key; 
} 

public static void main(String[] args) throws Exception { 

String value = "password1"; 
String valueEnc = AESEncryptionDecryptionTest.encrypt(value); 
String valueDec = AESEncryptionDecryptionTest.decrypt(valueEnc); 

System.out.println("Plain Text : " + value); 
System.out.println("Encrypted : " + valueEnc); 
System.out.println("Decrypted : " + valueDec); 
} 

} 

Answer 1

AES permite longitud de clave de 128, 192 o 256 bits. Eso es 16, 24 o 32 byte. Intente tomar solo los primeros 16 bytes de su mEncryptionKey como keyAsBytes.

Editar:
Una después de que se me ocurrió. Un hábito que he formado, y el que recomiendo, es tomar un hash SHA de una contraseña/frase de contraseña, y usar eso como los bytes de origen de su clave. Tomar un hash garantiza que los datos clave serán del tamaño correcto, independientemente de la duración de la contraseña/frase de contraseña. Su implementación actual del uso de los bytes String tiene dos problemas;

• Romperá la generación de su clave si alguien usa una contraseña corta.
• Dos contraseñas diferentes para las cuales los primeros 16 bytes son iguales crearán la misma clave.

Ambos problemas se eliminan mediante el uso de un hash.

Eche un vistazo al método buildKey() en esta clase; https://github.com/qwerky/DataVault/blob/master/src/qwerky/tools/datavault/DataVault.java

Answer 2

La clave utiliza la aleatoriedad como entrada, pero hay requisitos adicionales para la forma en que se compone. El constructor SecretKeySpec que utilizó es para cargar una clave ya generada en la memoria. En su lugar, use KeyGenerator.

KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM); 
kg.init(128); 
SecretKey k = kg.generateKey(); 

También tenga en cuenta que ahora se cree que AES-128 es más débil que AES-256. Probablemente no sea drásticamente diferente, pero el beneficio del tamaño de clave más largo puede ser compensado por las simplificaciones en otros lugares (menos rondas).