pwn 0.4.602 → 0.4.604

data/lib/pwn/plugins/open_ai.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module PWN
+  module Plugins
+    # This plugin is used for interacting w/ OpenAI's REST API using
+    # the 'rest' browser type of PWN::Plugins::TransparentBrowser.
+    # This is based on the following OpenAI API Specification:
+    # https://api.openai.com/v1
+    module OpenAI
+      @@logger = PWN::Plugins::PWNLogger.create
+
+      # Supported Method Parameters::
+      # open_ai_rest_call(
+      #   token: 'required - open_ai bearer token',
+      #   http_method: 'optional HTTP method (defaults to GET)
+      #   rest_call: 'required rest call to make per the schema',
+      #   params: 'optional params passed in the URI or HTTP Headers',
+      #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST'
+      # )
+
+      private_class_method def self.open_ai_rest_call(opts = {})
+        http_method = if opts[:http_method].nil?
+                        :get
+                      else
+                        opts[:http_method].to_s.scrub.to_sym
+                      end
+        rest_call = opts[:rest_call].to_s.scrub
+        params = opts[:params]
+        http_body = opts[:http_body].to_s.scrub
+        base_open_ai_api_uri = 'https://api.openai.com/v1'
+        token = opts[:token]
+
+        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
+
+        case http_method
+        when :get
+          response = rest_client.execute(
+            method: :get,
+            url: "#{base_open_ai_api_uri}/#{rest_call}",
+            headers: {
+              content_type: 'application/json; charset=UTF-8',
+              authorization: "Bearer #{token}",
+              params: params
+            },
+            verify_ssl: false
+          )
+
+        when :post
+          response = rest_client.execute(
+            method: :post,
+            url: "#{base_open_ai_api_uri}/#{rest_call}",
+            headers: {
+              content_type: 'application/json; charset=UTF-8',
+              authorization: "Bearer #{token}"
+            },
+            payload: http_body,
+            verify_ssl: false
+          )
+
+        else
+          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
+        end
+        response
+      rescue StandardError => e
+        case e.message
+        when '400 Bad Request', '404 Resource Not Found'
+          "#{e.message}: #{e.response}"
+        else
+          raise e
+        end
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.get_models(
+      #   token: 'required - Bearer token',
+      # )
+
+      public_class_method def self.get_models(opts = {})
+        token = opts[:token]
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: 'models'
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.chat_gpt(
+      #   token: 'required - Bearer token',
+      #   request: 'required - message to ChatGPT'
+      #   model: 'optional - model to use for text generation (defaults to text-davinci-003)',
+      #   temp: 'optional - creative response float (deafults to 0)',
+      #   max_tokens: 'optional - integer (deafults to 1024)'
+      # )
+
+      public_class_method def self.chat_gpt(opts = {})
+        token = opts[:token]
+        request = opts[:request]
+        model = opts[:model]
+        model ||= 'text-davinci-003'
+        temp = opts[:temp].to_f
+        temp = 0 unless temp.positive?
+        max_tokens = opts[:max_tokens].to_i
+        max_tokens = 1024 unless max_tokens.positive?
+
+        rest_call = 'completions'
+
+        http_body = {
+          model: model,
+          prompt: request,
+          temperature: temp,
+          max_tokens: max_tokens
+        }
+
+        response = open_ai_rest_call(
+          http_method: :post,
+          token: token,
+          rest_call: rest_call,
+          http_body: http_body.to_json
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.img_gen(
+      #   token: 'required - Bearer token',
+      #   request: 'required - message to ChatGPT'
+      #   n: 'optional - number of images to generate (defaults to 1)',
+      #   size: 'optional - size of image (defaults to "1024x1024")'
+      # )
+
+      public_class_method def self.img_gen(opts = {})
+        token = opts[:token]
+        request = opts[:request]
+        n = opts[:n]
+        n ||= 1
+        size = opts[:size]
+        size ||= '1024x1024'
+
+        rest_call = 'images/generations'
+
+        http_body = {
+          prompt: request,
+          n: n,
+          size: size
+        }
+
+        response = open_ai_rest_call(
+          http_method: :post,
+          token: token,
+          rest_call: rest_call,
+          http_body: http_body.to_json
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <request.pentest@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <request.pentest@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          response = #{self}.chat_gpt(
+            token: 'required - Bearer token',
+            request: 'required - message to ChatGPT',
+            model: 'optional - model to use for text generation (defaults to text-davinci-003)',
+            temp: 'optional - creative response float (deafults to 0)',
+            max_tokens: 'optional - integer (deafults to 1024)'
+          )
+
+          response = #{self}.img_gen(
+            token: 'required - Bearer token',
+            request: 'required - message to ChatGPT'
+            n: 'optional - number of images to generate (defaults to 1)',
+            size: 'optional - size of image (defaults to \"1024x1024\")'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end

data/lib/pwn/plugins/openvas.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'time'
+require 'base64'
+
+module PWN
+  module Plugins
+    # This plugin is used for interacting w/ OpenVAS using OMP (OpenVAS Management Protocol).
+    module OpenVAS
+      # Supported Method Parameters::
+      # task_xml_resp = PWN::Plugins::OpenVAS.get_task_id(
+      #   task_name: 'required task name to start',
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.get_task_id(opts = {})
+        task_name = opts[:task_name].to_s.scrub
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        get_tasks_xml_resp = Nokogiri::XML(
+          `sudo runuser -u _gvm -- /usr/bin/gvm-cli \
+            --gmp-username '#{username}' \
+            --gmp-password '#{password}' \
+            socket \
+            --xml="<get_tasks/>"
+          `
+        )
+
+        get_tasks_xml_resp.xpath(
+          "/get_tasks_response/task[name/text()='#{task_name}']"
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # start_task_xml_resp = PWN::Plugins::OpenVAS.start_task(
+      #   task_name: 'required task name to start',
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.start_task(opts = {})
+        task_name = opts[:task_name].to_s.scrub
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        task_id = get_task_id(
+          task_name: task_name,
+          username: username,
+          password: password
+        ).xpath('@id').text
+
+        Nokogiri::XML(
+          `sudo runuser -u _gvm -- /usr/bin/gvm-cli \
+            --gmp-username '#{username}' \
+            --gmp-password '#{password}' \
+            socket \
+            --xml="<start_task task_id='#{task_id}'/>"
+          `
+        )
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # task_status = PWN::Plugins::OpenVAS.get_task_status(
+      #   task_name: 'required task name to start',
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.get_task_status(opts = {})
+        task_name = opts[:task_name].to_s.scrub
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        get_task_id(
+          task_name: task_name,
+          username: username,
+          password: password
+        ).xpath('status').text
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # last_report_id = PWN::Plugins::OpenVAS.last_report_id(
+      #   task_name: 'required task name to start',
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.last_report_id(opts = {})
+        task_name = opts[:task_name].to_s.scrub
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        task_id = get_task_id(
+          task_name: task_name,
+          username: username,
+          password: password
+        ).xpath('@id').text
+
+        report_xml_resp = Nokogiri::XML(
+          `sudo runuser -u _gvm -- /usr/bin/gvm-cli \
+            --gmp-username '#{username}' \
+            --gmp-password '#{password}' \
+            socket \
+            --xml="<get_reports/>"
+          `
+        )
+
+        report_xml_resp.xpath(
+          "/get_reports_response/report/task[@id='#{task_id}']"
+        ).last.parent.xpath(
+          '@id'
+        ).text
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # PWN::Plugins::OpenVAS.save_report(
+      #   report_type: 'required report type (csv|itg|pdf|txt|xml)',
+      #   report_id: 'required report id to save',
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.save_report(opts = {})
+        report_type = opts[:report_type].to_s.scrub
+        report_id = opts[:report_id].to_s.scrub
+        report_dir = opts[:report_dir].to_s.scrub
+        raise "#{report_dir} Does Not Exist." unless Dir.exist?(
+          report_dir
+        )
+
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        case report_type.to_sym
+        when :csv
+          report_type_name = 'CSV Results'
+        when :itg
+          report_type_name = 'ITG'
+        when :pdf
+          report_type_name = 'PDF'
+        when :txt
+          report_type_name = 'TXT'
+        when :xml
+          report_type_name = 'XML'
+        else
+          raise "Report Type: \"#{report_type}\" not supported."
+        end
+
+        report_formats_xml_resp = Nokogiri::XML(
+          `sudo runuser -u _gvm -- /usr/bin/gvm-cli \
+            --gmp-username '#{username}' \
+            --gmp-password '#{password}' \
+            socket \
+            --xml="<get_report_formats/>"
+          `
+        )
+
+        rpt_fmt_xml_resp_by_name = report_formats_xml_resp.xpath(
+          "/get_report_formats_response/report_format[name/text()='#{report_type_name}']"
+        )
+
+        format_id = rpt_fmt_xml_resp_by_name.xpath('@id').text
+
+        # Generate Report
+        report_xml_resp = Nokogiri::XML(
+          `sudo runuser -u _gvm -- /usr/bin/gvm-cli \
+            --gmp-username '#{username}' \
+            --gmp-password '#{password}' \
+            socket \
+            --xml="<get_reports report_id='#{report_id}' format_id='#{format_id}'/>"
+          `
+        )
+
+        # timestamp = Time.parse(
+        #   report_xml_resp.xpath('//modification_time')
+        # ).localtime.strftime(
+        #   '%Y-%m-%d-%H-%M-%S%z'
+        # )
+
+        base64_report = report_xml_resp.xpath(
+          '//report/text()'
+        ).text
+
+        # File.open("#{report_dir}/openvas_results-#{timestamp}.#{report_type}", 'w') do |f|
+        File.open("#{report_dir}/openvas_results.#{report_type}", 'w') do |f|
+          f.puts Base64.strict_decode64(base64_report)
+        end
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # report_types = PWN::Plugins::OpenVAS.get_report_types(
+      #   username: 'required username',
+      #   password: 'optional password (will prompt if nil)'
+      # )
+
+      public_class_method def self.get_report_types(opts = {})
+        username = opts[:username].to_s.scrub
+
+        password = if opts[:password].nil?
+                     PWN::Plugins::AuthenticationHelper.mask_password
+                   else
+                     opts[:password].to_s.scrub
+                   end
+
+        report_types = %i[
+          csv
+          itg
+          pdf
+          txt
+          xml
+        ]
+      rescue StandardError => e
+        raise e
+      end
+
+      # Author(s):: 0day Inc. <request.pentest@0dayinc.com>
+
+      public_class_method def self.authors
+        "AUTHOR(S):
+          0day Inc. <request.pentest@0dayinc.com>
+        "
+      end
+
+      # Display Usage for this Module
+
+      public_class_method def self.help
+        puts "USAGE:
+          task_xml_resp = #{self}.get_task_id(
+            task_name: 'required task name to start',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          start_task_xml_resp = #{self}.start_task(
+            task_name: 'required task name to start',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          task_status = #{self}.get_task_status(
+            task_name: 'required task name to start',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          last_report_id = #{self}.last_report_id(
+            task_name: 'required task name to start',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          #{self}.save_report(
+            report_type: 'required report type (csv|itg|pdf|txt|xml)',
+            report_id: 'required report id to save',
+            report_dir: 'required directory to save report',
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          report_types = #{self}.get_report_types(
+            username: 'required username',
+            password: 'optional password (will prompt if nil)'
+          )
+
+          #{self}.authors
+        "
+      end
+    end
+  end
+end