rex-text 0.1.0

data/lib/rex/text/illegal_sequence.rb

@@ -0,0 +1,6 @@
+# -*- coding: binary -*-
+module Rex
+  module Text
+    class IllegalSequence < ArgumentError; end
+  end
+end

data/lib/rex/text/lang.rb

@@ -0,0 +1,156 @@
+# -*- coding: binary -*-
+module Rex
+  module Text
+    # We are re-opening the module to add these module methods.
+    # Breaking them up this way allows us to maintain a little higher
+    # degree of organisation and make it easier to find what you're looking for
+    # without hanging the underlying calls that we historically rely upon.
+
+    #
+    # Converts a raw string into a ruby buffer
+    #
+    def self.to_ruby(str, wrap = DefaultWrap, name = "buf")
+      return hexify(str, wrap, '"', '" +', "#{name} = \n", '"')
+    end
+
+    #
+    # Creates a ruby-style comment
+    #
+    def self.to_ruby_comment(str, wrap = DefaultWrap)
+      return wordwrap(str, 0, wrap, '', '# ')
+    end
+
+    #
+    # Converts a raw string into a C buffer
+    #
+    def self.to_c(str, wrap = DefaultWrap, name = "buf")
+      return hexify(str, wrap, '"', '"', "unsigned char #{name}[] = \n", '";')
+    end
+
+    def self.to_csharp(str, wrap = DefaultWrap, name = "buf")
+      ret = "byte[] #{name} = new byte[#{str.length}] {"
+      i = -1;
+      while (i += 1) < str.length
+        ret << "\n" if i%(wrap/4) == 0
+        ret << "0x" << str[i].unpack("H*")[0] << ","
+      end
+      ret = ret[0..ret.length-2] #cut off last comma
+      ret << " };\n"
+    end
+
+    #
+    # Creates a c-style comment
+    #
+    def self.to_c_comment(str, wrap = DefaultWrap)
+      return "/*\n" + wordwrap(str, 0, wrap, '', ' * ') + " */\n"
+    end
+
+    #
+    # Creates a javascript-style comment
+    #
+    def self.to_js_comment(str, wrap = DefaultWrap)
+      return wordwrap(str, 0, wrap, '', '// ')
+    end
+
+    #
+    # Converts a raw string into a perl buffer
+    #
+    def self.to_perl(str, wrap = DefaultWrap, name = "buf")
+      return hexify(str, wrap, '"', '" .', "my $#{name} = \n", '";')
+    end
+
+    #
+    # Converts a raw string into a python buffer
+    #
+    def self.to_python(str, wrap = DefaultWrap, name = "buf")
+      return hexify(str, wrap, "#{name} += \"", '"', "#{name} =  \"\"\n", '"')
+    end
+
+    #
+    # Converts a raw string into a Bash buffer
+    #
+    def self.to_bash(str, wrap = DefaultWrap, name = "buf")
+      return hexify(str, wrap, '$\'', '\'\\', "export #{name}=\\\n", '\'')
+    end
+
+    #
+    # Converts a raw string into a java byte array
+    #
+    def self.to_java(str, name = "shell")
+      buff = "byte #{name}[] = new byte[]\n{\n"
+      cnt = 0
+      max = 0
+      str.unpack('C*').each do |c|
+        buff << ", " if max > 0
+        buff << "\t" if max == 0
+        buff << sprintf('(byte) 0x%.2x', c)
+        max +=1
+        cnt +=1
+
+        if (max > 7)
+          buff << ",\n" if cnt != str.length
+          max = 0
+        end
+      end
+      buff << "\n};\n"
+      return buff
+    end
+
+    #
+    # Converts a raw string to a vbscript byte array
+    #
+    def self.to_vbscript(str, name = "buf")
+      return "#{name}" if str.nil? or str.empty?
+
+      code = str.unpack('C*')
+      buff = "#{name}=Chr(#{code[0]})"
+      1.upto(code.length-1) do |byte|
+        if(byte % 100 == 0)
+          buff << "\r\n#{name}=#{name}"
+        end
+        # exe is an Array of bytes, not a String, thanks to the unpack
+        # above, so the following line is not subject to the different
+        # treatments of String#[] between ruby 1.8 and 1.9
+        buff << "&Chr(#{code[byte]})"
+      end
+
+      return buff
+    end
+
+    #
+    # Converts a raw string into a vba buffer
+    #
+    def self.to_vbapplication(str, name = "buf")
+      return "#{name} = Array()" if str.nil? or str.empty?
+
+      code  = str.unpack('C*')
+      buff = "#{name} = Array("
+      maxbytes = 20
+
+      1.upto(code.length) do |idx|
+        buff << code[idx].to_s
+        buff << "," if idx < code.length - 1
+        buff << " _\r\n" if (idx > 1 and (idx % maxbytes) == 0)
+      end
+
+      buff << ")\r\n"
+
+      return buff
+    end
+
+    #
+    # Creates a perl-style comment
+    #
+    def self.to_perl_comment(str, wrap = DefaultWrap)
+      return wordwrap(str, 0, wrap, '', '# ')
+    end
+
+    #
+    # Creates a Bash-style comment
+    #
+    def self.to_bash_comment(str, wrap = DefaultWrap)
+      return wordwrap(str, 0, wrap, '', '# ')
+    end
+
+  end
+end

