pwn 0.5.708 → 0.5.709

data/lib/pwn/plugins/shodan.rb

@@ -538,91 +538,110 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          services_by_ips = #{self}.services_by_ips(
-            api_key: 'required - shodan api key',
+          # Run services by ips and return its result
+          #{self}.services_by_ips(
+            api_key: 'required - required shodan api key',
             target_ips: 'required - comma-delimited list of ip addresses to target'
           )
 
-          query_result_totals = PWN::Plugins::Shodan.query_result_totals(
-            api_key: 'required shodan api key',
+          # Run query result totals and return its result
+          #{self}.query_result_totals(
+            api_key: 'required - required shodan api key',
             query: 'required - shodan search query',
             facets: 'optional - comma-separated list of properties to get summary information'
           )
 
-          search_results = #{self}.search(
-            api_key: 'required shodan api key',
+          # Run a search using the open session.
+          #{self}.search(
+            api_key: 'required - required shodan api key',
             query: 'required - shodan search query',
             facets: 'optional - comma-separated list of properties to get summary information'
           )
 
-          tokens_result = #{self}.tokens(
-            api_key: 'required shodan api key',
-            query: 'required - shodan search query',
+          # Run tokens and return its result
+          #{self}.tokens(
+            api_key: 'required - required shodan api key',
+            query: 'required - shodan search query'
           )
 
-          ports_shodan_crawls = #{self}.ports_shodan_crawls(
-            api_key: 'required shodan api key'
+          # Run ports shodan crawls and return its result
+          #{self}.ports_shodan_crawls(
+            api_key: 'required - required shodan api key'
           )
 
-          protocols = #{self}.list_on_demand_scan_protocols(
-            api_key: 'required shodan api key'
+          # Run list on demand scan protocols and return its result
+          #{self}.list_on_demand_scan_protocols(
+            api_key: 'required - required shodan api key'
           )
 
-          scan_network_response = #{self}.scan_network(
-            api_key: 'required shodan api key',
+          # Run scan network and return its result
+          #{self}.scan_network(
+            api_key: 'required - required shodan api key',
             target_ips: 'required - comma-delimited list of ip addresses to target'
           )
 
-          scan_internet_response = #{self}.scan_internet(
-            api_key: 'required shodan api key',
+          # Run scan internet and return its result
+          #{self}.scan_internet(
+            api_key: 'required - required shodan api key',
             port: 'required - port to scan (see #ports_shodan_crawls for list)',
             protocol: 'required - supported shodan protocol (see #list_on_demand_scan_protocols for list)'
           )
 
-          scan_status_result = #{self}.scan_status(
-            api_key: 'required shodan api key',
-            scan_id: 'required - unique ID returned by #scan_network',
+          # Run scan status and return its result
+          #{self}.scan_status(
+            api_key: 'required - required shodan api key',
+            scan_id: 'required - unique ID returned by #scan_network'
           )
 
-          services_shodan_crawls = #{self}.services_shodan_crawls(
-            api_key: 'required shodan api key'
+          # Run services shodan crawls and return its result
+          #{self}.services_shodan_crawls(
+            api_key: 'required - required shodan api key'
           )
 
-          saved_search_queries_result = #{self}.saved_search_queries(
-            api_key: 'required shodan api key',
+          # Run saved search queries and return its result
+          #{self}.saved_search_queries(
+            api_key: 'required - required shodan api key',
             page: 'optional - page number to iterate over results (each page contains 10 items)',
             sort: 'optional - sort results by available parameters :votes|:timestamp',
             order: 'optional - sort :asc|:desc (ascending or descending)'
           )
 
-          most_popular_tags_result = #{self}.most_popular_tags(
-            api_key: 'required shodan api key',
+          # Run most popular tags and return its result
+          #{self}.most_popular_tags(
+            api_key: 'required - required shodan api key',
             result_count: 'optional - number of results to return (defaults to 10)'
           )
 
-          my_profile = #{self}.my_profile(
-            api_key: 'required shodan api key'
+          # Run my profile and return its result
+          #{self}.my_profile(
+            api_key: 'required - required shodan api key'
           )
 
-          my_pub_ip = #{self}.my_pub_ip(
-            api_key: 'required shodan api key'
+          # Run my pub ip and return its result
+          #{self}.my_pub_ip(
+            api_key: 'required - required shodan api key'
           )
 
