Android外部文件加解密及应用实践

有这样的应用场景，当我们把一些重要文件放到asset文件夹中时，把.apk解压是可以直接拿到这个文件的，一些涉及到重要信息的文件我们并不想被反编译拿去，这个时候需要先对文件进行加密，然后放到Android中的资源目录下，用的时候再解密出来。

现代密码学中，加密系统的安全性是基于密钥的，而不是基于算法，现在介绍一整套加解密及应用流程，这套加密流程从实用性和安全性上来讲，我觉得还是很靠谱的，也是市面上比较常用的做法，核心逻辑其实比较简单，毕竟最难的加解密算法实现部分是现成的了，我司部分也用了这套流程，当然会比我讲的这个要复杂一些。

1、简介

主要涉及到一下几个算法的应用，RSA、AES，以及Base64编码，基本思想是用[AES算法+AES密钥]来加密文件，为了保证密钥的安全性，会通过[RSA算法+RSA私钥]对AES密钥进行加密。

对这几种算法不熟悉可以看看我司大佬的‘常用的加密方式和应用场景’这篇文章，知道大概的原理和使用方法就行，因为算法在java中都是现成的，直接拿来用就是了。

Android加解密流程图.png

把流程整理了一下，就是以上的流程图，分成三块:

  • 第1块是把加密过程给封装成一个小工具，用加密工具来对文件进行加密;
  • 第2块是把解密过程封装成解密的小工具，用解密工具来解密我们的文件好进行相关修改;
  • 第3块使我们的目的，就是把加密文件和加解密的AES算法密钥放到Android资源文件中进行具体的使用。

有一点需要补充的，就是RSA算法的公私钥，从第3块中可以发现，并没有把RSA的公钥和私钥放到资源文件中，其实大家想想就知道了，如果被加密文件、加解密的AES密钥、用于对AES密钥进行加密的RSA密钥三者都放入文件夹中，那就没有啥安全性可言了(注：加解密的算法可以改造成自己公司独有的，我司就是这么做的)，所以为了保证安全性，我们的RSA公私钥是通过应用的签名(.keystore签名文件)中代码动态获取。感兴趣的可以看这篇文章：[从Java Keystore文件中提取私钥、证书]。

2、第1块：加密工具进行加密

工具的java界面开发是通过java的swing包来实现的，对swing感兴趣的可以参考这篇Java Swing 图形界面开发简介，讲得非常详细。

一开始的时候是没有AES秘钥的，需要我们生成一个安全的秘钥，所以生成一个随机AES秘钥，然后保存，加密工具的操作页界面：

加密

2.1、生成随机秘钥

生成随机秘钥主要分为几步：

  • 通过UUID.randomUUID()生成随机数作为seed种子;
  • seed种子提供给KeyGenerator生成AES秘钥，只要seed种子生成的AES秘钥就是一致的;
  • 通过应用签名获取RSA算法需要的公钥私钥;
  • RSA通过私钥来加密AES秘钥;

