librex 0.0.68 → 0.0.70

data/lib/rex/random_identifier_generator.rb

@@ -0,0 +1,176 @@
+
+# A quick way to produce unique random strings that follow the rules of
+# identifiers, i.e., begin with a letter and contain only alphanumeric
+# characters and underscore.
+#
+# The advantage of using this class over, say, {Rex::Text.rand_text_alpha}
+# each time you need a new identifier is that it ensures you don't have
+# collisions.
+#
+# @example
+#   vars = Rex::RandomIdentifierGenerator.new
+#   asp_code = <<-END_CODE
+#     Sub #{vars[:func]}()
+#       Dim #{vars[:fso]}
+#       Set #{vars[:fso]} = CreateObject("Scripting.FileSystemObject")
+#       ...
+#     End Sub
+#     #{vars[:func]}
+#   END_CODE
+#
+class Rex::RandomIdentifierGenerator
+
+  # Raised when a RandomIdentifierGenerator cannot create any more
+  # identifiers without collisions.
+  class ExhaustedSpaceError < StandardError; end
+
+  # Default options
+  DefaultOpts = {
+    # Arbitrary
+    :max_length => 12,
+    :min_length => 3,
+    # This should be pretty universal for identifier rules
+    :char_set => Rex::Text::AlphaNumeric+"_",
+    :first_char_set => Rex::Text::LowerAlpha
+  }
+
+  # @param opts [Hash] Options, see {DefaultOpts} for default values
+  # @option opts :max_length [Fixnum]
+  # @option opts :min_length [Fixnum]
+  # @option opts :char_set [String]
+  def initialize(opts={})
+    # Holds all identifiers.
+    @value_by_name = {}
+    # Inverse of value_by_name so we can ensure uniqueness without
+    # having to search through the whole list of values
+    @name_by_value = {}
+
+    @opts = DefaultOpts.merge(opts)
+    if @opts[:min_length] < 1 || @opts[:max_length] < 1 || @opts[:max_length] < @opts[:min_length]
+      raise ArgumentError, "Invalid length options"
+    end
+
+    # This is really just the maximum number of shortest names. This
+    # will still be a pretty big number most of the time, so don't
+    # bother calculating the real one, which will potentially be
+    # expensive, since we're talking about a 36-digit decimal number to
+    # represent the total possibilities for the range of 10- to
+    # 20-character identifiers.
+    #
+    # 26 because the first char is lowercase alpha, (min_length - 1) and
+    # not just min_length because it includes that first alpha char.
+    @max_permutations = 26 * (@opts[:char_set].length ** (@opts[:min_length]-1))
+    # The real number of permutations could be calculated thusly:
+    #((@opts[:min_length]-1) .. (@opts[:max_length]-1)).reduce(0) { |a, e|
+    #	a + (26 * @opts[:char_set].length ** e)
+    #}
+  end
+
+  # Returns the @value_by_name hash
+  #
+  # @return [Hash]
+  def to_h
+    return @value_by_name
+  end
+
+  # Return a unique random identifier for +name+, generating a new one
+  # if necessary.
+  #
+  # @param name [Symbol] A descriptive, intention-revealing name for an
+  #   identifier. This is what you would normally call the variable if
+  #   you weren't generating it.
+  # @return [String]
+  def get(name)
+    return @value_by_name[name] if @value_by_name[name]
+
+    @value_by_name[name] = generate
+    @name_by_value[@value_by_name[name]] = name
+
+    @value_by_name[name]
+  end
+  alias [] get
+  alias init_var get
+
+  # Add a new identifier. Its name will be checked for uniqueness among
+  # previously-generated names.
+  #
+  # @note This should be called *before* any calls to {#get} to avoid
+  #   potential collisions. If you do hit a collision, this method will
+  #   raise.
+  #
+  # @param name (see #get)
+  # @param value [String] The identifier that will be returned by
+  #   subsequent calls to {#get} with the sane +name+.
+  # @raise RuntimeError if +value+ already exists
+  # @return [void]
+  def store(name, value)
+
+    case @name_by_value[value]
+    when name
+      # we already have this value and it is associated with this name
+      # nothing to do here
+    when nil
+      # don't have this value yet, so go ahead and just insert
+      @value_by_name[name] = value
+      @name_by_value[value] = name
+    else
+      # then the caller is trying to insert a duplicate
+      raise RuntimeError, "Value is not unique!"
+    end
+
+    self
+  end
+
+  # Create a random string that satisfies most languages' requirements
+  # for identifiers. In particular, with a default configuration, the
+  # first character will always be lowercase alpha (unless modified by a
+  # block), and the whole thing will contain only a-zA-Z0-9_ characters.
+  #
+  # If called with a block, the block will be given the identifier before
+  # uniqueness checks. The block's return value will be the new
+  # identifier. Note that the block may be called multiple times if it
+  # returns a non-unique value.
+  #
+  # @note Calling this method with a block that returns only values that
+  #   this generator already contains will result in an infinite loop.
+  #
+  # @example
+  #   rig = Rex::RandomIdentifierGenerator.new
+  #   const = rig.generate { |val| val.capitalize }
+  #   rig.insert(:SOME_CONSTANT, const)
+  #   ruby_code = <<-EOC
+  #     #{rig[:SOME_CONSTANT]} = %q^generated ruby constant^
+  #     def #{rig[:my_method]}; ...; end
+  #   EOC
+  #
+  # @param len [Fixnum] Avoid setting this unless a specific size is
+  #   necessary. Default is random within range of min .. max
+  # @return [String] A string that matches <tt>[a-z][a-zA-Z0-9_]*</tt>
+  # @yield [String] The identifier before uniqueness checks. This allows
+  #   you to modify the value and still avoid collisions.
+  def generate(len=nil)
+    raise ArgumentError, "len must be positive integer" if len && len < 1
+    raise ExhaustedSpaceError if @value_by_name.length >= @max_permutations
+
+    # pick a random length within the limits
+    len ||= rand(@opts[:min_length] .. (@opts[:max_length]))
+
+    ident = ""
+
+    # XXX: Infinite loop if block returns only values we've already
+    # generated.
+    loop do
+      ident  = Rex::Text.rand_base(1, "", @opts[:first_char_set])
+      ident << Rex::Text.rand_base(len-1, "", @opts[:char_set])
+      if block_given?
+        ident = yield ident
+      end
+      # Try to make another one if it collides with a previously
+      # generated one.
+      break unless @name_by_value.key?(ident)
+    end
+
+    ident
+  end
+
+end