-          api_info = #{self}.api_info(
-            api_key: 'required shodan api key'
+          # Run api info and return its result
+          #{self}.api_info(
+            api_key: 'required - required shodan api key'
           )
 
-          honeypot_probability_scores = #{self}.honeypot_probability_scores(
-            api_key: 'required shodan api key',
+          # Run honeypot probability scores and return its result
+          #{self}.honeypot_probability_scores(
+            api_key: 'required - required shodan api key',
             target_ips: 'required - comma-delimited list of ip addresses to target'
           )
 
-          uri_arr = #{self}.get_uris(
+          # Run get uris and return its result
+          #{self}.get_uris(
             search_results: 'required - search_results object returned from #search method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/slack_client.rb

@@ -82,22 +82,27 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          slack_obj = #{self}.login(
-            api_token: 'optional slack api token (will prompt if blank)'
+          # Run login and return its result
+          #{self}.login(
+            api_token: 'required - required slack api token'
           )
 
+          # Run post message and return its result
           #{self}.post_message(
-            slack_obj: 'required slack_obj returned from login method',
-            channel: 'required #channel to post message',
-            message: 'required message to post'
+            slack_obj: 'required - required slack_obj returned from login method',
+            channel: 'required - required #channel to post message',
+            message: 'required - required message to post'
           )
 
+          # Run logout and return its result
           #{self}.logout(
-            slack_obj: 'required slack_obj returned from login method'
+            slack_obj: 'required - required slack_obj returned from login method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/sock.rb

@@ -319,43 +319,51 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          sock_obj = #{self}.connect(
+          # Run connect and return its result
+          #{self}.connect(
             target: 'required - target host or ip',
             port: 'required - target port',
-            protocol: 'optional - :tcp || :udp (defaults to tcp)',
+            protocol: 'optional - :tcp || :udp (defaults to :tcp)',
             tls: 'optional - boolean connect to target socket using TLS (defaults to false)'
           )
 
-          port = #{self}.get_random_unused_port(
+          # Run get random unused port and return its result
+          #{self}.get_random_unused_port(
             server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
             protocol: 'optional - :tcp || :udp (defaults to tcp)'
           )
 
+          # Run check port in use and return its result
           #{self}.check_port_in_use(
-            server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
             port: 'required - target port',
+            server_ip: 'optional - target host or ip to check (Defaults to 127.0.0.1)',
             protocol: 'optional - :tcp || :udp (defaults to tcp)'
           )
 
-          listen_obj = #{self}.listen(
+          # Run listen and return its result
+          #{self}.listen(
             port: 'required - target port',
-            server_ip: 'optional - target host or ip to listen (Defaults to 127.0.0.1')',
+            server_ip: 'optional - target host or ip to listen (Defaults to 127.0.0.1)',
             protocol: 'optional - :tcp || :udp (defaults to tcp)',
             tls: 'optional - boolean listen on TLS-enabled socket (defaults to false)',
             detach: 'optional - boolean to detach listener to background (defaults to false)'
           )
 
-          cert_obj = #{self}.get_tls_cert(
+          # Run get tls cert and return its result
+          #{self}.get_tls_cert(
             target: 'required - target host or ip',
             port: 'optional - target port (defaults to 443)'
           )
 
-          sock_obj = #{self}.disconnect(
+          # Run disconnect and return its result
+          #{self}.disconnect(
             sock_obj: 'required - sock_obj returned from #connect method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/spider.rb

@@ -63,15 +63,18 @@ module PWN
       # Display Usage for this Module
 
       public_class_method def self.help
