gophish-ruby 0.3.0 → 1.0.0

data/lib/gophish/campaign.rb

@@ -0,0 +1,330 @@
+require_relative 'base'
+require_relative 'template'
+require_relative 'page'
+require_relative 'smtp'
+require_relative 'group'
+require 'active_support/core_ext/object/blank'
+
+module Gophish
+  class Campaign < Base
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :created_date, :string
+    attribute :launch_date, :string
+    attribute :send_by_date, :string
+    attribute :completed_date, :string
+    attribute :template
+    attribute :page
+    attribute :status, :string
+    attribute :results, default: -> { [] }
+    attribute :groups, default: -> { [] }
+    attribute :timeline, default: -> { [] }
+    attribute :smtp
+    attribute :url, :string
+
+    define_attribute_methods :id, :name, :created_date, :launch_date, :send_by_date,
+                             :completed_date, :template, :page, :status, :results,
+                             :groups, :timeline, :smtp, :url
+
+    validates :name, presence: true
+    validates :template, presence: true
+    validates :page, presence: true
+    validates :groups, presence: true
+    validates :smtp, presence: true
+    validates :url, presence: true
+    validate :validate_groups_structure
+    validate :validate_results_structure
+    validate :validate_timeline_structure
+
+    def body_for_create
+      build_campaign_payload
+    end
+
+    def self.get_results(id)
+      response = get "#{resource_path}/#{id}/results"
+      raise StandardError, "Campaign not found with id: #{id}" if response.response.code != '200'
+
+      response.parsed_response
+    end
+
+    def self.get_summary(id)
+      response = get "#{resource_path}/#{id}/summary"
+      raise StandardError, "Campaign not found with id: #{id}" if response.response.code != '200'
+
+      response.parsed_response
+    end
+
+    def self.complete(id)
+      response = get "#{resource_path}/#{id}/complete"
+      raise StandardError, "Campaign not found with id: #{id}" if response.response.code != '200'
+
+      response.parsed_response
+    end
+
+    def get_results
+      self.class.get_results id
+    end
+
+    def get_summary
+      self.class.get_summary id
+    end
+
+    def complete!
+      response = self.class.complete id
+      self.status = 'Completed' if response['success']
+      response
+    end
+
+    def in_progress?
+      status == 'In progress'
+    end
+
+    def completed?
+      status == 'Completed'
+    end
+
+    def launched?
+      !launch_date.blank?
+    end
+
+    def has_send_by_date?
+      !send_by_date.blank?
+    end
+
+    # Custom getters to return proper class instances
+    def template
+      convert_to_instance super, Gophish::Template
+    end
+
+    def page
+      convert_to_instance super, Gophish::Page
+    end
+
+    def smtp
+      convert_to_instance super, Gophish::Smtp
+    end
+
+    def groups
+      convert_to_instances super, Gophish::Group
+    end
+
+    def results
+      convert_to_instances super, Result
+    end
+
+    def timeline
+      convert_to_instances super, Event
+    end
+
+    # Custom setters to handle both instances and hashes
+    def template=(value)
+      @template_raw = value
+      super(convert_from_instance(value))
+    end
+
+    def page=(value)
+      @page_raw = value
+      super(convert_from_instance(value))
+    end
+
+    def smtp=(value)
+      @smtp_raw = value
+      super(convert_from_instance(value))
+    end
+
+    def groups=(value)
+      @groups_raw = value
+      super(convert_from_instances(value))
+    end
+
+    def results=(value)
+      super(convert_from_instances(value))
+    end
+
+    def timeline=(value)
+      super(convert_from_instances(value))
+    end
+
+    private
+
+    def build_campaign_payload
+      {
+        name: name,
+        template: serialize_object(@template_raw || template),
+        page: serialize_object(@page_raw || page),
+        groups: serialize_groups,
+        smtp: serialize_object(@smtp_raw || smtp),
+        url: url, launch_date: launch_date, send_by_date: send_by_date
+      }
+    end
+
+    def serialize_object(obj)
+      return obj if obj.is_a? Hash
+      return { name: obj } if obj.is_a? String
+      return { name: obj.name } if obj.respond_to? :name
+
+      obj
+    end
+
+    def serialize_groups
+      raw_groups = @groups_raw || groups
+      return raw_groups if raw_groups.empty?
+
+      raw_groups.map { |group| serialize_object group }
+    end
+
+    def validate_groups_structure
+      return if groups.blank?
+      return errors.add :groups, 'must be an array' unless groups.is_a? Array
+      return errors.add :groups, 'cannot be empty' if groups.empty?
+
+      groups.each_with_index { |group, index| validate_group group, index }
+    end
+
+    def validate_group(group, index)
+      return if group.is_a?(Hash) && (group[:name] || group['name'])
+      return if group.respond_to? :name
+
+      errors.add :groups, "item at index #{index} must have a name"
+    end
+
+    def validate_results_structure
+      return if results.blank?
+      return errors.add :results, 'must be an array' unless results.is_a? Array
+
+      results.each_with_index { |result, index| validate_result result, index }
+    end
+
+    def validate_result(result, index)
+      return errors.add :results, "item at index #{index} must be a hash" unless result.is_a? Hash
+
+      validate_result_field result, index, :email
+    end
+
+    def validate_timeline_structure
+      return if timeline.blank?
+      return errors.add :timeline, 'must be an array' unless timeline.is_a? Array
+
+      timeline.each_with_index { |event, index| validate_timeline_event event, index }
+    end
+
+    def validate_timeline_event(event, index)
+      return errors.add :timeline, "item at index #{index} must be a hash" unless event.is_a? Hash
+
+      validate_event_field event, index, :time
+      validate_event_field event, index, :message
+    end
+
+    def validate_result_field(result, index, field)
+      value = result[field] || result[field.to_s]
+      return unless value.blank?
+
+      errors.add :results, "item at index #{index} must have a #{field}"
+    end
+
+    def validate_event_field(event, index, field)
+      value = event[field] || event[field.to_s]
+      return unless value.blank?
+
+      errors.add :timeline, "item at index #{index} must have a #{field}"
+    end
+
+    # Helper methods for instance conversion
+    def convert_to_instance(value, klass)
+      return nil if value.nil?
+      return value if value.is_a? klass
+      return create_instance_safely value, klass if value.is_a? Hash
+
+      value
+    end
+
+    def create_instance_safely(hash, klass)
+      klass.new hash
+    rescue ActiveModel::UnknownAttributeError
+      # Filter out unknown attributes and try again
+      known_attributes = klass.attribute_names.map(&:to_s)
+      filtered_hash = hash.select { |k, _v| known_attributes.include? k.to_s }
+      klass.new filtered_hash
+    end
+
+    def convert_to_instances(values, klass)
+      return [] if values.blank?
+      return values unless values.is_a? Array
+
+      values.map { |value| convert_to_instance value, klass }
+    end
+
+    def convert_from_instance(value)
+      return value if value.nil? || value.is_a?(Hash)
+
+      value
+    end
+
+    def convert_from_instances(values)
+      return values if values.blank?
+      return values unless values.is_a? Array
+
+      values
+    end
+
+    class Result
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :id, :string
+      attribute :first_name, :string
+      attribute :last_name, :string
+      attribute :position, :string
+      attribute :email, :string
+      attribute :status, :string
+      attribute :ip, :string
+      attribute :latitude, :float
+      attribute :longitude, :float
+      attribute :send_date, :string
+      attribute :reported, :boolean, default: false
+      attribute :modified_date, :string
+
+      def reported?
+        reported == true
+      end
+
+      def clicked?
+        status == 'Clicked Link'
+      end
+
+      def opened?
+        status == 'Email Opened'
+      end
+
+      def sent?
+        status == 'Email Sent'
+      end
+
+      def submitted_data?
+        status == 'Submitted Data'
+      end
+    end
+
+    class Event
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      attribute :email, :string
+      attribute :time, :string
+      attribute :message, :string
+      attribute :details, :string
+
+      def has_details?
+        !details.blank?
+      end
+
+      def parsed_details
+        return {} if details.blank?
+
+        JSON.parse details
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/gophish/smtp.rb

