rex-text 0.2.41 → 0.2.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99760857150edd0c9d0c3147b6529fa51244895878cf8aabb265cc17054931ed
-  data.tar.gz: 0bf2431de8fbdd5618a65925972e09e768f1e5b3c960a63cd4764d4bbc1252e5
+  metadata.gz: b88966aea3c2991faabd788caf7b9141968550554530da585e6cb46207c33d64
+  data.tar.gz: 233562b44e969d9a210695571a3aa84fcd4c4d84a6b0d22846696f84ff67a1d5
 SHA512:
-  metadata.gz: 10dc8566dc93c40022a13b03cb0f2e4ebde49e1bba0a7133d7048512635be71a084e54c4e68e39a7b3b36f44da57a81db6896c9cd739b314b49133cce4d9bcb3
-  data.tar.gz: 92daf4cf40ba727164f354be16b7193b0c84dc2bf87f89f4dd59ea2d6ac1172ac58993ad12dc30216a9e490d24f1c8aaad7083d75f01033f461fe0628cd0c6c8
+  metadata.gz: 6cd18682c4ffcaedc3c3177f27c42e93b4009cce7316090d3a64f84207895af48393f8cd431bd062fcc5c14f10241ad5537b464e2c5484bc1c513a4ed7d76502
+  data.tar.gz: 29cc99e565a56b899e43f8f9312ab9520abb3838ee68d8d3702de6ee13f080bc1929401837a0a32df3e00e29f673ae3d5aeee880e765fcf2f1b5727f60dfea76

data/lib/rex/text/color.rb

@@ -10,6 +10,7 @@ module Text
 #
 ###
 module Color
+  SUPPORTED_FORMAT_CODES = %w[%cya %red %grn %blu %yel %whi %mag %blk %dred %dgrn %dblu %dyel %dcya %dwhi %dmag %und %bld %clr %bgblu %bgyel %bggrn %bgmag %bgblk %bgred %bgcyn %bgwhi]
 
   AnsiAttributes =
     {

data/lib/rex/text/hex.rb

@@ -127,51 +127,22 @@ module Rex
     # 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 col < line_start.length + 4 + line_end.length
+        # raise an exception
+        raise ArgumentError.new('insufficient column width')
+      end
 
-          # 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
+      ret = buf_start.dup
+      ret << line_start if ret.end_with?("\n")
+      str.each_char do |char|
+        # "\x##".length is 4, check if we're going over the wrap boundary
+        if (ret.split("\n").last || '').length + 4 + line_end.length > col
+          ret << "#{line_end}\n#{line_start}"
         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"
+        ret << "\\x" << char.unpack('H*')[0]
       end
-
-      return output
+      ret << "\n" if ret.split("\n").last.length + buf_end.length > col
+      ret << "#{buf_end}\n"
     end
 
     #

data/lib/rex/text/lang.rb

@@ -29,13 +29,14 @@ module Rex
 
     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] << ","
+      str.each_char do |char|
+        # "0x##,".length is 5, check if we're going over the wrap boundary
+        ret << "\n" if ret.split("\n").last.length + 5 > wrap
+        ret << "0x" << char.unpack('H*')[0] << ","
       end
-      ret = ret[0..ret.length-2] #cut off last comma
-      ret << " };\n"
+      ret = ret[0..ret.length - 2] unless str.empty? # cut off last comma
+      ret << "\n" if ret.split("\n").last.length + 2 > wrap
+      ret << "};\n"
     end
 
     #
@@ -43,21 +44,21 @@ module Rex
     #
     def self.to_golang(str, wrap = DefaultWrap, name = "buf")
       ret = "#{name} :=  []byte{"
-      i = -1;
-      while (i += 1) < str.length
-        ret << "\n" if i%(wrap/4) == 0
-        ret << "0x" << str[i].unpack("H*")[0] << ", "
+      str.each_char do |char|
+        # "0x##,".length is 5, check if we're going over the wrap boundary
+        ret << "\n" if ret.split("\n").last.length + 5 > wrap
+        ret << "0x" << char.unpack('H*')[0] << ","
       end
