Refactoring linker

lib/caotral/binary/elf/header.rb

@@ -48,6 +48,7 @@ def set!(type: nil, arch: nil, entry: nil, phoffset: nil, shoffset: nil, shnum:
 
         def entry = @entry.pack("C*").unpack1("Q<")
         def ehsize = @ehsize.pack("C*").unpack1("S<")
+        def phoffset = @phoffset.pack("C*").unpack1("Q<")
         def phsize = @phsize.pack("C*").unpack1("S<")
         def phnum = @phnum.pack("C*").unpack1("S<")
         def shentsize = @shentsize.pack("C*").unpack1("S<")

lib/caotral/binary/elf/program_header.rb

@@ -24,6 +24,7 @@ class ProgramHeader
           LOAD: 1,
           DYNAMIC: 2,
           INTERP: 3,
+          PHDR: 6,
         }.freeze
         PT_BY_V = PT.invert.freeze
         def initialize
@@ -54,6 +55,7 @@ def flags = PF_BY_V[@flags.pack("C*").unpack1("L<")]
         def offset = @offset.pack("C*").unpack1("Q<")
         def filesz = @filesz.pack("C*").unpack1("Q<")
         def memsz = @memsz.pack("C*").unpack1("Q<")
+        def vaddr = @vaddr.pack("C*").unpack1("Q<")
 
         private def bytes = [@type, @flags, @offset, @vaddr, @paddr, @filesz, @memsz, @align]
       end

lib/caotral/binary/elf/reader.rb

@@ -139,6 +139,61 @@ def read
           @input.close
         end
 
+        def validate_relocations
+          rela_dyn = @context.sections.find { |section| section.section_name.to_s == ".rela.dyn" }
+          pt_load = @context.program_headers.find { |ph| ph.type == :LOAD }
+          dynamic = @context.sections.find { |section| section.section_name.to_s == ".dynamic" }
+          rela_plt = @context.sections.find { |section| section.section_name.to_s == ".rela.plt" }
+          got_plt = @context.sections.find { |s| s.section_name.to_s == ".got.plt" }
+          failed_messages = []
+          unless rela_dyn && pt_load && dynamic
+            data = [
+              rela_dyn ? nil : ".rela.dyn section",
+              pt_load ? nil : "LOAD program header",
+              dynamic ? nil : ".dynamic section"
+            ].compact.join(", ")
+            raise Caotral::Binary::ELF::Error, "Missing required relocations inputs: #{data}"
+          end
+          addr = rela_dyn.header.addr
+          size = rela_dyn.header.size
+          dynamic.body.each do |dyn|
+            val = nil
+            val = addr if dyn.rela?
+            val = size if dyn.rela_size?
+            val = 24 if dyn.rela_ent?
+            next unless val
+            if dyn.un != val
+              failed_messages << "Invalid dynamic section entry: expected #{val}, got #{dyn.un}"
+            end
+          end
+
+          valid_range = (pt_load.vaddr...(pt_load.vaddr + pt_load.memsz))
+          unless rela_dyn.body.all? { |rel| valid_range.include?(rel.offset) }
+            failed_messages << "Relocation entries in .rela.dyn exceed LOAD segment range"
+          end
+
+          if rela_plt
+            jump_rel = dynamic.body.find { |dt| dt.jmp_rel? }&.un == rela_plt.header.addr
+            plt_rel_size = dynamic.body.find { |dt| dt.plt_rel_size? }&.un == rela_plt.header.size
+            plt_rel = dynamic.body.find { |dt| dt.plt_rel? }&.un == 7
+            plt_got = dynamic.body.find { |dt| dt.plt_got? }&.un == got_plt.header.addr if got_plt
+            basemsg = "Dynamic section entry"
+            failed_messages << "#{basemsg} DT_JMPREL does not match .rela.plt address" unless jump_rel
+            failed_messages << "#{basemsg} DT_PLTRELSZ does not match .rela.plt size" unless plt_rel_size
+            failed_messages << "#{basemsg} DT_PLTREL does not indicate RELA type" unless plt_rel
+            failed_messages << "#{basemsg} DT_PLTGOT does not match .got.plt address" if got_plt && !plt_got
+
+            rela_plt.body.each do |rel|
+              vr = valid_range.include?(rel.offset)
+              js = rel.type_name == :AMD64_JUMP_SLOT
+              failed_messages << "Relocation entries in .rela.plt exceed LOAD segment range" unless vr
+              failed_messages << "Unexpected relocation type in .rela.plt: #{rel.type_name}" unless js
+            end
+          end
+          raise Caotral::Binary::ELF::Error, failed_messages.join("\n") unless failed_messages.empty?
+          true
+        end
+
         private
         def decision(input)
           case input
