ronin-support 0.2.0 → 0.3.0

data/lib/ronin/extensions/resolv.rb

@@ -0,0 +1,80 @@
+#
+# Copyright (c) 2006-2011 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
+# 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 'resolv'
+
+class Resolv
+
+  # List of valid Top-Level-Domains
+  TLDS = %w[
+    aero arpa asia biz cat com coop edu gov info int jobs mil mobi museum net
+    org pro tel travel xxx
+
+    ac ad ae af ag ai al am an ao aq ar as at au aw ax az
+    ba bb bd be bf bg bh bi bj bm bn bo br bs bt bv bw by bz
+    ca cc cd cf cg ch ci ck cl cm cn co cr cs cu cv cx cy cz
+    dd de dj dk dm do dz
+    ec ee eg eh er es et eu
+    fi fj fk fm fo fr
+    ga gb gd ge gf gg gh gi gl gm gn gp gq gr gs gt gu gw gy
+    hk hm hn hr ht hu
+    id ie il im in io iq ir is it
+    je jm jo jp
+    ke kg kh ki km kn kp kr kw ky kz
+    la lb lc li lk lr ls lt lu lv ly
+    ma mc md me mg mh mk ml mm mn mo mp mq mr ms mt mu mv mw mx my mz
+    na nc ne nf ng ni nl no np nr nu nz
+    om
+    pa pe pf pg ph pk pl pm pn pr ps pt pw py
+    qa
+    re ro rs ru rw
+    sa sb sc sd se sg sh si sj sk sl sm sn so sr ss st su sv sy sz
+    tc td tf tg th tj tk tl tm tn to tp tr tt tv tw tz
+    ua ug ak us uy uz
+    va vc ve vg vi vn vu
+    wf ws
+    ye yt
+    za zm zw
+  ]
+
+  #
+  # Creates a new resolver.
+  #
+  # @param [String, Array<String>, nil] nameserver
+  #   The nameserver(s) to query.
+  #
+  # @return [Resolv::DNS]
+  #   A new resolver for the given nameservers, or the default resolver.
+  #
+  # @example
+  #   Resolv.resolver('4.2.2.1')
+  #
+  # @since 0.3.0
+  #
+  # @api public
+  #
+  def Resolv.resolver(nameserver=nil)
+    if nameserver
+      DNS.new(:nameserver => nameserver)
+    else
+      self
+    end
+  end
+
+end

data/lib/ronin/extensions/string.rb

@@ -39,13 +39,17 @@ class String
   # @return [String]
   #   The original string
   #
+  # @example
+  #   "hello".each_substring(3).to_a
+  #   # => ["hel", "hell", "hello", "ell", "ello", "llo"]
+  #
   # @api public
   #
-  def each_substring(min=0,&block)
+  def each_substring(min=1,&block)
     return enum_for(:each_substring,min) unless block
 
-    (0..(self.length - min)).each do |i|
-      ((i + min)..self.length).each do |j|
+    (0..(length - min)).each do |i|
+      ((i + min)..length).each do |j|
         sub_string = self[i...j]
 
         if block.arity == 2
@@ -79,11 +83,15 @@ class String
   # @return [String]
   #   The original string
   #
+  # @example
+  #   "xoxo".each_unique_substring(2).to_a
+  #   # => ["xo", "xox", "xoxo", "ox", "oxo"]
+  #
   # @see each_substring
   #
   # @api public
   #
-  def each_unique_substring(min=0,&block)
+  def each_unique_substring(min=1,&block)
     return enum_for(:each_unique_substring,min) unless block
 
     unique_strings = {}
@@ -119,11 +127,11 @@ class String
 
     min_length.times do |i|
       if self[i] != other[i]
-        return self[0...i]
+        return self[0,i]
       end
     end
 
-    return self[0...min_length]
+    return self[0,min_length]
   end
 
   #
@@ -143,7 +151,7 @@ class String
     min_length = [length, other.length].min
 
     (min_length - 1).times do |i|
