nexpose_pxgrid 0.1.2-java

data/lib/pxnx_jruby/nx_logger.rb

@@ -0,0 +1,166 @@
+require 'fileutils'
+require 'json'
+require 'net/http'
+require 'singleton'
+
+module PxnxJruby
+  class NxLogger
+    include Singleton
+    LOG_PATH = "../logs/rapid7_%s.log"
+    KEY_FORMAT = "external.integration.%s"
+    PRODUCT_FORMAT = "%s_%s"
+
+    DEFAULT_LOG = 'integration'
+    PRODUCT_RANGE = 4..30
+    KEY_RANGE = 3..15
+
+    ENDPOINT = '/data/external/statistic/'
+
+    def initialize()
+      create_calls
+      @logger_file = get_log_path @product
+      setup_logging(true, 'info')
+    end
+
+    def setup_statistics_collection(vendor, product_name, gem_version)
+      begin
+        @statistic_key = get_statistic_key vendor
+        @product = get_product product_name, gem_version
+      rescue => e
+        #Continue
+      end
+    end
+
+    def setup_logging(enabled, log_level = 'info', stdout=false)
+      @stdout = stdout
+
+      log_message('Logging disabled.') unless enabled || @log.nil?
+      @enabled = enabled
+      return unless @enabled
+
+      @logger_file = get_log_path @product
+
+      require 'logger'
+      directory = File.dirname(@logger_file)
+      FileUtils.mkdir_p(directory) unless File.directory?(directory)
+      io = IO.for_fd(IO.sysopen(@logger_file, 'a'), 'a')
+      io.autoclose = false
+      io.sync = true
+      @log = Logger.new(io, 'weekly')
+      @log.level = if log_level.to_s.casecmp('info') == 0 
+                     Logger::INFO 
+                   else
+                     Logger::DEBUG
+                   end
+      log_message("Logging enabled at level <#{log_level}>")
+    end
+
+    def create_calls
+      levels = [:info, :debug, :error, :warn]
+      levels.each do |level|
+        method_name = 
+        define_singleton_method("log_#{level.to_s}_message") do |message|
+          puts message if @stdout
+          @log.send(level, message) unless !@enabled || @log.nil?
+        end
+      end
+    end
+
+    def log_message(message)
+      log_info_message message
+    end
+
+    def log_stat_message(message)
+    end
+
+    def get_log_path(product)
+      product.downcase! unless product.nil?
+      File.join(File.dirname(__FILE__), LOG_PATH % (product || DEFAULT_LOG))
+    end
+
+    def get_statistic_key(vendor)
+      if vendor.nil? || vendor.length < KEY_RANGE.min
+        log_stat_message("Vendor length is below minimum of <#{KEY_RANGE}>")
+        return nil
+      end
+
+      vendor.gsub!('-', '_')
+      vendor.slice! vendor.rindex('_') until vendor.count('_') <= 1
+
+      vendor.delete! "^A-Za-z0-9\_"
+
+      KEY_FORMAT % vendor[0...KEY_RANGE.max].downcase
+    end
+
+    def get_product(product, version)
+      return nil if ((product.nil? || product.empty?) || 
+                     (version.nil? || version.empty?))
+
+      product.gsub!('-', '_')
+      product.slice! product.rindex('_') until product.count('_') <= 1
+
+      product.delete! "^A-Za-z0-9\_"
+      version.delete! "^A-Za-z0-9\.\-"
+
+      product = (PRODUCT_FORMAT % [product, version])[0...PRODUCT_RANGE.max]
+
+      product.slice! product.rindex(/[A-Z0-9]/i)+1..-1
+
+      if product.length < PRODUCT_RANGE.min
+        log_stat_message("Product length below minimum <#{PRODUCT_RANGE.min}>.")
+        return nil
+      end
+      product.downcase
+    end
+
+    def generate_payload(statistic_value='')
+      product_name, separator, version = @product.to_s.rpartition('_')
+      payload_value = {'version' => version}.to_json
+
+      payload = {'statistic-key' => @statistic_key.to_s,
+                 'statistic-value' => payload_value,
+                 'product' => product_name}
+      JSON.generate(payload)
+    end
+
+    def send(nexpose_address, nexpose_port, session_id, payload)
+      header = {'Content-Type' => 'application/json',
+                'nexposeCCSessionID' => session_id,
+                'Cookie' => "nexposeCCSessionID=#{session_id}"}
+      req = Net::HTTP::Put.new(ENDPOINT, header)
+      req.body = payload
+      http_instance = Net::HTTP.new(nexpose_address, nexpose_port)
+      http_instance.use_ssl = true
+      http_instance.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      response = http_instance.start { |http| http.request(req) }
+      log_stat_message "Received code #{response.code} from Nexpose console."
+      log_stat_message "Received message #{response.msg} from Nexpose console."
+      log_stat_message 'Finished sending statistics data to Nexpose.'
+
+      response.code
+    end
+
+    def on_connect(nexpose_address, nexpose_port, session_id, value)
+      log_stat_message 'Sending statistics data to Nexpose'
+
+      if @product.nil? || @statistic_key.nil?
+        log_stat_message('Invalid product name and/or statistics key.')
+        log_stat_message('Statistics collection not enabled.')
+        return
+      end
+      
+      begin
+        payload = generate_payload value
+        send(nexpose_address, nexpose_port, session_id, payload)
+      rescue => e
+        #Let the program continue
+      end
+    end
+
+    #Used by net library for debugging 
+    def <<(value)
+      log_debug_message(value)
+    end
+
+  end
+end

