pwn 0.5.429 → 0.5.430

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d62d95361763fc4363d172024859e5fc8cc9ea1b96b2765a37c679b468c9a22f
-  data.tar.gz: 8def884e714ec444f10fae2c952087acb64fc4c5f06bef088f19e3f0a39fc157
+  metadata.gz: eecc95f7ab850f845600203b3fed19bb77d5d3737233a7f7f98df09b84154737
+  data.tar.gz: d838e72b716e9fc50e604a95600f1c9e43db9a42772e76073adc2f4cd673e96b
 SHA512:
-  metadata.gz: d46e4790ac2a3023a6210d77641c530226127429000c3994919750fcefa3a4610b0bf7390d4790be85081a9a7846c88e1bfa6ebda334375922276678239066cc
-  data.tar.gz: 2f96f89617d314c6f1b9094580890b67a9b722fd9a58ee8e05642ba7c8bdd51e8f598f3e7c2cc3df267da05ba77efebbb23e29e15ccd684414b385531cad122c
+  metadata.gz: 81dea57ae53b6401b7b5fa2784d5dc64e8b2a311ad1fc89c20c18e1024739ed66502db92be54ece95695df3b7a3fb25bbacd3aa311ac69d71bf5c2f4b23496c6
+  data.tar.gz: 071b3ac7ac65e4f282e3f59d223ec4c68c2f9b61b62442e613b4aa347ed6ab836cca10eafee0a148b79446c2adaf3e1a5bf60107b4871165d04d3017ef7b2fb3

data/README.md

@@ -37,7 +37,7 @@ $ cd /opt/pwn
 $ ./install.sh
 $ ./install.sh ruby-gem
 $ pwn
-pwn[v0.5.429]:001 >>> PWN.help
+pwn[v0.5.430]:001 >>> PWN.help
 ```
 
 [![Installing the pwn Security Automation Framework](https://raw.githubusercontent.com/0dayInc/pwn/master/documentation/pwn_install.png)](https://youtu.be/G7iLUY4FzsI)
@@ -52,7 +52,7 @@ $ rvm use ruby-3.4.4@pwn
 $ gem uninstall --all --executables pwn
 $ gem install --verbose pwn
 $ pwn
-pwn[v0.5.429]:001 >>> PWN.help
+pwn[v0.5.430]:001 >>> PWN.help
 ```
 
 If you're using a multi-user install of RVM do:
@@ -62,7 +62,7 @@ $ rvm use ruby-3.4.4@pwn
 $ rvmsudo gem uninstall --all --executables pwn
 $ rvmsudo gem install --verbose pwn
 $ pwn
