openvas-cli 0.1.1 → 0.2.0

data/lib/openvas-cli/vas_report.rb

@@ -1,118 +1,125 @@
 require 'vas_base'
 
-# Contains the details of a single OpenVAS report.
-class VasReport < VasBase
-  attr_accessor :report_id
-  attr_accessor :task_id
-  attr_accessor :task_name
-  attr_accessor :started_at
-  # Overall Status Only
-  attr_accessor :status
-  
-  validates :report_id, :presence => true, :UUID => true
-  validates :task_id,   :presence => true, :UUID => true
-  
-  # Pulls report details based off of the options passed.  By default, pulls all
-  # reports.
-  # === Options:
-  # [:report_id => [report_id]] Pulls a specific +report_id+.  If the id provided is bogus, an empty set is returned.
-  # [:filter => [array_of_filter_symbols]] Filters the report results by severity.  Valid symbols are: [:high, :medium, :low, :log, :deubg].
-  def self.get_all(options={})
-    params = {}
-    params[:report_id] = options[:report_id] if options[:report_id]
-    if options[:filter]
-      params[:levels] = ""
-      options[:filter].each { |f|
-        case f
-        when :high
-          params[:levels] += 'h'
-        when :medium
-          params[:levels] += 'm'
-        when :low
-          params[:levels] += 'l'
-        when :log
-          params[:levels] += 'g'
-        when :debug
-          params[:levels] += 'd'
+module OpenvasCli
+  # Contains the details of a single OpenVAS report.
+  class VasReport < VasBase
+    attr_accessor :report_id
+    attr_accessor :task_id
+    attr_accessor :task_name
+    attr_accessor :started_at
+    # Overall Status Only
+    attr_accessor :status
+    
+    validates :report_id, :presence => true, :UUID => true
+    validates :task_id,   :presence => true, :UUID => true, 
+              :unless => Proc.new { |report| report.empty? }
+    
+    # Pulls report details based off of the options passed.  By default, pulls all
+    # reports.
+    # === Options:
+    # [:report_id => [report_id]] Pulls a specific +report_id+.  If the id provided is bogus, an empty set is returned.
+    # [:filter => [array_of_filter_symbols]] Filters the report results by severity.  Valid symbols are: [:high, :medium, :low, :log, :deubg].
+    def self.get_all(options={})
+      params = {}
+      params[:report_id] = options[:report_id] if options[:report_id]
+      if options[:filter]
+        params[:levels] = ""
+        options[:filter].each { |f|
+          case f
+          when :high
+            params[:levels] += 'h'
+          when :medium
+            params[:levels] += 'm'
+          when :low
+            params[:levels] += 'l'
+          when :log
+            params[:levels] += 'g'
+          when :debug
+            params[:levels] += 'd'
+          end
+        }
+      end
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        if params.empty?
+          xml.get_reports
+        else
+          xml.get_reports(params)
         end
       }
