pwn 0.4.333

data/lib/pwn/plugins/ssn.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module PWN
+  module Plugins
+    # This plugin provides useful social security number capabilities
+    module SSN
+      # Supported Method Parameters::
+      # PWN::Plugins::SSN.generate(
+      #   count: 'required - number of SSN numbers to generate'
+      # )
+
+      public_class_method def self.generate(opts = {})
+        count = opts[:count].to_i
+
+        # Based upon new SSN Randomization:
+        # https://www.ssa.gov/employer/randomization.html
+        ssn_result_arr = []
+        (1..count).each do
+          this_area = format('%0.3d', Random.rand(1..999))
+          this_group = format('%0.2d', Random.rand(1..99))
+          this_serial = format('%0.4d', Random.rand(1..9999))
+          this_ssn = "#{this_area}-#{this_group}-#{this_serial}"
+          ssn_result_arr.push(this_ssn)
+        end
+
+        ssn_result_arr
+      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}.generate(
+            count: 'required - number of SSN numbers to generate'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/thread_pool.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PWN
+  module Plugins
+    # This plugin makes the creation of a thread pool much simpler.
+    module ThreadPool
+      # Supported Method Parameters::
+      # PWN::Plugins::ThreadPool.fill(
+      #   enumerable_array: 'required array for proper thread pool assignment',
+      #   :max_threads: 'optional number of threads in the thread pool (defaults to 9)',
+      #   &block
+      # )
+      #
+      # Example:
+      # arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      # PWN::Plugins::ThreadPool.fill(enumerable_array: arr, max_threads: 9) do |integer|
+      #   puts integer
+      # end
+
+      public_class_method def self.fill(opts = {})
+        enumerable_array = opts[:enumerable_array]
+        opts[:max_threads].nil? ? max_threads = 9 : max_threads = opts[:max_threads].to_i
+
+        puts "Initiating Thread Pool of #{max_threads} Worker Threads...."
+        queue = SizedQueue.new(max_threads)
+        threads = Array.new(max_threads) do
+          Thread.new do
+            until (this_thread = queue.pop) == :END
+              yield this_thread
+            end
+          end
+        end
+        enumerable_array.uniq.sort.each { |this_thread| queue << this_thread }
+        max_threads.times { queue << :END }
+        threads.each(&:join)
+      rescue Interrupt
+        puts "\nGoodbye."
+      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}.fill(
+            enumerable_array. => 'required array for proper thread pool assignment',
+            max_threads: 'optional number of threads in the thread pool (defaults to 9)',
+            &block
+          )
+
+          Example:
+          arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+          #{self}.fill(enumerable_array: arr, max_threads: 9) do |integer|
+            puts integer
+          end
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/transparent_browser.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+require 'watir'
+require 'rest-client'
+require 'socksify'
+require 'em/pure_ruby'
+require 'faye/websocket'
+
+module PWN
+  module Plugins
+    # This plugin rocks. Chrome, Firefox, PhantomJS, IE, REST Client,
+    # all from the comfort of one plugin.  Proxy support (e.g. Burp
+    # Suite Professional) is completely available for all browsers
+    # except for limited functionality within IE (IE has interesting
+    # protections in place to prevent this).  This plugin also supports
+    # taking screenshots :)
+    module TransparentBrowser
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # browser_obj1 = PWN::Plugins::TransparentBrowser.open(
+      #   browser_type: :firefox|:chrome|:headless|:rest|:websocket,
+      #   proxy: 'optional - scheme://proxy_host:port',
+      #   with_tor: 'optional - boolean (defaults to false)'
+      #   with_devtools: 'optional - boolean (defaults to false)'
+      # )
+
+      public_class_method def self.open(opts = {})
+        this_browser = nil
+        browser_type = opts[:browser_type]
+        proxy = opts[:proxy].to_s unless opts[:proxy].nil?
+        opts[:with_tor] ? (with_tor = true) : (with_tor = false)
+        opts[:with_devtools] ? (with_devtools = true) : (with_devtools = false)
+
+        # Let's crank up the default timeout from 30 seconds to 15 min for slow sites
+        Watir.default_timeout = 900
+
+        case browser_type
+        when :firefox
+          this_profile = Selenium::WebDriver::Firefox::Profile.new
+
+          # Increase Web Assembly Verbosity
+          this_profile['javascript.options.wasm_verbose'] = true
+
+          # Downloads reside in ~/Downloads
+          this_profile['browser.download.folderList'] = 1
+          this_profile['browser.helperApps.neverAsk.saveToDisk'] = 'application/pdf'
+
+          # disable Firefox's built-in PDF viewer
+          this_profile['pdfjs.disabled'] = true
+
+          # disable Adobe Acrobat PDF preview plugin
+          this_profile['plugin.scan.plid.all'] = false
+          this_profile['plugin.scan.Acrobat'] = '99.0'
+
+          # ensure localhost proxy capabilities are enabled
+          this_profile['network.proxy.no_proxies_on'] = ''
+
+          # allow scripts to run a bit longer
+          # this_profile['dom.max_chrome_script_run_time'] = 180
+          # this_profile['dom.max_script_run_time'] = 180
+
+          # disable browser cache
+          this_profile['browser.cache.disk.enable'] = false
+          this_profile['browser.cache.disk_cache_ssl.enable'] = false
+          this_profile['browser.cache.memory.enable'] = false
+          this_profile['browser.cache.offline.enable'] = false
+          this_profile['devtools.cache.disabled'] = true
+          this_profile['dom.caches.enabled'] = false
+
+          # caps = Selenium::WebDriver::Remote::Capabilities.firefox
+          # caps[:acceptInsecureCerts] = true
+
+          if proxy
+            this_profile['network.proxy.type'] = 1
+            this_profile['network.proxy.allow_hijacking_localhost'] = true
+            if with_tor
+              this_profile['network.proxy.socks_version'] = 5
+              this_profile['network.proxy.socks'] = URI(proxy).host
+              this_profile['network.proxy.socks_port'] = URI(proxy).port
+            else
+              this_profile['network.proxy.ftp'] = URI(proxy).host
+              this_profile['network.proxy.ftp_port'] = URI(proxy).port
+              this_profile['network.proxy.http'] = URI(proxy).host
+              this_profile['network.proxy.http_port'] = URI(proxy).port
+              this_profile['network.proxy.ssl'] = URI(proxy).host
+              this_profile['network.proxy.ssl_port'] = URI(proxy).port
+            end
+          end
+
+          args = []
+
+          args.push('--devtools') if with_devtools
+          options = Selenium::WebDriver::Firefox::Options.new(args: args, accept_insecure_certs: true)
+          options.profile = this_profile
+          driver = Selenium::WebDriver.for(:firefox, capabilities: options)
+          this_browser = Watir::Browser.new(driver)
+
+        when :chrome
+          this_profile = Selenium::WebDriver::Chrome::Profile.new
+          this_profile['download.prompt_for_download'] = false
+          this_profile['download.default_directory'] = '~/Downloads'
+
+          switches = []
+          if proxy
+            switches.push("--host-resolver-rules='MAP * 0.0.0.0 , EXCLUDE #{URI(proxy).host}'") if with_tor
+            switches.push("--proxy-server=#{proxy}")
+          end
+
+          if with_devtools
+            switches.push('--auto-open-devtools-for-tabs')
+            switches.push('--disable-hang-monitor')
+          end
+
+          options = Selenium::WebDriver::Chrome::Options.new(
+            args: switches,
+            accept_insecure_certs: true
+          )
+
+          options.profile = this_profile
+          driver = Selenium::WebDriver.for(:chrome, capabilities: options)
+          this_browser = Watir::Browser.new(driver)
+
+        when :headless, :headless_firefox
+          this_profile = Selenium::WebDriver::Firefox::Profile.new
+
+          # Increase Web Assembly Verbosity
+          this_profile['javascript.options.wasm_verbose'] = true
+
+          # Downloads reside in ~/Downloads
+          this_profile['browser.download.folderList'] = 1
+          this_profile['browser.helperApps.neverAsk.saveToDisk'] = 'application/pdf'
+
+          # disable Firefox's built-in PDF viewer
+          this_profile['pdfjs.disabled'] = true
+
+          # disable Adobe Acrobat PDF preview plugin
+          this_profile['plugin.scan.plid.all'] = false
+          this_profile['plugin.scan.Acrobat'] = '99.0'
+
+          # ensure localhost proxy capabilities are enabled
+          this_profile['network.proxy.no_proxies_on'] = ''
+
+          # allow scripts to run a bit longer
+          # this_profile['dom.max_chrome_script_run_time'] = 180
+          # this_profile['dom.max_script_run_time'] = 180
+
+          # disable browser cache
+          this_profile['browser.cache.disk.enable'] = false
+          this_profile['browser.cache.disk_cache_ssl.enable'] = false
+          this_profile['browser.cache.memory.enable'] = false
+          this_profile['browser.cache.offline.enable'] = false
+          this_profile['devtools.cache.disabled'] = true
+          this_profile['dom.caches.enabled'] = false
+
+          # caps = Selenium::WebDriver::Remote::Capabilities.firefox
+          # caps[:acceptInsecureCerts] = true
+
+          if proxy
+            this_profile['network.proxy.type'] = 1
+            this_profile['network.proxy.allow_hijacking_localhost'] = true
+            if with_tor
+              this_profile['network.proxy.socks_version'] = 5
+              this_profile['network.proxy.socks'] = URI(proxy).host
+              this_profile['network.proxy.socks_port'] = URI(proxy).port
+            else
+              this_profile['network.proxy.ftp'] = URI(proxy).host
+              this_profile['network.proxy.ftp_port'] = URI(proxy).port
+              this_profile['network.proxy.http'] = URI(proxy).host
+              this_profile['network.proxy.http_port'] = URI(proxy).port
+              this_profile['network.proxy.ssl'] = URI(proxy).host
+              this_profile['network.proxy.ssl_port'] = URI(proxy).port
+            end
+          end
+
+          options = Selenium::WebDriver::Firefox::Options.new(args: ['-headless'], accept_insecure_certs: true)
+          options.profile = this_profile
+          driver = Selenium::WebDriver.for(:firefox, capabilities: options)
+          this_browser = Watir::Browser.new(driver)
+
+        when :headless_chrome
+          this_profile = Selenium::WebDriver::Chrome::Profile.new
+          this_profile['download.prompt_for_download'] = false
+          this_profile['download.default_directory'] = '~/Downloads'
+
+          switches = []
+          switches.push('-headless')
+          if proxy
+            switches.push("--host-resolver-rules='MAP * 0.0.0.0 , EXCLUDE #{URI(proxy).host}'") if with_tor
+            switches.push("--proxy-server=#{proxy}")
+          end
+
+          options = Selenium::WebDriver::Chrome::Options.new(
+            args: switches,
+            accept_insecure_certs: true
+          )
+
+          options.profile = this_profile
+          driver = Selenium::WebDriver.for(:chrome, capabilities: options)
+          this_browser = Watir::Browser.new(driver)
+
+        when :rest
+          this_browser = RestClient
+          if proxy
+            if with_tor
+              TCPSocket.socks_server = URI(proxy).host
+              TCPSocket.socks_port = URI(proxy).port
+            else
+              this_browser.proxy = proxy
+            end
+          end
+
+        when :websocket
+          if proxy
+            if with_tor
+              TCPSocket.socks_server = URI(proxy).host
+              TCPSocket.socks_port = URI(proxy).port
+            end
+            proxy_opts = { origin: proxy }
+            tls_opts = { verify_peer: false }
+            this_browser = Faye::WebSocket::Client.new(
+              '',
+              [],
+              {
+                tls: tls_opts,
+                proxy: proxy_opts
+              }
+            )
+          else
+            this_browser = Faye::WebSocket::Client.new('')
+          end
+        else
+          puts 'Error: browser_type only supports :firefox, :chrome, :headless, :rest, or :websocket'
+          return nil
+        end
+
+        this_browser
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # browser_obj = PWN::Plugins::TransparentBrowser.linkout(
+      #   browser_obj: browser_obj1
+      # )
+
+      public_class_method def self.linkout(opts = {})
+        this_browser_obj = opts[:browser_obj]
+
+        this_browser_obj.links.each do |link|
+          @@logger.info("#{link.text} => #{link.href}\n\n\n") unless link.text == ''
+        end
+
+        this_browser_obj
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::TransparentBrowser.type_as_human(
+      #   q: 'required - query string to randomize',
+      #   rand_sleep_float: 'optional - float timing in between keypress (defaults to 0.09)'
+      # )
+
+      public_class_method def self.type_as_human(opts = {})
+        query_string = opts[:q].to_s
+
+        rand_sleep_float = if opts[:rand_sleep_float]
+                             opts[:rand_sleep_float].to_f
+                           else
+                             0.09
+                           end
+
+        query_string.each_char do |char|
+          yield char
+          sleep Random.rand(rand_sleep_float)
+        end
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # browser_obj1 = PWN::Plugins::TransparentBrowser.close(
+      #   browser_obj: 'required - browser_obj returned from #open method)'
+      # )
+
+      public_class_method def self.close(opts = {})
+        this_browser_obj = opts[:browser_obj]
+
+        unless this_browser_obj.to_s.include?('RestClient')
+          # Close the browser unless this_browser_obj.nil? (thus the &)
+          this_browser_obj&.close
+        end
+        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:
+          browser_obj1 = #{self}.open(
+            browser_type: :firefox|:chrome|:headless_chrome|:headless_firefox|:rest|:websocket,
+            proxy: 'optional scheme://proxy_host:port',
+            with_tor: 'optional boolean (defaults to false)',
+            with_devtools: 'optional - boolean (defaults to false)'
+          )
+          puts browser_obj1.public_methods
+
+          browser_obj1 = #{self}.linkout(
+            browser_obj: 'required - browser_obj returned from #open method)'
+          )
+
+          #{self}.type_as_human(
+            q: 'required - query string to randomize',
+            rand_sleep_float: 'optional - float timing in between keypress (defaults to 0.09)'
+          ) {|char| browser_obj1.text_field(name: \"q\").send_keys(char) }
+
+          browser_obj1 = #{self}.close(
+            browser_obj: 'required - browser_obj returned from #open method)'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/twitter_api.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+
+module PWN
+  module Plugins
+    # This plugin converts images to readable text
+    # TODO: Convert all rest requests to POST instead of GET
+    module TwitterAPI
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # bearer_token = PWN::Plugins::TwitterAPI.app_only_login(
+      #   consumer_key: 'required - consumer key for app-only authentication',
+      #   consumer_secret: 'optional - consumer secret (will prompt if nil)'
+      # )
+
+      public_class_method def self.app_only_login(opts = {})
+        base_api_uri = 'https://api.twitter.com'
+
+        consumer_key = opts[:consumer_key].to_s.strip.chomp.scrub
+        consumer_secret = if opts[:consumer_secret].nil?
+                            PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Consumer Secret')
+                          else
+                            opts[:consumer_secret].to_s.chomp.strip.scrub
+                          end
+
+        authz_str = Base64.strict_encode64("#{consumer_key}:#{consumer_secret}")
+        http_headers = {}
+        http_headers[:content_type] = 'application/x-www-form-urlencoded;charset=UTF-8'
+        http_headers[:authorization] = "Basic #{authz_str}"
+
+        @@logger.info("Logging into TwitterAPI REST API: #{base_api_uri}")
+        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
+        response = rest_client.execute(
+          method: :post,
+          url: "#{base_api_uri}/oauth2/token",
+          headers: http_headers,
+          payload: 'grant_type=client_credentials'
+        )
+
+        # Return array containing the post-authenticated TwitterAPI REST API token
+        json_response = JSON.parse(response, symbolize_names: true)
+        json_response[:access_token]
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # twitter_rest_call(
+      #   bearer_token: 'required bearer_token returned from #app_only_login method',
+      #   rest_call: 'required rest call to make per the schema',
+      #   http_method: 'optional HTTP method (defaults to GET)
+      #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST'
+      # )
+
+      private_class_method def self.twitter_rest_call(opts = {})
+        bearer_token = opts[:bearer_token]
+        rest_call = opts[:rest_call].to_s.scrub
+        http_method = if opts[:http_method].nil?
+                        :get
+                      else
+                        opts[:http_method].to_s.scrub.to_sym
+                      end
+        params = opts[:params]
+        http_body = opts[:http_body].to_s.scrub
+        host = bearer_token[:host]
+        port = bearer_token[:port]
+        base_zap_api_uri = "http://#{host}:#{port}"
+
+        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
+
+        case http_method
+        when :get
+          response = rest_client.execute(
+            method: :get,
+            url: "#{base_zap_api_uri}/#{rest_call}",
+            headers: {
+              params: params
+            },
+            verify_ssl: false
+          )
+
+        when :post
+          response = rest_client.execute(
+            method: :post,
+            url: "#{base_zap_api_uri}/#{rest_call}",
+            headers: {
+              content_type: 'application/json; charset=UTF-8'
+            },
+            payload: http_body,
+            verify_ssl: false
+          )
+
+        else
+          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
+        end
+
+        sleep 3
+
+        response
+      rescue StandardError, SystemExit, Interrupt => e
+        logout(bearer_token) unless bearer_token.nil?
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::TwitterAPI.logout(
+      #   bearer_token: 'required bearer_token returned from #app_only_login method'
+      # )
+
+      public_class_method def self.app_only_logout(opts = {})
+        bearer_token = opts[:bearer_token]
+        @@logger.info('Logging out...')
+        # TODO: Terminate Session if Possible via API Call
+        bearer_token = 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:
+          bearer_token = #{self}.app_only_login(
+            consumer_key: 'required - consumer key for app-only authentication',
+            consumer_secret: 'optional - consumer secret (will prompt if nil)'
+          )
+
+          #{self}.app_only_logout(
+            bearer_token: 'required bearer_token returned from #app_only_login method'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end