patchelf 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e432d8ac7a3e75e8c9e80d433bc756e635d6b4d057b7e02ed952be113c7edbf5
-  data.tar.gz: 463cee3d6e780346706752f2a537e67fde649db82b206a8d79f15e60dd4cb4ae
+  metadata.gz: d0268e11ae1f743826ab85b81245876d13ec987f4bf9b530f399260447b939aa
+  data.tar.gz: f8fca7603e33bdea3d44c328076a64a37172d61c49d1fd7a7915fe5b4d9ddba3
 SHA512:
-  metadata.gz: bebe4cca89632d3660045d7582c19cf356562d2cbd389cc910377e88ea293c4fb812bb8917e89670cad05224254497c361f608e7429dcfe2c09ed94d31834a9f
-  data.tar.gz: 849a0a0b5b8c5bc1c1e52c4f65c9452917f58cf881bca89de4a4986df0556fd677724fe1b17466ff469eed8bcada2320d69169951d9ea0ac4aed1d9be6e4d5aa
+  metadata.gz: 462df528984a4f51efb4f9b0f589b0378ff4b28a1008357c0f7b7b4cdaa4a41739402c3821cc6b06a1dccd7292e02c1f2e1d9513a7926e9708b56e0abc66ba84
+  data.tar.gz: acddd987c408cf26dc323a6873d5db81aba3635ffba5e9eb6a3d4ca76f2d0d5cfe395739073f0594307274be756e5f270b162cbc952ac5d4797672b321ddeb5f

data/README.md

@@ -12,19 +12,34 @@ Implements features of NixOS/patchelf in pure Ruby.
 
 ## Installation
 
-WIP.
+Available on RubyGems.org!
+```
+$ gem install patchelf
+```
 
 ## Usage
 
 ```
 $ patchelf.rb
 # Usage: patchelf.rb <commands> FILENAME [OUTPUT_FILE]
-#         --pi, --print-interpreter    Show interpreter's name.
-#         --pn, --print-needed         Show needed libraries specified in DT_NEEDED.
-#         --ps, --print-soname         Show soname specified in DT_SONAME.
-#         --interp, --set-interpreter INTERP
+#         --print-interpreter, --pi    Show interpreter's name.
+#         --print-needed, --pn         Show needed libraries specified in DT_NEEDED.
+#         --print-runpath, --pr        Show the path specified in DT_RUNPATH.
+#         --print-soname, --ps         Show soname specified in DT_SONAME.
+#         --set-interpreter, --interp INTERP
 #                                      Set interpreter's name.
-#         --so, --set-soname SONAME    Set name of a shared library.
+#         --set-needed, --needed LIB1,LIB2,LIB3
+#                                      Set needed libraries, this will remove all existent needed libraries.
+#         --add-needed LIB             Append a new needed library.
+#         --remove-needed LIB          Remove a needed library.
+#         --replace-needed LIB1,LIB2   Replace needed library LIB1 as LIB2.
+#         --set-runpath, --runpath PATH
+#                                      Set the path of runpath.
+#         --force-rpath                According to the ld.so docs, DT_RPATH is obsolete,
+#                                      patchelf.rb will always try to get/set DT_RUNPATH first.
+#                                      Use this option to force every operations related to runpath (e.g. --runpath)
+#                                      to consider 'DT_RPATH' instead of 'DT_RUNPATH'.
+#         --set-soname, --so SONAME    Set name of a shared library.
 #         --version                    Show current gem's version.
 
 ```
@@ -32,8 +47,8 @@ $ patchelf.rb
 ### Display information
 ```
 $ patchelf.rb --print-interpreter --print-needed /bin/ls
-# Interpreter: /lib64/ld-linux-x86-64.so.2
-# Needed: libselinux.so.1 libc.so.6
+# interpreter: /lib64/ld-linux-x86-64.so.2
+# needed: libselinux.so.1 libc.so.6
 
 ```
 
@@ -47,11 +62,54 @@ $ file ls.patch
 
 ```
 
+### Modify dependency libraries
+
+#### Add
+```
+$ patchelf.rb --add-needed libnew.so /bin/ls ls.patch
+```
+
+#### Remove
+```
+$ patchelf.rb --remove-needed libc.so.6 /bin/ls ls.patch
+```
+
+#### Replace
+```
+$ patchelf.rb --replace-needed libc.so.6,libcnew.so.6 /bin/ls ls.patch
+
+$ readelf -d ls.patch | grep NEEDED
+#  0x0000000000000001 (NEEDED)             Shared library: [libselinux.so.1]
+#  0x0000000000000001 (NEEDED)             Shared library: [libcnew.so.6]
+
+```
+
+#### Set directly
+```
+$ patchelf.rb --needed a.so,b.so,c.so /bin/ls ls.patch
+
+$ readelf -d ls.patch | grep NEEDED
+#  0x0000000000000001 (NEEDED)             Shared library: [a.so]
+#  0x0000000000000001 (NEEDED)             Shared library: [b.so]
+#  0x0000000000000001 (NEEDED)             Shared library: [c.so]
+
+```
+
+### Set RUNPATH of an executable
+```
+$ patchelf.rb --runpath . /bin/ls ls.patch
+
+$ readelf -d ls.patch | grep RUNPATH
+#  0x000000000000001d (RUNPATH)            Library runpath: [.]
+
+```
+
 ### Change SONAME of a shared library
 ```
