librex 0.0.68 → 0.0.70

data/lib/rex/platforms/windows.rb

@@ -8,45 +8,45 @@ module Windows
 #
 # Windows Registry Constants
 #
-	REG_NONE = 1
-	REG_SZ = 1
-	REG_EXPAND_SZ = 2
-	REG_BINARY = 3
-	REG_DWORD = 4
-	REG_LITTLE_ENDIAN = 4
-	REG_BIG_ENDIAN = 5
-	REG_LINK = 6
-	REG_MULTI_SZ = 7
+  REG_NONE = 1
+  REG_SZ = 1
+  REG_EXPAND_SZ = 2
+  REG_BINARY = 3
+  REG_DWORD = 4
+  REG_LITTLE_ENDIAN = 4
+  REG_BIG_ENDIAN = 5
+  REG_LINK = 6
+  REG_MULTI_SZ = 7
 
-	HKEY_CLASSES_ROOT = 0x80000000
-	HKEY_CURRENT_USER = 0x80000001
-	HKEY_LOCAL_MACHINE = 0x80000002
-	HKEY_USERS = 0x80000003
-	HKEY_PERFORMANCE_DATA = 0x80000004
-	HKEY_CURRENT_CONFIG = 0x80000005
-	HKEY_DYN_DATA = 0x80000006
+  HKEY_CLASSES_ROOT = 0x80000000
+  HKEY_CURRENT_USER = 0x80000001
+  HKEY_LOCAL_MACHINE = 0x80000002
+  HKEY_USERS = 0x80000003
+  HKEY_PERFORMANCE_DATA = 0x80000004
+  HKEY_CURRENT_CONFIG = 0x80000005
+  HKEY_DYN_DATA = 0x80000006
+
+  def registry_hive_lookup(hive)
+    case hive
+    when 'HKCR'
+      HKEY_LOCAL_MACHINE
+    when 'HKCU'
+      HKEY_CURRENT_USER
+    when 'HKLM'
+      HKEY_LOCAL_MACHINE
+    when 'HKU'
+      HKEY_USERS
+    when 'HKPD'
+      HKEY_PERFORMANCE_DATA
+    when 'HKCC'
+      HKEY_CURRENT_CONFIG
+    when 'HKDD'
+      HKEY_DYN_DATA
+    else
+      HKEY_LOCAL_MACHINE
+    end
+  end
 
-	def registry_hive_lookup(hive)
-		case hive
-		when 'HKCR'
-			HKEY_LOCAL_MACHINE
-		when 'HKCU'
-			HKEY_CURRENT_USER
-		when 'HKLM'
-			HKEY_LOCAL_MACHINE
-		when 'HKU'
-			HKEY_USERS
-		when 'HKPD'
-			HKEY_PERFORMANCE_DATA
-		when 'HKCC'
-			HKEY_CURRENT_CONFIG
-		when 'HKDD'
-			HKEY_DYN_DATA
-		else
-			HKEY_LOCAL_MACHINE
-		end
-	end
-	
 end
 end
 end

data/lib/rex/poly.rb

@@ -4,6 +4,7 @@ module Poly
 
 require 'rex/poly/register'
 require 'rex/poly/block'
+require 'rex/poly/machine'
 
 ###
 #
@@ -16,116 +17,116 @@ require 'rex/poly/block'
 ###
 class State
 
