当前位置：主页 > 查看内容

Android敏感数据泄露引发的思考

发布时间：2021-05-12 00:00| 有 位朋友查看

简介：1.事件始末 一个平淡的午后，我还悠哉悠哉的敲着代码品着茶。突然服务端同事告诉我，关注接口正在被机械式调用，怀疑是有人在使用脚本刷接口(目的主要是从平台导流)。 纳尼?不会吧，因为据我所知接口请求是做了加密处理的，除非知道加密的密钥和加密方式，不……

 1.事件始末

一个平淡的午后，我还悠哉悠哉的敲着代码品着茶。突然服务端同事告诉我，关注接口正在被机械式调用，怀疑是有人在使用脚本刷接口(目的主要是从平台导流)。

纳尼?不会吧，因为据我所知接口请求是做了加密处理的，除非知道加密的密钥和加密方式，不然是不会调用成功的，一定是你感觉错了。然而当服务端同事把接口调用日志发给我看时，彻底否定了我的侥幸心理。

接口调用频率固定为1s 一次

被关注者的id每次调用依次加一(目前业务上用户id的生成是按照注册时间依次递增的)

加密的密钥始终使用固定的一个(正常的是在固定的几个密钥中每次会随机使用一个)

综合以上三点就可以断定，肯定是存在刷接口的行为了。

2.事件分析

既然上述刷接口的行为成立，也就意味着密钥和加密方式被对方知道了，原因无非是以下两点：

  1. 内部人员泄露
  2. apk被破解

经过确认基本排除了第一点，那就只剩下apk被破解了，可是apk发布出去的包是进行过加固和混淆处理的，难道对方脱壳了?不管三七二十一，自己先来反编译试试。于是乎从最近发布的版本一个一个去反编译，最后在反编译到较早前的一个版本时发现，保存密钥和加密的工具类居然源码完全暴露了。

炸了锅了，排查了一下这个版本居然未加固过就发布出去了，而且这个加密工具类未被混淆。虽然还不太清楚对方是不是按照这种方式获取的密钥和加密算法，但无疑这是客户端存在的一个安全漏洞。

3.事件处理

既然已经发现了上述问题，那就要想办法解决。首先不考虑加固，如何尽最大可能保证客户端中的敏感数据不泄露?另一方面即使对方想要破解，也要想办法设障，增大破解难度。想到这里基本就大致确定了一个思路：使用NDK,将敏感数据和加密方式放到native层，因为C++代码编译后生成的so库是一个二进制文件，这无疑会增加破解的难度。利用这个特性，可以将客户端的敏感数据写在C++代码中，从而增强应用的安全性。 说干就干吧!!!

1.首先创建了加密工具类：

  1. public class HttpKeyUtil { 
  2.     static { 
  3.         System.loadLibrary("jniSecret"); 
  4.     } 
  5.     //根据随机值去获取密钥 
  6.     public static native String getHttpSecretKey(int index); 
  7.     //将待加密的数据传入，返回加密后的结果 
  8.     public static native String getSecretValue(byte[] bytes); 
  9. } 

2.生成相应的头文件：

  1. #include <jni.h> 
  2. #ifndef _Included_com_test_util_HttpKeyUtil 
  3. #define _Included_com_test_util_HttpKeyUtil 
  4. #ifdef __cplusplus 
  5. extern "C" { 
  6. #endif 
  7. JNIEXPORT jstring JNICALL Java_com_esky_common_component_util_HttpKeyUtil_getHttpSecretKey 
  8.         (JNIEnv *, jclass, jint); 
  9.          
  10. JNIEXPORT jstring JNICALL Java_com_test_util_HttpKeyUtil_getSecretValue 
  11.         (JNIEnv *, jclass, jbyteArray); 
  12.  
  13. #ifdef __cplusplus 
  14. } 
  15. #endif 
  16. #endif 

3.编写相应的cpp文件：

在相应的Module中创建jni目录，将com_test_util_HttpKeyUtil.h拷贝进来，然后再创建com_test_util_HttpKeyUtil.cpp文件

  1. #include <jni.h> 
  2. #include <cstring> 
  3. #include <malloc.h> 
  4. #include "com_test_util_HttpKeyUtil.h" 
  5.  
  6. extern "C" 
  7. const char *KEY1 = "密钥1"; 
  8. const char *KEY2 = "密钥2"; 
  9. const char *KEY3 = "密钥3"; 
  10. const char *UNKNOWN = "unknown"; 
  11.  
  12. jstring toMd5(JNIEnv *pEnv, jbyteArray pArray); 
  13.  
  14. extern "C" JNIEXPORT jstring JNICALL Java_com_test_util_HttpKeyUtil_getHttpSecretKey 
  15.         (JNIEnv *env, jclass cls, jint index) { 
  16.     if (随机数条件1) { 
  17.         return env->NewStringUTF(KEY1); 
  18.     } else if (随机数条件2) { 
  19.         return env->NewStringUTF(KEY2); 
  20.     } else if (随机数条件3) { 
  21.         return env->NewStringUTF(KEY3); 
  22.     } else { 
  23.         return env->NewStringUTF(UNKNOWN); 
  24.     } 
  25. } 
  26.  
  27. extern "C" JNIEXPORT jstring JNICALL 
  28. Java_com_test_util_HttpKeyUtil_getSecretValue 
  29.         (JNIEnv *env, jclass cls, jbyteArray jbyteArray1) { 
  30.         //加密算法各有不同，这里我就用md5做个示范 
  31.         return toMd5(env, jbyteArray1); 
  32. } 
  33.  
  34. //md5 
  35. jstring toMd5(JNIEnv *env, jbyteArray source) { 
  36.     // MessageDigest 
  37.     jclass classMessageDigest = env->FindClass("java/security/MessageDigest"); 
  38.     // MessageDigest.getInstance() 
  39.     jmethodID midGetInstance = env->GetStaticMethodID(classMessageDigest, "getInstance", 
  40.                                                       "(Ljava/lang/String;)Ljava/security/MessageDigest;"); 
  41.     // MessageDigest object 
  42.     jobject objMessageDigest = env->CallStaticObjectMethod(classMessageDigest, midGetInstance, 
  43.                                                            env->NewStringUTF("md5")); 
  44.  
  45.     jmethodID midUpdate = env->GetMethodID(classMessageDigest, "update", "([B)V"); 
  46.     env->CallVoidMethod(objMessageDigest, midUpdate, source); 
  47.  
  48.     // Digest 
  49.     jmethodID midDigest = env->GetMethodID(classMessageDigest, "digest", "()[B"); 
  50.     jbyteArray objArraySign = (jbyteArray) env->CallObjectMethod(objMessageDigest, midDigest); 
  51.  
  52.     jsize intArrayLength = env->GetArrayLength(objArraySign); 
  53.     jbyte *byte_array_elements = env->GetByteArrayElements(objArraySign, NULL); 
  54.     size_t length = (size_t) intArrayLength * 2 + 1; 
  55.     char *char_result = (char *) malloc(length); 
  56.     memset(char_result, 0, length); 
  57.     toHexStr((const char *) byte_array_elements, char_result, intArrayLength); 
  58.     // 在末尾补\0 
  59.     *(char_result + intArrayLength * 2) = '\0'; 
  60.     jstring stringResult = env->NewStringUTF(char_result); 
  61.     // release 
  62.     env->ReleaseByteArrayElements(objArraySign, byte_array_elements, JNI_ABORT); 
  63.     // 指针 
  64.     free(char_result); 
  65.     return stringResult; 
  66. } 
  67.  
  68. //转换为16进制字符串 
  69. void toHexStr(const char *source, char *dest, int sourceLen) { 
  70.     short i; 
  71.     char highByte, lowByte; 
  72.     for (i = 0; i < sourceLen; i++) { 
  73.         highByte = source[i] >> 4; 
  74.         lowByte = (char) (source[i] & 0x0f); 
  75.         highByte += 0x30; 
  76.         if (highByte > 0x39) { 
  77.             dest[i * 2] = (char) (highByte + 0x07); 
  78.         } else { 
  79.             dest[i * 2] = highByte; 
  80.         } 
  81.         lowByte += 0x30; 
  82.         if (lowByte > 0x39) { 
  83.             dest[i * 2 + 1] = (char) (lowByte + 0x07); 
  84.         } else { 
  85.             dest[i * 2 + 1] = lowByte; 
  86.         } 
  87.     } 
  88. } 

