mootool 0.1.0 → 0.2

data/lib/mootool/controller_base.rb

@@ -3,7 +3,10 @@
 CONTROLLERS_PATH = File.join(File.dirname(__FILE__), 'controllers')
 
 module MooTool
+  # Controller base is the base class for all controllers that respond to command line requests.
   class ControllerBase
+    @controllers = []
+
     def self.load_all
       Dir.glob(File.join(CONTROLLERS_PATH, '*')).each do |file|
         require file
@@ -15,8 +18,8 @@ module MooTool
     end
 
     def self.inherited(child)
-      @@controllers ||= []
       @@controllers << child
+      super
     end
 
     class << self

data/lib/mootool/controllers/dwarf.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MooTools
+  module Controllers
+    class DWARF < ControllerBase
+    end
+  end
+end

data/lib/mootool/controllers/dyld_linker.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MooTool
+  module Controllers
+    class DyldLinker < ControllerBase
+    end
+  end
+end

data/lib/mootool/controllers/dyld_shared_cache.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MooTool
+  module Controllers
+    class DyldSharedCache < ControllerBase
+    end
+  end
+end

data/lib/mootool/controllers/fat_binary.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MooTool
+  module Controllers
+    class FatBinary < ControllerBase
+    end
+  end
+end

data/lib/mootool/controllers/kernel_collection.rb

@@ -1,24 +1,30 @@
 # frozen_string_literal: true
 
 module MooTool
-  class KernelCollection < ControllerBase
-    command 'kc'
-    description 'Kernel Collections'
+  module Controllers
+    # Controller for extracting or viewing a KernelCollection (.kc file)
+    class KernelCollection < ControllerBase
+      command 'kc'
+      description 'Kernel Collections'
 
-    def extract(command, output_folder)
-      file = MachO.open command.file
-      input = File.open(command.file, 'rb')
+      def extract(command, output_folder)
+        file = MachO.open command.file
+        input = File.open(command.file, 'rb')
 
-      file.command(:LC_FILESET_ENTRY).each do |entry|
-        output_path = File.join(output_folder, entry.entry_id.to_s)
-        puts "Writing to #{output_path}"
-        output_file = File.open(output_path, 'wb')
-        matching = file.command(:LC_SEGMENT_64).find { |command| command.fileoff == entry.fileoff }
+        file.command(:LC_FILESET_ENTRY).each do |entry|
+          output_path = File.join(output_folder, entry.entry_id.to_s)
+          puts "Writing to #{output_path}"
+          output_file = File.open(output_path, 'wb')
+          # rubocop:disable Naming/VariableNumber
+          # We do not have control of this name as it is part of ruby-macho
+          matching = file.command(:LC_SEGMENT_64).find { |c| c.fileoff == entry.fileoff }
+          # rubocop:enable Naming/VariableNumber
 
-        input.seek(matching.fileoff)
-        output_file.write input.read(matching.filesize)
-        output_file.close
+          input.seek(matching.fileoff)
+          output_file.write input.read(matching.filesize)
+          output_file.close
+        end
       end
     end
   end
-end
+end

data/lib/mootool/controllers/sections.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MooTool
+  module Controllers
+    class Sections < ControllerBase
+    end
+  end
+end

data/lib/mootool/core_extensions.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# typed: true
+
+# rubocop:disable Style/Documentation
+
+class Integer
+  # rubocop:enable Style/Documentation
+  extend T::Sig
+  # Aligns the integer to the nearest multiple of the alignment.
+  # @param alignment [Integer] the alignment
+  # @return [Integer] the aligned integer
+  sig { params(alignment: T.nilable(Integer)).returns(Integer) }
+  def align(alignment = nil)
+    alignment ||= Integer.size
+
+    return self if alignment < 2
+
+    alignment -= 1
+
+    if (self & alignment).zero?
+      self
+    else
+      (self | alignment) + 1
+    end
+  end
+end

data/lib/mootool/models/device_tree.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# typed: true
+
+require 'sorbet-runtime'
+
+module MooTool
+  module Models
+    # DeviceTree is a Apple Device Tree node that has been parsed
+    class DeviceTree
+      extend T::Sig
+
+      NODE_FORMAT = 'VV'
+      PROP_FORMAT = 'A32V'
+
+      # Represents a single node in the device tree
+      class Node
+        extend T::Sig
+
+        attr_reader :children, :properties
+
+        sig { params(data: T.any(IO, StringIO)).void }
+        def initialize(data)
+          vals = T.must(data.read(8)).unpack(NODE_FORMAT)
+          property_count = T.cast(vals[0], Integer)
+          child_count = T.cast(vals[1], Integer)
+
+          @properties = T.let({}, T::Hash[String, Property])
+          @children = T.let([], T::Array[Node])
+
+          property_count.times do
+            prop = Property.new(data)
+            @properties[prop.name] = prop
+          end
+          child_count.times { @children << Node.new(data) }
+        end
+      end
+
+      # Represents a single property and it's value
+      class Property
+        extend T::Sig
+
+        attr_accessor :name, :value
+
+        sig { params(data: T.any(StringIO, IO)).void }
+        def initialize(data)
+          args = T.must(data.read(36)).unpack(PROP_FORMAT)
+
+          @name = T.let(T.cast(args[0], String), String)
+          @size = T.let(T.cast(args[1], Integer), Integer)
+
+          if @size & 0x80000000 != 0
+            @template = true
+            @size &= 0x7fffffff
+          end
+
+          @value = data.read(@size.align(4))
+          @value = T.must(@value)[0..@size]
+        end
+      end
+
+      attr_reader :root
+
+      # @param [String] data
+      sig { params(data: T.any(IO, String, StringIO, Pathname)).void }
+      def initialize(data)
+        case data
+        when Pathname
+          data = T.assert_type!(data, Pathname)
+          @data = File.open(data.realpath, 'rb')
+        when String
+          data = T.assert_type!(data, String)
+          @data = StringIO.new(data)
+        when IO
+          @data = T.cast(data, IO)
+        end
+        @root = Node.new(@data)
+      end
+
+      sig { params(path: String).returns(DeviceTree) }
+      def self.open(path)
+        DeviceTree.new(Pathname.new(path))
+      end
+    end
+  end
+end