@@ -148,8 +203,6 @@ def decision(input)
             raise ArgumentError, "wrong input type"
           end
         end
-
-        def type(num) = Caotral::Binary::ELF::SectionHeader::SHT_BY_VALUE.fetch(num, :unknown)
       end
     end
   end

lib/caotral/binary/elf/section.rb

@@ -9,6 +9,13 @@ def initialize(header:, body:, section_name:)
           @body = body
           @section_name = section_name
         end
+
+        def build
+          return @body.build if @body.respond_to?(:build)
+          return @body.each_with_object(StringIO.new) { |b, io| io.write(b.build) }.string if @body.is_a?(Array)
+          return @body if @body.is_a?(String)
+          "".b
+        end
       end
     end
   end

lib/caotral/binary/elf/section/dynamic.rb

@@ -7,6 +7,8 @@ class Dynamic
           include Caotral::Binary::ELF::Utils
           TAG_TYPES = {
             NULL: 0,
+            PLTRELSZ: 2,
+            PLTGOT: 3,
             HASH: 4,
             STRTAB: 5,
             SYMTAB: 6,
@@ -15,7 +17,9 @@ class Dynamic
             RELAENT: 9,
             STRSZ: 10,
             SYMENT: 11,
+            PLTREL: 20,
             TEXTREL: 22,
+            JMPREL: 23,
           }.freeze
           TAG_TYPES_BY_V = TAG_TYPES.invert.freeze
 
@@ -33,7 +37,15 @@ def set!(tag: nil, un: nil)
           end
 
           def tag = @tag.pack("C*").unpack1("Q<")
+          def un = @un.pack("C*").unpack1("Q<")
           def null? = tag == TAG_TYPES[:NULL]
+          def rela? = tag == TAG_TYPES[:RELA]
+          def rela_size? = tag == TAG_TYPES[:RELASZ]
+          def rela_ent? = tag == TAG_TYPES[:RELAENT]
+          def jmp_rel? = tag == TAG_TYPES[:JMPREL]
+          def plt_rel? = tag == TAG_TYPES[:PLTREL]
+          def plt_rel_size? = tag == TAG_TYPES[:PLTRELSZ]
+          def plt_got? = tag == TAG_TYPES[:PLTGOT]
 
           private def bytes = [@tag, @un]
         end

lib/caotral/binary/elf/section/rel.rb

@@ -13,6 +13,11 @@ class Rel
             AMD64_PLT32: 4,
             AMD64_COPY: 5,
             AMD64_GLOB_DAT: 6,
+            AMD64_JUMP_SLOT: 7,
+            AMD64_RELATIVE: 8,
+            AMD64_GOTPCREL: 9,
+            AMD64_GOTPCRELX: 41,
+            AMD64_REX_GOTPCRELX: 42,
           }.freeze
           TYPES_BY_V = TYPES.invert.freeze
 

lib/caotral/linker/builder.rb

@@ -5,17 +5,19 @@ module Caotral
   class Linker
     class Builder
       include Caotral::Binary::ELF::Utils
-      R_X86_64_64 = 1
-      R_X86_64_PC32 = 2
-      R_X86_64_PLT32 = 4
-      R_X86_64_RELATIVE = 8
+      REL_TYPES = Caotral::Binary::ELF::Section::Rel::TYPES
       SYMTAB_BIND = { locals: 0, globals: 1, weaks: 2, }.freeze
       BIND_BY_VALUE = SYMTAB_BIND.invert.freeze
       RELOCATION_SECTION_NAMES = [".rela.text", ".rel.text", ".rela.data", ".rel.data"].freeze
