ronin-support 0.5.0 → 0.5.1

data/lib/ronin/formatting/extensions/binary/float.rb

@@ -31,7 +31,8 @@ class Float
   #   The packed float.
   #
   # @raise [ArgumentError]
-  #   The argument was not a String code or a Symbol.
+  #   The given Symbol could not be found in
+  #   {Ronin::Binary::Template::FLOAT_TYPES}.
   #
   # @example using `Array#pack` template:
   #   0.42.pack('F')
@@ -42,6 +43,7 @@ class Float
   #   # => ">\xD7\n="
   #
   # @see http://rubydoc.info/stdlib/core/Array:pack
+  # @see Ronin::Binary::Template
   #
   # @since 0.5.0
   #
@@ -51,14 +53,12 @@ class Float
     case argument
     when String
       [self].pack(argument)
-    when Symbol
+    else
       unless Ronin::Binary::Template::FLOAT_TYPES.include?(argument)
         raise(ArgumentError,"unsupported integer type: #{argument}")
       end
 
       [self].pack(Ronin::Binary::Template::TYPES[argument])
-    else
-      raise(ArgumentError,"argument must be a String or a Symbol")
     end
   end
 

data/lib/ronin/formatting/extensions/binary/integer.rb

@@ -98,7 +98,8 @@ class Integer
   #   The packed Integer.
   #
   # @raise [ArgumentError]
-  #   The arguments were not a String, Symbol or Architecture object.
+  #   The given Symbol could not be found in
+  #   {Ronin::Binary::Template::INT_TYPES}.
   #
   # @example using a `Array#pack` template:
   #   0x41.pack('V')
@@ -122,22 +123,22 @@ class Integer
   #   # => "\0A"
   #
   # @see http://rubydoc.info/stdlib/core/Array:pack
+  # @see Ronin::Binary::Template
   #
   # @api public
   #
   def pack(*arguments)
-    argument = arguments.first
-
-    case argument
-    when String
-      [self].pack(argument)
-    when Symbol
-      unless Ronin::Binary::Template::INT_TYPES.include?(argument)
-        raise(ArgumentError,"unsupported integer type: #{argument}")
+    if (arguments.length == 1 && arguments.first.kind_of?(String))
+      [self].pack(arguments.first)
+    elsif (arguments.length == 1 && arguments.first.kind_of?(Symbol))
+      type = arguments.first
+
+      unless Ronin::Binary::Template::INT_TYPES.include?(type)
+        raise(ArgumentError,"unsupported integer type: #{type}")
       end
 
-      [self].pack(Ronin::Binary::Template::TYPES[argument])
-    else
+      [self].pack(Ronin::Binary::Template::TYPES[type])
+    elsif (arguments.length == 1 || arguments.length == 2)
       # TODO: deprecate this calling convention
       arch, address_length = arguments
 
@@ -155,6 +156,8 @@ class Integer
       integer_bytes.map! { |b| b.chr }
 
       return integer_bytes.join
+    else
+      raise(ArgumentError,"wrong number of arguments (#{arguments.length} for 1..2)")
     end
   end
 

data/lib/ronin/formatting/extensions/binary/string.rb

@@ -36,14 +36,14 @@ class String
   #
   # Unpacks the String.
   #
-  # @param [String, Array<Symbol>] arguments
+  # @param [String, Array<Symbol, (Symbol, Integer)>] arguments
   #   The `String#unpack` template or a list of {Ronin::Binary::Template} types.
   #
   # @return [Array]
   #   The values unpacked from the String.
   #
   # @raise [ArgumentError]
-  #   The arguments were not a String or a list of Symbols.
+  #   One of the arguments was not a known {Ronin::Binary::Template} type.
   #
   # @example using {Ronin::Binary::Template} types:
   #   "A\0\0\0hello\0".unpack(:uint32_le, :string)
@@ -54,19 +54,17 @@ class String
   #   # => 65
   #
   # @see http://rubydoc.info/stdlib/core/String:unpack
+  # @see Ronin::Binary::Template
   #
   # @since 0.5.0
   #
   # @api public
   #
   def unpack(*arguments)
-    case arguments.first
-    when String
+    if (arguments.length == 1 && arguments.first.kind_of?(String))
       unpack_original(arguments.first)
-    when Symbol
-      unpack_original(Ronin::Binary::Template.compile(arguments))
     else
-      raise(ArgumentError,"first argument to String#unpack must be a String or Symbol")
+      unpack_original(Ronin::Binary::Template.compile(arguments))
     end
   end
 
@@ -190,12 +188,9 @@ class String
   #
   def xor(key)
     key = case key
-          when Integer
-            [key]
-          when String
-            key.bytes
-          else
-            key
+          when Integer then [key]
+          when String  then key.bytes
+          else              key
           end
 
     key    = key.cycle
@@ -229,12 +224,9 @@ class String
   #
   def base64_encode(mode=nil)
     case mode