-    end
-    
-    req = Nokogiri::XML::Builder.new { |xml|
-      if params.empty?
-        xml.get_reports
-      else
-        xml.get_reports(params)
+      
+      begin
+        repts = connection.send_receive(req.doc)
+      rescue VasExceptions::CommandException => e
+        raise e unless e.message =~ /Failed to find/i
+        return []
       end
-    }
-    
-    begin
-      repts = client.send_receive(req.doc)
-    rescue VasExceptions::CommandException => e
-      raise e unless e.message =~ /Failed to find/i
-      return []
-    end
-    
-    ret = []
-    repts.xpath('//report').each { |r|
-      r_id            = VasReport.new
-      r_id.report_id  = extract_value_from("@id", r)
-      r_id.task_id    = extract_value_from("task/@id", r)
-      r_id.task_name  = extract_value_from("task/name", r)
-      r_id.status     = extract_value_from("scan_run_status", r)
-      r_id.started_at = extract_value_from("scan_start", r)
       
-      r_id.result_count[:total]             = extract_value_from("result_count/full", r).to_i
-      r_id.result_count[:filtered]          = extract_value_from("result_count/filtered", r).to_i
-      r_id.result_count[:debug][:total]     = extract_value_from("result_count/debug/full", r).to_i
-      r_id.result_count[:debug][:filtered]  = extract_value_from("result_count/debug/filtered", r).to_i
-      r_id.result_count[:high][:total]      = extract_value_from("result_count/hole/full", r).to_i
-      r_id.result_count[:high][:filtered]   = extract_value_from("result_count/hold/filtered", r).to_i
-      r_id.result_count[:low][:total]       = extract_value_from("result_count/info/full", r).to_i
-      r_id.result_count[:low][:filtered]    = extract_value_from("result_count/info/filtered", r).to_i
-      r_id.result_count[:log][:total]       = extract_value_from("result_count/log/full", r).to_i
-      r_id.result_count[:log][:filtered]    = extract_value_from("result_count/log/filtered", r).to_i
-      r_id.result_count[:medium][:total]    = extract_value_from("result_count/warning/full", r).to_i
-      r_id.result_count[:medium][:filtered] = extract_value_from("result_count/warning/filtered", r).to_i
+      ret = []
+      repts.xpath('//report').each { |r|
+        r_id            = VasReport.new
+        r_id.report_id  = extract_value_from("@id", r)
+        r_id.task_id    = extract_value_from("task/@id", r)
+        r_id.task_name  = extract_value_from("task/name", r)
+        r_id.status     = extract_value_from("scan_run_status", r)
+        r_id.started_at = extract_value_from("scan_start", r)
+        
+        r_id.result_count[:total]             = extract_value_from("result_count/full", r).to_i
+        r_id.result_count[:filtered]          = extract_value_from("result_count/filtered", r).to_i
+        r_id.result_count[:debug][:total]     = extract_value_from("result_count/debug/full", r).to_i
+        r_id.result_count[:debug][:filtered]  = extract_value_from("result_count/debug/filtered", r).to_i
+        r_id.result_count[:high][:total]      = extract_value_from("result_count/hole/full", r).to_i
+        r_id.result_count[:high][:filtered]   = extract_value_from("result_count/hold/filtered", r).to_i
+        r_id.result_count[:low][:total]       = extract_value_from("result_count/info/full", r).to_i
+        r_id.result_count[:low][:filtered]    = extract_value_from("result_count/info/filtered", r).to_i
+        r_id.result_count[:log][:total]       = extract_value_from("result_count/log/full", r).to_i
+        r_id.result_count[:log][:filtered]    = extract_value_from("result_count/log/filtered", r).to_i
+        r_id.result_count[:medium][:total]    = extract_value_from("result_count/warning/full", r).to_i
+        r_id.result_count[:medium][:filtered] = extract_value_from("result_count/warning/filtered", r).to_i
+        
+        r.xpath("results/result").each { |result|
+          r_id.results << VasResult.parse_result_node(result)
+        }
+        
+        ret << r_id
+      }
       
-      r.xpath("results/result").each { |result|
-        r_id.results << VasResult.parse_result_node(result)
+      ret
+    end
+    
+    def to_xml
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_reports(:report_id => @report_id)
       }
       
-      ret << r_id
-    }
+      report = VasReport.connection.send_receive(req.doc)
+      
+      report.at_xpath('//report').to_xml
+    end
     
-    ret
-  end
-  
-  def to_xml
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_reports(:report_id => @report_id)
-    }
+    def task
+      @task ||= VasTask.get_all(:task_id => @task_id)[0]
+    end
+    
+    def results
+      @results ||= []
+    end
     
-    report = VasBase.client.send_receive(req.doc)
+    def result_count
+      unless @result_count
+        @result_count = {:total  => 0, :filtered => 0, 
+                         :debug  => {:total => 0, :filtered => 0},
+                         :log    => {:total => 0, :filtered => 0},
+                         :low    => {:total => 0, :filtered => 0},
+                         :medium => {:total => 0, :filtered => 0},
+                         :high   => {:total => 0, :filtered => 0}
+                         }
+      end
+      @result_count
+    end
     
-    report.at_xpath('//report').to_xml
-  end
-  
-  def task
-    @task ||= VasTask.get_all(:task_id => @task_id)[0]
-  end
-  
-  def results
-    @results ||= []
-  end
-  
-  def result_count
-    unless @result_count
-      @result_count = {:total  => 0, :filtered => 0, 
-                       :debug  => {:total => 0, :filtered => 0},
-                       :log    => {:total => 0, :filtered => 0},
-                       :low    => {:total => 0, :filtered => 0},
-                       :medium => {:total => 0, :filtered => 0},
-                       :high   => {:total => 0, :filtered => 0}
-                       }
+    def empty?
+      !(@result_count && @result_count[:total] > 0)
     end
