rex-bin_tools 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85f2c2e56b2c77ce653ecc847daf6dfe581229da3bd8161f4a8dd9b3fe80c3e4
-  data.tar.gz: 92f0b96645ef5db53e653986321d59ccf0e0b682ec515af14d3ac9c7a82c357c
+  metadata.gz: 8a00458801cfc7194ebfbbd76eea9c275ebf05a024366eccf3501f2de4b6cc80
+  data.tar.gz: e15ee4b3499407d8ab9567d2ac0741a13976695173de794527c904238eea1012
 SHA512:
-  metadata.gz: 0d2ff6b17415c6ae0ee09bbfecb88484bbead1e97845794b194513c172f40dacea85f7f74367a055a2de3ed22cbafbb88a53b6411ac7f9c5f1e1216dc5b2a0fe
-  data.tar.gz: b21bdc33cd0c60c3907e399b8910bf2b40497a9eb0c0c4a77051be4401d580211b0a4ccfa165b337676b29d3fc3f636df937ed08685bdec8614636b3aae1e786
+  metadata.gz: 4d1c25e07486cbe60112204add101f4c9266cdc505b3d000b82329e61ae5bf2bd048b5012a73a5e7880d6ef60074f4d0386df624c085c1e64561dd668ca5c1a3
+  data.tar.gz: f407afa35613d09973d41c1e08ef329a8f7b65640f2ea9d5efbd34b5fb41afe207ffdb0026fcc5cd3d4721faa41597b2eac7f6b885c308db37cd97557123acb3

data/lib/rex/bin_tools/version.rb

@@ -1,5 +1,5 @@
 module Rex
   module BinTools
-    VERSION = "0.1.12"
+    VERSION = "0.1.13"
   end
 end

data/lib/rex/elfscan/scanner.rb

@@ -75,9 +75,18 @@ class JmpRegScanner < Generic
       regexstr += "\xff[#{calls}]|"
     end
 
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
     regexstr += "\xff[#{jmps}]|([#{pushs1}]|\xff[#{pushs2}])(\xc3|\xc2..))"
-
-    self.regex = Regexp.new(regexstr, nil, 'n')
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = regexstr.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(regexstr, nil, 'n')
+    end
   end
 
   # build a list for regex of the possible bytes, based on a base
@@ -156,7 +165,18 @@ class PopPopRetScanner < JmpRegScanner
 
   def config(param)
     pops = _build_byte_list(0x58, (0 .. 7).to_a - [4]) # we don't want pop esp's...
-    self.regex = Regexp.new("[#{pops}][#{pops}](\xc3|\xc2..)", nil, 'n')
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
+    pattern = "[#{pops}][#{pops}](\xc3|\xc2..)"
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = pattern.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(pattern, nil, 'n')
+    end
   end
 
   def scan_segment(program_header, param={})
@@ -191,7 +211,18 @@ end
 class RegexScanner < JmpRegScanner
 
   def config(param)
-    self.regex = Regexp.new(param['args'], nil, 'n')
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
+    pattern = param['args']
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = pattern.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(pattern, nil, 'n')
+    end
   end
 
   def scan_segment(program_header, param={})

data/lib/rex/machscan/scanner.rb

@@ -64,9 +64,18 @@ class JmpRegScanner < Generic
         regexstr += "\xff[#{calls}]|"
     end
 
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
     regexstr += "\xff[#{jmps}]|([#{pushs1}]|\xff[#{pushs2}])(\xc3|\xc2..))"
-
-    self.regex = Regexp.new(regexstr, nil, 'n')
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = regexstr.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(regexstr, nil, 'n')
+    end
   end
 
   # build a list for regex of the possible bytes, based on a base
@@ -145,7 +154,18 @@ class PopPopRetScanner < JmpRegScanner
 
   def config(param)
     pops = _build_byte_list(0x58, (0 .. 7).to_a - [4]) # we don't want pop esp's...
-    self.regex = Regexp.new("[#{pops}][#{pops}](\xc3|\xc2..)", nil, 'n')
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
+    pattern = "[#{pops}][#{pops}](\xc3|\xc2..)"
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = pattern.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(pattern, nil, 'n')
+    end
   end
 
   def scan_segment(segment, param={})
@@ -181,7 +201,18 @@ end
 class RegexScanner < JmpRegScanner
 
   def config(param)