-	#
-	# Initializes the polymorphic generation state.
-	#
-	def initialize
-		@block_list = nil
-		reset
-	end
-
-	#
-	# Resets the generation state to have a plain start by clearing all
-	# consumed registers, resetting the polymorphic buffer back to its
-	# beginning and destroying any block generation state.
-	#
-	def reset
-		# Reset the generation flag on any blocks in the block list
-		@block_list.each { |block|
-			block[0].generated = false
-		} if (@block_list)
-
-		@regnums     = Hash.new
-		@buffer      = ''
-		@block_list  = []
-		@curr_offset = 0
-		@first_phase = true
-		@badchars    = nil
-	end
-
-	#
-	# Returns true if the supplied register number is already consumed.
-	#
-	def consumed_regnum?(regnum)
-		@regnums[regnum]
-	end
-
-	#
-	# Consumes a register number, thus removing it from the pool that can be
-	# assigned.  The consumed register number is returned to the caller.
-	#
-	def consume_regnum(regnum)
-		raise RuntimeError, "Register #{regnum} is already consumed." if (consumed_regnum?(regnum))
-
-		@regnums[regnum] = true
-
-		regnum
-	end
-
-	#
-	# Acquires a register number that has not already been consumed from the
-	# supplied register number set and consumes it, returning the selected
-	# register number to the caller.  The register number is selected from the
-	# set at random.
-	#
-	def consume_regnum_from_set(regnum_set)
-		# Pick a random starting point within the supplied set.
-		idx = rand(regnum_set.length)
-
-		# Try each index in the set.
-		regnum_set.length.times { |x|
-			regnum = regnum_set[(idx + x) % regnum_set.length]
-
-			next if (consumed_regnum?(regnum))
-
-			return consume_regnum(regnum)
-		}
-
-		# If we get through the entire iteration without finding a register,
-		# then we are out of registers to assign.
-		raise RuntimeError, "No registers are available to consume from the set"
-	end
-
-	#
-	# Eliminates a register number from the consumed pool so that it can be
-	# used in the future.  This happens after a block indicates that a register
-	# has been clobbered.
-	#
-	def defecate_regnum(regnum)
-		@regnums.delete(regnum)
-	end
-
-	#
-	# The buffer state for the current polymorphic generation.  This stores the
-	# end-result of a call to generate on a LogicalBlock.
-	#
-	attr_accessor :buffer
-
-	#
-	# The linear list of blocks that is generated by calling the generate
-	# method on a LogicalBlock.
-	#
-	attr_accessor :block_list
-
-	#
-	# The current offset into the polymorphic buffer that is being generated.
-	# This is updated as blocks are appended to the block_list.
-	#
-	attr_accessor :curr_offset
-
-	#
-	# A boolean field that is used by the LogicalBlock class to track whether
-	# or not it is in the first phase (generating the block list), or in the
-	# second phase (generating the polymorphic buffer).  This phases are used
-	# to indicate whether or not the offset_of and regnum_of methods will
-	# return actual results.
-	#
-	attr_accessor :first_phase
-
-	#
-	# Characters to avoid when selecting permutations, if any.
-	#
-	attr_accessor :badchars
+  #
+  # Initializes the polymorphic generation state.
+  #
+  def initialize
+    @block_list = nil
+    reset
+  end
+
+  #
+  # Resets the generation state to have a plain start by clearing all
+  # consumed registers, resetting the polymorphic buffer back to its
+  # beginning and destroying any block generation state.
+  #
+  def reset
+    # Reset the generation flag on any blocks in the block list
+    @block_list.each { |block|
+      block[0].generated = false
+    } if (@block_list)
+
+    @regnums     = Hash.new
+    @buffer      = ''
+    @block_list  = []
+    @curr_offset = 0
+    @first_phase = true
+    @badchars    = nil
+  end
+
+  #
+  # Returns true if the supplied register number is already consumed.
+  #
+  def consumed_regnum?(regnum)
+    @regnums[regnum]
+  end
+
+  #
+  # Consumes a register number, thus removing it from the pool that can be
+  # assigned.  The consumed register number is returned to the caller.
+  #
+  def consume_regnum(regnum)
+    raise RuntimeError, "Register #{regnum} is already consumed." if (consumed_regnum?(regnum))
+
+    @regnums[regnum] = true
+
+    regnum
+  end
+
+  #
+  # Acquires a register number that has not already been consumed from the
+  # supplied register number set and consumes it, returning the selected
+  # register number to the caller.  The register number is selected from the
+  # set at random.
+  #
+  def consume_regnum_from_set(regnum_set)
+    # Pick a random starting point within the supplied set.
+    idx = rand(regnum_set.length)
+
+    # Try each index in the set.
+    regnum_set.length.times { |x|
+      regnum = regnum_set[(idx + x) % regnum_set.length]
+
+      next if (consumed_regnum?(regnum))
+
+      return consume_regnum(regnum)
+    }
+
+    # If we get through the entire iteration without finding a register,
+    # then we are out of registers to assign.
+    raise RuntimeError, "No registers are available to consume from the set"
+  end
+
+  #
+  # Eliminates a register number from the consumed pool so that it can be
+  # used in the future.  This happens after a block indicates that a register
+  # has been clobbered.
+  #
+  def defecate_regnum(regnum)
+    @regnums.delete(regnum)
+  end
+
+  #
+  # The buffer state for the current polymorphic generation.  This stores the
+  # end-result of a call to generate on a LogicalBlock.
+  #
+  attr_accessor :buffer
+
+  #
+  # The linear list of blocks that is generated by calling the generate
+  # method on a LogicalBlock.
+  #
+  attr_accessor :block_list
+
+  #
+  # The current offset into the polymorphic buffer that is being generated.
+  # This is updated as blocks are appended to the block_list.
+  #
+  attr_accessor :curr_offset
+
+  #
+  # A boolean field that is used by the LogicalBlock class to track whether
+  # or not it is in the first phase (generating the block list), or in the
+  # second phase (generating the polymorphic buffer).  This phases are used
+  # to indicate whether or not the offset_of and regnum_of methods will
+  # return actual results.
+  #
+  attr_accessor :first_phase
+
+  #
+  # Characters to avoid when selecting permutations, if any.
+  #
+  attr_accessor :badchars
 
 end
 