data/lib/pxnx_jruby/session_directory_notification.rb

@@ -0,0 +1,26 @@
+module PxnxJruby
+  class SessionDirectoryNotification
+    require 'java'
+    require 'jruby/core_ext'
+    java_import org.slf4j.Logger
+    java_import org.slf4j.LoggerFactory
+    include Java::com.cisco.pxgrid.stub.identity.SessionDirectoryNotification
+    java_signature 'void onChange(com.cisco.pxgrid.model.net.Session)'
+    attr_accessor :session, :interface, :device_ip_address
+
+    # TODO: Test this method.
+    # TODO: Properly create calls to start integration with the IP received.
+    def onChange(session)
+      # Log this session id.
+      @session = session
+      @interface = session.getInterface
+      device_interfaces = @interface.getIpIntfIDs
+      device = device_interfaces[0]
+      @device_ip_address = device.get_ip_address
+      connect_manager = PxnxJruby::ConnectionManager.instance
+      log = LoggerFactory.getLogger(SessionDirectoryNotification.become_java!)
+      log.info("Found new IP #{@device_ip_address} connecting to the network, assessing.")
+      connect_manager.new_connection(@device_ip_address)
+    end
+  end
+end

data/lib/pxnx_jruby/spoon/README

@@ -0,0 +1,7 @@
+The Apache licence applies to all files within this folder ('spoon').
+
+The original project was authored by 'headius' (https://github.com/headius) and is located at: https://github.com/headius/spoon.
+
+Modifications have been made to the pxnx_daemon_windows.rb file to fix issue #17 (https://github.com/headius/spoon/issues/17):
+    * Now extends the FFI Lib
+    * Imports MSVCRT DLL where some of the used functions are defined.

data/lib/pxnx_jruby/spoon/pxnx_daemon_unix.rb

@@ -0,0 +1,181 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# UNIX posix_spawn
+
+require 'ffi'
+
+module Spoon
+  class FileActions
+    attr_reader :pointer
+    SIZE = FFI::Platform.mac? ? FFI.type_size(:pointer) : 128
+
+    def initialize
+      @pointer =  FFI::AutoPointer.new(LibC.malloc(SIZE), Releaser)
+      error = LibC.posix_spawn_file_actions_init(@pointer)
+      raise SystemCallError.new("posix_file_actions_init", error) unless error == 0
+    end
+
+    class Releaser
+      def self.call(ptr)
+        LibC.posix_spawn_file_actions_destroy(ptr)
+        LibC.free(ptr)
+      end
+    end
+
+    def open(fd, path, oflag, mode)
+      error = LibC.posix_spawn_file_actions_addopen(@pointer, fd, path, oflag, mode)
+      raise SystemCallError.new("posix_file_actions_addopen", error) unless error == 0
+      self
+    end
+
+    def close(fd)
+      error = LibC.posix_spawn_file_actions_addclose(@pointer, fd)
+      raise SystemCallError.new("posix_file_actions_addclose", error) unless error == 0
+      self
+    end
+
+    def dup2(fd, newfd)
+      error = LibC.posix_spawn_file_actions_adddup2(@pointer, fd, newfd)
+      raise SystemCallError.new("posix_file_actions_adddup2", error) unless error == 0
+      self
+    end
+  end
+
+  class SpawnAttributes
+    attr_reader :pointer
+    SIZE = FFI::Platform.mac? ? FFI.type_size(:pointer) : 512
+
+    def initialize
+      @pointer =  FFI::AutoPointer.new(LibC.malloc(SIZE), Releaser)
+      error = LibC.posix_spawnattr_init(@pointer)
+      raise SystemCallError.new("posix_spawnattr_init", error) unless error == 0
+    end
+
+    class Releaser
+      def self.call(ptr)
+        LibC.posix_spawnattr_destroy(ptr)
+        LibC.free(ptr)
+      end
+    end
+
+    def pgroup=(group)
+      error = LibC.posix_spawnattr_setpgroup(pointer, group)
+      raise SystemCallError.new("posix_spawnattr_setpgroup", error) unless error == 0
+      group
+    end
+
+    def pgroup
+      group = FFI::MemoryPointer.new :pid_t
+      error = LibC.posix_spawnattr_getpgroup(pointer, group)
+      raise SystemCallError.new("posix_spawnattr_getpgroup", error) unless error == 0
+      get_pid(group)
+    end
+  end
+
+  def self.posix_spawn(path, file_actions, spawn_attr, argv, env = ENV)
+    pid_ptr, argv_ptr, env_ptr = _prepare_spawn_args(argv, env)
+    error = LibC.posix_spawnp(pid_ptr, path, file_actions, spawn_attr, argv_ptr, env_ptr)
+    raise SystemCallError.new(path, error) unless error == 0
+    get_pid(pid_ptr)
+  end
+
+  def self.posix_spawnp(file, file_actions, spawn_attr, argv, env = ENV)
+    pid_ptr, argv_ptr, env_ptr = _prepare_spawn_args(argv, env)
+    error = LibC.posix_spawnp(pid_ptr, file, file_actions, spawn_attr, argv_ptr, env_ptr)
+    raise SystemCallError.new(file, error) unless error == 0
+    get_pid(pid_ptr)
+  end
+
+  def self.spawn(*args)
+    posix_spawn(args[0], nil, nil, args, ENV)
+  end
+
+  def self.spawnp(*args)
+    posix_spawnp(args[0], nil, nil, args, ENV)
+  end
+
+  private
+
+  class PointerArray
+    def initialize
+      @ary = []
+    end
+
+    def <<(ptr)
+      @ary << ptr
+      self
+    end
+
+    def pointer
+      if @pointer.nil? || (@pointer.size / @pointer.type_size) <= @ary.length
+        ptr = FFI::MemoryPointer.new(:pointer, @ary.length + 1)
+        ptr.put_array_of_pointer(0, @ary)
+        @pointer = ptr
+      end
+      @pointer
+    end
+  end
+
+  if FFI.type_size(:pid_t) == 4
+    def self.get_pid(ptr)
+      ptr.get_int32(0)
+    end
+  else
+    def self.get_pid(ptr)
+      ptr.get_int64(0)
+    end
+  end
+
+  module LibC
+    extend FFI::Library
+    ffi_lib FFI::Library::LIBC
+
+    class PointerConverter
+      extend FFI::DataConverter
+      native_type FFI::Type::POINTER
+
+      def self.to_native(value, ctx)
+        value ? value.pointer : nil
+      end
+    end
+
+    typedef PointerConverter, :file_actions
+    typedef PointerConverter, :spawn_attr
+    typedef PointerConverter, :ptr_array
+
+    attach_function :posix_spawn, [:pointer, :string, :file_actions, :spawn_attr, :ptr_array, :ptr_array ], :int
+    attach_function :posix_spawnp, [:pointer, :string, :file_actions, :spawn_attr, :ptr_array, :ptr_array ], :int
+    attach_function :posix_spawn_file_actions_init, [ :pointer ], :int
+    attach_function :posix_spawn_file_actions_destroy, [ :pointer ], :int
+    attach_function :posix_spawn_file_actions_adddup2, [ :pointer, :int, :int ], :int
+    attach_function :posix_spawn_file_actions_addclose, [ :pointer, :int ], :int
+    attach_function :posix_spawn_file_actions_addopen, [ :pointer, :int, :string, :int, :mode_t ], :int
+    attach_function :posix_spawnattr_init, [ :pointer ], :int
+    attach_function :posix_spawnattr_destroy, [ :pointer ], :int
+    attach_function :posix_spawnattr_setpgroup, [ :pointer, :pid_t ], :int
+    attach_function :posix_spawnattr_getpgroup, [ :pointer, :pointer ], :int
+    attach_function :malloc, [ :size_t ], :pointer
+    attach_function :free, [ :pointer ], :void
+    attach_function :strerror, [ :int ], :string
+  end
+
+  def self._prepare_spawn_args(argv, env)
+    pid_ptr = FFI::MemoryPointer.new(:pid_t, 1)
+
+    args_ary = argv.inject(PointerArray.new) { |ary, str| ary << FFI::MemoryPointer.from_string(str) }
+    env_ary = PointerArray.new
+    env.each_pair { |key, value| env_ary << FFI::MemoryPointer.from_string("#{key}=#{value}") }
+
+    [pid_ptr, args_ary, env_ary]
+  end
+end

data/lib/pxnx_jruby/spoon/pxnx_daemon_windows.rb

@@ -0,0 +1,50 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'ffi'
+
+module Spoon
+  extend FFI::Library
+  P_NOWAIT = 1
+
+  ffi_lib 'MSVCRT'
+  attach_function :_spawnve, [:int, :string, :pointer, :pointer], :int
+  attach_function :_spawnvpe, [:int, :string, :pointer, :pointer], :int
+
+  ffi_lib 'kernel32'
+  ffi_convention :stdcall
+  attach_function :_get_process_id, :GetProcessId, [:int], :ulong
+
+  def self.spawn(*args)
+    spawn_args = _prepare_spawn_args(args)
+    _get_process_id(_spawnve(*spawn_args))
+  end
+
+  def self.spawnp(*args)
+    spawn_args = _prepare_spawn_args(args)
+    _get_process_id(_spawnvpe(*spawn_args))
+  end
+
+  private
+
+  def self._prepare_spawn_args(args)
+    args_ary = FFI::MemoryPointer.new(:pointer, args.length + 1)
+    str_ptrs = args.map {|str| FFI::MemoryPointer.from_string(str)}
+    args_ary.put_array_of_pointer(0, str_ptrs)
+
+    env_ary = FFI::MemoryPointer.new(:pointer, ENV.length + 1)
+    env_ptrs = ENV.map {|key,value| FFI::MemoryPointer.from_string("#{key}=#{value}")}
+    env_ary.put_array_of_pointer(0, env_ptrs)
+
+    [P_NOWAIT, args[0], args_ary, env_ary]
+  end
+end

data/lib/pxnx_jruby/spoon/pxnx_runner.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if RbConfig::CONFIG['host_os'] =~ /mingw|mswin|bccwin/
+  require_relative 'pxnx_daemon_windows'
+else
+  require_relative 'pxnx_daemon_unix'
+end

data/lib/pxnx_jruby/version.rb

@@ -0,0 +1,5 @@
+module PxnxJruby
+  PRODUCT = 'pxGrid'
+  VENDOR = 'Cisco'
+  VERSION = "0.1.2"
+end