manageiq-smartstate 0.1.0

data/lib/metadata/MIQExtract/MIQExtract.rb

@@ -0,0 +1,297 @@
+require 'MiqVm/MiqVm'
+require 'metadata/util/md5deep'
+require 'util/miq-xml'
+require 'util/miq-logger'
+require 'ostruct'
+require 'metadata/util/win32/Win32Accounts'
+require 'metadata/util/win32/Win32Software'
+require 'metadata/util/win32/Win32Services'
+require 'metadata/util/win32/Win32System'
+require 'metadata/util/win32/Win32EventLog'
+require 'metadata/linux/LinuxUsers'
+require 'metadata/linux/LinuxPackages'
+require 'metadata/linux/LinuxInitProcs'
+require 'metadata/linux/LinuxSystemd'
+require 'metadata/linux/LinuxOSInfo'
+require 'metadata/ScanProfile/VmScanProfiles'
+require 'VMwareWebService/MiqVim'
+require 'OpenStackExtract/MiqOpenStackVm/MiqOpenStackImage'
+require 'OpenStackExtract/MiqOpenStackVm/MiqOpenStackInstance'
+require 'util/miq-password'
+require 'VMwareWebService/MiqVimBroker'
+
+class MIQExtract
+  attr_reader :systemFsMsg, :systemFs, :vm
+
+  def initialize(filename, ost = nil) # TODO: Always pass in MiqVm
+    ost ||= OpenStruct.new
+    @ost = ost
+    @dataDir = ost.config.try(:dataDir)
+    ost.scanData = {} if ost.scanData.nil?
+    @xml_class = ost.xml_class.nil? ? XmlHash::Document : ost.xml_class
+
+    # TODO: Should all be subclasses of MiqVm.
+    #       Going forward, we should only pass in an MiqVm - so the "else" will be removed.
+    if filename.respond_to?(:rootTrees)
+      @externalMount = true
+      @target = filename
+      @configFile = filename.respond_to?(:vmConfigFile) ? @target.vmConfigFile : nil
+
+      $log.info "MIQExtract using config file: [#{@configFile}]  settings: [#{MiqPassword.sanitize_string(ost.scanData.inspect)}]"
+    else
+      @externalMount = false
+      @configFile = filename.gsub(/^"/, "").gsub(/"$/, "")
+
+      $log.info "MIQExtract using config file: [#{@configFile}]  settings: [#{MiqPassword.sanitize_string(ost.scanData.inspect)}]"
+      ost.openParent = true if ost.scanData.fetch_path('snapshot', 'use_existing') == true
+      ost.force = false if ost.scanData.fetch_path('snapshot', 'forceFleeceDefault') == false
+      ost.snapshotDescription = ost.scanData.fetch_path('snapshot', 'description') if ost.scanData.fetch_path('snapshot', 'description')
+      ost.snapshot_create_free_space = ost.scanData.fetch_path('snapshot', 'create_free_percent') || 100
+      ost.snapshot_remove_free_space = ost.scanData.fetch_path('snapshot', 'remove_free_percent') || 100
+      @target = MiqVm.new(@configFile, ost)
+    end
+
+    # Set the system fs handle
+    begin
+      st = Time.now
+      $log.info "Loading disk files for VM [#{@configFile}]"
+      @systemFs = @target.rootTrees[0]
+      if @systemFs.nil?
+        raise MiqException::MiqVmMountError, "No root filesystem found." if @target.diskInitErrors.empty?
+
+        err_msg = ''
+        @target.diskInitErrors.each do |disk, err|
+          err = "#{err} - #{disk}" unless err.include?(disk)
+          err_msg += "#{err}\n"
+        end
+        raise err_msg.chomp
+      end
+
+      @systemFsMsg = "OS:[#{@systemFs.guestOS}] found on VM [#{@configFile}].  Loaded in [#{Time.now - st}] seconds"
+      $log.info @systemFsMsg
+    rescue => err
+      @systemFsMsg = "Unable to mount filesystem.  Reason:[#{err}]"
+      $log.error "#{@systemFsMsg} for VM [#{@configFile}]"
+      log_level = err.kind_of?(MiqException::Error) ? :debug : :error
+      err.backtrace.each { |bt| $log.send(log_level, "MIQExtract.new #{bt}") }
+      close
+    end
+
+    # Load Scan Profiles
+    @scanProfiles = VmScanProfiles.new(ost.scanData['vmScanProfiles'], VmScanProfiles::SCAN_ITEM_CATEGORIES => ost.category, :xml_class => @xml_class)
+  end
+
+  def categories
+    @scanProfiles.get_categories
+  end
+
+  def split_registry(path)
+    y = path.tr("\\", "/").split("/")
+    return y[0].downcase, y[1..-1].join("/")
+  end
+
+  def getProfileData(&blk)
+    # First check for registry keys
+    if @systemFs.guestOS == "Windows"
+      reg_filters = @scanProfiles.get_registry_filters
+
+      if reg_filters
+        st = Time.now
+        $log.info "Scanning [Profile-Registry] information."
+        yield({:msg => 'Scanning Profile-Registry'}) if block_given?
+
+        filters = []
+        reg_filters[:HKCU].to_miq_a.each { |f| filters << {:key => split_registry(f['key']).join('/'), :depth => f['depth']} }
+        @scanProfiles.parse_data(@target, RemoteRegistry.new(@systemFs, @xml_class).loadCurrentUser(filters)) unless filters.empty?
+
+        filters = {}
+        reg_filters[:HKLM].each do |f|
+          hive, path = split_registry(f["key"])
+          filters[hive.downcase] = [] if filters[hive.downcase].nil?
+          filters[hive.downcase] << path
+        end unless reg_filters[:HKLM].nil?
+
+        filters.each_pair do |k, v|
+          regHnd = RemoteRegistry.new(@systemFs, @xml_class)
+          xml = regHnd.loadHive(k, v)
+          @scanProfiles.parse_data(@target, xml)
+        end unless filters.empty?
+        $log.info "Scanning [Profile-Registry] information ran for [#{Time.now - st}] seconds."
+      end
+    end
+
+    # Pass in the MiqVm handle to do file parsing
+    @scanProfiles.parse_data(@target, nil, &blk)
+
+    @scanProfiles.to_xml
+  end
+
+  def extract(category, &blk)
+    xml = nil
+    category.to_miq_a.each do |c|
+      c = c.downcase
+      xml = case c
+            when "accounts" then getAccounts(c)
+            when "services" then getServices(c)
+            when "software" then getSoftware(c)
+            when "system"   then getSystem(c)
+            when "ntevents" then getEventLogs(c)
+            when "vmconfig" then getVMConfig(c)
+            # vmEvents are added to the blackbox externally, not extracted from the vm disks.
+            when "vmevents" then return nil
+            when "profiles" then getProfileData(&blk)
+            else
+              $log.warn "Warning: Category not processed [#{c}]"
+              nil
+            end
+
+      # Write XML to data directory for debugging
+      # File.open(File.join(@dataDir, "scan_#{c}.xml"),"w") {|f| xml.write(f,0)} if xml rescue nil
+    end
+  rescue => err
+    $log.error "MIQExtract.extract #{err}"
+    log_level = err.kind_of?(MiqException::Error) ? :debug : :error
+    err.backtrace.each { |bt| $log.send(log_level, "MIQExtract.extract #{bt}") }
+    raise err
+  ensure
+    return xml
+  end
+
+  def getVMConfig(_c)
+    # Get VM config in XML format
+    config_xml = @target.vmConfig.toXML(true, @target)
+
+    begin
+      # Log snapshot data for diagnostic purposes
+      config_xml.find_each("//vm/snapshots") do |s|
+        formattedXml = ""
+        s.write(formattedXml, 0)
+
+        # Dump the formated snapshot xml section
+        formattedXml.split("\n").each { |l| $log.debug l }
+
+        # Log the high level snapshot details
+        $log.info "Snapshot overview: Count:[#{s.attributes['numsnapshots']}]  Current:[#{s.attributes['current']}]"
+
+        # Log each child snapshot element
+        s.find_each("child::snapshot") { |ss| $log.info "Snapshot details:  id:[#{ss.attributes['uid']}]  Name:[#{ss.attributes['displayname']}]" }
+      end
+    rescue # => e
+      # $log.error e
+    end
+
+    if config_xml.class != @xml_class
+      config_xml = @xml_class.load(config_xml.to_s)
+    end
+
+    config_xml
+  end
+
+  def xml_doc_node(category)
+    doc = @xml_class.createDoc(:miq)
+    node = doc.root.add_element(category)
+    return doc, node
+  end
+
+  def getAccounts(c)
+    return if @systemFs.nil?
+
+    doc, node = xml_doc_node(:accounts)
+    #   doc.root.attributes["xsi:schemaLocation"] += " accounts.xsd"
+
+    case @systemFs.guestOS
+    when "Windows"
+      MiqWin32::Accounts.new(c, @systemFs).to_xml(node)
+    when "Linux"
+      MiqLinux::Users.new(@systemFs).to_xml(node)
+    end
+
+    doc
+  end
+
+  def getServices(c)
+    return if @systemFs.nil?
+
+    doc, node = xml_doc_node(:services)
+    #   doc.root.attributes["xsi:schemaLocation"] += " services.xsd"
+
+    case @systemFs.guestOS
+    when "Windows"
+      MiqWin32::Services.new(c, @systemFs).to_xml(node)
+    when "Linux"
+      MiqLinux::Systemd.new(@systemFs).toXml(node) if MiqLinux::Systemd.detected?(@systemFs)
+      MiqLinux::InitProcs.new(@systemFs).toXml(node)
+    end
+
+    doc
+  end
+
+  def getSystem(c)
+    return if @systemFs.nil?
+
+    doc, node = xml_doc_node(:system)
+    #   doc.root.attributes["xsi:schemaLocation"] += " system.xsd"
+
+    case @systemFs.guestOS
+    when "Windows"
+      MiqWin32::System.new(c, @systemFs).to_xml(node)
+    when "Linux"
+      MiqLinux::OSInfo.new(@systemFs).toXml(node)
+    end
+
+    doc
+  end
+
+  def getSoftware(c)
+    return if @systemFs.nil?
+
+    doc, node = xml_doc_node(:software)
+    #   doc.root.attributes["xsi:schemaLocation"] += " software.xsd"
+
+    case @systemFs.guestOS
+    when "Windows"
+      MiqWin32::Software.new(c, @systemFs).to_xml(node)
+    when "Linux"
+      MiqLinux::Packages.new(@systemFs).toXml(node)
+    end
+
+    doc
+  end
+
+  def getEventLogs(_c)
+    ntevent = Win32EventLog.new(@systemFs)
+    ntevent.readAllLogs(Win32EventLog::SYSTEM_LOGS)
+  end
+
+  def scanMD5deep
+    # Produce file system XML with MD5 info
+    $log.debug "Starting Filesystem scan"
+    # scanPath = "c:/program files"
+    scanPath = "c:/program files/Java/jdk1.5.0_12/jre/lib"
+    md5 = MD5deep.new(@systemFs, 'versioninfo' => true, 'imports' => true)
+    md5.scan(scanPath, scanPath)
+  end
+
+  def getBaseConfigName
+    File.join(File.dirname(@configFile), File.basename(@configFile, ".*"))
+  end
+
+  def close
+    return if @externalMount
+    # Call Unmount command if drive was succesfully mounted
+    unless @target.nil?
+      $log.debug "Unmounting..."
+      begin
+        @target.unmount
+        $log.debug "Unmounting complete"
+      rescue => err
+        $log.error "Error during disk unmounting for VM:[#{@configFile}]"
+        $log.debug err.backtrace.join("\n")
+      ensure
+        @ost.miqVim.disconnect if @ost.miqVim
+        unmount_storage(@mount) unless @mount.blank?
+        set_process_permissions(:reset)
+      end
+    end
+  end  # close
+end  # MIQExtract class

