Encriptar y desencriptar con codificación AES y Base64

Question

Tengo el siguiente programa para encriptar datos.

import java.security.Key; 

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

import org.apache.commons.codec.binary.Base64; 

public class Test { 

    private static final String ALGORITHM = "AES"; 
    private static final byte[] keyValue = "ADBSJHJS12547896".getBytes(); 

    public static void main(String args[]) throws Exception { 
     String encriptValue = encrypt("dude5"); 
     decrypt(encriptValue); 

    } 

    /** 
    * @param args 
    * @throws Exception 
    */ 

    public static String encrypt(String valueToEnc) throws Exception { 

     Key key = generateKey(); 
     Cipher c = Cipher.getInstance(ALGORITHM); 
     c.init(Cipher.ENCRYPT_MODE, key); 

     System.out.println("valueToEnc.getBytes().length "+valueToEnc.getBytes().length); 
     byte[] encValue = c.doFinal(valueToEnc.getBytes()); 
     System.out.println("encValue length" + encValue.length); 
     byte[] encryptedByteValue = new Base64().encode(encValue); 
     String encryptedValue = encryptedByteValue.toString(); 
     System.out.println("encryptedValue " + encryptedValue); 

     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[] enctVal = c.doFinal(encryptedValue.getBytes()); 
     System.out.println("enctVal length " + enctVal.length); 

     byte[] decordedValue = new Base64().decode(enctVal); 

     return decordedValue.toString(); 
    } 

    private static Key generateKey() throws Exception { 
     Key key = new SecretKeySpec(keyValue, ALGORITHM); 
     return key; 
    } 

} 

Aquí recibo lo siguiente con excepción?

valueToEnc.getBytes().length 5 
encValue length16 
encryptedValue [B@aa9835 
Exception in thread "main" javax.crypto.IllegalBlockSizeException: Input length must be multiple of 16 when decrypting with padded cipher 
    at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..) 
    at com.sun.crypto.provider.SunJCE_f.b(DashoA13*..) 

¿Puede alguien explicarme la causa? ¿Por qué solo dice al descifrar esa longitud debe ser 16. No se convierte a 16 como al igual que el cifrado con el método doFinal.

Y como la excepción dice "cómo descifrar sin cifrado acolchado?"

Answer 1

su orden para cifrar:getBytes, cifrar, codificar, toString
su pedido de descifrar:getBytes, descifrar, decodificar, toString

dos problemas:

1. Como alguien ya ha mencionado, debe invertir el orden de las operaciones para d ecryption. No estás haciendo eso.
2. encrypt le da 16 bytes, codifica 24 bytes, pero toString da 106 bytes. Algo relacionado con los caracteres inválidos que ocupan espacio adicional.

Nota: Además, no es necesario que llame al generateKey() dos veces.

Solucione el problema n. ° 1 utilizando el orden inverso para el descifrado. orden correcto:getBytes, decodificar, descifrar, toString
problema de la reparación # 2 mediante la sustitución de xxx.toString() con new String(xxx). Haga esto en las funciones de cifrado y descifrado.

Su descifrar debería tener este aspecto:

c.init(Cipher.DECRYPT_MODE, key) 
val decodedValue = new Base64().decode(encryptedValue.getBytes()) 
val decryptedVal = c.doFinal(decodedValue) 
return new String(decryptedVal) 

Esto debe darle la espalda "dude5"

Answer 2

Fundamentalmente, existe una asimetría entre su función de cifrado y su función de descifrado. Cuando cifra, realiza un cifrado AES y luego una codificación base64; al descifrar, no debe deshacer primero el paso de codificación base64.

Creo que hay algo mal con la codificación base64, así como [ no debería aparecer en una cadena codificada en base64.

En cuanto a la documentación para org.apache.commons.codec.binary.Base64 usted debería ser capaz de hacer esto en codificar:

String encryptedValue = Base64.encodeBase64String(encValue); 

y esto de decodificación:

byte[] encValue = Base64.decodeBase64(encryptedValue); 

Answer 3

La línea

String encryptedValue = encryptedByteValue.toString(); 

es el problema. El tipo de encryptedByteValue es byte [] y llamar a String no es lo que quieres hacer allí. En lugar de tratar

String encryptedValue = Base64.getEncoder().encodeToString(encValue); 

A continuación, utilice Base64.decodeBase64(encryptedValue) en descifrar. Debe hacer eso antes de intentar descifrar sin embargo. Debe deshacer las operaciones en el orden inverso al método de cifrado.

Answer 4

¿Dónde obtiene una versión del códec de Apache que tiene encodeToString o encodeBase64String?

He descargado 1.5 del sitio apache y, aunque dice en la documentación que estos métodos existen, no aparecen cuando se completa el código y crean un método desconocido cuando se los proporciona.

que era capaz de hacer:

byte raw[] = md.digest(); //step 4 
byte hashBytes[] = Base64.encodeBase64(raw); //step 5 
StringBuffer buffer = new StringBuffer(); 
for(int i=0; i<hashBytes.length; i++) 
    buffer.append(hashBytes[i]); 
return buffer.toString(); //step 6 

Y a continuación, la cadena que obtuve fue muy largo, pero se descifra correctamente.

No creo que esta sea la forma "correcta" de hacer las cosas, pero no puedo encontrar los métodos que la documentación dice que están ahí.

Answer 5

tengo sustituye a la línea en el ejemplo:

String encryptedValue = encryptedByteValue.toString(); 

con una próxima:

String encryptedValue = new String(encryptedByteValue); 

¡Todo funciona bien!

Answer 6

Eso estaba bien, sólo necesita para

1) Utilice nueva cadena en lugar de toString() desde toString() no devuelve lo que necesita aquí (en ambos casos, el cifrado y descifrado)

2) primero necesita descodificar, ya que el valor se codifica en base64.

Me encontré con este hilo, pero me llevó un tiempo descubrir el punto real. Estoy publicando mi código para el resto de las personas que se encuentran con este problema.

public abstract class EncryptionDecryption { 
static byte[] key = "!@#$!@#$%^&**&^%".getBytes(); 
final static String algorithm="AES"; 

public static String encrypt(String data){ 

    byte[] dataToSend = data.getBytes(); 
    Cipher c = null; 
    try { 
     c = Cipher.getInstance(algorithm); 
    } catch (NoSuchAlgorithmException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (NoSuchPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    SecretKeySpec k = new SecretKeySpec(key, algorithm); 
    try { 
     c.init(Cipher.ENCRYPT_MODE, k); 
    } catch (InvalidKeyException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    byte[] encryptedData = "".getBytes(); 
    try { 
     encryptedData = c.doFinal(dataToSend); 
    } catch (IllegalBlockSizeException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (BadPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    byte[] encryptedByteValue = new Base64().encode(encryptedData); 
    return new String(encryptedByteValue);//.toString(); 
} 

public static String decrypt(String data){ 

    byte[] encryptedData = new Base64().decode(data); 
    Cipher c = null; 
    try { 
     c = Cipher.getInstance(algorithm); 
    } catch (NoSuchAlgorithmException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (NoSuchPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    SecretKeySpec k = 
      new SecretKeySpec(key, algorithm); 
    try { 
     c.init(Cipher.DECRYPT_MODE, k); 
    } catch (InvalidKeyException e1) { 
     // TODO Auto-generated catch block 
     e1.printStackTrace(); 
    } 
    byte[] decrypted = null; 
    try { 
     decrypted = c.doFinal(encryptedData); 
    } catch (IllegalBlockSizeException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } catch (BadPaddingException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    } 
    return new String(decrypted); 
} 

public static void main(String[] args){ 
    String password=EncryptionDecryption.encrypt("password123"); 
    System.out.println(password); 
    System.out.println(EncryptionDecryption.decrypt(password)); 
} 
}