-      index = (length - i - 1)
+      index       = (length - i - 1)
       other_index = (other.length - i - 1)
 
       if self[index] != other[other_index]
@@ -160,8 +168,8 @@ class String
   #   Please use {#common_suffix} instead.
   #
   def common_postfix(other)
-    warn "DEPRECATED: String#common_postfix was deprecated in 0.2.0."
-    warn "DEPRECATED: Please use String#common_suffix instead."
+    warn 'DEPRECATED: String#common_postfix was deprecated in 0.2.0.'
+    warn 'DEPRECATED: Please use String#common_suffix instead.'
 
     common_suffix(other)
   end
@@ -179,25 +187,29 @@ class String
   # @api public
   #
   def uncommon_substring(other)
-    prefix = common_prefix(other)
+    prefix  = common_prefix(other)
     postfix = self[prefix.length..-1].common_suffix(other[prefix.length..-1])
 
     return self[prefix.length...(length - postfix.length)]
   end
 
   if RUBY_VERSION < '1.9.'
-    ESCAPE_BYTES = {
-      0x00 => '\0',
-      0x07 => '\a',
-      0x08 => '\b',
-      0x09 => '\t',
-      0x0a => '\n',
-      0x0b => '\v',
-      0x0c => '\f',
-      0x0d => '\r',
-      0x22 => '\"',
-      0x5c => '\\'
-    }
+    ESCAPE_BYTES = Hash.new do |escape,byte|
+      escape[byte] = if (byte >= 0x20 && byte <= 0x7e)
+                       byte.chr
+                     else
+                       "\\x%.2X" % byte
+                     end
+    end
+
+    ESCAPE_BYTES[0x00] = '\0'
+    ESCAPE_BYTES[0x07] = '\a'
+    ESCAPE_BYTES[0x08] = '\b'
+    ESCAPE_BYTES[0x09] = '\t'
+    ESCAPE_BYTES[0x0a] = '\n'
+    ESCAPE_BYTES[0x0b] = '\v'
+    ESCAPE_BYTES[0x0c] = '\f'
+    ESCAPE_BYTES[0x0d] = '\r'
 
     #
     # Dumps the string as a C-style string.
@@ -217,16 +229,7 @@ class String
     def dump
       dumped_string = ''
 
-      each_byte do |b|
-        dumped_string << if (b >= 0x20 && b <= 0x7e)
-                           b.chr
-                         elsif ESCAPE_BYTES.has_key?(b)
-                           ESCAPE_BYTES[b]
-                         else
-                           ("\\x%.2X" % b)
-                         end
-      end
-
+      each_byte { |b| dumped_string << ESCAPE_BYTES[b] }
       return "\"#{dumped_string}\""
     end
 

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

@@ -27,14 +27,21 @@ class Integer
   #
   # @param [Symbol, String] endian
   #   The endianness to use while decoding the bytes of the Integer.
-  #   May be either `:big`, `:little` or `:net`.
+  #   May be one of:
+  #
+  #   * `:big` / `"big"`
+  #   * `:little` / `"little"`
+  #   * `:net` / `"net"`
   #
   # @return [Array]
   #   The bytes decoded from the Integer.
   #
   # @raise [ArgumentError]
-  #   The given `endian` is not `:little`, `"little"`, `:net`, `"net"`,
-  #   `:big` or `"big"`.
+  #   The given `endian` was not one of:
+  #
+  #   * `:little` / `"little"`
+  #   * `:net` / `"net"`
+  #   * `:big` / `"big"`
   #
   # @example
   #   0xff41.bytes(2)
@@ -52,7 +59,7 @@ class Integer
 
     case endian
     when :little, :net
-      mask = 0xff
+      mask  = 0xff
       shift = 0
 
       address_length.times do |i|
@@ -63,7 +70,7 @@ class Integer
       end
     when :big
       shift = ((address_length - 1) * 8)
-      mask = (0xff << shift)
+      mask  = (0xff << shift)
 
       address_length.times do |i|
         buffer << ((self & mask) >> shift)

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

