rex-java 0.1.0

data/lib/rex/java/serialization/model/block_data.rb

@@ -0,0 +1,70 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        # This class provides a block data representation
+        class BlockData < Element
+
+          # @!attribute length
+          #   @return [Integer] the length of the block
+          attr_accessor :length
+          # @!attribute contents
+          #   @return [String] the contents of the block
+          attr_accessor :contents
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          # @param contents [String] the contents of the block
+          def initialize(stream = nil, contents = '')
+            super(stream)
+            self.contents = contents
+            self.length = contents.length
+          end
+
+          # Deserializes a Rex::Java::Serialization::Model::BlockData
+          #
+          # @param io [IO] the io to read from
+          # @return [self] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
+          def decode(io)
+            raw_length = io.read(1)
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData' if raw_length.nil?
+            self.length = raw_length.unpack('C')[0]
+
+            if length == 0
+              self.contents = ''
+            else
+              self.contents = io.read(length)
+              if contents.nil? || contents.length != length
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
+              end
+            end
+
+            self
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            contents_hex = []
+            contents.each_byte {|byte| contents_hex << "0x#{byte.to_s(16)}" }
+
+            "[ #{contents_hex.join(', ')} ]"
+          end
+
+          # Serializes the Rex::Java::Serialization::Model::BlockData
+          #
+          # @return [String]
+          def encode
+            encoded = [length].pack('C')
+            encoded << contents
+
+            encoded
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/block_data_long.rb

@@ -0,0 +1,72 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        # This class provides a block data (long) representation
+        class BlockDataLong < Element
+
+          # @!attribute length
+          #   @return [Integer] the length of the block
+          attr_accessor :length
+          # @!attribute contents
+          #   @return [String] the contents of the block
+          attr_accessor :contents
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          # @param contents [String] the contents of the block
+          def initialize(stream = nil, contents = '')
+            super(stream)
+            self.contents = contents
+            self.length = contents.length
+          end
+
+          # Deserializes a Rex::Java::Serialization::Model::BlockDataLong
+          #
+          # @param io [IO] the io to read from
+          # @return [self] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
+          def decode(io)
+            raw_length = io.read(4)
+            if raw_length.nil? || raw_length.length != 4
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockDataLong'
+            end
+            self.length = raw_length.unpack('N')[0]
+
+            if length == 0
+              self.contents = ''
+            else
+              self.contents = io.read(length)
+              if contents.nil? || contents.length != length
+                raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize BlockData'
+              end
+            end
+
+            self
+          end
+
+          # Serializes the Rex::Java::Serialization::Model::BlockDataLong
+          #
+          # @return [String]
+          def encode
+            encoded = [length].pack('N')
+            encoded << contents
+
+            encoded
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            contents_hex = []
+            contents.each_byte {|byte| contents_hex << "0x#{byte.to_s(16)}" }
+
+            "[ #{contents_hex.join(', ')} ]"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/class_desc.rb

@@ -0,0 +1,64 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        # This class provides a Java classDesc representation
+        class ClassDesc < Element
+
+          include Rex::Java::Serialization::Model::Contents
+
+          attr_accessor :description
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          def initialize(stream = nil)
+            super(stream)
+            self.description = nil
+          end
+
+          # Deserializes a Rex::Java::Serialization::Model::ClassDesc
+          #
+          # @param io [IO] the io to read from
+          # @return [self] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
+          def decode(io)
+            content = decode_content(io, stream)
+            allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
+
+            unless allowed_contents.include?(content.class)
+              raise Rex::Java::Serialization::DecodeError, 'ClassDesc unserialize failed'
+            end
+
+            self.description = content
+            self
+          end
+
+          # Serializes the Rex::Java::Serialization::Model::ClassDesc
+          #
+          # @return [String] if serialization succeeds
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
+          def encode
+            encoded = ''
+            allowed_contents = [NullReference, NewClassDesc, Reference, ProxyClassDesc]
+
+            unless allowed_contents.include?(description.class)
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize ClassDesc'
+            end
+
+            encoded << encode_content(description)
+
+            encoded
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            print_content(description)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/contents.rb

