1 /*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android-base/file.h>
18 #include <androidfw/ResourceTypes.h>
19 #include <gtest/gtest.h>
20
21 #include <cstdio> // fclose
22 #include <fstream>
23 #include <memory>
24 #include <string>
25
26 #include <fcntl.h>
27 #include "R.h"
28 #include "TestConstants.h"
29 #include "TestHelpers.h"
30 #include "idmap2/LogInfo.h"
31 #include "idmap2/ResourceMapping.h"
32
33 using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
34
35 namespace android::idmap2 {
36
37 #define ASSERT_RESULT(r) \
38 do { \
39 auto result = r; \
40 ASSERT_TRUE(result) << result.GetErrorMessage(); \
41 } while (0)
42
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)43 Result<ResourceMapping> TestGetResourceMapping(const std::string& local_target_path,
44 const std::string& local_overlay_path,
45 const std::string& overlay_name,
46 const PolicyBitmask& fulfilled_policies,
47 bool enforce_overlayable) {
48 const std::string target_path = (local_target_path[0] == '/')
49 ? local_target_path
50 : (GetTestDataPath() + "/" + local_target_path);
51 auto target = TargetResourceContainer::FromPath(target_path);
52 if (!target) {
53 return Error(target.GetError(), R"(Failed to load target "%s")", target_path.c_str());
54 }
55
56 const std::string overlay_path = (local_overlay_path[0] == '/')
57 ? local_overlay_path
58 : (GetTestDataPath() + "/" + local_overlay_path);
59 auto overlay = OverlayResourceContainer::FromPath(overlay_path);
60 if (!overlay) {
61 return Error(overlay.GetError(), R"(Failed to load overlay "%s")", overlay_path.c_str());
62 }
63
64 auto overlay_info = (*overlay)->FindOverlayInfo(overlay_name);
65 if (!overlay_info) {
66 return Error(overlay_info.GetError(), R"(Failed to find overlay name "%s")",
67 overlay_name.c_str());
68 }
69
70 LogInfo log_info;
71 return ResourceMapping::FromContainers(**target, **overlay, *overlay_info, fulfilled_policies,
72 enforce_overlayable, log_info);
73 }
74
MappingExists(const ResourceMapping & mapping,ResourceId target_resource,ResourceId overlay_resource,bool rewrite)75 Result<Unit> MappingExists(const ResourceMapping& mapping, ResourceId target_resource,
76 ResourceId overlay_resource, bool rewrite) {
77 auto target_map = mapping.GetTargetToOverlayMap();
78 auto entry_map = target_map.find(target_resource);
79 if (entry_map == target_map.end()) {
80 std::string keys;
81 for (const auto &pair : target_map) {
82 keys.append(fmt::format("0x{:x}", pair.first)).append(" ");
83 }
84 return Error(R"(Failed to find mapping for target resource "0x%02x": "%s")",
85 target_resource, keys.c_str());
86 }
87
88 auto actual_overlay_resource = std::get_if<ResourceId>(&entry_map->second);
89 if (actual_overlay_resource == nullptr) {
90 return Error("Target resource is not mapped to an overlay resource id");
91 }
92
93 if (*actual_overlay_resource != overlay_resource) {
94 return Error(R"(Expected id: "0x%02x" Actual id: "0x%02x")", overlay_resource,
95 *actual_overlay_resource);
96 }
97
98 auto overlay_map = mapping.GetOverlayToTargetMap();
99 auto overlay_iter = overlay_map.find(overlay_resource);
100 if ((overlay_iter != overlay_map.end()) != rewrite) {
101 return Error(R"(Expected rewriting: "%s")", rewrite ? "true" : "false");
102 }
103
104 if (rewrite && overlay_iter->second != target_resource) {
105 return Error(R"(Expected rewrite id: "0x%02x" Actual id: "0x%02x")", target_resource,
106 overlay_iter->second);
107 }
108
109 return Result<Unit>({});
110 }
111
MappingExists(const ResourceMapping & mapping,const ResourceId & target_resource,const uint8_t type,const uint32_t value)112 Result<Unit> MappingExists(const ResourceMapping& mapping, const ResourceId& target_resource,
113 const uint8_t type, const uint32_t value) {
114 auto target_map = mapping.GetTargetToOverlayMap();
115 auto entry_map = target_map.find(target_resource);
116 if (entry_map == target_map.end()) {
117 std::string keys;
118 for (const auto &pair : target_map) {
119 keys.append(fmt::format("{:x}", pair.first)).append(" ");
120 }
121 return Error(R"(Failed to find mapping for target resource "0x%02x": "%s")",
122 target_resource, keys.c_str());
123 }
124
125 auto config_map = std::get_if<ConfigMap>(&entry_map->second);
126 if (config_map == nullptr || config_map->empty()) {
127 return Error("Target resource is not mapped to an inline value");
128 }
129 auto actual_overlay_value = config_map->begin()->second;
130
131 if (actual_overlay_value.data_type != type) {
132 return Error(R"(Expected type: "0x%02x" Actual type: "0x%02x")", type,
133 actual_overlay_value.data_type);
134 }
135
136 if (actual_overlay_value.data_value != value) {
137 return Error(R"(Expected value: "0x%08x" Actual value: "0x%08x")", type,
138 actual_overlay_value.data_value);
139 }
140
141 return Result<Unit>({});
142 }
143
TEST(ResourceMappingTests,ResourcesFromApkAssetsLegacy)144 TEST(ResourceMappingTests, ResourcesFromApkAssetsLegacy) {
145 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay-legacy.apk", "",
146 PolicyFlags::PUBLIC, /* enforce_overlayable */ false);
147
148 ASSERT_TRUE(resources) << resources.GetErrorMessage();
149 auto& res = *resources;
150 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 4U);
151 ASSERT_RESULT(
152 MappingExists(res, R::target::integer::int1, R::overlay::integer::int1, false /* rewrite */));
153 ASSERT_RESULT(
154 MappingExists(res, R::target::string::str1, R::overlay::string::str1, false /* rewrite */));
155 ASSERT_RESULT(
156 MappingExists(res, R::target::string::str3, R::overlay::string::str3, false /* rewrite */));
157 ASSERT_RESULT(
158 MappingExists(res, R::target::string::str4, R::overlay::string::str4, false /* rewrite */));
159 }
160
TEST(ResourceMappingTests,ResourcesFromApkAssetsNonMatchingNames)161 TEST(ResourceMappingTests, ResourcesFromApkAssetsNonMatchingNames) {
162 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", "SwapNames",
163 PolicyFlags::PUBLIC,
164 /* enforce_overlayable */ false);
165
166 ASSERT_TRUE(resources) << resources.GetErrorMessage();
167 auto& res = *resources;
168 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U);
169 ASSERT_RESULT(
170 MappingExists(res, R::target::string::str1, R::overlay::string::str4, true /* rewrite */));
171 ASSERT_RESULT(
172 MappingExists(res, R::target::string::str3, R::overlay::string::str1, true /* rewrite */));
173 ASSERT_RESULT(
174 MappingExists(res, R::target::string::str4, R::overlay::string::str3, true /* rewrite */));
175 }
176
TEST(ResourceMappingTests,DoNotRewriteNonOverlayResourceId)177 TEST(ResourceMappingTests, DoNotRewriteNonOverlayResourceId) {
178 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk",
179 "DifferentPackages", PolicyFlags::PUBLIC,
180 /* enforce_overlayable */ false);
181
182 ASSERT_TRUE(resources) << resources.GetErrorMessage();
183 auto& res = *resources;
184 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 2U);
185 ASSERT_EQ(res.GetOverlayToTargetMap().size(), 1U);
186 ASSERT_RESULT(MappingExists(res, R::target::string::str1, 0x0104000a,
187 false /* rewrite */)); // -> android:string/ok
188 ASSERT_RESULT(
189 MappingExists(res, R::target::string::str3, R::overlay::string::str3, true /* rewrite */));
190 }
191
TEST(ResourceMappingTests,InlineResources)192 TEST(ResourceMappingTests, InlineResources) {
193 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk", "Inline",
194 PolicyFlags::PUBLIC, /* enforce_overlayable */ false);
195
196 constexpr size_t overlay_string_pool_size = 10U;
197 ASSERT_TRUE(resources) << resources.GetErrorMessage();
198 auto& res = *resources;
199 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 2U);
200 ASSERT_EQ(res.GetOverlayToTargetMap().size(), 0U);
201 ASSERT_RESULT(MappingExists(res, R::target::string::str1, Res_value::TYPE_STRING,
202 overlay_string_pool_size + 0U)); // -> "Hello World"
203 ASSERT_RESULT(MappingExists(res, R::target::integer::int1, Res_value::TYPE_INT_DEC, 73U));
204 }
205
TEST(ResourceMappingTests,FabricatedOverlay)206 TEST(ResourceMappingTests, FabricatedOverlay) {
207 auto path = GetTestDataPath() + "/overlay/res/drawable/android.png";
208 auto fd = android::base::unique_fd(::open(path.c_str(), O_RDONLY | O_CLOEXEC));
209 ASSERT_TRUE(fd > 0) << "errno " << errno << " for path " << path;
210 auto frro = FabricatedOverlay::Builder("com.example.overlay", "SandTheme", "test.target")
211 .SetOverlayable("TestResources")
212 .SetResourceValue("integer/int1", Res_value::TYPE_INT_DEC, 2U, "")
213 .SetResourceValue("string/str1", Res_value::TYPE_REFERENCE, 0x7f010000, "")
214 .SetResourceValue("string/str2", Res_value::TYPE_STRING, "foobar", "")
215 .SetResourceValue("drawable/dr1", fd, "")
216 .setFrroPath("/foo/bar/biz.frro")
217 .Build();
218
219 ASSERT_TRUE(frro);
220 TemporaryFile tf;
221 std::ofstream out(tf.path);
222 ASSERT_TRUE((*frro).ToBinaryStream(out));
223 out.close();
224
225 auto resources = TestGetResourceMapping("target/target.apk", tf.path, "SandTheme",
226 PolicyFlags::PUBLIC, /* enforce_overlayable */ false);
227
228 ASSERT_TRUE(resources) << resources.GetErrorMessage();
229 auto& res = *resources;
230 auto string_pool_data = res.GetStringPoolData();
231 auto string_pool = ResStringPool(string_pool_data.data(), string_pool_data.size(), false);
232
233 std::u16string expected_uri = u"frro://foo/bar/biz.frro?offset=16&size=8341";
234 uint32_t uri_index
235 = string_pool.indexOfString(expected_uri.data(), expected_uri.length()).value_or(-1);
236
237 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 4U);
238 ASSERT_EQ(res.GetOverlayToTargetMap().size(), 0U);
239 ASSERT_RESULT(MappingExists(res, R::target::string::str1, Res_value::TYPE_REFERENCE, 0x7f010000));
240 ASSERT_RESULT(MappingExists(res, R::target::string::str2, Res_value::TYPE_STRING,
241 (uint32_t) (string_pool.indexOfString(u"foobar", 6)).value_or(-1)));
242 ASSERT_RESULT(MappingExists(res, R::target::drawable::dr1, Res_value::TYPE_STRING, uri_index));
243 ASSERT_RESULT(MappingExists(res, R::target::integer::int1, Res_value::TYPE_INT_DEC, 2U));
244 }
245
TEST(ResourceMappingTests,CreateIdmapFromApkAssetsPolicySystemPublic)246 TEST(ResourceMappingTests, CreateIdmapFromApkAssetsPolicySystemPublic) {
247 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk",
248 TestConstants::OVERLAY_NAME_ALL_POLICIES,
249 PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC,
250 /* enforce_overlayable */ true);
251
252 ASSERT_TRUE(resources) << resources.GetErrorMessage();
253 auto& res = *resources;
254 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U);
255 ASSERT_RESULT(MappingExists(res, R::target::string::policy_public,
256 R::overlay::string::policy_public, true /* rewrite */));
257 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system,
258 R::overlay::string::policy_system, true /* rewrite */));
259 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor,
260 R::overlay::string::policy_system_vendor, true /* rewrite */));
261 }
262
263 // Resources that are not declared as overlayable and resources that a protected by policies the
264 // overlay does not fulfill must not map to overlay resources.
TEST(ResourceMappingTests,CreateIdmapFromApkAssetsPolicySystemPublicInvalid)265 TEST(ResourceMappingTests, CreateIdmapFromApkAssetsPolicySystemPublicInvalid) {
266 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk",
267 TestConstants::OVERLAY_NAME_ALL_POLICIES,
268 PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC,
269 /* enforce_overlayable */ true);
270
271 ASSERT_TRUE(resources) << resources.GetErrorMessage();
272 auto& res = *resources;
273 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 3U);
274 ASSERT_RESULT(MappingExists(res, R::target::string::policy_public,
275 R::overlay::string::policy_public, true /* rewrite */));
276 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system,
277 R::overlay::string::policy_system, true /* rewrite */));
278 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor,
279 R::overlay::string::policy_system_vendor, true /* rewrite */));
280 }
281
282 // Resources that are not declared as overlayable and resources that a protected by policies the
283 // overlay does not fulfilled can map to overlay resources when overlayable enforcement is turned
284 // off.
TEST(ResourceMappingTests,ResourcesFromApkAssetsPolicySystemPublicInvalidIgnoreOverlayable)285 TEST(ResourceMappingTests, ResourcesFromApkAssetsPolicySystemPublicInvalidIgnoreOverlayable) {
286 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay.apk",
287 TestConstants::OVERLAY_NAME_ALL_POLICIES,
288 PolicyFlags::SYSTEM_PARTITION | PolicyFlags::PUBLIC,
289 /* enforce_overlayable */ false);
290
291 ASSERT_TRUE(resources) << resources.GetErrorMessage();
292 auto& res = *resources;
293 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 11U);
294 ASSERT_RESULT(MappingExists(res, R::target::string::not_overlayable,
295 R::overlay::string::not_overlayable, true /* rewrite */));
296 ASSERT_RESULT(
297 MappingExists(res, R::target::string::other, R::overlay::string::other, true /* rewrite */));
298 ASSERT_RESULT(MappingExists(res, R::target::string::policy_actor,
299 R::overlay::string::policy_actor, true /* rewrite */));
300 ASSERT_RESULT(MappingExists(res, R::target::string::policy_odm, R::overlay::string::policy_odm,
301 true /* rewrite */));
302 ASSERT_RESULT(MappingExists(res, R::target::string::policy_oem, R::overlay::string::policy_oem,
303 true /* rewrite */));
304 ASSERT_RESULT(MappingExists(res, R::target::string::policy_product,
305 R::overlay::string::policy_product, true /* rewrite */));
306 ASSERT_RESULT(MappingExists(res, R::target::string::policy_public,
307 R::overlay::string::policy_public, true /* rewrite */));
308 ASSERT_RESULT(MappingExists(res, R::target::string::policy_config_signature,
309 R::overlay::string::policy_config_signature, true /* rewrite */));
310 ASSERT_RESULT(MappingExists(res, R::target::string::policy_signature,
311 R::overlay::string::policy_signature, true /* rewrite */));
312 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system,
313 R::overlay::string::policy_system, true /* rewrite */));
314 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor,
315 R::overlay::string::policy_system_vendor, true /* rewrite */));
316 }
317
318 // Overlays that do not target an <overlayable> tag can overlay any resource if overlayable
319 // enforcement is disabled.
TEST(ResourceMappingTests,ResourcesFromApkAssetsNoDefinedOverlayableAndNoTargetName)320 TEST(ResourceMappingTests, ResourcesFromApkAssetsNoDefinedOverlayableAndNoTargetName) {
321 auto resources = TestGetResourceMapping("target/target.apk", "overlay/overlay-legacy.apk", "",
322 PolicyFlags::PUBLIC,
323 /* enforce_overlayable */ false);
324
325 ASSERT_TRUE(resources) << resources.GetErrorMessage();
326 auto& res = *resources;
327 ASSERT_EQ(res.GetTargetToOverlayMap().size(), 4U);
328 ASSERT_RESULT(
329 MappingExists(res, R::target::integer::int1, R::overlay::integer::int1, false /* rewrite */));
330 ASSERT_RESULT(
331 MappingExists(res, R::target::string::str1, R::overlay::string::str1, false /* rewrite */));
332 ASSERT_RESULT(
333 MappingExists(res, R::target::string::str3, R::overlay::string::str3, false /* rewrite */));
334 ASSERT_RESULT(
335 MappingExists(res, R::target::string::str4, R::overlay::string::str4, false /* rewrite */));
336 }
337
338 // Overlays that are neither pre-installed nor signed with the same signature as the target cannot
339 // overlay packages that have not defined overlayable resources.
TEST(ResourceMappingTests,ResourcesFromApkAssetsDefaultPoliciesPublicFail)340 TEST(ResourceMappingTests, ResourcesFromApkAssetsDefaultPoliciesPublicFail) {
341 auto resources = TestGetResourceMapping("target/target-no-overlayable.apk", "overlay/overlay.apk",
342 "NoTargetName", PolicyFlags::PUBLIC,
343 /* enforce_overlayable */ true);
344
345 ASSERT_TRUE(resources) << resources.GetErrorMessage();
346 ASSERT_EQ(resources->GetTargetToOverlayMap().size(), 0U);
347 }
348
349 // Overlays that are pre-installed or are signed with the same signature as the target or are
350 // signed with the same signature as the reference package can overlay packages that have not
351 // defined overlayable resources.
TEST(ResourceMappingTests,ResourcesFromApkAssetsDefaultPolicies)352 TEST(ResourceMappingTests, ResourcesFromApkAssetsDefaultPolicies) {
353 auto CheckEntries = [&](const PolicyBitmask& fulfilled_policies) {
354 auto resources =
355 TestGetResourceMapping("target/target-no-overlayable.apk", "overlay/overlay.apk",
356 TestConstants::OVERLAY_NAME_ALL_POLICIES, fulfilled_policies,
357 /* enforce_overlayable */ true);
358
359 ASSERT_TRUE(resources) << resources.GetErrorMessage();
360 auto& res = *resources;
361 ASSERT_EQ(resources->GetTargetToOverlayMap().size(), 11U);
362 ASSERT_RESULT(MappingExists(res, R::target::string::not_overlayable,
363 R::overlay::string::not_overlayable, true /* rewrite */));
364 ASSERT_RESULT(MappingExists(res, R::target::string::other, R::overlay::string::other,
365 true /* rewrite */));
366 ASSERT_RESULT(MappingExists(res, R::target::string::policy_actor,
367 R::overlay::string::policy_actor, true /* rewrite */));
368 ASSERT_RESULT(MappingExists(res, R::target::string::policy_odm, R::overlay::string::policy_odm,
369 true /* rewrite */));
370 ASSERT_RESULT(MappingExists(res, R::target::string::policy_oem, R::overlay::string::policy_oem,
371 true /* rewrite */));
372 ASSERT_RESULT(MappingExists(res, R::target::string::policy_product,
373 R::overlay::string::policy_product, true /* rewrite */));
374 ASSERT_RESULT(MappingExists(res, R::target::string::policy_public,
375 R::overlay::string::policy_public, true /* rewrite */));
376 ASSERT_RESULT(MappingExists(res, R::target::string::policy_config_signature,
377 R::overlay::string::policy_config_signature, true /* rewrite */));
378 ASSERT_RESULT(MappingExists(res, R::target::string::policy_signature,
379 R::overlay::string::policy_signature, true /* rewrite */));
380 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system,
381 R::overlay::string::policy_system, true /* rewrite */));
382 ASSERT_RESULT(MappingExists(res, R::target::string::policy_system_vendor,
383 R::overlay::string::policy_system_vendor, true /* rewrite */));
384 };
385
386 CheckEntries(PolicyFlags::SIGNATURE);
387 CheckEntries(PolicyFlags::CONFIG_SIGNATURE);
388 CheckEntries(PolicyFlags::PRODUCT_PARTITION);
389 CheckEntries(PolicyFlags::SYSTEM_PARTITION);
390 CheckEntries(PolicyFlags::VENDOR_PARTITION);
391 CheckEntries(PolicyFlags::ODM_PARTITION);
392 CheckEntries(PolicyFlags::OEM_PARTITION);
393 }
394
395 } // namespace android::idmap2
396
