openvas-cli 0.1.1 → 0.2.0

data/lib/openvas-cli/vas_exceptions.rb

@@ -1,8 +1,10 @@
-# Continer for all cusom exceptions used in openvas-cli.
-module VasExceptions
-  # Thrown when the OpenVAS management service rejects a command for some reason.
-  class CommandException < StandardError; end
-  # Thrown when some sort of communications error (like a timeout or unexpected
-  # end-of-file) is encountered.
-  class CommunicationException < StandardError; end
+module OpenvasCli
+  # Continer for all cusom exceptions used in openvas-cli.
+  module VasExceptions
+    # Thrown when the OpenVAS management service rejects a command for some reason.
+    class CommandException < StandardError; end
+    # Thrown when some sort of communications error (like a timeout or unexpected
+    # end-of-file) is encountered.
+    class CommunicationException < StandardError; end
+  end
 end

data/lib/openvas-cli/vas_lsc_credential.rb

@@ -0,0 +1,110 @@
+require 'vas_base'
+
+module OpenvasCli
+  class VasLscCredential < VasBase
+
+    attr_accessor :name
+    attr_accessor :login
+    attr_accessor :comment
+    attr_accessor :in_use
+    attr_accessor :type
+    attr_accessor :public_key
+    attr_accessor :package
+    attr_accessor :package_type
+    attr_accessor :password 
+    
+    validates :name,  :presence => true, :length => {:minimum => 1}
+    validates :login, :presence => true, :length => {:minimum => 1} 
+    
+    def initialize(params = {})
+      @id = params[:id] if params[:id]  
+      @name = params[:name] if params[:name]
+      @login = params[:login] if params[:login] 
+      @comment = params[:comment] if params[:comment] 
+      @password = params[:password] if params[:password]
+    end
+    
+    def target_keys
+      @target_keys ||= []
+    end
+    
+    def targets
+      @targets ||= []
+    end
+    
+    def save!
+      raise "VasLscCredential is not valid" unless valid?
+      
+      if @id
+        #update
+        req = Nokogiri::XML::Builder.new { |xml|
+          xml.modify_lsc_credential(:lsc_credential_id => @id) {
+            xml.name     { xml.text(@name) }
+            xml.comment  { xml.text(@comment) } if @comment
+            xml.login    { xml.text(@login) }
+            xml.password { xml.text(@password) } if @password
+          } 
+        }
+      else
+        #create
+        req = Nokogiri::XML::Builder.new { |xml|
+          xml.create_lsc_credential {
+            xml.name     { xml.text(@name) }
+            xml.comment  { xml.text(@comment) } if @comment
+            xml.login    { xml.text(@login) }
+            xml.password { xml.text(@password) } if @password
+          }
+        }
+      end
+      
+      resp = VasLscCredential.connection.send_receive(req.doc)
+      
+      @id = VasLscCredential.extract_value_from("create_lsc_credential_response/@id", resp) unless @id
+    end
+    
+    def destroy!
+      return unless @id
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.delete_lsc_credential( :lsc_credential_id => @id )
+      }
+      
+      VasLscCredential.connection.send_receive(req.doc)
+    end
+    
+    def self.get_all(options={})
+      params = {:sort_field => 'name'}
+      params[:lsc_credential_id] = options[:id] if options[:id]
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_lsc_credentials(params)
+      }
+      
+      resp = connection.send_receive(req.doc)
+      
+      ret = []
+      resp.xpath("//lsc_credential").each { |cred|
+        ret << from_xml_node(cred)
+      }
+      
+      ret
+    end
+    
+    def self.from_xml_node(node)
+      ret              = VasLscCredential.new
+      ret.id           = extract_value_from("@id", node)
+      ret.name         = extract_value_from("name", node)
+      ret.login        = extract_value_from("login", node)
+      ret.comment      = extract_value_from("comment", node)
+      ret.in_use       = extract_value_from("in_use", node).to_i > 0
+      ret.type         = extract_value_from("type", node)
+      ret.public_key   = extract_value_from("public_key", node)
+      ret.package      = extract_value_from("package", node)
+      ret.package_type = extract_value_from("package/@format", node)
+      
+      node.xpath("targets/target").each { |t|
+        ret.target_keys << extract_value_from("@id", t)
+      }
+      
+      ret
+    end
+  end
+end

