msfrpc-simple 0.0.1

data/Gemfile

@@ -0,0 +1,10 @@
+
+source 'http://rubygems.org'
+
+gem 'librex'
+gem 'msfrpc-client'
+
+group :test do
+	gem 'rspec'
+	gem 'pry'
+end

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (1.0.7)
+    diff-lcs (1.1.3)
+    librex (0.0.65)
+    method_source (0.8)
+    msfrpc-client (1.0.1)
+      librex (>= 0.0.32)
+      msgpack (>= 0.4.5)
+    msgpack (0.4.6)
+    pry (0.9.10)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.3.1)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.1)
+    slop (3.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  librex
+  msfrpc-client
+  pry
+  rspec

data/LICENSE

@@ -0,0 +1,31 @@
+Copyright (C) 2012, Pentestify LLC
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    * Neither the name of Pentestify LLC nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+================================================================================
+
+The msfrpc-simple library is provided under the 3-clause BSD license above.

data/README.md

@@ -0,0 +1 @@
+This library provides a simple-to-use wrapper for the Rapid7 Metasploit RPC API. 

data/Rakefile

@@ -0,0 +1,5 @@
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+
+desc "Run all RSpec tests"
+RSpec::Core::RakeTask.new(:spec)

data/lib/msfrpc-simple/client.rb

@@ -0,0 +1,58 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+require 'msfrpc-client'
+require 'features/framework'
+require 'features/pro'
+require 'module_mapper'
+require 'logger'
+require 'pry'
+
+module Msf
+  module RPC
+    module Simple
+      class Client
+
+        include Msf::RPC::Simple::Features::Framework
+        include Msf::RPC::Simple::Features::Pro
+
+        # Public: Create a simple client object.
+        #
+        # opts - hash of options to include in our initial connection.
+        # project - project name we want to use for this connection.
+        #
+        # Returns nothing.
+        def initialize(project="default", username, password, user_opts)
+
+          #
+          # Merge our project in, and set this as the project we'll
+          # use going forward. 
+          #
+          conn_params = { 
+            :project => project, 
+            :port => 55553,
+            :user => username, 
+            :pass => password 
+          }
+
+          user_opts.merge!(conn_params)
+          
+          #
+          # Connect to the RPC daemon using the default r7 client
+          #
+          @client = Msf::RPC::Client.new(user_opts)
+
+          #
+          # Create a logger
+          #
+          @logger = Msf::RPC::Simple::Logger.new
+        end
+
+        #
+        #  
+        #
+        def connected?
+          return true if @client.call("core.version")   
+        end
+      end
+    end
+  end
+end

data/lib/msfrpc-simple/features/framework.rb

@@ -0,0 +1,163 @@
+module Msf
+  module RPC
+    module Simple
+      module Features 
+        module Framework
+          
+          #
+          # This module simply runs a module
+          #
+          def execute_module_and_return_output(options)
+
+            module_name = options[:module_name]
+            #module_options = options[:module_options]
+            module_option_string = options[:module_option_string]
+
+            # split up the module name into type / name
+            module_type = module_name.split("/").first
+            raise "Error, bad module name" unless ["exploit", "auxiliary", "post", "encoder", "nop"].include? module_type  
+            
+            #module_options["TARGET"] = 0 unless module_options["TARGET"]
+
+            #info = @client.call("module.execute", module_type, module_name, module_options)
+            #@client.call("job.info", info["job_id"])
+
+            # The module output will be not available when run this way; to 
+            # capture the result of the print_* commands, you have to set the
+            # output driver of the module to something you can read from (Buffer,
+            # File, etc). For your use case, the best bet is to run the module 
+            # via the Console API instead of module.execute, and use that to read
+            # the output from the console itself, which provides buffer output for you.
+
+            # Create the console and get its id
+            console = @client.call("console.create")
+            console_id = console["id"]
+
+            # Do an initial read / discard to pull out the banner
+            @client.call("console.read", console_id)
+
+            # Move to the context of our module
+            @client.call("console.write", console_id, "use #{module_name}\n")
+
+            # Set up the module's datastore
+            module_option_string.split(",").each do |module_option|
+              @client.call "console.write", console_id, "set #{module_option}\n"
+            end
+
+            # Do an another read / discard to pull out the option confirmation
+            @client.call("console.read", console_id)
+
+            # Depending on the module_type, kick off the module
+            if module_type == "auxiliary"
+              @client.call "console.write", console_id, "run\n"
+            elsif module_type == "exploit"
+              @client.call "console.write", console_id, "exploit\n"
+            else
+              return "Unsupported"
+            end
+
+            # do an initial read of the module's output
+            module_output = @client.call("console.read", console_id)
+            module_output_data_string = "#{module_output['data']}"
+          
+            return "Module Error" if module_output["result"] == "failure"
+
+            until (module_output["busy"] == false) do
+              module_output = @client.call("console.read", console_id)
+              module_output_data_string += "#{module_output['data']}"
+              return "Module Error" if module_output["result"] == "failure"
+            end
+
+            # Clean up 
+            @client.call("console.destroy", console_id)
+
+          module_output_data_string
+          end
+
+
+          #
+          # This module runs a number of discovery modules
+          #
+          def discover_host(host)
+
+            # http version 
+            modules_and_options = [ 
+              {:module_name => "auxiliary/scanner/http/http_version", 
+               :module_option_string => "RHOSTS #{host}" },
+              {:module_name => "auxiliary/scanner/http/cert", 
+               :module_option_string => "RHOSTS #{host}" }
+            ]
+
+            # This is a naive and horrible way of doing it, but let's just knock 
+            # out the basic thing first. For each module in our list... 
+            module_output_data_string = ""
+            modules_and_options.each do |module_and_options|
+
+              module_name = module_and_options[:module_name]
+              module_option_string = module_and_options[:module_option_string]
+
+              # store this module's name in the output
+              module_output_data_string += "=== #{module_name} #{module_option_string} ===\n"
+
+              # split up the module name into type / name
+              module_type = module_name.split("/").first
+              raise "Error, bad module name" unless ["exploit", "auxiliary", "post", "encoder", "nop"].include? module_type  
+
+              # Create the console and get its id
+              console = @client.call("console.create")
+              console_id = console["id"]
+
+              # Do an initial read / discard to pull out the banner
+              @client.call("console.read", console_id)
+
+              # Move to the context of our module
+              @client.call("console.write", console_id, "use #{module_name}\n")
+
+              # Set up the module's datastore
+              module_option_string.split(",").each do |module_option|
+                @client.call "console.write", console_id, "set #{module_option}\n"
+              end
+
+              # Do an another read / discard to pull out the option confirmation
+              @client.call("console.read", console_id)
+
+              # Depending on the module_type, kick off the module
+              if module_type == "auxiliary"
+                @client.call "console.write", console_id, "run\n"
+              elsif module_type == "exploit"
+                @client.call "console.write", console_id, "exploit\n"
+              else
+                return "Unsupported"
+              end
+
+              # do an initial read of the module's output
+              module_output = @client.call("console.read", console_id)
+            
+              return "Module Error" if module_output["result"] == "failure"
+
+              until (module_output["busy"] == false) do
+                module_output = @client.call("console.read", console_id)
+                module_output_data_string += "#{module_output['data']}"
+                return "Module Error" if module_output["result"] == "failure"
+              end
+
+              # Clean up 
+              @client.call("console.destroy", console_id)
+            end
+
+          module_output_data_string
+          end
+
+
+          #
+          # This module runs a number of _login modules
+          #
+          def fw_bruteforce(options)
+            return "Not Implemented"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/msfrpc-simple/features/pro.rb

@@ -0,0 +1,56 @@
+module Msf
+  module RPC
+    module Simple
+      module Features 
+        module Pro
+
+          def start_report(options)
+            raise "Not Implemented"
+=begin
+            task = @rpc.call("pro.start_report", {
+              'DS_REPORT_TYPE'            => options[:report_type],
+              'DS_WHITELIST_HOSTS'        => options[:whitelist],
+              'DS_BLACKLIST_HOSTS'        => options[:blacklist],
+              'workspace'                 => options[:workspace],
+              'username'                  => options[:username],
+              'DS_MaskPasswords'          => options[:ds_mask_passwords] || true,
+              'DS_IncludeTaskLog'         => options[:include_task_log] || true,
+              'DS_JasperDisplaySession'   => options[:ds_jasper_display_session] || false,
+              'DS_JasperDisplayCharts'    => options[:ds_mask_passwords] || true,
+              'DS_LootExcludeScreenshots' => options[:ds_loot_exclude_screenshots] || false,
+              'DS_LootExcludePasswords'   => options[:ds_loot_exclude_passwords] || false,
+              'DS_JasperTemplate'         => options[:ds_jasper_template] || "msfxv3.jrxml",
+              'DS_UseJasper'              => options[:ds_use_jasper]] ||true,
+              'DS_UseCustomReporting'     => options[:ds_use_custom_reporting] || false,
+              'DS_JasperProductName'      => options[:ds_jasper_product_name] || "Metasploit Pro",
+              'DS_JasperDbEnv'            => options[:ds_jasper_db_env] || "production",
+              'DS_JasperLogo'             => options[:ds_jasper_logo] || "",
+              'DS_JasperDisplaySections'  => options[:ds_jasper_display_sections] || "1,2,3,4,5,6,7,8",
+              'DS_EnablePCIReport'        => options[:ds_enable_pci_report] || true,
+              'DS_EnableFISMAReport'      => options[:ds_enable_fisma_report] || true,
+              'DS_JasperDisplayWeb'       => options[:ds_enable_jasper_display_web] || true,
+            })
+=end
+          end
+
+          def start_discover(options)
+            raise "Not Implemented"
+
+            #task = @rpc.call("pro.start_discover", {
+            #  'DS_WHITELIST_HOSTS'        => options[:whitelist],
+            #  'DS_BLACKLIST_HOSTS'        => options[:blacklist],
+            #  'workspace'                 => options[:workspace],
+            #  'username'                  => options[:username]
+            #})
+          end
+
+          def start_bruteforce(options)
+            raise "Not Implemented"
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/lib/msfrpc-simple/logger.rb

