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加密数据时，我无法回答您提出的问题，但我会尝试解决这个问题-如果您面临跨设备/操作系统版本的bouncycastle的一些问题，您应该完全放弃内置版本，而是将bouncycastle作为jar添加到您的项目中，更改您的

导入

以指向该jar，重新构建，并假设一切正常，从现在起，您将不受android内置版本更改的影响。

首先免责声明：

切勿使用

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密钥，只需存储实际密钥，不要经历这种奇怪的舞蹈。通过执行以下操作，可以从字节中获取AES用法的

SecretKey

：

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

如果您使用密码派生密钥，请遵循以下警告：经验法则是salt大小应与密钥输出的大小相同

迭代计数

（工作系数）当然会发生变化，并且应该随着CPU功率的增加而变化-通常建议从2018年起不低于40到100K。请注意，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");

---

就这样。任何你不应该使用的东西

它确实与种子有关，而且它也应该使用8的倍数（如8、16、24或32），尝试用A和B或1和0来完成种子（必须是类似于此的ABAB…，因为AAA..或BBB..也不起作用）以达到8的倍数。还有一件事，如果您只读取和加密字节（而不是像我那样将其转换为Char64），那么您需要适当的PKCS5或PKCS7填充，但是在您的情况下（由于只有128位，并且它是用旧版本的Android创建的），PKCS5就足够了，虽然你也应该把它放在你的SecretKeySpec中，比如“AES/CBC/PKCS5Padding”或“AES/ECB/PKCS5Padding”，而不仅仅是“AES”，因为Android 4.2使用的是PKCS7Padding作为默认值，如果只是字节，那么你真的需要与以前默认值相同的算法。尝试获取一台Android版本早于4.2的设备，检查“keygen.init（128，secrand）；”上的对象树，如果我没有弄错的话，请使用它的标签密码。 试一试。

问题在于，对于新的提供者，以下代码片段

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

。因此，您尝试使用不同于用于加密数据的密钥进行解密，您会得到异常。以这种方式生成密钥或数据时，您将无法恢复密钥或数据，并且只保存了种子。

由于所有这些都无法帮助我生成在所有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;
    }
}

资料来源：

为我（作为@Giorgio）修复的只是替换了这个：

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

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

使用此：

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

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

---

然而，这并不能解决我面临的问题，即在Android 4.2中解密在旧版操作系统中加密的数据。有什么想法吗？完全同意。永远不要使用Android的内置加密。同样的问题也发生在我身上。我现在使用jar文件来避免不兼容。问题是你原来的方法有缺陷。你滥用PRNG作为KDF。在使用真正的KDF的地方，你能用全新的代码替换它吗？我可以在不久的将来改进我的代码，但目前我所需要的只是解密安卓4.2中加密在安卓<4.2中的数据。你知道怎么做吗？这就是为什么不使用Android内置的加密API的原因。当客户在旧版本的设备上加密数据，然后将数据上传到服务器，然后丢失设备并购买另一台运行新版Android的设备时，他们将无法解密数据。获得一个像Bouncy Castle这样的加密库，并在应用程序中包含jar文件，你就不必忍受谷歌破坏兼容性的垃圾。我发现这篇文章有助于解释这种情况：避免使用Android JCA API的建议是错误的。事实上，它应该是几乎所有加密需求的首选。据我所知，防止SecureRandom误用的更改是JCA整个历史中唯一一个破坏现有密码的更改示例。它导致问题的原因是，有人想出了一种安全随机的方法，但这并非故意的，然后许多人在不了解任何内容的情况下复制并粘贴了代码。但是复制粘贴程序员总是遇到这样的问题。好吧，那么在迁移之后，我应该如何加密/解密数据呢？有什么教程我可以遵循吗？我扩展了答案，包含了一个你应该使用的片段；但是，我仍然需要恢复Android<4.2中加密的数据。你知道怎么做吗？支持恢复旧数据的一种方法是使用SHA1RPNG的代码

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

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);
}