Android 4.2版打破了我的加密/解密代码和提供的解决方案不起作用(Android 4.2 b

2019-06-21 05:15发布

站内文章 / 前端开发
28 0 0

首先，我已经看到了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中唯一改变的事情，否则我的代码将提出的方案工作。

我的代码是基于一些后我很久以前在这里找到在StackOverflow的; 我看到它从帖子提到，因为它只是隐窝不同，解密字节数组，而其它解决方案隐窝和解密字符串（HEX字符串，我认为）。

是否有种子呢？ 它有一个最小/最大长度，字符的限制，等等？

任何想法/解决方案？

编辑 ：大量的测试后，我看到有2个问题：

  1. 该供应商在改变的Android 4.2（API 17） - >这样一个很容易解决，只是采用我所提到的解决方案在后的顶部

  2. BouncyCastle的从1.34改变到1.45中的Android 2.2（API 8） - >的Android2.3（API 9），所以我先前告诉解密问题是相同的描述这里： 升级到1.45时BouncyCastle的AES错误

所以，现在的问题是： 有没有什么办法来恢复BouncyCastle的1.45+在BouncyCastle的1.34加密后的数据？

Answer 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");

如果您使用密码导出密钥，请按照Nelenkov的优秀教程需要提醒的是一个很好的经验法则是盐的大小应为尺寸为重点输出相同。

该iterationCount （工作因子）当然受到的改变，应立即更换为CPU供电的进展-通常建议不要去低于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");

而已。 你还有什么不应该使用。



Answer 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每它的执行时间。 所以，你想从用于加密数据的一个带钥匙不同的解密，你会得到异常。 当它已经以这种方式产生的，只有种子已经保存，您将无法恢复密钥或数据 。



Answer 3:

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

资源



Answer 4:

什么固定它，我（作为@Giorgio 建议 ）刚刚更换这样的 ： 

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

与此 ： 

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


Answer 5:

我无法给你回答你问的问题，但我只是尝试围绕工作这个> - 如果你面对的一些问题在不同的设备/ OS版本BouncyCastle的，你应该沟内置的版本完全，而是添加BouncyCastle的成JAR到你的项目，改变你的import ，以指向该JAR，重建并假设它所有的作品你会幸免于目前在Android内置的版本变化。



Answer 6:

因为所有这一切都没有帮助我产生这是在所有的Android设备（> = 2.1）确定的加密密码，我搜索了另一AES实现。 我发现其中一个对我的作品在所有设备上。 我不是一个安全专家，因此，如果该技术是不是安全的，因为它可以请不要downvote我的答案。 我只是张贴了谁已经在我之前曾面临同样的问题跑人的代码。 

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

来源： HERE



Answer 7:

它确实有确实与种子做，它也应该用8的倍数（如8，16，24或32），尽量完成与A和B的或1和0的种子（必须是这样ABAB .. ，因为AAA ..或BBB ..不会也行。）最多，达到8数的倍数。 还有，如果你正在阅读和加密仅字节，（它不转换为Char64像我一样），那么你需要一个合适的PKCS5或PKCS7填充，但在你的情况下，其他的事情（由于只有128位和它已经与旧创建安卓）PKCS5的版本就足够了，但你也应该把它放在你的SecreteKeySpec类似“AES / CBC / PKCS5Padding”或“AES / ECB / PKCS5Padding”，而不仅仅是“AES”，由于Android 4.2它使用PKCS7Padding为默认如果它只是字节，你真正需要的相同的算法，以前是默认的。 尝试得到一个设备早于4.2检查你的对象树一个Android“keygen.init（128，secrand）;”如果我没有记错的话这是有标签的密码 ，不是用它。 试试看。



文章来源: Android 4.2 broke my encrypt/decrypt code and the provided solutions don't work
标签： android cryptography bouncycastle
举报

收藏的人(0)

Ta的文章 更多文章
登录 后发表评论
0条评论
还没有人评论过~