boris 1.0.0.beta.1

data/lib/boris/errors.rb

@@ -0,0 +1,17 @@
+module Boris
+  class MissingCredentials < Exception; end
+
+  class ConnectionFailed < StandardError; end
+
+  class ConnectionAlreadyActive < StandardError; end
+
+  class NoActiveConnection < StandardError; end
+
+  class NoProfileDetected < StandardError; end
+
+  class InvalidOption < StandardError; end
+
+  class InvalidCredentials < ConnectionFailed; end
+
+  class InvalidTargetName < StandardError; end
+end

data/lib/boris/helpers/array.rb

@@ -0,0 +1,63 @@
+class Array
+  def strip_string_values_in_array
+    self.map! do |val|
+      val.strip_string_values_in_array if val.is_a?(Array)
+      val.strip_string_values_in_hash if val.is_a?(Hash)
+      val.is_a?(String) ? val.strip : val
+    end
+  end
+  
+  def to_ms_product_key
+    valid_chars = 'BCDFGHJKMPQRTVWXY2346789'.scan(/./)
+
+    product_key = nil
+    
+    raw_product_key = []
+
+    52.upto(66) do |idx|
+      raw_product_key << self[idx]
+    end
+
+    24.downto(0) do |a|
+      b = 0
+
+      14.downto(0) do |c|
+        b = b * 256 ^ raw_product_key[c]
+        raw_product_key[c] = (b / 24).to_i
+        b = b.remainder(24)
+      end
+
+      product_key = "#{valid_chars[b]}#{product_key}"
+
+      if a.remainder(5) == 0 && a != 0
+        product_key = "-#{product_key}"
+      end
+    end
+
+    return product_key.upcase
+  end
+
+  def to_nil_hash
+    h = Hash.new
+    self.each do |item|
+      if item.kind_of?(Hash)
+        h.merge!(item)
+      else
+        h[item.to_sym] = nil
+      end
+    end
+    return h
+  end
+
+  def to_wwn
+    wwn = []
+
+    0.upto(7) do |i|
+      hex = self[i].to_s(16)
+      hex = "0#{hex}" if self[i] < 16
+      wwn << hex
+    end
+    
+    return wwn.join
+  end
+end

data/lib/boris/helpers/constants.rb

@@ -0,0 +1,20 @@
+module Boris
+  VENDOR_ADOBE      = 'Adobe Systems, Inc.'
+  VENDOR_AMD        = 'AMD, Inc.'
+  VENDOR_APC        = 'APC Corp.'
+  VENDOR_BROCADE    = 'Brocade Communications Corp.'
+  VENDOR_CISCO      = 'Cisco Systems, Inc.'
+  VENDOR_CITRIX     = 'Citrix Systems, Inc.'
+  VENDOR_DELL       = 'Dell Inc.'
+  VENDOR_EMULEX     = 'Emulex Corp.'
+  VENDOR_F5         = 'F5 Networks, Inc.'
+  VENDOR_HP         = 'Hewlett Packard, Inc.'
+  VENDOR_IBM        = 'IBM Corp.'
+  VENDOR_INTEL      = 'Intel Corp.'
+  VENDOR_MICROSOFT  = 'Microsoft Corp.'
+  VENDOR_ORACLE     = 'Oracle Corp.'
+  VENDOR_QLOGIC     = 'QLogic Corp.'
+  VENDOR_REDHAT     = 'Red Hat Inc.'
+  VENDOR_SUSE       = 'SUSE Linux GmbH'
+  VENDOR_VMWARE     = 'VMware, Inc.'
+end

data/lib/boris/helpers/hash.rb

@@ -0,0 +1,8 @@
+class Hash
+  def strip_string_values_in_hash
+    self.each_pair do |key, val|
+      val.strip_string_values_in_array if val.is_a?(Array)
+      self[key] = val.strip if val.is_a?(String)
+    end
+  end
+end

data/lib/boris/helpers/scrubber.rb