data/lib/rex/poly/block.rb

@@ -14,35 +14,35 @@ module Poly
 ###
 class Permutation
 
-	#
-	# Initializes the permutation and its associated block.
-	#
-	def initialize(perm, block)
-		@perm  = perm
-		@block = block
-	end
-
-	#
-	# Returns the length of the string returned by to_s.
-	#
-	def length
-		to_s.length
-	end
-
-	#
-	# Returns the string representation of the permutation.  If the underlying
-	# permutation is a procedure, the procedure is called.  Otherwise, the
-	# string representation of the permutation is returned.
-	#
-	def to_s
-		if (@perm.kind_of?(Proc))
-			@perm.call(@block).to_s
-		else
-			@perm.to_s
-		end
-	end
-
-	attr_reader :perm
+  #
+  # Initializes the permutation and its associated block.
+  #
+  def initialize(perm, block)
+    @perm  = perm
+    @block = block
+  end
+
+  #
+  # Returns the length of the string returned by to_s.
+  #
+  def length
+    to_s.length
+  end
+
+  #
+  # Returns the string representation of the permutation.  If the underlying
+  # permutation is a procedure, the procedure is called.  Otherwise, the
+  # string representation of the permutation is returned.
+  #
+  def to_s
+    if (@perm.kind_of?(Proc))
+      @perm.call(@block).to_s
+    else
+      @perm.to_s
+    end
+  end
+
+  attr_reader :perm
 
 end
 
@@ -69,387 +69,389 @@ end
 ###
 class LogicalBlock
 
