546 lines
21 KiB
C++
546 lines
21 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "dex_file_loader.h"
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <memory>
|
|
#include <optional>
|
|
|
|
#include "android-base/stringprintf.h"
|
|
#include "base/bit_utils.h"
|
|
#include "base/file_magic.h"
|
|
#include "base/mem_map.h"
|
|
#include "base/os.h"
|
|
#include "base/stl_util.h"
|
|
#include "base/systrace.h"
|
|
#include "base/unix_file/fd_file.h"
|
|
#include "base/zip_archive.h"
|
|
#include "compact_dex_file.h"
|
|
#include "dex_file.h"
|
|
#include "dex_file_verifier.h"
|
|
#include "standard_dex_file.h"
|
|
|
|
namespace art {
|
|
|
|
#if defined(STATIC_LIB)
|
|
#define DEXFILE_SCOPED_TRACE(name)
|
|
#else
|
|
#define DEXFILE_SCOPED_TRACE(name) ScopedTrace trace(name)
|
|
#endif
|
|
|
|
namespace {
|
|
|
|
// Technically we do not have a limitation with respect to the number of dex files that can be in a
|
|
// multidex APK. However, it's bad practice, as each dex file requires its own tables for symbols
|
|
// (types, classes, methods, ...) and dex caches. So warn the user that we open a zip with what
|
|
// seems an excessive number.
|
|
static constexpr size_t kWarnOnManyDexFilesThreshold = 100;
|
|
|
|
using android::base::StringPrintf;
|
|
|
|
class VectorContainer : public DexFileContainer {
|
|
public:
|
|
explicit VectorContainer(std::vector<uint8_t>&& vector) : vector_(std::move(vector)) { }
|
|
~VectorContainer() override { }
|
|
|
|
bool IsReadOnly() const override { return true; }
|
|
|
|
bool EnableWrite() override { return true; }
|
|
|
|
bool DisableWrite() override { return false; }
|
|
|
|
const uint8_t* Begin() const override { return vector_.data(); }
|
|
|
|
const uint8_t* End() const override { return vector_.data() + vector_.size(); }
|
|
|
|
private:
|
|
std::vector<uint8_t> vector_;
|
|
DISALLOW_COPY_AND_ASSIGN(VectorContainer);
|
|
};
|
|
|
|
class MemMapContainer : public DexFileContainer {
|
|
public:
|
|
explicit MemMapContainer(MemMap&& mem_map, bool is_file_map = false)
|
|
: mem_map_(std::move(mem_map)), is_file_map_(is_file_map) {}
|
|
|
|
int GetPermissions() const {
|
|
if (!mem_map_.IsValid()) {
|
|
return 0;
|
|
} else {
|
|
return mem_map_.GetProtect();
|
|
}
|
|
}
|
|
|
|
bool IsReadOnly() const override { return GetPermissions() == PROT_READ; }
|
|
|
|
bool EnableWrite() override {
|
|
CHECK(IsReadOnly());
|
|
if (!mem_map_.IsValid()) {
|
|
return false;
|
|
} else {
|
|
return mem_map_.Protect(PROT_READ | PROT_WRITE);
|
|
}
|
|
}
|
|
|
|
bool DisableWrite() override {
|
|
CHECK(!IsReadOnly());
|
|
if (!mem_map_.IsValid()) {
|
|
return false;
|
|
} else {
|
|
return mem_map_.Protect(PROT_READ);
|
|
}
|
|
}
|
|
|
|
const uint8_t* Begin() const override { return mem_map_.Begin(); }
|
|
|
|
const uint8_t* End() const override { return mem_map_.End(); }
|
|
|
|
bool IsFileMap() const override { return is_file_map_; }
|
|
|
|
protected:
|
|
MemMap mem_map_;
|
|
bool is_file_map_;
|
|
DISALLOW_COPY_AND_ASSIGN(MemMapContainer);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
bool DexFileLoader::IsMagicValid(uint32_t magic) {
|
|
return IsMagicValid(reinterpret_cast<uint8_t*>(&magic));
|
|
}
|
|
|
|
bool DexFileLoader::IsMagicValid(const uint8_t* magic) {
|
|
return StandardDexFile::IsMagicValid(magic) ||
|
|
CompactDexFile::IsMagicValid(magic);
|
|
}
|
|
|
|
bool DexFileLoader::IsVersionAndMagicValid(const uint8_t* magic) {
|
|
if (StandardDexFile::IsMagicValid(magic)) {
|
|
return StandardDexFile::IsVersionValid(magic);
|
|
}
|
|
if (CompactDexFile::IsMagicValid(magic)) {
|
|
return CompactDexFile::IsVersionValid(magic);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DexFileLoader::IsMultiDexLocation(const char* location) {
|
|
return strrchr(location, kMultiDexSeparator) != nullptr;
|
|
}
|
|
|
|
std::string DexFileLoader::GetMultiDexClassesDexName(size_t index) {
|
|
return (index == 0) ? "classes.dex" : StringPrintf("classes%zu.dex", index + 1);
|
|
}
|
|
|
|
std::string DexFileLoader::GetMultiDexLocation(size_t index, const char* dex_location) {
|
|
return (index == 0)
|
|
? dex_location
|
|
: StringPrintf("%s%cclasses%zu.dex", dex_location, kMultiDexSeparator, index + 1);
|
|
}
|
|
|
|
std::string DexFileLoader::GetDexCanonicalLocation(const char* dex_location) {
|
|
CHECK_NE(dex_location, static_cast<const char*>(nullptr));
|
|
std::string base_location = GetBaseLocation(dex_location);
|
|
const char* suffix = dex_location + base_location.size();
|
|
DCHECK(suffix[0] == 0 || suffix[0] == kMultiDexSeparator);
|
|
#ifdef _WIN32
|
|
// Warning: No symbolic link processing here.
|
|
PLOG(WARNING) << "realpath is unsupported on Windows.";
|
|
#else
|
|
// Warning: Bionic implementation of realpath() allocates > 12KB on the stack.
|
|
// Do not run this code on a small stack, e.g. in signal handler.
|
|
UniqueCPtr<const char[]> path(realpath(base_location.c_str(), nullptr));
|
|
if (path != nullptr && path.get() != base_location) {
|
|
return std::string(path.get()) + suffix;
|
|
}
|
|
#endif
|
|
if (suffix[0] == 0) {
|
|
return base_location;
|
|
} else {
|
|
return dex_location;
|
|
}
|
|
}
|
|
|
|
// All of the implementations here should be independent of the runtime.
|
|
|
|
DexFileLoader::DexFileLoader(const uint8_t* base, size_t size, const std::string& location)
|
|
: DexFileLoader(std::make_shared<MemoryDexFileContainer>(base, base + size), location) {}
|
|
|
|
DexFileLoader::DexFileLoader(std::vector<uint8_t>&& memory, const std::string& location)
|
|
: DexFileLoader(std::make_shared<VectorContainer>(std::move(memory)), location) {}
|
|
|
|
DexFileLoader::DexFileLoader(MemMap&& mem_map, const std::string& location)
|
|
: DexFileLoader(std::make_shared<MemMapContainer>(std::move(mem_map)), location) {}
|
|
|
|
std::unique_ptr<const DexFile> DexFileLoader::Open(uint32_t location_checksum,
|
|
const OatDexFile* oat_dex_file,
|
|
bool verify,
|
|
bool verify_checksum,
|
|
std::string* error_msg) {
|
|
DEXFILE_SCOPED_TRACE(std::string("Open dex file ") + location_);
|
|
|
|
uint32_t magic;
|
|
if (!InitAndReadMagic(&magic, error_msg) || !MapRootContainer(error_msg)) {
|
|
DCHECK(!error_msg->empty());
|
|
return {};
|
|
}
|
|
DCHECK(root_container_ != nullptr);
|
|
std::unique_ptr<const DexFile> dex_file = OpenCommon(root_container_,
|
|
root_container_->Begin(),
|
|
root_container_->Size(),
|
|
location_,
|
|
location_checksum,
|
|
oat_dex_file,
|
|
verify,
|
|
verify_checksum,
|
|
error_msg,
|
|
nullptr);
|
|
return dex_file;
|
|
}
|
|
|
|
bool DexFileLoader::InitAndReadMagic(uint32_t* magic, std::string* error_msg) {
|
|
if (root_container_ != nullptr) {
|
|
if (root_container_->Size() < sizeof(uint32_t)) {
|
|
*error_msg = StringPrintf("Unable to open '%s' : Size is too small", location_.c_str());
|
|
return false;
|
|
}
|
|
*magic = *reinterpret_cast<const uint32_t*>(root_container_->Begin());
|
|
} else {
|
|
// Open the file if we have not been given the file-descriptor directly before.
|
|
if (!file_.has_value()) {
|
|
CHECK(!filename_.empty());
|
|
file_.emplace(filename_, O_RDONLY, /* check_usage= */ false);
|
|
if (file_->Fd() == -1) {
|
|
*error_msg = StringPrintf("Unable to open '%s' : %s", filename_.c_str(), strerror(errno));
|
|
return false;
|
|
}
|
|
}
|
|
if (!ReadMagicAndReset(file_->Fd(), magic, error_msg)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool DexFileLoader::MapRootContainer(std::string* error_msg) {
|
|
if (root_container_ != nullptr) {
|
|
return true;
|
|
}
|
|
|
|
CHECK(MemMap::IsInitialized());
|
|
CHECK(file_.has_value());
|
|
struct stat sbuf;
|
|
memset(&sbuf, 0, sizeof(sbuf));
|
|
if (fstat(file_->Fd(), &sbuf) == -1) {
|
|
*error_msg = StringPrintf("DexFile: fstat '%s' failed: %s", filename_.c_str(), strerror(errno));
|
|
return false;
|
|
}
|
|
if (S_ISDIR(sbuf.st_mode)) {
|
|
*error_msg = StringPrintf("Attempt to mmap directory '%s'", filename_.c_str());
|
|
return false;
|
|
}
|
|
MemMap map = MemMap::MapFile(sbuf.st_size,
|
|
PROT_READ,
|
|
MAP_PRIVATE,
|
|
file_->Fd(),
|
|
0,
|
|
/*low_4gb=*/false,
|
|
filename_.c_str(),
|
|
error_msg);
|
|
if (!map.IsValid()) {
|
|
DCHECK(!error_msg->empty());
|
|
return false;
|
|
}
|
|
root_container_ = std::make_shared<MemMapContainer>(std::move(map));
|
|
return true;
|
|
}
|
|
|
|
bool DexFileLoader::Open(bool verify,
|
|
bool verify_checksum,
|
|
bool allow_no_dex_files,
|
|
DexFileLoaderErrorCode* error_code,
|
|
std::string* error_msg,
|
|
std::vector<std::unique_ptr<const DexFile>>* dex_files) {
|
|
DEXFILE_SCOPED_TRACE(std::string("Open dex file ") + location_);
|
|
|
|
DCHECK(dex_files != nullptr) << "DexFile::Open: out-param is nullptr";
|
|
|
|
uint32_t magic;
|
|
if (!InitAndReadMagic(&magic, error_msg)) {
|
|
return false;
|
|
}
|
|
|
|
if (IsZipMagic(magic)) {
|
|
std::unique_ptr<ZipArchive> zip_archive(
|
|
file_.has_value() ?
|
|
ZipArchive::OpenFromOwnedFd(file_->Fd(), location_.c_str(), error_msg) :
|
|
ZipArchive::OpenFromMemory(
|
|
root_container_->Begin(), root_container_->Size(), location_.c_str(), error_msg));
|
|
if (zip_archive.get() == nullptr) {
|
|
DCHECK(!error_msg->empty());
|
|
return false;
|
|
}
|
|
for (size_t i = 0;; ++i) {
|
|
std::string name = GetMultiDexClassesDexName(i);
|
|
std::string multidex_location = GetMultiDexLocation(i, location_.c_str());
|
|
bool ok = OpenFromZipEntry(*zip_archive,
|
|
name.c_str(),
|
|
multidex_location,
|
|
verify,
|
|
verify_checksum,
|
|
error_code,
|
|
error_msg,
|
|
dex_files);
|
|
if (!ok) {
|
|
// We keep opening consecutive dex entries as long as we can (until entry is not found).
|
|
if (*error_code == DexFileLoaderErrorCode::kEntryNotFound) {
|
|
// Success if we loaded at least one entry, or if empty zip is explicitly allowed.
|
|
return i > 0 || allow_no_dex_files;
|
|
}
|
|
return false;
|
|
}
|
|
if (i == kWarnOnManyDexFilesThreshold) {
|
|
LOG(WARNING) << location_ << " has in excess of " << kWarnOnManyDexFilesThreshold
|
|
<< " dex files. Please consider coalescing and shrinking the number to "
|
|
" avoid runtime overhead.";
|
|
}
|
|
}
|
|
}
|
|
if (IsMagicValid(magic)) {
|
|
if (!MapRootContainer(error_msg)) {
|
|
return false;
|
|
}
|
|
DCHECK(root_container_ != nullptr);
|
|
std::unique_ptr<const DexFile> dex_file =
|
|
OpenCommon(root_container_,
|
|
root_container_->Begin(),
|
|
root_container_->Size(),
|
|
location_,
|
|
/*location_checksum*/ {}, // Use default checksum from dex header.
|
|
/*oat_dex_file=*/nullptr,
|
|
verify,
|
|
verify_checksum,
|
|
error_msg,
|
|
nullptr);
|
|
if (dex_file.get() != nullptr) {
|
|
dex_files->push_back(std::move(dex_file));
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
*error_msg = StringPrintf("Expected valid zip or dex file");
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<DexFile> DexFileLoader::OpenCommon(std::shared_ptr<DexFileContainer> container,
|
|
const uint8_t* base,
|
|
size_t size,
|
|
const std::string& location,
|
|
std::optional<uint32_t> location_checksum,
|
|
const OatDexFile* oat_dex_file,
|
|
bool verify,
|
|
bool verify_checksum,
|
|
std::string* error_msg,
|
|
DexFileLoaderErrorCode* error_code) {
|
|
if (container == nullptr) {
|
|
// We should never pass null here, but use reasonable default for app compat anyway.
|
|
container = std::make_shared<MemoryDexFileContainer>(base, size);
|
|
}
|
|
if (error_code != nullptr) {
|
|
*error_code = DexFileLoaderErrorCode::kDexFileError;
|
|
}
|
|
std::unique_ptr<DexFile> dex_file;
|
|
auto header = reinterpret_cast<const DexFile::Header*>(base);
|
|
if (size >= sizeof(StandardDexFile::Header) && StandardDexFile::IsMagicValid(base)) {
|
|
uint32_t checksum = location_checksum.value_or(header->checksum_);
|
|
dex_file.reset(new StandardDexFile(base, size, location, checksum, oat_dex_file, container));
|
|
} else if (size >= sizeof(CompactDexFile::Header) && CompactDexFile::IsMagicValid(base)) {
|
|
uint32_t checksum = location_checksum.value_or(header->checksum_);
|
|
dex_file.reset(new CompactDexFile(base, size, location, checksum, oat_dex_file, container));
|
|
} else {
|
|
*error_msg = StringPrintf("Invalid or truncated dex file '%s'", location.c_str());
|
|
}
|
|
if (dex_file == nullptr) {
|
|
*error_msg =
|
|
StringPrintf("Failed to open dex file '%s': %s", location.c_str(), error_msg->c_str());
|
|
return nullptr;
|
|
}
|
|
if (!dex_file->Init(error_msg)) {
|
|
dex_file.reset();
|
|
return nullptr;
|
|
}
|
|
// NB: Dex verifier does not understand the compact dex format.
|
|
if (verify && !dex_file->IsCompactDexFile()) {
|
|
DEXFILE_SCOPED_TRACE(std::string("Verify dex file ") + location);
|
|
if (!dex::Verify(dex_file.get(), location.c_str(), verify_checksum, error_msg)) {
|
|
if (error_code != nullptr) {
|
|
*error_code = DexFileLoaderErrorCode::kVerifyError;
|
|
}
|
|
return nullptr;
|
|
}
|
|
}
|
|
if (error_code != nullptr) {
|
|
*error_code = DexFileLoaderErrorCode::kNoError;
|
|
}
|
|
return dex_file;
|
|
}
|
|
|
|
bool DexFileLoader::OpenFromZipEntry(const ZipArchive& zip_archive,
|
|
const char* entry_name,
|
|
const std::string& location,
|
|
bool verify,
|
|
bool verify_checksum,
|
|
DexFileLoaderErrorCode* error_code,
|
|
std::string* error_msg,
|
|
std::vector<std::unique_ptr<const DexFile>>* dex_files) const {
|
|
CHECK(!location.empty());
|
|
std::unique_ptr<ZipEntry> zip_entry(zip_archive.Find(entry_name, error_msg));
|
|
if (zip_entry == nullptr) {
|
|
*error_code = DexFileLoaderErrorCode::kEntryNotFound;
|
|
return false;
|
|
}
|
|
if (zip_entry->GetUncompressedLength() == 0) {
|
|
*error_msg = StringPrintf("Dex file '%s' has zero length", location.c_str());
|
|
*error_code = DexFileLoaderErrorCode::kDexFileError;
|
|
return false;
|
|
}
|
|
|
|
CHECK(MemMap::IsInitialized());
|
|
MemMap map;
|
|
bool is_file_map = false;
|
|
if (file_.has_value() && zip_entry->IsUncompressed()) {
|
|
if (!zip_entry->IsAlignedTo(alignof(DexFile::Header))) {
|
|
// Do not mmap unaligned ZIP entries because
|
|
// doing so would fail dex verification which requires 4 byte alignment.
|
|
LOG(WARNING) << "Can't mmap dex file " << location << "!" << entry_name << " directly; "
|
|
<< "please zipalign to " << alignof(DexFile::Header) << " bytes. "
|
|
<< "Falling back to extracting file.";
|
|
} else {
|
|
// Map uncompressed files within zip as file-backed to avoid a dirty copy.
|
|
map = zip_entry->MapDirectlyFromFile(location.c_str(), /*out*/ error_msg);
|
|
if (!map.IsValid()) {
|
|
LOG(WARNING) << "Can't mmap dex file " << location << "!" << entry_name << " directly; "
|
|
<< "is your ZIP file corrupted? Falling back to extraction.";
|
|
// Try again with Extraction which still has a chance of recovery.
|
|
}
|
|
is_file_map = true;
|
|
}
|
|
}
|
|
if (!map.IsValid()) {
|
|
DEXFILE_SCOPED_TRACE(std::string("Extract dex file ") + location);
|
|
|
|
// Default path for compressed ZIP entries,
|
|
// and fallback for stored ZIP entries.
|
|
map = zip_entry->ExtractToMemMap(location.c_str(), entry_name, error_msg);
|
|
}
|
|
if (!map.IsValid()) {
|
|
*error_msg = StringPrintf("Failed to extract '%s' from '%s': %s", entry_name, location.c_str(),
|
|
error_msg->c_str());
|
|
*error_code = DexFileLoaderErrorCode::kExtractToMemoryError;
|
|
return false;
|
|
}
|
|
auto container = std::make_shared<MemMapContainer>(std::move(map), is_file_map);
|
|
container->SetIsZip();
|
|
if (!container->DisableWrite()) {
|
|
*error_msg = StringPrintf("Failed to make dex file '%s' read only", location.c_str());
|
|
*error_code = DexFileLoaderErrorCode::kMakeReadOnlyError;
|
|
return false;
|
|
}
|
|
|
|
std::unique_ptr<const DexFile> dex_file = OpenCommon(container,
|
|
container->Begin(),
|
|
container->Size(),
|
|
location,
|
|
zip_entry->GetCrc32(),
|
|
/*oat_dex_file=*/nullptr,
|
|
verify,
|
|
verify_checksum,
|
|
error_msg,
|
|
error_code);
|
|
if (dex_file == nullptr) {
|
|
return false;
|
|
}
|
|
CHECK(dex_file->IsReadOnly()) << location;
|
|
dex_files->push_back(std::move(dex_file));
|
|
return true;
|
|
}
|
|
|
|
std::unique_ptr<const DexFile> DexFileLoader::Open(
|
|
const uint8_t* base,
|
|
size_t size,
|
|
const std::string& location,
|
|
uint32_t location_checksum,
|
|
const OatDexFile* oat_dex_file,
|
|
bool verify,
|
|
bool verify_checksum,
|
|
std::string* error_msg,
|
|
std::unique_ptr<DexFileContainer> container) const {
|
|
return OpenCommon(base,
|
|
size,
|
|
/*data_base=*/nullptr,
|
|
/*data_size=*/0,
|
|
location,
|
|
location_checksum,
|
|
oat_dex_file,
|
|
verify,
|
|
verify_checksum,
|
|
error_msg,
|
|
std::move(container),
|
|
/*verify_result=*/nullptr);
|
|
}
|
|
|
|
std::unique_ptr<DexFile> DexFileLoader::OpenCommon(const uint8_t* base,
|
|
size_t size,
|
|
const uint8_t* data_base,
|
|
size_t data_size,
|
|
const std::string& location,
|
|
uint32_t location_checksum,
|
|
const OatDexFile* oat_dex_file,
|
|
bool verify,
|
|
bool verify_checksum,
|
|
std::string* error_msg,
|
|
std::unique_ptr<DexFileContainer> old_container,
|
|
VerifyResult* verify_result) {
|
|
CHECK(data_base == base || data_base == nullptr);
|
|
CHECK(data_size == size || data_size == 0);
|
|
CHECK(verify_result == nullptr);
|
|
|
|
// The provided container probably does implent the new API.
|
|
// We don't use it, but let's at least call its destructor.
|
|
struct NewContainer : public MemoryDexFileContainer {
|
|
using MemoryDexFileContainer::MemoryDexFileContainer; // ctor.
|
|
std::unique_ptr<DexFileContainer> old_container_ = nullptr;
|
|
};
|
|
auto new_container = std::make_shared<NewContainer>(base, size);
|
|
new_container->old_container_ = std::move(old_container);
|
|
|
|
return OpenCommon(std::move(new_container),
|
|
base,
|
|
size,
|
|
location,
|
|
location_checksum,
|
|
oat_dex_file,
|
|
verify,
|
|
verify_checksum,
|
|
error_msg,
|
|
/*error_code=*/nullptr);
|
|
}
|
|
|
|
} // namespace art
|