@@ -0,0 +1,163 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        module Contents
+          include Rex::Java::Serialization
+
+          # Deserializes a content
+          #
+          # @param io [IO] the io to read from
+          # @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed or unsupported content
+          def decode_content(io, stream)
+            opcode = io.read(1)
+            raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content' if opcode.nil?
+            opcode = opcode.unpack('C')[0]
+            content = nil
+
+            case opcode
+            when TC_BLOCKDATA
+              content = BlockData.decode(io, stream)
+            when TC_BLOCKDATALONG
+              content = BlockDataLong.decode(io, stream)
+            when TC_ENDBLOCKDATA
+              content = EndBlockData.decode(io, stream)
+            when TC_OBJECT
+              content = NewObject.decode(io, stream)
+            when TC_CLASS
+              content = NewClass.decode(io, stream)
+            when TC_ARRAY
+              content = NewArray.decode(io, stream)
+            when TC_STRING
+              content = Utf.decode(io, stream)
+              stream.add_reference(content) unless stream.nil?
+            when TC_LONGSTRING
+              content = LongUtf.decode(io, stream)
+              stream.add_reference(content) unless stream.nil?
+            when TC_ENUM
+              content = NewEnum.decode(io, stream)
+            when TC_CLASSDESC
+              content = NewClassDesc.decode(io, stream)
+            when TC_PROXYCLASSDESC
+              content = ProxyClassDesc.decode(io, stream)
+            when TC_REFERENCE
+              content = Reference.decode(io, stream)
+            when TC_NULL
+              content = NullReference.decode(io, stream)
+            when TC_EXCEPTION
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize unsupported TC_EXCEPTION content'
+            when TC_RESET
+              content = Reset.decode(io, stream)
+            else
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize content'
+            end
+
+            content
+          end
+
+          # Serializes a content
+          #
+          # @param content [Rex::Java::Serialization::Model::Element] the content to serialize
+          # @return [String] if serialization succeeds
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
+          def encode_content(content)
+            encoded = ''
+
+            case content
+            when BlockData
+              encoded << [TC_BLOCKDATA].pack('C')
+            when BlockDataLong
+              encoded << [TC_BLOCKDATALONG].pack('C')
+            when EndBlockData
+              encoded << [TC_ENDBLOCKDATA].pack('C')
+            when NewObject
+              encoded << [TC_OBJECT].pack('C')
+            when NewClass
+              encoded << [TC_CLASS].pack('C')
+            when NewArray
+              encoded << [TC_ARRAY].pack('C')
+            when Utf
+              encoded << [TC_STRING].pack('C')
+            when LongUtf
+              encoded << [TC_LONGSTRING].pack('C')
+            when NewEnum
+              encoded << [TC_ENUM].pack('C')
+            when NewClassDesc
+              encoded << [TC_CLASSDESC].pack('C')
+            when ProxyClassDesc
+              encoded << [TC_PROXYCLASSDESC].pack('C')
+            when NullReference
+              encoded << [TC_NULL].pack('C')
+            when Reset
+              encoded << [TC_RESET].pack('C')
+            when Reference
+              encoded << [TC_REFERENCE].pack('C')
+            else
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
+            end
+
+            encoded << content.encode
+            encoded
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @param content [Rex::Java::Serialization::Model::Element] the content to print
+          # @return [String]
+          # @raise [Rex::Java::Serialization::EncodeError] if the content is unknown
+          def print_content(content)
+            str = ''
+
+            case content
+            when BlockData
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when BlockDataLong
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when EndBlockData
+              str << "#{print_class(content)}"
+            when NewObject
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when ClassDesc
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when NewClass
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when NewArray
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when Utf
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when LongUtf
+              str << "#{print_class(content)} { #{content.to_s} } "
+            when NewEnum
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when NewClassDesc
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when ProxyClassDesc
+              str << "#{print_class(content)} { #{content.to_s} }"
+            when NullReference
+              str << "#{print_class(content)}"
+            when Reset
+              str << "#{print_class(content)}"
+            when Reference
+              str << "#{print_class(content)} { #{content.to_s} }"
+            else
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize content'
+            end
+
+            str
+          end
+
+          # Creates a print-friendly string representation of the content class
+          #
+          # @param content [Rex::Java::Serialization::Model::Element] the content
+          # @return [String]
+          def print_class(content)
+            content.class.name.split('::').last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/element.rb

@@ -0,0 +1,44 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        class Element
+
+          attr_accessor :stream
+
+          # Deserializes a Rex::Java::Serialization::Model::Element
+          #
+          # @param io [IO] the io to read from
+          # @return [Rex::Java::Serialization::Model::Element] if deserialization succeeds
+          # @return [nil] if deserialization doesn't succeed
+          def self.decode(io, stream = nil)
+            elem = self.new(stream)
+            elem.decode(io)
+          end
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          def initialize(stream = nil)
+            self.stream = stream
+          end
+
+          def decode(io)
+            self
+          end
+
+          def encode
+            ''
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            self.class.name.split('::').last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/end_block_data.rb