因为生成的秘钥是byte[]，所以通过Base64编码展示出来给到界面上。

 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2. * 生成随机密钥  
    3.   
  
  
  
  3. */  
    4.   
  
  
  
  4. private void randomKey() {  
    5.   
  
  
  
  5. try {  
    6.   
  
  
  
  6. //生成随机数作为seed种子  
    7.   
  
  
  
  7. String uuid = UUID.randomUUID().toString();  
    8.   
  
  
  
  8. byte[] seed = uuid.getBytes("UTF-8");  
    9.   
  
  
  
  9. //生成AES秘钥  
    10.   
  
  
  
  10. byte[] rawkey = AES.getRawKey(seed);  
    11.   
  
  
  
  11. //获取应用签名的密钥对  
    12.   
  
  
  
  12. KeyPair pair = SignKey.getSignKeyPair();  
    13.   
  
  
  
  13. //通过RSA私钥来加密AES秘钥  
    14.   
  
  
  
  14. byte[] key = RSA.encrypt(rawkey, pair.getPrivate());  
    15.   
  
  
  
  15. //Base64编码成字符串展示  
    16.   
  
  
  
  16. String base64Key = Base64.encode(key);  
    17.   
  
  
  
  17. mKeyText.setText(base64Key);  
    18.   
  
  
  
  18. } catch (Exception e) {  
    19.   
  
  
  
  19. e.printStackTrace();  
    20.   
  
  
  
  20. }  
    21.   
  
  
  
  21. }  
    22.   
  
  
  
  22. 其中AES.getRawKey(seed)中主要是通过AES密钥生成器来生成128位的密钥，具体实现：  
    23.   
  
  
  
  23. /** 
    24.   
  
  
  
  24.  * 生成用AES算法来加密的密钥流，这个密钥会被应用签名{@link SignKey}的密钥进行二次加密  
    25.   
  
  
  
  25. */  
    26.   
  
  
  
  26. public static byte[] getRawKey(byte[] seed) throws Exception {  
    27.   
  
  
  
  27. KeyGenerator kgen = KeyGenerator.getInstance("AES");  
    28.   
  
  
  
  28. SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");  
    29.   
  
  
  
  29. sr.setSeed(seed);  
    30.   
  
  
  
  30. //192 and 256 bits may not be available  
    31.   
  
  
  
  31. kgen.init(128, sr);  
    32.   
  
  
  
  32. SecretKey skey = kgen.generateKey();  
    33.   
  
  
  
  33. return skey.getEncoded();  
    34.   
  
  
  
  34. } 
    35.

SignKey.getSignKeyPair()是获得RSA算法所需的公私钥，是从我们的应用签名来的，大家应该都很熟悉了，应用打包上传是需要签名打包的。

keystore

java提供了api获取testkey.keystore文件(自己用studio生成一个)的私钥和证书，把testkey.keystore文件放到目录中：

 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2. * Author:xishuang  
    3.   
  
  
  
  3. * Date:2018.05.06  
    4.   
  
  
  
  4. * Des:根据导入的应用签名，读取其中的密钥对和证书  
    5.   
  
  
  
  5. */  
    6.   
  
  
  
  6. public class SignKey {  
    7.   
  
  
  
  7. //应用签名  
    8.   
  
  
  
  8. private static final String keystoreName = "testkey.keystore";  
    9.   
  
  
  
  9. private static final String keystorePassword = "123456";  
    10.   
  
  
  
  10. //应用签名的别名  
    11.   
  
  
  
  11. private static final String alias = "key0";  
    12.   
  
  
  
  12. private static final String aliasPassword = "123456";  
    13.   
  
  
  
  13. /**  
    14.   
  
  
  
  14. * 获取签名的密钥对，用来给密钥加密  
    15.   
  
  
  
  15. */  
    16.   
  
  
  
  16. public static KeyPair getSignKeyPair() {  
    17.   
  
  
  
  17. try {  
    18.   
  
  
  
  18. File storeFile = new File(keystoreName);  
    19.   
  
  
  
  19. if (!storeFile.exists()) {  
    20.   
  
  
  
  20. throw new IllegalArgumentException("还没设置签名文件!");  
    21.   
  
  
  
  21. }  
    22.   
  
  
  
  22. String keyStoreType = "JKS";  
    23.   
  
  
  
  23. char[] keystorepasswd = keystorePassword.toCharArray();  
    24.   
  
  
  
  24. char[] keyaliaspasswd = aliasPassword.toCharArray();  
    25.   
  
  
  
  25. KeyStore keystore = KeyStore.getInstance(keyStoreType);  
    26.   
  
  
  
  26. keystore.load(new FileInputStream(storeFile), keystorepasswd);  
    27.   
  
  
  
  27. //拿私钥  
    28.   
  
  
  
  28. Key key = keystore.getKey(alias, keyaliaspasswd);  
    29.   
  
  
  
  29. if (key instanceof PrivateKey) {  
    30.   
  
  
  
  30. //拿公钥  
    31.   
  
  
  
  31. Certificate cert = keystore.getCertificate(alias);  
    32.   
  
  
  
  32. PublicKey publicKey = cert.getPublicKey();  
    33.   
  
  
  
  33. ///公私钥存到KeyPair 
    34.   
  
  
  
  34.  return new KeyPair(publicKey, (PrivateKey) key);  
    35.   
  
  
  
  35. }  
    36.   
  
  
  
  36. } catch (Exception e) {  
    37.   
  
  
  
  37. e.printStackTrace();  
    38.   
  
  
  
  38. }  
    39.   
  
  
  
  39. return null;  
    40.   
  
  
  
  40. }  
    41.   
  
  
  
  41. } 
    42.

