ronin-support 0.4.1 → 0.5.2

data/gemspec.yml

@@ -1,18 +1,27 @@
 name: ronin-support
-summary: A support library for Ronin.
-description:
-  Ronin Support is a support library for Ronin. Ronin Support contains many
+summary: A support library for ronin-rb.
+description: |
+  ronin-support is a support library for ronin-rb. ronin-support contains many
   of the convenience methods used by Ronin and additional libraries.
 
-license: LGPL-3
+  It's like activesupport, but for hacking!
+
+license: LGPL-3.0
 authors: Postmodern
 email: postmodern.mod3@gmail.com
-homepage: http://github.com/ronin-ruby/ronin-support
+homepage: https://ronin-rb.dev
 has_yard: true
 
+metadata:
+  documentation_uri: https://ronin-rb.dev/docs/ronin-support/frames
+  source_code_uri:   https://github.com/ronin-rb/ronin-support
+  bug_tracker_uri:   https://github.com/ronin-rb/ronin-support/issues
+  changelog_uri:     https://github.com/ronin-rb/ronin-support/blob/master/ChangeLog.md
+
 required_ruby_version: ">= 1.8.7"
 
 dependencies:
+  net-telnet: ~> 0.1
   chars: ~> 0.2
   hexdump: ~> 0.1
   combinatorics: ~> 0.4
@@ -21,6 +30,6 @@ dependencies:
   parameters: ~> 0.4
 
 development_dependencies:
-  bundler: ~> 1.0
-  yard: ~> 0.7
+  bundler: ~> 2.0
+  yard: ~> 0.9
   yard-parameters: ~> 0.1

data/lib/ronin/binary.rb

@@ -0,0 +1,21 @@
+#
+# Copyright (c) 2006-2021 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 <https://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-2021 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 <https://www.gnu.org/licenses/>.
+#
+
+require 'ronin/binary/hexdump/parser'

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

@@ -0,0 +1,403 @@
+#
+# Copyright (c) 2006-2021 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 <https://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 then :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
+
+          @chars = case @encoding
+                   when :hex_chars   then CHARS.merge(ESCAPED_CHARS)
+                   when :named_chars then 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 then 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 then parse_int(word)
+          when :float   then 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