-	#
-	# Initializes the logical block's name along with zero or more specific
-	# blocks.
-	#
-	def initialize(name, *perms)
-		@name  = name
-
-		reset
-
-		add_perm(*perms)
-	end
-
-	#
-	# Resets the block back to its starting point.
-	#
-	def reset
-		@perms           = []
-		@depends         = []
-		@next_blocks     = []
-		@clobbers        = []
-		@offset          = nil
-		@state           = nil
-		@once            = false
-		@references      = 0
-		@used_references = 0
-		@generated       = false
-	end
-
-	#
-	# Returns the block's name.
-	#
-	def name
-		@name
-	end
-
-	#
-	# Flags whether or not the block should only be generated once.  This can
-	# be used to mark a blog as being depended upon by multiple blocks, but
-	# making it such that it is only generated once.
-	#
-	def once=(tf)
-		@once = tf
-	end
-
-	#
-	# Returns true if this block is a 'once' block.  That is, this block is
-	# dependend upon by multiple blocks but should only be generated once.
-	#
-	def once
-		@once
-	end
-
-	#
-	# Increments the number of blocks that depend on this block.
-	#
-	def ref
-		@references += 1
-	end
-
-	#
-	# Increments the number of blocks that have completed their dependency
-	# pass on this block.  This number should never become higher than the
-	# @references attribute.
-	#
-	def deref
-		@used_references += 1
-	end
-
-	#
-	# Returns true if there is only one block reference remaining.
-	#
-	def last_reference?
-		(@references - @used_references <= 0)
-	end
-
-	#
-	# Adds zero or more specific permutations that may be represented either as
-	# strings or as Proc's to be called at evaluation time.
-	#
-	def add_perm(*perms)
-		@perms.concat(perms)
-	end
-
-	#
-	# Returns a random permutation that is encapsulated in a Permutation class
-	# instance.
-	#
-	def rand_perm
-		perm = nil
-
-		if (@state.badchars)
-			perm = rand_perm_badchars
-		else
-			perm = Permutation.new(@perms[rand(@perms.length)], self)
-		end
-
-		if (perm.nil?)
-			raise RuntimeError, "Failed to locate a valid permutation."
-		end
-
-		perm
-	end
-
-	#
-	# Returns a random permutation that passes any necessary bad character
-	# checks.
-	#
-	def rand_perm_badchars
-		idx = rand(@perms.length)
-		off = 0
-
-		while (off < @perms.length)
-			p = @perms[(idx + off) % @perms.length]
-
-			if (p.kind_of?(Proc) or
-			    @state.badchars.nil? or
-			    Rex::Text.badchar_index(p, @state.badchars).nil?)
-				return Permutation.new(p, self)
-			end
-
-			off += 1
-		end
-	end
-
-	#
-	# Sets the blocks that this block instance depends on.
-	#
-	def depends_on(*depends)
-		@depends = depends.dup
-
-		# Increment dependent references
-		@depends.each { |b| b.ref }
-	end
-
-	#
-	# Defines the next blocks, but not in a dependency fashion but rather in a
-	# linking of separate block contexts.
-	#
-	def next_blocks(*blocks)
-		@next_blocks = blocks.dup
-	end
-
-	#
-	# Defines the list of zero or more LogicalRegister's that this block
-	# clobbers.
-	#
-	def clobbers(*registers)
-		@clobbers = registers
-	end
-
-	#
-	# Enumerates each register instance that is clobbered by this block.
-	#
-	def each_clobbers(&block)
-		@clobbers.each(&block)
-	end
-
-	#
-	# Generates the polymorphic buffer that results from this block and any of
-	# the blocks that it either directly or indirectly depends on.  A list of
-	# register numbers to be saved can be passed in as an argument.
-	#
-	# This method is not thread safe.  To call this method on a single block
-	# instance from within multiple threads, be sure to encapsulate the calls
-	# inside a locked context.
-	#
-	def generate(save_registers = nil, state = nil, badchars = nil)
-		# Create a localized state instance if one was not supplied.
-		state = Rex::Poly::State.new if (state == nil)
-		buf   = nil
-		cnt   = 0
-
-		# This is a lame way of doing this.  We just try to generate at most 128
-		# times until we don't have badchars.  The reason we have to do it this
-		# way is because of the fact that badchars can be introduced through
-		# block offsetting and register number selection which can't be readily
-		# predicted or detected during the generation phase.  In the future we
-		# can make this better, but for now this will have to do.
-		begin
-			buf = do_generate(save_registers, state, badchars)
-
-			if (buf and
-			    (badchars.nil? or Rex::Text.badchar_index(buf, badchars).nil?))
-				break
-			end
-		end while ((cnt += 1) < 128)
-
-		# If we passed 128 tries, then we can't succeed.
-		buf = nil if (cnt >= 128)
-
-		buf
-	end
-
-	#
-	# Returns the offset of a block.  If the active state for this instance is
-	# operating in the first phase, then zero is always returned.  Otherwise,
-	# the correct offset for the supplied block is returned.
-	#
-	def offset_of(lblock)
-		if (@state.first_phase)
-			0
-		else
-			if (lblock.kind_of?(SymbolicBlock::End))
-				@state.curr_offset
-			else
-				lblock.offset
-			end
-		end
-	end
-
-	#
-	# Returns the register number associated with the supplied LogicalRegister
-	# instance.  If the active state for this instance is operating in the
-	# first phase, then zero is always returned.  Otherwise, the correct
-	# register number is returned based on what is currently assigned to the
-	# supplied LogicalRegister instance, if anything.
-	#
-	def regnum_of(reg)
-		(@state.first_phase) ? 0 : reg.regnum
-	end
-
-	def size_of(lblock)
-		@state.block_list.map { |b, p|
-			if b == lblock
-				return p.length
-			end
-		}
-		0
-	end
-
-	#
-	# This attributes contains the currently assigned offset of the permutation
-	# associated with this block into the polymorphic buffer that is being
-	# generated.
-	#
-	attr_accessor :offset
-
-	#
-	# Whether or not this block has currently been generated for a given
-	# iteration.
-	#
-	attr_accessor :generated
+  #
+  # Initializes the logical block's name along with zero or more specific
+  # blocks.
+  #
+  def initialize(name, *perms)
+    @name  = name
+
+    reset
+
+    add_perm(*perms)
+  end
+
+  #
+  # Resets the block back to its starting point.
+  #
+  def reset
+    @perms           = []
+    @depends         = []
+    @next_blocks     = []
+    @clobbers        = []
+    @offset          = nil
+    @state           = nil
+    @once            = false
+    @references      = 0
+    @used_references = 0
+    @generated       = false
+  end
+
+  #
+  # Returns the block's name.
+  #
+  def name
+    @name
+  end
+
+  #
+  # Flags whether or not the block should only be generated once.  This can
+  # be used to mark a blog as being depended upon by multiple blocks, but
+  # making it such that it is only generated once.
+  #
+  def once=(tf)
+    @once = tf
+  end
+
+  #
+  # Returns true if this block is a 'once' block.  That is, this block is
+  # dependend upon by multiple blocks but should only be generated once.
+  #
+  def once
+    @once
+  end
+
+  #
+  # Increments the number of blocks that depend on this block.
+  #
+  # @see #deref
+  def ref
+    @references += 1
+  end
+
+  #
+  # Increments the number of blocks that have completed their dependency
+  # pass on this block.  This number should never become higher than the
+  # `@references` attribute.
+  #
+  # @see #ref
+  def deref
+    @used_references += 1
+  end
+
+  #
+  # Returns true if there is only one block reference remaining.
+  #
+  def last_reference?
+    (@references - @used_references <= 0)
+  end
+
+  #
+  # Adds zero or more specific permutations that may be represented either as
+  # strings or as Proc's to be called at evaluation time.
+  #
+  def add_perm(*perms)
+    @perms.concat(perms)
+  end
+
+  #
+  # Returns a random permutation that is encapsulated in a Permutation class
+  # instance.
+  #
+  def rand_perm
+    perm = nil
+
+    if (@state.badchars)
+      perm = rand_perm_badchars
+    else
+      perm = Permutation.new(@perms[rand(@perms.length)], self)
+    end
+
+    if (perm.nil?)
+      raise RuntimeError, "Failed to locate a valid permutation."
+    end
+
+    perm
+  end
+
+  #
+  # Returns a random permutation that passes any necessary bad character
+  # checks.
+  #
+  def rand_perm_badchars
+    idx = rand(@perms.length)
+    off = 0
+
+    while (off < @perms.length)
+      p = @perms[(idx + off) % @perms.length]
+
+      if (p.kind_of?(Proc) or
+          @state.badchars.nil? or
+          Rex::Text.badchar_index(p, @state.badchars).nil?)
+        return Permutation.new(p, self)
+      end
+
+      off += 1
+    end
+  end
+
+  #
+  # Sets the blocks that this block instance depends on.
+  #
+  def depends_on(*depends)
+    @depends = depends.dup
+
+    # Increment dependent references
+    @depends.each { |b| b.ref }
+  end
+
+  #
+  # Defines the next blocks, but not in a dependency fashion but rather in a
+  # linking of separate block contexts.
+  #
+  def next_blocks(*blocks)
+    @next_blocks = blocks.dup
+  end
+
+  #
+  # Defines the list of zero or more LogicalRegister's that this block
+  # clobbers.
+  #
+  def clobbers(*registers)
+    @clobbers = registers
+  end
+
+  #
+  # Enumerates each register instance that is clobbered by this block.
+  #
+  def each_clobbers(&block)
+    @clobbers.each(&block)
+  end
+
+  #
+  # Generates the polymorphic buffer that results from this block and any of
+  # the blocks that it either directly or indirectly depends on.  A list of
+  # register numbers to be saved can be passed in as an argument.
+  #
+  # This method is not thread safe.  To call this method on a single block
+  # instance from within multiple threads, be sure to encapsulate the calls
+  # inside a locked context.
+  #
+  def generate(save_registers = nil, state = nil, badchars = nil)
+    # Create a localized state instance if one was not supplied.
+    state = Rex::Poly::State.new if (state == nil)
+    buf   = nil
+    cnt   = 0
+
+    # This is a lame way of doing this.  We just try to generate at most 128
+    # times until we don't have badchars.  The reason we have to do it this
+    # way is because of the fact that badchars can be introduced through
+    # block offsetting and register number selection which can't be readily
+    # predicted or detected during the generation phase.  In the future we
+    # can make this better, but for now this will have to do.
+    begin
+      buf = do_generate(save_registers, state, badchars)
+
+      if (buf and
+          (badchars.nil? or Rex::Text.badchar_index(buf, badchars).nil?))
+        break
+      end
+    end while ((cnt += 1) < 128)
+
+    # If we passed 128 tries, then we can't succeed.
+    buf = nil if (cnt >= 128)
+
+    buf
+  end
+
+  #
+  # Returns the offset of a block.  If the active state for this instance is
+  # operating in the first phase, then zero is always returned.  Otherwise,
+  # the correct offset for the supplied block is returned.
+  #
+  def offset_of(lblock)
+    if (@state.first_phase)
+      0
+    else
+      if (lblock.kind_of?(SymbolicBlock::End))
+        @state.curr_offset
+      else
+        lblock.offset
+      end
+    end
+  end
+
+  #
+  # Returns the register number associated with the supplied LogicalRegister
+  # instance.  If the active state for this instance is operating in the
+  # first phase, then zero is always returned.  Otherwise, the correct
+  # register number is returned based on what is currently assigned to the
+  # supplied LogicalRegister instance, if anything.
+  #
+  def regnum_of(reg)
+    (@state.first_phase) ? 0 : reg.regnum
+  end
+
+  def size_of(lblock)
+    @state.block_list.map { |b, p|
+      if b == lblock
+        return p.length
+      end
+    }
+    0
+  end
+
+  #
+  # This attributes contains the currently assigned offset of the permutation
+  # associated with this block into the polymorphic buffer that is being
+  # generated.
+  #
+  attr_accessor :offset
+
+  #
+  # Whether or not this block has currently been generated for a given
+  # iteration.
+  #
+  attr_accessor :generated
 
 protected
 