@@ -0,0 +1,21 @@
+module Msf
+  module RPC
+    module Simple
+      class Logger
+
+        def initialize(filename="msfrpc-simple.log")
+          @log = File.open(filename, "w+")
+        end
+
+        def log(text)
+          @log.puts text
+        end
+
+        def close 
+          @log.close
+        end
+
+      end
+    end
+  end
+end

data/lib/msfrpc-simple/module_mapper.rb

@@ -0,0 +1,149 @@
+module Msf
+  module RPC
+    module Simple
+      module ModuleMapper 
+          
+          # Public: Get all discovery modules, given a host endpoint
+          #
+          # This method may seem poorly abstracted but you must pass in an IP address
+          #  in order to compensate for the different ways that modules accept an
+          #  endpoint. For example, scanners need an RHOSTS option, while most other 
+          #  modules will accept a RHOST option.
+          #
+          # Returns a list of hashes, each one containing:
+          #  [
+          #  { :ip_address, 
+          #    :port_num,
+          #    :protocol,
+          #    :transport,
+          #    :modules_and_options => [ { :module_name, :module_option_string }, ...],
+          #  }, ...
+          #  ]
+          def self.get_discovery_modules_for_endpoints(endpoints)
+            #
+            # Iterate through the endpoints, assigning modules
+            #
+            endpoints_with_modules = []
+            endpoints.each do |endpoint|
+              endpoints_with_modules << get_discovery_modules_for_endpoint(endpoint)
+            end
+
+          endpoints_with_modules
+          end
+
+          # Public: Returns all discovery modules for a singular endpoint
+          #
+          # An endpoint looks like: 
+          #
+          # { :ip_address, 
+          #    :port_num,
+          #    :protocol,
+          #    :transport,
+          #    :modules_and_options => [ { :module_name, :module_option_string }, ...],
+          #  }
+          #
+          # Returns the endpoint object
+          def self.get_discovery_modules_for_endpoint(endpoint)
+              
+            # If we have an unknown protocol, fall back to guessing by port
+            endpoint[:protocol] = get_protocol_by_port_num(endpoint) unless endpoint[:protocol]
+        
+            # Start out with an empty modules_and_options array
+            endpoint[:modules_and_options] = []
+
+            # Now iterate through our protocols, assigning modules & optionss
+            #
+            # FTP
+            #
+            if endpoint[:protocol] == "FTP"
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/ftp/ftp_version",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+            #
+            # TELNET
+            #
+            elsif endpoint[:protocol] == "TELNET"
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/telnet/telnet_version",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+            #
+            # HTTP
+            #
+            elsif endpoint[:protocol] == "HTTP"
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/http/http_version",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+            #
+            # SNMP
+            #
+            elsif endpoint[:protocol] == "SNMP"
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/snmp/snmp_enum",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+              
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/snmp/snmp_enumshares",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+            
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/snmp/snmp_enumusers",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+
+            #
+            # HTTPS
+            #
+            elsif endpoint[:protocol] == "HTTPS"
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/http/http_version",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+              
+              endpoint[:modules_and_options] << {
+                :module_name => "auxiliary/scanner/http/cert",
+                :module_option_string => "RHOSTS #{endpoint[:ip_address]}, RPORT #{endpoint[:port_num]}" }
+            #
+            # Unknown protocol
+            #
+            else
+              
+            end
+
+          # Return the modified endpoint
+          endpoint
+          end
+
+
+          # Public: Returns a guessed protocol based on transport and port num
+          #
+          # Returns a protocol (string)
+          def self.get_protocol_by_port_num(endpoint)
+            #return endpoint[:protocol] unless endpoint[:protocol] == nil
+
+            protocol = nil
+            if endpoint[:transport] == "TCP"
+              if endpoint[:port_num] == 21
+                protocol = "FTP"
+              elsif endpoint[:port_num] == 23
+                protocol = "TELNET"
+              elsif endpoint[:port_num] == 80
+                protocol = "HTTP"
+              elsif endpoint[:port_num] == 443
+                protocol = "HTTPS"
+              elsif endpoint[:port_num] == 8080
+                protocol = "HTTP"
+              end
+            elsif endpoint[:transport] == "UDP"
+              if endpoint[:port_num] == 161
+                protocol = "SNMP"
+              end
+            else
+              raise "Unknown Transport"
+            end
+
+          protocol
+          end
+
+
+      end
+    end
+  end
+end

