pwn 0.5.508 → 0.5.509

data/lib/pwn/blockchain/eth.rb

@@ -1,160 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'rest-client'
-require 'tty-spinner'
-
-module PWN
-  module Blockchain
-    # This plugin interacts with BitCoin's Blockchain API.
-    module ETH
-      # Supported Method Parameters::
-      # eth_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',
-      #   timeout: 'optional timeout in seconds (defaults to 180)',
-      #   spinner: 'optional - display spinner (defaults to false)'
-      # )
-
-      private_class_method def self.eth_rest_call(opts = {})
-        http_method = if opts[:http_method].nil?
-                        :get
-                      else
-                        opts[:http_method].to_s.scrub.to_sym
-                      end
-
-        base_uri = 'https://api.blockcypher.com/v1/eth/'
-        rest_call = opts[:rest_call].to_s.scrub
-        params = opts[:params]
-        headers = { content_type: 'application/json; charset=UTF-8' }
-
-        http_body = opts[:http_body]
-        http_body ||= {}
-
-        timeout = opts[:timeout]
-        timeout ||= 180
-
-        spinner = opts[:spinner] || false
-
-        browser_obj = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)
-        rest_client = browser_obj[:browser]::Request
-
-        if spinner
-          spin = TTY::Spinner.new(format: :dots)
-          spin.auto_spin
-        end
-
-        retries = 0
-        case http_method
-        when :delete, :get
-          headers[:params] = params
-          response = rest_client.execute(
-            method: http_method,
-            url: "#{base_uri}#{rest_call}",
-            headers: headers,
-            verify_ssl: false,
-            timeout: timeout
-          )
-
-        when :post
-          if http_body.key?(:multipart)
-            headers[:content_type] = 'multipart/form-data'
-
-            response = rest_client.execute(
-              method: http_method,
-              url: "#{base_uri}#{rest_call}",
-              headers: headers,
-              payload: http_body,
-              verify_ssl: false,
-              timeout: timeout
-            )
-          else
-            response = rest_client.execute(
-              method: http_method,
-              url: "#{base_uri}#{rest_call}",
-              headers: headers,
-              payload: http_body.to_json,
-              verify_ssl: false,
-              timeout: timeout
-            )
-          end
-
-        else
-          raise "Unsupported HTTP Method #{http_method} for #{self} Plugin"
-        end
-
-        response
-      rescue RestClient::ExceptionWithResponse => e
-        case e.http_code
-        when 400, 404
-          "#{e.http_code} #{e.message}: #{e.response.body}"
-        else
-          raise e
-        end
-      rescue StandardError => e
-        raise e
-      ensure
-        spin.stop if spinner
-      end
-
-      # Supported Method Parameters::
-      # latest_block = PWN::Blockchain::ETH.get_latest_block(
-      #   token: 'optional - API token for higher rate limits'
-      # )
-
-      public_class_method def self.get_latest_block(opts = {})
-        params = {}
-        params[:token] = opts[:token] if opts[:token]
-
-        rest_call = 'main'
-        response = eth_rest_call(rest_call: rest_call, params: params)
-
-        JSON.parse(response.body, symbolize_names: true)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Supported Method Parameters::
-      # PWN::Blockchain::ETH.get_block_details(
-      #   height: 'required - block height number',
-      #   token: 'optional - API token for higher rate limits'
-      # )
-      public_class_method def self.get_block_details(opts = {})
-        height = opts[:height]
-        params = {}
-        params[:token] = opts[:token] if opts[:token]
-
-        rest_call = "main/blocks/#{height}"
-        response = eth_rest_call(rest_call: rest_call, params: params)
-
-        JSON.parse(response.body, symbolize_names: true)
-      rescue StandardError => e
-        raise e
-      end
-
-      # Author(s):: 0day Inc. <support@0dayinc.com>
-
-      public_class_method def self.authors
-        "AUTHOR(S):
-          0day Inc. <support@0dayinc.com>
-        "
-      end
-
-      # Display Usage for this Module
-
-      public_class_method def self.help
-        puts "USAGE:
-          latest_block = #{self}.get_latest_block
-
-          block_details = #{self}.get_block_details(
-            height: 'required - block height number'
-          )
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/blockchain.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module PWN
-  # This file, using the autoload directive loads Blockchain modules
-  # into memory only when they're needed. For more information, see:
-  # http://www.rubyinside.com/ruby-techniques-revealed-autoload-1652.html
-  module Blockchain
-    autoload :BTC, 'pwn/blockchain/btc'
-    autoload :ETH, 'pwn/blockchain/eth'
-
-    # Display a List of Every PWN::Blockchain Module
-
-    public_class_method def self.help
-      constants.sort
-    end
-  end
-end