data/lib/openvas-cli/vas_nvt.rb

@@ -1,70 +1,70 @@
 require 'vas_base'
 
-# Describes a NSIS/OpenVAS scan rule.
-#--
-# TODO: Filter by other useful fields
-# TODO: Find external links for more information
-# TODO: Redcloth and Autolink description
-# TODO: Implement sorting options[:sort_by]
-#++
-class VasNVT < VasBase
-  # Unique identifier for rule. 
-  attr_accessor :oid
-  # Human readable name of the rule.
-  attr_accessor :name
-  
-  attr_accessor :category
-  attr_accessor :copyright
-  attr_accessor :description
-  attr_accessor :summary 
-  attr_accessor :family
-  attr_accessor :version
-  attr_accessor :cvss_base
-  attr_accessor :risk_factor
-  attr_accessor :cve_id
-  attr_accessor :bugtraq_id
-  attr_accessor :xrefs
-  attr_accessor :tags
-  attr_accessor :preferences
-                
-  validates :oid, :presence => true, :OID => true
-  
-  # Pulls VasNVT rules that match the provided options.
-  #
-  # === Options:
-  # [:nvt_oid => [VasNVT.oid]] will pull only the NVT rule that matches the given OID
-  # [:family => [VasFamily.name]] will pull all NVT rules for the specified family
-  def self.get_all(options = {})
-    params = {:details => '1'}
-    params[:nvt_oid] = options[:oid] if options[:oid]
-    params[:family]  = options[:family] if options[:family]
-  
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_nvts(params)
-    }
+module OpenvasCli
+  # Describes a NSIS/OpenVAS scan rule.
+  #--
+  # TODO: Filter by other useful fields
+  # TODO: Find external links for more information
+  # TODO: Redcloth and Autolink description
+  # TODO: Implement sorting options[:sort_by]
+  #++
+  class VasNVT < VasBase
+    # Human readable name of the rule.
+    attr_accessor :name
     
-    rules = client.send_receive(req.doc)
+    attr_accessor :category
+    attr_accessor :copyright
+    attr_accessor :description
+    attr_accessor :summary 
+    attr_accessor :family
+    attr_accessor :version
+    attr_accessor :cvss_base
+    attr_accessor :risk_factor
+    attr_accessor :cve_id
+    attr_accessor :bugtraq_id
+    attr_accessor :xrefs
+    attr_accessor :tags
+    attr_accessor :preferences
     
-    ret = []
-    rules.xpath("//nvt").each { |nvt|
-      rule             = VasNVT.new
-      rule.oid         = extract_value_from("@oid", nvt)
-      rule.name        = extract_value_from("name", nvt)
-      rule.category    = extract_value_from("category", nvt)
-      rule.copyright   = extract_value_from("copyright", nvt)
-      rule.description = extract_value_from("description", nvt).strip
-      rule.summary     = extract_value_from("summary", nvt)
-      rule.family      = extract_value_from("family", nvt)
-      rule.version     = extract_value_from("version", nvt)
-      rule.cvss_base   = extract_value_from("cvss_base", nvt)
-      rule.risk_factor = extract_value_from("risk_factor", nvt)
-      rule.cve_id      = extract_value_from("cve_id", nvt)
-      rule.bugtraq_id  = extract_value_from("bugtraq_id", nvt)
-      rule.xrefs       = extract_value_from("xrefs", nvt).split(/, ?/)
-      rule.tags        = extract_value_from("tags", nvt).split(/, ?/)
-      ret << rule
-    }
+    validates :id, :OID => true, :presence => true
+    # Pulls VasNVT rules that match the provided options.
+    #
+    # === Options:
+    # [:id => [VasNVT.oid]] will pull only the NVT rule that matches the given OID
+    # [:family => [VasFamily.name]] will pull all NVT rules for the specified family
+    def self.get_all(options = {})
+      params = {:details => '1'}
+      params[:nvt_oid] = options[:id] if options[:id]
+      params[:family]  = options[:family] if options[:family]
+      params[:config_id] = options[:config_id] if options[:config_id]
     