@@ -0,0 +1,12 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        class EndBlockData < Element
+        end
+      end
+    end
+  end
+end

data/lib/rex/java/serialization/model/field.rb

@@ -0,0 +1,173 @@
+# -*- coding: binary -*-
+
+module Rex
+  module Java
+    module Serialization
+      module Model
+        # This class provides a field description representation (fieldDesc). It's used for
+        # both primitive descriptions (primitiveDesc) and object descriptions (objectDesc).
+        class Field < Element
+
+          include Rex::Java::Serialization::Model::Contents
+
+          # @!attribute type
+          # @return [String] The type of the field.
+          attr_accessor :type
+          # @!attribute name
+          # @return [Rex::Java::Serialization::Model::Utf] The name of the field.
+          attr_accessor :name
+          # @!attribute field_type
+          # @return [Rex::Java::Serialization::Model::Utf] The type of the field on object types.
+          attr_accessor :field_type
+
+          # @param stream [Rex::Java::Serialization::Model::Stream] the stream where it belongs to
+          def initialize(stream = nil)
+            super(stream)
+            self.type = ''
+            self.name = nil
+            self.field_type = nil
+          end
+
+          # Deserializes a Rex::Java::Serialization::Model::Field
+          #
+          # @param io [IO] the io to read from
+          # @return [self] if deserialization succeeds
+          # @raise [Rex::Java::Serialization::DecodeError] if deserialization doesn't succeed
+          def decode(io)
+            code = io.read(1)
+
+            unless code && is_valid?(code)
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field'
+            end
+
+            self.type = TYPE_CODES[code]
+            self.name = Utf.decode(io, stream)
+
+            if is_object?
+              self.field_type = decode_field_type(io)
+            end
+
+            self
+          end
+
+          # Serializes the Rex::Java::Serialization::Model::Field
+          #
+          # @return [String] if serialization succeeds
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization doesn't succeed
+          def encode
+            unless name.kind_of?(Rex::Java::Serialization::Model::Utf)
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
+            end
+
+            unless is_type_valid?
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
+            end
+
+            encoded = ''
+            encoded << TYPE_CODES.key(type)
+            encoded << name.encode
+
+            if is_object?
+                encoded << encode_field_type
+            end
+
+            encoded
+          end
+
+          # Whether the field type is valid.
+          #
+          # @return [Boolean]
+          def is_type_valid?
+            if TYPE_CODES.values.include?(type)
+              return true
+            end
+
+            false
+          end
+
+          # Whether the field type is a primitive one.
+          #
+          # @return [Boolean]
+          def is_primitive?
+            if PRIMITIVE_TYPE_CODES.values.include?(type)
+              return true
+            end
+
+            false
+          end
+
+          # Whether the field type is an object one.
+          #
+          # @return [Boolean]
+          def is_object?
+            if OBJECT_TYPE_CODES.values.include?(type)
+              return true
+            end
+
+            false
+          end
+
+          # Creates a print-friendly string representation
+          #
+          # @return [String]
+          def to_s
+            str = "#{name} "
+            if is_primitive?
+              str << "(#{type})"
+            else
+              str << "(#{field_type})"
+            end
+
+            str
+          end
+
+          private
+
+          # Whether the type opcode is a valid one.
+          #
+          # @param code [String] A type opcode
+          # @return [Boolean]
+          def is_valid?(code)
+            if TYPE_CODES.keys.include?(code)
+              return true
+            end
+
+            false
+          end
+
+          # Serializes the `field_type` attribute.
+          #
+          # @return [String]
+          # @raise [Rex::Java::Serialization::EncodeError] if serialization fails
+          def encode_field_type
+            allowed_contents = [Utf, Reference]
+
+            unless allowed_contents.include?(field_type.class)
+              raise Rex::Java::Serialization::EncodeError, 'Failed to serialize Field'
+            end
+
+            encoded = encode_content(field_type)
+
+            encoded
+          end
+
+          # Deserializes the `field_type` value.
+          #
+          # @param io [IO] the io to read from
+          # @return [Java::Serialization::Model::Utf]
+          # @raise [Rex::Java::Serialization::DecodeError] if unserialization doesn't succeed
+          def decode_field_type(io)
+            allowed_contents = [Utf, Reference]
+            type = decode_content(io, stream)
+
+            unless allowed_contents.include?(type.class)
+              raise Rex::Java::Serialization::DecodeError, 'Failed to unserialize Field field_type'
+            end
+
+            type
+          end
+        end
+      end
+    end
+  end
+end