data/lib/mootool/models/img4.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'openssl'
+
+module MooTool
+  # Module for Apple's IMG4 encryption and signing format
+  module Img4
+    # An instance of a IMG4 file
+    class File
+      attr_reader :payload, :manifest
+
+      def initialize(path)
+        @path = path
+        der = ::File.binread(path)
+        @data = OpenSSL::ASN1.decode(der)
+
+        case @data.first.value
+        when 'IM4P'
+          @type = @data.value[1].value
+          @build = @data.value[2].value
+          @payload = @data.value[3].value
+        when 'IMG4', 'IM4M'
+          raise 'Not implemented'
+        else
+          raise "Unknown IMG4 type #{@data.first.value}"
+        end
+      end
+
+      def payload?
+        !@payload.nil?
+      end
+
+      def manifest?
+        !@manifest.nil?
+      end
+
+      def basename
+        basename = ::File.basename(@path)
+        extension = ::File.extname(basename)
+        "#{basename.chomp(extension)}.#{@type}"
+      end
+
+      def extract_payload
+        output_path = ::File.join(::File.dirname(@path), basename)
+        ::File.write(output_path, @payload)
+      end
+    end
+  end
+end

data/lib/mootool/models/ipsw.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'zip'
+require 'plist'
+
+module MooTool
+  # Represents a single IPSW package
+  class IPSW
+    def initialize(file)
+      @file = file
+      @zip = Zip::File.open(file)
+      manifest = @zip.find_entry('BuildManifest.plist')
+
+      raise 'Invalid IPSW, does not contain BuildManifest.plist' unless manifest
+
+      @manifest = Plist.parse_xml(manifest.get_input_stream.read)
+    end
+  end
+end

data/lib/mootool/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MooTool
-  VERSION = '0.1.0'
+  VERSION = '0.2'
 end

data/lib/mootool/views/sections.full.erb

@@ -1,5 +1,5 @@
 <% @load_commands.each_index do |index| %>
-Load command <%= index %>
-      cmd <%= @load_commands[index].cmd %>
+  Load command <%= index %>
+  cmd <%= @load_commands[index].cmd %>
   cmdsize <%= @load_commands[index].cmdsize %>
 <% end %>

data/lib/mootool.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
-require 'mootool/version'
-
-require 'bundler/setup'
+require_relative 'mootool/version'
 
 require 'macho'
+require 'zip'
+
+require_relative 'mootool/core_extensions'
 
+# MooTool
 module MooTool
   class Error < StandardError; end
+
   # Your code goes here...
   autoload :Command, 'mootool/command'
   autoload :ControllerBase, 'mootool/controller_base'
+
+  autoload :Img4, 'mootool/models/img4'
+  autoload :DeviceTree, 'mootool/models/device_tree'
+  autoload :IPSW, 'mootool/models/ipsw'
 end

data/mootool.gemspec

@@ -5,27 +5,27 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'mootool/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'mootool'
-  spec.version       = MooTool::VERSION
-  spec.authors       = ['Rick Mark']
-  spec.email         = ['rickmark@outlook.com']
+  spec.name = 'mootool'
+  spec.version = MooTool::VERSION
+  spec.authors = ['Rick Mark']
+  spec.email = ['rickmark@outlook.com']
 
-  spec.summary       = "Mach-O's Other Tool"
-  spec.description   = 'mootool is a swiss army knife for dealing wiith Apple Mach-O files'
-  spec.homepage      = 'https://github.com/hack-different/mootool'
-  spec.license       = 'MIT'
+  spec.summary = "Mach-O's Other Tool"
+  spec.description = 'mootool is a swiss army knife for dealing with Apple Mach-O files'
+  spec.homepage = 'https://github.com/hack-different/mootool'
+  spec.license = 'MIT'
+
+  spec.required_ruby_version = '>= 3.1'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
-    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
-
     spec.metadata['homepage_uri'] = spec.homepage
     spec.metadata['source_code_uri'] = 'https://github.com/hack-different/mootool'
     spec.metadata['changelog_uri'] = 'https://github.com/hack-different/mootool'
   else
     raise 'RubyGems 2.0 or newer is required to protect against ' \
-      'public gem pushes.'
+          'public gem pushes.'
   end
 
   # Specify which files should be added to the gem when it is released.
@@ -33,10 +33,13 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = 'exe'
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'sorbet-runtime'
+  spec.add_runtime_dependency 'plist', '~> 3'
   spec.add_runtime_dependency 'ruby-macho', '~> 3'
+  spec.add_runtime_dependency 'rubyzip', '~> 2'
+  spec.add_runtime_dependency 'sorbet-runtime', '~> 0'
+  spec.metadata['rubygems_mfa_required'] = 'true'
 end

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: strict
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end