@@ -84,15 +84,16 @@ class String
       raise(ArgumentError,"first argument to Ineger#pack must respond to endian")
     end
 
+    endian           = arch.endian.to_sym
     address_length ||= arch.address_length
 
     integer = 0x0
     byte_index = 0
 
-    case arch.endian
-    when :little, 'little'
+    case endian
+    when :little
       mask = lambda { |b| b << (byte_index * 8) }
-    when :big, 'big'
+    when :big
       mask = lambda { |b|
         b << ((address_length - byte_index - 1) * 8)
       }
@@ -100,7 +101,7 @@ class String
       raise(ArgumentError,"invalid endian #{arch.endian.inspect}")
     end
 
-    self.each_byte do |b|
+    each_byte do |b|
       break if byte_index >= address_length
 
       integer |= mask.call(b)
@@ -110,6 +111,8 @@ class String
     return integer
   end
 
+  #
+  # Hex-escapes characters in the String.
   #
   # @return [String]
   #   The hex escaped version of the String.
@@ -207,18 +210,23 @@ class String
   # @api public
   #
   def xor(key)
-    key = if key.kind_of?(Integer)
+    key = case key
+          when Integer
             [key]
-          elsif key.kind_of?(String)
+          when String
             key.bytes
           else
             key
           end
 
-    key = key.cycle
+    key    = key.cycle
     result = ''
 
-    self.bytes.inject('') { |result,b| result << (b ^ key.next).chr }
+    bytes.each do |b|
+      result << (b ^ key.next).chr
+    end
+
+    return result
   end
 
   #
@@ -227,6 +235,10 @@ class String
   # @return [String]
   #   The base64 encoded form of the string.
   #
+  # @example
+  #   "hello".base64_encode
+  #   # => "aGVsbG8=\n"
+  #
   # @api public
   #
   def base64_encode
@@ -239,6 +251,10 @@ class String
   # @return [String]
   #   The base64 decoded form of the string.
   #
+  # @example
+  #   "aGVsbG8=\n"
+  #   # => "hello"
+  #
   # @api public
   #
   def base64_decode
@@ -251,6 +267,10 @@ class String
   # @return [String]
   #   The Zlib inflated form of the string.
   #
+  # @example
+  #   "x\x9C\xCBH\xCD\xC9\xC9\a\x00\x06,\x02\x15".zlib_inflate
+  #   # => "hello"
+  #
   # @api public
   #
   def zlib_inflate
@@ -263,6 +283,10 @@ class String
   # @return [String]
   #   The Zlib deflated form of the string.
   #
+  # @example
+  #   "hello".zlib_deflate
+  #   # => "x\x9C\xCBH\xCD\xC9\xC9\a\x00\x06,\x02\x15"
+  #
   # @api public
   #
   def zlib_deflate
@@ -282,6 +306,7 @@ class String
   # @option options [Symbol] :encoding
   #   Denotes the encoding used for the bytes within the hexdump.
   #   Must be one of the following:
+  #
   #   * `:binary`
   #   * `:octal`
   #   * `:octal_bytes`
@@ -309,14 +334,17 @@ class String
   def unhexdump(options={})
     case (format = options[:format])
     when :od
-      address_base = base = 8
-      word_size = 2
+      address_base = 8
+      base         = 8
+      word_size    = 2
     when :hexdump
-      address_base = base = 16
-      word_size = 2
+      address_base = 16
+      base         = 16
+      word_size    = 2
     else
-      address_base = base = 16
-      word_size = 1
+      address_base = 16
+      base         = 16
+      word_size    = 1
     end
 
     case options[:encoding]
@@ -379,13 +407,13 @@ class String
           end
         end
 
-        segment = segment[0...segment_length]
+        segment = segment[0,segment_length]
         buffer += segment
         last_addr = current_addr
       end
     end
 
-    return buffer[0...(last_addr - first_addr)]
+    return buffer[0,(last_addr - first_addr)]
   end
 
 end

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

