rex-text 0.2.23 → 0.2.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 749df288d86a56887e10173789fa6f5cf48338f0
-  data.tar.gz: 2816e209fbf1f7023bddfba45685547f39135e65
+SHA256:
+  metadata.gz: ed0a3f361cc220f42bd061edb39b914add50ad3a52f196f1d02bce1e3e56254a
+  data.tar.gz: b9317aea70870fc37394cf4d60c53b12b314e0c0f5da7ed949e0af658f54a2de
 SHA512:
-  metadata.gz: 13065d1896bf02cd692079389e4d67b870f8a429914c91a2cf238c6c4f6e9e0123de531cedd8845888958404e00d6c96af570f910e9741bee5309a60634d3d35
-  data.tar.gz: 9cf93a5d8f0c83d09a79841de00afaf39a329a95024d9f7345620f07442dd317f3592ef1351cddd0eace24772f51039434159073e94a62cf22adc9c0498671cb
+  metadata.gz: 984bc5972b4ac1abe5dbd98dbe651bcdc785724b61062062ee1c0aa5811cbd78d54c45bef34f5103e191b878b42fd341ebe37ad0bd482b7e99959b558f5aba4f
+  data.tar.gz: f21d06b23911998f4d178c081d420e18e1692e41855cf67d44c0d15509501efdc6745c592fbd3d5681171921c71a67c3e686004bf48e6c7bafdd4aa8747f2ad8

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in rex-text.gemspec
 gemspec
+
+group :development do
+  gem 'pry-byebug'
+end

data/lib/rex/text.rb

@@ -29,7 +29,7 @@ require 'rex/text/xor'
 
 require 'rex/text/color'
 require 'rex/text/table'
-
+require 'rex/text/wrapped_table'
 
 module Rex
 

data/lib/rex/text/color.rb

@@ -52,7 +52,7 @@ module Color
   def substitute_colors(msg, in_prompt = nil)
     str = msg.dup
     pre_color = post_color = ''
-    if (in_prompt)
+    if (in_prompt && supports_color?)
       pre_color = "\x01"  # RL_PROMPT_START_IGNORE
       post_color = "\x02" # RL_PROMPT_END_IGNORE
     end

data/lib/rex/text/lang.rb

@@ -152,5 +152,13 @@ module Rex
       return wordwrap(str, 0, wrap, '', '# ')
     end
 
+    #
+    # Creates a psh-style comment
+    #
+    def self.to_psh_comment(str, wrap = DefaultWrap)
+      return wordwrap(str, 0, wrap, '', '# ')
+    end
+
+
   end
 end

data/lib/rex/text/table.rb

@@ -12,6 +12,34 @@ module Text
 ###
 class Table
 
+  # Temporary forking logic for using the prototype `WrappedTable` implementation.
+  #
+  # This method replaces the default `Table.new` with the ability to call the `WrappedTable` class instead,
+  # to allow users to safely toggle between wrapped/unwrapped tables at a global level without changing
+  # their existing codebases. This approach will reduce the risk of enabling wrapped table behavior by default.
+  #
+  # To enforce all tables to be wrapped to the terminal's current width, call `Table.wrap_tables!`
+  # before invoking `Table.new` as normal.
+  def self.new(*args, &block)
+    if wrap_tables?
+      table_options = args[0]
+      return ::Rex::Text::WrappedTable.new(table_options)
+    end
+    return super(*args, &block)
+  end
+
+  def self.wrap_tables?
+    @@wrapped_tables_enabled ||= false
+  end
+
+  def self.wrap_tables!
+    @@wrapped_tables_enabled = true
+  end
+
+  def self.unwrap_tables!
+    @@wrapped_tables_enabled = false
+  end
+
   #
   # Initializes a text table instance using the supplied properties.  The
   # Table class supports the following hash attributes:
@@ -57,6 +85,10 @@ class Table
   #
   #	The column to sort the table on, -1 disables sorting.
   #
+  # ColProps
+  #
+  # A hash specifying column MaxWidth, Stylers, and Formatters.
+  #
   def initialize(opts = {})
     self.header   = opts['Header']
     self.headeri  = opts['HeaderIndent'] || 0
@@ -79,6 +111,8 @@ class Table
     self.columns.length.times { |idx|
       self.colprops[idx] = {}
       self.colprops[idx]['MaxWidth'] = self.columns[idx].length
+      self.colprops[idx]['Stylers'] = []
+      self.colprops[idx]['Formatters'] = []
     }
 
     # ensure all our internal state gets updated with the given rows by
@@ -172,16 +206,19 @@ class Table
     if fields.length != self.columns.length
       raise RuntimeError, 'Invalid number of columns!'
     end
