patchelf 0.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e432d8ac7a3e75e8c9e80d433bc756e635d6b4d057b7e02ed952be113c7edbf5
-  data.tar.gz: 463cee3d6e780346706752f2a537e67fde649db82b206a8d79f15e60dd4cb4ae
+  metadata.gz: 8560f68dba4f9e656585c38f31da63ae5f15320a03c1675adb13d27ffa2230b4
+  data.tar.gz: 2d19b129beb5df7bd713fc6f0f65bb942194bea201857bda499a18e4496c4fe2
 SHA512:
-  metadata.gz: bebe4cca89632d3660045d7582c19cf356562d2cbd389cc910377e88ea293c4fb812bb8917e89670cad05224254497c361f608e7429dcfe2c09ed94d31834a9f
-  data.tar.gz: 849a0a0b5b8c5bc1c1e52c4f65c9452917f58cf881bca89de4a4986df0556fd677724fe1b17466ff469eed8bcada2320d69169951d9ea0ac4aed1d9be6e4d5aa
+  metadata.gz: a2c443a08655333dc1b97ca62c1f6803bf6971565a9b40c80554aaf89a78b8e7548f0a854dd6703175e8be57154ca541ffe71f642a35ded2a734fbe1eae83b0e
+  data.tar.gz: 73707a964c3cc1a9d47efcb0baaa45d1fc8e42e2450acca899b5258ca2b9236229e9e560a5c9fa347bbd7c5a429644a66ceed5ac072cb7ac06db3b98088c1a8c

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')
@@ -76,4 +134,4 @@ patcher.save('ls.patch')
 
 ## Environment
 
-patchelf.rb is implemented in pure Ruby, so it should work in all environments include Linux, maxOS, and Windows!
+patchelf.rb is implemented in pure Ruby, so it should work in all environments include Linux, macOS, and Windows!

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,30 +27,50 @@ 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])
-      # TODO: Handle ELFTools::ELFError
+      begin
+        @patcher = PatchELF::Patcher.new(@options[:in_file])
+      rescue ELFTools::ELFError, Errno::ENOENT => e
+        return PatchELF::Logger.error(e.message)
+      end
+      patcher.use_rpath! if @options[:force_rpath]
+      readonly
+      patch_requests
+      patcher.save(@options[:out_file])
+    end
+
+    private
+
+    def patcher
+      @patcher
+    end
+
+    def readonly
       @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
+    end
 
+    def patch_requests
       @options[:set].each do |sym, val|
         patcher.__send__("#{sym}=".to_sym, val)
       end
 
-      patcher.save(@options[:out_file])
+      @options[:needed].each do |type, val|
+        patcher.__send__("#{type}_needed".to_sym, *val)
+      end
     end
 
-    private
-
     def parse(argv)
       remain = option_parser.permute(argv)
       return false if remain.first.nil?
@@ -62,23 +84,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/exceptions.rb

@@ -0,0 +1,13 @@
+# encoding: ascii-8bit
+# frozen_string_literal: true
+
+require 'elftools/exceptions'
+
+module PatchELF
+  # Raised on an error during ELF modification.
+  class PatchError < ELFTools::ELFError; end
+  # Raised when Dynamic Tag is missing
+  class MissingTagError < PatchError; end
+  # Raised on missing Program Header(segment)
+  class MissingSegmentError < PatchError; end
+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,9 +23,10 @@ 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
+      raise ArgumentError, 'malloc\'s size most be positive.' if size <= 0
+
       @request << [size, block]
     end
 
@@ -32,39 +35,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 +58,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 +72,75 @@ 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])
+
+      extend_forward(loads[idx])
+    end
 
-      # 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?
+    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
+      @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])
 
-      loads = load_segments.map do |seg|
-        PatchELF::Interval.new(seg.file_head, seg.size)
+        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
+
+    # TODO
+    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 +150,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 +171,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