data/lib/rex/registry.rb

@@ -9,6 +9,6 @@ require 'rex/registry/valuelist'
 module Rex
 module Registry
 
-	attr_accessor :alias
+  attr_accessor :alias
 end
 end

data/lib/rex/registry/hive.rb

@@ -6,126 +6,126 @@ module Rex
 module Registry
 
 class Hive
-	attr_accessor :root_key, :hive_regf, :hive_name
+  attr_accessor :root_key, :hive_regf, :hive_name
 
-	def initialize(hivepath)
+  def initialize(hivepath)
 
-		hive_blob = open(hivepath, "rb") { |io| io.read }
+    hive_blob = open(hivepath, "rb") { |io| io.read }
 
-		@hive_regf = RegfBlock.new(hive_blob)
-		return nil if !@hive_regf.root_key_offset
+    @hive_regf = RegfBlock.new(hive_blob)
+    return nil if !@hive_regf.root_key_offset
 
-		@root_key = NodeKey.new(hive_blob, 0x1000 + @hive_regf.root_key_offset)
-		return nil if !@root_key.lf_record
+    @root_key = NodeKey.new(hive_blob, 0x1000 + @hive_regf.root_key_offset)
+    return nil if !@root_key.lf_record
 
-		keys = []
-		root_key.lf_record.children.each do |key|
-			keys << key.name
-		end
+    keys = []
+    root_key.lf_record.children.each do |key|
+      keys << key.name
+    end
 
-		if keys.include? "LastKnownGoodRecovery"
-			@hive_name = "SYSTEM"
-		elsif keys.include? "Microsoft"
-			@hive_name = "SOFTWARE"
-		elsif keys.include? "Environment"
-			@hive_name = "NTUSER.DAT"
-		elsif keys.include? "SAM"
-			@hive_name = "SAM"
-		elsif keys.include? "Policy"
-			@hive_name = "SECURITY"
-		else
-			@hive_name = "UNKNOWN"
-		end
+    if keys.include? "LastKnownGoodRecovery"
+      @hive_name = "SYSTEM"
+    elsif keys.include? "Microsoft"
+      @hive_name = "SOFTWARE"
+    elsif keys.include? "Environment"
+      @hive_name = "NTUSER.DAT"
+    elsif keys.include? "SAM"
+      @hive_name = "SAM"
+    elsif keys.include? "Policy"
+      @hive_name = "SECURITY"
+    else
+      @hive_name = "UNKNOWN"
+    end
 
-	end
+  end
 
-	def relative_query(path)
+  def relative_query(path)
 
-		if path == "" || path == "\\"
-			return @root_key
-		end
+    if path == "" || path == "\\"
+      return @root_key
+    end
 
-		current_child = nil
-		paths = path.split("\\")
+    current_child = nil
+    paths = path.split("\\")
 
-		return if !@root_key.lf_record
+    return if !@root_key.lf_record
 
-		@root_key.lf_record.children.each do |child|
-			next if child.name.downcase != paths[1].downcase
+    @root_key.lf_record.children.each do |child|
+      next if child.name.downcase != paths[1].downcase
 
-			current_child = child
+      current_child = child
 
-			if paths.length == 2
-				current_child.full_path = path
-				return current_child
-			end
+      if paths.length == 2
+        current_child.full_path = path
+        return current_child
+      end
 
-			2.upto(paths.length) do |i|
+      2.upto(paths.length) do |i|
 