-    when :strict
-      Base64.strict_encode64(self)
-    when :url, :urlsafe
-      Base64.urlsafe_encode64(self)
-    else
-      Base64.encode64(self)
+    when :strict        then Base64.strict_encode64(self)
+    when :url, :urlsafe then Base64.urlsafe_encode64(self)
+    else                     Base64.encode64(self)
     end
   end
 
@@ -262,12 +254,9 @@ class String
   #
   def base64_decode(mode=nil)
     case mode
-    when :strict
-      Base64.strict_decode64(self)
-    when :url, :urlsafe
-      Base64.urlsafe_decode64(self)
-    else
-      Base64.decode64(self)
+    when :strict        then Base64.strict_decode64(self)
+    when :url, :urlsafe then Base64.urlsafe_decode64(self)
+    else                     Base64.decode64(self)
     end
   end
 

data/lib/ronin/formatting/extensions/html/integer.rb

@@ -114,10 +114,8 @@ class Integer
   # @api public
   #
   def js_escape
-    if self > 0xff
-      format_js
-    else
-      JS_ESCAPE_BYTES.fetch(self,chr)
+    if self > 0xff then format_js
+    else                JS_ESCAPE_BYTES.fetch(self,chr)
     end
   end
 
@@ -136,10 +134,8 @@ class Integer
   # @api public
   #
   def format_js
-    if self > 0xff
-      "\\u%.2X%.2X" % [(self & 0xff00) >> 8, (self & 0xff)]
-    else
-      "\\x%.2X" % self
+    if self > 0xff then "\\u%.4X" % self
+    else                "\\x%.2X" % self
     end
   end
 

data/lib/ronin/formatting/extensions/html/string.rb

@@ -26,11 +26,11 @@ class String
 
   # JavaScript characters that must be back-slashed.
   JS_BACKSLASHED_CHARS = {
-    "\\b" => "\b",
-    "\\t" => "\t",
-    "\\n" => "\n",
-    "\\f" => "\f",
-    "\\r" => "\r",
+    "\\b"  => "\b",
+    "\\t"  => "\t",
+    "\\n"  => "\n",
+    "\\f"  => "\f",
+    "\\r"  => "\r",
     "\\\"" => "\"",
     "\\\\" => "\\"
   }
@@ -95,11 +95,9 @@ class String
   # @api public
   #
   def format_html(options={})
-    formatter = if RUBY_VERSION < '1.9.'
-                  # String#ord was not backported to Ruby 1.8.7
-                  lambda { |c| c[0].format_html }
-                else
-                  lambda { |c| c.ord.format_html }
+    # String#ord was not backported to Ruby 1.8.7
+    formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].format_html  }
+                else                          lambda { |c| c.ord.format_html }
                 end
 
     format_chars(options,&formatter)
@@ -125,11 +123,9 @@ class String
   # @api public
   #
   def js_escape(options={})
-    formatter = if RUBY_VERSION < '1.9.'
-                  # String#ord was not backported to Rub 1.8.7
-                  lambda { |c| c[0].js_escape }
-                else
-                  lambda { |c| c.ord.js_escape }
+    # String#ord was not backported to Rub 1.8.7
+    formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].js_escape  }
+                else                          lambda { |c| c.ord.js_escape }
                 end
 
     format_chars(options,&formatter)
@@ -152,18 +148,16 @@ class String
   def js_unescape
     unescaped = ''
 