data/lib/metadata/MIQExtract/test/extractTest.rb

@@ -0,0 +1,41 @@
+require 'metadata/MIQExtract/MIQExtract'
+require 'log4r'
+require 'MiqVm/MiqVm'
+
+# vmDir = "v:"
+vmDir = File.join(ENV.fetch("HOME", '.'), 'VMs')
+puts "vmDir = #{vmDir}"
+
+class ConsoleFormatter < Log4r::Formatter
+  def format(event)
+    (event.data.kind_of?(String) ? event.data : event.data.inspect) + "\n"
+  end
+end
+
+toplog = Log4r::Logger.new 'toplog'
+Log4r::StderrOutputter.new('err_console', :level => Log4r::ERROR, :formatter => ConsoleFormatter)
+toplog.add 'err_console'
+$log = toplog if $log.nil?
+
+#
+# *** Test start
+#
+
+# vmCfgFile = File.join(vmDir, "UbuntuDev.vmwarevm/UbuntuDev.vmx")
+# vmCfgFile = File.join(vmDir, "gentoo/gentoo.vmx")
+# vmCfgFile = File.join(vmDir, "Ken_Linux/Ken_Linux.vmx")
+# vmCfgFile = File.join(vmDir, "Metasploit VM/Metasploit VM.vmx")
+# vmCfgFile = File.join(vmDir, "KnopDev.vmwarevm/KnopDev.vmx")
+vmCfgFile = File.join(vmDir, "Red Hat Linux.vmwarevm/Red Hat Linux.vmx")
+# vmCfgFile = File.join(vmDir, "MIQ Server Appliance - Ubuntu MD - small/MIQ Server Appliance - Ubuntu.vmx")
+# vmCfgFile = File.join(vmDir, "winxpDev.vmwarevm/winxpDev.vmx")
+puts "VM config file: #{vmCfgFile}"
+
+ost = OpenStruct.new
+vmCfg = MIQExtract.new(vmCfgFile, ost)
+xml = vmCfg.extract(["software"])
+
+xml.write($stdout, 4)
+puts
+
+vmCfg.close

