Android JNI 防二次打包應用簽名檢測

國內android市場的環境比較混亂，大小市場有數百家，應用被修改或加廣告病毒後二次打包發佈也是常有的事情，對開發者和用戶都造成了損失

經各方資料研究，在C++中做簽名檢測處理，安全性更高一些，結合網上資料，寫下此文

簽名檢測邏輯

• 獲取應用簽名生成的MD5值寫入C++中 (C++中會打印出當前的MD5,後面會說)
• 獲取Application
• 獲取應用的簽名信息
• 將簽名信息MD5化
• 匹配簽名MD5是否與寫入的相同
• 簽名不同時在JNI_OnLoad 中返回 -1
• 在App的代碼中加載so文件，會自動調用JNI_OnLoad,若返回-1，App Crash掉

NDK編譯

NDK編譯使用的實驗性NDK構建插件 Experimental Plugin
只要是因爲該插件支持C語言Debug調試,但是使用該插件需要修改Module的Build.gradle文件，不太建議使用在開發的項目中，可以使用之前的NDK或CMake來編譯NDK

這裏不介紹實驗性NDK插件了，附上使用手冊Experimental Plugin use guide

Java代碼上的邏輯

/**
 * 獲取Application，ActivityThread是一個不被公開的類，java代碼是不可直接調用的
 * 對應C++代碼中的static jobject getApplication(JNIEnv *env)
 */
Application application = ActivityThread.currentApplication();

/**
 * 獲取Signature數據
 * 對應C++ 的jstring loadSignature(JNIEnv *env, jobject * *context) 方法
 */
        PackageManager manager = application.getPackageManager();
        String packageName = application.getPackageName();
        PackageInfo packageInfo = manager.getPackageInfo(packageName,PackageManager.GET_SIGNATURES);
        Signature signature = packageInfo.signatures[0];
        byte[] chars = signature.toByteArray();
        
/**
* 將數據MD5化
* 對應C++的jstring ToMd5(JNIEnv *env, jbyteArray source)
*/
        MessageDigest digest = MessageDigest.getInstance("md5");
        digest.update(chars);
        byte[] objArraySign = digest.digest(chars);
        
//MD5化的C++ 代碼
        jsize intArrayLength = env->GetArrayLength(objArraySign);
        jbyte *byte_array_elements = env->GetByteArrayElements(objArraySign, NULL);
        size_t length = (size_t) intArrayLength * 2 + 1;
        char *char_result = (char *) malloc(length);
        memset(char_result, 0, length);
        // 將byte數組轉換成16進制字符串，發現這裏不用強轉，jbyte和unsigned char應該字節數是一樣的
        ByteToHexStr((const char *) byte_array_elements, char_result, intArrayLength);
        // 在末尾補\0
    *(char_result + intArrayLength * 2) = '\0';
        jstring stringResult = env->NewStringUTF(char_result);

//檢測當前應用的簽名MD5與我們設置的MD5是否一致

奉上C++ 代碼

#include <jni.h>
#include <string.h>
#include <android/log.h>
#include <malloc.h>

#define  LOG_TAG    "native-dev"
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)

const char *APP_SIGNATURE = "10645EA8A12BE7A2C04B1F81DF3B4D90";

void ByteToHexStr(const char *source, char *dest, int sourceLen) {
    short i;
    char highByte, lowByte;

    for (i = 0; i < sourceLen; i++) {
        highByte = source[i] >> 4;
        lowByte = source[i] & 0x0f;
        highByte += 0x30;

        if (highByte > 0x39) {
            dest[i * 2] = highByte + 0x07;
        } else {
            dest[i * 2] = highByte;
        }

        lowByte += 0x30;
        if (lowByte > 0x39) {
            dest[i * 2 + 1] = lowByte + 0x07;
        } else {
            dest[i * 2 + 1] = lowByte;
        }
    }
}


// byte數組轉MD5字符串
jstring ToMd5(JNIEnv *env, jbyteArray source) {
    // MessageDigest類
    jclass classMessageDigest = env->FindClass("java/security/MessageDigest");
    // MessageDigest.getInstance()靜態方法
    jmethodID midGetInstance = env->GetStaticMethodID(classMessageDigest, "getInstance",
                                                      "(Ljava/lang/String;)Ljava/security/MessageDigest;");
    // MessageDigest object
    jobject objMessageDigest = env->CallStaticObjectMethod(classMessageDigest, midGetInstance,
                                                           env->NewStringUTF("md5"));

    // update方法，這個函數的返回值是void，寫V
    jmethodID midUpdate = env->GetMethodID(classMessageDigest, "update", "([B)V");
    env->CallVoidMethod(objMessageDigest, midUpdate, source);

    // digest方法
    jmethodID midDigest = env->GetMethodID(classMessageDigest, "digest", "()[B");
    jbyteArray objArraySign = (jbyteArray) env->CallObjectMethod(objMessageDigest, midDigest);

    jsize intArrayLength = env->GetArrayLength(objArraySign);
    jbyte *byte_array_elements = env->GetByteArrayElements(objArraySign, NULL);
    size_t length = (size_t) intArrayLength * 2 + 1;
    char *char_result = (char *) malloc(length);
    memset(char_result, 0, length);

    // 將byte數組轉換成16進制字符串，發現這裏不用強轉，jbyte和unsigned char應該字節數是一樣的
    ByteToHexStr((const char *) byte_array_elements, char_result, intArrayLength);
    // 在末尾補\0
    *(char_result + intArrayLength * 2) = '\0';

    jstring stringResult = env->NewStringUTF(char_result);
    // release
    env->ReleaseByteArrayElements(objArraySign, byte_array_elements, JNI_ABORT);
    // 釋放指針使用free
    free(char_result);
    env->DeleteLocalRef(classMessageDigest);
    env->DeleteLocalRef(objMessageDigest);

    return stringResult;
}

