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
19 #include <cstdio> // fclose
20 #include <fstream>
21 #include <memory>
22 #include <sstream>
23 #include <string>
24 #include <utility>
25 #include <vector>
26
27 #include "R.h"
28 #include "TestConstants.h"
29 #include "TestHelpers.h"
30 #include "android-base/macros.h"
31 #include "androidfw/ApkAssets.h"
32 #include "androidfw/ResourceUtils.h"
33 #include "gmock/gmock.h"
34 #include "gtest/gtest.h"
35 #include "idmap2/BinaryStreamVisitor.h"
36 #include "idmap2/CommandLineOptions.h"
37 #include "idmap2/Idmap.h"
38 #include "idmap2/LogInfo.h"
39
40 using ::testing::NotNull;
41
42 using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
43
44 namespace android::idmap2 {
45
46 #define ASSERT_TARGET_ENTRY(entry, target_resid, overlay_resid) \
47 ASSERT_EQ((entry).target_id, (target_resid)); \
48 ASSERT_EQ((entry).overlay_id, (overlay_resid))
49
50 #define ASSERT_TARGET_INLINE_ENTRY(entry, target_resid, ex_config, expected_type, expected_value) \
51 ASSERT_EQ((entry).target_id, target_resid); \
52 ASSERT_EQ((entry).values.begin()->first.to_string(), (ex_config)); \
53 ASSERT_EQ((entry).values.begin()->second.data_type, (expected_type)); \
54 ASSERT_EQ((entry).values.begin()->second.data_value, (expected_value))
55
56 #define ASSERT_OVERLAY_ENTRY(entry, overlay_resid, target_resid) \
57 ASSERT_EQ((entry).overlay_id, (overlay_resid)); \
58 ASSERT_EQ((entry).target_id, (target_resid))
59
TEST(IdmapTests,TestCanonicalIdmapPathFor)60 TEST(IdmapTests, TestCanonicalIdmapPathFor) {
61 ASSERT_EQ(Idmap::CanonicalIdmapPathFor("/foo", "/vendor/overlay/bar.apk"),
62 "/foo/vendor@[email protected]@idmap");
63 }
64
TEST(IdmapTests,CreateIdmapHeaderFromBinaryStream)65 TEST(IdmapTests, CreateIdmapHeaderFromBinaryStream) {
66 std::string raw(reinterpret_cast<const char*>(kIdmapRawData), kIdmapRawDataLen);
67 std::istringstream stream(raw);
68 std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
69 ASSERT_THAT(header, NotNull());
70 ASSERT_EQ(header->GetMagic(), 0x504d4449U);
71 ASSERT_EQ(header->GetVersion(), 10);
72 ASSERT_EQ(header->GetTargetCrc(), 0x1234U);
73 ASSERT_EQ(header->GetOverlayCrc(), 0x5678U);
74 ASSERT_EQ(header->GetFulfilledPolicies(), 0x11);
75 ASSERT_EQ(header->GetEnforceOverlayable(), true);
76 ASSERT_EQ(header->GetTargetPath(), "targetX.apk");
77 ASSERT_EQ(header->GetOverlayPath(), "overlayX.apk");
78 ASSERT_EQ(header->GetDebugInfo(), "debug");
79 }
80
TEST(IdmapTests,IdmapFailParsingDifferentVersion)81 TEST(IdmapTests, IdmapFailParsingDifferentVersion) {
82 constexpr size_t kJunkSize = 2000;
83 std::stringstream stream;
84 stream << android::kIdmapMagic;
85 stream << 0xffffffffU;
86 stream << std::string(kJunkSize, static_cast<char>(0xffU));
87 ASSERT_FALSE(Idmap::FromBinaryStream(stream));
88 }
89
TEST(IdmapTests,IdmapFailParsingDifferentMagic)90 TEST(IdmapTests, IdmapFailParsingDifferentMagic) {
91 constexpr size_t kJunkSize = 2000;
92 std::stringstream stream;
93 stream << 0xffffffffU;
94 stream << android::kIdmapCurrentVersion;
95 stream << std::string(kJunkSize, static_cast<char>(0xffU));
96 ASSERT_FALSE(Idmap::FromBinaryStream(stream));
97 }
98
TEST(IdmapTests,CreateIdmapDataHeaderFromBinaryStream)99 TEST(IdmapTests, CreateIdmapDataHeaderFromBinaryStream) {
100 const size_t offset = kIdmapRawDataOffset;
101 std::string raw(reinterpret_cast<const char*>(kIdmapRawData + offset), kIdmapRawDataLen - offset);
102 std::istringstream stream(raw);
103
104 std::unique_ptr<const IdmapData::Header> header = IdmapData::Header::FromBinaryStream(stream);
105 ASSERT_THAT(header, NotNull());
106 ASSERT_EQ(header->GetTargetEntryCount(), 0x03);
107 ASSERT_EQ(header->GetOverlayEntryCount(), 0x03);
108 }
109
TEST(IdmapTests,CreateIdmapDataFromBinaryStream)110 TEST(IdmapTests, CreateIdmapDataFromBinaryStream) {
111 const size_t offset = kIdmapRawDataOffset;
112 std::string raw(reinterpret_cast<const char*>(kIdmapRawData + offset), kIdmapRawDataLen - offset);
113 std::istringstream stream(raw);
114
115 std::unique_ptr<const IdmapData> data = IdmapData::FromBinaryStream(stream);
116 ASSERT_THAT(data, NotNull());
117
118 const auto& target_entries = data->GetTargetEntries();
119 ASSERT_EQ(target_entries.size(), 3U);
120 ASSERT_TARGET_ENTRY(target_entries[0], 0x7f020000, 0x7f020000);
121 ASSERT_TARGET_ENTRY(target_entries[1], 0x7f030000, 0x7f030000);
122 ASSERT_TARGET_ENTRY(target_entries[2], 0x7f030002, 0x7f030001);
123
124 const auto& target_inline_entries = data->GetTargetInlineEntries();
125 ASSERT_EQ(target_inline_entries.size(), 1U);
126 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[0], 0x7f040000, "land-xxhdpi-v7",
127 Res_value::TYPE_INT_HEX, 0x12345678);
128
129 const auto& overlay_entries = data->GetOverlayEntries();
130 ASSERT_EQ(target_entries.size(), 3U);
131 ASSERT_OVERLAY_ENTRY(overlay_entries[0], 0x7f020000, 0x7f020000);
132 ASSERT_OVERLAY_ENTRY(overlay_entries[1], 0x7f030000, 0x7f030000);
133 ASSERT_OVERLAY_ENTRY(overlay_entries[2], 0x7f030001, 0x7f030002);
134 }
135
TEST(IdmapTests,CreateIdmapFromBinaryStream)136 TEST(IdmapTests, CreateIdmapFromBinaryStream) {
137 std::string raw(reinterpret_cast<const char*>(kIdmapRawData), kIdmapRawDataLen);
138 std::istringstream stream(raw);
139
140 auto result = Idmap::FromBinaryStream(stream);
141 ASSERT_TRUE(result);
142 const auto idmap = std::move(*result);
143
144 ASSERT_THAT(idmap->GetHeader(), NotNull());
145 ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449U);
146 ASSERT_EQ(idmap->GetHeader()->GetVersion(), 10);
147 ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), 0x1234U);
148 ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), 0x5678U);
149 ASSERT_EQ(idmap->GetHeader()->GetFulfilledPolicies(), kIdmapRawDataPolicies);
150 ASSERT_EQ(idmap->GetHeader()->GetEnforceOverlayable(), true);
151 ASSERT_EQ(idmap->GetHeader()->GetTargetPath(), kIdmapRawTargetPath);
152 ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), kIdmapRawOverlayPath);
153 ASSERT_EQ(idmap->GetHeader()->GetOverlayName(), kIdmapRawOverlayName);
154
155 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
156 ASSERT_EQ(dataBlocks.size(), 1U);
157
158 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
159 ASSERT_THAT(data, NotNull());
160
161 const auto& target_entries = data->GetTargetEntries();
162 ASSERT_EQ(target_entries.size(), 3U);
163 ASSERT_TARGET_ENTRY(target_entries[0], 0x7f020000, 0x7f020000);
164 ASSERT_TARGET_ENTRY(target_entries[1], 0x7f030000, 0x7f030000);
165 ASSERT_TARGET_ENTRY(target_entries[2], 0x7f030002, 0x7f030001);
166
167 const auto& target_inline_entries = data->GetTargetInlineEntries();
168 ASSERT_EQ(target_inline_entries.size(), 1U);
169 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[0], 0x7f040000, "land-xxhdpi-v7",
170 Res_value::TYPE_INT_HEX, 0x12345678);
171
172 const auto& overlay_entries = data->GetOverlayEntries();
173 ASSERT_EQ(target_entries.size(), 3U);
174 ASSERT_OVERLAY_ENTRY(overlay_entries[0], 0x7f020000, 0x7f020000);
175 ASSERT_OVERLAY_ENTRY(overlay_entries[1], 0x7f030000, 0x7f030000);
176 ASSERT_OVERLAY_ENTRY(overlay_entries[2], 0x7f030001, 0x7f030002);
177 }
178
TEST(IdmapTests,GracefullyFailToCreateIdmapFromCorruptBinaryStream)179 TEST(IdmapTests, GracefullyFailToCreateIdmapFromCorruptBinaryStream) {
180 std::string raw(reinterpret_cast<const char*>(kIdmapRawData),
181 10); // data too small
182 std::istringstream stream(raw);
183
184 const auto result = Idmap::FromBinaryStream(stream);
185 ASSERT_FALSE(result);
186 }
187
TEST(IdmapTests,CreateIdmapHeaderFromApkAssets)188 TEST(IdmapTests, CreateIdmapHeaderFromApkAssets) {
189 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
190 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
191
192 auto target = TargetResourceContainer::FromPath(target_apk_path);
193 ASSERT_TRUE(target);
194
195 auto overlay = OverlayResourceContainer::FromPath(overlay_apk_path);
196 ASSERT_TRUE(overlay);
197
198 auto idmap_result = Idmap::FromContainers(
199 **target, **overlay, TestConstants::OVERLAY_NAME_ALL_POLICIES, PolicyFlags::PUBLIC,
200 /* enforce_overlayable */ true);
201 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
202 auto& idmap = *idmap_result;
203 ASSERT_THAT(idmap, NotNull());
204
205 ASSERT_THAT(idmap->GetHeader(), NotNull());
206 ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449U);
207 ASSERT_EQ(idmap->GetHeader()->GetVersion(), 10);
208 ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), android::idmap2::TestConstants::TARGET_CRC);
209 ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), android::idmap2::TestConstants::OVERLAY_CRC);
210 ASSERT_EQ(idmap->GetHeader()->GetFulfilledPolicies(), PolicyFlags::PUBLIC);
211 ASSERT_EQ(idmap->GetHeader()->GetEnforceOverlayable(), true);
212 ASSERT_EQ(idmap->GetHeader()->GetTargetPath(), target_apk_path);
213 ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), overlay_apk_path);
214 ASSERT_EQ(idmap->GetHeader()->GetOverlayName(), TestConstants::OVERLAY_NAME_ALL_POLICIES);
215 }
216
TEST(IdmapTests,TargetContainerWorksAfterError)217 TEST(IdmapTests, TargetContainerWorksAfterError) {
218 auto target = TargetResourceContainer::FromPath(GetTestDataPath() + "/target/target-bad.apk");
219 ASSERT_TRUE(target);
220
221 auto crc = target->get()->GetCrc();
222 ASSERT_TRUE(crc);
223
224 // This call tries to construct the full ApkAssets state, and fails.
225 ASSERT_FALSE(target->get()->DefinesOverlayable());
226 auto crc2 = target->get()->GetCrc();
227 ASSERT_TRUE(crc2);
228 EXPECT_EQ(*crc, *crc2);
229 }
230
TEST(IdmapTests,CreateIdmapDataFromApkAssets)231 TEST(IdmapTests, CreateIdmapDataFromApkAssets) {
232 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
233 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
234
235 auto target = TargetResourceContainer::FromPath(target_apk_path);
236 ASSERT_TRUE(target);
237
238 auto overlay = OverlayResourceContainer::FromPath(overlay_apk_path);
239 ASSERT_TRUE(overlay);
240
241 auto idmap_result = Idmap::FromContainers(
242 **target, **overlay, TestConstants::OVERLAY_NAME_DEFAULT, PolicyFlags::PUBLIC,
243 /* enforce_overlayable */ true);
244 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
245 auto& idmap = *idmap_result;
246 ASSERT_THAT(idmap, NotNull());
247
248 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
249 ASSERT_EQ(dataBlocks.size(), 1U);
250
251 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
252 ASSERT_THAT(data, NotNull());
253
254 const auto& target_entries = data->GetTargetEntries();
255 ASSERT_EQ(target_entries.size(), 4U);
256 ASSERT_TARGET_ENTRY(target_entries[0], R::target::integer::int1, R::overlay::integer::int1);
257 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str1, R::overlay::string::str1);
258 ASSERT_TARGET_ENTRY(target_entries[2], R::target::string::str3, R::overlay::string::str3);
259 ASSERT_TARGET_ENTRY(target_entries[3], R::target::string::str4, R::overlay::string::str4);
260
261 const auto& target_inline_entries = data->GetTargetInlineEntries();
262 ASSERT_EQ(target_inline_entries.size(), 0U);
263
264 const auto& overlay_entries = data->GetOverlayEntries();
265 ASSERT_EQ(target_entries.size(), 4U);
266 ASSERT_OVERLAY_ENTRY(overlay_entries[0], R::overlay::integer::int1, R::target::integer::int1);
267 ASSERT_OVERLAY_ENTRY(overlay_entries[1], R::overlay::string::str1, R::target::string::str1);
268 ASSERT_OVERLAY_ENTRY(overlay_entries[2], R::overlay::string::str3, R::target::string::str3);
269 ASSERT_OVERLAY_ENTRY(overlay_entries[3], R::overlay::string::str4, R::target::string::str4);
270 }
271
TEST(IdmapTests,FabricatedOverlay)272 TEST(IdmapTests, FabricatedOverlay) {
273 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
274 auto target = TargetResourceContainer::FromPath(target_apk_path);
275 ASSERT_TRUE(target);
276
277 auto path = GetTestDataPath() + "/overlay/res/drawable/android.png";
278 auto fd = android::base::unique_fd(::open(path.c_str(), O_RDONLY | O_CLOEXEC));
279 ASSERT_TRUE(fd > 0) << "errno " << errno << " for path " << path;
280
281 auto frro = FabricatedOverlay::Builder("com.example.overlay", "SandTheme", "test.target")
282 .SetOverlayable("TestResources")
283 .SetResourceValue("integer/int1", Res_value::TYPE_INT_DEC, 2U, "land-xxhdpi-v7")
284 .SetResourceValue("string/str1", Res_value::TYPE_REFERENCE, 0x7f010000, "land")
285 .SetResourceValue("string/str2", Res_value::TYPE_STRING, "foobar", "xxhdpi-v7")
286 .SetResourceValue("drawable/dr1", fd, 0, 8341, "port-xxhdpi-v7", false)
287 .setFrroPath("/foo/bar/biz.frro")
288 .Build();
289
290 ASSERT_TRUE(frro);
291 TempFrroFile tf;
292 std::ofstream out(tf.path);
293 ASSERT_TRUE((*frro).ToBinaryStream(out));
294 out.close();
295
296 auto overlay = OverlayResourceContainer::FromPath(tf.path);
297 ASSERT_TRUE(overlay);
298
299 auto idmap_result = Idmap::FromContainers(**target, **overlay, "SandTheme", PolicyFlags::PUBLIC,
300 /* enforce_overlayable */ true);
301 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
302 auto& idmap = *idmap_result;
303 ASSERT_THAT(idmap, NotNull());
304
305 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
306 ASSERT_EQ(dataBlocks.size(), 1U);
307
308 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
309 ASSERT_THAT(data, NotNull());
310 ASSERT_EQ(data->GetTargetEntries().size(), 0U);
311 ASSERT_EQ(data->GetOverlayEntries().size(), 0U);
312
313 auto string_pool_data = data->GetStringPoolData();
314 auto string_pool = ResStringPool(string_pool_data.data(), string_pool_data.size(), false);
315
316 std::u16string expected_uri = u"frro://foo/bar/biz.frro?offset=16&size=8341";
317 uint32_t uri_index
318 = string_pool.indexOfString(expected_uri.data(), expected_uri.length()).value_or(-1);
319
320 const auto& target_inline_entries = data->GetTargetInlineEntries();
321 ASSERT_EQ(target_inline_entries.size(), 4U);
322 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[0], R::target::drawable::dr1, "port-xxhdpi-v7",
323 Res_value::TYPE_STRING, uri_index);
324 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[1], R::target::integer::int1, "land-xxhdpi-v7",
325 Res_value::TYPE_INT_DEC, 2U);
326 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[2], R::target::string::str1, "land",
327 Res_value::TYPE_REFERENCE, 0x7f010000);
328 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[3], R::target::string::str2, "xxhdpi-v7",
329 Res_value::TYPE_STRING,
330 (uint32_t) (string_pool.indexOfString(u"foobar", 6)).value_or(-1));
331 }
332
TEST(IdmapTests,FailCreateIdmapInvalidName)333 TEST(IdmapTests, FailCreateIdmapInvalidName) {
334 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
335 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
336
337 auto target = TargetResourceContainer::FromPath(target_apk_path);
338 ASSERT_TRUE(target);
339
340 auto overlay = OverlayResourceContainer::FromPath(overlay_apk_path);
341 ASSERT_TRUE(overlay);
342
343 {
344 auto idmap_result = Idmap::FromContainers(**target, **overlay, "", PolicyFlags::PUBLIC,
345 /* enforce_overlayable */ true);
346 ASSERT_FALSE(idmap_result);
347 }
348 {
349 auto idmap_result = Idmap::FromContainers(**target, **overlay, "unknown", PolicyFlags::PUBLIC,
350 /* enforce_overlayable */ true);
351 ASSERT_FALSE(idmap_result);
352 }
353 }
354
TEST(IdmapTests,CreateIdmapDataFromApkAssetsSharedLibOverlay)355 TEST(IdmapTests, CreateIdmapDataFromApkAssetsSharedLibOverlay) {
356 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
357 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay-shared.apk";
358
359 auto target = TargetResourceContainer::FromPath(target_apk_path);
360 ASSERT_TRUE(target);
361
362 auto overlay = OverlayResourceContainer::FromPath(overlay_apk_path);
363 ASSERT_TRUE(overlay);
364
365 auto idmap_result = Idmap::FromContainers(
366 **target, **overlay, TestConstants::OVERLAY_NAME_DEFAULT, PolicyFlags::PUBLIC,
367 /* enforce_overlayable */ true);
368 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
369 auto& idmap = *idmap_result;
370 ASSERT_THAT(idmap, NotNull());
371
372 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
373 ASSERT_EQ(dataBlocks.size(), 1U);
374
375 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
376 ASSERT_THAT(data, NotNull());
377
378 const auto& target_entries = data->GetTargetEntries();
379 ASSERT_EQ(target_entries.size(), 4U);
380 ASSERT_TARGET_ENTRY(target_entries[0], R::target::integer::int1,
381 fix_package_id(R::overlay::integer::int1, 0));
382 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str1,
383 fix_package_id(R::overlay::string::str1, 0));
384 ASSERT_TARGET_ENTRY(target_entries[2], R::target::string::str3,
385 fix_package_id(R::overlay::string::str3, 0));
386 ASSERT_TARGET_ENTRY(target_entries[3], R::target::string::str4,
387 fix_package_id(R::overlay::string::str4, 0));
388
389 const auto& target_inline_entries = data->GetTargetInlineEntries();
390 ASSERT_EQ(target_inline_entries.size(), 0U);
391
392 const auto& overlay_entries = data->GetOverlayEntries();
393 ASSERT_EQ(target_entries.size(), 4U);
394 ASSERT_OVERLAY_ENTRY(overlay_entries[0], fix_package_id(R::overlay::integer::int1, 0),
395 R::target::integer::int1);
396 ASSERT_OVERLAY_ENTRY(overlay_entries[1], fix_package_id(R::overlay::string::str1, 0),
397 R::target::string::str1);
398 ASSERT_OVERLAY_ENTRY(overlay_entries[2], fix_package_id(R::overlay::string::str3, 0),
399 R::target::string::str3);
400 ASSERT_OVERLAY_ENTRY(overlay_entries[3], fix_package_id(R::overlay::string::str4, 0),
401 R::target::string::str4);
402 }
403
TestIdmapDataFromApkAssets(const std::string & local_target_path,const std::string & local_overlay_path,const std::string & overlay_name,const PolicyBitmask & fulfilled_policies,bool enforce_overlayable)404 Result<std::unique_ptr<const IdmapData>> TestIdmapDataFromApkAssets(
405 const std::string& local_target_path, const std::string& local_overlay_path,
406 const std::string& overlay_name, const PolicyBitmask& fulfilled_policies,
407 bool enforce_overlayable) {
408 const std::string target_path(GetTestDataPath() + local_target_path);
409 auto target = TargetResourceContainer::FromPath(target_path);
410 if (!target) {
411 return Error(R"(Failed to load target "%s")", target_path.c_str());
412 }
413
414 const std::string overlay_path(GetTestDataPath() + local_overlay_path);
415 auto overlay = OverlayResourceContainer::FromPath(overlay_path);
416 if (!overlay) {
417 return Error(R"(Failed to load overlay "%s")", overlay_path.c_str());
418 }
419
420 auto overlay_info = (*overlay)->FindOverlayInfo(overlay_name);
421 if (!overlay_info) {
422 return Error(R"(Failed to find overlay name "%s")", overlay_name.c_str());
423 }
424
425 LogInfo log_info;
426 auto mapping = ResourceMapping::FromContainers(**target, **overlay, *overlay_info,
427 fulfilled_policies, enforce_overlayable, log_info);
428 if (!mapping) {
429 return mapping.GetError();
430 }
431
432 return IdmapData::FromResourceMapping(*mapping);
433 }
434
TEST(IdmapTests,CreateIdmapDataDoNotRewriteNonOverlayResourceId)435 TEST(IdmapTests, CreateIdmapDataDoNotRewriteNonOverlayResourceId) {
436 auto idmap_data = TestIdmapDataFromApkAssets("/target/target.apk", "/overlay/overlay.apk",
437 "DifferentPackages", PolicyFlags::PUBLIC,
438 /* enforce_overlayable */ false);
439
440 ASSERT_TRUE(idmap_data) << idmap_data.GetErrorMessage();
441 auto& data = *idmap_data;
442
443 const auto& target_entries = data->GetTargetEntries();
444 ASSERT_EQ(target_entries.size(), 2U);
445 ASSERT_TARGET_ENTRY(target_entries[0], R::target::string::str1,
446 0x0104000a); // -> android:string/ok
447 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str3, R::overlay::string::str3);
448
449 const auto& target_inline_entries = data->GetTargetInlineEntries();
450 ASSERT_EQ(target_inline_entries.size(), 0U);
451
452 const auto& overlay_entries = data->GetOverlayEntries();
453 ASSERT_EQ(overlay_entries.size(), 1U);
454 ASSERT_OVERLAY_ENTRY(overlay_entries[0], R::overlay::string::str3, R::target::string::str3);
455 }
456
TEST(IdmapTests,CreateIdmapDataInlineResources)457 TEST(IdmapTests, CreateIdmapDataInlineResources) {
458 auto idmap_data = TestIdmapDataFromApkAssets("/target/target.apk", "/overlay/overlay.apk",
459 "Inline", PolicyFlags::PUBLIC,
460 /* enforce_overlayable */ false);
461
462 ASSERT_TRUE(idmap_data) << idmap_data.GetErrorMessage();
463 auto& data = *idmap_data;
464
465 const auto& target_entries = data->GetTargetEntries();
466 ASSERT_EQ(target_entries.size(), 0U);
467
468 constexpr size_t overlay_string_pool_size = 10U;
469 const auto& target_inline_entries = data->GetTargetInlineEntries();
470 ASSERT_EQ(target_inline_entries.size(), 2U);
471 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[0], R::target::integer::int1, std::string(),
472 Res_value::TYPE_INT_DEC, 73U); // -> 73
473 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[1], R::target::string::str1, std::string(),
474 Res_value::TYPE_STRING,
475 overlay_string_pool_size + 0U); // -> "Hello World"
476
477 const auto& overlay_entries = data->GetOverlayEntries();
478 ASSERT_EQ(overlay_entries.size(), 0U);
479 }
480
TEST(IdmapTests,IdmapHeaderIsUpToDate)481 TEST(IdmapTests, IdmapHeaderIsUpToDate) {
482 fclose(stderr); // silence expected warnings from libandroidfw
483
484 const std::string target_apk_path {kIdmapRawTargetPath};
485 const std::string overlay_apk_path {kIdmapRawOverlayPath};
486 const std::string overlay_name {kIdmapRawOverlayName};
487 const PolicyBitmask policies = kIdmapRawDataPolicies;
488 const uint32_t target_crc = kIdmapRawDataTargetCrc;
489 const uint32_t overlay_crc = kIdmapRawOverlayCrc;
490
491 std::string raw(reinterpret_cast<const char*>(kIdmapRawData), kIdmapRawDataLen);
492 std::istringstream raw_stream(raw);
493
494 auto result = Idmap::FromBinaryStream(raw_stream);
495 ASSERT_TRUE(result);
496 const auto idmap = std::move(*result);
497
498 std::stringstream stream;
499 BinaryStreamVisitor visitor(stream);
500 idmap->accept(&visitor);
501
502 std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
503 ASSERT_THAT(header, NotNull());
504 ASSERT_TRUE(header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
505 kIdmapRawDataTargetCrc, overlay_crc, policies,
506 /* enforce_overlayable */ true));
507
508 // magic: bytes (0x0, 0x03)
509 std::string bad_magic_string(stream.str());
510 bad_magic_string[0x0] = '.';
511 bad_magic_string[0x1] = '.';
512 bad_magic_string[0x2] = '.';
513 bad_magic_string[0x3] = '.';
514 std::stringstream bad_magic_stream(bad_magic_string);
515 std::unique_ptr<const IdmapHeader> bad_magic_header =
516 IdmapHeader::FromBinaryStream(bad_magic_stream);
517 ASSERT_EQ(nullptr, bad_magic_header);
518
519 // version: bytes (0x4, 0x07)
520 std::string bad_version_string(stream.str());
521 bad_version_string[0x4] = '.';
522 bad_version_string[0x5] = '.';
523 bad_version_string[0x6] = '.';
524 bad_version_string[0x7] = '.';
525 std::stringstream bad_version_stream(bad_version_string);
526 std::unique_ptr<const IdmapHeader> bad_version_header =
527 IdmapHeader::FromBinaryStream(bad_version_stream);
528 ASSERT_EQ(nullptr, bad_version_header);
529
530 // target crc: bytes (0x8, 0xb)
531 std::string bad_target_crc_string(stream.str());
532 bad_target_crc_string[0x8] = '.';
533 bad_target_crc_string[0x9] = '.';
534 bad_target_crc_string[0xa] = '.';
535 bad_target_crc_string[0xb] = '.';
536 std::stringstream bad_target_crc_stream(bad_target_crc_string);
537 std::unique_ptr<const IdmapHeader> bad_target_crc_header =
538 IdmapHeader::FromBinaryStream(bad_target_crc_stream);
539 ASSERT_THAT(bad_target_crc_header, NotNull());
540 ASSERT_NE(header->GetTargetCrc(), bad_target_crc_header->GetTargetCrc());
541 ASSERT_FALSE(bad_target_crc_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
542 target_crc, overlay_crc, policies,
543 /* enforce_overlayable */ true));
544
545 // overlay crc: bytes (0xc, 0xf)
546 std::string bad_overlay_crc_string(stream.str());
547 bad_overlay_crc_string[0xc] = '.';
548 bad_overlay_crc_string[0xd] = '.';
549 bad_overlay_crc_string[0xe] = '.';
550 bad_overlay_crc_string[0xf] = '.';
551 std::stringstream bad_overlay_crc_stream(bad_overlay_crc_string);
552 std::unique_ptr<const IdmapHeader> bad_overlay_crc_header =
553 IdmapHeader::FromBinaryStream(bad_overlay_crc_stream);
554 ASSERT_THAT(bad_overlay_crc_header, NotNull());
555 ASSERT_NE(header->GetOverlayCrc(), bad_overlay_crc_header->GetOverlayCrc());
556 ASSERT_FALSE(bad_overlay_crc_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
557 target_crc, overlay_crc, policies,
558 /* enforce_overlayable */ true));
559
560 // fulfilled policy: bytes (0x10, 0x13)
561 std::string bad_policy_string(stream.str());
562 bad_policy_string[0x10] = '.';
563 bad_policy_string[0x11] = '.';
564 bad_policy_string[0x12] = '.';
565 bad_policy_string[0x13] = '.';
566 std::stringstream bad_policy_stream(bad_policy_string);
567 std::unique_ptr<const IdmapHeader> bad_policy_header =
568 IdmapHeader::FromBinaryStream(bad_policy_stream);
569 ASSERT_THAT(bad_policy_header, NotNull());
570 ASSERT_NE(header->GetFulfilledPolicies(), bad_policy_header->GetFulfilledPolicies());
571 ASSERT_FALSE(bad_policy_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
572 target_crc, overlay_crc, policies,
573 /* enforce_overlayable */ true));
574
575 // enforce overlayable: bytes (0x14)
576 std::string bad_enforce_string(stream.str());
577 bad_enforce_string[0x14] = '\0';
578 std::stringstream bad_enforce_stream(bad_enforce_string);
579 std::unique_ptr<const IdmapHeader> bad_enforce_header =
580 IdmapHeader::FromBinaryStream(bad_enforce_stream);
581 ASSERT_THAT(bad_enforce_header, NotNull());
582 ASSERT_NE(header->GetEnforceOverlayable(), bad_enforce_header->GetEnforceOverlayable());
583 ASSERT_FALSE(bad_enforce_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
584 target_crc, overlay_crc, policies,
585 /* enforce_overlayable */ true));
586
587 // target path: bytes (0x1c, 0x27)
588 std::string bad_target_path_string(stream.str());
589 bad_target_path_string[0x1c] = '\0';
590 std::stringstream bad_target_path_stream(bad_target_path_string);
591 std::unique_ptr<const IdmapHeader> bad_target_path_header =
592 IdmapHeader::FromBinaryStream(bad_target_path_stream);
593 ASSERT_THAT(bad_target_path_header, NotNull());
594 ASSERT_NE(header->GetTargetPath(), bad_target_path_header->GetTargetPath());
595 ASSERT_FALSE(bad_target_path_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
596 target_crc, overlay_crc, policies,
597 /* enforce_overlayable */ true));
598
599 // overlay path: bytes (0x2c, 0x37)
600 std::string bad_overlay_path_string(stream.str());
601 bad_overlay_path_string[0x33] = '\0';
602 std::stringstream bad_overlay_path_stream(bad_overlay_path_string);
603 std::unique_ptr<const IdmapHeader> bad_overlay_path_header =
604 IdmapHeader::FromBinaryStream(bad_overlay_path_stream);
605 ASSERT_THAT(bad_overlay_path_header, NotNull());
606 ASSERT_NE(header->GetOverlayPath(), bad_overlay_path_header->GetOverlayPath());
607 ASSERT_FALSE(bad_overlay_path_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
608 target_crc, overlay_crc, policies,
609 /* enforce_overlayable */ true));
610
611 // overlay name: bytes (0x3c, 0x47)
612 std::string bad_overlay_name_string(stream.str());
613 bad_overlay_name_string[0x3c] = '\0';
614 std::stringstream bad_overlay_name_stream(bad_overlay_name_string);
615 std::unique_ptr<const IdmapHeader> bad_overlay_name_header =
616 IdmapHeader::FromBinaryStream(bad_overlay_name_stream);
617 ASSERT_THAT(bad_overlay_name_header, NotNull());
618 ASSERT_NE(header->GetOverlayName(), bad_overlay_name_header->GetOverlayName());
619 ASSERT_FALSE(bad_overlay_name_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
620 target_crc, overlay_crc, policies,
621 /* enforce_overlayable */ true));
622 }
623
624 class TestVisitor : public Visitor {
625 public:
TestVisitor(std::ostream & stream)626 explicit TestVisitor(std::ostream& stream) : stream_(stream) {
627 }
628
visit(const Idmap & idmap ATTRIBUTE_UNUSED)629 void visit(const Idmap& idmap ATTRIBUTE_UNUSED) override {
630 stream_ << "TestVisitor::visit(Idmap)" << '\n';
631 }
632
visit(const IdmapHeader & idmap ATTRIBUTE_UNUSED)633 void visit(const IdmapHeader& idmap ATTRIBUTE_UNUSED) override {
634 stream_ << "TestVisitor::visit(IdmapHeader)" << '\n';
635 }
636
visit(const IdmapData & idmap ATTRIBUTE_UNUSED)637 void visit(const IdmapData& idmap ATTRIBUTE_UNUSED) override {
638 stream_ << "TestVisitor::visit(IdmapData)" << '\n';
639 }
640
visit(const IdmapData::Header & idmap ATTRIBUTE_UNUSED)641 void visit(const IdmapData::Header& idmap ATTRIBUTE_UNUSED) override {
642 stream_ << "TestVisitor::visit(IdmapData::Header)" << '\n';
643 }
644
645 private:
646 std::ostream& stream_;
647 };
648
TEST(IdmapTests,TestVisitor)649 TEST(IdmapTests, TestVisitor) {
650 std::string raw(reinterpret_cast<const char*>(kIdmapRawData), kIdmapRawDataLen);
651 std::istringstream stream(raw);
652
653 const auto idmap = Idmap::FromBinaryStream(stream);
654 ASSERT_TRUE(idmap);
655
656 std::stringstream test_stream;
657 TestVisitor visitor(test_stream);
658 (*idmap)->accept(&visitor);
659
660 ASSERT_EQ(test_stream.str(),
661 "TestVisitor::visit(IdmapHeader)\n"
662 "TestVisitor::visit(Idmap)\n"
663 "TestVisitor::visit(IdmapData::Header)\n"
664 "TestVisitor::visit(IdmapData)\n");
665 }
666
667 } // namespace android::idmap2
668
