rex 1.0.2 → 2.0.2

data/lib/rex/file.rb

@@ -0,0 +1,160 @@
+# -*- coding: binary -*-
+require 'find'
+require 'rex/compat'
+require 'tempfile'
+
+module Rex
+
+###
+#
+# This class provides helper methods for dealing with files that are not
+# supplied by the standard ruby API.
+#
+###
+module FileUtils
+
+  #
+  # This method joins the paths together in Unix format.
+  #
+  def self.normalize_unix_path(*strs)
+    new_str = strs * '/'
+    new_str = new_str.gsub!("//", "/") while new_str.index("//")
+
+    new_str
+  end
+
+  #
+  # This method joins the paths together in Windows format.
+  # All reserved characters will be filtered out, including:
+  #  " * : < > ? \ / |
+  #
+  def self.normalize_win_path(*strs)
+    # Convert to the same format so the parsing is easier
+    s = strs * '\\'
+
+    # Filter out double slashes
+    s = s.gsub(/\\\\/, '\\') while s.index('\\\\')
+
+    # Keep the trailing slash if exists
+    trailing_s = ('\\' if s =~ /\\$/) || ''
+
+    # Check the items (fie/dir) individually
+    s = s.split(/\\/)
+
+    # Parse the path prefix
+    prefix = (s[0] || '').gsub(/[\*<>\?\/]/, '')
+
+    # Delete the original prefix. We want the new one later.
+    s.delete_at(0)
+
+    # Filter out all the reserved characters
+    s.map! {|e| e.gsub(/["\*:<>\?\\\/|]/, '') }
+
+    # Put the modified prefix back
+    s.insert(0, prefix)
+
+    # And then safely join the items
+    s *= '\\'
+
+    # Add the trailing slash back if exists
+    s << trailing_s
+  end
+
+  #
+  # This method cleans the supplied path of directory traversal sequences
+  # It must accept path/with/..a/folder../starting/or/ending/in/two/dots
+  # but clean ../something as well as path/with/..\traversal
+  #
+  def self.clean_path(old)
+    path = old
+    while(path.index(/\/..\/|\/..\\|\\..\\|\\..\/|\A..\\|\A..\//) != nil)
+      path.gsub!(/\A..\\|\A..\//,'') #eliminate starting ..\ or ../
+      path.gsub!(/\/..\/|\/..\\/,'/') #clean linux style
+      path.gsub!(/\\..\\|\\..\//,'\\') #clean windows style
+    end
+    path
+  end
+
+  #
+  # This method searches the PATH environment variable for
+  # a fully qualified path to the supplied file name.
+  #
+  def self.find_full_path(file_name)
+
+    # Check for the absolute fast first
+    if (file_name[0,1] == "/" and ::File.exists?(file_name) and ::File::Stat.new(file_name))
+      return file_name
+    end
+
+    path = Rex::Compat.getenv('PATH')
+    if (path)
+      path.split(::File::PATH_SEPARATOR).each { |base|
+        begin
+          # Deal with Windows paths surrounded by quotes.  Prevents
+          # silliness like trying to look for
+          # '"C:\\framework\\nmap"\\nmap.exe' which will always fail.
+          base = $1 if base =~ /^"(.*)"$/
+          path = base + ::File::SEPARATOR + file_name
+          if (::File::Stat.new(path) and not ::File.directory?(path))
+            return path
+          end
+        rescue
+        end
+      }
+    end
+    return nil
+  end
+
+end
+
+class Quickfile < ::Tempfile
+  def initialize(*args)
+    super(*args)
+    self.binmode
+    ObjectSpace.undefine_finalizer(self)
+  end
+end
+
+module Find
+  #
+  # Identical to Find.find from Ruby, but follows symlinks to directories.
+  # See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/68671
+  #
+  def self.find(*paths)
+    paths.collect!{|d| d.dup}
+    while file = paths.shift
+      catch(:prune) do
+        yield file.dup.taint
+        next unless File.exist? file
+        begin
+          if File.stat(file).directory? then
+            d = Dir.open(file)
+            begin
+              for f in d
+                next if f == "." or f == ".."
+                if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+                  f = file + f
+                elsif file == "/" then
+                  f = "/" + f
+                else
+                  f = File.join(file, f)
+                end
+                paths.unshift f.untaint
+              end
+            ensure
+              d.close
+            end
+          end
+        rescue Errno::ENOENT, Errno::EACCES
+        end
+      end
+    end
+  end
+
+  def self.prune
+    throw :prune
+  end
+
+end
+
+end

data/lib/rex/image_source.rb

@@ -0,0 +1,10 @@
+# -*- coding: binary -*-
+
+module Rex
+module ImageSource
+
+end
+end
+
+require 'rex/image_source/disk'
+require 'rex/image_source/memory'

data/lib/rex/image_source/disk.rb

@@ -0,0 +1,58 @@
+# -*- coding: binary -*-
+
+require 'rex/image_source/image_source'
+require 'rex/struct2'
+
+module Rex
+module ImageSource
+class Disk < ImageSource
+
+  attr_accessor :file, :file_offset, :size
+
+  WINDOW_SIZE     = 4096
+  WINDOW_OVERLAP  = 64
+
+  def initialize(_file, _offset = 0, _len = nil)
+    _len = _file.stat.size if !_len
+
+    self.file         = _file
+    self.file_offset  = _offset
+    self.size         = _len
+  end
+
+  def read(offset, len)
+    if offset < 0 || offset+len > size
+      raise RangeError, "Offset #{offset} outside of image source", caller
+    end
+
+    file.seek(file_offset + offset)
+    file.read(len)
+  end
+
+  def index(search, offset = 0)
+    # do a sliding window search across the disk
+    while offset < size
+
+      # get a full window size if we can, we
+      # don't want to read past our boundaries
+      wsize = size - offset
+      wsize = WINDOW_SIZE if wsize > WINDOW_SIZE
+
+      window = self.read(offset, wsize)
+      res = window.index(search)
+      return res + offset if res
+      offset += WINDOW_SIZE - WINDOW_OVERLAP
+    end
+  end
+
+  def subsource(offset, len)
+    self.class.new(file, file_offset+offset, len)
+  end
+
+  def close
+    file.close
+  end
+end
+
+end
+end

data/lib/rex/image_source/image_source.rb

@@ -0,0 +1,44 @@
+# -*- coding: binary -*-
+
+module Rex
+module ImageSource
+class ImageSource
+
+  #
+  # Um, just some abstract class stuff I guess, this is the interface
+  # that any image sources should subscribe to...
+  #
+
+  def subsource(offset, len)
+    raise "do something"
+  end
+
+  def size
+    raise "do something"
+  end
+
+  def file_offset
+    raise "do something"
+  end
+
+  def close
+    raise "do something"
+  end
+
+  def read_asciiz(offset)
+    # FIXME, make me better
+    string = ''
+    loop do
+      char = read(offset, 1)
+      break if char == "\x00"
+      offset += 1
+      string << char
+    end
+    return string
+  end
+
+
+end
+
+end
+end

data/lib/rex/image_source/memory.rb

@@ -0,0 +1,35 @@
+# -*- coding: binary -*-
+
+require 'rex/image_source/image_source'
+require 'rex/struct2'
+
+module Rex
+module ImageSource
+class Memory < ImageSource
+
+  attr_accessor :rawdata, :size, :file_offset
+
+  def initialize(_rawdata, _file_offset = 0)
+    self.rawdata     = _rawdata
+    self.size        = _rawdata.length
+    self.file_offset = _file_offset
+  end
+
+  def read(offset, len)
+    rawdata[offset, len]
+  end
+
+  def subsource(offset, len)
+    self.class.new(rawdata[offset, len], offset + file_offset)
+  end
+
+  def close
+  end
+
+  def index(*args)
+    rawdata.index(*args)
+  end
+end
+
+end
+end

data/lib/rex/io/bidirectional_pipe.rb

@@ -0,0 +1,161 @@
+# -*- coding: binary -*-
+module Rex
+module IO
+
+require 'rex/ui/text/output'
+require 'rex/ui/text/output/buffer'
+require 'rex/ui/text/input/buffer'
+
+class BidirectionalPipe < Rex::Ui::Text::Input
+
+  def initialize
+    @subscribers_out = {}
+    @subscribers_ref = {}
+    @subscribers_idx = 0
+    @pipe_input = Rex::Ui::Text::Input::Buffer.new
+
+    # We are the shell, the input, and the output
+    self.output = self
+    self.input  = self
+  end
+
+  def pipe_input
+    @pipe_input
+  end
+
+  def close
+    @pipe_input.close
+  end
+
+  def has_subscriber?(id)
+    @subscribers_out.has_key?(id)
+  end
+
+  def create_subscriber(id=nil)
+    id ||= (@subscribers_idx += 1).to_s
+    @subscribers_out[id] = Rex::Ui::Text::Output::Buffer.new
+    return id
+  end
+
+  def create_subscriber_proc(id=nil, &block)
+    id = create_subscriber(id)
+    @subscribers_ref[id] = block
+  end
+
+  def remove_subscriber(id)
+    @subscribers_out.delete(id)
+    @subscribers_ref.delete(id)
+  end
+
+  def write_input(buf)
+    @pipe_input.put(buf)
+  end
+
+  def read_subscriber(id)
+    output = @subscribers_out[id]
+
+    return '' if output.nil?
+
+    buf = output.buf
+
+    output.reset
+
+    buf
+  end
+
+  def print(msg='')
+    @subscribers_out.each_pair { |id, buf|
+      begin
+        @subscribers_ref[id] ? @subscribers_ref[id].call(msg) : buf.print(msg)
+      rescue ::Exception => e
+        # $stderr.puts "Error handling subscriber #{id}: #{e} #{e.backtrace.inspect}"
+        raise e
+      end
+    }
+    msg
+  end
+
+  def print_error(msg='')
+    print_line('[-] ' + msg)
+  end
+
+  def print_line(msg='')
+    print(msg + "\n")
+  end
+
+  def print_good(msg='')
+    print_line('[+] ' + msg)
+  end
+
+  def print_debug(msg='')
+    print_line('[!] ' + msg)
+  end
+
+  def flush
+  end
+
+  def print_status(msg='')
+    print_line('[*] ' + msg)
+  end
+
+  def print_warning(msg='')
+    print_line('[!] ' + msg)
+  end
+
+  #
+  # Wrappers for the pipe_input methods
+  #
+
+  def close
+    @pipe_input.close
+  end
+
+  def sysread(len = 1)
+    @pipe_input.sysread(len)
+  end
+
+  def put(msg)
+    @pipe_input.put(msg)
+  end
+
+  def gets
+    @pipe_input.gets
+  end
+
+  def eof?
+    @pipe_input.eof?
+  end
+
+  def fd
+    @pipe_input.fd
+  end
+
+  #
+  # Wrappers for shell methods
+  #
+
+  attr_accessor :output, :prompt, :input
+
+  def intrinsic_shell?
+    true
+  end
+
+  def supports_readline
+    false
+  end
+
+  def supports_color?
+    false
+  end
+
+  def pgets
+    gets
+  end
+
+
+protected
+
+end
+
+end
+end