-pwn[v0.5.429]:001 >>> PWN.help
+pwn[v0.5.430]:001 >>> PWN.help
 ```
 
 PWN periodically upgrades to the latest version of Ruby which is reflected in `/opt/pwn/.ruby-version`.  The easiest way to upgrade to the latest version of Ruby from a previous PWN installation is to run the following script:

data/bin/pwn

@@ -10,12 +10,12 @@ OptionParser.new do |options|
     #{File.basename($PROGRAM_NAME)} [opts]
   "
 
-  options.on('-cPATH', '--yaml-config=PATH', '<Optional - PWN YAML File>') do |p|
-    opts[:yaml_config_path] = p
+  options.on('-YPATH', '--pwn-config=PATH', '<Optional - PWN YAML File>') do |p|
+    opts[:pwn_config_path] = p
   end
 
-  options.on('-dPATH', '--yaml-decryptor=PATH', '<Optional - Out-of-Band YAML File with :key && :iv>') do |d|
-    opts[:yaml_decryptor_path] = d
+  options.on('-ZPATH', '--pwn-decryptor=PATH', '<Optional - Out-of-Band YAML File with :key && :iv>') do |d|
+    opts[:pwn_decryptor_path] = d
   end
 end.parse!
 

data/bin/pwn_sast

@@ -11,6 +11,15 @@ OptionParser.new do |options|
     #{File.basename($PROGRAM_NAME)} [opts]
   "
 
+  # TODO: HOW TO LOAD THE pwn.yaml CONFIGURATION FILE FOR EVERYTHING UNLESS OVERRIDDEN???
+  options.on('-YPATH', '--pwn-config=PATH', '<Optional - PWN YAML File>') do |p|
+    opts[:pwn_config_path] = p
+  end
+
+  options.on('-ZPATH', '--pwn-decryptor=PATH', '<Optional - Out-of-Band YAML File with :key && :iv>') do |d|
+    opts[:pwn_decryptor_path] = d
+  end
+
   options.on('-uGITURI', '--uri-source-root=GITURI', '<Required - HTTP URI of Git Repo Scanned e.g. https://github.com/0dayInc/pwn/tree/master>') do |u|
     opts[:uri_source_root] = u
   end
@@ -35,30 +44,6 @@ OptionParser.new do |options|
     opts[:report_name] = n
   end
 
-  options.on('-aENGINE', '--ai-engine=ENGINE', '<Optional AI Engine to Analyze Results (grok, ollama, openai) [WARNING: CAN DRAMATICALLY INCREASE AI USAGE COSTS AND/OR SCAN DURATIONS]>') do |a|
-    opts[:ai_engine] = a
-  end
-
-  options.on('-bURI', '--ai-base-uri=URI', '<Optional AI Base API URI (Only Required for "ollama" AI Engine.  Supported by other LLMs when hosted privately)>') do |b|
-    opts[:ai_base_uri] = b
-  end
-
-  options.on('-mMODEL', '--ai-model=MODEL', '<Optional AI Model to Use for Respective AI Engine (e.g., grok-4-0709, grok-3-mini-fast, gpt5-chat-latest, chargpt-4o-latest, llama-3.1, etc.)>') do |m|
-    opts[:ai_model] = m
-  end
-
-  options.on('-kTOKEN', '--ai-key=TOKEN', '<Optional AI Key/Token for Respective AI Engine>') do |k|
-    opts[:ai_key] = k
-  end
-
-  options.on('-SCONTENT', '--ai-system-content=CONTENT', '<Optional AI System Role Content for Respective AI Engine (Defaults to, "Confidence score of 0-10 this is vulnerable (0 being not vulnerable, moving upwards in confidence of exploitation). Provide additional context to assist penetration tester assessment.")>') do |s|
-    opts[:ai_system_role_content] = s
-  end
-
-  options.on('-FTEMP', '--ai-temp=TEMP', '<Optional AI Temperature for Respective AI Engine (Default 0.9)>') do |t|
-    opts[:ai_temp] = t
-  end
-
   options.on('-s', '--[no-]start-reporting-server', '<Optional - Start Simple HTTP Server for Reporting>') do |s|
     opts[:start_reporting_server] = s
   end
@@ -71,6 +56,16 @@ end
 
 begin
   timestamp = Time.now.strftime('%Y-%m-%d_%H:%M:%S%z')
+
+  pwn_config_path = opts[:pwn_config_path]
+  pwn_decryptor_path = opts[:pwn_decryptor_path]
+  if pwn_config_path
+    PWN::Config.refresh(
+      pwn_config_path: pwn_config_path,
+      pwn_decryptor_path: pwn_decryptor_path
+    )
+  end
+
   previous_dir = Dir.pwd
 
   pwn_provider = 'ruby-gem'
@@ -95,23 +90,6 @@ begin
   report_name ||= "#{File.basename(Dir.pwd)}-#{timestamp}" if dir_path == '.'
   report_name ||= "#{File.basename(dir_path)}-#{timestamp}" unless dir_path == '.'
 
-  ai_engine = opts[:ai_engine]
-  if ai_engine
-    ai_engine = ai_engine.to_s.to_sym
-    valid_ai_engines = %i[grok ollama openai]
-    raise "ERROR: Invalid AI Engine. Valid options are: #{valid_ai_engines.join(', ')}" unless valid_ai_engines.include?(ai_engine)
-
-    ai_base_uri = opts[:ai_base_uri]
-    raise 'ERROR: --base-uri Parameter for Ollama AI engine is required.' if ai_engine == :ollama && ai_base_uri.nil?
-
-    ai_model = opts[:ai_model]
-    raise 'ERROR: AI Model is required for AI engine ollama.' if ai_engine == :ollama && ai_model.nil?
-
-    ai_key = opts[:ai_key] ||= PWN::Plugins::AuthenticationHelper.mask_password(prompt: "#{ai_engine} Token")
-    ai_system_role_content = opts[:ai_system_role_content]
-    ai_temp = opts[:ai_temp]
-  end
-
   start_reporting_server = opts[:start_reporting_server]
 
   # Define Test Cases to Run & Start Thread Pool
@@ -202,13 +180,7 @@ begin
   PWN::Reports::SAST.generate(
     dir_path: dir_path,
     results_hash: results_hash,
-    report_name: report_name,
-    ai_engine: ai_engine,
-    ai_model: ai_model,
-    ai_key: ai_key,
-    ai_base_uri: ai_base_uri,
-    ai_system_role_content: ai_system_role_content,
-    ai_temp: ai_temp
+    report_name: report_name
   )
   puts 'complete.'
 

data/etc/pwn.yaml.EXAMPLE

@@ -2,6 +2,9 @@
 # Use PWN::Plugins::Vault.create(file: 'pwn.yaml') to encrypt this file
 
 # ai_engine: 'openai' || 'ollama'
+# WARNING::
+# If PWN::CONFIG[:ai][:instrospection] = true, the active ai agent will be used
+# wherever possible throughout pwn. Proceeds with caution, as this may incur additional costs
 ai:
   active: 'grok'
   introspection: false

data/lib/pwn/ai/grok.rb

@@ -25,6 +25,13 @@ module PWN
 
       private_class_method def self.grok_rest_call(opts = {})
         token = opts[:token]
+        if token.nil?
+          PWN::Plugins::AuthenticationHelper.mask_password(
+            prompt: 'Grok Key'
+          )
+          PWN::CONFIG[:ai][:grok][:key] = token
+        end
+
         http_method = if opts[:http_method].nil?
                         :get
                       else

data/lib/pwn/ai/ollama.rb

@@ -27,6 +27,13 @@ module PWN
       private_class_method def self.ollama_rest_call(opts = {})
         base_uri = opts[:base_uri]
         token = opts[:token]
+        if token.nil?
+          PWN::Plugins::AuthenticationHelper.mask_password(
+            prompt: 'Ollama Key'
+          )
+          PWN::CONFIG[:ai][:ollama][:key] = token
+        end
+
         http_method = if opts[:http_method].nil?
                         :get
                       else

data/lib/pwn/ai/open_ai.rb

@@ -26,6 +26,13 @@ module PWN
 
       private_class_method def self.open_ai_rest_call(opts = {})
         token = opts[:token]
+        if token.nil?
+          PWN::Plugins::AuthenticationHelper.mask_password(
+            prompt: 'OpenAI Key'
+          )
+          PWN::CONFIG[:ai][:openai][:key] = token
+        end
+
         http_method = if opts[:http_method].nil?
                         :get
                       else

data/lib/pwn/config.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module PWN
+  # Used to manage PWN configuration settings within PWN drivers.
+  module Config
+    # Supported Method Parameters::
+    # PWN::Config.refresh(
+    #   pwn_config_path: 'optional - Path to pwn.yaml file.  Defaults to ~/.pwn/pwn.yaml',
+    #   pwn_decryptor_path: 'optional - Path to pwn.decryptor.yaml file.  Defaults to ~/.pwn/pwn.decryptor.yaml'
+    # )
+
+    public_class_method def self.refresh(opts = {})
+      pwn_config_root = "#{Dir.home}/.pwn"
+      FileUtils.mkdir_p(pwn_config_root)
+
+      pwn_config_path = opts[:pwn_config_path] ||= "#{pwn_config_root}/pwn.yaml"
+      raise "PWN Config (#{pwn_config_path}) does not exist!" unless File.exist?(pwn_config_path)
+
+      is_encrypted = PWN::Plugins::Vault.file_encrypted?(file: pwn_config_path)
+
+      if is_encrypted
+        pwn_decryptor_path = opts[:pwn_decryptor_path] ||= "#{pwn_config_root}/pwn.decryptor.yaml"
+        raise "PWN Decryptor (#{pwn_decryptor_path}) does not exist!" unless File.exist?(pwn_decryptor_path)
+
+        pwn_decryptor = YAML.load_file(pwn_decryptor_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?
+
+        config = PWN::Plugins::Vault.dump(
+          file: pwn_config_path,
+          key: key,
+          iv: iv
+        )
+      else
+        config = YAML.load_file(pwn_config_path, symbolize_names: true)
+      end
+
+      valid_ai_engines = %i[
+        grok
+        openai
+        ollama
+      ]
+
+      engine = config[:ai][:active].to_s.downcase.to_sym
+      raise "ERROR: Unsupported AI Engine: #{engine} in #{pwn_config_path}.  Supported AI Engines:\n#{valid_ai_engines.inspect}" unless valid_ai_engines.include?(engine)
+
+      model = config[:ai][engine][:model]
+      system_role_content = config[:ai][engine][:system_role_content]
+
+      # Reset the ai response history on config refresh
+      config[: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
+      config[:pwn_config_path] = pwn_config_path
+      config[:pwn_decryptor_path] = pwn_decryptor_path if is_encrypted
+
+      Pry.config.refresh = false if defined?(Pry)
+
+      PWN.send(:remove_const, :CONFIG) if PWN.const_defined?(:CONFIG)
+      PWN.const_set(:CONFIG, config)
+    end
+  end
+end

data/lib/pwn/plugins/repl.rb

@@ -18,11 +18,7 @@ module PWN
         mode = opts[:mode]
 
         proc do |_target_self, _nest_level, pi|
-          if Pry.config.refresh
-            # puts "Refreshing PWN env via #{opts[:yaml_config_path]}"
-            opts[:pi] = pi
-            PWN::Plugins::Vault.refresh_config(opts)
-          end
+          pi.config.pwn = PWN::Config.refresh(opts) if Pry.config.refresh
 
           pi.config.pwn_repl_line += 1
           line_pad = format(
@@ -464,24 +460,24 @@ module PWN
 
           def process
             pi = pry_instance
-            yaml_config_path = pi.config.yaml_config_path ||= "#{Dir.home}/.pwn/pwn.yaml"
-            unless File.exist?(yaml_config_path)
-              puts "ERROR: pwn.yaml not found: #{yaml_config_path}"
+            pwn_config_path = pi.config.pwn_config_path ||= "#{Dir.home}/.pwn/pwn.yaml"
+            unless File.exist?(pwn_config_path)
+              puts "ERROR: pwn.yaml not found: #{pwn_config_path}"
               return
             end
 
-            yaml_decryptor_path = pi.config.yaml_decryptor_path ||= "#{Dir.home}/.pwn/pwn.decryptor.yaml"
-            unless File.exist?(yaml_decryptor_path)
-              puts "ERROR: pwn.decryptor.yaml not found: #{yaml_decryptor_path}"
+            pwn_decryptor_path = pi.config.pwn_decryptor_path ||= "#{Dir.home}/.pwn/pwn.decryptor.yaml"
+            unless File.exist?(pwn_decryptor_path)
+              puts "ERROR: pwn.decryptor.yaml not found: #{pwn_decryptor_path}"
               return
             end
 
-            decryptor = YAML.load_file(yaml_decryptor_path, symbolize_names: true)
+            decryptor = YAML.load_file(pwn_decryptor_path, symbolize_names: true)
             key = decryptor[:key]
             iv = decryptor[:iv]
 
             PWN::Plugins::Vault.edit(
-              file: yaml_config_path,
+              file: pwn_config_path,
               key: key,
               iv: iv
             )
@@ -539,9 +535,7 @@ module PWN
 
         # Initialize pwn.yaml Configuration using :before_session Hook
         Pry.config.hooks.add_hook(:before_session, :init_opts) do |_output, _binding, pi|
-          # puts "Refreshing PWN env via #{opts[:yaml_config_path]}"
-          opts[:pi] = pi
-          PWN::Plugins::Vault.refresh_config(opts)
+          pi.config.pwn = PWN::Config.refresh(opts)
         end
 
         Pry.config.hooks.add_hook(:after_read, :pwn_asm_hook) do |request, pi|
@@ -588,13 +582,6 @@ module PWN
             engine = pi.config.pwn[:ai][:active].to_s.downcase.to_sym
             base_uri = pi.config.pwn[:ai][engine][:base_uri]
             key = pi.config.pwn[:ai][engine][:key] ||= ''
-            if key.empty?
-              key = PWN::Plugins::AuthenticationHelper.mask_password(
-                prompt: 'pwn-ai Key'
-              )
-              pi.config.pwn[:ai][engine][:key] = key
-            end
-
             response_history = pi.config.pwn[:ai][engine][:response_history]
             speak_answer = pi.config.pwn_ai_speak
             model = pi.config.pwn[:ai][engine][:model]
@@ -683,16 +670,10 @@ module PWN
       public_class_method def self.start(opts = {})
         # Monkey Patch Pry, add commands, && hooks
         PWN::Plugins::MonkeyPatch.pry
-        add_commands
-
         pwn_config_root = "#{Dir.home}/.pwn"
-        FileUtils.mkdir_p(pwn_config_root)
-
         Pry.config.history_file = "#{pwn_config_root}/pwn_history"
 
-        opts[:yaml_config_path] ||= "#{pwn_config_root}/pwn.yaml"
-        opts[:yaml_decryptor_path] ||= "#{pwn_config_root}/pwn.decryptor.yaml"
-
+        add_commands
         add_hooks(opts)
 
         # Define PS1 Prompt

data/lib/pwn/plugins/vault.rb

@@ -15,7 +15,7 @@ module PWN
       #   iv: 'required - iv to decrypt'
       # )
 
-      def self.refresh_encryption_secrets(opts = {})
+      public_class_method def self.refresh_encryption_secrets(opts = {})
         file = opts[:file].to_s.scrub if File.exist?(opts[:file].to_s.scrub)
         key = opts[:key]
         iv = opts[:iv]
@@ -234,83 +234,6 @@ module PWN
         raise e
       end
 
-      # Supported Method Parameters::
-      # PWN::Plugins::Vault.refresh_config(
-      #    yaml_config_path: 'required - full path to pwn.yaml file',
-      #    pi: 'optional - Pry instance (default: Pry)',
-      #    yaml_decryptor_path: 'optional - full path to decryption YAML file'
-      #  )
-      public_class_method def self.refresh_config(opts = {})
-        yaml_config_path = opts[:yaml_config_path]
-
-        return false unless File.exist?(yaml_config_path)
-
-        pi = opts[:pi]
-        raise 'ERROR: Pry instance is required.' if pi.nil?
-
-        is_encrypted = PWN::Plugins::Vault.file_encrypted?(file: yaml_config_path)
-
-        if is_encrypted
-          # TODO: Implement "something you know, something you have, && something you are?"
-          yaml_decryptor_path = opts[:yaml_decryptor_path] ||= "#{Dir.home}/.pwn/pwn.decryptor.yaml"
-          raise "ERROR: #{yaml_decryptor_path} does not exist." unless File.exist?(yaml_decryptor_path)
-
-          yaml_decryptor = YAML.load_file(yaml_decryptor_path, symbolize_names: true)
-
-          key = opts[:key] ||= yaml_decryptor[:key] ||= ENV.fetch('PWN_DECRYPTOR_KEY')
-          key = PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Decryption Key') if key.nil?
-
-          iv = opts[:iv] ||= yaml_decryptor[:iv] ||= ENV.fetch('PWN_DECRYPTOR_IV')
-          iv = PWN::Plugins::AuthenticationHelper.mask_password(prompt: 'Decryption IV') if iv.nil?
-
-          yaml_config = PWN::Plugins::Vault.dump(
-            file: yaml_config_path,
-            key: key,
-            iv: iv
-          )
-        else
-          yaml_config = YAML.load_file(yaml_config_path, symbolize_names: true)
-        end
-
-        valid_ai_engines = %i[
-          grok
-          openai
-          ollama
-        ]
-
-        # Convert ai_engine to symbol and downcase to ensure stability
-        pi.config.pwn = yaml_config
-        engine = pi.config.pwn[:ai][:active].to_s.downcase.to_sym
-        raise "ERROR: Unsupported AI Engine: #{engine} in #{yaml_config_path}.  Supported AI Engines:\n#{valid_ai_engines.inspect}" unless valid_ai_engines.include?(engine)
-
-        model = pi.config.pwn[:ai][engine][:model]
-        system_role_content = pi.config.pwn[:ai][engine][:system_role_content]
-
-        # Reset the ai response history on config refresh
-        pi.config.pwn[: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
-        pi.config.pwn[:yaml_config_path] = yaml_config_path
-        pi.config.pwn[:yaml_decryptor_path] = yaml_decryptor_path if is_encrypted
-
-        Pry.config.refresh = false
-
-        true
-      rescue StandardError => e
-        raise e
-      end
-
       # Author(s):: 0day Inc. <support@0dayinc.com>
 
       public_class_method def self.authors
@@ -363,12 +286,6 @@ module PWN
             file: 'required - file to check if encrypted'
           )
 
-          #{self}.refresh_config(
-            yaml_config_path: 'required - full path to pwn.yaml file',
-            pi: 'optional - Pry instance (default: Pry)',
-            yaml_decryptor_path: 'optional - full path to decryption YAML file'
-          )
-
           #{self}.authors
         "
       end

data/lib/pwn/reports/sast.rb

@@ -14,13 +14,7 @@ module PWN
       # PWN::Reports::SAST.generate(
       #   dir_path: 'optional - Directory path to save the report (defaults to .)',
       #   results_hash: 'optional - Hash containing the results of the SAST analysis (defaults to empty hash structure)',
-      #   report_name: 'optional - Name of the report file (defaults to current directory name)',
-      #   ai_engine: 'optional - AI engine to use for analysis (:grok, :ollama, or :openai)',
-      #   ai_model: 'optionnal - AI Model to Use for Respective AI Engine (e.g., grok-4i-0709, chargpt-4o-latest, llama-3.1, etc.)',
-      #   ai_key: 'optional -  AI Key/Token for Respective AI Engine',
-      #   ai_base_uri: 'optional -  AI FQDN (Only Required for "ollama" AI Engine)',
-      #   ai_system_role_content: 'optional - AI System Role Content (Defaults to "Confidence score of 0-10 this is vulnerable (0 being not vulnerable, moving upwards in confidence of exploitation). Provide additional context to assist penetration tester assessment.")',
-      #   ai_temp: 'optional - AI Temperature (Defaults to 0.1)'
+      #   report_name: 'optional - Name of the report file (defaults to current directory name)'
       # )
 
       public_class_method def self.generate(opts = {})
@@ -31,28 +25,21 @@ module PWN
         }
         report_name = opts[:report_name] ||= File.basename(Dir.pwd)
 
-        ai_engine = opts[:ai_engine]
-        if ai_engine
-          ai_engine = ai_engine.to_s.to_sym
-          valid_ai_engines = %i[grok ollama openai]
-          raise "ERROR: Invalid AI Engine. Valid options are: #{valid_ai_engines.join(', ')}" unless valid_ai_engines.include?(ai_engine)
+        ai_instrospection = PWN::CONFIG[:ai][:introspection]
+        if ai_instrospection
+          engine = PWN::CONFIG[:ai][:active].to_s.downcase.to_sym
+          base_uri = PWN::CONFIG[:ai][engine][:base_uri]
+          model = PWN::CONFIG[:ai][engine][:model]
+          key = PWN::CONFIG[:ai][engine][:key]
+          system_role_content = PWN::CONFIG[:ai][engine][:system_role_content]
+          temp = PWN::CONFIG[:ai][engine][:temp]
 
-          ai_base_uri = opts[:ai_base_uri]
-          raise 'ERROR: FQDN for Ollama AI engine is required.' if ai_engine == :ollama && ai_base_uri.nil?
-
-          ai_model = opts[:ai_model]
-          raise 'ERROR: AI Model is required for AI engine ollama.' if ai_engine == :ollama && ai_model.nil?
-
-          ai_key = opts[:ai_key] ||= PWN::Plugins::AuthenticationHelper.mask_password(prompt: "#{ai_engine} Token")
-          ai_system_role_content = opts[:ai_system_role_content] ||= 'Your sole purpose is to analyze source code snippets and generate an Exploit Prediction Scoring System (EPSS) score between 0% - 100%.  Just generate a score unless score is higher than 75% in which a code fic should also be included.'
-          ai_temp = opts[:ai_temp] ||= 0.1
-
-          puts "Analyzing source code using AI engine: #{ai_engine}\nModel: #{ai_model}\nSystem Role Content: #{ai_system_role_content}\nTemperature: #{ai_temp}"
+          puts "Analyzing source code using AI engine: #{engine}\nModel: #{model}\nSystem Role Content: #{system_role_content}\nTemperature: #{temp}"
         end
 
         # Calculate percentage of AI analysis based on the number of entries
         total_entries = results_hash[:data].sum { |entry| entry[:line_no_and_contents].size }
-        puts "Total entries to analyze: #{total_entries}" if ai_engine
+        puts "Total entries to analyze: #{total_entries}" if engine
 
         percent_complete = 0.0
         entry_count = 0
@@ -79,37 +66,39 @@ module PWN
             response = nil
             author = src_detail[:author].to_s.scrub.chomp.strip
 
-            case ai_engine
-            when :grok
-              response = PWN::AI::Grok.chat(
-                base_uri: ai_base_uri,
-                token: ai_key,
-                model: ai_model,
-                system_role_content: ai_system_role_content,
-                temp: ai_temp,
-                request: request.chomp,
-                spinner: false
-              )
-            when :ollama
-              response = PWN::AI::Ollama.chat(
-                base_uri: ai_base_uri,
-                token: ai_key,
-                model: ai_model,
-                system_role_content: ai_system_role_content,
-                temp: ai_temp,
-                request: request.chomp,
-                spinner: false
-              )
-            when :openai
-              response = PWN::AI::OpenAI.chat(
-                base_uri: ai_base_uri,
-                token: ai_key,
-                model: ai_model,
-                system_role_content: ai_system_role_content,
-                temp: ai_temp,
-                request: request.chomp,
-                spinner: false
-              )
+            if ai_instrospection
+              case engine
+              when :grok
+                response = PWN::AI::Grok.chat(
+                  base_uri: base_uri,
+                  token: key,
+                  model: model,
+                  system_role_content: system_role_content,
+                  temp: temp,
+                  request: request.chomp,
+                  spinner: false
+                )
+              when :ollama
+                response = PWN::AI::Ollama.chat(
+                  base_uri: base_uri,
+                  token: key,
+                  model: model,
+                  system_role_content: system_role_content,
+                  temp: temp,
+                  request: request.chomp,
+                  spinner: false
+                )
+              when :openai
+                response = PWN::AI::OpenAI.chat(
+                  base_uri: base_uri,
+                  token: key,
+                  model: model,
+                  system_role_content: system_role_content,
+                  temp: temp,
+                  request: request.chomp,
+                  spinner: false
+                )
+              end
             end
 
             ai_analysis = nil
@@ -118,6 +107,7 @@ module PWN
               ai_analysis = response[:choices].last[:content] if response[:choices].last.keys.include?(:content)
               # puts "AI Analysis Progress: #{percent_complete}% Line: #{line_no} | Author: #{author} | AI Analysis: #{ai_analysis}\n\n\n" if ai_analysis
             end
+            # TODO: Make results prettier in the HTML report
             src_detail[:ai_analysis] = ai_analysis.to_s.scrub.chomp.strip
 
             spin.update(

data/lib/pwn/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PWN
-  VERSION = '0.5.429'
+  VERSION = '0.5.430'
 end

data/lib/pwn.rb

@@ -12,19 +12,22 @@ module PWN
   autoload :AWS, 'pwn/aws'
   autoload :Banner, 'pwn/banner'
   autoload :Blockchain, 'pwn/blockchain'
+  autoload :Config, 'pwn/config'
   autoload :FFI, 'pwn/ffi'
   autoload :Plugins, 'pwn/plugins'
   autoload :Reports, 'pwn/reports'
   autoload :SAST, 'pwn/sast'
   autoload :WWW, 'pwn/www'
-  # TODO: If pwn.yaml is present, attempt to decrypt it, and initialize the YAML config
-  # Do this within PWN::Plugins::AuthenticationHelper?
 
   # Display a List of Every PWN Module
 
   public_class_method def self.help
     constants.sort
   end
+
+  # Initialize PWN configuration file
+  # PWN::CONFIG is the constant that stores the configuration data
+  PWN::Config.refresh
 rescue StandardError => e
   puts e.backtrace
   raise e

data/spec/lib/pwn/config_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe PWN::Config do
+  it 'should return data for refresh method' do
+    config_response = PWN::Config.refresh
+    expect(config_response).not_to be_nil
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.5.429
+  version: 0.5.430
 platform: ruby
 authors:
 - 0day Inc.
@@ -1832,6 +1832,7 @@ files:
 - lib/pwn/blockchain.rb
 - lib/pwn/blockchain/btc.rb
 - lib/pwn/blockchain/eth.rb
+- lib/pwn/config.rb
 - lib/pwn/ffi.rb
 - lib/pwn/ffi/stdio.rb
 - lib/pwn/plugins.rb
@@ -2180,6 +2181,7 @@ files:
 - spec/lib/pwn/blockchain/btc_spec.rb
 - spec/lib/pwn/blockchain/eth_spec.rb
 - spec/lib/pwn/blockchain_spec.rb
+- spec/lib/pwn/config_spec.rb
 - spec/lib/pwn/ffi/stdio_spec.rb
 - spec/lib/pwn/ffi_spec.rb
 - spec/lib/pwn/plugins/android_spec.rb