拿testkey.keystore所需的参数都在跟我们打包应用签名所需一样，通过java提供的keystore类获取。然后就是用刚拿到的testkey.keystore私钥来加密AES密钥，再通过Base64转换一下编码成字符串展示出来，只是为了把密钥展示出来才转换编码的。

密钥Base64编码.png

2.2、导出密钥

把密钥导出成文件，下次直接导入密钥用来解密文件，导出密钥需要先用Base64把文本框里的Base64密钥字符串转换为Byte[]再存。

 
 
 
 
    
  
  
  
  
  1. byte[] key = Base64.decode(base64Key);  
    2.   
  
  
  
  2. //将raw key输出  
    3.   
  
  
  
  3. File keyFile = new File(dir, "testkey.dat");  
    4.   
  
  
  
  4. FileOutputStream fos = new FileOutputStream(keyFile); 
    5.

2.3、加密文件

密钥已有，AES算法又是现成的，直接调用api加密就行了：

 
 
 
 
    
  
  
  
  
  1. private static final String AES = "AES";  
    2.   
  
  
  
  2. /**  
    3.   
  
  
  
  3. * AES算法加密文件  
    4.   
  
  
  
  4. *  
    5.   
  
  
  
  5. * @param rawKey AES密钥  
    6.   
  
  
  
  6. * @param fromFile 要加密的文件  
    7.   
  
  
  
  7. * @param toFile 加密后文件  
    8.   
  
  
  
  8. */  
    9.   
  
  
  
  9. public static void encryptFile(byte[] rawKey, File fromFile, File toFile) throws Exception {  
    10.   
  
  
  
  10. if (!fromFile.exists()) {  
    11.   
  
  
  
  11. throw new NullPointerException("文件不存在");  
    12.   
  
  
  
  12. }  
    13.   
  
  
  
  13. if (toFile.exists()) {  
    14.   
  
  
  
  14. toFile.delete();  
    15.   
  
  
  
  15. }  
    16.   
  
  
  
  16. SecretKeySpec skeySpec = new SecretKeySpec(rawKey, AES);  
    17.   
  
  
  
  17. Cipher cipher = Cipher.getInstance(AES); 
    18.   
  
  
  
  18.  //加密模式  
    19.   
  
  
  
  19. cipher.init(Cipher.ENCRYPT_MODE, skeySpec);  
    20.   
  
  
  
  20. FileInputStream fis = new FileInputStream(fromFile);  
    21.   
  
  
  
  21. FileOutputStream fos = new FileOutputStream(toFile, true);  
    22.   
  
  
  
  22. byte[] buffer = new byte[512 * 1024 - 16];  
    23.   
  
  
  
  23. int offset; 
    24.   
  
  
  
  24. //使用加密流来加密  
    25.   
  
  
  
  25. CipherInputStream bis = new CipherInputStream(fis, cipher);  
    26.   
  
  
  
  26. while ((offset = bis.read(buffer)) != -1) { 
    27.   
  
  
  
  27.  fos.write(buffer, 0, offset);  
    28.   
  
  
  
  28. fos.flush();  
    29.   
  
  
  
  29. }  
    30.   
  
  
  
  30. fos.close();  
    31.   
  
  
  
  31. fis.close();  
    32.   
  
  
  
  32. } 
    33.

选择文件，通过AES算法和AES密钥加密，最后效果如下，没有密钥能解密出来算我输。

