openvas-cli 0.1.0

data/lib/openvas-cli/vas_override.rb

@@ -0,0 +1,7 @@
+require 'vas_base'
+
+# NOT IMPLEMENTED
+class VasOverride
+  attr_accessor :task_id, :original_threat, :rule_id, :is_new
+  
+end

data/lib/openvas-cli/vas_preference.rb

@@ -0,0 +1,59 @@
+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
+
+  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
+      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
+end

data/lib/openvas-cli/vas_report.rb

@@ -0,0 +1,118 @@
+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'
+        end
+      }
+    end
+    
+    req = Nokogiri::XML::Builder.new { |xml|
+      if params.empty?
+        xml.get_reports
+      else
+        xml.get_reports(params)
+      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
+      
+      r.xpath("results/result").each { |result|
+        r_id.results << VasResult.parse_result_node(result)
+      }
+      
+      ret << r_id
+    }
+    
+    ret
+  end
+  
+  def to_xml
+    req = Nokogiri::XML::Builder.new { |xml|
+      xml.get_reports(:report_id => @report_id)
+    }
+    
+    report = VasBase.client.send_receive(req.doc)
+    
+    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}
+                       }
+    end
+    @result_count
+  end
+end

data/lib/openvas-cli/vas_result.rb

@@ -0,0 +1,102 @@
+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
+
+    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
+      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]]
+      end
+    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
+    
+    res
+  end
+  
+  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

data/lib/openvas-cli/vas_schedule.rb

@@ -0,0 +1,63 @@
+require 'vas_base'
+
+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
+      }
+      ret << sch
+    }
+   
+    if manual_sort
+      if options[:sort_by] == :next_time
+        ret.sort!{ |a,b| a.next_time <=> b.next_time }
+      end
+    end
+    
+    ret
+  end
+end

data/lib/openvas-cli/vas_target.rb

@@ -0,0 +1,28 @@
+require 'nokogiri'
+
+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)
+
+    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
+  end
+end

data/lib/openvas-cli/vas_task.rb

@@ -0,0 +1,36 @@
+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|
+      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
+  end
+end

data/openvas-cli.gemspec

@@ -0,0 +1,138 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{openvas-cli}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Reed Swenson"]
+  s.date = %q{2011-03-11}
+  s.description = %q{A full ruby implementation of the OpenVAS OMP (version 2.0) protocol.}
+  s.email = %q{fleureed@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "features/openvas-cli.feature",
+    "features/step_definitions/openvas-cli_steps.rb",
+    "features/support/env.rb",
+    "lib/openvas-cli/oid_validator.rb",
+    "lib/openvas-cli/openvas-cli.rb",
+    "lib/openvas-cli/uuid_validator.rb",
+    "lib/openvas-cli/vas_base.rb",
+    "lib/openvas-cli/vas_exceptions.rb",
+    "lib/openvas-cli/vas_nvt.rb",
+    "lib/openvas-cli/vas_nvt_family.rb",
+    "lib/openvas-cli/vas_override.rb",
+    "lib/openvas-cli/vas_preference.rb",
+    "lib/openvas-cli/vas_report.rb",
+    "lib/openvas-cli/vas_result.rb",
+    "lib/openvas-cli/vas_schedule.rb",
+    "lib/openvas-cli/vas_target.rb",
+    "lib/openvas-cli/vas_task.rb",
+    "openvas-cli.gemspec",
+    "spec/openvas-cli/openvas-cli_spec.rb",
+    "spec/openvas-cli/vas_nvt_family_spec.rb",
+    "spec/openvas-cli/vas_nvt_spec.rb",
+    "spec/openvas-cli/vas_preference_spec.rb",
+    "spec/openvas-cli/vas_report_spec.rb",
+    "spec/openvas-cli/vas_result_spec.rb",
+    "spec/openvas-cli/vas_schedule_spec.rb",
+    "spec/openvas-cli/vas_target_spec.rb",
+    "spec/openvas-cli/vas_task_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://reedswenson.github.com/openvas-cli/}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.0}
+  s.summary = %q{A full ruby implementation of the OpenVAS OMP (version 2.0) protocol.}
+  s.test_files = [
+    "spec/openvas-cli/openvas-cli_spec.rb",
+    "spec/openvas-cli/vas_nvt_family_spec.rb",
+    "spec/openvas-cli/vas_nvt_spec.rb",
+    "spec/openvas-cli/vas_preference_spec.rb",
+    "spec/openvas-cli/vas_report_spec.rb",
+    "spec/openvas-cli/vas_result_spec.rb",
+    "spec/openvas-cli/vas_schedule_spec.rb",
+    "spec/openvas-cli/vas_target_spec.rb",
+    "spec/openvas-cli/vas_task_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.4"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<ZenTest>, [">= 0"])
+      s.add_development_dependency(%q<log4r>, [">= 0"])
+      s.add_runtime_dependency(%q<activesupport>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<activerecord>, [">= 3.0.5"])
+      s.add_runtime_dependency(%q<nokogiri>, [">= 1.4.4"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<ZenTest>, [">= 0"])
+      s.add_development_dependency(%q<log4r>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 3.0.5"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.5"])
+      s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<ZenTest>, [">= 0"])
+      s.add_dependency(%q<log4r>, [">= 0"])
+      s.add_dependency(%q<activesupport>, [">= 3.0.5"])
+      s.add_dependency(%q<activerecord>, [">= 3.0.5"])
+      s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
+      s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<ZenTest>, [">= 0"])
+      s.add_dependency(%q<log4r>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 3.0.5"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.5"])
+    s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<ZenTest>, [">= 0"])
+    s.add_dependency(%q<log4r>, [">= 0"])
+    s.add_dependency(%q<activesupport>, [">= 3.0.5"])
+    s.add_dependency(%q<activerecord>, [">= 3.0.5"])
+    s.add_dependency(%q<nokogiri>, [">= 1.4.4"])
+    s.add_dependency(%q<rspec>, ["~> 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<ZenTest>, [">= 0"])
+    s.add_dependency(%q<log4r>, [">= 0"])
+  end
+end
+