ronin-support 0.5.1 → 1.0.0.beta1

data/lib/ronin/support/encoding/ruby/core_ext/string.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# Ronin Support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Ronin Support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with Ronin Support.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/encoding/ruby'
+
+class String
+
+  #
+  # Escapes a String for Ruby.
+  #
+  # @return [String]
+  #   The Ruby escaped String.
+  #
+  # @example
+  #   "hello\nworld\n".ruby_escape
+  #   # => "hello\\nworld\\n"
+  #
+  # @see Ronin::Support::Encoding::Ruby.escape
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def ruby_escape
+    Ronin::Support::Encoding::Ruby.escape(self)
+  end
+
+  alias escape ruby_escape
+
+  #
+  # Unescapes a Ruby escaped String.
+  #
+  # @return [String]
+  #   The unescaped Ruby String.
+  #
+  # @example
+  #   "\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64".ruby_unescape
+  #   # => "hello world"
+  #
+  # @see Ronin::Support::Encoding::Ruby.unescape
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def ruby_unescape
+    Ronin::Support::Encoding::Ruby.unescape(self)
+  end
+
+  alias unescape ruby_unescape
+
+  #
+  # Ruby escapes every character in the String.
+  #
+  # @return [String]
+  #   The Ruby escaped String.
+  #
+  # @example
+  #   "hello".ruby_encode
+  #   # => "\\x68\\x65\\x6c\\x6c\\x6f"
+  #
+  # @see Ronin::Support::Encoding::Ruby.encode
+  #
+  # @api public
+  #
+  # @since 1.0.0
+  #
+  def ruby_encode
+    Ronin::Support::Encoding::Ruby.encode(self)
+  end
+
+  alias ruby_decode ruby_unescape
+
+  #
+  # Rubyonverts the String into a Ruby string.
+  #
+  # @return [String]
+  #
+  # @example
+  #   "hello\nworld\n".ruby_string
+  #   # => "\"hello\\nworld\\n\""
+  #
+  # @see Ronin::Support::Encoding::Ruby.quote
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def ruby_string
+    Ronin::Support::Encoding::Ruby.quote(self)
+  end
+
+  #
+  # Removes the quotes an unescapes a Ruby string.
+  #
+  # @return [String]
+  #   The un-quoted String if the String begins and ends with quotes, or the
+  #   same String if it is not quoted.
+  #
+  # @example
+  #   "\"hello\\nworld\"".ruby_unquote
+  #   # => "hello\nworld"
+  #
+  # @see Ronin::Support::Encoding::Ruby.unquote
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def ruby_unquote
+    Ronin::Support::Encoding::Ruby.unquote(self)
+  end
+
+end

data/lib/ronin/{formatting/binary.rb → support/encoding/ruby/core_ext.rb}

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
 #
-# Copyright (c) 2006-2012 Hal Brodigan (postmodern.mod3 at gmail.com)
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
 #
-# This file is part of Ronin Support.
-#
-# Ronin Support is free software: you can redistribute it and/or modify
+# ronin-support is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Lesser General Public License as published
 # by the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Ronin Support is distributed in the hope that it will be useful,
+# ronin-support is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU Lesser General Public License for more details.
 #
 # You should have received a copy of the GNU Lesser General Public License
-# along with Ronin Support.  If not, see <http://www.gnu.org/licenses/>.
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
 #
 
-require 'ronin/formatting/extensions/binary'
+require 'ronin/support/encoding/ruby/core_ext/string'

