ocran 1.4.6 → 1.5.0

data/lib/ocran/pe_imports.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Ocran
+  # Reads the names of the DLLs a PE image (exe, dll, or a Ruby extension
+  # .so on Windows) imports, from its import and delay-load import tables.
+  # Pure Ruby, so it also works where the image cannot be loaded.
+  module PEImports
+    IMPORT_DIRECTORY = 1
+    DELAY_IMPORT_DIRECTORY = 13
+
+    module_function
+
+    # Returns the imported DLL names in table order, or [] for a file that
+    # is not a well-formed PE image.
+    def dll_names(path)
+      Image.new(File.binread(path)).dll_names
+    rescue SystemCallError, RangeError, ArgumentError
+      []
+    end
+
+    class Image
+      def initialize(data)
+        @data = data
+      end
+
+      def dll_names
+        return [] unless @data.byteslice(0, 2) == "MZ"
+
+        pe = u32(0x3c)
+        return [] unless @data.byteslice(pe, 4) == "PE\0\0"
+
+        section_count = u16(pe + 6)
+        optional_header = pe + 24
+        optional_header_size = u16(pe + 20)
+        directories, directory_count =
+          case u16(optional_header)
+          when 0x10b then [optional_header + 96, u32(optional_header + 92)]  # PE32
+          when 0x20b then [optional_header + 112, u32(optional_header + 108)] # PE32+
+          else return []
+          end
+
+        @sections = Array.new(section_count) do |i|
+          s = optional_header + optional_header_size + i * 40
+          { va: u32(s + 12), size: [u32(s + 8), u32(s + 16)].max, raw: u32(s + 20) }
+        end
+
+        names = []
+        if directory_count > IMPORT_DIRECTORY
+          # IMAGE_IMPORT_DESCRIPTOR: 20 bytes, the DLL name RVA at +12
+          each_descriptor(directories + IMPORT_DIRECTORY * 8, 20, 12) { |name| names << name }
+        end
+        if directory_count > DELAY_IMPORT_DIRECTORY
+          # IMAGE_DELAYLOAD_DESCRIPTOR: 32 bytes, the DLL name RVA at +4
+          each_descriptor(directories + DELAY_IMPORT_DIRECTORY * 8, 32, 4) { |name| names << name }
+        end
+        names.uniq(&:downcase)
+      end
+
+      private
+
+      def each_descriptor(directory, size, name_field)
+        table = offset_of(u32(directory))
+        return unless table
+
+        # Never past the table's declared size, in case a malformed image
+        # lacks the terminating all-zero descriptor.
+        (u32(directory + 4) / size).times do
+          name_rva = u32(table + name_field)
+          break if name_rva.zero?
+
+          offset = offset_of(name_rva)
+          break unless offset
+
+          name = @data.byteslice(offset, 260)&.unpack1("Z*")
+          yield name if name && !name.empty?
+          table += size
+        end
+      end
+
+      def offset_of(rva)
+        return nil if rva.zero?
+
+        section = @sections.find { |s| rva >= s[:va] && rva < s[:va] + s[:size] }
+        section && rva - section[:va] + section[:raw]
+      end
+
+      def u16(offset)
+        @data.byteslice(offset, 2)&.unpack1("v") or raise RangeError
+      end
+
+      def u32(offset)
+        @data.byteslice(offset, 4)&.unpack1("V") or raise RangeError
+      end
+    end
+  end
+end

