rex-text 0.2.46 → 0.2.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95af94249afe1b19de73e1090346169a280f87a8d3519838983630fb7e1cf69d
-  data.tar.gz: '06227846a02fc5b531e89b8114e17611a474ae231e3913adc1c2de72b53343c6'
+  metadata.gz: 4e3ab248f34fa3b7917bad07015868aebb7e91af8af1a210fa90cb89da7b8edc
+  data.tar.gz: 853d7652f999e24504754ad1416faed2a68377c0c29e4d74ff1189b2c7194f01
 SHA512:
-  metadata.gz: da78d18313b0d2c43819df1c2f812fe4e0b90ba8d1b47f8ab8beabe1025014e77c1c4651b9c9e25047bfdd52b7260ac872727dc0dd6d157129ade62d62c86aee
-  data.tar.gz: 92ee63cde2940b9eafe27264087f97210dfdd368754f4c84905c4b941590b0c28083c01b6b5f22d3110de8d9b2bb78f6dd42255432e762af07c95bffb3da215a
+  metadata.gz: 5d49ba31b089bc450704c14d0d93f5b2a5c40519c4d324474fa6f8c27faacb8808f71c9f36f9c8baa519084b9f20e39b9569868504d061c422fa65fc3ed1e94e
+  data.tar.gz: a11d6dbc2323b7e9e0aa92aa7bbdf8b67a2cbc1329ff637e4a4cfd047191ea347c58ae40bb6a5f0a4cfc614cf6e7c3561e9de629c1172e18c930534cdf5a7f25

data/.github/workflows/verify.yml

@@ -33,15 +33,16 @@ jobs:
       fail-fast: true
       matrix:
         ruby:
-          - 2.7
-          - 3.0
-          - 3.1
+          - '2.7'
+          - '3.0'
+          - '3.1'
+          - '3.2'
         os:
           - ubuntu-20.04
           - ubuntu-latest
         exclude:
-          - { os: ubuntu-latest, ruby: 2.7 }
-          - { os: ubuntu-latest, ruby: 3.0 }
+          - { os: ubuntu-latest, ruby: '2.7' }
+          - { os: ubuntu-latest, ruby: '3.0' }
         test_cmd:
           - bundle exec rspec
 

data/lib/rex/text/hex.rb

@@ -127,22 +127,13 @@ 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 = '')
-      if col < line_start.length + 4 + line_end.length
-        # raise an exception
-        raise ArgumentError.new('insufficient column width')
-      end
+      self.hexify_general(str, "\\x", col, line_start, line_end, buf_start, buf_end)
+    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
-        ret << "\\x" << char.unpack('H*')[0]
-      end
-      ret << "\n" if ret.split("\n").last.length + buf_end.length > col
-      ret << "#{buf_end}\n"
+    #
+    # Converts a string to hex, with each character prefixed with 0x; with wrapping support
+    def self.numhexify(str, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '', between = '')
+      self.hexify_general(str, "0x", col, line_start, line_end, buf_start, buf_end, between)
     end
 
     #
@@ -175,5 +166,35 @@ module Rex
       str.gsub!(regex) { |x| x[2,2].to_i(16).chr }
     end
 
+    private
+
+    #
+    # General-case method to handle both "\xAA\xBB\xCC" format and 0xAA,0xBB,0xCC format
+    #
+    def self.hexify_general(str, char_prefix, col = DefaultWrap, line_start = '', line_end = '', buf_start = '', buf_end = '', between='')
+      encoded_char_length = 2 + char_prefix.length + between.length
+      if col < line_start.length + encoded_char_length + line_end.length
+        # raise an exception
+        raise ArgumentError.new('insufficient column width')
+      end
+
+      ret = buf_start.dup
+      ret << line_start if ret.end_with?("\n")
+      last_newline = ret.rindex("\n") || -1
+      last_line_length = ret.length - last_newline - 1
+      str.each_char do |char|
+        # Check if we're going over the wrap boundary
+        if last_line_length + encoded_char_length + line_end.length > col
+          ret << "#{line_end}\n#{line_start}"
+          last_line_length = line_start.length
+        end
+        ret << char_prefix << char.unpack('H*')[0] << between
+        last_line_length += encoded_char_length
+      end
+      # Remove the last in-between characters, if required
+      ret = ret[0..ret.length - 1 - between.length] unless str.empty?
+      ret << "\n" if last_line_length + buf_end.length > col
+      ret << "#{buf_end}\n"
+    end
   end
 end

data/lib/rex/text/lang.rb

@@ -28,30 +28,14 @@ module Rex
     end
 
     def self.to_csharp(str, wrap = DefaultWrap, name = "buf")
-      ret = "byte[] #{name} = new byte[#{str.length}] {"
-      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] unless str.empty? # cut off last comma
-      ret << "\n" if ret.split("\n").last.length + 2 > wrap
-      ret << "};\n"
+      return numhexify(str, wrap, '', '',  "byte[] #{name} = new byte[#{str.length}] {", "};", ',')
     end
 
     #
     # Converts to a golang style array of bytes
     #
     def self.to_golang(str, wrap = DefaultWrap, name = "buf")
-      ret = "#{name} :=  []byte{"
-      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] unless str.empty? # cut off last comma
-      ret << "\n" if ret.split("\n").last.length + 2 > wrap
-      ret << "};\n"
+      return numhexify(str, wrap, '', '',  "#{name} :=  []byte{", "};", ',')
     end
 
     #
@@ -66,17 +50,7 @@ module Rex
     #
     def self.to_nim(str, wrap = DefaultWrap, name = "buf")
       raise ArgumentError.new('str can not be empty') if str.empty?
-
-      ret = "var #{name}: array[#{str.length}, byte] = [\n"
-      ret << "byte "
-      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] unless str.empty? # cut off last comma
-      ret << "\n" if ret.split("\n").last.length + 1 > wrap
-      ret << "]\n"
+      return numhexify(str, wrap, '', '',  "var #{name}: array[#{str.length}, byte] = [\nbyte ", "]", ',')
     end
 
     #
@@ -90,15 +64,7 @@ module Rex
     # Converts to a Rust style array of bytes
     #
     def self.to_rust(str, wrap = DefaultWrap, name = "buf")
-      ret = "let #{name}: [u8; #{str.length}] = ["
-      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] unless str.empty? # cut off last comma
-      ret << "\n" if ret.split("\n").last.length + 2 > wrap
-      ret << "];\n"
+      return numhexify(str, wrap, '', '',  "let #{name}: [u8; #{str.length}] = [", "];", ',')
     end
     
     #

data/lib/rex/text/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module Text
-    VERSION = "0.2.46"
+    VERSION = "0.2.48"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rex-text
 version: !ruby/object:Gem::Version
-  version: 0.2.46
+  version: 0.2.48
 platform: ruby
 authors:
 - Metasploit Hackers
@@ -93,7 +93,7 @@ cert_chain:
   EknWpNgVhohbot1lfVAMmIhdtOVaRVcQQixWPwprDj/ydB8ryDMDosIMcw+fkoXU
   9GJsSaSRRYQ9UUkVL27b64okU8D48m8=
   -----END CERTIFICATE-----
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2023-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -185,8 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.10
+rubygems_version: 3.3.26
 signing_key: 
 specification_version: 4
 summary: Provides Text Manipulation Methods for Exploitation