1 /*
2  * Copyright (C) 2016 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 "androidfw/LoadedArsc.h"
18 
19 #include "android-base/file.h"
20 #include "androidfw/ResourceUtils.h"
21 
22 #include "TestHelpers.h"
23 #include "data/basic/R.h"
24 #include "data/libclient/R.h"
25 #include "data/overlayable/R.h"
26 #include "data/sparse/R.h"
27 #include "data/styles/R.h"
28 #include "data/system/R.h"
29 
30 namespace app = com::android::app;
31 namespace basic = com::android::basic;
32 namespace libclient = com::android::libclient;
33 namespace overlayable = com::android::overlayable;
34 namespace sparse = com::android::sparse;
35 
36 using ::android::base::ReadFileToString;
37 using ::testing::Eq;
38 using ::testing::Ge;
39 using ::testing::IsNull;
40 using ::testing::NotNull;
41 using ::testing::SizeIs;
42 using ::testing::StrEq;
43 
44 using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
45 
46 namespace android {
47 
TEST(LoadedArscTest,LoadSinglePackageArsc)48 TEST(LoadedArscTest, LoadSinglePackageArsc) {
49   std::string contents;
50   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/styles/styles.apk", "resources.arsc",
51                                       &contents));
52 
53   auto loaded_arsc = LoadedArsc::Load(reinterpret_cast<const void*>(contents.data()),
54                                                                     contents.length());
55   ASSERT_THAT(loaded_arsc, NotNull());
56 
57   const LoadedPackage* package =
58       loaded_arsc->GetPackageById(get_package_id(app::R::string::string_one));
59   ASSERT_THAT(package, NotNull());
60   EXPECT_THAT(package->GetPackageName(), StrEq("com.android.app"));
61   EXPECT_THAT(package->GetPackageId(), Eq(0x7f));
62 
63   const uint8_t type_index = get_type_id(app::R::string::string_one) - 1;
64   const uint16_t entry_index = get_entry_id(app::R::string::string_one);
65 
66   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
67   ASSERT_THAT(type_spec, NotNull());
68   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
69 
70   auto type = type_spec->type_entries[0];
71   ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
72 }
73 
TEST(LoadedArscTest,LoadSparseEntryApp)74 TEST(LoadedArscTest, LoadSparseEntryApp) {
75   std::string contents;
76   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/sparse/sparse.apk", "resources.arsc",
77                                       &contents));
78 
79   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
80                                                                    contents.length());
81   ASSERT_THAT(loaded_arsc, NotNull());
82 
83   const LoadedPackage* package =
84       loaded_arsc->GetPackageById(get_package_id(sparse::R::integer::foo_9));
85   ASSERT_THAT(package, NotNull());
86 
87   const uint8_t type_index = get_type_id(sparse::R::integer::foo_9) - 1;
88   const uint16_t entry_index = get_entry_id(sparse::R::integer::foo_9);
89 
90   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
91   ASSERT_THAT(type_spec, NotNull());
92   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
93 
94   auto type = type_spec->type_entries[0];
95   ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
96 }
97 
TEST(LoadedArscTest,FindSparseEntryApp)98 TEST(LoadedArscTest, FindSparseEntryApp) {
99   std::string contents;
100   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/sparse/sparse.apk", "resources.arsc",
101                                       &contents));
102 
103   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
104                                                                    contents.length());
105   ASSERT_THAT(loaded_arsc, NotNull());
106 
107   const LoadedPackage* package =
108       loaded_arsc->GetPackageById(get_package_id(sparse::R::string::only_v26));
109   ASSERT_THAT(package, NotNull());
110 
111   const uint8_t type_index = get_type_id(sparse::R::string::only_v26) - 1;
112   const uint16_t entry_index = get_entry_id(sparse::R::string::only_v26);
113 
114   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
115   ASSERT_THAT(type_spec, NotNull());
116   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
117 
118   // Ensure that AAPT2 sparsely encoded the v26 config as expected.
119   auto type_entry = std::find_if(
120     type_spec->type_entries.begin(), type_spec->type_entries.end(),
121     [](const TypeSpec::TypeEntry& x) { return x.config.sdkVersion == 26; });
122   ASSERT_NE(type_entry, type_spec->type_entries.end());
123   ASSERT_NE(type_entry->type->flags & ResTable_type::FLAG_SPARSE, 0);
124 
125   // Test fetching a resource with only sparsely encoded configs by name.
126   auto id = package->FindEntryByName(u"string", u"only_v26");
127   ASSERT_EQ(id.value(), fix_package_id(sparse::R::string::only_v26, 0));
128 }
129 
TEST(LoadedArscTest,LoadSharedLibrary)130 TEST(LoadedArscTest, LoadSharedLibrary) {
131   std::string contents;
132   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/lib_one/lib_one.apk", "resources.arsc",
133                                       &contents));
134 
135   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
136                                                                    contents.length());
137   ASSERT_THAT(loaded_arsc, NotNull());
138 
139   const auto& packages = loaded_arsc->GetPackages();
140   ASSERT_THAT(packages, SizeIs(1u));
141   EXPECT_TRUE(packages[0]->IsDynamic());
142   EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.lib_one"));
143   EXPECT_THAT(packages[0]->GetPackageId(), Eq(0));
144 
145   const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();
146 
147   // The library has no dependencies.
148   ASSERT_TRUE(dynamic_pkg_map.empty());
149 }
150 
TEST(LoadedArscTest,LoadAppLinkedAgainstSharedLibrary)151 TEST(LoadedArscTest, LoadAppLinkedAgainstSharedLibrary) {
152   std::string contents;
153   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/libclient/libclient.apk",
154                                       "resources.arsc", &contents));
155 
156   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
157                                                                    contents.length());
158   ASSERT_THAT(loaded_arsc, NotNull());
159 
160   const auto& packages = loaded_arsc->GetPackages();
161   ASSERT_THAT(packages, SizeIs(1u));
162   EXPECT_FALSE(packages[0]->IsDynamic());
163   EXPECT_THAT(packages[0]->GetPackageName(), StrEq("com.android.libclient"));
164   EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));
165 
166   const auto& dynamic_pkg_map = packages[0]->GetDynamicPackageMap();
167 
168   // The library has two dependencies.
169   ASSERT_THAT(dynamic_pkg_map, SizeIs(2u));
170   EXPECT_THAT(dynamic_pkg_map[0].package_name, StrEq("com.android.lib_one"));
171   EXPECT_THAT(dynamic_pkg_map[0].package_id, Eq(0x02));
172 
173   EXPECT_THAT(dynamic_pkg_map[1].package_name, StrEq("com.android.lib_two"));
174   EXPECT_THAT(dynamic_pkg_map[1].package_id, Eq(0x03));
175 }
176 
TEST(LoadedArscTest,LoadAppAsSharedLibrary)177 TEST(LoadedArscTest, LoadAppAsSharedLibrary) {
178   std::string contents;
179   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/appaslib/appaslib.apk",
180                                       "resources.arsc", &contents));
181 
182   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
183                                                                    contents.length(),
184                                                                    nullptr /* loaded_idmap */,
185                                                                    PROPERTY_DYNAMIC);
186   ASSERT_THAT(loaded_arsc, NotNull());
187 
188   const auto& packages = loaded_arsc->GetPackages();
189   ASSERT_THAT(packages, SizeIs(1u));
190   EXPECT_TRUE(packages[0]->IsDynamic());
191   EXPECT_THAT(packages[0]->GetPackageId(), Eq(0x7f));
192 }
193 
TEST(LoadedArscTest,LoadFeatureSplit)194 TEST(LoadedArscTest, LoadFeatureSplit) {
195   std::string contents;
196   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/feature/feature.apk", "resources.arsc",
197                                       &contents));
198   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
199                                                                    contents.length());
200   ASSERT_THAT(loaded_arsc, NotNull());
201 
202   const LoadedPackage* package =
203       loaded_arsc->GetPackageById(get_package_id(basic::R::string::test3));
204   ASSERT_THAT(package, NotNull());
205 
206   uint8_t type_index = get_type_id(basic::R::string::test3) - 1;
207   uint8_t entry_index = get_entry_id(basic::R::string::test3);
208 
209   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
210   ASSERT_THAT(type_spec, NotNull());
211   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
212 
213   auto type_name16 = package->GetTypeStringPool()->stringAt(type_spec->type_spec->id - 1);
214   ASSERT_TRUE(type_name16.has_value());
215   EXPECT_THAT(util::Utf16ToUtf8(*type_name16), StrEq("string"));
216 
217   ASSERT_TRUE(LoadedPackage::GetEntry(type_spec->type_entries[0].type, entry_index).has_value());
218 }
219 
220 // AAPT(2) generates resource tables with chunks in a certain order. The rule is that
221 // a RES_TABLE_TYPE_TYPE with id `i` must always be preceded by a RES_TABLE_TYPE_SPEC_TYPE with
222 // id `i`. The RES_TABLE_TYPE_SPEC_TYPE does not need to be directly preceding, however.
223 //
224 // AAPT(2) generates something like:
225 //   RES_TABLE_TYPE_SPEC_TYPE id=1
226 //   RES_TABLE_TYPE_TYPE id=1
227 //   RES_TABLE_TYPE_SPEC_TYPE id=2
228 //   RES_TABLE_TYPE_TYPE id=2
229 //
230 // But the following is valid too:
231 //   RES_TABLE_TYPE_SPEC_TYPE id=1
232 //   RES_TABLE_TYPE_SPEC_TYPE id=2
233 //   RES_TABLE_TYPE_TYPE id=1
234 //   RES_TABLE_TYPE_TYPE id=2
235 //
TEST(LoadedArscTest,LoadOutOfOrderTypeSpecs)236 TEST(LoadedArscTest, LoadOutOfOrderTypeSpecs) {
237   std::string contents;
238   ASSERT_TRUE(
239       ReadFileFromZipToString(GetTestDataPath() + "/out_of_order_types/out_of_order_types.apk",
240                               "resources.arsc", &contents));
241 
242   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
243                                                                    contents.length());
244   ASSERT_THAT(loaded_arsc, NotNull());
245 
246   ASSERT_THAT(loaded_arsc->GetPackages(), SizeIs(1u));
247   const auto& package = loaded_arsc->GetPackages()[0];
248   ASSERT_THAT(package, NotNull());
249 
250   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(0);
251   ASSERT_THAT(type_spec, NotNull());
252   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
253 
254   type_spec = package->GetTypeSpecByTypeIndex(1);
255   ASSERT_THAT(type_spec, NotNull());
256   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
257 }
258 
TEST(LoadedArscTest,LoadOverlayable)259 TEST(LoadedArscTest, LoadOverlayable) {
260   std::string contents;
261   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
262                                       "resources.arsc", &contents));
263 
264   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
265                                                                    contents.length());
266 
267   ASSERT_THAT(loaded_arsc, NotNull());
268   const LoadedPackage* package = loaded_arsc->GetPackageById(
269       get_package_id(overlayable::R::string::not_overlayable));
270 
271   const OverlayableInfo* info = package->GetOverlayableInfo(
272       overlayable::R::string::not_overlayable);
273   ASSERT_THAT(info, IsNull());
274 
275   info = package->GetOverlayableInfo(overlayable::R::string::overlayable1);
276   ASSERT_THAT(info, NotNull());
277   EXPECT_THAT(info->name, Eq("OverlayableResources1"));
278   EXPECT_THAT(info->actor, Eq("overlay://theme"));
279   EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));
280 
281   info = package->GetOverlayableInfo(overlayable::R::string::overlayable2);
282   ASSERT_THAT(info, NotNull());
283   EXPECT_THAT(info->name, Eq("OverlayableResources1"));
284   EXPECT_THAT(info->actor, Eq("overlay://theme"));
285   EXPECT_THAT(info->policy_flags,
286               Eq(PolicyFlags::SYSTEM_PARTITION
287                  | PolicyFlags::PRODUCT_PARTITION));
288 
289   info = package->GetOverlayableInfo(overlayable::R::string::overlayable3);
290   ASSERT_THAT(info, NotNull());
291   EXPECT_THAT(info->name, Eq("OverlayableResources2"));
292   EXPECT_THAT(info->actor, Eq("overlay://com.android.overlayable"));
293   EXPECT_THAT(info->policy_flags,
294               Eq(PolicyFlags::VENDOR_PARTITION
295                  | PolicyFlags::PRODUCT_PARTITION));
296 
297   info = package->GetOverlayableInfo(overlayable::R::string::overlayable4);
298   EXPECT_THAT(info->name, Eq("OverlayableResources1"));
299   EXPECT_THAT(info->actor, Eq("overlay://theme"));
300   ASSERT_THAT(info, NotNull());
301   EXPECT_THAT(info->policy_flags, Eq(PolicyFlags::PUBLIC));
302 }
303 
TEST(LoadedArscTest,ResourceIdentifierIterator)304 TEST(LoadedArscTest, ResourceIdentifierIterator) {
305   std::string contents;
306   ASSERT_TRUE(
307       ReadFileFromZipToString(GetTestDataPath() + "/basic/basic.apk", "resources.arsc", &contents));
308 
309   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
310                                                                    contents.length());
311   ASSERT_NE(nullptr, loaded_arsc);
312 
313   const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
314   ASSERT_EQ(1u, packages.size());
315   ASSERT_EQ(std::string("com.android.basic"), packages[0]->GetPackageName());
316 
317   const auto& loaded_package = packages[0];
318   auto iter = loaded_package->begin();
319   auto end = loaded_package->end();
320 
321   ASSERT_NE(end, iter);
322   ASSERT_EQ(0x7f010000u, *iter++);
323   ASSERT_EQ(0x7f010001u, *iter++);
324   ASSERT_EQ(0x7f020000u, *iter++);
325   ASSERT_EQ(0x7f020001u, *iter++);
326   ASSERT_EQ(0x7f030000u, *iter++);
327   ASSERT_EQ(0x7f030001u, *iter++);
328   ASSERT_EQ(0x7f030002u, *iter++);  // note: string without default, excluded by aapt2 dump
329   ASSERT_EQ(0x7f040000u, *iter++);
330   ASSERT_EQ(0x7f040001u, *iter++);
331   ASSERT_EQ(0x7f040002u, *iter++);
332   ASSERT_EQ(0x7f040003u, *iter++);
333   ASSERT_EQ(0x7f040004u, *iter++);
334   ASSERT_EQ(0x7f040005u, *iter++);
335   ASSERT_EQ(0x7f040006u, *iter++);
336   ASSERT_EQ(0x7f040007u, *iter++);
337   ASSERT_EQ(0x7f040008u, *iter++);
338   ASSERT_EQ(0x7f040009u, *iter++);
339   ASSERT_EQ(0x7f04000au, *iter++);
340   ASSERT_EQ(0x7f04000bu, *iter++);
341   ASSERT_EQ(0x7f04000cu, *iter++);
342   ASSERT_EQ(0x7f04000du, *iter++);
343   ASSERT_EQ(0x7f050000u, *iter++);
344   ASSERT_EQ(0x7f050001u, *iter++);
345   ASSERT_EQ(0x7f060000u, *iter++);
346   ASSERT_EQ(0x7f070000u, *iter++);
347   ASSERT_EQ(0x7f070001u, *iter++);
348   ASSERT_EQ(0x7f070002u, *iter++);
349   ASSERT_EQ(0x7f070003u, *iter++);
350   ASSERT_EQ(end, iter);
351 }
352 
TEST(LoadedArscTest,GetOverlayableMap)353 TEST(LoadedArscTest, GetOverlayableMap) {
354   std::string contents;
355   ASSERT_TRUE(ReadFileFromZipToString(GetTestDataPath() + "/overlayable/overlayable.apk",
356                                       "resources.arsc", &contents));
357 
358   std::unique_ptr<const LoadedArsc> loaded_arsc = LoadedArsc::Load(contents.data(),
359                                                                    contents.length());
360   ASSERT_NE(nullptr, loaded_arsc);
361 
362   const std::vector<std::unique_ptr<const LoadedPackage>>& packages = loaded_arsc->GetPackages();
363   ASSERT_EQ(1u, packages.size());
364   ASSERT_EQ(std::string("com.android.overlayable"), packages[0]->GetPackageName());
365 
366   const auto map = packages[0]->GetOverlayableMap();
367   ASSERT_EQ(3, map.size());
368   ASSERT_EQ(map.at("OverlayableResources1"), "overlay://theme");
369   ASSERT_EQ(map.at("OverlayableResources2"), "overlay://com.android.overlayable");
370   ASSERT_EQ(map.at("OverlayableResources3"), "");
371 }
372 
TEST(LoadedArscTest,LoadCustomLoader)373 TEST(LoadedArscTest, LoadCustomLoader) {
374   auto asset = AssetsProvider::CreateAssetFromFile(GetTestDataPath() + "/loader/resources.arsc");
375   ASSERT_THAT(asset, NotNull());
376 
377   const StringPiece data(
378       reinterpret_cast<const char*>(asset->getBuffer(true /*wordAligned*/)),
379       asset->getLength());
380 
381   std::unique_ptr<const LoadedArsc> loaded_arsc =
382       LoadedArsc::Load(data.data(), data.length(), nullptr, PROPERTY_LOADER);
383   ASSERT_THAT(loaded_arsc, NotNull());
384 
385   const LoadedPackage* package =
386       loaded_arsc->GetPackageById(get_package_id(overlayable::R::string::overlayable11));
387   ASSERT_THAT(package, NotNull());
388   EXPECT_THAT(package->GetPackageName(), StrEq("com.android.loader"));
389   EXPECT_THAT(package->GetPackageId(), Eq(0x7f));
390 
391   const uint8_t type_index = get_type_id(overlayable::R::string::overlayable11) - 1;
392   const uint16_t entry_index = get_entry_id(overlayable::R::string::overlayable11);
393 
394   const TypeSpec* type_spec = package->GetTypeSpecByTypeIndex(type_index);
395   ASSERT_THAT(type_spec, NotNull());
396   ASSERT_THAT(type_spec->type_entries.size(), Ge(1u));
397 
398   auto type = type_spec->type_entries[0];
399   ASSERT_TRUE(LoadedPackage::GetEntry(type.type, entry_index).has_value());
400 }
401 
402 // structs with size fields (like Res_value, ResTable_entry) should be
403 // backwards and forwards compatible (aka checking the size field against
404 // sizeof(Res_value) might not be backwards compatible.
405 // TEST(LoadedArscTest, LoadingShouldBeForwardsAndBackwardsCompatible) { ASSERT_TRUE(false); }
406 
407 }  // namespace android
408