data/lib/ronin/support/encoding/ruby.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'strscan'
+
+module Ronin
+  module Support
+    class Encoding < ::Encoding
+      #
+      # Contains methods for encoding/decoding escaping/unescaping Ruby strings.
+      #
+      # @api public
+      #
+      module Ruby
+        #
+        # Encodes a byte as a Ruby escaped character.
+        #
+        # @param [Integer] byte
+        #   The byte value to encode.
+        #
+        # @return [String]
+        #   The escaped Ruby character.
+        #
+        # @example
+        #   Encoding::Ruby.encode_byte(0x41)
+        #   # => "\\x41"
+        #   Encoding::Ruby.encode_byte(0x100)
+        #   # => "\\u100"
+        #   Encoding::Ruby.encode_byte(0x10000)
+        #   # => "\\u{10000}"
+        #
+        def self.encode_byte(byte)
+          if byte >= 0x00 && byte <= 0xff
+            "\\x%.2X" % byte
+          elsif byte >= 0x100 && byte <= 0xffff
+            "\\u%.4X" % byte
+          elsif byte >= 0x10000 && byte <= 0x10ffff
+            "\\u{%.X}" % byte
+          else
+            raise(RangeError,"#{byte.inspect} out of char range")
+          end
+        end
+
+        #
+        # Escapes a byte as a Ruby character.
+        #
+        # @param [Integer] byte
+        #   The byte value to escape.
+        #
+        # @return [String]
+        #   The escaped Ruby character.
+        #
+        # @raise [RangeError]
+        #   The byte value isn't a valid ASCII or UTF byte.
+        #
+        def self.escape_byte(byte)
+          char = if byte >= 0x00 && byte <= 0xff
+                   byte.chr
+                 else
+                   byte.chr(Encoding::UTF_8)
+                 end
+
+          return char.dump[1..-2]
+        end
+
+        #
+        # Encodes each byte of the given data as a Ruby escaped character.
+        #
+        # @param [String] data
+        #   The given data to encode.
+        #
+        # @return [String]
+        #   The encoded Ruby String.
+        #
+        # @example
+        #   Encoding::Ruby.encode("hello")
+        #   # => "\\x68\\x65\\x6c\\x6c\\x6f"
+        #
+        def self.encode(data)
+          encoded = String.new
+
+          if data.valid_encoding?
+            data.each_codepoint do |codepoint|
+              encoded << encode_byte(codepoint)
+            end
+          else
+            data.each_byte do |byte|
+              encoded << encode_byte(byte)
+            end
+          end
+
+          return encoded
+        end
+
+        #
+        # Decodes the Ruby encoded data.
+        #
+        # @param [String] data
+        #   The given Ruby data to decode.
+        #
+        # @return [String]
+        #   The decoded data.
+        #
+        # @see unescape
+        #
+        def self.decode(data)
+          unescape(data)
+        end
+
+        #
+        # Escapes the Ruby string.
+        #
+        # @param [String] data
+        #   The data to escape.
+        #
+        # @return [String]
+        #   The Ruby escaped String.
+        #
+        def self.escape(data)
+          data.dump[1..-2]
+        end
+
+        # Common escaped characters.
+        UNESCAPE_CHARS = Hash.new do |hash,char|
+          if char[0] == '\\' then char[1]
+          else                    char
+          end
+        end
+        UNESCAPE_CHARS['\0'] = "\0"
+        UNESCAPE_CHARS['\a'] = "\a"
+        UNESCAPE_CHARS['\b'] = "\b"
+        UNESCAPE_CHARS['\t'] = "\t"
+        UNESCAPE_CHARS['\n'] = "\n"
+        UNESCAPE_CHARS['\v'] = "\v"
+        UNESCAPE_CHARS['\f'] = "\f"
+        UNESCAPE_CHARS['\r'] = "\r"
+
+        #
+        # Unescapes the escaped String.
+        #
+        # @param [String] data
+        #   The given Ruby escaped data.
+        #
+        # @return [String]
+        #   The unescaped version of the hex escaped String.
+        #
+        # @example
+        #   Encoding::Ruby.unescape("\\x68\\x65\\x6c\\x6c\\x6f")
+        #   # => "hello"
+        #
+        def self.unescape(data)
+          unescaped = String.new
+          scanner   = StringScanner.new(data)
+
+          until scanner.eos?
+            unescaped << if (unicode_escape = scanner.scan(/\\(?:[0-7]{1,3}|[0-7])/))
+                           unicode_escape[1,3].to_i(8).chr
+                         elsif (hex_escape = scanner.scan(/\\u[0-9a-fA-F]{4,8}/))
+                           hex_escape[2..-1].to_i(16).chr(Encoding::UTF_8)
+                         elsif (hex_escape = scanner.scan(/\\x[0-9a-fA-F]{1,2}/))
+                           hex_escape[2..-1].to_i(16).chr
+                         elsif (escape = scanner.scan(/\\./))
+                           UNESCAPE_CHARS[escape]
+                         else
+                           scanner.getch
+                         end
+          end
+
+          return unescaped
+        end
+
+        #
+        # Escapes and quotes the given data as a Ruby string.
+        #
+        # @param [String] data
+        #   The given data to escape and quote.
+        #
+        # @return [String]
+        #   The quoted Ruby string.
+        #
+        # @example
+        #   Encoding::Ruby.quote("hello\nworld\n")
+        #   # => "\"hello\\nworld\\n\""
+        #
+        def self.quote(data)
+          data.dump
+        end
+
+        #
+        # Removes the quotes an unescapes a quoted string.
+        #
+        # @param [String] data
+        #   The given Ruby string.
+        #
+        # @return [String]
+        #   The un-quoted String if the String begins and ends with quotes, or
+        #   the same String if it is not quoted.
+        #
+        # @example
+        #   Encoding::Ruby.unquote("\"hello\\nworld\"")
+        #   # => "hello\nworld"
+        #   Encoding::Ruby.unquote("'hello\\'world'")
+        #   # => "hello'world"
+        #
+        def self.unquote(data)
+          if (data[0] == '"' && data[-1] == '"')
+            unescape(data[1..-2])
+          elsif (data[0] == "'" && data[-1] == "'")
+            data[1..-2].gsub(/\\(['\\])/,'\1')
+          else
+            data
+          end
+        end
+
+      end
+    end
+  end
+end
+
+require 'ronin/support/encoding/ruby/core_ext'

data/lib/ronin/support/encoding/shell/core_ext/integer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/encoding/shell'
+
+class Integer
+
+  #
+  # Encodes the Integer as a shell character.
+  #
+  # @return [String]
+  #   The encoded shell character.
+  #
+  # @raise [RangeError]
+  #   The integer value is negative.
+  #
+  # @example 
+  #   0x41.shell_encode
+  #   # => "\\x41"
+  #   0x0a.shell_encode
+  #   # => "\\n"
+  #
+  # @example Encoding unicode characters:
+  #   1001.shell_encode
+  #   # => "\\u1001"
+  #
+  # @see Ronin::Support::Encoding::Shell.encode_byte
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def shell_encode
+    Ronin::Support::Encoding::Shell.encode_byte(self)
+  end
+
+  alias sh_encode shell_encode
+  alias bash_encode shell_encode
+
+  #
+  # Escapes the Integer as a shell character.
+  #
+  # @return [String]
+  #   The escaped shell character.
+  #
+  # @raise [RangeError]
+  #   The integer value is negative.
+  #
+  # @example 
+  #   0x41.shell_escape
+  #   # => "A"
+  #   0x08.shell_escape
+  #   # => "\b"
+  #   0xff.shell_escape
+  #   # => "\xff"
+  #
+  # @example Escaping unicode characters:
+  #   1001.shell_escape
+  #   # => "\\u1001"
+  #
+  # @see Ronin::Support::Encoding::Shell.escape_byte
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def shell_escape
+    Ronin::Support::Encoding::Shell.escape_byte(self)
+  end
+
+  alias sh_escape shell_escape
+  alias bash_escape shell_escape
+
+end

data/lib/ronin/support/encoding/shell/core_ext/string.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/encoding/shell'
+
+require 'strscan'
+
+class String
+
+  #
+  # Shell escapes the characters in the String.
+  #
+  # @return [String]
+  #   The shell escaped string.
+  #
+  # @example
+  #   "hello\nworld".shell_escape
+  #   # => "hello\\nworld"
+  #
+  # @see Ronin::Support::Encoding::Shell.escape
+  #
+  # @api public
+  #
+  # @since 1.0.0
+  #
+  def shell_escape
+    Ronin::Support::Encoding::Shell.escape(self)
+  end
+
+  #
+  # Shell unescapes the characters in the String.
+  #
+  # @return [String]
+  #   The shell unescaped string.
+  #
+  # @example
+  #   "hello\\nworld".shell_unescape
+  #   # => "hello\nworld"
+  #
+  # @see Ronin::Support::Encoding::Shell.unescape
+  #
+  # @api public
+  #
+  # @since 1.0.0
+  #
+  def shell_unescape
+    Ronin::Support::Encoding::Shell.unescape(self)
+  end
+
+  #
+  # Shell encodes every character in the String.
+  #
+  # @return [String]
+  #   The shell encoded String.
+  #
+  # @example
+  #   "hello world".shell_encode
+  #   # => "\\x68\\x65\\x6c\\x6c\\x6f\\x0a\\x77\\x6f\\x72\\x6c\\x64"
+  #
+  # @see Ronin::Support::Encoding::Shell.encode
+  #
+  # @api public
+  #
+  # @since 1.0.0
+  #
+  def shell_encode
+    Ronin::Support::Encoding::Shell.encode(self)
+  end
+
+  alias shell_decode shell_unescape
+
+  #
+  # Converts the String into a double-quoted shell escaped String.
+  #
+  # @return [String]
+  #   The quoted and escaped shell string.
+  #
+  # @example
+  #   "hello world".shell_string
+  #   # => "\"hello world\""
+  #   "hello\nworld".shell_string
+  #   # => "$'hello\\nworld'"
+  #
+  # @see Ronin::Support::Encoding::Shell.quote
+  #
+  # @api public
+  #
+  # @since 1.0.0
+  #
+  def shell_string
+    Ronin::Support::Encoding::Shell.quote(self)
+  end
+
+  #
+  # Removes the quotes an unescapes a shell string.
+  #
+  # @return [String]
+  #   The un-quoted String if the String begins and ends with quotes, or the
+  #   same String if it is not quoted.
+  #
+  # @example
+  #   "\"hello \\\"world\\\"\"".shell_unquote
+  #   # => "hello \"world\""
+  #   "'hello\\'world'".shell_unquote
+  #   # => "hello'world"
+  #   "$'hello\\nworld'".shell_unquote
+  #   # => "hello\nworld"
+  #
+  # @see Ronin::Support::Encoding::Shell.unquote
+  #
+  # @since 1.0.0
+  #
+  # @api public
+  #
+  def shell_unquote
+    Ronin::Support::Encoding::Shell.unquote(self)
+  end
+
+end

data/lib/ronin/support/encoding/shell/core_ext.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# ronin-support is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# ronin-support is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with ronin-support.  If not, see <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/support/encoding/shell/core_ext/integer'
+require 'ronin/support/encoding/shell/core_ext/string'