-    ret
-  end  
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_nvts(params)
+      }
+      
+      rules = connection.send_receive(req.doc)
+      
+      ret = []
+      rules.xpath("/get_nvts_response/nvt").each { |nvt|
+        rule             = VasNVT.new
+        rule.id          = extract_value_from("@oid", nvt)
+        rule.name        = extract_value_from("name", nvt)
+        rule.category    = extract_value_from("category", nvt)
+        rule.copyright   = extract_value_from("copyright", nvt)
+        rule.description = extract_value_from("description", nvt).strip
+        rule.summary     = extract_value_from("summary", nvt)
+        rule.family      = extract_value_from("family", nvt)
+        rule.version     = extract_value_from("version", nvt)
+        rule.cvss_base   = extract_value_from("cvss_base", nvt)
+        rule.risk_factor = extract_value_from("risk_factor", nvt)
+        rule.cve_id      = extract_value_from("cve_id", nvt)
+        rule.bugtraq_id  = extract_value_from("bugtraq_id", nvt)
+        rule.xrefs       = extract_value_from("xrefs", nvt).split(/, ?/)
+        rule.tags        = extract_value_from("tags", nvt).split(/, ?/)
+        ret << rule
+      }
+      
+      ret
+    end  
+  end
 end

data/lib/openvas-cli/vas_nvt_family.rb

@@ -1,37 +1,46 @@
 require 'vas_base'
 
-# Category for NVT rules
-class VasNVTFamily < VasBase
-  # Category Name
-  attr_accessor :name
-  # Number of rules in the family
-  attr_accessor :nvt_count
-  
-  validates :name, :presence => true, :length => {:minimum => 1}
-  
-  # Pulls all NVT Families defined on the server.
-  #
-  # === Options:
-  # None.
-  #--
-  # TODO: Implement options[:sort_by]
-  #++
-  def self.get_all(options = {})
-  
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_nvt_families
-    }
+module OpenvasCli
+  # Category for NVT rules
+  class VasNVTFamily < VasBase
+    # Category Name
+    attr_accessor :name
+    # Number of rules in the family
+    attr_accessor :nvt_count
+    attr_accessor :is_growing
     
-    fams = client.send_receive(req.doc)
+    validates :name, :presence => true, :length => {:minimum => 1}
     
-    ret = []
-    fams.xpath('//family').each { |f|
-      family           = VasNVTFamily.new
-      family.name      = extract_value_from('name', f)
-      family.nvt_count = extract_value_from('max_nvt_count', f).to_i
-      ret << family
-    }
+    # Pulls all NVT Families defined on the server.
+    #
+    # === Options:
+    # None.
+    #--
+    # TODO: Implement options[:sort_by]
+    #++
+    def self.get_all(options = {})
     
-    ret
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_nvt_families
+      }
+      
+      fams = connection.send_receive(req.doc)
+      
+      ret = []
+      fams.xpath('//family').each { |f|
+        ret << from_xml_node(f)
+      }
+      
+      ret
+    end
+    
+    def self.from_xml_node(node)
+      family            = VasNVTFamily.new
+      family.name       = extract_value_from('name', node)
+      family.nvt_count  = extract_value_from('max_nvt_count', node).to_i
+      family.is_growing = (extract_value_from("growing", node).to_i > 0)
+
+      family
+    end
   end
 end

data/lib/openvas-cli/vas_override.rb

@@ -1,7 +1,9 @@
 require 'vas_base'
 
-# NOT IMPLEMENTED
-class VasOverride
-  attr_accessor :task_id, :original_threat, :rule_id, :is_new
-  
+module OpenvasCli
+  # NOT IMPLEMENTED
+  class VasOverride < VasBase
+    attr_accessor :task_id, :original_threat, :rule_id, :is_new
+    
+  end
 end

data/lib/openvas-cli/vas_period.rb