@@ -0,0 +1,99 @@
+require_relative 'base'
+require 'active_support/core_ext/object/blank'
+
+module Gophish
+  class Smtp < Base
+    def self.resource_path
+      '/smtp'
+    end
+    attribute :id, :integer
+    attribute :name, :string
+    attribute :username, :string
+    attribute :password, :string
+    attribute :host, :string
+    attribute :interface_type, :string, default: 'SMTP'
+    attribute :from_address, :string
+    attribute :ignore_cert_errors, :boolean, default: false
+    attribute :modified_date, :string
+    attribute :headers, default: -> { [] }
+
+    define_attribute_methods :id, :name, :username, :password, :host, :interface_type, :from_address,
+                             :ignore_cert_errors, :modified_date, :headers
+
+    validates :name, presence: true
+    validates :host, presence: true
+    validates :from_address, presence: true
+    validate :validate_from_address_format
+    validate :validate_headers_structure
+
+    def body_for_create
+      {
+        name:, username:, password:, host:,
+        interface_type:,
+        from_address:,
+        ignore_cert_errors:,
+        headers:
+      }
+    end
+
+    def add_header(key, value)
+      headers << { key:, value: }
+      headers_will_change!
+    end
+
+    def remove_header(key)
+      original_size = headers.size
+      headers.reject! { |header| header[:key] == key || header['key'] == key }
+      headers_will_change! if headers.size != original_size
+    end
+
+    def has_headers?
+      !headers.empty?
+    end
+
+    def header_count
+      headers.length
+    end
+
+    def has_authentication?
+      !username.blank? && !password.blank?
+    end
+
+    def ignores_cert_errors?
+      ignore_cert_errors == true
+    end
+
+    private
+
+    def validate_from_address_format
+      return if from_address.blank?
+
+      email_regex = /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i
+
+      unless from_address.match? email_regex
+        errors.add :from_address, 'must be a valid email format (email@domain.com)'
+      end
+    end
+
+    def validate_headers_structure
+      return if headers.blank?
+      return errors.add :headers, 'must be an array' unless headers.is_a? Array
+
+      headers.each_with_index { |header, index| validate_header header, index }
+    end
+
+    def validate_header(header, index)
+      return errors.add :headers, "item at index #{index} must be a hash" unless header.is_a? Hash
+
+      validate_header_field header, index, :key
+      validate_header_field header, index, :value
+    end
+
+    def validate_header_field(header, index, field)
+      value = header[field] || header[field.to_s]
+      return unless value.blank?
+
+      errors.add :headers, "item at index #{index} must have a #{field}"
+    end
+  end
+end

data/lib/gophish/template.rb

@@ -6,20 +6,21 @@ module Gophish
   class Template < Base
     attribute :id, :integer
     attribute :name, :string
+    attribute :envelope_sender, :string
     attribute :subject, :string
     attribute :text, :string
     attribute :html, :string
     attribute :modified_date, :string
     attribute :attachments, default: -> { [] }
 
-    define_attribute_methods :id, :name, :subject, :text, :html, :modified_date, :attachments
+    define_attribute_methods :id, :name, :envelope_sender, :subject, :text, :html, :modified_date, :attachments
 
     validates :name, presence: true
     validate :validate_content_presence
     validate :validate_attachments_structure
 
     def body_for_create
-      { name:, subject:, text:, html:, attachments: }
+      { name:, envelope_sender:, subject:, text:, html:, attachments: }
     end
 
     def self.import_email(content, convert_links: false)
@@ -57,6 +58,10 @@ module Gophish
       attachments.length
     end
 
+    def has_envelope_sender?
+      !envelope_sender.blank?
+    end
+
     private
 
     def encode_content(content)

data/lib/gophish/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gophish
-  VERSION = '0.3.0'
+  VERSION = '1.0.0'
 end

data/lib/gophish-ruby.rb

@@ -3,6 +3,8 @@ require_relative 'gophish/configuration'
 require_relative 'gophish/group'
 require_relative 'gophish/template'
 require_relative 'gophish/page'
+require_relative 'gophish/smtp'
+require_relative 'gophish/campaign'
 
 module Gophish
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gophish-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Eli Sebastian Herrera Aguilar
@@ -103,9 +103,11 @@ files:
 - docs/GETTING_STARTED.md
 - lib/gophish-ruby.rb
 - lib/gophish/base.rb
+- lib/gophish/campaign.rb
 - lib/gophish/configuration.rb
 - lib/gophish/group.rb
 - lib/gophish/page.rb
+- lib/gophish/smtp.rb
 - lib/gophish/template.rb
 - lib/gophish/version.rb
 - sig/gophish/ruby.rbs