-    @result_count
   end
 end

data/lib/openvas-cli/vas_result.rb

@@ -1,102 +1,103 @@
 require 'vas_base'
 require 'vas_override'
 
-class VasResult < VasBase
-  attr_accessor :result_id, :subnet, :host, :port, :rule_id, :threat,
-                :description, :notes, :overrides, :task_id
-                
-  validates :result_id, :presence=>true, :UUID=>true
-  
-  def self.get_all(options = {})
-    options[:sort_by] ||= :threat
-    
-    params = {:overrides => 0, :notes => 0}
-    if options[:task_id]
-      params[:task_id] = options[:task_id]
-      params[:apply_overrides] = 1 if options[:apply_overrides]
-    end
+module OpenvasCli
+  class VasResult < VasBase
+    attr_accessor :result_id, :subnet, :host, :port, :rule_id, :threat,
+                  :description, :notes, :overrides, :task_id
+                  
+    validates :result_id, :presence=>true, :UUID=>true
+      
+    def self.get_all(options = {})
+      options[:sort_by] ||= :threat
+      
+      params = {:overrides => 0, :notes => 0}
+      if options[:id]
+        params[:task_id] = options[:id]
+        params[:apply_overrides] = 1 if options[:apply_overrides]
+      end
 
-    levels = []    
-    if options[:filter]
-      options[:filter].each { |ft|
-        case ft
-        when :high
-          levels << "High"
-        when :medium
-          levels << "Medium"
-        when :low
-          levels << "Low"
-        when :log
-          levels << "Log"
-        when :debug
-          levels << "Debug"
-        end
-      }
-    end
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_results(params)
-    }
-    xml = client.send_receive(req.doc)
-    
-    results = {}
-    xml.xpath("//result").each { |xr|
-      id     = extract_value_from("@id", xr)
-      threat = extract_value_from("threat", xr)
-      if (levels.empty? || levels.include?(threat)) && results.has_key?(id) == false
-        res = parse_result_node(xr, options[:task_id])
-        results[res.result_id] = res
+      levels = []    
+      if options[:filter]
+        options[:filter].each { |ft|
+          case ft
+          when :high
+            levels << "High"
+          when :medium
+            levels << "Medium"
+          when :low
+            levels << "Low"
+          when :log
+            levels << "Log"
+          when :debug
+            levels << "Debug"
+          end
+        }
       end
-    }    
-    
-    ret = results.values
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_results(params)
+      }
+      xml = connection.send_receive(req.doc)
+      
+      results = {}
+      xml.xpath("//result").each { |xr|
+        id     = extract_value_from("@id", xr)
+        threat = extract_value_from("threat", xr)
+        if (levels.empty? || levels.include?(threat)) && results.has_key?(id) == false
+          res = parse_result_node(xr, options[:task_id])
+          results[res.result_id] = res
+        end
+      }    
+      
+      ret = results.values
 
-    #Sort Results
-    ret.sort!{ |a,b| a.result_id <=> b.result_id }       if options[:sort_by] == :result_id
-    ret.sort!{ |a,b| a.host <=> b.host }                 if options[:sort_by] == :host
-    ret.sort!{ |a,b| a.rule_id <=> b.rule_id }           if options[:sort_by] == :rule_id
-    ret.sort!{ |a,b| a.subnet <=> b.subnet }             if options[:sort_by] == :subnet
-    ret.sort!{ |a,b| b.threat_level <=> a.threat_level } if options[:sort_by] == :threat
-    
-    #Fake Pagination
-    if options[:start]
-      if options[:count]
-        ret = ret[options[:start], options[:count]]
-      else
-        ret = ret[options[:start], ret.length - options[:start]]
+      #Sort Results
+      ret.sort!{ |a,b| a.result_id <=> b.result_id }       if options[:sort_by] == :result_id
+      ret.sort!{ |a,b| a.host <=> b.host }                 if options[:sort_by] == :host
+      ret.sort!{ |a,b| a.rule_id <=> b.rule_id }           if options[:sort_by] == :rule_id
+      ret.sort!{ |a,b| a.subnet <=> b.subnet }             if options[:sort_by] == :subnet
+      ret.sort!{ |a,b| b.threat_level <=> a.threat_level } if options[:sort_by] == :threat
+      
+      #Fake Pagination
+      if options[:start]
+        if options[:count]
+          ret = ret[options[:start], options[:count]]
+        else
+          ret = ret[options[:start], ret.length - options[:start]]
+        end
       end
