Android 4.2 нарушил мой шифрованный/дешифрованный код, и предоставленные решения не работают

Ответ 1

Сначала отказ от ответственности:

НЕ используйте SecureRandom для получения ключа! Это сломано и не имеет смысла!

Следующий блок кода из вопроса пытается детерминистически извлечь ключ из пароля, называемого "семя", так как пароль используется для "семени" генератора случайных чисел.

KeyGenerator keygen = KeyGenerator.getInstance("AES");
SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG");
secrand.setSeed(seed.getBytes());
keygen.init(128, secrand);
SecretKey seckey = keygen.generateKey();

Однако алгоритм "SHA1PRNG" не является четко определенным, и реализации "SHA1PRNG" могут возвращать разные или даже полностью случайные ключи в результате.

Если вы читаете ключ AES с диска, просто сохраните фактический ключ и не проходите этот странный танец. Вы можете получить SecretKey для использования AES из байтов, выполнив:

    SecretKey key = new SecretKeySpec(keyBytes, "AES");

Если вы используете пароль для получения ключа, следуйте превосходному учебнику Неленкова с предупреждением о том, что хорошее правило - размер соли должен совпадать с размером ключа.

iterationCount (рабочий фактор), конечно, может изменяться и должна изменяться по мере увеличения мощности процессора - как правило, рекомендуется не опускаться ниже 40-100K с 2018 года. Имейте в виду, что PBKDF2 добавляет только постоянную задержку к угадыванию паролей; это не замена действительно слабых паролей.

Это выглядит так:

    /* User types in their password: */
    String password = "password";

    /* Store these things on disk used to derive key later: */
    int iterationCount = 1000;
    int saltLength = 32; // bytes; should be the same size as the output (256 / 8 = 32)
    int keyLength = 256; // 256-bits for AES-256, 128-bits for AES-128, etc
    byte[] salt; // Should be of saltLength

    /* When first creating the key, obtain a salt with this: */
    SecureRandom random = new SecureRandom();
    byte[] salt = new byte[saltLength];
    random.nextBytes(salt);

    /* Use this to derive the key from the password: */
    KeySpec keySpec = new PBEKeySpec(password.toCharArray(), salt,
                iterationCount, keyLength);
    SecretKeyFactory keyFactory = SecretKeyFactory
                .getInstance("PBKDF2WithHmacSHA1");
    byte[] keyBytes = keyFactory.generateSecret(keySpec).getEncoded();
    SecretKey key = new SecretKeySpec(keyBytes, "AES");

Это. Все остальное, что вы не должны использовать.

Ответ 2

Проблема в том, что с новым провайдером следующий фрагмент кода

KeyGenerator keygen = KeyGenerator.getInstance("AES");
SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG");
secrand.setSeed(seed.getBytes());
keygen.init(128, secrand);
SecretKey seckey = keygen.generateKey();
byte[] rawKey = seckey.getEncoded();

генерирует разные, действительно случайные rawKey каждый раз, когда он выполняется. Таким образом, вы пытаетесь расшифровать ключ, отличный от того, который используется для шифрования данных, и вы получаете исключение. Вы не сможете восстановить свой ключ или данные, когда он был сгенерирован таким образом, и было сохранено только семя.

Ответ 3

Что исправлено для меня (так как @Giorgio предложил) было просто заменить это:

SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG");

с этим:

SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG", "Crypto");

Ответ 4

private static final int ITERATION_COUNT = 1000;
private static final int KEY_LENGTH = 256;
private static final String PBKDF2_DERIVATION_ALGORITHM = "PBKDF2WithHmacSHA1";
private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";
private static final int PKCS5_SALT_LENGTH = 32;
private static final String DELIMITER = "]";
private static final SecureRandom random = new SecureRandom();