@@ -0,0 +1,89 @@
+require 'active_model'
+
+module OpenvasCli
+  class VasPeriod
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    include Comparable
+    
+    attr_reader :number
+    attr_reader :period
+    
+    define_attribute_methods [:number, :period]
+    
+    validates :number, :numericality => { :greater_than_or_equal_to => 0 }
+    validates :period, :inclusion => [:second, :minute, :hour, :day, :month, :year]
+    
+    def initialize(params={})
+      @number = params[:number] if params[:number]
+      @period = params[:period] if params[:period]
+    end
+    
+    def number=(v)
+      number_will_change! unless @number == v
+      @number = v
+    end
+    
+    def period=(v)
+      period_will_change! unless @period == v
+      @period = v
+    end
+    
+    def <=> (rhs)
+      to_seconds - rhs.to_seconds
+    end
+    
+    def + (rhs)
+      if rhs.kind_of? VasPeriod
+        VasPeriod.from_seconds(to_seconds + rhs.to_seconds)
+      else
+        VasPeriod.from_seconds(to_seconds + rhs)
+      end
+    end
+    
+    def - (rhs)
+      if rhs.kind_of? VasPeriod
+        VasPeriod.from_seconds(to_seconds - rhs.to_seconds)
+      else
+        VasPeriod.from_seconds(to_seconds - rhs)
+      end
+    end
+    
+    def to_seconds
+      case @period
+      when :year
+        @number * 365.25 * 86400
+      when :month
+        @number * 365.25 * 86400 / 12
+      when :day
+        @number * 86400
+      when :hour
+        @number * 3600
+      when :minute
+        @number * 60
+      else
+        @number
+      end
+    end
+
+    def self.from_seconds(seconds)
+      if seconds % 86400 == 0
+        VasPeriod.new(:number => seconds / 86400, :period => :day)
+      elsif seconds % 3600 == 0
+        VasPeriod.new(:number => seconds / 3600, :period => :hour)
+      elsif seconds % 60 == 0
+        VasPeriod.new(:number => seconds / 60, :period => :minute)
+      else
+        VasPeriod.new(:number => seconds, :period => :second)
+      end
+    end 
+    
+    def self.from_months(months)
+      if months % 12 == 0
+        VasPeriod.new(:number => months / 12, :period => :month)
+      else
+        VasPeriod.new(:number => months, :period => :month)
+      end
+    end
+  end
+end

data/lib/openvas-cli/vas_preference.rb

@@ -1,59 +1,149 @@
 require 'vas_base'
 require 'nokogiri'
 
-# A name-value pair for OpenVAS configuration preferences.  If inspecting a 
-# specific configuration set, +config_id+ will be populated.  If +config_id+ is 
-# non-existant, then the preference is a system-wide default.
-#--
-# TODO: Implement write functions
-#++
-class VasPreference < VasBase
-  # Name of the configuration preference.
-  attr_accessor :name
-  # Value used for the preference.
-  attr_accessor :value
-  # Configuration Identifier.  If +nil+, the preference is a system-wide
-  # default.
-  attr_accessor :config_id
+module OpenvasCli
+  # A name-value pair for OpenVAS configuration preferences.  If inspecting a 
+  # specific configuration set, +config_id+ will be populated.  If +config_id+ is 
+  # non-existant, then the preference is a system-wide default.
+  class VasPreference < VasBase
+    # Type of value expected :boolean, :choice, :text
+    attr_accessor :val_type
+    
+    attr_accessor :val_type_desc
+    
+    # Configuration Identifier.  If +nil+, the preference is a system-wide
+    # default.
+    attr_accessor :config_id
+    
+    # NVT id
+    attr_accessor :nvt_id
 