+      
+      ret
     end
     
-    ret
-  end
-  
-  def self.parse_result_node(node, task_id = nil)
-    res             = VasResult.new
-    res.result_id   = extract_value_from("@id", node)
-    res.threat      = extract_value_from("threat", node)
-    res.subnet      = extract_value_from("subnet", node)
-    res.host        = extract_value_from("host", node)
-    res.rule_id     = extract_value_from("nvt/@oid", node)
-    res.description = extract_value_from("description", node)
-    res.task_id     = task_id if task_id
+    def self.parse_result_node(node, task_id = nil)
+      res             = VasResult.new
+      res.result_id   = extract_value_from("@id", node)
+      res.threat      = extract_value_from("threat", node)
+      res.subnet      = extract_value_from("subnet", node)
+      res.host        = extract_value_from("host", node)
+      res.rule_id     = extract_value_from("nvt/@oid", node)
+      res.description = extract_value_from("description", node)
+      res.task_id     = task_id if task_id
+      
+      res
+    end
     
-    res
-  end
-  
-  def threat_level
-    case @threat
-    when "High"
-      5
-    when "Medium"
-      4
-    when "Low"
-      3
-    when "Log"
-      2
-    when "Debug"
-      1
-    else
-      0
+    def threat_level
+      case @threat
+      when "High"
+        5
+      when "Medium"
+        4
+      when "Low"
+        3
+      when "Log"
+        2
+      when "Debug"
+        1
+      else
+        0
+      end
     end
   end
-  
 end

data/lib/openvas-cli/vas_schedule.rb

@@ -1,63 +1,171 @@
 require 'vas_base'
+require 'time'
 
-class VasSchedule < VasBase
-  attr_accessor :schedule_id, :name, :comment, :first_time, :next_time, 
-                :period, :period_months, :duration, :in_use, :task_ids
-                
-  validates :schedule_id, :presence => true, :UUID => true
-  
-  def self.get_all(options = {})
-    
-    manual_sort = false
-    params = {:details => '1'}
-    params[:schedule_id] = options[:schedule_id] if options[:schedule_id]
-    case options[:sort_by]
-    when :schedule_id
-      params[:sort_field] = 'id'
-    when :next_time
-      manual_sort = true
-    when :first_time
-      params[:first_time] = 'first_time'
-    else
-      params[:sort_field] = 'name'
-    end
-    
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_schedules(params)
-    }
-    
-    schedules = client.send_receive(req.doc)
-    
-    ret = []
-    schedules.xpath("//schedule").each { |s|
-      sch               = VasSchedule.new
-      sch.schedule_id   = extract_value_from("@id", s)
-      sch.name          = extract_value_from("name", s)
-      sch.comment       = extract_value_from("comment", s)
-      t_time            = extract_value_from("first_time", s)
-      sch.first_time    = Time.parse(t_time) unless t_time == ""
-      t_time            = extract_value_from("next_time", s)
-      sch.next_time     = Time.parse(t_time) unless t_time == "" or t_time == "done"
-      sch.period        = extract_value_from("period", s).to_i
-      sch.period_months = extract_value_from("period_months", s).to_i
-      t_time            = extract_value_from("duration", s)
-      unless t_time == ""
-        sch.duration = t_time.to_i unless t_time == 0
-      end
-      sch.in_use        = extract_value_from("in_use", s).to_i > 0
-      sch.task_ids         = []
-      s.xpath('tasks/task/@id') { |t|
-        sch.task_ids << t.value
+module OpenvasCli
+  class VasSchedule < VasBase
+    attr_reader :name
+    attr_reader :comment
+    attr_reader :first_time
+    attr_accessor :next_time
+    attr_reader :period
+    attr_accessor :duration
+    attr_accessor :in_use
+    attr_accessor :task_ids
+                  
+    validates :id, :UUID => true, :if => Proc.new { |s| s.id }
+    validates :name, :presence => true, :length => { :minimum => 1 }
+    validates :first_time, :presence => true
+    
+    define_attribute_methods [:name, :comment, :first_time, :period]
+    
+    def initialize(params = {})
+      @name          = params[:name]          if params[:name]  
+      @comment       = params[:comment]       if params[:comment]
+      @first_time    = params[:first_time]    if params[:first_time]
+      @period        = params[:period]        if params[:period]
+      reset_changes
+    end
+    
+    def changed?
+      local_changes = false
+      local_changes = @period.changed? if @period
+      
+      local_changes || super
+    end
+    
+    def name=(v)
+      name_will_change! unless @name == v
+      @name = v
+    end
+    
+    def comment=(v)
+      comment_will_change! unless @comment == v
+      @comment = v
+    end
+    
+    def first_time=(v)
+      first_time_will_change! unless @first_time == v
+      @first_time = v
+    end
+    
+    def period=(v)
+      period_will_change! unless @period == v
+      @period = v
+    end
+    
+    def destroy!
+      return unless @id
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.delete_schedule(:schedule_id => @id)
       }
-      ret << sch
-    }
-   
-    if manual_sort
-      if options[:sort_by] == :next_time
-        ret.sort!{ |a,b| a.next_time <=> b.next_time }
+      
+      VasSchedule.connection.send_receive(req.doc)
+      @id = nil
+      reset_changes
+    end
+    
+    def save!
+      return unless changed? || @id == nil
+      
+      if @id
+        destroy!
       end
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.create_schedule {
+          xml.name    { xml.text(@name) }
+          xml.comment { xml.text(@comment) } if @comment
+          xml.first_time {
+            xml.minute       { xml.text(@first_time.min) }
+            xml.hour         { xml.text(@first_time.hour) }
+            xml.day_of_month { xml.text(@first_time.day) }
+            xml.month        { xml.text(@first_time.month) }
+            xml.year         { xml.text(@first_time.year) }
+          }
+          xml.duration      { xml.text(@duration ? @duration : 0) }
+          xml.period { 
+            if @period
+              xml.text(@period.number)
+              xml.unit { xml.text(@period.period.to_s) }
+            else
+              xml.text(0)
+              xml.unit { xml.text("second") }
+            end
+          }
+        }
+      }
+      
+      resp = VasSchedule.connection.send_receive(req.doc)
+      @id = VasSchedule.extract_value_from("/create_schedule_response/@id", resp) unless @id
+      reset_changes
     end
     
