AES 256 bits/SRC/PKCS5Padding avec Château Gonflable

J'ai du mal à la cartographie de la JDK suivant la JCE code de cryptage pour les Châteaux pleins d'entrain de la Lumière-poids de l'API:

public String dec(String password, String salt, String encString) throws Throwable {
    //AES algorithm with CBC cipher and PKCS5 padding
    Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding", "BC");

    //Construct AES key from salt and 50 iterations 
    PBEKeySpec pbeEKeySpec = new PBEKeySpec(password.toCharArray(), toByte(salt), 50, 256);
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("PBEWithSHA256And256BitAES-CBC-BC");
    SecretKeySpec secretKey = new SecretKeySpec(keyFactory.generateSecret(pbeEKeySpec).getEncoded(), "AES");

    //IV seed for first block taken from first 32 bytes
    byte[] ivData = toByte(encString.substring(0, 32));
    //AES encrypted data
    byte[] encData = toByte(encString.substring(32));

    cipher.init( Cipher.DECRYPT_MODE, secretKey, new IvParameterSpec( ivData ) );

    return new String( cipher.doFinal( encData ) );
}

Ci-dessus fonctionne très bien, mais n'est pas très portable en raison de l'Oracle de la restriction sur le niveau de cryptage. J'ai fait plusieurs tentatives de portage pour les Châteaux pleins d'entrain de la Lumière-poids de l'API, mais sans succès.

public String decrypt1(String password, String salt, String encString) throws Exception {

    byte[] ivData = toByte(encString.substring(0, 32));
    byte[] encData = toByte(encString.substring(32));

    PKCS12ParametersGenerator gen = new PKCS12ParametersGenerator(new SHA256Digest());
    gen.init(password.getBytes(), toByte(salt), 50);
    CBCBlockCipher cbcBlockcipher = new CBCBlockCipher(new RijndaelEngine(256));
    CipherParameters params = gen.generateDerivedParameters(256, 256);

    cbcBlockcipher.init(false, params);

    PaddedBufferedBlockCipher aesCipher = new PaddedBufferedBlockCipher(cbcBlockcipher, new PKCS7Padding());
    byte[] plainTemp = new byte[aesCipher.getOutputSize(encData.length)];
    int offset = aesCipher.processBytes(encData, 0, encData.length, plainTemp, 0);
    int last = aesCipher.doFinal(plainTemp, offset);
    byte[] plain = new byte[offset + last];
    System.arraycopy(plainTemp, 0, plain, 0, plain.length);
    return new String(plain);
}

Au-dessus de la tentative de résultats dans un org.bouncycastle.crypto.DataLengthException: dernier bloc incomplet dans le déchiffrement.

J'ai cherché des exemples en ligne, mais il n'y a pas beaucoup d'exemples de fournir vos propres IV de données pour AES 256 bits avec CBC en utilisant PKCS5/PKCS7 comme rembourrage.

NB: Le toByte fonction convertit une Chaîne en un tableau d'octets en utilisant base64 ou similaire.

OriginalL'auteur Casper Bang | 2011-04-12

  1. 22

    Cela devrait fonctionner pour vous:

    public String dec(String password, String salt, String encString)
throws Exception {
byte[] ivData = toByte(encString.substring(0, 32));
byte[] encData = toByte(encString.substring(32));
//get raw key from password and salt
PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray(),
toByte(salt), 50, 256);
SecretKeyFactory keyFactory = SecretKeyFactory
.getInstance("PBEWithSHA256And256BitAES-CBC-BC");
SecretKeySpec secretKey = new SecretKeySpec(keyFactory.generateSecret(
pbeKeySpec).getEncoded(), "AES");
byte[] key = secretKey.getEncoded();
//setup cipher parameters with key and IV
KeyParameter keyParam = new KeyParameter(key);
CipherParameters params = new ParametersWithIV(keyParam, ivData);
//setup AES cipher in CBC mode with PKCS7 padding
BlockCipherPadding padding = new PKCS7Padding();
BufferedBlockCipher cipher = new PaddedBufferedBlockCipher(
new CBCBlockCipher(new AESEngine()), padding);
cipher.reset();
cipher.init(false, params);
//create a temporary buffer to decode into (it'll include padding)
byte[] buf = new byte[cipher.getOutputSize(encData.length)];
int len = cipher.processBytes(encData, 0, encData.length, buf, 0);
len += cipher.doFinal(buf, len);
//remove padding
byte[] out = new byte[len];
System.arraycopy(buf, 0, out, 0, len);
//return string representation of decoded bytes
return new String(out, "UTF-8");
}

    Je suppose que vous êtes en train de faire codage hexadécimal pour toByte() depuis votre code utilise 32 caractères pour le IV (qui fournit les 16 octets). Alors que je n'ai pas le code que vous avez utilisé pour faire le cryptage, je n'ai vérifier que ce code vous donnera le même déchiffré comme la sortie de votre code.

    vous êtes sûr que c'est correct de supposer la IV à être les 32 premiers caractères ? Si oui, quelle est cette fonction ?
    SecretKeyFactory keyFactory = SecretKeyFactory .getInstance("PBEWithSHA256And256BitAES-CBC-BC"); et les autres lignes ne sont pas de API légère, sont-ils?

    OriginalL'auteur WhiteFang34