1 /*
2 * Copyright (C) 2014 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 <gtest/gtest.h>
18
19 #include <dlfcn.h>
20 #include <elf.h>
21 #include <errno.h>
22 #include <fcntl.h>
23 #include <inttypes.h>
24 #include <stdio.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <android/dlext.h>
28 #include <sys/mman.h>
29 #include <sys/types.h>
30 #include <sys/wait.h>
31
32 #include <pagemap/pagemap.h>
33 #include <ziparchive/zip_archive.h>
34
35 #include "TemporaryFile.h"
36 #include "utils.h"
37 #include "dlext_private.h"
38
39 #define ASSERT_DL_NOTNULL(ptr) \
40 ASSERT_TRUE(ptr != nullptr) << "dlerror: " << dlerror()
41
42 #define ASSERT_DL_ZERO(i) \
43 ASSERT_EQ(0, i) << "dlerror: " << dlerror()
44
45 #define ASSERT_NOERROR(i) \
46 ASSERT_NE(-1, i) << "errno: " << strerror(errno)
47
48 #define ASSERT_SUBSTR(needle, haystack) \
49 ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack)
50
51
52 typedef int (*fn)(void);
53 #define LIBNAME "libdlext_test.so"
54 #define LIBNAME_NORELRO "libdlext_test_norelro.so"
55 #define LIBSIZE 1024*1024 // how much address space to reserve for it
56
57 #if defined(__LP64__)
58 #define NATIVE_TESTS_PATH "/nativetest64"
59 #else
60 #define NATIVE_TESTS_PATH "/nativetest"
61 #endif
62
63 #define LIBPATH NATIVE_TESTS_PATH "/libdlext_test_fd/libdlext_test_fd.so"
64 #define LIBZIPPATH NATIVE_TESTS_PATH "/libdlext_test_zip/libdlext_test_zip_zipaligned.zip"
65 #define LIBZIPPATH_WITH_RUNPATH NATIVE_TESTS_PATH "/libdlext_test_runpath_zip/libdlext_test_runpath_zip_zipaligned.zip"
66 #define LIBZIP_SIMPLE_ZIP "libdir/libatest_simple_zip.so"
67
68 class DlExtTest : public ::testing::Test {
69 protected:
SetUp()70 virtual void SetUp() {
71 handle_ = nullptr;
72 // verify that we don't have the library loaded already
73 void* h = dlopen(LIBNAME, RTLD_NOW | RTLD_NOLOAD);
74 ASSERT_TRUE(h == nullptr);
75 h = dlopen(LIBNAME_NORELRO, RTLD_NOW | RTLD_NOLOAD);
76 ASSERT_TRUE(h == nullptr);
77 // call dlerror() to swallow the error, and check it was the one we wanted
78 ASSERT_STREQ("dlopen failed: library \"" LIBNAME_NORELRO "\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror());
79 }
80
TearDown()81 virtual void TearDown() {
82 if (handle_ != nullptr) {
83 ASSERT_DL_ZERO(dlclose(handle_));
84 }
85 }
86
87 void* handle_;
88 };
89
TEST_F(DlExtTest,ExtInfoNull)90 TEST_F(DlExtTest, ExtInfoNull) {
91 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, nullptr);
92 ASSERT_DL_NOTNULL(handle_);
93 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
94 ASSERT_DL_NOTNULL(f);
95 EXPECT_EQ(4, f());
96 }
97
TEST_F(DlExtTest,ExtInfoNoFlags)98 TEST_F(DlExtTest, ExtInfoNoFlags) {
99 android_dlextinfo extinfo;
100 extinfo.flags = 0;
101 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
102 ASSERT_DL_NOTNULL(handle_);
103 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
104 ASSERT_DL_NOTNULL(f);
105 EXPECT_EQ(4, f());
106 }
107
TEST_F(DlExtTest,ExtInfoUseFd)108 TEST_F(DlExtTest, ExtInfoUseFd) {
109 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBPATH;
110
111 android_dlextinfo extinfo;
112 extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD;
113 extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
114 ASSERT_TRUE(extinfo.library_fd != -1);
115 handle_ = android_dlopen_ext(lib_path.c_str(), RTLD_NOW, &extinfo);
116 ASSERT_DL_NOTNULL(handle_);
117 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
118 ASSERT_DL_NOTNULL(f);
119 EXPECT_EQ(4, f());
120
121 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
122 ASSERT_DL_NOTNULL(taxicab_number);
123 EXPECT_EQ(1729U, *taxicab_number);
124 }
125
TEST_F(DlExtTest,ExtInfoUseFdWithOffset)126 TEST_F(DlExtTest, ExtInfoUseFdWithOffset) {
127 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
128
129 android_dlextinfo extinfo;
130 extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
131 extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
132
133 // Find the offset of the shared library in the zip.
134 ZipArchiveHandle handle;
135 ASSERT_EQ(0, OpenArchive(lib_path.c_str(), &handle));
136 ZipEntry zip_entry;
137 ZipString zip_name;
138 zip_name.name = reinterpret_cast<const uint8_t*>(LIBZIP_SIMPLE_ZIP);
139 zip_name.name_length = sizeof(LIBZIP_SIMPLE_ZIP) - 1;
140 ASSERT_EQ(0, FindEntry(handle, zip_name, &zip_entry));
141 extinfo.library_fd_offset = zip_entry.offset;
142 CloseArchive(handle);
143
144 handle_ = android_dlopen_ext(lib_path.c_str(), RTLD_NOW, &extinfo);
145 ASSERT_DL_NOTNULL(handle_);
146
147 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
148 ASSERT_DL_NOTNULL(taxicab_number);
149 EXPECT_EQ(1729U, *taxicab_number);
150 }
151
TEST_F(DlExtTest,ExtInfoUseFdWithInvalidOffset)152 TEST_F(DlExtTest, ExtInfoUseFdWithInvalidOffset) {
153 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
154 // lib_path is relative when $ANDROID_DATA is relative
155 char lib_realpath_buf[PATH_MAX];
156 ASSERT_TRUE(realpath(lib_path.c_str(), lib_realpath_buf) == lib_realpath_buf);
157 const std::string lib_realpath = std::string(lib_realpath_buf);
158
159 android_dlextinfo extinfo;
160 extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD | ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
161 extinfo.library_fd = TEMP_FAILURE_RETRY(open(lib_path.c_str(), O_RDONLY | O_CLOEXEC));
162 extinfo.library_fd_offset = 17;
163
164 handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
165 ASSERT_TRUE(handle_ == nullptr);
166 ASSERT_STREQ("dlopen failed: file offset for the library \"libname_placeholder\" is not page-aligned: 17", dlerror());
167
168 // Test an address above 2^44, for http://b/18178121 .
169 extinfo.library_fd_offset = (5LL<<48) + PAGE_SIZE;
170 handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
171 ASSERT_TRUE(handle_ == nullptr);
172 ASSERT_SUBSTR("dlopen failed: file offset for the library \"libname_placeholder\" >= file size", dlerror());
173
174 extinfo.library_fd_offset = 0LL - PAGE_SIZE;
175 handle_ = android_dlopen_ext("libname_placeholder", RTLD_NOW, &extinfo);
176 ASSERT_TRUE(handle_ == nullptr);
177 ASSERT_SUBSTR("dlopen failed: file offset for the library \"libname_placeholder\" is negative", dlerror());
178
179 extinfo.library_fd_offset = 0;
180 handle_ = android_dlopen_ext("libname_ignored", RTLD_NOW, &extinfo);
181 ASSERT_TRUE(handle_ == nullptr);
182 ASSERT_EQ("dlopen failed: \"" + lib_realpath + "\" has bad ELF magic", dlerror());
183
184 // Check if dlsym works after unsuccessful dlopen().
185 // Supply non-exiting one to make linker visit every soinfo.
186 void* sym = dlsym(RTLD_DEFAULT, "this_symbol_does_not_exist___");
187 ASSERT_TRUE(sym == nullptr);
188
189 close(extinfo.library_fd);
190 }
191
TEST_F(DlExtTest,ExtInfoUseOffsetWithoutFd)192 TEST_F(DlExtTest, ExtInfoUseOffsetWithoutFd) {
193 android_dlextinfo extinfo;
194 extinfo.flags = ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET;
195 // This offset will not be used, so it doesn't matter.
196 extinfo.library_fd_offset = 0;
197
198 handle_ = android_dlopen_ext("/some/lib/that/does_not_exist", RTLD_NOW, &extinfo);
199 ASSERT_TRUE(handle_ == nullptr);
200 ASSERT_STREQ("dlopen failed: invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without ANDROID_DLEXT_USE_LIBRARY_FD): 0x20", dlerror());
201 }
202
TEST(dlext,android_dlopen_ext_force_load_smoke)203 TEST(dlext, android_dlopen_ext_force_load_smoke) {
204 // 1. Open actual file
205 void* handle = dlopen("libdlext_test.so", RTLD_NOW);
206 ASSERT_DL_NOTNULL(handle);
207 // 2. Open link with force_load flag set
208 android_dlextinfo extinfo;
209 extinfo.flags = ANDROID_DLEXT_FORCE_LOAD;
210 void* handle2 = android_dlopen_ext("libdlext_test_v2.so", RTLD_NOW, &extinfo);
211 ASSERT_DL_NOTNULL(handle2);
212 ASSERT_TRUE(handle != handle2);
213
214 dlclose(handle2);
215 dlclose(handle);
216 }
217
TEST(dlext,android_dlopen_ext_force_load_soname_exception)218 TEST(dlext, android_dlopen_ext_force_load_soname_exception) {
219 // Check if soname lookup still returns already loaded library
220 // when ANDROID_DLEXT_FORCE_LOAD flag is specified.
221 void* handle = dlopen("libdlext_test_v2.so", RTLD_NOW);
222 ASSERT_DL_NOTNULL(handle);
223
224 android_dlextinfo extinfo;
225 extinfo.flags = ANDROID_DLEXT_FORCE_LOAD;
226
227 // Note that 'libdlext_test.so' is dt_soname for libdlext_test_v2.so
228 void* handle2 = android_dlopen_ext("libdlext_test.so", RTLD_NOW, &extinfo);
229
230 ASSERT_DL_NOTNULL(handle2);
231 ASSERT_TRUE(handle == handle2);
232
233 dlclose(handle2);
234 dlclose(handle);
235 }
236
TEST(dlfcn,dlopen_from_zip_absolute_path)237 TEST(dlfcn, dlopen_from_zip_absolute_path) {
238 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH;
239
240 void* handle = dlopen((lib_path + "!/libdir/libatest_simple_zip.so").c_str(), RTLD_NOW);
241 ASSERT_TRUE(handle != nullptr) << dlerror();
242
243 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_testlib_taxicab_number"));
244 ASSERT_DL_NOTNULL(taxicab_number);
245 EXPECT_EQ(1729U, *taxicab_number);
246
247 dlclose(handle);
248 }
249
TEST(dlfcn,dlopen_from_zip_with_dt_runpath)250 TEST(dlfcn, dlopen_from_zip_with_dt_runpath) {
251 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH_WITH_RUNPATH;
252
253 void* handle = dlopen((lib_path + "!/libdir/libtest_dt_runpath_d_zip.so").c_str(), RTLD_NOW);
254
255 ASSERT_TRUE(handle != nullptr) << dlerror();
256
257 typedef void *(* dlopen_b_fn)();
258 dlopen_b_fn fn = (dlopen_b_fn)dlsym(handle, "dlopen_b");
259 ASSERT_TRUE(fn != nullptr) << dlerror();
260
261 void *p = fn();
262 ASSERT_TRUE(p != nullptr) << dlerror();
263
264 dlclose(p);
265 dlclose(handle);
266 }
267
TEST(dlfcn,dlopen_from_zip_ld_library_path)268 TEST(dlfcn, dlopen_from_zip_ld_library_path) {
269 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + LIBZIPPATH + "!/libdir";
270
271 typedef void (*fn_t)(const char*);
272 fn_t android_update_LD_LIBRARY_PATH =
273 reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "android_update_LD_LIBRARY_PATH"));
274
275 ASSERT_TRUE(android_update_LD_LIBRARY_PATH != nullptr) << dlerror();
276
277 void* handle = dlopen("libdlext_test_zip.so", RTLD_NOW);
278 ASSERT_TRUE(handle == nullptr);
279
280 android_update_LD_LIBRARY_PATH(lib_path.c_str());
281
282 handle = dlopen("libdlext_test_zip.so", RTLD_NOW);
283 ASSERT_TRUE(handle != nullptr) << dlerror();
284
285 int (*fn)(void);
286 fn = reinterpret_cast<int (*)(void)>(dlsym(handle, "getRandomNumber"));
287 ASSERT_TRUE(fn != nullptr);
288 EXPECT_EQ(4, fn());
289
290 uint32_t* taxicab_number =
291 reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_testlib_taxicab_number"));
292 ASSERT_DL_NOTNULL(taxicab_number);
293 EXPECT_EQ(1729U, *taxicab_number);
294
295 dlclose(handle);
296 }
297
298
TEST_F(DlExtTest,Reserved)299 TEST_F(DlExtTest, Reserved) {
300 void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
301 ASSERT_TRUE(start != MAP_FAILED);
302 android_dlextinfo extinfo;
303 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
304 extinfo.reserved_addr = start;
305 extinfo.reserved_size = LIBSIZE;
306 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
307 ASSERT_DL_NOTNULL(handle_);
308 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
309 ASSERT_DL_NOTNULL(f);
310 EXPECT_GE(reinterpret_cast<void*>(f), start);
311 EXPECT_LT(reinterpret_cast<void*>(f),
312 reinterpret_cast<char*>(start) + LIBSIZE);
313 EXPECT_EQ(4, f());
314
315 // Check that after dlclose reserved address space is unmapped (and can be reused)
316 dlclose(handle_);
317 handle_ = nullptr;
318
319 void* new_start = mmap(start, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
320 ASSERT_NE(start, new_start) << "dlclose unmapped reserved space";
321 }
322
TEST_F(DlExtTest,ReservedTooSmall)323 TEST_F(DlExtTest, ReservedTooSmall) {
324 void* start = mmap(nullptr, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
325 ASSERT_TRUE(start != MAP_FAILED);
326 android_dlextinfo extinfo;
327 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
328 extinfo.reserved_addr = start;
329 extinfo.reserved_size = PAGE_SIZE;
330 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
331 EXPECT_EQ(nullptr, handle_);
332 }
333
TEST_F(DlExtTest,ReservedHint)334 TEST_F(DlExtTest, ReservedHint) {
335 void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
336 ASSERT_TRUE(start != MAP_FAILED);
337 android_dlextinfo extinfo;
338 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
339 extinfo.reserved_addr = start;
340 extinfo.reserved_size = LIBSIZE;
341 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
342 ASSERT_DL_NOTNULL(handle_);
343 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
344 ASSERT_DL_NOTNULL(f);
345 EXPECT_GE(reinterpret_cast<void*>(f), start);
346 EXPECT_LT(reinterpret_cast<void*>(f),
347 reinterpret_cast<char*>(start) + LIBSIZE);
348 EXPECT_EQ(4, f());
349 }
350
TEST_F(DlExtTest,ReservedHintTooSmall)351 TEST_F(DlExtTest, ReservedHintTooSmall) {
352 void* start = mmap(nullptr, PAGE_SIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
353 ASSERT_TRUE(start != MAP_FAILED);
354 android_dlextinfo extinfo;
355 extinfo.flags = ANDROID_DLEXT_RESERVED_ADDRESS_HINT;
356 extinfo.reserved_addr = start;
357 extinfo.reserved_size = PAGE_SIZE;
358 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
359 ASSERT_DL_NOTNULL(handle_);
360 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
361 ASSERT_DL_NOTNULL(f);
362 EXPECT_TRUE(reinterpret_cast<void*>(f) < start ||
363 (reinterpret_cast<void*>(f) >=
364 reinterpret_cast<char*>(start) + PAGE_SIZE));
365 EXPECT_EQ(4, f());
366 }
367
TEST_F(DlExtTest,LoadAtFixedAddress)368 TEST_F(DlExtTest, LoadAtFixedAddress) {
369 void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
370 ASSERT_TRUE(start != MAP_FAILED);
371 munmap(start, LIBSIZE);
372
373 android_dlextinfo extinfo;
374 extinfo.flags = ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS;
375 extinfo.reserved_addr = start;
376
377 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
378 ASSERT_DL_NOTNULL(handle_);
379 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
380 ASSERT_DL_NOTNULL(f);
381 EXPECT_GE(reinterpret_cast<void*>(f), start);
382 EXPECT_LT(reinterpret_cast<void*>(f), reinterpret_cast<char*>(start) + LIBSIZE);
383
384 EXPECT_EQ(4, f());
385 dlclose(handle_);
386 handle_ = nullptr;
387
388 // Check that dlclose unmapped the file
389 void* addr = mmap(start, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
390 ASSERT_EQ(start, addr) << "dlclose did not unmap the memory";
391 }
392
TEST_F(DlExtTest,LoadAtFixedAddressTooSmall)393 TEST_F(DlExtTest, LoadAtFixedAddressTooSmall) {
394 void* start = mmap(nullptr, LIBSIZE + PAGE_SIZE, PROT_NONE,
395 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
396 ASSERT_TRUE(start != MAP_FAILED);
397 munmap(start, LIBSIZE + PAGE_SIZE);
398 void* new_addr = mmap(reinterpret_cast<uint8_t*>(start) + PAGE_SIZE, LIBSIZE, PROT_NONE,
399 MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
400 ASSERT_TRUE(new_addr != MAP_FAILED);
401
402 android_dlextinfo extinfo;
403 extinfo.flags = ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS;
404 extinfo.reserved_addr = start;
405
406 handle_ = android_dlopen_ext(LIBNAME, RTLD_NOW, &extinfo);
407 ASSERT_TRUE(handle_ == nullptr);
408 }
409
410 class DlExtRelroSharingTest : public DlExtTest {
411 protected:
SetUp()412 virtual void SetUp() {
413 DlExtTest::SetUp();
414 void* start = mmap(nullptr, LIBSIZE, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
415 ASSERT_TRUE(start != MAP_FAILED);
416 extinfo_.flags = ANDROID_DLEXT_RESERVED_ADDRESS;
417 extinfo_.reserved_addr = start;
418 extinfo_.reserved_size = LIBSIZE;
419 extinfo_.relro_fd = -1;
420 }
421
TearDown()422 virtual void TearDown() {
423 DlExtTest::TearDown();
424 }
425
CreateRelroFile(const char * lib,const char * relro_file)426 void CreateRelroFile(const char* lib, const char* relro_file) {
427 int relro_fd = open(relro_file, O_RDWR | O_TRUNC);
428 ASSERT_NOERROR(relro_fd);
429
430 pid_t pid = fork();
431 if (pid == 0) {
432 // child process
433 extinfo_.flags |= ANDROID_DLEXT_WRITE_RELRO;
434 extinfo_.relro_fd = relro_fd;
435 void* handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
436 if (handle == nullptr) {
437 fprintf(stderr, "in child: %s\n", dlerror());
438 exit(1);
439 }
440 exit(0);
441 }
442
443 // continuing in parent
444 ASSERT_NOERROR(close(relro_fd));
445 ASSERT_NOERROR(pid);
446 AssertChildExited(pid, 0);
447
448 // reopen file for reading so it can be used
449 relro_fd = open(relro_file, O_RDONLY);
450 ASSERT_NOERROR(relro_fd);
451 extinfo_.flags |= ANDROID_DLEXT_USE_RELRO;
452 extinfo_.relro_fd = relro_fd;
453 }
454
TryUsingRelro(const char * lib)455 void TryUsingRelro(const char* lib) {
456 handle_ = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
457 ASSERT_DL_NOTNULL(handle_);
458 fn f = reinterpret_cast<fn>(dlsym(handle_, "getRandomNumber"));
459 ASSERT_DL_NOTNULL(f);
460 EXPECT_EQ(4, f());
461
462 uint32_t* taxicab_number =
463 reinterpret_cast<uint32_t*>(dlsym(handle_, "dlopen_testlib_taxicab_number"));
464 ASSERT_DL_NOTNULL(taxicab_number);
465 EXPECT_EQ(1729U, *taxicab_number);
466 }
467
468 void SpawnChildrenAndMeasurePss(const char* lib, bool share_relro, size_t* pss_out);
469
470 android_dlextinfo extinfo_;
471 };
472
TEST_F(DlExtRelroSharingTest,ChildWritesGoodData)473 TEST_F(DlExtRelroSharingTest, ChildWritesGoodData) {
474 TemporaryFile tf; // Use tf to get an unique filename.
475 ASSERT_NOERROR(close(tf.fd));
476
477 ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME, tf.filename));
478 ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME));
479
480 // Use destructor of tf to close and unlink the file.
481 tf.fd = extinfo_.relro_fd;
482 }
483
TEST_F(DlExtRelroSharingTest,ChildWritesNoRelro)484 TEST_F(DlExtRelroSharingTest, ChildWritesNoRelro) {
485 TemporaryFile tf; // // Use tf to get an unique filename.
486 ASSERT_NOERROR(close(tf.fd));
487
488 ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME_NORELRO, tf.filename));
489 ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME_NORELRO));
490
491 // Use destructor of tf to close and unlink the file.
492 tf.fd = extinfo_.relro_fd;
493 }
494
TEST_F(DlExtRelroSharingTest,RelroFileEmpty)495 TEST_F(DlExtRelroSharingTest, RelroFileEmpty) {
496 ASSERT_NO_FATAL_FAILURE(TryUsingRelro(LIBNAME));
497 }
498
TEST_F(DlExtRelroSharingTest,VerifyMemorySaving)499 TEST_F(DlExtRelroSharingTest, VerifyMemorySaving) {
500 if (geteuid() != 0) {
501 GTEST_LOG_(INFO) << "This test must be run as root.\n";
502 return;
503 }
504
505 TemporaryFile tf; // Use tf to get an unique filename.
506 ASSERT_NOERROR(close(tf.fd));
507
508 ASSERT_NO_FATAL_FAILURE(CreateRelroFile(LIBNAME, tf.filename));
509
510 int pipefd[2];
511 ASSERT_NOERROR(pipe(pipefd));
512
513 size_t without_sharing, with_sharing;
514 ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, false, &without_sharing));
515 ASSERT_NO_FATAL_FAILURE(SpawnChildrenAndMeasurePss(LIBNAME, true, &with_sharing));
516
517 // We expect the sharing to save at least 10% of the total PSS. In practice
518 // it saves 40%+ for this test.
519 size_t expected_size = without_sharing - (without_sharing/10);
520 EXPECT_LT(with_sharing, expected_size);
521
522 // Use destructor of tf to close and unlink the file.
523 tf.fd = extinfo_.relro_fd;
524 }
525
getPss(pid_t pid,size_t * pss_out)526 void getPss(pid_t pid, size_t* pss_out) {
527 pm_kernel_t* kernel;
528 ASSERT_EQ(0, pm_kernel_create(&kernel));
529
530 pm_process_t* process;
531 ASSERT_EQ(0, pm_process_create(kernel, pid, &process));
532
533 pm_map_t** maps;
534 size_t num_maps;
535 ASSERT_EQ(0, pm_process_maps(process, &maps, &num_maps));
536
537 size_t total_pss = 0;
538 for (size_t i = 0; i < num_maps; i++) {
539 pm_memusage_t usage;
540 ASSERT_EQ(0, pm_map_usage(maps[i], &usage));
541 total_pss += usage.pss;
542 }
543 *pss_out = total_pss;
544
545 free(maps);
546 pm_process_destroy(process);
547 pm_kernel_destroy(kernel);
548 }
549
SpawnChildrenAndMeasurePss(const char * lib,bool share_relro,size_t * pss_out)550 void DlExtRelroSharingTest::SpawnChildrenAndMeasurePss(const char* lib, bool share_relro,
551 size_t* pss_out) {
552 const int CHILDREN = 20;
553
554 // Create children
555 pid_t child_pids[CHILDREN];
556 int childpipe[CHILDREN];
557 for (int i=0; i<CHILDREN; ++i) {
558 char read_buf;
559 int child_done_pipe[2], parent_done_pipe[2];
560 ASSERT_NOERROR(pipe(child_done_pipe));
561 ASSERT_NOERROR(pipe(parent_done_pipe));
562
563 pid_t child = fork();
564 if (child == 0) {
565 // close the 'wrong' ends of the pipes in the child
566 close(child_done_pipe[0]);
567 close(parent_done_pipe[1]);
568
569 // open the library
570 void* handle;
571 if (share_relro) {
572 handle = android_dlopen_ext(lib, RTLD_NOW, &extinfo_);
573 } else {
574 handle = dlopen(lib, RTLD_NOW);
575 }
576 if (handle == nullptr) {
577 fprintf(stderr, "in child: %s\n", dlerror());
578 exit(1);
579 }
580
581 // close write end of child_done_pipe to signal the parent that we're done.
582 close(child_done_pipe[1]);
583
584 // wait for the parent to close parent_done_pipe, then exit
585 read(parent_done_pipe[0], &read_buf, 1);
586 exit(0);
587 }
588
589 ASSERT_NOERROR(child);
590
591 // close the 'wrong' ends of the pipes in the parent
592 close(child_done_pipe[1]);
593 close(parent_done_pipe[0]);
594
595 // wait for the child to be done
596 read(child_done_pipe[0], &read_buf, 1);
597 close(child_done_pipe[0]);
598
599 // save the child's pid and the parent_done_pipe
600 child_pids[i] = child;
601 childpipe[i] = parent_done_pipe[1];
602 }
603
604 // Sum the PSS of all the children
605 size_t total_pss = 0;
606 for (int i=0; i<CHILDREN; ++i) {
607 size_t child_pss;
608 ASSERT_NO_FATAL_FAILURE(getPss(child_pids[i], &child_pss));
609 total_pss += child_pss;
610 }
611 *pss_out = total_pss;
612
613 // Close pipes and wait for children to exit
614 for (int i=0; i<CHILDREN; ++i) {
615 ASSERT_NOERROR(close(childpipe[i]));
616 }
617 for (int i = 0; i < CHILDREN; ++i) {
618 AssertChildExited(child_pids[i], 0);
619 }
620 }
621
622 // Testing namespaces
623 static const char* g_public_lib = "libnstest_public.so";
624
TEST(dlext,ns_smoke)625 TEST(dlext, ns_smoke) {
626 static const char* root_lib = "libnstest_root.so";
627 std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
628
629 ASSERT_FALSE(android_init_namespaces(path.c_str(), nullptr));
630 ASSERT_STREQ("android_init_namespaces failed: error initializing public namespace: "
631 "a library with soname \"libnstest_public.so\" was not found in the "
632 "default namespace",
633 dlerror());
634
635 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
636
637 const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
638 void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
639 ASSERT_TRUE(handle_public != nullptr) << dlerror();
640
641 ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
642
643 // Check that libraries added to public namespace are NODELETE
644 dlclose(handle_public);
645 handle_public = dlopen((lib_path + "/public_namespace_libs/" + g_public_lib).c_str(),
646 RTLD_NOW | RTLD_NOLOAD);
647
648 ASSERT_TRUE(handle_public != nullptr) << dlerror();
649
650 android_namespace_t* ns1 =
651 android_create_namespace("private", nullptr,
652 (lib_path + "/private_namespace_libs").c_str(),
653 ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
654 ASSERT_TRUE(ns1 != nullptr) << dlerror();
655
656 android_namespace_t* ns2 =
657 android_create_namespace("private_isolated", nullptr,
658 (lib_path + "/private_namespace_libs").c_str(),
659 ANDROID_NAMESPACE_TYPE_ISOLATED, nullptr, nullptr);
660 ASSERT_TRUE(ns2 != nullptr) << dlerror();
661
662 // This should not have affect search path for default namespace:
663 ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
664 void* handle = dlopen(g_public_lib, RTLD_NOW);
665 ASSERT_TRUE(handle != nullptr) << dlerror();
666 dlclose(handle);
667
668 android_dlextinfo extinfo;
669 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
670 extinfo.library_namespace = ns1;
671
672 void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
673 ASSERT_TRUE(handle1 != nullptr) << dlerror();
674
675 extinfo.library_namespace = ns2;
676 void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
677 ASSERT_TRUE(handle2 != nullptr) << dlerror();
678
679 ASSERT_TRUE(handle1 != handle2);
680
681 // dlopen for a public library using an absolute path should work for isolated namespaces
682 extinfo.library_namespace = ns2;
683 handle = android_dlopen_ext(lib_public_path.c_str(), RTLD_NOW, &extinfo);
684 ASSERT_TRUE(handle != nullptr) << dlerror();
685 ASSERT_TRUE(handle == handle_public);
686
687 dlclose(handle);
688
689 typedef const char* (*fn_t)();
690
691 fn_t ns_get_local_string1 = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
692 ASSERT_TRUE(ns_get_local_string1 != nullptr) << dlerror();
693 fn_t ns_get_local_string2 = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_local_string"));
694 ASSERT_TRUE(ns_get_local_string2 != nullptr) << dlerror();
695
696 EXPECT_STREQ("This string is local to root library", ns_get_local_string1());
697 EXPECT_STREQ("This string is local to root library", ns_get_local_string2());
698
699 ASSERT_TRUE(ns_get_local_string1() != ns_get_local_string2());
700
701 fn_t ns_get_private_extern_string1 =
702 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
703 ASSERT_TRUE(ns_get_private_extern_string1 != nullptr) << dlerror();
704 fn_t ns_get_private_extern_string2 =
705 reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_private_extern_string"));
706 ASSERT_TRUE(ns_get_private_extern_string2 != nullptr) << dlerror();
707
708 EXPECT_STREQ("This string is from private namespace", ns_get_private_extern_string1());
709 EXPECT_STREQ("This string is from private namespace", ns_get_private_extern_string2());
710
711 ASSERT_TRUE(ns_get_private_extern_string1() != ns_get_private_extern_string2());
712
713 fn_t ns_get_public_extern_string1 =
714 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
715 ASSERT_TRUE(ns_get_public_extern_string1 != nullptr) << dlerror();
716 fn_t ns_get_public_extern_string2 =
717 reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_public_extern_string"));
718 ASSERT_TRUE(ns_get_public_extern_string2 != nullptr) << dlerror();
719
720 EXPECT_STREQ("This string is from public namespace", ns_get_public_extern_string1());
721 ASSERT_TRUE(ns_get_public_extern_string1() == ns_get_public_extern_string2());
722
723 // and now check that dlopen() does the right thing in terms of preserving namespace
724 fn_t ns_get_dlopened_string1 = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
725 ASSERT_TRUE(ns_get_dlopened_string1 != nullptr) << dlerror();
726 fn_t ns_get_dlopened_string2 = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_dlopened_string"));
727 ASSERT_TRUE(ns_get_dlopened_string2 != nullptr) << dlerror();
728
729 EXPECT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string1());
730 EXPECT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string2());
731
732 ASSERT_TRUE(ns_get_dlopened_string1() != ns_get_dlopened_string2());
733
734 dlclose(handle1);
735
736 // Check if handle2 is still alive (and well)
737 ASSERT_STREQ("This string is local to root library", ns_get_local_string2());
738 ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string2());
739 ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string2());
740 ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string2());
741
742 dlclose(handle2);
743 }
744
TEST(dlext,ns_isolated)745 TEST(dlext, ns_isolated) {
746 static const char* root_lib = "libnstest_root_not_isolated.so";
747 std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
748
749 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
750 const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
751 void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
752 ASSERT_TRUE(handle_public != nullptr) << dlerror();
753
754 android_set_application_target_sdk_version(42U); // something > 23
755
756 ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
757
758 android_namespace_t* ns_not_isolated =
759 android_create_namespace("private", nullptr,
760 (lib_path + "/private_namespace_libs").c_str(),
761 ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
762 ASSERT_TRUE(ns_not_isolated != nullptr) << dlerror();
763
764 android_namespace_t* ns_isolated =
765 android_create_namespace("private_isolated1",
766 nullptr,
767 (lib_path + "/private_namespace_libs").c_str(),
768 ANDROID_NAMESPACE_TYPE_ISOLATED,
769 nullptr,
770 nullptr);
771 ASSERT_TRUE(ns_isolated != nullptr) << dlerror();
772
773 android_namespace_t* ns_isolated2 =
774 android_create_namespace("private_isolated2",
775 (lib_path + "/private_namespace_libs").c_str(),
776 nullptr,
777 ANDROID_NAMESPACE_TYPE_ISOLATED,
778 lib_path.c_str(),
779 nullptr);
780 ASSERT_TRUE(ns_isolated2 != nullptr) << dlerror();
781
782 ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
783 ASSERT_STREQ("dlopen failed: library \"libnstest_root_not_isolated.so\" not found", dlerror());
784
785 std::string lib_private_external_path =
786 lib_path + "/private_namespace_libs_external/libnstest_private_external.so";
787
788 // Load lib_private_external_path to default namespace
789 // (it should remain invisible for the isolated namespaces after this)
790 void* handle = dlopen(lib_private_external_path.c_str(), RTLD_NOW);
791 ASSERT_TRUE(handle != nullptr) << dlerror();
792
793 android_dlextinfo extinfo;
794 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
795 extinfo.library_namespace = ns_not_isolated;
796
797 void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
798 ASSERT_TRUE(handle1 != nullptr) << dlerror();
799
800 extinfo.library_namespace = ns_isolated;
801
802 void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
803 ASSERT_TRUE(handle2 == nullptr);
804 ASSERT_STREQ("dlopen failed: library \"libnstest_private_external.so\" not found", dlerror());
805
806 // Check dlopen by absolute path
807 handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
808 ASSERT_TRUE(handle2 == nullptr);
809 ASSERT_EQ("dlopen failed: library \"" + lib_private_external_path + "\" needed"
810 " or dlopened by \"" + get_executable_path() + "\" is not accessible"
811 " for the namespace \"private_isolated1\"", dlerror());
812
813 extinfo.library_namespace = ns_isolated2;
814
815 // this should work because isolation_path for private_isolated2 includes lib_path
816 handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
817 ASSERT_TRUE(handle2 != nullptr) << dlerror();
818 dlclose(handle2);
819
820 // Check dlopen by absolute path
821 handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
822 ASSERT_TRUE(handle2 != nullptr) << dlerror();
823 dlclose(handle2);
824
825 typedef const char* (*fn_t)();
826 fn_t ns_get_local_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
827 ASSERT_TRUE(ns_get_local_string != nullptr) << dlerror();
828
829 ASSERT_STREQ("This string is local to root library", ns_get_local_string());
830
831 fn_t ns_get_private_extern_string =
832 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
833 ASSERT_TRUE(ns_get_private_extern_string != nullptr) << dlerror();
834
835 ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string());
836
837 fn_t ns_get_public_extern_string =
838 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
839 ASSERT_TRUE(ns_get_public_extern_string != nullptr) << dlerror();
840
841 ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string());
842
843 fn_t ns_get_dlopened_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
844 ASSERT_TRUE(ns_get_dlopened_string != nullptr) << dlerror();
845
846 ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string());
847
848 dlclose(handle1);
849 }
850
TEST(dlext,ns_shared)851 TEST(dlext, ns_shared) {
852 static const char* root_lib = "libnstest_root_not_isolated.so";
853 static const char* root_lib_isolated = "libnstest_root.so";
854 std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
855
856 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
857 const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
858 void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
859 ASSERT_TRUE(handle_public != nullptr) << dlerror();
860
861 android_set_application_target_sdk_version(42U); // something > 23
862
863 ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
864
865 // preload this library to the default namespace to check if it
866 // is shared later on.
867 void* handle_dlopened =
868 dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(), RTLD_NOW);
869 ASSERT_TRUE(handle_dlopened != nullptr) << dlerror();
870
871 android_namespace_t* ns_not_isolated =
872 android_create_namespace("private", nullptr,
873 (lib_path + "/private_namespace_libs").c_str(),
874 ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
875 ASSERT_TRUE(ns_not_isolated != nullptr) << dlerror();
876
877 android_namespace_t* ns_isolated_shared =
878 android_create_namespace("private_isolated_shared", nullptr,
879 (lib_path + "/private_namespace_libs").c_str(),
880 ANDROID_NAMESPACE_TYPE_ISOLATED | ANDROID_NAMESPACE_TYPE_SHARED,
881 nullptr, nullptr);
882 ASSERT_TRUE(ns_isolated_shared != nullptr) << dlerror();
883
884 ASSERT_TRUE(dlopen(root_lib, RTLD_NOW) == nullptr);
885 ASSERT_STREQ("dlopen failed: library \"libnstest_root_not_isolated.so\" not found", dlerror());
886
887 std::string lib_private_external_path =
888 lib_path + "/private_namespace_libs_external/libnstest_private_external.so";
889
890 // Load lib_private_external_path to default namespace
891 // (it should remain invisible for the isolated namespaces after this)
892 void* handle = dlopen(lib_private_external_path.c_str(), RTLD_NOW);
893 ASSERT_TRUE(handle != nullptr) << dlerror();
894
895 android_dlextinfo extinfo;
896 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
897 extinfo.library_namespace = ns_not_isolated;
898
899 void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
900 ASSERT_TRUE(handle1 != nullptr) << dlerror();
901
902 extinfo.library_namespace = ns_isolated_shared;
903
904 void* handle2 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
905 ASSERT_TRUE(handle2 == nullptr);
906 ASSERT_STREQ("dlopen failed: library \"libnstest_private_external.so\" not found", dlerror());
907
908 // Check dlopen by absolute path
909 handle2 = android_dlopen_ext(lib_private_external_path.c_str(), RTLD_NOW, &extinfo);
910 ASSERT_TRUE(handle2 == nullptr);
911 ASSERT_EQ("dlopen failed: library \"" + lib_private_external_path + "\" needed"
912 " or dlopened by \"" + get_executable_path() + "\" is not accessible"
913 " for the namespace \"private_isolated_shared\"", dlerror());
914
915 // load libnstest_root.so to shared namespace in order to check that everything is different
916 // except shared libnstest_dlopened.so
917
918 handle2 = android_dlopen_ext(root_lib_isolated, RTLD_NOW, &extinfo);
919
920 typedef const char* (*fn_t)();
921 fn_t ns_get_local_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_local_string"));
922 ASSERT_TRUE(ns_get_local_string != nullptr) << dlerror();
923 fn_t ns_get_local_string_shared = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_local_string"));
924 ASSERT_TRUE(ns_get_local_string_shared != nullptr) << dlerror();
925
926 ASSERT_STREQ("This string is local to root library", ns_get_local_string());
927 ASSERT_STREQ("This string is local to root library", ns_get_local_string_shared());
928 ASSERT_TRUE(ns_get_local_string() != ns_get_local_string_shared());
929
930 fn_t ns_get_private_extern_string =
931 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_private_extern_string"));
932 ASSERT_TRUE(ns_get_private_extern_string != nullptr) << dlerror();
933 fn_t ns_get_private_extern_string_shared =
934 reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_private_extern_string"));
935 ASSERT_TRUE(ns_get_private_extern_string_shared() != nullptr) << dlerror();
936
937 ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string());
938 ASSERT_STREQ("This string is from private namespace", ns_get_private_extern_string_shared());
939 ASSERT_TRUE(ns_get_private_extern_string() != ns_get_private_extern_string_shared());
940
941 fn_t ns_get_public_extern_string =
942 reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_public_extern_string"));
943 ASSERT_TRUE(ns_get_public_extern_string != nullptr) << dlerror();
944 fn_t ns_get_public_extern_string_shared =
945 reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_public_extern_string"));
946 ASSERT_TRUE(ns_get_public_extern_string_shared != nullptr) << dlerror();
947
948 ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string());
949 ASSERT_STREQ("This string is from public namespace", ns_get_public_extern_string_shared());
950 ASSERT_TRUE(ns_get_public_extern_string() == ns_get_public_extern_string_shared());
951
952 fn_t ns_get_dlopened_string = reinterpret_cast<fn_t>(dlsym(handle1, "ns_get_dlopened_string"));
953 ASSERT_TRUE(ns_get_dlopened_string != nullptr) << dlerror();
954 fn_t ns_get_dlopened_string_shared = reinterpret_cast<fn_t>(dlsym(handle2, "ns_get_dlopened_string"));
955 ASSERT_TRUE(ns_get_dlopened_string_shared != nullptr) << dlerror();
956 const char** ns_dlopened_string = static_cast<const char**>(dlsym(handle_dlopened, "g_private_dlopened_string"));
957 ASSERT_TRUE(ns_dlopened_string != nullptr) << dlerror();
958
959 ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string());
960 ASSERT_STREQ("This string is from private namespace (dlopened library)", *ns_dlopened_string);
961 ASSERT_STREQ("This string is from private namespace (dlopened library)", ns_get_dlopened_string_shared());
962 ASSERT_TRUE(ns_get_dlopened_string() != ns_get_dlopened_string_shared());
963 ASSERT_TRUE(*ns_dlopened_string == ns_get_dlopened_string_shared());
964
965 dlclose(handle1);
966 dlclose(handle2);
967 }
968
TEST(dlext,ns_shared_dlclose)969 TEST(dlext, ns_shared_dlclose) {
970 std::string path = "libc.so:libc++.so:libdl.so:libm.so";
971
972 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
973
974 android_set_application_target_sdk_version(42U); // something > 23
975
976 ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr)) << dlerror();
977
978 // preload this library to the default namespace to check if it
979 // is shared later on.
980 void* handle_dlopened =
981 dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(), RTLD_NOW);
982 ASSERT_TRUE(handle_dlopened != nullptr) << dlerror();
983
984 android_namespace_t* ns_isolated_shared =
985 android_create_namespace("private_isolated_shared", nullptr,
986 (lib_path + "/private_namespace_libs").c_str(),
987 ANDROID_NAMESPACE_TYPE_ISOLATED | ANDROID_NAMESPACE_TYPE_SHARED,
988 nullptr, nullptr);
989 ASSERT_TRUE(ns_isolated_shared != nullptr) << dlerror();
990
991 // Check if "libnstest_dlopened.so" is loaded (and the same)
992 android_dlextinfo extinfo;
993 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
994 extinfo.library_namespace = ns_isolated_shared;
995
996 void* handle = android_dlopen_ext("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD, &extinfo);
997 ASSERT_TRUE(handle != nullptr) << dlerror();
998 ASSERT_TRUE(handle == handle_dlopened);
999 dlclose(handle);
1000 dlclose(handle_dlopened);
1001
1002 // And now check that the library cannot be found by soname (and is no longer loaded)
1003 handle = android_dlopen_ext("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD, &extinfo);
1004 ASSERT_TRUE(handle == nullptr)
1005 << "Error: libnstest_dlopened.so is still accessible in shared namespace";
1006
1007 handle = android_dlopen_ext((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(),
1008 RTLD_NOW | RTLD_NOLOAD, &extinfo);
1009 ASSERT_TRUE(handle == nullptr)
1010 << "Error: libnstest_dlopened.so is still accessible in shared namespace";
1011
1012 handle = dlopen("libnstest_dlopened.so", RTLD_NOW | RTLD_NOLOAD);
1013 ASSERT_TRUE(handle == nullptr)
1014 << "Error: libnstest_dlopened.so is still accessible in default namespace";
1015
1016 handle = dlopen((lib_path + "/private_namespace_libs/libnstest_dlopened.so").c_str(),
1017 RTLD_NOW | RTLD_NOLOAD);
1018 ASSERT_TRUE(handle == nullptr)
1019 << "Error: libnstest_dlopened.so is still accessible in default namespace";
1020
1021 // Now lets see if the soinfo area gets reused in the wrong way:
1022 // load a library to default namespace.
1023 const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
1024 void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
1025 ASSERT_TRUE(handle_public != nullptr) << dlerror();
1026
1027 // try to find it in shared namespace
1028 handle = android_dlopen_ext(g_public_lib, RTLD_NOW | RTLD_NOLOAD, &extinfo);
1029 ASSERT_TRUE(handle == nullptr)
1030 << "Error: " << g_public_lib << " is accessible in shared namespace";
1031 }
1032
TEST(dlext,ns_isolated_rtld_global)1033 TEST(dlext, ns_isolated_rtld_global) {
1034 static const char* root_lib = "libnstest_root.so";
1035 std::string path = "libc.so:libc++.so:libdl.so:libm.so";
1036
1037 ASSERT_TRUE(android_init_namespaces(path.c_str(), nullptr));
1038
1039 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
1040
1041 const std::string lib_public_path = lib_path + "/public_namespace_libs";
1042
1043 android_namespace_t* ns1 =
1044 android_create_namespace("isolated1",
1045 nullptr,
1046 (lib_path + "/private_namespace_libs").c_str(),
1047 ANDROID_NAMESPACE_TYPE_ISOLATED,
1048 lib_public_path.c_str(),
1049 nullptr);
1050 ASSERT_TRUE(ns1 != nullptr) << dlerror();
1051
1052 android_namespace_t* ns2 =
1053 android_create_namespace("isolated2",
1054 nullptr,
1055 (lib_path + "/private_namespace_libs").c_str(),
1056 ANDROID_NAMESPACE_TYPE_ISOLATED,
1057 lib_public_path.c_str(),
1058 nullptr);
1059 ASSERT_TRUE(ns2 != nullptr) << dlerror();
1060
1061 android_dlextinfo extinfo;
1062 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1063 extinfo.library_namespace = ns1;
1064
1065 void* handle_global = android_dlopen_ext((lib_public_path + "/" + g_public_lib).c_str(),
1066 RTLD_GLOBAL,
1067 &extinfo);
1068
1069 ASSERT_TRUE(handle_global != nullptr) << dlerror();
1070
1071 android_namespace_t* ns1_child =
1072 android_create_namespace("isolated1_child",
1073 nullptr,
1074 (lib_path + "/private_namespace_libs").c_str(),
1075 ANDROID_NAMESPACE_TYPE_ISOLATED,
1076 nullptr,
1077 ns1);
1078
1079 // Now - only ns1 and ns1 child should be able to dlopen root_lib
1080 // attempt to use ns2 should result in dlerror()
1081
1082 // Check ns1_child first.
1083 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1084 extinfo.library_namespace = ns1_child;
1085
1086 void* handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1087 ASSERT_TRUE(handle1 != nullptr) << dlerror();
1088
1089 // now ns1
1090 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1091 extinfo.library_namespace = ns1;
1092
1093 handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1094 ASSERT_TRUE(handle1 != nullptr) << dlerror();
1095
1096 // and ns2 should fail
1097 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1098 extinfo.library_namespace = ns2;
1099
1100 handle1 = android_dlopen_ext(root_lib, RTLD_NOW, &extinfo);
1101 ASSERT_TRUE(handle1 == nullptr);
1102 ASSERT_STREQ("dlopen failed: library \"libnstest_public.so\" not found", dlerror());
1103 }
1104
TEST(dlext,ns_anonymous)1105 TEST(dlext, ns_anonymous) {
1106 static const char* root_lib = "libnstest_root.so";
1107 std::string path = std::string("libc.so:libc++.so:libdl.so:libm.so:") + g_public_lib;
1108
1109 const std::string lib_path = std::string(getenv("ANDROID_DATA")) + NATIVE_TESTS_PATH;
1110
1111 const std::string lib_public_path = lib_path + "/public_namespace_libs/" + g_public_lib;
1112 void* handle_public = dlopen(lib_public_path.c_str(), RTLD_NOW);
1113
1114 ASSERT_TRUE(handle_public != nullptr) << dlerror();
1115
1116 ASSERT_TRUE(android_init_namespaces(path.c_str(), (lib_path + "/private_namespace_libs").c_str()))
1117 << dlerror();
1118
1119 android_namespace_t* ns = android_create_namespace(
1120 "private", nullptr,
1121 (lib_path + "/private_namespace_libs").c_str(),
1122 ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, nullptr);
1123
1124 ASSERT_TRUE(ns != nullptr) << dlerror();
1125
1126 std::string private_library_absolute_path = lib_path + "/private_namespace_libs/" + root_lib;
1127
1128 android_dlextinfo extinfo;
1129 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE;
1130 extinfo.library_namespace = ns;
1131
1132 // we are going to copy this library to anonymous mmap and call the copy of ns_get_dlopened_string
1133 void* handle = android_dlopen_ext(private_library_absolute_path.c_str(), RTLD_NOW, &extinfo);
1134 ASSERT_TRUE(handle != nullptr) << dlerror();
1135
1136 uintptr_t ns_get_dlopened_string_addr =
1137 reinterpret_cast<uintptr_t>(dlsym(handle, "ns_get_dlopened_string"));
1138 ASSERT_TRUE(ns_get_dlopened_string_addr != 0) << dlerror();
1139 typedef const char* (*fn_t)();
1140 fn_t ns_get_dlopened_string_private = reinterpret_cast<fn_t>(ns_get_dlopened_string_addr);
1141
1142 std::vector<map_record> maps;
1143 Maps::parse_maps(&maps);
1144
1145 uintptr_t addr_start = 0;
1146 uintptr_t addr_end = 0;
1147 std::vector<map_record> maps_to_copy;
1148
1149 for (const auto& rec : maps) {
1150 if (rec.pathname == private_library_absolute_path) {
1151 if (addr_start == 0) {
1152 addr_start = rec.addr_start;
1153 }
1154 addr_end = rec.addr_end;
1155
1156 maps_to_copy.push_back(rec);
1157 }
1158 }
1159
1160 // some sanity checks..
1161 ASSERT_TRUE(addr_start > 0);
1162 ASSERT_TRUE(addr_end > 0);
1163 ASSERT_EQ(3U, maps_to_copy.size());
1164 ASSERT_TRUE(ns_get_dlopened_string_addr > addr_start);
1165 ASSERT_TRUE(ns_get_dlopened_string_addr < addr_end);
1166
1167 // copy
1168 uintptr_t reserved_addr = reinterpret_cast<uintptr_t>(mmap(nullptr, addr_end - addr_start,
1169 PROT_NONE, MAP_ANON | MAP_PRIVATE,
1170 -1, 0));
1171 ASSERT_TRUE(reinterpret_cast<void*>(reserved_addr) != MAP_FAILED);
1172
1173 for (const auto& rec : maps_to_copy) {
1174 uintptr_t offset = rec.addr_start - addr_start;
1175 size_t size = rec.addr_end - rec.addr_start;
1176 void* addr = reinterpret_cast<void*>(reserved_addr + offset);
1177 void* map = mmap(addr, size, PROT_READ | PROT_WRITE,
1178 MAP_ANON | MAP_PRIVATE | MAP_FIXED, -1, 0);
1179 ASSERT_TRUE(map != MAP_FAILED);
1180 memcpy(map, reinterpret_cast<void*>(rec.addr_start), size);
1181 mprotect(map, size, rec.perms);
1182 }
1183
1184 // call the function copy
1185 uintptr_t ns_get_dlopened_string_offset = ns_get_dlopened_string_addr - addr_start;
1186 fn_t ns_get_dlopened_string_anon = reinterpret_cast<fn_t>(reserved_addr + ns_get_dlopened_string_offset);
1187 ASSERT_STREQ("This string is from private namespace (dlopened library)",
1188 ns_get_dlopened_string_anon());
1189
1190 // They should belong to different namespaces (private and anonymous)
1191 ASSERT_STREQ("This string is from private namespace (dlopened library)",
1192 ns_get_dlopened_string_private());
1193
1194 ASSERT_TRUE(ns_get_dlopened_string_anon() != ns_get_dlopened_string_private());
1195 }
1196
TEST(dlext,dlopen_handle_value_platform)1197 TEST(dlext, dlopen_handle_value_platform) {
1198 void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_NOW | RTLD_LOCAL);
1199 ASSERT_TRUE((reinterpret_cast<uintptr_t>(handle) & 1) != 0)
1200 << "dlopen should return odd value for the handle";
1201 dlclose(handle);
1202 }
1203
TEST(dlext,dlopen_handle_value_app_compat)1204 TEST(dlext, dlopen_handle_value_app_compat) {
1205 android_set_application_target_sdk_version(23);
1206 void* handle = dlopen("libtest_dlsym_from_this.so", RTLD_NOW | RTLD_LOCAL);
1207 ASSERT_TRUE(reinterpret_cast<uintptr_t>(handle) % sizeof(uintptr_t) == 0)
1208 << "dlopen should return valid pointer";
1209 dlclose(handle);
1210 }
1211
1212