manageiq-smartstate 0.1.0

data/lib/metadata/util/win32/remote-registry.rb

@@ -0,0 +1,142 @@
+require 'metadata/util/win32/ms-registry'
+require 'util/miq-xml'
+require 'util/xml/xml_hash'
+require 'metadata/util/win32/system_path_win'
+
+HKEY_LOCAL_MACHINE = "HKEY_LOCAL_MACHINE"     # 0x80000002
+HKEY_USERS = "default"                        # 0x80000003
+
+class RemoteRegistry
+  attr_reader :fileLoadTime, :fileParseTime, :digitalProductKeys
+
+  def initialize(fs, xml_class = MiqXml, reg_path = nil)
+    @fileHnd = nil
+    @HKLM_element = nil
+    @loadedHives = []
+
+    # Legacy check - xml_class use to be use_hash flag
+    xml_class = XmlHash::Document if xml_class == true
+    xml_class = MiqXml if xml_class == false
+
+    # Create XML document
+    @xml = xml_class.createDoc(:registry)
+    @HKLM_element = @xml.root.add_element("HKEY_LOCAL_MACHINE")
+
+    if fs.kind_of?(MiqFS)
+      @fs = fs
+      if reg_path.nil?
+        path = Win32::SystemPath.registryPath(@fs) + "/"
+        @RegPath = path.gsub(/^"/, "").gsub(/"$/, "")
+      else
+        @RegPath = reg_path
+      end
+    else
+      @RegPath = fs
+    end
+
+    @fileLoadTime = nil
+    @fileParseTime = nil
+
+    @digitalProductKeys = []
+  end
+
+  def close
+    @xml = nil
+  end
+
+  def processRegistryAll
+    # Load Major hives
+    loadSoftwareHive
+    loadSystemHive
+    loadDefaultHive
+    loadSecurityHive
+    loadSAMHive
+    @xml
+  end
+
+  def open(key, subkey)
+    paths = subkey.tr("\\", "/").split("/")
+    if key == HKEY_LOCAL_MACHINE
+      # $log.debug "Loading hive: #{paths[0].downcase}"
+      loadHive(paths[0].downcase, nil)
+      paths.insert(0, key)
+      # $log.debug "Search paths: #{paths} #{paths.length}"
+      return MIQRexml.findRegElementInt(paths, @xml.root)
+    end
+  end
+
+  def loadSoftwareHive(filter = nil)
+    loadHive("software", filter)
+  end
+
+  def loadSystemHive(filter = nil)
+    loadHive("system", filter)
+  end
+
+  def loadSecurityHive(filter = nil)
+    loadHive("security", filter)
+  end
+
+  def loadSAMHive(filter = nil)
+    loadHive("SAM", filter)
+  end
+
+  # Vista stores boot information in a registry hive in /boot/BCD
+  def loadBootHive(_filter = nil)
+    loadHive("BCD", nil, "/boot")
+  end
+
+  def loadHive(name, filters = nil, path = @RegPath)
+    xml = @xml
+    unless @loadedHives.include?(name.downcase)
+      if name.downcase == "default"
+        xmlNode = @xml.root.add_element("HKEY_USERS").add_element("_DEFAULT")
+      else
+        xmlNode = @HKLM_element.add_element(name.upcase)
+      end
+      xml = process_hive(path, name, xmlNode, filters)
+      @loadedHives.push(name.downcase)
+    end
+    xml
+  end
+
+  def loadCurrentUser(filters = nil)
+    xml = @xml
+    users = []
+    hkcu = loadHive("software", [{:key => "Microsoft/Windows NT/CurrentVersion/ProfileList", :value => ['ProfileImagePath']}])
+    hkcu.root.each_recursive do |v|
+      # Only process user accounts, not local system service accounts (like S-1-5-18)
+      if v.name == :value && v.parent.attributes[:keyname].length > 8
+        ntuser = File.join(v.text.tr('\\', '/'), 'ntuser.dat')
+        users << {:path => ntuser, :mtime => @fs.fileMtime(ntuser).to_i} if @fs.fileExists?(ntuser)
+      end
+    end
+
+    unless users.empty?
+      # Sort so most recently updated is first
+      users.sort! { |a, b| b[:mtime] <=> a[:mtime] }
+      xmlNode = @xml.root.add_element("HKEY_CURRENT_USER")
+      path, name = File.dirname(users.first[:path]), File.basename(users.first[:path])
+      xml = process_hive(path, name, xmlNode, filters)
+    end
+
+    xml
+  end
+
+  def process_hive(path, name, xmlNode, filters)
+    defaultHive = MSRegHive.new(path, name.downcase, xmlNode, @fs, filters)
+    defaultHive.parseHives
+    @fileLoadTime, @fileParseTime = defaultHive.fileLoadTime, defaultHive.fileParseTime
+    @digitalProductKeys = defaultHive.digitalProductKeys
+    $log.debug "Hive parsing complete in [#{@fileLoadTime + @fileParseTime}] seconds"
+    defaultHive.xmlNode
+  end
+
+  def toXML
+    @xml
+  end
+
+  # Return a list of loaded hives so the user can check if there hive
+  # is already available in the xml structure
+  attr_reader :loadedHives
+end