data/lib/msfrpc-simple/version.rb

@@ -0,0 +1,7 @@
+module Msf
+  module RPC
+    module Simple
+      VERSION = "0.0.1"
+    end
+  end
+end

data/lib/msfrpc-simple.rb

@@ -0,0 +1,7 @@
+#
+# this file exists to be a top level for the gem
+# 
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'msfrpc-simple')))
+
+require 'version'
+require 'client' # our simple client

data/msfrpc-simple.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/msfrpc-simple/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["jcran"]
+  gem.email         = ["jcran@pentestify.com"]
+  gem.description   = %q{Simple interface to Metasploit RPC}
+  gem.summary       = %q{Simple interface to Metasploit RPC}
+  gem.homepage      = "http://www.github.com/jcran/msfrpc-simple"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "msfrpc-simple"
+  gem.require_paths = ["lib"]
+  gem.version       = Msf::RPC::Simple::VERSION
+end

data/spec/client_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+describe "Msf" do 
+  describe "RPC" do
+    describe "Simple" do
+      describe "Client" do
+
+        before :each do
+        
+          @client = Msf::RPC::Simple::Client.new("default", "test", "test", {  
+           # :host => "127.0.0.1",
+           # :port => 55553,
+           # :uri => '/api/'
+           # :ssl => true, 
+           # :password => 'test'
+          })
+
+        end
+
+
+        it "connects to local default msfrpcd" do
+          
+        # This spec requrires the msfrpcd to be runnning... 
+        #
+        # ./msfrpcd -P test -U test
+        #
+
+          #
+          # notice how this client isn't @client, allowing us to modify @client
+          # as necessary
+          #
+          client = Msf::RPC::Simple::Client.new("default", "test", "test", {  
+           # :host => "127.0.0.1",
+           # :port => 55553,
+           # :uri => '/api/'
+           # :ssl => true, 
+           # :password => 'test'
+          })
+
+          client.connected?.should be_true  
+        end
+
+
+        it "runs a module and gives the output" do 
+          output = @client.execute_module_and_return_output({
+            :module_name => "auxiliary/scanner/http/http_version", 
+            :module_option_string => "RHOSTS www.google.com,THREADS 10"
+          })
+          output.should include "Auxiliary module execution completed"
+        end
+        
+        it "runs a basic discover with framework modules" do 
+          output = @client.discover_host("www.google.com")          
+          output.should include "Auxiliary module execution completed"
+        end
+      end
+    end
+  end
+end

