pwn 0.4.658 → 0.4.659

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8c68251fcd5e0e63b4cf69eeb69a903ce22059b7596e1eb6ed3c7671a5e929d
-  data.tar.gz: 5ef0c65b628eadb0b9abb1a119a12447ab5597f92c2c798fdf361e4669b3aaca
+  metadata.gz: f0eb080cab0eea6cae868fb9d0cebac5614531ec77d43a581e9bee728b0d207a
+  data.tar.gz: fa6165a643f5e062047eb695528e5c1c04d8f62d2804bf4a5092a9febb224b48
 SHA512:
-  metadata.gz: b1e157e0332533711b5f54239497a1b954bf2ae785f913407a36a73763d16fc18d5de8353f01458c421cc477d01317f127042b36a271f970cb140dcad88831d0
-  data.tar.gz: 999ae9da2a56ccaaf37a5c8c3f8b055d62576be70bd51b48bcee5af8faa572277edf0976a820bbfa6d572b44595f8c111680f6ae92ee347f9646d56b0197fdad
+  metadata.gz: 77265b7ee61cce81ef319ed3f86a07d0a4f025562f167534ed6e1bef56e7e07a3d11bc46bb27ef65626fec3678808961f1661a98673e51b32024c56f3abf8fa1
+  data.tar.gz: 93534d53a13e0a065ff026d68d5090d22e51a8a84f2e61485499e880d623b8361eeffb23805eb9aba4a60fdb4960754fa4c34e6f73f0fdaf4adfd96ac1475206

data/.gitignore

