pwn 0.4.333

data/lib/pwn/plugins/ansible_vault.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'yaml'
+module PWN
+  module Plugins
+    # Used to encrypt/decrypt configuration files leveraging AES256
+    # (ansible-vault utility wrapper)
+    module AnsibleVault
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # PWN::Plugins::AnsibleVault.encrypt(
+      #   yaml_config: 'required - yaml config to encrypt',
+      #   vpassfile: 'required - path to anisble-vault pass file'
+      # )
+
+      public_class_method def self.encrypt(opts = {})
+        yaml_config = opts[:yaml_config].to_s.scrub if File.exist?(opts[:yaml_config].to_s.scrub)
+        vpassfile = opts[:vpassfile].to_s.scrub if File.exist?(opts[:vpassfile].to_s.scrub)
+
+        `sudo ansible-vault encrypt #{yaml_config} --vault-password-file #{vpassfile}`
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::AnsibleVault.decrypt(
+      #   yaml_config: 'required - yaml config to decrypt',
+      #   vpassfile: 'required - path to anisble-vault pass file'
+      # )
+
+      public_class_method def self.decrypt(opts = {})
+        yaml_config = opts[:yaml_config].to_s.scrub if File.exist?(opts[:yaml_config].to_s.scrub)
+        vpassfile = opts[:vpassfile].to_s.scrub if File.exist?(opts[:vpassfile].to_s.scrub)
+
+        if File.extname(yaml_config) == '.yaml'
+          config_resp = YAML.safe_load(`sudo ansible-vault view #{yaml_config} --vault-password-file #{vpassfile}`)
+        else
+          config_resp = `sudo ansible-vault view #{yaml_config} --vault-password-file #{vpassfile}`
+        end
+
+        config_resp
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+
+          #{self}.encrypt(
+            yaml_config: 'required - yaml config to encrypt',
+            vpassfile: 'required - path to anisble-vault pass file'
+          )
+
+          #{self}.decrypt(
+            yaml_config: 'required - yaml config to decrypt',
+            vpassfile: 'required - path to anisble-vault pass file'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/authentication_helper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+
+module PWN
+  module Plugins
+    # This plugin is used to assist in masking a password when entered in via
+    # STDIN to prevent would-be shoulder surfers from obtaining password
+    # information.  This plugin is useful when demonstrating the functionality
+    # of other SP plugins/modules.
+    module AuthenticationHelper
+      # Supported Method Parameters::
+      # PWN::Plugins::AuthenticationHelper.username
+
+      public_class_method def self.username
+        user = TTY::Prompt.new.ask('Username: ')
+        user.to_s.strip.chomp.scrub
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::AuthenticationHelper.mask_password(
+      #   prompt: 'optional - string to display at prompt'
+      # )
+
+      public_class_method def self.mask_password(opts = {})
+        opts[:prompt].nil? ? prompt = 'Password' : prompt = opts[:prompt].to_s.scrub.strip.chomp
+
+        pass = TTY::Prompt.new.mask("#{prompt}: ")
+        pass.to_s.strip.chomp.scrub
+      rescue Interrupt
+        puts 'CTRL+C detected...goodbye.'
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::AuthenticationHelper.mfa(
+      #   prompt: 'optional - string to display at prompt'
+      # )
+
+      public_class_method def self.mfa(opts = {})
+        opts[:prompt].nil? ? prompt = 'MFA Token' : prompt = opts[:prompt].to_s.scrub.strip.chomp
+
+        mfa = TTY::Prompt.new.ask("#{prompt}: ")
+        mfa.to_s.strip.chomp.scrub
+      rescue Interrupt
+        puts 'CTRL+C detected...goodbye.'
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.username
+
+          #{self}.mask_password
+
+          #{self}.mfa(
+            prompt: 'optional - string to display at prompt'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/basic_auth.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module PWN
+  module Plugins
+    # This plugin Base64 encodes/decodes AuthN credentials for passing to a ''Basic''
+    # authorization HTTP header.
+    module BasicAuth
+      # Supported Method Parameters::
+      # PWN::Plugins::BasicAuth.encode(
+      #   username: 'optional username',
+      #   password: 'optional password'
+      # )
+
+      public_class_method def self.encode(opts = {})
+        basic_user = opts[:username].to_s.chomp unless opts[:username].nil?
+        basic_pass = opts[:password].to_s.chomp unless opts[:password].nil?
+        base64_str = "#{basic_user}:#{basic_pass}"
+        @base64_encoded_auth = Base64.strict_encode64(base64_str).to_s.chomp
+        @base64_encoded_auth
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::BasicAuth.decode(
+      #   base64_str: 'required base64 encoded string'
+      # )
+
+      public_class_method def self.decode(opts = {})
+        base64_str = opts[:base64_str]
+        @base64_decoded_auth = Base64.decode64(base64_str)
+        @base64_decoded_auth
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          #{self}.encode(
+            username: 'optional username',
+            password: 'optional password'
+          )
+
+          #{self}.decode(base64_str: 'base64 encoded string')
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/beef.rb

@@ -0,0 +1,309 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module Plugins
+    # This plugin is used for interacting w/ BeEF's REST API using
+    # the 'rest' browser type of PWN::Plugins::TransparentBrowser.
+    module BeEF
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # beef_obj = PWN::Plugins::BeEF.login(
+      #   beef_ip: 'required - host/ip of BeEF Server',
+      #   beef_port: 'optional - port of BeEF server (defaults to 3000)',
+      #   username: 'required - username',
+      #   password: 'optional - password (will prompt if nil)'
+      # )
+
+      public_class_method def self.login(opts = {})
+        beef_ip = opts[:beef_ip]
+        beef_port = if opts[:beef_port]
+                      opts[:beef_port].to_i
+                    else
+                      3000
+                    end
+
+        username = opts[:username].to_s.scrub
+        base_beef_api_uri = "http://#{beef_ip}:#{beef_port}/api".to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        auth_payload = {}
+        auth_payload[:username] = username
+        auth_payload[:password] = password
+
+        @@logger.info("Logging into BeEF REST API: #{beef_ip}")
+        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
+        response = rest_client.execute(
+          method: :post,
+          url: "#{base_beef_api_uri}/admin/login",
+          payload: auth_payload.to_json
+        )
+
+        # Return array containing the post-authenticated BeEF REST API token
+        json_response = JSON.parse(response)
+        beef_success = json_response['success']
+        api_token = json_response['token']
+        beef_obj = {}
+        beef_obj[:beef_ip] = beef_ip
+        beef_obj[:beef_port] = beef_port
+        beef_obj[:beef_success] = beef_success
+        beef_obj[:api_token] = api_token
+        beef_obj[:raw_response] = response
+
+        beef_obj
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # beef_rest_call(
+      #   beef_obj: 'required beef_obj returned from #login method',
+      #   http_method: 'optional HTTP method (defaults to GET)
+      #   rest_call: 'required rest call to make per the schema',
+      #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST'
+      # )
+
+      private_class_method def self.beef_rest_call(opts = {})
+        beef_obj = opts[:beef_obj]
+        http_method = if opts[:http_method].nil?
+                        :get
+                      else
+                        opts[:http_method].to_s.scrub.to_sym
+                      end
+        rest_call = opts[:rest_call].to_s.scrub
+        http_body = opts[:http_body].to_s.scrub
+        beef_success = beef_obj[:beef_success].to_s.scrub
+        beef_ip = beef_obj[:beef_ip].to_s.scrub
+        beef_port = beef_obj[:beef_port].to_i
+        base_beef_api_uri = "http://#{beef_ip}:#{beef_port}/api".to_s.scrub
+        api_token = beef_obj[:api_token]
+
+        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
+
+        case http_method
+        when :get
+          response = rest_client.execute(
+            method: :get,
+            url: "#{base_beef_api_uri}/#{rest_call}",
+            headers: {
+              content_type: 'application/json; charset=UTF-8',
+              params: { token: api_token }
+            }
+          )
+
+        when :post
+          response = rest_client.execute(
+            method: :post,
+            url: "#{base_beef_api_uri}/#{rest_call}",
+            headers: {
+              content_type: 'application/json; charset=UTF-8'
+            },
+            payload: http_body
+          )
+
+        else
+          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
+        end
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # hooks = PWN::Plugins::BeEF.hooks(
+      #   beef_obj: 'required beef_obj returned from #login method'
+      # )
+
+      public_class_method def self.hooks(opts = {})
+        beef_obj = opts[:beef_obj]
+        @@logger.info('Retrieving BeEF Hooks...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: 'hooks'
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # hooked_browser_info = PWN::Plugins::BeEF.hooked_browser_info(
+      #   beef_obj: 'required beef_obj returned from #login method',
+      #   browser_session: 'required - browser session id returned from #hooks method'
+      # )
+
+      public_class_method def self.hooked_browser_info(opts = {})
+        beef_obj = opts[:beef_obj]
+        browser_session = opts[:browser_session].to_s.scrub
+
+        @@logger.info('Retrieving Browser Info...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: "hooks/#{browser_session}"
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # logs = PWN::Plugins::BeEF.logs(
+      #   beef_obj: 'required beef_obj returned from #login method'
+      # )
+
+      public_class_method def self.logs(opts = {})
+        beef_obj = opts[:beef_obj]
+        @@logger.info('Retrieving BeEF Logs...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: 'logs'
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # hooked_browser_logs = PWN::Plugins::BeEF.hooked_browser_logs(
+      #   beef_obj: 'required beef_obj returned from #login method',
+      #   browser_session: 'required - browser session id returned from #hooks method'
+      # )
+
+      public_class_method def self.hooked_browser_logs(opts = {})
+        beef_obj = opts[:beef_obj]
+        browser_session = opts[:browser_session].to_s.scrub
+
+        @@logger.info('Retrieving Browser Logs...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: "logs/#{browser_session}"
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # modules = PWN::Plugins::BeEF.modules(
+      #   beef_obj: 'required beef_obj returned from #login method'
+      # )
+
+      public_class_method def self.modules(opts = {})
+        beef_obj = opts[:beef_obj]
+        @@logger.info('Retrieving BeEF Modules...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: 'modules'
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # module_info = PWN::Plugins::BeEF.module_info(
+      #   beef_obj: 'required beef_obj returned from #login method',
+      #   module_id: 'required - module id returned from #modules method'
+      # )
+
+      public_class_method def self.module_info(opts = {})
+        beef_obj = opts[:beef_obj]
+        module_id = opts[:module_id].to_i
+
+        @@logger.info('Retrieving Module Info...')
+
+        response = beef_rest_call(
+          beef_obj: beef_obj,
+          rest_call: "modules/#{module_id}"
+        )
+
+        JSON.parse(response)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::BeEF.logout(
+      #   beef_obj: 'required beef_obj returned from #login method'
+      # )
+
+      public_class_method def self.logout(opts = {})
+        beef_obj = opts[:beef_obj]
+        @@logger.info('Logging out...')
+        beef_obj = nil
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: Jacob Hoopes <jake.hoopes@gmail.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          Jacob Hoopes <jake.hoopes@gmail.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          beef_obj = #{self}.login(
+            beef_ip: 'required host/ip of Nexpose Console (server)',
+            beef_port: 'optional - port of BeEF server (defaults to 3000)',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          hooks = #{self}.hooks(
+            beef_obj: 'required beef_obj returned from #login method'
+          )
+
+          hooked_browser_info = #{self}.hooked_browser_info(
+            beef_obj: 'required beef_obj returned from #login method',
+            browser_session: 'required - browser session id returned from #hooks method'
+          )
+
+          logs = #{self}.logs(
+            beef_obj: 'required beef_obj returned from #login method'
+          )
+
+          hooked_browser_logs = #{self}.hooked_browser_logs(
+            beef_obj: 'required beef_obj returned from #login method',
+            browser_session: 'required - browser session id returned from #hooks method'
+          )
+
+          modules = #{self}.modules(
+            beef_obj: 'required beef_obj returned from #login method'
+          )
+
+          module_info = #{self}.module_info(
+            beef_obj: 'required beef_obj returned from #login method',
+            module_id: 'required - module id returned from #modules method'
+          )
+
+          beef_obj = #{self}.logout(
+            beef_obj: 'required beef_obj returned from #login method'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end