blob: acb2da2d2536003150bac474dd190de87e238e8a [file] [log] [blame]
# elftools: elf/
# ELF relocations
# Eli Bendersky (
# This code is in the public domain
from collections import namedtuple
from ..common.exceptions import ELFRelocationError
from ..common.utils import elf_assert, struct_parse
from .sections import Section
from .enums import ENUM_RELOC_TYPE_i386, ENUM_RELOC_TYPE_x64
class Relocation(object):
""" Relocation object - representing a single relocation entry. Allows
dictionary-like access to the entry's fields.
Can be either a REL or RELA relocation.
def __init__(self, entry, elffile):
self.entry = entry
self.elffile = elffile
def is_RELA(self):
""" Is this a RELA relocation? If not, it's REL.
return 'r_addend' in self.entry
def __getitem__(self, name):
""" Dict-like access to entries
return self.entry[name]
def __repr__(self):
return '<Relocation (%s): %s>' % (
'RELA' if self.is_RELA() else 'REL',
def __str__(self):
return self.__repr__()
class RelocationSection(Section):
""" ELF relocation section. Serves as a collection of Relocation entries.
def __init__(self, header, name, stream, elffile):
super(RelocationSection, self).__init__(header, name, stream)
self.elffile = elffile
self.elfstructs = self.elffile.structs
if self.header['sh_type'] == 'SHT_REL':
expected_size = self.elfstructs.Elf_Rel.sizeof()
self.entry_struct = self.elfstructs.Elf_Rel
elif self.header['sh_type'] == 'SHT_RELA':
expected_size = self.elfstructs.Elf_Rela.sizeof()
self.entry_struct = self.elfstructs.Elf_Rela
elf_assert(False, 'Unknown relocation type section')
self.header['sh_entsize'] == expected_size,
'Expected sh_entsize of SHT_REL section to be %s' % expected_size)
def is_RELA(self):
""" Is this a RELA relocation section? If not, it's REL.
return self.header['sh_type'] == 'SHT_RELA'
def num_relocations(self):
""" Number of relocations in the section
return self['sh_size'] // self['sh_entsize']
def get_relocation(self, n):
""" Get the relocation at index #n from the section (Relocation object)
entry_offset = self['sh_offset'] + n * self['sh_entsize']
entry = struct_parse(
return Relocation(entry, self.elffile)
def iter_relocations(self):
""" Yield all the relocations in the section
for i in range(self.num_relocations()):
yield self.get_relocation(i)
class RelocationHandler(object):
""" Handles the logic of relocations in ELF files.
def __init__(self, elffile):
self.elffile = elffile
def find_relocations_for_section(self, section):
""" Given a section, find the relocation section for it in the ELF
file. Return a RelocationSection object, or None if none was
reloc_section_names = (
'.rel' +,
'.rela' +
# Find the relocation section aimed at this one. Currently assume
# that either .rel or .rela section exists for this section, but
# not both.
for relsection in self.elffile.iter_sections():
if ( isinstance(relsection, RelocationSection) and in reloc_section_names):
return relsection
return None
def apply_section_relocations(self, stream, reloc_section):
""" Apply all relocations in reloc_section (a RelocationSection object)
to the given stream, that contains the data of the section that is
being relocated. The stream is modified as a result.
# The symbol table associated with this relocation section
symtab = self.elffile.get_section(reloc_section['sh_link'])
for reloc in reloc_section.iter_relocations():
self._do_apply_relocation(stream, reloc, symtab)
def _do_apply_relocation(self, stream, reloc, symtab):
# Preparations for performing the relocation: obtain the value of
# the symbol mentioned in the relocation, as well as the relocation
# recipe which tells us how to actually perform it.
# All peppered with some sanity checking.
if reloc['r_info_sym'] >= symtab.num_symbols():
raise ELFRelocationError(
'Invalid symbol reference in relocation: index %s' % (
sym_value = symtab.get_symbol(reloc['r_info_sym'])['st_value']
reloc_type = reloc['r_info_type']
recipe = None
if self.elffile.get_machine_arch() == 'x86':
if reloc.is_RELA():
raise ELFRelocationError(
'Unexpected RELA relocation for x86: %s' % reloc)
recipe = self._RELOCATION_RECIPES_X86.get(reloc_type, None)
elif self.elffile.get_machine_arch() == 'x64':
if not reloc.is_RELA():
raise ELFRelocationError(
'Unexpected REL relocation for x64: %s' % reloc)
recipe = self._RELOCATION_RECIPES_X64.get(reloc_type, None)
if recipe is None:
raise ELFRelocationError(
'Unsupported relocation type: %s' % reloc_type)
# So now we have everything we need to actually perform the relocation.
# Let's get to it:
# 0. Find out which struct we're going to be using to read this value
# from the stream and write it back.
if recipe.bytesize == 4:
value_struct = self.elffile.structs.Elf_word('')
elif recipe.bytesize == 8:
value_struct = self.elffile.structs.Elf_word64('')
raise ELFRelocationError('Invalid bytesize %s for relocation' %
# 1. Read the value from the stream (with correct size and endianness)
original_value = struct_parse(
# 2. Apply the relocation to the value, acting according to the recipe
relocated_value = recipe.calc_func(
addend=reloc['r_addend'] if recipe.has_addend else 0)
# 3. Write the relocated value back into the stream['r_offset'])
value_struct.build_stream(relocated_value, stream)
# Relocations are represented by "recipes". Each recipe specifies:
# bytesize: The number of bytes to read (and write back) to the section.
# This is the unit of data on which relocation is performed.
# has_addend: Does this relocation have an extra addend?
# calc_func: A function that performs the relocation on an extracted
# value, and returns the updated value.
'bytesize has_addend calc_func')
def _reloc_calc_identity(value, sym_value, offset, addend=0):
return value
def _reloc_calc_sym_plus_value(value, sym_value, offset, addend=0):
return sym_value + value
def _reloc_calc_sym_plus_value_pcrel(value, sym_value, offset, addend=0):
return sym_value + value - offset
def _reloc_calc_sym_plus_addend(value, sym_value, offset, addend=0):
return sym_value + addend
bytesize=4, has_addend=False, calc_func=_reloc_calc_identity),
bytesize=4, has_addend=False,
bytesize=4, has_addend=False,
bytesize=8, has_addend=True, calc_func=_reloc_calc_identity),
bytesize=8, has_addend=True, calc_func=_reloc_calc_sym_plus_addend),
bytesize=4, has_addend=True, calc_func=_reloc_calc_sym_plus_addend),
bytesize=4, has_addend=True, calc_func=_reloc_calc_sym_plus_addend),