加密前后

3、第2块：解密工具进行解密

解密过程其实没啥必要讲了，因为解密过程是加密过程的逆过程。

这个解密不是在应用中用的，是为了便于我们更新加密文件，修改文件之前必须要先把文件先解密。

解密

3.1、导入AES密钥

这个密钥就是我们前面生成的密钥，导进来后用应用签名的RSA公钥解密AES密钥即可：

 
 
 
 
    
  
  
  
  
  1. //获取被加密的密钥raw key  
    2.   
  
  
  
  2. String keyStr = mKeyText.getText(); 
    3.   
  
  
  
  3. byte[] key = Base64.decode(keyStr);  
    4.   
  
  
  
  4. //获取应用签名密钥对，公钥解密raw key  
    5.   
  
  
  
  5. KeyPair keypair = SignKey.getSignKeyPair();  
    6.   
  
  
  
  6. byte[] rawkey = RSA.decrypt(key, keypair.getPublic());  
    7.   
  
  
  
  7. //用raw key去解密文件  
    8.   
  
  
  
  8. AES.decryptFile(rawkey, fromFile, toFile); 
    9.

3.2、解密文件

拿到纯洁版AES密钥之后就可以直接调用AES算法解密文件了：

 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2. * AES算法解密文件  
    3.   
  
  
  
  3. *  
    4.   
  
  
  
  4. * @param rawKey AES密钥  
    5.   
  
  
  
  5. * @param fromFile 被加密的文件  
    6.   
  
  
  
  6. * @param toFile 解密后文件  
    7.   
  
  
  
  7. */  
    8.   
  
  
  
  8. public static void decryptFile(byte[] rawKey, File fromFile, File toFile) throws Exception {  
    9.   
  
  
  
  9. if (!fromFile.exists()) {  
    10.   
  
  
  
  10. throw new NullPointerException("文件不存在");  
    11.   
  
  
  
  11. }  
    12.   
  
  
  
  12. if (toFile.exists()) {  
    13.   
  
  
  
  13. toFile.delete();  
    14.   
  
  
  
  14. }  
    15.   
  
  
  
  15. SecretKeySpec skeySpec = new SecretKeySpec(rawKey, AES);  
    16.   
  
  
  
  16. Cipher cipher = Cipher.getInstance(AES);  
    17.   
  
  
  
  17. //解密模式  
    18.   
  
  
  
  18. cipher.init(Cipher.DECRYPT_MODE, skeySpec);  
    19.   
  
  
  
  19. FileInputStream fis = new FileInputStream(fromFile);  
    20.   
  
  
  
  20. FileOutputStream fos = new FileOutputStream(toFile, true);  
    21.   
  
  
  
  21. byte[] buffer = new byte[512 * 1024 + 16];  
    22.   
  
  
  
  22. int offset;  
    23.   
  
  
  
  23. //使用解密流来解密  
    24.   
  
  
  
  24. CipherInputStream cipherInputStream = new CipherInputStream(fis, cipher);  
    25.   
  
  
  
  25. while ((offset = cipherInputStream.read(buffer)) != -1) {  
    26.   
  
  
  
  26. fos.write(buffer, 0, offset);  
    27.   
  
  
  
  27. fos.flush();  
    28.   
  
  
  
  28. }  
    29.   
  
  
  
  29. fos.close();  
    30.   
  
  
  
  30. fis.close();  
    31.   
  
  
  
  31. } 
    32.

和AES加密过程一对比，会发现只是切换一下AES算法模式。

3、第3块：Android应用中解密文件

要解密文件，需要在资源文件夹中加入被加密的AES密钥，这个密钥就是上面导出来的，还有就是被加密后的文件。能正确解密的前提是你应用签名和用来给文件加密过程中用到的签名是同一个。

资源文件

3.1、解密AES密钥