-$ patchelf.rb --soname libnewname.so.217 /lib/x86_64-linux-gnu/libc.so.6 ./libc.patched
+$ patchelf.rb --so libc.so.217 /lib/x86_64-linux-gnu/libc.so.6 libc.patch
 
-$ readelf -d libc.patched | grep SONAME
+$ readelf -d libc.patch | grep SONAME
+#  0x000000000000000e (SONAME)             Library soname: [libc.so.217]
 
 ```
 
@@ -60,11 +118,11 @@ $ readelf -d libc.patched | grep SONAME
 require 'patchelf'
 
 patcher = PatchELF::Patcher.new('/bin/ls')
-patcher.get(:interpreter)
+patcher.interpreter
 #=> "/lib64/ld-linux-x86-64.so.2"
 
 patcher.interpreter = '/lib/AAAA.so.2'
-patcher.get(:interpreter)
+patcher.interpreter
 #=> "/lib/AAAA.so.2"
 
 patcher.save('ls.patch')

data/bin/patchelf.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'patchelf/cli'
 

data/lib/patchelf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Main module of patchelf.
 #
 # @author david942j

data/lib/patchelf/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'optparse'
 
 require 'patchelf/patcher'
@@ -25,25 +27,32 @@ module PatchELF
     def work(argv)
       @options = {
         set: {},
-        print: []
+        print: [],
+        needed: []
       }
       return $stdout.puts "PatchELF Version #{PatchELF::VERSION}" if argv.include?('--version')
       return $stdout.puts option_parser unless parse(argv)
 
       # Now the options are (hopefully) valid, let's process the ELF file.
       patcher = PatchELF::Patcher.new(@options[:in_file])
+      patcher.use_rpath! if @options[:force_rpath]
       # TODO: Handle ELFTools::ELFError
       @options[:print].uniq.each do |s|
-        content = patcher.get(s)
+        content = patcher.__send__(s)
         next if content.nil?
 
-        $stdout.puts "#{s.to_s.capitalize}: #{Array(content).join(' ')}"
+        s = :rpath if @options[:force_rpath] && s == :runpath
+        $stdout.puts "#{s}: #{Array(content).join(' ')}"
       end
 
       @options[:set].each do |sym, val|
         patcher.__send__("#{sym}=".to_sym, val)
       end
 
+      @options[:needed].each do |type, val|
+        patcher.__send__("#{type}_needed".to_sym, *val)
+      end
+
       patcher.save(@options[:out_file])
     end
 
@@ -62,23 +71,58 @@ module PatchELF
       @option_parser ||= OptionParser.new do |opts|
         opts.banner = USAGE
 
-        opts.on('--pi', '--print-interpreter', 'Show interpreter\'s name.') do
+        opts.on('--print-interpreter', '--pi', 'Show interpreter\'s name.') do
           @options[:print] << :interpreter
         end
 
-        opts.on('--pn', '--print-needed', 'Show needed libraries specified in DT_NEEDED.') do
+        opts.on('--print-needed', '--pn', 'Show needed libraries specified in DT_NEEDED.') do
           @options[:print] << :needed
         end
 
-        opts.on('--ps', '--print-soname', 'Show soname specified in DT_SONAME.') do
+        opts.on('--print-runpath', '--pr', 'Show the path specified in DT_RUNPATH.') do
+          @options[:print] << :runpath
+        end
+
+        opts.on('--print-soname', '--ps', 'Show soname specified in DT_SONAME.') do
           @options[:print] << :soname
         end
 
-        opts.on('--interp INTERP', '--set-interpreter INTERP', 'Set interpreter\'s name.') do |interp|
+        opts.on('--set-interpreter INTERP', '--interp INTERP', 'Set interpreter\'s name.') do |interp|
           @options[:set][:interpreter] = interp
         end
 
-        opts.on('--so SONAME', '--set-soname SONAME', 'Set name of a shared library.') do |soname|
+        opts.on('--set-needed LIB1,LIB2,LIB3', '--needed LIB1,LIB2,LIB3', Array,
+                'Set needed libraries, this will remove all existent needed libraries.') do |needs|
+          @options[:set][:needed] = needs
+        end
+
+        opts.on('--add-needed LIB', 'Append a new needed library.') do |lib|
+          @options[:needed] << [:add, lib]
+        end
+
+        opts.on('--remove-needed LIB', 'Remove a needed library.') do |lib|
+          @options[:needed] << [:remove, lib]
+        end
+
+        opts.on('--replace-needed LIB1,LIB2', Array, 'Replace needed library LIB1 as LIB2.') do |libs|
+          @options[:needed] << [:replace, libs]
+        end
+
+        opts.on('--set-runpath PATH', '--runpath PATH', 'Set the path of runpath.') do |path|
+          @options[:set][:runpath] = path
+        end
+
+        opts.on(
+          '--force-rpath',
+          'According to the ld.so docs, DT_RPATH is obsolete,',
+          "#{SCRIPT_NAME} will always try to get/set DT_RUNPATH first.",
+          'Use this option to force every operations related to runpath (e.g. --runpath)',
+          'to consider \'DT_RPATH\' instead of \'DT_RUNPATH\'.'
+        ) do
+          @options[:force_rpath] = true
+        end
+
+        opts.on('--set-soname SONAME', '--so SONAME', 'Set name of a shared library.') do |soname|
           @options[:set][:soname] = soname
         end
 

data/lib/patchelf/helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PatchELF
   # Helper methods for internal usage.
   module Helper
@@ -40,11 +42,11 @@ module PatchELF
     # @return [Integer]
     #   Aligned result.
     # @example
-    #   Helper.aligndown(0x1234)
+    #   aligndown(0x1234)
     #   #=> 4096
-    #   Helper.aligndown(0x33, 0x20)
+    #   aligndown(0x33, 0x20)
     #   #=> 32
-    #   Helper.aligndown(0x10, 0x8)
+    #   aligndown(0x10, 0x8)
     #   #=> 16
     def aligndown(val, align = PAGE_SIZE)
       val - (val & (align - 1))
@@ -55,11 +57,11 @@ module PatchELF
     # @return [Integer]
     #   Aligned result.
     # @example
-    #   Helper.alignup(0x1234)
+    #   alignup(0x1234)
     #   #=> 8192
-    #   Helper.alignup(0x33, 0x20)
+    #   alignup(0x33, 0x20)
     #   #=> 64
-    #   Helper.alignup(0x10, 0x8)
+    #   alignup(0x10, 0x8)
     #   #=> 16
     def alignup(val, align = PAGE_SIZE)
       (val & (align - 1)).zero? ? val : (aligndown(val, align) + align)

data/lib/patchelf/logger.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 require 'patchelf/helper'

data/lib/patchelf/mm.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'patchelf/helper'
-require 'patchelf/interval'
 
 module PatchELF
   # Memory management, provides malloc/free to allocate LOAD segments.
+  # @private
   class MM
-    attr_reader :extend_size # @return [Integer]
-    attr_reader :threshold # @return [Integer]
+    attr_reader :extend_size # @return [Integer] The size extended.
+    attr_reader :threshold # @return [Integer] Where the file start to be extended.
 
     # Instantiate a {MM} object.
     # @param [ELFTools::ELFFile] elf
@@ -21,7 +23,7 @@ module PatchELF
     # @yieldreturn [void]
     #   One can only do the following things in the block:
     #   1. Set ELF headers' attributes (with ELFTools)
-    #   2. Invoke {Patcher#inline_patch}
+    #   2. Invoke {Saver#inline_patch}
     def malloc(size, &block)
       # TODO: check size > 0
       @request << [size, block]
@@ -32,39 +34,21 @@ module PatchELF
     def dispatch!
       return if @request.empty?
 
-      request_size = @request.map(&:first).inject(0, :+)
-      # TODO: raise exception if no LOAD exists.
-
-      # We're going to expand the first LOAD segment.
-      # Sometimes there's a 'gap' between the first and the second LOAD segment,
-      # in this case we only need to expand the first LOAD segment and remain all other things unchanged.
-      if gap_useful?(request_size)
-        invoke_callbacks
-        grow_first_load(request_size)
-      elsif extendable?(request_size)
-        # After extended we should have large enough 'gap'.
-
-        # |  1  | |  2  |
-        # |  1  |        |  2  |
-        #=>
-        # |  1      | |  2  |
-        # |  1      |    |  2  |
-        # This is really dangerous..
-        # We have to check all p_offset / sh_offset
-        # 1. Use ELFTools to patch all headers
-        # 2. Mark the extended size, inline_patch will behave different after this.
-        # 3. Invoke block.call, which might copy tables and (not-allow-to-patch) strings into the gap
-
-        @threshold = load_segments[1].file_head
-        # 1.file_tail + request_size <= 2.file_head + 0x1000x
-        @extend_size = PatchELF::Helper.alignup(request_size - gap_between_load.size)
-        shift_attributes
-
-        invoke_callbacks
-        grow_first_load(request_size)
-        # else
-        # This can happen in 32bit
-      end
+      @request_size = @request.map(&:first).inject(0, :+)
+      # The malloc-ed area must be 'rw-' since the dynamic table will be modified during runtime.
+      # Find all LOADs and calculate their f-gaps and m-gaps.
+      # We prefer f-gap since it doesn't need move the whole binaries.
+      # 1. Find if any f-gap has enough size, and one of the LOAD next to it is 'rw-'.
+      #   - expand (forwardlly), only need to change the attribute of LOAD.
+      # 2. Do 1. again but consider m-gaps instead.
+      #   - expand (forwardlly), need to modify all section headers.
+      # 3. We have to create a new LOAD, now we need to expand the first LOAD for putting new segment header.
+
+      # First of all we check if there're less than two LOADs.
+      abnormal_elf('No LOAD segment found, not an executable.') if load_segments.empty?
+      # TODO: Handle only one LOAD. (be careful if memsz > filesz)
+
+      fgap_method || mgap_method || new_load_method
     end
 
     # Query if extended.
@@ -73,7 +57,11 @@ module PatchELF
       defined?(@threshold)
     end
 
+    # Get correct offset after the extension.
+    #
+    # @param [Integer] off
     # @return [Integer]
+    #   Shifted offset.
     def extended_offset(off)
       return off unless defined?(@threshold)
       return off if off < @threshold
@@ -83,37 +71,74 @@ module PatchELF
 
     private
 
-    def gap_useful?(need_size)
-      # Two conditions:
-      # 1. gap is large enough
-      gap = gap_between_load
-      return false if gap.size < need_size
+    def fgap_method
+      idx = find_gap { |prv, nxt| nxt.file_head - prv.file_tail }
+      return false if idx.nil?
+
+      loads = load_segments
+      # prefer extend backwardly
+      return extend_backward(loads[idx - 1]) if writable?(loads[idx - 1])
 
-      # XXX: Do we really need this..?
-      # If gap is enough but not all zeros, we will fail on extension..
-      # 2. gap is all zeroes.
-      # @elf.stream.pos = gap.head
-      # return false unless @elf.stream.read(gap.size).bytes.inject(0, :+).zero?
+      extend_forward(loads[idx])
+    end
+
+    def extend_backward(seg, size = @request_size)
+      invoke_callbacks(seg, seg.file_tail)
+      seg.header.p_filesz += size
+      seg.header.p_memsz += size
+      true
+    end
 
+    def extend_forward(seg, size = @request_size)
+      seg.header.p_offset -= size
+      seg.header.p_vaddr -= size
+      seg.header.p_filesz += size
+      seg.header.p_memsz += size
+      invoke_callbacks(seg, seg.file_head)
       true
     end
 
-    # @return [PatchELF::Interval]
-    def gap_between_load
-      # We need this cache since the second LOAD might be changed
-      return @gap_between_load if defined?(@gap_between_load)
+    def mgap_method
+      # |  1  | |  2  |
+      # |  1  |        |  2  |
+      #=>
+      # |  1      | |  2  |
+      # |  1      |    |  2  |
+      idx = find_gap(check_sz: false) { |prv, nxt| PatchELF::Helper.aligndown(nxt.mem_head) - prv.mem_tail }
+      return false if idx.nil?
 
-      loads = load_segments.map do |seg|
-        PatchELF::Interval.new(seg.file_head, seg.size)
+      loads = load_segments
+      @threshold = loads[idx].file_head
+      @extend_size = PatchELF::Helper.alignup(@request_size)
+      shift_attributes
+      # prefer backward than forward
+      return extend_backward(loads[idx - 1]) if writable?(loads[idx - 1])
+
+      # note: loads[idx].file_head has been changed in shift_attributes
+      extend_forward(loads[idx], @extend_size)
+    end
+
+    def find_gap(check_sz: true)
+      loads = load_segments
+      loads.each_with_index do |l, i|
+        next if i.zero?
+        next unless writable?(l) || writable?(loads[i - 1])
+
+        sz = yield(loads[i - 1], l)
+        abnormal_elf('LOAD segments are out of order.') if check_sz && sz.negative?
+        next unless sz >= @request_size
+
+        return i
       end
-      # TODO: raise if loads.min != loads.first
+      nil
+    end
+
+    def new_load_method
+      raise NotImplementedError
+    end
 
-      loads.sort!
-      # Only one LOAD, the gap has infinity size!
-      size = if loads.size == 1 then Float::INFINITY
-             else loads[1].head - loads.first.tail
-             end
-      @gap_between_load = PatchELF::Interval.new(loads.first.tail, size)
+    def writable?(seg)
+      seg.readable? && seg.writable?
     end
 
     # For all attributes >= threshold, += offset
@@ -123,14 +148,18 @@ module PatchELF
       #   all
       # Segments:
       #   all
-      # XXX: will be buggy if one day the number of segments might be changed.
+      # XXX: will be buggy if someday the number of segments can be changed.
 
       # Bottom-up
       @elf.each_sections do |sec|
         sec.header.sh_offset += extend_size if sec.header.sh_offset >= threshold
       end
       @elf.each_segments do |seg|
-        seg.header.p_offset += extend_size if seg.header.p_offset >= threshold
+        next unless seg.header.p_offset >= threshold
+
+        seg.header.p_offset += extend_size
+        # We have to change align of LOAD segment since ld.so checks it.
+        seg.header.p_align = Helper::PAGE_SIZE if seg.is_a?(ELFTools::Segments::LoadSegment)
       end
 
       @elf.header.e_shoff += extend_size if @elf.header.e_shoff >= threshold
@@ -140,28 +169,16 @@ module PatchELF
       @elf.segments_by_type(:load)
     end
 
-    def extendable?(request_size)
-      loads = load_segments
-      # We can assume loads.size >= 2 because
-      # 0: has raised an exception before
-      # 1: the gap must be used, nobody cares extendable size.
-      # Calcluate the max size of the first LOAD segment can be.
-      PatchELF::Helper.aligndown(loads[1].mem_head) - loads.first.mem_tail >= request_size
-    end
-
-    def invoke_callbacks
-      seg = load_segments.first
-      cur = gap_between_load.head
+    def invoke_callbacks(seg, start)
+      cur = start
       @request.each do |sz, block|
         block.call(cur, seg.offset_to_vma(cur))
         cur += sz
       end
     end
 
-    def grow_first_load(size)
-      seg = load_segments.first
-      seg.header.p_filesz += size
-      seg.header.p_memsz += size
+    def abnormal_elf(msg)
+      raise ArgumentError, msg
     end
   end
 end

data/lib/patchelf/patcher.rb

@@ -1,8 +1,10 @@
-require 'elftools'
-require 'fileutils'
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'elftools/elf_file'
 
 require 'patchelf/logger'
-require 'patchelf/mm'
+require 'patchelf/saver'
 
 module PatchELF
   # Class to handle all patching things.
@@ -17,6 +19,16 @@ module PatchELF
       @in_file = filename
       @elf = ELFTools::ELFFile.new(File.open(filename))
       @set = {}
+      @rpath_sym = :runpath
+    end
+
+    # @return [String?]
+    #   Get interpreter's name.
+    # @example
+    #   PatchELF::Patcher.new('/bin/ls').interpreter
+    #   #=> "/lib64/ld-linux-x86-64.so.2"
+    def interpreter
+      @set[:interpreter] || interpreter_
     end
 
     # Set interpreter's name.
@@ -26,11 +38,73 @@ module PatchELF
     # @param [String] interp
     # @macro note_apply
     def interpreter=(interp)
-      return if interpreter.nil? # will also show warning if there's no interp segment.
+      return if interpreter_.nil? # will also show warning if there's no interp segment.
 
       @set[:interpreter] = interp
     end
 
+    # Get needed libraries.
+    # @return [Array<String>]
+    # @example
+    #   patcher = PatchELF::Patcher.new('/bin/ls')
+    #   patcher.needed
+    #   #=> ["libselinux.so.1", "libc.so.6"]
+    def needed
+      @set[:needed] || needed_
+    end
+
+    # Set needed libraries.
+    # @param [Array<String>] needs
+    # @macro note_apply
+    def needed=(needs)
+      @set[:needed] = needs
+    end
+
+    # Add the needed library.
+    # @param [String] need
+    # @return [void]
+    # @macro note_apply
+    def add_needed(need)
+      @set[:needed] ||= needed_
+      @set[:needed] << need
+    end
+
+    # Remove the needed library.
+    # @param [String] need
+    # @return [void]
+    # @macro note_apply
+    def remove_needed(need)
+      @set[:needed] ||= needed_
+      @set[:needed].delete(need)
+    end
+
+    # Replace needed library +src+ with +tar+.
+    #
+    # @param [String] src
+    #   Library to be replaced.
+    # @param [String] tar
+    #   Library replace with.
+    # @return [void]
+    # @macro note_apply
+    def replace_needed(src, tar)
+      @set[:needed] ||= needed_
+      @set[:needed].map! { |v| v == src ? tar : v }
+    end
+
+    # Get the soname of a shared library.
+    # @return [String?] The name.
+    # @example
+    #   patcher = PatchELF::Patcher.new('/bin/ls')
+    #   patcher.soname
+    #   # [WARN] Entry DT_SONAME not found, not a shared library?
+    #   #=> nil
+    # @example
+    #   PatchELF::Patcher.new('/lib/x86_64-linux-gnu/libc.so.6').soname
+    #   #=> "libc.so.6"
+    def soname
+      @set[:soname] || soname_
+    end
+
     # Set soname.
     #
     # If the input ELF is not a shared library with a soname,
@@ -38,19 +112,32 @@ module PatchELF
     # @param [String] name
     # @macro note_apply
     def soname=(name)
-      return if soname.nil?
+      return if soname_.nil?
 
       @set[:soname] = name
     end
 
-    # Set rpath.
+    # Get runpath.
+    # @return [String?]
+    def runpath
+      @set[@rpath_sym] || runpath_
+    end
+
+    # Set runpath.
     #
-    # If DT_RPATH is not presented in the input ELF,
-    # a new DT_RPATH attribute will be inserted into the DYNAMIC segment.
-    # @param [String] rpath
+    # If DT_RUNPATH is not presented in the input ELF,
+    # a new DT_RUNPATH attribute will be inserted into the DYNAMIC segment.
+    # @param [String] runpath
     # @macro note_apply
-    def rpath=(rpath)
-      @set[:rpath] = rpath
+    def runpath=(runpath)
+      @set[@rpath_sym] = runpath
+    end
+
+    # Set all operations related to DT_RUNPATH to use DT_RPATH.
+    # @return [self]
+    def use_rpath!
+      @rpath_sym = :rpath
+      self
     end
 
     # Save the patched ELF as +out_file+.
@@ -58,87 +145,18 @@ module PatchELF
     #   If +out_file+ is +nil+, the original input file will be modified.
     # @return [void]
     def save(out_file = nil)
-      # TODO: Test if we can save twice, and the output files are exactly same.
       # If nothing is modified, return directly.
       return if out_file.nil? && !dirty?
 
       out_file ||= @in_file
-      # [{Integer => String}]
-      @inline_patch = {}
-      @mm = PatchELF::MM.new(@elf)
-      # Patching interpreter is the easiest.
-      patch_interpreter(@set[:interpreter])
-
-      @mm.dispatch!
-
-      FileUtils.cp(@in_file, out_file) if out_file != @in_file
-      # if @mm.extend_size != 0:
-      # 1. Remember all data after the original second LOAD
-      # 2. Apply patches before the second LOAD.
-      # 3. Apply patches located after the second LOAD.
-
-      File.open(out_file, 'r+') do |f|
-        if @mm.extended?
-          original_head = @mm.threshold
-          extra = {}
-          # Copy all data after the second load
-          @elf.stream.pos = original_head
-          extra[original_head + @mm.extend_size] = @elf.stream.read # read to end
-          # zero out the 'gap' we created
-          extra[original_head] = "\x00" * @mm.extend_size
-          extra.each do |pos, str|
-            f.pos = pos
-            f.write(str)
-          end
-        end
-        @elf.patches.each do |pos, str|
-          f.pos = @mm.extended_offset(pos)
-          f.write(str)
-        end
-
-        @inline_patch.each do |pos, str|
-          f.pos = pos
-          f.write(str)
-        end
-      end
-
-      # Let output file have the same permission as input.
-      FileUtils.chmod(File.stat(@in_file).mode, out_file)
-    end
-
-    # Get name(s) of interpreter, needed libraries, rpath, or soname.
-    #
-    # @param [:interpreter, :needed, :rpath, :soname] name
-    # @return [String, Array<String>, nil]
-    #   Returns name(s) fetched from ELF.
-    # @example
-    #   patcher = Patcher.new('/bin/ls')
-    #   patcher.get(:interpreter)
-    #   #=> "/lib64/ld-linux-x86-64.so.2"
-    #   patcher.get(:needed)
-    #   #=> ["libselinux.so.1", "libc.so.6"]
-    #
-    #   patcher.get(:soname)
-    #   # [WARN] Entry DT_SONAME not found, not a shared library?
-    #   #=> nil
-    # @example
-    #   Patcher.new('/lib/x86_64-linux-gnu/libc.so.6').get(:soname)
-    #   #=> "libc.so.6"
-    def get(name)
-      return unless %i[interpreter needed rpath soname].include?(name)
-      return @set[name] if @set[name]
+      saver = PatchELF::Saver.new(@in_file, out_file, @set)
 
-      __send__(name)
+      saver.save!
     end
 
     private
 
-    # @return [String?]
-    #   Get interpreter's name.
-    # @example
-    #   Patcher.new('/bin/ls').interpreter
-    #   #=> "/lib64/ld-linux-x86-64.so.2"
-    def interpreter
+    def interpreter_
       segment = @elf.segment_by_type(:interp)
       return PatchELF::Logger.warn('No interpreter found.') if segment.nil?
 
@@ -146,7 +164,7 @@ module PatchELF
     end
 
     # @return [Array<String>]
-    def needed
+    def needed_
       segment = dynamic_or_log
       return if segment.nil?
 
@@ -154,64 +172,20 @@ module PatchELF
     end
 
     # @return [String?]
-    def rpath
-      # TODO: consider both rpath and runpath
-      tag_name_or_log(:rpath, 'Entry DT_RPATH not found.')
+    def runpath_
+      tag_name_or_log(@rpath_sym, "Entry DT_#{@rpath_sym.to_s.upcase} not found.")
     end
 
     # @return [String?]
-    def soname
+    def soname_
       tag_name_or_log(:soname, 'Entry DT_SONAME not found, not a shared library?')
     end
 
-    def patch_interpreter(new_interp)
-      return if new_interp.nil?
-
-      new_interp += "\x00"
-      old_interp = interpreter + "\x00"
-      return if old_interp == new_interp
-
-      # These headers must be found here but not in the proc.
-      seg_header = @elf.segment_by_type(:interp).header
-      sec_header = section_header('.interp')
-
-      patch = proc do |off, vaddr|
-        # Register an inline patching
-        inline_patch(off, new_interp)
-
-        # The patching feature of ELFTools
-        seg_header.p_offset = off
-        seg_header.p_vaddr = seg_header.p_paddr = vaddr
-        seg_header.p_filesz = seg_header.p_memsz = new_interp.size
-
-        if sec_header
-          sec_header.sh_offset = off
-          sec_header.sh_size = new_interp.size
-        end
-      end
-
-      if new_interp.size <= old_interp.size
-        # easy case
-        patch.call(seg_header.p_offset.to_i, seg_header.p_vaddr.to_i)
-      else
-        # hard case, we have to request a new LOAD area
-        @mm.malloc(new_interp.size, &patch)
-      end
-    end
-
     # @return [Boolean]
     def dirty?
       @set.any?
     end
 
-    # @return [ELFTools::Sections::Section?]
-    def section_header(name)
-      sec = @elf.section_by_name(name)
-      return if sec.nil?
-
-      sec.header
-    end
-
     def tag_name_or_log(type, log_msg)
       segment = dynamic_or_log
       return if segment.nil?
@@ -227,12 +201,5 @@ module PatchELF
         PatchELF::Logger.warn('DYNAMIC segment not found, might be a statically-linked ELF?') if s.nil?
       end
     end
-
-    # This can only be used for patching interpreter's name
-    # or set strings in a malloc-ed area.
-    # i.e. NEVER intend to change the string defined in strtab
-    def inline_patch(off, str)
-      @inline_patch[@mm.extended_offset(off)] = str
-    end
   end
 end

data/lib/patchelf/saver.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'elftools/constants'
+require 'elftools/elf_file'
+require 'elftools/structs'
+require 'elftools/util'
+require 'fileutils'
+
+require 'patchelf/mm'
+
+module PatchELF
+  # Internal use only.
+  #
+  # For {Patcher} to do patching things and save to file.
+  # @private
+  class Saver
+    attr_reader :in_file # @return [String] Input filename.
+    attr_reader :out_file # @return [String] Output filename.
+
+    # Instantiate a {Saver} object.
+    # @param [String] in_file
+    # @param [String] out_file
+    # @param [{Symbol => String, Array}] set
+    def initialize(in_file, out_file, set)
+      @in_file = in_file
+      @out_file = out_file
+      @set = set
+      # [{Integer => String}]
+      @inline_patch = {}
+      @elf = ELFTools::ELFFile.new(File.open(in_file))
+      @mm = PatchELF::MM.new(@elf)
+      @strtab_extend_requests = []
+      @append_dyn = []
+    end
+
+    # @return [void]
+    def save!
+      # In this method we assume all attributes that should exist do exist.
+      # e.g. DT_INTERP, DT_DYNAMIC. These should have been checked in the patcher.
+      patch_interpreter
+      patch_dynamic
+
+      @mm.dispatch!
+
+      FileUtils.cp(in_file, out_file) if out_file != in_file
+      patch_out(@out_file)
+      # Let output file have the same permission as input.
+      FileUtils.chmod(File.stat(in_file).mode, out_file)
+    end
+
+    private
+
+    def patch_interpreter
+      return if @set[:interpreter].nil?
+
+      new_interp = @set[:interpreter] + "\x00"
+      old_interp = @elf.segment_by_type(:interp).interp_name + "\x00"
+      return if old_interp == new_interp
+
+      # These headers must be found here but not in the proc.
+      seg_header = @elf.segment_by_type(:interp).header
+      sec_header = section_header('.interp')
+
+      patch = proc do |off, vaddr|
+        # Register an inline patching
+        inline_patch(off, new_interp)
+
+        # The patching feature of ELFTools
+        seg_header.p_offset = off
+        seg_header.p_vaddr = seg_header.p_paddr = vaddr
+        seg_header.p_filesz = seg_header.p_memsz = new_interp.size
+
+        if sec_header
+          sec_header.sh_offset = off
+          sec_header.sh_size = new_interp.size
+        end
+      end
+
+      if new_interp.size <= old_interp.size
+        # easy case
+        patch.call(seg_header.p_offset.to_i, seg_header.p_vaddr.to_i)
+      else
+        # hard case, we have to request a new LOAD area
+        @mm.malloc(new_interp.size, &patch)
+      end
+    end
+
+    def patch_dynamic
+      # We never do inline patching on strtab's string.
+      # 1. Search if there's useful string exists
+      #   - only need header patching
+      # 2. Append a new string to the strtab.
+      #   - register strtab extension
+      dynamic.tags # HACK, force @tags to be defined
+      patch_soname if @set[:soname]
+      patch_runpath if @set[:runpath]
+      patch_runpath(:rpath) if @set[:rpath]
+      patch_needed if @set[:needed]
+      malloc_strtab!
+      expand_dynamic!
+    end
+
+    def patch_soname
+      # The tag must exist.
+      so_tag = dynamic.tag_by_type(:soname)
+      reg_str_table(@set[:soname]) do |idx|
+        so_tag.header.d_val = idx
+      end
+    end
+
+    def patch_runpath(sym = :runpath)
+      tag = dynamic.tag_by_type(sym)
+      tag = tag.nil? ? lazy_dyn(sym) : tag.header
+      reg_str_table(@set[sym]) do |idx|
+        tag.d_val = idx
+      end
+    end
+
+    # To mark a not-using tag
+    IGNORE = ELFTools::Constants::DT_LOOS
+    def patch_needed
+      original_needs = dynamic.tags_by_type(:needed)
+      @set[:needed].uniq!
+      # 3 sets:
+      # 1. in original and in needs - remain unchanged
+      # 2. in original but not in needs - remove
+      # 3. not in original and in needs - append
+      original_needs.each do |n|
+        next if @set[:needed].include?(n.name)
+
+        n.header.d_tag = IGNORE # temporarily mark
+      end
+
+      extra = @set[:needed] - original_needs.map(&:name)
+      original_needs.each do |n|
+        break if extra.empty?
+        next if n.header.d_tag != IGNORE
+
+        n.header.d_tag = ELFTools::Constants::DT_NEEDED
+        reg_str_table(extra.shift) { |idx| n.header.d_val = idx }
+      end
+      return if extra.empty?
+
+      # no spaces, need append
+      extra.each do |name|
+        tag = lazy_dyn(:needed)
+        reg_str_table(name) { |idx| tag.d_val = idx }
+      end
+    end
+
+    # Create a temp tag header.
+    # @return [ELFTools::Structs::ELF_Dyn]
+    def lazy_dyn(sym)
+      ELFTools::Structs::ELF_Dyn.new(endian: @elf.endian).tap do |dyn|
+        @append_dyn << dyn
+        dyn.elf_class = @elf.elf_class
+        dyn.d_tag = ELFTools::Util.to_constant(ELFTools::Constants::DT, sym)
+      end
+    end
+
+    def expand_dynamic!
+      return if @append_dyn.empty?
+
+      dyn_sec = section_header('.dynamic')
+      total = dynamic.tags.map(&:header)
+      # the last must be a null-tag
+      total = total[0..-2] + @append_dyn + [total.last]
+      bytes = total.first.num_bytes * total.size
+      @mm.malloc(bytes) do |off, vaddr|
+        inline_patch(off, total.map(&:to_binary_s).join)
+        dynamic.header.p_offset = off
+        dynamic.header.p_vaddr = dynamic.header.p_paddr = vaddr
+        dynamic.header.p_filesz = dynamic.header.p_memsz = bytes
+        if dyn_sec
+          dyn_sec.sh_offset = off
+          dyn_sec.sh_addr = vaddr
+          dyn_sec.sh_size = bytes
+        end
+      end
+    end
+
+    def malloc_strtab!
+      return if @strtab_extend_requests.empty?
+
+      strtab = dynamic.tag_by_type(:strtab)
+      # Process registered requests
+      need_size = strtab_string.size + @strtab_extend_requests.reduce(0) { |sum, (str, _)| sum + str.size + 1 }
+      dynstr = section_header('.dynstr')
+      @mm.malloc(need_size) do |off, vaddr|
+        new_str = strtab_string + @strtab_extend_requests.map(&:first).join("\x00") + "\x00"
+        inline_patch(off, new_str)
+        @strtab_extend_requests.each do |str, block|
+          # TODO: make here more efficient
+          block.call(new_str.index(str + "\x00"))
+        end
+        # Now patching strtab header
+        strtab.header.d_val = vaddr
+        # We also need to patch dynstr to let readelf have correct output.
+        if dynstr
+          dynstr.sh_size = new_str.size
+          dynstr.sh_offset = off
+          dynstr.sh_addr = vaddr
+        end
+      end
+    end
+
+    # @param [String] str
+    # @yieldparam [Integer] idx
+    # @yieldreturn [void]
+    def reg_str_table(str, &block)
+      idx = strtab_string.index(str + "\x00")
+      # Request string is already exist
+      return yield idx if idx
+
+      # Record the request
+      @strtab_extend_requests << [str, block]
+    end
+
+    def strtab_string
+      return @strtab_string if defined?(@strtab_string)
+
+      # TODO: handle no strtab exists..
+      offset = @elf.offset_from_vma(dynamic.tag_by_type(:strtab).value)
+      # This is a little tricky since no length information is stored in the tag.
+      # We first get the file offset of the string then 'guess' where the end is.
+      @elf.stream.pos = offset
+      @strtab_string = +''
+      loop do
+        c = @elf.stream.read(1)
+        break unless c =~ /\x00|[[:print:]]/
+
+        @strtab_string << c
+      end
+      @strtab_string
+    end
+
+    # This can only be used for patching interpreter's name
+    # or set strings in a malloc-ed area.
+    # i.e. NEVER intend to change the string defined in strtab
+    def inline_patch(off, str)
+      @inline_patch[off] = str
+    end
+
+    # Modify the out_file according to registered patches.
+    def patch_out(out_file)
+      File.open(out_file, 'r+') do |f|
+        if @mm.extended?
+          original_head = @mm.threshold
+          extra = {}
+          # Copy all data after the second load
+          @elf.stream.pos = original_head
+          extra[original_head + @mm.extend_size] = @elf.stream.read # read to end
+          # zero out the 'gap' we created
+          extra[original_head] = "\x00" * @mm.extend_size
+          extra.each do |pos, str|
+            f.pos = pos
+            f.write(str)
+          end
+        end
+        @elf.patches.each do |pos, str|
+          f.pos = @mm.extended_offset(pos)
+          f.write(str)
+        end
+
+        @inline_patch.each do |pos, str|
+          f.pos = pos
+          f.write(str)
+        end
+      end
+    end
+
+    # @return [ELFTools::Sections::Section?]
+    def section_header(name)
+      sec = @elf.section_by_name(name)
+      return if sec.nil?
+
+      sec.header
+    end
+
+    def dynamic
+      @dynamic ||= @elf.segment_by_type(:dynamic)
+    end
+  end
+end

data/lib/patchelf/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module PatchELF
   # Current gem version.
-  VERSION = '0.0.0'.freeze
+  VERSION = '0.1.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: patchelf
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - david942j
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-07 00:00:00.000000000 Z
+date: 2019-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: elftools
@@ -123,10 +123,10 @@ files:
 - lib/patchelf.rb
 - lib/patchelf/cli.rb
 - lib/patchelf/helper.rb
-- lib/patchelf/interval.rb
 - lib/patchelf/logger.rb
 - lib/patchelf/mm.rb
 - lib/patchelf/patcher.rb
+- lib/patchelf/saver.rb
 - lib/patchelf/version.rb
 homepage: https://github.com/david942j/patchelf.rb
 licenses:
@@ -147,8 +147,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: patchelf

data/lib/patchelf/interval.rb

@@ -1,30 +0,0 @@
-module PatchELF
-  # Provides easier-to-use methods for manipulating LOAD segment.
-  #
-  # Internal use only.
-  class Interval
-    include Comparable
-
-    attr_reader :head # @return [Integer] Head.
-    attr_reader :size # @return [Integer] Length.
-
-    # @param [Integer] head
-    # @param [Integer] size
-    def initialize(head, size)
-      @head = head
-      @size = size
-    end
-
-    # Comparator.
-    # @param [Interval] other
-    def <=>(other)
-      head <=> other.head
-    end
-
-    # @return [Integer]
-    #   The end of this interval.
-    def tail
-      head + size
-    end
-  end
-end