wpxf 2.0.0a

data/lib/wpxf/cli/loot.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # A mixin to provide functions to interact with loot stored in the database.
+    module Loot
+      def home_directory
+        File.join(Dir.home, '.wpxf')
+      end
+
+      def build_loot_table
+        rows = []
+        rows.push(
+          id: 'ID',
+          host: 'Host',
+          filename: 'Filename',
+          notes: 'Notes',
+          type: 'Type'
+        )
+
+        Wpxf::Models::LootItem.where(workspace: active_workspace).each do |item|
+          rows.push(
+            id: item.id,
+            host: "#{item.host}:#{item.port}",
+            filename: File.basename(item.path),
+            notes: item.notes,
+            type: item.type
+          )
+        end
+
+        rows
+      end
+
+      def list_loot
+        rows = build_loot_table
+        print_table rows
+        puts
+        print_std "All filenames are relative to #{File.join(home_directory, 'loot')}".yellow
+      end
+
+      def find_loot_item(id)
+        item = Wpxf::Models::LootItem.first(
+          id: id.to_i,
+          workspace: active_workspace
+        )
+
+        return item unless item.nil?
+        print_bad "Could not find loot item #{id} in the current workspace"
+      end
+
+      def delete_loot(id)
+        item = find_loot_item(id)
+        return if item.nil?
+
+        item.destroy
+        print_good "Deleted item #{id}"
+      end
+
+      def print_loot_item(id)
+        item = find_loot_item(id)
+        return if item.nil?
+
+        content = File.read(item.path)
+        puts content
+      end
+
+      def loot(*args)
+        return list_loot if args.length.zero?
+
+        case args[0]
+        when '-d'
+          delete_loot(args[1])
+        when '-p'
+          print_loot_item(args[1])
+        else
+          print_warning 'Invalid option for "loot"'
+        end
+      end
+    end
+  end
+end

data/lib/wpxf/cli/module_cache.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # A mixin to handle the database caching of module data.
+    module ModuleCache
+      def initialize
+        super
+        self.current_version_number = Wpxf.version
+      end
+
+      def cache_valid?
+        last_version_log = Wpxf::Models::Log.first(key: 'version')
+        return false if last_version_log.nil?
+
+        current_version = Gem::Version.new(current_version_number)
+        last_version = Gem::Version.new(last_version_log.value)
+
+        current_version == last_version
+      end
+
+      def create_module_models(type)
+        namespace = type == 'exploit' ? Wpxf::Exploit : Wpxf::Auxiliary
+        namespace.module_list.each do |mod|
+          instance = mod[:class].new
+
+          Wpxf::Models::Module.create(
+            path: mod[:name],
+            name: instance.module_name,
+            type: type,
+            class_name: mod[:class].to_s
+          )
+        end
+      end
+
+      def refresh_version_log
+        log = Wpxf::Models::Log.first(key: 'version')
+        log = Wpxf::Models::Log.new if log.nil?
+        log.key = 'version'
+        log.value = current_version_number
+        log.save
+      end
+
+      def rebuild_cache
+        print_warning 'Refreshing the module cache...'
+
+        Wpxf::Models::Module.truncate
+
+        create_module_models 'exploit'
+        create_module_models 'auxiliary'
+
+        refresh_version_log
+        reset_context_stack
+      end
+
+      attr_accessor :current_version_number
+    end
+  end
+end

data/lib/wpxf/cli/module_info.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # Helper methods for outputing information about the currently loaded module.
+    module ModuleInfo
+      def print_author
+        print_std('Provided by:')
+        indent_cursor do
+          context.module.module_author.each do |author|
+            print_std(author)
+          end
+        end
+      end
+
+      def formatted_module_description
+        if context.module.module_description_preformatted
+          indent_without_wrap(context.module.module_desc)
+        else
+          remove_new_lines_and_wrap_text(context.module.module_desc).strip
+        end
+      end
+
+      def print_description
+        print_std('Description:')
+        indent_cursor do
+          print_std formatted_module_description
+        end
+      end
+
+      def print_module_summary
+        print_std("       Name: #{context.module.module_name}")
+        print_std("     Module: #{context.module_path}")
+        print_std("  Disclosed: #{context.module.module_date}")
+      end
+
+      def print_references
+        return unless context.module.module_references
+        print_std('References:')
+        indent_cursor do
+          context.module.module_references.each do |ref|
+            print_std Wpxf::Utility::ReferenceInflater.new(ref[0]).inflate(ref[1])
+          end
+        end
+      end
+
+      def info
+        return unless module_loaded?(false)
+
+        print_module_summary
+        puts
+        print_author
+        puts
+        show_options
+        puts
+        print_description
+        puts
+        print_references
+      end
+    end
+  end
+end

