Android NDK与SDK内存共享：设备安全等级判定结果C层存储实现

我之前处理过类似的Android安全需求，针对你不想让安全判定结果经过Java层（怕被Hook篡改）的问题，这里有一套成熟的解决方案，核心思路是让C层全程持有敏感结果，只通过安全的方式和Java层交互：

1. 用C层静态变量/单例存储判定结果 #

首先，把你的安全等级判定结果存在Native层的静态全局变量或者单例对象里，全程不通过Java方法返回，从根源上避免被Hook篡改。

比如，基于你现有的C++判定逻辑，我们可以改造如下：

#include <jni.h>

// 静态全局变量存储安全等级，-1表示未执行判定
static int s_security_level = -1;

// 你的原有稳定判定逻辑（这里简化示例）
void calculateSecurityLevel() {
    // 替换成你实际的判定代码：检查root、调试状态、篡改痕迹等
    if (isDeviceRooted()) {
        s_security_level = 0; // 高风险
    } else if (isAppDebuggable()) {
        s_security_level = 1; // 中风险
    } else {
        s_security_level = 2; // 安全
    }
}

// JNI方法：只触发判定，不返回结果
extern "C" JNIEXPORT void JNICALL
Java_com_your_package_SecurityChecker_triggerSecurityCheck(JNIEnv* env, jobject thiz) {
    // 可选：保证判定只执行一次，避免重复计算
    if (s_security_level == -1) {
        calculateSecurityLevel();
    }
}

这里的关键是：只给Java层暴露"触发判定"的方法，不直接返回结果，所有敏感状态都留在C层内存里。

2. 安全的结果查询：用"验证式"替代"直接获取" #

如果Java层需要用到判定结果，不要直接返回int或字符串，而是设计成"验证预期值是否匹配"的模式。这样即使攻击者Hook了Java方法，也不知道真实结果是什么，只能盲目尝试。

C层代码示例：

#include <mutex>

// 加锁保证线程安全（多线程环境必须加）
static std::mutex s_security_mutex;

extern "C" JNIEXPORT jboolean JNICALL
Java_com_your_package_SecurityChecker_isSecurityLevelMatch(JNIEnv* env, jobject thiz, jint expected_level) {
    std::lock_guard<std::mutex> lock(s_security_mutex);
    
    // 先确保判定已执行
    if (s_security_level == -1) {
        calculateSecurityLevel();
    }
    
    return (s_security_level == expected_level) ? JNI_TRUE : JNI_FALSE;
}

Java层调用示例：

public class SecurityChecker {
    static {
        System.loadLibrary("security-check");
    }

    public native void triggerSecurityCheck();
    public native boolean isSecurityLevelMatch(int expectedLevel);

    // 业务侧使用：判断设备是否安全
    public boolean isDeviceSafe() {
        triggerSecurityCheck();
        return isSecurityLevelMatch(2); // 查询是否是安全等级2
    }
}

3. 复杂结果的处理：用Native直接内存共享 #

如果你的判定结果是复杂结构（比如字符串、自定义数据），可以用JNI的直接ByteBuffer来共享Native层内存，避免数据拷贝到Java堆，进一步降低风险：

C层代码：

#include <cstdlib>
#include <cstring>

static char* s_security_detail = nullptr;

void calculateSecurityDetail() {
    std::lock_guard<std::mutex> lock(s_security_mutex);
    if (s_security_detail != nullptr) return;
    
    // 你的真实判定结果字符串
    const char* result = "Device is safe: no root, no debug flag";
    s_security_detail = (char*)malloc(strlen(result) + 1);
    strcpy(s_security_detail, result);
}

// 返回直接ByteBuffer，指向Native内存
extern "C" JNIEXPORT jobject JNICALL
Java_com_your_package_SecurityChecker_getSecurityDetailBuffer(JNIEnv* env, jobject thiz) {
    std::lock_guard<std::mutex> lock(s_security_mutex);
    if (s_security_detail == nullptr) {
        calculateSecurityDetail();
    }
    return env->NewDirectByteBuffer(s_security_detail, strlen(s_security_detail));
}

// JNI卸载时释放内存，避免泄漏
extern "C" JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM* vm, void* reserved) {
    std::lock_guard<std::mutex> lock(s_security_mutex);
    if (s_security_detail != nullptr) {
        free(s_security_detail);
        s_security_detail = nullptr;
    }
}

Java层访问：

public native ByteBuffer getSecurityDetailBuffer();

public String getSecurityDetail() {
    ByteBuffer buffer = getSecurityDetailBuffer();
    byte[] bytes = new byte[buffer.remaining()];
    buffer.get(bytes);
    return new String(bytes);
}

额外安全建议 #

• 线程安全必做：多线程环境下一定要加互斥锁，避免竞态条件导致的结果错误。
• 配合Native混淆：用LLVM混淆或者其他Native加固工具，增加攻击者逆向分析C层代码的难度。
• 避免Java层缓存结果：Java层不要存储判定结果，每次需要都通过C层验证，防止缓存被篡改。

内容的提问来源于stack exchange，提问作者MohanRaj