patchelf 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e432d8ac7a3e75e8c9e80d433bc756e635d6b4d057b7e02ed952be113c7edbf5
+  data.tar.gz: 463cee3d6e780346706752f2a537e67fde649db82b206a8d79f15e60dd4cb4ae
+SHA512:
+  metadata.gz: bebe4cca89632d3660045d7582c19cf356562d2cbd389cc910377e88ea293c4fb812bb8917e89670cad05224254497c361f608e7429dcfe2c09ed94d31834a9f
+  data.tar.gz: 849a0a0b5b8c5bc1c1e52c4f65c9452917f58cf881bca89de4a4986df0556fd677724fe1b17466ff469eed8bcada2320d69169951d9ea0ac4aed1d9be6e4d5aa

data/README.md

@@ -0,0 +1,79 @@
+[![Build Status](https://travis-ci.org/david942j/patchelf.rb.svg?branch=master)](https://travis-ci.org/david942j/patchelf.rb)
+[![Dependabot Status](https://api.dependabot.com/badges/status?host=github&repo=david942j/patchelf.rb)](https://dependabot.com)
+[![Code Climate](https://codeclimate.com/github/david942j/patchelf.rb/badges/gpa.svg)](https://codeclimate.com/github/david942j/patchelf.rb)
+[![Issue Count](https://codeclimate.com/github/david942j/patchelf.rb/badges/issue_count.svg)](https://codeclimate.com/github/david942j/patchelf.rb)
+[![Test Coverage](https://codeclimate.com/github/david942j/patchelf.rb/badges/coverage.svg)](https://codeclimate.com/github/david942j/patchelf.rb/coverage)
+[![Inline docs](https://inch-ci.org/github/david942j/patchelf.rb.svg?branch=master)](https://inch-ci.org/github/david942j/patchelf.rb)
+[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](http://choosealicense.com/licenses/mit/)
+
+# patchelf.rb
+
+Implements features of NixOS/patchelf in pure Ruby.
+
+## Installation
+
+WIP.
+
+## 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
+#                                      Set interpreter's name.
+#         --so, --set-soname SONAME    Set name of a shared library.
+#         --version                    Show current gem's version.
+
+```
+
+### 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
+
+```
+
+### Change the dynamic loader (interpreter)
+```
+# $ patchelf.rb --interp NEW_INTERP input.elf output.elf
+$ patchelf.rb --interp /lib/AAAA.so /bin/ls ls.patch
+
+$ file ls.patch
+# ls.patch: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib/AAAA.so, for GNU/Linux 3.2.0, BuildID[sha1]=9567f9a28e66f4d7ec4baf31cfbf68d0410f0ae6, stripped
+
+```
+
+### Change SONAME of a shared library
+```
+$ patchelf.rb --soname libnewname.so.217 /lib/x86_64-linux-gnu/libc.so.6 ./libc.patched
+
+$ readelf -d libc.patched | grep SONAME
+
+```
+
+### As Ruby library
+```rb
+require 'patchelf'
+
+patcher = PatchELF::Patcher.new('/bin/ls')
+patcher.get(:interpreter)
+#=> "/lib64/ld-linux-x86-64.so.2"
+
+patcher.interpreter = '/lib/AAAA.so.2'
+patcher.get(:interpreter)
+#=> "/lib/AAAA.so.2"
+
+patcher.save('ls.patch')
+
+# $ file ls.patch
+# ls.patch: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib/AAAA.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=9567f9a28e66f4d7ec4baf31cfbf68d0410f0ae6, stripped
+
+```
+
+## Environment
+
+patchelf.rb is implemented in pure Ruby, so it should work in all environments include Linux, maxOS, and Windows!

data/bin/patchelf.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'patchelf/cli'
+
+PatchELF::CLI.work(ARGV)

data/lib/patchelf.rb

@@ -0,0 +1,8 @@
+# Main module of patchelf.
+#
+# @author david942j
+module PatchELF
+end
+
+require 'patchelf/patcher'
+require 'patchelf/version'

data/lib/patchelf/cli.rb

@@ -0,0 +1,91 @@
+require 'optparse'
+
+require 'patchelf/patcher'
+require 'patchelf/version'
+
+module PatchELF
+  # For command line interface to parsing arguments.
+  module CLI
+    # Name of binary.
+    SCRIPT_NAME = 'patchelf.rb'.freeze
+    # CLI usage string.
+    USAGE = format('Usage: %s <commands> FILENAME [OUTPUT_FILE]', SCRIPT_NAME).freeze
+
+    module_function
+
+    # Main method of CLI.
+    # @param [Array<String>] argv
+    #   Command line arguments.
+    # @return [void]
+    # @example
+    #   PatchELF::CLI.work(%w[--help])
+    #   # usage message to stdout
+    #   PatchELF::CLI.work(%w[--version])
+    #   # version message to stdout
+    def work(argv)
+      @options = {
+        set: {},
+        print: []
+      }
+      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
+      @options[:print].uniq.each do |s|
+        content = patcher.get(s)
+        next if content.nil?
+
+        $stdout.puts "#{s.to_s.capitalize}: #{Array(content).join(' ')}"
+      end
+
+      @options[:set].each do |sym, val|
+        patcher.__send__("#{sym}=".to_sym, val)
+      end
+
+      patcher.save(@options[:out_file])
+    end
+
+    private
+
+    def parse(argv)
+      remain = option_parser.permute(argv)
+      return false if remain.first.nil?
+
+      @options[:in_file] = remain.first
+      @options[:out_file] = remain[1] # can be nil
+      true
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = USAGE
+
+        opts.on('--pi', '--print-interpreter', 'Show interpreter\'s name.') do
+          @options[:print] << :interpreter
+        end
+
+        opts.on('--pn', '--print-needed', 'Show needed libraries specified in DT_NEEDED.') do
+          @options[:print] << :needed
+        end
+
+        opts.on('--ps', '--print-soname', 'Show soname specified in DT_SONAME.') do
+          @options[:print] << :soname
+        end
+
+        opts.on('--interp INTERP', '--set-interpreter 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|
+          @options[:set][:soname] = soname
+        end
+
+        opts.on('--version', 'Show current gem\'s version.') {}
+      end
+    end
+
+    extend self
+  end
+end

data/lib/patchelf/helper.rb

@@ -0,0 +1,68 @@
+module PatchELF
+  # Helper methods for internal usage.
+  module Helper
+    # The size of one page.
+    PAGE_SIZE = 0x1000
+
+    module_function
+
+    # Color codes for pretty print.
+    COLOR_CODE = {
+      esc_m: "\e[0m",
+      info: "\e[38;5;82m", # light green
+      warn: "\e[38;5;230m", # light yellow
+      error: "\e[38;5;196m" # heavy red
+    }.freeze
+
+    # For wrapping string with color codes for prettier inspect.
+    # @param [String] str
+    #   Content to colorize.
+    # @param [Symbol] type
+    #   Specify which kind of color to use, valid symbols are defined in {.COLOR_CODE}.
+    # @return [String]
+    #   String that wrapped with color codes.
+    def colorize(str, type)
+      return str unless color_enabled?
+
+      cc = COLOR_CODE
+      color = cc.key?(type) ? cc[type] : ''
+      "#{color}#{str.sub(COLOR_CODE[:esc_m], color)}#{cc[:esc_m]}"
+    end
+
+    # For {#colorize} to decide if need add color codes.
+    # @return [Boolean]
+    def color_enabled?
+      $stderr.tty?
+    end
+
+    # @param [Integer] val
+    # @param [Integer] align
+    # @return [Integer]
+    #   Aligned result.
+    # @example
+    #   Helper.aligndown(0x1234)
+    #   #=> 4096
+    #   Helper.aligndown(0x33, 0x20)
+    #   #=> 32
+    #   Helper.aligndown(0x10, 0x8)
+    #   #=> 16
+    def aligndown(val, align = PAGE_SIZE)
+      val - (val & (align - 1))
+    end
+
+    # @param [Integer] val
+    # @param [Integer] align
+    # @return [Integer]
+    #   Aligned result.
+    # @example
+    #   Helper.alignup(0x1234)
+    #   #=> 8192
+    #   Helper.alignup(0x33, 0x20)
+    #   #=> 64
+    #   Helper.alignup(0x10, 0x8)
+    #   #=> 16
+    def alignup(val, align = PAGE_SIZE)
+      (val & (align - 1)).zero? ? val : (aligndown(val, align) + align)
+    end
+  end
+end

data/lib/patchelf/interval.rb

@@ -0,0 +1,30 @@
+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

data/lib/patchelf/logger.rb

@@ -0,0 +1,23 @@
+require 'logger'
+
+require 'patchelf/helper'
+
+module PatchELF
+  # A logger for internal usage.
+  module Logger
+    module_function
+
+    @logger = ::Logger.new($stderr).tap do |log|
+      log.formatter = proc do |severity, _datetime, _progname, msg|
+        "[#{PatchELF::Helper.colorize(severity, severity.downcase.to_sym)}] #{msg}\n"
+      end
+    end
+
+    %i[info warn error].each do |sym|
+      define_method(sym) do |msg|
+        @logger.__send__(sym, msg)
+        nil
+      end
+    end
+  end
+end

data/lib/patchelf/mm.rb

@@ -0,0 +1,167 @@
+require 'patchelf/helper'
+require 'patchelf/interval'
+
+module PatchELF
+  # Memory management, provides malloc/free to allocate LOAD segments.
+  class MM
+    attr_reader :extend_size # @return [Integer]
+    attr_reader :threshold # @return [Integer]
+
+    # Instantiate a {MM} object.
+    # @param [ELFTools::ELFFile] elf
+    def initialize(elf)
+      @elf = elf
+      @request = []
+    end
+
+    # @param [Integer] size
+    # @return [void]
+    # @yieldparam [Integer] off
+    # @yieldparam [Integer] vaddr
+    # @yieldreturn [void]
+    #   One can only do the following things in the block:
+    #   1. Set ELF headers' attributes (with ELFTools)
+    #   2. Invoke {Patcher#inline_patch}
+    def malloc(size, &block)
+      # TODO: check size > 0
+      @request << [size, block]
+    end
+
+    # Let the malloc / free requests be effective.
+    # @return [void]
+    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
+    end
+
+    # Query if extended.
+    # @return [Boolean]
+    def extended?
+      defined?(@threshold)
+    end
+
+    # @return [Integer]
+    def extended_offset(off)
+      return off unless defined?(@threshold)
+      return off if off < @threshold
+
+      off + @extend_size
+    end
+
+    private
+
+    def gap_useful?(need_size)
+      # Two conditions:
+      # 1. gap is large enough
+      gap = gap_between_load
+      return false if gap.size < need_size
+
+      # 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?
+
+      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)
+
+      loads = load_segments.map do |seg|
+        PatchELF::Interval.new(seg.file_head, seg.size)
+      end
+      # TODO: raise if loads.min != loads.first
+
+      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)
+    end
+
+    # For all attributes >= threshold, += offset
+    def shift_attributes
+      # ELFHeader->section_header
+      # Sections:
+      #   all
+      # Segments:
+      #   all
+      # XXX: will be buggy if one day the number of segments might 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
+      end
+
+      @elf.header.e_shoff += extend_size if @elf.header.e_shoff >= threshold
+    end
+
+    def load_segments
+      @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
+      @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
+    end
+  end
+end

data/lib/patchelf/patcher.rb

@@ -0,0 +1,238 @@
+require 'elftools'
+require 'fileutils'
+
+require 'patchelf/logger'
+require 'patchelf/mm'
+
+module PatchELF
+  # Class to handle all patching things.
+  class Patcher
+    # @!macro [new] note_apply
+    #   @note This setting will be saved after {#save} being invoked.
+
+    # Instantiate a {Patcher} object.
+    # @param [String] filename
+    #   Filename of input ELF.
+    def initialize(filename)
+      @in_file = filename
+      @elf = ELFTools::ELFFile.new(File.open(filename))
+      @set = {}
+    end
+
+    # Set interpreter's name.
+    #
+    # If the input ELF has no existent interpreter,
+    # this method will show a warning and has no effect.
+    # @param [String] interp
+    # @macro note_apply
+    def interpreter=(interp)
+      return if interpreter.nil? # will also show warning if there's no interp segment.
+
+      @set[:interpreter] = interp
+    end
+
+    # Set soname.
+    #
+    # If the input ELF is not a shared library with a soname,
+    # this method will show a warning and has no effect.
+    # @param [String] name
+    # @macro note_apply
+    def soname=(name)
+      return if soname.nil?
+
+      @set[:soname] = name
+    end
+
+    # Set rpath.
+    #
+    # 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
+    # @macro note_apply
+    def rpath=(rpath)
+      @set[:rpath] = rpath
+    end
+
+    # Save the patched ELF as +out_file+.
+    # @param [String?] out_file
+    #   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]
+
+      __send__(name)
+    end
+
+    private
+
+    # @return [String?]
+    #   Get interpreter's name.
+    # @example
+    #   Patcher.new('/bin/ls').interpreter
+    #   #=> "/lib64/ld-linux-x86-64.so.2"
+    def interpreter
+      segment = @elf.segment_by_type(:interp)
+      return PatchELF::Logger.warn('No interpreter found.') if segment.nil?
+
+      segment.interp_name
+    end
+
+    # @return [Array<String>]
+    def needed
+      segment = dynamic_or_log
+      return if segment.nil?
+
+      segment.tags_by_type(:needed).map(&:name)
+    end
+
+    # @return [String?]
+    def rpath
+      # TODO: consider both rpath and runpath
+      tag_name_or_log(:rpath, 'Entry DT_RPATH not found.')
+    end
+
+    # @return [String?]
+    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?
+
+      tag = segment.tag_by_type(type)
+      return PatchELF::Logger.warn(log_msg) if tag.nil?
+
+      tag.name
+    end
+
+    def dynamic_or_log
+      @elf.segment_by_type(:dynamic).tap do |s|
+        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/version.rb

@@ -0,0 +1,4 @@
+module PatchELF
+  # Current gem version.
+  VERSION = '0.0.0'.freeze
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: patchelf
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- david942j
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: elftools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.62'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+- !ruby/object:Gem::Dependency
+  name: tty-platform
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: |2
+    A simple utility for modifying existing ELF executables and
+  libraries.
+email:
+- david942j@gmail.com
+executables:
+- patchelf.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/patchelf.rb
+- 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/version.rb
+homepage: https://github.com/david942j/patchelf.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: patchelf
+test_files: []