ruby-macho 1.3.0.pre.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73711cb2c95bea44060fc6ab6ebd99a66b06ee1a6187b512ae68527e8dc4e8f7
-  data.tar.gz: fefdf5b471bbf158af6d8a1bf766f5b327ad737e09badc60d8adae723ef3d3b9
+  metadata.gz: 644d3e65c34cd64ddcba05a186fa28caa4032adb7ca7c4022e485f5d2a5bb399
+  data.tar.gz: 6835b176571ab230e171080c418a4f2873be9af58b47ebd1a316e8e219119222
 SHA512:
-  metadata.gz: ed466ba6c6c0c62f1cb7fa365401faef73a322c636f9a1e97f3e655457f1787b83ef134360168618849f0d3253f1d6b8ed41aa0f085a9a40b3ca966ef1d437e4
-  data.tar.gz: 61781f5efc71e38eff94704c09de7338e53918030189abe0f0bb2e1b442e5685a58076c431f112d27518e921fe5177666ccea7e6015fea65a5d8460da7632d13
+  metadata.gz: d4e29aaa92deb1128369c0f5368b6832d9c1068a89c5d1e35951ca17dc068806fc7674064dcf603ba3b6ba66a1e7b57189cb9589bbd53f74b7df4602d7726926
+  data.tar.gz: '0838f24f7b496660ce71eb06b1167c65f8c8b551ae6b6f223ec1518664d43bb8c1bdc0803e605ff93319c07ca2c8088a80aad1d2f397c9019c7fc067bae6c3d6'

data/lib/macho.rb

@@ -1,18 +1,18 @@
-require "#{File.dirname(__FILE__)}/macho/structure"
-require "#{File.dirname(__FILE__)}/macho/view"
-require "#{File.dirname(__FILE__)}/macho/headers"
-require "#{File.dirname(__FILE__)}/macho/load_commands"
-require "#{File.dirname(__FILE__)}/macho/sections"
-require "#{File.dirname(__FILE__)}/macho/macho_file"
-require "#{File.dirname(__FILE__)}/macho/fat_file"
-require "#{File.dirname(__FILE__)}/macho/exceptions"
-require "#{File.dirname(__FILE__)}/macho/utils"
-require "#{File.dirname(__FILE__)}/macho/tools"
+require_relative "macho/structure"
+require_relative "macho/view"
+require_relative "macho/headers"
+require_relative "macho/load_commands"
+require_relative "macho/sections"
+require_relative "macho/macho_file"
+require_relative "macho/fat_file"
+require_relative "macho/exceptions"
+require_relative "macho/utils"
+require_relative "macho/tools"
 
 # The primary namespace for ruby-macho.
 module MachO
   # release version
-  VERSION = "1.3.0.pre.1".freeze
+  VERSION = "1.3.0".freeze
 
   # Opens the given filename as a MachOFile or FatFile, depending on its magic.
   # @param filename [String] the file being opened

data/lib/macho/exceptions.rb

@@ -194,4 +194,14 @@ module MachO
       super "Unimplemented: #{thing}"
     end
   end
+
+  # Raised when attempting to create a {FatFile} from one or more {MachOFile}s
+  #  whose offsets will not fit within the resulting 32-bit {Headers::FatArch#offset} fields.
+  class FatArchOffsetOverflowError < MachOError
+    # @param offset [Integer] the offending offset
+    def initialize(offset)
+      super "Offset #{offset} exceeds the 32-bit width of a fat_arch offset." \
+            " Consider merging with `fat64: true`"
+    end
+  end
 end

data/lib/macho/fat_file.rb

@@ -14,7 +14,7 @@ module MachO
     # @return [Headers::FatHeader] the file's header
     attr_reader :header
 
-    # @return [Array<Headers::FatArch>] an array of fat architectures
+    # @return [Array<Headers::FatArch>, Array<Headers::FatArch64] an array of fat architectures
     attr_reader :fat_archs
 
     # @return [Array<MachOFile>] an array of Mach-O binaries