-    self.regex = Regexp.new(param['args'], nil, 'n')
+    # Adapting to Regexp.new's New Signature in Ruby 3.3+
+    pattern = param['args']
+    # Choose initialization method based on Ruby version
+    major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+    self.regex = if (major > 3) || (major == 3 && minor >= 3)
+      # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+      binary_pattern = pattern.b
+      Regexp.new(binary_pattern, Regexp::NOENCODING)
+    else
+      # For Ruby <= 3.2: use legacy three-argument syntax
+      Regexp.new(pattern, nil, 'n')
+    end
   end
 
   def scan_segment(segment, param={})

data/lib/rex/pescan/analyze.rb

@@ -59,9 +59,21 @@ module Analyze
 
       @sigs.each_pair do |name, data|
         begin
-        if (buf.match(Regexp.new('^' + data[0], nil, 'n')))
-          $stdout.puts param['file'] + ": " + name
-        end
+          # Adapting to Regexp.new's New Signature in Ruby 3.3+
+          pattern = '^' + data[0]
+          # Choose initialization method based on Ruby version
+          major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+          regex = if (major > 3) || (major == 3 && minor >= 3)
+            # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+            binary_pattern = pattern.b
+            Regexp.new(binary_pattern, Regexp::NOENCODING)
+          else
+            # For Ruby <= 3.2: use legacy three-argument syntax
+            Regexp.new(pattern, nil, 'n')
+          end
+          if (buf.match(regex))
+            $stdout.puts param['file'] + ": " + name
+          end
         rescue RegexpError
           $stderr.puts "Invalid signature: #{name} #{data[0]}"
         end

data/lib/rex/pescan/scanner.rb

@@ -80,9 +80,18 @@ module Scanner
         regexstr += "\xff[#{calls}]|"
       end
 
+      # Adapting to Regexp.new's New Signature in Ruby 3.3+
       regexstr += "\xff[#{jmps}]|([#{pushs1}]|\xff[#{pushs2}])(\xc3|\xc2..))"
-
-      self.regex = Regexp.new(regexstr, nil, 'n')
+      # Choose initialization method based on Ruby version
+      major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+      self.regex = if (major > 3) || (major == 3 && minor >= 3)
+        # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+        binary_pattern = regexstr.b
+        Regexp.new(binary_pattern, Regexp::NOENCODING)
+      else
+        # For Ruby <= 3.2: use legacy three-argument syntax
+        Regexp.new(regexstr, nil, 'n')
+      end
     end
 
     # build a list for regex of the possible bytes, based on a base
@@ -161,7 +170,18 @@ module Scanner
 
     def config(param)
       pops = _build_byte_list(0x58, (0 .. 7).to_a - [4]) # we don't want pop esp's...
-      self.regex = Regexp.new("[#{pops}][#{pops}](\xc3|\xc2..)", nil, 'n')
+      # Adapting to Regexp.new's New Signature in Ruby 3.3+
+      pattern = "[#{pops}][#{pops}](\xc3|\xc2..)"
+      # Choose initialization method based on Ruby version
+      major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+      self.regex = if (major > 3) || (major == 3 && minor >= 3)
+        # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+        binary_pattern = pattern.b
+        Regexp.new(binary_pattern, Regexp::NOENCODING)
+      else
+        # For Ruby <= 3.2: use legacy three-argument syntax
+        Regexp.new(pattern, nil, 'n')
+      end
     end
 
     def scan_section(section, param={})
@@ -195,7 +215,18 @@ module Scanner
   class RegexScanner < Generic
 
     def config(param)
-      self.regex = Regexp.new(param['args'], nil, 'n')
+      # Adapting to Regexp.new's New Signature in Ruby 3.3+
+      pattern = param['args']
+      # Choose initialization method based on Ruby version
+      major, minor, _patch = RUBY_VERSION.split('.').map(&:to_i)
+      self.regex = if (major > 3) || (major == 3 && minor >= 3)
+        # For Ruby 3.3+: explicitly mark as binary pattern and use NOENCODING
+        binary_pattern = pattern.b
+        Regexp.new(binary_pattern, Regexp::NOENCODING)
+      else
+        # For Ruby <= 3.2: use legacy three-argument syntax
+        Regexp.new(pattern, nil, 'n')
+      end
     end
 
     def scan_section(section, param={})

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rex-bin_tools
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Metasploit Hackers
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-07-10 00:00:00.000000000 Z
+date: 2026-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake