Eh.py

from Header import Header
from elf.Utils import *

# ELF header
class Eh(Header):

    org = 0x400000

    def getOrg(self):
        return self.org

    def retrieve(self, binList, offset = 0):
        self.resetPos(offset)

        self.set('magic',      self.getMagic(binList))
        self.set('type',       self.getWord(binList))
        self.set('machine',    self.getWord(binList))
        self.set('version',    self.getDw(binList))
        self.set('entry_addr', self.getQw(binList))
        self.set('ph_offset',  self.getQw(binList))
        self.set('sh_offset',  self.getQw(binList))
        self.set('flags',      self.getDw(binList))
        self.set('eh_size',    self.getWord(binList))
        self.set('ph_size',    self.getWord(binList))
        self.set('ph_num',     self.getWord(binList))
        self.set('sh_size',    self.getWord(binList))
        self.set('sh_num',     self.getWord(binList))
        self.set('shstrndx',   self.getWord(binList))

    def getMagic(self, binList):
        self.resetPos(self.pos + 16)
        return binList[0:16]

    def output(self):
        r = []
        r += self.get('magic')
        r += convLE(self.get('type'),       2)
        r += convLE(self.get('machine'),    2)
        r += convLE(self.get('version'),    4)
        r += convLE(self.get('entry_addr'), 8)
        r += convLE(self.get('ph_offset'),  8)
        r += convLE(self.get('sh_offset'),  8)
        r += convLE(self.get('flags'),      4)
        r += convLE(self.get('eh_size'),    2)
        r += convLE(self.get('ph_size'),    2)
        r += convLE(self.get('ph_num'),     2)
        r += convLE(self.get('sh_size'),    2)
        r += convLE(self.get('sh_num'),     2)
        r += convLE(self.get('shstrndx'),   2)

        return r

Header.py

from elf.Utils import *

class Header(object):

    def __init__(self):
        self.contents = {}
        self.pos = 0

    def set(self, key, val):
        self.contents[key] = val

    def get(self, key):
        return self.contents[key]

    def resetPos(self, pos):
        self.pos = pos

    # bs: bytesize
    def fetch(self, bs, byteList):
        r = convBin(byteList[self.pos:self.pos+bs])
        self.pos += bs

        return r

    def getByte(self, byteList):
        return self.fetch(1, byteList)

    def getWord(self, byteList):
        return self.fetch(2, byteList)

    def getDw(self, byteList):
        return self.fetch(4, byteList)

    def getQw(self, byteList):
        return self.fetch(8, byteList)

    def retrieve(self):
        raise('method retrieve() has to implement individualy')

Section.py

class Section(object):

    def __init__(self, byteList, name, sh):
        self.byteList = byteList
        self.name = name
        self.sh = sh

    def getBodyList(self):
        return self.byteList

    def getName(self):
        return self.name

    def getSh(self):
        return self.sh

    def setBodyList(self, byteList):
        self.byteList = byteList

    def setName(self, name):
        self.name = name

    def setSh(self, sh):
        self.sh = sh

    def setAddr(self, addr):
        None    # implement later

    # method for debug
    def echo(self):
        lm = lambda n: (n, hex(n))

        try:
            print('====== Section Header(%s) ======' % self.name)
        except AttributeError:
            print('====== Section Header(no name setting) ====')

        print('name_index:      %s' % self.sh.get('name_index'))
        print('type:            %s' % self.sh.get('type'))
        print('flag:            %s' % self.sh.get('flag'))
        print('address:         %s(%s)' % lm(self.sh.get('address')))
        print('offset:          %s(%s)' % lm(self.sh.get('offset')))
        print('size:            %s(%s)' % lm(self.sh.get('size')))
        print('link:            %s' % self.sh.get('link'))
        print('info:            %s' % self.sh.get('info'))
        print('address_align:   %s' % self.sh.get('address_align'))
        print('entry_table_size:%s' % self.sh.get('entry_table_size'))

SectionAggregator.py

class SectionAggregator(object):

    def __init__(self):
        self.sectionList = []

    def append(self, section):
        self.sectionList.append(section)

    def count(self):
        return len(self.sectionList)

    def dump(self):
        for sec in self.sectionList:
            sec.echo()

Sh.py

from Header import Header
from elf.Utils import *

# section header
class Sh(Header):

    def __init__(self):
        Header.__init__(self)
        self.contents = {
            'name_index'    : 0,
            'type'          : 0,
            'flag'          : 0,
            'address'       : 0,
            'offset'        : 0,
            'size'          : 0,
            'link'          : 0,
            'info'          : 0,
            'address_align' : 0,
            'entry_table_size': 0,
        }

    def retrieve(self, byteList, offset = 0):
        self.resetPos(offset)

        self.set('name_index',         self.getDw(byteList))
        self.set('type',               self.getDw(byteList))
        self.set('flag',               self.getQw(byteList))
        self.set('address',            self.getQw(byteList))
        self.set('offset',             self.getQw(byteList))
        self.set('size',               self.getQw(byteList))
        self.set('link',               self.getDw(byteList))
        self.set('info',               self.getDw(byteList))
        self.set('address_align',      self.getQw(byteList))
        self.set('entry_table_size',   self.getQw(byteList))

        return self

    def output(self):
        r = []
        r += convLE(self.get('name_index'),         4)
        r += convLE(self.get('type'),               4)
        r += convLE(self.get('flag'),               8)
        r += convLE(self.get('address'),            8)
        r += convLE(self.get('offset'),             8)
        r += convLE(self.get('size'),               8)
        r += convLE(self.get('link'),               4)
        r += convLE(self.get('info'),               4)
        r += convLE(self.get('address_align'),      8)
        r += convLE(self.get('entry_table_size'),   8)

        return r

Utils.py

# convert val of specified number of byte to
# little endian list inlucdes each byte
def convLE(val, byteNum):
    le = []
    for i in range(byteNum):
        le.append((val >> i*8) & 0xff)

    return le

# convert from list to little endian binary value
# regards list elements are single byte respectively
def convBin(li):
    b = 0
    for byte in reversed(li):
        b = (b << 8) | byte

    return b

def retrieveStr(shStr, index):
    s = shStr[index:]
    return s[:s.find("\0")]