-      ret = ret[0..ret.length-3] #cut off last comma
-      ret << " }\n"
-
+      ret = ret[0..ret.length - 2] unless str.empty? # cut off last comma
+      ret << "\n" if ret.split("\n").last.length + 2 > wrap
+      ret << "};\n"
     end
-    
+
     #
     # Creates a golang style comment
     #
     def self.to_golang_comment(str,  wrap = DefaultWrap)
-      return "/*\n" + wordwrap(str, 0, wrap, '', '') + "*/\n" 
+      return "/*\n" + wordwrap(str, 0, wrap, '', '') + "*/\n"
     end
 
     #
@@ -181,6 +182,5 @@ module Rex
       return wordwrap(str, 0, wrap, '', '# ')
     end
 
-
   end
 end

data/lib/rex/text/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Text
-    VERSION = "0.2.41"
+    VERSION = "0.2.44"
   end
 end

data/lib/rex/text/wrapped_table.rb

@@ -390,6 +390,7 @@ protected
   # Converts a row to a string.
   #
   def row_to_s(row) # :nodoc:
+    row = row.each_with_index.map { |cell, index| style_table_field(cell, index) }
     optimal_widths = calculate_optimal_widths
     values_as_chunks = chunk_values(row, optimal_widths)
     chunks_to_s(values_as_chunks, optimal_widths)
@@ -401,17 +402,134 @@ protected
   # widths. For now it simply returns the string's length.
   #
   def display_width(str)
-    str.length
+    Rex::Text.display_width(str)
   end
 
+  #
+  # Returns a string of color/formatting codes made up of the previously stored color_state
+  # e.g. if a `%blu` color code spans multiple lines this will return a string of `%blu` to be appended to
+  # the beginning of each row
+  #
+  # @param [Hash<String, String>] color_state tracks current color/formatting codes within table row
+  # @returns [String] Color code string such as `%blu%grn'
+  def color_code_string_for(color_state)
+    result = ''.dup
+    color_state.each do |_format, value|
+      if value.is_a?(Array)
+        result << value.uniq.join
+      else
+        result << value
+      end
+    end
+    result
+  end
+
+  # @returns [Hash<String, String>] The supported color codes from {Rex::Text::Color} grouped into sections
+  def color_code_groups
+    return @color_code_groups if @color_code_groups
+
+    @color_code_groups = {
+      foreground: %w[
+        %cya %red %grn %blu %yel %whi %mag %blk
+        %dred %dgrn %dblu %dyel %dcya %dwhi %dmag
+      ],
+      background: %w[
+        %bgblu %bgyel %bggrn %bgmag %bgblk %bgred %bgcyn %bgwhi
+      ],
+      decoration: %w[
+        %und %bld
+      ],
+      clear: %w[
+        %clr
+      ]
+    }
+
+    # Developer exception raised to ensure all color codes are accounted for. Verified via tests.
+    missing_color_codes = (Rex::Text::Color::SUPPORTED_FORMAT_CODES - @color_code_groups.values.flatten)
+    raise "Unsupported color codes #{missing_color_codes.join(', ')}" if missing_color_codes.any?
+
+    @color_code_groups
+  end
+
+  # Find the preceding color type and value of a given string
+  # @param [String] string A string such as '%bgyel etc'
+  # @returns [Array,nil] A tuple with the color type and value, or nil
+  def find_color_type_and_value(string)
+    color_code_groups.each do |color_type, color_values|
+      color_value = color_values.find { |color_value| string.start_with?(color_value) }
+      if color_value
+        return [color_type, color_value]
+      end
+    end
+
+    nil
+  end
+
+  #
+  # Takes an array of row values and an integer of optimal column width, loops over array and parses
+  # each string to gather color/formatting tags and handles those appropriately while not increasing the column width
+  #
+  # e.g. if a formatting "%blu" spans across multiple lines it needs to be added to the beginning off every following
+  # line, and each line will have a "%clr" added to the end of each row
+  #
+  # @param [Array<String>] values
+  # @param [Integer] optimal_widths
   def chunk_values(values, optimal_widths)
     # First split long strings into an array of chunks, where each chunk size is the calculated column width
     values_as_chunks = values.each_with_index.map do |value, idx|
+      color_state = {}
       column_width = optimal_widths[idx]