data/lib/metadata/util/win32/system_path_win.rb

@@ -0,0 +1,103 @@
+require 'util/extensions/miq-file'
+require 'enumerator'
+
+module Win32
+  class SystemPath
+    # BCD WMI Provider Enumerations (values)
+    # http://msdn.microsoft.com/en-us/library/cc441427(VS.85).aspx
+    SYSTEM_STORE_GUID = '{9dea862c-5cdd-4e70-acc1-f32b344d4795}'
+    BCD_BOOTMGR_OBJECT_DEFAULTOBJECT  = '23000003' # 0x23000003
+    BCD_OS_LOADER_DEVICE_OSDEVICE     = '21000001' # 0x21000001
+    BCD_OS_LOADER_STRING_SYSTEMROOT   = '22000002' # 0x22000002
+    BCD_LIBRARYSTRING_DESCRIPTION     = '12000004' # 0x12000004
+
+    def self.registryPath(fs = nil, root = nil)
+      File.join(system32Path(fs, root), "config")
+    end
+
+    def self.system32Path(fs = nil, root = nil)
+      return File.join(root, "system32") if root
+      File.join(systemRoot(fs), "system32")
+    end
+
+    def self.systemRoot(fs = nil, si = nil)
+      si = systemIdentifier(fs) if si.nil?
+      raise(MiqException::MiqVmMountError, "Filesystem does not contain system root identifiers.") if si.blank?
+      system32_dir = File.join(si[:system_root], 'system32')
+      raise(MiqException::MiqVmMountError, "Filesystem does not contain system root folder (#{system32_dir}).") unless fs.fileDirectory?(system32_dir)
+      si[:system_root]
+    end
+
+    def self.systemIdentifier(fs = nil, options = {})
+      # If we are not passed a fs handle return the %systemRoot% from the environment
+      if fs.nil?
+        raise(MiqException::MiqVmMountError, "System root not available through environment variables.") if ENV["SystemRoot"].nil?
+        return File.normalize(ENV["SystemRoot"])
+      end
+
+      # Use the boot.ini file to get the starting path to the Windows folder
+      fn = [{:file => "/boot.ini", :type => :boot_ini}, {:file => "/boot/BCD", :type => :bcd}, {:file => '/Windows/System32/config/SYSTEM', :type => :registry_file}]
+      drive_letter = fs.pwd.to_s[0, 2]
+      if drive_letter[1, 1] == ':'
+        fs.chdir("#{drive_letter}/")
+        fn.each { |f| f[:file] = "#{drive_letter}#{f[:file]}" }
+      end
+
+      # Determine where the initial boot information is stored (boot.ini or BCD registry
+      boot_cfg = fn.detect { |b| fs.fileExists?(b[:file]) }
+
+      # If we did not find either identifier above raise an error.
+      return {} if boot_cfg.nil?
+
+      # Set default system root path
+      boot_cfg[:system_root] = "/Windows"
+
+      $log.debug "Boot info stored in: [#{boot_cfg.inspect}]" if $log
+      case boot_cfg[:type]
+      when :boot_ini
+        begin
+          if fs.kind_of?(MiqFS)
+            boot_cfg_text = fs.fileOpen(boot_cfg[:file]).read
+            $log.warn "Contents of <#{boot_cfg[:file]}>\n#{boot_cfg_text}" if $log && options[:debug] == true
+            boot_cfg[:system_root] = $'.split("\n")[0].split("\\")[1].chomp if boot_cfg_text =~ /default=/
+          end
+          boot_cfg[:system_root].strip!
+          boot_cfg[:system_root] = "/#{boot_cfg[:system_root]}"
+        rescue RuntimeError => err
+          $log.warn "Win32::SystemPath.systemRoot [#{err}]" if $log
+        end
+      when :bcd
+        boot_cfg.merge!(parse_bcd(fs))
+        boot_cfg[:system_root].tr!('\\', '/') unless boot_cfg[:system_root].nil?
+      when :registry_files
+        # TODO: Needs to change to support BCD on different partition.  This is just a work-around
+      end
+
+      boot_cfg
+    end
+
+    def self.parse_bcd(fs)
+      result = {}
+      reg = RemoteRegistry.new(fs, XmlHash, '/boot')
+      xml = reg.loadBootHive
+
+      # Find the GUID of the default Boot element
+      default_guid_path = "HKEY_LOCAL_MACHINE\\BCD\\Objects\\#{SYSTEM_STORE_GUID}\\Elements\\#{BCD_BOOTMGR_OBJECT_DEFAULTOBJECT}\\Element"
+      default_os = MIQRexml.findRegElement(default_guid_path, xml.root)
+      default_os = MIQRexml.findRegElement("HKEY_LOCAL_MACHINE\\BCD\\Objects\\#{default_os.text}\\Elements", xml.root) if default_os
+
+      [BCD_OS_LOADER_DEVICE_OSDEVICE, :os_device, BCD_OS_LOADER_STRING_SYSTEMROOT, :system_root,
+       BCD_LIBRARYSTRING_DESCRIPTION, :os_description].each_slice(2) do |key_id, name|
+        device = MIQRexml.findRegElement("#{key_id}\\Element", default_os) if default_os
+        result[name] = device.text unless device.nil?
+      end
+
+      # Decode disk signature
+      unless result[:os_device].nil?
+        d = result[:os_device].split(',')
+        result[:disk_sig] = (d[59] + d[58] + d[57] + d[56]).to_i(16) if d.size >= 60
+      end
+      result
+    end
+  end
+end