data/lib/metadata/MIQExtract/test/full_extract_test.rb

@@ -0,0 +1,68 @@
+require 'util/miq-logger'
+require 'tempfile'
+include Log4r
+
+$log = MIQLogger.get_log(nil, __FILE__)
+$log.level = INFO
+
+require 'metadata/MIQExtract/MIQExtract'
+require 'util/miq-process'
+
+PROFILE_INIT = false
+PROFILE_EXTRACT = false
+
+begin
+  vmCfgFile = nil
+
+  startTime = Time.now
+  vms_path  = File.join((Sys::Platform::IMPL == :macosx ? "/Volumes" : "/mnt"), "manageiq", "fleecing_test", "images", "virtual_machines")
+  vmCfgFile = File.join(vms_path, "vmware", "JanusVM", "JanusVM-17-sep-2007", "JanusVM", "JanusVM.vmx")
+
+  # Load VM config file
+  ost = OpenStruct.new
+  vmCfg = if PROFILE_INIT
+            profile_block(:file_prefix => "init_") { MIQExtract.new(vmCfgFile, ost) }
+          else
+            MIQExtract.new(vmCfgFile, ost)
+          end
+
+  $log.info "******************** Memory    : [#{MiqProcess.processInfo.inspect}] ********************"
+  %w(vmconfig vmevents accounts software services system).each do |c|
+    $log.warn "Start fleece for [#{c}]"
+    stf = Time.now
+
+    xml = if PROFILE_EXTRACT
+            profile_block(:file_prefix => "#{c}_") { vmCfg.extract([c]) }
+          else
+            vmCfg.extract([c])
+          end
+
+    $log.warn "Fleece for [#{c}] completed [#{Time.now - stf}]"
+
+    $log.summary "[#{c}] extract return xml of type [#{xml.class}]" if xml
+    File.open(Tempfile.new("extract_#{c}.xml"), "w") { |f| xml.write(f, 2) } if xml
+  end
+  $log.info "******************** Memory    : [#{MiqProcess.processInfo.inspect}] ********************"
+
+  # Unmounts the VM
+  vmCfg.close
+
+  $log.info "START TIME: [#{startTime}]"
+  $log.info "STOP TIME : [#{Time.now}]"
+  $log.info "Run  time : [#{(Time.now - startTime)}] seconds"
+
+# Use this time to check for memory usage through OS utilities
+#  $log.info "Sleeping for 5 seconds"
+#  sleep(5)
+
+rescue NameError => err
+  unless err.to_s.include?("MiqVm")
+    $log.warn err
+    $log.fatal err.backtrace.join("\n")
+  end
+rescue => err
+  $log.fatal err.to_s
+  err.backtrace.each { |e| $log.fatal e }
+end
+
+$log.info "MIQExtract ending."

