path: root/dependency/elf_parser.py

#!/usr/bin/env python
#
# Copyright (C) 2017 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.
#

import os
import struct


class ElfError(Exception):
    """The exception raised by ElfParser."""
    pass


class ElfParser(object):
    """The class reads information from an ELF file.

    Attributes:
        _file: The ELF file object.
        _file_size: Size of the ELF.
        bitness: Bitness of the ELF.
        _address_size: Size of address or offset in the ELF.
        _offsets: Offset of each entry in the ELF.
        _seek_read_address: The function to read an address or offset entry
                            from the ELF.
        _sh_offset: Offset of section header table in the file.
        _sh_size: Size of section header table entry.
        _sh_count: Number of section header table entries.
        _section_headers: List of SectionHeader objects read from the ELF.
    """
    _MAGIC_OFFSET = 0
    _MAGIC_BYTES = b"\x7fELF"
    _BITNESS_OFFSET = 4
    _BITNESS_32 = 1
    _BITNESS_64 = 2
    # Section type
    _SHT_DYNAMIC = 6
    # Tag in dynamic section
    _DT_NULL = 0
    _DT_NEEDED = 1
    _DT_STRTAB = 5

    class ElfOffsets32(object):
        """Offset of each entry in 32-bit ELF"""
        # offset from ELF header
        SECTION_HEADER_OFFSET = 0x20
        SECTION_HEADER_SIZE = 0x2e
        SECTION_HEADER_COUNT = 0x30
        # offset from section header
        SECTION_TYPE = 0x04
        SECTION_ADDRESS = 0x0c
        SECTION_OFFSET = 0x10

    class ElfOffsets64(object):
        """Offset of each entry in 64-bit ELF"""
        # offset from ELF header
        SECTION_HEADER_OFFSET = 0x28
        SECTION_HEADER_SIZE = 0x3a
        SECTION_HEADER_COUNT = 0x3c
        # offset from section header
        SECTION_TYPE = 0x04
        SECTION_ADDRESS = 0x10
        SECTION_OFFSET = 0x18

    class SectionHeader(object):
        """Contains section header entries as attributes.

        Attributes:
            type: Type of the section.
            address: The virtual memory address where the section is loaded.
            offset: The offset of the section in the ELF file.
        """
        def __init__(self, type, address, offset):
            self.type = type
            self.address = address
            self.offset = offset

    def __init__(self, file_path):
        """Creates a parser to open and read an ELF file.

        Args:
            file_path: The path to the ELF.

        Raises:
            ElfError if the file is not a valid ELF.
        """
        try:
            self._file = open(file_path, "rb")
        except IOError as e:
            raise ElfError(e)
        try:
            self._loadElfHeader()
            self._section_headers = [
                    self._loadSectionHeader(self._sh_offset + i * self._sh_size)
                    for i in range(self._sh_count)]
        except:
            self._file.close()
            raise

    def __del__(self):
        """Closes the ELF file."""
        self.close()

    def close(self):
        """Closes the ELF file."""
        self._file.close()

    def _seekRead(self, offset, read_size):
        """Reads a byte string at specific offset in the file.

        Args:
            offset: An integer, the offset from the beginning of the file.
            read_size: An integer, number of bytes to read.

        Returns:
            A byte string which is the file content.

        Raises:
            ElfError if fails to seek and read.
        """
        if offset + read_size > self._file_size:
            raise ElfError("Read beyond end of file.")
        try:
            self._file.seek(offset)
            return self._file.read(read_size)
        except IOError as e:
            raise ElfError(e)

    def _seekRead8(self, offset):
        """Reads an 1-byte integer from file."""
        return struct.unpack("B", self._seekRead(offset, 1))[0]

    def _seekRead16(self, offset):
        """Reads a 2-byte integer from file."""
        return struct.unpack("H", self._seekRead(offset, 2))[0]

    def _seekRead32(self, offset):
        """Reads a 4-byte integer from file."""
        return struct.unpack("I", self._seekRead(offset, 4))[0]

    def _seekRead64(self, offset):
        """Reads an 8-byte integer from file."""
        return struct.unpack("Q", self._seekRead(offset, 8))[0]

    def _seekReadString(self, offset):
        """Reads a null-terminated string starting from specific offset.

        Args:
            offset: The offset from the beginning of the file.

        Returns:
            A byte string, excluding the null character.
        """
        ret = ""
        buf_size = 16
        self._file.seek(offset)
        while True:
            try:
                buf = self._file.read(buf_size)
            except IOError as e:
                raise ElfError(e)
            end_index = buf.find('\0')
            if end_index < 0:
                ret += buf
            else:
                ret += buf[:end_index]
                return ret
            if len(buf) != buf_size:
                raise ElfError("Null-terminated string reaches end of file.")

    def _loadElfHeader(self):
        """Loads ElfHeader and initializes attributes"""
        try:
            self._file_size = os.fstat(self._file.fileno()).st_size
        except OSError as e:
            raise ElfError(e)

        magic = self._seekRead(self._MAGIC_OFFSET, 4)
        if magic != self._MAGIC_BYTES:
            raise ElfError("Wrong magic bytes.")
        bitness = self._seekRead8(self._BITNESS_OFFSET)
        if bitness == self._BITNESS_32:
            self.bitness = 32
            self._address_size = 4
            self._offsets = self.ElfOffsets32
            self._seek_read_address = self._seekRead32
        elif bitness == self._BITNESS_64:
            self.bitness = 64
            self._address_size = 8
            self._offsets = self.ElfOffsets64
            self._seek_read_address = self._seekRead64
        else:
            raise ElfError("Wrong bitness value.")

        self._sh_offset = self._seek_read_address(
                self._offsets.SECTION_HEADER_OFFSET)
        self._sh_size = self._seekRead16(self._offsets.SECTION_HEADER_SIZE)
        self._sh_count = self._seekRead16(self._offsets.SECTION_HEADER_COUNT)
        return True

    def _loadSectionHeader(self, offset):
        """Loads a section header from ELF file.

        Args:
            offset: The starting offset of the section header.

        Returns:
            An instance of SectionHeader.
        """
        return self.SectionHeader(
                self._seekRead32(offset + self._offsets.SECTION_TYPE),
                self._seek_read_address(offset + self._offsets.SECTION_ADDRESS),
                self._seek_read_address(offset + self._offsets.SECTION_OFFSET))

    def _loadDtNeeded(self, offset):
        """Reads DT_NEEDED entries from dynamic section.

        Args:
            offset: The offset of the dynamic section from the beginning of
                    the file

        Returns:
            A list of strings, the names of libraries.
        """
        strtab_address = None
        name_offsets = []
        while True:
            tag = self._seek_read_address(offset)
            offset += self._address_size
            value = self._seek_read_address(offset)
            offset += self._address_size

            if tag == self._DT_NULL:
                break
            if tag == self._DT_NEEDED:
                name_offsets.append(value)
            if tag == self._DT_STRTAB:
                strtab_address = value

        if strtab_address is None:
            raise ElfError("Cannot find string table offset in dynamic section")

        try:
            strtab_offset = next(x.offset for x in self._section_headers
                                 if x.address == strtab_address)
        except StopIteration:
            raise ElfError("Cannot find dynamic string table.")

        names = [self._seekReadString(strtab_offset + x)
                 for x in name_offsets]
        return names

    def listDependencies(self):
        """Lists the shared libraries that the ELF depends on.

        Returns:
            A list of strings, the names of the depended libraries.
        """
        deps = []
        for sh in self._section_headers:
            if sh.type == self._SHT_DYNAMIC:
                deps.extend(self._loadDtNeeded(sh.offset))
        return deps