4.事件就此结束?

到这里就此结束了?too yuang too simple!!!虽然将密钥和加密算法写在了c++中，貌似好像是比较安全了。但是但是万一别人反编译后，拿到c++代码最终生成的so库，然后直接调用so库里的方法去获取密钥并调用加密方法怎么破?看来我们还是要加一步身份校验才行：即在native层对应用的包名、签名进行鉴权校验，校验通过才返回正确结果。下面就是获取apk包名和签名校验的代码：

  1. const char *PACKAGE_NAME = "你的ApplicationId"; 
  2. //(签名的md5值自己可以写方法获取,或者用签名工具直接获取，一般对接微信sdk的时候也会要应用签名的MD5值) 
  3. const char *SIGN_MD5 = "你的应用签名的MD5值注意是大写"; 
  4.  
  5. //获取Application实例 
  6. jobject getApplication(JNIEnv *env) { 
  7.     jobject application = NULL; 
  8.     //这里是你的Application的类路径,混淆时注意不要混淆该类和该类获取实例的方法比如getInstance 
  9.     jclass baseapplication_clz = env->FindClass("com/test/component/BaseApplication"); 
  10.     if (baseapplication_clz != NULL) { 
  11.         jmethodID currentApplication = env->GetStaticMethodID( 
  12.                 baseapplication_clz, "getInstance", 
  13.                 "()Lcom/test/component/BaseApplication;"); 
  14.         if (currentApplication != NULL) { 
  15.             application = env->CallStaticObjectMethod(baseapplication_clz, currentApplication); 
  16.         } 
  17.         env->DeleteLocalRef(baseapplication_clz); 
  18.     } 
  19.     return application; 
  20. } 
  21.  
  22.  
  23. bool isRight = false; 
  24. //获取应用签名的MD5值并判断是否与本应用的一致 
  25. jboolean getSignature(JNIEnv *env) { 
  26.     LOGD("getSignature isRight: %d", isRight ? 1 : 0); 
  27.     if (!isRight) {//避免每次都进行校验浪费资源，只要第一次校验通过后，后边就不在进行校验 
  28.         jobject context = getApplication(env); 
  29.         // 获得Context类 
  30.         jclass cls = env->FindClass("android/content/Context"); 
  31.         // 得到getPackageManager方法的ID 
  32.         jmethodID mid = env->GetMethodID(cls, "getPackageManager", 
  33.                                          "()Landroid/content/pm/PackageManager;"); 
  34.  
  35.         // 获得应用包的管理器 
  36.         jobject pm = env->CallObjectMethod(context, mid); 
  37.  
  38.         // 得到getPackageName方法的ID 
  39.         mid = env->GetMethodID(cls, "getPackageName", "()Ljava/lang/String;"); 
  40.         // 获得当前应用包名 
  41.         jstring packageName = (jstring) env->CallObjectMethod(context, mid); 
  42.         const char *c_pack_name = env->GetStringUTFChars(packageName, NULL); 
  43.  
  44.         // 比较包名,若不一致，直接return包名 
  45.         if (strcmp(c_pack_name, PACKAGE_NAME) != 0) { 
  46.             return false; 
  47.         } 
  48.         // 获得PackageManager类 
  49.         cls = env->GetObjectClass(pm); 
  50.         // 得到getPackageInfo方法的ID 
  51.         mid = env->GetMethodID(cls, "getPackageInfo", 
  52.                                "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;"); 
  53.         // 获得应用包的信息 
  54.         jobject packageInfo = env->CallObjectMethod(pm, mid, packageName, 
  55.                                                     0x40); //GET_SIGNATURES = 64; 
  56.         // 获得PackageInfo 类 
  57.         cls = env->GetObjectClass(packageInfo); 
  58.         // 获得签名数组属性的ID 
  59.         jfieldID fid = env->GetFieldID(cls, "signatures", "[Landroid/content/pm/Signature;"); 
  60.         // 得到签名数组 
  61.         jobjectArray signatures = (jobjectArray) env->GetObjectField(packageInfo, fid); 
  62.         // 得到签名 
  63.         jobject signature = env->GetObjectArrayElement(signatures, 0); 
  64.  
  65.         // 获得Signature类 
  66.         cls = env->GetObjectClass(signature); 
  67.         mid = env->GetMethodID(cls, "toByteArray", "()[B"); 
  68.         // 当前应用签名信息 
  69.         jbyteArray signatureByteArray = (jbyteArray) env->CallObjectMethod(signature, mid); 
  70.         //转成jstring 
  71.         jstring str = toMd5(env, signatureByteArray); 
  72.         char *c_msg = (char *) env->GetStringUTFChars(str, 0); 
  73.         LOGD("getSignature release sign md5: %s", c_msg); 
  74.         isRight = strcmp(c_msg, SIGN_MD5) == 0; 
  75.         return isRight; 
  76.     } 
  77.     return isRight; 
  78. } 
  79.  
  80.  
  81. //有了校验的方法，所以我们要对第3步中，获取密钥和加密方法的进行修改，添加校验的逻辑 
  82. extern "C" JNIEXPORT jstring JNICALL Java_com_test_util_HttpKeyUtil_getHttpSecretKey 
  83.         (JNIEnv *env, jclass cls, jint index) { 
  84.     if (getSignature(env)){//校验通过 
  85.       if (随机数条件1) { 
  86.         return env->NewStringUTF(KEY1); 
  87.       } else if (随机数条件2) { 
  88.         return env->NewStringUTF(KEY2); 
  89.       } else if (随机数条件3) { 
  90.         return env->NewStringUTF(KEY3); 
  91.       } else { 
  92.         return env->NewStringUTF(UNKNOWN); 
  93.       } 
  94.     }else { 
  95.         return env->NewStringUTF(UNKNOWN); 
  96.     } 
  97. } 
  98.  
  99. extern "C" JNIEXPORT jstring JNICALL 
  100. Java_com_test_util_HttpKeyUtil_getSecretValue 
  101.         (JNIEnv *env, jclass cls, jbyteArray jbyteArray1) { 
  102.         //加密算法各有不同，这里我就用md5做个示范 
  103.     if (getSignature(env)){//校验通过 
  104.        return toMd5(env, jbyteArray1); 
  105.     }else { 
  106.         return env->NewStringUTF(UNKNOWN); 
  107.     } 
  108. } 
  109.  
  110. 作者：AirSj 
  111. 链接：https://juejin.im/post/6862732328406351879 
  112. 来源：掘金 
  113. 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 

5.总结

以上就是此次事件native的相关代码，至于如何生成so库可以自行百度。从此次事件中需要反思的几点是：

安全性的认识，安全无小事

发布出去的包必须走加固流程，为了防止疏漏，禁止人工打包加固，全部通过脚本实现

服务端增加相关风险的报警机制

作者：AirSj

链接：https://juejin.im/post/6862732328406351879

来源：掘金


本文转载自网络，原文链接：https://juejin.im/post/6862732328406351879
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！
上一篇：快速扩展应用程序的6条经验 下一篇：没有了

推荐图文

  • 周排行
  • 月排行
  • 总排行

随机推荐