rex-text 0.1.0

data/lib/rex/text/ebcdic.rb

@@ -0,0 +1,219 @@
+# -*- 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.
+
+
+    # The Iconv translation table for IBM's mainframe / System Z
+    # (z/os, s390, mvs, etc) - This is a different implementation
+    # of EBCDIC than the Iconv_EBCDIC below.
+    # It is technically referred to as Code Page IBM1047.
+    # This will be net new (until Ruby supports 1047 code page)
+    # for all Mainframe / SystemZ based modules
+    # that need to convert ASCII to EBCDIC
+    #
+    # The bytes are indexed by ASCII conversion number
+    # e.g.  Iconv_IBM1047[0x41] == \xc1 for letter "A"
+    #
+    # Note the characters CANNOT be assumed to be in any logical
+    # order. Nor are the tables reversible.  Lookups must be for each byte
+    # https://gist.github.com/bigendiansmalls/b08483ecedff52cc8fa3
+    #
+    Iconv_IBM1047 = [
+      "\x00","\x01","\x02","\x03","\x37","\x2d","\x2e","\x2f",
+      "\x16","\x05","\x15","\x0b","\x0c","\x0d","\x0e","\x0f","\x10",
+      "\x11","\x12","\x13","\x3c","\x3d","\x32","\x26","\x18","\x19",
+      "\x3f","\x27","\x1c","\x1d","\x1e","\x1f","\x40","\x5a","\x7f",
+      "\x7b","\x5b","\x6c","\x50","\x7d","\x4d","\x5d","\x5c","\x4e",
+      "\x6b","\x60","\x4b","\x61","\xf0","\xf1","\xf2","\xf3","\xf4",
+      "\xf5","\xf6","\xf7","\xf8","\xf9","\x7a","\x5e","\x4c","\x7e",
+      "\x6e","\x6f","\x7c","\xc1","\xc2","\xc3","\xc4","\xc5","\xc6",
+      "\xc7","\xc8","\xc9","\xd1","\xd2","\xd3","\xd4","\xd5","\xd6",
+      "\xd7","\xd8","\xd9","\xe2","\xe3","\xe4","\xe5","\xe6","\xe7",
+      "\xe8","\xe9","\xad","\xe0","\xbd","\x5f","\x6d","\x79","\x81",
+      "\x82","\x83","\x84","\x85","\x86","\x87","\x88","\x89","\x91",
+      "\x92","\x93","\x94","\x95","\x96","\x97","\x98","\x99","\xa2",
+      "\xa3","\xa4","\xa5","\xa6","\xa7","\xa8","\xa9","\xc0","\x4f",
+      "\xd0","\xa1","\x07","\x20","\x21","\x22","\x23","\x24","\x25",
+      "\x06","\x17","\x28","\x29","\x2a","\x2b","\x2c","\x09","\x0a",
+      "\x1b","\x30","\x31","\x1a","\x33","\x34","\x35","\x36","\x08",
+      "\x38","\x39","\x3a","\x3b","\x04","\x14","\x3e","\xff","\x41",
+      "\xaa","\x4a","\xb1","\x9f","\xb2","\x6a","\xb5","\xbb","\xb4",
+      "\x9a","\x8a","\xb0","\xca","\xaf","\xbc","\x90","\x8f","\xea",
+      "\xfa","\xbe","\xa0","\xb6","\xb3","\x9d","\xda","\x9b","\x8b",
+      "\xb7","\xb8","\xb9","\xab","\x64","\x65","\x62","\x66","\x63",
+      "\x67","\x9e","\x68","\x74","\x71","\x72","\x73","\x78","\x75",
+      "\x76","\x77","\xac","\x69","\xed","\xee","\xeb","\xef","\xec",
+      "\xbf","\x80","\xfd","\xfe","\xfb","\xfc","\xba","\xae","\x59",
+      "\x44","\x45","\x42","\x46","\x43","\x47","\x9c","\x48","\x54",
+      "\x51","\x52","\x53","\x58","\x55","\x56","\x57","\x8c","\x49",
+      "\xcd","\xce","\xcb","\xcf","\xcc","\xe1","\x70","\xdd","\xde",
+      "\xdb","\xdc","\x8d","\x8e","\xdf"
+    ]
+
+    #
+    # This is the reverse of the above, converts EBCDIC -> ASCII
+    # The bytes are indexed by IBM1047(EBCDIC) conversion number
+    # e.g. Iconv_ISO8859_1[0xc1] = \x41 for letter "A"
+    #
+    # Note the characters CANNOT be assumed to be in any logical (e.g. sequential)
+    # order. Nor are the tables reversible.  Lookups must be done byte by byte
+    #
+    Iconv_ISO8859_1 = [
+      "\x00","\x01","\x02","\x03","\x9c","\x09","\x86","\x7f",
+      "\x97","\x8d","\x8e","\x0b","\x0c","\x0d","\x0e","\x0f","\x10",
+      "\x11","\x12","\x13","\x9d","\x0a","\x08","\x87","\x18","\x19",
+      "\x92","\x8f","\x1c","\x1d","\x1e","\x1f","\x80","\x81","\x82",
+      "\x83","\x84","\x85","\x17","\x1b","\x88","\x89","\x8a","\x8b",
+      "\x8c","\x05","\x06","\x07","\x90","\x91","\x16","\x93","\x94",
+      "\x95","\x96","\x04","\x98","\x99","\x9a","\x9b","\x14","\x15",
+      "\x9e","\x1a","\x20","\xa0","\xe2","\xe4","\xe0","\xe1","\xe3",
+      "\xe5","\xe7","\xf1","\xa2","\x2e","\x3c","\x28","\x2b","\x7c",
+      "\x26","\xe9","\xea","\xeb","\xe8","\xed","\xee","\xef","\xec",
+      "\xdf","\x21","\x24","\x2a","\x29","\x3b","\x5e","\x2d","\x2f",
+      "\xc2","\xc4","\xc0","\xc1","\xc3","\xc5","\xc7","\xd1","\xa6",
+      "\x2c","\x25","\x5f","\x3e","\x3f","\xf8","\xc9","\xca","\xcb",
+      "\xc8","\xcd","\xce","\xcf","\xcc","\x60","\x3a","\x23","\x40",
+      "\x27","\x3d","\x22","\xd8","\x61","\x62","\x63","\x64","\x65",
+      "\x66","\x67","\x68","\x69","\xab","\xbb","\xf0","\xfd","\xfe",
+      "\xb1","\xb0","\x6a","\x6b","\x6c","\x6d","\x6e","\x6f","\x70",
+      "\x71","\x72","\xaa","\xba","\xe6","\xb8","\xc6","\xa4","\xb5",
+      "\x7e","\x73","\x74","\x75","\x76","\x77","\x78","\x79","\x7a",
+      "\xa1","\xbf","\xd0","\x5b","\xde","\xae","\xac","\xa3","\xa5",
+      "\xb7","\xa9","\xa7","\xb6","\xbc","\xbd","\xbe","\xdd","\xa8",
+      "\xaf","\x5d","\xb4","\xd7","\x7b","\x41","\x42","\x43","\x44",
+      "\x45","\x46","\x47","\x48","\x49","\xad","\xf4","\xf6","\xf2",
+      "\xf3","\xf5","\x7d","\x4a","\x4b","\x4c","\x4d","\x4e","\x4f",
+      "\x50","\x51","\x52","\xb9","\xfb","\xfc","\xf9","\xfa","\xff",
+      "\x5c","\xf7","\x53","\x54","\x55","\x56","\x57","\x58","\x59",
+      "\x5a","\xb2","\xd4","\xd6","\xd2","\xd3","\xd5","\x30","\x31",
+      "\x32","\x33","\x34","\x35","\x36","\x37","\x38","\x39","\xb3",
+      "\xdb","\xdc","\xd9","\xda","\x9f"
+    ]
+
+    # The Iconv translation table. The Iconv gem is deprecated in favor of
+    # String#encode, yet there is no encoding for EBCDIC. See #4525
+    Iconv_EBCDIC = [
+      "\x00", "\x01", "\x02", "\x03", "7", "-", ".", "/", "\x16", "\x05",
+      "%", "\v", "\f", "\r", "\x0E", "\x0F", "\x10", "\x11", "\x12", "\x13",
+      "<", "=", "2", "&", "\x18", "\x19", "?", "'", "\x1C", "\x1D", "\x1E",
+      "\x1F", "@", "Z", "\x7F", "{", "[", "l", "P", "}", "M", "]", "\\",
+      "N", "k", "`", "K", "a", "\xF0", "\xF1", "\xF2", "\xF3", "\xF4",
+      "\xF5", "\xF6", "\xF7", "\xF8", "\xF9", "z", "^", "L", "~", "n", "o",
+      "|", "\xC1", "\xC2", "\xC3", "\xC4", "\xC5", "\xC6", "\xC7", "\xC8",
+      "\xC9", "\xD1", "\xD2", "\xD3", "\xD4", "\xD5", "\xD6", "\xD7",
+      "\xD8", "\xD9", "\xE2", "\xE3", "\xE4", "\xE5", "\xE6", "\xE7",
+      "\xE8", "\xE9", nil, "\xE0", nil, nil, "m", "y", "\x81", "\x82",
+      "\x83", "\x84", "\x85", "\x86", "\x87", "\x88", "\x89", "\x91",
+      "\x92", "\x93", "\x94", "\x95", "\x96", "\x97", "\x98", "\x99",
+      "\xA2", "\xA3", "\xA4", "\xA5", "\xA6", "\xA7", "\xA8", "\xA9",
+      "\xC0", "O", "\xD0", "\xA1", "\a", nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil
+    ]
+
+    Iconv_ASCII  = [
+      "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06", "\a", "\b",
+      "\t", "\n", "\v", "\f", "\r", "\x0E", "\x0F", "\x10", "\x11", "\x12",
+      "\x13", "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1A", "\e",
+      "\x1C", "\x1D", "\x1E", "\x1F", " ", "!", "\"", "#", "$", "%", "&",
+      "'", "(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4",
+      "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?", "@", "A", "B",
+      "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P",
+      "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", nil, "\\", nil,
+      nil, "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k",
+      "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y",
+      "z", "{", "|", "}", "~", "\x7F", nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+      nil, nil, nil, nil, nil, nil, nil, nil, nil
+    ]
+
+    # A native implementation of the ASCII to EBCDIC conversion table, since
+    # EBCDIC isn't available to String#encode as of Ruby 2.1
+    #
+    # @param str [String] An encodable ASCII string
+    # @return [String] an EBCDIC encoded string
+    # @note This method will raise in the event of invalid characters
+    def self.to_ebcdic(str)
+      new_str = []
+      str.each_byte do |x|
+        if Iconv_ASCII.index(x.chr)
+          new_str << Iconv_EBCDIC[Iconv_ASCII.index(x.chr)]
+        else
+          raise Rex::Text::IllegalSequence, ("\\x%x" % x)
+        end
+      end
+      new_str.join
+    end
+
+    # A native implementation of the EBCDIC to ASCII conversion table, since
+    # EBCDIC isn't available to String#encode as of Ruby 2.1
+    #
+    # @param str [String] an EBCDIC encoded string
+    # @return [String] An encodable ASCII string
+    # @note This method will raise in the event of invalid characters
+    def self.from_ebcdic(str)
+      new_str = []
+      str.each_byte do |x|
+        if Iconv_EBCDIC.index(x.chr)
+          new_str << Iconv_ASCII[Iconv_EBCDIC.index(x.chr)]
+        else
+          raise Rex::Text::IllegalSequence, ("\\x%x" % x)
+        end
+      end
+      new_str.join
+    end
+
+    #
+    # The next two are the same as the above, except strictly for z/os
+    # conversions
+    #  strictly for IBM1047 -> ISO8859-1
+    # A native implementation of the IBM1047(EBCDIC) -> ISO8859-1(ASCII)
+    # conversion table, since EBCDIC isn't available to String#encode as of Ruby 2.1
+    # all 256 bytes are defined
+    #
+    def self.to_ibm1047(str)
+      return str if str.nil?
+      new_str = []
+      str.each_byte do |x|
+        new_str << Iconv_IBM1047[x.ord]
+      end
+      new_str.join
+    end
+
+    #
+    # The next two are the same as the above, except strictly for z/os
+    # conversions
+    #  strictly for ISO8859-1 -> IBM1047
+    # A native implementation of the ISO8859-1(ASCII) -> IBM1047(EBCDIC)
+    # conversion table, since EBCDIC isn't available to String#encode as of Ruby 2.1
+    #
+    def self.from_ibm1047(str)
+      return str if str.nil?
+      new_str = []
+      str.each_byte do |x|
+        new_str << Iconv_ISO8859_1[x.ord]
+      end
+      new_str.join
+    end
+
+  end
+end