-      value
-        .chars
-        .each_slice(column_width)
-        .map(&:join)
+      chunks = []
+      current_chunk = nil
+      chars = value.chars
+      char_index = 0
+
+      # Check if any color code(s) from previous the string need appended
+      while char_index < chars.length do
+        # If a new chunk has started, start the chunk with any previous color codes
+        if current_chunk.nil? && color_state.any?
+          current_chunk = color_code_string_for(color_state)
+        end
+        current_chunk ||= ''.dup
+
+        # Check if the remaining chars start with a color code such as %blu
+        color_type_and_value = chars[char_index] == '%' ? find_color_type_and_value(chars[char_index..].join) : nil
+        if color_type_and_value.nil?
+          current_chunk << chars[char_index]
+          char_index += 1
+        else
+          color_type, color_code = color_type_and_value
+
+          if color_type == :clear
+            color_state.clear
+          elsif color_type == :decoration
+            # Multiple decorations can be enabled
+            color_state[:decoration] ||= []
+            color_state[:decoration] << color_code
+          else
+            # There can only be one foreground or background color
+            color_state[color_type] = color_code
+          end
+
+          current_chunk << color_code
+          char_index += color_code.length
+        end
+
+        # If we've reached the final character of the string, or need to word wrap
+        # it's time to push the current chunk, and start a new row. Also discard
+        # any values that are purely colors and have no display_width
+        is_final_character = char_index >= chars.length
+        display_width = display_width(current_chunk)
+        if (is_final_character && display_width != 0) || display_width == column_width
+          if color_state.any? && !current_chunk.end_with?('%clr')
+            current_chunk << '%clr'
+          end
+          chunks.push(current_chunk)
+          current_chunk = nil
+        end
+      end
+
+      chunks
     end
 
     values_as_chunks
@@ -424,12 +542,13 @@ protected
       line = ""
       row_chunks.each_with_index do |chunk, idx|
         column_width = optimal_widths[idx]
+        chunk_length_with_padding = column_width + (chunk.to_s.length - display_width(chunk.to_s))
 
         if idx == 0
           line << ' ' * indent
         end
 
-        line << chunk.to_s.ljust(column_width)
+        line << chunk.to_s.ljust(chunk_length_with_padding)
         line << ' ' * cellpad
       end
 
@@ -519,13 +638,12 @@ protected
     str_cp
   end
 
-  def style_table_field(str, _idx)
+  def style_table_field(str, idx)
     str_cp = str.dup
 
-    # Not invoking as color currently conflicts with the wrapping of tables
-    # colprops[idx]['Stylers'].each do |s|
-    #   str_cp = s.style(str_cp)
-    # end
+    colprops[idx]['Stylers'].each do |s|
+      str_cp = s.style(str_cp)
+    end
 
     str_cp
   end

data/lib/rex/text.rb

@@ -98,6 +98,21 @@ module Rex
     end
 
 
+    # @return [Regexp] Matches a valid color code, i.e. "%blu,%yel,...etc"
+    COLOR_CODES_REGEX = /#{Regexp.union(Rex::Text::Color::SUPPORTED_FORMAT_CODES.compact).source}/
+    private_constant :COLOR_CODES_REGEX
+
+    #
+    # Function that aims to calculate the display width of the given string.
+    # In the future this will be aware of East Asian characters having different display
+    # widths. For now it simply returns the string's length ignoring color codes.
+    #
+    # @param [String] str
+    # @return [Integer]
+    def self.display_width(str)
+      str.gsub(COLOR_CODES_REGEX, '').length
+    end
+
     #
     # Convert 16-byte string to a GUID string
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rex-text
 version: !ruby/object:Gem::Version
-  version: 0.2.41
+  version: 0.2.44
 platform: ruby
 authors:
 - Metasploit Hackers
@@ -93,7 +93,7 @@ cert_chain:
   EknWpNgVhohbot1lfVAMmIhdtOVaRVcQQixWPwprDj/ydB8ryDMDosIMcw+fkoXU
   9GJsSaSRRYQ9UUkVL27b64okU8D48m8=
   -----END CERTIFICATE-----
-date: 2022-08-31 00:00:00.000000000 Z
+date: 2022-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake