Add elf parsing utility function (#33628)

Introduces `spack.util.elf.parse_elf(file_handle)`

4 files changed, 635 insertions, 46 deletions

diff --git a/lib/spack/spack/test/conftest.py b/lib/spack/spack/test/conftest.py
index 9ae346c720..1f3c17916c 100644
--- a/lib/spack/spack/test/conftest.py
+++ b/lib/spack/spack/test/conftest.py
@@ -1789,3 +1789,39 @@ def mock_spider_configs(mock_config_data, monkeypatch):
 @pytest.fixture(scope="function")
 def mock_tty_stdout(monkeypatch):
     monkeypatch.setattr(sys.stdout, "isatty", lambda: True)
+
+
+@pytest.fixture()
+def binary_with_rpaths(tmpdir):
+    """Factory fixture that compiles an ELF binary setting its RPATH. Relative
+    paths are encoded with `$ORIGIN` prepended.
+    """
+
+    def _factory(rpaths, message="Hello world!"):
+        source = tmpdir.join("main.c")
+        source.write(
+            """
+        #include <stdio.h>
+        int main(){{
+            printf("{0}");
+        }}
+        """.format(
+                message
+            )
+        )
+        gcc = spack.util.executable.which("gcc")
+        executable = source.dirpath("main.x")
+        # Encode relative RPATHs using `$ORIGIN` as the root prefix
+        rpaths = [x if os.path.isabs(x) else os.path.join("$ORIGIN", x) for x in rpaths]
+        rpath_str = ":".join(rpaths)
+        opts = [
+            "-Wl,--disable-new-dtags",
+            "-Wl,-rpath={0}".format(rpath_str),
+            str(source),
+            "-o",
+            str(executable),
+        ]
+        gcc(*opts)
+        return executable
+
+    return _factory
diff --git a/lib/spack/spack/test/relocate.py b/lib/spack/spack/test/relocate.py
index 4c9dd8be66..99dd7a460c 100644
--- a/lib/spack/spack/test/relocate.py
+++ b/lib/spack/spack/test/relocate.py
@@ -83,42 +83,6 @@ def mock_patchelf(tmpdir, mock_executable):
 
 
 @pytest.fixture()
-def hello_world(tmpdir):
-    """Factory fixture that compiles an ELF binary setting its RPATH. Relative
-    paths are encoded with `$ORIGIN` prepended.
-    """
-
-    def _factory(rpaths, message="Hello world!"):
-        source = tmpdir.join("main.c")
-        source.write(
-            """
-        #include <stdio.h>
-        int main(){{
-            printf("{0}");
-        }}
-        """.format(
-                message
-            )
-        )
-        gcc = spack.util.executable.which("gcc")
-        executable = source.dirpath("main.x")
-        # Encode relative RPATHs using `$ORIGIN` as the root prefix
-        rpaths = [x if os.path.isabs(x) else os.path.join("$ORIGIN", x) for x in rpaths]
-        rpath_str = ":".join(rpaths)
-        opts = [
-            "-Wl,--disable-new-dtags",
-            "-Wl,-rpath={0}".format(rpath_str),
-            str(source),
-            "-o",
-            str(executable),
-        ]
-        gcc(*opts)
-        return executable
-
-    return _factory
-
-
-@pytest.fixture()
 def make_dylib(tmpdir_factory):
     """Create a shared library with unfriendly qualities.
 
@@ -315,9 +279,9 @@ def test_set_elf_rpaths_warning(mock_patchelf):
 
 @pytest.mark.requires_executables("patchelf", "strings", "file", "gcc")
 @skip_unless_linux
-def test_replace_prefix_bin(hello_world):
+def test_replace_prefix_bin(binary_with_rpaths):
     # Compile an "Hello world!" executable and set RPATHs
-    executable = hello_world(rpaths=["/usr/lib", "/usr/lib64"])
+    executable = binary_with_rpaths(rpaths=["/usr/lib", "/usr/lib64"])
 
     # Relocate the RPATHs
     spack.relocate._replace_prefix_bin(str(executable), {b"/usr": b"/foo"})
@@ -328,9 +292,9 @@ def test_replace_prefix_bin(hello_world):
 
 @pytest.mark.requires_executables("patchelf", "strings", "file", "gcc")
 @skip_unless_linux
-def test_relocate_elf_binaries_absolute_paths(hello_world, copy_binary, tmpdir):
+def test_relocate_elf_binaries_absolute_paths(binary_with_rpaths, copy_binary, tmpdir):
     # Create an executable, set some RPATHs, copy it to another location
-    orig_binary = hello_world(rpaths=[str(tmpdir.mkdir("lib")), "/usr/lib64"])
+    orig_binary = binary_with_rpaths(rpaths=[str(tmpdir.mkdir("lib")), "/usr/lib64"])
     new_binary = copy_binary(orig_binary)
 
     spack.relocate.relocate_elf_binaries(
@@ -350,9 +314,9 @@ def test_relocate_elf_binaries_absolute_paths(hello_world, copy_binary, tmpdir):
 
 @pytest.mark.requires_executables("patchelf", "strings", "file", "gcc")
 @skip_unless_linux
-def test_relocate_elf_binaries_relative_paths(hello_world, copy_binary):
+def test_relocate_elf_binaries_relative_paths(binary_with_rpaths, copy_binary):
     # Create an executable, set some RPATHs, copy it to another location
-    orig_binary = hello_world(rpaths=["lib", "lib64", "/opt/local/lib"])
+    orig_binary = binary_with_rpaths(rpaths=["lib", "lib64", "/opt/local/lib"])
     new_binary = copy_binary(orig_binary)
 
     spack.relocate.relocate_elf_binaries(
@@ -371,8 +335,8 @@ def test_relocate_elf_binaries_relative_paths(hello_world, copy_binary):
 
 @pytest.mark.requires_executables("patchelf", "strings", "file", "gcc")
 @skip_unless_linux
-def test_make_elf_binaries_relative(hello_world, copy_binary, tmpdir):
-    orig_binary = hello_world(
+def test_make_elf_binaries_relative(binary_with_rpaths, copy_binary, tmpdir):
+    orig_binary = binary_with_rpaths(
         rpaths=[str(tmpdir.mkdir("lib")), str(tmpdir.mkdir("lib64")), "/opt/local/lib"]
     )
     new_binary = copy_binary(orig_binary)
@@ -393,8 +357,8 @@ def test_raise_if_not_relocatable(monkeypatch):
 
 @pytest.mark.requires_executables("patchelf", "strings", "file", "gcc")
 @skip_unless_linux
-def test_relocate_text_bin(hello_world, copy_binary, tmpdir):
-    orig_binary = hello_world(
+def test_relocate_text_bin(binary_with_rpaths, copy_binary, tmpdir):
+    orig_binary = binary_with_rpaths(
         rpaths=[str(tmpdir.mkdir("lib")), str(tmpdir.mkdir("lib64")), "/opt/local/lib"],
         message=str(tmpdir),
     )
diff --git a/lib/spack/spack/test/util/elf.py b/lib/spack/spack/test/util/elf.py
new file mode 100644
index 0000000000..cf6b3aeb27
--- /dev/null
+++ b/lib/spack/spack/test/util/elf.py
@@ -0,0 +1,130 @@
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+
+import io
+
+import pytest
+
+import llnl.util.filesystem as fs
+
+import spack.platforms
+import spack.util.elf as elf
+import spack.util.executable
+
+
+# note that our elf parser is platform independent... but I guess creating an elf file
+# is slightly more difficult with system tools on non-linux.
+def skip_unless_linux(f):
+    return pytest.mark.skipif(
+        str(spack.platforms.real_host()) != "linux",
+        reason="implementation currently requires linux",
+    )(f)
+
+
+@pytest.mark.requires_executables("gcc")
+@skip_unless_linux
+def test_elf_get_rpaths(binary_with_rpaths):
+    # Compile an "Hello world!" executable and set RPATHs
+    long_rpaths = ["/very/long/prefix/x", "/very/long/prefix/y"]
+    executable = str(binary_with_rpaths(rpaths=long_rpaths))
+    assert elf.get_rpaths(executable) == long_rpaths
+
+
+@pytest.mark.requires_executables("gcc")
+@skip_unless_linux
+@pytest.mark.parametrize(
+    "linker_flag,is_runpath",
+    [
+        ("-Wl,--disable-new-dtags", False),
+        ("-Wl,--enable-new-dtags", True),
+    ],
+)
+def test_elf_parsing_shared_linking(linker_flag, is_runpath, tmpdir):
+    gcc = spack.util.executable.which("gcc")
+
+    with fs.working_dir(str(tmpdir)):
+        # Create a library to link to so we can force a dynamic section in an ELF file
+        with open("foo.c", "w") as f:
+            f.write("int foo(){return 0;}")
+        with open("bar.c", "w") as f:
+            f.write("int foo(); int _start(){return foo();}")
+
+        # Create library and executable linking to it.
+        gcc("-shared", "-o", "libfoo.so", "-Wl,-soname,libfoo.so.1", "-nostdlib", "foo.c")
+        gcc(
+            "-o",
+            "bar",
+            linker_flag,
+            "-Wl,-rpath,/first",
+            "-Wl,-rpath,/second",
+            "-Wl,--no-as-needed",
+            "-nostdlib",
+            "libfoo.so",
+            "bar.c",
+            "-o",
+            "bar",
+        )
+
+        with open("libfoo.so", "rb") as f:
+            foo_parsed = elf.parse_elf(f, interpreter=True, dynamic_section=True)
+
+        assert not foo_parsed.has_pt_interp
+        assert foo_parsed.has_pt_dynamic
+        assert not foo_parsed.has_rpath
+        assert not foo_parsed.has_needed
+        assert foo_parsed.has_soname
+        assert foo_parsed.dt_soname_str == b"libfoo.so.1"
+
+        with open("bar", "rb") as f:
+            bar_parsed = elf.parse_elf(f, interpreter=True, dynamic_section=True)
+
+        assert bar_parsed.has_pt_interp
+        assert bar_parsed.has_pt_dynamic
+        assert bar_parsed.has_rpath
+        assert bar_parsed.has_needed
+        assert not bar_parsed.has_soname
+        assert bar_parsed.dt_rpath_str == b"/first:/second"
+        assert bar_parsed.dt_needed_strs == [b"libfoo.so.1"]
+
+
+def test_broken_elf():
+    # No elf magic
+    with pytest.raises(elf.ElfParsingError, match="Not an ELF file"):
+        elf.parse_elf(io.BytesIO(b"x"))
+
+    # Incomplete ELF header
+    with pytest.raises(elf.ElfParsingError, match="Not an ELF file"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF"))
+
+    # Invalid class
+    with pytest.raises(elf.ElfParsingError, match="Invalid class"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF\x09\x01" + b"\x00" * 10))
+
+    # Invalid data type
+    with pytest.raises(elf.ElfParsingError, match="Invalid data type"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF\x01\x09" + b"\x00" * 10))
+
+    # 64-bit needs at least 64 bytes of header; this is only 56 bytes
+    with pytest.raises(elf.ElfParsingError, match="ELF header malformed"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF\x02\x01" + b"\x00" * 50))
+
+    # 32-bit needs at least 52 bytes of header; this is only 46 bytes
+    with pytest.raises(elf.ElfParsingError, match="ELF header malformed"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF\x01\x01" + b"\x00" * 40))
+
+    # Not a ET_DYN/ET_EXEC on a 32-bit LE ELF
+    with pytest.raises(elf.ElfParsingError, match="Not an ET_DYN or ET_EXEC"):
+        elf.parse_elf(io.BytesIO(b"\x7fELF\x01\x01" + (b"\x00" * 10) + b"\x09" + (b"\x00" * 35)))
+
+
+def test_parser_doesnt_deal_with_nonzero_offset():
+    # Currently we don't have logic to parse ELF files at nonzero offsets in a file
+    # This could be useful when e.g. modifying an ELF file inside a tarball or so,
+    # but currently we cannot.
+    elf_at_offset_one = io.BytesIO(b"\x00\x7fELF\x01\x01" + b"\x00" * 10)
+    elf_at_offset_one.read(1)
+    with pytest.raises(elf.ElfParsingError, match="Cannot parse at a nonzero offset"):
+        elf.parse_elf(elf_at_offset_one)
diff --git a/lib/spack/spack/util/elf.py b/lib/spack/spack/util/elf.py
new file mode 100644
index 0000000000..bb9bfbb22d
--- /dev/null
+++ b/lib/spack/spack/util/elf.py
@@ -0,0 +1,459 @@
+# Copyright 2013-2021 Lawrence Livermore National Security, LLC and other
+# Spack Project Developers. See the top-level COPYRIGHT file for details.
+#
+# SPDX-License-Identifier: (Apache-2.0 OR MIT)
+
+import bisect
+import struct
+import sys
+from collections import namedtuple
+from struct import calcsize, unpack, unpack_from
+
+ElfHeader = namedtuple(
+    "ElfHeader",
+    [
+        "e_type",
+        "e_machine",
+        "e_version",
+        "e_entry",
+        "e_phoff",
+        "e_shoff",
+        "e_flags",
+        "e_ehsize",
+        "e_phentsize",
+        "e_phnum",
+        "e_shentsize",
+        "e_shnum",
+        "e_shstrndx",
+    ],
+)
+
+SectionHeader = namedtuple(
+    "SectionHeader",
+    [
+        "sh_name",
+        "sh_type",
+        "sh_flags",
+        "sh_addr",
+        "sh_offset",
+        "sh_size",
+        "sh_link",
+        "sh_info",
+        "sh_addralign",
+        "sh_entsize",
+    ],
+)
+
+ProgramHeader32 = namedtuple(
+    "ProgramHeader32",
+    [
+        "p_type",
+        "p_offset",
+        "p_vaddr",
+        "p_paddr",
+        "p_filesz",
+        "p_memsz",
+        "p_flags",
+        "p_align",
+    ],
+)
+
+ProgramHeader64 = namedtuple(
+    "ProgramHeader64",
+    [
+        "p_type",
+        "p_flags",
+        "p_offset",
+        "p_vaddr",
+        "p_paddr",
+        "p_filesz",
+        "p_memsz",
+        "p_align",
+    ],
+)
+
+
+class ELF_CONSTANTS:
+    MAGIC = b"\x7fELF"
+    CLASS32 = 1
+    CLASS64 = 2
+    DATA2LSB = 1
+    DATA2MSB = 2
+    ET_EXEC = 2
+    ET_DYN = 3
+    PT_LOAD = 1
+    PT_DYNAMIC = 2
+    PT_INTERP = 3
+    DT_NULL = 0
+    DT_NEEDED = 1
+    DT_STRTAB = 5
+    DT_SONAME = 14
+    DT_RPATH = 15
+    DT_RUNPATH = 29
+    SHT_STRTAB = 3
+
+
+def get_byte_at(byte_array, idx):
+    if sys.version_info[0] < 3:
+        return ord(byte_array[idx])
+    return byte_array[idx]
+
+
+class ElfParsingError(Exception):
+    pass
+
+
+class ElfFile(object):
+    """Parsed ELF file."""
+
+    __slots__ = [
+        "is_64_bit",
+        "is_little_endian",
+        "byte_order",
+        "elf_hdr",
+        "pt_load",
+        # pt_interp
+        "has_pt_interp",
+        "pt_interp_p_offset",
+        "pt_interp_p_filesz",
+        "pt_interp_str",
+        # pt_dynamic
+        "has_pt_dynamic",
+        "pt_dynamic_p_offset",
+        "pt_dynamic_p_filesz",
+        # rpath
+        "has_rpath",
+        "dt_rpath_offset",
+        "dt_rpath_str",
+        "rpath_strtab_offset",
+        "is_runpath",
+        # dt needed
+        "has_needed",
+        "dt_needed_strtab_offsets",
+        "dt_needed_strs",
+        # dt soname
+        "has_soname",
+        "dt_soname_strtab_offset",
+        "dt_soname_str",
+    ]
+
+    def __init__(self):
+        self.dt_needed_strtab_offsets = []
+        self.has_soname = False
+        self.has_rpath = False
+        self.has_needed = False
+        self.pt_load = []
+        self.has_pt_dynamic = False
+        self.has_pt_interp = False
+
+
+def parse_c_string(byte_string, start=0):
+    """
+    Retrieve a C-string at a given offset in a byte string
+
+    Arguments:
+        byte_string (bytes): String
+        start (int): Offset into the string
+
+    Returns:
+        bytes: A copy of the C-string excluding the terminating null byte
+    """
+    str_end = byte_string.find(b"\0", start)
+    if str_end == -1:
+        raise ElfParsingError("C-string is not null terminated")
+    return byte_string[start:str_end]
+
+
+def read_exactly(f, num_bytes, msg):
+    """
+    Read exactly num_bytes at the current offset, otherwise raise
+    a parsing error with the given error message.
+
+    Arguments:
+        f: file handle
+        num_bytes (int): Number of bytes to read
+        msg (str): Error to show when bytes cannot be read
+
+    Returns:
+        bytes: the ``num_bytes`` bytes that were read.
+    """
+    data = f.read(num_bytes)
+    if len(data) != num_bytes:
+        raise ElfParsingError(msg)
+    return data
+
+
+def parse_program_headers(f, elf):
+    """
+    Parse program headers
+
+    Arguments:
+        f: file handle
+        elf (ElfFile): ELF file parser data
+    """
+    # Forward to the program header
+    f.seek(elf.elf_hdr.e_phoff)
+
+    # Here we have to make a mapping from virtual address to offset in the file.
+    ProgramHeader = ProgramHeader64 if elf.is_64_bit else ProgramHeader32
+    ph_fmt = elf.byte_order + ("LLQQQQQQ" if elf.is_64_bit else "LLLLLLLL")
+    ph_size = calcsize(ph_fmt)
+    ph_num = elf.elf_hdr.e_phnum
+
+    # Read all program headers in one go
+    data = read_exactly(f, ph_num * ph_size, "Malformed program header")
+
+    for i in range(ph_num):
+        ph = ProgramHeader._make(unpack_from(ph_fmt, data, i * ph_size))
+
+        # Skip segments of size 0; we don't distinguish between missing segment and
+        # empty segments. I've see an empty PT_DYNAMIC section for an ELF file that
+        # contained debug data.
+        if ph.p_filesz == 0:
+            continue
+
+        # For PT_LOAD entries: Save offsets and virtual addrs of the loaded ELF segments
+        # This way we can map offsets by virtual address to offsets in the file.
+        if ph.p_type == ELF_CONSTANTS.PT_LOAD:
+            elf.pt_load.append((ph.p_offset, ph.p_vaddr))
+
+        elif ph.p_type == ELF_CONSTANTS.PT_INTERP:
+            elf.pt_interp_p_offset = ph.p_offset
+            elf.pt_interp_p_filesz = ph.p_filesz
+            elf.has_pt_interp = True
+
+        elif ph.p_type == ELF_CONSTANTS.PT_DYNAMIC:
+            elf.pt_dynamic_p_offset = ph.p_offset
+            elf.pt_dynamic_p_filesz = ph.p_filesz
+            elf.has_pt_dynamic = True
+
+    # The linker sorts PT_LOAD segments by vaddr, but let's do it just to be sure, since
+    # patchelf for example has a flag to leave them in an arbitrary order.
+    elf.pt_load.sort(key=lambda x: x[1])
+
+
+def parse_pt_interp(f, elf):
+    """
+    Parse the interpreter (i.e. absolute path to the dynamic linker)
+
+    Arguments:
+        f: file handle
+        elf (ElfFile): ELF file parser data
+    """
+    f.seek(elf.pt_interp_p_offset)
+    data = read_exactly(f, elf.pt_interp_p_filesz, "Malformed PT_INTERP entry")
+    elf.pt_interp_str = parse_c_string(data)
+
+
+def find_strtab_size_at_offset(f, elf, offset):
+    """
+    Retrieve the size of a string table section at a particular known offset
+
+    Arguments:
+        f: file handle
+        elf (ElfFile): ELF file parser data
+        offset (int): offset of the section in the file (i.e. ``sh_offset``)
+
+    Returns:
+        int: the size of the string table in bytes
+    """
+    section_hdr_fmt = elf.byte_order + ("LLQQQQLLQQ" if elf.is_64_bit else "LLLLLLLLLL")
+    section_hdr_size = calcsize(section_hdr_fmt)
+    f.seek(elf.elf_hdr.e_shoff)
+    for _ in range(elf.elf_hdr.e_shnum):
+        data = read_exactly(f, section_hdr_size, "Malformed section header")
+        sh = SectionHeader._make(unpack(section_hdr_fmt, data))
+        if sh.sh_type == ELF_CONSTANTS.SHT_STRTAB and sh.sh_offset == offset:
+            return sh.sh_size
+
+    raise ElfParsingError("Could not determine strtab size")
+
+
+def retrieve_strtab(f, elf, offset):
+    """
+    Read a full string table at the given offset, which
+    requires looking it up in the section headers.
+
+    Arguments:
+        elf (ElfFile): ELF file parser data
+        vaddr (int): virtual address
+
+    Returns:
+        bytes: file offset
+    """
+    size = find_strtab_size_at_offset(f, elf, offset)
+    f.seek(offset)
+    return read_exactly(f, size, "Could not read string table")
+
+
+def vaddr_to_offset(elf, vaddr):
+    """
+    Given a virtual address, find the corresponding offset in the ELF file itself.
+
+    Arguments:
+        elf (ElfFile): ELF file parser data
+        vaddr (int): virtual address
+    """
+    idx = bisect.bisect_right([p_vaddr for (p_offset, p_vaddr) in elf.pt_load], vaddr) - 1
+    p_offset, p_vaddr = elf.pt_load[idx]
+    return p_offset - p_vaddr + vaddr
+
+
+def parse_pt_dynamic(f, elf):
+    """
+    Parse the dynamic section of an ELF file
+
+    Arguments:
+        f: file handle
+        elf (ElfFile): ELF file parse data
+    """
+    dynamic_array_fmt = elf.byte_order + ("qQ" if elf.is_64_bit else "lL")
+    dynamic_array_size = calcsize(dynamic_array_fmt)
+
+    current_offset = elf.pt_dynamic_p_offset
+    count_rpath = 0
+    count_runpath = 0
+    count_strtab = 0
+
+    f.seek(elf.pt_dynamic_p_offset)
+
+    # In case of broken ELF files, don't read beyond the advertized size.
+    for _ in range(elf.pt_dynamic_p_filesz // dynamic_array_size):
+        data = read_exactly(f, dynamic_array_size, "Malformed dynamic array entry")
+        tag, val = unpack(dynamic_array_fmt, data)
+        if tag == ELF_CONSTANTS.DT_NULL:
+            break
+        elif tag == ELF_CONSTANTS.DT_RPATH:
+            count_rpath += 1
+            elf.rpath_strtab_offset = val
+            elf.dt_rpath_offset = current_offset
+            elf.is_runpath = False
+            elf.has_rpath = True
+        elif tag == ELF_CONSTANTS.DT_RUNPATH:
+            count_runpath += 1
+            elf.rpath_strtab_offset = val
+            elf.dt_rpath_offset = current_offset
+            elf.is_runpath = True
+            elf.has_rpath = True
+        elif tag == ELF_CONSTANTS.DT_STRTAB:
+            count_strtab += 1
+            strtab_vaddr = val
+        elif tag == ELF_CONSTANTS.DT_NEEDED:
+            elf.has_needed = True
+            elf.dt_needed_strtab_offsets.append(val)
+        elif tag == ELF_CONSTANTS.DT_SONAME:
+            elf.has_soname = True
+            elf.dt_soname_strtab_offset = val
+        current_offset += dynamic_array_size
+
+    # No rpath/runpath, that happens.
+    if count_rpath == count_runpath == 0:
+        elf.has_rpath = False
+    elif count_rpath + count_runpath != 1:
+        raise ElfParsingError("Could not find a unique rpath/runpath.")
+
+    if count_strtab != 1:
+        raise ElfParsingError("Could not find a unique strtab of for the dynamic section strings")
+
+    # Nothing to retrieve, so don't bother getting the string table.
+    if not (elf.has_rpath or elf.has_soname or elf.has_needed):
+        return
+
+    string_table = retrieve_strtab(f, elf, vaddr_to_offset(elf, strtab_vaddr))
+
+    if elf.has_needed:
+        elf.dt_needed_strs = list(
+            parse_c_string(string_table, offset) for offset in elf.dt_needed_strtab_offsets
+        )
+
+    if elf.has_soname:
+        elf.dt_soname_str = parse_c_string(string_table, elf.dt_soname_strtab_offset)
+
+    if elf.has_rpath:
+        elf.dt_rpath_str = parse_c_string(string_table, elf.rpath_strtab_offset)
+
+
+def parse_header(f, elf):
+    # Read the 32/64 bit class independent part of the header and validate
+    e_ident = f.read(16)
+
+    # Require ELF magic bytes.
+    if len(e_ident) != 16 or e_ident[:4] != ELF_CONSTANTS.MAGIC:
+        raise ElfParsingError("Not an ELF file")
+
+    # Defensively require a valid class and data.
+    e_ident_class, e_ident_data = get_byte_at(e_ident, 4), get_byte_at(e_ident, 5)
+
+    if e_ident_class not in (ELF_CONSTANTS.CLASS32, ELF_CONSTANTS.CLASS64):
+        raise ElfParsingError("Invalid class found")
+
+    if e_ident_data not in (ELF_CONSTANTS.DATA2LSB, ELF_CONSTANTS.DATA2MSB):
+        raise ElfParsingError("Invalid data type")
+
+    elf.is_64_bit = e_ident_class == ELF_CONSTANTS.CLASS64
+    elf.is_little_endian = e_ident_data == ELF_CONSTANTS.DATA2LSB
+
+    # Set up byte order and types for unpacking
+    elf.byte_order = "<" if elf.is_little_endian else ">"
+
+    # Parse the rest of the header
+    elf_header_fmt = elf.byte_order + ("HHLQQQLHHHHHH" if elf.is_64_bit else "HHLLLLLHHHHHH")
+    hdr_size = calcsize(elf_header_fmt)
+    data = read_exactly(f, hdr_size, "ELF header malformed")
+    elf.elf_hdr = ElfHeader._make(unpack(elf_header_fmt, data))
+
+
+def _do_parse_elf(f, interpreter=True, dynamic_section=True):
+    # We don't (yet?) allow parsing ELF files at a nonzero offset, we just
+    # jump to absolute offsets as they are specified in the ELF file.
+    if f.tell() != 0:
+        raise ElfParsingError("Cannot parse at a nonzero offset")
+
+    elf = ElfFile()
+    parse_header(f, elf)
+
+    # We don't handle anything but executables and shared libraries now.
+    if elf.elf_hdr.e_type not in (ELF_CONSTANTS.ET_EXEC, ELF_CONSTANTS.ET_DYN):
+        raise ElfParsingError("Not an ET_DYN or ET_EXEC type")
+
+    parse_program_headers(f, elf)
+
+    # Parse PT_INTERP section
+    if interpreter and elf.has_pt_interp:
+        parse_pt_interp(f, elf)
+
+    # Parse PT_DYNAMIC section.
+    if dynamic_section and elf.has_pt_dynamic and len(elf.pt_load) > 0:
+        parse_pt_dynamic(f, elf)
+
+    return elf
+
+
+def parse_elf(f, interpreter=False, dynamic_section=False):
+    """Given a file handle f for an ELF file opened in binary mode, return an ElfFile
+    object that is stores data about rpaths"""
+    try:
+        return _do_parse_elf(f, interpreter, dynamic_section)
+    except (DeprecationWarning, struct.error):
+        # According to the docs old versions of Python can throw DeprecationWarning
+        # instead of struct.error.
+        raise ElfParsingError("Malformed ELF file")
+
+
+def get_rpaths(path):
+    """Returns list of rpaths of the given file as UTF-8 strings, or None if the file
+    does not have any rpaths."""
+    try:
+        with open(path, "rb") as f:
+            elf = parse_elf(f, interpreter=False, dynamic_section=True)
+    except ElfParsingError:
+        return None
+
+    if not elf.has_rpath:
+        return None
+
+    # If it does, split the string in components
+    rpath = elf.dt_rpath_str
+    if sys.version_info[0] >= 3:
+        rpath = rpath.decode("utf-8")
+    return rpath.split(":")