data/lib/pwn/config.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'yaml'
-
-module PWN
-  # Used to manage PWN configuration settings within PWN drivers.
-  module Config
-    # Supported Method Parameters::
-    # env = PWN::Config.default_env(
-    #   pwn_env_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml'
-    # )
-    public_class_method def self.default_env(opts = {})
-      pwn_env_path = opts[:pwn_env_path]
-      pwn_dec_path = "#{pwn_env_path}.decryptor"
-
-      puts "
-        [*] NOTICE:
-        1. Writing minimal PWN::Env to:
-           #{pwn_env_path}
-        2. Your decryptor file will be written to:
-           #{pwn_dec_path}
-        3. Use the pwn-vault command in the pwn prototyping driver to update:
-           #{pwn_env_path}
-        4. For optimal security, it's recommended to move:
-           #{pwn_dec_path}
-           to a secure location and use the --pwn-dec parameter for PWN drivers.
-      "
-      env = {
-        ai: {
-          active: 'grok',
-          introspection: false,
-          grok: {
-            base_uri: 'optional - Base URI for Grok - Use private base OR defaults to https://api.x.ai/v1',
-            key: 'required - OpenAI API Key',
-            model: 'optional - Grok model to use',
-            system_role_content: 'You are an ethically hacking OpenAI agent.',
-            temp: 'optional - OpenAI temperature',
-            max_prompt_length: 256_000
-          },
-          openai: {
-            base_uri: 'optional - Base URI for OpenAI - Use private base OR defaults to https://api.openai.com/v1',
-            key: 'required - OpenAI API Key',
-            model: 'optional - OpenAI model to use',
-            system_role_content: 'You are an ethically hacking OpenAI agent.',
-            temp: 'optional - OpenAI temperature',
-            max_prompt_length: 128_000
-          },
-          ollama: {
-            base_uri: 'required - Base URI for Open WebUI - e.g. https://ollama.local',
-            key: 'required - Open WebUI API Key Under Settings  >> Account >> JWT Token',
-            model: 'required - Ollama model to use',
-            system_role_content: 'You are an ethically hacking Ollama agent.',
-            temp: 'optional - Ollama temperature',
-            max_prompt_length: 32_000
-          }
-        },
-        plugins: {
-          asm: { arch: PWN::Plugins::DetectOS.arch, endian: PWN::Plugins::DetectOS.endian.to_s },
-          blockchain: {
-            bitcoin: {
-              rpc_host: 'localhost',
-              rpc_port: 8332,
-              rpc_user: 'bitcoin RPC Username',
-              rpc_pass: 'bitcoin RPC Password'
-            }
-          },
-          irc: {
-            ui_nick: '_human_',
-            shared_chan: '#pwn',
-            ai_agent_nicks: {
-              browser: {
-                pwn_rb: '/opt/pwn/lib/pwn/plugins/transparent_browser.rb',
-                system_role_content: 'You are a browser.  You are a web browser that can be controlled by a human or AI agent'
-              },
-              nimjeh: {
-                pwn_rb: '',
-                system_role_content: 'You are a sarcastic hacker.  You find software zero day vulnerabilities. This involves analyzing source code, race conditions, application binaries, and network protocols from an offensive security perspective.'
-              },
-              nmap: {
-                pwn_rb: '/opt/pwn/lib/pwn/plugins/nmap_it.rb',
-                system_role_content: 'You are a network scanner.  You are a network scanner that can be controlled by a human or AI agent'
-              },
-              shodan: {
-                pwn_rb: '/opt/pwn/lib/pwn/plugins/shodan.rb',
-                system_role_content: 'You are a passive reconnaissance agent.  You are a passive reconnaissance agent that can be controlled by a human or AI agent'
-              }
-            }
-          },
-          hunter: { api_key: 'hunter.how API Key' },
-          jira_data_center: {
-            base_uri: 'Jira Server Base API URI (e.g. https://jira.company.com/rest/api/latest)',
-            token: 'Jira Server API Token'
-          },
-          meshtastic: {
-            admin_key: 'Public key authorized to send admin messages to nodes',
-            serial: {
-              port: '/dev/ttyUSB0',
-              baud: 115_200,
-              bits: 8,
-              stop: 1,
-              parity: :none
-            },
-            mqtt: {
-              host: 'mqtt.meshtastic.org',
-              port: 1883,
-              tls: false,
-              user: 'meshdev',
-              pass: 'large4cats'
-            },
-            channel: {
-              active: 'LongFast',
-              LongFast: {
-                psk: 'AQ==',
-                region: 'US/<STATE>',
-                topic: '2/e/#',
-                channel_num: 8
-              },
-              PWN: {
-                psk: 'required - PSK for pwn channel',
-                region: 'US/<STATE>',
-                topic: '2/e/PWN/#',
-                channel_num: 99
-              }
-            }
-          },
-          shodan: { api_key: 'SHODAN API Key' }
-        }
-      }
-
-      # Remove beginning colon from key names
-      yaml_env = YAML.dump(env).gsub(/^(\s*):/, '\1')
-      File.write(pwn_env_path, yaml_env)
-      # Change file permission to 600
-      File.chmod(0o600, pwn_env_path)
-
-      env[:driver_opts] = {
-        pwn_env_path: pwn_env_path,
-        pwn_dec_path: pwn_dec_path
-      }
-
-      PWN::Plugins::Vault.create(
-        file: pwn_env_path,
-        decryptor_file: pwn_dec_path
-      )
-
-      Pry.config.refresh_pwn_env = false if defined?(Pry)
-      PWN.send(:remove_const, :Env) if PWN.const_defined?(:Env)
-      PWN.const_set(:Env, env.freeze)
-    rescue StandardError => e
-      raise e
-    end
-
-    # Supported Method Parameters::
-    # PWN::Config.redact_sensitive_artifacts(
-    #   config: 'optional - Hash to redact sensitive artifacts from.  Defaults to PWN::Env'
-    # )
-    public_class_method def self.redact_sensitive_artifacts(opts = {})
-      config = opts[:config] ||= PWN::Env
-
-      sensitive_keys = %i[api_key key pass password psk token]
-
-      # Transform values at the current level: redact sensitive keys
-      config.transform_values.with_index do |v, k|
-        if sensitive_keys.include?(config.keys[k])
-          '>>> REDACTED >>> USE `pwn-vault` FOR ADMINISTRATION <<< REDACTED <<<'
-        else
-          v.is_a?(Hash) ? redact_sensitive_artifacts(config: v) : v
-        end
-      end
-    rescue StandardError => e
-      raise e
-    end
-
-    # Supported Method Parameters::
-    # env = PWN::Config.init_driver_options
-    public_class_method def self.init_driver_options
-      env = {
-        driver_opts: {
-          pwn_env_path: nil,
-          pwn_dec_path: nil
-        }
-      }
-      PWN.const_set(:Env, env)
-      # puts '[*] Loaded driver options.'
-    rescue StandardError => e
-      raise e
-    end
-
-    # Supported Method Parameters::
-    # PWN::Config.refresh_env(
-    #   pwn_env_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml',
-    #   pwn_dec_path: 'optional - Path to pwn.yaml.decryptor file.  Defaults to ~/.pwn/pwn.yaml.decryptor'
-    # )
-
-    public_class_method def self.refresh_env(opts = {})
-      pwn_env_root = "#{Dir.home}/.pwn"
-      FileUtils.mkdir_p(pwn_env_root)
-
-      pwn_env_path = opts[:pwn_env_path] ||= "#{pwn_env_root}/pwn.yaml"
-      return default_env(pwn_env_path: pwn_env_path) unless File.exist?(pwn_env_path)
-
-      is_encrypted = PWN::Plugins::Vault.file_encrypted?(file: pwn_env_path)
-      raise "PWN Environment (#{pwn_env_path}) is not encrypted!  Use PWN::Vault.create(file: '#{pwn_env_path}', decryptor_file: '#{pwn_env_path}.decryptor') to encrypt it." unless is_encrypted
-
-      pwn_dec_path = opts[:pwn_dec_path] ||= "#{pwn_env_path}.decryptor"
-      raise "PWN Decryptor (#{pwn_dec_path}) does not exist!" unless File.exist?(pwn_dec_path)
-
-      pwn_decryptor = YAML.load_file(pwn_dec_path, symbolize_names: true)
-
-      key = opts[:key] ||= pwn_decryptor[:key] ||= ENV.fetch('PWN_DECRYPTOR_KEY')
-      key = PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Decryption Key') if key.nil?
-
-      iv = opts[:iv] ||= pwn_decryptor[:iv] ||= ENV.fetch('PWN_DECRYPTOR_IV')
-      iv = PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Decryption IV') if iv.nil?
-
-      env = PWN::Plugins::Vault.dump(
-        file: pwn_env_path,
-        key: key,
-        iv: iv
-      )
-
-      valid_ai_engines = PWN::AI.help.reject { |e| e.downcase == :introspection }.map(&:downcase)
-
-      engine = env[:ai][:active].to_s.downcase.to_sym
-      raise "ERROR: Unsupported AI Engine: #{engine} in #{pwn_env_path}.  Supported AI Engines:\n#{valid_ai_engines.inspect}" unless valid_ai_engines.include?(engine)
-
-      key = env[:ai][engine][:key]
-      if key.nil?
-        key = PWN::Plugins::AuthenticationHelper.mask_password(
-          prompt: "#{engine} API Key"
-        )
-        env[:ai][engine][:key] = key
-      end
-
-      model = env[:ai][engine][:model]
-      system_role_content = env[:ai][engine][:system_role_content]
-
-      # Reset the ai response history on env refresh
-      env[:ai][engine][:response_history] = {
-        id: '',
-        object: '',
-        model: model,
-        usage: {},
-        choices: [
-          {
-            role: 'system',
-            content: system_role_content
-          }
-        ]
-      }
-
-      # These two lines should be immutable for the session
-      env[:driver_opts] = {
-        pwn_env_path: pwn_env_path,
-        pwn_dec_path: pwn_dec_path
-      }
-
-      # Assign the refreshed env to PWN::Env
-      PWN.send(:remove_const, :Env) if PWN.const_defined?(:Env)
-      PWN.const_set(:Env, env.freeze)
-
-      # Redact sensitive artifacts from PWN::Env and store in PWN::EnvRedacted
-      env_redacted = redact_sensitive_artifacts(config: env)
-      PWN.send(:remove_const, :EnvRedacted) if PWN.const_defined?(:EnvRedacted)
-      PWN.const_set(:EnvRedacted, env_redacted.freeze)
-
-      Pry.config.refresh_pwn_env = false if defined?(Pry)
-
-      puts "[*] PWN::Env loaded via: #{pwn_env_path}\n"
-    rescue StandardError => e
-      raise e
-    end
-
-    # Author(s):: 0day Inc. <support@0dayinc.com>
-
-    public_class_method def self.authors
-      "AUTHOR(S):
-        0day Inc. <support@0dayinc.com>
-      "
-    end
-
-    # Display Usage for this Module
-
-    public_class_method def self.help
-      puts "USAGE:
-        #{self}.default_env(
-          pwn_env_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml'
-        )
-
-        #{self}.redact_sensitive_artifacts(
-          config: 'optional - Hash to redact sensitive artifacts from.  Defaults to PWN::Env'
-        )
-
-        #{self}.refresh_env(
-          pwn_env_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml',
-        pwn_dec_path: 'optional - Path to pwn.yaml.decryptor file.  Defaults to ~/.pwn/pwn.yaml.decryrptor'
-        )
-
-        #{self}.authors
-      "
-    end
-  end
-end

