| # Copyright 2013-2016 The Meson development team |
| |
| # 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. |
| |
| |
| import sys, struct |
| |
| SHT_STRTAB = 3 |
| DT_NEEDED = 1 |
| DT_RPATH = 15 |
| DT_RUNPATH = 29 |
| DT_STRTAB = 5 |
| DT_SONAME = 14 |
| DT_MIPS_RLD_MAP_REL = 1879048245 |
| |
| class DataSizes: |
| def __init__(self, ptrsize, is_le): |
| if is_le: |
| p = '<' |
| else: |
| p = '>' |
| self.Half = p + 'h' |
| self.HalfSize = 2 |
| self.Word = p + 'I' |
| self.WordSize = 4 |
| self.Sword = p + 'i' |
| self.SwordSize = 4 |
| if ptrsize == 64: |
| self.Addr = p + 'Q' |
| self.AddrSize = 8 |
| self.Off = p + 'Q' |
| self.OffSize = 8 |
| self.XWord = p + 'Q' |
| self.XWordSize = 8 |
| self.Sxword = p + 'q' |
| self.SxwordSize = 8 |
| else: |
| self.Addr = p + 'I' |
| self.AddrSize = 4 |
| self.Off = p + 'I' |
| self.OffSize = 4 |
| |
| class DynamicEntry(DataSizes): |
| def __init__(self, ifile, ptrsize, is_le): |
| super().__init__(ptrsize, is_le) |
| self.ptrsize = ptrsize |
| if ptrsize == 64: |
| self.d_tag = struct.unpack(self.Sxword, ifile.read(self.SxwordSize))[0] |
| self.val = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.d_tag = struct.unpack(self.Sword, ifile.read(self.SwordSize))[0] |
| self.val = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| |
| def write(self, ofile): |
| if self.ptrsize == 64: |
| ofile.write(struct.pack(self.Sxword, self.d_tag)) |
| ofile.write(struct.pack(self.XWord, self.val)) |
| else: |
| ofile.write(struct.pack(self.Sword, self.d_tag)) |
| ofile.write(struct.pack(self.Word, self.val)) |
| |
| class SectionHeader(DataSizes): |
| def __init__(self, ifile, ptrsize, is_le): |
| super().__init__(ptrsize, is_le) |
| if ptrsize == 64: |
| is_64 = True |
| else: |
| is_64 = False |
| # Elf64_Word |
| self.sh_name = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_type = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_flags = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_flags = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Addr |
| self.sh_addr = struct.unpack(self.Addr, ifile.read(self.AddrSize))[0] |
| # Elf64_Off |
| self.sh_offset = struct.unpack(self.Off, ifile.read(self.OffSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_size = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_size = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_link = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Word |
| self.sh_info = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_addralign = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_addralign = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| # Elf64_Xword |
| if is_64: |
| self.sh_entsize = struct.unpack(self.XWord, ifile.read(self.XWordSize))[0] |
| else: |
| self.sh_entsize = struct.unpack(self.Word, ifile.read(self.WordSize))[0] |
| |
| class Elf(DataSizes): |
| def __init__(self, bfile, verbose=True): |
| self.bfile = bfile |
| self.verbose = verbose |
| self.bf = open(bfile, 'r+b') |
| try: |
| (self.ptrsize, self.is_le) = self.detect_elf_type() |
| super().__init__(self.ptrsize, self.is_le) |
| self.parse_header() |
| self.parse_sections() |
| self.parse_dynamic() |
| except: |
| self.bf.close() |
| raise |
| |
| def __enter__(self): |
| return self |
| |
| def __del__(self): |
| if self.bf: |
| self.bf.close() |
| |
| def __exit__(self, exc_type, exc_value, traceback): |
| self.bf.close() |
| self.bf = None |
| |
| def detect_elf_type(self): |
| data = self.bf.read(6) |
| if data[1:4] != b'ELF': |
| # This script gets called to non-elf targets too |
| # so just ignore them. |
| if self.verbose: |
| print('File "%s" is not an ELF file.' % self.bfile) |
| sys.exit(0) |
| if data[4] == 1: |
| ptrsize = 32 |
| elif data[4] == 2: |
| ptrsize = 64 |
| else: |
| sys.exit('File "%s" has unknown ELF class.' % self.bfile) |
| if data[5] == 1: |
| is_le = True |
| elif data[5] == 2: |
| is_le = False |
| else: |
| sys.exit('File "%s" has unknown ELF endianness.' % self.bfile) |
| return ptrsize, is_le |
| |
| def parse_header(self): |
| self.bf.seek(0) |
| self.e_ident = struct.unpack('16s', self.bf.read(16))[0] |
| self.e_type = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_machine = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_version = struct.unpack(self.Word, self.bf.read(self.WordSize))[0] |
| self.e_entry = struct.unpack(self.Addr, self.bf.read(self.AddrSize))[0] |
| self.e_phoff = struct.unpack(self.Off, self.bf.read(self.OffSize))[0] |
| self.e_shoff = struct.unpack(self.Off, self.bf.read(self.OffSize))[0] |
| self.e_flags = struct.unpack(self.Word, self.bf.read(self.WordSize))[0] |
| self.e_ehsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_phentsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_phnum = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shentsize = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shnum = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| self.e_shstrndx = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0] |
| |
| def parse_sections(self): |
| self.bf.seek(self.e_shoff) |
| self.sections = [] |
| for i in range(self.e_shnum): |
| self.sections.append(SectionHeader(self.bf, self.ptrsize, self.is_le)) |
| |
| def read_str(self): |
| arr = [] |
| x = self.bf.read(1) |
| while x != b'\0': |
| arr.append(x) |
| x = self.bf.read(1) |
| if x == b'': |
| raise RuntimeError('Tried to read past the end of the file') |
| return b''.join(arr) |
| |
| def find_section(self, target_name): |
| section_names = self.sections[self.e_shstrndx] |
| for i in self.sections: |
| self.bf.seek(section_names.sh_offset + i.sh_name) |
| name = self.read_str() |
| if name == target_name: |
| return i |
| |
| def parse_dynamic(self): |
| sec = self.find_section(b'.dynamic') |
| self.dynamic = [] |
| if sec is None: |
| return |
| self.bf.seek(sec.sh_offset) |
| while True: |
| e = DynamicEntry(self.bf, self.ptrsize, self.is_le) |
| self.dynamic.append(e) |
| if e.d_tag == 0: |
| break |
| |
| def print_section_names(self): |
| section_names = self.sections[self.e_shstrndx] |
| for i in self.sections: |
| self.bf.seek(section_names.sh_offset + i.sh_name) |
| name = self.read_str() |
| print(name.decode()) |
| |
| def print_soname(self): |
| soname = None |
| strtab = None |
| for i in self.dynamic: |
| if i.d_tag == DT_SONAME: |
| soname = i |
| if i.d_tag == DT_STRTAB: |
| strtab = i |
| if soname is None or strtab is None: |
| print("This file does not have a soname") |
| return |
| self.bf.seek(strtab.val + soname.val) |
| print(self.read_str()) |
| |
| def get_entry_offset(self, entrynum): |
| sec = self.find_section(b'.dynstr') |
| for i in self.dynamic: |
| if i.d_tag == entrynum: |
| return sec.sh_offset + i.val |
| return None |
| |
| def print_rpath(self): |
| offset = self.get_entry_offset(DT_RPATH) |
| if offset is None: |
| print("This file does not have an rpath.") |
| else: |
| self.bf.seek(offset) |
| print(self.read_str()) |
| |
| def print_runpath(self): |
| offset = self.get_entry_offset(DT_RUNPATH) |
| if offset is None: |
| print("This file does not have a runpath.") |
| else: |
| self.bf.seek(offset) |
| print(self.read_str()) |
| |
| def print_deps(self): |
| sec = self.find_section(b'.dynstr') |
| deps = [] |
| for i in self.dynamic: |
| if i.d_tag == DT_NEEDED: |
| deps.append(i) |
| for i in deps: |
| offset = sec.sh_offset + i.val |
| self.bf.seek(offset) |
| name = self.read_str() |
| print(name) |
| |
| def fix_deps(self, prefix): |
| sec = self.find_section(b'.dynstr') |
| deps = [] |
| for i in self.dynamic: |
| if i.d_tag == DT_NEEDED: |
| deps.append(i) |
| for i in deps: |
| offset = sec.sh_offset + i.val |
| self.bf.seek(offset) |
| name = self.read_str() |
| if name.startswith(prefix): |
| basename = name.split(b'/')[-1] |
| padding = b'\0' * (len(name) - len(basename)) |
| newname = basename + padding |
| assert(len(newname) == len(name)) |
| self.bf.seek(offset) |
| self.bf.write(newname) |
| |
| def fix_rpath(self, new_rpath): |
| # The path to search for can be either rpath or runpath. |
| # Fix both of them to be sure. |
| self.fix_rpathtype_entry(new_rpath, DT_RPATH) |
| self.fix_rpathtype_entry(new_rpath, DT_RUNPATH) |
| |
| def fix_rpathtype_entry(self, new_rpath, entrynum): |
| if isinstance(new_rpath, str): |
| new_rpath = new_rpath.encode('utf8') |
| rp_off = self.get_entry_offset(entrynum) |
| if rp_off is None: |
| if self.verbose: |
| print('File does not have rpath. It should be a fully static executable.') |
| return |
| self.bf.seek(rp_off) |
| old_rpath = self.read_str() |
| if len(old_rpath) < len(new_rpath): |
| sys.exit("New rpath must not be longer than the old one.") |
| # The linker does read-only string deduplication. If there is a |
| # string that shares a suffix with the rpath, they might get |
| # dedupped. This means changing the rpath string might break something |
| # completely unrelated. This has already happened once with X.org. |
| # Thus we want to keep this change as small as possible to minimize |
| # the chance of obliterating other strings. It might still happen |
| # but our behavior is identical to what chrpath does and it has |
| # been in use for ages so based on that this should be rare. |
| if not new_rpath: |
| self.remove_rpath_entry(entrynum) |
| else: |
| self.bf.seek(rp_off) |
| self.bf.write(new_rpath) |
| self.bf.write(b'\0') |
| |
| def remove_rpath_entry(self, entrynum): |
| sec = self.find_section(b'.dynamic') |
| if sec is None: |
| return None |
| for (i, entry) in enumerate(self.dynamic): |
| if entry.d_tag == entrynum: |
| rpentry = self.dynamic[i] |
| rpentry.d_tag = 0 |
| self.dynamic = self.dynamic[:i] + self.dynamic[i + 1:] + [rpentry] |
| break |
| # DT_MIPS_RLD_MAP_REL is relative to the offset of the tag. Adjust it consequently. |
| for entry in self.dynamic[i:]: |
| if entry.d_tag == DT_MIPS_RLD_MAP_REL: |
| entry.val += 2 * (self.ptrsize // 8) |
| break |
| self.bf.seek(sec.sh_offset) |
| for entry in self.dynamic: |
| entry.write(self.bf) |
| return None |
| |
| def run(args): |
| if len(args) < 1 or len(args) > 2: |
| print('This application resets target rpath.') |
| print('Don\'t run this unless you know what you are doing.') |
| print('%s: <binary file> <prefix>' % sys.argv[0]) |
| sys.exit(1) |
| with Elf(args[0]) as e: |
| if len(args) == 1: |
| e.print_rpath() |
| e.print_runpath() |
| else: |
| new_rpath = args[1] |
| e.fix_rpath(new_rpath) |
| return 0 |
| |
| if __name__ == '__main__': |
| run(sys.argv[1:]) |
