AES-PKCS7-padding

Wenn Sie angeben, PKCS7 -, BC wird die Polsterung um die Daten vor der Verschlüsselung, und entfernen Sie es wieder, wenn die Entschlüsselung. PKCS7 - mit AES würde immer mindestens 1 byte padding, und fügen Sie genug Daten, um die Eingabe ein Vielfaches der AES-block-Größe. Beim entschlüsseln der Polsterung ist überprüft korrekt zu sein, und im Falle von PKCS7 dienen auch als Indikator, wie viel der Letzte block der entschlüsselten Daten ist die Polsterung, und wie viel ist real Daten.

Wenn Sie versuchen, entschlüsseln der verschlüsselten und gepolsterte Daten ohne Angabe PKCS7 in den entschlüsseln-Schritt, die Polsterung wäre noch in den entschlüsselten Daten.

Edit:

Zu meinen Standpunkt zu verdeutlichen .. hier ist einige Java-code, der verschlüsselt "1234567890" mit AES/CBC/PKCS7 -, und dann entschlüsselt es wieder mit und ohne PKCS7 padding:

public class BCTest {
    public static void doTest() throws Exception {
        Security.addProvider(new BouncyCastleProvider());

        byte[] clearData = "1234567890".getBytes();
        SecretKey secretKey = new SecretKeySpec("0123456789ABCDEF".getBytes(), "AES");
        AlgorithmParameterSpec IVspec = new IvParameterSpec("0123456789ABCDEF".getBytes());

        //encrypt with PKCS7 padding
        Cipher encrypterWithPad = Cipher.getInstance("AES/CBC/PKCS7PADDING", "BC");
        encrypterWithPad.init(Cipher.ENCRYPT_MODE, secretKey, IVspec);
        byte[] encryptedData = encrypterWithPad.doFinal(clearData);
        System.out.println("Encryped data (" + encryptedData.length + " bytes): \t" + toHexString(encryptedData));

        //decrypt with PKCS7 pad
        Cipher decrypterWithPad = Cipher.getInstance("AES/CBC/PKCS7PADDING", "BC");
        decrypterWithPad.init(Cipher.DECRYPT_MODE, secretKey, IVspec);
        byte[] buffer1 = new byte[encryptedData.length]; 
        int decryptLen1 = decrypterWithPad.doFinal(encryptedData, 0, encryptedData.length, buffer1); 
        System.out.println("Decrypted with Pad (" + decryptLen1 + " bytes):  \t" + toHexString(buffer1));

        //decrypt without PKCS7 pad
        Cipher decrypterWithoutPad = Cipher.getInstance("AES/CBC/NOPADDING", "BC");
        decrypterWithoutPad.init(Cipher.DECRYPT_MODE, secretKey, IVspec);
        byte[] buffer2 = new byte[encryptedData.length]; 
        int decryptLen2 = decrypterWithoutPad.doFinal(encryptedData, 0, encryptedData.length, buffer2); 
        System.out.println("Decrypted without Pad (" + decryptLen2 + " bytes):\t" + toHexString(buffer2));
    }

    private static String toHexString(byte[] bytes) {
        return javax.xml.bind.DatatypeConverter.printHexBinary(bytes);
    }

    public static void main(String[] args) throws Exception {
        BCTest.doTest(); 
    }
}

Ausgabe:

Encryped data (16 bytes):           602CAE14358D0AC5C96E2D46D17E58E3
Decrypted with Pad (10 bytes):      31323334353637383930000000000000
Decrypted without Pad (16 bytes):   31323334353637383930060606060606

Beim entschlüsseln mit der Polsterung option, die Ausgabe wurde gestreift, der Polster - und der Namenszug zeigt, 10 bytes Daten entschlüsselt - der rest des Puffers wird mit 0 gefüllt. Entschlüsseln ohne die Polsterung option, die Ergebnisse in die Polsterung nun als Teil der entschlüsselten Daten.

Edit2:

Nun sehen, das original-code, bestätigt meine Vermutung. Die methode GetOutputSize nicht zurückkehren, wird die Ausgabe der Größe der entschlüsselten Zeichenfolge, sondern nur der maximale Platz brauchen, in einen Ausgabepuffer. Die methode haben die folgende Dokumentation im BC-code:

/**
* return the size of the output buffer required for an update plus a
* doFinal with an input of len bytes.
*
* @param len the length of the input.
* @return the space required to accommodate a call to update and doFinal
* with len bytes of input.
*/

DoFinal gibt die tatsächliche Länge der entschlüsselten Daten im Puffer.

So, in

byte[] plainTextBuffer = new byte[cipher.GetOutputSize(data.Length - IV_LENGTH)];
int length = cipher.DoFinal(data, iv.Length, data.Length - iv.Length, plainTextBuffer, 0);

Den plainTextBuffer wäre etwas größer als die eigentlichen Daten entschlüsselt - die tatsächliche Länge der Daten wäre in length.

InformationsquelleAutor Ebbe M. Pedersen