ronin-support 0.5.1 → 1.0.0.beta1

data/lib/ronin/support/binary/ctypes/array_object_type.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# 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/support/binary/ctypes/object_type'
+require 'ronin/support/binary/ctypes/array_type'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        #
+        # Represents a {Binary::Array} in memory.
+        #
+        # @api private
+        #
+        # @since 1.0.0
+        #
+        class ArrayObjectType < ObjectType
+
+          # The type used for packing literal {::Array} values.
+          #
+          # @return [ArrayType]
+          attr_reader :array_type
+
+          #
+          # Initializes the memory-mapped array type.
+          #
+          # @param [ArrayType] array_type
+          #   The array type.
+          #
+          def initialize(array_type)
+            @array_type = array_type
+
+            super(@array_type.size)
+          end
+
+          #
+          # The type of the element in the memory-mapped array type.
+          #
+          # @return [Type]
+          #
+          def type
+            @array_type.type
+          end
+
+          #
+          # The number of elements in the memory-mapped array type.
+          #
+          # @return [Integer]
+          #
+          def length
+            @array_type.length
+          end
+
+          #
+          # The alignment, in bytes, of the memory-mapped array type.
+          #
+          # @return [Integer]
+          #
+          def alignment
+            @array_type.alignment
+          end
+
+          #
+          # Creates a copy of the array object type with a different
+          # {#alignment}.
+          #
+          # @param [Integer] new_alignment
+          #   The new alignment for the new array object type.
+          #
+          # @return [ArrayObjectType]
+          #   The new array object type.
+          #
+          def align(new_alignment)
+            self.class.new(@array_type.align(new_alignment))
+          end
+
+          #
+          # Packs the memory-mapped array.
+          #
+          # @param [Binary::Array, ::Array] array
+          #   The memory-mapped array.
+          #
+          # @return [String]
+          #   The underlying binary data for the memory object.
+          #
+          # @raise [ArgumentError]
+          #   The given value was not a {Binary::Array} or {::Array}.
+          #
+          def pack(array)
+            case array
+            when Binary::Array
+              array.to_s
+            when ::Array
+              @array_type.pack(array)
+            else
+              raise(ArgumentError,"value must be either a #{Binary::Array} or an #{::Array}: #{array.inspect}")
+            end
+          end
+
+          #
+          # Unpacks the memory-mapped array.
+          #
+          # @param [String] data
+          #   The raw binary data to unpack.
+          #
+          # @return [Binary::Array]
+          #   the memory-mapped Array.
+          #
+          def unpack(data)
+            Binary::Array.new(@array_type.type,data)
+          end
+
+          #
+          # Enqueues the memory-mapped array into the list of values.
+          #
+          # @param [Binary::Array, ::Array] values
+          #   The flat array of values.
+          #
+          # @param [Binary::Array, ::Array] array
+          #   The memory-mapped array object to enqueue.
+          #
+          def enqueue_value(values,array)
+            case array
+            when Binary::Array
+              values.push(array.to_s)
+            when ::Array
+              values.push(@array_type.pack(array))
+            end
+          end
+
+          #
+          # Dequeues a memory object from the flat list of values.
+          #
+          # @param [::Array] values
+          #   The flat array of values.
+          #
+          # @return [Binary::Array]
+          #   The dequeued memory-mapped array object.
+          #
+          def dequeue_value(values)
+            Binary::Array.new(@array_type.type,values.shift)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/binary/ctypes/array_type.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# 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/support/binary/ctypes/aggregate_type'
+require 'ronin/support/binary/ctypes/unbounded_array_type'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        #
+        # Represents a bounded array type.
+        #
+        # @api private
+        #
+        # @since 1.0.0
+        #
+        class ArrayType < AggregateType
+
+          # The type of each element in the array type.
+          #
+          # @return [Type]
+          attr_reader :type
+
+          # The length of the array type.
+          #
+          # @return [Integer]
+          attr_reader :length
+
+          # The size of the array type.
+          #
+          # @return [Integer]
+          attr_reader :size
+
+          #
+          # Initializes the array type.
+          #
+          # @param [Type] type
+          #   The type of each element in the array type.
+          #
+          # @param [Integer] length
+          #   The length of the array type.
+          #
+          # @param [Integer, nil] alignment
+          #   Custom type alignment to override the type's alignment.
+          #
+          def initialize(type,length, alignment: nil)
+            if type.class == UnboundedArrayType
+              raise(ArgumentError,"cannot initialize an #{self.class} of #{UnboundedArrayType}")
+            end
+
+            @type   = type
+            @length = length
+
+            @size      = @type.size * @length
+            @alignment = alignment
+
+            super(
+              pack_string: if @type.pack_string
+                             @type.pack_string * @length
+                           end
+            )
+          end
+
+          #
+          # Initializes an Array of uninitialized values.
+          #
+          # @return [::Array]
+          #
+          def uninitialized_value
+            ::Array.new(@length) { @type.uninitialized_value }
+          end
+
+          #
+          # The endianness of each element in the bounded array type.
+          #
+          # @return [:little, :big, nil]
+          #   Indicates whether each element is little-endian, big-endian,
+          #   or `nil` if each element has no endianness.
+          #
+          def endian
+            @type.endian
+          end
+
+          #
+          # The alignment, in bytes, for the array type.
+          #
+          # @return [Integer]
+          #
+          def alignment
+            @alignment || @type.alignment
+          end
+
+          #
+          # Creates a copy of the array type with a different {#alignment}.
+          #
+          # @param [Integer] new_alignment
+          #   The new alignment for the new array type.
+          #
+          # @return [ScalarType]
+          #   The new array type.
+          #
+          def align(new_alignment)
+            self.class.new(@type,@length, alignment: new_alignment)
+          end
+
+          #
+          # Indicates whether each element is signed.
+          #
+          # @return [Boolean]
+          #
+          def signed?
+            @type.signed?
+          end
+
+          #
+          # Indicates whether each element is unsigned.
+          #
+          # @return [Boolean]
+          #
+          def unsigned?
+            @type.unsigned?
+          end
+
+          #
+          # Packs an array of values into the type's binary format.
+          #
+          # @param [::Array<Integer, Float, String>] array
+          #   The array to pack.
+          #
+          # @return [String]
+          #   The packed binary data.
+          #
+          # @api public
+          #
+          def pack(array)
+            if @pack_string
+              super(array)
+            else
+              buffer = String.new("", encoding: Encoding::ASCII_8BIT)
+
+              @length.times do |index|
+                value = array[index] || @type.uninitialized_value
+
+                buffer << @type.pack(value)
+              end
+
+              return buffer
+            end
+          end
+
+          #
+          # Unpacks an array of binary data.
+          #
+          # @param [String] data
+          #   The binary data to unpack.
+          #
+          # @return [::Array<Integer, Float, String, nil>]
+          #   The unpacked array.
+          #
+          # @api public
+          #
+          def unpack(data)
+            if @pack_string
+              super(data)
+            else
+              type_size = @type.size
+
+              ::Array.new(@length) do |index|
+                offset = index * type_size
+
+                @type.unpack(data.byteslice(offset,type_size))
+              end
+            end
+          end
+
+          #
+          # Enqueues an array of values onto the flat list of values.
+          #
+          # @param [::Array] values
+          #   The flat array of values.
+          #
+          # @param [::Array] array
+          #   The array to enqueue.
+          #
+          # @api private
+          #
+          def enqueue_value(values,array)
+            @length.times do |index|
+              value = array[index] || @type.uninitialized_value
+
+              @type.enqueue_value(values,value)
+            end
+          end
+
+          #
+          # Dequeues an array from the flat list of values.
+          #
+          # @param [::Array] values
+          #   The flat array of values.
+          #
+          # @return [::Array]
+          #   The dequeued array.
+          #
+          # @api private
+          #
+          def dequeue_value(values)
+            ::Array.new(@length) do
+              @type.dequeue_value(values)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/binary/ctypes/big_endian.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# 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/support/binary/ctypes/int8_type'
+require 'ronin/support/binary/ctypes/int16_type'
+require 'ronin/support/binary/ctypes/int32_type'
+require 'ronin/support/binary/ctypes/int64_type'
+require 'ronin/support/binary/ctypes/uint8_type'
+require 'ronin/support/binary/ctypes/uint16_type'
+require 'ronin/support/binary/ctypes/uint32_type'
+require 'ronin/support/binary/ctypes/uint64_type'
+require 'ronin/support/binary/ctypes/float32_type'
+require 'ronin/support/binary/ctypes/float64_type'
+require 'ronin/support/binary/ctypes/char_types'
+require 'ronin/support/binary/ctypes/native'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        module BigEndian
+          include CharTypes
+
+          # The size of a native pointer in bytes.
+          #
+          # @return [4, 8]
+          ADDRESS_SIZE = Native::ADDRESS_SIZE
+
+          # The `int8_t` type.
+          INT8 = Int8Type.new
+
+          # The `int16_t` type (big-endianness).
+          INT16 = Int16Type.new(endian: :big, pack_string: 's>')
+
+          # The `int32_t` type (big-endianness).
+          INT32 = Int32Type.new(endian: :big, pack_string: 'l>')
+
+          # The `int64_t` type (big-endianness).
+          INT64 = Int64Type.new(endian: :big, pack_string: 'q>')
+
+          # The `short` type.
+          SHORT = INT16
+
+          # The `int` type.
+          INT = INT32
+
+          # The `long` type.
+          LONG = if ADDRESS_SIZE == 8 then INT64
+                 else                      INT32
+                 end
+
+          # The `long long` type.
+          LONG_LONG = INT64
+
+          # The `uint8_t` type.
+          UINT8 = UInt8Type.new
+
+          # The `uint16_t` type (big-endianness).
+          UINT16 = UInt16Type.new(endian: :big, pack_string: 'S>')
+
+          # The `uint32_t` type (big-endianness).
+          UINT32 = UInt32Type.new(endian: :big, pack_string: 'L>')
+
+          # The `uint64_t` type (big-endianness).
+          UINT64 = UInt64Type.new(endian: :big, pack_string: 'Q>')
+
+          # The `byte` type.
+          BYTE = UINT8
+
+          # The `unsigned short` type.
+          USHORT = UINT16
+
+          # The `unsigned int` type.
+          UINT = UINT32
+
+          # The `unsigned long` type.
+          ULONG = if ADDRESS_SIZE == 8 then UINT64
+                  else                      UINT32
+                  end
+
+          # The `unsigned long long` type.
+          ULONG_LONG = UINT64
+
+          # The "word" type (16-bit big-endian unsigned integer).
+          WORD = UINT16
+
+          # The "dword" type (32-bit big-endian unsigned integer).
+          DWORD = UINT32
+
+          # The "qword" type (64-bit big-endian unsigned integer).
+          QWORD = UINT64
+
+          # The "machine word" type.
+          #
+          # @return [UINT64, UINT32]
+          #   {UINT64} on 64-bit systems and {UINT32} on 32-bit systems.
+          MACHINE_WORD = if ADDRESS_SIZE == 8 then UINT64
+                         else                      UINT32
+                         end
+
+          # The `void *` type.
+          POINTER = MACHINE_WORD
+
+          # The `float` type (big-endianness).
+          FLOAT32 = Float32Type.new(endian: :big, pack_string: 'g')
+
+          # The `float` type (big-endianness).
+          FLOAT = FLOAT32
+
+          # The `double` type (big-endianness).
+          FLOAT64 = Float64Type.new(endian: :big, pack_string: 'G')
+
+          # The `double` type (big-endianness).
+          DOUBLE = FLOAT64
+
+          # The big-endian types.
+          TYPES = {
+            int8:  INT8,
+            int16: INT16,
+            int32: INT32,
+            int64: INT64,
+
+            short:     SHORT,
+            int:       INT,
+            long:      LONG,
+            long_long: LONG_LONG,
+
+            uint8:  UINT8,
+            uint16: UINT16,
+            uint32: UINT32,
+            uint64: UINT64,
+
+            byte:       BYTE,
+            ushort:     USHORT,
+            uint:       UINT,
+            ulong:      ULONG,
+            ulong_long: ULONG_LONG,
+
+            word:  WORD,
+            dword: DWORD,
+            qword: QWORD,
+
+            machine_word: MACHINE_WORD,
+            pointer:      MACHINE_WORD,
+
+            float32: FLOAT32,
+            float64: FLOAT64,
+
+            float:   FLOAT,
+            double:  DOUBLE,
+
+            char:  CHAR,
+            uchar: UCHAR,
+
+            cstring: STRING,
+            string:  STRING
+          }
+
+          #
+          # Fetches the type from {TYPES}.
+          #
+          # @param [Symbol] name
+          #   The type name to lookup.
+          #
+          # @return [Type]
+          #   The type object from {TYPES}.
+          #
+          # @raise [ArgumentError]
+          #   The type name was unknown.
+          #
+          def self.[](name)
+            TYPES.fetch(name) do
+              raise(ArgumentError,"unknown type: #{name.inspect}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/binary/ctypes/char_type.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# 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/support/binary/ctypes/scalar_type'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        #
+        # Base class for all character types.
+        #
+        class CharType < ScalarType
+
+          #
+          # Initializes the character type.
+          #
+          # @param [Hash{Symbol => Object}] kwargs
+          #   Additional keyword arguments for {Type#initialize}.
+          #
+          # @option kwargs [Boolean] :signed
+          #   Indicates whether the character type is signed or unsigned.
+          #
+          # @option kwargs [String] :pack_string
+          #   The String for `Array#pack` or `String#unpack`.
+          #
+          def initialize(**kwargs)
+            super(size: 1, endian: nil, **kwargs)
+          end
+
+          #
+          # The default uniniitalized char value.
+          #
+          # @return ['']
+          #
+          def uninitialized_value
+            ''
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/binary/ctypes/char_types.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+#
+# Copyright (c) 2006-2022 Hal Brodigan (postmodern.mod3 at gmail.com)
+#
+# 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/support/binary/ctypes/char_type'
+require 'ronin/support/binary/ctypes/string_type'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        module CharTypes
+          # The `char` type.
+          CHAR = CharType.new(signed: true, pack_string: 'Z')
+
+          # The `unsigned char` type.
+          UCHAR = CharType.new(signed: false, pack_string: 'a')
+
+          # The null-terminated C string type.
+          STRING = StringType.new
+        end
+      end
+    end
+  end
+end