@@ -0,0 +1,51 @@
+module Boris; module Profiles
+  module Structure
+    def scrub_data!
+      [ @file_systems,
+        @hosted_shares,
+        @installed_applications,
+        @installed_patches,
+        @installed_services,
+        @local_user_groups,
+        @network_interfaces
+      ].each {|arr| arr.strip_string_values_in_array}
+      debug 'string values from within data arrays cleaned up'
+
+      [@hardware, @network_id, @operating_system].each {|h| h.strip_string_values_in_hash}
+      debug 'string values from within data hashes cleaned up'
+
+      @installed_applications.each do |app|
+        app[:license_key].upcase! unless !app[:license_key]
+        app[:name].string_clean
+        app[:vendor].format_vendor unless !app[:vendor]
+      end
+      debug 'installed application data cleaned up'
+
+      @network_id[:hostname].upcase!
+      @network_id[:domain].downcase! unless !@network_id[:domain]
+      debug 'network id data cleaned up'
+
+      @network_interfaces.each do |interface|
+        interface[:fabric_name].downcase! unless !interface[:fabric_name]
+        interface[:mac_address].upcase! unless !interface[:mac_address]
+        interface[:model] = interface[:model].format_model unless !interface[:model]
+        interface[:node_wwn].downcase! unless !interface[:node_wwn]
+        interface[:port_wwn].downcase! unless !interface[:port_wwn]
+        interface[:remote_mac_address].upcase! unless !interface[:remote_mac_address]
+        interface[:vendor] = interface[:vendor].format_vendor unless !interface[:vendor]
+      end
+      debug 'network interface data cleaned up'
+
+      @hardware[:cpu_vendor] = @hardware[:cpu_vendor].string_clean.format_vendor unless !@hardware[:cpu_vendor]
+      @hardware[:model] = @hardware[:model].format_model unless !@hardware[:model]
+      @hardware[:serial].upcase! unless !@hardware[:serial]
+      @hardware[:vendor] = @hardware[:vendor].string_clean.format_vendor unless !@hardware[:vendor]
+      debug 'network interface data cleaned up'
+
+      @operating_system[:license_key].upcase! unless !@operating_system[:license_key]
+      debug 'operating system data cleaned up'
+
+      debug 'data scrubbing complete'
+    end
+  end
+end; end

data/lib/boris/helpers/string.rb

