openvas-cli 0.1.1 → 0.2.0

data/lib/openvas-cli/vas_target.rb

@@ -1,28 +1,205 @@
 require 'nokogiri'
+require 'ipaddress'
+require 'vas_lsc_credential'
+require 'vas_task'
 
-class VasTarget < VasBase
-  attr_accessor :vas_id, :name, :hosts, :comment, :credential
-  
-  validates :vas_id, :UUID => true
-  
-  def self.get_all
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_targets(:tasks=>0)
-    }
-    
-    targets = client.send_receive(req.doc)
+module OpenvasCli
+  class VasTarget < VasBase
+    attr_reader :name
+    attr_reader :comment
+    attr_reader :port_range
+    attr_accessor :in_use
+    
+    define_attribute_methods [:name, :comment, :port_range, :hosts]
+    
+    def name=(val)
+      name_will_change! unless val == @name
+      @name = val
+    end
+    
+    def comment=(val)
+      comment_will_change! unless val == @comment
+      @comment = val
+    end
+    
+    def port_range=(val)
+      port_range_will_change! unless val == @port_range
+      @port_range = val 
+    end
+   
+    def changed?
+      local_changes = false
+      local_changes = !@org_hosts.eql?(@hosts) if @org_hosts 
+    
+      unless local_changes == true
+        local_changes = credential_changed?(:ssh) || credential_changed?(:smb)
+      end
+      
+      local_changes ||  super
+    end
+   
+    validates :id, :UUID => true, :if => Proc.new { |o| o.id }
+    validates :name, :presence => true, :length => { :minimum => 1 }
 
-    ret = []
-    targets.xpath('//target').each { |t|
-      targ         = VasTarget.new
-      targ.vas_id  = extract_value_from("@id", t)
-      targ.name    = extract_value_from("name", t)
-      host_string  = extract_value_from("hosts", t)
-      targ.hosts   = host_string.split(", ")
-      targ.comment = extract_value_from("comment", t)
-      ret << targ
-    }
-    
-    ret
+    def self.get_local_subnets
+      adrs = []
+      `ifconfig`.split("\n").each { |cmd|
+        if cmd =~ /inet addr:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+.*Mask:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/i
+          adrs << IPAddress("#{$1}/#{$2}") unless $1 == '127.0.0.1'
+        end
+      }
+      
+      adrs.collect{ |a| a.network.to_string }    
+    end
+
+    def initialize(params = {})
+      @id = params[:id] if params[:id]
+      @name = params[:name] if params[:name]
+      @hosts = params[:hosts] if params[:hosts]
+      @comment = params[:comment] if params[:comment]
+      @port_range = params[:port_range] if params[:port_range]
+    
+      @org_hosts = @hosts.collect { |h| h } if @hosts
+      
+      reset_changes
+    end
+
+    def credentials
+      @credentials ||= get_credentials
+    end
+    
+    def credential_keys
+      @credential_keys ||= { :smb => nil, :ssh => nil }
+    end
+    
+    def tasks
+      @tasks ||= get_tasks
+    end
+    
+    def task_keys
+      @task_keys ||= []
+    end
+    
+    def hosts
+      @hosts ||= []
+    end
+    
+    def hosts=(val)
+      hosts_will_change! unless @hosts.eql?(val)
+      @host = val
+      
+      @org_hosts = val.collect { |h| h } if val
+    end  
+    
+    def save!
+      if @id
+        destroy!
+      end
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.create_target {
+          xml.name       { xml.text(@name) }
+          xml.comment    { xml.text(@comment) } if @comment
+          xml.hosts      { xml.text(@hosts.join(', ')) }
+          xml.ssh_lsc_credential(:id => credentials[:ssh].id) if credentials[:ssh]
+          xml.smb_lsc_credential(:id => credentials[:smb].id) if credentials[:smb]
+          xml.port_range { xml.text(@port_range) } if @port_range
+        }
+      }
+      resp = VasTarget.connection.send_receive(req.doc)
+      
+      @id = VasTarget.extract_value_from("create_target_response/@id", resp)
+      
+      reset_changes
+    end
+    
+    def destroy!
+      return unless @id
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.delete_target(:target_id => @id)
+      }
+      
+      VasTarget.connection.send_receive(req.doc)
+      
+      @id = nil
+    end
+    
+    def self.create!(params={})
+      t = VasTarget.new(params)
+      t.save!
+      
+      t
+    end
+    
+    def self.get_all(options = {})
+      params = {:tasks => 1}
+      params[:target_id] = options[:id] if options[:id]
+      
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_targets(params)
+      }
+      ret = []
+      
+      begin    
+        targets = connection.send_receive(req.doc)
+        targets.xpath('//target').each { |t|
+          targ                       = VasTarget.new
+          targ.id                    = extract_value_from("@id", t)
+          targ.name                  = extract_value_from("name", t)
+          host_string                = extract_value_from("hosts", t)
+          targ.hosts                 << host_string.split(/, /)
+          targ.comment               = extract_value_from("comment", t)
+          targ.port_range            = extract_value_from("port_range", t)
+          targ.in_use                = extract_value_from("in_use", t).to_i > 0
+          targ.credential_keys[:ssh] = extract_value_from("ssh_lsc_credential/@id", t)
+          targ.credential_keys[:smb] = extract_value_from("smb_lsc_credential/@id", t)
+          
+          
+          t.xpath('tasks/task').each { |task|
+            targ.task_keys << extract_value_from("@id", task)
+          }
+          
+          ret << targ
+        }
+      
+      rescue VasExceptions::CommandException => e
+        raise e unless e.message =~ /Failed to find target/i
+      end
+      
+      ret
+    end
+    
+  private
+    def get_tasks
+      ret = []
+      
+      @task_keys.each { |key|
+        ret << VasTask.get_all(:task_id => key)
+      }
+      
+      ret
+    end
+    
+    def get_credentials
+      ret = { :ssh => nil, :smb => nil }
+      
+      @credential_keys.each { |key, value|
+        ret[key] = VasLscCredential.get_all(:id => value) if value && !value.empty?
+      } if @credential_keys
+      
+      ret
+    end
+    
+    def credential_changed?(key)
+      if credential_keys[key] == nil && credentials[key] != nil
+        return true
+      elsif credential_keys[key] != nil && credentials[key] == nil
+        return true
+      elsif credential_keys[key] == nil && credentials[key] == nil
+        return false
+      else
+        return credential_keys[key] != credentials[key].id
+      end
+    end
   end
 end