public static String encrypt(String plaintext, String password) {
    byte[] salt  = generateSalt();
    SecretKey key = deriveKey(password, salt);

    try {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        byte[] iv = generateIv(cipher.getBlockSize());
        IvParameterSpec ivParams = new IvParameterSpec(iv);
        cipher.init(Cipher.ENCRYPT_MODE, key, ivParams);
        byte[] cipherText = cipher.doFinal(plaintext.getBytes("UTF-8"));

        if(salt != null) {
            return String.format("%s%s%s%s%s",
                    toBase64(salt),
                    DELIMITER,
                    toBase64(iv),
                    DELIMITER,
                    toBase64(cipherText));
        }

        return String.format("%s%s%s",
                toBase64(iv),
                DELIMITER,
                toBase64(cipherText));
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}

public static String decrypt(String ciphertext, String password) {
    String[] fields = ciphertext.split(DELIMITER);
    if(fields.length != 3) {
        throw new IllegalArgumentException("Invalid encypted text format");
    }
    byte[] salt        = fromBase64(fields[0]);
    byte[] iv          = fromBase64(fields[1]);
    byte[] cipherBytes = fromBase64(fields[2]);
    SecretKey key = deriveKey(password, salt);

    try {
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
        IvParameterSpec ivParams = new IvParameterSpec(iv);
        cipher.init(Cipher.DECRYPT_MODE, key, ivParams);
        byte[] plaintext = cipher.doFinal(cipherBytes);
        return new String(plaintext, "UTF-8");
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
}

private static byte[] generateSalt() {
    byte[] b = new byte[PKCS5_SALT_LENGTH];
    random.nextBytes(b);
    return b;
}

private static byte[] generateIv(int length) {
    byte[] b = new byte[length];
    random.nextBytes(b);
    return b;
}

private static SecretKey deriveKey(String password, byte[] salt) {
    try {
        KeySpec keySpec = new PBEKeySpec(password.toCharArray(), salt, ITERATION_COUNT, KEY_LENGTH);
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(PBKDF2_DERIVATION_ALGORITHM);
        byte[] keyBytes = keyFactory.generateSecret(keySpec).getEncoded();
        return new SecretKeySpec(keyBytes, "AES");
    } catch (GeneralSecurityException e) {
        throw new RuntimeException(e);
    }
}

private static String toBase64(byte[] bytes) {
    return Base64.encodeToString(bytes, Base64.NO_WRAP);
}

private static byte[] fromBase64(String base64) {
    return Base64.decode(base64, Base64.NO_WRAP);
}

Источник

Ответ 5

Я не могу дать вам ответ на заданный вами вопрос, но я просто попытаюсь решить эту проблему > - если вы столкнулись с некоторыми проблемами с bouncycastle на разных версиях устройств/ОС, вы должны полностью использовать встроенные версии и вместо этого добавить bouncycastle в качестве jar для вашего проекта, измените ваш import на то, чтобы указать на эту банку, перестроить и предположить, что все это работает, и вы теперь будете невосприимчивы к изменениям встроенной версии Android.

Ответ 6

Поскольку все это не помогло мне создать зашифрованный пароль, который был детерминирован для всех устройств Android ( >= 2.1), я искал другую реализацию AES. Я нашел ту, которая работает для меня на всех устройствах. Я не специалист по безопасности, поэтому, пожалуйста, не уменьшайте мой ответ, если техника не так безопасна, как могла бы быть. Я только отправляю код для людей, которые запускали ту же проблему, с которой я сталкивался раньше.

import java.security.GeneralSecurityException;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import android.util.Log;

public class EncodeDecodeAES {


    private static final String TAG_DEBUG = "TAG";
    private IvParameterSpec ivspec;
    private SecretKeySpec keyspec;
    private Cipher cipher;

    private String iv = "fedcba9876543210";//Dummy iv (CHANGE IT!)
    private String SecretKey = "0123456789abcdef";//Dummy secretKey (CHANGE IT!)

    public EncodeDecodeAES() {
        ivspec = new IvParameterSpec(iv.getBytes());

        keyspec = new SecretKeySpec(SecretKey.getBytes(), "AES");

        try {
            cipher = Cipher.getInstance("AES/CBC/NoPadding");
        } catch (GeneralSecurityException e) {
            Log.d(TAG_DEBUG, e.getMessage());
        }
    }

    public byte[] encrypt(String text) throws Exception {
        if (text == null || text.length() == 0)
            throw new Exception("Empty string");

        byte[] encrypted = null;

        try {
            cipher.init(Cipher.ENCRYPT_MODE, keyspec, ivspec);

            encrypted = cipher.doFinal(padString(text).getBytes());
        } catch (Exception e) {
            Log.d(TAG_DEBUG, e.getMessage());
            throw new Exception("[encrypt] " + e.getMessage());
        }

        return encrypted;
    }

    public byte[] decrypt(String code) throws Exception {
        if (code == null || code.length() == 0)
            throw new Exception("Empty string");

        byte[] decrypted = null;

        try {
            cipher.init(Cipher.DECRYPT_MODE, keyspec, ivspec);

            decrypted = cipher.doFinal(hexToBytes(code));
        } catch (Exception e) {
            Log.d(TAG_DEBUG, e.getMessage());
            throw new Exception("[decrypt] " + e.getMessage());
        }
        return decrypted;
    }

    public static String bytesToHex(byte[] data) {
        if (data == null) {
            return null;
        }

        int len = data.length;
        String str = "";
        for (int i = 0; i < len; i++) {
            if ((data[i] & 0xFF) < 16)
                str = str + "0" + java.lang.Integer.toHexString(data[i] & 0xFF);
            else
                str = str + java.lang.Integer.toHexString(data[i] & 0xFF);
        }
        return str;
    }

    public static byte[] hexToBytes(String str) {
        if (str == null) {
            return null;
        } else if (str.length() < 2) {
            return null;
        } else {
            int len = str.length() / 2;
            byte[] buffer = new byte[len];
            for (int i = 0; i < len; i++) {
                buffer[i] = (byte) Integer.parseInt(str.substring(i * 2, i * 2 + 2), 16);
            }
            return buffer;
        }
    }

    private static String padString(String source) {
        char paddingChar = ' ';
        int size = 16;
        int x = source.length() % size;
        int padLength = size - x;

        for (int i = 0; i < padLength; i++) {
            source += paddingChar;
        }

        return source;
    }
}

Вы можете использовать его как:

EncodeDecodeAES aes = new EncodeDecodeAES ();
/* Encrypt */
String encrypted = EncodeDecodeAES.bytesToHex(aes.encrypt("Text to Encrypt"));
/* Decrypt */
String decrypted = new String(aes.decrypt(encrypted));

Источник: ЗДЕСЬ

Ответ 7

Он действительно имеет отношение к семени, и он также должен использовать несколько 8 (например, 8, 16, 24 или 32), попробуйте заполнить семя с помощью A и B или 1 и 0 (должно быть что-то вроде этого ABAB..., потому что AAA.. или BBB.. тоже не будет работать.), Чтобы достичь кратного числа 8. Другое дело, если вы читаете и шифруете только байты (не конвертируете его в Char64, как и я), тогда вам нужно соответствующее PKCS5 или PKCS7 Padding, однако в вашем случае (из-за только 128 бит, и оно было создано с более старыми версии Android) PKCS5 будет достаточно, хотя вы также должны поместить его в свой SecreteKeySpec как нечто вроде "AES/CBC/PKCS5Padding" или "AES/ECB/PKCS5Padding", а не просто "AES", поскольку Android 4.2 использует PKCS7Padding по умолчанию и если это только байты, вам действительно нужен тот же самый алгоритм, который ранее был по умолчанию. Попробуйте подключить устройство с Android раньше 4.2, проверьте дерево объектов на keygen.init(128, secrand); ", если я не ошибаюсь, у него есть шифр ярлыков, чем использовать его. Попробуйте.