ronin-support 0.4.0.rc2 → 0.4.0

data/ChangeLog.md

@@ -1,4 +1,4 @@
-### 0.4.0 / 2012-01-01
+### 0.4.0 / 2012-02-12
 
 * Require uri-query_params ~> 0.6.
 * Require parameters ~> 0.4.
@@ -9,13 +9,13 @@
 * Added {Regexp::FILE_NAME}.
 * Added {Regexp::FILE}.
 * Added {Regexp::DIRECTORY}.
-* Added {Regexp::LOCAL_UNIX_PATH}.
+* Added {Regexp::RELATIVE_UNIX_PATH}.
 * Added {Regexp::ABSOLUTE_UNIX_PATH}.
 * Added {Regexp::UNIX_PATH}.
-* Added {Regexp::LOCAL_WINDOWS_PATH}.
+* Added {Regexp::RELATIVE_WINDOWS_PATH}.
 * Added {Regexp::ABSOLUTE_WINDOWS_PATH}.
 * Added {Regexp::WINDOWS_PATH}.
-* Added {Regexp::LOCAL_PATH}.
+* Added {Regexp::RELATIVE_PATH}.
 * Added {Regexp::ABSOLUTE_PATH}.
 * Added {Regexp::PATH}.
 * Added {String#repeating}.
@@ -41,7 +41,9 @@
   * Added {Ronin::Fuzzing.sint32}.
   * Added {Ronin::Fuzzing.sint64}.
 * Added {Ronin::Wordlist}.
+* Added {Ronin::Network::DNS}.
 * Added {Ronin::Network::Mixins::Mixin}.
+* Added {Ronin::Network::Mixins::DNS}.
 * Added {Ronin::Network::Mixins::SSL}.
 * Added missing {Ronin::Network::UDP#udp_send} and
   {Ronin::Network::Mixins::UDP#udp_send} methods.

data/README.md

@@ -28,6 +28,7 @@ or payloads over many common Source-Code-Management (SCM) systems.
     * SQL
   * Fuzzing
   * Networking:
+    * DNS
     * TCP
     * UDP
     * SMTP / ESMTP

data/lib/ronin/extensions/regexp.rb

@@ -28,10 +28,29 @@ class Regexp
   MAC = /[0-9a-fA-F]{2}(?::[0-9a-fA-F]{2}){5}/
 
   # A regular expression for matching IPv4 Addresses.
-  IPv4 = /#{OCTET}(?:\.#{OCTET}){3}/
+  IPv4 = /#{OCTET}(?:\.#{OCTET}){3}(?:\/\d{1,2})?/
 
   # A regular expression for matching IPv6 Addresses.
-  IPv6 = /:(:[0-9a-f]{1,4}){1,7}|([0-9a-f]{1,4}::?){1,7}[0-9a-f]{1,4}(:#{IPv4})?/
+  IPv6 = union(
+    /(?:[0-9a-f]{1,4}:){6}#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){5}[0-9a-f]{1,4}:#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){5}:[0-9a-f]{1,4}:#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){1,1}(?::[0-9a-f]{1,4}){1,4}:#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){1,2}(?::[0-9a-f]{1,4}){1,3}:#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){1,3}(?::[0-9a-f]{1,4}){1,2}:#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){1,4}(?::[0-9a-f]{1,4}){1,1}:#{IPv4}/,
+    /:(?::[0-9a-f]{1,4}){1,5}:#{IPv4}/,
+    /(?:(?:[0-9a-f]{1,4}:){1,5}|:):#{IPv4}/,
+    /(?:[0-9a-f]{1,4}:){1,1}(?::[0-9a-f]{1,4}){1,6}(?:\/\d{1,3})?/,
+    /(?:[0-9a-f]{1,4}:){1,2}(?::[0-9a-f]{1,4}){1,5}(?:\/\d{1,3})?/,
+    /(?:[0-9a-f]{1,4}:){1,3}(?::[0-9a-f]{1,4}){1,4}(?:\/\d{1,3})?/,
+    /(?:[0-9a-f]{1,4}:){1,4}(?::[0-9a-f]{1,4}){1,3}(?:\/\d{1,3})?/,
+    /(?:[0-9a-f]{1,4}:){1,5}(?::[0-9a-f]{1,4}){1,2}(?:\/\d{1,3})?/,
+    /(?:[0-9a-f]{1,4}:){1,6}(?::[0-9a-f]{1,4}){1,1}(?:\/\d{1,3})?/,
+    /[0-9a-f]{1,4}(?::[0-9a-f]{1,4}){7}(?:\/\d{1,3})?/,
+    /:(?::[0-9a-f]{1,4}){1,7}(?:\/\d{1,3})?/,
+    /(?:(?:[0-9a-f]{1,4}:){1,7}|:):(?:\/\d{1,3})?/
+  )
 
   # A regular expression for matching IP Addresses.
   IP = /#{IPv4}|#{IPv6}/
@@ -40,19 +59,19 @@ class Regexp
   HOST_NAME = /(?:[a-zA-Z0-9]+(?:[_-][a-zA-Z0-9]+)*\.)+(?:#{union(Resolv::TLDS)})/i
 
   # Regular expression to match a word in the username of an email address
-  USER_NAME = /[A-Za-z](?:[A-Za-z0-9]+[\._-])*[A-Za-z0-9]+/
+  USER_NAME = /[A-Za-z](?:[A-Za-z0-9]*[\._-])*[A-Za-z0-9]+/
 
   # Regular expression to find email addresses in text
-  EMAIL_ADDR = /#{USER_NAME}(?:\.#{USER_NAME})*\@#{HOST_NAME}/
+  EMAIL_ADDR = /#{USER_NAME}\@#{HOST_NAME}/
 
   # Regular expression to find deliminators in text
   DELIM = /[;&\n\r]/
 
   # Regular expression to find identifier in text
-  IDENTIFIER = /[_a-zA-Z][a-zA-Z0-9_-]*/
+  IDENTIFIER = /[_]*[a-zA-Z]+[a-zA-Z0-9_-]*/
 
   # Regular expression to find File extensions in text
-  FILE_EXT = /(?:\.[A-Za-z0-9_-]+)+/
+  FILE_EXT = /(?:\.[A-Za-z0-9]+)+/
 
   # Regular expression to find File names in text
   FILE_NAME = /(?:[^\/\\\. ]|\\[\/\\ ])+/
@@ -64,25 +83,25 @@ class Regexp
   DIRECTORY = /(?:\.\.|\.|#{FILE})/
 
   # Regular expression to find local UNIX Paths in text
-  LOCAL_UNIX_PATH = /(?:#{DIRECTORY}\/)+#{DIRECTORY}\/?/
+  RELATIVE_UNIX_PATH = /(?:#{DIRECTORY}\/)+#{DIRECTORY}\/?/
 
   # Regular expression to find absolute UNIX Paths in text
   ABSOLUTE_UNIX_PATH = /(?:\/#{FILE})+\/?/
 
   # Regular expression to find UNIX Paths in text
-  UNIX_PATH = /#{ABSOLUTE_UNIX_PATH}|#{LOCAL_UNIX_PATH}/
+  UNIX_PATH = /#{ABSOLUTE_UNIX_PATH}|#{RELATIVE_UNIX_PATH}/
 
   # Regular expression to find local Windows Paths in text
-  LOCAL_WINDOWS_PATH = /(?:#{DIRECTORY}\\)+#{DIRECTORY}\\?/
+  RELATIVE_WINDOWS_PATH = /(?:#{DIRECTORY}\\)+#{DIRECTORY}\\?/
 
   # Regular expression to find absolute Windows Paths in text
-  ABSOLUTE_WINDOWS_PATH = /[A-Za-z]:(?:\\#{DIRECTORY})+\\?/
+  ABSOLUTE_WINDOWS_PATH = /[A-Za-z]:(?:\\#{FILE})+\\?/
 
   # Regular expression to find Windows Paths in text
-  WINDOWS_PATH = /#{ABSOLUTE_WINDOWS_PATH}|#{LOCAL_WINDOWS_PATH}/
+  WINDOWS_PATH = /#{ABSOLUTE_WINDOWS_PATH}|#{RELATIVE_WINDOWS_PATH}/
 
   # Regular expression to find local Paths in text
-  LOCAL_PATH = /#{LOCAL_UNIX_PATH}|#{LOCAL_WINDOWS_PATH}/
+  RELATIVE_PATH = /#{RELATIVE_UNIX_PATH}|#{RELATIVE_WINDOWS_PATH}/
 
   # Regular expression to find absolute Paths in text
   ABSOLUTE_PATH = /#{ABSOLUTE_UNIX_PATH}|#{ABSOLUTE_WINDOWS_PATH}/

data/lib/ronin/fuzzing/fuzzing.rb

@@ -20,9 +20,18 @@
 require 'set'
 
 module Ronin
+  #
+  # Contains class-methods which generate malicious data for fuzzing.
+  #
+  # @see Fuzzing.[]
+  #
+  # @since 0.4.0
+  #
   module Fuzzing
+    # Short String lengths
     SHORT_LENGTHS = SortedSet[1, 100, 500, 1_000, 10_000]
 
+    # Long String lengths
     LONG_LENGTHS = SortedSet[
       128, 255, 256, 257, 511, 512, 513, 1023, 1024, 2048, 2049, 4095,
       4096, 4097, 5_000, 10_000, 20_000, 32762, 32763, 32764, 32765, 32766,
@@ -51,14 +60,23 @@ module Ronin
     #
     # @api semipublic
     #
-    # @since 0.4.0
-    #
     def self.[](name)
       if (!Object.respond_to?(name) && respond_to?(name))
         enum_for(name)
       end
     end
 
+    #
+    # Various bad-strings.
+    #
+    # @yield [string]
+    #   The given block will be passed each bad-string.
+    #
+    # @yieldparam [String] string
+    #   A bad-string containing known control characters, deliminators
+    #   or null-bytes (see {NULL_BYTES}), of varying length
+    #   (see {SHORT_LENGTHS} and {LONG_LENGTHS}).
+    #
     def self.bad_strings(&block)
       yield ''
 
@@ -91,6 +109,15 @@ module Ronin
       yield "<>"   * 500
     end
 
+    #
+    # Various format-strings.
+    #
+    # @yield [fmt_string]
+    #   The given block will be passed each format-string.
+    #
+    # @yieldparam [String] fmt_string
+    #   A format-string containing format operators (see {FORMAT_STRINGS}).
+    #
     def self.format_strings(&block)
       FORMAT_STRINGS.each do |fmt|
         yield fmt
@@ -100,6 +127,15 @@ module Ronin
       end
     end
 
+    #
+    # Various bad paths and directory traversals.
+    #
+    # @yield [path]
+    #   The given block will be passed each path.
+    #
+    # @yieldparam [String] path
+    #   A known bad path.
+    #
     def self.bad_paths(&block)
       padding = 'A' * 5_000
 
@@ -121,6 +157,15 @@ module Ronin
       end
     end
 
+    #
+    # The range of bit-fields.
+    #
+    # @yield [bitfield]
+    #   The given block will be passed each bit-field.
+    #
+    # @yieldparam [String] bitfield
+    #   A bit-field (8bit - 64bit).
+    #
     def self.bit_fields(&block)
       ("\x00".."\xff").each do |c|
         yield c
@@ -130,6 +175,15 @@ module Ronin
       end
     end
 
+    #
+    # The range of signed bit-fields.
+    #
+    # @yield [bitfield]
+    #   The given block will be passed each bit-field.
+    #
+    # @yieldparam [String] bitfield
+    #   A signed bit-field (8bit - 64bit).
+    #
     def self.signed_bit_fields(&block)
       ("\x80".."\xff").each do |c|
         yield c
@@ -139,50 +193,158 @@ module Ronin
       end
     end
 
+    #
+    # The range of unsigned 8bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A unsigned 8bit integer.
+    #
     def self.uint8(&block)
       ("\x00".."\xff").each(&block)
     end
 
+    #
+    # The range of unsigned 16bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A unsigned 16bit integer.
+    #
     def self.uint16
       uint8 { |c| yield c * 2 }
     end
 
+    #
+    # The range of unsigned 32bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A unsigned 32bit integer.
+    #
     def self.uint32
       uint8 { |c| yield c * 4 }
     end
 
+    #
+    # The range of unsigned 64bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A unsigned 64bit integer.
+    #
     def self.uint64
       uint8 { |c| yield c * 8 }
     end
 
+    #
+    # The range of signed 8bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A signed 8bit integer.
+    #
     def self.int8(&block)
       ("\x00".."\x70").each(&block)
     end
 
+    #
+    # The range of signed 16bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A signed 16bit integer.
+    #
     def self.int16
       int8 { |c| yield c * 2 }
     end
 
+    #
+    # The range of signed 32bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A signed 32bit integer.
+    #
     def self.int32
       int8 { |c| yield c * 4 }
     end
 
+    #
+    # The range of signed 64bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A signed 64bit integer.
+    #
     def self.int64
       int8 { |c| yield c * 8 }
     end
 
+    #
+    # The range of negative-signed 8bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A negative-signed 8bit integer.
+    #
     def self.sint8(&block)
       ("\x80".."\xff").each(&block)
     end
 
+    #
+    # The range of negative-signed 16bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A negative-signed 16bit integer.
+    #
     def self.sint16
       sint8 { |c| yield c * 2 }
     end
 
+    #
+    # The range of negative-signed 32bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A negative-signed 32bit integer.
+    #
     def self.sint32
       sint8 { |c| yield c * 4 }
     end
 
+    #
+    # The range of negative-signed 64bit integers.
+    #
+    # @yield [int]
+    #   The given block will be passed each integer.
+    #
+    # @yieldparam [String] int
+    #   A negative-signed 64bit integer.
+    #
     def self.sint64
       sint8 { |c| yield c * 8 }
     end

data/lib/ronin/network.rb

@@ -17,6 +17,7 @@
 # along with Ronin Support.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+require 'ronin/network/dns'
 require 'ronin/network/tcp'
 require 'ronin/network/udp'
 require 'ronin/network/smtp'

data/lib/ronin/network/dns.rb

@@ -0,0 +1,161 @@
+#
+# Copyright (c) 2006-2012 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'
+
+module Ronin
+  module Network
+    #
+    # Provides helper methods for performing DNS queries.
+    #
+    # @since 0.4.0
+    #
+    module DNS
+      #
+      # The DNS nameserver to query.
+      #
+      # @return [String, nil]
+      #   The address of the nameserver.
+      #
+      # @api public
+      #
+      def self.nameserver
+        @nameserver
+      end
+
+      #
+      # Sets the DNS nameserver to be queried.
+      #
+      # @param [IPAddr, String, nil]
+      #   The address of the nameserver.
+      #
+      # @return [String, nil]
+      #   The address of the new nameserver.
+      #
+      # @api public
+      #
+      def self.nameserver=(address)
+        @nameserver = if address
+                        address.to_s
+                      end
+      end
+
+      #
+      # Creates a DNS Resolver for the nameserver.
+      #
+      # @param [String, nil] nameserver
+      #   Optional DNS nameserver to query.
+      #
+      # @return [Resolv, Resolv::DNS]
+      #   The DNS Resolver.
+      #
+      # @api public
+      #
+      def dns_resolver(nameserver=DNS.nameserver)
+        if nameserver
+          Resolv::DNS.new(:nameserver => nameserver)
+        else
+          Resolv
+        end
+      end
+
+      #
+      # Looks up the address of a hostname.
+      #
+      # @param [String] hostname
+      #   The hostname to lookup.
+      #
+      # @param [String, nil] nameserver
+      #   Optional DNS nameserver to query.
+      #
+      # @return [String, nil]
+      #   The address of the hostname.
+      #
+      # @api public
+      #
+      def dns_lookup(hostname,nameserver=DNS.nameserver)
+        resolv = dns_resolver(nameserver)
+
+        begin
+          resolv.getaddress(hostname.to_s).to_s
+        rescue Resolv::ResolvError
+        end
+      end
+
+      #
+      # Looks up all addresses of a hostname.
+      #
+      # @param [String] hostname
+      #   The hostname to lookup.
+      #
+      # @param [String, nil] nameserver
+      #   Optional DNS nameserver to query.
+      #
+      # @return [Array<String>]
+      #   The addresses of the hostname.
+      #
+      # @api public
+      #
+      def dns_lookup_all(hostname,nameserver=DNS.nameserver)
+        dns_resolver(nameserver).getaddresses(hostname.to_s).map(&:to_s)
+      end
+
+      #
+      # Looks up the hostname of the address.
+      #
+      # @param [String] address
+      #   The address to lookup.
+      #
+      # @param [String, nil] nameserver
+      #   Optional DNS nameserver to query.
+      #
+      # @return [String, nil]
+      #   The hostname of the address.
+      #
+      # @api public
+      #
+      def dns_reverse_lookup(address,nameserver=DNS.nameserver)
+        resolv = dns_resolver(nameserver)
+
+        begin
+          resolv.getname(address.to_s).to_s
+        rescue Resolv::ResolvError
+        end
+      end
+
+      #
+      # Looks up all hostnames associated with the address.
+      #
+      # @param [String] address
+      #   The address to lookup.
+      #
+      # @param [String, nil] nameserver
+      #   Optional DNS nameserver to query.
+      #
+      # @return [Array<String>]
+      #   The hostnames of the address.
+      #
+      # @api public
+      #
+      def dns_reverse_lookup_all(address,nameserver=DNS.nameserver)
+        dns_resolver(nameserver).getnames(address.to_s).map(&:to_s)
+      end
+    end
+  end
+end