@@ -0,0 +1,130 @@
+class String
+  include Boris
+
+  def after_colon
+    generic_after(':')
+  end
+
+  def after_period
+    generic_after('\.')
+  end
+
+  def after_pipe
+    generic_after('|')
+  end
+
+  def after_slash
+    generic_after('\\\\|\/')
+  end
+
+  def before_colon
+    generic_before(':')
+  end
+
+  def before_period
+    generic_before('\.')
+  end
+
+  def before_pipe
+    generic_before('|')
+  end
+
+  def before_slash
+    generic_before('\\\\|\/')
+  end  
+
+  def between_parenthesis
+    x = self.scan(/\((.*)\)/)
+    return x.empty? ? nil : x.join
+  end
+
+  def format_model
+    return nil if self == ''
+
+    # delete models containing "server" or beginning with "ibm"
+    # also remove configuration numbers appended (typically on IBM
+    # products... ex 'System x1000 M3 -[123456]-')
+    model = self.gsub(/(^ibm|server)/i, '').split(/-*(\[|\()/)[0]
+
+    model = if model =~ /^sun.*blade/i
+      'SunBlade ' + model.scan(/\d/).join
+    elsif model =~ /^sun.*fire/i
+      'SunFire ' + model.scan(/\d/).join
+    elsif model =~ /^T\d{4}/
+      'SPARC Enterprise ' + model
+    elsif model =~ /^big-*ip/i
+      model.sub(/^big-*ip/i, 'BIG-IP')
+    elsif model =~ /^wsc\d{4}-*.*/i
+      'Catalyst ' + (model.scan(/\d/).join + '-' + model.scan(/[a-z]$/i).join).sub(/-$/, '')
+    else
+      model
+    end
+
+    model.strip
+  end
+
+  def format_serial
+    return nil if self =~ /(^$|\(*none\)*)/i
+
+    self.upcase
+  end
+
+  def string_clean
+    # remove registered "(R)" mark
+    string = self.gsub(/\(r\)/i, '')
+
+    string.encode(Encoding.find('ASCII'), :undef=>:replace, :replace=>'').strip
+  end
+
+  def format_vendor
+    return nil if self == ''
+    
+    vendor = self
+
+    vendor = if vendor =~ /^(amd|authenticamd)/i;       VENDOR_AMD
+    elsif vendor =~ /^brocade/i;                        VENDOR_BROCADE
+    elsif vendor =~ /^citrix/i;                         VENDOR_CITRIX
+    elsif vendor =~ /^dell/i;                           VENDOR_DELL
+    elsif vendor =~ /^emulex/i;                         VENDOR_EMULEX
+    elsif vendor =~ /^(compaq|hp|hewlett packard)/i;    VENDOR_HP
+    elsif vendor =~ /^ibm/i;                            VENDOR_IBM
+    elsif vendor =~ /^(genuineintel|intel )/i;          VENDOR_INTEL
+    elsif vendor =~ /^(microsoft)/i;                    VENDOR_MICROSOFT
+    elsif vendor =~ /^(oracle|sun[w]*|sun microsys)/i;  VENDOR_ORACLE
+    elsif vendor =~ /^qlogic/i;                         VENDOR_QLOGIC
+    elsif vendor =~ /^red\s*hat/i;                      VENDOR_REDHAT
+    elsif vendor =~ /^suse linux/i;                     VENDOR_SUSE
+    elsif vendor =~ /^vmware/i;                         VENDOR_VMWARE
+    else vendor
+    end
+
+    vendor.strip
+  end
+
+  def generic_after(delimiter)
+    x = self.scan(/^.*[#{delimiter}](.*)$/)
+    return x.empty? ? nil : x.join.strip
+  end
+
+  def generic_before(delimiter)
+    x = self.scan(/^(.*?)[#{delimiter}]/)
+    return x.empty? ? nil : x.join.strip
+  end
+
+  def hex_to_address
+    self.scan(/../).map {|octet| octet.hex}.join('.')
+  end
+  
+  def remove_arch
+    String.new(self).remove_arch!
+  end
+
+  def remove_arch!
+    self.replace(self.gsub(/\s+\(*(32|64)(-|\s)*bit\)*/, ''))
+  end
+
+  def within_quotes
+    x = self.scan(/["|'](.*?)["|']/).flatten
+    return x.empty? ? nil : x
+  end
+end

data/lib/boris/lumberjack.rb

@@ -0,0 +1,47 @@
+class BorisLogger < Logger
+  def initialize(output)
+    super(output)
+
+    self.datetime_format = '%m-%d-%Y %H:%M:%S'
+
+    self.formatter = proc do |severity, time, progname, msg|
+      sprintf("%-6s %-20s %-20s %-s\n", severity, time, progname, msg)
+    end
+  end
+end
+
+module Boris
+  module Lumberjack
+    attr_accessor :logger
+
+    def debug(msg)
+      logger.add(Logger::DEBUG, append_target_name(msg), facility) if logger && logger.debug?
+    end
+
+    def info(msg)
+      logger.add(Logger::INFO, append_target_name(msg), facility) if logger && logger.info?
+    end
+
+    def warn(msg)
+      logger.add(Logger::WARN, append_target_name(msg), facility) if logger && logger.warn?
+    end
+
+    def error(msg)
+      logger.add(Logger::ERROR, append_target_name(msg), facility) if logger && logger.error?
+    end
+
+    def fatal(msg)
+      logger.add(Logger::FATAL, append_target_name(msg), facility) if logger && logger.fatal?
+    end
+
+    private
+
+    def append_target_name(msg)
+      @host ? "#{@host}: #{msg}" : msg
+    end
+
+    def facility
+      @facility ||= self.class.name.gsub(/::/, '.').gsub(/([a-z])([A-Z])/, "\\1_\\2").downcase
+    end
+  end
+end

data/lib/boris/options.rb

@@ -0,0 +1,86 @@
+module Boris
+  class Options
+    attr_accessor :options
+
+    # Creates our options hash where the user can pass in an optional hash to immediately
+    # override the default values.
+    #
+    #  credentials = [{:user=>'joe', :password=>'mypassword', :connection_types=>[:ssh, :wmi]}]
+    #  ssh_keys = ['/home/joe/private_key']
+    #  options = Boris::Options.new(:log_level=>:debug, :ssh_options=>{:keys=>ssh_keys}, :credentials=>credentials)
+    #
+    # @option options [Boolean] :auto_scrub_data should the target's data be scrubbed
+    #  after running #retrieve_all?
+    # @option options [Array] :credentials an array of credentials in the format of
+    #  +:user+, +:password+, +:connection_types+.  Only +:user+ is mandatory.
+    # @option options [Symbol] :log_level The level of logging.  Options are:
+    #  +:debug+, +:info+, +:warn+, +:error+, +:fatal (default)+
+    # @option options [Array] profiles An array of module names of the profiles we wish
+    #  to have available for use on this target.  {Boris::Profiles::RedHat} and
+    #  {Profiles::Solaris} are always the defaults, and Windows profiles are included
+    #  as defaults as well if {Boris} is running on a Windows host (where WMI connections
+    #  are available)
+    # @option options [Hash] snmp_options A hash of options supported by ruby-snmp.
+    # @option options [Hash] ssh_options A hash of options supported by net-ssh.
+    #
+    # @raise ArgumentError when invalid arguments are passed
+    def initialize(options={})
+      @options = {}
+
+      # set our defaults
+      @options[:auto_scrub_data] ||= true
+      @options[:credentials] ||= []
+      @options[:log_level] ||= :fatal
+      @options[:profiles] ||= [Profiles::RedHat, Profiles::Solaris]
+      @options[:profiles].concat([Profiles::Windows::Windows2003, Profiles::Windows::Windows2008, Profiles::Windows::Windows2012]) if PLATFORM == :win32
+      @options[:snmp_options] ||= {}
+      @options[:ssh_options] ||= {}
+
+      invalid_options = options.keys - @options.keys
+      if invalid_options.any?
+        raise ArgumentError, "invalid options specified (#{invalid_options.join(", ")})"
+      end
+
+      # override the defaults with passed in Options
+      @options.merge!(options)
+    end
+
+    # Getter method for grabbing a value from the Options.
+    #  puts options[:log_level] #=> :debug
+    #
+    # @param key symbol of the key-value pair
+    # @return returns the value of specified key from Options
+    def [](key)
+      @options[key]
+    end
+
+    # Setter method for setting the value in the options hash
+    #  puts options[:log_level] #=> :debug
+    #  options[:log_level] = :info
+    #  puts options[:log_level] #=> :info
+    # @raise ArgumentError when invalid options are provided
+    def []=(key, val)
+      raise ArgumentError, 'invalid option provided' if !@options.has_key?(key)
+      @options[key] = val
+    end
+
+    # Provides a simple mechanism for adding credentials to the credentials array of Options.
+    #
+    # @param cred [Hash] a credential hash. Values include +:user+, +:password+, and
+    #  +:connection_types+. +:user+ is mandatory, and +:connection_types+ should be an Array.
+    # @raise ArgumentError when invalid credentials or connection_types are supplied
+    def add_credential(cred)
+      raise ArgumentError, 'invalid credential supplied (must be Hash)' if !cred.kind_of?(Hash)
+      raise ArgumentError, 'username required' if !cred[:user]
+
+      cred[:connection_types] ||= VALID_CONNECTION_TYPES
+
+      invalid_options = cred[:connection_types] - VALID_CONNECTION_TYPES
+      if invalid_options.any?
+        raise ArgumentError, "invalid connection method specified (#{invalid_options.join(', ')})"
+      end
+
+      @options[:credentials] << cred unless @options[:credentials].include?(cred)
+    end
+  end
+end

data/lib/boris/profiles/linux/redhat.rb

@@ -0,0 +1,77 @@
+require 'boris/profiles/linux_core'
+
+module Boris; module Profiles
+    module RedHat
+      include Linux
+
+      def self.connection_type
+        Linux.connection_type
+      end
+
+      def self.matches_target?(connector)
+        release_data = connector.values_at(%q{ls -d /etc/[A-Za-z]*[_-][rv]e[lr]* | grep -v "lsb|system" | cut -d '/' -f3 | cut -d '-' -f1 | cut -d '_' -f1}).join(' ')
+        return true if release_data =~ /redhat/i
+      end
+
+      def get_file_systems; super; end
+      def get_hardware; super; end
+
+      def get_hosted_shares
+        super
+
+        # TODO add code for gathering list of hosted shares from redhat
+      end
+
+      def get_installed_applications
+        super
+        
+        application_data = @connector.values_at('rpm -qa --queryformat "%{NAME}|%{VERSION}|%{VENDOR}|%{ARCH}|%{INSTALLTIME:date}\n" | sort')
+
+        application_data.each do |application|
+          application = application.split('|')
+          h = installed_application_template
+
+          h[:date_installed] = DateTime.parse(application[4])
+          h[:install_location] = nil
+          h[:name] = application[0]
+          h[:vendor] = application[2]
+          h[:version] = application[1]
+
+          @installed_applications << h
+        end
+      end
+
+      def get_installed_patches; super; end
+
+      def get_installed_services
+        super
+        service_data = @connector.values_at("/sbin/chkconfig --list | awk {'print $1'}")
+
+        service_data.each do |service|
+          h = installed_service_template
+          h[:name] = service
+
+          @installed_services << h
+        end
+      end
+
+      def get_local_user_groups; super; end
+      def get_network_id; super; end
+      def get_network_interfaces; super; end
+
+      def get_operating_system
+        super
+
+        os_install_date = @connector.value_at("rpm -qa basesystem --queryformat '%{INSTALLTIME:date}\n'")
+        kernel_version = @connector.value_at('uname -r')
+        os_data = @connector.values_at('lsb_release -a | egrep -i "description|release"')
+
+        @operating_system[:date_installed] = DateTime.parse(os_install_date)
+        @operating_system[:kernel] = kernel_version
+
+        os_base_name = os_data.grep(/^description/i)[0].after_colon
+        @operating_system[:name] = os_base_name.split(/ linux /i)[0] + ' Linux'
+        @operating_system[:version] = os_base_name.scan(/linux (.*) release/i).join + ' ' + os_data.grep(/^release/i)[0].after_colon
+      end
+    end
+end; end