data/lib/metadata/ScanProfile/HostScanItem.rb

@@ -0,0 +1,4 @@
+require 'metadata/ScanProfile/ScanItemBase'
+
+class HostScanItem < ScanItemBase
+end

data/lib/metadata/ScanProfile/HostScanProfile.rb

@@ -0,0 +1,4 @@
+require 'metadata/ScanProfile/ScanProfileBase'
+
+class HostScanProfile < ScanProfileBase
+end

data/lib/metadata/ScanProfile/HostScanProfiles.rb

@@ -0,0 +1,41 @@
+require 'metadata/ScanProfile/ScanProfilesBase'
+require 'metadata/ScanProfile/HostScanProfile'
+require 'metadata/ScanProfile/HostScanItem'
+
+class HostScanProfiles < ScanProfilesBase
+  SCAN_TYPE_HOSTD = 'nteventlog'
+  SCAN_TYPE_FILE = 'file'
+
+  def get_hostd_scan_item
+    scan_item = nil
+    each_scan_item(SCAN_TYPE_HOSTD) do |si|
+      next unless si.scan_definition['content'][0][:name] == 'hostd'
+      scan_item = si
+      break
+    end
+    scan_item
+  end
+
+  def get_file_scan_item
+    scan_item = nil
+    each_scan_item(SCAN_TYPE_FILE) do |si|
+      scan_item = si
+      break
+    end
+    scan_item
+  end
+
+  def parse_data_hostd(vim)
+    si = get_hostd_scan_item
+    return if si.nil?
+    si.parse_data(vim, nil)
+    si.scan_definition[:data]
+  end
+
+  def parse_data_files(ssu)
+    si = get_file_scan_item
+    return if si.nil?
+    si.parse_data(ssu, nil)
+    si.scan_definition[:data]
+  end
+end

