Android 4.2 сломал мой код шифрования / дешифрования, и предоставленные решения не работают
Прежде всего, я уже видел, как Android 4.2 сломал мой код шифрования / дешифрования AES и ошибку шифрования на Android 4.2 и предоставленное решение:
SecureRandom sr = null;
if (android.os.Build.VERSION.SDK_INT >= JELLY_BEAN_4_2) {
sr = SecureRandom.getInstance("SHA1PRNG", "Crypto");
} else {
sr = SecureRandom.getInstance("SHA1PRNG");
}
не работает для меня, потому что при декодировании данных, зашифрованных в Android<4.2 в Android 4.2, я получаю:
javax.crypto.BadPaddingException: pad block corrupted
at com.android.org.bouncycastle.jcajce.provider.symmetric.util.BaseBlockCipher.engineDoFinal(BaseBlockCipher.java:709)
Мой код довольно прост и работал до Android 4.2:
public static byte[] encrypt(byte[] data, String seed) throws Exception {
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();
SecretKeySpec skeySpec = new SecretKeySpec(rawKey, "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
return cipher.doFinal(data);
}
public static byte[] decrypt(byte[] data, String seed) throws Exception {
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();
SecretKeySpec skeySpec = new SecretKeySpec(rawKey, "AES");
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
return cipher.doFinal(data);
}
Я предполагаю, что поставщик по умолчанию был не единственным, что изменилось в Android 4.2, в противном случае мой код будет работать с предлагаемым решением.
Мой код был основан на каком-то посте, который я нашел здесь в Stackru давным-давно; Я вижу, что он отличается от упомянутых постов тем, что он просто шифрует и дешифрует байтовые массивы, тогда как другие решения шифруют и дешифруют строки (HEX Strings, я думаю).
Это имеет отношение к семени? Есть ли у него минимальная / максимальная длина, ограничение символов и т. Д.?
Любая идея / решение?
РЕДАКТИРОВАТЬ: После многих испытаний, я вижу, что есть 2 проблемы:
Провайдер изменился в Android 4.2 (API 17) -> Это легко исправить, просто примените решение, которое я упомянул в начале статьи
BouncyCastle изменился с 1.34 до 1.45 в Android 2.2 (API 8)->Android2.3 (API 9), поэтому проблема дешифрования, о которой я говорил ранее, такая же, как описано здесь: Ошибка Aoun BouncyCastle при обновлении до 1.45
Итак, теперь вопрос: есть ли способ восстановить данные, зашифрованные в BouncyCastle 1.34 в BouncyCastle 1.45+?
7 ответов
Сначала отказ от ответственности:
Никогда не используйте "SecureRandom" для получения ключа!Это сломано и не имеет смысла!
Если вы читаете ключ AES с диска, просто сохраните фактический ключ и не проходите этот странный танец. Вы можете получить SecretKey для использования AES из байтов, выполнив:
SecretKey key = new SecretKeySpec(keyBytes, "AES");
Если вы используете пароль для получения ключа, следуйте превосходному учебнику Неленкова с предупреждением о том, что хорошим правилом является то, что размер соли должен совпадать с размером ключа. Это выглядит так:
/* 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");
Вот и все. Все остальное, что вы не должны использовать.
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);
}
Проблема в том, что с новым провайдером, следующий фрагмент кода
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
каждый раз, когда это выполняется. Итак, вы пытаетесь расшифровать ключом, отличным от того, который использовался для шифрования данных, и вы получаете исключение. Вы не сможете восстановить свой ключ или данные, когда они были сгенерированы таким образом, и только семя было сохранено.
То, что исправило это для меня (как предложил@Giorgio), просто заменило это:
SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG");
с этим:
SecureRandom secrand = SecureRandom.getInstance("SHA1PRNG", "Crypto");
Поскольку все это не помогло мне создать зашифрованный пароль, который был бы детерминированным на всех устройствах 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));
Источник: ЗДЕСЬ
Я не могу дать вам ответ на заданный вопрос, но я бы просто попытался обойти это>- если вы столкнулись с некоторыми проблемами с bouncycastle на разных устройствах / версиях ОС, вам следует полностью отказаться от встроенных версий и вместо этого добавить bouncycastle в качестве jar в свой проект, измените свой import
чтобы указать на эту банку, перестроить и предположить, что все это работает, вы будете защищены от изменений встроенной версии Android.
Это действительно связано с начальным числом, и оно также должно использовать кратное 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);", если я не ошибаюсь, у него есть шифр метки, чем использовать его. Попробуйте.