@@ -22,22 +22,54 @@ module MachO
 
     # Creates a new FatFile from the given (single-arch) Mach-Os
     # @param machos [Array<MachOFile>] the machos to combine
+    # @param fat64 [Boolean] whether to use {Headers::FatArch64}s to represent each slice
     # @return [FatFile] a new FatFile containing the give machos
-    def self.new_from_machos(*machos)
-      header = Headers::FatHeader.new(Headers::FAT_MAGIC, machos.size)
-      offset = Headers::FatHeader.bytesize + (machos.size * Headers::FatArch.bytesize)
-      fat_archs = []
+    # @raise [ArgumentError] if less than one Mach-O is given
+    # @raise [FatArchOffsetOverflowError] if the Mach-Os are too big to be represented
+    #  in a 32-bit {Headers::FatArch} and `fat64` is `false`.
+    def self.new_from_machos(*machos, fat64: false)
+      raise ArgumentError, "expected at least one Mach-O" if machos.empty?
+
+      fa_klass, magic = if fat64
+        [Headers::FatArch64, Headers::FAT_MAGIC_64]
+      else
+        [Headers::FatArch, Headers::FAT_MAGIC]
+      end
+
+      # put the smaller alignments further forwards in fat macho, so that we do less padding
+      machos = machos.sort_by(&:segment_alignment)
+
+      bin = if String.instance_methods.include? :+@
+        +""
+      else
+        ""
+      end
+
+      bin << Headers::FatHeader.new(magic, machos.size).serialize
+      offset = Headers::FatHeader.bytesize + (machos.size * fa_klass.bytesize)
+
+      macho_pads = {}
+
       machos.each do |macho|
-        fat_archs << Headers::FatArch.new(macho.header.cputype,
-                                          macho.header.cpusubtype,
-                                          offset, macho.serialize.bytesize,
-                                          macho.alignment)
-        offset += macho.serialize.bytesize
+        macho_offset = Utils.round(offset, 2**macho.segment_alignment)
+
+        if !fat64 && macho_offset > (2**32 - 1)
+          raise FatArchOffsetOverflowError, macho_offset
+        end
+
+        macho_pads[macho] = Utils.padding_for(offset, 2**macho.segment_alignment)
+
+        bin << fa_klass.new(macho.header.cputype, macho.header.cpusubtype,
+                            macho_offset, macho.serialize.bytesize,
+                            macho.segment_alignment).serialize
+
+        offset += (macho.serialize.bytesize + macho_pads[macho])
       end
 
-      bin = header.serialize
-      bin << fat_archs.map(&:serialize).join
-      bin << machos.map(&:serialize).join
+      machos.each do |macho|
+        bin << Utils.nullpad(macho_pads[macho])
+        bin << macho.serialize
+      end
 
       new_from_bin(bin)
     end
@@ -262,6 +294,7 @@ module MachO
     # @note Overwrites all data in the file!
     def write!
       raise MachOError, "no initial file to write to" if filename.nil?
+
       File.open(@filename, "wb") { |f| f.write(@raw_data) }
     end
 
@@ -311,10 +344,12 @@ module MachO
     def populate_fat_archs
       archs = []
 
-      fa_off = Headers::FatHeader.bytesize
-      fa_len = Headers::FatArch.bytesize
+      fa_klass = Utils.fat_magic32?(header.magic) ? Headers::FatArch : Headers::FatArch64
+      fa_off   = Headers::FatHeader.bytesize
+      fa_len   = fa_klass.bytesize
+
       header.nfat_arch.times do |i|
-        archs << Headers::FatArch.new_from_bin(:big, @raw_data[fa_off + (fa_len * i), fa_len])
+        archs << fa_klass.new_from_bin(:big, @raw_data[fa_off + (fa_len * i), fa_len])
       end
 
       archs