-	#
-	# Performs the actual polymorphic buffer generation.  Called from generate
-	#
-	def do_generate(save_registers, state, badchars)
-		# Reset the state in case it was passed in.
-		state.reset
-
-		# Set the bad character list
-		state.badchars = badchars if (badchars)
-
-		# Consume any registers that should be saved.
-		save_registers.each { |reg|
-			state.consume_regnum(reg)
-		} if (save_registers)
-
-		# Build the linear list of blocks that will be processed.  This
-		# list is built in a dynamic fashion based on block dependencies.
-		# The list that is returned is an Array of which each element is a two
-		# member array, the first element being the LogicalBlock instance that
-		# the permutation came from and the second being an instance of the
-		# Permutation class associated with the selected permutation.
-		block_list = generate_block_list(state)
-
-		# Transition into the second phase which enables offset_of and regnum_of
-		# calls to return real values.
-		state.first_phase = false
-
-		# Now that every block has been assigned an offset, generate the
-		# buffer block by block, assigning registers as necessary.
-		block_list.each { |b|
-
-			# Generate the next permutation and append it to the buffer.
-			begin
-				state.buffer += b[1].to_s
-			# If an invalid register exception is raised, try to consume a random
-			# register from the register's associated architecture register
-			# number set.
-			rescue InvalidRegisterError => e
-				e.reg.regnum = state.consume_regnum_from_set(e.reg.class.regnum_set)
-				retry
-			end
-
-			# Remove any of the registers that have been clobbered by this block
-			# from the list of consumed register numbers so that they can be used
-			# in the future.
-			b[0].each_clobbers { |reg|
-				begin
-					state.defecate_regnum(reg.regnum)
-
-					reg.regnum = nil
-				rescue InvalidRegisterError
-				end
-			}
-
-		}
-
-		# Finally, return the buffer that has been created.
-		state.buffer
-	end
-
-	#
-	# Generates the linear list of block permutations which is stored in the
-	# supplied state instance.  This is done prior to assigning blocks offsets
-	#
-	def generate_block_list(state, level=0)
-		if @depends.length > 1
-			@depends.length.times {
-				f = rand(@depends.length)
-				@depends.push(@depends.delete_at(f))
-			}
-		end
-
-		@depends.length.times { |cidx|
-
-			pass = false
-
-			while (not pass)
-
-				if (@depends[cidx].generated)
-					break
-
-				# If this dependent block is a once block and the magic 8 ball turns
-				# up zero, skip it and let a later block pick it up.  We only do this
-				# if we are not the last block to have a dependency on this block.
-				elsif ((@depends[cidx].once) and
-			    	(rand(2).to_i == 0) and
-			    	(@depends[cidx].last_reference? == false))
-					break
-				end
-
-				# Generate this block
-				@depends[cidx].generate_block_list(state, level+1)
-
-				if level != 0
-					return
-				else
-					@depends.length.times {
-						f = rand(@depends.length)
-						@depends.push(@depends.delete_at(f))
-					}
-
-					next
-				end
-			end
-
-			next
-		}
-
-		self.deref
-
-		# Assign the instance local state for the duration of this generation
-		@state = state
-
-		# Select a random permutation
-		perm = rand_perm
-
-		# Set our block offset to the current state offset
-		self.offset = state.curr_offset
-
-		# Flag ourselves as having been generated for this iteration.
-		self.generated = true
-
-		# Adjust the current offset based on the permutations length
-		state.curr_offset += perm.length
-
-		# Add it to the linear list of blocks
-		state.block_list << [ self, perm ]
-
-		# Generate all the blocks that follow this one.
-		@next_blocks.each { |b|
-			b.generate_block_list(state)
-		}
-
-		# Return the state's block list
-		state.block_list
-	end
+  #
+  # Performs the actual polymorphic buffer generation.  Called from generate
+  #
+  def do_generate(save_registers, state, badchars)
+    # Reset the state in case it was passed in.
+    state.reset
+
+    # Set the bad character list
+    state.badchars = badchars if (badchars)
+
+    # Consume any registers that should be saved.
+    save_registers.each { |reg|
+      state.consume_regnum(reg)
+    } if (save_registers)
+
+    # Build the linear list of blocks that will be processed.  This
+    # list is built in a dynamic fashion based on block dependencies.
+    # The list that is returned is an Array of which each element is a two
+    # member array, the first element being the LogicalBlock instance that
+    # the permutation came from and the second being an instance of the
+    # Permutation class associated with the selected permutation.
+    block_list = generate_block_list(state)
+
+    # Transition into the second phase which enables offset_of and regnum_of
+    # calls to return real values.
+    state.first_phase = false
+
+    # Now that every block has been assigned an offset, generate the
+    # buffer block by block, assigning registers as necessary.
+    block_list.each { |b|
+
+      # Generate the next permutation and append it to the buffer.
+      begin
+        state.buffer += b[1].to_s
+      # If an invalid register exception is raised, try to consume a random
+      # register from the register's associated architecture register
+      # number set.
+      rescue InvalidRegisterError => e
+        e.reg.regnum = state.consume_regnum_from_set(e.reg.class.regnum_set)
+        retry
+      end
+
+      # Remove any of the registers that have been clobbered by this block
+      # from the list of consumed register numbers so that they can be used
+      # in the future.
+      b[0].each_clobbers { |reg|
+        begin
+          state.defecate_regnum(reg.regnum)
+
+          reg.regnum = nil
+        rescue InvalidRegisterError
+        end
+      }
+
+    }
+
+    # Finally, return the buffer that has been created.
+    state.buffer
+  end
+
+  #
+  # Generates the linear list of block permutations which is stored in the
+  # supplied state instance.  This is done prior to assigning blocks offsets
+  #
+  def generate_block_list(state, level=0)
+    if @depends.length > 1
+      @depends.length.times {
+        f = rand(@depends.length)
+        @depends.push(@depends.delete_at(f))
+      }
+    end
+
+    @depends.length.times { |cidx|
+
+      pass = false
+
+      while (not pass)
+
+        if (@depends[cidx].generated)
+          break
+
+        # If this dependent block is a once block and the magic 8 ball turns
+        # up zero, skip it and let a later block pick it up.  We only do this
+        # if we are not the last block to have a dependency on this block.
+        elsif ((@depends[cidx].once) and
+            (rand(2).to_i == 0) and
+            (@depends[cidx].last_reference? == false))
+          break
+        end
+
+        # Generate this block
+        @depends[cidx].generate_block_list(state, level+1)
+
+        if level != 0
+          return
+        else
+          @depends.length.times {
+            f = rand(@depends.length)
+            @depends.push(@depends.delete_at(f))
+          }
+
+          next
+        end
+      end
+
+      next
+    }
+
+    self.deref
+
+    # Assign the instance local state for the duration of this generation
+    @state = state
+
+    # Select a random permutation
+    perm = rand_perm
+
+    # Set our block offset to the current state offset
+    self.offset = state.curr_offset
+
+    # Flag ourselves as having been generated for this iteration.
+    self.generated = true
+
+    # Adjust the current offset based on the permutations length
+    state.curr_offset += perm.length
+
+    # Add it to the linear list of blocks
+    state.block_list << [ self, perm ]
+
+    # Generate all the blocks that follow this one.
+    @next_blocks.each { |b|
+      b.generate_block_list(state)
+    }
+
+    # Return the state's block list
+    state.block_list
+  end
 
 end
 
@@ -462,16 +464,16 @@ end
 ###
 module SymbolicBlock
 
-	###
-	#
-	# The symbolic end of a polymorphic buffer.
-	#
-	###
-	class End < LogicalBlock
-		def initialize
-			super('__SYMBLK_END__')
-		end
-	end
+  ###
+  #
+  # The symbolic end of a polymorphic buffer.
+  #
+  ###
+  class End < LogicalBlock
+    def initialize
+      super('__SYMBLK_END__')
+    end
+  end
 end
 
 end