-      ALLOW_RELOCATION_TYPES = [R_X86_64_PC32, R_X86_64_PLT32].freeze
-      GENERATED_SECTION_NAMES = [".text", ".data", ".strtab", ".symtab", ".shstrtab", /\.rela?\./, ".dynstr", ".dynsym", ".dynamic", ".interp", ".rela.dyn"].freeze
+      ALLOW_RELOCATION_TYPES = [REL_TYPES[:AMD64_PC32], REL_TYPES[:AMD64_PLT32],].freeze
+      GENERATED_SECTION_NAMES = [".text", ".data", ".strtab", ".symtab", ".shstrtab", /\.rela?\./, ".dynstr", ".dynsym", ".dynamic", ".interp", ".rela.dyn", ".plt", ".got.plt"].freeze
       SHT = Caotral::Binary::ELF::SectionHeader::SHT
       SHF = Caotral::Binary::ELF::SectionHeader::SHF
+      UNSUPPORTED_REL_TYPES = [
+        REL_TYPES[:AMD64_GOTPCREL],
+        REL_TYPES[:AMD64_GOTPCRELX],
+        REL_TYPES[:AMD64_REX_GOTPCRELX],
+      ].freeze
 
       attr_reader :symbols
 
@@ -44,6 +46,25 @@ def build
           body: String.new,
           section_name: ".data",
           header: Caotral::Binary::ELF::SectionHeader.new
+                    .set!(type: SHT[:progbits], flags: SHF[:ALLOC] | SHF[:WRITE], addralign: 8)
+        )
+        plt_section = Caotral::Binary::ELF::Section.new(
+          body: [0, 0].pack("Q<Q<"),
+          section_name: ".plt",
+          header: Caotral::Binary::ELF::SectionHeader.new
+                    .set!(type: SHT[:progbits], flags: SHF[:ALLOC] | SHF[:EXECINSTR], addralign: 16)
+        )
+        got_plt_section = Caotral::Binary::ELF::Section.new(
+          body: [0].pack("Q<"),
+          section_name: ".got.plt",
+          header: Caotral::Binary::ELF::SectionHeader.new
+                    .set!(type: SHT[:progbits], flags: SHF[:ALLOC] | SHF[:WRITE], addralign: 8)
+        )
+        rela_plt_section = Caotral::Binary::ELF::Section.new(
+          body: [],
+          section_name: ".rela.plt",
+          header: Caotral::Binary::ELF::SectionHeader.new
+                    .set!(type: SHT[:rela], flags: SHF[:ALLOC], addralign: 8, entsize: 24)
         )
         strtab_section = Caotral::Binary::ELF::Section.new(
           body: Caotral::Binary::ELF::Section::Strtab.new("\0".b),
@@ -64,10 +85,9 @@ def build
           body: [],
           section_name: ".rela.dyn",
           header: Caotral::Binary::ELF::SectionHeader.new
+                    .set!(flags: SHF[:ALLOC], info: 0, addralign: 8)
         )
 
-        data_section.header.set!(type: SHT[:progbits], flags: SHF[:ALLOC] | SHF[:WRITE], addralign: 8)
-
         start_bytes = [0xe8, *[0] * 4, 0x48, 0x89, 0xc7, 0x48, 0xc7, 0xc0, 0x3c, 0x00, 0x00, 0x00, 0x0f, 0x05]
         exec_text_offset = 0x1000
         base_addr = 0x400000
@@ -84,9 +104,12 @@ def build
         strtab_names = []
         text_offsets = {}
         data_offsets = {}
+        got_plt_offsets = {}
         text_offset = 0
         data_offset = 0
+        got_plt_offset = 8
         sym_by_elf = Hash.new { |h, k| h[k] = [] }
+        dynstr, dynsym = build_shared_dynamic_sections if dynamic?
         @elf_objs.each do |elf_obj|
           text = elf_obj.find_by_name(".text")
           unless text.nil?
@@ -128,7 +151,7 @@ def build
               header: Caotral::Binary::ELF::SectionHeader.new
             )
             section.body.each do |rel|
-              if rel.type == R_X86_64_64
+              if rel.type == REL_TYPES[:AMD64_64]
                 base_offset = case section.section_name.to_s
                               when /\.rela?\.text/
                                 vaddr + start_len + text_offsets.fetch(elf_obj.object_id, 0)
@@ -146,8 +169,32 @@ def build
                              0
                            end
                 addend = sym_addr - base_addr
-                rela_dyn_section.body << Caotral::Binary::ELF::Section::Rel.new.set!(offset:, info: (0 << 32) | R_X86_64_RELATIVE, addend:)
+                rela_dyn_section.body << Caotral::Binary::ELF::Section::Rel.new.set!(offset:, info: (0 << 32) | REL_TYPES[:AMD64_RELATIVE], addend:)
                 next