-  validates :name, :presence => true, :length=>{:minimum => 1}
-  
-  # Pulls Vas preferences.
-  # === Options:
-  # [:nvt_oid => [oid]] pulls preferences associated associated with the provided VasNVT.oid
-  # [:name => [name]] pulls the preference with the specified name
-  # [:sort_by => [field_name]] filters the results by the provided field name.  Valid symbols are, :name, :value, :config_id.
-  def self.get_all(options={})
-    manual_filter = false
-    params = {}
-    params[:nvt_oid]    = options[:nvt_oid] if options[:nvt_oid]
-    manual_filter       = true              if options[:name]
-    
-    req = Nokogiri::XML::Builder.new { |xml|
-      if params.empty?
-        xml.get_preferences
-      else
-        xml.get_preferences(params)
-      end
-    }
-    
-    prefs = client.send_receive(req.doc)
-    ret = []
-    prefs.xpath("//preference").each { |p|
-      pref       = VasPreference.new
-      pref.name  = extract_value_from("name", p)
-      pref.value = extract_value_from("value", p)
-      if manual_filter
-        ret << pref if options[:name] && options[:name] == pref.name
+    validates :name, :presence => true, :length=>{:minimum => 1}
+    
+    define_attribute_methods [:name, :value]
+    
+    def name
+      @name
+    end
+    
+    def name=(val)
+      name_will_change! unless val == @name
+      @name = val
+    end
+    
+    def value
+      @value
+    end
+    
+    def value=(val)
+      value_will_change! unless val == @value
+      @value = val
+    end
+    
+    def initialize(attributes={})
+      @name      = attributes[:name]      if attributes[:name]  
+      @value     = attributes[:value]     if attributes[:value]
+      @config_id = attributes[:config_id] if attributes[:config_id]
+    end
+    
+    def config
+      @config ||= VasConfig.get_all(:id => @config_id)[0]
+    end
+    
+    def nvt
+      @nvt ||= VasNVT.get_all(:id => @nvt_id)[0]
+    end
+    
+    def val_choices
+      @val_choices ||= []
+    end
+    
+    def full_name
+      if @nvt_id && !@nvt_id.empty?
+        "#{nvt.name}[#{@val_type_desc}]:#{@name}"
       else
-        ret << pref
+        @name
       end
-    }
+    end
+    
+    def save!
+      raise "Cannot save a preference that is not tied to a configuration" unless @config_id
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.modify_config(:config_id => @config_id) {
+          xml.preference {
+            xml.nvt(:oid=>@nvt_id) if @nvt_id && !@nvt_id.empty?
+            xml.name  { xml.text(full_name) }
+            xml.value { 
+              if @val_type == :boolean
+                xml.text(Base64.encode64(@value ? "yes" : "no"))
+              else
+                xml.text(Base64.encode64(@value))
+              end 
+            }
+          }
+        } 
+      }
     
-    ret.sort!{ |a,b| a.name <=> b.name }           if params[:sort_by] == :name
-    ret.sort!{ |a,b| a.value <=> b.value }         if params[:sort_by] == :value
-    ret.sort!{ |a,b| a.config_id <=> b.config_id } if params[:sort_by] == :config_id
+      VasPreference.connection.send_receive(req.doc)
+    end
     
-    ret    
+    # Pulls Vas preferences.
+    # === Options:
+    # [:nvt_oid => [oid]] pulls preferences associated associated with the provided VasNVT.oid
+    # [:name => [name]] pulls the preference with the specified name
+    # [:sort_by => [field_name]] filters the results by the provided field name.  Valid symbols are, :name, :value, :config_id.
+    def self.get_all(options={})
+      manual_filter = false
+      params = {}
+      params[:nvt_oid]    = options[:nvt_oid] if options[:nvt_oid]
+      manual_filter       = true              if options[:name]
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        if params.empty?
+          xml.get_preferences
+        else
+          xml.get_preferences(params)
+        end
+      }
+      
+      prefs = connection.send_receive(req.doc)
+      ret = []
+      prefs.xpath("//preference").each { |p|
+        pref       = from_xml_node(p)
+        if manual_filter
+          ret << pref if options[:name] && options[:name] == pref.name
+        else
+          ret << pref
+        end
+      }
+      
+      ret.sort!{ |a,b| a.name <=> b.name }           if params[:sort_by] == :name
+      ret.sort!{ |a,b| a.value <=> b.value }         if params[:sort_by] == :value
+      ret.sort!{ |a,b| a.config_id <=> b.config_id } if params[:sort_by] == :config_id
+      
+      ret    
+    end
+    
+    def self.from_xml_node(node)
+      pref        = VasPreference.new
+      pref.name   = extract_value_from("name", node)
+      pref.value  = extract_value_from("value", node)
+      pref.nvt_id = extract_value_from("nvt/@oid", node)
+      pref.val_type_desc = extract_value_from("type", node)
+      case pref.val_type_desc
+        when "checkbox"
+          pref.val_type = :boolean
+          pref.value = pref.value == "yes" ? true : false
+        when "radio"
+          pref.val_type = :choice
+          pref.val_choices << pref.value
+          node.xpath("alt").each { |alt|
+            pref.val_choices << alt.text
+          }
+        else
+          pref.val_type = :text
+      end
+      pref
+    end
   end
 end