data/lib/wpxf/cli/modules.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # Methods for handling module loading and searching.
+    module Modules
+      def initialize
+        super
+        self.context_stack = []
+      end
+
+      def context
+        context_stack.last
+      end
+
+      def back
+        context_stack.pop
+        context.module.active_workspace = active_workspace if context
+
+        refresh_autocomplete_options
+      end
+
+      def reload
+        return unless module_loaded?(false)
+
+        begin
+          mod = context.reload
+          mod.event_emitter.subscribe(self)
+          mod.active_workspace = active_workspace
+          print_good "Reloaded module: #{mod}"
+        rescue StandardError => e
+          print_bad "Failed to reload module: #{e}"
+          return
+        end
+
+        apply_global_options(mod)
+      end
+
+      def use(module_path)
+        context = Context.new
+        begin
+          mod = context.load_module(module_path)
+          mod.event_emitter.subscribe(self)
+          mod.active_workspace = active_workspace
+          print_good "Loaded module: #{mod}"
+          mod.emit_usage_info
+          context_stack.push(context)
+        rescue StandardError => e
+          print_bad "Failed to load module: #{e}"
+          return
+        end
+
+        apply_global_options(mod)
+        refresh_autocomplete_options
+      end
+
+      def module_name_from_class(klass)
+        klass.new.module_name
+      end
+
+      def search_modules(args)
+        modules = Wpxf::Models::Module.where(Sequel.ilike(:name, "%#{args.join(' ')}%"))
+        modules.map { |m| { path: m.path, title: m.name } }
+      end
+
+      def print_module_table(modules)
+        modules = modules.sort_by { |k| k[:path] }
+        modules.unshift(path: 'Module', title: 'Title')
+        puts
+        indent_cursor 2 do
+          print_table(modules)
+        end
+      end
+
+      def search(*args)
+        results = search_modules(args)
+
+        if !results.empty?
+          print_good "#{results.length} Results for \"#{args.join(' ')}\""
+          print_module_table results
+        else
+          print_bad "No results for \"#{args.join(' ')}\""
+        end
+      end
+
+      def reset_context_stack
+        self.context_stack = []
+        setup_auto_complete
+      end
+
+      attr_accessor :context_stack
+    end
+  end
+end