data/lib/openvas-cli/vas_task.rb

@@ -1,36 +1,235 @@
 require 'vas_base'
 require 'vas_result'
 
-class VasTask < VasBase
-  attr_accessor :task_id, :task_name, :comment, :status,
-                :progress, :times_run, :last_report_id
-                
-  validates :task_id, :presence => true, :UUID => true
-  
-  def self.get_all(options = {})
-    params = {:apply_overrides => 0, :sort_field => "name"}
-    
-    params[:task_id] = options[:task_id] if options[:task_id]
-  
-    req = Nokogiri::XML::Builder.new { |xml|
-      xml.get_tasks
-    }
-    
-    tasks = client.send_receive(req.doc)
-    
-    ret = []
-    tasks.xpath('//task').each { |t|
+module OpenvasCli
+  class VasTask < VasBase
+    attr_reader   :name
+    attr_reader   :comment
+    attr_accessor :status
+    attr_accessor :times_run
+    attr_accessor :last_report_id
+    attr_reader   :config_id
+    attr_reader   :target_id
+    attr_reader   :schedule_id
+    
+    validates :id, :UUID => true, :if => Proc.new { |t| t.id }
+    validates :config_id, :UUID => true, :if => Proc.new { |t| t.config_id }
+    validates :target_id, :UUID => true, :if => Proc.new { |t| t.target_id }
+    validates_with ImmutableChildrenValidator
+    
+    
+    define_attribute_methods [:name, :comment, :config_id, :target_id, :schedule_id]
+    
+    def initialize(params = {})
+      @name        = params[:name]        if params[:name]
+      @comment     = params[:comment]     if params[:comment]
+      @config_id   = params[:config_id]   if params[:config_id]
+      @target_id   = params[:target_id]   if params[:target_id]
+      @schedule_id = params[:schedule_id] if params[:schedule_id]
+      @schedule    = params[:schedule]    if params[:schedule]
+      reset_changes
+    end
+
+    def name=(val)
+      name_will_change! unless @name == val
+      @name = val
+    end
+    
+    def comment=(val)
+      comment_will_change! unless @comment == val
+      @comment = val
+    end
+    
+    def config_id=(v)
+      config_id_will_change! unless @config_id == v
+      @config_id = v
+    end
+    
+    def target_id=(v)
+      target_id_will_change! unless @target_id == v
+      @target_id = v
+    end
+    
+    def schedule_id=(v)
+      schedule_id_will_change! unless @schedule_id == v
+      @schedule_id = v
+    end
+    
+    def schedule
+      @schedule || pull_my_schedule
+    end
+    
+    def schedule=(v)
+      @schedule = v
+      schedule_id = v ? v.id : nil 
+    end
+    
+    def config
+      @config || pull_my_config
+    end
+    
+    def config=(val)
+      @config = val
+      config_id = val ? val.id : nil
+    end
+    
+    def target
+      @target || pull_my_target
+    end
+    
+    def target=(val)
+      @target = val
+      target_id = val ? val.id : nil
+    end
+    
+    def save!
+      raise "Invalid State" unless valid?
+    
+      if schedule && schedule.changed?
+        schedule.save!
+        schedule_id = schedule.id
+      end
+      
+      if config.changed?
+        config.save!
+      end
+       
+      req = Nokogiri::XML::Builder.new { |xml|
+        if @id
+          xml.modify_task(:id => @id) {
+            xml.name    { xml.text(@name) }    if name_changed?
+            xml.comment { xml.text(@comment) } if comment_changed?
+            xml.schedule(:id => @schedule_id)  if schedule_id && schedule_id_changed?
+          }
+        else
+          xml.create_task {
+            xml.name    { xml.text(@name) }    if @name
+            xml.comment { xml.text(@comment) } if @comment
+            xml.config(:id => @config_id)
+            xml.target(:id => @target_id)
+            xml.schedule(:id => @schedule_id)  if @schedule_id
+          }
+        end
+      }
+      
+      resp = VasTask.connection.send_receive(req.doc)
+      
+      @id = VasTask.extract_value_from("/create_task_response/@id", resp) unless @id
+      
+      reset_changes
+    end
+    
+    def destroy!
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.delete_task(:task_id => @id)
+      }
+      
+      VasTask.connection.send_receive(req.doc)
+    end
+    
+    def start
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.resume_or_start_task(:task_id => @id)
+      }
+      
+      VasTask.connection.send_receive(req.doc)
+    end
+    
+    def progress=(val)
+      @progress = val
+    end
+    
+    def progress(refresh=false)
+      if refresh == true || @progress == nil
+        params = {:apply_overrides => 0, :sort_field => "name"}
+        params[:task_id] = options[:task_id] if options[:task_id]
+      
+        req = Nokogiri::XML::Builder.new { |xml|
+          xml.get_tasks
+        }
+        
+        task = VasTask.connection.send_receive(req.doc)
+      
+       @progress = VasTaskStatus.from_xml_node task.at_xpath('/get_tasks_response/task/progress')
+      end
+      @progress
+    end
+    
+    def pause
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.pause_task(:task_id => @id)
+      }
+      
+      VasTask.connection.send_receive(req.doc)
+    end
+    
+    def stop
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.stop_task(:task_id => @id)
+      }
+      
+      VasTask.connection.send_receive(req.doc)
+    end
+              
+    def self.get_all(options = {})
+      params = {:apply_overrides => 0, :sort_field => "name"}
+      
+      params[:task_id] = options[:task_id] if options[:task_id]
+    
+      req = Nokogiri::XML::Builder.new { |xml|
+        xml.get_tasks
+      }
+      
+      tasks = connection.send_receive(req.doc)
+      
+      ret = []
+      tasks.xpath('//task').each { |t|
+        ret << from_xml_node(t)
+      }
+      
+      ret
+    end
+    
+    def self.from_xml_node(node)
       t_id                = VasTask.new
