lab 0.2.2 → 0.2.3

data/src/lib/lab/driver/vm_driver.rb

@@ -1,195 +0,0 @@
-##
-## $Id$
-##
-
-#
-#   !!WARNING!! - All drivers are expected to filter input before running
-#  anything based on it. This is particularly important in the case
-#  of the drivers which wrap a command line to provide functionality.  
-#
-
-module Lab
-module Drivers
-class VmDriver
-
-  attr_accessor :vmid 
-  attr_accessor :location
-  attr_accessor :os
-  attr_accessor :tools
-  attr_accessor :credentials
-  
-  def initialize(config)
-
-    @vmid = filter_command(config["vmid"].to_s)
-    @location = filter_command(config["location"])
-    @credentials = config["credentials"] || []
-    @tools = filter_input(config["tools"])
-    @arch = filter_input(config["arch"])
-    @os = filter_input(config["os"])
-    @hostname = filter_input(config["hostname"]) || filter_input(config["vmid"].to_s)
-
-    # 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
-  end
-
-  ## This interface must be implemented in a child driver class
-  ## #########################################################
-
-  def register
-    raise "Command not Implemented"
-  end
-    
-  def unregister
-    raise "Command not Implemented"
-  end
-
-  def start
-    raise "Command not Implemented"
-  end
-
-  def stop
-    raise "Command not Implemented"
-  end
-
-  def suspend
-    raise "Command not Implemented"
-  end
-
-  def pause
-    raise "Command not Implemented"
-  end
-
-  def resume
-    raise "Command not Implemented"
-  end
-
-  def reset
-    raise "Command not Implemented"
-  end
-
-  def create_snapshot(snapshot)
-    raise "Command not Implemented"
-  end
-
-  def revert_snapshot(snapshot)
-    raise "Command not Implemented"
-  end
-
-  def delete_snapshot(snapshot)
-    raise "Command not Implemented"
-  end
-
-  def run_command(command)  
-    raise "Command not Implemented"
-  end
-  
-  def copy_from(from, to)
-    raise "Command not Implemented"
-  end
-  
-  def copy_to(from, to)
-    raise "Command not Implemented"
-  end
-
-  def check_file_exists(file)
-    raise "Command not Implemented"
-  end
-
-  def create_directory(directory)
-    raise "Command not Implemented"
-  end
-
-  def cleanup
-    raise "Command not Implemented"
-  end
-
-  ## End Interface
-  ## #########################################################
-
-private
-
-  # The only reason we don't filter here is because we need
-  # the ability to still run clean (controlled entirely by us)
-  # command lines.
-  def system_command(command)
-    puts "DEBUG: system command #{command}"
-    system(command)
-  end
-
-  def remote_system_command(command)
-    puts "DEBUG: remote system command #{command} running with user #{@user}@#{@host}"
-    system_command("ssh #{@user}@#{@host} \"#{command}\"")
-  end
-
-  def scp_to(local,remote)
-    if @vm_keyfile
-      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
-      Net::SCP.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |scp|
-        puts "DEBUG: uploading #{local} to #{remote}"
-        scp.upload!(local,remote)
-      end
-    else
-      Net::SCP.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |scp|
-        puts "DEBUG: uploading #{local} to #{remote}"
-        scp.upload!(local,remote)
-      end
-    end  
-  end
-  
-  def scp_from(remote, local)
-    # download a file from a remote server
-    if @vm_keyfile
-      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
-      Net::SCP.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |scp|
-        puts "DEBUG: downloading #{remote} to #{local}"
-        scp.download!(remote,local)
-      end
-    else
-      Net::SCP.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |scp|
-        puts "DEBUG: downloading #{remote} to #{local}"
-        scp.download!(remote,local)
-      end
-    end
-  end
-  
-  def ssh_exec(command)
-    if @vm_keyfile
-      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
-      Net::SSH.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |ssh|
-        puts "DEBUG: running command: #{command}"
-        ssh.exec!(command)
-      end
-    else
-      Net::SSH.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |ssh|
-        result = ssh.exec!(command)
-      end
-    end
-  end
-
-  def filter_input(string)
-    return "" unless string # nil becomes empty string
-    return unless string.class == String # Allow other types unmodified
-    
-    unless /^[\d\w\s\[\]\{\}\/\\\.\-\"\(\):!]*$/.match string
-      raise "WARNING! Invalid character in: #{string}"
-    end
-  string
-  end
-
-  def filter_command(string)
-    return "" unless string # nil becomes empty string
-    return unless string.class == String # Allow other types unmodified    
-    
-    unless /^[\d\w\s\[\]\{\}\/\\\.\-\"\(\)]*$/.match string
-      raise "WARNING! Invalid character in: #{string}"
-    end
-  string
-  end
-
-end
-end
-end

data/src/lib/lab/driver/vsphere_driver.rb

@@ -1,120 +0,0 @@
-require 'vm_driver'
-
-##
-## $Id$
-##
-
-# This driver was built against: 
-# VMware Vsphere 4.1
-
-module Lab
-module Drivers
-
-class VsphereDriver < VmDriver
-
-  def initialize(config)
-    unless config['user'] then raise ArgumentError, "Must provide a username" end
-    unless config['host'] then raise ArgumentError, "Must provide a hostname" end
-    unless config[''] then raise ArgumentError, "Must provide a password" end
-    super(config)
-
-    @user = filter_command(config['user'])
-    @host = filter_command(config['host'])
-
-    # Soft dependency
-    begin
-      require 'rbvmomi'
-    rescue LoadError
-      raise "WARNING: Library rbvmomi not found. Could not create driver!"
-    end
-
-    vim = RbVmomi::VIM.connect host: @host, user: @user, password: @pass
-    dc = vim.serviceInstance.find_datacenter("datacenter1") or fail "datacenter not found"
-    @vm = dc.find_vm("test") or fail "VM not found"
-  end
-
-  def start
-    @vm.PowerOnVM_Task.wait_for_completion
-  end
-
-  def stop
-    @vm.PowerOffVM_Task.wait_for_completion
-  end
-
-  def suspend
-    @vm.SuspendVM_Task.wait_for_completion
-  end
-
-  def pause
-    raise "Unimplemented"
-  end
-
-  def resume
-    raise "Unimplemented"
-  end
-
-  def reset
-    @vm.ResetVM_Task.wait_for_completion
-  end
-
-  def create_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    raise "Unimplemented"
-  end
-
-  def revert_snapshot(snapshot)
-    raise "Unimplemented"
-    # If we got here, the snapshot didn't exist
-    raise "Invalid Snapshot Name"
-  end
-
-  def delete_snapshot(snapshot, remove_children=false)
-    raise "Unimplemented"
-    # If we got here, the snapshot didn't exist
-    raise "Invalid Snapshot Name"
-  end
-  
-  def delete_all_snapshots
-    raise "Unimplemented"
-  end
-    
-  def run_command(command)
-    raise "Unimplemented"
-  end
-  
-  def copy_from(from, to)
-    if @os == "linux"
-      scp_from(from, to)
-    else
-      raise "Unimplemented"
-    end
-  end
-
-  def copy_to(from, to)
-    if @os == "linux"
-      scp_to(from, to)
-    else
-      raise "Unimplemented"
-    end
-  end
-
-  def check_file_exists(file)
-    raise "Unimplemented"
-  end
-
-  def create_directory(directory)
-    raise "Unimplemented"
-  end
-
-  def cleanup
-    raise "Unimplemented"
-  end
-
-  def running?
-    raise "Unimplemented"
-  end 
-
-end
-
-end 
-end

data/src/lib/lab/driver/workstation_driver.rb

@@ -1,234 +0,0 @@
-require 'vm_driver'
-
-##
-## $Id$
-##
-
-module Lab
-module Drivers
-
-class WorkstationDriver < VmDriver
-
-  def initialize(config)
-    super(config)
-    
-    if !File.exist?(@location)
-      raise ArgumentError,"Couldn't find: #{@location}"
-    end
-  end
-
-  def start
-    system_command("vmrun -T ws start " + "\'#{@location}\' nogui")
-  end
-
-  def stop
-    system_command("vmrun -T ws stop " + "\'#{@location}\' nogui")
-  end
-
-  def suspend
-    system_command("vmrun -T ws suspend " + "\'#{@location}\' nogui")
-  end
-
-  def pause
-    system_command("vmrun -T ws pause " + "\'#{@location}\' nogui")
-  end
-
-  def reset
-    system_command("vmrun -T ws reset " + "\'#{@location}\' nogui")
-  end
-
-  def create_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("vmrun -T ws snapshot " + "\'#{@location}\' \'#{snapshot}\' nogui")
-  end
-
-  def revert_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("vmrun -T ws revertToSnapshot " + "\'#{@location}\' \'#{snapshot}\' nogui")
-  end
-
-  def delete_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("vmrun -T ws deleteSnapshot " + "\'#{@location}\' \'#{snapshot}\' nogui" )
-  end
-
-  def run_command(command)
-
-    #
-    # Generate a script name
-    #
-    script_rand_name = rand(1000000)
-
-    #
-    # Configure paths for each OS - We really can't filter command, so we're gonna 
-    # stick it in a script
-    #
-    if @os == "windows"
-      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.bat"
-      remote_tempfile_path = "C:\\\\lab_script_#{script_rand_name}.bat"
-      remote_output_file = "C:\\\\lab_command_output_#{script_rand_name}"
-      remote_run_command = remote_tempfile_path
-      File.open(local_tempfile_path, 'w') {|f| f.write(command) }
-    else
-      
-      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
-      remote_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
-      remote_output_file = "/tmp/lab_command_output_#{script_rand_name}"
-      local_output_file = "/tmp/lab_command_output_#{script_rand_name}"
-      
-      remote_run_command = remote_tempfile_path
-      
-      File.open(local_tempfile_path, 'w') {|f| f.write("#!/bin/sh\n#{command}\n")}
-    end
-    
-    if @tools
-
-      #puts "DEBUG: Running w/ tools"
-
-      #
-      # Copy our local tempfile to the guest
-      #
-      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "copyFileFromHostToGuest \'#{@location}\' \'#{local_tempfile_path}\'" +
-          " \'#{remote_tempfile_path}\'"
-      system_command(vmrunstr)
-
-      if @os == "linux"
-        #
-        # Now run the command directly on the guest (linux - call w/ /bin/sh)
-        #
-        vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
-            "runProgramInGuest \'#{@location}\' /bin/sh #{remote_tempfile_path} > #{remote_output_file}"
-        system_command(vmrunstr)
-      else
-        #
-        # Now run the command directly on the guest (windows)
-        #
-        vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
-            "runProgramInGuest \'#{@location}\' #{remote_tempfile_path} > #{remote_output_file}" 
-        system_command(vmrunstr)
-      end
-      
-      #
-      # Cleanup. Delete it on the guest
-      #
-      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
-          "deleteFileInGuest \'#{@location}\' \'#{remote_tempfile_path}\'"
-      system_command(vmrunstr)
-
-      #
-      # Delete it locally
-      #
-      local_delete_command = "rm #{local_tempfile_path}"
-      system_command(local_delete_command)
-    else
-
-      #
-      # Use SCP / SSH
-      #
-
-      if @os == "linux"
-        
-        #
-        # Copy it over
-        #
-        scp_to(local_tempfile_path, remote_tempfile_path)
-
-        #
-        # And ... execute it
-        #
-        ssh_exec("/bin/sh #{remote_tempfile_path} > #{remote_output_file}")
-
-        #
-        # Now copy the output back to us
-        #
-        scp_from(remote_output_file, local_output_file)
-
-        # Now, let's look at the output of the command
-        output_string = File.open(local_output_file,"r").read
-
-        #
-        # And clean up
-        #
-        ssh_exec("rm #{remote_output_file}")
-        ssh_exec("rm #{remote_tempfile_path}")
-        
-        `rm #{local_output_file}`
-
-      else
-        raise "Hey, no tools, and windows? can't do nuttin for ya man."
-      end
-      
-    end
-  output_string
-  end
-  
-  def copy_from(from, to)
-    from = filter_input(from)
-    to = filter_input(to)
-    if @tools
-      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' copyFileFromGuestToHost " +
-          "\'#{@location}\' \'#{from}\' \'#{to}\'" 
-    else
-      scp_from(from, to)
-    end
-    system_command(vmrunstr)
-  end
-
-  def copy_to(from, to)
-    from = filter_input(from)
-    to = filter_input(to)
-    if @tools
-      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} copyFileFromHostToGuest " +
-        "\'#{@location}\' \'#{from}\' \'#{to}\'"
-      system_command(vmrunstr)
-    else
-      scp_to(from, to)
-    end
-  end
-
-  def check_file_exists(file)
-    file = filter_input(file)
-    if @tools
-      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' fileExistsInGuest " +
-        "\'#{@location}\' \'#{file}\'"
-      system_command(vmrunstr)
-    else
-      raise "Unsupported"
-    end
-  end
-
-  def create_directory(directory)
-    directory = filter_input(directory)
-    if @tools
-      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' createDirectoryInGuest " +
-          " \'#{@location}\' \'#{directory}\' "
-      system_command(vmrunstr)
-    else
-      raise "Unsupported"
-    end
-  end
-
-  def cleanup
-
-  end
-
-  def running?
-    ## Get running Vms
-    running = `vmrun list`
-    running_array = running.split("\n")
-    running_array.shift
-
-    running_array.each do |vmx|
-      if vmx.to_s == @location.to_s
-        return true
-      end
-    end
-
-    return false
-  end
-
-end
-
-end 
-end

data/src/lib/lab/driver/workstation_vixr_driver.rb

@@ -1,126 +0,0 @@
-require 'vm_driver'
-##
-## $Id$
-##
-
-# This requires rhythmx's vixr driver from https://github.com/rhythmx/vixr 
-# and below that, the VIX api from vmware http://www.vmware.com/support/developer/vix-api/
-
-module Lab
-module Drivers
-
-class WorkstationVixrDriver < VmDriver
-
-  attr_accessor :type
-  attr_accessor :location
-
-  def initialize(vmid, location, os=nil, tools=false, credentials=nil)
-
-    # We have to treat this differently, as it's not in the same tree
-    begin
-      require 'vixr'
-    rescue LoadError
-      puts   "WARNING: Library pro_vixr not found. To resolve this error, please\n" + 
-        "         install the vixr gem. Latest is available here:\n" +
-        "https://github.com/rhythmx/vixr ."
-      raise "Unable to create vixr driver"
-    end
-    
-    @vmid = filter_command(vmid)
-    @location = filter_command(location)
-
-    if !File.exist?(@location)
-      raise ArgumentError,"Couldn't find: " + location
-    end
-
-    @credentials = credentials
-    @tools = tools  # not used in command lines, no filter
-    @os = os  # not used in command lines, no filter
-
-    # 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']) || "\'\'"
-    end
-    
-    host = VixR.connect()
-    vm = host.open_vmx(@location)
-    
-  end
-
-  def start
-    vm.power_on
-  end
-
-  def stop
-    vm.power_off
-  end
-
-  def suspend
-    vm.suspend
-  end
-
-  def pause
-    vm.pause
-  end
-
-  def reset
-    vm.reset
-  end
-
-  def create_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("ssh #{@user}@#{@host} vmrun -T ws snapshot \\\'#{@location}\\\' #{snapshot} nogui")
-  end
-
-  def revert_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("ssh #{@user}@#{@host} vmrun -T ws revertToSnapshot \\\'#{@location}\\\' #{snapshot} nogui")
-  end
-
-  def delete_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    system_command("ssh #{@user}@#{@host} vmrun -T ws deleteSnapshot \\\'#{@location}\\\' #{snapshot} nogui" )
-  end
-
-
-  def run_command(command)
-    command = filter_input(command)
-    if vm.login(@vm_user,@vm_pass)
-      vm.run_prog(command)
-    end
-  end
-  
-  def copy_from(from, to)
-    from = filter_input(from)
-    to = filter_input(to)
-    cp_from_host(from,to)
-  end
-
-  def copy_to(from, to)
-    from = filter_input(from)
-    to = filter_input(to)
-    vm.cp_to_guest(from,to)
-  end
-
-  def check_file_exists(file)
-    file = filter_input(file)
-    file_exists?(file)
-  end
-
-  def create_directory(directory)
-    directory = filter_input(directory)
-  end
-
-  def cleanup
-
-  end
-
-  def running?
-    vm.running?
-  end
-
-end
-
-end 
-end

data/src/lib/lab/drivers.rb

@@ -1,9 +0,0 @@
-require 'driver/workstation_driver'
-require 'driver/virtualbox_driver'
-require 'driver/fog_driver'
-require 'driver/dynagen_driver'
-require 'driver/remote_workstation_driver'
-require 'driver/remote_esxi_driver'
-require 'driver/vsphere_driver'
-#require 'driver/qemu_driver'
-#require 'driver/qemudo_driver'

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

@@ -1,16 +0,0 @@
-module Lab
-module Modifier
-module Backtrack5
-
-  def nmap(options)
-    run_command("nmap #{filter_input(options)}")
-  end
-  
-  def testssl(site)
-    run_command("/pentest/scanners/testssl/testssl.sh #{filter_input(site)}")
-  end
-  
-end
-end
-end
-

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

@@ -1,14 +0,0 @@
-# This assumes you're on a recent ubuntu
-# TODO - enforce this, or split it out...
-
-module Lab
-module Modifier
-module Dos
-
-  def ping(target)
-    run_command("ping #{filter_input(target)}")
-  end
-
-end
-end
-end