@@ -364,6 +399,7 @@ module MachO
 
           # Strict mode: Immediately re-raise. Otherwise: Retain, check later.
           raise error if strict
+
           errors << error
         end
       end

data/lib/macho/headers.rb

@@ -6,11 +6,19 @@ module MachO
     FAT_MAGIC = 0xcafebabe
 
     # little-endian fat magic
-    # this is defined, but should never appear in ruby-macho code because
-    # fat headers are always big-endian and therefore always unpacked as such.
+    # @note This is defined for completeness, but should never appear in ruby-macho code,
+    #  since fat headers are always big-endian.
     # @api private
     FAT_CIGAM = 0xbebafeca
 
+    # 64-bit big-endian fat magic
+    FAT_MAGIC_64 = 0xcafebabf
+
+    # 64-bit little-endian fat magic
+    # @note This is defined for completeness, but should never appear in ruby-macho code,
+    #   since fat headers are always big-endian.
+    FAT_CIGAM_64 = 0xbfbafeca
+
     # 32-bit big-endian magic
     # @api private
     MH_MAGIC = 0xfeedface
@@ -31,6 +39,7 @@ module MachO
     # @api private
     MH_MAGICS = {
       FAT_MAGIC => "FAT_MAGIC",
+      FAT_MAGIC_64 => "FAT_MAGIC_64",
       MH_MAGIC => "MH_MAGIC",
       MH_CIGAM => "MH_CIGAM",
       MH_MAGIC_64 => "MH_MAGIC_64",
@@ -41,6 +50,11 @@ module MachO
     # @api private
     CPU_ARCH_ABI64 = 0x01000000
 
+    # mask for CPUs with 64-bit architectures (when running a 32-bit ABI?)
+    # @see https://github.com/Homebrew/ruby-macho/issues/113
+    # @api private
+    CPU_ARCH_ABI32 = 0x02000000
+
     # any CPU (unused?)
     # @api private
     CPU_TYPE_ANY = -1
@@ -69,6 +83,10 @@ module MachO
     # @api private
     CPU_TYPE_ARM64 = (CPU_TYPE_ARM | CPU_ARCH_ABI64)
 
+    # 64-bit ARM compatible CPUs (running in 32-bit mode?)
+    # @see https://github.com/Homebrew/ruby-macho/issues/113
+    CPU_TYPE_ARM64_32 = (CPU_TYPE_ARM | CPU_ARCH_ABI32)
+
     # PowerPC compatible CPUs
     # @api private
     CPU_TYPE_POWERPC = 0x12
@@ -85,6 +103,7 @@ module MachO
       CPU_TYPE_X86_64 => :x86_64,
       CPU_TYPE_ARM => :arm,
       CPU_TYPE_ARM64 => :arm64,
+      CPU_TYPE_ARM64_32 => :arm64_32,
       CPU_TYPE_POWERPC => :ppc,
       CPU_TYPE_POWERPC64 => :ppc64,
     }.freeze
@@ -218,6 +237,10 @@ module MachO
     # @api private
     CPU_SUBTYPE_ARM64_V8 = 1
 
+    # the v8 sub-type for `CPU_TYPE_ARM64_32`
+    # @api private
+    CPU_SUBTYPE_ARM64_32_V8 = 1
+
     # the lowest common sub-type for `CPU_TYPE_MC88000`
     # @api private
     CPU_SUBTYPE_MC88000_ALL = 0
@@ -328,6 +351,9 @@ module MachO
         CPU_SUBTYPE_ARM64_ALL => :arm64,
         CPU_SUBTYPE_ARM64_V8 => :arm64v8,
       }.freeze,