data/spec/logger_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+describe "Msf" do 
+  describe "RPC" do
+    describe "Simple" do
+      describe "Logger" do
+
+        it "writes to a logfile" do
+
+          @logger = Msf::RPC::Simple::Logger.new
+          @logger.log "test"
+          @logger.close
+
+          File.open("msfrpc-simple.log").read.should == "test\n"
+
+        end
+      end
+    end
+  end
+end

data/spec/module_mapper_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+describe "Msf" do 
+  describe "RPC" do
+    describe "Simple" do
+      describe "ModuleMapper" do
+
+        before :each do
+        end
+
+        it "maps modules for a standard HTTP endpoint" do 
+
+          endpoint = { 
+            :ip_address => "1.1.1.1",
+            :port_num => 80,
+            :transport => "TCP",
+            :protocol => "HTTP"
+          }
+
+          endpoint_and_modules = Msf::RPC::Simple::ModuleMapper.get_discovery_modules_for_endpoint endpoint
+
+          endpoint_and_modules[:ip_address].should == "1.1.1.1"
+          endpoint_and_modules[:port_num].should == 80
+          endpoint_and_modules[:transport].should == "TCP"
+          endpoint_and_modules[:protocol].should == "HTTP"
+          endpoint_and_modules[:modules_and_options].should include({ 
+            :module_name => "auxiliary/scanner/http/http_version",
+            :module_option_string => "RHOSTS 1.1.1.1, RPORT 80"
+          })
+
+        end
+
+        it "maps modules for a non-standard HTTP endpoint" do 
+
+          endpoint = { 
+            :ip_address => "1.1.1.1",
+            :port_num => 8080,
+            :transport => "TCP",
+          }
+
+          endpoint_and_modules = Msf::RPC::Simple::ModuleMapper.get_discovery_modules_for_endpoint endpoint
+
+          endpoint_and_modules[:ip_address].should == "1.1.1.1"
+          endpoint_and_modules[:port_num].should == 8080
+          endpoint_and_modules[:transport].should == "TCP"
+          endpoint_and_modules[:protocol].should == "HTTP"
+          endpoint_and_modules[:modules_and_options].should include({ 
+            :module_name => "auxiliary/scanner/http/http_version",
+            :module_option_string => "RHOSTS 1.1.1.1, RPORT 8080"
+          })
+
+        end
+
+
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(File.expand_path(File.join(__FILE__,"..")))
+require 'rspec'
+require 'msfrpc-simple'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: msfrpc-simple
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- jcran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-16 00:00:00.000000000 Z
+dependencies: []
+description: Simple interface to Metasploit RPC
+email:
+- jcran@pentestify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/.DS_Store
+- lib/msfrpc-simple.rb
+- lib/msfrpc-simple/.DS_Store
+- lib/msfrpc-simple/client.rb
+- lib/msfrpc-simple/features/.DS_Store
+- lib/msfrpc-simple/features/framework.rb
+- lib/msfrpc-simple/features/pro.rb
+- lib/msfrpc-simple/logger.rb
+- lib/msfrpc-simple/module_mapper.rb
+- lib/msfrpc-simple/version.rb
+- msfrpc-simple.gemspec
+- spec/client_spec.rb
+- spec/logger_spec.rb
+- spec/module_mapper_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.github.com/jcran/msfrpc-simple
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple interface to Metasploit RPC
+test_files:
+- spec/client_spec.rb
+- spec/logger_spec.rb
+- spec/module_mapper_spec.rb
+- spec/spec_helper.rb