dstruct 0.0.1

data/lib/rex/poly/register.rb

@@ -0,0 +1,101 @@
+# -*- coding: binary -*-
+module Rex
+module Poly
+
+###
+#
+# This class represents a register that is used in the context of one or more
+# logical blocks.  The register number is assigned on demand or is statically
+# specified if passed in to the constructor.
+#
+###
+class LogicalRegister
+
+  require 'rex/poly/register/x86'
+
+  #
+  # This class method is meant to return an array of register numbers that
+  # can be used to pool from.  Architecture specific classes must implement
+  # this method on their own.
+  #
+  def self.regnum_set
+    nil
+  end
+
+  #
+  # Initializes the register's name and number, if assigned.  If a register
+  # number is specified, the instance will be assumed to have a statically
+  # assigned register number.  The name is meant to be used as a symbolic
+  # variable name, such as 'counter' or 'key'.
+  #
+  def initialize(name, regnum = nil)
+    @name   = name
+    @regnum = regnum
+    @static = (regnum) ? true : false
+  end
+
+  #
+  # Returns true if the register number should be assumed static.
+  #
+  def static?
+    @static
+  end
+
+  #
+  # Sets the register number to the value specified.  If the register number
+  # is declared static, a RuntimeError exception is raised.
+  #
+  def regnum=(val)
+    raise RuntimeError, "Attempted to assign regnum to static register" if (static?)
+
+    @regnum = val
+  end
+
+  #
+  # Returns the register number that has currently been assigned.  If no
+  # register number is assigned, an InvalidRegisterError exception is raised.
+  # This exception can be used to assign the LogicalRegister instance a
+  # register number on demand.
+  #
+  def regnum
+    raise InvalidRegisterError.new(self), "Register has not been assigned" if (@regnum == nil)
+
+    @regnum
+  end
+
+  #
+  # Returns the variable (friendly) name for the register that was passed to
+  # the constructor.
+  #
+  attr_reader :name
+
+protected
+
+end
+
+###
+#
+# An exception that is raised when the regnum method is accessed on a
+# LogicalRegister that does not currently have a regnum assigned to it.
+#
+###
+class InvalidRegisterError < RuntimeError
+
+  #
+  # Initializes the exception with the instance that lead to the generation
+  # of the exception such that it can be assigned a register number as
+  # needed.
+  #
+  def initialize(reg)
+    @reg = reg
+  end
+
+  #
+  # The LogicalRegister instance that generated the exception.
+  #
+  attr_reader :reg
+
+end
+
+end
+end

data/lib/rex/poly/register/x86.rb

@@ -0,0 +1,41 @@
+# -*- coding: binary -*-
+require 'rex/arch/x86'
+
+module Rex
+module Poly
+
+###
+#
+# This class encapsulates logical registers for the X86 architecture.
+#
+###
+class LogicalRegister::X86 < LogicalRegister
+
+  #
+  # The default set of register numbers that can be used on x86.
+  #
+  def self.regnum_set
+    [
+      Rex::Arch::X86::EAX,
+      Rex::Arch::X86::EBX,
+      Rex::Arch::X86::ECX,
+      Rex::Arch::X86::EDX,
+      Rex::Arch::X86::ESI,
+      Rex::Arch::X86::EDI,
+      Rex::Arch::X86::EBP,
+      Rex::Arch::X86::ESP
+    ]
+  end
+
+  #
+  # Calls the base class constructor after translating the register name to
+  # number.
+  #
+  def initialize(name, register = nil)
+    super(name, register ? Rex::Arch::X86.reg_number(register) : nil)
+  end
+
+end
+
+end
+end

data/lib/rex/post.rb

@@ -0,0 +1,7 @@
+# -*- coding: binary -*-
+
+# General independent containers
+require 'rex/post/permission'
+
+# Post-exploitation clients
+require 'rex/post/meterpreter'

data/lib/rex/post/dir.rb

@@ -0,0 +1,51 @@
+# -*- coding: binary -*-
+
+module Rex
+module Post
+
+###
+#
+# This class wraps the behavior of the Ruby Dir class against a remote entity.
+# Refer to the Ruby documentation for expected behavior.
+#
+###
+class Dir
+
+  def Dir.entries(name)
+    raise NotImplementedError
+  end
+
+  def Dir.foreach(name, &block)
+    entries(name).each(&block)
+  end
+
+  def Dir.chdir(path)
+    raise NotImplementedError
+  end
+
+  def Dir.mkdir(path)
+    raise NotImplementedError
+  end
+
+  def Dir.pwd
+    raise NotImplementedError
+  end
+
+  def Dir.getwd
+    raise NotImplementedError
+  end
+
+  def Dir.delete(path)
+    raise NotImplementedError
+  end
+
+  def Dir.rmdir(path)
+    raise NotImplementedError
+  end
+
+  def Dir.unlink(path)
+    raise NotImplementedError
+  end
+end
+
+end; end # Post/Rex

data/lib/rex/post/file.rb