-        puts %{USAGE:
+        puts "USAGE:
+          # Run crawl and return its result
           #{self}.crawl(
             target_fqdn: 'required - target fqdn to spider',
             results_path: 'required - path to save spider results',
             proxy: 'optional - proxy to spider through e.g. http://127.0.0.1:8080'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
-        }
+        "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/sqlmap.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PWN
+  module Plugins
+    # sqlmap wrapper to pair with SAST SQL detection.
+    module Sqlmap
+      public_class_method def self.required_bins
+        %w[sqlmap]
+      end
+
+      public_class_method def self.run(opts = {})
+        PWN::Plugins::Doctor.require_bin!(name: 'sqlmap')
+        url = opts[:url].to_s
+        raise 'ERROR: url is required' if url.empty?
+
+        cmd = ['sqlmap', '-u', url, '--batch', '--level', (opts[:level] || 1).to_s]
+        cmd += ['--data', opts[:data].to_s] if opts[:data]
+        cmd << '--dbs' if opts[:dbs]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.authors
+        "AUTHOR(S):\n  0day Inc. <support@0dayinc.com>\n"
+      end
+
+      public_class_method def self.help
+        puts "USAGE:
+          # List host binaries this module expects to be installed.
+          #{self}.required_bins
+
+          # Run run and return its result
+          #{self}.run(
+            url: 'required - HTTP(S) URL',
+            level: 'optional - level value consumed by #run',
+            data: 'optional - data value consumed by #run',
+            dbs: 'optional - dbs value consumed by #run'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end

data/lib/pwn/plugins/ssn.rb

@@ -40,12 +40,15 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run generate and return its result
           #{self}.generate(
             count: 'required - number of SSN numbers to generate'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/thread_pool.rb

@@ -60,20 +60,17 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
           #{self}.fill(
-            enumerable_array. => 'required array for proper thread pool assignment',
-            max_threads: 'optional number of threads in the thread pool (defaults to 9)',
-            detach: 'optional boolean to detach threads (defaults to false)'
+            enumerable_array: 'required - required array for proper thread pool assignment',
+            max_threads: 'optional - optional number of threads in the thread pool (defaults to 9)',
+            detach: 'optional - optional boolean to detach threads (defaults to false)'
           )
 
-          Example:
-          arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
-          #{self}.fill(enumerable_array: arr, max_threads: 9) do |integer|
-            puts integer
-          end
-
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/tor.rb

@@ -248,25 +248,30 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          tor_obj = #{self}.start(
+          # Run start and return its result
+          #{self}.start(
             ip: 'optional - IP address to listen (default: 127.0.0.1)',
-            port: 'optional - socks port to listen (default: 9050)',
-            ctrl_port: 'optional - tor control port to listen (default: 9051)',
-            net: 'optional - CIDR notation to accept connections (default: 127.0.0.1/32)',
+            port: 'optional - socks port to listen (default: 1024-65535)',
+            ctrl_port: 'optional - tor control port to listen (default: 1024-65535)',
+            net: 'optional - CIDR notation to accept connections (default: 127.0.0.0.1/32)',
             data_dir: 'optional - directory to keep tor session data (default: /tmp/tor_pwn-TIMESTAMP)'
           )
 
+          # Run switch exit node and return its result
           #{self}.switch_exit_node(
             tor_obj: 'required - tor_obj returned from #start method',
             response_timeout: 'optional - float in seconds to timeout (default: 3.0)'
           )
 
+          # Run stop and return its result
           #{self}.stop(
             tor_obj: 'required - tor_obj returned from #start method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/transparent_browser.rb

@@ -1561,188 +1561,143 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          browser_obj1 = #{self}.open(
+          # Open a session or connection and return a handle.
+          #{self}.open(
             browser_type: 'optional - :firefox|:chrome|:headless|:rest|:websocket (defaults to :chrome)',
-            proxy: 'optional scheme://proxy_host:port || tor (defaults to nil)',
+            proxy: 'optional - scheme://proxy_host:port || tor (defaults to nil)',
             devtools: 'optional - boolean (defaults to false)'
           )
