lab 0.2.2 → 0.2.3

data/src/lib/lab/modifier/test_modifier.rb

@@ -1,16 +0,0 @@
-# This assumes you're on a recent ubuntu
-# TODO - enforce this, or split it out...
-
-module Lab
-module Modifier
-module Test
-  def install_nmap
-    run_command("sudo apt-get install nmap")
-  end
-
-  def nmap(options)
-    run_command("nmap #{filter_input(options)}")
-  end
-end
-end
-end

data/src/lib/lab/modifiers.rb

@@ -1,3 +0,0 @@
-require 'modifier/test_modifier'
-require 'modifier/backtrack5_modifier'
-require 'modifier/dos_modifier'	

data/src/lib/lab/version.rb

@@ -1,3 +0,0 @@
-module Lab
-  VERSION = "0.2.0"
-end

data/src/lib/lab/vm.rb

@@ -1,269 +0,0 @@
-#
-module Lab
-
-#
-# This class encapsulates a vm, provides functionality on that vm, and contains a single driver.
-#
-class Vm
-  
-  attr_accessor :vmid
-  attr_accessor :hostname
-  attr_accessor :description
-  attr_accessor :user
-  attr_accessor :host
-  attr_accessor :location
-  attr_accessor :driver
-  attr_accessor :credentials
-  attr_accessor :tools
-  attr_accessor :type
-  attr_accessor :os
-  attr_accessor :arch
-  attr_accessor :tags
-
-  ## Initialize takes a vm configuration hash of the form
-  ##  - vmid (unique id)
-  ##    hostname (unique name)
-  ##    description (describes the vm's contents)
-  ##    driver (vm driver)
-  ##    location (if applicable - local system)
-  ##    user (if applicable - remote system)
-  ##    host (if applicable - remote system)
-  ##    pass (if applicable - remote system) # DISCOURAGED - USE KEYS!
-  ##    tools (true if tools are installed)
-  ##    type ( qa / vulnerable / etc - freeform option)
-  ##    credentials (of the form [ {'user'=>"user",'pass'=>"pass", 'admin' => false}, ... ])
-  ##    os (currently linux / windows / solaris / aix) - may be used in modifiers
-  ##    arch (currently 32 / 64)
-  ##    modifiers - array of strings, can be anything in the modifiers directory
-  ##    tags - array of strings associated with this vm
-  
-  def initialize(config = {})  
-
-    # TODO - This is a mess. clean up, and pass stuff down to drivers
-    # and then rework the code that uses this api. 
-    @vmid = config['vmid'].to_s 
-    raise "Invalid VMID" unless @vmid
-
-    # Grab the hostname if specified, otherwise use the vmid
-    # VMID will be different in the case of ESX
-    @hostname = config['hostname']
-    if !@hostname
-      @hostname = @vmid
-    end
-
-    @driver_type = filter_input(config['driver'])
-    @driver_type.downcase!
-
-    @location = filter_input(config['location'])
-    @description = config['description']
-    @tools = config['tools']
-    @os = config['os']
-    @arch = config['arch']
-    @type = filter_input(config['type']) || "unspecified"
-    @credentials = config['credentials'] || []
-    
-    # TODO - Currently only implemented for the first set
-    if @credentials.count > 0
-      @vm_user = filter_input(@credentials[0]['user']) || "\'\'"
-      @vm_pass = filter_input(@credentials[0]['pass']) || "\'\'"
-      @vm_keyfile = filter_input(@credentials[0]['keyfile'])
-    end
-
-    # Only applicable to remote systems
-    @user = filter_input(config['user']) || nil
-    @host = filter_input(config['host']) || nil
-    @port = filter_input(config['port']) || nil
-    @pass = filter_input(config['pass']) || nil # DISCORAGED, use keys!
-
-    # Only dynagen systems need this
-    @platform = config['platform']
-
-    # Only fog systems need this
-    @fog_config = config['fog_config']
-
-    # Process the correct driver
-    if @driver_type == "workstation"
-      @driver = Lab::Drivers::WorkstationDriver.new(config)
-    elsif @driver_type == "remote_workstation"
-      @driver = Lab::Drivers::RemoteWorkstationDriver.new(config)
-    elsif @driver_type == "virtualbox"
-      @driver = Lab::Drivers::VirtualBoxDriver.new(config)
-    elsif @driver_type == "fog"
-      @driver = Lab::Drivers::FogDriver.new(config, config['fog_config'])
-    elsif @driver_type == "dynagen"
-      @driver = Lab::Drivers::DynagenDriver.new(config, config['dynagen_config'])  
-    elsif @driver_type == "remote_esxi"
-      @driver = Lab::Drivers::RemoteEsxiDriver.new(config)
-    elsif @driver_type == "vsphere"
-      @driver = Lab::Drivers::VsphereDriver.new(config)
-    #elsif @driver_type == "qemu"
-    #  @driver = Lab::Drivers::QemuDriver.new
-    #elsif @driver_type == "qemudo"
-    #  @driver = Lab::Drivers::QemudoDriver.new
-    else
-      raise "Unknown Driver Type"
-    end
-        
-    # Load in a list of modifiers. These provide additional methods
-    # Currently it is up to the user to verify that 
-    # modifiers are properly used with the correct VM image.
-    #
-    # If not, the results are likely to be disasterous.
-    @modifiers = config['modifiers']
-    
-    if @modifiers  
-      begin
-         @modifiers.each { |modifier|  self.class.send(:include, eval("Lab::Modifier::#{modifier}"))}
-      rescue Exception => e
-        # modifier likely didn't exist
-      end
-    end
-    
-    #
-    # Grab a tags array
-    #
-    @tags = config['tags']
-    
-  end
-  
-  def running?
-    @driver.running?
-  end
-
-  def location
-    @driver.location
-  end
-
-  def start
-    @driver.start
-  end
-
-  def stop
-    @driver.stop
-  end
-
-  def pause
-    @driver.pause
-  end
-
-  def suspend
-    @driver.suspend
-  end
-  
-  def reset
-    @driver.reset
-  end
-  
-  def resume
-    @driver.resume
-  end
-
-  def create_snapshot(snapshot)
-    @driver.create_snapshot(snapshot)
-  end
-
-  def revert_snapshot(snapshot)
-    @driver.revert_snapshot(snapshot)
-  end
-
-  def delete_snapshot(snapshot)
-    @driver.delete_snapshot(snapshot)
-  end
-
-  def revert_and_start(snapshot)
-    @driver.revert_snapshot(snapshot)
-    @driver.start
-  end
-
-  def copy_to(from,to)
-    @driver.copy_to(from,to)
-  end
-  
-  def copy_from(from,to)
-    @driver.copy_from(from,to)
-  end
-  
-  def run_command(command)
-    @driver.run_command(command)
-  end
-
-  def check_file_exists(file)
-    @driver.check_file_exists(file)
-  end
-  
-  def create_directory(directory)
-    @driver.create_directory(directory)
-  end
-
-  def open_uri(uri)
-    # we don't filter the uri, as it's getting tossed into a script 
-    # by the driver
-    if @os == "windows"
-      command = "\"C:\\program files\\internet explorer\\iexplore.exe\" #{uri}"
-    else
-      command = "firefox #{uri}"
-    end
-
-    @driver.run_command(command)
-  end
-
-  def to_s
-    return "#{@hostname}"
-  end
-
-  def to_yaml
-    
-    # TODO - push this down to the drivers.
-    
-    # Standard configuration options
-    out =  " - vmid: #{@vmid}\n"
-    out += "   hostname: #{@hostname}\n"
-    out += "   driver: #{@driver_type}\n"
-    out += "   description: |\n #{@description}\n"
-    out += "   location: #{@location}\n"
-    out += "   type: #{@type}\n"
-    out += "   tools: #{@tools}\n"
-    out += "   os: #{@os}\n"
-    out += "   arch: #{@arch}\n"
-    
-    if @user or @host # Remote vm/drivers only
-      out += "   user: #{@user}\n"
-      out += "   host: #{@host}\n"
-      out += "   port: #{@port}\n"
-      out += "   pass: #{@pass}\n"
-    end
-
-    if @platform
-      out += "   platform: #{@platform}\n"
-    end
-
-    if @fog_config
-      out += @fog_config.to_yaml
-    end
-
-    if @dynagen_config
-      out += @dynagen_config.to_yaml
-    end
-
-    out += "   credentials:\n"
-    @credentials.each do |credential|    
-      out += "     - user: #{credential['user']}\n"
-      out += "       pass: #{credential['pass']}\n"
-    end
-  
-     return out
-  end
-private
-
-  def filter_input(string)
-    return "" unless string # nil becomes empty string
-    return unless string.class == String # Allow other types
-          
-    unless /^[(!)\d*\w*\s*\[\]\{\}\/\\\.\-\"\(\)]*$/.match string
-      raise "WARNING! Invalid character in: #{string}"
-    end
-
-    string
-  end
-end
-end

data/src/lib/lab/vm_controller.rb

@@ -1,275 +0,0 @@
-#
-# $Id$
-#
-# This is the main lab controller. Require this controller to get all 
-# lab functionality. 
-#
-#
-
-$:.unshift(File.expand_path(File.dirname(__FILE__)))
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'driver')))
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'controller')))
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'modifier')))
-
-require 'find'
-require 'yaml'
-require 'enumerator'
-require 'fileutils'
-
-require 'vm'
-require 'controllers'
-require 'drivers'
-require 'modifiers'
-
-require 'net/scp'
-require 'net/ssh'
-
-module Lab
-module Controllers
-  class VmController 
-
-    include Enumerable
-    include Lab::Controllers::WorkstationController
-    include Lab::Controllers::RemoteWorkstationController
-    include Lab::Controllers::VirtualBoxController 
-    include Lab::Controllers::FogController
-    include Lab::Controllers::DynagenController 
-    include Lab::Controllers::RemoteEsxiController
-    include Lab::Controllers::VsphereController
-    #include Lab::Controllers::QemuController 
-    #include Lab::Controllers::QemudoController 
-    def initialize (labdef=nil)
-
-      # Start with an empty array of vm objects
-      @vms = [] 
-
-      # labdef is a just a big array of hashes
-      load_vms(labdef) if labdef
-    end
-    
-    def clear!
-      @vms = []
-    end
-
-    def [](x)
-      # Support indexing by both names and number
-      if x.class == String
-        find_by_vmid(x)
-      else
-        return @vms[x]
-      end
-    end
-
-    def find_by_vmid(search)
-      @vms.each do |vm|
-        return vm if vm.hostname.to_s.downcase == search.to_s.downcase
-      end
-      return nil
-    end
-
-    def find_by_tag(search)
-      @vms.each do |vm|
-        vm.tags.each do |tag| 
-          return vm if tag.downcase == search.to_s.downcase
-        end
-      end
-      return nil
-    end
-
-    def add_vm(vmid, location=nil, os=nil, tools=nil, credentials=nil, user=nil, host=nil)
-      @vms << Vm.new( {
-        'vmid' => vmid, 
-        'driver' => type, 
-        'location' => location, 
-        'credentials' => credentials,
-        'user' => user,
-        'host' => host
-        })
-    end
-
-    def remove_by_vmid(vmid)
-      @vms.delete(self.find_by_vmid(vmid))
-    end  
-
-    def from_file(file)
-      load_vms(YAML::load_file(file))
-    end
-
-    def load_vms(vms)
-      vms.each do |item|
-        vm = Vm.new(item)
-        @vms << vm unless includes_vmid? vm.vmid
-      end
-    end
-
-    def to_file(file)
-      File.open(file, 'w') { |f| @vms.each { |vm| f.puts vm.to_yaml } } 
-    end
-
-    def each &block
-      @vms.each { |vm| yield vm }
-    end
-
-    def includes?(specified_vm)
-      @vms.each { |vm| if (vm == specified_vm) then return true end  }
-    end
-
-    def includes_vmid?(vmid)
-      @vms.each do |vm|
-        return true if (vm.vmid == vmid)
-      end
-    false
-    end
-
-    #
-    # Build a vm lab from a directory of files. Really only useful for file-based
-    # vm hosts. (vmware workstation)
-    #
-    def build_from_dir(driver_type, dir, clear=false)
-
-      if clear
-        @vms = []
-      end
-
-      if driver_type.downcase == "workstation"
-        vm_list = ::Lab::Controllers::WorkstationController::dir_list(dir)
-      elsif driver_type.downcase == "remote_workstation"  
-        vm_list = ::Lab::Controllers::RemoteWorkstationController::dir_list(dir)
-      elsif driver_type.downcase == "virtualbox"  
-        vm_list = ::Lab::Controllers::VirtualBoxController::dir_list(dir)
-      elsif driver_type.downcase == "fog"
-        vm_list = ::Lab::Controllers::FogController::dir_list(dir)
-      elsif driver_type.downcase == "Dynagen"  
-        vm_list = ::Lab::Controllers::DynagenController::dir_list(dir)
-      elsif driver_type.downcase == "remote_esxi"
-        vm_list =::Lab::Controllers::RemoteEsxiController::dir_list(dir)
-      elsif driver_type.downcase == "vsphere"
-        vm_list =::Lab::Controllers::VsphereController::dir_list(dir)
-      else
-        raise TypeError, "Unsupported VM Type"
-      end
-      
-      vm_list.each_index do |index|
-        @vms << Vm.new( {'vmid' => "vm_#{index}", 'driver' => driver_type, 'location' => vm_list[index]} )
-      end
-    end
-
-
-    #
-    # Builds a vm lab from all running vms. Handy for connecting and saving out 
-    # a config or just managing the currently running vms
-    #
-    def build_from_running(driver_type=nil, user=nil, host=nil, clear=false, pass=nil)
-    
-      if clear
-        @vms = []
-      end
-
-      case driver_type.intern
-        when :workstation
-          vm_list = ::Lab::Controllers::WorkstationController::running_list
-          vm_list.each do |item|
-            # Name the VM
-            index = @vms.count + 1
-            # Add it to the vm list
-            @vms << Vm.new({
-              'vmid' => "vm_#{index}",
-              'driver' => driver_type, 
-              'location' => item
-              })
-          end
-        when :remote_workstation
-          vm_list = ::Lab::Controllers::RemoteWorkstationController::running_list(user, host)
-          vm_list.each do |item|
-            # Name the VM
-            index = @vms.count + 1
-            # Add it to the VM list
-            @vms << Vm.new({
-              'vmid' => "vm_#{index}",
-              'driver' => driver_type, 
-              'location' => item, 
-              'user' => user,
-              'host' => host 
-              })
-          end
-        when :virtualbox
-          vm_list = ::Lab::Controllers::VirtualBoxController::running_list
-          vm_list.each do |item|
-            # Add it to the vm list
-            @vms << Vm.new( {  
-              'vmid' => "#{item}",
-              'driver' => driver_type,
-              'location' => nil 
-              })
-          end
-        when :fog
-          raise "Unsupported"
-        when :dynagen
-          raise "Unsupported"
-        when :remote_esxi
-          vm_list = ::Lab::Controllers::RemoteEsxiController::running_list(user,host)
-          vm_list.each do |item|
-            @vms << Vm.new( {  
-              'vmid' => "#{item[:id]}",
-              'name' => "#{item[:name]}",
-              'driver' => driver_type, 
-              'user' => user,
-              'host' => host 
-              })
-          end
-        when :vsphere
-          vm_list = ::Lab::Controllers::VsphereController::running_list(user,host,pass)
-          vm_list.each do |item|
-            @vms << Vm.new( {  
-              'vmid' => "#{item[:id]}",
-              'name' => "#{item[:name]}",
-              'driver' => driver_type, 
-              'user' => user,
-              'host' => host,
-              'pass' => pass
-              })
-          end
-        else
-          raise TypeError, "Unsupported VM Type"
-        end
-
-    end  
-
-    #
-    # Applicable only to virtualbox. Reads the config file & parses / creates
-    # VM objects for each vm.
-    #
-    def build_from_config(driver_type=nil, user=nil, host=nil, clear=false)
-      if clear
-        @vms = []
-      end
-
-      case driver_type.intern
-        when :virtualbox
-          vm_list = ::Lab::Controllers::VirtualBoxController::config_list
-          
-          vm_list.each do |item|
-            # Add it to the vm list
-            @vms << Vm.new( {  
-              'vmid' => "#{item}",
-              'driver' => driver_type, 
-              'location' => nil, 
-              'user' => user,
-              'host' => host } )
-          end
-            
-        else
-          raise TypeError, "Unsupported VM Type"
-        end
-
-    end  
-
-    def running?(vmid)
-      if includes_vmid?(vmid)
-        return self.find_by_vmid(vmid).running?
-      end
-      return false 
-    end
-  end
-end
-end

data/src/lib/lab.rb

@@ -1,2 +0,0 @@
-require 'lab/vm_controller'
-require 'lab/version'