@@ -0,0 +1,172 @@
+# -*- coding: binary -*-
+
+require 'rex/post/io'
+
+module Rex
+module Post
+
+# make this a module so we can mix it in, and have inheritence like..
+# => [Rex::Post::DispatchNinja::File, Rex::Post::File,
+# Rex::Post::DispatchNinja::IO, Rex::Post::IO, Object, Kernel]
+
+###
+#
+# This module simulates the behavior that one would expect from the Ruby File
+# class against a remote entity.  Refer to the ruby documentation for expected
+# behavior.
+#
+###
+module File
+
+  protected
+    # inherits fd and mode from IO
+    attr_accessor :filename
+  public
+
+  # f = File.new("testfile", "r")
+  # f = File.new("newfile",  "w+")
+  # f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
+  # !!! I suppose I should figure out the correct default for perm..
+  def initialize(name, mode='r', perm=0)
+  end
+
+  def path
+    filename
+  end
+
+  # ctime/atime blah need fstat..
+  # need lchown/chown/fchown, etc, etc
+
+  # proxy these methods
+  def File.basename(*a)
+    ::File.basename(*a)
+  end
+  def File.dirname(*a)
+    ::File.dirname(*a)
+  end
+  def File.extname(*a)
+    ::File.extname(*a)
+  end
+  # !!! we might actually want to handle this File::SEPERATOR stuff
+  # for win32 support, etc.
+  def File.join(*a)
+    ::File.join(*a)
+  end
+
+  def File.chmod
+    raise NotImplementedError
+  end
+  def File.chown
+    raise NotImplementedError
+  end
+  def File.delete(*a)
+    unlink(*a)
+  end
+  def File.unlink
+    raise NotImplementedError
+  end
+  def File.lchmod
+    raise NotImplementedError
+  end
+  def File.lchown
+    raise NotImplementedError
+  end
+  def File.link
+    raise NotImplementedError
+  end
+  def File.lstat
+    raise NotImplementedError
+  end
+
+  # this, along with all the other globbing/search stuff, probably
+  # won't get implemented, atleast for a bit...
+  def File.expand_path
+    raise NotImplementedError
+  end
+  def File.fnmatch(*a)
+    fnmatch?(*a)
+  end
+  def File.fnmatch?
+    raise NotImplementedError
+  end
+
+  #
+  # autogen'd stat passthroughs
+  #
+  def File.atime(name)
+    stat(name).atime
+  end
+  def File.blockdev?(name)
+    stat(name).blockdev?
+  end
+  def File.chardev?(name)
+    stat(name).chardev?
+  end
+  def File.ctime(name)
+    stat(name).ctime
+  end
+  def File.directory?(name)
+    stat(name).directory?
+  end
+  def File.executable?(name)
+    stat(name).executable?
+  end
+  def File.executable_real?(name)
+    stat(name).executable_real?
+  end
+  def File.file?(name)
+    stat(name).file?
+  end
+  def File.ftype(name)
+    stat(name).ftype
+  end
+  def File.grpowned?(name)
+    stat(name).grpowned?
+  end
+  def File.mtime(name)
+    stat(name).mtime
+  end
+  def File.owned?(name)
+    stat(name).owned?
+  end
+  def File.pipe?(name)
+    stat(name).pipe?
+  end
+  def File.readable?(name)
+    stat(name).readable?
+  end
+  def File.readable_real?(name)
+    stat(name).readable_real?
+  end
+  def File.setuid?(name)
+    stat(name).setuid?
+  end
+  def File.setgid?(name)
+    stat(name).setgid?
+  end
+  def File.size(name)
+    stat(name).size
+  end
+  def File.socket?(name)
+    stat(name).socket?
+  end
+  def File.sticky?(name)
+    stat(name).sticky?
+  end
+  def File.symlink?(name)
+    stat(name).symlink?
+  end
+  def File.writeable?(name)
+    stat(name).writeable?
+  end
+  def File.writeable_real?(name)
+    stat(name).writeable_real?
+  end
+  def File.zero?(name)
+    stat(name).zero?
+  end
+
+end
+
+end; end # Post/Rex
+

data/lib/rex/post/file_stat.rb

@@ -0,0 +1,220 @@
+# -*- coding: binary -*-
+
+#
+# This is just a container class basically, that acts like File::Struct
+#
+# You must supply an initialize method that somehow populates the stathash..
+#
+
+module Rex
+module Post
+
+###
+#
+# This class emulates the ruby FileStat class against a remote entity in a
+# generic fashion.  Refer to the ruby documentation for expected behavior.
+#
+###
+class FileStat
+
+  #
+  # Basic file types.
+  #
+  @@ftypes = [
+    'fifo', 'characterSpecial', 'directory',
+    'blockSpecial', 'file', 'link', 'socket'
+  ]
+
+  attr_accessor :stathash
+
+  def initialize(buf='')
+    self.stathash = {}
+    update(buf) if (buf and not buf.empty?)
+  end
+
+  def dev
+    self.stathash['st_dev']
+  end
+  def ino
+    self.stathash['st_ino']
+  end
+  def mode
+    self.stathash['st_mode']
+  end
+  def nlink
+    self.stathash['st_nlink']
+  end
+  def uid
+    self.stathash['st_uid']
+  end
+  def gid
+    self.stathash['st_gid']
+  end
+  def rdev
+    self.stathash['st_rdev']
+  end
+  def size
+    self.stathash['st_size']
+  end
+  def blksize
+    self.stathash['st_blksize']
+  end
+  def blocks
+    self.stathash['st_blocks']
+  end
+  def atime
+    Time.at(self.stathash['st_atime'])
+  end
+  def mtime
+    Time.at(self.stathash['st_mtime'])
+  end
+  def ctime
+    Time.at(self.stathash['st_ctime'])
+  end
+
+  def update(buf)
+
+    # XXX: This needs to understand more than just 'stat' structures
+    # Windows can also return _stat32, _stat32i64, _stat64i32, and _stat64 structures
+
+    skeys = %W{st_dev st_ino st_mode st_wtf st_nlink st_uid st_gid st_rdev st_size st_ctime st_atime st_mtime}
+    svals = buf.unpack("VvvvvvvVVVVV")
+    skeys.each_index do |i|
+      self.stathash[ skeys[i] ] = svals[i]
+    end
+  end
+
+  #
+  # S_IFMT     0170000   bitmask for the file type bitfields
+  # S_IFSOCK   0140000   socket
+  # S_IFLNK    0120000   symbolic link
+  # S_IFREG    0100000   regular file
+  # S_IFBLK    0060000   block device
+  # S_IFDIR    0040000   directory
+  # S_IFCHR    0020000   character device
+  # S_IFIFO    0010000   fifo
+  #
+
+  # this is my own, just a helper...
+  def filetype?(mask)
+    return true if mode & 0170000 == mask
+    return false
+  end
+
+  def blockdev?
+    filetype?(060000)
+  end
+  def chardev?
+    filetype?(020000)
+  end
+  def directory?
+    filetype?(040000)
+  end
+  def file?
+    filetype?(0100000)
+  end
+  def pipe?
+    filetype?(010000) # ??? fifo?
+  end
+  def socket?
+    filetype(0140000)
+  end
+  def symlink?
+    filetype(0120000)
+  end
+
+  def ftype
+    return @@ftypes[(mode & 0170000) >> 13].dup
+  end
+
+  #
+  # S_ISUID    0004000   set UID bit
+  # S_ISGID    0002000   set GID bit (see below)
+  # S_ISVTX    0001000   sticky bit (see below)
+  # S_IRWXU    00700     mask for file owner permissions
+  # S_IRUSR    00400     owner has read permission
+  # S_IWUSR    00200     owner has write permission
+  # S_IXUSR    00100     owner has execute permission
+  # S_IRWXG    00070     mask for group permissions
+  # S_IRGRP    00040     group has read permission
+  # S_IWGRP    00020     group has write permission
+  # S_IXGRP    00010     group has execute permission
+  # S_IRWXO    00007     mask for permissions for others (not in group)
+  # S_IROTH    00004     others have read permission
+  # S_IWOTH    00002     others have write permisson
+  # S_IXOTH    00001     others have execute permission
+  #
+
+  def perm?(mask)
+    return true if mode & mask == mask
+    return false
+  end
+
+  def setgid?
+    perm?(02000)
+  end
+  def setuid?
+    perm?(04000)
+  end
+  def sticky?
+    perm?(01000)
+  end
+
+  def executable?
+    raise NotImplementedError
+  end
+  def executable_real?
+    raise NotImplementedError
+  end
+  def grpowned?
+    raise NotImplementedError
+  end
+  def owned?
+    raise NotImplementedError
+  end
+  def readable?
+    raise NotImplementedError
+  end
+  def readable_real?
+    raise NotImplementedError
+  end
+  def writeable?
+    raise NotImplementedError
+  end
+  def writeable_real?
+    raise NotImplementedError
+  end
+
+  #
+  # Return pretty information about a file's permissions.
+  #
+  def prettymode
+    m  = mode
+    om = '%04o' % m
+    perms = ''
+
+    3.times {
+      perms = ((m & 01) == 01 ? 'x' : '-') + perms
+      perms = ((m & 02) == 02 ? 'w' : '-') + perms
+      perms = ((m & 04) == 04 ? 'r' : '-') + perms
+      m >>= 3
+    }
+
+    return "#{om}/#{perms}"
+  end
+
+  #
+  # Return pretty information about a file.
+  #
+  def pretty
+    "  Size: #{size}   Blocks: #{blocks}   IO Block: #{blksize}   Type: #{rdev}\n"\
+    "Device: #{dev}  Inode: #{ino}  Links: #{nlink}\n"\
+    "  Mode: #{prettymode}\n"\
+    "   Uid: #{uid}  Gid: #{gid}\n"\
+    "Access: #{atime}\n"\
+    "Modify: #{mtime}\n"\
+    "Change: #{ctime}\n"
+  end
+
+end
+end; end # Post/Rex