data/lib/wpxf/cli/options.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # Methods for handling commands that interact with module options.
+    module Options
+      def initialize
+        super
+        self.global_opts = {}
+      end
+
+      def unset(name)
+        unless context
+          print_bad 'No module loaded yet'
+          return
+        end
+
+        if name.eql?('payload')
+          context.module.payload = nil
+        else
+          context.module.unset_option(name)
+        end
+
+        print_good "Unset #{name}"
+      end
+
+      def apply_global_options(target)
+        return if target.nil?
+        global_opts.each do |k, v|
+          target.set_option_value(k, v)
+        end
+      end
+
+      def load_payload(name)
+        if context.module.aux_module?
+          print_warning 'Auxiliary modules do not use payloads'
+          return
+        end
+
+        begin
+          payload = context.load_payload(name)
+          print_good "Loaded payload: #{payload}"
+        rescue StandardError => e
+          print_bad "Failed to load payload: #{e}"
+          print_bad e.backtrace.join("\n\t")
+          return
+        end
+
+        apply_global_options(payload)
+        refresh_autocomplete_options
+      end
+
+      def set_option_value(name, value, silent = false)
+        res = context.module.set_option_value(name, value)
+
+        return if silent
+
+        if res == :not_found
+          print_warning "\"#{name}\" is not a valid option"
+        elsif res == :invalid
+          print_bad "\"#{value}\" is not a valid value"
+        else
+          print_good "Set #{name} => #{res}"
+        end
+      end
+
+      def gset(name, *args)
+        if name.eql? 'payload'
+          print_warning 'The payload cannot be globally set'
+          return
+        end
+
+        value = args.join(' ')
+        global_opts[name] = value
+        set_option_value(name, value, true) if context
+
+        print_good "Globally set the value of #{name} to #{value}"
+      end
+
+      def gunset(name)
+        global_opts.delete(name)
+        context.module.unset_option(name) if module_loaded?
+        print_good "Removed the global setting for #{name}"
+      end
+
+      def set(name, *args)
+        value = args.join(' ')
+        return unless module_loaded?
+
+        begin
+          if name.eql? 'payload'
+            load_payload(value)
+          else
+            set_option_value(name, value)
+          end
+        rescue StandardError => e
+          print_bad "Failed to set #{name}: #{e}"
+          print_bad e.backtrace.join("\n\t")
+        end
+      end
+
+      attr_accessor :global_opts
+    end
+  end
+end

data/lib/wpxf/cli/output.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Wpxf
+  module Cli
+    # Methods for handling output to the screen.
+    module Output
+      def initialize
+        super
+        self.indent = '  '
+        self.indent_level = 1
+      end
+
+      def indent_cursor(level = 1)
+        self.indent_level += level
+        yield
+        self.indent_level -= level
+      end
+
+      def remove_new_lines_and_wrap_text(value, padding = 0, width = 78)
+        wrap_text(value.tr("\n", ''), padding, width)
+      end
+
+      def wrap_text(value, padding = 0, width = 78)
+        value.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n#{indent * indent_level}#{' ' * padding}").chomp
+             .gsub(/\s+$/, '')
+      end
+
+      def indent_without_wrap(value)
+        value.gsub(/\n/, "\n#{indent * indent_level}")
+      end
+
+      def print_std(msg)
+        puts "#{indent * indent_level}#{msg}"
+      end
+
+      def print_info(msg)
+        print "#{indent * indent_level}[-] ".light_blue
+        puts wrap_text(msg, 4, 90)
+      end
+
+      def print_good(msg)
+        print "#{indent * indent_level}[+] ".green
+        puts wrap_text(msg, 4, 90)
+      end
+
+      def print_bad(msg)
+        print "#{indent * indent_level}[!] ".red
+        puts wrap_text(msg, 4, 90)
+      end
+
+      def print_warning(msg)
+        print "#{indent * indent_level}[!] ".yellow
+        puts wrap_text(msg, 4, 90)
+      end
+
+      def print_table(data, pad_with_new_lines = false)
+        puts if pad_with_new_lines
+
+        col_widths = calculate_col_widths(data)
+        print_table_header data, col_widths
+
+        (1..data.length - 1).each do |i|
+          print_table_row(data[i], col_widths)
+          puts
+        end
+
+        puts if pad_with_new_lines
+      end
+
+      def print_table_header(data, col_widths)
+        print_table_row data[0], col_widths
+        puts
+        print_header_separator col_widths
+        puts
+      end
+
+      def calculate_col_widths(data)
+        widths = {}
+        data.each do |row|
+          row.keys.each do |col|
+            if widths[col].nil? || row[col].to_s.length > widths[col]
+              widths[col] = row[col].to_s.length
+            end
+          end
+        end
+        widths
+      end
+
+      def print_header_separator(widths)
+        separators = {}
+        widths.keys.each do |col|
+          separators[col] = '-' * widths[col]
+        end
+
+        print_table_row(separators, widths)
+      end
+
+      def print_table_row(data, widths)
+        print indent * indent_level
+        data.keys.each do |col|
+          padding = widths[col] - data[col].to_s.length
+          print "#{data[col]}#{' ' * padding}   "
+        end
+      end
+
+      attr_accessor :indent
+      attr_accessor :indent_level
+    end
+  end
+end