p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/art/runtime/hidden_api_test.cc

740 lines
35 KiB
C++
Raw Permalink Blame History

/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hidden_api.h"
#include <fstream>
#include <sstream>
#include "android-base/stringprintf.h"
#include "base/file_utils.h"
#include "base/sdk_version.h"
#include "base/stl_util.h"
#include "common_runtime_test.h"
#include "jni/jni_internal.h"
#include "proxy_test.h"
#include "well_known_classes.h"
namespace art {
using android::base::StringPrintf;
using hiddenapi::detail::MemberSignature;
using hiddenapi::detail::ShouldDenyAccessToMemberImpl;
// Should be the same as dalvik.system.VMRuntime.HIDE_MAXTARGETSDK_P_HIDDEN_APIS,
// dalvik.system.VMRuntime.HIDE_MAXTARGETSDK_Q_HIDDEN_APIS, and
// dalvik.system.VMRuntime.EXEMPT_TEST_API_ACCESS_VERIFICATION.
static constexpr uint64_t kHideMaxtargetsdkPHiddenApis = 149997251;
static constexpr uint64_t kHideMaxtargetsdkQHiddenApis = 149994052;
static constexpr uint64_t kAllowTestApiAccess = 166236554;
static bool Copy(const std::string& src, const std::string& dst, /*out*/ std::string* error_msg) {
std::ifstream src_stream(src, std::ios::binary);
std::ofstream dst_stream(dst, std::ios::binary);
dst_stream << src_stream.rdbuf();
src_stream.close();
dst_stream.close();
if (src_stream.good() && dst_stream.good()) {
return true;
} else {
*error_msg = "Copy " + src + " => " + dst + " (src_good="
+ (src_stream.good() ? "true" : "false") + ", dst_good="
+ (dst_stream.good() ? "true" : "false") + ")";
return false;
}
}
static bool LoadDexFiles(const std::string& path,
ScopedObjectAccess& soa,
/* out */ std::vector<std::unique_ptr<const DexFile>>* dex_files,
/* out */ ObjPtr<mirror::ClassLoader>* class_loader,
/* out */ std::string* error_msg) REQUIRES_SHARED(Locks::mutator_lock_) {
if (!ArtDexFileLoader().Open(path.c_str(),
path,
/* verify= */ true,
/* verify_checksum= */ true,
error_msg,
dex_files)) {
return false;
}
ClassLinker* const linker = Runtime::Current()->GetClassLinker();
StackHandleScope<2> hs(soa.Self());
Handle<mirror::Class> h_class = hs.NewHandle(soa.Decode<mirror::Class>(
WellKnownClasses::dalvik_system_PathClassLoader));
Handle<mirror::ClassLoader> h_loader = hs.NewHandle(linker->CreateWellKnownClassLoader(
soa.Self(),
MakeNonOwningPointerVector(*dex_files),
h_class,
/* parent_loader= */ ScopedNullHandle<mirror::ClassLoader>(),
/* shared_libraries= */ ScopedNullHandle<mirror::ObjectArray<mirror::ClassLoader>>()));
for (const auto& dex_file : *dex_files) {
linker->RegisterDexFile(*dex_file.get(), h_loader.Get());
}
*class_loader = h_loader.Get();
return true;
}
static bool Remove(const std::string& path, /*out*/ std::string* error_msg) {
if (TEMP_FAILURE_RETRY(remove(path.c_str())) == 0) {
return true;
}
*error_msg = StringPrintf("Unable to remove(\"%s\"): %s", path.c_str(), strerror(errno));
return false;
}
static bool CheckAllDexFilesInDomain(ObjPtr<mirror::ClassLoader> loader,
const std::vector<std::unique_ptr<const DexFile>>& dex_files,
hiddenapi::Domain expected_domain,
/* out */ std::string* error_msg)
REQUIRES_SHARED(Locks::mutator_lock_) {
for (const auto& dex_file : dex_files) {
hiddenapi::AccessContext context(loader, dex_file.get());
if (context.GetDomain() != expected_domain) {
std::stringstream ss;
ss << dex_file->GetLocation() << ": access context domain does not match "
<< "(expected=" << static_cast<uint32_t>(expected_domain)
<< ", actual=" << static_cast<uint32_t>(context.GetDomain()) << ")";
*error_msg = ss.str();
return false;
}
if (dex_file->GetHiddenapiDomain() != expected_domain) {
std::stringstream ss;
ss << dex_file->GetLocation() << ": dex file domain does not match "
<< "(expected=" << static_cast<uint32_t>(expected_domain)
<< ", actual=" << static_cast<uint32_t>(dex_file->GetHiddenapiDomain()) << ")";
*error_msg = ss.str();
return false;
}
}
return true;
}
class HiddenApiTest : public CommonRuntimeTest {
protected:
void SetUp() override {
// Do the normal setup.
CommonRuntimeTest::SetUp();
self_ = Thread::Current();
self_->TransitionFromSuspendedToRunnable();
jclass_loader_ = LoadDex("HiddenApiSignatures");
bool started = runtime_->Start();
CHECK(started);
class1_field1_ = GetArtField("mypackage/packagea/Class1", "field1", "I");
class1_field12_ = GetArtField("mypackage/packagea/Class1", "field12", "I");
class1_init_ = GetArtMethod("mypackage/packagea/Class1", "<init>", "()V");
class1_method1_ = GetArtMethod("mypackage/packagea/Class1", "method1", "()V");
class1_method1_i_ = GetArtMethod("mypackage/packagea/Class1", "method1", "(I)V");
class1_method12_ = GetArtMethod("mypackage/packagea/Class1", "method12", "()V");
class12_field1_ = GetArtField("mypackage/packagea/Class12", "field1", "I");
class12_method1_ = GetArtMethod("mypackage/packagea/Class12", "method1", "()V");
class2_field1_ = GetArtField("mypackage/packagea/Class2", "field1", "I");
class2_method1_ = GetArtMethod("mypackage/packagea/Class2", "method1", "()V");
class2_method1_i_ = GetArtMethod("mypackage/packagea/Class2", "method1", "(I)V");
class3_field1_ = GetArtField("mypackage/packageb/Class3", "field1", "I");
class3_method1_ = GetArtMethod("mypackage/packageb/Class3", "method1", "()V");
class3_method1_i_ = GetArtMethod("mypackage/packageb/Class3", "method1", "(I)V");
}
ArtMethod* GetArtMethod(const char* class_name, const char* name, const char* signature) {
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass klass = env->FindClass(class_name);
jmethodID method_id = env->GetMethodID(klass, name, signature);
ArtMethod* art_method = jni::DecodeArtMethod(method_id);
return art_method;
}
ArtField* GetArtField(const char* class_name, const char* name, const char* signature) {
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass klass = env->FindClass(class_name);
jfieldID field_id = env->GetFieldID(klass, name, signature);
ArtField* art_field = jni::DecodeArtField(field_id);
return art_field;
}
void SetChangeIdState(uint64_t change, bool enabled) {
CompatFramework& compat_framework = runtime_->GetCompatFramework();
std::set<uint64_t> disabled_changes = compat_framework.GetDisabledCompatChanges();
if (enabled) {
disabled_changes.erase(change);
} else {
disabled_changes.insert(change);
}
compat_framework.SetDisabledCompatChanges(disabled_changes);
}
bool ShouldDenyAccess(hiddenapi::ApiList list) REQUIRES_SHARED(Locks::mutator_lock_) {
// Choose parameters such that there are no side effects (AccessMethod::kNone)
// and that the member is not on the exemptions list (here we choose one which
// is not even in boot class path).
return ShouldDenyAccessToMemberImpl(/* member= */ class1_field1_,
list,
/* access_method= */ hiddenapi::AccessMethod::kNone);
}
void TestLocation(const std::string& location, hiddenapi::Domain expected_domain) {
ScopedObjectAccess soa(Thread::Current());
std::vector<std::unique_ptr<const DexFile>> dex_files;
std::string error_msg;
ObjPtr<mirror::ClassLoader> class_loader;
ASSERT_TRUE(Copy(GetTestDexFileName("Main"), location, &error_msg)) << error_msg;
ASSERT_TRUE(LoadDexFiles(location, soa, &dex_files, &class_loader, &error_msg))
<< error_msg;
ASSERT_GE(dex_files.size(), 1u);
ASSERT_TRUE(CheckAllDexFilesInDomain(class_loader,
dex_files,
expected_domain,
&error_msg)) << error_msg;
dex_files.clear();
ASSERT_TRUE(Remove(location, &error_msg)) << error_msg;
}
protected:
Thread* self_;
jobject jclass_loader_;
ArtField* class1_field1_;
ArtField* class1_field12_;
ArtMethod* class1_init_;
ArtMethod* class1_method1_;
ArtMethod* class1_method1_i_;
ArtMethod* class1_method12_;
ArtField* class12_field1_;
ArtMethod* class12_method1_;
ArtField* class2_field1_;
ArtMethod* class2_method1_;
ArtMethod* class2_method1_i_;
ArtField* class3_field1_;
ArtMethod* class3_method1_;
ArtMethod* class3_method1_i_;
};
TEST_F(HiddenApiTest, CheckGetActionFromRuntimeFlags) {
ScopedObjectAccess soa(self_);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kJustWarn);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), false);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetO().GetMaxAllowedSdkVersion()));
SetChangeIdState(kHideMaxtargetsdkPHiddenApis, false);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetO().GetMaxAllowedSdkVersion()) + 1);
SetChangeIdState(kHideMaxtargetsdkPHiddenApis, false);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetP().GetMaxAllowedSdkVersion()) + 1);
SetChangeIdState(kHideMaxtargetsdkPHiddenApis, true);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetQ().GetMaxAllowedSdkVersion()) + 1);
SetChangeIdState(kHideMaxtargetsdkPHiddenApis, true);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetR().GetMaxAllowedSdkVersion()) + 1);
SetChangeIdState(kHideMaxtargetsdkPHiddenApis, true);
SetChangeIdState(kHideMaxtargetsdkQHiddenApis, true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetR()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetQ()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetP()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(ShouldDenyAccess(hiddenapi::ApiList::Blocked()), true);
}
TEST_F(HiddenApiTest, CheckTestApiEnforcement) {
ScopedObjectAccess soa(self_);
runtime_->SetHiddenApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
runtime_->SetTargetSdkVersion(
static_cast<uint32_t>(hiddenapi::ApiList::MaxTargetR().GetMaxAllowedSdkVersion()) + 1);
// Default case where all TestApis are treated like non-TestApi.
runtime_->SetTestApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
SetChangeIdState(kAllowTestApiAccess, false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetR()), true);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetQ()), true);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetP()), true);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetO()), true);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Blocked()), true);
// A case where we want to allow access to TestApis.
runtime_->SetTestApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kDisabled);
SetChangeIdState(kAllowTestApiAccess, false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetO()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Blocked()), false);
// A second case where we want to allow access to TestApis.
runtime_->SetTestApiEnforcementPolicy(hiddenapi::EnforcementPolicy::kEnabled);
SetChangeIdState(kAllowTestApiAccess, true);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Sdk()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Unsupported()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetR()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetQ()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetP()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::MaxTargetO()), false);
ASSERT_EQ(
ShouldDenyAccess(hiddenapi::ApiList::TestApi() | hiddenapi::ApiList::Blocked()), false);
}
TEST_F(HiddenApiTest, CheckMembersRead) {
ASSERT_NE(nullptr, class1_field1_);
ASSERT_NE(nullptr, class1_field12_);
ASSERT_NE(nullptr, class1_init_);
ASSERT_NE(nullptr, class1_method1_);
ASSERT_NE(nullptr, class1_method1_i_);
ASSERT_NE(nullptr, class1_method12_);
ASSERT_NE(nullptr, class12_field1_);
ASSERT_NE(nullptr, class12_method1_);
ASSERT_NE(nullptr, class2_field1_);
ASSERT_NE(nullptr, class2_method1_);
ASSERT_NE(nullptr, class2_method1_i_);
ASSERT_NE(nullptr, class3_field1_);
ASSERT_NE(nullptr, class3_method1_);
ASSERT_NE(nullptr, class3_method1_i_);
}
TEST_F(HiddenApiTest, CheckEverythingMatchesL) {
ScopedObjectAccess soa(self_);
std::string prefix("L");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_method1_i_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class3_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class3_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class3_method1_i_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckPackageMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class2_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class3_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class3_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class3_method1_i_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckClassMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class12_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_method1_i_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckClassExactMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class12_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class12_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class2_method1_i_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMethodMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->method1");
ASSERT_FALSE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class12_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class12_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMethodExactMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->method1(");
ASSERT_FALSE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMethodSignatureMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->method1(I)");
ASSERT_FALSE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMethodSignatureAndReturnMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->method1()V");
ASSERT_FALSE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckFieldMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->field1");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_TRUE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_i_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method12_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckFieldExactMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->field1:");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckFieldTypeMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->field1:I");
ASSERT_TRUE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_field12_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckConstructorMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;-><init>");
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckConstructorExactMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;-><init>()V");
ASSERT_TRUE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMethodSignatureTrailingCharsNoMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->method1()Vfoo");
ASSERT_FALSE(MemberSignature(class1_method1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckConstructorTrailingCharsNoMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;-><init>()Vfoo");
ASSERT_FALSE(MemberSignature(class1_init_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckFieldTrailingCharsNoMatch) {
ScopedObjectAccess soa(self_);
std::string prefix("Lmypackage/packagea/Class1;->field1:Ifoo");
ASSERT_FALSE(MemberSignature(class1_field1_).DoesPrefixMatch(prefix));
}
TEST_F(HiddenApiTest, CheckMemberSignatureForProxyClass) {
ScopedObjectAccess soa(self_);
StackHandleScope<4> hs(soa.Self());
Handle<mirror::ClassLoader> class_loader(
hs.NewHandle(soa.Decode<mirror::ClassLoader>(jclass_loader_)));
// Find interface we will create a proxy for.
Handle<mirror::Class> h_iface(hs.NewHandle(
class_linker_->FindClass(soa.Self(), "Lmypackage/packagea/Interface;", class_loader)));
ASSERT_TRUE(h_iface != nullptr);
// Create the proxy class.
std::vector<Handle<mirror::Class>> interfaces;
interfaces.push_back(h_iface);
Handle<mirror::Class> proxyClass = hs.NewHandle(proxy_test::GenerateProxyClass(
soa, jclass_loader_, runtime_->GetClassLinker(), "$Proxy1234", interfaces));
ASSERT_TRUE(proxyClass != nullptr);
ASSERT_TRUE(proxyClass->IsProxyClass());
ASSERT_TRUE(proxyClass->IsInitialized());
// Find the "method" virtual method.
ArtMethod* method = nullptr;
for (auto& m : proxyClass->GetDeclaredVirtualMethods(kRuntimePointerSize)) {
if (strcmp("method", m.GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetName()) == 0) {
method = &m;
break;
}
}
ASSERT_TRUE(method != nullptr);
// Find the "interfaces" static field. This is generated for all proxies.
ArtField* field = nullptr;
for (size_t i = 0; i < proxyClass->NumStaticFields(); ++i) {
ArtField* f = proxyClass->GetStaticField(i);
if (strcmp("interfaces", f->GetName()) == 0) {
field = f;
break;
}
}
ASSERT_TRUE(field != nullptr);
// Test the signature. We expect the signature from the interface class.
std::ostringstream ss_method;
MemberSignature(method->GetInterfaceMethodIfProxy(kRuntimePointerSize)).Dump(ss_method);
ASSERT_EQ("Lmypackage/packagea/Interface;->method()V", ss_method.str());
// Test the signature. We expect the signature of the proxy class.
std::ostringstream ss_field;
MemberSignature(field).Dump(ss_field);
ASSERT_EQ("L$Proxy1234;->interfaces:[Ljava/lang/Class;", ss_field.str());
}
TEST_F(HiddenApiTest, DexDomain_DataDir) {
// Load file from a non-system directory and check that it is not flagged as framework.
std::string data_location_path = android_data_ + "/foo.jar";
ASSERT_FALSE(LocationIsOnSystemFramework(data_location_path.c_str()));
TestLocation(data_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemDir) {
// Load file from a system, non-framework directory and check that it is not flagged as framework.
std::string system_location_path = GetAndroidRoot() + "/foo.jar";
ASSERT_FALSE(LocationIsOnSystemFramework(system_location_path.c_str()));
TestLocation(system_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemExtDir) {
// Load file from a system_ext, non-framework directory and check that it is not flagged as
// framework.
std::string system_ext_location_path = android_system_ext_ + "/foo.jar";
ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path.c_str()));
TestLocation(system_ext_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemSystemExtDir) {
// Load file from a system/system_ext, non-framework directory and check that it is not flagged as
// framework.
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext");
std::string system_ext_location_path = GetAndroidRoot() + "/system_ext/foo.jar";
ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_location_path.c_str()));
TestLocation(system_ext_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemFrameworkDir) {
// Load file from a system/framework directory and check that it is flagged as a framework dex.
std::filesystem::create_directory(GetAndroidRoot() + "/framework");
std::string system_framework_location_path = GetAndroidRoot() + "/framework/foo.jar";
ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_location_path.c_str()));
TestLocation(system_framework_location_path, hiddenapi::Domain::kPlatform);
}
TEST_F(HiddenApiTest, DexDomain_SystemExtFrameworkDir) {
// Load file from a system_ext/framework directory and check that it is flagged as a framework dex.
std::filesystem::create_directory(android_system_ext_ + "/framework");
std::string system_ext_framework_location_path = android_system_ext_ + "/framework/foo.jar";
ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path.c_str()));
TestLocation(system_ext_framework_location_path, hiddenapi::Domain::kPlatform);
}
TEST_F(HiddenApiTest, DexDomain_SystemSystemExtFrameworkDir) {
// Load file from a system/system_ext/framework directory and check that it is flagged as a
// framework dex.
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext");
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext/framework");
std::string system_ext_framework_location_path =
GetAndroidRoot() + "/system_ext/framework/foo.jar";
ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_location_path.c_str()));
TestLocation(system_ext_framework_location_path, hiddenapi::Domain::kPlatform);
}
TEST_F(HiddenApiTest, DexDomain_DataDir_MultiDex) {
// Load multidex file from a non-system directory and check that it is not flagged as framework.
std::string data_multi_location_path = android_data_ + "/multifoo.jar";
ASSERT_FALSE(LocationIsOnSystemFramework(data_multi_location_path.c_str()));
TestLocation(data_multi_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemDir_MultiDex) {
// Load multidex file from a system, non-framework directory and check that it is not flagged
// as framework.
std::string system_multi_location_path = GetAndroidRoot() + "/multifoo.jar";
ASSERT_FALSE(LocationIsOnSystemFramework(system_multi_location_path.c_str()));
TestLocation(system_multi_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemExtDir_MultiDex) {
// Load multidex file from a system_ext, non-framework directory and check that it is not flagged
// as framework.
std::string system_ext_multi_location_path = android_system_ext_ + "/multifoo.jar";
ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path.c_str()));
TestLocation(system_ext_multi_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemSystemExtDir_MultiDex) {
// Load multidex file from a system/system_ext, non-framework directory and check that it is not
// flagged as framework.
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext");
std::string system_ext_multi_location_path =
GetAndroidRoot() + "/system_ext/multifoo.jar";
ASSERT_FALSE(LocationIsOnSystemExtFramework(system_ext_multi_location_path.c_str()));
TestLocation(system_ext_multi_location_path, hiddenapi::Domain::kApplication);
}
TEST_F(HiddenApiTest, DexDomain_SystemFrameworkDir_MultiDex) {
// Load multidex file from a system/framework directory and check that it is flagged as a
// framework dex.
std::filesystem::create_directory(GetAndroidRoot() + "/framework");
std::string system_framework_multi_location_path = GetAndroidRoot() + "/framework/multifoo.jar";
ASSERT_TRUE(LocationIsOnSystemFramework(system_framework_multi_location_path.c_str()));
TestLocation(system_framework_multi_location_path, hiddenapi::Domain::kPlatform);
}
TEST_F(HiddenApiTest, DexDomain_SystemExtFrameworkDir_MultiDex) {
// Load multidex file from a system_ext/framework directory and check that it is flagged as a
// framework dex.
std::filesystem::create_directory(android_system_ext_ + "/framework");
std::string system_ext_framework_multi_location_path =
android_system_ext_ + "/framework/multifoo.jar";
ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path.c_str()));
TestLocation(system_ext_framework_multi_location_path, hiddenapi::Domain::kPlatform);
}
TEST_F(HiddenApiTest, DexDomain_SystemSystemExtFrameworkDir_MultiDex) {
// Load multidex file from a system/system_ext/framework directory and check that it is flagged
// as a framework dex.
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext");
std::filesystem::create_directory(GetAndroidRoot() + "/system_ext/framework");
std::string system_ext_framework_multi_location_path =
GetAndroidRoot() + "/system_ext/framework/multifoo.jar";
ASSERT_TRUE(LocationIsOnSystemExtFramework(system_ext_framework_multi_location_path.c_str()));
TestLocation(system_ext_framework_multi_location_path, hiddenapi::Domain::kPlatform);
}
} // namespace art
Reference in New Issue View Git Blame Copy Permalink