native_loader.cpp revision 6b7425881860c7b16d4228a27ed2b2119aba0bda
1/* 2 * Copyright (C) 2015 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 "nativeloader/native_loader.h" 18#include "ScopedUtfChars.h" 19 20#include <dlfcn.h> 21#ifdef __ANDROID__ 22#define LOG_TAG "libnativeloader" 23#include "nativeloader/dlext_namespaces.h" 24#include "cutils/properties.h" 25#include "log/log.h" 26#endif 27#include "nativebridge/native_bridge.h" 28 29#include <algorithm> 30#include <vector> 31#include <string> 32#include <mutex> 33 34#include <android-base/file.h> 35#include <android-base/macros.h> 36#include <android-base/strings.h> 37 38#define CHECK(predicate) LOG_ALWAYS_FATAL_IF(!(predicate),\ 39 "%s:%d: %s CHECK '" #predicate "' failed.",\ 40 __FILE__, __LINE__, __FUNCTION__) 41 42namespace android { 43 44#if defined(__ANDROID__) 45class NativeLoaderNamespace { 46 public: 47 NativeLoaderNamespace() 48 : android_ns_(nullptr), native_bridge_ns_(nullptr) { } 49 50 explicit NativeLoaderNamespace(android_namespace_t* ns) 51 : android_ns_(ns), native_bridge_ns_(nullptr) { } 52 53 explicit NativeLoaderNamespace(native_bridge_namespace_t* ns) 54 : android_ns_(nullptr), native_bridge_ns_(ns) { } 55 56 NativeLoaderNamespace(NativeLoaderNamespace&& that) = default; 57 NativeLoaderNamespace(const NativeLoaderNamespace& that) = default; 58 59 NativeLoaderNamespace& operator=(const NativeLoaderNamespace& that) = default; 60 61 android_namespace_t* get_android_ns() const { 62 CHECK(native_bridge_ns_ == nullptr); 63 return android_ns_; 64 } 65 66 native_bridge_namespace_t* get_native_bridge_ns() const { 67 CHECK(android_ns_ == nullptr); 68 return native_bridge_ns_; 69 } 70 71 bool is_android_namespace() const { 72 return native_bridge_ns_ == nullptr; 73 } 74 75 private: 76 // Only one of them can be not null 77 android_namespace_t* android_ns_; 78 native_bridge_namespace_t* native_bridge_ns_; 79}; 80 81static constexpr const char* kPublicNativeLibrariesSystemConfigPathFromRoot = 82 "/etc/public.libraries.txt"; 83static constexpr const char* kPublicNativeLibrariesVendorConfig = 84 "/vendor/etc/public.libraries.txt"; 85 86// (http://b/27588281) This is a workaround for apps using custom classloaders and calling 87// System.load() with an absolute path which is outside of the classloader library search path. 88// This list includes all directories app is allowed to access this way. 89static constexpr const char* kWhitelistedDirectories = "/data:/mnt/expand"; 90 91static bool is_debuggable() { 92 char debuggable[PROP_VALUE_MAX]; 93 property_get("ro.debuggable", debuggable, "0"); 94 return std::string(debuggable) == "1"; 95} 96 97class LibraryNamespaces { 98 public: 99 LibraryNamespaces() : initialized_(false) { } 100 101 bool Create(JNIEnv* env, 102 jobject class_loader, 103 bool is_shared, 104 jstring java_library_path, 105 jstring java_permitted_path, 106 NativeLoaderNamespace* ns, 107 std::string* error_msg) { 108 std::string library_path; // empty string by default. 109 110 if (java_library_path != nullptr) { 111 ScopedUtfChars library_path_utf_chars(env, java_library_path); 112 library_path = library_path_utf_chars.c_str(); 113 } 114 115 // (http://b/27588281) This is a workaround for apps using custom 116 // classloaders and calling System.load() with an absolute path which 117 // is outside of the classloader library search path. 118 // 119 // This part effectively allows such a classloader to access anything 120 // under /data and /mnt/expand 121 std::string permitted_path = kWhitelistedDirectories; 122 123 if (java_permitted_path != nullptr) { 124 ScopedUtfChars path(env, java_permitted_path); 125 if (path.c_str() != nullptr && path.size() > 0) { 126 permitted_path = permitted_path + ":" + path.c_str(); 127 } 128 } 129 130 if (!initialized_ && !InitPublicNamespace(library_path.c_str(), error_msg)) { 131 return false; 132 } 133 134 bool found = FindNamespaceByClassLoader(env, class_loader, nullptr); 135 136 LOG_ALWAYS_FATAL_IF(found, 137 "There is already a namespace associated with this classloader"); 138 139 uint64_t namespace_type = ANDROID_NAMESPACE_TYPE_ISOLATED; 140 if (is_shared) { 141 namespace_type |= ANDROID_NAMESPACE_TYPE_SHARED; 142 } 143 144 NativeLoaderNamespace parent_ns; 145 bool found_parent_namespace = FindParentNamespaceByClassLoader(env, class_loader, &parent_ns); 146 147 bool is_native_bridge = false; 148 149 if (found_parent_namespace) { 150 is_native_bridge = !parent_ns.is_android_namespace(); 151 } else if (!library_path.empty()) { 152 is_native_bridge = NativeBridgeIsPathSupported(library_path.c_str()); 153 } 154 155 NativeLoaderNamespace native_loader_ns; 156 if (!is_native_bridge) { 157 android_namespace_t* ns = android_create_namespace("classloader-namespace", 158 nullptr, 159 library_path.c_str(), 160 namespace_type, 161 permitted_path.c_str(), 162 parent_ns.get_android_ns()); 163 if (ns == nullptr) { 164 *error_msg = dlerror(); 165 return false; 166 } 167 168 native_loader_ns = NativeLoaderNamespace(ns); 169 } else { 170 native_bridge_namespace_t* ns = NativeBridgeCreateNamespace("classloader-namespace", 171 nullptr, 172 library_path.c_str(), 173 namespace_type, 174 permitted_path.c_str(), 175 parent_ns.get_native_bridge_ns()); 176 if (ns == nullptr) { 177 *error_msg = NativeBridgeGetError(); 178 return false; 179 } 180 181 native_loader_ns = NativeLoaderNamespace(ns); 182 } 183 184 namespaces_.push_back(std::make_pair(env->NewWeakGlobalRef(class_loader), native_loader_ns)); 185 186 *ns = native_loader_ns; 187 return true; 188 } 189 190 bool FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader, NativeLoaderNamespace* ns) { 191 auto it = std::find_if(namespaces_.begin(), namespaces_.end(), 192 [&](const std::pair<jweak, NativeLoaderNamespace>& value) { 193 return env->IsSameObject(value.first, class_loader); 194 }); 195 if (it != namespaces_.end()) { 196 if (ns != nullptr) { 197 *ns = it->second; 198 } 199 200 return true; 201 } 202 203 return false; 204 } 205 206 void Initialize() { 207 // Once public namespace is initialized there is no 208 // point in running this code - it will have no effect 209 // on the current list of public libraries. 210 if (initialized_) { 211 return; 212 } 213 214 std::vector<std::string> sonames; 215 const char* android_root_env = getenv("ANDROID_ROOT"); 216 std::string root_dir = android_root_env != nullptr ? android_root_env : "/system"; 217 std::string public_native_libraries_system_config = 218 root_dir + kPublicNativeLibrariesSystemConfigPathFromRoot; 219 220 std::string error_msg; 221 LOG_ALWAYS_FATAL_IF(!ReadConfig(public_native_libraries_system_config, &sonames, &error_msg), 222 "Error reading public native library list from \"%s\": %s", 223 public_native_libraries_system_config.c_str(), error_msg.c_str()); 224 225 // For debuggable platform builds use ANDROID_ADDITIONAL_PUBLIC_LIBRARIES environment 226 // variable to add libraries to the list. This is intended for platform tests only. 227 if (is_debuggable()) { 228 const char* additional_libs = getenv("ANDROID_ADDITIONAL_PUBLIC_LIBRARIES"); 229 if (additional_libs != nullptr && additional_libs[0] != '\0') { 230 std::vector<std::string> additional_libs_vector = base::Split(additional_libs, ":"); 231 std::copy(additional_libs_vector.begin(), 232 additional_libs_vector.end(), 233 std::back_inserter(sonames)); 234 } 235 } 236 237 // This file is optional, quietly ignore if the file does not exist. 238 ReadConfig(kPublicNativeLibrariesVendorConfig, &sonames); 239 240 // android_init_namespaces() expects all the public libraries 241 // to be loaded so that they can be found by soname alone. 242 // 243 // TODO(dimitry): this is a bit misleading since we do not know 244 // if the vendor public library is going to be opened from /vendor/lib 245 // we might as well end up loading them from /system/lib 246 // For now we rely on CTS test to catch things like this but 247 // it should probably be addressed in the future. 248 for (const auto& soname : sonames) { 249 LOG_ALWAYS_FATAL_IF(dlopen(soname.c_str(), RTLD_NOW | RTLD_NODELETE) == nullptr, 250 "Error preloading public library %s: %s", 251 soname.c_str(), dlerror()); 252 } 253 254 public_libraries_ = base::Join(sonames, ':'); 255 } 256 257 void Reset() { 258 namespaces_.clear(); 259 } 260 261 private: 262 bool ReadConfig(const std::string& configFile, std::vector<std::string>* sonames, 263 std::string* error_msg = nullptr) { 264 // Read list of public native libraries from the config file. 265 std::string file_content; 266 if(!base::ReadFileToString(configFile, &file_content)) { 267 if (error_msg) *error_msg = strerror(errno); 268 return false; 269 } 270 271 std::vector<std::string> lines = base::Split(file_content, "\n"); 272 273 for (auto& line : lines) { 274 auto trimmed_line = base::Trim(line); 275 if (trimmed_line[0] == '#' || trimmed_line.empty()) { 276 continue; 277 } 278 size_t space_pos = trimmed_line.rfind(' '); 279 if (space_pos != std::string::npos) { 280 std::string type = trimmed_line.substr(space_pos + 1); 281 if (type != "32" && type != "64") { 282 if (error_msg) *error_msg = "Malformed line: " + line; 283 return false; 284 } 285#if defined(__LP64__) 286 // Skip 32 bit public library. 287 if (type == "32") { 288 continue; 289 } 290#else 291 // Skip 64 bit public library. 292 if (type == "64") { 293 continue; 294 } 295#endif 296 trimmed_line.resize(space_pos); 297 } 298 299 sonames->push_back(trimmed_line); 300 } 301 302 return true; 303 } 304 305 bool InitPublicNamespace(const char* library_path, std::string* error_msg) { 306 // Ask native bride if this apps library path should be handled by it 307 bool is_native_bridge = NativeBridgeIsPathSupported(library_path); 308 309 // (http://b/25844435) - Some apps call dlopen from generated code (mono jited 310 // code is one example) unknown to linker in which case linker uses anonymous 311 // namespace. The second argument specifies the search path for the anonymous 312 // namespace which is the library_path of the classloader. 313 initialized_ = android_init_namespaces(public_libraries_.c_str(), 314 is_native_bridge ? nullptr : library_path); 315 if (!initialized_) { 316 *error_msg = dlerror(); 317 return false; 318 } 319 320 // and now initialize native bridge namespaces if necessary. 321 if (NativeBridgeInitialized()) { 322 initialized_ = NativeBridgeInitNamespace(public_libraries_.c_str(), 323 is_native_bridge ? library_path : nullptr); 324 if (!initialized_) { 325 *error_msg = NativeBridgeGetError(); 326 } 327 } 328 329 return initialized_; 330 } 331 332 jobject GetParentClassLoader(JNIEnv* env, jobject class_loader) { 333 jclass class_loader_class = env->FindClass("java/lang/ClassLoader"); 334 jmethodID get_parent = env->GetMethodID(class_loader_class, 335 "getParent", 336 "()Ljava/lang/ClassLoader;"); 337 338 return env->CallObjectMethod(class_loader, get_parent); 339 } 340 341 bool FindParentNamespaceByClassLoader(JNIEnv* env, 342 jobject class_loader, 343 NativeLoaderNamespace* ns) { 344 jobject parent_class_loader = GetParentClassLoader(env, class_loader); 345 346 while (parent_class_loader != nullptr) { 347 if (FindNamespaceByClassLoader(env, parent_class_loader, ns)) { 348 return true; 349 } 350 351 parent_class_loader = GetParentClassLoader(env, parent_class_loader); 352 } 353 354 return false; 355 } 356 357 bool initialized_; 358 std::vector<std::pair<jweak, NativeLoaderNamespace>> namespaces_; 359 std::string public_libraries_; 360 361 362 DISALLOW_COPY_AND_ASSIGN(LibraryNamespaces); 363}; 364 365static std::mutex g_namespaces_mutex; 366static LibraryNamespaces* g_namespaces = new LibraryNamespaces; 367#endif 368 369void InitializeNativeLoader() { 370#if defined(__ANDROID__) 371 std::lock_guard<std::mutex> guard(g_namespaces_mutex); 372 g_namespaces->Initialize(); 373#endif 374} 375 376void ResetNativeLoader() { 377#if defined(__ANDROID__) 378 std::lock_guard<std::mutex> guard(g_namespaces_mutex); 379 g_namespaces->Reset(); 380#endif 381} 382 383jstring CreateClassLoaderNamespace(JNIEnv* env, 384 int32_t target_sdk_version, 385 jobject class_loader, 386 bool is_shared, 387 jstring library_path, 388 jstring permitted_path) { 389#if defined(__ANDROID__) 390 UNUSED(target_sdk_version); 391 std::lock_guard<std::mutex> guard(g_namespaces_mutex); 392 393 std::string error_msg; 394 NativeLoaderNamespace ns; 395 bool success = g_namespaces->Create(env, 396 class_loader, 397 is_shared, 398 library_path, 399 permitted_path, 400 &ns, 401 &error_msg); 402 if (!success) { 403 return env->NewStringUTF(error_msg.c_str()); 404 } 405#else 406 UNUSED(env, target_sdk_version, class_loader, is_shared, 407 library_path, permitted_path); 408#endif 409 return nullptr; 410} 411 412void* OpenNativeLibrary(JNIEnv* env, 413 int32_t target_sdk_version, 414 const char* path, 415 jobject class_loader, 416 jstring library_path, 417 bool* needs_native_bridge, 418 std::string* error_msg) { 419#if defined(__ANDROID__) 420 UNUSED(target_sdk_version); 421 if (class_loader == nullptr) { 422 *needs_native_bridge = false; 423 return dlopen(path, RTLD_NOW); 424 } 425 426 std::lock_guard<std::mutex> guard(g_namespaces_mutex); 427 NativeLoaderNamespace ns; 428 429 if (!g_namespaces->FindNamespaceByClassLoader(env, class_loader, &ns)) { 430 // This is the case where the classloader was not created by ApplicationLoaders 431 // In this case we create an isolated not-shared namespace for it. 432 if (!g_namespaces->Create(env, class_loader, false, library_path, nullptr, &ns, error_msg)) { 433 return nullptr; 434 } 435 } 436 437 if (ns.is_android_namespace()) { 438 android_dlextinfo extinfo; 439 extinfo.flags = ANDROID_DLEXT_USE_NAMESPACE; 440 extinfo.library_namespace = ns.get_android_ns(); 441 442 void* handle = android_dlopen_ext(path, RTLD_NOW, &extinfo); 443 if (handle == nullptr) { 444 *error_msg = dlerror(); 445 } 446 *needs_native_bridge = false; 447 return handle; 448 } else { 449 void* handle = NativeBridgeLoadLibraryExt(path, RTLD_NOW, ns.get_native_bridge_ns()); 450 if (handle == nullptr) { 451 *error_msg = NativeBridgeGetError(); 452 } 453 *needs_native_bridge = true; 454 return handle; 455 } 456#else 457 UNUSED(env, target_sdk_version, class_loader, library_path); 458 *needs_native_bridge = false; 459 void* handle = dlopen(path, RTLD_NOW); 460 if (handle == nullptr) { 461 if (NativeBridgeIsSupported(path)) { 462 *needs_native_bridge = true; 463 handle = NativeBridgeLoadLibrary(path, RTLD_NOW); 464 if (handle == nullptr) { 465 *error_msg = NativeBridgeGetError(); 466 } 467 } else { 468 *needs_native_bridge = false; 469 *error_msg = dlerror(); 470 } 471 } 472 return handle; 473#endif 474} 475 476bool CloseNativeLibrary(void* handle, const bool needs_native_bridge) { 477 return needs_native_bridge ? NativeBridgeUnloadLibrary(handle) : 478 dlclose(handle); 479} 480 481#if defined(__ANDROID__) 482// native_bridge_namespaces are not supported for callers of this function. 483// This function will return nullptr in the case when application is running 484// on native bridge. 485android_namespace_t* FindNamespaceByClassLoader(JNIEnv* env, jobject class_loader) { 486 std::lock_guard<std::mutex> guard(g_namespaces_mutex); 487 NativeLoaderNamespace ns; 488 if (g_namespaces->FindNamespaceByClassLoader(env, class_loader, &ns)) { 489 return ns.is_android_namespace() ? ns.get_android_ns() : nullptr; 490 } 491 492 return nullptr; 493} 494#endif 495 496}; // android namespace 497