在Android应用中解密文件与在java工具中解密文件，区别主要在于RSA密钥的获取，在java工具中应用签名testkey.keystore是开发者拥有的，可以拿到其中的全部信息，而在Android中应用是要发布到应用市场的，任何人都可以下载我们的包，应用签名只能通过Android提供的api拿到其公钥。

 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2. * Author:xishuang  
    3.   
  
  
  
  3. * Date:2018.05.06  
    4.   
  
  
  
  4. * Des:应用签名读取工具类  
    5.   
  
  
  
  5. */  
    6.   
  
  
  
  6. public class SignKey {  
    7.   
  
  
  
  7. /**  
    8.   
  
  
  
  8. * 获取当前应用的签名  
    9.   
  
  
  
  9. *  
    10.   
  
  
  
  10. * @param context 上下文  
    11.   
  
  
  
  11. */  
    12.   
  
  
  
  12. public static byte[] getSign(Context context) {  
    13.   
  
  
  
  13. PackageManager pm = context.getPackageManager(); 
    14.   
  
  
  
  14. try {  
    15.   
  
  
  
  15. PackageInfo info = pm.getPackageInfo(context.getPackageName(), PackageManager.GET_SIGNATURES);  
    16.   
  
  
  
  16. Signature[] signatures = info.signatures;  
    17.   
  
  
  
  17. if (signatures != null) {  
    18.   
  
  
  
  18. return signatures[0].toByteArray();  
    19.   
  
  
  
  19. }  
    20.   
  
  
  
  20. } catch (NameNotFoundException e) {  
    21.   
  
  
  
  21. e.printStackTrace();  
    22.   
  
  
  
  22. }  
    23.   
  
  
  
  23. return null;  
    24.   
  
  
  
  24. }  
    25.   
  
  
  
  25. /**  
    26.   
  
  
  
  26. * 根据签名去获取公钥  
    27.   
  
  
  
  27. */  
    28.   
  
  
  
  28. public static PublicKey getPublicKey(byte[] signature) {  
    29.   
  
  
  
  29. try {  
    30.   
  
  
  
  30. CertificateFactory certFactory = CertificateFactory  
    31.   
  
  
  
  31. .getInstance("X.509");  
    32.   
  
  
  
  32. X509Certificate cert = (X509Certificate) certFactory  
    33.   
  
  
  
  33. .generateCertificate(new ByteArrayInputStream(signature));  
    34.   
  
  
  
  34. return cert.getPublicKey();  
    35.   
  
  
  
  35. } catch (CertificateException e) {  
    36.   
  
  
  
  36. e.printStackTrace();  
    37.   
  
  
  
  37. } 
    38.   
  
  
  
  38.  return null;  
    39.   
  
  
  
  39. }  
    40.   
  
  
  
  40. } 
    41.

拿到应用签名testkey.keystore的公钥之后的流程就和在java工具中的操作基本一致了，用RSA公钥来解密AES密钥。

 
 
 
 
    
  
  
  
  
  1. private static final String SIMPLE_KEY_DATA = "testkey.dat";  
    2.   
  
  
  
  2. /**  
    3.   
  
  
  
  3. * 获取解密之后的文件加密密钥  
    4.   
  
  
  
  4. */  
    5.   
  
  
  
  5. private static byte[] getRawKey(Context context) throws Exception {  
    6.   
  
  
  
  6. //获取应用的签名密钥  
    7.   
  
  
  
  7. byte[] sign = SignKey.getSign(context);  
    8.   
  
  
  
  8. PublicKey pubKey = SignKey.getPublicKey(sign);  
    9.   
  
  
  
  9. //获取加密文件的密钥  
    10.   
  
  
  
  10. InputStream keyis = context.getAssets().open(SIMPLE_KEY_DATA);  
    11.   
  
  
  
  11. byte[] key = getData(keyis);  
    12.   
  
  
  
  12. //解密密钥  
    13.   
  
  
  
  13. return RSA.decrypt(key, pubKey);  
    14.   
  
  
  
  14. } 
    15.

最后再用解密之后的AES密钥来解密文件。

3.2、AES密钥解密文件

