pwn 0.5.708 → 0.5.710

data/lib/pwn/plugins/irc.rb

@@ -249,63 +249,76 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          irc_obj = #{self}.connect(
-            host: 'required - host or ip',
-            port: 'required - host port',
-            nick: 'required - nickname',
+          # Run connect and return its result
+          #{self}.connect(
+            host: 'required - host or ip (defaults to 127.0.0.1)',
+            port: 'required - host port (defaults to 6667)',
+            nick: 'required - nick value consumed by #connect',
             real: 'optional - real name (defaults to value of nick)',
             tls: 'optional - boolean connect to host socket using TLS (defaults to false)'
           )
 
-          #{self}.ping(
+          # Run join and return its result
+          #{self}.join(
             irc_obj: 'required - irc_obj returned from #connect method',
-            message: 'required - message to send'
+            nick: 'required - nick value consumed by #join',
+            chan: 'required - channel to join'
           )
 
-          #{self}.pong(
+          # Run names and return its result
+          #{self}.names(
             irc_obj: 'required - irc_obj returned from #connect method',
-            message: 'required - message to send'
+            chan: 'required - channel to list names'
           )
 
+          # Run privmsg and return its result
           #{self}.privmsg(
             irc_obj: 'required - irc_obj returned from #connect method',
             chan: 'required - channel to send message',
-            message: 'required - message to send'
+            message: 'required - message to send',
+            nick: 'optional - nick value consumed by #privmsg'
           )
 
-          #{self}.join(
+          # Run ping and return its result
+          #{self}.ping(
             irc_obj: 'required - irc_obj returned from #connect method',
-            nick: 'required - nickname',
-            chan: 'required - channel to join'
+            message: 'required - message to send'
           )
 
-          #{self}.names(
+          # Run pong and return its result
+          #{self}.pong(
             irc_obj: 'required - irc_obj returned from #connect method',
-            chan: 'required - channel to list names'
+            message: 'required - message to send'
           )
 
+          # Run part and return its result
           #{self}.part(
             irc_obj: 'required - irc_obj returned from #connect method',
             chan: 'required - channel to part',
             message: 'optional - message to send when parting'
           )
 
+          # Run quit and return its result
           #{self}.quit(
             irc_obj: 'required - irc_obj returned from #connect method',
             message: 'optional - message to send when quitting'
           )
 
+          # Run listen and return its result
           #{self}.listen(
             irc_obj: 'required - irc_obj returned from #connect method',
             verbose: 'optional - boolean to enable verbose output (defaults to false)'
           )
 
-          irc_obj = #{self}.disconnect(
+          # Run disconnect and return its result
+          #{self}.disconnect(
             irc_obj: 'required - irc_obj returned from #connect method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/jenkins.rb

@@ -442,95 +442,103 @@ module PWN
       # Display Usage for this Module
 
       public_class_method def self.help
-        puts %{USAGE:
-          jenkins_obj = #{self}.connect(
-            ip: 'required host/ip of Jenkins Server',
-            port: 'optional tcp port (defaults to 8080),
-            username: 'optional username (functionality will be limited if ommitted)',
-            api_key: 'optional api_key (functionality will be limited if ommitted)',
-            identity_file: 'optional ssh private key path to AuthN w/ Jenkins PREFERRED over username/api_key',
-            ssl: 'optional connect over TLS (defaults to true),
-            proxy: 'optional debug proxy rest api requests to jenkins (e.g. "http://127.0.0.1:8080")''
+        puts "USAGE:
+          # Run connect and return its result
+          #{self}.connect(
+            ip: 'required - required host/ip of Jenkins Server',
+            port: 'optional - optional tcp port (defaults to 8080',
+            username: 'optional - optional username (functionality will be limited if ommitted)',
+            api_key: 'optional - optional api_key (functionality will be limited if ommitted)',
+            identity_file: 'optional - optional ssh private key path to AuthN w/ Jenkins PREFERRED over username/api_key',
+            ssl: 'optional - optional connect over TLS (defaults to true',
+            proxy: 'optional - optional debug proxy rest api requests to jenkins (e.g. http://127.0.0.1:8080)'
           )
