ronin-support 0.5.2 → 1.0.0.beta2

data/lib/ronin/binary/template.rb

@@ -1,454 +0,0 @@
-#
-# 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 'set'
-
-module Ronin
-  module Binary
-    #
-    # Provides a translation layer between C-types and Ruby `Array#pack`
-    # codes.
-    #
-    # ## Types
-    #
-    # * `:uint8` (`C`) - unsigned 8-bit integer.
-    # * `:uint16` (`S`) - unsigned 16-bit integer.
-    # * `:uint32` (`L`) - unsigned 32-bit integer.
-    # * `:uint64` (`Q`) - unsigned 64-bit integer.
-    # * `:int8` (`c`) - signed 8-bit integer.
-    # * `:int16` (`s`) - signed 16-bit integer.
-    # * `:int32` (`l`) - signed 32-bit integer.
-    # * `:int64` (`q`) - signed 64-bit integer.
-    # * `:uint16_le` (`v`) - unsigned 16-bit integer, little endian.
-    # * `:uint32_le` (`V`) - unsigned 32-bit integer, little endian.
-    # * `:uint16_be` (`n`) - unsigned 16-bit integer, big endian.
-    # * `:uint32_be` (`N`) - unsigned 32-bit integer, big endian.
-    # * `:uchar` (`Z`) - unsigned character.
-    # * `:ushort` (`S!`) - unsigned short integer, native endian.
-    # * `:uint` (`I!`) - unsigned integer, native endian.
-    # * `:ulong` (`L!`) - unsigned long integer, native endian.
-    # * `:ulong_long` (`Q`) - unsigned quad integer, native endian.
-    # * `:char` (`Z`) - signed character.
-    # * `:short` (`s!`) - signed short integer, native endian.
-    # * `:int` (`i!`) - signed integer, native endian.
-    # * `:long` (`l!`) - signed long integer, native endian.
-    # * `:long_long` (`q`) - signed quad integer, native endian.
-    # * `:utf8` (`U`) - UTF8 character.
-    # * `:float` (`F`) - single-precision float, native format.
-    # * `:double` (`D`) - double-precision float, native format.
-    # * `:float_le` (`e`) - single-precision float, little endian.
-    # * `:double_le` (`E`) - double-precision float, little endian.
-    # * `:float_be` (`g`) - single-precision float, big endian.
-    # * `:double_be` (`G`) - double-precision float, big endian.
-    # * `:ubyte` (`C`) - unsigned byte.
-    # * `:byte` (`c`) - signed byte.
-    # * `:string` (`Z*`) - binary String, `\0` terminated.
-    #
-    # ### Ruby 1.9 specific C-types
-    #
-    # * `:uint16_le` (`S<`) - unsigned 16-bit integer, little endian.
-    # * `:uint32_le` (`L<`) - unsigned 32-bit integer, little endian.
-    # * `:uint64_le` (`Q<`) - unsigned 64-bit integer, little endian.
-    # * `:int16_le` (`s<`) - signed 16-bit integer, little endian.
-    # * `:int32_le` (`l<`) - signed 32-bit integer, little endian.
-    # * `:int64_le` (`q<`) - signed 64-bit integer, little endian.
-    # * `:uint16_be` (`S>`) - unsigned 16-bit integer, big endian.
-    # * `:uint32_be` (`L>`) - unsigned 32-bit integer, big endian.
-    # * `:uint64_be` (`Q>`) - unsigned 64-bit integer, big endian.
-    # * `:int16_be` (`s>`) - signed 16-bit integer, big endian.
-    # * `:int32_be` (`l>`) - signed 32-bit integer, big endian.
-    # * `:int64_be` (`q>`) - signed 64-bit integer, big endian.
-    # * `:ushort_le` (`S<`) - unsigned short integer, little endian.
-    # * `:uint_le` (`I<`) - unsigned integer, little endian.
-    # * `:ulong_le` (`L<`) - unsigned long integer, little endian.
-    # * `:ulong_long_le` (`Q<`) - unsigned quad integer, little endian.
-    # * `:short_le` (`s<`) - signed short integer, little endian.
-    # * `:int_le` (`i<`) - signed integer, little endian.
-    # * `:long_le` (`l<`) - signed long integer, little endian.
-    # * `:long_long_le` (`q<`) - signed quad integer, little endian.
-    # * `:ushort_be` (`S>`) - unsigned short integer, little endian.
-    # * `:uint_be` (`I>`) - unsigned integer, little endian.
-    # * `:ulong_be` (`L>`) - unsigned long integer, little endian.
-    # * `:ulong_long_be` (`Q>`) - unsigned quad integer, little endian.
-    # * `:short_be` (`s>`) - signed short integer, little endian.
-    # * `:int_be` (`i>`) - signed integer, little endian.
-    # * `:long_be` (`l>`) - signed long integer, little endian.
-    # * `:long_long_be` (`q>`) - signed quad integer, little endian.
-    #
-    # @see https://rubydoc.info/stdlib/core/Array:pack
-    #
-    # @api semipbulic
-    #
-    # @since 0.5.0
-    #
-    class Template
-
-      # Supported C-types and corresponding `Array#pack` codes.
-      TYPES = {
-        :uint8  => 'C',
-        :uint16 => 'S',
-        :uint32 => 'L',
-        :uint64 => 'Q',
-
-        :int8   => 'c',
-        :int16  => 's',
-        :int32  => 'l',
-        :int64  => 'q',
-
-        :uint16_le => 'v',
-        :uint32_le => 'V',
-        :uint16_be => 'n',
-        :uint32_be => 'N',
-
-        :uchar      => 'Z',
-        :ushort     => 'S!',
-        :uint       => 'I!',
-        :ulong      => 'L!',
-        :ulong_long => 'Q',
-
-        :char      => 'Z',
-        :short     => 's!',
-        :int       => 'i!',
-        :long      => 'l!',
-        :long_long => 'q',
-
-        :utf8 => 'U',
-
-        :float     => 'F',
-        :double    => 'D',
-
-        :float_le  => 'e',
-        :double_le => 'E',
-
-        :float_be  => 'g',
-        :double_be => 'G',
-
-        :ubyte  => 'C',
-        :byte   => 'c',
-        :string => 'Z*'
-      }
-
-      # Additional C-types, not available on Ruby 1.8:
-      if RUBY_VERSION > '1.9.'
-        TYPES.merge!(
-          :uint16_le => 'S<',
-          :uint32_le => 'L<',
-          :uint64_le => 'Q<',
-
-          :int16_le => 's<',
-          :int32_le => 'l<',
-          :int64_le => 'q<',
-
-          :uint16_be => 'S>',
-          :uint32_be => 'L>',
-          :uint64_be => 'Q>',
-
-          :int16_be => 's>',
-          :int32_be => 'l>',
-          :int64_be => 'q>',
-
-          :ushort_le     => 'S!<',
-          :uint_le       => 'I!<',
-          :ulong_le      => 'L!<',
-          :ulong_long_le => 'Q<',
-
-          :short_le     => 's!<',
-          :int_le       => 'i!<',
-          :long_le      => 'l!<',
-          :long_long_le => 'q<',
-
-          :ushort_be     => 'S!>',
-          :uint_be       => 'I!>',
-          :ulong_be      => 'L!>',
-          :ulong_long_be => 'Q>',
-
-          :short_be     => 's!>',
-          :int_be       => 'i!>',
-          :long_be      => 'l!>',
-          :long_long_be => 'q>'
-        )
-      end
-
-      # Integer C-types
-      INT_TYPES = Set[
-        :uint8,
-        :uint16,
-        :uint32,
-        :uint64,
-
-        :int8,
-        :int16,
-        :int32,
-        :int64,
-
-        :ubyte,
-        :ushort,
-        :uint,
-        :ulong,
-        :ulong_long,
-
-        :byte,
-        :short,
-        :int,
-        :long,
-        :long_long,
-
-        :uint16_le,
-        :uint32_le,
-        :uint64_le,
-
-        :int16_le,
-        :int32_le,
-        :int64_le,
-
-        :ushort_le,
-        :uint_le,
-        :ulong_le,
-        :ulong_long_le,
-
-        :short_le,
-        :int_le,
-        :long_le,
-        :long_long_le,
-
-        :uint16_be,
-        :uint32_be,
-        :uint64_be,
-
-        :int16_be,
-        :int32_be,
-        :int64_be,
-
-        :ushort_be,
-        :uint_be,
-        :ulong_be,
-        :ulong_long_be,
-
-        :short_be,
-        :int_be,
-        :long_be,
-        :long_long_be
-      ]
-
-      # Float C-types
-      FLOAT_TYPES = Set[
-        :float,    :double,
-        :float_le, :double_le,
-        :float_be, :double_be
-      ]
-
-      # Character C-types
-      CHAR_TYPES = Set[:uchar, :char]
-
-      # String C-types
-      STRING_TYPES = CHAR_TYPES + Set[:string]
-
-      # Types which have little and big endian forms
-      ENDIAN_TYPES = Set[
-        :uint16, :uint32, :uint64,
-        :int16, :int32, :int64,
-        :ushort, :uint, :ulong, :ulong_long,
-        :short, :int, :long, :long_long,
-        :float, :double
-      ]
-
-      # The fields of the template
-      attr_reader :fields
-
-      #
-      # Creates a new Binary Template.
-      #
-      # @param [Array<type, (type, length)>] fields
-      #   The C-types which the packer will use.
-      #
-      # @param [Hash] options
-      #   Template options.
-      #
-      # @option options [:little, :big, :network] :endian
-      #   The endianness to apply to the C-types.
-      #
-      # @raise [ArgumentError]
-      #   A given type is not known.
-      #
-      # @note
-      #   The following C-types are **not supported** on Ruby 1.8:
-      #
-      #   * `:uint16_le`
-      #   * `:uint32_le`
-      #   * `:uint64_le`
-      #   * `:int16_le`
-      #   * `:int32_le`
-      #   * `:int64_le`
-      #   * `:uint16_be`
-      #   * `:uint32_be`
-      #   * `:uint64_be`
-      #   * `:int16_be`
-      #   * `:int32_be`
-      #   * `:int64_be`
-      #   * `:ushort_le`
-      #   * `:uint_le`
-      #   * `:ulong_le`
-      #   * `:ulong_long_le`
-      #   * `:short_le`
-      #   * `:int_le`
-      #   * `:long_le`
-      #   * `:long_long_le`
-      #   * `:ushort_be`
-      #   * `:uint_be`
-      #   * `:ulong_be`
-      #   * `:ulong_long_be`
-      #   * `:short_be`
-      #   * `:int_be`
-      #   * `:long_be`
-      #   * `:long_long_be`
-      #
-      # @example
-      #   Template.new(:uint32, [:char, 100])
-      #
-      def initialize(fields,options={})
-        @fields   = fields
-        @template = self.class.compile(@fields,options)
-      end
-
-      #
-      # @see #initialize
-      #
-      def self.[](*fields)
-        new(fields)
-      end
-
-      #
-      # Translates the type of the field.
-      #
-      # @param [Symbol] type
-      #   The type to translate.
-      #
-      # @param [Hash] options
-      #   Translation options.
-      #
-      # @option options [:little, :big, :network] :endian
-      #   The endianness to apply to the C-types.
-      #
-      # @return [Symbol]
-      #   The translated type.
-      #
-      # @raise [ArgumentError]
-      #   The value of `:endian` is unknown.
-      #
-      def self.translate(type,options={})
-        if (options[:endian] && ENDIAN_TYPES.include?(type))
-          type = case options[:endian]
-                 when :little        then :"#{type}_le"
-                 when :big, :network then :"#{type}_be"
-                 else
-                   raise(ArgumentError,"unknown endianness: #{type}")
-                 end
-        end
-
-        return type
-      end
-
-      #
-      # Compiles C-types into an `Array#pack` / `String#unpack`
-      # template.
-      #
-      # @param [Array<type, (type, length)>] types
-      #   The C-types which the packer will use.
-      #
-      # @param [Hash] options
-      #   Type options.
-      #
-      # @option options [:little, :big, :network] :endian
-      #   The endianness to apply to the C-types.
-      #
-      # @return [String]
-      #   The `Array#pack` / `String#unpack` template.
-      #
-      # @raise [ArgumentError]
-      #   A given type is not known.
-      #
-      def self.compile(types,options={})
-        string = ''
-
-        types.each do |(type,length)|
-          type = translate(type,options)
-
-          unless (code = TYPES[type])
-            raise(ArgumentError,"#{type.inspect} not supported")
-          end
-
-          string << code << length.to_s
-        end
-
-        return string
-      end
-
-      #
-      # Packs the data.
-      #
-      # @param [Array] data
-      #   The data to pack.
-      #
-      # @return [String]
-      #   The packed data.
-      #
-      def pack(*data)
-        data.pack(@template)
-      end
-
-      #
-      # Unpacks the string.
-      #
-      # @param [String] string
-      #   The raw String to unpack.
-      #
-      # @return [Array]
-      #   The unpacked data.
-      #
-      def unpack(string)
-        string.unpack(@template)
-      end
-
-      #
-      # Converts the template to a `Array#pack` template String.
-      #
-      # @return [String]
-      #   The template String.
-      #
-      # @see https://rubydoc.info/stdlib/core/Array:pack
-      #
-      def to_s
-        @template
-      end
-
-      #
-      # Inspects the template.
-      #
-      # @return [String]
-      #   The inspected template.
-      #
-      # @since 1.5.1
-      #
-      def inspect
-        "<#{self.class}: #{@fields.inspect}>"
-      end
-
-    end
-  end
-end