通过资源管理器拿到加密文件的文件流，通过AES密钥来用AES算法来解密文件流。

 
 
 
 
    
  
  
  
  
  1. /**  
    2.   
  
  
  
  2. * 获取解密之后的文件流  
    3.   
  
  
  
  3. */  
    4.   
  
  
  
  4. public static InputStream onObtainInputStream(Context context) {  
    5.   
  
  
  
  5. try {  
    6.   
  
  
  
  6. AssetManager assetmanager = context.getAssets();  
    7.   
  
  
  
  7. InputStream is = assetmanager.open("encrypt_测试.txt");  
    8.   
  
  
  
  8. byte[] rawkey = getRawKey(context);  
    9.   
  
  
  
  9. //使用解密流，数据写出到基础OutputStream之前先对该会先对数据进行解密  
    10.   
  
  
  
  10. SecretKeySpec skeySpec = new SecretKeySpec(rawkey, "AES");  
    11.   
  
  
  
  11. Cipher cipher = Cipher.getInstance("AES");  
    12.   
  
  
  
  12. cipher.init(Cipher.DECRYPT_MODE, skeySpec);  
    13.   
  
  
  
  13. return new CipherInputStream(is, cipher);  
    14.   
  
  
  
  14. } catch (Exception e) {  
    15.   
  
  
  
  15. e.printStackTrace();  
    16.   
  
  
  
  16. }  
    17.   
  
  
  
  17. return null;  
    18.   
  
  
  
  18. } 
    19.

拿到加密后文件流之后就达成目的了，可以解析成字符串展示出来：

 
 
 
 
    
  
  
  
  
  1. private void inputData() {  
    2.   
  
  
  
  2. InputStream in = DecryptUtil.onObtainInputStream(this);  
    3.   
  
  
  
  3. try {  
    4.   
  
  
  
  4. BufferedReader reader = new BufferedReader(new InputStreamReader(in, "GBK"));  
    5.   
  
  
  
  5. StringBuilder sb = new StringBuilder();  
    6.   
  
  
  
  6. String line;  
    7.   
  
  
  
  7. while ((line = reader.readLine()) != null) {  
    8.   
  
  
  
  8. sb.append(line + "\n");  
    9.   
  
  
  
  9. }  
    10.   
  
  
  
  10. contentTv.setText(sb.toString());  
    11.   
  
  
  
  11. } catch (IOException e) {  
    12.   
  
  
  
  12. e.printStackTrace();  
    13.   
  
  
  
  13. } finally {  
    14.   
  
  
  
  14. try {  
    15.   
  
  
  
  15. in.close();  
    16.   
  
  
  
  16. } catch (IOException e) {  
    17.   
  
  
  
  17. e.printStackTrace();  
    18.   
  
  
  
  18. }  
    19.   
  
  
  
  19. }  
    20.   
  
  
  
  20. } 
    21.

实例效果图如下，请关注红框里面内容，因为懒得新建项目，用原有项目测试了一下：

效果

目前工具使用的是市面上比较常见的加解密算法，可以换一下算法，比如DES或者其它的对称和非对称算法，甚至是自己改动的算法，想运行示例演示的话：

QQ截图20180508234849.png

就是运行一下java文件，就可以打开加解密小工具了，加解密工具界面是仿我司工具包中抽出来的小部分的，毕竟写界面好烦，感谢我司大神多年前就写出了如此工具。

新闻名称：Android外部文件加解密及应用实践
分享路径：http://www.shufengxianlan.com/qtweb/news36/352536.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站维护知识

各行业网站

香港云主机　　 　雕琢时光茶叶　　 　网创优客　　 　温江服务器托管　　 　德阳服务器托管　　 　网站建设方案　　 　定制网站建设　　 　宜宾网站营销推广　　 　乐山网站建设　　 　南充机房托管　　 　域名申请　　 　成都广告设计公司　　 　东方电机技改服务有限公司　　 　腾讯免备案空间　　 　雅安网站建设　　 　金羊影视传媒　　 　重庆花箱　　 　主机租用　　 　邛崃做网站　　 　温江网站建设