-    ret
+    def self.get_all(options = {})
+      
+      manual_sort = false
+      params = {:details => '1'}
+      params[:schedule_id] = options[:id] if options[:id]
+      case options[:sort_by]
+      when :schedule_id
+        params[:sort_field] = 'id'
+      when :next_time
+        manual_sort = true
+      when :first_time
+        params[:first_time] = 'first_time'
+      else
+        params[:sort_field] = 'name'
+      end
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_schedules(params)
+      }
+      ret = []
+      
+      begin
+        schedules = connection.send_receive(req.doc)
+        schedules.xpath("//schedule").each { |s|
+          sch               = VasSchedule.new
+          sch.id            = extract_value_from("@id", s)
+          sch.name          = extract_value_from("name", s)
+          sch.comment       = extract_value_from("comment", s)
+          t_time            = extract_value_from("first_time", s)
+          sch.first_time    = Time.parse(t_time) unless t_time == ""
+          t_time            = extract_value_from("next_time", s)
+          sch.next_time     = Time.parse(t_time) unless t_time == "" or t_time == "done"
+
+          period_num = extract_value_from("period", s).to_i
+          if period_num > 0
+            sch.period = VasPeriod.from_seconds(period_num)
+          end
+          
+          period_num = extract_value_from("period_months", s).to_i
+          if period_num > 0
+            sch.period = VasPeriod.from_months(period_num)
+          end
+          
+          t_time            = extract_value_from("duration", s)
+          unless t_time == ""
+            sch.duration = t_time.to_i unless t_time == 0
+          end
+
+          sch.in_use        = extract_value_from("in_use", s).to_i > 0
+          sch.task_ids         = []
+          s.xpath('tasks/task/@id') { |t|
+            sch.task_ids << t.value
+          }
+          ret << sch
+        }
+       
+        if manual_sort
+          if options[:sort_by] == :next_time
+            ret.sort!{ |a,b| a.next_time <=> b.next_time }
+          end
+        end
+      rescue VasExceptions::CommandException => e
+        raise e unless e.message =~ /Failed to find schedule/i
+      end    
+      ret
+    end
   end
 end