-          puts jenkins_obj.public_methods
 
+          # Run create user and return its result
           #{self}.create_user(
-            jenkins_obj: 'required - jenkins_obj returned from #connect method',
-            username: 'required - user to create',
-            password: 'optional - password for new user (will prompt if nil)'
-            fullname: 'required - full name of new user'
-            email: 'required - email address of new user'
+            jenkins_obj: 'optional - jenkins obj value consumed by #create_user',
+            username: 'optional - username value consumed by #create_user',
+            password: 'optional - password value consumed by #create_user',
+            fullname: 'optional - fullname value consumed by #create_user',
+            email: 'optional - email value consumed by #create_user'
           )
 
+          # Run create ssh credential and return its result
           #{self}.create_ssh_credential(
-            jenkins_obj: 'required - jenkins_obj returned from #connect method',
-            username: 'required - username for new credential'
-            private_key_path: 'required - path of private ssh key for new credential'
-            key_passphrase: 'optional - private key passphrase for new credential'
-            credential_id: 'optional but recommended - useful when creating userland jobs',
-            description: 'optional - description of new credential'
-            domain: 'optional - defaults to GLOBAL',
-            scope: 'optional - GLOBAL or SYSTEM (defaults to GLOBAL)'
+            jenkins_obj: 'optional - jenkins obj value consumed by #create_ssh_credential',
+            username: 'optional - username value consumed by #create_ssh_credential',
+            private_key_path: 'optional - private key path value consumed by #create_ssh_credential',
+            key_passphrase: 'optional - key passphrase value consumed by #create_ssh_credential',
+            credential_id: 'optional - credential id value consumed by #create_ssh_credential',
+            description: 'optional - description value consumed by #create_ssh_credential',
+            domain: 'optional - FQDN to query (e.g. example.com)',
+            scope: 'optional - scope value consumed by #create_ssh_credential'
           )
 
-          git_repo_arr = #{self}.get_all_job_git_repos(
-            jenkins_obj: 'required jenkins_obj returned from connect method'
+          # Run get all job git repos and return its result
+          #{self}.get_all_job_git_repos(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method'
           )
 
-          git_repo_branches = #{self}.get_all_git_repo_branches_by_commit_date(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            job_name: 'required jenkins job name',
-            git_url: 'required git url for git_repo'
+          # Run list nested jobs and return its result
+          #{self}.list_nested_jobs(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            view_path: 'required - required view path to list jobs'
           )
 
-          nested_jobs_arr = #{self}.list_nested_jobs(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            view_path: 'required view path list jobs'
+          # Run list nested views and return its result
+          #{self}.list_nested_views(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            view_path: 'required - required view path list sub-views'
           )
 
-          nested_views_arr = #{self}.list_nested_views(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            view_path: 'required view path list sub-views'
+          # Run create nested view and return its result
+          #{self}.create_nested_view(
+            jenkins_obj: 'optional - jenkins obj value consumed by #create_nested_view',
+            view_name: 'optional - view name value consumed by #create_nested_view',
+            create_in_view_path: 'optional - create in view path value consumed by #create_nested_view'
           )
 
-          view_created_bool = #{self}.create_nested_view(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            view_path: 'required view path create',
-            create_in_view_path: 'optional creates nested view within an existing nested view, defaults to / views'
+          # Run add job to nested view and return its result
+          #{self}.add_job_to_nested_view(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            view_path: 'required - required view path associate job',
+            job_name: 'required - required view path attach to a view'
           )
 
-          add_job_to_nested_view_resp = #{self}.add_job_to_nested_view(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            view_path: 'required view path associate job',
-            job_name: 'required view path attach to a view',
-          )
-
-          copy_job_resp = #{self}.copy_job_no_fail_on_exist(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            existing_job_name: 'required existing job to copt to new job',
-            new_job_name: 'required name of new job'
+          # Run copy job no fail on exist and return its result
+          #{self}.copy_job_no_fail_on_exist(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            existing_job_name: 'required - required existing job to copt to new job',
+            new_job_name: 'required - required name of new job'
           )
 
