Android11绕过反射限制的方法

1. 问题出现的背景

腾讯视频在集成我们 replay sdk 的时候发现这么个错误，导致整个 db mock 功能完全失效。

accessing hidden field landroid/database/sqlite/sqlitecursor;
->mdriver:landroid/database/sqlite/sqlitecursordriver; (greylist-max-o, reflection, denied)

java.lang.nosuchfieldexception: no field mdriver in class landroid/database/sqlite/sqlitecursor;
(declaration of 'android.database.sqlite.sqlitecursor' appears in /system/framework/framework.jar)

我清晰的记得我们引入了一个第三方解决方案，在 9.0 以上已经解决了这个问题，大致的方案是这样的：

if (sdk_int >= build.version_codes.p) {
  try {
    method forname = class.class.getdeclaredmethod("forname", string.class);
    method getdeclaredmethod = class.class.getdeclaredmethod("getdeclaredmethod", string.class, class[].class);

    class<?> vmruntimeclass = (class<?>) forname.invoke(null, "dalvik.system.vmruntime");
    method getruntime = (method) getdeclaredmethod.invoke(vmruntimeclass, "getruntime", null);
    sethiddenapiexemptions = (method) getdeclaredmethod.invoke(vmruntimeclass, "sethiddenapiexemptions", new class[]{string[].class});
    svmruntime = getruntime.invoke(null);
  } catch (throwable e) {
    log.e(tag, "reflect bootstrap failed:", e);
  }
}

吓得我赶紧去看下到底有没有猫腻，发现在 android 11 上果然有问题：

accessing hidden method ldalvik/system/vmruntime;
->sethiddenapiexemptions([ljava/lang/string;)v (blacklist,core-platform-api, reflection, denied)

caused by: java.lang.nosuchmethodexception: dalvik.system.vmruntime.sethiddenapiexemptions [class [ljava.lang.string;]
......

2. 分析问题出现的原因

本着时间紧任务重尽量不影响进度的情况下，我还是想去网上搜索看看，但是发现都是一堆旧的方案。迫不得已去看看到底为什么？到底为什么？刚好前几天找同事要了一份 android 11 的源码。

static jobject class_getdeclaredmethodinternal(jnienv* env, jobject javathis, jstring name, jobjectarray args) {
  // ……
  handle<mirror::method> result = hs.newhandle(
      mirror::class::getdeclaredmethodinternal<kruntimepointersize>(
          soa.self(),
          klass,
          soa.decode<mirror::string>(name),
          soa.decode<mirror::objectarray<mirror::class>>(args),
          gethiddenapiaccesscontextfunction(soa.self())));
  if (result == nullptr || shoulddenyaccesstomember(result->getartmethod(), soa.self())) {
    return nullptr;
  }
  return soa.addlocalreference<jobject>(result.get());
}

如果 shoulddenyaccesstomember 返回 true，那么就会返回 null，上层就会抛出方法找不到的异常。这里和 android p 没什么不同，只是把 shouldblockaccesstomember 改了个名而已。

shoulddenyaccesstomember 会调用到 hiddenapi::shoulddenyaccesstomember，该函数是这样实现的：

template<typename t>
inline bool shoulddenyaccesstomember(t* member,
                                     const std::function<accesscontext()>& fn_get_access_context,
                                     accessmethod access_method)
    requires_shared(locks::mutator_lock_) {

  const uint32_t runtime_flags = getruntimeflags(member);

  // 1：如果该成员是公开api，直接通过
  if ((runtime_flags & kaccpublicapi) != 0) {
    return false;
  }

  // 2：不是公开api（即为隐藏api），获取调用者和被访问成员的 domain 
  // 主要看这个
  const accesscontext caller_context = fn_get_access_context();
  const accesscontext callee_context(member->getdeclaringclass());

  // 3：如果调用者是可信的，直接返回
  if (caller_context.canalwaysaccess(callee_context)) {
    return false;
  }
  // ......
  }

原来的方案失效了能在 firstexternalcallervisitor 的 visitframe 方法中找到答案

bool visitframe() override requires_shared(locks::mutator_lock_) {
    artmethod *m = getmethod();
    ......
    objptr<mirror::class> declaring_class = m->getdeclaringclass();
    if (declaring_class->isbootstrapclassloaded()) {
        ......
        // 如果 prevent_meta_reflection_blacklist_access 为 enabled，跳过来自 java.lang.reflect.* 的访问
        // 系统对“套娃反射”的限制的关键就在此
        objptr<mirror::class> proxy_class = getclassroot<mirror::proxy>();
        if (declaring_class->isinsamepackage(proxy_class) && declaring_class != proxy_class) {
            if (runtime::current()->ischangeenabled(kpreventmetareflectionblacklistaccess)) {
                return true;
            }
        }
    }

    caller = m;
    return false;
}

3. 解决方案

• native hook 住 shoulddenyaccesstomember 方法，直接返回 false
• 破坏调用堆栈绕过去，使 vm 无法识别调用方

我们采用的是第二种方案，有什么方法可以让 vm 无法识别我的调用栈呢？这可以通过 jnienv::attachcurrentthread(…) 函数创建一个新的 thread 来完成。具体我们可以看下这里 ，然后配合 std::async(…)  与 std::async::get(..)  就能搞定了，下面是关键代码：

// java 层直接用 jni 调用这个方法
static jobject java_getdeclaredmethod(
    jnienv *env,
    jclass interface,
    jobject clazz,
    jstring method_name,
    jobjectarray params) {
  // ...... 省掉一些转换代码
  //  先用 std::async 调用 getdeclaredmethod_internal 方法
  auto future = std::async(&getdeclaredmethod_internal, global_clazz,
                           global_method_name,
                           global_params);
  auto result = future.get();
  return result;
}

static jobject getdeclaredmethod_internal(
    jobject clazz,
    jstring method_name,
    jobjectarray params) {
  // 这里就是一些普通的 jni 操作了
  jnienv *env = attachcurrentthread();
  jclass clazz_class = env->getobjectclass(clazz);
  jmethodid get_declared_method_id = env->getmethodid(clazz_class, "getdeclaredmethod",
                                                      "(ljava/lang/string;[ljava/lang/class;)ljava/lang/reflect/method;");
  jobject res = env->callobjectmethod(clazz, get_declared_method_id,
                                      method_name, params);
  detachcurrentthread();
  return env->newglobalref(res);
}

jnienv *attachcurrentthread() {
  jnienv *env;
  // attachcurrentthread 核心在这里
  int res = _vm->attachcurrentthread(&env, nullptr);
  return env;
}

到此这篇关于android11绕过反射限制的方法的文章就介绍到这了,更多相关android 绕过反射限制内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！