rex-text 0.1.0

data/lib/rex/text/badchars.rb

@@ -0,0 +1,50 @@
+# -*- 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.
+
+    #
+    # Return the index of the first badchar in +data+, otherwise return
+    # nil if there wasn't any badchar occurences.
+    #
+    # @param data [String] The string to check for bad characters
+    # @param badchars [String] A list of characters considered to be bad
+    # @return [Fixnum] Index of the first bad character if any exist in +data+
+    # @return [nil] If +data+ contains no bad characters
+    def self.badchar_index(data, badchars = '')
+      badchars.unpack("C*").each { |badchar|
+        pos = data.index(badchar.chr)
+        return pos if pos
+      }
+      return nil
+    end
+
+    #
+    # Removes bad characters from a string.
+    #
+    # Modifies +data+ in place
+    #
+    # @param data [#delete]
+    # @param badchars [String] A list of characters considered to be bad
+    def self.remove_badchars(data, badchars = '')
+      return data if badchars.length == 0
+      badchars_pat = badchars.unpack("C*").map{|c| "\\x%.2x" % c}.join
+      data.gsub!(/[#{badchars_pat}]/n, '')
+      data
+    end
+
+    #
+    # Returns all chars that are not in the supplied set
+    #
+    # @param keepers [String]
+    # @return [String] All characters not contained in +keepers+
+    def self.charset_exclude(keepers)
+      excluded_bytes = [*(0..255)] - keepers.unpack("C*")
+      excluded_bytes.pack("C*")
+    end
+
+  end
+end

data/lib/rex/text/base32.rb

@@ -0,0 +1,87 @@
+# -*- 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.
+
+    #
+    # Base32 code
+    #
+
+    # Based on --> https://github.com/stesla/base32
+
+    # Copyright (c) 2007-2011 Samuel Tesla
+
+    # Permission is hereby granted, free of charge, to any person obtaining a copy
+    # of this software and associated documentation files (the "Software"), to deal
+    # in the Software without restriction, including without limitation the rights
+    # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    # copies of the Software, and to permit persons to whom the Software is
+    # furnished to do so, subject to the following conditions:
+
+    # The above copyright notice and this permission notice shall be included in
+    # all copies or substantial portions of the Software.
+
+    # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    # THE SOFTWARE.
+
+
+    #
+    # Base32 encoder
+    #
+    def self.b32encode(bytes_in)
+      n = (bytes_in.length * 8.0 / 5.0).ceil
+      p = n < 8 ? 5 - (bytes_in.length * 8) % 5 : 0
+      c = bytes_in.inject(0) {|m,o| (m << 8) + o} << p
+      [(0..n-1).to_a.reverse.collect {|i| Base32[(c >> i * 5) & 0x1f].chr},
+       ("=" * (8-n))]
+    end
+
+    def self.encode_base32(str)
+      bytes = str.bytes
+      result = ''
+      size= 5
+      while bytes.any? do
+        bytes.each_slice(size) do |a|
+          bytes_out = b32encode(a).flatten.join
+          result << bytes_out
+          bytes = bytes.drop(size)
+        end
+      end
+      return result
+    end
+
+    #
+    # Base32 decoder
+    #
+    def self.b32decode(bytes_in)
+      bytes = bytes_in.take_while {|c| c != 61} # strip padding
+      n = (bytes.length * 5.0 / 8.0).floor
+      p = bytes.length < 8 ? 5 - (n * 8) % 5 : 0
+      c = bytes.inject(0) {|m,o| (m << 5) + Base32.index(o.chr)} >> p
+      (0..n-1).to_a.reverse.collect {|i| ((c >> i * 8) & 0xff).chr}
+    end
+
+    def self.decode_base32(str)
+      bytes = str.bytes
+      result = ''
+      size= 8
+      while bytes.any? do
+        bytes.each_slice(size) do |a|
+          bytes_out = b32decode(a).flatten.join
+          result << bytes_out
+          bytes = bytes.drop(size)
+        end
+      end
+      return result
+    end
+
+  end
+end

data/lib/rex/text/base64.rb

@@ -0,0 +1,42 @@
+# -*- 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.
+
+
+    #
+    # Base64 encoder
+    #
+    def self.encode_base64(str, delim='')
+      [str.to_s].pack("m").gsub(/\s+/, delim)
+    end
+
+    #
+    # Base64 decoder
+    #
+    def self.decode_base64(str)
+      str.to_s.unpack("m")[0]
+    end
+
+    #
+    # Base64 encoder (URL-safe RFC6920)
+    #
+    def self.encode_base64url(str, delim='')
+      encode_base64(str, delim).
+        tr('+/', '-_').
+        gsub('=', '')
+    end
+
+    #
+    # Base64 decoder (URL-safe RFC6920, ignores invalid characters)
+    #
+    def self.decode_base64url(str)
+      decode_base64(
+        str.gsub(/[^a-zA-Z0-9_\-]/, '').
+          tr('-_', '+/'))
+    end
+  end
+end

data/lib/rex/text/binary_manipulation.rb

@@ -0,0 +1,117 @@
+# -*- 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 comma separated list of numbers
+    #
+    def self.to_num(str, wrap = DefaultWrap)
+      code = str.unpack('C*')
+      buff = ""
+      0.upto(code.length-1) do |byte|
+        if(byte % 15 == 0) and (buff.length > 0)
+          buff << "\r\n"
+        end
+        buff << sprintf('0x%.2x, ', code[byte])
+      end
+      # strip , at the end
+      buff = buff.chomp(', ')
+      buff << "\r\n"
+      return buff
+    end
+
+    #
+    # Creates a comma separated list of dwords
+    #
+    def self.to_dword(str, wrap = DefaultWrap)
+      code = str
+      alignnr = str.length % 4
+      if (alignnr > 0)
+        code << "\x00" * (4 - alignnr)
+      end
+      codevalues = Array.new
+      code.split("").each_slice(4) do |chars4|
+        chars4 = chars4.join("")
+        dwordvalue = chars4.unpack('*V')
+        codevalues.push(dwordvalue[0])
+      end
+      buff = ""
+      0.upto(codevalues.length-1) do |byte|
+        if(byte % 8 == 0) and (buff.length > 0)
+          buff << "\r\n"
+        end
+        buff << sprintf('0x%.8x, ', codevalues[byte])
+      end
+      # strip , at the end
+      buff = buff.chomp(', ')
+      buff << "\r\n"
+      return buff
+    end
+
+    #
+    # Returns the words in +str+ as an Array.
+    #
+    # strict - include *only* words, no boundary characters (like spaces, etc.)
+    #
+    def self.to_words( str, strict = false )
+      splits = str.split( /\b/ )
+      splits.reject! { |w| !(w =~ /\w/) } if strict
+      splits
+    end
+
+    #
+    # Pack a value as 64 bit litle endian; does not exist for Array.pack
+    #
+    def self.pack_int64le(val)
+      [val & 0x00000000ffffffff, val >> 32].pack("V2")
+    end
+
+    #
+    # Rotate a 32-bit value to the right by +cnt+ bits
+    #
+    # @param val [Fixnum] The value to rotate
+    # @param cnt [Fixnum] Number of bits to rotate by
+    def self.ror(val, cnt)
+      bits = [val].pack("N").unpack("B32")[0].split(//)
+      1.upto(cnt) do |c|
+        bits.unshift( bits.pop )
+      end
+      [bits.join].pack("B32").unpack("N")[0]
+    end
+
+    #
+    # Rotate a 32-bit value to the left by +cnt+ bits
+    #
+    # @param val (see ror)
+    # @param cnt (see ror)
+    # @return (see ror)
+    def self.rol(val, cnt)
+      bits = [val].pack("N").unpack("B32")[0].split(//)
+      1.upto(cnt) do |c|
+        bits.push( bits.shift )
+      end
+      [bits.join].pack("B32").unpack("N")[0]
+    end
+
+    #
+    # Removes noise from 2 Strings and return a refined String version.
+    #
+    def self.refine( str1, str2 )
+      return str1 if str1 == str2
+
+      # get the words of the first str in an array
+      s_words = to_words( str1 )
+
+      # get the words of the second str in an array
+      o_words = to_words( str2 )
+
+      # get what hasn't changed (the rdiff, so to speak) as a string
+      (s_words - (s_words - o_words)).join
+    end
+
+  end
+end

data/lib/rex/text/block_api.rb

@@ -0,0 +1,33 @@
+# -*- 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.
+
+    #
+    # Calculate the block API hash for the given module/function
+    #
+    # @param mod [String] The name of the module containing the target function.
+    # @param fun [String] The name of the function.
+    #
+    # @return [String] The hash of the mod/fun pair in string format
+    def self.block_api_hash(mod, fun)
+      unicode_mod = (mod.upcase + "\x00").unpack('C*').pack('v*')
+      mod_hash = self.ror13_hash(unicode_mod)
+      fun_hash = self.ror13_hash(fun + "\x00")
+      "0x#{(mod_hash + fun_hash & 0xFFFFFFFF).to_s(16)}"
+    end
+
+    #
+    # Calculate the ROR13 hash of a given string
+    #
+    # @return [Fixnum]
+    def self.ror13_hash(name)
+      hash = 0
+      name.unpack("C*").each {|c| hash = ror(hash, 13); hash += c }
+      hash
+    end
+  end
+end

data/lib/rex/text/checksum.rb

@@ -0,0 +1,39 @@
+# -*- 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.
+
+    # @param str [String] Data to checksum
+    # @return [Fixnum] 8-bit checksum
+    def self.checksum8(str)
+      (str.unpack("C*").inject(:+) || 0) % 0x100
+    end
+
+    # @param str [String] Little-endian data to checksum
+    # @return [Fixnum] 16-bit checksum
+    def self.checksum16_le(str)
+      (str.unpack("v*").inject(:+) || 0) % 0x10000
+    end
+
+    # @param str [String] Big-endian data to checksum
+    # @return [Fixnum] 16-bit checksum
+    def self.checksum16_be(str)
+      (str.unpack("n*").inject(:+) || 0) % 0x10000
+    end
+
+    # @param str [String] Little-endian data to checksum
+    # @return [Fixnum] 32-bit checksum
+    def self.checksum32_le(str)
+      (str.unpack("V*").inject(:+) || 0) % 0x100000000
+    end
+
+    # @param str [String] Big-endian data to checksum
+    # @return [Fixnum] 32-bit checksum
+    def self.checksum32_be(str)
+      (str.unpack("N*").inject(:+) || 0) % 0x100000000
+    end
+  end
+end

data/lib/rex/text/compress.rb

@@ -0,0 +1,105 @@
+# -*- 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.
+
+    #
+    # Compresses a string, eliminating all superfluous whitespace before and
+    # after lines and eliminating all lines.
+    #
+    # @param str [String] The string in which to crunch whitespace
+    # @return [String] Just like +str+, but with repeated whitespace characters
+    #   trimmed down to a single space
+    def self.compress(str)
+      str.gsub(/\n/m, ' ').gsub(/\s+/, ' ').gsub(/^\s+/, '').gsub(/\s+$/, '')
+    end
+
+
+
+    # Returns true if zlib can be used.
+    def self.zlib_present?
+      begin
+        temp = Zlib
+        return true
+      rescue
+        return false
+      end
+    end
+
+    # backwards compat for just a bit...
+    def self.gzip_present?
+      self.zlib_present?
+    end
+
+    #
+    # Compresses a string using zlib
+    #
+    # @param str [String] The string to be compressed
+    # @param level [Fixnum] One of the Zlib compression level constants
+    # @return [String] The compressed version of +str+
+    def self.zlib_deflate(str, level = Zlib::BEST_COMPRESSION)
+      if self.zlib_present?
+        z = Zlib::Deflate.new(level)
+        dst = z.deflate(str, Zlib::FINISH)
+        z.close
+        return dst
+      else
+        raise RuntimeError, "Gzip support is not present."
+      end
+    end
+
+    #
+    # Uncompresses a string using zlib
+    #
+    # @param str [String] Compressed string to inflate
+    # @return [String] The uncompressed version of +str+
+    def self.zlib_inflate(str)
+      if(self.zlib_present?)
+        zstream = Zlib::Inflate.new
+        buf = zstream.inflate(str)
+        zstream.finish
+        zstream.close
+        return buf
+      else
+        raise RuntimeError, "Gzip support is not present."
+      end
+    end
+
+    #
+    # Compresses a string using gzip
+    #
+    # @param str (see zlib_deflate)
+    # @param level [Fixnum] Compression level, 1 (fast) to 9 (best)
+    # @return (see zlib_deflate)
+    def self.gzip(str, level = 9)
+      raise RuntimeError, "Gzip support is not present." if (!zlib_present?)
+      raise RuntimeError, "Invalid gzip compression level" if (level < 1 or level > 9)
+
+      s = ""
+      s.force_encoding('ASCII-8BIT') if s.respond_to?(:encoding)
+      gz = Zlib::GzipWriter.new(StringIO.new(s, 'wb'), level)
+      gz << str
+      gz.close
+      return s
+    end
+
+    #
+    # Uncompresses a string using gzip
+    #
+    # @param str (see zlib_inflate)
+    # @return (see zlib_inflate)
+    def self.ungzip(str)
+      raise RuntimeError, "Gzip support is not present." if (!zlib_present?)
+
+      s = ""
+      s.force_encoding('ASCII-8BIT') if s.respond_to?(:encoding)
+      gz = Zlib::GzipReader.new(StringIO.new(str, 'rb'))
+      s << gz.read
+      gz.close
+      return s
+    end
+  end
+end