+          # Run disable jobs by regex and return its result
           #{self}.disable_jobs_by_regex(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            regex: 'required regex pattern for matching jobs to disable e.g. :regex => "^M[0-9]"',
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            regex: 'required - required regex pattern for matching jobs to disable e.g. :regex => ^M[0-9]'
           )
 
-          #{self}.delete_job_by_regex(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
-            regex: 'required regex pattern for matching jobs to disable e.g. :regex => "^M[0-9]"',
+          # Run delete jobs by regex and return its result
+          #{self}.delete_jobs_by_regex(
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method',
+            regex: 'required - required regex pattern for matching jobs to disable e.g. :regex => ^M[0-9]'
           )
 
+          # Run clear build queue and return its result
           #{self}.clear_build_queue(
-            jenkins_obj: 'required jenkins_obj returned from #connect method',
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method'
           )
 
+          # Run disconnect and return its result
           #{self}.disconnect(
-            jenkins_obj: 'required jenkins_obj returned from connect method'
+            jenkins_obj: 'required - required jenkins_obj returned from #connect method'
           )
 
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
-        }
+        "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/jira_data_center.rb

@@ -607,67 +607,75 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
-          all_fields = #{self}.get_all_fields
+          # Run get all fields and return its result
+          #{self}.get_all_fields
 
-          user = #{self}.get_user(
-            username: 'required - username to lookup (e.g. jane.doe')',
+          # Run get user and return its result
+          #{self}.get_user(
+            username: 'required - username to lookup (e.g. jane.doe) (defaults to PWN::Plugins::AuthenticationHelper.username)',
             params: 'optional - additional parameters to pass in the URI (e.g. expand, etc.)'
           )
 
-          issue_resp = #{self}.get_issue(
+          # Run get issue and return its result
+          #{self}.get_issue(
             issue: 'required - issue to lookup (e.g. Bug, Issue, Story, or Epic ID)',
             params: 'optional - additional parameters to pass in the URI (e.g. fields, expand, etc.)'
           )
 
-          issue_resp = #{self}.create_issue(
+          # Run create issue and return its result
+          #{self}.create_issue(
             project_key: 'required - project key (e.g. PWN)',
             summary: 'required - summary of the issue (e.g. Epic for PWN-1337)',
             issue_type: 'required - issue type (e.g. :epic, :story, :bug)',
             description: 'optional - description of the issue',
             epic_name: 'optional - name of the epic',
             additional_fields: 'optional - additional fields to set in the issue (e.g. labels, components, custom fields, etc.)',
-            attachments: 'optional - array of attachment paths to upload to the issue (e.g. [\"/tmp/file1.txt\", \"/tmp/file2.txt\"])',
-            comment: 'optional - comment to add to the issue (e.g. \"This is a comment\")'
+            attachments: 'optional - array of attachment paths to upload to the issue (e.g. [/tmp/file1.txt, /tmp/file2.txt])',
+            comment: 'optional - comment to add to the issue (e.g. This is a comment)'
           )
 
-          issue_resp = #{self}.update_issue(
-            issue: 'required - issue to update (e.g. Bug, Issue, Story, or Epic ID)',
+          # Run update issue and return its result
+          #{self}.update_issue(
             fields: 'required - fields to update in the issue (e.g. summary, description, labels, components, custom fields, etc.)',
-            attachments: 'optional - array of attachment paths to upload to the issue (e.g. [\"/tmp/file1.txt\", \"/tmp/file2.txt\"])'
+            attachments: 'optional - array of attachment paths to upload to the issue (e.g. [/tmp/file1.txt, /tmp/file2.txt])',
+            issue: 'required - issue value consumed by #update_issue'
           )
 