-      t_id.task_id        = extract_value_from("@id", t)
-      t_id.task_name      = extract_value_from("name", t)
-      t_id.comment        = extract_value_from("comment", t)
-      t_id.status         = extract_value_from("status", t)
-      t_id.progress       = extract_value_from("progress", t)
-      t_id.times_run      = extract_value_from("report_count/finished", t).to_i
-      t_id.last_report_id = extract_value_from("last_report/report/@id", t)
-      ret << t_id
-    }
-    
-    ret
+      t_id.id             = extract_value_from("@id", node)
+      t_id.name           = extract_value_from("name", node)
+      t_id.comment        = extract_value_from("comment", node)
+      t_id.status         = extract_value_from("status", node)
+      if node.at_xpath("progress")
+        t_id.progress = VasTaskProgress.from_xml_node(node.at_xpath("progress"))
+      end
+      t_id.times_run      = extract_value_from("report_count/finished", node).to_i
+      t_id.last_report_id = extract_value_from("last_report/report/@id", node)
+      t_id.config_id      = extract_value_from("config/@id", node)
+      t_id.target_id      = extract_value_from("target/@id", node)
+      
+      t_id
+    end
+   
+  private
+    def pull_my_config
+      if @config_id && !@config_id.empty?
+        VasConfig.get_all(:id => @config_id)[0]
+      else
+        nil
+      end
+    end
+    
+    def pull_my_target
+      if @target_id && !@target_id.empty?
+        VasTarget.get_all(:id => @target_id)[0]
+      else
+        nil
+      end
+    end
+    
+    def pull_my_schedule
+      if @schedule_id && !@schedule_id.empty?
+        VasSchedule.get_all(:id => @schedule_id)[0]
+      else
+        nil
+      end
+    end
   end
 end