data/lib/metadata/ScanProfile/ScanItemBase.rb

@@ -0,0 +1,63 @@
+class ScanItemBase
+  SCAN_TYPE_PROP = "item_type"
+
+  attr_accessor :scan_definition, :scan_item_type
+
+  def self.scan_profile_class;  ScanProfilesBase.get_class('profile',  self); end
+
+  def self.scan_profiles_class; ScanProfilesBase.get_class('profiles', self); end
+
+  def self.scan_item_class;     self; end
+
+  def initialize(dataHash, options = {})
+    @params = dataHash
+    @options = options
+    @xml_class = @options[:xml_class] || XmlHash::Document
+
+    @scan_item_type = @params[SCAN_TYPE_PROP]
+    extend_scan_module(@scan_item_type)
+
+    @scan_definition = @params[ScanProfileBase::DEFINITION]
+  end
+
+  def extend_scan_module(type)
+    raise "Already set scan module" if @extend_scan_module
+    begin
+      m = "#{self.class.name}#{type.capitalize}"
+      require_relative "modules/#{m}"
+      extend Object.const_get(m)
+    rescue LoadError
+    end
+    @extend_scan_module = true
+  end
+
+  def with_scan_definition(type = nil)
+    yield scan_definition if type.nil? || type == scan_item_type
+  end
+
+  # THESE METHODS SHOULD BE OVER-RIDDEN BY THE REQUIRES IN THE INITIALIZER
+  def to_xml
+    xml = @xml_class.newNode("scan_item")
+    xml.add_attributes(
+      "guid"      => @params["guid"],
+      "name"      => @params["name"],
+      "item_type" => @params["item_type"])
+    xml
+  end
+
+  def to_hash
+    {
+      :guid      => @params["guid"],
+      :name      => @params["name"],
+      :item_type => @params["item_type"]
+    }
+  end
+
+  def to_yaml
+    YAML.dump(to_hash)
+  end
+
+  def parse_data(_obj, _data, &_blk)
+    nil
+  end
+end

data/lib/metadata/ScanProfile/ScanProfileBase.rb

@@ -0,0 +1,51 @@
+class ScanProfileBase
+  def self.scan_item_class;     ScanProfilesBase.get_class('item',     self); end
+
+  def self.scan_profiles_class; ScanProfilesBase.get_class('profiles', self); end
+
+  def self.scan_profile_class;  self; end
+
+  include Enumerable
+
+  DEFINITION = "definition"
+
+  attr_accessor :scan_items
+
+  def initialize(dataHash, options = {})
+    @params = dataHash
+    @options = options
+    @xml_class = @options[:xml_class] || XmlHash::Document
+    @scan_items = @params[DEFINITION].collect { |s| self.class.scan_item_class.new(s, options) }
+  end
+
+  def each
+    scan_items.each { |si| yield si }
+  end
+
+  def each_scan_definition(type = nil, &blk)
+    scan_items.each { |si| si.with_scan_definition(type, &blk) if type.nil? || type == si.scan_item_type }
+  end
+
+  def each_scan_item(type = nil)
+    scan_items.each { |si| yield si if type.nil? || type == si.scan_item_type }
+  end
+
+  def to_xml
+    xml = @xml_class.newNode("scan_profile")
+    xml.add_attributes("guid" => @params["guid"], "name" => @params["name"])
+    each { |si| xml << si.to_xml }
+    xml
+  end
+
+  def to_hash
+    {
+      :guid       => @params["guid"],
+      :name       => @params["name"],
+      :scan_items => collect(&:to_hash)
+    }
+  end
+
+  def to_yaml
+    YAML.dump(to_hash)
+  end
+end