-          issue_resp = #{self}.issue_comment(
-            issue: 'required - issue to comment on (e.g. Bug, Issue, Story, or Epic ID)',
+          # Run issue comment and return its result
+          #{self}.issue_comment(
+            issue: 'required - issue to delete (e.g. Bug, Issue, Story, or Epic ID)',
             comment_action: 'required - action to perform on the issue comment (e.g. :delete, :add, :update - Defaults to :add)',
             comment_id: 'optional - comment ID to delete or update (e.g. 10000)',
-            author: 'optional - author of the comment (e.g. \"jane.doe\")',
-            comment: 'optional - comment to add or update in the issue (e.g. \"This is a comment\")'
+            author: 'optional - author of the comment (e.g. jane.doe)',
+            comment: 'optional - comment to add or update in the issue (e.g. This is a comment)'
           )
 
-          issue_type_metadata = #{self}.get_issue_type_metadata(
+          # Run get issue type metadata and return its result
+          #{self}.get_issue_type_metadata(
             project_key: 'required - project key (e.g. PWN)',
             issue_type_id: 'required - issue type ID (e.g. issue[:fields][:issuetype][:id] from #get_issue method)'
           )
 
-          issue_resp = #{self}.clone_issue(
+          # Run clone issue and return its result
+          #{self}.clone_issue(
             issue: 'required - issue to clone (e.g. Bug, Issue, Story, or Epic ID)',
             copy_attachments: 'optional - boolean to indicate whether to copy attachments (Defaults to false)'
           )
 
-          issue_resp = #{self}.delete_issue(
+          # Run delete issue and return its result
+          #{self}.delete_issue(
             issue: 'required - issue to delete (e.g. Bug, Issue, Story, or Epic ID)'
           )
 
-          issue_resp = #{self}.delete_attachment(
+          # Run delete attachment and return its result
+          #{self}.delete_attachment(
             id: 'required - attachment ID to delete (e.g. 10000) found in #get_issue method'
           )
 
-          **********************************************************************
-          * For more information on the Jira Server REST API, see:
-          * https://developer.atlassian.com/server/jira/platform/rest-apis/
-
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
         "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/jobs.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'securerandom'
+require 'open3'
+
+module PWN
+  module Plugins
+    # Background jobs that survive a pwn-ai turn (scans, fuzz campaigns).
+    module Jobs
+      JOBS_DIR = File.join(Dir.home, '.pwn', 'jobs')
+
+      public_class_method def self.required_bins
+        []
+      end
+
+      public_class_method def self.start(opts = {})
+        cmd = opts[:command] || opts[:cmd]
+        raise 'ERROR: command is required' if cmd.to_s.empty?
+
+        FileUtils.mkdir_p(JOBS_DIR)
+        id = SecureRandom.hex(6)
+        log = File.join(JOBS_DIR, "#{id}.log")
+        meta = File.join(JOBS_DIR, "#{id}.json")
+        pid = spawn(cmd.to_s, %i[out err] => [log, 'a'])
+        Process.detach(pid)
+        row = {
+          id: id,
+          pid: pid,
+          command: cmd.to_s,
+          log: log,
+          session_id: opts[:session_id],
+          started_at: Time.now.utc.iso8601
+        }
+        File.write(meta, JSON.generate(row))
+        PWN::Plugins::ArtifactRegistry.register(session_id: opts[:session_id], path: log, kind: 'job-log') if opts[:session_id] && defined?(PWN::Plugins::ArtifactRegistry) && File.file?(log)
+        row
+      end
+
+      public_class_method def self.status(opts = {})
+        row = load_job(opts)
+        alive = begin
+          Process.kill(0, row[:pid].to_i)
+          true
+        rescue Errno::ESRCH, Errno::EPERM
+          false
+        end
+        row.merge(alive: alive)
+      end
+
+      public_class_method def self.tail(opts = {})
+        row = load_job(opts)
+        n = (opts[:lines] || 40).to_i
+        return '' unless File.file?(row[:log])
+
+        File.readlines(row[:log]).last(n).join
+      end
+
+      public_class_method def self.stop(opts = {})
+        row = load_job(opts)
+        Process.kill('TERM', row[:pid].to_i)
+        true
+      rescue Errno::ESRCH
+        false
+      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 start and return its result
+          #{self}.start(
+            command: 'required - command value consumed by #start (defaults to opts[:cmd])',
+            cmd: 'required - command string to run',
+            session_id: 'optional - session id value consumed by #start'
+          )
+
+          # Run status and return its result
+          #{self}.status
+
+          # Run tail and return its result
+          #{self}.tail(
+            lines: 'optional - lines value consumed by #tail'
+          )
+
+          # Run stop and return its result
+          #{self}.stop
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+
+      private_class_method def self.load_job(opts = {})
+        id = opts[:id].to_s
+        path = File.join(JOBS_DIR, "#{id}.json")
+        raise "ERROR: unknown job #{id}" unless File.file?(path)
+
+        JSON.parse(File.read(path), symbolize_names: true)
+      end
+    end
+  end
+end