@@ -23,38 +23,38 @@ class Integer
 
   # Special JavaScript bytes and their escaped Strings.
   JS_ESCAPE_BYTES = {
-    0x00 => '%u0000',
-    0x01 => '%u0001',
-    0x02 => '%u0002',
-    0x03 => '%u0003',
-    0x04 => '%u0004',
-    0x05 => '%u0005',
-    0x06 => '%u0006',
-    0x07 => '%u0007',
+    0x00 => '\u0000',
+    0x01 => '\u0001',
+    0x02 => '\u0002',
+    0x03 => '\u0003',
+    0x04 => '\u0004',
+    0x05 => '\u0005',
+    0x06 => '\u0006',
+    0x07 => '\u0007',
     0x08 =>  '\b',
     0x09 =>  '\t',
     0x0a =>  '\n',
-    0x0b => '%u000b',
+    0x0b => '\u000b',
     0x0c =>  '\f',
     0x0d =>  '\r',
-    0x0e => '%u000e',
-    0x0f => '%u000f',
-    0x10 => '%u0010',
-    0x11 => '%u0011',
-    0x12 => '%u0012',
-    0x13 => '%u0013',
-    0x14 => '%u0014',
-    0x15 => '%u0015',
-    0x16 => '%u0016',
-    0x17 => '%u0017',
-    0x18 => '%u0018',
-    0x19 => '%u0019',
-    0x1a => '%u001a',
-    0x1b => '%u001b',
-    0x1c => '%u001c',
-    0x1d => '%u001d',
-    0x1e => '%u001e',
-    0x1f => '%u001f',
+    0x0e => '\u000e',
+    0x0f => '\u000f',
+    0x10 => '\u0010',
+    0x11 => '\u0011',
+    0x12 => '\u0012',
+    0x13 => '\u0013',
+    0x14 => '\u0014',
+    0x15 => '\u0015',
+    0x16 => '\u0016',
+    0x17 => '\u0017',
+    0x18 => '\u0018',
+    0x19 => '\u0019',
+    0x1a => '\u001a',
+    0x1b => '\u001b',
+    0x1c => '\u001c',
+    0x1d => '\u001d',
+    0x1e => '\u001e',
+    0x1f => '\u001f',
     0x22 =>  '\"',
     0x5c =>  '\\\\',
   }
@@ -65,12 +65,16 @@ class Integer
   # @return [String]
   #   The escaped HTML String.
   #
+  # @example
+  #   0x26.html_escape
+  #   # => "&"
+  #
   # @since 0.2.0
   #
   # @api public
   #
   def html_escape
-    CGI.escapeHTML(self.chr)
+    CGI.escapeHTML(chr)
   end
 
   #
@@ -79,6 +83,10 @@ class Integer
   # @return [String]
   #   The HTML String.
   #
+  # @example
+  #   0x41.format_html
+  #   # => "A"
+  #
   # @since 0.2.0
   #
   # @api public
@@ -93,6 +101,14 @@ class Integer
   # @return [String]
   #   The escaped JavaScript String.
   #
+  # @example 
+  #   0x22.js_escape
+  #   # => "\\\""
+  #
+  # @example
+  #   0x7f.js_escape
+  #   # => "\x7F"
+  #
   # @since 0.2.0
   #
   # @api public
@@ -101,7 +117,7 @@ class Integer
     if self > 0xff
       format_js
     else
-      JS_ESCAPE_BYTES.fetch(self,self.chr)
+      JS_ESCAPE_BYTES.fetch(self,chr)
     end
   end
 
@@ -111,15 +127,19 @@ class Integer
   # @return [String]
   #   The escaped JavaScript String.
   #
+  # @example
+  #   0x41.format_js
+  #   # => "%41"
+  #
   # @since 0.2.0
   #
   # @api public
   #
   def format_js
     if self > 0xff
-      "%%u%.2X%.2X" % [(self & 0xff00) >> 8, (self & 0xff)]
+      "\\u%.2X%.2X" % [(self & 0xff00) >> 8, (self & 0xff)]
     else
-      "%%%.2X" % self
+      "\\x%.2X" % self
     end
   end