data/lib/ronin/extensions/ip_addr.rb

@@ -1,216 +0,0 @@
-#
-# 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/extensions/resolv'
-require 'ronin/extensions/regexp'
-
-require 'ipaddr'
-require 'combinatorics/list_comprehension'
-
-class IPAddr
-
-  include Enumerable
-
-  # Socket families and IP address masks
-  MASKS = {
-    Socket::AF_INET  => IN4MASK,
-    Socket::AF_INET6 => IN6MASK
-  }
-
-  #
-  # Extracts IP Addresses from text.
-  #
-  # @param [String] text
-  #   The text to scan for IP Addresses.
-  #
-  # @param [Integer, Symbol] version
-  #   The version of IP Address to scan for (`4`, `6`, `:v4` or `:v6`).
-  #
-  # @yield [ip]
-  #   The given block will be passed each extracted IP Address.
-  #
-  # @yieldparam [String] ip
-  #   An IP Address from the text.
-  #
-  # @return [Array<String>]
-  #   The IP Addresses found in the text.
-  #
-  # @example
-  #   IPAddr.extract("Host: 127.0.0.1\n\rHost: 10.1.1.1\n\r")
-  #   # => ["127.0.0.1", "10.1.1.1"]
-  #
-  # @example Extract only IPv4 addresses from a large amount of text:
-  #   IPAddr.extract(text,:v4) do |ip|
-  #     puts ip
-  #   end
-  #   
-  # @api public
-  #
-  def IPAddr.extract(text,version=nil,&block)
-    return enum_for(__method__,text,version).to_a unless block_given?
-
-    regexp = case version
-             when :ipv4, :v4, 4 then Regexp::IPv4
-             when :ipv6, :v6, 6 then Regexp::IPv6
-             else                    Regexp::IP
-             end
-
-    text.scan(regexp) do |match|
-      yield match
-    end
-
-    return nil
-  end
-
-  #
-  # Iterates over each IP address within the IP Address range. Supports
-  # both IPv4 and IPv6 address ranges.
-  #
-  # @param [String] cidr_or_glob
-  #   The IP address range to iterate over.
-  #   May be in standard CIDR notation or globbed format.
-  #
-  # @yield [ip]
-  #   The block which will be passed each IP address contained within the
-  #   IP address range.
-  #
-  # @yieldparam [String] ip
-  #   An IP address within the IP address range.
-  #
-  # @return [nil]
-  #
-  # @example Enumerate through a CIDR range
-  #   IPAddr.each('10.1.1.1/24') do |ip|
-  #     puts ip
-  #   end
-  #
-  # @example Enumerate through a globbed IP range
-  #   IPAddr.each('10.1.1-5,10-20.*') do |ip|
-  #     puts ip
-  #   end
-  #
-  # @example Enumerate through a globbed IPv6 range
-  #   IPAddr.each('::ff::02-0a::c3') do |ip|
-  #     puts ip
-  #   end
-  #
-  # @api public
-  #
-  def IPAddr.each(cidr_or_glob,&block)
-    unless (cidr_or_glob.include?('*') ||
-            cidr_or_glob.include?(',') ||
-            cidr_or_glob.include?('-'))
-      return IPAddr.new(cidr_or_glob).each(&block)
-    end
-
-    return enum_for(__method__,cidr_or_glob) unless block
-
-    if cidr_or_glob.include?('::')
-      separator = '::'
-      base      = 16
-
-      prefix = if cidr_or_glob.start_with?('::') then '::'
-               else                                   ''
-               end
-
-      format = lambda { |address|
-        prefix + address.map { |i| '%.2x' % i }.join('::')
-      }
-    else
-      separator = '.'
-      base      = 10
-      format    = lambda { |address| address.join('.') }
-    end
-
-    # split the address
-    segments = cidr_or_glob.split(separator)
-    ranges   = []
-    
-    # map the components of the address to numeric ranges
-    segments.each do |segment|
-      next if segment.empty?
-
-      ranges << if segment == '*'
-                  (1..254)
-                else
-                  segment.split(',').map { |octet|
-                    if octet.include?('-')
-                      start, stop = octet.split('-',2)
-
-                      (start.to_i(base)..stop.to_i(base)).to_a
-                    else
-                      octet.to_i(base)
-                    end
-                  }.flatten
-                end
-    end
-
-    # cycle through the address ranges
-    ranges.comprehension { |address| yield format[address] }
-    return nil
-  end
-
-  #
-  # Resolves the host-names for the IP address.
-  #
-  # @param [String] nameserver
-  #   The optional nameserver to query.
-  #
-  # @return [Array<String>]
-  #   The host-names for the IP address.
-  #
-  # @api public
-  #
-  def lookup(nameserver=nil)
-    Resolv.resolver(nameserver).getnames(self.to_s)
-  end
-
-  #
-  # Iterates over each IP address that is included in the addresses
-  # netmask. Supports both IPv4 and IPv6 addresses.
-  #
-  # @yield [ip]
-  #   The block which will be passed every IP address covered be the
-  #   netmask of the IPAddr object.
-  #
-  # @yieldparam [String] ip
-  #   An IP address.
-  #
-  # @example
-  #   netblock = IPAddr.new('10.1.1.1/24')
-  #
-  #   netblock.each do |ip|
-  #     puts ip
-  #   end
-  #
-  # @api public
-  #
-  def each
-    return enum_for(__method__) unless block_given?
-
-    family_mask = MASKS[@family]
-
-    (0..((~@mask_addr) & family_mask)).each do |i|
-      yield _to_string(@addr | i)
-    end
-
-    return self
-  end
-
-end

data/lib/ronin/extensions/meta/object.rb

@@ -1,24 +0,0 @@
-# metaprogramming assistant -- metaid.rb
-class Object # :nodoc:
-  # The hidden singleton lurks behind everyone
-  def metaclass; class << self; self; end; end
-  def meta_eval(&blk); metaclass.instance_eval(&blk); end
-
-  # A class_eval version of meta_eval
-  def metaclass_eval(&blk); metaclass.class_eval(&blk); end
-
-  # A class_def version of meta_def
-  def metaclass_def(name, &blk)
-    metaclass_eval { define_method(name, &blk) }
-  end
-  
-  # Adds methods to a metaclass
-  def meta_def(name, &blk)
-    meta_eval { define_method(name, &blk) }
-  end
-  
-  # Defines an instance method within a class
-  def class_def(name, &blk)
-    class_eval { define_method(name, &blk) }
-  end
-end