data/lib/pwn/plugins/json_pathify.rb

@@ -33,13 +33,17 @@ module PWN
       # Display Usage for this Module
 
       public_class_method def self.help
-        puts %{USAGE:
-          json_path_arr = #{self}.search_key(
-            json_data_struct: "required JSON data structure",
-            key: "required key to find in JSON data structure. returns key values"
+        puts "USAGE:
+          # Run search key and return its result
+          #{self}.search_key(
+            json_data_struct: 'required - required JSON data structure',
+            key: 'required - required key to find in JSON data structure. returns key values'
           )
+
+          # Print the AUTHOR(S) string for this module.
           #{self}.authors
-        }
+        "
+        constants.sort
       end
     end
   end

data/lib/pwn/plugins/k8s.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module PWN
+  module Plugins
+    # trivy / kube-hunter wrappers plus docker-socket preflight.
+    module K8s
+      public_class_method def self.required_bins
+        %w[trivy]
+      end
+
+      public_class_method def self.trivy(opts = {})
+        PWN::Plugins::PreflightChecker.require_bin!(name: 'trivy')
+        target = opts[:target] || opts[:image] || opts[:path]
+        raise 'ERROR: target is required' if target.to_s.empty?
+
+        mode = (opts[:mode] || :image).to_s
+        cmd = ['trivy', mode, '--format', 'json', target.to_s]
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.kube_hunter(opts = {})
+        return { error: 'kube-hunter missing', hint: 'pip install kube-hunter' } unless PWN::Plugins::PreflightChecker.bin?(name: 'kube-hunter')
+
+        cmd = ['kube-hunter']
+        cmd += ['--remote', opts[:remote].to_s] if opts[:remote]
+        cmd << '--report' << 'json'
+        stdout, stderr, status = Open3.capture3(*cmd)
+        { stdout: stdout, stderr: stderr, exit: status.exitstatus }
+      end
+
+      public_class_method def self.docker_socket?(opts = {})
+        path = (opts[:path] || '/var/run/docker.sock').to_s
+        PWN::Plugins::PreflightChecker.service?(name: 'docker', path: path)
+      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
+
+          # Scan a container image or filesystem with trivy.
+          #{self}.trivy(
+            target: 'required - image name or path',
+            image: 'optional - alias for target',
+            path: 'optional - alias for target',
+            mode: 'optional - trivy subcommand (defaults to image)'
+          )
+
+          # Run kube-hunter (remote cluster optional).
+          #{self}.kube_hunter(
+            remote: 'optional - API server host for --remote'
+          )
+
+          # True when the docker unix socket is present.
+          #{self}.docker_socket?(
+            path: 'optional - socket path (defaults to /var/run/docker.sock)'
+          )
+
+          # Print the AUTHOR(S) string for this module.
+          #{self}.authors
+        "
+        constants.sort
+      end
+    end
+  end
+end