pwn 0.5.708 → 0.5.710

data/lib/pwn/plugins/repl.rb

@@ -2131,18 +2131,139 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Restore the TTY after a spinner / agent turn so Pry/Reline prints
+          #{self}.ready_tty!(
+            skip: 'optional - skip value consumed by #ready_tty!',
+            io: 'optional - io value consumed by #ready_tty!'
+          )
+
+          # Compact token-count formatter for the pwn.ai PS1 (e.g. 0, 843, 12K, 250K, 1M)
+          #{self}.compact_context_tokens(
+            tokens: 'optional - tokens value consumed by #compact_context_tokens'
+          )
+
+          # Run refresh ps1 proc and return its result
           #{self}.refresh_ps1_proc(
-            mode: 'required - :splat or nil'
+            mode: 'optional - mode value consumed by #refresh_ps1_proc'
           )
 
+          # Run add commands and return its result
           #{self}.add_commands
 
+          # Run add hooks and return its result
           #{self}.add_hooks
 
+          # Run pwn ai complete kind and return its result
+          #{self}.pwn_ai_complete_kind(
+            line: 'optional - line value consumed by #pwn_ai_complete_kind'
+          )
+
+          # Run pwn ai complete and return its result
+          #{self}.pwn_ai_complete(
+            target: 'required - token Reline is completing',
+            line: 'optional - full line buffer',
+            pry: 'optional - Pry instance for Ruby completion'
+          )
+
+          # Run pwn ai complete command and return its result
+          #{self}.pwn_ai_complete_command(
+            line: 'optional - line value consumed by #pwn_ai_complete_command',
+            target: 'required - hostname, IP, or CIDR to scan'
+          )
+
+          # Run pwn ai complete path and return its result
+          #{self}.pwn_ai_complete_path(
+            target: 'required - hostname, IP, or CIDR to scan',
+            line: 'optional - line value consumed by #pwn_ai_complete_path'
+          )
+
+          # Run pwn ai complete ruby and return its result
+          #{self}.pwn_ai_complete_ruby(
+            target: 'optional - hostname, IP, or CIDR to scan',
+            pry: 'optional - pry value consumed by #pwn_ai_complete_ruby (defaults to Thread.current[:pwn_ai_completer_pry])'
+          )
+
+          # Install Reline dropdown for pwn-ai (commands / paths / Ruby)
+          #{self}.install_pwn_ai_completer!(
+            pry: 'optional - pry value consumed by #install_pwn_ai_completer!'
+          )
+
+          # Run restore pwn ai completer and return its result
+          #{self}.restore_pwn_ai_completer!
+
+          # Run a leading-slash pwn-ai command locally. Returns true when handled
+          #{self}.pwn_ai_dispatch_slash!(
+            request: 'optional - request value consumed by #pwn_ai_dispatch_slash!',
+            pry: 'optional - pry value consumed by #pwn_ai_dispatch_slash!'
+          )
+
+          # Run pwn ai engines and return its result
+          #{self}.pwn_ai_engines
+
+          # Run pwn ai provider class and return its result
+          #{self}.pwn_ai_provider_class(
+            engine: 'optional - engine value consumed by #pwn_ai_provider_class'
+          )
+
+          # Run pwn ai model ids and return its result
+          #{self}.pwn_ai_model_ids(
+            models: 'optional - models value consumed by #pwn_ai_model_ids'
+          )
+
+          # Run pwn ai list llms and return its result
+          #{self}.pwn_ai_list_llms(
+            engine: 'required - engine value consumed by #pwn_ai_list_llms'
+          )
+
+          # Run pwn ai engine model and return its result
+          #{self}.pwn_ai_engine_model(
+            engine: 'required - engine value consumed by #pwn_ai_engine_model'
+          )
+
+          # Run pwn ai run model and return its result
+          #{self}.pwn_ai_run_model(
+            args: 'optional - Array args value consumed by #pwn_ai_run_model'
+          )
+
+          # Run persist ai selection and return its result
+          #{self}.persist_ai_selection(
+            engine: 'required - engine value consumed by #persist_ai_selection',
+            model: 'required - model value consumed by #persist_ai_selection'
+          )
+
+          # Run pwn ai run cron and return its result
+          #{self}.pwn_ai_run_cron(
+            args: 'optional - Array args value consumed by #pwn_ai_run_cron'
+          )
+
+          # Run pwn ai run sessions and return its result
+          #{self}.pwn_ai_run_sessions(
+            args: 'optional - Array args value consumed by #pwn_ai_run_sessions'
+          )
+
+          # Run pwn ai run memory and return its result
+          #{self}.pwn_ai_run_memory(
+            args: 'optional - Array args value consumed by #pwn_ai_run_memory'
+          )
+
+          # Run pwn ai run skills and return its result
+          #{self}.pwn_ai_run_skills(
+            args: 'optional - Array args value consumed by #pwn_ai_run_skills'
+          )
+
+          # IRB-style suggest-as-you-type for the pwn REPL
+          #{self}.enable_autocomplete(
+            enabled: 'optional - Boolean (default true). false reverts to single-line cycling.',
+            graph: 'optional - constants (PWN::Plugins::Nm<TAB>), instance methods'
+          )
+
+          # Run start and return its result
           #{self}.start
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/scannable_codes.rb