//獲取應用簽名
 jstring loadSignature(JNIEnv *env, jobject context) {
    // 獲得Context類
    jclass cls = env->GetObjectClass(context);
    // 得到getPackageManager方法的ID
    jmethodID mid = env->GetMethodID(cls, "getPackageManager",
                                     "()Landroid/content/pm/PackageManager;");

    // 獲得應用包的管理器
    jobject pm = env->CallObjectMethod(context, mid);

    // 得到getPackageName方法的ID
    mid = env->GetMethodID(cls, "getPackageName", "()Ljava/lang/String;");
    // 獲得當前應用包名
    jstring packageName = (jstring) env->CallObjectMethod(context, mid);

    // 獲得PackageManager類
    cls = env->GetObjectClass(pm);
    // 得到getPackageInfo方法的ID
    mid = env->GetMethodID(cls, "getPackageInfo",
                           "(Ljava/lang/String;I)Landroid/content/pm/PackageInfo;");
    // 獲得應用包的信息
    jobject packageInfo = env->CallObjectMethod(pm, mid, packageName, 0x40); //GET_SIGNATURES = 64;
    // 獲得PackageInfo 類
    cls = env->GetObjectClass(packageInfo);
    // 獲得簽名數組屬性的ID
    jfieldID fid = env->GetFieldID(cls, "signatures", "[Landroid/content/pm/Signature;");
    // 得到簽名數組
    jobjectArray signatures = (jobjectArray) env->GetObjectField(packageInfo, fid);
    // 得到簽名
    jobject signature = env->GetObjectArrayElement(signatures, 0);

    // 獲得Signature類
    cls = env->GetObjectClass(signature);
    // 得到toCharsString方法的ID
    mid = env->GetMethodID(cls, "toByteArray", "()[B");
    // 返回當前應用簽名信息
    jbyteArray signatureByteArray = (jbyteArray) env->CallObjectMethod(signature, mid);

    return ToMd5(env, signatureByteArray);
}
//檢測簽名是否匹配
jboolean checkSignature(
        JNIEnv *env, jobject context) {

    jstring appSignature = loadSignature(env,
                                                                           context); // 當前 App 的簽名
    jstring releaseSignature = env->NewStringUTF(APP_SIGNATURE); // 發佈時候的簽名
    const char *charAppSignature = env->GetStringUTFChars(appSignature, NULL);
    const char *charReleaseSignature = env->GetStringUTFChars(releaseSignature, NULL);

//    LOGI("  start cmp  getSignature");
       __android_log_print(ANDROID_LOG_INFO, LOG_TAG, charAppSignature);
//    LOGI("  start cmp  getReleaseSignature");
    //  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, charAppSignature);

    jboolean result = JNI_FALSE;
    // 比較是否相等
    if (charAppSignature != NULL && charReleaseSignature != NULL) {
        if (strcmp(charAppSignature, charReleaseSignature) == 0) {
            result = JNI_TRUE;
        }
    }

    env->ReleaseStringUTFChars(appSignature, charAppSignature);
    env->ReleaseStringUTFChars(releaseSignature, charReleaseSignature);

    return result;
}

static jobject getApplication(JNIEnv *env) {
    jobject application = NULL;
    jclass activity_thread_clz = env->FindClass("android/app/ActivityThread");
    if (activity_thread_clz != NULL) {
        jmethodID currentApplication = env->GetStaticMethodID(
                activity_thread_clz, "currentApplication", "()Landroid/app/Application;");
        if (currentApplication != NULL) {
            application = env->CallStaticObjectMethod(activity_thread_clz, currentApplication);
        } else {
            //           LOGE("Cannot find method: currentApplication() in ActivityThread.");
        }
        env->DeleteLocalRef(activity_thread_clz);
    } else {
//        LOGE("Cannot find class: android.app.ActivityThread");
    }

    return application;
}

/**
 * 檢查加載該so的應用的簽名，與預置的簽名是否一致
 */
static jboolean checkSignature(JNIEnv *env) {

    // 調用 getContext 方法得到 Context 對象
    jobject appContext = getApplication(env);

    if (appContext != NULL) {
        jboolean signatureValid = checkSignature(
                env, appContext);
        return signatureValid;
    }

    return JNI_FALSE;
}

/**
 * 加載 so 文件的時候，會觸發 OnLoad
 * 檢測失敗，返回 -1，App 就會 Crash
 */
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
//    LOGI("  JNI_OnLoad  ");
    if (vm->GetEnv((void **) (&env), JNI_VERSION_1_6) != JNI_OK) {
        return -1;
    }
//    LOGI("  start checkSignature  ");
    if (checkSignature(env) != JNI_TRUE) {
//        LOGI("  checkSignature = false ");
        // 檢測不通過，返回 -1 就會使 App crash
        return -1;
    }

    return JNI_VERSION_1_6;
}

在C++的 checkSignature方法中，
__android_log_print(ANDROID_LOG_INFO, LOG_TAG, charAppSignature);
此代碼會打印出當前應用的簽名MD5碼，也是我們需要寫在C++中用於檢測的MD5碼，獲取到之後寫C++中並註釋掉這行代碼

加載jni

static{
    System.loadLibrary("SignatureLib");
}

---

完整代碼的GitHub地址
https://github.com/junzLiu/JniTest

參考資料

• 前人方案代碼 https://github.com/ksxkq/CheckSignatureInNativeSample
• Experimental Plugin User Guide http://tools.android.com/tech-docs/new-build-system/gradle-experimental

如有問題 歡迎指正 與君共勉