data/lib/ocran/pe_resources.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+require_relative "ed_resource_builder"
+
+module Ocran
+  # Reads and rewrites the resources of a PE executable in pure Ruby, so that
+  # icons and version information can be set on any build host - the
+  # Windows API OCRAN uses for the stub (BeginUpdateResource) exists only on
+  # Windows. Used for --static-runtime, whose executable is a copy of the runtime.
+  #
+  # The resource tree is a Hash: type => { name => { language => data } },
+  # where types and names are Integers (IDs) or Strings. #write puts the
+  # rebuilt tree into a new section at the end of the image and points the
+  # resource data directory at it; the old resource section stays where it
+  # is, unused (renamed .rsrc_o), so no other section has to move.
+  class PeResources
+    RT_ICON = 3
+    RT_STRING = 6
+    RT_GROUP_ICON = 14
+    RT_VERSION = 16
+    RT_MANIFEST = 24
+    SECTION_CHARACTERISTICS = 0x40000040 # initialized data, readable
+
+    attr_reader :tree
+
+    def initialize(bytes)
+      @bytes = bytes.b
+      parse_headers
+      @tree = read_tree
+    end
+
+    def self.update(path)
+      pe = new(File.binread(path))
+      yield pe
+      File.binwrite(path, pe.to_bytes)
+    end
+
+    # Replaces the icon(s) with the images of an .ico file.
+    def set_icon(ico_data)
+      ico = ico_data.b
+      reserved, type, count = ico.unpack("vvv")
+      raise "not an icon file" unless reserved.zero? && type == 1 && count.positive?
+
+      icons = {}
+      group = [0, 1, count].pack("vvv")
+      count.times do |i|
+        w, h, colors, res, planes, bits, size, offset = ico.unpack("CCCCvvVV", offset: 6 + i * 16)
+        icons[i + 1] = { EdResource::LANGID => ico.byteslice(offset, size) }
+        group << [w, h, colors, res, planes, bits, size, i + 1].pack("CCCCvvVv")
+      end
+      @tree[RT_ICON] = icons
+      @tree[RT_GROUP_ICON] = { 1 => { EdResource::LANGID => group } }
+    end
+
+    def set_version_info(blob)
+      @tree[RT_VERSION] = { 1 => { EdResource::LANGID => blob.b } }
+    end
+
+    def manifest
+      @tree.dig(RT_MANIFEST, 1)&.values&.first
+    end
+
+    def set_manifest(xml)
+      @tree[RT_MANIFEST] = { 1 => { EdResource::LANGID => xml.b } }
+    end
+
+    def set_strings(id_to_value)
+      table = (@tree[RT_STRING] ||= {})
+      id_to_value.group_by { |id, _| id.to_i / 16 }.each do |bundle, pairs|
+        table[bundle + 1] = { EdResource::LANGID => EdResource::Build.string_bundle(pairs.to_h) }
+      end
+    end
+
+    def to_bytes
+      out = @bytes.dup
+      rva = align(@sections.map { |s| s[:va] + [s[:vsize], s[:rsize]].max }.max, @section_align)
+      section = build_tree(rva)
+      raw_size = align(section.bytesize, @file_align)
+      raw_at = align(@sections.map { |s| s[:raw] + s[:rsize] }.max, @file_align)
+      # The new section goes where the file's sections end; whatever follows
+      # them (an Authenticode signature, an overlay) would be cut off.
+      if @bytes.bytesize > raw_at
+        raise "the PE file has #{@bytes.bytesize - raw_at} bytes after its last section " \
+              "(a signature or other appended data); its resources cannot be rewritten"
+      end
+      table_at = @section_table + @sections.size * 40
+      raise "no room in the PE header for another section" if table_at + 40 > @size_of_headers
+
+      out = out.byteslice(0, raw_at).ljust(raw_at, "\0".b)
+      out << section << ("\0".b * (raw_size - section.bytesize))
+      header = [".rsrc".b.ljust(8, "\0".b), section.bytesize, rva, raw_size, raw_at, 0, 0, 0, 0,
+                SECTION_CHARACTERISTICS].pack("a8VVVVVVvvV")
+      out[table_at, 40] = header
+      out[@pe + 6, 2] = [@sections.size + 1].pack("v")
+      out[@optional + 56, 4] = [align(rva + section.bytesize, @section_align)].pack("V") # SizeOfImage
+      out[@optional + 64, 4] = [0].pack("V") # CheckSum: not checked for user-mode executables
+      out[@data_dirs + 16, 8] = [rva, section.bytesize].pack("VV")
+      if (old = @sections.find { |s| s[:va] == @resource_rva })
+        out[old[:header], 8] = ".rsrc_o".b.ljust(8, "\0".b)
+      end
+      out
+    end
+
+    private
+
+    def align(value, to) = (value + to - 1) / to * to
+
+    def parse_headers
+      raise "not a PE executable" unless @bytes.start_with?("MZ")
+
+      @pe = @bytes.unpack1("V", offset: 0x3c)
+      raise "not a PE executable" unless @bytes.byteslice(@pe, 4) == "PE\0\0".b
+
+      count = @bytes.unpack1("v", offset: @pe + 6)
+      size_of_optional = @bytes.unpack1("v", offset: @pe + 20)
+      @optional = @pe + 24
+      pe32_plus = @bytes.unpack1("v", offset: @optional) == 0x20b
+      @section_align, @file_align = @bytes.unpack("VV", offset: @optional + 32)
+      @size_of_headers = @bytes.unpack1("V", offset: @optional + 60)
+      @data_dirs = @optional + (pe32_plus ? 112 : 96)
+      @resource_rva, @resource_size = @bytes.unpack("VV", offset: @data_dirs + 16)
+      @section_table = @optional + size_of_optional
+      @sections = (0...count).map do |i|
+        at = @section_table + i * 40
+        vsize, va, rsize, raw = @bytes.unpack("VVVV", offset: at + 8)
+        { header: at, vsize: vsize, va: va, rsize: rsize, raw: raw }
+      end
+    end
+
+    def rva_to_offset(rva)
+      s = @sections.find { |sec| rva >= sec[:va] && rva < sec[:va] + [sec[:vsize], sec[:rsize]].max }
+      raise "RVA #{rva} is in no section" unless s
+
+      rva - s[:va] + s[:raw]
+    end
+
+    def read_tree
+      return {} if @resource_rva.zero?
+
+      @root = rva_to_offset(@resource_rva)
+      read_directory(0, 3)
+    end
+
+    def read_directory(offset, depth)
+      at = @root + offset
+      named, ids = @bytes.unpack("vv", offset: at + 12)
+      (0...(named + ids)).to_h do |i|
+        name, target = @bytes.unpack("VV", offset: at + 16 + i * 8)
+        key = name & 0x80000000 != 0 ? read_name(name & 0x7fffffff) : name
+        value =
+          if target & 0x80000000 != 0
+            read_directory(target & 0x7fffffff, depth - 1)
+          else
+            data_rva, size = @bytes.unpack("VV", offset: @root + target)
+            @bytes.byteslice(rva_to_offset(data_rva), size)
+          end
+        [key, value]
+      end
+    end
+
+    def read_name(offset)
+      length = @bytes.unpack1("v", offset: @root + offset)
+      @bytes.byteslice(@root + offset + 2, length * 2).force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8)
+    end
+
+    # Serializes the tree the way resource compilers lay it out: all
+    # directories, then name strings, then data entries, then the data.
+    def build_tree(rva)
+      levels = []
+      collect = lambda do |node, depth|
+        dir = { entries: sort_entries(node) }
+        levels << dir
+        dir[:entries].each do |entry|
+          entry[:child] = depth < 2 ? collect.(entry[:value], depth + 1) : { leaf: entry[:value] }
+        end
+        dir
+      end
+      root = collect.(@tree, 0)
+
+      offset = 0
+      levels.each { |d| d[:offset] = offset; offset += 16 + d[:entries].size * 8 }
+      names = {}
+      levels.each do |d|
+        d[:entries].each do |e|
+          next unless e[:key].is_a?(String)
+
+          names[e[:key]] ||= begin
+            at = offset
+            offset += 2 + e[:key].encode(Encoding::UTF_16LE).bytesize
+            at
+          end
+        end
+      end
+      offset = align(offset, 4)
+      leaves = levels.flat_map { |d| d[:entries].map { |e| e[:child] } }.select { |c| c[:leaf] }
+      leaves.each { |l| l[:entry] = offset; offset += 16 }
+      leaves.each { |l| offset = align(offset, 8); l[:data] = offset; offset += l[:leaf].bytesize }
+
+      out = "\0".b * offset
+      levels.each do |d|
+        named = d[:entries].count { |e| e[:key].is_a?(String) }
+        out[d[:offset], 16] = [0, 0, 0, 0, named, d[:entries].size - named].pack("VVvvvv")
+        d[:entries].each_with_index do |e, i|
+          name = e[:key].is_a?(String) ? 0x80000000 | names[e[:key]] : e[:key]
+          target = e[:child][:leaf] ? e[:child][:entry] : 0x80000000 | e[:child][:offset]
+          out[d[:offset] + 16 + i * 8, 8] = [name, target].pack("VV")
+        end
+      end
+      names.each do |name, at|
+        utf16 = name.encode(Encoding::UTF_16LE).b
+        out[at, 2 + utf16.bytesize] = [utf16.bytesize / 2].pack("v") + utf16
+      end
+      leaves.each do |l|
+        out[l[:entry], 16] = [rva + l[:data], l[:leaf].bytesize, 0, 0].pack("VVVV")
+        out[l[:data], l[:leaf].bytesize] = l[:leaf]
+      end
+      out
+    end
+
+    # Named entries first, in case-insensitive order, then IDs ascending,
+    # as Windows' binary search through a directory expects.
+    def sort_entries(node)
+      named, ids = node.partition { |k, _| k.is_a?(String) }
+      (named.sort_by { |k, _| k.upcase } + ids.sort_by(&:first)).map { |k, v| { key: k, value: v } }
+    end
+  end
+end

