8098b1c378
Add the code to parse the Elf section headers. Add the plumbing through of all the symbol handling code. Add tests for all of this new functionality. Bug: 23762183 Test: Pass new unit tests. Change-Id: Ie2d90cbb3d7653c53251dbcf34d9e5d241278377
923 lines
26 KiB
C++
923 lines
26 KiB
C++
/*
|
|
* Copyright (C) 2016 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 <elf.h>
|
|
|
|
#include <memory>
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "ElfInterface.h"
|
|
#include "ElfInterfaceArm.h"
|
|
|
|
#include "MemoryFake.h"
|
|
|
|
#if !defined(PT_ARM_EXIDX)
|
|
#define PT_ARM_EXIDX 0x70000001
|
|
#endif
|
|
|
|
#if !defined(EM_AARCH64)
|
|
#define EM_AARCH64 183
|
|
#endif
|
|
|
|
class ElfInterfaceTest : public ::testing::Test {
|
|
protected:
|
|
void SetUp() override {
|
|
memory_.Clear();
|
|
}
|
|
|
|
void SetStringMemory(uint64_t offset, const char* string) {
|
|
memory_.SetMemory(offset, string, strlen(string) + 1);
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void SinglePtLoad();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void MultipleExecutablePtLoads();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void NonExecutablePtLoads();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ManyPhdrs();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void Soname();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void SonameAfterDtNull();
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void SonameSize();
|
|
|
|
template <typename ElfType>
|
|
void InitHeadersEhFrameTest();
|
|
|
|
template <typename ElfType>
|
|
void InitHeadersDebugFrame();
|
|
|
|
template <typename ElfType>
|
|
void InitHeadersEhFrameFail();
|
|
|
|
template <typename ElfType>
|
|
void InitHeadersDebugFrameFail();
|
|
|
|
template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
|
|
void InitSectionHeadersMalformed();
|
|
|
|
template <typename Ehdr, typename Shdr, typename Sym, typename ElfInterfaceType>
|
|
void InitSectionHeaders(uint64_t entry_size);
|
|
|
|
template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
|
|
void InitSectionHeadersOffsets();
|
|
|
|
template <typename Sym>
|
|
void InitSym(uint64_t offset, uint32_t value, uint32_t size, uint32_t name_offset,
|
|
uint64_t sym_offset, const char* name);
|
|
|
|
MemoryFake memory_;
|
|
};
|
|
|
|
template <typename Sym>
|
|
void ElfInterfaceTest::InitSym(uint64_t offset, uint32_t value, uint32_t size, uint32_t name_offset,
|
|
uint64_t sym_offset, const char* name) {
|
|
Sym sym;
|
|
memset(&sym, 0, sizeof(sym));
|
|
sym.st_info = STT_FUNC;
|
|
sym.st_value = value;
|
|
sym.st_size = size;
|
|
sym.st_name = name_offset;
|
|
sym.st_shndx = SHN_COMMON;
|
|
|
|
memory_.SetMemory(offset, &sym, sizeof(sym));
|
|
memory_.SetMemory(sym_offset + name_offset, name, strlen(name) + 1);
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::SinglePtLoad() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 1;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 0x10000;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1000;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
|
|
const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
|
|
ASSERT_EQ(1U, pt_loads.size());
|
|
LoadInfo load_data = pt_loads.at(0);
|
|
ASSERT_EQ(0U, load_data.offset);
|
|
ASSERT_EQ(0x2000U, load_data.table_offset);
|
|
ASSERT_EQ(0x10000U, load_data.table_size);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_single_pt_load) {
|
|
SinglePtLoad<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_single_pt_load) {
|
|
SinglePtLoad<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::MultipleExecutablePtLoads() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 3;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 0x10000;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1000;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x1000;
|
|
phdr.p_vaddr = 0x2001;
|
|
phdr.p_memsz = 0x10001;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1001;
|
|
memory_.SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_vaddr = 0x2002;
|
|
phdr.p_memsz = 0x10002;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1002;
|
|
memory_.SetMemory(0x100 + 2 * sizeof(phdr), &phdr, sizeof(phdr));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
|
|
const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
|
|
ASSERT_EQ(3U, pt_loads.size());
|
|
|
|
LoadInfo load_data = pt_loads.at(0);
|
|
ASSERT_EQ(0U, load_data.offset);
|
|
ASSERT_EQ(0x2000U, load_data.table_offset);
|
|
ASSERT_EQ(0x10000U, load_data.table_size);
|
|
|
|
load_data = pt_loads.at(0x1000);
|
|
ASSERT_EQ(0x1000U, load_data.offset);
|
|
ASSERT_EQ(0x2001U, load_data.table_offset);
|
|
ASSERT_EQ(0x10001U, load_data.table_size);
|
|
|
|
load_data = pt_loads.at(0x2000);
|
|
ASSERT_EQ(0x2000U, load_data.offset);
|
|
ASSERT_EQ(0x2002U, load_data.table_offset);
|
|
ASSERT_EQ(0x10002U, load_data.table_size);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_multiple_executable_pt_loads) {
|
|
MultipleExecutablePtLoads<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_multiple_executable_pt_loads) {
|
|
MultipleExecutablePtLoads<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 3;
|
|
ehdr.e_phentsize = sizeof(Phdr) + 100;
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 0x10000;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1000;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x1000;
|
|
phdr.p_vaddr = 0x2001;
|
|
phdr.p_memsz = 0x10001;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1001;
|
|
memory_.SetMemory(0x100 + sizeof(phdr) + 100, &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_vaddr = 0x2002;
|
|
phdr.p_memsz = 0x10002;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1002;
|
|
memory_.SetMemory(0x100 + 2 * (sizeof(phdr) + 100), &phdr, sizeof(phdr));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
|
|
const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
|
|
ASSERT_EQ(3U, pt_loads.size());
|
|
|
|
LoadInfo load_data = pt_loads.at(0);
|
|
ASSERT_EQ(0U, load_data.offset);
|
|
ASSERT_EQ(0x2000U, load_data.table_offset);
|
|
ASSERT_EQ(0x10000U, load_data.table_size);
|
|
|
|
load_data = pt_loads.at(0x1000);
|
|
ASSERT_EQ(0x1000U, load_data.offset);
|
|
ASSERT_EQ(0x2001U, load_data.table_offset);
|
|
ASSERT_EQ(0x10001U, load_data.table_size);
|
|
|
|
load_data = pt_loads.at(0x2000);
|
|
ASSERT_EQ(0x2000U, load_data.offset);
|
|
ASSERT_EQ(0x2002U, load_data.table_offset);
|
|
ASSERT_EQ(0x10002U, load_data.table_size);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_multiple_executable_pt_loads_increments_not_size_of_phdr) {
|
|
MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn,
|
|
ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_multiple_executable_pt_loads_increments_not_size_of_phdr) {
|
|
MultipleExecutablePtLoadsIncrementsNotSizeOfPhdr<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn,
|
|
ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::NonExecutablePtLoads() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 3;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 0x10000;
|
|
phdr.p_flags = PF_R;
|
|
phdr.p_align = 0x1000;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x1000;
|
|
phdr.p_vaddr = 0x2001;
|
|
phdr.p_memsz = 0x10001;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1001;
|
|
memory_.SetMemory(0x100 + sizeof(phdr), &phdr, sizeof(phdr));
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_vaddr = 0x2002;
|
|
phdr.p_memsz = 0x10002;
|
|
phdr.p_flags = PF_R;
|
|
phdr.p_align = 0x1002;
|
|
memory_.SetMemory(0x100 + 2 * sizeof(phdr), &phdr, sizeof(phdr));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
|
|
const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
|
|
ASSERT_EQ(1U, pt_loads.size());
|
|
|
|
LoadInfo load_data = pt_loads.at(0x1000);
|
|
ASSERT_EQ(0x1000U, load_data.offset);
|
|
ASSERT_EQ(0x2001U, load_data.table_offset);
|
|
ASSERT_EQ(0x10001U, load_data.table_size);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_non_executable_pt_loads) {
|
|
NonExecutablePtLoads<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_non_executable_pt_loads) {
|
|
NonExecutablePtLoads<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::ManyPhdrs() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 7;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
uint64_t phdr_offset = 0x100;
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_LOAD;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 0x10000;
|
|
phdr.p_flags = PF_R | PF_X;
|
|
phdr.p_align = 0x1000;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_GNU_EH_FRAME;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_DYNAMIC;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_INTERP;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_NOTE;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_SHLIB;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_GNU_EH_FRAME;
|
|
memory_.SetMemory(phdr_offset, &phdr, sizeof(phdr));
|
|
phdr_offset += sizeof(phdr);
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
|
|
const std::unordered_map<uint64_t, LoadInfo>& pt_loads = elf->pt_loads();
|
|
ASSERT_EQ(1U, pt_loads.size());
|
|
|
|
LoadInfo load_data = pt_loads.at(0);
|
|
ASSERT_EQ(0U, load_data.offset);
|
|
ASSERT_EQ(0x2000U, load_data.table_offset);
|
|
ASSERT_EQ(0x10000U, load_data.table_size);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_many_phdrs) {
|
|
ElfInterfaceTest::ManyPhdrs<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_many_phdrs) {
|
|
ElfInterfaceTest::ManyPhdrs<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_arm) {
|
|
ElfInterfaceArm elf_arm(&memory_);
|
|
|
|
Elf32_Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 1;
|
|
ehdr.e_phentsize = sizeof(Elf32_Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Elf32_Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_ARM_EXIDX;
|
|
phdr.p_vaddr = 0x2000;
|
|
phdr.p_memsz = 16;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
// Add arm exidx entries.
|
|
memory_.SetData32(0x2000, 0x1000);
|
|
memory_.SetData32(0x2008, 0x1000);
|
|
|
|
ASSERT_TRUE(elf_arm.Init());
|
|
|
|
std::vector<uint32_t> entries;
|
|
for (auto addr : elf_arm) {
|
|
entries.push_back(addr);
|
|
}
|
|
ASSERT_EQ(2U, entries.size());
|
|
ASSERT_EQ(0x3000U, entries[0]);
|
|
ASSERT_EQ(0x3008U, entries[1]);
|
|
|
|
ASSERT_EQ(0x2000U, elf_arm.start_offset());
|
|
ASSERT_EQ(2U, elf_arm.total_entries());
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::Soname() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 1;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_DYNAMIC;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_memsz = sizeof(Dyn) * 3;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
uint64_t offset = 0x2000;
|
|
Dyn dyn;
|
|
|
|
dyn.d_tag = DT_STRTAB;
|
|
dyn.d_un.d_ptr = 0x10000;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_STRSZ;
|
|
dyn.d_un.d_val = 0x1000;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_SONAME;
|
|
dyn.d_un.d_val = 0x10;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_NULL;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
|
|
SetStringMemory(0x10010, "fake_soname.so");
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
std::string name;
|
|
ASSERT_TRUE(elf->GetSoname(&name));
|
|
ASSERT_STREQ("fake_soname.so", name.c_str());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_soname) {
|
|
Soname<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_soname) {
|
|
Soname<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::SonameAfterDtNull() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 1;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_DYNAMIC;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_memsz = sizeof(Dyn) * 3;
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
Dyn dyn;
|
|
uint64_t offset = 0x2000;
|
|
|
|
dyn.d_tag = DT_STRTAB;
|
|
dyn.d_un.d_ptr = 0x10000;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_STRSZ;
|
|
dyn.d_un.d_val = 0x1000;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_NULL;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_SONAME;
|
|
dyn.d_un.d_val = 0x10;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
SetStringMemory(0x10010, "fake_soname.so");
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
std::string name;
|
|
ASSERT_FALSE(elf->GetSoname(&name));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_soname_after_dt_null) {
|
|
SonameAfterDtNull<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_soname_after_dt_null) {
|
|
SonameAfterDtNull<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Phdr, typename Dyn, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::SonameSize() {
|
|
std::unique_ptr<ElfInterface> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_phoff = 0x100;
|
|
ehdr.e_phnum = 1;
|
|
ehdr.e_phentsize = sizeof(Phdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
Phdr phdr;
|
|
memset(&phdr, 0, sizeof(phdr));
|
|
phdr.p_type = PT_DYNAMIC;
|
|
phdr.p_offset = 0x2000;
|
|
phdr.p_memsz = sizeof(Dyn);
|
|
memory_.SetMemory(0x100, &phdr, sizeof(phdr));
|
|
|
|
Dyn dyn;
|
|
uint64_t offset = 0x2000;
|
|
|
|
dyn.d_tag = DT_STRTAB;
|
|
dyn.d_un.d_ptr = 0x10000;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_STRSZ;
|
|
dyn.d_un.d_val = 0x10;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_SONAME;
|
|
dyn.d_un.d_val = 0x10;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
offset += sizeof(dyn);
|
|
|
|
dyn.d_tag = DT_NULL;
|
|
memory_.SetMemory(offset, &dyn, sizeof(dyn));
|
|
|
|
SetStringMemory(0x10010, "fake_soname.so");
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
std::string name;
|
|
ASSERT_FALSE(elf->GetSoname(&name));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf32_soname_size) {
|
|
SonameSize<Elf32_Ehdr, Elf32_Phdr, Elf32_Dyn, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, elf64_soname_size) {
|
|
SonameSize<Elf64_Ehdr, Elf64_Phdr, Elf64_Dyn, ElfInterface64>();
|
|
}
|
|
|
|
class MockElfInterface32 : public ElfInterface32 {
|
|
public:
|
|
MockElfInterface32(Memory* memory) : ElfInterface32(memory) {}
|
|
virtual ~MockElfInterface32() = default;
|
|
|
|
void TestSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; }
|
|
void TestSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; }
|
|
|
|
void TestSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; }
|
|
void TestSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; }
|
|
};
|
|
|
|
class MockElfInterface64 : public ElfInterface64 {
|
|
public:
|
|
MockElfInterface64(Memory* memory) : ElfInterface64(memory) {}
|
|
virtual ~MockElfInterface64() = default;
|
|
|
|
void TestSetEhFrameOffset(uint64_t offset) { eh_frame_offset_ = offset; }
|
|
void TestSetEhFrameSize(uint64_t size) { eh_frame_size_ = size; }
|
|
|
|
void TestSetDebugFrameOffset(uint64_t offset) { debug_frame_offset_ = offset; }
|
|
void TestSetDebugFrameSize(uint64_t size) { debug_frame_size_ = size; }
|
|
};
|
|
|
|
template <typename ElfType>
|
|
void ElfInterfaceTest::InitHeadersEhFrameTest() {
|
|
ElfType elf(&memory_);
|
|
|
|
elf.TestSetEhFrameOffset(0x10000);
|
|
elf.TestSetEhFrameSize(0);
|
|
elf.TestSetDebugFrameOffset(0);
|
|
elf.TestSetDebugFrameSize(0);
|
|
|
|
memory_.SetMemory(0x10000,
|
|
std::vector<uint8_t>{0x1, DW_EH_PE_udata2, DW_EH_PE_udata2, DW_EH_PE_udata2});
|
|
memory_.SetData32(0x10004, 0x500);
|
|
memory_.SetData32(0x10008, 250);
|
|
|
|
elf.InitHeaders();
|
|
|
|
EXPECT_FALSE(elf.eh_frame() == nullptr);
|
|
EXPECT_TRUE(elf.debug_frame() == nullptr);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_eh_frame32) {
|
|
InitHeadersEhFrameTest<MockElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_eh_frame64) {
|
|
InitHeadersEhFrameTest<MockElfInterface64>();
|
|
}
|
|
|
|
template <typename ElfType>
|
|
void ElfInterfaceTest::InitHeadersDebugFrame() {
|
|
ElfType elf(&memory_);
|
|
|
|
elf.TestSetEhFrameOffset(0);
|
|
elf.TestSetEhFrameSize(0);
|
|
elf.TestSetDebugFrameOffset(0x5000);
|
|
elf.TestSetDebugFrameSize(0x200);
|
|
|
|
memory_.SetData32(0x5000, 0xfc);
|
|
memory_.SetData32(0x5004, 0xffffffff);
|
|
memory_.SetData8(0x5008, 1);
|
|
memory_.SetData8(0x5009, '\0');
|
|
|
|
memory_.SetData32(0x5100, 0xfc);
|
|
memory_.SetData32(0x5104, 0);
|
|
memory_.SetData32(0x5108, 0x1500);
|
|
memory_.SetData32(0x510c, 0x200);
|
|
|
|
elf.InitHeaders();
|
|
|
|
EXPECT_TRUE(elf.eh_frame() == nullptr);
|
|
EXPECT_FALSE(elf.debug_frame() == nullptr);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_debug_frame32) {
|
|
InitHeadersDebugFrame<MockElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_debug_frame64) {
|
|
InitHeadersDebugFrame<MockElfInterface64>();
|
|
}
|
|
|
|
template <typename ElfType>
|
|
void ElfInterfaceTest::InitHeadersEhFrameFail() {
|
|
ElfType elf(&memory_);
|
|
|
|
elf.TestSetEhFrameOffset(0x1000);
|
|
elf.TestSetEhFrameSize(0x100);
|
|
elf.TestSetDebugFrameOffset(0);
|
|
elf.TestSetDebugFrameSize(0);
|
|
|
|
elf.InitHeaders();
|
|
|
|
EXPECT_TRUE(elf.eh_frame() == nullptr);
|
|
EXPECT_EQ(0U, elf.eh_frame_offset());
|
|
EXPECT_EQ(static_cast<uint64_t>(-1), elf.eh_frame_size());
|
|
EXPECT_TRUE(elf.debug_frame() == nullptr);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_eh_frame32_fail) {
|
|
InitHeadersEhFrameFail<MockElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_eh_frame64_fail) {
|
|
InitHeadersEhFrameFail<MockElfInterface64>();
|
|
}
|
|
|
|
template <typename ElfType>
|
|
void ElfInterfaceTest::InitHeadersDebugFrameFail() {
|
|
ElfType elf(&memory_);
|
|
|
|
elf.TestSetEhFrameOffset(0);
|
|
elf.TestSetEhFrameSize(0);
|
|
elf.TestSetDebugFrameOffset(0x1000);
|
|
elf.TestSetDebugFrameSize(0x100);
|
|
|
|
elf.InitHeaders();
|
|
|
|
EXPECT_TRUE(elf.eh_frame() == nullptr);
|
|
EXPECT_TRUE(elf.debug_frame() == nullptr);
|
|
EXPECT_EQ(0U, elf.debug_frame_offset());
|
|
EXPECT_EQ(static_cast<uint64_t>(-1), elf.debug_frame_size());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_debug_frame32_fail) {
|
|
InitHeadersDebugFrameFail<MockElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_headers_debug_frame64_fail) {
|
|
InitHeadersDebugFrameFail<MockElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::InitSectionHeadersMalformed() {
|
|
std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_shoff = 0x1000;
|
|
ehdr.e_shnum = 10;
|
|
ehdr.e_shentsize = sizeof(Shdr);
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_malformed32) {
|
|
InitSectionHeadersMalformed<Elf32_Ehdr, Elf32_Shdr, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_malformed64) {
|
|
InitSectionHeadersMalformed<Elf64_Ehdr, Elf64_Shdr, ElfInterface64>();
|
|
}
|
|
|
|
template <typename Ehdr, typename Shdr, typename Sym, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::InitSectionHeaders(uint64_t entry_size) {
|
|
std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
|
|
|
|
uint64_t offset = 0x1000;
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_shoff = offset;
|
|
ehdr.e_shnum = 10;
|
|
ehdr.e_shentsize = entry_size;
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
offset += ehdr.e_shentsize;
|
|
|
|
Shdr shdr;
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_SYMTAB;
|
|
shdr.sh_link = 4;
|
|
shdr.sh_addr = 0x5000;
|
|
shdr.sh_offset = 0x5000;
|
|
shdr.sh_entsize = sizeof(Sym);
|
|
shdr.sh_size = shdr.sh_entsize * 10;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_DYNSYM;
|
|
shdr.sh_link = 4;
|
|
shdr.sh_addr = 0x6000;
|
|
shdr.sh_offset = 0x6000;
|
|
shdr.sh_entsize = sizeof(Sym);
|
|
shdr.sh_size = shdr.sh_entsize * 10;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_PROGBITS;
|
|
shdr.sh_name = 0xa000;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
// The string data for the entries.
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_STRTAB;
|
|
shdr.sh_name = 0x20000;
|
|
shdr.sh_offset = 0xf000;
|
|
shdr.sh_size = 0x1000;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
InitSym<Sym>(0x5000, 0x90000, 0x1000, 0x100, 0xf000, "function_one");
|
|
InitSym<Sym>(0x6000, 0xd0000, 0x1000, 0x300, 0xf000, "function_two");
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
EXPECT_EQ(0U, elf->debug_frame_offset());
|
|
EXPECT_EQ(0U, elf->debug_frame_size());
|
|
EXPECT_EQ(0U, elf->gnu_debugdata_offset());
|
|
EXPECT_EQ(0U, elf->gnu_debugdata_size());
|
|
|
|
// Look in the first symbol table.
|
|
std::string name;
|
|
uint64_t name_offset;
|
|
ASSERT_TRUE(elf->GetFunctionName(0x90010, &name, &name_offset));
|
|
EXPECT_EQ("function_one", name);
|
|
EXPECT_EQ(16U, name_offset);
|
|
ASSERT_TRUE(elf->GetFunctionName(0xd0020, &name, &name_offset));
|
|
EXPECT_EQ("function_two", name);
|
|
EXPECT_EQ(32U, name_offset);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers32) {
|
|
InitSectionHeaders<Elf32_Ehdr, Elf32_Shdr, Elf32_Sym, ElfInterface32>(sizeof(Elf32_Shdr));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers64) {
|
|
InitSectionHeaders<Elf64_Ehdr, Elf64_Shdr, Elf64_Sym, ElfInterface64>(sizeof(Elf64_Shdr));
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_non_std_entry_size32) {
|
|
InitSectionHeaders<Elf32_Ehdr, Elf32_Shdr, Elf32_Sym, ElfInterface32>(0x100);
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_non_std_entry_size64) {
|
|
InitSectionHeaders<Elf64_Ehdr, Elf64_Shdr, Elf64_Sym, ElfInterface64>(0x100);
|
|
}
|
|
|
|
template <typename Ehdr, typename Shdr, typename ElfInterfaceType>
|
|
void ElfInterfaceTest::InitSectionHeadersOffsets() {
|
|
std::unique_ptr<ElfInterfaceType> elf(new ElfInterfaceType(&memory_));
|
|
|
|
uint64_t offset = 0x2000;
|
|
|
|
Ehdr ehdr;
|
|
memset(&ehdr, 0, sizeof(ehdr));
|
|
ehdr.e_shoff = offset;
|
|
ehdr.e_shnum = 10;
|
|
ehdr.e_shentsize = sizeof(Shdr);
|
|
ehdr.e_shstrndx = 2;
|
|
memory_.SetMemory(0, &ehdr, sizeof(ehdr));
|
|
|
|
offset += ehdr.e_shentsize;
|
|
|
|
Shdr shdr;
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_PROGBITS;
|
|
shdr.sh_link = 2;
|
|
shdr.sh_name = 0x200;
|
|
shdr.sh_addr = 0x5000;
|
|
shdr.sh_offset = 0x5000;
|
|
shdr.sh_entsize = 0x100;
|
|
shdr.sh_size = 0x800;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
// The string data for section header names.
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_STRTAB;
|
|
shdr.sh_name = 0x20000;
|
|
shdr.sh_offset = 0xf000;
|
|
shdr.sh_size = 0x1000;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
memset(&shdr, 0, sizeof(shdr));
|
|
shdr.sh_type = SHT_PROGBITS;
|
|
shdr.sh_link = 2;
|
|
shdr.sh_name = 0x100;
|
|
shdr.sh_addr = 0x6000;
|
|
shdr.sh_offset = 0x6000;
|
|
shdr.sh_entsize = 0x100;
|
|
shdr.sh_size = 0x500;
|
|
memory_.SetMemory(offset, &shdr, sizeof(shdr));
|
|
offset += ehdr.e_shentsize;
|
|
|
|
memory_.SetMemory(0xf100, ".debug_frame", sizeof(".debug_frame"));
|
|
memory_.SetMemory(0xf200, ".gnu_debugdata", sizeof(".gnu_debugdata"));
|
|
|
|
ASSERT_TRUE(elf->Init());
|
|
EXPECT_EQ(0x6000U, elf->debug_frame_offset());
|
|
EXPECT_EQ(0x500U, elf->debug_frame_size());
|
|
EXPECT_EQ(0x5000U, elf->gnu_debugdata_offset());
|
|
EXPECT_EQ(0x800U, elf->gnu_debugdata_size());
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_offsets32) {
|
|
InitSectionHeadersOffsets<Elf32_Ehdr, Elf32_Shdr, ElfInterface32>();
|
|
}
|
|
|
|
TEST_F(ElfInterfaceTest, init_section_headers_offsets64) {
|
|
InitSectionHeadersOffsets<Elf64_Ehdr, Elf64_Shdr, ElfInterface64>();
|
|
}
|