Śledziłem większość ten post w celu wdrożenia szyfrowania AES 256 w moim oprogramowaniu i działa dobrze

Kluczowym punktem tutaj jest to, że cała implementacja opisana w powyższym linku używa klasy AESEngine. Patrząc na kod zajęć i informacje o javadoc, AESEngine to 128-bitowy zamiast 256-bitowego szyfru blokowego

Przeszukując kod i dokumenty, nie mogłem znaleźć implementacji 192 lub 256 bitów. Gdzie oni są?

Dla kompletności, to jest sedno mojej aktualnej klasy szyfrowania:

    private void init(String passphrase) {
        try {
            String algorithm = "PBEWithSHA256And256BitAES-CBC-BC"; 

            encryptCipher = createCipher();
            decryptCipher = createCipher();    

            randomGenerator = new RandomGenerator();

            PBEKeySpec keySpec = new PBEKeySpec(passphrase.toCharArray(), KEY_SALT, ITERATIONS);    

            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algorithm);
            key = keyFactory.generateSecret(keySpec);    

        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException("NoSuchAlgorithmException occured while trying to generate the crypto key. This error should never occur, check the application code", e);
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException("InvalidKeySpecException occured while trying to generate the crypto key. This error should never occur, check the application code", e);
        }
    }    

    private BufferedBlockCipher createCipher() {
        return new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESFastEngine()), new PKCS7Padding());
    }    

    public byte[] encrypt(byte[] data) {
        if (data == null)
            throw new NullPointerException("Cannot encrypt null data");    

        byte[] iv = randomGenerator.generateRandom(IV_SIZE);    

        byte[] encrypted;

        synchronized (encryptCipher) {
            encrypted = runCipher(encryptCipher, true, data, iv);
        }    

        return DataUtil.append(iv, encrypted);
    }    

    public byte[] decrypt(byte[] data) {
        if (data == null)
            throw new NullPointerException("Cannot decrypt null data");    

        byte[] iv = DataUtil.extract(data, 0, IV_SIZE);
        byte[] cipherText = DataUtil.extract(data, IV_SIZE, data.length - IV_SIZE);

        byte[] decrypted;    

        synchronized (decryptCipher) {
            decrypted = runCipher(decryptCipher, false, cipherText, iv);
        }

        return decrypted;
    }

    private byte[] runCipher(BufferedBlockCipher cipher, boolean forEncryption, byte[] data, byte[] iv) {
        String operation = forEncryption ? "encrypt" : "decrypt";

        try {
            KeyParameter keyParam = new KeyParameter(key.getEncoded());
            ParametersWithIV cipherParams = new ParametersWithIV(keyParam, iv);

            cipher.init(forEncryption, cipherParams);

            byte[] result = new byte[cipher.getOutputSize(data.length)];
            int len = cipher.processBytes(data, 0, data.length, result, 0);
            len += cipher.doFinal(result, len);

            //Remove padding se estiver decriptografando
            if(!forEncryption)
                result = DataUtil.extract(result, 0, len);

            return result;
        } catch (DataLengthException e) {
            throw new RuntimeException("DataLengthException occured while trying to " + operation + " data with length " + data.length + ". This error should never occur, check the application code", e);
        } catch (IllegalStateException e) {
            throw new RuntimeException("IllegalStateException occured while trying to " + operation + " data with length " + data.length + ". This error should never occur, check the application code", e);
        } catch (InvalidCipherTextException e) {
            throw new IllegalArgumentException("InvalidCipherTextException occured while trying to " + operation + " data with length " + data.length, e);
        }
    }
4
Bruno Penteado 25 wrzesień 2012, 01:28

2 odpowiedzi

Najlepsza odpowiedź

Jeśli chcesz wykonać szyfrowanie typu AES z rozmiarem bloku 256 bitów, powinieneś użyć:

http://www.docjar.org/docs/api/org/bouncycastle/crypto/engines/RijndaelEngine.html

Ale prawdopodobnie nie tego chcesz; 256 w AES-256 ma rozmiar klucza. Ten rozmiar klucza jest następnie używany przez bazowy 128-bitowy szyfr blokowy AES. AES to standardowa, 128-bitowa wersja Rijndaela.

5
Maarten Bodewes 25 wrzesień 2012, 02:40

AES obsługuje 3 rozmiary kluczy — Wikipedia, NIST.

Prawdopodobnie odnosisz się do rozmiaru bloku, który jest ustalony na 128 bitów.

Próbowałem też przejść przez kod, jest napisany przy założeniu różnych rozmiarów kluczy - 128, 192 i 256. Kopiuj - wklej z kodu - "AES określił stały rozmiar bloku 128 bitów i rozmiary kluczy 128/192/256 bitów. To kod jest pisany przy założeniu, że są to jedyne możliwe wartości"

0
Cipher 22 luty 2015, 17:39