@@ -72,15 +72,19 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          # Run generate and return its result
           #{self}.generate(
             data: 'required - data to encode',
             type: 'optional - :barcode || :qrcode (defaults to :qrcode)',
             size: 'optional - size of the image when type is :qrcode (defaults to 200)',
-            path: 'optional - path to save image (defaults to \"./\#{data}.png\")'
+            path: 'optional - path to save image (defaults to ./\#{data}.png)',
+            return_type: 'optional - :base64 || :file (defaults to :file)'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/semgrep.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'open3'
+
+module PWN
+  module Plugins
+    # semgrep wrapper feeding SAST-shaped findings.
+    module Semgrep
+      public_class_method def self.required_bins
+        %w[semgrep]
+      end
+
+      public_class_method def self.scan(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'semgrep')
+        target = opts[:path] || opts[:target] || '.'
+        cmd = ['semgrep', '--json', '--quiet']
+        cmd += ['--config', opts[:config].to_s] if opts[:config]
+        cmd << target.to_s
+        stdout, stderr, status = Open3.capture3(*cmd)
+        parsed = begin
+          JSON.parse(stdout)
+        rescue JSON::ParserError
+          {}
+        end
+        findings = Array(parsed['results']).map do |r|
+          {
+            title: r['check_id'],
+            severity: r.dig('extra', 'severity'),
+            path: r['path'],
+            line: r.dig('start', 'line'),
+            message: r.dig('extra', 'message')
+          }
+        end
+        { findings: findings, 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 semgrep --json and map results into finding hashes.
+          #{self}.scan(
+            path: 'optional - directory or file to scan (defaults to .)',
+            target: 'optional - alias for path',
+            config: 'optional - semgrep --config value (e.g. auto or p/owasp-top-ten)'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end

data/lib/pwn/plugins/serial.rb

@@ -232,41 +232,51 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          serial_obj = #{self}.connect(
-            block_dev: 'optional serial block device path (defaults to /dev/ttyUSB0)',
-            baud: 'optional (defaults to 9600)',
-            data_bits: 'optional (defaults to 8)',
-            stop_bits: 'optional (defaults to 1)',
+          # Run connect and return its result
+          #{self}.connect(
+            block_dev: 'optional - serial block device path (defaults to /dev/ttyUSB0)',
+            baud: 'optional - (defaults to 9600)',
+            data_bits: 'optional - (defaults to 8)',
+            stop_bits: 'optional - (defaults to 1)',
             parity: 'optional - :even|:mark|:odd|:space|:none (defaults to :none)'
           )
 
-          line_state = #{self}.get_line_state(
-            serial_obj: 'required serial_obj returned from #connect method'
+          # Run get line state and return its result
+          #{self}.get_line_state(
+            serial_obj: 'required - required serial_obj returned from #connect method'
           )
 
-          modem_params = #{self}.get_modem_params(
-            serial_obj: 'required serial_obj returned from #connect method'
+          # Run get modem params and return its result
+          #{self}.get_modem_params(
+            serial_obj: 'required - serial_obj returned from #connect method'
           )
 
+          # Run request and return its result
           #{self}.request(
-            serial_obj: 'required serial_obj returned from #connect method',
-            payload: 'required - array of bytes OR string to write to serial device (e.g. [0x00, 0x41, 0x90, 0x00] OR \"ATDT+15555555\r\n\"'
+            serial_obj: 'required - required serial_obj returned from #connect method',
+            payload: 'required - array of bytes OR string to write to serial device (e.g. [0x00, 0x41, 0x90, 0x00] OR ATDT+15555555\\r\\n'
           )
 
+          # Run response and return its result
           #{self}.response(
-            serial_obj: 'required serial_obj returned from #connect method'
+            serial_obj: 'required - serial_obj returned from #connect method'
           )
 
-          session_data_arr = #{self}.dump_session_data
+          # Run dump session data and return its result
+          #{self}.dump_session_data
 
+          # Run flush session data and return its result
           #{self}.flush_session_data
 
+          # Run disconnect and return its result
           #{self}.disconnect(
-            serial_obj: 'required serial_obj returned from #connect method'
+            serial_obj: 'required - serial_obj returned from #connect method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

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

@@ -23,6 +23,7 @@ module PWN
 
         protocol = opts[:protocol]
         protocol ||= :tcp
+        PWN::Plugins::PreflightChecker.require_cap_net_raw! if protocol.to_s.to_sym == :raw
 
         # TODO: Add proxy support
 
@@ -319,43 +320,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::PreflightChecker.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