-    scan(/([\\%]u[0-9a-fA-F]{1,4}|[\\%][0-9a-fA-F]{1,2}|\\[btnfr"\\]|.)/).each do |match|
-      c = match[0]
-
-      unescaped << if JS_BACKSLASHED_CHARS.has_key?(c)
-                     JS_BACKSLASHED_CHARS[c]
-                   elsif (c.start_with?("\\u") || c.start_with?("%u"))
-                     c[2..-1].to_i(16)
-                   elsif (c.start_with?("\\") || c.start_with?("%"))
-                     c[1..-1].to_i(16)
-                   else
-                     c
-                   end
+    scan(/[\\%]u[0-9a-fA-F]{1,4}|[\\%][0-9a-fA-F]{1,2}|\\[btnfr"\\]|./) do |c|
+      unescaped << JS_BACKSLASHED_CHARS.fetch(c) do
+        if (c.start_with?("\\u") || c.start_with?("%u"))
+          c[2..-1].to_i(16)
+        elsif (c.start_with?("\\") || c.start_with?("%"))
+          c[1..-1].to_i(16)
+        else
+          c
+        end
+      end
     end
 
     return unescaped
@@ -189,11 +183,9 @@ class String
   # @api public
   #
   def format_js(options={})
-    formatter = if RUBY_VERSION < '1.9.'
-                  # String#ord was not backported to Rub 1.8.7
-                  lambda { |c| c[0].format_js }
-                else
-                  lambda { |c| c.ord.format_js }
+    # String#ord was not backported to Rub 1.8.7
+    formatter = if RUBY_VERSION < '1.9.' then lambda { |c| c[0].format_js  }
+                else                          lambda { |c| c.ord.format_js }
                 end
 
     format_chars(options,&formatter)

data/lib/ronin/formatting/extensions/sql/string.rb

@@ -40,10 +40,8 @@ class String
   #
   def sql_escape(quotes=:single)
     case quotes
-    when :single
-      "'#{gsub(/'/,"''")}'"
-    when :double
-      "\"#{gsub(/"/,'""')}\""
+    when :single then "'#{gsub(/'/,"''")}'"
+    when :double then "\"#{gsub(/"/,'""')}\""
     else
       raise(ArgumentError,"invalid quoting style #{quotes.inspect}")
     end
@@ -80,16 +78,16 @@ class String
   #  # => "/etc/passwd"
   #
   def sql_decode
-    if ((self[0...2] == '0x') && (length % 2 == 0))
+    if (start_with?('0x') && (length % 2 == 0))
       raw = ''
 
-      self[2..-1].scan(/[0-9a-fA-F]{2}/).each do |hex_char|
-        raw << hex_char.hex.chr
+      self[2..-1].scan(/../) do |hex_char|
+        raw << hex_char.to_i(16).chr
       end
 
       return raw
-    elsif (self[0..0] == "'" && self[-1..-1] == "'")
-      self[1..-2].gsub("\\'","'").gsub("''","'")
+    elsif (start_with?("'") && end_with?("'"))
+      self[1..-2].gsub(/\\'|''/,"'")
     else
       return self
     end
@@ -119,10 +117,8 @@ class String
   #
   def sql_inject
     if (start_with?("'") || start_with?('"') || start_with?('`'))
-      if self[0,1] == self[-1,1]
-        self[1..-2]
-      else
-        "#{self[1..-1]}--"
+      if self[0,1] == self[-1,1] then self[1..-2]
+      else                            "#{self[1..-1]}--"
       end
     else
       self

data/lib/ronin/formatting/extensions/text/array.rb

@@ -40,10 +40,12 @@ class Array
     bytes = []
 
     each do |element|
-      if element.kind_of?(Integer)
-        bytes << element
+      case element
+      when Integer then bytes << element
       else
-        element.to_s.each_byte { |b| bytes << b }
+        element.to_s.each_byte do |b|
+          bytes << b
+        end
       end
     end
 
@@ -65,8 +67,8 @@ class Array
   #
   def chars
     array_bytes = bytes
-
     array_bytes.map! { |b| b.chr }
+
     return array_bytes
   end
 
@@ -103,8 +105,8 @@ class Array
   #
   def hex_chars
     array_bytes = bytes
-    
     array_bytes.map! { |b| '\x%x' % b }
+
     return array_bytes
   end
 
@@ -127,8 +129,8 @@ class Array
   #
   def hex_integers
     array_bytes = bytes
-    
     array_bytes.map! { |b| '0x%x' % b }
+
     return array_bytes
   end
 

data/lib/ronin/formatting/extensions/text/string.rb

@@ -99,10 +99,8 @@ class String
     formatted = ''
 
     matches = lambda { |filter,c|
-      if filter.respond_to?(:include?)
-        filter.include?(c)
-      elsif filter.kind_of?(Regexp)
-        c =~ filter
+      if    filter.respond_to?(:include?) then filter.include?(c)
+      elsif filter.kind_of?(Regexp)       then c =~ filter
       end
     }
 
@@ -143,10 +141,8 @@ class String
     prob = (options[:probability] || 0.5)
 
     format_chars(options) do |c|
-      if rand <= prob
-        c.swapcase 
-      else
-        c
+      if rand <= prob then c.swapcase 
+      else                 c
       end
     end
   end

data/lib/ronin/fuzzing/fuzzer.rb

@@ -48,21 +48,16 @@ module Ronin
         
         rules.each do |pattern,substitution|
           pattern = case pattern
-                    when Regexp
-                      pattern
-                    when String
-                      Regexp.new(Regexp.escape(pattern))
-                    when Symbol
-                      Regexp.const_get(pattern.to_s.upcase)
+                    when Regexp then pattern
+                    when String then Regexp.new(Regexp.escape(pattern))
+                    when Symbol then Regexp.const_get(pattern.to_s.upcase)
                     else
                       raise(TypeError,"cannot convert #{pattern.inspect} to a Regexp")
                     end
 
           substitution = case substitution
-                         when Enumerable
-                           substitution
-                         when Symbol
-                           Fuzzing[substitution]
+                         when Enumerable then substitution
+                         when Symbol     then Fuzzing[substitution]
                          else
                            raise(TypeError,"substitutions must be Enumerable or a Symbol")
                          end
@@ -97,12 +92,9 @@ module Ronin
           indices.each do |index,length|
             substitution.each do |substitute|
               substitute = case substitute
-                           when Proc
-                             substitute.call(string[index,length])
-                           when Integer
-                             substitute.chr
-                           else
-                             substitute.to_s
+                           when Proc    then substitute[string[index,length]]
+                           when Integer then substitute.chr
+                           else              substitute.to_s
                            end
 
               fuzzed = string.dup