-    fields.each_with_index { |field, idx|
+    formatted_fields = fields.map.with_index { |field, idx|
       # Remove whitespace and ensure String format
-      field = field.to_s.strip
+      field = format_table_field(field.to_s.strip, idx)
+
       if (colprops[idx]['MaxWidth'] < field.to_s.length)
         old = colprops[idx]['MaxWidth']
         colprops[idx]['MaxWidth'] = field.to_s.length
       end
+
+      field
     }
 
-    rows << fields
+    rows << formatted_fields
   end
 
   def ip_cmp(a, b)
@@ -389,9 +426,9 @@ protected
       # Limit wide cells
       if colprops[idx]['MaxChar']
         last_cell = cell.to_s[0..colprops[idx]['MaxChar'].to_i]
-        line << last_cell
+        line << style_table_field(last_cell, idx)
       else
-        line << cell.to_s
+        line << style_table_field(cell.to_s, idx)
         last_cell = cell
       end
       last_idx = idx
@@ -414,7 +451,12 @@ protected
         __method__.to_s << ': String with unsupported encoding caught!'
     end
     utf8_buf = buf.dup.force_encoding("UTF-8")
-    remainder = max - utf8_buf.length
+    if !utf8_buf.valid_encoding?
+      hans_size = 0
+    else
+      hans_size = utf8_buf.size - utf8_buf.gsub(/\p{Han}+/u, '').size
+    end
+    remainder = max - utf8_buf.length - hans_size
     remainder = 0 if remainder < 0
     val       = chr * remainder
 
@@ -425,6 +467,25 @@ protected
     return val
   end
 
+  def format_table_field(str, idx)
+    str_cp = str.clone
+
+    colprops[idx]['Formatters'].each do |f|
+      str_cp = f.format(str_cp)
+    end
+
+    str_cp
+  end
+
+  def style_table_field(str, idx)
+    str_cp = str.clone
+
+    colprops[idx]['Stylers'].each do |s|
+      str_cp = s.style(str_cp)
+    end
+
+    str_cp
+  end
 
 end
 

data/lib/rex/text/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Text
-    VERSION = "0.2.23"
+    VERSION = "0.2.28"
   end
 end

data/lib/rex/text/wrapped_table.rb

@@ -0,0 +1,538 @@
+# -*- coding: binary -*-
+require 'ipaddr'
+require 'io/console'
+
+module Rex
+module Text
+
+###
+#
+# Prints text in a tablized format.  Pretty lame at the moment, but
+# whatever.
+#
+###
+# private_constant
+class WrappedTable
+
+  #
+  # Initializes a text table instance using the supplied properties.  The
+  # Table class supports the following hash attributes:
+  #
+  # Header
+  #
+  #	The string to display as a heading above the table.  If none is
+  #	specified, no header will be displayed.
+  #
+  # HeaderIndent
+  #
+  # 	The amount of space to indent the header.  The default is zero.
+  #
+  # Columns
+  #
+  # 	The array of columns that will exist within the table.
+  #
+  # Rows
+  #
+  # 	The array of rows that will exist.
+  #
+  # Width
+  #
+  # 	The maximum width of the table in characters.
+  #
+  # Indent
+  #
+  # 	The number of characters to indent the table.
+  #
+  # CellPad
+  #
+  # 	The number of characters to put between each horizontal cell.
+  #
+  # Prefix
+  #
+  # 	The text to prefix before the table.
+  #
+  # Postfix
+  #
+  # 	The text to affix to the end of the table.
+  #
+  # Sortindex
+  #
+  #	The column to sort the table on, -1 disables sorting.
+  #
+  # ColProps
+  #
+  # A hash specifying column MaxWidth, Stylers, and Formatters.
+  #
+  def initialize(opts = {})
+    self.header   = opts['Header']
+    self.headeri  = opts['HeaderIndent'] || 0
+    self.columns  = opts['Columns'] || []
+    # updated below if we got a "Rows" option
+    self.rows     = []
+
+    # TODO: Discuss a cleaner way to handle this information
+    self.width    = opts['Width']   || ::IO.console.winsize[1]
+    self.indent   = opts['Indent']  || 0
+    self.cellpad  = opts['CellPad'] || 2
+    self.prefix   = opts['Prefix']  || ''
+    self.postfix  = opts['Postfix'] || ''
+    self.colprops = []
+    self.scterm   = /#{opts['SearchTerm']}/mi if opts['SearchTerm']
+
+    self.sort_index  = opts['SortIndex'] || 0
+    self.sort_order  = opts['SortOrder'] || :forward
+
+    # Default column properties
+    self.columns.length.times { |idx|
+      self.colprops[idx] = {}
+      self.colprops[idx]['MaxWidth'] = self.columns[idx].length
+      self.colprops[idx]['WordWrap'] = true
+      self.colprops[idx]['Stylers'] = []
+      self.colprops[idx]['Formatters'] = []
+    }
+
+    # ensure all our internal state gets updated with the given rows by
+    # using add_row instead of just adding them to self.rows.  See #3825.
+    opts['Rows'].each { |row| add_row(row) } if opts['Rows']
+
+    # Merge in options
+    if (opts['ColProps'])
+      opts['ColProps'].each_key { |col|
+        idx = self.columns.index(col)
+
+        if (idx)
+          self.colprops[idx].merge!(opts['ColProps'][col])
+        end
+      }
+    end
+
+  end
+
+  #
+  # Converts table contents to a string.
+  #
+  def to_s
+    str  = prefix.dup
+    str << header_to_s || ''
+    str << columns_to_s || ''
+    str << hr_to_s || ''
+
+    sort_rows
+    rows.each { |row|
+      if (is_hr(row))
+        str << hr_to_s
+      else
+        str << row_to_s(row) if row_visible(row)
+      end
+    }
+
+    str << postfix
+
+    return str
+  end
+
+  #
+  # Converts table contents to a csv
+  #
+  def to_csv
+    str = ''
+    str << ( columns.join(",") + "\n" )
+    rows.each { |row|
+      next if is_hr(row) || !row_visible(row)
+      str << ( row.map{|x|
+        x = x.to_s
+        x.gsub(/[\r\n]/, ' ').gsub(/\s+/, ' ').gsub('"', '""')
+      }.map{|x| "\"#{x}\"" }.join(",") + "\n" )
+    }
+    str
+  end
+
+  #
+  #
+  # Returns the header string.
+  #
+  def header_to_s # :nodoc:
+    if (header)
+      pad = " " * headeri
+
+      return pad + header + "\n" + pad + "=" * header.length + "\n\n"
+    end
+
+    return ''
+  end
+
+  #
+  # Prints the contents of the table.
+  #
+  def print
+    puts to_s
+  end
+
+  #
+  # Adds a row using the supplied fields.
+  #
+  def <<(fields)
+    add_row(fields)
+  end
+
+  #
+  # Adds a row with the supplied fields.
+  #
+  def add_row(fields = [])
+    if fields.length != self.columns.length
+      raise RuntimeError, 'Invalid number of columns!'
+    end
+    formatted_fields = fields.map.with_index { |field, idx|
+      # Remove whitespace and ensure String format
+      field = format_table_field(field.to_s.strip, idx)
+
+      if (colprops[idx]['MaxWidth'] < display_width(field.to_s))
+        old = colprops[idx]['MaxWidth']
+        colprops[idx]['MaxWidth'] = display_width(field.to_s)
+      end
+
+      field
+    }
+
+    rows << formatted_fields
+  end
+
+  def ip_cmp(a, b)
+    begin
+      a = IPAddr.new(a.to_s)
+      b = IPAddr.new(b.to_s)
+      return 1  if a.ipv6? && b.ipv4?
+      return -1 if a.ipv4? && b.ipv6?
+      a <=> b
+    rescue IPAddr::Error
+      nil
+    end
+  end
+
+  #
+  # Sorts the rows based on the supplied index of sub-arrays
+  # If the supplied index is an IPv4 address, handle it differently, but
+  # avoid actually resolving domain names.
+  #
+  def sort_rows(index = sort_index, order = sort_order)
+    return if index == -1
+    return unless rows
+    rows.sort! do |a,b|
+      if a[index].nil?
+        cmp = -1
+      elsif b[index].nil?
+        cmp = 1
+      elsif a[index] =~ /^[0-9]+$/ and b[index] =~ /^[0-9]+$/
+        cmp = a[index].to_i <=> b[index].to_i
+      elsif (cmp = ip_cmp(a[index], b[index])) != nil
+      else
+        cmp = a[index] <=> b[index] # assumes otherwise comparable.
+      end
+      cmp ||= 0
+      order == :forward ? cmp : -cmp
+    end
+  end
+
+  #
+  # Adds a horizontal line.
+  #
+  def add_hr
+    rows << '__hr__'
+  end
+
+  #
+  # Returns new sub-table with headers and rows maching column names submitted
+  #
+  #
+  # Flips table 90 degrees left
+  #
+  def drop_left
+    tbl = self.class.new(
+      'Columns' => Array.new(self.rows.count+1,'  '),
+      'Header' => self.header,
+      'Indent' => self.indent)
+    (self.columns.count+1).times do |ti|
+      row = self.rows.map {|r| r[ti]}.unshift(self.columns[ti]).flatten
+      # insert our col|row break. kind of hackish
+      row[1] = "| #{row[1]}" unless row.all? {|e| e.nil? || e.empty?}
+      tbl << row
+    end
+    return tbl
+  end
+
+  def valid_ip?(value)
+    begin
+      IPAddr.new value
+      true
+    rescue IPAddr::Error
+      false
+    end
+  end
+
+  #
+  # Build table from CSV dump
+  #
+  def self.new_from_csv(csv)
+    # Read in or keep data, get CSV or die
+    if csv.is_a?(String)
+      csv = File.file?(csv) ? CSV.read(csv) : CSV.parse(csv)
+    end
+    # Adjust for skew
+    if csv.first == ["Keys", "Values"]
+      csv.shift # drop marker
+      cols = []
+      rows = []
+      csv.each do |row|
+        cols << row.shift
+        rows << row
+      end
+      tbl = self.new('Columns' => cols)
+      rows.in_groups_of(cols.count) {|r| tbl << r.flatten}
+    else
+      tbl = self.new('Columns' => csv.shift)
+      while !csv.empty? do
+        tbl << csv.shift
+      end
+    end
+    return tbl
+  end
+
+  def [](*col_names)
+    tbl = self.class.new('Indent' => self.indent,
+                         'Header' => self.header,
+                         'Columns' => col_names)
+    indexes = []
+
+    col_names.each do |col_name|
+      index = self.columns.index(col_name)
+      raise RuntimeError, "Invalid column name #{col_name}" if index.nil?
+      indexes << index
+    end
+
+    self.rows.each do |old_row|
+      new_row = []
+      indexes.map {|i| new_row << old_row[i]}
+      tbl << new_row
+    end
+
+    return tbl
+  end
+
+
+  alias p print
+
+  attr_accessor :header, :headeri # :nodoc:
+  attr_accessor :columns, :rows, :colprops # :nodoc:
+  attr_accessor :width, :indent, :cellpad # :nodoc:
+  attr_accessor :prefix, :postfix # :nodoc:
+  attr_accessor :sort_index, :sort_order, :scterm # :nodoc:
+
+protected
+
+  #
+  # Returns if a row should be visible or not
+  #
+  def row_visible(row)
+    return true if self.scterm.nil?
+    row_to_s(row).match(self.scterm)
+  end
+
+  #
+  # Defaults cell widths and alignments.
+  #
+  def defaults # :nodoc:
+    self.columns.length.times { |idx|
+    }
+  end
+
+  #
+  # Checks to see if the row is an hr.
+  #
+  def is_hr(row) # :nodoc:
+    return ((row.kind_of?(String)) && (row == '__hr__'))
+  end
+
+  #
+  # Converts the columns to a string.
+  #
+  def columns_to_s # :nodoc:
+    optimal_widths = calculate_optimal_widths
+    values_as_chunks = chunk_values(columns, optimal_widths)
+    result = chunks_to_s(values_as_chunks, optimal_widths)
+
+    barline = ""
+    columns.each.with_index do |_column, idx|
+      bar_width = display_width(values_as_chunks[idx].first)
+      column_width = optimal_widths[idx]
+
+      if idx == 0
+        barline << ' ' * indent
+      end
+
+      barline << '-' * bar_width
+      is_last_column = (idx + 1) == columns.length
+      unless is_last_column
+        barline << ' ' * (column_width - bar_width)
+        barline << ' ' * cellpad
+      end
+    end
+
+    result + barline
+  end
+
+  #
+  # Converts an hr to a string.
+  #
+  def hr_to_s # :nodoc:
+    return "\n"
+  end
+
+  #
+  # Converts a row to a string.
+  #
+  def row_to_s(row) # :nodoc:
+    optimal_widths = calculate_optimal_widths
+    values_as_chunks = chunk_values(row, optimal_widths)
+    chunks_to_s(values_as_chunks, optimal_widths)
+  end
+
+  #
+  # Placeholder 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.
+  #
+  def display_width(str)
+    str.length
+  end
+
+  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|
+      column_width = optimal_widths[idx]
+      value
+        .split('')
+        .each_slice(column_width)
+        .map(&:join)
+    end
+
+    values_as_chunks
+  end
+
+  def chunks_to_s(values_as_chunks, optimal_widths)
+    result = ''
+
+    interleave(values_as_chunks).each do |row_chunks|
+      line = ""
+      row_chunks.each_with_index do |chunk, idx|
+        column_width = optimal_widths[idx]
+
+        if idx == 0
+          line << ' ' * indent
+        end
+
+        line << chunk.to_s.ljust(column_width)
+        line << ' ' * cellpad
+      end
+
+      result << line.rstrip << "\n"
+    end
+
+    result
+  end
+
+  def interleave(arrays)
+    max_length = arrays.map(&:size).max
+    padding = [nil] * max_length
+    with_left_extra_column = padding.zip(*arrays)
+    without_extra_column = with_left_extra_column.map { |columns| columns.drop(1) }
+
+    without_extra_column
+  end
+
+  def calculate_optimal_widths
+    # Calculate the minimum width each column can be. This is dictated by the user.
+    user_influenced_column_widths = colprops.map do |colprop|
+      if colprop['WordWrap'] == false
+        colprop['MaxWidth']
+        raise 'Not implemented'
+      else
+        nil
+      end
+    end
+
+    required_padding = indent + (colprops.length) * cellpad
+    available_space = self.width - user_influenced_column_widths.sum(&:to_i) - required_padding
+    remaining_column_calculations = user_influenced_column_widths.select(&:nil?).count
+
+    # Calculate the initial widths, which will need an additional refinement to reallocate surplus space
+    naive_optimal_width_calculations = colprops.map.with_index do |colprop, index|
+      shared_column_width = available_space / [remaining_column_calculations, 1].max
+      remaining_column_calculations -= 1
+
+      if user_influenced_column_widths[index]
+        { width: user_influenced_column_widths[index], wrapped: false }
+      elsif colprop['MaxWidth'] < shared_column_width
+        available_space -= colprop['MaxWidth']
+        { width: colprop['MaxWidth'], wrapped: false }
+      else
+        available_space -= shared_column_width
+        { width: shared_column_width, wrapped: true }
+      end
+    end
+
+    # Naively redistribute any surplus space to columns that were wrapped, and try to fit the cell on one line still
+    current_width = naive_optimal_width_calculations.sum { |width| width[:width] }
+    surplus_width = self.width - current_width - required_padding
+    # revisit all columns that were wrapped and add add additional characters
+    revisiting_column_counts = naive_optimal_width_calculations.count { |width| width[:wrapped] }
+    optimal_widths = naive_optimal_width_calculations.map.with_index do |naive_width, index|
+      additional_column_width = surplus_width / [revisiting_column_counts, 1].max
+      revisiting_column_counts -= 1
+
+      if naive_width[:wrapped]
+        max_width = colprops[index]['MaxWidth']
+        if max_width < (naive_width[:width] + additional_column_width)
+          surplus_width -= max_width - naive_width[:width]
+          max_width
+        else
+          surplus_width -= additional_column_width
+          naive_width[:width] + additional_column_width
+        end
+      else
+        naive_width[:width]
+      end
+    end
+
+    # In certain scenarios columns can be allocated 0 widths if it's completely impossible to fit the columns into the
+    # given space. There's different ways to handle that, for instance truncating data in the table to the initial
+    # columns that can fit. For now, we just ensure every width is at least 1 or more character wide, and in the future
+    # it may have to truncate columns entirely.
+    optimal_widths.map { |width| [1, width].max }
+  end
+
+  def format_table_field(str, idx)
+    str_cp = str.dup
+
+    colprops[idx]['Formatters'].each do |f|
+      str_cp = f.format(str_cp)
+    end
+
+    str_cp.dup.force_encoding('UTF-8')
+  end
+
+  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
+
+    str_cp
+  end
+
+end
+
+end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rex-text
 version: !ruby/object:Gem::Version
-  version: 0.2.23
+  version: 0.2.28
 platform: ruby
 authors:
 - David 'thelightcosine' Maloney
@@ -10,85 +10,90 @@ bindir: exe
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
-  A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
-  Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
-  MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
-  A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
-  hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
-  RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
-  gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
-  KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
-  QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
-  XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
-  DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
-  LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
-  RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
-  jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
-  6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
-  mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
-  Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
-  WD9f
+  MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
+  MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+  d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+  b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
+  EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+  cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
+  MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
+  JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
+  mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
+  wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
+  VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
+  AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
+  AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
+  BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
+  pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
+  dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
+  fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
+  NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
+  H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
+  +o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
   -----END CERTIFICATE-----
 - |
   -----BEGIN CERTIFICATE-----
-  MIIElDCCA3ygAwIBAgIOSBtqBybS6D8mAtSCWs0wDQYJKoZIhvcNAQELBQAwTDEg
-  MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2Jh
-  bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTYwNjE1MDAwMDAwWhcNMjQw
-  NjE1MDAwMDAwWjBaMQswCQYDVQQGEwJCRTEZMBcGA1UEChMQR2xvYmFsU2lnbiBu
-  di1zYTEwMC4GA1UEAxMnR2xvYmFsU2lnbiBDb2RlU2lnbmluZyBDQSAtIFNIQTI1
-  NiAtIEczMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAjYVVI6kfU6/J
-  7TbCKbVu2PlC9SGLh/BDoS/AP5fjGEfUlk6Iq8Zj6bZJFYXx2Zt7G/3YSsxtToZA
-  F817ukcotdYUQAyG7h5LM/MsVe4hjNq2wf6wTjquUZ+lFOMQ5pPK+vldsZCH7/g1
-  LfyiXCbuexWLH9nDoZc1QbMw/XITrZGXOs5ynQYKdTwfmOPLGC+MnwhKkQrZ2TXZ
-  g5J2Yl7fg67k1gFOzPM8cGFYNx8U42qgr2v02dJsLBkwXaBvUt/RnMngDdl1EWWW
-  2UO0p5A5rkccVMuxlW4l3o7xEhzw127nFE2zGmXWhEpX7gSvYjjFEJtDjlK4Prau
-  niyX/4507wIDAQABo4IBZDCCAWAwDgYDVR0PAQH/BAQDAgEGMB0GA1UdJQQWMBQG
-  CCsGAQUFBwMDBggrBgEFBQcDCTASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQW
-  BBQPOueslJF0LZYCc4OtnC5JPxmqVDAfBgNVHSMEGDAWgBSP8Et/qC5FJK5NUPpj
-  move4t0bvDA+BggrBgEFBQcBAQQyMDAwLgYIKwYBBQUHMAGGImh0dHA6Ly9vY3Nw
-  Mi5nbG9iYWxzaWduLmNvbS9yb290cjMwNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDov
-  L2NybC5nbG9iYWxzaWduLmNvbS9yb290LXIzLmNybDBjBgNVHSAEXDBaMAsGCSsG
-  AQQBoDIBMjAIBgZngQwBBAEwQQYJKwYBBAGgMgFfMDQwMgYIKwYBBQUHAgEWJmh0
-  dHBzOi8vd3d3Lmdsb2JhbHNpZ24uY29tL3JlcG9zaXRvcnkvMA0GCSqGSIb3DQEB
-  CwUAA4IBAQAVhCgM7aHDGYLbYydB18xjfda8zzabz9JdTAKLWBoWCHqxmJl/2DOK
-  XJ5iCprqkMLFYwQL6IdYBgAHglnDqJQy2eAUTaDVI+DH3brwaeJKRWUtTUmQeGYy
-  DrBowLCIsI7tXAb4XBBIPyNzujtThFKAzfCzFcgRCosFeEZZCNS+t/9L9ZxqTJx2
-  ohGFRYzUN+5Q3eEzNKmhHzoL8VZEim+zM9CxjtEMYAfuMsLwJG+/r/uBAXZnxKPo
-  4KvcM1Uo42dHPOtqpN+U6fSmwIHRUphRptYCtzzqSu/QumXSN4NTS35nfIxA9gcc
-  sK8EBtz4bEaIcpzrTp3DsLlUo7lOl8oU
+  MIIFMDCCBBigAwIBAgIQBAkYG1/Vu2Z1U0O1b5VQCDANBgkqhkiG9w0BAQsFADBl
+  MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+  d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
+  b3QgQ0EwHhcNMTMxMDIyMTIwMDAwWhcNMjgxMDIyMTIwMDAwWjByMQswCQYDVQQG
+  EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
+  cnQuY29tMTEwLwYDVQQDEyhEaWdpQ2VydCBTSEEyIEFzc3VyZWQgSUQgQ29kZSBT
+  aWduaW5nIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+NOzHH8O
+  Ea9ndwfTCzFJGc/Q+0WZsTrbRPV/5aid2zLXcep2nQUut4/6kkPApfmJ1DcZ17aq
+  8JyGpdglrA55KDp+6dFn08b7KSfH03sjlOSRI5aQd4L5oYQjZhJUM1B0sSgmuyRp
+  wsJS8hRniolF1C2ho+mILCCVrhxKhwjfDPXiTWAYvqrEsq5wMWYzcT6scKKrzn/p
+  fMuSoeU7MRzP6vIK5Fe7SrXpdOYr/mzLfnQ5Ng2Q7+S1TqSp6moKq4TzrGdOtcT3
+  jNEgJSPrCGQ+UpbB8g8S9MWOD8Gi6CxR93O8vYWxYoNzQYIH5DiLanMg0A9kczye
+  n6Yzqf0Z3yWT0QIDAQABo4IBzTCCAckwEgYDVR0TAQH/BAgwBgEB/wIBADAOBgNV
+  HQ8BAf8EBAMCAYYwEwYDVR0lBAwwCgYIKwYBBQUHAwMweQYIKwYBBQUHAQEEbTBr
+  MCQGCCsGAQUFBzABhhhodHRwOi8vb2NzcC5kaWdpY2VydC5jb20wQwYIKwYBBQUH
+  MAKGN2h0dHA6Ly9jYWNlcnRzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJ
+  RFJvb3RDQS5jcnQwgYEGA1UdHwR6MHgwOqA4oDaGNGh0dHA6Ly9jcmw0LmRpZ2lj
+  ZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmwwOqA4oDaGNGh0dHA6
+  Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEFzc3VyZWRJRFJvb3RDQS5jcmww
+  TwYDVR0gBEgwRjA4BgpghkgBhv1sAAIEMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8v
+  d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwCgYIYIZIAYb9bAMwHQYDVR0OBBYEFFrEuXsq
+  CqOl6nEDwGD5LfZldQ5YMB8GA1UdIwQYMBaAFEXroq/0ksuCMS1Ri6enIZ3zbcgP
+  MA0GCSqGSIb3DQEBCwUAA4IBAQA+7A1aJLPzItEVyCx8JSl2qB1dHC06GsTvMGHX
+  fgtg/cM9D8Svi/3vKt8gVTew4fbRknUPUbRupY5a4l4kgU4QpO4/cY5jDhNLrddf
+  RHnzNhQGivecRk5c/5CxGwcOkRX7uq+1UcKNJK4kxscnKqEpKBo6cSgCPC6Ro8Al
+  EeKcFEehemhor5unXCBc2XGxDI+7qPjFEmifz0DLQESlE/DmZAwlCEIysjaKJAL+
+  L3J+HNdJRZboWR3p+nRka7LrZkPas7CM1ekN3fYBIM6ZMWM9CBoYs4GbT8aTEAb8
+  B4H6i9r5gkn3Ym6hU/oSlBiFLpKR6mhsRDKyZqHnGKSaZFHv
   -----END CERTIFICATE-----
 - |
   -----BEGIN CERTIFICATE-----
-  MIIE5jCCA86gAwIBAgIMKDuO03uv6RWXR1uAMA0GCSqGSIb3DQEBCwUAMFoxCzAJ
-  BgNVBAYTAkJFMRkwFwYDVQQKExBHbG9iYWxTaWduIG52LXNhMTAwLgYDVQQDEydH
-  bG9iYWxTaWduIENvZGVTaWduaW5nIENBIC0gU0hBMjU2IC0gRzMwHhcNMTYwOTEz
-  MTgxMDIyWhcNMTkxMTExMTUxNTM4WjBgMQswCQYDVQQGEwJVUzEWMBQGA1UECBMN
-  TWFzc2FjaHVzZXR0czEPMA0GA1UEBxMGQm9zdG9uMRMwEQYDVQQKEwpSYXBpZDcg
-  TExDMRMwEQYDVQQDEwpSYXBpZDcgTExDMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
-  MIIBCgKCAQEAl0HeC0FzN1BJ4nQkxsBng3peS9Bdi9rpSGx+g0Ximd+M/7twmund
-  bzn2JPbNK/Gp/rq/SytrNSLcUzcbH/0z5Ltyw1/jQsGtRBrns0NZSRXqupQDW5R6
-  HFpaIAl3OdsesmIQc/fm0uhh8dkfHVo7UsZO/TeCPoy0uHXTI6aFBPzMMsdz+gf3
-  cCCLsnNKQh/T2Q/jwBs3NTPoyza/pPZcvGogKcWCeNihTO5Rn1Fc71sMHSjQsDtn
-  1fWGKYGi0qjvZ4lpGM9IFZMTbySKHbPLhhHnBOoV7avGemdky3AEsUeiT+6DY0P1
-  IydBy24uVNhGATglME1ttlT4Eme/to0M6wIDAQABo4IBpDCCAaAwDgYDVR0PAQH/
-  BAQDAgeAMIGUBggrBgEFBQcBAQSBhzCBhDBIBggrBgEFBQcwAoY8aHR0cDovL3Nl
-  Y3VyZS5nbG9iYWxzaWduLmNvbS9jYWNlcnQvZ3Njb2Rlc2lnbnNoYTJnM29jc3Au
-  Y3J0MDgGCCsGAQUFBzABhixodHRwOi8vb2NzcDIuZ2xvYmFsc2lnbi5jb20vZ3Nj
-  b2Rlc2lnbnNoYTJnMzBWBgNVHSAETzBNMEEGCSsGAQQBoDIBMjA0MDIGCCsGAQUF
-  BwIBFiZodHRwczovL3d3dy5nbG9iYWxzaWduLmNvbS9yZXBvc2l0b3J5LzAIBgZn
-  gQwBBAEwCQYDVR0TBAIwADA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3JsLmds
-  b2JhbHNpZ24uY29tL2dzY29kZXNpZ25zaGEyZzMuY3JsMBMGA1UdJQQMMAoGCCsG
-  AQUFBwMDMB0GA1UdDgQWBBSm8RBpBC/cK9VmxzO2+RWnacN8CTAfBgNVHSMEGDAW
-  gBQPOueslJF0LZYCc4OtnC5JPxmqVDANBgkqhkiG9w0BAQsFAAOCAQEANVO3uYQl
-  h8iicbaXE3odrL+kXXmeeNgt4BD3x7GKAVIVixtwBS6pvrshjc1LN0tm3ruiv8oy
-  cq4FiEmVUXZejSRvVVtABeWdZWo+lJ8NxCBUEYYmnMrjgFIbGiEbBsg7PGtyeQsA
-  5Wbg7Lx889mS1tKfQBcPif8EjpTiXNfMiywmpaMYmvm+yQgzrRLDbjz6JV0Rc5Ga
-  WChka+LTPnMtsWJuFM8ka8icMeS28/nAGERdewxWvz+DeAPMORdTJ7aqb6+Y9xuz
-  G+Hmcg1v810agasPdoydE0RTVZgEOOMoQ07qu7JFXVWZ9ZQpHT7qJATWL/b2csFG
-  8mVuTXnyJOKRJA==
+  MIIFIzCCBAugAwIBAgIQDX9ZkVJ2eNVTlibR5ALyJTANBgkqhkiG9w0BAQsFADBy
+  MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
+  d3cuZGlnaWNlcnQuY29tMTEwLwYDVQQDEyhEaWdpQ2VydCBTSEEyIEFzc3VyZWQg
+  SUQgQ29kZSBTaWduaW5nIENBMB4XDTE5MTAxNjAwMDAwMFoXDTIwMTAxOTEyMDAw
+  MFowYDELMAkGA1UEBhMCVVMxFjAUBgNVBAgTDU1hc3NhY2h1c2V0dHMxDzANBgNV
+  BAcTBkJvc3RvbjETMBEGA1UEChMKUmFwaWQ3IExMQzETMBEGA1UEAxMKUmFwaWQ3
+  IExMQzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANHnKegPAghKuZk4
+  Gy1jKaZEXbWc4fxioTemv/F1yIYzAjCWP65qjKtyeeFDe4/kJzG9nseF9oa93YBf
+  1nyEqxNSZMw/sCAZ87lOl713dRi73uxOoszy2PT5xEB+Q5R6cbzExkWG2zrLdXDr
+  so0Bd6VHw+IsAoBBkAq5FrZOJQYGn5VY20xw/2DqtCeoW4QDWyqTnbJmwO9tZrfr
+  3Le2crfk2eOgafaPNhLon5uuIKCZsk2YkUSNURSS3M7gosMwU9Gg4JTBi7X5+oww
+  rY43dJT28YklxmNVu8o5kJxW4dqLKJLOIgSXZ63nceT/EaCSg7DcofHNcUzejFwb
+  M7Zbb2kCAwEAAaOCAcUwggHBMB8GA1UdIwQYMBaAFFrEuXsqCqOl6nEDwGD5LfZl
+  dQ5YMB0GA1UdDgQWBBR18CAeMsIEU+0pXal/XXw9LCtMADAOBgNVHQ8BAf8EBAMC
+  B4AwEwYDVR0lBAwwCgYIKwYBBQUHAwMwdwYDVR0fBHAwbjA1oDOgMYYvaHR0cDov
+  L2NybDMuZGlnaWNlcnQuY29tL3NoYTItYXNzdXJlZC1jcy1nMS5jcmwwNaAzoDGG
+  L2h0dHA6Ly9jcmw0LmRpZ2ljZXJ0LmNvbS9zaGEyLWFzc3VyZWQtY3MtZzEuY3Js
+  MEwGA1UdIARFMEMwNwYJYIZIAYb9bAMBMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8v
+  d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwCAYGZ4EMAQQBMIGEBggrBgEFBQcBAQR4MHYw
+  JAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBOBggrBgEFBQcw
+  AoZCaHR0cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL0RpZ2lDZXJ0U0hBMkFzc3Vy
+  ZWRJRENvZGVTaWduaW5nQ0EuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQEL
+  BQADggEBAFpzR9s7lcYKDzSJucOHztEPj+iSIeCzxEw34NTE9M2AfkYIu82c4r2a
+  bzIGmzZWiCGufjOp0gF5xW6sSSJ9n0TqH0nhHhvjtZQkmkGtOBbN1zeYDFS2ozAp
+  sljF/g68Y1eYs3NaFf7kQUa6vb6RdjW3J8M9AQ8gthBt7gr/guVxd/gJUYbdDdBX
+  cWfJJi/X7GVBOBmmvA43qoKideuhOBrVGBHvIF/yO9p23dIiUrGmW9kxXCSxgute
+  JI/W23RbIRksG2pioMhd4dCXq3FLLlkOV1YfCwWixNB+iIhQPPZVaPNfgPhCn4Dt
+  DeGjje/qA4fkLtRmOtb9PUBq3ToRDE4=
   -----END CERTIFICATE-----
-date: 2019-08-27 00:00:00.000000000 Z
+date: 2020-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -172,6 +177,7 @@ files:
 - lib/rex/text/table.rb
 - lib/rex/text/unicode.rb
 - lib/rex/text/version.rb
+- lib/rex/text/wrapped_table.rb
 - lib/rex/text/xor.rb
 - rex-text.gemspec
 homepage: https://github.com/rapid7/rex-text
@@ -193,7 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.7.10
 signing_key: 
 specification_version: 4
 summary: Provides Text Manipulation Methods for Exploitation