ronin-support 0.4.1 → 0.5.0.rc1

data/ChangeLog.md

@@ -1,19 +1,62 @@
-### 0.4.1 / 2012-04-01
+### 0.5.0 / 2012-05-28
 
-* Added "WARNING" messages for when ronin-support cannot load `openssl` or
-  `zlib`.
-* Added YARD `@see` tags to all methods defined in {Ronin::Network::Mixins}.
-* Use `$stdout`, `$stderr` instead of `STDOUT`, `STDERR`, respectively.
-* Included {Ronin::Network::DNS} into {Net} as well.
-* Included {Ronin::Network::TCP} into {Ronin::Network::SSL}.
-* Require `ronin/network/ssl` in `ronin/network`.
-* Require `ronin/network/extensions/ssl` in `ronin/network/extensions`.
-* Included {Ronin::Network::SSL} into {Ronin::Support}.
-* Default all `local_port` variables to `0` instead of `nil`. Workaround
-  for JRuby bug [#6574](http://jira.codehaus.org/browse/JRUBY-6574).
-* Fixed a major syntax error in `ronin/network/ssl`, that caused the `ssl_*`
-  methods to not be defined in {Ronin::Network::SSL}.
-* Fixed YARD `@see` tags in the {Ronin::Network} modules.
+* Added {Float#pack}.
+* Added {Regexp::WORD}.
+* Added {Regexp::PHONE_NUMBER}.
+* Added {Ronin::Binary::Template}.
+* Added {Ronin::Binary::Struct}.
+* Added {Ronin::Binary::Hexdump::Parser}.
+* Added {Ronin::Wordlist.create}.
+* Added {Ronin::Wordlist#path} and {Ronin::Wordlist#words}.
+* Added {Ronin::Wordlist#save}.
+* Added {Ronin::Network::Proxy}, {Ronin::Network::TCP::Proxy} and
+  {Ronin::Network::UDP::Proxy}.
+* Added {Ronin::Network::TCP#tcp_open?}.
+* Added {Ronin::Network::TCP#tcp_server_loop}.
+* Added {Ronin::Network::UDP#udp_open?}.
+* Added {Ronin::Network::UDP#udp_server_loop}.
+* Added {Ronin::Network::Mixins::TCP#tcp_open?}.
+* Added {Ronin::Network::Mixins::UDP#udp_open?}.
+* Added {Ronin::Network::Mixins::UDP#udp_server_loop}.
+* Added {Ronin::Network::Mixins::UDP#udp_recv}.
+* Added {Ronin::Network::FTP}.
+* Added {Ronin::Network::UNIX}.
+* Added {Ronin::Network::Mixins::FTP}.
+* Added {Ronin::Network::Mixins::UNIX}.
+* Aliased {String#escape} to {String#dump}.
+* Renamed {String#hex_unescape} to {String#unescape}.
+  * Aliased {String#hex_unescape} to {String#unescape}.
+* Renamed {Ronin::Network::TCP#tcp_single_server} to
+  {Ronin::Network::TCP#tcp_accept}.
+* Renamed {Ronin::Network::UDP#udp_single_server} to
+  {Ronin::Network::UDP#udp_recv}.
+* Deprecated {Ronin::Network::TCP#tcp_single_server}.
+* Deprecated {Ronin::Network::UDP#udp_single_server}.
+* Backported Ruby 1.9 only {Base64} methods.
+* Allow {Integer#pack} to accept a type from {Ronin::Binary::Template::TYPES}.
+* Allow {Array#pack} to accept types from {Ronin::Binary::Template::TYPES}.
+* Allow {String#unpack} to accept types from {Ronin::Binary::Template::TYPES}.
+* Support nmap-style `i,j-k` globbed IP address ranges in {IPAddr.each}.
+* Moved {String#unhexdump} logic into {Ronin::Binary::Hexdump::Parser}.
+  * Added the `:named_chars` option.
+  * Improved the parsing of `od` hexdumps.
+  * Support unhexdumping specific endianness.
+  * Support unhexdumping floats / doubles.
+* Allow {String#mutate} to accept Symbols that map to {Ronin::Fuzzing}
+  generator methods.
+* Use `module_function` in {Ronin::Fuzzing}, so the generator methods can be
+  included into other Classes/Modules.
+* Require uri-query_params ~> 0.6.
+* Use `$stdout` instead of calling `Kernel.puts` or `STDOUT`.
+  Prevents infinite recursion if another library overrides `Kernel.puts`.
+* Allow {Ronin::Network::DNS} methods to yield resolved addresses.
+* Inject {Ronin::Network::DNS} into {Net} for backwards compatibility.
+* Allow {Ronin::Network::TCP#tcp_server} to accept a `backlog` argument.
+* Default the server host to `0.0.0.0` in
+  {Ronin::Network::TCP#tcp_accept}.
+* No longer honor the `VERBOSE` environment variable for enabling verbose output
+  in {Ronin::UI::Output}. Use `ruby -w` or `ruby -d` instead.
+* No longer support loading `extlib` in `ronin/support/inflector`.
 
 ### 0.4.0 / 2012-02-12
 
@@ -40,23 +83,23 @@
 * Added {String#mutate}.
 * Added {Ronin::Fuzzing}.
   * Added {Ronin::Fuzzing.[]}.
-  * Added {Ronin::Fuzzing.bad_strings}.
-  * Added {Ronin::Fuzzing.format_strings}.
-  * Added {Ronin::Fuzzing.bad_paths}.
-  * Added {Ronin::Fuzzing.bit_fields}.
-  * Added {Ronin::Fuzzing.signed_bit_fields}.
-  * Added {Ronin::Fuzzing.uint8}.
-  * Added {Ronin::Fuzzing.uint16}.
-  * Added {Ronin::Fuzzing.uint32}.
-  * Added {Ronin::Fuzzing.uint64}.
-  * Added {Ronin::Fuzzing.int8}.
-  * Added {Ronin::Fuzzing.int16}.
-  * Added {Ronin::Fuzzing.int32}.
-  * Added {Ronin::Fuzzing.int64}.
-  * Added {Ronin::Fuzzing.sint8}.
-  * Added {Ronin::Fuzzing.sint16}.
-  * Added {Ronin::Fuzzing.sint32}.
-  * Added {Ronin::Fuzzing.sint64}.
+  * Added `Ronin::Fuzzing.bad_strings`.
+  * Added `Ronin::Fuzzing.format_strings`.
+  * Added `Ronin::Fuzzing.bad_paths`.
+  * Added `Ronin::Fuzzing.bit_fields`.
+  * Added `Ronin::Fuzzing.signed_bit_fields`.
+  * Added `Ronin::Fuzzing.uint8`.
+  * Added `Ronin::Fuzzing.uint16`.
+  * Added `Ronin::Fuzzing.uint32`.
+  * Added `Ronin::Fuzzing.uint64`.
+  * Added `Ronin::Fuzzing.int8`.
+  * Added `Ronin::Fuzzing.int16`.
+  * Added `Ronin::Fuzzing.int32`.
+  * Added `Ronin::Fuzzing.int64`.
+  * Added `Ronin::Fuzzing.sint8`.
+  * Added `Ronin::Fuzzing.sint16`.
+  * Added `Ronin::Fuzzing.sint32`.
+  * Added `Ronin::Fuzzing.sint64`.
 * Added {Ronin::Wordlist}.
 * Added {Ronin::Network::DNS}.
 * Added {Ronin::Network::Mixins::Mixin}.

data/Gemfile

@@ -2,29 +2,28 @@ source 'https://rubygems.org'
 
 gemspec
 
-platforms :jruby do
-  gem 'jruby-openssl',	'~> 0.7'
-end
+gem 'jruby-openssl',	'~> 0.7.0', :platforms => :jruby
 
 group :development do
-  gem 'rake',		        '~> 0.8'
+  gem 'rake',               '~> 0.8'
+  gem 'rubygems-tasks',     '~> 0.1'
+  gem 'rspec',              '~> 2.8'
 
-  gem 'ore-tasks',	    '~> 0.4'
-  gem 'rspec',          '~> 2.8'
+  gem 'ripl',               '~> 0.3'
+  gem 'ripl-multi_line',    '~> 0.2'
+  gem 'ripl-auto_indent',   '~> 0.1'
+  gem 'ripl-color_result',  '~> 0.3'
 
-  gem 'kramdown',       '~> 0.12'
+  gem 'kramdown',           '~> 0.12'
 end
 
 group :test do
-  gem 'i18n',           '~> 0.4'
-  gem 'tzinfo',         '~> 0.3'
-
-  INFLECTORS = {
-    'activesupport' => '~> 3.0',
-    'dm-core'       => '~> 1.0',
-    'extlib'        => '~> 0.9'
-  }
-
-  inflector = ENV.fetch('INFLECTOR','dm-core')
-  gem(inflector,INFLECTORS[inflector])
+  case ENV['INFLECTOR']
+  when 'activesupport'
+    gem 'i18n',           '~> 0.4'
+    gem 'tzinfo',         '~> 0.3.0'
+    gem 'activesupport',  '~> 3.0.0'
+  else
+    gem 'dm-core',        '~> 1.0'
+  end
 end

data/README.md

@@ -1,8 +1,8 @@
 # Ronin Support
 
-* [Source](https://github.com/ronin-ruby/ronin-support)
-* [Issues](https://github.com/ronin-ruby/ronin-support/issues)
-* [Documentation](http://ronin-ruby.github.com/docs/ronin-support/frames)
+* [Source](http://github.com/ronin-ruby/ronin-support)
+* [Issues](http://github.com/ronin-ruby/ronin-support/issues)
+* [Documentation](http://rubydoc.info/gems/ronin-support/frames)
 * [Mailing List](http://groups.google.com/group/ronin-ruby)
 * [irc.freenode.net #ronin](http://webchat.freenode.net/?channels=ronin&uio=Mj10cnVldd)
 
@@ -31,7 +31,6 @@ or payloads over many common Source-Code-Management (SCM) systems.
     * DNS
     * TCP
     * UDP
-    * SSL
     * SMTP / ESMTP
     * POP3
     * Imap
@@ -58,17 +57,17 @@ please see [Everyday Ronin](http://ronin-ruby.github.com/guides/everyday_ronin.h
 ## Requirements
 
 * [Ruby](http://www.ruby-lang.org/) >= 1.8.7
-* [chars](https://github.com/postmodern/chars#readme)
+* [chars](http://github.com/postmodern/chars#readme)
   ~> 0.2
-* [hexdump](https://github.com/postmodern/hexdump#readme)
+* [hexdump](http://github.com/postmodern/hexdump#readme)
   ~> 0.1
-* [combinatorics](https://github.com/postmodern/combinatorics#readme)
+* [combinatorics](http://github.com/postmodern/combinatorics#readme)
   ~> 0.4
-* [uri-query_params](https://github.com/postmodern/uri-query_params#readme)
+* [uri-query_params](http://github.com/postmodern/uri-query_params#readme)
   ~> 0.6
-* [data_paths](https://github.com/postmodern/data_paths#readme)
+* [data_paths](http://github.com/postmodern/data_paths#readme)
   ~> 0.3
-* [parameters](https://github.com/postmodern/parameters#readme)
+* [parameters](http://github.com/postmodern/parameters#readme)
   ~> 0.4
 
 ## Install

data/Rakefile

@@ -18,8 +18,16 @@ end
 
 require 'rake'
 
-require 'ore/tasks'
-Ore::Tasks.new
+require 'rubygems/tasks'
+Gem::Tasks.new(:sign => {:checksum => true, :pgp => true}) do |tasks|
+  tasks.scm.tag.format  = 'v%s'
+  tasks.console.command = 'ripl'
+  tasks.console.options = %w[
+    -rripl/multi_line
+    -rripl/auto_indent
+    -rripl/color_result
+  ]
+end
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new

data/gemspec.yml

@@ -22,5 +22,5 @@ dependencies:
 
 development_dependencies:
   bundler: ~> 1.0
-  yard: ~> 0.7
+  yard: ~> 0.8
   yard-parameters: ~> 0.1

data/lib/ronin/binary.rb

@@ -0,0 +1,21 @@
+#
+# 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 'ronin/binary/template'
+require 'ronin/binary/struct'

data/lib/ronin/binary/hexdump.rb

@@ -0,0 +1,20 @@
+#
+# 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 'ronin/binary/hexdump/parser'

data/lib/ronin/binary/hexdump/parser.rb

@@ -0,0 +1,411 @@
+#
+# 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 'chars'
+
+module Ronin
+  module Binary
+    module Hexdump
+      #
+      # @since 0.5.0
+      #
+      # @api semipublic
+      #
+      class Parser
+
+        # Bases for various encodings
+        BASES = {
+          :binary         => 2,
+          :octal          => 8,
+          :octal_bytes    => 8,
+          :octal_shorts   => 8,
+          :octal_ints     => 8,
+          :octal_quads    => 8,
+          :decimal        => 10,
+          :decimal_bytes  => 10,
+          :decimal_shorts => 10,
+          :decimal_ints   => 10,
+          :decimal_quads  => 10,
+          :hex            => 16,
+          :hex_bytes      => 16,
+          :hex_shorts     => 16,
+          :hex_ints       => 16,
+          :hex_quads      => 16,
+          :named_chars    => 16,
+          :floats         => 10,
+          :doubles        => 10
+        }
+
+        # Word-sizes for various encodings
+        WORD_SIZES = {
+          :binary         => 1,
+          :octal_bytes    => 1,
+          :decimal_bytes  => 1,
+          :hex_bytes      => 1,
+          :hex_chars      => 1,
+          :named_chars    => 1,
+          :octal_shorts   => 2,
+          :decimal_shorts => 2,
+          :hex_shorts     => 2,
+          :octal_ints     => 4,
+          :decimal_ints   => 4,
+          :hex_ints       => 4,
+          :octal_quads    => 8,
+          :decimal_quads  => 8,
+          :hex_quads      => 8,
+          :floats         => 4,
+          :doubles        => 8
+        }
+
+        # The format to parse (`:hexdump` / `:od`)
+        attr_reader :format
+
+        # The encoding of the hexdump data
+        attr_reader :encoding
+
+        # The type of data to parse (`:integer` / `:float`)
+        attr_reader :type
+
+        # The endianness of data to parse (`:little`, `:big`, `:network`)
+        attr_reader :endian
+
+        # The size of words to parse
+        attr_reader :word_size
+
+        # The base of all addresses to parse
+        attr_reader :address_base
+
+        # The base of all words to parse
+        attr_reader :base
+
+        #
+        # Initializes the hexdump parser.
+        #
+        # @param [Hash] options
+        #   Additional options.
+        #
+        # @option options [Symbol] :format
+        #   The expected format of the hexdump. Must be either `:od` or
+        #   `:hexdump`.
+        #
+        # @option options [Symbol] :encoding
+        #   Denotes the encoding used for the bytes within the hexdump.
+        #   Must be one of the following:
+        #
+        #   * `:binary`
+        #   * `:octal`
+        #   * `:octal_bytes`
+        #   * `:octal_shorts`
+        #   * `:octal_ints`
+        #   * `:octal_quads` (Ruby 1.9 only)
+        #   * `:decimal`
+        #   * `:decimal_bytes`
+        #   * `:decimal_shorts`
+        #   * `:decimal_ints`
+        #   * `:decimal_quads` (Ruby 1.9 only)
+        #   * `:hex`
+        #   * `:hex_chars`
+        #   * `:hex_bytes`
+        #   * `:hex_shorts`
+        #   * `:hex_ints`
+        #   * `:hex_quads` (Ruby 1.9 only)
+        #   * `:named_chars`
+        #   * `:floats`
+        #   * `:doubles`
+        #
+        # @option options [:little, :big, :network] :endian (:little)
+        #   The endianness of the words.
+        #
+        def initialize(options={})
+          @format   = options[:format]
+          @encoding = options[:encoding]
+
+          @type = case @encoding
+                  when :floats, :doubles
+                    :float
+                  else
+                    :integer
+                  end
+          @endian = options.fetch(:endian,:little)
+
+          case @format
+          when :od
+            @address_base = 8
+            @base         = 8
+            @word_size    = 2
+          when :hexdump
+            @address_base = 16
+            @base         = 16
+            @word_size    = 2
+          else
+            @address_base = 16
+            @base         = 16
+            @word_size    = 1
+          end
+
+          if @encoding
+            @base      = BASES.fetch(options[:encoding])
+            @word_size = WORD_SIZES.fetch(options[:encoding])
+          end
+
+          case @encoding
+          when :hex_chars
+            @chars = CHARS.merge(ESCAPED_CHARS)
+          when :named_chars
+            @chars = CHARS.merge(NAMED_CHARS)
+          end
+        end
+
+        #
+        # Parses a hexdump.
+        #
+        # @param [#each_line] hexdump
+        #   The hexdump output.
+        #
+        # @return [String]
+        #   The raw-data from the hexdump.
+        #
+        def parse(hexdump)
+          current_addr = last_addr = first_addr = nil
+          repeated = false
+
+          segment = ''
+          buffer  = ''
+
+          hexdump.each_line do |line|
+            if @format == :hexdump
+              line = line.gsub(/\s+\|.+\|\s*$/,'')
+            end
+
+            words = line.split
+
+            if words.first == '*'
+              repeated = true
+            elsif words.length > 0
+              current_addr = parse_address(words.shift)
+              first_addr ||= current_addr
+
+              if repeated
+                (((current_addr - last_addr) / segment.length) - 1).times do
+                  buffer << segment
+                end
+
+                repeated = false
+              end
+
+              segment = pack(words.map { |word| parse_word(word) })
+
+              buffer   << segment
+              last_addr = current_addr
+            end
+          end
+
+          return buffer[0,last_addr - first_addr]
+        end
+
+        protected
+
+        # Visible characters
+        CHARS = Hash[Chars::VISIBLE.chars.sort.zip(Chars::VISIBLE.bytes.sort)]
+
+        # Escaped characters
+        ESCAPED_CHARS = {
+          '\0' => 0x00,
+          '\a' => 0x07,
+          '\b' => 0x08,
+          '\t' => 0x09,
+          '\n' => 0x0a,
+          '\v' => 0x0b,
+          '\f' => 0x0c,
+          '\r' => 0x0d
+        }
+
+        # od named characters
+        NAMED_CHARS = {
+          'nul' => 0x00,
+          'soh' => 0x01,
+          'stx' => 0x02,
+          'etx' => 0x03,
+          'eot' => 0x04,
+          'enq' => 0x05,
+          'ack' => 0x06,
+          'bel' => 0x07,
+          'bs'  => 0x08,
+          'ht'  => 0x09,
+          'lf'  => 0x0a,
+          'nl'  => 0x0a,
+          'vt'  => 0x0b,
+          'ff'  => 0x0c,
+          'cr'  => 0x0d,
+          'so'  => 0x0e,
+          'si'  => 0x0f,
+          'dle' => 0x10,
+          'dc1' => 0x11,
+          'dc2' => 0x12,
+          'dc3' => 0x13,
+          'dc4' => 0x14,
+          'nak' => 0x15,
+          'syn' => 0x16,
+          'etb' => 0x17,
+          'can' => 0x18,
+          'em'  => 0x19,
+          'sub' => 0x1a,
+          'esc' => 0x1b,
+          'fs'  => 0x1c,
+          'gs'  => 0x1d,
+          'rs'  => 0x1e,
+          'us'  => 0x1f,
+          'sp'  => 0x20,
+          'del' => 0x7f
+        }
+
+        # `Array#pack` codes for various types/endianness/word-sizes
+        FORMATS = {
+          :integer => {
+            :little => {
+              1 => 'C',
+              2 => (RUBY_VERSION > '1.9.' ? 'S<' : 'v'),
+              4 => (RUBY_VERSION > '1.9.' ? 'L<' : 'V'),
+              8 => 'Q<' # Ruby 1.9 only
+            },
+
+            :big => {
+              1 => 'C',
+              2 => (RUBY_VERSION > '1.9.' ? 'S>' : 'n'),
+              4 => (RUBY_VERSION > '1.9.' ? 'L>' : 'N'),
+              8 => 'Q>' # Ruby 1.9 only
+            }
+          },
+
+          :float => {
+            :little => {
+              4 => 'e',
+              8 => 'E'
+            },
+
+            :big => {
+              4 => 'g',
+              8 => 'G'
+            }
+          }
+        }
+
+        # alias network endianness to big endian
+        FORMATS[:integer][:network] = FORMATS[:integer][:big]
+        FORMATS[:float][:network]   = FORMATS[:float][:big]
+
+        #
+        # Parses an address.
+        #
+        # @param [String] address
+        #   The text of the address.
+        #
+        # @return [Integer]
+        #   The parsed address.
+        #
+        # @api private
+        #   
+        def parse_address(address)
+          address.to_i(@address_base)
+        end
+
+        #
+        # Parses a character or hex-byte.
+        #
+        # @param [String] char
+        #   The character to parse.
+        #
+        # @return [Integer]
+        #   The parsed byte.
+        #
+        def parse_char(char)
+          @chars.fetch(char) do |hex_byte|
+            hex_byte.to_i(16)
+          end
+        end
+
+        #
+        # Parses an Integer.
+        #
+        # @param [String] int
+        #   The text of the Integer.
+        #
+        # @return [Integer]
+        #   The parsed word.
+        #
+        # @api private
+        #   
+        def parse_int(int)
+          if @chars
+            parse_char(int)
+          else
+            int.to_i(@base)
+          end
+        end
+
+        #
+        # Parses a float.
+        #
+        # @param [String] float
+        #   The text of the float.
+        #
+        # @return [Float]
+        #   The parsed float.
+        #
+        def parse_float(float)
+          float.to_f
+        end
+
+        #
+        # Parses a word within a segment.
+        #
+        # @param [String] word
+        #   The word to parse.
+        #
+        # @return [Integer, Float]
+        #   The value of the word.
+        #  
+        def parse_word(word)
+          case @type
+          when :integer
+            parse_int(word)
+          when :float
+            parse_float(word)
+          end
+        end
+
+        #
+        # Packs a segment back into bytes.
+        #
+        # @param [Array<Integer, Float>] values
+        #   A segment of words.
+        #
+        # @return [String]
+        #   The packed segment.
+        #
+        # @api private
+        #   
+        def pack(values)
+          values.pack(FORMATS[@type][@endian][@word_size] * values.length)
+        end
+
+      end
+    end
+  end
+end