#!/usr/bin/env python3 # Copyright 2019 The Chromium Authors # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import os import pathlib import sys import unittest sys.path.append(str(pathlib.Path(__file__).resolve().parents[1])) import elf_headers ELF_HEADER_TEST_LIBRARY = 'testdata/lib.so' class ElfHeaderTest(unittest.TestCase): def setUp(self): super(ElfHeaderTest, self).setUp() script_dir = os.path.dirname(os.path.abspath(__file__)) self.library_path = os.path.join(script_dir, ELF_HEADER_TEST_LIBRARY) def testElfHeaderParsing(self): with open(self.library_path, 'rb') as f: data = f.read() elf = elf_headers.ElfHeader(data) # Validating all of the ELF header fields. self.assertEqual(elf.e_type, elf_headers.ElfHeader.EType.ET_DYN) self.assertEqual(elf.e_entry, 0x1040) self.assertEqual(elf.e_phoff, 64) self.assertEqual(elf.e_shoff, 14136) self.assertEqual(elf.e_flags, 0) self.assertEqual(elf.e_ehsize, 64) self.assertEqual(elf.e_phentsize, 56) self.assertEqual(elf.e_phnum, 8) self.assertEqual(elf.e_shentsize, 64) self.assertEqual(elf.e_shnum, 26) self.assertEqual(elf.e_shstrndx, 25) # Validating types and amount of all segments excluding GNU specific ones. phdrs = elf.GetProgramHeaders() self.assertEqual(len(phdrs), 8) phdr_types = [ elf_headers.ProgramHeader.Type.PT_LOAD, elf_headers.ProgramHeader.Type.PT_LOAD, elf_headers.ProgramHeader.Type.PT_LOAD, elf_headers.ProgramHeader.Type.PT_LOAD, elf_headers.ProgramHeader.Type.PT_DYNAMIC, None, # Non-standard segment: GNU_EH_FRAME None, # Non-standard segment: GNU_STACK None, # Non-standard segment: GNU_RELRO ] for i in range(0, len(phdrs)): if phdr_types[i] is not None: self.assertEqual(phdrs[i].p_type, phdr_types[i]) # Validating all of the fields of the first segment. load_phdr = phdrs[0] self.assertEqual(load_phdr.p_offset, 0x0) self.assertEqual(load_phdr.p_vaddr, 0x0) self.assertEqual(load_phdr.p_paddr, 0x0) self.assertEqual(load_phdr.p_filesz, 0x468) self.assertEqual(load_phdr.p_memsz, 0x468) self.assertEqual(load_phdr.p_flags, 0b100) self.assertEqual(load_phdr.p_align, 0x1000) # Validating offsets of the second segment load_phdr = phdrs[1] self.assertEqual(load_phdr.p_offset, 0x1000) self.assertEqual(load_phdr.p_vaddr, 0x1000) self.assertEqual(load_phdr.p_paddr, 0x1000) # Validating types and amount of sections excluding GNU ones. shdrs = elf.GetSectionHeaders() self.assertEqual(len(shdrs), 26) shdr_types = [ elf_headers.SectionHeader.Type.SHT_NULL, elf_headers.SectionHeader.Type.SHT_HASH, None, # Non-standard section: GNU_HASH elf_headers.SectionHeader.Type.SHT_DYNSYM, elf_headers.SectionHeader.Type.SHT_STRTAB, None, # Non-standard section: VERSYM None, # Non-standard section: VERNEED elf_headers.SectionHeader.Type.SHT_RELA, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, None, # Non-standard section: INIT_ARRAY None, # Non-standard section: FINI_ARRAY elf_headers.SectionHeader.Type.SHT_DYNAMIC, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_NOBITS, elf_headers.SectionHeader.Type.SHT_PROGBITS, elf_headers.SectionHeader.Type.SHT_SYMTAB, elf_headers.SectionHeader.Type.SHT_STRTAB, elf_headers.SectionHeader.Type.SHT_STRTAB, ] for i in range(0, len(shdrs)): if shdr_types[i] is not None: self.assertEqual(shdrs[i].sh_type, shdr_types[i]) # Validate all fields of the first and second section, since the first one # is NULL section. shdr = shdrs[0] self.assertEqual(shdr.sh_flags, 0) self.assertEqual(shdr.sh_addr, 0x0) self.assertEqual(shdr.sh_offset, 0x0) self.assertEqual(shdr.sh_size, 0x0) self.assertEqual(shdr.sh_link, 0) self.assertEqual(shdr.sh_info, 0) self.assertEqual(shdr.sh_addralign, 0) self.assertEqual(shdr.sh_entsize, 0) shdr = shdrs[1] self.assertEqual(shdr.sh_flags, 2) self.assertEqual(shdr.sh_addr, 0x200) self.assertEqual(shdr.sh_offset, 0x200) self.assertEqual(shdr.sh_size, 0x30) self.assertEqual(shdr.sh_link, 3) self.assertEqual(shdr.sh_info, 0) self.assertEqual(shdr.sh_addralign, 8) self.assertEqual(shdr.sh_entsize, 4) def testElfHeaderSectionNames(self): """Test that the section names are correctly resolved""" with open(self.library_path, 'rb') as f: data = f.read() elf = elf_headers.ElfHeader(data) section_names = [ '', '.hash', '.gnu.hash', '.dynsym', '.dynstr', '.gnu.version', '.gnu.version_r', '.rela.dyn', '.init', '.plt', '.plt.got', '.text', '.fini', '.eh_frame_hdr', '.eh_frame', '.init_array', '.fini_array', '.dynamic', '.got', '.got.plt', '.data', '.bss', '.comment', '.symtab', '.strtab', '.shstrtab', ] shdrs = elf.GetSectionHeaders() for i in range(0, len(shdrs)): self.assertEqual(shdrs[i].GetStrName(), section_names[i]) def testElfHeaderNoopPatching(self): """Patching the ELF without any changes.""" with open(self.library_path, 'rb') as f: data = bytearray(f.read()) data_copy = data[:] elf = elf_headers.ElfHeader(data) elf.PatchData(data) self.assertEqual(data, data_copy) def testElfHeaderPatchingAndParsing(self): """Patching the ELF and validating that it worked.""" with open(self.library_path, 'rb') as f: data = bytearray(f.read()) elf = elf_headers.ElfHeader(data) # Changing some values. elf.e_ehsize = 42 elf.GetProgramHeaders()[0].p_align = 1 elf.GetProgramHeaders()[0].p_filesz = 10 elf.PatchData(data) updated_elf = elf_headers.ElfHeader(data) # Validating all of the ELF header fields. self.assertEqual(updated_elf.e_type, elf.e_type) self.assertEqual(updated_elf.e_entry, elf.e_entry) self.assertEqual(updated_elf.e_phoff, elf.e_phoff) self.assertEqual(updated_elf.e_shoff, elf.e_shoff) self.assertEqual(updated_elf.e_flags, elf.e_flags) self.assertEqual(updated_elf.e_ehsize, 42) self.assertEqual(updated_elf.e_phentsize, elf.e_phentsize) self.assertEqual(updated_elf.e_phnum, elf.e_phnum) self.assertEqual(updated_elf.e_shentsize, elf.e_shentsize) self.assertEqual(updated_elf.e_shnum, elf.e_shnum) self.assertEqual(updated_elf.e_shstrndx, elf.e_shstrndx) # Validating all of the fields of the first segment. load_phdr = elf.GetProgramHeaders()[0] updated_load_phdr = updated_elf.GetProgramHeaders()[0] self.assertEqual(updated_load_phdr.p_offset, load_phdr.p_offset) self.assertEqual(updated_load_phdr.p_vaddr, load_phdr.p_vaddr) self.assertEqual(updated_load_phdr.p_paddr, load_phdr.p_paddr) self.assertEqual(updated_load_phdr.p_filesz, 10) self.assertEqual(updated_load_phdr.p_memsz, load_phdr.p_memsz) self.assertEqual(updated_load_phdr.p_flags, load_phdr.p_flags) self.assertEqual(updated_load_phdr.p_align, 1) if __name__ == '__main__': unittest.main()