data/lib/rex/text/pattern.rb

@@ -0,0 +1,91 @@
+# -*- coding: binary -*-
+module Rex
+  module Text
+    # We are re-opening the module to add these module methods.
+    # Breaking them up this way allows us to maintain a little higher
+    # degree of organisation and make it easier to find what you're looking for
+    # without hanging the underlying calls that we historically rely upon.
+
+    #
+    # Creates a pattern that can be used for offset calculation purposes.  This
+    # routine is capable of generating patterns using a supplied set and a
+    # supplied number of identifiable characters (slots).  The supplied sets
+    # should not contain any duplicate characters or the logic will fail.
+    #
+    # @param length [Fixnum]
+    # @param sets [Array<(String,String,String)>] The character sets to choose
+    #   from. Should have 3 elements, each of which must be a string containing
+    #   no characters contained in the other sets.
+    # @return [String] A pattern of +length+ bytes, in which any 4-byte chunk is
+    #   unique
+    # @see pattern_offset
+    def self.pattern_create(length, sets = nil)
+      buf = ''
+      offsets = []
+
+      # Make sure there's something in sets even if we were given an explicit nil
+      sets ||= [ UpperAlpha, LowerAlpha, Numerals ]
+
+      # Return stupid uses
+      return "" if length.to_i < 1
+      return sets[0][0].chr * length if sets.size == 1 and sets[0].size == 1
+
+      sets.length.times { offsets << 0 }
+
+      until buf.length >= length
+        begin
+          buf << converge_sets(sets, 0, offsets, length)
+        end
+      end
+
+      # Maximum permutations reached, but we need more data
+      if (buf.length < length)
+        buf = buf * (length / buf.length.to_f).ceil
+      end
+
+      buf[0,length]
+    end
+
+    # Step through an arbitrary number of sets of bytes to build up a findable pattern.
+    # This is mostly useful for experimentially determining offset lengths into memory
+    # structures. Note that the supplied sets should never contain duplicate bytes, or
+    # else it can become impossible to measure the offset accurately.
+    def self.patt2(len, sets = nil)
+      buf = ""
+      counter = []
+      sets ||= [ UpperAlpha, LowerAlpha, Numerals ]
+      len ||= len.to_i
+      return "" if len.zero?
+
+      sets = sets.map {|a| a.split(//)}
+      sets.size.times { counter << 0}
+      0.upto(len-1) do |i|
+        setnum = i % sets.size
+
+        #puts counter.inspect
+      end
+
+      return buf
+    end
+
+    #
+    # Calculate the offset to a pattern
+    #
+    # @param pattern [String] The pattern to search. Usually the return value
+    #   from {.pattern_create}
+    # @param value [String,Fixnum,Bignum]
+    # @return [Fixnum] Index of the given +value+ within +pattern+, if it exists
+    # @return [nil] if +pattern+ does not contain +value+
+    # @see pattern_create
+    def self.pattern_offset(pattern, value, start=0)
+      if (value.kind_of?(String))
+        pattern.index(value, start)
+      elsif (value.kind_of?(Fixnum) or value.kind_of?(Bignum))
+        pattern.index([ value ].pack('V'), start)
+      else
+        raise ::ArgumentError, "Invalid class for value: #{value.class}"
+      end
+    end
+
+  end
+end

data/lib/rex/text/rand.rb

@@ -0,0 +1,233 @@
+# -*- coding: binary -*-
+module Rex
+  module Text
+    # We are re-opening the module to add these module methods.
+    # Breaking them up this way allows us to maintain a little higher
+    # degree of organisation and make it easier to find what you're looking for
+    # without hanging the underlying calls that we historically rely upon.
+
+
+    TLDs = ['com', 'net', 'org', 'gov', 'biz', 'edu']
+    States = ["AK", "AL", "AR", "AZ", "CA", "CO", "CT", "DE", "FL", "GA", "HI",
+              "IA", "ID", "IL", "IN", "KS", "KY", "LA", "MA", "MD", "ME", "MI", "MN",
+              "MO", "MS", "MT", "NC", "ND", "NE", "NH", "NJ", "NM", "NV", "NY", "OH",
+              "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VA", "VT", "WA",
+              "WI", "WV", "WY"]
+    #
+    # Most 100 common surnames, male/female names in the U.S. (http://names.mongabay.com/)
+    #
+
+    Surnames = [
+      "adams", "alexander", "allen", "anderson", "bailey", "baker", "barnes",
+      "bell", "bennett", "brooks", "brown", "bryant", "butler", "campbell",
+      "carter", "clark", "coleman", "collins", "cook", "cooper", "cox",
+      "davis", "diaz", "edwards", "evans", "flores", "foster", "garcia",
+      "gonzales", "gonzalez", "gray", "green", "griffin", "hall", "harris",
+      "hayes", "henderson", "hernandez", "hill", "howard", "hughes", "jackson",
+      "james", "jenkins", "johnson", "jones", "kelly", "king", "lee", "lewis",
+      "long", "lopez", "martin", "martinez", "miller", "mitchell", "moore",
+      "morgan", "morris", "murphy", "nelson", "parker", "patterson", "perez",
+      "perry", "peterson", "phillips", "powell", "price", "ramirez", "reed",
+      "richardson", "rivera", "roberts", "robinson", "rodriguez", "rogers",
+      "ross", "russell", "sanchez", "sanders", "scott", "simmons", "smith",
+      "stewart", "taylor", "thomas", "thompson", "torres", "turner", "walker",
+      "ward", "washington", "watson", "white", "williams", "wilson", "wood",
+      "wright", "young"
+    ]
+
+    Names_Male = [
+      "aaron", "adam", "alan", "albert", "andrew", "anthony", "antonio",
+      "arthur", "benjamin", "billy", "bobby", "brandon", "brian", "bruce",
+      "carl", "carlos", "charles", "chris", "christopher", "clarence", "craig",
+      "daniel", "david", "dennis", "donald", "douglas", "earl", "edward",
+      "eric", "ernest", "eugene", "frank", "fred", "gary", "george", "gerald",
+      "gregory", "harold", "harry", "henry", "howard", "jack", "james", "jason",
+      "jeffrey", "jeremy", "jerry", "jesse", "jimmy", "joe", "john", "johnny",
+      "jonathan", "jose", "joseph", "joshua", "juan", "justin", "keith",
+      "kenneth", "kevin", "larry", "lawrence", "louis", "mark", "martin",
+      "matthew", "michael", "nicholas", "patrick", "paul", "peter", "philip",
+      "phillip", "ralph", "randy", "raymond", "richard", "robert", "roger",
+      "ronald", "roy", "russell", "ryan", "samuel", "scott", "sean", "shawn",
+      "stephen", "steve", "steven", "terry", "thomas", "timothy", "todd",
+      "victor", "walter", "wayne", "william", "willie"
+    ]
+
+    Names_Female = [
+      "alice", "amanda", "amy", "andrea", "angela", "ann", "anna", "anne",
+      "annie", "ashley", "barbara", "betty", "beverly", "bonnie", "brenda",
+      "carol", "carolyn", "catherine", "cheryl", "christina", "christine",
+      "cynthia", "deborah", "debra", "denise", "diana", "diane", "donna",
+      "doris", "dorothy", "elizabeth", "emily", "evelyn", "frances", "gloria",
+      "heather", "helen", "irene", "jacqueline", "jane", "janet", "janice",
+      "jean", "jennifer", "jessica", "joan", "joyce", "judith", "judy", "julia",
+      "julie", "karen", "katherine", "kathleen", "kathryn", "kathy", "kelly",
+      "kimberly", "laura", "lillian", "linda", "lisa", "lois", "lori", "louise",
+      "margaret", "maria", "marie", "marilyn", "martha", "mary", "melissa",
+      "michelle", "mildred", "nancy", "nicole", "norma", "pamela", "patricia",
+      "paula", "phyllis", "rachel", "rebecca", "robin", "rose", "ruby", "ruth",
+      "sandra", "sara", "sarah", "sharon", "shirley", "stephanie", "susan",
+      "tammy", "teresa", "theresa", "tina", "virginia", "wanda"
+    ]
+
+
+    # Generates a random character.
+    def self.rand_char(bad, chars = AllChars)
+      rand_text(1, bad, chars)
+    end
+
+    # Base text generator method
+    def self.rand_base(len, bad, *foo)
+      cset = (foo.join.unpack("C*") - bad.to_s.unpack("C*")).uniq
+      return "" if cset.length == 0
+      outp = []
+      len.times { outp << cset[rand(cset.length)] }
+      outp.pack("C*")
+    end
+
+    # Generate random bytes of data
+    def self.rand_text(len, bad='', chars = AllChars)
+      foo = chars.split('')
+      rand_base(len, bad, *foo)
+    end
+
+    # Generate random bytes of alpha data
+    def self.rand_text_alpha(len, bad='')
+      foo = []
+      foo += ('A' .. 'Z').to_a
+      foo += ('a' .. 'z').to_a
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of lowercase alpha data
+    def self.rand_text_alpha_lower(len, bad='')
+      rand_base(len, bad, *('a' .. 'z').to_a)
+    end
+
+    # Generate random bytes of uppercase alpha data
+    def self.rand_text_alpha_upper(len, bad='')
+      rand_base(len, bad, *('A' .. 'Z').to_a)
+    end
+
+    # Generate random bytes of alphanumeric data
+    def self.rand_text_alphanumeric(len, bad='')
+      foo = []
+      foo += ('A' .. 'Z').to_a
+      foo += ('a' .. 'z').to_a
+      foo += ('0' .. '9').to_a
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of alphanumeric hex.
+    def self.rand_text_hex(len, bad='')
+      foo = []
+      foo += ('0' .. '9').to_a
+      foo += ('a' .. 'f').to_a
+      rand_base(len, bad, *foo)
+    end
+
+    # Generate random bytes of numeric data
+    def self.rand_text_numeric(len, bad='')
+      foo = ('0' .. '9').to_a
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of english-like data
+    def self.rand_text_english(len, bad='')
+      foo = []
+      foo += (0x21 .. 0x7e).map{ |c| c.chr }
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of high ascii data
+    def self.rand_text_highascii(len, bad='')
+      foo = []
+      foo += (0x80 .. 0xff).map{ |c| c.chr }
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of base64 data
+    def self.rand_text_base64(len, bad='')
+      foo = Base64.unpack('C*').map{ |c| c.chr }
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate random bytes of base64url data
+    def self.rand_text_base64url(len, bad='')
+      foo = Base64Url.unpack('C*').map{ |c| c.chr }
+      rand_base(len, bad, *foo )
+    end
+
+    # Generate a random GUID
+    #
+    # @example
+    #   Rex::Text.rand_guid # => "{ca776ced-4ab8-2ed6-6510-aa71e5e2508e}"
+    #
+    # @return [String]
+    def self.rand_guid
+      "{#{[8,4,4,4,12].map {|a| rand_text_hex(a) }.join("-")}}"
+    end
+
+    #
+    # Generate a valid random 4 byte UTF-8 character
+    # valid codepoints for 4byte UTF-8 chars: U+010000 - U+10FFFF
+    #
+    # @example
+    #   Rex::Text.rand_4byte_utf8 # => "\u{108CF3}"
+    #
+    # @return [String]
+    def self.rand_4byte_utf8
+      [rand(0x10000..0x10ffff)].pack('U*')
+    end
+
+    # Generate a random hostname
+    #
+    # @return [String] A random string conforming to the rules of FQDNs
+    def self.rand_hostname
+      host = []
+      (rand(5) + 1).times {
+        host.push(Rex::Text.rand_text_alphanumeric(rand(10) + 1))
+      }
+      host.push(TLDs.sample)
+      host.join('.').downcase
+    end
+
+    # Generate a state
+    def self.rand_state()
+      States.sample
+    end
+
+    # Generate a surname
+    def self.rand_surname
+      Surnames.sample
+    end
+
+    # Generate a name
+    def self.rand_name
+      if rand(10) % 2 == 0
+        Names_Male.sample
+      else
+        Names_Female.sample
+      end
+    end
+
+    # Generate a male name
+    def self.rand_name_male
+      Names_Male.sample
+    end
+
+    # Generate a female name
+    def self.rand_name_female
+      Names_Female.sample
+    end
+
+    # Generate a random mail address
+    def self.rand_mail_address
+      mail_address = ''
+      mail_address << Rex::Text.rand_name
+      mail_address << '.'
+      mail_address << Rex::Text.rand_surname
+      mail_address << '@'
+      mail_address << Rex::Text.rand_hostname
+    end
+  end
+end