data/lib/pwn/driver.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'optparse'
-
-module PWN
-  # Used to consume options passed into PWN drivers and load PWN::Env
-  class Driver
-    # Add OptionParser options to PWN::Env
-    class Parser < OptionParser
-      attr_accessor :auto_opts_help,
-                    :opts
-
-      def initialize
-        super
-        @opts = PWN::Env[:driver_opts]
-        @auto_opts_help = true
-
-        banner = "USAGE: #{File.basename($PROGRAM_NAME)} [opts]\n"
-        on(
-          '-YPATH',
-          '--pwn_env=PATH',
-          '<Optional - PWN::Env YAML file path (Default: ~/.pwn/pwn.yaml)>'
-        ) do |o|
-          @opts[:pwn_env_path] = o
-        end
-        on(
-          '-ZPATH',
-          '--pwn_dec=PATH',
-          '<Optional - Out-of-Band YAML file path (Default: ~/.pwn/pwn.decryptor.yaml)>'
-        ) do |o|
-          @opts[:pwn_dec_path] = o
-        end
-      end
-
-      def parse!
-        super(ARGV, into: @opts)
-        # puts @opts
-
-        PWN::Config.refresh_env(
-          pwn_env_path: @opts[:pwn_env_path],
-          pwn_dec_path: @opts[:pwn_dec_path]
-        )
-
-        if @auto_opts_help && @opts.keys.join(' ') == 'pwn_env_path pwn_dec_path'
-          puts `#{File.basename($PROGRAM_NAME)} --help`
-          exit 1
-        end
-      end
-    end
-
-    # Author(s):: 0day Inc. <support@0dayinc.com>
-
-    public_class_method def self.authors
-      "AUTHOR(S):
-        0day Inc. <support@0dayinc.com>
-      "
-    end
-
-    # Display Usage for this Module
-
-    public_class_method def self.help
-      puts "USAGE:
-        # Load default driver options into PWN::Env
-        opts = PWN::Env[:driver_opts]
-        #{self}::Parser.new.parse(&:on).parse!
-
-        # Add more options by passing a block to the parser
-        opts = PWN::Env[:driver_opts]
-        #{self}::Parser.new do |options|
-          # Boolean option
-          options.on('-b', '--boolean') do |o|
-            opts[:boolean] = o
-          end
-
-          # String option
-          options.on('-sSTRING', '--string=STRING') do |o|
-            opts[:string] = o
-          end
-        end.parse!
-
-        #{self}.authors
-      "
-    end
-  end
-end