data/lib/metadata/util/win32/versioninfo.rb

@@ -0,0 +1,17 @@
+require 'metadata/util/win32/peheader'
+
+class File
+  def self.getVersionInfo(fname)
+    PEheader.new(fname).versioninfo
+  end
+end
+
+###########################################################
+# Only run if we are calling this script directly
+if __FILE__ == $0
+  puts "Running script [#{__FILE__}]"
+  vi = File.getVersionInfo("c:/temp/strings.exe")
+  # vi = File.getVersionInfo("c:/windows/system32/mui/0419/xpob2res.dll")  #Russian version_info file
+  vi.each_pair { |k, v| puts "vi[#{k}] = [#{v}]" }
+  puts "Completed script [#{__FILE__}]"
+end

data/manageiq-smartstate.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'manageiq/smartstate/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "manageiq-smartstate"
+  spec.version       = ManageIQ::Smartstate::VERSION
+  spec.authors       = ["ManageIQ Developers"]
+
+  spec.summary       = "ManageIQ SmartState Analysis"
+  spec.description   = "ManageIQ SmartState Analysis"
+  spec.homepage      = "https://github.com/ManageIQ/manageiq-smartstate"
+  spec.license       = "Apache-2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "manageiq-gems-pending"
+  spec.add_dependency "vmware_web_service", "~>0.1.1"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "camcorder"
+  spec.add_development_dependency "vcr", "~>3.0.2"
+  spec.add_development_dependency "webmock", "~>2.3.1"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0.0"
+
+end