-          browser = browser_obj1[:browser]
-          puts browser.public_methods
-
-          ********************************************************
-          * DevTools Interaction
-          * All DevTools Commands can be found here:
-          * https://chromedevtools.github.io/devtools-protocol/
-          * Examples
-          devtools = browser_obj1[:devtools]
-          puts devtools.public_methods
-          puts devtools.instance_variables
-          puts devtools.instance_variable_get('@session_id')
-
-          websocket = devtools.instance_variable_get('@ws')
-          puts websocket.public_methods
-          puts websocket.instance_variables
-          puts websocket.instance_variable_get('@messages')
-
-          * Tracing
-          devtools.send_cmd('Tracing.start')
-          devtools.send_cmd('Tracing.requestMemoryDump')
-          devtools.send_cmd('Tracing.end')
-          puts devtools.instance_variable_get('@messages')
-
-          * Network
-          devtools.send_cmd('Network.enable')
-          last_ws_resp = devtools.instance_variable_get('@messages').last if devtools.instance_variable_get('@messages').last['method'] == 'Network.webSocketFrameReceived'
-          puts last_ws_resp
-          devtools.send_cmd('Network.disable')
-
-          * Debugging DOM and Sending JavaScript to Console
-          devtools.send_cmd('Runtime.enable')
-          devtools.send_cmd('Console.enable')
-          devtools.send_cmd('DOM.enable')
-          devtools.send_cmd('Page.enable')
-          devtools.send_cmd('Log.enable')
-          devtools.send_cmd('Debugger.enable')
-          devtools.send_cmd('Debugger.pause')
-          step = 1
-          next_step = 60
-          loop do
-            devtools.send_cmd('Console.clearMessages')
-            devtools.send_cmd('Log.clear')
-            console_events = []
-            browser.driver.on_log_event(:console) { |event| console_events.push(event) }
-
-            devtools.send_cmd('Debugger.stepInto')
-            puts \"Step: \#{step}\"
-
-            this_document = devtools.send_cmd('DOM.getDocument')
-            puts \"This #document:\\n\#{this_document}\\n\\n\\n\"
-
-            console_cmd = {
-              expression: 'for(var pop_var in window) { if (window.hasOwnProperty(pop_var) && window[pop_var] != null) console.log(pop_var + \" = \" + window[pop_var]); }'
-            }
-            puts devtools.send_cmd('Runtime.evaluate', **console_cmd)
-
-            print '-' * 180
-            print \"\\n\"
-            console_events.each do |event|
-              puts event.args
-            end
-            puts \"Console Response Length: \#{console_events.length}\"
-            console_events_digest = OpenSSL::Digest::SHA256.hexdigest(
-              console_events.inspect
-            )
-            puts \"Console Events Array SHA256 Digest: \#{console_events_digest}\"
-            print '-' * 180
-            puts \"\\n\\n\\n\"
-
-            print \"Next Step in \"
-            next_step.downto(1) {|n| print \"\#{n} \"; sleep 1 }
-            puts 'READY!'
-            step += 1
-          end
-
-          devtools.send_cmd('Debugger.disable')
-          devtools.send_cmd('Log.disable')
-          devtools.send_cmd('Page.disable')
-          devtools.send_cmd('DOM.disable')
-          devtools.send_cmd('Console.disable')
-          devtools.send_cmd('Runtime.disable')
-          * End of DevTools Examples
-          ********************************************************
 
-          browser_obj1 = #{self}.dump_links(
-            browser_obj: 'required - browser_obj returned from #open method)'
+          # Run dump links and return its result
+          #{self}.dump_links(
+            browser_obj: 'optional - browser object returned from #open'
           )
 
-          browser_obj1 = #{self}.find_elements_by_text(
-            browser_obj: 'required - browser_obj returned from #open method)',
+          # Run find elements by text and return its result
+          #{self}.find_elements_by_text(
+            browser_obj: 'optional - browser object returned from #open',
             text: 'required - text to search for in the DOM'
           )
 
+          # Run type as human and return its result
           #{self}.type_as_human(
             string: 'required - string to type as human',
             rand_sleep_float: 'optional - float timing in between keypress (defaults to 0.09)'
-          ) {|char| browser_obj1.text_field(name: \"search\").send_keys(char) }
+          )
 
-          console_resp = #{self}.console(
-            browser_obj: 'required - browser_obj returned from #open method)',
+          # Run console and return its result
+          #{self}.console(
+            browser_obj: 'optional - browser object returned from #open',
             js: 'required - JavaScript expression to evaluate',
             return_to: 'optional - return to :console or :stdout (defaults to :console)'
           )
 
-          console_resp = #{self}.view_dom_mutations(
-            browser_obj: 'required - browser_obj returned from #open method)',
+          # Run view dom mutations and return its result
+          #{self}.view_dom_mutations(
+            browser_obj: 'required - browser_obj returned from #open method',
             index: 'optional - index of tab to switch to (defaults to active tab)',
-            target: 'optional - target JavaScript node to observe (defaults to document.body)'
+            target: 'optional - target JavaScript node to observe (defaults to document.body)',
+            observe_clobbering: 'optional - boolean to enable DOM Clobbering detection (defaults to true)',
+            observe_redirects: 'optional - boolean to enable Insecure Redirect detection (defaults to true)',
+            observe_resources: 'optional - boolean to enable resource load monitoring (defaults to true)'
           )
 
-          console_resp = #{self}.hide_dom_mutations(
-            browser_obj: 'required - browser_obj returned from #open method)',
+          # Run hide dom mutations and return its result
+          #{self}.hide_dom_mutations(
+            browser_obj: 'optional - browser object returned from #open',
             index: 'optional - index of tab to switch to (defaults to active tab)'
           )
 
+          # Run update about config and return its result
           #{self}.update_about_config(
-            browser_obj: 'required - browser_obj returned from #open method)',
+            browser_obj: 'optional - browser object returned from #open',
             key: 'required - key to update in about:config',
             value: 'required - value to set for key in about:config'
           )
 
-          tabs = #{self}.list_tabs(
+          # Run list tabs and return its result
+          #{self}.list_tabs(
             browser_obj: 'required - browser_obj returned from #open method)'
           )
 
-          tab = #{self}.jmp_tab(
+          # Run jmp tab and return its result
+          #{self}.jmp_tab(
             browser_obj: 'required - browser_obj returned from #open method)',
             index: 'optional - index of tab to switch to (defaults to switching to next tab)',
-            keyword: 'optional - keyword in title or url used to switch tabs (defaults to switching to next tab)',
+            keyword: 'optional - keyword in title or url used to switch tabs (defaults to switching to next tab)'
           )
 
-          tab = #{self}.new_tab(
+          # Run new tab and return its result
+          #{self}.new_tab(
             browser_obj: 'required - browser_obj returned from #open method)',
             url: 'optional - URL to open in new tab'
           )
 
-          tab = #{self}.close_tab(
+          # Run close tab and return its result
+          #{self}.close_tab(
             browser_obj: 'required - browser_obj returned from #open method)',
             index: 'optional - index of tab to close (defaults to closing active tab)',
             keyword: 'optional - keyword in title or url used to close tabs (defaults to closing active tab)'
           )
 
-          current_dom = #{self}.dom(
+          # Run dom and return its result
+          #{self}.dom(
+            browser_obj: 'required - browser_obj returned from #open method)'
+          )
+
+          # Run get page state and return its result
+          #{self}.get_page_state(
             browser_obj: 'required - browser_obj returned from #open method)'
           )
 
-          page_state = #{self}.get_page_state(
+          # Run devtools websocket messages and return its result
+          #{self}.devtools_websocket_messages(
             browser_obj: 'required - browser_obj returned from #open method)'
           )
 
+          # Run debugger and return its result
           #{self}.debugger(
             browser_obj: 'required - browser_obj returned from #open method)',
             action: 'optional - action to take :enable|:pause|:resume|:disable (Defaults to :enable)'
           )
 
+          # Run get targets and return its result
+          #{self}.get_targets(
+            browser_obj: 'required - browser_obj returned from #open method)'
+          )
+
+          # Run breakpoint locations and return its result
+          #{self}.breakpoint_locations(
+            browser_obj: 'required - browser_obj returned from #open method)'
+          )
+
+          # Run step and return its result
           #{self}.step(
             browser_obj: 'required - browser_obj returned from #open method)',
             action: 'optional - action to take :into|:out|:over (Defaults to :into)',
             steps: 'optional - number of steps taken (Defaults to 1)'
           )
 
+          # Run toggle devtools and return its result
           #{self}.toggle_devtools(
             browser_obj: 'required - browser_obj returned from #open method)'
           )
 
+          # Run jmp devtools panel and return its result
           #{self}.jmp_devtools_panel(
             browser_obj: 'required - browser_obj returned from #open method)',
             panel: 'optional - panel to switch to :elements|:inspector|:console|:debugger|:sources|:network'
           )
 
-          browser_obj1 = #{self}.close(
+          # Close a session previously returned by #open.
+          #{self}.close(
             browser_obj: 'required - browser_obj returned from #open method)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end