| /* | |
| * 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 <android-base/file.h> | |
| #include <androidfw/ResourceTypes.h> | |
| #include <gtest/gtest.h> | |
| #include <cstdio> // fclose | |
| #include <fstream> | |
| #include <memory> | |
| #include <string> | |
| #include "R.h" | |
| #include "TestConstants.h" | |
| #include "TestHelpers.h" | |
| #include "idmap2/LogInfo.h" | |
| #include "idmap2/ResourceMapping.h" | |
| using android::Res_value; | |
| using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags; | |
| namespace android::idmap2 { | |
| #define ASSERT_RESULT(r) \ | |
| do { \ | |
| auto result = r; \ | |
| ASSERT_TRUE(result) << result.GetErrorMessage(); \ | |
| } while (0) | |
| Result<ResourceMapping> TestGetResourceMapping(const std::string& local_target_path, | |
| const std::string& local_overlay_path, | |
| const std::string& overlay_name, | |
| const PolicyBitmask& fulfilled_policies, | |
| bool enforce_overlayable) { | |
| const std::string target_path = (local_target_path[0] == '/') | |
| ? local_target_path | |
| : (GetTestDataPath() + "/" + local_target_path); | |
| auto target = TargetResourceContainer::FromPath(target_path); | |
| if (!target) { | |
| return Error(target.GetError(), R"(Failed to load target "%s")", target_path.c_str()); | |
| } | |
| const std::string overlay_path = (local_overlay_path[0] == '/') | |
| ? local_overlay_path | |
| : (GetTestDataPath() + "/" + local_overlay_path); | |
| auto overlay = OverlayResourceContainer::FromPath(overlay_path); | |
| if (!overlay) { | |
| return Error(overlay.GetError(), R"(Failed to load overlay "%s")", overlay_path.c_str()); | |
| } | |
| auto overlay_info = (*overlay)->FindOverlayInfo(overlay_name); | |
| if (!overlay_info) { | |
| return Error(overlay_info.GetError(), R"(Failed to find overlay name "%s")", | |
| overlay_name.c_str()); | |
| } | |
| LogInfo log_info; | |
| return ResourceMapping::FromContainers(**target, **overlay, *overlay_info, fulfilled_policies, | |
| enforce_overlayable, log_info); | |
| } | |
| Result<Unit> MappingExists(const ResourceMapping& mapping, ResourceId target_resource, | |
| ResourceId overlay_resource, bool rewrite) { | |
| auto target_map = mapping.GetTargetToOverlayMap(); | |
| auto entry_map = target_map.find(target_resource); | |
| if (entry_map == target_map.end()) { | |
| return Error("Failed to find mapping for target resource"); | |
| } | |
| auto actual_overlay_resource = std::get_if<ResourceId>(&entry_map->second); | |
| if (actual_overlay_resource == nullptr) { | |
| return Error("Target resource is not mapped to an overlay resource id"); | |
| } | |
| if (*actual_overlay_resource != overlay_resource) { | |
| return Error(R"(Expected id: "0x%02x" Actual id: "0x%02x")", overlay_resource, | |
| *actual_overlay_resource); | |
| } | |
| auto overlay_map = mapping.GetOverlayToTargetMap(); | |
| auto overlay_iter = overlay_map.find(overlay_resource); | |
| if ((overlay_iter != overlay_map.end()) != rewrite) { | |
| return Error(R"(Expected rewriting: "%s")", rewrite ? "true" : "false"); | |
| } | |
| if (rewrite && overlay_iter->second != target_resource) { | |
| return Error(R"(Expected rewrite id: "0x%02x" Actual id: "0x%02x")", target_resource, | |
| overlay_iter->second); | |
| } | |
| return Result<Unit>({}); | |
| } | |
| Result<Unit> MappingExists(const ResourceMapping& mapping, const ResourceId& target_resource, | |
| const uint8_t type, const uint32_t value) { | |
| auto target_map = mapping.GetTargetToOverlayMap(); | |
| auto entry_map = target_map.find(target_resource); | |
| if (entry_map == target_map.end()) { | |
| return Error("Failed to find mapping for target resource"); | |
| } | |
| auto actual_overlay_value = std::get_if<TargetValue>(&entry_map->second); | |
| if (actual_overlay_value == nullptr) { | |
| return Error("Target resource is not mapped to an inline value"); | |
| } | |
| if (actual_overlay_value->data_type != type) { | |
| return Error(R"(Expected type: "0x%02x" Actual type: "0x%02x")", type, | |
| actual_overlay_value->data_type); | |
| } | |
| if (actual_overlay_value->data_value != value) { | |
| return Error(R"(Expected value: "0x%08x" Actual value: "0x%08x")", type, | |
| actual_overlay_value->data_value); | |
| } | |
| return Result<Unit>({}); | |
| } | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsLegacy) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay-legacy.apk", "", | |
| PolicyFlags::PUBLIC, /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 4U); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::integer::int1, R::overlay::integer::int1, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str1, R::overlay::string::str1, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str3, R::overlay::string::str3, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str4, R::overlay::string::str4, false /* rewrite */)); | |
| } | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsNonMatchingNames) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", "SwapNames", | |
| PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str1, R::overlay::string::str4, true /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str3, R::overlay::string::str1, true /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str4, R::overlay::string::str3, true /* rewrite */)); | |
| } | |
| TEST(ResourceMappingTests, DoNotRewriteNonOverlayResourceId) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", | |
| "DifferentPackages", PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 2U); | |
| ASSERT_EQ(res.GetOverlayToTargetMap().size(), 1U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::str1, 0x0104000a, | |
| false /* rewrite */)); // -> android:string/ok | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str3, R::overlay::string::str3, true /* rewrite */)); | |
| } | |
| TEST(ResourceMappingTests, InlineResources) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", "Inline", | |
| PolicyFlags::PUBLIC, /* enforce_overlayable */ false); | |
| constexpr size_t overlay_string_pool_size = 10U; | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 2U); | |
| ASSERT_EQ(res.GetOverlayToTargetMap().size(), 0U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::str1, Res_value::TYPE_STRING, | |
| overlay_string_pool_size + 0U)); // -> "Hello World" | |
| ASSERT_RESULT(MappingExists(res, R::target::integer::int1, Res_value::TYPE_INT_DEC, 73U)); | |
| } | |
| TEST(ResourceMappingTests, FabricatedOverlay) { | |
| auto frro = FabricatedOverlay::Builder("com.example.overlay", "SandTheme", "test.target") | |
| .SetOverlayable("TestResources") | |
| .SetResourceValue("integer/int1", Res_value::TYPE_INT_DEC, 2U) | |
| .SetResourceValue("string/str1", Res_value::TYPE_REFERENCE, 0x7f010000) | |
| .Build(); | |
| ASSERT_TRUE(frro); | |
| TemporaryFile tf; | |
| std::ofstream out(tf.path); | |
| ASSERT_TRUE((*frro).ToBinaryStream(out)); | |
| out.close(); | |
| auto resources = TestGetResourceMapping("target/target.apk", tf.path, "SandTheme", | |
| PolicyFlags::PUBLIC, /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 2U); | |
| ASSERT_EQ(res.GetOverlayToTargetMap().size(), 0U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::str1, Res_value::TYPE_REFERENCE, 0x7f010000)); | |
| ASSERT_RESULT(MappingExists(res, R::target::integer::int1, Res_value::TYPE_INT_DEC, 2U)); | |
| } | |
| TEST(ResourceMappingTests, CreateIdmapFromApkAssetsPolicySystemPublic) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", | |
| TestConstants::OVERLAY_NAME_ALL_POLICIES, | |
| PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ true); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_public, | |
| R::overlay::string::policy_public, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system, | |
| R::overlay::string::policy_system, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor, | |
| R::overlay::string::policy_system_vendor, true /* rewrite */)); | |
| } | |
| // Resources that are not declared as overlayable and resources that a protected by policies the | |
| // overlay does not fulfill must not map to overlay resources. | |
| TEST(ResourceMappingTests, CreateIdmapFromApkAssetsPolicySystemPublicInvalid) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", | |
| TestConstants::OVERLAY_NAME_ALL_POLICIES, | |
| PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ true); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_public, | |
| R::overlay::string::policy_public, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system, | |
| R::overlay::string::policy_system, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor, | |
| R::overlay::string::policy_system_vendor, true /* rewrite */)); | |
| } | |
| // Resources that are not declared as overlayable and resources that a protected by policies the | |
| // overlay does not fulfilled can map to overlay resources when overlayable enforcement is turned | |
| // off. | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsPolicySystemPublicInvalidIgnoreOverlayable) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", | |
| TestConstants::OVERLAY_NAME_ALL_POLICIES, | |
| PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 11U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::not_overlayable, | |
| R::overlay::string::not_overlayable, true /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::other, R::overlay::string::other, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_actor, | |
| R::overlay::string::policy_actor, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_odm, R::overlay::string::policy_odm, | |
| true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_oem, R::overlay::string::policy_oem, | |
| true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_product, | |
| R::overlay::string::policy_product, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_public, | |
| R::overlay::string::policy_public, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_config_signature, | |
| R::overlay::string::policy_config_signature, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_signature, | |
| R::overlay::string::policy_signature, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system, | |
| R::overlay::string::policy_system, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor, | |
| R::overlay::string::policy_system_vendor, true /* rewrite */)); | |
| } | |
| // Overlays that do not target an <overlayable> tag can overlay any resource if overlayable | |
| // enforcement is disabled. | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsNoDefinedOverlayableAndNoTargetName) { | |
| auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay-legacy.apk", "", | |
| PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ false); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(res.GetTargetToOverlayMap().size(), 4U); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::integer::int1, R::overlay::integer::int1, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str1, R::overlay::string::str1, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str3, R::overlay::string::str3, false /* rewrite */)); | |
| ASSERT_RESULT( | |
| MappingExists(res, R::target::string::str4, R::overlay::string::str4, false /* rewrite */)); | |
| } | |
| // Overlays that are neither pre-installed nor signed with the same signature as the target cannot | |
| // overlay packages that have not defined overlayable resources. | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsDefaultPoliciesPublicFail) { | |
| auto resources = TestGetResourceMapping("target/target-no-overlayable.apk", "overlay/overlay.apk", | |
| "NoTargetName", PolicyFlags::PUBLIC, | |
| /* enforce_overlayable */ true); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| ASSERT_EQ(resources->GetTargetToOverlayMap().size(), 0U); | |
| } | |
| // Overlays that are pre-installed or are signed with the same signature as the target or are | |
| // signed with the same signature as the reference package can overlay packages that have not | |
| // defined overlayable resources. | |
| TEST(ResourceMappingTests, ResourcesFromApkAssetsDefaultPolicies) { | |
| auto CheckEntries = [&](const PolicyBitmask& fulfilled_policies) { | |
| auto resources = | |
| TestGetResourceMapping("target/target-no-overlayable.apk", "overlay/overlay.apk", | |
| TestConstants::OVERLAY_NAME_ALL_POLICIES, fulfilled_policies, | |
| /* enforce_overlayable */ true); | |
| ASSERT_TRUE(resources) << resources.GetErrorMessage(); | |
| auto& res = *resources; | |
| ASSERT_EQ(resources->GetTargetToOverlayMap().size(), 11U); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::not_overlayable, | |
| R::overlay::string::not_overlayable, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::other, R::overlay::string::other, | |
| true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_actor, | |
| R::overlay::string::policy_actor, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_odm, R::overlay::string::policy_odm, | |
| true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_oem, R::overlay::string::policy_oem, | |
| true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_product, | |
| R::overlay::string::policy_product, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_public, | |
| R::overlay::string::policy_public, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_config_signature, | |
| R::overlay::string::policy_config_signature, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_signature, | |
| R::overlay::string::policy_signature, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system, | |
| R::overlay::string::policy_system, true /* rewrite */)); | |
| ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor, | |
| R::overlay::string::policy_system_vendor, true /* rewrite */)); | |
| }; | |
| CheckEntries(PolicyFlags::SIGNATURE); | |
| CheckEntries(PolicyFlags::CONFIG_SIGNATURE); | |
| CheckEntries(PolicyFlags::PRODUCT_PARTITION); | |
| CheckEntries(PolicyFlags::SYSTEM_PARTITION); | |
| CheckEntries(PolicyFlags::VENDOR_PARTITION); | |
| CheckEntries(PolicyFlags::ODM_PARTITION); | |
| CheckEntries(PolicyFlags::OEM_PARTITION); | |
| } | |
| } // namespace android::idmap2 |