+              elsif (undefined = symtab.body[rel.sym]&.shndx.to_i == 0) && rel.type == REL_TYPES[:AMD64_PLT32]
+                sym = base_index.to_i + rel.sym
+                first_insertion = got_plt_offsets[sym].nil?
+                got_plt_offsets[sym] ||= got_plt_offset.tap { got_plt_offset += 8 }
+                if dynamic? && undefined && first_insertion
+                    got_plt_section.body << [0].pack("Q<")
+                    rps = Caotral::Binary::ELF::Section::Rel.new.set!(
+                      offset: got_plt_offsets[sym],
+                      info: ((sym) << 32) | REL_TYPES[:AMD64_JUMP_SLOT]
+                    )
+                    name = symtab_section.body[sym].name_string
+                    dynstr_index = dynstr.body.offset_of(name)
+                    if dynstr_index.nil?
+                      dynstr.body.names += name + "\0"
+                      dynsym.body << Caotral::Binary::ELF::Section::Symtab.new.set!(
+                        name: dynstr.body.offset_of(name),
+                        info: (1 << 4) | 2,
+                      )
+                    end
+                    rela_plt_section.body << rps
+                    next
+                end
+              elsif UNSUPPORTED_REL_TYPES.include?(rel.type)
+                raise Caotral::Binary::ELF::Error, "unsupported relocation type: #{rel.type_name}"
               end
               offset = rel.offset + text_offsets.fetch(elf_obj.object_id, 0)
               addend = rel.addend? ? rel.addend : nil
@@ -161,6 +208,7 @@ def build
           end
           rel_sections += rels
         end
+
         strtab_section.body.names = strtab_names.to_a.sort.join("\0") + "\0"
         sections << null_section
 
@@ -182,6 +230,10 @@ def build
         sections << text_section
         strtab_section.header.set!(type: 3, flags: 0, addralign: 1, entsize: 0)
         sections << data_section
+        if dynamic?
+          sections << plt_section
+          sections << got_plt_section
+        end
         sections << strtab_section
         text_index = sections.index(text_section)
         symtab_section.body.each do |sym|
@@ -206,13 +258,14 @@ def build
 
         sections += build_pie_sections if @pie
         if dynamic?
-          dynstr, dynsym = build_shared_dynamic_sections
           sections << dynstr
           sections << dynsym
           sections << build_hash_section if @pie
           sections << rela_dyn_section
+          sections << rela_plt_section
           sym = sections.index(dynsym)
-          rela_dyn_section.header.set!(flags: SHF[:ALLOC], link: sym, type: rel_type(rela_dyn_section), info: 0, addralign: 8, entsize: rel_entsize(rela_dyn_section))
+          rela_dyn_section.header.set!(link: sym, type: rel_type(rela_dyn_section), entsize: rel_entsize(rela_dyn_section))
+          rela_plt_section.header.set!(link: sym, type: rel_type(rela_plt_section), info: ref_index(sections, got_plt_section.section_name))
           sections << build_dynamic_section
         end
         sections << symtab_section
@@ -226,10 +279,6 @@ def build
           entsize: 0
         )
 
-        @elf_objs.first.without_sections(GENERATED_SECTION_NAMES).each do |section|
-          sections << section.dup
-        end
-
         sections << shstrtab_section
 
         shstrtab_section_names = [*sections.map(&:section_name), "\0"].join("\0")
@@ -366,17 +415,21 @@ def build_dynamic_section
         tag_types = Caotral::Binary::ELF::Section::Dynamic::TAG_TYPES
         dynamic_section = Caotral::Binary::ELF::Section.new(
           body: [
-            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:HASH], un: 0),
-            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:RELA], un: 0),
-            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:RELASZ], un: 0),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:PLTRELSZ]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:PLTGOT]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:HASH]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:RELA]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:RELASZ]),
             Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:RELAENT], un: 24),
             Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:STRTAB]),
             Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:STRSZ]),
             Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:SYMTAB]),
             Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:SYMENT], un: 24),
-            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:TEXTREL], un: 0),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:PLTREL]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:TEXTREL]),
+            Caotral::Binary::ELF::Section::Dynamic.new.set!(tag: tag_types[:JMPREL]),
             Caotral::Binary::ELF::Section::Dynamic.new
-          ],
+          ].compact,
           section_name: ".dynamic",
           header: Caotral::Binary::ELF::SectionHeader.new
         )