+      CPU_TYPE_ARM64_32 => {
+        CPU_SUBTYPE_ARM64_32_V8 => :arm64_32v8,
+      }.freeze,
       CPU_TYPE_POWERPC => {
         CPU_SUBTYPE_POWERPC_ALL => :ppc,
         CPU_SUBTYPE_POWERPC_601 => :ppc601,
@@ -486,8 +512,10 @@ module MachO
       end
     end
 
-    # Fat binary header architecture structure. A Fat binary has one or more of
-    # these, representing one or more internal Mach-O blobs.
+    # 32-bit fat binary header architecture structure. A 32-bit fat Mach-O has one or more of
+    #  these, indicating one or more internal Mach-O blobs.
+    # @note "32-bit" indicates the fact that this structure stores 32-bit offsets, not that the
+    #  Mach-Os that it points to necessarily *are* 32-bit.
     # @see MachO::Headers::FatHeader
     class FatArch < MachOStructure
       # @return [Integer] the CPU type of the Mach-O
@@ -505,10 +533,10 @@ module MachO
       # @return [Integer] the alignment, as a power of 2
       attr_reader :align
 
-      # always big-endian
+      # @note Always big endian.
       # @see MachOStructure::FORMAT
       # @api private
-      FORMAT = "N5".freeze
+      FORMAT = "L>5".freeze
 
       # @see MachOStructure::SIZEOF
       # @api private
@@ -542,6 +570,43 @@ module MachO
       end
     end
 
+    # 64-bit fat binary header architecture structure. A 64-bit fat Mach-O has one or more of
+    #  these, indicating one or more internal Mach-O blobs.
+    # @note "64-bit" indicates the fact that this structure stores 64-bit offsets, not that the
+    #  Mach-Os that it points to necessarily *are* 64-bit.
+    # @see MachO::Headers::FatHeader
+    class FatArch64 < FatArch
+      # @return [void]
+      attr_reader :reserved
+
+      # @note Always big endian.
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L>2Q>2L>2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 32
+
+      # @api private
+      def initialize(cputype, cpusubtype, offset, size, align, reserved = 0)
+        super(cputype, cpusubtype, offset, size, align)
+        @reserved = reserved
+      end
+
+      # @return [String] the serialized fields of the fat arch
+      def serialize
+        [cputype, cpusubtype, offset, size, align, reserved].pack(FORMAT)
+      end
+
+      # @return [Hash] a hash representation of this {FatArch64}
+      def to_h
+        {
+          "reserved" => reserved,
+        }.merge super
+      end
+    end
+
     # 32-bit Mach-O file header structure
     class MachHeader < MachOStructure
       # @return [Integer] the magic number
@@ -593,7 +658,9 @@ module MachO
       # @return [Boolean] true if `flag` is present in the header's flag section
       def flag?(flag)
         flag = MH_FLAGS[flag]
+
         return false if flag.nil?
+
         flags & flag == flag
       end
 

data/lib/macho/load_commands.rb

@@ -242,6 +242,7 @@ module MachO
       # @api private
       def serialize(context)
         raise LoadCommandNotSerializableError, LOAD_COMMANDS[cmd] unless serializable?
+
         format = Utils.specialize_format(FORMAT, context.endianness)
         [cmd, SIZEOF].pack(format)
       end
@@ -298,7 +299,9 @@ module MachO
             lc_end = view.offset + lc.cmdsize - 1
             raw_string = view.raw_data.slice(lc_str_abs..lc_end)
             @string, null_byte, _padding = raw_string.partition("\x00")
+
             raise LCStrMalformedError, lc if null_byte.empty?
+
             @string_offset = lc_str
           else
             @string = lc_str
@@ -473,10 +476,32 @@ module MachO
       # @return [Boolean] true if `flag` is present in the segment's flag field
       def flag?(flag)
         flag = SEGMENT_FLAGS[flag]
+
         return false if flag.nil?
+
         flags & flag == flag
       end
 
+      # Guesses the alignment of the segment.
+      # @return [Integer] the guessed alignment, as a power of 2
+      # @note See `guess_align` in `cctools/misc/lipo.c`
+      def guess_align
+        return Sections::MAX_SECT_ALIGN if vmaddr.zero?
+
+        align = 0
+        segalign = 1
+
+        while (segalign & vmaddr).zero?
+          segalign <<= 1
+          align += 1
+        end
+
+        return 2 if align < 2
+        return Sections::MAX_SECT_ALIGN if align > Sections::MAX_SECT_ALIGN
+
+        align
+      end
+
       # @return [Hash] a hash representation of this {SegmentCommand}
       def to_h
         {

data/lib/macho/macho_file.rb

@@ -219,8 +219,7 @@ module MachO
       update_sizeofcmds(sizeofcmds - lc.cmdsize)
 
       # pad the space after the load commands to preserve offsets
-      null_pad = "\x00" * lc.cmdsize
-      @raw_data.insert(header.class.bytesize + sizeofcmds - lc.cmdsize, null_pad)
+      @raw_data.insert(header.class.bytesize + sizeofcmds - lc.cmdsize, Utils.nullpad(lc.cmdsize))
 
       populate_fields if options.fetch(:repopulate, true)
     end
@@ -252,6 +251,33 @@ module MachO
       end
     end
 
+    # The segment alignment for the Mach-O. Guesses conservatively.
+    # @return [Integer] the alignment, as a power of 2
+    # @note This is **not** the same as {#alignment}!
+    # @note See `get_align` and `get_align_64` in `cctools/misc/lipo.c`
+    def segment_alignment
+      # special cases: 12 for x86/64/PPC/PP64, 14 for ARM/ARM64
+      return 12 if %i[i386 x86_64 ppc ppc64].include?(cputype)
+      return 14 if %i[arm arm64].include?(cputype)
+
+      cur_align = Sections::MAX_SECT_ALIGN
+
+      segments.each do |segment|
+        if filetype == :object
+          # start with the smallest alignment, and work our way up
+          align = magic32? ? 2 : 3
+          segment.sections.each do |section|
+            align = section.align unless section.align <= align
+          end
+        else
+          align = segment.guess_align
+        end
+        cur_align = align if align < cur_align
+      end
+
+      cur_align
+    end
+
     # The Mach-O's dylib ID, or `nil` if not a dylib.
     # @example
     #  file.dylib_id # => 'libBar.dylib'
@@ -405,6 +431,7 @@ module MachO
     # @note Overwrites all data in the file!
     def write!
       raise MachOError, "no initial file to write to" if @filename.nil?
+
       File.open(@filename, "wb") { |f| f.write(@raw_data) }
     end
 

data/lib/macho/sections.rb

@@ -13,6 +13,10 @@ module MachO
     # system settable attributes mask
     SECTION_ATTRIBUTES_SYS = 0x00ffff00
 
+    # maximum specifiable section alignment, as a power of 2
+    # @note see `MAXSECTALIGN` macro in `cctools/misc/lipo.c`
+    MAX_SECT_ALIGN = 15
+
     # association of section flag symbols to values
     # @api private
     SECTION_FLAGS = {
@@ -146,7 +150,9 @@ module MachO
       # @return [Boolean] whether the flag is present in the section's {flags}
       def flag?(flag)
         flag = SECTION_FLAGS[flag]
+
         return false if flag.nil?
+
         flags & flag == flag
       end
 

data/lib/macho/tools.rb

@@ -89,8 +89,9 @@ module MachO
     # Merge multiple Mach-Os into one universal (Fat) binary.
     # @param filename [String] the fat binary to create
     # @param files [Array<String>] the files to merge
+    # @param fat64 [Boolean] whether to use {Headers::FatArch64}s to represent each slice
     # @return [void]
-    def self.merge_machos(filename, *files)
+    def self.merge_machos(filename, *files, fat64: false)
       machos = files.map do |file|
         macho = MachO.open(file)
         case macho
@@ -101,7 +102,7 @@ module MachO
         end
       end.flatten
 
-      fat_macho = MachO::FatFile.new_from_machos(*machos)
+      fat_macho = MachO::FatFile.new_from_machos(*machos, :fat64 => fat64)
       fat_macho.write(filename)
     end
   end

data/lib/macho/utils.rb

@@ -22,6 +22,16 @@ module MachO
       round(size, alignment) - size
     end
 
+    # Returns a string of null bytes of the requested (non-negative) size
+    # @param size [Integer] the size of the nullpad
+    # @return [String] the null string (or empty string, for `size = 0`)
+    # @raise [ArgumentError] if a non-positive nullpad is requested
+    def self.nullpad(size)
+      raise ArgumentError, "size < 0: #{size}" if size < 0
+
+      "\x00" * size
+    end
+
     # Converts an abstract (native-endian) String#unpack format to big or
     #  little.
     # @param format [String] the format string being converted
@@ -46,11 +56,11 @@ module MachO
       strings.each do |key, string|
         offsets[key] = next_offset
         payload << string
-        payload << "\x00"
+        payload << Utils.nullpad(1)
         next_offset += string.bytesize + 1
       end
 
-      payload << "\x00" * padding_for(fixed_offset + payload.bytesize, alignment)
+      payload << Utils.nullpad(padding_for(fixed_offset + payload.bytesize, alignment))
       [payload, offsets]
     end
 
@@ -65,35 +75,49 @@ module MachO
     # @param num [Integer] the number being checked
     # @return [Boolean] whether `num` is a valid Fat magic number
     def self.fat_magic?(num)
+      [Headers::FAT_MAGIC, Headers::FAT_MAGIC_64].include? num
+    end
+
+    # Compares the given number to valid 32-bit Fat magic numbers.
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 32-bit fat magic number
+    def self.fat_magic32?(num)
       num == Headers::FAT_MAGIC
     end
 
+    # Compares the given number to valid 64-bit Fat magic numbers.
+    # @param num [Integer] the number being checked
+    # @return [Boolean] whether `num` is a valid 64-bit fat magic number
+    def self.fat_magic64?(num)
+      num == Headers::FAT_MAGIC_64
+    end
+
     # Compares the given number to valid 32-bit Mach-O magic numbers.
     # @param num [Integer] the number being checked
     # @return [Boolean] whether `num` is a valid 32-bit magic number
     def self.magic32?(num)
-      num == Headers::MH_MAGIC || num == Headers::MH_CIGAM
+      [Headers::MH_MAGIC, Headers::MH_CIGAM].include? num
     end
 
     # Compares the given number to valid 64-bit Mach-O magic numbers.
     # @param num [Integer] the number being checked
     # @return [Boolean] whether `num` is a valid 64-bit magic number
     def self.magic64?(num)
-      num == Headers::MH_MAGIC_64 || num == Headers::MH_CIGAM_64
+      [Headers::MH_MAGIC_64, Headers::MH_CIGAM_64].include? num
     end
 
     # Compares the given number to valid little-endian magic numbers.
     # @param num [Integer] the number being checked
     # @return [Boolean] whether `num` is a valid little-endian magic number
     def self.little_magic?(num)
-      num == Headers::MH_CIGAM || num == Headers::MH_CIGAM_64
+      [Headers::MH_CIGAM, Headers::MH_CIGAM_64].include? num
     end
 
     # Compares the given number to valid big-endian magic numbers.
     # @param num [Integer] the number being checked
     # @return [Boolean] whether `num` is a valid big-endian magic number
     def self.big_magic?(num)
-      num == Headers::MH_CIGAM || num == Headers::MH_CIGAM_64
+      [Headers::MH_MAGIC, Headers::MH_MAGIC_64].include? num
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-macho
 version: !ruby/object:Gem::Version
-  version: 1.3.0.pre.1
+  version: 1.3.0
 platform: ruby
 authors:
 - William Woodruff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-21 00:00:00.000000000 Z
+date: 2018-09-30 00:00:00.000000000 Z
 dependencies: []
 description: A library for viewing and manipulating Mach-O files in Ruby.
 email: william@yossarian.net
@@ -42,12 +42,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.6