pwn 0.4.594 → 0.4.595

data/lib/pwn/plugins/github.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module PWN
-  module Plugins
-    # This plugin is used for interacting w/ Github's REST API using
-    # the 'rest' browser type of PWN::Plugins::TransparentBrowser.
-    module Github
-      @@logger = PWN::Plugins::PWNLogger.create
-
-      # Supported Method Parameters::
-      # github_rest_call(
-      #   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.github_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_gist_api_uri = 'https://api.github.com'
-
-        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
-
-        case http_method
-        when :get
-          response = rest_client.execute(
-            method: :get,
-            url: "#{base_gist_api_uri}/#{rest_call}",
-            headers: {
-              content_type: 'application/json; charset=UTF-8',
-              params: params
-            },
-            verify_ssl: false
-          )
-
-        when :post
-          response = rest_client.execute(
-            method: :post,
-            url: "#{base_gist_api_uri}/#{rest_call}",
-            headers: {
-              content_type: 'application/json; charset=UTF-8',
-              params: params
-            },
-            payload: http_body,
-            verify_ssl: false
-          )
-
-        else
-          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
-        end
-
-        response
-      rescue RestClient::Forbidden
-        raise response
-      rescue RestClient::BadRequest, RestClient::NotFound, StandardError => e
-        raise
-      end
-
-      # Supported Method Parameters::
-      # response_json = PWN::Plugins::Github.download_all_gists(
-      #   username: 'required - username of gists to backup',
-      #   target_dir: 'required - target directory to save respective gists'
-      # )
-
-      public_class_method def self.download_all_gists(opts = {})
-        username = opts[:username].to_s.scrub
-        target_dir = opts[:target_dir].to_s.scrub
-
-        raise "ERROR: #{target_dir} Does Not Exist." unless Dir.exist?(target_dir)
-
-        params = {}
-        page = 1
-        response_json = [{}]
-        while response_json.any?
-          params[:page] = page
-          response_body = github_rest_call(
-            rest_call: "users/#{username}/gists",
-            params: params
-          ).body
-
-          Dir.chdir(target_dir)
-          response_json = JSON.parse(response_body, symbolize_names: true)
-          response_json.each do |gist_hash|
-            clone_dir = gist_hash[:id]
-            clone_uri = gist_hash[:git_pull_url]
-            next if Dir.exist?(clone_dir)
-
-            print "Cloning: #{clone_uri}..."
-            system(
-              'git',
-              'clone',
-              clone_uri
-            )
-            puts 'complete.'
-          end
-
-          page += 1
-        end
-
-        response_json
-      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_json = #{self}.download_all_gists(
-            username: 'required - username of gists to download',
-            target_dir: 'required - target directory to save respective gists'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/hacker_one.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'base64'
-
-module PWN
-  module Plugins
-    # This plugin is used for interacting w/ HackerOne's REST API using
-    # the 'rest' browser type of PWN::Plugins::TransparentBrowser.
-    module HackerOne
-      @@logger = PWN::Plugins::PWNLogger.create
-
-      # Supported Method Parameters::
-      # h1_obj = PWN::Plugins::HackerOne.login(
-      #   username: 'required - username',
-      #   token: 'optional - api token (will prompt if nil)'
-      # )
-
-      public_class_method def self.login(opts = {})
-        username = opts[:username].to_s.scrub
-        base_h1_api_uri = 'https://api.hackerone.com/v1/'.to_s.scrub
-
-        token = if opts[:token].nil?
-                  PWN::Plugins::AuthenticationHelper.mask_password
-                else
-                  opts[:token].to_s.scrub
-                end
-
-        auth_payload = {}
-        auth_payload[:username] = username
-        auth_payload[:token] = token
-
-        base64_str = "#{username}:#{token}"
-        base64_encoded_auth = Base64.strict_encode64(base64_str).to_s.chomp
-        basic_auth_header = "Basic #{base64_encoded_auth}"
-
-        @@logger.info("Logging into HackerOne REST API: #{base_h1_api_uri}")
-        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
-        response = rest_client.execute(
-          method: :get,
-          url: base_h1_api_uri,
-          headers: {
-            authorization: basic_auth_header,
-            content_type: 'application/json; charset=UTF-8'
-          }
-        )
-
-        # Return array containing the post-authenticated HackerOne REST API token
-        json_response = JSON.parse(response, symbolize_names: true)
-        h1_success = json_response['success']
-        api_token = json_response['token']
-        h1_obj = {}
-        h1_obj[:h1_success] = h1_success
-        h1_obj[:api_token] = api_token
-        h1_obj[:raw_response] = response
-
-        h1_obj
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # h1_rest_call(
-      #   h1_obj: 'required h1_obj returned from #login method',
-      #   http_method: 'optional HTTP method (defaults to GET)
-      #   rest_call: 'required rest call to make per the schema',
-      #   http_body: 'optional HTTP body sent in HTTP methods that support it e.g. POST'
-      # )
-
-      private_class_method def self.h1_rest_call(opts = {})
-        h1_obj = opts[:h1_obj]
-        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
-        http_body = opts[:http_body].to_s.scrub
-        h1_success = h1_obj[:h1_success].to_s.scrub
-        base_h1_api_uri = 'https://api.hackerone.com/v1/'.to_s.scrub
-        api_token = h1_obj[:api_token]
-
-        rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
-
-        case http_method
-        when :get
-          response = rest_client.execute(
-            method: :get,
-            url: "#{base_h1_api_uri}/#{rest_call}",
-            headers: {
-              content_type: 'application/json; charset=UTF-8',
-              params: { token: api_token }
-            }
-          )
-
-        when :post
-          response = rest_client.execute(
-            method: :post,
-            url: "#{base_h1_api_uri}/#{rest_call}",
-            headers: {
-              content_type: 'application/json; charset=UTF-8'
-            },
-            payload: http_body
-          )
-
-        else
-          raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
-        end
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Plugins::HackerOne.logout(
-      #   h1_obj: 'required h1_obj returned from #login method'
-      # )
-
-      public_class_method def self.logout(opts = {})
-        h1_obj = opts[:h1_obj]
-        @@logger.info('Logging out...')
-        h1_obj = nil
-      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:
-          h1_obj = #{self}.login(
-            username: 'required username',
-            token: 'optional api token (will prompt if nil)'
-          )
-
-          h1_obj = #{self}.logout(
-            h1_obj: 'required h1_obj returned from #login method'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/plugins/http_intercept_helper.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module PWN
-  module Plugins
-    # This plugin was created to generate UTF-8 characters for fuzzing
-    module HTTPInterceptHelper
-      @@logger = PWN::Plugins::PWNLogger.create
-
-      # Supported Method Parameters::
-      # request_hash = PWN::Plugins::HTTPInterceptHelper.raw_to_hash(
-      #   request_raw: 'required => raw http request string to convert to hash'
-      # )
-
-      public_class_method def self.raw_to_hash(opts = {})
-        request_raw = opts[:request_raw].to_s
-        request_hash = {}
-
-        # Basic Parsing Begins
-        raw_intercepted_request_arr = request_raw.split("\r\n")
-
-        # Parse HTTP Protocol Request Line
-        raw_request_line_arr = raw_intercepted_request_arr[0].split
-        request_hash[:http_method] = raw_request_line_arr[0].to_s.upcase.to_sym
-        request_hash[:http_resource_path] = URI.parse(raw_request_line_arr[1])
-        request_hash[:http_version] = raw_request_line_arr[-1]
-
-        # Begin Parsing HTTP Headers & Body (If Applicable)
-        request_hash[:http_headers] = {}
-
-        case request_hash[:http_method]
-        when :CONNECT,
-             :DELETE,
-             :GET,
-             :HEAD,
-             :OPTIONS,
-             :PATCH,
-             :PUT,
-             :TRACE
-          puts request_hash[:http_method]
-        when :POST
-          # Parse HTTP Headers
-          raw_intercepted_request_arr[1..-1].each do |val|
-            break if val == '' # This may cause issues
-
-            key = ''
-            val.each_char do |char|
-              break if char == ':'
-
-              key = "#{key}#{char}"
-            end
-
-            header_val = val.gsub(/^#{key}:/, '').strip
-
-            request_hash[:http_headers][key.to_sym] = header_val
-          end
-
-          # Parse HTTP Body
-          raw_request_body = []
-          raw_intercepted_request_arr[1..-1].each_with_index do |val, index|
-            next if val != '' # This may cause issues
-
-            break_index = index + 2
-            request_hash[:http_body] = raw_intercepted_request_arr[break_index..-1].join(',')
-          end
-        else
-          raise "HTTP Method: #{request_hash[:http_method]} Currently Unsupported>"
-        end
-
-        request_hash
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # request_raw = PWN::Plugins::HTTPInterceptHelper.hash_to_raw(
-      #   request_hash: 'required => request_hash object returned by #raw_to_hash method'
-      # )
-
-      public_class_method def self.hash_to_raw(opts = {})
-        request_hash = opts[:request_hash]
-
-        # Populate HTTP Request Line
-        request_raw = "#{request_hash[:http_method]} "
-        request_raw = "#{request_raw}#{request_hash[:http_resource_path]} "
-        request_raw = "#{request_raw}#{request_hash[:http_version]}\r\n"
-
-        # Populate HTTP Headers
-        request_hash[:http_headers].each do |key, header_val|
-          request_raw = "#{request_raw}#{key}: #{header_val}\r\n"
-        end
-
-        # Populate HTTP Body (If Applicable)
-        request_raw = "#{request_raw}\r\n"
-        request_raw = "#{request_raw}#{request_hash[:http_body]}" unless request_hash[:http_body] == ''
-      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:
-          request_hash = PWN::Plugins::HTTPInterceptHelper.raw_to_hash(
-            request_raw: 'required => raw http request string to convert to hash'
-          )
-
-          request_raw = PWN::Plugins::HTTPInterceptHelper.hash_to_raw(
-            request_hash: 'required => request_hash object returned by #raw_to_hash method'
-          )
-        "
-      end
-    end
-  end
-end