ronin-support 0.5.2 → 1.0.0.beta2

data/lib/ronin/support/binary/ctypes/little_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 LittleEndian
+          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 (little-endianness).
+          INT16 = Int16Type.new(endian: :little, pack_string: 's<')
+
+          # The `int32_t` type (little-endianness).
+          INT32 = Int32Type.new(endian: :little, pack_string: 'l<')
+
+          # The `int64_t` type (little-endianness).
+          INT64 = Int64Type.new(endian: :little, 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 `byte` type.
+          BYTE = UINT8
+
+          # The `uint16_t` type (little-endianness).
+          UINT16 = UInt16Type.new(endian: :little, pack_string: 'S<')
+
+          # The `uint32_t` type (little-endianness).
+          UINT32 = UInt32Type.new(endian: :little, pack_string: 'L<')
+
+          # The `uint64_t` type (little-endianness).
+          UINT64 = UInt64Type.new(endian: :little, pack_string: 'Q<')
+
+          # 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 little-endian unsigned integer).
+          WORD = UINT16
+
+          # The "dword" type (32-bit little-endian unsigned integer).
+          DWORD = UINT32
+
+          # The "qword" type (64-bit little-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 (little-endianness).
+          FLOAT32 = Float32Type.new(endian: :little, pack_string: 'e')
+
+          # The `float` type (little-endianness).
+          FLOAT = FLOAT32
+
+          # The `double` type (little-endianness).
+          FLOAT64 = Float64Type.new(endian: :little, pack_string: 'E')
+
+          # The `double` type (little-endianness).
+          DOUBLE = FLOAT64
+
+          # The little-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/mixin.rb

@@ -0,0 +1,135 @@
+# 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'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        #
+        # Adds a type system that can be used by {Memory} objects.
+        #
+        # @api semipublic
+        #
+        module Mixin
+          # The endianness of the binary format.
+          #
+          # @return [:little, :big, :net, nil]
+          #
+          # @api public
+          attr_reader :endian
+
+          # The desired architecture of the binary format.
+          #
+          # @return [:x86, :x86_64, :ppc, :ppc64, :arm, :arm_be, :arm64,
+          #          :arm64_be, :mips, :mips_le, :mips64, :mips64_le, nil]
+          #
+          # @api public
+          attr_reader :arch
+
+          # The desired Operating System (OS) of the binary format.
+          #
+          # @return [:linux, :macos, :windows,
+          #          :bsd, :freebsd, :openbsd, :netbsd, nil]
+          #
+          # @api public
+          attr_reader :os
+
+          # The type system module or object to lookup type names in.
+          #
+          # @return [Native, LittleEndian, BigEndian, Network,
+          #          Arch::ARM, Arch::ARM::BigEndian,
+          #          Arch::ARM64, Arch::ARM64::BigEndian,
+          #          Arch::MIPS, Arch::MIPS::LittleEndian,
+          #          Arch::MIPS64, Arch::MIPS64::LittleEndian,
+          #          Arch::PPC64, Arch::PPC, Arch::X86_64, Arch::X86,
+          #          OS::FreeBSD,
+          #          OS::NetBSD,
+          #          OS::OpenBSD,
+          #          OS::Linux,
+          #          OS::MacOS,
+          #          OS::Windows]
+          #
+          # @api semipublic
+          attr_reader :type_system
+
+          # The type resolver.
+          #
+          # @return [Resolver]
+          #
+          # @api semipublic
+          attr_reader :type_resolver
+
+          protected
+
+          #
+          # Initializes the type system.
+          #
+          # @param [Native, LittleEndian, BigEndian, Network,
+          #         Arch::ARM, Arch::ARM::BigEndian,
+          #         Arch::ARM64, Arch::ARM64::BigEndian,
+          #         Arch::MIPS, Arch::MIPS::LittleEndian,
+          #         Arch::MIPS64, Arch::MIPS64::LittleEndian,
+          #         Arch::PPC64, Arch::PPC, Arch::X86_64, Arch::X86,
+          #         OS::FreeBSD,
+          #         OS::NetBSD,
+          #         OS::OpenBSD,
+          #         OS::Linux,
+          #         OS::MacOS,
+          #         OS::Windows, nil] type_system
+          #   Optional type system to use instead.
+          #
+          # @param [:little, :big, :net, nil] endian
+          #   The desired endianness to use.
+          #
+          # @param [:x86, :x86_64,
+          #         :ppc, :ppc64,
+          #         :mips, :mips_le, :mips_be,
+          #         :mips64, :mips64_le, :mips64_be,
+          #         :arm, :arm_le, :arm_be,
+          #         :arm64, :arm64_le, :arm64_be] arch
+          #   The desired architecture to use.
+          #
+          # @param [:linux, :macos, :windows,
+          #         :bsd, :freebsd, :openbsd, :netbsd] os
+          #   The Operating System (OS) to use.
+          #
+          def initialize_type_system(type_system: nil,
+                                     endian:      nil,
+                                     arch:        nil,
+                                     os:          nil)
+            @endian = endian
+            @arch   = arch
+            @os     = os
+
+            @type_system = type_system || CTypes.platform(
+                                            endian: endian,
+                                            arch:   arch,
+                                            os:     os
+                                          )
+
+            @type_resolver = CTypes::TypeResolver.new(@type_system)
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'ronin/support/binary/ctypes/type_resolver'

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

@@ -0,0 +1,205 @@
+# 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'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        module Native
+          include CharTypes
+
+          # The native endian-ness.
+          ENDIAN = if [0x1].pack('S') == [0x1].pack('S>')
+                     :big
+                   else
+                     :little
+                   end
+
+          # The size of a native pointer in bytes.
+          #
+          # @return [4, 8]
+          ADDRESS_SIZE = if RbConfig::CONFIG['host_cpu'].include?('64')
+                           8
+                         else
+                           4
+                         end
+
+          # The `int8_t` type.
+          INT8 = Int8Type.new
+
+          # The `int16_t` type (native-endianness).
+          INT16 = Int16Type.new(endian: ENDIAN, pack_string: 's')
+
+          # The `int32_t` type (native-endianness).
+          INT32 = Int32Type.new(endian: ENDIAN, pack_string: 'l')
+
+          # The `int64_t` type (native-endianness).
+          INT64 = Int64Type.new(endian: ENDIAN, 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 (native-endianness).
+          UINT16 = UInt16Type.new(endian: ENDIAN, pack_string: 'S')
+
+          # The `uint32_t` type (native-endianness).
+          UINT32 = UInt32Type.new(endian: ENDIAN, pack_string: 'L')
+
+          # The `uint64_t` type (native-endianness).
+          UINT64 = UInt64Type.new(endian: ENDIAN, 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 unsigned integer).
+          WORD = UINT16
+
+          # The "dword" type (32-bit unsigned integer).
+          DWORD = UINT32
+
+          # The "qword" type (64-bit 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 (native-endianness).
+          FLOAT32 = Float32Type.new(endian: ENDIAN, pack_string: 'f')
+
+          # The `float` type (native-endianness).
+          FLOAT = FLOAT32
+
+          # The `double` type (native-endianness).
+          FLOAT64 = Float64Type.new(endian: ENDIAN,pack_string: 'd')
+
+          # The `double` type (native-endianness).
+          DOUBLE = FLOAT64
+
+          # The native 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/network.rb

@@ -0,0 +1,29 @@
+# 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/big_endian'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        Network = BigEndian
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# 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/type'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        #
+        # Represents a object type that is memory mapped.
+        #
+        # @api private
+        #
+        # @since 1.0.0
+        #
+        class ObjectType < Type
+
+          # The size, in bytes, of the memory-mapped type.
+          #
+          # @return [Integer]
+          attr_reader :size
+
+          #
+          # Initializes the memory-mapped type.
+          #
+          # @param [Integer] size
+          #   The size, in bytes, of the memory-mapped type.
+          #
+          def initialize(size)
+            @size = size
+
+            super(pack_string: "a#{@size}")
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ronin/support/binary/ctypes/os/bsd.rb

@@ -0,0 +1,65 @@
+# 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/os/unix'
+
+module Ronin
+  module Support
+    module Binary
+      module CTypes
+        class OS
+          #
+          # Common types shared by all BSD OSes.
+          #
+          # @api private
+          #
+          # @since 1.0.0
+          #
+          class BSD < UNIX
+
+            #
+            # Initializes the FreeBSD types object.
+            #
+            # @param [#[]] types
+            #   The base types module.
+            #
+            def initialize(types)
+              super(types)
+
+              typedef :long_long,  :__int64_t
+              typedef :ulong_long, :__uint64_t
+              typedef :long_long,  :int64_t
+
+              typedef :long_long,  :quad_t
+              typedef :ulong_long, :u_quad_t
+
+              typedef :string, :caddr_t
+              typedef :uint, :fixpt_t
+              typedef :long_long, :off_t
+              typedef :pointer, :qaddr_t
+              typedef :uchar, :sa_family_t
+              typedef :int, :segsz_t
+              typedef :uint, :useconds_t
+            end
+
+          end
+        end
+      end
+    end
+  end
+end