data/lib/rex/text/encode.rb

@@ -0,0 +1,104 @@
+# -*- 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.
+
+
+
+    #
+    # Encode a string in a manor useful for HTTP URIs and URI Parameters.
+    #
+    def self.uri_encode(str, mode = 'hex-normal')
+      return "" if str == nil
+
+      return str if mode == 'none' # fast track no encoding
+
+      all = /./
+      noslashes = /[^\/\\]+/
+      # http://tools.ietf.org/html/rfc3986#section-2.3
+      normal = /[^a-zA-Z0-9\/\\\.\-_~]+/
+
+      case mode
+        when 'hex-all'
+          return str.gsub(all) { |s| Rex::Text.to_hex(s, '%') }
+        when 'hex-normal'
+          return str.gsub(normal) { |s| Rex::Text.to_hex(s, '%') }
+        when 'hex-noslashes'
+          return str.gsub(noslashes) { |s| Rex::Text.to_hex(s, '%') }
+        when 'hex-random'
+          res = ''
+          str.each_byte do |c|
+            b = c.chr
+            res << ((rand(2) == 0) ?
+              b.gsub(all)   { |s| Rex::Text.to_hex(s, '%') } :
+              b.gsub(normal){ |s| Rex::Text.to_hex(s, '%') } )
+          end
+          return res
+        when 'u-all'
+          return str.gsub(all) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) }
+        when 'u-normal'
+          return str.gsub(normal) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) }
+        when 'u-noslashes'
+          return str.gsub(noslashes) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) }
+        when 'u-random'
+          res = ''
+          str.each_byte do |c|
+            b = c.chr
+            res << ((rand(2) == 0) ?
+              b.gsub(all)   { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } :
+              b.gsub(normal){ |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms'), '%u', 2) } )
+          end
+          return res
+        when 'u-half'
+          return str.gsub(all) { |s| Rex::Text.to_hex(Rex::Text.to_unicode(s, 'uhwtfms-half'), '%u', 2) }
+        else
+          raise TypeError, "invalid mode #{mode.inspect}"
+      end
+    end
+
+    #
+    # Encode a string in a manner useful for HTTP URIs and URI Parameters.
+    #
+    # @param str [String] The string to be encoded
+    # @param mode ["hex","int","int-wide"]
+    # @return [String]
+    # @raise [TypeError] if +mode+ is not one of the three available modes
+    def self.html_encode(str, mode = 'hex')
+      case mode
+        when 'hex'
+          return str.unpack('C*').collect{ |i| "&#x" + ("%.2x" % i) + ";"}.join
+        when 'int'
+          return str.unpack('C*').collect{ |i| "&#" + i.to_s + ";"}.join
+        when 'int-wide'
+          return str.unpack('C*').collect{ |i| "&#" + ("0" * (7 - i.to_s.length)) + i.to_s + ";" }.join
+        else
+          raise TypeError, 'invalid mode'
+      end
+    end
+
+    #
+    # Decode a string that's html encoded
+    #
+    def self.html_decode(str)
+      decoded_str = CGI.unescapeHTML(str)
+      return decoded_str
+    end
+
+    #
+    # Encode an ASCII string so it's safe for XML. It's a wrapper for to_hex_ascii.
+    #
+    def self.xml_char_encode(str)
+      self.to_hex_ascii(str, "&#x", 1, ";")
+    end
+
+    #
+    # Decode a URI encoded string
+    #
+    def self.uri_decode(str)
+      str.gsub(/(%[a-z0-9]{2})/i){ |c| [c[1,2]].pack("H*") }
+    end
+  end
+end

data/lib/rex/text/hash.rb

@@ -0,0 +1,37 @@
+# -*- 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.
+
+    #
+    # Raw MD5 digest of the supplied string
+    #
+    def self.md5_raw(str)
+      Digest::MD5.digest(str)
+    end
+
+    #
+    # Hexidecimal MD5 digest of the supplied string
+    #
+    def self.md5(str)
+      Digest::MD5.hexdigest(str)
+    end
+
+    #
+    # Raw SHA1 digest of the supplied string
+    #
+    def self.sha1_raw(str)
+      Digest::SHA1.digest(str)
+    end
+
+    #
+    # Hexidecimal SHA1 digest of the supplied string
+    #
+    def self.sha1(str)
+      Digest::SHA1.hexdigest(str)
+    end
+  end
+end

data/lib/rex/text/hex.rb

@@ -0,0 +1,204 @@
+# -*- 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.
+
+    #
+    # Returns the escaped hex version of the supplied string
+    #
+    # @example
+    #   Rex::Text.to_hex("asdf") # => "\\x61\\x73\\x64\\x66"
+    #
+    # @param str (see to_octal)
+    # @param prefix (see to_octal)
+    # @param count [Fixnum] Number of bytes to put in each escape chunk
+    # @return [String] The escaped hex version of +str+
+    def self.to_hex(str, prefix = "\\x", count = 1)
+      raise ::RuntimeError, "unable to chunk into #{count} byte chunks" if ((str.length % count) > 0)
+
+      # XXX: Regexp.new is used here since using /.{#{count}}/o would compile
+      # the regex the first time it is used and never check again.  Since we
+      # want to know how many to capture on every instance, we do it this
+      # way.
+      return str.unpack('H*')[0].gsub(Regexp.new(".{#{count * 2}}", nil, 'n')) { |s| prefix + s }
+    end
+
+    #
+    # Returns the string with nonprintable hex characters sanitized to ascii.
+    # Similiar to {.to_hex}, but regular ASCII is not translated if +count+ is 1.
+    #
+    # @example
+    #   Rex::Text.to_hex_ascii("\x7fABC\0") # => "\\x7fABC\\x00"
+    #
+    # @param str (see to_hex)
+    # @param prefix (see to_hex)
+    # @param count (see to_hex)
+    # @param suffix [String,nil] A string to append to the converted bytes
+    # @return [String] The original string with non-printables converted to
+    #   their escaped hex representation
+    def self.to_hex_ascii(str, prefix = "\\x", count = 1, suffix=nil)
+      raise ::RuntimeError, "unable to chunk into #{count} byte chunks" if ((str.length % count) > 0)
+      return str.unpack('H*')[0].gsub(Regexp.new(".{#{count * 2}}", nil, 'n')) { |s|
+        (0x20..0x7e) === s.to_i(16) ? s.to_i(16).chr : prefix + s + suffix.to_s
+      }
+    end
+
+    #
+    # Converts a string to a nicely formatted hex dump
+    #
+    # @param str [String] The string to convert
+    # @param width [Fixnum] Number of bytes to convert before adding a newline
+    # @param base [Fixnum] The base address of the dump
+    def self.to_hex_dump(str, width=16, base=nil)
+      buf = ''
+      idx = 0
+      cnt = 0
+      snl = false
+      lst = 0
+      lft_col_len = (base.to_i+str.length).to_s(16).length
+      lft_col_len = 8 if lft_col_len < 8
+
+      while (idx < str.length)
+        chunk = str[idx, width]
+        addr = base ? "%0#{lft_col_len}x  " %(base.to_i + idx) : ''
+        line  = chunk.unpack("H*")[0].scan(/../).join(" ")
+        buf << addr + line
+
+        if (lst == 0)
+          lst = line.length
+          buf << " " * 4
+        else
+          buf << " " * ((lst - line.length) + 4).abs
+        end
+
+        buf << "|"
+
+        chunk.unpack("C*").each do |c|
+          if (c >	0x1f and c < 0x7f)
+            buf << c.chr
+          else
+            buf << "."
+          end
+        end
+
+        buf << "|\n"
+
+        idx += width
+      end
+
+      buf << "\n"
+    end
+
+    #
+    # Converts a hex string to a raw string
+    #
+    # @example
+    #   Rex::Text.hex_to_raw("\\x41\\x7f\\x42") # => "A\x7fB"
+    #
+    def self.hex_to_raw(str)
+      [ str.downcase.gsub(/'/,'').gsub(/\\?x([a-f0-9][a-f0-9])/, '\1') ].pack("H*")
+    end
+
+    #
+    # Turn non-printable chars into hex representations, leaving others alone
+    #
+    # If +whitespace+ is true, converts whitespace (0x20, 0x09, etc) to hex as
+    # well.
+    #
+    # @see hexify
+    # @see to_hex Converts all the chars
+    #
+    def self.ascii_safe_hex(str, whitespace=false)
+      if whitespace
+        str.gsub(/([\x00-\x20\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0] }
+      else
+        str.gsub(/([\x00-\x08\x0b\x0c\x0e-\x1f\x80-\xFF])/n){ |x| "\\x%.2x" % x.unpack("C*")[0]}
+      end
+    end
+
+    #
+    # Converts a string to a hex version with wrapping support
+    #
+    def self.hexify(str, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '')
+      output	 = buf_start
+      cur	 = 0
+      count	 = 0
+      new_line = true
+
+      # Go through each byte in the string
+      str.each_byte { |byte|
+        count  += 1
+        append	= ''
+
+        # If this is a new line, prepend with the
+        # line start text
+        if (new_line == true)
+          append	 << line_start
+          new_line  = false
+        end
+
+        # Append the hexified version of the byte
+        append << sprintf("\\x%.2x", byte)
+        cur    += append.length
+
+        # If we're about to hit the column or have gone past it,
+        # time to finish up this line
+        if ((cur + line_end.length >= col) or (cur + buf_end.length  >= col))
+          new_line  = true
+          cur	  = 0
+
+          # If this is the last byte, use the buf_end instead of
+          # line_end
+          if (count == str.length)
+            append << buf_end + "\n"
+          else
+            append << line_end + "\n"
+          end
+        end
+
+        output << append
+      }
+
+      # If we were in the middle of a line, finish the buffer at this point
+      if (new_line == false)
+        output << buf_end + "\n"
+      end
+
+      return output
+    end
+
+    #
+    # Convert hex-encoded characters to literals.
+    #
+    # @example
+    #   Rex::Text.dehex("AA\\x42CC") # => "AABCC"
+    #
+    # @see hex_to_raw
+    # @param str [String]
+    def self.dehex(str)
+      return str unless str.respond_to? :match
+      return str unless str.respond_to? :gsub
+      regex = /\x5cx[0-9a-f]{2}/nmi
+      if str.match(regex)
+        str.gsub(regex) { |x| x[2,2].to_i(16).chr }
+      else
+        str
+      end
+    end
+
+    #
+    # Convert and replace hex-encoded characters to literals.
+    #
+    # @param (see dehex)
+    def self.dehex!(str)
+      return str unless str.respond_to? :match
+      return str unless str.respond_to? :gsub
+      regex = /\x5cx[0-9a-f]{2}/nmi
+      str.gsub!(regex) { |x| x[2,2].to_i(16).chr }
+    end
+
+  end
+end