data/lib/ocran/refine_pathname.rb

@@ -4,7 +4,24 @@ require "pathname"
 module Ocran
   # The Pathname class in Ruby is modified to handle mixed path separators and
   # to be case-insensitive.
+  #
+  # Caveat: refinements apply only to calls written in a file that is
+  # `using RefinePathname`. Hash, Set, Array#uniq, Array#include? and Array#-
+  # call hash/eql?/== from C, which never sees a refinement, so collections
+  # of Pathnames keep comparing them case- and separator-sensitively. Where
+  # a collection has to treat two spellings of one file as the same, key it
+  # on Pathname#path_key instead (e.g. `paths.uniq { |p| p.path_key }`).
   module RefinePathname
+    # The spelling-independent form of +path+ on this platform: separators
+    # unified and, on case-insensitive file systems (Windows), downcased. On
+    # POSIX it is the path itself.
+    def self.path_key(path)
+      s = path.to_s
+      s = s.tr(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
+      s = s.downcase if File::FNM_SYSCASE.nonzero?
+      s
+    end
+
     refine Pathname do
       def normalize_file_separator(s)
         if File::ALT_SEPARATOR
@@ -15,56 +32,36 @@ module Ocran
       end
       private :normalize_file_separator
 
-      # Compares two paths for equality based on the case sensitivity of the
-      # Ruby execution environment's file system.
-      # If the file system is case-insensitive, it performs a case-insensitive
-      # comparison. Otherwise, it performs a case-sensitive comparison.
-      def pathequal(a, b)
-        if File::FNM_SYSCASE.nonzero?
-          a.casecmp(b) == 0
-        else
-          a == b
-        end
-      end
-      private :pathequal
-
       def to_posix
         normalize_file_separator(to_s)
       end
 
+      # See RefinePathname.path_key. Two Pathnames denote the same file on
+      # this platform when their keys are equal.
+      def path_key
+        RefinePathname.path_key(self)
+      end
+
       # Checks if two Pathname objects are equal, considering the file system's
       # case sensitivity and path separators. Returns false if the other object is not
       # an Pathname.
-      # This method enables the use of the `uniq` method on arrays of Pathname objects.
+      # NOTE: only calls written in refined code see this; Array#uniq and
+      # the like do not (see the caveat on RefinePathname).
       def eql?(other)
         return false unless other.is_a?(Pathname)
 
-        a = normalize_file_separator(to_s)
-        b = normalize_file_separator(other.to_s)
-        pathequal(a, b)
+        path_key == other.path_key
       end
 
       alias == eql?
       alias === eql?
 
-      # Calculates a normalized hash value for a pathname to ensure consistent
-      # hashing across different environments, particularly in Windows.
-      # This method first normalizes the path by:
-      # 1. Converting the file separator from the platform-specific separator
-      #    to the common POSIX separator ('/') if necessary.
-      # 2. Converting the path to lowercase if the filesystem is case-insensitive.
-      # The normalized path string is then hashed, providing a stable hash value
-      # that is consistent with the behavior of eql? method, thus maintaining
-      # the integrity of hash-based data structures like Hash or Set.
+      # A hash value consistent with eql?, based on the normalized path. As
+      # with eql?, Hash and Set do not call this refinement.
       #
       # @return [Integer] A hash integer based on the normalized path.
       def hash
-        path = if File::FNM_SYSCASE.nonzero?
-                 to_s.downcase
-               else
-                 to_s
-               end
-        normalize_file_separator(path).hash
+        path_key.hash
       end
 
       # Checks if the current path is a sub path of the specified base_directory.