data/lib/pwn/ffi/stdio.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'ffi'
-
-PubFFI = FFI
-module PWN
-  module FFI
-    # This plugin is a wrapper for the standard I/O functions in libc.
-    module Stdio
-      extend PubFFI::Library
-
-      ffi_lib PubFFI::Library::LIBC
-
-      attach_function(:puts, [:string], :int)
-      attach_function(:printf, %i[string varargs], :int, convention: :default)
-      attach_function(:scanf, %i[string varargs], :int)
-
-      # Author(s):: 0day Inc. <support@0dayinc.com>
-
-      public_class_method def self.authors
-        "AUTHOR(S):
-          0day Inc. <support@0dayinc.com>
-        "
-      end
-
-      # Display Usage for this Module
-
-      public_class_method def self.help
-        puts "USAGE:
-          #{self}.puts string
-          #{self}.printf(\"format string\", str, int, etc)
-
-          scanf_buffer = FFI::MemoryPointer.new(:char, 100)
-          #{self}.scanf(\"format string\", scanf_buffer)
-
-          #{self}.authors
-        "
-      end
-    end
-  end
-end

data/lib/pwn/ffi.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module PWN
-  # This file, using the autoload directive loads FFI modules
-  # into memory only when they're needed. For more information, see:
-  # http://www.rubyinside.com/ruby-techniques-revealed-autoload-1652.html
-  module FFI
-    autoload :Stdio, 'pwn/ffi/stdio'
-
-    # Display a List of Every PWN::FFI Module
-
-    public_class_method def self.help
-      constants.sort
-    end
-  end
-end