@@ -59,4 +59,5 @@ packer/provisioners/salt/states/install.sh
 packer/output-*
 packer/*.box
 third_party/burpsuite-pro.jar
+third_party/open_ai_pwn.jsonl
 ubuntu-*-cloudimg-console.log

data/Gemfile

@@ -52,7 +52,7 @@ gem 'oily_png', '1.2.1'
 gem 'os', '1.1.4'
 gem 'packetfu', '1.1.13'
 gem 'pdf-reader', '2.11.0'
-gem 'pg', '1.5.2'
+gem 'pg', '1.5.3'
 gem 'pry', '0.14.2'
 gem 'pry-doc', '1.4.0'
 gem 'rake', '13.0.6'

data/README.md

@@ -37,7 +37,7 @@ $ rvm use ruby-3.2.2@pwn
 $ rvm list gemsets
 $ gem install --verbose pwn
 $ pwn
-pwn[v0.4.658]:001 >>> PWN.help
+pwn[v0.4.659]: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.2.2@pwn
 $ gem uninstall --all --executables pwn
 $ gem install --verbose pwn
 $ pwn
-pwn[v0.4.658]:001 >>> PWN.help
+pwn[v0.4.659]:001 >>> PWN.help
 ```
 
 

data/lib/pwn/plugins/open_ai.rb

@@ -30,39 +30,66 @@ module PWN
                       end
         rest_call = opts[:rest_call].to_s.scrub
         params = opts[:params]
-        http_body = opts[:http_body].to_s.scrub
+        http_body = opts[:http_body]
+        http_body ||= {}
         base_open_ai_api_uri = 'https://api.openai.com/v1'
         token = opts[:token]
 
+        content_type = 'application/json; charset=UTF-8'
+
         rest_client = PWN::Plugins::TransparentBrowser.open(browser_type: :rest)::Request
         spinner = TTY::Spinner.new
         spinner.auto_spin
 
         case http_method
-        when :get
+        when :delete
           response = rest_client.execute(
-            method: :get,
+            method: :delete,
             url: "#{base_open_ai_api_uri}/#{rest_call}",
             headers: {
-              content_type: 'application/json; charset=UTF-8',
+              content_type: content_type,
               authorization: "Bearer #{token}",
               params: params
             },
             verify_ssl: false
           )
 
-        when :post
+        when :get
           response = rest_client.execute(
-            method: :post,
+            method: :get,
             url: "#{base_open_ai_api_uri}/#{rest_call}",
             headers: {
-              content_type: 'application/json; charset=UTF-8',
-              authorization: "Bearer #{token}"
+              content_type: content_type,
+              authorization: "Bearer #{token}",
+              params: params
             },
-            payload: http_body,
             verify_ssl: false
           )
 
+        when :post
+          if http_body.key?(:multipart)
+            response = rest_client.execute(
+              method: :post,
+              url: "#{base_open_ai_api_uri}/#{rest_call}",
+              headers: {
+                authorization: "Bearer #{token}"
+              },
+              payload: http_body,
+              verify_ssl: false
+            )
+          else
+            response = rest_client.execute(
+              method: :post,
+              url: "#{base_open_ai_api_uri}/#{rest_call}",
+              headers: {
+                content_type: content_type,
+                authorization: "Bearer #{token}"
+              },
+              payload: http_body.to_json,
+              verify_ssl: false
+            )
+          end
+
         else
           raise @@logger.error("Unsupported HTTP Method #{http_method} for #{self} Plugin")
         end
@@ -80,7 +107,7 @@ module PWN
 
       # Supported Method Parameters::
       # response = PWN::Plugins::OpenAI.get_models(
-      #   token: 'required - Bearer token',
+      #   token: 'required - Bearer token'
       # )
 
       public_class_method def self.get_models(opts = {})
@@ -181,7 +208,7 @@ module PWN
           http_method: :post,
           token: token,
           rest_call: rest_call,
-          http_body: http_body.to_json
+          http_body: http_body
         )
 
         json_resp = JSON.parse(response, symbolize_names: true)
@@ -259,7 +286,298 @@ module PWN
           http_method: :post,
           token: token,
           rest_call: rest_call,
-          http_body: http_body.to_json
+          http_body: http_body
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.create_fine_tune(
+      #   token: 'required - Bearer token',
+      #   training_file: 'required - JSONL that contains OpenAI training data'
+      #   validation_file: 'optional - JSONL that contains OpenAI validation data'
+      #   model: 'optional - :ada||:babbage||:curie||:davinci (defaults to :davinci)',
+      #   n_epochs: 'optional - iterate N times through training_file to train the model (defaults to 4)',
+      #   batch_size: 'optional - batch size to use for training (defaults to nil)',
+      #   learning_rate_multipler: 'optional - fine-tuning learning rate is the original learning rate used for pretraining multiplied by this value (defaults to nil)',
+      #   prompt_loss_weight: 'optional -  (defaults to 0.01)',
+      #   computer_classification_metrics: 'optional - calculate classification-specific metrics such as accuracy and F-1 score using the validation set at the end of every epoch (defaults to false)',
+      #   classification_n_classes: 'optional - number of classes in a classification task (defaults to nil)',
+      #   classification_positive_class: 'optional - generate precision, recall, and F1 metrics when doing binary classification (defaults to nil)',
+      #   classification_betas: 'optional - calculate F-beta scores at the specified beta values (defaults to nil)',
+      #   suffix: 'optional - string of up to 40 characters that will be added to your fine-tuned model name (defaults to nil)',
+      # )
+
+      public_class_method def self.create_fine_tune(opts = {})
+        token = opts[:token]
+        training_file = opts[:training_file]
+        validation_file = opts[:validation_file]
+        model = opts[:model]
+        model ||= :davinci
+
+        n_epochs = opts[:n_epochs]
+        n_epochs ||= 4
+
+        batch_size = opts[:batch_size]
+        learning_rate_multipler = opts[:learning_rate_multipler]
+
+        prompt_loss_weight = opts[:prompt_loss_weight]
+        prompt_loss_weight ||= 0.01
+
+        computer_classification_metrics = true if opts[:computer_classification_metrics]
+        classification_n_classes = opts[:classification_n_classes]
+        classification_positive_class = opts[:classification_positive_class]
+        classification_betas = opts[:classification_betas]
+        suffix = opts[:suffix]
+
+        response = upload_file(
+          token: token,
+          file: training_file
+        )
+        training_file = response[:id]
+
+        if validation_file
+          response = upload_file(
+            token: token,
+            file: validation_file
+          )
+          validation_file = response[:id]
+        end
+
+        http_body = {}
+        http_body[:training_file] = training_file
+        http_body[:validation_file] = validation_file if validation_file
+        http_body[:model] = model
+        http_body[:n_epochs] = n_epochs
+        http_body[:batch_size] = batch_size if batch_size
+        http_body[:learning_rate_multipler] = learning_rate_multipler if learning_rate_multipler
+        http_body[:prompt_loss_weight] = prompt_loss_weight if prompt_loss_weight
+        http_body[:computer_classification_metrics] = computer_classification_metrics if computer_classification_metrics
+        http_body[:classification_n_classes] = classification_n_classes if classification_n_classes
+        http_body[:classification_positive_class] = classification_positive_class if classification_positive_class
+        http_body[:classification_betas] = classification_betas if classification_betas
+        http_body[:suffix] = suffix if suffix
+
+        response = open_ai_rest_call(
+          http_method: :post,
+          token: token,
+          rest_call: 'fine-tunes',
+          http_body: http_body
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.list_fine_tunes(
+      #   token: 'required - Bearer token'
+      # )
+
+      public_class_method def self.list_fine_tunes(opts = {})
+        token = opts[:token]
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: 'fine-tunes'
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.get_fine_tune_status(
+      #   token: 'required - Bearer token',
+      #   fine_tune_id: 'required - respective :id value returned from #list_fine_tunes',
+      # )
+
+      public_class_method def self.get_fine_tune_status(opts = {})
+        token = opts[:token]
+        fine_tune_id = opts[:fine_tune_id]
+
+        rest_call = "fine-tunes/#{fine_tune_id}"
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: rest_call
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.cancel_fine_tune(
+      #   token: 'required - Bearer token',
+      #   fine_tune_id: 'required - respective :id value returned from #list_fine_tunes',
+      # )
+
+      public_class_method def self.cancel_fine_tune(opts = {})
+        token = opts[:token]
+        fine_tune_id = opts[:fine_tune_id]
+
+        rest_call = "fine-tunes/#{fine_tune_id}/cancel"
+
+        response = open_ai_rest_call(
+          http_method: :post,
+          token: token,
+          rest_call: rest_call
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.get_fine_tune_events(
+      #   token: 'required - Bearer token',
+      #   fine_tune_id: 'required - respective :id value returned from #list_fine_tunes',
+      # )
+
+      public_class_method def self.get_fine_tune_events(opts = {})
+        token = opts[:token]
+        fine_tune_id = opts[:fine_tune_id]
+
+        rest_call = "fine-tunes/#{fine_tune_id}/events"
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: rest_call
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.delete_fine_tune_model(
+      #   token: 'required - Bearer token',
+      #   model: 'required - model to delete'
+      # )
+
+      public_class_method def self.delete_fine_tune_model(opts = {})
+        token = opts[:token]
+        model = opts[:model]
+
+        rest_call = "models/#{model}"
+
+        response = open_ai_rest_call(
+          http_method: :delete,
+          token: token,
+          rest_call: rest_call
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.list_files(
+      #   token: 'required - Bearer token'
+      # )
+
+      public_class_method def self.list_files(opts = {})
+        token = opts[:token]
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: 'files'
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.upload_file(
+      #   token: 'required - Bearer token',
+      #   file: 'required - file to upload',
+      #   purpose: 'optional - intended purpose of the uploaded documents (defaults to fine-tune'
+      # )
+
+      public_class_method def self.upload_file(opts = {})
+        token = opts[:token]
+        file = opts[:file]
+        raise "ERROR: #{file} not found." unless File.exist?(file)
+
+        purpose = opts[:purpose]
+        purpose ||= 'fine-tune'
+
+        http_body = {
+          multipart: true,
+          file: File.new(file, 'rb'),
+          purpose: purpose
+        }
+
+        response = open_ai_rest_call(
+          http_method: :post,
+          token: token,
+          rest_call: 'files',
+          http_body: http_body
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.delete_file(
+      #   token: 'required - Bearer token',
+      #   file: 'required - file to delete'
+      # )
+
+      public_class_method def self.delete_file(opts = {})
+        token = opts[:token]
+        file = opts[:file]
+        raise "ERROR: #{file} not found." unless File.exist?(file)
+
+        response = list_files(token: token)
+        file_id = response[:data].select { |f| f if f[:filename] == File.basename(file) }.first[:id]
+
+        rest_call = "files/#{file_id}"
+
+        response = open_ai_rest_call(
+          http_method: :delete,
+          token: token,
+          rest_call: rest_call
+        )
+
+        JSON.parse(response, symbolize_names: true)
+      rescue StandardError => e
+        raise e
+      end
+
+      # Supported Method Parameters::
+      # response = PWN::Plugins::OpenAI.get_file(
+      #   token: 'required - Bearer token',
+      #   file: 'required - file to delete'
+      # )
+
+      public_class_method def self.get_file(opts = {})
+        token = opts[:token]
+        file = opts[:file]
+        raise "ERROR: #{file} not found." unless File.exist?(file)
+
+        response = list_files(token: token)
+        file_id = response[:data].select { |f| f if f[:filename] == File.basename(file) }.first[:id]
+
+        rest_call = "files/#{file_id}"
+
+        response = open_ai_rest_call(
+          token: token,
+          rest_call: rest_call
         )
 
         JSON.parse(response, symbolize_names: true)
@@ -279,6 +597,10 @@ module PWN
 
       public_class_method def self.help
         puts "USAGE:
+          response = #{self}.get_models(
+            token: 'required - Bearer token'
+          )
+
           response = #{self}.chat(
             token: 'required - Bearer token',
             request: 'required - message to ChatGPT',
@@ -296,6 +618,55 @@ module PWN
             size: 'optional - size of image (defaults to \"1024x1024\")'
           )
 
+          response = #{self}.create_fine_tune(
+            token: 'required - Bearer token',
+            training_file: 'required - JSONL that contains OpenAI training data'
+            validation_file: 'optional - JSONL that contains OpenAI validation data'
+            model: 'optional - :ada||:babbage||:curie||:davinci (defaults to :davinci)',
+            n_epochs: 'optional - iterate N times through training_file to train the model (defaults to 4)',
+            batch_size: 'optional - batch size to use for training (defaults to nil)',
+            learning_rate_multipler: 'optional - fine-tuning learning rate is the original learning rate used for pretraining multiplied by this value (defaults to nill)',
+            prompt_loss_weight: 'optional -  (defaults to nil)',
+            computer_classification_metrics: 'optional - calculate classification-specific metrics such as accuracy and F-1 score using the validation set at the end of every epoch (defaults to false)',
+            classification_n_classes: 'optional - number of classes in a classification task (defaults to nil)',
+            classification_positive_class: 'optional - generate precision, recall, and F1 metrics when doing binary classification (defaults to nil)',
+            classification_betas: 'optional - calculate F-beta scores at the specified beta values (defaults to nil)',
+            suffix: 'optional - string of up to 40 characters that will be added to your fine-tuned model name (defaults to nil)',
+          )
+
+          response = #{self}.list_fine_tunes(
+            token: 'required - Bearer token'
+          )
+
+          response = #{self}.get_fine_tune_status(
+            token: 'required - Bearer token',
+            fine_tune_id: 'required - respective :id value returned from #list_fine_tunes',
+          )
+
+          response = #{self}.get_fine_tune_events(
+            token: 'required - Bearer token',
+            fine_tune_id: 'required - respective :id value returned from #list_fine_tunes',
+          )
+
+          response = #{self}.list_files(
+            token: 'required - Bearer token'
+          )
+
+          response = #{self}.upload_file(
+            token: 'required - Bearer token',
+            file: 'required - file to upload'
+          )
+
+          response = #{self}.delete_file(
+            token: 'required - Bearer token',
+            file: 'required - file to delete'
+          )
+
+          response = #{self}.get_file(
+            token: 'required - Bearer token',
+            file: 'required - file to delete'
+          )
+
           #{self}.authors
         "
       end

data/lib/pwn/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pwn
 version: !ruby/object:Gem::Version
-  version: 0.4.658
+  version: 0.4.659
 platform: ruby
 authors:
 - 0day Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-26 00:00:00.000000000 Z
+date: 2023-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -590,14 +590,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: 1.5.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: 1.5.3
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement