nexpose 0.2.8 → 0.5.0

data/lib/nexpose/ticket.rb

@@ -1,46 +1,22 @@
 module Nexpose
 
-  module Ticket
-
-    module State
-      OPEN = 'O'
-      ASSIGNED = 'A'
-      MODIFIED = 'M'
-      FIXED = 'X'
-      PARTIAL = 'P'
-      REJECTED_FIX = 'R'
-      PRIORITIZED = 'Z'
-      NOT_REPRODUCIBLE = 'F'
-      NOT_ISSUE = 'I'
-      CLOSED = 'C'
-      UNKNOWN = 'U'
-    end
-
-    module Priority
-      LOW = 'low'
-      MODERATE = 'moderate'
-      NORMAL = 'normal'
-      HIGH = 'high'
-      CRITICAL = 'critical'
-    end
-  end
-
   module NexposeAPI
     include XMLUtils
 
-    def ticket_listing
+    def list_tickets
+      # TODO: Should take in filters as arguments.
       xml = make_xml('TicketListingRequest')
       r = execute(xml, '1.2')
       tickets = []
       if r.success
         r.res.elements.each('TicketListingResponse/TicketSummary') do |summary|
-          tickets << TicketSummary::parse(summary)
+          tickets << TicketSummary.parse(summary)
         end
       end
       tickets
     end
 
-    alias_method :tickets, :ticket_listing
+    alias_method :tickets, :list_tickets
 
     # Deletes a Nexpose ticket.
     #
@@ -48,6 +24,7 @@ module Nexpose
     # @return [Boolean] Whether or not the ticket deletion succeeded.
     #
     def delete_ticket(ticket)
+      # TODO: Take Ticket object, too, and pull out IDs.
       delete_tickets([ticket])
     end
 
@@ -57,98 +34,14 @@ module Nexpose
     # @return [Boolean] Whether or not the ticket deletions succeeded.
     #
     def delete_tickets(tickets)
+      # TODO: Take Ticket objects, too, and pull out IDs.
       xml = make_xml('TicketDeleteRequest')
       tickets.each do |id|
-        xml.add_element('Ticket', {'id' => id})
+        xml.add_element('Ticket', { 'id' => id })
       end
 
       (execute xml, '1.2').success
     end
-
-    alias_method :ticket_delete, :delete_tickets
-
-    #
-    # Create a Nexpose ticket
-    #
-    # ticket_info: A hash of the data to be used to create a ticket in Nexpose:
-    # :name        => The name of the ticket (Required)
-    # :device_id   => The Nexpose device ID for the device being ticketed (Required)
-    # :assigned_to => The Nexpose user to whom this ticket is assigned (Required)
-    # :priority    => "low,moderate,normal,high,critical" (Required)
-    #
-    # :vulnerabilities => An array of Nexpose vuln IDs. This is NOT the same as vuln ID.  (Required)
-    # :comments        => An array of comments to accompany this ticket
-    #
-    # @return The ticket ID if the ticket creation was successful, {@code false} otherwise
-    #
-    def create_ticket(ticket_info)
-      ticket_name = ticket_info[:name]
-      unless ticket_name
-        raise ArgumentError.new 'Ticket name is required'
-      end
-
-      device_id = ticket_info[:device_id]
-      unless device_id
-        raise ArgumentError.new 'Device ID is required'
-      end
-
-      assigned_to = ticket_info[:assigned_to]
-      unless assigned_to
-        raise ArgumentError.new 'Assignee name is required'
-      end
-
-      priority = ticket_info[:priority]
-      unless priority
-        raise ArgumentError.new 'Ticket priority is required'
-      end
-
-      vulnerabilities = ticket_info[:vulnerabilities]
-      if not vulnerabilities or vulnerabilities.count < 1
-        raise ArgumentError.new 'Vulnerabilities are required'
-      end
-
-      comments = ticket_info[:comments]
-      base_xml = make_xml 'TicketCreateRequest'
-
-      required_attributes = {
-          'name' => ticket_name,
-          'priority' => priority,
-          'device-id' => device_id,
-          'assigned-to' => assigned_to
-      }
-
-      create_request_xml = REXML::Element.new 'TicketCreate'
-      create_request_xml.add_attributes required_attributes
-
-      # Add vulnerabilities
-      vulnerabilities_xml = REXML::Element.new 'Vulnerabilities'
-      vulnerabilities.each do |vuln_id|
-        vulnerabilities_xml.add_element 'Vulnerability', {'id' => vuln_id.downcase}
-      end
-      create_request_xml.add_element vulnerabilities_xml
-
-      # Add comments
-      if comments and comments.count > 0
-        comments_xml = REXML::Element.new 'Comments'
-        comments.each do |comment|
-          comment_xml = REXML::Element.new 'Comment'
-          comment_xml.add_text comment
-          comments_xml.add_element comment_xml
-        end
-
-        create_request_xml.add_element comments_xml
-      end
-
-      base_xml.add_element create_request_xml
-      r = execute base_xml, '1.2'
-      if r.success
-        r.res.elements.each('TicketCreateResponse') do |group|
-          return group.attributes['id'].to_i
-        end
-      else
-        false
-      end
-    end
   end
 
   # Summary of ticket information returned from a ticket listing request.
@@ -182,21 +75,182 @@ module Nexpose
     # The current status of the ticket.
     attr_accessor :state
 
-    def initialize(id, name)
+    def initialize(name, id)
       @id, @name = id, name
     end
 
     def self.parse(xml)
-      ticket = new(xml.attributes['id'].to_i,
-                   xml.attributes['name'])
+      ticket = new(xml.attributes['name'],
+                   xml.attributes['id'].to_i)
       ticket.device_id = xml.attributes['device-id'].to_i
       ticket.assigned_to = xml.attributes['assigned-to']
-      ticket.priority = xml.attributes['priority']
+      lookup = Ticket::Priority.constants.reduce({}) { |a, e| a[Ticket::Priority.const_get(e)] = e; a }
+      ticket.priority = lookup[xml.attributes['priority']]
       ticket.author = xml.attributes['author']
-      ticket.created_on = DateTime::parse(xml.attributes['created-on'])
+      ticket.created_on = DateTime.parse(xml.attributes['created-on']).to_time
+      ticket.created_on -= ticket.created_on.gmt_offset
       lookup = Ticket::State.constants.reduce({}) { |a, e| a[Ticket::State.const_get(e)] = e; a }
       ticket.state = lookup[xml.attributes['state']]
       ticket
     end
+
+    module State
+      OPEN = 'O'
+      ASSIGNED = 'A'
+      MODIFIED = 'M'
+      FIXED = 'X'
+      PARTIAL = 'P'
+      REJECTED_FIX = 'R'
+      PRIORITIZED = 'Z'
+      NOT_REPRODUCIBLE = 'F'
+      NOT_ISSUE = 'I'
+      CLOSED = 'C'
+      UNKNOWN = 'U'
+    end
+
+    module Priority
+      LOW = 'low'
+      MODERATE = 'moderate'
+      NORMAL = 'normal'
+      HIGH = 'high'
+      CRITICAL = 'critical'
+    end
+  end
+
+  class Ticket < TicketSummary
+
+    # List of vulnerabilities (by ID) this ticket addresses.
+    attr_accessor :vulnerabilities
+
+    # Array of comments about the ticket.
+    attr_accessor :comments
+
+    # History of events on this ticket.
+    attr_accessor :history
+
+    def initialize(name, id = nil)
+      @id, @name = id, name
+      @priority = Priority::NORMAL
+      @vulnerabilities = []
+      @comments = []
+      @history = []
+    end
+
+    # Save this ticket to a Nexpose console.
+    #
+    # @param [Connection] connection Connection to console where ticket exists.
+    # @return [Fixnum] Unique ticket ID assigned to this ticket.
+    #
+    def save(connection)
+      xml = connection.make_xml('TicketCreateRequest')
+      xml.add_element(to_xml)
+
+      response = connection.execute(xml, '1.2')
+      @id = response.attributes['id'].to_i if response.success
+    end
+
+    # Delete this ticket from the system.
+    #
+    # @param [Connection] connection Connection to console where ticket exists.
+    # @return [Boolean] Whether the ticket was successfully delete.
+    #
+    def delete(connection)
+      connection.delete_ticket(@id)
+    end
+
+    # Load existing ticket data.
+    #
+    # @param [Connection] connection Connection to console where ticket exists.
+    # @param [Fixnum] id Ticket ID of an existing ticket.
+    # @return [Ticket] Ticket populated with current state.
+    #
+    def self.load(connection, id)
+      # TODO: Load multiple tickets in a single request, as supported by API.
+      xml = connection.make_xml('TicketDetailsRequest')
+      xml.add_element('Ticket', { 'id' => id })
+      response = connection.execute(xml, '1.2')
+      response.res.elements.each('//TicketInfo') do |info|
+        return parse_details(info)
+      end
+    end
+
+    def to_xml
+      xml = REXML::Element.new('TicketCreate')
+      xml.add_attributes({ 'name' => @name,
+                           'priority' => @priority,
+                           'device-id' => @device_id,
+                           'assigned-to' => @assigned_to })
+
+      vuln_xml = REXML::Element.new('Vulnerabilities')
+      @vulnerabilities.each do |vuln_id|
+        vuln_xml.add_element('Vulnerability', { 'id' => vuln_id.downcase })
+      end
+      xml.add_element(vuln_xml)
+
+      unless @comments.empty?
+        comments_xml = REXML::Element.new('Comments')
+        @comments.each do |comment|
+          comment_xml = REXML::Element.new('Comment')
+          comment_xml.add_text(comment)
+          comments_xml.add_element(comment_xml)
+        end
+        xml.add_element(comments_xml)
+      end
+
+      xml
+    end
+
+    def self.parse_details(xml)
+      ticket = parse(xml)
+
+      xml.elements.each('Vulnerabilities/Vulnerability') do |vuln|
+        ticket.vulnerabilities << vuln.attributes['id']
+      end
+
+      xml.elements.each('TicketHistory/Entry') do |entry|
+        ticket.history << Event.parse(entry)
+      end
+
+      ticket.comments = ticket.history.select { |h| h.description == 'Added comment' }.map { |e| e.comment }
+
+      ticket
+    end
+
+    class Event
+
+      # Date and time of the ticket event.
+      attr_reader :created_on
+      # The login name of the person responsible for the event.
+      attr_reader :author
+      # The status of the ticket at the time the event was recorded.
+      attr_reader :state
+      # Description of the ticket event.
+      attr_accessor :description
+      # Comment on the ticket event.
+      attr_accessor :comment
+
+      def initialize(state, author, created)
+        @state, @author, @created = state, author, created
+      end
+
+      def self.parse(xml)
+        author = xml.attributes['author']
+        created_on = DateTime.parse(xml.attributes['created-on']).to_time
+        created_on -= created_on.gmt_offset
+
+        event = REXML::XPath.first(xml, 'Event')
+        lookup = Ticket::State.constants.reduce({}) { |a, e| a[Ticket::State.const_get(e)] = e; a }
+        state = lookup[event.attributes['state']]
+        desc = event.text
+
+        event = new(state, author, created_on)
+
+        comment = REXML::XPath.first(xml, 'Comment')
+        event.comment = comment.text if comment
+
+        event.description = desc if desc
+        event
+      end
+    end
   end
 end

data/lib/nexpose/user.rb

@@ -7,7 +7,7 @@ module Nexpose
     #
     # @return [Array[UserSummary]] Array of users.
     #
-    def users
+    def list_users
       r = execute(make_xml('UserListingRequest'))
       arr = []
       if r.success
@@ -18,7 +18,12 @@ module Nexpose
       arr
     end
 
+    alias_method :users, :list_users
+
     # Retrieve the User ID based upon the user's login name.
+    #
+    # @param [String] user_name User name to search for.
+    #
     def get_user_id(user_name)
       users.find { |user| user.name.eql? user_name }
     end
@@ -35,7 +40,9 @@ module Nexpose
   end
 
   # Summary only returned by API when issuing a listing request.
+  #
   class UserSummary
+
     attr_reader :id, :auth_source, :auth_module, :name, :full_name, :email
     attr_reader :is_admin, :is_disabled, :is_locked, :site_count, :group_count
 
@@ -176,6 +183,7 @@ module Nexpose
   end
 
   class UserAuthenticator
+
     attr_reader :id, :auth_source, :auth_module, :external
 
     def initialize(id, auth_module, auth_source, external = false)
@@ -189,13 +197,13 @@ module Nexpose
     # * *Returns* : An array of known user authenticator sources.
     def self.list(connection)
       r = connection.execute('<UserAuthenticatorListingRequest session-id="' + connection.session_id + '" />', '1.1')
+      modules = []
       if r.success
-        modules = []
         r.res.elements.each('UserAuthenticatorListingResponse/AuthenticatorSummary') do |summary|
           modules << UserAuthenticator.new(summary.attributes['id'], summary.attributes['authModule'], summary.attributes['authSource'], ('1'.eql? summary.attributes['external']))
         end
-        modules
       end
+      modules
     end
   end
 end

data/lib/nexpose/vuln.rb

@@ -9,15 +9,15 @@ module Nexpose
     #   It can take twice a long to retrieve full summary information.
     # @return [Array[Vulnerability|VulnerabilitySummary]] Collection of all known vulnerabilities.
     #
-    def vuln_listing(full = false)
+    def list_vulns(full = false)
       xml = make_xml('VulnerabilityListingRequest')
-      # TODO Add a flag to do stream parsing of the XML to improve performance.
+      # TODO: Add a flag to do stream parsing of the XML to improve performance.
       response = execute(xml, '1.2')
       vulns = []
       if response.success
         response.res.elements.each('VulnerabilityListingResponse/VulnerabilitySummary') do |vuln|
           if full
-            vulns << VulnerabilitySummary::parse(vuln)
+            vulns << VulnerabilitySummary.parse(vuln)
           else
             vulns << Vulnerability.new(vuln.attributes['id'],
                                        vuln.attributes['title'],
@@ -28,7 +28,7 @@ module Nexpose
       vulns
     end
 
-    alias_method :vulns, :vuln_listing
+    alias_method :vulns, :list_vulns
 
     # Retrieve details for a vulnerability.
     #
@@ -36,17 +36,34 @@ module Nexpose
     # @return [VulnerabilityDetail] Details of the requested vulnerability.
     #
     def vuln_details(vuln_id)
-      xml = make_xml('VulnerabilityDetailsRequest', {'vuln-id' => vuln_id})
+      xml = make_xml('VulnerabilityDetailsRequest', { 'vuln-id' => vuln_id })
       response = execute(xml, '1.2')
       if response.success
         response.res.elements.each('VulnerabilityDetailsResponse/Vulnerability') do |vuln|
-          return VulnerabilityDetail::parse(vuln)
+          return VulnerabilityDetail.parse(vuln)
         end
       end
     end
+
+    # Search for Vulnerability Checks.
+    #
+    # @param [String] search_term Search terms to search for.
+    # @param [Boolean] partial_words Allow partial word matches.
+    # @param [Boolean] all_words All words must be present.
+    # @return [Array[VulnCheck]] List of matching Vulnerability Checks.
+    #
+    def find_vuln_check(search_term, partial_words = true, all_words = true)
+      uri = "/ajax/vulnck_synopsis.txml?phrase=#{URI.encode(search_term)}"
+      uri += '&wholeWords=1' unless partial_words
+      uri += '&allWords=1' if all_words
+      data = DataTable._get_dyn_table(self, uri)
+      data.map do |vuln|
+        VulnCheck.new(vuln)
+      end
+    end
   end
 
-  # Basic vulnerability information. Only includes id, title, and severity.
+  # Basic vulnerability information. Only includes ID, title, and severity.
   #
   class Vulnerability
 
@@ -60,7 +77,25 @@ module Nexpose
     attr_reader :severity
 
     def initialize(id, title, severity)
-      @id, @title, @severity = id, title, severity
+      @id, @title, @severity = id, title, severity.to_i
+    end
+  end
+
+  # Vulnerability Check information.
+  #
+  class VulnCheck < Vulnerability
+
+    attr_reader :check_id
+    attr_reader :categories
+    attr_reader :check_type
+
+    def initialize(json)
+      @id = json['Vuln ID']
+      @check_id = json['Vuln Check ID']
+      @title = json['Vulnerability']
+      @severity = json['Severity'].to_i
+      @check_type = json['Check Type']
+      @categories = json['Category'].split(/, */)
     end
   end
 
@@ -68,14 +103,14 @@ module Nexpose
   #
   class VulnerabilitySummary < Vulnerability
 
-    # PCI severity value for the vulnerability on a scale of 1 to 5. 
+    # PCI severity value for the vulnerability on a scale of 1 to 5.
     attr_accessor :pci_severity
 
     # Whether all checks for the vulnerability are safe.
     # Unsafe checks may cause denial of service or otherwise disrupt system performance.
     attr_accessor :safe
 
-    # A vulnerability is considered “credentialed” when all of its checks
+    # A vulnerability is considered "credentialed" when all of its checks
     # require credentials or if the check depends on previous authentication
     # during a scan.
     attr_accessor :credentials
@@ -103,12 +138,12 @@ module Nexpose
 
       vuln.pci_severity = xml.attributes['pciSeverity'].to_i
       vuln.safe = xml.attributes['safe'] == 'true'  # or xml.attributes['safe'] == '1'
-      vuln.added = Date::parse(xml.attributes['added'])
-      vuln.modified = Date::parse(xml.attributes['modified'])
+      vuln.added = Date.parse(xml.attributes['added'])
+      vuln.modified = Date.parse(xml.attributes['modified'])
       vuln.credentials = xml.attributes['requiresCredentials'] == 'true'
 
       # These three fields are optional in the XSD.
-      vuln.published = Date::parse(xml.attributes['published']) if xml.attributes['published']
+      vuln.published = Date.parse(xml.attributes['published']) if xml.attributes['published']
       vuln.cvss_vector = xml.attributes['cvssVector'] if xml.attributes['cvssVector']
       vuln.cvss_score = xml.attributes['cvssScore'].to_f if xml.attributes['cvssScore']
       vuln
@@ -164,332 +199,40 @@ module Nexpose
     end
   end
 
-  module NexposeAPI
-    include XMLUtils
-
-    ###################
-    # VULN EXCEPTIONS #
-    ###################
-
-    #-----------------------------------------------------------------------
-    # Returns an array of vulnerability exceptions and their associated
-    # attributes.
-    #
-    # @param status - (optional) The status of the vulnerability exception:
-    # "Under Review", "Approved", "Rejected"
-    #-----------------------------------------------------------------------
-    def vuln_exception_listing(status = nil)
-      option = {}
-
-      if status && !status.empty?
-        if status =~ /Under Review|Approved|Rejected/
-          option['status'] = status
-        else
-          raise ArgumentError.new 'The vulnerability status passed in is invalid!'
-        end
-      end
-
-      xml = make_xml('VulnerabilityExceptionListingRequest', option)
-      r = execute xml, '1.2'
-
-      if r.success
-        res = []
-        r.res.elements.each('//VulnerabilityException') do |ve|
-          submitter_comment = ve.elements['submitter-comment']
-          reviewer_comment = ve.elements['reviewer-comment']
-          res << {
-            :vuln_id => ve.attributes['vuln-id'],
-            :exception_id => ve.attributes['exception-id'],
-            :submitter => ve.attributes['submitter'],
-            :reviewer => ve.attributes['reviewer'],
-            :status => ve.attributes['status'],
-            :reason => ve.attributes['reason'],
-            :scope => ve.attributes['scope'],
-            :device_id => ve.attributes['device-id'],
-            :port_no => ve.attributes['port-no'],
-            :expiration_date => ve.attributes['expiration-date'],
-            :vuln_key => ve.attributes['vuln-key'],
-            :submitter_comment => submitter_comment.nil? ? '' : submitter_comment.text,
-            :reviewer_comment => reviewer_comment.nil? ? '' : reviewer_comment.text
-          }
-        end
-        res
-      else
-        false
-      end
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Creates a vulnerability exception.
-    #
-    # @param input - data used to create the vulnerability exception:
-    # :vuln_id - The Nexpose vulnerability ID.
-    # :reason - The reason for the exception
-    #         values - "False Positive", "Compensating Control", "Acceptable Use", "Acceptable Risk", "Other"
-    # :scope - The scope type  (NOTE: The case is important)
-    #        values - "All Instances", "All Instances on a Specific Asset", "Specific Instance of a specific Asset"
-    # :comment - A user comment
-    # :device-id - Used for specific instances related to "All Instances on a Specific Asset" AND "Specific Instance of Specific Asset"
-    # :port - All assets on this port related to "Specific Instance of a specific Asset"
-    # :vuln-key - The vulnerability key related to the "Specific Instance of a specific Asset"
-    #
-    # @returns exception-id - The Id associated with this create request
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_create(input)
-      options = {}
-
-      if input.nil?
-        raise ArgumentError.new 'The input element cannot be null'
-      end
-
-      vuln_id = input[:vuln_id]
-      unless vuln_id
-        raise ArgumentError.new 'The vulnerability ID is required'
-      end
-      options['vuln-id'] = vuln_id
-
-      reason = input[:reason]
-      if reason.nil? || reason.empty?
-        raise ArgumentError.new 'The reason is required'
-      end
-
-      unless reason =~ /False Positive|Compensating Control|Acceptable Use|Acceptable Risk|Other/
-        raise ArgumentError.new 'The reason type is invalid'
-      end
-      options['reason'] = reason
-
-      scope = input[:scope]
-      if scope.nil? || scope.empty?
-        raise ArgumentError.new 'The scope is required'
-      end
-
-      # For scope case matters.
-      unless scope =~ /All Instances|All Instances on a Specific Asset|Specific Instance of Specific Asset/
-        raise ArgumentError.new 'The scope type is invalid'
-      end
-
-      if scope =~ /All Instances on a Specific Asset|Specific Instance of Specific Asset/
-        device_id = input[:device_id]
-        vuln_key = input[:vuln_key]
-        port = input[:port]
-        if device_id
-          options['device-id'] = device_id
-        end
-
-        if scope =~ /All Instances on a Specific Asset/ && (vuln_key || port)
-          raise ArgumentError.new 'Vulnerability key or port cannot be used with the scope specified'
-        end
-
-        if vuln_key
-          options['vuln-key'] = vuln_key
-        end
-
-        if port
-          options['port-no'] = port
-        end
-      end
-      options['scope'] = scope
-
-      xml = make_xml('VulnerabilityExceptionCreateRequest', options)
-
-      comment = input[:comment]
-      if comment && !comment.empty?
-        comment_xml = make_xml('comment', {}, comment, false)
-        xml.add_element comment_xml
-      else
-        raise ArgumentError.new 'The comment cannot be empty'
-      end
-
-      r = execute xml, '1.2'
-      if r.success
-        r.res.elements.each('//VulnerabilityExceptionCreateResponse') do |vecr|
-          return vecr.attributes['exception-id']
-        end
-      else
-        false
-      end
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Resubmit a vulnerability exception.
-    #
-    # @param input - data used to create the vulnerability exception:
-    # :vuln_id - The Nexpose vulnerability ID. (required)
-    # :reason - The reason for the exception (optional)
-    #         values - "False Positive", "Compensating Control", "Acceptable Use", "Acceptable Risk", "Other"
-    # :comment - A user comment  (required)
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_resubmit(input)
-      options = {}
-
-      if input.nil?
-        raise ArgumentError.new 'The input element cannot be null'
-      end
-
-      exception_id = input[:exception_id]
-      unless exception_id
-        raise ArgumentError.new 'The exception ID is required'
-      end
-      options['exception-id'] = exception_id
-
-      reason = input[:reason]
-      if !reason.nil? && !reason.empty?
-        unless reason =~ /False Positive|Compensating Control|Acceptable Use|Acceptable Risk|Other/
-          raise ArgumentError.new 'The reason type is invalid'
-        end
-        options['reason'] = reason
-
-      end
-
-      xml = make_xml('VulnerabilityExceptionResubmitRequest', options)
-
-      comment = input[:comment]
-      if comment && !comment.empty?
-        comment_xml = make_xml('comment', {}, comment, false)
-        xml.add_element comment_xml
-      end
-
-      r = execute xml, '1.2'
-      r.success
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Allows a previously submitted exception that has not been approved to be withdrawn.
-    #
-    # @param exception_id - The exception id returned after the vuln exception was submitted for creation.
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_recall(exception_id)
-      xml = make_xml('VulnerabilityExceptionRecallRequest', {'exception-id' => exception_id})
-      r = execute xml, '1.2'
-      r.success
-    end
-
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Allows a submitted vulnerability exception to be approved.
-    #
-    # @param input:
-    # :exception_id - The exception id returned after the vuln exception was submitted for creation.
-    # :comment - An optional comment
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_approve(input)
-      exception_id = input[:exception_id]
-      unless exception_id
-        raise ArgumentError.new 'Exception Id is required'
-      end
-
-      xml = make_xml('VulnerabilityExceptionApproveRequest', {'exception-id' => exception_id})
-      comment = input[:comment]
-      if comment && !comment.empty?
-        comment_xml = make_xml('comment', {}, comment, false)
-        xml.add_element comment_xml
-      end
-
-      r = execute xml, '1.2'
-      r.success
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Rejects a submitted vulnerability exception to be approved.
-    #
-    # @param input:
-    # :exception_id - The exception id returned after the vuln exception was submitted for creation.
-    # :comment - An optional comment
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_reject(input)
-      exception_id = input[:exception_id]
-      unless exception_id
-        raise ArgumentError.new 'Exception Id is required'
-      end
-
-      xml = make_xml('VulnerabilityExceptionRejectRequest', {'exception-id' => exception_id})
-      comment = input[:comment]
-      if comment && !comment.empty?
-        comment_xml = make_xml('comment', {}, comment, false)
-        xml.add_element comment_xml
-      end
-
-      r = execute xml, '1.2'
-      r.success
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Updates a vulnerability exception comment.
-    #
-    # @param input:
-    # :exception_id - The exception id returned after the vuln exception was submitted for creation.
-    # :submitter_comment - The submitter comment
-    # :reviewer_comment - The reviewer comment
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_update_comment(input)
-      exception_id = input[:exception_id]
-      unless exception_id
-        raise ArgumentError.new 'Exception Id is required'
-      end
-
-      xml = make_xml('VulnerabilityExceptionUpdateCommentRequest', {'exception-id' => exception_id})
-      submitter_comment = input[:submitter_comment]
-      if submitter_comment && !submitter_comment.empty?
-        comment_xml = make_xml('submitter-comment', {}, submitter_comment, false)
-        xml.add_element comment_xml
-      end
-
-      reviewer_comment = input[:reviewer_comment]
-      if reviewer_comment && !reviewer_comment.empty?
-        comment_xml = make_xml('reviewer-comment', {}, reviewer_comment, false)
-        xml.add_element comment_xml
-      end
-
-      r = execute xml, '1.2'
-      r.success
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Update the expiration date for a vulnerability exception.
-    #
-    # @param input
-    # :exception_id - The exception id returned after the vulnerability exception was submitted for creation.
-    # :expiration_date - The new expiration date format: YYYY-MM-DD
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_update_expiration_date(input)
-      exception_id = input[:exception_id]
-      unless exception_id
-        raise ArgumentError.new 'Exception Id is required'
-      end
-
-      expiration_date = input[:expiration_date]
-      if expiration_date && !expiration_date.empty? && expiration_date =~ /\A\d{4}-(\d{2})-(\d{2})\z/
-        if $1.to_i > 12
-          raise ArgumentError.new 'The expiration date month value is invalid'
-        end
-        if $2.to_i > 31
-          raise ArgumentError.new 'The expiration date day value is invalid'
-        end
-      else
-        raise ArgumentError.new 'Expiration date is invalid'
-      end
-
-      options = {}
-      options['exception-id'] = exception_id
-      options['expiration-date'] = expiration_date
-      xml = make_xml('VulnerabilityExceptionUpdateExpirationDateRequest', options)
-      r = execute xml, '1.2'
-      r.success
-    end
-
-    #-------------------------------------------------------------------------------------------------------------------
-    # Deletes a submitted vulnerability exception to be approved.
-    #
-    # @param exception_id - The exception id returned after the vuln exception was submitted for creation.
-    #-------------------------------------------------------------------------------------------------------------------
-    def vuln_exception_delete(exception_id)
-      unless exception_id
-        raise ArgumentError.new 'Exception Id is required'
-      end
+  # Vulnerability finding information pulled from AJAX requests.
+  # Data uses a numeric, console-specific vuln ID, which may need to be
+  # cross-referenced to the String ID to be used elsewhere.
+  #
+  class VulnFinding
 
-      xml = make_xml('VulnerabilityExceptionDeleteRequest', {'exception-id' => exception_id})
-      r = execute xml, '1.2'
-      r.success
+    # Unique, console-specific identifier of the vulnerability.
+    attr_reader :id
+    # Vulnerability title.
+    attr_reader :title
+    attr_reader :cvss_score
+    attr_reader :cvss_vector
+    attr_reader :risk
+    # Date this exploit was published.
+    attr_reader :published
+    attr_reader :severity
+    # Number of instances of this vulnerabilty finding on an asset.
+    attr_reader :instances
+    # Main published exploit module against this vulnerability, if any.
+    attr_reader :exploit
+    # Whether known malware kits exploit this vulnerability.
+    attr_reader :malware
+
+    def initialize(json)
+      @id = json['vulnID']
+      @title = json['title']
+      @cvss_vector = json['cvssBase']
+      @cvss_score = json['cvssScore']
+      @risk = json['riskScore']
+      @published = Time.at(json['publishedDate'] / 1000)
+      @severity = json['severity']
+      @instances = json['vulnInstanceCount']
+      @exploit = json['mainExploit']
+      @malware = json['malwareCount']
     end
   end
 end