-				if i == paths.length
-					current_child.full_path = path
-					return current_child
-				else
-					if current_child.lf_record && current_child.lf_record.children
-						current_child.lf_record.children.each do |c|
-							next if c.name.downcase != paths[i].downcase
+        if i == paths.length
+          current_child.full_path = path
+          return current_child
+        else
+          if current_child.lf_record && current_child.lf_record.children
+            current_child.lf_record.children.each do |c|
+              next if c.name.downcase != paths[i].downcase
 
-							current_child = c
+              current_child = c
 
-							break
-						end
-					end
-				end
-			end
-		end
+              break
+            end
+          end
+        end
+      end
+    end
 
-		return if !current_child
+    return if !current_child
 
-		current_child.full_path = path
-		return current_child
-		end
+    current_child.full_path = path
+    return current_child
+    end
 
-		def value_query(path)
-			if path == "" || path == "\\"
-			return nil
-		end
+    def value_query(path)
+      if path == "" || path == "\\"
+      return nil
+    end
 
-		paths = path.split("\\")
+    paths = path.split("\\")
 
-		return if !@root_key.lf_record
+    return if !@root_key.lf_record
 
-		@root_key.lf_record.children.each do |root_child|
-			next if root_child.name.downcase != paths[1].downcase
+    @root_key.lf_record.children.each do |root_child|
+      next if root_child.name.downcase != paths[1].downcase
 
-			current_child = root_child
+      current_child = root_child
 
-			if paths.length == 2
-				return nil
-			end
+      if paths.length == 2
+        return nil
+      end
 
-			2.upto(paths.length - 1) do |i|
-				next if !current_child.lf_record
+      2.upto(paths.length - 1) do |i|
+        next if !current_child.lf_record
 
-				current_child.lf_record.children.each do |c|
-					next if c.name != paths[i]
-					current_child = c
+        current_child.lf_record.children.each do |c|
+          next if c.name != paths[i]
+          current_child = c
 
-					break
-				end
-			end
+          break
+        end
+      end
 
-			if !current_child.value_list || current_child.value_list.values.length == 0
-				return nil
-			end
+      if !current_child.value_list || current_child.value_list.values.length == 0
+        return nil
+      end
 
-			current_child.value_list.values.each do |value|
-				next if value.name.downcase != paths[paths.length - 1].downcase
+      current_child.value_list.values.each do |value|
+        next if value.name.downcase != paths[paths.length - 1].downcase
 
-				value.full_path = path
-				return value
-			end
-		end
-	end
+        value.full_path = path
+        return value
+      end
+    end
+  end
 end
 
 end

data/lib/rex/registry/lfkey.rb

@@ -6,44 +6,44 @@ module Registry
 
 class LFBlock
 
-	attr_accessor :number_of_keys, :hash_records, :children
+  attr_accessor :number_of_keys, :hash_records, :children
 
-	def initialize(hive_blob, offset)
-		offset = offset + 4
-		lf_header = hive_blob[offset, 2]
+  def initialize(hive_blob, offset)
+    offset = offset + 4
+    lf_header = hive_blob[offset, 2]
 
-		if lf_header !~ /lf/ && lf_header !~ /lh/
-			return
-		end
+    if lf_header !~ /lf/ && lf_header !~ /lh/
+      return
+    end
 
-		@number_of_keys = hive_blob[offset + 0x02, 2].unpack('C').first
+    @number_of_keys = hive_blob[offset + 0x02, 2].unpack('C').first
 
-		@hash_records = []
-		@children = []
+    @hash_records = []
+    @children = []
 
-		hash_offset = offset + 0x04
+    hash_offset = offset + 0x04
 
-		1.upto(@number_of_keys) do |h|
-			
-			hash = LFHashRecord.new(hive_blob, hash_offset)
+    1.upto(@number_of_keys) do |h|
 
-			@hash_records << hash
+      hash = LFHashRecord.new(hive_blob, hash_offset)
 
-			hash_offset = hash_offset + 0x08
+      @hash_records << hash
 
-			@children << NodeKey.new(hive_blob, hash.nodekey_offset + 0x1000)
-		end
-	end
+      hash_offset = hash_offset + 0x08
+
+      @children << NodeKey.new(hive_blob, hash.nodekey_offset + 0x1000)
+    end
+  end
 end
 
 class LFHashRecord
 
-	attr_accessor :nodekey_offset, :nodekey_name_verification
-		
-	def initialize(hive_blob, offset)
-		@nodekey_offset = hive_blob[offset, 4].unpack('l').first
-		@nodekey_name_verification = hive_blob[offset+0x04, 4].to_s
-	end
+  attr_accessor :nodekey_offset, :nodekey_name_verification
+
+  def initialize(hive_blob, offset)
+    @nodekey_offset = hive_blob[offset, 4].unpack('l').first
+    @nodekey_name_verification = hive_blob[offset+0x04, 4].to_s
+  end
 
 end