data/lib/metadata/ScanProfile/ScanProfilesBase.rb

@@ -0,0 +1,60 @@
+require 'util/miq-xml'
+require 'util/miq-logger'
+
+class ScanProfilesBase
+  def self.get_class(type, from)
+    k = from.instance_variable_get("@scan_#{type}_class")
+    return k unless k.nil?
+
+    k = "#{from.name.underscore.split('_')[0..-2].join('_').camelize}#{type.camelize}"
+    require "metadata/ScanProfile/#{k}"
+    from.instance_variable_set("@scan_#{type}_class", Object.const_get(k))
+  end
+
+  def self.scan_item_class;     get_class('item',    self); end
+
+  def self.scan_profile_class;  get_class('profile', self); end
+
+  def self.scan_profiles_class; self; end
+
+  include Enumerable
+
+  attr_accessor :profiles
+
+  def initialize(dataHash, options = {})
+    @params = dataHash
+    @options = options
+    @xml_class = @options[:xml_class] || XmlHash::Document
+    @profiles = @params.nil? ? [] : @params.collect { |p| self.class.scan_profile_class.new(p, @options) }
+  end
+
+  def each
+    profiles.each { |p| yield p }
+  end
+
+  def each_scan_definition(type = nil, &blk)
+    profiles.each { |p| p.each_scan_definition(type, &blk) }
+  end
+
+  def each_scan_item(type = nil, &blk)
+    profiles.each { |p| p.each_scan_item(type, &blk) }
+  end
+
+  def parse_data(obj, data, &blk)
+    each_scan_item { |si| si.parse_data(obj, data, &blk) }
+  end
+
+  def to_xml
+    xml = @xml_class.createDoc("<scan_profiles/>")
+    each { |p| xml.root << p.to_xml }
+    xml
+  end
+
+  def to_hash
+    {:scan_profiles => collect(&:to_hash)}
+  end
+
+  def to_yaml
+    YAML.dump(to_hash)
+  end
+end

data/lib/metadata/ScanProfile/VmScanItem.rb

@@ -0,0 +1,4 @@
+require 'metadata/ScanProfile/ScanItemBase'
+
+class VmScanItem < ScanItemBase
+end

data/lib/metadata/ScanProfile/VmScanProfile.rb

@@ -0,0 +1,4 @@
+require 'metadata/ScanProfile/ScanProfileBase'
+
+class VmScanProfile < ScanProfileBase
+end

data/lib/metadata/ScanProfile/VmScanProfiles.rb

@@ -0,0 +1,38 @@
+require 'metadata/ScanProfile/ScanProfilesBase'
+require 'metadata/ScanProfile/VmScanProfile'
+require 'metadata/ScanProfile/VmScanItem'
+
+class VmScanProfiles < ScanProfilesBase
+  SCAN_TYPE_CATEGORY = "category"
+  SCAN_TYPE_REGISTRY = "registry"
+
+  SCAN_ITEM_CATEGORIES = "categories"
+
+  def get_categories
+    categories = []
+    # Get data from each "category" scan item
+    each_scan_definition(SCAN_TYPE_CATEGORY) do |sd|
+      # Add the target items from the content array
+      sd["content"].each { |si| categories << si["target"] } unless sd["content"].nil?
+    end
+    if categories.empty?
+      categories = @options[SCAN_ITEM_CATEGORIES].split(",") if @options[SCAN_ITEM_CATEGORIES]
+    end
+    categories.each do |c|
+      c.delete!("\"")
+      c.strip!
+    end
+    categories << "profiles"
+    categories.uniq
+  end
+
+  def get_registry_filters
+    reg_filters = Hash.new { |h, k| h[k] = [] }
+    each_scan_definition(SCAN_TYPE_REGISTRY) do |sd|
+      # Add the target items from the content array and
+      # split the registry request into hive/key
+      sd["content"].each { |si| reg_filters[si["hive"].to_sym] << si }
+    end
+    reg_filters
+  end
+end