Sanitize ELF Sections API

ELF Sections are kinda 1-indexed in that while there is a Section 0,
it is always of type SHT_NULL and is otherwise invalid to reference.
Further, later ELF extensions have re-used these unused bits for
extensions, notably for ELF files with more than 0xff00 sections.
This patch does the following:

- Prevents section 0 from being returned by "Sections", since it isn't
  actually a real section and treating it as such would be incorrect
  if the section header stores extension data (before it just doesn't
  make a difference)
- As a result indices into `Sections` now actually match the ELF section
  number rather than being off by one.
- For good measure, implement the ELF large sections extension and add
  a test to make sure we can handle a file with as many sections.

Author: Keno

src/ELF/ELFHandle.jl

@@ -35,7 +35,7 @@ function readmeta(io::IO, ::Type{H}) where {H <: ELFHandle}
     start = position(io)
 
     # Check for magic bytes
-    magic = [read(io, UInt8) for idx in 1:4]    
+    magic = [read(io, UInt8) for idx in 1:4]
     if any(magic .!= elven_magic)
         msg = """
         Magic Number 0x$(join(string.(magic, base=16),"")) does not match expected ELF
@@ -78,7 +78,11 @@ mangle_symbol_name(oh::ELFHandle, name::AbstractString) = name
 format_string(::Type{H}) where {H <: ELFHandle} = "ELF"
 
 # Section information
-section_header_offset(oh::ELFHandle) = header(oh).e_shoff
+
+# The section entry at index 0 is SHN_UNDEF of section type SHT_NULL. It is not
+# a real section and may actually contain extension data. Do not return it to
+# avoid confusion clients
+section_header_offset(oh::ELFHandle) = header(oh).e_shoff + section_header_size(oh)
 section_header_size(oh::ELFHandle) = header(oh).e_shentsize
 function section_header_type(oh::H) where {H <: ELFHandle}
     if is64bit(oh)

src/ELF/ELFSection.jl

@@ -17,8 +17,18 @@ Sections(oh::ELFHandle) = ELFSections(oh)
 
 # Implement Sections API
 handle(sections::ELFSections) = sections.handle
-lastindex(sections::ELFSections) = header(handle(sections)).e_shnum
-
+function lastindex(sections::ELFSections)
+    head = header(handle(sections))
+    head.e_shoff == 0 && return 0
+    if head.e_shnum == 0
+        # Large section extension. Number of sections is actually stored in the
+        # sh_size field of the undef section
+        seek(handle(sections), head.e_shoff)
+        return unpack(handle(sections), section_header_type(handle(sections))).sh_size - 1
+    end
+    # Exclude the SHT_NULL section
+    return head.e_shnum - 1
+end
 
 """
     ELFSection

src/ELF/ELFStrTab.jl

@@ -21,7 +21,7 @@ struct ELFStrTab{H <: ELFHandle} <: StrTab{H}
             """)
             @warn(replace(msg, "\n" => " "), key=(handle(section), section_idx))
         end
-        
+
         return new(section)
     end
 end
@@ -59,10 +59,17 @@ construct an `StrTab` object from.  The returned value is an index (e.g. it is
 1-based, not zero-based as the value within the ELF object itself).
 """
 function section_header_strtab_index(oh::ELFHandle)
-    return header(oh).e_shstrndx + 1
+    head = header(oh)
+    if head.e_shoff != 0 && head.e_shnum == 0
+        # ELF Large Sections extension. Actual strtab index is the sh_link
+        # field of the SHN_UNDEF section
+        seek(oh, head.e_shoff)
+        return unpack(oh, section_header_type(oh)).sh_link
+    end
+    return head.e_shstrndx
 end
 
 function strtab_lookup(strtab::ELFStrTab, index)
     seek(strtab.section_ref, index)
     return strip(readuntil(handle(strtab), '\0'), '\0')
-end
+end