blob: 16b68f01e8f5adfa17c6024d2d66676c4cc36529 [file] [log] [blame]
Mårten Kongstad02751232018-04-27 13:16:32 +02001/*
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 <cstdio> // fclose
Mårten Kongstad02751232018-04-27 13:16:32 +020018#include <fstream>
19#include <memory>
20#include <sstream>
21#include <string>
Mårten Kongstadce424902019-03-01 08:35:37 +010022#include <utility>
Mårten Kongstad02751232018-04-27 13:16:32 +020023#include <vector>
24
Winson62ac8b52019-12-04 08:36:48 -080025#include "R.h"
26#include "TestConstants.h"
Ryan Mitchell52e1f7a2019-04-12 12:31:42 -070027#include "TestHelpers.h"
Mårten Kongstad02751232018-04-27 13:16:32 +020028#include "android-base/macros.h"
29#include "androidfw/ApkAssets.h"
Ryan Mitchell30dc2e02020-12-02 11:43:18 -080030#include "androidfw/ResourceUtils.h"
Ryan Mitchell52e1f7a2019-04-12 12:31:42 -070031#include "gmock/gmock.h"
32#include "gtest/gtest.h"
Mårten Kongstad02751232018-04-27 13:16:32 +020033#include "idmap2/BinaryStreamVisitor.h"
34#include "idmap2/CommandLineOptions.h"
35#include "idmap2/Idmap.h"
Mårten Kongstadd7e8a532019-10-11 08:32:04 +020036#include "idmap2/LogInfo.h"
Mårten Kongstad02751232018-04-27 13:16:32 +020037
Ryan Mitchelle753ffe2019-09-23 09:47:02 -070038using android::Res_value;
Mårten Kongstad02751232018-04-27 13:16:32 +020039using ::testing::NotNull;
40
Winson62ac8b52019-12-04 08:36:48 -080041using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
42
Mårten Kongstad0eba72a2018-11-29 08:23:14 +010043namespace android::idmap2 {
Mårten Kongstad02751232018-04-27 13:16:32 +020044
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -070045#define ASSERT_TARGET_ENTRY(entry, target_resid, overlay_resid) \
46 ASSERT_EQ((entry).target_id, (target_resid)); \
47 ASSERT_EQ((entry).overlay_id, (overlay_resid))
48
49#define ASSERT_TARGET_INLINE_ENTRY(entry, target_resid, expected_type, expected_value) \
50 ASSERT_EQ((entry).target_id, target_resid); \
51 ASSERT_EQ((entry).value.data_type, (expected_type)); \
52 ASSERT_EQ((entry).value.data_value, (expected_value))
Ryan Mitchelle753ffe2019-09-23 09:47:02 -070053
54#define ASSERT_OVERLAY_ENTRY(entry, overlay_resid, target_resid) \
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -070055 ASSERT_EQ((entry).overlay_id, (overlay_resid)); \
56 ASSERT_EQ((entry).target_id, (target_resid))
Ryan Mitchelle753ffe2019-09-23 09:47:02 -070057
Mårten Kongstad02751232018-04-27 13:16:32 +020058TEST(IdmapTests, TestCanonicalIdmapPathFor) {
59 ASSERT_EQ(Idmap::CanonicalIdmapPathFor("/foo", "/vendor/overlay/bar.apk"),
60 "/foo/vendor@overlay@bar.apk@idmap");
61}
62
63TEST(IdmapTests, CreateIdmapHeaderFromBinaryStream) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -080064 std::string raw(reinterpret_cast<const char*>(idmap_raw_data), kIdmapRawDataLen);
Mårten Kongstad02751232018-04-27 13:16:32 +020065 std::istringstream stream(raw);
66 std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
67 ASSERT_THAT(header, NotNull());
Mårten Kongstadb8779022018-11-29 09:53:17 +010068 ASSERT_EQ(header->GetMagic(), 0x504d4449U);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -080069 ASSERT_EQ(header->GetVersion(), 0x07U);
Mårten Kongstadb8779022018-11-29 09:53:17 +010070 ASSERT_EQ(header->GetTargetCrc(), 0x1234U);
71 ASSERT_EQ(header->GetOverlayCrc(), 0x5678U);
Ryan Mitchella7070132020-05-13 14:17:52 -070072 ASSERT_EQ(header->GetFulfilledPolicies(), 0x11);
73 ASSERT_EQ(header->GetEnforceOverlayable(), true);
Ryan Mitchell0699f1d2020-12-03 15:41:42 -080074 ASSERT_EQ(header->GetTargetPath(), "targetX.apk");
75 ASSERT_EQ(header->GetOverlayPath(), "overlayX.apk");
Mårten Kongstadd7e8a532019-10-11 08:32:04 +020076 ASSERT_EQ(header->GetDebugInfo(), "debug");
Mårten Kongstad02751232018-04-27 13:16:32 +020077}
78
Ryan Mitchell9289a042021-01-13 17:21:29 -080079TEST(IdmapTests, IdmapFailParsingDifferentVersion) {
80 constexpr size_t kJunkSize = 2000;
81 std::stringstream stream;
82 stream << android::kIdmapMagic;
83 stream << 0xffffffffU;
84 stream << std::string(kJunkSize, (char) 0xffU);
85 ASSERT_FALSE(Idmap::FromBinaryStream(stream));
86}
87
88TEST(IdmapTests, IdmapFailParsingDifferentMagic) {
89 constexpr size_t kJunkSize = 2000;
90 std::stringstream stream;
91 stream << 0xffffffffU;
92 stream << android::kIdmapCurrentVersion;
93 stream << std::string(kJunkSize, (char) 0xffU);
94 ASSERT_FALSE(Idmap::FromBinaryStream(stream));
95}
96
Mårten Kongstad02751232018-04-27 13:16:32 +020097TEST(IdmapTests, CreateIdmapDataHeaderFromBinaryStream) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -080098 const size_t offset = kIdmapRawDataOffset;
Mårten Kongstad02751232018-04-27 13:16:32 +020099 std::string raw(reinterpret_cast<const char*>(idmap_raw_data + offset),
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800100 kIdmapRawDataLen - offset);
Mårten Kongstad02751232018-04-27 13:16:32 +0200101 std::istringstream stream(raw);
102
103 std::unique_ptr<const IdmapData::Header> header = IdmapData::Header::FromBinaryStream(stream);
104 ASSERT_THAT(header, NotNull());
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700105 ASSERT_EQ(header->GetTargetEntryCount(), 0x03);
106 ASSERT_EQ(header->GetOverlayEntryCount(), 0x03);
Mårten Kongstad02751232018-04-27 13:16:32 +0200107}
108
109TEST(IdmapTests, CreateIdmapDataFromBinaryStream) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800110 const size_t offset = kIdmapRawDataOffset;
Mårten Kongstad02751232018-04-27 13:16:32 +0200111 std::string raw(reinterpret_cast<const char*>(idmap_raw_data + offset),
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800112 kIdmapRawDataLen - offset);
Mårten Kongstad02751232018-04-27 13:16:32 +0200113 std::istringstream stream(raw);
114
115 std::unique_ptr<const IdmapData> data = IdmapData::FromBinaryStream(stream);
116 ASSERT_THAT(data, NotNull());
Mårten Kongstad02751232018-04-27 13:16:32 +0200117
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700118 const auto& target_entries = data->GetTargetEntries();
119 ASSERT_EQ(target_entries.size(), 3U);
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700120 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, Res_value::TYPE_INT_HEX,
127 0x12345678);
Mårten Kongstad02751232018-04-27 13:16:32 +0200128
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700129 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);
Mårten Kongstad02751232018-04-27 13:16:32 +0200134}
135
136TEST(IdmapTests, CreateIdmapFromBinaryStream) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800137 std::string raw(reinterpret_cast<const char*>(idmap_raw_data), kIdmapRawDataLen);
Mårten Kongstad02751232018-04-27 13:16:32 +0200138 std::istringstream stream(raw);
139
Mårten Kongstadce424902019-03-01 08:35:37 +0100140 auto result = Idmap::FromBinaryStream(stream);
141 ASSERT_TRUE(result);
142 const auto idmap = std::move(*result);
Mårten Kongstad02751232018-04-27 13:16:32 +0200143
144 ASSERT_THAT(idmap->GetHeader(), NotNull());
Mårten Kongstadb8779022018-11-29 09:53:17 +0100145 ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449U);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800146 ASSERT_EQ(idmap->GetHeader()->GetVersion(), 0x07U);
Mårten Kongstadb8779022018-11-29 09:53:17 +0100147 ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), 0x1234U);
148 ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), 0x5678U);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800149 ASSERT_EQ(idmap->GetHeader()->GetFulfilledPolicies(), kIdmapRawDataPolicies);
Ryan Mitchella7070132020-05-13 14:17:52 -0700150 ASSERT_EQ(idmap->GetHeader()->GetEnforceOverlayable(), true);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800151 ASSERT_EQ(idmap->GetHeader()->GetTargetPath(), kIdmapRawTargetPath);
152 ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), kIdmapRawOverlayPath);
153 ASSERT_EQ(idmap->GetHeader()->GetOverlayName(), kIdmapRawOverlayName);
Mårten Kongstad02751232018-04-27 13:16:32 +0200154
155 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
Mårten Kongstadb8779022018-11-29 09:53:17 +0100156 ASSERT_EQ(dataBlocks.size(), 1U);
Mårten Kongstad02751232018-04-27 13:16:32 +0200157
158 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700159 ASSERT_THAT(data, NotNull());
Mårten Kongstad02751232018-04-27 13:16:32 +0200160
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700161 const auto& target_entries = data->GetTargetEntries();
162 ASSERT_EQ(target_entries.size(), 3U);
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700163 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, Res_value::TYPE_INT_HEX,
170 0x12345678);
Mårten Kongstad02751232018-04-27 13:16:32 +0200171
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700172 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);
Mårten Kongstad02751232018-04-27 13:16:32 +0200177}
178
179TEST(IdmapTests, GracefullyFailToCreateIdmapFromCorruptBinaryStream) {
180 std::string raw(reinterpret_cast<const char*>(idmap_raw_data),
181 10); // data too small
182 std::istringstream stream(raw);
183
Mårten Kongstadce424902019-03-01 08:35:37 +0100184 const auto result = Idmap::FromBinaryStream(stream);
185 ASSERT_FALSE(result);
Mårten Kongstad02751232018-04-27 13:16:32 +0200186}
187
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700188TEST(IdmapTests, CreateIdmapHeaderFromApkAssets) {
Ryan Mitchellb863ca32019-03-07 14:31:54 -0800189 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
190 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700191
192 std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
193 ASSERT_THAT(target_apk, NotNull());
194
195 std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
196 ASSERT_THAT(overlay_apk, NotNull());
197
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800198 auto idmap_result = Idmap::FromApkAssets(
199 *target_apk, *overlay_apk, TestConstants::OVERLAY_NAME_ALL_POLICIES, PolicyFlags::PUBLIC,
200 /* enforce_overlayable */ true);
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700201 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
202 auto& idmap = *idmap_result;
203 ASSERT_THAT(idmap, NotNull());
Mårten Kongstad02751232018-04-27 13:16:32 +0200204
205 ASSERT_THAT(idmap->GetHeader(), NotNull());
Mårten Kongstadb8779022018-11-29 09:53:17 +0100206 ASSERT_EQ(idmap->GetHeader()->GetMagic(), 0x504d4449U);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800207 ASSERT_EQ(idmap->GetHeader()->GetVersion(), 0x07U);
Winson62ac8b52019-12-04 08:36:48 -0800208 ASSERT_EQ(idmap->GetHeader()->GetTargetCrc(), android::idmap2::TestConstants::TARGET_CRC);
209 ASSERT_EQ(idmap->GetHeader()->GetOverlayCrc(), android::idmap2::TestConstants::OVERLAY_CRC);
Ryan Mitchella7070132020-05-13 14:17:52 -0700210 ASSERT_EQ(idmap->GetHeader()->GetFulfilledPolicies(), PolicyFlags::PUBLIC);
211 ASSERT_EQ(idmap->GetHeader()->GetEnforceOverlayable(), true);
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800212 ASSERT_EQ(idmap->GetHeader()->GetTargetPath(), target_apk_path);
Mårten Kongstad02751232018-04-27 13:16:32 +0200213 ASSERT_EQ(idmap->GetHeader()->GetOverlayPath(), overlay_apk_path);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800214 ASSERT_EQ(idmap->GetHeader()->GetOverlayName(), TestConstants::OVERLAY_NAME_ALL_POLICIES);
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700215}
216
217TEST(IdmapTests, CreateIdmapDataFromApkAssets) {
Ryan Mitchellb863ca32019-03-07 14:31:54 -0800218 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700219 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
220
221 std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
222 ASSERT_THAT(target_apk, NotNull());
223
224 std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
225 ASSERT_THAT(overlay_apk, NotNull());
226
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800227 auto idmap_result = Idmap::FromApkAssets(*target_apk, *overlay_apk,
228 TestConstants::OVERLAY_NAME_DEFAULT, PolicyFlags::PUBLIC,
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700229 /* enforce_overlayable */ true);
230 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
231 auto& idmap = *idmap_result;
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800232 ASSERT_THAT(idmap, NotNull());
233
234 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
235 ASSERT_EQ(dataBlocks.size(), 1U);
236
237 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700238 ASSERT_THAT(data, NotNull());
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800239
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700240 const auto& target_entries = data->GetTargetEntries();
241 ASSERT_EQ(target_entries.size(), 4U);
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700242 ASSERT_TARGET_ENTRY(target_entries[0], R::target::integer::int1, R::overlay::integer::int1);
243 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str1, R::overlay::string::str1);
244 ASSERT_TARGET_ENTRY(target_entries[2], R::target::string::str3, R::overlay::string::str3);
245 ASSERT_TARGET_ENTRY(target_entries[3], R::target::string::str4, R::overlay::string::str4);
246
247 const auto& target_inline_entries = data->GetTargetInlineEntries();
248 ASSERT_EQ(target_inline_entries.size(), 0U);
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800249
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700250 const auto& overlay_entries = data->GetOverlayEntries();
251 ASSERT_EQ(target_entries.size(), 4U);
Winson62ac8b52019-12-04 08:36:48 -0800252 ASSERT_OVERLAY_ENTRY(overlay_entries[0], R::overlay::integer::int1, R::target::integer::int1);
253 ASSERT_OVERLAY_ENTRY(overlay_entries[1], R::overlay::string::str1, R::target::string::str1);
254 ASSERT_OVERLAY_ENTRY(overlay_entries[2], R::overlay::string::str3, R::target::string::str3);
255 ASSERT_OVERLAY_ENTRY(overlay_entries[3], R::overlay::string::str4, R::target::string::str4);
Winsonb4100202019-02-06 12:05:32 -0800256}
257
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800258TEST(IdmapTests, FailCreateIdmapInvalidName) {
259 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
260 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay.apk";
261
262 std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
263 ASSERT_THAT(target_apk, NotNull());
264
265 std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
266 ASSERT_THAT(overlay_apk, NotNull());
267
268 {
269 auto idmap_result = Idmap::FromApkAssets(*target_apk, *overlay_apk, "", PolicyFlags::PUBLIC,
270 /* enforce_overlayable */ true);
271 ASSERT_FALSE(idmap_result);
272 }
273 {
274 auto idmap_result =
275 Idmap::FromApkAssets(*target_apk, *overlay_apk, "unknown", PolicyFlags::PUBLIC,
276 /* enforce_overlayable */ true);
277 ASSERT_FALSE(idmap_result);
278 }
279}
280
Ryan Mitchell5035d662020-01-22 13:19:41 -0800281TEST(IdmapTests, CreateIdmapDataFromApkAssetsSharedLibOverlay) {
282 std::string target_apk_path = GetTestDataPath() + "/target/target.apk";
283 std::string overlay_apk_path = GetTestDataPath() + "/overlay/overlay-shared.apk";
284
285 std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
286 ASSERT_THAT(target_apk, NotNull());
287
288 std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
289 ASSERT_THAT(overlay_apk, NotNull());
290
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800291 auto idmap_result = Idmap::FromApkAssets(*target_apk, *overlay_apk,
292 TestConstants::OVERLAY_NAME_DEFAULT, PolicyFlags::PUBLIC,
Ryan Mitchell5035d662020-01-22 13:19:41 -0800293 /* enforce_overlayable */ true);
294 ASSERT_TRUE(idmap_result) << idmap_result.GetErrorMessage();
295 auto& idmap = *idmap_result;
296 ASSERT_THAT(idmap, NotNull());
297
298 const std::vector<std::unique_ptr<const IdmapData>>& dataBlocks = idmap->GetData();
299 ASSERT_EQ(dataBlocks.size(), 1U);
300
301 const std::unique_ptr<const IdmapData>& data = dataBlocks[0];
302 ASSERT_THAT(data, NotNull());
303
304 const auto& target_entries = data->GetTargetEntries();
305 ASSERT_EQ(target_entries.size(), 4U);
Winsonf56ade32019-12-04 11:32:41 -0800306 ASSERT_TARGET_ENTRY(target_entries[0], R::target::integer::int1,
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800307 fix_package_id(R::overlay::integer::int1, 0));
308 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str1,
309 fix_package_id(R::overlay::string::str1, 0));
310 ASSERT_TARGET_ENTRY(target_entries[2], R::target::string::str3,
311 fix_package_id(R::overlay::string::str3, 0));
312 ASSERT_TARGET_ENTRY(target_entries[3], R::target::string::str4,
313 fix_package_id(R::overlay::string::str4, 0));
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700314
315 const auto& target_inline_entries = data->GetTargetInlineEntries();
316 ASSERT_EQ(target_inline_entries.size(), 0U);
Ryan Mitchell5035d662020-01-22 13:19:41 -0800317
318 const auto& overlay_entries = data->GetOverlayEntries();
319 ASSERT_EQ(target_entries.size(), 4U);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800320 ASSERT_OVERLAY_ENTRY(overlay_entries[0], fix_package_id(R::overlay::integer::int1, 0),
Winsonf56ade32019-12-04 11:32:41 -0800321 R::target::integer::int1);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800322 ASSERT_OVERLAY_ENTRY(overlay_entries[1], fix_package_id(R::overlay::string::str1, 0),
Winsonf56ade32019-12-04 11:32:41 -0800323 R::target::string::str1);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800324 ASSERT_OVERLAY_ENTRY(overlay_entries[2], fix_package_id(R::overlay::string::str3, 0),
Winsonf56ade32019-12-04 11:32:41 -0800325 R::target::string::str3);
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800326 ASSERT_OVERLAY_ENTRY(overlay_entries[3], fix_package_id(R::overlay::string::str4, 0),
Winsonf56ade32019-12-04 11:32:41 -0800327 R::target::string::str4);
Ryan Mitchell5035d662020-01-22 13:19:41 -0800328}
329
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800330Result<std::unique_ptr<const IdmapData>> TestIdmapDataFromApkAssets(
331 const std::string& local_target_apk_path, const std::string& local_overlay_apk_path,
332 const std::string& overlay_name, const PolicyBitmask& fulfilled_policies,
333 bool enforce_overlayable) {
334 auto overlay_info =
335 utils::ExtractOverlayManifestInfo(GetTestDataPath() + local_overlay_apk_path, overlay_name);
336 if (!overlay_info) {
337 return overlay_info.GetError();
338 }
339
340 const std::string target_apk_path(GetTestDataPath() + local_target_apk_path);
341 std::unique_ptr<const ApkAssets> target_apk = ApkAssets::Load(target_apk_path);
342 if (!target_apk) {
343 return Error(R"(Failed to load target apk "%s")", target_apk_path.data());
344 }
345
346 const std::string overlay_apk_path(GetTestDataPath() + local_overlay_apk_path);
347 std::unique_ptr<const ApkAssets> overlay_apk = ApkAssets::Load(overlay_apk_path);
348 if (!overlay_apk) {
349 return Error(R"(Failed to load overlay apk "%s")", overlay_apk_path.data());
350 }
351
352 LogInfo log_info;
353 auto mapping = ResourceMapping::FromApkAssets(*target_apk, *overlay_apk, *overlay_info,
354 fulfilled_policies, enforce_overlayable, log_info);
355 if (!mapping) {
356 return mapping.GetError();
357 }
358
359 return IdmapData::FromResourceMapping(*mapping);
360}
361
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700362TEST(IdmapTests, CreateIdmapDataDoNotRewriteNonOverlayResourceId) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800363 auto idmap_data =
364 TestIdmapDataFromApkAssets("/target/target.apk", "/overlay/overlay.apk", "DifferentPackages",
365
366 PolicyFlags::PUBLIC,
367 /* enforce_overlayable */ false);
Winsonb4100202019-02-06 12:05:32 -0800368
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700369 ASSERT_TRUE(idmap_data) << idmap_data.GetErrorMessage();
370 auto& data = *idmap_data;
Winsonb4100202019-02-06 12:05:32 -0800371
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700372 const auto& target_entries = data->GetTargetEntries();
373 ASSERT_EQ(target_entries.size(), 2U);
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700374 ASSERT_TARGET_ENTRY(target_entries[0], R::target::string::str1,
Winson62ac8b52019-12-04 08:36:48 -0800375 0x0104000a); // -> android:string/ok
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700376 ASSERT_TARGET_ENTRY(target_entries[1], R::target::string::str3, R::overlay::string::str3);
377
378 const auto& target_inline_entries = data->GetTargetInlineEntries();
379 ASSERT_EQ(target_inline_entries.size(), 0U);
Winsonb4100202019-02-06 12:05:32 -0800380
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700381 const auto& overlay_entries = data->GetOverlayEntries();
382 ASSERT_EQ(overlay_entries.size(), 1U);
Winson62ac8b52019-12-04 08:36:48 -0800383 ASSERT_OVERLAY_ENTRY(overlay_entries[0], R::overlay::string::str3, R::target::string::str3);
Winsonb4100202019-02-06 12:05:32 -0800384}
385
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700386TEST(IdmapTests, CreateIdmapDataInlineResources) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800387 auto idmap_data = TestIdmapDataFromApkAssets("/target/target.apk", "/overlay/overlay.apk",
388 "Inline", PolicyFlags::PUBLIC,
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700389 /* enforce_overlayable */ false);
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800390
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700391 ASSERT_TRUE(idmap_data) << idmap_data.GetErrorMessage();
392 auto& data = *idmap_data;
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800393
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700394 const auto& target_entries = data->GetTargetEntries();
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700395 ASSERT_EQ(target_entries.size(), 0U);
396
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800397 constexpr size_t overlay_string_pool_size = 10U;
Ryan Mitchellbf1f45b2020-09-29 17:22:52 -0700398 const auto& target_inline_entries = data->GetTargetInlineEntries();
399 ASSERT_EQ(target_inline_entries.size(), 2U);
400 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[0], R::target::integer::int1,
401 Res_value::TYPE_INT_DEC, 73U); // -> 73
402 ASSERT_TARGET_INLINE_ENTRY(target_inline_entries[1], R::target::string::str1,
403 Res_value::TYPE_STRING,
404 overlay_string_pool_size + 0U); // -> "Hello World"
Mårten Kongstadd10d06d2019-01-07 17:26:25 -0800405
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700406 const auto& overlay_entries = data->GetOverlayEntries();
407 ASSERT_EQ(overlay_entries.size(), 0U);
Ryan Mitchell19823452019-01-29 12:01:24 -0800408}
409
Mårten Kongstad02751232018-04-27 13:16:32 +0200410TEST(IdmapTests, IdmapHeaderIsUpToDate) {
411 fclose(stderr); // silence expected warnings from libandroidfw
412
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800413 const std::string target_apk_path = kIdmapRawTargetPath;
414 const std::string overlay_apk_path = kIdmapRawOverlayPath;
415 const std::string overlay_name = kIdmapRawOverlayName;
416 const PolicyBitmask policies = kIdmapRawDataPolicies;
417 const uint32_t target_crc = kIdmapRawDataTargetCrc;
418 const uint32_t overlay_crc = kIdmapRawOverlayCrc;
Mårten Kongstad02751232018-04-27 13:16:32 +0200419
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800420 std::string raw(reinterpret_cast<const char*>(idmap_raw_data), kIdmapRawDataLen);
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800421 std::istringstream raw_stream(raw);
Mårten Kongstad02751232018-04-27 13:16:32 +0200422
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800423 auto result = Idmap::FromBinaryStream(raw_stream);
Mårten Kongstadce424902019-03-01 08:35:37 +0100424 ASSERT_TRUE(result);
425 const auto idmap = std::move(*result);
Mårten Kongstad02751232018-04-27 13:16:32 +0200426
427 std::stringstream stream;
428 BinaryStreamVisitor visitor(stream);
429 idmap->accept(&visitor);
430
431 std::unique_ptr<const IdmapHeader> header = IdmapHeader::FromBinaryStream(stream);
432 ASSERT_THAT(header, NotNull());
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800433 ASSERT_TRUE(header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
434 kIdmapRawDataTargetCrc, overlay_crc, policies,
435 /* enforce_overlayable */ true));
Mårten Kongstad02751232018-04-27 13:16:32 +0200436
437 // magic: bytes (0x0, 0x03)
438 std::string bad_magic_string(stream.str());
439 bad_magic_string[0x0] = '.';
440 bad_magic_string[0x1] = '.';
441 bad_magic_string[0x2] = '.';
442 bad_magic_string[0x3] = '.';
443 std::stringstream bad_magic_stream(bad_magic_string);
444 std::unique_ptr<const IdmapHeader> bad_magic_header =
445 IdmapHeader::FromBinaryStream(bad_magic_stream);
Ryan Mitchell9289a042021-01-13 17:21:29 -0800446 ASSERT_EQ(nullptr, bad_magic_header);
Mårten Kongstad02751232018-04-27 13:16:32 +0200447
448 // version: bytes (0x4, 0x07)
449 std::string bad_version_string(stream.str());
450 bad_version_string[0x4] = '.';
451 bad_version_string[0x5] = '.';
452 bad_version_string[0x6] = '.';
453 bad_version_string[0x7] = '.';
454 std::stringstream bad_version_stream(bad_version_string);
455 std::unique_ptr<const IdmapHeader> bad_version_header =
456 IdmapHeader::FromBinaryStream(bad_version_stream);
Ryan Mitchell9289a042021-01-13 17:21:29 -0800457 ASSERT_EQ(nullptr, bad_version_header);
Mårten Kongstad02751232018-04-27 13:16:32 +0200458
459 // target crc: bytes (0x8, 0xb)
460 std::string bad_target_crc_string(stream.str());
461 bad_target_crc_string[0x8] = '.';
462 bad_target_crc_string[0x9] = '.';
463 bad_target_crc_string[0xa] = '.';
464 bad_target_crc_string[0xb] = '.';
465 std::stringstream bad_target_crc_stream(bad_target_crc_string);
466 std::unique_ptr<const IdmapHeader> bad_target_crc_header =
467 IdmapHeader::FromBinaryStream(bad_target_crc_stream);
468 ASSERT_THAT(bad_target_crc_header, NotNull());
469 ASSERT_NE(header->GetTargetCrc(), bad_target_crc_header->GetTargetCrc());
Ryan Mitchell9289a042021-01-13 17:21:29 -0800470 ASSERT_FALSE(bad_target_crc_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800471 target_crc, overlay_crc, policies,
472 /* enforce_overlayable */ true));
Mårten Kongstad02751232018-04-27 13:16:32 +0200473
474 // overlay crc: bytes (0xc, 0xf)
475 std::string bad_overlay_crc_string(stream.str());
476 bad_overlay_crc_string[0xc] = '.';
477 bad_overlay_crc_string[0xd] = '.';
478 bad_overlay_crc_string[0xe] = '.';
479 bad_overlay_crc_string[0xf] = '.';
480 std::stringstream bad_overlay_crc_stream(bad_overlay_crc_string);
481 std::unique_ptr<const IdmapHeader> bad_overlay_crc_header =
482 IdmapHeader::FromBinaryStream(bad_overlay_crc_stream);
483 ASSERT_THAT(bad_overlay_crc_header, NotNull());
484 ASSERT_NE(header->GetOverlayCrc(), bad_overlay_crc_header->GetOverlayCrc());
Ryan Mitchell9289a042021-01-13 17:21:29 -0800485 ASSERT_FALSE(bad_overlay_crc_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800486 target_crc, overlay_crc, policies,
487 /* enforce_overlayable */ true));
Mårten Kongstad02751232018-04-27 13:16:32 +0200488
Ryan Mitchella7070132020-05-13 14:17:52 -0700489 // fulfilled policy: bytes (0x10, 0x13)
490 std::string bad_policy_string(stream.str());
491 bad_policy_string[0x10] = '.';
492 bad_policy_string[0x11] = '.';
493 bad_policy_string[0x12] = '.';
494 bad_policy_string[0x13] = '.';
495 std::stringstream bad_policy_stream(bad_policy_string);
496 std::unique_ptr<const IdmapHeader> bad_policy_header =
497 IdmapHeader::FromBinaryStream(bad_policy_stream);
498 ASSERT_THAT(bad_policy_header, NotNull());
499 ASSERT_NE(header->GetFulfilledPolicies(), bad_policy_header->GetFulfilledPolicies());
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800500 ASSERT_FALSE(bad_policy_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
501 target_crc, overlay_crc, policies,
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800502 /* enforce_overlayable */ true));
Ryan Mitchella7070132020-05-13 14:17:52 -0700503
504 // enforce overlayable: bytes (0x14)
505 std::string bad_enforce_string(stream.str());
506 bad_enforce_string[0x14] = '\0';
507 std::stringstream bad_enforce_stream(bad_enforce_string);
508 std::unique_ptr<const IdmapHeader> bad_enforce_header =
509 IdmapHeader::FromBinaryStream(bad_enforce_stream);
510 ASSERT_THAT(bad_enforce_header, NotNull());
511 ASSERT_NE(header->GetEnforceOverlayable(), bad_enforce_header->GetEnforceOverlayable());
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800512 ASSERT_FALSE(bad_enforce_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
513 target_crc, overlay_crc, policies,
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800514 /* enforce_overlayable */ true));
Ryan Mitchella7070132020-05-13 14:17:52 -0700515
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800516 // target path: bytes (0x1c, 0x27)
Mårten Kongstad02751232018-04-27 13:16:32 +0200517 std::string bad_target_path_string(stream.str());
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800518 bad_target_path_string[0x1c] = '\0';
Mårten Kongstad02751232018-04-27 13:16:32 +0200519 std::stringstream bad_target_path_stream(bad_target_path_string);
520 std::unique_ptr<const IdmapHeader> bad_target_path_header =
521 IdmapHeader::FromBinaryStream(bad_target_path_stream);
522 ASSERT_THAT(bad_target_path_header, NotNull());
523 ASSERT_NE(header->GetTargetPath(), bad_target_path_header->GetTargetPath());
Ryan Mitchell9289a042021-01-13 17:21:29 -0800524 ASSERT_FALSE(bad_target_path_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800525 target_crc, overlay_crc, policies,
526 /* enforce_overlayable */ true));
Mårten Kongstad02751232018-04-27 13:16:32 +0200527
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800528 // overlay path: bytes (0x2c, 0x37)
Mårten Kongstad02751232018-04-27 13:16:32 +0200529 std::string bad_overlay_path_string(stream.str());
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800530 bad_overlay_path_string[0x33] = '\0';
Mårten Kongstad02751232018-04-27 13:16:32 +0200531 std::stringstream bad_overlay_path_stream(bad_overlay_path_string);
532 std::unique_ptr<const IdmapHeader> bad_overlay_path_header =
533 IdmapHeader::FromBinaryStream(bad_overlay_path_stream);
534 ASSERT_THAT(bad_overlay_path_header, NotNull());
535 ASSERT_NE(header->GetOverlayPath(), bad_overlay_path_header->GetOverlayPath());
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800536 ASSERT_FALSE(bad_overlay_path_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
537 target_crc, overlay_crc, policies,
Ryan Mitchell0699f1d2020-12-03 15:41:42 -0800538 /* enforce_overlayable */ true));
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800539
Ryan Mitchell9289a042021-01-13 17:21:29 -0800540 // overlay name: bytes (0x3c, 0x47)
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800541 std::string bad_overlay_name_string(stream.str());
542 bad_overlay_name_string[0x3c] = '\0';
543 std::stringstream bad_overlay_name_stream(bad_overlay_name_string);
544 std::unique_ptr<const IdmapHeader> bad_overlay_name_header =
545 IdmapHeader::FromBinaryStream(bad_overlay_name_stream);
546 ASSERT_THAT(bad_overlay_name_header, NotNull());
547 ASSERT_NE(header->GetOverlayName(), bad_overlay_name_header->GetOverlayName());
548 ASSERT_FALSE(bad_overlay_name_header->IsUpToDate(target_apk_path, overlay_apk_path, overlay_name,
549 target_crc, overlay_crc, policies,
550 /* enforce_overlayable */ true));
Mårten Kongstad02751232018-04-27 13:16:32 +0200551}
552
553class TestVisitor : public Visitor {
554 public:
555 explicit TestVisitor(std::ostream& stream) : stream_(stream) {
556 }
557
Mårten Kongstad0eba72a2018-11-29 08:23:14 +0100558 void visit(const Idmap& idmap ATTRIBUTE_UNUSED) override {
Mårten Kongstad02751232018-04-27 13:16:32 +0200559 stream_ << "TestVisitor::visit(Idmap)" << std::endl;
560 }
561
Mårten Kongstad0eba72a2018-11-29 08:23:14 +0100562 void visit(const IdmapHeader& idmap ATTRIBUTE_UNUSED) override {
Mårten Kongstad02751232018-04-27 13:16:32 +0200563 stream_ << "TestVisitor::visit(IdmapHeader)" << std::endl;
564 }
565
Mårten Kongstad0eba72a2018-11-29 08:23:14 +0100566 void visit(const IdmapData& idmap ATTRIBUTE_UNUSED) override {
Mårten Kongstad02751232018-04-27 13:16:32 +0200567 stream_ << "TestVisitor::visit(IdmapData)" << std::endl;
568 }
569
Mårten Kongstad0eba72a2018-11-29 08:23:14 +0100570 void visit(const IdmapData::Header& idmap ATTRIBUTE_UNUSED) override {
Mårten Kongstad02751232018-04-27 13:16:32 +0200571 stream_ << "TestVisitor::visit(IdmapData::Header)" << std::endl;
572 }
573
Mårten Kongstad02751232018-04-27 13:16:32 +0200574 private:
575 std::ostream& stream_;
576};
577
578TEST(IdmapTests, TestVisitor) {
Ryan Mitchell30dc2e02020-12-02 11:43:18 -0800579 std::string raw(reinterpret_cast<const char*>(idmap_raw_data), kIdmapRawDataLen);
Mårten Kongstad02751232018-04-27 13:16:32 +0200580 std::istringstream stream(raw);
581
Mårten Kongstadce424902019-03-01 08:35:37 +0100582 const auto idmap = Idmap::FromBinaryStream(stream);
583 ASSERT_TRUE(idmap);
Mårten Kongstad02751232018-04-27 13:16:32 +0200584
585 std::stringstream test_stream;
586 TestVisitor visitor(test_stream);
Mårten Kongstadce424902019-03-01 08:35:37 +0100587 (*idmap)->accept(&visitor);
Mårten Kongstad02751232018-04-27 13:16:32 +0200588
589 ASSERT_EQ(test_stream.str(),
Mårten Kongstad02751232018-04-27 13:16:32 +0200590 "TestVisitor::visit(IdmapHeader)\n"
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700591 "TestVisitor::visit(Idmap)\n"
Mårten Kongstad02751232018-04-27 13:16:32 +0200592 "TestVisitor::visit(IdmapData::Header)\n"
Ryan Mitchelle753ffe2019-09-23 09:47:02 -0700593 "TestVisitor::visit(IdmapData)\n");
Mårten Kongstad02751232018-04-27 13:16:32 +0200594}
595
Mårten Kongstad0eba72a2018-11-29 08:23:14 +0100596} // namespace android::idmap2